glusterd: Added glusterd command specific optional args for hooks scripts.

start volume: --first=yes if the volume is the first to be started and --first=no otherwise stop volume: --last=yes if the volume is the last to be stopped and --last=no otherwise set volume: -o key=value ... for every key, value supplied in volume set command Change-Id: Ia8530771f8b9d7424fd1c736cb4c3622b5cabec2 BUG: 806996 Signed-off-by: Krishnan Parthasarathi <kp@gluster.com> Reviewed-on: http://review.gluster.com/3260 Tested-by: Gluster Build System <jenkins@build.gluster.com> Reviewed-by: Jeff Darcy <jdarcy@redhat.com> Reviewed-by: Vijay Bellur <vijay@gluster.com>
author: Krishnan Parthasarathi <kp@gluster.com> 2012-05-02 18:38:52 +0530
committer: Vijay Bellur <vijay@gluster.com> 2012-05-03 21:26:07 -0700
commit: 5f48ad266195ec85171db48cf3dba83f98cbe728 (patch)
tree: f8a021a1e047272f2f3f546ea6c825771bbce2d5 /cli
parent: d88237faa6982c9f0beca65262a220becaacb096 (diff)
0 files changed, 0 insertions, 0 deletions
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000000..84c2efe3fad
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,107 @@
+---
+Language:        Cpp
+# BasedOnStyle:  Chromium
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: All
+AlwaysBreakAfterReturnType: All
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Linux
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories:
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+  - Regex:           '^<.*'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseLabels: true
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakAssignment: 200
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Auto
+TabWidth:        8
+UseTab:          Never
+...
diff --git a/.github/ISSUE_TEMPLATE b/.github/ISSUE_TEMPLATE
index 306b4eebc15..386ed2d8dd5 100644
--- a/.github/ISSUE_TEMPLATE
+++ b/.github/ISSUE_TEMPLATE
@@ -1,13 +1,30 @@
-This repository (glusterfs) uses github issues to track feature requests *only*.
+<!-- Please use this template while reporting an issue, providing as much information as possible. Failure to do so may result in a delayed response. Thank you! -->
 
-For assistance with bugs, please file a bug in our bugzilla instance [1]
+**Description of problem:**
 
-For other queries regarding glusterfs, please post to the users [2] or devel [3] lists as appropriate.
 
-You may further want to subscribe to these lists or view the archives for these lists, see [4] [5].
+**The exact command to reproduce the issue**:
+
+
+**The full output of the command that failed**:
+<details>
+
+
+
+</details>
+
+**Expected results:**
+
+
+**Additional info:**
+
+
+**- The output of the `gluster volume info` command**:
+<details>
+
+
+
+</details>
+
+**- The operating system / glusterfs version**:
 
-[1] glusterfs Bugzilla: https://bugzilla.redhat.com/enter_bug.cgi?product=GlusterFS
-[2] Gluster users list ID: gluster-users@gluster.org
-[3] Gluster devel list ID: gluster-devel@gluster.org
-[4] Gluster users list subscribe/view archives: https://lists.gluster.org/mailman/listinfo/gluster-users
-[5] Gluster devel list subscribe/view archives: https://lists.gluster.org/mailman/listinfo/gluster-devel
diff --git a/.github/PULL_REQUEST_TEMPLATE b/.github/PULL_REQUEST_TEMPLATE
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE
diff --git a/.github/RELEASE_TRACKER_TEMPLATE b/.github/RELEASE_TRACKER_TEMPLATE
new file mode 100644
index 00000000000..502bbd5556c
--- /dev/null
+++ b/.github/RELEASE_TRACKER_TEMPLATE
@@ -0,0 +1,12 @@
+<!-- Please use this template while creating a tracker issue -->
+
+**Description of problem:**
+A tracker issue to track the issues that will be fixed as a part of this release
+
+
+**Major or minor release**:
+
+
+**Release version**:
+
+
diff --git a/.github/stale.yml b/.github/stale.yml
new file mode 100644
index 00000000000..460e327c6ea
--- /dev/null
+++ b/.github/stale.yml
@@ -0,0 +1,25 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 210
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 15
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  Thank you for your contributions.
+
+  Noticed that this issue is not having any activity in last ~6 months! We
+  are marking this issue as stale because it has not had recent activity.
+
+  It will be closed in 2 weeks if no one responds with a comment here.
+  
+
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+  Closing this issue as there was no update since my last update on issue.
+  If this is an issue which is still valid, feel free to open it.
diff --git a/.gitignore b/.gitignore
index fc6a0b8c685..fc5ba586f8e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,7 @@ Makefile
 Makefile.in
 missing
 stamp-h1
+stamp-h2
 test-driver
 *compile
 *.gcda
@@ -28,10 +29,12 @@ test-driver
 *.patch
 .libs
 .deps
+.dirstamp
 
 # Softlinks to test and log
 log
 *.vol
+.clang-format
 
 # cmocka unit tests
 *.log
@@ -45,9 +48,7 @@ api/examples/__init__.py
 api/examples/setup.py
 api/src/gfapi.map
 cli/src/gluster
-contrib/argp-standalone/libargp.a
 contrib/fuse-util/fusermount-glusterfs
-contrib/uuid/uuid_types.h
 extras/geo-rep/gsync-sync-gfid
 extras/geo-rep/schedule_georep.py
 extras/snap_scheduler/conf.py
@@ -60,9 +61,11 @@ extras/ocf/glusterd
 extras/ocf/volume
 extras/run-gluster.tmpfiles
 extras/systemd/glusterd.service
+extras/systemd/gluster-ta-volume.service
 extras/systemd/glusterfssharedstorage.service
 extras/who-wrote-glusterfs/gitdm
 geo-replication/.tox
+geo-replication/gsyncd.conf
 geo-replication/src/gsyncd
 geo-replication/src/peer_gsec_create
 geo-replication/src/peer_mountbroker
@@ -84,17 +87,14 @@ glusterfsd/src/glusterfsd
 glusterfsd/src/gf_attach
 heal/src/glfsheal
 libgfchangelog.pc
-libgfdb.pc
 libglusterfs/src/graph.lex.c
 libglusterfs/src/y.tab.c
 libglusterfs/src/y.tab.h
 libglusterfs/src/defaults.c
-libglusterfs/src/glusterfs-fops.h
 libglusterfs/src/cli1-xdr.h
 libglusterfs/src/protocol-common.h
 libtool
 # copied XDR for cyclic libglusterfs <-> rpc-header dependency
-rpc/xdr/gen/*.x
 run-tests.sh
 !tests/basic/fuse/Makefile
 !tests/basic/gfapi/Makefile
@@ -108,14 +108,6 @@ extras/peer_add_secret_pub
 tools/gfind_missing_files/gcrawler
 tools/glusterfind/glusterfind
 tools/glusterfind/src/tool.conf
-# Generated by fdl xlator
-xlators/experimental/fdl/src/fdl.c
-xlators/experimental/fdl/src/gf_logdump
-xlators/experimental/fdl/src/gf_recon
-xlators/experimental/fdl/src/libfdl.c
-xlators/experimental/fdl/src/librecon.c
-xlators/experimental/jbr-client/src/jbrc-cg.c
-xlators/experimental/jbr-server/src/jbr-cg.c
 # Eventing
 events/src/eventsapiconf.py
 extras/systemd/glustereventsd.service
@@ -125,3 +117,9 @@ extras/init.d/glustereventsd-Debian
 extras/init.d/glustereventsd-FreeBSD
 extras/init.d/glustereventsd-Redhat
 tools/setgfid2path/src/gluster-setgfid2path
+xlators/features/cloudsync/src/cloudsync-autogen-fops.c
+xlators/features/cloudsync/src/cloudsync-autogen-fops.h
+xlators/features/utime/src/utime-autogen-fops.c
+xlators/features/utime/src/utime-autogen-fops.h
+tests/basic/metadisp/ftruncate
+xlators/features/metadisp/src/fops.c
diff --git a/.mailmap b/.mailmap
index e8e641ce174..141a1667ffa 100644
--- a/.mailmap
+++ b/.mailmap
@@ -12,6 +12,7 @@ Anush Shetty <ashetty@redhat.com> <anush@gluster.com>
 Csaba Henk <csaba@redhat.com> <csaba@gluster.com> <csaba@lowlife.hu> <csaba@zresearch.com>
 Günther Deschner <gd@redhat.com> <gd@samba.org>
 Harshavardhana <fharshav@redhat.com> <harsha@gluster.com> <harsha@zresearch.com> <harsha@dev.gluster.com> <harsha@harshavardhana.net>
+Ji-Hyeon Gim <potatogim@gluesys.com> <potatogim@potatogim.net>
 Justin Clift <justin@gluster.org> <jclift@redhat.com>
 Kaleb S. KEITHLEY <kkeithle@redhat.com> <kkeithle@f16node1.kkeithle.usersys.redhat.com> <kkeithle@linux.keithley.org>
 Kaushal M <kaushal@redhat.com> <kaushal@gluster.com>
diff --git a/.testignore b/.testignore
index 72c0b38526b..fe8f838bf2b 100644
--- a/.testignore
+++ b/.testignore
@@ -1,9 +1,14 @@
 .github/ISSUE_TEMPLATE
+.github/PULL_REQUEST_TEMPLATE
+.github/stale.yml
 .gitignore
 .mailmap
+.testignore
+.clang-format
 rfc.sh
+submit-for-review.sh
 AUTHORS
-CONTRIBUTING
+CONTRIBUTING.md
 COPYING-GPLV2
 COPYING-LGPLV3
 ChangeLog
@@ -12,16 +17,13 @@ MAINTAINERS
 NEWS
 README.md
 THANKS
+COMMITMENT
 api/examples/README
 api/examples/getvolfile.py
 api/src/README.Symbol_Versions
 build-aux/checkpatch.pl
 contrib/fuse-lib/COPYING.LIB
 contrib/fuse-util/COPYING
-contrib/ipaddr-py/COPYING
-contrib/ipaddr-py/MANIFEST.in
-contrib/ipaddr-py/OWNERS
-contrib/ipaddr-py/README
 contrib/macfuse/COPYING.txt
 doc/*
 extras/FreeBSD/README.FreeBSD
@@ -32,10 +34,8 @@ extras/cliutils/README.md
 extras/command-completion/README
 extras/create_new_xlator/README.md
 extras/glusterfs.vim
-extras/group-gluster-block
-extras/group-metadata-cache
-extras/group-nl-cache
-extras/group-virt.example
+extras/glusterfs-logrotate
+extras/glusterfs-georep-logrotate
 extras/init.d/glusterd-Debian.in
 extras/init.d/glusterd-FreeBSD.in
 extras/init.d/glusterd-Redhat.in
@@ -49,6 +49,7 @@ extras/logger.conf.example
 extras/snap_scheduler/README.md
 extras/test/ld-preload-test/README
 extras/who-wrote-glusterfs/*
+extras/distributed-testing/*
 geo-replication/syncdaemon/README.md
 geo-replication/test-requirements.txt
 rpc/xdr/src/.gitignore
diff --git a/COMMITMENT b/COMMITMENT
new file mode 100644
index 00000000000..16b75efcf29
--- /dev/null
+++ b/COMMITMENT
@@ -0,0 +1,46 @@
+Common Cure Rights Commitment
+Version 1.0
+
+Before filing or continuing to prosecute any legal proceeding or claim
+(other than a Defensive Action) arising from termination of a Covered
+License, we commit to extend to the person or entity ('you') accused
+of violating the Covered License the following provisions regarding
+cure and reinstatement, taken from GPL version 3. As used here, the
+term 'this License' refers to the specific Covered License being
+enforced.
+
+    However, if you cease all violation of this License, then your
+    license from a particular copyright holder is reinstated (a)
+    provisionally, unless and until the copyright holder explicitly
+    and finally terminates your license, and (b) permanently, if the
+    copyright holder fails to notify you of the violation by some
+    reasonable means prior to 60 days after the cessation.
+
+    Moreover, your license from a particular copyright holder is
+    reinstated permanently if the copyright holder notifies you of the
+    violation by some reasonable means, this is the first time you
+    have received notice of violation of this License (for any work)
+    from that copyright holder, and you cure the violation prior to 30
+    days after your receipt of the notice.
+
+We intend this Commitment to be irrevocable, and binding and
+enforceable against us and assignees of or successors to our
+copyrights.
+
+Definitions
+
+'Covered License' means the GNU General Public License, version 2
+(GPLv2), the GNU Lesser General Public License, version 2.1
+(LGPLv2.1), or the GNU Library General Public License, version 2
+(LGPLv2), all as published by the Free Software Foundation.
+
+'Defensive Action' means a legal proceeding or claim that We bring
+against you in response to a prior proceeding or claim initiated by
+you or your affiliate.
+
+'We' means each contributor to this repository as of the date of
+inclusion of this file, including subsidiaries of a corporate
+contributor.
+
+This work is available under a Creative Commons Attribution-ShareAlike
+4.0 International license (https://creativecommons.org/licenses/by-sa/4.0/).
diff --git a/CONTRIBUTING b/CONTRIBUTING
deleted file mode 100644
index 7bccd88d7e5..00000000000
--- a/CONTRIBUTING
+++ /dev/null
@@ -1,25 +0,0 @@
-        Developer's Certificate of Origin 1.1
-
-        By making a contribution to this project, I certify that:
-
-        (a) The contribution was created in whole or in part by me and I
-            have the right to submit it under the open source license
-            indicated in the file; or
-
-        (b) The contribution is based upon previous work that, to the best
-            of my knowledge, is covered under an appropriate open source
-            license and I have the right under that license to submit that
-            work with modifications, whether created in whole or in part
-            by me, under the same open source license (unless I am
-            permitted to submit under a different license), as indicated
-            in the file; or
-
-        (c) The contribution was provided directly to me by some other
-            person who certified (a), (b) or (c) and I have not modified
-            it.
-
-        (d) I understand and agree that this project and the contribution
-            are public and that a record of the contribution (including all
-            personal information I submit with it, including my sign-off) is
-            maintained indefinitely and may be redistributed consistent with
-            this project or the open source license(s) involved.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..65fc3497104
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,114 @@
+# GlusterFS project Contribution guidelines
+
+## Development Workflow
+
+We follow most of the details as per the [document here](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests). If you are not aware of the github workflow, it is recommended to go through them before continuing here.
+
+
+#### Get the Repository setup
+
+0. Fork Repository
+   - Fork [GlusterFS repository](https://github.com/gluster/glusterfs/fork).
+
+1. Clone Repository
+   - Clone the glusterfs repo freshly from github using below steps.
+
+```
+   git clone git@github.com:${username}/glusterfs.git
+   cd glusterfs/
+   git remote add upstream git@github.com:gluster/glusterfs.git
+```
+
+About two tasks are one time for the life time. You can continue to use the same repository for all the work in future.
+
+#### Development & Other flows
+
+0. Issue:
+   - Make sure there is an issue filed for the task you are working on.
+   - If it is not filed, open the issue with all the description.
+   - If it is a bug fix, add label "Type:Bug".
+   - If it is an RFC, provide all the documentation, and request for "DocApproved", and "SpecApproved" label.
+
+1. Code:
+   - Start coding
+   - Build and test locally
+   - Make sure clang-format is installed and is run on the patch.
+
+2. Keep up-to-date
+   - GlusterFS is a large project with many developers, so there would be one or the other patch everyday.
+   - It is critical for developer to be up-to-date with `devel` repo to be Conflict-Free when PR is opened.
+   - Git provides many options to keep up-to-date, below is one of them
+```
+   git fetch upstream
+   git rebase upstream/devel
+```
+   - It is recommended you keep pushing to your repo every day, so you don't loose any work.
+     - It can be done by `./rfc.sh` (or `git push origin HEAD:issueNNN`)
+
+2. Commit Message / PR description:
+   - The name of the branch on your personal fork can start with issueNNNN, followed by anything of your choice.
+   - PRs continue to have the title of format "component: \<title\>", like it is practiced now.
+   - When you open a PR, having a reference Issue for the commit is mandatory in GlusterFS.
+   - Commit message can have, either `Fixes: #NNNN` or `Updates: #NNNN` in a separate line in the commit message.
+     - Here, NNNN is the Issue ID in glusterfs repository.
+   - Each commit needs the author to have the "Signed-off-by: Name \<email\>" line.
+     - Can do this by `-s` option for `git commit`.
+   - If the PR is not ready for review, apply the label `work-in-progress`.
+     - Check the availability of "Draft PR" is present for you, if yes, use that instead.
+
+3. Tests:
+   - All the required smoke tests would be auto-triggered.
+     - Developers get a chance to retrigger the smoke tests using **"/recheck smoke"** as comment.
+   - The "regression" tests would be triggered by a comment **"/run regression"** from developers in the [@gluster-maintainers](https://github.com/orgs/gluster/teams/gluster-maintainers) group.
+     - Ask for help as comment in PR if you have any questions about the process!
+
+4. Review Process:
+   - `+2` : is equivalent to "Approve" from the people in the maintainer's group.
+   - `+1` : can be given by a maintainer/reviewer by explicitly stating that in the comment.
+   - `-1` : provide details on required changes and pick "Request Changes" while submitting your review.
+   - `-2` : done by adding the `DO-NOT-MERGE` label.
+
+   - Any further discussions can happen as comments in the PR.
+
+5. Making changes:
+   - There are 2 approaches to submit changes done after addressing review comments.
+     - Commit changes as a new commit on top of the original commits in the branch, and push the changes to same branch (issueNNNN)
+     - Commit changes into the same commit with `--amend` option, and do a push to the same branch with `--force` option.
+
+6. Merging:
+   - GlusterFS project follows 'Squash and Merge' method
+     - This is mainly to preserve the historic Gerrit method of one patch in `git log` for one URL link.
+     - This also makes every merge a complete patch, which has passed all tests.
+   - The merging of the patch is expected to be done by the maintainers.
+     - It can be done when all the tests (smoke and regression) pass.
+     - When the PR has 'Approved' flag from corresponding maintainer.
+   - If you feel there is delay, feel free to add a comment, discuss the same in Slack channel, or send email.
+
+## By contributing to this project, the contributor would need to agree to below.
+
+### Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+
diff --git a/INSTALL b/INSTALL
index c24a916cf1d..a56390e54fb 100644
--- a/INSTALL
+++ b/INSTALL
@@ -44,4 +44,4 @@ Installation completed :-)
 Make sure your version is the latest from the release, and the one you 
 just installed :-)
 
-For more information on GlusterFS installation refer# https://gluster.readthedocs.io/en/latest/Developer-guide/Building-GlusterFS/
+For more information on GlusterFS installation refer# http://docs.gluster.org/en/latest/Developer-guide/Building-GlusterFS/
diff --git a/MAINTAINERS b/MAINTAINERS
index 773d64e06f0..953e8755fd9 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -51,15 +51,10 @@ Descriptions of section entries:
 
 General Project Architects
 --------------------------
-M: Jeff Darcy <jeff@pl.atyp.us>
-M: Vijay Bellur <vbellur@redhat.com>
-P: Amar Tumballi <amarts@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
-P: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Niels de Vos <ndevos@redhat.com>
-P: Xavier Hernandez  <xhernandez@datalab.es>
-
+M: Amar Tumballi <amarts@gmail.com>
+M: Xavier Hernandez  <xhernandez@redhat.com>
+P: Pranith Karampuri <pranith.karampuri@phonepe.com>
+P: Atin Mukherjee <amukherj@redhat.com>
 
 xlators:
 --------
@@ -71,13 +66,14 @@ F: xlators/system/posix-acl/
 
 Arbiter
 M: Ravishankar N <ravishankar@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
+P: Pranith Karampuri <pranith.karampuri@phonepe.com>
 S: Maintained
 F: xlators/features/arbiter/
 
 Automatic File Replication (AFR)
-M: Pranith Karampuri <pkarampu@redhat.com>
-P: Ravishankar N <ravishankar@redhat.com>
+M: Pranith Karampuri <pranith.karampuri@phonepe.com>
+M: Ravishankar N <ravishankar@redhat.com>
+P: Karthik US <ksubrahm@redhat.com>
 S: Maintained
 F: xlators/cluster/afr/
 
@@ -87,10 +83,6 @@ P: Atin Mukherjee <amukherj@redhat.com>
 S: Maintained
 F: xlators/features/barrier
 
-Block Device
-S: Orphan
-F: xlators/storage/bd/
-
 BitRot
 M: Kotresh HR <khiremat@redhat.com>
 P: Raghavendra Bhat <rabhat@redhat.com>
@@ -103,30 +95,15 @@ P: Kotresh HR <khiremat@redhat.com>
 S: Maintained
 F: xlators/features/changelog/
 
-Changetimerecorder
-M: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Hari Gowtham <hgowtham@redhat.com>
-S: Maintained
-F: xlators/features/changetimerecorder/
-
-Decompounder
-M: Krutika Dhananjay <kdhananj@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
-S: Maintained
-F: xlators/features/decompounder/
-
 Distributed Hashing Table (DHT)
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-M: Nithya Balachandran <nbalacha@redhat.com>
 P: Susant Palai <spalai@redhat.com>
 S: Maintained
 F: xlators/cluster/dht/
 
 Erasure Coding
-M: Pranith Karampuri <pkarampu@redhat.com>
-M: Xavier Hernandez  <xhernandez@datalab.es>
+M: Pranith Karampuri <pranith.karampuri@phonepe.com>
+M: Xavier Hernandez  <xhernandez@redhat.com>
 P: Ashish Pandey <aspandey@redhat.com>
-P: Sunil Kumar Acharya <sheggodu@redhat.com>
 S: Maintained
 F: xlators/cluster/ec/
 
@@ -136,21 +113,19 @@ S: Maintained
 F: xlators/debug/error-gen/
 
 FUSE Bridge
-M: Niels de Vos <ndevos@redhat.com>
-P: Csaba Henk <chenk@redhat.com>
+M: Csaba Henk <chenk@redhat.com>
+P: Niels de Vos <ndevos@redhat.com>
 S: Maintained
 F: xlators/mount/
 
 Index
-M: Pranith Karampuri <pkarampu@redhat.com>
+M: Pranith Karampuri <pranith.karampuri@phonepe.com>
 P: Ravishankar N <ravishankar@redhat.com>
 S: Maintained
 F: xlators/features/index/
 
 IO Cache
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
-P: Nithya Balachandran <nbalacha@redhat.com>
+P: Mohammed Rafi KC <rafi.kavungal@iternity.com>
 S: Maintained
 F: xlators/performance/io-cache/
 
@@ -161,7 +136,7 @@ S: Maintained
 F: xlators/debug/io-stats/
 
 IO threads
-M: Pranith Karampuri <pkarampu@redhat.com>
+M: Pranith Karampuri <pranith.karampuri@phonepe.com>
 P: Ravishankar N <ravishankar@redhat.com>
 S: Maintained
 F: xlators/performance/io-threads/
@@ -175,18 +150,17 @@ F: xlators/features/leases/
 
 Locks
 M: Krutika Dhananjay <kdhananj@redhat.com>
+P: Xavier Hernandez  <xhernandez@redhat.com>
 S: Maintained
 F: xlators/features/locks/
 
 Marker
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
 M: Kotresh HR <khiremat@redhat.com>
-P: Sanoj Unnikrishnan <sunnikri@redhat.com>
 S: Maintained
 F: xlators/features/marker/
 
 Meta
-M: Mohammed Rafi KC <rkavunga@redhat.com>
+M: Mohammed Rafi KC <rafi.kavungal@iternity.com>
 S: Maintained
 F: xlators/features/meta/
 
@@ -198,66 +172,53 @@ F: xlators/performance/md-cache/
 
 Negative-lookup Cache
 M: Poornima G <pgurusid@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
+P: Pranith Karampuri <pranith.karampuri@phonepe.com>
 S: Maintained
 F: xlators/performance/nl-cache/
 
-NFS
-M: Niels de Vos <ndevos@redhat.com>
-P: Jiffin Tony Thottan <jthottan@redhat.com>
-P: Soumya Koduri <skoduri@redhat.com>
-S: Maintained
+gNFS
+M: Jiffin Tony Thottan <jthottan@redhat.com>
+P: Xie Changlong <xiechanglong@cmss.chinamobile.com>
+P: Amar Tumballi <amarts@gmail.com>
+S: Odd Fixes
 F: xlators/nfs/server/
 
 Open-behind
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Milind Changire <mchangir@redhat.com>
 S: Maintained
 F: xlators/performance/open-behind/
 
 Posix:
 M: Raghavendra Bhat <raghavendra@redhat.com>
+P: Kotresh HR <khiremat@redhat.com>
 P: Krutika Dhananjay <kdhananj@redhat.com>
-P: Jiffin Tony Thottan <jthottan@redhat.com>
 S: Maintained
 F: xlators/storage/posix/
 
 Quick-read
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Milind Changire <mchangir@redhat.com>
 S: Maintained
 F: xlators/performance/quick-read/
 
 Quota
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Sanoj Unnikrishnan <sunnikri@redhat.com>
 M: Shyamsundar Ranganathan <srangana@redhat.com>
+P: Hari Gowtham <hgowtham@redhat.com>
 S: Maintained
 F: xlators/features/quota/
 
 Read-ahead
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
 P: Csaba Henk <chenk@redhat.com>
 S: Maintained
 F: xlators/performance/read-ahead/
 
 Readdir-ahead
-M: Poornima G <pgurusid@redhat.com>
-P: Krutika Dhananjay <kdhananj@redhat.com>
 S: Maintained
 F: xlators/performance/readdir-ahead/
 
 Sharding
 M: Krutika Dhananjay <kdhananj@redhat.com>
+P: Xavier Hernandez  <xhernandez@redhat.com>
 S: Maintained
 F: xlators/features/shard/
 
-Tiering
-M: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Hari Gowtham <hgowtham@redhat.com>
-S: Maintained
-F: xlators/cluster/dht/src/tier.c
-
 Trash
 M: Anoop C S <anoopcs@redhat.com>
 M: Jiffin Tony Thottan <jthottan@redhat.com>
@@ -272,7 +233,6 @@ S: Maintained
 F: xlators/features/upcall/
 
 Write-behind
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
 P: Csaba Henk <chenk@redhat.com>
 S: Maintained
 F: xlators/performance/write-behind/
@@ -282,24 +242,10 @@ P: Karthik US <ksubrahm@redhat.com>
 S: Maintained
 F: xlators/features/read-only/
 
-Experimental Features:
-----------------------
-
-Distributed Hash Table 2
-M: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Kotresh HR <khiremat@redhat.com>
-P: Susant Palai <spalai@redhat.com>
+Cloudsync
+M: Susant Kumar Palai <spalai@redhat.com>
 S: Maintained
-F: xlators/experimental/dht2/
-
-Journal Based Replication
-M: Jeff Darcy <jeff@pl.atyp.us>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
-S: Maintained
-F: xlators/experimental/fdl/
-F: xlators/experimenta/jbr-client/
-F: xlators/experimental/jbr-server/
-
+F: xlators/features/cloudsync/
 
 Other bits of code:
 -------------------
@@ -307,24 +253,18 @@ Other bits of code:
 Doc
 M: Humble Chirammal <hchiramm@redhat.com>
 M: Raghavendra Talur <rtalur@redhat.com>
-M: Prashanth Pai <ppai@redhat.com>
 S: Maintained
 F: doc/
 
 Geo Replication
 M: Aravinda V K <avishwan@redhat.com>
 M: Kotresh HR <khiremat@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
+M: Sunny Kumar <sunkumar@redhat.com>
 S: Maintained
 F: geo-replication/
 
-Glupy
-S: Orphan
-F: xlators/features/glupy/
-
 Glusterfind
-M: Milind Changire <mchangir@redhat.com>
-P: Aravinda VK <avishwan@redhat.com>
+M: Aravinda VK <avishwan@redhat.com>
 S: Maintained
 F: tools/glusterfind/
 
@@ -336,19 +276,13 @@ P: Soumya Koduri <skoduri@redhat.com>
 S: Maintained
 F: api/
 
-libgfdb
-M: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Hari Gowtham <hgowtham@redhat.com>
-S: Maintained
-F: libglusterfs/src/gfdb/
-
 libglusterfs
-M: Amar Tumballi <amarts@redhat.com>
+M: Amar Tumballi <amarts@gmail.com>
+M: Xavier Hernandez  <xhernandez@redhat.com>
 M: Jeff Darcy <jeff@pl.atyp.us>
 P: Kaleb Keithley <kkeithle@redhat.com>
 P: Niels de Vos <ndevos@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
-P: Raghavendra Gowdappa <rgowdapp@redhat.com>
+P: Pranith Karampuri <pranith.karampuri@phonepe.com>
 P: Shyamsundar Ranganathan <srangana@redhat.com>
 S: Maintained
 F: libglusterfs/
@@ -356,43 +290,26 @@ F: libglusterfs/
 xxhash
 M: Aravinda VK <avishwan@redhat.com>
 M: Kotresh HR <khiremat@redhat.com>
-P: Amar Tumballi <amarts@redhat.com>
+P: Yaniv Kaul <ykaul@redhat.com>
 S: Maintained
 F: contrib/xxhash/
 T: https://github.com/Cyan4973/xxHash.git
 
-Management Daemon - glusterd1
+Management Daemon - glusterd
 M: Atin Mukherjee <amukherj@redhat.com>
-M: Samikshan Bairagya <samikshan@gmail.com>
+M: Mohit Agrawal <moagrawa@redhat.com>
+M: Sanju Rakonde <srakonde@redhat.com>
 S: Maintained
 F: cli/
 F: xlators/mgmt/glusterd/
 
-Management Daemon - glusterd2
-M: Kaushal M <kaushal@redhat.com>
-M: Prashanth Pai <ppai@redhat.com>
-P: Aravinda VK <avishwan@redhat.com>
-S: Maintained
-T: https://github.com/gluster/glusterd2.git
-
 Protocol
-M: Kaleb Keithley <kkeithle@redhat.com>
 M: Niels de Vos <ndevos@redhat.com>
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
+P: Mohammed Rafi KC <rafi.kavungal@iternity.com>
 S: Maintained
 F: xlators/protocol/
 
-RDMA subsystem
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-M: Amar Tumballi <amarts@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
-S: Maintained
-F: rpc/rpc-transport/rdma/
-
 Remote Procedure Call subsystem
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
-P: Milind Changire <mchangir@redhat.com>
 P: Mohit Agrawal <moagrawa@redhat.com>
 S: Maintained
 F: rpc/rpc-lib/
@@ -400,16 +317,16 @@ F: rpc/xdr/
 
 Snapshot
 M: Raghavendra Bhat <raghavendra@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
+P: Mohammed Rafi KC <rafi.kavungal@iternity.com>
+P: Sunny Kumar <sunkumar@redhat.com>
 S: Maintained
 F: xlators/mgmt/glusterd/src/glusterd-snap*
 F: extras/snap-scheduler.py
 
 Socket subsystem
-M: Raghavendra Gowdappa <rgowdapp@redhat.com>
 P: Krutika Dhananjay <kdhananj@redhat.com>
 P: Milind Changire <mchangir@redhat.com>
-P: Mohammed Rafi KC <rkavunga@redhat.com>
+P: Mohammed Rafi KC <rafi.kavungal@iternity.com>
 P: Mohit Agrawal <moagrawa@redhat.com>
 S: Maintained
 F: rpc/rpc-transport/socket/
@@ -422,7 +339,6 @@ F: tests/
 Utilities
 M: Aravinda VK <avishwan@redhat.com>
 P: Niels de Vos <ndevos@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
 P: Raghavendra Talur <rtalur@redhat.com>
 P: Sachidanda Urs <surs@redhat.com>
 S: Maintained
@@ -439,17 +355,18 @@ F: extras/systemd/glustereventsd*
 Distribution Specific:
 ----------------------
 Build:
-M: Kaleb Keithley <kkeithle@redhat.com>
 M: Niels de Vos <ndevos@redhat.com>
+M: Hari Gowtham <hgowtham@redhat.com>
 P: Anoop C S <anoopcs@redhat.com>
-P: Kaushal M <kaushal@redhat.com>
 P: Raghavendra Talur <rtalur@redhat.com>
+P: Rinku Kothiya <rkothiya@redhat.com>
 S: Maintained
 
 Debian packages on download.gluster.org
 M: packaging@gluster.org
 M: Kaleb Keithley <kkeithle@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
+P: Sheetal Pamecha <spamecha@redhat.com>
+P: Shwetha Acharya <sacharya@redhat.com>
 S: Maintained
 W: http://download.gluster.org/pub/gluster/glusterfs/LATEST/Debian/Debian.README
 T: https://github.com/gluster/glusterfs-debian.git
@@ -457,7 +374,8 @@ T: https://github.com/gluster/glusterfs-debian.git
 OpenSuSE
 M: packaging@gluster.org
 M: Kaleb Keithley <kkeithle@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
+P: Sheetal Pamecha <spamecha@redhat.com>
+P: Shwetha Acharya <sacharya@redhat.com>
 S: Maintained
 W: https://build.opensuse.org/repositories/home:glusterfs
 W: https://download.gluster.org/pub/gluster/glusterfs/LATEST/SuSE/SuSE.README
@@ -474,7 +392,8 @@ T: https://github.com/CentOS-Storage-SIG/glusterfs.git
 Ubuntu PPA
 M: packaging@gluster.org
 M: Kaleb Keithley <kkeithle@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
+P: Sheetal Pamecha <spamecha@redhat.com>
+P: Shwetha Acharya <sacharya@redhat.com>
 S: Maintained
 W: https://launchpad.net/~gluster
 W: http://download.gluster.org/pub/gluster/glusterfs/LATEST/Ubuntu/Ubuntu.README
@@ -484,22 +403,10 @@ Related projects
 ----------------
 Gluster Block
 M: Prasanna Kumar Kalever <prasanna.kalever@redhat.com>
-P: Pranith Karampuri <pkarampu@redhat.com>
-P: Niels de Vos <ndevos@redhat.com>
+M: Xiubo Li <xiubli@redhat.com>
 S: Maintained
 T: https://github.com/gluster/gluster-block.git
 
-Gluster Object
-P: Ram Edara <redara@redhat.com>
-P: Saravanakumar Arumugam <sarumuga@redhat.com>
-S: Maintained
-T: https://github.com/gluster/gluster-swift.git
-
-GlusterFS Hadoop HCFS plugin
-S: Orphan
-W: https://github.com/gluster/glusterfs-hadoop/wiki
-T: https://github.com/gluster/glusterfs-hadoop.git
-
 GlusterFS core-utils
 M: Anoop C S <anoopcs@redhat.com>
 S: Maintained
@@ -513,11 +420,6 @@ S: Maintained
 T: git://github.com/nfs-ganesha/nfs-ganesha.git
 F: src/nfs-ganesha~/src/FSAL/FSAL_GLUSTER/
 
-Nagios Monitoring
-M: Sahina Bose <sabose@redhat.com>
-S: Maintained
-T: https://github.com/gluster/nagios-plugins-gluster.git
-
 QEMU integration
 M: Niels de Vos <ndevos@redhat.com>
 M: Prasanna Kumar Kalever <prasanna.kalever@redhat.com>
@@ -540,10 +442,10 @@ P: Kaleb Keithley <kkeithle@redhat.com>
 S: Maintained
 T: https://github.com/linux-ha-storage/storhaug.git
 
-Testing - Glusto
+Testing - Glusto-Tests
 M: Jonathan Holloway <jholloway@redhat.com>
-M: Shwetha Panduranga <spandura@redhat.com>
-P: Nigel Babu <nigelb@redhat.com>
+M: Vijay Bhaskar Reddy Avuthu <vavuthu@redhat.com>
+M: Akarsha Rai <akrai@redhat.com>
 S: Maintained
 T: https://github.com/gluster/glusto-tests.git
 
@@ -558,15 +460,13 @@ Infrastructure
 --------------
 
 Platform
-M: Nigel Babu <nigelb@redhat.com>
 M: Michael Scherer <misc@redhat.com>
 P: Shyamsundar Ranganathan <srangana@redhat.com>
-P: Amar Tumballi <amarts@redhat.com>
+P: Amar Tumballi <amarts@gmail.com>
 
 Continuous Integration
-M: Nigel Babu <nigelb@redhat.com>
 M: Michael Scherer <misc@redhat.com>
-P: Kaushal M <kaushal@redhat.com>
+M: Deepshikha Khandelwal <dkhandel@redhat.com>
 P: Niels de Vos <ndevos@redhat.com>
 
 Special Thanks
@@ -574,6 +474,17 @@ Special Thanks
 
 GlusterFS would not be possible without the contributions of:
 
+
+M: Vijay Bellur <vbellur@redhat.com>
+M: Jeff Darcy <jeff@pl.atyp.us>
+M: Shreyas Siravara <sshreyas@fb.com>
+M: Kaushal M <kaushal@redhat.com>
+M: Nigel Babu
+M: Prashanth Pai
+P: Sanoj Unnikrishnan
+P: Milind Changire <mchangir@redhat.com>
+P: Sunil Kumar Acharya <sheggodu@redhat.com>
+M: Samikshan Bairagya <samikshan@gmail.com>
 M: Chris Hertel
 M: M. Mohan Kumar <mohan@in.ibm.com>
 M: Shishir Gowda <gowda.shishir@gmail.com>
@@ -594,3 +505,6 @@ M: Dan Lambright
 M: Jay Vyas
 M: Luis Pabon
 M: Ira Cooper
+M: Shwetha Panduranga
+M: Nithya Balachandran
+M: Raghavendra Gowdappa
diff --git a/Makefile.am b/Makefile.am
index bbf121a0059..98ea5c1038d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,51 +1,37 @@
 SOURCES = site.h
 
 EXTRA_DIST = autogen.sh \
-	COPYING-GPLV2 COPYING-LGPLV3 \
+	COPYING-GPLV2 COPYING-LGPLV3 COMMITMENT \
 	INSTALL README.md AUTHORS THANKS NEWS \
-	glusterfs.spec glusterfs-api.pc.in libgfchangelog.pc.in libgfdb.pc.in \
+	glusterfs.spec glusterfs-api.pc.in libgfchangelog.pc.in \
 	run-tests.sh \
 	build-aux/pkg-version \
-        contrib/argp-standalone \
-        contrib/umountd \
-        contrib/uuid \
+	contrib/umountd \
 	$(shell find $(top_srcdir)/tests -type f -print)
 
-SUBDIRS = $(ARGP_STANDALONE_DIR) rpc/xdr/gen libglusterfs rpc api xlators \
-	glusterfsd $(FUSERMOUNT_SUBDIR) doc extras cli heal \
+
+SUBDIRS = $(ARGP_STANDALONE_DIR) libglusterfs rpc libglusterd api \
+	glusterfsd xlators $(FUSERMOUNT_SUBDIR) doc extras cli heal \
 	@SYNCDAEMON_SUBDIR@ @UMOUNTD_SUBDIR@ tools events
 
 pkgconfigdir = @pkgconfigdir@
 pkgconfig_DATA = glusterfs-api.pc libgfchangelog.pc
-if USE_GFDB
-pkgconfig_DATA += libgfdb.pc
-endif
 
-CLEANFILES = glusterfs-api.pc libgfchangelog.pc libgfdb.pc \
-	tests/env.rc contrib/umountd/Makefile
-CONFIG_CLEAN_FILES = $(CONTRIB_BUILDDIR)/uuid/uuid_types.h
+CLEANFILES = glusterfs-api.pc libgfchangelog.pc contrib/umountd/Makefile
+
+clean-local:
+	find . -name '*.o' -o -name '*.lo' -o -name '.Po' | xargs rm -f
 
 gitclean: distclean
 	find . -name Makefile.in -exec rm -f {} \;
 	find . -name mount.glusterfs -exec rm -f {} \;
+	find . -name .deps -o -name .libs | xargs rm -rf
 	rm -fr autom4te.cache
 	rm -f missing aclocal.m4 config.h.in config.guess config.sub ltmain.sh install-sh configure depcomp
-	-rm -fr $(CONTRIBDIR)/argp-standalone/autom4te.cache
-	-rm -f $(CONTRIBDIR)/argp-standalone/aclocal.m4
-	-rm -f $(CONTRIBDIR)/argp-standalone/config.h.in
-	-rm -f $(CONTRIBDIR)/argp-standalone/configure
-	-rm -f $(CONTRIBDIR)/argp-standalone/config.status
-	-rm -f $(CONTRIBDIR)/argp-standalone/config.log
-	-rm -f $(CONTRIBDIR)/argp-standalone/depcomp
-	-rm -fr $(CONTRIBDIR)/argp-standalone/.deps
-	-rm -f $(CONTRIBDIR)/argp-standalone/install-sh
-	-rm -f $(CONTRIBDIR)/argp-standalone/missing
 
 # dist-hook gets executed with 'make dist', this is the only target getting
 # executed, a dist-hook in other Makefile.am files seem to get ignored.
 dist-hook: gen-VERSION gen-ChangeLog
-	-rm -fr $(distdir)/contrib/argp-standalone/autom4te.cache
-	-rm -fr $(distdir)/contrib/argp-standalone/.deps
 	-rm -fr $(distdir)/contrib/umountd/.deps
 	-rm -f $(distdir)/events/src/eventtypes.py
 	-rm -f $(distdir)/tests/env.rc
@@ -67,4 +53,3 @@ gen-VERSION:
 	  ./build-aux/pkg-version --full                \
 	    > $(abs_top_builddir)/$(distdir)/VERSION;   \
 	fi
-
diff --git a/README.md b/README.md
index 1cab5c19390..9d68e033782 100644
--- a/README.md
+++ b/README.md
@@ -3,15 +3,40 @@
   petabytes. It provides interfaces for object, block and file storage.
 
 ## Development
-  Contributions to gluster in the form of patches and new feature additions can
-  be made by following steps outlined at [Developers Guide](https://gluster.readthedocs.io/en/latest/Developer-guide/Developers-Index/#contributing-to-the-gluster-community).
+  The development workflow is documented in [Contributors guide](CONTRIBUTING.md)
 
 ## Documentation
-  The Gluster documentation can be found at [Gluster Docs](http://gluster.readthedocs.io/en/latest).
+  The Gluster documentation can be found at [Gluster Docs](http://docs.gluster.org).
 
 ## Deployment
   Quick instructions to build and install can be found in [INSTALL](INSTALL) file.
 
+## Testing
+
+  GlusterFS source contains some functional tests under `tests/` directory. All
+  these tests are run against every patch submitted for review. If you want your
+  patch to be tested, please add a `.t` test file as part of your patch submission.
+  You can also submit a patch to only add a `.t` file for the test case you are
+  aware of.
+
+  To run these tests, on your test-machine, just run `./run-tests.sh`. Don't run
+  this on a machine where you have 'production' glusterfs is running, as it would
+  blindly kill all gluster processes in each runs.
+
+  If you are sending a patch, and want to validate one or few specific tests, then
+  run a single test by running the below command.
+
+```
+  bash# /bin/bash ${path_to_gluster}/tests/basic/rpc-coverage.t
+```
+
+  You can also use `prove` tool if available in your machine, as follows.
+
+```
+  bash# prove -vmfe '/bin/bash' ${path_to_gluster}/tests/basic/rpc-coverage.t
+```
+
+
 ## Maintainers
   The list of Gluster maintainers is available in [MAINTAINERS](MAINTAINERS) file.
 
diff --git a/api/examples/getvolfile.py b/api/examples/getvolfile.py
index 0c95213f0b6..3b2c8ab5a15 100755
--- a/api/examples/getvolfile.py
+++ b/api/examples/getvolfile.py
@@ -1,9 +1,10 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
+from __future__ import print_function
 import ctypes
 import ctypes.util
 
-api = ctypes.CDLL(ctypes.util.find_library("gfapi"))
+api = ctypes.CDLL("libgfapi.so")
 api.glfs_get_volfile.argtypes = [ctypes.c_void_p,
                                  ctypes.c_void_p,
                                  ctypes.c_ulong]
@@ -33,12 +34,12 @@ if __name__ == "__main__":
     import sys
 
     try:
-        res = apply(get_volfile, sys.argv[1:3])
+        res = get_volfile(*sys.argv[1:3])
     except:
-        print "fetching volfile failed (volume not started?)"
+        print("fetching volfile failed (volume not started?)")
 
     try:
         for line in res.split('\n'):
-            print line
+            print(line)
     except:
-        print "bad return value %s" % res
+        print("bad return value %s" % res)
diff --git a/api/examples/glfsxmp.c b/api/examples/glfsxmp.c
index 7ff3f0eb7ee..a55616ef739 100644
--- a/api/examples/glfsxmp.c
+++ b/api/examples/glfsxmp.c
@@ -1,1598 +1,1811 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
-#include "api/glfs.h"
-#include "api/glfs-handles.h"
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
 #include <string.h>
 #include <time.h>
 
+#define TEST_STR_LEN 2048
 
 int
-test_dirops (glfs_t *fs)
+test_dirops(glfs_t *fs)
 {
-        glfs_fd_t *fd = NULL;
-        char buf[512];
-        struct dirent *entry = NULL;
-
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "/: %s\n", strerror (errno));
-                return -1;
-        }
-
-        fprintf (stderr, "Entries:\n");
-        while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) {
-                fprintf (stderr, "%s: %lu\n", entry->d_name, glfs_telldir (fd));
-        }
-
-        glfs_closedir (fd);
-        return 0;
+    glfs_fd_t *fd = NULL;
+    char buf[512];
+    struct dirent *entry = NULL;
+
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "Entries:\n");
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        fprintf(stderr, "%s: %lu\n", entry->d_name, glfs_telldir(fd));
+    }
+
+    glfs_closedir(fd);
+    return 0;
 }
 
-
 int
-test_xattr (glfs_t *fs)
+test_xattr(glfs_t *fs)
 {
-        char *filename = "/filename2";
-        char buf[512];
-        char *ptr;
-        int ret;
-
-        ret = glfs_setxattr (fs, filename, "user.testkey", "testval", 8, 0);
-        fprintf (stderr, "setxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-
-        ret = glfs_setxattr (fs, filename, "user.testkey2", "testval", 8, 0);
-        fprintf (stderr, "setxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-
-        ret = glfs_listxattr (fs, filename, buf, 512);
-        fprintf (stderr, "listxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-        if (ret < 0)
-                return -1;
-
-        for (ptr = buf; ptr < buf + ret; ptr++) {
-                printf ("key=%s\n", ptr);
-                ptr += strlen (ptr);
-        }
-
-        return 0;
+    char *filename = "/filename2";
+    char *linkfile = "/linkfile";
+    glfs_fd_t *fd = NULL;
+    char buf[512];
+    char *ptr;
+    int ret;
+
+    ret = glfs_setxattr(fs, filename, "user.testkey", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_setxattr(fs, filename, "user.testkey2", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_getxattr(fs, filename, "user.testkey", buf, 512);
+    fprintf(stderr, "getxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_listxattr(fs, filename, buf, 512);
+    fprintf(stderr, "listxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_symlink(fs, "filename", linkfile);
+    fprintf(stderr, "symlink(%s %s): %s\n", filename, linkfile,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_readlink(fs, linkfile, buf, 512);
+    fprintf(stderr, "readlink(%s) : %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_lsetxattr(fs, filename, "user.testkey3", "testval", 8, 0);
+    fprintf(stderr, "lsetxattr(%s) : %d (%s)\n", linkfile, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_llistxattr(fs, linkfile, buf, 512);
+    fprintf(stderr, "llistxattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_lgetxattr(fs, filename, "user.testkey3", buf, 512);
+    fprintf(stderr, "lgetxattr(%s): %d (%s)\n", linkfile, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    for (ptr = buf; ptr < buf + ret; ptr++) {
+        printf("key=%s\n", ptr);
+        ptr += strlen(ptr);
+    }
+
+    ret = glfs_removexattr(fs, filename, "user.testkey2");
+    fprintf(stderr, "removexattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+
+    fd = glfs_open(fs, filename, O_RDWR);
+    fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    ret = glfs_fsetxattr(fd, "user.testkey2", "testval", 8, 0);
+    fprintf(stderr, "fsetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_fgetxattr(fd, "user.testkey2", buf, 512);
+    fprintf(stderr, "fgetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_flistxattr(fd, buf, 512);
+    fprintf(stderr, "flistxattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    for (ptr = buf; ptr < buf + ret; ptr++) {
+        printf("key=%s\n", ptr);
+        ptr += strlen(ptr);
+    }
+
+    ret = glfs_fremovexattr(fd, "user.testkey2");
+    fprintf(stderr, "fremovexattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+
+    glfs_close(fd);
+
+    return 0;
 }
 
-
 int
-test_chdir (glfs_t *fs)
+test_chdir(glfs_t *fs)
 {
-        int ret = -1;
-        char *topdir = "/topdir";
-        char *linkdir = "/linkdir";
-        char *subdir = "./subdir";
-        char *respath = NULL;
-        char pathbuf[4096];
-
-        ret = glfs_mkdir (fs, topdir, 0755);
-        if (ret) {
-                fprintf (stderr, "mkdir(%s): %s\n", topdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
-
-        ret = glfs_symlink (fs, topdir, linkdir);
-        if (ret) {
-                fprintf (stderr, "symlink(%s, %s): %s\n", topdir, linkdir, strerror (errno));
-                return -1;
-        }
-
-        ret = glfs_chdir (fs, linkdir);
-        if (ret) {
-                fprintf (stderr, "chdir(%s): %s\n", linkdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
-
-        respath = glfs_realpath (fs, subdir, pathbuf);
-        if (respath) {
-                fprintf (stderr, "realpath(%s) worked unexpectedly: %s\n", subdir, respath);
-                return -1;
-        }
-
-        ret = glfs_mkdir (fs, subdir, 0755);
-        if (ret) {
-                fprintf (stderr, "mkdir(%s): %s\n", subdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_realpath (fs, subdir, pathbuf);
-        if (!respath) {
-                fprintf (stderr, "realpath(%s): %s\n", subdir, strerror (errno));
-        } else {
-                fprintf (stdout, "realpath(%s) = %s\n", subdir, respath);
-        }
-
-        ret = glfs_chdir (fs, subdir);
-        if (ret) {
-                fprintf (stderr, "chdir(%s): %s\n", subdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
-
-        respath = glfs_realpath (fs, "/linkdir/subdir", pathbuf);
-        if (!respath) {
-                fprintf (stderr, "realpath(/linkdir/subdir): %s\n", strerror (errno));
-        } else {
-                fprintf (stdout, "realpath(/linkdir/subdir) = %s\n", respath);
-        }
-
-        return 0;
+    int ret = -1;
+    char *dir = "/dir";
+    char *topdir = "/topdir";
+    char *linkdir = "/linkdir";
+    char *linkdir2 = "/linkdir2";
+    char *subdir = "./subdir";
+    char *respath = NULL;
+    char pathbuf[4096];
+
+    ret = glfs_mkdir(fs, topdir, 0755);
+    fprintf(stderr, "mkdir(%s): %s\n", topdir, strerror(errno));
+    if (ret)
+        return -1;
+
+    ret = glfs_mkdir(fs, dir, 0755);
+    fprintf(stderr, "mkdir(%s): %s\n", dir, strerror(errno));
+    if (ret)
+        return -1;
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    ret = glfs_symlink(fs, "topdir", linkdir);
+    if (ret) {
+        fprintf(stderr, "symlink(%s, %s): %s\n", topdir, linkdir,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_chdir(fs, linkdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", linkdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (respath) {
+        fprintf(stderr, "realpath(%s) worked unexpectedly: %s\n", subdir,
+                respath);
+        return -1;
+    }
+
+    ret = glfs_mkdir(fs, subdir, 0755);
+    if (ret) {
+        fprintf(stderr, "mkdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(%s): %s\n", subdir, strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(%s) = %s\n", subdir, respath);
+    }
+
+    ret = glfs_chdir(fs, subdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, "/linkdir/subdir", pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(/linkdir/subdir): %s\n", strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(/linkdir/subdir) = %s\n", respath);
+    }
+
+    return 0;
 }
 
 #ifdef DEBUG
 static void
-peek_stat (struct stat *sb)
+peek_stat(struct stat *sb)
 {
-        printf ("Dumping stat information:\n");
-        printf ("File type:                ");
-
-        switch (sb->st_mode & S_IFMT) {
-                case S_IFBLK:  printf ("block device\n");            break;
-                case S_IFCHR:  printf ("character device\n");        break;
-                case S_IFDIR:  printf ("directory\n");               break;
-                case S_IFIFO:  printf ("FIFO/pipe\n");               break;
-                case S_IFLNK:  printf ("symlink\n");                 break;
-                case S_IFREG:  printf ("regular file\n");            break;
-                case S_IFSOCK: printf ("socket\n");                  break;
-                default:       printf ("unknown?\n");                break;
-        }
-
-        printf ("I-node number:            %ld\n", (long) sb->st_ino);
-
-        printf ("Mode:                     %lo (octal)\n",
-                (unsigned long) sb->st_mode);
-
-        printf ("Link count:               %ld\n", (long) sb->st_nlink);
-        printf ("Ownership:                UID=%ld   GID=%ld\n",
-                (long) sb->st_uid, (long) sb->st_gid);
-
-        printf ("Preferred I/O block size: %ld bytes\n",
-                (long) sb->st_blksize);
-        printf ("File size:                %lld bytes\n",
-                (long long) sb->st_size);
-        printf ("Blocks allocated:         %lld\n",
-                (long long) sb->st_blocks);
-
-        printf ("Last status change:       %s", ctime(&sb->st_ctime));
-        printf ("Last file access:         %s", ctime(&sb->st_atime));
-        printf ("Last file modification:   %s", ctime(&sb->st_mtime));
-
-        return;
+    printf("Dumping stat information:\n");
+    printf("File type:                ");
+
+    switch (sb->st_mode & S_IFMT) {
+        case S_IFBLK:
+            printf("block device\n");
+            break;
+        case S_IFCHR:
+            printf("character device\n");
+            break;
+        case S_IFDIR:
+            printf("directory\n");
+            break;
+        case S_IFIFO:
+            printf("FIFO/pipe\n");
+            break;
+        case S_IFLNK:
+            printf("symlink\n");
+            break;
+        case S_IFREG:
+            printf("regular file\n");
+            break;
+        case S_IFSOCK:
+            printf("socket\n");
+            break;
+        default:
+            printf("unknown?\n");
+            break;
+    }
+
+    printf("I-node number:            %ld\n", (long)sb->st_ino);
+
+    printf("Mode:                     %lo (octal)\n",
+           (unsigned long)sb->st_mode);
+
+    printf("Link count:               %ld\n", (long)sb->st_nlink);
+    printf("Ownership:                UID=%ld   GID=%ld\n", (long)sb->st_uid,
+           (long)sb->st_gid);
+
+    printf("Preferred I/O block size: %ld bytes\n", (long)sb->st_blksize);
+    printf("File size:                %lld bytes\n", (long long)sb->st_size);
+    printf("Blocks allocated:         %lld\n", (long long)sb->st_blocks);
+
+    printf("Last status change:       %s", ctime(&sb->st_ctime));
+    printf("Last file access:         %s", ctime(&sb->st_atime));
+    printf("Last file modification:   %s", ctime(&sb->st_mtime));
+
+    return;
 }
 
 static void
-peek_handle (unsigned char *glid)
+peek_handle(unsigned char *glid)
 {
-        int i;
+    int i;
 
-        for (i = 0; i < GFAPI_HANDLE_LENGTH; i++)
-        {
-                printf (":%02x:", glid[i]);
-        }
-        printf ("\n");
+    for (i = 0; i < GFAPI_HANDLE_LENGTH; i++) {
+        printf(":%02x:", glid[i]);
+    }
+    printf("\n");
 }
-#else /* DEBUG */
+#else  /* DEBUG */
 static void
-peek_stat (struct stat *sb)
+peek_stat(struct stat *sb)
 {
-        return;
+    return;
 }
 
 static void
-peek_handle (unsigned char *id)
+peek_handle(unsigned char *id)
 {
-        return;
+    return;
 }
 #endif /* DEBUG */
 
-glfs_t    *fs = NULL;
-char      *full_parent_name = "/testdir", *parent_name = "testdir";
+glfs_t *fs = NULL;
+char *full_parent_name = "/testdir", *parent_name = "testdir";
 
 void
-test_h_unlink (void)
+test_h_unlink(void)
 {
-        char               *my_dir = "unlinkdir";
-        char               *my_file = "file.txt";
-        char               *my_subdir = "dir1";
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
-                           *subdir = NULL, *subleaf = NULL;
-        struct stat         sb;
-        int                 ret;
-
-        printf ("glfs_h_unlink tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        subdir = glfs_h_mkdir (fs, dir, my_subdir, 0644, &sb);
-        if (subdir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_subdir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        subleaf = glfs_h_creat (fs, subdir, my_file, O_CREAT, 0644, &sb);
-        if (subleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non empty directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
-                         my_subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink regular file */
-        ret = glfs_h_unlink (fs, subdir, my_file);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_file, subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_subdir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink regular file */
-        ret = glfs_h_unlink (fs, dir, my_file);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non-existent regular file */
-        ret = glfs_h_unlink (fs, dir, my_file);
-        if ((ret && errno != ENOENT) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking non-existent %s: invalid errno ,%d, %s\n",
-                         my_file, ret, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non-existent directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if ((ret && errno != ENOENT) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking non-existent %s:  invalid errno ,%d, %s\n",
-                         my_subdir, ret, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink directory */
-        ret = glfs_h_unlink (fs, parent, my_dir);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_unlink tests: PASSED\n");
+    char *my_dir = "unlinkdir";
+    char *my_file = "file.txt";
+    char *my_subdir = "dir1";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
+                       *subdir = NULL, *subleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_unlink tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subdir = glfs_h_mkdir(fs, dir, my_subdir, 0755, &sb);
+    if (subdir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subleaf = glfs_h_creat(fs, subdir, my_file, O_CREAT, 0644, &sb);
+    if (subleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non empty directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
+                my_subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, subdir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s: invalid errno "
+                ",%d, %s\n",
+                my_file, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s:  invalid "
+                "errno ,%d, %s\n",
+                my_subdir, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, parent, my_dir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_dir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_unlink tests: PASSED\n");
 
 out:
-        if (dir)
-                glfs_h_close (dir);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (subdir)
-                glfs_h_close (subdir);
-        if (subleaf)
-                glfs_h_close (subleaf);
-        if (parent)
-                glfs_h_close (parent);
-
-        return;
+    if (dir)
+        glfs_h_close(dir);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (subdir)
+        glfs_h_close(subdir);
+    if (subleaf)
+        glfs_h_close(subleaf);
+    if (parent)
+        glfs_h_close(parent);
+
+    return;
 }
 
 void
-test_h_getsetattrs (void)
+test_h_getsetattrs(void)
 {
-        char               *my_dir = "attrdir";
-        char               *my_file = "attrfile.txt";
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
-        struct stat         sb, retsb;
-        int                 ret, valid;
-        struct timespec     timestamp;
-
-        printf("glfs_h_getattrs and setattrs tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = glfs_h_getattrs (fs, dir, &retsb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&retsb);
-        /* TODO: Compare stat information */
-
-        retsb.st_mode = 00666;
-        retsb.st_uid = 1000;
-        retsb.st_gid = 1001;
-        ret = clock_gettime (CLOCK_REALTIME, &timestamp);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        retsb.st_atim = timestamp;
-        retsb.st_mtim = timestamp;
-        valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
-        GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
-        peek_stat (&retsb);
-
-        ret = glfs_h_setattrs (fs, dir, &retsb, valid);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_setattrs: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-
-        memset(&retsb, 0, sizeof (struct stat));
-        ret = glfs_h_stat (fs, dir, &retsb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_stat: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&retsb);
-
-        printf ("glfs_h_getattrs and setattrs tests: PASSED\n");
+    char *my_dir = "attrdir";
+    char *my_file = "attrfile.txt";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb, retsb;
+    int ret, valid;
+    struct timespec timestamp;
+
+    printf("glfs_h_getattrs and setattrs tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_getattrs(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+    /* TODO: Compare stat information */
+
+    retsb.st_mode = 00666;
+    retsb.st_uid = 1000;
+    retsb.st_gid = 1001;
+    ret = clock_gettime(CLOCK_REALTIME, &timestamp);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    retsb.st_atim = timestamp;
+    retsb.st_mtim = timestamp;
+    valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
+            GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
+    peek_stat(&retsb);
+
+    ret = glfs_h_setattrs(fs, dir, &retsb, valid);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_setattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    memset(&retsb, 0, sizeof(struct stat));
+    ret = glfs_h_stat(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_stat: error %s: from (%p),%s\n", my_dir, dir,
+                strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+
+    printf("glfs_h_getattrs and setattrs tests: PASSED\n");
 out:
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dir)
-                glfs_h_close (dir);
-
-        return;
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dir)
+        glfs_h_close(dir);
+
+    return;
 }
 
 void
-test_h_truncate (void)
+test_h_truncate(void)
 {
-        char               *my_dir = "truncatedir";
-        char               *my_file = "file.txt";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
-        struct stat         sb;
-        glfs_fd_t          *fd = NULL;
-        char                buf[32];
-        off_t               offset = 0;
-        int                 ret = 0;
-
-        printf("glfs_h_truncate tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         my_file, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        memcpy (buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, buf, 32, 0);
-
-        /* run tests */
-        /* truncate lower */
-        offset = 30;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        /* truncate higher */
-        offset = 32;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        /* truncate equal */
-        offset = 30;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_truncate tests: PASSED\n");
+    char *my_dir = "truncatedir";
+    char *my_file = "file.txt";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
+    struct stat sb;
+    glfs_fd_t *fd = NULL;
+    char buf[32];
+    off_t offset = 0;
+    int ret = 0;
+
+    printf("glfs_h_truncate tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n", my_file,
+                strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    memcpy(buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, buf, 32, 0);
+
+    /* run tests */
+    /* truncate lower */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate higher */
+    offset = 32;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate equal */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_truncate tests: PASSED\n");
 out:
-        if (fd)
-                glfs_close (fd);
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-
-        return;
+    if (fd)
+        glfs_close(fd);
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return;
 }
 
 void
-test_h_links (void)
+test_h_links(void)
 {
-        char               *my_dir = "linkdir";
-        char               *my_file = "file.txt";
-        char               *my_symlnk = "slnk.txt";
-        char               *my_lnk = "lnk.txt";
-        char               *linksrc_dir = "dir1";
-        char               *linktgt_dir = "dir2";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
-        struct glfs_object *ln1 = NULL;
-        struct stat         sb;
-        int                 ret;
-        char               *buf = NULL;
-
-        printf("glfs_h_link(s) tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirsrc = glfs_h_mkdir (fs, parent, linksrc_dir, 0644, &sb);
-        if (dirsrc == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         linksrc_dir, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirtgt = glfs_h_mkdir (fs, parent, linktgt_dir, 0644, &sb);
-        if (dirtgt == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         linktgt_dir, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
-        if (dleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dirsrc, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* run tests */
-        /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
-        ln1 = glfs_h_symlink (fs, parent, my_symlnk, "./file.txt", &sb);
-        if (ln1 == NULL) {
-                fprintf (stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
-                         my_symlnk, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        buf = calloc (1024, sizeof(char));
-        if (buf == NULL) {
-                fprintf (stderr, "Error allocating memory\n");
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-
-        ret = glfs_h_readlink (fs, ln1, buf, 1024);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
-                         my_symlnk, ln1, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        if (!(strncmp (buf, my_symlnk, strlen (my_symlnk)))) {
-                fprintf (stderr, "glfs_h_readlink: error mismatch in link name: actual %s: retrieved %s\n",
-                         my_symlnk, buf);
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-
-        /* link: /testdir/linkdir/file.txt to ./lnk.txt */
-        ret = glfs_h_link (fs, leaf, parent, my_lnk);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
-                         my_lnk, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        /* TODO: Should write content to a file and read from the link */
-
-        /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
-        ret = glfs_h_link (fs, dleaf, dirtgt, my_lnk);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
-                         my_lnk, dirtgt, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        /* TODO: Should write content to a file and read from the link */
-
-        printf ("glfs_h_link(s) tests: PASSED\n");
+    char *my_dir = "linkdir";
+    char *my_file = "file.txt";
+    char *my_symlnk = "slnk.txt";
+    char *my_lnk = "lnk.txt";
+    char *linksrc_dir = "dir1";
+    char *linktgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct glfs_object *ln1 = NULL;
+    struct stat sb;
+    int ret;
+    char *buf = NULL;
+
+    printf("glfs_h_link(s) tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, linksrc_dir, 0755, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linksrc_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, linktgt_dir, 0755, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linktgt_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
+    ln1 = glfs_h_symlink(fs, parent, my_symlnk, "./file.txt", &sb);
+    if (ln1 == NULL) {
+        fprintf(stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
+                my_symlnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    buf = calloc(1024, sizeof(char));
+    if (buf == NULL) {
+        fprintf(stderr, "Error allocating memory\n");
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    ret = glfs_h_readlink(fs, ln1, buf, 1024);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
+                my_symlnk, ln1, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    if (!(strncmp(buf, my_symlnk, strlen(my_symlnk)))) {
+        fprintf(stderr,
+                "glfs_h_readlink: error mismatch in link name: actual %s: "
+                "retrieved %s\n",
+                my_symlnk, buf);
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    /* link: /testdir/linkdir/file.txt to ./lnk.txt */
+    ret = glfs_h_link(fs, leaf, parent, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
+    ret = glfs_h_link(fs, dleaf, dirtgt, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, dirtgt, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    printf("glfs_h_link(s) tests: PASSED\n");
 
 out:
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dirsrc)
-                glfs_h_close (dirsrc);
-        if (dirtgt)
-                glfs_h_close (dirtgt);
-        if (dleaf)
-                glfs_h_close (dleaf);
-        if (ln1)
-                glfs_h_close (ln1);
-        if (buf)
-                free (buf);
-
-        return;
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+    if (ln1)
+        glfs_h_close(ln1);
+    if (buf)
+        free(buf);
+
+    return;
 }
 
 void
-test_h_rename (void)
+test_h_rename(void)
 {
-        char               *my_dir = "renamedir";
-        char               *my_file = "file.txt";
-        char               *src_dir = "dir1";
-        char               *tgt_dir = "dir2";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
-        struct stat         sb;
-        int                 ret;
-
-        printf("glfs_h_rename tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirsrc = glfs_h_mkdir (fs, parent, src_dir, 0644, &sb);
-        if (dirsrc == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         src_dir, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirtgt = glfs_h_mkdir (fs, parent, tgt_dir, 0644, &sb);
-        if (dirtgt == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         tgt_dir, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
-        if (dleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dirsrc, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* run tests */
-        /* Rename file.txt -> file1.txt */
-        ret = glfs_h_rename (fs, parent, "file.txt", parent, "file1.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "file.txt", "file1.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir1/file.txt -> file.txt */
-        ret = glfs_h_rename (fs, dirsrc, "file.txt", parent, "file.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
-                         src_dir, "file.txt", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename file1.txt -> file.txt (exists) */
-        ret = glfs_h_rename (fs, parent, "file1.txt", parent, "file.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "file.txt", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir1 -> dir3 */
-        ret = glfs_h_rename (fs, parent, "dir1", parent, "dir3");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "dir1", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir2 ->dir3 (exists) */
-        ret = glfs_h_rename (fs, parent, "dir2", parent, "dir3");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "dir2", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename file.txt -> dir3 (fail) */
-        ret = glfs_h_rename (fs, parent, "file.txt", parent, "dir3");
-        if (ret == 0) {
-                fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
-                         "file.txt", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir3 -> file.txt (fail) */
-        ret = glfs_h_rename (fs, parent, "dir3", parent, "file.txt");
-        if (ret == 0) {
-                fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
-                         "dir3", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_rename tests: PASSED\n");
+    char *my_dir = "renamedir";
+    char *my_file = "file.txt";
+    char *src_dir = "dir1";
+    char *tgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_rename tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, src_dir, 0755, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                src_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, tgt_dir, 0755, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                tgt_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* Rename file.txt -> file1.txt */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "file1.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file1.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1/file.txt -> file.txt */
+    ret = glfs_h_rename(fs, dirsrc, "file.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
+                src_dir, "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file1.txt -> file.txt (exists) */
+    ret = glfs_h_rename(fs, parent, "file1.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1 -> dir3 */
+    ret = glfs_h_rename(fs, parent, "dir1", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir1",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir2 ->dir3 (exists) */
+    ret = glfs_h_rename(fs, parent, "dir2", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir2",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file.txt -> dir3 (fail) */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "dir3");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "file.txt", "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir3 -> file.txt (fail) */
+    ret = glfs_h_rename(fs, parent, "dir3", parent, "file.txt");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "dir3", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_rename tests: PASSED\n");
 
 out:
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dirsrc)
-                glfs_h_close (dirsrc);
-        if (dirtgt)
-                glfs_h_close (dirtgt);
-        if (dleaf)
-                glfs_h_close (dleaf);
-
-        return;
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+
+    return;
 }
 
 void
-assimilatetime (struct timespec *ts, struct timespec ts_st,
-                struct timespec ts_ed)
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
 {
-        if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
-                ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
-        } else {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
-                ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
-        }
-
-        if (ts->tv_nsec > 1000000000) {
-                ts->tv_nsec = ts->tv_nsec - 1000000000;
-                ts->tv_sec += 1;
-        }
-
-        return;
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
 }
 
 #define MAX_FILES_CREATE 10
-#define MAXPATHNAME      512
+#define MAXPATHNAME 512
 void
-test_h_performance (void)
+test_h_performance(void)
 {
-        char               *my_dir = "perftest",
-                           *full_dir_path="/testdir/perftest";
-        char               *my_file = "file_", my_file_name[MAXPATHNAME];
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
-        struct stat         sb;
-        int                 ret, i;
-        struct glfs_fd     *fd;
-        struct timespec     c_ts = {0, 0}, c_ts_st, c_ts_ed;
-        struct timespec     o_ts = {0, 0}, o_ts_st, o_ts_ed;
-
-        printf("glfs_h_performance tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* create performance */
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+    char *my_dir = "perftest", *full_dir_path = "/testdir/perftest";
+    char *my_file = "file_", my_file_name[MAXPATHNAME];
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb;
+    int ret, i;
+    struct glfs_fd *fd;
+    struct timespec c_ts = {0, 0}, c_ts_st, c_ts_ed;
+    struct timespec o_ts = {0, 0}, o_ts_st, o_ts_ed;
+
+    printf("glfs_h_performance tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* create performance */
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
         }
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s%d", my_file, i);
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                leaf = glfs_h_lookupat (fs, dir, my_file_name, &sb, 0);
-                if (leaf != NULL) {
-                        fprintf (stderr, "glfs_h_lookup: exists %s\n",
-                                 my_file_name);
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                leaf = glfs_h_creat (fs, dir, my_file_name, O_CREAT, 0644, &sb);
-                if (leaf == NULL) {
-                        fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                                 my_file, dir, strerror (errno));
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                assimilatetime (&c_ts, c_ts_st, c_ts_ed);
-                glfs_h_close (leaf); leaf = NULL;
+        leaf = glfs_h_lookupat(fs, dir, my_file_name, &sb, 0);
+        if (leaf != NULL) {
+            fprintf(stderr, "glfs_h_lookup: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+        leaf = glfs_h_creat(fs, dir, my_file_name, O_CREAT, 0644, &sb);
+        if (leaf == NULL) {
+            fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        assimilatetime (&o_ts, o_ts_st, o_ts_ed);
-
-        printf ("Creation performance (handle based):\n\t# empty files:%d\n",
-                MAX_FILES_CREATE);
-        printf ("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                o_ts.tv_sec, o_ts.tv_nsec);
-        printf ("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                c_ts.tv_sec, c_ts.tv_nsec);
-
-        /* create using path */
-        c_ts.tv_sec = o_ts.tv_sec = 0;
-        c_ts.tv_nsec = o_ts.tv_nsec = 0;
-
-        sprintf (my_file_name, "%s1", full_dir_path);
-        ret = glfs_mkdir (fs, my_file_name, 0644);
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
         if (ret != 0) {
-                fprintf (stderr, "glfs_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_h_close(leaf);
+        leaf = NULL;
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (handle based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
+
+    /* create using path */
+    c_ts.tv_sec = o_ts.tv_sec = 0;
+    c_ts.tv_nsec = o_ts.tv_nsec = 0;
+
+    sprintf(my_file_name, "%s1", full_dir_path);
+    ret = glfs_mkdir(fs, my_file_name, 0755);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_mkdir: error creating %s: from (%p),%s\n", my_dir,
+                parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
         }
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = glfs_stat (fs, my_file_name, &sb);
-                if (ret == 0) {
-                        fprintf (stderr, "glfs_stat: exists %s\n",
-                                 my_file_name);
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                fd = glfs_creat (fs, my_file_name, O_CREAT, 0644);
-                if (fd == NULL) {
-                        fprintf (stderr, "glfs_creat: error creating %s: from (%p),%s\n",
-                                 my_file, dir, strerror (errno));
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                assimilatetime (&c_ts, c_ts_st, c_ts_ed);
-                glfs_close (fd);
+        ret = glfs_stat(fs, my_file_name, &sb);
+        if (ret == 0) {
+            fprintf(stderr, "glfs_stat: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+        fd = glfs_creat(fs, my_file_name, O_CREAT, 0644);
+        if (fd == NULL) {
+            fprintf(stderr, "glfs_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        assimilatetime (&o_ts, o_ts_st, o_ts_ed);
-
-        printf ("Creation performance (path based):\n\t# empty files:%d\n",
-                MAX_FILES_CREATE);
-        printf ("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                o_ts.tv_sec, o_ts.tv_nsec);
-        printf ("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                c_ts.tv_sec, c_ts.tv_nsec);
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_close(fd);
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (path based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
 out:
-        return;
+    return;
 }
 
 int
-test_handleops (int argc, char *argv[])
+test_handleops(int argc, char *argv[])
 {
-        int                 ret = 0;
-        glfs_fd_t          *fd = NULL;
-        struct stat         sb = {0, };
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *tmp = NULL;
-        char                readbuf[32], writebuf[32];
-        unsigned char       leaf_handle[GFAPI_HANDLE_LENGTH];
-
-        char *full_leaf_name = "/testdir/testfile.txt",
-             *leaf_name = "testfile.txt",
-             *relative_leaf_name = "testdir/testfile.txt";
-        char *leaf_name1 = "testfile1.txt";
-        char *full_newparent_name = "/testdir/dir1",
-             *newparent_name = "dir1";
-        char *full_newnod_name = "/testdir/nod1",
-             *newnod_name = "nod1";
-
-        /* Initialize test area */
-        ret = glfs_mkdir (fs, full_parent_name, 0644);
-        if (ret != 0 && errno != EEXIST) {
-                fprintf (stderr, "%s: (%p) %s\n", full_parent_name, fd,
-                        strerror (errno));
-                printf ("Test initialization failed on volume %s\n", argv[1]);
-                goto out;
-        }
-        else if (ret != 0) {
-                printf ("Found test directory %s to be existing\n",
-                        full_parent_name);
-                printf ("Cleanup test directory and restart tests\n");
-                goto out;
-        }
-
-        fd = glfs_creat (fs, full_leaf_name, O_CREAT, 0644);
-        if (fd == NULL) {
-                fprintf (stderr, "%s: (%p) %s\n", full_leaf_name, fd,
-                        strerror (errno));
-                printf ("Test initialization failed on volume %s\n", argv[1]);
-                goto out;
-        }
-        glfs_close (fd);
-
-        printf ("Initialized the test area, within volume %s\n", argv[1]);
-
-        /* Handle based APIs test area */
-
-        /* glfs_lookupat test */
-        printf ("glfs_h_lookupat tests: In Progress\n");
-        /* start at root of the volume */
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         "/", NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* lookup a parent within root */
-        parent = glfs_h_lookupat (fs, root, parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         parent_name, root, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* lookup a leaf/child within the parent */
-        leaf = glfs_h_lookupat (fs, parent, leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         leaf_name, parent, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (root); root = NULL;
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        /* check absolute paths */
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         "/", NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_lookupat (fs, NULL, full_leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_leaf_name, parent, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (leaf); leaf = NULL;
-
-        /* check multiple component paths */
-        leaf = glfs_h_lookupat (fs, root, relative_leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         relative_leaf_name, parent, strerror (errno));
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (root); root = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        /* check symlinks in path */
-
-        /* TODO: -ve test cases */
-        /* parent invalid
-        * path invalid
-        * path does not exist after some components
-        * no parent, but relative path
-        * parent and full path? -ve?
-        */
-
-        printf ("glfs_h_lookupat tests: PASSED\n");
-
-        /* glfs_openat test */
-        printf ("glfs_h_open tests: In Progress\n");
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_open tests: FAILED\n");
-                goto out;
-        }
-
-        /* test read/write based on fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, writebuf, 32, 0);
-
-        glfs_lseek (fd, 0, SEEK_SET);
-
-        ret = glfs_read (fd, readbuf, 32, 0);
-        if (memcmp (readbuf, writebuf, 32)) {
-                printf ("Failed to read what I wrote: %s %s\n", readbuf,
-                        writebuf);
-                glfs_close (fd);
-                printf ("glfs_h_open tests: FAILED\n");
-                goto out;
-        }
-
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_close (fd);
-
-        printf ("glfs_h_open tests: PASSED\n");
-
-        /* Create tests */
-        printf ("glfs_h_creat tests: In Progress\n");
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
-                         leaf_name1, parent, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644,
-                            &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_creat: existing file, leaf = (%p), errno = %s\n",
-                        leaf, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
-
-        tmp = glfs_h_creat (fs, root, parent_name, O_CREAT, 0644, &sb);
-        if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
-                fprintf (stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
-                        leaf, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                if (tmp != NULL) {
-                        glfs_h_close (tmp); tmp = NULL;
-                }
-        }
-
-        /* TODO: Other combinations and -ve cases as applicable */
-        printf ("glfs_h_creat tests: PASSED\n");
-
-        /* extract handle and create from handle test */
-        printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: In Progress\n");
-        /* TODO: Change the lookup to creat below for a GIFD recovery falure,
-         * that needs to be fixed */
-        leaf = glfs_h_lookupat (fs, parent, leaf_name1, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         leaf_name1, parent, strerror (errno));
-                printf ("glfs_h_extract_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = glfs_h_extract_handle (leaf, leaf_handle,
-                                             GFAPI_HANDLE_LENGTH);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_extract_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_handle (leaf_handle);
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL, *tmp = NULL;
+    char readbuf[32], writebuf[32];
+    unsigned char leaf_handle[GFAPI_HANDLE_LENGTH];
+
+    char *full_leaf_name = "/testdir/testfile.txt", *leaf_name = "testfile.txt",
+         *relative_leaf_name = "testdir/testfile.txt";
+    char *leaf_name1 = "testfile1.txt";
+    char *full_newparent_name = "/testdir/dir1", *newparent_name = "dir1";
+    char *full_newnod_name = "/testdir/nod1", *newnod_name = "nod1";
+
+    /* Initialize test area */
+    ret = glfs_mkdir(fs, full_parent_name, 0755);
+    if (ret != 0 && errno != EEXIST) {
+        fprintf(stderr, "%s: (%p) %s\n", full_parent_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    } else if (ret != 0) {
+        printf("Found test directory %s to be existing\n", full_parent_name);
+        printf("Cleanup test directory and restart tests\n");
+        goto out;
+    }
+
+    fd = glfs_creat(fs, full_leaf_name, O_CREAT, 0644);
+    if (fd == NULL) {
+        fprintf(stderr, "%s: (%p) %s\n", full_leaf_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    }
+    glfs_close(fd);
+
+    printf("Initialized the test area, within volume %s\n", argv[1]);
+
+    /* Handle based APIs test area */
+
+    /* glfs_lookupat test */
+    printf("glfs_h_lookupat tests: In Progress\n");
+    /* start at root of the volume */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a parent within root */
+    parent = glfs_h_lookupat(fs, root, parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a leaf/child within the parent */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check absolute paths */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_lookupat(fs, NULL, full_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    /* check multiple component paths */
+    leaf = glfs_h_lookupat(fs, root, relative_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                relative_leaf_name, parent, strerror(errno));
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check symlinks in path */
+
+    /* TODO: -ve test cases */
+    /* parent invalid
+     * path invalid
+     * path does not exist after some components
+     * no parent, but relative path
+     * parent and full path? -ve?
+     */
+
+    printf("glfs_h_lookupat tests: PASSED\n");
+
+    /* glfs_openat test */
+    printf("glfs_h_open tests: In Progress\n");
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 0, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", readbuf, writebuf);
+        glfs_close(fd);
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_close(fd);
+
+    printf("glfs_h_open tests: PASSED\n");
+
+    /* Create tests */
+    printf("glfs_h_creat tests: In Progress\n");
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_creat: existing file, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    tmp = glfs_h_creat(fs, root, parent_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
+        fprintf(stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (tmp != NULL) {
+            glfs_h_close(tmp);
+            tmp = NULL;
+        }
+    }
+
+    /* TODO: Other combinations and -ve cases as applicable */
+    printf("glfs_h_creat tests: PASSED\n");
+
+    /* extract handle and create from handle test */
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: In "
+        "Progress\n");
+    /* TODO: Change the lookup to create below for a GIFD recovery failure,
+     * that needs to be fixed */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name1, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_extract_handle(leaf, leaf_handle, GFAPI_HANDLE_LENGTH);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_handle(leaf_handle);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_create_from_handle(fs, leaf_handle, GFAPI_HANDLE_LENGTH, &sb);
+    if (leaf == NULL) {
+        fprintf(
+            stderr,
+            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+            leaf_name1, leaf_handle, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 0, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", writebuf, writebuf);
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        glfs_close(fd);
+        goto out;
+    }
+
+    glfs_close(fd);
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
+
+    /* Mkdir tests */
+    printf("glfs_h_mkdir tests: In Progress\n");
+
+    ret = glfs_rmdir(fs, full_newparent_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_rmdir: Failed for %s: %s\n", full_newparent_name,
+                strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newparent_name, parent, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mkdir tests: PASSED\n");
+
+    /* Mknod tests */
+    printf("glfs_h_mknod tests: In Progress\n");
+    ret = glfs_unlink(fs, full_newnod_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_unlink: Failed for %s: %s\n", full_newnod_name,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, S_IFIFO, 0, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newnod_name, parent, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* TODO: create op on a FIFO node hangs, need to check and fix
+    tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || errno != EINVAL) {
+            fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno =
+    %s\n", tmp, strerror (errno)); printf ("glfs_h_creat/mknod tests:
+    FAILED\n"); if (tmp != NULL) { glfs_h_close(tmp); tmp = NULL;
+            }
+    } */
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, 0644, 0, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mknod tests: PASSED\n");
+
+    /* unlink tests */
+    test_h_unlink();
+
+    /* TODO: opendir tests */
+
+    /* getattr tests */
+    test_h_getsetattrs();
+
+    /* TODO: setattr tests */
+
+    /* truncate tests */
+    test_h_truncate();
+
+    /* link tests */
+    test_h_links();
+
+    /* rename tests */
+    test_h_rename();
+
+    /* performance tests */
+    test_h_performance();
+
+    /* END: New APIs test area */
 
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_create_from_handle (fs, leaf_handle, GFAPI_HANDLE_LENGTH,
-                                          &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
-                         leaf_name1, leaf_handle, strerror (errno));
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                goto out;
-        }
-
-        /* test read/write based on fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, writebuf, 32, 0);
-
-        glfs_lseek (fd, 0, SEEK_SET);
-
-        ret = glfs_read (fd, readbuf, 32, 0);
-        if (memcmp (readbuf, writebuf, 32)) {
-                printf ("Failed to read what I wrote: %s %s\n", writebuf,
-                        writebuf);
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                glfs_close (fd);
-                goto out;
-        }
-
-        glfs_close (fd);
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
-
-        /* Mkdir tests */
-        printf ("glfs_h_mkdir tests: In Progress\n");
+out:
+    /* Cleanup glfs handles */
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return ret;
+}
 
-        ret = glfs_rmdir (fs, full_newparent_name);
-        if (ret && errno != ENOENT) {
-                fprintf (stderr, "glfs_rmdir: Failed for %s: %s\n",
-                         full_newparent_name, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
+int
+test_write_apis(glfs_t *fs)
+{
+    /* Add more content here */
+    /* Some apis we can get are */
+    /*
+      0. glfs_set_xlator_option()
+
+      Read/Write combinations:
+      . glfs_{p,}readv/{p,}writev
+      . glfs_pread/pwrite
+
+      tests/basic/gfapi/gfapi-async-calls-test.c
+      . glfs_read_async/write_async
+      . glfs_pread_async/pwrite_async
+      . glfs_readv_async/writev_async
+      . glfs_preadv_async/pwritev_async
+
+      . ftruncate/ftruncate_async
+      . fsync/fsync_async
+      . fdatasync/fdatasync_async
+
+    */
+
+    glfs_fd_t *fd = NULL;
+    char *filename = "/filename2";
+    int flags = O_RDWR;
+    char *buf = "some bytes!";
+    char writestr[TEST_STR_LEN];
+    struct iovec iov = {&writestr, TEST_STR_LEN};
+    int ret, i;
+
+    for (i = 0; i < TEST_STR_LEN; i++)
+        writestr[i] = 0x11;
+
+    fd = glfs_open(fs, filename, flags);
+    if (!fd)
+        fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    ret = glfs_writev(fd, &iov, 1, flags);
+    if (ret < 0) {
+        fprintf(stderr, "writev(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    ret = glfs_pwrite(fd, buf, 10, 4, flags, NULL, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "pwrite(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    ret = glfs_pwritev(fd, &iov, 1, 4, flags);
+    if (ret < 0) {
+        fprintf(stderr, "pwritev(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    return 0;
+}
 
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
+int
+test_metadata_ops(glfs_t *fs, glfs_t *fs2)
+{
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_stat gsb = {
+        0,
+    };
+    struct statvfs sfs;
+    char readbuf[32];
+    char writebuf[32];
 
-        leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
-                         newparent_name, parent, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
-                         leaf, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
+    char *filename = "/filename2";
+    int ret;
 
-        glfs_h_close (parent); parent = NULL;
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-        printf ("glfs_h_mkdir tests: PASSED\n");
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    fprintf(stderr, "creat(%s): (%p) %s\n", filename, fd, strerror(errno));
 
-        /* Mknod tests */
-        printf ("glfs_h_mknod tests: In Progress\n");
-        ret = glfs_unlink (fs, full_newnod_name);
-        if (ret && errno != ENOENT) {
-                fprintf (stderr, "glfs_unlink: Failed for %s: %s\n",
-                         full_newnod_name, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
+    fd2 = glfs_open(fs2, filename, O_RDWR);
+    fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
 
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
+    glfs_lseek(fd2, 0, SEEK_SET);
 
-        leaf = glfs_h_mknod (fs, parent, newnod_name, S_IFIFO, 0, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
-                         newnod_name, parent, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* TODO: creat op on a FIFO node hangs, need to check and fix
-        tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
-        if (tmp != NULL || errno != EINVAL) {
-                fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno = %s\n",
-                        tmp, strerror (errno));
-                printf ("glfs_h_creat/mknod tests: FAILED\n");
-                if (tmp != NULL) {
-                        glfs_h_close(tmp); tmp = NULL;
-                }
-        } */
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_mknod (fs, parent, newnod_name, 0644, 0, &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n",
-                         leaf, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
+    ret = glfs_read(fd2, readbuf, 32, 0);
 
-        glfs_h_close (parent); parent = NULL;
+    printf("read %d, %s", ret, readbuf);
 
-        printf ("glfs_h_mknod tests: PASSED\n");
+    /* get stat */
+    ret = glfs_fstat(fd2, &sb);
 
-        /* unlink tests */
-        test_h_unlink ();
+    ret = glfs_access(fs, filename, R_OK);
 
-        /* TODO: opendir tests */
+    /* set stat */
+    /* TODO: got some errors, need to fix */
+    /* ret = glfs_fsetattr(fd2, &gsb); */
 
-        /* getattr tests */
-        test_h_getsetattrs ();
+    glfs_close(fd);
+    glfs_close(fd2);
 
-        /* TODO: setattr tests */
+    filename = "/filename3";
+    ret = glfs_mknod(fs, filename, S_IFIFO, 0);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        /* truncate tests */
-        test_h_truncate();
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        /* link tests */
-        test_h_links ();
+    ret = glfs_rename(fs, filename, "/filename4");
+    fprintf(stderr, "rename(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-        /* rename tests */
-        test_h_rename ();
+    ret = glfs_unlink(fs, "/filename4");
+    fprintf(stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
+            strerror(errno));
 
-        /* performance tests */
-        test_h_performance ();
+    filename = "/dirname2";
+    ret = glfs_mkdir(fs, filename, 0);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        /* END: New APIs test area */
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-out:
-        /* Cleanup glfs handles */
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-
-        return ret;
+    ret = glfs_rmdir(fs, filename);
+    fprintf(stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror(errno));
 }
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs2 = NULL;
-        int        ret = 0;
-        glfs_fd_t *fd = NULL;
-        glfs_fd_t *fd2 = NULL;
-        struct stat sb = {0, };
-        char       readbuf[32];
-        char       writebuf[32];
-
-        char      *filename = "/filename2";
-
-        if (argc != 3) {
-                printf ("Expect following args\n\t%s <volname> <hostname>\n", argv[0]);
-                return -1;
-        }
-
-        fs = glfs_new (argv[1]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-//      ret = glfs_set_volfile (fs, "/tmp/posix.vol");
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[2], 24007);
-
-//      ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
-
-        ret = glfs_set_logging (fs, "/dev/stderr", 7);
+    glfs_t *fs2 = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_stat gsb = {
+        0,
+    };
+    struct statvfs sfs;
+    char readbuf[32];
+    char writebuf[32];
 
-        ret = glfs_init (fs);
+    char *filename = "/filename2";
 
-        fprintf (stderr, "glfs_init: returned %d\n", ret);
+    if (argc != 3) {
+        printf("Expect following args\n\t%s <volname> <hostname>\n", argv[0]);
+        return -1;
+    }
 
-        sleep (2);
+    fs = glfs_new(argv[1]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        fs2 = glfs_new (argv[1]);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-
-//      ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
-
-        ret = glfs_set_volfile_server (fs2, "tcp", argv[2], 24007);
+    //      ret = glfs_set_volfile (fs, "/tmp/posix.vol");
 
-        ret = glfs_set_logging (fs2, "/dev/stderr", 7);
+    ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
 
-        ret = glfs_init (fs2);
+    //      ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
 
-        fprintf (stderr, "glfs_init: returned %d\n", ret);
+    ret = glfs_set_logging(fs, "/dev/stderr", 7);
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    ret = glfs_init(fs);
 
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
+    fprintf(stderr, "glfs_init: returned %d\n", ret);
 
-        fd2 = glfs_open (fs2, filename, O_RDWR);
-        fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
+    if (ret)
+        goto out;
 
-        sprintf (writebuf, "hi there\n");
-        ret = glfs_write (fd, writebuf, 32, 0);
+    sleep(2);
 
-        glfs_lseek (fd2, 0, SEEK_SET);
+    fs2 = glfs_new(argv[1]);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_read (fd2, readbuf, 32, 0);
+    //      ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
 
-        printf ("read %d, %s", ret, readbuf);
+    ret = glfs_set_volfile_server(fs2, "tcp", argv[2], 24007);
 
-        glfs_close (fd);
-        glfs_close (fd2);
+    ret = glfs_set_logging(fs2, "/dev/stderr", 7);
 
-        filename = "/filename3";
-        ret = glfs_mknod (fs, filename, S_IFIFO, 0);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    ret = glfs_init(fs2);
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    fprintf(stderr, "glfs_init: returned %d\n", ret);
 
+    test_metadata_ops(fs, fs2);
 
-        ret = glfs_rename (fs, filename, "/filename4");
-        fprintf (stderr, "rename(%s): (%d) %s\n", filename, ret,
-                 strerror (errno));
+    test_dirops(fs);
 
-        ret = glfs_unlink (fs, "/filename4");
-        fprintf (stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
-                 strerror (errno));
+    test_xattr(fs);
 
-        filename = "/dirname2";
-        ret = glfs_mkdir (fs, filename, 0);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    test_chdir(fs);
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror (errno));
+    test_handleops(argc, argv);
+    // done
 
-        ret = glfs_rmdir (fs, filename);
-        fprintf (stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror (errno));
+    /* Test some extra apis */
+    test_write_apis(fs);
 
-        test_dirops (fs);
+    glfs_statvfs(fs, "/", &sfs);
 
-        test_xattr (fs);
+    glfs_fini(fs);
+    glfs_fini(fs2);
 
-        test_chdir (fs);
-
-        test_handleops (argc, argv);
-        // done
-
-        glfs_fini (fs);
-        glfs_fini (fs2);
-
-        return ret;
+    ret = 0;
+out:
+    return ret;
 }
diff --git a/api/src/Makefile.am b/api/src/Makefile.am
index 625183c8dbc..7f9a7d17b35 100644
--- a/api/src/Makefile.am
+++ b/api/src/Makefile.am
@@ -9,21 +9,20 @@ libgfapi_la_SOURCES = glfs.c glfs-mgmt.c glfs-fops.c glfs-resolve.c \
 	glfs-handleops.c
 libgfapi_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 	$(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
-	$(top_builddir)/rpc/xdr/src/libgfxdr.la \
-	$(GF_LDADD)
+	$(top_builddir)/rpc/xdr/src/libgfxdr.la
+
+libgfapi_la_LDFLAGS = -version-info $(GFAPI_LT_VERSION) $(GF_LDFLAGS) \
+	$(GFAPI_EXTRA_LDFLAGS) $(ACL_LIBS)
 
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
+libgfapi_la_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
         -I$(top_srcdir)/rpc/rpc-lib/src \
         -I$(top_srcdir)/rpc/xdr/src \
         -I$(top_builddir)/rpc/xdr/src \
         -DDATADIR=\"$(localstatedir)\" \
-        -D__USE_FILE_OFFSET64
+        -D__USE_FILE_OFFSET64 -D__USE_LARGEFILE64
 
 AM_CFLAGS = -Wall $(GF_CFLAGS)
 
-libgfapi_la_LDFLAGS = -version-info $(GFAPI_LT_VERSION) \
-	$(GFAPI_EXTRA_LDFLAGS) $(ACL_LIBS)
-
 xlator_LTLIBRARIES = api.la
 xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/mount
 # workaround for broken parallel install support in automake with LTLIBRARIES
@@ -33,9 +32,12 @@ $(install_xlatorLTLIBRARIES): install-libLTLIBRARIES
 
 api_la_SOURCES = glfs-master.c
 api_la_DEPENDENCIES = libgfapi.la
+api_la_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
+	-I$(top_srcdir)/rpc/xdr/src \
+	-I$(top_builddir)/rpc/xdr/src
 api_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
+#api_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS) $(GF_LDFLAGS)
 api_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 	$(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
 	$(top_builddir)/rpc/xdr/src/libgfxdr.la \
 	$(top_builddir)/api/src/libgfapi.la
-
diff --git a/api/src/README.Symbol_Versions b/api/src/README.Symbol_Versions
index d5cdedd826b..b6ec95f9311 100644
--- a/api/src/README.Symbol_Versions
+++ b/api/src/README.Symbol_Versions
@@ -1,3 +1,3 @@
 
-See .../doc/gfapi-symbol-versions/gfapi-symbol-versions.md
+See ../../doc/developer-guide/gfapi-symbol-versions.md
 
diff --git a/api/src/gfapi-messages.h b/api/src/gfapi-messages.h
index 6fcbd9d392e..b9223940416 100644
--- a/api/src/gfapi-messages.h
+++ b/api/src/gfapi-messages.h
@@ -1,5 +1,5 @@
 /*
- *   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+ *   Copyright (c) 2015-2018 Red Hat, Inc. <http://www.redhat.com>
  *   This file is part of GlusterFS.
  *
  *   This file is licensed to you under your choice of the GNU Lesser
@@ -11,93 +11,137 @@
 #ifndef _GFAPI_MESSAGES_H__
 #define _GFAPI_MESSAGES_H__
 
-#include "glfs-message-id.h"
+#include <glusterfs/glfs-message-id.h>
 
-/*! \file gfapi-messages.h
- *  \brief libgfapi log-message IDs and their descriptions
- */
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
  */
 
-#define GLFS_GFAPI_BASE             GLFS_MSGID_COMP_API
-#define GLFS_NUM_MESSAGES           50
-#define GLFS_MSGID_END              (GLFS_GFAPI_BASE + GLFS_NUM_MESSAGES + 1)
-/* Messages with message IDs */
-#define glfs_msg_start_x GLFS_GFAPI_BASE, "Invalid: Start of messages"
-/*------------*/
-
-#define API_MSG_MEM_ACCT_INIT_FAILED            (GLFS_GFAPI_BASE + 1)
-#define API_MSG_MASTER_XLATOR_INIT_FAILED       (GLFS_GFAPI_BASE + 2)
-#define API_MSG_GFAPI_XLATOR_INIT_FAILED        (GLFS_GFAPI_BASE + 3)
-#define API_MSG_VOLFILE_OPEN_FAILED             (GLFS_GFAPI_BASE + 4)
-#define API_MSG_VOL_SPEC_FILE_ERROR             (GLFS_GFAPI_BASE + 5)
-#define API_MSG_GLFS_FSOBJ_NULL                 (GLFS_GFAPI_BASE + 6)
-#define API_MSG_INVALID_ENTRY                   (GLFS_GFAPI_BASE + 7)
-#define API_MSG_FSMUTEX_LOCK_FAILED             (GLFS_GFAPI_BASE + 8)
-#define API_MSG_COND_WAIT_FAILED                (GLFS_GFAPI_BASE + 9)
-#define API_MSG_FSMUTEX_UNLOCK_FAILED           (GLFS_GFAPI_BASE + 10)
-#define API_MSG_INODE_REFRESH_FAILED            (GLFS_GFAPI_BASE + 11)
-#define API_MSG_GRAPH_CONSTRUCT_FAILED          (GLFS_GFAPI_BASE + 12)
-#define API_MSG_API_XLATOR_ERROR                (GLFS_GFAPI_BASE + 13)
-#define API_MSG_XDR_PAYLOAD_FAILED              (GLFS_GFAPI_BASE + 14)
-#define API_MSG_GET_VOLINFO_CBK_FAILED          (GLFS_GFAPI_BASE + 15)
-#define API_MSG_FETCH_VOLUUID_FAILED            (GLFS_GFAPI_BASE + 16)
-#define API_MSG_INSUFF_SIZE                     (GLFS_GFAPI_BASE + 17)
-#define API_MSG_FRAME_CREAT_FAILED              (GLFS_GFAPI_BASE + 18)
-#define API_MSG_DICT_SET_FAILED                 (GLFS_GFAPI_BASE + 19)
-#define API_MSG_XDR_DECODE_FAILED               (GLFS_GFAPI_BASE + 20)
-#define API_MSG_GET_VOLFILE_FAILED              (GLFS_GFAPI_BASE + 21)
-#define API_MSG_WRONG_OPVERSION                 (GLFS_GFAPI_BASE + 22)
-#define API_MSG_DICT_SERIALIZE_FAILED           (GLFS_GFAPI_BASE + 23)
-#define API_MSG_REMOTE_HOST_CONN_FAILED         (GLFS_GFAPI_BASE + 24)
-#define API_MSG_VOLFILE_SERVER_EXHAUST          (GLFS_GFAPI_BASE + 25)
-#define API_MSG_CREATE_RPC_CLIENT_FAILED        (GLFS_GFAPI_BASE + 26)
-#define API_MSG_REG_NOTIFY_FUNC_FAILED          (GLFS_GFAPI_BASE + 27)
-#define API_MSG_REG_CBK_FUNC_FAILED             (GLFS_GFAPI_BASE + 28)
-#define API_MSG_GET_CWD_FAILED                  (GLFS_GFAPI_BASE + 29)
-#define API_MSG_FGETXATTR_FAILED                (GLFS_GFAPI_BASE + 30)
-#define API_MSG_LOCKINFO_KEY_MISSING            (GLFS_GFAPI_BASE + 31)
-#define API_MSG_FSETXATTR_FAILED                (GLFS_GFAPI_BASE + 32)
-#define API_MSG_FSYNC_FAILED                    (GLFS_GFAPI_BASE + 33)
-#define API_MSG_FDCREATE_FAILED                 (GLFS_GFAPI_BASE + 34)
-#define API_MSG_INODE_PATH_FAILED               (GLFS_GFAPI_BASE + 35)
-#define API_MSG_SYNCOP_OPEN_FAILED              (GLFS_GFAPI_BASE + 36)
-#define API_MSG_LOCK_MIGRATE_FAILED             (GLFS_GFAPI_BASE + 37)
-#define API_MSG_OPENFD_SKIPPED                  (GLFS_GFAPI_BASE + 38)
-#define API_MSG_FIRST_LOOKUP_GRAPH_FAILED       (GLFS_GFAPI_BASE + 39)
-#define API_MSG_CWD_GRAPH_REF_FAILED            (GLFS_GFAPI_BASE + 40)
-#define API_MSG_SWITCHED_GRAPH                  (GLFS_GFAPI_BASE + 41)
-#define API_MSG_XDR_RESPONSE_DECODE_FAILED      (GLFS_GFAPI_BASE + 42)
-#define API_MSG_VOLFILE_INFO                    (GLFS_GFAPI_BASE + 43)
-#define API_MSG_VOLFILE_CONNECTING              (GLFS_GFAPI_BASE + 44)
-#define API_MSG_NEW_GRAPH                       (GLFS_GFAPI_BASE + 45)
-#define API_MSG_ALLOC_FAILED                    (GLFS_GFAPI_BASE + 46)
-#define API_MSG_CREATE_HANDLE_FAILED            (GLFS_GFAPI_BASE + 47)
-#define API_MSG_INODE_LINK_FAILED               (GLFS_GFAPI_BASE + 48)
-#define API_MSG_STATEDUMP_FAILED                (GLFS_GFAPI_BASE + 49)
-#define API_MSG_XREADDIRP_R_FAILED              (GLFS_GFAPI_BASE + 50)
+GLFS_MSGID(API, API_MSG_MEM_ACCT_INIT_FAILED, API_MSG_MASTER_XLATOR_INIT_FAILED,
+           API_MSG_GFAPI_XLATOR_INIT_FAILED, API_MSG_VOLFILE_OPEN_FAILED,
+           API_MSG_VOL_SPEC_FILE_ERROR, API_MSG_GLFS_FSOBJ_NULL,
+           API_MSG_INVALID_ENTRY, API_MSG_FSMUTEX_LOCK_FAILED,
+           API_MSG_COND_WAIT_FAILED, API_MSG_FSMUTEX_UNLOCK_FAILED,
+           API_MSG_INODE_REFRESH_FAILED, API_MSG_GRAPH_CONSTRUCT_FAILED,
+           API_MSG_API_XLATOR_ERROR, API_MSG_XDR_PAYLOAD_FAILED,
+           API_MSG_GET_VOLINFO_CBK_FAILED, API_MSG_FETCH_VOLUUID_FAILED,
+           API_MSG_INSUFF_SIZE, API_MSG_FRAME_CREAT_FAILED,
+           API_MSG_DICT_SET_FAILED, API_MSG_XDR_DECODE_FAILED,
+           API_MSG_GET_VOLFILE_FAILED, API_MSG_WRONG_OPVERSION,
+           API_MSG_DICT_SERIALIZE_FAILED, API_MSG_REMOTE_HOST_CONN_FAILED,
+           API_MSG_VOLFILE_SERVER_EXHAUST, API_MSG_CREATE_RPC_CLIENT_FAILED,
+           API_MSG_REG_NOTIFY_FUNC_FAILED, API_MSG_REG_CBK_FUNC_FAILED,
+           API_MSG_GET_CWD_FAILED, API_MSG_FGETXATTR_FAILED,
+           API_MSG_LOCKINFO_KEY_MISSING, API_MSG_FSETXATTR_FAILED,
+           API_MSG_FSYNC_FAILED, API_MSG_FDCREATE_FAILED,
+           API_MSG_INODE_PATH_FAILED, API_MSG_SYNCOP_OPEN_FAILED,
+           API_MSG_LOCK_MIGRATE_FAILED, API_MSG_OPENFD_SKIPPED,
+           API_MSG_FIRST_LOOKUP_GRAPH_FAILED, API_MSG_CWD_GRAPH_REF_FAILED,
+           API_MSG_SWITCHED_GRAPH, API_MSG_XDR_RESPONSE_DECODE_FAILED,
+           API_MSG_VOLFILE_INFO, API_MSG_VOLFILE_CONNECTING, API_MSG_NEW_GRAPH,
+           API_MSG_ALLOC_FAILED, API_MSG_CREATE_HANDLE_FAILED,
+           API_MSG_INODE_LINK_FAILED, API_MSG_STATEDUMP_FAILED,
+           API_MSG_XREADDIRP_R_FAILED, API_MSG_LOCK_INSERT_MERGE_FAILED,
+           API_MSG_SETTING_LOCK_TYPE_FAILED, API_MSG_INODE_FIND_FAILED,
+           API_MSG_FDCTX_SET_FAILED, API_MSG_UPCALL_SYNCOP_FAILED,
+           API_MSG_INVALID_ARG, API_MSG_UPCALL_EVENT_NULL_RECEIVED,
+           API_MSG_FLAGS_HANDLE, API_MSG_FDCREATE_FAILED_ON_GRAPH,
+           API_MSG_TRANS_RDMA_DEP, API_MSG_TRANS_NOT_SUPPORTED,
+           API_MSG_FS_NOT_INIT, API_MSG_INVALID_SYSRQ,
+           API_MSG_DECODE_XDR_FAILED, API_MSG_NULL, API_MSG_CALL_NOT_SUCCESSFUL,
+           API_MSG_CALL_NOT_VALID, API_MSG_UNABLE_TO_DEL,
+           API_MSG_REMOTE_HOST_DISCONN, API_MSG_HANDLE_NOT_SET);
 
-/*------------*/
-#define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
+#define API_MSG_ALLOC_FAILED_STR "Upcall allocation failed"
+#define API_MSG_LOCK_INSERT_MERGE_FAILED_STR                                   \
+    "Lock insertion and splitting/merging failed"
+#define API_MSG_SETTING_LOCK_TYPE_FAILED_STR "Setting lock type failed"
 
+#define API_MSG_INVALID_ARG_STR "Invalid"
+#define API_MSG_INVALID_ENTRY_STR "Upcall entry validation failed"
+#define API_MSG_INODE_FIND_FAILED_STR "Unable to find inode entry"
+#define API_MSG_CREATE_HANDLE_FAILED_STR "handle creation failed"
+#define API_MSG_UPCALL_EVENT_NULL_RECEIVED_STR                                 \
+    "Upcall_EVENT_NULL received. Skipping it"
+#define API_MSG_UPCALL_SYNCOP_FAILED_STR "Synctask for upcall failed"
+#define API_MSG_FDCREATE_FAILED_STR "Allocating anonymous fd failed"
+#define API_MSG_XREADDIRP_R_FAILED_STR "glfs_x_readdirp_r failed"
+#define API_MSG_FDCTX_SET_FAILED_STR "Setting fd ctx failed"
+#define API_MSG_FLAGS_HANDLE_STR "arg not set. Flags handled are"
+#define API_MSG_INODE_REFRESH_FAILED_STR "inode refresh failed"
+#define API_MSG_INODE_LINK_FAILED_STR "inode linking failed"
+#define API_MSG_GET_CWD_FAILED_STR "Failed to get cwd"
+#define API_MSG_FGETXATTR_FAILED_STR "fgetxattr failed"
+#define API_MSG_LOCKINFO_KEY_MISSING_STR "missing lockinfo key"
+#define API_MSG_FSYNC_FAILED_STR "fsync() failed"
+#define API_MSG_FDCREATE_FAILED_ON_GRAPH_STR "fd_create failed on graph"
+#define API_MSG_INODE_PATH_FAILED_STR "inode_path failed"
+#define API_MSG_SYNCOP_OPEN_FAILED_STR "syncop_open failed"
+#define API_MSG_LOCK_MIGRATE_FAILED_STR "lock migration failed on graph"
+#define API_MSG_OPENFD_SKIPPED_STR "skipping openfd in graph"
+#define API_MSG_FIRST_LOOKUP_GRAPH_FAILED_STR "first lookup on graph failed"
+#define API_MSG_CWD_GRAPH_REF_FAILED_STR "cwd refresh of graph failed"
+#define API_MSG_SWITCHED_GRAPH_STR "switched to graph"
+#define API_MSG_FSETXATTR_FAILED_STR "fsetxattr failed"
+#define API_MSG_MEM_ACCT_INIT_FAILED_STR "Memory accounting init failed"
+#define API_MSG_MASTER_XLATOR_INIT_FAILED_STR                                  \
+    "master xlator for initialization failed"
+#define API_MSG_GFAPI_XLATOR_INIT_FAILED_STR                                   \
+    "failed to initialize gfapi translator"
+#define API_MSG_VOLFILE_OPEN_FAILED_STR "volume file open failed"
+#define API_MSG_VOL_SPEC_FILE_ERROR_STR "Cannot reach volume specification file"
+#define API_MSG_TRANS_RDMA_DEP_STR                                             \
+    "transport RDMA is deprecated, falling back to tcp"
+#define API_MSG_TRANS_NOT_SUPPORTED_STR                                        \
+    "transport is not supported, possible values tcp|unix"
+#define API_MSG_GLFS_FSOBJ_NULL_STR "fs is NULL"
+#define API_MSG_FS_NOT_INIT_STR "fs is not properly initialized"
+#define API_MSG_FSMUTEX_LOCK_FAILED_STR                                        \
+    "pthread lock on glfs mutex, returned error"
+#define API_MSG_FSMUTEX_UNLOCK_FAILED_STR                                      \
+    "pthread unlock on glfs mutex, returned error"
+#define API_MSG_COND_WAIT_FAILED_STR "cond wait failed"
+#define API_MSG_INVALID_SYSRQ_STR "not a valid sysrq"
+#define API_MSG_GRAPH_CONSTRUCT_FAILED_STR "failed to construct the graph"
+#define API_MSG_API_XLATOR_ERROR_STR                                           \
+    "api master xlator cannot be specified in volume file"
+#define API_MSG_STATEDUMP_FAILED_STR "statedump failed"
+#define API_MSG_DECODE_XDR_FAILED_STR                                          \
+    "Failed to decode xdr response for GF_CBK_STATEDUMP"
+#define API_MSG_NULL_STR "NULL"
+#define API_MSG_XDR_PAYLOAD_FAILED_STR "failed to create XDR payload"
+#define API_MSG_CALL_NOT_SUCCESSFUL_STR                                        \
+    "GET_VOLUME_INFO RPC call is not successful"
+#define API_MSG_XDR_RESPONSE_DECODE_FAILED_STR                                 \
+    "Failed to decode xdr response for GET_VOLUME_INFO"
+#define API_MSG_CALL_NOT_VALID_STR                                             \
+    "Response received for GET_VOLUME_INFO RPC is not valid"
+#define API_MSG_GET_VOLINFO_CBK_FAILED_STR                                     \
+    "In GET_VOLUME_INFO cbk, received error"
+#define API_MSG_FETCH_VOLUUID_FAILED_STR "Unable to fetch volume UUID"
+#define API_MSG_INSUFF_SIZE_STR "Insufficient size passed"
+#define API_MSG_FRAME_CREAT_FAILED_STR "failed to create the frame"
+#define API_MSG_DICT_SET_FAILED_STR "failed to set"
+#define API_MSG_XDR_DECODE_FAILED_STR "XDR decoding error"
+#define API_MSG_GET_VOLFILE_FAILED_STR "failed to get the volume file"
+#define API_MSG_VOLFILE_INFO_STR "No change in volfile, continuing"
+#define API_MSG_UNABLE_TO_DEL_STR "unable to delete file"
+#define API_MSG_WRONG_OPVERSION_STR                                            \
+    "Server is operating at an op-version which is not supported"
+#define API_MSG_DICT_SERIALIZE_FAILED_STR "Failed to serialize dictionary"
+#define API_MSG_REMOTE_HOST_CONN_FAILED_STR "Failed to connect to remote-host"
+#define API_MSG_REMOTE_HOST_DISCONN_STR "disconnected from remote-host"
+#define API_MSG_VOLFILE_SERVER_EXHAUST_STR "Exhausted all volfile servers"
+#define API_MSG_VOLFILE_CONNECTING_STR "connecting to next volfile server"
+#define API_MSG_CREATE_RPC_CLIENT_FAILED_STR "failed to create rpc clnt"
+#define API_MSG_REG_NOTIFY_FUNC_FAILED_STR "failed to register notify function"
+#define API_MSG_REG_CBK_FUNC_FAILED_STR "failed to register callback function"
+#define API_MSG_NEW_GRAPH_STR "New graph coming up"
+#define API_MSG_HANDLE_NOT_SET_STR "handle not set. Flags handled for xstat are"
 #endif /* !_GFAPI_MESSAGES_H__ */
diff --git a/api/src/gfapi.aliases b/api/src/gfapi.aliases
index 85e8448982d..bc639e6b99f 100644
--- a/api/src/gfapi.aliases
+++ b/api/src/gfapi.aliases
@@ -18,31 +18,24 @@ _pub_glfs_from_glfd _glfs_from_glfd$GFAPI_3.4.0
 _pub_glfs_set_xlator_option _glfs_set_xlator_option$GFAPI_3.4.0
 _pub_glfs_read _glfs_read$GFAPI_3.4.0
 _pub_glfs_write _glfs_write$GFAPI_3.4.0
-_pub_glfs_read_async _glfs_read_async$GFAPI_3.4.0
-_pub_glfs_write_async _glfs_write_async$GFAPI_3.4.0
 _pub_glfs_readv _glfs_readv$GFAPI_3.4.0
 _pub_glfs_writev _glfs_writev$GFAPI_3.4.0
-_pub_glfs_readv_async _glfs_readv_async$GFAPI_3.4.0
-_pub_glfs_writev_async _glfs_writev_async$GFAPI_3.4.0
-_pub_glfs_pread _glfs_pread$GFAPI_3.4.0
-_pub_glfs_pwrite _glfs_pwrite$GFAPI_3.4.0
-_pub_glfs_pread_async _glfs_pread_async$GFAPI_3.4.0
-_pub_glfs_pwrite_async _glfs_pwrite_async$GFAPI_3.4.0
+_pub_glfs_pread34 _glfs_pread$GFAPI_3.4.0
+_pub_glfs_pwrite34 _glfs_pwrite$GFAPI_3.4.0
+_pub_glfs_pread_async34 _glfs_pread_async$GFAPI_3.4.0
+_pub_glfs_pwrite_async34 _glfs_pwrite_async$GFAPI_3.4.0
 _pub_glfs_preadv _glfs_preadv$GFAPI_3.4.0
 _pub_glfs_pwritev _glfs_pwritev$GFAPI_3.4.0
-_pub_glfs_preadv_async _glfs_preadv_async$GFAPI_3.4.0
-_pub_glfs_pwritev_async _glfs_pwritev_async$GFAPI_3.4.0
 _pub_glfs_lseek _glfs_lseek$GFAPI_3.4.0
-_pub_glfs_truncate _glfs_truncate$GFAPI_3.7.15
-_pub_glfs_ftruncate _glfs_ftruncate$GFAPI_3.4.0
-_pub_glfs_ftruncate_async _glfs_ftruncate_async$GFAPI_3.4.0
+_pub_glfs_ftruncate34 _glfs_ftruncate$GFAPI_3.4.0
+_pub_glfs_ftruncate_async34 _glfs_ftruncate_async$GFAPI_3.4.0
 _pub_glfs_lstat _glfs_lstat$GFAPI_3.4.0
 _pub_glfs_stat _glfs_stat$GFAPI_3.4.0
 _pub_glfs_fstat _glfs_fstat$GFAPI_3.4.0
-_pub_glfs_fsync _glfs_fsync$GFAPI_3.4.0
-_pub_glfs_fsync_async _glfs_fsync_async$GFAPI_3.4.0
-_pub_glfs_fdatasync _glfs_fdatasync$GFAPI_3.4.0
-_pub_glfs_fdatasync_async _glfs_fdatasync_async$GFAPI_3.4.0
+_pub_glfs_fsync34 _glfs_fsync$GFAPI_3.4.0
+_pub_glfs_fsync_async34 _glfs_fsync_async$GFAPI_3.4.0
+_pub_glfs_fdatasync34 _glfs_fdatasync$GFAPI_3.4.0
+_pub_glfs_fdatasync_async34 _glfs_fdatasync_async$GFAPI_3.4.0
 _pub_glfs_access _glfs_access$GFAPI_3.4.0
 _pub_glfs_symlink _glfs_symlink$GFAPI_3.4.0
 _pub_glfs_readlink _glfs_readlink$GFAPI_3.4.0
@@ -113,9 +106,8 @@ _pub_glfs_readdir _glfs_readdir$GFAPI_3.5.0
 _pub_glfs_readdirplus _glfs_readdirplus$GFAPI_3.5.0
 _pub_glfs_fallocate _glfs_fallocate$GFAPI_3.5.0
 _pub_glfs_discard _glfs_discard$GFAPI_3.5.0
-_pub_glfs_discard_async _glfs_discard_async$GFAPI_3.5.0
 _pub_glfs_zerofill _glfs_zerofill$GFAPI_3.5.0
-_pub_glfs_zerofill_async _glfs_zerofill_async$GFAPI_3.5.0
+_pub_glfs_caller_specific_init _glfs_caller_specific_init$GFAPI_3.5.0
 _pub_glfs_h_setxattrs _glfs_h_setxattrs$GFAPI_3.5.0
 
 _pub_glfs_unset_volfile_server _glfs_unset_volfile_server$GFAPI_3.5.1
@@ -125,11 +117,10 @@ _pub_glfs_h_removexattrs _glfs_h_removexattrs$GFAPI_3.5.1
 _pub_glfs_get_volfile _glfs_get_volfile$GFAPI_3.6.0
 _pub_glfs_h_access _glfs_h_access$GFAPI_3.6.0
 
-_pub_glfs_h_poll_upcall _glfs_h_poll_upcall$GFAPI_3.7.0
+_pub_glfs_h_poll_upcall370 _glfs_h_poll_upcall$GFAPI_3.7.0
 _pub_glfs_h_acl_set _glfs_h_acl_set$GFAPI_3.7.0
 _pub_glfs_h_acl_get _glfs_h_acl_get$GFAPI_3.7.0
 _pub_glfs_h_statfs _glfs_h_statfs$GFAPI_3.7.0
-
 _pub_glfs_h_anonymous_read _glfs_h_anonymous_read$GFAPI_3.7.0
 _pub_glfs_h_anonymous_write _glfs_h_anonymous_write$GFAPI_3.7.0
 
@@ -140,6 +131,8 @@ _priv_glfs_process_upcall_event _glfs_process_upcall_event$GFAPI_PRIVATE_3.7.0
 
 _pub_glfs_h_lookupat _glfs_h_lookupat$GFAPI_3.7.4
 
+_pub_glfs_truncate _glfs_truncate$GFAPI_3.7.15
+
 _pub_glfs_free _glfs_free$GFAPI_3.7.16
 _pub_glfs_h_poll_upcall _glfs_h_poll_upcall$GFAPI_3.7.16
 _pub_glfs_upcall_get_fs _glfs_upcall_get_fs$GFAPI_3.7.16
@@ -153,9 +146,11 @@ _pub_glfs_upcall_inode_get_pobject _glfs_upcall_inode_get_pobject$GFAPI_3.7.16
 _pub_glfs_upcall_inode_get_pstat _glfs_upcall_inode_get_pstat$GFAPI_3.7.16
 _pub_glfs_upcall_inode_get_oldpobject _glfs_upcall_inode_get_oldpobject$GFAPI_3.7.16
 _pub_glfs_upcall_inode_get_oldpstat _glfs_upcall_inode_get_oldpstat$GFAPI_3.7.16
+
 _pub_glfs_realpath _glfs_realpath$GFAPI_3.7.17
 
 _pub_glfs_sysrq _glfs_sysrq$GFAPI_3.10.0
+
 _pub_glfs_fd_set_lkowner _glfs_fd_set_lkowner$GFAPI_3.10.7
 
 _pub_glfs_xreaddirplus_r _glfs_xreaddirplus_r$GFAPI_3.11.0
@@ -164,3 +159,43 @@ _pub_glfs_xreaddirplus_r_get_object _glfs_xreaddirplus_r_get_object$GFAPI_3.11.0
 _pub_glfs_object_copy _glfs_object_copy$GFAPI_3.11.0
 
 _priv_glfs_ipc _glfs_ipc$GFAPI_3.12.0
+
+_pub_glfs_upcall_register _glfs_upcall_register$GFAPI_3.13.0
+_pub_glfs_upcall_unregister _glfs_upcall_unregister$GFAPI_3.13.0
+
+_pub_glfs_setfsleaseid _glfs_setfsleaseid$GFAPI_4.0.0
+_pub_glfs_file_lock _glfs_file_lock$GFAPI_4.0.0
+_pub_glfs_lease _glfs_lease$GFAPI_4.0.0
+_pub_glfs_h_lease _glfs_h_lease$GFAPI_4.0.0
+_pub_glfs_upcall_lease_get_object _glfs_upcall_lease_get_object$GFAPI_4.1.6
+_pub_glfs_upcall_lease_get_lease_type _glfs_upcall_lease_get_lease_type$GFAPI_4.1.6
+
+_priv_glfs_statx _glfs_statx$GFAPI_6.0
+_priv_glfs_iatt_from_statx _glfs_iatt_from_statx$GFAPI_6.0
+_priv_glfs_setfspid _glfs_setfspid$GFAPI_6.1
+
+_pub_glfs_read_async _glfs_read_async$GFAPI_6.0
+_pub_glfs_write_async _glfs_write_async$GFAPI_6.0
+_pub_glfs_readv_async _glfs_readv_async$GFAPI_6.0
+_pub_glfs_writev_async _glfs_writev_async$GFAPI_6.0
+_pub_glfs_pread _glfs_pread$GFAPI_6.0
+_pub_glfs_pwrite _glfs_pwrite$GFAPI_6.0
+_pub_glfs_pread_async _glfs_pread_async$GFAPI_6.0
+_pub_glfs_pwrite_async _glfs_pwrite_async$GFAPI_6.0
+_pub_glfs_preadv_async _glfs_preadv_async$GFAPI_6.0
+_pub_glfs_pwritev_async _glfs_pwritev_async$GFAPI_6.0
+_pub_glfs_fsync _glfs_fsync$GFAPI_6.0
+_pub_glfs_fsync_async _glfs_fsync_async$GFAPI_6.0
+_pub_glfs_fdatasync _glfs_fdatasync$GFAPI_6.0
+_pub_glfs_fdatasync_async _glfs_fdatasync_async$GFAPI_6.0
+_pub_glfs_ftruncate _glfs_ftruncate$GFAPI_6.0
+_pub_glfs_ftruncate_async _glfs_ftruncate_async$GFAPI_6.0
+_pub_glfs_discard_async _glfs_discard_async$GFAPI_6.0
+_pub_glfs_zerofill_async _glfs_zerofill_async$GFAPI_6.0
+_pub_glfs_copy_file_range _glfs_copy_file_range$GFAPI_6.0
+_pub_glfs_fsetattr _glfs_fsetattr$GFAPI_6.0
+_pub_glfs_setattr _glfs_setattr$GFAPI_6.0
+
+_pub_glfs_set_statedump_path _glfs_set_statedump_path@GFAPI_7.0
+
+_pub_glfs_h_creat_open _glfs_h_creat_open@GFAPI_6.6
diff --git a/api/src/gfapi.map b/api/src/gfapi.map
index 88673007d25..228ac47c084 100644
--- a/api/src/gfapi.map
+++ b/api/src/gfapi.map
@@ -97,7 +97,6 @@ GFAPI_3.4.2 {
 		glfs_setfsuid;
 		glfs_setfsgid;
 		glfs_setfsgroups;
-		glfs_h_lookupat;
 		glfs_h_creat;
 		glfs_h_mkdir;
 		glfs_h_mknod;
@@ -115,6 +114,7 @@ GFAPI_3.4.2 {
 		glfs_h_create_from_handle;
 		glfs_h_opendir;
 		glfs_h_open;
+		glfs_h_lookupat;
 } GFAPI_3.4.0;
 
 GFAPI_3.5.0 {
@@ -186,6 +186,7 @@ GFAPI_3.7.16 {
 		glfs_upcall_inode_get_pstat;
 		glfs_upcall_inode_get_oldpobject;
 		glfs_upcall_inode_get_oldpstat;
+		glfs_h_poll_upcall;
 } GFAPI_3.7.15;
 
 GFAPI_3.7.17 {
@@ -207,10 +208,76 @@ GFAPI_3.11.0 {
 		glfs_xreaddirplus_r;
 		glfs_xreaddirplus_r_get_stat;
 		glfs_xreaddirplus_r_get_object;
-                glfs_object_copy;
+		glfs_object_copy;
 } GFAPI_3.10.7;
 
 GFAPI_PRIVATE_3.12.0 {
 	global:
 		glfs_ipc;
 } GFAPI_3.11.0;
+
+GFAPI_3.13.0 {
+	global:
+		glfs_upcall_register;
+		glfs_upcall_unregister;
+} GFAPI_PRIVATE_3.12.0;
+
+GFAPI_4.0.0 {
+	global:
+		glfs_setfsleaseid;
+		glfs_file_lock;
+		glfs_lease;
+		glfs_h_lease;
+} GFAPI_3.13.0;
+
+GFAPI_4.1.6 {
+	global:
+		glfs_upcall_lease_get_object;
+		glfs_upcall_lease_get_lease_type;
+} GFAPI_4.0.0;
+
+GFAPI_PRIVATE_6.0 {
+	global:
+		glfs_statx;
+		glfs_iatt_from_statx;
+} GFAPI_4.1.6;
+
+GFAPI_6.0 {
+	global:
+		glfs_read_async;
+		glfs_write_async;
+		glfs_readv_async;
+		glfs_writev_async;
+		glfs_pread;
+		glfs_pwrite;
+		glfs_pread_async;
+		glfs_pwrite_async;
+		glfs_preadv_async;
+		glfs_pwritev_async;
+		glfs_fsync;
+		glfs_fsync_async;
+		glfs_fdatasync;
+		glfs_fdatasync_async;
+		glfs_ftruncate;
+		glfs_ftruncate_async;
+		glfs_discard_async;
+		glfs_zerofill_async;
+		glfs_copy_file_range;
+		glfs_setattr;
+		glfs_fsetattr;
+} GFAPI_PRIVATE_6.0;
+
+GFAPI_PRIVATE_6.1 {
+	global:
+		glfs_setfspid;
+} GFAPI_6.0;
+
+GFAPI_6.6 {
+	global:
+		glfs_h_creat_open;
+} GFAPI_PRIVATE_6.1;
+
+GFAPI_7.0 {
+	global:
+		glfs_set_statedump_path;
+} GFAPI_6.6;
diff --git a/api/src/glfs-fops.c b/api/src/glfs-fops.c
index 7fb86fc859f..6aa3c5602d1 100644
--- a/api/src/glfs-fops.c
+++ b/api/src/glfs-fops.c
@@ -1,6 +1,6 @@
 
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -18,12 +18,13 @@
 
 #include "glfs-internal.h"
 #include "glfs-mem-types.h"
-#include "syncop.h"
+#include <glusterfs/syncop.h>
 #include "glfs.h"
 #include "gfapi-messages.h"
-#include "compat-errno.h"
+#include <glusterfs/compat-errno.h>
 #include <limits.h>
 #include "glusterfs3.h"
+#include <glusterfs/iatt.h>
 
 #ifdef NAME_MAX
 #define GF_NAME_MAX NAME_MAX
@@ -31,22 +32,33 @@
 #define GF_NAME_MAX 255
 #endif
 
+struct upcall_syncop_args {
+    struct glfs *fs;
+    struct gf_upcall upcall_data;
+};
+
 #define READDIRBUF_SIZE (sizeof(struct dirent) + GF_NAME_MAX + 1)
 
+typedef void (*glfs_io_cbk34)(glfs_fd_t *fd, ssize_t ret, void *data);
+
 /*
  * This function will mark glfd for deletion and decrement its refcount.
  */
 int
-glfs_mark_glfd_for_deletion (struct glfs_fd *glfd)
+glfs_mark_glfd_for_deletion(struct glfs_fd *glfd)
 {
+    LOCK(&glfd->lock);
+    {
         glfd->state = GLFD_CLOSE;
+    }
+    UNLOCK(&glfd->lock);
 
-        GF_REF_PUT (glfd);
+    GF_REF_PUT(glfd);
 
-        return 0;
+    return 0;
 }
 
-/* This function is usefull for all async fops. There is chance that glfd is
+/* This function is useful for all async fops. There is chance that glfd is
  * closed before async fop is completed. When glfd is closed we change the
  * state to GLFD_CLOSE.
  *
@@ -54,12 +66,33 @@ glfs_mark_glfd_for_deletion (struct glfs_fd *glfd)
  * _gf_false.
  */
 gf_boolean_t
-glfs_is_glfd_still_valid (struct glfs_fd *glfd)
+glfs_is_glfd_still_valid(struct glfs_fd *glfd)
 {
+    gf_boolean_t ret = _gf_false;
+
+    LOCK(&glfd->lock);
+    {
         if (glfd->state != GLFD_CLOSE)
-                return _gf_true;
+            ret = _gf_true;
+    }
+    UNLOCK(&glfd->lock);
+
+    return ret;
+}
+
+void
+glfd_set_state_bind(struct glfs_fd *glfd)
+{
+    LOCK(&glfd->lock);
+    {
+        glfd->state = GLFD_OPEN;
+    }
+    UNLOCK(&glfd->lock);
+
+    fd_bind(glfd->fd);
+    glfs_fd_bind(glfd);
 
-        return _gf_false;
+    return;
 }
 
 /*
@@ -70,4742 +103,6343 @@ glfs_is_glfd_still_valid (struct glfs_fd *glfd)
  * maintained by gfapi.
  */
 int
-glfs_get_upcall_cache_invalidation (struct gf_upcall *to_up_data,
-                                    struct gf_upcall *from_up_data)
+glfs_get_upcall_cache_invalidation(struct gf_upcall *to_up_data,
+                                   struct gf_upcall *from_up_data)
 {
+    struct gf_upcall_cache_invalidation *ca_data = NULL;
+    struct gf_upcall_cache_invalidation *f_ca_data = NULL;
+    int ret = -1;
 
-        struct gf_upcall_cache_invalidation *ca_data = NULL;
-        struct gf_upcall_cache_invalidation *f_ca_data = NULL;
-        int                                 ret      = -1;
+    GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, to_up_data, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, from_up_data, out);
+    f_ca_data = from_up_data->data;
+    GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out);
 
-        f_ca_data = from_up_data->data;
-        GF_VALIDATE_OR_GOTO (THIS->name, f_ca_data, out);
+    ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
 
-        ca_data = GF_CALLOC (1, sizeof(*ca_data),
-                            glfs_mt_upcall_entry_t);
-
-        if (!ca_data) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    if (!ca_data) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
 
-        to_up_data->data = ca_data;
+    to_up_data->data = ca_data;
 
-        ca_data->flags      = f_ca_data->flags;
-        ca_data->expire_time_attr = f_ca_data->expire_time_attr;
-        ca_data->stat       = f_ca_data->stat;
-        ca_data->p_stat     = f_ca_data->p_stat;
-        ca_data->oldp_stat  = f_ca_data->oldp_stat;
+    ca_data->flags = f_ca_data->flags;
+    ca_data->expire_time_attr = f_ca_data->expire_time_attr;
+    ca_data->stat = f_ca_data->stat;
+    ca_data->p_stat = f_ca_data->p_stat;
+    ca_data->oldp_stat = f_ca_data->oldp_stat;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfs_loc_link (loc_t *loc, struct iatt *iatt)
+glfs_get_upcall_lease(struct gf_upcall *to_up_data,
+                      struct gf_upcall *from_up_data)
 {
-	int ret = -1;
-        inode_t *old_inode = NULL;
-        uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+    struct gf_upcall_recall_lease *ca_data = NULL;
+    struct gf_upcall_recall_lease *f_ca_data = NULL;
+    int ret = -1;
 
-	if (!loc->inode) {
-		errno = EINVAL;
-		return -1;
-	}
+    GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out);
 
-        old_inode = loc->inode;
+    f_ca_data = from_up_data->data;
+    GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out);
 
-        /* If the inode already exists in the cache, the inode
-         * returned here points to the existing one. We need
-         * to update loc.inode accordingly.
-         */
-	loc->inode = inode_link (loc->inode, loc->parent, loc->name, iatt);
-	if (loc->inode) {
-                inode_ctx_set (loc->inode, THIS, &ctx_value);
-		inode_lookup (loc->inode);
-                inode_unref (old_inode);
-		ret = 0;
-	} else {
-		ret = -1;
-	}
+    ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
+
+    if (!ca_data) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
 
-	return ret;
+    to_up_data->data = ca_data;
+
+    ca_data->lease_type = f_ca_data->lease_type;
+    gf_uuid_copy(ca_data->tid, f_ca_data->tid);
+    ca_data->dict = f_ca_data->dict;
+
+    ret = 0;
+out:
+    return ret;
 }
+int
+glfs_loc_link(loc_t *loc, struct iatt *iatt)
+{
+    int ret = -1;
+    inode_t *old_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
 
+    if (!loc->inode) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    old_inode = loc->inode;
+
+    /* If the inode already exists in the cache, the inode
+     * returned here points to the existing one. We need
+     * to update loc.inode accordingly.
+     */
+    loc->inode = inode_link(loc->inode, loc->parent, loc->name, iatt);
+    if (loc->inode) {
+        inode_ctx_set(loc->inode, THIS, &ctx_value);
+        inode_lookup(loc->inode);
+        inode_unref(old_inode);
+        ret = 0;
+    } else {
+        ret = -1;
+    }
+
+    return ret;
+}
 
 void
-glfs_iatt_to_stat (struct glfs *fs, struct iatt *iatt, struct stat *stat)
+glfs_iatt_to_stat(struct glfs *fs, struct iatt *iatt, struct stat *stat)
 {
-	iatt_to_stat (iatt, stat);
-	stat->st_dev = fs->dev_id;
+    iatt_to_stat(iatt, stat);
+    stat->st_dev = fs->dev_id;
 }
 
+void
+glfs_iatt_to_statx(struct glfs *fs, const struct iatt *iatt,
+                   struct glfs_stat *statx)
+{
+    statx->glfs_st_mask = 0;
+
+    statx->glfs_st_mode = 0;
+    if (IATT_TYPE_VALID(iatt->ia_flags)) {
+        statx->glfs_st_mode |= st_mode_type_from_ia(iatt->ia_type);
+        statx->glfs_st_mask |= GLFS_STAT_TYPE;
+    }
+
+    if (IATT_MODE_VALID(iatt->ia_flags)) {
+        statx->glfs_st_mode |= st_mode_prot_from_ia(iatt->ia_prot);
+        statx->glfs_st_mask |= GLFS_STAT_MODE;
+    }
+
+    if (IATT_NLINK_VALID(iatt->ia_flags)) {
+        statx->glfs_st_nlink = iatt->ia_nlink;
+        statx->glfs_st_mask |= GLFS_STAT_NLINK;
+    }
+
+    if (IATT_UID_VALID(iatt->ia_flags)) {
+        statx->glfs_st_uid = iatt->ia_uid;
+        statx->glfs_st_mask |= GLFS_STAT_UID;
+    }
+
+    if (IATT_GID_VALID(iatt->ia_flags)) {
+        statx->glfs_st_gid = iatt->ia_gid;
+        statx->glfs_st_mask |= GLFS_STAT_GID;
+    }
+
+    if (IATT_ATIME_VALID(iatt->ia_flags)) {
+        statx->glfs_st_atime.tv_sec = iatt->ia_atime;
+        statx->glfs_st_atime.tv_nsec = iatt->ia_atime_nsec;
+        statx->glfs_st_mask |= GLFS_STAT_ATIME;
+    }
+
+    if (IATT_MTIME_VALID(iatt->ia_flags)) {
+        statx->glfs_st_mtime.tv_sec = iatt->ia_mtime;
+        statx->glfs_st_mtime.tv_nsec = iatt->ia_mtime_nsec;
+        statx->glfs_st_mask |= GLFS_STAT_MTIME;
+    }
+
+    if (IATT_CTIME_VALID(iatt->ia_flags)) {
+        statx->glfs_st_ctime.tv_sec = iatt->ia_ctime;
+        statx->glfs_st_ctime.tv_nsec = iatt->ia_ctime_nsec;
+        statx->glfs_st_mask |= GLFS_STAT_CTIME;
+    }
+
+    if (IATT_BTIME_VALID(iatt->ia_flags)) {
+        statx->glfs_st_btime.tv_sec = iatt->ia_btime;
+        statx->glfs_st_btime.tv_nsec = iatt->ia_btime_nsec;
+        statx->glfs_st_mask |= GLFS_STAT_BTIME;
+    }
+
+    if (IATT_INO_VALID(iatt->ia_flags)) {
+        statx->glfs_st_ino = iatt->ia_ino;
+        statx->glfs_st_mask |= GLFS_STAT_INO;
+    }
+
+    if (IATT_SIZE_VALID(iatt->ia_flags)) {
+        statx->glfs_st_size = iatt->ia_size;
+        statx->glfs_st_mask |= GLFS_STAT_SIZE;
+    }
+
+    if (IATT_BLOCKS_VALID(iatt->ia_flags)) {
+        statx->glfs_st_blocks = iatt->ia_blocks;
+        statx->glfs_st_mask |= GLFS_STAT_BLOCKS;
+    }
+
+    /* unconditionally present, encode as is */
+    statx->glfs_st_blksize = iatt->ia_blksize;
+    statx->glfs_st_rdev_major = ia_major(iatt->ia_rdev);
+    statx->glfs_st_rdev_minor = ia_minor(iatt->ia_rdev);
+    statx->glfs_st_dev_major = ia_major(fs->dev_id);
+    statx->glfs_st_dev_minor = ia_minor(fs->dev_id);
+
+    /* At present we do not read any localFS attributes and pass them along,
+     * so setting this to 0. As we start supporting file attributes we can
+     * populate the same here as well */
+    statx->glfs_st_attributes = 0;
+    statx->glfs_st_attributes_mask = 0;
+}
 
-int
-glfs_loc_unlink (loc_t *loc)
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_iatt_from_statx, 6.0)
+void
+priv_glfs_iatt_from_statx(struct iatt *iatt, const struct glfs_stat *statx)
 {
-	inode_unlink (loc->inode, loc->parent, loc->name);
+    /* Most code in xlators are not checking validity flags before accessing
+    the items. Hence zero everything before setting valid items */
+    memset(iatt, 0, sizeof(struct iatt));
+
+    if (GLFS_STAT_TYPE_VALID(statx->glfs_st_mask)) {
+        iatt->ia_type = ia_type_from_st_mode(statx->glfs_st_mode);
+        iatt->ia_flags |= IATT_TYPE;
+    }
+
+    if (GLFS_STAT_MODE_VALID(statx->glfs_st_mask)) {
+        iatt->ia_prot = ia_prot_from_st_mode(statx->glfs_st_mode);
+        iatt->ia_flags |= IATT_MODE;
+    }
+
+    if (GLFS_STAT_NLINK_VALID(statx->glfs_st_mask)) {
+        iatt->ia_nlink = statx->glfs_st_nlink;
+        iatt->ia_flags |= IATT_NLINK;
+    }
+
+    if (GLFS_STAT_UID_VALID(statx->glfs_st_mask)) {
+        iatt->ia_uid = statx->glfs_st_uid;
+        iatt->ia_flags |= IATT_UID;
+    }
+
+    if (GLFS_STAT_GID_VALID(statx->glfs_st_mask)) {
+        iatt->ia_gid = statx->glfs_st_gid;
+        iatt->ia_flags |= IATT_GID;
+    }
+
+    if (GLFS_STAT_ATIME_VALID(statx->glfs_st_mask)) {
+        iatt->ia_atime = statx->glfs_st_atime.tv_sec;
+        iatt->ia_atime_nsec = statx->glfs_st_atime.tv_nsec;
+        iatt->ia_flags |= IATT_ATIME;
+    }
+
+    if (GLFS_STAT_MTIME_VALID(statx->glfs_st_mask)) {
+        iatt->ia_mtime = statx->glfs_st_mtime.tv_sec;
+        iatt->ia_mtime_nsec = statx->glfs_st_mtime.tv_nsec;
+        iatt->ia_flags |= IATT_MTIME;
+    }
+
+    if (GLFS_STAT_CTIME_VALID(statx->glfs_st_mask)) {
+        iatt->ia_ctime = statx->glfs_st_ctime.tv_sec;
+        iatt->ia_ctime_nsec = statx->glfs_st_ctime.tv_nsec;
+        iatt->ia_flags |= IATT_CTIME;
+    }
+
+    if (GLFS_STAT_BTIME_VALID(statx->glfs_st_mask)) {
+        iatt->ia_btime = statx->glfs_st_btime.tv_sec;
+        iatt->ia_btime_nsec = statx->glfs_st_btime.tv_nsec;
+        iatt->ia_flags |= IATT_BTIME;
+    }
+
+    if (GLFS_STAT_INO_VALID(statx->glfs_st_mask)) {
+        iatt->ia_ino = statx->glfs_st_ino;
+        iatt->ia_flags |= IATT_INO;
+    }
+
+    if (GLFS_STAT_SIZE_VALID(statx->glfs_st_mask)) {
+        iatt->ia_size = statx->glfs_st_size;
+        iatt->ia_flags |= IATT_SIZE;
+    }
+
+    if (GLFS_STAT_BLOCKS_VALID(statx->glfs_st_mask)) {
+        iatt->ia_blocks = statx->glfs_st_blocks;
+        iatt->ia_flags |= IATT_BLOCKS;
+    }
+
+    /* unconditionally present, encode as is */
+    iatt->ia_blksize = statx->glfs_st_blksize;
+    iatt->ia_rdev = makedev(statx->glfs_st_rdev_major,
+                            statx->glfs_st_rdev_minor);
+    iatt->ia_dev = makedev(statx->glfs_st_dev_major, statx->glfs_st_dev_minor);
+    iatt->ia_attributes = statx->glfs_st_attributes;
+    iatt->ia_attributes_mask = statx->glfs_st_attributes_mask;
+}
 
-	return 0;
+void
+glfsflags_from_gfapiflags(struct glfs_stat *stat, int *glvalid)
+{
+    *glvalid = 0;
+    if (stat->glfs_st_mask & GLFS_STAT_MODE) {
+        *glvalid |= GF_SET_ATTR_MODE;
+    }
+
+    if (stat->glfs_st_mask & GLFS_STAT_SIZE) {
+        *glvalid |= GF_SET_ATTR_SIZE;
+    }
+
+    if (stat->glfs_st_mask & GLFS_STAT_UID) {
+        *glvalid |= GF_SET_ATTR_UID;
+    }
+
+    if (stat->glfs_st_mask & GLFS_STAT_GID) {
+        *glvalid |= GF_SET_ATTR_GID;
+    }
+
+    if (stat->glfs_st_mask & GLFS_STAT_ATIME) {
+        *glvalid |= GF_SET_ATTR_ATIME;
+    }
+
+    if (stat->glfs_st_mask & GLFS_STAT_MTIME) {
+        *glvalid |= GF_SET_ATTR_MTIME;
+    }
 }
 
+int
+glfs_loc_unlink(loc_t *loc)
+{
+    inode_unlink(loc->inode, loc->parent, loc->name);
+
+    /* since glfs_h_* objects hold a reference to inode
+     * it is safe to keep lookup count to '0' */
+    if (!inode_has_dentry(loc->inode))
+        inode_forget(loc->inode, 0);
+
+    return 0;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_open, 3.4.0)
 struct glfs_fd *
-pub_glfs_open (struct glfs *fs, const char *path, int flags)
+pub_glfs_open(struct glfs *fs, const char *path, int flags)
 {
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+retry:
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    if (ret)
+        goto out;
 
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
+    if (IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
 
-retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret)
-		goto out;
-
-	if (IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
-
-	if (!IA_ISREG (iatt.ia_type)) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-        glfd->fd->flags = flags;
-
-	ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    if (!IA_ISREG(iatt.ia_type)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_open(subvol, &loc, flags, glfd->fd, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (ret && glfd) {
-                GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd->state = GLFD_OPEN;
-		fd_bind (glfd->fd);
-		glfs_fd_bind (glfd);
-	}
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (fs, subvol);
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-        __GLFS_EXIT_FS;
+    glfs_subvol_done(fs, subvol);
+
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_open, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0)
 int
-pub_glfs_close (struct glfs_fd *glfd)
+pub_glfs_close(struct glfs_fd *glfd)
 {
-	xlator_t  *subvol = NULL;
-	int        ret = -1;
-	fd_t      *fd = NULL;
-	struct glfs *fs = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-	subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        if (glfd->lk_owner.len != 0) {
-                ret = syncopctx_setfslkowner (&glfd->lk_owner);
-                if (ret)
-                        goto out;
-        }
-
-	ret = syncop_flush (subvol, fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    fd_t *fd = NULL;
+    struct glfs *fs = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    if (glfd->lk_owner.len != 0) {
+        ret = syncopctx_setfslkowner(&glfd->lk_owner);
+        if (ret)
+            goto out;
+    }
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_flush(subvol, fd, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	fs = glfd->fs;
+    fs = glfd->fs;
 
-        if (fd)
-                fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        glfs_mark_glfd_for_deletion (glfd);
-	glfs_subvol_done (fs, subvol);
+    glfs_mark_glfd_for_deletion(glfd);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lstat, 3.4.0)
 int
-pub_glfs_lstat (struct glfs *fs, const char *path, struct stat *stat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_lstat(struct glfs *fs, const char *path, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (fs, &iatt, stat);
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lstat, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_stat, 3.4.0)
 int
-pub_glfs_stat (struct glfs *fs, const char *path, struct stat *stat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_stat(struct glfs *fs, const char *path, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (fs, &iatt, stat);
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_stat, 3.4.0);
-
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_statx, 6.0)
 int
-pub_glfs_fstat (struct glfs_fd *glfd, struct stat *stat)
+priv_glfs_statx(struct glfs *fs, const char *path, const unsigned int mask,
+                struct glfs_stat *statxbuf)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	struct iatt      iatt = {0, };
-	fd_t            *fd = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (path == NULL) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (mask & ~GLFS_STAT_ALL) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+retry:
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-        GF_REF_GET (glfd);
+    if (ret == 0 && statxbuf)
+        glfs_iatt_to_statx(fs, &iatt, statxbuf);
+out:
+    loc_wipe(&loc);
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    glfs_subvol_done(fs, subvol);
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+    __GLFS_EXIT_FS;
 
-	ret = syncop_fstat (subvol, fd, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+invalid_fs:
+    return ret;
+}
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (glfd->fs, &iatt, stat);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0)
+int
+pub_glfs_fstat(struct glfs_fd *glfd, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fstat(subvol, fd, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(glfd->fs, &iatt, stat);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_creat, 3.4.0)
 struct glfs_fd *
-pub_glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode)
-{
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
-
-	/* This must be glfs_resolve() and NOT glfs_lresolve().
-	   That is because open("name", O_CREAT) where "name"
-	   is a danging symlink must create the dangling
-	   destinataion.
-	*/
+pub_glfs_creat(struct glfs *fs, const char *path, int flags, mode_t mode)
+{
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    /* This must be glfs_resolve() and NOT glfs_lresolve().
+       That is because open("name", O_CREAT) where "name"
+       is a danging symlink must create the dangling
+       destination.
+    */
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
-
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
-
-	if (loc.inode) {
-		if (flags & O_EXCL) {
-			ret = -1;
-			errno = EEXIST;
-			goto out;
-		}
-
-		if (IA_ISDIR (iatt.ia_type)) {
-			ret = -1;
-			errno = EISDIR;
-			goto out;
-		}
-
-		if (!IA_ISREG (iatt.ia_type)) {
-			ret = -1;
-			errno = EINVAL;
-			goto out;
-		}
-	}
-
-	if (ret == -1 && errno == ENOENT) {
-		loc.inode = inode_new (loc.parent->table);
-		if (!loc.inode) {
-			ret = -1;
-			errno = ENOMEM;
-			goto out;
-		}
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-        glfd->fd->flags = flags;
-
-	if (ret == 0) {
-		ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-	} else {
-		ret = syncop_create (subvol, &loc, flags, mode, glfd->fd,
-				     &iatt, xattr_req, NULL);
-                DECODE_SYNCOP_ERR (ret);
-	}
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
+
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
+
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
+
+    if (loc.inode) {
+        if (flags & O_EXCL) {
+            ret = -1;
+            errno = EEXIST;
+            goto out;
+        }
+
+        if (IA_ISDIR(iatt.ia_type)) {
+            ret = -1;
+            errno = EISDIR;
+            goto out;
+        }
+
+        if (!IA_ISREG(iatt.ia_type)) {
+            ret = -1;
+            errno = EINVAL;
+            goto out;
+        }
+    }
+
+    if (ret == -1 && errno == ENOENT) {
+        loc.inode = inode_new(loc.parent->table);
+        if (!loc.inode) {
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    if (get_fop_attr_thrd_key(&xattr_req))
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+    if (ret == 0) {
+        ret = syncop_open(subvol, &loc, flags, glfd->fd, xattr_req, NULL);
+        DECODE_SYNCOP_ERR(ret);
+    } else {
+        ret = syncop_create(subvol, &loc, flags, mode, glfd->fd, &iatt,
+                            xattr_req, NULL);
+        DECODE_SYNCOP_ERR(ret);
+    }
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
+
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	if (ret && glfd) {
-                GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd->state = GLFD_OPEN;
-		fd_bind (glfd->fd);
-		glfs_fd_bind (glfd);
-	}
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_creat, 3.4.0);
-
 #ifdef HAVE_SEEK_HOLE
 static int
-glfs_seek (struct glfs_fd *glfd, off_t offset, int whence)
+glfs_seek(struct glfs_fd *glfd, off_t offset, int whence)
 {
-        int               ret             = -1;
-        xlator_t         *subvol          = NULL;
-        fd_t             *fd              = NULL;
-        gf_seek_what_t    what            = 0;
-        off_t             off             = -1;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    gf_seek_what_t what = 0;
+    off_t off = -1;
 
-        switch (whence) {
+    switch (whence) {
         case SEEK_DATA:
-                what = GF_SEEK_DATA;
-                break;
+            what = GF_SEEK_DATA;
+            break;
         case SEEK_HOLE:
-                what = GF_SEEK_HOLE;
-                break;
+            what = GF_SEEK_HOLE;
+            break;
         default:
-                /* other SEEK_* do not make sense, all operations get an offset
-                 * and the position in the fd is not tracked */
-                errno = EINVAL;
-                goto out;
-        }
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto done;
-        }
-
-        ret = syncop_seek (subvol, fd, offset, what, NULL, &off);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret != -1)
-                glfd->offset = off;
+            /* other SEEK_* do not make sense, all operations get an offset
+             * and the position in the fd is not tracked */
+            errno = EINVAL;
+            goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto done;
+    }
+
+    ret = syncop_seek(subvol, fd, offset, what, NULL, &off);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret != -1)
+        glfd->offset = off;
 
 done:
-        if (fd)
-                fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-        glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
 out:
-        return ret;
+    return ret;
 }
 #endif
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lseek, 3.4.0)
 off_t
-pub_glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
-{
-	struct stat sb  = {0, };
-	int         ret = -1;
-        off_t       off = -1;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	switch (whence) {
-	case SEEK_SET:
-		glfd->offset = offset;
-                ret = 0;
-		break;
-	case SEEK_CUR:
-		glfd->offset += offset;
-                ret = 0;
-		break;
-	case SEEK_END:
-		ret = pub_glfs_fstat (glfd, &sb);
-		if (ret) {
-			/* seek cannot fail :O */
-			break;
-		}
-		glfd->offset = sb.st_size + offset;
-		break;
+pub_glfs_lseek(struct glfs_fd *glfd, off_t offset, int whence)
+{
+    struct stat sb = {
+        0,
+    };
+    int ret = -1;
+    off_t off = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    switch (whence) {
+        case SEEK_SET:
+            glfd->offset = offset;
+            ret = 0;
+            break;
+        case SEEK_CUR:
+            glfd->offset += offset;
+            ret = 0;
+            break;
+        case SEEK_END:
+            ret = pub_glfs_fstat(glfd, &sb);
+            if (ret) {
+                /* seek cannot fail :O */
+                break;
+            }
+            glfd->offset = sb.st_size + offset;
+            break;
 #ifdef HAVE_SEEK_HOLE
         case SEEK_DATA:
         case SEEK_HOLE:
-                ret = glfs_seek (glfd, offset, whence);
-                break;
+            ret = glfs_seek(glfd, offset, whence);
+            break;
 #endif
         default:
-                errno = EINVAL;
-	}
+            errno = EINVAL;
+    }
 
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        if (ret != -1)
-                off = glfd->offset;
+    if (ret != -1)
+        off = glfd->offset;
 
-        return off;
+    return off;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lseek, 3.4.0);
-
-
-ssize_t
-pub_glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                 off_t offset, int flags)
+static ssize_t
+glfs_preadv_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                   off_t offset, int flags, struct glfs_stat *poststat)
 {
-	xlator_t       *subvol = NULL;
-	ssize_t         ret = -1;
-	ssize_t         size = -1;
-	struct iovec   *iov = NULL;
-	int             cnt = 0;
-	struct iobref  *iobref = NULL;
-	fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    xlator_t *subvol = NULL;
+    ssize_t ret = -1;
+    ssize_t size = -1;
+    struct iovec *iov = NULL;
+    int cnt = 0;
+    struct iobref *iobref = NULL;
+    fd_t *fd = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    size = iov_length(iovec, iovcnt);
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_readv(subvol, fd, size, offset, 0, &iov, &cnt, &iobref, &iatt,
+                       fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0 && poststat)
+        glfs_iatt_to_statx(glfd->fs, &iatt, poststat);
+
+    if (ret <= 0)
+        goto out;
+
+    size = iov_copy(iovec, iovcnt, iov, cnt); /* FIXME!!! */
+
+    glfd->offset = (offset + size);
+
+    ret = size;
+out:
+    if (iov)
+        GF_FREE(iov);
+    if (iobref)
+        iobref_unref(iobref);
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	size = iov_length (iovec, iovcnt);
+    glfs_subvol_done(glfd->fs, subvol);
 
-	ret = syncop_readv (subvol, fd, size, offset, 0, &iov, &cnt, &iobref,
-                            NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret <= 0)
-		goto out;
+    __GLFS_EXIT_FS;
 
-	size = iov_copy (iovec, iovcnt, iov, cnt); /* FIXME!!! */
+invalid_fs:
+    return ret;
+}
 
-	glfd->offset = (offset + size);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0)
+ssize_t
+pub_glfs_preadv(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                off_t offset, int flags)
+{
+    return glfs_preadv_common(glfd, iovec, iovcnt, offset, flags, NULL);
+}
 
-	ret = size;
-out:
-        if (iov)
-                GF_FREE (iov);
-        if (iobref)
-                iobref_unref (iobref);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0)
+ssize_t
+pub_glfs_read(struct glfs_fd *glfd, void *buf, size_t count, int flags)
+{
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	glfs_subvol_done (glfd->fs, subvol);
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        __GLFS_EXIT_FS;
+    ret = pub_glfs_preadv(glfd, &iov, 1, glfd->offset, flags);
 
-invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC(glfs_pread34, glfs_pread, 3.4.0)
 ssize_t
-pub_glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags)
+pub_glfs_pread34(struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
+                 int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_preadv (glfd, &iov, 1, glfd->offset, flags);
+    ret = pub_glfs_preadv(glfd, &iov, 1, offset, flags);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, 6.0)
 ssize_t
-pub_glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-                int flags)
+pub_glfs_pread(struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
+               int flags, struct glfs_stat *poststat)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_preadv (glfd, &iov, 1, offset, flags);
+    ret = glfs_preadv_common(glfd, &iov, 1, offset, flags, poststat);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv, 3.4.0)
 ssize_t
-pub_glfs_readv (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                int flags)
+pub_glfs_readv(struct glfs_fd *glfd, const struct iovec *iov, int count,
+               int flags)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = pub_glfs_preadv (glfd, iov, count, glfd->offset, flags);
-
-	return ret;
-}
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv, 3.4.0);
+    ret = pub_glfs_preadv(glfd, iov, count, glfd->offset, flags);
 
+    return ret;
+}
 
 struct glfs_io {
-	struct glfs_fd      *glfd;
-	int                  op;
-	off_t                offset;
-	struct iovec        *iov;
-	int                  count;
-	int                  flags;
-	glfs_io_cbk          fn;
-	void                *data;
+    struct glfs_fd *glfd;
+    int op;
+    off_t offset;
+    struct iovec *iov;
+    int count;
+    int flags;
+    gf_boolean_t oldcb;
+    union {
+        glfs_io_cbk34 fn34;
+        glfs_io_cbk fn;
+    };
+    void *data;
 };
 
-
 static int
-glfs_io_async_cbk (int op_ret, int op_errno, call_frame_t *frame,
-                   void *cookie, struct iovec *iovec, int count)
+glfs_io_async_cbk(int op_ret, int op_errno, call_frame_t *frame, void *cookie,
+                  struct iovec *iovec, int count, struct iatt *prebuf,
+                  struct iatt *postbuf)
 {
-        struct glfs_io *gio = NULL;
-        xlator_t       *subvol = NULL;
-        struct glfs    *fs = NULL;
-        struct glfs_fd *glfd = NULL;
-        int             ret  = -1;
-
-        GF_VALIDATE_OR_GOTO ("gfapi", frame, inval);
-        GF_VALIDATE_OR_GOTO ("gfapi", cookie, inval);
-
-        gio = frame->local;
-        frame->local = NULL;
-        subvol = cookie;
-        glfd = gio->glfd;
-        fs = glfd->fs;
-
-        if (!glfs_is_glfd_still_valid (glfd))
-                goto err;
+    struct glfs_io *gio = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs *fs = NULL;
+    struct glfs_fd *glfd = NULL;
+    int ret = -1;
+    struct glfs_stat prestat = {}, *prestatp = NULL;
+    struct glfs_stat poststat = {}, *poststatp = NULL;
+
+    GF_VALIDATE_OR_GOTO("gfapi", frame, inval);
+    GF_VALIDATE_OR_GOTO("gfapi", cookie, inval);
+
+    gio = frame->local;
+    frame->local = NULL;
+    subvol = cookie;
+    glfd = gio->glfd;
+    fs = glfd->fs;
+
+    if (!glfs_is_glfd_still_valid(glfd))
+        goto err;
+
+    if (op_ret <= 0) {
+        goto out;
+    } else if (gio->op == GF_FOP_READ) {
+        if (!iovec) {
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto out;
+        }
 
-        if (op_ret <= 0) {
-                goto out;
-        } else if (gio->op == GF_FOP_READ) {
-                if (!iovec) {
-                        op_ret = -1;
-                        op_errno = EINVAL;
-                        goto out;
-                }
+        op_ret = iov_copy(gio->iov, gio->count, iovec, count);
+        glfd->offset = gio->offset + op_ret;
+    } else if (gio->op == GF_FOP_WRITE) {
+        glfd->offset = gio->offset + gio->iov->iov_len;
+    }
 
-                op_ret = iov_copy (gio->iov, gio->count, iovec, count);
-                glfd->offset = gio->offset + op_ret;
-        } else if (gio->op == GF_FOP_WRITE) {
-                glfd->offset = gio->offset + gio->iov->iov_len;
+out:
+    errno = op_errno;
+    if (gio->oldcb) {
+        gio->fn34(gio->glfd, op_ret, gio->data);
+    } else {
+        if (prebuf) {
+            prestatp = &prestat;
+            glfs_iatt_to_statx(fs, prebuf, prestatp);
         }
 
-out:
-        errno = op_errno;
-        gio->fn (gio->glfd, op_ret, gio->data);
+        if (postbuf) {
+            poststatp = &poststat;
+            glfs_iatt_to_statx(fs, postbuf, poststatp);
+        }
 
+        gio->fn(gio->glfd, op_ret, prestatp, poststatp, gio->data);
+    }
 err:
-        fd_unref (glfd->fd);
-        /* Since the async operation is complete
-         * release the ref taken during the start
-         * of async operation
-         */
-        GF_REF_PUT (glfd);
-
-        GF_FREE (gio->iov);
-        GF_FREE (gio);
-        STACK_DESTROY (frame->root);
-        glfs_subvol_done (fs, subvol);
-
-        ret = 0;
+    fd_unref(glfd->fd);
+    /* Since the async operation is complete
+     * release the ref taken during the start
+     * of async operation
+     */
+    GF_REF_PUT(glfd);
+
+    GF_FREE(gio->iov);
+    GF_FREE(gio);
+    STACK_DESTROY(frame->root);
+    glfs_subvol_done(fs, subvol);
+
+    ret = 0;
 inval:
-        return ret;
+    return ret;
 }
 
 static int
-glfs_preadv_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, struct iovec *iovec,
-                       int count, struct iatt *stbuf, struct iobref *iobref,
-                       dict_t *xdata)
+glfs_preadv_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, struct iovec *iovec, int count,
+                      struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, iovec, count);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, iovec, count, NULL,
+                      stbuf);
 
-	return 0;
+    return 0;
 }
 
-
-int
-pub_glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec,
-                       int count, off_t offset, int flags, glfs_io_cbk fn,
-                       void *data)
+static int
+glfs_preadv_async_common(struct glfs_fd *glfd, const struct iovec *iovec,
+                         int count, off_t offset, int flags, gf_boolean_t oldcb,
+                         glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = 0;
-	call_frame_t   *frame = NULL;
-	xlator_t       *subvol = NULL;
-	glfs_t         *fs = NULL;
-	fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	fs = glfd->fs;
-
-	frame = syncop_create_frame (THIS);
-	if (!frame) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->iov = iov_dup (iovec, count);
-	if (!gio->iov) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_READ;
-	gio->glfd   = glfd;
-	gio->count  = count;
-	gio->offset = offset;
-	gio->flags  = flags;
-	gio->fn     = fn;
-	gio->data   = data;
-
-	frame->local = gio;
-
-	STACK_WIND_COOKIE (frame, glfs_preadv_async_cbk, subvol, subvol,
-			   subvol->fops->readv, fd, iov_length (iovec, count),
-			   offset, flags, NULL);
+    struct glfs_io *gio = NULL;
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs *fs = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    fs = glfd->fs;
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->iov = iov_dup(iovec, count);
+    if (!gio->iov) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_READ;
+    gio->glfd = glfd;
+    gio->count = count;
+    gio->offset = offset;
+    gio->flags = flags;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_preadv_async_cbk, subvol, subvol,
+                      subvol->fops->readv, fd, iov_length(iovec, count), offset,
+                      flags, fop_attr);
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                if (gio) {
-                        GF_FREE (gio->iov);
-                        GF_FREE (gio);
-                }
-                if (frame) {
-                        STACK_DESTROY (frame->root);
-                }
-		glfs_subvol_done (fs, subvol);
-	}
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        if (gio) {
+            GF_FREE(gio->iov);
+            GF_FREE(gio);
+        }
+        if (frame) {
+            STACK_DESTROY(frame->root);
+        }
+        glfs_subvol_done(fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC(glfs_preadv_async34, glfs_preadv_async, 3.4.0)
+int
+pub_glfs_preadv_async34(struct glfs_fd *glfd, const struct iovec *iovec,
+                        int count, off_t offset, int flags, glfs_io_cbk34 fn,
+                        void *data)
+{
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags, _gf_true,
+                                    (void *)fn, data);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, 6.0)
 int
-pub_glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags,
-                     glfs_io_cbk fn, void *data)
+pub_glfs_preadv_async(struct glfs_fd *glfd, const struct iovec *iovec,
+                      int count, off_t offset, int flags, glfs_io_cbk fn,
+                      void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags,
+                                    _gf_false, fn, data);
+}
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+GFAPI_SYMVER_PUBLIC(glfs_read_async34, glfs_read_async, 3.4.0)
+int
+pub_glfs_read_async34(struct glfs_fd *glfd, void *buf, size_t count, int flags,
+                      glfs_io_cbk34 fn, void *data)
+{
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_preadv_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read_async, 3.4.0);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags, _gf_true,
+                                   (void *)fn, data);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read_async, 6.0)
 int
-pub_glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count,
-                      off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_read_async(struct glfs_fd *glfd, void *buf, size_t count, int flags,
+                    glfs_io_cbk fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
-
-	ret = pub_glfs_preadv_async (glfd, &iov, 1, offset, flags, fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, 3.4.0);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                   _gf_false, fn, data);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC(glfs_pread_async34, glfs_pread_async, 3.4.0)
 int
-pub_glfs_readv_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                      int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pread_async34(struct glfs_fd *glfd, void *buf, size_t count,
+                       off_t offset, int flags, glfs_io_cbk34 fn, void *data)
 {
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_preadv_async (glfd, iov, count, glfd->offset, flags,
-				  fn, data);
-	return ret;
-}
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, 3.4.0);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                   (void *)fn, data);
 
+    return ret;
+}
 
-static int
-glfs_buf_copy (xlator_t *subvol, const struct iovec *iovec_src, int iovcnt,
-               struct iobref **iobref, struct iobuf **iobuf,
-               struct iovec *iov_dst)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, 6.0)
+int
+pub_glfs_pread_async(struct glfs_fd *glfd, void *buf, size_t count,
+                     off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
-        size_t         size = -1;
-        int            ret  = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        size = iov_length (iovec_src, iovcnt);
-
-        *iobuf = iobuf_get2 (subvol->ctx->iobuf_pool, size);
-        if (!(*iobuf)) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        *iobref = iobref_new ();
-        if (!(*iobref)) {
-                iobuf_unref (*iobuf);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                   data);
 
-        ret = iobref_add (*iobref, *iobuf);
-        if (ret) {
-                iobuf_unref (*iobuf);
-                iobref_unref (*iobref);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    return ret;
+}
 
-        iov_unload (iobuf_ptr (*iobuf), iovec_src, iovcnt);  /* FIXME!!! */
+GFAPI_SYMVER_PUBLIC(glfs_readv_async34, glfs_readv_async, 3.4.0)
+int
+pub_glfs_readv_async34(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                       int flags, glfs_io_cbk34 fn, void *data)
+{
+    ssize_t ret = 0;
 
-        iov_dst->iov_base = iobuf_ptr (*iobuf);
-        iov_dst->iov_len = size;
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-out:
-        return ret;
+    ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags,
+                                   _gf_true, (void *)fn, data);
+    return ret;
 }
 
-
-ssize_t
-pub_glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                  off_t offset, int flags)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, 6.0)
+int
+pub_glfs_readv_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                     int flags, glfs_io_cbk fn, void *data)
 {
-	xlator_t       *subvol = NULL;
-	int             ret = -1;
-	struct iobref  *iobref = NULL;
-	struct iobuf   *iobuf = NULL;
-	struct iovec    iov = {0, };
-	fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = glfs_buf_copy (subvol, iovec, iovcnt, &iobref, &iobuf, &iov);
-        if (ret)
-                goto out;
+    ssize_t ret = 0;
 
-	ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags, NULL,
-                             NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret <= 0)
-		goto out;
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	glfd->offset = (offset + iov.iov_len);
+    ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags,
+                                   _gf_false, fn, data);
+    return ret;
+}
 
+static ssize_t
+glfs_pwritev_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                    off_t offset, int flags, struct glfs_stat *prestat,
+                    struct glfs_stat *poststat)
+{
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iovec iov = {
+        0,
+    };
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, iovcnt, &iobref, &iobuf,
+                     &iov);
+    if (ret)
+        goto out;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, &preiatt,
+                        &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_statx(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_statx(glfd->fs, &postiatt, poststat);
+    }
+
+    if (ret <= 0)
+        goto out;
+
+    glfd->offset = (offset + iov.iov_len);
 out:
-        if (iobuf)
-                iobuf_unref (iobuf);
-        if (iobref)
-                iobref_unref (iobref);
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    if (iobref)
+        iobref_unref(iobref);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_copy_file_range, 6.0)
 ssize_t
-pub_glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags)
+pub_glfs_copy_file_range(struct glfs_fd *glfd_in, off64_t *off_in,
+                         struct glfs_fd *glfd_out, off64_t *off_out, size_t len,
+                         unsigned int flags, struct glfs_stat *statbuf,
+                         struct glfs_stat *prestat, struct glfs_stat *poststat)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
-
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    fd_t *fd_in = NULL;
+    fd_t *fd_out = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                iattbuf =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+    off64_t pos_in;
+    off64_t pos_out;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd_in, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FD(glfd_out, invalid_fs);
+
+    GF_REF_GET(glfd_in);
+    GF_REF_GET(glfd_out);
+
+    if (glfd_in->fs != glfd_out->fs) {
+        ret = -1;
+        errno = EXDEV;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd_in->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd_in = glfs_resolve_fd(glfd_in->fs, subvol, glfd_in);
+    if (!fd_in) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    fd_out = glfs_resolve_fd(glfd_out->fs, subvol, glfd_out);
+    if (!fd_out) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    /*
+     * This is based on how the vfs layer in the kernel handles
+     * copy_file_range call. Upon receiving it follows the
+     * below method to consider the offset.
+     * if (off_in != NULL)
+     *    use the value off_in to perform the op
+     * else if off_in == NULL
+     *    use the current file offset position to perform the op
+     *
+     * For gfapi, glfd->offset is used. For a freshly opened
+     * fd, the offset is set to 0.
+     */
+    if (off_in)
+        pos_in = *off_in;
+    else
+        pos_in = glfd_in->offset;
+
+    if (off_out)
+        pos_out = *off_out;
+    else
+        pos_out = glfd_out->offset;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_copy_file_range(subvol, fd_in, pos_in, fd_out, pos_out, len,
+                                 flags, &iattbuf, &preiatt, &postiatt, fop_attr,
+                                 NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        pos_in += ret;
+        pos_out += ret;
+
+        if (off_in)
+            *off_in = pos_in;
+        if (off_out)
+            *off_out = pos_out;
+
+        if (statbuf)
+            glfs_iatt_to_statx(glfd_in->fs, &iattbuf, statbuf);
+        if (prestat)
+            glfs_iatt_to_statx(glfd_in->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_statx(glfd_in->fs, &postiatt, poststat);
+    }
+
+    if (ret <= 0)
+        goto out;
+
+    /*
+     * If *off_in is NULL, then there is no offset info that can
+     * obtained from the input argument. Hence follow below method.
+     *  If *off_in is NULL, then
+     *     glfd->offset = offset + ret;
+     * else
+     *     do nothing.
+     *
+     * According to the man page of copy_file_range, if off_in is
+     * NULL, then the offset of the source file is advanced by
+     * the return value of the fop. The same applies to off_out as
+     * well. Otherwise, if *off_in is not NULL, then the offset
+     * is not advanced by the filesystem. The entity which sends
+     * the copy_file_range call is supposed to advance the offset
+     * value in its buffer (pointed to by *off_in or *off_out)
+     * by the return value of copy_file_range.
+     */
+    if (!off_in)
+        glfd_in->offset += ret;
+
+    if (!off_out)
+        glfd_out->offset += ret;
 
-	ret = pub_glfs_pwritev (glfd, &iov, 1, glfd->offset, flags);
+out:
+    if (fd_in)
+        fd_unref(fd_in);
+    if (fd_out)
+        fd_unref(fd_out);
+    if (glfd_in)
+        GF_REF_PUT(glfd_in);
+    if (glfd_out)
+        GF_REF_PUT(glfd_out);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	return ret;
-}
+    glfs_subvol_done(glfd_in->fs, subvol);
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0);
+    __GLFS_EXIT_FS;
 
+invalid_fs:
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0)
 ssize_t
-pub_glfs_writev (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                 int flags)
+pub_glfs_pwritev(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                 off_t offset, int flags)
 {
-	ssize_t      ret = 0;
-
-	ret = pub_glfs_pwritev (glfd, iov, count, glfd->offset, flags);
-
-	return ret;
+    return glfs_pwritev_common(glfd, iovec, iovcnt, offset, flags, NULL, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0)
 ssize_t
-pub_glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count,
-                 off_t offset, int flags)
+pub_glfs_write(struct glfs_fd *glfd, const void *buf, size_t count, int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
-
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_pwritev (glfd, &iov, 1, offset, flags);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, 3.4.0);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, glfd->offset, flags);
 
+    return ret;
+}
 
-extern glfs_t *pub_glfs_from_glfd (glfs_fd_t *);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0)
+ssize_t
+pub_glfs_writev(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                int flags)
+{
+    ssize_t ret = 0;
 
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-static int
-glfs_pwritev_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
-{
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0);
+    ret = pub_glfs_pwritev(glfd, iov, count, glfd->offset, flags);
 
-        return 0;
+    return ret;
 }
 
-int
-pub_glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec,
-                        int count, off_t offset, int flags, glfs_io_cbk fn,
-                        void *data)
+GFAPI_SYMVER_PUBLIC(glfs_pwrite34, glfs_pwrite, 3.4.0)
+ssize_t
+pub_glfs_pwrite34(struct glfs_fd *glfd, const void *buf, size_t count,
+                  off_t offset, int flags)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-        struct iobref  *iobref = NULL;
-        struct iobuf   *iobuf = NULL;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, offset, flags);
 
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    return ret;
+}
 
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, 6.0)
+ssize_t
+pub_glfs_pwrite(struct glfs_fd *glfd, const void *buf, size_t count,
+                off_t offset, int flags, struct glfs_stat *prestat,
+                struct glfs_stat *poststat)
+{
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                goto out;
-        }
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        gio->op     = GF_FOP_WRITE;
-        gio->glfd   = glfd;
-        gio->offset = offset;
-        gio->flags  = flags;
-        gio->fn     = fn;
-        gio->data   = data;
-        gio->count  = 1;
-        gio->iov = GF_CALLOC (gio->count, sizeof (*(gio->iov)),
-                              gf_common_mt_iovec);
-        if (!gio->iov) {
-                errno = ENOMEM;
-                goto out;
-        }
+    ret = glfs_pwritev_common(glfd, &iov, 1, offset, flags, prestat, poststat);
 
-        ret = glfs_buf_copy (subvol, iovec, count, &iobref, &iobuf, gio->iov);
-        if (ret)
-                goto out;
+    return ret;
+}
 
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
+extern glfs_t *
+pub_glfs_from_glfd(glfs_fd_t *);
 
-        frame->local = gio;
+static int
+glfs_pwritev_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
+{
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        STACK_WIND_COOKIE (frame, glfs_pwritev_async_cbk, subvol, subvol,
-                           subvol->fops->writev, fd, gio->iov,
-                           gio->count, offset, flags, iobref, NULL);
+    return 0;
+}
 
-        ret = 0;
+static int
+glfs_pwritev_async_common(struct glfs_fd *glfd, const struct iovec *iovec,
+                          int count, off_t offset, int flags,
+                          gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+{
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_WRITE;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->flags = flags;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+    gio->count = 1;
+    gio->iov = GF_CALLOC(gio->count, sizeof(*(gio->iov)), gf_common_mt_iovec);
+    if (!gio->iov) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, count, &iobref, &iobuf,
+                     gio->iov);
+    if (ret)
+        goto out;
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_pwritev_async_cbk, subvol, subvol,
+                      subvol->fops->writev, fd, gio->iov, gio->count, offset,
+                      flags, iobref, fop_attr);
+
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        /*
+         * If there is any error condition check after the frame
+         * creation, we have to destroy the frame root.
+         */
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    if (iobref)
+        iobref_unref(iobref);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC(glfs_pwritev_async34, glfs_pwritev_async, 3.4.0)
+int
+pub_glfs_pwritev_async34(struct glfs_fd *glfd, const struct iovec *iovec,
+                         int count, off_t offset, int flags, glfs_io_cbk34 fn,
+                         void *data)
+{
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_true, (void *)fn, data);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, 6.0)
 int
-pub_glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count,
-                      int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pwritev_async(struct glfs_fd *glfd, const struct iovec *iovec,
+                       int count, off_t offset, int flags, glfs_io_cbk fn,
+                       void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_false, fn, data);
+}
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+GFAPI_SYMVER_PUBLIC(glfs_write_async34, glfs_write_async, 3.4.0)
+int
+pub_glfs_write_async34(struct glfs_fd *glfd, const void *buf, size_t count,
+                       int flags, glfs_io_cbk34 fn, void *data)
+{
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_pwritev_async (glfd, &iov, 1, glfd->offset, flags, fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, 3.4.0);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                    _gf_true, (void *)fn, data);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, 6.0)
 int
-pub_glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count,
-                       off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_write_async(struct glfs_fd *glfd, const void *buf, size_t count,
+                     int flags, glfs_io_cbk fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
-
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_pwritev_async (glfd, &iov, 1, offset, flags, fn, data);
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-	return ret;
-}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, 3.4.0);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                    _gf_false, fn, data);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC(glfs_pwrite_async34, glfs_pwrite_async, 3.4.0)
 int
-pub_glfs_writev_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                       int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pwrite_async34(struct glfs_fd *glfd, const void *buf, int count,
+                        off_t offset, int flags, glfs_io_cbk34 fn, void *data)
 {
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	ret = pub_glfs_pwritev_async (glfd, iov, count, glfd->offset, flags,
-				   fn, data);
-	return ret;
-}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, 3.4.0);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                    (void *)fn, data);
 
+    return ret;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, 6.0)
 int
-pub_glfs_fsync (struct glfs_fd *glfd)
+pub_glfs_pwrite_async(struct glfs_fd *glfd, const void *buf, int count,
+                      off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                    data);
 
-	ret = syncop_fsync (subvol, fd, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    return ret;
+}
 
-	glfs_subvol_done (glfd->fs, subvol);
+GFAPI_SYMVER_PUBLIC(glfs_writev_async34, glfs_writev_async, 3.4.0)
+int
+pub_glfs_writev_async34(struct glfs_fd *glfd, const struct iovec *iov,
+                        int count, int flags, glfs_io_cbk34 fn, void *data)
+{
+    ssize_t ret = 0;
 
-        __GLFS_EXIT_FS;
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
-invalid_fs:
-	return ret;
+    ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags,
+                                    _gf_true, (void *)fn, data);
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, 3.4.0);
-
-static int
-glfs_fsync_async_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret,
-                      int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, 6.0)
+int
+pub_glfs_writev_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                      int flags, glfs_io_cbk fn, void *data)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0);
+    ssize_t ret = 0;
 
-        return 0;
+    if (glfd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
+
+    ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags,
+                                    _gf_false, fn, data);
+    return ret;
 }
 
 static int
-glfs_fsync_async_common (struct glfs_fd *glfd, glfs_io_cbk fn, void *data,
-			 int dataonly)
+glfs_fsync_common(struct glfs_fd *glfd, struct glfs_stat *prestat,
+                  struct glfs_stat *poststat)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = 0;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fsync(subvol, fd, 0, &preiatt, &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_statx(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_statx(glfd->fs, &postiatt, poststat);
+    }
+out:
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    __GLFS_EXIT_FS;
 
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                ret = -1;
-                errno = EBADFD;
-                goto out;
-        }
+invalid_fs:
+    return ret;
+}
 
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+GFAPI_SYMVER_PUBLIC(glfs_fsync34, glfs_fsync, 3.4.0)
+int
+pub_glfs_fsync34(struct glfs_fd *glfd)
+{
+    return glfs_fsync_common(glfd, NULL, NULL);
+}
 
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, 6.0)
+int
+pub_glfs_fsync(struct glfs_fd *glfd, struct glfs_stat *prestat,
+               struct glfs_stat *poststat)
+{
+    return glfs_fsync_common(glfd, prestat, poststat);
+}
 
-	gio->op     = GF_FOP_FSYNC;
-	gio->glfd   = glfd;
-	gio->flags  = dataonly;
-	gio->fn     = fn;
-	gio->data   = data;
+static int
+glfs_fsync_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
+{
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        frame->local = gio;
+    return 0;
+}
 
-        STACK_WIND_COOKIE (frame, glfs_fsync_async_cbk, subvol, subvol,
-                           subvol->fops->fsync, fd, dataonly, NULL);
+static int
+glfs_fsync_async_common(struct glfs_fd *glfd, gf_boolean_t oldcb,
+                        glfs_io_cbk fn, void *data, int dataonly)
+{
+    struct glfs_io *gio = NULL;
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    gio->op = GF_FOP_FSYNC;
+    gio->glfd = glfd;
+    gio->flags = dataonly;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    STACK_WIND_COOKIE(frame, glfs_fsync_async_cbk, subvol, subvol,
+                      subvol->fops->fsync, fd, dataonly, NULL);
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
-
-        return ret;
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC(glfs_fsync_async34, glfs_fsync_async, 3.4.0)
 int
-pub_glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fsync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        ret = glfs_fsync_async_common (glfd, fn, data, 0);
+    ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 0);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, 6.0)
 int
-pub_glfs_fdatasync (struct glfs_fd *glfd)
+pub_glfs_fsync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 0);
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    __GLFS_EXIT_FS;
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+invalid_fs:
+    return ret;
+}
 
-	ret = syncop_fsync (subvol, fd, 1, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+static int
+glfs_fdatasync_common(struct glfs_fd *glfd, struct glfs_stat *prestat,
+                      struct glfs_stat *poststat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fsync(subvol, fd, 1, &preiatt, &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_statx(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_statx(glfd->fs, &postiatt, poststat);
+    }
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, 3.4.0);
+GFAPI_SYMVER_PUBLIC(glfs_fdatasync34, glfs_fdatasync, 3.4.0)
+int
+pub_glfs_fdatasync34(struct glfs_fd *glfd)
+{
+    return glfs_fdatasync_common(glfd, NULL, NULL);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, 6.0)
+int
+pub_glfs_fdatasync(struct glfs_fd *glfd, struct glfs_stat *prestat,
+                   struct glfs_stat *poststat)
+{
+    return glfs_fdatasync_common(glfd, prestat, poststat);
+}
 
+GFAPI_SYMVER_PUBLIC(glfs_fdatasync_async34, glfs_fdatasync_async, 3.4.0)
 int
-pub_glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fdatasync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-	ret = glfs_fsync_async_common (glfd, fn, data, 1);
+    ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 1);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, 6.0)
 int
-pub_glfs_ftruncate (struct glfs_fd *glfd, off_t offset)
+pub_glfs_fdatasync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 1);
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    __GLFS_EXIT_FS;
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+invalid_fs:
+    return ret;
+}
 
-	ret = syncop_ftruncate (subvol, fd, offset, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+static int
+glfs_ftruncate_common(struct glfs_fd *glfd, off_t offset,
+                      struct glfs_stat *prestat, struct glfs_stat *poststat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_ftruncate(subvol, fd, offset, &preiatt, &postiatt, fop_attr,
+                           NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_statx(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_statx(glfd->fs, &postiatt, poststat);
+    }
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC(glfs_ftruncate34, glfs_ftruncate, 3.4.0)
 int
-pub_glfs_truncate (struct glfs *fs, const char *path, off_t length)
+pub_glfs_ftruncate34(struct glfs_fd *glfd, off_t offset)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-        int              reval = 0;
+    return glfs_ftruncate_common(glfd, offset, NULL, NULL);
+}
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, 6.0)
+int
+pub_glfs_ftruncate(struct glfs_fd *glfd, off_t offset,
+                   struct glfs_stat *prestat, struct glfs_stat *poststat)
+{
+    return glfs_ftruncate_common(glfd, offset, prestat, poststat);
+}
 
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_truncate, 3.7.15)
+int
+pub_glfs_truncate(struct glfs *fs, const char *path, off_t length)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-        ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-        ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = syncop_truncate (subvol, &loc, length, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_truncate(subvol, &loc, length, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_truncate, 3.7.15);
-
-
 static int
-glfs_ftruncate_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iatt *prebuf, struct iatt *postbuf,
-                          dict_t *xdata)
+glfs_ftruncate_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
-int
-pub_glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset, glfs_io_cbk fn,
-                          void *data)
+static int
+glfs_ftruncate_async_common(struct glfs_fd *glfd, off_t offset,
+                            gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_FTRUNCATE;
-	gio->glfd   = glfd;
-	gio->offset = offset;
-	gio->fn     = fn;
-	gio->data   = data;
-
-        frame->local = gio;
-
-        STACK_WIND_COOKIE (frame, glfs_ftruncate_async_cbk, subvol, subvol,
-                           subvol->fops->ftruncate, fd, offset, NULL);
-
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_FTRUNCATE;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_ftruncate_async_cbk, subvol, subvol,
+                      subvol->fops->ftruncate, fd, offset, fop_attr);
+
+    ret = 0;
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, 3.4.0);
+GFAPI_SYMVER_PUBLIC(glfs_ftruncate_async34, glfs_ftruncate_async, 3.4.0)
+int
+pub_glfs_ftruncate_async34(struct glfs_fd *glfd, off_t offset, glfs_io_cbk34 fn,
+                           void *data)
+{
+    return glfs_ftruncate_async_common(glfd, offset, _gf_true, (void *)fn,
+                                       data);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, 6.0)
+int
+pub_glfs_ftruncate_async(struct glfs_fd *glfd, off_t offset, glfs_io_cbk fn,
+                         void *data)
+{
+    return glfs_ftruncate_async_common(glfd, offset, _gf_false, fn, data);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_access, 3.4.0)
 int
-pub_glfs_access (struct glfs *fs, const char *path, int mode)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_access(struct glfs *fs, const char *path, int mode)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_access (subvol, &loc, mode, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_access(subvol, &loc, mode, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_access, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_symlink, 3.4.0)
 int
-pub_glfs_symlink (struct glfs *fs, const char *data, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_symlink(struct glfs *fs, const char *data, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_symlink, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readlink, 3.4.0)
 int
-pub_glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-	char            *linkval = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_readlink(struct glfs *fs, const char *path, char *buf, size_t bufsiz)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+    char *linkval = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type != IA_IFLNK) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    if (iatt.ia_type != IA_IFLNK) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret > 0) {
-		memcpy (buf, linkval, ret);
-		GF_FREE (linkval);
-	}
+    ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret > 0) {
+        memcpy(buf, linkval, ret);
+        GF_FREE(linkval);
+    }
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readlink, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mknod, 3.4.0)
 int
-pub_glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_mknod(struct glfs *fs, const char *path, mode_t mode, dev_t dev)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mknod, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mkdir, 3.4.0)
 int
-pub_glfs_mkdir (struct glfs *fs, const char *path, mode_t mode)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_mkdir(struct glfs *fs, const char *path, mode_t mode)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mkdir, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unlink, 3.4.0)
 int
-pub_glfs_unlink (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_unlink(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type == IA_IFDIR) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
+    if (iatt.ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
 
-	ret = syncop_unlink (subvol, &loc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* TODO: Add leaseid */
+    ret = syncop_unlink(subvol, &loc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unlink, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rmdir, 3.4.0)
 int
-pub_glfs_rmdir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_rmdir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type != IA_IFDIR) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
+    if (iatt.ia_type != IA_IFDIR) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
 
-	ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rmdir, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rename, 3.4.0)
 int
-pub_glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            oldloc = {0, };
-	loc_t            newloc = {0, };
-	struct iatt      oldiatt = {0, };
-	struct iatt      newiatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_rename(struct glfs *fs, const char *oldpath, const char *newpath)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval);
+    ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &oldloc, retry);
+    ESTALE_RETRY(ret, errno, reval, &oldloc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 retrynew:
-	ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &newloc, retrynew);
-
-	if (ret && errno != ENOENT && newloc.parent)
-		goto out;
-
-	if (newiatt.ia_type != IA_INVAL) {
-                if ((oldiatt.ia_type == IA_IFDIR) !=
-                    (newiatt.ia_type == IA_IFDIR)) {
-                       /* Either both old and new must be dirs,
-                        * or both must be non-dirs. Else, fail.
-                        */
-                       ret = -1;
-                       errno = EISDIR;
-                       goto out;
-                }
+    ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &newloc, retrynew);
+
+    if (ret && errno != ENOENT && newloc.parent)
+        goto out;
+
+    if (newiatt.ia_type != IA_INVAL) {
+        if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) {
+            /* Either both old and new must be dirs,
+             * or both must be non-dirs. Else, fail.
+             */
+            ret = -1;
+            errno = EISDIR;
+            goto out;
         }
+    }
 
-	/* TODO: check if new or old is a prefix of the other, and fail EINVAL */
+    /* TODO: - check if new or old is a prefix of the other, and fail EINVAL
+     *       - Add leaseid */
 
-	ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	if (ret == -1 && errno == ESTALE) {
-		if (reval < DEFAULT_REVAL_COUNT) {
-			reval++;
-			loc_wipe (&oldloc);
-			loc_wipe (&newloc);
-			goto retry;
-		}
-	}
+    if (ret == -1 && errno == ESTALE) {
+        if (reval < DEFAULT_REVAL_COUNT) {
+            reval++;
+            loc_wipe(&oldloc);
+            loc_wipe(&newloc);
+            goto retry;
+        }
+    }
 
-	if (ret == 0)
-		inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
-			      newloc.parent, newloc.name, oldloc.inode,
-			      &oldiatt);
+    if (ret == 0) {
+        inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name,
+                     newloc.parent, newloc.name, oldloc.inode, &oldiatt);
+
+        if (newloc.inode && !inode_has_dentry(newloc.inode))
+            inode_forget(newloc.inode, 0);
+    }
 out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rename, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_link, 3.4.0)
 int
-pub_glfs_link (struct glfs *fs, const char *oldpath, const char *newpath)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            oldloc = {0, };
-	loc_t            newloc = {0, };
-	struct iatt      oldiatt = {0, };
-	struct iatt      newiatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_link(struct glfs *fs, const char *oldpath, const char *newpath)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval);
+    ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &oldloc, retry);
+    ESTALE_RETRY(ret, errno, reval, &oldloc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 retrynew:
-	ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval);
+    ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &newloc, retrynew);
+
+    if (ret == 0) {
+        ret = -1;
+        errno = EEXIST;
+        goto out;
+    }
+
+    if (oldiatt.ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    /* Filling the inode of the hard link to be same as that of the
+       original file
+    */
+    if (newloc.inode) {
+        inode_unref(newloc.inode);
+        newloc.inode = NULL;
+    }
+    newloc.inode = inode_ref(oldloc.inode);
+
+    ret = syncop_link(subvol, &oldloc, &newloc, &newiatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == -1 && errno == ESTALE) {
+        loc_wipe(&oldloc);
+        loc_wipe(&newloc);
+        if (reval--)
+            goto retry;
+    }
+
+    if (ret == 0)
+        ret = glfs_loc_link(&newloc, &newiatt);
+out:
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-	ESTALE_RETRY (ret, errno, reval, &newloc, retrynew);
+    glfs_subvol_done(fs, subvol);
 
-	if (ret == 0) {
-		ret = -1;
-		errno = EEXIST;
-		goto out;
-	}
+    __GLFS_EXIT_FS;
 
-	if (oldiatt.ia_type == IA_IFDIR) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
+invalid_fs:
+    return ret;
+}
 
-        /* Filling the inode of the hard link to be same as that of the
-           original file
-        */
-	if (newloc.inode) {
-		inode_unref (newloc.inode);
-		newloc.inode = NULL;
-	}
-        newloc.inode = inode_ref (oldloc.inode);
-
-	ret = syncop_link (subvol, &oldloc, &newloc, &newiatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret == -1 && errno == ESTALE) {
-		loc_wipe (&oldloc);
-		loc_wipe (&newloc);
-		if (reval--)
-			goto retry;
-	}
-
-	if (ret == 0)
-		ret = glfs_loc_link (&newloc, &newiatt);
-out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_opendir, 3.4.0)
+struct glfs_fd *
+pub_glfs_opendir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    INIT_LIST_HEAD(&glfd->entries);
+retry:
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	glfs_subvol_done (fs, subvol);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-        __GLFS_EXIT_FS;
+    if (ret)
+        goto out;
 
-invalid_fs:
-	return ret;
-}
+    if (!IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_link, 3.4.0);
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
 
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-struct glfs_fd *
-pub_glfs_opendir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
-
-	INIT_LIST_HEAD (&glfd->entries);
-retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret)
-		goto out;
-
-	if (!IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (ret && glfd) {
-		GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd->state = GLFD_OPEN;
-		fd_bind (glfd->fd);
-		glfs_fd_bind (glfd);
-	}
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_opendir, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_closedir, 3.4.0)
 int
-pub_glfs_closedir (struct glfs_fd *glfd)
+pub_glfs_closedir(struct glfs_fd *glfd)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-	gf_dirent_free (list_entry (&glfd->entries, gf_dirent_t, list));
+    gf_dirent_free(list_entry(&glfd->entries, gf_dirent_t, list));
 
-        glfs_mark_glfd_for_deletion (glfd);
+    glfs_mark_glfd_for_deletion(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        ret = 0;
+    ret = 0;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_closedir, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_telldir, 3.4.0)
 long
-pub_glfs_telldir (struct glfs_fd *fd)
+pub_glfs_telldir(struct glfs_fd *fd)
 {
-	return fd->offset;
-}
-
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_telldir, 3.4.0);
+    if (fd == NULL) {
+        errno = EBADF;
+        return -1;
+    }
 
+    return fd->offset;
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0)
 void
-pub_glfs_seekdir (struct glfs_fd *fd, long offset)
+pub_glfs_seekdir(struct glfs_fd *fd, long offset)
 {
-	gf_dirent_t *entry = NULL;
-	gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-	if (fd->offset == offset)
-		return;
+    if (fd == NULL) {
+        errno = EBADF;
+        return;
+    }
 
-	fd->offset = offset;
-	fd->next = NULL;
+    if (fd->offset == offset)
+        return;
 
-	list_for_each_entry_safe (entry, tmp, &fd->entries, list) {
-		if (entry->d_off != offset)
-			continue;
+    fd->offset = offset;
+    fd->next = NULL;
 
-		if (&tmp->list != &fd->entries) {
-			/* found! */
-			fd->next = tmp;
-			return;
-		}
-	}
-	/* could not find entry at requested offset in the cache.
-	   next readdir_r() will result in glfd_entry_refresh()
-	*/
-}
+    list_for_each_entry_safe(entry, tmp, &fd->entries, list)
+    {
+        if (entry->d_off != offset)
+            continue;
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0);
+        if (&tmp->list != &fd->entries) {
+            /* found! */
+            fd->next = tmp;
+            return;
+        }
+    }
+    /* could not find entry at requested offset in the cache.
+       next readdir_r() will result in glfd_entry_refresh()
+    */
+}
 
 static int
-glfs_discard_async_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this, int32_t op_ret,
-                        int32_t op_errno, struct iatt *preop_stbuf,
-                        struct iatt *postop_stbuf, dict_t *xdata)
+glfs_discard_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno,
+                       struct iatt *preop_stbuf, struct iatt *postop_stbuf,
+                       dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        return 0;
+    return 0;
 }
 
-int
-pub_glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
-                        glfs_io_cbk fn, void *data)
+static int
+glfs_discard_async_common(struct glfs_fd *glfd, off_t offset, size_t len,
+                          gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_DISCARD;
-	gio->glfd   = glfd;
-	gio->offset = offset;
-	gio->count  = len;
-	gio->fn     = fn;
-	gio->data   = data;
-
-        frame->local = gio;
-
-        STACK_WIND_COOKIE (frame, glfs_discard_async_cbk, subvol, subvol,
-                           subvol->fops->discard, fd, offset, len, NULL);
-
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_DISCARD;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->count = len;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_discard_async_cbk, subvol, subvol,
+                      subvol->fops->discard, fd, offset, len, fop_attr);
+
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, 3.5.0);
-
-
-static int
-glfs_zerofill_async_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret,
-                         int32_t op_errno, struct iatt *preop_stbuf,
-                         struct iatt *postop_stbuf, dict_t *xdata)
+GFAPI_SYMVER_PUBLIC(glfs_discard_async35, glfs_discard_async, 3.5.0)
+int
+pub_glfs_discard_async35(struct glfs_fd *glfd, off_t offset, size_t len,
+                         glfs_io_cbk34 fn, void *data)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0);
-
-        return 0;
+    return glfs_discard_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                     data);
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, 6.0)
 int
-pub_glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
-                         glfs_io_cbk fn, void *data)
+pub_glfs_discard_async(struct glfs_fd *glfd, off_t offset, size_t len,
+                       glfs_io_cbk fn, void *data)
 {
-        struct glfs_io *gio  = NULL;
-        int             ret  = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                goto out;
-        }
+    return glfs_discard_async_common(glfd, offset, len, _gf_false, fn, data);
+}
 
-        gio->op     = GF_FOP_ZEROFILL;
-        gio->glfd   = glfd;
-        gio->offset = offset;
-        gio->count  = len;
-        gio->fn     = fn;
-        gio->data   = data;
+static int
+glfs_zerofill_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        struct iatt *preop_stbuf, struct iatt *postop_stbuf,
+                        dict_t *xdata)
+{
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        frame->local = gio;
+    return 0;
+}
 
-        STACK_WIND_COOKIE (frame, glfs_zerofill_async_cbk, subvol, subvol,
-                           subvol->fops->zerofill, fd, offset, len, NULL);
-        ret = 0;
+static int
+glfs_zerofill_async_common(struct glfs_fd *glfd, off_t offset, off_t len,
+                           gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+{
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_ZEROFILL;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->count = len;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_zerofill_async_cbk, subvol, subvol,
+                      subvol->fops->zerofill, fd, offset, len, fop_attr);
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, 3.5.0);
+GFAPI_SYMVER_PUBLIC(glfs_zerofill_async35, glfs_zerofill_async, 3.5.0)
+int
+pub_glfs_zerofill_async35(struct glfs_fd *glfd, off_t offset, off_t len,
+                          glfs_io_cbk34 fn, void *data)
+{
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                      data);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, 6.0)
+int
+pub_glfs_zerofill_async(struct glfs_fd *glfd, off_t offset, off_t len,
+                        glfs_io_cbk fn, void *data)
+{
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_false, fn, data);
+}
 
 void
-gf_dirent_to_dirent (gf_dirent_t *gf_dirent, struct dirent *dirent)
+gf_dirent_to_dirent(gf_dirent_t *gf_dirent, struct dirent *dirent)
 {
-	dirent->d_ino = gf_dirent->d_ino;
+    dirent->d_ino = gf_dirent->d_ino;
 
 #ifdef _DIRENT_HAVE_D_OFF
-	dirent->d_off = gf_dirent->d_off;
+    dirent->d_off = gf_dirent->d_off;
 #endif
 
 #ifdef _DIRENT_HAVE_D_TYPE
-	dirent->d_type = gf_dirent->d_type;
+    dirent->d_type = gf_dirent->d_type;
 #endif
 
 #ifdef _DIRENT_HAVE_D_NAMLEN
-	dirent->d_namlen = strlen (gf_dirent->d_name);
+    dirent->d_namlen = strlen(gf_dirent->d_name);
 #endif
 
-	strncpy (dirent->d_name, gf_dirent->d_name, NAME_MAX);
-	dirent->d_name[NAME_MAX] = 0;
+    snprintf(dirent->d_name, NAME_MAX + 1, "%s", gf_dirent->d_name);
 }
 
-
 int
-glfd_entry_refresh (struct glfs_fd *glfd, int plus)
-{
-	xlator_t        *subvol = NULL;
-	gf_dirent_t      entries;
-	gf_dirent_t      old;
-        gf_dirent_t     *entry = NULL;
-	int              ret = -1;
-	fd_t            *fd = NULL;
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	if (fd->inode->ia_type != IA_IFDIR) {
-		ret = -1;
-		errno = EBADF;
-		goto out;
-	}
-
-	INIT_LIST_HEAD (&entries.list);
-	INIT_LIST_HEAD (&old.list);
-
-	if (plus)
-		ret = syncop_readdirp (subvol, fd, 131072, glfd->offset,
-				       &entries, NULL, NULL);
-	else
-		ret = syncop_readdir (subvol, fd, 131072, glfd->offset,
-				      &entries, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret >= 0) {
-		if (plus) {
-                        /**
-                         * Set inode_needs_lookup flag before linking the
-                         * inode. Doing it later post linkage might lead
-                         * to a race where a fop comes after inode link
-                         * but before setting need_lookup flag.
-                         */
-                        list_for_each_entry (entry, &entries.list, list) {
-                                if (entry->inode)
-                                        inode_set_need_lookup (entry->inode, THIS);
-                                else if (!IA_ISDIR (entry->d_stat.ia_type)) {
-                                        /* entry->inode for directories will be
-                                         * always set to null to force a lookup
-                                         * on the dentry. Also we will have
-                                         * proper stat if directory present on
-                                         * hashed subvolume.
-                                         */
-                                        gf_fill_iatt_for_dirent (entry,
-                                                                 fd->inode,
-                                                                 subvol);
-                                }
-                        }
-
-			gf_link_inodes_from_dirent (THIS, fd->inode, &entries);
+glfd_entry_refresh(struct glfs_fd *glfd, int plus)
+{
+    xlator_t *subvol = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t old;
+    gf_dirent_t *entry = NULL;
+    int ret = -1;
+    fd_t *fd = NULL;
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    if (fd->inode->ia_type != IA_IFDIR) {
+        ret = -1;
+        errno = EBADF;
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&entries.list);
+    INIT_LIST_HEAD(&old.list);
+
+    if (plus)
+        ret = syncop_readdirp(subvol, fd, 131072, glfd->offset, &entries, NULL,
+                              NULL);
+    else
+        ret = syncop_readdir(subvol, fd, 131072, glfd->offset, &entries, NULL,
+                             NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret >= 0) {
+        if (plus) {
+            list_for_each_entry(entry, &entries.list, list)
+            {
+                if ((!entry->inode && (!IA_ISDIR(entry->d_stat.ia_type))) ||
+                    ((entry->d_stat.ia_ctime == 0) &&
+                     strcmp(entry->d_name, ".") &&
+                     strcmp(entry->d_name, ".."))) {
+                    /* entry->inode for directories will be
+                     * always set to null to force a lookup
+                     * on the dentry. Hence to not degrade
+                     * readdir performance, we skip lookups
+                     * for directory entries. Also we will have
+                     * proper stat if directory present on
+                     * hashed subvolume.
+                     *
+                     * In addition, if the stat is invalid, force
+                     * lookup to fetch proper stat.
+                     */
+                    gf_fill_iatt_for_dirent(entry, fd->inode, subvol);
                 }
+            }
 
-		list_splice_init (&glfd->entries, &old.list);
-		list_splice_init (&entries.list, &glfd->entries);
+            gf_link_inodes_from_dirent(THIS, fd->inode, &entries);
+        }
 
-		/* spurious errno is dangerous for glfd_entry_next() */
-		errno = 0;
-	}
+        list_splice_init(&glfd->entries, &old.list);
+        list_splice_init(&entries.list, &glfd->entries);
 
+        /* spurious errno is dangerous for glfd_entry_next() */
+        errno = 0;
+    }
 
-	if (ret > 0)
-		glfd->next = list_entry (glfd->entries.next, gf_dirent_t, list);
+    if (ret > 0)
+        glfd->next = list_entry(glfd->entries.next, gf_dirent_t, list);
 
-	gf_dirent_free (&old);
+    gf_dirent_free(&old);
 out:
-	if (fd)
-		fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-	return ret;
+    return ret;
 }
 
-
 gf_dirent_t *
-glfd_entry_next (struct glfs_fd *glfd, int plus)
+glfd_entry_next(struct glfs_fd *glfd, int plus)
 {
-	gf_dirent_t     *entry = NULL;
-	int              ret = -1;
+    gf_dirent_t *entry = NULL;
+    int ret = -1;
 
-	if (!glfd->offset || !glfd->next) {
-		ret = glfd_entry_refresh (glfd, plus);
-		if (ret < 0)
-			return NULL;
-	}
+    if (!glfd->offset || !glfd->next) {
+        ret = glfd_entry_refresh(glfd, plus);
+        if (ret < 0)
+            return NULL;
+    }
 
-	entry = glfd->next;
-	if (!entry)
-		return NULL;
+    entry = glfd->next;
+    if (!entry)
+        return NULL;
 
-	if (&entry->next->list == &glfd->entries)
-		glfd->next = NULL;
-	else
-		glfd->next = entry->next;
+    if (&entry->next->list == &glfd->entries)
+        glfd->next = NULL;
+    else
+        glfd->next = entry->next;
 
-	glfd->offset = entry->d_off;
+    glfd->offset = entry->d_off;
 
-	return entry;
+    return entry;
 }
 
-
 struct dirent *
-glfs_readdirbuf_get (struct glfs_fd *glfd)
+glfs_readdirbuf_get(struct glfs_fd *glfd)
 {
-        struct dirent *buf = NULL;
-
-        LOCK (&glfd->fd->lock);
-        {
-                buf = glfd->readdirbuf;
-                if (buf) {
-                        memset (buf, 0, READDIRBUF_SIZE);
-                        goto unlock;
-                }
-
-                buf = GF_CALLOC (1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t);
-                if (!buf) {
-                        errno = ENOMEM;
-                        goto unlock;
-                }
+    struct dirent *buf = NULL;
+
+    LOCK(&glfd->fd->lock);
+    {
+        buf = glfd->readdirbuf;
+        if (buf) {
+            memset(buf, 0, READDIRBUF_SIZE);
+            goto unlock;
+        }
 
-                glfd->readdirbuf = buf;
+        buf = GF_CALLOC(1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t);
+        if (!buf) {
+            errno = ENOMEM;
+            goto unlock;
         }
+
+        glfd->readdirbuf = buf;
+    }
 unlock:
-        UNLOCK (&glfd->fd->lock);
+    UNLOCK(&glfd->fd->lock);
 
-        return buf;
+    return buf;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus_r, 3.4.0)
 int
-pub_glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat,
-                        struct dirent *ext, struct dirent **res)
+pub_glfs_readdirplus_r(struct glfs_fd *glfd, struct stat *stat,
+                       struct dirent *ext, struct dirent **res)
 {
-	int              ret = 0;
-	gf_dirent_t     *entry = NULL;
-	struct dirent   *buf = NULL;
+    int ret = 0;
+    gf_dirent_t *entry = NULL;
+    struct dirent *buf = NULL;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-	errno = 0;
+    errno = 0;
 
-	if (ext)
-		buf = ext;
-	else
-		buf = glfs_readdirbuf_get (glfd);
+    if (ext)
+        buf = ext;
+    else
+        buf = glfs_readdirbuf_get(glfd);
 
-	if (!buf) {
-		errno = ENOMEM;
-                ret = -1;
-                goto out;
-	}
+    if (!buf) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-	entry = glfd_entry_next (glfd, !!stat);
-	if (errno)
-		ret = -1;
+    entry = glfd_entry_next(glfd, !!stat);
+    if (errno)
+        ret = -1;
 
-	if (res) {
-		if (entry)
-			*res = buf;
-		else
-			*res = NULL;
-	}
+    if (res) {
+        if (entry)
+            *res = buf;
+        else
+            *res = NULL;
+    }
 
-	if (entry) {
-		gf_dirent_to_dirent (entry, buf);
-		if (stat)
-			glfs_iatt_to_stat (glfd->fs, &entry->d_stat, stat);
-	}
+    if (entry) {
+        gf_dirent_to_dirent(entry, buf);
+        if (stat)
+            glfs_iatt_to_stat(glfd->fs, &entry->d_stat, stat);
+    }
 
 out:
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus_r, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir_r, 3.4.0)
 int
-pub_glfs_readdir_r (struct glfs_fd *glfd, struct dirent *buf,
-                    struct dirent **res)
+pub_glfs_readdir_r(struct glfs_fd *glfd, struct dirent *buf,
+                   struct dirent **res)
 {
-	return pub_glfs_readdirplus_r (glfd, 0, buf, res);
+    return pub_glfs_readdirplus_r(glfd, 0, buf, res);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir_r, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus, 3.5.0)
 struct dirent *
-pub_glfs_readdirplus (struct glfs_fd *glfd, struct stat *stat)
+pub_glfs_readdirplus(struct glfs_fd *glfd, struct stat *stat)
 {
-        struct dirent *res = NULL;
-        int ret = -1;
+    struct dirent *res = NULL;
+    int ret = -1;
 
-        ret = pub_glfs_readdirplus_r (glfd, stat, NULL, &res);
-        if (ret)
-                return NULL;
+    ret = pub_glfs_readdirplus_r(glfd, stat, NULL, &res);
+    if (ret)
+        return NULL;
 
-        return res;
+    return res;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir, 3.5.0)
 struct dirent *
-pub_glfs_readdir (struct glfs_fd *glfd)
+pub_glfs_readdir(struct glfs_fd *glfd)
 {
-        return pub_glfs_readdirplus (glfd, NULL);
+    return pub_glfs_readdirplus(glfd, NULL);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_statvfs, 3.4.0)
 int
-pub_glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_statvfs(struct glfs *fs, const char *path, struct statvfs *buf)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_statfs (subvol, &loc, buf, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_statfs(subvol, &loc, buf, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_statvfs, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setattr, 6.0)
 int
-glfs_setattr (struct glfs *fs, const char *path, struct iatt *iatt,
-	      int valid, int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      riatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_setattr(struct glfs *fs, const char *path, struct glfs_stat *stat,
+                 int follow)
+{
+    int ret = -1;
+    int glvalid;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt riatt = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    GF_VALIDATE_OR_GOTO("glfs_setattr", stat, out);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &riatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &riatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &riatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &riatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    if (ret)
+        goto out;
 
-	if (ret)
-		goto out;
+    glfs_iatt_from_statx(&iatt, stat);
+    glfsflags_from_gfapiflags(stat, &glvalid);
 
-	ret = syncop_setattr (subvol, &loc, iatt, valid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* TODO : Add leaseid */
+    ret = syncop_setattr(subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetattr, 6.0)
 int
-glfs_fsetattr (struct glfs_fd *glfd, struct iatt *iatt, int valid)
+pub_glfs_fsetattr(struct glfs_fd *glfd, struct glfs_stat *stat)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fsetattr (subvol, fd, iatt, valid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    int glvalid;
+    struct iatt iatt = {
+        0,
+    };
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    GF_VALIDATE_OR_GOTO("glfs_fsetattr", stat, out);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    glfs_iatt_from_statx(&iatt, stat);
+    glfsflags_from_gfapiflags(stat, &glvalid);
+
+    /* TODO : Add leaseid */
+    ret = syncop_fsetattr(subvol, fd, &iatt, glvalid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chmod, 3.4.0)
 int
-pub_glfs_chmod (struct glfs *fs, const char *path, mode_t mode)
+pub_glfs_chmod(struct glfs *fs, const char *path, mode_t mode)
 {
-	int              ret = -1;
-	struct iatt      iatt = {0, };
-	int              valid = 0;
+    int ret = -1;
+    struct glfs_stat stat = {
+        0,
+    };
 
-	iatt.ia_prot = ia_prot_from_st_mode (mode);
-	valid = GF_SET_ATTR_MODE;
+    stat.glfs_st_mode = mode;
+    stat.glfs_st_mask = GLFS_STAT_MODE;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    ret = glfs_setattr(fs, path, &stat, 1);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chmod, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchmod, 3.4.0)
 int
-pub_glfs_fchmod (struct glfs_fd *glfd, mode_t mode)
+pub_glfs_fchmod(struct glfs_fd *glfd, mode_t mode)
 {
-	int              ret = -1;
-	struct iatt      iatt = {0, };
-	int              valid = 0;
+    int ret = -1;
+    struct glfs_stat stat = {
+        0,
+    };
 
-	iatt.ia_prot = ia_prot_from_st_mode (mode);
-	valid = GF_SET_ATTR_MODE;
+    stat.glfs_st_mode = mode;
+    stat.glfs_st_mask = GLFS_STAT_MODE;
 
-	ret = glfs_fsetattr (glfd, &iatt, valid);
+    ret = glfs_fsetattr(glfd, &stat);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchmod, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chown, 3.4.0)
 int
-pub_glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_chown(struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    struct glfs_stat stat = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-                iatt.ia_uid = uid;
-                valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        stat.glfs_st_uid = uid;
+        stat.glfs_st_mask = GLFS_STAT_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        stat.glfs_st_gid = gid;
+        stat.glfs_st_mask = stat.glfs_st_mask | GLFS_STAT_GID;
+    }
 
-        if (valid)
-	        ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    if (stat.glfs_st_mask)
+        ret = glfs_setattr(fs, path, &stat, 1);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chown, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lchown, 3.4.0)
 int
-pub_glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_lchown(struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    struct glfs_stat stat = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-	        iatt.ia_uid = uid;
-	        valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        stat.glfs_st_uid = uid;
+        stat.glfs_st_mask = GLFS_STAT_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        stat.glfs_st_gid = gid;
+        stat.glfs_st_mask = stat.glfs_st_mask | GLFS_STAT_GID;
+    }
 
-        if (valid)
-	        ret = glfs_setattr (fs, path, &iatt, valid, 0);
+    if (stat.glfs_st_mask)
+        ret = glfs_setattr(fs, path, &stat, 0);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lchown, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchown, 3.4.0)
 int
-pub_glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid)
+pub_glfs_fchown(struct glfs_fd *glfd, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    struct glfs_stat stat = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-                iatt.ia_uid = uid;
-                valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        stat.glfs_st_uid = uid;
+        stat.glfs_st_mask = GLFS_STAT_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        stat.glfs_st_gid = gid;
+        stat.glfs_st_mask = stat.glfs_st_mask | GLFS_STAT_GID;
+    }
 
-        if (valid)
-	        ret = glfs_fsetattr (glfd, &iatt, valid);
+    if (stat.glfs_st_mask)
+        ret = glfs_fsetattr(glfd, &stat);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchown, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_utimens, 3.4.0)
 int
-pub_glfs_utimens (struct glfs *fs, const char *path,
-                  const struct timespec times[2])
+pub_glfs_utimens(struct glfs *fs, const char *path,
+                 const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    struct glfs_stat stat = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    stat.glfs_st_atime = times[0];
+    stat.glfs_st_mtime = times[1];
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    stat.glfs_st_mask = GLFS_STAT_ATIME | GLFS_STAT_MTIME;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    ret = glfs_setattr(fs, path, &stat, 1);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_utimens, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lutimens, 3.4.0)
 int
-pub_glfs_lutimens (struct glfs *fs, const char *path,
-                   const struct timespec times[2])
+pub_glfs_lutimens(struct glfs *fs, const char *path,
+                  const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    struct glfs_stat stat = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    stat.glfs_st_atime = times[0];
+    stat.glfs_st_mtime = times[1];
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    stat.glfs_st_mask = GLFS_STAT_ATIME | GLFS_STAT_MTIME;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 0);
+    ret = glfs_setattr(fs, path, &stat, 0);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lutimens, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_futimens, 3.4.0)
 int
-pub_glfs_futimens (struct glfs_fd *glfd, const struct timespec times[2])
+pub_glfs_futimens(struct glfs_fd *glfd, const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    struct glfs_stat stat = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    stat.glfs_st_atime = times[0];
+    stat.glfs_st_mtime = times[1];
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    stat.glfs_st_mask = GLFS_STAT_ATIME | GLFS_STAT_MTIME;
 
-	ret = glfs_fsetattr (glfd, &iatt, valid);
+    ret = glfs_fsetattr(glfd, &stat);
 
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_futimens, 3.4.0);
-
-
 int
-glfs_getxattr_process (void *value, size_t size, dict_t *xattr,
-		       const char *name)
-{
-	data_t *data = NULL;
-	int     ret = -1;
-
-	data = dict_get (xattr, (char *)name);
-	if (!data) {
-		errno = ENODATA;
-		ret = -1;
-		goto out;
-	}
-
-	ret = data->len;
-	if (!value || !size)
-		goto out;
-
-	if (size < ret) {
-		ret = -1;
-		errno = ERANGE;
-		goto out;
-	}
-
-	memcpy (value, data->data, ret);
+glfs_getxattr_process(void *value, size_t size, dict_t *xattr, const char *name)
+{
+    data_t *data = NULL;
+    int ret = -1;
+
+    data = dict_get(xattr, (char *)name);
+    if (!data) {
+        errno = ENODATA;
+        ret = -1;
+        goto out;
+    }
+
+    ret = data->len;
+    if (!value || !size)
+        goto out;
+
+    if (size < ret) {
+        ret = -1;
+        errno = ERANGE;
+        goto out;
+    }
+
+    memcpy(value, data->data, ret);
 out:
-	return ret;
+    return ret;
 }
 
-
 ssize_t
-glfs_getxattr_common (struct glfs *fs, const char *path, const char *name,
-		      void *value, size_t size, int follow)
+glfs_getxattr_common(struct glfs *fs, const char *path, const char *name,
+                     void *value, size_t size, int follow)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_getxattr (subvol, &loc, &xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_getxattr(subvol, &loc, &xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = glfs_getxattr_process (value, size, xattr, name);
+    ret = glfs_getxattr_process(value, size, xattr, name);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getxattr, 3.4.0)
 ssize_t
-pub_glfs_getxattr (struct glfs *fs, const char *path, const char *name,
-                   void *value, size_t size)
+pub_glfs_getxattr(struct glfs *fs, const char *path, const char *name,
+                  void *value, size_t size)
 {
-	return glfs_getxattr_common (fs, path, name, value, size, 1);
+    return glfs_getxattr_common(fs, path, name, value, size, 1);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lgetxattr, 3.4.0)
 ssize_t
-pub_glfs_lgetxattr (struct glfs *fs, const char *path, const char *name,
-                    void *value, size_t size)
+pub_glfs_lgetxattr(struct glfs *fs, const char *path, const char *name,
+                   void *value, size_t size)
 {
-	return glfs_getxattr_common (fs, path, name, value, size, 0);
+    return glfs_getxattr_common(fs, path, name, value, size, 0);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lgetxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0)
 ssize_t
-pub_glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value,
-                    size_t size)
+pub_glfs_fgetxattr(struct glfs_fd *glfd, const char *name, void *value,
+                   size_t size)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fgetxattr (subvol, fd, &xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	ret = glfs_getxattr_process (value, size, xattr, name);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fgetxattr(subvol, fd, &xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    ret = glfs_getxattr_process(value, size, xattr, name);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (xattr)
-                dict_unref (xattr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0);
-
-
 int
-glfs_listxattr_process (void *value, size_t size, dict_t *xattr)
+glfs_listxattr_process(void *value, size_t size, dict_t *xattr)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (!xattr)
-		goto out;
+    if (!xattr)
+        goto out;
 
-	ret = dict_keys_join (NULL, 0, xattr, NULL);
+    ret = dict_keys_join(NULL, 0, xattr, NULL);
 
-        if (!value || !size)
-                goto out;
+    if (!value || !size)
+        goto out;
 
-	if (size < ret) {
-		ret = -1;
-		errno = ERANGE;
-	} else {
-		dict_keys_join (value, size, xattr, NULL);
-	}
+    if (size < ret) {
+        ret = -1;
+        errno = ERANGE;
+    } else {
+        dict_keys_join(value, size, xattr, NULL);
+    }
 
 out:
-	return ret;
+    return ret;
 }
 
-
 ssize_t
-glfs_listxattr_common (struct glfs *fs, const char *path, void *value,
-		       size_t size, int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_listxattr_common(struct glfs *fs, const char *path, void *value,
+                      size_t size, int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_getxattr (subvol, &loc, &xattr, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_getxattr(subvol, &loc, &xattr, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = glfs_listxattr_process (value, size, xattr);
+    ret = glfs_listxattr_process(value, size, xattr);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_listxattr, 3.4.0)
 ssize_t
-pub_glfs_listxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_listxattr(struct glfs *fs, const char *path, void *value, size_t size)
 {
-	return glfs_listxattr_common (fs, path, value, size, 1);
+    return glfs_listxattr_common(fs, path, value, size, 1);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_listxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_llistxattr, 3.4.0)
 ssize_t
-pub_glfs_llistxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_llistxattr(struct glfs *fs, const char *path, void *value, size_t size)
 {
-	return glfs_listxattr_common (fs, path, value, size, 0);
+    return glfs_listxattr_common(fs, path, value, size, 0);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_llistxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_flistxattr, 3.4.0)
 ssize_t
-pub_glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fgetxattr (subvol, fd, &xattr, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	ret = glfs_listxattr_process (value, size, xattr);
+pub_glfs_flistxattr(struct glfs_fd *glfd, void *value, size_t size)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fgetxattr(subvol, fd, &xattr, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    ret = glfs_listxattr_process(value, size, xattr);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (xattr)
-                dict_unref (xattr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_flistxattr, 3.4.0);
-
 int
-glfs_setxattr_common (struct glfs *fs, const char *path, const char *name,
-		      const void *value, size_t size, int flags, int follow)
+glfs_setxattr_common(struct glfs *fs, const char *path, const char *name,
+                     const void *value, size_t size, int flags, int follow)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
-        void            *value_cp = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+    void *value_cp = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
 
-	xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-	if (!xattr) {
-                GF_FREE (value_cp);
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-	loc_wipe (&loc);
-	if (xattr)
-		dict_unref (xattr);
+    loc_wipe(&loc);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setxattr, 3.4.0)
 int
-pub_glfs_setxattr (struct glfs *fs, const char *path, const char *name,
-                   const void *value, size_t size, int flags)
+pub_glfs_setxattr(struct glfs *fs, const char *path, const char *name,
+                  const void *value, size_t size, int flags)
 {
-	return glfs_setxattr_common (fs, path, name, value, size, flags, 1);
+    return glfs_setxattr_common(fs, path, name, value, size, flags, 1);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lsetxattr, 3.4.0)
 int
-pub_glfs_lsetxattr (struct glfs *fs, const char *path, const char *name,
-                    const void *value, size_t size, int flags)
+pub_glfs_lsetxattr(struct glfs *fs, const char *path, const char *name,
+                   const void *value, size_t size, int flags)
 {
-	return glfs_setxattr_common (fs, path, name, value, size, flags, 0);
+    return glfs_setxattr_common(fs, path, name, value, size, flags, 0);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lsetxattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetxattr, 3.4.0)
 int
-pub_glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value,
-                    size_t size, int flags)
+pub_glfs_fsetxattr(struct glfs_fd *glfd, const char *name, const void *value,
+                   size_t size, int flags)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-        void            *value_cp = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
-
-	xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-	if (!xattr) {
-                GF_FREE (value_cp);
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	ret = syncop_fsetxattr (subvol, fd, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+    void *value_cp = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
+
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_fsetxattr(subvol, fd, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (xattr)
-		dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetxattr, 3.4.0);
-
-
 int
-glfs_removexattr_common (struct glfs *fs, const char *path, const char *name,
-			 int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_removexattr_common(struct glfs *fs, const char *path, const char *name,
+                        int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_removexattr (subvol, &loc, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_removexattr(subvol, &loc, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_removexattr, 3.4.0)
 int
-pub_glfs_removexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_removexattr(struct glfs *fs, const char *path, const char *name)
 {
-	return glfs_removexattr_common (fs, path, name, 1);
+    return glfs_removexattr_common(fs, path, name, 1);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_removexattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lremovexattr, 3.4.0)
 int
-pub_glfs_lremovexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_lremovexattr(struct glfs *fs, const char *path, const char *name)
 {
-	return glfs_removexattr_common (fs, path, name, 0);
+    return glfs_removexattr_common(fs, path, name, 0);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lremovexattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fremovexattr, 3.4.0)
 int
-pub_glfs_fremovexattr (struct glfs_fd *glfd, const char *name)
+pub_glfs_fremovexattr(struct glfs_fd *glfd, const char *name)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fremovexattr (subvol, fd, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fremovexattr(subvol, fd, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fremovexattr, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fallocate, 3.5.0)
 int
-pub_glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len)
+pub_glfs_fallocate(struct glfs_fd *glfd, int keep_size, off_t offset,
+                   size_t len)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t		*fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fallocate (subvol, fd, keep_size, offset, len, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fallocate(subvol, fd, keep_size, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fallocate, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard, 3.5.0)
 int
-pub_glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len)
+pub_glfs_discard(struct glfs_fd *glfd, off_t offset, size_t len)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t		*fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_discard (subvol, fd, offset, len, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_discard(subvol, fd, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill, 3.5.0)
 int
-pub_glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len)
+pub_glfs_zerofill(struct glfs_fd *glfd, off_t offset, off_t len)
 {
-        int               ret             = -1;
-        xlator_t         *subvol          = NULL;
-        fd_t             *fd              = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        ret = syncop_zerofill (subvol, fd, offset, len, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_zerofill(subvol, fd, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        if (fd)
-                fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chdir, 3.4.0)
 int
-pub_glfs_chdir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_chdir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (!IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
+    if (!IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
 
-	glfs_cwd_set (fs, loc.inode);
+    glfs_cwd_set(fs, loc.inode);
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chdir, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0)
 int
-pub_glfs_fchdir (struct glfs_fd *glfd)
-{
-	int       ret = -1;
-	inode_t  *inode = NULL;
-	xlator_t *subvol = NULL;
-	fd_t     *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	inode = fd->inode;
-
-	if (!IA_ISDIR (inode->ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
-
-	glfs_cwd_set (glfd->fs, inode);
-	ret = 0;
+pub_glfs_fchdir(struct glfs_fd *glfd)
+{
+    int ret = -1;
+    inode_t *inode = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    inode = fd->inode;
+
+    if (!IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
+
+    glfs_cwd_set(glfd->fs, inode);
+    ret = 0;
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0);
-
 static gf_boolean_t warn_realpath = _gf_true; /* log once */
 
 static char *
-glfs_realpath_common (struct glfs *fs, const char *path, char *resolved_path,
-                      gf_boolean_t warn_deprecated)
-{
-	int              ret = -1;
-	char            *retpath = NULL;
-	char            *allocpath = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	if (resolved_path)
-		retpath = resolved_path;
-        else if (warn_deprecated) {
-                retpath = allocpath = malloc (PATH_MAX + 1);
-                if (warn_realpath) {
-                        warn_realpath = _gf_false;
-                        gf_log (THIS->name, GF_LOG_WARNING, "this application "
-                                "is compiled against an old version of "
-                                "libgfapi, it should use glfs_free() to "
-                                "release the path returned by "
-                                "glfs_realpath()");
-                }
-        } else {
-                retpath = allocpath = GF_CALLOC (1, PATH_MAX + 1,
-                                                 glfs_mt_realpath_t);
+glfs_realpath_common(struct glfs *fs, const char *path, char *resolved_path,
+                     gf_boolean_t warn_deprecated)
+{
+    int ret = -1;
+    char *retpath = NULL;
+    char *allocpath = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (resolved_path)
+        retpath = resolved_path;
+    else if (warn_deprecated) {
+        retpath = allocpath = malloc(PATH_MAX + 1);
+        if (warn_realpath) {
+            warn_realpath = _gf_false;
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "this application "
+                   "is compiled against an old version of "
+                   "libgfapi, it should use glfs_free() to "
+                   "release the path returned by "
+                   "glfs_realpath()");
         }
-
-	if (!retpath) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    } else {
+        retpath = allocpath = GLFS_CALLOC(1, PATH_MAX + 1, NULL,
+                                          glfs_mt_realpath_t);
+    }
+
+    if (!retpath) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (loc.path) {
-		strncpy (retpath, loc.path, PATH_MAX);
-		retpath[PATH_MAX] = 0;
-	}
+    if (loc.path) {
+        snprintf(retpath, PATH_MAX + 1, "%s", loc.path);
+    }
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (ret == -1) {
-                if (warn_deprecated && allocpath)
-                        free (allocpath);
-                else if (allocpath)
-                        GF_FREE (allocpath);
-                retpath = NULL;
-	}
+    if (ret == -1) {
+        if (warn_deprecated && allocpath)
+            free(allocpath);
+        else if (allocpath)
+            GLFS_FREE(allocpath);
+        retpath = NULL;
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return retpath;
+    return retpath;
 }
 
-
+GFAPI_SYMVER_PUBLIC(glfs_realpath34, glfs_realpath, 3.4.0)
 char *
-pub_glfs_realpath34 (struct glfs *fs, const char *path, char *resolved_path)
+pub_glfs_realpath34(struct glfs *fs, const char *path, char *resolved_path)
 {
-        return glfs_realpath_common (fs, path, resolved_path, _gf_true);
+    return glfs_realpath_common(fs, path, resolved_path, _gf_true);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_realpath34, glfs_realpath, 3.4.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_realpath, 3.7.17)
 char *
-pub_glfs_realpath (struct glfs *fs, const char *path, char *resolved_path)
+pub_glfs_realpath(struct glfs *fs, const char *path, char *resolved_path)
 {
-        return glfs_realpath_common (fs, path, resolved_path, _gf_false);
+    return glfs_realpath_common(fs, path, resolved_path, _gf_false);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_realpath, 3.7.17);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getcwd, 3.4.0)
+char *
+pub_glfs_getcwd(struct glfs *fs, char *buf, size_t n)
+{
+    int ret = -1;
+    inode_t *inode = NULL;
+    char *path = NULL;
 
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-char *
-pub_glfs_getcwd (struct glfs *fs, char *buf, size_t n)
-{
-	int              ret = -1;
-	inode_t         *inode = NULL;
-	char            *path = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	if (!buf || n < 2) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	inode = glfs_cwd_get (fs);
-
-	if (!inode) {
-		strncpy (buf, "/", n);
-		ret = 0;
-		goto out;
-	}
-
-	ret = inode_path (inode, 0, &path);
-	if (n <= ret) {
-		ret = -1;
-		errno = ERANGE;
-		goto out;
-	}
-
-	strncpy (buf, path, n);
-	ret = 0;
+    if (!buf || n < 2) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    inode = glfs_cwd_get(fs);
+
+    if (!inode) {
+        strncpy(buf, "/", n);
+        ret = 0;
+        goto out;
+    }
+
+    ret = inode_path(inode, 0, &path);
+    if (n <= ret) {
+        ret = -1;
+        errno = ERANGE;
+        goto out;
+    }
+
+    strncpy(buf, path, n);
+    ret = 0;
 out:
-	GF_FREE (path);
+    GF_FREE(path);
 
-	if (inode)
-		inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	if (ret < 0)
-		return NULL;
+    if (ret < 0)
+        return NULL;
 
-	return buf;
+    return buf;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getcwd, 3.4.0);
-
-
 static void
-gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock)
+gf_flock_to_flock(struct gf_flock *gf_flock, struct flock *flock)
 {
-	flock->l_type   = gf_flock->l_type;
-	flock->l_whence = gf_flock->l_whence;
-	flock->l_start  = gf_flock->l_start;
-	flock->l_len    = gf_flock->l_len;
-	flock->l_pid    = gf_flock->l_pid;
+    flock->l_type = gf_flock->l_type;
+    flock->l_whence = gf_flock->l_whence;
+    flock->l_start = gf_flock->l_start;
+    flock->l_len = gf_flock->l_len;
+    flock->l_pid = gf_flock->l_pid;
 }
 
-
 static void
-gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock)
+gf_flock_from_flock(struct gf_flock *gf_flock, struct flock *flock)
 {
-	gf_flock->l_type   = flock->l_type;
-	gf_flock->l_whence = flock->l_whence;
-	gf_flock->l_start  = flock->l_start;
-	gf_flock->l_len    = flock->l_len;
-	gf_flock->l_pid    = flock->l_pid;
+    gf_flock->l_type = flock->l_type;
+    gf_flock->l_whence = flock->l_whence;
+    gf_flock->l_start = flock->l_start;
+    gf_flock->l_len = flock->l_len;
+    gf_flock->l_pid = flock->l_pid;
 }
 
+static int
+glfs_lock_common(struct glfs_fd *glfd, int cmd, struct flock *flock,
+                 dict_t *xdata)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    struct gf_flock gf_flock = {
+        0,
+    };
+    struct gf_flock saved_flock = {
+        0,
+    };
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    if (!flock) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    GF_REF_GET(glfd);
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    /* Generate glusterfs flock structure from client flock
+     * structure to be processed by server */
+    gf_flock_from_flock(&gf_flock, flock);
+
+    /* Keep another copy of flock for split/merge of locks
+     * at client side */
+    gf_flock_from_flock(&saved_flock, flock);
+
+    if (glfd->lk_owner.len != 0) {
+        ret = syncopctx_setfslkowner(&glfd->lk_owner);
+
+        if (ret)
+            goto out;
+    }
 
-int
-pub_glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	struct gf_flock  gf_flock = {0, };
-	struct gf_flock  saved_flock = {0, };
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	gf_flock_from_flock (&gf_flock, flock);
-	gf_flock_from_flock (&saved_flock, flock);
-
-        if (glfd->lk_owner.len != 0) {
-                ret = syncopctx_setfslkowner (&glfd->lk_owner);
-
-                if (ret)
-                        goto out;
-        }
+    ret = get_fop_attr_thrd_key(&xdata);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-	ret = syncop_lk (subvol, fd, cmd, &gf_flock, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	gf_flock_to_flock (&gf_flock, flock);
+    ret = syncop_lk(subvol, fd, cmd, &gf_flock, xdata, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* Convert back from gf_flock to flock as expected by application */
+    gf_flock_to_flock(&gf_flock, flock);
+
+    if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) {
+        ret = fd_lk_insert_and_merge(fd, cmd, &saved_flock);
+        if (ret) {
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0,
+                    API_MSG_LOCK_INSERT_MERGE_FAILED, "gfid=%s",
+                    uuid_utoa(fd->inode->gfid), NULL);
+            ret = 0;
+        }
+    }
 
-	if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW))
-		fd_lk_insert_and_merge (fd, cmd, &saved_flock);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_file_lock, 4.0.0)
+int
+pub_glfs_file_lock(struct glfs_fd *glfd, int cmd, struct flock *flock,
+                   glfs_lock_mode_t lk_mode)
+{
+    int ret = -1;
+    dict_t *xdata_in = NULL;
+
+    if (lk_mode == GLFS_LK_MANDATORY) {
+        /* Create a new dictionary */
+        xdata_in = dict_new();
+        if (xdata_in == NULL) {
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
+        }
 
+        /* Set GF_LK_MANDATORY internally within dictionary to map
+         * GLFS_LK_MANDATORY */
+        ret = dict_set_uint32(xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY);
+        if (ret) {
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0,
+                    API_MSG_SETTING_LOCK_TYPE_FAILED, NULL);
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    ret = glfs_lock_common(glfd, cmd, flock, xdata_in);
+out:
+    if (xdata_in)
+        dict_unref(xdata_in);
+
+    return ret;
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0)
 int
-pub_glfs_fd_set_lkowner (glfs_fd_t *glfd, void *data, int len)
+pub_glfs_posix_lock(struct glfs_fd *glfd, int cmd, struct flock *flock)
 {
-        int ret = -1;
+    return glfs_lock_common(glfd, cmd, flock, NULL);
+}
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fd_set_lkowner, 3.10.7)
+int
+pub_glfs_fd_set_lkowner(struct glfs_fd *glfd, void *data, int len)
+{
+    int ret = -1;
 
-        if (!GF_REF_GET (glfd)) {
-                goto invalid_fs;
-        }
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, data, out);
+    if (!GF_REF_GET(glfd)) {
+        goto invalid_fs;
+    }
 
-        if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) {
-                errno = EINVAL;
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "Invalid lk_owner len (%d)", len);
-                goto out;
-        }
+    GF_VALIDATE_OR_GOTO(THIS->name, data, out);
 
-        glfd->lk_owner.len = len;
+    if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) {
+        errno = EINVAL;
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "lk_owner len=%d", len, NULL);
+        goto out;
+    }
 
-        memcpy (glfd->lk_owner.data, data, len);
+    glfd->lk_owner.len = len;
 
-        ret = 0;
+    memcpy(glfd->lk_owner.data, data, len);
+
+    ret = 0;
 out:
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fd_set_lkowner, 3.10.7);
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_dup, 3.4.0)
 struct glfs_fd *
-pub_glfs_dup (struct glfs_fd *glfd)
-{
-	xlator_t  *subvol = NULL;
-	fd_t      *fd = NULL;
-	glfs_fd_t *dupfd = NULL;
-	struct glfs *fs = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	fs = glfd->fs;
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (fs, subvol, glfd);
-	if (!fd) {
-		errno = EBADFD;
-		goto out;
-	}
-
-	dupfd = glfs_fd_new (fs);
-	if (!dupfd) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	dupfd->fd = fd_ref (fd);
-        dupfd->state = glfd->state;
+pub_glfs_dup(struct glfs_fd *glfd)
+{
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct glfs_fd *dupfd = NULL;
+    struct glfs *fs = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    fs = glfd->fs;
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    dupfd = glfs_fd_new(fs);
+    if (!dupfd) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    dupfd->fd = fd_ref(fd);
+    dupfd->state = glfd->state;
 out:
-	if (fd)
-		fd_unref (fd);
-	if (dupfd)
-		glfs_fd_bind (dupfd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (dupfd)
+        glfs_fd_bind(dupfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return dupfd;
+    return dupfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_dup, 3.4.0);
+static void
+glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
+{
+    int ret = -1;
+    upcall_entry *u_list = NULL;
 
-/*
- * This routine is called in case of any notification received
- * from the server. All the upcall events are queued up in a list
- * to be read by the applications.
- *
- * XXX: Applications may register a cbk function for each 'fs'
- * which then needs to be called by this routine incase of any
- * event received. The cbk fn is responsible for notifying the
- * applications the way it desires for each event queued (for eg.,
- * can raise a signal or broadcast a cond variable etc.)
- */
-void
-priv_glfs_process_upcall_event (struct glfs *fs, void *data)
+    if (!fs || !upcall_data)
+        goto out;
+
+    u_list = GF_CALLOC(1, sizeof(*u_list), glfs_mt_upcall_entry_t);
+
+    if (!u_list) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&u_list->upcall_list);
+
+    gf_uuid_copy(u_list->upcall_data.gfid, upcall_data->gfid);
+    u_list->upcall_data.event_type = upcall_data->event_type;
+
+    switch (upcall_data->event_type) {
+        case GF_UPCALL_CACHE_INVALIDATION:
+            ret = glfs_get_upcall_cache_invalidation(&u_list->upcall_data,
+                                                     upcall_data);
+            break;
+        case GF_UPCALL_RECALL_LEASE:
+            ret = glfs_get_upcall_lease(&u_list->upcall_data, upcall_data);
+            break;
+        default:
+            break;
+    }
+
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, NULL);
+        goto out;
+    }
+
+    pthread_mutex_lock(&fs->upcall_list_mutex);
+    {
+        list_add_tail(&u_list->upcall_list, &fs->upcall_list);
+    }
+    pthread_mutex_unlock(&fs->upcall_list_mutex);
+
+    ret = 0;
+
+out:
+    if (ret && u_list) {
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    }
+}
+
+static void
+glfs_free_upcall_lease(void *to_free)
 {
-        int                ret             = -1;
-        upcall_entry       *u_list         = NULL;
-        glusterfs_ctx_t    *ctx            = NULL;
-        struct gf_upcall   *upcall_data    = NULL;
+    struct glfs_upcall_lease *arg = to_free;
+
+    if (!arg)
+        return;
 
-        gf_msg_debug (THIS->name, 0,
-                      "Upcall gfapi callback is called");
+    if (arg->object)
+        glfs_h_close(arg->object);
 
-        if (!fs || !data)
-                goto out;
+    GF_FREE(arg);
+}
 
-        /* Unlike in I/O path, "glfs_fini" would not have freed
-         * 'fs' by the time we take lock as it waits for all epoll
-         * threads to exit including this
-         */
-        pthread_mutex_lock (&fs->mutex);
+int
+glfs_recall_lease_fd(struct glfs *fs, struct gf_upcall *up_data)
+{
+    struct gf_upcall_recall_lease *recall_lease = NULL;
+    xlator_t *subvol = NULL;
+    int ret = 0;
+    inode_t *inode = NULL;
+    struct glfs_fd *glfd = NULL;
+    struct glfs_fd *tmp = NULL;
+    struct list_head glfd_list;
+    fd_t *fd = NULL;
+    uint64_t value = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("gfapi", up_data, out);
+    GF_VALIDATE_OR_GOTO("gfapi", fs, out);
+
+    recall_lease = up_data->data;
+    GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out);
+
+    INIT_LIST_HEAD(&glfd_list);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s",
+                 uuid_utoa(up_data->gfid));
+
+    inode = inode_find(subvol->itable, up_data->gfid);
+    if (!inode) {
+        ret = -1;
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INODE_FIND_FAILED,
+                "gfid=%s", uuid_utoa(up_data->gfid), "graph_id=%d",
+                subvol->graph->id, NULL);
+        goto out;
+    }
+
+    LOCK(&inode->lock);
+    {
+        list_for_each_entry(fd, &inode->fd_list, inode_list)
         {
-                ctx = fs->ctx;
+            ret = fd_ctx_get(fd, subvol, &value);
+            glfd = (struct glfs_fd *)(uintptr_t)value;
+            if (glfd) {
+                gf_msg_trace(THIS->name, 0, "glfd (%p) has held lease", glfd);
+                GF_REF_GET(glfd);
+                list_add_tail(&glfd->list, &glfd_list);
+            }
+        }
+    }
+    UNLOCK(&inode->lock);
 
-                /* if we're not interested in upcalls (anymore), skip them */
-                if (ctx->cleanup_started || !fs->cache_upcalls) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto out;
+    if (!list_empty(&glfd_list)) {
+        list_for_each_entry_safe(glfd, tmp, &glfd_list, list)
+        {
+            LOCK(&glfd->lock);
+            {
+                if (glfd->state != GLFD_CLOSE) {
+                    gf_msg_trace(THIS->name, 0,
+                                 "glfd (%p) has held lease, "
+                                 "calling recall cbk",
+                                 glfd);
+                    glfd->cbk(lease, glfd->cookie);
                 }
+            }
+            UNLOCK(&glfd->lock);
 
-                fs->pin_refcnt++;
+            list_del_init(&glfd->list);
+            GF_REF_PUT(glfd);
         }
-        pthread_mutex_unlock (&fs->mutex);
+    }
 
+out:
+    return ret;
+}
 
-        upcall_data = (struct gf_upcall *)data;
+static int
+glfs_recall_lease_upcall(struct glfs *fs, struct glfs_upcall *up_arg,
+                         struct gf_upcall *up_data)
+{
+    struct gf_upcall_recall_lease *recall_lease = NULL;
+    struct glfs_object *object = NULL;
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    struct glfs_upcall_lease *up_lease_arg = NULL;
+
+    GF_VALIDATE_OR_GOTO("gfapi", up_data, out);
+    GF_VALIDATE_OR_GOTO("gfapi", fs, out);
+
+    recall_lease = up_data->data;
+    GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s",
+                 uuid_utoa(up_data->gfid));
+
+    object = glfs_h_find_handle(fs, up_data->gfid, GFAPI_HANDLE_LENGTH);
+    if (!object) {
+        /* The reason handle creation will fail is because we
+         * couldn't find the inode in the gfapi inode table.
+         *
+         * But since application would have taken inode_ref, the
+         * only case when this can happen is when it has closed
+         * the handle and hence will no more be interested in
+         * the upcall for this particular gfid.
+         */
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "gfid=%s", uuid_utoa(up_data->gfid), NULL);
+        errno = ESTALE;
+        goto out;
+    }
 
-        gf_msg_trace (THIS->name, 0, "Upcall gfapi gfid = %s"
-                      "ret = %d", (char *)(upcall_data->gfid), ret);
+    up_lease_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_lease),
+                             glfs_mt_upcall_inode_t);
+    up_lease_arg->object = object;
 
-        u_list = GF_CALLOC (1, sizeof(*u_list),
-                            glfs_mt_upcall_entry_t);
+    GF_VALIDATE_OR_GOTO("glfs_recall_lease", up_lease_arg, out);
 
-        if (!u_list) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    up_lease_arg->lease_type = recall_lease->lease_type;
 
-        INIT_LIST_HEAD (&u_list->upcall_list);
+    up_arg->reason = GLFS_UPCALL_RECALL_LEASE;
+    up_arg->event = up_lease_arg;
+    up_arg->free_event = glfs_free_upcall_lease;
 
-        gf_uuid_copy (u_list->upcall_data.gfid, upcall_data->gfid);
-        u_list->upcall_data.event_type = upcall_data->event_type;
+    ret = 0;
 
+out:
+    if (ret) {
+        /* Close p_object and oldp_object as well if being referenced.*/
+        if (object)
+            glfs_h_close(object);
+
+        /* Set reason to prevent applications from using ->event */
+        up_arg->reason = GF_UPCALL_EVENT_NULL;
+    }
+    return ret;
+}
+
+static int
+upcall_syncop_args_free(struct upcall_syncop_args *args)
+{
+    dict_t *dict = NULL;
+    struct gf_upcall *upcall_data = NULL;
+
+    if (args) {
+        upcall_data = &args->upcall_data;
         switch (upcall_data->event_type) {
-        case GF_UPCALL_CACHE_INVALIDATION:
-                ret = glfs_get_upcall_cache_invalidation (&u_list->upcall_data,
-                                                          upcall_data);
+            case GF_UPCALL_CACHE_INVALIDATION:
+                dict = ((struct gf_upcall_cache_invalidation *)(upcall_data
+                                                                    ->data))
+                           ->dict;
+                break;
+            case GF_UPCALL_RECALL_LEASE:
+                dict = ((struct gf_upcall_recall_lease *)(upcall_data->data))
+                           ->dict;
                 break;
-        default:
-                goto out;
         }
+        if (dict)
+            dict_unref(dict);
+
+        GF_FREE(upcall_data->client_uid);
+        GF_FREE(upcall_data->data);
+    }
+    GF_FREE(args);
+    return 0;
+}
 
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall entry validation failed.");
-                goto out;
-        }
+static int
+glfs_upcall_syncop_cbk(int ret, call_frame_t *frame, void *opaque)
+{
+    struct upcall_syncop_args *args = opaque;
 
-        pthread_mutex_lock (&fs->upcall_list_mutex);
-        {
-                list_add_tail (&u_list->upcall_list,
-                               &fs->upcall_list);
-        }
-        pthread_mutex_unlock (&fs->upcall_list_mutex);
+    (void)upcall_syncop_args_free(args);
 
-        pthread_mutex_lock (&fs->mutex);
-        {
-                fs->pin_refcnt--;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+    return 0;
+}
 
+static int
+glfs_cbk_upcall_syncop(void *opaque)
+{
+    struct upcall_syncop_args *args = opaque;
+    struct gf_upcall *upcall_data = NULL;
+    struct glfs_upcall *up_arg = NULL;
+    struct glfs *fs;
+    int ret = -1;
+
+    fs = args->fs;
+    upcall_data = &args->upcall_data;
+
+    if (!upcall_data) {
+        goto out;
+    }
+
+    up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall), glfs_release_upcall,
+                         glfs_mt_upcall_entry_t);
+    if (!up_arg) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
+
+    switch (upcall_data->event_type) {
+        case GF_UPCALL_CACHE_INVALIDATION:
+            ret = glfs_h_poll_cache_invalidation(fs, up_arg, upcall_data);
+            break;
+        case GF_UPCALL_RECALL_LEASE:
+            ret = glfs_recall_lease_upcall(fs, up_arg, upcall_data);
+            break;
+        default:
+            errno = EINVAL;
+    }
+
+    /* It could so happen that the file which got
+     * upcall notification may have got deleted by
+     * the same client. In such cases up_arg->reason
+     * is set to GLFS_UPCALL_EVENT_NULL. No need to
+     * send upcall then
+     */
+    if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) {
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                API_MSG_UPCALL_EVENT_NULL_RECEIVED, NULL);
         ret = 0;
+        GLFS_FREE(up_arg);
+        goto out;
+    } else if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, NULL);
+        GLFS_FREE(up_arg);
+        goto out;
+    }
+
+    if (fs->up_cbk && up_arg)
+        (fs->up_cbk)(up_arg, fs->up_data);
+
+    /* application takes care of calling glfs_free on up_arg post
+     * their processing */
+
 out:
-        if (ret && u_list) {
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE(u_list);
-        }
-        return;
+    return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_process_upcall_event, 3.7.0);
+static struct gf_upcall_cache_invalidation *
+gf_copy_cache_invalidation(struct gf_upcall_cache_invalidation *src)
+{
+    struct gf_upcall_cache_invalidation *dst = NULL;
 
-ssize_t
-glfs_anonymous_pwritev (struct glfs *fs, struct glfs_object *object,
-                        const struct iovec *iovec, int iovcnt,
-                        off_t offset, int flags)
-{
-        xlator_t        *subvol = NULL;
-        struct iobref   *iobref = NULL;
-        struct iobuf    *iobuf  = NULL;
-        struct iovec    iov     = {0, };
-        inode_t         *inode  = NULL;
-        fd_t            *fd     = NULL;
-        int             ret     = -1;
-        size_t          size    = -1;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    if (!src)
+        goto out;
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
+    dst = GF_CALLOC(1, sizeof(struct gf_upcall_cache_invalidation),
+                    glfs_mt_upcall_entry_t);
 
-        fd = fd_anonymous (inode);
-        if (!fd) {
-                ret = -1;
-                gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                errno = ENOMEM;
-                goto out;
-        }
+    if (!dst) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
 
-        size = iov_length (iovec, iovcnt);
+    dst->flags = src->flags;
+    dst->expire_time_attr = src->expire_time_attr;
+    dst->stat = src->stat;
+    dst->p_stat = src->p_stat;
+    dst->oldp_stat = src->oldp_stat;
 
-        iobuf = iobuf_get2 (subvol->ctx->iobuf_pool, size);
-        if (!iobuf) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    if (src->dict)
+        dst->dict = dict_copy_with_ref(src->dict, NULL);
 
-        iobref = iobref_new ();
-        if (!iobref) {
-                iobuf_unref (iobuf);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    return dst;
+out:
+    return NULL;
+}
 
-        ret = iobref_add (iobref, iobuf);
-        if (ret) {
-                iobuf_unref (iobuf);
-                iobref_unref (iobref);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
+static struct gf_upcall_recall_lease *
+gf_copy_recall_lease(struct gf_upcall_recall_lease *src)
+{
+    struct gf_upcall_recall_lease *dst = NULL;
+
+    if (!src)
+        goto out;
+
+    dst = GF_CALLOC(1, sizeof(struct gf_upcall_recall_lease),
+                    glfs_mt_upcall_entry_t);
+
+    if (!dst) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
+        goto out;
+    }
+
+    dst->lease_type = src->lease_type;
+    memcpy(dst->tid, src->tid, 16);
+
+    if (src->dict)
+        dst->dict = dict_copy_with_ref(src->dict, NULL);
+
+    return dst;
+out:
+    return NULL;
+}
+
+static struct upcall_syncop_args *
+upcall_syncop_args_init(struct glfs *fs, struct gf_upcall *upcall_data)
+{
+    struct upcall_syncop_args *args = NULL;
+    int ret = -1;
+    struct gf_upcall *t_data = NULL;
+
+    if (!fs || !upcall_data)
+        goto out;
+
+    args = GF_CALLOC(1, sizeof(struct upcall_syncop_args),
+                     glfs_mt_upcall_entry_t);
+    if (!args) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
+                "syncop args", NULL);
+        goto out;
+    }
+
+    /* Note: we are not taking any ref on fs here.
+     * Ideally applications have to unregister for upcall events
+     * or stop polling for upcall events before performing
+     * glfs_fini. And as for outstanding synctasks created, we wait
+     * for all syncenv threads to finish tasks before cleaning up the
+     * fs->ctx. Hence it seems safe to process these callback
+     * notification without taking any lock/ref.
+     */
+    args->fs = fs;
+    t_data = &(args->upcall_data);
+    t_data->client_uid = gf_strdup(upcall_data->client_uid);
+
+    gf_uuid_copy(t_data->gfid, upcall_data->gfid);
+    t_data->event_type = upcall_data->event_type;
+
+    switch (t_data->event_type) {
+        case GF_UPCALL_CACHE_INVALIDATION:
+            t_data->data = gf_copy_cache_invalidation(
+                (struct gf_upcall_cache_invalidation *)upcall_data->data);
+            break;
+        case GF_UPCALL_RECALL_LEASE:
+            t_data->data = gf_copy_recall_lease(
+                (struct gf_upcall_recall_lease *)upcall_data->data);
+            break;
+    }
+
+    if (!t_data->data)
+        goto out;
+
+    return args;
+out:
+    if (ret) {
+        if (args) {
+            GF_FREE(args->upcall_data.client_uid);
+            GF_FREE(args);
         }
+    }
+
+    return NULL;
+}
 
-        iov_unload (iobuf_ptr (iobuf), iovec, iovcnt);
+static void
+glfs_cbk_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
+{
+    struct upcall_syncop_args *args = NULL;
+    int ret = -1;
 
-        iov.iov_base = iobuf_ptr (iobuf);
-        iov.iov_len = size;
+    if (!fs || !upcall_data)
+        goto out;
 
-        ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags,
-                             NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (!(fs->upcall_events & upcall_data->event_type)) {
+        /* ignore events which application hasn't registered*/
+        goto out;
+    }
 
-        iobuf_unref (iobuf);
-        iobref_unref (iobref);
+    args = upcall_syncop_args_init(fs, upcall_data);
 
-        if (ret <= 0)
-                goto out;
+    if (!args)
+        goto out;
+
+    ret = synctask_new(THIS->ctx->env, glfs_cbk_upcall_syncop,
+                       glfs_upcall_syncop_cbk, NULL, args);
+    /* should we retry incase of failure? */
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_UPCALL_SYNCOP_FAILED,
+                "event_type=%d", upcall_data->event_type, "gfid=%s",
+                (char *)(upcall_data->gfid), NULL);
+        upcall_syncop_args_free(args);
+    }
 
 out:
+    return;
+}
 
-        if (fd)
-                fd_unref(fd);
+/*
+ * This routine is called in case of any notification received
+ * from the server. All the upcall events are queued up in a list
+ * to be read by the applications.
+ *
+ * In case if the application registers a cbk function, that shall
+ * be called by this routine in case of any event received.
+ * The cbk fn is responsible for notifying the
+ * applications the way it desires for each event queued (for eg.,
+ * can raise a signal or broadcast a cond variable etc.)
+ *
+ * Otherwise all the upcall events are queued up in a list
+ * to be read/polled by the applications.
+ */
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_process_upcall_event, 3.7.0)
+void
+priv_glfs_process_upcall_event(struct glfs *fs, void *data)
+{
+    glusterfs_ctx_t *ctx = NULL;
+    struct gf_upcall *upcall_data = NULL;
 
-        if (inode)
-                inode_unref (inode);
+    DECLARE_OLD_THIS;
 
-        glfs_subvol_done (fs, subvol);
+    gf_msg_debug(THIS->name, 0, "Upcall gfapi callback is called");
 
-        __GLFS_EXIT_FS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, err);
 
-invalid_fs:
-        return ret;
+    if (!data)
+        goto out;
+
+    /* Unlike in I/O path, "glfs_fini" would not have freed
+     * 'fs' by the time we take lock as it waits for all epoll
+     * threads to exit including this
+     */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        ctx = fs->ctx;
+
+        /* if we're not interested in upcalls (anymore), skip them */
+        if (ctx->cleanup_started || !fs->cache_upcalls) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto out;
+        }
+
+        fs->pin_refcnt++;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    upcall_data = (struct gf_upcall *)data;
+
+    gf_msg_trace(THIS->name, 0, "Upcall gfapi gfid = %s",
+                 (char *)(upcall_data->gfid));
+
+    /* *
+     * TODO: RECALL LEASE for each glfd
+     *
+     * In case of RECALL_LEASE, we could associate separate
+     * cbk function for each glfd either by
+     * - extending pub_glfs_lease to accept new args (recall_cbk_fn, cookie)
+     * - or by defining new API "glfs_register_recall_cbk_fn (glfd,
+     * recall_cbk_fn, cookie) . In such cases, flag it and instead of calling
+     * below upcall functions, define a new one to go through the glfd list and
+     * invoke each of theirs recall_cbk_fn.
+     * */
+
+    if (fs->up_cbk) { /* upcall cbk registered */
+        (void)glfs_cbk_upcall_data(fs, upcall_data);
+    } else {
+        (void)glfs_enqueue_upcall_data(fs, upcall_data);
+    }
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->pin_refcnt--;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+out:
+    __GLFS_EXIT_FS;
+err:
+    return;
 }
 
 ssize_t
-glfs_anonymous_preadv (struct glfs *fs,  struct glfs_object *object,
-                       const struct iovec *iovec, int iovcnt,
-                       off_t offset, int flags)
-{
-        xlator_t        *subvol = NULL;
-        struct iovec    *iov    = NULL;
-        struct iobref   *iobref = NULL;
-        inode_t         *inode  = NULL;
-        fd_t            *fd     = NULL;
-        int             cnt     = 0;
-        ssize_t         ret     = -1;
-        ssize_t         size    = -1;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+glfs_anonymous_pwritev(struct glfs *fs, struct glfs_object *object,
+                       const struct iovec *iovec, int iovcnt, off_t offset,
+                       int flags)
+{
+    xlator_t *subvol = NULL;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iovec iov = {
+        0,
+    };
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    int ret = -1;
+    size_t size = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    fd = fd_anonymous(inode);
+    if (!fd) {
+        ret = -1;
+        gf_smsg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, NULL);
+        errno = ENOMEM;
+        goto out;
+    }
+
+    size = iov_length(iovec, iovcnt);
+
+    iobuf = iobuf_get2(subvol->ctx->iobuf_pool, size);
+    if (!iobuf) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    iobref = iobref_new();
+    if (!iobref) {
+        iobuf_unref(iobuf);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = iobref_add(iobref, iobuf);
+    if (ret) {
+        iobuf_unref(iobuf);
+        iobref_unref(iobref);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    iov_unload(iobuf_ptr(iobuf), iovec, iovcnt);
+
+    iov.iov_base = iobuf_ptr(iobuf);
+    iov.iov_len = size;
+
+    /* TODO : set leaseid */
+    ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, NULL, NULL,
+                        NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    iobuf_unref(iobuf);
+    iobref_unref(iobref);
+
+    if (ret <= 0)
+        goto out;
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
+out:
 
-        fd = fd_anonymous (inode);
-        if (!fd) {
-                ret = -1;
-                gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                errno = ENOMEM;
-                goto out;
-        }
+    if (fd)
+        fd_unref(fd);
 
-        size = iov_length (iovec, iovcnt);
+    if (inode)
+        inode_unref(inode);
 
-	ret = syncop_readv (subvol, fd, size, offset, flags, &iov, &cnt,
-                            &iobref, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-        if (ret <= 0)
-                goto out;
+    glfs_subvol_done(fs, subvol);
 
-        size = iov_copy (iovec, iovcnt, iov, cnt);
+    __GLFS_EXIT_FS;
 
-        ret = size;
+invalid_fs:
+    return ret;
+}
+
+ssize_t
+glfs_anonymous_preadv(struct glfs *fs, struct glfs_object *object,
+                      const struct iovec *iovec, int iovcnt, off_t offset,
+                      int flags)
+{
+    xlator_t *subvol = NULL;
+    struct iovec *iov = NULL;
+    struct iobref *iobref = NULL;
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    int cnt = 0;
+    ssize_t ret = -1;
+    ssize_t size = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    fd = fd_anonymous(inode);
+    if (!fd) {
+        ret = -1;
+        gf_smsg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, NULL);
+        errno = ENOMEM;
+        goto out;
+    }
+
+    size = iov_length(iovec, iovcnt);
+
+    /* TODO : set leaseid */
+    ret = syncop_readv(subvol, fd, size, offset, flags, &iov, &cnt, &iobref,
+                       NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret <= 0)
+        goto out;
+
+    size = iov_copy(iovec, iovcnt, iov, cnt);
+
+    ret = size;
 out:
-        if (iov)
-                GF_FREE (iov);
-        if (iobref)
-                iobref_unref (iobref);
-        if (fd)
-                fd_unref(fd);
+    if (iov)
+        GF_FREE(iov);
+    if (iobref)
+        iobref_unref(iobref);
+    if (fd)
+        fd_unref(fd);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
+}
+
+static void
+glfs_release_xreaddirp_stat(void *ptr)
+{
+    struct glfs_xreaddirp_stat *to_free = ptr;
+
+    if (to_free->object)
+        glfs_h_close(to_free->object);
 }
 
 /*
  * Given glfd of a directory, this function does readdirp and returns
  * xstat along with dirents.
  */
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_r, 3.11.0)
 int
-pub_glfs_xreaddirplus_r (struct glfs_fd *glfd, uint32_t flags,
-                         struct glfs_xreaddirp_stat **xstat_p,
-                         struct dirent *ext,
-                         struct dirent **res)
+pub_glfs_xreaddirplus_r(struct glfs_fd *glfd, uint32_t flags,
+                        struct glfs_xreaddirp_stat **xstat_p,
+                        struct dirent *ext, struct dirent **res)
 {
-        int              ret = -1;
-        gf_dirent_t     *entry = NULL;
-        struct dirent   *buf = NULL;
-        struct glfs_xreaddirp_stat *xstat = NULL;
+    int ret = -1;
+    gf_dirent_t *entry = NULL;
+    struct dirent *buf = NULL;
+    struct glfs_xreaddirp_stat *xstat = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, xstat_p, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, res, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, xstat_p, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, res, out);
 
-        errno = 0;
+    errno = 0;
 
-        if (ext)
-                buf = ext;
-        else
-                buf = glfs_readdirbuf_get (glfd);
+    if (ext)
+        buf = ext;
+    else
+        buf = glfs_readdirbuf_get(glfd);
 
-        if (!buf)
-                goto out;
+    if (!buf)
+        goto out;
 
-        xstat = GF_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
-                          glfs_mt_xreaddirp_stat_t);
+    xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
+                        glfs_release_xreaddirp_stat, glfs_mt_xreaddirp_stat_t);
 
-        if (!xstat)
-                goto out;
+    if (!xstat)
+        goto out;
 
-        /* this is readdirplus operation */
-        entry = glfd_entry_next (glfd, 1);
+    /* this is readdirplus operation */
+    entry = glfd_entry_next(glfd, 1);
 
-        /* XXX: Ideally when we reach EOD, errno should have been
-         * set to ENOENT. But that doesn't seem to be the case.
-         *
-         * The only way to confirm if its EOD at this point is that
-         * errno == 0 and entry == NULL
-         */
-        if (errno)
-                goto out;
+    /* XXX: Ideally when we reach EOD, errno should have been
+     * set to ENOENT. But that doesn't seem to be the case.
+     *
+     * The only way to confirm if its EOD at this point is that
+     * errno == 0 and entry == NULL
+     */
+    if (errno)
+        goto out;
 
-        if (!entry) {
-                /* reached EOD, ret = 0  */
-                ret = 0;
-                *res = NULL;
-                *xstat_p = NULL;
+    if (!entry) {
+        /* reached EOD, ret = 0  */
+        ret = 0;
+        *res = NULL;
+        *xstat_p = NULL;
+
+        /* free xstat as applications shall not be using it */
+        GLFS_FREE(xstat);
+
+        goto out;
+    }
+
+    *res = buf;
+    gf_dirent_to_dirent(entry, buf);
+
+    if (flags & GFAPI_XREADDIRP_STAT) {
+        glfs_iatt_to_stat(glfd->fs, &entry->d_stat, &xstat->st);
+        xstat->flags_handled |= GFAPI_XREADDIRP_STAT;
+    }
+
+    if ((flags & GFAPI_XREADDIRP_HANDLE) &&
+        /* skip . and .. */
+        strcmp(buf->d_name, ".") && strcmp(buf->d_name, "..")) {
+        /* Now create object.
+         * We can use "glfs_h_find_handle" as well as inodes would have
+         * already got linked as part of 'gf_link_inodes_from_dirent' */
+        xstat->object = glfs_h_create_from_handle(
+            glfd->fs, entry->d_stat.ia_gfid, GFAPI_HANDLE_LENGTH, NULL);
+
+        if (xstat->object) { /* success */
+            /* note: xstat->object->inode->ref is taken
+             * This shall be unref'ed when application does
+             * glfs_free(xstat) */
+            xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE;
+        }
+    }
 
-                /* free xstat as applications shall not be using it */
-                glfs_free (xstat);
+    ret = xstat->flags_handled;
+    *xstat_p = xstat;
 
-                goto out;
-        }
+    gf_msg_debug(THIS->name, 0,
+                 "xreaddirp- requested_flags (%x) , processed_flags (%x)",
+                 flags, xstat->flags_handled);
 
-        *res = buf;
-        gf_dirent_to_dirent (entry, buf);
+out:
+    GF_REF_PUT(glfd);
 
-        if (flags & GFAPI_XREADDIRP_STAT) {
-                glfs_iatt_to_stat (glfd->fs, &entry->d_stat, &xstat->st);
-                xstat->flags_handled |= GFAPI_XREADDIRP_STAT;
-        }
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED,
+                "reason=%s", strerror(errno), NULL);
 
-        if ((flags & GFAPI_XREADDIRP_HANDLE) &&
-                /* skip . and .. */
-                strcmp(buf->d_name, ".")
-                     && strcmp(buf->d_name, "..")) {
-
-                /* Now create object.
-                 * We can use "glfs_h_find_handle" as well as inodes would have
-                 * already got linked as part of 'gf_link_inodes_from_dirent' */
-                xstat->object = glfs_h_create_from_handle (glfd->fs,
-                                                        entry->d_stat.ia_gfid,
-                                                        GFAPI_HANDLE_LENGTH,
-                                                        NULL);
-
-                if (xstat->object) { /* success */
-                        /* note: xstat->object->inode->ref is taken
-                         * This shall be unref'ed when application does
-                         * glfs_free(xstat) */
-                        xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE;
-                }
-        }
+        if (xstat)
+            GLFS_FREE(xstat);
+    }
 
-        ret = xstat->flags_handled;
-        *xstat_p = xstat;
+    __GLFS_EXIT_FS;
 
-        gf_msg_debug (THIS->name, 0,
-                      "xreaddirp- requested_flags (%x) , processed_flags (%x)",
-                      flags, xstat->flags_handled);
+    return ret;
 
-out:
-        GF_REF_PUT (glfd);
+invalid_fs:
+    return -1;
+}
 
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        API_MSG_XREADDIRP_R_FAILED,
-                        "glfs_x_readdirp_r failed - reason (%s)",
-                        strerror(errno));
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_stat, 3.11.0)
+struct stat *
+pub_glfs_xreaddirplus_get_stat(struct glfs_xreaddirp_stat *xstat)
+{
+    GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_stat", xstat, out);
 
-                if (xstat)
-                        glfs_free (xstat);
-        }
+    if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT)
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_FLAGS_HANDLE,
+                "GFAPI_XREADDIRP_STAT"
+                "xstat=%p",
+                xstat, "handles=%x", xstat->flags_handled, NULL);
+    return &xstat->st;
 
-        __GLFS_EXIT_FS;
+out:
+    return NULL;
+}
 
-        return ret;
+void
+gf_lease_to_glfs_lease(struct gf_lease *gf_lease, struct glfs_lease *lease)
+{
+    u_int lease_type = gf_lease->lease_type;
+    lease->cmd = gf_lease->cmd;
+    lease->lease_type = lease_type;
+    memcpy(lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
+}
 
-invalid_fs:
-        return -1;
+void
+glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease)
+{
+    u_int lease_type = lease->lease_type;
+    gf_lease->cmd = lease->cmd;
+    gf_lease->lease_type = lease_type;
+    memcpy(gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE);
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_r, 3.11.0);
 
-struct stat*
-pub_glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lease, 4.0.0)
+int
+pub_glfs_lease(struct glfs_fd *glfd, struct glfs_lease *lease,
+               glfs_recall_cbk fn, void *data)
 {
-        GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_stat", xstat, out);
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct gf_lease gf_lease = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!is_valid_lease_id(lease->lease_id)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    switch (lease->lease_type) {
+        case GLFS_RD_LEASE:
+            if ((fd->flags != O_RDONLY) && !(fd->flags & O_RDWR)) {
+                ret = -1;
+                errno = EINVAL;
+                goto out;
+            }
+            break;
+        case GLFS_RW_LEASE:
+            if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) {
+                ret = -1;
+                errno = EINVAL;
+                goto out;
+            }
+            break;
+        default:
+            if (lease->cmd != GLFS_GET_LEASE) {
+                ret = -1;
+                errno = EINVAL;
+                goto out;
+            }
+            break;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(fd->inode, loc, out);
+
+    glfs_lease_to_gf_lease(lease, &gf_lease);
 
-        if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT)
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "GFAPI_XREADDIRP_STAT is not set. Flags"
-                        "handled for xstat(%p) are (%x)",
-                        xstat, xstat->flags_handled);
-        return &xstat->st;
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    gf_lease_to_glfs_lease(&gf_lease, lease);
+
+    /* TODO: Add leases for client replay
+    if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW))
+            fd_lk_insert_and_merge (fd, cmd, &saved_flock);
+    */
+    if (ret == 0) {
+        ret = fd_ctx_set(glfd->fd, subvol, (uint64_t)(long)glfd);
+        if (ret) {
+            gf_smsg(subvol->name, GF_LOG_ERROR, ENOMEM,
+                    API_MSG_FDCTX_SET_FAILED, "fd=%p", glfd->fd, NULL);
+            goto out;
+        }
+        glfd->cbk = fn;
+        glfd->cookie = data;
+    }
 
 out:
-        return NULL;
-}
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_stat, 3.11.0);
 
+    if (glfd)
+        GF_REF_PUT(glfd);
+
+    if (subvol)
+        glfs_subvol_done(glfd->fs, subvol);
+
+    __GLFS_EXIT_FS;
+
+invalid_fs:
+    return ret;
+}
diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c
index 4180f5cf777..53c2ee896f9 100644
--- a/api/src/glfs-handleops.c
+++ b/api/src/glfs-handleops.c
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+ *  Copyright (c) 2013-2018 Red Hat, Inc. <http://www.redhat.com>
  *  This file is part of GlusterFS.
  *
  *  This file is licensed to you under your choice of the GNU Lesser
@@ -8,1988 +8,2156 @@
  *  cases as published by the Free Software Foundation.
  */
 
-
 #include "glfs-internal.h"
 #include "glfs-mem-types.h"
-#include "syncop.h"
+#include <glusterfs/syncop.h>
 #include "glfs.h"
 #include "glfs-handles.h"
 #include "gfapi-messages.h"
 
 int
-glfs_listxattr_process (void *value, size_t size, dict_t *xattr);
+glfs_listxattr_process(void *value, size_t size, dict_t *xattr);
 
-static void
-glfs_iatt_from_stat (struct stat *stat, int valid, struct iatt *iatt,
-                     int *glvalid)
+void
+glfs_iatt_from_stat(struct stat *stat, int valid, struct iatt *iatt,
+                    int *glvalid)
 {
-        /* validate in args */
-        if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
-                errno = EINVAL;
-                return;
-        }
-
-        *glvalid = 0;
-
-        if (valid & GFAPI_SET_ATTR_MODE) {
-                iatt->ia_prot = ia_prot_from_st_mode (stat->st_mode);
-                *glvalid |= GF_SET_ATTR_MODE;
-        }
-
-        if (valid & GFAPI_SET_ATTR_UID) {
-                iatt->ia_uid = stat->st_uid;
-                *glvalid |= GF_SET_ATTR_UID;
-        }
-
-        if (valid & GFAPI_SET_ATTR_GID) {
-                iatt->ia_gid = stat->st_gid;
-                *glvalid |= GF_SET_ATTR_GID;
-        }
-
-        if (valid & GFAPI_SET_ATTR_ATIME) {
-                iatt->ia_atime = stat->st_atime;
-                iatt->ia_atime_nsec = ST_ATIM_NSEC (stat);
-                *glvalid |= GF_SET_ATTR_ATIME;
-        }
-
-        if (valid & GFAPI_SET_ATTR_MTIME) {
-                iatt->ia_mtime = stat->st_mtime;
-                iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat);
-                *glvalid |= GF_SET_ATTR_MTIME;
-        }
-
+    /* validate in args */
+    if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
+        errno = EINVAL;
         return;
+    }
+
+    *glvalid = 0;
+
+    if (valid & GFAPI_SET_ATTR_MODE) {
+        iatt->ia_prot = ia_prot_from_st_mode(stat->st_mode);
+        *glvalid |= GF_SET_ATTR_MODE;
+    }
+
+    if (valid & GFAPI_SET_ATTR_UID) {
+        iatt->ia_uid = stat->st_uid;
+        *glvalid |= GF_SET_ATTR_UID;
+    }
+
+    if (valid & GFAPI_SET_ATTR_GID) {
+        iatt->ia_gid = stat->st_gid;
+        *glvalid |= GF_SET_ATTR_GID;
+    }
+
+    if (valid & GFAPI_SET_ATTR_ATIME) {
+        iatt->ia_atime = stat->st_atime;
+        iatt->ia_atime_nsec = ST_ATIM_NSEC(stat);
+        *glvalid |= GF_SET_ATTR_ATIME;
+    }
+
+    if (valid & GFAPI_SET_ATTR_MTIME) {
+        iatt->ia_mtime = stat->st_mtime;
+        iatt->ia_mtime_nsec = ST_MTIM_NSEC(stat);
+        *glvalid |= GF_SET_ATTR_MTIME;
+    }
+
+    return;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lookupat, 3.7.4)
 struct glfs_object *
-pub_glfs_h_lookupat (struct glfs *fs, struct glfs_object *parent,
-                     const char *path, struct stat *stat, int follow)
+pub_glfs_h_lookupat(struct glfs *fs, struct glfs_object *parent,
+                    const char *path, struct stat *stat, int follow)
 {
-        int                      ret = 0;
-        xlator_t                *subvol = NULL;
-        inode_t                 *inode = NULL;
-        struct iatt              iatt = {0, };
-        struct glfs_object      *object = NULL;
-        loc_t                    loc = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if (path == NULL) {
-                errno = EINVAL;
-                return NULL;
-        }
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    struct glfs_object *object = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if (path == NULL) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        if (parent) {
-                inode = glfs_resolve_inode (fs, subvol, parent);
-                if (!inode) {
-                        errno = ESTALE;
-                        goto out;
-                }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    if (parent) {
+        inode = glfs_resolve_inode(fs, subvol, parent);
+        if (!inode) {
+            errno = ESTALE;
+            goto out;
         }
+    }
 
-        /* fop/op */
-        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, &iatt,
-                                    follow, 0);
+    /* fop/op */
+    ret = glfs_resolve_at(fs, subvol, inode, path, &loc, &iatt, follow, 0);
 
-        /* populate out args */
-        if (!ret) {
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+    /* populate out args */
+    if (!ret) {
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lookupat, 3.7.4);
-
+GFAPI_SYMVER_PUBLIC(glfs_h_lookupat34, glfs_h_lookupat, 3.4.2)
 struct glfs_object *
-pub_glfs_h_lookupat34 (struct glfs *fs, struct glfs_object *parent,
-                       const char *path, struct stat *stat)
+pub_glfs_h_lookupat34(struct glfs *fs, struct glfs_object *parent,
+                      const char *path, struct stat *stat)
 {
-        return pub_glfs_h_lookupat (fs, parent, path, stat, 0);
+    return pub_glfs_h_lookupat(fs, parent, path, stat, 0);
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_h_lookupat34, glfs_h_lookupat, 3.4.2);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_statfs, 3.7.0)
 int
-pub_glfs_h_statfs (struct glfs *fs, struct glfs_object *object,
-                   struct statvfs *statvfs)
+pub_glfs_h_statfs(struct glfs *fs, struct glfs_object *object,
+                  struct statvfs *statvfs)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL || statvfs == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL || statvfs == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    /* fop/op */
+    ret = syncop_statfs(subvol, &loc, statvfs, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* fop/op */
-        ret = syncop_statfs (subvol, &loc, statvfs, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
 out:
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_statfs, 3.7.0);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_stat, 3.4.2)
 int
-pub_glfs_h_stat (struct glfs *fs, struct glfs_object *object, struct stat *stat)
+pub_glfs_h_stat(struct glfs *fs, struct glfs_object *object, struct stat *stat)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_stat (subvol, &loc, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (!ret && stat) {
-                glfs_iatt_to_stat (fs, &iatt, stat);
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (!ret && stat) {
+        glfs_iatt_to_stat(fs, &iatt, stat);
+    }
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_stat, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getattrs, 3.4.2)
 int
-pub_glfs_h_getattrs (struct glfs *fs, struct glfs_object *object,
-                     struct stat *stat)
+pub_glfs_h_getattrs(struct glfs *fs, struct glfs_object *object,
+                    struct stat *stat)
 {
-        int                      ret = -1;
-        xlator_t                *subvol = NULL;
-        inode_t                 *inode = NULL;
-        struct iatt              iatt = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = 0;
-                errno = ESTALE;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = 0;
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* fop/op */
-        ret = glfs_resolve_base (fs, subvol, inode, &iatt);
+    /* fop/op */
+    ret = glfs_resolve_base(fs, subvol, inode, &iatt);
 
-        /* populate out args */
-        if (!ret && stat) {
-                glfs_iatt_to_stat (fs, &iatt, stat);
-        }
+    /* populate out args */
+    if (!ret && stat) {
+        glfs_iatt_to_stat(fs, &iatt, stat);
+    }
 
 out:
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getattrs, 3.4.2);
-
-
 int
-glfs_h_getxattrs_common (struct glfs *fs, struct glfs_object *object,
-                         dict_t **xattr, const char *name,
-                         gf_boolean_t is_listxattr)
+glfs_h_getxattrs_common(struct glfs *fs, struct glfs_object *object,
+                        dict_t **xattr, const char *name,
+                        gf_boolean_t is_listxattr)
 {
-        int                 ret = 0;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (!is_listxattr) {
-                if (!name || *name == '\0') {
-                        errno = EINVAL;
-                        return -1;
-                }
-
-                if (strlen(name) > GF_XATTR_NAME_MAX) {
-                        errno = ENAMETOOLONG;
-                        return -1;
-                }
-        }
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
+    if (!is_listxattr) {
+        if (!name || *name == '\0') {
+            errno = EINVAL;
+            return -1;
         }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        ret = syncop_getxattr (subvol, &loc, xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+        if (strlen(name) > GF_XATTR_NAME_MAX) {
+            errno = ENAMETOOLONG;
+            return -1;
+        }
+    }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    ret = syncop_getxattr(subvol, &loc, xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getxattrs, 3.5.1)
 int
-pub_glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object,
-                      const char *name, void *value, size_t size)
+pub_glfs_h_getxattrs(struct glfs *fs, struct glfs_object *object,
+                     const char *name, void *value, size_t size)
 {
-        int                    ret   = -1;
-        dict_t                *xattr = NULL;
+    int ret = -1;
+    dict_t *xattr = NULL;
 
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        ret = glfs_h_getxattrs_common (fs, object, &xattr, name,
-                                       (name == NULL));
-        if (ret)
-                goto out;
+    ret = glfs_h_getxattrs_common(fs, object, &xattr, name, (name == NULL));
+    if (ret)
+        goto out;
 
-        /* If @name is NULL, means get all the xattrs (i.e listxattr). */
-        if (name)
-                ret = glfs_getxattr_process (value, size, xattr, name);
-        else
-                ret = glfs_listxattr_process (value, size, xattr);
+    /* If @name is NULL, means get all the xattrs (i.e listxattr). */
+    if (name)
+        ret = glfs_getxattr_process(value, size, xattr, name);
+    else
+        ret = glfs_listxattr_process(value, size, xattr);
 
 out:
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getxattrs, 3.5.1);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setattrs, 3.4.2)
 int
-pub_glfs_h_setattrs (struct glfs *fs, struct glfs_object *object,
-                     struct stat *stat, int valid)
+pub_glfs_h_setattrs(struct glfs *fs, struct glfs_object *object,
+                    struct stat *stat, int valid)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-        int              glvalid = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* map valid masks from in args */
-        glfs_iatt_from_stat (stat, valid, &iatt, &glvalid);
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int glvalid = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* map valid masks from in args */
+    glfs_iatt_from_stat(stat, valid, &iatt, &glvalid);
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_setattr(subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setattrs, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setxattrs, 3.5.0)
 int
-pub_glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object,
-                      const char *name, const void *value, size_t size,
-                      int flags)
+pub_glfs_h_setxattrs(struct glfs *fs, struct glfs_object *object,
+                     const char *name, const void *value, size_t size,
+                     int flags)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        dict_t          *xattr = NULL;
-        void            *value_cp = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) ||
-                 (name == NULL) || (value == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (!name || *name == '\0') {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                errno = ENAMETOOLONG;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
-
-        xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-        if (!xattr) {
-                GF_FREE (value_cp);
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    void *value_cp = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (name == NULL) || (value == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    if (!name || *name == '\0') {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* fop/op */
-        ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        errno = ENAMETOOLONG;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
+
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setxattrs, 3.5.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_removexattrs, 3.5.1)
 int
-pub_glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object,
-                         const char *name)
+pub_glfs_h_removexattrs(struct glfs *fs, struct glfs_object *object,
+                        const char *name)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) || (name == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (name == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_removexattr (subvol, &loc, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_removexattr(subvol, &loc, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_removexattrs, 3.5.1);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_open, 3.4.2)
 struct glfs_fd *
-pub_glfs_h_open (struct glfs *fs, struct glfs_object *object, int flags)
+pub_glfs_h_open(struct glfs *fs, struct glfs_object *object, int flags)
 {
-        int              ret = -1;
-        struct glfs_fd  *glfd = NULL;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* check types to open */
-        if (IA_ISDIR (inode->ia_type)) {
-                ret = -1;
-                errno = EISDIR;
-                goto out;
-        }
-
-        if (!IA_ISREG (inode->ia_type)) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        glfd = glfs_fd_new (fs);
-        if (!glfd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        glfd->fd = fd_create (inode, getpid());
-        if (!glfd->fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-        glfd->fd->flags = flags;
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        glfd->fd->flags = flags;
-        fd_bind (glfd->fd);
-        glfs_fd_bind (glfd);
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *fop_attr = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* check types to open */
+    if (IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    if (!IA_ISREG(inode->ia_type)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    glfd->fd = fd_create(inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_open(subvol, &loc, flags, glfd->fd, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    glfd->fd->flags = flags;
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        if (ret && glfd) {
-                GF_REF_PUT (glfd);
-                glfd = NULL;
-        } else if (glfd) {
-                glfd->state = GLFD_OPEN;
-        }
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return glfd;
+    return glfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_open, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_creat, 3.4.2)
 struct glfs_object *
-pub_glfs_h_creat (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  int flags, mode_t mode, struct stat *stat)
+pub_glfs_h_creat(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 int flags, mode_t mode, struct stat *stat)
 {
-        int                 ret = -1;
-        fd_t               *fd = NULL;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-        fd = fd_create (loc.inode, getpid());
-        if (!fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    fd_t *fd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    fd = fd_create(loc.inode, getpid());
+    if (!fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    fd->flags = flags;
+
+    /* fop/op */
+    ret = syncop_create(subvol, &loc, flags, mode, fd, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
-        fd->flags = flags;
-
-        /* fop/op */
-        ret = syncop_create (subvol, &loc, flags, mode, fd, &iatt,
-                             xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
 
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        if (ret && object != NULL) {
-                /* Release the held reference */
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        /* Release the held reference */
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        if (fd)
-                fd_unref(fd);
+    if (fd)
+        fd_unref(fd);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_creat, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_creat_open, 6.6)
 struct glfs_object *
-pub_glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  mode_t mode, struct stat *stat)
+pub_glfs_h_creat_open(struct glfs *fs, struct glfs_object *parent,
+                      const char *path, int flags, mode_t mode,
+                      struct stat *stat, struct glfs_fd **out_fd)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+    dict_t *fop_attr = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL) ||
+        (out_fd == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        ret = -1;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    /* fop/op */
+    ret = syncop_create(subvol, &loc, flags, mode, glfd->fd, &iatt, xattr_req,
+                        NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        glfd->fd->flags = flags;
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-        gf_uuid_generate (gfid);
-        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+out:
+    if (ret && object != NULL) {
+        /* Release the held reference */
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        /* fop/op */
-        ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    loc_wipe(&loc);
 
-        /* populate out args */
-        if ( ret == 0 )  {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
+    if (inode)
+        inode_unref(inode);
 
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-out:
-        if (ret && object != NULL) {
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+        *out_fd = glfd;
+    }
 
-        loc_wipe(&loc);
+    glfs_subvol_done(fs, subvol);
 
-        if (inode)
-                inode_unref (inode);
-
-        if (xattr_req)
-                dict_unref (xattr_req);
-
-        glfs_subvol_done (fs, subvol);
-
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mkdir, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mkdir, 3.4.2)
 struct glfs_object *
-pub_glfs_h_mknod (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  mode_t mode, dev_t dev, struct stat *stat)
+pub_glfs_h_mkdir(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 mode_t mode, struct stat *stat)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    /* fop/op */
+    ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+out:
+    if (ret && object != NULL) {
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    loc_wipe(&loc);
 
-        gf_uuid_generate (gfid);
-        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    if (inode)
+        inode_unref(inode);
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        /* fop/op */
-        ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    glfs_subvol_done(fs, subvol);
 
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
+    __GLFS_EXIT_FS;
 
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+invalid_fs:
+    return object;
+}
 
-                ret = glfs_create_object (&loc, &object);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mknod, 3.4.2)
+struct glfs_object *
+pub_glfs_h_mknod(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 mode_t mode, dev_t dev, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    /* fop/op */
+    ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
+
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
+
+        ret = glfs_create_object(&loc, &object);
+    }
 out:
-        if (ret && object != NULL) {
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mknod, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_unlink, 3.4.2)
 int
-pub_glfs_h_unlink (struct glfs *fs, struct glfs_object *parent, const char *path)
+pub_glfs_h_unlink(struct glfs *fs, struct glfs_object *parent, const char *path)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if ( !subvol ) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, NULL, 0 , 0);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, inode, path, &loc, NULL, 0, 0);
+    if (ret != 0) {
+        goto out;
+    }
+
+    if (!IA_ISDIR(loc.inode->ia_type)) {
+        ret = syncop_unlink(subvol, &loc, NULL, NULL);
+        DECODE_SYNCOP_ERR(ret);
         if (ret != 0) {
-                goto out;
+            goto out;
         }
-
-        if (!IA_ISDIR(loc.inode->ia_type)) {
-                ret = syncop_unlink (subvol, &loc, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-                if (ret != 0) {
-                        goto out;
-                }
-        } else {
-                ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-                if (ret != 0) {
-                        goto out;
-                }
+    } else {
+        ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL);
+        DECODE_SYNCOP_ERR(ret);
+        if (ret != 0) {
+            goto out;
         }
+    }
 
-        if (ret == 0)
-                ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_unlink, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_opendir, 3.4.2)
 struct glfs_fd *
-pub_glfs_h_opendir (struct glfs *fs, struct glfs_object *object)
+pub_glfs_h_opendir(struct glfs *fs, struct glfs_object *object)
 {
-        int              ret = -1;
-        struct glfs_fd  *glfd = NULL;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        if (!IA_ISDIR (inode->ia_type)) {
-                ret = -1;
-                errno = ENOTDIR;
-                goto out;
-        }
-
-        glfd = glfs_fd_new (fs);
-        if (!glfd)
-                goto out;
-
-        INIT_LIST_HEAD (&glfd->entries);
-
-        glfd->fd = fd_create (inode, getpid());
-        if (!glfd->fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    if (!IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    INIT_LIST_HEAD(&glfd->entries);
+
+    glfd->fd = fd_create(inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+out:
+    loc_wipe(&loc);
 
-        /* fop/op */
-        ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (inode)
+        inode_unref(inode);
 
-out:
-        loc_wipe (&loc);
-
-        if (inode)
-                inode_unref (inode);
-
-        if (ret && glfd) {
-                GF_REF_PUT (glfd);
-                glfd = NULL;
-        } else if (glfd) {
-                glfd->state = GLFD_OPEN;
-                fd_bind (glfd->fd);
-                glfs_fd_bind (glfd);
-        }
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return glfd;
+    return glfd;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_opendir, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_access, 3.6.0)
 int
-pub_glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask)
+pub_glfs_h_access(struct glfs *fs, struct glfs_object *object, int mask)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-
-	DECLARE_OLD_THIS;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return ret;
-	}
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return ret;
+    }
 
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-	GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-	/* fop/op */
+    /* fop/op */
 
-	ret = syncop_access (subvol, &loc, mask, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_access(subvol, &loc, mask, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (inode)
-		inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
+    glfs_subvol_done(fs, subvol);
 
-	glfs_subvol_done (fs, subvol);
-
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_access, 3.6.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_extract_handle, 3.4.2)
 ssize_t
-pub_glfs_h_extract_handle (struct glfs_object *object, unsigned char *handle,
-                           int len)
+pub_glfs_h_extract_handle(struct glfs_object *object, unsigned char *handle,
+                          int len)
 {
-        ssize_t ret = -1;
+    ssize_t ret = -1;
 
-        /* validate in args */
-        if (object == NULL) {
-                errno = EINVAL;
-                goto out;
-        }
+    /* validate in args */
+    if (object == NULL) {
+        errno = EINVAL;
+        goto out;
+    }
 
-        if (!handle || !len) {
-                ret = GFAPI_HANDLE_LENGTH;
-                goto out;
-        }
+    if (!handle || !len) {
+        ret = GFAPI_HANDLE_LENGTH;
+        goto out;
+    }
 
-        if (len < GFAPI_HANDLE_LENGTH)
-        {
-                errno = ERANGE;
-                goto out;
-        }
+    if (len < GFAPI_HANDLE_LENGTH) {
+        errno = ERANGE;
+        goto out;
+    }
 
-        memcpy (handle, object->gfid, GFAPI_HANDLE_LENGTH);
+    memcpy(handle, object->gfid, GFAPI_HANDLE_LENGTH);
 
-        ret = GFAPI_HANDLE_LENGTH;
+    ret = GFAPI_HANDLE_LENGTH;
 
 out:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_extract_handle, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_create_from_handle, 3.4.2)
 struct glfs_object *
-pub_glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len,
-                               struct stat *stat)
+pub_glfs_h_create_from_handle(struct glfs *fs, unsigned char *handle, int len,
+                              struct stat *stat)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        struct iatt         iatt = {0, };
-        inode_t            *newinode = NULL;
-        xlator_t           *subvol = NULL;
-        struct glfs_object *object = NULL;
-        uint64_t            ctx_value = LOOKUP_NOT_NEEDED;
-
-        /* validate in args */
-        if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
-                errno = EINVAL;
-                return NULL;
-        }
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *newinode = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs_object *object = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+    gf_boolean_t lookup_needed = _gf_false;
+
+    /* validate in args */
+    if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH);
+    memcpy(loc.gfid, handle, GFAPI_HANDLE_LENGTH);
 
-        /* make sure the gfid received is valid */
-        GF_VALIDATE_OR_GOTO ("glfs_h_create_from_handle",
-                             !(gf_uuid_is_null (loc.gfid)), out);
+    /* make sure the gfid received is valid */
+    GF_VALIDATE_OR_GOTO("glfs_h_create_from_handle",
+                        !(gf_uuid_is_null(loc.gfid)), out);
 
-        newinode = inode_find (subvol->itable, loc.gfid);
-        if (newinode) {
-                if (!stat) /* No need of lookup */
-                        goto found;
+    newinode = inode_find(subvol->itable, loc.gfid);
+    if (newinode) {
+        if (!stat) /* No need of lookup */
+            goto found;
 
-                loc.inode = newinode;
+        lookup_needed = inode_needs_lookup(newinode, THIS);
+        if (lookup_needed) {
+            loc.inode = newinode;
         } else {
-                loc.inode = inode_new (subvol->itable);
-                if (!loc.inode) {
-                        errno = ENOMEM;
-                        goto out;
-                }
-        }
-
-        ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
-        if (ret) {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-                        "inode refresh of %s failed: %s",
-                        uuid_utoa (loc.gfid), strerror (errno));
-                goto out;
-        }
-
-        newinode = inode_link (loc.inode, 0, 0, &iatt);
-        if (newinode) {
-                if (newinode == loc.inode) {
-                        inode_ctx_set (newinode, THIS, &ctx_value);
-                }
-                inode_lookup (newinode);
-        } else {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed", uuid_utoa (loc.gfid));
-                goto out;
-        }
-
-        /* populate stat */
-        if (stat)
-                glfs_iatt_to_stat (fs, &iatt, stat);
+            /* populate loc */
+            GLFS_LOC_FILL_INODE(newinode, loc, fill_out);
+
+            /* fop/op */
+            ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL);
+            DECODE_SYNCOP_ERR(ret);
+
+            if (ret) {
+            fill_out:
+                /* Drop the reference hold in inode_find */
+                inode_unref(newinode);
+                goto out;
+            }
+
+            glfs_iatt_to_stat(fs, &iatt, stat);
+            goto found;
+        }
+    } else {
+        loc.inode = inode_new(subvol->itable);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret) {
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s", uuid_utoa(loc.gfid),
+                "error=%s", strerror(errno), NULL);
+        goto out;
+    }
+
+    newinode = inode_link(loc.inode, 0, 0, &iatt);
+    if (newinode) {
+        if (newinode == loc.inode) {
+            inode_ctx_set(newinode, THIS, &ctx_value);
+        }
+        inode_lookup(newinode);
+    } else {
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa(loc.gfid), NULL);
+        goto out;
+    }
+
+    /* populate stat */
+    if (stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 
 found:
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-        /* populate the return object */
-        object->inode = newinode;
-        gf_uuid_copy (object->gfid, object->inode->gfid);
+    /* populate the return object */
+    object->inode = newinode;
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
 out:
-        /* TODO: Check where the inode ref is being held? */
-        loc_wipe (&loc);
+    /* TODO: Check where the inode ref is being held? */
+    loc_wipe(&loc);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_create_from_handle, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_close, 3.4.2)
 int
-pub_glfs_h_close (struct glfs_object *object)
+pub_glfs_h_close(struct glfs_object *object)
 {
-        /* since glfs_h_* objects hold a reference to inode
-         * it is safe to keep lookup count to '0' */
-        inode_forget (object->inode, 0);
-        inode_unref (object->inode);
-        GF_FREE (object);
+    /* since glfs_h_* objects hold a reference to inode
+     * it is safe to keep lookup count to '0' */
+    inode_forget(object->inode, 0);
+    inode_unref(object->inode);
+    GF_FREE(object);
 
-        return 0;
+    return 0;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_close, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_truncate, 3.4.2)
 int
-pub_glfs_h_truncate (struct glfs *fs, struct glfs_object *object, off_t offset)
+pub_glfs_h_truncate(struct glfs *fs, struct glfs_object *object, off_t offset)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if (object == NULL) {
-                errno = EINVAL;
-                return -1;
-        }
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if (object == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_truncate (subvol, &loc, (off_t)offset, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_truncate(subvol, &loc, (off_t)offset, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* populate out args */
-        if (ret == 0)
-                ret = glfs_loc_unlink (&loc);
+    /* populate out args */
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_truncate, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_symlink, 3.4.2)
 struct glfs_object *
-pub_glfs_h_symlink (struct glfs *fs, struct glfs_object *parent,
-                    const char *name, const char *data, struct stat *stat)
+pub_glfs_h_symlink(struct glfs *fs, struct glfs_object *parent,
+                   const char *name, const char *data, struct stat *stat)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((parent == NULL) || (name == NULL) ||
-                (data == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((parent == NULL) || (name == NULL) || (data == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, name);
+
+    /* fop/op */
+    ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, name);
-
-        /* fop/op */
-        ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
-
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        if (ret && object != NULL) {
-                pub_glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        pub_glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_symlink, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_readlink, 3.4.2)
 int
-pub_glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf,
-                     size_t bufsiz)
+pub_glfs_h_readlink(struct glfs *fs, struct glfs_object *object, char *buf,
+                    size_t bufsiz)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        char               *linkval = NULL;
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((object == NULL) || (buf == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    char *linkval = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((object == NULL) || (buf == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* populate out args */
-        if (ret > 0)
-                memcpy (buf, linkval, ret);
+    /* populate out args */
+    if (ret > 0)
+        memcpy(buf, linkval, ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (linkval)
-                GF_FREE (linkval);
+    if (linkval)
+        GF_FREE(linkval);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_readlink, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_link, 3.4.2)
 int
-pub_glfs_h_link (struct glfs *fs, struct glfs_object *linksrc,
-             struct glfs_object *parent, const char *name)
+pub_glfs_h_link(struct glfs *fs, struct glfs_object *linksrc,
+                struct glfs_object *parent, const char *name)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        inode_t            *pinode = NULL;
-        loc_t               oldloc = {0, };
-        loc_t               newloc = {0, };
-        struct iatt         iatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((linksrc == NULL) || (parent == NULL) ||
-                (name == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, linksrc);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        if (inode->ia_type == IA_IFDIR) {
-                ret = -1;
-                errno = EISDIR;
-                goto out;
-        }
-
-        GLFS_LOC_FILL_INODE (inode, oldloc, out);
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        pinode = glfs_resolve_inode (fs, subvol, parent);
-        if (!pinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* setup newloc based on parent */
-        newloc.parent = inode_ref (pinode);
-        newloc.name = name;
-        ret = glfs_loc_touchup (&newloc);
-        if (ret != 0) {
-                errno = EINVAL;
-                goto out;
-        }
-
-        /* Filling the inode of the hard link to be same as that of the
-         * original file
-         */
-        newloc.inode = inode_ref (inode);
-
-        /* fop/op */
-        ret = syncop_link (subvol, &oldloc, &newloc, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret == 0)
-                ret = glfs_loc_link (&newloc, &iatt);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    inode_t *pinode = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((linksrc == NULL) || (parent == NULL) || (name == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, linksrc);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    if (inode->ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_INODE(inode, oldloc, out);
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    pinode = glfs_resolve_inode(fs, subvol, parent);
+    if (!pinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* setup newloc based on parent */
+    newloc.parent = inode_ref(pinode);
+    newloc.name = name;
+    ret = glfs_loc_touchup(&newloc);
+    if (ret != 0) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    /* Filling the inode of the hard link to be same as that of the
+     * original file
+     */
+    newloc.inode = inode_ref(inode);
+
+    /* fop/op */
+    ret = syncop_link(subvol, &oldloc, &newloc, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0)
+        ret = glfs_loc_link(&newloc, &iatt);
 out:
-        loc_wipe (&oldloc);
-        loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (pinode)
-                inode_unref (pinode);
+    if (pinode)
+        inode_unref(pinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_link, 3.4.2);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2)
 int
-pub_glfs_h_rename (struct glfs *fs, struct glfs_object *olddir,
-                   const char *oldname, struct glfs_object *newdir,
-                   const char *newname)
+pub_glfs_h_rename(struct glfs *fs, struct glfs_object *olddir,
+                  const char *oldname, struct glfs_object *newdir,
+                  const char *newname)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *oldpinode = NULL;
-        inode_t            *newpinode = NULL;
-        loc_t               oldloc = {0, };
-        loc_t               newloc = {0, };
-        struct iatt         oldiatt = {0, };
-        struct iatt         newiatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((olddir == NULL) || (oldname == NULL) ||
-                (newdir == NULL) || (newname == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if ( !subvol ) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        oldpinode = glfs_resolve_inode (fs, subvol, olddir);
-        if (!oldpinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, oldpinode, oldname, &oldloc,
-                                    &oldiatt, 0 , 0);
-        if (ret != 0) {
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        newpinode = glfs_resolve_inode (fs, subvol, newdir);
-        if (!newpinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, newpinode, newname, &newloc,
-                                    &newiatt, 0, 0);
-
-        if (ret && errno != ENOENT && newloc.parent)
-                goto out;
-
-        if (newiatt.ia_type != IA_INVAL) {
-                if ((oldiatt.ia_type == IA_IFDIR) !=
-                        (newiatt.ia_type == IA_IFDIR)) {
-                        /* Either both old and new must be dirs,
-                         * or both must be non-dirs. Else, fail.
-                         */
-                        ret = -1;
-                        errno = EEXIST;
-                        goto out;
-                }
-        }
-
-        /* TODO: check if new or old is a prefix of the other, and fail EINVAL */
-
-        ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret == 0)
-                inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
-                              newloc.parent, newloc.name, oldloc.inode,
-                              &oldiatt);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *oldpinode = NULL;
+    inode_t *newpinode = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((olddir == NULL) || (oldname == NULL) || (newdir == NULL) ||
+        (newname == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    oldpinode = glfs_resolve_inode(fs, subvol, olddir);
+    if (!oldpinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, oldpinode, oldname, &oldloc, &oldiatt, 0,
+                          0);
+    if (ret != 0) {
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    newpinode = glfs_resolve_inode(fs, subvol, newdir);
+    if (!newpinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, newpinode, newname, &newloc, &newiatt, 0,
+                          0);
+
+    if (ret && errno != ENOENT && newloc.parent)
+        goto out;
+
+    if (newiatt.ia_type != IA_INVAL) {
+        if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) {
+            /* Either both old and new must be dirs,
+             * or both must be non-dirs. Else, fail.
+             */
+            ret = -1;
+            errno = EEXIST;
+            goto out;
+        }
+    }
+
+    /* TODO: check if new or old is a prefix of the other, and fail EINVAL */
+
+    ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0) {
+        inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name,
+                     newloc.parent, newloc.name, oldloc.inode, &oldiatt);
+
+        if (newloc.inode && !inode_has_dentry(newloc.inode))
+            inode_forget(newloc.inode, 0);
+    }
 
 out:
-        loc_wipe (&oldloc);
-        loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-        if (oldpinode)
-                inode_unref (oldpinode);
+    if (oldpinode)
+        inode_unref(oldpinode);
 
-        if (newpinode)
-                inode_unref (newpinode);
+    if (newpinode)
+        inode_unref(newpinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2);
-
 /*
  * Given a handle/gfid, find if the corresponding inode is present in
  * the inode table. If yes create and return the corresponding glfs_object.
  */
 struct glfs_object *
-glfs_h_find_handle (struct glfs *fs, unsigned char *handle, int len)
+glfs_h_find_handle(struct glfs *fs, unsigned char *handle, int len)
 {
-        inode_t            *newinode = NULL;
-        xlator_t           *subvol = NULL;
-        struct glfs_object *object = NULL;
-        uuid_t gfid;
-
-        /* validate in args */
-        if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
-                errno = EINVAL;
-                return NULL;
-        }
+    inode_t *newinode = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs_object *object = NULL;
+    uuid_t gfid;
+
+    /* validate in args */
+    if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        memcpy (gfid, handle, GFAPI_HANDLE_LENGTH);
+    memcpy(gfid, handle, GFAPI_HANDLE_LENGTH);
 
-        /* make sure the gfid received is valid */
-        GF_VALIDATE_OR_GOTO ("glfs_h_find_handle",
-                             !(gf_uuid_is_null (gfid)), out);
+    /* make sure the gfid received is valid */
+    GF_VALIDATE_OR_GOTO("glfs_h_find_handle", !(gf_uuid_is_null(gfid)), out);
 
-        newinode = inode_find (subvol->itable, gfid);
-        if (!newinode) {
-                goto out;
-        }
+    newinode = inode_find(subvol->itable, gfid);
+    if (!newinode) {
+        goto out;
+    }
 
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                goto out;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        goto out;
+    }
 
-        /* populate the return object. The ref taken here
-         * is un'refed when the application does glfs_h_close() */
-        object->inode = inode_ref(newinode);
-        gf_uuid_copy (object->gfid, object->inode->gfid);
+    /* populate the return object. The ref taken here
+     * is un'refed when the application does glfs_h_close() */
+    object->inode = inode_ref(newinode);
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
 out:
-        /* inode_find takes a reference. Unref it. */
-        if (newinode)
-                inode_unref (newinode);
+    /* inode_find takes a reference. Unref it. */
+    if (newinode)
+        inode_unref(newinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
-
+    return object;
 }
 
 static void
-glfs_free_upcall_inode (void *to_free)
+glfs_free_upcall_inode(void *to_free)
 {
-        struct glfs_upcall_inode *arg = to_free;
+    struct glfs_upcall_inode *arg = to_free;
 
-        if (!arg)
-                return;
+    if (!arg)
+        return;
 
-        if (arg->object)
-                glfs_h_close (arg->object);
-        if (arg->p_object)
-                glfs_h_close (arg->p_object);
-        if (arg->oldp_object)
-                glfs_h_close (arg->oldp_object);
+    if (arg->object)
+        glfs_h_close(arg->object);
+    if (arg->p_object)
+        glfs_h_close(arg->p_object);
+    if (arg->oldp_object)
+        glfs_h_close(arg->oldp_object);
 
-        GF_FREE (arg);
+    GF_FREE(arg);
 }
 
 int
-glfs_h_poll_cache_invalidation (struct glfs *fs,
-                                struct glfs_upcall *up_arg,
-                                struct gf_upcall *upcall_data)
+glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
+                               struct gf_upcall *upcall_data)
 {
-        int                                 ret           = -1;
-        struct glfs_object                  *p_object     = NULL;
-        struct glfs_object                  *oldp_object  = NULL;
-        struct glfs_object                  *object       = NULL;
-        struct gf_upcall_cache_invalidation *ca_data      = NULL;
-        struct glfs_upcall_inode            *up_inode_arg = NULL;
-
-        ca_data = upcall_data->data;
-        GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation",
-                             ca_data, out);
-
-        object = glfs_h_find_handle (fs, upcall_data->gfid,
-                                     GFAPI_HANDLE_LENGTH);
-        if (!object) {
-                /* The reason handle creation will fail is because we
-                 * couldn't find the inode in the gfapi inode table.
-                 *
-                 * But since application would have taken inode_ref, the
-                 * only case when this can happen is when it has closed
-                 * the handle and hence will no more be interested in
-                 * the upcall for this particular gfid.
-                 */
-                gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_CREATE_HANDLE_FAILED,
-                        "handle creation of %s failed",
-                         uuid_utoa (upcall_data->gfid));
-                errno = ESTALE;
-                goto out;
-        }
-
-        up_inode_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_inode),
-                                  glfs_mt_upcall_inode_t);
-        GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation",
-                             up_inode_arg, out);
-
-        up_inode_arg->object = object;
-        up_inode_arg->flags = ca_data->flags;
-        up_inode_arg->expire_time_attr = ca_data->expire_time_attr;
-
-        /* XXX: Update stat as well incase of UP_*_TIMES.
-         * This will be addressed as part of INODE_UPDATE */
-        if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) {
-                glfs_iatt_to_stat (fs, &ca_data->stat, &up_inode_arg->buf);
-        }
-
-        if (ca_data->flags & GFAPI_UP_PARENT_TIMES) {
-                p_object = glfs_h_find_handle (fs,
-                                               ca_data->p_stat.ia_gfid,
-                                               GFAPI_HANDLE_LENGTH);
-                if (!p_object) {
-                        gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                                API_MSG_CREATE_HANDLE_FAILED,
-                                "handle creation of %s failed",
-                                 uuid_utoa (ca_data->p_stat.ia_gfid));
-                        errno = ESTALE;
-                        goto out;
-                }
-
-                glfs_iatt_to_stat (fs, &ca_data->p_stat, &up_inode_arg->p_buf);
-        }
-        up_inode_arg->p_object = p_object;
-
-        /* In case of RENAME, update old parent as well */
-        if (ca_data->flags & GFAPI_UP_RENAME) {
-                oldp_object = glfs_h_find_handle (fs,
-                                                  ca_data->oldp_stat.ia_gfid,
-                                                  GFAPI_HANDLE_LENGTH);
-                if (!oldp_object) {
-                        gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                                API_MSG_CREATE_HANDLE_FAILED,
-                                "handle creation of %s failed",
-                                 uuid_utoa (ca_data->oldp_stat.ia_gfid));
-                        errno = ESTALE;
-                        /* By the time we receive upcall old parent_dir may
-                         * have got removed. We still need to send upcall
-                         * for the file/dir and current parent handles. */
-                        up_inode_arg->oldp_object = NULL;
-                        ret = 0;
-                }
-
-                glfs_iatt_to_stat (fs, &ca_data->oldp_stat,
-                                   &up_inode_arg->oldp_buf);
-        }
-        up_inode_arg->oldp_object = oldp_object;
+    int ret = -1;
+    struct glfs_object *p_object = NULL;
+    struct glfs_object *oldp_object = NULL;
+    struct glfs_object *object = NULL;
+    struct gf_upcall_cache_invalidation *ca_data = NULL;
+    struct glfs_upcall_inode *up_inode_arg = NULL;
+
+    ca_data = upcall_data->data;
+    GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", ca_data, out);
+
+    object = glfs_h_find_handle(fs, upcall_data->gfid, GFAPI_HANDLE_LENGTH);
+    if (!object) {
+        /* The reason handle creation will fail is because we
+         * couldn't find the inode in the gfapi inode table.
+         *
+         * But since application would have taken inode_ref, the
+         * only case when this can happen is when it has closed
+         * the handle and hence will no more be interested in
+         * the upcall for this particular gfid.
+         */
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "gfid=%s", uuid_utoa(upcall_data->gfid), NULL);
+        errno = ESTALE;
+        goto out;
+    }
+
+    up_inode_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_inode),
+                             glfs_mt_upcall_inode_t);
+    GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", up_inode_arg, out);
+
+    up_inode_arg->object = object;
+    up_inode_arg->flags = ca_data->flags;
+    up_inode_arg->expire_time_attr = ca_data->expire_time_attr;
+
+    /* XXX: Update stat as well in case of UP_*_TIMES.
+     * This will be addressed as part of INODE_UPDATE */
+    if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) {
+        glfs_iatt_to_stat(fs, &ca_data->stat, &up_inode_arg->buf);
+    }
+
+    if (ca_data->flags & GFAPI_UP_PARENT_TIMES) {
+        p_object = glfs_h_find_handle(fs, ca_data->p_stat.ia_gfid,
+                                      GFAPI_HANDLE_LENGTH);
+        if (!p_object) {
+            gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                    API_MSG_CREATE_HANDLE_FAILED, "gfid=%s",
+                    uuid_utoa(ca_data->p_stat.ia_gfid), NULL);
+            errno = ESTALE;
+            goto out;
+        }
+
+        glfs_iatt_to_stat(fs, &ca_data->p_stat, &up_inode_arg->p_buf);
+    }
+    up_inode_arg->p_object = p_object;
+
+    /* In case of RENAME, update old parent as well */
+    if (ca_data->flags & GFAPI_UP_RENAME) {
+        oldp_object = glfs_h_find_handle(fs, ca_data->oldp_stat.ia_gfid,
+                                         GFAPI_HANDLE_LENGTH);
+        if (!oldp_object) {
+            gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                    API_MSG_CREATE_HANDLE_FAILED, "gfid=%s",
+                    uuid_utoa(ca_data->oldp_stat.ia_gfid), NULL);
+            errno = ESTALE;
+            /* By the time we receive upcall old parent_dir may
+             * have got removed. We still need to send upcall
+             * for the file/dir and current parent handles. */
+            up_inode_arg->oldp_object = NULL;
+            ret = 0;
+        }
+
+        glfs_iatt_to_stat(fs, &ca_data->oldp_stat, &up_inode_arg->oldp_buf);
+    }
+    up_inode_arg->oldp_object = oldp_object;
+
+    up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE;
+    up_arg->event = up_inode_arg;
+    up_arg->free_event = glfs_free_upcall_inode;
+
+    ret = 0;
 
-        up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE;
-        up_arg->event = up_inode_arg;
-        up_arg->free_event = glfs_free_upcall_inode;
+out:
+    if (ret) {
+        /* Close p_object and oldp_object as well if being referenced.*/
+        if (object)
+            glfs_h_close(object);
+
+        /* Set reason to prevent applications from using ->event */
+        up_arg->reason = GLFS_UPCALL_EVENT_NULL;
+        GF_FREE(up_inode_arg);
+    }
+    return ret;
+}
 
-        ret = 0;
+void
+glfs_release_upcall(void *ptr)
+{
+    struct glfs_upcall *to_free = ptr;
 
-out:
-        if (ret) {
-                /* Close p_object and oldp_object as well if being referenced.*/
-                if (object)
-                        glfs_h_close (object);
-
-                /* Set reason to prevent applications from using ->event */
-                up_arg->reason = GLFS_UPCALL_EVENT_NULL;
-                GF_FREE (up_inode_arg);
-        }
-        return ret;
+    if (to_free->event)
+        to_free->free_event(to_free->event);
 }
 
 /*
  * This API is used to poll for upcall events stored in the upcall list.
- * Current users of this API is NFS-Ganesha. Incase of any event received, it
+ * Current users of this API is NFS-Ganesha. In case of any event received, it
  * will be mapped appropriately into 'glfs_upcall' along with the handle object
  * to be passed to NFS-Ganesha.
  *
@@ -2007,427 +2175,481 @@ out:
  * calling glfs_fini(..). Hence making an assumption that 'fs' & ctx structures
  * cannot be freed while in this routine.
  */
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_poll_upcall, 3.7.16)
 int
-pub_glfs_h_poll_upcall (struct glfs *fs, struct glfs_upcall **up_arg)
+pub_glfs_h_poll_upcall(struct glfs *fs, struct glfs_upcall **up_arg)
 {
-        upcall_entry       *u_list         = NULL;
-        upcall_entry       *tmp            = NULL;
-        xlator_t           *subvol         = NULL;
-        glusterfs_ctx_t    *ctx            = NULL;
-        int                 ret            = -1;
-        struct gf_upcall   *upcall_data    = NULL;
-
-        DECLARE_OLD_THIS;
-
-        if (!up_arg) {
-                errno = EINVAL;
-                goto err;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, err);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto restore;
-        }
-
-        /* Ideally applications should stop polling before calling
-         * 'glfs_fini'. Yet cross check if cleanup has started. */
-        pthread_mutex_lock (&fs->mutex);
+    upcall_entry *u_list = NULL;
+    upcall_entry *tmp = NULL;
+    xlator_t *subvol = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = -1;
+    struct gf_upcall *upcall_data = NULL;
+
+    DECLARE_OLD_THIS;
+
+    if (!up_arg) {
+        errno = EINVAL;
+        goto err;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, err);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto restore;
+    }
+
+    /* Ideally applications should stop polling before calling
+     * 'glfs_fini'. Yet cross check if cleanup has started. */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        ctx = fs->ctx;
+
+        if (ctx->cleanup_started) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto out;
+        }
+
+        fs->pin_refcnt++;
+
+        /* once we call this function, the applications seems to be
+         * interested in events, enable caching them */
+        fs->cache_upcalls = _gf_true;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    pthread_mutex_lock(&fs->upcall_list_mutex);
+    {
+        list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list)
         {
-                ctx = fs->ctx;
-
-                if (ctx->cleanup_started) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto out;
+            list_del_init(&u_list->upcall_list);
+            upcall_data = &u_list->upcall_data;
+            break;
+        }
+    }
+    /* No other thread can delete this entry. So unlock it */
+    pthread_mutex_unlock(&fs->upcall_list_mutex);
+
+    if (upcall_data) {
+        switch (upcall_data->event_type) {
+            case GF_UPCALL_CACHE_INVALIDATION:
+                *up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall),
+                                      glfs_release_upcall,
+                                      glfs_mt_upcall_entry_t);
+                if (!*up_arg) {
+                    errno = ENOMEM;
+                    break; /* goto free u_list */
                 }
 
-                fs->pin_refcnt++;
-
-                /* once we call this function, the applications seems to be
-                 * interested in events, enable caching them */
-                fs->cache_upcalls = _gf_true;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+                /* XXX: Need to revisit this to support
+                 * GLFS_UPCALL_INODE_UPDATE if required. */
+                ret = glfs_h_poll_cache_invalidation(fs, *up_arg, upcall_data);
+                if (ret || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) {
+                    /* It could so happen that the file which got
+                     * upcall notification may have got deleted by
+                     * the same client. Irrespective of the error,
+                     * return with an error or success+ENOENT. */
+                    if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL)
+                        errno = ENOENT;
 
-        pthread_mutex_lock (&fs->upcall_list_mutex);
-        {
-                list_for_each_entry_safe (u_list, tmp,
-                                          &fs->upcall_list,
-                                          upcall_list) {
-                        list_del_init (&u_list->upcall_list);
-                        upcall_data = &u_list->upcall_data;
-                        break;
+                    GLFS_FREE(*up_arg);
+                    *up_arg = NULL;
                 }
-        }
-        /* No other thread can delete this entry. So unlock it */
-        pthread_mutex_unlock (&fs->upcall_list_mutex);
-
-        if (upcall_data) {
-                switch (upcall_data->event_type) {
-                case GF_UPCALL_CACHE_INVALIDATION:
-                        *up_arg = GF_CALLOC (1, sizeof (struct gf_upcall),
-                                             glfs_mt_upcall_entry_t);
-                        if (!*up_arg) {
-                                errno = ENOMEM;
-                                break; /* goto free u_list */
-                        }
-
-                        /* XXX: Need to revisit this to support
-                         * GLFS_UPCALL_INODE_UPDATE if required. */
-                        ret = glfs_h_poll_cache_invalidation (fs, *up_arg,
-                                                              upcall_data);
-                        if (ret
-                            || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) {
-                                /* It could so happen that the file which got
-                                 * upcall notification may have got deleted by
-                                 * the same client. Irrespective of the error,
-                                 * return with an error or success+ENOENT. */
-                                if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL)
-                                        errno = ENOENT;
-
-                                GF_FREE (*up_arg);
-                                *up_arg = NULL;
-                        }
-                        break;
-                case GF_UPCALL_RECALL_LEASE:
-                        gf_log ("glfs_h_poll_upcall", GF_LOG_DEBUG,
-                                "UPCALL_RECALL_LEASE is not implemented yet");
-                /* fallthrough till we support leases */
-                case GF_UPCALL_EVENT_NULL:
+                break;
+            case GF_UPCALL_RECALL_LEASE:
+                gf_log("glfs_h_poll_upcall", GF_LOG_DEBUG,
+                       "UPCALL_RECALL_LEASE is not implemented yet");
+            /* fallthrough till we support leases */
+            case GF_UPCALL_EVENT_NULL:
                 /* no 'default:' label, to force handling all upcall events */
-                        errno = ENOENT;
-                        break;
-                }
-
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE (u_list);
-        } else {
-                /* fs->upcall_list was empty, no upcall events cached */
                 errno = ENOENT;
+                break;
         }
 
-        ret = 0;
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    } else {
+        /* fs->upcall_list was empty, no upcall events cached */
+        errno = ENOENT;
+    }
+
+    ret = 0;
 
 out:
-        pthread_mutex_lock (&fs->mutex);
-        {
-                fs->pin_refcnt--;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->pin_refcnt--;
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
 restore:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 err:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_poll_upcall, 3.7.16);
-
 static gf_boolean_t log_upcall370 = _gf_true; /* log once */
 
-/* The old glfs_h_poll_upcall interface requires intimite knowledge of the
+/* The old glfs_h_poll_upcall interface requires intimate knowledge of the
  * structures that are returned to the calling application. This is not
  * recommended, as the returned structures need to returned correctly (handles
  * closed, memory free'd with the unavailable GF_FREE(), and possibly more.)
  *
  * To the best of our knowledge, only NFS-Ganesha uses the upcall events
- * through gfapi. We keep this backwards compatability function around so that
+ * through gfapi. We keep this backwards compatibility function around so that
  * applications using the existing implementation do not break.
  *
  * WARNING: this function will be removed in the future.
  */
+GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0)
 int
-pub_glfs_h_poll_upcall370 (struct glfs *fs, struct glfs_callback_arg *up_arg)
+pub_glfs_h_poll_upcall370(struct glfs *fs, struct glfs_callback_arg *up_arg)
 {
-        struct glfs_upcall    *upcall        = NULL;
-        int                    ret           = -1;
-
-        if (log_upcall370) {
-                log_upcall370 = _gf_false;
-                gf_log (THIS->name, GF_LOG_WARNING, "this application is "
-                        "compiled against an old version of libgfapi, it "
-                        "should use glfs_free() to release the structure "
-                        "returned by glfs_h_poll_upcall() - for more details, "
-                        "see http://review.gluster.org/14701");
-        }
+    struct glfs_upcall *upcall = NULL;
+    int ret = -1;
+
+    if (log_upcall370) {
+        log_upcall370 = _gf_false;
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "this application is "
+               "compiled against an old version of libgfapi, it "
+               "should use glfs_free() to release the structure "
+               "returned by glfs_h_poll_upcall() - for more details, "
+               "see http://review.gluster.org/14701");
+    }
+
+    ret = pub_glfs_h_poll_upcall(fs, &upcall);
+    if (ret == 0) {
+        up_arg->fs = fs;
+        if ((errno == ENOENT) || !upcall || !upcall->event) {
+            up_arg->reason = GLFS_UPCALL_EVENT_NULL;
+            goto out;
+        }
+
+        up_arg->reason = upcall->reason;
+
+        if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) {
+            struct glfs_callback_inode_arg *cb_inode = NULL;
+            struct glfs_upcall_inode *up_inode = NULL;
+
+            cb_inode = GF_CALLOC(1, sizeof(struct glfs_callback_inode_arg),
+                                 glfs_mt_upcall_inode_t);
+            if (!cb_inode) {
+                errno = ENOMEM;
+                ret = -1;
+                goto out;
+            }
 
-        ret = pub_glfs_h_poll_upcall (fs, &upcall);
-        if (ret == 0) {
-                up_arg->fs = fs;
-                if (errno == ENOENT || upcall->event == NULL) {
-                        up_arg->reason = GLFS_UPCALL_EVENT_NULL;
-                        goto out;
-                }
+            up_inode = upcall->event;
 
-                up_arg->reason = upcall->reason;
-
-                if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                        struct glfs_callback_inode_arg *cb_inode = NULL;
-                        struct glfs_upcall_inode       *up_inode = NULL;
-
-                        cb_inode = GF_CALLOC (1,
-                                              sizeof (struct glfs_callback_inode_arg),
-                                              glfs_mt_upcall_inode_t);
-                        if (!cb_inode) {
-                                errno = ENOMEM;
-                                ret = -1;
-                                goto out;
-                        }
-
-                        up_inode = upcall->event;
-
-                        /* copy attributes one by one, the memory layout might
-                         * be different between the old glfs_callback_inode_arg
-                         * and new glfs_upcall_inode */
-                        cb_inode->object = up_inode->object;
-                        cb_inode->flags = up_inode->flags;
-                        memcpy (&cb_inode->buf, &up_inode->buf,
-                                sizeof (struct stat));
-                        cb_inode->expire_time_attr = up_inode->expire_time_attr;
-                        cb_inode->p_object = up_inode->p_object;
-                        memcpy (&cb_inode->p_buf, &up_inode->p_buf,
-                                sizeof (struct stat));
-                        cb_inode->oldp_object = up_inode->oldp_object;
-                        memcpy (&cb_inode->oldp_buf, &up_inode->oldp_buf,
-                                sizeof (struct stat));
-
-                        up_arg->event_arg = cb_inode;
-                }
+            /* copy attributes one by one, the memory layout might
+             * be different between the old glfs_callback_inode_arg
+             * and new glfs_upcall_inode */
+            cb_inode->object = up_inode->object;
+            cb_inode->flags = up_inode->flags;
+            memcpy(&cb_inode->buf, &up_inode->buf, sizeof(struct stat));
+            cb_inode->expire_time_attr = up_inode->expire_time_attr;
+            cb_inode->p_object = up_inode->p_object;
+            memcpy(&cb_inode->p_buf, &up_inode->p_buf, sizeof(struct stat));
+            cb_inode->oldp_object = up_inode->oldp_object;
+            memcpy(&cb_inode->oldp_buf, &up_inode->oldp_buf,
+                   sizeof(struct stat));
+
+            up_arg->event_arg = cb_inode;
         }
+    }
 
 out:
-        if (upcall) {
-                /* we can not use glfs_free() here, objects need to stay */
-                GF_FREE (upcall->event);
-                GF_FREE (upcall);
-        }
+    if (upcall) {
+        /* we can not use glfs_free() here, objects need to stay */
+        GF_FREE(upcall->event);
+        GF_FREE(upcall);
+    }
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0);
-
 #ifdef HAVE_ACL_LIBACL_H
-#include "glusterfs-acl.h"
+#include <glusterfs/glusterfs-acl.h>
 #include <acl/libacl.h>
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_set, 3.7.0)
 int
-pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type, const acl_t acl)
+pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type, const acl_t acl)
 {
-        int ret = -1;
-        char *acl_s = NULL;
-        const char *acl_key = NULL;
-        struct glfs_object *new_object = NULL;
+    int ret = -1;
+    char *acl_s = NULL;
+    const char *acl_key = NULL;
+    struct glfs_object *new_object = NULL;
 
-        DECLARE_OLD_THIS;
+    DECLARE_OLD_THIS;
 
-        if (!object || !acl) {
-                errno = EINVAL;
-                return ret;
-        }
+    if (!object || !acl) {
+        errno = EINVAL;
+        return ret;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        acl_key = gf_posix_acl_get_key (type);
-        if (!acl_key)
-                goto out;
+    acl_key = gf_posix_acl_get_key(type);
+    if (!acl_key)
+        goto out;
 
-        acl_s = acl_to_any_text (acl, NULL, ',',
-                                 TEXT_ABBREVIATE | TEXT_NUMERIC_IDS);
-        if (!acl_s)
-                goto out;
+    acl_s = acl_to_any_text(acl, NULL, ',', TEXT_ABBREVIATE | TEXT_NUMERIC_IDS);
+    if (!acl_s)
+        goto out;
 
-        if (IA_ISLNK (object->inode->ia_type)) {
-                new_object = glfs_h_resolve_symlink (fs, object);
-                if (new_object == NULL)
-                        goto out;
-        } else
-                new_object = object;
+    if (IA_ISLNK(object->inode->ia_type)) {
+        new_object = glfs_h_resolve_symlink(fs, object);
+        if (new_object == NULL)
+            goto out;
+    } else
+        new_object = object;
 
-        ret = pub_glfs_h_setxattrs (fs, new_object, acl_key, acl_s,
-                                    strlen (acl_s) + 1, 0);
+    ret = pub_glfs_h_setxattrs(fs, new_object, acl_key, acl_s,
+                               strlen(acl_s) + 1, 0);
 
-        acl_free (acl_s);
+    acl_free(acl_s);
 
 out:
-        if (IA_ISLNK (object->inode->ia_type) && new_object)
-                glfs_h_close (new_object);
+    if (IA_ISLNK(object->inode->ia_type) && new_object)
+        glfs_h_close(new_object);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_get, 3.7.0)
 acl_t
-pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type)
+pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type)
 {
-        int                 ret = 0;
-        acl_t acl = NULL;
-        char *acl_s = NULL;
-        dict_t *xattr = NULL;
-        const char *acl_key = NULL;
-        struct glfs_object *new_object = NULL;
-
-        DECLARE_OLD_THIS;
-
-        if (!object) {
-                errno = EINVAL;
-                return NULL;
-        }
+    int ret = 0;
+    acl_t acl = NULL;
+    char *acl_s = NULL;
+    dict_t *xattr = NULL;
+    const char *acl_key = NULL;
+    struct glfs_object *new_object = NULL;
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
 
-        acl_key = gf_posix_acl_get_key (type);
-        if (!acl_key)
-                goto out;
+    if (!object) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        if (IA_ISLNK (object->inode->ia_type)) {
-                new_object = glfs_h_resolve_symlink (fs, object);
-                if (new_object == NULL)
-                        goto out;
-        } else
-                new_object = object;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        ret = glfs_h_getxattrs_common (fs, new_object, &xattr, acl_key,
-                                       _gf_false);
-        if (ret)
-                goto out;
+    acl_key = gf_posix_acl_get_key(type);
+    if (!acl_key)
+        goto out;
 
-        ret = dict_get_str (xattr, (char *)acl_key, &acl_s);
-        if (ret)
-                goto out;
+    if (IA_ISLNK(object->inode->ia_type)) {
+        new_object = glfs_h_resolve_symlink(fs, object);
+        if (new_object == NULL)
+            goto out;
+    } else
+        new_object = object;
 
-        acl = acl_from_text (acl_s);
+    ret = glfs_h_getxattrs_common(fs, new_object, &xattr, acl_key, _gf_false);
+    if (ret)
+        goto out;
+
+    ret = dict_get_str(xattr, (char *)acl_key, &acl_s);
+    if (ret)
+        goto out;
+
+    acl = acl_from_text(acl_s);
 
 out:
-        if (xattr)
-                dict_unref(xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        if (IA_ISLNK (object->inode->ia_type) && new_object)
-                glfs_h_close (new_object);
+    if (IA_ISLNK(object->inode->ia_type) && new_object)
+        glfs_h_close(new_object);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return acl;
+    return acl;
 }
 #else /* !HAVE_ACL_LIBACL_H */
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_get, 3.7.0)
 acl_t
-pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type)
+pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type)
 {
-        errno = ENOTSUP;
-        return NULL;
+    errno = ENOTSUP;
+    return NULL;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_set, 3.7.0)
 int
-pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type, const acl_t acl)
+pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type, const acl_t acl)
 {
-        errno = ENOTSUP;
-        return -1;
+    errno = ENOTSUP;
+    return -1;
 }
 #endif
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_set, 3.7.0);
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_get, 3.7.0);
 
 /* The API to perform read using anonymous fd */
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_read, 3.7.0)
 ssize_t
-pub_glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object,
-                           const void *buf, size_t count, off_t offset)
+pub_glfs_h_anonymous_read(struct glfs *fs, struct glfs_object *object,
+                          const void *buf, size_t count, off_t offset)
 {
-        struct iovec    iov     = {0, };
-        ssize_t         ret     = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_anonymous_preadv (fs, object, &iov, 1, offset, 0);
+    ret = glfs_anonymous_preadv(fs, object, &iov, 1, offset, 0);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_read, 3.7.0);
-
 /* The API to perform write using anonymous fd */
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_write, 3.7.0)
 ssize_t
-pub_glfs_h_anonymous_write (struct glfs *fs, struct glfs_object *object,
-                            const void *buf, size_t count, off_t offset)
+pub_glfs_h_anonymous_write(struct glfs *fs, struct glfs_object *object,
+                           const void *buf, size_t count, off_t offset)
 {
-        struct iovec iov        = {0, };
-        ssize_t      ret        = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_anonymous_pwritev (fs, object, &iov, 1, offset, 0);
+    ret = glfs_anonymous_pwritev(fs, object, &iov, 1, offset, 0);
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_write, 3.7.0);
-
-struct glfs_object*
-pub_glfs_object_copy (struct glfs_object *src)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_object_copy, 3.11.0)
+struct glfs_object *
+pub_glfs_object_copy(struct glfs_object *src)
 {
-        struct glfs_object *object = NULL;
+    struct glfs_object *object = NULL;
 
-        GF_VALIDATE_OR_GOTO ("glfs_dup_object", src, out);
+    GF_VALIDATE_OR_GOTO("glfs_dup_object", src, out);
 
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                         API_MSG_CREATE_HANDLE_FAILED,
-                        "glfs_dup_object for gfid-%s failed",
-                        uuid_utoa (src->inode->gfid));
-                return NULL;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        gf_smsg(THIS->name, GF_LOG_WARNING, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "glfs_dup_object gfid=%s", uuid_utoa(src->inode->gfid), NULL);
+        return NULL;
+    }
 
-        object->inode = inode_ref (src->inode);
-        gf_uuid_copy (object->gfid, src->inode->gfid);
+    object->inode = inode_ref(src->inode);
+    gf_uuid_copy(object->gfid, src->inode->gfid);
 
 out:
-        return object;
+    return object;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_object_copy, 3.11.0);
 
-struct glfs_object*
-pub_glfs_xreaddirplus_get_object (struct glfs_xreaddirp_stat *xstat)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_object, 3.11.0)
+struct glfs_object *
+pub_glfs_xreaddirplus_get_object(struct glfs_xreaddirp_stat *xstat)
 {
-        GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_object", xstat, out);
+    GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_object", xstat, out);
 
-        if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE))
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "GFAPI_XREADDIRP_HANDLE is not set. Flags"
-                        "handled for xstat(%p) are (%x)",
-                        xstat, xstat->flags_handled);
+    if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE))
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_HANDLE_NOT_SET,
+                "GFAPI_XREADDIRP_HANDLE xstat=%p", xstat, "handle=%x",
+                xstat->flags_handled, NULL);
 
-        return xstat->object;
+    return xstat->object;
 
 out:
-        return NULL;
+    return NULL;
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lease, 4.0.0)
+int
+pub_glfs_h_lease(struct glfs *fs, struct glfs_object *object,
+                 struct glfs_lease *lease)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct gf_lease gf_lease = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    glfs_lease_to_gf_lease(lease, &gf_lease);
+
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    gf_lease_to_glfs_lease(&gf_lease, lease);
+
+out:
+    loc_wipe(&loc);
+
+    if (inode)
+        inode_unref(inode);
+
+    glfs_subvol_done(fs, subvol);
+
+    __GLFS_EXIT_FS;
+
+invalid_fs:
+    return ret;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_object, 3.11.0);
diff --git a/api/src/glfs-handles.h b/api/src/glfs-handles.h
index 9583fab069a..4d039b9c76b 100644
--- a/api/src/glfs-handles.h
+++ b/api/src/glfs-handles.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2013-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -12,7 +12,6 @@
 #define _GLFS_HANDLES_H
 
 #include "glfs.h"
-#include <inttypes.h>
 
 /* GLFS OBJECT BASED OPERATIONS
  *
@@ -47,46 +46,39 @@
  *
  */
 
-/* Values for valid falgs to be used when using XXXsetattr, to set multiple
- attribute values passed via the related stat structure.
- */
-#define GFAPI_SET_ATTR_MODE  0x1
-#define GFAPI_SET_ATTR_UID   0x2
-#define GFAPI_SET_ATTR_GID   0x4
-#define GFAPI_SET_ATTR_SIZE  0x8
-#define GFAPI_SET_ATTR_ATIME 0x10
-#define GFAPI_SET_ATTR_MTIME 0x20
-
 /* Handle length for object handles returned from glfs_h_extract_handle or
  * glfs_h_create_from_handle */
 #define GFAPI_HANDLE_LENGTH 16
 
 /* These flags should be in sync to the ones defined in upcall.h */
-#define GFAPI_UP_NLINK   0x00000001   /* update nlink */
-#define GFAPI_UP_MODE    0x00000002   /* update mode and ctime */
-#define GFAPI_UP_OWN     0x00000004   /* update mode,uid,gid and ctime */
-#define GFAPI_UP_SIZE    0x00000008   /* update fsize */
-#define GFAPI_UP_TIMES   0x00000010   /* update all times */
-#define GFAPI_UP_ATIME   0x00000020   /* update atime only */
-#define GFAPI_UP_PERM    0x00000040   /* update fields needed for
-                                         permission checking */
-#define GFAPI_UP_RENAME  0x00000080   /* this is a rename op -
-                                         delete the cache entry */
-#define GFAPI_UP_FORGET  0x00000100   /* inode_forget on server side -
-                                         invalidate the cache entry */
-#define GFAPI_UP_PARENT_TIMES   0x00000200   /* update parent dir times */
-
-#define GFAPI_INODE_UPDATE_FLAGS (GFAPI_UP_NLINK | GFAPI_UP_MODE | \
-                                  GFAPI_UP_OWN | GFAPI_UP_SIZE | \
-                                  GFAPI_UP_TIMES | GFAPI_UP_ATIME)
+#define GFAPI_UP_NLINK 0x00000001 /* update nlink */
+#define GFAPI_UP_MODE 0x00000002  /* update mode and ctime */
+#define GFAPI_UP_OWN 0x00000004   /* update mode,uid,gid and ctime */
+#define GFAPI_UP_SIZE 0x00000008  /* update fsize */
+#define GFAPI_UP_TIMES 0x00000010 /* update all times */
+#define GFAPI_UP_ATIME 0x00000020 /* update atime only */
+#define GFAPI_UP_PERM                                                          \
+    0x00000040 /* update fields needed for                                     \
+                  permission checking */
+#define GFAPI_UP_RENAME                                                        \
+    0x00000080 /* this is a rename op -                                        \
+                  delete the cache entry */
+#define GFAPI_UP_FORGET                                                        \
+    0x00000100                           /* inode_forget on server side -      \
+                                            invalidate the cache entry */
+#define GFAPI_UP_PARENT_TIMES 0x00000200 /* update parent dir times */
+
+#define GFAPI_INODE_UPDATE_FLAGS                                               \
+    (GFAPI_UP_NLINK | GFAPI_UP_MODE | GFAPI_UP_OWN | GFAPI_UP_SIZE |           \
+     GFAPI_UP_TIMES | GFAPI_UP_ATIME)
 
 /* Portability non glibc c++ build systems */
 #ifndef __THROW
-# if defined __cplusplus
-#  define __THROW       throw ()
-# else
-#  define __THROW
-# endif
+#if defined __cplusplus
+#define __THROW throw()
+#else
+#define __THROW
+#endif
 #endif
 
 __BEGIN_DECLS
@@ -102,49 +94,6 @@ __BEGIN_DECLS
 struct glfs_object;
 typedef struct glfs_object glfs_object_t;
 
-/*
- * Applications (currently NFS-Ganesha) can make use of this
- * structure to read upcall notifications sent by server.
- *
- * On success, applications need to check for 'reason' to decide
- * if any upcall event is received.
- *
- * Currently supported upcall_events -
- *      GFAPI_INODE_INVALIDATE -
- *              'event_arg' - glfs_upcall_inode
- *
- * After processing the event, applications need to free 'event_arg' with
- * glfs_free().
- *
- * Also similar to I/Os, the application should ideally stop polling
- * before calling glfs_fini(..). Hence making an assumption that
- * 'fs' & ctx structures cannot be freed while in this routine.
- */
-struct glfs_upcall;
-
-struct glfs*
-glfs_upcall_get_fs (struct glfs_upcall *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_get_fs, 3.7.16);
-
-enum glfs_upcall_reason {
-        GLFS_UPCALL_EVENT_NULL = 0,
-        GLFS_UPCALL_INODE_INVALIDATE,    /* invalidate cache entry */
-};
-
-enum glfs_upcall_reason
-glfs_upcall_get_reason (struct glfs_upcall *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_get_reason, 3.7.16);
-
-
-/*
- * After processing upcall event, glfs_free() should be called on the
- * glfs_upcall.
- */
-void*
-glfs_upcall_get_event (struct glfs_upcall *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_get_event, 3.7.16);
-
-
 /* Functions for getting details about the glfs_upcall_inode
  *
  * None of the pointers returned by the below functions should be free()'d,
@@ -154,153 +103,158 @@ glfs_upcall_get_event (struct glfs_upcall *arg) __THROW
  * to glfs_free().
  */
 struct glfs_upcall_inode;
+typedef struct glfs_upcall_inode glfs_upcall_inode_t;
 
-struct glfs_object*
-glfs_upcall_inode_get_object (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_object, 3.7.16);
+glfs_object_t *
+glfs_upcall_inode_get_object(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_object, 3.7.16);
 
 uint64_t
-glfs_upcall_inode_get_flags (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_flags, 3.7.16);
+glfs_upcall_inode_get_flags(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_flags, 3.7.16);
 
-struct stat*
-glfs_upcall_inode_get_stat (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_stat, 3.7.16);
+struct stat *
+glfs_upcall_inode_get_stat(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_stat, 3.7.16);
 
 uint64_t
-glfs_upcall_inode_get_expire (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_expire, 3.7.16);
+glfs_upcall_inode_get_expire(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_expire, 3.7.16);
 
-struct glfs_object*
-glfs_upcall_inode_get_pobject (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_pobject, 3.7.16);
+glfs_object_t *
+glfs_upcall_inode_get_pobject(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_pobject, 3.7.16);
 
-struct stat*
-glfs_upcall_inode_get_pstat (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_pstat, 3.7.16);
+struct stat *
+glfs_upcall_inode_get_pstat(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_pstat, 3.7.16);
 
-struct glfs_object*
-glfs_upcall_inode_get_oldpobject (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_oldpobject, 3.7.16);
-
-struct stat*
-glfs_upcall_inode_get_oldpstat (struct glfs_upcall_inode *arg) __THROW
-        GFAPI_PUBLIC(glfs_upcall_inode_get_oldpstat, 3.7.16);
+glfs_object_t *
+glfs_upcall_inode_get_oldpobject(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_oldpobject, 3.7.16);
 
+struct stat *
+glfs_upcall_inode_get_oldpstat(glfs_upcall_inode_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_inode_get_oldpstat, 3.7.16);
 
 /* Handle based operations */
 /* Operations that generate handles */
-struct glfs_object *glfs_h_lookupat (struct glfs *fs,
-                                     struct glfs_object *parent,
-                                     const char *path,
-                                     struct stat *stat, int follow) __THROW
-        GFAPI_PUBLIC(glfs_h_lookupat, 3.7.4);
-
-struct glfs_object *glfs_h_creat (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, int flags, mode_t mode,
-				  struct stat *sb) __THROW
-        GFAPI_PUBLIC(glfs_h_creat, 3.4.2);
-
-struct glfs_object *glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, mode_t flags,
-				  struct stat *sb) __THROW
-        GFAPI_PUBLIC(glfs_h_mkdir, 3.4.2);
-
-struct glfs_object *glfs_h_mknod (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, mode_t mode, dev_t dev,
-				  struct stat *sb) __THROW
-        GFAPI_PUBLIC(glfs_h_mknod, 3.4.2);
-
-struct glfs_object *glfs_h_symlink (struct glfs *fs, struct glfs_object *parent,
-				    const char *name, const char *data,
-				    struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_symlink, 3.4.2);
+glfs_object_t *
+glfs_h_lookupat(glfs_t *fs, glfs_object_t *parent, const char *path,
+                struct stat *stat, int follow) __THROW
+    GFAPI_PUBLIC(glfs_h_lookupat, 3.7.4);
+
+glfs_object_t *
+glfs_h_creat(glfs_t *fs, glfs_object_t *parent, const char *path, int flags,
+             mode_t mode, struct stat *sb) __THROW
+    GFAPI_PUBLIC(glfs_h_creat, 3.4.2);
+
+glfs_object_t *
+glfs_h_mkdir(glfs_t *fs, glfs_object_t *parent, const char *path, mode_t flags,
+             struct stat *sb) __THROW GFAPI_PUBLIC(glfs_h_mkdir, 3.4.2);
+
+glfs_object_t *
+glfs_h_mknod(glfs_t *fs, glfs_object_t *parent, const char *path, mode_t mode,
+             dev_t dev, struct stat *sb) __THROW
+    GFAPI_PUBLIC(glfs_h_mknod, 3.4.2);
+
+glfs_object_t *
+glfs_h_symlink(glfs_t *fs, glfs_object_t *parent, const char *name,
+               const char *data, struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_h_symlink, 3.4.2);
 
 /* Operations on the actual objects */
-int glfs_h_unlink (struct glfs *fs, struct glfs_object *parent,
-		   const char *path) __THROW
-        GFAPI_PUBLIC(glfs_h_unlink, 3.4.2);
+int
+glfs_h_unlink(glfs_t *fs, glfs_object_t *parent, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_h_unlink, 3.4.2);
 
-int glfs_h_close (struct glfs_object *object) __THROW
-        GFAPI_PUBLIC(glfs_h_close, 3.4.2);
+int
+glfs_h_close(glfs_object_t *object) __THROW GFAPI_PUBLIC(glfs_h_close, 3.4.2);
 
-int glfs_caller_specific_init (void *uid_caller_key, void *gid_caller_key,
-			       void *future) __THROW
-        GFAPI_PUBLIC(glfs_caller_specific_init, 3.5.0);
+int
+glfs_caller_specific_init(void *uid_caller_key, void *gid_caller_key,
+                          void *future) __THROW
+    GFAPI_PUBLIC(glfs_caller_specific_init, 3.5.0);
 
-int glfs_h_truncate (struct glfs *fs, struct glfs_object *object,
-                     off_t offset) __THROW
-        GFAPI_PUBLIC(glfs_h_truncate, 3.4.2);
+int
+glfs_h_truncate(glfs_t *fs, glfs_object_t *object, off_t offset) __THROW
+    GFAPI_PUBLIC(glfs_h_truncate, 3.4.2);
 
-int glfs_h_stat(struct glfs *fs, struct glfs_object *object,
-                struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_stat, 3.4.2);
+int
+glfs_h_stat(glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_h_stat, 3.4.2);
 
-int glfs_h_statfs(struct glfs *fs, struct glfs_object *object,
-                struct statvfs *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_statfs, 3.7.0);
+int
+glfs_h_statfs(glfs_t *fs, glfs_object_t *object, struct statvfs *stat) __THROW
+    GFAPI_PUBLIC(glfs_h_statfs, 3.7.0);
 
-int glfs_h_getattrs (struct glfs *fs, struct glfs_object *object,
-		     struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_getattrs, 3.4.2);
+int
+glfs_h_getattrs(glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_h_getattrs, 3.4.2);
 
-int glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object,
-		      const char *name, void *value,
-		      size_t size) __THROW
-        GFAPI_PUBLIC(glfs_h_getxattrs, 3.5.1);
+int
+glfs_h_getxattrs(glfs_t *fs, glfs_object_t *object, const char *name,
+                 void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_h_getxattrs, 3.5.1);
 
-int glfs_h_setattrs (struct glfs *fs, struct glfs_object *object,
-		     struct stat *sb, int valid) __THROW
-        GFAPI_PUBLIC(glfs_h_setattrs, 3.4.2);
+int
+glfs_h_setattrs(glfs_t *fs, glfs_object_t *object, struct stat *sb,
+                int valid) __THROW GFAPI_PUBLIC(glfs_h_setattrs, 3.4.2);
 
-int glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object,
-		      const char *name, const void *value,
-		      size_t size, int flags) __THROW
-        GFAPI_PUBLIC(glfs_h_setxattrs, 3.5.0);
+int
+glfs_h_setxattrs(glfs_t *fs, glfs_object_t *object, const char *name,
+                 const void *value, size_t size, int flags) __THROW
+    GFAPI_PUBLIC(glfs_h_setxattrs, 3.5.0);
 
-int glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf,
-		     size_t bufsiz) __THROW
-        GFAPI_PUBLIC(glfs_h_readlink, 3.4.2);
+int
+glfs_h_readlink(glfs_t *fs, glfs_object_t *object, char *buf,
+                size_t bufsiz) __THROW GFAPI_PUBLIC(glfs_h_readlink, 3.4.2);
 
-int glfs_h_link (struct glfs *fs, struct glfs_object *linktgt,
-		 struct glfs_object *parent, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_h_link, 3.4.2);
+int
+glfs_h_link(glfs_t *fs, glfs_object_t *linktgt, glfs_object_t *parent,
+            const char *name) __THROW GFAPI_PUBLIC(glfs_h_link, 3.4.2);
 
-int glfs_h_rename (struct glfs *fs, struct glfs_object *olddir,
-		   const char *oldname, struct glfs_object *newdir,
-		   const char *newname) __THROW
-        GFAPI_PUBLIC(glfs_h_rename, 3.4.2);
+int
+glfs_h_rename(glfs_t *fs, glfs_object_t *olddir, const char *oldname,
+              glfs_object_t *newdir, const char *newname) __THROW
+    GFAPI_PUBLIC(glfs_h_rename, 3.4.2);
 
-int glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object,
-			 const char *name) __THROW
-        GFAPI_PUBLIC(glfs_h_removexattrs, 3.5.1);
+int
+glfs_h_removexattrs(glfs_t *fs, glfs_object_t *object, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_h_removexattrs, 3.5.1);
 
 /* Operations enabling opaque invariant handle to object transitions */
-ssize_t glfs_h_extract_handle (struct glfs_object *object,
-			       unsigned char *handle, int len) __THROW
-        GFAPI_PUBLIC(glfs_h_extract_handle, 3.4.2);
+ssize_t
+glfs_h_extract_handle(glfs_object_t *object, unsigned char *handle,
+                      int len) __THROW
+    GFAPI_PUBLIC(glfs_h_extract_handle, 3.4.2);
 
 /* Given a handle, looks up the inode and creates glfs_object.
  * In addition, if provided 'stat', copies the inode attributes
  */
-struct glfs_object *glfs_h_create_from_handle (struct glfs *fs,
-					       unsigned char *handle, int len,
-					       struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_h_create_from_handle, 3.4.2);
+glfs_object_t *
+glfs_h_create_from_handle(glfs_t *fs, unsigned char *handle, int len,
+                          struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_h_create_from_handle, 3.4.2);
 
 /* Operations enabling object handles to fd transitions */
-struct glfs_fd *glfs_h_opendir (struct glfs *fs,
-                                struct glfs_object *object) __THROW
-        GFAPI_PUBLIC(glfs_h_opendir, 3.4.2);
+glfs_fd_t *
+glfs_h_opendir(glfs_t *fs, glfs_object_t *object) __THROW
+    GFAPI_PUBLIC(glfs_h_opendir, 3.4.2);
 
-struct glfs_fd *glfs_h_open (struct glfs *fs, struct glfs_object *object,
-			     int flags) __THROW
-        GFAPI_PUBLIC(glfs_h_open, 3.4.2);
+glfs_fd_t *
+glfs_h_open(glfs_t *fs, glfs_object_t *object, int flags) __THROW
+    GFAPI_PUBLIC(glfs_h_open, 3.4.2);
 
 int
-glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) __THROW
-        GFAPI_PUBLIC(glfs_h_access, 3.6.0);
-
+glfs_h_access(glfs_t *fs, glfs_object_t *object, int mask) __THROW
+    GFAPI_PUBLIC(glfs_h_access, 3.6.0);
+
+struct glfs_object *
+glfs_h_creat_open(struct glfs *fs, struct glfs_object *parent, const char *path,
+                  int flags, mode_t mode, struct stat *stat,
+                  struct glfs_fd **out_fd) __THROW
+    GFAPI_PUBLIC(glfs_h_creat_open, 6.6);
 /*
   SYNOPSIS
 
@@ -310,7 +264,7 @@ glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) __THROW
 
   This API is used to poll for upcall events stored in the
   upcall list. Current users of this API is NFS-Ganesha.
-  Incase of any event received, it will be mapped appropriately
+  In case of any event received, it will be mapped appropriately
   into 'glfs_upcall' along with the handle('glfs_object') to be
   passed to NFS-Ganesha.
 
@@ -332,44 +286,69 @@ glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) __THROW
 */
 
 int
-glfs_h_poll_upcall (struct glfs *fs, struct glfs_upcall **cbk) __THROW
-        GFAPI_PUBLIC(glfs_h_poll_upcall, 3.7.16);
+glfs_h_poll_upcall(glfs_t *fs, glfs_upcall_t **cbk) __THROW
+    GFAPI_PUBLIC(glfs_h_poll_upcall, 3.7.16);
 
 int
-glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                const acl_type_t type, const acl_t acl) __THROW
-        GFAPI_PUBLIC(glfs_h_acl_set, 3.7.0);
+glfs_h_acl_set(glfs_t *fs, glfs_object_t *object, const acl_type_t type,
+               const acl_t acl) __THROW GFAPI_PUBLIC(glfs_h_acl_set, 3.7.0);
 
 acl_t
-glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
-                const acl_type_t type) __THROW
-        GFAPI_PUBLIC(glfs_h_acl_get, 3.7.0);
+glfs_h_acl_get(glfs_t *fs, glfs_object_t *object, const acl_type_t type) __THROW
+    GFAPI_PUBLIC(glfs_h_acl_get, 3.7.0);
 
 size_t
-glfs_h_anonymous_write (struct glfs *fs, struct glfs_object *object,
-                        const void *buf, size_t count, off_t offset) __THROW
-        GFAPI_PUBLIC(glfs_h_anonymous_write, 3.7.0);
+glfs_h_anonymous_write(glfs_t *fs, glfs_object_t *object, const void *buf,
+                       size_t count, off_t offset) __THROW
+    GFAPI_PUBLIC(glfs_h_anonymous_write, 3.7.0);
 
 ssize_t
-glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object,
-                      const void *buf, size_t count, off_t offset) __THROW
-        GFAPI_PUBLIC(glfs_h_anonymous_read, 3.7.0);
+glfs_h_anonymous_read(glfs_t *fs, glfs_object_t *object, const void *buf,
+                      size_t count, off_t offset) __THROW
+    GFAPI_PUBLIC(glfs_h_anonymous_read, 3.7.0);
 
 /*
  * Caution: The object returned by this object gets freed as part
  * of 'glfs_free(xstat)'. Make sure to have a copy using 'glfs_object_copy()'
  * to use post that.
  */
-struct glfs_object*
-glfs_xreaddirplus_get_object (struct glfs_xreaddirp_stat *xstat) __THROW
-        GFAPI_PUBLIC(glfs_xreaddirplus_get_object, 3.11.0);
+glfs_object_t *
+glfs_xreaddirplus_get_object(struct glfs_xreaddirp_stat *xstat) __THROW
+    GFAPI_PUBLIC(glfs_xreaddirplus_get_object, 3.11.0);
 
 /* Applications should close the object returned by this routine
  * explicitly using 'glfs_h_close()'
  */
-struct glfs_object*
-glfs_object_copy (struct glfs_object *src);
-        GFAPI_PUBLIC(glfs_object_copy, 3.11.0);
+glfs_object_t *
+glfs_object_copy(glfs_object_t *src) __THROW
+    GFAPI_PUBLIC(glfs_object_copy, 3.11.0);
+
+int
+glfs_h_lease(glfs_t *fs, glfs_object_t *object, glfs_lease_t *lease) __THROW
+    GFAPI_PUBLIC(glfs_h_lease, 4.0.0);
+
+glfs_object_t *
+glfs_h_find_handle(glfs_t *fs, unsigned char *handle, int len) __THROW
+    GFAPI_PUBLIC(glfs_h_lease, 4.0.0);
+
+/* Functions for getting details about the glfs_upcall_lease
+ *
+ * None of the pointers returned by the below functions should be free()'d,
+ * glfs_free()'d or glfs_h_close()'d by the application.
+ *
+ * Releasing of the structures is done by passing the glfs_upcall pointer
+ * to glfs_free().
+ */
+struct glfs_upcall_lease;
+typedef struct glfs_upcall_lease glfs_upcall_lease_t;
+
+glfs_object_t *
+glfs_upcall_lease_get_object(glfs_upcall_lease_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_lease_get_object, 4.1.6);
+
+uint32_t
+glfs_upcall_lease_get_lease_type(glfs_upcall_lease_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_lease_get_lease_type, 4.1.6);
 
 __END_DECLS
 
diff --git a/api/src/glfs-internal.h b/api/src/glfs-internal.h
index c94fcd9078d..7cc3b18a104 100644
--- a/api/src/glfs-internal.h
+++ b/api/src/glfs-internal.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,25 +8,25 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef _GLFS_INTERNAL_H
 #define _GLFS_INTERNAL_H
 
-#include "xlator.h"
-#include "glusterfs.h"
-#include "upcall-utils.h"
+#include <glusterfs/xlator.h>
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/upcall-utils.h>
 #include "glfs-handles.h"
-#include "refcount.h"
+#include <glusterfs/refcount.h>
+#include <glusterfs/syncop.h>
 
 #define GLFS_SYMLINK_MAX_FOLLOW 2048
 
 #define DEFAULT_REVAL_COUNT 1
 
 /*
- * According to  pthread mutex and conditional variable ( cond, child_down_count,
- * upcall mutex and mutex) initialization of struct glfs members,
- * below GLFS_INIT_* flags are set in 'pthread_flags' member of struct glfs.
- * The flags are set from glfs_init() and  glfs_new_from_ctx() functions
+ * According to  pthread mutex and conditional variable ( cond,
+ * child_down_count, upcall mutex and mutex) initialization of struct glfs
+ * members, below GLFS_INIT_* flags are set in 'pthread_flags' member of struct
+ * glfs. The flags are set from glfs_init() and  glfs_new_from_ctx() functions
  * as part of fs inititialization.
  *
  * These flag bits are validated in glfs_fini() to destroy all or partially
@@ -37,39 +37,42 @@
  *
  */
 
-#define PTHREAD_MUTEX_INIT(mutex, attr, flags, mask, label) do { \
-        int __ret = -1;                                          \
-        __ret = pthread_mutex_init (mutex, attr);                \
-        if (__ret == 0)                                          \
-                flags |= mask;                                   \
-        else                                                     \
-                goto label;                                      \
-} while (0)
-
-#define PTHREAD_MUTEX_DESTROY(mutex, flags, mask) do {           \
-        if (flags & mask)                                        \
-                (void) pthread_mutex_destroy (mutex);            \
-} while (0)
-
-#define PTHREAD_COND_INIT(cond, attr, flags, mask, label) do {   \
-        int __ret = -1;                                          \
-        __ret = pthread_cond_init (cond, attr);                  \
-        if (__ret == 0)                                          \
-                flags |= mask;                                   \
-        else                                                     \
-                goto label;                                      \
-} while (0)
-
-#define PTHREAD_COND_DESTROY(cond, flags, mask) do {             \
-        if (flags & mask)                                        \
-                (void) pthread_cond_destroy (cond);              \
-} while (0)
-
-#define GLFS_INIT_MUTEX              0x00000001   /* pthread_mutex_flag */
-#define GLFS_INIT_COND               0x00000002   /* pthread_cond_flag */
-#define GLFS_INIT_COND_CHILD         0x00000004   /* pthread_cond_child_down_flag */
-#define GLFS_INIT_MUTEX_UPCALL       0x00000008   /* pthread_mutex_upcall_flag */
-
+#define PTHREAD_MUTEX_INIT(mutex, attr, flags, mask, label)                    \
+    do {                                                                       \
+        int __ret = -1;                                                        \
+        __ret = pthread_mutex_init(mutex, attr);                               \
+        if (__ret == 0)                                                        \
+            flags |= mask;                                                     \
+        else                                                                   \
+            goto label;                                                        \
+    } while (0)
+
+#define PTHREAD_MUTEX_DESTROY(mutex, flags, mask)                              \
+    do {                                                                       \
+        if (flags & mask)                                                      \
+            (void)pthread_mutex_destroy(mutex);                                \
+    } while (0)
+
+#define PTHREAD_COND_INIT(cond, attr, flags, mask, label)                      \
+    do {                                                                       \
+        int __ret = -1;                                                        \
+        __ret = pthread_cond_init(cond, attr);                                 \
+        if (__ret == 0)                                                        \
+            flags |= mask;                                                     \
+        else                                                                   \
+            goto label;                                                        \
+    } while (0)
+
+#define PTHREAD_COND_DESTROY(cond, flags, mask)                                \
+    do {                                                                       \
+        if (flags & mask)                                                      \
+            (void)pthread_cond_destroy(cond);                                  \
+    } while (0)
+
+#define GLFS_INIT_MUTEX 0x00000001        /* pthread_mutex_flag */
+#define GLFS_INIT_COND 0x00000002         /* pthread_cond_flag */
+#define GLFS_INIT_COND_CHILD 0x00000004   /* pthread_cond_child_down_flag */
+#define GLFS_INIT_MUTEX_UPCALL 0x00000008 /* pthread_mutex_upcall_flag */
 
 #ifndef GF_DARWIN_HOST_OS
 #ifndef GFAPI_PUBLIC
@@ -78,232 +81,411 @@
 #ifndef GFAPI_PRIVATE
 #define GFAPI_PRIVATE(sym, ver) /**/
 #endif
-#define GFAPI_SYMVER_PUBLIC_DEFAULT(fn, ver) \
-        asm(".symver pub_"STR(fn)", "STR(fn)"@@GFAPI_"STR(ver))
+#if __GNUC__ >= 10
+#define GFAPI_SYMVER_PUBLIC_DEFAULT(fn, ver)                                   \
+    __attribute__((__symver__(STR(fn) "@@GFAPI_" STR(ver))))
+
+#define GFAPI_SYMVER_PRIVATE_DEFAULT(fn, ver)                                  \
+    __attribute__((__symver__(STR(fn) "@@GFAPI_PRIVATE_" STR(ver))))
+
+#define GFAPI_SYMVER_PUBLIC(fn1, fn2, ver)                                     \
+    __attribute__((__symver__(STR(fn2) "@GFAPI_" STR(ver))))
 
-#define GFAPI_SYMVER_PRIVATE_DEFAULT(fn, ver) \
-        asm(".symver priv_"STR(fn)", "STR(fn)"@@GFAPI_PRIVATE_"STR(ver))
+#define GFAPI_SYMVER_PRIVATE(fn1, fn2, ver)                                    \
+    __attribute__((__symver__(STR(fn2) "@GFAPI_PRIVATE_" STR(ver))))
 
-#define GFAPI_SYMVER_PUBLIC(fn1, fn2, ver) \
-        asm(".symver pub_"STR(fn1)", "STR(fn2)"@GFAPI_"STR(ver))
+#else
+#define GFAPI_SYMVER_PUBLIC_DEFAULT(fn, ver)                                   \
+    asm(".symver pub_" STR(fn) ", " STR(fn) "@@GFAPI_" STR(ver));
+
+#define GFAPI_SYMVER_PRIVATE_DEFAULT(fn, ver)                                  \
+    asm(".symver priv_" STR(fn) ", " STR(fn) "@@GFAPI_PRIVATE_" STR(ver));
 
-#define GFAPI_SYMVER_PRIVATE(fn1, fn2, ver) \
-        asm(".symver priv_"STR(fn1)", "STR(fn2)"@GFAPI_PRIVATE_"STR(ver))
+#define GFAPI_SYMVER_PUBLIC(fn1, fn2, ver)                                     \
+    asm(".symver pub_" STR(fn1) ", " STR(fn2) "@GFAPI_" STR(ver));
+
+#define GFAPI_SYMVER_PRIVATE(fn1, fn2, ver)                                    \
+    asm(".symver priv_" STR(fn1) ", " STR(fn2) "@GFAPI_PRIVATE_" STR(ver));
+#endif
 #define STR(str) #str
 #else
 #ifndef GFAPI_PUBLIC
-#define GFAPI_PUBLIC(sym, ver) __asm("_" __STRING(sym) "$GFAPI_" __STRING(ver))
+#define GFAPI_PUBLIC(sym, ver) __asm("_" __STRING(sym) "$GFAPI_" __STRING(ver));
 #endif
 #ifndef GFAPI_PRIVATE
-#define GFAPI_PRIVATE(sym, ver) __asm("_" __STRING(sym) "$GFAPI_PRIVATE_" __STRING(ver))
+#define GFAPI_PRIVATE(sym, ver)                                                \
+    __asm("_" __STRING(sym) "$GFAPI_PRIVATE_" __STRING(ver));
 #endif
-#define GFAPI_SYMVER_PUBLIC_DEFAULT(fn, dotver) /**/
+#define GFAPI_SYMVER_PUBLIC_DEFAULT(fn, dotver)  /**/
 #define GFAPI_SYMVER_PRIVATE_DEFAULT(fn, dotver) /**/
-#define GFAPI_SYMVER_PUBLIC(fn1, fn2, dotver) /**/
-#define GFAPI_SYMVER_PRIVATE(fn1, fn2, dotver) /**/
+#define GFAPI_SYMVER_PUBLIC(fn1, fn2, dotver)    /**/
+#define GFAPI_SYMVER_PRIVATE(fn1, fn2, dotver)   /**/
 #endif
 
-#define ESTALE_RETRY(ret,errno,reval,loc,label) do {	\
-	if (ret == -1 && errno == ESTALE) {	        \
-		if (reval < DEFAULT_REVAL_COUNT) {	\
-			reval++;			\
-			loc_wipe (loc);			\
-			goto label;			\
-		}					\
-	}						\
-	} while (0)
-
-#define GLFS_LOC_FILL_INODE(oinode, loc, label) do {   \
-	loc.inode = inode_ref (oinode);                \
-	gf_uuid_copy (loc.gfid, oinode->gfid);         \
-	ret = glfs_loc_touchup (&loc);                 \
-	if (ret != 0) {                                \
-		errno = EINVAL;                        \
-		goto label;                            \
-	}                                              \
-	} while (0)
-
-#define GLFS_LOC_FILL_PINODE(pinode, loc, ret, errno, label, path) do {   \
-	loc.inode = inode_new (pinode->table);                            \
-	if (!loc.inode) {                                                 \
-		ret = -1;                                                 \
-		errno = ENOMEM;                                           \
-		goto label;                                               \
-	}                                                                 \
-	loc.parent = inode_ref (pinode);                                  \
-	loc.name = path;                                                  \
-	ret = glfs_loc_touchup (&loc);                                    \
-	if (ret != 0) {                                                   \
-		errno = EINVAL;                                           \
-		goto label;                                               \
-	}                                                                 \
-	} while (0)
+#define ESTALE_RETRY(ret, errno, reval, loc, label)                            \
+    do {                                                                       \
+        if (ret == -1 && errno == ESTALE) {                                    \
+            if (reval < DEFAULT_REVAL_COUNT) {                                 \
+                reval++;                                                       \
+                loc_wipe(loc);                                                 \
+                goto label;                                                    \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define GLFS_LOC_FILL_INODE(oinode, loc, label)                                \
+    do {                                                                       \
+        loc.inode = inode_ref(oinode);                                         \
+        gf_uuid_copy(loc.gfid, oinode->gfid);                                  \
+        ret = glfs_loc_touchup(&loc);                                          \
+        if (ret != 0) {                                                        \
+            errno = EINVAL;                                                    \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GLFS_LOC_FILL_PINODE(pinode, loc, ret, errno, label, path)             \
+    do {                                                                       \
+        loc.inode = inode_new(pinode->table);                                  \
+        if (!loc.inode) {                                                      \
+            ret = -1;                                                          \
+            errno = ENOMEM;                                                    \
+            goto label;                                                        \
+        }                                                                      \
+        loc.parent = inode_ref(pinode);                                        \
+        loc.name = path;                                                       \
+        ret = glfs_loc_touchup(&loc);                                          \
+        if (ret != 0) {                                                        \
+            errno = EINVAL;                                                    \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 struct glfs;
 
 struct _upcall_entry {
-        struct list_head  upcall_list;
-        struct gf_upcall  upcall_data;
+    struct list_head upcall_list;
+    struct gf_upcall upcall_data;
 };
 typedef struct _upcall_entry upcall_entry;
 
-typedef int (*glfs_init_cbk) (struct glfs *fs, int ret);
+typedef int (*glfs_init_cbk)(struct glfs *fs, int ret);
 
 struct glfs {
-	char               *volname;
-        uuid_t              vol_uuid;
-
-	glusterfs_ctx_t    *ctx;
-
-	pthread_t           poller;
-
-	glfs_init_cbk       init_cbk;
-	pthread_mutex_t     mutex;
-	pthread_cond_t      cond;
-        pthread_cond_t      child_down_cond; /* for broadcasting CHILD_DOWN */
-	int                 init;
-	int                 ret;
-	int                 err;
-
-	xlator_t           *active_subvol; /* active graph */
-        xlator_t           *mip_subvol;    /* graph for which migration is in
-                                            * progress */
-	xlator_t           *next_subvol;   /* Any new graph is put to
-                                            * next_subvol, the graph in
-                                            * next_subvol can either be move to
-                                            * mip_subvol (if any IO picks it up
-                                            * for migration), or be detroyed (if
-                                            * there is a new graph, and this was
-                                            * never picked for migration) */
-	xlator_t           *old_subvol;
-
-	char               *oldvolfile;
-	ssize_t             oldvollen;
-
-	inode_t            *cwd;
-
-	uint32_t            dev_id; /* Used to fill st_dev in struct stat */
-
-	struct list_head    openfds;
-
-	gf_boolean_t        migration_in_progress;
-
-        gf_boolean_t        cache_upcalls; /* add upcalls to the upcall_list? */
-        struct list_head    upcall_list;
-        pthread_mutex_t     upcall_list_mutex; /* mutex for upcall entry list */
-
-        uint32_t            pin_refcnt;
-        uint32_t            pthread_flags; /* GLFS_INIT_* # defines set this flag */
+    char *volname;
+    uuid_t vol_uuid;
+
+    glusterfs_ctx_t *ctx;
+
+    pthread_t poller;
+
+    glfs_init_cbk init_cbk;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    pthread_cond_t child_down_cond; /* for broadcasting CHILD_DOWN */
+    int init;
+    int ret;
+    int err;
+
+    xlator_t *active_subvol; /* active graph */
+    xlator_t *mip_subvol;    /* graph for which migration is in
+                              * progress */
+    xlator_t *next_subvol;   /* Any new graph is put to
+                              * next_subvol, the graph in
+                              * next_subvol can either be moved
+                              * to mip_subvol (if any IO picks it
+                              * up for migration), or be
+                              * destroyed (if there is a new
+                              * graph, and this was never picked
+                              * for migration) */
+    xlator_t *old_subvol;
+
+    char *oldvolfile;
+    ssize_t oldvollen;
+
+    inode_t *cwd;
+
+    uint32_t dev_id; /* Used to fill st_dev in struct stat */
+
+    struct list_head openfds;
+
+    gf_boolean_t migration_in_progress;
+
+    gf_boolean_t cache_upcalls; /* add upcalls to the upcall_list? */
+    struct list_head upcall_list;
+    pthread_mutex_t upcall_list_mutex; /* mutex for upcall entry list */
+
+    uint32_t pin_refcnt;
+    uint32_t pthread_flags; /* GLFS_INIT_* # defines set this flag */
+
+    uint32_t upcall_events; /* Mask of upcall events application
+                             * is interested in */
+    glfs_upcall_cbk up_cbk; /* upcall cbk function to be registered */
+    void *up_data;          /* Opaque data provided by application
+                             * during upcall registration */
+    struct list_head waitq; /* waiting synctasks */
 };
 
 /* This enum is used to maintain the state of glfd. In case of async fops
  * fd might be closed before the actual fop is complete. Therefore we need
  * to track whether the fd is closed or not, instead actually closing it.*/
-enum glfs_fd_state {
-        GLFD_INIT,
-        GLFD_OPEN,
-        GLFD_CLOSE
-};
+enum glfs_fd_state { GLFD_INIT, GLFD_OPEN, GLFD_CLOSE };
 
 struct glfs_fd {
-	struct list_head   openfds;
-        GF_REF_DECL;
-	struct glfs       *fs;
-        enum glfs_fd_state state;
-	off_t              offset;
-	fd_t              *fd; /* Currently guared by @fs->mutex. TODO: per-glfd lock */
-	struct list_head   entries;
-	gf_dirent_t       *next;
-	struct dirent     *readdirbuf;
-        gf_lkowner_t       lk_owner;
+    struct list_head openfds;
+    struct list_head list;
+    GF_REF_DECL;
+    struct glfs *fs;
+    enum glfs_fd_state state;
+    off_t offset;
+    fd_t *fd; /* Currently guared by @fs->mutex. TODO: per-glfd lock */
+    struct list_head entries;
+    gf_dirent_t *next;
+    struct dirent *readdirbuf;
+    gf_lkowner_t lk_owner;
+    glfs_leaseid_t lease_id; /* Stores lease_id of client in glfd */
+    gf_lock_t lock;          /* lock taken before updating fd state */
+    glfs_recall_cbk cbk;
+    void *cookie;
 };
 
 /* glfs object handle introduced for the alternate gfapi implementation based
    on glfs handles/gfid/inode
 */
 struct glfs_object {
-        inode_t         *inode;
-        uuid_t          gfid;
+    inode_t *inode;
+    uuid_t gfid;
 };
 
 struct glfs_upcall {
-        struct glfs             *fs;     /* glfs object */
-        enum glfs_upcall_reason  reason; /* Upcall event type */
-        void                    *event;  /* changes based in the event type */
-        void (*free_event)(void *);      /* free event after the usage */
+    struct glfs *fs;                /* glfs object */
+    enum glfs_upcall_reason reason; /* Upcall event type */
+    void *event;                    /* changes based in the event type */
+    void (*free_event)(void *);     /* free event after the usage */
 };
 
 struct glfs_upcall_inode {
-        struct glfs_object   *object;  /* Object which need to be acted upon */
-        int                   flags;   /* Cache UPDATE/INVALIDATE flags */
-        struct stat           buf;     /* Latest stat of this entry */
-        unsigned int          expire_time_attr; /* the amount of time for which
-                                                 * the application need to cache
-                                                 * this entry */
-        struct glfs_object   *p_object; /* parent Object to be updated */
-        struct stat           p_buf;    /* Latest stat of parent dir handle */
-        struct glfs_object   *oldp_object; /* Old parent Object to be updated */
-        struct stat           oldp_buf; /* Latest stat of old parent dir handle */
+    struct glfs_object *object;      /* Object which need to be acted upon */
+    int flags;                       /* Cache UPDATE/INVALIDATE flags */
+    struct stat buf;                 /* Latest stat of this entry */
+    unsigned int expire_time_attr;   /* the amount of time for which
+                                      * the application need to cache
+                                      * this entry */
+    struct glfs_object *p_object;    /* parent Object to be updated */
+    struct stat p_buf;               /* Latest stat of parent dir handle */
+    struct glfs_object *oldp_object; /* Old parent Object to be updated */
+    struct stat oldp_buf;            /* Latest stat of old parent dir handle */
+};
+
+struct glfs_upcall_lease {
+    struct glfs_object *object; /* Object which need to be acted upon */
+    uint32_t lease_type;        /* Lease type to which client can downgrade to*/
+};
+
+struct glfs_upcall_lease_fd {
+    uint32_t lease_type; /* Lease type to which client can downgrade to*/
+    void *fd_cookie;     /* Object which need to be acted upon */
 };
 
 struct glfs_xreaddirp_stat {
-        struct stat st; /* Stat for that dirent - corresponds to GFAPI_XREADDIRP_STAT */
-        struct glfs_object *object; /* handled for GFAPI_XREADDIRP_HANDLE */
-        uint32_t flags_handled; /* final set of flags successfulyy handled */
+    struct stat
+        st; /* Stat for that dirent - corresponds to GFAPI_XREADDIRP_STAT */
+    struct glfs_object *object; /* handled for GFAPI_XREADDIRP_HANDLE */
+    uint32_t flags_handled;     /* final set of flags successfulyy handled */
 };
 
-#define DEFAULT_EVENT_POOL_SIZE           16384
-#define GF_MEMPOOL_COUNT_OF_DICT_T        4096
-#define GF_MEMPOOL_COUNT_OF_DATA_T        (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
-#define GF_MEMPOOL_COUNT_OF_DATA_PAIR_T   (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
-
-#define GF_MEMPOOL_COUNT_OF_LRU_BUF_T     256
-
-int glfs_mgmt_init (struct glfs *fs);
-void glfs_init_done (struct glfs *fs, int ret)
-        GFAPI_PRIVATE(glfs_init_done, 3.4.0);
-int glfs_process_volfp (struct glfs *fs, FILE *fp);
-int glfs_resolve (struct glfs *fs, xlator_t *subvol, const char *path,
-                       loc_t *loc, struct iatt *iatt, int reval)
-        GFAPI_PRIVATE(glfs_resolve, 3.7.0);
-int glfs_lresolve (struct glfs *fs, xlator_t *subvol, const char *path, loc_t *loc,
-		   struct iatt *iatt, int reval);
-fd_t *glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd);
-
-fd_t *__glfs_migrate_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd);
-
-int glfs_first_lookup (xlator_t *subvol);
-
-void glfs_process_upcall_event (struct glfs *fs, void *data)
-        GFAPI_PRIVATE(glfs_process_upcall_event, 3.7.0);
-
-
-#define __GLFS_ENTRY_VALIDATE_FS(fs, label)                         \
-do {                                                                \
-        if (!fs) {                                                  \
-                errno = EINVAL;                                     \
-                goto label;                                         \
-        }                                                           \
-        old_THIS = THIS;                                            \
-        THIS = fs->ctx->master;                                     \
-} while (0)
-
-#define __GLFS_EXIT_FS                                              \
-do {                                                                \
-        THIS = old_THIS;                                            \
-} while (0)
-
-#define __GLFS_ENTRY_VALIDATE_FD(glfd, label)                       \
-do {                                                                \
-        if (!glfd || !glfd->fd || !glfd->fd->inode ||               \
-             glfd->state != GLFD_OPEN) {                           \
-                errno = EBADF;                                      \
-                goto label;                                         \
-        }                                                           \
-        old_THIS = THIS;                                            \
-        THIS = glfd->fd->inode->table->xl->ctx->master;             \
-} while (0)
+#define DEFAULT_EVENT_POOL_SIZE 16384
+#define GF_MEMPOOL_COUNT_OF_DICT_T 4096
+#define GF_MEMPOOL_COUNT_OF_DATA_T (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
+#define GF_MEMPOOL_COUNT_OF_DATA_PAIR_T (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
+
+#define GF_MEMPOOL_COUNT_OF_LRU_BUF_T 256
+
+typedef void(glfs_mem_release_t)(void *ptr);
+
+struct glfs_mem_header {
+    uint32_t magic;
+    size_t nmemb;
+    size_t size;
+    glfs_mem_release_t *release;
+};
+
+#define GLFS_MEM_HEADER_SIZE (sizeof(struct glfs_mem_header))
+#define GLFS_MEM_HEADER_MAGIC 0x20170830
+
+static inline void *
+__glfs_calloc(size_t nmemb, size_t size, glfs_mem_release_t release,
+              uint32_t type, const char *typestr)
+{
+    struct glfs_mem_header *header = NULL;
+
+    header = __gf_calloc(nmemb, (size + GLFS_MEM_HEADER_SIZE), type, typestr);
+    if (!header)
+        return NULL;
+
+    header->magic = GLFS_MEM_HEADER_MAGIC;
+    header->nmemb = nmemb;
+    header->size = size;
+    header->release = release;
+
+    return header + 1;
+}
+
+static inline void *
+__glfs_malloc(size_t size, glfs_mem_release_t release, uint32_t type,
+              const char *typestr)
+{
+    struct glfs_mem_header *header = NULL;
+
+    header = __gf_malloc((size + GLFS_MEM_HEADER_SIZE), type, typestr);
+    if (!header)
+        return NULL;
+
+    header->magic = GLFS_MEM_HEADER_MAGIC;
+    header->nmemb = 1;
+    header->size = size;
+    header->release = release;
+
+    return header + 1;
+}
+
+static inline void *
+__glfs_realloc(void *ptr, size_t size)
+{
+    struct glfs_mem_header *old_header = NULL;
+    struct glfs_mem_header *new_header = NULL;
+    struct glfs_mem_header tmp_header;
+    void *new_ptr = NULL;
+
+    GF_ASSERT(NULL != ptr);
+
+    old_header = (struct glfs_mem_header *)(ptr - GLFS_MEM_HEADER_SIZE);
+    GF_ASSERT(old_header->magic == GLFS_MEM_HEADER_MAGIC);
+    tmp_header = *old_header;
+
+    new_ptr = __gf_realloc(old_header, (size + GLFS_MEM_HEADER_SIZE));
+    if (!new_ptr)
+        return NULL;
+
+    new_header = (struct glfs_mem_header *)new_ptr;
+    *new_header = tmp_header;
+    new_header->size = size;
+
+    return new_header + 1;
+}
+
+static inline void
+__glfs_free(void *free_ptr)
+{
+    struct glfs_mem_header *header = NULL;
+    void *release_ptr = NULL;
+    int i = 0;
+
+    if (!free_ptr)
+        return;
+
+    header = (struct glfs_mem_header *)(free_ptr - GLFS_MEM_HEADER_SIZE);
+    GF_ASSERT(header->magic == GLFS_MEM_HEADER_MAGIC);
+
+    if (header->release) {
+        release_ptr = free_ptr;
+        for (i = 0; i < header->nmemb; i++) {
+            header->release(release_ptr);
+            release_ptr += header->size;
+        }
+    }
+
+    __gf_free(header);
+}
+
+#define GLFS_CALLOC(nmemb, size, release, type)                                \
+    __glfs_calloc(nmemb, size, release, type, #type)
+
+#define GLFS_MALLOC(size, release, type)                                       \
+    __glfs_malloc(size, release, type, #type)
+
+#define GLFS_REALLOC(ptr, size) __glfs_realloc(ptr, size)
+
+#define GLFS_FREE(free_ptr) __glfs_free(free_ptr)
+
+int
+glfs_mgmt_init(struct glfs *fs);
+void
+glfs_init_done(struct glfs *fs, int ret) GFAPI_PRIVATE(glfs_init_done, 3.4.0);
+int
+glfs_process_volfp(struct glfs *fs, FILE *fp);
+int
+glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *path, loc_t *loc,
+             struct iatt *iatt, int reval) GFAPI_PRIVATE(glfs_resolve, 3.7.0);
+int
+glfs_lresolve(struct glfs *fs, xlator_t *subvol, const char *path, loc_t *loc,
+              struct iatt *iatt, int reval);
+fd_t *
+glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd);
+
+fd_t *
+__glfs_migrate_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd);
+
+int
+glfs_first_lookup(xlator_t *subvol);
 
+void
+glfs_process_upcall_event(struct glfs *fs, void *data)
+    GFAPI_PRIVATE(glfs_process_upcall_event, 3.7.0);
+
+#define __GLFS_ENTRY_VALIDATE_FS(fs, label)                                    \
+    do {                                                                       \
+        if (!fs) {                                                             \
+            errno = EINVAL;                                                    \
+            goto label;                                                        \
+        }                                                                      \
+        old_THIS = THIS;                                                       \
+        THIS = fs->ctx->master;                                                \
+    } while (0)
+
+#define __GLFS_EXIT_FS                                                         \
+    do {                                                                       \
+        THIS = old_THIS;                                                       \
+    } while (0)
+
+#define __GLFS_ENTRY_VALIDATE_FD(glfd, label)                                  \
+    do {                                                                       \
+        if (!glfd || !glfd->fd || !glfd->fd->inode ||                          \
+            glfd->state != GLFD_OPEN) {                                        \
+            errno = EBADF;                                                     \
+            goto label;                                                        \
+        }                                                                      \
+        old_THIS = THIS;                                                       \
+        THIS = glfd->fd->inode->table->xl->ctx->master;                        \
+    } while (0)
+
+#define __GLFS_LOCK_WAIT(fs)                                                   \
+    do {                                                                       \
+        struct synctask *task = NULL;                                          \
+                                                                               \
+        task = synctask_get();                                                 \
+                                                                               \
+        if (task) {                                                            \
+            list_add_tail(&task->waitq, &fs->waitq);                           \
+            pthread_mutex_unlock(&fs->mutex);                                  \
+            synctask_yield(task, NULL);                                        \
+            pthread_mutex_lock(&fs->mutex);                                    \
+        } else {                                                               \
+            /* non-synctask */                                                 \
+            pthread_cond_wait(&fs->cond, &fs->mutex);                          \
+        }                                                                      \
+    } while (0)
+
+#define __GLFS_SYNCTASK_WAKE(fs)                                               \
+    do {                                                                       \
+        struct synctask *waittask = NULL;                                      \
+                                                                               \
+        while (!list_empty(&fs->waitq)) {                                      \
+            waittask = list_entry(fs->waitq.next, struct synctask, waitq);     \
+            list_del_init(&waittask->waitq);                                   \
+            synctask_wake(waittask);                                           \
+        }                                                                      \
+    } while (0)
 
 /*
   By default all lock attempts from user context must
@@ -324,61 +506,81 @@ do {                                                                \
   rpc replies.
 */
 static inline int
-glfs_lock (struct glfs *fs, gf_boolean_t wait_for_migration)
+glfs_lock(struct glfs *fs, gf_boolean_t wait_for_migration)
 {
-	pthread_mutex_lock (&fs->mutex);
+    pthread_mutex_lock(&fs->mutex);
 
-	while (!fs->init)
-		pthread_cond_wait (&fs->cond, &fs->mutex);
+    while (!fs->init)
+        __GLFS_LOCK_WAIT(fs);
 
-        while (wait_for_migration && fs->migration_in_progress)
-		pthread_cond_wait (&fs->cond, &fs->mutex);
+    while (wait_for_migration && fs->migration_in_progress)
+        __GLFS_LOCK_WAIT(fs);
 
-	return 0;
+    return 0;
 }
 
-
 static inline void
-glfs_unlock (struct glfs *fs)
+glfs_unlock(struct glfs *fs)
 {
-	pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_unlock(&fs->mutex);
 }
 
-struct glfs_fd *glfs_fd_new (struct glfs *fs);
-void glfs_fd_bind (struct glfs_fd *glfd);
-
-xlator_t *glfs_active_subvol (struct glfs *fs)
-        GFAPI_PRIVATE(glfs_active_subvol, 3.4.0);
-xlator_t *__glfs_active_subvol (struct glfs *fs);
-void glfs_subvol_done (struct glfs *fs, xlator_t *subvol)
-        GFAPI_PRIVATE(glfs_subvol_done, 3.4.0);
-
-inode_t *glfs_refresh_inode (xlator_t *subvol, inode_t *inode);
-
-inode_t *glfs_cwd_get (struct glfs *fs);
-int glfs_cwd_set (struct glfs *fs, inode_t *inode);
-inode_t *glfs_resolve_inode (struct glfs *fs, xlator_t *subvol,
-			     struct glfs_object *object);
-int glfs_create_object (loc_t *loc, struct glfs_object **retobject);
-int __glfs_cwd_set (struct glfs *fs, inode_t *inode);
-
-int glfs_resolve_base (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-		       struct iatt *iatt);
-
-int glfs_resolve_at (struct glfs *fs, xlator_t *subvol, inode_t *at,
-                          const char *origpath, loc_t *loc, struct iatt *iatt,
-                          int follow, int reval)
-        GFAPI_PRIVATE(glfs_resolve_at, 3.4.0);
-int glfs_loc_touchup (loc_t *loc)
-	GFAPI_PRIVATE(glfs_loc_touchup, 3.4.0);
-void glfs_iatt_to_stat (struct glfs *fs, struct iatt *iatt, struct stat *stat);
-int glfs_loc_link (loc_t *loc, struct iatt *iatt);
-int glfs_loc_unlink (loc_t *loc);
-int glfs_getxattr_process (void *value, size_t size, dict_t *xattr,
-			   const char *name);
+struct glfs_fd *
+glfs_fd_new(struct glfs *fs);
+void
+glfs_fd_bind(struct glfs_fd *glfd);
+void
+glfd_set_state_bind(struct glfs_fd *glfd);
+
+xlator_t *
+glfs_active_subvol(struct glfs *fs) GFAPI_PRIVATE(glfs_active_subvol, 3.4.0);
+xlator_t *
+__glfs_active_subvol(struct glfs *fs);
+void
+glfs_subvol_done(struct glfs *fs, xlator_t *subvol)
+    GFAPI_PRIVATE(glfs_subvol_done, 3.4.0);
+
+inode_t *
+glfs_refresh_inode(xlator_t *subvol, inode_t *inode);
+
+inode_t *
+glfs_cwd_get(struct glfs *fs);
+int
+glfs_cwd_set(struct glfs *fs, inode_t *inode);
+inode_t *
+glfs_resolve_inode(struct glfs *fs, xlator_t *subvol,
+                   struct glfs_object *object);
+int
+glfs_create_object(loc_t *loc, struct glfs_object **retobject);
+int
+__glfs_cwd_set(struct glfs *fs, inode_t *inode);
+
+int
+glfs_resolve_base(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                  struct iatt *iatt);
+
+int
+glfs_resolve_at(struct glfs *fs, xlator_t *subvol, inode_t *at,
+                const char *origpath, loc_t *loc, struct iatt *iatt, int follow,
+                int reval) GFAPI_PRIVATE(glfs_resolve_at, 3.4.0);
+int
+glfs_loc_touchup(loc_t *loc) GFAPI_PRIVATE(glfs_loc_touchup, 3.4.0);
+void
+glfs_iatt_to_stat(struct glfs *fs, struct iatt *iatt, struct stat *stat);
+void
+glfs_iatt_from_stat(struct stat *stat, int valid, struct iatt *iatt,
+                    int *gvalid);
+int
+glfs_loc_link(loc_t *loc, struct iatt *iatt);
+int
+glfs_loc_unlink(loc_t *loc);
+int
+glfs_getxattr_process(void *value, size_t size, dict_t *xattr,
+                      const char *name);
 
 /* Sends RPC call to glusterd to fetch required volume info */
-int glfs_get_volume_info (struct glfs *fs);
+int
+glfs_get_volume_info(struct glfs *fs);
 
 /*
   SYNOPSIS
@@ -404,8 +606,8 @@ int glfs_get_volume_info (struct glfs *fs);
        NULL   : Otherwise.
 */
 
-struct glfs *glfs_new_from_ctx (glusterfs_ctx_t *ctx)
-        GFAPI_PRIVATE(glfs_new_from_ctx, 3.7.0);
+struct glfs *
+glfs_new_from_ctx(glusterfs_ctx_t *ctx) GFAPI_PRIVATE(glfs_new_from_ctx, 3.7.0);
 
 /*
   SYNOPSIS
@@ -430,27 +632,30 @@ struct glfs *glfs_new_from_ctx (glusterfs_ctx_t *ctx)
        void
 */
 
-void glfs_free_from_ctx (struct glfs *fs)
-         GFAPI_PRIVATE(glfs_free_from_ctx, 3.7.0);
+void
+glfs_free_from_ctx(struct glfs *fs) GFAPI_PRIVATE(glfs_free_from_ctx, 3.7.0);
+
+int
+glfs_recall_lease_fd(struct glfs *fs, struct gf_upcall *up_data);
 
-int glfs_get_upcall_cache_invalidation (struct gf_upcall *to_up_data,
-                                        struct gf_upcall *from_up_data);
 int
-glfs_h_poll_cache_invalidation (struct glfs *fs,
-                                struct glfs_upcall *up_arg,
-                                struct gf_upcall *upcall_data);
+glfs_get_upcall_cache_invalidation(struct gf_upcall *to_up_data,
+                                   struct gf_upcall *from_up_data);
+int
+glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
+                               struct gf_upcall *upcall_data);
 
 ssize_t
-glfs_anonymous_preadv (struct glfs *fs, struct glfs_object *object,
-                       const struct iovec *iovec, int iovcnt,
-                       off_t offset, int flags);
+glfs_anonymous_preadv(struct glfs *fs, struct glfs_object *object,
+                      const struct iovec *iovec, int iovcnt, off_t offset,
+                      int flags);
 ssize_t
-glfs_anonymous_pwritev (struct glfs *fs, struct glfs_object *object,
-                        const struct iovec *iovec, int iovcnt,
-                        off_t offset, int flags);
+glfs_anonymous_pwritev(struct glfs *fs, struct glfs_object *object,
+                       const struct iovec *iovec, int iovcnt, off_t offset,
+                       int flags);
 
 struct glfs_object *
-glfs_h_resolve_symlink (struct glfs *fs, struct glfs_object *object);
+glfs_h_resolve_symlink(struct glfs *fs, struct glfs_object *object);
 
 /* Deprecated structures that were passed to client applications, replaced by
  * accessor functions. Do not use these in new applications, and update older
@@ -461,39 +666,91 @@ glfs_h_resolve_symlink (struct glfs *fs, struct glfs_object *object);
  * WARNING: These structures will be removed in the future.
  */
 struct glfs_callback_arg {
-        struct glfs             *fs;
-        enum glfs_upcall_reason  reason;
-        void                    *event_arg;
+    struct glfs *fs;
+    enum glfs_upcall_reason reason;
+    void *event_arg;
 };
 
 struct glfs_callback_inode_arg {
-        struct glfs_object      *object; /* Object which need to be acted upon */
-        int                     flags; /* Cache UPDATE/INVALIDATE flags */
-        struct stat             buf; /* Latest stat of this entry */
-        unsigned int            expire_time_attr; /* the amount of time for which
-                                                   * the application need to cache
-                                                   * this entry
-                                                   */
-        struct glfs_object      *p_object; /* parent Object to be updated */
-        struct stat             p_buf; /* Latest stat of parent dir handle */
-        struct glfs_object      *oldp_object; /* Old parent Object
-                                               * to be updated */
-        struct stat             oldp_buf; /* Latest stat of old parent
-                                           * dir handle */
+    struct glfs_object *object;      /* Object which need to be acted upon */
+    int flags;                       /* Cache UPDATE/INVALIDATE flags */
+    struct stat buf;                 /* Latest stat of this entry */
+    unsigned int expire_time_attr;   /* the amount of time for which
+                                      * the application need to cache
+                                      * this entry
+                                      */
+    struct glfs_object *p_object;    /* parent Object to be updated */
+    struct stat p_buf;               /* Latest stat of parent dir handle */
+    struct glfs_object *oldp_object; /* Old parent Object
+                                      * to be updated */
+    struct stat oldp_buf;            /* Latest stat of old parent
+                                      * dir handle */
 };
 struct dirent *
-glfs_readdirbuf_get (struct glfs_fd *glfd);
+glfs_readdirbuf_get(struct glfs_fd *glfd);
 
 gf_dirent_t *
-glfd_entry_next (struct glfs_fd *glfd, int plus);
+glfd_entry_next(struct glfs_fd *glfd, int plus);
+
+void
+gf_dirent_to_dirent(gf_dirent_t *gf_dirent, struct dirent *dirent);
+
+void
+gf_lease_to_glfs_lease(struct gf_lease *gf_lease, struct glfs_lease *lease);
+
+void
+glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease);
 
 void
-gf_dirent_to_dirent (gf_dirent_t *gf_dirent, struct dirent *dirent);
+glfs_release_upcall(void *ptr);
+
+int
+get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd);
+
+int
+set_fop_attr_glfd(struct glfs_fd *glfd);
+
+int
+get_fop_attr_thrd_key(dict_t **fop_attr);
+
+void
+unset_fop_attr(dict_t **fop_attr);
 
 /*
- * Nobody needs this call at all yet except for the test script.
+  SYNOPSIS
+  glfs_statx: Fetch extended file attributes for the given path.
+
+  DESCRIPTION
+  This function fetches extended file attributes for the given path.
+
+  PARAMETERS
+  @fs: The 'virtual mount' object referencing a volume, under which file exists.
+  @path: Path of the file within the virtual mount.
+  @mask: Requested extended file attributes mask, (See mask defines above)
+
+  RETURN VALUES
+  -1 : Failure. @errno will be set with the type of failure.
+  0  : Filled in statxbuf with appropriate masks for valid items in the
+       structure.
+
+  ERRNO VALUES
+    EINVAL: fs is invalid
+    EINVAL: mask has unsupported bits set
+    Other errors as returned by stat(2)
  */
-int glfs_ipc (glfs_fd_t *fd, int cmd,  void *xd_in, void **xd_out) __THROW
-        GFAPI_PRIVATE(glfs_ipc, 3.12.0);
 
+int
+glfs_statx(struct glfs *fs, const char *path, unsigned int mask,
+           struct glfs_stat *statxbuf) GFAPI_PRIVATE(glfs_statx, 6.0);
+
+void
+glfs_iatt_from_statx(struct iatt *, const struct glfs_stat *)
+    GFAPI_PRIVATE(glfs_iatt_from_statx, 6.0);
+
+/*
+ * This API is a per thread setting, similar to glfs_setfs{u/g}id, because of
+ * the call to syncopctx_setfspid.
+ */
+int
+glfs_setfspid(struct glfs *, pid_t) GFAPI_PRIVATE(glfs_setfspid, 6.1);
 #endif /* !_GLFS_INTERNAL_H */
diff --git a/api/src/glfs-master.c b/api/src/glfs-master.c
index 00a9c929a04..100dcc16cc0 100644
--- a/api/src/glfs-master.c
+++ b/api/src/glfs-master.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2016 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,180 +8,176 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <unistd.h>
-#include <string.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <inttypes.h>
-#include <limits.h>
 
-#include "xlator.h"
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 
 #include "glfs-internal.h"
 #include "glfs-mem-types.h"
 #include "gfapi-messages.h"
 
-
 int
-graph_setup (struct glfs *fs, glusterfs_graph_t *graph)
+graph_setup(struct glfs *fs, glusterfs_graph_t *graph)
 {
-	xlator_t      *new_subvol = NULL;
-	xlator_t      *old_subvol = NULL;
-	inode_table_t *itable = NULL;
-	int            ret = -1;
-
-	new_subvol = graph->top;
-
-	/* This is called in a bottom-up context, it should specifically
-	   NOT be glfs_lock()
-	*/
-	pthread_mutex_lock (&fs->mutex);
-	{
-		if (new_subvol->switched ||
-		    new_subvol == fs->active_subvol ||
-		    new_subvol == fs->next_subvol ||
-                    new_subvol == fs->mip_subvol) {
-			/* Spurious CHILD_UP event on old graph */
-			ret = 0;
-			goto unlock;
-		}
-
-		if (!new_subvol->itable) {
-			itable = inode_table_new (131072, new_subvol);
-			if (!itable) {
-				errno = ENOMEM;
-				ret = -1;
-				goto unlock;
-			}
-
-			new_subvol->itable = itable;
-		}
-
-		old_subvol = fs->next_subvol;
-		fs->next_subvol = new_subvol;
-		fs->next_subvol->winds++; /* first ref */
-		ret = 0;
-	}
+    xlator_t *new_subvol = NULL;
+    xlator_t *old_subvol = NULL;
+    inode_table_t *itable = NULL;
+    int ret = -1;
+
+    new_subvol = graph->top;
+
+    /* This is called in a bottom-up context, it should specifically
+       NOT be glfs_lock()
+    */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        if (new_subvol->switched || new_subvol == fs->active_subvol ||
+            new_subvol == fs->next_subvol || new_subvol == fs->mip_subvol) {
+            /* Spurious CHILD_UP event on old graph */
+            ret = 0;
+            goto unlock;
+        }
+
+        if (!new_subvol->itable) {
+            itable = inode_table_new(131072, new_subvol);
+            if (!itable) {
+                errno = ENOMEM;
+                ret = -1;
+                goto unlock;
+            }
+
+            new_subvol->itable = itable;
+        }
+
+        old_subvol = fs->next_subvol;
+        fs->next_subvol = new_subvol;
+        fs->next_subvol->winds++; /* first ref */
+        ret = 0;
+    }
 unlock:
-	pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_unlock(&fs->mutex);
 
-	if (old_subvol)
-		/* wasn't picked up so far, skip */
-		glfs_subvol_done (fs, old_subvol);
+    if (old_subvol)
+        /* wasn't picked up so far, skip */
+        glfs_subvol_done(fs, old_subvol);
 
-	return ret;
+    return ret;
 }
 
-
 int
-notify (xlator_t *this, int event, void *data, ...)
+notify(xlator_t *this, int event, void *data, ...)
 {
-	glusterfs_graph_t   *graph = NULL;
-	struct glfs	    *fs = NULL;
-
-	graph = data;
-	fs = this->private;
-
-	switch (event) {
-	case GF_EVENT_GRAPH_NEW:
-		gf_msg (this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
-                        "New graph %s (%d) coming up",
-			uuid_utoa ((unsigned char *)graph->graph_uuid),
-			graph->id);
-		break;
-	case GF_EVENT_CHILD_UP:
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        graph->used = 1;
-                }
-                pthread_mutex_unlock (&fs->mutex);
-		graph_setup (fs, graph);
-		glfs_init_done (fs, 0);
-		break;
-	case GF_EVENT_CHILD_DOWN:
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        graph->used = 0;
-                        pthread_cond_broadcast (&fs->child_down_cond);
-                }
-                pthread_mutex_unlock (&fs->mutex);
-		glfs_init_done (fs, 1);
-		break;
-	case GF_EVENT_CHILD_CONNECTING:
-		break;
+    glusterfs_graph_t *graph = NULL;
+    struct glfs *fs = NULL;
+
+    graph = data;
+    fs = this->private;
+
+    switch (event) {
+        case GF_EVENT_GRAPH_NEW:
+            gf_smsg(this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
+                    "graph-uuid=%s",
+                    uuid_utoa((unsigned char *)graph->graph_uuid), "id=%d",
+                    graph->id, NULL);
+            break;
+        case GF_EVENT_CHILD_UP:
+            pthread_mutex_lock(&fs->mutex);
+            {
+                graph->used = 1;
+            }
+            pthread_mutex_unlock(&fs->mutex);
+            graph_setup(fs, graph);
+            glfs_init_done(fs, 0);
+            break;
+        case GF_EVENT_CHILD_DOWN:
+            pthread_mutex_lock(&fs->mutex);
+            {
+                graph->used = 0;
+                pthread_cond_broadcast(&fs->child_down_cond);
+            }
+            pthread_mutex_unlock(&fs->mutex);
+            glfs_init_done(fs, 1);
+            break;
+        case GF_EVENT_CHILD_CONNECTING:
+            break;
         case GF_EVENT_UPCALL:
-                glfs_process_upcall_event (fs, data);
-                break;
-	default:
-		gf_msg_debug (this->name, 0, "got notify event %d", event);
-		break;
-	}
-
-	return 0;
+            glfs_process_upcall_event(fs, data);
+            break;
+        default:
+            gf_msg_debug(this->name, 0, "got notify event %d", event);
+            break;
+    }
+
+    return 0;
 }
 
-
 int
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (!this)
-		return ret;
+    if (!this)
+        return ret;
 
-	ret = xlator_mem_acct_init (this, glfs_mt_end + 1);
-	if (ret) {
-		gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        API_MSG_MEM_ACCT_INIT_FAILED, "Failed to initialise "
-                        "memory accounting");
-		return ret;
-	}
+    ret = xlator_mem_acct_init(this, glfs_mt_end + 1);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+                NULL);
+        return ret;
+    }
 
-	return 0;
+    return 0;
 }
 
-
 int
-init (xlator_t *this)
+init(xlator_t *this)
 {
-	return 0;
+    return 0;
 }
 
-
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-
 }
 
 /* place-holder fops */
 int
-glfs_forget (xlator_t *this, inode_t *inode)
+glfs_forget(xlator_t *this, inode_t *inode)
 {
-	return 0;
+    return 0;
 }
 
 int
-glfs_release (xlator_t *this, fd_t *fd)
+glfs_release(xlator_t *this, fd_t *fd)
 {
-	return 0;
+    return 0;
 }
 
 int
-glfs_releasedir (xlator_t *this, fd_t *fd)
+glfs_releasedir(xlator_t *this, fd_t *fd)
 {
-	return 0;
+    return 0;
 }
 
 struct xlator_dumpops dumpops;
 
-
 struct xlator_fops fops;
 
-
 struct xlator_cbks cbks = {
-	.forget	    = glfs_forget,
-	.release    = glfs_release,
-	.releasedir = glfs_releasedir
+    .forget = glfs_forget,
+    .release = glfs_release,
+    .releasedir = glfs_releasedir,
+};
+
+xlator_api_t xlator_api = {
+    .init = init,
+    .fini = fini,
+    .notify = notify,
+    .mem_acct_init = mem_acct_init,
+    .op_version = {1},
+    .dumpops = &dumpops,
+    .fops = &fops,
+    .cbks = &cbks,
+    .identifier = "glfs-api",
+    .category = GF_MAINTAINED,
 };
diff --git a/api/src/glfs-mem-types.h b/api/src/glfs-mem-types.h
index 4179138e65e..bfa325a3ad9 100644
--- a/api/src/glfs-mem-types.h
+++ b/api/src/glfs-mem-types.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2017 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -11,25 +11,25 @@
 #ifndef _GLFS_MEM_TYPES_H
 #define _GLFS_MEM_TYPES_H
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 #define GF_MEM_TYPE_START (gf_common_mt_end + 1)
 
 enum glfs_mem_types_ {
-        glfs_mt_call_pool_t = GF_MEM_TYPE_START,
-        glfs_mt_xlator_t,
-	glfs_mt_glfs_fd_t,
-	glfs_mt_glfs_io_t,
-	glfs_mt_volfile_t,
-	glfs_mt_xlator_cmdline_option_t,
-        glfs_mt_server_cmdline_t,
-	glfs_mt_glfs_object_t,
-	glfs_mt_readdirbuf_t,
-        glfs_mt_upcall_entry_t,
-	glfs_mt_acl_t,
-        glfs_mt_upcall_inode_t,
-        glfs_mt_realpath_t,
-        glfs_mt_xreaddirp_stat_t,
-	glfs_mt_end
+    glfs_mt_call_pool_t = GF_MEM_TYPE_START,
+    glfs_mt_xlator_t,
+    glfs_mt_glfs_fd_t,
+    glfs_mt_glfs_io_t,
+    glfs_mt_volfile_t,
+    glfs_mt_xlator_cmdline_option_t,
+    glfs_mt_server_cmdline_t,
+    glfs_mt_glfs_object_t,
+    glfs_mt_readdirbuf_t,
+    glfs_mt_upcall_entry_t,
+    glfs_mt_acl_t,
+    glfs_mt_upcall_inode_t,
+    glfs_mt_realpath_t,
+    glfs_mt_xreaddirp_stat_t,
+    glfs_mt_end
 };
 #endif
diff --git a/api/src/glfs-mgmt.c b/api/src/glfs-mgmt.c
index 32b9dbd4e31..7c82b8cd162 100644
--- a/api/src/glfs-mgmt.c
+++ b/api/src/glfs-mgmt.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -16,1020 +15,1035 @@
 #include <signal.h>
 #include <pthread.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "glfs.h"
-#include "stack.h"
-#include "dict.h"
-#include "event.h"
-#include "defaults.h"
+#include <glusterfs/dict.h>
 
 #include "rpc-clnt.h"
 #include "protocol-common.h"
-#include "glusterfs3.h"
-#include "portmap-xdr.h"
-#include "xdr-common.h"
 #include "xdr-generic.h"
 #include "rpc-common-xdr.h"
 
-#include "syncop.h"
-#include "xlator.h"
+#include <glusterfs/syncop.h>
 
 #include "glfs-internal.h"
-#include "glfs-mem-types.h"
 #include "gfapi-messages.h"
-#include "syscall.h"
+#include <glusterfs/syscall.h>
 
-int glfs_volfile_fetch (struct glfs *fs);
-int32_t glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
-                                  struct glfs *fs);
+int
+glfs_volfile_fetch(struct glfs *fs);
+int32_t
+glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs);
 
 int
-glfs_process_volfp (struct glfs *fs, FILE *fp)
+glfs_process_volfp(struct glfs *fs, FILE *fp)
 {
-	glusterfs_graph_t  *graph = NULL;
-	int		    ret = -1;
-	xlator_t	   *trav = NULL;
-	glusterfs_ctx_t	   *ctx = NULL;
-
-	ctx = fs->ctx;
-	graph = glusterfs_graph_construct (fp);
-	if (!graph) {
-		gf_msg ("glfs", GF_LOG_ERROR, errno,
-                        API_MSG_GRAPH_CONSTRUCT_FAILED,
-                        "failed to construct the graph");
-		goto out;
-	}
-
-	for (trav = graph->first; trav; trav = trav->next) {
-		if (strcmp (trav->type, "mount/api") == 0) {
-			gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                                API_MSG_API_XLATOR_ERROR,
-				"api master xlator cannot be specified "
-				"in volume file");
-			goto out;
-		}
-	}
-
-	ret = glusterfs_graph_prepare (graph, ctx, fs->volname);
-	if (ret) {
-		glusterfs_graph_destroy (graph);
-		goto out;
-	}
-
-	ret = glusterfs_graph_activate (graph, ctx);
-
-	if (ret) {
-		glusterfs_graph_destroy (graph);
-		goto out;
-	}
-
-        gf_log_dump_graph (fp, graph);
-
-	ret = 0;
+    glusterfs_graph_t *graph = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = fs->ctx;
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_smsg("glfs", GF_LOG_ERROR, errno, API_MSG_GRAPH_CONSTRUCT_FAILED,
+                NULL);
+        goto out;
+    }
+
+    for (trav = graph->first; trav; trav = trav->next) {
+        if (strcmp(trav->type, "mount/api") == 0) {
+            gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_API_XLATOR_ERROR,
+                    NULL);
+            goto out;
+        }
+    }
+
+    ret = glusterfs_graph_prepare(graph, ctx, fs->volname);
+    if (ret) {
+        glusterfs_graph_destroy(graph);
+        goto out;
+    }
+
+    ret = glusterfs_graph_activate(graph, ctx);
+
+    if (ret) {
+        glusterfs_graph_destroy(graph);
+        goto out;
+    }
+
+    gf_log_dump_graph(fp, graph);
+
+    ret = 0;
 out:
-	if (fp)
-		fclose (fp);
+    if (fp)
+        fclose(fp);
 
-	if (!ctx->active) {
-		ret = -1;
-	}
+    if (!ctx->active) {
+        ret = -1;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-	struct glfs *fs = NULL;
-	xlator_t    *this = NULL;
+    struct glfs *fs = NULL;
+    xlator_t *this = NULL;
 
-	this = mydata;
-	fs = this->private;
+    this = mydata;
+    fs = this->private;
 
-	glfs_volfile_fetch (fs);
+    glfs_volfile_fetch(fs);
 
-	return 0;
+    return 0;
 }
 
-
 int
-mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-	return 0;
+    return 0;
 }
 
 static int
-mgmt_cbk_statedump (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_statedump(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        struct glfs      *fs          = NULL;
-        xlator_t         *this        = NULL;
-        gf_statedump      target_pid  = {0, };
-        struct iovec     *iov         = NULL;
-        int               ret         = -1;
-
-        this = mydata;
-        if (!this) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL mydata");
-                errno = EINVAL;
-                goto out;
-        }
-
-        fs = this->private;
-        if (!fs) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL glfs");
-                errno = EINVAL;
-                goto out;
-        }
-
-        iov = (struct iovec *)data;
-        if (!iov) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL iovec data");
-                errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &target_pid,
-                              (xdrproc_t)xdr_gf_statedump);
+    struct glfs *fs = NULL;
+    xlator_t *this = NULL;
+    gf_statedump target_pid = {
+        0,
+    };
+    struct iovec *iov = NULL;
+    int ret = -1;
+
+    this = mydata;
+    if (!this) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "mydata", NULL);
+        errno = EINVAL;
+        goto out;
+    }
+
+    fs = this->private;
+    if (!fs) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "glfs", NULL);
+        errno = EINVAL;
+        goto out;
+    }
+
+    iov = (struct iovec *)data;
+    if (!iov) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "iovec data", NULL);
+        errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &target_pid, (xdrproc_t)xdr_gf_statedump);
+    if (ret < 0) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_DECODE_XDR_FAILED, NULL);
+        goto out;
+    }
+
+    gf_msg_trace("glfs", 0, "statedump requested for pid: %d", target_pid.pid);
+
+    if ((uint64_t)getpid() == target_pid.pid) {
+        gf_msg_debug("glfs", 0, "Taking statedump for pid: %d", target_pid.pid);
+
+        ret = glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
         if (ret < 0) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED,
-                        "Failed to decode xdr response for GF_CBK_STATEDUMP");
-                goto out;
-        }
-
-        gf_msg_trace ("glfs", 0, "statedump requested for pid: %d",
-                      target_pid.pid);
-
-        if ((uint64_t)getpid() == target_pid.pid) {
-                gf_msg_debug ("glfs", 0, "Taking statedump for pid: %d",
-                              target_pid.pid);
-
-                ret = glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP);
-                if (ret < 0) {
-                        gf_msg ("glfs", GF_LOG_INFO, 0,
-                                API_MSG_STATEDUMP_FAILED,
-                                "statedump failed");
-                }
+            gf_smsg("glfs", GF_LOG_INFO, 0, API_MSG_STATEDUMP_FAILED, NULL);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
-	[GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec },
-	[GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
-				 mgmt_cbk_event},
-        [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_statedump},
+static rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
+    [GF_CBK_FETCHSPEC] = {"FETCHSPEC", mgmt_cbk_spec, GF_CBK_FETCHSPEC},
+    [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", mgmt_cbk_event,
+                             GF_CBK_EVENT_NOTIFY},
+    [GF_CBK_STATEDUMP] = {"STATEDUMP", mgmt_cbk_statedump, GF_CBK_STATEDUMP},
 };
 
-
-struct rpcclnt_cb_program mgmt_cbk_prog = {
-	.progname  = "GlusterFS Callback",
-	.prognum   = GLUSTER_CBK_PROGRAM,
-	.progver   = GLUSTER_CBK_VERSION,
-	.actors	   = mgmt_cbk_actors,
-	.numactors = GF_CBK_MAXVALUE,
+static struct rpcclnt_cb_program mgmt_cbk_prog = {
+    .progname = "GlusterFS Callback",
+    .prognum = GLUSTER_CBK_PROGRAM,
+    .progver = GLUSTER_CBK_VERSION,
+    .actors = mgmt_cbk_actors,
+    .numactors = GF_CBK_MAXVALUE,
 };
 
-char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
-	[GF_HNDSK_NULL]		= "NULL",
-	[GF_HNDSK_SETVOLUME]	= "SETVOLUME",
-	[GF_HNDSK_GETSPEC]	= "GETSPEC",
-	[GF_HNDSK_PING]		= "PING",
-	[GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
-        [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO",
+static char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
+    [GF_HNDSK_NULL] = "NULL",
+    [GF_HNDSK_SETVOLUME] = "SETVOLUME",
+    [GF_HNDSK_GETSPEC] = "GETSPEC",
+    [GF_HNDSK_PING] = "PING",
+    [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
+    [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO",
 };
 
-rpc_clnt_prog_t clnt_handshake_prog = {
-	.progname  = "GlusterFS Handshake",
-	.prognum   = GLUSTER_HNDSK_PROGRAM,
-	.progver   = GLUSTER_HNDSK_VERSION,
-	.procnames = clnt_handshake_procs,
+static rpc_clnt_prog_t clnt_handshake_prog = {
+    .progname = "GlusterFS Handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
+    .procnames = clnt_handshake_procs,
 };
 
-
 int
-mgmt_submit_request (void *req, call_frame_t *frame,
-		     glusterfs_ctx_t *ctx,
-		     rpc_clnt_prog_t *prog, int procnum,
-		     fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx,
+                    rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbkfn,
+                    xdrproc_t xdrproc)
 {
-	int			ret	    = -1;
-	int			count	   = 0;
-	struct iovec		iov	    = {0, };
-	struct iobuf		*iobuf = NULL;
-	struct iobref		*iobref = NULL;
-	ssize_t			xdr_size = 0;
-
-	iobref = iobref_new ();
-	if (!iobref) {
-		goto out;
-	}
-
-	if (req) {
-		xdr_size = xdr_sizeof (xdrproc, req);
-
-		iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-		if (!iobuf) {
-			goto out;
-		};
-
-		iobref_add (iobref, iobuf);
-
-		iov.iov_base = iobuf->ptr;
-		iov.iov_len  = iobuf_pagesize (iobuf);
-
-		/* Create the xdr payload */
-		ret = xdr_serialize_generic (iov, req, xdrproc);
-		if (ret == -1) {
-			gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                API_MSG_XDR_PAYLOAD_FAILED,
-				"failed to create XDR payload");
-			goto out;
-		}
-		iov.iov_len = ret;
-		count = 1;
-	}
-
-	/* Send the msg */
-	ret = rpc_clnt_submit (ctx->mgmt, prog, procnum, cbkfn,
-			       &iov, count,
-			       NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+
+        iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_pagesize(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_XDR_PAYLOAD_FAILED,
+                    NULL);
+            goto out;
+        }
+        iov.iov_len = ret;
+        count = 1;
+    }
+
+    /* Send the msg */
+    ret = rpc_clnt_submit(ctx->mgmt, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
 
 out:
-	if (iobref)
-		iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-	if (iobuf)
-		iobuf_unref (iobuf);
-	return ret;
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 /*
  * Callback routine for 'GF_HNDSK_GET_VOLUME_INFO' rpc request
  */
 int
-mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
+mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        int                        ret                  = 0;
-        char                       *volume_id_str       = NULL;
-        dict_t                     *dict                = NULL;
-        char                       key[1024]            = {0};
-        gf_get_volume_info_rsp     rsp                  = {0,};
-        call_frame_t               *frame               = NULL;
-        glusterfs_ctx_t            *ctx                 = NULL;
-        struct glfs                *fs                  = NULL;
-        struct syncargs            *args;
-
-        frame = myframe;
-        ctx = frame->this->ctx;
-        args = frame->local;
-
-        if (!ctx) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "NULL context");
-                errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        fs = ((xlator_t *)ctx->master)->private;
-
-        if (-1 == req->rpc_status) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY,
-                        "GET_VOLUME_INFO RPC call is not successful");
-                errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
-
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                        API_MSG_XDR_RESPONSE_DECODE_FAILED,
-                        "Failed to decode xdr response for GET_VOLUME_INFO");
-                goto out;
-        }
-
-        gf_msg_debug (frame->this->name, 0, "Received resp to GET_VOLUME_INFO "
-                      "RPC: %d", rsp.op_ret);
-
-        if (rsp.op_ret == -1) {
-                errno = rsp.op_errno;
-                ret = -1;
-                goto out;
-        }
-
-        if (!rsp.dict.dict_len) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "Response received for "
-                        "GET_VOLUME_INFO RPC call is not valid");
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "volume_id");
-        ret = dict_get_str (dict, key, &volume_id_str);
-        if (ret) {
-                errno = EINVAL;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    char *volume_id_str = NULL;
+    dict_t *dict = NULL;
+    gf_get_volume_info_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    struct glfs *fs = NULL;
+    struct syncargs *args;
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+    args = frame->local;
+
+    if (!ctx) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_NULL,
+                "context", NULL);
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    if (-1 == req->rpc_status) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL,
+                API_MSG_CALL_NOT_SUCCESSFUL, NULL);
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
+
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, 0,
+                API_MSG_XDR_RESPONSE_DECODE_FAILED, NULL);
+        goto out;
+    }
+
+    gf_msg_debug(frame->this->name, 0,
+                 "Received resp to GET_VOLUME_INFO "
+                 "RPC: %d",
+                 rsp.op_ret);
+
+    if (rsp.op_ret == -1) {
+        errno = rsp.op_errno;
+        ret = -1;
+        goto out;
+    }
+
+    if (!rsp.dict.dict_len) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_CALL_NOT_VALID,
+                NULL);
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(dict, "volume_id", &volume_id_str);
+    if (ret) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (volume_id_str) {
-                gf_msg_debug (frame->this->name, 0,
-                              "Volume Id: %s", volume_id_str);
-                pthread_mutex_lock (&fs->mutex);
-                gf_uuid_parse (volume_id_str, fs->vol_uuid);
-                pthread_mutex_unlock (&fs->mutex);
-        }
+    if (volume_id_str) {
+        gf_msg_debug(frame->this->name, 0, "Volume Id: %s", volume_id_str);
+        pthread_mutex_lock(&fs->mutex);
+        gf_uuid_parse(volume_id_str, fs->vol_uuid);
+        pthread_mutex_unlock(&fs->mutex);
+    }
 
-        if (ret) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, errno,
-                        API_MSG_GET_VOLINFO_CBK_FAILED, "In GET_VOLUME_INFO "
-                        "cbk, received error: %s", strerror(errno));
-        }
+    if (ret) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, errno,
+                API_MSG_GET_VOLINFO_CBK_FAILED, "error=%s", strerror(errno),
+                NULL);
+    }
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
+    if (rsp.dict.dict_val)
+        free(rsp.dict.dict_val);
 
-        if (rsp.op_errstr)
-                free (rsp.op_errstr);
+    if (rsp.op_errstr)
+        free(rsp.op_errstr);
 
-        gf_msg_debug (frame->this->name, 0, "Returning: %d", ret);
+    gf_msg_debug(frame->this->name, 0, "Returning: %d", ret);
 
-        __wake (args);
+    __wake(args);
 
-        return ret;
+    return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volumeid, 3.5.0)
 int
-pub_glfs_get_volumeid (struct glfs *fs, char *volid, size_t size)
+pub_glfs_get_volumeid(struct glfs *fs, char *volid, size_t size)
 {
-        /* TODO: Define a global macro to store UUID size */
-        size_t uuid_size = 16;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        pthread_mutex_lock (&fs->mutex);
-        {
-                /* check if the volume uuid is initialized */
-                if (!gf_uuid_is_null (fs->vol_uuid)) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto done;
-                }
+    /* TODO: Define a global macro to store UUID size */
+    size_t uuid_size = 16;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        /* check if the volume uuid is initialized */
+        if (!gf_uuid_is_null(fs->vol_uuid)) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto done;
         }
-        pthread_mutex_unlock (&fs->mutex);
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
-        /* Need to fetch volume_uuid */
-        glfs_get_volume_info (fs);
+    /* Need to fetch volume_uuid */
+    glfs_get_volume_info(fs);
 
-        if (gf_uuid_is_null (fs->vol_uuid)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_FETCH_VOLUUID_FAILED, "Unable to fetch "
-                        "volume UUID");
-                goto out;
-        }
+    if (gf_uuid_is_null(fs->vol_uuid)) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_FETCH_VOLUUID_FAILED,
+                NULL);
+        goto out;
+    }
 
 done:
-        if (!volid || !size) {
-                gf_msg_debug (THIS->name, 0, "volumeid/size is null");
-                __GLFS_EXIT_FS;
-                return uuid_size;
-        }
+    if (!volid || !size) {
+        gf_msg_debug(THIS->name, 0, "volumeid/size is null");
+        __GLFS_EXIT_FS;
+        return uuid_size;
+    }
 
-        if (size < uuid_size) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE,
-                        "Insufficient size passed");
-                errno = ERANGE;
-                goto out;
-        }
+    if (size < uuid_size) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE, NULL);
+        errno = ERANGE;
+        goto out;
+    }
 
-        memcpy (volid, fs->vol_uuid, uuid_size);
+    memcpy(volid, fs->vol_uuid, uuid_size);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        return uuid_size;
+    return uuid_size;
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volumeid, 3.5.0);
-
 int
-glfs_get_volume_info (struct glfs *fs)
+glfs_get_volume_info(struct glfs *fs)
 {
-        call_frame_t     *frame = NULL;
-        glusterfs_ctx_t  *ctx   = NULL;
-        struct syncargs  args   = {0, };
-        int              ret    = 0;
-
-        ctx = fs->ctx;
-        frame = create_frame (THIS, ctx->pool);
-        if (!frame) {
-                gf_msg ("glfs", GF_LOG_ERROR, ENOMEM,
-                        API_MSG_FRAME_CREAT_FAILED,
-                        "failed to create the frame");
-                ret = -1;
-                goto out;
-        }
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    struct syncargs args = {
+        0,
+    };
+    int ret = 0;
 
-        frame->local = &args;
+    ctx = fs->ctx;
+    frame = create_frame(THIS, ctx->pool);
+    if (!frame) {
+        gf_smsg("glfs", GF_LOG_ERROR, ENOMEM, API_MSG_FRAME_CREAT_FAILED, NULL);
+        ret = -1;
+        goto out;
+    }
 
-        __yawn ((&args));
+    frame->local = &args;
 
-        ret = glfs_get_volume_info_rpc (frame, THIS, fs);
-        if (ret)
-                goto out;
+    __yawn((&args));
 
-        __yield ((&args));
+    ret = glfs_get_volume_info_rpc(frame, THIS, fs);
+    if (ret)
+        goto out;
 
-        frame->local = NULL;
-        STACK_DESTROY (frame->root);
+    __yield((&args));
+
+    frame->local = NULL;
+    STACK_DESTROY(frame->root);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
-                          struct glfs *fs)
+glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs)
 {
-        gf_get_volume_info_req  req       = {{0,}};
-        int                     ret       = 0;
-        glusterfs_ctx_t         *ctx      = NULL;
-        dict_t                  *dict     = NULL;
-        int32_t                 flags     = 0;
-
-        if (!frame || !this || !fs) {
-                ret = -1;
-                goto out;
-        }
-
-        ctx = fs->ctx;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        if (fs->volname) {
-                ret = dict_set_str (dict, "volname", fs->volname);
-                if (ret)
-                        goto out;
-        }
-
-        // Set the flags for the fields which we are interested in
-        flags = (int32_t)GF_GET_VOLUME_UUID; //ctx->flags;
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED, "failed to set flags");
-                goto out;
-        }
-
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-
-
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_GET_VOLUME_INFO,
-                                   mgmt_get_volinfo_cbk,
-                                   (xdrproc_t)xdr_gf_get_volume_info_req);
+    gf_get_volume_info_req req = {{
+        0,
+    }};
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+    int32_t flags = 0;
+
+    if (!frame || !this || !fs) {
+        ret = -1;
+        goto out;
+    }
+
+    ctx = fs->ctx;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    if (fs->volname) {
+        ret = dict_set_str(dict, "volname", fs->volname);
+        if (ret)
+            goto out;
+    }
+
+    // Set the flags for the fields which we are interested in
+    flags = (int32_t)GF_GET_VOLUME_UUID;  // ctx->flags;
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL,
+                API_MSG_DICT_SET_FAILED, "flags", NULL);
+        goto out;
+    }
+
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GET_VOLUME_INFO, mgmt_get_volinfo_cbk,
+                              (xdrproc_t)xdr_gf_get_volume_info_req);
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 static int
-glusterfs_oldvolfile_update (struct glfs *fs, char *volfile, ssize_t size)
+glusterfs_oldvolfile_update(struct glfs *fs, char *volfile, ssize_t size)
 {
-	int ret = -1;
-
-        pthread_mutex_lock (&fs->mutex);
-
-	fs->oldvollen = size;
-	if (!fs->oldvolfile) {
-		fs->oldvolfile = GF_CALLOC (1, size+1, glfs_mt_volfile_t);
-	} else {
-		fs->oldvolfile = GF_REALLOC (fs->oldvolfile, size+1);
-	}
-
-	if (!fs->oldvolfile) {
-		fs->oldvollen = 0;
-	} else {
-		memcpy (fs->oldvolfile, volfile, size);
-		fs->oldvollen = size;
-		ret = 0;
-	}
+    int ret = -1;
+
+    pthread_mutex_lock(&fs->mutex);
+
+    fs->oldvollen = size;
+    if (!fs->oldvolfile) {
+        fs->oldvolfile = CALLOC(1, size + 1);
+    } else {
+        fs->oldvolfile = REALLOC(fs->oldvolfile, size + 1);
+    }
+
+    if (!fs->oldvolfile) {
+        fs->oldvollen = 0;
+    } else {
+        memcpy(fs->oldvolfile, volfile, size);
+        fs->oldvollen = size;
+        ret = 0;
+    }
 
-        pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_unlock(&fs->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
+glfs_mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-	gf_getspec_rsp		 rsp   = {0,};
-	call_frame_t		*frame = NULL;
-	glusterfs_ctx_t		*ctx = NULL;
-	int			 ret   = 0;
-	ssize_t			 size = 0;
-	FILE			*tmpfp = NULL;
-	int			 need_retry = 0;
-	struct glfs		*fs = NULL;
-
-	frame = myframe;
-	ctx = frame->this->ctx;
-
-	if (!ctx) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "NULL context");
-		errno = EINVAL;
-		ret = -1;
-		goto out;
-	}
-
-	fs = ((xlator_t *)ctx->master)->private;
-
-	if (-1 == req->rpc_status) {
-		ret = -1;
-		need_retry = 1;
-		goto out;
-	}
-
-	ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-	if (ret < 0) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                        API_MSG_XDR_DECODE_FAILED, "XDR decoding error");
-		ret   = -1;
-		goto out;
-	}
-
-	if (-1 == rsp.op_ret) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, rsp.op_errno,
-                        API_MSG_GET_VOLFILE_FAILED,
-			"failed to get the 'volume file' from server");
-		ret = -1;
-		errno = rsp.op_errno;
-		goto out;
-	}
-
-	ret = 0;
-	size = rsp.op_ret;
-
-	if ((size == fs->oldvollen) &&
-	    (memcmp (fs->oldvolfile, rsp.spec, size) == 0)) {
-		gf_msg (frame->this->name, GF_LOG_INFO, 0,
-                        API_MSG_VOLFILE_INFO,
-			"No change in volfile, continuing");
-		goto out;
-	}
-
-	tmpfp = tmpfile ();
-	if (!tmpfp) {
-		ret = -1;
-		goto out;
-	}
-
-	fwrite (rsp.spec, size, 1, tmpfp);
-	fflush (tmpfp);
-	if (ferror (tmpfp)) {
-		ret = -1;
-		goto out;
-	}
-
-	/*  Check if only options have changed. No need to reload the
-	*  volfile if topology hasn't changed.
-	*  glusterfs_volfile_reconfigure returns 3 possible return states
-	*  return 0	     =======> reconfiguration of options has succeeded
-	*  return 1	     =======> the graph has to be reconstructed and all the xlators should be inited
-	*  return -1(or -ve) =======> Some Internal Error occurred during the operation
-	*/
-
-        ret = gf_volfile_reconfigure (fs->oldvollen, tmpfp, fs->ctx,
-                                      fs->oldvolfile);
-	if (ret == 0) {
-		gf_msg_debug ("glusterfsd-mgmt", 0, "No need to re-load "
-                              "volfile, reconfigure done");
-		ret = glusterfs_oldvolfile_update (fs, rsp.spec, size);
-		goto out;
-	}
-
-	if (ret < 0) {
-		gf_msg_debug ("glusterfsd-mgmt", 0, "Reconfigure failed !!");
-		goto out;
-	}
-
-	ret = glfs_process_volfp (fs, tmpfp);
-	/* tmpfp closed */
-	tmpfp = NULL;
-	if (ret)
-		goto out;
-
-	ret = glusterfs_oldvolfile_update (fs, rsp.spec, size);
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    ssize_t size = 0;
+    FILE *tmpfp = NULL;
+    int need_retry = 0;
+    struct glfs *fs = NULL;
+    dict_t *dict = NULL;
+    char *servers_list = NULL;
+    int tmp_fd = -1;
+    char template[] = "/tmp/gfapi.volfile.XXXXXX";
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+
+    if (!ctx) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_NULL,
+                "context", NULL);
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        need_retry = 1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, 0, API_MSG_XDR_DECODE_FAILED,
+                NULL);
+        ret = -1;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_smsg(frame->this->name, GF_LOG_ERROR, rsp.op_errno,
+                API_MSG_GET_VOLFILE_FAILED, "from server", NULL);
+        ret = -1;
+        errno = rsp.op_errno;
+        goto out;
+    }
+
+    if (!rsp.xdata.xdata_len) {
+        goto volfile;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.xdata.xdata_val, rsp.xdata.xdata_len, &dict);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to unserialize xdata to dictionary");
+        goto out;
+    }
+    dict->extra_stdfree = rsp.xdata.xdata_val;
+
+    /* glusterd2 only */
+    ret = dict_get_str(dict, "servers-list", &servers_list);
+    if (ret) {
+        goto volfile;
+    }
+
+    gf_log(frame->this->name, GF_LOG_INFO,
+           "Received list of available volfile servers: %s", servers_list);
+
+    ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed (%s) to process servers list: %s", strerror(errno),
+               servers_list);
+    }
+
+volfile:
+    ret = 0;
+    size = rsp.op_ret;
+
+    pthread_mutex_lock(&fs->mutex);
+    if ((size == fs->oldvollen) &&
+        (memcmp(fs->oldvolfile, rsp.spec, size) == 0)) {
+        pthread_mutex_unlock(&fs->mutex);
+        gf_smsg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO, NULL);
+        goto out;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    tmp_fd = mkstemp(template);
+    if (-1 == tmp_fd) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Calling unlink so that when the file is closed or program
+     * terminates the temporary file is deleted.
+     */
+    ret = sys_unlink(template);
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_INFO, 0, API_MSG_UNABLE_TO_DEL,
+                "template=%s", template, NULL);
+        ret = 0;
+    }
+
+    tmpfp = fdopen(tmp_fd, "w+b");
+    if (!tmpfp) {
+        ret = -1;
+        goto out;
+    }
+
+    fwrite(rsp.spec, size, 1, tmpfp);
+    fflush(tmpfp);
+    if (ferror(tmpfp)) {
+        ret = -1;
+        goto out;
+    }
+
+    /*  Check if only options have changed. No need to reload the
+     *  volfile if topology hasn't changed.
+     *  glusterfs_volfile_reconfigure returns 3 possible return states
+     *  return 0	     =======> reconfiguration of options has succeeded
+     *  return 1	     =======> the graph has to be reconstructed and all
+     * the xlators should be inited return -1(or -ve) =======> Some Internal
+     * Error occurred during the operation
+     */
+
+    pthread_mutex_lock(&fs->mutex);
+    ret = gf_volfile_reconfigure(fs->oldvollen, tmpfp, fs->ctx, fs->oldvolfile);
+    pthread_mutex_unlock(&fs->mutex);
+
+    if (ret == 0) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "No need to re-load "
+                     "volfile, reconfigure done");
+        ret = glusterfs_oldvolfile_update(fs, rsp.spec, size);
+        goto out;
+    }
+
+    if (ret < 0) {
+        gf_msg_debug("glusterfsd-mgmt", 0, "Reconfigure failed !!");
+        goto out;
+    }
+
+    ret = glfs_process_volfp(fs, tmpfp);
+    /* tmpfp closed */
+    tmpfp = NULL;
+    tmp_fd = -1;
+    if (ret)
+        goto out;
+
+    ret = glusterfs_oldvolfile_update(fs, rsp.spec, size);
 out:
-	STACK_DESTROY (frame->root);
-
-	if (rsp.spec)
-		free (rsp.spec);
-
-        if (rsp.xdata.xdata_val)
-                free (rsp.xdata.xdata_val);
-
-	// Stop if server is running at an unsupported op-version
-	if (ENOTSUP == ret) {
-		gf_msg ("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION,
-                        "Server is operating at an op-version which is not "
-                        "supported");
-		errno = ENOTSUP;
-		glfs_init_done (fs, -1);
-	}
-
-	if (ret && ctx && !ctx->active) {
-		/* Do it only for the first time */
-		/* Failed to get the volume file, something wrong,
-		   restart the process */
-		gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY,
-			"failed to fetch volume file (key:%s)",
-			ctx->cmd_args.volfile_id);
-		if (!need_retry) {
-			if (!errno)
-				errno = EINVAL;
-			glfs_init_done (fs, -1);
-		}
-	}
-
-	if (tmpfp)
-		fclose (tmpfp);
-
-	return 0;
-}
-
-
-int
-glfs_volfile_fetch (struct glfs *fs)
-{
-	cmd_args_t	 *cmd_args = NULL;
-	gf_getspec_req	  req = {0, };
-	int		  ret = 0;
-	call_frame_t	 *frame = NULL;
-	glusterfs_ctx_t	 *ctx = NULL;
-        dict_t           *dict = NULL;
-
-	ctx = fs->ctx;
-	cmd_args = &ctx->cmd_args;
-
-	frame = create_frame (THIS, ctx->pool);
-
-	req.key = cmd_args->volfile_id;
-	req.flags = 0;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED,
-                        "Failed to set min-op-version in request dict");
-                goto out;
+    STACK_DESTROY(frame->root);
+
+    if (rsp.spec)
+        free(rsp.spec);
+
+    if (dict)
+        dict_unref(dict);
+
+    // Stop if server is running at an unsupported op-version
+    if (ENOTSUP == ret) {
+        gf_smsg("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION, NULL);
+        errno = ENOTSUP;
+        glfs_init_done(fs, -1);
+    }
+
+    if (ret && ctx && !ctx->active) {
+        /* Do it only for the first time */
+        /* Failed to get the volume file, something wrong,
+           restart the process */
+        gf_smsg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_GET_VOLFILE_FAILED,
+                "key=%s", ctx->cmd_args.volfile_id, NULL);
+        if (!need_retry) {
+            if (!errno)
+                errno = EINVAL;
+            glfs_init_done(fs, -1);
         }
+    }
 
-        ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED,
-                        "Failed to set max-op-version in request dict");
-                goto out;
-        }
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
 
-        ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                        API_MSG_DICT_SERIALIZE_FAILED,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
+    return 0;
+}
 
-	ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-				   GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk,
-				   (xdrproc_t)xdr_gf_getspec_req);
+int
+glfs_volfile_fetch(struct glfs *fs)
+{
+    cmd_args_t *cmd_args = NULL;
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+
+    ctx = fs->ctx;
+    cmd_args = &ctx->cmd_args;
+
+    req.key = cmd_args->volfile_id;
+    req.flags = 0;
+
+    dict = dict_new();
+    if (!dict) {
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+                "min-op-version", NULL);
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+                "max-op-version", NULL);
+        goto out;
+    }
+
+    /* Ask for a list of volfile (glusterd2 only) servers */
+    if (GF_CLIENT_PROCESS == ctx->process_mode) {
+        req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
+    }
+
+    ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, API_MSG_DICT_SERIALIZE_FAILED,
+                NULL);
+        goto out;
+    }
+
+    frame = create_frame(THIS, ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk,
+                              (xdrproc_t)xdr_gf_getspec_req);
 out:
-        if (req.xdata.xdata_val)
-                GF_FREE(req.xdata.xdata_val);
-        if (dict)
-                dict_unref (dict);
+    if (req.xdata.xdata_val)
+        GF_FREE(req.xdata.xdata_val);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-		 void *data)
+mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                void *data)
 {
-	xlator_t	*this = NULL;
-	glusterfs_ctx_t *ctx = NULL;
-        server_cmdline_t *server = NULL;
-        rpc_transport_t  *rpc_trans = NULL;
-	struct glfs	 *fs = NULL;
-	int		 ret = 0;
-	struct dnscache6 *dnscache = NULL;
-
-	this = mydata;
-        rpc_trans = rpc->conn.trans;
-
-	ctx = this->ctx;
-	if (!ctx)
-		goto out;
-
-	fs = ((xlator_t *)ctx->master)->private;
-
-	switch (event) {
-	case RPC_CLNT_DISCONNECT:
-		if (!ctx->active) {
-                        if (rpc_trans->connect_failed)
-                                gf_msg ("glfs-mgmt", GF_LOG_ERROR, 0,
-                                        API_MSG_REMOTE_HOST_CONN_FAILED,
-                                        "failed to connect to remote-host: %s",
-                                        ctx->cmd_args.volfile_server);
-                        else
-                                gf_msg ("glfs-mgmt", GF_LOG_INFO, 0,
-                                        API_MSG_REMOTE_HOST_CONN_FAILED,
-                                        "disconnected from remote-host: %s",
-                                        ctx->cmd_args.volfile_server);
-
-                        if (!rpc->disabled) {
-                                /*
-                                 * Check if dnscache is exhausted for current server
-                                 * and continue until cache is exhausted
-                                 */
-                                dnscache = rpc_trans->dnscache;
-                                if (dnscache && dnscache->next) {
-                                        break;
-                                }
-                        }
-                        server = ctx->cmd_args.curr_server;
-                        if (server->list.next == &ctx->cmd_args.volfile_servers) {
-                                errno = ENOTCONN;
-                                gf_msg ("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
-                                        API_MSG_VOLFILE_SERVER_EXHAUST,
-                                        "Exhausted all volfile servers");
-                                glfs_init_done (fs, -1);
-                                break;
-                        }
-                        server = list_entry (server->list.next, typeof(*server),
-                                             list);
-                        ctx->cmd_args.curr_server = server;
-                        ctx->cmd_args.volfile_server_port = server->port;
-                        ctx->cmd_args.volfile_server = server->volfile_server;
-                        ctx->cmd_args.volfile_server_transport = server->transport;
-
-                        ret = dict_set_str (rpc_trans->options,
-                                            "transport-type",
-                                            server->transport);
-                        if (ret != 0) {
-                                gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                                        API_MSG_DICT_SET_FAILED,
-                                        "failed to set transport-type: %s",
-                                        server->transport);
-                                errno = ENOTCONN;
-                                glfs_init_done (fs, -1);
-                                break;
-                        }
-
-                        if (strcmp(server->transport, "unix") == 0) {
-                                ret = dict_set_str (rpc_trans->options,
-                                                    "transport.socket.connect-path",
-                                                    server->volfile_server);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set socket.connect-path: %s",
-                                                server->volfile_server);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-                                /* delete the remote-host and remote-port keys
-                                 * in case they were set while looping through
-                                 * list of volfile servers previously
-                                 */
-                                dict_del (rpc_trans->options, "remote-host");
-                                dict_del (rpc_trans->options, "remote-port");
-                        } else {
-                                ret = dict_set_int32 (rpc_trans->options,
-                                                      "remote-port",
-                                                      server->port);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set remote-port: %d",
-                                                server->port);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-
-                                ret = dict_set_str (rpc_trans->options,
-                                                    "remote-host",
-                                                    server->volfile_server);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set remote-host: %s",
-                                                server->volfile_server);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-                                /* delete the "transport.socket.connect-path"
-                                 * key in case if it was set while looping
-                                 * through list of volfile servers previously
-                                 */
-                                dict_del (rpc_trans->options,
-                                          "transport.socket.connect-path");
-                        }
-
-                        gf_msg ("glfs-mgmt", GF_LOG_INFO, 0,
-                                API_MSG_VOLFILE_CONNECTING,
-                                "connecting to next volfile server %s"
-                                " at port %d with transport: %s",
-                                server->volfile_server, server->port,
-                                server->transport);
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    server_cmdline_t *server = NULL;
+    rpc_transport_t *rpc_trans = NULL;
+    struct glfs *fs = NULL;
+    int ret = 0;
+    struct dnscache6 *dnscache = NULL;
+
+    this = mydata;
+    rpc_trans = rpc->conn.trans;
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto out;
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    switch (event) {
+        case RPC_CLNT_DISCONNECT:
+            if (!ctx->active) {
+                if (rpc_trans->connect_failed)
+                    gf_smsg("glfs-mgmt", GF_LOG_ERROR, 0,
+                            API_MSG_REMOTE_HOST_CONN_FAILED, "server=%s",
+                            ctx->cmd_args.volfile_server, NULL);
+                else
+                    gf_smsg("glfs-mgmt", GF_LOG_INFO, 0,
+                            API_MSG_REMOTE_HOST_CONN_FAILED, "server=%s",
+                            ctx->cmd_args.volfile_server, NULL);
+
+                if (!rpc->disabled) {
+                    /*
+                     * Check if dnscache is exhausted for current server
+                     * and continue until cache is exhausted
+                     */
+                    dnscache = rpc_trans->dnscache;
+                    if (dnscache && dnscache->next) {
+                        break;
+                    }
+                }
+                server = ctx->cmd_args.curr_server;
+                if (server->list.next == &ctx->cmd_args.volfile_servers) {
+                    errno = ENOTCONN;
+                    gf_smsg("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
+                            API_MSG_VOLFILE_SERVER_EXHAUST, NULL);
+                    glfs_init_done(fs, -1);
+                    break;
                 }
-                break;
-	case RPC_CLNT_CONNECT:
-		rpc_clnt_set_connected (&((struct rpc_clnt*)ctx->mgmt)->conn);
-
-		ret = glfs_volfile_fetch (fs);
-		if (ret && (ctx->active == NULL)) {
-			/* Do it only for the first time */
-			/* Exit the process.. there are some wrong options */
-			gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-				"failed to fetch volume file (key:%s)",
-                                ctx->cmd_args.volfile_id);
-                        errno = EINVAL;
-                        glfs_init_done (fs, -1);
+                server = list_entry(server->list.next, typeof(*server), list);
+                ctx->cmd_args.curr_server = server;
+                ctx->cmd_args.volfile_server_port = server->port;
+                ctx->cmd_args.volfile_server = server->volfile_server;
+                ctx->cmd_args.volfile_server_transport = server->transport;
+
+                ret = dict_set_str(rpc_trans->options, "transport-type",
+                                   server->transport);
+                if (ret != 0) {
+                    gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                            API_MSG_DICT_SET_FAILED, "transport-type=%s",
+                            server->transport, NULL);
+                    errno = ENOTCONN;
+                    glfs_init_done(fs, -1);
+                    break;
+                }
+
+                if (strcmp(server->transport, "unix") == 0) {
+                    ret = dict_set_str(rpc_trans->options,
+                                       "transport.socket.connect-path",
+                                       server->volfile_server);
+                    if (ret != 0) {
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED,
+                                "socket.connect-path=%s",
+                                server->volfile_server, NULL);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+                    /* delete the remote-host and remote-port keys
+                     * in case they were set while looping through
+                     * list of volfile servers previously
+                     */
+                    dict_del(rpc_trans->options, "remote-host");
+                    dict_del(rpc_trans->options, "remote-port");
+                } else {
+                    ret = dict_set_int32(rpc_trans->options, "remote-port",
+                                         server->port);
+                    if (ret != 0) {
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED, "remote-port=%d",
+                                server->port, NULL);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+
+                    ret = dict_set_str(rpc_trans->options, "remote-host",
+                                       server->volfile_server);
+                    if (ret != 0) {
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED, "remote-host=%s",
+                                server->volfile_server, NULL);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+                    /* delete the "transport.socket.connect-path"
+                     * key in case if it was set while looping
+                     * through list of volfile servers previously
+                     */
+                    dict_del(rpc_trans->options,
+                             "transport.socket.connect-path");
                 }
 
-                break;
-	default:
-		break;
-	}
+                gf_smsg("glfs-mgmt", GF_LOG_INFO, 0, API_MSG_VOLFILE_CONNECTING,
+                        "server=%s", server->volfile_server, "port=%d",
+                        server->port, "transport=%s", server->transport, NULL);
+            }
+            break;
+        case RPC_CLNT_CONNECT:
+            ret = glfs_volfile_fetch(fs);
+            if (ret && (ctx->active == NULL)) {
+                /* Do it only for the first time */
+                /* Exit the process.. there are some wrong options */
+                gf_smsg("glfs-mgmt", GF_LOG_ERROR, EINVAL,
+                        API_MSG_GET_VOLFILE_FAILED, "key=%s",
+                        ctx->cmd_args.volfile_id, NULL);
+                errno = EINVAL;
+                glfs_init_done(fs, -1);
+            }
+
+            break;
+        default:
+            break;
+    }
 out:
-	return 0;
+    return 0;
 }
 
-
 int
-glusterfs_mgmt_notify (int32_t op, void *data, ...)
+glusterfs_mgmt_notify(int32_t op, void *data, ...)
 {
-	int ret = 0;
+    int ret = 0;
 
-	switch (op)
-	{
-		case GF_EN_DEFRAG_STATUS:
-			break;
+    switch (op) {
+        case GF_EN_DEFRAG_STATUS:
+            break;
 
-		default:
-			break;
-	}
+        default:
+            break;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_mgmt_init (struct glfs *fs)
+glfs_mgmt_init(struct glfs *fs)
 {
-	cmd_args_t		*cmd_args = NULL;
-	struct rpc_clnt		*rpc = NULL;
-	dict_t			*options = NULL;
-	int			ret = -1;
-	int			port = GF_DEFAULT_BASE_PORT;
-	char			*host = NULL;
-	glusterfs_ctx_t		*ctx = NULL;
-
-	ctx = fs->ctx;
-	cmd_args = &ctx->cmd_args;
-
-	if (ctx->mgmt)
-		return 0;
-
-	if (cmd_args->volfile_server_port)
-		port = cmd_args->volfile_server_port;
-
-	if (cmd_args->volfile_server) {
-		host = cmd_args->volfile_server;
-        } else if (cmd_args->volfile_server_transport &&
-                   !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                host = DEFAULT_GLUSTERD_SOCKFILE;
-        } else {
-                host = "localhost";
-        }
-
-        if (cmd_args->volfile_server_transport &&
-            !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                ret = rpc_transport_unix_options_build (&options, host, 0);
-        } else {
-                ret = rpc_transport_inet_options_build (&options, host, port);
-        }
-
-	if (ret)
-		goto out;
-
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
-                ctx->secure_mgmt = 1;
-        }
-
-	rpc = rpc_clnt_new (options, THIS, THIS->name, 8);
-	if (!rpc) {
-		ret = -1;
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_CREATE_RPC_CLIENT_FAILED,
-			"failed to create rpc clnt");
-		goto out;
-	}
-
-	ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS);
-	if (ret) {
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_REG_NOTIFY_FUNC_FAILED,
-			"failed to register notify function");
-		goto out;
-	}
-
-	ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS);
-	if (ret) {
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_REG_CBK_FUNC_FAILED,
-			"failed to register callback function");
-		goto out;
-	}
-
-	ctx->notify = glusterfs_mgmt_notify;
-
-	/* This value should be set before doing the 'rpc_clnt_start()' as
-	   the notify function uses this variable */
-	ctx->mgmt = rpc;
-
-	ret = rpc_clnt_start (rpc);
+    cmd_args_t *cmd_args = NULL;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = GF_DEFAULT_BASE_PORT;
+    char *host = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = fs->ctx;
+    cmd_args = &ctx->cmd_args;
+
+    if (ctx->mgmt)
+        return 0;
+
+    options = dict_new();
+    if (!options)
+        goto out;
+
+    if (cmd_args->volfile_server_port)
+        port = cmd_args->volfile_server_port;
+
+    if (cmd_args->volfile_server) {
+        host = cmd_args->volfile_server;
+    } else if (cmd_args->volfile_server_transport &&
+               !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        host = DEFAULT_GLUSTERD_SOCKFILE;
+    } else {
+        host = "localhost";
+    }
+
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        ret = rpc_transport_unix_options_build(options, host, 0);
+    } else {
+        xlator_cmdline_option_t *opt = find_xlator_option_in_cmd_args_t(
+            "address-family", cmd_args);
+        ret = rpc_transport_inet_options_build(options, host, port,
+                                               (opt ? opt->value : NULL));
+    }
+
+    if (ret)
+        goto out;
+
+    rpc = rpc_clnt_new(options, THIS, THIS->name, 8);
+    if (!rpc) {
+        ret = -1;
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_CREATE_RPC_CLIENT_FAILED,
+                NULL);
+        goto out;
+    }
+
+    ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_NOTIFY_FUNC_FAILED,
+                NULL);
+        goto out;
+    }
+
+    ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_CBK_FUNC_FAILED,
+                NULL);
+        goto out;
+    }
+
+    ctx->notify = glusterfs_mgmt_notify;
+
+    /* This value should be set before doing the 'rpc_clnt_start()' as
+       the notify function uses this variable */
+    ctx->mgmt = rpc;
+
+    ret = rpc_clnt_start(rpc);
 out:
-	return ret;
+    if (options)
+        dict_unref(options);
+    return ret;
 }
diff --git a/api/src/glfs-resolve.c b/api/src/glfs-resolve.c
index 76835cbaebd..8a393ecb464 100644
--- a/api/src/glfs-resolve.c
+++ b/api/src/glfs-resolve.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
@@ -16,57 +15,61 @@
 #include <inttypes.h>
 #include <limits.h>
 
-#include "glusterfs.h"
-#include "logging.h"
-#include "stack.h"
-#include "event.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/stack.h>
+#include <glusterfs/gf-event.h>
 #include "glfs-mem-types.h"
-#include "common-utils.h"
-#include "syncop.h"
-#include "call-stub.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/syncop.h>
+#include <glusterfs/call-stub.h>
 #include "gfapi-messages.h"
-#include "inode.h"
+#include <glusterfs/inode.h>
 #include "glfs-internal.h"
 
-#define graphid_str(subvol) (uuid_utoa((unsigned char *)subvol->graph->graph_uuid))
+#define graphid_str(subvol)                                                    \
+    (uuid_utoa((unsigned char *)subvol->graph->graph_uuid))
 int
-glfs_first_lookup_safe (xlator_t *subvol)
+glfs_first_lookup_safe(xlator_t *subvol)
 {
-	loc_t  loc = {0, };
-	int    ret = -1;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
 
-	loc.inode = subvol->itable->root;
-	memset (loc.gfid, 0, 16);
-	loc.gfid[15] = 1;
-	loc.path = "/";
-	loc.name = "";
+    loc.inode = subvol->itable->root;
+    memset(loc.gfid, 0, 16);
+    loc.gfid[15] = 1;
+    loc.path = "/";
+    loc.name = "";
 
-	ret = syncop_lookup (subvol, &loc, 0, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_lookup(subvol, &loc, 0, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
 
-	gf_msg_debug (subvol->name, 0, "first lookup complete %d", ret);
+    gf_msg_debug(subvol->name, 0, "first lookup complete %d", ret);
 
-	return ret;
+    return ret;
 }
 
-
 int
-__glfs_first_lookup (struct glfs *fs, xlator_t *subvol)
+__glfs_first_lookup(struct glfs *fs, xlator_t *subvol)
 {
-	int ret = -1;
-
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		ret = glfs_first_lookup_safe (subvol);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
-
-	return ret;
-}
+    int ret = -1;
+
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        ret = glfs_first_lookup_safe(subvol);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
 
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
+
+    return ret;
+}
 
 /**
  * We have to check if need_lookup flag is set in both old and the new inodes.
@@ -76,835 +79,837 @@ __glfs_first_lookup (struct glfs *fs, xlator_t *subvol)
  * below xlators can set their respective contexts.
  */
 inode_t *
-glfs_refresh_inode_safe (xlator_t *subvol, inode_t *oldinode,
-                         gf_boolean_t need_lookup)
+glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
+                        gf_boolean_t need_lookup)
 {
-	loc_t        loc = {0, };
-	int          ret = -1;
-	struct iatt  iatt = {0, };
-	inode_t     *newinode = NULL;
-        gf_boolean_t lookup_needed = _gf_false;
-        uint64_t     ctx_value = LOOKUP_NOT_NEEDED;
-
-
-	if (!oldinode)
-		return NULL;
-
-	if (!need_lookup && oldinode->table->xl == subvol)
-		return inode_ref (oldinode);
-
-	newinode = inode_find (subvol->itable, oldinode->gfid);
-	if (!need_lookup && newinode) {
-
-                lookup_needed = inode_needs_lookup (newinode, THIS);
-                if (!lookup_needed)
-                        return newinode;
-        }
-
-	gf_uuid_copy (loc.gfid, oldinode->gfid);
-        if (!newinode)
-                loc.inode = inode_new (subvol->itable);
-        else
-                loc.inode = newinode;
-
-	if (!loc.inode)
-		return NULL;
-
-	ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret) {
-		gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-			"inode refresh of %s failed: %s",
-			uuid_utoa (oldinode->gfid), strerror (errno));
-		loc_wipe (&loc);
-		return NULL;
-	}
-
-	newinode = inode_link (loc.inode, 0, 0, &iatt);
-        if (newinode) {
-                if (newinode == loc.inode)
-                        inode_ctx_set (newinode, THIS, &ctx_value);
-                inode_lookup (newinode);
-        } else {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed",
-                        uuid_utoa ((unsigned char *)&iatt.ia_gfid));
-        }
-
-	loc_wipe (&loc);
-
-	return newinode;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *newinode = NULL;
+    gf_boolean_t lookup_needed = _gf_false;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    if (!oldinode)
+        return NULL;
+
+    if (!need_lookup && oldinode->table->xl == subvol)
+        return inode_ref(oldinode);
+
+    newinode = inode_find(subvol->itable, oldinode->gfid);
+    if (!need_lookup && newinode) {
+        lookup_needed = inode_needs_lookup(newinode, THIS);
+        if (!lookup_needed)
+            return newinode;
+    }
+
+    gf_uuid_copy(loc.gfid, oldinode->gfid);
+    if (!newinode)
+        loc.inode = inode_new(subvol->itable);
+    else
+        loc.inode = newinode;
+
+    if (!loc.inode)
+        return NULL;
+
+    ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret) {
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa(oldinode->gfid), "err=%s", strerror(errno), NULL);
+        loc_wipe(&loc);
+        return NULL;
+    }
+
+    newinode = inode_link(loc.inode, 0, 0, &iatt);
+    if (newinode) {
+        if (newinode == loc.inode)
+            inode_ctx_set(newinode, THIS, &ctx_value);
+        inode_lookup(newinode);
+    } else {
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&iatt.ia_gfid), NULL);
+    }
+
+    loc_wipe(&loc);
+
+    return newinode;
 }
 
-
 inode_t *
-__glfs_refresh_inode (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-                      gf_boolean_t need_lookup)
+__glfs_refresh_inode(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                     gf_boolean_t need_lookup)
 {
-	inode_t *newinode = NULL;
-
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		newinode = glfs_refresh_inode_safe (subvol, inode, need_lookup);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
-
-	return newinode;
+    inode_t *newinode = NULL;
+
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        newinode = glfs_refresh_inode_safe(subvol, inode, need_lookup);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
+
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
+
+    return newinode;
 }
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0)
 int
-priv_glfs_loc_touchup (loc_t *loc)
+priv_glfs_loc_touchup(loc_t *loc)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        ret = loc_touchup (loc, loc->name);
-        if (ret < 0) {
-                errno = -ret;
-                ret = -1;
-        }
+    ret = loc_touchup(loc, loc->name);
+    if (ret < 0) {
+        errno = -ret;
+        ret = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0);
-
 int
-glfs_resolve_symlink (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-		      char **lpath)
+glfs_resolve_symlink(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                     char **lpath)
 {
-	loc_t  loc = {0, };
-	char  *path = NULL;
-	char  *rpath = NULL;
-	int    ret = -1;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-	ret = inode_path (inode, NULL, &rpath);
-	if (ret < 0)
-		goto out;
-	loc.path = rpath;
-
-	ret = syncop_readlink (subvol, &loc, &path, 4096, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret < 0)
-		goto out;
-
-	if (lpath)
-		*lpath = path;
+    loc_t loc = {
+        0,
+    };
+    char *path = NULL;
+    char *rpath = NULL;
+    int ret = -1;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    ret = inode_path(inode, NULL, &rpath);
+    if (ret < 0)
+        goto out;
+    loc.path = rpath;
+
+    ret = syncop_readlink(subvol, &loc, &path, 4096, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret < 0)
+        goto out;
+
+    if (lpath)
+        *lpath = path;
 out:
-	loc_wipe (&loc);
-	return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
-
 int
-glfs_resolve_base (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-		   struct iatt *iatt)
+glfs_resolve_base(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                  struct iatt *iatt)
 {
-	loc_t       loc = {0, };
-	int         ret = -1;
-	char       *path = NULL;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	ret = inode_path (loc.inode, NULL, &path);
-	loc.path = path;
-	if (ret < 0)
-		goto out;
-
-	ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    ret = inode_path(loc.inode, NULL, &path);
+    loc.path = path;
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return ret;
+    return ret;
 }
 /*
  * This function can be used to call named lookup on root.
  * If you use glfs_resolve_base, that will be a nameless lookup.
  */
 static int
-glfs_resolve_root (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-                   struct iatt *iatt)
+glfs_resolve_root(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                  struct iatt *iatt)
 {
-        loc_t       loc = {0, };
-        int         ret = -1;
-        char       *path = NULL;
-
-        loc.inode = inode_ref (inode);
-
-        ret = inode_path (loc.inode, NULL, &path);
-        loc.path = path;
-        loc.name = "";
-        /* Having a value in loc.name will help to bypass md-cache check for
-         * nameless lookup.
-         * TODO: Re-visit on nameless lookup and md-cache.
-         * Github issue : https://github.com/gluster/glusterfs/issues/232
-         */
-        loc.parent = inode_ref (inode);
-        if (ret < 0)
-                goto out;
-
-        ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+
+    loc.inode = inode_ref(inode);
+
+    ret = inode_path(loc.inode, ".", &path);
+    loc.path = path;
+    loc.name = ".";
+    /* Having a value in loc.name will help to bypass md-cache check for
+     * nameless lookup.
+     * TODO: Re-visit on nameless lookup and md-cache.
+     * Github issue : https://github.com/gluster/glusterfs/issues/232
+     */
+    loc.parent = inode_ref(inode);
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 inode_t *
-glfs_resolve_component (struct glfs *fs, xlator_t *subvol, inode_t *parent,
-			const char *component, struct iatt *iatt,
-			int force_lookup)
+glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
+                       const char *component, struct iatt *iatt,
+                       int force_lookup)
 {
-	loc_t        loc = {0, };
-	inode_t     *inode = NULL;
-        inode_t     *temp_parent = NULL;
-	int          reval = 0;
-	int          ret = -1;
-	int          glret = -1;
-	struct iatt  ciatt = {0, };
-	uuid_t       gfid;
-	dict_t      *xattr_req = NULL;
-        uint64_t     ctx_value = LOOKUP_NOT_NEEDED;
-
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, parent->gfid);
-
-        if (__is_root_gfid (parent->gfid) &&
-            ((strcmp (component, ".") == 0) ||
-             (strcmp (component, "..") == 0) ||
-             (strcmp (component, "") == 0))) {
-                if (!force_lookup) {
-                        inode = inode_ref (parent);
-                } else {
-                        ret = glfs_resolve_root (fs, subvol, parent, &ciatt);
-                        if (!ret)
-                                inode = inode_ref (parent);
-                }
-                goto found;
+    loc_t loc = {
+        0,
+    };
+    inode_t *inode = NULL;
+    inode_t *temp_parent = NULL;
+    int reval = 0;
+    int ret = -1;
+    int glret = -1;
+    struct iatt ciatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+
+    if (__is_root_gfid(parent->gfid) &&
+        ((strcmp(component, ".") == 0) || (strcmp(component, "..") == 0) ||
+         (strcmp(component, "") == 0))) {
+        if (!force_lookup) {
+            inode = inode_ref(parent);
+        } else {
+            ret = glfs_resolve_root(fs, subvol, parent, &ciatt);
+            if (!ret)
+                inode = inode_ref(parent);
+        }
+        goto found;
+    }
+    /* *
+     * if the component name is either "." or "..", it will try to
+     * resolve that if inode has a proper parent (named lookup).
+     *
+     * Below condition works like this
+     *
+     * Example 1 :
+     * Path /out_dir/dir/in_dir/.
+     *     In put values :
+     *         parent = in_dir
+     *         component : "."
+     *
+     *      Out put values:
+     *         parent : dir
+     *         component : "in_dir"
+     *
+     * Example 2 :
+     * Path /out_dir/dir/in_dir/..
+     *     In put values :
+     *         parent = in_dir
+     *         component : ".."
+     *
+     *     Out put values:
+     *         parent : output_dir
+     *         component : "dir"
+     *
+     * In case of nameless lookup, both "." and ".." retained
+     */
+
+    if (strcmp(component, ".") == 0) {
+        loc.inode = inode_ref(parent);
+        temp_parent = inode_parent(loc.inode, 0, 0);
+        if (temp_parent) {
+            inode_unref(loc.parent);
+            loc.parent = temp_parent;
+            gf_uuid_copy(loc.pargfid, temp_parent->gfid);
+            inode_find_directory_name(loc.inode, &loc.name);
         }
-        /* *
-        * if the component name is either "." or "..", it will try to
-        * resolve that if inode has a proper parent (named lookup).
-        *
-        * Below condition works like this
-        *
-        * Example 1 :
-        * Path /out_dir/dir/in_dir/.
-        *     In put values :
-        *         parent = in_dir
-        *         component : "."
-        *
-        *      Out put values:
-        *         parent : dir
-        *         component : "in_dir"
-        *
-        * Example 2 :
-        * Path /out_dir/dir/in_dir/..
-        *     In put values :
-        *         parent = in_dir
-        *         component : ".."
-        *
-        *     Out put values:
-        *         parent : output_dir
-        *         component : "dir"
-        *
-        * Incase of nameless lookup, both "." and ".." retained
-        */
 
-        if (strcmp (component, ".") == 0) {
-                loc.inode = inode_ref (parent);
-                temp_parent = inode_parent (loc.inode, 0, 0);
-                if (temp_parent) {
-                        inode_unref (loc.parent);
-                        loc.parent = temp_parent;
-                        inode_find_directory_name (loc.inode, &loc.name);
-                }
+    } else if (strcmp(component, "..") == 0) {
+        loc.inode = inode_parent(parent, 0, 0);
+        if (loc.inode) {
+            temp_parent = inode_parent(loc.inode, 0, 0);
+            if (temp_parent) {
+                inode_unref(loc.parent);
+                loc.parent = temp_parent;
+                gf_uuid_copy(loc.pargfid, temp_parent->gfid);
+                inode_find_directory_name(loc.inode, &loc.name);
+            } else if (__is_root_gfid(loc.inode->gfid)) {
+                inode_unref(loc.parent);
+                loc.parent = inode_ref(loc.inode);
+                gf_uuid_copy(loc.pargfid, loc.inode->gfid);
+                loc.name = ".";
+            } else {
+                inode_unref(loc.inode);
+                loc.inode = NULL;
+            }
+        }
+    } else
+        loc.inode = inode_grep(parent->table, parent, component);
 
-        } else if (strcmp (component, "..") == 0) {
-                loc.inode = inode_parent (parent, 0, 0);
-                if (loc.inode) {
-                        temp_parent = inode_parent (loc.inode, 0, 0);
-                        if (temp_parent) {
-                                inode_unref (loc.parent);
-                                loc.parent = temp_parent;
-                                inode_find_directory_name (loc.inode, &loc.name);
-                        } else if (__is_root_gfid (loc.inode->gfid)) {
-                                inode_unref (loc.parent);
-                                loc.parent = inode_ref (loc.inode);
-                                loc.name = "";
-                        } else {
-                                inode_unref (loc.inode);
-                                loc.inode = NULL;
-                        }
+    if (!loc.name)
+        loc.name = component;
 
-                }
-        } else
-                loc.inode = inode_grep (parent->table, parent, component);
-
-        if (!loc.name)
-                loc.name = component;
-
-	if (loc.inode) {
-		gf_uuid_copy (loc.gfid, loc.inode->gfid);
-		reval = 1;
-
-                if (!(force_lookup || inode_needs_lookup (loc.inode, THIS))) {
-			inode = inode_ref (loc.inode);
-			goto found;
-		}
-	} else {
-		gf_uuid_generate (gfid);
-		loc.inode = inode_new (parent->table);
-                if (!loc.inode) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+    if (loc.inode) {
+        gf_uuid_copy(loc.gfid, loc.inode->gfid);
+        reval = 1;
 
-                xattr_req = dict_new ();
-                if (!xattr_req) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+        if (!(force_lookup || inode_needs_lookup(loc.inode, THIS))) {
+            inode = inode_ref(loc.inode);
+            goto found;
+        }
+    } else {
+        gf_uuid_generate(gfid);
+        loc.inode = inode_new(parent->table);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-                ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-                if (ret) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+        xattr_req = dict_new();
+        if (!xattr_req) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-	}
-
-	glret = priv_glfs_loc_touchup (&loc);
-	if (glret < 0) {
-		ret = -1;
-		goto out;
-	}
-
-        ret = syncop_lookup (subvol, &loc, &ciatt, NULL, xattr_req, NULL);
-        if (ret && reval) {
-                /*
-                 * A stale mapping might exist for a dentry/inode that has been
-                 * removed from another client.
-                 */
-                if (-ret == ENOENT)
-                        inode_unlink(loc.inode, loc.parent,
-                                     loc.name);
-		inode_unref (loc.inode);
-	        gf_uuid_clear (loc.gfid);
-		loc.inode = inode_new (parent->table);
-		if (!loc.inode) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		xattr_req = dict_new ();
-		if (!xattr_req) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		gf_uuid_generate (gfid);
-
-		ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-		if (ret) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		ret = syncop_lookup (subvol, &loc, &ciatt, NULL,
-				     xattr_req, NULL);
-	}
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	inode = inode_link (loc.inode, loc.parent, component, &ciatt);
+        ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+        if (ret) {
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    glret = priv_glfs_loc_touchup(&loc);
+    if (glret < 0) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL);
+    if (ret && reval) {
+        /*
+         * A stale mapping might exist for a dentry/inode that has been
+         * removed from another client.
+         */
+        if (-ret == ENOENT) {
+            inode_unlink(loc.inode, loc.parent, loc.name);
+            if (!inode_has_dentry(loc.inode))
+                inode_forget(loc.inode, 0);
+        }
 
-        if (!inode) {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed",
-                        uuid_utoa ((unsigned char *)&ciatt.ia_gfid));
-                goto out;
-        } else if (inode == loc.inode)
-                inode_ctx_set (inode, THIS, &ctx_value);
-found:
-	if (inode) {
-                ciatt.ia_type = inode->ia_type;
-		inode_lookup (inode);
+        inode_unref(loc.inode);
+        gf_uuid_clear(loc.gfid);
+        loc.inode = inode_new(parent->table);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
+
+        xattr_req = dict_new();
+        if (!xattr_req) {
+            errno = ENOMEM;
+            goto out;
+        }
+
+        gf_uuid_generate(gfid);
+
+        ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+        if (ret) {
+            errno = ENOMEM;
+            goto out;
         }
-	if (iatt)
-		*iatt = ciatt;
+
+        ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL);
+    }
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    inode = inode_link(loc.inode, loc.parent, component, &ciatt);
+
+    if (!inode) {
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&ciatt.ia_gfid), NULL);
+        goto out;
+    } else if (inode == loc.inode)
+        inode_ctx_set(inode, THIS, &ctx_value);
+found:
+    if (inode) {
+        ciatt.ia_type = inode->ia_type;
+        inode_lookup(inode);
+    }
+    if (iatt)
+        *iatt = ciatt;
 out:
-	if (xattr_req)
-		dict_unref (xattr_req);
-	loc_wipe (&loc);
+    if (xattr_req)
+        dict_unref(xattr_req);
+    loc_wipe(&loc);
 
-	return inode;
+    return inode;
 }
 
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0)
 int
-priv_glfs_resolve_at (struct glfs *fs, xlator_t *subvol, inode_t *at,
-		 const char *origpath, loc_t *loc, struct iatt *iatt,
-		 int follow, int reval)
+priv_glfs_resolve_at(struct glfs *fs, xlator_t *subvol, inode_t *at,
+                     const char *origpath, loc_t *loc, struct iatt *iatt,
+                     int follow, int reval)
 {
-	inode_t    *inode = NULL;
-	inode_t    *parent = NULL;
-	char       *saveptr = NULL;
-	char       *path = NULL;
-	char       *component = NULL;
-	char       *next_component = NULL;
-	int         ret = -1;
-	struct iatt ciatt = {0, };
-
-	DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
-
-	path = gf_strdup (origpath);
-	if (!path) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	parent = NULL;
-	if (at && path[0] != '/') {
-		/* A relative resolution of a path which starts with '/'
-		   is equal to an absolute path resolution.
-		*/
-		inode = inode_ref (at);
-	} else {
-		inode = inode_ref (subvol->itable->root);
-
-		if (strcmp (path, "/") == 0)
-                        glfs_resolve_root (fs, subvol, inode, &ciatt);
-	}
-
-	for (component = strtok_r (path, "/", &saveptr);
-	     component; component = next_component) {
-
-		next_component = strtok_r (NULL, "/", &saveptr);
-
-		if (parent)
-			inode_unref (parent);
-		parent = inode;
-		inode = glfs_resolve_component (fs, subvol, parent,
-						component, &ciatt,
-						/* force hard lookup on the last
-						   component, as the caller
-						   wants proper iatt filled
-						*/
-						(reval || (!next_component &&
-						iatt)));
-		if (!inode) {
-                        ret = -1;
-			break;
-                }
+    inode_t *inode = NULL;
+    inode_t *parent = NULL;
+    char *saveptr = NULL;
+    char *path = NULL;
+    char *component = NULL;
+    char *next_component = NULL;
+    int ret = -1;
+    struct iatt ciatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (origpath[0] == '\0') {
+        errno = EINVAL;
+        goto invalid_fs;
+    }
+
+    parent = NULL;
+    if (at && origpath[0] != '/') {
+        /* A relative resolution of a path which starts with '/'
+           is equal to an absolute path resolution.
+        */
+        inode = inode_ref(at);
+    } else {
+        inode = inode_ref(subvol->itable->root);
+
+        if (strcmp(origpath, "/") == 0)
+            glfs_resolve_root(fs, subvol, inode, &ciatt);
+    }
+
+    path = gf_strdup(origpath);
+    if (!path)
+        goto invalid_fs;
+
+    for (component = strtok_r(path, "/", &saveptr); component;
+         component = next_component) {
+        next_component = strtok_r(NULL, "/", &saveptr);
+
+        if (parent)
+            inode_unref(parent);
+        parent = inode;
+        inode = glfs_resolve_component(fs, subvol, parent, component, &ciatt,
+                                       /* force hard lookup on the last
+                                          component, as the caller
+                                          wants proper iatt filled
+                                       */
+                                       (reval || (!next_component && iatt)));
+        if (!inode) {
+            ret = -1;
+            break;
+        }
 
-		if (IA_ISLNK (ciatt.ia_type) && (next_component || follow)) {
-			/* If the component is not the last piece,
-			   then following it is necessary even if
-			   not requested by the caller
-			*/
-			char *lpath = NULL;
-			loc_t sym_loc = {0,};
-
-			if (follow > GLFS_SYMLINK_MAX_FOLLOW) {
-				errno = ELOOP;
-				ret = -1;
-				if (inode) {
-					inode_unref (inode);
-					inode = NULL;
-				}
-				break;
-			}
-
-			ret = glfs_resolve_symlink (fs, subvol, inode, &lpath);
-			inode_unref (inode);
-			inode = NULL;
-			if (ret < 0)
-				break;
-
-			ret = priv_glfs_resolve_at (fs, subvol, parent, lpath,
-					       &sym_loc,
-					       /* followed iatt becomes the
-						  component iatt
-					       */
-					       &ciatt,
-					       /* always recurisvely follow while
-						  following symlink
-					       */
-					       follow + 1, reval);
-			if (ret == 0)
-				inode = inode_ref (sym_loc.inode);
-			loc_wipe (&sym_loc);
-			GF_FREE (lpath);
-		}
-
-		if (!next_component)
-			break;
-
-		if (!IA_ISDIR (ciatt.ia_type)) {
-			/* next_component exists and this component is
-			   not a directory
-			*/
-			inode_unref (inode);
-			inode = NULL;
-			ret = -1;
-			errno = ENOTDIR;
-			break;
-		}
-	}
-
-	if (parent && next_component)
-		/* resolution failed mid-way */
-		goto out;
-
-	/* At this point, all components up to the last parent directory
-	   have been resolved successfully (@parent). Resolution of basename
-	   might have failed (@inode) if at all.
-	*/
-
-	loc->parent = parent;
-	if (parent) {
-		gf_uuid_copy (loc->pargfid, parent->gfid);
-		loc->name = component;
-	}
-
-	loc->inode = inode;
-	if (inode) {
-		gf_uuid_copy (loc->gfid, inode->gfid);
-		if (iatt)
-			*iatt = ciatt;
-		ret = 0;
-	}
-
-        if (priv_glfs_loc_touchup (loc) < 0) {
+        if (IA_ISLNK(ciatt.ia_type) && (next_component || follow)) {
+            /* If the component is not the last piece,
+               then following it is necessary even if
+               not requested by the caller
+            */
+            char *lpath = NULL;
+            loc_t sym_loc = {
+                0,
+            };
+
+            if (follow > GLFS_SYMLINK_MAX_FOLLOW) {
+                errno = ELOOP;
                 ret = -1;
+                if (inode) {
+                    inode_unref(inode);
+                    inode = NULL;
+                }
+                break;
+            }
+
+            ret = glfs_resolve_symlink(fs, subvol, inode, &lpath);
+            inode_unref(inode);
+            inode = NULL;
+            if (ret < 0)
+                break;
+
+            ret = priv_glfs_resolve_at(fs, subvol, parent, lpath, &sym_loc,
+                                       /* followed iatt becomes the
+                                          component iatt
+                                       */
+                                       &ciatt,
+                                       /* always recurisvely follow while
+                                          following symlink
+                                       */
+                                       follow + 1, reval);
+            if (ret == 0)
+                inode = inode_ref(sym_loc.inode);
+            loc_wipe(&sym_loc);
+            GF_FREE(lpath);
+        }
+
+        if (!next_component)
+            break;
+
+        if (!IA_ISDIR(ciatt.ia_type)) {
+            /* next_component exists and this component is
+               not a directory
+            */
+            inode_unref(inode);
+            inode = NULL;
+            ret = -1;
+            errno = ENOTDIR;
+            break;
         }
+    }
+
+    if (parent && next_component)
+        /* resolution failed mid-way */
+        goto out;
+
+    /* At this point, all components up to the last parent directory
+       have been resolved successfully (@parent). Resolution of basename
+       might have failed (@inode) if at all.
+    */
+
+    loc->parent = parent;
+    if (parent) {
+        gf_uuid_copy(loc->pargfid, parent->gfid);
+        loc->name = component;
+    }
+
+    loc->inode = inode;
+    if (inode) {
+        gf_uuid_copy(loc->gfid, inode->gfid);
+        if (iatt)
+            *iatt = ciatt;
+        ret = 0;
+    }
+
+    if (priv_glfs_loc_touchup(loc) < 0) {
+        ret = -1;
+    }
 out:
-	GF_FREE (path);
-        __GLFS_EXIT_FS;
+    GF_FREE(path);
+    __GLFS_EXIT_FS;
 
-	/* do NOT loc_wipe here as only last component might be missing */
+    /* do NOT loc_wipe here as only last component might be missing */
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0);
-
-
 int
-glfs_resolve_path (struct glfs *fs, xlator_t *subvol, const char *origpath,
-		   loc_t *loc, struct iatt *iatt, int follow, int reval)
+glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath,
+                  loc_t *loc, struct iatt *iatt, int follow, int reval)
 {
-	int ret = -1;
-	inode_t *cwd = NULL;
-
-	if (origpath[0] == '/')
-		return priv_glfs_resolve_at (fs, subvol, NULL, origpath, loc,
-                                             iatt, follow, reval);
-
-	cwd = glfs_cwd_get (fs);
-        if (NULL == cwd) {
-                gf_msg (subvol->name, GF_LOG_WARNING, EIO,
-                        API_MSG_GET_CWD_FAILED, "Failed to get cwd");
-                errno = EIO;
-                goto out;
-        }
+    int ret = -1;
+    inode_t *cwd = NULL;
 
-	ret = priv_glfs_resolve_at (fs, subvol, cwd, origpath, loc, iatt,
+    if (origpath[0] == '/')
+        return priv_glfs_resolve_at(fs, subvol, NULL, origpath, loc, iatt,
                                     follow, reval);
-	if (cwd)
-		inode_unref (cwd);
+
+    cwd = glfs_cwd_get(fs);
+    if (NULL == cwd) {
+        gf_smsg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
+                NULL);
+        errno = EIO;
+        goto out;
+    }
+
+    ret = priv_glfs_resolve_at(fs, subvol, cwd, origpath, loc, iatt, follow,
+                               reval);
+    if (cwd)
+        inode_unref(cwd);
 
 out:
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0)
 int
-priv_glfs_resolve (struct glfs *fs, xlator_t *subvol, const char *origpath,
-	      loc_t *loc, struct iatt *iatt, int reval)
+priv_glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
+                  loc_t *loc, struct iatt *iatt, int reval)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 1, reval);
+    ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 1, reval);
 
-	return ret;
+    return ret;
 }
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0);
 
 int
-glfs_lresolve (struct glfs *fs, xlator_t *subvol, const char *origpath,
-	       loc_t *loc, struct iatt *iatt, int reval)
+glfs_lresolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
+              loc_t *loc, struct iatt *iatt, int reval)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 0, reval);
+    ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 0, reval);
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
-			    xlator_t *newsubvol, fd_t *newfd)
+glfs_migrate_fd_locks_safe(struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
+                           xlator_t *newsubvol, fd_t *newfd)
 {
-	dict_t *lockinfo = NULL;
-	int ret = 0;
-	char uuid1[64];
-
-	if (!oldfd->lk_ctx || fd_lk_ctx_empty (oldfd->lk_ctx))
-		return 0;
-
-	newfd->lk_ctx = fd_lk_ctx_ref (oldfd->lk_ctx);
-
-	ret = syncop_fgetxattr (oldsubvol, oldfd, &lockinfo,
-				GF_XATTR_LOCKINFO_KEY, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret < 0) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_FGETXATTR_FAILED,
-			"fgetxattr (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (oldfd->inode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (oldsubvol), oldsubvol->graph->id);
-		goto out;
-	}
-
-	if (!dict_get (lockinfo, GF_XATTR_LOCKINFO_KEY)) {
-		gf_msg (fs->volname, GF_LOG_WARNING, 0,
-                        API_MSG_LOCKINFO_KEY_MISSING,
-			"missing lockinfo key (%s) on graph %s (%d)",
-			uuid_utoa_r (oldfd->inode->gfid, uuid1),
-			graphid_str (oldsubvol), oldsubvol->graph->id);
-		goto out;
-	}
-
-	ret = syncop_fsetxattr (newsubvol, newfd, lockinfo, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret < 0) {
-		gf_msg (fs->volname, GF_LOG_WARNING, 0,
-                        API_MSG_FSETXATTR_FAILED,
-			"fsetxattr (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newfd->inode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
+    dict_t *lockinfo = NULL;
+    int ret = 0;
+    char uuid1[64];
+
+    if (!oldfd->lk_ctx || fd_lk_ctx_empty(oldfd->lk_ctx))
+        return 0;
+
+    newfd->lk_ctx = fd_lk_ctx_ref(oldfd->lk_ctx);
+
+    ret = syncop_fgetxattr(oldsubvol, oldfd, &lockinfo, GF_XATTR_LOCKINFO_KEY,
+                           NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret < 0) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(oldsubvol), "id=%d",
+                oldsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    if (!dict_get(lockinfo, GF_XATTR_LOCKINFO_KEY)) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    ret = syncop_fsetxattr(newsubvol, newfd, lockinfo, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret < 0) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(newfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
+        goto out;
+    }
 out:
-	if (lockinfo)
-		dict_unref (lockinfo);
-	return ret;
+    if (lockinfo)
+        dict_unref(lockinfo);
+    return ret;
 }
 
-
 fd_t *
-glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
+glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
 {
-	fd_t *newfd = NULL;
-	inode_t *oldinode = NULL;
-	inode_t *newinode = NULL;
-	xlator_t *oldsubvol = NULL;
-	int ret = -1;
-	loc_t loc = {0, };
-	char uuid1[64];
-
-
-	oldinode = oldfd->inode;
-	oldsubvol = oldinode->table->xl;
-
-	if (oldsubvol == newsubvol)
-		return fd_ref (oldfd);
-
-	if (!oldsubvol->switched) {
-		ret = syncop_fsync (oldsubvol, oldfd, 0, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-		if (ret) {
-			gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                                API_MSG_FSYNC_FAILED, "fsync() failed "
-                                "(%s) on %s graph %s (%d)", strerror (errno),
-				uuid_utoa_r (oldfd->inode->gfid, uuid1),
-				graphid_str (oldsubvol), oldsubvol->graph->id);
-		}
-	}
-
-	newinode = glfs_refresh_inode_safe (newsubvol, oldinode, _gf_false);
-	if (!newinode) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-			"inode (%s) refresh failed (%s) on graph %s (%d)",
-			uuid_utoa_r (oldinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	newfd = fd_create (newinode, getpid());
-	if (!newfd) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_FDCREATE_FAILED,
-			"fd_create (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	loc.inode = inode_ref (newinode);
-
-        ret = inode_path (oldfd->inode, NULL, (char **)&loc.path);
-        if (ret < 0) {
-                gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
-                        "inode_path failed");
-                goto out;
+    fd_t *newfd = NULL;
+    inode_t *oldinode = NULL;
+    inode_t *newinode = NULL;
+    xlator_t *oldsubvol = NULL;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    char uuid1[64];
+    dict_t *xdata = NULL;
+
+    oldinode = oldfd->inode;
+    oldsubvol = oldinode->table->xl;
+
+    if (oldsubvol == newsubvol)
+        return fd_ref(oldfd);
+
+    if (!oldsubvol->switched) {
+        xdata = dict_new();
+        if (!xdata || dict_set_int8(xdata, "last-fsync", 1)) {
+            gf_smsg(fs->volname, GF_LOG_WARNING, ENOMEM, API_MSG_FSYNC_FAILED,
+                    "err=%s", "last-fsync set failed", "gfid=%s",
+                    uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                    graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id,
+                    NULL);
         }
 
-        gf_uuid_copy (loc.gfid, oldinode->gfid);
-
-
-	if (IA_ISDIR (oldinode->ia_type))
-		ret = syncop_opendir (newsubvol, &loc, newfd, NULL, NULL);
-	else
-		ret = syncop_open (newsubvol, &loc,
-				   oldfd->flags & ~(O_TRUNC|O_EXCL|O_CREAT),
-				   newfd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	loc_wipe (&loc);
-
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_SYNCOP_OPEN_FAILED,
-			"syncop_open%s (%s) failed (%s) on graph %s (%d)",
-			IA_ISDIR (oldinode->ia_type) ? "dir" : "",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	ret = glfs_migrate_fd_locks_safe (fs, oldsubvol, oldfd, newsubvol,
-					  newfd);
-
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_LOCK_MIGRATE_FAILED,
-			"lock migration (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-        newfd->flags = oldfd->flags;
-	fd_bind (newfd);
+        ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, xdata, NULL);
+        DECODE_SYNCOP_ERR(ret);
+        if (ret) {
+            gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
+                    "err=%s", strerror(errno), "gfid=%s",
+                    uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                    graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id,
+                    NULL);
+        }
+    }
+
+    newinode = glfs_refresh_inode_safe(newsubvol, oldinode, _gf_false);
+    if (!newinode) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa_r(oldinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    newfd = fd_create(newinode, getpid());
+    if (!newfd) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_FDCREATE_FAILED_ON_GRAPH, "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    loc.inode = inode_ref(newinode);
+
+    ret = inode_path(oldfd->inode, NULL, (char **)&loc.path);
+    if (ret < 0) {
+        gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED, NULL);
+        goto out;
+    }
+
+    gf_uuid_copy(loc.gfid, oldinode->gfid);
+
+    if (IA_ISDIR(oldinode->ia_type))
+        ret = syncop_opendir(newsubvol, &loc, newfd, NULL, NULL);
+    else
+        ret = syncop_open(newsubvol, &loc,
+                          oldfd->flags & ~(O_TRUNC | O_EXCL | O_CREAT), newfd,
+                          NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    loc_wipe(&loc);
+
+    if (ret) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
+                "type=%s", IA_ISDIR(oldinode->ia_type) ? "dir" : "", "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    ret = glfs_migrate_fd_locks_safe(fs, oldsubvol, oldfd, newsubvol, newfd);
+
+    if (ret) {
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
+                "gfid=%s", uuid_utoa_r(newinode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
+        goto out;
+    }
+
+    newfd->flags = oldfd->flags;
+    fd_bind(newfd);
 out:
-	if (newinode)
-		inode_unref (newinode);
+    if (newinode)
+        inode_unref(newinode);
 
-	if (ret) {
-		fd_unref (newfd);
-		newfd = NULL;
-	}
+    if (ret) {
+        fd_unref(newfd);
+        newfd = NULL;
+    }
 
-	return newfd;
-}
+    if (xdata)
+        dict_unref(xdata);
 
+    return newfd;
+}
 
 fd_t *
-__glfs_migrate_fd (struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd)
+__glfs_migrate_fd(struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd)
 {
-	fd_t *oldfd = NULL;
-	fd_t *newfd = NULL;
+    fd_t *oldfd = NULL;
+    fd_t *newfd = NULL;
 
-	oldfd = glfd->fd;
+    oldfd = glfd->fd;
 
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		newfd = glfs_migrate_fd_safe (fs, newsubvol, oldfd);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        newfd = glfs_migrate_fd_safe(fs, newsubvol, oldfd);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
 
-	return newfd;
-}
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
 
+    return newfd;
+}
 
 fd_t *
-__glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
+__glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
 {
-	fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-	if (glfd->fd->inode->table->xl == subvol)
-		return fd_ref (glfd->fd);
+    if (glfd->fd->inode->table->xl == subvol)
+        return fd_ref(glfd->fd);
 
-	fd = __glfs_migrate_fd (fs, subvol, glfd);
-	if (!fd)
-		return NULL;
+    fd = __glfs_migrate_fd(fs, subvol, glfd);
+    if (!fd)
+        return NULL;
 
-	if (subvol == fs->active_subvol) {
-		fd_unref (glfd->fd);
-		glfd->fd = fd_ref (fd);
-	}
+    if (subvol == fs->active_subvol) {
+        fd_unref(glfd->fd);
+        glfd->fd = fd_ref(fd);
+    }
 
-	return fd;
+    return fd;
 }
 
-
 fd_t *
-glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
+glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
 {
-	fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		fd = __glfs_resolve_fd (fs, subvol, glfd);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        fd = __glfs_resolve_fd(fs, subvol, glfd);
+    }
+    glfs_unlock(fs);
 
-	return fd;
+    return fd;
 }
 
-
 void
-__glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol)
+__glfs_migrate_openfds(struct glfs *fs, xlator_t *subvol)
 {
-	struct glfs_fd *glfd = NULL;
-	fd_t *fd = NULL;
-
-	list_for_each_entry (glfd, &fs->openfds, openfds) {
-		if (gf_uuid_is_null (glfd->fd->inode->gfid)) {
-			gf_msg (fs->volname, GF_LOG_INFO, 0,
-                                API_MSG_OPENFD_SKIPPED,
-				"skipping openfd %p/%p in graph %s (%d)",
-				glfd, glfd->fd,	graphid_str(subvol),
-				subvol->graph->id);
-			/* create in progress, defer */
-			continue;
-		}
-
-		fd = __glfs_migrate_fd (fs, subvol, glfd);
-		if (fd) {
-			fd_unref (glfd->fd);
-			glfd->fd = fd;
-		}
-	}
-}
+    struct glfs_fd *glfd = NULL;
+    fd_t *fd = NULL;
+
+    list_for_each_entry(glfd, &fs->openfds, openfds)
+    {
+        if (gf_uuid_is_null(glfd->fd->inode->gfid)) {
+            gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
+                    "glfd=%p", glfd, "glfd->fd=%p", glfd->fd, "subvol=%s",
+                    graphid_str(subvol), "id=%d", subvol->graph->id, NULL);
+            /* create in progress, defer */
+            continue;
+        }
 
+        fd = __glfs_migrate_fd(fs, subvol, glfd);
+        if (fd) {
+            fd_unref(glfd->fd);
+            glfd->fd = fd;
+        }
+    }
+}
 
 /* Note that though it appears that this function executes under fs->mutex,
  * it is not fully executed under fs->mutex. i.e. there are functions like
@@ -914,289 +919,281 @@ __glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol)
  * function need not have the same value by the end of the function.
  */
 xlator_t *
-__glfs_active_subvol (struct glfs *fs)
+__glfs_active_subvol(struct glfs *fs)
 {
-	xlator_t      *new_subvol = NULL;
-	int            ret = -1;
-	inode_t       *new_cwd = NULL;
-
-	if (!fs->next_subvol)
-		return fs->active_subvol;
-
-	new_subvol = fs->mip_subvol = fs->next_subvol;
-        fs->next_subvol = NULL;
-
-	ret = __glfs_first_lookup (fs, new_subvol);
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_INFO, errno,
-                        API_MSG_FIRST_LOOKUP_GRAPH_FAILED,
-			"first lookup on graph %s (%d) failed (%s)",
-			graphid_str (new_subvol), new_subvol->graph->id,
-			strerror (errno));
-		return NULL;
-	}
-
-	if (fs->cwd) {
-		new_cwd = __glfs_refresh_inode (fs, new_subvol, fs->cwd,
-                                                _gf_false);
-
-		if (!new_cwd) {
-			char buf1[64];
-			gf_msg (fs->volname, GF_LOG_INFO, errno,
-                                API_MSG_CWD_GRAPH_REF_FAILED,
-				"cwd refresh of %s graph %s (%d) failed (%s)",
-				uuid_utoa_r (fs->cwd->gfid, buf1),
-				graphid_str (new_subvol),
-				new_subvol->graph->id, strerror (errno));
-			return NULL;
-		}
-	}
-
-	__glfs_migrate_openfds (fs, new_subvol);
-
-	/* switching @active_subvol and @cwd
-	   should be atomic
-	*/
-	fs->old_subvol = fs->active_subvol;
-	fs->active_subvol = fs->mip_subvol;
-	fs->mip_subvol = NULL;
-
-	if (new_cwd) {
-		__glfs_cwd_set (fs, new_cwd);
-		inode_unref (new_cwd);
-	}
-
-	gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH,
-                "switched to graph %s (%d)",
-		graphid_str (new_subvol), new_subvol->graph->id);
-
-	return new_subvol;
-}
+    xlator_t *new_subvol = NULL;
+    int ret = -1;
+    inode_t *new_cwd = NULL;
+
+    if (!fs->next_subvol)
+        return fs->active_subvol;
+
+    new_subvol = fs->mip_subvol = fs->next_subvol;
+    fs->next_subvol = NULL;
+
+    ret = __glfs_first_lookup(fs, new_subvol);
+    if (ret) {
+        gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                API_MSG_FIRST_LOOKUP_GRAPH_FAILED, "subvol=%s",
+                graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                "err=%s", strerror(errno), NULL);
+        return NULL;
+    }
+
+    if (fs->cwd) {
+        new_cwd = __glfs_refresh_inode(fs, new_subvol, fs->cwd, _gf_false);
+
+        if (!new_cwd) {
+            char buf1[64];
+            gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                    API_MSG_CWD_GRAPH_REF_FAILED, "buf=%s",
+                    uuid_utoa_r(fs->cwd->gfid, buf1), "subvol=%s",
+                    graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                    "err=%s", strerror(errno), NULL);
+            return NULL;
+        }
+    }
 
+    __glfs_migrate_openfds(fs, new_subvol);
+    /* TODO: Migrate the fds and inodes which have leases to the new graph
+     * (issue #350)*/
 
-void
-priv_glfs_subvol_done (struct glfs *fs, xlator_t *subvol)
-{
-	int ref = 0;
-	xlator_t *active_subvol = NULL;
+    /* switching @active_subvol and @cwd
+       should be atomic
+    */
+    fs->old_subvol = fs->active_subvol;
+    fs->active_subvol = fs->mip_subvol;
+    fs->mip_subvol = NULL;
 
-	if (!subvol)
-		return;
+    if (new_cwd) {
+        __glfs_cwd_set(fs, new_cwd);
+        inode_unref(new_cwd);
+    }
 
-        /* For decrementing subvol->wind ref count we need not check/wait for
-         * migration-in-progress flag.
-         * Also glfs_subvol_done is called in call-back path therefore waiting
-         * fot migration-in-progress flag can lead to dead-lock.
-         */
-        glfs_lock (fs, _gf_false);
-	{
-		ref = (--subvol->winds);
-		active_subvol = fs->active_subvol;
-	}
-        glfs_unlock (fs);
-
-	if (ref == 0) {
-		assert (subvol != active_subvol);
-		xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, NULL);
-	}
-}
+    gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH, "subvol=%s",
+            graphid_str(new_subvol), "id=%d", new_subvol->graph->id, NULL);
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0);
+    return new_subvol;
+}
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0)
+void
+priv_glfs_subvol_done(struct glfs *fs, xlator_t *subvol)
+{
+    int ref = 0;
+    xlator_t *active_subvol = NULL;
+
+    if (!subvol)
+        return;
+
+    /* For decrementing subvol->wind ref count we need not check/wait for
+     * migration-in-progress flag.
+     * Also glfs_subvol_done is called in call-back path therefore waiting
+     * for migration-in-progress flag can lead to dead-lock.
+     */
+    glfs_lock(fs, _gf_false);
+    {
+        ref = (--subvol->winds);
+        active_subvol = fs->active_subvol;
+    }
+    glfs_unlock(fs);
+
+    if (ref == 0) {
+        assert(subvol != active_subvol);
+        xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, NULL);
+    }
+}
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0)
 xlator_t *
-priv_glfs_active_subvol (struct glfs *fs)
+priv_glfs_active_subvol(struct glfs *fs)
 {
-	xlator_t      *subvol = NULL;
-	xlator_t      *old_subvol = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *old_subvol = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		subvol = __glfs_active_subvol (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        subvol = __glfs_active_subvol(fs);
 
-		if (subvol)
-			subvol->winds++;
+        if (subvol)
+            subvol->winds++;
 
-		if (fs->old_subvol) {
-			old_subvol = fs->old_subvol;
-			fs->old_subvol = NULL;
-			old_subvol->switched = 1;
-		}
-	}
-	glfs_unlock (fs);
+        if (fs->old_subvol) {
+            old_subvol = fs->old_subvol;
+            fs->old_subvol = NULL;
+            old_subvol->switched = 1;
+        }
+    }
+    glfs_unlock(fs);
 
-	if (old_subvol)
-		priv_glfs_subvol_done (fs, old_subvol);
+    if (old_subvol)
+        priv_glfs_subvol_done(fs, old_subvol);
 
-	return subvol;
+    return subvol;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0);
-
 int
-__glfs_cwd_set (struct glfs *fs, inode_t *inode)
+__glfs_cwd_set(struct glfs *fs, inode_t *inode)
 {
-	if (inode->table->xl != fs->active_subvol) {
-		inode = __glfs_refresh_inode (fs, fs->active_subvol, inode,
-                                              _gf_false);
-		if (!inode)
-			return -1;
-	} else {
-		inode_ref (inode);
-	}
+    if (inode->table->xl != fs->active_subvol) {
+        inode = __glfs_refresh_inode(fs, fs->active_subvol, inode, _gf_false);
+        if (!inode)
+            return -1;
+    } else {
+        inode_ref(inode);
+    }
 
-	if (fs->cwd)
-		inode_unref (fs->cwd);
+    if (fs->cwd)
+        inode_unref(fs->cwd);
 
-	fs->cwd = inode;
+    fs->cwd = inode;
 
-	return 0;
+    return 0;
 }
 
-
 int
-glfs_cwd_set (struct glfs *fs, inode_t *inode)
+glfs_cwd_set(struct glfs *fs, inode_t *inode)
 {
-	int ret = 0;
+    int ret = 0;
 
-        glfs_lock (fs, _gf_true);
-	{
-		ret = __glfs_cwd_set (fs, inode);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        ret = __glfs_cwd_set(fs, inode);
+    }
+    glfs_unlock(fs);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-__glfs_cwd_get (struct glfs *fs)
+__glfs_cwd_get(struct glfs *fs)
 {
-	inode_t *cwd = NULL;
+    inode_t *cwd = NULL;
 
-	if (!fs->cwd)
-		return NULL;
+    if (!fs->cwd)
+        return NULL;
 
-	if (fs->cwd->table->xl == fs->active_subvol) {
-		cwd = inode_ref (fs->cwd);
-		return cwd;
-	}
+    if (fs->cwd->table->xl == fs->active_subvol) {
+        cwd = inode_ref(fs->cwd);
+        return cwd;
+    }
 
-	cwd = __glfs_refresh_inode (fs, fs->active_subvol, fs->cwd, _gf_false);
+    cwd = __glfs_refresh_inode(fs, fs->active_subvol, fs->cwd, _gf_false);
 
-	return cwd;
+    return cwd;
 }
 
 inode_t *
-glfs_cwd_get (struct glfs *fs)
+glfs_cwd_get(struct glfs *fs)
 {
-	inode_t *cwd = NULL;
+    inode_t *cwd = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		cwd = __glfs_cwd_get (fs);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        cwd = __glfs_cwd_get(fs);
+    }
+    glfs_unlock(fs);
 
-	return cwd;
+    return cwd;
 }
 
 inode_t *
-__glfs_resolve_inode (struct glfs *fs, xlator_t *subvol,
-		    struct glfs_object *object)
+__glfs_resolve_inode(struct glfs *fs, xlator_t *subvol,
+                     struct glfs_object *object)
 {
-	inode_t *inode = NULL;
-        gf_boolean_t lookup_needed = _gf_false;
+    inode_t *inode = NULL;
+    gf_boolean_t lookup_needed = _gf_false;
 
-        lookup_needed = inode_needs_lookup (object->inode, THIS);
+    lookup_needed = inode_needs_lookup(object->inode, THIS);
 
-	if (!lookup_needed && object->inode->table->xl == subvol)
-		return inode_ref (object->inode);
+    if (!lookup_needed && object->inode->table->xl == subvol)
+        return inode_ref(object->inode);
 
-	inode = __glfs_refresh_inode (fs, fs->active_subvol,
-                                      object->inode, lookup_needed);
-	if (!inode)
-		return NULL;
+    inode = __glfs_refresh_inode(fs, fs->active_subvol, object->inode,
+                                 lookup_needed);
+    if (!inode)
+        return NULL;
 
-	if (subvol == fs->active_subvol) {
-		inode_unref (object->inode);
-		object->inode = inode_ref (inode);
-	}
+    if (subvol == fs->active_subvol) {
+        inode_unref(object->inode);
+        object->inode = inode_ref(inode);
+    }
 
-	return inode;
+    return inode;
 }
 
 inode_t *
-glfs_resolve_inode (struct glfs *fs, xlator_t *subvol,
-		    struct glfs_object *object)
+glfs_resolve_inode(struct glfs *fs, xlator_t *subvol,
+                   struct glfs_object *object)
 {
-	inode_t *inode = NULL;
+    inode_t *inode = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		inode = __glfs_resolve_inode(fs, subvol, object);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        inode = __glfs_resolve_inode(fs, subvol, object);
+    }
+    glfs_unlock(fs);
 
-	return inode;
+    return inode;
 }
 
 int
-glfs_create_object (loc_t *loc, struct glfs_object **retobject)
+glfs_create_object(loc_t *loc, struct glfs_object **retobject)
 {
-	struct glfs_object *object = NULL;
+    struct glfs_object *object = NULL;
 
-	object = GF_CALLOC (1, sizeof(struct glfs_object),
-			    glfs_mt_glfs_object_t);
-	if (object == NULL) {
-		errno = ENOMEM;
-		return -1;
-	}
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
 
-	object->inode = loc->inode;
-	gf_uuid_copy (object->gfid, object->inode->gfid);
+    object->inode = loc->inode;
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
-	/* we hold the reference */
-	loc->inode = NULL;
+    /* we hold the reference */
+    loc->inode = NULL;
 
-	*retobject = object;
+    *retobject = object;
 
-	return 0;
+    return 0;
 }
 
 struct glfs_object *
-glfs_h_resolve_symlink (struct glfs *fs, struct glfs_object *object)
+glfs_h_resolve_symlink(struct glfs *fs, struct glfs_object *object)
 {
-
-        xlator_t                *subvol         = NULL;
-        loc_t                   sym_loc         = {0,};
-        struct iatt             iatt            = {0,};
-        char                    *lpath          = NULL;
-        int                     ret             = 0;
-        struct glfs_object      *target_object  = NULL;
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        ret = glfs_resolve_symlink (fs, subvol, object->inode, &lpath);
-        if (ret < 0)
-                goto out;
-
-        ret = glfs_resolve_at (fs, subvol, NULL, lpath,
-                               &sym_loc, &iatt,
-                              /* always recurisvely follow while
-                                following symlink
-                              */
-                               1, 0);
-        if (ret == 0)
-                ret = glfs_create_object (&sym_loc, &target_object);
+    xlator_t *subvol = NULL;
+    loc_t sym_loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    char *lpath = NULL;
+    int ret = 0;
+    struct glfs_object *target_object = NULL;
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    ret = glfs_resolve_symlink(fs, subvol, object->inode, &lpath);
+    if (ret < 0)
+        goto out;
+
+    ret = glfs_resolve_at(fs, subvol, NULL, lpath, &sym_loc, &iatt,
+                          /* always recurisvely follow while
+                            following symlink
+                          */
+                          1, 0);
+    if (ret == 0)
+        ret = glfs_create_object(&sym_loc, &target_object);
 
 out:
-        loc_wipe (&sym_loc);
-        GF_FREE (lpath);
-        return target_object;
+    loc_wipe(&sym_loc);
+    GF_FREE(lpath);
+    return target_object;
 }
diff --git a/api/src/glfs.c b/api/src/glfs.c
index 8369546667b..b4bf1423f6d 100644
--- a/api/src/glfs.c
+++ b/api/src/glfs.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /*
   TODO:
   - set proper pid/lk_owner to call frames (currently buried in syncop)
@@ -31,662 +30,743 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <limits.h>
-
-#include "glusterfs.h"
-#include "logging.h"
-#include "stack.h"
-#include "event.h"
+#ifdef GF_LINUX_HOST_OS
+#include <sys/prctl.h>
+#endif
+
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/stack.h>
+#include <glusterfs/gf-event.h>
 #include "glfs-mem-types.h"
-#include "common-utils.h"
-#include "syncop.h"
-#include "call-stub.h"
-#include "hashfn.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/syncop.h>
+#include <glusterfs/call-stub.h>
+#include <glusterfs/hashfn.h>
 #include "rpc-clnt.h"
-#include "statedump.h"
+#include <glusterfs/statedump.h>
+#include <glusterfs/syscall.h>
 
 #include "gfapi-messages.h"
 #include "glfs.h"
 #include "glfs-internal.h"
 
-
 static gf_boolean_t
-vol_assigned (cmd_args_t *args)
+vol_assigned(cmd_args_t *args)
 {
-	return args->volfile || args->volfile_server;
+    return args->volfile || args->volfile_server;
 }
 
-
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-	call_pool_t   *pool = NULL;
-	int	       ret = -1;
-
-	if (!ctx) {
-		goto err;
-        }
-
-        ret = xlator_mem_acct_init (THIS, glfs_mt_end + 1);
-        if (ret != 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                        API_MSG_MEM_ACCT_INIT_FAILED,
-                        "Memory accounting init failed");
-                return ret;
-        }
-
-        /* reset ret to -1 so that we don't need to explicitly
-         * set it in all error paths before "goto err"
-         */
+    call_pool_t *pool = NULL;
+    int ret = -1;
 
-        ret = -1;
+    if (!ctx) {
+        goto err;
+    }
 
-	ctx->process_uuid = generate_glusterfs_ctx_id ();
-	if (!ctx->process_uuid) {
-		goto err;
-	}
-
-	ctx->page_size	= 128 * GF_UNIT_KB;
-
-	ctx->iobuf_pool = iobuf_pool_new ();
-	if (!ctx->iobuf_pool) {
-		goto err;
-	}
-
-	ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-	if (!ctx->event_pool) {
-		goto err;
-	}
-
-	ctx->env = syncenv_new (0, 0, 0);
-	if (!ctx->env) {
-		goto err;
-	}
-
-	pool = GF_CALLOC (1, sizeof (call_pool_t),
-			  glfs_mt_call_pool_t);
-	if (!pool) {
-		goto err;
-	}
-
-	/* frame_mem_pool size 112 * 4k */
-	pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096);
-	if (!pool->frame_mem_pool) {
-		goto err;
-	}
-	/* stack_mem_pool size 256 * 1024 */
-	pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024);
-	if (!pool->stack_mem_pool) {
-		goto err;
-	}
-
-	ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
-	if (!ctx->stub_mem_pool) {
-		goto err;
-	}
-
-	ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
-	if (!ctx->dict_pool)
-		goto err;
-
-	ctx->dict_pair_pool = mem_pool_new (data_pair_t,
-					    GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
-	if (!ctx->dict_pair_pool)
-		goto err;
-
-	ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
-	if (!ctx->dict_data_pool)
-		goto err;
-
-        ctx->logbuf_pool = mem_pool_new (log_buf_t,
-                                         GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
-        if (!ctx->logbuf_pool)
-                goto err;
-
-	INIT_LIST_HEAD (&pool->all_frames);
-	INIT_LIST_HEAD (&ctx->cmd_args.xlator_options);
-        INIT_LIST_HEAD (&ctx->cmd_args.volfile_servers);
-
-	LOCK_INIT (&pool->lock);
-	ctx->pool = pool;
-
-	ret = 0;
+    ret = xlator_mem_acct_init(THIS, glfs_mt_end + 1);
+    if (ret != 0) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+                NULL);
+        return ret;
+    }
+
+    /* reset ret to -1 so that we don't need to explicitly
+     * set it in all error paths before "goto err"
+     */
+
+    ret = -1;
+
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid) {
+        goto err;
+    }
+
+    ctx->page_size = 128 * GF_UNIT_KB;
+
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool) {
+        goto err;
+    }
+
+    ctx->event_pool = gf_event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                        STARTING_EVENT_THREADS);
+    if (!ctx->event_pool) {
+        goto err;
+    }
+
+    ctx->env = syncenv_new(0, 0, 0);
+    if (!ctx->env) {
+        goto err;
+    }
+
+    pool = GF_CALLOC(1, sizeof(call_pool_t), glfs_mt_call_pool_t);
+    if (!pool) {
+        goto err;
+    }
+
+    /* frame_mem_pool size 112 * 4k */
+    pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096);
+    if (!pool->frame_mem_pool) {
+        goto err;
+    }
+    /* stack_mem_pool size 256 * 1024 */
+    pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024);
+    if (!pool->stack_mem_pool) {
+        goto err;
+    }
+
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024);
+    if (!ctx->stub_mem_pool) {
+        goto err;
+    }
+
+    ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
+    if (!ctx->dict_pool)
+        goto err;
+
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t,
+                                       GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
+    if (!ctx->dict_pair_pool)
+        goto err;
+
+    ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
+    if (!ctx->dict_data_pool)
+        goto err;
+
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
+    if (!ctx->logbuf_pool)
+        goto err;
+
+    INIT_LIST_HEAD(&pool->all_frames);
+    INIT_LIST_HEAD(&ctx->cmd_args.xlator_options);
+    INIT_LIST_HEAD(&ctx->cmd_args.volfile_servers);
+
+    LOCK_INIT(&pool->lock);
+    ctx->pool = pool;
+
+    ret = 0;
 err:
-	if (ret && pool) {
-		if (pool->frame_mem_pool)
-			mem_pool_destroy (pool->frame_mem_pool);
-		if (pool->stack_mem_pool)
-			mem_pool_destroy (pool->stack_mem_pool);
-		GF_FREE (pool);
-	}
-
-	if (ret && ctx) {
-		if (ctx->stub_mem_pool)
-			mem_pool_destroy (ctx->stub_mem_pool);
-		if (ctx->dict_pool)
-			mem_pool_destroy (ctx->dict_pool);
-		if (ctx->dict_data_pool)
-			mem_pool_destroy (ctx->dict_data_pool);
-		if (ctx->dict_pair_pool)
-			mem_pool_destroy (ctx->dict_pair_pool);
-                if (ctx->logbuf_pool)
-                        mem_pool_destroy (ctx->logbuf_pool);
-	}
-
-	return ret;
-}
+    if (ret && pool) {
+        if (pool->frame_mem_pool)
+            mem_pool_destroy(pool->frame_mem_pool);
+        if (pool->stack_mem_pool)
+            mem_pool_destroy(pool->stack_mem_pool);
+        GF_FREE(pool);
+    }
+
+    if (ret && ctx) {
+        if (ctx->stub_mem_pool)
+            mem_pool_destroy(ctx->stub_mem_pool);
+        if (ctx->dict_pool)
+            mem_pool_destroy(ctx->dict_pool);
+        if (ctx->dict_data_pool)
+            mem_pool_destroy(ctx->dict_data_pool);
+        if (ctx->dict_pair_pool)
+            mem_pool_destroy(ctx->dict_pair_pool);
+        if (ctx->logbuf_pool)
+            mem_pool_destroy(ctx->logbuf_pool);
+    }
 
+    return ret;
+}
 
 static int
-create_master (struct glfs *fs)
+create_master(struct glfs *fs)
 {
-	int		 ret = 0;
-	xlator_t	*master = NULL;
-
-	master = GF_CALLOC (1, sizeof (*master),
-			    glfs_mt_xlator_t);
-	if (!master)
-		goto err;
+    int ret = 0;
+    xlator_t *master = NULL;
 
-	master->name = gf_strdup ("gfapi");
-	if (!master->name)
-		goto err;
+    master = GF_CALLOC(1, sizeof(*master), glfs_mt_xlator_t);
+    if (!master)
+        goto err;
 
-	if (xlator_set_type (master, "mount/api") == -1) {
-		gf_msg ("glfs", GF_LOG_ERROR, 0,
-                        API_MSG_MASTER_XLATOR_INIT_FAILED, "master xlator "
-                        "for %s initialization failed", fs->volname);
-		goto err;
-	}
+    master->name = gf_strdup("gfapi");
+    if (!master->name)
+        goto err;
 
-	master->ctx	 = fs->ctx;
-	master->private	 = fs;
-	master->options	 = get_new_dict ();
-	if (!master->options)
-		goto err;
+    if (xlator_set_type(master, "mount/api") == -1) {
+        gf_smsg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED,
+                "name=%s", fs->volname, NULL);
+        goto err;
+    }
 
+    master->ctx = fs->ctx;
+    master->private = fs;
+    master->options = dict_new();
+    if (!master->options)
+        goto err;
 
-	ret = xlator_init (master);
-	if (ret) {
-		gf_msg ("glfs", GF_LOG_ERROR, 0,
-                        API_MSG_GFAPI_XLATOR_INIT_FAILED,
-			"failed to initialize gfapi translator");
-		goto err;
-	}
+    ret = xlator_init(master);
+    if (ret) {
+        gf_smsg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,
+                NULL);
+        goto err;
+    }
 
-	fs->ctx->master = master;
-	THIS = master;
+    fs->ctx->master = master;
+    THIS = master;
 
-	return 0;
+    return 0;
 
 err:
-	if (master) {
-		xlator_destroy (master);
-	}
+    if (master) {
+        xlator_destroy(master);
+    }
 
-	return -1;
+    return -1;
 }
 
-
 static FILE *
-get_volfp (struct glfs *fs)
+get_volfp(struct glfs *fs)
 {
-	cmd_args_t  *cmd_args = NULL;
-	FILE	    *specfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    FILE *specfp = NULL;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
-		gf_msg ("glfs", GF_LOG_ERROR, errno,
-                        API_MSG_VOLFILE_OPEN_FAILED,
-			"volume file %s open failed: %s",
-			cmd_args->volfile,
-			strerror (errno));
-		return NULL;
-	}
+    if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {
+        gf_smsg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED,
+                "file=%s", cmd_args->volfile, "err=%s", strerror(errno), NULL);
+        return NULL;
+    }
 
-	gf_msg_debug ("glfs", 0, "loading volume file %s", cmd_args->volfile);
+    gf_msg_debug("glfs", 0, "loading volume file %s", cmd_args->volfile);
 
-	return specfp;
+    return specfp;
 }
 
-
 int
-glfs_volumes_init (struct glfs *fs)
+glfs_volumes_init(struct glfs *fs)
 {
-	FILE		   *fp = NULL;
-	cmd_args_t	   *cmd_args = NULL;
-	int		    ret = 0;
+    FILE *fp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if (!vol_assigned (cmd_args))
-		return -1;
+    if (!vol_assigned(cmd_args))
+        return -1;
 
-	if (cmd_args->volfile_server) {
-		ret = glfs_mgmt_init (fs);
-		goto out;
-	}
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        fs->ctx->secure_mgmt = 1;
+        fs->ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
 
-	fp = get_volfp (fs);
+    if (cmd_args->volfile_server) {
+        ret = glfs_mgmt_init(fs);
+        goto out;
+    }
 
-	if (!fp) {
-		gf_msg ("glfs", GF_LOG_ERROR, ENOENT,
-                        API_MSG_VOL_SPEC_FILE_ERROR,
-			"Cannot reach volume specification file");
-		ret = -1;
-		goto out;
-	}
+    fp = get_volfp(fs);
+
+    if (!fp) {
+        gf_smsg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR,
+                NULL);
+        ret = -1;
+        goto out;
+    }
 
-	ret = glfs_process_volfp (fs, fp);
-	if (ret)
-		goto out;
+    ret = glfs_process_volfp(fs, fp);
+    if (ret)
+        goto out;
 
 out:
-	return ret;
+    return ret;
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_xlator_option, 3.4.0)
 int
-pub_glfs_set_xlator_option (struct glfs *fs, const char *xlator,
-                            const char *key, const char *value)
+pub_glfs_set_xlator_option(struct glfs *fs, const char *xlator, const char *key,
+                           const char *value)
 {
-	xlator_cmdline_option_t *option = NULL;
+    xlator_cmdline_option_t *option = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	option = GF_CALLOC (1, sizeof (*option),
-			    glfs_mt_xlator_cmdline_option_t);
-	if (!option)
-		goto enomem;
+    option = GF_CALLOC(1, sizeof(*option), glfs_mt_xlator_cmdline_option_t);
+    if (!option)
+        goto enomem;
 
-	INIT_LIST_HEAD (&option->cmd_args);
+    INIT_LIST_HEAD(&option->cmd_args);
 
-	option->volume = gf_strdup (xlator);
-	if (!option->volume)
-		goto enomem;
-	option->key = gf_strdup (key);
-	if (!option->key)
-		goto enomem;
-	option->value = gf_strdup (value);
-	if (!option->value)
-		goto enomem;
+    option->volume = gf_strdup(xlator);
+    if (!option->volume)
+        goto enomem;
+    option->key = gf_strdup(key);
+    if (!option->key)
+        goto enomem;
+    option->value = gf_strdup(value);
+    if (!option->value)
+        goto enomem;
 
-	list_add (&option->cmd_args, &fs->ctx->cmd_args.xlator_options);
+    list_add(&option->cmd_args, &fs->ctx->cmd_args.xlator_options);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return 0;
+    return 0;
 enomem:
-	errno = ENOMEM;
+    errno = ENOMEM;
 
-	if (!option) {
-                __GLFS_EXIT_FS;
-		return -1;
-        }
+    if (!option) {
+        __GLFS_EXIT_FS;
+        return -1;
+    }
 
-	GF_FREE (option->volume);
-	GF_FREE (option->key);
-	GF_FREE (option->value);
-	GF_FREE (option);
+    GF_FREE(option->volume);
+    GF_FREE(option->key);
+    GF_FREE(option->value);
+    GF_FREE(option);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return -1;
+    return -1;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_xlator_option, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unset_volfile_server, 3.5.1)
 int
-pub_glfs_unset_volfile_server (struct glfs *fs, const char *transport,
-                               const char *host, const int port)
+pub_glfs_unset_volfile_server(struct glfs *fs, const char *transport,
+                              const char *host, const int port)
 {
-        cmd_args_t       *cmd_args = NULL;
-        server_cmdline_t *server = NULL;
-        server_cmdline_t *tmp = NULL;
-        char             *transport_val = NULL;
-        int               port_val = 0;
-        int               ret = -1;
-
-        if (!fs || !host) {
-                errno = EINVAL;
-                return ret;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        cmd_args = &fs->ctx->cmd_args;
-
-        if (transport) {
-                transport_val = gf_strdup (transport);
-        } else {
-                transport_val = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT);
-        }
-
-        if (!transport_val) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (port) {
-                port_val = port;
-        } else {
-                port_val = GF_DEFAULT_BASE_PORT;
-        }
-
-        list_for_each_entry_safe (server, tmp,
-                                  &cmd_args->curr_server->list,
-                                  list) {
-                if ((!strcmp(server->volfile_server, host) &&
-                     !strcmp(server->transport, transport_val) &&
-                     (server->port == port_val))) {
-                        list_del (&server->list);
-                        ret = 0;
-                        goto out;
-                }
+    cmd_args_t *cmd_args = NULL;
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+    char *transport_val = NULL;
+    int port_val = 0;
+    int ret = -1;
+
+    if (!fs || !host) {
+        errno = EINVAL;
+        return ret;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    cmd_args = &fs->ctx->cmd_args;
+
+    if (transport) {
+        transport_val = gf_strdup(transport);
+    } else {
+        transport_val = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+    }
+
+    if (!transport_val) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (port) {
+        port_val = port;
+    } else {
+        port_val = GF_DEFAULT_BASE_PORT;
+    }
+
+    list_for_each_entry_safe(server, tmp, &cmd_args->curr_server->list, list)
+    {
+        if (!server->volfile_server || !server->transport)
+            continue;
+        if ((!strcmp(server->volfile_server, host) &&
+             !strcmp(server->transport, transport_val) &&
+             (server->port == port_val))) {
+            list_del(&server->list);
+            ret = 0;
+            goto out;
         }
+    }
 
 out:
-        GF_FREE (transport_val);
-        __GLFS_EXIT_FS;
+    GF_FREE(transport_val);
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unset_volfile_server, 3.5.1);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0)
 int
-pub_glfs_set_volfile_server (struct glfs *fs, const char *transport,
-                             const char *host, int port)
+pub_glfs_set_volfile_server(struct glfs *fs, const char *transport,
+                            const char *host, int port)
 {
-        cmd_args_t            *cmd_args = NULL;
-        server_cmdline_t      *server = NULL;
-        server_cmdline_t      *tmp = NULL;
-        int                    ret = -1;
-
-        if (!fs || !host) {
-                errno = EINVAL;
-                return ret;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        cmd_args = &fs->ctx->cmd_args;
-
-        cmd_args->max_connect_attempts = 1;
-
-        server = GF_CALLOC (1, sizeof (server_cmdline_t),
-                            glfs_mt_server_cmdline_t);
-
-        if (!server) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&server->list);
-
-        server->volfile_server = gf_strdup (host);
-        if (!server->volfile_server) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (transport) {
-                /* volfile fetch support over tcp|unix only */
-                if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) {
-                        server->transport = gf_strdup (transport);
-                } else if (!strcmp(transport, "rdma")) {
-                        server->transport = gf_strdup ("tcp");
-                        gf_msg ("glfs", GF_LOG_WARNING, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-                                "transport RDMA is deprecated, "
-                                "falling back to tcp");
-                } else {
-                        gf_msg ("glfs", GF_LOG_TRACE, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-                                "transport %s is not supported, "
-                                "possible values tcp|unix",
-                                transport);
-                        ret = -1;
-                        goto out;
-                }
-        } else {
-                server->transport = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT);
-        }
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+    char *server_host = NULL;
+    char *server_transport = NULL;
 
-        if (!server->transport) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (strcmp(server->transport, "unix")) {
-                if (port) {
-                        server->port = port;
-                } else {
-                        server->port = GF_DEFAULT_BASE_PORT;
-                }
+    if (!fs || !host) {
+        errno = EINVAL;
+        return ret;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    cmd_args = &fs->ctx->cmd_args;
+    cmd_args->max_connect_attempts = 1;
+
+    server_host = gf_strdup(host);
+    if (!server_host) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (transport) {
+        /* volfile fetch support over tcp|unix only */
+        if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) {
+            server_transport = gf_strdup(transport);
+        } else if (!strcmp(transport, "rdma")) {
+            server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+            gf_smsg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_TRANS_RDMA_DEP,
+                    NULL);
         } else {
-                server->port = 0;
-        }
-
-        if (!cmd_args->volfile_server) {
-                cmd_args->volfile_server = server->volfile_server;
-                cmd_args->volfile_server_transport = server->transport;
-                cmd_args->volfile_server_port = server->port;
-                cmd_args->curr_server = server;
+            gf_smsg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_TRANS_NOT_SUPPORTED,
+                    "transport=%s", transport, NULL);
+            goto out;
         }
+    } else {
+        server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+    }
+
+    if (!server_transport) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (!port) {
+        port = GF_DEFAULT_BASE_PORT;
+    }
+
+    if (!strcmp(server_transport, "unix")) {
+        port = 0;
+    }
+
+    ret = gf_set_volfile_server_common(cmd_args, server_host, server_transport,
+                                       port);
+    if (ret) {
+        gf_log("glfs", GF_LOG_ERROR, "failed to set volfile server: %s",
+               strerror(errno));
+    }
 
-        list_for_each_entry(tmp, &cmd_args->volfile_servers, list) {
-                if ((!strcmp(tmp->volfile_server, server->volfile_server) &&
-                     !strcmp(tmp->transport, server->transport) &&
-                     (tmp->port == server->port))) {
-                        errno = EEXIST;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        list_add_tail (&server->list, &cmd_args->volfile_servers);
-
-        ret = 0;
 out:
-        if (ret == -1) {
-                if (server) {
-                        GF_FREE (server->volfile_server);
-                        GF_FREE (server->transport);
-                        GF_FREE (server);
-                }
-        }
+    if (server_host) {
+        GF_FREE(server_host);
+    }
 
-        __GLFS_EXIT_FS;
+    if (server_transport) {
+        GF_FREE(server_transport);
+    }
+
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0);
-
 /* *
  * Used to free the arguments allocated by glfs_set_volfile_server()
  */
-void
-glfs_free_volfile_servers (cmd_args_t *cmd_args)
+static void
+glfs_free_volfile_servers(cmd_args_t *cmd_args)
 {
-        server_cmdline_t *server = NULL;
-        server_cmdline_t *tmp = NULL;
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out);
+
+    list_for_each_entry_safe(server, tmp, &cmd_args->volfile_servers, list)
+    {
+        list_del_init(&server->list);
+        GF_FREE(server->volfile_server);
+        GF_FREE(server->transport);
+        GF_FREE(server);
+    }
+    cmd_args->curr_server = NULL;
+out:
+    return;
+}
 
-        GF_VALIDATE_OR_GOTO (THIS->name, cmd_args, out);
+static void
+glfs_free_xlator_options(cmd_args_t *cmd_args)
+{
+    xlator_cmdline_option_t *xo = NULL;
+    xlator_cmdline_option_t *tmp_xo = NULL;
 
-        list_for_each_entry_safe (server, tmp, &cmd_args->volfile_servers,
-                                  list) {
-                list_del_init (&server->list);
-                GF_FREE (server->volfile_server);
-                GF_FREE (server->transport);
-                GF_FREE (server);
-        }
-        cmd_args->curr_server = NULL;
-out:
+    if (!&(cmd_args->xlator_options))
         return;
+
+    list_for_each_entry_safe(xo, tmp_xo, &cmd_args->xlator_options, cmd_args)
+    {
+        list_del_init(&xo->cmd_args);
+        GF_FREE(xo->volume);
+        GF_FREE(xo->key);
+        GF_FREE(xo->value);
+        GF_FREE(xo);
+    }
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsuid, 3.4.2)
 int
-pub_glfs_setfsuid (uid_t fsuid)
+pub_glfs_setfsuid(uid_t fsuid)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsuid (&fsuid);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsuid(&fsuid);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsuid, 3.4.2);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2)
+int
+pub_glfs_setfsgid(gid_t fsgid)
+{
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgid(&fsgid);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2)
 int
-pub_glfs_setfsgid (gid_t fsgid)
+pub_glfs_setfsgroups(size_t size, const gid_t *list)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgid (&fsgid);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgroups(size, list);
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0)
+int
+pub_glfs_setfsleaseid(glfs_leaseid_t leaseid)
+{
+    int ret = -1;
+    char *gleaseid = NULL;
+
+    gleaseid = gf_leaseid_get();
+    if (gleaseid) {
+        if (leaseid)
+            memcpy(gleaseid, leaseid, LEASE_ID_SIZE);
+        else /* reset leaseid */
+            memset(gleaseid, 0, LEASE_ID_SIZE);
+        ret = 0;
+    }
 
+    if (ret)
+        gf_log("glfs", GF_LOG_ERROR, "failed to set leaseid: %s",
+               strerror(errno));
+    return ret;
+}
 
 int
-pub_glfs_setfsgroups (size_t size, const gid_t *list)
+get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgroups(size, list);
+    char *leaseid = NULL;
+    int ret = 0;
+    gf_boolean_t dict_create = _gf_false;
+
+    leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char);
+    GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out);
+    memcpy(leaseid, glfd->lease_id, LEASE_ID_SIZE);
+    if (*fop_attr == NULL) {
+        *fop_attr = dict_new();
+        dict_create = _gf_true;
+    }
+    GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
+    ret = dict_set_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);
+out:
+    if (ret) {
+        GF_FREE(leaseid);
+        if (dict_create) {
+            if (*fop_attr)
+                dict_unref(*fop_attr);
+            *fop_attr = NULL;
+        }
+    }
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2);
+int
+set_fop_attr_glfd(struct glfs_fd *glfd)
+{
+    char *lease_id = NULL;
+    int ret = -1;
 
+    lease_id = gf_existing_leaseid();
+    if (lease_id) {
+        memcpy(glfd->lease_id, lease_id, LEASE_ID_SIZE);
+        ret = 0;
+    }
+    return ret;
+}
 
-struct glfs *
-pub_glfs_from_glfd (struct glfs_fd *glfd)
+int
+get_fop_attr_thrd_key(dict_t **fop_attr)
 {
-	return glfd->fs;
+    char *existing_leaseid = NULL, *leaseid = NULL;
+    int ret = 0;
+    gf_boolean_t dict_create = _gf_false;
+
+    existing_leaseid = gf_existing_leaseid();
+    if (existing_leaseid) {
+        leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char);
+        GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed",
+                               out);
+        memcpy(leaseid, existing_leaseid, LEASE_ID_SIZE);
+        if (*fop_attr == NULL) {
+            *fop_attr = dict_new();
+            dict_create = _gf_true;
+        }
+        GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
+        ret = dict_set_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);
+    }
+
+out:
+    if (ret) {
+        GF_FREE(leaseid);
+        if (dict_create) {
+            if (*fop_attr)
+                dict_unref(*fop_attr);
+            *fop_attr = NULL;
+        }
+    }
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0);
+void
+unset_fop_attr(dict_t **fop_attr)
+{
+    char *lease_id = NULL;
+    lease_id = gf_existing_leaseid();
+    if (lease_id)
+        memset(lease_id, 0, LEASE_ID_SIZE);
+    if (*fop_attr) {
+        dict_unref(*fop_attr);
+        *fop_attr = NULL;
+    }
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0)
+struct glfs *
+pub_glfs_from_glfd(struct glfs_fd *glfd)
+{
+    if (glfd == NULL) {
+        errno = EBADF;
+        return NULL;
+    }
+
+    return glfd->fs;
+}
 
 static void
-glfs_fd_destroy (struct glfs_fd *glfd)
+glfs_fd_destroy(struct glfs_fd *glfd)
 {
-        if (!glfd)
-                return;
+    if (!glfd)
+        return;
 
-        glfs_lock (glfd->fs, _gf_true);
-        {
-                list_del_init (&glfd->openfds);
-        }
-        glfs_unlock (glfd->fs);
+    glfs_lock(glfd->fs, _gf_true);
+    {
+        list_del_init(&glfd->openfds);
+    }
+    glfs_unlock(glfd->fs);
 
-        if (glfd->fd) {
-                fd_unref (glfd->fd);
-                glfd->fd = NULL;
-        }
+    if (glfd->fd) {
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
 
-        GF_FREE (glfd->readdirbuf);
+    GF_FREE(glfd->readdirbuf);
 
-        GF_FREE (glfd);
+    GF_FREE(glfd);
 }
 
-
 struct glfs_fd *
-glfs_fd_new (struct glfs *fs)
+glfs_fd_new(struct glfs *fs)
 {
-	struct glfs_fd  *glfd = NULL;
+    struct glfs_fd *glfd = NULL;
 
-	glfd = GF_CALLOC (1, sizeof (*glfd), glfs_mt_glfs_fd_t);
-	if (!glfd)
-		return NULL;
+    glfd = GF_CALLOC(1, sizeof(*glfd), glfs_mt_glfs_fd_t);
+    if (!glfd)
+        return NULL;
 
-	glfd->fs = fs;
+    glfd->fs = fs;
 
-	INIT_LIST_HEAD (&glfd->openfds);
+    INIT_LIST_HEAD(&glfd->openfds);
 
-        GF_REF_INIT (glfd, glfs_fd_destroy);
+    GF_REF_INIT(glfd, glfs_fd_destroy);
 
-	return glfd;
+    return glfd;
 }
 
-
 void
-glfs_fd_bind (struct glfs_fd *glfd)
+glfs_fd_bind(struct glfs_fd *glfd)
 {
-	struct glfs *fs = NULL;
+    struct glfs *fs = NULL;
 
-	fs = glfd->fs;
+    fs = glfd->fs;
 
-        glfs_lock (fs, _gf_true);
-	{
-		list_add_tail (&glfd->openfds, &fs->openfds);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        list_add_tail(&glfd->openfds, &fs->openfds);
+    }
+    glfs_unlock(fs);
 }
 
-
 static void *
-glfs_poller (void *data)
+glfs_poller(void *data)
 {
-	struct glfs  *fs = NULL;
+    struct glfs *fs = NULL;
 
-	fs = data;
+    fs = data;
 
-	event_dispatch (fs->ctx->event_pool);
+    gf_event_dispatch(fs->ctx->event_pool);
 
-	return NULL;
+    return NULL;
 }
 
 static struct glfs *
-glfs_new_fs (const char *volname)
+glfs_new_fs(const char *volname)
 {
-        struct glfs     *fs             = NULL;
+    struct glfs *fs = NULL;
 
-        fs = CALLOC (1, sizeof (*fs));
-        if (!fs)
-                return NULL;
+    fs = CALLOC(1, sizeof(*fs));
+    if (!fs)
+        return NULL;
 
-        INIT_LIST_HEAD (&fs->openfds);
-        INIT_LIST_HEAD (&fs->upcall_list);
+    INIT_LIST_HEAD(&fs->openfds);
+    INIT_LIST_HEAD(&fs->upcall_list);
+    INIT_LIST_HEAD(&fs->waitq);
 
-        PTHREAD_MUTEX_INIT (&fs->mutex, NULL, fs->pthread_flags,
-                            GLFS_INIT_MUTEX, err);
+    PTHREAD_MUTEX_INIT(&fs->mutex, NULL, fs->pthread_flags, GLFS_INIT_MUTEX,
+                       err);
 
-        PTHREAD_COND_INIT (&fs->cond, NULL, fs->pthread_flags,
-                           GLFS_INIT_COND, err);
+    PTHREAD_COND_INIT(&fs->cond, NULL, fs->pthread_flags, GLFS_INIT_COND, err);
 
-        PTHREAD_COND_INIT (&fs->child_down_cond, NULL, fs->pthread_flags,
-                           GLFS_INIT_COND_CHILD, err);
+    PTHREAD_COND_INIT(&fs->child_down_cond, NULL, fs->pthread_flags,
+                      GLFS_INIT_COND_CHILD, err);
 
-        PTHREAD_MUTEX_INIT (&fs->upcall_list_mutex, NULL, fs->pthread_flags,
-                            GLFS_INIT_MUTEX_UPCALL, err);
+    PTHREAD_MUTEX_INIT(&fs->upcall_list_mutex, NULL, fs->pthread_flags,
+                       GLFS_INIT_MUTEX_UPCALL, err);
 
-        fs->volname = strdup (volname);
-        if (!fs->volname)
-                goto err;
+    fs->volname = strdup(volname);
+    if (!fs->volname)
+        goto err;
 
-        fs->pin_refcnt = 0;
+    fs->pin_refcnt = 0;
+    fs->upcall_events = 0;
+    fs->up_cbk = NULL;
+    fs->up_data = NULL;
 
-        return fs;
+    return fs;
 
 err:
-        glfs_free_from_ctx (fs);
-        return NULL;
+    glfs_free_from_ctx(fs);
+    return NULL;
 }
 
 extern xlator_t global_xlator;
@@ -694,850 +774,1033 @@ extern glusterfs_ctx_t *global_ctx;
 extern pthread_mutex_t global_ctx_mutex;
 
 static int
-glfs_init_global_ctx ()
+glfs_init_global_ctx()
 {
-        int              ret = 0;
-        glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
 
-        pthread_mutex_lock (&global_ctx_mutex);
-        {
-                if (global_xlator.ctx)
-                        goto unlock;
+    pthread_mutex_lock(&global_ctx_mutex);
+    {
+        if (global_xlator.ctx)
+            goto unlock;
 
-                ctx = glusterfs_ctx_new ();
-                if (!ctx) {
-                        ret = -1;
-                        goto unlock;
-                }
+        ctx = glusterfs_ctx_new();
+        if (!ctx) {
+            ret = -1;
+            goto unlock;
+        }
 
-                gf_log_globals_init (ctx, GF_LOG_NONE);
+        gf_log_globals_init(ctx, GF_LOG_NONE);
 
-                global_ctx = ctx;
-                global_xlator.ctx = global_ctx;
+        global_ctx = ctx;
+        global_xlator.ctx = global_ctx;
 
-                ret = glusterfs_ctx_defaults_init (ctx);
-                if (ret) {
-                        global_ctx = NULL;
-                        global_xlator.ctx = NULL;
-                        goto unlock;
-                }
+        ret = glusterfs_ctx_defaults_init(ctx);
+        if (ret) {
+            global_ctx = NULL;
+            global_xlator.ctx = NULL;
+            goto unlock;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&global_ctx_mutex);
+    pthread_mutex_unlock(&global_ctx_mutex);
 
-        if (ret)
-                FREE (ctx);
+    if (ret)
+        FREE(ctx);
 
-        return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_new, 3.4.0)
 struct glfs *
-pub_glfs_new (const char *volname)
+pub_glfs_new(const char *volname)
 {
-	struct glfs     *fs             = NULL;
-	int              ret            = -1;
-	glusterfs_ctx_t *ctx            = NULL;
-        xlator_t        *old_THIS       = NULL;
-
-        if (!volname) {
-                errno = EINVAL;
-                return NULL;
+    if (!volname) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    struct glfs *fs = NULL;
+    int i = 0;
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *old_THIS = NULL;
+    char pname[16] = "";
+    char msg[32] = "";
+
+    if (volname[0] == '/' || volname[0] == '-') {
+        if (strncmp(volname, "/snaps/", 7) == 0) {
+            goto label;
         }
+        errno = EINVAL;
+        return NULL;
+    }
 
-        /*
-         * Do this as soon as possible in case something else depends on
-         * pool allocations.
-         */
-        mem_pools_init_early ();
-        mem_pools_init_late ();
+    for (i = 0; i < strlen(volname); i++) {
+        if (!isalnum(volname[i]) && (volname[i] != '_') &&
+            (volname[i] != '-')) {
+            errno = EINVAL;
+            return NULL;
+        }
+    }
 
-        fs = glfs_new_fs (volname);
-        if (!fs)
-                goto out;
+label:
+    /*
+     * Do this as soon as possible in case something else depends on
+     * pool allocations.
+     */
+    mem_pools_init();
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                goto out;
+    fs = glfs_new_fs(volname);
+    if (!fs)
+        goto out;
 
-        /* first globals init, for gf_mem_acct_enable_set () */
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        goto out;
 
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                goto out;
+    /* first globals init, for gf_mem_acct_enable_set () */
 
-        old_THIS = THIS;
-        ret = glfs_init_global_ctx ();
-        if (ret)
-                goto out;
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        goto out;
 
-        /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */
+    old_THIS = THIS;
+    ret = glfs_init_global_ctx();
+    if (ret)
+        goto out;
 
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
+    /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */
 
-        fs->ctx = ctx;
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        ret = glfs_set_logging (fs, "/dev/null", 0);
-        if (ret)
-                goto out;
+    fs->ctx = ctx;
+    fs->ctx->process_mode = GF_CLIENT_PROCESS;
 
-        fs->ctx->cmd_args.volfile_id = gf_strdup (volname);
-        if (!(fs->ctx->cmd_args.volfile_id)) {
-                ret = -1;
-                goto out;
-        }
+    ret = glfs_set_logging(fs, "/dev/null", 0);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    fs->ctx->cmd_args.volfile_id = gf_strdup(volname);
+    if (!(fs->ctx->cmd_args.volfile_id)) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = -1;
+#ifdef GF_LINUX_HOST_OS
+    ret = prctl(PR_GET_NAME, (unsigned long)pname, 0, 0, 0);
+#endif
+    if (ret)
+        fs->ctx->cmd_args.process_name = gf_strdup("gfapi");
+    else {
+        snprintf(msg, sizeof(msg), "gfapi.%s", pname);
+        fs->ctx->cmd_args.process_name = gf_strdup(msg);
+    }
+    ret = 0;
 
 out:
-        if (ret) {
-                if (fs) {
-                        glfs_fini (fs);
-                        fs = NULL;
-                } else {
-                        /* glfs_fini() calls mem_pools_fini() too */
-                        mem_pools_fini ();
-                }
+    if (ret) {
+        if (fs) {
+            glfs_fini(fs);
+            fs = NULL;
+        } else {
+            /* glfs_fini() calls mem_pools_fini() too */
+            mem_pools_fini();
         }
+    }
 
-        if (old_THIS)
-                THIS = old_THIS;
+    if (old_THIS)
+        THIS = old_THIS;
 
-        return fs;
+    return fs;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_new, 3.4.0);
-
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_new_from_ctx, 3.7.0)
 struct glfs *
-priv_glfs_new_from_ctx (glusterfs_ctx_t *ctx)
+priv_glfs_new_from_ctx(glusterfs_ctx_t *ctx)
 {
-        struct glfs    *fs = NULL;
+    struct glfs *fs = NULL;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        fs = glfs_new_fs ("");
-        if (!fs)
-                goto out;
+    fs = glfs_new_fs("");
+    if (!fs)
+        goto out;
 
-        fs->ctx = ctx;
+    fs->ctx = ctx;
 
 out:
-        return fs;
+    return fs;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_new_from_ctx, 3.7.0);
-
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_free_from_ctx, 3.7.0)
 void
-priv_glfs_free_from_ctx (struct glfs *fs)
+priv_glfs_free_from_ctx(struct glfs *fs)
 {
-        upcall_entry       *u_list   = NULL;
-        upcall_entry       *tmp      = NULL;
-
-        if (!fs)
-                return;
-
-        /* cleanup upcall structures */
-        list_for_each_entry_safe (u_list, tmp,
-                                  &fs->upcall_list,
-                                  upcall_list) {
-                list_del_init (&u_list->upcall_list);
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE (u_list);
-        }
+    upcall_entry *u_list = NULL;
+    upcall_entry *tmp = NULL;
 
-        PTHREAD_MUTEX_DESTROY (&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX);
+    if (!fs)
+        return;
 
-        PTHREAD_COND_DESTROY (&fs->cond, fs->pthread_flags, GLFS_INIT_COND);
+    /* cleanup upcall structures */
+    list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list)
+    {
+        list_del_init(&u_list->upcall_list);
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    }
 
-        PTHREAD_COND_DESTROY (&fs->child_down_cond, fs->pthread_flags,
-                              GLFS_INIT_COND_CHILD);
+    PTHREAD_MUTEX_DESTROY(&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX);
 
-        PTHREAD_MUTEX_DESTROY (&fs->upcall_list_mutex, fs->pthread_flags,
-                               GLFS_INIT_MUTEX_UPCALL);
+    PTHREAD_COND_DESTROY(&fs->cond, fs->pthread_flags, GLFS_INIT_COND);
 
-        FREE (fs->volname);
+    PTHREAD_COND_DESTROY(&fs->child_down_cond, fs->pthread_flags,
+                         GLFS_INIT_COND_CHILD);
 
-        FREE (fs);
-}
+    PTHREAD_MUTEX_DESTROY(&fs->upcall_list_mutex, fs->pthread_flags,
+                          GLFS_INIT_MUTEX_UPCALL);
+
+    if (fs->oldvolfile)
+        FREE(fs->oldvolfile);
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_free_from_ctx, 3.7.0);
+    FREE(fs->volname);
 
+    FREE(fs);
+}
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile, 3.4.0)
 int
-pub_glfs_set_volfile (struct glfs *fs, const char *volfile)
+pub_glfs_set_volfile(struct glfs *fs, const char *volfile)
 {
-	cmd_args_t  *cmd_args = NULL;
+    cmd_args_t *cmd_args = NULL;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if (vol_assigned (cmd_args))
-		return -1;
+    if (vol_assigned(cmd_args))
+        return -1;
 
-	cmd_args->volfile = gf_strdup (volfile);
-        if (!cmd_args->volfile)
-                return -1;
-	return 0;
+    cmd_args->volfile = gf_strdup(volfile);
+    if (!cmd_args->volfile)
+        return -1;
+    return 0;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_logging, 3.4.0)
 int
-pub_glfs_set_logging (struct glfs *fs, const char *logfile, int loglevel)
+pub_glfs_set_logging(struct glfs *fs, const char *logfile, int loglevel)
 {
-        int              ret     = -1;
-        char            *tmplog  = NULL;
-        glusterfs_ctx_t *old_ctx = NULL;
+    int ret = -1;
+    char *tmplog = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        old_ctx = THIS->ctx;
-        THIS->ctx = fs->ctx;
-
-        if (!logfile) {
-                ret = gf_set_log_file_path (&fs->ctx->cmd_args, fs->ctx);
-                if (ret)
-                        goto out;
-                tmplog = fs->ctx->cmd_args.log_file;
-        } else {
-                tmplog = (char *)logfile;
-        }
+    if (!logfile) {
+        ret = gf_set_log_file_path(&fs->ctx->cmd_args, fs->ctx);
+        if (ret)
+            goto out;
+        tmplog = fs->ctx->cmd_args.log_file;
+    } else {
+        tmplog = (char *)logfile;
+    }
 
-        /* finish log set parameters before init */
-        if (loglevel >= 0)
-                gf_log_set_loglevel (loglevel);
+    /* finish log set parameters before init */
+    if (loglevel >= 0)
+        gf_log_set_loglevel(fs->ctx, loglevel);
 
-        ret = gf_log_init (fs->ctx, tmplog, NULL);
-        if (ret)
-                goto out;
+    ret = gf_log_init(fs->ctx, tmplog, NULL);
+    if (ret)
+        goto out;
 
-        ret = gf_log_inject_timer_event (fs->ctx);
-        if (ret)
-                goto out;
+    ret = gf_log_inject_timer_event(fs->ctx);
+    if (ret)
+        goto out;
 
 out:
-        THIS->ctx = old_ctx;
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_logging, 3.4.0);
-
-
 int
-glfs_init_wait (struct glfs *fs)
+glfs_init_wait(struct glfs *fs)
 {
-	int   ret = -1;
-
-	/* Always a top-down call, use glfs_lock() */
-        glfs_lock (fs, _gf_true);
-	{
-		while (!fs->init)
-			pthread_cond_wait (&fs->cond,
-					   &fs->mutex);
-		ret = fs->ret;
-		errno = fs->err;
-	}
-	glfs_unlock (fs);
-
-	return ret;
+    int ret = -1;
+
+    /* Always a top-down call, use glfs_lock() */
+    glfs_lock(fs, _gf_true);
+    {
+        while (!fs->init)
+            pthread_cond_wait(&fs->cond, &fs->mutex);
+        ret = fs->ret;
+        errno = fs->err;
+    }
+    glfs_unlock(fs);
+
+    return ret;
 }
 
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_init_done, 3.4.0)
 void
-priv_glfs_init_done (struct glfs *fs, int ret)
+priv_glfs_init_done(struct glfs *fs, int ret)
 {
-	glfs_init_cbk init_cbk;
-
-	if (!fs) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL,
-			"fs is NULL");
-		goto out;
-	}
-
-	init_cbk = fs->init_cbk;
-
-	/* Always a bottom-up call, use mutex_lock() */
-	pthread_mutex_lock (&fs->mutex);
-	{
-		fs->init = 1;
-		fs->ret = ret;
-		fs->err = errno;
-
-		if (!init_cbk)
-			pthread_cond_broadcast (&fs->cond);
-	}
-	pthread_mutex_unlock (&fs->mutex);
-
-	if (init_cbk)
-		init_cbk (fs, ret);
-out:
-	return;
-}
+    glfs_init_cbk init_cbk;
+
+    if (!fs) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL, NULL);
+        goto out;
+    }
+
+    init_cbk = fs->init_cbk;
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_init_done, 3.4.0);
+    /* Always a bottom-up call, use mutex_lock() */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->init = 1;
+        fs->ret = ret;
+        fs->err = errno;
 
+        if (!init_cbk)
+            pthread_cond_broadcast(&fs->cond);
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    if (init_cbk)
+        init_cbk(fs, ret);
+out:
+    return;
+}
 
 int
-glfs_init_common (struct glfs *fs)
+glfs_init_common(struct glfs *fs)
 {
-	int  ret = -1;
+    int ret = -1;
 
-	ret = create_master (fs);
-	if (ret)
-		return ret;
+    ret = create_master(fs);
+    if (ret)
+        return ret;
 
-	ret = gf_thread_create (&fs->poller, NULL, glfs_poller, fs, "glfspoll");
-	if (ret)
-		return ret;
+    ret = gf_thread_create(&fs->poller, NULL, glfs_poller, fs, "glfspoll");
+    if (ret)
+        return ret;
 
-	ret = glfs_volumes_init (fs);
-	if (ret)
-		return ret;
+    ret = glfs_volumes_init(fs);
+    if (ret)
+        return ret;
 
-	fs->dev_id = gf_dm_hashfn (fs->volname, strlen (fs->volname));
-	return ret;
+    fs->dev_id = gf_dm_hashfn(fs->volname, strlen(fs->volname));
+    return ret;
 }
 
-
 int
-glfs_init_async (struct glfs *fs, glfs_init_cbk cbk)
+glfs_init_async(struct glfs *fs, glfs_init_cbk cbk)
 {
-	int  ret = -1;
+    int ret = -1;
 
-	if (!fs || !fs->ctx) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-			"fs is not properly initialized.");
-		errno = EINVAL;
-		return ret;
-	}
+    if (!fs || !fs->ctx) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_FS_NOT_INIT, NULL);
+        errno = EINVAL;
+        return ret;
+    }
 
-	fs->init_cbk = cbk;
+    fs->init_cbk = cbk;
 
-	ret = glfs_init_common (fs);
+    ret = glfs_init_common(fs);
 
-	return ret;
+    return ret;
 }
 
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_init, 3.4.0)
 int
-pub_glfs_init (struct glfs *fs)
+pub_glfs_init(struct glfs *fs)
 {
-	int  ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
+    DECLARE_OLD_THIS;
 
-	if (!fs || !fs->ctx) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-			"fs is not properly initialized.");
-		errno = EINVAL;
-		return ret;
-	}
+    if (!fs || !fs->ctx) {
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_FS_NOT_INIT, NULL);
+        errno = EINVAL;
+        return ret;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	ret = glfs_init_common (fs);
-	if (ret)
-		goto out;
+    ret = glfs_init_common(fs);
+    if (ret)
+        goto out;
 
-	ret = glfs_init_wait (fs);
+    ret = glfs_init_wait(fs);
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        /* Set the initial current working directory to "/" */
-        if (ret >= 0) {
-                ret = glfs_chdir (fs, "/");
-        }
+    /* Set the initial current working directory to "/" */
+    if (ret >= 0) {
+        ret = glfs_chdir(fs, "/");
+    }
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_init, 3.4.0);
-
 static int
-glusterfs_ctx_destroy (glusterfs_ctx_t *ctx)
+glusterfs_ctx_destroy(glusterfs_ctx_t *ctx)
 {
-        call_pool_t       *pool            = NULL;
-        int               ret              = 0;
-        glusterfs_graph_t *trav_graph      = NULL;
-        glusterfs_graph_t *tmp             = NULL;
-
-        if (ctx == NULL)
-                return 0;
-
-        if (ctx->cmd_args.curr_server)
-                glfs_free_volfile_servers (&ctx->cmd_args);
-
-        /* For all the graphs, crawl through the xlator_t structs and free
-         * all its members except for the mem_acct member,
-         * as GF_FREE will be referencing it.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                xlator_tree_free_members (trav_graph->first);
-        }
-
-        /* Free the memory pool */
-        if (ctx->stub_mem_pool)
-                mem_pool_destroy (ctx->stub_mem_pool);
-        if (ctx->dict_pool)
-                mem_pool_destroy (ctx->dict_pool);
-        if (ctx->dict_data_pool)
-                mem_pool_destroy (ctx->dict_data_pool);
-        if (ctx->dict_pair_pool)
-                mem_pool_destroy (ctx->dict_pair_pool);
-        if (ctx->logbuf_pool)
-                mem_pool_destroy (ctx->logbuf_pool);
-
-        pool = ctx->pool;
-        if (pool) {
-                if (pool->frame_mem_pool)
-                        mem_pool_destroy (pool->frame_mem_pool);
-                if (pool->stack_mem_pool)
-                        mem_pool_destroy (pool->stack_mem_pool);
-                LOCK_DESTROY (&pool->lock);
-                GF_FREE (pool);
-        }
-
-        /* Free the event pool */
-        ret = event_pool_destroy (ctx->event_pool);
-
-        /* Free the iobuf pool */
-        iobuf_pool_destroy (ctx->iobuf_pool);
-
-        GF_FREE (ctx->process_uuid);
-        GF_FREE (ctx->cmd_args.volfile_id);
-
-        LOCK_DESTROY (&ctx->lock);
-        pthread_mutex_destroy (&ctx->notify_lock);
-        pthread_cond_destroy (&ctx->notify_cond);
-
-        /* Free all the graph structs and its containing xlator_t structs
-         * from this point there should be no reference to GF_FREE/GF_CALLOC
-         * as it will try to access mem_acct and the below funtion would
-         * have freed the same.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                glusterfs_graph_destroy_residual (trav_graph);
-        }
-
-        FREE (ctx);
-
-        return ret;
+    call_pool_t *pool = NULL;
+    int ret = 0;
+    glusterfs_graph_t *trav_graph = NULL;
+    glusterfs_graph_t *tmp = NULL;
+
+    if (ctx == NULL)
+        return 0;
+
+    if (ctx->cmd_args.curr_server)
+        glfs_free_volfile_servers(&ctx->cmd_args);
+
+    glfs_free_xlator_options(&ctx->cmd_args);
+
+    /* For all the graphs, crawl through the xlator_t structs and free
+     * all its members except for the mem_acct member,
+     * as GF_FREE will be referencing it.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        xlator_tree_free_members(trav_graph->first);
+    }
+
+    /* Free the memory pool */
+    if (ctx->stub_mem_pool)
+        mem_pool_destroy(ctx->stub_mem_pool);
+    if (ctx->dict_pool)
+        mem_pool_destroy(ctx->dict_pool);
+    if (ctx->dict_data_pool)
+        mem_pool_destroy(ctx->dict_data_pool);
+    if (ctx->dict_pair_pool)
+        mem_pool_destroy(ctx->dict_pair_pool);
+    if (ctx->logbuf_pool)
+        mem_pool_destroy(ctx->logbuf_pool);
+
+    pool = ctx->pool;
+    if (pool) {
+        if (pool->frame_mem_pool)
+            mem_pool_destroy(pool->frame_mem_pool);
+        if (pool->stack_mem_pool)
+            mem_pool_destroy(pool->stack_mem_pool);
+        LOCK_DESTROY(&pool->lock);
+        GF_FREE(pool);
+    }
+
+    /* Free the event pool */
+    ret = gf_event_pool_destroy(ctx->event_pool);
+
+    /* Free the iobuf pool */
+    iobuf_pool_destroy(ctx->iobuf_pool);
+
+    GF_FREE(ctx->process_uuid);
+    GF_FREE(ctx->cmd_args.volfile_id);
+    GF_FREE(ctx->cmd_args.process_name);
+
+    LOCK_DESTROY(&ctx->lock);
+    pthread_mutex_destroy(&ctx->notify_lock);
+    pthread_cond_destroy(&ctx->notify_cond);
+
+    /* Free all the graph structs and its containing xlator_t structs
+     * from this point there should be no reference to GF_FREE/GF_CALLOC
+     * as it will try to access mem_acct and the below function would
+     * have freed the same.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        glusterfs_graph_destroy_residual(trav_graph);
+    }
+
+    GF_FREE(ctx->statedump_path);
+    FREE(ctx);
+
+    return ret;
 }
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fini, 3.4.0)
 int
-pub_glfs_fini (struct glfs *fs)
+pub_glfs_fini(struct glfs *fs)
 {
-        int                ret = -1;
-        int                countdown = 100;
-        xlator_t           *subvol = NULL;
-        glusterfs_ctx_t    *ctx = NULL;
-        glusterfs_graph_t  *graph = NULL;
-        call_pool_t        *call_pool = NULL;
-        int                fs_init = 0;
-        int                err = -1;
-
-        DECLARE_OLD_THIS;
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        ctx = fs->ctx;
-        if (!ctx) {
-                goto free_fs;
-        }
-
-        if (ctx->mgmt) {
-                rpc_clnt_disable (ctx->mgmt);
-                ctx->mgmt = NULL;
-        }
-
-        call_pool = fs->ctx->pool;
-
-        while (countdown--) {
-                /* give some time for background frames to finish */
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        /* Do we need to increase countdown? */
-                        if ((!call_pool->cnt) && (!fs->pin_refcnt)) {
-                                gf_msg_trace ("glfs", 0,
-                                        "call_pool_cnt - %"PRId64","
-                                        "pin_refcnt - %d",
-                                        call_pool->cnt, fs->pin_refcnt);
-
-                                ctx->cleanup_started = 1;
-                                pthread_mutex_unlock (&fs->mutex);
-                                break;
-                        }
-                }
-                pthread_mutex_unlock (&fs->mutex);
-                usleep (100000);
-        }
-
-        /* leaked frames may exist, we ignore */
-
-        /*We deem glfs_fini as successful if there are no pending frames in the call
-         *pool*/
-        ret = (call_pool->cnt == 0)? 0: -1;
-
-        pthread_mutex_lock (&fs->mutex);
+    int ret = -1;
+    int countdown = 100;
+    xlator_t *subvol = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *graph = NULL;
+    call_pool_t *call_pool = NULL;
+    int fs_init = 0;
+    int err = -1;
+    struct synctask *waittask = NULL;
+
+    DECLARE_OLD_THIS;
+
+    if (!fs) {
+        errno = EINVAL;
+        goto invalid_fs;
+    }
+
+    ctx = fs->ctx;
+    if (!ctx) {
+        goto free_fs;
+    }
+
+    THIS = fs->ctx->master;
+
+    if (ctx->mgmt) {
+        rpc_clnt_disable(ctx->mgmt);
+    }
+
+    call_pool = fs->ctx->pool;
+
+    /* Wake up any suspended synctasks */
+    while (!list_empty(&fs->waitq)) {
+        waittask = list_entry(fs->waitq.next, struct synctask, waitq);
+        list_del_init(&waittask->waitq);
+        synctask_wake(waittask);
+    }
+
+    while (countdown--) {
+        /* give some time for background frames to finish */
+        pthread_mutex_lock(&fs->mutex);
         {
-                fs_init = fs->init;
+            /* Do we need to increase countdown? */
+            if ((!call_pool->cnt) && (!fs->pin_refcnt)) {
+                gf_msg_trace("glfs", 0,
+                             "call_pool_cnt - %" PRId64
+                             ","
+                             "pin_refcnt - %d",
+                             call_pool->cnt, fs->pin_refcnt);
+
+                ctx->cleanup_started = 1;
+                pthread_mutex_unlock(&fs->mutex);
+                break;
+            }
         }
-        pthread_mutex_unlock (&fs->mutex);
-
-        if (fs_init != 0) {
-                subvol = glfs_active_subvol (fs);
-                if (subvol) {
-                        /* PARENT_DOWN within glfs_subvol_done() is issued
-                           only on graph switch (new graph should activiate
-                           and decrement the extra @winds count taken in
-                           glfs_graph_setup()
-
-                           Since we are explicitly destroying,
-                           PARENT_DOWN is necessary
-                        */
-                        xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, 0);
-                        /* Here we wait for GF_EVENT_CHILD_DOWN before exiting,
-                           in case of asynchrnous cleanup
-                        */
-                        graph = subvol->graph;
-                        err = pthread_mutex_lock (&fs->mutex);
-                        if (err != 0) {
-                                gf_msg ("glfs", GF_LOG_ERROR, err,
-                                        API_MSG_FSMUTEX_LOCK_FAILED,
-                                        "pthread lock on glfs mutex, "
-                                        "returned error: (%s)", strerror (err));
-                                goto fail;
-                        }
-                        /* check and wait for CHILD_DOWN for active subvol*/
-                        {
-                                while (graph->used) {
-                                        err = pthread_cond_wait (&fs->child_down_cond,
-                                                                 &fs->mutex);
-                                        if (err != 0)
-                                                gf_msg ("glfs", GF_LOG_INFO, err,
-                                                        API_MSG_COND_WAIT_FAILED,
-                                                        "%s cond wait failed %s",
-                                                        subvol->name,
-                                                        strerror (err));
-                                }
-                        }
-
-                        err = pthread_mutex_unlock (&fs->mutex);
-                        if (err != 0) {
-                                gf_msg ("glfs", GF_LOG_ERROR, err,
-                                        API_MSG_FSMUTEX_UNLOCK_FAILED,
-                                        "pthread unlock on glfs mutex, "
-                                        "returned error: (%s)", strerror (err));
-                                goto fail;
-                        }
+        pthread_mutex_unlock(&fs->mutex);
+        gf_nanosleep(100000 * GF_US_IN_NS);
+    }
+
+    /* leaked frames may exist, we ignore */
+
+    /*We deem glfs_fini as successful if there are no pending frames in the call
+     *pool*/
+    ret = (call_pool->cnt == 0) ? 0 : -1;
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs_init = fs->init;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    if (fs_init != 0) {
+        subvol = glfs_active_subvol(fs);
+        if (subvol) {
+            /* PARENT_DOWN within glfs_subvol_done() is issued
+               only on graph switch (new graph should activiate
+               and decrement the extra @winds count taken in
+               glfs_graph_setup()
+
+               Since we are explicitly destroying,
+               PARENT_DOWN is necessary
+            */
+            xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, 0);
+            /* Here we wait for GF_EVENT_CHILD_DOWN before exiting,
+               in case of asynchrnous cleanup
+            */
+            graph = subvol->graph;
+            err = pthread_mutex_lock(&fs->mutex);
+            if (err != 0) {
+                gf_smsg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_LOCK_FAILED,
+                        "error=%s", strerror(err), NULL);
+                goto fail;
+            }
+            /* check and wait for CHILD_DOWN for active subvol*/
+            {
+                while (graph->used) {
+                    err = pthread_cond_wait(&fs->child_down_cond, &fs->mutex);
+                    if (err != 0)
+                        gf_smsg("glfs", GF_LOG_INFO, err,
+                                API_MSG_COND_WAIT_FAILED, "name=%s",
+                                subvol->name, "err=%s", strerror(err), NULL);
                 }
-                glfs_subvol_done (fs, subvol);
+            }
+
+            err = pthread_mutex_unlock(&fs->mutex);
+            if (err != 0) {
+                gf_smsg("glfs", GF_LOG_ERROR, err,
+                        API_MSG_FSMUTEX_UNLOCK_FAILED, "error=%s",
+                        strerror(err), NULL);
+                goto fail;
+            }
         }
-
-        ctx->cleanup_started = 1;
-
-        if (fs_init != 0) {
-                /* Destroy all the inode tables of all the graphs.
-                 * NOTE:
-                 * - inode objects should be destroyed before calling fini()
-                 *   of each xlator, as fini() and forget() of the xlators
-                 *   can share few common locks or data structures, calling
-                 *   fini first might destroy those required by forget
-                 *   ( eg: in quick-read)
-                 * - The call to inode_table_destroy_all is not required when
-                 *   the cleanup during graph switch is implemented to perform
-                 *   inode table destroy.
-                 */
-                inode_table_destroy_all (ctx);
-
-                /* Call fini() of all the xlators in the active graph
-                 * NOTE:
-                 * - xlator fini() should be called before destroying any of
-                 *   the threads. (eg: fini() in protocol-client uses timer
-                 *   thread) */
-                glusterfs_graph_deactivate (ctx->active);
-
-                /* Join the syncenv_processor threads and cleanup
-                 * syncenv resources*/
-                syncenv_destroy (ctx->env);
-
-                /* Join the poller thread */
-                if (event_dispatch_destroy (ctx->event_pool) < 0)
-                        ret = -1;
-        }
-
-        /* log infra has to be brought down before destroying
-         * timer registry, as logging uses timer infra
+        glfs_subvol_done(fs, subvol);
+    }
+
+    ctx->cleanup_started = 1;
+
+    if (fs_init != 0) {
+        /* Destroy all the inode tables of all the graphs.
+         * NOTE:
+         * - inode objects should be destroyed before calling fini()
+         *   of each xlator, as fini() and forget() of the xlators
+         *   can share few common locks or data structures, calling
+         *   fini first might destroy those required by forget
+         *   ( eg: in quick-read)
+         * - The call to inode_table_destroy_all is not required when
+         *   the cleanup during graph switch is implemented to perform
+         *   inode table destroy.
          */
-        if (gf_log_fini (ctx) != 0)
-                ret = -1;
+        inode_table_destroy_all(ctx);
+
+        /* Call fini() of all the xlators in the active graph
+         * NOTE:
+         * - xlator fini() should be called before destroying any of
+         *   the threads. (eg: fini() in protocol-client uses timer
+         *   thread) */
+        glusterfs_graph_deactivate(ctx->active);
+
+        /* Join the syncenv_processor threads and cleanup
+         * syncenv resources*/
+        syncenv_destroy(ctx->env);
+
+        /* Join the poller thread */
+        if (gf_event_dispatch_destroy(ctx->event_pool) < 0)
+            ret = -1;
+    }
+
+    /* Avoid dispatching events to mgmt after freed,
+     * unreference mgmt after the event_dispatch_destroy */
+    if (ctx->mgmt) {
+        rpc_clnt_unref(ctx->mgmt);
+        ctx->mgmt = NULL;
+    }
+
+    /* log infra has to be brought down before destroying
+     * timer registry, as logging uses timer infra
+     */
+    if (gf_log_fini(ctx) != 0)
+        ret = -1;
 
-        /* Join the timer thread */
-        if (fs_init != 0) {
-                gf_timer_registry_destroy (ctx);
-        }
+    /* Join the timer thread */
+    if (fs_init != 0) {
+        gf_timer_registry_destroy(ctx);
+    }
 
-        /* Destroy the context and the global pools */
-        if (glusterfs_ctx_destroy (ctx) != 0)
-                ret = -1;
+    /* Destroy the context and the global pools */
+    if (glusterfs_ctx_destroy(ctx) != 0)
+        ret = -1;
 
 free_fs:
-        glfs_free_from_ctx (fs);
+    glfs_free_from_ctx(fs);
 
-        /*
-         * Do this as late as possible in case anything else has (or
-         * grows) a dependency on mem-pool allocations.
-         */
-        mem_pools_fini ();
+    /*
+     * Do this as late as possible in case anything else has (or
+     * grows) a dependency on mem-pool allocations.
+     */
+    mem_pools_fini();
 
 fail:
-        if (!ret)
-                ret = err;
+    if (!ret)
+        ret = err;
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fini, 3.4.0);
-
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volfile, 3.6.0)
 ssize_t
-pub_glfs_get_volfile (struct glfs *fs, void *buf, size_t len)
+pub_glfs_get_volfile(struct glfs *fs, void *buf, size_t len)
 {
-        ssize_t         res = -1;
+    ssize_t res = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        glfs_lock(fs, _gf_true);
-        if (len >= fs->oldvollen) {
-                gf_msg_trace ("glfs", 0, "copying %zu to %p", len, buf);
-                memcpy(buf,fs->oldvolfile,len);
-                res = len;
-        }
-        else {
-                res = len - fs->oldvollen;
-                gf_msg_trace ("glfs", 0, "buffer is %zd too short", -res);
-        }
-        glfs_unlock(fs);
+    glfs_lock(fs, _gf_true);
+    if (len >= fs->oldvollen) {
+        gf_msg_trace("glfs", 0, "copying %zu to %p", len, buf);
+        memcpy(buf, fs->oldvolfile, len);
+        res = len;
+    } else {
+        res = len - fs->oldvollen;
+        gf_msg_trace("glfs", 0, "buffer is %zd too short", -res);
+    }
+    glfs_unlock(fs);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return res;
+    return res;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volfile, 3.6.0);
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_ipc, 3.12.0)
 int
-priv_glfs_ipc (struct glfs *fs, int opcode, void *xd_in, void **xd_out)
+priv_glfs_ipc(struct glfs *fs, int opcode, void *xd_in, void **xd_out)
 {
-	xlator_t        *subvol = NULL;
-        int             ret = -1;
+    xlator_t *subvol = NULL;
+    int ret = -1;
 
-	DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-	ret = syncop_ipc (subvol, opcode, (dict_t *) xd_in, (dict_t **) xd_out);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_ipc(subvol, opcode, (dict_t *)xd_in, (dict_t **)xd_out);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        glfs_subvol_done (fs, subvol);
-        __GLFS_EXIT_FS;
+    glfs_subvol_done(fs, subvol);
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_ipc, 3.12.0);
-
-
-void
-pub_glfs_free (void *ptr)
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_setfspid, 6.1)
+int
+priv_glfs_setfspid(struct glfs *fs, pid_t pid)
 {
-        int mem_type = 0;
-
-        mem_type = gf_get_mem_type (ptr);
-
-        switch (mem_type) {
-        case glfs_mt_upcall_entry_t:
-        {
-                struct glfs_upcall *to_free = ptr;
-
-                if (to_free->event)
-                        to_free->free_event (to_free->event);
-
-                GF_FREE (ptr);
-                break;
-        }
-        case glfs_mt_xreaddirp_stat_t:
-        {
-                struct glfs_xreaddirp_stat *to_free = ptr;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-                if (to_free->object)
-                        glfs_h_close (to_free->object);
+    cmd_args = &fs->ctx->cmd_args;
+    cmd_args->client_pid = pid;
+    cmd_args->client_pid_set = 1;
+    ret = syncopctx_setfspid(&pid);
 
-                GF_FREE (ptr);
-                break;
-        }
-        default:
-                GF_FREE (ptr);
-        }
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16);
-
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16)
+void
+pub_glfs_free(void *ptr)
+{
+    GLFS_FREE(ptr);
+}
 
-struct glfs*
-pub_glfs_upcall_get_fs (struct glfs_upcall *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_fs, 3.7.16)
+struct glfs *
+pub_glfs_upcall_get_fs(struct glfs_upcall *arg)
 {
-        return arg->fs;
+    return arg->fs;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_fs, 3.7.16);
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_reason, 3.7.16)
 enum glfs_upcall_reason
-pub_glfs_upcall_get_reason (struct glfs_upcall *arg)
+pub_glfs_upcall_get_reason(struct glfs_upcall *arg)
 {
-        return arg->reason;
+    return arg->reason;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_reason, 3.7.16);
 
-void*
-pub_glfs_upcall_get_event (struct glfs_upcall *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_event, 3.7.16)
+void *
+pub_glfs_upcall_get_event(struct glfs_upcall *arg)
 {
-        return arg->event;
+    return arg->event;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_event, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_object (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_object, 3.7.16)
+struct glfs_object *
+pub_glfs_upcall_inode_get_object(struct glfs_upcall_inode *arg)
 {
-        return arg->object;
+    return arg->object;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_object, 3.7.16);
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_flags, 3.7.16)
 uint64_t
-pub_glfs_upcall_inode_get_flags (struct glfs_upcall_inode *arg)
+pub_glfs_upcall_inode_get_flags(struct glfs_upcall_inode *arg)
 {
-        return arg->flags;
+    return arg->flags;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_flags, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_stat (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_stat, 3.7.16)
+struct stat *
+pub_glfs_upcall_inode_get_stat(struct glfs_upcall_inode *arg)
 {
-        return &arg->buf;
+    return &arg->buf;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_stat, 3.7.16);
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_expire, 3.7.16)
 uint64_t
-pub_glfs_upcall_inode_get_expire (struct glfs_upcall_inode *arg)
+pub_glfs_upcall_inode_get_expire(struct glfs_upcall_inode *arg)
 {
-        return arg->expire_time_attr;
+    return arg->expire_time_attr;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_expire, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_pobject (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pobject, 3.7.16)
+struct glfs_object *
+pub_glfs_upcall_inode_get_pobject(struct glfs_upcall_inode *arg)
 {
-        return arg->p_object;
+    return arg->p_object;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pobject, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_pstat (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pstat, 3.7.16)
+struct stat *
+pub_glfs_upcall_inode_get_pstat(struct glfs_upcall_inode *arg)
 {
-        return &arg->p_buf;
+    return &arg->p_buf;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pstat, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_oldpobject (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpobject, 3.7.16)
+struct glfs_object *
+pub_glfs_upcall_inode_get_oldpobject(struct glfs_upcall_inode *arg)
 {
-        return arg->oldp_object;
+    return arg->oldp_object;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpobject, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_oldpstat (struct glfs_upcall_inode *arg)
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpstat, 3.7.16)
+struct stat *
+pub_glfs_upcall_inode_get_oldpstat(struct glfs_upcall_inode *arg)
 {
-        return &arg->oldp_buf;
+    return &arg->oldp_buf;
 }
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpstat, 3.7.16);
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_object, 4.1.6)
+struct glfs_object *
+pub_glfs_upcall_lease_get_object(struct glfs_upcall_lease *arg)
+{
+    return arg->object;
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_lease_type, 4.1.6)
+uint32_t
+pub_glfs_upcall_lease_get_lease_type(struct glfs_upcall_lease *arg)
+{
+    return arg->lease_type;
+}
 
 /* definitions of the GLFS_SYSRQ_* chars are in glfs.h */
 static struct glfs_sysrq_help {
-        char  sysrq;
-        char *msg;
-} glfs_sysrq_help[] = {
-        { GLFS_SYSRQ_HELP,      "(H)elp" },
-        { GLFS_SYSRQ_STATEDUMP, "(S)tatedump" },
-        { 0,                    NULL }
-};
+    char sysrq;
+    char *msg;
+} glfs_sysrq_help[] = {{GLFS_SYSRQ_HELP, "(H)elp"},
+                       {GLFS_SYSRQ_STATEDUMP, "(S)tatedump"},
+                       {0, NULL}};
 
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_sysrq, 3.10.0)
 int
-pub_glfs_sysrq (struct glfs *fs, char sysrq)
+pub_glfs_sysrq(struct glfs *fs, char sysrq)
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        int               ret = 0;
-        char              msg[1024] = {0,}; /* should not exceed 1024 chars */
-
-        if (!fs || !fs->ctx) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    int msg_len;
+    char msg[1024] = {
+        0,
+    }; /* should not exceed 1024 chars */
+
+    if (!fs || !fs->ctx) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-        ctx = fs->ctx;
+    ctx = fs->ctx;
 
-        switch (sysrq) {
-        case GLFS_SYSRQ_HELP:
-        {
-                struct glfs_sysrq_help *usage = NULL;
+    switch (sysrq) {
+        case GLFS_SYSRQ_HELP: {
+            struct glfs_sysrq_help *usage = NULL;
 
-                for (usage = glfs_sysrq_help; usage->sysrq; usage++) {
-                        snprintf (msg + strlen (msg), /* append to msg */
-                                  sizeof (msg) - strlen (msg) - 2,
-                                  /* - 2 for the " " + terminating \0 */
-                                  " %s", usage->msg);
-                }
+            for (usage = glfs_sysrq_help; usage->sysrq; usage++) {
+                msg_len = strlen(msg);
+                snprintf(msg + msg_len, /* append to msg */
+                         sizeof(msg) - msg_len - 2,
+                         /* - 2 for the " " + terminating \0 */
+                         " %s", usage->msg);
+            }
 
-                /* not really an 'error', but make sure it gets logged */
-                gf_log ("glfs", GF_LOG_ERROR, "available events: %s", msg);
+            /* not really an 'error', but make sure it gets logged */
+            gf_log("glfs", GF_LOG_ERROR, "available events: %s", msg);
 
-                break;
+            break;
         }
         case GLFS_SYSRQ_STATEDUMP:
-                gf_proc_dump_info (SIGUSR1, ctx);
-                break;
+            gf_proc_dump_info(SIGUSR1, ctx);
+            break;
         default:
-                gf_msg ("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY,
-                        "'%c' is not a valid sysrq", sysrq);
-                errno = ENOTSUP;
-                ret = -1;
+            gf_smsg("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_SYSRQ,
+                    "sysrq=%c", sysrq, NULL);
+            errno = ENOTSUP;
+            ret = -1;
+    }
+out:
+    return ret;
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_register, 3.13.0)
+int
+pub_glfs_upcall_register(struct glfs *fs, uint32_t event_list,
+                         glfs_upcall_cbk cbk, void *data)
+{
+    int ret = 0;
+
+    /* list of supported upcall events */
+    uint32_t up_events = (GLFS_EVENT_INODE_INVALIDATE |
+                          GLFS_EVENT_RECALL_LEASE);
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    GF_VALIDATE_OR_GOTO(THIS->name, cbk, out);
+
+    /* Event list should be either GLFS_EVENT_ANY
+     * or list of supported individual events (up_events)
+     */
+    if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
+        errno = EINVAL;
+        ret = -1;
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "event_list=(0x%08x)", event_list, NULL);
+        goto out;
+    }
+
+    /* in case other thread does unregister */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
+            /* @todo: Check if features.cache-invalidation is
+             * enabled.
+             */
+            fs->upcall_events |= GF_UPCALL_CACHE_INVALIDATION;
+            ret |= GLFS_EVENT_INODE_INVALIDATE;
+        }
+        if (event_list & GLFS_EVENT_RECALL_LEASE) {
+            /* @todo: Check if features.leases is enabled */
+            fs->upcall_events |= GF_UPCALL_RECALL_LEASE;
+            ret |= GLFS_EVENT_RECALL_LEASE;
         }
+        /* Override cbk function if existing */
+        fs->up_cbk = cbk;
+        fs->up_data = data;
+        fs->cache_upcalls = _gf_true;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
 out:
-        return ret;
+    __GLFS_EXIT_FS;
+
+invalid_fs:
+    return ret;
 }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_sysrq, 3.10.0);
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_unregister, 3.13.0)
+int
+pub_glfs_upcall_unregister(struct glfs *fs, uint32_t event_list)
+{
+    int ret = 0;
+    /* list of supported upcall events */
+    uint32_t up_events = (GLFS_EVENT_INODE_INVALIDATE |
+                          GLFS_EVENT_RECALL_LEASE);
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* Event list should be either GLFS_EVENT_ANY
+     * or list of supported individual events (up_events)
+     */
+    if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
+        errno = EINVAL;
+        ret = -1;
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "event_list=(0x%08x)", event_list, NULL);
+        goto out;
+    }
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        /* We already checked if event_list contains list of supported
+         * upcall events. No other specific checks needed as of now for
+         * unregister */
+        fs->upcall_events &= ~(event_list);
+        ret |= ((event_list == GLFS_EVENT_ANY) ? up_events : event_list);
+
+        /* If there are no upcall events registered, reset cbk */
+        if (fs->upcall_events == 0) {
+            fs->up_cbk = NULL;
+            fs->up_data = NULL;
+            fs->cache_upcalls = _gf_false;
+        }
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+out:
+    __GLFS_EXIT_FS;
+
+invalid_fs:
+    return ret;
+}
+
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_statedump_path, 7.0)
+int
+pub_glfs_set_statedump_path(struct glfs *fs, const char *path)
+{
+    struct stat st;
+    int ret;
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!path) {
+        gf_log("glfs", GF_LOG_ERROR, "path is NULL");
+        errno = EINVAL;
+        goto err;
+    }
+
+    /* If path is not present OR, if it is directory AND has enough permission
+     * to create files, then proceed */
+    ret = sys_stat(path, &st);
+    if (ret && errno != ENOENT) {
+        gf_log("glfs", GF_LOG_ERROR, "%s: not a valid path (%s)", path,
+               strerror(errno));
+        errno = EINVAL;
+        goto err;
+    }
+
+    if (!ret) {
+        /* file is present, now check other things */
+        if (!S_ISDIR(st.st_mode)) {
+            gf_log("glfs", GF_LOG_ERROR, "%s: path is not directory", path);
+            errno = EINVAL;
+            goto err;
+        }
+        if (sys_access(path, W_OK | X_OK) < 0) {
+            gf_log("glfs", GF_LOG_ERROR,
+                   "%s: path doesn't have write permission", path);
+            errno = EPERM;
+            goto err;
+        }
+    }
+
+    /* If set, it needs to be freed, so we don't have leak */
+    GF_FREE(fs->ctx->statedump_path);
+
+    fs->ctx->statedump_path = gf_strdup(path);
+    if (!fs->ctx->statedump_path) {
+        gf_log("glfs", GF_LOG_ERROR,
+               "%s: failed to set statedump path, no memory", path);
+        errno = ENOMEM;
+        goto err;
+    }
+
+    __GLFS_EXIT_FS;
+
+    return 0;
+err:
+    __GLFS_EXIT_FS;
+
+invalid_fs:
+    return -1;
+}
diff --git a/api/src/glfs.h b/api/src/glfs.h
index ec3258d083a..279d11d58ee 100644
--- a/api/src/glfs.h
+++ b/api/src/glfs.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef _GLFS_H
 #define _GLFS_H
 
@@ -21,6 +20,17 @@
   both the library and the application.
 */
 
+/* Values for valid flags to be used when using XXXsetattr, to set multiple
+ attribute values passed via the related stat structure.
+ */
+
+#define GFAPI_SET_ATTR_MODE 0x1
+#define GFAPI_SET_ATTR_UID 0x2
+#define GFAPI_SET_ATTR_GID 0x4
+#define GFAPI_SET_ATTR_SIZE 0x8
+#define GFAPI_SET_ATTR_ATIME 0x10
+#define GFAPI_SET_ATTR_MTIME 0x20
+
 #ifndef _FILE_OFFSET_BITS
 #define _FILE_OFFSET_BITS 64
 #endif
@@ -41,7 +51,40 @@
 #include <sys/cdefs.h>
 #include <dirent.h>
 #include <sys/statvfs.h>
-#include <inttypes.h>
+#include <stdint.h>
+#include <sys/time.h>
+
+/*
+ * For off64_t to be defined, we need both
+ * __USE_LARGEFILE64 to be true and __off64_t_defnined to be
+ * false. But, making __USE_LARGEFILE64 true causes other issues
+ * such as redinition of stat and fstat to stat64 and fstat64
+ * respectively which again causes compilation issues.
+ * Without off64_t being defined, this will not compile as
+ * copy_file_range uses off64_t. Hence define it here. First
+ * check whether __off64_t_defined is true or not. <unistd.h>
+ * sets that flag when it defines off64_t. If __off64_t_defined
+ * is false and __USE_FILE_OFFSET64 is true, then go on to define
+ * off64_t using __off64_t.
+ */
+#ifndef GF_BSD_HOST_OS
+#if defined(__USE_FILE_OFFSET64) && !defined(__off64_t_defined)
+typedef __off64_t off64_t;
+#endif /* defined(__USE_FILE_OFFSET64) && !defined(__off64_t_defined) */
+#else
+#include <stdio.h>
+#ifndef _OFF64_T_DECLARED
+/*
+ * Including <stdio.h> (done above) should actually define
+ * _OFF64_T_DECLARED with off64_t data type being available
+ * for consumption. But, off64_t data type is not recognizable
+ * for FreeBSD versions less than 11. Hence, int64_t is typedefed
+ * to off64_t.
+ */
+#define _OFF64_T_DECLARED
+typedef int64_t off64_t;
+#endif /* _OFF64_T_DECLARED */
+#endif /* GF_BSD_HOST_OS */
 
 #if defined(HAVE_SYS_ACL_H) || (defined(USE_POSIX_ACLS) && USE_POSIX_ACLS)
 #include <sys/acl.h>
@@ -52,19 +95,20 @@ typedef int acl_type_t;
 
 /* Portability non glibc c++ build systems */
 #ifndef __THROW
-# if defined __cplusplus
-#  define __THROW       throw ()
-# else
-#  define __THROW
-# endif
+#if defined __cplusplus
+#define __THROW throw()
+#else
+#define __THROW
+#endif
 #endif
 
 #ifndef GF_DARWIN_HOST_OS
-#define GFAPI_PUBLIC(sym, ver) /**/
+#define GFAPI_PUBLIC(sym, ver)  /**/
 #define GFAPI_PRIVATE(sym, ver) /**/
 #else
 #define GFAPI_PUBLIC(sym, ver) __asm("_" __STRING(sym) "$GFAPI_" __STRING(ver))
-#define GFAPI_PRIVATE(sym, ver) __asm("_" __STRING(sym) "$GFAPI_PRIVATE_" __STRING(ver))
+#define GFAPI_PRIVATE(sym, ver)                                                \
+    __asm("_" __STRING(sym) "$GFAPI_PRIVATE_" __STRING(ver))
 #endif
 
 __BEGIN_DECLS
@@ -93,8 +137,8 @@ typedef struct glfs glfs_t;
 
   @volname: Name of the volume. This identifies the server-side volume and
             the fetched volfile (equivalent of --volfile-id command line
-	    parameter to glusterfsd). When used with glfs_set_volfile() the
-	    @volname has no effect (except for appearing in log messages).
+            parameter to glusterfsd). When used with glfs_set_volfile() the
+            @volname has no effect (except for appearing in log messages).
 
   RETURN VALUES
 
@@ -103,9 +147,8 @@ typedef struct glfs glfs_t;
 
 */
 
-glfs_t *glfs_new (const char *volname) __THROW
-        GFAPI_PUBLIC(glfs_new, 3.4.0);
-
+glfs_t *
+glfs_new(const char *volname) __THROW GFAPI_PUBLIC(glfs_new, 3.4.0);
 
 /*
   SYNOPSIS
@@ -134,9 +177,9 @@ glfs_t *glfs_new (const char *volname) __THROW
 
 */
 
-int glfs_set_volfile (glfs_t *fs, const char *volfile) __THROW
-        GFAPI_PUBLIC(glfs_set_volfile, 3.4.0);
-
+int
+glfs_set_volfile(glfs_t *fs, const char *volfile) __THROW
+    GFAPI_PUBLIC(glfs_set_volfile, 3.4.0);
 
 /*
   SYNOPSIS
@@ -187,12 +230,15 @@ int glfs_set_volfile (glfs_t *fs, const char *volfile) __THROW
 
 */
 
-int glfs_set_volfile_server (glfs_t *fs, const char *transport,
-                             const char *host, int port) __THROW
-        GFAPI_PUBLIC(glfs_set_volfile_server, 3.4.0);
-int glfs_unset_volfile_server (glfs_t *fs, const char *transport,
-                               const char *host, int port) __THROW
-        GFAPI_PUBLIC(glfs_unset_volfile_server, 3.5.1);
+int
+glfs_set_volfile_server(glfs_t *fs, const char *transport, const char *host,
+                        int port) __THROW
+    GFAPI_PUBLIC(glfs_set_volfile_server, 3.4.0);
+
+int
+glfs_unset_volfile_server(glfs_t *fs, const char *transport, const char *host,
+                          int port) __THROW
+    GFAPI_PUBLIC(glfs_unset_volfile_server, 3.5.1);
 /*
   SYNOPSIS
 
@@ -222,9 +268,9 @@ int glfs_unset_volfile_server (glfs_t *fs, const char *transport,
 
 */
 
-int glfs_set_logging (glfs_t *fs, const char *logfile, int loglevel) __THROW
-        GFAPI_PUBLIC(glfs_set_logging, 3.4.0);
-
+int
+glfs_set_logging(glfs_t *fs, const char *logfile, int loglevel) __THROW
+    GFAPI_PUBLIC(glfs_set_logging, 3.4.0);
 
 /*
   SYNOPSIS
@@ -250,9 +296,8 @@ int glfs_set_logging (glfs_t *fs, const char *logfile, int loglevel) __THROW
 
 */
 
-int glfs_init (glfs_t *fs) __THROW
-        GFAPI_PUBLIC(glfs_init, 3.4.0);
-
+int
+glfs_init(glfs_t *fs) __THROW GFAPI_PUBLIC(glfs_init, 3.4.0);
 
 /*
   SYNOPSIS
@@ -284,8 +329,8 @@ int glfs_init (glfs_t *fs) __THROW
    0 : Success.
 */
 
-int glfs_fini (glfs_t *fs) __THROW
-        GFAPI_PUBLIC(glfs_fini, 3.4.0);
+int
+glfs_fini(glfs_t *fs) __THROW GFAPI_PUBLIC(glfs_fini, 3.4.0);
 
 /*
   SYNOPSIS
@@ -315,9 +360,9 @@ int glfs_fini (glfs_t *fs) __THROW
       <0: volfile length exceeds @len by N bytes (@buf unchanged)
 */
 
-ssize_t glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
-        GFAPI_PUBLIC(glfs_get_volfile, 3.6.0);
-
+ssize_t
+glfs_get_volfile(glfs_t *fs, void *buf, size_t len) __THROW
+    GFAPI_PUBLIC(glfs_get_volfile, 3.6.0);
 
 /*
   SYNOPSIS
@@ -330,9 +375,9 @@ ssize_t glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
        the management server (glusterd) to fetch volume uuid and stores it
        in the glusterfs_context linked to the glfs object fs which can be used
        in the subsequent calls. Later it parses that UUID to convert it from
-       cannonical string format into an opaque byte array and copy it into
-       the volid array. Incase if either of the input parameters, volid or size,
-       is NULL, number of bytes required to copy the volume UUID is returned.
+       canonical string format into an opaque byte array and copy it into
+       the volid array. In case if either of the input parameters, volid or
+  size, is NULL, number of bytes required to copy the volume UUID is returned.
 
   PARAMETERS
 
@@ -347,9 +392,9 @@ ssize_t glfs_get_volfile (glfs_t *fs, void *buf, size_t len) __THROW
         Others : length of the volume UUID stored.
 */
 
-int glfs_get_volumeid (struct glfs *fs, char *volid, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_get_volumeid, 3.5.0);
-
+int
+glfs_get_volumeid(glfs_t *fs, char *volid, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_get_volumeid, 3.5.0);
 
 /*
  * FILE OPERATION
@@ -371,6 +416,119 @@ struct glfs_fd;
 typedef struct glfs_fd glfs_fd_t;
 
 /*
+ * Mask for request/result items in the struct glfs_stat.
+ *
+ * Query request/result mask for glfs_stat() (family of functions) and
+ * struct glfs_stat::glfs_st_mask.
+ *
+ * These bits should be set in the mask argument of glfs_stat() (family of
+ * functions) to request particular items when calling glfs_stat().
+ *
+ * NOTE: Lower order 32 bits are used to reflect statx(2) bits. For Gluster
+ * specific attrs/extensions, use higher order 32 bits.
+ *
+ */
+#define GLFS_STAT_TYPE 0x0000000000000001U   /* Want/got stx_mode & S_IFMT */
+#define GLFS_STAT_MODE 0x0000000000000002U   /* Want/got stx_mode & ~S_IFMT */
+#define GLFS_STAT_NLINK 0x0000000000000004U  /* Want/got stx_nlink */
+#define GLFS_STAT_UID 0x0000000000000008U    /* Want/got stx_uid */
+#define GLFS_STAT_GID 0x0000000000000010U    /* Want/got stx_gid */
+#define GLFS_STAT_ATIME 0x0000000000000020U  /* Want/got stx_atime */
+#define GLFS_STAT_MTIME 0x0000000000000040U  /* Want/got stx_mtime */
+#define GLFS_STAT_CTIME 0x0000000000000080U  /* Want/got stx_ctime */
+#define GLFS_STAT_INO 0x0000000000000100U    /* Want/got stx_ino */
+#define GLFS_STAT_SIZE 0x0000000000000200U   /* Want/got stx_size */
+#define GLFS_STAT_BLOCKS 0x0000000000000400U /* Want/got stx_blocks */
+#define GLFS_STAT_BASIC_STATS                                                  \
+    0x00000000000007ffU /* Items in the normal stat struct */
+#define GLFS_STAT_BTIME 0x0000000000000800U /* Want/got stx_btime */
+#define GLFS_STAT_ALL 0x0000000000000fffU   /* All currently supported flags */
+#define GLFS_STAT_RESERVED                                                     \
+    0x8000000000000000U /* Reserved to denote future expansion */
+
+/* Macros for checking validity of struct glfs_stat members.*/
+#define GLFS_STAT_TYPE_VALID(stmask) (stmask & GLFS_STAT_TYPE)
+#define GLFS_STAT_MODE_VALID(stmask) (stmask & GLFS_STAT_MODE)
+#define GLFS_STAT_NLINK_VALID(stmask) (stmask & GLFS_STAT_NLINK)
+#define GLFS_STAT_UID_VALID(stmask) (stmask & GLFS_STAT_UID)
+#define GLFS_STAT_GID_VALID(stmask) (stmask & GLFS_STAT_GID)
+#define GLFS_STAT_ATIME_VALID(stmask) (stmask & GLFS_STAT_ATIME)
+#define GLFS_STAT_MTIME_VALID(stmask) (stmask & GLFS_STAT_MTIME)
+#define GLFS_STAT_CTIME_VALID(stmask) (stmask & GLFS_STAT_CTIME)
+#define GLFS_STAT_INO_VALID(stmask) (stmask & GLFS_STAT_INO)
+#define GLFS_STAT_SIZE_VALID(stmask) (stmask & GLFS_STAT_SIZE)
+#define GLFS_STAT_BLOCKS_VALID(stmask) (stmask & GLFS_STAT_BLOCKS)
+#define GLFS_STAT_BTIME_VALID(stmask) (stmask & GLFS_STAT_BTIME)
+#define GLFS_STAT_GFID_VALID(stmask) (stmask & GLFS_STAT_GFID)
+
+/*
+ * Attributes to be found in glfs_st_attributes and masked in
+ * glfs_st_attributes_mask.
+ *
+ * These give information about the features or the state of a file that might
+ * be of use to programs.
+ *
+ * NOTE: Lower order 32 bits are used to reflect statx(2) attribute bits. For
+ * Gluster specific attrs, use higher order 32 bits.
+ *
+ * NOTE: We do not support any file attributes or state as yet!
+ */
+#define GLFS_STAT_ATTR_RESERVED                                                \
+    0x8000000000000000U /* Reserved to denote future expansion */
+
+/* Extended file attribute structure.
+ *
+ * The caller passes a mask of what they're specifically interested in as a
+ * parameter to glfs_stat().  What glfs_stat() actually got will be indicated
+ * in glfs_st_mask upon return.
+ *
+ * For each bit in the mask argument:
+ *
+ * - if the datum is not supported:
+ *
+ *   - the bit will be cleared, and
+ *
+ *   - the datum value is undefined
+ *
+ * - otherwise, if explicitly requested:
+ *
+ *   - the field will be filled in and the bit will be set;
+ *
+ * - otherwise, if not requested, but available in, it will be filled in
+ * anyway, and the bit will be set upon return;
+ *
+ * - otherwise the field and the bit will be cleared before returning.
+ *
+ */
+
+struct glfs_stat {
+    uint64_t glfs_st_mask;       /* What results were written [uncond] */
+    uint64_t glfs_st_attributes; /* Flags conveying information about the file
+                                    [uncond] */
+    uint64_t glfs_st_attributes_mask; /* Mask to show what's supported in
+                                         st_attributes [ucond] */
+    struct timespec glfs_st_atime;    /* Last access time */
+    struct timespec glfs_st_btime;    /* File creation time */
+    struct timespec glfs_st_ctime;    /* Last attribute change time */
+    struct timespec glfs_st_mtime;    /* Last data modification time */
+    ino_t glfs_st_ino;                /* Inode number */
+    off_t glfs_st_size;               /* File size */
+    blkcnt_t glfs_st_blocks;          /* Number of 512-byte blocks allocated */
+    uint32_t glfs_st_rdev_major; /* Device ID of special file [if bdev/cdev] */
+    uint32_t glfs_st_rdev_minor;
+    uint32_t glfs_st_dev_major; /* ID of device containing file [uncond] */
+    uint32_t glfs_st_dev_minor;
+    blksize_t glfs_st_blksize; /* Preferred general I/O size [uncond] */
+    nlink_t glfs_st_nlink;     /* Number of hard links */
+    uid_t glfs_st_uid;         /* User ID of owner */
+    gid_t glfs_st_gid;         /* Group ID of owner */
+    mode_t glfs_st_mode;       /* File mode */
+};
+
+#define GLFS_LEASE_ID_SIZE 16 /* 128bits */
+typedef char glfs_leaseid_t[GLFS_LEASE_ID_SIZE];
+
+/*
  * PER THREAD IDENTITY MODIFIERS
  *
  * The following operations enable to set a per thread identity context
@@ -387,18 +545,27 @@ typedef struct glfs_fd glfs_fd_t;
  *    caller
  *  - The groups once set, need to be unset by setting the size to 0 (in which
  *    case the list argument is a do not care)
+ *  - In case of leases feature enables, setfsleaseid is used to set and reset
+ *    leaseid before and after every I/O operation.
  *  - Once a process for a thread of operation choses to set the IDs, all glfs
  *    calls made from that thread would default to the IDs set for the thread.
  *    As a result use these APIs with care and ensure that the set IDs are
  *    reverted to global process defaults as required.
  *
  */
-int glfs_setfsuid (uid_t fsuid) __THROW
-        GFAPI_PUBLIC(glfs_setfsuid, 3.4.2);
-int glfs_setfsgid (gid_t fsgid) __THROW
-        GFAPI_PUBLIC(glfs_setfsgid, 3.4.2);
-int glfs_setfsgroups (size_t size, const gid_t *list) __THROW
-        GFAPI_PUBLIC(glfs_setfsgroups, 3.4.2);
+int
+glfs_setfsuid(uid_t fsuid) __THROW GFAPI_PUBLIC(glfs_setfsuid, 3.4.2);
+
+int
+glfs_setfsgid(gid_t fsgid) __THROW GFAPI_PUBLIC(glfs_setfsgid, 3.4.2);
+
+int
+glfs_setfsgroups(size_t size, const gid_t *list) __THROW
+    GFAPI_PUBLIC(glfs_setfsgroups, 3.4.2);
+
+int
+glfs_setfsleaseid(glfs_leaseid_t leaseid) __THROW
+    GFAPI_PUBLIC(glfs_setfsleaseid, 4.0.0);
 
 /*
   SYNOPSIS
@@ -425,9 +592,9 @@ int glfs_setfsgroups (size_t size, const gid_t *list) __THROW
 
  */
 
-glfs_fd_t *glfs_open (glfs_t *fs, const char *path, int flags) __THROW
-        GFAPI_PUBLIC(glfs_open, 3.4.0);
-
+glfs_fd_t *
+glfs_open(glfs_t *fs, const char *path, int flags) __THROW
+    GFAPI_PUBLIC(glfs_open, 3.4.0);
 
 /*
   SYNOPSIS
@@ -455,19 +622,20 @@ glfs_fd_t *glfs_open (glfs_t *fs, const char *path, int flags) __THROW
 
  */
 
-glfs_fd_t *glfs_creat (glfs_t *fs, const char *path, int flags,
-		       mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_creat, 3.4.0);
+glfs_fd_t *
+glfs_creat(glfs_t *fs, const char *path, int flags, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_creat, 3.4.0);
 
-int glfs_close (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_close, 3.4.0);
+int
+glfs_close(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_close, 3.4.0);
 
-glfs_t *glfs_from_glfd (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_from_glfd, 3.4.0);
+glfs_t *
+glfs_from_glfd(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_from_glfd, 3.4.0);
 
-int glfs_set_xlator_option (glfs_t *fs, const char *xlator, const char *key,
-			    const char *value) __THROW
-        GFAPI_PUBLIC(glfs_set_xlator_option, 3.4.0);
+int
+glfs_set_xlator_option(glfs_t *fs, const char *xlator, const char *key,
+                       const char *value) __THROW
+    GFAPI_PUBLIC(glfs_set_xlator_option, 3.4.0);
 
 /*
 
@@ -490,132 +658,190 @@ int glfs_set_xlator_option (glfs_t *fs, const char *xlator, const char *key,
   time of issuing the async IO call. This can be used by the
   caller to differentiate different instances of the async requests
   in a common callback function.
+
+  @prestat and @poststat are allocated on the stack, that are auto destroyed
+  post the callback function returns.
 */
 
-typedef void (*glfs_io_cbk) (glfs_fd_t *fd, ssize_t ret, void *data);
+typedef void (*glfs_io_cbk)(glfs_fd_t *fd, ssize_t ret,
+                            struct glfs_stat *prestat,
+                            struct glfs_stat *poststat, void *data);
 
 // glfs_{read,write}[_async]
 
-ssize_t glfs_read (glfs_fd_t *fd, void *buf,
-                   size_t count, int flags) __THROW
-        GFAPI_PUBLIC(glfs_read, 3.4.0);
-ssize_t glfs_write (glfs_fd_t *fd, const void *buf,
-                    size_t count, int flags) __THROW
-        GFAPI_PUBLIC(glfs_write, 3.4.0);
-int glfs_read_async (glfs_fd_t *fd, void *buf, size_t count, int flags,
-		     glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_read_async, 3.4.0);
-int glfs_write_async (glfs_fd_t *fd, const void *buf, size_t count, int flags,
-		      glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_write_async, 3.4.0);
+ssize_t
+glfs_read(glfs_fd_t *fd, void *buf, size_t count, int flags) __THROW
+    GFAPI_PUBLIC(glfs_read, 3.4.0);
+
+ssize_t
+glfs_write(glfs_fd_t *fd, const void *buf, size_t count, int flags) __THROW
+    GFAPI_PUBLIC(glfs_write, 3.4.0);
+
+int
+glfs_read_async(glfs_fd_t *fd, void *buf, size_t count, int flags,
+                glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_read_async, 6.0);
+
+int
+glfs_write_async(glfs_fd_t *fd, const void *buf, size_t count, int flags,
+                 glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_write_async, 6.0);
 
 // glfs_{read,write}v[_async]
 
-ssize_t glfs_readv (glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
-		    int flags) __THROW
-        GFAPI_PUBLIC(glfs_readv, 3.4.0);
-ssize_t glfs_writev (glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
-		     int flags) __THROW
-        GFAPI_PUBLIC(glfs_writev, 3.4.0);
-int glfs_readv_async (glfs_fd_t *fd, const struct iovec *iov, int count,
-		      int flags, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_readv_async, 3.4.0);
-int glfs_writev_async (glfs_fd_t *fd, const struct iovec *iov, int count,
-		       int flags, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_writev_async, 3.4.0);
+ssize_t
+glfs_readv(glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
+           int flags) __THROW GFAPI_PUBLIC(glfs_readv, 3.4.0);
+
+ssize_t
+glfs_writev(glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
+            int flags) __THROW GFAPI_PUBLIC(glfs_writev, 3.4.0);
+
+int
+glfs_readv_async(glfs_fd_t *fd, const struct iovec *iov, int count, int flags,
+                 glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_readv_async, 6.0);
+
+int
+glfs_writev_async(glfs_fd_t *fd, const struct iovec *iov, int count, int flags,
+                  glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_writev_async, 6.0);
 
 // glfs_p{read,write}[_async]
 
-ssize_t glfs_pread (glfs_fd_t *fd, void *buf, size_t count, off_t offset,
-		    int flags) __THROW
-        GFAPI_PUBLIC(glfs_pread, 3.4.0);
-ssize_t glfs_pwrite (glfs_fd_t *fd, const void *buf, size_t count,
-		     off_t offset, int flags) __THROW
-        GFAPI_PUBLIC(glfs_pwrite, 3.4.0);
-int glfs_pread_async (glfs_fd_t *fd, void *buf, size_t count, off_t offset,
-		      int flags, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_pread_async, 3.4.0);
-int glfs_pwrite_async (glfs_fd_t *fd, const void *buf, int count, off_t offset,
-		       int flags, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_pwrite_async, 3.4.0);
+ssize_t
+glfs_pread(glfs_fd_t *fd, void *buf, size_t count, off_t offset, int flags,
+           struct glfs_stat *poststat) __THROW GFAPI_PUBLIC(glfs_pread, 6.0);
+
+ssize_t
+glfs_pwrite(glfs_fd_t *fd, const void *buf, size_t count, off_t offset,
+            int flags, struct glfs_stat *prestat,
+            struct glfs_stat *poststat) __THROW GFAPI_PUBLIC(glfs_pwrite, 6.0);
+
+int
+glfs_pread_async(glfs_fd_t *fd, void *buf, size_t count, off_t offset,
+                 int flags, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_pread_async, 6.0);
+
+int
+glfs_pwrite_async(glfs_fd_t *fd, const void *buf, int count, off_t offset,
+                  int flags, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_pwrite_async, 6.0);
 
 // glfs_p{read,write}v[_async]
 
-ssize_t glfs_preadv (glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
-		     off_t offset, int flags) __THROW
-        GFAPI_PUBLIC(glfs_preadv, 3.4.0);
-ssize_t glfs_pwritev (glfs_fd_t *fd, const struct iovec *iov, int iovcnt,
-		      off_t offset, int flags) __THROW
-        GFAPI_PUBLIC(glfs_pwritev, 3.4.0);
-int glfs_preadv_async (glfs_fd_t *fd, const struct iovec *iov,
-                       int count, off_t offset, int flags,
-                       glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_preadv_async, 3.4.0);
-int glfs_pwritev_async (glfs_fd_t *fd, const struct iovec *iov,
-                        int count, off_t offset, int flags,
-                        glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_pwritev_async, 3.4.0);
+ssize_t
+glfs_preadv(glfs_fd_t *fd, const struct iovec *iov, int iovcnt, off_t offset,
+            int flags) __THROW GFAPI_PUBLIC(glfs_preadv, 3.4.0);
+
+ssize_t
+glfs_pwritev(glfs_fd_t *fd, const struct iovec *iov, int iovcnt, off_t offset,
+             int flags) __THROW GFAPI_PUBLIC(glfs_pwritev, 3.4.0);
+
+int
+glfs_preadv_async(glfs_fd_t *fd, const struct iovec *iov, int count,
+                  off_t offset, int flags, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_preadv_async, 6.0);
+
+int
+glfs_pwritev_async(glfs_fd_t *fd, const struct iovec *iov, int count,
+                   off_t offset, int flags, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_pwritev_async, 6.0);
+
+off_t
+glfs_lseek(glfs_fd_t *fd, off_t offset, int whence) __THROW
+    GFAPI_PUBLIC(glfs_lseek, 3.4.0);
+
+ssize_t
+glfs_copy_file_range(struct glfs_fd *glfd_in, off64_t *off_in,
+                     struct glfs_fd *glfd_out, off64_t *off_out, size_t len,
+                     unsigned int flags, struct glfs_stat *statbuf,
+                     struct glfs_stat *prestat,
+                     struct glfs_stat *poststat) __THROW
+    GFAPI_PUBLIC(glfs_copy_file_range, 6.0);
 
+int
+glfs_truncate(glfs_t *fs, const char *path, off_t length) __THROW
+    GFAPI_PUBLIC(glfs_truncate, 3.7.15);
+
+int
+glfs_ftruncate(glfs_fd_t *fd, off_t length, struct glfs_stat *prestat,
+               struct glfs_stat *poststat) __THROW
+    GFAPI_PUBLIC(glfs_ftruncate, 6.0);
+
+int
+glfs_ftruncate_async(glfs_fd_t *fd, off_t length, glfs_io_cbk fn,
+                     void *data) __THROW
+    GFAPI_PUBLIC(glfs_ftruncate_async, 6.0);
+
+int
+glfs_lstat(glfs_t *fs, const char *path, struct stat *buf) __THROW
+    GFAPI_PUBLIC(glfs_lstat, 3.4.0);
 
-off_t glfs_lseek (glfs_fd_t *fd, off_t offset, int whence) __THROW
-        GFAPI_PUBLIC(glfs_lseek, 3.4.0);
+int
+glfs_stat(glfs_t *fs, const char *path, struct stat *buf) __THROW
+    GFAPI_PUBLIC(glfs_stat, 3.4.0);
 
-int glfs_truncate (glfs_t *fs, const char *path, off_t length) __THROW
-        GFAPI_PUBLIC(glfs_truncate, 3.7.15);
+int
+glfs_fstat(glfs_fd_t *fd, struct stat *buf) __THROW
+    GFAPI_PUBLIC(glfs_fstat, 3.4.0);
 
-int glfs_ftruncate (glfs_fd_t *fd, off_t length) __THROW
-        GFAPI_PUBLIC(glfs_ftruncate, 3.4.0);
-int glfs_ftruncate_async (glfs_fd_t *fd, off_t length, glfs_io_cbk fn,
-			  void *data) __THROW
-        GFAPI_PUBLIC(glfs_ftruncate_async, 3.4.0);
+int
+glfs_fsync(glfs_fd_t *fd, struct glfs_stat *prestat,
+           struct glfs_stat *poststat) __THROW GFAPI_PUBLIC(glfs_fsync, 6.0);
 
-int glfs_lstat (glfs_t *fs, const char *path, struct stat *buf) __THROW
-        GFAPI_PUBLIC(glfs_lstat, 3.4.0);
-int glfs_stat (glfs_t *fs, const char *path, struct stat *buf) __THROW
-        GFAPI_PUBLIC(glfs_stat, 3.4.0);
-int glfs_fstat (glfs_fd_t *fd, struct stat *buf) __THROW
-        GFAPI_PUBLIC(glfs_fstat, 3.4.0);
+int
+glfs_fsync_async(glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_fsync_async, 6.0);
 
-int glfs_fsync (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_fsync, 3.4.0);
-int glfs_fsync_async (glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_fsync_async, 3.4.0);
+int
+glfs_fdatasync(glfs_fd_t *fd, struct glfs_stat *prestat,
+               struct glfs_stat *poststat) __THROW
+    GFAPI_PUBLIC(glfs_fdatasync, 6.0);
 
-int glfs_fdatasync (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_fdatasync, 3.4.0);
-int glfs_fdatasync_async (glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_fdatasync_async, 3.4.0);
+int
+glfs_fdatasync_async(glfs_fd_t *fd, glfs_io_cbk fn, void *data) __THROW
+    GFAPI_PUBLIC(glfs_fdatasync_async, 6.0);
 
-int glfs_access (glfs_t *fs, const char *path, int mode) __THROW
-        GFAPI_PUBLIC(glfs_access, 3.4.0);
+int
+glfs_access(glfs_t *fs, const char *path, int mode) __THROW
+    GFAPI_PUBLIC(glfs_access, 3.4.0);
 
-int glfs_symlink (glfs_t *fs, const char *oldpath, const char *newpath) __THROW
-        GFAPI_PUBLIC(glfs_symlink, 3.4.0);
+int
+glfs_symlink(glfs_t *fs, const char *oldpath, const char *newpath) __THROW
+    GFAPI_PUBLIC(glfs_symlink, 3.4.0);
 
-int glfs_readlink (glfs_t *fs, const char *path,
-                   char *buf, size_t bufsiz) __THROW
-        GFAPI_PUBLIC(glfs_readlink, 3.4.0);
+int
+glfs_readlink(glfs_t *fs, const char *path, char *buf, size_t bufsiz) __THROW
+    GFAPI_PUBLIC(glfs_readlink, 3.4.0);
 
-int glfs_mknod (glfs_t *fs, const char *path, mode_t mode, dev_t dev) __THROW
-        GFAPI_PUBLIC(glfs_mknod, 3.4.0);
+int
+glfs_mknod(glfs_t *fs, const char *path, mode_t mode, dev_t dev) __THROW
+    GFAPI_PUBLIC(glfs_mknod, 3.4.0);
 
-int glfs_mkdir (glfs_t *fs, const char *path, mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_mkdir, 3.4.0);
+int
+glfs_mkdir(glfs_t *fs, const char *path, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_mkdir, 3.4.0);
 
-int glfs_unlink (glfs_t *fs, const char *path) __THROW
-        GFAPI_PUBLIC(glfs_unlink, 3.4.0);
+int
+glfs_unlink(glfs_t *fs, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_unlink, 3.4.0);
 
-int glfs_rmdir (glfs_t *fs, const char *path) __THROW
-        GFAPI_PUBLIC(glfs_rmdir, 3.4.0);
+int
+glfs_rmdir(glfs_t *fs, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_rmdir, 3.4.0);
 
-int glfs_rename (glfs_t *fs, const char *oldpath, const char *newpath) __THROW
-        GFAPI_PUBLIC(glfs_rename, 3.4.0);
+int
+glfs_rename(glfs_t *fs, const char *oldpath, const char *newpath) __THROW
+    GFAPI_PUBLIC(glfs_rename, 3.4.0);
 
-int glfs_link (glfs_t *fs, const char *oldpath, const char *newpath) __THROW
-        GFAPI_PUBLIC(glfs_link, 3.4.0);
+int
+glfs_link(glfs_t *fs, const char *oldpath, const char *newpath) __THROW
+    GFAPI_PUBLIC(glfs_link, 3.4.0);
 
-glfs_fd_t *glfs_opendir (glfs_t *fs, const char *path) __THROW
-        GFAPI_PUBLIC(glfs_opendir, 3.4.0);
+glfs_fd_t *
+glfs_opendir(glfs_t *fs, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_opendir, 3.4.0);
 
 /*
  * @glfs_readdir_r and @glfs_readdirplus_r ARE thread safe AND re-entrant,
@@ -625,13 +851,15 @@ glfs_fd_t *glfs_opendir (glfs_t *fs, const char *path) __THROW
  * insufficient in the future.
  */
 
-int glfs_readdir_r (glfs_fd_t *fd, struct dirent *dirent,
-		    struct dirent **result) __THROW
-        GFAPI_PUBLIC(glfs_readdir_r, 3.4.0);
+int
+glfs_readdir_r(glfs_fd_t *fd, struct dirent *dirent,
+               struct dirent **result) __THROW
+    GFAPI_PUBLIC(glfs_readdir_r, 3.4.0);
 
-int glfs_readdirplus_r (glfs_fd_t *fd, struct stat *stat, struct dirent *dirent,
-			struct dirent **result) __THROW
-        GFAPI_PUBLIC(glfs_readdirplus_r, 3.4.0);
+int
+glfs_readdirplus_r(glfs_fd_t *fd, struct stat *stat, struct dirent *dirent,
+                   struct dirent **result) __THROW
+    GFAPI_PUBLIC(glfs_readdirplus_r, 3.4.0);
 
 /*
  * @glfs_readdir and @glfs_readdirplus are NEITHER thread safe NOR re-entrant
@@ -640,138 +868,201 @@ int glfs_readdirplus_r (glfs_fd_t *fd, struct stat *stat, struct dirent *dirent,
  * referring to the same directory too.)
  */
 
-struct dirent *glfs_readdir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_readdir, 3.5.0);
-
-struct dirent *glfs_readdirplus (glfs_fd_t *fd, struct stat *stat) __THROW
-        GFAPI_PUBLIC(glfs_readdirplus, 3.5.0);
+struct dirent *
+glfs_readdir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_readdir, 3.5.0);
 
-long glfs_telldir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_telldir, 3.4.0);
+struct dirent *
+glfs_readdirplus(glfs_fd_t *fd, struct stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_readdirplus, 3.5.0);
 
-void glfs_seekdir (glfs_fd_t *fd, long offset) __THROW
-        GFAPI_PUBLIC(glfs_seekdir, 3.4.0);
+long
+glfs_telldir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_telldir, 3.4.0);
 
-int glfs_closedir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_closedir, 3.4.0);
+void
+glfs_seekdir(glfs_fd_t *fd, long offset) __THROW
+    GFAPI_PUBLIC(glfs_seekdir, 3.4.0);
 
-int glfs_statvfs (glfs_t *fs, const char *path, struct statvfs *buf) __THROW
-        GFAPI_PUBLIC(glfs_statvfs, 3.4.0);
+int
+glfs_closedir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_closedir, 3.4.0);
 
-int glfs_chmod (glfs_t *fs, const char *path, mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_chmod, 3.4.0);
+int
+glfs_statvfs(glfs_t *fs, const char *path, struct statvfs *buf) __THROW
+    GFAPI_PUBLIC(glfs_statvfs, 3.4.0);
 
-int glfs_fchmod (glfs_fd_t *fd, mode_t mode) __THROW
-        GFAPI_PUBLIC(glfs_fchmod, 3.4.0);
+int
+glfs_chmod(glfs_t *fs, const char *path, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_chmod, 3.4.0);
 
-int glfs_chown (glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
-        GFAPI_PUBLIC(glfs_chown, 3.4.0);
+int
+glfs_fchmod(glfs_fd_t *fd, mode_t mode) __THROW
+    GFAPI_PUBLIC(glfs_fchmod, 3.4.0);
 
-int glfs_lchown (glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
-        GFAPI_PUBLIC(glfs_lchown, 3.4.0);
+int
+glfs_chown(glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_chown, 3.4.0);
 
-int glfs_fchown (glfs_fd_t *fd, uid_t uid, gid_t gid) __THROW
-        GFAPI_PUBLIC(glfs_fchown, 3.4.0);
+int
+glfs_lchown(glfs_t *fs, const char *path, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_lchown, 3.4.0);
 
-int glfs_utimens (glfs_t *fs, const char *path,
-                  const struct timespec times[2]) __THROW
-        GFAPI_PUBLIC(glfs_utimens, 3.4.0);
+int
+glfs_fchown(glfs_fd_t *fd, uid_t uid, gid_t gid) __THROW
+    GFAPI_PUBLIC(glfs_fchown, 3.4.0);
 
-int glfs_lutimens (glfs_t *fs, const char *path,
-                   const struct timespec times[2]) __THROW
-        GFAPI_PUBLIC(glfs_lutimens, 3.4.0);
+int
+glfs_utimens(glfs_t *fs, const char *path,
+             const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_utimens, 3.4.0);
 
-int glfs_futimens (glfs_fd_t *fd, const struct timespec times[2]) __THROW
-        GFAPI_PUBLIC(glfs_futimens, 3.4.0);
+int
+glfs_lutimens(glfs_t *fs, const char *path,
+              const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_lutimens, 3.4.0);
 
-ssize_t glfs_getxattr (glfs_t *fs, const char *path, const char *name,
-		       void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_getxattr, 3.4.0);
+int
+glfs_futimens(glfs_fd_t *fd, const struct timespec times[2]) __THROW
+    GFAPI_PUBLIC(glfs_futimens, 3.4.0);
 
-ssize_t glfs_lgetxattr (glfs_t *fs, const char *path, const char *name,
-			void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_lgetxattr, 3.4.0);
+ssize_t
+glfs_getxattr(glfs_t *fs, const char *path, const char *name, void *value,
+              size_t size) __THROW GFAPI_PUBLIC(glfs_getxattr, 3.4.0);
 
-ssize_t glfs_fgetxattr (glfs_fd_t *fd, const char *name,
-			void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_fgetxattr, 3.4.0);
+ssize_t
+glfs_lgetxattr(glfs_t *fs, const char *path, const char *name, void *value,
+               size_t size) __THROW GFAPI_PUBLIC(glfs_lgetxattr, 3.4.0);
 
-ssize_t glfs_listxattr (glfs_t *fs, const char *path,
-                        void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_listxattr, 3.4.0);
+ssize_t
+glfs_fgetxattr(glfs_fd_t *fd, const char *name, void *value,
+               size_t size) __THROW GFAPI_PUBLIC(glfs_fgetxattr, 3.4.0);
 
-ssize_t glfs_llistxattr (glfs_t *fs, const char *path, void *value,
-			 size_t size) __THROW
-        GFAPI_PUBLIC(glfs_llistxattr, 3.4.0);
+ssize_t
+glfs_listxattr(glfs_t *fs, const char *path, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_listxattr, 3.4.0);
 
-ssize_t glfs_flistxattr (glfs_fd_t *fd, void *value, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_flistxattr, 3.4.0);
+ssize_t
+glfs_llistxattr(glfs_t *fs, const char *path, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_llistxattr, 3.4.0);
 
-int glfs_setxattr (glfs_t *fs, const char *path, const char *name,
-		   const void *value, size_t size, int flags) __THROW
-        GFAPI_PUBLIC(glfs_setxattr, 3.4.0);
+ssize_t
+glfs_flistxattr(glfs_fd_t *fd, void *value, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_flistxattr, 3.4.0);
 
-int glfs_lsetxattr (glfs_t *fs, const char *path, const char *name,
-		    const void *value, size_t size, int flags) __THROW
-        GFAPI_PUBLIC(glfs_lsetxattr, 3.4.0);
+int
+glfs_setxattr(glfs_t *fs, const char *path, const char *name, const void *value,
+              size_t size, int flags) __THROW
+    GFAPI_PUBLIC(glfs_setxattr, 3.4.0);
 
-int glfs_fsetxattr (glfs_fd_t *fd, const char *name,
-		    const void *value, size_t size, int flags) __THROW
-        GFAPI_PUBLIC(glfs_fsetxattr, 3.4.0);
+int
+glfs_lsetxattr(glfs_t *fs, const char *path, const char *name,
+               const void *value, size_t size, int flags) __THROW
+    GFAPI_PUBLIC(glfs_lsetxattr, 3.4.0);
 
-int glfs_removexattr (glfs_t *fs, const char *path, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_removexattr, 3.4.0);
+int
+glfs_fsetxattr(glfs_fd_t *fd, const char *name, const void *value, size_t size,
+               int flags) __THROW GFAPI_PUBLIC(glfs_fsetxattr, 3.4.0);
 
-int glfs_lremovexattr (glfs_t *fs, const char *path, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_lremovexattr, 3.4.0);
+int
+glfs_removexattr(glfs_t *fs, const char *path, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_removexattr, 3.4.0);
 
-int glfs_fremovexattr (glfs_fd_t *fd, const char *name) __THROW
-        GFAPI_PUBLIC(glfs_fremovexattr, 3.4.0);
+int
+glfs_lremovexattr(glfs_t *fs, const char *path, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_lremovexattr, 3.4.0);
 
-int glfs_fallocate(glfs_fd_t *fd, int keep_size,
-                   off_t offset, size_t len) __THROW
-        GFAPI_PUBLIC(glfs_fallocate, 3.5.0);
+int
+glfs_fremovexattr(glfs_fd_t *fd, const char *name) __THROW
+    GFAPI_PUBLIC(glfs_fremovexattr, 3.4.0);
 
-int glfs_discard(glfs_fd_t *fd, off_t offset, size_t len) __THROW
-        GFAPI_PUBLIC(glfs_discard, 3.5.0);
+int
+glfs_fallocate(glfs_fd_t *fd, int keep_size, off_t offset, size_t len) __THROW
+    GFAPI_PUBLIC(glfs_fallocate, 3.5.0);
 
+int
+glfs_discard(glfs_fd_t *fd, off_t offset, size_t len) __THROW
+    GFAPI_PUBLIC(glfs_discard, 3.5.0);
 
-int glfs_discard_async (glfs_fd_t *fd, off_t length, size_t lent,
-			glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_discard_async, 3.5.0);
+int
+glfs_discard_async(glfs_fd_t *fd, off_t length, size_t lent, glfs_io_cbk fn,
+                   void *data) __THROW GFAPI_PUBLIC(glfs_discard_async, 6.0);
 
-int glfs_zerofill(glfs_fd_t *fd, off_t offset, off_t len) __THROW
-        GFAPI_PUBLIC(glfs_zerofill, 3.5.0);
+int
+glfs_zerofill(glfs_fd_t *fd, off_t offset, off_t len) __THROW
+    GFAPI_PUBLIC(glfs_zerofill, 3.5.0);
 
-int glfs_zerofill_async (glfs_fd_t *fd, off_t length, off_t len,
-                        glfs_io_cbk fn, void *data) __THROW
-        GFAPI_PUBLIC(glfs_zerofill_async, 3.5.0);
+int
+glfs_zerofill_async(glfs_fd_t *fd, off_t length, off_t len, glfs_io_cbk fn,
+                    void *data) __THROW GFAPI_PUBLIC(glfs_zerofill_async, 6.0);
 
-char *glfs_getcwd (glfs_t *fs, char *buf, size_t size) __THROW
-        GFAPI_PUBLIC(glfs_getcwd, 3.4.0);
+char *
+glfs_getcwd(glfs_t *fs, char *buf, size_t size) __THROW
+    GFAPI_PUBLIC(glfs_getcwd, 3.4.0);
 
-int glfs_chdir (glfs_t *fs, const char *path) __THROW
-        GFAPI_PUBLIC(glfs_chdir, 3.4.0);
+int
+glfs_chdir(glfs_t *fs, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_chdir, 3.4.0);
 
-int glfs_fchdir (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_fchdir, 3.4.0);
+int
+glfs_fchdir(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_fchdir, 3.4.0);
 
-char *glfs_realpath34 (glfs_t *fs, const char *path, char *resolved_path) __THROW
-        GFAPI_PUBLIC(glfs_realpath, 3.4.0);
+char *
+glfs_realpath(glfs_t *fs, const char *path, char *resolved_path) __THROW
+    GFAPI_PUBLIC(glfs_realpath, 3.7.17);
 
-char *glfs_realpath (glfs_t *fs, const char *path, char *resolved_path) __THROW
-        GFAPI_PUBLIC(glfs_realpath, 3.7.17);
 /*
  * @cmd and @flock are as specified in man fcntl(2).
  */
-int glfs_posix_lock (glfs_fd_t *fd, int cmd, struct flock *flock) __THROW
-        GFAPI_PUBLIC(glfs_posix_lock, 3.4.0);
+int
+glfs_posix_lock(glfs_fd_t *fd, int cmd, struct flock *flock) __THROW
+    GFAPI_PUBLIC(glfs_posix_lock, 3.4.0);
+
+/*
+  SYNOPSIS
+
+  glfs_file_lock: Request extended byte range lock on a file
+
+  DESCRIPTION
+
+  This function is capable of requesting either advisory or mandatory type
+  byte range locks on a file.
+
+  Note: To set a unique owner key for locks based on a particular file
+  descriptor, make use of glfs_fd_set_lkowner() api to do so before
+  requesting lock via this api. This owner key will be further consumed
+  by other incoming data modifying file operations via the same file
+  descriptor.
+
+  PARAMETERS
+
+  @fd: File descriptor
+
+  @cmd: As specified in man fcntl(2).
+
+  @flock: As specified in man fcntl(2).
+
+  @lk_mode: Required lock type from options available with the
+            enum glfs_lock_mode_t defined below.
+
+  RETURN VALUES
+
+  0   : Success. Lock has been granted.
+  -1  : Failure. @errno will be set indicating the type of failure.
+
+ */
+
+/* Lock modes used by glfs_file_lock() */
+enum glfs_lock_mode { GLFS_LK_ADVISORY = 0, GLFS_LK_MANDATORY };
+typedef enum glfs_lock_mode glfs_lock_mode_t;
+
+int
+glfs_file_lock(glfs_fd_t *fd, int cmd, struct flock *flock,
+               glfs_lock_mode_t lk_mode) __THROW
+    GFAPI_PUBLIC(glfs_file_lock, 3.13.0);
 
-glfs_fd_t *glfs_dup (glfs_fd_t *fd) __THROW
-        GFAPI_PUBLIC(glfs_dup, 3.4.0);
+glfs_fd_t *
+glfs_dup(glfs_fd_t *fd) __THROW GFAPI_PUBLIC(glfs_dup, 3.4.0);
 
-void glfs_free (void *ptr) __THROW
-        GFAPI_PUBLIC(glfs_free, 3.7.16);
+void
+glfs_free(void *ptr) __THROW GFAPI_PUBLIC(glfs_free, 3.7.16);
 
 /*
  * glfs_sysrq: send a system request to the @fs instance
@@ -783,29 +1074,30 @@ void glfs_free (void *ptr) __THROW
  * value does not way anythin about the result of the @sysrq execution. Not all
  * @sysrq command will be able to return a success/failure status.
  */
-int glfs_sysrq (glfs_t *fs, char sysrq) __THROW
-        GFAPI_PUBLIC(glfs_sysrq, 3.10.0);
+int
+glfs_sysrq(glfs_t *fs, char sysrq) __THROW GFAPI_PUBLIC(glfs_sysrq, 3.10.0);
 
 #define GLFS_SYSRQ_HELP 'h' /* log a message with supported sysrq commands */
 #define GLFS_SYSRQ_STATEDUMP 's' /* create a statedump */
 
-
 /*
  * Structure returned as part of xreaddirplus
  */
 struct glfs_xreaddirp_stat;
+typedef struct glfs_xreaddirp_stat glfs_xreaddirp_stat_t;
 
 /* Request flags to be used in XREADDIRP operation */
-#define GFAPI_XREADDIRP_NULL    0x00000000 /* by default, no stat will be fetched */
-#define GFAPI_XREADDIRP_STAT    0x00000001 /* Get stat */
-#define GFAPI_XREADDIRP_HANDLE  0x00000002 /* Get object handle */
+#define GFAPI_XREADDIRP_NULL                                                   \
+    0x00000000 /* by default, no stat will be fetched */
+#define GFAPI_XREADDIRP_STAT 0x00000001   /* Get stat */
+#define GFAPI_XREADDIRP_HANDLE 0x00000002 /* Get object handle */
 
 /*
  * This stat structure returned gets freed as part of glfs_free(xstat)
  */
-struct stat*
-glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat) __THROW
-        GFAPI_PUBLIC(glfs_xreaddirplus_get_stat, 3.11.0);
+struct stat *
+glfs_xreaddirplus_get_stat(glfs_xreaddirp_stat_t *xstat) __THROW
+    GFAPI_PUBLIC(glfs_xreaddirplus_get_stat, 3.11.0);
 
 /*
  * SYNOPSIS
@@ -835,7 +1127,7 @@ glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat) __THROW
  *              GFAPI_XREADDIRP_HANDLE
  * @ext: Dirent struture to copy the values to
  *       (though optional recommended to be allocated by application
- *        esp., in multi-threaded environement)
+ *        esp., in multi-threaded environment)
  *
  * OUTPUT:
  * @res: to store the next dirent value. If NULL and return value is '0',
@@ -850,10 +1142,10 @@ glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat) __THROW
  *  -1: FAILURE
  */
 int
-glfs_xreaddirplus_r (struct glfs_fd *glfd, uint32_t flags,
-                     struct glfs_xreaddirp_stat **xstat_p,
-                     struct dirent *ext, struct dirent **res);
-        GFAPI_PUBLIC(glfs_xreaddirplus_r, 3.11.0);
+glfs_xreaddirplus_r(glfs_fd_t *glfd, uint32_t flags,
+                    glfs_xreaddirp_stat_t **xstat_p, struct dirent *ext,
+                    struct dirent **res) __THROW
+    GFAPI_PUBLIC(glfs_xreaddirplus_r, 3.11.0);
 
 #define GFAPI_MAX_LOCK_OWNER_LEN 255
 
@@ -881,8 +1173,313 @@ glfs_xreaddirplus_r (struct glfs_fd *glfd, uint32_t flags,
  * 0: SUCCESS
  * -1: FAILURE
  */
-int glfs_fd_set_lkowner (glfs_fd_t *glfd, void *data, int len);
-        GFAPI_PUBLIC(glfs_fd_set_lkowner, 3.10.7);
-__END_DECLS
+int
+glfs_fd_set_lkowner(glfs_fd_t *glfd, void *data, int len) __THROW
+    GFAPI_PUBLIC(glfs_fd_set_lkowner, 3.10.7);
+
+/*
+ * Applications (currently NFS-Ganesha) can make use of this
+ * structure to read upcall notifications sent by server either
+ * by polling or registering a callback function.
+ *
+ * On success, applications need to check for 'reason' to decide
+ * if any upcall event is received.
+ *
+ * Currently supported upcall_events -
+ *      GLFS_UPCALL_INODE_INVALIDATE -
+ *              'event_arg' - glfs_upcall_inode
+ *
+ * After processing the event, applications need to free 'event_arg' with
+ * glfs_free().
+ *
+ * Also similar to I/Os, the application should ideally stop polling
+ * or unregister upcall_cbk function before calling glfs_fini(..).
+ * Hence making an assumption that 'fs' & ctx structures cannot be
+ * freed while in this routine.
+ */
+struct glfs_upcall;
+typedef struct glfs_upcall glfs_upcall_t;
+
+glfs_t *
+glfs_upcall_get_fs(glfs_upcall_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_get_fs, 3.7.16);
+
+enum glfs_upcall_reason {
+    GLFS_UPCALL_EVENT_NULL = 0,
+    GLFS_UPCALL_INODE_INVALIDATE, /* invalidate cache entry */
+    GLFS_UPCALL_RECALL_LEASE,     /* recall lease */
+};
+typedef enum glfs_upcall_reason glfs_upcall_reason_t;
+
+glfs_upcall_reason_t
+glfs_upcall_get_reason(glfs_upcall_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_get_reason, 3.7.16);
+
+/*
+ * Applications first need to make use of above API i.e,
+ * "glfs_upcall_get_reason" to determine which upcall event it has
+ * received. Post that below API - "glfs_upcall_get_event" should
+ * be used to get corresponding upcall event object.
+ *
+ * Below are the upcall_reason and corresponding upcall_event objects:
+ *      ==========================================================
+ *      glfs_upcall_reason           -    event_object
+ *      ==========================================================
+ *      GLFS_UPCALL_EVENT_NULL       -    NULL
+ *      GLFS_UPCALL_INODE_INVALIDATE -    struct glfs_upcall_inode
+ *      GLFS_UPCALL_RECALL_LEASE     -    struct glfs_upcall_lease
+ *
+ * After processing upcall event, glfs_free() should be called on the
+ * glfs_upcall.
+ */
+void *
+glfs_upcall_get_event(glfs_upcall_t *arg) __THROW
+    GFAPI_PUBLIC(glfs_upcall_get_event, 3.7.16);
+
+/*
+ * SYNOPSIS
+ *
+ * glfs_upcall_cbk: Upcall callback definition
+ *
+ * This is function type definition of the callback function pointer
+ * which has to be provided by the caller while registering for any
+ * upcall events.
+ *
+ * This function is called whenever any upcall which the application
+ * has registered for is received from the server.
+ *
+ * @up_arg: Upcall structure whose contents need to be interpreted by
+ * making use of glfs_upcall_* helper routines.
+ *
+ * @data: The same context pointer provided by the caller at the time of
+ * registering of upcall events. This may be used by the caller for any
+ * of its internal use while processing upcalls.
+ */
+typedef void (*glfs_upcall_cbk)(glfs_upcall_t *up_arg, void *data);
+
+/*
+ * List of upcall events supported by gluster/gfapi
+ */
+#define GLFS_EVENT_INODE_INVALIDATE 0x00000001 /* invalidate cache entry */
+#define GLFS_EVENT_RECALL_LEASE 0x00000002     /* Recall lease */
+#define GLFS_EVENT_ANY 0xffffffff              /* for all the above events */
+
+/*
+ * SYNOPSIS
+ *
+ * glfs_upcall_register: Register for upcall events
+ *
+ * DESCRIPTION
+ *
+ * This function is used to register for various upcall events application
+ * is interested in and the callback function to be invoked when such
+ * events are triggered.
+ *
+ * Multiple calls of this routine shall override cbk function. That means
+ * only one cbk function can be used for all the upcall events registered
+ * and that shall be the one last updated.
+ *
+ * PARAMETERS:
+ *
+ * INPUT:
+ * @fs: The 'virtual mount' object
+ *
+ * @event_list: List of upcall events to be registered.
+ *              Current available values are:
+ *               - GLFS_EVENT_INODE_INVALIDATE
+ *               - GLFS_EVENT_RECALL_LEASE
+ *
+ * @cbk: The cbk routine to be invoked in case of any upcall received
+ * @data: Any opaque pointer provided by caller which shall be using while
+ * making cbk calls. This pointer may be used by caller for any of its
+ * internal use while processing upcalls. Can be NULL.
+ *
+ * RETURN VALUE:
+ * >0: SUCCESS (value contains the events successfully registered)
+ * -1: FAILURE
+ */
+int
+glfs_upcall_register(glfs_t *fs, uint32_t event_list, glfs_upcall_cbk cbk,
+                     void *data) __THROW
+    GFAPI_PUBLIC(glfs_upcall_register, 3.13.0);
+
+/*
+ * SYNOPSIS
+ *
+ * glfs_upcall_unregister: Unregister for upcall events
+ *
+ * DESCRIPTION
+ *
+ * This function is used to unregister the upcall events application
+ * is not interested in. In case if the caller unregisters all the events
+ * it has registered for, it shall no more receive any upcall event.
+ *
+ * PARAMETERS:
+ *
+ * INPUT:
+ * @fs: The 'virtual mount' object
+ *
+ * @event_list: List of upcall events to be unregistered.
+ *              Current available values are:
+ *               - GLFS_EVENT_INODE_INVALIDATE
+ *               - GLFS_EVENT_RECALL_LEASE
+ * RETURN VALUE:
+ * >0: SUCCESS (value contains the events successfully unregistered)
+ * -1: FAILURE
+ */
+int
+glfs_upcall_unregister(glfs_t *fs, uint32_t event_list) __THROW
+    GFAPI_PUBLIC(glfs_upcall_unregister, 3.13.0);
+
+/* Lease Types */
+enum glfs_lease_types {
+    GLFS_LEASE_NONE = 0,
+    GLFS_RD_LEASE = 1,
+    GLFS_RW_LEASE = 2,
+};
+typedef enum glfs_lease_types glfs_lease_types_t;
+
+/* Lease cmds */
+enum glfs_lease_cmds {
+    GLFS_GET_LEASE = 1,
+    GLFS_SET_LEASE = 2,
+    GLFS_UNLK_LEASE = 3,
+};
+typedef enum glfs_lease_cmds glfs_lease_cmds_t;
+
+struct glfs_lease {
+    glfs_lease_cmds_t cmd;
+    glfs_lease_types_t lease_type;
+    glfs_leaseid_t lease_id;
+    unsigned int lease_flags;
+};
+typedef struct glfs_lease glfs_lease_t;
+
+typedef void (*glfs_recall_cbk)(glfs_lease_t lease, void *data);
+
+/*
+  SYNOPSIS
+
+  glfs_lease: Takes a lease on a file.
+
+  DESCRIPTION
+
+  This function takes lease on an open file.
+
+  PARAMETERS
+
+  @glfd: The fd of the file on which lease should be taken,
+   this fd is returned by glfs_open/glfs_create.
+
+  @lease: Struct that defines the lease operation to be performed
+   on the file.
+      @lease.cmd - Can be one of the following values
+         GF_GET_LEASE:  Get the lease type currently present on the file,
+                        lease.lease_type will contain GF_RD_LEASE
+                        or GF_RW_LEASE or 0 if no leases.
+         GF_SET_LEASE:  Set the lease of given lease.lease_type on the file.
+         GF_UNLK_LEASE: Unlock the lease present on the given fd.
+                        Note that the every lease request should have
+                        a corresponding unlk_lease.
+
+      @lease.lease_type - Can be one of the following values
+         GF_RD_LEASE:   Read lease on a file, shared lease.
+         GF_RW_LEASE:   Read-Write lease on a file, exclusive lease.
+
+      @lease.lease_id - A unique identification of lease, 128bits.
+
+  @fn: This is the function that is invoked when the lease has to be recalled
+  @data: It is a cookie, this pointer is returned as a part of recall
+
+  fn and data field are stored as a part of glfs_fd, hence if there are multiple
+  glfs_lease calls, each of them updates the fn and data fields. glfs_recall_cbk
+  will be invoked with the last updated fn and data
+
+  RETURN VALUES
+  0:  Successful completion
+  <0: Failure. @errno will be set with the type of failure
+*/
+
+int
+glfs_lease(glfs_fd_t *glfd, glfs_lease_t *lease, glfs_recall_cbk fn,
+           void *data) __THROW GFAPI_PUBLIC(glfs_lease, 4.0.0);
+
+/*
+  SYNOPSIS
+
+  glfs_fsetattr: Function to set attributes.
+  glfs_setattr: Function to set attributes
+
+  DESCRIPTION
+
+  The functions are used to set attributes on the file.
+
+  PARAMETERS
+
+  @glfs_fsetattr
+
+     @glfd: The fd of the file for which the attributes are to be set,
+            this fd is returned by glfs_open/glfs_create.
+
+  @glfs_setattr
+
+         @fs: File object.
+
+         @path: The path of the file that is being operated on.
 
+         @follow: Flag used to resolve symlink.
+
+
+  @stat: Struct that has information about the file.
+
+  @valid: This is the mask bit, that accepts GFAPI_SET_ATTR* masks.
+          Refer glfs.h to see the mask definitions.
+
+  Both functions are similar in functionality, just that the
+  func setattr() uses file path whereas the func fsetattr()
+  uses the fd.
+
+  RETURN VALUES
+  0:  Successful completion
+  <0: Failure. @errno will be set with the type of failure
+
+ */
+
+int
+glfs_fsetattr(struct glfs_fd *glfd, struct glfs_stat *stat) __THROW
+    GFAPI_PUBLIC(glfs_fsetattr, 6.0);
+
+int
+glfs_setattr(struct glfs *fs, const char *path, struct glfs_stat *stat,
+             int follow) __THROW GFAPI_PUBLIC(glfs_setattr, 6.0);
+
+/*
+  SYNOPSIS
+
+  glfs_set_statedump_path: Function to set statedump path.
+
+  DESCRIPTION
+
+  This function is used to set statedump directory
+
+  PARAMETERS
+
+  @fs: The 'virtual mount' object to be configured with the volume
+       specification file.
+
+  @path: statedump path. Should be a directory. But the API won't fail if the
+  directory doesn't exist yet, as one may create it later.
+
+  RETURN VALUES
+
+   0 : Success.
+  -1 : Failure. @errno will be set with the type of failure.
+
+ */
+
+int
+glfs_set_statedump_path(struct glfs *fs, const char *path) __THROW
+    GFAPI_PUBLIC(glfs_set_statedump_path, 7.0);
+
+__END_DECLS
 #endif /* !_GLFS_H */
diff --git a/autogen.sh b/autogen.sh
index 73019f29e4c..c8cdc3f89fa 100755
--- a/autogen.sh
+++ b/autogen.sh
@@ -85,11 +85,7 @@ $TOOL --automake --copy --force
 echo Running ${AUTOCONF}...
 $AUTOCONF
 echo Running ${AUTOMAKE}...
-$AUTOMAKE --add-missing --force-missing --copy --foreign
-
-# Run autogen in the argp-standalone sub-directory
-echo "Running autogen.sh in argp-standalone ..."
-( cd contrib/argp-standalone;./autogen.sh )
+$AUTOMAKE --add-missing --force-missing --copy
 
 # Instruct user on next steps
 echo
diff --git a/build-aux/checkpatch.pl b/build-aux/checkpatch.pl
index 205567307b1..17ae4e4d579 100755
--- a/build-aux/checkpatch.pl
+++ b/build-aux/checkpatch.pl
@@ -3099,7 +3099,7 @@ sub process {
             if (ERROR("SPACING",
                       "space required before the open brace '{'\n" . $herecurr) &&
                 $fix) {
-                $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
+                $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
             }
         }
 
diff --git a/build-aux/pkg-version b/build-aux/pkg-version
index 83d4a5f9136..17ceab70c03 100755
--- a/build-aux/pkg-version
+++ b/build-aux/pkg-version
@@ -1,9 +1,13 @@
-#!/bin/sh
+#!/bin/bash
 
 # To override version/release from git,
 # create VERSION file containing text with version/release
 # eg. v3.4.0-1
-PKG_VERSION=`cat VERSION 2> /dev/null || git describe --tags --match "v[0-9]*"`
+
+# One thing to note, If one does 'git clone --depth N glusterfs.git',
+# the git describe command doesn't work. Hence you notice below that
+# we have added timestamp as version (YYYY.MM.DD) and release (HH.mmss)
+PKG_VERSION=`cat VERSION 2> /dev/null || git describe --tags --match "v[0-9]*" 2>/dev/null`
 
 get_version()
 {
@@ -18,7 +22,11 @@ get_version()
       sub(/^v/,"") ; print $1
     }'
 
-    echo $PKG_VERSION | awk "$AWK_VERSION" | tr -cd '[:alnum:].'
+    version=$(echo $PKG_VERSION | awk "$AWK_VERSION" | tr -cd '[:alnum:].')
+    if [ "x${version}" == "x" ] ; then
+       version=$(date +%Y.%m.%d | tr -d '\n')
+    fi
+    echo $version | tr -d '\n'
 }
 
 get_release()
@@ -37,7 +45,11 @@ get_release()
       else if (NF == 4) print $2, $3, "git" substr($4, 2)
     }'
 
-    echo $PKG_VERSION | awk "$AWK_RELEASE" | tr -cd '[:alnum:].'
+    release=$(echo $PKG_VERSION | awk "$AWK_RELEASE" | tr -cd '[:alnum:].')
+    if [ "x${release}" == "x" ] ; then
+       release=$(date +%H.%M%S | tr -d '\n')
+    fi
+    echo $release | tr -d '\n'
 }
 
 if test "x$1" = "x--full"; then
diff --git a/cli/src/Makefile.am b/cli/src/Makefile.am
index 5ef93899fca..16063f27c7f 100644
--- a/cli/src/Makefile.am
+++ b/cli/src/Makefile.am
@@ -5,6 +5,7 @@ gluster_SOURCES = cli.c registry.c input.c cli-cmd.c cli-rl.c cli-cmd-global.c \
 	 cli-cmd-system.c cli-cmd-misc.c cli-xml-output.c cli-quotad-client.c cli-cmd-snapshot.c
 
 gluster_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la $(GF_LDADD) \
+		$(top_builddir)/libglusterd/src/libglusterd.la \
 		$(RLLIBS) $(top_builddir)/rpc/xdr/src/libgfxdr.la \
 		$(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
 		$(XML_LIBS)
@@ -13,21 +14,24 @@ gluster_LDFLAGS = $(GF_LDFLAGS)
 noinst_HEADERS = cli.h cli-mem-types.h cli-cmd.h cli-quotad-client.h
 
 AM_CPPFLAGS = $(GF_CPPFLAGS) \
-	-I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src\
-	-I$(top_srcdir)/rpc/xdr/src\
-	-I$(top_builddir)/rpc/xdr/src\
+	-I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src \
+	-I$(top_srcdir)/rpc/xdr/src -I$(top_srcdir)/libglusterd/src \
+	-I$(top_builddir)/rpc/xdr/src \
 	-DDATADIR=\"$(localstatedir)\" \
 	-DCONFDIR=\"$(sysconfdir)/glusterfs\" \
 	-DGSYNCD_PREFIX=\"$(GLUSTERFS_LIBEXECDIR)\"\
-	-DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE) -DSBIN_DIR=\"$(sbindir)\"\
-	$(XML_CPPFLAGS)
+	-DGLFSHEAL_PREFIX=\"$(GLUSTERFS_LIBEXECDIR)\"\
+	-DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE)
 
-AM_CFLAGS = -Wall $(GF_CFLAGS)
+AM_CFLAGS = -Wall $(GF_CFLAGS) $(XML_CFLAGS)
 
 CLEANFILES =
 
 $(top_builddir)/libglusterfs/src/libglusterfs.la:
 	$(MAKE) -C $(top_builddir)/libglusterfs/src/ all
 
+$(top_builddir)/libglusterd/src/libglusterd.la:
+	$(MAKE) -C $(top_builddir)/libglusterd/src/ all
+
 install-data-hook:
 	$(mkdir_p) $(DESTDIR)$(localstatedir)/run/gluster
diff --git a/cli/src/cli-cmd-global.c b/cli/src/cli-cmd-global.c
index fb2ecb1d3de..2c9a5f01bb1 100644
--- a/cli/src/cli-cmd-global.c
+++ b/cli/src/cli-cmd-global.c
@@ -23,118 +23,173 @@
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
 #include "cli1-xdr.h"
-#include "run.h"
-#include "syscall.h"
-#include "common-utils.h"
-
-extern rpc_clnt_prog_t *cli_rpc_prog;
+#include <glusterfs/run.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/common-utils.h>
 
 int
-cli_cmd_global_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
+cli_cmd_global_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
+int
+cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount);
+
 int
-cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount);
+cli_cmd_ganesha_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount);
 
 struct cli_cmd global_cmds[] = {
-        { "global help",
-           cli_cmd_global_help_cbk,
-           "list global commands",
-        },
-        { "get-state [<daemon>] [[odir </path/to/output/dir/>] "
-          "[file <filename>]] [detail|volumeoptions]",
-          cli_cmd_get_state_cbk,
-          "Get local state representation of mentioned daemon",
-        },
-        {NULL,  NULL,  NULL}
-};
+    {
+        "global help",
+        cli_cmd_global_help_cbk,
+        "list global commands",
+    },
+    {
+        "get-state [<daemon>] [[odir </path/to/output/dir/>] "
+        "[file <filename>]] [detail|volumeoptions]",
+        cli_cmd_get_state_cbk,
+        "Get local state representation of mentioned daemon",
+    },
+    {
+        "nfs-ganesha {enable| disable} ",
+        cli_cmd_ganesha_cbk,
+        "Enable/disable NFS-Ganesha support",
+    },
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_global_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount)
+cli_cmd_global_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *global_cmd = NULL;
-        int                   count     = 0;
-
-        cmd = GF_CALLOC (1, sizeof (global_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, global_cmds, sizeof (global_cmds));
-        count = (sizeof (global_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
-
-        cli_out ("\ngluster global commands");
-        cli_out ("========================\n");
-        for (global_cmd = cmd; global_cmd->pattern; global_cmd++)
-                if (_gf_false == global_cmd->disable)
-                        cli_out ("%s - %s", global_cmd->pattern,
-                                 global_cmd->desc);
-
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *global_cmd = NULL;
+    int count = 0;
+
+    cmd = GF_MALLOC(sizeof(global_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, global_cmds, sizeof(global_cmds));
+    count = (sizeof(global_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
+
+    cli_out("\ngluster global commands");
+    cli_out("========================\n");
+    for (global_cmd = cmd; global_cmd->pattern; global_cmd++)
+        if (_gf_false == global_cmd->disable)
+            cli_out("%s - %s", global_cmd->pattern, global_cmd->desc);
+
+    cli_out("\n");
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_global_register (struct cli_state *state)
+cli_cmd_global_register(struct cli_state *state)
 {
-        int ret = 0;
-        struct cli_cmd *cmd =  NULL;
-        for (cmd = global_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                        if (ret)
-                                goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+    for (cmd = global_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
+}
+
+int
+cli_cmd_ganesha_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount)
+
+{
+    int sent = 0;
+    int parse_error = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    char *op_errstr = NULL;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GANESHA];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    ret = cli_cmd_ganesha_parse(state, words, wordcount, &options, &op_errstr);
+    if (ret) {
+        if (op_errstr) {
+            cli_err("%s", op_errstr);
+            GF_FREE(op_errstr);
+        } else
+            cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
+out:
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Setting global option failed");
+    }
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                     sent        =   0;
-        int                     parse_error =   0;
-        int                     ret         =  -1;
-        rpc_clnt_procedure_t    *proc       =  NULL;
-        call_frame_t            *frame      =  NULL;
-        dict_t                  *options    =  NULL;
-        cli_local_t             *local      =  NULL;
-        char                    *op_errstr  =  NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_get_state_parse (state, words, wordcount, &options,
-                                       &op_errstr);
-
-        if (ret) {
-                if (op_errstr) {
-                        cli_err ("%s", op_errstr);
-                        cli_usage_out (word->pattern);
-                        GF_FREE (op_errstr);
-                } else
-                        cli_usage_out (word->pattern);
-
-                parse_error = 1;
-                goto out;
-        }
-
-        CLI_LOCAL_INIT (local, words, frame, options);
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_STATE];
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    int sent = 0;
+    int parse_error = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    char *op_errstr = NULL;
+
+    ret = cli_cmd_get_state_parse(state, words, wordcount, &options,
+                                  &op_errstr);
+
+    if (ret) {
+        if (op_errstr) {
+            cli_err("%s", op_errstr);
+            cli_usage_out(word->pattern);
+            GF_FREE(op_errstr);
+        } else
+            cli_usage_out(word->pattern);
+
+        parse_error = 1;
+        goto out;
+    }
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_STATE];
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Getting daemon state failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Getting daemon state failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
-
diff --git a/cli/src/cli-cmd-misc.c b/cli/src/cli-cmd-misc.c
index c887515af85..e961d88da86 100644
--- a/cli/src/cli-cmd-misc.c
+++ b/cli/src/cli-cmd-misc.c
@@ -18,14 +18,9 @@
 #include "cli-mem-types.h"
 #include "protocol-common.h"
 
-extern struct rpc_clnt *global_rpc;
-
-extern rpc_clnt_prog_t *cli_rpc_prog;
-
 extern struct cli_cmd volume_cmds[];
 extern struct cli_cmd bitrot_cmds[];
 extern struct cli_cmd quota_cmds[];
-extern struct cli_cmd tier_cmds[];
 extern struct cli_cmd cli_probe_cmds[];
 extern struct cli_cmd cli_log_cmds[];
 extern struct cli_cmd cli_system_cmds[];
@@ -35,107 +30,88 @@ extern struct cli_cmd global_cmds[];
 struct cli_cmd cli_misc_cmds[];
 
 int
-cli_cmd_quit_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_quit_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                 const char **words, int wordcount)
 {
-        exit (0);
+    exit(0);
 }
 
-
 static gf_boolean_t
-cli_is_help_command (const char *pattern)
+cli_is_help_command(const char *pattern)
 {
-        /* FixFixFix
-         * This is not the best way to determine whether
-         * this is a help command
-         */
-        if (strstr (pattern, "help"))
-                return _gf_true;
-
-        return _gf_false;
+    /* FixFixFix
+     * This is not the best way to determine whether
+     * this is a help command
+     */
+    if (strstr(pattern, "help"))
+        return _gf_true;
+
+    return _gf_false;
 }
 
-
 int
-cli_cmd_display_help (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount)
+cli_cmd_display_help(struct cli_state *state, struct cli_cmd_word *in_word,
+                     const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd[] = {cli_misc_cmds, cli_probe_cmds,
-                                        volume_cmds, bitrot_cmds, quota_cmds,
-#if !defined(__NetBSD__)
-                                        tier_cmds,
-#endif
-                                        snapshot_cmds, global_cmds, NULL};
-        struct cli_cmd        *cmd_ind      = NULL;
-        int                    i            = 0;
-        gf_boolean_t           list_all     = _gf_false;
-
-         /* cli_system_cmds commands for internal usage
-           they are not exposed
-         */
-
-        /* If "help all" */
-        if (wordcount == 2)
-                list_all = _gf_true;
-
-        for (i = 0; cmd[i] != NULL; i++) {
-                for (cmd_ind = cmd[i]; cmd_ind->pattern; cmd_ind++) {
-                        if ((_gf_false == cmd_ind->disable) &&
-                            cli_is_help_command (cmd_ind->pattern)) {
-                                if (list_all && (cmd_ind->cbk)) {
-                                        cmd_ind->cbk (state, in_word, words,
-                                                      wordcount);
-                                } else {
-                                        cli_out (" %-25s- %s", cmd_ind->pattern,
-                                                 cmd_ind->desc);
-                                }
-                        }
+    static struct cli_cmd *cmd[] = {
+        cli_misc_cmds, cli_probe_cmds, volume_cmds, bitrot_cmds,
+        quota_cmds,    snapshot_cmds,  global_cmds, NULL};
+    struct cli_cmd *cmd_ind = NULL;
+    int i = 0;
+    gf_boolean_t list_all = _gf_false;
+
+    /* cli_system_cmds commands for internal usage
+      they are not exposed
+    */
+
+    /* If "help all" */
+    if (wordcount == 2)
+        list_all = _gf_true;
+
+    for (i = 0; cmd[i] != NULL; i++) {
+        for (cmd_ind = cmd[i]; cmd_ind->pattern; cmd_ind++) {
+            if ((_gf_false == cmd_ind->disable) &&
+                cli_is_help_command(cmd_ind->pattern)) {
+                if (list_all && (cmd_ind->cbk)) {
+                    cmd_ind->cbk(state, in_word, words, wordcount);
+                } else {
+                    cli_out(" %-25s- %s", cmd_ind->pattern, cmd_ind->desc);
                 }
+            }
         }
+    }
 
-        cli_out ("\n");
-        return 0;
+    cli_out("\n");
+    return 0;
 }
 
-
 struct cli_cmd cli_help_cmds[] = {
-        { "help [all]",
-           cli_cmd_display_help,
-           "display help for command classes"},
-
-        { NULL, NULL, NULL }
-};
+    {"help [all]", cli_cmd_display_help, "display help for command classes"},
 
+    {NULL, NULL, NULL}};
 
-struct cli_cmd cli_misc_cmds[] = {
-        { "quit",
-          cli_cmd_quit_cbk,
-          "quit"},
-        { "exit",
-          cli_cmd_quit_cbk,
-          "exit"},
-
-        { NULL, NULL, NULL }
-};
+struct cli_cmd cli_misc_cmds[] = {{"quit", cli_cmd_quit_cbk, "quit"},
+                                  {"exit", cli_cmd_quit_cbk, "exit"},
 
+                                  {NULL, NULL, NULL}};
 
 int
-cli_cmd_misc_register (struct cli_state *state)
+cli_cmd_misc_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_misc_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
-
-        for (cmd = cli_help_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+
+    for (cmd = cli_misc_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
+
+    for (cmd = cli_help_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c
index 6eee72e2d16..34620b4a31b 100644
--- a/cli/src/cli-cmd-parser.c
+++ b/cli/src/cli-cmd-parser.c
@@ -18,2642 +18,2751 @@
 #include "cli.h"
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
-#include "dict.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/list.h>
 
 #include "protocol-common.h"
 #include "cli1-xdr.h"
 
 #define MAX_SNAP_DESCRIPTION_LEN 1024
 
-struct snap_config_opt_vals_ snap_confopt_vals[] = {
-        {.op_name        = "snap-max-hard-limit",
-         .question       = "Changing snapshot-max-hard-limit "
-                           "will limit the creation of new snapshots "
-                           "if they exceed the new limit.\n"
-                           "Do you want to continue?"
-        },
-        {.op_name        = "snap-max-soft-limit",
-         .question       = "If Auto-delete is enabled, snap-max-soft-limit will"
-                           " trigger deletion of oldest snapshot, on the "
-                           "creation of new snapshot, when the "
-                           "snap-max-soft-limit is reached.\n"
-                           "Do you want to change the snap-max-soft-limit?"
-        },
-        {.op_name        = "both",
-        .question        = "Changing snapshot-max-hard-limit "
-                           "will limit the creation of new snapshots "
-                           "if they exceed the new snapshot-max-hard-limit.\n"
-                           "If Auto-delete is enabled, snap-max-soft-limit will"
-                           " trigger deletion of oldest snapshot, on the "
-                           "creation of new snapshot, when the "
-                           "snap-max-soft-limit is reached.\n"
-                           "Do you want to continue?"
-        },
-        {.op_name        = NULL,
-        }
-};
+static struct snap_config_opt_vals_ snap_confopt_vals[] = {
+    {.op_name = "snap-max-hard-limit",
+     .question = "Changing snapshot-max-hard-limit "
+                 "will limit the creation of new snapshots "
+                 "if they exceed the new limit.\n"
+                 "Do you want to continue?"},
+    {.op_name = "snap-max-soft-limit",
+     .question = "If Auto-delete is enabled, snap-max-soft-limit will"
+                 " trigger deletion of oldest snapshot, on the "
+                 "creation of new snapshot, when the "
+                 "snap-max-soft-limit is reached.\n"
+                 "Do you want to change the snap-max-soft-limit?"},
+    {.op_name = "both",
+     .question = "Changing snapshot-max-hard-limit "
+                 "will limit the creation of new snapshots "
+                 "if they exceed the new snapshot-max-hard-limit.\n"
+                 "If Auto-delete is enabled, snap-max-soft-limit will"
+                 " trigger deletion of oldest snapshot, on the "
+                 "creation of new snapshot, when the "
+                 "snap-max-soft-limit is reached.\n"
+                 "Do you want to continue?"},
+    {
+        .op_name = NULL,
+    }};
 
 enum cli_snap_config_set_types {
-        GF_SNAP_CONFIG_SET_HARD = 0,
-        GF_SNAP_CONFIG_SET_SOFT = 1,
-        GF_SNAP_CONFIG_SET_BOTH = 2,
+    GF_SNAP_CONFIG_SET_HARD = 0,
+    GF_SNAP_CONFIG_SET_SOFT = 1,
+    GF_SNAP_CONFIG_SET_BOTH = 2,
 };
 typedef enum cli_snap_config_set_types cli_snap_config_set_types;
 
+typedef struct _cli_brick {
+    struct list_head list;
+    const char *name;
+    int32_t len;
+} cli_brick_t;
+
 int
-cli_cmd_validate_volume (char *volname);
+cli_cmd_validate_volume(char *volname);
 
 static const char *
-id_sel (void *wcon)
+id_sel(void *wcon)
 {
-        return (const char *)wcon;
+    return (const char *)wcon;
 }
 
 static char *
-str_getunamb (const char *tok, char **opwords)
+str_getunamb(const char *tok, char **opwords)
 {
-        return (char *)cli_getunamb (tok, (void **)opwords, id_sel);
+    return (char *)cli_getunamb(tok, (void **)opwords, id_sel);
 }
 
 int32_t
-cli_cmd_bricks_parse (const char **words, int wordcount, int brick_index,
-                      char **bricks, int *brick_count)
+cli_cmd_ta_brick_parse(const char **words, int wordcount, char **ta_brick)
 {
-        int                    ret = 0;
-        char             *tmp_list = NULL;
-        char    brick_list[120000] = {0,};
-        char                *space = " ";
-        char            *delimiter = NULL;
-        char            *host_name = NULL;
-        char        *free_list_ptr = NULL;
-        char               *tmpptr = NULL;
-        int                      j = 0;
-        int         brick_list_len = 0;
-        char             *tmp_host = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (wordcount);
-        GF_ASSERT (bricks);
-        GF_ASSERT (brick_index > 0);
-        GF_ASSERT (brick_index < wordcount);
-
-        strncpy (brick_list, space, strlen (space));
-        brick_list_len++;
-        while (brick_index < wordcount) {
-                if (validate_brick_name ((char *)words[brick_index])) {
-                        cli_err ("Wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[brick_index]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        delimiter = strrchr (words[brick_index], ':');
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-
-                if ((brick_list_len + strlen (words[brick_index]) + 1) > sizeof (brick_list)) {
-                        cli_err ("Total brick list is larger than a request. "
-                                 "Can take (brick_count %d)", *brick_count);
-                        ret = -1;
-                        goto out;
-                }
+    char *host_name = NULL;
+    char *tmp_host = NULL;
+    char *delimiter = NULL;
+    cli_brick_t *brick = NULL;
+    int ret = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(wordcount);
+
+    if (validate_brick_name((char *)words[wordcount - 1])) {
+        cli_err(
+            "Wrong brick type: %s, use <HOSTNAME>:"
+            "<export-dir-abs-path>",
+            words[wordcount - 1]);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr(words[wordcount - 1], ':');
+        ret = gf_canonicalize_path(delimiter + 1);
+        if (ret)
+            goto out;
+    }
 
-                tmp_host = gf_strdup ((char *)words[brick_index]);
-                if (!tmp_host) {
-                        gf_log ("cli", GF_LOG_ERROR, "Out of memory");
-                        ret = -1;
-                        goto out;
-                }
-                get_host_name (tmp_host, &host_name);
-                if (!host_name) {
-                        ret = -1;
-                        gf_log("cli",GF_LOG_ERROR, "Unable to allocate "
-                               "memory");
-                        goto out;
-                }
+    tmp_host = gf_strdup((char *)words[wordcount - 1]);
+    if (!tmp_host) {
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        ret = -1;
+        goto out;
+    }
+    get_host_name(tmp_host, &host_name);
+    if (!host_name) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to retrieve "
+               "hostname");
+        goto out;
+    }
+
+    if (!(strcmp(host_name, "localhost") && strcmp(host_name, "127.0.0.1") &&
+          strncmp(host_name, "0.", 2))) {
+        cli_err(
+            "Please provide a valid hostname/ip other "
+            "than localhost, 127.0.0.1 or loopback "
+            "address (0.0.0.0 to 0.255.255.255).");
+        ret = -1;
+        goto out;
+    }
+    if (!valid_internet_address(host_name, _gf_false, _gf_false)) {
+        cli_err(
+            "internet address '%s' does not conform to "
+            "standards",
+            host_name);
+    }
+
+    brick = GF_MALLOC(sizeof(cli_brick_t), gf_common_list_node);
+    if (brick == NULL) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        goto out;
+    }
 
-                if (!(strcmp (host_name, "localhost") &&
-                      strcmp (host_name, "127.0.0.1") &&
-                      strncmp (host_name, "0.", 2))) {
-                        cli_err ("Please provide a valid hostname/ip other "
-                                 "than localhost, 127.0.0.1 or loopback "
-                                 "address (0.0.0.0 to 0.255.255.255).");
-                        ret = -1;
-                        GF_FREE (tmp_host);
-                        goto out;
-                }
-                if (!valid_internet_address (host_name, _gf_false)) {
-                        cli_err ("internet address '%s' does not conform to "
-                                 "standards", host_name);
-                }
-                GF_FREE (tmp_host);
-                tmp_list = gf_strdup (brick_list + 1);
-                if (free_list_ptr) {
-                        GF_FREE (free_list_ptr);
-                        free_list_ptr = NULL;
-                }
-                free_list_ptr = tmp_list;
-                j = 0;
-                while(j < *brick_count) {
-                        strtok_r (tmp_list, " ", &tmpptr);
-                        if (!(strcmp (tmp_list, words[brick_index]))) {
-                                ret = -1;
-                                cli_err ("Found duplicate"
-                                         " exports %s",words[brick_index]);
-                                goto out;
-                       }
-                       tmp_list = tmpptr;
-                       j++;
-                }
-                strcat (brick_list, words[brick_index]);
-                strcat (brick_list, " ");
-                brick_list_len += (strlen (words[brick_index]) + 1);
-                ++(*brick_count);
-                ++brick_index;
-        }
+    brick->name = words[wordcount - 1];
+    brick->len = strlen(words[wordcount - 1]);
+    *ta_brick = GF_MALLOC(brick->len + 3, gf_common_mt_char);
+    if (*ta_brick == NULL) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        goto out;
+    }
 
-        *bricks = gf_strdup (brick_list);
-        if (!*bricks)
-                ret = -1;
+    strcat(*ta_brick, " ");
+    strcat(*ta_brick, brick->name);
+    strcat(*ta_brick, " ");
 out:
-        GF_FREE (free_list_ptr);
-        return ret;
+    if (tmp_host) {
+        GF_FREE(tmp_host);
+        tmp_host = NULL;
+    }
+    if (brick) {
+        GF_FREE(brick);
+        brick = NULL;
+    }
+
+    return ret;
 }
 
 int32_t
-cli_cmd_create_disperse_check (struct cli_state *state, int *disperse,
-                               int *redundancy, int *data, int count)
+cli_cmd_bricks_parse(const char **words, int wordcount, int brick_index,
+                     char **bricks, int *brick_count)
 {
-        int i = 0;
-        int tmp = 0;
-        gf_answer_t answer = GF_ANSWER_NO;
-        char question[128];
-
-        const char *question1 = "There isn't an optimal redundancy value "
-                                "for this configuration. Do you want to "
-                                "create the volume with redundancy 1 ?";
-
-        const char *question2 = "The optimal redundancy for this "
-                                "configuration is %d. Do you want to create "
-                                "the volume with this value ?";
-
-        const char *question3 = "This configuration is not optimal on most "
-                                "workloads. Do you want to use it ?";
-
-        const char *question4 = "Redundancy for this configuration is %d. "
-                                "Do you want to create "
-                                "the volume with this value ?";
-
-        if (*data > 0) {
-                if (*disperse > 0 && *redundancy > 0) {
-                        if (*disperse != (*data + *redundancy)) {
-                                cli_err ("Disperse count(%d) should be equal "
-                                         "to sum of disperse-data count(%d) and "
-                                         "redundancy count(%d)", *disperse,
-                                         *data, *redundancy);
-                                return -1;
-                        }
-                } else if (*redundancy > 0) {
-                        *disperse = *data + *redundancy;
-                } else if (*disperse > 0) {
-                        *redundancy = *disperse - *data;
-                } else {
-                        if ((count - *data) >= *data) {
-                                cli_err ("Please provide redundancy count "
-                                         "along with disperse-data count");
-                                return -1;
-                        } else {
-                                sprintf (question, question4, count - *data);
-                                answer = cli_cmd_get_confirmation (state,
-                                                                   question);
-                                if (answer == GF_ANSWER_NO)
-                                        return -1;
-                                *redundancy = count - *data;
-                                *disperse = count;
-                        }
-                }
+    int ret = 0;
+    char *delimiter = NULL;
+    char *host_name = NULL;
+    char *tmp_host = NULL;
+    char *bricks_str = NULL;
+    int len = 0;
+    int brick_list_len = 1; /* For initial space */
+    struct list_head brick_list = {
+        0,
+    };
+    cli_brick_t *brick = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(wordcount);
+    GF_ASSERT(bricks);
+    GF_ASSERT(brick_index > 0);
+    GF_ASSERT(brick_index < wordcount);
+
+    INIT_LIST_HEAD(&brick_list);
+
+    while (brick_index < wordcount) {
+        if (validate_brick_name((char *)words[brick_index])) {
+            cli_err(
+                "Wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[brick_index]);
+            ret = -1;
+            goto out;
+        } else {
+            delimiter = strrchr(words[brick_index], ':');
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
 
-        if (*disperse <= 0) {
-                if (count < 3) {
-                        cli_err ("number of bricks must be greater "
-                                 "than 2");
+        tmp_host = gf_strdup((char *)words[brick_index]);
+        if (!tmp_host) {
+            gf_log("cli", GF_LOG_ERROR, "Out of memory");
+            ret = -1;
+            goto out;
+        }
+        get_host_name(tmp_host, &host_name);
+        if (!host_name) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to allocate "
+                   "memory");
+            GF_FREE(tmp_host);
+            goto out;
+        }
+
+        if (!(strcmp(host_name, "localhost") &&
+              strcmp(host_name, "127.0.0.1") && strncmp(host_name, "0.", 2))) {
+            cli_err(
+                "Please provide a valid hostname/ip other "
+                "than localhost, 127.0.0.1 or loopback "
+                "address (0.0.0.0 to 0.255.255.255).");
+            ret = -1;
+            GF_FREE(tmp_host);
+            goto out;
+        }
+        if (!valid_internet_address(host_name, _gf_false, _gf_false)) {
+            cli_err(
+                "internet address '%s' does not conform to "
+                "standards",
+                host_name);
+        }
+        GF_FREE(tmp_host);
+        list_for_each_entry(brick, &brick_list, list)
+        {
+            if (strcmp(brick->name, words[brick_index]) == 0) {
+                ret = -1;
+                cli_err("Found duplicate exports %s", words[brick_index]);
+                goto out;
+            }
+        }
 
-                        return -1;
-                }
-                *disperse = count;
+        brick = GF_MALLOC(sizeof(cli_brick_t), gf_common_list_node);
+        if (brick == NULL) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Out of memory");
+            goto out;
         }
+        len = strlen(words[brick_index]);
+        brick->name = words[brick_index];
+        brick->len = len;
+        list_add_tail(&brick->list, &brick_list);
 
-        if (*redundancy == -1) {
-                tmp = *disperse - 1;
-                for (i = tmp / 2;
-                     (i > 0) && ((tmp & -tmp) != tmp);
-                     i--, tmp--);
+        brick_list_len += len + 1; /* Brick name + space */
+        ++(*brick_count);
+        ++brick_index;
+    }
 
-                if (i == 0) {
-                        answer = cli_cmd_get_confirmation(state, question1);
-                        if (answer == GF_ANSWER_NO)
-                                return -1;
+    /* If brick count is not valid exit here */
+    if (!*brick_count) {
+        cli_err("No bricks specified");
+        ret = -1;
+        goto out;
+    }
 
-                        *redundancy = 1;
-                }
-                else
-                {
-                        *redundancy = *disperse - tmp;
-                        if (*redundancy > 1) {
-                                sprintf(question, question2, *redundancy);
-                                answer = cli_cmd_get_confirmation(state,
-                                                                  question);
-                                if (answer == GF_ANSWER_NO)
-                                        return -1;
-                        }
-                }
+    brick_list_len++; /* For terminating null char */
+
+    bricks_str = GF_MALLOC(brick_list_len, gf_common_mt_char);
+    if (bricks_str == NULL) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        goto out;
+    }
+    *bricks = bricks_str;
+    *bricks_str = ' ';
+    bricks_str++;
+    while (!list_empty(&brick_list)) {
+        brick = list_first_entry(&brick_list, cli_brick_t, list);
+        list_del_init(&brick->list);
+        memcpy(bricks_str, brick->name, brick->len);
+        bricks_str[brick->len] = ' ';
+        bricks_str += brick->len + 1;
+        GF_FREE(brick);
+    }
+    *bricks_str = 0;
+
+out:
+    while (!list_empty(&brick_list)) {
+        brick = list_first_entry(&brick_list, cli_brick_t, list);
+        list_del_init(&brick->list);
+        GF_FREE(brick);
+    }
+
+    return ret;
+}
 
-                tmp = 0;
+int32_t
+cli_cmd_create_disperse_check(struct cli_state *state, int *disperse,
+                              int *redundancy, int *data, int count)
+{
+    int i = 0;
+    int tmp = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    char question[128];
+
+    const char *question1 =
+        "There isn't an optimal redundancy value "
+        "for this configuration. Do you want to "
+        "create the volume with redundancy 1 ?";
+
+    const char *question2 =
+        "The optimal redundancy for this "
+        "configuration is %d. Do you want to create "
+        "the volume with this value ?";
+
+    const char *question3 =
+        "This configuration is not optimal on most "
+        "workloads. Do you want to use it ?";
+
+    const char *question4 =
+        "Redundancy for this configuration is %d. "
+        "Do you want to create "
+        "the volume with this value ?";
+
+    if (*data > 0) {
+        if (*disperse > 0 && *redundancy > 0) {
+            if (*disperse != (*data + *redundancy)) {
+                cli_err(
+                    "Disperse count(%d) should be equal "
+                    "to sum of disperse-data count(%d) and "
+                    "redundancy count(%d)",
+                    *disperse, *data, *redundancy);
+                return -1;
+            }
+        } else if (*redundancy > 0) {
+            *disperse = *data + *redundancy;
+        } else if (*disperse > 0) {
+            *redundancy = *disperse - *data;
         } else {
-                tmp = *disperse - *redundancy;
+            if ((count - *data) >= *data) {
+                cli_err(
+                    "Please provide redundancy count "
+                    "along with disperse-data count");
+                return -1;
+            } else {
+                sprintf(question, question4, count - *data);
+                answer = cli_cmd_get_confirmation(state, question);
+                if (answer == GF_ANSWER_NO)
+                    return -1;
+                *redundancy = count - *data;
+                *disperse = count;
+            }
         }
+    }
 
-        if (*redundancy > (*disperse - 1) / 2) {
-                cli_err ("redundancy must be less than %d for a "
-                         "disperse %d volume",
-                         (*disperse + 1) / 2, *disperse);
+    if (*disperse <= 0) {
+        if (count < 3) {
+            cli_err(
+                "number of bricks must be greater "
+                "than 2");
 
-                return -1;
+            return -1;
         }
+        *disperse = count;
+    }
 
-        if ((tmp & -tmp) != tmp) {
-                answer = cli_cmd_get_confirmation(state, question3);
+    if (*redundancy == -1) {
+        tmp = *disperse - 1;
+        for (i = tmp / 2; (i > 0) && ((tmp & -tmp) != tmp); i--, tmp--)
+            ;
+
+        if (i == 0) {
+            answer = cli_cmd_get_confirmation(state, question1);
+            if (answer == GF_ANSWER_NO)
+                return -1;
+
+            *redundancy = 1;
+        } else {
+            *redundancy = *disperse - tmp;
+            if (*redundancy > 1) {
+                sprintf(question, question2, *redundancy);
+                answer = cli_cmd_get_confirmation(state, question);
                 if (answer == GF_ANSWER_NO)
-                        return -1;
+                    return -1;
+            }
         }
 
-        return 0;
+        tmp = 0;
+    } else {
+        tmp = *disperse - *redundancy;
+    }
+
+    if ((*redundancy < 1) || (*redundancy > (*disperse - 1) / 2)) {
+        cli_err(
+            "redundancy must be greater than or equal to 1 and "
+            "less than %d for a disperse %d volume",
+            (*disperse + 1) / 2, *disperse);
+
+        return -1;
+    }
+
+    if ((tmp & -tmp) != tmp) {
+        answer = cli_cmd_get_confirmation(state, question3);
+        if (answer == GF_ANSWER_NO)
+            return -1;
+    }
+
+    return 0;
 }
 
 static int32_t
-cli_validate_disperse_volume (char *word, gf1_cluster_type type,
-                              const char **words, int32_t wordcount,
-                              int32_t index, int32_t *disperse_count,
-                              int32_t *redundancy_count,
-                              int32_t *data_count)
+cli_validate_disperse_volume(char *word, gf1_cluster_type type,
+                             const char **words, int32_t wordcount,
+                             int32_t index, int32_t *disperse_count,
+                             int32_t *redundancy_count, int32_t *data_count)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        switch (type) {
+    switch (type) {
         case GF_CLUSTER_TYPE_NONE:
         case GF_CLUSTER_TYPE_DISPERSE:
-                if (strcmp (word, "disperse") == 0) {
-                        if (*disperse_count >= 0) {
-                                cli_err ("disperse option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index + 1], disperse_count);
-                        if (ret == -1 && errno == EINVAL) {
-                                *disperse_count = 0;
-                                ret = 1;
-                        } else if (ret == -1) {
-                                goto out;
-                        } else {
-                                if (*disperse_count < 3) {
-                                        cli_err ("disperse count must "
-                                                 "be greater than 2");
-                                        goto out;
-                                }
-                                ret = 2;
-                        }
-                } else if (strcmp (word, "disperse-data") == 0) {
-                        if (*data_count >= 0) {
-                                cli_err ("disperse-data option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index+1], data_count);
-                        if (ret == -1 || *data_count < 2) {
-                                cli_err ("disperse-data must be greater than 1");
-                                goto out;
-                        }
-                        ret = 2;
-                } else if (strcmp (word, "redundancy") == 0) {
-                        if (*redundancy_count >= 0) {
-                                cli_err ("redundancy option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index+1], redundancy_count);
-                        if (ret == -1 || *redundancy_count < 1) {
-                                cli_err ("redundancy must be greater than 0");
-                                goto out;
-                        }
-                        ret = 2;
-                }
-                break;
-        case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                cli_err ("striped-replicated-dispersed volume "
-                         "is not supported");
-                goto out;
-        case GF_CLUSTER_TYPE_TIER:
-                cli_err ("tier-dispersed volume is not "
-                         "supported");
-                goto out;
-        case GF_CLUSTER_TYPE_STRIPE:
-                cli_err ("striped-dispersed volume is not "
-                         "supported");
-                goto out;
+            if (strcmp(word, "disperse") == 0) {
+                if (*disperse_count >= 0) {
+                    cli_err("disperse option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], disperse_count);
+                if (ret == -1 && errno == EINVAL) {
+                    *disperse_count = 0;
+                    ret = 1;
+                } else if (ret == -1) {
+                    goto out;
+                } else {
+                    if (*disperse_count < 3) {
+                        cli_err(
+                            "disperse count must "
+                            "be greater than 2");
+                        goto out;
+                    }
+                    ret = 2;
+                }
+            } else if (strcmp(word, "disperse-data") == 0) {
+                if (*data_count >= 0) {
+                    cli_err("disperse-data option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], data_count);
+                if (ret == -1 || *data_count < 2) {
+                    cli_err("disperse-data must be greater than 1");
+                    goto out;
+                }
+                ret = 2;
+            } else if (strcmp(word, "redundancy") == 0) {
+                if (*redundancy_count >= 0) {
+                    cli_err("redundancy option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], redundancy_count);
+                if (ret == -1 || *redundancy_count < 1) {
+                    cli_err("redundancy must be greater than 0");
+                    goto out;
+                }
+                ret = 2;
+            }
+            break;
         case GF_CLUSTER_TYPE_REPLICATE:
-                cli_err ("replicated-dispersed volume is not "
-                         "supported");
-                goto out;
+            cli_err(
+                "replicated-dispersed volume is not "
+                "supported");
+            goto out;
         default:
-                cli_err ("Invalid type given");
-                break;
-        }
+            cli_err("Invalid type given");
+            break;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_validate_volname (const char *volname)
+cli_validate_volname(const char *volname)
 {
-        int32_t            ret                       = -1;
-        int32_t            i                         = -1;
-        static const char * const invalid_volnames[] = {
-                                      "volume", "type", "subvolumes", "option",
-                                      "end-volume", "all", "volume_not_in_ring",
-                                      "description", "force",
-                                      "snap-max-hard-limit",
-                                      "snap-max-soft-limit", "auto-delete",
-                                      "activate-on-create", NULL};
-
-        if (volname[0] == '-')
-                goto out;
-
-        for (i = 0; invalid_volnames[i]; i++) {
-                if (!strcmp (volname, invalid_volnames[i])) {
-                        cli_err ("\"%s\" cannot be the name of a volume.",
-                                 volname);
-                        goto out;
-                }
-        }
+    int32_t ret = -1;
+    int32_t i = -1;
+    int volname_len;
+    static const char *const invalid_volnames[] = {"volume",
+                                                   "type",
+                                                   "subvolumes",
+                                                   "option",
+                                                   "end-volume",
+                                                   "all",
+                                                   "volume_not_in_ring",
+                                                   "description",
+                                                   "force",
+                                                   "snap-max-hard-limit",
+                                                   "snap-max-soft-limit",
+                                                   "auto-delete",
+                                                   "activate-on-create",
+                                                   NULL};
 
-        if (strchr (volname, '/'))
-                goto out;
+    if (volname[0] == '-')
+        goto out;
 
-        if (strlen (volname) > GD_VOLUME_NAME_MAX) {
-                cli_err("Volume name exceeds %d characters.",
-                        GD_VOLUME_NAME_MAX);
-                goto out;
+    for (i = 0; invalid_volnames[i]; i++) {
+        if (!strcmp(volname, invalid_volnames[i])) {
+            cli_err("\"%s\" cannot be the name of a volume.", volname);
+            goto out;
         }
+    }
 
-        for (i = 0; i < strlen (volname); i++) {
-                if (!isalnum (volname[i]) && (volname[i] != '_') &&
-                   (volname[i] != '-')) {
-                        cli_err ("Volume name should not contain \"%c\""
-                                 " character.\nVolume names can only"
-                                 "contain alphanumeric, '-' and '_' "
-                                 "characters.", volname[i]);
-                        goto out;
-                }
-        }
+    if (strchr(volname, '/'))
+        goto out;
 
-        ret = 0;
+    volname_len = strlen(volname);
+    if (volname_len > GD_VOLUME_NAME_MAX) {
+        cli_err("Volume name exceeds %d characters.", GD_VOLUME_NAME_MAX);
+        goto out;
+    }
+
+    for (i = 0; i < volname_len; i++) {
+        if (!isalnum(volname[i]) && (volname[i] != '_') &&
+            (volname[i] != '-')) {
+            cli_err(
+                "Volume name should not contain \"%c\""
+                " character.\nVolume names can only"
+                "contain alphanumeric, '-' and '_' "
+                "characters.",
+                volname[i]);
+            goto out;
+        }
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_create_parse (struct cli_state *state, const char **words,
-                             int wordcount, dict_t **options, char **brick_list)
+cli_cmd_volume_create_parse(struct cli_state *state, const char **words,
+                            int wordcount, dict_t **options, char **brick_list)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
-        gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
-        int     sub_count = 1;
-        int     brick_index = 0;
-        char    *trans_type = NULL;
-        int32_t index = 0;
-        char    *bricks = NULL;
-        int32_t brick_count = 0;
-        char    *opwords[] = { "replica", "stripe", "transport", "disperse",
-                               "redundancy", "disperse-data", "arbiter", NULL };
-
-        char    *w = NULL;
-        int      op_count = 0;
-        int32_t  replica_count = 1;
-        int32_t  arbiter_count = 0;
-        int32_t  stripe_count = 1;
-        int32_t  disperse_count = -1;
-        int32_t  redundancy_count = -1;
-        int32_t  disperse_data_count = -1;
-        gf_boolean_t is_force = _gf_false;
-        int wc = wordcount;
-        gf_answer_t answer = GF_ANSWER_NO;
-        const char *question = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
+    int sub_count = 1;
+    int brick_index = 0;
+    char *trans_type = NULL;
+    int32_t index = 0;
+    char *bricks = NULL;
+    char *ta_brick = NULL;
+    int32_t brick_count = 0;
+    static char *opwords[] = {"replica",  "stripe",       "transport",
+                              "disperse", "redundancy",   "disperse-data",
+                              "arbiter",  "thin-arbiter", NULL};
+
+    char *w = NULL;
+    int op_count = 0;
+    int32_t replica_count = 1;
+    int32_t arbiter_count = 0;
+    int32_t thin_arbiter_count = 0;
+    int32_t stripe_count = 1;
+    int32_t disperse_count = -1;
+    int32_t redundancy_count = -1;
+    int32_t disperse_data_count = -1;
+    gf_boolean_t is_force = _gf_false;
+    int wc = wordcount;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    if (wordcount < 3)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        if (wordcount < 4) {
-                ret = -1;
-                goto out;
-        }
+    if (wordcount < 4) {
+        ret = -1;
+        goto out;
+    }
 
-        type = GF_CLUSTER_TYPE_NONE;
-        index = 3;
+    type = GF_CLUSTER_TYPE_NONE;
+    index = 3;
 
-        while (op_count < 3) {
+    while (op_count < 3) {
+        ret = -1;
+        w = str_getunamb(words[index], opwords);
+        if (!w) {
+            break;
+        } else if ((strcmp(w, "replica")) == 0) {
+            switch (type) {
+                case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
+                case GF_CLUSTER_TYPE_REPLICATE:
+                    cli_err("replica option given twice");
+                    goto out;
+                case GF_CLUSTER_TYPE_NONE:
+                    type = GF_CLUSTER_TYPE_REPLICATE;
+                    break;
+                case GF_CLUSTER_TYPE_STRIPE:
+                    cli_err("stripe option not supported");
+                    goto out;
+                case GF_CLUSTER_TYPE_DISPERSE:
+                    cli_err(
+                        "replicated-dispersed volume is not "
+                        "supported");
+                    goto out;
+                default:
+                    cli_err("Invalid type given");
+                    goto out;
+            }
+
+            if (wordcount < (index + 2)) {
                 ret = -1;
-                w = str_getunamb (words[index], opwords);
-                if (!w) {
-                        break;
-                } else if ((strcmp (w, "replica")) == 0) {
-                        switch (type) {
-                        case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                        case GF_CLUSTER_TYPE_REPLICATE:
-                                cli_err ("replica option given twice");
-                                goto out;
-                        case GF_CLUSTER_TYPE_NONE:
-                                type = GF_CLUSTER_TYPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_STRIPE:
-                                type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_TIER:
-                                cli_err ("replicated-tiered volume is not "
-                                         "supported");
-                                goto out;
-                                break;
-                        case GF_CLUSTER_TYPE_DISPERSE:
-                                cli_err ("replicated-dispersed volume is not "
-                                         "supported");
-                                goto out;
-                        default:
-                                cli_err ("Invalid type given");
-                                goto out;
-                        }
-
-                        if (wordcount < (index+2)) {
-                                ret = -1;
-                                goto out;
-                        }
-                        replica_count = strtol (words[index+1], NULL, 0);
-                        if (replica_count < 2) {
-                                cli_err ("replica count should be greater"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
-                        if (replica_count == 2) {
-                                if (strcmp (words[wordcount - 1], "force")) {
-                                        question = "Replica 2 volumes are prone"
-                                                   " to split-brain. Use "
-                                                   "Arbiter or Replica 3 to "
-                                                   "avoid this. See: "
-                                                   "http://docs.gluster.org/en/latest/Administrator%20Guide/Split%20brain%20and%20ways%20to%20deal%20with%20it/."
-                                                   "\nDo you still want to "
-                                                   "continue?\n";
-                                        answer = cli_cmd_get_confirmation (state,
-                                                 question);
-                                        if (GF_ANSWER_NO == answer) {
-                                                gf_log ("cli", GF_LOG_ERROR,
-                                                        "Volume create "
-                                                        "cancelled, exiting");
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-                        }
-                        ret = dict_set_int32 (dict, "replica-count", replica_count);
-                        if (ret)
-                                goto out;
-
-                        index += 2;
-                        if (words[index]) {
-                                if (!strcmp (words[index], "arbiter")) {
-                                        ret = gf_string2int (words[index+1],
-                                                             &arbiter_count);
-                                        if (ret == -1 || arbiter_count != 1 ||
-                                            replica_count != 3) {
-                                                cli_err ("For arbiter "
-                                                         "configuration, "
-                                                         "replica count must be"
-                                                         " 3 and arbiter count "
-                                                         "must be 1. The 3rd "
-                                                         "brick of the replica "
-                                                         "will be the arbiter");
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                        ret = dict_set_int32 (dict, "arbiter-count",
-                                                              arbiter_count);
-                                        if (ret)
-                                                goto out;
-                                        index += 2;
-                                }
-                        }
-
-                } else if ((strcmp (w, "stripe")) == 0) {
-                        switch (type) {
-                        case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                        case GF_CLUSTER_TYPE_STRIPE:
-                                cli_err ("stripe option given twice");
-                                goto out;
-                        case GF_CLUSTER_TYPE_NONE:
-                                type = GF_CLUSTER_TYPE_STRIPE;
-                                break;
-                        case GF_CLUSTER_TYPE_REPLICATE:
-                                type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_DISPERSE:
-                                cli_err ("striped-dispersed volume is not "
-                                         "supported");
-                                goto out;
-                        case GF_CLUSTER_TYPE_TIER:
-                                cli_err ("striped-tier volume is not "
-                                         "supported");
-                                goto out;
-                        default:
-                                cli_err ("Invalid type given");
-                                goto out;
-                        }
-                        if (wordcount < (index + 2)) {
-                                ret = -1;
-                                goto out;
-                        }
-                        stripe_count = strtol (words[index+1], NULL, 0);
-                        if (stripe_count < 2) {
-                                cli_err ("stripe count should be greater"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_int32 (dict, "stripe-count", stripe_count);
-                        if (ret)
-                                goto out;
-
-                        index += 2;
+                goto out;
+            }
 
-                } else if ((strcmp (w, "transport")) == 0) {
-                        if (trans_type) {
-                                cli_err ("'transport' option given more"
-                                         " than one time");
-                                goto out;
-                        }
-                        if ((strcasecmp (words[index+1], "tcp") == 0)) {
-                                trans_type = gf_strdup ("tcp");
-                        } else if ((strcasecmp (words[index+1], "rdma") == 0)) {
-                                trans_type = gf_strdup ("rdma");
-                        } else if ((strcasecmp (words[index+1], "tcp,rdma") == 0) ||
-                                   (strcasecmp (words[index+1], "rdma,tcp") == 0)) {
-                                trans_type = gf_strdup ("tcp,rdma");
-                        } else {
-                                gf_log ("", GF_LOG_ERROR, "incorrect transport"
-                                        " protocol specified");
-                                ret = -1;
-                                goto out;
-                        }
-                        index += 2;
-
-                } else if ((strcmp (w, "disperse") == 0) ||
-                           (strcmp (w, "redundancy") == 0) ||
-                           (strcmp (w, "disperse-data") == 0)) {
-                        ret = cli_validate_disperse_volume (w, type, words,
-                                      wordcount, index, &disperse_count,
-                                      &redundancy_count, &disperse_data_count);
-                        if (ret < 0)
-                                goto out;
-                        index += ret;
-                        type = GF_CLUSTER_TYPE_DISPERSE;
-                } else if ((strcmp (w, "arbiter") == 0)) {
-                        cli_err ("arbiter option must be preceded by replica "
-                                 "option.");
+            replica_count = strtol(words[index + 1], NULL, 0);
+            if (replica_count < 2) {
+                cli_err(
+                    "replica count should be greater"
+                    " than 1");
+                ret = -1;
+                goto out;
+            }
+
+            index += 2;
+            if (words[index]) {
+                if (!strcmp(words[index], "arbiter")) {
+                    ret = gf_string2int(words[index + 1], &arbiter_count);
+                    if ((ret == -1) || (arbiter_count != 1)) {
+                        cli_err(
+                            "For arbiter "
+                            "configuration, "
+                            "replica count must be"
+                            " 2 and arbiter count "
+                            "must be 1. The 3rd "
+                            "brick of the replica "
+                            "will be the arbiter");
                         ret = -1;
                         goto out;
-                } else {
-                        GF_ASSERT (!"opword mismatch");
+                    }
+                    ret = dict_set_int32(dict, "arbiter-count", arbiter_count);
+                    if (ret)
+                        goto out;
+                    index += 2;
+                } else if (!strcmp(words[index], "thin-arbiter")) {
+                    ret = gf_string2int(words[index + 1], &thin_arbiter_count);
+                    if ((ret == -1) || (thin_arbiter_count != 1) ||
+                        (replica_count != 2)) {
+                        cli_err(
+                            "For thin-arbiter "
+                            "configuration, "
+                            "replica count must be"
+                            " 2 and thin-arbiter count "
+                            "must be 1. The 3rd "
+                            "brick of the replica "
+                            "will be the thin-arbiter brick");
                         ret = -1;
                         goto out;
-                }
-                op_count++;
-        }
-
-        if (!trans_type)
-                trans_type = gf_strdup ("tcp");
-
-        if (index >= wordcount) {
+                    }
+                    ret = dict_set_int32(dict, "thin-arbiter-count",
+                                         thin_arbiter_count);
+                    if (ret)
+                        goto out;
+                    index += 2;
+                }
+            }
+
+            /* Do this to keep glusterd happy with sending
+               "replica 3 arbiter 1" options to server */
+            if ((arbiter_count == 1) && (replica_count == 2))
+                replica_count += arbiter_count;
+
+            if (replica_count == 2 && thin_arbiter_count == 0) {
+                if (strcmp(words[wordcount - 1], "force")) {
+                    question =
+                        "Replica 2 volumes are prone"
+                        " to split-brain. Use "
+                        "Arbiter or Replica 3 to "
+                        "avoid this. See: "
+                        "http://docs.gluster.org/en/latest/"
+                        "Administrator%20Guide/"
+                        "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                        "\nDo you still want to "
+                        "continue?\n";
+                    answer = cli_cmd_get_confirmation(state, question);
+                    if (GF_ANSWER_NO == answer) {
+                        gf_log("cli", GF_LOG_ERROR,
+                               "Volume create "
+                               "cancelled, exiting");
+                        ret = -1;
+                        goto out;
+                    }
+                }
+            }
+            ret = dict_set_int32(dict, "replica-count", replica_count);
+            if (ret)
+                goto out;
+
+        } else if ((strcmp(w, "stripe")) == 0) {
+            cli_err("stripe option not supported");
+            goto out;
+        } else if ((strcmp(w, "transport")) == 0) {
+            if (trans_type) {
+                cli_err(
+                    "'transport' option given more"
+                    " than one time");
+                goto out;
+            }
+            if ((strcasecmp(words[index + 1], "tcp") == 0)) {
+                trans_type = gf_strdup("tcp");
+            } else if ((strcasecmp(words[index + 1], "rdma") == 0)) {
+                trans_type = gf_strdup("rdma");
+            } else if ((strcasecmp(words[index + 1], "tcp,rdma") == 0) ||
+                       (strcasecmp(words[index + 1], "rdma,tcp") == 0)) {
+                trans_type = gf_strdup("tcp,rdma");
+            } else {
+                gf_log("", GF_LOG_ERROR,
+                       "incorrect transport"
+                       " protocol specified");
                 ret = -1;
                 goto out;
+            }
+            index += 2;
+
+        } else if ((strcmp(w, "disperse") == 0) ||
+                   (strcmp(w, "redundancy") == 0) ||
+                   (strcmp(w, "disperse-data") == 0)) {
+            ret = cli_validate_disperse_volume(
+                w, type, words, wordcount, index, &disperse_count,
+                &redundancy_count, &disperse_data_count);
+            if (ret < 0)
+                goto out;
+            index += ret;
+            type = GF_CLUSTER_TYPE_DISPERSE;
+        } else if ((strcmp(w, "arbiter") == 0)) {
+            cli_err(
+                "arbiter option must be preceded by replica "
+                "option.");
+            ret = -1;
+            goto out;
+        } else if ((strcmp(w, "thin-arbiter") == 0)) {
+            cli_err(
+                "thin-arbiter option must be preceded by replica "
+                "option.");
+            ret = -1;
+            goto out;
+        } else {
+            GF_ASSERT(!"opword mismatch");
+            ret = -1;
+            goto out;
         }
+        op_count++;
+    }
 
-        brick_index = index;
+    if (!trans_type)
+        trans_type = gf_strdup("tcp");
 
-        if (strcmp (words[wordcount - 1], "force") == 0) {
-                is_force = _gf_true;
-                wc = wordcount - 1;
-        }
+    if (index >= wordcount) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_bricks_parse (words, wc, brick_index, &bricks,
-                                    &brick_count);
-        if (ret)
-                goto out;
+    brick_index = index;
 
-        /* If brick-count is not valid when replica or stripe is
-           given, exit here */
-        if (!brick_count) {
-                cli_err ("No bricks specified");
-                ret = -1;
-                goto out;
-        }
+    if (strcmp(words[wordcount - 1], "force") == 0) {
+        is_force = _gf_true;
+        wc = wordcount - 1;
+    }
 
-        if (type == GF_CLUSTER_TYPE_DISPERSE) {
-                ret = cli_cmd_create_disperse_check (state, &disperse_count,
-                                                     &redundancy_count,
-                                                     &disperse_data_count,
-                                                     brick_count);
-                if (!ret)
-                        ret = dict_set_int32 (dict, "disperse-count",
-                                              disperse_count);
-                if (!ret)
-                        ret = dict_set_int32 (dict, "redundancy-count",
-                                              redundancy_count);
-                if (ret)
-                        goto out;
+    // Exclude the thin-arbiter-brick i.e. last brick in the bricks list
+    if (thin_arbiter_count == 1) {
+        ret = cli_cmd_bricks_parse(words, wc - 1, brick_index, &bricks,
+                                   &brick_count);
+        if (ret)
+            goto out;
 
-                sub_count = disperse_count;
-        } else
-                sub_count = stripe_count * replica_count;
-
-        if (brick_count % sub_count) {
-                if (type == GF_CLUSTER_TYPE_STRIPE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "stripe count");
-                else if (type == GF_CLUSTER_TYPE_REPLICATE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "replica count");
-                else if (type == GF_CLUSTER_TYPE_DISPERSE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "disperse count");
-                else
-                        cli_err ("number of bricks given doesn't match "
-                                 "required count");
+        ret = cli_cmd_ta_brick_parse(words, wc, &ta_brick);
 
-                ret = -1;
-                goto out;
-        }
+    } else {
+        ret = cli_cmd_bricks_parse(words, wc, brick_index, &bricks,
+                                   &brick_count);
+    }
 
-        /* Everything is parsed fine. start setting info in dict */
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "type", type);
+    if (type == GF_CLUSTER_TYPE_DISPERSE) {
+        ret = cli_cmd_create_disperse_check(state, &disperse_count,
+                                            &redundancy_count,
+                                            &disperse_data_count, brick_count);
+        if (!ret)
+            ret = dict_set_int32(dict, "disperse-count", disperse_count);
+        if (!ret)
+            ret = dict_set_int32(dict, "redundancy-count", redundancy_count);
         if (ret)
-                goto out;
+            goto out;
+
+        sub_count = disperse_count;
+    } else
+        sub_count = stripe_count * replica_count;
+
+    if (brick_count % sub_count) {
+        if (type == GF_CLUSTER_TYPE_STRIPE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "stripe count");
+        else if (type == GF_CLUSTER_TYPE_REPLICATE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "replica count");
+        else if (type == GF_CLUSTER_TYPE_DISPERSE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "disperse count");
+        else
+            cli_err(
+                "number of bricks given doesn't match "
+                "required count");
 
-        ret = dict_set_dynstr (dict, "transport", trans_type);
-        if (ret)
-                goto out;
-        trans_type = NULL;
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_dynstr (dict, "bricks", bricks);
-        if (ret)
-                goto out;
+    /* Everything is parsed fine. start setting info in dict */
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "count", brick_count);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "type", type);
+    if (ret)
+        goto out;
+
+    ret = dict_set_dynstr(dict, "transport", trans_type);
+    if (ret)
+        goto out;
+    trans_type = NULL;
+
+    ret = dict_set_dynstr(dict, "bricks", bricks);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "force", is_force);
+    if (thin_arbiter_count == 1) {
+        ret = dict_set_dynstr(dict, "ta-brick", ta_brick);
         if (ret)
-                goto out;
+            goto out;
+    }
 
-        *options = dict;
-        *brick_list = bricks;
+    ret = dict_set_int32(dict, "count", brick_count);
+    if (ret)
+        goto out;
+
+    ret = dict_set_int32(dict, "force", is_force);
+    if (ret)
+        goto out;
+
+    *options = dict;
+    *brick_list = bricks;
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse create volume CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        GF_FREE(bricks);
+        GF_FREE(ta_brick);
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse create volume CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        GF_FREE (trans_type);
+    GF_FREE(trans_type);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_reset_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_volume_reset_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict)
-                goto out;
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    if (wordcount < 3)
+        goto out;
 
-        if (wordcount > 5)
-                goto out;
+    if (wordcount > 5)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (wordcount == 3) {
-                ret = dict_set_str (dict, "key", "all");
-                if (ret)
-                        goto out;
-        }
+    if (wordcount == 3) {
+        ret = dict_set_str(dict, "key", "all");
+        if (ret)
+            goto out;
+    }
 
-        if (wordcount >= 4) {
-                if (!strcmp ("force", (char*)words[3])) {
-                        ret = dict_set_int32 (dict, "force", 1);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "key", "all");
-                        if (ret)
-                                goto out;
-                } else {
-                        ret = dict_set_str (dict, "key", (char *)words[3]);
-                        if (ret)
-                                goto out;
-                }
+    if (wordcount >= 4) {
+        if (!strcmp("force", (char *)words[3])) {
+            ret = dict_set_int32(dict, "force", 1);
+            if (ret)
+                goto out;
+            ret = dict_set_str(dict, "key", "all");
+            if (ret)
+                goto out;
+        } else {
+            ret = dict_set_str(dict, "key", (char *)words[3]);
+            if (ret)
+                goto out;
         }
+    }
 
-        if (wordcount == 5) {
-                if (strcmp ("force", (char*)words[4])) {
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = dict_set_int32 (dict, "force", 1);
-                        if (ret)
-                                goto out;
-                }
+    if (wordcount == 5) {
+        if (strcmp("force", (char *)words[4])) {
+            ret = -1;
+            goto out;
+        } else {
+            ret = dict_set_int32(dict, "force", 1);
+            if (ret)
+                goto out;
         }
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
+    if (ret && dict) {
+        dict_unref(dict);
+    }
 
-                return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_get_state_parse (struct cli_state *state,
-                         const char **words, int wordcount,
-                         dict_t **options, char **op_errstr)
+cli_cmd_get_state_parse(struct cli_state *state, const char **words,
+                        int wordcount, dict_t **options, char **op_errstr)
 {
-        dict_t    *dict                 = NULL;
-        int        ret                  = -1;
-        char      *odir                 = NULL;
-        char      *filename             = NULL;
-        char      *daemon_name          = NULL;
-        int        count                = 0;
-        uint32_t   cmd                  = 0;
-
-        GF_VALIDATE_OR_GOTO ("cli", options, out);
-        GF_VALIDATE_OR_GOTO ("cli", words, out);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount < 1 || wordcount > 7) {
-                *op_errstr = gf_strdup ("Problem parsing arguments."
-                                        " Check usage.");
-                goto out;
-        }
-
-        if (wordcount >= 1) {
-                gf_asprintf (&daemon_name, "%s", "glusterd");
-
-                for (count = 1; count < wordcount; count++) {
-                        if (strcmp (words[count], "odir") == 0 ||
-                                        strcmp (words[count], "file") == 0) {
-                                if (strcmp (words[count], "odir") == 0) {
-                                        if (++count < wordcount) {
-                                                odir = (char *) words[count];
-                                                continue;
-                                        } else {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                } else if (strcmp (words[count], "file") == 0) {
-                                        if (++count < wordcount) {
-                                                filename = (char *) words[count];
-                                                continue;
-                                        } else {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-                        } else {
-                                if (count > 1) {
-                                        if (count == wordcount-1) {
-                                                if (strcmp (words[count],
-                                                            "detail") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_DETAIL;
-                                                        continue;
-                                                } else if (strcmp (words[count],
-                                                                   "volumeoptions") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_VOLOPTS;
-                                                        continue;
-                                                }
-                                        } else {
-                                                *op_errstr = gf_strdup ("Problem"
-                                                        " parsing arguments. "
-                                                        "Check usage.");
-                                                ret = -1;
-                                                goto out;
-                                        }
-
-                                }
-                                if (strcmp (words[count], "glusterd") == 0) {
-                                        continue;
-                                } else {
-                                        if (count == wordcount-1) {
-                                                if (strcmp (words[count],
-                                                            "detail") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_DETAIL;
-                                                        continue;
-                                                } else if (strcmp (words[count],
-                                                                   "volumeoptions") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_VOLOPTS;
-                                                        continue;
-                                                }
-                                        }
-
-                                        *op_errstr = gf_strdup ("glusterd is "
-                                                 "the only supported daemon.");
-                                        ret = -1;
-                                        goto out;
-                                }
-                        }
-                }
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *odir = NULL;
+    char *filename = NULL;
+    char *daemon_name = NULL;
+    int count = 0;
+    uint32_t cmd = 0;
+
+    GF_VALIDATE_OR_GOTO("cli", options, out);
+    GF_VALIDATE_OR_GOTO("cli", words, out);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-                ret = dict_set_str (dict, "daemon", daemon_name);
-                if (ret) {
-                        *op_errstr = gf_strdup ("Command failed. Please check "
-                                                " log file for more details.");
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "Setting daemon name to dictionary failed");
+    if (wordcount < 1 || wordcount > 7) {
+        *op_errstr = gf_strdup(
+            "Problem parsing arguments."
+            " Check usage.");
+        goto out;
+    }
+
+    if (wordcount >= 1) {
+        gf_asprintf(&daemon_name, "%s", "glusterd");
+
+        for (count = 1; count < wordcount; count++) {
+            if (strcmp(words[count], "odir") == 0 ||
+                strcmp(words[count], "file") == 0) {
+                if (strcmp(words[count], "odir") == 0) {
+                    if (++count < wordcount) {
+                        odir = (char *)words[count];
+                        continue;
+                    } else {
+                        ret = -1;
                         goto out;
-                }
-
-                if (odir) {
-                        ret = dict_set_str (dict, "odir", odir);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more details.");
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Setting output directory to"
-                                        "dictionary failed");
-                                goto out;
+                    }
+                } else if (strcmp(words[count], "file") == 0) {
+                    if (++count < wordcount) {
+                        filename = (char *)words[count];
+                        continue;
+                    } else {
+                        ret = -1;
+                        goto out;
+                    }
+                }
+            } else {
+                if (count > 1) {
+                    if (count == wordcount - 1) {
+                        if (strcmp(words[count], "detail") == 0) {
+                            cmd = GF_CLI_GET_STATE_DETAIL;
+                            continue;
+                        } else if (strcmp(words[count], "volumeoptions") == 0) {
+                            cmd = GF_CLI_GET_STATE_VOLOPTS;
+                            continue;
                         }
+                    } else {
+                        *op_errstr = gf_strdup(
+                            "Problem"
+                            " parsing arguments. "
+                            "Check usage.");
+                        ret = -1;
+                        goto out;
+                    }
                 }
-
-                if (filename) {
-                        ret = dict_set_str (dict, "filename", filename);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more  details.");
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Setting filename to dictionary failed");
-                                goto out;
+                if (strcmp(words[count], "glusterd") == 0) {
+                    continue;
+                } else {
+                    if (count == wordcount - 1) {
+                        if (strcmp(words[count], "detail") == 0) {
+                            cmd = GF_CLI_GET_STATE_DETAIL;
+                            continue;
+                        } else if (strcmp(words[count], "volumeoptions") == 0) {
+                            cmd = GF_CLI_GET_STATE_VOLOPTS;
+                            continue;
                         }
-                }
+                    }
 
-                if (cmd) {
-                        ret = dict_set_uint32 (dict, "getstate-cmd", cmd);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more details.");
-                                gf_log (THIS->name, GF_LOG_ERROR, "Setting "
-                                        "get-state command type to dictionary "
-                                        "failed");
-                                goto out;
-                        }
+                    *op_errstr = gf_strdup(
+                        "glusterd is "
+                        "the only supported daemon.");
+                    ret = -1;
+                    goto out;
                 }
+            }
         }
 
- out:
-        if (dict)
-                *options = dict;
+        ret = dict_set_dynstr(dict, "daemon", daemon_name);
+        if (ret) {
+            *op_errstr = gf_strdup(
+                "Command failed. Please check "
+                " log file for more details.");
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "Setting daemon name to dictionary failed");
+            goto out;
+        }
+        daemon_name = NULL;
+
+        if (odir) {
+            ret = dict_set_str(dict, "odir", odir);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting output directory to"
+                       "dictionary failed");
+                goto out;
+            }
+        }
+
+        if (filename) {
+            ret = dict_set_str(dict, "filename", filename);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more  details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting filename to dictionary failed");
+                goto out;
+            }
+        }
+
+        if (cmd) {
+            ret = dict_set_uint32(dict, "getstate-cmd", cmd);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting "
+                       "get-state command type to dictionary "
+                       "failed");
+                goto out;
+            }
+        }
+    }
 
-        if (ret && dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        *options = dict;
 
-        return ret;
+    if (ret && dict)
+        dict_unref(dict);
+
+    GF_FREE(daemon_name);
+
+    return ret;
 }
 
 int32_t
-cli_cmd_inode_quota_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_inode_quota_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t          *dict    = NULL;
-        char            *volname = NULL;
-        int              ret     = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "dict_new failed");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "dict_new failed");
+        goto out;
+    }
 
-        if (wordcount != 4)
-                goto out;
+    if (wordcount != 4)
+        goto out;
 
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret < 0)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret < 0)
+        goto out;
 
-        if (strcmp (words[3], "enable") != 0) {
-                cli_out ("Invalid quota option : %s", words[3]);
-                ret = -1;
-                goto out;
-        }
+    if (strcmp(words[3], "enable") != 0) {
+        cli_out("Invalid quota option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "type",
-                              GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS);
-        if (ret < 0)
-                goto out;
+    ret = dict_set_int32(dict, "type", GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS);
+    if (ret < 0)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 out:
-        if (ret < 0) {
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret < 0) {
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_quota_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_quota_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t          *dict    = NULL;
-        char            *volname = NULL;
-        int              ret     = -1;
-        int              i       = -1;
-        char             key[20] = {0, };
-        int64_t          value   = 0;
-        gf_quota_type    type    = GF_QUOTA_OPTION_TYPE_NONE;
-        char           *opwords[] = { "enable", "disable", "limit-usage",
-                                      "remove", "list", "alert-time",
-                                      "soft-timeout", "hard-timeout",
-                                      "default-soft-limit", "limit-objects",
-                                      "list-objects", "remove-objects", NULL};
-        char            *w       = NULL;
-        uint32_t         time    = 0;
-        double           percent = 0;
-        char            *end_ptr = NULL;
-        int64_t          limit   = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "dict_new failed");
-                goto out;
-        }
-
-        if (wordcount < 4) {
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int i = -1;
+    char key[20] = {
+        0,
+    };
+    int64_t value = 0;
+    gf_quota_type type = GF_QUOTA_OPTION_TYPE_NONE;
+    static char *opwords[] = {"enable",
+                              "disable",
+                              "limit-usage",
+                              "remove",
+                              "list",
+                              "alert-time",
+                              "soft-timeout",
+                              "hard-timeout",
+                              "default-soft-limit",
+                              "limit-objects",
+                              "list-objects",
+                              "remove-objects",
+                              NULL};
+    char *w = NULL;
+    uint32_t time = 0;
+    double percent = 0;
+    char *end_ptr = NULL;
+    int64_t limit = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "dict_new failed");
+        goto out;
+    }
 
-                if ((wordcount == 3) && !(strcmp (words[2], "help"))) {
-                        ret = 1;
-                }
-                goto out;
-        }
-
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
+    if (wordcount < 4) {
+        if ((wordcount == 3) && !(strcmp(words[2], "help"))) {
+            ret = 1;
         }
+        goto out;
+    }
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                cli_out ("Invalid quota option : %s", words[3]);
-                ret = - 1;
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret < 0)
+        goto out;
 
-        if (strcmp (w, "enable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_QUOTA_OPTION_TYPE_ENABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        cli_out("Invalid quota option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
 
-        if (strcmp (w, "disable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_QUOTA_OPTION_TYPE_DISABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    if (strcmp(w, "enable") == 0) {
+        if (wordcount == 4) {
+            type = GF_QUOTA_OPTION_TYPE_ENABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (strcmp (w, "limit-usage") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIMIT_USAGE;
-        } else if (strcmp (w, "limit-objects") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS;
+    if (strcmp(w, "disable") == 0) {
+        if (wordcount == 4) {
+            type = GF_QUOTA_OPTION_TYPE_DISABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE ||
-            type == GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS) {
-
-                if (wordcount < 6 || wordcount > 7) {
-                        ret = -1;
-                        goto out;
-                }
+    if (strcmp(w, "limit-usage") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIMIT_USAGE;
+    } else if (strcmp(w, "limit-objects") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS;
+    }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret)
-                        goto out;
-
-                if (!words[5]) {
-                        cli_err ("Please enter the limit value to be set");
-                        ret = -1;
-                        goto out;
-                }
-
-                if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE) {
-                        ret = gf_string2bytesize_int64 (words[5], &value);
-                        if (ret != 0 || value <= 0) {
-                                if (errno == ERANGE || value <= 0) {
-                                        ret = -1;
-                                        cli_err ("Please enter an integer "
-                                                 "value in the range of "
-                                                 "(1 - %"PRId64 ")",
-                                                 INT64_MAX);
-                                } else
-                                        cli_err ("Please enter a correct "
-                                                 "value");
-                                goto out;
-                        }
-                } else {
-                        errno = 0;
-                        limit = strtol (words[5], &end_ptr, 10);
-                        if (errno == ERANGE || errno == EINVAL || limit <= 0
-                                            || strcmp (end_ptr, "") != 0) {
-                                ret = -1;
-                                cli_err ("Please enter an integer value in "
-                                         "the range 1 - %"PRId64, INT64_MAX);
-                                goto out;
-                        }
-                }
-
-                ret  = dict_set_str (dict, "hard-limit", (char *) words[5]);
-                if (ret < 0)
-                        goto out;
+    if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE ||
+        type == GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS) {
+        if (wordcount < 6 || wordcount > 7) {
+            ret = -1;
+            goto out;
+        }
 
-                if (wordcount == 7) {
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret)
+            goto out;
+
+        if (!words[5]) {
+            cli_err("Please enter the limit value to be set");
+            ret = -1;
+            goto out;
+        }
+
+        if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE) {
+            ret = gf_string2bytesize_int64(words[5], &value);
+            if (ret != 0 || value <= 0) {
+                if (errno == ERANGE || value <= 0) {
+                    ret = -1;
+                    cli_err(
+                        "Please enter an integer "
+                        "value in the range of "
+                        "(1 - %" PRId64 ")",
+                        INT64_MAX);
+                } else
+                    cli_err(
+                        "Please enter a correct "
+                        "value");
+                goto out;
+            }
+        } else {
+            errno = 0;
+            limit = strtol(words[5], &end_ptr, 10);
+            if (errno == ERANGE || errno == EINVAL || limit <= 0 ||
+                strcmp(end_ptr, "") != 0) {
+                ret = -1;
+                cli_err(
+                    "Please enter an integer value in "
+                    "the range 1 - %" PRId64,
+                    INT64_MAX);
+                goto out;
+            }
+        }
 
-                        ret = gf_string2percent (words[6], &percent);
-                        if (ret != 0 || percent > 100) {
-                                ret = -1;
-                                cli_err ("Please enter a correct value "
-                                         "in the range of 0 to 100");
-                                goto out;
-                        }
+        ret = dict_set_str(dict, "hard-limit", (char *)words[5]);
+        if (ret < 0)
+            goto out;
 
-                        ret = dict_set_str (dict, "soft-limit",
-                                            (char *) words[6]);
-                        if (ret < 0)
-                                goto out;
-                }
+        if (wordcount == 7) {
+            ret = gf_string2percent(words[6], &percent);
+            if (ret != 0 || percent > 100) {
+                ret = -1;
+                cli_err(
+                    "Please enter a correct value "
+                    "in the range of 0 to 100");
+                goto out;
+            }
 
-                goto set_type;
+            ret = dict_set_str(dict, "soft-limit", (char *)words[6]);
+            if (ret < 0)
+                goto out;
         }
 
-        if (strcmp (w, "remove") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-
-                type = GF_QUOTA_OPTION_TYPE_REMOVE;
-
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        goto set_type;
+    }
 
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+    if (strcmp(w, "remove") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "remove-objects") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
+        type = GF_QUOTA_OPTION_TYPE_REMOVE;
 
-                type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
+        }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+    if (strcmp(w, "remove-objects") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "list") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
 
-                type = GF_QUOTA_OPTION_TYPE_LIST;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
+        }
 
-                if (words[4] && words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                i = 4;
-                while (i < wordcount) {
-                        snprintf (key, 20, "path%d", i-4);
+    if (strcmp(w, "list") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIST;
 
-                        ret = dict_set_str (dict, key, (char *) words [i++]);
-                        if (ret < 0)
-                                goto out;
-                }
+        if (words[4] && words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
+        }
 
-                ret = dict_set_int32 (dict, "count", i - 4);
-                if (ret < 0)
-                        goto out;
+        i = 4;
+        while (i < wordcount) {
+            snprintf(key, 20, "path%d", i - 4);
 
-                goto set_type;
+            ret = dict_set_str(dict, key, (char *)words[i++]);
+            if (ret < 0)
+                goto out;
         }
 
-        if (strcmp (w, "list-objects") == 0) {
-                if (wordcount < 4) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_int32(dict, "count", i - 4);
+        if (ret < 0)
+            goto out;
 
-                type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
+        goto set_type;
+    }
 
-                i = 4;
-                while (i < wordcount) {
-                        snprintf (key, 20, "path%d", i-4);
+    if (strcmp(w, "list-objects") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
 
-                        ret = dict_set_str (dict, key, (char *) words[i++]);
-                        if (ret < 0) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                        "quota patch in request dictionary");
-                                goto out;
-                        }
-                }
+        i = 4;
+        while (i < wordcount) {
+            snprintf(key, 20, "path%d", i - 4);
 
-                ret = dict_set_int32 (dict, "count", i - 4);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set quota "
-                                "limit count in request dictionary");
-                        goto out;
-                }
+            ret = dict_set_str(dict, key, (char *)words[i++]);
+            if (ret < 0) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to set "
+                       "quota patch in request dictionary");
+                goto out;
+            }
+        }
 
-                goto set_type;
+        ret = dict_set_int32(dict, "count", i - 4);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set quota "
+                   "limit count in request dictionary");
+            goto out;
         }
 
-        if (strcmp (w, "alert-time") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_ALERT_TIME;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "alert-time") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_ALERT_TIME;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
 
-        if (strcmp (w, "soft-timeout") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT;
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "soft-timeout") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
 
-        if (strcmp (w, "hard-timeout") == 0) {
-                if(wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT;
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "hard-timeout") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
-        if (strcmp (w, "default-soft-limit") == 0) {
-                if(wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
-        } else {
-                GF_ASSERT (!"opword mismatch");
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
+    if (strcmp(w, "default-soft-limit") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
         }
+        type = GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT;
 
-set_type:
-        ret = dict_set_int32 (dict, "type", type);
+        ret = dict_set_str(dict, "value", (char *)words[4]);
         if (ret < 0)
-                goto out;
+            goto out;
+        goto set_type;
+    } else {
+        GF_ASSERT(!"opword mismatch");
+    }
 
-        *options = dict;
+set_type:
+    ret = dict_set_int32(dict, "type", type);
+    if (ret < 0)
+        goto out;
+
+    *options = dict;
 out:
-        if (ret < 0) {
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret < 0) {
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-cli_is_key_spl (char *key)
+cli_is_key_spl(char *key)
 {
-        return (strcmp (key, "group") == 0);
+    return (strcmp(key, "group") == 0);
 }
 
-static int
-cli_add_key_group (dict_t *dict, char *key, char *value, char **op_errstr)
+static int32_t
+cli_add_key_group_value(dict_t *dict, const char *name, const char *value,
+                        int32_t id, char **op_errstr)
 {
-        int             ret = -1;
-        int             opt_count = 0;
-        char            iter_key[1024] = {0,};
-        char            iter_val[1024] = {0,};
-        char            *saveptr = NULL;
-        char            *tok_key = NULL;
-        char            *tok_val = NULL;
-        char            *dkey = NULL;
-        char            *dval = NULL;
-        char            *tagpath = NULL;
-        char            *buf = NULL;
-        char            line[PATH_MAX + 256] = {0,};
-        char            errstr[2048] = "";
-        FILE            *fp = NULL;
-
-        ret = gf_asprintf (&tagpath, "%s/groups/%s",
-                           GLUSTERD_DEFAULT_WORKDIR, value);
-        if (ret == -1) {
-                tagpath = NULL;
-                goto out;
-        }
+    char *key = NULL;
+    char *data = NULL;
+    int32_t ret = -1;
 
-        fp = fopen (tagpath, "r");
-        if (!fp) {
-                ret = -1;
-                snprintf(errstr, sizeof(errstr), "Unable to open file '%s'."
-                         " Error: %s", tagpath, strerror (errno));
-                if (op_errstr)
-                        *op_errstr = gf_strdup(errstr);
-                goto out;
-        }
+    ret = gf_asprintf(&key, "%s%d", name, id);
+    if (ret < 0) {
+        goto out;
+    }
+    data = gf_strdup(value);
+    if (data == NULL) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to allocate memory for data");
+        ret = -1;
+        goto out;
+    }
 
-        opt_count = 0;
-        buf = line;
-        while (fscanf (fp, "%s", buf) != EOF) {
+    ret = dict_set_dynstr(dict, key, data);
+    if (ret == 0) {
+        data = NULL;
+    }
 
-                opt_count++;
-                tok_key = strtok_r (line, "=", &saveptr);
-                tok_val = strtok_r (NULL, "=", &saveptr);
-                if (!tok_key || !tok_val) {
-                        ret = -1;
-                        snprintf(errstr, sizeof(errstr), "'%s' file format "
-                                 "not valid.", tagpath);
-                        if (op_errstr)
-                                *op_errstr = gf_strdup(errstr);
-                        goto out;
-                }
+out:
+    GF_FREE(key);
+    GF_FREE(data);
 
-                snprintf (iter_key, sizeof (iter_key), "key%d", opt_count);
-                dkey = gf_strdup (tok_key);
-                ret = dict_set_dynstr (dict, iter_key, dkey);
-                if (ret)
-                        goto out;
-                dkey = NULL;
+    if ((ret != 0) && (op_errstr != NULL)) {
+        *op_errstr = gf_strdup("Failed to allocate memory");
+    }
 
-                snprintf (iter_val, sizeof (iter_val), "value%d", opt_count);
-                dval = gf_strdup (tok_val);
-                ret = dict_set_dynstr (dict, iter_val, dval);
-                if (ret)
-                        goto out;
-                dval = NULL;
+    return ret;
+}
 
-        }
+static int
+cli_add_key_group(dict_t *dict, char *key, char *value, char **op_errstr)
+{
+    int ret = -1;
+    int opt_count = 0;
+    char *saveptr = NULL;
+    char *tok_key = NULL;
+    char *tok_val = NULL;
+    char *tagpath = NULL;
+    char line[PATH_MAX + 256] = {
+        0,
+    };
+    FILE *fp = NULL;
+
+    ret = gf_asprintf(&tagpath, "%s/groups/%s", GLUSTERD_DEFAULT_WORKDIR,
+                      value);
+    if (ret == -1) {
+        tagpath = NULL;
+        goto out;
+    }
 
-        if (!opt_count) {
-                ret = -1;
-                snprintf(errstr, sizeof(errstr), "'%s' file format "
-                         "not valid.", tagpath);
-                if (op_errstr)
-                        *op_errstr = gf_strdup(errstr);
-                goto out;
+    fp = fopen(tagpath, "r");
+    if (!fp) {
+        ret = -1;
+        if (op_errstr) {
+            gf_asprintf(op_errstr,
+                        "Unable to open file '%s'. "
+                        "Error: %s",
+                        tagpath, strerror(errno));
         }
-        ret = dict_set_int32 (dict, "count", opt_count);
+        goto out;
+    }
+
+    opt_count = 0;
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (strlen(line) >= sizeof(line) - 1) {
+            ret = -1;
+            if (op_errstr != NULL) {
+                *op_errstr = gf_strdup("Line too long");
+            }
+            goto out;
+        }
+
+        /* Treat line that start with "#" as comments */
+        if ('#' == line[0])
+            continue;
+
+        opt_count++;
+        tok_key = strtok_r(line, "=", &saveptr);
+        tok_val = strtok_r(NULL, "\r\n", &saveptr);
+        if (!tok_key || !tok_val) {
+            ret = -1;
+            if (op_errstr) {
+                gf_asprintf(op_errstr,
+                            "'%s' file format "
+                            "not valid.",
+                            tagpath);
+            }
+            goto out;
+        }
+
+        ret = cli_add_key_group_value(dict, "key", tok_key, opt_count,
+                                      op_errstr);
+        if (ret != 0) {
+            goto out;
+        }
+        ret = cli_add_key_group_value(dict, "value", tok_val, opt_count,
+                                      op_errstr);
+        if (ret != 0) {
+            goto out;
+        }
+    }
+
+    if (!opt_count) {
+        ret = -1;
+        if (op_errstr) {
+            gf_asprintf(op_errstr, "'%s' file format not valid.", tagpath);
+        }
+        goto out;
+    }
+    ret = dict_set_int32(dict, "count", opt_count);
 out:
 
-        GF_FREE (tagpath);
+    GF_FREE(tagpath);
 
-        if (ret) {
-                GF_FREE (dkey);
-                GF_FREE (dval);
-        }
+    if (fp)
+        fclose(fp);
 
-        if (fp)
-                fclose (fp);
-
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_set_parse (struct cli_state *state, const char **words,
-                          int wordcount, dict_t **options, char **op_errstr)
+cli_cmd_volume_set_parse(struct cli_state *state, const char **words,
+                         int wordcount, dict_t **options, char **op_errstr)
 {
-        dict_t                 *dict      = NULL;
-        char                   *volname   = NULL;
-        int                     ret       = -1;
-        int                     count     = 0;
-        char                   *key       = NULL;
-        char                   *value     = NULL;
-        int                     i         = 0;
-        char                    str[50]   = {0,};
-        const char             *question  = NULL;
-        gf_answer_t             answer    = GF_ANSWER_NO;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
-
-        if (wordcount < 3)
-                goto out;
-
-        volname = (char *)words[2];
-
-        GF_ASSERT (volname);
-
-        ret = dict_set_str (dict, "volname", volname);
-
-        if (ret)
-                goto out;
-
-        if (!strcmp (volname, "all")) {
-                ret = dict_set_str (dict, "globalname", "All");
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "dict set on global key failed.");
-                        goto out;
-                }
-
-                ret = dict_set_int32 (dict, "hold_global_locks", _gf_true);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "dict set on global key failed.");
-                        goto out;
-                }
-        }
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int count = 0;
+    char *key = NULL;
+    char *value = NULL;
+    int i = 0;
+    char str[50] = {
+        0,
+    };
+    const char *question = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        if ((!strcmp (volname, "help") || !strcmp (volname, "help-xml"))
-            && wordcount == 3 ) {
-                ret = dict_set_str (dict, volname, volname);
-                if (ret)
-                        goto out;
+    if (wordcount < 3)
+        goto out;
 
-        } else if (wordcount < 5) {
-                ret = -1;
-                goto out;
+    volname = (char *)words[2];
 
-        } else if (wordcount == 5  && cli_is_key_spl ((char *)words[3])) {
-                key = (char *) words[3];
-                value = (char *) words[4];
-                if ( !key || !value) {
-                        ret = -1;
-                        goto out;
-                }
+    GF_ASSERT(volname);
 
-                ret = gf_strip_whitespace (value, strlen (value));
-                if (ret == -1)
-                        goto out;
+    ret = dict_set_str(dict, "volname", volname);
 
-                if (strlen (value) == 0) {
-                        ret = -1;
-                        goto out;
-                }
+    if (ret)
+        goto out;
 
-                ret = cli_add_key_group (dict, key, value, op_errstr);
-                if (ret == 0)
-                        *options = dict;
-                goto out;
+    if (!strcmp(volname, "all")) {
+        ret = dict_set_str(dict, "globalname", "All");
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR, "dict set on global key failed.");
+            goto out;
         }
 
-        for (i = 3; i < wordcount; i+=2) {
-
-                key = (char *) words[i];
-                value = (char *) words[i+1];
-
-                if ( !key || !value) {
-                        ret = -1;
-                        goto out;
-                }
-
-                count++;
-
-                if (fnmatch ("user.*", key, FNM_NOESCAPE) != 0) {
-                        ret = gf_strip_whitespace (value, strlen (value));
-                        if (ret == -1)
-                                goto out;
-                }
-
-                if (strlen (value) == 0) {
-                        ret = -1;
-                        goto out;
-                }
-
-                if (cli_is_key_spl (key)) {
-                        ret = -1;
-                        goto out;
-                }
-
-                sprintf (str, "key%d", count);
-                ret = dict_set_str (dict, str, key);
-                if (ret)
-                        goto out;
-
-                sprintf (str, "value%d", count);
-                ret = dict_set_str (dict, str, value);
-
-                if (ret)
-                        goto out;
-
-                if ((!strcmp (key, "cluster.enable-shared-storage")) &&
-                    (!strcmp (value, "disable"))) {
-                        question = "Disabling cluster.enable-shared-storage "
-                                   "will delete the shared storage volume"
-                                   "(gluster_shared_storage), which is used "
-                                   "by snapshot scheduler, geo-replication "
-                                   "and NFS-Ganesha. Do you still want to "
-                                   "continue?";
-                        answer = cli_cmd_get_confirmation (state, question);
-                        if (GF_ANSWER_NO == answer) {
-                                gf_log ("cli", GF_LOG_ERROR, "Operation "
-                                        "cancelled, exiting");
-                                *op_errstr = gf_strdup ("Aborted by user.");
-                                ret = -1;
-                                goto out;
-                        }
-                }
-                if ((!strcmp (key, "nfs.disable")) &&
-                            (!strcmp (value, "off"))) {
-                        question = "Gluster NFS is being deprecated in favor "
-                                   "of NFS-Ganesha Enter \"yes\" to continue "
-                                   "using Gluster NFS";
-                        answer = cli_cmd_get_confirmation (state, question);
-                        if (GF_ANSWER_NO == answer) {
-                                gf_log ("cli", GF_LOG_ERROR, "Operation "
-                                        "cancelled, exiting");
-                                *op_errstr = gf_strdup ("Aborted by user.");
-                                ret = -1;
-                                goto out;
-                        }
-                }
+        ret = dict_set_int32(dict, "hold_global_locks", _gf_true);
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR, "dict set on global key failed.");
+            goto out;
         }
+    }
 
-        ret = dict_set_int32 (dict, "count", wordcount-3);
-
+    if ((!strcmp(volname, "help") || !strcmp(volname, "help-xml")) &&
+        wordcount == 3) {
+        ret = dict_set_str(dict, volname, volname);
         if (ret)
-                goto out;
-
-        *options = dict;
+            goto out;
 
-out:
-        if (ret && dict)
-                dict_unref (dict);
+    } else if (wordcount < 5) {
+        ret = -1;
+        goto out;
 
-        return ret;
-}
+    } else if (wordcount == 5 && cli_is_key_spl((char *)words[3])) {
+        key = (char *)words[3];
+        value = (char *)words[4];
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
 
-int32_t
-cli_cmd_volume_add_brick_parse (const char **words, int wordcount,
-                                dict_t **options, int *ret_type)
-{
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
-        int     brick_count = 0, brick_index = 0;
-        char    *bricks = NULL;
-        char    *opwords_cl[] = { "replica", "stripe", NULL };
-        gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
-        int     count = 1;
-        int     arbiter_count = 0;
-        char    *w = NULL;
-        int     index;
-        gf_boolean_t is_force = _gf_false;
-        int wc = wordcount;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
+        ret = gf_strip_whitespace(value, strlen(value));
+        if (ret == -1)
+            goto out;
 
-        if (wordcount < 3)
-                goto out;
+        if (strlen(value) == 0) {
+            ret = -1;
+            goto out;
+        }
 
-        volname = (char *)words[2];
+        ret = cli_add_key_group(dict, key, value, op_errstr);
+        if (ret == 0)
+            *options = dict;
+        goto out;
+    }
 
-        GF_ASSERT (volname);
+    for (i = 3; i < wordcount; i += 2) {
+        key = (char *)words[i];
+        value = (char *)words[i + 1];
 
-        ret = dict_set_str (dict, "volname", volname);
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
 
-        if (ret)
-                goto out;
+        count++;
 
-        if (wordcount < 4) {
-                ret = -1;
+        if (fnmatch("user.*", key, FNM_NOESCAPE) != 0) {
+            ret = gf_strip_whitespace(value, strlen(value));
+            if (ret == -1)
                 goto out;
         }
-        if (wordcount < 6) {
-                /* seems no options are given, go directly to the parse_brick */
-                brick_index = 3;
-                type = GF_CLUSTER_TYPE_NONE;
-                goto parse_bricks;
-        }
 
-        w = str_getunamb (words[3], opwords_cl);
-        if (!w) {
-                type = GF_CLUSTER_TYPE_NONE;
-                index = 3;
-        } else if ((strcmp (w, "replica")) == 0) {
-                type = GF_CLUSTER_TYPE_REPLICATE;
-                count = strtol (words[4], NULL, 0);
-                if (!count || (count < 2)) {
-                        cli_err ("replica count should be greater than 1");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_int32 (dict, "replica-count", count);
-                if (ret)
-                        goto out;
-                index = 5;
-                if (words[index] && !strcmp (words[index], "arbiter")) {
-                        arbiter_count = strtol (words[6], NULL, 0);
-                        if (arbiter_count != 1 || count != 3) {
-                                cli_err ("For arbiter configuration, replica "
-                                         "count must be 3 and arbiter count "
-                                         "must be 1. The 3rd brick of the "
-                                         "replica will be the arbiter");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_int32 (dict, "arbiter-count",
-                                              arbiter_count);
-                        if (ret)
-                                goto out;
-                        index = 7;
-                }
-        } else if ((strcmp (w, "stripe")) == 0) {
-                type = GF_CLUSTER_TYPE_STRIPE;
-                count = strtol (words[4], NULL, 0);
-                if (!count || (count < 2)) {
-                        cli_err ("stripe count should be greater than 1");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_int32 (dict, "stripe-count", count);
-                if (ret)
-                        goto out;
-                index = 5;
-        } else {
-                GF_ASSERT (!"opword mismatch");
-                ret = -1;
-                goto out;
+        if (strlen(value) == 0) {
+            ret = -1;
+            goto out;
         }
 
-        brick_index = index;
+        if (cli_is_key_spl(key)) {
+            ret = -1;
+            goto out;
+        }
 
-parse_bricks:
+        sprintf(str, "key%d", count);
+        ret = dict_set_str(dict, str, key);
+        if (ret)
+            goto out;
 
-        if (strcmp (words[wordcount - 1], "force") == 0) {
-                is_force = _gf_true;
-                wc = wordcount - 1;
-        }
+        sprintf(str, "value%d", count);
+        ret = dict_set_str(dict, str, value);
 
-        ret = cli_cmd_bricks_parse (words, wc, brick_index, &bricks,
-                                    &brick_count);
         if (ret)
+            goto out;
+
+        if ((!strcmp(key, "cluster.enable-shared-storage")) &&
+            (!strcmp(value, "disable"))) {
+            question =
+                "Disabling cluster.enable-shared-storage "
+                "will delete the shared storage volume"
+                "(gluster_shared_storage), which is used "
+                "by snapshot scheduler, geo-replication "
+                "and NFS-Ganesha. Do you still want to "
+                "continue?";
+            answer = cli_cmd_get_confirmation(state, question);
+            if (GF_ANSWER_NO == answer) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Operation "
+                       "cancelled, exiting");
+                *op_errstr = gf_strdup("Aborted by user.");
+                ret = -1;
                 goto out;
-        if (!brick_count) {
-                cli_err ("No bricks specified");
+            }
+        }
+        if ((!strcmp(key, "nfs.disable")) && (!strcmp(value, "off"))) {
+            question =
+                "Gluster NFS is being deprecated in favor "
+                "of NFS-Ganesha Enter \"yes\" to continue "
+                "using Gluster NFS";
+            answer = cli_cmd_get_confirmation(state, question);
+            if (GF_ANSWER_NO == answer) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Operation "
+                       "cancelled, exiting");
+                *op_errstr = gf_strdup("Aborted by user.");
                 ret = -1;
                 goto out;
+            }
         }
-        ret = dict_set_dynstr (dict, "bricks", bricks);
-        if (ret)
-                goto out;
+    }
 
-        ret = dict_set_int32 (dict, "count", brick_count);
+    ret = dict_set_int32(dict, "count", wordcount - 3);
 
-        if (ret)
-                goto out;
-
-        ret = dict_set_int32 (dict, "force", is_force);
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret_type)
-                *ret_type = type;
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse add-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_tier_parse (const char **words, int wordcount,
-                           dict_t **options)
+cli_cmd_volume_add_brick_parse(struct cli_state *state, const char **words,
+                               int wordcount, dict_t **options, int *ret_type)
 {
-        dict_t  *dict    = NULL;
-        char    *volname = NULL;
-        int      ret     = -1;
-        int32_t  command = GF_DEFRAG_CMD_NONE;
-        int32_t  is_force    = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int brick_count = 0, brick_index = 0;
+    char *bricks = NULL;
+    static char *opwords_cl[] = {"replica", "stripe", NULL};
+    gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
+    int count = 1;
+    int arbiter_count = 0;
+    char *w = NULL;
+    int index;
+    gf_boolean_t is_force = _gf_false;
+    int wc = wordcount;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        dict = dict_new ();
+    if (wordcount < 3)
+        goto out;
 
-        if (!dict)
-                goto out;
+    volname = (char *)words[2];
 
-        if (!(wordcount == 4 || wordcount == 5)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                ret = -1;
-                goto out;
-        }
-
-        volname = (char *)words[2];
+    GF_ASSERT(volname);
 
-        GF_ASSERT (volname);
+    ret = dict_set_str(dict, "volname", volname);
 
-        ret = cli_cmd_validate_volume (volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to validate volume name");
-                goto out;
-        }
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", volname);
+    if (wordcount < 4) {
+        ret = -1;
+        goto out;
+    }
+    if (wordcount < 6) {
+        /* seems no options are given, go directly to the parse_brick */
+        brick_index = 3;
+        type = GF_CLUSTER_TYPE_NONE;
+        goto parse_bricks;
+    }
 
+    w = str_getunamb(words[3], opwords_cl);
+    if (!w) {
+        type = GF_CLUSTER_TYPE_NONE;
+        index = 3;
+    } else if ((strcmp(w, "replica")) == 0) {
+        type = GF_CLUSTER_TYPE_REPLICATE;
+        count = strtol(words[4], NULL, 0);
+        if (!count || (count < 2)) {
+            cli_err("replica count should be greater than 1");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_int32(dict, "replica-count", count);
         if (ret)
+            goto out;
+        index = 5;
+        if (words[index] && !strcmp(words[index], "arbiter")) {
+            arbiter_count = strtol(words[6], NULL, 0);
+            if (arbiter_count != 1 || count != 3) {
+                cli_err(
+                    "For arbiter configuration, replica "
+                    "count must be 3 and arbiter count "
+                    "must be 1. The 3rd brick of the "
+                    "replica will be the arbiter");
+                ret = -1;
                 goto out;
-
-        volname = (char *)words[2];
-        if (wordcount == 4) {
-                if (!strcmp(words[3], "status"))
-                        command = GF_DEFRAG_CMD_STATUS_TIER;
-                else if (!strcmp(words[3], "start"))
-                        command = GF_DEFRAG_CMD_START_TIER;
-                else if (!strcmp(words[3], "stop"))
-                        command = GF_DEFRAG_CMD_STOP_TIER;
-                else {
-                        ret = -1;
-                        goto out;
-                }
-        } else if (wordcount == 5) {
-                if ((!strcmp (words[3], "start")) &&
-                    (!strcmp (words[4], "force"))) {
-                        command = GF_DEFRAG_CMD_START_TIER;
-                        is_force = 1;
-                        ret = dict_set_int32 (dict, "force", is_force);
-                        if (ret)
-                                goto out;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (dict, "rebalance-command", command);
-        if (ret)
+            }
+            ret = dict_set_int32(dict, "arbiter-count", arbiter_count);
+            if (ret)
                 goto out;
+            index = 7;
+        }
 
-        *options = dict;
-out:
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse tier CLI");
-                if (dict)
-                        dict_unref (dict);
+        if (count == 2) {
+            if (strcmp(words[wordcount - 1], "force")) {
+                question =
+                    "Replica 2 volumes are prone to "
+                    "split-brain. Use Arbiter or "
+                    "Replica 3 to avoid this. See: "
+                    "http://docs.gluster.org/en/latest/Administrator%20Guide/"
+                    "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                    "\nDo you still want to continue?\n";
+                answer = cli_cmd_get_confirmation(state, question);
+                if (GF_ANSWER_NO == answer) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Add brick"
+                           " cancelled, exiting");
+                    ret = -1;
+                    goto out;
+                }
+            }
         }
+    } else if ((strcmp(w, "stripe")) == 0) {
+        cli_err("stripe option not supported");
+        goto out;
+    } else {
+        GF_ASSERT(!"opword mismatch");
+        ret = -1;
+        goto out;
+    }
 
-        return ret;
-}
+    brick_index = index;
 
-int32_t
-cli_cmd_volume_detach_tier_parse (const char **words, int wordcount,
-                                  dict_t **options, int *question)
-{
-        int      ret = -1;
-        char    *word = NULL;
-        dict_t  *dict = NULL;
-        int32_t  command = GF_DEFRAG_CMD_NONE;
+parse_bricks:
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    if (strcmp(words[wordcount - 1], "force") == 0) {
+        is_force = _gf_true;
+        wc = wordcount - 1;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
-
-        if (wordcount == 3 && !strcmp ((char *)words[2], "help")) {
-                return -1;
-        }
+    ret = cli_cmd_bricks_parse(words, wc, brick_index, &bricks, &brick_count);
+    if (ret)
+        goto out;
 
-        if (wordcount != 4) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_set_dynstr(dict, "bricks", bricks);
+    if (ret)
+        goto out;
 
-        word = (char *)words[3];
+    ret = dict_set_int32(dict, "count", brick_count);
 
-        ret = -1;
+    if (ret)
+        goto out;
 
-        if (!strcmp(word, "start")) {
-                command = GF_DEFRAG_CMD_DETACH_START;
-        } else if (!strcmp(word, "commit")) {
-                *question = 1;
-                command = GF_DEFRAG_CMD_DETACH_COMMIT;
-        } else if (!strcmp(word, "force")) {
-                *question = 1;
-                command = GF_DEFRAG_CMD_DETACH_COMMIT_FORCE;
-        } else if (!strcmp(word, "stop"))
-                command = GF_DEFRAG_CMD_DETACH_STOP;
-        else if (!strcmp(word, "status"))
-                command = GF_DEFRAG_CMD_DETACH_STATUS;
-        else
-                goto out;
+    ret = dict_set_int32(dict, "force", is_force);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "command", command);
-        if (ret)
-                goto out;
+    *options = dict;
 
-        *options = dict;
-        ret = 0;
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse detach tier CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret_type)
+        *ret_type = type;
 
-        return ret;
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse add-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
+
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_remove_brick_parse (const char **words, int wordcount,
-                                   dict_t **options, int *question,
-                                   int *brick_count)
+cli_cmd_volume_remove_brick_parse(struct cli_state *state, const char **words,
+                                  int wordcount, dict_t **options,
+                                  int *question, int *brick_count,
+                                  int32_t *comm)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *delimiter = NULL;
-        int     ret = -1;
-        char    key[50];
-        int     brick_index = 0;
-        int32_t tmp_index = 0;
-        int32_t j = 0;
-        char    *tmp_brick = NULL;
-        char    *tmp_brick1 = NULL;
-        char    *type_opword[] = { "replica", NULL };
-        char    *opwords[] = { "start", "commit", "stop", "status",
-                               "force", NULL };
-        char    *w = NULL;
-        int32_t  command = GF_OP_CMD_NONE;
-        long     count = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        if (wordcount < 5)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *delimiter = NULL;
+    int ret = -1;
+    char key[50];
+    int brick_index = 0;
+    int32_t tmp_index = 0;
+    int32_t j = 0;
+    char *tmp_brick = NULL;
+    char *tmp_brick1 = NULL;
+    static char *type_opword[] = {"replica", NULL};
+    static char *opwords[] = {"start",  "commit", "stop",
+                              "status", "force",  NULL};
+    char *w = NULL;
+    int32_t command = GF_OP_CMD_NONE;
+    long count = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *ques = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    if (wordcount < 5)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        brick_index = 3;
-        w = str_getunamb (words[3], type_opword);
-        if (w && !strcmp ("replica", w)) {
-                if (wordcount < 6) {
-                        ret = -1;
-                        goto out;
-                }
-                count = strtol (words[4], NULL, 0);
-                if (count < 1) {
-                        cli_err ("replica count should be greater than 0 in "
-                                 "case of remove-brick");
-                        ret = -1;
-                        goto out;
+    brick_index = 3;
+    w = str_getunamb(words[3], type_opword);
+    if (w && !strcmp("replica", w)) {
+        if (wordcount < 6) {
+            ret = -1;
+            goto out;
+        }
+        count = strtol(words[4], NULL, 0);
+        if (count < 1) {
+            cli_err(
+                "replica count should be greater than 0 in "
+                "case of remove-brick");
+            ret = -1;
+            goto out;
+        }
+
+        if (count == 2) {
+            if (strcmp(words[wordcount - 1], "force")) {
+                ques =
+                    "Replica 2 volumes are prone to "
+                    "split-brain. Use Arbiter or Replica 3 "
+                    "to avoid this. See: "
+                    "http://docs.gluster.org/en/latest/Administrator%20Guide/"
+                    "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                    "\nDo you still want to continue?\n";
+                answer = cli_cmd_get_confirmation(state, ques);
+                if (GF_ANSWER_NO == answer) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Remove "
+                           "brick cancelled, exiting");
+                    ret = -1;
+                    goto out;
                 }
-
-                ret = dict_set_int32 (dict, "replica-count", count);
-                if (ret)
-                        goto out;
-                brick_index = 5;
-        } else if (w) {
-                GF_ASSERT (!"opword mismatch");
+            }
         }
 
-        w = str_getunamb (words[wordcount - 1], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
+        ret = dict_set_int32(dict, "replica-count", count);
+        if (ret)
+            goto out;
+        brick_index = 5;
+    } else if (w) {
+        GF_ASSERT(!"opword mismatch");
+    }
+
+    w = str_getunamb(words[wordcount - 1], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    } else {
+        /* handled this option */
+        wordcount--;
+        if (!strcmp("start", w)) {
+            command = GF_OP_CMD_START;
+            if (question)
+                *question = 1;
+        } else if (!strcmp("commit", w)) {
+            command = GF_OP_CMD_COMMIT;
+        } else if (!strcmp("stop", w)) {
+            command = GF_OP_CMD_STOP;
+        } else if (!strcmp("status", w)) {
+            command = GF_OP_CMD_STATUS;
+        } else if (!strcmp("force", w)) {
+            command = GF_OP_CMD_COMMIT_FORCE;
+            if (question)
+                *question = 1;
         } else {
-                /* handled this option */
-                wordcount--;
-                if (!strcmp ("start", w)) {
-                        command = GF_OP_CMD_START;
-                } else if (!strcmp ("commit", w)) {
-                        command = GF_OP_CMD_COMMIT;
-                        if (question)
-                                *question = 1;
-                } else if (!strcmp ("stop", w)) {
-                        command = GF_OP_CMD_STOP;
-                } else if (!strcmp ("status", w)) {
-                        command = GF_OP_CMD_STATUS;
-                } else if (!strcmp ("force", w)) {
-                        command = GF_OP_CMD_COMMIT_FORCE;
-                        if (question)
-                                *question = 1;
-                } else {
-                        GF_ASSERT (!"opword mismatch");
-                        ret = -1;
-                        goto out;
-                }
+            GF_ASSERT(!"opword mismatch");
+            ret = -1;
+            goto out;
         }
+    }
 
-        ret = dict_set_int32 (dict, "command", command);
-        if (ret)
-                gf_log ("cli", GF_LOG_INFO, "failed to set 'command' %d",
-                        command);
-
+    ret = dict_set_int32(dict, "command", command);
+    if (ret)
+        gf_log("cli", GF_LOG_INFO, "failed to set 'command' %d", command);
 
-        tmp_index = brick_index;
-        tmp_brick = GF_MALLOC(2048 * sizeof(*tmp_brick), gf_common_mt_char);
+    tmp_index = brick_index;
+    tmp_brick = GF_MALLOC(2048 * sizeof(*tmp_brick), gf_common_mt_char);
 
-        if (!tmp_brick) {
-                gf_log ("",GF_LOG_ERROR,"cli_cmd_volume_remove_brick_parse: "
-                        "Unable to get memory");
-                ret = -1;
-                goto out;
-        }
+    if (!tmp_brick) {
+        gf_log("", GF_LOG_ERROR,
+               "cli_cmd_volume_remove_brick_parse: "
+               "Unable to get memory");
+        ret = -1;
+        goto out;
+    }
 
-        tmp_brick1 = GF_MALLOC(2048 * sizeof(*tmp_brick1), gf_common_mt_char);
+    tmp_brick1 = GF_MALLOC(2048 * sizeof(*tmp_brick1), gf_common_mt_char);
 
-        if (!tmp_brick1) {
-                gf_log ("",GF_LOG_ERROR,"cli_cmd_volume_remove_brick_parse: "
-                        "Unable to get memory");
+    if (!tmp_brick1) {
+        gf_log("", GF_LOG_ERROR,
+               "cli_cmd_volume_remove_brick_parse: "
+               "Unable to get memory");
+        ret = -1;
+        goto out;
+    }
+
+    while (brick_index < wordcount) {
+        if (validate_brick_name((char *)words[brick_index])) {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[brick_index]);
+            ret = -1;
+            goto out;
+        } else {
+            delimiter = strrchr(words[brick_index], ':');
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
+        }
+
+        j = tmp_index;
+        strcpy(tmp_brick, words[brick_index]);
+        while (j < brick_index) {
+            strcpy(tmp_brick1, words[j]);
+            if (!(strcmp(tmp_brick, tmp_brick1))) {
+                gf_log("", GF_LOG_ERROR,
+                       "Duplicate bricks"
+                       " found %s",
+                       words[brick_index]);
+                cli_err("Duplicate bricks found %s", words[brick_index]);
                 ret = -1;
                 goto out;
+            }
+            j++;
         }
+        snprintf(key, 50, "brick%d", ++(*brick_count));
+        ret = dict_set_str(dict, key, (char *)words[brick_index++]);
 
-        while (brick_index < wordcount) {
-                if (validate_brick_name ((char *)words[brick_index])) {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[brick_index]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        delimiter = strrchr(words[brick_index], ':');
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-
-                j = tmp_index;
-                strcpy(tmp_brick, words[brick_index]);
-                while ( j < brick_index) {
-                        strcpy(tmp_brick1, words[j]);
-                        if (!(strcmp (tmp_brick, tmp_brick1))) {
-                                gf_log("",GF_LOG_ERROR, "Duplicate bricks"
-                                       " found %s", words[brick_index]);
-                                cli_err("Duplicate bricks found %s",
-                                        words[brick_index]);
-                                ret = -1;
-                                goto out;
-                        }
-                        j++;
-                }
-                snprintf (key, 50, "brick%d", ++(*brick_count));
-                ret = dict_set_str (dict, key, (char *)words[brick_index++]);
-
-                if (ret)
-                        goto out;
-        }
+        if (ret)
+            goto out;
+    }
 
-        if (command != GF_OP_CMD_STATUS && command != GF_OP_CMD_STOP) {
-                ret = dict_set_int32 (dict, "count", *brick_count);
-                if (ret)
-                        goto out;
-        }
+    if (command != GF_OP_CMD_STATUS && command != GF_OP_CMD_STOP) {
+        ret = dict_set_int32(dict, "count", *brick_count);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse remove-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse remove-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        GF_FREE (tmp_brick);
-        GF_FREE (tmp_brick1);
+    GF_FREE(tmp_brick);
+    GF_FREE(tmp_brick1);
 
-        return ret;
+    *comm = command;
+
+    return ret;
 }
 
 int32_t
-cli_cmd_brick_op_validate_bricks (const char **words, dict_t *dict,
-				  int src, int dst)
+cli_cmd_brick_op_validate_bricks(const char **words, dict_t *dict, int src,
+                                 int dst)
 {
-        int             ret = -1;
-        char            *delimiter  = NULL;
-
-        if (validate_brick_name ((char *)words[src])) {
-                cli_err ("wrong brick type: %s, use "
-                         "<HOSTNAME>:<export-dir-abs-path>", words[3]);
-                ret = -1;
-                goto out;
-        } else {
-                delimiter = strrchr ((char *)words[src], '/');
-                ret = gf_canonicalize_path (delimiter);
-                if (ret)
-                        goto out;
-        }
-
-        ret = dict_set_str (dict, "src-brick", (char *)words[src]);
+    int ret = -1;
+    char *delimiter = NULL;
+
+    if (validate_brick_name((char *)words[src])) {
+        cli_err(
+            "wrong brick type: %s, use "
+            "<HOSTNAME>:<export-dir-abs-path>",
+            words[3]);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr((char *)words[src], '/');
+        ret = gf_canonicalize_path(delimiter);
         if (ret)
-                goto out;
+            goto out;
+    }
 
-        if (dst == -1) {
-                ret = 0;
-                goto out;
-        }
+    ret = dict_set_str(dict, "src-brick", (char *)words[src]);
+    if (ret)
+        goto out;
 
-        if (validate_brick_name ((char *)words[dst])) {
-                cli_err ("wrong brick type: %s, use "
-                         "<HOSTNAME>:<export-dir-abs-path>", words[dst]);
-                ret = -1;
-                goto out;
-        } else {
-                delimiter = strrchr ((char *)words[dst], '/');
-                ret = gf_canonicalize_path (delimiter);
-                if (ret)
-                        goto out;
-        }
+    if (dst == -1) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "dst-brick", (char *)words[dst]);
+    if (validate_brick_name((char *)words[dst])) {
+        cli_err(
+            "wrong brick type: %s, use "
+            "<HOSTNAME>:<export-dir-abs-path>",
+            words[dst]);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr((char *)words[dst], '/');
+        ret = gf_canonicalize_path(delimiter);
         if (ret)
-                goto out;
-        ret = 0;
+            goto out;
+    }
+
+    ret = dict_set_str(dict, "dst-brick", (char *)words[dst]);
+    if (ret)
+        goto out;
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_reset_brick_parse (const char **words, int wordcount,
-                                  dict_t **options)
+cli_cmd_volume_reset_brick_parse(const char **words, int wordcount,
+                                 dict_t **options)
 {
-        int                   ret        = -1;
-        char                 *volname    = NULL;
-        dict_t               *dict       = NULL;
-
-        if (wordcount < 5 || wordcount > 7)
-                goto out;
+    int ret = -1;
+    char *volname = NULL;
+    dict_t *dict = NULL;
 
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
+    if (wordcount < 5 || wordcount > 7)
+        goto out;
 
-        volname = (char *)words[2];
+    dict = dict_new();
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    if (!dict)
+        goto out;
 
-        if (wordcount == 5) {
-                if (strcmp (words[4], "start")) {
-                        cli_err ("Invalid option '%s' for reset-brick. Please "
-                                 "enter valid reset-brick command", words[4]);
-                        ret = -1;
-                        goto out;
-                }
+    volname = (char *)words[2];
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, -1);
-                if (ret)
-                        goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-                ret = dict_set_str (dict, "operation", "GF_RESET_OP_START");
-                if (ret)
-                        goto out;
-        } else if (wordcount == 6) {
-                if (strcmp (words[5], "commit")) {
-                        cli_err ("Invalid option '%s' for reset-brick. Please "
-                                 "enter valid reset-brick command", words[5]);
-                        ret = -1;
-                        goto out;
-                }
+    if (wordcount == 5) {
+        if (strcmp(words[4], "start")) {
+            cli_err(
+                "Invalid option '%s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[4]);
+            ret = -1;
+            goto out;
+        }
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-                if (ret)
-                        goto out;
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, -1);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "operation", "GF_RESET_OP_COMMIT");
-                if (ret)
-                        goto out;
-        } else if (wordcount == 7) {
-                if (strcmp (words[5], "commit") || strcmp (words[6], "force")) {
-                        cli_err ("Invalid option '%s %s' for reset-brick. Please "
-                                 "enter valid reset-brick command",
-                                  words[5], words[6]);
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_START");
+        if (ret)
+            goto out;
+    } else if (wordcount == 6) {
+        if (strcmp(words[5], "commit")) {
+            cli_err(
+                "Invalid option '%s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[5]);
+            ret = -1;
+            goto out;
+        }
+
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+        if (ret)
+            goto out;
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-                if (ret)
-                        goto out;
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_COMMIT");
+        if (ret)
+            goto out;
+    } else if (wordcount == 7) {
+        if (strcmp(words[5], "commit") || strcmp(words[6], "force")) {
+            cli_err(
+                "Invalid option '%s %s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[5], words[6]);
+            ret = -1;
+            goto out;
+        }
+
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "operation",
-                                    "GF_RESET_OP_COMMIT_FORCE");
-                if (ret)
-                        goto out;
-        }
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_COMMIT_FORCE");
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unable to parse reset-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
-                                    dict_t **options)
+cli_cmd_volume_replace_brick_parse(const char **words, int wordcount,
+                                   dict_t **options)
 {
-        int                   ret        = -1;
-        char                 *volname    = NULL;
-        dict_t               *dict       = NULL;
+    int ret = -1;
+    char *volname = NULL;
+    dict_t *dict = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        if (wordcount != 7) {
-                ret = -1;
-                goto out;
-        }
+    if (wordcount != 7) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to allocate dictionary");
-                goto out;
-        }
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to allocate dictionary");
+        goto out;
+    }
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-        if (ret)
-                goto out;
+    ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+    if (ret)
+        goto out;
 
-        /* commit force option */
-        if (strcmp ("commit", words[5]) || strcmp ("force", words[6])) {
-                cli_err ("Invalid option '%s' '%s' for replace-brick. Please "
-                         "enter valid replace-brick command", words[5],
-                         words[6]);
-                ret = -1;
-                goto out;
-        }
+    /* commit force option */
+    if (strcmp("commit", words[5]) || strcmp("force", words[6])) {
+        cli_err(
+            "Invalid option '%s' '%s' for replace-brick. Please "
+            "enter valid replace-brick command",
+            words[5], words[6]);
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "operation", "GF_REPLACE_OP_COMMIT_FORCE");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "operation", "GF_REPLACE_OP_COMMIT_FORCE");
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_filename_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_filename_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[3];
-        GF_ASSERT (volname);
+    volname = (char *)words[3];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        str = (char *)words[4];
-        if (strchr (str, ':')) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
-                /* Path */
-                str = (char *)words[5];
-                ret = dict_set_str (dict, "path", str);
-                if (ret)
-                        goto out;
+    str = (char *)words[4];
+    if (strchr(str, ':')) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
         } else {
-                ret = dict_set_str (dict, "path", str);
-                if (ret)
-                        goto out;
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+        /* Path */
+        str = (char *)words[5];
+        ret = dict_set_str(dict, "path", str);
+        if (ret)
+            goto out;
+    } else {
+        ret = dict_set_str(dict, "path", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_level_parse (const char **words, int worcount, dict_t **options)
+cli_cmd_log_level_parse(const char **words, int worcount, dict_t **options)
 {
-        dict_t *dict            = NULL;
-        int     ret             = -1;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        /*
-         * loglevel command format:
-         *  > volume log level <VOL> <XLATOR[*]> <LOGLEVEL>
-         *  > volume log level colon-o posix WARNING
-         *  > volume log level colon-o replicate* DEBUG
-         *  > volume log level coon-o * TRACE
-         */
-
-        GF_ASSERT ((strncmp(words[0], "volume", 6) == 0));
-        GF_ASSERT ((strncmp(words[1], "log", 3) == 0));
-        GF_ASSERT ((strncmp(words[2], "level", 5) == 0));
-
-        ret = glusterd_check_log_level(words[5]);
-        if (ret == -1) {
-                cli_err("Invalid log level [%s] specified", words[5]);
-                cli_err("Valid values for loglevel: (DEBUG|WARNING|ERROR"
-                        "|CRITICAL|NONE|TRACE)");
-                goto out;
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    /*
+     * loglevel command format:
+     *  > volume log level <VOL> <XLATOR[*]> <LOGLEVEL>
+     *  > volume log level colon-o posix WARNING
+     *  > volume log level colon-o replicate* DEBUG
+     *  > volume log level coon-o * TRACE
+     */
+
+    GF_ASSERT((strncmp(words[0], "volume", 6) == 0));
+    GF_ASSERT((strncmp(words[1], "log", 3) == 0));
+    GF_ASSERT((strncmp(words[2], "level", 5) == 0));
+
+    ret = glusterd_check_log_level(words[5]);
+    if (ret == -1) {
+        cli_err("Invalid log level [%s] specified", words[5]);
+        cli_err(
+            "Valid values for loglevel: (DEBUG|WARNING|ERROR"
+            "|CRITICAL|NONE|TRACE)");
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        GF_ASSERT(words[3]);
-        GF_ASSERT(words[4]);
+    GF_ASSERT(words[3]);
+    GF_ASSERT(words[4]);
 
-        ret = dict_set_str (dict, "volname", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "xlator", (char *)words[4]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "xlator", (char *)words[4]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "loglevel", (char *)words[5]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "loglevel", (char *)words[5]);
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
- out:
-        if (ret && dict)
-                dict_unref (dict);
+out:
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_locate_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_locate_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[3];
-        GF_ASSERT (volname);
+    volname = (char *)words[3];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (words[4]) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                str = (char *)words[4];
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
+    if (words[4]) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
+        } else {
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        str = (char *)words[4];
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_rotate_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_rotate_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp ("rotate", words[3]) == 0)
-                volname = (char *)words[2];
-        else if (strcmp ("rotate", words[2]) == 0)
-                volname = (char *)words[3];
-        GF_ASSERT (volname);
+    if (strcmp("rotate", words[3]) == 0)
+        volname = (char *)words[2];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (words[4]) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                str = (char *)words[4];
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
+    if (words[4]) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
+        } else {
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        str = (char *)words[4];
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
+}
+
+static gf_boolean_t
+gsyncd_url_check(const char *w)
+{
+    return !!strpbrk(w, ":/");
 }
 
 static gf_boolean_t
-gsyncd_url_check (const char *w)
+valid_slave_gsyncd_url(const char *w)
 {
-        return !!strpbrk (w, ":/");
+    if (strstr(w, ":::"))
+        return _gf_false;
+    else if (strstr(w, "::"))
+        return _gf_true;
+    else
+        return _gf_false;
 }
 
 static gf_boolean_t
-gsyncd_glob_check (const char *w)
+gsyncd_glob_check(const char *w)
 {
-        return !!strpbrk (w, "*?[");
+    return !!strpbrk(w, "*?[");
 }
 
 static int
-config_parse (const char **words, int wordcount, dict_t *dict,
-              unsigned cmdi, unsigned glob)
+config_parse(const char **words, int wordcount, dict_t *dict, unsigned cmdi,
+             unsigned glob)
 {
-        int32_t            ret     = -1;
-        int32_t            i       = -1;
-        char               *append_str = NULL;
-        size_t             append_len = 0;
-        char               *subop = NULL;
-        char               *ret_chkpt = NULL;
-        struct tm           checkpoint_time;
-        char                chkpt_buf[20] = "";
-
-        switch ((wordcount - 1) - cmdi) {
+    int32_t ret = -1;
+    int32_t i = -1;
+    char *append_str = NULL;
+    size_t append_len = 0;
+    char *subop = NULL;
+    char *ret_chkpt = NULL;
+    struct tm checkpoint_time;
+    char chkpt_buf[20] = "";
+
+    switch ((wordcount - 1) - cmdi) {
         case 0:
-                subop = gf_strdup ("get-all");
-                break;
+            subop = gf_strdup("get-all");
+            break;
         case 1:
-                if (words[cmdi + 1][0] == '!') {
-                        (words[cmdi + 1])++;
-                        if (gf_asprintf (&subop, "del%s",
-                                         glob ? "-glob" : "") == -1)
-                                subop = NULL;
-                } else
-                        subop = gf_strdup ("get");
+            if (words[cmdi + 1][0] == '!') {
+                (words[cmdi + 1])++;
+                if (gf_asprintf(&subop, "del%s", glob ? "-glob" : "") == -1)
+                    subop = NULL;
+            } else
+                subop = gf_strdup("get");
 
-                ret = dict_set_str (dict, "op_name", ((char *)words[cmdi + 1]));
-                if (ret < 0)
-                        goto out;
-                break;
+            ret = dict_set_str(dict, "op_name", ((char *)words[cmdi + 1]));
+            if (ret < 0)
+                goto out;
+            break;
         default:
-                if (gf_asprintf (&subop, "set%s", glob ? "-glob" : "") == -1)
-                        subop = NULL;
+            if (gf_asprintf(&subop, "set%s", glob ? "-glob" : "") == -1)
+                subop = NULL;
 
-                ret = dict_set_str (dict, "op_name", ((char *)words[cmdi + 1]));
-                if (ret < 0)
-                        goto out;
+            ret = dict_set_str(dict, "op_name", ((char *)words[cmdi + 1]));
+            if (ret < 0)
+                goto out;
 
-                /* join the varargs by spaces to get the op_value */
+            /* join the varargs by spaces to get the op_value */
 
-                for (i = cmdi + 2; i < wordcount; i++)
-                        append_len += (strlen (words[i]) + 1);
-                /* trailing strcat will add two bytes, make space for that */
-                append_len++;
+            for (i = cmdi + 2; i < wordcount; i++)
+                append_len += (strlen(words[i]) + 1);
+            /* trailing strcat will add two bytes, make space for that */
+            append_len++;
 
-                append_str = GF_CALLOC (1, append_len, cli_mt_append_str);
-                if (!append_str) {
-                        ret = -1;
-                        goto out;
-                }
+            /* strcat is used on this allocation and hence expected to be
+             * initiatlized to 0. So GF_CALLOC is used.
+             */
+            append_str = GF_CALLOC(1, append_len, cli_mt_append_str);
+            if (!append_str) {
+                ret = -1;
+                goto out;
+            }
+
+            for (i = cmdi + 2; i < wordcount; i++) {
+                strcat(append_str, words[i]);
+                strcat(append_str, " ");
+            }
+            append_str[append_len - 2] = '\0';
+            /* "checkpoint now" is special: we resolve that "now" */
+            if ((strcmp(words[cmdi + 1], "checkpoint") == 0) &&
+                (strcmp(append_str, "now") == 0)) {
+                struct timeval tv = {
+                    0,
+                };
+
+                ret = gettimeofday(&tv, NULL);
+                if (ret == -1)
+                    goto out;
 
-                for (i = cmdi + 2; i < wordcount; i++) {
-                        strcat (append_str, words[i]);
-                        strcat (append_str, " ");
-                }
-                append_str[append_len - 2] = '\0';
-                /* "checkpoint now" is special: we resolve that "now" */
-                if ((strcmp (words[cmdi + 1], "checkpoint") == 0) &&
-                    (strcmp (append_str, "now") == 0)) {
-                        struct timeval tv = {0,};
-
-                        ret = gettimeofday (&tv, NULL);
-                        if (ret == -1)
-                                goto out;
-
-                        GF_FREE (append_str);
-                        append_str = GF_CALLOC (1, 300, cli_mt_append_str);
-                        if (!append_str) {
-                                ret = -1;
-                                goto out;
-                        }
-                        snprintf (append_str, 300, "%" GF_PRI_SECOND,
-                                  tv.tv_sec);
-                } else if ((strcmp (words[cmdi + 1], "checkpoint") == 0) &&
-                           (strcmp (append_str, "now") != 0)) {
-                        memset(&checkpoint_time, 0, sizeof(struct tm));
-                        ret_chkpt = strptime(append_str, "%Y-%m-%d %H:%M:%S",
-                                             &checkpoint_time);
-
-                        if (ret_chkpt == NULL) {
-                                ret = -1;
-                                cli_err ("Invalid Checkpoint label. Use format "
-                                         "\"Y-m-d H:M:S\", Example: 2016-10-25 15:30:45");
-                                goto out;
-                        }
-                        GF_FREE (append_str);
-                        append_str = GF_CALLOC (1, 300, cli_mt_append_str);
-                        if (!append_str) {
-                                ret = -1;
-                                goto out;
-                        }
-                        strftime (chkpt_buf, sizeof(chkpt_buf), "%s",
-                                  &checkpoint_time);
-                        snprintf (append_str, 300, "%s", chkpt_buf);
+                GF_FREE(append_str);
+                append_str = GF_MALLOC(300, cli_mt_append_str);
+                if (!append_str) {
+                    ret = -1;
+                    goto out;
+                }
+                snprintf(append_str, 300, "%" GF_PRI_SECOND, tv.tv_sec);
+            } else if ((strcmp(words[cmdi + 1], "checkpoint") == 0) &&
+                       (strcmp(append_str, "now") != 0)) {
+                memset(&checkpoint_time, 0, sizeof(struct tm));
+                ret_chkpt = strptime(append_str, "%Y-%m-%d %H:%M:%S",
+                                     &checkpoint_time);
+
+                if (ret_chkpt == NULL || *ret_chkpt != '\0') {
+                    ret = -1;
+                    cli_err(
+                        "Invalid Checkpoint label. Use format "
+                        "\"Y-m-d H:M:S\", Example: 2016-10-25 15:30:45");
+                    goto out;
+                }
+                GF_FREE(append_str);
+                append_str = GF_MALLOC(300, cli_mt_append_str);
+                if (!append_str) {
+                    ret = -1;
+                    goto out;
                 }
+                strftime(chkpt_buf, sizeof(chkpt_buf), "%s", &checkpoint_time);
+                snprintf(append_str, 300, "%s", chkpt_buf);
+            }
 
-                ret = dict_set_dynstr (dict, "op_value", append_str);
-        }
+            ret = dict_set_dynstr(dict, "op_value", append_str);
+            if (ret != 0) {
+                goto out;
+            }
+            append_str = NULL;
+    }
 
-        ret = -1;
-        if (subop) {
-                ret = dict_set_dynstr (dict, "subop", subop);
-                if (!ret)
-                      subop = NULL;
-        }
+    ret = -1;
+    if (subop) {
+        ret = dict_set_dynstr(dict, "subop", subop);
+        if (!ret)
+            subop = NULL;
+    }
 
 out:
-        if (ret && append_str)
-                GF_FREE (append_str);
+    GF_FREE(append_str);
+    GF_FREE(subop);
 
-        GF_FREE (subop);
-
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 /* ssh_port_parse: Parses and validates when ssh_port is given.
@@ -2662,1488 +2771,1467 @@ out:
  */
 
 static int32_t
-parse_ssh_port (const char **words, int wordcount, dict_t *dict,
-                unsigned *cmdi, int ssh_index, char *type) {
-
-        int        ret         = 0;
-        char      *end_ptr     = NULL;
-        int64_t    limit       = 0;
-
-        if (!strcmp ((char *)words[ssh_index], "ssh-port")) {
-                if (strcmp ((char *)words[ssh_index-1], "create")) {
-                        ret = -1;
-                        goto out;
-                }
-                (*cmdi)++;
-                limit = strtol (words[ssh_index+1], &end_ptr, 10);
-                if (errno == ERANGE || errno == EINVAL || limit <= 0
-                                    || strcmp (end_ptr, "") != 0) {
-                        ret = -1;
-                        cli_err ("Please enter an integer value for ssh_port ");
-                        goto out;
-                }
+parse_ssh_port(const char **words, int wordcount, dict_t *dict, unsigned *cmdi,
+               int ssh_index, char *type)
+{
+    int ret = 0;
+    char *end_ptr = NULL;
+    int64_t limit = 0;
 
-                ret = dict_set_int32 (dict, "ssh_port", limit);
-                if (ret)
-                        goto out;
-                (*cmdi)++;
-        } else if (strcmp ((char *)words[ssh_index+1], "create")) {
-                ret = -1;
-                goto out;
+    if (!strcmp((char *)words[ssh_index], "ssh-port")) {
+        if (strcmp((char *)words[ssh_index - 1], "create")) {
+            ret = -1;
+            goto out;
+        }
+        (*cmdi)++;
+        limit = strtol(words[ssh_index + 1], &end_ptr, 10);
+        if (errno == ERANGE || errno == EINVAL || limit <= 0 ||
+            strcmp(end_ptr, "") != 0) {
+            ret = -1;
+            cli_err("Please enter an integer value for ssh_port ");
+            goto out;
         }
 
-        ret = dict_set_int32 (dict, type, 1);
+        ret = dict_set_int32(dict, "ssh_port", limit);
         if (ret)
-                goto out;
+            goto out;
         (*cmdi)++;
+    } else if (strcmp((char *)words[ssh_index + 1], "create")) {
+        ret = -1;
+        goto out;
+    }
 
- out:
-        return ret;
+    ret = dict_set_int32(dict, type, 1);
+    if (ret)
+        goto out;
+    (*cmdi)++;
+
+out:
+    return ret;
 }
 
 static int32_t
-force_push_pem_no_verify_parse (const char **words, int wordcount,
-                      dict_t *dict, unsigned *cmdi)
+force_push_pem_no_verify_parse(const char **words, int wordcount, dict_t *dict,
+                               unsigned *cmdi)
 {
-        int32_t            ret     = 0;
-
-        if (!strcmp ((char *)words[wordcount-1], "force")) {
-                if ((strcmp ((char *)words[wordcount-2], "start")) &&
-                    (strcmp ((char *)words[wordcount-2], "stop")) &&
-                    (strcmp ((char *)words[wordcount-2], "create")) &&
-                    (strcmp ((char *)words[wordcount-2], "no-verify")) &&
-                    (strcmp ((char *)words[wordcount-2], "push-pem")) &&
-                    (strcmp ((char *)words[wordcount-2], "pause")) &&
-                    (strcmp ((char *)words[wordcount-2], "resume"))) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_uint32 (dict, "force",
-                                       _gf_true);
-                if (ret)
-                        goto out;
-                (*cmdi)++;
-
-                if (!strcmp ((char *)words[wordcount-2], "push-pem")) {
-                        ret = parse_ssh_port (words, wordcount, dict, cmdi,
-                                              wordcount-4, "push_pem");
-                        if (ret)
-                                goto out;
-                } else if (!strcmp ((char *)words[wordcount-2], "no-verify")) {
-                        ret = parse_ssh_port (words, wordcount, dict, cmdi,
-                                              wordcount-4, "no_verify");
-                        if (ret)
-                                goto out;
-                }
-        } else if (!strcmp ((char *)words[wordcount-1], "push-pem")) {
-                ret = parse_ssh_port (words, wordcount, dict, cmdi, wordcount-3,
-                                      "push_pem");
-                if (ret)
-                        goto out;
-        } else if (!strcmp ((char *)words[wordcount-1], "no-verify")) {
-                ret = parse_ssh_port (words, wordcount, dict, cmdi, wordcount-3,
-                                      "no_verify");
-                if (ret)
-                        goto out;
+    int32_t ret = 0;
+
+    if (!strcmp((char *)words[wordcount - 1], "force")) {
+        if ((strcmp((char *)words[wordcount - 2], "start")) &&
+            (strcmp((char *)words[wordcount - 2], "stop")) &&
+            (strcmp((char *)words[wordcount - 2], "create")) &&
+            (strcmp((char *)words[wordcount - 2], "no-verify")) &&
+            (strcmp((char *)words[wordcount - 2], "push-pem")) &&
+            (strcmp((char *)words[wordcount - 2], "pause")) &&
+            (strcmp((char *)words[wordcount - 2], "resume"))) {
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_int32n(dict, "force", SLEN("force"), 1);
+        if (ret)
+            goto out;
+        (*cmdi)++;
+
+        if (!strcmp((char *)words[wordcount - 2], "push-pem")) {
+            ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 4,
+                                 "push_pem");
+            if (ret)
+                goto out;
+        } else if (!strcmp((char *)words[wordcount - 2], "no-verify")) {
+            ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 4,
+                                 "no_verify");
+            if (ret)
+                goto out;
         }
+    } else if (!strcmp((char *)words[wordcount - 1], "push-pem")) {
+        ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 3,
+                             "push_pem");
+        if (ret)
+            goto out;
+    } else if (!strcmp((char *)words[wordcount - 1], "no-verify")) {
+        ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 3,
+                             "no_verify");
+        if (ret)
+            goto out;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
-
 int32_t
-cli_cmd_gsync_set_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_gsync_set_parse(struct cli_state *state, const char **words,
+                        int wordcount, dict_t **options, char **errstr)
 {
-        int32_t            ret     = -1;
-        dict_t             *dict   = NULL;
-        gf1_cli_gsync_set  type    = GF_GSYNC_OPTION_TYPE_NONE;
-        int                i       = 0;
-        unsigned           masteri = 0;
-        unsigned           slavei  = 0;
-        unsigned           glob    = 0;
-        unsigned           cmdi    = 0;
-        char               *opwords[] = { "create", "status", "start", "stop",
-                                          "config", "force", "delete",
-                                          "ssh-port", "no-verify", "push-pem",
-                                          "detail", "pause", "resume", NULL };
-        char               *w = NULL;
-        char               *save_ptr   = NULL;
-        char               *slave_temp = NULL;
-        char               *token      = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        /* new syntax:
-         *
-         * volume geo-replication $m $s create [[ssh-port n] [[no-verify] | [push-pem]]] [force]
-         * volume geo-replication [$m [$s]] status [detail]
-         * volume geo-replication [$m] $s config [[!]$opt [$val]]
-         * volume geo-replication $m $s start|stop [force]
-         * volume geo-replication $m $s delete [reset-sync-time]
-         * volume geo-replication $m $s pause [force]
-         * volume geo-replication $m $s resume [force]
-         */
+    int32_t ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_gsync_set type = GF_GSYNC_OPTION_TYPE_NONE;
+    int i = 0;
+    unsigned masteri = 0;
+    unsigned slavei = 0;
+    unsigned glob = 0;
+    unsigned cmdi = 0;
+    static char *opwords[] = {"create",    "status",   "start",  "stop",
+                              "config",    "force",    "delete", "ssh-port",
+                              "no-verify", "push-pem", "detail", "pause",
+                              "resume",    NULL};
+    char *w = NULL;
+    char *save_ptr = NULL;
+    char *slave_temp = NULL;
+    char *token = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    /* new syntax:
+     *
+     * volume geo-replication $m $s create [[ssh-port n] [[no-verify] |
+     * [push-pem]]] [force] volume geo-replication [$m [$s]] status [detail]
+     * volume geo-replication [$m] $s config [[!]$opt [$val]]
+     * volume geo-replication $m $s start|stop [force]
+     * volume geo-replication $m $s delete [reset-sync-time]
+     * volume geo-replication $m $s pause [force]
+     * volume geo-replication $m $s resume [force]
+     */
+
+    if (wordcount < 3)
+        goto out;
 
-        for (i = 2; i <= 3 && i < wordcount - 1; i++) {
-                if (gsyncd_glob_check (words[i]))
-                        glob = i;
-                if (gsyncd_url_check (words[i])) {
-                        slavei = i;
-                        break;
-                }
+    for (i = 2; i <= 3 && i < wordcount - 1; i++) {
+        if (gsyncd_glob_check(words[i]))
+            glob = i;
+        if (gsyncd_url_check(words[i])) {
+            slavei = i;
+            break;
         }
+    }
 
-        if (glob && !slavei)
-                /* glob is allowed only for config, thus it implies there is a
-                 * slave argument; but that might have not been recognized on
-                 * the first scan as it's url characteristics has been covered
-                 * by the glob syntax.
-                 *
-                 * In this case, the slave is perforce the last glob-word -- the
-                 * upcoming one is neither glob, nor url, so it's definitely not
-                 * the slave.
-                 */
-                slavei = glob;
-        if (slavei) {
-                cmdi = slavei + 1;
-                if (slavei == 3)
-                        masteri = 2;
-        } else if (i <= 4) {
-                if (strtail ("detail", (char *)words[wordcount-1])) {
-                        cmdi = wordcount - 2;
-                        if (i == 4)
-                                masteri = 2;
-                } else {
-                        /* no $s, can only be status cmd
-                         * (with either a single $m before it or nothing)
-                         * -- these conditions imply that i <= 3 after
-                         * the iteration and that i is the successor of
-                         * the (0 or 1 length) sequence of $m-s.
-                         */
-                        cmdi = i;
-                        if (i == 3)
-                                masteri = 2;
-                }
-        } else
-                goto out;
-
-        /* now check if input really complies syntax
-         * (in a somewhat redundant way, in favor
-         * transparent soundness)
+    if (glob && !slavei)
+        /* glob is allowed only for config, thus it implies there is a
+         * slave argument; but that might have not been recognized on
+         * the first scan as it's url characteristics has been covered
+         * by the glob syntax.
+         *
+         * In this case, the slave is perforce the last glob-word -- the
+         * upcoming one is neither glob, nor url, so it's definitely not
+         * the slave.
          */
+        slavei = glob;
+    if (slavei) {
+        cmdi = slavei + 1;
+        if (slavei == 3)
+            masteri = 2;
+    } else if (i <= 4) {
+        if (strtail("detail", (char *)words[wordcount - 1])) {
+            cmdi = wordcount - 2;
+            if (i == 4)
+                masteri = 2;
+        } else {
+            /* no $s, can only be status cmd
+             * (with either a single $m before it or nothing)
+             * -- these conditions imply that i <= 3 after
+             * the iteration and that i is the successor of
+             * the (0 or 1 length) sequence of $m-s.
+             */
+            cmdi = i;
+            if (i == 3)
+                masteri = 2;
+        }
+    } else
+        goto out;
 
-        if (masteri && gsyncd_url_check (words[masteri]))
-                goto out;
-        if (slavei && !glob && !gsyncd_url_check (words[slavei]))
-                goto out;
-
-        w = str_getunamb (words[cmdi], opwords);
-        if (!w)
-                goto out;
-
-        if (strcmp (w, "create") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_CREATE;
-
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "status") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_STATUS;
-
-                if (slavei && !masteri)
-                        goto out;
-        } else if (strcmp (w, "config") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_CONFIG;
-
-                if (!slavei)
-                        goto out;
-        } else if (strcmp (w, "start") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_START;
+    /* now check if input really complies syntax
+     * (in a somewhat redundant way, in favor
+     * transparent soundness)
+     */
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "stop") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_STOP;
+    if (masteri && gsyncd_url_check(words[masteri]))
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "delete") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_DELETE;
+    if (slavei && !glob && !valid_slave_gsyncd_url(words[slavei])) {
+        gf_asprintf(errstr, "Invalid slave url: %s", words[slavei]);
+        goto out;
+    }
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "pause") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_PAUSE;
+    w = str_getunamb(words[cmdi], opwords);
+    if (!w)
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "resume") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_RESUME;
+    if (strcmp(w, "create") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_CREATE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "status") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_STATUS;
+
+        if (slavei && !masteri)
+            goto out;
+    } else if (strcmp(w, "config") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_CONFIG;
+
+        if (!slavei)
+            goto out;
+    } else if (strcmp(w, "start") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_START;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "stop") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_STOP;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "delete") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_DELETE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "pause") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_PAUSE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "resume") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_RESUME;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else
+        GF_ASSERT(!"opword mismatch");
+
+    ret = force_push_pem_no_verify_parse(words, wordcount, dict, &cmdi);
+    if (ret)
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else
-                GF_ASSERT (!"opword mismatch");
+    if (strtail("detail", (char *)words[wordcount - 1])) {
+        if (!strtail("status", (char *)words[wordcount - 2])) {
+            ret = -1;
+            goto out;
+        }
 
-        ret = force_push_pem_no_verify_parse (words, wordcount, dict, &cmdi);
+        ret = dict_set_uint32(dict, "status-detail", _gf_true);
         if (ret)
-                goto out;
-
-        if (strtail ("detail", (char *)words[wordcount-1])) {
-                if (!strtail ("status", (char *)words[wordcount-2])) {
-                        ret = -1;
-                        goto out;
-                }
+            goto out;
+        cmdi++;
+    }
 
-                ret = dict_set_uint32 (dict, "status-detail", _gf_true);
-                if (ret)
-                        goto out;
-                cmdi++;
-        }
-
-        if (type == GF_GSYNC_OPTION_TYPE_DELETE &&
-            !strcmp ((char *)words[wordcount-1], "reset-sync-time")) {
-                if (strcmp ((char *)words[wordcount-2], "delete")) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_uint32 (dict, "reset-sync-time", _gf_true);
-                if (ret)
-                        goto out;
-                cmdi++;
+    if (type == GF_GSYNC_OPTION_TYPE_DELETE &&
+        !strcmp((char *)words[wordcount - 1], "reset-sync-time")) {
+        if (strcmp((char *)words[wordcount - 2], "delete")) {
+            ret = -1;
+            goto out;
         }
+        ret = dict_set_uint32(dict, "reset-sync-time", _gf_true);
+        if (ret)
+            goto out;
+        cmdi++;
+    }
 
-        if (type != GF_GSYNC_OPTION_TYPE_CONFIG &&
-            (cmdi < wordcount - 1 || glob))
-                goto out;
+    if (type != GF_GSYNC_OPTION_TYPE_CONFIG && (cmdi < wordcount - 1 || glob)) {
+        ret = -1;
+        goto out;
+    }
 
-        /* If got so far, input is valid, assemble the message */
+    /* If got so far, input is valid, assemble the message */
 
-        ret = 0;
+    ret = 0;
 
-        if (masteri) {
-                ret = dict_set_str (dict, "master", (char *)words[masteri]);
-                if (!ret)
-                        ret = dict_set_str (dict, "volname",
-                                            (char *)words[masteri]);
-        }
-        if (!ret && slavei) {
-                /* If geo-rep is created with root user using the syntax
-                 * gluster vol geo-rep <mastervol> root@<slavehost> ...
-                 * pass down only <slavehost> else pass as it is.
-                 */
-                slave_temp = gf_strdup (words[slavei]);
-                token = strtok_r (slave_temp, "@", &save_ptr);
-                if (token && !strcmp (token, "root")) {
-                        ret = dict_set_str (dict, "slave",
-                                            (char *)words[slavei]+5);
-                } else {
-                        ret = dict_set_str (dict, "slave",
-                                            (char *)words[slavei]);
-                }
-        }
+    if (masteri) {
+        ret = dict_set_str(dict, "master", (char *)words[masteri]);
         if (!ret)
-                ret = dict_set_int32 (dict, "type", type);
-        if (!ret && type == GF_GSYNC_OPTION_TYPE_CONFIG)
-                ret = config_parse (words, wordcount, dict, cmdi, glob);
+            ret = dict_set_str(dict, "volname", (char *)words[masteri]);
+    }
+    if (!ret && slavei) {
+        /* If geo-rep is created with root user using the syntax
+         * gluster vol geo-rep <mastervol> root@<slavehost> ...
+         * pass down only <slavehost> else pass as it is.
+         */
+        slave_temp = gf_strdup(words[slavei]);
+        if (slave_temp == NULL) {
+            ret = -1;
+            goto out;
+        }
+        token = strtok_r(slave_temp, "@", &save_ptr);
+        if (token && !strcmp(token, "root")) {
+            ret = dict_set_str(dict, "slave", (char *)words[slavei] + 5);
+        } else {
+            ret = dict_set_str(dict, "slave", (char *)words[slavei]);
+        }
+    }
+    if (!ret)
+        ret = dict_set_int32(dict, "type", type);
+    if (!ret && type == GF_GSYNC_OPTION_TYPE_CONFIG) {
+        if (!strcmp((char *)words[wordcount - 2], "ignore-deletes") &&
+            !strcmp((char *)words[wordcount - 1], "true")) {
+            question =
+                "There exists ~15 seconds delay for the option to take"
+                " effect from stime of the corresponding brick. Please"
+                " check the log for the time, the option is effective."
+                " Proceed";
+
+            answer = cli_cmd_get_confirmation(state, question);
+
+            if (GF_ANSWER_NO == answer) {
+                gf_log("cli", GF_LOG_INFO,
+                       "Operation "
+                       "cancelled, exiting");
+                *errstr = gf_strdup("Aborted by user.");
+                ret = -1;
+                goto out;
+            }
+        }
 
-out:
-        if (slave_temp)
-                GF_FREE (slave_temp);
-        if (ret) {
-                if (dict)
-                        dict_unref (dict);
-        } else
-                *options = dict;
+        ret = config_parse(words, wordcount, dict, cmdi, glob);
+    }
 
+out:
+    if (slave_temp)
+        GF_FREE(slave_temp);
+    if (ret && dict)
+        dict_unref(dict);
+    else
+        *options = dict;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_profile_parse (const char **words, int wordcount,
-                              dict_t **options)
+cli_cmd_volume_profile_parse(const char **words, int wordcount,
+                             dict_t **options)
 {
-        dict_t              *dict       = NULL;
-        char                *volname    = NULL;
-        int                 ret         = -1;
-        gf1_cli_stats_op    op          = GF_CLI_STATS_NONE;
-        gf1_cli_info_op     info_op     = GF_CLI_INFO_NONE;
-        gf_boolean_t        is_peek     = _gf_false;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    gf1_cli_info_op info_op = GF_CLI_INFO_NONE;
+    gf_boolean_t is_peek = _gf_false;
 
-        char      *opwords[] = { "start", "stop", "info", NULL };
-        char      *w = NULL;
+    static char *opwords[] = {"start", "stop", "info", NULL};
+    char *w = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount < 4)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[2];
+    if (wordcount < 4)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    volname = (char *)words[2];
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if ((strcmp (w, "start") == 0 || strcmp (w, "stop") == 0) &&
-            wordcount > 5)
-                goto out;
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    }
 
-        if (strcmp (w, "info") == 0 && wordcount > 7)
-                goto out;
+    if ((strcmp(w, "start") == 0 || strcmp(w, "stop") == 0) && wordcount > 5) {
+        ret = -1;
+        goto out;
+    }
 
-        if (strcmp (w, "start") == 0) {
-                op = GF_CLI_STATS_START;
-        } else if (strcmp (w, "stop") == 0) {
-                op = GF_CLI_STATS_STOP;
-        } else if (strcmp (w, "info") == 0) {
-                op = GF_CLI_STATS_INFO;
-                info_op = GF_CLI_INFO_ALL;
-                if (wordcount > 4) {
-                        if (strcmp (words[4], "incremental") == 0) {
-                                info_op = GF_CLI_INFO_INCREMENTAL;
-                                if (wordcount > 5 &&
-                                    strcmp (words[5], "peek") == 0) {
-                                        is_peek = _gf_true;
-                                }
-                        } else if (strcmp (words[4], "cumulative") == 0) {
-                                info_op = GF_CLI_INFO_CUMULATIVE;
-                        } else if (strcmp (words[4], "clear") == 0) {
-                                info_op = GF_CLI_INFO_CLEAR;
-                        } else if (strcmp (words[4], "peek") == 0) {
-                                is_peek = _gf_true;
-                        }
-                }
-        } else
-                GF_ASSERT (!"opword mismatch");
+    if (strcmp(w, "info") == 0 && wordcount > 7) {
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(w, "start") == 0) {
+        op = GF_CLI_STATS_START;
+    } else if (strcmp(w, "stop") == 0) {
+        op = GF_CLI_STATS_STOP;
+    } else if (strcmp(w, "info") == 0) {
+        op = GF_CLI_STATS_INFO;
+        info_op = GF_CLI_INFO_ALL;
+        if (wordcount > 4) {
+            if (strcmp(words[4], "incremental") == 0) {
+                info_op = GF_CLI_INFO_INCREMENTAL;
+                if (wordcount > 5 && strcmp(words[5], "peek") == 0) {
+                    is_peek = _gf_true;
+                }
+            } else if (strcmp(words[4], "cumulative") == 0) {
+                info_op = GF_CLI_INFO_CUMULATIVE;
+            } else if (strcmp(words[4], "clear") == 0) {
+                info_op = GF_CLI_INFO_CLEAR;
+            } else if (strcmp(words[4], "peek") == 0) {
+                is_peek = _gf_true;
+            }
+        }
+    } else
+        GF_ASSERT(!"opword mismatch");
+
+    ret = dict_set_int32(dict, "op", (int32_t)op);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "op", (int32_t)op);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "info-op", (int32_t)info_op);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "info-op", (int32_t)info_op);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "peek", is_peek);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "peek", is_peek);
+    if (!strcmp(words[wordcount - 1], "nfs")) {
+        ret = dict_set_int32(dict, "nfs", _gf_true);
         if (ret)
-                goto out;
-
-        if (!strcmp (words[wordcount - 1], "nfs")) {
-                ret = dict_set_int32 (dict, "nfs", _gf_true);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 out:
-        if (ret && dict)
-                dict_unref (dict);
-        return ret;
+    if (ret && dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_top_parse (const char **words, int wordcount,
-                              dict_t **options)
+cli_cmd_volume_top_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict           = NULL;
-        char    *volname        = NULL;
-        char    *value          = NULL;
-        char    *key            = NULL;
-        int      ret            = -1;
-        gf1_cli_stats_op op = GF_CLI_STATS_NONE;
-        gf1_cli_top_op    top_op = GF_CLI_TOP_NONE;
-        int32_t  list_cnt       = -1;
-        int      index          = 0;
-        int      perf           = 0;
-        int32_t  blk_size       = 0;
-        int      count          = 0;
-        gf_boolean_t nfs        = _gf_false;
-        char    *delimiter      = NULL;
-        char    *opwords[]      = { "open", "read", "write", "opendir",
-                                    "readdir", "read-perf", "write-perf",
-                                    "clear", NULL };
-        char    *w = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *value = NULL;
+    char *key = NULL;
+    int ret = -1;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    gf1_cli_top_op top_op = GF_CLI_TOP_NONE;
+    int32_t list_cnt = -1;
+    int index = 0;
+    int perf = 0;
+    int32_t blk_size = 0;
+    int count = 0;
+    gf_boolean_t nfs = _gf_false;
+    char *delimiter = NULL;
+    static char *opwords[] = {"open",       "read",    "write",
+                              "opendir",    "readdir", "read-perf",
+                              "write-perf", "clear",   NULL};
+    char *w = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount < 4)
-                goto out;
+    if (wordcount < 4)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        op = GF_CLI_STATS_TOP;
-        ret = dict_set_int32 (dict, "op", (int32_t)op);
-        if (ret)
-                goto out;
+    op = GF_CLI_STATS_TOP;
+    ret = dict_set_int32(dict, "op", (int32_t)op);
+    if (ret)
+        goto out;
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    }
+    if (strcmp(w, "open") == 0) {
+        top_op = GF_CLI_TOP_OPEN;
+    } else if (strcmp(w, "read") == 0) {
+        top_op = GF_CLI_TOP_READ;
+    } else if (strcmp(w, "write") == 0) {
+        top_op = GF_CLI_TOP_WRITE;
+    } else if (strcmp(w, "opendir") == 0) {
+        top_op = GF_CLI_TOP_OPENDIR;
+    } else if (strcmp(w, "readdir") == 0) {
+        top_op = GF_CLI_TOP_READDIR;
+    } else if (strcmp(w, "read-perf") == 0) {
+        top_op = GF_CLI_TOP_READ_PERF;
+        perf = 1;
+    } else if (strcmp(w, "write-perf") == 0) {
+        top_op = GF_CLI_TOP_WRITE_PERF;
+        perf = 1;
+    } else if (strcmp(w, "clear") == 0) {
+        ret = dict_set_int32(dict, "clear-stats", 1);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not set clear-stats in dict");
+            goto out;
         }
-        if (strcmp (w, "open") == 0) {
-                top_op = GF_CLI_TOP_OPEN;
-        } else if (strcmp (w, "read") == 0) {
-                top_op = GF_CLI_TOP_READ;
-        } else if (strcmp (w, "write") == 0) {
-                top_op = GF_CLI_TOP_WRITE;
-        } else if (strcmp (w, "opendir") == 0) {
-                top_op = GF_CLI_TOP_OPENDIR;
-        } else if (strcmp (w, "readdir") == 0) {
-                top_op = GF_CLI_TOP_READDIR;
-        } else if (strcmp (w, "read-perf") == 0) {
-                top_op = GF_CLI_TOP_READ_PERF;
-                perf = 1;
-        } else if (strcmp (w, "write-perf") == 0) {
-                top_op = GF_CLI_TOP_WRITE_PERF;
-                perf = 1;
-        } else if (strcmp (w, "clear") == 0) {
-                ret = dict_set_int32 (dict, "clear-stats", 1);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not set clear-stats in dict");
-                        goto out;
-                }
-        } else
-                GF_ASSERT (!"opword mismatch");
-        ret = dict_set_int32 (dict, "top-op", (int32_t)top_op);
+    } else
+        GF_ASSERT(!"opword mismatch");
+    ret = dict_set_int32(dict, "top-op", (int32_t)top_op);
+    if (ret)
+        goto out;
+
+    if ((wordcount > 4) && !strcmp(words[4], "nfs")) {
+        nfs = _gf_true;
+        ret = dict_set_int32(dict, "nfs", nfs);
         if (ret)
+            goto out;
+        index = 5;
+    } else {
+        index = 4;
+    }
+
+    for (; index < wordcount; index += 2) {
+        key = (char *)words[index];
+        value = (char *)words[index + 1];
+
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
+        if (!strcmp(key, "brick")) {
+            delimiter = strchr(value, ':');
+            if (!delimiter || delimiter == value || *(delimiter + 1) != '/') {
+                cli_err(
+                    "wrong brick type: %s, use <HOSTNAME>:"
+                    "<export-dir-abs-path>",
+                    value);
+                ret = -1;
                 goto out;
-
-        if ((wordcount > 4) && !strcmp (words[4], "nfs")) {
-                nfs = _gf_true;
-                ret = dict_set_int32 (dict, "nfs", nfs);
+            } else {
+                ret = gf_canonicalize_path(delimiter + 1);
                 if (ret)
-                        goto out;
-                index = 5;
-        } else {
-                index = 4;
-        }
-
-        for (; index < wordcount; index+=2) {
-
-                key = (char *) words[index];
-                value = (char *) words[index+1];
-
-                if ( key && !value ) {
-                        ret = -1;
-                        goto out;
-                }
-                if (!strcmp (key, "brick")) {
-                        delimiter = strchr (value, ':');
-                        if (!delimiter || delimiter == value
-                            || *(delimiter+1) != '/') {
-                                cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                         "<export-dir-abs-path>", value);
-                                ret = -1;
-                                goto out;
-                        } else {
-                                ret = gf_canonicalize_path (delimiter + 1);
-                                if (ret)
-                                        goto out;
-                        }
-                        ret = dict_set_str (dict, "brick", value);
-
-                } else if (!strcmp (key, "list-cnt")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                list_cnt = atoi (value);
-                        if (ret || (list_cnt < 0) || (list_cnt > 100)) {
-                                cli_err ("list-cnt should be between 0 to 100");
-                                ret = -1;
-                                goto out;
-                        }
-                } else if (perf && !nfs && !strcmp (key, "bs")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                blk_size = atoi (value);
-                        if (ret || (blk_size <= 0)) {
-                                if (blk_size < 0)
-                                        cli_err ("block size is an invalid"
-                                                 " number");
-                                else
-                                        cli_err ("block size should be an "
-                                                 "integer greater than zero");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_uint32 (dict, "blk-size",
-                                                        (uint32_t)blk_size);
-                } else if (perf && !nfs && !strcmp (key, "count")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                count = atoi(value);
-                        if (ret || (count <= 0)) {
-                                if (count < 0)
-                                        cli_err ("count is an invalid number");
-                                else
-                                        cli_err ("count should be an integer "
-                                                 "greater than zero");
-
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_uint32 (dict, "blk-cnt", count);
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-                if (ret) {
-                        gf_log ("", GF_LOG_WARNING, "Dict set failed for "
-                                "key %s", key);
-                        goto out;
-                }
-        }
-        if (list_cnt == -1)
-                list_cnt = 100;
-        ret = dict_set_int32 (dict, "list-cnt", list_cnt);
-        if (ret) {
-                gf_log ("", GF_LOG_WARNING, "Dict set failed for list_cnt");
+                    goto out;
+            }
+            ret = dict_set_str(dict, "brick", value);
+
+        } else if (!strcmp(key, "list-cnt")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                list_cnt = atoi(value);
+            if (ret || (list_cnt < 0) || (list_cnt > 100)) {
+                cli_err("list-cnt should be between 0 to 100");
+                ret = -1;
                 goto out;
-        }
-
-        if ((blk_size > 0) ^ (count > 0)) {
-                cli_err ("Need to give both 'bs' and 'count'");
+            }
+        } else if (perf && !nfs && !strcmp(key, "bs")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                blk_size = atoi(value);
+            if (ret || (blk_size <= 0)) {
+                if (blk_size < 0)
+                    cli_err(
+                        "block size is an invalid"
+                        " number");
+                else
+                    cli_err(
+                        "block size should be an "
+                        "integer greater than zero");
                 ret = -1;
                 goto out;
-        } else if (((uint64_t)blk_size * count) > (10 * GF_UNIT_GB)) {
-                cli_err ("'bs * count' value %"PRIu64" is greater than "
-                         "maximum allowed value of 10GB",
-                         ((uint64_t)blk_size * count));
+            }
+            ret = dict_set_uint32(dict, "blk-size", (uint32_t)blk_size);
+        } else if (perf && !nfs && !strcmp(key, "count")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                count = atoi(value);
+            if (ret || (count <= 0)) {
+                if (count < 0)
+                    cli_err("count is an invalid number");
+                else
+                    cli_err(
+                        "count should be an integer "
+                        "greater than zero");
+
                 ret = -1;
                 goto out;
+            }
+            ret = dict_set_uint32(dict, "blk-cnt", count);
+        } else {
+            ret = -1;
+            goto out;
         }
+        if (ret) {
+            gf_log("", GF_LOG_WARNING,
+                   "Dict set failed for "
+                   "key %s",
+                   key);
+            goto out;
+        }
+    }
+    if (list_cnt == -1)
+        list_cnt = 100;
+    ret = dict_set_int32(dict, "list-cnt", list_cnt);
+    if (ret) {
+        gf_log("", GF_LOG_WARNING, "Dict set failed for list_cnt");
+        goto out;
+    }
 
-        *options = dict;
+    if ((blk_size > 0) ^ (count > 0)) {
+        cli_err("Need to give both 'bs' and 'count'");
+        ret = -1;
+        goto out;
+    } else if (((uint64_t)blk_size * count) > (10 * GF_UNIT_GB)) {
+        cli_err("'bs * count' value %" PRIu64
+                " is greater than "
+                "maximum allowed value of 10GB",
+                ((uint64_t)blk_size * count));
+        ret = -1;
+        goto out;
+    }
+
+    *options = dict;
 out:
-        if (ret && dict)
-                dict_unref (dict);
-        return ret;
+    if (ret && dict)
+        dict_unref(dict);
+    return ret;
 }
 
 uint32_t
-cli_cmd_get_statusop (const char *arg)
+cli_cmd_get_statusop(const char *arg)
 {
-        int        i         = 0;
-        uint32_t   ret       = GF_CLI_STATUS_NONE;
-        char      *w         = NULL;
-        char      *opwords[] = {"detail", "mem", "clients", "fd",
-                                "inode", "callpool", "tasks", NULL};
-        struct {
-                char      *opname;
-                uint32_t   opcode;
-        } optable[] = {
-                { "detail",   GF_CLI_STATUS_DETAIL   },
-                { "mem",      GF_CLI_STATUS_MEM      },
-                { "clients",  GF_CLI_STATUS_CLIENTS  },
-                { "fd",       GF_CLI_STATUS_FD       },
-                { "inode",    GF_CLI_STATUS_INODE    },
-                { "callpool", GF_CLI_STATUS_CALLPOOL },
-                { "tasks",    GF_CLI_STATUS_TASKS    },
-                { NULL }
-        };
-
-        w = str_getunamb (arg, opwords);
-        if (!w) {
-                gf_log ("cli", GF_LOG_DEBUG,
-                        "Not a status op  %s", arg);
-                goto out;
-        }
+    int i = 0;
+    uint32_t ret = GF_CLI_STATUS_NONE;
+    char *w = NULL;
+    static char *opwords[] = {"detail",   "mem",   "clients",     "fd", "inode",
+                              "callpool", "tasks", "client-list", NULL};
+    static struct {
+        char *opname;
+        uint32_t opcode;
+    } optable[] = {{"detail", GF_CLI_STATUS_DETAIL},
+                   {"mem", GF_CLI_STATUS_MEM},
+                   {"clients", GF_CLI_STATUS_CLIENTS},
+                   {"fd", GF_CLI_STATUS_FD},
+                   {"inode", GF_CLI_STATUS_INODE},
+                   {"callpool", GF_CLI_STATUS_CALLPOOL},
+                   {"tasks", GF_CLI_STATUS_TASKS},
+                   {"client-list", GF_CLI_STATUS_CLIENT_LIST},
+                   {NULL}};
+
+    w = str_getunamb(arg, opwords);
+    if (!w) {
+        gf_log("cli", GF_LOG_DEBUG, "Not a status op  %s", arg);
+        goto out;
+    }
 
-        for (i = 0; optable[i].opname; i++) {
-                if (!strcmp (w, optable[i].opname)) {
-                        ret = optable[i].opcode;
-                        break;
-                }
+    for (i = 0; optable[i].opname; i++) {
+        if (!strcmp(w, optable[i].opname)) {
+            ret = optable[i].opcode;
+            break;
         }
+    }
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 int
-cli_cmd_volume_status_parse (const char **words, int wordcount,
-                             dict_t **options)
+cli_cmd_volume_status_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t    *dict            = NULL;
-        int        ret             = -1;
-        uint32_t   cmd             = 0;
+    dict_t *dict = NULL;
+    int ret = -1;
+    uint32_t cmd = 0;
 
-        GF_ASSERT (options);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        switch (wordcount) {
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
+    switch (wordcount) {
         case 2:
-                cmd = GF_CLI_STATUS_ALL;
-                ret = 0;
-                break;
+            cmd = GF_CLI_STATUS_ALL;
+            ret = 0;
+            break;
 
         case 3:
-                if (!strcmp (words[2], "all")) {
-                        cmd = GF_CLI_STATUS_ALL;
-                        ret = 0;
+            if (!strcmp(words[2], "all")) {
+                cmd = GF_CLI_STATUS_ALL;
+                ret = 0;
 
-                } else {
-                        cmd = GF_CLI_STATUS_VOL;
-                        ret = dict_set_str (dict, "volname", (char *)words[2]);
-                }
+            } else {
+                cmd = GF_CLI_STATUS_VOL;
+                ret = dict_set_str(dict, "volname", (char *)words[2]);
+            }
 
-                break;
+            break;
 
         case 4:
-                cmd = cli_cmd_get_statusop (words[3]);
-
-                if (!strcmp (words[2], "all")) {
-                        if (cmd == GF_CLI_STATUS_NONE) {
-                                cli_err ("%s is not a valid status option",
-                                         words[3]);
-                                ret = -1;
-                                goto out;
-                        }
-                        cmd |= GF_CLI_STATUS_ALL;
-                        ret  = 0;
-
-                } else {
-                        ret = dict_set_str (dict, "volname",
-                                            (char *)words[2]);
-                        if (ret)
-                                goto out;
-
-                        if (cmd == GF_CLI_STATUS_NONE) {
-                                if (!strcmp (words[3], "nfs")) {
-                                        cmd |= GF_CLI_STATUS_NFS;
-                                } else if (!strcmp (words[3], "shd")) {
-                                        cmd |= GF_CLI_STATUS_SHD;
-                                } else if (!strcmp (words[3], "quotad")) {
-                                        cmd |= GF_CLI_STATUS_QUOTAD;
-                                } else if (!strcmp (words[3], "snapd")) {
-                                        cmd |= GF_CLI_STATUS_SNAPD;
-                                } else if (!strcmp (words[3], "tierd")) {
-                                        cmd |= GF_CLI_STATUS_TIERD;
-                                } else if (!strcmp (words[3], "bitd")) {
-                                        cmd |= GF_CLI_STATUS_BITD;
-                                } else if (!strcmp (words[3], "scrub")) {
-                                        cmd |= GF_CLI_STATUS_SCRUB;
-                                } else {
-                                        cmd = GF_CLI_STATUS_BRICK;
-                                        ret = dict_set_str (dict, "brick",
-                                                            (char *)words[3]);
-                                }
-
-                        } else {
-                                cmd |= GF_CLI_STATUS_VOL;
-                                ret  = 0;
-                        }
-                }
-
-                break;
-
-        case 5:
-                if (!strcmp (words[2], "all")) {
-                        cli_err ("Cannot specify brick/nfs for \"all\"");
-                        ret = -1;
-                        goto out;
-                }
+            cmd = cli_cmd_get_statusop(words[3]);
 
-                cmd = cli_cmd_get_statusop (words[4]);
+            if (!strcmp(words[2], "all")) {
                 if (cmd == GF_CLI_STATUS_NONE) {
-                        cli_err ("%s is not a valid status option",
-                                 words[4]);
-                        ret = -1;
-                        goto out;
+                    cli_err("%s is not a valid status option", words[3]);
+                    ret = -1;
+                    goto out;
                 }
+                cmd |= GF_CLI_STATUS_ALL;
+                ret = 0;
 
-
-                ret = dict_set_str (dict, "volname", (char *)words[2]);
+            } else {
+                ret = dict_set_str(dict, "volname", (char *)words[2]);
                 if (ret)
-                        goto out;
+                    goto out;
 
-                if (!strcmp (words[3], "nfs")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Detail/FD/Tasks status not available"
-                                         " for NFS Servers");
-                                ret = -1;
-                                goto out;
-                        }
+                if (cmd == GF_CLI_STATUS_NONE) {
+                    if (!strcmp(words[3], "nfs")) {
                         cmd |= GF_CLI_STATUS_NFS;
-                } else if (!strcmp (words[3], "shd")){
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Detail/FD/Clients/Tasks status not "
-                                         "available for Self-heal Daemons");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "shd")) {
                         cmd |= GF_CLI_STATUS_SHD;
-                } else if (!strcmp (words[3], "quotad")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for Quota Daemon");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "quotad")) {
                         cmd |= GF_CLI_STATUS_QUOTAD;
-                } else if  (!strcmp (words[3], "snapd")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for snap daemon");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "snapd")) {
                         cmd |= GF_CLI_STATUS_SNAPD;
-                } else if  (!strcmp (words[3], "tierd")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for tier daemon");
-                                ret = -1;
-                                goto out;
-                        }
-                        cmd |= GF_CLI_STATUS_TIERD;
+                    } else if (!strcmp(words[3], "bitd")) {
+                        cmd |= GF_CLI_STATUS_BITD;
+                    } else if (!strcmp(words[3], "scrub")) {
+                        cmd |= GF_CLI_STATUS_SCRUB;
+                    } else {
+                        cmd = GF_CLI_STATUS_BRICK;
+                        ret = dict_set_str(dict, "brick", (char *)words[3]);
+                    }
+
                 } else {
-                        if (cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Tasks status not available for "
-                                         "bricks");
-                                ret = -1;
-                                goto out;
-                        }
-                        cmd |= GF_CLI_STATUS_BRICK;
-                        ret = dict_set_str (dict, "brick", (char *)words[3]);
+                    cmd |= GF_CLI_STATUS_VOL;
+                    ret = 0;
                 }
-                break;
+            }
 
-        default:
-                goto out;
-        }
+            break;
 
-        if (ret)
+        case 5:
+            if (!strcmp(words[2], "all")) {
+                cli_err("Cannot specify brick/nfs for \"all\"");
+                ret = -1;
                 goto out;
+            }
 
-        ret = dict_set_int32 (dict, "cmd", cmd);
-        if (ret)
+            cmd = cli_cmd_get_statusop(words[4]);
+            if (cmd == GF_CLI_STATUS_NONE) {
+                cli_err("%s is not a valid status option", words[4]);
+                ret = -1;
                 goto out;
+            }
+
+            ret = dict_set_str(dict, "volname", (char *)words[2]);
+            if (ret)
+                goto out;
+
+            if (!strcmp(words[3], "nfs")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_DETAIL ||
+                    cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Detail/FD/Tasks status not available"
+                        " for NFS Servers");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_NFS;
+            } else if (!strcmp(words[3], "shd")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Detail/FD/Clients/Tasks status not "
+                        "available for Self-heal Daemons");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_SHD;
+            } else if (!strcmp(words[3], "quotad")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_INODE) {
+                    cli_err(
+                        "Detail/FD/Clients/Inode status not "
+                        "available for Quota Daemon");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_QUOTAD;
+            } else if (!strcmp(words[3], "snapd")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_INODE) {
+                    cli_err(
+                        "Detail/FD/Clients/Inode status not "
+                        "available for snap daemon");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_SNAPD;
+            } else {
+                if (cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Tasks status not available for "
+                        "bricks");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_BRICK;
+                ret = dict_set_str(dict, "brick", (char *)words[3]);
+            }
+            break;
 
-        *options = dict;
+        default:
+            goto out;
+    }
 
- out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret)
+        goto out;
 
-        return ret;
+    ret = dict_set_int32(dict, "cmd", cmd);
+    if (ret)
+        goto out;
+
+    *options = dict;
+
+out:
+    if (ret && dict)
+        dict_unref(dict);
+
+    return ret;
 }
 
 gf_boolean_t
-cli_cmd_validate_dumpoption (const char *arg, char **option)
+cli_cmd_validate_dumpoption(const char *arg, char **option)
 {
-        char    *opwords[] = {"all", "nfs", "mem", "iobuf", "callpool", "priv",
-                              "fd", "inode", "history", "inodectx", "fdctx",
-                              "quotad", NULL};
-        char    *w = NULL;
-
-        w = str_getunamb (arg, opwords);
-        if (!w) {
-                gf_log ("cli", GF_LOG_DEBUG, "Unknown statedump option  %s",
-                        arg);
-                return _gf_false;
-        }
-        *option = w;
-        return _gf_true;
+    static char *opwords[] = {"all",   "nfs",    "mem",   "iobuf",   "callpool",
+                              "priv",  "fd",     "inode", "history", "inodectx",
+                              "fdctx", "quotad", NULL};
+    char *w = NULL;
+
+    w = str_getunamb(arg, opwords);
+    if (!w) {
+        gf_log("cli", GF_LOG_DEBUG, "Unknown statedump option  %s", arg);
+        return _gf_false;
+    }
+    *option = w;
+    return _gf_true;
 }
 
 int
-cli_cmd_volume_statedump_options_parse (const char **words, int wordcount,
-                                        dict_t **options)
+cli_cmd_volume_statedump_options_parse(const char **words, int wordcount,
+                                       dict_t **options)
 {
-        int     ret = 0;
-        int     i = 0;
-        dict_t  *dict = NULL;
-        int     option_cnt = 0;
-        char    *option = NULL;
-        char    option_str[_POSIX_HOST_NAME_MAX + 100] = {0,};
-        char    *tmp = NULL;
-        char    *ip_addr = NULL;
-        char    *pid = NULL;
-
-        if ((wordcount >= 5) && ((strcmp (words[3], "client")) == 0)) {
-                tmp = gf_strdup(words[4]);
-                if (!tmp) {
-                        ret = -1;
-                        goto out;
-                }
-                ip_addr = strtok(tmp, ":");
-                pid = strtok(NULL, ":");
-                if (valid_internet_address (ip_addr, _gf_true)
-                   && pid && gf_valid_pid (pid, strlen(pid))) {
-                        strncat (option_str, words[3], strlen (words[3]));
-                        strncat (option_str, " ", 1);
-                        strncat (option_str, ip_addr, strlen (ip_addr));
-                        strncat (option_str, " ", 1);
-                        strncat (option_str, pid, strlen (pid));
-                        option_cnt = 3;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    int ret = 0;
+    int i = 0;
+    dict_t *dict = NULL;
+    int option_cnt = 0;
+    char *option = NULL;
+    char *option_str = NULL;
+    char *tmp_str = NULL;
+    char *tmp = NULL;
+    char *ip_addr = NULL;
+    char *pid = NULL;
+
+    if ((wordcount >= 5) && ((strcmp(words[3], "client")) == 0)) {
+        tmp = gf_strdup(words[4]);
+        if (!tmp) {
+            ret = -1;
+            goto out;
+        }
+        ip_addr = strtok(tmp, ":");
+        pid = strtok(NULL, ":");
+        if (valid_internet_address(ip_addr, _gf_true, _gf_false) && pid &&
+            gf_valid_pid(pid, strlen(pid))) {
+            ret = gf_asprintf(&option_str, "%s %s %s", words[3], ip_addr, pid);
+            if (ret < 0) {
+                goto out;
+            }
+            option_cnt = 3;
         } else {
-                for (i = 3; i < wordcount; i++, option_cnt++) {
-                        if (!cli_cmd_validate_dumpoption (words[i], &option)) {
-                                ret = -1;
-                                goto out;
-                        }
-                        strncat (option_str, option, strlen (option));
-                        strncat (option_str, " ", 1);
-                }
-                if ((strstr (option_str, "nfs")) && strstr (option_str, "quotad")) {
-                        ret = -1;
-                        goto out;
-                }
+            ret = -1;
+            goto out;
         }
-
-        dict = dict_new ();
-        if (!dict)
+    } else {
+        for (i = 3; i < wordcount; i++, option_cnt++) {
+            if (!cli_cmd_validate_dumpoption(words[i], &option)) {
+                ret = -1;
                 goto out;
-
-        ret = dict_set_dynstr (dict, "options", gf_strdup (option_str));
-        if (ret)
+            }
+            tmp_str = option_str;
+            option_str = NULL;
+            ret = gf_asprintf(&option_str, "%s%s ", tmp_str ? tmp_str : "",
+                              option);
+            GF_FREE(tmp_str);
+            if (ret < 0) {
                 goto out;
+            }
+        }
+        if (option_str && (strstr(option_str, "nfs")) &&
+            strstr(option_str, "quotad")) {
+            ret = -1;
+            goto out;
+        }
+    }
 
-        ret = dict_set_int32 (dict, "option_cnt", option_cnt);
-        if (ret)
-                goto out;
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        *options = dict;
+    /* dynamic string in dict is freed up when dict is freed up, and hence
+    if option_str is NULL pass in an duplicate empty string to the same */
+    ret = dict_set_dynstr(dict, "options",
+                          (option_str ? option_str : gf_strdup("")));
+    if (ret)
+        goto out;
+    option_str = NULL;
+
+    ret = dict_set_int32(dict, "option_cnt", option_cnt);
+    if (ret)
+        goto out;
+
+    *options = dict;
 out:
-        GF_FREE (tmp);
-        if (ret && dict)
-                dict_unref (dict);
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "Error parsing dumpoptions");
-        return ret;
+    GF_FREE(tmp);
+    GF_FREE(option_str);
+    if (ret && dict)
+        dict_unref(dict);
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "Error parsing dumpoptions");
+    return ret;
 }
 
 int
-cli_cmd_volume_clrlks_opts_parse (const char **words, int wordcount,
-                                  dict_t **options)
+cli_cmd_volume_clrlks_opts_parse(const char **words, int wordcount,
+                                 dict_t **options)
 {
-        int     ret = -1;
-        int     i = 0;
-        dict_t  *dict = NULL;
-        char    *kind_opts[4] = {"blocked", "granted", "all", NULL};
-        char    *types[4] = {"inode", "entry", "posix", NULL};
-        char    *free_ptr = NULL;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    int ret = -1;
+    int i = 0;
+    dict_t *dict = NULL;
+    char *kind_opts[4] = {"blocked", "granted", "all", NULL};
+    char *types[4] = {"inode", "entry", "posix", NULL};
+    char *free_ptr = NULL;
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp (words[4], "kind"))
-                goto out;
+    if (strcmp(words[4], "kind"))
+        goto out;
 
-        for (i = 0; kind_opts[i]; i++) {
-               if (!strcmp (words[5], kind_opts[i])) {
-                       free_ptr = gf_strdup (words[5]);
-                       ret = dict_set_dynstr (dict, "kind", free_ptr);
-                       if (ret)
-                               goto out;
-                       free_ptr = NULL;
-                       break;
-               }
-        }
-        if (i == 3)
+    for (i = 0; kind_opts[i]; i++) {
+        if (!strcmp(words[5], kind_opts[i])) {
+            free_ptr = gf_strdup(words[5]);
+            ret = dict_set_dynstr(dict, "kind", free_ptr);
+            if (ret)
                 goto out;
+            free_ptr = NULL;
+            break;
+        }
+    }
+    if (i == 3)
+        goto out;
 
-        ret = -1;
-        for (i = 0; types[i]; i++) {
-               if (!strcmp (words[6], types[i])) {
-                       free_ptr = gf_strdup (words[6]);
-                       ret = dict_set_dynstr (dict, "type", free_ptr);
-                       if (ret)
-                               goto out;
-                       free_ptr = NULL;
-                       break;
-               }
-        }
-        if (i == 3)
+    ret = -1;
+    for (i = 0; types[i]; i++) {
+        if (!strcmp(words[6], types[i])) {
+            free_ptr = gf_strdup(words[6]);
+            ret = dict_set_dynstr(dict, "type", free_ptr);
+            if (ret)
                 goto out;
-
-        if (wordcount == 8) {
-                free_ptr = gf_strdup (words[7]);
-                ret = dict_set_dynstr (dict, "opts", free_ptr);
-                if (ret)
-                        goto out;
-                free_ptr = NULL;
+            free_ptr = NULL;
+            break;
         }
+    }
+    if (i == 3)
+        goto out;
 
-        ret = 0;
-        *options = dict;
+    if (wordcount == 8) {
+        free_ptr = gf_strdup(words[7]);
+        ret = dict_set_dynstr(dict, "opts", free_ptr);
+        if (ret)
+            goto out;
+        free_ptr = NULL;
+    }
+
+    ret = 0;
+    *options = dict;
 out:
-       if (ret) {
-               GF_FREE (free_ptr);
-               dict_unref (dict);
-       }
+    if (ret) {
+        GF_FREE(free_ptr);
+        dict_unref(dict);
+    }
 
-       return ret;
+    return ret;
 }
 
 static int
-extract_hostname_path_from_token (const char *tmp_words, char **hostname,
-                                  char **path)
+extract_hostname_path_from_token(const char *tmp_words, char **hostname,
+                                 char **path)
 {
-        int ret = 0;
-        char *delimiter = NULL;
-        char *tmp_host = NULL;
-        char *host_name = NULL;
-        char *words = NULL;
-
-        *hostname = NULL;
-        *path = NULL;
-
-        words = GF_CALLOC (1, strlen (tmp_words) + 1, gf_common_mt_char);
-        if (!words){
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    char *delimiter = NULL;
+    char *tmp_host = NULL;
+    char *host_name = NULL;
+    char *words = NULL;
+    int str_len = 0;
+    *hostname = NULL;
+    *path = NULL;
+
+    str_len = strlen(tmp_words) + 1;
+    words = GF_MALLOC(str_len, gf_common_mt_char);
+    if (!words) {
+        ret = -1;
+        goto out;
+    }
 
-        strncpy (words, tmp_words, strlen (tmp_words) + 1);
+    snprintf(words, str_len, "%s", tmp_words);
 
-        if (validate_brick_name (words)) {
-                cli_err ("Wrong brick type: %s, use <HOSTNAME>:"
-                        "<export-dir-abs-path>", words);
-                ret = -1;
-                goto out;
+    if (validate_brick_name(words)) {
+        cli_err(
+            "Wrong brick type: %s, use <HOSTNAME>:"
+            "<export-dir-abs-path>",
+            words);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr(words, ':');
+        ret = gf_canonicalize_path(delimiter + 1);
+        if (ret) {
+            goto out;
         } else {
-                delimiter = strrchr (words, ':');
-                ret = gf_canonicalize_path (delimiter + 1);
-                if (ret) {
-                        goto out;
-                } else {
-                        *path = GF_CALLOC (1, strlen (delimiter+1) +1,
-                                           gf_common_mt_char);
-                        if (!*path) {
-                           ret = -1;
-                                goto out;
-
-                        }
-                        strncpy (*path, delimiter +1,
-                                 strlen(delimiter + 1) + 1);
-                }
-        }
-
-        tmp_host = gf_strdup (words);
-        if (!tmp_host) {
-                gf_log ("cli", GF_LOG_ERROR, "Out of memory");
-                ret = -1;
-                goto out;
-        }
-        get_host_name (tmp_host, &host_name);
-        if (!host_name) {
-                ret = -1;
-                gf_log("cli",GF_LOG_ERROR, "Unable to allocate "
-                        "memory");
-                goto out;
-        }
-        if (!(strcmp (host_name, "localhost") &&
-            strcmp (host_name, "127.0.0.1") &&
-            strncmp (host_name, "0.", 2))) {
-                cli_err ("Please provide a valid hostname/ip other "
-                         "than localhost, 127.0.0.1 or loopback "
-                         "address (0.0.0.0 to 0.255.255.255).");
-                ret = -1;
-                goto out;
-        }
-        if (!valid_internet_address (host_name, _gf_false)) {
-                cli_err ("internet address '%s' does not conform to "
-                          "standards", host_name);
+            str_len = strlen(delimiter + 1) + 1;
+            *path = GF_MALLOC(str_len, gf_common_mt_char);
+            if (!*path) {
                 ret = -1;
                 goto out;
+            }
+            snprintf(*path, str_len, "%s", delimiter + 1);
         }
+    }
 
-        *hostname = GF_CALLOC (1, strlen (host_name) + 1,
-                                       gf_common_mt_char);
-        if (!*hostname) {
-                ret = -1;
-                goto out;
-        }
-        strncpy (*hostname, host_name, strlen (host_name) + 1);
-        ret = 0;
+    tmp_host = gf_strdup(words);
+    if (!tmp_host) {
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        ret = -1;
+        goto out;
+    }
+    get_host_name(tmp_host, &host_name);
+    if (!host_name) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to allocate "
+               "memory");
+        goto out;
+    }
+    if (!(strcmp(host_name, "localhost") && strcmp(host_name, "127.0.0.1") &&
+          strncmp(host_name, "0.", 2))) {
+        cli_err(
+            "Please provide a valid hostname/ip other "
+            "than localhost, 127.0.0.1 or loopback "
+            "address (0.0.0.0 to 0.255.255.255).");
+        ret = -1;
+        goto out;
+    }
+    if (!valid_internet_address(host_name, _gf_false, _gf_false)) {
+        cli_err(
+            "internet address '%s' does not conform to "
+            "standards",
+            host_name);
+        ret = -1;
+        goto out;
+    }
+
+    str_len = strlen(host_name) + 1;
+    *hostname = GF_MALLOC(str_len, gf_common_mt_char);
+    if (!*hostname) {
+        ret = -1;
+        goto out;
+    }
+    snprintf(*hostname, str_len, "%s", host_name);
+    ret = 0;
 
 out:
-        GF_FREE (words);
-        GF_FREE (tmp_host);
-        return ret;
+    GF_FREE(words);
+    GF_FREE(tmp_host);
+    return ret;
 }
 
 static int
-set_hostname_path_in_dict (const char *token, dict_t *dict, int heal_op)
+set_hostname_path_in_dict(const char *token, dict_t *dict, int heal_op)
 {
-        char *hostname = NULL;
-        char *path     = NULL;
-        int   ret      = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int ret = 0;
 
-        ret = extract_hostname_path_from_token (token, &hostname, &path);
-        if (ret)
-                goto out;
+    ret = extract_hostname_path_from_token(token, &hostname, &path);
+    if (ret)
+        goto out;
 
-        switch (heal_op) {
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_set_dynstr (dict, "heal-source-hostname",
-                                       hostname);
-                if (ret)
-                        goto out;
-                ret = dict_set_dynstr (dict, "heal-source-brickpath",
-                                       path);
-                break;
+            ret = dict_set_dynstr(dict, "heal-source-hostname", hostname);
+            if (ret)
+                goto out;
+            hostname = NULL;
+            ret = dict_set_dynstr(dict, "heal-source-brickpath", path);
+            if (ret) {
+                goto out;
+            }
+            path = NULL;
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                ret = dict_set_dynstr (dict, "per-replica-cmd-hostname",
-                                       hostname);
-                if (ret)
-                        goto out;
-                ret = dict_set_dynstr (dict, "per-replica-cmd-path",
-                                       path);
-                break;
+            ret = dict_set_dynstr(dict, "per-replica-cmd-hostname", hostname);
+            if (ret)
+                goto out;
+            hostname = NULL;
+            ret = dict_set_dynstr(dict, "per-replica-cmd-path", path);
+            if (ret) {
+                goto out;
+            }
+            path = NULL;
+            break;
         default:
-                ret = -1;
-                break;
-        }
+            ret = -1;
+            break;
+    }
 
 out:
-        return ret;
+    GF_FREE(hostname);
+    GF_FREE(path);
+    return ret;
 }
 
 static int
-heal_command_type_get (const char *command)
+heal_command_type_get(const char *command)
 {
-        int     i = 0;
-        /* subcommands are set as NULL */
-        char    *heal_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
-                [GF_SHD_OP_INVALID]                            = NULL,
-                [GF_SHD_OP_HEAL_INDEX]                         = NULL,
-                [GF_SHD_OP_HEAL_FULL]                          = "full",
-                [GF_SHD_OP_INDEX_SUMMARY]                      = "info",
-                [GF_SHD_OP_HEALED_FILES]                       = NULL,
-                [GF_SHD_OP_HEAL_FAILED_FILES]                  = NULL,
-                [GF_SHD_OP_SPLIT_BRAIN_FILES]                  = NULL,
-                [GF_SHD_OP_STATISTICS]                         = "statistics",
-                [GF_SHD_OP_STATISTICS_HEAL_COUNT]              = NULL,
-                [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA]  = NULL,
-                [GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE]       = NULL,
-                [GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK]             = NULL,
-                [GF_SHD_OP_HEAL_ENABLE]                        = "enable",
-                [GF_SHD_OP_HEAL_DISABLE]                       = "disable",
-        };
-
-        for (i = 0; i <= GF_SHD_OP_HEAL_DISABLE; i++) {
-                if (heal_cmds[i] && (strcmp (heal_cmds[i], command) == 0))
-                        return i;
-        }
-
-        return GF_SHD_OP_INVALID;
+    int i = 0;
+    /* subcommands are set as NULL */
+    char *heal_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
+        [GF_SHD_OP_INVALID] = NULL,
+        [GF_SHD_OP_HEAL_INDEX] = NULL,
+        [GF_SHD_OP_HEAL_FULL] = "full",
+        [GF_SHD_OP_INDEX_SUMMARY] = "info",
+        [GF_SHD_OP_SPLIT_BRAIN_FILES] = NULL,
+        [GF_SHD_OP_STATISTICS] = "statistics",
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT] = NULL,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = NULL,
+        [GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE] = NULL,
+        [GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK] = NULL,
+        [GF_SHD_OP_HEAL_ENABLE] = "enable",
+        [GF_SHD_OP_HEAL_DISABLE] = "disable",
+    };
+
+    for (i = 0; i <= GF_SHD_OP_HEAL_DISABLE; i++) {
+        if (heal_cmds[i] && (strcmp(heal_cmds[i], command) == 0))
+            return i;
+    }
+
+    return GF_SHD_OP_INVALID;
 }
 
 int
-cli_cmd_volume_heal_options_parse (const char **words, int wordcount,
-                                   dict_t **options)
+cli_cmd_volume_heal_options_parse(const char **words, int wordcount,
+                                  dict_t **options)
 {
-        int     ret = 0;
-        dict_t  *dict = NULL;
-        gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to create the dict");
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *) words[2]);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set volname");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set volname");
+        goto out;
+    }
 
-        if (wordcount == 3) {
-                ret = dict_set_int32 (dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
-                goto done;
-        }
+    if (wordcount == 3) {
+        ret = dict_set_int32(dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
+        goto done;
+    }
 
-        if (wordcount == 4) {
-                op = heal_command_type_get (words[3]);
-                if (op == GF_SHD_OP_INVALID) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_set_int32 (dict, "heal-op", op);
-                goto done;
+    if (wordcount == 4) {
+        op = heal_command_type_get(words[3]);
+        if (op == GF_SHD_OP_INVALID) {
+            ret = -1;
+            goto out;
         }
 
-        if (wordcount == 5) {
-                if (strcmp (words[3], "info") &&
-                    strcmp (words[3], "statistics") &&
-                    strcmp (words[3], "granular-entry-heal")) {
-                        ret = -1;
-                        goto out;
-                }
-
-                if (!strcmp (words[3], "info")) {
-                        if (!strcmp (words[4], "split-brain")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                                   GF_SHD_OP_SPLIT_BRAIN_FILES);
-                                goto done;
-                        }
-                }
-
-                if (!strcmp (words[3], "statistics")) {
-                        if (!strcmp (words[4], "heal-count")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                               GF_SHD_OP_STATISTICS_HEAL_COUNT);
-                                goto done;
-                        }
-                }
+        ret = dict_set_int32(dict, "heal-op", op);
+        goto done;
+    }
 
-                if (!strcmp (words[3], "granular-entry-heal")) {
-                        if (!strcmp (words[4], "enable")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                          GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE);
-                                goto done;
-                        } else if (!strcmp (words[4], "disable")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                         GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE);
-                                goto done;
-                        }
-                }
+    if (wordcount == 5) {
+        if (strcmp(words[3], "info") && strcmp(words[3], "statistics") &&
+            strcmp(words[3], "granular-entry-heal")) {
+            ret = -1;
+            goto out;
+        }
 
-                ret = -1;
-                goto out;
+        if (!strcmp(words[3], "info")) {
+            if (!strcmp(words[4], "split-brain")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_SPLIT_BRAIN_FILES);
+                goto done;
+            }
+            if (!strcmp(words[4], "summary")) {
+                ret = dict_set_int32(dict, "heal-op", GF_SHD_OP_HEAL_SUMMARY);
+                goto done;
+            }
         }
-        if (wordcount == 6) {
-                if (strcmp (words[3], "split-brain")) {
-                        ret = -1;
-                        goto out;
-                }
-                if (!strcmp (words[4], "bigger-file")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                        GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file", (char *)words[5]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                if (!strcmp (words[4], "latest-mtime")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                       GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file", (char *)words[5]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                if (!strcmp (words[4], "source-brick")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        ret = set_hostname_path_in_dict (words[5], dict,
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                ret = -1;
-                goto out;
+
+        if (!strcmp(words[3], "statistics")) {
+            if (!strcmp(words[4], "heal-count")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_STATISTICS_HEAL_COUNT);
+                goto done;
+            }
         }
-        if (wordcount == 7) {
-                if (!strcmp (words[3], "statistics")
-                    && !strcmp (words[4], "heal-count")
-                    && !strcmp (words[5], "replica")) {
-
-                        ret = dict_set_int32 (dict, "heal-op",
-                                   GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
-                        if (ret)
-                                goto out;
-                        ret = set_hostname_path_in_dict (words[6], dict,
-                                   GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
-                        if (ret)
-                                goto out;
-                        goto done;
 
-                }
-                if (!strcmp (words[3], "split-brain") &&
-                    !strcmp (words[4], "source-brick")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        ret = set_hostname_path_in_dict (words[5], dict,
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file",
-                                            (char *) words[6]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
+        if (!strcmp(words[3], "granular-entry-heal")) {
+            if (!strcmp(words[4], "enable")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE);
+                goto done;
+            } else if (!strcmp(words[4], "disable")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE);
+                goto done;
+            }
         }
+
         ret = -1;
         goto out;
-done:
-        *options = dict;
-out:
-        if (ret && dict) {
-                dict_unref (dict);
-                *options = NULL;
+    }
+    if (wordcount == 6) {
+        if (strcmp(words[3], "split-brain")) {
+            ret = -1;
+            goto out;
         }
-
-        return ret;
-}
-
-int
-cli_cmd_volume_old_tier_parse (const char **words, int wordcount,
-                             dict_t **options)
-{
-        dict_t                 *dict = NULL;
-        int                      ret = -1;
-        char                *volname = NULL;
-        gf_cli_defrag_type       cmd = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
+        if (!strcmp(words[4], "bigger-file")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE);
+            if (ret)
                 goto out;
-
-        if (wordcount != 4)
+            ret = dict_set_str(dict, "file", (char *)words[5]);
+            if (ret)
                 goto out;
-
-        if ((strcmp (words[1], "tier") == 0) &&
-            (strcmp (words[3], "start") == 0)) {
-                cmd = GF_DEFRAG_CMD_START_TIER;
-        } else
+            goto done;
+        }
+        if (!strcmp(words[4], "latest-mtime")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME);
+            if (ret)
                 goto out;
-
-        volname = (char *) words[2];
-
-        ret = dict_set_str (dict, "volname", volname);
-
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
+            ret = dict_set_str(dict, "file", (char *)words[5]);
+            if (ret)
                 goto out;
+            goto done;
         }
-
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
-
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
+        if (!strcmp(words[4], "source-brick")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
+                goto out;
+            ret = set_hostname_path_in_dict(words[5], dict,
+                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
                 goto out;
+            goto done;
         }
-
-        *options = dict;
-
+        ret = -1;
+        goto out;
+    }
+    if (wordcount == 7) {
+        if (!strcmp(words[3], "statistics") &&
+            !strcmp(words[4], "heal-count") && !strcmp(words[5], "replica")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
+            if (ret)
+                goto out;
+            ret = set_hostname_path_in_dict(
+                words[6], dict, GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
+            if (ret)
+                goto out;
+            goto done;
+        }
+        if (!strcmp(words[3], "split-brain") &&
+            !strcmp(words[4], "source-brick")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            ret = set_hostname_path_in_dict(words[5], dict,
+                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
+                goto out;
+            ret = dict_set_str(dict, "file", (char *)words[6]);
+            if (ret)
+                goto out;
+            goto done;
+        }
+    }
+    ret = -1;
+    goto out;
+done:
+    *options = dict;
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict) {
+        dict_unref(dict);
+        *options = NULL;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_defrag_parse (const char **words, int wordcount,
-                             dict_t **options)
+cli_cmd_volume_defrag_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t                 *dict = NULL;
-        int                      ret = -1;
-        char                *option  = NULL;
-        char                *volname = NULL;
-        char                *command = NULL;
-        gf_cli_defrag_type       cmd = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (!((wordcount == 4) || (wordcount == 5)))
-                goto out;
-
-        if (wordcount == 4) {
-                if (strcmp (words[3], "start") && strcmp (words[3], "stop") &&
-                    strcmp (words[3], "status"))
-                            goto out;
-        } else {
-                if (strcmp (words[3], "fix-layout") &&
-                    strcmp (words[3], "start"))
-                        goto out;
-        }
-
-        volname = (char *) words[2];
-
-        if (wordcount == 4) {
-                command = (char *) words[3];
-        }
-        if (wordcount == 5) {
-               if ((strcmp (words[3], "fix-layout") ||
-                    strcmp (words[4], "start")) &&
-                    (strcmp (words[3], "start") ||
-                    strcmp (words[4], "force"))) {
-                        ret = -1;
-                        goto out;
-                }
-                command = (char *) words[3];
-                option = (char *) words[4];
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *option = NULL;
+    char *volname = NULL;
+    char *command = NULL;
+    gf_cli_defrag_type cmd = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp (command, "start") == 0) {
-                cmd = GF_DEFRAG_CMD_START;
-                if (option && strcmp (option, "force") == 0) {
-                                cmd = GF_DEFRAG_CMD_START_FORCE;
-                        }
-                goto done;
-        }
+    if (!((wordcount == 4) || (wordcount == 5)))
+        goto out;
 
-        if (strcmp (command, "fix-layout") == 0) {
-                cmd = GF_DEFRAG_CMD_START_LAYOUT_FIX;
-                goto done;
-        }
-        if (strcmp (command, "stop") == 0) {
-                cmd = GF_DEFRAG_CMD_STOP;
-                goto done;
-        }
-        if (strcmp (command, "status") == 0) {
-                cmd = GF_DEFRAG_CMD_STATUS;
-        }
+    if (wordcount == 4) {
+        if (strcmp(words[3], "start") && strcmp(words[3], "stop") &&
+            strcmp(words[3], "status"))
+            goto out;
+    } else {
+        if (strcmp(words[3], "fix-layout") && strcmp(words[3], "start"))
+            goto out;
+    }
+
+    volname = (char *)words[2];
+
+    if (wordcount == 4) {
+        command = (char *)words[3];
+    }
+    if (wordcount == 5) {
+        if ((strcmp(words[3], "fix-layout") || strcmp(words[4], "start")) &&
+            (strcmp(words[3], "start") || strcmp(words[4], "force"))) {
+            ret = -1;
+            goto out;
+        }
+        command = (char *)words[3];
+        option = (char *)words[4];
+    }
+
+    if (strcmp(command, "start") == 0) {
+        cmd = GF_DEFRAG_CMD_START;
+        if (option && strcmp(option, "force") == 0) {
+            cmd = GF_DEFRAG_CMD_START_FORCE;
+        }
+        goto done;
+    }
+
+    if (strcmp(command, "fix-layout") == 0) {
+        cmd = GF_DEFRAG_CMD_START_LAYOUT_FIX;
+        goto done;
+    }
+    if (strcmp(command, "stop") == 0) {
+        cmd = GF_DEFRAG_CMD_STOP;
+        goto done;
+    }
+    if (strcmp(command, "status") == 0) {
+        cmd = GF_DEFRAG_CMD_STATUS;
+    }
 
 done:
-        ret = dict_set_str (dict, "volname", volname);
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
+    ret = dict_set_int32(dict, "rebalance-command", (int32_t)cmd);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_snap_create_desc_parse (dict_t *dict, const char **words,
-                            size_t wordcount, int32_t desc_opt_loc)
+cli_snap_create_desc_parse(dict_t *dict, const char **words, size_t wordcount,
+                           int32_t desc_opt_loc)
 {
-        int32_t        ret      = -1;
-        char          *desc     = NULL;
-        int32_t        desc_len = 0;
-
-        desc = GF_CALLOC (MAX_SNAP_DESCRIPTION_LEN + 1, sizeof(char),
-                          gf_common_mt_char);
-        if (!desc) {
-                ret = -1;
-                goto out;
-        }
-
-
-        if (strlen (words[desc_opt_loc]) >= MAX_SNAP_DESCRIPTION_LEN) {
-                cli_out ("snapshot create: description truncated: "
-                         "Description provided is longer than 1024 characters");
-                desc_len = MAX_SNAP_DESCRIPTION_LEN;
-        } else {
-                desc_len = strlen (words[desc_opt_loc]);
-        }
-
-        strncpy (desc, words[desc_opt_loc], desc_len);
-        desc[desc_len] = '\0';
-        /* Calculating the size of the description as given by the user */
+    int32_t ret = -1;
+    char *desc = NULL;
+    int32_t desc_len = 0;
+    int len;
 
-        ret = dict_set_dynstr (dict, "description", desc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap "
-                        "description");
-                goto out;
-        }
+    desc = GF_MALLOC(MAX_SNAP_DESCRIPTION_LEN + 1, gf_common_mt_char);
+    if (!desc) {
+        ret = -1;
+        goto out;
+    }
+
+    len = strlen(words[desc_opt_loc]);
+    if (len >= MAX_SNAP_DESCRIPTION_LEN) {
+        cli_out(
+            "snapshot create: description truncated: "
+            "Description provided is longer than 1024 characters");
+        desc_len = MAX_SNAP_DESCRIPTION_LEN;
+    } else {
+        desc_len = len;
+    }
+
+    snprintf(desc, desc_len + 1, "%s", words[desc_opt_loc]);
+    /* Calculating the size of the description as given by the user */
+
+    ret = dict_set_dynstr(dict, "description", desc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to save snap "
+               "description");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && desc)
-                GF_FREE (desc);
+    if (ret && desc)
+        GF_FREE(desc);
 
-        return ret;
+    return ret;
 }
 
 /* Function to check whether the Volume name is repeated */
 int
-cli_check_if_volname_repeated (const char **words, unsigned int start_index,
-                           uint64_t cur_index) {
-        uint64_t        i       =       -1;
-        int             ret     =        0;
+cli_check_if_volname_repeated(const char **words, unsigned int start_index,
+                              uint64_t cur_index)
+{
+    uint64_t i = -1;
+    int ret = 0;
 
-        GF_ASSERT (words);
+    GF_ASSERT(words);
 
-        for (i = start_index ; i < cur_index ; i++) {
-                if (strcmp (words[i], words[cur_index]) == 0) {
-                        ret = -1;
-                        goto out;
-                }
+    for (i = start_index; i < cur_index; i++) {
+        if (strcmp(words[i], words[cur_index]) == 0) {
+            ret = -1;
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot clone <clonename> <snapname>
@@ -4155,72 +4243,77 @@ out:
  *                 0 on success
  */
 int
-cli_snap_clone_parse (dict_t *dict, const char **words, int wordcount) {
-        uint64_t        i               =       0;
-        int             ret             =       -1;
-        char            *clonename      =       NULL;
-        unsigned int    cmdi            =       2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot clone)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount == cmdi + 1) {
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Invalid number of  words for snap clone command");
-                goto out;
-        }
-
-        if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
-                cli_err ("snapshot clone: failed: clonename cannot exceed "
-                         "255 characters.");
-                gf_log ("cli", GF_LOG_ERROR, "Clone name too long");
-
-                goto out;
-        }
-
-        clonename = (char *) words[cmdi];
-        for (i = 0 ; i < strlen (clonename); i++) {
-                /* Following volume name convention */
-                if (!isalnum (clonename[i]) && (clonename[i] != '_'
-                                           && (clonename[i] != '-'))) {
-                        /* TODO : Is this message enough?? */
-                        cli_err ("Clonename can contain only alphanumeric, "
-                                 "\"-\" and \"_\" characters");
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (dict, "volcount", 1);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save volcount");
-                goto out;
-        }
+cli_snap_clone_parse(dict_t *dict, const char **words, int wordcount)
+{
+    uint64_t i = 0;
+    int ret = -1;
+    char *clonename = NULL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot clone)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if (wordcount == cmdi + 1) {
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR,
+               "Invalid number of  words for snap clone command");
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "clonename", (char *)words[cmdi]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save clone "
-                        "name(%s)", (char *)words[cmdi]);
-                goto out;
-        }
+    if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
+        cli_err(
+            "snapshot clone: failed: clonename cannot exceed "
+            "255 characters.");
+        gf_log("cli", GF_LOG_ERROR, "Clone name too long");
 
-        /* Filling snap name in the dictionary */
-        ret = dict_set_str (dict, "snapname", (char *)words[cmdi+1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not "
-                        "save snap name(%s)", (char *)words[cmdi+1]);
-                goto out;
-        }
+        goto out;
+    }
+
+    clonename = (char *)words[cmdi];
+    for (i = 0; i < strlen(clonename); i++) {
+        /* Following volume name convention */
+        if (!isalnum(clonename[i]) &&
+            (clonename[i] != '_' && (clonename[i] != '-'))) {
+            /* TODO : Is this message enough?? */
+            cli_err(
+                "Clonename can contain only alphanumeric, "
+                "\"-\" and \"_\" characters");
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "volcount", 1);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save volcount");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "clonename", (char *)words[cmdi]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save clone "
+               "name(%s)",
+               (char *)words[cmdi]);
+        goto out;
+    }
+
+    /* Filling snap name in the dictionary */
+    ret = dict_set_str(dict, "snapname", (char *)words[cmdi + 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not "
+               "save snap name(%s)",
+               (char *)words[cmdi + 1]);
+        goto out;
+    }
 
-
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* snapshot create <snapname> <vol-name(s)> [description <description>]
  *                                           [force]
  * @arg-0, dict     : Request Dictionary to be sent to server side.
@@ -4231,172 +4324,181 @@ out:
  *                 0 on success
  */
 int
-cli_snap_create_parse (dict_t *dict, const char **words, int wordcount) {
-        uint64_t        i               =       0;
-        int             ret             =       -1;
-        uint64_t        volcount        =       0;
-        char            key[PATH_MAX]   =       "";
-        char            *snapname       =       NULL;
-        unsigned int    cmdi            =       2;
-        int             flags           =       0;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot create)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount <= cmdi + 1) {
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Too less words for snap create command");
-                goto out;
-        }
+cli_snap_create_parse(dict_t *dict, const char **words, int wordcount)
+{
+    uint64_t i = 0;
+    int ret = -1;
+    uint64_t volcount = 0;
+    char key[PATH_MAX] = "";
+    char *snapname = NULL;
+    unsigned int cmdi = 2;
+    int flags = 0;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot create)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if (wordcount <= cmdi + 1) {
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR, "Too less words for snap create command");
+        goto out;
+    }
 
-        if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
-                cli_err ("snapshot create: failed: snapname cannot exceed "
-                         "255 characters.");
-                gf_log ("cli", GF_LOG_ERROR, "Snapname too long");
+    if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
+        cli_err(
+            "snapshot create: failed: snapname cannot exceed "
+            "255 characters.");
+        gf_log("cli", GF_LOG_ERROR, "Snapname too long");
 
-                goto out;
+        goto out;
+    }
+
+    snapname = (char *)words[cmdi];
+    for (i = 0; i < strlen(snapname); i++) {
+        /* Following volume name convention */
+        if (!isalnum(snapname[i]) &&
+            (snapname[i] != '_' && (snapname[i] != '-'))) {
+            /* TODO : Is this message enough?? */
+            cli_err(
+                "Snapname can contain only alphanumeric, "
+                "\"-\" and \"_\" characters");
+            goto out;
+        }
+    }
+
+    ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save snap "
+               "name(%s)",
+               (char *)words[cmdi]);
+        goto out;
+    }
+
+    /* Filling volume name in the dictionary */
+    for (i = cmdi + 1;
+         i < wordcount && (strcmp(words[i], "description")) != 0 &&
+         (strcmp(words[i], "force") != 0) &&
+         (strcmp(words[i], "no-timestamp") != 0);
+         i++) {
+        volcount++;
+        /* volume index starts from 1 */
+        ret = snprintf(key, sizeof(key), "volname%" PRIu64, volcount);
+        if (ret < 0) {
+            goto out;
         }
 
-        snapname = (char *) words[cmdi];
-        for (i = 0 ; i < strlen (snapname); i++) {
-                /* Following volume name convention */
-                if (!isalnum (snapname[i]) && (snapname[i] != '_'
-                                           && (snapname[i] != '-'))) {
-                        /* TODO : Is this message enough?? */
-                        cli_err ("Snapname can contain only alphanumeric, "
-                                 "\"-\" and \"_\" characters");
-                        goto out;
-                }
+        ret = dict_set_str(dict, key, (char *)words[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not "
+                   "save volume name(%s)",
+                   (char *)words[i]);
+            goto out;
         }
 
-        ret = dict_set_str (dict, "snapname", (char *)words[cmdi]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save snap "
-                        "name(%s)", (char *)words[cmdi]);
-                goto out;
+        if (i >= cmdi + 2) {
+            ret = -1;
+            cli_err(
+                "Creating multiple volume snapshot is not "
+                "supported as of now");
+            goto out;
         }
+        /* TODO : remove this above condition check once
+         * multiple volume snapshot is supported */
+    }
 
-        /* Filling volume name in the dictionary */
-        for (i = cmdi + 1 ; i < wordcount
-                            && (strcmp (words[i], "description")) != 0
-                            && (strcmp (words[i], "force") != 0)
-                            && (strcmp (words[i], "no-timestamp") != 0);
-                            i++) {
-                volcount++;
-                /* volume index starts from 1 */
-                ret = snprintf (key, sizeof (key), "volname%"PRIu64, volcount);
-                if (ret < 0) {
-                        goto out;
-                }
+    if (volcount == 0) {
+        ret = -1;
+        cli_err("Please provide the volume name");
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-                ret = dict_set_str (dict, key, (char *)words[i]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                "save volume name(%s)", (char *)words[i]);
-                        goto out;
-                }
+    ret = dict_set_int32(dict, "volcount", volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save volcount");
+        goto out;
+    }
+
+    /* Verify how we got out of "for" loop,
+     * if it is by reaching wordcount limit then goto "out",
+     * because we need not parse for "description","force" and
+     * "no-timestamp" after this.
+     */
+    if (i == wordcount) {
+        goto out;
+    }
 
-                if (i >= cmdi + 2) {
-                        ret = -1;
-                        cli_err("Creating multiple volume snapshot is not "
-                                "supported as of now");
-                        goto out;
-                }
-                /* TODO : remove this above condition check once
-                 * multiple volume snapshot is supported */
+    if (strcmp(words[i], "no-timestamp") == 0) {
+        ret = dict_set_int32n(dict, "no-timestamp", SLEN("no-timestamp"), 1);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "time-stamp option");
         }
+        if (i == (wordcount - 1))
+            goto out;
+        i++;
+    }
 
-        if (volcount == 0) {
-                ret = -1;
-                cli_err ("Please provide the volume name");
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+    if ((strcmp(words[i], "description")) == 0) {
+        ++i;
+        if (i > (wordcount - 1)) {
+            ret = -1;
+            cli_err("Please provide a description");
+            gf_log("cli", GF_LOG_ERROR, "Description not provided");
+            goto out;
         }
 
-        ret = dict_set_int32 (dict, "volcount", volcount);
+        ret = cli_snap_create_desc_parse(dict, words, wordcount, i);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save volcount");
-                goto out;
-        }
-
-        /* Verify how we got out of "for" loop,
-         * if it is by reaching wordcount limit then goto "out",
-         * because we need not parse for "description","force" and
-         * "no-timestamp" after this.
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save snap "
+                   "description");
+            goto out;
+        }
+
+        if (i == (wordcount - 1))
+            goto out;
+        i++;
+        /* point the index to next word.
+         * As description might be follwed by force option.
+         * Before that, check if wordcount limit is reached
          */
-        if (i == wordcount) {
-                goto out;
-        }
-
-        if (strcmp (words[i], "no-timestamp") == 0) {
-                ret = dict_set_str (dict, "no-timestamp", "true");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "time-stamp option");
-                }
-                if (i == (wordcount-1))
-                        goto out;
-                i++;
-        }
-
-        if ((strcmp (words[i], "description")) == 0) {
-                ++i;
-                if (i > (wordcount - 1)) {
-                        ret = -1;
-                        cli_err ("Please provide a description");
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Description not provided");
-                        goto out;
-                }
-
-                ret = cli_snap_create_desc_parse(dict, words, wordcount, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save snap "
-                                "description");
-                        goto out;
-                }
-
-                if (i == (wordcount - 1))
-                        goto out;
-                i++;
-                /* point the index to next word.
-                 * As description might be follwed by force option.
-                 * Before that, check if wordcount limit is reached
-                 */
-        }
+    }
 
-        if (strcmp (words[i], "force") == 0) {
-                flags = GF_CLI_FLAG_OP_FORCE;
+    if (strcmp(words[i], "force") == 0) {
+        flags = GF_CLI_FLAG_OP_FORCE;
 
-        } else {
-                ret = -1;
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    } else {
+        ret = -1;
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        /* Check if the command has anything after "force" keyword */
-        if (++i < wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    /* Check if the command has anything after "force" keyword */
+    if (++i < wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if(ret == 0) {
-                /*Adding force flag in either of the case i.e force set
-                 * or unset*/
-                ret = dict_set_int32 (dict, "flags", flags);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "snap force option");
-                }
+    if (ret == 0) {
+        /*Adding force flag in either of the case i.e force set
+         * or unset*/
+        ret = dict_set_int32(dict, "flags", flags);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "snap force option");
         }
-        return ret;
+    }
+    return ret;
 }
 
 /* snapshot list [volname]
@@ -4408,30 +4510,30 @@ out:
  *                 0 on success
  */
 int
-cli_snap_list_parse (dict_t *dict, const char **words, int wordcount) {
-        int             ret     =       -1;
+cli_snap_list_parse(dict_t *dict, const char **words, int wordcount)
+{
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        if (wordcount < 2 || wordcount > 3) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if (wordcount < 2 || wordcount > 3) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (wordcount == 2) {
-                ret = 0;
-                goto out;
-        }
+    if (wordcount == 2) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to save volname in dictionary");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save volname in dictionary");
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot info [(snapname |  volume <volname>)]
@@ -4443,87 +4545,88 @@ out:
  *                 0 on success
  */
 int
-cli_snap_info_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_info_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int32_t cmd = GF_SNAP_INFO_TYPE_ALL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot info)*/
 
-        int             ret             =       -1;
-        int32_t         cmd             =       GF_SNAP_INFO_TYPE_ALL;
-        unsigned int    cmdi            =        2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot info)*/
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    if (wordcount > 4 || wordcount < cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid syntax");
+        goto out;
+    }
 
-        if (wordcount > 4 || wordcount < cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid syntax");
-                goto out;
-        }
+    if (wordcount == cmdi) {
+        ret = 0;
+        goto out;
+    }
 
-        if (wordcount == cmdi) {
-                ret = 0;
-                goto out;
+    /* If 3rd word is not "volume", then it must
+     * be snapname.
+     */
+    if (strcmp(words[cmdi], "volume") != 0) {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to save "
+                   "snapname %s",
+                   words[cmdi]);
+            goto out;
         }
 
-        /* If 3rd word is not "volume", then it must
-         * be snapname.
+        /* Once snap name is parsed, if we encounter any other
+         * word then fail it. Invalid Syntax.
+         * example : snapshot info <snapname> word
          */
-        if (strcmp (words[cmdi], "volume") != 0) {
-                ret = dict_set_str (dict, "snapname",
-                                   (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to save "
-                                "snapname %s", words[cmdi]);
-                        goto out;
-                }
-
-                /* Once snap name is parsed, if we encounter any other
-                 * word then fail it. Invalid Syntax.
-                 * example : snapshot info <snapname> word
-                 */
-                if ((cmdi + 1) != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                cmd = GF_SNAP_INFO_TYPE_SNAP;
-                ret = 0;
-                goto out;
-                /* No need to continue the parsing once we
-                 * get the snapname
-                 */
+        if ((cmdi + 1) != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        /* If 3rd word is "volume", then check if next word
-         * is present. As, "snapshot info volume" is an
-         * invalid command.
+        cmd = GF_SNAP_INFO_TYPE_SNAP;
+        ret = 0;
+        goto out;
+        /* No need to continue the parsing once we
+         * get the snapname
          */
-        if ((cmdi + 1) == wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[wordcount - 1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                        "volume name %s", words[wordcount - 1]);
-                goto out;
-        }
-        cmd = GF_SNAP_INFO_TYPE_VOL;
+    /* If 3rd word is "volume", then check if next word
+     * is present. As, "snapshot info volume" is an
+     * invalid command.
+     */
+    if ((cmdi + 1) == wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", (char *)words[wordcount - 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save "
+               "volume name %s",
+               words[wordcount - 1]);
+        goto out;
+    }
+    cmd = GF_SNAP_INFO_TYPE_VOL;
 out:
-        if (ret == 0) {
-                ret = dict_set_int32 (dict, "sub-cmd", cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "type of snapshot info");
-                }
+    if (ret == 0) {
+        ret = dict_set_int32(dict, "sub-cmd", cmd);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "type of snapshot info");
         }
-        return ret;
+    }
+    return ret;
 }
 
-
-
 /* snapshot restore <snapname>
  * @arg-0, dict     : Request Dictionary to be sent to server side.
  * @arg-1, words    : Contains individual words of CLI command.
@@ -4533,42 +4636,43 @@ out:
  *                 0 on success
  */
 int
-cli_snap_restore_parse (dict_t *dict, const char **words, int wordcount,
-                        struct cli_state *state)
+cli_snap_restore_parse(dict_t *dict, const char **words, int wordcount,
+                       struct cli_state *state)
 {
+    int ret = -1;
+    const char *question = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
 
-        int             ret             =       -1;
-        const char      *question       =       NULL;
-        gf_answer_t     answer          =       GF_ANSWER_NO;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount != 3) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        question = "Restore operation will replace the "
-                   "original volume with the snapshotted volume. "
-                   "Do you still want to continue?";
+    if (wordcount != 3) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 1;
-                gf_log ("cli", GF_LOG_ERROR, "User cancelled a snapshot "
-                        "restore operation for snap %s", (char *)words[2]);
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
+
+    question =
+        "Restore operation will replace the "
+        "original volume with the snapshotted volume. "
+        "Do you still want to continue?";
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 1;
+        gf_log("cli", GF_LOG_ERROR,
+               "User cancelled a snapshot "
+               "restore operation for snap %s",
+               (char *)words[2]);
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot activate <snapname> [force]
@@ -4580,43 +4684,41 @@ out:
  *                 0 on success
  */
 int
-cli_snap_activate_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_activate_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int flags = 0;
 
-        int ret = -1;
-        int flags = 0;
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if ((wordcount < 3) || (wordcount > 4)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if ((wordcount < 3) || (wordcount > 4)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
 
-        if (wordcount == 4) {
-                if (!strcmp("force", (char *)words[3])) {
-                        flags = GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid option");
-                        ret = -1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save force option");
-                goto out;
-        }
+    if (wordcount == 4) {
+        if (!strcmp("force", (char *)words[3])) {
+            flags = GF_CLI_FLAG_OP_FORCE;
+        } else {
+            gf_log("cli", GF_LOG_ERROR, "Invalid option");
+            ret = -1;
+            goto out;
+        }
+    }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save force option");
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot deactivate <snapname>
@@ -4629,42 +4731,41 @@ out:
  *                 1 if user cancelled the request
  */
 int
-cli_snap_deactivate_parse (dict_t *dict, const char **words, int wordcount,
-                        struct cli_state *state)
+cli_snap_deactivate_parse(dict_t *dict, const char **words, int wordcount,
+                          struct cli_state *state)
 {
+    int ret = -1;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question =
+        "Deactivating snap will make its "
+        "data inaccessible. Do you want to "
+        "continue?";
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if ((wordcount != 3)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        int             ret             = -1;
-        gf_answer_t     answer          = GF_ANSWER_NO;
-        const char     *question        = "Deactivating snap will make its "
-                                          "data inaccessible. Do you want to "
-                                          "continue?";
-
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if ((wordcount != 3)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
-
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 1;
-                gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot deactivate operation");
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 1;
+        gf_log("cli", GF_LOG_DEBUG,
+               "User cancelled "
+               "snapshot deactivate operation");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot delete (all | snapname | volume <volname>)
@@ -4677,78 +4778,84 @@ out:
  *                 1 if user cancel the operation
  */
 int
-cli_snap_delete_parse (dict_t *dict, const char **words, int wordcount,
-                       struct cli_state *state) {
-
-        int             ret             =       -1;
-        const char      *question       =       NULL;
-        int32_t         cmd             =       -1;
-        unsigned int    cmdi            =       2;
-        gf_answer_t     answer          =       GF_ANSWER_NO;
+cli_snap_delete_parse(dict_t *dict, const char **words, int wordcount,
+                      struct cli_state *state)
+{
+    int ret = -1;
+    const char *question = NULL;
+    int32_t cmd = -1;
+    unsigned int cmdi = 2;
+    gf_answer_t answer = GF_ANSWER_NO;
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        if (wordcount > 4 || wordcount <= cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
-
-        question = "Deleting snap will erase all the information about "
-                   "the snap. Do you still want to continue?";
+    if (wordcount > 4 || wordcount <= cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (strcmp (words [cmdi], "all") == 0) {
-                ret = 0;
-                cmd = GF_SNAP_DELETE_TYPE_ALL;
-        } else if (strcmp (words [cmdi], "volume") == 0) {
-                if (++cmdi == wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+    question =
+        "Deleting snap will erase all the information about "
+        "the snap. Do you still want to continue?";
 
-                ret = dict_set_str (dict, "volname",
-                                    (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "volume name %s", words[wordcount - 1]);
-                        goto out;
-                }
-                cmd = GF_SNAP_DELETE_TYPE_VOL;
-        } else {
-                ret = dict_set_str (dict, "snapname", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to save "
-                                "snapname %s", words[2]);
-                        goto out;
-                }
-                cmd = GF_SNAP_DELETE_TYPE_SNAP;
+    if (strcmp(words[cmdi], "all") == 0) {
+        ret = 0;
+        cmd = GF_SNAP_DELETE_TYPE_ALL;
+    } else if (strcmp(words[cmdi], "volume") == 0) {
+        if (++cmdi == wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        if ((cmdi + 1) != wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+        ret = dict_set_str(dict, "volname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "volume name %s",
+                   words[wordcount - 1]);
+            goto out;
+        }
+        cmd = GF_SNAP_DELETE_TYPE_VOL;
+    } else {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to save "
+                   "snapname %s",
+                   words[2]);
+            goto out;
         }
+        cmd = GF_SNAP_DELETE_TYPE_SNAP;
+    }
 
-        if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 1;
-                        gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                                "snapshot delete operation for snap %s",
-                                (char *)words[2]);
-                        goto out;
-                }
-        }
+    if ((cmdi + 1) != wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "sub-cmd", cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                        "type of snapshot delete");
-        }
+    if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 1;
+            gf_log("cli", GF_LOG_DEBUG,
+                   "User cancelled "
+                   "snapshot delete operation for snap %s",
+                   (char *)words[2]);
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "sub-cmd", cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save "
+               "type of snapshot delete");
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot status [(snapname | volume <volname>)]
@@ -4760,132 +4867,138 @@ out:
  *                 0 on success
  */
 int
-cli_snap_status_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_status_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int32_t cmd = GF_SNAP_STATUS_TYPE_ALL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot status)*/
 
-        int             ret  =        -1;
-        int32_t         cmd  =       GF_SNAP_STATUS_TYPE_ALL;
-        unsigned int    cmdi =        2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot status)*/
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    if (wordcount > 4 || wordcount < cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (wordcount > 4 || wordcount < cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if (wordcount == cmdi) {
+        ret = 0;
+        goto out;
+    }
 
-        if (wordcount == cmdi) {
-                ret = 0;
-                goto out;
+    /* if 3rd word is not "volume", then it must be "snapname"
+     */
+    if (strcmp(words[cmdi], "volume") != 0) {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Count not save "
+                   "snap name %s",
+                   words[cmdi]);
+            goto out;
         }
 
-        /* if 3rd word is not "volume", then it must be "snapname"
-        */
-        if (strcmp (words[cmdi], "volume") != 0) {
-                ret = dict_set_str (dict, "snapname",
-                                   (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Count not save "
-                                "snap name %s", words[cmdi]);
-                        goto out;
-                }
-
-                if ((cmdi + 1) != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                ret = 0;
-                cmd = GF_SNAP_STATUS_TYPE_SNAP;
-                goto out;
+        if ((cmdi + 1) != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        /* If 3rd word is "volume", then check if next word is present.
-         * As, "snapshot info volume" is an invalid command
-         */
-        if ((cmdi + 1) == wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+        ret = 0;
+        cmd = GF_SNAP_STATUS_TYPE_SNAP;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words [wordcount - 1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Count not save "
-                        "volume name %s", words[wordcount - 1]);
-                goto out;
-        }
-        cmd = GF_SNAP_STATUS_TYPE_VOL;
+    /* If 3rd word is "volume", then check if next word is present.
+     * As, "snapshot info volume" is an invalid command
+     */
+    if ((cmdi + 1) == wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", (char *)words[wordcount - 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Count not save "
+               "volume name %s",
+               words[wordcount - 1]);
+        goto out;
+    }
+    cmd = GF_SNAP_STATUS_TYPE_VOL;
 
 out:
-        if (ret == 0) {
-                ret = dict_set_int32 (dict, "sub-cmd", cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save cmd "
-                                "of snapshot status");
-                }
+    if (ret == 0) {
+        ret = dict_set_int32(dict, "sub-cmd", cmd);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save cmd "
+                   "of snapshot status");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 /* return value:
  *      -1  in case of failure.
  *       0  in case of success.
  */
 int32_t
-cli_snap_config_limit_parse (const char **words, dict_t *dict,
-                             unsigned int wordcount, unsigned int index,
-                             char *key)
+cli_snap_config_limit_parse(const char **words, dict_t *dict,
+                            unsigned int wordcount, unsigned int index,
+                            char *key)
 {
-        int             ret             = -1;
-        int             limit           = 0;
-        char            *end_ptr        = NULL;
+    int ret = -1;
+    int limit = 0;
+    char *end_ptr = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-        GF_ASSERT (key);
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+    GF_ASSERT(key);
 
-        if (index >= wordcount) {
-                ret = -1;
-                cli_err ("Please provide a value for %s.", key);
-                gf_log ("cli", GF_LOG_ERROR, "Value not provided for %s", key);
-                goto out;
-        }
-
-        limit = strtol (words[index], &end_ptr, 10);
+    if (index >= wordcount) {
+        ret = -1;
+        cli_err("Please provide a value for %s.", key);
+        gf_log("cli", GF_LOG_ERROR, "Value not provided for %s", key);
+        goto out;
+    }
 
-        if (limit <= 0 || strcmp (end_ptr, "") != 0) {
-                ret = -1;
-                cli_err("Please enter an integer value "
-                        "greater than zero for %s", key);
-                goto out;
-        }
+    limit = strtol(words[index], &end_ptr, 10);
 
-        ret = dict_set_int32 (dict, key, limit);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set "
-                        "%s in dictionary", key);
-                goto out;
-        }
+    if (limit <= 0 || strcmp(end_ptr, "") != 0) {
+        ret = -1;
+        cli_err(
+            "Please enter an integer value "
+            "greater than zero for %s",
+            key);
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, key, limit);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not set "
+               "%s in dictionary",
+               key);
+        goto out;
+    }
 
-        ret = dict_set_dynstr_with_alloc (dict, "globalname", "All");
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set global key");
-                goto out;
-        }
-        ret = dict_set_int32 (dict, "hold_global_locks", _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set global locks");
-                goto out;
-        }
+    ret = dict_set_dynstr_with_alloc(dict, "globalname", "All");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not set global key");
+        goto out;
+    }
+    ret = dict_set_int32(dict, "hold_global_locks", _gf_true);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not set global locks");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /* function cli_snap_config_parse
@@ -4901,773 +5014,933 @@ out:
   NOTE : snap-max-soft-limit can only be set for system.
 */
 int32_t
-cli_snap_config_parse (const char **words, int wordcount, dict_t *dict,
-                       struct cli_state *state)
+cli_snap_config_parse(const char **words, int wordcount, dict_t *dict,
+                      struct cli_state *state)
 {
-        int                            ret                 = -1;
-        gf_answer_t                    answer              = GF_ANSWER_NO;
-        gf_boolean_t                   vol_presence        = _gf_false;
-        struct snap_config_opt_vals_  *conf_vals           = NULL;
-        int8_t                         hard_limit          = 0;
-        int8_t                         soft_limit          = 0;
-        int8_t                         config_type         = -1;
-        const char                    *question            = NULL;
-        unsigned int                   cmdi                = 2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot config)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-        GF_ASSERT (state);
-
-        if ((wordcount < 2) || (wordcount > 7)) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Invalid wordcount(%d)", wordcount);
-                goto out;
-        }
+    int ret = -1;
+    gf_answer_t answer = GF_ANSWER_NO;
+    gf_boolean_t vol_presence = _gf_false;
+    struct snap_config_opt_vals_ *conf_vals = NULL;
+    int8_t hard_limit = 0;
+    int8_t soft_limit = 0;
+    int8_t config_type = -1;
+    const char *question = NULL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot config)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+    GF_ASSERT(state);
+
+    if ((wordcount < 2) || (wordcount > 7)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid wordcount(%d)", wordcount);
+        goto out;
+    }
 
-        if (wordcount == 2) {
-                config_type = GF_SNAP_CONFIG_DISPLAY;
-                ret = 0;
-                goto set;
+    if (wordcount == 2) {
+        config_type = GF_SNAP_CONFIG_DISPLAY;
+        ret = 0;
+        goto set;
+    }
+
+    /* auto-delete cannot be a volume name */
+    /* Check whether the 3rd word is volname */
+    if (strcmp(words[cmdi], "snap-max-hard-limit") != 0 &&
+        strcmp(words[cmdi], "snap-max-soft-limit") != 0 &&
+        strcmp(words[cmdi], "auto-delete") != 0 &&
+        strcmp(words[cmdi], "activate-on-create") != 0) {
+        ret = dict_set_str(dict, "volname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to set volname");
+            goto out;
         }
+        cmdi++;
+        vol_presence = _gf_true;
 
-        /* auto-delete cannot be a volume name */
-        /* Check whether the 3rd word is volname */
-        if (strcmp (words[cmdi], "snap-max-hard-limit") != 0
-             && strcmp (words[cmdi], "snap-max-soft-limit") != 0
-             && strcmp (words[cmdi], "auto-delete") != 0
-             && strcmp (words[cmdi], "activate-on-create") != 0) {
-                ret = dict_set_str (dict, "volname", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set volname");
-                        goto out;
-                }
-                cmdi++;
-                vol_presence = _gf_true;
-
-                if (cmdi == wordcount) {
-                        config_type = GF_SNAP_CONFIG_DISPLAY;
-                        ret = 0;
-                        goto set;
-                }
+        if (cmdi == wordcount) {
+            config_type = GF_SNAP_CONFIG_DISPLAY;
+            ret = 0;
+            goto set;
         }
+    }
 
-        config_type = GF_SNAP_CONFIG_TYPE_SET;
-
-        if (strcmp (words[cmdi], "snap-max-hard-limit") == 0) {
-                ret = cli_snap_config_limit_parse (words, dict, wordcount,
-                                                ++cmdi, "snap-max-hard-limit");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse snap "
-                                "config hard limit");
-                        goto out;
-                }
-                hard_limit = 1;
+    config_type = GF_SNAP_CONFIG_TYPE_SET;
 
-                if (++cmdi == wordcount) {
-                        ret = 0;
-                        goto set;
-                }
+    if (strcmp(words[cmdi], "snap-max-hard-limit") == 0) {
+        ret = cli_snap_config_limit_parse(words, dict, wordcount, ++cmdi,
+                                          "snap-max-hard-limit");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to parse snap "
+                   "config hard limit");
+            goto out;
         }
+        hard_limit = 1;
 
-        if (strcmp (words[cmdi], "snap-max-soft-limit") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("Soft limit cannot be set to individual "
-                                  "volumes.");
-                        gf_log ("cli", GF_LOG_ERROR, "Soft limit cannot be "
-                                "set to volumes");
-                        goto out;
-                }
-
-                ret = cli_snap_config_limit_parse (words, dict, wordcount,
-                                                ++cmdi, "snap-max-soft-limit");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse snap "
-                                "config soft limit");
-                        goto out;
-                }
-
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-                soft_limit = 1;
+        if (++cmdi == wordcount) {
+            ret = 0;
+            goto set;
         }
+    }
 
-        if (hard_limit || soft_limit)
-                goto set;
+    if (strcmp(words[cmdi], "snap-max-soft-limit") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "Soft limit cannot be set to individual "
+                "volumes.");
+            gf_log("cli", GF_LOG_ERROR,
+                   "Soft limit cannot be "
+                   "set to volumes");
+            goto out;
+        }
 
-        if (strcmp(words[cmdi], "auto-delete") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("As of now, auto-delete option cannot be set "
-                                "to volumes");
-                        gf_log ("cli", GF_LOG_ERROR, "auto-delete option "
-                                "cannot be set to volumes");
-                        goto out;
-                }
+        ret = cli_snap_config_limit_parse(words, dict, wordcount, ++cmdi,
+                                          "snap-max-soft-limit");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to parse snap "
+                   "config soft limit");
+            goto out;
+        }
 
-                if (++cmdi >= wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+        soft_limit = 1;
+    }
 
-                ret = dict_set_str (dict, "auto-delete", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                "value of auto-delete in request "
-                                "dictionary");
-                        goto out;
-                }
+    if (hard_limit || soft_limit)
+        goto set;
 
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-        } else if (strcmp(words[cmdi], "activate-on-create") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("As of now, activate-on-create option "
-                                 "cannot be set to volumes");
-                        gf_log ("cli", GF_LOG_ERROR, "activate-on-create "
-                                "option cannot be set to volumes");
-                        goto out;
-                }
+    if (strcmp(words[cmdi], "auto-delete") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "As of now, auto-delete option cannot be set "
+                "to volumes");
+            gf_log("cli", GF_LOG_ERROR,
+                   "auto-delete option "
+                   "cannot be set to volumes");
+            goto out;
+        }
 
-                if (++cmdi >= wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+        if (++cmdi >= wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
 
-                ret = dict_set_str (dict, "snap-activate-on-create",
-                                    (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set value "
-                                "of activate-on-create in request dictionary");
-                        goto out;
-                }
+        ret = dict_set_str(dict, "auto-delete", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set "
+                   "value of auto-delete in request "
+                   "dictionary");
+            goto out;
+        }
+
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+    } else if (strcmp(words[cmdi], "activate-on-create") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "As of now, activate-on-create option "
+                "cannot be set to volumes");
+            gf_log("cli", GF_LOG_ERROR,
+                   "activate-on-create "
+                   "option cannot be set to volumes");
+            goto out;
+        }
+
+        if (++cmdi >= wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+
+        ret = dict_set_str(dict, "snap-activate-on-create",
+                           (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set value "
+                   "of activate-on-create in request dictionary");
+            goto out;
+        }
 
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-        } else {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
+    } else {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = 0; /* Success */
+    ret = 0; /* Success */
 
 set:
-        ret = dict_set_int32 (dict, "config-command", config_type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to set "
-                        "config-command");
-                goto out;
-        }
+    ret = dict_set_int32(dict, "config-command", config_type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to set "
+               "config-command");
+        goto out;
+    }
 
-        if (config_type == GF_SNAP_CONFIG_TYPE_SET &&
-           (hard_limit || soft_limit)) {
-                conf_vals = snap_confopt_vals;
-                if (hard_limit && soft_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_BOTH].question;
-                } else if (soft_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_SOFT].question;
-                } else if (hard_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_HARD].question;
-                }
+    if (config_type == GF_SNAP_CONFIG_TYPE_SET && (hard_limit || soft_limit)) {
+        conf_vals = snap_confopt_vals;
+        if (hard_limit && soft_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_BOTH].question;
+        } else if (soft_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_SOFT].question;
+        } else if (hard_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_HARD].question;
+        }
 
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 1;
-                        gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot config operation");
-                }
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 1;
+            gf_log("cli", GF_LOG_DEBUG,
+                   "User cancelled "
+                   "snapshot config operation");
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-validate_op_name (const char *op, const char *opname, char **opwords) {
-        int     ret     =       -1;
-        int     i       =       0;
+validate_op_name(const char *op, const char *opname, char **opwords)
+{
+    int ret = -1;
+    int i = 0;
 
-        GF_ASSERT (opname);
-        GF_ASSERT (opwords);
+    GF_ASSERT(opname);
+    GF_ASSERT(opwords);
 
-        for (i = 0 ; opwords[i] != NULL; i++) {
-                if (strcmp (opwords[i], opname) == 0) {
-                        cli_out ("\"%s\" cannot be a %s", opname, op);
-                        goto out;
-                }
+    for (i = 0; opwords[i] != NULL; i++) {
+        if (strcmp(opwords[i], opname) == 0) {
+            cli_out("\"%s\" cannot be a %s", opname, op);
+            goto out;
         }
-        ret = 0;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_snapshot_parse (const char **words, int wordcount, dict_t **options,
-                        struct cli_state *state)
+cli_cmd_snapshot_parse(const char **words, int wordcount, dict_t **options,
+                       struct cli_state *state)
 {
-        int32_t            ret        = -1;
-        dict_t             *dict      = NULL;
-        gf1_cli_snapshot   type       = GF_SNAP_OPTION_TYPE_NONE;
-        char               *w         = NULL;
-        char               *opwords[] = {"create", "delete", "restore",
-                                        "activate", "deactivate", "list",
-                                        "status", "config", "info", "clone",
+    int32_t ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_snapshot type = GF_SNAP_OPTION_TYPE_NONE;
+    char *w = NULL;
+    static char *opwords[] = {"create",     "delete", "restore", "activate",
+                              "deactivate", "list",   "status",  "config",
+                              "info",       "clone",  NULL};
+    static char *invalid_snapnames[] = {"description", "force", "volume", "all",
                                         NULL};
-        char               *invalid_snapnames[] = {"description", "force",
-                                                  "volume", "all", NULL};
-        char               *invalid_volnames[]  = {"volume", "type",
-                                                   "subvolumes", "option",
-                                                   "end-volume", "all",
-                                                   "volume_not_in_ring",
-                                                   "description", "force",
-                                                   "snap-max-hard-limit",
-                                                   "snap-max-soft-limit",
-                                                   "auto-delete",
-                                                   "activate-on-create", NULL};
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-        GF_ASSERT (state);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        /* Lowest wordcount possible */
-        if (wordcount < 2) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Invalid command: Not enough arguments");
-                goto out;
-        }
-
-        w = str_getunamb (words[1], opwords);
-        if (!w) {
-                /* Checks if the operation is a valid operation */
-                gf_log ("", GF_LOG_ERROR, "Opword Mismatch");
-                goto out;
-        }
+    static char *invalid_volnames[] = {"volume",
+                                       "type",
+                                       "subvolumes",
+                                       "option",
+                                       "end-volume",
+                                       "all",
+                                       "volume_not_in_ring",
+                                       "description",
+                                       "force",
+                                       "snap-max-hard-limit",
+                                       "snap-max-soft-limit",
+                                       "auto-delete",
+                                       "activate-on-create",
+                                       NULL};
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+    GF_ASSERT(state);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (!strcmp (w, "create")) {
-                type = GF_SNAP_OPTION_TYPE_CREATE;
-        } else if (!strcmp (w, "list")) {
-                type = GF_SNAP_OPTION_TYPE_LIST;
-        } else if (!strcmp (w, "info")) {
-                type = GF_SNAP_OPTION_TYPE_INFO;
-        } else if (!strcmp (w, "delete")) {
-                type = GF_SNAP_OPTION_TYPE_DELETE;
-        } else if (!strcmp (w, "config")) {
-                type = GF_SNAP_OPTION_TYPE_CONFIG;
-        } else if (!strcmp (w, "restore")) {
-                type = GF_SNAP_OPTION_TYPE_RESTORE;
-        } else if (!strcmp (w, "status")) {
-                type = GF_SNAP_OPTION_TYPE_STATUS;
-        } else if (!strcmp (w, "activate")) {
-                type = GF_SNAP_OPTION_TYPE_ACTIVATE;
-        } else if (!strcmp (w, "deactivate")) {
-                type = GF_SNAP_OPTION_TYPE_DEACTIVATE;
-        } else if (!strcmp(w, "clone")) {
-                type = GF_SNAP_OPTION_TYPE_CLONE;
-        }
-
-        if (type != GF_SNAP_OPTION_TYPE_CONFIG &&
-            type != GF_SNAP_OPTION_TYPE_STATUS) {
-                ret = dict_set_int32 (dict, "hold_snap_locks", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to set hold-snap-locks value "
-                                "as _gf_true");
-                        goto out;
-                }
-        }
+    /* Lowest wordcount possible */
+    if (wordcount < 2) {
+        gf_log("", GF_LOG_ERROR, "Invalid command: Not enough arguments");
+        goto out;
+    }
 
-        /* Following commands does not require volume locks  */
-        if (type == GF_SNAP_OPTION_TYPE_STATUS ||
-            type == GF_SNAP_OPTION_TYPE_ACTIVATE ||
-            type == GF_SNAP_OPTION_TYPE_DEACTIVATE) {
-                ret = dict_set_int32 (dict, "hold_vol_locks", _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Setting volume lock "
-                                "flag failed");
-                        goto out;
-                }
+    w = str_getunamb(words[1], opwords);
+    if (!w) {
+        /* Checks if the operation is a valid operation */
+        gf_log("", GF_LOG_ERROR, "Opword Mismatch");
+        goto out;
+    }
+
+    if (!strcmp(w, "create")) {
+        type = GF_SNAP_OPTION_TYPE_CREATE;
+    } else if (!strcmp(w, "list")) {
+        type = GF_SNAP_OPTION_TYPE_LIST;
+    } else if (!strcmp(w, "info")) {
+        type = GF_SNAP_OPTION_TYPE_INFO;
+    } else if (!strcmp(w, "delete")) {
+        type = GF_SNAP_OPTION_TYPE_DELETE;
+    } else if (!strcmp(w, "config")) {
+        type = GF_SNAP_OPTION_TYPE_CONFIG;
+    } else if (!strcmp(w, "restore")) {
+        type = GF_SNAP_OPTION_TYPE_RESTORE;
+    } else if (!strcmp(w, "status")) {
+        type = GF_SNAP_OPTION_TYPE_STATUS;
+    } else if (!strcmp(w, "activate")) {
+        type = GF_SNAP_OPTION_TYPE_ACTIVATE;
+    } else if (!strcmp(w, "deactivate")) {
+        type = GF_SNAP_OPTION_TYPE_DEACTIVATE;
+    } else if (!strcmp(w, "clone")) {
+        type = GF_SNAP_OPTION_TYPE_CLONE;
+    }
+
+    if (type != GF_SNAP_OPTION_TYPE_CONFIG &&
+        type != GF_SNAP_OPTION_TYPE_STATUS) {
+        ret = dict_set_int32(dict, "hold_snap_locks", _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to set hold-snap-locks value "
+                   "as _gf_true");
+            goto out;
+        }
+    }
+
+    /* Following commands does not require volume locks  */
+    if (type == GF_SNAP_OPTION_TYPE_STATUS ||
+        type == GF_SNAP_OPTION_TYPE_ACTIVATE ||
+        type == GF_SNAP_OPTION_TYPE_DEACTIVATE) {
+        ret = dict_set_int32(dict, "hold_vol_locks", _gf_false);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Setting volume lock "
+                   "flag failed");
+            goto out;
         }
+    }
 
-        /* Check which op is intended */
-        switch (type) {
+    /* Check which op is intended */
+    switch (type) {
         case GF_SNAP_OPTION_TYPE_CREATE:
-                /* Syntax :
-                 * gluster snapshot create <snapname> <vol-name(s)>
-                 *                         [no-timestamp]
-                 *                         [description <description>]
-                 *                         [force]
-                 */
-                /* In cases where the snapname is not given then
-                 * parsing fails & snapname cannot be "description",
-                 * "force" and "volume", that check is made here
-                 */
-                if (wordcount == 2){
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+            /* Syntax :
+             * gluster snapshot create <snapname> <vol-name(s)>
+             *                         [no-timestamp]
+             *                         [description <description>]
+             *                         [force]
+             */
+            /* In cases where the snapname is not given then
+             * parsing fails & snapname cannot be "description",
+             * "force" and "volume", that check is made here
+             */
+            if (wordcount == 2) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+                goto out;
+            }
 
-                ret = validate_op_name ("snapname", words[2],
-                                        invalid_snapnames);
-                if (ret) {
-                        goto out;
-                }
+            ret = validate_op_name("snapname", words[2], invalid_snapnames);
+            if (ret) {
+                goto out;
+            }
 
-                ret = cli_snap_create_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "create command parsing failed.");
-                        goto out;
-                }
-                break;
+            ret = cli_snap_create_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "create command parsing failed.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_CLONE:
-                /* Syntax :
-                 * gluster snapshot clone <clonename> <snapname>
-                 */
-                /* In cases where the clonename is not given then
-                 * parsing fails & snapname cannot be "description",
-                 * "force" and "volume", that check is made here
-                 */
-                if (wordcount == 2) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                ret = validate_op_name ("clonename", words[2],
-                                        invalid_volnames);
-                if (ret) {
-                        goto out;
-                }
+            /* Syntax :
+             * gluster snapshot clone <clonename> <snapname>
+             */
+            /* In cases where the clonename is not given then
+             * parsing fails & snapname cannot be "description",
+             * "force" and "volume", that check is made here
+             */
+            if (wordcount == 2) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+                goto out;
+            }
 
-                ret = cli_snap_clone_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "clone command parsing failed.");
-                        goto out;
-                }
-                break;
+            ret = validate_op_name("clonename", words[2], invalid_volnames);
+            if (ret) {
+                goto out;
+            }
 
+            ret = cli_snap_clone_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "clone command parsing failed.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_INFO:
-                /* Syntax :
-                 * gluster snapshot info [(snapname] | [vol <volname>)]
-                 */
-                ret = cli_snap_info_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "snapshot info command");
-                        goto out;
-                }
-                break;
+            /* Syntax :
+             * gluster snapshot info [(snapname] | [vol <volname>)]
+             */
+            ret = cli_snap_info_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot info command");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_LIST:
-                /* Syntax :
-                 * gluster snaphsot list [volname]
-                 */
+            /* Syntax :
+             * gluster snaphsot list [volname]
+             */
 
-                ret = cli_snap_list_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "snapshot list command");
-                        goto out;
-                }
-                break;
+            ret = cli_snap_list_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot list command");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_DELETE:
-                /* Syntax :
-                 * snapshot delete (all | snapname | volume <volname>)
-                 */
-                ret = cli_snap_delete_parse (dict, words, wordcount, state);
-                if (ret) {
-                        /* A positive ret value means user cancelled
-                        * the command */
-                        if (ret < 0) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "snapshot delete command");
-                        }
-                        goto out;
+            /* Syntax :
+             * snapshot delete (all | snapname | volume <volname>)
+             */
+            ret = cli_snap_delete_parse(dict, words, wordcount, state);
+            if (ret) {
+                /* A positive ret value means user cancelled
+                 * the command */
+                if (ret < 0) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Failed to parse "
+                           "snapshot delete command");
                 }
-                break;
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_CONFIG:
-                /* snapshot config [volname]  [snap-max-hard-limit <count>]
-                 *                            [snap-max-soft-limit <percent>] */
-                ret = cli_snap_config_parse (words, wordcount, dict, state);
-                if (ret) {
-                        if (ret < 0)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "config command parsing failed.");
-                        goto out;
-                }
-
-                ret = dict_set_int32 (dict, "type", GF_SNAP_OPTION_TYPE_CONFIG);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to set "
-                                "config type");
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        case GF_SNAP_OPTION_TYPE_STATUS:
-                {
-                        /* Syntax :
-                         * gluster snapshot status [(snapname |
-                         *                         volume <volname>)]
-                         */
-                        ret = cli_snap_status_parse (dict, words, wordcount);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "snapshot status command");
-                                goto out;
-                        }
-                        break;
-                }
+            /* snapshot config [volname]  [snap-max-hard-limit <count>]
+             *                            [snap-max-soft-limit <percent>] */
+            ret = cli_snap_config_parse(words, wordcount, dict, state);
+            if (ret) {
+                if (ret < 0)
+                    gf_log("cli", GF_LOG_ERROR,
+                           "config command parsing failed.");
+                goto out;
+            }
 
-        case GF_SNAP_OPTION_TYPE_RESTORE:
-                /* Syntax:
-                 * snapshot restore <snapname>
-                 */
-                ret = cli_snap_restore_parse (dict, words, wordcount, state);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "restore command");
-                        goto out;
-                }
-                break;
-
-                case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                        /* Syntax:
-                        * snapshot activate <snapname> [force]
-                        */
-                        ret = cli_snap_activate_parse (dict, words, wordcount);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "start command");
-                                goto out;
-                        }
-                        break;
-                case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                        /* Syntax:
-                        * snapshot deactivate <snapname>
-                        */
-                        ret = cli_snap_deactivate_parse (dict, words, wordcount,
-                                state);
-                        if (ret) {
-                                /* A positive ret value means user cancelled
-                                 * the command */
-                                if (ret < 0) {
-                                        gf_log ("cli", GF_LOG_ERROR,
-                                                "Failed to parse deactivate "
-                                                "command");
-                                }
-                                goto out;
-                        }
-                        break;
+            ret = dict_set_int32(dict, "type", GF_SNAP_OPTION_TYPE_CONFIG);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Unable to set "
+                       "config type");
+                ret = -1;
+                goto out;
+            }
+            break;
 
-        default:
-                gf_log ("", GF_LOG_ERROR, "Opword Mismatch");
+        case GF_SNAP_OPTION_TYPE_STATUS: {
+            /* Syntax :
+             * gluster snapshot status [(snapname |
+             *                         volume <volname>)]
+             */
+            ret = cli_snap_status_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot status command");
                 goto out;
+            }
+            break;
         }
 
-        ret = dict_set_int32 (dict, "type", type);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Failed to set type.");
+        case GF_SNAP_OPTION_TYPE_RESTORE:
+            /* Syntax:
+             * snapshot restore <snapname>
+             */
+            ret = cli_snap_restore_parse(dict, words, wordcount, state);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "restore command");
+                goto out;
+            }
+            break;
+
+        case GF_SNAP_OPTION_TYPE_ACTIVATE:
+            /* Syntax:
+             * snapshot activate <snapname> [force]
+             */
+            ret = cli_snap_activate_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "start command");
+                goto out;
+            }
+            break;
+        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
+            /* Syntax:
+             * snapshot deactivate <snapname>
+             */
+            ret = cli_snap_deactivate_parse(dict, words, wordcount, state);
+            if (ret) {
+                /* A positive ret value means user cancelled
+                 * the command */
+                if (ret < 0) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Failed to parse deactivate "
+                           "command");
+                }
                 goto out;
-        }
-        /* If you got so far, input is valid */
-        ret = 0;
+            }
+            break;
+
+        default:
+            ret = -1;
+            gf_log("", GF_LOG_ERROR, "Opword Mismatch");
+            goto out;
+    }
+
+    ret = dict_set_int32(dict, "type", type);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Failed to set type.");
+        goto out;
+    }
+    /* If you got so far, input is valid */
+    ret = 0;
 out:
-        if (ret) {
-                if (dict)
-                        dict_unref (dict);
-        } else
-                *options = dict;
+    if (ret) {
+        if (dict)
+            dict_unref(dict);
+    } else
+        *options = dict;
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_validate_volume (char *volname)
+cli_cmd_validate_volume(char *volname)
 {
-        int       i        =  0;
-        int       ret      = -1;
+    int i = 0;
+    int ret = -1;
+    int volname_len;
 
+    if (volname[0] == '-')
+        return ret;
 
-        if (volname[0] == '-')
-                return ret;
+    if (!strcmp(volname, "all")) {
+        cli_err("\"all\" cannot be the name of a volume.");
+        return ret;
+    }
 
-        if (!strcmp (volname, "all")) {
-                cli_err ("\"all\" cannot be the name of a volume.");
-                return ret;
-        }
+    if (strchr(volname, '/')) {
+        cli_err("Volume name should not contain \"/\" character.");
+        return ret;
+    }
 
-        if (strchr (volname, '/')) {
-                cli_err ("Volume name should not contain \"/\" character.");
-                return ret;
-        }
+    volname_len = strlen(volname);
+    if (volname_len > GD_VOLUME_NAME_MAX) {
+        cli_err("Volname can not exceed %d characters.", GD_VOLUME_NAME_MAX);
+        return ret;
+    }
 
-        if (strlen (volname) > GD_VOLUME_NAME_MAX) {
-                cli_err ("Volname can not exceed %d characters.",
-                        GD_VOLUME_NAME_MAX);
-                return ret;
+    for (i = 0; i < volname_len; i++)
+        if (!isalnum(volname[i]) && (volname[i] != '_') &&
+            (volname[i] != '-')) {
+            cli_err(
+                "Volume name should not contain \"%c\""
+                " character.\nVolume names can only"
+                "contain alphanumeric, '-' and '_' "
+                "characters.",
+                volname[i]);
+            return ret;
         }
 
-        for (i = 0; i < strlen (volname); i++)
-                if (!isalnum (volname[i]) && (volname[i] != '_') &&
-                    (volname[i] != '-')) {
-                        cli_err ("Volume name should not contain \"%c\""
-                                 " character.\nVolume names can only"
-                                 "contain alphanumeric, '-' and '_' "
-                                 "characters.", volname[i]);
-                        return ret;
-                }
-
-        ret = 0;
+    ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_bitrot_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_bitrot_parse(const char **words, int wordcount, dict_t **options)
 {
-        int32_t            ret                    = -1;
-        char               *w                     = NULL;
-        char               *volname               = NULL;
-        char               *opwords[]             = {"enable", "disable",
-                                                     "scrub-throttle",
-                                                     "scrub-frequency", "scrub",
-                                                     "signing-time", NULL};
-        char               *scrub_throt_values[]  = {"lazy", "normal",
-                                                     "aggressive", NULL};
-        char               *scrub_freq_values[]   = {"hourly",
-                                                     "daily", "weekly",
-                                                     "biweekly", "monthly",
-                                                     "minute",  NULL};
-        char               *scrub_values[]        = {"pause", "resume",
-                                                     "status", "ondemand",
-                                                     NULL};
-        dict_t             *dict                  = NULL;
-        gf_bitrot_type     type                   = GF_BITROT_OPTION_TYPE_NONE;
-        int32_t            expiry_time            = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-
-        /* Hack to print out bitrot help properly */
-        if ((wordcount == 3) && !(strcmp (words[2], "help"))) {
-                ret = 1;
-                return ret;
-        }
-
-        if (wordcount < 4 || wordcount > 5) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid syntax");
-                goto out;
-        }
+    int32_t ret = -1;
+    char *w = NULL;
+    char *volname = NULL;
+    static char *opwords[] = {"enable",          "disable", "scrub-throttle",
+                              "scrub-frequency", "scrub",   "signing-time",
+                              "signer-threads",  NULL};
+    static char *scrub_throt_values[] = {"lazy", "normal", "aggressive", NULL};
+    static char *scrub_freq_values[] = {
+        "hourly", "daily", "weekly", "biweekly", "monthly", "minute", NULL};
+    static char *scrub_values[] = {"pause", "resume", "status", "ondemand",
+                                   NULL};
+    dict_t *dict = NULL;
+    gf_bitrot_type type = GF_BITROT_OPTION_TYPE_NONE;
+    int32_t expiry_time = 0;
+    int32_t signer_th_count = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    /* Hack to print out bitrot help properly */
+    if ((wordcount == 3) && !(strcmp(words[2], "help"))) {
+        ret = 1;
+        return ret;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    if (wordcount < 4 || wordcount > 5) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid syntax");
+        goto out;
+    }
 
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        ret = cli_cmd_validate_volume (volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to validate volume name");
-                goto out;
-        }
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                cli_out ("Failed to set volume name in dictionary ");
-                goto out;
+    ret = cli_cmd_validate_volume(volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to validate volume name");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        cli_out("Failed to set volume name in dictionary ");
+        goto out;
+    }
+
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        cli_out("Invalid bit rot option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(w, "enable") == 0) {
+        if (wordcount == 4) {
+            type = GF_BITROT_OPTION_TYPE_ENABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                cli_out ("Invalid bit rot option : %s", words[3]);
+    if (strcmp(w, "disable") == 0) {
+        if (wordcount == 4) {
+            type = GF_BITROT_OPTION_TYPE_DISABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    if (!strcmp(w, "scrub-throttle")) {
+        if (!words[4]) {
+            cli_err(
+                "Missing scrub-throttle value for bitrot "
+                "option");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_throt_values);
+            if (!w) {
+                cli_err(
+                    "Invalid scrub-throttle option for "
+                    "bitrot");
                 ret = -1;
                 goto out;
-        }
-
-        if (strcmp (w, "enable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_BITROT_OPTION_TYPE_ENABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
+            } else {
+                type = GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE;
+                ret = dict_set_str(dict, "scrub-throttle-value",
+                                   (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set scrub-throttle "
+                        "value in the dict");
+                    goto out;
                 }
+                goto set_type;
+            }
         }
+    }
 
-        if (strcmp (w, "disable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_BITROT_OPTION_TYPE_DISABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
+    if (!strcmp(words[3], "scrub-frequency")) {
+        if (!words[4]) {
+            cli_err("Missing scrub-frequency value");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_freq_values);
+            if (!w) {
+                cli_err("Invalid frequency option for bitrot");
+                ret = -1;
+                goto out;
+            } else {
+                type = GF_BITROT_OPTION_TYPE_SCRUB_FREQ;
+                ret = dict_set_str(dict, "scrub-frequency-value",
+                                   (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set dict for "
+                        "bitrot");
+                    goto out;
                 }
+                goto set_type;
+            }
         }
+    }
 
-        if (!strcmp (w, "scrub-throttle")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub-throttle value for bitrot "
-                                 "option");
-                        ret = -1;
-                        goto out;
+    if (!strcmp(words[3], "scrub")) {
+        if (!words[4]) {
+            cli_err("Missing scrub value for bitrot option");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_values);
+            if (!w) {
+                cli_err("Invalid scrub option for bitrot");
+                ret = -1;
+                goto out;
+            } else {
+                if (strcmp(words[4], "status") == 0) {
+                    type = GF_BITROT_CMD_SCRUB_STATUS;
+                } else if (strcmp(words[4], "ondemand") == 0) {
+                    type = GF_BITROT_CMD_SCRUB_ONDEMAND;
                 } else {
-                        w = str_getunamb (words[4], scrub_throt_values);
-                        if (!w) {
-                                cli_err ("Invalid scrub-throttle option for "
-                                         "bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                type = GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE;
-                                ret =  dict_set_str (dict,
-                                                     "scrub-throttle-value",
-                                                     (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set scrub-throttle "
-                                                 "value in the dict");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
+                    type = GF_BITROT_OPTION_TYPE_SCRUB;
                 }
-        }
-
-        if (!strcmp (words[3], "scrub-frequency")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub-frequency value");
-                        ret = -1;
-                        goto out;
-                } else {
-                        w = str_getunamb (words[4], scrub_freq_values);
-                        if (!w) {
-                                cli_err ("Invalid frequency option for bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                type = GF_BITROT_OPTION_TYPE_SCRUB_FREQ;
-                                ret = dict_set_str (dict,
-                                                    "scrub-frequency-value",
-                                                    (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set dict for "
-                                                 "bitrot");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
+                ret = dict_set_str(dict, "scrub-value", (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set dict for "
+                        "bitrot");
+                    goto out;
                 }
+                goto set_type;
+            }
         }
+    }
 
-        if (!strcmp (words[3], "scrub")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub value for bitrot option");
-                        ret = -1;
-                        goto out;
-                } else {
-                        w = str_getunamb (words[4], scrub_values);
-                        if (!w) {
-                                cli_err ("Invalid scrub option for bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                if (strcmp (words[4], "status") == 0) {
-                                        type = GF_BITROT_CMD_SCRUB_STATUS;
-                                } else if (strcmp (words[4], "ondemand") == 0) {
-                                        type = GF_BITROT_CMD_SCRUB_ONDEMAND;
-                                } else {
-                                        type = GF_BITROT_OPTION_TYPE_SCRUB;
-                                }
-                                ret =  dict_set_str (dict, "scrub-value",
-                                                    (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set dict for "
-                                                 "bitrot");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
-                }
-        }
+    if (!strcmp(words[3], "signing-time")) {
+        if (!words[4]) {
+            cli_err(
+                "Missing signing-time value for bitrot "
+                "option");
+            ret = -1;
+            goto out;
+        } else {
+            type = GF_BITROT_OPTION_TYPE_EXPIRY_TIME;
 
-        if (!strcmp (words[3], "signing-time")) {
-                if (!words[4]) {
-                        cli_err ("Missing signing-time value for bitrot "
-                                 "option");
-                        ret = -1;
-                        goto out;
-                } else {
-                        type = GF_BITROT_OPTION_TYPE_EXPIRY_TIME;
-
-                        expiry_time = strtol (words[4], NULL, 0);
-                        if (expiry_time < 1) {
-                                cli_err ("Expiry time  value should not be less"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
+            expiry_time = strtol(words[4], NULL, 0);
+            if (expiry_time < 1) {
+                cli_err(
+                    "Expiry time  value should not be less"
+                    " than 1");
+                ret = -1;
+                goto out;
+            }
 
-                        ret = dict_set_uint32 (dict, "expiry-time",
-                                               (unsigned int) expiry_time);
-                        if (ret) {
-                                cli_out ("Failed to set dict for bitrot");
-                                goto out;
-                        }
-                        goto set_type;
-                }
+            ret = dict_set_uint32(dict, "expiry-time",
+                                  (unsigned int)expiry_time);
+            if (ret) {
+                cli_out("Failed to set dict for bitrot");
+                goto out;
+            }
+            goto set_type;
+        }
+    } else if (!strcmp(words[3], "signer-threads")) {
+        if (!words[4]) {
+            cli_err(
+                "Missing signer-thread value for bitrot "
+                "option");
+            ret = -1;
+            goto out;
         } else {
-                cli_err ("Invalid option %s for bitrot. Please enter valid "
-                         "bitrot option", words[3]);
+            type = GF_BITROT_OPTION_TYPE_SIGNER_THREADS;
+
+            signer_th_count = strtol(words[4], NULL, 0);
+            if (signer_th_count < 1) {
+                cli_err("signer-thread count should not be less than 1");
                 ret = -1;
                 goto out;
-        }
+            }
 
-set_type:
-        ret = dict_set_int32 (dict, "type", type);
-        if (ret < 0)
+            ret = dict_set_uint32(dict, "signer-threads",
+                                  (unsigned int)signer_th_count);
+            if (ret) {
+                cli_out("Failed to set dict for bitrot");
                 goto out;
+            }
+            goto set_type;
+        }
+    } else {
+        cli_err(
+            "Invalid option %s for bitrot. Please enter valid "
+            "bitrot option",
+            words[3]);
+        ret = -1;
+        goto out;
+    }
+set_type:
+    ret = dict_set_int32(dict, "type", type);
+    if (ret < 0)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse bitrot command");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse bitrot command");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
+}
+
+/* Parsing global option for NFS-Ganesha config
+ *  gluster nfs-ganesha enable/disable */
+
+int32_t
+cli_cmd_ganesha_parse(struct cli_state *state, const char **words,
+                      int wordcount, dict_t **options, char **op_errstr)
+{
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *key = NULL;
+    char *value = NULL;
+    char *w = NULL;
+    static char *opwords[] = {"enable", "disable", NULL};
+    const char *question = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
+
+    if (wordcount != 2)
+        goto out;
+
+    key = (char *)words[0];
+    value = (char *)words[1];
+
+    if (!key || !value) {
+        cli_out("Usage : nfs-ganesha <enable/disable>");
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_strip_whitespace(value, strlen(value));
+    if (ret == -1)
+        goto out;
+
+    if (strcmp(key, "nfs-ganesha")) {
+        gf_asprintf(op_errstr,
+                    "Global option: error: ' %s '"
+                    "is not a valid global option.",
+                    key);
+        ret = -1;
+        goto out;
+    }
+
+    w = str_getunamb(value, opwords);
+    if (!w) {
+        cli_out(
+            "Invalid global option \n"
+            "Usage : nfs-ganesha <enable/disable>");
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(value, "enable") == 0) {
+        question =
+            "Enabling NFS-Ganesha requires Gluster-NFS to be "
+            "disabled across the trusted pool. Do you "
+            "still want to continue?\n";
+    } else if (strcmp(value, "disable") == 0) {
+        question =
+            "Disabling NFS-Ganesha will tear down the entire "
+            "ganesha cluster across the trusted pool. Do you "
+            "still want to continue?\n";
+    } else {
+        ret = -1;
+        goto out;
+    }
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Global operation "
+               "cancelled, exiting");
+        ret = -1;
+        goto out;
+    }
+    cli_out("This will take a few minutes to complete. Please wait ..");
+
+    ret = dict_set_str(dict, "key", key);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set on key failed");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "value", value);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set on value failed");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "globalname", "All");
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "dict set on global"
+               " key failed.");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "hold_global_locks", _gf_true);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "dict set on global key "
+               "failed.");
+        goto out;
+    }
+
+    *options = dict;
+out:
+    if (ret)
+        dict_unref(dict);
+
+    return ret;
 }
diff --git a/cli/src/cli-cmd-peer.c b/cli/src/cli-cmd-peer.c
index 7df60bcb2be..084998701d8 100644
--- a/cli/src/cli-cmd-peer.c
+++ b/cli/src/cli-cmd-peer.c
@@ -18,298 +18,300 @@
 #include "cli-mem-types.h"
 #include "cli1-xdr.h"
 #include "protocol-common.h"
-#include "events.h"
+#include <glusterfs/events.h>
 
-extern struct rpc_clnt *global_rpc;
-
-extern rpc_clnt_prog_t *cli_rpc_prog;
-
-int cli_cmd_peer_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+int
+cli_cmd_peer_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                       const char **words, int wordcount);
 
 int
-cli_cmd_peer_probe_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_peer_probe_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        if (!(wordcount == 3)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROBE];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_set_str (dict, "hostname", (char *)words[2]);
-        if (ret)
-                goto out;
-
-        ret = valid_internet_address ((char *) words[2], _gf_false);
-        if (ret == 1) {
-                ret = 0;
-        } else {
-                cli_out ("%s is an invalid address", words[2]);
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                ret = -1;
-                goto out;
-        }
-/*        if (words[3]) {
-                ret = dict_set_str (dict, "port", (char *)words[3]);
-                if (ret)
-                        goto out;
-        }
-*/
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (!(wordcount == 3)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROBE];
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret)
+        goto out;
+
+    ret = valid_internet_address((char *)words[2], _gf_false, _gf_false);
+    if (ret == 1) {
+        ret = 0;
+    } else {
+        cli_out("%s is an invalid address", words[2]);
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        ret = -1;
+        goto out;
+    }
+    /*        if (words[3]) {
+                    ret = dict_set_str (dict, "port", (char *)words[3]);
+                    if (ret)
+                            goto out;
+            }
+    */
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    CLI_LOCAL_INIT(local, words, frame, dict);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer probe failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer probe failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_PEER_ATTACH, "host=%s", (char *)words[2]);
-        }
+    if (ret == 0) {
+        gf_event(EVENT_PEER_ATTACH, "host=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmd_peer_deprobe_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_peer_deprobe_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                   ret   = -1;
-        rpc_clnt_procedure_t *proc  = NULL;
-        call_frame_t         *frame = NULL;
-        dict_t               *dict  = NULL;
-        int                  flags = 0;
-        int                  sent = 0;
-        int                  parse_error = 0;
-        cli_local_t          *local = NULL;
-
-        if ((wordcount < 3) || (wordcount > 4)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEPROBE];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-
-        ret = dict_set_str (dict, "hostname", (char *)words[2]);
-        if (ret)
-                goto out;
-
-/*        if (words[3]) {
-                ret = dict_set_str (dict, "port", (char *)words[3]);
-                if (ret)
-                        goto out;
-        }
-*/
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3]))
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int flags = 0;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    if ((wordcount < 3) || (wordcount > 4)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+    question =
+        "All clients mounted through the peer which is getting detached need "
+        "to be remounted using one of the other active peers in the trusted "
+        "storage pool to ensure client gets notification on any changes done "
+        "on the gluster configuration and if the same has been done do you "
+        "want to proceed?";
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEPROBE];
+
+    dict = dict_new();
+
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret)
+        goto out;
+
+    /*        if (words[3]) {
+                    ret = dict_set_str (dict, "port", (char *)words[3]);
+                    if (ret)
+                            goto out;
+            }
+    */
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3]))
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
         }
+    }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret)
+        goto out;
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    CLI_LOCAL_INIT(local, words, frame, dict);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer detach failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer detach failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_PEER_DETACH, "host=%s", (char *)words[2]);
-        }
+    if (ret == 0) {
+        gf_event(EVENT_PEER_DETACH, "host=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_peer_status_cbk (struct cli_state *state, struct cli_cmd_word *word,
+cli_cmd_peer_status_cbk(struct cli_state *state, struct cli_cmd_word *word,
                         const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, (void *)GF_CLI_LIST_PEERS);
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, (void *)GF_CLI_LIST_PEERS);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer status failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer status failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_pool_list_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_pool_list_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS,
-                                (void *)GF_CLI_LIST_POOL_NODES);
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, (void *)GF_CLI_LIST_POOL_NODES);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_err ("pool list: command execution failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_err("pool list: command execution failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 struct cli_cmd cli_probe_cmds[] = {
-        { "peer probe { <HOSTNAME> | <IP-address> }",
-          cli_cmd_peer_probe_cbk,
-          "probe peer specified by <HOSTNAME>"},
+    {"peer probe { <HOSTNAME> | <IP-address> }", cli_cmd_peer_probe_cbk,
+     "probe peer specified by <HOSTNAME>"},
 
-        { "peer detach { <HOSTNAME> | <IP-address> } [force]",
-          cli_cmd_peer_deprobe_cbk,
-          "detach peer specified by <HOSTNAME>"},
+    {"peer detach { <HOSTNAME> | <IP-address> } [force]",
+     cli_cmd_peer_deprobe_cbk, "detach peer specified by <HOSTNAME>"},
 
-        { "peer status",
-          cli_cmd_peer_status_cbk,
-          "list status of peers"},
+    {"peer status", cli_cmd_peer_status_cbk, "list status of peers"},
 
-	{ "peer help",
-           cli_cmd_peer_help_cbk,
-           "display help for peer commands"},
+    {"peer help", cli_cmd_peer_help_cbk, "display help for peer commands"},
 
-        { "pool list",
-          cli_cmd_pool_list_cbk,
-          "list all the nodes in the pool (including localhost)"},
+    {"pool list", cli_cmd_pool_list_cbk,
+     "list all the nodes in the pool (including localhost)"},
 
-        { NULL, NULL, NULL }
-};
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_peer_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_peer_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                       const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *probe_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *probe_cmd = NULL;
+    int count = 0;
 
-        cli_out ("\ngluster peer commands");
-        cli_out ("======================\n");
+    cli_out("\ngluster peer commands");
+    cli_out("======================\n");
 
-        cmd = GF_CALLOC (1, sizeof (cli_probe_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, cli_probe_cmds, sizeof (cli_probe_cmds));
-        count = (sizeof (cli_probe_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(cli_probe_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, cli_probe_cmds, sizeof(cli_probe_cmds));
+    count = (sizeof(cli_probe_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        for (probe_cmd = cmd; probe_cmd->pattern; probe_cmd++)
-                cli_out ("%s - %s", probe_cmd->pattern, probe_cmd->desc);
+    for (probe_cmd = cmd; probe_cmd->pattern; probe_cmd++)
+        cli_out("%s - %s", probe_cmd->pattern, probe_cmd->desc);
 
-        GF_FREE (cmd);
+    GF_FREE(cmd);
 
-        cli_out ("\n");
-        return 0;
+    cli_out("\n");
+    return 0;
 }
 
 int
-cli_cmd_probe_register (struct cli_state *state)
+cli_cmd_probe_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_probe_cmds; cmd->pattern; cmd++) {
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = cli_probe_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-snapshot.c b/cli/src/cli-cmd-snapshot.c
index 88b4737cd65..859d6b2e40d 100644
--- a/cli/src/cli-cmd-snapshot.c
+++ b/cli/src/cli-cmd-snapshot.c
@@ -17,153 +17,119 @@
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
 
-extern rpc_clnt_prog_t *cli_rpc_prog;
-
 int
-cli_cmd_snapshot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                           const char **words, int wordcount);
+cli_cmd_snapshot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                          const char **words, int wordcount);
 
 int
-cli_cmd_snapshot_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_snapshot_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                      ret       = 0;
-        int                      parse_err = 0;
-        dict_t                  *options   = NULL;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        call_frame_t            *frame     = NULL;
-        cli_local_t             *local     = NULL;
-
-        proc = &cli_rpc_prog->proctable [GLUSTER_CLI_SNAP];
-        if (proc == NULL) {
-               ret = -1;
-                goto out;
-        }
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (frame == NULL) {
-                ret = -1;
-                goto out;
+    int ret = 0;
+    int parse_err = 0;
+    dict_t *options = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SNAP];
+
+    /* Parses the command entered by the user */
+    ret = cli_cmd_snapshot_parse(words, wordcount, &options, state);
+    if (ret) {
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+        } else {
+            /* User might have cancelled the snapshot operation */
+            ret = 0;
         }
+        goto out;
+    }
 
-        /* Parses the command entered by the user */
-        ret = cli_cmd_snapshot_parse (words, wordcount, &options, state);
-        if (ret) {
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                } else {
-                        /* User might have cancelled the snapshot operation */
-                        ret = 0;
-                }
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (frame == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret && parse_err == 0)
-                cli_out ("Snapshot command failed");
+    if (ret && parse_err == 0)
+        cli_out("Snapshot command failed");
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 struct cli_cmd snapshot_cmds[] = {
-        { "snapshot help",
-          cli_cmd_snapshot_help_cbk,
-          "display help for snapshot commands"
-        },
-        { "snapshot create <snapname> <volname> [no-timestamp] "
-                "[description <description>] [force]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Create."
-        },
-        { "snapshot clone <clonename> <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Clone."
-        },
-        { "snapshot restore <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Restore."
-        },
-        { "snapshot status [(snapname | volume <volname>)]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Status."
-        },
-        { "snapshot info [(snapname | volume <volname>)]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Info."
-        },
-        { "snapshot list [volname]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot List."
-        },
-        {"snapshot config [volname] ([snap-max-hard-limit <count>] "
-         "[snap-max-soft-limit <percent>]) "
-         "| ([auto-delete <enable|disable>])"
-         "| ([activate-on-create <enable|disable>])",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Config."
-        },
-        {"snapshot delete (all | snapname | volume <volname>)",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Delete."
-        },
-        {"snapshot activate <snapname> [force]",
-          cli_cmd_snapshot_cbk,
-          "Activate snapshot volume."
-        },
-        {"snapshot deactivate <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Deactivate snapshot volume."
-        },
-        { NULL, NULL, NULL }
-};
+    {"snapshot help", cli_cmd_snapshot_help_cbk,
+     "display help for snapshot commands"},
+    {"snapshot create <snapname> <volname> [no-timestamp] "
+     "[description <description>] [force]",
+     cli_cmd_snapshot_cbk, "Snapshot Create."},
+    {"snapshot clone <clonename> <snapname>", cli_cmd_snapshot_cbk,
+     "Snapshot Clone."},
+    {"snapshot restore <snapname>", cli_cmd_snapshot_cbk, "Snapshot Restore."},
+    {"snapshot status [(snapname | volume <volname>)]", cli_cmd_snapshot_cbk,
+     "Snapshot Status."},
+    {"snapshot info [(snapname | volume <volname>)]", cli_cmd_snapshot_cbk,
+     "Snapshot Info."},
+    {"snapshot list [volname]", cli_cmd_snapshot_cbk, "Snapshot List."},
+    {"snapshot config [volname] ([snap-max-hard-limit <count>] "
+     "[snap-max-soft-limit <percent>]) "
+     "| ([auto-delete <enable|disable>])"
+     "| ([activate-on-create <enable|disable>])",
+     cli_cmd_snapshot_cbk, "Snapshot Config."},
+    {"snapshot delete (all | snapname | volume <volname>)",
+     cli_cmd_snapshot_cbk, "Snapshot Delete."},
+    {"snapshot activate <snapname> [force]", cli_cmd_snapshot_cbk,
+     "Activate snapshot volume."},
+    {"snapshot deactivate <snapname>", cli_cmd_snapshot_cbk,
+     "Deactivate snapshot volume."},
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_snapshot_help_cbk (struct cli_state *state,
-                           struct cli_cmd_word *in_word,
-                           const char **words,
-                           int wordcount)
+cli_cmd_snapshot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                          const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd      = NULL;
-        struct cli_cmd        *snap_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *snap_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_CALLOC (1, sizeof (snapshot_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, snapshot_cmds, sizeof (snapshot_cmds));
-        count = (sizeof (snapshot_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(snapshot_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, snapshot_cmds, sizeof(snapshot_cmds));
+    count = (sizeof(snapshot_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster snapshot commands");
-        cli_out ("=========================\n");
+    cli_out("\ngluster snapshot commands");
+    cli_out("=========================\n");
 
-        for (snap_cmd = cmd; snap_cmd->pattern; snap_cmd++)
-                if (_gf_false == snap_cmd->disable)
-                        cli_out ("%s - %s", snap_cmd->pattern, snap_cmd->desc);
-        cli_out ("\n");
+    for (snap_cmd = cmd; snap_cmd->pattern; snap_cmd++)
+        if (_gf_false == snap_cmd->disable)
+            cli_out("%s - %s", snap_cmd->pattern, snap_cmd->desc);
+    cli_out("\n");
 
-        GF_FREE (cmd);
-        return 0;
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_snapshot_register (struct cli_state *state)
+cli_cmd_snapshot_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = snapshot_cmds; cmd->pattern; cmd++) {
-
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+
+    for (cmd = snapshot_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-system.c b/cli/src/cli-cmd-system.c
index 93aac0b60cc..801e8f4efed 100644
--- a/cli/src/cli-cmd-system.c
+++ b/cli/src/cli-cmd-system.c
@@ -18,585 +18,607 @@
 #include "cli-mem-types.h"
 #include "protocol-common.h"
 
+int
+cli_cmd_system_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
 
-extern struct rpc_clnt *global_rpc;
-
-extern rpc_clnt_prog_t *cli_rpc_prog;
-
-int cli_cmd_system_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                             const char **words, int wordcount);
-
-int cli_cmd_copy_file_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount);
+int
+cli_cmd_copy_file_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount);
 
-int cli_cmd_sys_exec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount);
+int
+cli_cmd_sys_exec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount);
 
 int
-cli_cmd_getspec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                     const char **words, int wordcount)
+cli_cmd_getspec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "volid", (char *)words[2]);
-        if (ret)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETSPEC];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "volid", (char *)words[2]);
+    if (ret)
+        goto out;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETSPEC];
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            ret = -1;
+            goto out;
+        }
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (!proc && ret) {
-                if (dict)
-                        dict_unref (dict);
-                if (wordcount > 1)
-                        cli_out ("Fetching spec for volume %s failed",
-                                 (char *)words[2]);
-        }
+    if (!proc && ret) {
+        if (wordcount > 1)
+            cli_out("Fetching spec for volume %s failed", (char *)words[2]);
+    }
 
-        return ret;
+    if (dict)
+        dict_unref(dict);
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_pmap_b2p_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                 const char **words, int wordcount)
+cli_cmd_pmap_b2p_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "brick", (char *)words[3]);
-        if (ret)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PMAP_PORTBYBRICK];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "brick", (char *)words[3]);
+    if (ret)
+        goto out;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PMAP_PORTBYBRICK];
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            ret = -1;
+            goto out;
+        }
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (!proc && ret) {
-                if (dict)
-                        dict_unref (dict);
-                if (wordcount > 1)
-                        cli_out ("Fetching spec for volume %s failed",
-                                 (char *)words[3]);
-        }
+    if (!proc && ret) {
+        if (wordcount > 1)
+            cli_out("Fetching spec for volume %s failed", (char *)words[3]);
+    }
+
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_fsm_log_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                     const char **words, int wordcount)
+cli_cmd_fsm_log_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        char                            *name = "";
-
-        if ((wordcount != 4) && (wordcount != 3)) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        if (wordcount == 4)
-                name = (char*)words[3];
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_FSM_LOG];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, (void*)name);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *name = "";
+
+    if ((wordcount != 4) && (wordcount != 3)) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    if (wordcount == 4)
+        name = (char *)words[3];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_FSM_LOG];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, (void *)name);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_getwd_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_getwd_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETWD];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, NULL);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETWD];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, NULL);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static dict_t *
-make_seq_dict (int argc, char **argv)
+make_seq_dict(int argc, char **argv)
 {
-        char index[] = "4294967296"; // 1<<32
-        int i        = 0;
-        int ret      = 0;
-        dict_t *dict = dict_new ();
-
-        if (!dict)
-                return NULL;
-
-        for (i = 0; i < argc; i++) {
-                snprintf(index, sizeof(index), "%d", i);
-                ret = dict_set_str (dict, index, argv[i]);
-                if (ret == -1)
-                        break;
-        }
-
-        if (ret) {
-                dict_unref (dict);
-                dict = NULL;
-        }
-
-        return dict;
+    char index[] = "4294967296";  // 1<<32
+    int i = 0;
+    int len;
+    int ret = 0;
+    dict_t *dict = dict_new();
+
+    if (!dict)
+        return NULL;
+
+    for (i = 0; i < argc; i++) {
+        len = snprintf(index, sizeof(index), "%d", i);
+        ret = dict_set_strn(dict, index, len, argv[i]);
+        if (ret == -1)
+            break;
+    }
+
+    if (ret) {
+        dict_unref(dict);
+        dict = NULL;
+    }
+
+    return dict;
 }
 
 int
-cli_cmd_mount_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_mount_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame        = NULL;
-        int ret                    = -1;
-        dict_t *dict               = NULL;
-        void *dataa[]              = {NULL, NULL};
-
-        if (wordcount < 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = make_seq_dict (wordcount - 3, (char **)words + 3);
-        if (!dict)
-                goto out;
-
-        dataa[0] = (void *)words[2];
-        dataa[1] = dict;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_MOUNT];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, dataa);
-        }
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    dict_t *dict = NULL;
+    void *dataa[] = {NULL, NULL};
+
+    if (wordcount < 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = make_seq_dict(wordcount - 3, (char **)words + 3);
+    if (!dict)
+        goto out;
+
+    dataa[0] = (void *)words[2];
+    dataa[1] = dict;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_MOUNT];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, dataa);
+    }
 
- out:
-        if (dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        dict_unref(dict);
 
-        if (!proc && ret)
-                cli_out ("Mount command failed");
+    if (!proc && ret)
+        cli_out("Mount command failed");
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_umount_cbk (struct cli_state *state, struct cli_cmd_word *word,
+cli_cmd_umount_cbk(struct cli_state *state, struct cli_cmd_word *word,
                    const char **words, int wordcount)
 {
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame        = NULL;
-        int ret                    = -1;
-        dict_t *dict               = NULL;
-
-        if (!(wordcount == 3 ||
-              (wordcount == 4 && strcmp (words[3], "lazy") == 0))) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    dict_t *dict = NULL;
+
+    if (!(wordcount == 3 ||
+          (wordcount == 4 && strcmp(words[3], "lazy") == 0))) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "path", (char *)words[2]);
+    if (ret != 0)
+        goto out;
+    ret = dict_set_int32(dict, "lazy", wordcount == 4);
+    if (ret != 0)
+        goto out;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UMOUNT];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+            ret = -1;
+            goto out;
+        }
+        ret = proc->fn(frame, THIS, dict);
+    }
 
-        ret = dict_set_str (dict, "path", (char *)words[2]);
-        if (ret != 0)
-                goto out;
-        ret = dict_set_int32 (dict, "lazy", wordcount == 4);
-        if (ret != 0)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UMOUNT];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, dict);
-        }
-
- out:
-        if (dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        dict_unref(dict);
 
-        if (!proc && ret)
-                cli_out ("Umount command failed");
+    if (!proc && ret)
+        cli_out("Umount command failed");
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_uuid_get_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_uuid_get_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                     ret = -1;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict  = NULL;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        cli_local_t             *local = NULL;
-        xlator_t                *this  = NULL;
-
-        this = THIS;
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_GET];
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-        if (proc->fn)
-                ret = proc->fn (frame, this, dict);
+    int ret = -1;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_GET];
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    CLI_LOCAL_INIT(local, words, frame, dict);
+    if (proc->fn)
+        ret = proc->fn(frame, this, dict);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("uuid get failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("uuid get failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_uuid_reset_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_uuid_reset_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        char                    *question = NULL;
-        cli_local_t             *local = NULL;
-        dict_t                  *dict  = NULL;
-        xlator_t                *this  = NULL;
-
-        question = "Resetting uuid changes the uuid of local glusterd. "
-                   "Do you want to continue?";
-
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_RESET];
-
-        this = THIS;
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-        CLI_LOCAL_INIT (local, words, frame, dict);
-        answer = cli_cmd_get_confirmation (state, question);
-
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
-
-        //send NULL as argument since no dictionary is sent to glusterd
-        if (proc->fn) {
-                ret = proc->fn (frame, this, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    char *question = NULL;
+    cli_local_t *local = NULL;
+    dict_t *dict = NULL;
+    xlator_t *this = NULL;
+
+    question =
+        "Resetting uuid changes the uuid of local glusterd. "
+        "Do you want to continue?";
+
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_RESET];
+
+    this = THIS;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+    CLI_LOCAL_INIT(local, words, frame, dict);
+    answer = cli_cmd_get_confirmation(state, question);
+
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
+
+    // send NULL as argument since no dictionary is sent to glusterd
+    if (proc->fn) {
+        ret = proc->fn(frame, this, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("uuid reset failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("uuid reset failed");
+    }
+
+    if (dict)
+        dict_unref(dict);
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
-struct cli_cmd cli_system_cmds[] = {
-        { "system:: getspec <VOLNAME>",
-          cli_cmd_getspec_cbk,
-          "fetch the volume file for the volume <VOLNAME>"},
+static struct cli_cmd cli_system_cmds[] = {
+    {"system:: getspec <VOLNAME>", cli_cmd_getspec_cbk,
+     "fetch the volume file for the volume <VOLNAME>"},
 
-        { "system:: portmap brick2port <BRICK>",
-          cli_cmd_pmap_b2p_cbk,
-          "query which port <BRICK> listens on"},
+    {"system:: portmap brick2port <BRICK>", cli_cmd_pmap_b2p_cbk,
+     "query which port <BRICK> listens on"},
 
-        { "system:: fsm log [<peer-name>]",
-          cli_cmd_fsm_log_cbk,
-          "display fsm transitions"},
+    {"system:: fsm log [<peer-name>]", cli_cmd_fsm_log_cbk,
+     "display fsm transitions"},
 
-        { "system:: getwd",
-          cli_cmd_getwd_cbk,
-          "query glusterd work directory"},
+    {"system:: getwd", cli_cmd_getwd_cbk, "query glusterd work directory"},
 
-        { "system:: mount <label> <args...>",
-          cli_cmd_mount_cbk,
-          "request a mount"},
+    {"system:: mount <label> <args...>", cli_cmd_mount_cbk, "request a mount"},
 
-        { "system:: umount <path> [lazy]",
-          cli_cmd_umount_cbk,
-          "request an umount"},
+    {"system:: umount <path> [lazy]", cli_cmd_umount_cbk, "request an umount"},
 
-        { "system:: uuid get",
-          cli_cmd_uuid_get_cbk,
-          "get uuid of glusterd"},
+    {"system:: uuid get", cli_cmd_uuid_get_cbk, "get uuid of glusterd"},
 
-        { "system:: uuid reset",
-          cli_cmd_uuid_reset_cbk,
-          "reset the uuid of glusterd"},
+    {"system:: uuid reset", cli_cmd_uuid_reset_cbk,
+     "reset the uuid of glusterd"},
 
-        { "system:: help",
-           cli_cmd_system_help_cbk,
-           "display help for system commands"},
+    {"system:: help", cli_cmd_system_help_cbk,
+     "display help for system commands"},
 
-        { "system:: copy file [<filename>]",
-           cli_cmd_copy_file_cbk,
-           "Copy file from current node's $working_dir to "
-           "$working_dir of all cluster nodes"},
+    {"system:: copy file [<filename>]", cli_cmd_copy_file_cbk,
+     "Copy file from current node's $working_dir to "
+     "$working_dir of all cluster nodes"},
 
-        { "system:: execute <command> <args>",
-           cli_cmd_sys_exec_cbk,
-           "Execute the command on all the nodes "
-           "in the cluster and display their output."},
+    {"system:: execute <command> <args>", cli_cmd_sys_exec_cbk,
+     "Execute the command on all the nodes "
+     "in the cluster and display their output."},
 
-        { NULL, NULL, NULL }
-};
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_sys_exec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_sys_exec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        char                   cmd_arg_name[PATH_MAX] = "";
-        char                  *command                = NULL;
-        char                  *saveptr                = NULL;
-        char                  *tmp                    = NULL;
-        int                    ret                    = -1;
-        int                    i                      = -1;
-        int                    cmd_args_count         = 0;
-        int                    in_cmd_args_count      = 0;
-        rpc_clnt_procedure_t  *proc                   = NULL;
-        call_frame_t          *frame                  = NULL;
-        dict_t                *dict                   = NULL;
-        cli_local_t           *local                  = NULL;
-
-        if (wordcount < 3) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        command = strtok_r ((char *)words[2], " ", &saveptr);
-        do {
-                tmp = strtok_r (NULL, " ", &saveptr);
-                if (tmp) {
-                        in_cmd_args_count++;
-                        memset (cmd_arg_name, '\0', sizeof(cmd_arg_name));
-                        snprintf (cmd_arg_name, sizeof(cmd_arg_name),
-                                  "cmd_arg_%d", in_cmd_args_count);
-                        ret = dict_set_str (dict, cmd_arg_name, tmp);
-                        if (ret) {
-                                gf_log ("", GF_LOG_ERROR, "Unable to set "
-                                        "%s in dict", cmd_arg_name);
-                                goto out;
-                        }
-                }
-        } while (tmp);
-
-        cmd_args_count = wordcount - 3;
-
-        ret = dict_set_str (dict, "command", command);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to set command in dict");
+    char cmd_arg_name[PATH_MAX] = "";
+    char *command = NULL;
+    char *saveptr = NULL;
+    char *tmp = NULL;
+    int ret = -1;
+    int i = -1;
+    int len;
+    int cmd_args_count = 0;
+    int in_cmd_args_count = 0;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+
+    if ((wordcount < 3) || (words[2] == NULL)) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    command = strtok_r((char *)words[2], " ", &saveptr);
+    if (command == NULL) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to parse command");
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    do {
+        tmp = strtok_r(NULL, " ", &saveptr);
+        if (tmp) {
+            in_cmd_args_count++;
+            snprintf(cmd_arg_name, sizeof(cmd_arg_name), "cmd_arg_%d",
+                     in_cmd_args_count);
+            ret = dict_set_str(dict, cmd_arg_name, tmp);
+            if (ret) {
+                gf_log("", GF_LOG_ERROR,
+                       "Unable to set "
+                       "%s in dict",
+                       cmd_arg_name);
                 goto out;
+            }
         }
+    } while (tmp);
 
-        for (i=1; i <= cmd_args_count; i++) {
-                in_cmd_args_count++;
-                memset (cmd_arg_name, '\0', sizeof(cmd_arg_name));
-                snprintf (cmd_arg_name, sizeof(cmd_arg_name),
-                          "cmd_arg_%d", in_cmd_args_count);
-                ret = dict_set_str (dict, cmd_arg_name,
-                                    (char *)words[2+i]);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Unable to set %s in dict",
-                               cmd_arg_name);
-                        goto out;
-                }
-        }
+    cmd_args_count = wordcount - 3;
 
-        ret = dict_set_int32 (dict, "cmd_args_count", in_cmd_args_count);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Unable to set cmd_args_count in dict");
-                goto out;
-        }
+    ret = dict_set_str(dict, "command", command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set command in dict");
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", "N/A");
+    for (i = 1; i <= cmd_args_count; i++) {
+        in_cmd_args_count++;
+        len = snprintf(cmd_arg_name, sizeof(cmd_arg_name), "cmd_arg_%d",
+                       in_cmd_args_count);
+        ret = dict_set_strn(dict, cmd_arg_name, len, (char *)words[2 + i]);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to set volname in dict");
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYS_EXEC];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                CLI_LOCAL_INIT (local, words, frame, dict);
-                ret = proc->fn (frame, THIS, (void*)dict);
-        }
+            gf_log("", GF_LOG_ERROR, "Unable to set %s in dict", cmd_arg_name);
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "cmd_args_count", in_cmd_args_count);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set cmd_args_count in dict");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", "N/A");
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set volname in dict");
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYS_EXEC];
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+            ret = -1;
+            goto out;
+        }
+        CLI_LOCAL_INIT(local, words, frame, dict);
+        ret = proc->fn(frame, THIS, (void *)dict);
+
+        /* proc->fn is processed synchronously, which means that the
+         * execution flow won't return here until the operation is
+         * fully processed, including any related callback. For this
+         * reason, it's safe to destroy the stack here, since no one
+         * can still be using it. Additionally, it's not easy to move
+         * the stack destroy to the callback executed after completion
+         * of the operation because there are multiple things than can
+         * fail even before having queued the callback, so we would
+         * still need to destroy the stack if proc->fn returns an
+         * error. */
+        CLI_STACK_DESTROY(frame);
+        dict = NULL;
+    }
 out:
-        return ret;
+    if (dict != NULL) {
+        dict_unref(dict);
+    }
+
+    return ret;
 }
 
 int
-cli_cmd_copy_file_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_copy_file_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                    ret      = -1;
-        rpc_clnt_procedure_t  *proc     = NULL;
-        call_frame_t          *frame    = NULL;
-        char                  *filename = "";
-        dict_t                *dict     = NULL;
-        cli_local_t           *local    = NULL;
-
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        filename = (char*)words[3];
-        ret = dict_set_str (dict, "source", filename);
-        if (ret)
-                 gf_log ("", GF_LOG_ERROR, "Unable to set filename in dict");
-
-        ret = dict_set_str (dict, "volname", "N/A");
-        if (ret)
-                 gf_log ("", GF_LOG_ERROR, "Unable to set volname in dict");
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_COPY_FILE];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                CLI_LOCAL_INIT (local, words, frame, dict);
-                ret = proc->fn (frame, THIS, (void*)dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *filename = "";
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    filename = (char *)words[3];
+    ret = dict_set_str(dict, "source", filename);
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "Unable to set filename in dict");
+
+    ret = dict_set_str(dict, "volname", "N/A");
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "Unable to set volname in dict");
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_COPY_FILE];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+            ret = -1;
+            goto out;
+        }
+        CLI_LOCAL_INIT(local, words, frame, dict);
+        ret = proc->fn(frame, THIS, (void *)dict);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_system_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_system_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *system_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *system_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_CALLOC (1, sizeof (cli_system_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, cli_system_cmds, sizeof (cli_system_cmds));
-        count = (sizeof (cli_system_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(cli_system_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, cli_system_cmds, sizeof(cli_system_cmds));
+    count = (sizeof(cli_system_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        for (system_cmd = cmd; system_cmd->pattern; system_cmd++)
-                cli_out ("%s - %s", system_cmd->pattern, system_cmd->desc);
+    for (system_cmd = cmd; system_cmd->pattern; system_cmd++)
+        cli_out("%s - %s", system_cmd->pattern, system_cmd->desc);
 
-        GF_FREE (cmd);
-        return 0;
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_system_register (struct cli_state *state)
+cli_cmd_system_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_system_cmds; cmd->pattern; cmd++) {
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = cli_system_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-volume.c b/cli/src/cli-cmd-volume.c
index a1e5c514d86..f238851586e 100644
--- a/cli/src/cli-cmd-volume.c
+++ b/cli/src/cli-cmd-volume.c
@@ -23,3171 +23,2932 @@
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
 #include "cli1-xdr.h"
-#include "run.h"
-#include "syscall.h"
-#include "common-utils.h"
-#include "events.h"
+#include <glusterfs/run.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/events.h>
 
-extern struct rpc_clnt *global_rpc;
-extern struct rpc_clnt *global_quotad_rpc;
-
-extern rpc_clnt_prog_t *cli_rpc_prog;
 extern rpc_clnt_prog_t cli_quotad_clnt;
 
-int
-cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
+static int
+gf_asprintf_append(char **string_ptr, const char *format, ...);
 
 int
-cli_cmd_bitrot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
+cli_cmd_volume_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
 
 int
-cli_cmd_quota_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_bitrot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                         const char **words, int wordcount);
 
 int
-cli_cmd_tier_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_quota_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                        const char **words, int wordcount);
 
 int
-cli_cmd_volume_info_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
+cli_cmd_volume_info_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        cli_cmd_volume_get_ctx_t        ctx = {0,};
-        cli_local_t                     *local = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_cmd_volume_get_ctx_t ctx = {
+        0,
+    };
+    cli_local_t *local = NULL;
+    int sent = 0;
+    int parse_error = 0;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
+
+    if ((wordcount == 2) || (wordcount == 3 && !strcmp(words[2], "all"))) {
+        ctx.flags = GF_CLI_GET_NEXT_VOLUME;
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME];
+    } else if (wordcount == 3) {
+        ctx.flags = GF_CLI_GET_VOLUME;
+        ctx.volname = (char *)words[2];
+        if (strlen(ctx.volname) > GD_VOLUME_NAME_MAX) {
+            cli_out("Invalid volume name");
+            goto out;
+        }
         proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
+    } else {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        return -1;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if ((wordcount == 2)  || (wordcount == 3 &&
-                                  !strcmp (words[2], "all"))) {
-                ctx.flags = GF_CLI_GET_NEXT_VOLUME;
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME];
-        } else if (wordcount == 3) {
-                ctx.flags = GF_CLI_GET_VOLUME;
-                ctx.volname = (char *)words[2];
-                if (strlen (ctx.volname) > GD_VOLUME_NAME_MAX) {
-                        cli_out ("Invalid volume name");
-                        goto out;
-                }
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
-        } else {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                return -1;
-        }
+    local = cli_local_get();
 
-        local = cli_local_get ();
+    if (!local)
+        goto out;
 
-        if (!local)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        local->get_vol.flags = ctx.flags;
-        if (ctx.volname)
-                local->get_vol.volname = gf_strdup (ctx.volname);
+    local->get_vol.flags = ctx.flags;
+    if (ctx.volname)
+        local->get_vol.volname = gf_strdup(ctx.volname);
 
-        frame->local = local;
+    frame->local = local;
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, &ctx);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, &ctx);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Getting Volume information failed!");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Getting Volume information failed!");
+    }
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_sync_volume_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
+cli_cmd_sync_volume_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        cli_local_t             *local = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        const char              *question = "Sync volume may make data "
-                                            "inaccessible while the sync "
-                                            "is in progress. Do you want "
-                                            "to continue?";
-
-        if ((wordcount < 3) || (wordcount > 4)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question =
+        "Sync volume may make data "
+        "inaccessible while the sync "
+        "is in progress. Do you want "
+        "to continue?";
+
+    if ((wordcount < 3) || (wordcount > 4)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if ((wordcount == 3) || !strcmp(words[3], "all")) {
-                ret = dict_set_int32 (dict, "flags", (int32_t)
-                                      GF_CLI_SYNC_ALL);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "failed to set"
-                                "flag");
-                        goto out;
-                }
-        } else {
-                ret = dict_set_str (dict, "volname", (char *) words[3]);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "failed to set "
-                                "volume");
-                        goto out;
-                }
+    if ((wordcount == 3) || !strcmp(words[3], "all")) {
+        ret = dict_set_int32(dict, "flags", (int32_t)GF_CLI_SYNC_ALL);
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set"
+                   "flag");
+            goto out;
         }
-
-        ret = dict_set_str (dict, "hostname", (char *) words[2]);
+    } else {
+        ret = dict_set_str(dict, "volname", (char *)words[3]);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set hostname");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set "
+                   "volume");
+            goto out;
         }
+    }
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT)) {
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set hostname");
+        goto out;
+    }
+
+    if (!(state->mode & GLUSTER_MODE_SCRIPT)) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume sync failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume sync failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_create_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_create_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        char                    *trans_type = NULL;
-        char                    *bricks = NULL;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    char *trans_type = NULL;
+    char *bricks = NULL;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];
+
+    ret = cli_cmd_volume_create_parse(state, words, wordcount, &options,
+                                      &bricks);
+
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_volume_create_parse (state, words, wordcount, &options,
-                                           &bricks);
+    ret = dict_get_str(options, "transport", &trans_type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get transport type");
+        goto out;
+    }
 
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
         if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set force "
+                   "option");
+            goto out;
         }
+    }
 
-        ret = dict_get_str (options, "transport", &trans_type);
-        if (ret) {
-                gf_log("cli", GF_LOG_ERROR, "Unable to get transport type");
-                goto out;
-        }
-
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume create failed");
-        }
-
-        CLI_STACK_DESTROY (frame);
-        if (ret == 0) {
-                gf_event (EVENT_VOLUME_CREATE, "name=%s;bricks=%s",
-                          (char *)words[2], bricks);
-        }
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume create failed");
+    }
+
+    if (ret == 0) {
+        gf_event(EVENT_VOLUME_CREATE, "name=%s;bricks=%s", (char *)words[2],
+                 bricks);
+    }
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
 int
-cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_delete_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *volname = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        const char              *question = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        dict_t                  *dict = NULL;
-
-        question = "Deleting volume will erase all information about the volume. "
-                   "Do you want to continue?";
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DELETE_VOLUME];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *volname = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    dict_t *dict = NULL;
+
+    question =
+        "Deleting volume will erase all information about the volume. "
+        "Do you want to continue?";
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DELETE_VOLUME];
+
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING, "dict set failed");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Deleting the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "dict set failed");
+        goto out;
+    }
+
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Deleting the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+    }
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
 
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume delete failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume delete failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0 && GF_ANSWER_YES == answer) {
-                gf_event (EVENT_VOLUME_DELETE, "name=%s", (char *)words[2]);
-        }
+    if (ret == 0 && GF_ANSWER_YES == answer) {
+        gf_event(EVENT_VOLUME_DELETE, "name=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_start_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        int                     flags = 0;
-        cli_local_t             *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    int flags = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount < 3 || wordcount > 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (wordcount < 3 || wordcount > 4) {
-               cli_usage_out (word->pattern);
-                parse_error = 1;
-               goto out;
-        }
+    if (!words[2])
+        goto out;
 
-        dict = dict_new ();
-        if (!dict) {
-                goto out;
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3])) {
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        } else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
         }
+    }
 
-        if (!words[2])
-                goto out;
+    dict = dict_new();
+    if (!dict) {
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "dict set failed");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3])) {
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                 gf_log (THIS->name, GF_LOG_ERROR,
-                         "dict set failed");
-                 goto out;
-        }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    CLI_LOCAL_INIT(local, words, frame, dict);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume start failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume start failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_VOLUME_START, "name=%s;force=%d",
-                          (char *)words[2], (flags & GF_CLI_FLAG_OP_FORCE));
-        }
+    if (ret == 0) {
+        gf_event(EVENT_VOLUME_START, "name=%s;force=%d", (char *)words[2],
+                 (flags & GF_CLI_FLAG_OP_FORCE));
+    }
 
-        return ret;
+    return ret;
 }
 
 gf_answer_t
-cli_cmd_get_confirmation (struct cli_state *state, const char *question)
+cli_cmd_get_confirmation(struct cli_state *state, const char *question)
 {
-        char                    answer[5] = {'\0', };
-        int                     flush = '\0';
-        size_t			len;
+    char answer[5] = {
+        '\0',
+    };
+    int flush = '\0';
+    size_t len;
 
-        if (state->mode & GLUSTER_MODE_SCRIPT)
-                return GF_ANSWER_YES;
+    if (state->mode & GLUSTER_MODE_SCRIPT)
+        return GF_ANSWER_YES;
 
-	printf ("%s (y/n) ", question);
+    printf("%s (y/n) ", question);
 
-        if (fgets (answer, 4, stdin) == NULL) {
-                cli_out("gluster cli read error");
-                goto out;
-        }
+    if (fgets(answer, 4, stdin) == NULL) {
+        cli_out("gluster cli read error");
+        goto out;
+    }
 
-	len = strlen (answer);
+    len = strlen(answer);
 
-	if (len && answer [len - 1] == '\n'){
-		answer [--len] = '\0';
-	} else {
-		do{
-			flush = getchar ();
-		}while (flush != '\n');
-	}
+    if (len && answer[len - 1] == '\n') {
+        answer[--len] = '\0';
+    } else {
+        do {
+            flush = getchar();
+        } while (flush != '\n');
+    }
 
-	if (len > 3)
-		goto out;
+    if (len > 3)
+        goto out;
 
-	if (!strcasecmp (answer, "y") || !strcasecmp (answer, "yes"))
-		return GF_ANSWER_YES;
+    if (!strcasecmp(answer, "y") || !strcasecmp(answer, "yes"))
+        return GF_ANSWER_YES;
 
-	else if (!strcasecmp (answer, "n") || !strcasecmp (answer, "no"))
-		return GF_ANSWER_NO;
+    else if (!strcasecmp(answer, "n") || !strcasecmp(answer, "no"))
+        return GF_ANSWER_NO;
 
 out:
-	cli_out ("Invalid input, please enter y/n");
+    cli_out("Invalid input, please enter y/n");
 
-	return GF_ANSWER_NO;
+    return GF_ANSWER_NO;
 }
 
 int
-cli_cmd_volume_stop_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_stop_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     flags   = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        char                    *volname = NULL;
-        cli_local_t             *local = NULL;
-
-        const char *question = "Stopping volume will make its data inaccessible. "
-                               "Do you want to continue?";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if (wordcount < 3 || wordcount > 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        volname = (char*) words[2];
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int flags = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    cli_local_t *local = NULL;
+
+    const char *question =
+        "Stopping volume will make its data inaccessible. "
+        "Do you want to continue?";
+
+    if (wordcount < 3 || wordcount > 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        dict = dict_new ();
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "dict set failed");
-                goto out;
-        }
+    volname = (char *)words[2];
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Stopping the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
+    dict = dict_new();
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
+
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Stopping the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+    }
+
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3])) {
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        } else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
         }
+    }
 
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3])) {
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
-        }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "dict set failed");
-                goto out;
-        }
+    answer = cli_cmd_get_confirmation(state, question);
 
-        answer = cli_cmd_get_confirmation (state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
 
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STOP_VOLUME];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STOP_VOLUME];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume stop on '%s' failed", volname);
-        }
-
-        CLI_STACK_DESTROY (frame);
-
-        if (ret == 0 && GF_ANSWER_YES == answer) {
-                gf_event (EVENT_VOLUME_STOP, "name=%s;force=%d",
-                          (char *)words[2], (flags & GF_CLI_FLAG_OP_FORCE));
-        }
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume stop on '%s' failed", volname);
+    }
+
+    CLI_STACK_DESTROY(frame);
+    if (dict)
+        dict_unref(dict);
+
+    if (ret == 0 && GF_ANSWER_YES == answer) {
+        gf_event(EVENT_VOLUME_STOP, "name=%s;force=%d", (char *)words[2],
+                 (flags & GF_CLI_FLAG_OP_FORCE));
+    }
+
+    return ret;
 }
 
-
 int
-cli_cmd_volume_rename_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_rename_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        ret = dict_set_str (dict, "old-volname", (char *)words[2]);
+    ret = dict_set_str(dict, "old-volname", (char *)words[2]);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "new-volname", (char *)words[3]);
+    ret = dict_set_str(dict, "new-volname", (char *)words[3]);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RENAME_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RENAME_VOLUME];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame) {
+            ret = -1;
+            goto out;
         }
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume rename on '%s' failed", (char *)words[2]);
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume rename on '%s' failed", (char *)words[2]);
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_defrag_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_defrag_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                   ret     = -1;
-        rpc_clnt_procedure_t *proc    = NULL;
-        call_frame_t         *frame   = NULL;
-        dict_t               *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t          *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 #if (USE_EVENTS)
-        eventtypes_t         event = EVENT_LAST;
+    eventtypes_t event = EVENT_LAST;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_volume_defrag_parse(words, wordcount, &dict);
 
-        ret = cli_cmd_volume_defrag_parse (words, wordcount, &dict);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+    }
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEFRAG_VOLUME];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEFRAG_VOLUME];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume rebalance failed");
-        } else {
-
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume rebalance failed");
+    } else {
 #if (USE_EVENTS)
-                if (!(strcmp (words[wordcount-1], "start")) ||
-                        !(strcmp (words[wordcount-1], "force")))  {
-                        event = EVENT_VOLUME_REBALANCE_START;
-                } else if (!strcmp (words[wordcount-1], "stop")) {
-                        event = EVENT_VOLUME_REBALANCE_STOP;
-                }
+        if (!(strcmp(words[wordcount - 1], "start")) ||
+            !(strcmp(words[wordcount - 1], "force"))) {
+            event = EVENT_VOLUME_REBALANCE_START;
+        } else if (!strcmp(words[wordcount - 1], "stop")) {
+            event = EVENT_VOLUME_REBALANCE_STOP;
+        }
 
-                if (event != EVENT_LAST)
-                        gf_event (event, "volume=%s", (char *)words[2]);
+        if (event != EVENT_LAST)
+            gf_event(event, "volume=%s", (char *)words[2]);
 #endif
-        }
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_reset_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_reset_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
 #if (USE_EVENTS)
-        int                      ret1    = -1;
-        char                    *tmp_opt = NULL;
+    int ret1 = -1;
+    char *tmp_opt = NULL;
 #endif
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_volume_reset_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_volume_reset_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume reset failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume reset failed");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                ret1 = dict_get_str (options, "key", &tmp_opt);
-                if (ret1)
-                        tmp_opt = "";
-
-                gf_event (EVENT_VOLUME_RESET, "name=%s;option=%s",
-                          (char *)words[2],
-                          tmp_opt);
-        }
+    if (ret == 0) {
+        ret1 = dict_get_str(options, "key", &tmp_opt);
+        if (ret1)
+            tmp_opt = "";
+
+        gf_event(EVENT_VOLUME_RESET, "name=%s;option=%s", (char *)words[2],
+                 tmp_opt);
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_profile_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_profile_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                           const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
+    int sent = 0;
+    int parse_error = 0;
 
-        int                     ret      = -1;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
 
-        ret = cli_cmd_volume_profile_parse (words, wordcount, &options);
+    ret = cli_cmd_volume_profile_parse(words, wordcount, &options);
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROFILE_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROFILE_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume profile failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume profile failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_volume_set_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
+    int sent = 0;
+    int parse_error = 0;
 
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
-        char                    *op_errstr = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    char *op_errstr = NULL;
 
 #if (USE_EVENTS)
-        int                      ret1          = -1;
-        int                      i             = 1;
-        char                     dict_key[50]  = {0,};
-        char                    *tmp_opt       = NULL;
-        char                    *opts_str      = NULL;
-        int                      num_options   = 0;
+    int ret1 = -1;
+    int i = 1;
+    char dict_key[50] = {
+        0,
+    };
+    char *tmp_opt = NULL;
+    char *opts_str = NULL;
+    int num_options = 0;
 #endif
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SET_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SET_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_volume_set_parse(state, words, wordcount, &options,
+                                   &op_errstr);
+    if (ret) {
+        if (op_errstr) {
+            cli_err("%s", op_errstr);
+            GF_FREE(op_errstr);
+        } else
+            cli_usage_out(word->pattern);
 
-        ret = cli_cmd_volume_set_parse (state, words, wordcount,
-                                        &options, &op_errstr);
-        if (ret) {
-                if (op_errstr) {
-                    cli_err ("%s", op_errstr);
-                    GF_FREE (op_errstr);
-                } else
-                    cli_usage_out (word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-                parse_error = 1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume set failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume set failed");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0 && strcmp(words[2], "help") != 0) {
-                ret1 = dict_get_int32 (options, "count", &num_options);
-                if (ret1)
-                        num_options = 0;
-                else
-                        num_options = num_options/2;
+    if (ret == 0 && strcmp(words[2], "help") != 0) {
+        ret1 = dict_get_int32(options, "count", &num_options);
+        if (ret1) {
+            num_options = 0;
+            goto end;
+        } else {
+            num_options = num_options / 2;
+        }
 
-                /* Initialize opts_str */
-                opts_str = gf_strdup ("");
+        char *free_list_key[num_options];
+        char *free_list_val[num_options];
+        for (i = 0; i < num_options; i++) {
+            free_list_key[i] = NULL;
+            free_list_val[i] = NULL;
+        }
+        /* Initialize opts_str */
+        opts_str = "";
 
-                /* Prepare String in format options=KEY1,VALUE1,KEY2,VALUE2 */
-                for (i = 1; i <= num_options; i++) {
-                        sprintf (dict_key, "key%d", i);
-                        ret1 = dict_get_str (options, dict_key, &tmp_opt);
-                        if (ret1)
-                                tmp_opt = "";
+        /* Prepare String in format options=KEY1,VALUE1,KEY2,VALUE2 */
+        for (i = 1; i <= num_options; i++) {
+            sprintf(dict_key, "key%d", i);
+            ret1 = dict_get_str(options, dict_key, &tmp_opt);
+            if (ret1)
+                tmp_opt = "";
 
-                        gf_asprintf (&opts_str, "%s,%s", opts_str, tmp_opt);
+            gf_asprintf(&opts_str, "%s,%s", opts_str, tmp_opt);
+            free_list_key[i - 1] = opts_str;
 
-                        sprintf (dict_key, "value%d", i);
-                        ret1 = dict_get_str (options, dict_key, &tmp_opt);
-                        if (ret1)
-                                tmp_opt = "";
+            sprintf(dict_key, "value%d", i);
+            ret1 = dict_get_str(options, dict_key, &tmp_opt);
+            if (ret1)
+                tmp_opt = "";
 
-                        gf_asprintf (&opts_str, "%s,%s", opts_str, tmp_opt);
-                }
+            gf_asprintf(&opts_str, "%s,%s", opts_str, tmp_opt);
+            free_list_val[i - 1] = opts_str;
+        }
 
-                gf_event (EVENT_VOLUME_SET, "name=%s;options=%s",
-                          (char *)words[2],
-                          opts_str);
+        gf_event(EVENT_VOLUME_SET, "name=%s;options=%s", (char *)words[2],
+                 opts_str);
 
-                /* Allocated by gf_strdup and gf_asprintf */
-                GF_FREE (opts_str);
+        /* Allocated by gf_strdup and gf_asprintf */
+        for (i = 0; i < num_options; i++) {
+            GF_FREE(free_list_key[i]);
+            GF_FREE(free_list_val[i]);
         }
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+end:
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
-static
-int
-cli_event_remove_brick_str (dict_t *options, char **event_str,
-                            eventtypes_t *event)
+static int
+cli_event_remove_brick_str(dict_t *options, char **event_str,
+                           eventtypes_t *event)
 {
-        int           ret             = -1;
-        char          *bricklist      = NULL;
-        char          *brick          = NULL;
-        char          *volname        = NULL;
-        char           key[256]       = {0,};
-        const char    *eventstrformat = "volume=%s;bricks=%s";
-        int32_t        command        = 0;
-        int32_t        i              = 1;
-        int32_t        count          = 0;
-        int32_t        eventstrlen    = 1;
-        char          *tmp_ptr        = NULL;
-
-        if (!options || !event_str || !event)
-                goto out;
+    int ret = -1;
+    char *bricklist = NULL;
+    char *brick = NULL;
+    char *volname = NULL;
+    char key[256] = {
+        0,
+    };
+    const char *eventstrformat = "volume=%s;bricks=%s";
+    int32_t command = 0;
+    int32_t i = 1;
+    int32_t count = 0;
+    int32_t eventstrlen = 1;
+    int bricklen = 0;
+    char *tmp_ptr = NULL;
+
+    if (!options || !event_str || !event)
+        goto out;
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret || !volname) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch volname");
-                ret = -1;
-                goto out;
-        }
-        /* Get the list of bricks for the event */
-        ret = dict_get_int32 (options, "command", &command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch command");
-                ret = -1;
-                goto out;
-        }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret || !volname) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch volname");
+        ret = -1;
+        goto out;
+    }
+    /* Get the list of bricks for the event */
+    ret = dict_get_int32(options, "command", &command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch command");
+        ret = -1;
+        goto out;
+    }
 
-        switch (command) {
+    switch (command) {
         case GF_OP_CMD_START:
-                *event = EVENT_VOLUME_REMOVE_BRICK_START;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_START;
+            break;
         case GF_OP_CMD_COMMIT:
-                *event = EVENT_VOLUME_REMOVE_BRICK_COMMIT;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_COMMIT;
+            break;
         case GF_OP_CMD_COMMIT_FORCE:
-                *event = EVENT_VOLUME_REMOVE_BRICK_FORCE;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_FORCE;
+            break;
         case GF_OP_CMD_STOP:
-                *event = EVENT_VOLUME_REMOVE_BRICK_STOP;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_STOP;
+            break;
         default:
-                *event = EVENT_LAST;
-                break;
-        }
+            *event = EVENT_LAST;
+            break;
+    }
 
-        ret = -1;
+    ret = -1;
 
-        if (*event == EVENT_LAST) {
-                goto out;
-        }
+    if (*event == EVENT_LAST) {
+        goto out;
+    }
 
-        /* I could just get this from words[] but this is cleaner in case the
-         * format changes  */
-        while (i) {
-                snprintf (key, sizeof (key), "brick%d", i);
-                ret = dict_get_str (options, key, &brick);
-                if (ret) {
-                        break;
-                }
-                eventstrlen += strlen (brick) + 1;
-                i++;
+    /* I could just get this from words[] but this is cleaner in case the
+     * format changes  */
+    while (i) {
+        snprintf(key, sizeof(key), "brick%d", i);
+        ret = dict_get_str(options, key, &brick);
+        if (ret) {
+            break;
         }
+        eventstrlen += strlen(brick) + 1;
+        i++;
+    }
 
-        count = --i;
+    count = --i;
 
-        eventstrlen += 1;
+    eventstrlen += 1;
 
-        bricklist = GF_CALLOC (eventstrlen, sizeof (char), gf_common_mt_char);
-        if (!bricklist) {
-                goto out;
-        }
+    bricklist = GF_CALLOC(eventstrlen, sizeof(char), gf_common_mt_char);
+    if (!bricklist) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "memory allocation failed for"
+               "bricklist");
+        ret = -1;
+        goto out;
+    }
 
-        tmp_ptr = bricklist;
+    tmp_ptr = bricklist;
 
-        i = 1;
-        while (i <= count) {
-                snprintf (key, sizeof (key), "brick%d", i);
-                ret = dict_get_str (options, key, &brick);
-                if (ret) {
-                        break;
-                }
-                snprintf (tmp_ptr, eventstrlen, "%s ", brick);
-                eventstrlen -= (strlen (brick) + 1);
-                tmp_ptr += (strlen (brick) + 1);
-                i++;
+    i = 1;
+    while (i <= count) {
+        snprintf(key, sizeof(key), "brick%d", i);
+        ret = dict_get_str(options, key, &brick);
+        if (ret) {
+            break;
         }
+        snprintf(tmp_ptr, eventstrlen, "%s ", brick);
+        bricklen = strlen(brick);
+        eventstrlen -= (bricklen + 1);
+        tmp_ptr += (bricklen + 1);
+        i++;
+    }
 
-        if (!ret) {
-                gf_asprintf (event_str, eventstrformat, volname,
-                             bricklist);
-        } else {
-                gf_asprintf (event_str, eventstrformat, volname,
-                             "<unavailable>");
-        }
+    if (!ret) {
+        gf_asprintf(event_str, eventstrformat, volname, bricklist);
+    } else {
+        gf_asprintf(event_str, eventstrformat, volname, "<unavailable>");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (bricklist);
-        return ret;
+    GF_FREE(bricklist);
+    return ret;
 }
 
-
 int
-cli_cmd_volume_add_brick_cbk (struct cli_state *state,
-                              struct cli_cmd_word *word, const char **words,
-                              int wordcount)
+cli_cmd_volume_add_brick_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    cli_local_t *local = NULL;
 
 #if (USE_EVENTS)
-        char                    *event_str = NULL;
-        char                    *bricks = NULL;
-        const char              *eventstrformat = "volume=%s;bricks=%s";
+    char *event_str = NULL;
+    char *bricks = NULL;
+    const char *eventstrformat = "volume=%s;bricks=%s";
 #endif
 
-        const char *question = "Changing the 'stripe count' of the volume is "
-                "not a supported feature. In some cases it may result in data "
-                "loss on the volume. Also there may be issues with regular "
-                "filesystem operations on the volume after the change. Do you "
-                "really want to continue with 'stripe' count option ? ";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_volume_add_brick_parse (words, wordcount, &options, 0);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    const char *question =
+        "Changing the 'stripe count' of the volume is "
+        "not a supported feature. In some cases it may result in data "
+        "loss on the volume. Also there may be issues with regular "
+        "filesystem operations on the volume after the change. Do you "
+        "really want to continue with 'stripe' count option ? ";
+
+    ret = cli_cmd_volume_add_brick_parse(state, words, wordcount, &options, 0);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        /* TODO: there are challenges in supporting changing of
-           stripe-count, until it is properly supported give warning to user */
-        if (dict_get (options, "stripe-count")) {
-                answer = cli_cmd_get_confirmation (state, question);
+    /* TODO: there are challenges in supporting changing of
+       stripe-count, until it is properly supported give warning to user */
+    if (dict_get(options, "stripe-count")) {
+        answer = cli_cmd_get_confirmation(state, question);
 
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
 #if (USE_EVENTS)
-        /* Get the list of bricks for the event */
+    /* Get the list of bricks for the event */
 
-        ret = dict_get_str (options, "bricks", &bricks);
+    ret = dict_get_str(options, "bricks", &bricks);
 
-        if (!ret) {
-                gf_asprintf (&event_str, eventstrformat, (char *)words[2],
-                            &bricks[1] /*Skip leading space*/);
-        } else {
-                gf_asprintf (&event_str, eventstrformat, (char *)words[2],
-                            "<unavailable>");
-        }
+    if (!ret) {
+        gf_asprintf(&event_str, eventstrformat, (char *)words[2],
+                    &bricks[1] /*Skip leading space*/);
+    } else {
+        gf_asprintf(&event_str, eventstrformat, (char *)words[2],
+                    "<unavailable>");
+    }
 #endif
 
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set force "
+                   "option");
+            goto out;
         }
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_BRICK];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume add-brick failed");
-        } else {
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume add-brick failed");
+    } else {
 #if (USE_EVENTS)
-                gf_event (EVENT_VOLUME_ADD_BRICK, "%s", event_str);
-                GF_FREE (event_str);
+        gf_event(EVENT_VOLUME_ADD_BRICK, "%s", event_str);
+#endif
+    }
+#if (USE_EVENTS)
+    GF_FREE(event_str);
 #endif
-        }
-
-        CLI_STACK_DESTROY (frame);
-        return ret;
-}
-
-int
-cli_tier_validate_replica_type (dict_t *dict, int type)
-{
-
-        int             brick_count             = -1;
-        int             replica_count           = 1;
-        int             ret                     = -1;
-
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get brick count");
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "replica-count", &replica_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_DEBUG, "Failed to get replica count. "
-                        "Defaulting to one");
-                replica_count = 1;
-        }
 
-        /*
-         * Change the calculation of sub_count once attach-tier support
-         * disperse volume.
-         * sub_count = disperse_count for disperse volume
-         * */
-
-
-        if (brick_count % replica_count) {
-             if (type == GF_CLUSTER_TYPE_REPLICATE)
-                     cli_err ("number of bricks is not a multiple of "
-                              "replica count");
-             else if (type == GF_CLUSTER_TYPE_DISPERSE)
-                     cli_err ("number of bricks is not a multiple of "
-                              "disperse count");
-             else
-                     cli_err ("number of bricks given doesn't match "
-                              "required count");
-
-             ret = -1;
-             goto out;
-     }
-        ret = 0;
-out:
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-do_cli_cmd_volume_attach_tier (struct cli_state *state,
-                                struct cli_cmd_word *word, const char **words,
-                                int wordcount)
+cli_get_soft_limit(dict_t *options, const char **words, dict_t *xdata)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        int                     type = 0;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_volume_add_brick_parse (words, wordcount, &options, &type);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        /*
-         * Merge this check when attach-tier has it's own cli parse function.
-         */
-        ret = cli_tier_validate_replica_type (options, type);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (options, "attach-tier", 1);
-        if (ret)
-                goto out;
-
-        ret = dict_set_int32 (options, "hot-type", type);
-        if (ret)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_TIER_BRICK];
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    char *default_sl = NULL;
+    char *default_sl_dup = NULL;
+    int ret = -1;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    // We need a ref on @options to prevent CLI_STACK_DESTROY
+    // from destroying it prematurely.
+    dict_ref(options);
+    CLI_LOCAL_INIT(local, words, frame, options);
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
+    ret = proc->fn(frame, THIS, options);
+
+    ret = dict_get_str(options, "default-soft-limit", &default_sl);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get default soft limit");
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    default_sl_dup = gf_strdup(default_sl);
+    if (!default_sl_dup) {
+        ret = -1;
+        goto out;
+    }
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    ret = dict_set_dynstr(xdata, "default-soft-limit", default_sl_dup);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set default soft limit");
+        GF_FREE(default_sl_dup);
+        goto out;
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("attach-tier failed");
-        }
-
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-int
-do_cli_cmd_volume_detach_tier (struct cli_state *state,
-                              struct cli_cmd_word *word, const char **words,
-                              int wordcount, gf_boolean_t *aborted)
+/* Checks if at least one limit has been set on the volume
+ *
+ * Returns true if at least one limit is set. Returns false otherwise.
+ */
+gf_boolean_t
+_limits_set_on_volume(char *volname, int type)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        cli_local_t             *local = NULL;
-        int                     need_question = 0;
-
-        const char *question = "Removing tier can result in data loss. "
-                               "Do you want to Continue?";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_volume_detach_tier_parse(words, wordcount, &options,
-                                               &need_question);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        ret = dict_set_int32 (options, "force", 1);
-        if (ret)
-                goto out;
-
-        ret = dict_set_int32 (options, "count", 0);
-        if (ret)
-                goto out;
-
-        *aborted = _gf_false;
+    gf_boolean_t limits_set = _gf_false;
+    int ret = -1;
+    char quota_conf_file[PATH_MAX] = {
+        0,
+    };
+    int fd = -1;
+    char buf[16] = {
+        0,
+    };
+    float version = 0.0f;
+    char gfid_type_stored = 0;
+    char gfid_type = 0;
+
+    /* TODO: fix hardcoding; Need to perform an RPC call to glusterd
+     * to fetch working directory
+     */
+    snprintf(quota_conf_file, sizeof quota_conf_file, "%s/vols/%s/quota.conf",
+             GLUSTERD_DEFAULT_WORKDIR, volname);
+    fd = open(quota_conf_file, O_RDONLY);
+    if (fd == -1)
+        goto out;
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
-                /* we need to ask question only in case of 'commit or force' */
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        *aborted = _gf_true;
-                        goto out;
-                }
-        }
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_TIER_BRICK];
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        gfid_type = GF_QUOTA_CONF_TYPE_USAGE;
+    else
+        gfid_type = GF_QUOTA_CONF_TYPE_OBJECTS;
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    /* Try to read at least one gfid  of type 'gfid_type' */
+    while (1) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type_stored, version);
+        if (ret <= 0)
+            break;
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
+        if (gfid_type_stored == gfid_type) {
+            limits_set = _gf_true;
+            break;
         }
-
+    }
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume detach tier failed");
-        }
+    if (fd != -1)
+        sys_close(fd);
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    return limits_set;
 }
 
 int
-cli_cmd_volume_tier_cbk (struct cli_state *state,
-                         struct cli_cmd_word *word, const char **words,
-                         int wordcount)
+cli_cmd_quota_handle_list_all(const char **words, dict_t *options)
 {
-        int                      ret     = -1;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        cli_local_t             *local   = NULL;
-        int                      i       = 0;
-        eventtypes_t            event    = EVENT_LAST;
-        gf_boolean_t            aborted  = _gf_false;
-        gf_answer_t             answer   = GF_ANSWER_NO;
-
-        const char *detach_question = "gluster volume detach-tier <VOLNAME> "
-                               "<start|stop|status|commit|force> is "
-                               "deprecated. Use the new command \'"
-                               "gluster volume tier <VOLNAME> detach <start|"
-                               "stop|status|commit|force>\'\n"
-                               "Do you want to Continue?";
-
-        const char *attach_question = "gluster volume attach-tier <VOLNAME> "
-                               "[<replica COUNT>] <NEW-BRICK>... is "
-                               "deprecated. Use the new command \'"
-                               "gluster volume tier <VOLNAME> attach [<replica"
-                               " COUNT>] <NEW-BRICK>... [force]\'\n"
-                               "Do you want to Continue?";
-
-
-        if (wordcount < 4) {
-                if (wordcount == 3 && !strcmp(words[2], "help")) {
-                        cli_cmd_tier_help_cbk (state, word, words, wordcount);
-                        ret = 0;
-                } else {
-                        cli_usage_out (word->pattern);
-                }
-                goto out;
-        }
-
-        if (!strcmp(words[1], "detach-tier")) {
-                /* we need to ask question when older command is used */
-                answer = cli_cmd_get_confirmation (state, detach_question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-                ret = do_cli_cmd_volume_detach_tier (state, word,
-                                                     words, wordcount,
-                                                     &aborted);
-                goto out;
-        } else if (!strcmp(words[3], "detach")) {
-                for (i = 3; i < wordcount; i++)
-                        words[i] = words[i+1];
-
-                ret = do_cli_cmd_volume_detach_tier (state, word,
-                                                     words, wordcount-1,
-                                                     &aborted);
-                if (!aborted) {
-                        if (!strcmp (words[wordcount-2], "commit")) {
-                                event = EVENT_TIER_DETACH_COMMIT;
-                        } else if (!strcmp (words[wordcount-2], "start")) {
-                                event = EVENT_TIER_DETACH_START;
-                        } else if (!strcmp (words[wordcount-2], "stop")) {
-                                event = EVENT_TIER_DETACH_STOP;
-                        } else if (!strcmp (words[wordcount-2], "force")) {
-                                event = EVENT_TIER_DETACH_FORCE;
-                        }
-                }
-                goto out;
-
-        } else if (!strcmp(words[1], "attach-tier")) {
-                /* we need to ask question when the older command is used */
-                answer = cli_cmd_get_confirmation (state, attach_question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-                ret = do_cli_cmd_volume_attach_tier (state, word,
-                                                     words, wordcount);
-                goto out;
-        } else if (!strcmp(words[3], "attach")) {
-                for (i = 3; i < wordcount; i++)
-                        words[i] = words[i+1];
-
-                ret = do_cli_cmd_volume_attach_tier (state, word,
-                                                     words, wordcount-1);
-                if (!strcmp (words[wordcount-2], "force")) {
-                        event = EVENT_TIER_ATTACH_FORCE;
-                } else {
-                        event = EVENT_TIER_ATTACH;
-                }
-                goto out;
-        }
-
-        ret = cli_cmd_volume_tier_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        if (!strcmp (words[wordcount-1], "start")) {
-                event = EVENT_TIER_START;
-        } else {
-                if (!strcmp (words[wordcount-2], "start") &&
-                    !strcmp (words[wordcount-1], "force")) {
-                        event = EVENT_TIER_START_FORCE;
-                }
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TIER];
+    int all_failed = 1;
+    int count = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *xdata = NULL;
+    char gfid_str[UUID_CANONICAL_FORM_LEN + 1];
+    char *volname = NULL;
+    char *volname_dup = NULL;
+    unsigned char buf[16] = {0};
+    int fd = -1;
+    char quota_conf_file[PATH_MAX] = {0};
+    gf_boolean_t xml_err_flag = _gf_false;
+    char err_str[NAME_MAX] = {
+        0,
+    };
+    int32_t type = 0;
+    char gfid_type = 0;
+    float version = 0.0f;
+    int32_t max_count = 0;
+
+    xdata = dict_new();
+    if (!xdata) {
+        ret = -1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    ret = dict_get_int32(options, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get quota option type");
+        goto out;
+    }
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    ret = dict_set_int32(xdata, "type", type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set type in xdata");
+        goto out;
+    }
 
-out:
-        if (ret) {
-                cli_out ("Tier command failed");
+    ret = cli_get_soft_limit(options, words, xdata);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to fetch default "
+               "soft-limit");
+        goto out;
+    }
+
+    /* Check if at least one limit is set on volume. No need to check for
+     * quota enabled as cli_get_soft_limit() handles that
+     */
+    if (!_limits_set_on_volume(volname, type)) {
+        snprintf(err_str, sizeof(err_str),
+                 "No%s quota configured on"
+                 " volume %s",
+                 (type == GF_QUOTA_OPTION_TYPE_LIST) ? "" : " inode", volname);
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            xml_err_flag = _gf_true;
         } else {
-                if (event != EVENT_LAST) {
-                        gf_event (event, "vol=%s", words[2]);
-                }
-        }
-        if (options)
-                dict_unref (options);
-
-        return ret;
-}
-
-int
-cli_get_soft_limit (dict_t *options, const char **words, dict_t *xdata)
-{
-        call_frame_t            *frame          = NULL;
-        cli_local_t             *local          = NULL;
-        rpc_clnt_procedure_t    *proc           = NULL;
-        char                    *default_sl     = NULL;
-        char                    *default_sl_dup = NULL;
-        int                      ret  = -1;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
-
-        //We need a ref on @options to prevent CLI_STACK_DESTROY
-        //from destroying it prematurely.
-        dict_ref (options);
-        CLI_LOCAL_INIT (local, words, frame, options);
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
-        ret = proc->fn (frame, THIS, options);
-
-        ret = dict_get_str (options, "default-soft-limit", &default_sl);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get default soft limit");
-                goto out;
-        }
-
-        default_sl_dup = gf_strdup (default_sl);
-        if (!default_sl_dup) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (xdata, "default-soft-limit", default_sl_dup);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set default soft limit");
-                GF_FREE (default_sl_dup);
-                goto out;
+            cli_out("quota: %s", err_str);
         }
+        ret = 0;
+        goto out;
+    }
 
-out:
-        CLI_STACK_DESTROY (frame);
-        return ret;
-}
-
-/* Checks if at least one limit has been set on the volume
- *
- * Returns true if at least one limit is set. Returns false otherwise.
- */
-gf_boolean_t
-_limits_set_on_volume (char *volname, int type) {
-        gf_boolean_t    limits_set                = _gf_false;
-        int             ret                       = -1;
-        char            quota_conf_file[PATH_MAX] = {0,};
-        int             fd                        = -1;
-        char            buf[16]                   = {0,};
-        float           version                   = 0.0f;
-        char            gfid_type_stored          = 0;
-        char            gfid_type                 = 0;
-
-        /* TODO: fix hardcoding; Need to perform an RPC call to glusterd
-         * to fetch working directory
-         */
-        snprintf (quota_conf_file, sizeof quota_conf_file,
-                  "%s/vols/%s/quota.conf",
-                  GLUSTERD_DEFAULT_WORKDIR,
-                  volname);
-        fd = open (quota_conf_file, O_RDONLY);
-        if (fd == -1)
-                goto out;
+    volname_dup = gf_strdup(volname);
+    if (!volname_dup) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(xdata, "volume-uuid", volname_dup);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set volume-uuid");
+        GF_FREE(volname_dup);
+        goto out;
+    }
+
+    // TODO: fix hardcoding; Need to perform an RPC call to glusterd
+    // to fetch working directory
+    snprintf(quota_conf_file, sizeof quota_conf_file, "%s/vols/%s/quota.conf",
+             GLUSTERD_DEFAULT_WORKDIR, volname);
+    fd = open(quota_conf_file, O_RDONLY);
+    if (fd == -1) {
+        // This may because no limits were yet set on the volume
+        gf_log("cli", GF_LOG_TRACE,
+               "Unable to open "
+               "quota.conf");
+        ret = 0;
+        goto out;
+    }
 
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                gfid_type = GF_QUOTA_CONF_TYPE_USAGE;
-        else
-                gfid_type = GF_QUOTA_CONF_TYPE_OBJECTS;
-
-        /* Try to read atleast one gfid  of type 'gfid_type' */
-        while (1) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type_stored,
-                                            version);
-                if (ret <= 0)
-                        break;
-
-                if (gfid_type_stored == gfid_type) {
-                        limits_set = _gf_true;
-                        break;
-                }
-        }
-out:
-        if (fd != -1)
-                sys_close (fd);
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        return limits_set;
-}
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-int
-cli_cmd_quota_handle_list_all (const char **words, dict_t *options)
-{
-        int                      all_failed = 1;
-        int                      count      = 0;
-        int                      ret        = -1;
-        rpc_clnt_procedure_t    *proc       = NULL;
-        cli_local_t             *local      = NULL;
-        call_frame_t            *frame      = NULL;
-        dict_t                  *xdata      = NULL;
-        char                    *gfid_str   = NULL;
-        char                    *volname    = NULL;
-        char                    *volname_dup = NULL;
-        unsigned char            buf[16]   = {0};
-        int                      fd        = -1;
-        char                     quota_conf_file[PATH_MAX] = {0};
-        gf_boolean_t             xml_err_flag   = _gf_false;
-        char                     err_str[NAME_MAX] = {0,};
-        int32_t                  type       = 0;
-        char                     gfid_type  = 0;
-        float                    version    = 0.0f;
-        int32_t                  max_count  = 0;
-
-        xdata = dict_new ();
-        if (!xdata) {
-                ret = -1;
-                goto out;
-        }
+    CLI_LOCAL_INIT(local, words, frame, xdata);
+    proc = &cli_quotad_clnt.proctable[GF_AGGREGATOR_GETLIMIT];
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto out;
-        }
+    for (count = 0;; count++) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type, version);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            gf_log(THIS->name, GF_LOG_CRITICAL,
+                   "Quota "
+                   "configuration store may be corrupt.");
+            goto out;
+        }
+
+        if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
+             gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
+            (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
+             gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
+            continue;
+
+        max_count++;
+    }
+    ret = dict_set_int32(xdata, "max_count", max_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set max_count");
+        goto out;
+    }
+
+    ret = sys_lseek(fd, 0L, SEEK_SET);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to move offset to "
+               "the beginning: %s",
+               strerror(errno));
+        goto out;
+    }
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 (options, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota option type");
-                goto out;
+    for (count = 0;; count++) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type, version);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            gf_log(THIS->name, GF_LOG_CRITICAL,
+                   "Quota "
+                   "configuration store may be corrupt.");
+            goto out;
         }
 
-        ret = dict_set_int32 (xdata, "type", type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set type in xdata");
-                goto out;
-        }
+        if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
+             gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
+            (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
+             gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
+            continue;
 
-        ret = cli_get_soft_limit (options, words, xdata);
+        uuid_utoa_r(buf, gfid_str);
+        ret = dict_set_str(xdata, "gfid", gfid_str);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch default "
-                        "soft-limit");
-                goto out;
-        }
-
-        /* Check if at least one limit is set on volume. No need to check for
-         * quota enabled as cli_get_soft_limit() handles that
-         */
-        if (!_limits_set_on_volume (volname, type)) {
-                snprintf (err_str, sizeof (err_str), "No%s quota configured on"
-                          " volume %s",
-                          (type == GF_QUOTA_OPTION_TYPE_LIST) ? "" : " inode",
-                          volname);
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        xml_err_flag = _gf_true;
-                } else {
-                        cli_out ("quota: %s", err_str);
-                }
-                ret = 0;
-                goto out;
-        }
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
-
-        volname_dup = gf_strdup (volname);
-        if (!volname_dup) {
-                ret = -1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to set gfid");
+            goto out;
         }
 
-        ret = dict_set_dynstr (xdata, "volume-uuid", volname_dup);
+        ret = proc->fn(frame, THIS, xdata);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set volume-uuid");
-                GF_FREE (volname_dup);
-                goto out;
-        }
-
-        //TODO: fix hardcoding; Need to perform an RPC call to glusterd
-        //to fetch working directory
-        snprintf (quota_conf_file, sizeof quota_conf_file,
-                  "%s/vols/%s/quota.conf",
-                  GLUSTERD_DEFAULT_WORKDIR,
-                  volname);
-        fd = open (quota_conf_file, O_RDONLY);
-        if (fd == -1) {
-                //This may because no limits were yet set on the volume
-                gf_log ("cli", GF_LOG_TRACE, "Unable to open "
-                        "quota.conf");
-                ret = 0;
-                goto out;
-         }
-
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, xdata);
-        proc = &cli_quotad_clnt.proctable[GF_AGGREGATOR_GETLIMIT];
-
-        gfid_str = GF_CALLOC (1, gf_common_mt_char, 64);
-        if (!gfid_str) {
-                ret = -1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to get quota "
+                   "limits for %s",
+                   uuid_utoa((unsigned char *)buf));
         }
 
-        for (count = 0;; count++) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type, version);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        gf_log (THIS->name, GF_LOG_CRITICAL, "Quota "
-                                "configuration store may be corrupt.");
-                        goto out;
-                }
-
-                if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
-                    (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
-                        continue;
+        dict_del(xdata, "gfid");
+        all_failed = all_failed && ret;
+    }
 
-                max_count++;
-        }
-        ret = dict_set_int32 (xdata, "max_count", max_count);
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_quota_limit_list_end(local);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set max_count");
-                goto out;
-        }
-
-        ret = sys_lseek (fd, 0L, SEEK_SET);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to move offset to "
-                        "the beginning: %s", strerror (errno));
-                goto out;
-        }
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
-
-        for (count = 0;; count++) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type, version);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        gf_log (THIS->name, GF_LOG_CRITICAL, "Quota "
-                                "configuration store may be corrupt.");
-                        goto out;
-                }
-
-                if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
-                    (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
-                        continue;
-
-                uuid_utoa_r (buf, gfid_str);
-                ret = dict_set_str (xdata, "gfid", gfid_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set gfid");
-                        goto out;
-                }
-
-                ret = proc->fn (frame, THIS, xdata);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get quota "
-                                "limits for %s", uuid_utoa ((unsigned char*)buf));
-                }
-
-                dict_del (xdata, "gfid");
-                all_failed = all_failed && ret;
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_quota_limit_list_end (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error in printing "
-                                "xml output");
-                        goto out;
-                }
-        }
-
-        if (count > 0) {
-                ret = all_failed? -1: 0;
-        } else {
-                ret = 0;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error in printing "
+                   "xml output");
+            goto out;
         }
+    }
 
+    if (count > 0) {
+        ret = all_failed ? -1 : 0;
+    } else {
+        ret = 0;
+    }
 
 out:
-        if (xml_err_flag) {
-                ret = cli_xml_output_str ("volQuota", NULL, -1, 0, err_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting in "
-                                "xml format");
-                }
-        }
-
-        if (fd != -1) {
-                sys_close (fd);
-        }
-
-        GF_FREE (gfid_str);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch and display quota"
-                        " limits");
-        }
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (xml_err_flag) {
+        ret = cli_xml_output_str("volQuota", NULL, -1, 0, err_str);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error outputting in "
+                   "xml format");
+        }
+    }
+    if (xdata)
+        dict_unref(xdata);
+
+    if (fd != -1) {
+        sys_close(fd);
+    }
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not fetch and display quota"
+               " limits");
+    }
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
-
 int
-cli_cmd_bitrot_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                    const char **words, int wordcount)
+cli_cmd_bitrot_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                   const char **words, int wordcount)
 {
-
-        int                     ret        = -1;
-        int                     parse_err  = 0;
-        call_frame_t            *frame     = NULL;
-        dict_t                  *options   = NULL;
-        cli_local_t             *local     = NULL;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        int                     sent       = 0;
+    int ret = -1;
+    int parse_err = 0;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    int sent = 0;
 #if (USE_EVENTS)
-        int                     cmd_type        = -1;
-        int                     ret1            = -1;
-        int                     event_type      = -1;
-        char                    *tmp            = NULL;
-        char                    *events_str     = NULL;
+    int cmd_type = -1;
+    int ret1 = -1;
+    int event_type = -1;
+    char *tmp = NULL;
+    char *events_str = NULL;
+    char *volname = NULL;
 #endif
 
-        ret = cli_cmd_bitrot_parse (words, wordcount, &options);
-        if (ret < 0) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    ret = cli_cmd_bitrot_parse(words, wordcount, &options);
+    if (ret < 0) {
+        cli_usage_out(word->pattern);
+        parse_err = 1;
+        goto out;
+    }
 
-        if (ret == 1) {
-                /* this is 'volume bitrot help' */
-                cli_cmd_bitrot_help_cbk (state, word, words, wordcount);
-                ret = 0;
-                goto out2;
-        }
+    if (ret == 1) {
+        /* this is 'volume bitrot help' */
+        cli_cmd_bitrot_help_cbk(state, word, words, wordcount);
+        ret = 0;
+        goto out2;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BITROT];
-        if (proc == NULL) {
-                ret = -1;
-                goto out;
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BITROT];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_err == 0))
-                    cli_err ("Bit rot command failed. Please check the cli "
-                             "logs for more details");
-
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_err == 0))
+            cli_err(
+                "Bit rot command failed. Please check the cli "
+                "logs for more details");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                ret1 = dict_get_int32 (options, "type", &cmd_type);
+    if (ret == 0) {
+        ret1 = dict_get_int32(options, "type", &cmd_type);
+        if (ret1)
+            cmd_type = -1;
+        else {
+            ret1 = dict_get_str(options, "volname", &volname);
+            if (ret1)
+                volname = "";
+        }
+
+        switch (cmd_type) {
+            case GF_BITROT_OPTION_TYPE_ENABLE:
+                event_type = EVENT_BITROT_ENABLE;
+                break;
+            case GF_BITROT_OPTION_TYPE_DISABLE:
+                event_type = EVENT_BITROT_DISABLE;
+                break;
+            case GF_BITROT_CMD_SCRUB_ONDEMAND:
+                event_type = EVENT_BITROT_SCRUB_ONDEMAND;
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
+                event_type = EVENT_BITROT_SCRUB_THROTTLE;
+                ret1 = dict_get_str(options, "scrub-throttle-value", &tmp);
                 if (ret1)
-                        cmd_type = -1;
-                else {
-                        ret1 = dict_get_str (options, "volname", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "name=%s", tmp);
-                }
-
-                switch (cmd_type) {
-                case GF_BITROT_OPTION_TYPE_ENABLE:
-                        event_type = EVENT_BITROT_ENABLE;
-                        break;
-                case GF_BITROT_OPTION_TYPE_DISABLE:
-                        event_type = EVENT_BITROT_DISABLE;
-                        break;
-                case GF_BITROT_CMD_SCRUB_ONDEMAND:
-                        event_type = EVENT_BITROT_SCRUB_ONDEMAND;
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
-                        event_type = EVENT_BITROT_SCRUB_THROTTLE;
-                        ret1 = dict_get_str (options, "scrub-throttle-value",
-                                             &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
-                        event_type = EVENT_BITROT_SCRUB_FREQ;
-                        ret1 = dict_get_str (options, "scrub-frequency-value",
-                                             &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB:
-                        event_type = EVENT_BITROT_SCRUB_OPTION;
-                        ret1 = dict_get_str (options, "scrub-value", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                default:
-                        break;
-                }
+                    tmp = "";
+                gf_asprintf(&events_str, "name=%s;value=%s", volname, tmp);
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
+                event_type = EVENT_BITROT_SCRUB_FREQ;
+                ret1 = dict_get_str(options, "scrub-frequency-value", &tmp);
+                if (ret1)
+                    tmp = "";
+                gf_asprintf(&events_str, "name=%s;value=%s", volname, tmp);
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB:
+                event_type = EVENT_BITROT_SCRUB_OPTION;
+                ret1 = dict_get_str(options, "scrub-value", &tmp);
+                if (ret1)
+                    tmp = "";
+                gf_asprintf(&events_str, "name=%s;value=%s", volname, tmp);
+                break;
+            default:
+                break;
+        }
 
-                if (event_type > -1)
-                        gf_event (event_type, "%s", events_str);
+        if (event_type > -1)
+            gf_event(event_type, "%s", events_str);
 
-                if (events_str)
-                        GF_FREE (events_str);
-        }
+        if (events_str)
+            GF_FREE(events_str);
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 out2:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_quota_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_quota_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-
-        int                      ret       = 0;
-        int                      parse_err = 0;
-        int32_t                  type      = 0;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        call_frame_t            *frame     = NULL;
-        dict_t                  *options   = NULL;
-        gf_answer_t              answer    = GF_ANSWER_NO;
-        cli_local_t             *local     = NULL;
-        int                      sent      = 0;
-        char                    *volname   = NULL;
-        const char *question = "Disabling quota will delete all the quota "
-                               "configuration. Do you want to continue?";
-
-        //parse **words into options dictionary
-        if (strcmp (words[1], "inode-quota") == 0) {
-                ret = cli_cmd_inode_quota_parse (words, wordcount, &options);
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                        goto out;
-                }
-        } else {
-                ret = cli_cmd_quota_parse (words, wordcount, &options);
-
-                if (ret == 1) {
-                        cli_cmd_quota_help_cbk (state, word, words, wordcount);
-                        ret = 0;
-                        goto out;
-                }
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                        goto out;
-                }
+    int ret = 0;
+    int parse_err = 0;
+    int32_t type = 0;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    cli_local_t *local = NULL;
+    int sent = 0;
+    char *volname = NULL;
+    const char *question =
+        "Disabling quota will delete all the quota "
+        "configuration. Do you want to continue?";
+
+    // parse **words into options dictionary
+    if (strcmp(words[1], "inode-quota") == 0) {
+        ret = cli_cmd_inode_quota_parse(words, wordcount, &options);
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+            goto out;
         }
+    } else {
+        ret = cli_cmd_quota_parse(words, wordcount, &options);
 
-        ret = dict_get_int32 (options, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get opcode");
-                goto out;
+        if (ret == 1) {
+            cli_cmd_quota_help_cbk(state, word, words, wordcount);
+            ret = 0;
+            goto out;
+        }
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+            goto out;
         }
+    }
 
-        //handle quota-disable and quota-list-all different from others
-        switch (type) {
+    ret = dict_get_int32(options, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get opcode");
+        goto out;
+    }
+
+    // handle quota-disable and quota-list-all different from others
+    switch (type) {
         case GF_QUOTA_OPTION_TYPE_DISABLE:
-                answer = cli_cmd_get_confirmation (state, question);
-                if (answer == GF_ANSWER_NO)
-                        goto out;
-                break;
+            answer = cli_cmd_get_confirmation(state, question);
+            if (answer == GF_ANSWER_NO)
+                goto out;
+            break;
         case GF_QUOTA_OPTION_TYPE_LIST:
         case GF_QUOTA_OPTION_TYPE_LIST_OBJECTS:
-                if (wordcount != 4)
-                        break;
-                ret = cli_cmd_quota_handle_list_all (words, options);
-                goto out;
-        default:
+            if (wordcount != 4)
                 break;
-        }
+            ret = cli_cmd_quota_handle_list_all(words, options);
+            goto out;
+        default:
+            break;
+    }
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto out;
-        }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
+    CLI_LOCAL_INIT(local, words, frame, options);
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if (sent == 0 && parse_err == 0)
-                        cli_out ("Quota command failed. Please check the cli "
-                                 "logs for more details");
-        }
-
-        /* Events for Quota */
-         if (ret == 0) {
-                switch (type) {
-                case GF_QUOTA_OPTION_TYPE_ENABLE:
-                        gf_event (EVENT_QUOTA_ENABLE, "volume=%s", volname);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_DISABLE:
-                        gf_event (EVENT_QUOTA_DISABLE, "volume=%s", volname);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_LIMIT_USAGE:
-                        gf_event (EVENT_QUOTA_SET_USAGE_LIMIT, "volume=%s;"
-                                  "path=%s;limit=%s", volname, words[4],
-                                  words[5]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS:
-                        gf_event (EVENT_QUOTA_SET_OBJECTS_LIMIT, "volume=%s;"
-                                  "path=%s;limit=%s", volname, words[4],
-                                  words[5]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_REMOVE:
-                        gf_event (EVENT_QUOTA_REMOVE_USAGE_LIMIT, "volume=%s;"
-                                  "path=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS:
-                        gf_event (EVENT_QUOTA_REMOVE_OBJECTS_LIMIT,
-                                  "volume=%s;" "path=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_ALERT_TIME:
-                        gf_event (EVENT_QUOTA_ALERT_TIME, "volume=%s;time=%s",
-                                  volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT:
-                        gf_event (EVENT_QUOTA_SOFT_TIMEOUT, "volume=%s;"
-                                  "soft-timeout=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT:
-                        gf_event (EVENT_QUOTA_HARD_TIMEOUT, "volume=%s;"
-                                  "hard-timeout=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT:
-                        gf_event (EVENT_QUOTA_DEFAULT_SOFT_LIMIT, "volume=%s;"
-                                  "default-soft-limit=%s", volname, words[4]);
-                        break;
-                }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if (sent == 0 && parse_err == 0)
+            cli_out(
+                "Quota command failed. Please check the cli "
+                "logs for more details");
+    }
+    if (options)
+        dict_unref(options);
+
+    /* Events for Quota */
+    if (ret == 0) {
+        switch (type) {
+            case GF_QUOTA_OPTION_TYPE_ENABLE:
+                gf_event(EVENT_QUOTA_ENABLE, "volume=%s", volname);
+                break;
+            case GF_QUOTA_OPTION_TYPE_DISABLE:
+                gf_event(EVENT_QUOTA_DISABLE, "volume=%s", volname);
+                break;
+            case GF_QUOTA_OPTION_TYPE_LIMIT_USAGE:
+                gf_event(EVENT_QUOTA_SET_USAGE_LIMIT,
+                         "volume=%s;"
+                         "path=%s;limit=%s",
+                         volname, words[4], words[5]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS:
+                gf_event(EVENT_QUOTA_SET_OBJECTS_LIMIT,
+                         "volume=%s;"
+                         "path=%s;limit=%s",
+                         volname, words[4], words[5]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_REMOVE:
+                gf_event(EVENT_QUOTA_REMOVE_USAGE_LIMIT,
+                         "volume=%s;"
+                         "path=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS:
+                gf_event(EVENT_QUOTA_REMOVE_OBJECTS_LIMIT,
+                         "volume=%s;"
+                         "path=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_ALERT_TIME:
+                gf_event(EVENT_QUOTA_ALERT_TIME, "volume=%s;time=%s", volname,
+                         words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT:
+                gf_event(EVENT_QUOTA_SOFT_TIMEOUT,
+                         "volume=%s;"
+                         "soft-timeout=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT:
+                gf_event(EVENT_QUOTA_HARD_TIMEOUT,
+                         "volume=%s;"
+                         "hard-timeout=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT:
+                gf_event(EVENT_QUOTA_DEFAULT_SOFT_LIMIT,
+                         "volume=%s;"
+                         "default-soft-limit=%s",
+                         volname, words[4]);
+                break;
         }
+    }
 
-
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_volume_remove_brick_cbk (struct cli_state *state,
-                                 struct cli_cmd_word *word, const char **words,
-                                 int wordcount)
+cli_cmd_volume_remove_brick_cbk(struct cli_state *state,
+                                struct cli_cmd_word *word, const char **words,
+                                int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        int                     brick_count = 0;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        int                     need_question = 0;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    int brick_count = 0;
+    int sent = 0;
+    int parse_error = 0;
+    int need_question = 0;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
 #if (USE_EVENTS)
-        eventtypes_t            event = EVENT_LAST;
-        char                    *event_str = NULL;
-        int                     event_ret = -1;
+    eventtypes_t event = EVENT_LAST;
+    char *event_str = NULL;
+    int event_ret = -1;
 #endif
-        const char *question = "Removing brick(s) can result in data loss. "
-                               "Do you want to Continue?";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_volume_remove_brick_parse (words, wordcount, &options,
-                                                 &need_question, &brick_count);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-        if (!brick_count) {
-                cli_err ("No bricks specified");
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret || !volname) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch volname");
-                ret = -1;
-                goto out;
-        }
+    int32_t command = GF_OP_CMD_NONE;
+    char *question = NULL;
+
+    ret = cli_cmd_volume_remove_brick_parse(state, words, wordcount, &options,
+                                            &need_question, &brick_count,
+                                            &command);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    if (command == GF_OP_CMD_COMMIT_FORCE) {
+        question =
+            "Remove-brick force will not migrate files from the "
+            "removed bricks, so they will no longer be available"
+            " on the volume.\nDo you want to continue?";
+    } else if (command == GF_OP_CMD_START) {
+        question =
+            "It is recommended that remove-brick be run with"
+            " cluster.force-migration option disabled to prevent"
+            " possible data corruption. Doing so will ensure that"
+            " files that receive writes during migration will not"
+            " be migrated and will need to be manually copied"
+            " after the remove-brick commit operation. Please"
+            " check the value of the option and update accordingly."
+            " \nDo you want to continue with your current"
+            " cluster.force-migration settings?";
+    }
+
+    if (!brick_count) {
+        cli_err("No bricks specified");
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret || !volname) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch volname");
+        ret = -1;
+        goto out;
+    }
 
 #if (USE_EVENTS)
-        event_ret = cli_event_remove_brick_str (options, &event_str, &event);
+    event_ret = cli_event_remove_brick_str(options, &event_str, &event);
 #endif
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Removing brick from the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
-                need_question = _gf_true;
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Removing brick from the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+        need_question = _gf_true;
+    }
+
+    if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
-                /* we need to ask question only in case of 'commit or force' */
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_BRICK];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_BRICK];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume remove-brick failed");
-        } else {
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume remove-brick failed");
+    }
 #if (USE_EVENTS)
-                if (!event_ret) {
-                        gf_event (event, "%s", event_str);
-                        GF_FREE (event_str);
-                }
-#endif
-        }
-
-        CLI_STACK_DESTROY (frame);
+    if (!ret && !event_ret)
+        gf_event(event, "%s", event_str);
+    if (event_str)
+        GF_FREE(event_str);
 
+#endif
 
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    if (options)
+        dict_unref(options);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_reset_brick_cbk (struct cli_state *state,
-                                struct cli_cmd_word *word,
-                                const char **words,
-                                int wordcount)
+cli_cmd_volume_reset_brick_cbk(struct cli_state *state,
+                               struct cli_cmd_word *word, const char **words,
+                               int wordcount)
 {
-        int                      ret          = -1;
-        rpc_clnt_procedure_t    *proc         = NULL;
-        call_frame_t            *frame        = NULL;
-        dict_t                  *options      = NULL;
-        int                      sent         = 0;
-        int                      parse_error  = 0;
-        cli_local_t             *local        = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_BRICK];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_volume_reset_brick_parse(words, wordcount, &options);
 
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_volume_reset_brick_parse (words, wordcount, &options);
-
+    if (state->mode & GLUSTER_MODE_WIGNORE_PARTITION) {
+        ret = dict_set_int32(options, "ignore-partition", _gf_true);
         if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set ignore-"
+                   "partition option");
+            goto out;
         }
+    }
 
-        if (state->mode & GLUSTER_MODE_WIGNORE_PARTITION) {
-                ret = dict_set_int32 (options, "ignore-partition", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set ignore-"
-                                "partition option");
-                        goto out;
-                }
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume reset-brick failed");
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume reset-brick failed");
+    } else {
+        if (wordcount > 5) {
+            gf_event(EVENT_BRICK_RESET_COMMIT,
+                     "Volume=%s;source-brick=%s;"
+                     "destination-brick=%s",
+                     (char *)words[2], (char *)words[3], (char *)words[4]);
         } else {
-                if (wordcount > 5) {
-                        gf_event (EVENT_BRICK_RESET_COMMIT,
-                                  "Volume=%s;source-brick=%s;"
-                                  "destination-brick=%s",
-                                  (char *)words[2], (char *)words[3],
-                                  (char *)words[4]);
-                } else {
-                        gf_event (EVENT_BRICK_RESET_START,
-                                  "Volume=%s;source-brick=%s",
-                                  (char *)words[2], (char *)words[3]);
-                }
+            gf_event(EVENT_BRICK_RESET_START, "Volume=%s;source-brick=%s",
+                     (char *)words[2], (char *)words[3]);
         }
-        CLI_STACK_DESTROY (frame);
+    }
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_replace_brick_cbk (struct cli_state *state,
-                                  struct cli_cmd_word *word,
-                                  const char **words,
-                                  int wordcount)
+cli_cmd_volume_replace_brick_cbk(struct cli_state *state,
+                                 struct cli_cmd_word *word, const char **words,
+                                 int wordcount)
 {
-        int                      ret          = -1;
-        rpc_clnt_procedure_t    *proc         = NULL;
-        call_frame_t            *frame        = NULL;
-        dict_t                  *options = NULL;
-        int                      sent = 0;
-        int                      parse_error = 0;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REPLACE_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REPLACE_BRICK];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_volume_replace_brick_parse(words, wordcount, &options);
 
-        ret = cli_cmd_volume_replace_brick_parse (words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume replace-brick failed");
-        } else {
-                gf_event (EVENT_BRICK_REPLACE,
-                          "Volume=%s;source-brick=%s;destination-brick=%s",
-                          (char *)words[2], (char *)words[3], (char *)words[4]);
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume replace-brick failed");
+    } else {
+        gf_event(EVENT_BRICK_REPLACE,
+                 "Volume=%s;source-brick=%s;destination-brick=%s",
+                 (char *)words[2], (char *)words[3], (char *)words[4]);
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
-
 int
-cli_cmd_volume_set_transport_cbk (struct cli_state *state,
-                                  struct cli_cmd_word *word,
-                                  const char **words, int wordcount)
+cli_cmd_volume_set_transport_cbk(struct cli_state *state,
+                                 struct cli_cmd_word *word, const char **words,
+                                 int wordcount)
 {
-        cli_cmd_broadcast_response (0);
-        return 0;
+    cli_cmd_broadcast_response(0);
+    return 0;
 }
 
 int
-cli_cmd_volume_top_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_top_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    ret = cli_cmd_volume_top_parse(words, wordcount, &options);
+
+    if (ret) {
+        parse_error = 1;
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        int                     ret      = -1;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        int                     sent     = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        ret = cli_cmd_volume_top_parse (words, wordcount, &options);
-
-        if (ret) {
-                parse_error = 1;
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TOP_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TOP_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume top failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume top failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
-
 int
-cli_cmd_log_rotate_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_log_rotate_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        if (!((wordcount == 4) || (wordcount == 5))) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (!((wordcount == 4) || (wordcount == 5))) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (!((strcmp ("rotate", words[2]) == 0) ||
-              (strcmp ("rotate", words[3]) == 0))) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (!(strcmp("rotate", words[3]) == 0)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LOG_ROTATE];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LOG_ROTATE];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    ret = cli_cmd_log_rotate_parse(words, wordcount, &options);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_log_rotate_parse (words, wordcount, &options);
-        if (ret)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume log rotate failed");
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume log rotate failed");
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
 #if (SYNCDAEMON_COMPILE)
 static int
-cli_check_gsync_present ()
+cli_check_gsync_present()
 {
-        char                buff[PATH_MAX] = {0, };
-        runner_t            runner = {0,};
-        char                *ptr = NULL;
-        int                 ret = 0;
-
-        ret = setenv ("_GLUSTERD_CALLED_", "1", 1);
-        if (-1 == ret) {
-                gf_log ("", GF_LOG_WARNING, "setenv syscall failed, hence could"
-                        "not assert if geo-replication is installed");
-                goto out;
-        }
-
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "--version", NULL);
-        runner_redir (&runner, STDOUT_FILENO, RUN_PIPE);
-        ret = runner_start (&runner);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_INFO, "geo-replication not installed");
-                goto out;
-        }
+    char buff[PATH_MAX] = {
+        0,
+    };
+    runner_t runner = {
+        0,
+    };
+    char *ptr = NULL;
+    int ret = 0;
+
+    ret = setenv("_GLUSTERD_CALLED_", "1", 1);
+    if (-1 == ret) {
+        gf_log("", GF_LOG_WARNING,
+               "setenv syscall failed, hence could"
+               "not assert if geo-replication is installed");
+        goto out;
+    }
+
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "--version", NULL);
+    runner_redir(&runner, STDOUT_FILENO, RUN_PIPE);
+    ret = runner_start(&runner);
+    if (ret == -1) {
+        gf_log("", GF_LOG_INFO, "geo-replication not installed");
+        goto out;
+    }
 
-        ptr = fgets(buff, sizeof(buff), runner_chio (&runner, STDOUT_FILENO));
-        if (ptr) {
-                if (!strstr (buff, "gsyncd")) {
-                        ret  = -1;
-                        goto out;
-                }
-        } else {
-                ret = -1;
-                goto out;
+    ptr = fgets(buff, sizeof(buff), runner_chio(&runner, STDOUT_FILENO));
+    if (ptr) {
+        if (!strstr(buff, "gsyncd")) {
+            ret = -1;
+            goto out;
         }
+    } else {
+        ret = -1;
+        goto out;
+    }
 
-        ret = runner_end (&runner);
+    ret = runner_end(&runner);
 
-        if (ret)
-                gf_log ("", GF_LOG_ERROR, "geo-replication not installed");
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "geo-replication not installed");
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret ? -1 : 0;
-
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret ? -1 : 0;
 }
 
 void
-cli_cmd_check_gsync_exists_cbk (struct cli_cmd *this)
+cli_cmd_check_gsync_exists_cbk(struct cli_cmd *this)
 {
+    int ret = 0;
 
-        int             ret = 0;
-
-        ret = cli_check_gsync_present ();
-        if (ret)
-                this->disable = _gf_true;
-
+    ret = cli_check_gsync_present();
+    if (ret)
+        this->disable = _gf_true;
 }
 #endif
 
 int
-cli_cmd_volume_gsync_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount)
+cli_cmd_volume_gsync_set_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                      ret     = 0;
-        int                      parse_err = 0;
-        dict_t                  *options = NULL;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        cli_local_t             *local   = NULL;
+    int ret = 0;
+    int parse_err = 0;
+    dict_t *options = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    char *errstr = NULL;
 #if (USE_EVENTS)
-        int                      ret1       = -1;
-        int                      cmd_type   = -1;
-        int                      tmpi       = 0;
-        char                    *tmp        = NULL;
-        char                    *events_str = NULL;
-        int                      event_type = -1;
+    int ret1 = -1;
+    int cmd_type = -1;
+    int tmpi = 0;
+    char *tmp = NULL;
+    char *events_str = NULL;
+    int event_type = -1;
 #endif
 
-        proc = &cli_rpc_prog->proctable [GLUSTER_CLI_GSYNC_SET];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GSYNC_SET];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (frame == NULL) {
-                ret = -1;
-                goto out;
+    ret = cli_cmd_gsync_set_parse(state, words, wordcount, &options, &errstr);
+    if (ret) {
+        if (errstr) {
+            cli_err("%s", errstr);
+            GF_FREE(errstr);
+        } else {
+            cli_usage_out(word->pattern);
         }
+        parse_err = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_gsync_set_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (frame == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret && parse_err == 0)
-                cli_out (GEOREP" command failed");
+    if (ret && parse_err == 0)
+        cli_out(GEOREP " command failed");
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                events_str = gf_strdup ("");
-
-                /* Type of Geo-rep Action - Create, Start etc */
-                ret1 = dict_get_int32 (options, "type", &cmd_type);
+    if (ret == 0) {
+        events_str = gf_strdup("");
+
+        /* Type of Geo-rep Action - Create, Start etc */
+        ret1 = dict_get_int32(options, "type", &cmd_type);
+        if (ret1)
+            cmd_type = -1;
+
+        /* Only capture Events for modification commands */
+        switch (cmd_type) {
+            case GF_GSYNC_OPTION_TYPE_CREATE:
+                event_type = EVENT_GEOREP_CREATE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_START:
+                event_type = EVENT_GEOREP_START;
+                break;
+            case GF_GSYNC_OPTION_TYPE_STOP:
+                event_type = EVENT_GEOREP_STOP;
+                break;
+            case GF_GSYNC_OPTION_TYPE_PAUSE:
+                event_type = EVENT_GEOREP_PAUSE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_RESUME:
+                event_type = EVENT_GEOREP_RESUME;
+                break;
+            case GF_GSYNC_OPTION_TYPE_DELETE:
+                event_type = EVENT_GEOREP_DELETE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_CONFIG:
+                ret1 = dict_get_str(options, "subop", &tmp);
                 if (ret1)
-                        cmd_type = -1;
-
-                /* Only capture Events for modification commands */
-                switch (cmd_type) {
-                case GF_GSYNC_OPTION_TYPE_CREATE:
-                        event_type = EVENT_GEOREP_CREATE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_START:
-                        event_type = EVENT_GEOREP_START;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_STOP:
-                        event_type = EVENT_GEOREP_STOP;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_PAUSE:
-                        event_type = EVENT_GEOREP_PAUSE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_RESUME:
-                        event_type = EVENT_GEOREP_RESUME;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_DELETE:
-                        event_type = EVENT_GEOREP_DELETE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_CONFIG:
-                        ret1 = dict_get_str (options, "subop", &tmp);
-                        if (ret1)
-                                tmp = "";
-
-                        /* For Config Set additionally capture key and value */
-                        /* For Config Reset capture key */
-                        if (strcmp (tmp, "set") == 0) {
-                                event_type = EVENT_GEOREP_CONFIG_SET;
-
-                                ret1 = dict_get_str (options, "op_name", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%soption=%s;",
-                                             events_str, tmp);
-
-                                ret1 = dict_get_str (options, "op_value", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%svalue=%s;",
-                                             events_str, tmp);
-                        } else if (strcmp (tmp, "del") == 0) {
-                                event_type = EVENT_GEOREP_CONFIG_RESET;
-
-                                ret1 = dict_get_str (options, "op_name", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%soption=%s;",
-                                             events_str, tmp);
-                        }
-                        break;
-                default:
-                        break;
-                }
+                    tmp = "";
 
-                if (event_type > -1) {
-                        /* Capture all optional arguments used */
-                        ret1 = dict_get_int32 (options, "force", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sforce=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "push_pem", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%spush_pem=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "no_verify", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sno_verify=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "ssh_port", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sssh_port=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "reset-sync-time",
-                                               &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str,
-                                             "%sreset_sync_time=%d;",
-                                             events_str, tmpi);
-
-                        /* Capture Master and Slave Info */
-                        ret1 = dict_get_str (options, "master", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%smaster=%s;",
-                                     events_str, tmp);
-
-                        ret1 = dict_get_str (options, "slave", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%sslave=%s",
-                                     events_str, tmp);
-
-                        gf_event (event_type, "%s", events_str);
-                }
+                /* For Config Set additionally capture key and value */
+                /* For Config Reset capture key */
+                if (strcmp(tmp, "set") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_SET;
 
-                /* Allocated by gf_strdup and gf_asprintf */
-                GF_FREE (events_str);
-        }
-#endif
+                    ret1 = dict_get_str(options, "op_name", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-        CLI_STACK_DESTROY (frame);
+                    gf_asprintf_append(&events_str, "%soption=%s;", events_str,
+                                       tmp);
 
-        return ret;
-}
+                    ret1 = dict_get_str(options, "op_value", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-int
-cli_cmd_volume_status_cbk (struct cli_state *state,
-                           struct cli_cmd_word *word,
-                           const char **words, int wordcount)
-{
-        int                   ret         = -1;
-        rpc_clnt_procedure_t *proc        = NULL;
-        call_frame_t         *frame       = NULL;
-        dict_t               *dict        = NULL;
-        uint32_t              cmd         = 0;
-        cli_local_t          *local       = NULL;
+                    gf_asprintf_append(&events_str, "%svalue=%s;", events_str,
+                                       tmp);
+                } else if (strcmp(tmp, "del") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_RESET;
 
-        ret = cli_cmd_volume_status_parse (words, wordcount, &dict);
-
-        if (ret) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
+                    ret1 = dict_get_str(options, "op_name", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-        if (!(cmd & GF_CLI_STATUS_ALL)) {
-                /* for one volume or brick */
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_VOLUME];
-        } else {
-                /* volume status all or all detail */
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_ALL];
+                    gf_asprintf_append(&events_str, "%soption=%s;", events_str,
+                                       tmp);
+                }
+                break;
+            default:
+                break;
         }
 
-        if (!proc->fn)
-                goto out;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        ret = proc->fn (frame, THIS, dict);
+        if (event_type > -1) {
+            /* Capture all optional arguments used */
+            ret1 = dict_get_int32(options, "force", &tmpi);
+            if (ret1 == 0) {
+                gf_asprintf_append(&events_str, "%sforce=%d;", events_str,
+                                   tmpi);
+            }
+            ret1 = dict_get_int32(options, "push_pem", &tmpi);
+            if (ret1 == 0) {
+                gf_asprintf_append(&events_str, "%spush_pem=%d;", events_str,
+                                   tmpi);
+            }
+            ret1 = dict_get_int32(options, "no_verify", &tmpi);
+            if (ret1 == 0) {
+                gf_asprintf_append(&events_str, "%sno_verify=%d;", events_str,
+                                   tmpi);
+            }
+
+            ret1 = dict_get_int32(options, "ssh_port", &tmpi);
+            if (ret1 == 0) {
+                gf_asprintf_append(&events_str, "%sssh_port=%d;", events_str,
+                                   tmpi);
+            }
+
+            ret1 = dict_get_int32(options, "reset-sync-time", &tmpi);
+            if (ret1 == 0) {
+                gf_asprintf_append(&events_str, "%sreset_sync_time=%d;",
+                                   events_str, tmpi);
+            }
+            /* Capture Master and Slave Info */
+            ret1 = dict_get_str(options, "master", &tmp);
+            if (ret1)
+                tmp = "";
+            gf_asprintf_append(&events_str, "%smaster=%s;", events_str, tmp);
+
+            ret1 = dict_get_str(options, "slave", &tmp);
+            if (ret1)
+                tmp = "";
+            gf_asprintf_append(&events_str, "%sslave=%s", events_str, tmp);
+
+            gf_event(event_type, "%s", events_str);
+        }
+
+        /* Allocated by gf_strdup and gf_asprintf */
+        if (events_str)
+            GF_FREE(events_str);
+    }
+#endif
 
-out:
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_get_detail_status (dict_t *dict, int i, cli_volume_status_t *status)
+cli_cmd_volume_status_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        uint64_t                   free            = 0;
-        uint64_t                   total           = 0;
-        char                       key[1024]       = {0};
-        int                        ret             = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    uint32_t cmd = 0;
+    cli_local_t *local = NULL;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.free", i);
-        ret = dict_get_uint64 (dict, key, &free);
-
-        status->free = gf_uint64_2human_readable (free);
-        if (!status->free)
-                goto out;
+    ret = cli_cmd_volume_status_parse(words, wordcount, &dict);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.total", i);
-        ret = dict_get_uint64 (dict, key, &total);
-
-        status->total = gf_uint64_2human_readable (total);
-        if (!status->total)
-                goto out;
+    if (ret) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.device", i);
-        ret = dict_get_str (dict, key, &(status->device));
-        if (ret)
-                status->device = NULL;
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.block_size", i);
-        ret = dict_get_uint64 (dict, key, &(status->block_size));
-        if (ret) {
-                ret = 0;
-                status->block_size = 0;
-        }
+    if (!(cmd & GF_CLI_STATUS_ALL)) {
+        /* for one volume or brick */
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_VOLUME];
+    } else {
+        /* volume status all or all detail */
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_ALL];
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mnt_options", i);
-        ret = dict_get_str (dict, key, &(status->mount_options));
-        if (ret)
-                status->mount_options = NULL;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.fs_name", i);
-        ret = dict_get_str (dict, key, &(status->fs_name));
-        if (ret) {
-                ret = 0;
-                status->fs_name = NULL;
-        }
+    if (!proc->fn) {
+        ret = -1;
+        goto out;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.inode_size", i);
-        ret = dict_get_str (dict, key, &(status->inode_size));
-        if (ret)
-                status->inode_size = NULL;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to create frame");
+        ret = -1;
+        goto out;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.total_inodes", i);
-        ret = dict_get_uint64 (dict, key,
-                        &(status->total_inodes));
-        if (ret)
-                status->total_inodes = 0;
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.free_inodes", i);
-        ret = dict_get_uint64 (dict, key, &(status->free_inodes));
-        if (ret) {
-                ret = 0;
-                status->free_inodes = 0;
-        }
+    ret = proc->fn(frame, THIS, dict);
 
+out:
+    CLI_STACK_DESTROY(frame);
 
- out:
-        return ret;
+    return ret;
 }
 
-void
-cli_print_detailed_status (cli_volume_status_t *status)
+int
+cli_get_detail_status(dict_t *dict, int i, cli_volume_status_t *status)
 {
-        cli_out ("%-20s : %-20s", "Brick", status->brick);
+    uint64_t free = 0;
+    uint64_t total = 0;
+    char key[1024] = {0};
+    int ret = 0;
 
-        if (status->online) {
-                cli_out ("%-20s : %-20d", "TCP Port", status->port);
-                cli_out ("%-20s : %-20d", "RDMA Port", status->rdma_port);
-        } else {
-                cli_out ("%-20s : %-20s", "TCP Port", "N/A");
-                cli_out ("%-20s : %-20s", "RDMA Port", "N/A");
-        }
+    snprintf(key, sizeof(key), "brick%d.free", i);
+    ret = dict_get_uint64(dict, key, &free);
 
-        cli_out ("%-20s : %-20c", "Online", (status->online) ? 'Y' : 'N');
-        cli_out ("%-20s : %-20s", "Pid", status->pid_str);
+    status->free = gf_uint64_2human_readable(free);
+    if (!status->free)
+        goto out;
 
-        if (status->fs_name)
-                cli_out ("%-20s : %-20s", "File System", status->fs_name);
-        else
-                cli_out ("%-20s : %-20s", "File System", "N/A");
+    snprintf(key, sizeof(key), "brick%d.total", i);
+    ret = dict_get_uint64(dict, key, &total);
 
-        if (status->device)
-                cli_out ("%-20s : %-20s", "Device", status->device);
-        else
-                cli_out ("%-20s : %-20s", "Device", "N/A");
+    status->total = gf_uint64_2human_readable(total);
+    if (!status->total)
+        goto out;
 
-        if (status->mount_options) {
-                cli_out ("%-20s : %-20s", "Mount Options",
-                         status->mount_options);
-        } else {
-                cli_out ("%-20s : %-20s", "Mount Options", "N/A");
-        }
+    snprintf(key, sizeof(key), "brick%d.device", i);
+    ret = dict_get_str(dict, key, &(status->device));
+    if (ret)
+        status->device = NULL;
 
-        if (status->inode_size) {
-                cli_out ("%-20s : %-20s", "Inode Size",
-                         status->inode_size);
-        } else {
-                cli_out ("%-20s : %-20s", "Inode Size", "N/A");
-        }
-        if (status->free)
-                cli_out ("%-20s : %-20s", "Disk Space Free", status->free);
-        else
-                cli_out ("%-20s : %-20s", "Disk Space Free", "N/A");
+    snprintf(key, sizeof(key), "brick%d.block_size", i);
+    ret = dict_get_uint64(dict, key, &(status->block_size));
+    if (ret) {
+        ret = 0;
+        status->block_size = 0;
+    }
 
-        if (status->total)
-                cli_out ("%-20s : %-20s", "Total Disk Space", status->total);
-        else
-                cli_out ("%-20s : %-20s", "Total Disk Space", "N/A");
+    snprintf(key, sizeof(key), "brick%d.mnt_options", i);
+    ret = dict_get_str(dict, key, &(status->mount_options));
+    if (ret)
+        status->mount_options = NULL;
 
+    snprintf(key, sizeof(key), "brick%d.fs_name", i);
+    ret = dict_get_str(dict, key, &(status->fs_name));
+    if (ret) {
+        ret = 0;
+        status->fs_name = NULL;
+    }
+
+    snprintf(key, sizeof(key), "brick%d.inode_size", i);
+    ret = dict_get_str(dict, key, &(status->inode_size));
+    if (ret)
+        status->inode_size = NULL;
+
+    snprintf(key, sizeof(key), "brick%d.total_inodes", i);
+    ret = dict_get_uint64(dict, key, &(status->total_inodes));
+    if (ret)
+        status->total_inodes = 0;
+
+    snprintf(key, sizeof(key), "brick%d.free_inodes", i);
+    ret = dict_get_uint64(dict, key, &(status->free_inodes));
+    if (ret) {
+        ret = 0;
+        status->free_inodes = 0;
+    }
 
-        if (status->total_inodes) {
-                cli_out ("%-20s : %-20"GF_PRI_INODE, "Inode Count",
-                         status->total_inodes);
-        } else {
-                cli_out ("%-20s : %-20s", "Inode Count", "N/A");
-        }
+out:
+    return ret;
+}
 
-        if (status->free_inodes) {
-                cli_out ("%-20s : %-20"GF_PRI_INODE, "Free Inodes",
-                         status->free_inodes);
-        } else {
-                cli_out ("%-20s : %-20s", "Free Inodes", "N/A");
-        }
+void
+cli_print_detailed_status(cli_volume_status_t *status)
+{
+    cli_out("%-20s : %-20s", "Brick", status->brick);
+
+    if (status->online) {
+        cli_out("%-20s : %-20d", "TCP Port", status->port);
+        cli_out("%-20s : %-20d", "RDMA Port", status->rdma_port);
+    } else {
+        cli_out("%-20s : %-20s", "TCP Port", "N/A");
+        cli_out("%-20s : %-20s", "RDMA Port", "N/A");
+    }
+
+    cli_out("%-20s : %-20c", "Online", (status->online) ? 'Y' : 'N');
+    cli_out("%-20s : %-20s", "Pid", status->pid_str);
+
+    if (status->fs_name)
+        cli_out("%-20s : %-20s", "File System", status->fs_name);
+    else
+        cli_out("%-20s : %-20s", "File System", "N/A");
+
+    if (status->device)
+        cli_out("%-20s : %-20s", "Device", status->device);
+    else
+        cli_out("%-20s : %-20s", "Device", "N/A");
+
+    if (status->mount_options) {
+        cli_out("%-20s : %-20s", "Mount Options", status->mount_options);
+    } else {
+        cli_out("%-20s : %-20s", "Mount Options", "N/A");
+    }
+
+    if (status->inode_size) {
+        cli_out("%-20s : %-20s", "Inode Size", status->inode_size);
+    } else {
+        cli_out("%-20s : %-20s", "Inode Size", "N/A");
+    }
+    if (status->free)
+        cli_out("%-20s : %-20s", "Disk Space Free", status->free);
+    else
+        cli_out("%-20s : %-20s", "Disk Space Free", "N/A");
+
+    if (status->total)
+        cli_out("%-20s : %-20s", "Total Disk Space", status->total);
+    else
+        cli_out("%-20s : %-20s", "Total Disk Space", "N/A");
+
+    if (status->total_inodes) {
+        cli_out("%-20s : %-20" GF_PRI_INODE, "Inode Count",
+                status->total_inodes);
+    } else {
+        cli_out("%-20s : %-20s", "Inode Count", "N/A");
+    }
+
+    if (status->free_inodes) {
+        cli_out("%-20s : %-20" GF_PRI_INODE, "Free Inodes",
+                status->free_inodes);
+    } else {
+        cli_out("%-20s : %-20s", "Free Inodes", "N/A");
+    }
 }
 
 int
-cli_print_brick_status (cli_volume_status_t *status)
+cli_print_brick_status(cli_volume_status_t *status)
 {
-        int  fieldlen = CLI_VOL_STATUS_BRICK_LEN;
-        int  bricklen = 0;
-        char *p = NULL;
-        int  num_spaces = 0;
-
-        p = status->brick;
-        bricklen = strlen (p);
-        while (bricklen > 0) {
-                if (bricklen > fieldlen) {
-                        cli_out ("%.*s", fieldlen, p);
-                        p += fieldlen;
-                        bricklen -= fieldlen;
-                } else {
-                        num_spaces = (fieldlen - bricklen) + 1;
-                        printf ("%s", p);
-                        while (num_spaces-- != 0)
-                                printf (" ");
-                        if (status->port || status->rdma_port) {
-                                if (status->online)
-                                        cli_out ("%-10d%-11d%-8c%-5s",
-                                                 status->port,
-                                                 status->rdma_port,
-                                                 status->online?'Y':'N',
-                                                 status->pid_str);
-                                else
-                                        cli_out ("%-10s%-11s%-8c%-5s",
-                                                 "N/A",
-                                                 "N/A",
-                                                 status->online?'Y':'N',
-                                                 status->pid_str);
-                        }
-                        else
-                                cli_out ("%-10s%-11s%-8c%-5s",
-                                         "N/A", "N/A", status->online?'Y':'N',
-                                         status->pid_str);
-                        bricklen = 0;
-                }
+    int fieldlen = CLI_VOL_STATUS_BRICK_LEN;
+    int bricklen = 0;
+    char *p = NULL;
+    int num_spaces = 0;
+
+    p = status->brick;
+    bricklen = strlen(p);
+    while (bricklen > 0) {
+        if (bricklen > fieldlen) {
+            cli_out("%.*s", fieldlen, p);
+            p += fieldlen;
+            bricklen -= fieldlen;
+        } else {
+            num_spaces = (fieldlen - bricklen) + 1;
+            printf("%s", p);
+            while (num_spaces-- != 0)
+                printf(" ");
+            if (status->port || status->rdma_port) {
+                if (status->online)
+                    cli_out("%-10d%-11d%-8c%-5s", status->port,
+                            status->rdma_port, status->online ? 'Y' : 'N',
+                            status->pid_str);
+                else
+                    cli_out("%-10s%-11s%-8c%-5s", "N/A", "N/A",
+                            status->online ? 'Y' : 'N', status->pid_str);
+            } else
+                cli_out("%-10s%-11s%-8c%-5s", "N/A", "N/A",
+                        status->online ? 'Y' : 'N', status->pid_str);
+            bricklen = 0;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-#define NEEDS_GLFS_HEAL(op) ((op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) || \
-                             (op == GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME) ||\
-                             (op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) ||      \
-                             (op == GF_SHD_OP_INDEX_SUMMARY) ||               \
-                             (op == GF_SHD_OP_SPLIT_BRAIN_FILES) ||           \
-                             (op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE))
+#define NEEDS_GLFS_HEAL(op)                                                    \
+    ((op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) ||                         \
+     (op == GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME) ||                        \
+     (op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) ||                               \
+     (op == GF_SHD_OP_INDEX_SUMMARY) || (op == GF_SHD_OP_SPLIT_BRAIN_FILES) || \
+     (op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||                           \
+     (op == GF_SHD_OP_HEAL_SUMMARY))
 
 int
-cli_launch_glfs_heal (int heal_op, dict_t *options)
+cli_launch_glfs_heal(int heal_op, dict_t *options)
 {
-        char      buff[PATH_MAX] = {0};
-        runner_t  runner         = {0};
-        char      *filename      = NULL;
-        char      *hostname      = NULL;
-        char      *path          = NULL;
-        char      *volname       = NULL;
-        char      *out           = NULL;
-        int        ret           = 0;
-
-        runinit (&runner);
-        ret = dict_get_str (options, "volname", &volname);
-        runner_add_args (&runner, SBIN_DIR"/glfsheal", volname, NULL);
-        runner_redir (&runner, STDOUT_FILENO, RUN_PIPE);
-
-        switch (heal_op) {
+    char buff[PATH_MAX] = {0};
+    runner_t runner = {0};
+    char *filename = NULL;
+    char *hostname = NULL;
+    char *path = NULL;
+    char *volname = NULL;
+    char *out = NULL;
+    int ret = 0;
+
+    runinit(&runner);
+    ret = dict_get_str(options, "volname", &volname);
+    runner_add_args(&runner, GLFSHEAL_PREFIX "/glfsheal", volname, NULL);
+    runner_redir(&runner, STDOUT_FILENO, RUN_PIPE);
+
+    switch (heal_op) {
         case GF_SHD_OP_INDEX_SUMMARY:
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        runner_add_args (&runner, "xml", NULL);
-                }
-                break;
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "--xml", NULL);
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                ret = dict_get_str (options, "file", &filename);
-                runner_add_args (&runner, "bigger-file", filename, NULL);
-                break;
+            ret = dict_get_str(options, "file", &filename);
+            runner_add_args(&runner, "bigger-file", filename, NULL);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                ret = dict_get_str (options, "file", &filename);
-                runner_add_args (&runner, "latest-mtime", filename, NULL);
-                break;
+            ret = dict_get_str(options, "file", &filename);
+            runner_add_args(&runner, "latest-mtime", filename, NULL);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (options, "heal-source-hostname",
-                                    &hostname);
-                ret = dict_get_str (options, "heal-source-brickpath",
-                                    &path);
-                runner_add_args (&runner, "source-brick", NULL);
-                runner_argprintf (&runner, "%s:%s", hostname, path);
-                if (dict_get_str (options, "file", &filename) == 0)
-                        runner_argprintf (&runner, filename);
-                break;
+            ret = dict_get_str(options, "heal-source-hostname", &hostname);
+            ret = dict_get_str(options, "heal-source-brickpath", &path);
+            runner_add_args(&runner, "source-brick", NULL);
+            runner_argprintf(&runner, "%s:%s", hostname, path);
+            if (dict_get_str(options, "file", &filename) == 0)
+                runner_argprintf(&runner, "%s", filename);
+            break;
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-                runner_add_args (&runner, "split-brain-info", NULL);
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        runner_add_args (&runner, "xml", NULL);
-                }
-                break;
+            runner_add_args(&runner, "split-brain-info", NULL);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "--xml", NULL);
+            }
+            break;
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
-                runner_add_args (&runner, "granular-entry-heal-op", NULL);
-                break;
+            runner_add_args(&runner, "granular-entry-heal-op", NULL);
+            break;
+        case GF_SHD_OP_HEAL_SUMMARY:
+            runner_add_args(&runner, "info-summary", NULL);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "--xml", NULL);
+            }
+            break;
         default:
-                ret = -1;
-        }
-        ret = runner_start (&runner);
-        if (ret == -1)
-                goto out;
-        while ((out = fgets (buff, sizeof(buff),
-                             runner_chio (&runner, STDOUT_FILENO)))) {
-                printf ("%s", out);
-        }
-        ret = runner_end (&runner);
+            ret = -1;
+            goto out;
+    }
+    if (global_state->mode & GLUSTER_MODE_GLFSHEAL_NOLOG)
+        runner_add_args(&runner, "--nolog", NULL);
+    ret = runner_start(&runner);
+    if (ret == -1)
+        goto out;
+    while ((
+        out = fgets(buff, sizeof(buff), runner_chio(&runner, STDOUT_FILENO)))) {
+        printf("%s", out);
+    }
+    ret = runner_end(&runner);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_heal_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_heal_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *options = NULL;
-        xlator_t                *this = NULL;
-        cli_local_t             *local = NULL;
-        int                     heal_op = 0;
-
-        this = THIS;
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if (wordcount < 3) {
-               cli_usage_out (word->pattern);
-               parse_error = 1;
-               goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *options = NULL;
+    xlator_t *this = NULL;
+    cli_local_t *local = NULL;
+    int heal_op = 0;
+
+    this = THIS;
+
+    if (wordcount < 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_volume_heal_options_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-        ret = dict_get_int32 (options, "heal-op", &heal_op);
+    ret = cli_cmd_volume_heal_options_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+    ret = dict_get_int32(options, "heal-op", &heal_op);
+    if (ret < 0)
+        goto out;
+    if (NEEDS_GLFS_HEAL(heal_op)) {
+        ret = cli_launch_glfs_heal(heal_op, options);
         if (ret < 0)
-                goto out;
-        if (NEEDS_GLFS_HEAL (heal_op)) {
-                ret = cli_launch_glfs_heal (heal_op, options);
-                if (ret < 0)
-                        goto out;
-                if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                        goto out;
-        }
+            goto out;
+        if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+            goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_HEAL_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_HEAL_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0) &&
-                    !(global_state->mode & GLUSTER_MODE_XML)) {
-                        cli_out ("Volume heal failed.");
-                }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0) &&
+            !(global_state->mode & GLUSTER_MODE_XML)) {
+            cli_out("Volume heal failed.");
         }
+    }
+
+    if (options)
+        dict_unref(options);
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_statedump_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount)
+cli_cmd_volume_statedump_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        dict_t                          *options = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-        cli_local_t                     *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount < 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (wordcount < 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+    if (wordcount >= 3) {
+        ret = cli_cmd_volume_statedump_options_parse(words, wordcount,
+                                                     &options);
+        if (ret) {
+            parse_error = 1;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error parsing "
+                   "statedump options");
+            cli_out("Error parsing options");
+            cli_usage_out(word->pattern);
         }
+    }
 
-        if (wordcount >= 3) {
-               ret = cli_cmd_volume_statedump_options_parse (words, wordcount,
-                                                              &options);
-               if (ret) {
-                       parse_error = 1;
-                       gf_log ("cli", GF_LOG_ERROR, "Error parsing "
-                               "statedump options");
-                       cli_out ("Error parsing options");
-                       cli_usage_out (word->pattern);
-               }
-        }
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATEDUMP_VOLUME];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATEDUMP_VOLUME];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume statedump failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume statedump failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_list_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
+cli_cmd_volume_list_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        call_frame_t            *frame = NULL;
-        rpc_clnt_procedure_t    *proc = NULL;
-        int                     sent = 0;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    int sent = 0;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_VOLUME];
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
         if (!frame)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_VOLUME];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, NULL);
-        }
+            goto out;
+        ret = proc->fn(frame, THIS, NULL);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if (sent == 0)
-                        cli_out ("Volume list failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if (sent == 0)
+            cli_out("Volume list failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_clearlocks_cbk (struct cli_state *state,
-                               struct cli_cmd_word *word,
-                               const char **words, int wordcount)
+cli_cmd_volume_clearlocks_cbk(struct cli_state *state,
+                              struct cli_cmd_word *word, const char **words,
+                              int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        dict_t                          *options = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-        cli_local_t                     *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if (wordcount < 7 || wordcount > 8) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-       ret = cli_cmd_volume_clrlks_opts_parse (words, wordcount, &options);
-       if (ret) {
-               parse_error = 1;
-               gf_log ("cli", GF_LOG_ERROR, "Error parsing "
-                       "clear-locks options");
-               cli_out ("Error parsing options");
-               cli_usage_out (word->pattern);
-       }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount < 7 || wordcount > 8) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    ret = cli_cmd_volume_clrlks_opts_parse(words, wordcount, &options);
+    if (ret) {
+        parse_error = 1;
+        gf_log("cli", GF_LOG_ERROR,
+               "Error parsing "
+               "clear-locks options");
+        cli_out("Error parsing options");
+        cli_usage_out(word->pattern);
+    }
+
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "path", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "path", (char *)words[3]);
-        if (ret)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CLRLOCKS_VOLUME];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CLRLOCKS_VOLUME];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume clear-locks failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume clear-locks failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_barrier_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                            const char **words, int wordcount)
+cli_cmd_volume_barrier_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                           const char **words, int wordcount)
 {
-        int ret = -1;
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame = NULL;
-        dict_t *options = NULL;
-        int sent = 0;
-        int parse_error = 0;
-        cli_local_t *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    options = dict_new();
+    if (!options) {
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        options = dict_new();
-        if (!options) {
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str(options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "barrier", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "barrier", (char *)words[3]);
-        if (ret)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BARRIER_VOLUME];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BARRIER_VOLUME];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_err ("Volume barrier failed");
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_err("Volume barrier failed");
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
 int
-cli_cmd_volume_getopt_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_volume_getopt_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                   ret       = -1;
-        rpc_clnt_procedure_t *proc      = NULL;
-        call_frame_t         *frame     = NULL;
-        dict_t               *options   = NULL;
-        int                   sent      = 0;
-        int                   parse_err = 0;
-        cli_local_t          *local     = NULL;
-
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_err = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_err = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    options = dict_new();
+    if (!options)
+        goto out;
 
-        options = dict_new ();
-        if (!options)
-                goto out;
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "key", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "key", (char *)words[3]);
-        if (ret)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOL_OPT];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOL_OPT];
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_err == 0))
-                        cli_err ("Volume get option failed");
-        }
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_err == 0))
+            cli_err("Volume get option failed");
+    }
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
 /* This is a bit of a hack to display the help. The current bitrot cmd
  * format does not work well when registering the cmds.
  * Ideally the should have been of the form
@@ -3196,430 +2957,322 @@ out:
 
 struct cli_cmd bitrot_cmds[] = {
 
-        {"volume bitrot help",
-         cli_cmd_bitrot_help_cbk,
-         "display help for volume bitrot commands"
-        },
-
-        {"volume bitrot <VOLNAME> {enable|disable}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Enable/disable bitrot for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub-throttle {lazy|normal|aggressive}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Set the speed of the scrubber for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub-frequency {hourly|daily|weekly|biweekly"
-         "|monthly}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Set the frequency of the scrubber for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub {pause|resume|status|ondemand}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Pause/resume the scrubber for <VOLNAME>. Status displays the status of "
-         "the scrubber. ondemand starts the scrubber immediately."
-        },
-
-        {"volume bitrot <VOLNAME> {enable|disable}\n"
-         "volume bitrot <volname> scrub-throttle {lazy|normal|aggressive}\n"
-         "volume bitrot <volname> scrub-frequency {hourly|daily|weekly|biweekly"
-         "|monthly}\n"
-         "volume bitrot <volname> scrub {pause|resume|status|ondemand}",
-         cli_cmd_bitrot_cbk,
-         NULL
-        },
-
-        { NULL, NULL, NULL }
-};
+    {"volume bitrot help", cli_cmd_bitrot_help_cbk,
+     "display help for volume bitrot commands"},
+
+    {"volume bitrot <VOLNAME> {enable|disable}", NULL, /*cli_cmd_bitrot_cbk,*/
+     "Enable/disable bitrot for volume <VOLNAME>"},
+
+    {"volume bitrot <VOLNAME> signing-time <time-in-secs>",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Waiting time for an object after last fd is closed to start signing "
+     "process"},
+
+    {"volume bitrot <VOLNAME> signer-threads <count>",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Number of signing process threads. Usually set to number of available "
+     "cores"},
 
+    {"volume bitrot <VOLNAME> scrub-throttle {lazy|normal|aggressive}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Set the speed of the scrubber for volume <VOLNAME>"},
+
+    {"volume bitrot <VOLNAME> scrub-frequency {hourly|daily|weekly|biweekly"
+     "|monthly}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Set the frequency of the scrubber for volume <VOLNAME>"},
+
+    {"volume bitrot <VOLNAME> scrub {pause|resume|status|ondemand}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Pause/resume the scrubber for <VOLNAME>. Status displays the status of "
+     "the scrubber. ondemand starts the scrubber immediately."},
+
+    {"volume bitrot <VOLNAME> {enable|disable}\n"
+     "volume bitrot <VOLNAME> signing-time <time-in-secs>\n"
+     "volume bitrot <VOLNAME> signer-threads <count>\n"
+     "volume bitrot <volname> scrub-throttle {lazy|normal|aggressive}\n"
+     "volume bitrot <volname> scrub-frequency {hourly|daily|weekly|biweekly"
+     "|monthly}\n"
+     "volume bitrot <volname> scrub {pause|resume|status|ondemand}",
+     cli_cmd_bitrot_cbk, NULL},
+
+    {NULL, NULL, NULL}};
 
 struct cli_cmd quota_cmds[] = {
 
-        /* Quota commands */
-        {"volume quota help",
-         cli_cmd_quota_help_cbk,
-         "display help for volume quota commands"
-        },
-
-        {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
-         "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
-         "default-soft-limit <percent>}",
-         cli_cmd_quota_cbk,
-         "Enable/disable and configure quota for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}",
-         cli_cmd_quota_cbk,
-         "Set maximum size for <path> for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}",
-         cli_cmd_quota_cbk,
-         "Set the maximum number of entries allowed in <path> for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
-         cli_cmd_quota_cbk,
-         "Set quota timeout for <VOLNAME>"
-        },
-
-        { "volume inode-quota <VOLNAME> enable",
-          cli_cmd_quota_cbk,
-          "Enable/disable inode-quota for <VOLNAME>"
-        },
-
-        { "volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
-          "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
-          "default-soft-limit <percent>}\n"
-          "volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}\n"
-          "volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}\n"
-          "volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
-          cli_cmd_quota_cbk,
-          NULL
-        },
-
-        { NULL, NULL, NULL }
-};
-
-struct cli_cmd tier_cmds[] = {
-
-        { "volume tier help",
-          cli_cmd_tier_help_cbk,
-          "display help for volume tier commands"},
-
-        { "volume tier <VOLNAME> status",
-          cli_cmd_volume_tier_cbk,
-          "Display tier status for <VOLNAME>"},
-
-        { "volume tier <VOLNAME> start [force]",
-          cli_cmd_volume_tier_cbk,
-          "Start the tier service for <VOLNAME>"},
-
-        { "volume tier <VOLNAME> stop [force]",
-          cli_cmd_volume_tier_cbk,
-          "Stop the tier service for <VOLNAME>"},
-
-        { "volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]",
-          cli_cmd_volume_tier_cbk,
-          "Attach a hot tier to <VOLNAME>"},
-
-        { "volume tier <VOLNAME> detach <start|stop|status|commit|[force]>",
-          cli_cmd_volume_tier_cbk,
-          "Detach the hot tier from <VOLNAME>"},
-
-        { "volume attach-tier <VOLNAME> [<replica COUNT>] <NEW-BRICK>...",
-          cli_cmd_volume_tier_cbk,
-          "NOTE: this is old syntax, will be deprecated in next release. "
-          "Please use gluster volume tier <vol> attach "
-          "[<replica COUNT>] <NEW-BRICK>..."},
-
-        { "volume detach-tier <VOLNAME> "
-          "<start|stop|status|commit|force>",
-          cli_cmd_volume_tier_cbk,
-          "NOTE: this is old syntax, will be deprecated in next release. "
-          "Please use gluster volume tier <vol> detach "
-          "{start|stop|commit} [force]"},
-
-        { "volume tier <VOLNAME> status\n"
-          "volume tier <VOLNAME> start [force]\n"
-          "volume tier <VOLNAME> stop\n"
-          "volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]\n"
-          "volume tier <VOLNAME> detach <start|stop|status|commit|[force]>\n",
-          cli_cmd_volume_tier_cbk,
-          NULL },
-
-        {NULL, NULL, NULL}
-
-        };
+    /* Quota commands */
+    {"volume quota help", cli_cmd_quota_help_cbk,
+     "display help for volume quota commands"},
+
+    {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
+     "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
+     "default-soft-limit <percent>}",
+     cli_cmd_quota_cbk, "Enable/disable and configure quota for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}",
+     cli_cmd_quota_cbk, "Set maximum size for <path> for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}",
+     cli_cmd_quota_cbk,
+     "Set the maximum number of entries allowed in <path> for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
+     cli_cmd_quota_cbk, "Set quota timeout for <VOLNAME>"},
+
+    {"volume inode-quota <VOLNAME> enable", cli_cmd_quota_cbk,
+     "Enable/disable inode-quota for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
+     "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
+     "default-soft-limit <percent>}\n"
+     "volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}\n"
+     "volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}\n"
+     "volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
+     cli_cmd_quota_cbk, NULL},
+
+    {NULL, NULL, NULL}};
 
 struct cli_cmd volume_cmds[] = {
-        { "volume help",
-          cli_cmd_volume_help_cbk,
-          "display help for volume commands"},
-
-        { "volume info [all|<VOLNAME>]",
-          cli_cmd_volume_info_cbk,
-          "list information of all volumes"},
-
-        { "volume create <NEW-VOLNAME> [stripe <COUNT>] "
-          "[replica <COUNT> [arbiter <COUNT>]] "
-          "[disperse [<COUNT>]] [disperse-data <COUNT>] [redundancy <COUNT>] "
-          "[transport <tcp|rdma|tcp,rdma>] <NEW-BRICK>"
-#ifdef HAVE_BD_XLATOR
-          "?<vg_name>"
-#endif
-          "... [force]",
+    {"volume help", cli_cmd_volume_help_cbk,
+     "display help for volume commands"},
+
+    {"volume info [all|<VOLNAME>]", cli_cmd_volume_info_cbk,
+     "list information of all volumes"},
 
-          cli_cmd_volume_create_cbk,
-          "create a new volume of specified type with mentioned bricks"},
+    {"volume create <NEW-VOLNAME> [stripe <COUNT>] "
+     "[[replica <COUNT> [arbiter <COUNT>]]|[replica 2 thin-arbiter 1]] "
+     "[disperse [<COUNT>]] [disperse-data <COUNT>] [redundancy <COUNT>] "
+     "[transport <tcp|rdma|tcp,rdma>] <NEW-BRICK> <TA-BRICK>"
+     "... [force]",
 
-        { "volume delete <VOLNAME>",
-          cli_cmd_volume_delete_cbk,
-          "delete volume specified by <VOLNAME>"},
+     cli_cmd_volume_create_cbk,
+     "create a new volume of specified type with mentioned bricks"},
 
-        { "volume start <VOLNAME> [force]",
-          cli_cmd_volume_start_cbk,
-          "start volume specified by <VOLNAME>"},
+    {"volume delete <VOLNAME>", cli_cmd_volume_delete_cbk,
+     "delete volume specified by <VOLNAME>"},
 
-        { "volume stop <VOLNAME> [force]",
-          cli_cmd_volume_stop_cbk,
-          "stop volume specified by <VOLNAME>"},
+    {"volume start <VOLNAME> [force]", cli_cmd_volume_start_cbk,
+     "start volume specified by <VOLNAME>"},
 
-        /*{ "volume rename <VOLNAME> <NEW-VOLNAME>",
-          cli_cmd_volume_rename_cbk,
-          "rename volume <VOLNAME> to <NEW-VOLNAME>"},*/
+    {"volume stop <VOLNAME> [force]", cli_cmd_volume_stop_cbk,
+     "stop volume specified by <VOLNAME>"},
 
-        { "volume add-brick <VOLNAME> [<stripe|replica> <COUNT> "
-          "[arbiter <COUNT>]] <NEW-BRICK> ... [force]",
-          cli_cmd_volume_add_brick_cbk,
-          "add brick to volume <VOLNAME>"},
+    /*{ "volume rename <VOLNAME> <NEW-VOLNAME>",
+      cli_cmd_volume_rename_cbk,
+      "rename volume <VOLNAME> to <NEW-VOLNAME>"},*/
 
-        { "volume remove-brick <VOLNAME> [replica <COUNT>] <BRICK> ..."
-          " <start|stop|status|commit|force>",
-          cli_cmd_volume_remove_brick_cbk,
-          "remove brick from volume <VOLNAME>"},
+    {"volume add-brick <VOLNAME> [<stripe|replica> <COUNT> "
+     "[arbiter <COUNT>]] <NEW-BRICK> ... [force]",
+     cli_cmd_volume_add_brick_cbk, "add brick to volume <VOLNAME>"},
 
-        { "volume rebalance <VOLNAME> {{fix-layout start} | {start [force]|stop|status}}",
-          cli_cmd_volume_defrag_cbk,
-          "rebalance operations"},
+    {"volume remove-brick <VOLNAME> [replica <COUNT>] <BRICK> ..."
+     " <start|stop|status|commit|force>",
+     cli_cmd_volume_remove_brick_cbk, "remove brick from volume <VOLNAME>"},
 
-        { "volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> "
-          "{commit force}",
-          cli_cmd_volume_replace_brick_cbk,
-          "replace-brick operations"},
+    {"volume rebalance <VOLNAME> {{fix-layout start} | {start "
+     "[force]|stop|status}}",
+     cli_cmd_volume_defrag_cbk, "rebalance operations"},
 
-        /*{ "volume set-transport <VOLNAME> <TRANSPORT-TYPE> [<TRANSPORT-TYPE>] ...",
-          cli_cmd_volume_set_transport_cbk,
-          "set transport type for volume <VOLNAME>"},*/
+    {"volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> "
+     "{commit force}",
+     cli_cmd_volume_replace_brick_cbk, "replace-brick operations"},
 
-        { "volume set <VOLNAME> <KEY> <VALUE>",
-          cli_cmd_volume_set_cbk,
-         "set options for volume <VOLNAME>"},
+    /*{ "volume set-transport <VOLNAME> <TRANSPORT-TYPE> [<TRANSPORT-TYPE>]
+      ...", cli_cmd_volume_set_transport_cbk, "set transport type for volume
+      <VOLNAME>"},*/
 
+    {"volume set <VOLNAME> <KEY> <VALUE>", cli_cmd_volume_set_cbk,
+     "set options for volume <VOLNAME>"},
 
-        { "volume log <VOLNAME> rotate [BRICK]",
-          cli_cmd_log_rotate_cbk,
-         "rotate the log file for corresponding volume/brick"},
+    {"volume set <VOLNAME> group <GROUP>", cli_cmd_volume_set_cbk,
+     "This option can be used for setting multiple pre-defined volume options "
+     "where group_name is a file under /var/lib/glusterd/groups containing one "
+     "key value pair per line"},
 
-        { "volume log rotate <VOLNAME> [BRICK]",
-          cli_cmd_log_rotate_cbk,
-         "rotate the log file for corresponding volume/brick"
-         " NOTE: This is an old syntax, will be deprecated from next release."},
+    {"volume log <VOLNAME> rotate [BRICK]", cli_cmd_log_rotate_cbk,
+     "rotate the log file for corresponding volume/brick"},
 
-        { "volume sync <HOSTNAME> [all|<VOLNAME>]",
-          cli_cmd_sync_volume_cbk,
-         "sync the volume information from a peer"},
+    {"volume sync <HOSTNAME> [all|<VOLNAME>]", cli_cmd_sync_volume_cbk,
+     "sync the volume information from a peer"},
 
-         { "volume reset <VOLNAME> [option] [force]",
-         cli_cmd_volume_reset_cbk,
-         "reset all the reconfigured options"},
+    {"volume reset <VOLNAME> [option] [force]", cli_cmd_volume_reset_cbk,
+     "reset all the reconfigured options"},
 
 #if (SYNCDAEMON_COMPILE)
-        {"volume "GEOREP" [<VOLNAME>] [<SLAVE-URL>] {create [[ssh-port n] [[no-verify]|[push-pem]]] [force]"
-         "|start [force]|stop [force]|pause [force]|resume [force]|config|status [detail]|delete [reset-sync-time]} [options...]",
-         cli_cmd_volume_gsync_set_cbk,
-         "Geo-sync operations",
-         cli_cmd_check_gsync_exists_cbk},
+    {"volume " GEOREP " [<MASTER-VOLNAME>] [<SLAVE-IP>]::[<SLAVE-VOLNAME>] {"
+     "\\\n create [[ssh-port n] [[no-verify] \\\n | [push-pem]]] [force] \\\n"
+     " | start [force] \\\n | stop [force] \\\n | pause [force] \\\n | resume "
+     "[force] \\\n"
+     " | config [[[\\!]<option>] [<value>]] \\\n | status "
+     "[detail] \\\n | delete [reset-sync-time]} ",
+     cli_cmd_volume_gsync_set_cbk, "Geo-sync operations",
+     cli_cmd_check_gsync_exists_cbk},
 #endif
 
-         { "volume profile <VOLNAME> {start|info [peek|incremental [peek]|cumulative|clear]|stop} [nfs]",
-           cli_cmd_volume_profile_cbk,
-           "volume profile operations"},
-
-         { "volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick <brick>] [list-cnt <value>] |\n"
-           "volume top <VOLNAME> {read-perf|write-perf} [bs <size> count <count>] [brick <brick>] [list-cnt <value>]",
-           cli_cmd_volume_top_cbk,
-           "volume top operations"},
-
-        { "volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad|tierd]]"
-          " [detail|clients|mem|inode|fd|callpool|tasks]",
-          cli_cmd_volume_status_cbk,
-          "display status of all or specified volume(s)/brick"},
-
-        { "volume heal <VOLNAME> [enable | disable | full |"
-          "statistics [heal-count [replica <HOSTNAME:BRICKNAME>]] |"
-          "info [summary | split-brain] |"
-          "split-brain {bigger-file <FILE> | latest-mtime <FILE> |"
-                       "source-brick <HOSTNAME:BRICKNAME> [<FILE>]} |"
-          "granular-entry-heal {enable | disable}]",
-          cli_cmd_volume_heal_cbk,
-          "self-heal commands on volume specified by <VOLNAME>"},
-
-        {"volume statedump <VOLNAME> [[nfs|quotad] [all|mem|iobuf|callpool|"
-         "priv|fd|inode|history]... | [client <hostname:process-id>]]",
-         cli_cmd_volume_statedump_cbk,
-         "perform statedump on bricks"},
-
-        {"volume list",
-         cli_cmd_volume_list_cbk,
-         "list all volumes in cluster"},
-
-        {"volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}"
-          "{inode [range]|entry [basename]|posix [range]}",
-          cli_cmd_volume_clearlocks_cbk,
-          "Clear locks held on path"
-        },
-        {"volume barrier <VOLNAME> {enable|disable}",
-         cli_cmd_volume_barrier_cbk,
-         "Barrier/unbarrier file operations on a volume"
-        },
-        {"volume get <VOLNAME|all> <key|all>",
-         cli_cmd_volume_getopt_cbk,
-         "Get the value of the all options or given option for volume <VOLNAME>"
-         " or all option. gluster volume get all all is to get all global "
-         "options"
-        },
-
-        { "volume reset-brick <VOLNAME> <SOURCE-BRICK> {{start} |"
-          " {<NEW-BRICK> commit}}",
-          cli_cmd_volume_reset_brick_cbk,
-          "reset-brick operations"},
-
-
-        { NULL, NULL, NULL }
-};
+    {"volume profile <VOLNAME> {start|info [peek|incremental "
+     "[peek]|cumulative|clear]|stop} [nfs]",
+     cli_cmd_volume_profile_cbk, "volume profile operations"},
+
+    {"volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick "
+     "<brick>] [list-cnt <value>] | "
+     "{read-perf|write-perf} [bs <size> count <count>] "
+     "[brick <brick>] [list-cnt <value>]",
+     cli_cmd_volume_top_cbk, "volume top operations"},
+
+    {"volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad]]"
+     " [detail|clients|mem|inode|fd|callpool|tasks|client-list]",
+     cli_cmd_volume_status_cbk,
+     "display status of all or specified volume(s)/brick"},
+
+    {"volume heal <VOLNAME> [enable | disable | full |"
+     "statistics [heal-count [replica <HOSTNAME:BRICKNAME>]] |"
+     "info [summary | split-brain] |"
+     "split-brain {bigger-file <FILE> | latest-mtime <FILE> |"
+     "source-brick <HOSTNAME:BRICKNAME> [<FILE>]} |"
+     "granular-entry-heal {enable | disable}]",
+     cli_cmd_volume_heal_cbk,
+     "self-heal commands on volume specified by <VOLNAME>"},
+
+    {"volume statedump <VOLNAME> [[nfs|quotad] [all|mem|iobuf|callpool|"
+     "priv|fd|inode|history]... | [client <hostname:process-id>]]",
+     cli_cmd_volume_statedump_cbk, "perform statedump on bricks"},
+
+    {"volume list", cli_cmd_volume_list_cbk, "list all volumes in cluster"},
+
+    {"volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}"
+     "{inode [range]|entry [basename]|posix [range]}",
+     cli_cmd_volume_clearlocks_cbk, "Clear locks held on path"},
+    {"volume barrier <VOLNAME> {enable|disable}", cli_cmd_volume_barrier_cbk,
+     "Barrier/unbarrier file operations on a volume"},
+    {"volume get <VOLNAME|all> <key|all>", cli_cmd_volume_getopt_cbk,
+     "Get the value of the all options or given option for volume <VOLNAME>"
+     " or all option. gluster volume get all all is to get all global "
+     "options"},
+
+    {"volume reset-brick <VOLNAME> <SOURCE-BRICK> {{start} |"
+     " {<NEW-BRICK> commit}}",
+     cli_cmd_volume_reset_brick_cbk, "reset-brick operations"},
+
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_quota_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                        const char **words, int wordcount)
+cli_cmd_quota_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                       const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *quota_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *quota_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_CALLOC (1, sizeof (quota_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, quota_cmds, sizeof (quota_cmds));
-        count = (sizeof (quota_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(quota_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, quota_cmds, sizeof(quota_cmds));
+    count = (sizeof(quota_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster quota commands");
-        cli_out ("=======================\n");
+    cli_out("\ngluster quota commands");
+    cli_out("=======================\n");
 
-        for (quota_cmd = cmd; quota_cmd->pattern; quota_cmd++)
-                if ((_gf_false == quota_cmd->disable) && (quota_cmd->desc))
-                        cli_out ("%s - %s", quota_cmd->pattern,
-                                 quota_cmd->desc);
+    for (quota_cmd = cmd; quota_cmd->pattern; quota_cmd++)
+        if ((_gf_false == quota_cmd->disable) && (quota_cmd->desc))
+            cli_out("%s - %s", quota_cmd->pattern, quota_cmd->desc);
 
-        cli_out ("\n");
-        GF_FREE (cmd);
+    cli_out("\n");
+    GF_FREE(cmd);
 
-        return 0;
+    return 0;
 }
 
 int
-cli_cmd_bitrot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_bitrot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *bitrot_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *bitrot_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_CALLOC (1, sizeof (bitrot_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, bitrot_cmds, sizeof (bitrot_cmds));
-        count = (sizeof (bitrot_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(bitrot_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, bitrot_cmds, sizeof(bitrot_cmds));
+    count = (sizeof(bitrot_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster bitrot commands");
-        cli_out ("========================\n");
+    cli_out("\ngluster bitrot commands");
+    cli_out("========================\n");
 
-        for (bitrot_cmd = cmd; bitrot_cmd->pattern; bitrot_cmd++)
-                if ((_gf_false == bitrot_cmd->disable) && (bitrot_cmd->desc))
-                        cli_out ("%s - %s", bitrot_cmd->pattern,
-                                 bitrot_cmd->desc);
+    for (bitrot_cmd = cmd; bitrot_cmd->pattern; bitrot_cmd++)
+        if ((_gf_false == bitrot_cmd->disable) && (bitrot_cmd->desc))
+            cli_out("%s - %s", bitrot_cmd->pattern, bitrot_cmd->desc);
 
-        cli_out ("\n");
-        GF_FREE (cmd);
+    cli_out("\n");
+    GF_FREE(cmd);
 
-        return 0;
+    return 0;
 }
 
 int
-cli_cmd_tier_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                       const char **words, int wordcount)
+cli_cmd_volume_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *tier_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *vol_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_CALLOC (1, sizeof (tier_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, tier_cmds, sizeof (tier_cmds));
-        count = (sizeof (tier_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(volume_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, volume_cmds, sizeof(volume_cmds));
+    count = (sizeof(volume_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster tier commands");
-        cli_out ("======================\n");
+    cli_out("\ngluster volume commands");
+    cli_out("========================\n");
 
-        for (tier_cmd = cmd; tier_cmd->pattern; tier_cmd++) {
-                if ((_gf_false == tier_cmd->disable) && tier_cmd->desc) {
-                        cli_out ("%s - %s", tier_cmd->pattern, tier_cmd->desc);
-                }
-        }
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+    for (vol_cmd = cmd; vol_cmd->pattern; vol_cmd++)
+        if (_gf_false == vol_cmd->disable)
+            cli_out("%s - %s", vol_cmd->pattern, vol_cmd->desc);
+
+    cli_out("\n");
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_volume_register(struct cli_state *state)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *vol_cmd = NULL;
-        int                   count    = 0;
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-        cmd = GF_CALLOC (1, sizeof (volume_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, volume_cmds, sizeof (volume_cmds));
-        count = (sizeof (volume_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    for (cmd = volume_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
-        cli_out ("\ngluster volume commands");
-        cli_out ("========================\n");
+    for (cmd = bitrot_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
-        for (vol_cmd = cmd; vol_cmd->pattern; vol_cmd++)
-                if (_gf_false == vol_cmd->disable)
-                        cli_out ("%s - %s", vol_cmd->pattern, vol_cmd->desc);
+    for (cmd = quota_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+out:
+    return ret;
 }
 
-int
-cli_cmd_volume_register (struct cli_state *state)
+static int
+gf_asprintf_append(char **string_ptr, const char *format, ...)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
+    va_list arg;
+    int rv = 0;
+    char *tmp = *string_ptr;
 
-        for (cmd = volume_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    va_start(arg, format);
+    rv = gf_vasprintf(string_ptr, format, arg);
+    va_end(arg);
 
-        for (cmd = bitrot_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    if (tmp)
+        GF_FREE(tmp);
 
-        for (cmd = quota_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
-
-#if !defined(__NetBSD__)
-        for (cmd = tier_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
-
-#endif
-
-out:
-        return ret;
+    return rv;
 }
diff --git a/cli/src/cli-cmd.c b/cli/src/cli-cmd.c
index 236009b449e..2d458b16a56 100644
--- a/cli/src/cli-cmd.c
+++ b/cli/src/cli-cmd.c
@@ -22,395 +22,390 @@
 
 static int cmd_done;
 static int cmd_sent;
-static pthread_cond_t      cond  = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t     cond_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t      conn  = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t     conn_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t conn = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t conn_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-int    cli_op_ret = 0;
-int    connected = 0;
-
-int cli_cmd_log_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount);
+int cli_op_ret = 0;
+static gf_boolean_t connected = _gf_false;
 
 static unsigned
-cli_cmd_needs_connection (struct cli_cmd_word *word)
+cli_cmd_needs_connection(struct cli_cmd_word *word)
 {
-        if (!strcasecmp ("quit", word->word))
-                return 0;
+    if (!strcasecmp("quit", word->word))
+        return 0;
 
-        if (!strcasecmp ("help", word->word))
-                return 0;
+    if (!strcasecmp("help", word->word))
+        return 0;
 
-        if (!strcasecmp ("getwd", word->word))
-                return 1;
+    if (!strcasecmp("getwd", word->word))
+        return 1;
 
-        if (!strcasecmp ("exit", word->word))
-                return 0;
+    if (!strcasecmp("exit", word->word))
+        return 0;
 
-        return cli_default_conn_timeout;
+    return cli_default_conn_timeout;
 }
 
 int
-cli_cmd_status_reset (void)
+cli_cmd_status_reset(void)
 {
-        int ret = 0;
-
-        ret = cli_cmd_lock ();
-        {
-                if (ret == 0) {
-                        cmd_sent = 0;
-                        cmd_done = 0;
-                }
-        }
-        ret = cli_cmd_unlock ();
-        return ret;
+    int ret = 0;
 
+    ret = cli_cmd_lock();
+    {
+        if (ret == 0) {
+            cmd_sent = 0;
+            cmd_done = 0;
+        }
+    }
+    ret = cli_cmd_unlock();
+    return ret;
 }
 
 int
-cli_cmd_sent_status_get (int *status)
+cli_cmd_sent_status_get(int *status)
 {
-        int ret = 0;
-        GF_ASSERT (status);
-
-        ret = cli_cmd_lock ();
-        {
-                if (ret == 0)
-                        *status = cmd_sent;
-        }
-        ret = cli_cmd_unlock ();
-        return ret;
+    int ret = 0;
+    GF_ASSERT(status);
+
+    ret = cli_cmd_lock();
+    {
+        if (ret == 0)
+            *status = cmd_sent;
+    }
+    ret = cli_cmd_unlock();
+    return ret;
 }
 
 int
-cli_cmd_process (struct cli_state *state, int argc, char **argv)
+cli_cmd_process(struct cli_state *state, int argc, char **argv)
 {
-        int                  ret = 0;
-        struct cli_cmd_word *word = NULL;
-        struct cli_cmd_word *next = NULL;
-        int                  i = 0;
+    int ret = 0;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
+    int i = 0;
 
-        word = &state->tree.root;
+    word = &state->tree.root;
 
-        if (!argc)
-                return 0;
+    if (!argc)
+        return 0;
 
-        for (i = 0; i < argc; i++) {
-                next = cli_cmd_nextword (word, argv[i]);
+    for (i = 0; i < argc; i++) {
+        next = cli_cmd_nextword(word, argv[i]);
 
-                word = next;
-                if (!word)
-                        break;
+        word = next;
+        if (!word)
+            break;
 
-                if (word->cbkfn)
-                        break;
-        }
+        if (word->cbkfn)
+            break;
+    }
 
-        if (!word) {
-                cli_out ("unrecognized word: %s (position %d)",
-                         argv[i], i);
-                return -1;
-        }
+    if (!word) {
+        cli_out("unrecognized word: %s (position %d)\n", argv[i], i);
+        usage();
+        return -1;
+    }
 
-        if (!word->cbkfn) {
-                cli_out ("unrecognized command");
-                return -1;
-        }
+    if (!word->cbkfn) {
+        cli_out("unrecognized command\n");
+        usage();
+        return -1;
+    }
 
-	if ( strcmp (word->word,"help")==0 )
-		goto callback;
+    if (strcmp(word->word, "help") == 0)
+        goto callback;
 
-        state->await_connected = cli_cmd_needs_connection (word);
+    state->await_connected = cli_cmd_needs_connection(word);
 
-        ret = cli_cmd_await_connected (state->await_connected);
-        if (ret) {
-                cli_out ("Connection failed. Please check if gluster "
-                          "daemon is operational.");
-                gf_log ("", GF_LOG_INFO, "Exiting with: %d", ret);
-                exit (ret);
-        }
+    ret = cli_cmd_await_connected(state->await_connected);
+    if (ret) {
+        cli_out(
+            "Connection failed. Please check if gluster "
+            "daemon is operational.");
+        gf_log("", GF_LOG_INFO, "Exiting with: %d", ret);
+        exit(ret);
+    }
 
 callback:
-        ret = word->cbkfn (state, word, (const char **)argv, argc);
-        (void) cli_cmd_status_reset ();
-        return ret;
+    ret = word->cbkfn(state, word, (const char **)argv, argc);
+    (void)cli_cmd_status_reset();
+    return ret;
 }
 
 int
-cli_cmd_input_token_count (const char *text)
+cli_cmd_input_token_count(const char *text)
 {
-        int          count = 0;
-        const char  *trav = NULL;
-        int          is_spc = 1;
-
-        for (trav = text; *trav; trav++) {
-                if (*trav == ' ') {
-                        is_spc = 1;
-                } else {
-                        if (is_spc) {
-                                count++;
-                                is_spc = 0;
-                        }
-                }
+    int count = 0;
+    const char *trav = NULL;
+    int is_spc = 1;
+
+    for (trav = text; *trav; trav++) {
+        if (*trav == ' ') {
+            is_spc = 1;
+        } else {
+            if (is_spc) {
+                count++;
+                is_spc = 0;
+            }
         }
+    }
 
-        return count;
+    return count;
 }
 
-
 int
-cli_cmd_process_line (struct cli_state *state, const char *text)
+cli_cmd_process_line(struct cli_state *state, const char *text)
 {
-        int     count = 0;
-        char  **tokens = NULL;
-        char  **tokenp = NULL;
-        char   *token = NULL;
-        char   *copy = NULL;
-        char   *saveptr = NULL;
-        int     i = 0;
-        int     ret = -1;
-
-        count = cli_cmd_input_token_count (text);
-
-        tokens = calloc (count + 1, sizeof (*tokens));
-        if (!tokens)
-                return -1;
-
-        copy = strdup (text);
-        if (!copy)
-                goto out;
-
-        tokenp = tokens;
-
-        for (token = strtok_r (copy, " \t\r\n", &saveptr); token;
-             token = strtok_r (NULL, " \t\r\n", &saveptr)) {
-                *tokenp = strdup (token);
-
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-
-        }
-
-        ret = cli_cmd_process (state, count, tokens);
+    int count = 0;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char *copy = NULL;
+    char *saveptr = NULL;
+    int i = 0;
+    int ret = -1;
+
+    count = cli_cmd_input_token_count(text);
+
+    tokens = calloc(count + 1, sizeof(*tokens));
+    if (!tokens)
+        return -1;
+
+    copy = strdup(text);
+    if (!copy)
+        goto out;
+
+    tokenp = tokens;
+
+    for (token = strtok_r(copy, " \t\r\n", &saveptr); token;
+         token = strtok_r(NULL, " \t\r\n", &saveptr)) {
+        *tokenp = strdup(token);
+
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
+
+    ret = cli_cmd_process(state, count, tokens);
 out:
-        free (copy);
+    free(copy);
 
-        if (tokens)
-                cli_cmd_tokens_destroy (tokens);
+    if (tokens)
+        cli_cmd_tokens_destroy(tokens);
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmds_register (struct cli_state *state)
+cli_cmds_register(struct cli_state *state)
 {
-        int  ret = 0;
-
-        ret = cli_cmd_volume_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_probe_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_system_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_misc_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_snapshot_register (state);
-        if (ret)
-                goto out;
-        ret = cli_cmd_global_register (state);
-        if (ret)
-                goto out;
+    int ret = 0;
+
+    ret = cli_cmd_volume_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_probe_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_system_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_misc_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_snapshot_register(state);
+    if (ret)
+        goto out;
+    ret = cli_cmd_global_register(state);
+    if (ret)
+        goto out;
 out:
-        return ret;
-}
-
-int
-cli_cmd_cond_init ()
-{
-
-       pthread_mutex_init (&cond_mutex, NULL);
-       pthread_cond_init (&cond, NULL);
-
-       pthread_mutex_init (&conn_mutex, NULL);
-       pthread_cond_init (&conn, NULL);
-
-       return 0;
+    return ret;
 }
 
 int
-cli_cmd_lock ()
+cli_cmd_lock()
 {
-       pthread_mutex_lock (&cond_mutex);
-       return 0;
+    pthread_mutex_lock(&cond_mutex);
+    return 0;
 }
 
 int
-cli_cmd_unlock ()
+cli_cmd_unlock()
 {
-        pthread_mutex_unlock (&cond_mutex);
-        return 0;
+    pthread_mutex_unlock(&cond_mutex);
+    return 0;
 }
 
 static void
-seconds_from_now (unsigned secs, struct timespec *ts)
+seconds_from_now(unsigned secs, struct timespec *ts)
 {
-        struct timeval tv = {0,};
+    struct timeval tv = {
+        0,
+    };
 
-        gettimeofday (&tv, NULL);
+    gettimeofday(&tv, NULL);
 
-        ts->tv_sec = tv.tv_sec + secs;
-        ts->tv_nsec = tv.tv_usec * 1000;
+    ts->tv_sec = tv.tv_sec + secs;
+    ts->tv_nsec = tv.tv_usec * 1000;
 }
 
 int
-cli_cmd_await_response (unsigned time)
+cli_cmd_await_response(unsigned time)
 {
-        struct  timespec        ts = {0,};
-        int                     ret = 0;
+    struct timespec ts = {
+        0,
+    };
+    int ret = 0;
 
-        cli_op_ret = -1;
+    cli_op_ret = -1;
 
-        seconds_from_now (time, &ts);
-        while (!cmd_done && !ret) {
-                ret = pthread_cond_timedwait (&cond, &cond_mutex,
-                                        &ts);
-        }
+    seconds_from_now(time, &ts);
+    while (!cmd_done && !ret) {
+        ret = pthread_cond_timedwait(&cond, &cond_mutex, &ts);
+    }
 
-        if (!cmd_done) {
-                if (ret == ETIMEDOUT)
-                        cli_out ("Error : Request timed out");
-                else
-                        cli_out ("Error : Command returned with error code:%d",
-                                 ret);
-        }
-        cmd_done = 0;
+    if (!cmd_done) {
+        if (ret == ETIMEDOUT)
+            cli_out("Error : Request timed out");
+        else
+            cli_out("Error : Command returned with error code:%d", ret);
+    }
+    cmd_done = 0;
 
-        return cli_op_ret;
+    return cli_op_ret;
 }
 
 /* This function must be called _only_ after all actions associated with
  * command processing is complete. Otherwise, gluster process may exit before
  * reporting results to stdout/stderr. */
 int
-cli_cmd_broadcast_response (int32_t status)
+cli_cmd_broadcast_response(int32_t status)
 {
-
-        pthread_mutex_lock (&cond_mutex);
-        {
-                if (!cmd_sent)
-                        goto out;
-                cmd_done = 1;
-                cli_op_ret = status;
-                pthread_cond_broadcast (&cond);
-        }
-
+    pthread_mutex_lock(&cond_mutex);
+    {
+        if (!cmd_sent)
+            goto out;
+        cmd_done = 1;
+        cli_op_ret = status;
+        pthread_cond_broadcast(&cond);
+    }
 
 out:
-        pthread_mutex_unlock (&cond_mutex);
-        return 0;
+    pthread_mutex_unlock(&cond_mutex);
+    return 0;
 }
 
 int32_t
-cli_cmd_await_connected (unsigned conn_timo)
+cli_cmd_await_connected(unsigned conn_timo)
 {
-        int32_t                 ret = 0;
-        struct  timespec        ts = {0,};
-
-        if (!conn_timo)
-                return 0;
-
-        pthread_mutex_lock (&conn_mutex);
-        {
-                seconds_from_now (conn_timo, &ts);
-                while (!connected && !ret) {
-                        ret = pthread_cond_timedwait (&conn, &conn_mutex,
-                                                      &ts);
-                }
-        }
-        pthread_mutex_unlock (&conn_mutex);
+    int32_t ret = 0;
+    struct timespec ts = {
+        0,
+    };
+
+    if (!conn_timo)
+        return 0;
 
+    pthread_mutex_lock(&conn_mutex);
+    {
+        seconds_from_now(conn_timo, &ts);
+        while (!connected && !ret) {
+            ret = pthread_cond_timedwait(&conn, &conn_mutex, &ts);
+        }
+    }
+    pthread_mutex_unlock(&conn_mutex);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_broadcast_connected ()
+cli_cmd_broadcast_connected(gf_boolean_t status)
 {
-        pthread_mutex_lock (&conn_mutex);
-        {
-                connected = 1;
-                pthread_cond_broadcast (&conn);
-        }
-
-        pthread_mutex_unlock (&conn_mutex);
-
-        return 0;
+    pthread_mutex_lock(&conn_mutex);
+    {
+        connected = status;
+        pthread_cond_broadcast(&conn);
+    }
+    pthread_mutex_unlock(&conn_mutex);
+
+    return 0;
 }
 
-int
-cli_cmd_submit (struct rpc_clnt* rpc, void *req, call_frame_t *frame,
-                rpc_clnt_prog_t *prog,
-                int procnum, struct iobref *iobref,
-                xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+gf_boolean_t
+cli_cmd_connected(void)
 {
-        int             ret = -1;
-        unsigned        timeout = 0;
-
-        if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||
-            (GLUSTER_CLI_HEAL_VOLUME == procnum))
-                timeout = cli_ten_minutes_timeout;
-        else
-                timeout = cli_default_conn_timeout;
-
-        cli_cmd_lock ();
-        cmd_sent = 0;
-        ret = cli_submit_request (rpc, req, frame, prog,
-                                  procnum, NULL, this, cbkfn, xdrproc);
+    gf_boolean_t status;
 
-        if (!ret) {
-                cmd_sent = 1;
-                ret = cli_cmd_await_response (timeout);
-        }
+    pthread_mutex_lock(&conn_mutex);
+    {
+        status = connected;
+    }
+    pthread_mutex_unlock(&conn_mutex);
 
-        cli_cmd_unlock ();
+    return status;
+}
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+int
+cli_cmd_submit(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+               rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+               xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+{
+    int ret = -1;
+    unsigned timeout = 0;
+
+    if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||
+        (GLUSTER_CLI_HEAL_VOLUME == procnum) ||
+        (GLUSTER_CLI_GANESHA == procnum))
+        timeout = cli_ten_minutes_timeout;
+    else
+        timeout = cli_default_conn_timeout;
+
+    cli_cmd_lock();
+    cmd_sent = 0;
+    ret = cli_submit_request(rpc, req, frame, prog, procnum, NULL, this, cbkfn,
+                             xdrproc);
+
+    if (!ret) {
+        cmd_sent = 1;
+        ret = cli_cmd_await_response(timeout);
+    }
+
+    cli_cmd_unlock();
+
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_cmd_pattern_cmp (void *a, void *b)
+cli_cmd_pattern_cmp(void *a, void *b)
 {
-        struct cli_cmd *ia = NULL;
-        struct cli_cmd *ib = NULL;
-        int            ret = 0;
-
-        ia = a;
-        ib = b;
-        if (strcmp (ia->pattern, ib->pattern) > 0)
-                ret = 1;
-        else if (strcmp (ia->pattern, ib->pattern) < 0)
-                ret = -1;
-        else
-                ret = 0;
-        return ret;
+    struct cli_cmd *ia = NULL;
+    struct cli_cmd *ib = NULL;
+    int ret = 0;
+
+    ia = a;
+    ib = b;
+    if (strcmp(ia->pattern, ib->pattern) > 0)
+        ret = 1;
+    else if (strcmp(ia->pattern, ib->pattern) < 0)
+        ret = -1;
+    else
+        ret = 0;
+    return ret;
 }
 
 void
-cli_cmd_sort (struct cli_cmd *cmd, int count)
+cli_cmd_sort(struct cli_cmd *cmd, int count)
 {
-        gf_array_insertionsort (cmd, 1, count - 2, sizeof(struct cli_cmd),
-                                cli_cmd_pattern_cmp);
+    gf_array_insertionsort(cmd, 1, count - 2, sizeof(struct cli_cmd),
+                           cli_cmd_pattern_cmp);
 }
diff --git a/cli/src/cli-cmd.h b/cli/src/cli-cmd.h
index 54e3686c9e1..c1c068c7085 100644
--- a/cli/src/cli-cmd.h
+++ b/cli/src/cli-cmd.h
@@ -13,107 +13,117 @@
 #include <netdb.h>
 
 #include "cli.h"
-#include "list.h"
-
-#define GLUSTER_SHARED_STORAGE      "gluster_shared_storage"
-
-#define CLI_LOCAL_INIT(local, words, frame, dictionary) \
-        do {                                                 \
-                local = cli_local_get ();                    \
-                                                             \
-                if (local) {                                 \
-                        local->words = words;                \
-                        if (dictionary)                      \
-                                local->dict = dictionary;    \
-                        if (frame)                           \
-                                frame->local = local;        \
-                }                                            \
-        } while (0)
-
-#define CLI_STACK_DESTROY(_frame)                                       \
-        do {                                                            \
-                if (_frame) {                                           \
-                        if (_frame->local) {                            \
-                                gf_log ("cli", GF_LOG_DEBUG, "frame->local " \
-                                        "is not NULL (%p)", _frame->local); \
-                                cli_local_wipe (_frame->local);         \
-                                _frame->local = NULL;                   \
-                        }                                               \
-                        STACK_DESTROY (_frame->root);                   \
-                }                                                       \
-        } while (0);
-
-typedef enum {
-        GF_ANSWER_YES = 1,
-        GF_ANSWER_NO  = 2
-} gf_answer_t;
+#include <glusterfs/list.h>
+
+#define GLUSTER_SHARED_STORAGE "gluster_shared_storage"
+
+#define CLI_LOCAL_INIT(local, words, frame, dictionary)                        \
+    do {                                                                       \
+        local = cli_local_get();                                               \
+                                                                               \
+        if (local) {                                                           \
+            local->words = words;                                              \
+            if (dictionary)                                                    \
+                local->dict = dictionary;                                      \
+            if (frame)                                                         \
+                frame->local = local;                                          \
+        }                                                                      \
+    } while (0)
+
+#define CLI_STACK_DESTROY(_frame)                                              \
+    do {                                                                       \
+        if (_frame) {                                                          \
+            if (_frame->local) {                                               \
+                gf_log("cli", GF_LOG_DEBUG,                                    \
+                       "frame->local "                                         \
+                       "is not NULL (%p)",                                     \
+                       _frame->local);                                         \
+                cli_local_wipe(_frame->local);                                 \
+                _frame->local = NULL;                                          \
+            }                                                                  \
+            STACK_DESTROY(_frame->root);                                       \
+        }                                                                      \
+    } while (0);
+
+typedef enum { GF_ANSWER_YES = 1, GF_ANSWER_NO = 2 } gf_answer_t;
 
 struct cli_cmd {
-        const char         *pattern;
-        cli_cmd_cbk_t      *cbk;
-        const char         *desc;
-        cli_cmd_reg_cbk_t  *reg_cbk; /* callback to check in runtime if the   *
-                                      * command should be enabled or disabled */
-        gf_boolean_t       disable;
+    const char *pattern;
+    cli_cmd_cbk_t *cbk;
+    const char *desc;
+    cli_cmd_reg_cbk_t *reg_cbk; /* callback to check in runtime if the   *
+                                 * command should be enabled or disabled */
+    gf_boolean_t disable;
 };
 
 struct cli_cmd_volume_get_ctx_ {
-        char            *volname;
-        int             flags;
+    char *volname;
+    int flags;
 };
 
 typedef struct cli_profile_info_ {
-        uint64_t fop_hits;
-        double min_latency;
-        double max_latency;
-        double avg_latency;
-        char   *fop_name;
-        double percentage_avg_latency;
+    uint64_t fop_hits;
+    double min_latency;
+    double max_latency;
+    double avg_latency;
+    char *fop_name;
+    double percentage_avg_latency;
 } cli_profile_info_t;
 
 typedef struct cli_cmd_volume_get_ctx_ cli_cmd_volume_get_ctx_t;
 
-int cli_cmd_volume_register (struct cli_state *state);
-
-int cli_cmd_probe_register (struct cli_state *state);
+int
+cli_cmd_volume_register(struct cli_state *state);
 
-int cli_cmd_system_register (struct cli_state *state);
+int
+cli_cmd_probe_register(struct cli_state *state);
 
-int cli_cmd_snapshot_register (struct cli_state *state);
+int
+cli_cmd_system_register(struct cli_state *state);
 
-int cli_cmd_global_register (struct cli_state *state);
+int
+cli_cmd_snapshot_register(struct cli_state *state);
 
-int cli_cmd_misc_register (struct cli_state *state);
+int
+cli_cmd_global_register(struct cli_state *state);
 
-struct cli_cmd_word *cli_cmd_nextword (struct cli_cmd_word *word,
-                                       const char *text);
-void cli_cmd_tokens_destroy (char **tokens);
+int
+cli_cmd_misc_register(struct cli_state *state);
 
-int cli_cmd_await_response (unsigned time);
+struct cli_cmd_word *
+cli_cmd_nextword(struct cli_cmd_word *word, const char *text);
+void
+cli_cmd_tokens_destroy(char **tokens);
 
-int cli_cmd_broadcast_response (int32_t status);
+int
+cli_cmd_await_response(unsigned time);
 
-int cli_cmd_cond_init ();
+int
+cli_cmd_broadcast_response(int32_t status);
 
-int cli_cmd_lock ();
+int
+cli_cmd_lock();
 
-int cli_cmd_unlock ();
+int
+cli_cmd_unlock();
 
 int
-cli_cmd_submit (struct rpc_clnt *rpc, void *req, call_frame_t *frame,
-                rpc_clnt_prog_t *prog,
-                int procnum, struct iobref *iobref,
-                xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc);
+cli_cmd_submit(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+               rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+               xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc);
 
-int cli_cmd_pattern_cmp (void *a, void *b);
+int
+cli_cmd_pattern_cmp(void *a, void *b);
 
-void cli_cmd_sort (struct cli_cmd *cmd, int count);
+void
+cli_cmd_sort(struct cli_cmd *cmd, int count);
 
 gf_answer_t
-cli_cmd_get_confirmation (struct cli_state *state, const char *question);
-int cli_cmd_sent_status_get (int *status);
+cli_cmd_get_confirmation(struct cli_state *state, const char *question);
+int
+cli_cmd_sent_status_get(int *status);
 
 gf_boolean_t
-_limits_set_on_volume (char *volname, int type);
+_limits_set_on_volume(char *volname, int type);
 
 #endif /* __CLI_CMD_H__ */
diff --git a/cli/src/cli-mem-types.h b/cli/src/cli-mem-types.h
index 5468b25cc0c..b42b4dd86c2 100644
--- a/cli/src/cli-mem-types.h
+++ b/cli/src/cli-mem-types.h
@@ -10,21 +10,21 @@
 #ifndef __CLI_MEM_TYPES_H__
 #define __CLI_MEM_TYPES_H__
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 #define CLI_MEM_TYPE_START (gf_common_mt_end + 1)
 
 enum cli_mem_types_ {
-        cli_mt_xlator_list_t = CLI_MEM_TYPE_START,
-        cli_mt_xlator_t,
-        cli_mt_xlator_cmdline_option_t,
-        cli_mt_char,
-        cli_mt_call_pool_t,
-        cli_mt_cli_local_t,
-        cli_mt_cli_get_vol_ctx_t,
-        cli_mt_append_str,
-        cli_mt_cli_cmd,
-        cli_mt_end
+    cli_mt_xlator_list_t = CLI_MEM_TYPE_START,
+    cli_mt_xlator_t,
+    cli_mt_xlator_cmdline_option_t,
+    cli_mt_char,
+    cli_mt_call_pool_t,
+    cli_mt_cli_local_t,
+    cli_mt_cli_get_vol_ctx_t,
+    cli_mt_append_str,
+    cli_mt_cli_cmd,
+    cli_mt_end
 
 };
 
diff --git a/cli/src/cli-quotad-client.c b/cli/src/cli-quotad-client.c
index 5be9c80c858..772b8f75bd9 100644
--- a/cli/src/cli-quotad-client.c
+++ b/cli/src/cli-quotad-client.c
@@ -10,140 +10,137 @@
 
 #include "cli-quotad-client.h"
 
-extern struct rpc_clnt global_quotad_rpc;
-extern struct rpc_clnt_program cli_quotad_clnt;
-
 int
-cli_quotad_submit_request (void *req, call_frame_t *frame,
-                           rpc_clnt_prog_t *prog,
-                           int procnum, struct iobref *iobref,
-                           xlator_t *this, fop_cbk_fn_t cbkfn,
-                           xdrproc_t xdrproc)
+cli_quotad_submit_request(void *req, call_frame_t *frame, rpc_clnt_prog_t *prog,
+                          int procnum, struct iobref *iobref, xlator_t *this,
+                          fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
 {
-        int           ret        = -1;
-        int           count      = 0;
-        struct iovec  iov        = {0, };
-        struct iobuf *iobuf      = NULL;
-        char          new_iobref = 0;
-        ssize_t       xdr_size   = 0;
-
-        GF_ASSERT (this);
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-                iobuf = iobuf_get2 (this->ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                if (!iobref) {
-                        iobref = iobref_new ();
-                        if (!iobref) {
-                                goto out;
-                        }
-
-                        new_iobref = 1;
-                }
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_size (iobuf);
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    char new_iobref = 0;
+    ssize_t xdr_size = 0;
+
+    GF_ASSERT(this);
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+        iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        if (!iobref) {
+            iobref = iobref_new();
+            if (!iobref) {
+                goto out;
+            }
+
+            new_iobref = 1;
+        }
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_size(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            goto out;
         }
+        iov.iov_len = ret;
+        count = 1;
+    }
 
-        /* Send the msg */
-        ret = rpc_clnt_submit (&global_quotad_rpc, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
-        ret = 0;
+    /* Send the msg */
+    ret = rpc_clnt_submit(global_quotad_rpc, prog, procnum, cbkfn, &iov, count,
+                          NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    ret = 0;
 
 out:
-        if (new_iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (new_iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_quotad_notify (struct rpc_clnt *rpc, void *mydata,
-                   rpc_clnt_event_t event, void *data)
+cli_quotad_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                  void *data)
 {
-        xlator_t                *this = NULL;
-        int                     ret = 0;
+    xlator_t *this = NULL;
+    int ret = 0;
 
-        this = mydata;
+    this = mydata;
 
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
-                break;
+    switch (event) {
+        case RPC_CLNT_CONNECT: {
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
+            break;
         }
 
-        case RPC_CLNT_DISCONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
-                break;
+        case RPC_CLNT_DISCONNECT: {
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
+            break;
         }
 
         default:
-                gf_log (this->name, GF_LOG_TRACE,
-                        "got some other RPC event %d", event);
-                ret = 0;
-                break;
-        }
+            gf_log(this->name, GF_LOG_TRACE, "got some other RPC event %d",
+                   event);
+            ret = 0;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 struct rpc_clnt *
-cli_quotad_clnt_init (xlator_t *this, dict_t *options)
+cli_quotad_clnt_init(xlator_t *this, dict_t *options)
 {
-        struct rpc_clnt *rpc  = NULL;
-        int              ret  = -1;
-
-
-        ret = dict_set_str (options, "transport.address-family", "unix");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (options, "transport.socket.connect-path",
-                            "/var/run/gluster/quotad.socket");
-        if (ret)
-                goto out;
-
-        rpc = rpc_clnt_new (options, this, this->name, 16);
-        if (!rpc)
-                goto out;
-
-        ret = rpc_clnt_register_notify (rpc, cli_quotad_notify, this);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "failed to register notify");
-                goto out;
-        }
-
-        rpc_clnt_start (rpc);
+    struct rpc_clnt *rpc = NULL;
+    int ret = -1;
+
+    ret = dict_set_nstrn(options, "transport.address-family",
+                         SLEN("transport.address-family"), "unix",
+                         SLEN("unix"));
+    if (ret)
+        goto out;
+
+    ret = dict_set_nstrn(options, "transport-type", SLEN("transport-type"),
+                         "socket", SLEN("socket"));
+    if (ret)
+        goto out;
+
+    ret = dict_set_nstrn(options, "transport.socket.connect-path",
+                         SLEN("transport.socket.connect-path"),
+                         "/var/run/gluster/quotad.socket",
+                         SLEN("/var/run/gluster/quotad.socket"));
+    if (ret)
+        goto out;
+
+    rpc = rpc_clnt_new(options, this, this->name, 16);
+    if (!rpc)
+        goto out;
+
+    ret = rpc_clnt_register_notify(rpc, cli_quotad_notify, this);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "failed to register notify");
+        goto out;
+    }
+
+    rpc_clnt_start(rpc);
 out:
-        if (ret) {
-                if (rpc)
-                        rpc_clnt_unref (rpc);
-                rpc = NULL;
-        }
+    if (ret) {
+        if (rpc)
+            rpc_clnt_unref(rpc);
+        rpc = NULL;
+    }
 
-        return rpc;
+    return rpc;
 }
-
diff --git a/cli/src/cli-quotad-client.h b/cli/src/cli-quotad-client.h
index aa0b42af38d..71a44e5916b 100644
--- a/cli/src/cli-quotad-client.h
+++ b/cli/src/cli-quotad-client.h
@@ -8,26 +8,22 @@
    cases as published by the Free Software Foundation.
 */
 #include "cli.h"
-#include "compat-errno.h"
-#include "compat.h"
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
 #include "cli-cmd.h"
 #include "cli1-xdr.h"
 #include "xdr-generic.h"
 #include "protocol-common.h"
 #include "cli-mem-types.h"
 
-
 int
-cli_quotad_submit_request (void *req, call_frame_t *frame,
-                           rpc_clnt_prog_t *prog,
-                           int procnum, struct iobref *iobref,
-                           xlator_t *this, fop_cbk_fn_t cbkfn,
-                           xdrproc_t xdrproc);
+cli_quotad_submit_request(void *req, call_frame_t *frame, rpc_clnt_prog_t *prog,
+                          int procnum, struct iobref *iobref, xlator_t *this,
+                          fop_cbk_fn_t cbkfn, xdrproc_t xdrproc);
 
 struct rpc_clnt *
-cli_quotad_clnt_init (xlator_t *this, dict_t *options);
+cli_quotad_clnt_init(xlator_t *this, dict_t *options);
 
 int
-cli_quotad_notify (struct rpc_clnt *rpc, void *mydata,
-                   rpc_clnt_event_t event, void *data);
-
+cli_quotad_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                  void *data);
diff --git a/cli/src/cli-rl.c b/cli/src/cli-rl.c
index 4745cf49369..7a38a0b882a 100644
--- a/cli/src/cli-rl.c
+++ b/cli/src/cli-rl.c
@@ -17,7 +17,7 @@
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
 
-#include "event.h"
+#include <glusterfs/gf-event.h>
 
 #include <fnmatch.h>
 
@@ -27,390 +27,376 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 
-
 int
-cli_rl_out (struct cli_state *state, const char *fmt, va_list ap)
+cli_rl_out(struct cli_state *state, const char *fmt, va_list ap)
 {
-        int tmp_rl_point = rl_point;
-        int            n = rl_end;
-        int            ret = 0;
+    int tmp_rl_point = rl_point;
+    int n = rl_end;
+    int ret = 0;
 
-        if (rl_end >= 0 ) {
-                rl_kill_text (0, rl_end);
-                rl_redisplay ();
-        }
+    if (rl_end >= 0) {
+        rl_kill_text(0, rl_end);
+        rl_redisplay();
+    }
 
-        printf ("\r%*s\r", (int)strlen (state->prompt), "");
+    printf("\r%*s\r", (int)strlen(state->prompt), "");
 
-        ret = vprintf (fmt, ap);
+    ret = vprintf(fmt, ap);
 
-        printf ("\n");
-        fflush(stdout);
+    printf("\n");
+    fflush(stdout);
 
-        if (n) {
-                rl_do_undo ();
-                rl_point = tmp_rl_point;
-                rl_reset_line_state ();
-        }
+    if (n) {
+        rl_do_undo();
+        rl_point = tmp_rl_point;
+        rl_reset_line_state();
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_rl_err (struct cli_state *state, const char *fmt, va_list ap)
+cli_rl_err(struct cli_state *state, const char *fmt, va_list ap)
 {
-        int tmp_rl_point = rl_point;
-        int            n = rl_end;
-        int            ret = 0;
+    int tmp_rl_point = rl_point;
+    int n = rl_end;
+    int ret = 0;
 
-        if (rl_end >= 0 ) {
-                rl_kill_text (0, rl_end);
-                rl_redisplay ();
-        }
+    if (rl_end >= 0) {
+        rl_kill_text(0, rl_end);
+        rl_redisplay();
+    }
 
-        fprintf (stderr, "\r%*s\r", (int)strlen (state->prompt), "");
+    fprintf(stderr, "\r%*s\r", (int)strlen(state->prompt), "");
 
-        ret = vfprintf (stderr, fmt, ap);
+    ret = vfprintf(stderr, fmt, ap);
 
-        fprintf (stderr, "\n");
-        fflush(stderr);
+    fprintf(stderr, "\n");
+    fflush(stderr);
 
-        if (n) {
-                rl_do_undo ();
-                rl_point = tmp_rl_point;
-                rl_reset_line_state ();
-        }
+    if (n) {
+        rl_do_undo();
+        rl_point = tmp_rl_point;
+        rl_reset_line_state();
+    }
 
-        return ret;
+    return ret;
 }
 
-
 void
-cli_rl_process_line (char *line)
+cli_rl_process_line(char *line)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
+    struct cli_state *state = NULL;
+    int ret = 0;
 
-        state = global_state;
+    state = global_state;
 
-        state->rl_processing = 1;
-        {
-                ret = cli_cmd_process_line (state, line);
-                if (ret)
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "failed to process line");
-
-                add_history (line);
-        }
-        state->rl_processing = 0;
+    state->rl_processing = 1;
+    {
+        ret = cli_cmd_process_line(state, line);
+        if (ret)
+            gf_log(THIS->name, GF_LOG_WARNING, "failed to process line");
 
+        add_history(line);
+    }
+    state->rl_processing = 0;
 }
 
-
-int
-cli_rl_stdin (int fd, int idx, int gen, void *data,
-              int poll_out, int poll_in, int poll_err)
+void
+cli_rl_stdin(int fd, int idx, int gen, void *data, int poll_out, int poll_in,
+             int poll_err, char event_thread_died)
 {
-        struct cli_state *state = NULL;
+    struct cli_state *state = NULL;
 
-        state = data;
+    state = data;
 
-        rl_callback_read_char ();
+    rl_callback_read_char();
 
-        event_handled (state->ctx->event_pool, fd, idx, gen);
+    gf_event_handled(state->ctx->event_pool, fd, idx, gen);
 
-        return 0;
+    return;
 }
 
-
 char *
-cli_rl_autocomplete_entry (const char *text, int times)
+cli_rl_autocomplete_entry(const char *text, int times)
 {
-        struct cli_state  *state = NULL;
-        char              *retp = NULL;
+    struct cli_state *state = NULL;
+    char *retp = NULL;
 
-        state = global_state;
+    state = global_state;
 
-        if (!state->matchesp)
-                return NULL;
+    if (!state->matchesp)
+        return NULL;
 
-        retp = *state->matchesp;
+    retp = *state->matchesp;
 
-        state->matchesp++;
+    state->matchesp++;
 
-        return retp ? strdup (retp) : NULL;
+    return retp ? strdup(retp) : NULL;
 }
 
-
 int
-cli_rl_token_count (const char *text)
+cli_rl_token_count(const char *text)
 {
-        int          count = 0;
-        const char  *trav = NULL;
-        int          is_spc = 1;
-
-        for (trav = text; *trav; trav++) {
-                if (*trav == ' ') {
-                        is_spc = 1;
-                } else {
-                        if (is_spc) {
-                                count++;
-                                is_spc = 0;
-                        }
-                }
+    int count = 0;
+    const char *trav = NULL;
+    int is_spc = 1;
+
+    for (trav = text; *trav; trav++) {
+        if (*trav == ' ') {
+            is_spc = 1;
+        } else {
+            if (is_spc) {
+                count++;
+                is_spc = 0;
+            }
         }
+    }
 
-        if (is_spc)
-                /* what needs to be autocompleted is a full
-                   new word, and not extend the last word
-                */
-                count++;
+    if (is_spc)
+        /* what needs to be autocompleted is a full
+           new word, and not extend the last word
+        */
+        count++;
 
-        return count;
+    return count;
 }
 
-
 char **
-cli_rl_tokenize (const char *text)
+cli_rl_tokenize(const char *text)
 {
-        int     count = 0;
-        char  **tokens = NULL;
-        char  **tokenp = NULL;
-        char   *token = NULL;
-        char   *copy = NULL;
-        char   *saveptr = NULL;
-        int     i = 0;
-
-        count = cli_rl_token_count (text);
-
-        tokens = calloc (count + 1, sizeof (*tokens));
-        if (!tokens)
-                return NULL;
-
-        copy = strdup (text);
-        if (!copy)
-                goto out;
-
-        tokenp = tokens;
-
-        for (token = strtok_r (copy, " \t\r\n", &saveptr); token;
-             token = strtok_r (NULL, " \t\r\n", &saveptr)) {
-                *tokenp = strdup (token);
-
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-
-        }
+    int count = 0;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char *copy = NULL;
+    char *saveptr = NULL;
+    int i = 0;
+
+    count = cli_rl_token_count(text);
+
+    tokens = calloc(count + 1, sizeof(*tokens));
+    if (!tokens)
+        return NULL;
 
-        if (i < count) {
-                /* symbolize that what needs to be autocompleted is
-                   the full set of possible nextwords, and not extend
-                   the last word
-                */
-                *tokenp = strdup ("");
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-        }
+    copy = strdup(text);
+    if (!copy)
+        goto out;
+
+    tokenp = tokens;
+
+    for (token = strtok_r(copy, " \t\r\n", &saveptr); token;
+         token = strtok_r(NULL, " \t\r\n", &saveptr)) {
+        *tokenp = strdup(token);
+
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
+
+    if (i < count) {
+        /* symbolize that what needs to be autocompleted is
+           the full set of possible nextwords, and not extend
+           the last word
+        */
+        *tokenp = strdup("");
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
 
 out:
-        free (copy);
+    free(copy);
 
-        if (i < count) {
-                cli_cmd_tokens_destroy (tokens);
-                tokens = NULL;
-        }
+    if (i < count) {
+        cli_cmd_tokens_destroy(tokens);
+        tokens = NULL;
+    }
 
-        return tokens;
+    return tokens;
 }
 
-
 char **
-cli_rl_get_matches (struct cli_state *state, struct cli_cmd_word *word,
-                    const char *text)
+cli_rl_get_matches(struct cli_state *state, struct cli_cmd_word *word,
+                   const char *text)
 {
-        char                 **matches = NULL;
-        char                 **matchesp = NULL;
-        struct cli_cmd_word  **next = NULL;
-        int                    count = 0;
-        int                    len = 0;
+    char **matches = NULL;
+    char **matchesp = NULL;
+    struct cli_cmd_word **next = NULL;
+    int count = 0;
+    int len = 0;
 
-        len = strlen (text);
+    len = strlen(text);
 
-        if (!word->nextwords)
-                return NULL;
+    if (!word->nextwords)
+        return NULL;
 
-        for (next = word->nextwords; *next; next++)
-                count++;
+    for (next = word->nextwords; *next; next++)
+        count++;
 
-        matches = calloc (count + 1, sizeof (*matches));
-        matchesp = matches;
+    matches = calloc(count + 1, sizeof(*matches));
+    matchesp = matches;
 
-        for (next = word->nextwords; *next; next++) {
-                if ((*next)->match) {
-                        continue;
-                }
+    for (next = word->nextwords; *next; next++) {
+        if ((*next)->match) {
+            continue;
+        }
 
-                if (strncmp ((*next)->word, text, len) == 0) {
-                        *matchesp = strdup ((*next)->word);
-                        matchesp++;
-                }
+        if (strncmp((*next)->word, text, len) == 0) {
+            *matchesp = strdup((*next)->word);
+            matchesp++;
         }
+    }
 
-        return matches;
+    return matches;
 }
 
-
 int
-cli_rl_autocomplete_prepare (struct cli_state *state, const char *text)
+cli_rl_autocomplete_prepare(struct cli_state *state, const char *text)
 {
-        struct cli_cmd_word   *word = NULL;
-        struct cli_cmd_word   *next = NULL;
-        char                 **tokens = NULL;
-        char                 **tokenp = NULL;
-        char                  *token = NULL;
-        char                 **matches = NULL;
-
-        tokens = cli_rl_tokenize (text);
-        if (!tokens)
-                return 0;
-
-        word = &state->tree.root;
-
-        for (tokenp = tokens; (token = *tokenp); tokenp++) {
-                if (!*(tokenp+1)) {
-                        /* last word */
-                        break;
-                }
-
-                next = cli_cmd_nextword (word, token);
-                word = next;
-                if (!word)
-                        break;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char **matches = NULL;
+
+    tokens = cli_rl_tokenize(text);
+    if (!tokens)
+        return 0;
+
+    word = &state->tree.root;
+
+    for (tokenp = tokens; (token = *tokenp); tokenp++) {
+        if (!*(tokenp + 1)) {
+            /* last word */
+            break;
         }
 
+        next = cli_cmd_nextword(word, token);
+        word = next;
         if (!word)
-                goto out;
+            break;
+    }
+
+    if (!word || !token)
+        goto out;
 
-        matches = cli_rl_get_matches (state, word, token);
+    matches = cli_rl_get_matches(state, word, token);
 
-        state->matches = matches;
-        state->matchesp = matches;
+    state->matches = matches;
+    state->matchesp = matches;
 
 out:
-        cli_cmd_tokens_destroy (tokens);
-        return 0;
+    cli_cmd_tokens_destroy(tokens);
+    return 0;
 }
 
-
 int
-cli_rl_autocomplete_cleanup (struct cli_state *state)
+cli_rl_autocomplete_cleanup(struct cli_state *state)
 {
-        if (state->matches)
-                cli_cmd_tokens_destroy (state->matches);
+    if (state->matches)
+        cli_cmd_tokens_destroy(state->matches);
 
-        state->matches = NULL;
-        state->matchesp = NULL;
+    state->matches = NULL;
+    state->matchesp = NULL;
 
-        return 0;
+    return 0;
 }
 
-
 char **
-cli_rl_autocomplete (const char *text, int start, int end)
+cli_rl_autocomplete(const char *text, int start, int end)
 {
-        struct cli_state  *state = NULL;
-        char             **matches = NULL;
-        char               save = 0;
+    struct cli_state *state = NULL;
+    char **matches = NULL;
+    char save = 0;
 
-        state = global_state;
+    state = global_state;
 
-        /* hack to make the autocompletion code neater */
-        /* fake it as though the cursor is at the end of line */
+    /* hack to make the autocompletion code neater */
+    /* fake it as though the cursor is at the end of line */
 
-        save = rl_line_buffer[rl_point];
-        rl_line_buffer[rl_point] = 0;
+    save = rl_line_buffer[rl_point];
+    rl_line_buffer[rl_point] = 0;
 
-        cli_rl_autocomplete_prepare (state, rl_line_buffer);
+    cli_rl_autocomplete_prepare(state, rl_line_buffer);
 
-        matches = rl_completion_matches (text, cli_rl_autocomplete_entry);
+    matches = rl_completion_matches(text, cli_rl_autocomplete_entry);
 
-        cli_rl_autocomplete_cleanup (state);
+    cli_rl_autocomplete_cleanup(state);
 
-        rl_line_buffer[rl_point] = save;
+    rl_line_buffer[rl_point] = save;
 
-        return matches;
+    return matches;
 }
 
-
 static char *
-complete_none (const char *txt, int times)
+complete_none(const char *txt, int times)
 {
-        return NULL;
+    return NULL;
 }
 
-
 void *
-cli_rl_input (void *_data)
+cli_rl_input(void *_data)
 {
-        struct cli_state *state = NULL;
-        char             *line = NULL;
+    struct cli_state *state = NULL;
+    char *line = NULL;
 
-        state = _data;
+    state = _data;
 
-        for (;;) {
-                line = readline (state->prompt);
-                if (!line)
-                        exit(0);  //break;
+    fprintf(stderr,
+            "Welcome to gluster prompt, type 'help' to see the available "
+            "commands.\n");
+    for (;;) {
+        line = readline(state->prompt);
+        if (!line)
+            exit(0);  // break;
 
-                if (*line)
-                        cli_rl_process_line (line);
+        if (*line)
+            cli_rl_process_line(line);
 
-                free (line);
-        }
+        free(line);
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 int
-cli_rl_enable (struct cli_state *state)
+cli_rl_enable(struct cli_state *state)
 {
-        int ret = 0;
-
-        rl_pre_input_hook = NULL;
-        rl_attempted_completion_function = cli_rl_autocomplete;
-        rl_completion_entry_function = complete_none;
-
-        if (!state->rl_async) {
-                ret = pthread_create (&state->input, NULL,
-                                      cli_rl_input, state);
-                if (ret == 0)
-                        state->rl_enabled = 1;
-                goto out;
-        }
+    int ret = 0;
 
-        ret = event_register (state->ctx->event_pool, 0, cli_rl_stdin, state,
-                              1, 0);
-        if (ret == -1)
-                goto out;
+    rl_pre_input_hook = NULL;
+    rl_attempted_completion_function = cli_rl_autocomplete;
+    rl_completion_entry_function = complete_none;
 
-        state->rl_enabled = 1;
-        rl_callback_handler_install (state->prompt, cli_rl_process_line);
+    if (!state->rl_async) {
+        ret = pthread_create(&state->input, NULL, cli_rl_input, state);
+        if (ret == 0)
+            state->rl_enabled = 1;
+        goto out;
+    }
+
+    ret = gf_event_register(state->ctx->event_pool, 0, cli_rl_stdin, state, 1,
+                            0, 0);
+    if (ret == -1)
+        goto out;
+
+    state->rl_enabled = 1;
+    rl_callback_handler_install(state->prompt, cli_rl_process_line);
 
 out:
-        return state->rl_enabled;
+    return state->rl_enabled;
 }
 
 #else /* HAVE_READLINE */
 
 int
-cli_rl_enable (struct cli_state *state)
+cli_rl_enable(struct cli_state *state)
 {
-        return 0;
+    return 0;
 }
 
 #endif /* HAVE_READLINE */
diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c
index 58ecd8ba1f8..9b6b0c7fa50 100644
--- a/cli/src/cli-rpc-ops.c
+++ b/cli/src/cli-rpc-ops.c
@@ -14,58 +14,49 @@
  */
 #define VOL_TOP_PERF_FILENAME_DEF_WIDTH 47
 #define VOL_TOP_PERF_FILENAME_ALT_WIDTH 44
-#define VOL_TOP_PERF_SPEED_WIDTH        4
-#define VOL_TOP_PERF_TIME_WIDTH         26
+#define VOL_TOP_PERF_SPEED_WIDTH 4
+#define VOL_TOP_PERF_TIME_WIDTH 26
 
 #define INDENT_MAIN_HEAD "%-25s %s "
 
+#define RETURNING "Returning %d"
+#define XML_ERROR "Error outputting to xml"
+#define XDR_DECODE_FAIL "Failed to decode xdr response"
+#define DICT_SERIALIZE_FAIL "Failed to serialize to data to dictionary"
+#define DICT_UNSERIALIZE_FAIL "Failed to unserialize the dictionary"
+
 /* Do not show estimates if greater than this number */
-#define REBAL_ESTIMATE_SEC_UPPER_LIMIT    (60*24*3600)
-#define REBAL_ESTIMATE_START_TIME         600
+#define REBAL_ESTIMATE_SEC_UPPER_LIMIT (60 * 24 * 3600)
+#define REBAL_ESTIMATE_START_TIME 600
 
 #include "cli.h"
-#include "compat-errno.h"
+#include <glusterfs/compat-errno.h>
 #include "cli-cmd.h"
 #include <sys/uio.h>
 #include <stdlib.h>
 #include <sys/mount.h>
-#include "cli1-xdr.h"
-#include "xdr-generic.h"
-#include "protocol-common.h"
+#include <glusterfs/compat.h>
 #include "cli-mem-types.h"
-#include "compat.h"
-#include "upcall-utils.h"
-
-#include "syscall.h"
+#include <glusterfs/syscall.h>
 #include "glusterfs3.h"
 #include "portmap-xdr.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 
-#include "cli-quotad-client.h"
-#include "run.h"
-#include "quota-common-utils.h"
-#include "events.h"
+#include <glusterfs/run.h>
+#include <glusterfs/events.h>
 
-enum gf_task_types {
-        GF_TASK_TYPE_REBALANCE,
-        GF_TASK_TYPE_REMOVE_BRICK
-};
+enum gf_task_types { GF_TASK_TYPE_REBALANCE, GF_TASK_TYPE_REMOVE_BRICK };
 
-extern struct rpc_clnt *global_quotad_rpc;
-extern rpc_clnt_prog_t cli_quotad_clnt;
-extern rpc_clnt_prog_t *cli_rpc_prog;
-extern int              cli_op_ret;
-extern int              connected;
-
-int32_t
-gf_cli_remove_brick (call_frame_t *frame, xlator_t *this,
-                     void *data);
+rpc_clnt_prog_t cli_quotad_clnt;
 
+static int32_t
+gf_cli_remove_brick(call_frame_t *frame, xlator_t *this, void *data);
 
-char *cli_vol_status_str[] = {"Created",
-                              "Started",
-                              "Stopped",
-                             };
+char *cli_vol_status_str[] = {
+    "Created",
+    "Started",
+    "Stopped",
+};
 
 char *cli_vol_task_status_str[] = {"not started",
                                    "in progress",
@@ -76,9630 +67,8582 @@ char *cli_vol_task_status_str[] = {"not started",
                                    "fix-layout stopped",
                                    "fix-layout completed",
                                    "fix-layout failed",
-                                   "unknown"
-};
+                                   "unknown"};
 
-int32_t
-gf_cli_snapshot (call_frame_t *frame, xlator_t *this, void *data);
+static int32_t
+gf_cli_snapshot(call_frame_t *frame, xlator_t *this, void *data);
 
-int32_t
-gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
-                      void *data);
+static int32_t
+gf_cli_get_volume(call_frame_t *frame, xlator_t *this, void *data);
 
-int
-cli_to_glusterd (gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
-                 xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
-                 rpc_clnt_prog_t *prog, struct iobref *iobref);
-
-rpc_clnt_prog_t cli_handshake_prog = {
-        .progname  = "cli handshake",
-        .prognum   = GLUSTER_HNDSK_PROGRAM,
-        .progver   = GLUSTER_HNDSK_VERSION,
+static int
+cli_to_glusterd(gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
+                xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
+                rpc_clnt_prog_t *prog, struct iobref *iobref);
+
+static int
+add_cli_cmd_timeout_to_dict(dict_t *dict);
+
+static rpc_clnt_prog_t cli_handshake_prog = {
+    .progname = "cli handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
 };
 
-rpc_clnt_prog_t cli_pmap_prog = {
-        .progname   = "cli portmap",
-        .prognum    = GLUSTER_PMAP_PROGRAM,
-        .progver    = GLUSTER_PMAP_VERSION,
+static rpc_clnt_prog_t cli_pmap_prog = {
+    .progname = "cli portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
 };
 
-int
-gf_cli_probe_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
+static void
+gf_free_xdr_cli_rsp(gf_cli_rsp rsp)
 {
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        char                  msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (rsp.dict.dict_val) {
+        free(rsp.dict.dict_val);
+    }
+    if (rsp.op_errstr) {
+        free(rsp.op_errstr);
+    }
+}
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
-                goto out;
-        }
+static void
+gf_free_xdr_getspec_rsp(gf_getspec_rsp rsp)
+{
+    if (rsp.spec) {
+        free(rsp.spec);
+    }
+    if (rsp.xdata.xdata_val) {
+        free(rsp.xdata.xdata_val);
+    }
+}
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
+static void
+gf_free_xdr_fsm_log_rsp(gf1_cli_fsm_log_rsp rsp)
+{
+    if (rsp.op_errstr) {
+        free(rsp.op_errstr);
+    }
+    if (rsp.fsm_log.fsm_log_val) {
+        free(rsp.fsm_log.fsm_log_val);
+    }
+}
 
-        if (rsp.op_errstr && (strlen (rsp.op_errstr) > 0)) {
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                if (rsp.op_ret)
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
+static int
+gf_cli_probe_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = "success";
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to probe");
+
+    if (rsp.op_errstr && rsp.op_errstr[0] != '\0') {
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        if (rsp.op_ret) {
+            gf_log("cli", GF_LOG_ERROR, "%s", msg);
         }
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str (NULL,
-                                          (rsp.op_ret)? NULL : msg,
-                                          rsp.op_ret, rsp.op_errno,
-                                          (rsp.op_ret)? msg : NULL);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str(NULL, (rsp.op_ret) ? NULL : msg, rsp.op_ret,
+                                 rsp.op_errno, (rsp.op_ret) ? msg : NULL);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("peer probe: success. %s", msg);
-        else
-                cli_err ("peer probe: failed: %s", msg);
+    if (!rsp.op_ret)
+        cli_out("peer probe: %s", msg);
+    else
+        cli_err("peer probe: failed: %s", msg);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_deprobe_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
-{
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        char              msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to deprobe");
-
-        if (rsp.op_ret) {
-                if (strlen (rsp.op_errstr) > 0) {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                        gf_log ("cli", GF_LOG_ERROR, "%s", rsp.op_errstr);
-                }
-        } else {
-                snprintf (msg, sizeof (msg), "success");
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str (NULL,
-                                          (rsp.op_ret)? NULL : msg,
-                                          rsp.op_ret, rsp.op_errno,
-                                          (rsp.op_ret)? msg : NULL);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+static int
+gf_cli_deprobe_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = "success";
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to deprobe");
+
+    if (rsp.op_ret) {
+        if (rsp.op_errstr[0] != '\0') {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            gf_log("cli", GF_LOG_ERROR, "%s", rsp.op_errstr);
+        }
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str(NULL, (rsp.op_ret) ? NULL : msg, rsp.op_ret,
+                                 rsp.op_errno, (rsp.op_ret) ? msg : NULL);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("peer detach: %s", msg);
-        else
-                cli_err ("peer detach: failed: %s", msg);
+    if (!rsp.op_ret)
+        cli_out("peer detach: %s", msg);
+    else
+        cli_err("peer detach: failed: %s", msg);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_output_peer_hostnames (dict_t *dict, int count, char *prefix)
-{
-        int ret = -1;
-        char key[256] = {0,};
-        int i = 0;
-        char *hostname = NULL;
-
-        cli_out ("Other names:");
-        /* Starting from friend.hostname1, as friend.hostname0 will be the same
-         * as friend.hostname
-         */
-        for (i = 1; i < count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.hostname%d", prefix, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        break;
-                cli_out ("%s", hostname);
-                hostname = NULL;
-        }
+static int
+gf_cli_output_peer_hostnames(dict_t *dict, int count, const char *prefix)
+{
+    int ret = -1;
+    char key[512] = {
+        0,
+    };
+    int i = 0;
+    char *hostname = NULL;
+
+    cli_out("Other names:");
+    /* Starting from friend.hostname1, as friend.hostname0 will be the same
+     * as friend.hostname
+     */
+    for (i = 1; i < count; i++) {
+        ret = snprintf(key, sizeof(key), "%s.hostname%d", prefix, i);
+        ret = dict_get_strn(dict, key, ret, &hostname);
+        if (ret)
+            break;
+        cli_out("%s", hostname);
+        hostname = NULL;
+    }
 
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_output_peer_status (dict_t *dict, int count)
-{
-        int                        ret   = -1;
-        char                       *uuid_buf = NULL;
-        char                       *hostname_buf = NULL;
-        int32_t                    i = 1;
-        char                       key[256] = {0,};
-        char                       *state = NULL;
-        int32_t                    connected = 0;
-        char                       *connected_str = NULL;
-        int                        hostname_count = 0;
-
-        cli_out ("Number of Peers: %d", count);
-        i = 1;
-        while ( i <= count) {
-                snprintf (key, 256, "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid_buf);
-                if (ret)
-                        goto out;
-
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+static int
+gf_cli_output_peer_status(dict_t *dict, int count)
+{
+    int ret = -1;
+    char *uuid_buf = NULL;
+    char *hostname_buf = NULL;
+    int32_t i = 1;
+    char key[256] = {
+        0,
+    };
+    int keylen;
+    char *state = NULL;
+    int32_t connected = 0;
+    const char *connected_str = NULL;
+    int hostname_count = 0;
+
+    cli_out("Number of Peers: %d", count);
+    i = 1;
+    while (i <= count) {
+        keylen = snprintf(key, sizeof(key), "friend%d.uuid", i);
+        ret = dict_get_strn(dict, key, keylen, &uuid_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
-                if (connected)
-                        connected_str = "Connected";
-                else
-                        connected_str = "Disconnected";
+        keylen = snprintf(key, sizeof(key), "friend%d.hostname", i);
+        ret = dict_get_strn(dict, key, keylen, &hostname_buf);
+        if (ret)
+            goto out;
 
+        keylen = snprintf(key, sizeof(key), "friend%d.connected", i);
+        ret = dict_get_int32n(dict, key, keylen, &connected);
+        if (ret)
+            goto out;
+        if (connected)
+            connected_str = "Connected";
+        else
+            connected_str = "Disconnected";
 
-                snprintf (key, 256, "friend%d.state", i);
-                ret = dict_get_str (dict, key, &state);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "friend%d.state", i);
+        ret = dict_get_strn(dict, key, keylen, &state);
+        if (ret)
+            goto out;
 
-                cli_out ("\nHostname: %s\nUuid: %s\nState: %s (%s)",
-                         hostname_buf, uuid_buf, state, connected_str);
+        cli_out("\nHostname: %s\nUuid: %s\nState: %s (%s)", hostname_buf,
+                uuid_buf, state, connected_str);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.hostname_count", i);
-                ret = dict_get_int32 (dict, key, &hostname_count);
-                /* Print other addresses only if there are more than 1.
-                 */
-                if ((ret == 0) && (hostname_count > 1)) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "friend%d", i);
-                        ret = gf_cli_output_peer_hostnames (dict,
-                                                            hostname_count,
-                                                            key);
-                }
-                i++;
+        keylen = snprintf(key, sizeof(key), "friend%d.hostname_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &hostname_count);
+        /* Print other addresses only if there are more than 1.
+         */
+        if ((ret == 0) && (hostname_count > 1)) {
+            snprintf(key, sizeof(key), "friend%d", i);
+            ret = gf_cli_output_peer_hostnames(dict, hostname_count, key);
+            if (ret) {
+                gf_log("cli", GF_LOG_WARNING,
+                       "error outputting peer other names");
+                goto out;
+            }
         }
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_output_pool_list (dict_t *dict, int count)
-{
-        int                         ret           = -1;
-        char                       *uuid_buf      = NULL;
-        char                       *hostname_buf  = NULL;
-        int32_t                     hostname_len  = 8; /*min len 8 chars*/
-        int32_t                     i             = 1;
-        char                        key[256]      = {0,};
-        int32_t                     connected     = 0;
-        char                       *connected_str = NULL;
-
-        if (count <= 0)
-                goto out;
-
-        while (i <= count) {
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+static int
+gf_cli_output_pool_list(dict_t *dict, int count)
+{
+    int ret = -1;
+    char *uuid_buf = NULL;
+    char *hostname_buf = NULL;
+    int32_t hostname_len = 8; /*min len 8 chars*/
+    int32_t i = 1;
+    char key[64] = {
+        0,
+    };
+    int keylen;
+    int32_t connected = 0;
+    const char *connected_str = NULL;
+
+    if (count <= 0)
+        goto out;
+
+    while (i <= count) {
+        keylen = snprintf(key, sizeof(key), "friend%d.hostname", i);
+        ret = dict_get_strn(dict, key, keylen, &hostname_buf);
+        if (ret)
+            goto out;
 
-                ret = strlen(hostname_buf);
-                if (ret > hostname_len)
-                        hostname_len = ret;
+        ret = strlen(hostname_buf);
+        if (ret > hostname_len)
+            hostname_len = ret;
 
-                i++;
-        }
+        i++;
+    }
 
-        cli_out ("UUID\t\t\t\t\t%-*s\tState", hostname_len, "Hostname");
+    cli_out("UUID\t\t\t\t\t%-*s\tState", hostname_len, "Hostname");
 
-        i = 1;
-        while ( i <= count) {
-                snprintf (key, 256, "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid_buf);
-                if (ret)
-                        goto out;
+    i = 1;
+    while (i <= count) {
+        keylen = snprintf(key, sizeof(key), "friend%d.uuid", i);
+        ret = dict_get_strn(dict, key, keylen, &uuid_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "friend%d.hostname", i);
+        ret = dict_get_strn(dict, key, keylen, &hostname_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
-                if (connected)
-                        connected_str = "Connected";
-                else
-                        connected_str = "Disconnected";
+        keylen = snprintf(key, sizeof(key), "friend%d.connected", i);
+        ret = dict_get_int32n(dict, key, keylen, &connected);
+        if (ret)
+            goto out;
+        if (connected)
+            connected_str = "Connected";
+        else
+            connected_str = "Disconnected";
 
-                cli_out ("%s\t%-*s\t%s ", uuid_buf, hostname_len, hostname_buf,
-                         connected_str);
-                i++;
-        }
+        cli_out("%s\t%-*s\t%s ", uuid_buf, hostname_len, hostname_buf,
+                connected_str);
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* function pointer for gf_cli_output_{pool_list,peer_status} */
-typedef int (*cli_friend_output_fn) (dict_t*, int);
+typedef int (*cli_friend_output_fn)(dict_t *, int);
 
-int
-gf_cli_list_friends_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_list_friends_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf1_cli_peer_list_rsp      rsp   = {0,};
-        int                        ret   = -1;
-        dict_t                    *dict = NULL;
-        char                       msg[1024] = {0,};
-        char                      *cmd = NULL;
-        cli_friend_output_fn       friend_output_fn;
-        call_frame_t              *frame = NULL;
-        unsigned long              flags = 0;
+    gf1_cli_peer_list_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    const char *cmd = NULL;
+    cli_friend_output_fn friend_output_fn;
+    call_frame_t *frame = NULL;
+    unsigned long flags = 0;
 
-        GF_ASSERT (myframe);
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    GF_ASSERT(myframe);
 
-        flags = (long)frame->local;
+    frame = myframe;
 
-        if (flags == GF_CLI_LIST_POOL_NODES) {
-                cmd = "pool list";
-                friend_output_fn = &gf_cli_output_pool_list;
-        } else {
-                cmd = "peer status";
-                friend_output_fn = &gf_cli_output_peer_status;
-        }
-
-        /* 'free' the flags set by gf_cli_list_friends */
-        frame->local = NULL;
+    flags = (long)frame->local;
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (flags == GF_CLI_LIST_POOL_NODES) {
+        cmd = "pool list";
+        friend_output_fn = &gf_cli_output_pool_list;
+    } else {
+        cmd = "peer status";
+        friend_output_fn = &gf_cli_output_peer_status;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_peer_list_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
-                goto out;
-        }
+    /* 'free' the flags set by gf_cli_list_friends */
+    frame->local = NULL;
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to list: %d",
-                rsp.op_ret);
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_peer_list_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to list: %d", rsp.op_ret);
 
-        if (!rsp.op_ret) {
-
-                if (!rsp.friends.friends_len) {
-                        snprintf (msg, sizeof (msg),
-                                  "%s: No peers present", cmd);
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                ret = cli_xml_output_peer_status (dict,
-                                                                  rsp.op_ret,
-                                                                  rsp.op_errno,
-                                                                  msg);
-                                if (ret)
-                                        gf_log ("cli", GF_LOG_ERROR,
-                                                "Error outputting to xml");
-                                goto out;
-                        }
-                        cli_err ("%s", msg);
-                        ret = 0;
-                        goto out;
-                }
+    if (!rsp.op_ret) {
+        if (!rsp.friends.friends_len) {
+            snprintf(msg, sizeof(msg), "%s: No peers present", cmd);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                                 msg);
+                if (ret)
+                    gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+                goto out;
+            }
+            cli_err("%s", msg);
+            ret = 0;
+            goto out;
+        }
 
-                dict = dict_new ();
+        dict = dict_new();
 
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
 
-                ret = dict_unserialize (rsp.friends.friends_val,
-                                        rsp.friends.friends_len,
-                                        &dict);
+        ret = dict_unserialize(rsp.friends.friends_val, rsp.friends.friends_len,
+                               &dict);
 
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR,
-                                        "Unable to allocate memory");
-                        goto out;
-                }
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
+        }
 
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_peer_status (dict, rsp.op_ret,
-                                                          rsp.op_errno, msg);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        goto out;
-                }
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                             msg);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            goto out;
+        }
 
-                ret = dict_get_int32 (dict, "count", &count);
-                if (ret) {
-                        goto out;
-                }
+        ret = dict_get_int32_sizen(dict, "count", &count);
+        if (ret) {
+            goto out;
+        }
 
-                ret = friend_output_fn (dict, count);
-                if (ret) {
-                        goto out;
-                }
+        ret = friend_output_fn(dict, count);
+        if (ret) {
+            goto out;
+        }
+    } else {
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                             NULL);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
         } else {
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_peer_status (dict, rsp.op_ret,
-                                                          rsp.op_errno, NULL);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                } else {
-                        ret = -1;
-                }
-                goto out;
+            ret = -1;
         }
+        goto out;
+    }
 
-
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret)
-                cli_err ("%s: failed", cmd);
+    if (ret)
+        cli_err("%s: failed", cmd);
 
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    if (rsp.friends.friends_val) {
+        free(rsp.friends.friends_val);
+    }
+    return ret;
 }
 
-int
-gf_cli_get_state_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
-{
-        gf_cli_rsp           rsp            = {0,};
-        int                  ret            = -1;
-        dict_t               *dict          = NULL;
-        char                 *daemon_name   = NULL;
-        char                 *ofilepath     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+static int
+gf_cli_get_state_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *daemon_name = NULL;
+    char *ofilepath = NULL;
+
+    GF_VALIDATE_OR_GOTO("cli", myframe, out);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("Failed to get daemon state: %s", rsp.op_errstr);
+        else
+            cli_err(
+                "Failed to get daemon state. Check glusterd"
+                " log file for more details");
+    } else {
+        ret = dict_get_str_sizen(dict, "daemon", &daemon_name);
         if (ret)
-                goto out;
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("Failed to get daemon state: %s", rsp.op_errstr);
-                else
-                        cli_err ("Failed to get daemon state. Check glusterd"
-                                 " log file for more details");
-        } else {
-                ret = dict_get_str (dict, "daemon", &daemon_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get daemon name");
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get daemon name");
 
-                ret = dict_get_str (dict, "ofilepath", &ofilepath);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get filepath");
+        ret = dict_get_str_sizen(dict, "ofilepath", &ofilepath);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get filepath");
 
-                if (daemon_name && ofilepath)
-                        cli_out ("%s state dumped to %s",
-                                 daemon_name, ofilepath);
-        }
+        if (daemon_name && ofilepath)
+            cli_out("%s state dumped to %s", daemon_name, ofilepath);
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    if (dict)
+        dict_unref(dict);
 
-        if (dict)
-                dict_unref (dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-        cli_cmd_broadcast_response (ret);
-
-        return ret;
+    return ret;
 }
 
-void
-cli_out_options ( char *substr, char *optstr, char *valstr)
+static void
+cli_out_options(char *substr, char *optstr, char *valstr)
 {
-        char                    *ptr1 = NULL;
-        char                    *ptr2 = NULL;
+    char *ptr1 = NULL;
+    char *ptr2 = NULL;
 
-        ptr1 = substr;
-        ptr2 = optstr;
+    ptr1 = substr;
+    ptr2 = optstr;
 
-        while (ptr1)
-        {
- /* Avoiding segmentation fault. */
-                if (!ptr2)
-                        return;
-                if (*ptr1 != *ptr2)
-                        break;
-                ptr1++;
-                ptr2++;
-        }
+    while (ptr1) {
+        /* Avoiding segmentation fault. */
+        if (!ptr2)
+            return;
+        if (*ptr1 != *ptr2)
+            break;
+        ptr1++;
+        ptr2++;
+    }
 
-        if (*ptr2 == '\0')
-                return;
-        cli_out ("%s: %s",ptr2 , valstr);
+    if (*ptr2 == '\0')
+        return;
+    cli_out("%s: %s", ptr2, valstr);
 }
 
 static int
-_gf_cli_output_volinfo_opts (dict_t *d, char *k,
-                             data_t *v, void *tmp)
-{
-        int     ret   = 0;
-        char   *key   = NULL;
-        char   *ptr   = NULL;
-        data_t *value = NULL;
-
-        key = tmp;
-
-        ptr = strstr (k, "option.");
-        if (ptr) {
-                value = v;
-                if (!value) {
-                        ret = -1;
-                        goto out;
-                }
-                cli_out_options (key, k, v->data);
+_gf_cli_output_volinfo_opts(dict_t *d, char *k, data_t *v, void *tmp)
+{
+    int ret = 0;
+    char *key = NULL;
+    char *ptr = NULL;
+    data_t *value = NULL;
+
+    key = tmp;
+
+    ptr = strstr(k, "option.");
+    if (ptr) {
+        value = v;
+        if (!value) {
+            ret = -1;
+            goto out;
         }
+        cli_out_options(key, k, v->data);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-print_brick_details (dict_t *dict, int volcount, int start_index,
-                     int end_index, int replica_count)
-{
-        char           key[1024]   = {0,};
-        int            index       = start_index;
-        int            isArbiter   = 0;
-        int            ret         = -1;
-        char          *brick       = NULL;
-#ifdef HAVE_BD_XLATOR
-        char          *caps        = NULL;
-#endif
-
-        while (index <= end_index) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, 1024, "volume%d.brick%d", volcount, index);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof(key));
-                snprintf (key, sizeof (key), "volume%d.brick%d.isArbiter",
+print_brick_details(dict_t *dict, int volcount, int start_index, int end_index,
+                    int replica_count)
+{
+    char key[64] = {
+        0,
+    };
+    int keylen;
+    int index = start_index;
+    int isArbiter = 0;
+    int ret = -1;
+    char *brick = NULL;
+
+    while (index <= end_index) {
+        keylen = snprintf(key, sizeof(key), "volume%d.brick%d", volcount,
+                          index);
+        ret = dict_get_strn(dict, key, keylen, &brick);
+        if (ret)
+            goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.brick%d.isArbiter",
                           volcount, index);
-                if (dict_get (dict, key))
-                        isArbiter = 1;
-                else
-                        isArbiter = 0;
+        if (dict_getn(dict, key, keylen))
+            isArbiter = 1;
+        else
+            isArbiter = 0;
 
-                if (isArbiter)
-                        cli_out ("Brick%d: %s (arbiter)", index, brick);
-                else
-                        cli_out ("Brick%d: %s", index, brick);
-#ifdef HAVE_BD_XLATOR
-                snprintf (key, 1024, "volume%d.vg%d", volcount, index);
-                ret = dict_get_str (dict, key, &caps);
-                if (!ret)
-                        cli_out ("Brick%d VG: %s", index, caps);
-#endif
-                index++;
-        }
-        ret = 0;
+        if (isArbiter)
+            cli_out("Brick%d: %s (arbiter)", index, brick);
+        else
+            cli_out("Brick%d: %s", index, brick);
+        index++;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
-void
-gf_cli_print_number_of_bricks (int type, int brick_count, int dist_count,
-                               int stripe_count, int replica_count,
-                               int disperse_count, int redundancy_count,
-                               int arbiter_count)
-{
-       if (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE) {
-               if (arbiter_count == 0) {
-                       cli_out ("Number of Bricks: %d x %d x %d = %d",
-                                (brick_count / dist_count),
-                                stripe_count,
-                                replica_count,
-                                brick_count);
-               } else {
-                       cli_out ("Number of Bricks: %d x %d x (%d + %d) = %d",
-                                (brick_count / dist_count),
-                                stripe_count, replica_count - arbiter_count,
-                                arbiter_count, brick_count);
-               }
-       } else if (type == GF_CLUSTER_TYPE_NONE ||
-                  type == GF_CLUSTER_TYPE_TIER) {
-               cli_out ("Number of Bricks: %d", brick_count);
-       } else if (type == GF_CLUSTER_TYPE_DISPERSE) {
-               cli_out ("Number of Bricks: %d x (%d + %d) = %d",
-                        (brick_count / dist_count),
-                        disperse_count - redundancy_count,
-                        redundancy_count, brick_count);
-       } else {
-               /* For both replicate and stripe, dist_count is
-                  good enough */
-               if (arbiter_count == 0) {
-                       cli_out ("Number of Bricks: %d x %d = %d",
-                                (brick_count / dist_count),
-                                dist_count, brick_count);
-               } else {
-                       cli_out ("Number of Bricks: %d x (%d + %d) = %d",
-                                (brick_count / dist_count),
-                                dist_count - arbiter_count, arbiter_count,
-                                brick_count);
-               }
-       }
 
+static void
+gf_cli_print_number_of_bricks(int type, int brick_count, int dist_count,
+                              int stripe_count, int replica_count,
+                              int disperse_count, int redundancy_count,
+                              int arbiter_count)
+{
+    if (type == GF_CLUSTER_TYPE_NONE) {
+        cli_out("Number of Bricks: %d", brick_count);
+    } else if (type == GF_CLUSTER_TYPE_DISPERSE) {
+        cli_out("Number of Bricks: %d x (%d + %d) = %d",
+                (brick_count / dist_count), disperse_count - redundancy_count,
+                redundancy_count, brick_count);
+    } else {
+        /* For both replicate and stripe, dist_count is
+           good enough */
+        if (arbiter_count == 0) {
+            cli_out("Number of Bricks: %d x %d = %d",
+                    (brick_count / dist_count), dist_count, brick_count);
+        } else {
+            cli_out("Number of Bricks: %d x (%d + %d) = %d",
+                    (brick_count / dist_count), dist_count - arbiter_count,
+                    arbiter_count, brick_count);
+        }
+    }
 }
 
-int
-gf_cli_print_tier_info (dict_t *dict, int i, int brick_count)
-{
-
-        int                  hot_brick_count        = -1;
-        int                  cold_type              = 0;
-        int                  cold_brick_count       = 0;
-        int                  cold_replica_count     = 0;
-        int                  cold_arbiter_count     = 0;
-        int                  cold_disperse_count    = 0;
-        int                  cold_redundancy_count  = 0;
-        int                  cold_dist_count        = 0;
-        int                  hot_type               = 0;
-        int                  hot_replica_count      = 0;
-        int                  hot_dist_count         = 0;
-        int                  ret                    = -1;
-        int                  vol_type               = -1;
-        char                 key[256]               = {0,};
-
-        GF_ASSERT (dict);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_brick_count", i);
-        ret = dict_get_int32 (dict, key, &cold_brick_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_type", i);
-        ret = dict_get_int32 (dict, key, &cold_type);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_dist_count", i);
-        ret = dict_get_int32 (dict, key, &cold_dist_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_replica_count", i);
-        ret = dict_get_int32 (dict, key, &cold_replica_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_arbiter_count", i);
-        ret = dict_get_int32 (dict, key, &cold_arbiter_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.cold_disperse_count", i);
-        ret = dict_get_int32 (dict, key, &cold_disperse_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256,
-                  "volume%d.cold_redundancy_count", i);
-        ret = dict_get_int32 (dict, key,
-                              &cold_redundancy_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.hot_brick_count", i);
-        ret = dict_get_int32 (dict, key, &hot_brick_count);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.hot_type", i);
-        ret = dict_get_int32 (dict, key, &hot_type);
-        if (ret)
-                goto out;
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "volume%d.hot_replica_count", i);
-        ret = dict_get_int32 (dict, key, &hot_replica_count);
-        if (ret)
-                goto out;
-
-        cli_out ("Hot Tier :");
-        vol_type = hot_type;
-        hot_dist_count = (hot_replica_count ?
-                          hot_replica_count : 1);
-
-        vol_type = get_vol_type (hot_type, hot_dist_count, hot_brick_count);
-        cli_out ("Hot Tier Type : %s",
-                 vol_type_str[vol_type]);
-
-        gf_cli_print_number_of_bricks (hot_type,
-                        hot_brick_count, hot_dist_count, 0,
-                        hot_replica_count, 0, 0, 0);
+static int
+gf_cli_get_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    int ret = -1;
+    int opt_count = 0;
+    int32_t i = 0;
+    int32_t j = 1;
+    int32_t status = 0;
+    int32_t type = 0;
+    int32_t brick_count = 0;
+    int32_t dist_count = 0;
+    int32_t stripe_count = 0;
+    int32_t replica_count = 0;
+    int32_t disperse_count = 0;
+    int32_t redundancy_count = 0;
+    int32_t arbiter_count = 0;
+    int32_t snap_count = 0;
+    int32_t thin_arbiter_count = 0;
+    int32_t vol_type = 0;
+    int32_t transport = 0;
+    char *volume_id_str = NULL;
+    char *volname = NULL;
+    char *ta_brick = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+    char key[64] = {0};
+    int keylen;
+    char err_str[2048] = {0};
+    gf_cli_rsp rsp = {0};
+    char *caps __attribute__((unused)) = NULL;
+    int k __attribute__((unused)) = 0;
+    call_frame_t *frame = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to get vol: %d", rsp.op_ret);
+
+    if (!rsp.dict.dict_len) {
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+        cli_err("No volumes present");
+        ret = 0;
+        goto out;
+    }
 
-        ret = print_brick_details (dict, i, 1, hot_brick_count,
-                                   hot_replica_count);
-        if (ret)
-                goto out;
+    dict = dict_new();
 
-        cli_out ("Cold Tier:");
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        vol_type = get_vol_type (cold_type, cold_dist_count, cold_brick_count);
-        cli_out ("Cold Tier Type : %s",
-                        vol_type_str[vol_type]);
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        gf_cli_print_number_of_bricks (cold_type,
-                cold_brick_count,
-                cold_dist_count, 0, cold_replica_count,
-                cold_disperse_count, cold_redundancy_count, cold_arbiter_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
 
-        ret = print_brick_details (dict, i, hot_brick_count+1,
-                                   brick_count, cold_replica_count);
-        if (ret)
-                goto out;
-out:
-        return ret;
-}
+    ret = dict_get_int32_sizen(dict, "count", &count);
+    if (ret)
+        goto out;
 
-int
-gf_cli_get_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
-{
-        int                        ret                  = -1;
-        int                        opt_count            = 0;
-        int32_t                    i                    = 0;
-        int32_t                    j                    = 1;
-        int32_t                    status               = 0;
-        int32_t                    type                 = 0;
-        int32_t                    brick_count          = 0;
-        int32_t                    dist_count           = 0;
-        int32_t                    stripe_count         = 0;
-        int32_t                    replica_count        = 0;
-        int32_t                    disperse_count       = 0;
-        int32_t                    redundancy_count     = 0;
-        int32_t                    arbiter_count        = 0;
-        int32_t                    snap_count           = 0;
-        int32_t                    vol_type             = 0;
-        int32_t                    transport            = 0;
-        char                      *volume_id_str        = NULL;
-        char                      *volname              = NULL;
-        dict_t                    *dict                 = NULL;
-        cli_local_t               *local                = NULL;
-        char                       key[1024]            = {0};
-        char                       err_str[2048]        = {0};
-        gf_cli_rsp                 rsp                  = {0};
-        char                      *caps __attribute__((unused)) = NULL;
-        int                        k __attribute__((unused)) = 0;
-        call_frame_t              *frame                = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
+    if (!count) {
+        switch (local->get_vol.flags) {
+            case GF_CLI_GET_NEXT_VOLUME:
+                GF_FREE(local->get_vol.volname);
+                local->get_vol.volname = NULL;
+                ret = 0;
                 goto out;
 
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+            case GF_CLI_GET_VOLUME:
+                snprintf(err_str, sizeof(err_str), "Volume %s does not exist",
+                         local->get_vol.volname);
+                ret = -1;
+                if (!(global_state->mode & GLUSTER_MODE_XML))
+                    goto out;
         }
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to get vol: %d",
-                rsp.op_ret);
+    if (rsp.op_ret) {
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+        ret = -1;
+        goto out;
+    }
 
-        if (!rsp.dict.dict_len) {
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-                cli_err ("No volumes present");
-                ret = 0;
+xml_output:
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        /* For GET_NEXT_VOLUME output is already begun in
+         * and will also end in gf_cli_get_next_volume()
+         */
+        if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
+            ret = cli_xml_output_vol_info_begin(local, rsp.op_ret, rsp.op_errno,
+                                                rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
                 goto out;
+            }
         }
 
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
+        if (dict) {
+            ret = cli_xml_output_vol_info(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
                 goto out;
+            }
         }
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unable to allocate memory");
-                goto out;
+        if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
+            ret = cli_xml_output_vol_info_end(local);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
         }
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "count", &count);
+    while (i < count) {
+        cli_out(" ");
+        keylen = snprintf(key, sizeof(key), "volume%d.name", i);
+        ret = dict_get_strn(dict, key, keylen, &volname);
         if (ret)
-                goto out;
+            goto out;
 
-        if (!count) {
-                switch (local->get_vol.flags) {
-
-                case GF_CLI_GET_NEXT_VOLUME:
-                        GF_FREE (local->get_vol.volname);
-                        local->get_vol.volname = NULL;
-                        ret = 0;
-                        goto out;
-
-                case GF_CLI_GET_VOLUME:
-                        memset (err_str, 0, sizeof (err_str));
-                        snprintf (err_str, sizeof (err_str),
-                                  "Volume %s does not exist",
-                                  local->get_vol.volname);
-                        ret = -1;
-                        if (!(global_state->mode & GLUSTER_MODE_XML))
-                                goto out;
-                }
-        }
-
-        if (rsp.op_ret) {
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-                ret = -1;
-                goto out;
-        }
+        keylen = snprintf(key, sizeof(key), "volume%d.type", i);
+        ret = dict_get_int32n(dict, key, keylen, &type);
+        if (ret)
+            goto out;
 
-xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                /* For GET_NEXT_VOLUME output is already begun in
-                 * and will also end in gf_cli_get_next_volume()
-                 */
-                if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
-                        ret = cli_xml_output_vol_info_begin
-                                (local, rsp.op_ret, rsp.op_errno,
-                                 rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto out;
-                        }
-                }
+        keylen = snprintf(key, sizeof(key), "volume%d.status", i);
+        ret = dict_get_int32n(dict, key, keylen, &status);
+        if (ret)
+            goto out;
 
-                if (dict) {
-                        ret = cli_xml_output_vol_info (local, dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto out;
-                        }
-                }
+        keylen = snprintf(key, sizeof(key), "volume%d.brick_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &brick_count);
+        if (ret)
+            goto out;
 
-                if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
-                        ret = cli_xml_output_vol_info_end (local);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                }
-                goto out;
-        }
+        keylen = snprintf(key, sizeof(key), "volume%d.dist_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &dist_count);
+        if (ret)
+            goto out;
 
-        while ( i < count) {
-                cli_out (" ");
-                snprintf (key, 256, "volume%d.name", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.stripe_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &stripe_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.type", i);
-                ret = dict_get_int32 (dict, key, &type);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.replica_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &replica_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.disperse_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &disperse_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.brick_count", i);
-                ret = dict_get_int32 (dict, key, &brick_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.redundancy_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &redundancy_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.dist_count", i);
-                ret = dict_get_int32 (dict, key, &dist_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.arbiter_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &arbiter_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.stripe_count", i);
-                ret = dict_get_int32 (dict, key, &stripe_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.transport", i);
+        ret = dict_get_int32n(dict, key, keylen, &transport);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.replica_count", i);
-                ret = dict_get_int32 (dict, key, &replica_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.volume_id", i);
+        ret = dict_get_strn(dict, key, keylen, &volume_id_str);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.disperse_count", i);
-                ret = dict_get_int32 (dict, key, &disperse_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.snap_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &snap_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.redundancy_count", i);
-                ret = dict_get_int32 (dict, key, &redundancy_count);
-                if (ret)
-                        goto out;
+        keylen = snprintf(key, sizeof(key), "volume%d.thin_arbiter_count", i);
+        ret = dict_get_int32n(dict, key, keylen, &thin_arbiter_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof(key), "volume%d.arbiter_count", i);
-                ret = dict_get_int32 (dict, key, &arbiter_count);
-                if (ret)
-                        goto out;
+        // Distributed (stripe/replicate/stripe-replica) setups
+        vol_type = get_vol_type(type, dist_count, brick_count);
 
-                snprintf (key, 256, "volume%d.transport", i);
-                ret = dict_get_int32 (dict, key, &transport);
-                if (ret)
-                        goto out;
+        cli_out("Volume Name: %s", volname);
+        cli_out("Type: %s", vol_type_str[vol_type]);
+        cli_out("Volume ID: %s", volume_id_str);
+        cli_out("Status: %s", cli_vol_status_str[status]);
+        cli_out("Snapshot Count: %d", snap_count);
 
-                snprintf (key, 256, "volume%d.volume_id", i);
-                ret = dict_get_str (dict, key, &volume_id_str);
-                if (ret)
-                        goto out;
+        gf_cli_print_number_of_bricks(
+            type, brick_count, dist_count, stripe_count, replica_count,
+            disperse_count, redundancy_count, arbiter_count);
 
-                snprintf (key, 256, "volume%d.snap_count", i);
-                ret = dict_get_int32 (dict, key, &snap_count);
-                if (ret)
-                        goto out;
-
-                // Distributed (stripe/replicate/stripe-replica) setups
-                vol_type = get_vol_type (type, dist_count, brick_count);
-
-                cli_out ("Volume Name: %s", volname);
-                cli_out ("Type: %s", vol_type_str[vol_type]);
-                cli_out ("Volume ID: %s", volume_id_str);
-                cli_out ("Status: %s", cli_vol_status_str[status]);
-                cli_out ("Snapshot Count: %d", snap_count);
-
-#ifdef HAVE_BD_XLATOR
-                k = 0;
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.xlator%d", i, k);
-                ret = dict_get_str (dict, key, &caps);
-                if (ret)
-                        goto next;
-                do {
-                        j = 0;
-                        cli_out ("Xlator %d: %s", k + 1, caps);
-                        do {
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.xlator%d.caps%d",
-                                          i, k, j++);
-                                ret = dict_get_str (dict, key, &caps);
-                                if (ret)
-                                        break;
-                                cli_out ("Capability %d: %s", j, caps);
-                        } while (1);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                  "volume%d.xlator%d", i, ++k);
-                        ret = dict_get_str (dict, key, &caps);
-                        if (ret)
-                                break;
-                } while (1);
-
-next:
-#endif
-                gf_cli_print_number_of_bricks (type, brick_count,
-                                dist_count, stripe_count, replica_count,
-                                disperse_count, redundancy_count,
-                                arbiter_count);
-
-                cli_out ("Transport-type: %s",
-                         ((transport == 0)?"tcp":
-                          (transport == 1)?"rdma":
-                          "tcp,rdma"));
-                j = 1;
-
-                GF_FREE (local->get_vol.volname);
-                local->get_vol.volname = gf_strdup (volname);
-
-                if (type == GF_CLUSTER_TYPE_TIER) {
-                        ret = gf_cli_print_tier_info (dict, i, brick_count);
-                        if (ret)
-                                goto out;
-
-                } else {
-                        cli_out ("Bricks:");
-                        ret = print_brick_details (dict, i, j, brick_count,
-                                                  replica_count);
-                        if (ret)
-                                goto out;
-                }
+        cli_out("Transport-type: %s",
+                ((transport == 0) ? "tcp"
+                                  : (transport == 1) ? "rdma" : "tcp,rdma"));
+        j = 1;
 
-                snprintf (key, 256, "volume%d.opt_count",i);
-                ret = dict_get_int32 (dict, key, &opt_count);
-                if (ret)
-                        goto out;
+        GF_FREE(local->get_vol.volname);
+        local->get_vol.volname = gf_strdup(volname);
 
-                if (!opt_count)
-                        goto out;
+        cli_out("Bricks:");
+        ret = print_brick_details(dict, i, j, brick_count, replica_count);
+        if (ret)
+            goto out;
 
-                cli_out ("Options Reconfigured:");
+        if (thin_arbiter_count) {
+            snprintf(key, sizeof(key), "volume%d.thin_arbiter_brick", i);
+            ret = dict_get_str(dict, key, &ta_brick);
+            if (ret)
+                goto out;
+            cli_out("Thin-arbiter-path: %s", ta_brick);
+        }
 
-                snprintf (key, 256, "volume%d.option.",i);
+        snprintf(key, sizeof(key), "volume%d.opt_count", i);
+        ret = dict_get_int32(dict, key, &opt_count);
+        if (ret)
+            goto out;
 
-                ret = dict_foreach (dict, _gf_cli_output_volinfo_opts, key);
-                if (ret)
-                        goto out;
+        if (!opt_count)
+            goto out;
 
-                i++;
-        }
+        cli_out("Options Reconfigured:");
 
+        snprintf(key, sizeof(key), "volume%d.option.", i);
 
-        ret = 0;
-out:
+        ret = dict_foreach(dict, _gf_cli_output_volinfo_opts, key);
         if (ret)
-                cli_err ("%s", err_str);
+            goto out;
 
-        cli_cmd_broadcast_response (ret);
+        i++;
+    }
 
-        if (dict)
-                dict_unref (dict);
+    ret = 0;
+out:
+    if (ret)
+        cli_err("%s", err_str);
+
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.op_errstr);
+    gf_free_xdr_cli_rsp(rsp);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning: %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int
-gf_cli_create_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_create_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp       = {0,};
-        int                     ret       = -1;
-        cli_local_t             *local    = NULL;
-        char                    *volname  = NULL;
-        dict_t                  *rsp_dict = NULL;
-        call_frame_t            *frame    = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    dict_t *rsp_dict = NULL;
+    call_frame_t *frame = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to create volume");
+    gf_log("cli", GF_LOG_INFO, "Received resp to create volume");
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret)
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
                 goto out;
+            }
+        }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+        ret = cli_xml_output_vol_create(rsp_dict, rsp.op_ret, rsp.op_errno,
+                                        rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                ret = cli_xml_output_vol_create (rsp_dict, rsp.op_ret,
-                                                 rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume create: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume create: %s: failed", volname);
-        else
-                cli_out ("volume create: %s: success: "
-                         "please start the volume to access data", volname);
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume create: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume create: %s: failed", volname);
+    else
+        cli_out(
+            "volume create: %s: success: "
+            "please start the volume to access data",
+            volname);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+
+    if (rsp_dict)
+        dict_unref(rsp_dict);
+    return ret;
 }
 
-int
-gf_cli_delete_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_delete_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *rsp_dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-        GF_ASSERT (myframe);
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    GF_ASSERT(myframe);
+    frame = myframe;
 
-        frame = myframe;
+    GF_ASSERT(frame->local);
 
-        GF_ASSERT (frame->local);
+    local = frame->local;
 
-        local = frame->local;
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    gf_log("cli", GF_LOG_INFO, "Received resp to delete volume");
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict get failed");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
                 goto out;
+            }
         }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to delete volume");
+        ret = cli_xml_output_generic_volume("volDelete", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict get failed");
+        goto out;
+    }
 
-                ret = cli_xml_output_generic_volume ("volDelete", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume delete: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume delete: %s: failed", volname);
+    else
+        cli_out("volume delete: %s: success", volname);
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume delete: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume delete: %s: failed", volname);
-        else
-                cli_out ("volume delete: %s: success", volname);
-
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    if (rsp_dict)
+        dict_unref(rsp_dict);
+    gf_log("", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int
-gf_cli3_1_uuid_get_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
+static int
+gf_cli3_1_uuid_get_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
 {
-        char                    *uuid_str = NULL;
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
+    char *uuid_str = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status)
-                goto out;
+    if (-1 == req->rpc_status)
+        goto out;
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        frame->local = NULL;
+    frame->local = NULL;
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to uuid get");
+    gf_log("cli", GF_LOG_INFO, "Received resp to uuid get");
 
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to unserialize "
-                        "response for uuid get");
-                goto out;
-        }
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
 
-        ret = dict_get_str (dict, "uuid", &uuid_str);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get uuid "
-                        "from dictionary");
-                goto out;
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_dict ("uuidGenerate", dict, rsp.op_ret,
-                                           rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, "") == 0)
-                        cli_err ("Get uuid was unsuccessful");
-                else
-                        cli_err ("%s", rsp.op_errstr);
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_dict("uuidGenerate", dict, rsp.op_ret,
+                                  rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        } else {
-                cli_out ("UUID: %s", uuid_str);
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, "") == 0)
+            cli_err("Get uuid was unsuccessful");
+        else
+            cli_err("%s", rsp.op_errstr);
 
+    } else {
+        ret = dict_get_str_sizen(dict, "uuid", &uuid_str);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to get uuid from dictionary");
+            goto out;
         }
-        ret = rsp.op_ret;
+        cli_out("UUID: %s", uuid_str);
+    }
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        cli_local_wipe (local);
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    cli_local_wipe(local);
+    gf_free_xdr_cli_rsp(rsp);
+
+    if (dict)
+        dict_unref(dict);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int
-gf_cli3_1_uuid_reset_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli3_1_uuid_reset_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        frame->local = NULL;
+    frame->local = NULL;
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to uuid reset");
+    gf_log("cli", GF_LOG_INFO, "Received resp to uuid reset");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_dict ("uuidReset", dict, rsp.op_ret,
-                                           rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_dict("uuidReset", NULL, rsp.op_ret, rsp.op_errno,
+                                  rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("%s", rsp.op_errstr);
-        else
-                cli_out ("resetting the peer uuid has been %s",
-                         (rsp.op_ret) ? "unsuccessful": "successful");
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("%s", rsp.op_errstr);
+    else
+        cli_out("resetting the peer uuid has been %s",
+                (rsp.op_ret) ? "unsuccessful" : "successful");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        cli_local_wipe (local);
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
-        if (dict)
-                dict_unref (dict);
+    cli_cmd_broadcast_response(ret);
+    cli_local_wipe(local);
+    gf_free_xdr_cli_rsp(rsp);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int
-gf_cli_start_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_start_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *rsp_dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "dict get failed");
+    gf_log("cli", GF_LOG_INFO, "Received resp to start volume");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
                 goto out;
+            }
         }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to start volume");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+        ret = cli_xml_output_generic_volume("volStart", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                ret = cli_xml_output_generic_volume ("volStart", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "dict get failed");
+        goto out;
+    }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume start: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume start: %s: failed", volname);
-        else
-                cli_out ("volume start: %s: success", volname);
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume start: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume start: %s: failed", volname);
+    else
+        cli_out("volume start: %s: success", volname);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+
+    if (rsp_dict)
+        dict_unref(rsp_dict);
+    return ret;
 }
 
-int
-gf_cli_stop_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_stop_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
 {
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        cli_local_t           *local = NULL;
-        char                  *volname = NULL;
-        call_frame_t          *frame = NULL;
-        dict_t                *rsp_dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Unable to get volname from dict");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to stop volume");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-                ret = cli_xml_output_generic_volume ("volStop", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    GF_ASSERT(myframe);
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume stop: %s: failed: %s", volname, rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume stop: %s: failed", volname);
-        else
-                cli_out ("volume stop: %s: success", volname);
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    frame = myframe;
 
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
+    GF_ASSERT(frame->local);
 
-        return ret;
-}
+    local = frame->local;
 
-int
-gf_cli_print_rebalance_status (dict_t *dict, enum gf_task_types task_type,
-                               gf_boolean_t is_tier)
-{
-        int                ret            = -1;
-        int                count          = 0;
-        int                i              = 1;
-        char               key[256]       = {0,};
-        gf_defrag_status_t status_rcd     = GF_DEFRAG_STATUS_NOT_STARTED;
-        uint64_t           files          = 0;
-        uint64_t           size           = 0;
-        uint64_t           lookup         = 0;
-        char               *node_name     = NULL;
-        uint64_t           failures       = 0;
-        uint64_t           skipped        = 0;
-        double             elapsed        = 0;
-        char               *status_str    = NULL;
-        char               *size_str      = NULL;
-        int32_t            hrs            = 0;
-        uint32_t           min            = 0;
-        uint32_t           sec            = 0;
-        gf_boolean_t       down           = _gf_false;
-        gf_boolean_t       fix_layout     = _gf_false;
-        uint64_t           max_time       = 0;
-        uint64_t           max_elapsed    = 0;
-        uint64_t           time_left      = 0;
-        gf_boolean_t       show_estimates = _gf_false;
-
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        memset (key, 0, 256);
-        snprintf (key, 256, "status-1");
+    gf_log("cli", GF_LOG_INFO, "Received resp to stop volume");
 
-        ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, 1);
-                gf_log ("cli", GF_LOG_TRACE, "failed to get status");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
                 goto out;
+            }
         }
 
-        /* Fix layout will be sent to all nodes for the volume
-           so every status should be of type
-           GF_DEFRAG_STATUS_LAYOUT_FIX*
-        */
-
-        if ((task_type == GF_TASK_TYPE_REBALANCE)
-           && (status_rcd >= GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED)) {
-                fix_layout = _gf_true;
-        }
+        ret = cli_xml_output_generic_volume("volStop", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (fix_layout) {
-                cli_out ("%35s %41s %27s", "Node", "status",
-                         "run time in h:m:s");
-                cli_out ("%35s %41s %27s", "---------", "-----------",
-                         "------------");
-        } else {
-                cli_out ("%40s %16s %13s %13s %13s %13s %20s %18s",
-                         "Node", "Rebalanced-files", "size", "scanned",
-                         "failures", "skipped", "status", "run time in"
-                         " h:m:s");
-                cli_out ("%40s %16s %13s %13s %13s %13s %20s %18s",
-                         "---------", "-----------", "-----------",
-                         "-----------", "-----------", "-----------",
-                         "------------", "--------------");
-        }
-
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name = NULL;
-                files = 0;
-                size = 0;
-                lookup = 0;
-                skipped = 0;
-                status_str = NULL;
-                elapsed = 0;
-                time_left = 0;
-
-                /* Check if status is NOT_STARTED, and continue early */
-                memset (key, 0, 256);
-                snprintf (key, 256, "status-%d", i);
-
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-                if (ret == -ENOENT) {
-                        gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, i);
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get status");
-                        gf_log ("cli", GF_LOG_ERROR, "node down and has failed"
-                                " to set dict");
-                        down = _gf_true;
-                        continue;
-                        /* skip this node if value not available*/
-                } else if (ret) {
-                        gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, i);
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get status");
-                        continue;
-                        /* skip this node if value not available*/
-                }
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Unable to get volname from dict");
+        goto out;
+    }
 
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume stop: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume stop: %s: failed", volname);
+    else
+        cli_out("volume stop: %s: success", volname);
 
-                if (GF_DEFRAG_STATUS_STARTED == status_rcd)
-                        show_estimates = _gf_true;
+    ret = rsp.op_ret;
 
-                snprintf (key, 256, "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+out:
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "files-%d", i);
-                ret = dict_get_uint64 (dict, key, &files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get file count");
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "size-%d", i);
-                ret = dict_get_uint64 (dict, key, &size);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get size of xfer");
+    return ret;
+}
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "lookups-%d", i);
-                ret = dict_get_uint64 (dict, key, &lookup);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get lookedup file count");
+static int
+gf_cli_print_rebalance_status(dict_t *dict, enum gf_task_types task_type)
+{
+    int ret = -1;
+    int count = 0;
+    int i = 1;
+    char key[64] = {
+        0,
+    };
+    int keylen;
+    gf_defrag_status_t status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookup = 0;
+    char *node_name = NULL;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    double elapsed = 0;
+    char *status_str = NULL;
+    char *size_str = NULL;
+    int32_t hrs = 0;
+    uint32_t min = 0;
+    uint32_t sec = 0;
+    gf_boolean_t fix_layout = _gf_false;
+    uint64_t max_time = 0;
+    uint64_t max_elapsed = 0;
+    uint64_t time_left = 0;
+    gf_boolean_t show_estimates = _gf_false;
+
+    ret = dict_get_int32_sizen(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "count not set");
+        goto out;
+    }
+
+    for (i = 1; i <= count; i++) {
+        keylen = snprintf(key, sizeof(key), "status-%d", i);
+        ret = dict_get_int32n(dict, key, keylen, (int32_t *)&status_rcd);
+        /* If information from a node is missing we should skip
+         * the node and try to fetch information of other nodes.
+         * If information is not found for all nodes, we should
+         * error out.
+         */
+        if (!ret)
+            break;
+        if (ret && i == count) {
+            gf_log("cli", GF_LOG_TRACE, "failed to get status");
+            goto out;
+        }
+    }
+
+    /* Fix layout will be sent to all nodes for the volume
+       so every status should be of type
+       GF_DEFRAG_STATUS_LAYOUT_FIX*
+    */
+
+    if ((task_type == GF_TASK_TYPE_REBALANCE) &&
+        (status_rcd >= GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED)) {
+        fix_layout = _gf_true;
+    }
+
+    if (fix_layout) {
+        cli_out("%35s %41s %27s", "Node", "status", "run time in h:m:s");
+        cli_out("%35s %41s %27s", "---------", "-----------", "------------");
+    } else {
+        cli_out("%40s %16s %13s %13s %13s %13s %20s %18s", "Node",
+                "Rebalanced-files", "size", "scanned", "failures", "skipped",
+                "status",
+                "run time in"
+                " h:m:s");
+        cli_out("%40s %16s %13s %13s %13s %13s %20s %18s", "---------",
+                "-----------", "-----------", "-----------", "-----------",
+                "-----------", "------------", "--------------");
+    }
+
+    for (i = 1; i <= count; i++) {
+        /* Reset the variables to prevent carryover of values */
+        node_name = NULL;
+        files = 0;
+        size = 0;
+        lookup = 0;
+        skipped = 0;
+        status_str = NULL;
+        elapsed = 0;
+        time_left = 0;
+
+        /* Check if status is NOT_STARTED, and continue early */
+        keylen = snprintf(key, sizeof(key), "status-%d", i);
+
+        ret = dict_get_int32n(dict, key, keylen, (int32_t *)&status_rcd);
+        if (ret == -ENOENT) {
+            gf_log("cli", GF_LOG_TRACE, "count %d %d", count, i);
+            gf_log("cli", GF_LOG_TRACE, "failed to get status");
+            gf_log("cli", GF_LOG_ERROR, "node down and has failed to set dict");
+            continue;
+            /* skip this node if value not available*/
+        } else if (ret) {
+            gf_log("cli", GF_LOG_TRACE, "count %d %d", count, i);
+            gf_log("cli", GF_LOG_TRACE, "failed to get status");
+            continue;
+            /* skip this node if value not available*/
+        }
+
+        if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
+            continue;
+
+        if (GF_DEFRAG_STATUS_STARTED == status_rcd)
+            show_estimates = _gf_true;
+
+        keylen = snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_strn(dict, key, keylen, &node_name);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get node-name");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "failures-%d", i);
-                ret = dict_get_uint64 (dict, key, &failures);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get failures count");
+        snprintf(key, sizeof(key), "files-%d", i);
+        ret = dict_get_uint64(dict, key, &files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get file count");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "skipped-%d", i);
-                ret = dict_get_uint64 (dict, key, &skipped);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get skipped count");
+        snprintf(key, sizeof(key), "size-%d", i);
+        ret = dict_get_uint64(dict, key, &size);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get size of xfer");
 
-                /* For remove-brick include skipped count into failure count*/
-                if (task_type != GF_TASK_TYPE_REBALANCE) {
-                        failures += skipped;
-                        skipped = 0;
-                }
+        snprintf(key, sizeof(key), "lookups-%d", i);
+        ret = dict_get_uint64(dict, key, &lookup);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get lookedup file count");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get run-time");
+        snprintf(key, sizeof(key), "failures-%d", i);
+        ret = dict_get_uint64(dict, key, &failures);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get failures count");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "time-left-%d", i);
-                ret = dict_get_uint64 (dict, key, &time_left);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get time left");
-
-                if (elapsed > max_elapsed)
-                        max_elapsed = elapsed;
-
-                if (time_left > max_time)
-                        max_time = time_left;
-
-                /* Check for array bound */
-                if (status_rcd >= GF_DEFRAG_STATUS_MAX)
-                        status_rcd = GF_DEFRAG_STATUS_MAX;
-
-                status_str = cli_vol_task_status_str[status_rcd];
-                size_str = gf_uint64_2human_readable(size);
-                hrs = elapsed / 3600;
-                min = ((uint64_t) elapsed % 3600) / 60;
-                sec = ((uint64_t) elapsed % 3600) % 60;
-
-                if (fix_layout) {
-                        cli_out ("%35s %50s %8d:%d:%d", node_name, status_str,
-                                 hrs, min, sec);
-                } else {
-                        if (size_str) {
-                                cli_out ("%40s %16"PRIu64 " %13s" " %13"PRIu64
-                                          " %13" PRIu64" %13"PRIu64 " %20s "
-                                         "%8d:%02d:%02d", node_name, files,
-                                         size_str, lookup, failures, skipped,
-                                         status_str, hrs, min, sec);
-                        } else {
-                                cli_out ("%40s %16"PRIu64 " %13"PRIu64 " %13"
-                                         PRIu64 " %13"PRIu64" %13"PRIu64 " %20s"
-                                         " %8d:%02d:%02d", node_name, files,
-                                         size, lookup, failures, skipped,
-                                         status_str, hrs, min, sec);
-                        }
-                }
-                GF_FREE(size_str);
-        }
-        if (is_tier && down)
-                cli_out ("WARNING: glusterd might be down on one or more nodes."
-                         " Please check the nodes that are down using \'gluster"
-                         " peer status\' and start the glusterd on those nodes,"
-                         " else tier detach commit might fail!");
-
-        /* Max time will be non-zero if rebalance is still running */
-        if (max_time) {
-                hrs = max_time / 3600;
-                min = (max_time % 3600) / 60;
-                sec = (max_time % 3600) % 60;
-
-                if (hrs < REBAL_ESTIMATE_SEC_UPPER_LIMIT) {
-                        cli_out ("Estimated time left for rebalance to "
-                                 "complete : %8d:%02d:%02d", hrs, min, sec);
-                } else {
-                        cli_out ("Estimated time left for rebalance to "
-                                 "complete : > 2 months. Please try again "
-                                 "later.");
-                }
-        } else {
-                /* Rebalance will return 0 if it could not calculate the
-                 * estimates or if it is complete.
-                 */
-                if (!show_estimates) {
-                        goto out;
-                }
-                if (max_elapsed <= REBAL_ESTIMATE_START_TIME) {
-                        cli_out ("The estimated time for rebalance to complete "
-                                 "will be unavailable for the first 10 "
-                                 "minutes.");
-                } else {
-                        cli_out ("Rebalance estimated time unavailable. Please "
-                                 "try again later.");
-                }
-        }
-out:
-        return ret;
-}
+        snprintf(key, sizeof(key), "skipped-%d", i);
+        ret = dict_get_uint64(dict, key, &skipped);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get skipped count");
 
-int
-gf_cli_print_tier_status (dict_t *dict, enum gf_task_types task_type)
-{
-        int                ret          = -1;
-        int                count        = 0;
-        int                i            = 1;
-        uint64_t           promoted     = 0;
-        uint64_t           demoted      = 0;
-        char               key[256]     = {0,};
-        char               *node_name   = NULL;
-        gf_defrag_status_t status_rcd   = GF_DEFRAG_STATUS_NOT_STARTED;
-        char               *status_str  = NULL;
-        gf_boolean_t       down         = _gf_false;
-        double             elapsed      = 0;
-        int                hrs          = 0;
-        int                min          = 0;
-        int                sec          = 0;
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
+        /* For remove-brick include skipped count into failure count*/
+        if (task_type != GF_TASK_TYPE_REBALANCE) {
+            failures += skipped;
+            skipped = 0;
         }
 
-        cli_out ("%-20s %-20s %-20s %-20s %-20s", "Node", "Promoted files",
-                 "Demoted files", "Status", "run time in h:m:s");
-        cli_out ("%-20s %-20s %-20s %-20s %-20s", "---------", "---------",
-                 "---------", "---------", "---------");
-
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name = NULL;
-                promoted = 0;
-                demoted = 0;
-
-                /* Check if status is NOT_STARTED, and continue early */
-                memset (key, 0, 256);
-                snprintf (key, 256, "status-%d", i);
-
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-                if (ret == -ENOENT) {
-                        gf_log ("cli", GF_LOG_TRACE, "count: %d, %d,"
-                                "failed to get status", count, i);
-                        gf_log ("cli", GF_LOG_ERROR, "node down and has failed"
-                                " to set dict");
-                        down = _gf_true;
-                        continue;
-                        /*skipping this node as value unavailable*/
-                } else if (ret) {
-                        gf_log ("cli", GF_LOG_TRACE, "count: %d, %d,"
-                                "failed to get status", count, i);
-                        continue;
-                }
-
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
-
-                memset (key, 0, 256);
-                snprintf (key, 256, "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+        snprintf(key, sizeof(key), "run-time-%d", i);
+        ret = dict_get_double(dict, key, &elapsed);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get run-time");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "promoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &promoted);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get promoted count");
+        snprintf(key, sizeof(key), "time-left-%d", i);
+        ret = dict_get_uint64(dict, key, &time_left);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get time left");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "demoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &demoted);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get demoted count");
+        if (elapsed > max_elapsed)
+            max_elapsed = elapsed;
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get run-time");
+        if (time_left > max_time)
+            max_time = time_left;
 
-                /* Check for array bound */
-                if (status_rcd >= GF_DEFRAG_STATUS_MAX)
-                        status_rcd = GF_DEFRAG_STATUS_MAX;
+        /* Check for array bound */
+        if (status_rcd >= GF_DEFRAG_STATUS_MAX)
+            status_rcd = GF_DEFRAG_STATUS_MAX;
 
-                hrs = elapsed / 3600;
-                min = ((int) elapsed % 3600) / 60;
-                sec = ((int) elapsed % 3600) % 60;
+        status_str = cli_vol_task_status_str[status_rcd];
+        size_str = gf_uint64_2human_readable(size);
+        hrs = elapsed / 3600;
+        min = ((uint64_t)elapsed % 3600) / 60;
+        sec = ((uint64_t)elapsed % 3600) % 60;
 
-                status_str = cli_vol_task_status_str[status_rcd];
-                cli_out ("%-20s %-20"PRIu64" %-20"PRIu64" %-20s"
-                         " %d:%d:%d", node_name, promoted, demoted,
-                         status_str, hrs, min, sec);
+        if (fix_layout) {
+            cli_out("%35s %50s %8d:%d:%d", node_name, status_str, hrs, min,
+                    sec);
+        } else {
+            if (size_str) {
+                cli_out("%40s %16" PRIu64
+                        " %13s"
+                        " %13" PRIu64 " %13" PRIu64 " %13" PRIu64
+                        " %20s "
+                        "%8d:%02d:%02d",
+                        node_name, files, size_str, lookup, failures, skipped,
+                        status_str, hrs, min, sec);
+            } else {
+                cli_out("%40s %16" PRIu64 " %13" PRIu64 " %13" PRIu64
+                        " %13" PRIu64 " %13" PRIu64
+                        " %20s"
+                        " %8d:%02d:%02d",
+                        node_name, files, size, lookup, failures, skipped,
+                        status_str, hrs, min, sec);
+            }
+        }
+        GF_FREE(size_str);
+    }
+
+    /* Max time will be non-zero if rebalance is still running */
+    if (max_time) {
+        hrs = max_time / 3600;
+        min = (max_time % 3600) / 60;
+        sec = (max_time % 3600) % 60;
+
+        if (hrs < REBAL_ESTIMATE_SEC_UPPER_LIMIT) {
+            cli_out(
+                "Estimated time left for rebalance to "
+                "complete : %8d:%02d:%02d",
+                hrs, min, sec);
+        } else {
+            cli_out(
+                "Estimated time left for rebalance to "
+                "complete : > 2 months. Please try again "
+                "later.");
+        }
+    } else {
+        /* Rebalance will return 0 if it could not calculate the
+         * estimates or if it is complete.
+         */
+        if (!show_estimates) {
+            goto out;
+        }
+        if (max_elapsed <= REBAL_ESTIMATE_START_TIME) {
+            cli_out(
+                "The estimated time for rebalance to complete "
+                "will be unavailable for the first 10 "
+                "minutes.");
+        } else {
+            cli_out(
+                "Rebalance estimated time unavailable. Please "
+                "try again later.");
         }
-        if (down)
-                cli_out ("WARNING: glusterd might be down on one or more nodes."
-                         " Please check the nodes that are down using \'gluster"
-                         " peer status\' and start the glusterd on those nodes.");
+    }
 out:
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_defrag_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp   rsp          = {0,};
-        cli_local_t  *local       = NULL;
-        char         *volname     = NULL;
-        call_frame_t *frame       = NULL;
-        int          cmd          = 0;
-        int          ret          = -1;
-        dict_t       *dict        = NULL;
-        char         msg[1024]    = {0,};
-        char         *task_id_str = NULL;
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        GF_ASSERT (myframe);
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
+static int
+gf_cli_defrag_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    int cmd = 0;
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *task_id_str = NULL;
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    GF_ASSERT(myframe);
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "Failed to get volname");
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(local->dict, "rebalance-command",
+                               (int32_t *)&cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get command");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+            gf_log("glusterd", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
+    if (!((cmd == GF_DEFRAG_CMD_STOP) || (cmd == GF_DEFRAG_CMD_STATUS)) &&
+        !(global_state->mode & GLUSTER_MODE_XML)) {
+        ret = dict_get_str_sizen(dict, GF_REBALANCE_TID_KEY, &task_id_str);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to get volname");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "rebalance-command",
-                              (int32_t *)&cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to get command");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("glusterd", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_WARNING, "failed to get %s from dict",
+                   GF_REBALANCE_TID_KEY);
         }
-
-        if (!((cmd == GF_DEFRAG_CMD_STOP) ||
-              (cmd == GF_DEFRAG_CMD_STATUS) ||
-              (cmd == GF_DEFRAG_CMD_STATUS_TIER)) &&
-             !(global_state->mode & GLUSTER_MODE_XML)) {
-                ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);
-                if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                } else {
-                         if (!rsp.op_ret) {
-                                /* append errstr in the cli msg for successful
-                                 * case since unlock failures can be highlighted
-                                 * event though rebalance command was successful
-                                 */
-                                 if (cmd == GF_DEFRAG_CMD_START_TIER) {
-                                         snprintf (msg, sizeof (msg), "Tier "
-                                                  "start is successful on %s.",
-                                                  volname);
-                                 } else if (cmd == GF_DEFRAG_CMD_STOP_TIER) {
-                                         snprintf (msg, sizeof (msg), "Tier "
-                                                  "daemon stopped "
-                                                  "on %s.", volname);
-                                 } else {
-                                         snprintf (msg, sizeof (msg),
-                                                  "Rebalance on %s has been "
-                                                  "started successfully. Use "
-                                                  "rebalance status command to"
-                                                  " check status of the "
-                                                  "rebalance process.\nID: %s",
-                                                  volname, task_id_str);
-                                 }
-                         } else {
-                                snprintf (msg, sizeof (msg),
-                                          "Starting rebalance on volume %s has "
-                                          "been unsuccessful.", volname);
-                        }
-                }
-                goto done;
-        }
-
-        if (cmd == GF_DEFRAG_CMD_STOP) {
-                if (rsp.op_ret == -1) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg),
-                                          "%s", rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg),
-                                          "rebalance volume %s stop failed",
-                                          volname);
-                        goto done;
-                } else {
-                        /* append errstr in the cli msg for successful case
-                         * since unlock failures can be highlighted event though
-                         * rebalance command was successful */
-                        snprintf (msg, sizeof (msg),
-                                  "rebalance process may be in the middle of a "
-                                  "file migration.\nThe process will be fully "
-                                  "stopped once the migration of the file is "
-                                  "complete.\nPlease check rebalance process "
-                                  "for completion before doing any further "
-                                  "brick related tasks on the volume.\n%s",
-                                  rsp.op_errstr);
-                }
-        }
-        if (cmd == GF_DEFRAG_CMD_STATUS || cmd == GF_DEFRAG_CMD_STATUS_TIER) {
-                if (rsp.op_ret == -1) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg),
-                                          "%s", rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg),
-                                          "Failed to get the status of "
-                                          "rebalance process");
-                        goto done;
-                } else {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                }
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_rebalance (cmd, dict, rsp.op_ret,
-                                                    rsp.op_errno,
-                                                    rsp.op_errstr);
-                goto out;
+        if (rsp.op_ret && strcmp(rsp.op_errstr, "")) {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        } else {
+            if (!rsp.op_ret) {
+                /* append errstr in the cli msg for successful
+                 * case since unlock failures can be highlighted
+                 * event though rebalance command was successful
+                 */
+                snprintf(msg, sizeof(msg),
+                         "Rebalance on %s has been "
+                         "started successfully. Use "
+                         "rebalance status command to"
+                         " check status of the "
+                         "rebalance process.\nID: %s",
+                         volname, task_id_str);
+            } else {
+                snprintf(msg, sizeof(msg),
+                         "Starting rebalance on volume %s has "
+                         "been unsuccessful.",
+                         volname);
+            }
+        }
+        goto done;
+    }
+
+    if (cmd == GF_DEFRAG_CMD_STOP) {
+        if (rsp.op_ret == -1) {
+            if (strcmp(rsp.op_errstr, ""))
+                snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            else
+                snprintf(msg, sizeof(msg), "rebalance volume %s stop failed",
+                         volname);
+            goto done;
+        } else {
+            /* append errstr in the cli msg for successful case
+             * since unlock failures can be highlighted event though
+             * rebalance command was successful */
+            snprintf(msg, sizeof(msg),
+                     "rebalance process may be in the middle of a "
+                     "file migration.\nThe process will be fully "
+                     "stopped once the migration of the file is "
+                     "complete.\nPlease check rebalance process "
+                     "for completion before doing any further "
+                     "brick related tasks on the volume.\n%s",
+                     rsp.op_errstr);
+        }
+    }
+    if (cmd == GF_DEFRAG_CMD_STATUS) {
+        if (rsp.op_ret == -1) {
+            if (strcmp(rsp.op_errstr, ""))
+                snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            else
+                snprintf(msg, sizeof(msg),
+                         "Failed to get the status of rebalance process");
+            goto done;
+        } else {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
         }
+    }
 
-        if (cmd == GF_DEFRAG_CMD_STATUS_TIER)
-                ret = gf_cli_print_tier_status (dict, GF_TASK_TYPE_REBALANCE);
-        else if (cmd == GF_DEFRAG_CMD_DETACH_STATUS)
-                ret = gf_cli_print_rebalance_status (dict,
-                                                     GF_TASK_TYPE_REBALANCE,
-                                                     _gf_true);
-        else
-                ret = gf_cli_print_rebalance_status (dict,
-                                                     GF_TASK_TYPE_REBALANCE,
-                                                     _gf_false);
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_rebalance(cmd, dict, rsp.op_ret, rsp.op_errno,
+                                           rsp.op_errstr);
+        goto out;
+    }
 
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to print rebalance status");
+    ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REBALANCE);
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "Failed to print rebalance status");
 
 done:
-        if (global_state->mode & GLUSTER_MODE_XML)
-                cli_xml_output_str ("volRebalance", msg,
-                                    rsp.op_ret, rsp.op_errno,
-                                    rsp.op_errstr);
-        else {
-                if (rsp.op_ret)
-
-                        if (cmd == GF_DEFRAG_CMD_START_TIER || cmd ==
-                            GF_DEFRAG_CMD_STATUS_TIER) {
-                                cli_err ("Tiering Migration Functionality: %s:"
-                                         " failed%s%s", volname,
-                                         strlen (msg) ? ": " : "", msg);
-                        } else
-                                cli_err ("volume rebalance: %s: failed%s%s",
-                                         volname, strlen (msg) ? ": " : "",
-                                         msg);
-                else
-                        if (cmd == GF_DEFRAG_CMD_START_TIER || cmd ==
-                            GF_DEFRAG_CMD_STATUS_TIER) {
-                                cli_out ("Tiering Migration Functionality: %s:"
-                                         " success%s%s", volname,
-                                         strlen (msg) ? ": " : "", msg);
-                        } else
-                                cli_out ("volume rebalance: %s: success%s%s",
-                                         volname, strlen (msg) ? ": " : "",
-                                         msg);
-        }
-        ret = rsp.op_ret;
-
-out:
-        free (rsp.op_errstr); //malloced by xdr
-        free (rsp.dict.dict_val); //malloced by xdr
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
-}
-
-int
-gf_cli_rename_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        char                    msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
-        snprintf (msg, sizeof (msg), "Rename volume %s",
-                  (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volRename", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
+    if (global_state->mode & GLUSTER_MODE_XML)
+        cli_xml_output_str("volRebalance", msg, rsp.op_ret, rsp.op_errno,
+                           rsp.op_errstr);
+    else {
         if (rsp.op_ret)
-                cli_err ("volume rename: failed");
+            cli_err("volume rebalance: %s: failed%s%s", volname,
+                    strlen(msg) ? ": " : "", msg);
         else
-                cli_out ("volume rename: success");
-
-        ret = rsp.op_ret;
+            cli_out("volume rebalance: %s: success%s%s", volname,
+                    strlen(msg) ? ": " : "", msg);
+    }
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    gf_free_xdr_cli_rsp(rsp);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-int
-gf_cli_reset_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp           rsp   = {0,};
-        int                  ret   = -1;
-        char                 msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to reset");
-
-        if (strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "reset volume %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volReset", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+static int
+gf_cli_rename_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to probe");
+    snprintf(msg, sizeof(msg), "Rename volume %s",
+             (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volRename", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume reset: failed: %s", msg);
-        else
-                cli_out ("volume reset: success: %s", msg);
+    if (rsp.op_ret)
+        cli_err("volume rename: failed");
+    else
+        cli_out("volume rename: success");
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
-}
-
-char *
-is_server_debug_xlator (void *myframe)
-{
-        call_frame_t         *frame        = NULL;
-        cli_local_t          *local        = NULL;
-        char                 **words       = NULL;
-        char                 *key          = NULL;
-        char                 *value        = NULL;
-        char                 *debug_xlator = NULL;
-
-        frame = myframe;
-        local = frame->local;
-        words = (char **)local->words;
-
-        while (*words != NULL) {
-                if (strstr (*words, "trace") == NULL &&
-                    strstr (*words, "error-gen") == NULL) {
-                        words++;
-                        continue;
-                }
-
-                key = *words;
-                words++;
-                value = *words;
-                if (value == NULL)
-                        break;
-                if (strstr (value, "client")) {
-                        words++;
-                        continue;
-                } else {
-                        if (!(strstr (value, "posix") || strstr (value, "acl")
-                              || strstr (value, "locks") ||
-                              strstr (value, "io-threads") ||
-                              strstr (value, "marker") ||
-                              strstr (value, "index"))) {
-                                words++;
-                                continue;
-                        } else {
-                                debug_xlator = gf_strdup (key);
-                                break;
-                        }
-                }
-        }
-
-        return debug_xlator;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_set_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli_reset_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf_cli_rsp           rsp   = {0,};
-        int                  ret   = -1;
-        dict_t               *dict = NULL;
-        char                 *help_str = NULL;
-        char                 msg[1024] = {0,};
-        char                 *debug_xlator = NULL;
-        char                 tmp_str[512] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to set");
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-
-        /* For brick processes graph change does not happen on the fly.
-         * The process has to be restarted. So this is a check from the
-         * volume set option such that if debug xlators such as trace/errorgen
-         * are provided in the set command, warn the user.
-         */
-        debug_xlator = is_server_debug_xlator (myframe);
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to reset");
+
+    if (strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "reset volume %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volReset", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (dict_get_str (dict, "help-str", &help_str) && !msg[0])
-                snprintf (msg, sizeof (msg), "Set volume %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-        if (rsp.op_ret == 0 && debug_xlator) {
-                snprintf (tmp_str, sizeof (tmp_str), "\n%s translator has been "
-                          "added to the server volume file. Please restart the"
-                          " volume for enabling the translator", debug_xlator);
-        }
+    if (rsp.op_ret)
+        cli_err("volume reset: failed: %s", msg);
+    else
+        cli_out("volume reset: success: %s", msg);
 
-        if ((global_state->mode & GLUSTER_MODE_XML) && (help_str == NULL)) {
-                ret = cli_xml_output_str ("volSet", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("volume set: failed: %s", rsp.op_errstr);
-                else
-                        cli_err ("volume set: failed");
-        } else {
-                if (help_str == NULL) {
-                        if (debug_xlator == NULL)
-                                cli_out ("volume set: success");
-                        else
-                                cli_out ("volume set: success%s", tmp_str);
-                }else {
-                        cli_out ("%s", help_str);
-                }
-        }
-
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        GF_FREE (debug_xlator);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_add_tier_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                           int count, void *myframe)
+static int
+gf_cli_ganesha_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
 {
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
 
+    GF_ASSERT(myframe);
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to attach tier");
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Attach tier %s",
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAttachTier", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret)
-                cli_err ("volume attach-tier: failed: %s", msg);
-        else
-                cli_out ("volume attach-tier: success");
-        ret = rsp.op_ret;
-
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
-}
-
-int
-gf_cli_attach_tier_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to ganesha");
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    dict = dict_new();
 
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to attach tier");
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret)
+        goto out;
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("nfs-ganesha: failed: %s", rsp.op_errstr);
         else
-                snprintf (msg, sizeof (msg), "Attach tier %s",
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
+            cli_err("nfs-ganesha: failed");
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAttachTier", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    else {
+        cli_out("nfs-ganesha : success ");
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume attach-tier: failed: %s", msg);
-        else
-                cli_out ("volume attach-tier: success");
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-int
-gf_cli_remove_tier_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static char *
+is_server_debug_xlator(void *myframe)
 {
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    char **words = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char *debug_xlator = NULL;
 
-        gf_cli_rsp                      rsp   = {0,};
-        int                             ret   = -1;
-        char                            msg[1024] = {0,};
-        char                           *cmd_str = "unknown";
-        cli_local_t                    *local = NULL;
-        call_frame_t                   *frame = NULL;
-        char                           *task_id_str = NULL;
-        dict_t                         *rsp_dict = NULL;
-        int32_t                         command = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
+    frame = myframe;
+    local = frame->local;
+    words = (char **)local->words;
 
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", &command);
-        if (ret) {
-                 gf_log ("", GF_LOG_ERROR, "failed to get command");
-                 goto out;
+    while (*words != NULL) {
+        if (strstr(*words, "trace") == NULL &&
+            strstr(*words, "error-gen") == NULL) {
+            words++;
+            continue;
         }
 
-
-        if (rsp.dict.dict_len) {
-                rsp_dict = dict_new ();
-                if (!rsp_dict) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                        &rsp_dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to unserialize rsp_dict");
-                        goto out;
-                }
-        }
-
-        switch (command) {
-        case GF_DEFRAG_CMD_DETACH_START:
-                cmd_str = "start";
-
-                ret = dict_get_str (rsp_dict, GF_REMOVE_BRICK_TID_KEY,
-                                    &task_id_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "remove-brick-id is not present in dict");
-                }
-                break;
-        case GF_DEFRAG_CMD_DETACH_COMMIT:
-                cmd_str = "commit";
-                break;
-        case GF_DEFRAG_CMD_DETACH_COMMIT_FORCE:
-                cmd_str = "commit force";
-                break;
-        case GF_DEFRAG_CMD_DETACH_STOP:
-                cmd_str = "stop";
-                break;
-        case GF_DEFRAG_CMD_DETACH_STATUS:
-                cmd_str = "status";
-                break;
-
-        default:
-                cmd_str = "unknown";
+        key = *words;
+        words++;
+        value = *words;
+        if (value == NULL)
+            break;
+        if (strstr(value, "client")) {
+            words++;
+            continue;
+        } else {
+            if (!(strstr(value, "posix") || strstr(value, "acl") ||
+                  strstr(value, "locks") || strstr(value, "io-threads") ||
+                  strstr(value, "marker") || strstr(value, "index"))) {
+                words++;
+                continue;
+            } else {
+                debug_xlator = gf_strdup(key);
                 break;
+            }
         }
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to detach tier");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Detach tier %s %s", cmd_str,
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
+    return debug_xlator;
+}
 
-        ret = rsp.op_ret;
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                _gf_true, rsp_dict,
-                                rsp.op_ret, rsp.op_errno,
-                                msg, "volDetachTier");
+static int
+gf_cli_set_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *help_str = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *debug_xlator = NULL;
+    char tmp_str[512] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to set");
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    /* For brick processes graph change does not happen on the fly.
+     * The process has to be restarted. So this is a check from the
+     * volume set option such that if debug xlators such as trace/errorgen
+     * are provided in the set command, warn the user.
+     */
+    debug_xlator = is_server_debug_xlator(myframe);
+
+    if (dict_get_str_sizen(dict, "help-str", &help_str) && !msg[0])
+        snprintf(msg, sizeof(msg), "Set volume %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+    if (rsp.op_ret == 0 && debug_xlator) {
+        snprintf(tmp_str, sizeof(tmp_str),
+                 "\n%s translator has been "
+                 "added to the server volume file. Please restart the"
+                 " volume for enabling the translator",
+                 debug_xlator);
+    }
+
+    if ((global_state->mode & GLUSTER_MODE_XML) && (help_str == NULL)) {
+        ret = cli_xml_output_str("volSet", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("volume set: failed: %s", rsp.op_errstr);
+        else
+            cli_err("volume set: failed");
+    } else {
+        if (help_str == NULL) {
+            if (debug_xlator == NULL)
+                cli_out("volume set: success");
+            else
+                cli_out("volume set: success%s", tmp_str);
         } else {
-                if (rsp.op_ret) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg), "volume tier "
-                                          "detach %s: failed: %s", cmd_str,
-                                          rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg), "volume tier "
-                                          "detach %s: failed", cmd_str);
-
-                        cli_err ("%s", msg);
-                        goto out;
-
-                } else {
-                        cli_out ("volume detach tier %s: success", cmd_str);
-                        if (GF_DEFRAG_CMD_DETACH_START == command &&
-                            task_id_str != NULL)
-                                cli_out ("ID: %s", task_id_str);
-                        if (GF_DEFRAG_CMD_DETACH_COMMIT == command)
-                                cli_out ("Check the detached bricks to ensure "
-                                         "all files are migrated.\nIf files "
-                                         "with data are found on the brick "
-                                         "path, copy them via a gluster mount "
-                                         "point before re-purposing the "
-                                         "removed brick. ");
-                }
-        }
-        if (command == GF_DEFRAG_CMD_DETACH_STOP ||
-            command == GF_DEFRAG_CMD_DETACH_STATUS)
-                ret = gf_cli_print_rebalance_status (rsp_dict,
-                                GF_TASK_TYPE_REMOVE_BRICK, _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                                "rebalance status");
-                goto out;
+            cli_out("%s", help_str);
         }
+    }
 
-        if ((command == GF_DEFRAG_CMD_DETACH_STOP) && (rsp.op_ret == 0)) {
-                cli_out ("'detach tier' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check detach tier process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    GF_FREE(debug_xlator);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
 int
-gf_cli_detach_tier_status_cbk (struct rpc_req *req, struct iovec *iov,
-                                 int count, void *myframe)
-{
-        gf_cli_rsp               rsp     = {0,};
-        int                      ret     = -1;
-        dict_t                  *dict    = NULL;
-        char                     msg[1024] = {0,};
-        int32_t                  command = 0;
-        gf1_op_commands          cmd = GF_OP_CMD_NONE;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *cmd_str = "unknown";
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", &command);
+gf_cli_add_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to add brick");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Add Brick %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volAddBrick", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
         if (ret)
-                goto out;
-
-        cmd = command;
-
-        switch (cmd) {
-        case GF_OP_CMD_STOP_DETACH_TIER:
-                cmd_str = "stop";
-                break;
-        case GF_OP_CMD_STATUS:
-                cmd_str = "status";
-                break;
-        default:
-                break;
-        }
-
-        ret = rsp.op_ret;
-        if (rsp.op_ret == -1) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume tier detach %s: "
-                                  "failed: %s", cmd_str, rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume tier detach %s: "
-                                  "failed", cmd_str);
-
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-
-                cli_err ("%s", msg);
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        strncpy (msg, "failed to unserialize req-buffer to "
-                                 "dictionary", sizeof (msg));
-
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                rsp.op_ret = -1;
-                                goto xml_output;
-                        }
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
-                        goto out;
-                }
-        }
-xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr,
-                                                               "volDetachTier");
-                } else {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier
-                                                               (_gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               msg,
-                                                               "volDetachTier");
-                }
-                goto out;
-        }
-
-        ret = gf_cli_print_rebalance_status (dict, GF_TASK_TYPE_REMOVE_BRICK,
-                                             _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                        "rebalance status");
-                goto out;
-        }
-
-        if ((cmd == GF_OP_CMD_STOP_DETACH_TIER) && (rsp.op_ret == 0)) {
-                cli_out ("'detach tier' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check detach tier process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
+    if (rsp.op_ret)
+        cli_err("volume add-brick: failed: %s", rsp.op_errstr);
+    else
+        cli_out("volume add-brick: success");
+    ret = rsp.op_ret;
 
 out:
-        free (rsp.dict.dict_val); /* malloced by xdr */
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-
-int
-gf_cli_add_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+static int
+gf_cli3_remove_brick_status_cbk(struct rpc_req *req, struct iovec *iov,
+                                int count, void *myframe)
 {
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    int32_t command = 0;
+    gf1_op_commands cmd = GF_OP_CMD_NONE;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    const char *cmd_str;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    frame = myframe;
 
+    GF_ASSERT(frame->local);
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to add brick");
+    local = frame->local;
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Add Brick %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAddBrick", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    ret = dict_get_int32_sizen(local->dict, "command", &command);
+    if (ret)
+        goto out;
 
-        if (rsp.op_ret)
-                cli_err ("volume add-brick: failed: %s", rsp.op_errstr);
-        else
-                cli_out ("volume add-brick: success");
-        ret = rsp.op_ret;
-
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
-}
-
-int
-gf_cli3_remove_brick_status_cbk (struct rpc_req *req, struct iovec *iov,
-                                 int count, void *myframe)
-{
-        gf_cli_rsp               rsp     = {0,};
-        int                      ret     = -1;
-        dict_t                  *dict    = NULL;
-        char                     msg[1024] = {0,};
-        int32_t                  command = 0;
-        gf1_op_commands          cmd = GF_OP_CMD_NONE;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *cmd_str = "unknown";
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
+    cmd = command;
 
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", &command);
-        if (ret)
-                goto out;
-
-        cmd = command;
-
-        switch (cmd) {
+    switch (cmd) {
         case GF_OP_CMD_STOP:
-                cmd_str = "stop";
-                break;
+            cmd_str = "stop";
+            break;
         case GF_OP_CMD_STATUS:
-                cmd_str = "status";
-                break;
+            cmd_str = "status";
+            break;
         default:
-                break;
-        }
-
-        ret = rsp.op_ret;
-        if (rsp.op_ret == -1) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume remove-brick %s: "
-                                  "failed: %s", cmd_str, rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume remove-brick %s: "
-                                  "failed", cmd_str);
+            cmd_str = "unknown";
+            break;
+    }
+
+    ret = rsp.op_ret;
+    if (rsp.op_ret == -1) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg), "volume remove-brick %s: failed: %s",
+                     cmd_str, rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg), "volume remove-brick %s: failed",
+                     cmd_str);
 
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-                cli_err ("%s", msg);
-                goto out;
-        }
+        cli_err("%s", msg);
+        goto out;
+    }
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        strncpy (msg, "failed to unserialize req-buffer to "
-                                 "dictionary", sizeof (msg));
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+        if (ret < 0) {
+            strncpy(msg, DICT_UNSERIALIZE_FAIL, sizeof(msg));
 
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                rsp.op_ret = -1;
-                                goto xml_output;
-                        }
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                rsp.op_ret = -1;
+                goto xml_output;
+            }
 
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR, "%s", msg);
+            goto out;
         }
+    }
 
 xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr,
-                                                               "volRemoveBrick");
-                } else {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               msg,
-                                                               "volRemoveBrick");
-                }
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (strcmp(rsp.op_errstr, "")) {
+            ret = cli_xml_output_vol_remove_brick(_gf_true, dict, rsp.op_ret,
+                                                  rsp.op_errno, rsp.op_errstr,
+                                                  "volRemoveBrick");
+        } else {
+            ret = cli_xml_output_vol_remove_brick(_gf_true, dict, rsp.op_ret,
+                                                  rsp.op_errno, msg,
+                                                  "volRemoveBrick");
+        }
+        goto out;
+    }
+
+    ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REMOVE_BRICK);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to print remove-brick rebalance status");
+        goto out;
+    }
+
+    if ((cmd == GF_OP_CMD_STOP) && (rsp.op_ret == 0)) {
+        cli_out(
+            "'remove-brick' process may be in the middle of a "
+            "file migration.\nThe process will be fully stopped "
+            "once the migration of the file is complete.\nPlease "
+            "check remove-brick process for completion before "
+            "doing any further brick related tasks on the "
+            "volume.");
+    }
+
+out:
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
+}
 
-        ret = gf_cli_print_rebalance_status (dict, GF_TASK_TYPE_REMOVE_BRICK,
-                                             _gf_false);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                        "rebalance status");
-                goto out;
-        }
+static int
+gf_cli_remove_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+    gf1_op_commands cmd = GF_OP_CMD_NONE;
+    char *cmd_str = "unknown";
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *task_id_str = NULL;
+    dict_t *rsp_dict = NULL;
 
-        if ((cmd == GF_OP_CMD_STOP) && (rsp.op_ret == 0)) {
-                cli_out ("'remove-brick' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check remove-brick process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
+    GF_ASSERT(myframe);
 
-out:
-        free (rsp.dict.dict_val); //malloced by xdr
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
-}
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
+    frame = myframe;
 
-int
-gf_cli_remove_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                      rsp   = {0,};
-        int                             ret   = -1;
-        char                            msg[1024] = {0,};
-        gf1_op_commands                 cmd = GF_OP_CMD_NONE;
-        char                           *cmd_str = "unknown";
-        cli_local_t                    *local = NULL;
-        call_frame_t                   *frame = NULL;
-        char                           *task_id_str = NULL;
-        dict_t                         *rsp_dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    GF_ASSERT(frame->local);
 
-        frame = myframe;
+    local = frame->local;
 
-        GF_ASSERT (frame->local);
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        local = frame->local;
+    ret = dict_get_int32_sizen(local->dict, "command", (int32_t *)&cmd);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "failed to get command");
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+    if (rsp.dict.dict_len) {
+        rsp_dict = dict_new();
+        if (!rsp_dict) {
+            ret = -1;
+            goto out;
         }
 
-        ret = dict_get_int32 (local->dict, "command", (int32_t *)&cmd);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret) {
-                 gf_log ("", GF_LOG_ERROR, "failed to get command");
-                 goto out;
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
+    }
 
-        if (rsp.dict.dict_len) {
-                rsp_dict = dict_new ();
-                if (!rsp_dict) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                        &rsp_dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to unserialize rsp_dict");
-                        goto out;
-                }
-        }
-
-        switch (cmd) {
+    switch (cmd) {
         case GF_OP_CMD_DETACH_START:
         case GF_OP_CMD_START:
-                cmd_str = "start";
-
-                ret = dict_get_str (rsp_dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "remove-brick-id is not present in dict");
-                }
-                break;
+            cmd_str = "start";
+
+            ret = dict_get_str_sizen(rsp_dict, GF_REMOVE_BRICK_TID_KEY,
+                                     &task_id_str);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "remove-brick-id is not present in dict");
+            }
+            break;
         case GF_OP_CMD_COMMIT:
-                cmd_str = "commit";
-                break;
+            cmd_str = "commit";
+            break;
         case GF_OP_CMD_COMMIT_FORCE:
-                cmd_str = "commit force";
-                break;
+            cmd_str = "commit force";
+            break;
         default:
-                cmd_str = "unknown";
-                break;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to remove brick");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Remove Brick %s %s", cmd_str,
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                       _gf_false, rsp_dict,
-                                                       rsp.op_ret, rsp.op_errno,
-                                                       msg, "volRemoveBrick");
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+            cmd_str = "unknown";
+            break;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to remove brick");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Remove Brick %s %s", cmd_str,
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_remove_brick(_gf_false, rsp_dict, rsp.op_ret,
+                                              rsp.op_errno, msg,
+                                              "volRemoveBrick");
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret) {
-                cli_err ("volume remove-brick %s: failed: %s", cmd_str,
-                         msg);
-        } else {
-                cli_out ("volume remove-brick %s: success", cmd_str);
-                if (GF_OP_CMD_START == cmd && task_id_str != NULL)
-                        cli_out ("ID: %s", task_id_str);
-                if (GF_OP_CMD_COMMIT == cmd)
-                        cli_out ("Check the removed bricks to ensure all files "
-                                 "are migrated.\nIf files with data are "
-                                 "found on the brick path, copy them via a "
-                                 "gluster mount point before re-purposing the "
-                                 "removed brick. ");
-        }
+    if (rsp.op_ret) {
+        cli_err("volume remove-brick %s: failed: %s", cmd_str, msg);
+    } else {
+        cli_out("volume remove-brick %s: success", cmd_str);
+        if (GF_OP_CMD_START == cmd && task_id_str != NULL)
+            cli_out("ID: %s", task_id_str);
+        if (GF_OP_CMD_COMMIT == cmd)
+            cli_out(
+                "Check the removed bricks to ensure all files "
+                "are migrated.\nIf files with data are "
+                "found on the brick path, copy them via a "
+                "gluster mount point before re-purposing the "
+                "removed brick. ");
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-        return ret;
-}
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-int
-gf_cli_reset_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
-{
-        gf_cli_rsp                       rsp              = {0,};
-        int                              ret              = -1;
-        cli_local_t                     *local            = NULL;
-        call_frame_t                    *frame            = NULL;
-        char                            *rb_operation_str = NULL;
-        dict_t                          *rsp_dict         = NULL;
-        char                             msg[1024]        = {0,};
-        char                            *reset_op         = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
+    return ret;
+}
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+static int
+gf_cli_reset_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    const char *rb_operation_str = NULL;
+    dict_t *rsp_dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *reset_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(local->dict, "operation", &reset_op);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict_get on operation failed");
+        goto out;
+    }
+
+    if (strcmp(reset_op, "GF_RESET_OP_START") &&
+        strcmp(reset_op, "GF_RESET_OP_COMMIT") &&
+        strcmp(reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
+        ret = -1;
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        rsp_dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_str (local->dict, "operation", &reset_op);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                rsp_dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &rsp_dict);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                                "unserialize rsp buffer to dictionary");
-                        goto out;
-                }
-        }
-
-        if (strcmp (reset_op, "GF_RESET_OP_START") &&
-            strcmp (reset_op, "GF_RESET_OP_COMMIT") &&
-            strcmp (reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
-                rb_operation_str = gf_strdup ("Unknown operation");
-                ret = -1;
-                goto out;
-        }
-
-        if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
-                rb_operation_str = gf_strdup (rsp.op_errstr);
-        } else {
-                if (!strcmp (reset_op, "GF_RESET_OP_START")) {
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "start "
-                                                              "operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "start "
-                                                              "operation "
-                                                              "successful");
-                } else if (!strcmp (reset_op, "GF_RESET_OP_COMMIT")) {
-
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "operation "
-                                                              "successful");
-                } else if (!strcmp (reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
-
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "force operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "force operation "
-                                                              "successful");
-                }
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to reset brick");
-        snprintf (msg, sizeof (msg), "%s",
-                  rb_operation_str ? rb_operation_str : "Unknown operation");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_replace_brick (rsp_dict,
-                                                        rsp.op_ret,
-                                                        rsp.op_errno, msg);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+            gf_log(frame->this->name, GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
+        }
+    }
+
+    if (rsp.op_ret && (strcmp(rsp.op_errstr, ""))) {
+        rb_operation_str = rsp.op_errstr;
+    } else {
+        if (!strcmp(reset_op, "GF_RESET_OP_START")) {
+            if (rsp.op_ret)
+                rb_operation_str = "reset-brick start operation failed";
+            else
+                rb_operation_str = "reset-brick start operation successful";
+        } else if (!strcmp(reset_op, "GF_RESET_OP_COMMIT")) {
+            if (rsp.op_ret)
+                rb_operation_str = "reset-brick commit operation failed";
+            else
+                rb_operation_str = "reset-brick commit operation successful";
+        } else if (!strcmp(reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
+            if (rsp.op_ret)
+                rb_operation_str = "reset-brick commit force operation failed";
+            else
+                rb_operation_str =
+                    "reset-brick commit force operation successful";
+        }
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to reset brick");
+    snprintf(msg, sizeof(msg), "%s",
+             rb_operation_str ? rb_operation_str : "Unknown operation");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_replace_brick(rsp_dict, rsp.op_ret,
+                                               rsp.op_errno, msg);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume reset-brick: failed: %s", msg);
-        else
-                cli_out ("volume reset-brick: success: %s", msg);
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume reset-brick: failed: %s", msg);
+    else
+        cli_out("volume reset-brick: success: %s", msg);
+    ret = rsp.op_ret;
 
 out:
-        if (frame)
-                frame->local = NULL;
-
-        if (local)
-                cli_local_wipe (local);
+    if (frame)
+        frame->local = NULL;
 
-        if (rb_operation_str)
-                GF_FREE (rb_operation_str);
+    if (local)
+        cli_local_wipe(local);
 
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
-int
-gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                       rsp              = {0,};
-        int                              ret              = -1;
-        cli_local_t                     *local            = NULL;
-        call_frame_t                    *frame            = NULL;
-        char                            *rb_operation_str = NULL;
-        dict_t                          *rsp_dict         = NULL;
-        char                             msg[1024]        = {0,};
-        char                            *replace_op       = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+static int
+gf_cli_replace_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    const char *rb_operation_str = NULL;
+    dict_t *rsp_dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *replace_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(local->dict, "operation", &replace_op);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict_get on operation failed");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        rsp_dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_str (local->dict, "operation", &replace_op);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                rsp_dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &rsp_dict);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                                "unserialize rsp buffer to dictionary");
-                        goto out;
-                }
-        }
-
-        if (!strcmp (replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
-
-                if (rsp.op_ret || ret)
-                        rb_operation_str = gf_strdup ("replace-brick commit "
-                                                      "force operation failed");
-                else
-                        rb_operation_str = gf_strdup ("replace-brick commit "
-                                                      "force operation "
-                                                      "successful");
-        } else {
-                gf_log (frame->this->name, GF_LOG_DEBUG, "Unknown operation");
-        }
-
-        if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
-                rb_operation_str = gf_strdup (rsp.op_errstr);
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to replace brick");
-        snprintf (msg, sizeof (msg), "%s",
-                  rb_operation_str ? rb_operation_str : "Unknown operation");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_replace_brick (rsp_dict,
-                                                        rsp.op_ret,
-                                                        rsp.op_errno, msg);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
+            gf_log(frame->this->name, GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume replace-brick: failed: %s", msg);
+    if (!strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
+        if (rsp.op_ret || ret)
+            rb_operation_str = "replace-brick commit force operation failed";
         else
-                cli_out ("volume replace-brick: success: %s", msg);
-        ret = rsp.op_ret;
+            rb_operation_str =
+                "replace-brick commit force operation successful";
+    } else {
+        gf_log(frame->this->name, GF_LOG_DEBUG, "Unknown operation");
+    }
+
+    if (rsp.op_ret && (strcmp(rsp.op_errstr, ""))) {
+        rb_operation_str = rsp.op_errstr;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to replace brick");
+    snprintf(msg, sizeof(msg), "%s",
+             rb_operation_str ? rb_operation_str : "Unknown operation");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_replace_brick(rsp_dict, rsp.op_ret,
+                                               rsp.op_errno, msg);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-out:
-        if (frame)
-                frame->local = NULL;
+    if (rsp.op_ret)
+        cli_err("volume replace-brick: failed: %s", msg);
+    else
+        cli_out("volume replace-brick: success: %s", msg);
+    ret = rsp.op_ret;
 
-        if (local)
-                cli_local_wipe (local);
+out:
+    if (frame)
+        frame->local = NULL;
 
-        if (rb_operation_str)
-                GF_FREE (rb_operation_str);
+    if (local)
+        cli_local_wipe(local);
 
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-gf_cli_log_rotate_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
-{
-        gf_cli_rsp             rsp   = {0,};
-        int                    ret   = -1;
-        char                   msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to log rotate");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "log rotate %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volLogRotate", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_log_rotate_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to log rotate");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "log rotate %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volLogRotate", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume log-rotate: failed: %s", msg);
-        else
-                cli_out ("volume log-rotate: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume log-rotate: failed: %s", msg);
+    else
+        cli_out("volume log-rotate: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_sync_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                           int count, void *myframe)
-{
-        gf_cli_rsp                     rsp   = {0,};
-        int                            ret   = -1;
-        char                           msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to sync");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "volume sync: failed: %s",
-                          rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "volume sync: %s",
-                          (rsp.op_ret) ? "failed": "success");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volSync", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_sync_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to sync");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "volume sync: failed: %s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "volume sync: %s",
+                 (rsp.op_ret) ? "failed" : "success");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volSync", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("%s", msg);
-        else
-                cli_out ("%s", msg);
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("%s", msg);
+    else
+        cli_out("%s", msg);
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
 static int
-print_quota_list_usage_output (cli_local_t *local, char *path, int64_t avail,
-                               char *sl_str, quota_limits_t *limits,
-                               quota_meta_t *used_space, gf_boolean_t sl,
-                               gf_boolean_t hl, double sl_num,
-                               gf_boolean_t limit_set)
-{
-        int32_t         ret          = -1;
-        char           *used_str     = NULL;
-        char           *avail_str    = NULL;
-        char           *hl_str       = NULL;
-        char           *sl_val       = NULL;
-
-        used_str = gf_uint64_2human_readable (used_space->size);
-
-        if (limit_set) {
-                hl_str = gf_uint64_2human_readable (limits->hl);
-                avail_str = gf_uint64_2human_readable (avail);
-
-                sl_val = gf_uint64_2human_readable (sl_num);
+print_quota_list_usage_output(cli_local_t *local, char *path, int64_t avail,
+                              char *sl_str, quota_limits_t *limits,
+                              quota_meta_t *used_space, gf_boolean_t sl,
+                              gf_boolean_t hl, double sl_num,
+                              gf_boolean_t limit_set)
+{
+    int32_t ret = -1;
+    char *used_str = NULL;
+    char *avail_str = NULL;
+    char *hl_str = NULL;
+    char *sl_val = NULL;
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_quota_xml_output(local, path, limits->hl, sl_str, sl_num,
+                                   used_space->size, avail, sl ? "Yes" : "No",
+                                   hl ? "Yes" : "No", limit_set);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to output in xml format for quota list command");
         }
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_quota_xml_output (local, path, limits->hl,
-                                            sl_str, sl_num, used_space->size,
-                                            avail, sl ? "Yes" : "No",
-                                            hl ? "Yes" : "No", limit_set);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "output in xml format for quota "
-                                "list command");
-                }
-                goto out;
-        }
+    used_str = gf_uint64_2human_readable(used_space->size);
 
-        if (limit_set) {
-                if (!used_str) {
-                        cli_out ("%-40s %7s %7s(%s) %8"PRIu64 "%9"PRIu64""
-                                 "%15s %18s", path, hl_str, sl_str, sl_val,
-                                 used_space->size, avail,
-                                 sl ? "Yes" : "No", hl ? "Yes" : "No");
-                } else {
-                        cli_out ("%-40s %7s %7s(%s) %8s %7s %15s %20s",
-                                 path, hl_str, sl_str, sl_val, used_str,
-                                 avail_str, sl ? "Yes" : "No",
-                                 hl ? "Yes" : "No");
-                }
+    if (limit_set) {
+        hl_str = gf_uint64_2human_readable(limits->hl);
+        sl_val = gf_uint64_2human_readable(sl_num);
+
+        if (!used_str) {
+            cli_out("%-40s %7s %7s(%s) %8" PRIu64 "%9" PRIu64
+                    ""
+                    "%15s %18s",
+                    path, hl_str, sl_str, sl_val, used_space->size, avail,
+                    sl ? "Yes" : "No", hl ? "Yes" : "No");
         } else {
-                        cli_out ("%-36s %10s %10s %14s %9s %15s %18s",
-                                 path, "N/A", "N/A", used_str, "N/A",
-                                 "N/A", "N/A");
+            avail_str = gf_uint64_2human_readable(avail);
+            cli_out("%-40s %7s %7s(%s) %8s %7s %15s %20s", path, hl_str, sl_str,
+                    sl_val, used_str, avail_str, sl ? "Yes" : "No",
+                    hl ? "Yes" : "No");
         }
+    } else {
+        cli_out("%-36s %10s %10s %14s %9s %15s %18s", path, "N/A", "N/A",
+                used_str, "N/A", "N/A", "N/A");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (hl_str);
-        GF_FREE (used_str);
-        GF_FREE (avail_str);
-        GF_FREE (sl_val);
+    GF_FREE(hl_str);
+    GF_FREE(used_str);
+    GF_FREE(avail_str);
+    GF_FREE(sl_val);
 
-        return ret;
+    return ret;
 }
 
 static int
-print_quota_list_object_output (cli_local_t *local, char *path, int64_t avail,
+print_quota_list_object_output(cli_local_t *local, char *path, int64_t avail,
                                char *sl_str, quota_limits_t *limits,
                                quota_meta_t *used_space, gf_boolean_t sl,
                                gf_boolean_t hl, double sl_num,
                                gf_boolean_t limit_set)
 {
-        int32_t         ret       = -1;
-        int64_t         sl_val    = sl_num;
+    int32_t ret = -1;
+    int64_t sl_val = sl_num;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_quota_object_xml_output (local, path, sl_str, sl_val,
-                                                   limits, used_space, avail,
-                                                   sl ? "Yes" : "No",
-                                                   hl ? "Yes" : "No",
-                                                   limit_set);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "output in xml format for quota "
-                                "list command");
-                }
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_quota_object_xml_output(local, path, sl_str, sl_val, limits,
+                                          used_space, avail, sl ? "Yes" : "No",
+                                          hl ? "Yes" : "No", limit_set);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to output in xml format for quota list command");
         }
+        goto out;
+    }
 
-        if (limit_set) {
-                cli_out ("%-40s %9"PRIu64" %9s(%"PRId64") %10"PRIu64""
-                         "%10"PRIu64" %11"PRIu64" %15s %20s",
-                         path, limits->hl, sl_str, sl_val,
-                         used_space->file_count, used_space->dir_count,
-                         avail, sl ? "Yes" : "No", hl ? "Yes" : "No");
-        } else {
-                cli_out ("%-40s %9s %9s %10"PRIu64" %10"PRIu64" %11s %15s %20s",
-                         path, "N/A", "N/A", used_space->file_count,
-                         used_space->dir_count, "N/A", "N/A", "N/A");
-        }
-        ret = 0;
+    if (limit_set) {
+        cli_out("%-40s %9" PRIu64 " %9s(%" PRId64 ") %10" PRIu64
+                ""
+                "%10" PRIu64 " %11" PRIu64 " %15s %20s",
+                path, limits->hl, sl_str, sl_val, used_space->file_count,
+                used_space->dir_count, avail, sl ? "Yes" : "No",
+                hl ? "Yes" : "No");
+    } else {
+        cli_out("%-40s %9s %9s %10" PRIu64 " %10" PRIu64 " %11s %15s %20s",
+                path, "N/A", "N/A", used_space->file_count,
+                used_space->dir_count, "N/A", "N/A", "N/A");
+    }
+    ret = 0;
 
 out:
 
-        return ret;
+    return ret;
 }
 
 static int
-print_quota_list_output (cli_local_t *local, char *path, char *default_sl,
-                         quota_limits_t *limits, quota_meta_t *used_space,
-                         int type, gf_boolean_t limit_set)
-{
-        int64_t         avail            = 0;
-        char            percent_str[20]  = {0};
-        char           *sl_final         = NULL;
-        int             ret              = -1;
-        double          sl_num           = 0;
-        gf_boolean_t    sl               = _gf_false;
-        gf_boolean_t    hl               = _gf_false;
-        int64_t         used_size        = 0;
-
-        GF_ASSERT (local);
-        GF_ASSERT (path);
-
-        if (limit_set) {
-                if (limits->sl < 0) {
-                        ret = gf_string2percent (default_sl, &sl_num);
-                        sl_num = (sl_num * limits->hl) / 100;
-                        sl_final = default_sl;
-                } else {
-                        sl_num = (limits->sl * limits->hl) / 100;
-                        snprintf (percent_str, sizeof (percent_str), "%"PRIu64"%%",
-                                        limits->sl);
-                        sl_final = percent_str;
-                }
-                if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                        used_size = used_space->size;
-                else
-                        used_size = used_space->file_count + used_space->dir_count;
-
-                if (limits->hl > used_size) {
-                        avail = limits->hl - used_size;
-                        hl = _gf_false;
-                        if (used_size > sl_num)
-                                sl = _gf_true;
-                        else
-                                sl = _gf_false;
-                } else {
-                        avail = 0;
-                        hl = sl = _gf_true;
-                }
+print_quota_list_output(cli_local_t *local, char *path, char *default_sl,
+                        quota_limits_t *limits, quota_meta_t *used_space,
+                        int type, gf_boolean_t limit_set)
+{
+    int64_t avail = 0;
+    char percent_str[20] = {0};
+    char *sl_final = NULL;
+    int ret = -1;
+    double sl_num = 0;
+    gf_boolean_t sl = _gf_false;
+    gf_boolean_t hl = _gf_false;
+    int64_t used_size = 0;
+
+    GF_ASSERT(local);
+    GF_ASSERT(path);
+
+    if (limit_set) {
+        if (limits->sl < 0) {
+            ret = gf_string2percent(default_sl, &sl_num);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "could not convert default soft limit to percent");
+                goto out;
+            }
+            sl_num = (sl_num * limits->hl) / 100;
+            sl_final = default_sl;
+        } else {
+            sl_num = (limits->sl * limits->hl) / 100;
+            ret = snprintf(percent_str, sizeof(percent_str), "%" PRIu64 "%%",
+                           limits->sl);
+            if (ret < 0)
+                goto out;
+            sl_final = percent_str;
         }
-
         if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                ret = print_quota_list_usage_output (local, path, avail,
-                                                     sl_final, limits,
-                                                     used_space, sl, hl,
-                                                     sl_num, limit_set);
+            used_size = used_space->size;
         else
-                ret = print_quota_list_object_output (local, path, avail,
-                                                      sl_final, limits,
-                                                      used_space, sl, hl,
-                                                      sl_num, limit_set);
+            used_size = used_space->file_count + used_space->dir_count;
+
+        if (limits->hl > used_size) {
+            avail = limits->hl - used_size;
+            hl = _gf_false;
+            if (used_size > sl_num)
+                sl = _gf_true;
+            else
+                sl = _gf_false;
+        } else {
+            avail = 0;
+            hl = sl = _gf_true;
+        }
+    }
 
-        return ret;
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        ret = print_quota_list_usage_output(local, path, avail, sl_final,
+                                            limits, used_space, sl, hl, sl_num,
+                                            limit_set);
+    else
+        ret = print_quota_list_object_output(local, path, avail, sl_final,
+                                             limits, used_space, sl, hl, sl_num,
+                                             limit_set);
+out:
+    return ret;
 }
 
 static int
-print_quota_list_from_mountdir (cli_local_t *local, char *mountdir,
-                                char *default_sl, char *path, int type)
-{
-        int             ret              = -1;
-        ssize_t         xattr_size       = 0;
-        quota_limits_t  limits           = {0,};
-        quota_meta_t    used_space       = {0,};
-        char           *key              = NULL;
-        gf_boolean_t    limit_set        = _gf_true;
-
-        GF_ASSERT (local);
-        GF_ASSERT (mountdir);
-        GF_ASSERT (path);
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                key = QUOTA_LIMIT_KEY;
-        else
-                key = QUOTA_LIMIT_OBJECTS_KEY;
-
-
-        ret = sys_lgetxattr (mountdir, key, (void *)&limits, sizeof (limits));
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get the xattr %s "
-                        "on %s. Reason : %s", key, mountdir, strerror (errno));
-
-                switch (errno) {
+print_quota_list_from_mountdir(cli_local_t *local, char *mountdir,
+                               char *default_sl, char *path, int type)
+{
+    int ret = -1;
+    ssize_t xattr_size = 0;
+    quota_limits_t limits = {
+        0,
+    };
+    quota_meta_t used_space = {
+        0,
+    };
+    char *key = NULL;
+    gf_boolean_t limit_set = _gf_true;
+
+    GF_ASSERT(local);
+    GF_ASSERT(mountdir);
+    GF_ASSERT(path);
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        key = QUOTA_LIMIT_KEY;
+    else
+        key = QUOTA_LIMIT_OBJECTS_KEY;
+
+    ret = sys_lgetxattr(mountdir, key, (void *)&limits, sizeof(limits));
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get the xattr %s on %s. Reason : %s", key, mountdir,
+               strerror(errno));
+
+        switch (errno) {
 #if defined(ENODATA)
-                case ENODATA:
+            case ENODATA:
 #endif
 #if defined(ENOATTR) && (ENOATTR != ENODATA)
-                case ENOATTR:
+            case ENOATTR:
 #endif
-                        /* If it's an ENOATTR, quota/inode-quota is
-                         * configured(limit is set atleast for one directory).
-                         * The user is trying to issue 'list/list-objects'
-                         * command for a directory on which quota limit is
-                         * not set and we are showing the used-space in case
-                         * of list-usage and showing (dir_count, file_count)
-                         * in case of list-objects. Other labels are
-                         * shown "N/A".
-                         */
-
-                        limit_set = _gf_false;
-                        goto enoattr;
-                        break;
-
-                default:
-                        cli_err ("%-40s %s", path, strerror (errno));
-                        break;
-                }
+                /* If it's an ENOATTR, quota/inode-quota is
+                 * configured(limit is set at least for one directory).
+                 * The user is trying to issue 'list/list-objects'
+                 * command for a directory on which quota limit is
+                 * not set and we are showing the used-space in case
+                 * of list-usage and showing (dir_count, file_count)
+                 * in case of list-objects. Other labels are
+                 * shown "N/A".
+                 */
 
-                goto out;
+                limit_set = _gf_false;
+                goto enoattr;
+                break;
+
+            default:
+                cli_err("%-40s %s", path, strerror(errno));
+                break;
         }
 
-        limits.hl = ntoh64 (limits.hl);
-        limits.sl = ntoh64 (limits.sl);
+        goto out;
+    }
+
+    limits.hl = ntoh64(limits.hl);
+    limits.sl = ntoh64(limits.sl);
 
 enoattr:
-        xattr_size = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY, NULL, 0);
-        if (xattr_size < (sizeof (int64_t) * 2) &&
-            type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS) {
-                ret = -1;
+    xattr_size = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, NULL, 0);
+    if (xattr_size < (sizeof(int64_t) * 2) &&
+        type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS) {
+        ret = -1;
 
-                /* This can happen when glusterfs is upgraded from 3.6 to 3.7
-                 * and the xattr healing is not completed.
-                 */
-        } else if (xattr_size > (sizeof (int64_t) * 2)) {
-                ret = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY,
-                                     &used_space, sizeof (used_space));
-        } else if (xattr_size > 0) {
-                /* This is for compatibility.
-                 * Older version had only file usage
-                 */
-                ret = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY,
-                             &(used_space.size), sizeof (used_space.size));
-                used_space.file_count = 0;
-                used_space.dir_count = 0;
-        } else {
-                ret = -1;
-        }
+        /* This can happen when glusterfs is upgraded from 3.6 to 3.7
+         * and the xattr healing is not completed.
+         */
+    } else if (xattr_size > (sizeof(int64_t) * 2)) {
+        ret = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, &used_space,
+                            sizeof(used_space));
+    } else if (xattr_size > 0) {
+        /* This is for compatibility.
+         * Older version had only file usage
+         */
+        ret = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, &(used_space.size),
+                            sizeof(used_space.size));
+        used_space.file_count = 0;
+        used_space.dir_count = 0;
+    } else {
+        ret = -1;
+    }
 
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota size "
-                        "on path %s: %s", mountdir, strerror (errno));
-                print_quota_list_empty (path, type);
-                goto out;
-        }
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get quota size on path %s: %s",
+               mountdir, strerror(errno));
+        print_quota_list_empty(path, type);
+        goto out;
+    }
 
-        used_space.size = ntoh64 (used_space.size);
-        used_space.file_count = ntoh64 (used_space.file_count);
-        used_space.dir_count = ntoh64 (used_space.dir_count);
+    used_space.size = ntoh64(used_space.size);
+    used_space.file_count = ntoh64(used_space.file_count);
+    used_space.dir_count = ntoh64(used_space.dir_count);
 
-        ret = print_quota_list_output (local, path, default_sl, &limits,
-                                       &used_space, type, limit_set);
+    ret = print_quota_list_output(local, path, default_sl, &limits, &used_space,
+                                  type, limit_set);
 out:
-        return ret;
+    return ret;
 }
 
-int
-gluster_remove_auxiliary_mount (char *volname)
+static int
+gluster_remove_auxiliary_mount(char *volname)
 {
-        int       ret                = -1;
-        char      mountdir[PATH_MAX] = {0,};
-        xlator_t  *this               = NULL;
+    int ret = -1;
+    char mountdir[PATH_MAX] = {
+        0,
+    };
+    xlator_t *this = NULL;
 
-        this = THIS;
-        GF_ASSERT (this);
+    this = THIS;
+    GF_ASSERT(this);
 
-        GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH (mountdir, volname, "/");
-        ret = gf_umount_lazy (this->name, mountdir, 1);
-        if (ret) {
-                gf_log("cli", GF_LOG_ERROR, "umount on %s failed, "
-                        "reason : %s", mountdir, strerror (errno));
-        }
+    GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(mountdir, volname, "/");
+    ret = gf_umount_lazy(this->name, mountdir, 1);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "umount on %s failed, reason : %s",
+               mountdir, strerror(errno));
+    }
 
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_print_limit_list_from_dict (cli_local_t *local, char *volname,
-                                   dict_t *dict, char *default_sl, int count,
-                                   int op_ret, int op_errno, char *op_errstr)
-{
-        int             ret                     = -1;
-        int             i                       = 0;
-        char            key[1024]               = {0,};
-        char            mountdir[PATH_MAX]      = {0,};
-        char            *path                   = NULL;
-        gf_boolean_t    xml_err_flag            = _gf_false;
-        char            err_str[NAME_MAX]       = {0,};
-        int             type                    = -1;
-
-        if (!dict|| count <= 0)
-                goto out;
-
-        ret = dict_get_int32 (dict, "type", &type);
+static int
+gf_cli_print_limit_list_from_dict(cli_local_t *local, char *volname,
+                                  dict_t *dict, char *default_sl, int count,
+                                  int op_ret, int op_errno, char *op_errstr)
+{
+    int ret = -1;
+    int i = 0;
+    char key[32] = {
+        0,
+    };
+    int keylen;
+    char mountdir[PATH_MAX] = {
+        0,
+    };
+    char *path = NULL;
+    int type = -1;
+
+    if (!dict || count <= 0)
+        goto out;
+
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get quota type");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_quota_limit_list_begin(local, op_ret, op_errno,
+                                                        op_errstr);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota type");
-                goto out;
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_quota_limit_list_begin
-                                (local, op_ret, op_errno, op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting xml begin");
-                        goto out;
-                }
-        } else {
-                print_quota_list_header (type);
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            goto out;
         }
+    } else {
+        print_quota_list_header(type);
+    }
 
-        while (count--) {
-                snprintf (key, sizeof (key), "path%d", i++);
-
-                ret = dict_get_str (dict, key, &path);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_DEBUG, "Path not present in limit"
-                                " list");
-                        continue;
-                }
+    while (count--) {
+        keylen = snprintf(key, sizeof(key), "path%d", i++);
 
-                ret = gf_canonicalize_path (path);
-                if (ret)
-                        goto out;
-                GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH (mountdir, volname, path);
-                ret = print_quota_list_from_mountdir (local, mountdir,
-                                                      default_sl, path, type);
+        ret = dict_get_strn(dict, key, keylen, &path);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_DEBUG, "Path not present in limit list");
+            continue;
         }
 
+        ret = gf_canonicalize_path(path);
+        if (ret)
+            goto out;
+        GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(mountdir, volname, path);
+        ret = print_quota_list_from_mountdir(local, mountdir, default_sl, path,
+                                             type);
+    }
+
 out:
-        if (xml_err_flag) {
-                ret = cli_xml_output_str ("volQuota", NULL, -1, 0, err_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting in xml "
-                                "format");
-                }
-        }
-        return ret;
+    return ret;
 }
 
-int
-print_quota_list_from_quotad (call_frame_t *frame, dict_t *rsp_dict)
-{
-        char             *path          = NULL;
-        char             *default_sl    = NULL;
-        int              ret            = -1;
-        cli_local_t     *local          = NULL;
-        dict_t          *gd_rsp_dict    = NULL;
-        quota_meta_t     used_space     = {0, };
-        quota_limits_t   limits         = {0, };
-        quota_limits_t  *size_limits    = NULL;
-        int32_t          type           = 0;
-        int32_t          success_count  = 0;
-
-        GF_ASSERT (frame);
-
-        local = frame->local;
-        gd_rsp_dict = local->dict;
-
-        ret = dict_get_int32 (rsp_dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get type");
-                goto out;
-        }
-
-        ret = dict_get_str (rsp_dict, GET_ANCESTRY_PATH_KEY, &path);
+static int
+print_quota_list_from_quotad(call_frame_t *frame, dict_t *rsp_dict)
+{
+    char *path = NULL;
+    char *default_sl = NULL;
+    int ret = -1;
+    cli_local_t *local = NULL;
+    dict_t *gd_rsp_dict = NULL;
+    quota_meta_t used_space = {
+        0,
+    };
+    quota_limits_t limits = {
+        0,
+    };
+    quota_limits_t *size_limits = NULL;
+    int32_t type = 0;
+    int32_t success_count = 0;
+
+    GF_ASSERT(frame);
+
+    local = frame->local;
+    gd_rsp_dict = local->dict;
+
+    ret = dict_get_int32_sizen(rsp_dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get type");
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(rsp_dict, GET_ANCESTRY_PATH_KEY, &path);
+    if (ret) {
+        gf_log("cli", GF_LOG_WARNING, "path key is not present in dict");
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(gd_rsp_dict, "default-soft-limit", &default_sl);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get default soft limit");
+        goto out;
+    }
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST) {
+        ret = dict_get_bin(rsp_dict, QUOTA_LIMIT_KEY, (void **)&size_limits);
         if (ret) {
-                gf_log ("cli", GF_LOG_WARNING, "path key is not present "
-                        "in dict");
-                goto out;
+            gf_log("cli", GF_LOG_WARNING, "limit key not present in dict on %s",
+                   path);
+            goto out;
         }
-
-        ret = dict_get_str (gd_rsp_dict, "default-soft-limit", &default_sl);
+    } else {
+        ret = dict_get_bin(rsp_dict, QUOTA_LIMIT_OBJECTS_KEY,
+                           (void **)&size_limits);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                        "get default soft limit");
-                goto out;
-        }
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST) {
-                ret = dict_get_bin (rsp_dict, QUOTA_LIMIT_KEY,
-                                    (void **)&size_limits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "limit key not present in dict on %s",
-                                path);
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_WARNING,
+                   "object limit key not present in dict on %s", path);
+            goto out;
+        }
+    }
+
+    limits.hl = ntoh64(size_limits->hl);
+    limits.sl = ntoh64(size_limits->sl);
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        ret = quota_dict_get_meta(rsp_dict, QUOTA_SIZE_KEY,
+                                  SLEN(QUOTA_SIZE_KEY), &used_space);
+    else
+        ret = quota_dict_get_inode_meta(rsp_dict, QUOTA_SIZE_KEY,
+                                        SLEN(QUOTA_SIZE_KEY), &used_space);
+
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_WARNING, "size key not present in dict");
+        print_quota_list_empty(path, type);
+        goto out;
+    }
+
+    LOCK(&local->lock);
+    {
+        ret = dict_get_int32_sizen(gd_rsp_dict, "quota-list-success-count",
+                                   &success_count);
+        if (ret)
+            success_count = 0;
+
+        ret = dict_set_int32_sizen(gd_rsp_dict, "quota-list-success-count",
+                                   success_count + 1);
+    }
+    UNLOCK(&local->lock);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to set quota-list-success-count in dict");
+        goto out;
+    }
+
+    if (success_count == 0) {
+        if (!(global_state->mode & GLUSTER_MODE_XML)) {
+            print_quota_list_header(type);
         } else {
-                ret = dict_get_bin (rsp_dict, QUOTA_LIMIT_OBJECTS_KEY,
-                                   (void **)&size_limits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "object limit key not present in dict on %s",
-                                path);
-                        goto out;
-                }
-        }
-
-        limits.hl = ntoh64 (size_limits->hl);
-        limits.sl = ntoh64 (size_limits->sl);
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                ret = quota_dict_get_meta (rsp_dict, QUOTA_SIZE_KEY,
-                                           &used_space);
-        else
-                ret = quota_dict_get_inode_meta (rsp_dict, QUOTA_SIZE_KEY,
-                                                 &used_space);
-
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_WARNING,
-                        "size key not present in dict");
-                print_quota_list_empty (path, type);
-                goto out;
-        }
-
-        LOCK (&local->lock);
-        {
-                ret = dict_get_int32 (gd_rsp_dict, "quota-list-success-count",
-                                      &success_count);
-                if (ret)
-                        success_count = 0;
-
-                ret = dict_set_int32 (gd_rsp_dict,
-                                      "quota-list-success-count",
-                                      success_count + 1);
-        }
-        UNLOCK (&local->lock);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                        "quota-list-success-count in dict");
+            ret = cli_xml_output_vol_quota_limit_list_begin(local, 0, 0, NULL);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
                 goto out;
+            }
         }
+    }
 
-        if (success_count == 0) {
-                if (!(global_state->mode & GLUSTER_MODE_XML)) {
-                        print_quota_list_header (type);
-                } else {
-                        ret = cli_xml_output_vol_quota_limit_list_begin
-                                (local, 0, 0, NULL);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Error in "
-                                        "printing xml output");
-                                goto out;
-                        }
-                }
-        }
-
-        ret = print_quota_list_output (local, path, default_sl, &limits,
-                                       &used_space, type, _gf_true);
+    ret = print_quota_list_output(local, path, default_sl, &limits, &used_space,
+                                  type, _gf_true);
 out:
-        return ret;
+    return ret;
 }
 
-void*
-cli_cmd_broadcast_response_detached (void *opaque)
+static void *
+cli_cmd_broadcast_response_detached(void *opaque)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        ret = (intptr_t) opaque;
-        cli_cmd_broadcast_response (ret);
+    ret = (intptr_t)opaque;
+    cli_cmd_broadcast_response(ret);
 
-        return NULL;
+    return NULL;
 }
 
-int32_t
-cli_quota_compare_path (struct list_head *list1,
-                        struct list_head *list2)
+static int32_t
+cli_quota_compare_path(struct list_head *list1, struct list_head *list2)
 {
-        struct list_node  *node1  = NULL;
-        struct list_node  *node2  = NULL;
-        dict_t            *dict1  = NULL;
-        dict_t            *dict2  = NULL;
-        char              *path1  = NULL;
-        char              *path2  = NULL;
-        int                ret    = 0;
+    struct list_node *node1 = NULL;
+    struct list_node *node2 = NULL;
+    dict_t *dict1 = NULL;
+    dict_t *dict2 = NULL;
+    char *path1 = NULL;
+    char *path2 = NULL;
+    int ret = 0;
 
-        node1 = list_entry (list1, struct list_node, list);
-        node2 = list_entry (list2, struct list_node, list);
+    node1 = list_entry(list1, struct list_node, list);
+    node2 = list_entry(list2, struct list_node, list);
 
-        dict1 = node1->ptr;
-        dict2 = node2->ptr;
+    dict1 = node1->ptr;
+    dict2 = node2->ptr;
 
-        ret = dict_get_str (dict1, GET_ANCESTRY_PATH_KEY, &path1);
-        if (ret < 0)
-                return 0;
+    ret = dict_get_str_sizen(dict1, GET_ANCESTRY_PATH_KEY, &path1);
+    if (ret < 0)
+        return 0;
 
-        ret = dict_get_str (dict2, GET_ANCESTRY_PATH_KEY, &path2);
-        if (ret < 0)
-                return 0;
+    ret = dict_get_str_sizen(dict2, GET_ANCESTRY_PATH_KEY, &path2);
+    if (ret < 0)
+        return 0;
 
-        return strcmp (path1, path2);
+    return strcmp(path1, path2);
 }
 
-int
-cli_quotad_getlimit_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
+static int
+cli_quotad_getlimit_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
     /*TODO: we need to gather the path, hard-limit, soft-limit and used space*/
-        gf_cli_rsp         rsp         = {0,};
-        int                ret         = -1;
-        dict_t            *dict        = NULL;
-        struct list_node  *node        = NULL;
-        struct list_node  *tmpnode     = NULL;
-        call_frame_t      *frame       = NULL;
-        cli_local_t       *local       = NULL;
-        int32_t            list_count  = 0;
-        pthread_t          th_id       = {0, };
-        int32_t            max_count   = 0;
-
-        GF_ASSERT (myframe);
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        LOCK (&local->lock);
-        {
-                ret = dict_get_int32 (local->dict, "quota-list-count",
-                                      &list_count);
-                if (ret)
-                        list_count = 0;
-
-                list_count++;
-                ret = dict_set_int32 (local->dict, "quota-list-count",
-                                      list_count);
-        }
-        UNLOCK (&local->lock);
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                        "quota-list-count in dict");
-                goto out;
-        }
-
-        if (-1 == req->rpc_status) {
-                if (list_count == 0)
-                        cli_err ("Connection failed. Please check if quota "
-                                 "daemon is operational.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                ret = -1;
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("quota command failed : %s", rsp.op_errstr);
-                else
-                        cli_err ("quota command : failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
-
-                node = list_node_add_order (dict, &local->dict_list,
-                                            cli_quota_compare_path);
-                if (node == NULL) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to add node to the list");
-                        dict_unref (dict);
-                        goto out;
-                }
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    struct list_node *node = NULL;
+    struct list_node *tmpnode = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    int32_t list_count = 0;
+    pthread_t th_id = {
+        0,
+    };
+    int32_t max_count = 0;
+
+    GF_ASSERT(myframe);
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    LOCK(&local->lock);
+    {
+        ret = dict_get_int32_sizen(local->dict, "quota-list-count",
+                                   &list_count);
+        if (ret)
+            list_count = 0;
+
+        list_count++;
+        ret = dict_set_int32_sizen(local->dict, "quota-list-count", list_count);
+    }
+    UNLOCK(&local->lock);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set quota-list-count in dict");
+        goto out;
+    }
+
+    if (-1 == req->rpc_status) {
+        if (list_count == 0)
+            cli_err(
+                "Connection failed. Please check if quota "
+                "daemon is operational.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("quota command failed : %s", rsp.op_errstr);
+        else
+            cli_err("quota command : failed");
+        goto out;
+    }
 
-       }
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-        ret = dict_get_int32 (local->dict, "max_count",
-                              &max_count);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "failed to get max_count");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
 
-        if (list_count == max_count) {
-                list_for_each_entry_safe (node, tmpnode,
-                                          &local->dict_list, list) {
-                        dict = node->ptr;
-                        print_quota_list_from_quotad (frame, dict);
-                        list_node_del (node);
-                        dict_unref (dict);
-                }
+        node = list_node_add_order(dict, &local->dict_list,
+                                   cli_quota_compare_path);
+        if (node == NULL) {
+            gf_log("cli", GF_LOG_ERROR, "failed to add node to the list");
+            dict_unref(dict);
+            ret = -1;
+            goto out;
         }
+    }
 
+    ret = dict_get_int32_sizen(local->dict, "max_count", &max_count);
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR, "failed to get max_count");
+        goto out;
+    }
 
+    if (list_count == max_count) {
+        list_for_each_entry_safe(node, tmpnode, &local->dict_list, list)
+        {
+            dict = node->ptr;
+            print_quota_list_from_quotad(frame, dict);
+            list_node_del(node);
+            dict_unref(dict);
+        }
+    }
+
+out:
+    /* Bad Fix: CLI holds the lock to process a command.
+     * When processing quota list command, below sequence of steps executed
+     * in the same thread and causing deadlock
+     *
+     * 1) CLI holds the lock
+     * 2) Send rpc_clnt_submit request to quotad for quota usage
+     * 3) If quotad is down, rpc_clnt_submit invokes cbk function with error
+     * 4) cbk function cli_quotad_getlimit_cbk invokes
+     *    cli_cmd_broadcast_response which tries to hold lock to broadcast
+     *    the results and hangs, because same thread has already holding
+     *    the lock
+     *
+     * Broadcasting response in a separate thread which is not a
+     * good fix. This needs to be re-visted with better solution
+     */
+    if (ret == -1) {
+        ret = pthread_create(&th_id, NULL, cli_cmd_broadcast_response_detached,
+                             (void *)-1);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "pthread_create failed: %s",
+                   strerror(errno));
+    } else {
+        cli_cmd_broadcast_response(ret);
+    }
+    gf_free_xdr_cli_rsp(rsp);
 
-out:
-        /* Bad Fix: CLI holds the lock to process a command.
-         * When processing quota list command, below sequence of steps executed
-         * in the same thread and causing deadlock
-         *
-         * 1) CLI holds the lock
-         * 2) Send rpc_clnt_submit request to quotad for quota usage
-         * 3) If quotad is down, rpc_clnt_submit invokes cbk function with error
-         * 4) cbk function cli_quotad_getlimit_cbk invokes
-         *    cli_cmd_broadcast_response which tries to hold lock to broadcast
-         *    the results and hangs, because same thread has already holding
-         *    the lock
-         *
-         * Broadcasting response in a seperate thread which is not a
-         * good fix. This needs to be re-visted with better solution
-         */
-        if (ret == -1) {
-                ret = pthread_create (&th_id, NULL,
-                                cli_cmd_broadcast_response_detached,
-                                (void *)-1);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "pthread_create failed: "
-                                "%s", strerror (errno));
-        } else {
-                cli_cmd_broadcast_response (ret);
-        }
-
-        free (rsp.dict.dict_val);
-        return ret;
+    return ret;
 }
 
-int
-cli_quotad_getlimit (call_frame_t *frame, xlator_t *this, void *data)
+static int
+cli_quotad_getlimit(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req          req = {{0,}};
-        int                 ret = 0;
-        dict_t             *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to serialize the data");
+    dict = data;
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, DICT_SERIALIZE_FAIL);
+
+        goto out;
+    }
 
-        ret = cli_cmd_submit (global_quotad_rpc, &req, frame, &cli_quotad_clnt,
-                              GF_AGGREGATOR_GETLIMIT, NULL,
-                              this, cli_quotad_getlimit_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(global_quotad_rpc, &req, frame, &cli_quotad_clnt,
+                         GF_AGGREGATOR_GETLIMIT, NULL, this,
+                         cli_quotad_getlimit_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-void
-gf_cli_quota_list (cli_local_t *local, char *volname, dict_t *dict,
-                   char *default_sl, int count, int op_ret,
-                   int op_errno, char *op_errstr)
+static void
+gf_cli_quota_list(cli_local_t *local, char *volname, dict_t *dict,
+                  char *default_sl, int count, int op_ret, int op_errno,
+                  char *op_errstr)
 {
-        GF_VALIDATE_OR_GOTO ("cli", volname, out);
+    if (!cli_cmd_connected())
+        goto out;
 
-        if (!connected)
-                goto out;
+    if (count > 0) {
+        GF_VALIDATE_OR_GOTO("cli", volname, out);
 
-        if (count > 0)
-                gf_cli_print_limit_list_from_dict (local, volname, dict,
-                                                   default_sl, count, op_ret,
-                                                   op_errno, op_errstr);
+        gf_cli_print_limit_list_from_dict(local, volname, dict, default_sl,
+                                          count, op_ret, op_errno, op_errstr);
+    }
 out:
-        return;
+    return;
 }
 
-int
-gf_cli_quota_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        gf_cli_rsp         rsp         = {0,};
-        int                ret         = -1;
-        dict_t            *dict        = NULL;
-        char              *volname     = NULL;
-        int32_t            type        = 0;
-        call_frame_t      *frame       = NULL;
-        char              *default_sl  = NULL;
-        cli_local_t       *local       = NULL;
-        char              *default_sl_dup  = NULL;
-        int32_t            entry_count      = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+static int
+gf_cli_quota_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int32_t type = 0;
+    call_frame_t *frame = NULL;
+    char *default_sl = NULL;
+    cli_local_t *local = NULL;
+    char *default_sl_dup = NULL;
+    int32_t entry_count = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-        frame = myframe;
+        if (strcmp(rsp.op_errstr, "")) {
+            cli_err("quota command failed : %s", rsp.op_errstr);
+            if (rsp.op_ret == -ENOENT)
+                cli_err("please enter the path relative to the volume");
+        } else {
+            cli_err("quota command : failed");
+        }
 
-        GF_ASSERT (frame->local);
+        goto out;
+    }
 
-        local = frame->local;
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
+    }
 
-        if (rsp.op_ret) {
-                ret = -1;
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-
-                if (strcmp (rsp.op_errstr, "")) {
-                        cli_err ("quota command failed : %s", rsp.op_errstr);
-                        if (rsp.op_ret == -ENOENT)
-                                cli_err ("please enter the path relative to "
-                                         "the volume");
-                } else {
-                        cli_err ("quota command : failed");
-                }
-
-                goto out;
-        }
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to quota command");
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
+    ret = dict_get_str_sizen(dict, "default-soft-limit", &default_sl);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE,
+               "failed to get default soft limit");
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
+    // default-soft-limit is part of rsp_dict only iff we sent
+    // GLUSTER_CLI_QUOTA with type being GF_QUOTA_OPTION_TYPE_LIST
+    if (default_sl) {
+        default_sl_dup = gf_strdup(default_sl);
+        if (!default_sl_dup) {
+            ret = -1;
+            goto out;
         }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to quota command");
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get volname");
-
-        ret = dict_get_str (dict, "default-soft-limit", &default_sl);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE, "failed to get "
-                        "default soft limit");
-
-        // default-soft-limit is part of rsp_dict only iff we sent
-        // GLUSTER_CLI_QUOTA with type being GF_QUOTA_OPTION_TYPE_LIST
-        if (default_sl) {
-                default_sl_dup = gf_strdup (default_sl);
-                if (!default_sl_dup) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_dynstr (local->dict, "default-soft-limit",
-                                       default_sl_dup);
-                if (ret) {
-                        gf_log (frame->this->name, GF_LOG_TRACE,
-                                "failed to set default soft limit");
-                        GF_FREE (default_sl_dup);
-                }
+        ret = dict_set_dynstr_sizen(local->dict, "default-soft-limit",
+                                    default_sl_dup);
+        if (ret) {
+            gf_log(frame->this->name, GF_LOG_TRACE,
+                   "failed to set default soft limit");
+            GF_FREE(default_sl_dup);
         }
+    }
 
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE,
-                        "failed to get type");
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get volname");
 
-        ret = dict_get_int32 (dict, "count", &entry_count);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE, "failed to get count");
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE, "failed to get type");
 
-        if ((type == GF_QUOTA_OPTION_TYPE_LIST)
-            || (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
-                gf_cli_quota_list (local, volname, dict, default_sl,
-                                   entry_count, rsp.op_ret,
-                                   rsp.op_errno, rsp.op_errstr);
+    ret = dict_get_int32_sizen(dict, "count", &entry_count);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE, "failed to get count");
 
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_vol_quota_limit_list_end (local);
-                        if (ret < 0) {
-                                ret = -1;
-                                gf_log ("cli", GF_LOG_ERROR, "Error in printing"
-                                       " xml output");
-                        }
-                        goto out;
-                }
+    if ((type == GF_QUOTA_OPTION_TYPE_LIST) ||
+        (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
+        gf_cli_quota_list(local, volname, dict, default_sl, entry_count,
+                          rsp.op_ret, rsp.op_errno, rsp.op_errstr);
+
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_vol_quota_limit_list_end(local);
+            if (ret < 0) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            }
+            goto out;
         }
+    }
 
 xml_output:
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volQuota", NULL, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volQuota", NULL, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (!rsp.op_ret && type != GF_QUOTA_OPTION_TYPE_LIST
-                        && type != GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)
-                cli_out ("volume quota : success");
+    if (!rsp.op_ret && type != GF_QUOTA_OPTION_TYPE_LIST &&
+        type != GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)
+        cli_out("volume quota : success");
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 out:
 
-        if ((type == GF_QUOTA_OPTION_TYPE_LIST)
-            || (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
-                gluster_remove_auxiliary_mount (volname);
-        }
+    if ((type == GF_QUOTA_OPTION_TYPE_LIST) ||
+        (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
+        gluster_remove_auxiliary_mount(volname);
+    }
 
-        cli_cmd_broadcast_response (ret);
-        if (dict)
-                dict_unref (dict);
+    cli_cmd_broadcast_response(ret);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
+    gf_free_xdr_cli_rsp(rsp);
 
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_getspec_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
+static int
+gf_cli_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
 {
-        gf_getspec_rsp          rsp   = {0,};
-        int                     ret   = -1;
-        char                   *spec  = NULL;
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *spec = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "getspec failed");
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "getspec failed");
+        ret = -1;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to getspec");
+    gf_log("cli", GF_LOG_INFO, "Received resp to getspec");
 
-        spec = GF_MALLOC (rsp.op_ret + 1, cli_mt_char);
-        if (!spec) {
-                gf_log("", GF_LOG_ERROR, "out of memory");
-                goto out;
-        }
-        memcpy (spec, rsp.spec, rsp.op_ret);
-        spec[rsp.op_ret] = '\0';
-        cli_out ("%s", spec);
-        GF_FREE (spec);
+    spec = GF_MALLOC(rsp.op_ret + 1, cli_mt_char);
+    if (!spec) {
+        gf_log("", GF_LOG_ERROR, "out of memory");
+        ret = -1;
+        goto out;
+    }
+    memcpy(spec, rsp.spec, rsp.op_ret);
+    spec[rsp.op_ret] = '\0';
+    cli_out("%s", spec);
+    GF_FREE(spec);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_getspec_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_pmap_b2p_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
+static int
+gf_cli_pmap_b2p_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
 {
-        pmap_port_by_brick_rsp rsp = {0,};
-        int                     ret   = -1;
-        char                   *spec  = NULL;
+    pmap_port_by_brick_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *spec = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_port_by_brick_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_port_by_brick_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "pump_b2p failed");
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "pump_b2p failed");
+        ret = -1;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to pmap b2p");
+    gf_log("cli", GF_LOG_INFO, "Received resp to pmap b2p");
 
-        cli_out ("%d", rsp.port);
-        GF_FREE (spec);
+    cli_out("%d", rsp.port);
+    GF_FREE(spec);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-
-int32_t
-gf_cli_probe (call_frame_t *frame, xlator_t *this,
-                 void *data)
+static int32_t
+gf_cli_probe(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req         req      = {{0,},};
-        int                ret      = 0;
-        dict_t            *dict     = NULL;
-        int                port     = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_int32 (dict, "port", &port);
-        if (ret) {
-                ret = dict_set_int32 (dict, "port", CLI_GLUSTERD_PORT);
-                if (ret)
-                        goto out;
-        }
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    int port = 0;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_int32_sizen(dict, "port", &port);
+    if (ret) {
+        ret = dict_set_int32_sizen(dict, "port", CLI_GLUSTERD_PORT);
+        if (ret)
+            goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_probe_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROBE, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_probe_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_PROBE,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_deprobe (call_frame_t *frame, xlator_t *this,
-                   void *data)
+static int32_t
+gf_cli_deprobe(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req           req      = {{0,},};
-        int                  ret      = 0;
-        dict_t              *dict     = NULL;
-        int                  port     = 0;
-        int                  flags    = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-        ret = dict_get_int32 (dict, "port", &port);
-        if (ret) {
-                ret = dict_set_int32 (dict, "port", CLI_GLUSTERD_PORT);
-                if (ret)
-                        goto out;
-        }
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    int port = 0;
+    int flags = 0;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+    ret = dict_get_int32_sizen(dict, "port", &port);
+    if (ret) {
+        ret = dict_set_int32_sizen(dict, "port", CLI_GLUSTERD_PORT);
+        if (ret)
+            goto out;
+    }
 
-        ret = dict_get_int32 (dict, "flags", &flags);
-        if (ret) {
-                ret = dict_set_int32 (dict, "flags", 0);
-                if (ret)
-                        goto out;
-        }
+    ret = dict_get_int32_sizen(dict, "flags", &flags);
+    if (ret) {
+        ret = dict_set_int32_sizen(dict, "flags", 0);
+        if (ret)
+            goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_deprobe_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                              GLUSTER_CLI_DEPROBE, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_deprobe_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_DEPROBE,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_list_friends (call_frame_t *frame, xlator_t *this,
-                     void *data)
+static int32_t
+gf_cli_list_friends(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_peer_list_req   req = {0,};
-        int                     ret = 0;
-        unsigned long           flags = 0;
+    gf1_cli_peer_list_req req = {
+        0,
+    };
+    int ret = 0;
+    unsigned long flags = 0;
 
-        if (!frame || !this) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this) {
+        ret = -1;
+        goto out;
+    }
 
-        GF_ASSERT (frame->local == NULL);
+    GF_ASSERT(frame->local == NULL);
 
-        flags = (long)data;
-        req.flags = flags;
-        frame->local = (void*)flags;
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_LIST_FRIENDS, NULL,
-                              this, gf_cli_list_friends_cbk,
-                              (xdrproc_t) xdr_gf1_cli_peer_list_req);
+    flags = (long)data;
+    req.flags = flags;
+    frame->local = (void *)flags;
+    ret = cli_cmd_submit(
+        NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_LIST_FRIENDS, NULL, this,
+        gf_cli_list_friends_cbk, (xdrproc_t)xdr_gf1_cli_peer_list_req);
 
 out:
-        if (ret) {
-                /*
-                 * If everything goes fine, gf_cli_list_friends_cbk()
-                 * [invoked through cli_cmd_submit()]resets the
-                 * frame->local to NULL. In case cli_cmd_submit()
-                 * fails in between, RESET frame->local here.
-                 */
-                frame->local = NULL;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (ret && frame) {
+        /*
+         * If everything goes fine, gf_cli_list_friends_cbk()
+         * [invoked through cli_cmd_submit()]resets the
+         * frame->local to NULL. In case cli_cmd_submit()
+         * fails in between, RESET frame->local here.
+         */
+        frame->local = NULL;
+    }
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int32_t
-gf_cli_get_state (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_get_state(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,},};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_get_state_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_GET_STATE, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    ret = cli_to_glusterd(&req, frame, gf_cli_get_state_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_GET_STATE, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_get_next_volume (call_frame_t *frame, xlator_t *this,
-                           void *data)
+static int32_t
+gf_cli_get_next_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
+    int ret = 0;
+    cli_cmd_volume_get_ctx_t *ctx = NULL;
+    cli_local_t *local = NULL;
 
-        int                             ret = 0;
-        cli_cmd_volume_get_ctx_t        *ctx = NULL;
-        cli_local_t                     *local = NULL;
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
-
-        ctx = data;
-        local = frame->local;
+    ctx = data;
+    local = frame->local;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_info_begin (local, 0, 0, "");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-                        goto out;
-                }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_info_begin(local, 0, 0, "");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            goto out;
         }
+    }
 
-        ret = gf_cli_get_volume (frame, this, data);
+    ret = gf_cli_get_volume(frame, this, data);
 
+    if (!local || !local->get_vol.volname) {
+        if ((global_state->mode & GLUSTER_MODE_XML))
+            goto end_xml;
 
-        if (!local || !local->get_vol.volname) {
-                if ((global_state->mode & GLUSTER_MODE_XML))
-                        goto end_xml;
-
-                cli_err ("No volumes present");
-                goto out;
-        }
+        cli_err("No volumes present");
+        goto out;
+    }
 
+    ctx->volname = local->get_vol.volname;
 
+    while (ctx->volname) {
+        ret = gf_cli_get_volume(frame, this, ctx);
+        if (ret)
+            goto out;
         ctx->volname = local->get_vol.volname;
-
-        while (ctx->volname) {
-                ret = gf_cli_get_volume (frame, this, ctx);
-                if (ret)
-                        goto out;
-                ctx->volname = local->get_vol.volname;
-        }
+    }
 
 end_xml:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_info_end (local);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_info_end(local);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int32_t
-gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
-                      void *data)
-{
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        cli_cmd_volume_get_ctx_t        *ctx = NULL;
-        dict_t                          *dict = NULL;
-        int32_t                         flags = 0;
-
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
-
-        ctx = data;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (ctx->volname) {
-                ret = dict_set_str (dict, "volname", ctx->volname);
-                if (ret)
-                        goto out;
-        }
+static int32_t
+gf_cli_get_volume(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    cli_cmd_volume_get_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+    int32_t flags = 0;
+
+    if (!this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    ctx = data;
+
+    dict = dict_new();
+    if (!dict) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to create the dict");
+        ret = -1;
+        goto out;
+    }
+
+    if (ctx->volname) {
+        ret = dict_set_str_sizen(dict, "volname", ctx->volname);
+        if (ret)
+            goto out;
+    }
 
-        flags = ctx->flags;
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to set flags");
-                goto out;
-        }
+    flags = ctx->flags;
+    ret = dict_set_int32_sizen(dict, "flags", flags);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to set flags");
+        goto out;
+    }
 
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, DICT_SERIALIZE_FAIL);
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_GET_VOLUME, NULL,
-                              this, gf_cli_get_volume_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_GET_VOLUME, NULL, this,
+                         gf_cli_get_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int32_t
-gf_cli3_1_uuid_get (call_frame_t *frame, xlator_t *this,
-                      void *data)
+static int32_t
+gf_cli3_1_uuid_get(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        dict_t                          *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-        ret = cli_to_glusterd (&req, frame, gf_cli3_1_uuid_get_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_UUID_GET, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    dict = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli3_1_uuid_get_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_UUID_GET,
+                          this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli3_1_uuid_reset (call_frame_t *frame, xlator_t *this,
-                      void *data)
+static int32_t
+gf_cli3_1_uuid_reset(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        dict_t                          *dict = NULL;
-
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
-        ret = cli_to_glusterd (&req, frame, gf_cli3_1_uuid_reset_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_UUID_RESET, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    dict = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli3_1_uuid_reset_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_UUID_RESET, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_create_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_create_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    dict = data;
 
-        dict = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli_create_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_create_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    GF_FREE(req.dict.dict_val);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_delete_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_delete_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_delete_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_DELETE_VOLUME, this, cli_rpc_prog,
-                               NULL);
-
-out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    ret = cli_to_glusterd(&req, frame, gf_cli_delete_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_DELETE_VOLUME, this, cli_rpc_prog, NULL);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_start_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_start_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_start_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_START_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_start_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_START_VOLUME, this, cli_rpc_prog, NULL);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_stop_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_stop_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req             req = {{0,}};
-        int                    ret = 0;
-        dict_t                 *dict = data;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = data;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_stop_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_STOP_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_stop_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_STOP_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_defrag_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_defrag_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req     =  {{0,}};
-        int                     ret     = 0;
-        dict_t                 *dict    = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_defrag_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_DEFRAG_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_defrag_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_DEFRAG_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_rename_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_rename_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to serialize the data");
-
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, DICT_SERIALIZE_FAIL);
 
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_RENAME_VOLUME, NULL,
-                              this, gf_cli_rename_volume_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_RENAME_VOLUME, NULL, this,
+                         gf_cli_rename_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_reset_volume (call_frame_t *frame, xlator_t *this,
-                        void *data)
-{
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_reset_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_RESET_VOLUME, this, cli_rpc_prog,
-                               NULL);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
-
-int32_t
-gf_cli_set_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_reset_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_set_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SET_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    dict = data;
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        return ret;
+    ret = cli_to_glusterd(&req, frame, gf_cli_reset_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_RESET_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_add_brick (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_ganesha(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-        char                    *volname = NULL;
-        int32_t                 count = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volname", &volname);
-
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
-                goto out;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_add_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ADD_BRICK, this, cli_rpc_prog, NULL);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    dict = data;
 
-        GF_FREE (req.dict.dict_val);
+    ret = cli_to_glusterd(&req, frame, gf_cli_ganesha_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_GANESHA,
+                          this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_tier (call_frame_t *frame, xlator_t *this,
-             void *data)
+static int32_t
+gf_cli_set_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                     ret = 0;
-        int32_t                 command = 0;
-        gf_cli_req              req =  { {0,} };
-        dict_t                  *dict = NULL;
-
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
-        dict = data;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        ret = dict_get_int32 (dict, "rebalance-command", &command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get rebalance-command");
-                goto out;
-        }
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_defrag_volume_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, dict,
-                                GLUSTER_CLI_TIER, this, cli_rpc_prog,
-                                NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_set_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_SET_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_add_tier_brick (call_frame_t *frame, xlator_t *this,
-                       void *data)
+gf_cli_add_brick(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req             = { {0,} };
-        int                     ret             = 0;
-        dict_t                  *dict           = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_add_tier_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ADD_TIER_BRICK, this,
-                               cli_rpc_prog, NULL);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to send request to "
-                        "glusterd");
-                goto out;
-        }
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-        return ret;
-}
-
-
-int32_t
-gf_cli_attach_tier (call_frame_t *frame, xlator_t *this,
-                    void *data)
-{
-        gf_cli_req              req             =  {{0,} };
-        int                     ret             = 0;
-        dict_t                  *dict           = NULL;
-        dict_t                  *newdict        = NULL;
-        char                    *tierwords[]    = {"volume", "tier", "",
-                                                   "start", NULL};
-        const char              **words         = (const char **)tierwords;
-        char                    *volname        = NULL;
-        cli_local_t             *local          = NULL;
-        cli_local_t             *oldlocal       = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        if (ret)
-                goto out;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_attach_tier_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ATTACH_TIER, this,
-                               cli_rpc_prog, NULL);
-        if (ret)
-                goto out;
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto notify_cli;
-        }
-
-        words[2] = volname;
-        ret = cli_cmd_volume_old_tier_parse ((const char **)words,
-                                             4, &newdict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to parse tier start "
-                        "command");
-                goto notify_cli;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        gf_log ("cli", GF_LOG_DEBUG, "Sending tier start");
+    dict = data;
 
-        oldlocal = frame->local;
-        CLI_LOCAL_INIT (local, words, frame, newdict);
-        ret = gf_cli_tier (frame, this, newdict);
-        frame->local = oldlocal;
-        cli_local_wipe (local);
+    ret = cli_to_glusterd(&req, frame, gf_cli_add_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_ADD_BRICK, this, cli_rpc_prog, NULL);
 
-notify_cli:
-        if (ret) {
-                cli_out ("Failed to run tier start. Please execute tier start "
-                         "command explicitly");
-                cli_out ("Usage : gluster volume tier <volname> start");
-        }
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_remove_tier_brick (call_frame_t *frame, xlator_t *this,
-                    void *data)
-{
-        gf_cli_req                status_req = { {0,} };
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
-        int32_t                   command = 0;
-        char                     *volname = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "command", &command);
-        if (ret)
-                goto out;
+static int32_t
+gf_cli_remove_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    ;
+    gf_cli_req status_req = {{
+        0,
+    }};
+    ;
+    int ret = 0;
+    dict_t *dict = NULL;
+    int32_t command = 0;
+    int32_t cmd = 0;
+
+    if (!frame || !this) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_int32_sizen(dict, "command", &command);
+    if (ret)
+        goto out;
+
+    if ((command != GF_OP_CMD_STATUS) && (command != GF_OP_CMD_STOP)) {
+        ret = cli_to_glusterd(
+            &req, frame, gf_cli_remove_brick_cbk, (xdrproc_t)xdr_gf_cli_req,
+            dict, GLUSTER_CLI_REMOVE_BRICK, this, cli_rpc_prog, NULL);
+    } else {
+        /* Need rebalance status to be sent :-) */
+        if (command == GF_OP_CMD_STATUS)
+            cmd |= GF_DEFRAG_CMD_STATUS;
+        else
+            cmd |= GF_DEFRAG_CMD_STOP;
 
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) command);
+        ret = dict_set_int32_sizen(dict, "rebalance-command", (int32_t)cmd);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                                "Failed to set dict");
-                goto out;
+            gf_log(this->name, GF_LOG_ERROR, "Failed to set dict");
+            goto out;
         }
 
-        ret = cli_to_glusterd (&status_req, frame,
-                        gf_cli_remove_tier_brick_cbk,
-                        (xdrproc_t) xdr_gf_cli_req, dict,
-                        GLUSTER_CLI_TIER, this,
-                        cli_rpc_prog, NULL);
+        ret = cli_to_glusterd(
+            &status_req, frame, gf_cli3_remove_brick_status_cbk,
+            (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_DEFRAG_VOLUME, this,
+            cli_rpc_prog, NULL);
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (status_req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
-}
+    GF_FREE(status_req.dict.dict_val);
 
-int32_t
-gf_cli_remove_brick (call_frame_t *frame, xlator_t *this,
-                     void *data)
-{
-        gf_cli_req                req =  {{0,}};;
-        gf_cli_req                status_req =  {{0,}};;
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
-        int32_t                   command = 0;
-        char                     *volname = NULL;
-        int32_t                   cmd = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "command", &command);
-        if (ret)
-                goto out;
-
-        if ((command != GF_OP_CMD_STATUS) &&
-            (command != GF_OP_CMD_STOP)) {
-
-
-                ret = cli_to_glusterd (&req, frame, gf_cli_remove_brick_cbk,
-                                       (xdrproc_t) xdr_gf_cli_req, dict,
-                                       GLUSTER_CLI_REMOVE_BRICK, this,
-                                       cli_rpc_prog, NULL);
-        } else {
-                /* Need rebalance status to be sent :-) */
-                if (command == GF_OP_CMD_STATUS)
-                        cmd |= GF_DEFRAG_CMD_STATUS;
-                else
-                        cmd |= GF_DEFRAG_CMD_STOP;
-
-                ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Failed to set dict");
-                        goto out;
-                }
-
-                ret = cli_to_glusterd (&status_req, frame,
-                                       gf_cli3_remove_brick_status_cbk,
-                                       (xdrproc_t) xdr_gf_cli_req, dict,
-                                       GLUSTER_CLI_DEFRAG_VOLUME, this,
-                                       cli_rpc_prog, NULL);
-
-                }
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-
-        GF_FREE (status_req.dict.dict_val);
-
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_reset_brick (call_frame_t *frame, xlator_t *this, void *data)
-{
-        gf_cli_req                  req        =  { {0,} };
-        int                         ret        = 0;
-        dict_t                     *dict       = NULL;
-        char                       *dst_brick  = NULL;
-        char                       *src_brick  = NULL;
-        char                       *volname    = NULL;
-        char                       *op         = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "operation", &op);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on volname failed");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "src-brick", &src_brick);
+static int32_t
+gf_cli_reset_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    char *dst_brick = NULL;
+    char *op = NULL;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_str_sizen(dict, "operation", &op);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on operation failed");
+        goto out;
+    }
+
+    if (!strcmp(op, "GF_RESET_OP_COMMIT") ||
+        !strcmp(op, "GF_RESET_OP_COMMIT_FORCE")) {
+        ret = dict_get_str_sizen(dict, "dst-brick", &dst_brick);
         if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on src-brick failed");
-                goto out;
-        }
-
-        if (!strcmp (op, "GF_RESET_OP_COMMIT") ||
-            !strcmp (op, "GF_RESET_OP_COMMIT_FORCE")) {
-                ret = dict_get_str (dict, "dst-brick", &dst_brick);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "dict_get on dst-brick failed");
-                        goto out;
-                }
+            gf_log(this->name, GF_LOG_DEBUG, "dict_get on dst-brick failed");
+            goto out;
         }
+    }
 
-        gf_log (this->name, GF_LOG_DEBUG,
-                "Received command reset-brick %s on %s.", op, src_brick);
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_reset_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_RESET_BRICK, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_reset_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_RESET_BRICK, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_replace_brick (call_frame_t *frame, xlator_t *this,
-                      void *data)
-{
-        gf_cli_req                  req        =  {{0,}};
-        int                         ret        = 0;
-        dict_t                     *dict       = NULL;
-        char                       *src_brick  = NULL;
-        char                       *dst_brick  = NULL;
-        char                       *volname    = NULL;
-        int32_t                     op         = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_int32 (dict, "operation", &op);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on volname failed");
-                goto out;
-        }
+static int32_t
+gf_cli_replace_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    int32_t op = 0;
 
-        ret = dict_get_str (dict, "src-brick", &src_brick);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on src-brick failed");
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_get_str (dict, "dst-brick", &dst_brick);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on dst-brick failed");
-                goto out;
-        }
+    dict = data;
 
-        gf_log (this->name, GF_LOG_DEBUG,
-                "Received command replace-brick %s with "
-                "%s with operation=%d", src_brick,
-                dst_brick, op);
+    ret = dict_get_int32_sizen(dict, "operation", &op);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on operation failed");
+        goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_replace_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_REPLACE_BRICK, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_replace_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_REPLACE_BRICK, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-
-int32_t
-gf_cli_log_rotate (call_frame_t *frame, xlator_t *this,
-                      void *data)
+static int32_t
+gf_cli_log_rotate(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                req = {{0,}};
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_log_rotate_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_LOG_ROTATE, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_log_rotate_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_LOG_ROTATE, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_sync_volume (call_frame_t *frame, xlator_t *this,
-                       void *data)
+static int32_t
+gf_cli_sync_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int               ret = 0;
-        gf_cli_req        req = {{0,}};
-        dict_t            *dict = NULL;
-
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_sync_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SYNC_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_sync_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_SYNC_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        GF_FREE (req.dict.dict_val);
-
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_getspec (call_frame_t *frame, xlator_t *this,
-                         void *data)
-{
-        gf_getspec_req          req = {0,};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-        dict_t                  *op_dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volid", &req.key);
-        if (ret)
-                goto out;
-
-        op_dict = dict_new ();
-        if (!op_dict) {
-                ret = -1;
-                goto out;
-        }
-
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (op_dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version"
-                        " in request dict");
-                goto out;
-        }
-
-        ret = dict_set_int32 (op_dict, "max-op-version", GD_OP_VERSION_MAX);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version"
-                        " in request dict");
-                goto out;
-        }
-
-        ret = dict_allocate_and_serialize (op_dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
-
-        ret = cli_cmd_submit (NULL, &req, frame, &cli_handshake_prog,
-                              GF_HNDSK_GETSPEC, NULL,
-                              this, gf_cli_getspec_cbk,
-                              (xdrproc_t) xdr_gf_getspec_req);
-
-out:
-        if (op_dict) {
-                dict_unref(op_dict);
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        return ret;
+static int32_t
+gf_cli_getspec(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    dict_t *op_dict = NULL;
+
+    if (!frame || !this) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_str_sizen(dict, "volid", &req.key);
+    if (ret)
+        goto out;
+
+    op_dict = dict_new();
+    if (!op_dict) {
+        ret = -1;
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32_sizen(op_dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set min-op-version in request dict");
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(op_dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set max-op-version in request dict");
+        goto out;
+    }
+
+    ret = dict_allocate_and_serialize(op_dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, DICT_SERIALIZE_FAIL);
+        goto out;
+    }
+
+    ret = cli_cmd_submit(NULL, &req, frame, &cli_handshake_prog,
+                         GF_HNDSK_GETSPEC, NULL, this, gf_cli_getspec_cbk,
+                         (xdrproc_t)xdr_gf_getspec_req);
+
+out:
+    if (op_dict) {
+        dict_unref(op_dict);
+    }
+    GF_FREE(req.xdata.xdata_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+
+    return ret;
 }
 
-int32_t
-gf_cli_quota (call_frame_t *frame, xlator_t *this,
-                 void *data)
+static int32_t
+gf_cli_quota(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req          req = {{0,}};
-        int                 ret = 0;
-        dict_t             *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    dict = data;
 
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_quota_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_QUOTA, this, cli_rpc_prog, NULL);
-
-out:
-        GF_FREE (req.dict.dict_val);
-
-        return ret;
+    ret = cli_to_glusterd(&req, frame, gf_cli_quota_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_QUOTA,
+                          this, cli_rpc_prog, NULL);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int32_t
-gf_cli_pmap_b2p (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_pmap_b2p(call_frame_t *frame, xlator_t *this, void *data)
 {
-        pmap_port_by_brick_req  req = {0,};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    pmap_port_by_brick_req req = {
+        0,
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "brick", &req.brick);
-        if (ret)
-                goto out;
+    ret = dict_get_str_sizen(dict, "brick", &req.brick);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_submit (NULL, &req, frame, &cli_pmap_prog,
-                              GF_PMAP_PORTBYBRICK, NULL,
-                              this, gf_cli_pmap_b2p_cbk,
-                              (xdrproc_t) xdr_pmap_port_by_brick_req);
+    ret = cli_cmd_submit(NULL, &req, frame, &cli_pmap_prog, GF_PMAP_PORTBYBRICK,
+                         NULL, this, gf_cli_pmap_b2p_cbk,
+                         (xdrproc_t)xdr_pmap_port_by_brick_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_fsm_log_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
-{
-        gf1_cli_fsm_log_rsp        rsp   = {0,};
-        int                        ret   = -1;
-        dict_t                     *dict = NULL;
-        int                        tr_count = 0;
-        char                       key[256] = {0};
-        int                        i = 0;
-        char                       *old_state = NULL;
-        char                       *new_state = NULL;
-        char                       *event = NULL;
-        char                       *time = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_fsm_log_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("%s", rsp.op_errstr);
-                cli_err ("fsm log unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.fsm_log.fsm_log_val,
-                                rsp.fsm_log.fsm_log_len,
-                                &dict);
-
-        if (ret) {
-                cli_err ("bad response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "count", &tr_count);
-        if (tr_count)
-                cli_out("number of transitions: %d", tr_count);
-        else
-                cli_err("No transitions");
-        for (i = 0; i < tr_count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "log%d-old-state", i);
-                ret = dict_get_str (dict, key, &old_state);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "log%d-event", i);
-                ret = dict_get_str (dict, key, &event);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "log%d-new-state", i);
-                ret = dict_get_str (dict, key, &new_state);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "log%d-time", i);
-                ret = dict_get_str (dict, key, &time);
-                if (ret)
-                        goto out;
-                cli_out ("Old State: [%s]\n"
-                         "New State: [%s]\n"
-                         "Event    : [%s]\n"
-                         "timestamp: [%s]\n", old_state, new_state, event, time);
-        }
-
+gf_cli_fsm_log_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
+{
+    gf1_cli_fsm_log_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    int tr_count = 0;
+    char key[64] = {0};
+    int keylen;
+    int i = 0;
+    char *old_state = NULL;
+    char *new_state = NULL;
+    char *event = NULL;
+    char *time = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_fsm_log_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("%s", rsp.op_errstr);
+        cli_err("fsm log unsuccessful");
         ret = rsp.op_ret;
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.fsm_log.fsm_log_val, rsp.fsm_log.fsm_log_len,
+                           &dict);
+
+    if (ret) {
+        cli_err(DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "count", &tr_count);
+    if (!ret && tr_count)
+        cli_out("number of transitions: %d", tr_count);
+    else
+        cli_err("No transitions");
+    for (i = 0; i < tr_count; i++) {
+        keylen = snprintf(key, sizeof(key), "log%d-old-state", i);
+        ret = dict_get_strn(dict, key, keylen, &old_state);
+        if (ret)
+            goto out;
 
-out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
-}
+        keylen = snprintf(key, sizeof(key), "log%d-event", i);
+        ret = dict_get_strn(dict, key, keylen, &event);
+        if (ret)
+            goto out;
 
-int32_t
-gf_cli_fsm_log (call_frame_t *frame, xlator_t *this, void *data)
-{
-        int                        ret = -1;
-        gf1_cli_fsm_log_req        req = {0,};
+        keylen = snprintf(key, sizeof(key), "log%d-new-state", i);
+        ret = dict_get_strn(dict, key, keylen, &new_state);
+        if (ret)
+            goto out;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+        keylen = snprintf(key, sizeof(key), "log%d-time", i);
+        ret = dict_get_strn(dict, key, keylen, &time);
+        if (ret)
+            goto out;
+        cli_out(
+            "Old State: [%s]\n"
+            "New State: [%s]\n"
+            "Event    : [%s]\n"
+            "timestamp: [%s]\n",
+            old_state, new_state, event, time);
+    }
 
-        if (!frame || !this || !data)
-                goto out;
-        req.name = data;
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_FSM_LOG, NULL,
-                              this, gf_cli_fsm_log_cbk,
-                              (xdrproc_t) xdr_gf1_cli_fsm_log_req);
+    ret = rsp.op_ret;
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    cli_cmd_broadcast_response(ret);
+    if (dict) {
+        dict_unref(dict);
+    }
+    gf_free_xdr_fsm_log_rsp(rsp);
 
-        return ret;
+    return ret;
 }
 
-int
-gf_cli_gsync_config_command (dict_t *dict)
+static int32_t
+gf_cli_fsm_log(call_frame_t *frame, xlator_t *this, void *data)
 {
-        runner_t runner     = {0,};
-        char *subop         = NULL;
-        char *gwd           = NULL;
-        char *slave         = NULL;
-        char *confpath      = NULL;
-        char *master        = NULL;
-        char *op_name       = NULL;
-        int   ret           = -1;
-        char  conf_path[PATH_MAX] = "";
+    int ret = -1;
+    gf1_cli_fsm_log_req req = {
+        0,
+    };
 
-        if (dict_get_str (dict, "subop", &subop) != 0)
-                return -1;
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
-                cli_out (GEOREP" config updated successfully");
-                return 0;
-        }
+    if (!frame || !this || !data)
+        goto out;
+    req.name = data;
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_FSM_LOG,
+                         NULL, this, gf_cli_fsm_log_cbk,
+                         (xdrproc_t)xdr_gf1_cli_fsm_log_req);
 
-        if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
-            dict_get_str (dict, "slave", &slave) != 0)
-                return -1;
-
-        if (dict_get_str (dict, "master", &master) != 0)
-                master = NULL;
-        if (dict_get_str (dict, "op_name", &op_name) != 0)
-                op_name = NULL;
-
-        ret = dict_get_str (dict, "conf_path", &confpath);
-        if (!confpath) {
-                ret = snprintf (conf_path, sizeof(conf_path) - 1,
-                                "%s/"GEOREP"/gsyncd_template.conf", gwd);
-                conf_path[ret] = '\0';
-                confpath = conf_path;
-        }
-
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "-c", NULL);
-        runner_argprintf (&runner, "%s", confpath);
-        runner_argprintf (&runner, "--iprefix=%s", DATADIR);
-        if (master)
-                runner_argprintf (&runner, ":%s", master);
-        runner_add_arg (&runner, slave);
-        runner_argprintf (&runner, "--config-%s", subop);
-        if (op_name)
-                runner_add_arg (&runner, op_name);
+out:
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return runner_run (&runner);
+    return ret;
 }
 
+static int
+gf_cli_gsync_config_command(dict_t *dict)
+{
+    runner_t runner = {
+        0,
+    };
+    char *subop = NULL;
+    char *gwd = NULL;
+    char *slave = NULL;
+    char *confpath = NULL;
+    char *master = NULL;
+    char *op_name = NULL;
+    int ret = -1;
+    char conf_path[PATH_MAX] = "";
+
+    if (dict_get_str_sizen(dict, "subop", &subop) != 0)
+        return -1;
+
+    if (strcmp(subop, "get") != 0 && strcmp(subop, "get-all") != 0) {
+        cli_out(GEOREP " config updated successfully");
+        return 0;
+    }
+
+    if (dict_get_str_sizen(dict, "glusterd_workdir", &gwd) != 0 ||
+        dict_get_str_sizen(dict, "slave", &slave) != 0)
+        return -1;
+
+    if (dict_get_str_sizen(dict, "master", &master) != 0)
+        master = NULL;
+    if (dict_get_str_sizen(dict, "op_name", &op_name) != 0)
+        op_name = NULL;
+
+    ret = dict_get_str_sizen(dict, "conf_path", &confpath);
+    if (ret || !confpath) {
+        ret = snprintf(conf_path, sizeof(conf_path) - 1,
+                       "%s/" GEOREP "/gsyncd_template.conf", gwd);
+        conf_path[ret] = '\0';
+        confpath = conf_path;
+    }
+
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "-c", NULL);
+    runner_argprintf(&runner, "%s", confpath);
+    runner_argprintf(&runner, "--iprefix=%s", DATADIR);
+    if (master)
+        runner_argprintf(&runner, ":%s", master);
+    runner_add_arg(&runner, slave);
+    runner_argprintf(&runner, "--config-%s", subop);
+    if (op_name)
+        runner_add_arg(&runner, op_name);
+
+    return runner_run(&runner);
+}
 
-int
-gf_cli_print_status (char **title_values,
-                     gf_gsync_status_t **sts_vals,
-                     int *spacing, int gsync_count,
-                     int number_of_fields, int is_detail)
-{
-        int     i                        = 0;
-        int     j                        = 0;
-        int     ret                      = 0;
-        int     status_fields            = 8; /* Indexed at 0 */
-        int     total_spacing            = 0;
-        char  **output_values            = NULL;
-        char   *tmp                      = NULL;
-        char   *hyphens                  = NULL;
-
-        /* calculating spacing for hyphens */
-        for (i = 0; i < number_of_fields; i++) {
-                /* Suppressing detail output for status */
-                if ((!is_detail) && (i > status_fields)) {
-                       /* Suppressing detailed output for
-                        * status */
-                        continue;
-                }
-                spacing[i] += 3; /* Adding extra space to
-                                    distinguish between fields */
-                total_spacing += spacing[i];
-        }
-        total_spacing += 4; /* For the spacing between the fields */
-
-        /* char pointers for each field */
-        output_values = GF_CALLOC (number_of_fields, sizeof (char *),
-                                   gf_common_mt_char);
-        if (!output_values) {
-                ret = -1;
-                goto out;
-        }
-        for (i = 0; i < number_of_fields; i++) {
-                output_values[i] = GF_CALLOC (spacing[i] + 1, sizeof (char),
-                                              gf_common_mt_char);
-                if (!output_values[i]) {
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        hyphens = GF_CALLOC (total_spacing + 1, sizeof (char),
-                             gf_common_mt_char);
-        if (!hyphens) {
+static int
+gf_cli_print_status(char **title_values, gf_gsync_status_t **sts_vals,
+                    int *spacing, int gsync_count, int number_of_fields,
+                    int is_detail)
+{
+    int i = 0;
+    int j = 0;
+    int ret = 0;
+    int status_fields = 8; /* Indexed at 0 */
+    int total_spacing = 0;
+    char **output_values = NULL;
+    char *tmp = NULL;
+    char *hyphens = NULL;
+
+    /* calculating spacing for hyphens */
+    for (i = 0; i < number_of_fields; i++) {
+        /* Suppressing detail output for status */
+        if ((!is_detail) && (i > status_fields)) {
+            /* Suppressing detailed output for
+             * status */
+            continue;
+        }
+        spacing[i] += 3; /* Adding extra space to
+                            distinguish between fields */
+        total_spacing += spacing[i];
+    }
+    total_spacing += 4; /* For the spacing between the fields */
+
+    /* char pointers for each field */
+    output_values = GF_MALLOC(number_of_fields * sizeof(char *),
+                              gf_common_mt_char);
+    if (!output_values) {
+        ret = -1;
+        goto out;
+    }
+    for (i = 0; i < number_of_fields; i++) {
+        output_values[i] = GF_CALLOC(spacing[i] + 1, sizeof(char),
+                                     gf_common_mt_char);
+        if (!output_values[i]) {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    cli_out(" ");
+
+    /* setting the title "NODE", "MASTER", etc. from title_values[]
+       and printing the same */
+    for (j = 0; j < number_of_fields; j++) {
+        if ((!is_detail) && (j > status_fields)) {
+            /* Suppressing detailed output for
+             * status */
+            output_values[j][0] = '\0';
+            continue;
+        }
+        memset(output_values[j], ' ', spacing[j]);
+        memcpy(output_values[j], title_values[j], strlen(title_values[j]));
+        output_values[j][spacing[j]] = '\0';
+    }
+    cli_out("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s", output_values[0],
+            output_values[1], output_values[2], output_values[3],
+            output_values[4], output_values[5], output_values[6],
+            output_values[7], output_values[8], output_values[9],
+            output_values[10], output_values[11], output_values[12],
+            output_values[13], output_values[14], output_values[15]);
+
+    hyphens = GF_MALLOC((total_spacing + 1) * sizeof(char), gf_common_mt_char);
+    if (!hyphens) {
+        ret = -1;
+        goto out;
+    }
+
+    /* setting and printing the hyphens */
+    memset(hyphens, '-', total_spacing);
+    hyphens[total_spacing] = '\0';
+    cli_out("%s", hyphens);
+
+    for (i = 0; i < gsync_count; i++) {
+        for (j = 0; j < number_of_fields; j++) {
+            if ((!is_detail) && (j > status_fields)) {
+                /* Suppressing detailed output for
+                 * status */
+                output_values[j][0] = '\0';
+                continue;
+            }
+            tmp = get_struct_variable(j, sts_vals[i]);
+            if (!tmp) {
+                gf_log("", GF_LOG_ERROR, "struct member empty.");
                 ret = -1;
                 goto out;
+            }
+            memset(output_values[j], ' ', spacing[j]);
+            memcpy(output_values[j], tmp, strlen(tmp));
+            output_values[j][spacing[j]] = '\0';
         }
 
-        cli_out (" ");
-
-        /* setting the title "NODE", "MASTER", etc. from title_values[]
-           and printing the same */
-        for (j = 0; j < number_of_fields; j++) {
-                if ((!is_detail) && (j > status_fields)) {
-                       /* Suppressing detailed output for
-                        * status */
-                       output_values[j][0] = '\0';
-                       continue;
-                }
-                memset (output_values[j], ' ', spacing[j]);
-                memcpy (output_values[j], title_values[j],
-                        strlen(title_values[j]));
-                output_values[j][spacing[j]] = '\0';
-        }
-        cli_out ("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
-                 output_values[0], output_values[1],
-                 output_values[2], output_values[3],
-                 output_values[4], output_values[5],
-                 output_values[6], output_values[7],
-                 output_values[8], output_values[9],
-                 output_values[10], output_values[11],
-                 output_values[12], output_values[13],
-                 output_values[14], output_values[15]);
-
-        /* setting and printing the hyphens */
-        memset (hyphens, '-', total_spacing);
-        hyphens[total_spacing] = '\0';
-        cli_out ("%s", hyphens);
-
-        for (i = 0; i < gsync_count; i++) {
-                for (j = 0; j < number_of_fields; j++) {
-                        if ((!is_detail) && (j > status_fields)) {
-                                /* Suppressing detailed output for
-                                 * status */
-                                output_values[j][0] = '\0';
-                                continue;
-                        }
-                        tmp = get_struct_variable(j, sts_vals[i]);
-                        if (!tmp) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-                        memset (output_values[j], ' ', spacing[j]);
-                        memcpy (output_values[j], tmp, strlen (tmp));
-                        output_values[j][spacing[j]] = '\0';
-                }
-
-                cli_out ("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
-                         output_values[0], output_values[1],
-                         output_values[2], output_values[3],
-                         output_values[4], output_values[5],
-                         output_values[6], output_values[7],
-                         output_values[8], output_values[9],
-                         output_values[10], output_values[11],
-                         output_values[12], output_values[13],
-                         output_values[14], output_values[15]);
-        }
+        cli_out("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
+                output_values[0], output_values[1], output_values[2],
+                output_values[3], output_values[4], output_values[5],
+                output_values[6], output_values[7], output_values[8],
+                output_values[9], output_values[10], output_values[11],
+                output_values[12], output_values[13], output_values[14],
+                output_values[15]);
+    }
 
 out:
-        if (output_values) {
-                for (i = 0; i < number_of_fields; i++) {
-                        if (output_values[i])
-                                GF_FREE (output_values[i]);
-                }
-                GF_FREE (output_values);
+    if (output_values) {
+        for (i = 0; i < number_of_fields; i++) {
+            if (output_values[i])
+                GF_FREE(output_values[i]);
         }
+        GF_FREE(output_values);
+    }
 
-        if (hyphens)
-                GF_FREE (hyphens);
+    if (hyphens)
+        GF_FREE(hyphens);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_gsync_status_t_comparator (const void *p, const void *q)
+gf_gsync_status_t_comparator(const void *p, const void *q)
 {
-        char *slavekey1 = NULL;
-        char *slavekey2 = NULL;
-
-        slavekey1 = get_struct_variable (20, (*(gf_gsync_status_t **)p));
-        slavekey2 = get_struct_variable (20, (*(gf_gsync_status_t **)q));
-        if (!slavekey1 || !slavekey2) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "struct member empty.");
-                return 0;
-        }
-
-        return strcmp (slavekey1, slavekey2);
-}
-
-int
-gf_cli_read_status_data (dict_t *dict,
-                         gf_gsync_status_t **sts_vals,
-                         int *spacing, int gsync_count,
-                         int number_of_fields)
-{
-        char   *tmp                    = NULL;
-        char    sts_val_name[PATH_MAX] = "";
-        int     ret                    = 0;
-        int     i                      = 0;
-        int     j                      = 0;
-
-        /* Storing per node status info in each object */
-        for (i = 0; i < gsync_count; i++) {
-                snprintf (sts_val_name, sizeof(sts_val_name), "status_value%d", i);
-
-                /* Fetching the values from dict, and calculating
-                   the max length for each field */
-                ret = dict_get_bin (dict, sts_val_name, (void **)&(sts_vals[i]));
-                if (ret)
-                        goto out;
-
-                for (j = 0; j < number_of_fields; j++) {
-                        tmp = get_struct_variable(j, sts_vals[i]);
-                        if (!tmp) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-                        if (strlen (tmp) > spacing[j])
-                                spacing[j] = strlen (tmp);
-                }
-        }
+    char *slavekey1 = NULL;
+    char *slavekey2 = NULL;
 
-        /* Sort based on Session Slave */
-        qsort(sts_vals, gsync_count,
-              sizeof(gf_gsync_status_t *),
-              gf_gsync_status_t_comparator);
+    slavekey1 = get_struct_variable(20, (*(gf_gsync_status_t **)p));
+    slavekey2 = get_struct_variable(20, (*(gf_gsync_status_t **)q));
+    if (!slavekey1 || !slavekey2) {
+        gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+        return 0;
+    }
 
-out:
-        return ret;
+    return strcmp(slavekey1, slavekey2);
 }
 
-int
-gf_cli_gsync_status_output (dict_t *dict, gf_boolean_t is_detail)
-{
-        int                     gsync_count    = 0;
-        int                     i              = 0;
-        int                     ret            = 0;
-        int                     spacing[16]    = {0};
-        int                     num_of_fields  = 16;
-        char                    errmsg[1024]   = "";
-        char                   *master         = NULL;
-        char                   *slave          = NULL;
-        char                   *title_values[] = {"MASTER NODE", "MASTER VOL",
-                                                  "MASTER BRICK", "SLAVE USER",
-                                                  "SLAVE", "SLAVE NODE",
-                                                  "STATUS", "CRAWL STATUS",
-                                                  "LAST_SYNCED", "ENTRY",
-                                                  "DATA", "META", "FAILURES",
-                                                  "CHECKPOINT TIME",
-                                                  "CHECKPOINT COMPLETED",
-                                                  "CHECKPOINT COMPLETION TIME"};
-        gf_gsync_status_t     **sts_vals       = NULL;
-
-        /* Checks if any session is active or not */
-        ret = dict_get_int32 (dict, "gsync-count", &gsync_count);
-        if (ret) {
-                ret = dict_get_str (dict, "master", &master);
-
-                ret = dict_get_str (dict, "slave", &slave);
-
-                if (master) {
-                        if (slave)
-                                snprintf (errmsg, sizeof(errmsg), "No active "
-                                          "geo-replication sessions between %s"
-                                          " and %s", master, slave);
-                        else
-                                snprintf (errmsg, sizeof(errmsg), "No active "
-                                          "geo-replication sessions for %s",
-                                          master);
-                } else
-                        snprintf (errmsg, sizeof(errmsg), "No active "
-                                  "geo-replication sessions");
-
-                gf_log ("cli", GF_LOG_INFO, "%s", errmsg);
-                cli_out ("%s", errmsg);
-                ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < num_of_fields; i++)
-                spacing[i] = strlen(title_values[i]);
+static int
+gf_cli_read_status_data(dict_t *dict, gf_gsync_status_t **sts_vals,
+                        int *spacing, int gsync_count, int number_of_fields)
+{
+    char *tmp = NULL;
+    char sts_val_name[PATH_MAX] = "";
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+
+    /* Storing per node status info in each object */
+    for (i = 0; i < gsync_count; i++) {
+        snprintf(sts_val_name, sizeof(sts_val_name), "status_value%d", i);
+
+        /* Fetching the values from dict, and calculating
+           the max length for each field */
+        ret = dict_get_bin(dict, sts_val_name, (void **)&(sts_vals[i]));
+        if (ret)
+            goto out;
 
-        /* gsync_count = number of nodes reporting output.
-           each sts_val object will store output of each
-           node */
-        sts_vals = GF_CALLOC (gsync_count, sizeof (gf_gsync_status_t *),
-                              gf_common_mt_char);
-        if (!sts_vals) {
+        for (j = 0; j < number_of_fields; j++) {
+            tmp = get_struct_variable(j, sts_vals[i]);
+            if (!tmp) {
+                gf_log("", GF_LOG_ERROR, "struct member empty.");
                 ret = -1;
                 goto out;
+            }
+            if (strlen(tmp) > spacing[j])
+                spacing[j] = strlen(tmp);
         }
-        for (i = 0; i < gsync_count; i++) {
-                sts_vals[i] = GF_CALLOC (1, sizeof (gf_gsync_status_t),
-                                         gf_common_mt_char);
-                if (!sts_vals[i]) {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    }
 
-        ret = gf_cli_read_status_data (dict, sts_vals, spacing,
-                                       gsync_count, num_of_fields);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to read status data");
-                goto out;
-        }
-
-        ret = gf_cli_print_status (title_values, sts_vals, spacing, gsync_count,
-                                   num_of_fields, is_detail);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to print status output");
-                goto out;
-        }
+    /* Sort based on Session Slave */
+    qsort(sts_vals, gsync_count, sizeof(gf_gsync_status_t *),
+          gf_gsync_status_t_comparator);
 
 out:
-        if (sts_vals)
-                GF_FREE (sts_vals);
+    return ret;
+}
 
-        return ret;
+static int
+gf_cli_gsync_status_output(dict_t *dict, gf_boolean_t is_detail)
+{
+    int gsync_count = 0;
+    int i = 0;
+    int ret = 0;
+    int spacing[16] = {0};
+    int num_of_fields = 16;
+    char errmsg[1024] = "";
+    char *master = NULL;
+    char *slave = NULL;
+    static char *title_values[] = {"MASTER NODE",
+                                   "MASTER VOL",
+                                   "MASTER BRICK",
+                                   "SLAVE USER",
+                                   "SLAVE",
+                                   "SLAVE NODE",
+                                   "STATUS",
+                                   "CRAWL STATUS",
+                                   "LAST_SYNCED",
+                                   "ENTRY",
+                                   "DATA",
+                                   "META",
+                                   "FAILURES",
+                                   "CHECKPOINT TIME",
+                                   "CHECKPOINT COMPLETED",
+                                   "CHECKPOINT COMPLETION TIME"};
+    gf_gsync_status_t **sts_vals = NULL;
+
+    /* Checks if any session is active or not */
+    ret = dict_get_int32_sizen(dict, "gsync-count", &gsync_count);
+    if (ret) {
+        ret = dict_get_str_sizen(dict, "master", &master);
+
+        ret = dict_get_str_sizen(dict, "slave", &slave);
+
+        if (master) {
+            if (slave)
+                snprintf(errmsg, sizeof(errmsg),
+                         "No active geo-replication sessions between %s"
+                         " and %s",
+                         master, slave);
+            else
+                snprintf(errmsg, sizeof(errmsg),
+                         "No active geo-replication sessions for %s", master);
+        } else
+            snprintf(errmsg, sizeof(errmsg),
+                     "No active geo-replication sessions");
+
+        gf_log("cli", GF_LOG_INFO, "%s", errmsg);
+        cli_out("%s", errmsg);
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < num_of_fields; i++)
+        spacing[i] = strlen(title_values[i]);
+
+    /* gsync_count = number of nodes reporting output.
+       each sts_val object will store output of each
+       node */
+    sts_vals = GF_MALLOC(gsync_count * sizeof(gf_gsync_status_t *),
+                         gf_common_mt_char);
+    if (!sts_vals) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_cli_read_status_data(dict, sts_vals, spacing, gsync_count,
+                                  num_of_fields);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to read status data");
+        goto out;
+    }
+
+    ret = gf_cli_print_status(title_values, sts_vals, spacing, gsync_count,
+                              num_of_fields, is_detail);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to print status output");
+        goto out;
+    }
+
+out:
+    if (sts_vals)
+        GF_FREE(sts_vals);
+
+    return ret;
 }
 
 static int32_t
-write_contents_to_common_pem_file (dict_t *dict, int output_count)
-{
-        char            *workdir                   = NULL;
-        char             common_pem_file[PATH_MAX] = "";
-        char            *output                    = NULL;
-        char             output_name[PATH_MAX]     = "";
-        int              bytes_written             = 0;
-        int              fd                        = -1;
-        int              ret                       = -1;
-        int              i                         = -1;
-
-        ret = dict_get_str (dict, "glusterd_workdir", &workdir);
-        if (ret || !workdir) {
-                gf_log ("", GF_LOG_ERROR, "Unable to fetch workdir");
+write_contents_to_common_pem_file(dict_t *dict, int output_count)
+{
+    char *workdir = NULL;
+    char common_pem_file[PATH_MAX] = "";
+    char *output = NULL;
+    char output_name[32] = "";
+    int bytes_written = 0;
+    int fd = -1;
+    int ret = -1;
+    int i = -1;
+
+    ret = dict_get_str_sizen(dict, "glusterd_workdir", &workdir);
+    if (ret || !workdir) {
+        gf_log("", GF_LOG_ERROR, "Unable to fetch workdir");
+        ret = -1;
+        goto out;
+    }
+
+    snprintf(common_pem_file, sizeof(common_pem_file),
+             "%s/geo-replication/common_secret.pem.pub", workdir);
+
+    sys_unlink(common_pem_file);
+
+    fd = open(common_pem_file, O_WRONLY | O_CREAT, 0600);
+    if (fd == -1) {
+        gf_log("", GF_LOG_ERROR, "Failed to open %s Error : %s",
+               common_pem_file, strerror(errno));
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 1; i <= output_count; i++) {
+        ret = snprintf(output_name, sizeof(output_name), "output_%d", i);
+        ret = dict_get_strn(dict, output_name, ret, &output);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "Failed to get %s.", output_name);
+            cli_out("Unable to fetch output.");
+        }
+        if (output) {
+            bytes_written = sys_write(fd, output, strlen(output));
+            if (bytes_written != strlen(output)) {
+                gf_log("", GF_LOG_ERROR, "Failed to write to %s",
+                       common_pem_file);
                 ret = -1;
                 goto out;
-        }
-
-        snprintf (common_pem_file, sizeof(common_pem_file),
-                  "%s/geo-replication/common_secret.pem.pub",
-                  workdir);
-
-        sys_unlink (common_pem_file);
-
-        fd = open (common_pem_file, O_WRONLY | O_CREAT, 0600);
-        if (fd == -1) {
-                gf_log ("", GF_LOG_ERROR, "Failed to open %s"
-                        " Error : %s", common_pem_file,
-                        strerror (errno));
+            }
+            /* Adding the new line character */
+            bytes_written = sys_write(fd, "\n", 1);
+            if (bytes_written != 1) {
+                gf_log("", GF_LOG_ERROR, "Failed to add new line char");
                 ret = -1;
                 goto out;
+            }
+            output = NULL;
         }
+    }
 
-        for (i = 1; i <= output_count; i++) {
-                memset (output_name, '\0', sizeof (output_name));
-                snprintf (output_name, sizeof (output_name),
-                          "output_%d", i);
-                ret = dict_get_str (dict, output_name, &output);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Failed to get %s.",
-                                output_name);
-                        cli_out ("Unable to fetch output.");
-                }
-                if (output) {
-                        bytes_written = sys_write (fd, output, strlen(output));
-                        if (bytes_written != strlen(output)) {
-                                gf_log ("", GF_LOG_ERROR, "Failed to write "
-                                        "to %s", common_pem_file);
-                                ret = -1;
-                                goto out;
-                        }
-                        /* Adding the new line character */
-                        bytes_written = sys_write (fd, "\n", strlen("\n"));
-                        if (bytes_written != strlen("\n")) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "Failed to add new line char");
-                                ret = -1;
-                                goto out;
-                        }
-                        output = NULL;
-                }
-        }
-
-        cli_out ("Common secret pub file present at %s", common_pem_file);
-        ret = 0;
+    cli_out("Common secret pub file present at %s", common_pem_file);
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-int
-gf_cli_sys_exec_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        int                     ret     = -1;
-        int                     output_count     = -1;
-        int                     i     = -1;
-        char                   *output  = NULL;
-        char                   *command = NULL;
-        char                    output_name[PATH_MAX] = "";
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-       }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+static int
+gf_cli_sys_exec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+    int ret = -1;
+    int output_count = -1;
+    int i = -1;
+    char *output = NULL;
+    char *command = NULL;
+    char output_name[32] = "";
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret) {
+        cli_err("%s", rsp.op_errstr ? rsp.op_errstr : "Command failed.");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    ret = dict_get_int32_sizen(dict, "output_count", &output_count);
+    if (ret) {
+        cli_out("Command executed successfully.");
+        ret = 0;
+        goto out;
+    }
 
-        if (ret)
-                goto out;
+    ret = dict_get_str_sizen(dict, "command", &command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to get command from dict");
+        goto out;
+    }
 
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         "Command failed.");
-                ret = rsp.op_ret;
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "output_count", &output_count);
-        if (ret) {
-                cli_out ("Command executed successfully.");
-                ret = 0;
-                goto out;
-        }
+    if (!strcmp(command, "gsec_create")) {
+        ret = write_contents_to_common_pem_file(dict, output_count);
+        if (!ret)
+            goto out;
+    }
 
-        ret = dict_get_str (dict, "command", &command);
+    for (i = 1; i <= output_count; i++) {
+        ret = snprintf(output_name, sizeof(output_name), "output_%d", i);
+        ret = dict_get_strn(dict, output_name, ret, &output);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Unable to get command from dict");
-                goto out;
+            gf_log("", GF_LOG_ERROR, "Failed to get %s.", output_name);
+            cli_out("Unable to fetch output.");
         }
-
-        if (!strcmp (command, "gsec_create")) {
-                ret = write_contents_to_common_pem_file (dict, output_count);
-                if (!ret)
-                        goto out;
+        if (output) {
+            cli_out("%s", output);
+            output = NULL;
         }
+    }
 
-        for (i = 1; i <= output_count; i++) {
-                memset (output_name, '\0', sizeof (output_name));
-                snprintf (output_name, sizeof (output_name),
-                          "output_%d", i);
-                ret = dict_get_str (dict, output_name, &output);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Failed to get %s.",
-                                output_name);
-                        cli_out ("Unable to fetch output.");
-                }
-                if (output) {
-                        cli_out ("%s", output);
-                        output = NULL;
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-
-        free (rsp.dict.dict_val);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_copy_file_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
+static int
+gf_cli_copy_file_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        int                     ret     = -1;
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (req->rpc_status == -1) {
-                goto out;
-        }
+    if (req->rpc_status == -1) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-       }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-       if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         "Copy unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (rsp.op_ret) {
+        cli_err("%s", rsp.op_errstr ? rsp.op_errstr : "Copy unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        cli_out ("Successfully copied file.");
+    cli_out("Successfully copied file.");
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-
-        free (rsp.dict.dict_val);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_gsync_set_cbk (struct rpc_req *req, struct iovec *iov,
-                         int count, void *myframe)
-{
-        int                     ret     = -1;
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
-        char                    *gsync_status = NULL;
-        char                    *master = NULL;
-        char                    *slave  = NULL;
-        int32_t                  type   = 0;
-        gf_boolean_t             status_detail = _gf_false;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-
+static int
+gf_cli_gsync_set_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *gsync_status = NULL;
+    char *master = NULL;
+    char *slave = NULL;
+    int32_t type = 0;
+    gf_boolean_t status_detail = _gf_false;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_gsync(dict, rsp.op_ret, rsp.op_errno,
+                                       rsp.op_errstr);
         if (ret)
-                goto out;
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_gsync (dict, rsp.op_ret, rsp.op_errno,
-                                                rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         GEOREP" command unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "gsync-status", &gsync_status);
-        if (!ret)
-                cli_out ("%s", gsync_status);
-        else
-                ret = 0;
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "failed to get type");
-                goto out;
-        }
-
-        switch (type) {
-                case GF_GSYNC_OPTION_TYPE_START:
-                case GF_GSYNC_OPTION_TYPE_STOP:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-
-                        cli_out ("%s " GEOREP " session between %s & %s"
-                                 " has been successful",
-                                 type == GF_GSYNC_OPTION_TYPE_START ?
-                                  "Starting" : "Stopping",
-                                 master, slave);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_PAUSE:
-                case GF_GSYNC_OPTION_TYPE_RESUME:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-
-                        cli_out ("%s " GEOREP " session between %s & %s"
-                                 " has been successful",
-                                 type == GF_GSYNC_OPTION_TYPE_PAUSE ?
-                                  "Pausing" : "Resuming",
-                                 master, slave);
-                break;
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-                case GF_GSYNC_OPTION_TYPE_CONFIG:
-                        ret = gf_cli_gsync_config_command (dict);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_STATUS:
-                        status_detail = dict_get_str_boolean (dict,
-                                                              "status-detail",
-                                                              _gf_false);
-                        ret = gf_cli_gsync_status_output (dict, status_detail);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_DELETE:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-                        cli_out ("Deleting " GEOREP " session between %s & %s"
-                                 " has been successful", master, slave);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_CREATE:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-                        cli_out ("Creating " GEOREP " session between %s & %s"
-                                 " has been successful", master, slave);
-                break;
+    if (rsp.op_ret) {
+        cli_err("%s",
+                rsp.op_errstr ? rsp.op_errstr : GEOREP " command unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(dict, "gsync-status", &gsync_status);
+    if (!ret)
+        cli_out("%s", gsync_status);
+
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "failed to get type");
+        goto out;
+    }
+
+    switch (type) {
+        case GF_GSYNC_OPTION_TYPE_START:
+        case GF_GSYNC_OPTION_TYPE_STOP:
+            if (dict_get_str_sizen(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str_sizen(dict, "slave", &slave) != 0)
+                slave = "???";
+
+            cli_out(
+                "%s " GEOREP " session between %s & %s has been successful",
+                type == GF_GSYNC_OPTION_TYPE_START ? "Starting" : "Stopping",
+                master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_PAUSE:
+        case GF_GSYNC_OPTION_TYPE_RESUME:
+            if (dict_get_str_sizen(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str_sizen(dict, "slave", &slave) != 0)
+                slave = "???";
+
+            cli_out("%s " GEOREP " session between %s & %s has been successful",
+                    type == GF_GSYNC_OPTION_TYPE_PAUSE ? "Pausing" : "Resuming",
+                    master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_CONFIG:
+            ret = gf_cli_gsync_config_command(dict);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_STATUS:
+            status_detail = dict_get_str_boolean(dict, "status-detail",
+                                                 _gf_false);
+            ret = gf_cli_gsync_status_output(dict, status_detail);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_DELETE:
+            if (dict_get_str_sizen(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str_sizen(dict, "slave", &slave) != 0)
+                slave = "???";
+            cli_out("Deleting " GEOREP
+                    " session between %s & %s has been successful",
+                    master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_CREATE:
+            if (dict_get_str_sizen(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str_sizen(dict, "slave", &slave) != 0)
+                slave = "???";
+            cli_out("Creating " GEOREP
+                    " session between %s & %s has been successful",
+                    master, slave);
+            break;
 
-                default:
-                        cli_out (GEOREP" command executed successfully");
-        }
+        default:
+            cli_out(GEOREP " command executed successfully");
+    }
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-
-        free (rsp.dict.dict_val);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_sys_exec (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_sys_exec(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
+    dict = data;
+
+    ret = cli_to_glusterd(&req, frame, gf_cli_sys_exec_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_SYS_EXEC,
+                          this, cli_rpc_prog, NULL);
+    if (ret)
         if (!frame || !this || !data) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid data");
-                goto out;
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid data");
         }
 
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_sys_exec_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SYS_EXEC, this, cli_rpc_prog,
-                               NULL);
-out:
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_copy_file (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_copy_file(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
+    dict = data;
+
+    ret = cli_to_glusterd(&req, frame, gf_cli_copy_file_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_COPY_FILE, this, cli_rpc_prog, NULL);
+    if (ret)
         if (!frame || !this || !data) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid data");
-                goto out;
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid data");
         }
 
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_copy_file_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_COPY_FILE, this, cli_rpc_prog,
-                               NULL);
-out:
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_gsync_set (call_frame_t *frame, xlator_t *this,
-                     void *data)
+static int32_t
+gf_cli_gsync_set(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    dict = data;
 
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_gsync_set_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_GSYNC_SET, this, cli_rpc_prog,
-                               NULL);
-
-out:
-        GF_FREE (req.dict.dict_val);
+    ret = cli_to_glusterd(&req, frame, gf_cli_gsync_set_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_GSYNC_SET, this, cli_rpc_prog, NULL);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_profile_info_percentage_cmp (void *a, void *b)
+cli_profile_info_percentage_cmp(void *a, void *b)
 {
-        cli_profile_info_t *ia = NULL;
-        cli_profile_info_t *ib = NULL;
-        int                ret = 0;
-
-        ia = a;
-        ib = b;
-        if (ia->percentage_avg_latency < ib->percentage_avg_latency)
-                ret = -1;
-        else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
-                ret = 1;
-        else
-                ret = 0;
-        return ret;
-}
+    cli_profile_info_t *ia = NULL;
+    cli_profile_info_t *ib = NULL;
 
+    ia = a;
+    ib = b;
+    if (ia->percentage_avg_latency < ib->percentage_avg_latency)
+        return -1;
+    else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
+        return 1;
 
-void
-cmd_profile_volume_brick_out (dict_t *dict, int count, int interval)
-{
-        char                    key[256] = {0};
-        int                     i = 0;
-        uint64_t                sec = 0;
-        uint64_t                r_count = 0;
-        uint64_t                w_count = 0;
-        uint64_t                rb_counts[32] = {0};
-        uint64_t                wb_counts[32] = {0};
-        cli_profile_info_t      profile_info[GF_FOP_MAXVALUE] = {{0}};
-        cli_profile_info_t      upcall_info[GF_UPCALL_FLAGS_MAXVALUE] = {{0},};
-        char                    output[128] = {0};
-        int                     per_line = 0;
-        char                    read_blocks[128] = {0};
-        char                    write_blocks[128] = {0};
-        int                     index = 0;
-        int                     is_header_printed = 0;
-        int                     ret = 0;
-        double                  total_percentage_latency = 0;
-
-        for (i = 0; i < 32; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-read-%d", count,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &rb_counts[i]);
-        }
-
-        for (i = 0; i < 32; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-write-%d", count, interval,
-                          (1<<i));
-                ret = dict_get_uint64 (dict, key, &wb_counts[i]);
-        }
-
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                snprintf (key, sizeof (key), "%d-%d-%d-upcall-hits", count,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &upcall_info[i].fop_hits);
-                upcall_info[i].fop_name = (char *)gf_upcall_list[i];
-        }
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-hits", count,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &profile_info[i].fop_hits);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-avglatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].avg_latency);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-minlatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].min_latency);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].max_latency);
-                profile_info[i].fop_name = (char *)gf_fop_list[i];
-
-                total_percentage_latency +=
-                       (profile_info[i].fop_hits * profile_info[i].avg_latency);
-        }
-        if (total_percentage_latency) {
-                for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                        profile_info[i].percentage_avg_latency = 100 * (
-                     (profile_info[i].avg_latency* profile_info[i].fop_hits) /
-                                total_percentage_latency);
-                }
-                gf_array_insertionsort (profile_info, 1, GF_FOP_MAXVALUE - 1,
-                                    sizeof (cli_profile_info_t),
-                                    cli_profile_info_percentage_cmp);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-duration", count, interval);
-        ret = dict_get_uint64 (dict, key, &sec);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-total-read", count, interval);
-        ret = dict_get_uint64 (dict, key, &r_count);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-total-write", count, interval);
-        ret = dict_get_uint64 (dict, key, &w_count);
-
-        if (ret == 0) {
-        }
+    return 0;
+}
 
-        if (interval == -1)
-                cli_out ("Cumulative Stats:");
-        else
-                cli_out ("Interval %d Stats:", interval);
-        snprintf (output, sizeof (output), "%14s", "Block Size:");
-        snprintf (read_blocks, sizeof (read_blocks), "%14s", "No. of Reads:");
-        snprintf (write_blocks, sizeof (write_blocks), "%14s", "No. of Writes:");
-        index = 14;
-        for (i = 0; i < 32; i++) {
-                if ((rb_counts[i] == 0) && (wb_counts[i] == 0))
-                        continue;
-                per_line++;
-                snprintf (output+index, sizeof (output)-index, "%19db+ ", (1<<i));
-                if (rb_counts[i]) {
-                        snprintf (read_blocks+index, sizeof (read_blocks)-index,
-                                  "%21"PRId64" ", rb_counts[i]);
-                } else {
-                        snprintf (read_blocks+index, sizeof (read_blocks)-index,
-                                  "%21s ", "0");
-                }
-                if (wb_counts[i]) {
-                        snprintf (write_blocks+index, sizeof (write_blocks)-index,
-                                  "%21"PRId64" ", wb_counts[i]);
-                } else {
-                        snprintf (write_blocks+index, sizeof (write_blocks)-index,
-                                  "%21s ", "0");
-                }
-                index += 22;
-                if (per_line == 3) {
-                        cli_out ("%s", output);
-                        cli_out ("%s", read_blocks);
-                        cli_out ("%s", write_blocks);
-                        cli_out (" ");
-                        per_line = 0;
-                        memset (output, 0, sizeof (output));
-                        memset (read_blocks, 0, sizeof (read_blocks));
-                        memset (write_blocks, 0, sizeof (write_blocks));
-                        snprintf (output, sizeof (output), "%14s", "Block Size:");
-                        snprintf (read_blocks, sizeof (read_blocks), "%14s",
-                                  "No. of Reads:");
-                        snprintf (write_blocks, sizeof (write_blocks), "%14s",
-                                  "No. of Writes:");
-                        index = 14;
-                }
+static void
+cmd_profile_volume_brick_out(dict_t *dict, int count, int interval)
+{
+    char key[256] = {0};
+    int i = 0;
+    uint64_t sec = 0;
+    uint64_t r_count = 0;
+    uint64_t w_count = 0;
+    uint64_t rb_counts[32] = {0};
+    uint64_t wb_counts[32] = {0};
+    cli_profile_info_t profile_info[GF_FOP_MAXVALUE] = {{0}};
+    cli_profile_info_t upcall_info[GF_UPCALL_FLAGS_MAXVALUE] = {
+        {0},
+    };
+    char output[128] = {0};
+    int per_line = 0;
+    char read_blocks[128] = {0};
+    char write_blocks[128] = {0};
+    int index = 0;
+    int is_header_printed = 0;
+    int ret = 0;
+    double total_percentage_latency = 0;
+
+    for (i = 0; i < 32; i++) {
+        snprintf(key, sizeof(key), "%d-%d-read-%" PRIu32, count, interval,
+                 (1U << i));
+        ret = dict_get_uint64(dict, key, &rb_counts[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+    }
 
-        if (per_line != 0) {
-                cli_out ("%s", output);
-                cli_out ("%s", read_blocks);
-                cli_out ("%s", write_blocks);
-        }
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                if (profile_info[i].fop_hits == 0)
-                        continue;
-                if (is_header_printed == 0) {
-                        cli_out ("%10s %13s %13s %13s %14s %11s", "%-latency",
-                                 "Avg-latency", "Min-Latency", "Max-Latency",
-                                 "No. of calls", "Fop");
-                        cli_out ("%10s %13s %13s %13s %14s %11s", "---------",
-                                 "-----------", "-----------", "-----------",
-                                 "------------", "----");
-                        is_header_printed = 1;
-                }
-                if (profile_info[i].fop_hits) {
-                        cli_out ("%10.2lf %10.2lf us %10.2lf us %10.2lf us"
-                                 " %14"PRId64" %11s",
-                                 profile_info[i].percentage_avg_latency,
-                                 profile_info[i].avg_latency,
-                                 profile_info[i].min_latency,
-                                 profile_info[i].max_latency,
-                                 profile_info[i].fop_hits,
-                                 profile_info[i].fop_name);
-                }
+    for (i = 0; i < 32; i++) {
+        snprintf(key, sizeof(key), "%d-%d-write-%" PRIu32, count, interval,
+                 (1U << i));
+        ret = dict_get_uint64(dict, key, &wb_counts[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+    }
 
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                if (upcall_info[i].fop_hits == 0)
-                        continue;
-                if (upcall_info[i].fop_hits) {
-                        cli_out ("%10.2lf %10.2lf us %10.2lf us %10.2lf us"
-                                 " %14"PRId64" %11s",
-                                 upcall_info[i].percentage_avg_latency,
-                                 upcall_info[i].avg_latency,
-                                 upcall_info[i].min_latency,
-                                 upcall_info[i].max_latency,
-                                 upcall_info[i].fop_hits,
-                                 upcall_info[i].fop_name);
-                }
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-upcall-hits", count, interval, i);
+        ret = dict_get_uint64(dict, key, &upcall_info[i].fop_hits);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+        upcall_info[i].fop_name = (char *)gf_upcall_list[i];
+    }
 
-        cli_out (" ");
-        cli_out ("%12s: %"PRId64" seconds", "Duration", sec);
-        cli_out ("%12s: %"PRId64" bytes", "Data Read", r_count);
-        cli_out ("%12s: %"PRId64" bytes", "Data Written", w_count);
-        cli_out (" ");
-}
-
-int32_t
-gf_cli_profile_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                              int count, void *myframe)
-{
-        gf_cli_rsp                        rsp   = {0,};
-        int                               ret   = -1;
-        dict_t                            *dict = NULL;
-        gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
-        char                              key[256] = {0};
-        int                               interval = 0;
-        int                               i = 1;
-        int32_t                           brick_count = 0;
-        char                              *volname = NULL;
-        char                              *brick = NULL;
-        char                              str[1024] = {0,};
-        int                               stats_cleared = 0;
-        gf1_cli_info_op                   info_op = GF_CLI_INFO_NONE;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-hits", count, interval, i);
+        ret = dict_get_uint64(dict, key, &profile_info[i].fop_hits);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to profile");
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+        snprintf(key, sizeof(key), "%d-%d-%d-avglatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].avg_latency);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
+        snprintf(key, sizeof(key), "%d-%d-%d-minlatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].min_latency);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
+        snprintf(key, sizeof(key), "%d-%d-%d-maxlatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].max_latency);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
-        } else {
-                dict->extra_stdfree = rsp.dict.dict_val;
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+        profile_info[i].fop_name = (char *)gf_fop_list[i];
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_profile (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
+        total_percentage_latency += (profile_info[i].fop_hits *
+                                     profile_info[i].avg_latency);
+    }
+    if (total_percentage_latency) {
+        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+            profile_info[i]
+                .percentage_avg_latency = 100 * ((profile_info[i].avg_latency *
+                                                  profile_info[i].fop_hits) /
+                                                 total_percentage_latency);
+        }
+        gf_array_insertionsort(profile_info, 1, GF_FOP_MAXVALUE - 1,
+                               sizeof(cli_profile_info_t),
+                               cli_profile_info_percentage_cmp);
+    }
+    snprintf(key, sizeof(key), "%d-%d-duration", count, interval);
+    ret = dict_get_uint64(dict, key, &sec);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    snprintf(key, sizeof(key), "%d-%d-total-read", count, interval);
+    ret = dict_get_uint64(dict, key, &r_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    snprintf(key, sizeof(key), "%d-%d-total-write", count, interval);
+    ret = dict_get_uint64(dict, key, &w_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    if (interval == -1)
+        cli_out("Cumulative Stats:");
+    else
+        cli_out("Interval %d Stats:", interval);
+    snprintf(output, sizeof(output), "%14s", "Block Size:");
+    snprintf(read_blocks, sizeof(read_blocks), "%14s", "No. of Reads:");
+    snprintf(write_blocks, sizeof(write_blocks), "%14s", "No. of Writes:");
+    index = 14;
+    for (i = 0; i < 32; i++) {
+        if ((rb_counts[i] == 0) && (wb_counts[i] == 0))
+            continue;
+        per_line++;
+        snprintf(output + index, sizeof(output) - index, "%19" PRIu32 "b+ ",
+                 (1U << i));
+        if (rb_counts[i]) {
+            snprintf(read_blocks + index, sizeof(read_blocks) - index,
+                     "%21" PRId64 " ", rb_counts[i]);
+        } else {
+            snprintf(read_blocks + index, sizeof(read_blocks) - index, "%21s ",
+                     "0");
         }
+        if (wb_counts[i]) {
+            snprintf(write_blocks + index, sizeof(write_blocks) - index,
+                     "%21" PRId64 " ", wb_counts[i]);
+        } else {
+            snprintf(write_blocks + index, sizeof(write_blocks) - index,
+                     "%21s ", "0");
+        }
+        index += 22;
+        if (per_line == 3) {
+            cli_out("%s", output);
+            cli_out("%s", read_blocks);
+            cli_out("%s", write_blocks);
+            cli_out(" ");
+            per_line = 0;
+            snprintf(output, sizeof(output), "%14s", "Block Size:");
+            snprintf(read_blocks, sizeof(read_blocks), "%14s", "No. of Reads:");
+            snprintf(write_blocks, sizeof(write_blocks), "%14s",
+                     "No. of Writes:");
+            index = 14;
+        }
+    }
+
+    if (per_line != 0) {
+        cli_out("%s", output);
+        cli_out("%s", read_blocks);
+        cli_out("%s", write_blocks);
+    }
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        if (profile_info[i].fop_hits == 0)
+            continue;
+        if (is_header_printed == 0) {
+            cli_out("%10s %13s %13s %13s %14s %11s", "%-latency", "Avg-latency",
+                    "Min-Latency", "Max-Latency", "No. of calls", "Fop");
+            cli_out("%10s %13s %13s %13s %14s %11s", "---------", "-----------",
+                    "-----------", "-----------", "------------", "----");
+            is_header_printed = 1;
+        }
+        if (profile_info[i].fop_hits) {
+            cli_out(
+                "%10.2lf %10.2lf us %10.2lf us %10.2lf us"
+                " %14" PRId64 " %11s",
+                profile_info[i].percentage_avg_latency,
+                profile_info[i].avg_latency, profile_info[i].min_latency,
+                profile_info[i].max_latency, profile_info[i].fop_hits,
+                profile_info[i].fop_name);
+        }
+    }
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        if (upcall_info[i].fop_hits == 0)
+            continue;
+        if (upcall_info[i].fop_hits) {
+            cli_out(
+                "%10.2lf %10.2lf us %10.2lf us %10.2lf us"
+                " %14" PRId64 " %11s",
+                upcall_info[i].percentage_avg_latency,
+                upcall_info[i].avg_latency, upcall_info[i].min_latency,
+                upcall_info[i].max_latency, upcall_info[i].fop_hits,
+                upcall_info[i].fop_name);
+        }
+    }
+
+    cli_out(" ");
+    cli_out("%12s: %" PRId64 " seconds", "Duration", sec);
+    cli_out("%12s: %" PRId64 " bytes", "Data Read", r_count);
+    cli_out("%12s: %" PRId64 " bytes", "Data Written", w_count);
+    cli_out(" ");
+}
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "op", (int32_t*)&op);
+static int32_t
+gf_cli_profile_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    char key[64] = {0};
+    int len;
+    int interval = 0;
+    int i = 1;
+    int32_t brick_count = 0;
+    char *volname = NULL;
+    char *brick = NULL;
+    char str[1024] = {
+        0,
+    };
+    int stats_cleared = 0;
+    gf1_cli_info_op info_op = GF_CLI_INFO_NONE;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to profile");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_profile(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
         if (ret)
-                goto out;
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
-                cli_err ("%s", rsp.op_errstr);
-        } else {
-                switch (op) {
-                case GF_CLI_STATS_START:
-                        cli_out ("Starting volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                case GF_CLI_STATS_STOP:
-                        cli_out ("Stopping volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                case GF_CLI_STATS_INFO:
-                        break;
-                default:
-                        cli_out ("volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                }
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "op", (int32_t *)&op);
+    if (ret)
+        goto out;
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, "")) {
+        cli_err("%s", rsp.op_errstr);
+    } else {
+        switch (op) {
+            case GF_CLI_STATS_START:
+                cli_out("Starting volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
+            case GF_CLI_STATS_STOP:
+                cli_out("Stopping volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
+            case GF_CLI_STATS_INFO:
+                break;
+            default:
+                cli_out("volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
         }
+    }
 
-        if (rsp.op_ret) {
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (rsp.op_ret) {
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        if (GF_CLI_STATS_INFO != op) {
-                ret = 0;
-                goto out;
-        }
+    if (GF_CLI_STATS_INFO != op) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "info-op", (int32_t*)&info_op);
-        if (ret)
-                goto out;
+    ret = dict_get_int32_sizen(dict, "count", &brick_count);
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
+    if (!brick_count) {
+        cli_err("All bricks of volume %s are down.", volname);
+        goto out;
+    }
 
-        if (!brick_count) {
-                cli_err ("All bricks of volume %s are down.", volname);
-                goto out;
+    ret = dict_get_int32_sizen(dict, "info-op", (int32_t *)&info_op);
+    if (ret)
+        goto out;
+
+    while (i <= brick_count) {
+        len = snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_strn(dict, key, len, &brick);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get brick name");
+            goto out;
         }
 
-        while (i <= brick_count) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get brick name");
-                        goto out;
-                }
+        ret = dict_get_str_boolean(dict, "nfs", _gf_false);
 
-                ret = dict_get_str_boolean (dict, "nfs", _gf_false);
+        if (ret)
+            len = snprintf(str, sizeof(str), "NFS Server : %s", brick);
+        else
+            len = snprintf(str, sizeof(str), "Brick: %s", brick);
+        cli_out("%s", str);
+        memset(str, '-', len);
+        cli_out("%s", str);
+
+        if (GF_CLI_INFO_CLEAR == info_op) {
+            len = snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32n(dict, key, len, &stats_cleared);
+            if (ret)
+                goto out;
+            cli_out(stats_cleared ? "Cleared stats."
+                                  : "Failed to clear stats.");
+        } else {
+            len = snprintf(key, sizeof(key), "%d-cumulative", i);
+            ret = dict_get_int32n(dict, key, len, &interval);
+            if (ret == 0)
+                cmd_profile_volume_brick_out(dict, i, interval);
 
-                if (ret)
-                        snprintf (str, sizeof (str), "NFS Server : %s", brick);
-                else
-                        snprintf (str, sizeof (str), "Brick: %s", brick);
-                cli_out ("%s", str);
-                memset (str, '-', strlen (str));
-                cli_out ("%s", str);
-
-                if (GF_CLI_INFO_CLEAR == info_op) {
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-                        cli_out (stats_cleared ? "Cleared stats." :
-                                                 "Failed to clear stats.");
-                } else {
-                        snprintf (key, sizeof (key), "%d-cumulative", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0)
-                                cmd_profile_volume_brick_out (dict, i,
-                                                              interval);
-
-                        snprintf (key, sizeof (key), "%d-interval", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0)
-                                cmd_profile_volume_brick_out (dict, i,
-                                                              interval);
-                }
-                i++;
+            len = snprintf(key, sizeof(key), "%d-interval", i);
+            ret = dict_get_int32n(dict, key, len, &interval);
+            if (ret == 0)
+                cmd_profile_volume_brick_out(dict, i, interval);
         }
-        ret = rsp.op_ret;
+        i++;
+    }
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (rsp.op_errstr);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_profile_volume (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_profile_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                        ret   = -1;
-        gf_cli_req                 req   = {{0,}};
-        dict_t                     *dict = NULL;
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_profile_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_profile_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_top_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                              int count, void *myframe)
-{
-        gf_cli_rsp                        rsp   = {0,};
-        int                               ret   = -1;
-        dict_t                           *dict = NULL;
-        gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
-        char                              key[256] = {0};
-        int                               i = 0;
-        int32_t                           brick_count = 0;
-        char                              brick[1024];
-        int32_t                           members = 0;
-        char                             *filename;
-        char                             *bricks;
-        uint64_t                          value = 0;
-        int32_t                           j = 0;
-        gf1_cli_top_op                    top_op = GF_CLI_TOP_NONE;
-        uint64_t                          nr_open = 0;
-        uint64_t                          max_nr_open = 0;
-        double                            throughput = 0;
-        double                            time = 0;
-        int32_t                           time_sec = 0;
-        long int                          time_usec = 0;
-        char                              timestr[256] = {0, };
-        char                             *openfd_str = NULL;
-        gf_boolean_t                      nfs = _gf_false;
-        gf_boolean_t                      clear_stats = _gf_false;
-        int                               stats_cleared = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+static int32_t
+gf_cli_top_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    char key[256] = {0};
+    int keylen;
+    int i = 0;
+    int32_t brick_count = 0;
+    char brick[1024];
+    int32_t members = 0;
+    char *filename;
+    char *bricks;
+    uint64_t value = 0;
+    int32_t j = 0;
+    gf1_cli_top_op top_op = GF_CLI_TOP_NONE;
+    uint64_t nr_open = 0;
+    uint64_t max_nr_open = 0;
+    double throughput = 0;
+    double time = 0;
+    int32_t time_sec = 0;
+    long int time_usec = 0;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char *openfd_str = NULL;
+    gf_boolean_t nfs = _gf_false;
+    gf_boolean_t clear_stats = _gf_false;
+    int stats_cleared = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to top");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("%s", rsp.op_errstr);
+        cli_err("volume top unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to top");
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    dict = dict_new();
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("%s", rsp.op_errstr);
-                cli_err ("volume top unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = dict_new ();
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "op", (int32_t *)&op);
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
+    if (op != GF_CLI_STATS_TOP) {
+        ret = 0;
+        goto out;
+    }
 
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_top(dict, rsp.op_ret, rsp.op_errno,
+                                     rsp.op_errstr);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
         }
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "op", (int32_t*)&op);
+    ret = dict_get_int32_sizen(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    keylen = snprintf(key, sizeof(key), "%d-top-op", 1);
+    ret = dict_get_int32n(dict, key, keylen, (int32_t *)&top_op);
+    if (ret)
+        goto out;
 
-        if (op != GF_CLI_STATS_TOP) {
-                ret = 0;
+    clear_stats = dict_get_str_boolean(dict, "clear-stats", _gf_false);
+
+    while (i < brick_count) {
+        i++;
+        keylen = snprintf(brick, sizeof(brick), "%d-brick", i);
+        ret = dict_get_strn(dict, brick, keylen, &bricks);
+        if (ret)
+            goto out;
+
+        nfs = dict_get_str_boolean(dict, "nfs", _gf_false);
+
+        if (clear_stats) {
+            keylen = snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32n(dict, key, keylen, &stats_cleared);
+            if (ret)
                 goto out;
+            cli_out(stats_cleared ? "Cleared stats for %s %s"
+                                  : "Failed to clear stats for %s %s",
+                    nfs ? "NFS server on" : "brick", bricks);
+            continue;
         }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_top (dict, rsp.op_ret,
-                                              rsp.op_errno,
-                                              rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+        if (nfs)
+            cli_out("NFS Server : %s", bricks);
+        else
+            cli_out("Brick: %s", bricks);
+
+        keylen = snprintf(key, sizeof(key), "%d-members", i);
+        ret = dict_get_int32n(dict, key, keylen, &members);
+
+        switch (top_op) {
+            case GF_CLI_TOP_OPEN:
+                snprintf(key, sizeof(key), "%d-current-open", i);
+                ret = dict_get_uint64(dict, key, &nr_open);
+                if (ret)
+                    break;
+                snprintf(key, sizeof(key), "%d-max-open", i);
+                ret = dict_get_uint64(dict, key, &max_nr_open);
+                if (ret)
+                    goto out;
+                keylen = snprintf(key, sizeof(key), "%d-max-openfd-time", i);
+                ret = dict_get_strn(dict, key, keylen, &openfd_str);
+                if (ret)
+                    goto out;
+                cli_out("Current open fds: %" PRIu64 ", Max open fds: %" PRIu64
+                        ", Max openfd time: %s",
+                        nr_open, max_nr_open, openfd_str);
+            case GF_CLI_TOP_READ:
+            case GF_CLI_TOP_WRITE:
+            case GF_CLI_TOP_OPENDIR:
+            case GF_CLI_TOP_READDIR:
+                if (!members) {
+                    continue;
+                }
+                cli_out("Count\t\tfilename\n=======================");
+                break;
+            case GF_CLI_TOP_READ_PERF:
+            case GF_CLI_TOP_WRITE_PERF:
+                snprintf(key, sizeof(key), "%d-throughput", i);
+                ret = dict_get_double(dict, key, &throughput);
+                if (!ret) {
+                    snprintf(key, sizeof(key), "%d-time", i);
+                    ret = dict_get_double(dict, key, &time);
                 }
+                if (!ret)
+                    cli_out("Throughput %.2f MBps time %.4f secs", throughput,
+                            time / 1e6);
+
+                if (!members) {
+                    continue;
+                }
+                cli_out("%*s %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH, "MBps",
+                        VOL_TOP_PERF_FILENAME_DEF_WIDTH, "Filename",
+                        VOL_TOP_PERF_TIME_WIDTH, "Time");
+                cli_out("%*s %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH,
+                        "====", VOL_TOP_PERF_FILENAME_DEF_WIDTH,
+                        "========", VOL_TOP_PERF_TIME_WIDTH, "====");
+                break;
+            default:
                 goto out;
         }
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof (key), "%d-top-op", 1);
-        ret = dict_get_int32 (dict, key, (int32_t*)&top_op);
-        if (ret)
-                goto out;
-
-        clear_stats = dict_get_str_boolean (dict, "clear-stats", _gf_false);
-
-        while (i < brick_count) {
-                i++;
-                snprintf (brick, sizeof (brick), "%d-brick", i);
-                ret = dict_get_str (dict, brick, &bricks);
-                if (ret)
-                        goto out;
-
-                nfs = dict_get_str_boolean (dict, "nfs", _gf_false);
-
-                if (clear_stats) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-                        cli_out (stats_cleared ? "Cleared stats for %s %s" :
-                                 "Failed to clear stats for %s %s",
-                                 nfs ? "NFS server on" : "brick", bricks);
-                        continue;
-                }
-
-                if (nfs)
-                        cli_out ("NFS Server : %s", bricks);
+        for (j = 1; j <= members; j++) {
+            keylen = snprintf(key, sizeof(key), "%d-filename-%d", i, j);
+            ret = dict_get_strn(dict, key, keylen, &filename);
+            if (ret)
+                break;
+            snprintf(key, sizeof(key), "%d-value-%d", i, j);
+            ret = dict_get_uint64(dict, key, &value);
+            if (ret)
+                goto out;
+            if (top_op == GF_CLI_TOP_READ_PERF ||
+                top_op == GF_CLI_TOP_WRITE_PERF) {
+                keylen = snprintf(key, sizeof(key), "%d-time-sec-%d", i, j);
+                ret = dict_get_int32n(dict, key, keylen, (int32_t *)&time_sec);
+                if (ret)
+                    goto out;
+                keylen = snprintf(key, sizeof(key), "%d-time-usec-%d", i, j);
+                ret = dict_get_int32n(dict, key, keylen, (int32_t *)&time_usec);
+                if (ret)
+                    goto out;
+                gf_time_fmt(timestr, sizeof timestr, time_sec, gf_timefmt_FT);
+                snprintf(timestr + strlen(timestr),
+                         sizeof timestr - strlen(timestr), ".%ld", time_usec);
+                if (strlen(filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH)
+                    cli_out("%*" PRIu64 " %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH,
+                            value, VOL_TOP_PERF_FILENAME_DEF_WIDTH, filename,
+                            VOL_TOP_PERF_TIME_WIDTH, timestr);
                 else
-                        cli_out ("Brick: %s", bricks);
-
-                snprintf(key, sizeof (key), "%d-members", i);
-                ret = dict_get_int32 (dict, key, &members);
-
-                switch (top_op) {
-                case GF_CLI_TOP_OPEN:
-                        snprintf (key, sizeof (key), "%d-current-open", i);
-                        ret = dict_get_uint64 (dict, key, &nr_open);
-                        if (ret)
-                                break;
-                        snprintf (key, sizeof (key), "%d-max-open", i);
-                        ret = dict_get_uint64 (dict, key, &max_nr_open);
-                        if (ret)
-                                goto out;
-                        snprintf (key, sizeof (key), "%d-max-openfd-time", i);
-                        ret = dict_get_str (dict, key, &openfd_str);
-                        if (ret)
-                                goto out;
-                        cli_out ("Current open fds: %"PRIu64", Max open"
-                                " fds: %"PRIu64", Max openfd time: %s", nr_open,
-                                 max_nr_open, openfd_str);
-                case GF_CLI_TOP_READ:
-                case GF_CLI_TOP_WRITE:
-                case GF_CLI_TOP_OPENDIR:
-                case GF_CLI_TOP_READDIR:
-                        if (!members) {
-                                continue;
-                        }
-                        cli_out ("Count\t\tfilename\n=======================");
-                        break;
-                case GF_CLI_TOP_READ_PERF:
-                case GF_CLI_TOP_WRITE_PERF:
-                        snprintf (key, sizeof (key), "%d-throughput", i);
-                        ret = dict_get_double (dict, key, &throughput);
-                        if (!ret) {
-                                snprintf (key, sizeof (key), "%d-time", i);
-                                ret = dict_get_double (dict, key, &time);
-                        }
-                        if (!ret)
-                                cli_out ("Throughput %.2f MBps time %.4f secs", throughput,
-                                          time / 1e6);
-
-                        if (!members) {
-                                continue;
-                        }
-                        cli_out ("%*s %-*s %-*s",
-                                 VOL_TOP_PERF_SPEED_WIDTH, "MBps",
-                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH, "Filename",
-                                 VOL_TOP_PERF_TIME_WIDTH, "Time");
-                        cli_out ("%*s %-*s %-*s",
-                                 VOL_TOP_PERF_SPEED_WIDTH, "====",
-                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH, "========",
-                                 VOL_TOP_PERF_TIME_WIDTH, "====");
-                        break;
-                default:
-                        goto out;
-                }
-
-                for (j = 1; j <= members; j++) {
-                        snprintf (key, sizeof (key), "%d-filename-%d", i, j);
-                        ret = dict_get_str (dict, key, &filename);
-                        if (ret)
-                                break;
-                        snprintf (key, sizeof (key), "%d-value-%d", i, j);
-                        ret = dict_get_uint64 (dict, key, &value);
-                        if (ret)
-                                goto out;
-                        if ( top_op == GF_CLI_TOP_READ_PERF ||
-                                top_op == GF_CLI_TOP_WRITE_PERF) {
-                                snprintf (key, sizeof (key), "%d-time-sec-%d", i, j);
-                                ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
-                                if (ret)
-                                        goto out;
-                                snprintf (key, sizeof (key), "%d-time-usec-%d", i, j);
-                                ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
-                                if (ret)
-                                        goto out;
-                                gf_time_fmt (timestr, sizeof timestr,
-                                             time_sec, gf_timefmt_FT);
-                                snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                                  ".%ld", time_usec);
-                                if (strlen (filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH)
-                                        cli_out ("%*"PRIu64" %-*s %-*s",
-                                                 VOL_TOP_PERF_SPEED_WIDTH,
-                                                 value,
-                                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH,
-                                                 filename,
-                                                 VOL_TOP_PERF_TIME_WIDTH,
-                                                 timestr);
-                                else
-                                        cli_out ("%*"PRIu64" ...%-*s %-*s",
-                                                 VOL_TOP_PERF_SPEED_WIDTH,
-                                                 value,
-                                                 VOL_TOP_PERF_FILENAME_ALT_WIDTH ,
-                                                 filename + strlen (filename) -
-                                                 VOL_TOP_PERF_FILENAME_ALT_WIDTH,
-                                                 VOL_TOP_PERF_TIME_WIDTH,
-                                                 timestr);
-                        } else {
-                                cli_out ("%"PRIu64"\t\t%s", value, filename);
-                        }
-                }
+                    cli_out("%*" PRIu64 " ...%-*s %-*s",
+                            VOL_TOP_PERF_SPEED_WIDTH, value,
+                            VOL_TOP_PERF_FILENAME_ALT_WIDTH,
+                            filename + strlen(filename) -
+                                VOL_TOP_PERF_FILENAME_ALT_WIDTH,
+                            VOL_TOP_PERF_TIME_WIDTH, timestr);
+            } else {
+                cli_out("%" PRIu64 "\t\t%s", value, filename);
+            }
         }
-        ret = rsp.op_ret;
+    }
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
-        return ret;
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_top_volume (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_top_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                        ret   = -1;
-        gf_cli_req                 req   = {{0,}};
-        dict_t                     *dict = NULL;
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_top_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    dict = data;
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    ret = cli_to_glusterd(&req, frame, gf_cli_top_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-
-int
-gf_cli_getwd_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
+static int
+gf_cli_getwd_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf1_cli_getwd_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_getwd_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_getwd_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_getwd_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                cli_err ("getwd failed");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        cli_err("getwd failed");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to getwd");
+    gf_log("cli", GF_LOG_INFO, "Received resp to getwd");
 
-        cli_out ("%s", rsp.wd);
+    cli_out("%s", rsp.wd);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    if (rsp.wd) {
+        free(rsp.wd);
+    }
+
+    return ret;
 }
 
-int32_t
-gf_cli_getwd (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_getwd(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret = -1;
-        gf1_cli_getwd_req        req = {0,};
+    int ret = -1;
+    gf1_cli_getwd_req req = {
+        0,
+    };
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
 
-        if (!frame || !this)
-                goto out;
+    if (!frame || !this)
+        goto out;
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_GETWD, NULL,
-                              this, gf_cli_getwd_cbk,
-                              (xdrproc_t) xdr_gf1_cli_getwd_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_GETWD,
+                         NULL, this, gf_cli_getwd_cbk,
+                         (xdrproc_t)xdr_gf1_cli_getwd_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        return ret;
+    return ret;
 }
 
-void
-cli_print_volume_status_mempool (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        int32_t         mempool_count = 0;
-        char            *name = NULL;
-        int32_t         hotcount = 0;
-        int32_t         coldcount = 0;
-        uint64_t        paddedsizeof = 0;
-        uint64_t        alloccount = 0;
-        int32_t         maxalloc = 0;
-        uint64_t        pool_misses = 0;
-        int32_t         maxstdalloc = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.mempool-count",prefix);
-        ret = dict_get_int32 (dict, key, &mempool_count);
+static void
+cli_print_volume_status_mempool(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    int32_t mempool_count = 0;
+    char *name = NULL;
+    int32_t hotcount = 0;
+    int32_t coldcount = 0;
+    uint64_t paddedsizeof = 0;
+    uint64_t alloccount = 0;
+    int32_t maxalloc = 0;
+    uint64_t pool_misses = 0;
+    int32_t maxstdalloc = 0;
+    char key[128] = {
+        /* prefix is really small 'brick%d' really */
+        0,
+    };
+    int keylen;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    keylen = snprintf(key, sizeof(key), "%s.mempool-count", prefix);
+    ret = dict_get_int32n(dict, key, keylen, &mempool_count);
+    if (ret)
+        goto out;
+
+    cli_out("Mempool Stats\n-------------");
+    cli_out("%-30s %9s %9s %12s %10s %8s %8s %12s", "Name", "HotCount",
+            "ColdCount", "PaddedSizeof", "AllocCount", "MaxAlloc", "Misses",
+            "Max-StdAlloc");
+    cli_out("%-30s %9s %9s %12s %10s %8s %8s %12s", "----", "--------",
+            "---------", "------------", "----------", "--------", "--------",
+            "------------");
+
+    for (i = 0; i < mempool_count; i++) {
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.name", prefix, i);
+        ret = dict_get_strn(dict, key, keylen, &name);
         if (ret)
-                goto out;
-
-        cli_out ("Mempool Stats\n-------------");
-        cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "Name", "HotCount",
-                 "ColdCount", "PaddedSizeof", "AllocCount", "MaxAlloc",
-                 "Misses", "Max-StdAlloc");
-        cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "----", "--------",
-                 "---------", "------------", "----------",
-                 "--------", "--------", "------------");
-
-        for (i = 0; i < mempool_count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
-                ret = dict_get_str (dict, key, &name);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &hotcount);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &coldcount);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
-                          prefix, i);
-                ret = dict_get_uint64 (dict, key, &paddedsizeof);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxstdalloc);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
-                ret = dict_get_uint64 (dict, key, &pool_misses);
-                if (ret)
-                        goto out;
-
-                cli_out ("%-30s %9d %9d %12"PRIu64" %10"PRIu64" %8d %8"PRIu64
-                         " %12d", name, hotcount, coldcount, paddedsizeof,
-                         alloccount, maxalloc, pool_misses, maxstdalloc);
-        }
-
-out:
-        return;
-
-}
-
-void
-cli_print_volume_status_mem (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        char            key[1024] = {0,};
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        int             val = 0;
-        int             i = 0;
-
-        GF_ASSERT (dict);
+            goto out;
 
-        ret = dict_get_str (dict, "volname", &volname);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.hotcount", prefix, i);
+        ret = dict_get_int32n(dict, key, keylen, &hotcount);
         if (ret)
-                goto out;
-        cli_out ("Memory status for volume : %s", volname);
+            goto out;
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.coldcount", prefix, i);
+        ret = dict_get_int32n(dict, key, keylen, &coldcount);
         if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
-
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        continue;
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        continue;
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
-
-                cli_out ("Mallinfo\n--------");
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.arena", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d","Arena", val);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d","Ordblks", val);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d","Smblks", val);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Hblks", val);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Hblkhd", val);
+        snprintf(key, sizeof(key), "%s.pool%d.paddedsizeof", prefix, i);
+        ret = dict_get_uint64(dict, key, &paddedsizeof);
+        if (ret)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Usmblks", val);
+        snprintf(key, sizeof(key), "%s.pool%d.alloccount", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
+        if (ret)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Fsmblks", val);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.max_alloc", prefix, i);
+        ret = dict_get_int32n(dict, key, keylen, &maxalloc);
+        if (ret)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Uordblks", val);
+        keylen = snprintf(key, sizeof(key), "%s.pool%d.max-stdalloc", prefix,
+                          i);
+        ret = dict_get_int32n(dict, key, keylen, &maxstdalloc);
+        if (ret)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Fordblks", val);
+        snprintf(key, sizeof(key), "%s.pool%d.pool-misses", prefix, i);
+        ret = dict_get_uint64(dict, key, &pool_misses);
+        if (ret)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Keepcost", val);
+        cli_out("%-30s %9d %9d %12" PRIu64 " %10" PRIu64 " %8d %8" PRIu64
+                " %12d",
+                name, hotcount, coldcount, paddedsizeof, alloccount, maxalloc,
+                pool_misses, maxstdalloc);
+    }
 
-                cli_out (" ");
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d", i);
-                cli_print_volume_status_mempool (dict, key);
-        }
 out:
-        cli_out ("----------------------------------------------\n");
-        return;
+    return;
 }
 
-void
-cli_print_volume_status_clients (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             client_count = 0;
-        char            *clientname = NULL;
-        uint64_t        bytesread = 0;
-        uint64_t        byteswrite = 0;
-        uint32_t        opversion = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("Client connections for volume %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+static void
+cli_print_volume_status_mem(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    char key[64] = {
+        0,
+    };
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    int val = 0;
+    int i = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Memory status for volume : %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+            continue;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
+            continue;
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-        for (i = 0; i <= index_max; i++) {
-                hostname = NULL;
-                path = NULL;
-                online = -1;
-                client_count = 0;
-                clientname = NULL;
-                bytesread = 0;
-                byteswrite = 0;
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (ret)
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
 
-                cli_out ("----------------------------------------------");
+        cli_out("Mallinfo\n--------");
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.arena", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Arena", val);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.ordblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Ordblks", val);
 
-                if (hostname && path) {
-                        if (notbrick)
-                                cli_out ("%s : %s", hostname, path);
-                        else
-                                cli_out ("Brick : %s:%s", hostname, path);
-                }
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+        snprintf(key, sizeof(key), "brick%d.mallinfo.smblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Smblks", val);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.clientcount", i);
-                ret = dict_get_int32 (dict, key, &client_count);
-
-                if (hostname && path)
-                        cli_out ("Clients connected : %d", client_count);
-                if (client_count == 0)
-                        continue;
-
-                cli_out ("%-48s %15s %15s %15s", "Hostname", "BytesRead",
-                         "BytesWritten", "OpVersion");
-                cli_out ("%-48s %15s %15s %15s", "--------", "---------",
-                         "------------", "---------");
-                for (j =0; j < client_count; j++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                  "brick%d.client%d.hostname", i, j);
-                        ret = dict_get_str (dict, key, &clientname);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                  "brick%d.client%d.bytesread", i, j);
-                        ret = dict_get_uint64 (dict, key, &bytesread);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                 "brick%d.client%d.byteswrite", i, j);
-                        ret = dict_get_uint64 (dict, key, &byteswrite);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                 "brick%d.client%d.opversion", i, j);
-                        ret = dict_get_uint32 (dict, key, &opversion);
-
-                        cli_out ("%-48s %15"PRIu64" %15"PRIu64" %15"PRIu32,
-                                  clientname, bytesread, byteswrite,
-                                  opversion);
-                }
-        }
-out:
-        cli_out ("----------------------------------------------\n");
-        return;
-}
+        snprintf(key, sizeof(key), "brick%d.mallinfo.hblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Hblks", val);
 
-void
-cli_print_volume_status_inode_entry (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        char            *gfid = NULL;
-        uint64_t        nlookup = 0;
-        uint32_t        ref = 0;
-        int             ia_type = 0;
-        char            inode_type;
+        snprintf(key, sizeof(key), "brick%d.mallinfo.hblkhd", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Hblkhd", val);
 
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.usmblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Usmblks", val);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_get_str (dict, key, &gfid);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.fsmblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Fsmblks", val);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_get_uint64 (dict, key, &nlookup);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.uordblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Uordblks", val);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_get_uint32 (dict, key, &ref);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.fordblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Fordblks", val);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_get_int32 (dict, key, &ia_type);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.keepcost", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Keepcost", val);
+
+        cli_out(" ");
+        snprintf(key, sizeof(key), "brick%d", i);
+        cli_print_volume_status_mempool(dict, key);
+    }
+out:
+    cli_out("----------------------------------------------\n");
+    return;
+}
+
+static void
+cli_print_volume_status_client_list(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int client_count = 0;
+    int current_count = 0;
+    char key[64] = {
+        0,
+    };
+    int i = 0;
+    int total = 0;
+    char *name = NULL;
+    gf_boolean_t is_fuse_done = _gf_false;
+    gf_boolean_t is_gfapi_done = _gf_false;
+    gf_boolean_t is_rebalance_done = _gf_false;
+    gf_boolean_t is_glustershd_done = _gf_false;
+    gf_boolean_t is_quotad_done = _gf_false;
+    gf_boolean_t is_snapd_done = _gf_false;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Client connections for volume %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "client-count", &client_count);
+    if (ret)
+        goto out;
+
+    cli_out("%-48s %15s", "Name", "count");
+    cli_out("%-48s %15s", "-----", "------");
+    for (i = 0; i < client_count; i++) {
+        name = NULL;
+        snprintf(key, sizeof(key), "client%d.name", i);
+        ret = dict_get_str(dict, key, &name);
+
+        if (!strncmp(name, "fuse", 4)) {
+            if (!is_fuse_done) {
+                is_fuse_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "fuse-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strncmp(name, "gfapi", 5)) {
+            if (!is_gfapi_done) {
+                is_gfapi_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "gfapi-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "rebalance")) {
+            if (!is_rebalance_done) {
+                is_rebalance_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "rebalance-count",
+                                           &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "glustershd")) {
+            if (!is_glustershd_done) {
+                is_glustershd_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "glustershd-count",
+                                           &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "quotad")) {
+            if (!is_quotad_done) {
+                is_quotad_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "quotad-count",
+                                           &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "snapd")) {
+            if (!is_snapd_done) {
+                is_snapd_done = _gf_true;
+                ret = dict_get_int32_sizen(dict, "snapd-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        }
+
+    print:
+        cli_out("%-48s %15d", name, current_count);
+    }
+out:
+    cli_out("\ntotal clients for volume %s : %d ", volname, total);
+    cli_out(
+        "-----------------------------------------------------------------\n");
+    return;
+}
 
-        switch (ia_type) {
+static void
+cli_print_volume_status_clients(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int client_count = 0;
+    char *clientname = NULL;
+    uint64_t bytesread = 0;
+    uint64_t byteswrite = 0;
+    uint32_t opversion = 0;
+    char key[128] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Client connections for volume %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        hostname = NULL;
+        path = NULL;
+        online = -1;
+        client_count = 0;
+        clientname = NULL;
+        bytesread = 0;
+        byteswrite = 0;
+
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
+
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
+
+        if (hostname && path) {
+            if (notbrick)
+                cli_out("%s : %s", hostname, path);
+            else
+                cli_out("Brick : %s:%s", hostname, path);
+        }
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
+
+        snprintf(key, sizeof(key), "brick%d.clientcount", i);
+        ret = dict_get_int32(dict, key, &client_count);
+
+        if (hostname && path)
+            cli_out("Clients connected : %d", client_count);
+        if (client_count == 0)
+            continue;
+
+        cli_out("%-48s %15s %15s %15s", "Hostname", "BytesRead", "BytesWritten",
+                "OpVersion");
+        cli_out("%-48s %15s %15s %15s", "--------", "---------", "------------",
+                "---------");
+        for (j = 0; j < client_count; j++) {
+            snprintf(key, sizeof(key), "brick%d.client%d.hostname", i, j);
+            ret = dict_get_str(dict, key, &clientname);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.bytesread", i, j);
+            ret = dict_get_uint64(dict, key, &bytesread);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.byteswrite", i, j);
+            ret = dict_get_uint64(dict, key, &byteswrite);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.opversion", i, j);
+            ret = dict_get_uint32(dict, key, &opversion);
+
+            cli_out("%-48s %15" PRIu64 " %15" PRIu64 " %15" PRIu32, clientname,
+                    bytesread, byteswrite, opversion);
+        }
+    }
+out:
+    cli_out("----------------------------------------------\n");
+    return;
+}
+
+#ifdef DEBUG /* this function is only used in debug */
+static void
+cli_print_volume_status_inode_entry(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    char *gfid = NULL;
+    uint64_t nlookup = 0;
+    uint32_t ref = 0;
+    int ia_type = 0;
+    char inode_type;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_get_str(dict, key, &gfid);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    ret = dict_get_uint64(dict, key, &nlookup);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_get_uint32(dict, key, &ref);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_get_int32(dict, key, &ia_type);
+    if (ret)
+        goto out;
+
+    switch (ia_type) {
         case IA_IFREG:
-                inode_type = 'R';
-                break;
+            inode_type = 'R';
+            break;
         case IA_IFDIR:
-                inode_type = 'D';
-                break;
+            inode_type = 'D';
+            break;
         case IA_IFLNK:
-                inode_type = 'L';
-                break;
+            inode_type = 'L';
+            break;
         case IA_IFBLK:
-                inode_type = 'B';
-                break;
+            inode_type = 'B';
+            break;
         case IA_IFCHR:
-                inode_type = 'C';
-                break;
+            inode_type = 'C';
+            break;
         case IA_IFIFO:
-                inode_type = 'F';
-                break;
+            inode_type = 'F';
+            break;
         case IA_IFSOCK:
-                inode_type = 'S';
-                break;
+            inode_type = 'S';
+            break;
         default:
-                inode_type = 'I';
-                break;
-        }
+            inode_type = 'I';
+            break;
+    }
 
-        cli_out ("%-40s %14"PRIu64" %14"PRIu32" %9c",
-                 gfid, nlookup, ref, inode_type);
+    cli_out("%-40s %14" PRIu64 " %14" PRIu32 " %9c", gfid, nlookup, ref,
+            inode_type);
 
 out:
-        return;
-
+    return;
 }
+#endif
 
-void
-cli_print_volume_status_itables (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        uint32_t        active_size = 0;
-        uint32_t        lru_size = 0;
-        uint32_t        purge_size = 0;
-        int             i =0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
+static void
+cli_print_volume_status_itables(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    uint32_t active_size = 0;
+    uint32_t lru_size = 0;
+    uint32_t purge_size = 0;
+    uint32_t lru_limit = 0;
+#ifdef DEBUG
+    int i = 0;
+#endif
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.lru_limit", prefix);
+    ret = dict_get_uint32(dict, key, &lru_limit);
+    if (ret)
+        goto out;
+    cli_out("LRU limit     : %u", lru_limit);
+
+    snprintf(key, sizeof(key), "%s.active_size", prefix);
+    ret = dict_get_uint32(dict, key, &active_size);
+    if (ret)
+        goto out;
+
+#ifdef DEBUG
+    if (active_size != 0) {
+        cli_out("Active inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < active_size; i++) {
+        snprintf(key, sizeof(key), "%s.active%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+    cli_out(" ");
+#else
+    cli_out("Active Inodes : %u", active_size);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.active_size", prefix);
-        ret = dict_get_uint32 (dict, key, &active_size);
-        if (ret)
-                goto out;
-        if (active_size != 0) {
-                cli_out ("Active inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < active_size; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.active%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
-        cli_out (" ");
+#endif
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.lru_size", prefix);
-        ret = dict_get_uint32 (dict, key, &lru_size);
-        if (ret)
-                goto out;
-        if (lru_size != 0) {
-                cli_out ("LRU inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < lru_size; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
-        cli_out (" ");
+    snprintf(key, sizeof(key), "%s.lru_size", prefix);
+    ret = dict_get_uint32(dict, key, &lru_size);
+    if (ret)
+        goto out;
+
+#ifdef DEBUG
+    if (lru_size != 0) {
+        cli_out("LRU inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < lru_size; i++) {
+        snprintf(key, sizeof(key), "%s.lru%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+    cli_out(" ");
+#else
+    cli_out("LRU Inodes    : %u", lru_size);
+#endif
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.purge_size", prefix);
-        ret = dict_get_uint32 (dict, key, &purge_size);
-        if (ret)
-                goto out;
-        if (purge_size != 0) {
-                cli_out ("Purged inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < purge_size; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
+    snprintf(key, sizeof(key), "%s.purge_size", prefix);
+    ret = dict_get_uint32(dict, key, &purge_size);
+    if (ret)
+        goto out;
+#ifdef DEBUG
+    if (purge_size != 0) {
+        cli_out("Purged inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < purge_size; i++) {
+        snprintf(key, sizeof(key), "%s.purge%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+#else
+    cli_out("Purge Inodes  : %u", purge_size);
+#endif
 
 out:
-        return;
+    return;
 }
 
-void
-cli_print_volume_status_inode (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
+static void
+cli_print_volume_status_inode(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int conn_count = 0;
+    char key[64] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Inode tables for volume %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        cli_out ("Inode tables for volume %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
-
-        for ( i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
+            goto out;
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (ret)
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.conncount", i);
-                ret = dict_get_int32 (dict, key, &conn_count);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "brick%d.conncount", i);
+        ret = dict_get_int32(dict, key, &conn_count);
+        if (ret)
+            goto out;
 
-                for (j = 0; j < conn_count; j++) {
-                        if (conn_count > 1)
-                                cli_out ("Connection %d:", j+1);
+        for (j = 0; j < conn_count; j++) {
+            if (conn_count > 1)
+                cli_out("Connection %d:", j + 1);
 
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "brick%d.conn%d.itable",
-                                  i, j);
-                        cli_print_volume_status_itables (dict, key);
-                        cli_out (" ");
-                }
+            snprintf(key, sizeof(key), "brick%d.conn%d.itable", i, j);
+            cli_print_volume_status_itables(dict, key);
+            cli_out(" ");
         }
+    }
 out:
-        cli_out ("----------------------------------------------");
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
 void
-cli_print_volume_status_fdtable (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             refcount = 0;
-        uint32_t        maxfds = 0;
-        int             firstfree = 0;
-        int             openfds = 0;
-        int             fd_pid = 0;
-        int             fd_refcount = 0;
-        int             fd_flags = 0;
-        int             i = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &refcount);
+cli_print_volume_status_fdtable(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[256] = {
+        0,
+    };
+    int refcount = 0;
+    uint32_t maxfds = 0;
+    int firstfree = 0;
+    int openfds = 0;
+    int fd_pid = 0;
+    int fd_refcount = 0;
+    int fd_flags = 0;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &refcount);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.maxfds", prefix);
+    ret = dict_get_uint32(dict, key, &maxfds);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.firstfree", prefix);
+    ret = dict_get_int32(dict, key, &firstfree);
+    if (ret)
+        goto out;
+
+    cli_out("RefCount = %d  MaxFDs = %d  FirstFree = %d", refcount, maxfds,
+            firstfree);
+
+    snprintf(key, sizeof(key), "%s.openfds", prefix);
+    ret = dict_get_int32(dict, key, &openfds);
+    if (ret)
+        goto out;
+    if (0 == openfds) {
+        cli_err("No open fds");
+        goto out;
+    }
+
+    cli_out("%-19s %-19s %-19s %-19s", "FD Entry", "PID", "RefCount", "Flags");
+    cli_out("%-19s %-19s %-19s %-19s", "--------", "---", "--------", "-----");
+
+    for (i = 0; i < maxfds; i++) {
+        snprintf(key, sizeof(key), "%s.fdentry%d.pid", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_pid);
         if (ret)
-                goto out;
+            continue;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.maxfds", prefix);
-        ret = dict_get_uint32 (dict, key, &maxfds);
+        snprintf(key, sizeof(key), "%s.fdentry%d.refcount", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_refcount);
         if (ret)
-                goto out;
+            continue;
 
-        memset (key, 0 ,sizeof (key));
-        snprintf (key, sizeof (key), "%s.firstfree", prefix);
-        ret = dict_get_int32 (dict, key, &firstfree);
+        snprintf(key, sizeof(key), "%s.fdentry%d.flags", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_flags);
         if (ret)
-                goto out;
+            continue;
 
-        cli_out ("RefCount = %d  MaxFDs = %d  FirstFree = %d",
-                 refcount, maxfds, firstfree);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.openfds", prefix);
-        ret = dict_get_int32 (dict, key, &openfds);
-        if (ret)
-                goto out;
-        if (0 == openfds) {
-                cli_err ("No open fds");
-                goto out;
-        }
-
-        cli_out ("%-19s %-19s %-19s %-19s", "FD Entry", "PID",
-                 "RefCount", "Flags");
-        cli_out ("%-19s %-19s %-19s %-19s", "--------", "---",
-                 "--------", "-----");
-
-        for (i = 0; i < maxfds ; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_pid);
-                if (ret)
-                        continue;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
-                          prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_refcount);
-                if (ret)
-                        continue;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_flags);
-                if (ret)
-                        continue;
-
-                cli_out ("%-19d %-19d %-19d %-19d", i, fd_pid, fd_refcount,
-                         fd_flags);
-        }
+        cli_out("%-19d %-19d %-19d %-19d", i, fd_pid, fd_refcount, fd_flags);
+    }
 
 out:
-        return;
+    return;
 }
 
-void
-cli_print_volume_status_fd (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("FD tables for volume %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+static void
+cli_print_volume_status_fd(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int conn_count = 0;
+    char key[64] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("FD tables for volume %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
+            goto out;
 
-        index_max = brick_index_max + other_count;
-
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
-
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (ret)
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.conncount", i);
-                ret = dict_get_int32 (dict, key, &conn_count);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "brick%d.conncount", i);
+        ret = dict_get_int32(dict, key, &conn_count);
+        if (ret)
+            goto out;
 
-                for (j = 0; j < conn_count; j++) {
-                        cli_out ("Connection %d:", j+1);
+        for (j = 0; j < conn_count; j++) {
+            cli_out("Connection %d:", j + 1);
 
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
-                                  i, j);
-                        cli_print_volume_status_fdtable (dict, key);
-                        cli_out (" ");
-                }
+            snprintf(key, sizeof(key), "brick%d.conn%d.fdtable", i, j);
+            cli_print_volume_status_fdtable(dict, key);
+            cli_out(" ");
         }
+    }
 out:
-        cli_out ("----------------------------------------------");
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
-void
-cli_print_volume_status_call_frame (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             ref_count = 0;
-        char            *translator = 0;
-        int             complete = 0;
-        char            *parent = NULL;
-        char            *wind_from = NULL;
-        char            *wind_to = NULL;
-        char            *unwind_from = NULL;
-        char            *unwind_to = NULL;
-
-        if (!dict || !prefix)
-                return;
+static void
+cli_print_volume_status_call_frame(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int ref_count = 0;
+    char *translator = 0;
+    int complete = 0;
+    char *parent = NULL;
+    char *wind_from = NULL;
+    char *wind_to = NULL;
+    char *unwind_from = NULL;
+    char *unwind_to = NULL;
+
+    if (!dict || !prefix)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &ref_count);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &ref_count);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_get_str (dict, key, &translator);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_get_str(dict, key, &translator);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_get_int32 (dict, key, &complete);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_get_int32(dict, key, &complete);
+    if (ret)
+        return;
 
-        cli_out ("  Ref Count   = %d", ref_count);
-        cli_out ("  Translator  = %s", translator);
-        cli_out ("  Completed   = %s", (complete ? "Yes" : "No"));
+    cli_out("  Ref Count   = %d", ref_count);
+    cli_out("  Translator  = %s", translator);
+    cli_out("  Completed   = %s", (complete ? "Yes" : "No"));
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.parent", prefix);
-        ret = dict_get_str (dict, key, &parent);
-        if (!ret)
-                cli_out ("  Parent      = %s", parent);
+    snprintf(key, sizeof(key), "%s.parent", prefix);
+    ret = dict_get_str(dict, key, &parent);
+    if (!ret)
+        cli_out("  Parent      = %s", parent);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.windfrom", prefix);
-        ret = dict_get_str (dict, key, &wind_from);
-        if (!ret)
-                cli_out ("  Wind From   = %s", wind_from);
+    snprintf(key, sizeof(key), "%s.windfrom", prefix);
+    ret = dict_get_str(dict, key, &wind_from);
+    if (!ret)
+        cli_out("  Wind From   = %s", wind_from);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.windto", prefix);
-        ret = dict_get_str (dict, key, &wind_to);
-        if (!ret)
-                cli_out ("  Wind To     = %s", wind_to);
+    snprintf(key, sizeof(key), "%s.windto", prefix);
+    ret = dict_get_str(dict, key, &wind_to);
+    if (!ret)
+        cli_out("  Wind To     = %s", wind_to);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-        ret = dict_get_str (dict, key, &unwind_from);
-        if (!ret)
-                cli_out ("  Unwind From = %s", unwind_from);
+    snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+    ret = dict_get_str(dict, key, &unwind_from);
+    if (!ret)
+        cli_out("  Unwind From = %s", unwind_from);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unwindto", prefix);
-        ret = dict_get_str (dict, key, &unwind_to);
-        if (!ret)
-                cli_out ("  Unwind To   = %s", unwind_to);
+    snprintf(key, sizeof(key), "%s.unwindto", prefix);
+    ret = dict_get_str(dict, key, &unwind_to);
+    if (!ret)
+        cli_out("  Unwind To   = %s", unwind_to);
 }
 
-void
-cli_print_volume_status_call_stack (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             uid = 0;
-        int             gid = 0;
-        int             pid = 0;
-        uint64_t        unique = 0;
-        //char            *op = NULL;
-        int             count = 0;
-        int             i = 0;
-
-        if (!dict || !prefix)
-                return;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_get_int32 (dict, key, &uid);
-        if (ret)
-                return;
+static void
+cli_print_volume_status_call_stack(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[256] = {
+        0,
+    };
+    int uid = 0;
+    int gid = 0;
+    int pid = 0;
+    uint64_t unique = 0;
+    // char            *op = NULL;
+    int count = 0;
+    int i = 0;
+
+    if (!prefix)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_get_int32 (dict, key, &gid);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_get_int32(dict, key, &uid);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_get_int32(dict, key, &gid);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_get_uint64 (dict, key, &unique);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        return;
 
-        /*
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.op", prefix);
-        ret = dict_get_str (dict, key, &op);
-        if (ret)
-                return;
-        */
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_get_uint64(dict, key, &unique);
+    if (ret)
+        return;
 
+    /*
+    snprintf (key, sizeof (key), "%s.op", prefix);
+    ret = dict_get_str (dict, key, &op);
+    if (ret)
+            return;
+    */
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &count);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &count);
+    if (ret)
+        return;
 
-        cli_out (" UID    : %d", uid);
-        cli_out (" GID    : %d", gid);
-        cli_out (" PID    : %d", pid);
-        cli_out (" Unique : %"PRIu64, unique);
-        //cli_out ("\tOp     : %s", op);
-        cli_out (" Frames : %d", count);
+    cli_out(" UID    : %d", uid);
+    cli_out(" GID    : %d", gid);
+    cli_out(" PID    : %d", pid);
+    cli_out(" Unique : %" PRIu64, unique);
+    // cli_out ("\tOp     : %s", op);
+    cli_out(" Frames : %d", count);
 
-        for (i = 0; i < count; i++) {
-                cli_out (" Frame %d", i+1);
+    for (i = 0; i < count; i++) {
+        cli_out(" Frame %d", i + 1);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
-                cli_print_volume_status_call_frame (dict, key);
-        }
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        cli_print_volume_status_call_frame(dict, key);
+    }
 
-        cli_out (" ");
+    cli_out(" ");
 }
 
-void
-cli_print_volume_status_callpool (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             call_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("Pending calls for volume %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+static void
+cli_print_volume_status_callpool(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int call_count = 0;
+    char key[64] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Pending calls for volume %s", volname);
+
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
+            goto out;
 
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
-
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (ret)
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.callpool.count", i);
-                ret = dict_get_int32 (dict, key, &call_count);
-                if (ret)
-                        goto out;
-                cli_out ("Pending calls: %d", call_count);
+        snprintf(key, sizeof(key), "brick%d.callpool.count", i);
+        ret = dict_get_int32(dict, key, &call_count);
+        if (ret)
+            goto out;
+        cli_out("Pending calls: %d", call_count);
 
-                if (0 == call_count)
-                        continue;
+        if (0 == call_count)
+            continue;
 
-                for (j = 0; j < call_count; j++) {
-                        cli_out ("Call Stack%d", j+1);
+        for (j = 0; j < call_count; j++) {
+            cli_out("Call Stack%d", j + 1);
 
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),
-                                  "brick%d.callpool.stack%d", i, j);
-                        cli_print_volume_status_call_stack (dict, key);
-                }
+            snprintf(key, sizeof(key), "brick%d.callpool.stack%d", i, j);
+            cli_print_volume_status_call_stack(dict, key);
         }
+    }
 
 out:
-        cli_out ("----------------------------------------------");
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
 static void
-cli_print_volume_status_tasks (dict_t *dict)
-{
-        int             ret         = -1;
-        int             i           = 0;
-        int             j           = 0;
-        int             count       = 0;
-        int             task_count  = 0;
-        int             status      = 0;
-        char           *op          = NULL;
-        char           *task_id_str = NULL;
-        char           *volname     = NULL;
-        char            key[1024]   = {0,};
-        char            task[1024]  = {0,};
-        char           *brick       = NULL;
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
+cli_print_volume_status_tasks(dict_t *dict)
+{
+    int ret = -1;
+    int i = 0;
+    int j = 0;
+    int count = 0;
+    int task_count = 0;
+    int status = 0;
+    char *op = NULL;
+    char *task_id_str = NULL;
+    char *volname = NULL;
+    char key[64] = {
+        0,
+    };
+    char task[32] = {
+        0,
+    };
+    char *brick = NULL;
+
+    ret = dict_get_int32_sizen(dict, "tasks", &task_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get tasks count");
+        return;
+    }
 
-        ret = dict_get_int32 (dict, "tasks", &task_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get tasks count");
-                return;
-        }
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-        cli_out ("Task Status of Volume %s", volname);
-        cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
+    cli_out("Task Status of Volume %s", volname);
+    cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
 
-        if (task_count == 0) {
-                cli_out ("There are no active volume tasks");
-                cli_out (" ");
-                return;
-        }
+    if (task_count == 0) {
+        cli_out("There are no active volume tasks");
+        cli_out(" ");
+        return;
+    }
 
-        for (i = 0; i < task_count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.type", i);
-                ret = dict_get_str(dict, key, &op);
-                if (ret)
-                        return;
-                cli_out ("%-20s : %-20s", "Task", op);
+    for (i = 0; i < task_count; i++) {
+        snprintf(key, sizeof(key), "task%d.type", i);
+        ret = dict_get_str(dict, key, &op);
+        if (ret)
+            return;
+        cli_out("%-20s : %-20s", "Task", op);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.id", i);
-                ret = dict_get_str (dict, key, &task_id_str);
-                if (ret)
-                        return;
-                cli_out ("%-20s : %-20s", "ID", task_id_str);
+        snprintf(key, sizeof(key), "task%d.id", i);
+        ret = dict_get_str(dict, key, &task_id_str);
+        if (ret)
+            return;
+        cli_out("%-20s : %-20s", "ID", task_id_str);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        return;
+        snprintf(key, sizeof(key), "task%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            return;
 
-                snprintf (task, sizeof (task), "task%d", i);
+        snprintf(task, sizeof(task), "task%d", i);
 
-                if (!strcmp (op, "Remove brick")) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.count", task);
-                        ret = dict_get_int32 (dict, key, &count);
-                        if (ret)
-                                goto out;
+        if (!strcmp(op, "Remove brick")) {
+            snprintf(key, sizeof(key), "%s.count", task);
+            ret = dict_get_int32(dict, key, &count);
+            if (ret)
+                goto out;
 
-                        cli_out ("%-20s", "Removed bricks:");
+            cli_out("%-20s", "Removed bricks:");
 
-                        for (j = 1; j <= count; j++) {
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),"%s.brick%d",
-                                          task, j);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
+            for (j = 1; j <= count; j++) {
+                snprintf(key, sizeof(key), "%s.brick%d", task, j);
+                ret = dict_get_str(dict, key, &brick);
+                if (ret)
+                    goto out;
 
-                                cli_out ("%-20s", brick);
-                        }
-                }
-                cli_out ("%-20s : %-20s", "Status",
-                         cli_vol_task_status_str[status]);
-                cli_out (" ");
+                cli_out("%-20s", brick);
+            }
         }
+        cli_out("%-20s : %-20s", "Status", cli_vol_task_status_str[status]);
+        cli_out(" ");
+    }
 
 out:
-        return;
+    return;
 }
 
 static int
-gf_cli_status_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
-{
-        int                             ret             = -1;
-        int                             brick_index_max = -1;
-        int                             other_count     = 0;
-        int                             index_max       = 0;
-        int                             i               = 0;
-        int                             type            = -1;
-        int                             hot_brick_count = -1;
-        int                             pid             = -1;
-        uint32_t                        cmd             = 0;
-        gf_boolean_t                    notbrick        = _gf_false;
-        char                            key[1024]       = {0,};
-        char                           *hostname        = NULL;
-        char                           *path            = NULL;
-        char                           *volname         = NULL;
-        dict_t                         *dict            = NULL;
-        gf_cli_rsp                      rsp             = {0,};
-        cli_volume_status_t             status          = {0};
-        cli_local_t                    *local           = NULL;
-        gf_boolean_t                    wipe_local      = _gf_false;
-        char                            msg[1024]       = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+gf_cli_status_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
+{
+    int ret = -1;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    int i = 0;
+    int type = -1;
+    int hot_brick_count = -1;
+    int pid = -1;
+    uint32_t cmd = 0;
+    gf_boolean_t notbrick = _gf_false;
+    char key[64] = {
+        0,
+    };
+    char *hostname = NULL;
+    char *path = NULL;
+    char *volname = NULL;
+    dict_t *dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    cli_volume_status_t status = {0};
+    cli_local_t *local = NULL;
+    gf_boolean_t wipe_local = _gf_false;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received response to status cmd");
+
+    local = ((call_frame_t *)myframe)->local;
+    if (!local) {
+        local = cli_local_get();
+        if (!local) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get local");
+            goto out;
         }
+        wipe_local = _gf_true;
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to status cmd");
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg),
+                     "Unable to obtain volume status information.");
 
-        local = ((call_frame_t *) myframe)->local;
-        if (!local) {
-                local = cli_local_get ();
-                if (!local) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get local");
-                        goto out;
-                }
-                wipe_local = _gf_true;
-        }
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            if (!local->all)
+                cli_xml_output_str("volStatus", msg, rsp.op_ret, rsp.op_errno,
+                                   rsp.op_errstr);
+            ret = 0;
+            goto out;
+        }
+
+        cli_err("%s", msg);
+        if (local && local->all) {
+            ret = 0;
+            cli_out(" ");
+        } else
+            ret = -1;
+
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to create the dict");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret)
+        goto out;
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
+
+    if ((cmd & GF_CLI_STATUS_ALL)) {
+        if (local && local->dict) {
+            dict_ref(dict);
+            ret = dict_set_static_ptr(local->dict, "rsp-dict", dict);
+            ret = 0;
+        } else {
+            gf_log("cli", GF_LOG_ERROR, "local not found");
+            ret = -1;
+        }
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (!local->all) {
+            ret = cli_xml_output_vol_status_begin(local, rsp.op_ret,
+                                                  rsp.op_errno, rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+                goto xml_end;
+            }
+        }
+        if (cmd & GF_CLI_STATUS_TASKS) {
+            ret = cli_xml_output_vol_status_tasks_detail(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+                goto xml_end;
+            }
+        } else {
+            ret = cli_xml_output_vol_status(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+                goto xml_end;
+            }
+        }
+
+    xml_end:
+        if (!local->all) {
+            ret = cli_xml_output_vol_status_end(local);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            }
+        }
+        goto out;
+    }
+
+    if ((cmd & GF_CLI_STATUS_NFS) || (cmd & GF_CLI_STATUS_SHD) ||
+        (cmd & GF_CLI_STATUS_QUOTAD) || (cmd & GF_CLI_STATUS_SNAPD) ||
+        (cmd & GF_CLI_STATUS_BITD) || (cmd & GF_CLI_STATUS_SCRUB))
+        notbrick = _gf_true;
+
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            cli_print_volume_status_mem(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CLIENTS:
+            cli_print_volume_status_clients(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CLIENT_LIST:
+            cli_print_volume_status_client_list(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_INODE:
+            cli_print_volume_status_inode(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_FD:
+            cli_print_volume_status_fd(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CALLPOOL:
+            cli_print_volume_status_callpool(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_TASKS:
+            cli_print_volume_status_tasks(dict);
+            goto cont;
+            break;
+        default:
+            break;
+    }
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "Unable to obtain volume "
-                                  "status information.");
-
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        if (!local->all)
-                                cli_xml_output_str ("volStatus", msg,
-                                                    rsp.op_ret, rsp.op_errno,
-                                                    rsp.op_errstr);
-                        ret = 0;
-                        goto out;
-                }
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-                cli_err ("%s", msg);
-                if (local && local->all) {
-                        ret = 0;
-                        cli_out (" ");
-                } else
-                        ret = -1;
+    ret = dict_get_int32_sizen(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
 
-                goto out;
-        }
+    ret = dict_get_int32_sizen(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    index_max = brick_index_max + other_count;
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-        if (ret)
-                goto out;
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret)
+        goto out;
 
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
+    ret = dict_get_int32_sizen(dict, "hot_brick_count", &hot_brick_count);
+    if (ret)
+        goto out;
 
-        if ((cmd & GF_CLI_STATUS_ALL)) {
-                if (local && local->dict) {
-                        dict_ref (dict);
-                        ret = dict_set_static_ptr (local->dict, "rsp-dict", dict);
-                        ret = 0;
-                } else {
-                        gf_log ("cli", GF_LOG_ERROR, "local not found");
-                        ret = -1;
-                }
-                goto out;
-        }
+    cli_out("Status of volume: %s", volname);
 
-        if ((cmd & GF_CLI_STATUS_NFS) || (cmd & GF_CLI_STATUS_SHD) ||
-            (cmd & GF_CLI_STATUS_QUOTAD) || (cmd & GF_CLI_STATUS_SNAPD) ||
-            (cmd & GF_CLI_STATUS_BITD) || (cmd & GF_CLI_STATUS_SCRUB) ||
-            (cmd & GF_CLI_STATUS_TIERD))
-                notbrick = _gf_true;
+    if ((cmd & GF_CLI_STATUS_DETAIL) == 0) {
+        cli_out("%-*s %s  %s  %s  %s", CLI_VOL_STATUS_BRICK_LEN,
+                "Gluster process", "TCP Port", "RDMA Port", "Online", "Pid");
+        cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (!local->all) {
-                        ret = cli_xml_output_vol_status_begin (local,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto xml_end;
-                        }
-                }
-                if (cmd & GF_CLI_STATUS_TASKS) {
-                        ret = cli_xml_output_vol_status_tasks_detail (local,
-                                                                      dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,"Error outputting "
-                                        "to xml");
-                                goto xml_end;
-                        }
-                } else {
-                        ret = cli_xml_output_vol_status (local, dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto xml_end;
-                        }
-                }
+    status.brick = GF_MALLOC(PATH_MAX + 256, gf_common_mt_strdup);
+    if (!status.brick) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-xml_end:
-                if (!local->all) {
-                        ret = cli_xml_output_vol_status_end (local);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        }
-                }
-                goto out;
-        }
+    for (i = 0; i <= index_max; i++) {
+        status.rdma_port = 0;
 
-        status.brick = GF_CALLOC (1, PATH_MAX + 256, gf_common_mt_strdup);
-        if (!status.brick) {
-                errno   = ENOMEM;
-                ret     = -1;
-                goto out;
-        }
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        cli_print_volume_status_mem (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_CLIENTS:
-                        cli_print_volume_status_clients (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_INODE:
-                        cli_print_volume_status_inode (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_FD:
-                        cli_print_volume_status_fd (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_CALLPOOL:
-                        cli_print_volume_status_callpool (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_TASKS:
-                        cli_print_volume_status_tasks (dict);
-                        goto cont;
-                        break;
-                default:
-                        break;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
+            continue;
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
+            continue;
 
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
+        /* Brick/not-brick is handled separately here as all
+         * types of nodes are contained in the default output
+         */
+        status.brick[0] = '\0';
+        if (!strcmp(hostname, "NFS Server") ||
+            !strcmp(hostname, "Self-heal Daemon") ||
+            !strcmp(hostname, "Quota Daemon") ||
+            !strcmp(hostname, "Snapshot Daemon") ||
+            !strcmp(hostname, "Scrubber Daemon") ||
+            !strcmp(hostname, "Bitrot Daemon"))
+            snprintf(status.brick, PATH_MAX + 255, "%s on %s", hostname, path);
+        else {
+            snprintf(key, sizeof(key), "brick%d.rdma_port", i);
+            ret = dict_get_int32(dict, key, &(status.rdma_port));
+            if (ret)
+                continue;
+            snprintf(status.brick, PATH_MAX + 255, "Brick %s:%s", hostname,
+                     path);
+        }
 
-        index_max = brick_index_max + other_count;
+        snprintf(key, sizeof(key), "brick%d.port", i);
+        ret = dict_get_int32(dict, key, &(status.port));
+        if (ret)
+            continue;
 
-        ret = dict_get_int32 (dict, "type", &type);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &(status.online));
         if (ret)
-                goto out;
+            continue;
 
-        ret = dict_get_int32 (dict, "hot_brick_count", &hot_brick_count);
+        snprintf(key, sizeof(key), "brick%d.pid", i);
+        ret = dict_get_int32(dict, key, &pid);
         if (ret)
-                goto out;
+            continue;
+        if (pid == -1)
+            ret = gf_asprintf(&(status.pid_str), "%s", "N/A");
+        else
+            ret = gf_asprintf(&(status.pid_str), "%d", pid);
 
-        cli_out ("Status of volume: %s", volname);
+        if (ret == -1)
+            goto out;
 
-        if ((cmd & GF_CLI_STATUS_DETAIL) == 0) {
-                cli_out ("%-*s %s  %s  %s  %s", CLI_VOL_STATUS_BRICK_LEN,
-                         "Gluster process", "TCP Port", "RDMA Port",
-                         "Online", "Pid");
-                cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
-        }
-        if (type == GF_CLUSTER_TYPE_TIER) {
-                cli_out ("Hot Bricks:");
+        if ((cmd & GF_CLI_STATUS_DETAIL)) {
+            ret = cli_get_detail_status(dict, i, &status);
+            if (ret)
+                goto out;
+            cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
+            cli_print_detailed_status(&status);
+        } else {
+            cli_print_brick_status(&status);
         }
-        for (i = 0; i <= index_max; i++) {
 
-                if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
-                        cli_out ("Cold Bricks:");
-                }
-                status.rdma_port = 0;
+        /* Allocatated memory using gf_asprintf*/
+        GF_FREE(status.pid_str);
+    }
+    cli_out(" ");
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        continue;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        continue;
-
-                /* Brick/not-brick is handled separately here as all
-                 * types of nodes are contained in the default output
-                 */
-                memset (status.brick, 0, PATH_MAX + 255);
-                if (!strcmp (hostname, "NFS Server") ||
-                    !strcmp (hostname, "Self-heal Daemon") ||
-                    !strcmp (hostname, "Quota Daemon") ||
-                    !strcmp (hostname, "Snapshot Daemon") ||
-                    !strcmp (hostname, "Scrubber Daemon") ||
-                    !strcmp (hostname, "Bitrot Daemon") ||
-                    !strcmp (hostname, "Tier Daemon"))
-                        snprintf (status.brick, PATH_MAX + 255, "%s on %s",
-                                  hostname, path);
-                else {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "brick%d.rdma_port", i);
-                        ret = dict_get_int32 (dict, key, &(status.rdma_port));
-                        if (ret)
-                                continue;
-                        snprintf (status.brick, PATH_MAX + 255, "Brick %s:%s",
-                                  hostname, path);
-                }
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.port", i);
-                ret = dict_get_int32 (dict, key, &(status.port));
-                if (ret)
-                        continue;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &(status.online));
-                if (ret)
-                        continue;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.pid", i);
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret)
-                        continue;
-                if (pid == -1)
-                        ret = gf_asprintf (&(status.pid_str), "%s", "N/A");
-                else
-                        ret = gf_asprintf (&(status.pid_str), "%d", pid);
-
-                if (ret == -1)
-                        goto out;
-
-                if ((cmd & GF_CLI_STATUS_DETAIL)) {
-                        ret = cli_get_detail_status (dict, i, &status);
-                        if (ret)
-                                goto out;
-                        cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
-                        cli_print_detailed_status (&status);
-                } else {
-                        cli_print_brick_status (&status);
-                }
-
-        }
-        cli_out (" ");
-
-        if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE)
-                cli_print_volume_status_tasks (dict);
+    if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE)
+        cli_print_volume_status_tasks(dict);
 cont:
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        GF_FREE (status.brick);
-        if (local && wipe_local) {
-                cli_local_wipe (local);
-        }
+    if (dict)
+        dict_unref(dict);
+    GF_FREE(status.brick);
+    if (local && wipe_local) {
+        cli_local_wipe(local);
+    }
 
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_status_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_status_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req  = {{0,}};
-        int                             ret  = -1;
-        dict_t                         *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = -1;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    dict = data;
 
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_status_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_STATUS_VOLUME, this, cli_rpc_prog,
-                               NULL);
- out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning: %d", ret);
-        return ret;
+    ret = cli_to_glusterd(&req, frame, gf_cli_status_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_STATUS_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int
-gf_cli_status_volume_all (call_frame_t *frame, xlator_t *this, void *data)
-{
-        int              i            = 0;
-        int              ret          = -1;
-        int              vol_count    = -1;
-        uint32_t         cmd          = 0;
-        char             key[1024]    = {0};
-        char            *volname      = NULL;
-        void            *vol_dict     = NULL;
-        dict_t          *dict         = NULL;
-        cli_local_t     *local        = NULL;
-
-        if (!frame)
-                goto out;
+static int
+gf_cli_status_volume_all(call_frame_t *frame, xlator_t *this, void *data)
+{
+    int i = 0;
+    int ret = -1;
+    int vol_count = -1;
+    uint32_t cmd = 0;
+    char key[1024] = {0};
+    char *volname = NULL;
+    void *vol_dict = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
 
-        if (!frame->local)
-                goto out;
+    if (!frame)
+        goto out;
 
-        local = frame->local;
+    if (!frame->local)
+        goto out;
 
-        ret = dict_get_uint32 (local->dict, "cmd", &cmd);
-        if (ret)
-                goto out;
+    local = frame->local;
 
-        local->all = _gf_true;
+    ret = dict_get_uint32(local->dict, "cmd", &cmd);
+    if (ret)
+        goto out;
 
-        ret = gf_cli_status_volume (frame, this, data);
+    local->all = _gf_true;
 
-        if (ret)
-                goto out;
+    ret = gf_cli_status_volume(frame, this, data);
 
-        ret = dict_get_ptr (local->dict, "rsp-dict", &vol_dict);
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 ((dict_t *)vol_dict, "vol_count", &vol_count);
-        if (ret) {
-                cli_err ("Failed to get names of volumes");
-                goto out;
-        }
+    ret = dict_get_ptr(local->dict, "rsp-dict", &vol_dict);
+    if (ret)
+        goto out;
 
-        /* remove the "all" flag in cmd */
-        cmd &= ~GF_CLI_STATUS_ALL;
-        cmd |= GF_CLI_STATUS_VOL;
+    ret = dict_get_int32_sizen((dict_t *)vol_dict, "vol_count", &vol_count);
+    if (ret) {
+        cli_err("Failed to get names of volumes");
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                //TODO: Pass proper op_* values
-                ret = cli_xml_output_vol_status_begin (local, 0,0, NULL);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                        goto xml_end;
-                }
-        }
+    /* remove the "all" flag in cmd */
+    cmd &= ~GF_CLI_STATUS_ALL;
+    cmd |= GF_CLI_STATUS_VOL;
 
-        if (vol_count == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
-                cli_err ("No volumes present");
-                ret = 0;
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        // TODO: Pass proper op_* values
+        ret = cli_xml_output_vol_status_begin(local, 0, 0, NULL);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            goto xml_end;
         }
+    }
 
-        for (i = 0; i < vol_count; i++) {
+    if (vol_count == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_err("No volumes present");
+        ret = 0;
+        goto out;
+    }
 
-                dict = dict_new ();
-                if (!dict)
-                        goto out;
+    for (i = 0; i < vol_count; i++) {
+        dict = dict_new();
+        if (!dict)
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "vol%d", i);
-                ret = dict_get_str (vol_dict, key, &volname);
-                if (ret)
-                        goto out;
+        ret = snprintf(key, sizeof(key), "vol%d", i);
+        ret = dict_get_strn(vol_dict, key, ret, &volname);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "volname", volname);
-                if (ret)
-                        goto out;
+        ret = dict_set_str_sizen(dict, "volname", volname);
+        if (ret)
+            goto out;
 
-                ret = dict_set_uint32 (dict, "cmd", cmd);
-                if (ret)
-                        goto out;
+        ret = dict_set_uint32(dict, "cmd", cmd);
+        if (ret)
+            goto out;
 
-                ret = gf_cli_status_volume (frame, this, dict);
-                if (ret)
-                        goto out;
+        ret = gf_cli_status_volume(frame, this, dict);
+        if (ret)
+            goto out;
 
-                dict_unref (dict);
-        }
+        dict_unref(dict);
+    }
 
 xml_end:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_status_end (local);
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_status_end(local);
+    }
 
- out:
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "status all failed");
+out:
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "status all failed");
 
-        if (vol_dict)
-                dict_unref (vol_dict);
+    if (vol_dict)
+        dict_unref(vol_dict);
 
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        if (local)
-                cli_local_wipe (local);
+    if (local)
+        cli_local_wipe(local);
 
-        if (frame)
-                frame->local = NULL;
+    if (frame)
+        frame->local = NULL;
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_mount_cbk (struct rpc_req *req, struct iovec *iov,
-                  int count, void *myframe)
+gf_cli_mount_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf1_cli_mount_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_mount_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_mount_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_mount_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
+    gf_log("cli", GF_LOG_INFO, "Received resp to mount");
 
-        if (rsp.op_ret == 0) {
-                ret = 0;
-                cli_out ("%s", rsp.path);
-        } else {
-                /* weird sounding but easy to parse... */
-                cli_err ("%d : failed with this errno (%s)",
-                         rsp.op_errno, strerror (rsp.op_errno));
-                ret = -1;
-        }
+    if (rsp.op_ret == 0) {
+        ret = 0;
+        cli_out("%s", rsp.path);
+    } else {
+        /* weird sounding but easy to parse... */
+        cli_err("%d : failed with this errno (%s)", rsp.op_errno,
+                strerror(rsp.op_errno));
+        ret = -1;
+    }
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    if (rsp.path) {
+        free(rsp.path);
+    }
+    return ret;
 }
 
-int32_t
-gf_cli_mount (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_mount(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_mount_req  req  = {0,};
-        int                ret  = -1;
-        void            **dataa = data;
-        char             *label = NULL;
-        dict_t            *dict = NULL;
+    gf1_cli_mount_req req = {
+        0,
+    };
+    int ret = -1;
+    void **dataa = data;
+    char *label = NULL;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        label = dataa[0];
-        dict  = dataa[1];
+    label = dataa[0];
+    dict = dataa[1];
 
-        req.label = label;
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    req.label = label;
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_MOUNT, NULL,
-                              this, gf_cli_mount_cbk,
-                              (xdrproc_t)xdr_gf1_cli_mount_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_MOUNT,
+                         NULL, this, gf_cli_mount_cbk,
+                         (xdrproc_t)xdr_gf1_cli_mount_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
 static int
-gf_cli_umount_cbk (struct rpc_req *req, struct iovec *iov,
-                   int count, void *myframe)
+gf_cli_umount_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
 {
-        gf1_cli_umount_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_umount_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_umount_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_umount_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
+    gf_log("cli", GF_LOG_INFO, "Received resp to mount");
 
-        if (rsp.op_ret == 0)
-                ret = 0;
-        else {
-                cli_err ("umount failed");
-                ret = -1;
-        }
+    if (rsp.op_ret == 0)
+        ret = 0;
+    else {
+        cli_err("umount failed");
+        ret = -1;
+    }
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-int32_t
-gf_cli_umount (call_frame_t *frame, xlator_t *this, void *data)
+static int32_t
+gf_cli_umount(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_umount_req  req  = {0,};
-        int                ret  = -1;
-        dict_t            *dict = NULL;
+    gf1_cli_umount_req req = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "path", &req.path);
-        if (ret == 0)
-                ret = dict_get_int32 (dict, "lazy", &req.lazy);
+    ret = dict_get_str_sizen(dict, "path", &req.path);
+    if (ret == 0)
+        ret = dict_get_int32_sizen(dict, "lazy", &req.lazy);
 
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_UMOUNT, NULL,
-                              this, gf_cli_umount_cbk,
-                              (xdrproc_t)xdr_gf1_cli_umount_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_UMOUNT,
+                         NULL, this, gf_cli_umount_cbk,
+                         (xdrproc_t)xdr_gf1_cli_umount_req);
 
- out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+out:
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
 }
 
-void
-cmd_heal_volume_statistics_out (dict_t *dict, int  brick)
-{
-
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char            *hostname = NULL;
-        uint64_t        i = 0;
-        uint64_t        healed_count = 0;
-        uint64_t        split_brain_count = 0;
-        uint64_t        heal_failed_count = 0;
-        char            *start_time_str = NULL;
-        char            *end_time_str = NULL;
-        char            *crawl_type = NULL;
-        int             progress = -1;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
+static void
+cmd_heal_volume_statistics_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[256] = {0};
+    char *hostname = NULL;
+    uint64_t i = 0;
+    uint64_t healed_count = 0;
+    uint64_t split_brain_count = 0;
+    uint64_t heal_failed_count = 0;
+    char *start_time_str = NULL;
+    char *end_time_str = NULL;
+    char *crawl_type = NULL;
+    int progress = -1;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    cli_out("------------------------------------------------");
+    cli_out("\nCrawl statistics for brick no %d", brick);
+    cli_out("Hostname of brick %s", hostname);
+
+    snprintf(key, sizeof key, "statistics-%d-count", brick);
+    ret = dict_get_uint64(dict, key, &num_entries);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < num_entries; i++) {
+        snprintf(key, sizeof key, "statistics_crawl_type-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_str(dict, key, &crawl_type);
         if (ret)
-                goto out;
-        cli_out ("------------------------------------------------");
-        cli_out ("\nCrawl statistics for brick no %d", brick);
-        cli_out ("Hostname of brick %s", hostname);
+            goto out;
 
-        snprintf (key, sizeof key, "statistics-%d-count", brick);
-        ret = dict_get_uint64 (dict, key, &num_entries);
+        snprintf(key, sizeof key, "statistics_healed_cnt-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_uint64(dict, key, &healed_count);
         if (ret)
-                goto out;
+            goto out;
 
-        for (i = 0; i < num_entries; i++)
-        {
-                snprintf (key, sizeof key, "statistics_crawl_type-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key, &crawl_type);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof key, "statistics_healed_cnt-%d-%"PRIu64,
-                          brick,i);
-                ret = dict_get_uint64 (dict, key, &healed_count);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof key, "statistics_sb_cnt-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_uint64 (dict, key, &split_brain_count);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_heal_failed_cnt-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_uint64 (dict, key, &heal_failed_count);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_strt_time-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key,  &start_time_str);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_end_time-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key, &end_time_str);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_inprogress-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_int32 (dict, key, &progress);
-                if (ret)
-                        goto out;
-
-                cli_out ("\nStarting time of crawl: %s", start_time_str);
-                if (progress == 1)
-                        cli_out ("Crawl is in progress");
-                else
-                        cli_out ("Ending time of crawl: %s", end_time_str);
-
-                cli_out ("Type of crawl: %s", crawl_type);
-                cli_out ("No. of entries healed: %"PRIu64,
-                         healed_count);
-                cli_out ("No. of entries in split-brain: %"PRIu64,
-                        split_brain_count);
-                cli_out ("No. of heal failed entries: %"PRIu64,
-                         heal_failed_count);
-
-        }
-
-
-out:
-        return;
-}
-
-void
-cmd_heal_volume_brick_out (dict_t *dict, int brick)
-{
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char           *hostname = NULL;
-        char           *path = NULL;
-        char           *status = NULL;
-        uint64_t        i = 0;
-        uint32_t        time = 0;
-        char            timestr[32] = {0};
-        char            *shd_status = NULL;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
+        snprintf(key, sizeof key, "statistics_sb_cnt-%d-%" PRIu64, brick, i);
+        ret = dict_get_uint64(dict, key, &split_brain_count);
         if (ret)
-                goto out;
-        snprintf (key, sizeof key, "%d-path", brick);
-        ret = dict_get_str (dict, key, &path);
+            goto out;
+        snprintf(key, sizeof key, "statistics_heal_failed_cnt-%d-%" PRIu64,
+                 brick, i);
+        ret = dict_get_uint64(dict, key, &heal_failed_count);
         if (ret)
-                goto out;
-        cli_out ("\nBrick %s:%s", hostname, path);
-
-        snprintf (key, sizeof key, "%d-status", brick);
-        ret = dict_get_str (dict, key, &status);
-        if (status && strlen (status))
-                cli_out ("Status: %s", status);
+            goto out;
+        snprintf(key, sizeof key, "statistics_strt_time-%d-%" PRIu64, brick, i);
+        ret = dict_get_str(dict, key, &start_time_str);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_end_time-%d-%" PRIu64, brick, i);
+        ret = dict_get_str(dict, key, &end_time_str);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_inprogress-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_int32(dict, key, &progress);
+        if (ret)
+            goto out;
 
-        snprintf (key, sizeof key, "%d-shd-status",brick);
-        ret = dict_get_str (dict, key, &shd_status);
+        cli_out("\nStarting time of crawl: %s", start_time_str);
+        if (progress == 1)
+            cli_out("Crawl is in progress");
+        else
+            cli_out("Ending time of crawl: %s", end_time_str);
 
-        if(!shd_status)
-        {
-                snprintf (key, sizeof key, "%d-count", brick);
-                ret = dict_get_uint64 (dict, key, &num_entries);
-                cli_out ("Number of entries: %"PRIu64, num_entries);
-
-
-                for (i = 0; i < num_entries; i++) {
-                        snprintf (key, sizeof key, "%d-%"PRIu64, brick, i);
-                        ret = dict_get_str (dict, key, &path);
-                        if (ret)
-                                continue;
-                        time = 0;
-                        snprintf (key, sizeof key, "%d-%"PRIu64"-time",
-                                  brick, i);
-                        ret = dict_get_uint32 (dict, key, &time);
-                        if (!time) {
-                                cli_out ("%s", path);
-                        } else {
-                                gf_time_fmt (timestr, sizeof timestr,
-                                             time, gf_timefmt_FT);
-                                if (i == 0) {
-                                cli_out ("at                    path on brick");
-                                cli_out ("-----------------------------------");
-                                }
-                                cli_out ("%s %s", timestr, path);
-                        }
-                }
-        }
+        cli_out("Type of crawl: %s", crawl_type);
+        cli_out("No. of entries healed: %" PRIu64, healed_count);
+        cli_out("No. of entries in split-brain: %" PRIu64, split_brain_count);
+        cli_out("No. of heal failed entries: %" PRIu64, heal_failed_count);
+    }
 
 out:
-        return;
+    return;
 }
 
+static void
+cmd_heal_volume_brick_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[64] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *status = NULL;
+    uint64_t i = 0;
+    uint32_t time = 0;
+    char timestr[GF_TIMESTR_SIZE] = {0};
+    char *shd_status = NULL;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof key, "%d-path", brick);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    cli_out("\nBrick %s:%s", hostname, path);
+
+    snprintf(key, sizeof key, "%d-status", brick);
+    ret = dict_get_str(dict, key, &status);
+    if (status && status[0] != '\0')
+        cli_out("Status: %s", status);
+
+    snprintf(key, sizeof key, "%d-shd-status", brick);
+    ret = dict_get_str(dict, key, &shd_status);
+
+    if (!shd_status) {
+        snprintf(key, sizeof key, "%d-count", brick);
+        ret = dict_get_uint64(dict, key, &num_entries);
+        cli_out("Number of entries: %" PRIu64, num_entries);
+
+        for (i = 0; i < num_entries; i++) {
+            snprintf(key, sizeof key, "%d-%" PRIu64, brick, i);
+            ret = dict_get_str(dict, key, &path);
+            if (ret)
+                continue;
+            time = 0;
+            snprintf(key, sizeof key, "%d-%" PRIu64 "-time", brick, i);
+            ret = dict_get_uint32(dict, key, &time);
+            if (ret || !time) {
+                cli_out("%s", path);
+            } else {
+                gf_time_fmt(timestr, sizeof timestr, time, gf_timefmt_FT);
+                if (i == 0) {
+                    cli_out("at                    path on brick");
+                    cli_out("-----------------------------------");
+                }
+                cli_out("%s %s", timestr, path);
+            }
+        }
+    }
+
+out:
+    return;
+}
 
-void
-cmd_heal_volume_statistics_heal_count_out (dict_t *dict, int brick)
-{
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char           *hostname = NULL;
-        char           *path = NULL;
-        char           *status = NULL;
-        char            *shd_status = NULL;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof key, "%d-path", brick);
-        ret = dict_get_str (dict, key, &path);
+static void
+cmd_heal_volume_statistics_heal_count_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[64] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *status = NULL;
+    char *shd_status = NULL;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof key, "%d-path", brick);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    cli_out("\nBrick %s:%s", hostname, path);
+
+    snprintf(key, sizeof key, "%d-status", brick);
+    ret = dict_get_str(dict, key, &status);
+    if (status && strlen(status))
+        cli_out("Status: %s", status);
+
+    snprintf(key, sizeof key, "%d-shd-status", brick);
+    ret = dict_get_str(dict, key, &shd_status);
+
+    if (!shd_status) {
+        snprintf(key, sizeof key, "%d-hardlinks", brick);
+        ret = dict_get_uint64(dict, key, &num_entries);
         if (ret)
-                goto out;
-        cli_out ("\nBrick %s:%s", hostname, path);
-
-        snprintf (key, sizeof key, "%d-status", brick);
-        ret = dict_get_str (dict, key, &status);
-        if (status && strlen (status))
-                cli_out ("Status: %s", status);
-
-        snprintf (key, sizeof key, "%d-shd-status",brick);
-        ret = dict_get_str (dict, key, &shd_status);
-
-        if(!shd_status)
-        {
-                snprintf (key, sizeof key, "%d-hardlinks", brick);
-                ret = dict_get_uint64 (dict, key, &num_entries);
-                if (ret)
-                        cli_out ("No gathered input for this brick");
-                else
-                        cli_out ("Number of entries: %"PRIu64, num_entries);
-
-
-        }
+            cli_out("No gathered input for this brick");
+        else
+            cli_out("Number of entries: %" PRIu64, num_entries);
+    }
 
 out:
-        return;
+    return;
 }
 
-int
-gf_is_cli_heal_get_command (gf_xl_afr_op_t heal_op)
-{
-        /* If the command is get command value is 1 otherwise 0, for
-           invalid commands -1 */
-        int    get_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
-                       [GF_SHD_OP_INVALID] = -1,
-                       [GF_SHD_OP_HEAL_INDEX] = 0,
-                       [GF_SHD_OP_HEAL_FULL] = 0,
-                       [GF_SHD_OP_INDEX_SUMMARY] = 1,
-                       [GF_SHD_OP_HEALED_FILES] = 1,
-                       [GF_SHD_OP_HEAL_FAILED_FILES] = 1,
-                       [GF_SHD_OP_SPLIT_BRAIN_FILES] = 1,
-                       [GF_SHD_OP_STATISTICS] = 1,
-                       [GF_SHD_OP_STATISTICS_HEAL_COUNT] = 1,
-                       [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = 1,
-                       [GF_SHD_OP_HEAL_ENABLE] = 0,
-                       [GF_SHD_OP_HEAL_DISABLE] = 0,
-                };
-
-        if (heal_op > GF_SHD_OP_INVALID && heal_op <= GF_SHD_OP_HEAL_DISABLE)
-                return get_cmds[heal_op] == 1;
-        return _gf_false;
+static int
+gf_is_cli_heal_get_command(gf_xl_afr_op_t heal_op)
+{
+    /* If the command is get command value is 1 otherwise 0, for
+       invalid commands -1 */
+    static int get_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
+        [GF_SHD_OP_INVALID] = -1,
+        [GF_SHD_OP_HEAL_INDEX] = 0,
+        [GF_SHD_OP_HEAL_FULL] = 0,
+        [GF_SHD_OP_INDEX_SUMMARY] = 1,
+        [GF_SHD_OP_SPLIT_BRAIN_FILES] = 1,
+        [GF_SHD_OP_STATISTICS] = 1,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT] = 1,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = 1,
+        [GF_SHD_OP_HEAL_ENABLE] = 0,
+        [GF_SHD_OP_HEAL_DISABLE] = 0,
+    };
+
+    if (heal_op > GF_SHD_OP_INVALID && heal_op <= GF_SHD_OP_HEAL_DISABLE)
+        return get_cmds[heal_op] == 1;
+    return _gf_false;
 }
 
 int
-gf_cli_heal_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     brick_count = 0;
-        int                     i = 0;
-        gf_xl_afr_op_t          heal_op = GF_SHD_OP_INVALID;
-        char                    *operation = NULL;
-        char                    *substr = NULL;
-        char                    *heal_op_str = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "heal-op", (int32_t *)&heal_op);
-//TODO: Proper XML output
-//#if (HAVE_LIB_XML)
-//        if (global_state->mode & GLUSTER_MODE_XML) {
-//                ret = cli_xml_output_dict ("volHeal", dict, rsp.op_ret,
-//                                           rsp.op_errno, rsp.op_errstr);
-//                if (ret)
-//                        gf_log ("cli", GF_LOG_ERROR,
-//                                "Error outputting to xml");
-//                goto out;
-//        }
-//#endif
-
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to get volname");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to heal volume");
-
-        operation = "Gathering ";
-        substr = "";
-        switch (heal_op) {
-        case    GF_SHD_OP_HEAL_INDEX:
-                operation   = "Launching heal operation ";
-                heal_op_str = "to perform index self heal";
-                substr      = "\nUse heal info commands to check"
-                              " status.";
-                break;
-        case    GF_SHD_OP_HEAL_FULL:
-                operation   = "Launching heal operation ";
-                heal_op_str = "to perform full self heal";
-                substr      = "\nUse heal info commands to check"
-                              " status.";
-                break;
-        case    GF_SHD_OP_INDEX_SUMMARY:
-                heal_op_str = "list of entries to be healed";
-                break;
-        case    GF_SHD_OP_HEALED_FILES:
-                heal_op_str = "list of healed entries";
-                break;
-        case    GF_SHD_OP_HEAL_FAILED_FILES:
-                heal_op_str = "list of heal failed entries";
-                break;
-        case    GF_SHD_OP_SPLIT_BRAIN_FILES:
-                heal_op_str = "list of split brain entries";
-                break;
-        case    GF_SHD_OP_STATISTICS:
-                heal_op_str =  "crawl statistics";
-                break;
-        case    GF_SHD_OP_STATISTICS_HEAL_COUNT:
-                heal_op_str = "count of entries to be healed";
-                break;
-        case    GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                heal_op_str = "count of entries to be healed per replica";
-                break;
-        /* The below 3 cases are never hit; they're coded only to make
-         * compiler warnings go away.*/
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                break;
-
-        case    GF_SHD_OP_INVALID:
-                heal_op_str = "invalid heal op";
-                break;
-        case    GF_SHD_OP_HEAL_ENABLE:
-                operation   = "";
-                heal_op_str = "Enable heal";
-                break;
-        case    GF_SHD_OP_HEAL_DISABLE:
-                operation   = "";
-                heal_op_str = "Disable heal";
-                break;
-        case    GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
-                operation   = "";
-                heal_op_str = "Enable granular entry heal";
-                break;
-        case    GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
-                operation   = "";
-                heal_op_str = "Disable granular entry heal";
-                break;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        cli_err ("%s%s on volume %s has been unsuccessful:",
-                                 operation, heal_op_str, volname);
-                        cli_err ("%s", rsp.op_errstr);
-                }
-                ret = rsp.op_ret;
-                goto out;
-        } else {
-                cli_out ("%s%s on volume %s has been successful %s", operation,
-                         heal_op_str, volname, substr);
+gf_cli_heal_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int brick_count = 0;
+    int i = 0;
+    gf_xl_afr_op_t heal_op = GF_SHD_OP_INVALID;
+    const char *operation = NULL;
+    const char *substr = NULL;
+    const char *heal_op_str = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(local->dict, "heal-op", (int32_t *)&heal_op);
+    // TODO: Proper XML output
+    //#if (HAVE_LIB_XML)
+    //        if (global_state->mode & GLUSTER_MODE_XML) {
+    //                ret = cli_xml_output_dict ("volHeal", dict, rsp.op_ret,
+    //                                           rsp.op_errno, rsp.op_errstr);
+    //                if (ret)
+    //                        gf_log ("cli", GF_LOG_ERROR, XML_ERROR);
+    //                goto out;
+    //        }
+    //#endif
+
+    ret = dict_get_str_sizen(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get volname");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to heal volume");
+
+    operation = "Gathering ";
+    substr = "";
+    switch (heal_op) {
+        case GF_SHD_OP_HEAL_INDEX:
+            operation = "Launching heal operation ";
+            heal_op_str = "to perform index self heal";
+            substr = "\nUse heal info commands to check status.";
+            break;
+        case GF_SHD_OP_HEAL_FULL:
+            operation = "Launching heal operation ";
+            heal_op_str = "to perform full self heal";
+            substr = "\nUse heal info commands to check status.";
+            break;
+        case GF_SHD_OP_INDEX_SUMMARY:
+            heal_op_str = "list of entries to be healed";
+            break;
+        case GF_SHD_OP_SPLIT_BRAIN_FILES:
+            heal_op_str = "list of split brain entries";
+            break;
+        case GF_SHD_OP_STATISTICS:
+            heal_op_str = "crawl statistics";
+            break;
+        case GF_SHD_OP_STATISTICS_HEAL_COUNT:
+            heal_op_str = "count of entries to be healed";
+            break;
+        case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
+            heal_op_str = "count of entries to be healed per replica";
+            break;
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
+        case GF_SHD_OP_HEAL_SUMMARY:
+        case GF_SHD_OP_HEALED_FILES:
+        case GF_SHD_OP_HEAL_FAILED_FILES:
+            /* These cases are never hit; they're coded just to silence the
+             * compiler warnings.*/
+            break;
+
+        case GF_SHD_OP_INVALID:
+            heal_op_str = "invalid heal op";
+            break;
+        case GF_SHD_OP_HEAL_ENABLE:
+            operation = "";
+            heal_op_str = "Enable heal";
+            break;
+        case GF_SHD_OP_HEAL_DISABLE:
+            operation = "";
+            heal_op_str = "Disable heal";
+            break;
+        case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
+            operation = "";
+            heal_op_str = "Enable granular entry heal";
+            break;
+        case GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
+            operation = "";
+            heal_op_str = "Disable granular entry heal";
+            break;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, "")) {
+            cli_err("%s%s on volume %s has been unsuccessful:", operation,
+                    heal_op_str, volname);
+            cli_err("%s", rsp.op_errstr);
         }
-
         ret = rsp.op_ret;
-        if (!gf_is_cli_heal_get_command (heal_op))
-                goto out;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
-        } else {
-                dict->extra_stdfree = rsp.dict.dict_val;
-        }
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-
-        if (!brick_count) {
-                cli_err ("All bricks of volume %s are down.", volname);
-                goto out;
-        }
-
-        switch (heal_op) {
+        goto out;
+    } else {
+        cli_out("%s%s on volume %s has been successful %s", operation,
+                heal_op_str, volname, substr);
+    }
+
+    ret = rsp.op_ret;
+    if (!gf_is_cli_heal_get_command(heal_op))
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+
+    if (!brick_count) {
+        cli_err("All bricks of volume %s are down.", volname);
+        ret = -1;
+        goto out;
+    }
+
+    switch (heal_op) {
         case GF_SHD_OP_STATISTICS:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_statistics_out (dict, i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_statistics_out(dict, i);
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT:
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_statistics_heal_count_out (dict,
-                                                                   i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_statistics_heal_count_out(dict, i);
+            break;
         case GF_SHD_OP_INDEX_SUMMARY:
-        case GF_SHD_OP_HEALED_FILES:
-        case GF_SHD_OP_HEAL_FAILED_FILES:
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_brick_out (dict, i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_brick_out(dict, i);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.op_errstr);
-        if (dict)
-                dict_unref (dict);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
-int32_t
-gf_cli_heal_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+static int32_t
+gf_cli_heal_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_heal_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_HEAL_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_heal_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_HEAL_VOLUME, this, cli_rpc_prog, NULL);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_statedump_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                int count, void *myframe)
-{
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-        char                            msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to statedump");
-        if (rsp.op_ret)
-                snprintf (msg, sizeof(msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Volume statedump successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volStatedump", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+static int32_t
+gf_cli_statedump_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                            void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = "Volume statedump successful";
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to statedump");
+    if (rsp.op_ret)
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volStatedump", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume statedump: failed: %s", msg);
-        else
-                cli_out ("volume statedump: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume statedump: failed: %s", msg);
+    else
+        cli_out("volume statedump: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_statedump_volume (call_frame_t *frame, xlator_t *this,
-                            void *data)
+static int32_t
+gf_cli_statedump_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
-
-        if (!frame || !this || !data)
-                goto out;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_statedump_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(
+        &req, frame, gf_cli_statedump_volume_cbk, (xdrproc_t)xdr_gf_cli_req,
+        options, GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_list_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                int count, void *myframe)
-{
-        int             ret = -1;
-        gf_cli_rsp      rsp = {0,};
-        dict_t          *dict = NULL;
-        int             vol_count = 0;;
-        char            *volname = NULL;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+static int32_t
+gf_cli_list_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    int vol_count = 0;
+    ;
+    char *volname = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_list(dict, rsp.op_ret, rsp.op_errno,
+                                      rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
+
+    if (rsp.op_ret)
+        cli_err("%s", rsp.op_errstr);
+    else {
+        ret = dict_get_int32_sizen(dict, "count", &vol_count);
+        if (ret)
+            goto out;
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to allocate memory");
-                goto out;
+        if (vol_count == 0) {
+            cli_err("No volumes present in cluster");
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_list (dict, rsp.op_ret, rsp.op_errno,
-                                               rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+        for (i = 0; i < vol_count; i++) {
+            ret = snprintf(key, sizeof(key), "volume%d", i);
+            ret = dict_get_strn(dict, key, ret, &volname);
+            if (ret)
                 goto out;
+            cli_out("%s", volname);
         }
+    }
 
-        if (rsp.op_ret)
-                cli_err ("%s", rsp.op_errstr);
-        else {
-                ret = dict_get_int32 (dict, "count", &vol_count);
-                if (ret)
-                        goto out;
-
-                if (vol_count == 0) {
-                        cli_err ("No volumes present in cluster");
-                        goto out;
-                }
-                for (i = 0; i < vol_count; i++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "volume%d", i);
-                        ret = dict_get_str (dict, key, &volname);
-                        if (ret)
-                                goto out;
-                        cli_out ("%s", volname);
-                }
-        }
-
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
-}
-
-int32_t
-gf_cli_list_volume (call_frame_t *frame, xlator_t *this, void *data)
-{
-        int             ret = -1;
-        gf_cli_req      req = {{0,}};
-
-        if (!frame || !this)
-                goto out;
-
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_LIST_VOLUME, NULL,
-                              this, gf_cli_list_volume_cbk,
-                              (xdrproc_t)xdr_gf_cli_req);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
-int32_t
-gf_cli_clearlocks_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                  int count, void *myframe)
+static int32_t
+gf_cli_list_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-        char                            *lk_summary = NULL;
-        char                            *volname = NULL;
-        dict_t                          *dict = NULL;
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_LIST_VOLUME, NULL, this,
+                         gf_cli_list_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+    return ret;
+}
 
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+static int32_t
+gf_cli_clearlocks_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                             void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *lk_summary = NULL;
+    dict_t *dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to clear-locks");
+
+    if (rsp.op_ret) {
+        cli_err("Volume clear-locks unsuccessful");
+        cli_err("%s", rsp.op_errstr);
+
+    } else {
+        if (!rsp.dict.dict_len) {
+            cli_err("Possibly no locks cleared");
+            ret = 0;
+            goto out;
         }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to clear-locks");
 
-        if (rsp.op_ret) {
-                cli_err ("Volume clear-locks unsuccessful");
-                cli_err ("%s", rsp.op_errstr);
-
-        } else {
-                if (!rsp.dict.dict_len) {
-                        cli_err ("Possibly no locks cleared");
-                        ret = 0;
-                        goto out;
-                }
-
-                dict = dict_new ();
-
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
+        dict = dict_new();
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to serialize response dictionary");
-                        goto out;
-                }
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
 
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get volname "
-                                "from dictionary");
-                        goto out;
-                }
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-                ret = dict_get_str (dict, "lk-summary", &lk_summary);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get lock "
-                                "summary from dictionary");
-                        goto out;
-                }
-                cli_out ("Volume clear-locks successful");
-                cli_out ("%s", lk_summary);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
+        }
 
+        ret = dict_get_str(dict, "lk-summary", &lk_summary);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to get lock summary from dictionary");
+            goto out;
         }
+        cli_out("Volume clear-locks successful");
+        cli_out("%s", lk_summary);
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int32_t
-gf_cli_clearlocks_volume (call_frame_t *frame, xlator_t *this,
-                             void *data)
+static int32_t
+gf_cli_clearlocks_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
-
-        if (!frame || !this || !data)
-                goto out;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_clearlocks_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_CLRLOCKS_VOLUME, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    ret = cli_to_glusterd(
+        &req, frame, gf_cli_clearlocks_volume_cbk, (xdrproc_t)xdr_gf_cli_req,
+        options, GLUSTER_CLI_CLRLOCKS_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-cli_snapshot_remove_reply (gf_cli_rsp *rsp, dict_t *dict, call_frame_t *frame)
+static int32_t
+cli_snapshot_remove_reply(gf_cli_rsp *rsp, dict_t *dict, call_frame_t *frame)
 {
-        int32_t         ret             = -1;
-        char            *snap_name      = NULL;
-        int32_t         delete_cmd      = -1;
-        cli_local_t     *local          = NULL;
+    int32_t ret = -1;
+    char *snap_name = NULL;
+    int32_t delete_cmd = -1;
+    cli_local_t *local = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (rsp);
-        GF_ASSERT (dict);
+    GF_ASSERT(frame);
+    GF_ASSERT(rsp);
+    GF_ASSERT(dict);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = dict_get_int32 (dict, "sub-cmd", &delete_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get sub-cmd");
-                goto end;
-        }
+    ret = dict_get_int32_sizen(dict, "sub-cmd", &delete_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get sub-cmd");
+        goto end;
+    }
 
-        if ((global_state->mode & GLUSTER_MODE_XML) &&
-            (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
-                ret = cli_xml_output_snap_delete_begin (local, rsp->op_ret,
-                                                        rsp->op_errno,
-                                                        rsp->op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for delete");
-                        goto end;
-                }
+    if ((global_state->mode & GLUSTER_MODE_XML) &&
+        (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
+        ret = cli_xml_output_snap_delete_begin(local, rsp->op_ret,
+                                               rsp->op_errno, rsp->op_errstr);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create xml output for delete");
+            goto end;
+        }
+    }
+
+    if (rsp->op_ret && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_err("snapshot delete: failed: %s",
+                rsp->op_errstr ? rsp->op_errstr
+                               : "Please check log file for details");
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL ||
+        delete_cmd == GF_SNAP_DELETE_TYPE_VOL) {
+        local = ((call_frame_t *)frame)->local;
+        if (!local) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "frame->local is NULL");
+            goto out;
         }
 
+        /* During first call back of snapshot delete of type
+         * ALL and VOL, We will get the snapcount and snapnames.
+         * Hence to make the subsequent rpc calls for individual
+         * snapshot delete, We need to save it in local dictionary.
+         */
+        dict_copy(dict, local->dict);
+        ret = 0;
+        goto out;
+    }
 
-        if (rsp->op_ret && !(global_state->mode & GLUSTER_MODE_XML)) {
-                        cli_err ("snapshot delete: failed: %s",
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                 "Please check log file for details");
-                ret = rsp->op_ret;
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_delete(local, dict, rsp);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create xml output for snapshot delete command");
+            goto out;
         }
-
-        if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL ||
-            delete_cmd == GF_SNAP_DELETE_TYPE_VOL) {
-                local = ((call_frame_t *) frame) -> local;
-                if (!local) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "frame->local is NULL");
-                        goto out;
-                }
-
-                /* During first call back of snapshot delete of type
-                 * ALL and VOL, We will get the snapcount and snapnames.
-                 * Hence to make the subsequent rpc calls for individual
-                 * snapshot delete, We need to save it in local dictionary.
-                 */
-                dict_copy (dict, local->dict);
-                ret = 0;
-                goto out;
+        /* Error out in case of the op already failed */
+        if (rsp->op_ret) {
+            ret = rsp->op_ret;
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_delete (local, dict, rsp);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot delete command");
-                        goto out;
-                }
-                /* Error out in case of the op already failed */
-                if (rsp->op_ret) {
-                        ret = rsp->op_ret;
-                        goto out;
-                }
-        } else {
-                ret = dict_get_str (dict, "snapname", &snap_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snapname");
-                        goto out;
-                }
-
-                cli_out ("snapshot delete: %s: snap removed successfully",
-                         snap_name);
+    } else {
+        ret = dict_get_str_sizen(dict, "snapname", &snap_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to get snapname");
+            goto out;
         }
-        ret = 0;
+
+        cli_out("snapshot delete: %s: snap removed successfully", snap_name);
+    }
+    ret = 0;
 
 out:
-        if ((global_state->mode & GLUSTER_MODE_XML) &&
-            (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
-                ret = cli_xml_output_snap_delete_end (local);
-        }
+    if ((global_state->mode & GLUSTER_MODE_XML) &&
+        (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
+        ret = cli_xml_output_snap_delete_end(local);
+    }
 end:
-        return ret;
+    return ret;
 }
 
-int
-cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp)
-{
-        char                buf[PATH_MAX]        = "";
-        char               *volname              = NULL;
-        int                 ret                  = -1;
-        int                 config_command       = 0;
-        uint64_t            value                = 0;
-        uint64_t            hard_limit           = 0;
-        uint64_t            soft_limit           = 0;
-        uint64_t            i                    = 0;
-        uint64_t            voldisplaycount      = 0;
-        char               *auto_delete          = NULL;
-        char               *snap_activate        = NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (rsp);
+static int
+cli_snapshot_config_display(dict_t *dict, gf_cli_rsp *rsp)
+{
+    char buf[PATH_MAX] = "";
+    char *volname = NULL;
+    int ret = -1;
+    int config_command = 0;
+    uint64_t value = 0;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    uint64_t i = 0;
+    uint64_t voldisplaycount = 0;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(rsp);
+
+    if (rsp->op_ret) {
+        cli_err("Snapshot Config : failed: %s",
+                rsp->op_errstr ? rsp->op_errstr
+                               : "Please check log file for details");
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "config-command", &config_command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+        goto out;
+    }
+
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+    /* Ignore the error, as the key specified is optional */
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+
+    ret = dict_get_str_sizen(dict, "auto-delete", &auto_delete);
+
+    ret = dict_get_str_sizen(dict, "snap-activate-on-create", &snap_activate);
+
+    if (!hard_limit && !soft_limit &&
+        config_command != GF_SNAP_CONFIG_DISPLAY && !auto_delete &&
+        !snap_activate) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "Could not fetch config-key");
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    /* Ignore the error, as volname is optional */
+
+    if (!volname) {
+        volname = "System";
+    }
+
+    switch (config_command) {
+        case GF_SNAP_CONFIG_TYPE_SET:
+            if (hard_limit && soft_limit) {
+                cli_out(
+                    "snapshot config: snap-max-hard-limit "
+                    "& snap-max-soft-limit for system set successfully");
+            } else if (hard_limit) {
+                cli_out(
+                    "snapshot config: snap-max-hard-limit "
+                    "for %s set successfully",
+                    volname);
+            } else if (soft_limit) {
+                cli_out(
+                    "snapshot config: snap-max-soft-limit "
+                    "for %s set successfully",
+                    volname);
+            } else if (auto_delete) {
+                cli_out("snapshot config: auto-delete successfully set");
+            } else if (snap_activate) {
+                cli_out("snapshot config: activate-on-create successfully set");
+            }
+            break;
 
-        if (rsp->op_ret) {
-                cli_err ("Snapshot Config : failed: %s",
-                         rsp->op_errstr ? rsp->op_errstr :
-                         "Please check log file for details");
-                ret = rsp->op_ret;
+        case GF_SNAP_CONFIG_DISPLAY:
+            cli_out("\nSnapshot System Configuration:");
+            ret = dict_get_uint64(dict, "snap-max-hard-limit", &value);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Could not fetch snap_max_hard_limit for %s", volname);
+                ret = -1;
                 goto out;
-        }
+            }
+            cli_out("snap-max-hard-limit : %" PRIu64, value);
 
-        ret = dict_get_int32 (dict, "config-command", &config_command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch config type");
+            ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Could not fetch snap-max-soft-limit for %s", volname);
+                ret = -1;
                 goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        /* Ignore the error, as volname is optional */
+            }
+            cli_out("snap-max-soft-limit : %" PRIu64 "%%", soft_limit);
 
-        if (!volname) {
-                volname = "System";
-        }
+            cli_out("auto-delete : %s", auto_delete);
 
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &hard_limit);
-        /* Ignore the error, as the key specified is optional */
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &soft_limit);
+            cli_out("activate-on-create : %s\n", snap_activate);
 
-        ret = dict_get_str (dict, "auto-delete", &auto_delete);
+            cli_out("Snapshot Volume Configuration:");
 
-        ret = dict_get_str (dict, "snap-activate-on-create", &snap_activate);
-
-        if (!hard_limit && !soft_limit
-                        && config_command != GF_SNAP_CONFIG_DISPLAY
-                        && !auto_delete && !snap_activate) {
+            ret = dict_get_uint64(dict, "voldisplaycount", &voldisplaycount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not fetch voldisplaycount");
                 ret = -1;
-                gf_log(THIS->name, GF_LOG_ERROR,
-                       "Could not fetch config-key");
                 goto out;
-        }
+            }
 
-        switch (config_command) {
-        case GF_SNAP_CONFIG_TYPE_SET:
-                if (hard_limit && soft_limit) {
-                        cli_out ("snapshot config: snap-max-hard-limit "
-                                "& snap-max-soft-limit for system set "
-                                 "successfully");
-                } else if (hard_limit) {
-                        cli_out ("snapshot config: snap-max-hard-limit "
-                                 "for %s set successfully",
-                                 volname);
-                } else if (soft_limit) {
-                        cli_out ("snapshot config: snap-max-soft-limit "
-                                 "for %s set successfully",
-                                 volname);
-                } else if (auto_delete) {
-                        cli_out ("snapshot config: auto-delete "
-                                 "successfully set");
-                } else if (snap_activate) {
-                        cli_out ("snapshot config: activate-on-create "
-                                 "successfully set");
-                }
-                break;
-
-        case GF_SNAP_CONFIG_DISPLAY:
-                cli_out ("\nSnapshot System Configuration:");
-                ret = dict_get_uint64 (dict, "snap-max-hard-limit",
-                                       &value);
+            for (i = 0; i < voldisplaycount; i++) {
+                ret = snprintf(buf, sizeof(buf), "volume%" PRIu64 "-volname",
+                               i);
+                ret = dict_get_strn(dict, buf, ret, &volname);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                "snap_max_hard_limit for %s", volname);
-                        ret = -1;
-                        goto out;
+                    gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+                    ret = -1;
+                    goto out;
                 }
-                cli_out ("snap-max-hard-limit : %"PRIu64, value);
+                cli_out("\nVolume : %s", volname);
 
-                ret = dict_get_uint64 (dict, "snap-max-soft-limit",
-                                       &soft_limit);
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-snap-max-hard-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                               "snap-max-soft-limit for %s", volname);
-                        ret = -1;
-                        goto out;
+                    gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+                    ret = -1;
+                    goto out;
                 }
-                cli_out ("snap-max-soft-limit : %"PRIu64"%%",
-                         soft_limit);
+                cli_out("snap-max-hard-limit : %" PRIu64, value);
 
-                cli_out ("auto-delete : %s", auto_delete);
-
-                cli_out ("activate-on-create : %s\n", snap_activate);
-
-                cli_out ("Snapshot Volume Configuration:");
-
-                ret = dict_get_uint64 (dict, "voldisplaycount",
-                                       &voldisplaycount);
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-active-hard-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                               "Could not fetch voldisplaycount");
-                        ret = -1;
-                        goto out;
-                }
-
-                for (i = 0; i < voldisplaycount; i++) {
-                        snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i);
-                        ret = dict_get_str (dict, buf, &volname);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("\nVolume : %s", volname);
-
-                        snprintf (buf, sizeof(buf),
-                                  "volume%"PRIu64"-snap-max-hard-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("snap-max-hard-limit : %"PRIu64, value);
-
-                        snprintf (buf, sizeof(buf),
-                                  "volume%"PRIu64"-active-hard-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                 gf_log ("cli", GF_LOG_ERROR, "Could not fetch"
-                                        " effective snap_max_hard_limit for "
-                                        "%s", volname);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("Effective snap-max-hard-limit : %"PRIu64,
-                                 value);
-
-                        snprintf (buf, sizeof(buf),
-                                      "volume%"PRIu64"-snap-max-soft-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("Effective snap-max-soft-limit : %"PRIu64" "
-                                 "(%"PRIu64"%%)", value, soft_limit);
-                }
-                break;
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Could not fetch"
+                           " effective snap_max_hard_limit for %s",
+                           volname);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("Effective snap-max-hard-limit : %" PRIu64, value);
+
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-snap-max-soft-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
+                if (ret) {
+                    gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("Effective snap-max-soft-limit : %" PRIu64
+                        " "
+                        "(%" PRIu64 "%%)",
+                        value, soft_limit);
+            }
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function is used to print the volume related information
@@ -9708,2338 +8651,2299 @@ out:
  * arg - 0, dict       : Response Dictionary.
  * arg - 1, prefix str : snaplist.snap{0..}.vol{0..}.*
  */
-int
-cli_get_each_volinfo_in_snap (dict_t *dict, char *keyprefix,
-                              gf_boolean_t snap_driven) {
-        char             key[PATH_MAX]  =  "";
-        char            *get_buffer     =  NULL;
-        int              value          =  0;
-        int              ret            = -1;
-        char             indent[5]      = "\t";
-        char            *volname        =  NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        if (snap_driven) {
-                ret = snprintf (key, sizeof (key), "%s.volname", keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &get_buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                        "Snap Volume Name", ":", get_buffer);
-
-                ret = snprintf (key, sizeof (key),
-                                "%s.origin-volname", keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING, "Failed to get %s", key);
-                        cli_out ("%-12s", "Origin:");
-                }
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                        "Origin Volume name", ":", volname);
-
-
-                ret = snprintf (key, sizeof (key), "%s.snapcount",
-                                keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_int32 (dict, key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s%s %s      %s %d", indent, "Snaps taken for",
-                        volname, ":", value);
-
-                ret = snprintf (key, sizeof (key), "%s.snaps-available",
-                                keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_int32 (dict, key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s%s %s  %s %d", indent, "Snaps available for",
-                         volname, ":", value);
-        }
+static int
+cli_get_each_volinfo_in_snap(dict_t *dict, char *keyprefix,
+                             gf_boolean_t snap_driven)
+{
+    char key[PATH_MAX] = "";
+    char *get_buffer = NULL;
+    int value = 0;
+    int ret = -1;
+    char indent[5] = "\t";
+    char *volname = NULL;
 
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
 
-        ret = snprintf (key, sizeof (key), "%s.vol-status", keyprefix);
+    if (snap_driven) {
+        ret = snprintf(key, sizeof(key), "%s.volname", keyprefix);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_str(dict, key, &get_buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
         }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Status",
-                 ":", get_buffer);
-out:
-        return ret;
-}
-
-/* This function is used to print snap related information
- * arg - 0, dict       : Response dictionary.
- * arg - 1, prefix_str : snaplist.snap{0..}.*
- */
-int
-cli_get_volinfo_in_snap (dict_t *dict, char *keyprefix) {
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snap Volume Name", ":",
+                get_buffer);
 
-        char            key[PATH_MAX]   = "";
-        int             i               = 0;
-        int             volcount        = 0;
-        int             ret             = -1;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        ret = snprintf (key, sizeof (key), "%s.vol-count", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.origin-volname", keyprefix);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_int32 (dict, key, &volcount);
-        for (i = 1 ; i <= volcount ; i++) {
-                ret = snprintf (key, sizeof (key),
-                                "%s.vol%d", keyprefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_volinfo_in_snap (dict, key, _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not list "
-                                "details of volume in a snap");
-                        goto out;
-                }
-                cli_out (" ");
+        ret = dict_get_str(dict, key, &volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_WARNING, "Failed to get %s", key);
+            cli_out("%-12s", "Origin:");
         }
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Origin Volume name", ":",
+                volname);
 
-out:
-        return ret;
-}
-
-int
-cli_get_each_snap_info (dict_t *dict, char *prefix_str,
-                        gf_boolean_t snap_driven) {
-        char            key_buffer[PATH_MAX] = "";
-        char           *get_buffer           = NULL;
-        int             ret                  = -1;
-        char            indent[5]            = "";
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix_str);
-
-        if (!snap_driven)
-                strcat (indent, "\t");
-
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snapname",
-                        prefix_str);
+        ret = snprintf(key, sizeof(key), "%s.snapcount", keyprefix);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
+        ret = dict_get_int32(dict, key, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ",
-                        key_buffer);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
         }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Snapshot",
-                ":", get_buffer);
+        cli_out("%s%s %s      %s %d", indent, "Snaps taken for", volname, ":",
+                value);
 
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-id",
-                        prefix_str);
+        ret = snprintf(key, sizeof(key), "%s.snaps-available", keyprefix);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
+        ret = dict_get_int32(dict, key, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ",
-                        key_buffer);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
         }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Snap UUID",
-                ":", get_buffer);
+        cli_out("%s%s %s  %s %d", indent, "Snaps available for", volname, ":",
+                value);
+    }
 
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-desc",
-                        prefix_str);
-        if (ret < 0) {
-                goto out;
-        }
+    ret = snprintf(key, sizeof(key), "%s.vol-status", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
 
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
-        if (!ret) {
-                /* Ignore error for description */
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                         "Description", ":", get_buffer);
-        }
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Status", ":", get_buffer);
+out:
+    return ret;
+}
+
+/* This function is used to print snap related information
+ * arg - 0, dict       : Response dictionary.
+ * arg - 1, prefix_str : snaplist.snap{0..}.*
+ */
+static int
+cli_get_volinfo_in_snap(dict_t *dict, char *keyprefix)
+{
+    char key[PATH_MAX] = "";
+    int i = 0;
+    int volcount = 0;
+    int ret = -1;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
 
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-time",
-                        prefix_str);
+    ret = snprintf(key, sizeof(key), "%s.vol-count", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, key, &volcount);
+    for (i = 1; i <= volcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
-
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
+        ret = cli_get_each_volinfo_in_snap(dict, key, _gf_true);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
-                        prefix_str);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not list details of volume in a snap");
+            goto out;
         }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Created",
-                ":", get_buffer);
+        cli_out(" ");
+    }
 
-        if (snap_driven) {
-                cli_out ("%-12s", "Snap Volumes:\n");
-                ret = cli_get_volinfo_in_snap (dict, prefix_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to list details "
-                                "of the snaps");
-                        goto out;
-                }
+out:
+    return ret;
+}
+
+static int
+cli_get_each_snap_info(dict_t *dict, char *prefix_str, gf_boolean_t snap_driven)
+{
+    char key_buffer[PATH_MAX] = "";
+    char *get_buffer = NULL;
+    int ret = -1;
+    char indent[5] = "";
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix_str);
+
+    if (!snap_driven)
+        strcat(indent, "\t");
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snapname", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ", key_buffer);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snapshot", ":", get_buffer);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-id", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ", key_buffer);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snap UUID", ":", get_buffer);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-desc", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (!ret) {
+        /* Ignore error for description */
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Description", ":",
+                get_buffer);
+    }
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-time", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
+               prefix_str);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Created", ":", get_buffer);
+
+    if (snap_driven) {
+        cli_out("%-12s", "Snap Volumes:\n");
+        ret = cli_get_volinfo_in_snap(dict, prefix_str);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to list details of the snaps");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* This is a generic function to print snap related information.
  * arg - 0, dict : Response Dictionary
  */
-int
-cli_call_snapshot_info (dict_t *dict, gf_boolean_t bool_snap_driven) {
-        int             snap_count       =  0;
-        char            key[PATH_MAX]    =  "";
-        int             ret              =  -1;
-        int             i                =   0;
+static int
+cli_call_snapshot_info(dict_t *dict, gf_boolean_t bool_snap_driven)
+{
+    int snap_count = 0;
+    char key[32] = "";
+    int ret = -1;
+    int i = 0;
 
-        GF_ASSERT (dict);
+    GF_ASSERT(dict);
 
-        ret = dict_get_int32 (dict, "snapcount", &snap_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapcount");
-                goto out;
-        }
+    ret = dict_get_int32_sizen(dict, "snapcount", &snap_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapcount");
+        goto out;
+    }
 
-        if (snap_count == 0) {
-                cli_out ("No snapshots present");
-        }
+    if (snap_count == 0) {
+        cli_out("No snapshots present");
+    }
 
-        for (i = 1 ; i <= snap_count ; i++) {
-                ret = snprintf (key, sizeof (key), "snap%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_snap_info (dict, key, bool_snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to print snap details");
-                        goto out;
-                }
+    for (i = 1; i <= snap_count; i++) {
+        ret = snprintf(key, sizeof(key), "snap%d", i);
+        if (ret < 0) {
+            goto out;
         }
+        ret = cli_get_each_snap_info(dict, key, bool_snap_driven);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to print snap details");
+            goto out;
+        }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-int
-cli_get_snaps_in_volume (dict_t *dict) {
-        int      ret             =  -1;
-        int      i               =  0;
-        int      count           =  0;
-        int      avail           =  0;
-        char     key[PATH_MAX]   =  "";
-        char    *get_buffer      =  NULL;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "origin-volname", &get_buffer);
+static int
+cli_get_snaps_in_volume(dict_t *dict)
+{
+    int ret = -1;
+    int i = 0;
+    int count = 0;
+    int avail = 0;
+    char key[32] = "";
+    char *get_buffer = NULL;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str_sizen(dict, "origin-volname", &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch origin-volname");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%s", "Volume Name", ":", get_buffer);
+
+    ret = dict_get_int32_sizen(dict, "snapcount", &avail);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snapcount");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%d", "Snaps Taken", ":", avail);
+
+    ret = dict_get_int32_sizen(dict, "snaps-available", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snaps-available");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%d", "Snaps Available", ":", count);
+
+    for (i = 1; i <= avail; i++) {
+        snprintf(key, sizeof(key), "snap%d", i);
+        ret = cli_get_each_snap_info(dict, key, _gf_false);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch origin-volname");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Unable to print snap details");
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%s", "Volume Name", ":", get_buffer);
 
-        ret = dict_get_int32 (dict, "snapcount", &avail);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snapcount");
-                goto out;
+        ret = snprintf(key, sizeof(key), "snap%d.vol1", i);
+        if (ret < 0) {
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%d", "Snaps Taken", ":", avail);
-
-        ret = dict_get_int32 (dict, "snaps-available", &count);
+        ret = cli_get_each_volinfo_in_snap(dict, key, _gf_false);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snaps-available");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not get volume related information");
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%d", "Snaps Available", ":", count);
-
-        for (i = 1 ; i <= avail ; i++) {
-                snprintf (key, sizeof (key), "snap%d", i);
-                ret = cli_get_each_snap_info (dict, key, _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to print snap details");
-                        goto out;
-                }
 
-                ret = snprintf (key, sizeof (key), "snap%d.vol1", i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_volinfo_in_snap (dict, key, _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get volume "
-                                "related information");
-                        goto out;
-                }
-
-                cli_out (" ");
-        }
+        cli_out(" ");
+    }
 out:
-        return ret;
+    return ret;
 }
 
-int
-cli_snapshot_list (dict_t *dict) {
-        int     snapcount       =       0;
-        char    key[PATH_MAX]   =       "";
-        int     ret             =       -1;
-        int     i               =       0;
-        char    *get_buffer     =       NULL;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snap count");
-                goto out;
-        }
-
-        if (snapcount == 0) {
-                cli_out ("No snapshots present");
-        }
-
-        for (i = 1 ; i <= snapcount ; i++) {
-                ret = snprintf (key, sizeof (key), "snapname%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
+static int
+cli_snapshot_list(dict_t *dict)
+{
+    int snapcount = 0;
+    char key[32] = "";
+    int ret = -1;
+    int i = 0;
+    char *get_buffer = NULL;
 
-                ret = dict_get_str (dict, key, &get_buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                } else {
-                        cli_out ("%s", get_buffer);
-                }
-        }
-out:
-        return ret;
-}
+    GF_ASSERT(dict);
 
-int
-cli_get_snap_volume_status (dict_t *dict, char *key_prefix)
-{
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        char            *buffer         =       NULL;
-        int             brickcount      =       0;
-        int             i               =       0;
-        int             pid             =       0;
+    ret = dict_get_int32_sizen(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snap count");
+        goto out;
+    }
 
-        GF_ASSERT (dict);
-        GF_ASSERT (key_prefix);
+    if (snapcount == 0) {
+        cli_out("No snapshots present");
+    }
 
-        ret = snprintf (key, sizeof (key), "%s.brickcount", key_prefix);
+    for (i = 1; i <= snapcount; i++) {
+        ret = snprintf(key, sizeof(key), "snapname%d", i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
-        ret = dict_get_int32 (dict, key, &brickcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
-                goto out;
-        }
-
-        for (i = 0 ; i < brickcount ; i++) {
-                ret = snprintf (key, sizeof (key), "%s.brick%d.path",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Path");
-                        continue;
-                }
-                cli_out ("\n\t%-17s %s   %s", "Brick Path", ":", buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.vgname",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Volume Group");
-                        cli_out ("\t%-17s %s   %s", "Volume Group", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Volume Group", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.status",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Running");
-                        cli_out ("\t%-17s %s   %s", "Brick Running", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Brick Running", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.pid",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get pid");
-                        cli_out ("\t%-17s %s   %s", "Brick PID", ":", "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %d", "Brick PID", ":", pid);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.data",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Data Percent");
-                        cli_out ("\t%-17s %s   %s", "Data Percentage", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Data Percentage", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.lvsize",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO, "Unable to get LV Size");
-                        cli_out ("\t%-17s %s   %s", "LV Size", ":", "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "LV Size", ":", buffer);
 
+        ret = dict_get_strn(dict, key, ret, &get_buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
+        } else {
+            cli_out("%s", get_buffer);
         }
-
-        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
-int
-cli_get_single_snap_status (dict_t *dict, char *keyprefix)
-{
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        int             i               =       0;
-        int             volcount        =       0;
-        char            *get_buffer     =       NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        ret = snprintf (key, sizeof (key), "%s.snapname", keyprefix);
+static int
+cli_get_snap_volume_status(dict_t *dict, char *key_prefix)
+{
+    int ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+    int brickcount = 0;
+    int i = 0;
+    int pid = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(key_prefix);
+
+    ret = snprintf(key, sizeof(key), "%s.brickcount", key_prefix);
+    if (ret < 0) {
+        goto out;
+    }
+    ret = dict_get_int32(dict, key, &brickcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
+        goto out;
+    }
+
+    for (i = 0; i < brickcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.brick%d.path", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapname");
-                goto out;
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Path");
+            continue;
         }
-        cli_out ("\nSnap Name : %s", get_buffer);
+        cli_out("\n\t%-17s %s   %s", "Brick Path", ":", buffer);
 
-        ret = snprintf (key, sizeof (key), "%s.uuid", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.vgname", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snap UUID");
-                goto out;
-        }
-        cli_out ("Snap UUID : %s", get_buffer);
+            gf_log("cli", GF_LOG_INFO, "Unable to get Volume Group");
+            cli_out("\t%-17s %s   %s", "Volume Group", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Volume Group", ":", buffer);
 
-        ret = snprintf (key, sizeof (key), "%s.volcount", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.status", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_int32 (dict, key, &volcount);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get volume count");
-                goto out;
-        }
-
-        for (i = 0 ; i < volcount ; i++) {
-                ret = snprintf (key, sizeof (key), "%s.vol%d", keyprefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Running");
+            cli_out("\t%-17s %s   %s", "Brick Running", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Brick Running", ":", buffer);
 
-                ret = cli_get_snap_volume_status (dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not get snap volume status");
-                        goto out;
-                }
+        ret = snprintf(key, sizeof(key), "%s.brick%d.pid", key_prefix, i);
+        if (ret < 0) {
+            goto out;
         }
-out:
-        return ret;
-}
-
-int32_t
-cli_populate_req_dict_for_delete (dict_t *snap_dict, dict_t *dict, size_t index)
-{
-        int32_t         ret             = -1;
-        char            key[PATH_MAX]   = "";
-        char            *buffer         = NULL;
-
-        GF_ASSERT (snap_dict);
-        GF_ASSERT (dict);
 
-        ret = dict_set_int32 (snap_dict, "sub-cmd",
-                              GF_SNAP_DELETE_TYPE_ITER);
+        ret = dict_get_int32(dict, key, &pid);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save command "
-                        "type in snap dictionary");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get pid");
+            cli_out("\t%-17s %s   %s", "Brick PID", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %d", "Brick PID", ":", pid);
 
-        ret = snprintf (key, sizeof (key), "snapname%zu", index);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.data", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapname");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get Data Percent");
+            cli_out("\t%-17s %s   %s", "Data Percentage", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Data Percentage", ":", buffer);
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "snapname", buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to save snapname");
-                goto out;
+        ret = snprintf(key, sizeof(key), "%s.brick%d.lvsize", key_prefix, i);
+        if (ret < 0) {
+            goto out;
         }
-
-        ret = dict_set_int32 (snap_dict, "type", GF_SNAP_OPTION_TYPE_DELETE);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to save command type");
-                goto out;
+            gf_log("cli", GF_LOG_INFO, "Unable to get LV Size");
+            cli_out("\t%-17s %s   %s", "LV Size", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "LV Size", ":", buffer);
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
+
+static int
+cli_get_single_snap_status(dict_t *dict, char *keyprefix)
+{
+    int ret = -1;
+    char key[64] = ""; /* keyprefix is ""status.snap0" */
+    int i = 0;
+    int volcount = 0;
+    char *get_buffer = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    ret = snprintf(key, sizeof(key), "%s.snapname", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapname");
+        goto out;
+    }
+    cli_out("\nSnap Name : %s", get_buffer);
+
+    ret = snprintf(key, sizeof(key), "%s.uuid", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snap UUID");
+        goto out;
+    }
+    cli_out("Snap UUID : %s", get_buffer);
+
+    ret = snprintf(key, sizeof(key), "%s.volcount", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, key, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get volume count");
+        goto out;
+    }
+
+    for (i = 0; i < volcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
+        if (ret < 0) {
+            goto out;
         }
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "cmd-str",
-                                       "snapshot delete");
+        ret = cli_get_snap_volume_status(dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command string as delete");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snap volume status");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-int
-cli_populate_req_dict_for_status (dict_t *snap_dict, dict_t *dict, int index)
+static int32_t
+cli_populate_req_dict_for_delete(dict_t *snap_dict, dict_t *dict, size_t index)
+{
+    int32_t ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+
+    GF_ASSERT(snap_dict);
+    GF_ASSERT(dict);
+
+    ret = dict_set_int32_sizen(snap_dict, "sub-cmd", GF_SNAP_DELETE_TYPE_ITER);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save command type in snap dictionary");
+        goto out;
+    }
+
+    ret = snprintf(key, sizeof(key), "snapname%zu", index);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapname");
+        goto out;
+    }
+
+    ret = dict_set_dynstr_with_alloc(snap_dict, "snapname", buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save snapname");
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(snap_dict, "type", GF_SNAP_OPTION_TYPE_DELETE);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save command type");
+        goto out;
+    }
+
+    ret = dict_set_dynstr_with_alloc(snap_dict, "cmd-str", "snapshot delete");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command string as delete");
+        goto out;
+    }
+out:
+    return ret;
+}
+
+static int
+cli_populate_req_dict_for_status(dict_t *snap_dict, dict_t *dict, int index)
 {
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        char            *buffer         =       NULL;
+    int ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
 
-        GF_ASSERT (snap_dict);
-        GF_ASSERT (dict);
+    GF_ASSERT(snap_dict);
+    GF_ASSERT(dict);
 
-        ret = dict_set_uint32 (snap_dict, "sub-cmd",
-                               GF_SNAP_STATUS_TYPE_ITER);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save command "
-                        "type in snap dict");
-                goto out;
-        }
+    ret = dict_set_uint32(snap_dict, "sub-cmd", GF_SNAP_STATUS_TYPE_ITER);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command type in snap dict");
+        goto out;
+    }
 
-        ret = snprintf (key, sizeof (key), "status.snap%d.snapname", index);
-         if (ret < 0) {
-                 goto out;
-         }
+    ret = snprintf(key, sizeof(key), "status.snap%d.snapname", index);
+    if (ret < 0) {
+        goto out;
+    }
 
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get snapname");
-                goto out;
-        }
+    ret = dict_get_strn(dict, key, ret, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get snapname");
+        goto out;
+    }
 
-        ret = dict_set_str (snap_dict, "snapname", buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save snapname "
-                        "in snap dict");
-                goto out;
+    ret = dict_set_str_sizen(snap_dict, "snapname", buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save snapname in snap dict");
+        goto out;
+    }
 
-        }
+    ret = dict_set_int32_sizen(snap_dict, "type", GF_SNAP_OPTION_TYPE_STATUS);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command type");
+        goto out;
+    }
 
-        ret = dict_set_int32 (snap_dict, "type", GF_SNAP_OPTION_TYPE_STATUS);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command type");
-                goto out;
-        }
+    ret = dict_set_dynstr_with_alloc(snap_dict, "cmd-str", "snapshot status");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command string as status");
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(snap_dict, "hold_vol_locks", _gf_false);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Setting volume lock flag failed");
+        goto out;
+    }
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "cmd-str",
-                                       "snapshot status");
+out:
+    return ret;
+}
+
+static int
+cli_snapshot_status(dict_t *dict, gf_cli_rsp *rsp, call_frame_t *frame)
+{
+    int ret = -1;
+    int status_cmd = -1;
+    cli_local_t *local = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(rsp);
+    GF_ASSERT(frame);
+
+    local = ((call_frame_t *)frame)->local;
+    if (!local) {
+        gf_log("cli", GF_LOG_ERROR, "frame->local is NULL");
+        goto out;
+    }
+
+    if (rsp->op_ret) {
+        if (rsp->op_errstr) {
+            ret = dict_set_dynstr_with_alloc(local->dict, "op_err_str",
+                                             rsp->op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to set op_errstr in local dictionary");
+                goto out;
+            }
+        }
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    ret = dict_get_int32_sizen(dict, "sub-cmd", &status_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch status type");
+        goto out;
+    }
+
+    if ((status_cmd != GF_SNAP_STATUS_TYPE_SNAP) &&
+        (status_cmd != GF_SNAP_STATUS_TYPE_ITER)) {
+        dict_copy(dict, local->dict);
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_status_single_snap(local, dict, "status.snap0");
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command string as status");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create xml output for snapshot status");
         }
-
-        ret = dict_set_int32 (snap_dict, "hold_vol_locks", _gf_false);
+    } else {
+        ret = cli_get_single_snap_status(dict, "status.snap0");
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Setting volume lock flag failed");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch status of snap");
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-int
-cli_snapshot_status (dict_t *dict, gf_cli_rsp *rsp,
-                             call_frame_t *frame)
-{
-        char            key[PATH_MAX]   =       "";
-        int             ret             =       -1;
-        int             status_cmd      =       -1;
-        cli_local_t     *local          =       NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (rsp);
-        GF_ASSERT (frame);
-
-        local = ((call_frame_t *) frame) -> local;
-        if (!local) {
-                gf_log ("cli", GF_LOG_ERROR, "frame->local is NULL");
-                goto out;
-        }
-
-        if (rsp->op_ret) {
-                if (rsp->op_errstr) {
-                        ret = dict_set_dynstr_with_alloc (local->dict,
-                                                          "op_err_str",
-                                                          rsp->op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                        "op_errstr in local dictionary");
-                                goto out;
-                        }
-                }
-                ret = rsp->op_ret;
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "sub-cmd", &status_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch status type");
+static int
+gf_cli_generate_snapshot_event(gf_cli_rsp *rsp, dict_t *dict, int32_t type,
+                               char *snap_name, char *volname, char *snap_uuid,
+                               char *clone_name)
+{
+    int ret = -1;
+    int config_command = 0;
+    int32_t delete_cmd = -1;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+    char msg[PATH_MAX] = {
+        0,
+    };
+    char option[512] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
+    GF_VALIDATE_OR_GOTO("cli", rsp, out);
+
+    switch (type) {
+        case GF_SNAP_OPTION_TYPE_CREATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
                 goto out;
-        }
+            }
 
-        if ((status_cmd != GF_SNAP_STATUS_TYPE_SNAP) &&
-            (status_cmd != GF_SNAP_STATUS_TYPE_ITER)) {
-                dict_copy (dict, local->dict);
+            if (!volname) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
                 goto out;
-        }
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CREATE_FAILED,
+                         "snapshot_name=%s;volume_name=%s;error=%s", snap_name,
+                         volname,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-        ret = snprintf (key, sizeof (key), "status.snap0");
-        if (ret < 0) {
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
                 goto out;
-        }
+            }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_status_single_snap (local, dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot status");
-                        goto out;
-                }
-        } else {
-                ret = cli_get_single_snap_status (dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                "status of snap");
-                        goto out;
-                }
-        }
+            gf_event(EVENT_SNAPSHOT_CREATED,
+                     "snapshot_name=%s;volume_name=%s;snapshot_uuid=%s",
+                     snap_name, volname, snap_uuid);
 
-        ret = 0;
-out:
-        return ret;
-}
+            ret = 0;
+            break;
 
-int
-gf_cli_generate_snapshot_event (gf_cli_rsp *rsp, dict_t *dict,
-                                int32_t type, char *snap_name,
-                                char *volname, char *snap_uuid,
-                                char *clone_name)
-{
-        int         ret               = -1;
-        int         config_command    = 0;
-        int32_t     delete_cmd        = -1;
-        uint64_t    hard_limit        = 0;
-        uint64_t    soft_limit        = 0;
-        char       *auto_delete       = NULL;
-        char       *snap_activate     = NULL;
-        char        msg[PATH_MAX]     = {0, };
-        char        option[PATH_MAX]  = {0, };
-
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-        GF_VALIDATE_OR_GOTO ("cli", rsp, out);
-
-        switch (type) {
-        case GF_SNAP_OPTION_TYPE_CREATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
-
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get volume name");
-                        goto out;
-                }
-
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CREATE_FAILED,
-                                  "snapshot_name=%s;volume_name=%s;error=%s",
-                                  snap_name, volname,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
-
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
-
-                gf_event (EVENT_SNAPSHOT_CREATED, "snapshot_name=%s;"
-                          "volume_name=%s;snapshot_uuid=%s", snap_name,
-                          volname, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_ACTIVATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_ACTIVATE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_ACTIVATE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_ACTIVATED,
+                     "snapshot_name=%s;snapshot_uuid=%s", snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_ACTIVATED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_DEACTIVATE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_DEACTIVATE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_DEACTIVATED,
+                     "snapshot_name=%s;snapshot_uuid=%s", snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_DEACTIVATED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_RESTORE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_RESTORE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_RESTORE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_RESTORE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            if (!volname) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volname");
+                goto out;
+            }
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            gf_event(EVENT_SNAPSHOT_RESTORED,
+                     "snapshot_name=%s;snapshot_uuid=%s;volume_name=%s",
+                     snap_name, snap_uuid, volname);
 
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get volname");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_RESTORED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s;volume_name=%s",
-                          snap_name, snap_uuid, volname);
+        case GF_SNAP_OPTION_TYPE_DELETE:
+            ret = dict_get_int32_sizen(dict, "sub-cmd", &delete_cmd);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not get sub-cmd");
+                goto out;
+            }
 
+            /*
+             * Need not generate any event (success or failure) for delete *
+             * all, as it will trigger individual delete for all snapshots *
+             */
+            if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL) {
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_DELETE:
-                ret = dict_get_int32 (dict, "sub-cmd", &delete_cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get sub-cmd");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                /*
-                 * Need not generate any event (success or failure) for delete *
-                 * all, as it will trigger individual delete for all snapshots *
-                 */
-                if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL) {
-                        ret = 0;
-                        break;
-                }
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_DELETE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_DELETE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_DELETED,
+                     "snapshot_name=%s;snapshot_uuid=%s", snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_DELETED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_CLONE:
+            if (!clone_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+                goto out;
+            }
+
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snapname name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CLONE_FAILED,
+                         "snapshot_name=%s;clone_name=%s;error=%s", snap_name,
+                         clone_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_CLONE:
-                if (!clone_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get clone name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snapname name");
-                        goto out;
-                }
+            gf_event(EVENT_SNAPSHOT_CLONED,
+                     "snapshot_name=%s;clone_name=%s;clone_uuid=%s", snap_name,
+                     clone_name, snap_uuid);
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CLONE_FAILED,
-                                  "snapshot_name=%s;clone_name=%s;"
-                                  "error=%s", snap_name, clone_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            ret = 0;
+            break;
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+        case GF_SNAP_OPTION_TYPE_CONFIG:
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CONFIG_UPDATE_FAILED, "error=%s",
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-                gf_event (EVENT_SNAPSHOT_CLONED, "snapshot_name=%s;"
-                          "clone_name=%s;clone_uuid=%s",
-                          snap_name, clone_name, snap_uuid);
+            ret = dict_get_int32_sizen(dict, "config-command", &config_command);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+                goto out;
+            }
 
+            if (config_command == GF_SNAP_CONFIG_DISPLAY) {
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_CONFIG:
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CONFIG_UPDATE_FAILED,
-                                  "error=%s",
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            /* These are optional parameters therefore ignore the error */
+            ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+            ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+            ret = dict_get_str_sizen(dict, "auto-delete", &auto_delete);
+            ret = dict_get_str_sizen(dict, "snap-activate-on-create",
+                                     &snap_activate);
 
-                ret = dict_get_int32 (dict, "config-command", &config_command);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not fetch config type");
-                        goto out;
-                }
-
-                if (config_command == GF_SNAP_CONFIG_DISPLAY) {
-                        ret = 0;
-                        break;
-                }
+            if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR,
+                       "At least one option from "
+                       "snap-max-hard-limit, snap-max-soft-limit, "
+                       "auto-delete and snap-activate-on-create "
+                       "should be set");
+                goto out;
+            }
 
-                /* These are optional parameters therefore ignore the error */
-                ret = dict_get_uint64 (dict, "snap-max-hard-limit",
-                                       &hard_limit);
-                ret = dict_get_uint64 (dict, "snap-max-soft-limit",
-                                       &soft_limit);
-                ret = dict_get_str (dict, "auto-delete",
-                                    &auto_delete);
-                ret = dict_get_str (dict, "snap-activate-on-create",
-                                    &snap_activate);
-
-                if (!hard_limit && !soft_limit &&
-                    !auto_delete && !snap_activate) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "At least one option from "
-                                "snap-max-hard-limit, snap-max-soft-limit, "
-                                "auto-delete and snap-activate-on-create "
-                                "should be set");
-                        goto out;
-                }
+            if (hard_limit || soft_limit) {
+                snprintf(option, sizeof(option), "%s=%" PRIu64,
+                         hard_limit ? "hard_limit" : "soft_limit",
+                         hard_limit ? hard_limit : soft_limit);
+            } else if (auto_delete || snap_activate) {
+                snprintf(option, sizeof(option), "%s=%s",
+                         auto_delete ? "auto-delete" : "snap-activate",
+                         auto_delete ? auto_delete : snap_activate);
+            }
 
-                volname = NULL;
-                ret = dict_get_str (dict, "volname", &volname);
-
-                if (hard_limit || soft_limit) {
-                        snprintf (option, sizeof(option), "%s=%"PRIu64,
-                                  hard_limit ? "hard_limit" : "soft_limit",
-                                  hard_limit ? hard_limit:soft_limit);
-                } else if (auto_delete || snap_activate) {
-                        snprintf (option, sizeof(option), "%s=%s",
-                                  auto_delete ? "auto-delete" : "snap-activate",
-                                  auto_delete ? auto_delete:snap_activate);
-                }
+            volname = NULL;
+            ret = dict_get_str_sizen(dict, "volname", &volname);
 
-                snprintf (msg, sizeof(msg), "config_type=%s;%s",
-                          volname?"volume_config":"system_config", option);
+            snprintf(msg, sizeof(msg), "config_type=%s;%s",
+                     volname ? "volume_config" : "system_config", option);
 
-                gf_event (EVENT_SNAPSHOT_CONFIG_UPDATED, "%s", msg);
+            gf_event(EVENT_SNAPSHOT_CONFIG_UPDATED, "%s", msg);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         default:
-                gf_log ("cli", GF_LOG_WARNING,
-                        "Cannot generate event for unknown type.");
-                ret = 0;
-                goto out;
-        }
+            gf_log("cli", GF_LOG_WARNING,
+                   "Cannot generate event for unknown type.");
+            ret = 0;
+            goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /*
  * Fetch necessary data from dict at one place instead of *
  * repeating the same code again and again.               *
  */
-int
-gf_cli_snapshot_get_data_from_dict (dict_t *dict, char **snap_name,
-                                    char **volname, char **snap_uuid,
-                                    int8_t *soft_limit_flag,
-                                    char **clone_name)
+static int
+gf_cli_snapshot_get_data_from_dict(dict_t *dict, char **snap_name,
+                                   char **volname, char **snap_uuid,
+                                   int8_t *soft_limit_flag, char **clone_name)
 {
-        int     ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-
-        if (snap_name)
-                ret = dict_get_str (dict, "snapname", snap_name);
+    int ret = -1;
 
-        if (volname)
-                ret = dict_get_str (dict, "volname1", volname);
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
 
-        if (snap_uuid)
-                ret = dict_get_str (dict, "snapuuid", snap_uuid);
-
-        if (soft_limit_flag)
-                ret = dict_get_int8 (dict, "soft-limit-reach",
-                                     soft_limit_flag);
-
-        if (clone_name)
-                ret = dict_get_str (dict, "clonename", clone_name);
-
-        ret = 0;
-out:
-        return ret;
-}
-
-int
-gf_cli_snapshot_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        int                   ret                      = -1;
-        gf_cli_rsp            rsp                      = {0, };
-        dict_t               *dict                     = NULL;
-        char                 *snap_name                = NULL;
-        char                 *clone_name               = NULL;
-        int32_t               type                     =  0;
-        call_frame_t         *frame                    = NULL;
-        gf_boolean_t         snap_driven               = _gf_false;
-        int8_t               soft_limit_flag           = -1;
-        char                 *volname                  = NULL;
-        char                 *snap_uuid                = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
+    if (snap_name) {
+        ret = dict_get_str_sizen(dict, "snapname", snap_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get snapname from dict");
         }
+    }
 
-        frame = myframe;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+    if (volname) {
+        ret = dict_get_str_sizen(dict, "volname1", volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get volname1 from dict");
         }
+    }
 
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
+    if (snap_uuid) {
+        ret = dict_get_str_sizen(dict, "snapuuid", snap_uuid);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get snapuuid from dict");
         }
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "type", &type);
+    if (soft_limit_flag) {
+        ret = dict_get_int8(dict, "soft-limit-reach", soft_limit_flag);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to get type");
-                goto out;
+            gf_log("cli", GF_LOG_DEBUG,
+                   "failed to get soft-limit-reach from dict");
         }
+    }
 
-        ret = gf_cli_snapshot_get_data_from_dict (dict, &snap_name, &volname,
-                                                  &snap_uuid, &soft_limit_flag,
-                                                  &clone_name);
+    if (clone_name) {
+        ret = dict_get_str_sizen(dict, "clonename", clone_name);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch data from dict.");
-                goto out;
+            gf_log("cli", GF_LOG_DEBUG, "failed to get clonename from dict");
         }
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
+
+static int
+gf_cli_snapshot_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *snap_name = NULL;
+    char *clone_name = NULL;
+    int32_t type = 0;
+    call_frame_t *frame = NULL;
+    gf_boolean_t snap_driven = _gf_false;
+    int8_t soft_limit_flag = -1;
+    char *volname = NULL;
+    char *snap_uuid = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get type");
+        goto out;
+    }
+
+    ret = gf_cli_snapshot_get_data_from_dict(
+        dict, &snap_name, &volname, &snap_uuid, &soft_limit_flag, &clone_name);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch data from dict.");
+        goto out;
+    }
 
 #if (USE_EVENTS)
-        ret = gf_cli_generate_snapshot_event (&rsp, dict, type, snap_name,
-                                              volname, snap_uuid, clone_name);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to generate snapshot event");
-                goto out;
-        }
+    ret = gf_cli_generate_snapshot_event(&rsp, dict, type, snap_name, volname,
+                                         snap_uuid, clone_name);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to generate snapshot event");
+        goto out;
+    }
 #endif
 
-        /* Snapshot status and delete command is handled separately */
-        if (global_state->mode & GLUSTER_MODE_XML &&
-            GF_SNAP_OPTION_TYPE_STATUS != type &&
-            GF_SNAP_OPTION_TYPE_DELETE != type) {
-                ret = cli_xml_output_snapshot (type, dict, rsp.op_ret,
-                                               rsp.op_errno, rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-                }
-
-                goto out;
+    /* Snapshot status and delete command is handled separately */
+    if (global_state->mode & GLUSTER_MODE_XML &&
+        GF_SNAP_OPTION_TYPE_STATUS != type &&
+        GF_SNAP_OPTION_TYPE_DELETE != type) {
+        ret = cli_xml_output_snapshot(type, dict, rsp.op_ret, rsp.op_errno,
+                                      rsp.op_errstr);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
         }
 
-        switch (type) {
+        goto out;
+    }
+
+    switch (type) {
         case GF_SNAP_OPTION_TYPE_CREATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot create: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot create: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get volume name");
-                        goto out;
-                }
+            if (!volname) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+                goto out;
+            }
 
-                cli_out ("snapshot create: success: Snap %s created "
-                                        "successfully", snap_name);
+            cli_out("snapshot create: success: Snap %s created successfully",
+                    snap_name);
 
-                if (soft_limit_flag == 1) {
-                        cli_out ("Warning: Soft-limit of volume (%s) is "
-                                "reached. Snapshot creation is not possible "
-                                "once hard-limit is reached.", volname);
-                }
-                ret = 0;
-                break;
+            if (soft_limit_flag == 1) {
+                cli_out(
+                    "Warning: Soft-limit of volume (%s) is "
+                    "reached. Snapshot creation is not possible "
+                    "once hard-limit is reached.",
+                    volname);
+            }
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_CLONE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot clone: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot clone: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!clone_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get clone name");
-                        goto out;
-                }
+            if (!clone_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snapname name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snapname name");
+                goto out;
+            }
 
-                cli_out ("snapshot clone: success: Clone %s created "
-                                        "successfully", clone_name);
+            cli_out("snapshot clone: success: Clone %s created successfully",
+                    clone_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_RESTORE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot restore: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot restore: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot restore: %s: Snap restored "
-                                 "successfully", snap_name);
+            cli_out("Snapshot restore: %s: Snap restored successfully",
+                    snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot activate: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot activate: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot activate: %s: Snap activated "
-                                 "successfully", snap_name);
+            cli_out("Snapshot activate: %s: Snap activated successfully",
+                    snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot deactivate: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot deactivate: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot deactivate: %s: Snap deactivated "
-                                 "successfully", snap_name);
+            cli_out("Snapshot deactivate: %s: Snap deactivated successfully",
+                    snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case GF_SNAP_OPTION_TYPE_INFO:
-                if (rsp.op_ret) {
-                        cli_err ("Snapshot info : failed: %s",
-                                  rsp.op_errstr ? rsp.op_errstr :
-                                  "Please check log file for details");
-                        ret = rsp.op_ret;
-                        goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("Snapshot info : failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                snap_driven = dict_get_str_boolean (dict, "snap-driven",
-                                                    _gf_false);
-                if (snap_driven == _gf_true) {
-                        ret = cli_call_snapshot_info  (dict, snap_driven);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Snapshot info failed");
-                                goto out;
-                        }
-                } else if (snap_driven == _gf_false) {
-                        ret = cli_get_snaps_in_volume (dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Snapshot info failed");
-                                goto out;
-                        }
+            snap_driven = dict_get_str_boolean(dict, "snap-driven", _gf_false);
+            if (snap_driven == _gf_true) {
+                ret = cli_call_snapshot_info(dict, snap_driven);
+                if (ret) {
+                    gf_log("cli", GF_LOG_ERROR, "Snapshot info failed");
+                    goto out;
                 }
-                break;
-
-        case GF_SNAP_OPTION_TYPE_CONFIG:
-                ret = cli_snapshot_config_display (dict, &rsp);
+            } else if (snap_driven == _gf_false) {
+                ret = cli_get_snaps_in_volume(dict);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot config output.");
-                        goto out;
+                    gf_log("cli", GF_LOG_ERROR, "Snapshot info failed");
+                    goto out;
                 }
-                break;
+            }
+            break;
+
+        case GF_SNAP_OPTION_TYPE_CONFIG:
+            ret = cli_snapshot_config_display(dict, &rsp);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to display snapshot config output.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_LIST:
-                if (rsp.op_ret) {
-                        cli_err ("Snapshot list : failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                "Please check log file for details");
-                        ret = rsp.op_ret;
-                        goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("Snapshot list : failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                ret = cli_snapshot_list (dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot list");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_list(dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to display snapshot list");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_DELETE:
-                ret = cli_snapshot_remove_reply (&rsp, dict, frame);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to delete snap");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_remove_reply(&rsp, dict, frame);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to delete snap");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_STATUS:
-                ret = cli_snapshot_status (dict, &rsp, frame);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot status output.");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_status(dict, &rsp, frame);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to display snapshot status output.");
+                goto out;
+            }
+            break;
 
         default:
-                cli_err ("Unknown command executed");
-                ret = -1;
-                goto out;
-        }
+            cli_err("Unknown command executed");
+            ret = -1;
+            goto out;
+    }
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_snapshot_for_delete (call_frame_t *frame, xlator_t *this,
-                            void *data)
-{
-        gf_cli_req      req                     = {{0,}};
-        int32_t         ret                     = -1;
-        int32_t         cmd                     = -1;
-        cli_local_t     *local                  = NULL;
-        dict_t          *snap_dict              = NULL;
-        int32_t         snapcount               = 0;
-        int             i                       = 0;
-        char            question[PATH_MAX]      = "";
-        char            *volname                = NULL;
-        gf_answer_t     answer                  = GF_ANSWER_NO;
-
-        GF_VALIDATE_OR_GOTO ("cli", frame,  out);
-        GF_VALIDATE_OR_GOTO ("cli", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("cli", this, out);
-        GF_VALIDATE_OR_GOTO ("cli", data, out);
-
-        local = frame->local;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                goto out;
-        }
+gf_cli_snapshot_for_delete(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int32_t ret = -1;
+    int32_t cmd = -1;
+    cli_local_t *local = NULL;
+    dict_t *snap_dict = NULL;
+    int32_t snapcount = 0;
+    int i = 0;
+    char question[PATH_MAX] = "";
+    char *volname = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    GF_VALIDATE_OR_GOTO("cli", frame, out);
+    GF_VALIDATE_OR_GOTO("cli", frame->local, out);
+    GF_VALIDATE_OR_GOTO("cli", this, out);
+    GF_VALIDATE_OR_GOTO("cli", data, out);
+
+    local = frame->local;
+
+    ret = dict_get_int32_sizen(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
+        goto out;
+    }
+
+    /* No need multiple RPCs for individual snapshot delete*/
+    if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        ret = 0;
+        goto out;
+    }
 
-        /* No need multiple RPCs for individual snapshot delete*/
-        if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
-                ret = 0;
-                goto out;
-        }
+    ret = dict_get_int32_sizen(local->dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get snapcount");
+        goto out;
+    }
 
-        ret = dict_get_int32 (local->dict, "snapcount",
-                              &snapcount);
+    if (global_state->mode & GLUSTER_MODE_XML) {
+#ifdef HAVE_LIB_XML
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"snapCount", "%d", snapcount);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get "
-                        "snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to write xml element \"snapCount\"");
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-#ifdef HAVE_LIB_XML
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                (xmlChar *)"snapCount",
-                                                "%d", snapcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to write "
-                                "xml element \"snapCount\"");
-                        goto out;
-                }
 #endif /* HAVE_LIB_XML */
-        } else if (snapcount == 0) {
-                cli_out ("No snapshots present");
-                goto out;
+    } else if (snapcount == 0) {
+        cli_out("No snapshots present");
+        goto out;
+    }
+
+    if (cmd == GF_SNAP_DELETE_TYPE_ALL) {
+        snprintf(question, sizeof(question),
+                 "System contains %d snapshot(s).\nDo you still "
+                 "want to continue and delete them? ",
+                 snapcount);
+    } else {
+        ret = dict_get_str_sizen(local->dict, "volname", &volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to fetch volname from local dictionary");
+            goto out;
         }
 
-        if (cmd == GF_SNAP_DELETE_TYPE_ALL) {
-                snprintf (question, sizeof (question), "System contains %d "
-                          "snapshot(s).\nDo you still "
-                          "want to continue and delete them? ",
-                           snapcount);
-        } else {
-                ret = dict_get_str (local->dict, "volname", &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to fetch "
-                                "volname from local dictionary");
-                        goto out;
-                }
-
-                snprintf (question, sizeof (question), "Volume (%s) contains "
-                          "%d snapshot(s).\nDo you still want to "
-                           "continue and delete them? ", volname,
-                           snapcount);
-        }
+        snprintf(question, sizeof(question),
+                 "Volume (%s) contains %d snapshot(s).\nDo you still want to "
+                 "continue and delete them? ",
+                 volname, snapcount);
+    }
 
-        answer = cli_cmd_get_confirmation (global_state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot delete operation for snap delete");
-                goto out;
-        }
+    answer = cli_cmd_get_confirmation(global_state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        gf_log("cli", GF_LOG_DEBUG,
+               "User cancelled snapshot delete operation for snap delete");
+        goto out;
+    }
 
-        for (i = 1 ; i <= snapcount ; i++) {
-                ret = -1;
+    for (i = 1; i <= snapcount; i++) {
+        ret = -1;
 
-                snap_dict = dict_new();
-                if (!snap_dict)
-                        goto out;
+        snap_dict = dict_new();
+        if (!snap_dict)
+            goto out;
 
-                ret = cli_populate_req_dict_for_delete (snap_dict,
-                                                       local->dict, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                "populate snap request dictionary");
-                        goto out;
-                }
+        ret = cli_populate_req_dict_for_delete(snap_dict, local->dict, i);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not populate snap request dictionary");
+            goto out;
+        }
 
-                ret = cli_to_glusterd (&req, frame,
-                                gf_cli_snapshot_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, snap_dict,
-                                GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                                NULL);
-                if (ret) {
-                        /* Fail the operation if deleting one of the
-                         * snapshots is failed
-                         */
-                        gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd "
-                                "for snapshot delete failed");
-                        goto out;
-                }
-                dict_unref (snap_dict);
-                snap_dict = NULL;
+        ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                              (xdrproc_t)xdr_gf_cli_req, snap_dict,
+                              GLUSTER_CLI_SNAP, this, cli_rpc_prog, NULL);
+        if (ret) {
+            /* Fail the operation if deleting one of the
+             * snapshots is failed
+             */
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli_to_glusterd for snapshot delete failed");
+            goto out;
         }
+        dict_unref(snap_dict);
+        snap_dict = NULL;
+    }
 
 out:
-        if (snap_dict)
-                dict_unref (snap_dict);
+    if (snap_dict)
+        dict_unref(snap_dict);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_snapshot_for_status (call_frame_t *frame, xlator_t *this,
-                            void *data)
-{
+static int32_t
+gf_cli_snapshot_for_status(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = -1;
+    int32_t cmd = -1;
+    cli_local_t *local = NULL;
+    dict_t *snap_dict = NULL;
+    int snapcount = 0;
+    int i = 0;
+
+    GF_VALIDATE_OR_GOTO("cli", frame, out);
+    GF_VALIDATE_OR_GOTO("cli", frame->local, out);
+    GF_VALIDATE_OR_GOTO("cli", this, out);
+    GF_VALIDATE_OR_GOTO("cli", data, out);
+
+    local = frame->local;
+
+    ret = dict_get_int32_sizen(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
+        goto out;
+    }
+
+    /* Snapshot status of single snap (i.e. GF_SNAP_STATUS_TYPE_SNAP)
+     * is already handled. Therefore we can return from here.
+     * If want to get status of all snaps in the system or volume then
+     * we should get them one by one.*/
+    if ((cmd == GF_SNAP_STATUS_TYPE_SNAP) ||
+        (cmd == GF_SNAP_STATUS_TYPE_ITER)) {
+        ret = 0;
+        goto out;
+    }
 
-        gf_cli_req        req           = {{0,}};
-        int               ret           = -1;
-        int32_t           cmd           = -1;
-        cli_local_t      *local         = NULL;
-        dict_t           *snap_dict     = NULL;
-        int              snapcount      =  0;
-        int              i              =  0;
+    ret = dict_get_int32_sizen(local->dict, "status.snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get snapcount");
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("cli", frame, out);
-        GF_VALIDATE_OR_GOTO ("cli", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("cli", this, out);
-        GF_VALIDATE_OR_GOTO ("cli", data, out);
+    if (snapcount == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_out("No snapshots present");
+    }
 
-        local = frame->local;
+    for (i = 0; i < snapcount; i++) {
+        ret = -1;
 
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
-                goto out;
-        }
+        snap_dict = dict_new();
+        if (!snap_dict)
+            goto out;
 
-        /* Snapshot status of single snap (i.e. GF_SNAP_STATUS_TYPE_SNAP)
-         * is already handled. Therefore we can return from here.
-         * If want to get status of all snaps in the system or volume then
-         * we should get them one by one.*/
-        if ((cmd == GF_SNAP_STATUS_TYPE_SNAP) ||
-            (cmd == GF_SNAP_STATUS_TYPE_ITER)) {
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "status.snapcount", &snapcount);
+        ret = cli_populate_req_dict_for_status(snap_dict, local->dict, i);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not populate snap request dictionary");
+            goto out;
         }
 
-        if (snapcount == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
-                cli_out ("No snapshots present");
-        }
-
-        for (i = 0 ; i < snapcount; i++) {
-                ret = -1;
-
-                snap_dict = dict_new();
-                if (!snap_dict)
-                        goto out;
+        ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                              (xdrproc_t)xdr_gf_cli_req, snap_dict,
+                              GLUSTER_CLI_SNAP, this, cli_rpc_prog, NULL);
 
-                ret = cli_populate_req_dict_for_status (snap_dict,
-                                local->dict, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                        "populate snap request dictionary");
-                        goto out;
-                }
-
-                ret = cli_to_glusterd (&req, frame,
-                                gf_cli_snapshot_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, snap_dict,
-                                GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                                NULL);
-
-                /* Ignore the return value and error for snapshot
-                 * status of type "ALL" or "VOL"
-                 *
-                 * Scenario : There might be case where status command
-                 * and delete command might be issued at the same time.
-                 * In that case when status tried to fetch detail of
-                 * snap which has been deleted by concurrent command,
-                 * then it will show snapshot not present. Which will
-                 * not be appropriate.
-                 */
-                dict_unref (snap_dict);
-                snap_dict = NULL;
+        /* Ignore the return value and error for snapshot
+         * status of type "ALL" or "VOL"
+         *
+         * Scenario : There might be case where status command
+         * and delete command might be issued at the same time.
+         * In that case when status tried to fetch detail of
+         * snap which has been deleted by concurrent command,
+         * then it will show snapshot not present. Which will
+         * not be appropriate.
+         */
+        if (ret && (cmd != GF_SNAP_STATUS_TYPE_ALL &&
+                    cmd != GF_SNAP_STATUS_TYPE_VOL)) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli_to_glusterd for snapshot status failed");
+            goto out;
         }
+        dict_unref(snap_dict);
+        snap_dict = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (snap_dict)
-                dict_unref (snap_dict);
+    if (snap_dict)
+        dict_unref(snap_dict);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-int32_t
-gf_cli_snapshot (call_frame_t *frame, xlator_t *this,
-                 void *data)
-{
-        gf_cli_req        req           = {{0,}};
-        dict_t           *options       = NULL;
-        int               ret           = -1;
-        int               tmp_ret       = -1;
-        cli_local_t      *local         = NULL;
-        char             *err_str       = NULL;
-        int              type           =  -1;
-
-        if (!frame || !this || !data)
-                goto out;
-
-        if (!frame->local)
-                goto out;
+static int32_t
+gf_cli_snapshot(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
+    int tmp_ret = -1;
+    cli_local_t *local = NULL;
+    char *err_str = NULL;
+    int type = -1;
 
-        local = frame->local;
+    if (!frame || !frame->local || !this || !data)
+        goto out;
 
-        options = data;
+    local = frame->local;
 
-        ret = dict_get_int32 (local->dict, "type", &type);
+    options = data;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_begin_composite_op (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to begin "
-                                "snapshot xml composite op");
-                        goto out;
-                }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_begin_composite_op(local);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to begin snapshot xml composite op");
+            goto out;
         }
+    }
 
+    ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options, GLUSTER_CLI_SNAP,
+                          this, cli_rpc_prog, NULL);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "cli_to_glusterd for snapshot failed");
+        goto xmlend;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_snapshot_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                               NULL);
+    ret = dict_get_int32_sizen(local->dict, "type", &type);
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type) {
+        ret = gf_cli_snapshot_for_status(frame, this, data);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd for "
-                        "snapshot failed");
-                goto xmlend;
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli to glusterd for snapshot status command failed");
         }
 
-        if (GF_SNAP_OPTION_TYPE_STATUS == type) {
-                ret = gf_cli_snapshot_for_status (frame, this, data);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "cli to glusterd "
-                                "for snapshot status command failed");
-                }
+        goto xmlend;
+    }
 
-                goto xmlend;
+    if (GF_SNAP_OPTION_TYPE_DELETE == type) {
+        ret = gf_cli_snapshot_for_delete(frame, this, data);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli to glusterd for snapshot delete command failed");
         }
 
-        if (GF_SNAP_OPTION_TYPE_DELETE == type) {
-                ret = gf_cli_snapshot_for_delete (frame, this, data);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "cli to glusterd "
-                                "for snapshot delete command failed");
-                }
+        goto xmlend;
+    }
 
-                goto xmlend;
-        }
-
-        ret = 0;
+    ret = 0;
 
 xmlend:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_end_composite_op (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to end "
-                                "snapshot xml composite op");
-                        goto out;
-                }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_end_composite_op(local);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to end snapshot xml composite op");
+            goto out;
         }
+    }
 out:
-        if (ret && local && GF_SNAP_OPTION_TYPE_STATUS == type) {
-                tmp_ret = dict_get_str (local->dict, "op_err_str", &err_str);
-                if (tmp_ret || !err_str) {
-                        cli_err ("Snapshot Status : failed: %s", "Please "
-                                 "check log file for details");
-                } else {
-                        cli_err ("Snapshot Status : failed: %s", err_str);
-                        dict_del (local->dict, "op_err_str");
-                }
+    if (ret && local && GF_SNAP_OPTION_TYPE_STATUS == type) {
+        tmp_ret = dict_get_str_sizen(local->dict, "op_err_str", &err_str);
+        if (tmp_ret || !err_str) {
+            cli_err("Snapshot Status : failed: %s",
+                    "Please check log file for details");
+        } else {
+            cli_err("Snapshot Status : failed: %s", err_str);
+            dict_del_sizen(local->dict, "op_err_str");
         }
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                /* XML mode handles its own error */
-                ret = 0;
-        }
-        return ret;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        /* XML mode handles its own error */
+        ret = 0;
+    }
+    return ret;
 }
 
-int32_t
-gf_cli_barrier_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                  int count, void *myframe)
-{
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-        dict_t                          *dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to barrier");
-
-        if (rsp.op_ret) {
-                if (rsp.op_errstr && (strlen (rsp.op_errstr) > 1)) {
-                        cli_err ("volume barrier: command unsuccessful : %s",
-                                 rsp.op_errstr);
-                } else {
-                        cli_err ("volume barrier: command unsuccessful");
-                }
+static int32_t
+gf_cli_barrier_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to barrier");
+
+    if (rsp.op_ret) {
+        if (rsp.op_errstr && (strlen(rsp.op_errstr) > 1)) {
+            cli_err("volume barrier: command unsuccessful : %s", rsp.op_errstr);
         } else {
-                cli_out ("volume barrier: command successful");
+            cli_err("volume barrier: command unsuccessful");
         }
-        ret = rsp.op_ret;
+    } else {
+        cli_out("volume barrier: command successful");
+    }
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_barrier_volume (call_frame_t *frame, xlator_t *this, void *data)
+static int
+gf_cli_barrier_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    options = data;
 
-        options = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli_barrier_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_BARRIER_VOLUME, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_barrier_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_BARRIER_VOLUME, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int32_t
-gf_cli_get_vol_opt_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        gf_cli_rsp   rsp  = {0,};
-        int          ret  = -1;
-        dict_t      *dict = NULL;
-        char        *key  = NULL;
-        char        *value = NULL;
-        char         msg[1024] = {0,};
-        int          i     = 0;
-        char         dict_key[50] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to get volume option");
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume get option: "
-                                  "failed: %s", rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume get option: "
-                                  "failed");
-
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_str ("volGetopts", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        }
-                } else {
-                        cli_err ("%s", msg);
-                }
-                ret = rsp.op_ret;
-                goto out_nolog;
-        }
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed rsp_dict unserialization");
-                goto out;
-        }
+static int32_t
+gf_cli_get_vol_opt_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char msg[1024] = {
+        0,
+    };
+    int i = 0;
+    char dict_key[50] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to get volume option");
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg), "volume get option: failed: %s",
+                     rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg), "volume get option: failed");
 
         if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_getopts (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "xml output generation "
-                                "failed");
-                        ret = 0;
-                }
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "warning", &value);
-        if (!ret) {
-                cli_out ("%s", value);
+            ret = cli_xml_output_str("volGetopts", msg, rsp.op_ret,
+                                     rsp.op_errno, rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            }
+        } else {
+            cli_err("%s", msg);
         }
-
-        ret = dict_get_int32 (dict, "count", &count);
+        ret = rsp.op_ret;
+        goto out_nolog;
+    }
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_getopts(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to retrieve count "
-                        "from the dictionary");
-                goto out;
-        }
-
-        if (count <= 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Value of count :%d is "
-                        "invalid", count);
-                ret = -1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+            ret = 0;
+        }
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(dict, "warning", &value);
+    if (!ret) {
+        cli_out("%s", value);
+    }
+
+    ret = dict_get_int32_sizen(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to retrieve count from the dictionary");
+        goto out;
+    }
+
+    if (count <= 0) {
+        gf_log("cli", GF_LOG_ERROR, "Value of count :%d is invalid", count);
+        ret = -1;
+        goto out;
+    }
+
+    cli_out("%-40s%-40s", "Option", "Value");
+    cli_out("%-40s%-40s", "------", "-----");
+    for (i = 1; i <= count; i++) {
+        ret = snprintf(dict_key, sizeof dict_key, "key%d", i);
+        ret = dict_get_strn(dict, dict_key, ret, &key);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to retrieve %s from the dictionary", dict_key);
+            goto out;
         }
-
-        cli_out ("%-40s%-40s", "Option", "Value");
-        cli_out ("%-40s%-40s", "------", "-----");
-        for (i=1; i<=count; i++) {
-                snprintf (dict_key, sizeof dict_key, "key%d", i);
-                ret = dict_get_str (dict, dict_key, &key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to"
-                                " retrieve %s from the "
-                                "dictionary", dict_key);
-                        goto out;
-                }
-                snprintf (dict_key, sizeof dict_key, "value%d", i);
-                ret = dict_get_str (dict, dict_key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "retrieve key value for %s from"
-                                "the dictionary", dict_key);
-                        goto out;
-                }
-                cli_out ("%-40s%-40s", key, value);
+        ret = snprintf(dict_key, sizeof dict_key, "value%d", i);
+        ret = dict_get_strn(dict, dict_key, ret, &value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to retrieve key value for %s from the dictionary",
+                   dict_key);
+            goto out;
         }
+        cli_out("%-40s%-40s", key, value);
+    }
 
 out:
-        if (ret) {
-                cli_out ("volume get option failed. Check the cli/glusterd log "
-                         "file for more details");
-        }
+    if (ret) {
+        cli_out(
+            "volume get option failed. Check the cli/glusterd log "
+            "file for more details");
+    }
 
 out_nolog:
-        if (dict)
-                dict_unref (dict);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    gf_free_xdr_cli_rsp(rsp);
+    return ret;
 }
 
-int
-gf_cli_get_vol_opt (call_frame_t *frame, xlator_t *this, void *data)
+static int
+gf_cli_get_vol_opt(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req  req     = {{0,}};
-        dict_t     *options = NULL;
-        int         ret     = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
-
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_get_vol_opt_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, options,
-                               GLUSTER_CLI_GET_VOL_OPT, this, cli_rpc_prog,
-                               NULL);
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    ret = cli_to_glusterd(&req, frame, gf_cli_get_vol_opt_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_GET_VOL_OPT, this, cli_rpc_prog, NULL);
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-int
-cli_to_glusterd (gf_cli_req *req, call_frame_t *frame,
-                 fop_cbk_fn_t cbkfn, xdrproc_t xdrproc, dict_t *dict,
-                 int procnum, xlator_t *this, rpc_clnt_prog_t *prog,
-                 struct iobref *iobref)
-{
-        int                ret = 0;
-        size_t             len = 0;
-        char               *cmd = NULL;
-        int                i = 0;
-        const char         **words = NULL;
-        cli_local_t        *local = NULL;
-
-        if (!this || !frame || !dict) {
-                ret = -1;
-                goto out;
-        }
+static int
+add_cli_cmd_timeout_to_dict(dict_t *dict)
+{
+    int ret = 0;
 
-        if (!frame->local) {
-                ret = -1;
-                goto out;
+    if (cli_default_conn_timeout > 120) {
+        ret = dict_set_uint32(dict, "timeout", cli_default_conn_timeout);
+        if (ret) {
+            gf_log("cli", GF_LOG_INFO, "Failed to save timeout to dict");
         }
+    }
+    return ret;
+}
 
-        local = frame->local;
+static int
+cli_to_glusterd(gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
+                xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
+                rpc_clnt_prog_t *prog, struct iobref *iobref)
+{
+    int ret = 0;
+    size_t len = 0;
+    char *cmd = NULL;
+    int i = 0;
+    const char **words = NULL;
+    cli_local_t *local = NULL;
 
-        if (!local->words) {
-                ret = -1;
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !dict) {
+        ret = -1;
+        goto out;
+    }
 
-        words = local->words;
+    local = frame->local;
 
-        while (words[i])
-                len += strlen (words[i++]) + 1;
+    if (!local->words) {
+        ret = -1;
+        goto out;
+    }
 
-        cmd = GF_CALLOC (1, len, gf_common_mt_char);
+    words = local->words;
 
-        if (!cmd) {
-                ret = -1;
-                goto out;
-        }
+    while (words[i])
+        len += strlen(words[i++]) + 1;
 
-        for (i = 0; words[i]; i++) {
-                strncat (cmd, words[i], strlen (words[i]));
-                if (words[i+1] != NULL)
-                        strncat (cmd, " ", strlen (" "));
-        }
+    cmd = GF_MALLOC(len + 1, gf_common_mt_char);
+    if (!cmd) {
+        ret = -1;
+        goto out;
+    }
+    cmd[0] = '\0';
 
-        cmd [len - 1] = '\0';
+    for (i = 0; words[i]; i++) {
+        strncat(cmd, words[i], len - 1);
+        if (words[i + 1] != NULL)
+            strncat(cmd, " ", len - 1);
+    }
 
-        ret = dict_set_dynstr (dict, "cmd-str", cmd);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr_sizen(dict, "cmd-str", cmd);
+    if (ret)
+        goto out;
 
-        ret = dict_allocate_and_serialize (dict, &(req->dict).dict_val,
-                                           &(req->dict).dict_len);
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "failed to get serialized length of dict");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &(req->dict).dict_val,
+                                      &(req->dict).dict_len);
 
-        ret = cli_cmd_submit (NULL, req, frame, prog, procnum, iobref, this,
-                              cbkfn, (xdrproc_t) xdrproc);
-out:
-        return ret;
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "failed to get serialized length of dict");
+        goto out;
+    }
 
+    ret = cli_cmd_submit(NULL, req, frame, prog, procnum, iobref, this, cbkfn,
+                         (xdrproc_t)xdrproc);
+out:
+    return ret;
 }
 
-int
-gf_cli_print_bitrot_scrub_status (dict_t *dict)
-{
-        int            i                = 1;
-        int            j                = 0;
-        int            ret              = -1;
-        int            count            = 0;
-        char           key[256]         = {0,};
-        char           *volname         = NULL;
-        char           *node_name       = NULL;
-        char           *scrub_freq      = NULL;
-        char           *state_scrub     = NULL;
-        char           *scrub_impact    = NULL;
-        char           *bad_file_str    = NULL;
-        char           *scrub_log_file  = NULL;
-        char           *bitrot_log_file = NULL;
-        uint64_t       scrub_files      = 0;
-        uint64_t       unsigned_files   = 0;
-        uint64_t       scrub_time       = 0;
-        uint64_t       days             = 0;
-        uint64_t       hours            = 0;
-        uint64_t       minutes          = 0;
-        uint64_t       seconds          = 0;
-        char          *last_scrub       = NULL;
-        uint64_t       error_count      = 0;
-        int8_t         scrub_running    = 0;
-        char          *scrub_state_op   = NULL;
-
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get volume name");
-
-        ret = dict_get_str (dict, "features.scrub", &state_scrub);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub state value");
-
-        ret = dict_get_str (dict, "features.scrub-throttle", &scrub_impact);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub impact "
-                        "value");
-
-        ret = dict_get_str (dict, "features.scrub-freq", &scrub_freq);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub -freq value");
-
-        ret = dict_get_str (dict, "bitrot_log_file", &bitrot_log_file);
+static int
+gf_cli_print_bitrot_scrub_status(dict_t *dict)
+{
+    int i = 1;
+    int j = 0;
+    int ret = -1;
+    int count = 0;
+    char key[64] = {
+        0,
+    };
+    char *volname = NULL;
+    char *node_name = NULL;
+    char *scrub_freq = NULL;
+    char *state_scrub = NULL;
+    char *scrub_impact = NULL;
+    char *bad_file_str = NULL;
+    char *scrub_log_file = NULL;
+    char *bitrot_log_file = NULL;
+    uint64_t scrub_files = 0;
+    uint64_t unsigned_files = 0;
+    uint64_t scrub_time = 0;
+    uint64_t days = 0;
+    uint64_t hours = 0;
+    uint64_t minutes = 0;
+    uint64_t seconds = 0;
+    char *last_scrub = NULL;
+    uint64_t error_count = 0;
+    int8_t scrub_running = 0;
+    char *scrub_state_op = NULL;
+
+    ret = dict_get_int32_sizen(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "failed to get count value from dictionary");
+        goto out;
+    }
+
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get volume name");
+
+    ret = dict_get_str_sizen(dict, "features.scrub", &state_scrub);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrub state value");
+
+    ret = dict_get_str_sizen(dict, "features.scrub-throttle", &scrub_impact);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrub impact value");
+
+    ret = dict_get_str_sizen(dict, "features.scrub-freq", &scrub_freq);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrub -freq value");
+
+    ret = dict_get_str_sizen(dict, "bitrot_log_file", &bitrot_log_file);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get bitrot log file location");
+
+    ret = dict_get_str_sizen(dict, "scrub_log_file", &scrub_log_file);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrubber log file location");
+
+    for (i = 1; i <= count; i++) {
+        snprintf(key, sizeof(key), "scrub-running-%d", i);
+        ret = dict_get_int8(dict, key, &scrub_running);
         if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get bitrot log file "
-                        "location");
+            gf_log("cli", GF_LOG_TRACE, "failed to get scrubbed files");
+        if (scrub_running)
+            break;
+    }
 
-        ret = dict_get_str (dict, "scrub_log_file", &scrub_log_file);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrubber log file "
-                        "location");
+    if (scrub_running)
+        gf_asprintf(&scrub_state_op, "%s (In Progress)", state_scrub);
+    else
+        gf_asprintf(&scrub_state_op, "%s (Idle)", state_scrub);
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not get count value from"
-                        " dictionary");
-                goto out;
-        }
+    cli_out("\n%s: %s\n", "Volume name ", volname);
 
-        for (i = 1; i <= count; i++) {
-                memset (key, 0, 256);
-                snprintf (key, 256, "scrub-running-%d", i);
-                ret = dict_get_int8 (dict, key, &scrub_running);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get scrubbed "
-                                "files");
-                if (scrub_running)
-                        break;
-        }
+    cli_out("%s: %s\n", "State of scrub", scrub_state_op);
 
-        if (scrub_running)
-                gf_asprintf (&scrub_state_op, "%s (In Progress)", state_scrub);
-        else
-                gf_asprintf (&scrub_state_op, "%s (Idle)", state_scrub);
+    cli_out("%s: %s\n", "Scrub impact", scrub_impact);
 
-        cli_out ("\n%s: %s\n", "Volume name ", volname);
+    cli_out("%s: %s\n", "Scrub frequency", scrub_freq);
 
-        cli_out ("%s: %s\n", "State of scrub", scrub_state_op);
+    cli_out("%s: %s\n", "Bitrot error log location", bitrot_log_file);
 
-        cli_out ("%s: %s\n", "Scrub impact", scrub_impact);
+    cli_out("%s: %s\n", "Scrubber error log location", scrub_log_file);
 
-        cli_out ("%s: %s\n", "Scrub frequency", scrub_freq);
+    for (i = 1; i <= count; i++) {
+        /* Reset the variables to prevent carryover of values */
+        node_name = NULL;
+        last_scrub = NULL;
+        scrub_time = 0;
+        error_count = 0;
+        scrub_files = 0;
+        unsigned_files = 0;
 
-        cli_out ("%s: %s\n", "Bitrot error log location", bitrot_log_file);
-
-        cli_out ("%s: %s\n", "Scrubber error log location", scrub_log_file);
+        snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get node-name");
 
+        snprintf(key, sizeof(key), "scrubbed-files-%d", i);
+        ret = dict_get_uint64(dict, key, &scrub_files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get scrubbed files");
 
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name       = NULL;
-                last_scrub      = NULL;
-                scrub_time      = 0;
-                days            = 0;
-                hours           = 0;
-                minutes         = 0;
-                seconds         = 0;
-                error_count     = 0;
-                scrub_files     = 0;
-                unsigned_files  = 0;
+        snprintf(key, sizeof(key), "unsigned-files-%d", i);
+        ret = dict_get_uint64(dict, key, &unsigned_files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get unsigned files");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+        snprintf(key, sizeof(key), "scrub-duration-%d", i);
+        ret = dict_get_uint64(dict, key, &scrub_time);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get last scrub duration");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "scrubbed-files-%d", i);
-                ret = dict_get_uint64 (dict, key, &scrub_files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get scrubbed "
-                                "files");
+        snprintf(key, sizeof(key), "last-scrub-time-%d", i);
+        ret = dict_get_str(dict, key, &last_scrub);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get last scrub time");
+        snprintf(key, sizeof(key), "error-count-%d", i);
+        ret = dict_get_uint64(dict, key, &error_count);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get error count");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "unsigned-files-%d", i);
-                ret = dict_get_uint64 (dict, key, &unsigned_files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get unsigned "
-                                "files");
+        cli_out("\n%s\n",
+                "=========================================================");
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "scrub-duration-%d", i);
-                ret = dict_get_uint64 (dict, key, &scrub_time);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get last scrub "
-                                "duration");
+        cli_out("%s: %s\n", "Node", node_name);
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "last-scrub-time-%d", i);
-                ret = dict_get_str (dict, key, &last_scrub);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get last scrub"
-                                " time");
-                memset (key, 0, 256);
-                snprintf (key, 256, "error-count-%d", i);
-                ret = dict_get_uint64 (dict, key, &error_count);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get error "
-                                "count");
+        cli_out("%s: %" PRIu64 "\n", "Number of Scrubbed files", scrub_files);
 
-                cli_out ("\n%s\n", "=========================================="
-                         "===============");
+        cli_out("%s: %" PRIu64 "\n", "Number of Skipped files", unsigned_files);
 
-                cli_out ("%s: %s\n", "Node", node_name);
+        if ((!last_scrub) || !strcmp(last_scrub, ""))
+            cli_out("%s: %s\n", "Last completed scrub time",
+                    "Scrubber pending to complete.");
+        else
+            cli_out("%s: %s\n", "Last completed scrub time", last_scrub);
 
-                cli_out ("%s: %"PRIu64 "\n", "Number of Scrubbed files",
-                          scrub_files);
+        /* Printing last scrub duration time in human readable form*/
+        seconds = scrub_time % 60;
+        minutes = (scrub_time / 60) % 60;
+        hours = (scrub_time / 3600) % 24;
+        days = scrub_time / 86400;
+        cli_out("%s: %" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
+                "Duration of last scrub (D:M:H:M:S)", days, hours, minutes,
+                seconds);
 
-                cli_out ("%s: %"PRIu64 "\n", "Number of Skipped files",
-                          unsigned_files);
+        cli_out("%s: %" PRIu64 "\n", "Error count", error_count);
 
-                if ((!last_scrub) || !strcmp (last_scrub, ""))
-                        cli_out ("%s: %s\n", "Last completed scrub time",
-                                 "Scrubber pending to complete.");
-                else
-                        cli_out ("%s: %s\n", "Last completed scrub time",
-                                 last_scrub);
-
-                /* Printing last scrub duration time in human readable form*/
-                seconds    = scrub_time%60;
-                minutes    = (scrub_time/60)%60;
-                hours      = (scrub_time/3600)%24;
-                days       = scrub_time/86400;
-                cli_out ("%s: %"PRIu64 ":%"PRIu64 ":%"PRIu64 ":%"PRIu64 "\n",
-                         "Duration of last scrub (D:M:H:M:S)",
-                         days, hours, minutes, seconds);
-
-                cli_out ("%s: %"PRIu64 "\n", "Error count", error_count);
-
-                if (error_count) {
-                        cli_out ("%s:\n", "Corrupted object's [GFID]");
-                        /* Printing list of bad file's (Corrupted object's)*/
-                        for (j = 0; j < error_count; j++) {
-                                memset (key, 0, 256);
-                                snprintf (key, 256, "quarantine-%d-%d", j, i);
-                                ret = dict_get_str (dict, key, &bad_file_str);
-                                if (!ret) {
-                                        cli_out ("%s\n", bad_file_str);
-                                }
-                        }
+        if (error_count) {
+            cli_out("%s:\n", "Corrupted object's [GFID]");
+            /* Printing list of bad file's (Corrupted object's)*/
+            for (j = 0; j < error_count; j++) {
+                snprintf(key, sizeof(key), "quarantine-%d-%d", j, i);
+                ret = dict_get_str(dict, key, &bad_file_str);
+                if (!ret) {
+                    cli_out("%s\n", bad_file_str);
                 }
+            }
         }
-        cli_out ("%s\n", "=========================================="
-                 "===============");
+    }
+    cli_out("%s\n",
+            "=========================================================");
 
 out:
-        GF_FREE (scrub_state_op);
-        return 0;
+    GF_FREE(scrub_state_op);
+    return 0;
 }
 
-int
-gf_cli_bitrot_cbk (struct rpc_req *req, struct iovec *iov,
-                   int count, void *myframe)
-{
-        int                  ret                       = -1;
-        int                  type                      = 0;
-        gf_cli_rsp           rsp                       = {0, };
-        dict_t               *dict                     = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
+static int
+gf_cli_bitrot_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
+{
+    int ret = -1;
+    int type = 0;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *scrub_cmd = NULL;
+    char *volname = NULL;
+    char *cmd_str = NULL;
+    char *cmd_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               XDR_DECODE_FAIL);
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("Bitrot command failed : %s", rsp.op_errstr);
+        else
+            cli_err("Bitrot command : failed");
 
-        if (rsp.op_ret) {
-                ret = -1;
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
+        goto out;
+    }
 
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("Bitrot command failed : %s", rsp.op_errstr);
-                else
-                        cli_err ("Bitrot command : failed");
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-                goto out;
+        if (!dict) {
+            ret = -1;
+            goto out;
         }
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict = dict_new ();
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "failed to unserialize "
-                                "req-buffer to dictionary");
-                        goto out;
-                }
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, DICT_UNSERIALIZE_FAIL);
+            goto out;
         }
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to bit rot command");
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to bit rot command");
 
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get command type");
-                goto out;
-        }
+    ret = dict_get_int32_sizen(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get command type");
+        goto out;
+    }
 
-        if ((type == GF_BITROT_CMD_SCRUB_STATUS) &&
-             !(global_state->mode & GLUSTER_MODE_XML)) {
-                ret = gf_cli_print_bitrot_scrub_status (dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to print bitrot "
-                                "scrub status");
-                }
-                goto out;
-        }
+    if ((type == GF_BITROT_CMD_SCRUB_STATUS) &&
+        !(global_state->mode & GLUSTER_MODE_XML)) {
+        ret = gf_cli_print_bitrot_scrub_status(dict);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to print bitrot scrub status");
+        }
+        goto out;
+    }
+
+    /* Ignoring the error, as using dict val for cli output only */
+    ret = dict_get_str_sizen(dict, "volname", &volname);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get volume name");
+
+    ret = dict_get_str_sizen(dict, "scrub-value", &scrub_cmd);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "Failed to get scrub command");
+
+    ret = dict_get_str_sizen(dict, "cmd-str", &cmd_str);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get command string");
+
+    if (cmd_str)
+        cmd_op = strrchr(cmd_str, ' ') + 1;
+
+    switch (type) {
+        case GF_BITROT_OPTION_TYPE_ENABLE:
+            cli_out("volume bitrot: success bitrot enabled for volume %s",
+                    volname);
+            ret = 0;
+            goto out;
+        case GF_BITROT_OPTION_TYPE_DISABLE:
+            cli_out("volume bitrot: success bitrot disabled for volume %s",
+                    volname);
+            ret = 0;
+            goto out;
+        case GF_BITROT_CMD_SCRUB_ONDEMAND:
+            cli_out("volume bitrot: scrubber started ondemand for volume %s",
+                    volname);
+            ret = 0;
+            goto out;
+        case GF_BITROT_OPTION_TYPE_SCRUB:
+            if (!strncmp("pause", scrub_cmd, sizeof("pause")))
+                cli_out("volume bitrot: scrubber paused for volume %s",
+                        volname);
+            if (!strncmp("resume", scrub_cmd, sizeof("resume")))
+                cli_out("volume bitrot: scrubber resumed for volume %s",
+                        volname);
+            ret = 0;
+            goto out;
+        case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
+            cli_out(
+                "volume bitrot: scrub-frequency is set to %s "
+                "successfully for volume %s",
+                cmd_op, volname);
+            ret = 0;
+            goto out;
+        case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
+            cli_out(
+                "volume bitrot: scrub-throttle is set to %s "
+                "successfully for volume %s",
+                cmd_op, volname);
+            ret = 0;
+            goto out;
+    }
 
 xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_profile (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_profile(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, XML_ERROR);
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("volume bitrot: success");
+    if (!rsp.op_ret)
+        cli_out("volume bitrot: success");
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-            dict_unref (dict);
-
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    if (dict)
+        dict_unref(dict);
 
-        cli_cmd_broadcast_response (ret);
-
-        return ret;
+    gf_free_xdr_cli_rsp(rsp);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-int32_t
-gf_cli_bitrot (call_frame_t *frame, xlator_t *this, void *data)
-{
-        gf_cli_req        req           = { {0,} };
-        dict_t           *options       = NULL;
-        int               ret           = -1;
-
-        if (!frame || !this || !data)
-                goto out;
-
-        options = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_bitrot_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_BITROT, this, cli_rpc_prog,
-                               NULL);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd for "
-                        "bitrot failed");
-                goto out;
-        }
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        GF_FREE (req.dict.dict_val);
-
-        return ret;
-}
-
-struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {
-        [GLUSTER_CLI_NULL]             = {"NULL", NULL },
-        [GLUSTER_CLI_PROBE]            = {"PROBE_QUERY", gf_cli_probe},
-        [GLUSTER_CLI_DEPROBE]          = {"DEPROBE_QUERY", gf_cli_deprobe},
-        [GLUSTER_CLI_LIST_FRIENDS]     = {"LIST_FRIENDS", gf_cli_list_friends},
-        [GLUSTER_CLI_UUID_RESET]       = {"UUID_RESET", gf_cli3_1_uuid_reset},
-        [GLUSTER_CLI_UUID_GET]         = {"UUID_GET", gf_cli3_1_uuid_get},
-        [GLUSTER_CLI_CREATE_VOLUME]    = {"CREATE_VOLUME", gf_cli_create_volume},
-        [GLUSTER_CLI_DELETE_VOLUME]    = {"DELETE_VOLUME", gf_cli_delete_volume},
-        [GLUSTER_CLI_START_VOLUME]     = {"START_VOLUME", gf_cli_start_volume},
-        [GLUSTER_CLI_STOP_VOLUME]      = {"STOP_VOLUME", gf_cli_stop_volume},
-        [GLUSTER_CLI_RENAME_VOLUME]    = {"RENAME_VOLUME", gf_cli_rename_volume},
-        [GLUSTER_CLI_DEFRAG_VOLUME]    = {"DEFRAG_VOLUME", gf_cli_defrag_volume},
-        [GLUSTER_CLI_GET_VOLUME]       = {"GET_VOLUME", gf_cli_get_volume},
-        [GLUSTER_CLI_GET_NEXT_VOLUME]  = {"GET_NEXT_VOLUME", gf_cli_get_next_volume},
-        [GLUSTER_CLI_SET_VOLUME]       = {"SET_VOLUME", gf_cli_set_volume},
-        [GLUSTER_CLI_ADD_BRICK]        = {"ADD_BRICK", gf_cli_add_brick},
-        [GLUSTER_CLI_REMOVE_BRICK]     = {"REMOVE_BRICK", gf_cli_remove_brick},
-        [GLUSTER_CLI_REPLACE_BRICK]    = {"REPLACE_BRICK", gf_cli_replace_brick},
-        [GLUSTER_CLI_LOG_ROTATE]       = {"LOG ROTATE", gf_cli_log_rotate},
-        [GLUSTER_CLI_GETSPEC]          = {"GETSPEC", gf_cli_getspec},
-        [GLUSTER_CLI_PMAP_PORTBYBRICK] = {"PMAP PORTBYBRICK", gf_cli_pmap_b2p},
-        [GLUSTER_CLI_SYNC_VOLUME]      = {"SYNC_VOLUME", gf_cli_sync_volume},
-        [GLUSTER_CLI_RESET_VOLUME]     = {"RESET_VOLUME", gf_cli_reset_volume},
-        [GLUSTER_CLI_FSM_LOG]          = {"FSM_LOG", gf_cli_fsm_log},
-        [GLUSTER_CLI_GSYNC_SET]        = {"GSYNC_SET", gf_cli_gsync_set},
-        [GLUSTER_CLI_PROFILE_VOLUME]   = {"PROFILE_VOLUME", gf_cli_profile_volume},
-        [GLUSTER_CLI_QUOTA]            = {"QUOTA", gf_cli_quota},
-        [GLUSTER_CLI_TOP_VOLUME]       = {"TOP_VOLUME", gf_cli_top_volume},
-        [GLUSTER_CLI_GETWD]            = {"GETWD", gf_cli_getwd},
-        [GLUSTER_CLI_STATUS_VOLUME]    = {"STATUS_VOLUME", gf_cli_status_volume},
-        [GLUSTER_CLI_STATUS_ALL]       = {"STATUS_ALL", gf_cli_status_volume_all},
-        [GLUSTER_CLI_MOUNT]            = {"MOUNT", gf_cli_mount},
-        [GLUSTER_CLI_UMOUNT]           = {"UMOUNT", gf_cli_umount},
-        [GLUSTER_CLI_HEAL_VOLUME]      = {"HEAL_VOLUME", gf_cli_heal_volume},
-        [GLUSTER_CLI_STATEDUMP_VOLUME] = {"STATEDUMP_VOLUME", gf_cli_statedump_volume},
-        [GLUSTER_CLI_LIST_VOLUME]      = {"LIST_VOLUME", gf_cli_list_volume},
-        [GLUSTER_CLI_CLRLOCKS_VOLUME]  = {"CLEARLOCKS_VOLUME", gf_cli_clearlocks_volume},
-        [GLUSTER_CLI_COPY_FILE]        = {"COPY_FILE", gf_cli_copy_file},
-        [GLUSTER_CLI_SYS_EXEC]         = {"SYS_EXEC", gf_cli_sys_exec},
-        [GLUSTER_CLI_SNAP]             = {"SNAP", gf_cli_snapshot},
-        [GLUSTER_CLI_BARRIER_VOLUME]   = {"BARRIER VOLUME", gf_cli_barrier_volume},
-        [GLUSTER_CLI_GET_VOL_OPT]      = {"GET_VOL_OPT", gf_cli_get_vol_opt},
-        [GLUSTER_CLI_BITROT]           = {"BITROT", gf_cli_bitrot},
-        [GLUSTER_CLI_ATTACH_TIER]      = {"ATTACH_TIER", gf_cli_attach_tier},
-        [GLUSTER_CLI_TIER]             = {"TIER", gf_cli_tier},
-        [GLUSTER_CLI_GET_STATE]        = {"GET_STATE", gf_cli_get_state},
-        [GLUSTER_CLI_RESET_BRICK]      = {"RESET_BRICK", gf_cli_reset_brick},
-        [GLUSTER_CLI_REMOVE_TIER_BRICK] = {"DETACH_TIER", gf_cli_remove_tier_brick},
-        [GLUSTER_CLI_ADD_TIER_BRICK]   = {"ADD_TIER_BRICK", gf_cli_add_tier_brick}
+static int32_t
+gf_cli_bitrot(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
+
+    options = data;
+
+    ret = cli_to_glusterd(&req, frame, gf_cli_bitrot_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_BITROT, this, cli_rpc_prog, NULL);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "cli_to_glusterd for bitrot failed");
+        goto out;
+    }
+
+out:
+    gf_log("cli", GF_LOG_DEBUG, RETURNING, ret);
+
+    GF_FREE(req.dict.dict_val);
+
+    return ret;
+}
+
+static struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {
+    [GLUSTER_CLI_NULL] = {"NULL", NULL},
+    [GLUSTER_CLI_PROBE] = {"PROBE_QUERY", gf_cli_probe},
+    [GLUSTER_CLI_DEPROBE] = {"DEPROBE_QUERY", gf_cli_deprobe},
+    [GLUSTER_CLI_LIST_FRIENDS] = {"LIST_FRIENDS", gf_cli_list_friends},
+    [GLUSTER_CLI_UUID_RESET] = {"UUID_RESET", gf_cli3_1_uuid_reset},
+    [GLUSTER_CLI_UUID_GET] = {"UUID_GET", gf_cli3_1_uuid_get},
+    [GLUSTER_CLI_CREATE_VOLUME] = {"CREATE_VOLUME", gf_cli_create_volume},
+    [GLUSTER_CLI_DELETE_VOLUME] = {"DELETE_VOLUME", gf_cli_delete_volume},
+    [GLUSTER_CLI_START_VOLUME] = {"START_VOLUME", gf_cli_start_volume},
+    [GLUSTER_CLI_STOP_VOLUME] = {"STOP_VOLUME", gf_cli_stop_volume},
+    [GLUSTER_CLI_RENAME_VOLUME] = {"RENAME_VOLUME", gf_cli_rename_volume},
+    [GLUSTER_CLI_DEFRAG_VOLUME] = {"DEFRAG_VOLUME", gf_cli_defrag_volume},
+    [GLUSTER_CLI_GET_VOLUME] = {"GET_VOLUME", gf_cli_get_volume},
+    [GLUSTER_CLI_GET_NEXT_VOLUME] = {"GET_NEXT_VOLUME", gf_cli_get_next_volume},
+    [GLUSTER_CLI_SET_VOLUME] = {"SET_VOLUME", gf_cli_set_volume},
+    [GLUSTER_CLI_ADD_BRICK] = {"ADD_BRICK", gf_cli_add_brick},
+    [GLUSTER_CLI_REMOVE_BRICK] = {"REMOVE_BRICK", gf_cli_remove_brick},
+    [GLUSTER_CLI_REPLACE_BRICK] = {"REPLACE_BRICK", gf_cli_replace_brick},
+    [GLUSTER_CLI_LOG_ROTATE] = {"LOG ROTATE", gf_cli_log_rotate},
+    [GLUSTER_CLI_GETSPEC] = {"GETSPEC", gf_cli_getspec},
+    [GLUSTER_CLI_PMAP_PORTBYBRICK] = {"PMAP PORTBYBRICK", gf_cli_pmap_b2p},
+    [GLUSTER_CLI_SYNC_VOLUME] = {"SYNC_VOLUME", gf_cli_sync_volume},
+    [GLUSTER_CLI_RESET_VOLUME] = {"RESET_VOLUME", gf_cli_reset_volume},
+    [GLUSTER_CLI_FSM_LOG] = {"FSM_LOG", gf_cli_fsm_log},
+    [GLUSTER_CLI_GSYNC_SET] = {"GSYNC_SET", gf_cli_gsync_set},
+    [GLUSTER_CLI_PROFILE_VOLUME] = {"PROFILE_VOLUME", gf_cli_profile_volume},
+    [GLUSTER_CLI_QUOTA] = {"QUOTA", gf_cli_quota},
+    [GLUSTER_CLI_TOP_VOLUME] = {"TOP_VOLUME", gf_cli_top_volume},
+    [GLUSTER_CLI_GETWD] = {"GETWD", gf_cli_getwd},
+    [GLUSTER_CLI_STATUS_VOLUME] = {"STATUS_VOLUME", gf_cli_status_volume},
+    [GLUSTER_CLI_STATUS_ALL] = {"STATUS_ALL", gf_cli_status_volume_all},
+    [GLUSTER_CLI_MOUNT] = {"MOUNT", gf_cli_mount},
+    [GLUSTER_CLI_UMOUNT] = {"UMOUNT", gf_cli_umount},
+    [GLUSTER_CLI_HEAL_VOLUME] = {"HEAL_VOLUME", gf_cli_heal_volume},
+    [GLUSTER_CLI_STATEDUMP_VOLUME] = {"STATEDUMP_VOLUME",
+                                      gf_cli_statedump_volume},
+    [GLUSTER_CLI_LIST_VOLUME] = {"LIST_VOLUME", gf_cli_list_volume},
+    [GLUSTER_CLI_CLRLOCKS_VOLUME] = {"CLEARLOCKS_VOLUME",
+                                     gf_cli_clearlocks_volume},
+    [GLUSTER_CLI_COPY_FILE] = {"COPY_FILE", gf_cli_copy_file},
+    [GLUSTER_CLI_SYS_EXEC] = {"SYS_EXEC", gf_cli_sys_exec},
+    [GLUSTER_CLI_SNAP] = {"SNAP", gf_cli_snapshot},
+    [GLUSTER_CLI_BARRIER_VOLUME] = {"BARRIER VOLUME", gf_cli_barrier_volume},
+    [GLUSTER_CLI_GET_VOL_OPT] = {"GET_VOL_OPT", gf_cli_get_vol_opt},
+    [GLUSTER_CLI_BITROT] = {"BITROT", gf_cli_bitrot},
+    [GLUSTER_CLI_GET_STATE] = {"GET_STATE", gf_cli_get_state},
+    [GLUSTER_CLI_RESET_BRICK] = {"RESET_BRICK", gf_cli_reset_brick},
+    [GLUSTER_CLI_GANESHA] = {"GANESHA", gf_cli_ganesha},
 };
 
 struct rpc_clnt_program cli_prog = {
-        .progname  = "Gluster CLI",
-        .prognum   = GLUSTER_CLI_PROGRAM,
-        .progver   = GLUSTER_CLI_VERSION,
-        .numproc   = GLUSTER_CLI_MAXVALUE,
-        .proctable = gluster_cli_actors,
+    .progname = "Gluster CLI",
+    .prognum = GLUSTER_CLI_PROGRAM,
+    .progver = GLUSTER_CLI_VERSION,
+    .numproc = GLUSTER_CLI_MAXVALUE,
+    .proctable = gluster_cli_actors,
 };
 
-struct rpc_clnt_procedure cli_quotad_procs[GF_AGGREGATOR_MAXVALUE] = {
-        [GF_AGGREGATOR_NULL]     = {"NULL", NULL},
-        [GF_AGGREGATOR_LOOKUP]   = {"LOOKUP", NULL},
-        [GF_AGGREGATOR_GETLIMIT]   = {"GETLIMIT", cli_quotad_getlimit},
+static struct rpc_clnt_procedure cli_quotad_procs[GF_AGGREGATOR_MAXVALUE] = {
+    [GF_AGGREGATOR_NULL] = {"NULL", NULL},
+    [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", NULL},
+    [GF_AGGREGATOR_GETLIMIT] = {"GETLIMIT", cli_quotad_getlimit},
 };
 
 struct rpc_clnt_program cli_quotad_clnt = {
-        .progname  = "CLI Quotad client",
-        .prognum   = GLUSTER_AGGREGATOR_PROGRAM,
-        .progver   = GLUSTER_AGGREGATOR_VERSION,
-        .numproc   = GF_AGGREGATOR_MAXVALUE,
-        .proctable = cli_quotad_procs,
+    .progname = "CLI Quotad client",
+    .prognum = GLUSTER_AGGREGATOR_PROGRAM,
+    .progver = GLUSTER_AGGREGATOR_VERSION,
+    .numproc = GF_AGGREGATOR_MAXVALUE,
+    .proctable = cli_quotad_procs,
 };
diff --git a/cli/src/cli-xml-output.c b/cli/src/cli-xml-output.c
index 29ee81b6012..069de75801c 100644
--- a/cli/src/cli-xml-output.c
+++ b/cli/src/cli-xml-output.c
@@ -10,15 +10,12 @@
 #include <stdlib.h>
 #include "cli.h"
 #include "cli1-xdr.h"
-#include "run.h"
-#include "compat.h"
-#include "syscall.h"
-#include "upcall-utils.h"
-
-enum gf_task_types {
-    GF_TASK_TYPE_REBALANCE,
-    GF_TASK_TYPE_REMOVE_BRICK
-};
+#include <glusterfs/run.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/upcall-utils.h>
+
+enum gf_task_types { GF_TASK_TYPE_REBALANCE, GF_TASK_TYPE_REMOVE_BRICK };
 
 /*
  * IMPORTANT NOTE:
@@ -42,4477 +39,3796 @@ enum gf_task_types {
  *      }
  *      #endif
  *
- *  Following the above formate ensures that all xml related code is compliled
+ *  Following the above format ensures that all xml related code is compiled
  *  only when libxml2 is present, and also keeps the rest of the codebase free
  *  of #if (HAVE_LIB_XML)
  */
 
-
 #if (HAVE_LIB_XML)
 
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 
-#define XML_RET_CHECK_AND_GOTO(ret, label)      do {            \
-                if (ret < 0) {                                  \
-                        ret = -1;                               \
-                        goto label;                             \
-                }                                               \
-                else                                            \
-                        ret = 0;                                \
-        }while (0)                                              \
+#define XML_RET_CHECK_AND_GOTO(ret, label)                                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        } else                                                                 \
+            ret = 0;                                                           \
+    } while (0)
 
 int
-cli_begin_xml_output (xmlTextWriterPtr *writer, xmlDocPtr *doc)
+cli_begin_xml_output(xmlTextWriterPtr *writer, xmlDocPtr *doc)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        *writer = xmlNewTextWriterDoc (doc, 0);
-        if (writer == NULL) {
-                ret = -1;
-                goto out;
-        }
+    *writer = xmlNewTextWriterDoc(doc, 0);
+    if (*writer == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xmlTextWriterStartDocument (*writer, "1.0", "UTF-8", "yes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartDocument(*writer, "1.0", "UTF-8", "yes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <cliOutput> */
-        ret = xmlTextWriterStartElement (*writer, (xmlChar *)"cliOutput");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <cliOutput> */
+    ret = xmlTextWriterStartElement(*writer, (xmlChar *)"cliOutput");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_end_xml_output (xmlTextWriterPtr writer, xmlDocPtr doc)
+cli_end_xml_output(xmlTextWriterPtr writer, xmlDocPtr doc)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        /* </cliOutput> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </cliOutput> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndDocument (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndDocument(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    /* Dump xml document to stdout and pretty format it */
+    xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
 
-        /* Dump xml document to stdout and pretty format it */
-        xmlSaveFormatFileEnc ("-", doc, "UTF-8", 1);
-
-        xmlFreeTextWriter (writer);
-        xmlFreeDoc (doc);
+    xmlFreeTextWriter(writer);
+    xmlFreeDoc(doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_common (xmlTextWriterPtr writer, int op_ret, int op_errno,
-                       char *op_errstr)
+cli_xml_output_common(xmlTextWriterPtr writer, int op_ret, int op_errno,
+                      char *op_errstr)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opRet",
-                                               "%d", op_ret);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opRet", "%d",
+                                          op_ret);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opErrno",
-                                               "%d", op_errno);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrno", "%d",
+                                          op_errno);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (op_errstr)
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opErrstr",
-                                                       "%s", op_errstr);
-        else
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opErrstr",
-                                                       "%s", "");
+    if (op_errstr)
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrstr",
+                                              "%s", op_errstr);
+    else
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrstr",
+                                              "%s", "");
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_str (char *op, char *str, int op_ret, int op_errno,
-                    char *op_errstr)
+cli_xml_output_str(char *op, char *str, int op_ret, int op_errno,
+                   char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        if (op) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"cliOp",
-                                                       "%s", op);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (op) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"cliOp", "%s",
+                                              op);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (str) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"output",
-                                                       "%s", str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (str) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"output", "%s",
+                                              str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_data_pair (dict_t *this, char *key, data_t *value,
-                          void *data)
+cli_xml_output_data_pair(dict_t *this, char *key, data_t *value, void *data)
 {
-        int                     ret = -1;
-        xmlTextWriterPtr        *writer = NULL;
+    int ret = -1;
+    xmlTextWriterPtr *writer = NULL;
 
-        writer = (xmlTextWriterPtr *)data;
+    writer = (xmlTextWriterPtr *)data;
 
-        ret = xmlTextWriterWriteFormatElement (*writer, (xmlChar *)key,
-                                               "%s", value->data);
+    ret = xmlTextWriterWriteFormatElement(*writer, (xmlChar *)key, "%s",
+                                          value->data);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        return ret;
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_dict ( char *op, dict_t *dict, int op_ret, int op_errno,
-                      char *op_errstr)
+cli_xml_output_dict(char *op, dict_t *dict, int op_ret, int op_errno,
+                    char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        /* <"op"> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <"op"> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (dict)
-                dict_foreach (dict, cli_xml_output_data_pair, &writer);
+    if (dict)
+        dict_foreach(dict, cli_xml_output_data_pair, &writer);
 
-        /* </"op"> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </"op"> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_status_common (xmlTextWriterPtr writer, dict_t *dict,
-                                  int   brick_index, int *online,
-                                  gf_boolean_t *node_present)
+cli_xml_output_vol_status_common(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index, int *online,
+                                 gf_boolean_t *node_present)
 {
-        int             ret             = -1;
-        char            *hostname       = NULL;
-        char            *path           = NULL;
-        char            *uuid           = NULL;
-        int             port            = 0;
-        int             rdma_port       = 0;
-        int             status          = 0;
-        int             pid             = 0;
-        char            key[1024]       = {0,};
-
-        snprintf (key, sizeof (key), "brick%d.hostname", brick_index);
-        ret = dict_get_str (dict, key, &hostname);
-        if (ret) {
-                *node_present = _gf_false;
-                goto out;
+    int ret = -1;
+    char *hostname = NULL;
+    char *path = NULL;
+    char *uuid = NULL;
+    int port = 0;
+    int rdma_port = 0;
+    int status = 0;
+    int pid = 0;
+    char key[1024] = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "brick%d.hostname", brick_index);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret) {
+        *node_present = _gf_false;
+        goto out;
+    }
+    *node_present = _gf_true;
+
+    /* <node>
+     * will be closed in the calling function cli_xml_output_vol_status()*/
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"node");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname", "%s",
+                                          hostname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.path", brick_index);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"path", "%s",
+                                          path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.peerid", brick_index);
+    ret = dict_get_str(dict, key, &uuid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"peerid", "%s",
+                                          uuid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.status", brick_index);
+    ret = dict_get_int32(dict, key, &status);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                          status);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    *online = status;
+
+    snprintf(key, sizeof(key), "brick%d.port", brick_index);
+    ret = dict_get_int32(dict, key, &port);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "brick%d.rdma_port", brick_index);
+    ret = dict_get_int32(dict, key, &rdma_port);
+
+    /* If the process is either offline or doesn't provide a port (shd)
+     * port = "N/A"
+     * else print the port number of the process.
+     */
+
+    /*
+     * Tag 'port' can be removed once console management is started
+     * to support new tag ports.
+     */
+
+    if (*online == 1 && port != 0)
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"port", "%d",
+                                              port);
+    else
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"port", "%s",
+                                              "N/A");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"ports");
+    if (*online == 1 && (port != 0 || rdma_port != 0)) {
+        if (port) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp",
+                                                  "%d", port);
+        } else {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp",
+                                                  "%s", "N/A");
         }
-        *node_present = _gf_true;
-
-        /* <node>
-         * will be closed in the calling function cli_xml_output_vol_status()*/
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hostname",
-                                               "%s", hostname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.path", brick_index);
-        ret = dict_get_str (dict, key, &path);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.peerid", brick_index);
-        ret = dict_get_str (dict, key, &uuid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"peerid",
-                                               "%s", uuid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.status", brick_index);
-        ret = dict_get_int32 (dict, key, &status);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"status",
-                                               "%d", status);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        *online = status;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.port", brick_index);
-        ret = dict_get_int32 (dict, key, &port);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.rdma_port", brick_index);
-        ret = dict_get_int32 (dict, key, &rdma_port);
-
-        /* If the process is either offline or doesn't provide a port (shd)
-         * port = "N/A"
-         * else print the port number of the process.
-         */
-
-        /*
-         * Tag 'port' can be removed once console management is started
-         * to support new tag ports.
-         */
-
-        if (*online == 1 && port != 0)
-                 ret = xmlTextWriterWriteFormatElement (writer,
-                                                    (xmlChar *)"port",
-                                                        "%d", port);
-         else
-                 ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)"port",
-                                                        "%s", "N/A");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"ports");
-        if (*online == 1 && (port != 0 || rdma_port != 0)) {
-
-                if (port) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%d", port);
-                } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%s", "N/A");
-                }
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                if (rdma_port) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%d", rdma_port);
-                } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%s", "N/A");
-                }
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        if (rdma_port) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma",
+                                                  "%d", rdma_port);
         } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%s", "N/A");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%s", "N/A");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma",
+                                                  "%s", "N/A");
         }
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp", "%s",
+                                              "N/A");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma", "%s",
+                                              "N/A");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.pid", brick_index);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
-                                               "%d", pid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-int
-cli_xml_output_vol_status_detail (xmlTextWriterPtr writer, dict_t *dict,
-                                  int brick_index)
-{
-        int             ret = -1;
-        uint64_t        size_total = 0;
-        uint64_t        size_free = 0;
-        char            *device = NULL;
-        uint64_t        block_size = 0;
-        char            *mnt_options = NULL;
-        char            *fs_name = NULL;
-        char            *inode_size = NULL;
-        uint64_t        inodes_total = 0;
-        uint64_t        inodes_free = 0;
-        char            key[1024] = {0,};
-
-        snprintf (key, sizeof (key), "brick%d.total", brick_index);
-        ret = dict_get_uint64 (dict, key, &size_total);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"sizeTotal",
-                                                       "%"PRIu64, size_total);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.free", brick_index);
-        ret = dict_get_uint64 (dict, key, &size_free);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"sizeFree",
-                                                       "%"PRIu64, size_free);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.device", brick_index);
-        ret = dict_get_str (dict, key, &device);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"device",
-                                                       "%s", device);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.block_size", brick_index);
-        ret = dict_get_uint64 (dict, key, &block_size);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"blockSize",
-                                                       "%"PRIu64, block_size);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mnt_options", brick_index);
-        ret = dict_get_str (dict, key, &mnt_options);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"mntOptions",
-                                                       "%s", mnt_options);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.fs_name", brick_index);
-        ret = dict_get_str (dict, key, &fs_name);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"fsName",
-                                                       "%s", fs_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.inode_size", brick_index);
-        ret = dict_get_str (dict, key, &inode_size);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodeSize",
-                                                       "%s", fs_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.total_inodes", brick_index);
-        ret = dict_get_uint64 (dict, key, &inodes_total);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodesTotal",
-                                                       "%"PRIu64, inodes_total);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.free_inodes", brick_index);
-        ret = dict_get_uint64 (dict, key, &inodes_free);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodesFree",
-                                                       "%"PRIu64, inodes_free);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        } else {
-		ret = 0;
-        }
+    snprintf(key, sizeof(key), "brick%d.pid", brick_index);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d", pid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_mempool (xmlTextWriterPtr writer, dict_t *dict,
-                                   char *prefix)
+cli_xml_output_vol_status_detail(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index)
 {
-        int             ret = -1;
-        int             mempool_count = 0;
-        char            *name = NULL;
-        int             hotcount = 0;
-        int             coldcount = 0;
-        uint64_t        paddedsizeof = 0;
-        uint64_t        alloccount = 0;
-        int             maxalloc = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <mempool> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"mempool");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.mempool-count", prefix);
-        ret = dict_get_int32 (dict, key, &mempool_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", mempool_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < mempool_count; i++) {
-                /* <pool> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"pool");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
-                ret = dict_get_str (dict, key, &name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &hotcount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hotCount",
-                                                       "%d", hotcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &coldcount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"coldCount",
-                                                       "%d", coldcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
-                          prefix, i);
-                ret = dict_get_uint64 (dict, key, &paddedsizeof);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"padddedSizeOf", "%"PRIu64,
-                         paddedsizeof);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"allocCount",
-                                                       "%"PRIu64, alloccount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"maxAlloc",
-                                                       "%d", maxalloc);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"poolMisses",
-                                                       "%"PRIu64, alloccount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"maxStdAlloc",
-                                                       "%d", maxalloc);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-                /* </pool> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        /* </mempool> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t size_total = 0;
+    uint64_t size_free = 0;
+    char *device = NULL;
+    uint64_t block_size = 0;
+    char *mnt_options = NULL;
+    char *fs_name = NULL;
+    char *inode_size = NULL;
+    uint64_t inodes_total = 0;
+    uint64_t inodes_free = 0;
+    char key[1024] = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "brick%d.total", brick_index);
+    ret = dict_get_uint64(dict, key, &size_total);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"sizeTotal",
+                                              "%" PRIu64, size_total);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.free", brick_index);
+    ret = dict_get_uint64(dict, key, &size_free);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"sizeFree",
+                                              "%" PRIu64, size_free);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.device", brick_index);
+    ret = dict_get_str(dict, key, &device);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"device", "%s",
+                                              device);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.block_size", brick_index);
+    ret = dict_get_uint64(dict, key, &block_size);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"blockSize",
+                                              "%" PRIu64, block_size);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.mnt_options", brick_index);
+    ret = dict_get_str(dict, key, &mnt_options);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"mntOptions",
+                                              "%s", mnt_options);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.fs_name", brick_index);
+    ret = dict_get_str(dict, key, &fs_name);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fsName", "%s",
+                                              fs_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.inode_size", brick_index);
+    ret = dict_get_str(dict, key, &inode_size);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodeSize",
+                                              "%s", fs_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.total_inodes", brick_index);
+    ret = dict_get_uint64(dict, key, &inodes_total);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodesTotal",
+                                              "%" PRIu64, inodes_total);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.free_inodes", brick_index);
+    ret = dict_get_uint64(dict, key, &inodes_free);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodesFree",
+                                              "%" PRIu64, inodes_free);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    } else {
+        ret = 0;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_mem (xmlTextWriterPtr writer, dict_t *dict,
-                               int brick_index)
+cli_xml_output_vol_status_mempool(xmlTextWriterPtr writer, dict_t *dict,
+                                  char *prefix)
 {
-        int             ret = -1;
-        int             arena = 0;
-        int             ordblks = 0;
-        int             smblks = 0;
-        int             hblks = 0;
-        int             hblkhd = 0;
-        int             usmblks = 0;
-        int             fsmblks = 0;
-        int             uordblks = 0;
-        int             fordblks = 0;
-        int             keepcost = 0;
-        char            key[1024] = {0,};
-
-        /* <memStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"memStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <mallinfo> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"mallinfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.mallinfo.arena", brick_index);
-        ret = dict_get_int32 (dict, key, &arena);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"arena",
-                                               "%d", arena);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &ordblks);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ordblks",
-                                               "%d", ordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int mempool_count = 0;
+    char *name = NULL;
+    int hotcount = 0;
+    int coldcount = 0;
+    uint64_t paddedsizeof = 0;
+    uint64_t alloccount = 0;
+    int maxalloc = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <mempool> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"mempool");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.mempool-count", prefix);
+    ret = dict_get_int32(dict, key, &mempool_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          mempool_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < mempool_count; i++) {
+        /* <pool> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"pool");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", brick_index);
-        ret = dict_get_int32 (dict, key, &smblks);
+        snprintf(key, sizeof(key), "%s.pool%d.name", prefix, i);
+        ret = dict_get_str(dict, key, &name);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"smblks",
-                                               "%d", smblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", brick_index);
-        ret = dict_get_int32 (dict, key, &hblks);
+        snprintf(key, sizeof(key), "%s.pool%d.hotcount", prefix, i);
+        ret = dict_get_int32(dict, key, &hotcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblks",
-                                               "%d", hblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hotCount",
+                                              "%d", hotcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", brick_index);
-        ret = dict_get_int32 (dict, key, &hblkhd);
+        snprintf(key, sizeof(key), "%s.pool%d.coldcount", prefix, i);
+        ret = dict_get_int32(dict, key, &coldcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblkhd",
-                                               "%d", hblkhd);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"coldCount",
+                                              "%d", coldcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", brick_index);
-        ret = dict_get_int32 (dict, key, &usmblks);
+        snprintf(key, sizeof(key), "%s.pool%d.paddedsizeof", prefix, i);
+        ret = dict_get_uint64(dict, key, &paddedsizeof);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"usmblks",
-                                               "%d", usmblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"padddedSizeOf", "%" PRIu64, paddedsizeof);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", brick_index);
-        ret = dict_get_int32 (dict, key, &fsmblks);
+        snprintf(key, sizeof(key), "%s.pool%d.alloccount", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fsmblks",
-                                               "%d", fsmblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"allocCount",
+                                              "%" PRIu64, alloccount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &uordblks);
+        snprintf(key, sizeof(key), "%s.pool%d.max_alloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxalloc);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uordblks",
-                                               "%d", uordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxAlloc",
+                                              "%d", maxalloc);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &fordblks);
+        snprintf(key, sizeof(key), "%s.pool%d.pool-misses", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fordblks",
-                                               "%d", fordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"poolMisses",
+                                              "%" PRIu64, alloccount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", brick_index);
-        ret = dict_get_int32 (dict, key, &keepcost);
+        snprintf(key, sizeof(key), "%s.pool%d.max-stdalloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxalloc);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"keepcost",
-                                               "%d", keepcost);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </mallinfo> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxStdAlloc",
+                                              "%d", maxalloc);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "brick%d", brick_index);
-        ret = cli_xml_output_vol_status_mempool (writer, dict, key);
-        if (ret)
-                goto out;
+        /* </pool> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </memStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </mempool> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_clients (xmlTextWriterPtr writer, dict_t *dict,
-                                   int brick_index)
+cli_xml_output_vol_status_mem(xmlTextWriterPtr writer, dict_t *dict,
+                              int brick_index)
 {
-        int             ret = -1;
-        int             client_count = 0;
-        char            *hostname = NULL;
-        uint64_t        bytes_read = 0;
-        uint64_t        bytes_write = 0;
-        uint32_t        opversion = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <clientsStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"clientsStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.clientcount", brick_index);
-        ret = dict_get_int32 (dict, key, &client_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"clientCount",
-                                               "%d", client_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < client_count; i++) {
-                /* <client> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"client");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.client%d.hostname",
-                          brick_index, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hostname",
-                                                       "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.client%d.bytesread",
-                          brick_index, i);
-                ret = dict_get_uint64 (dict, key, &bytes_read);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"bytesRead",
-                                                       "%"PRIu64, bytes_read);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.client%d.byteswrite",
-                          brick_index, i);
-                ret = dict_get_uint64 (dict, key, &bytes_write);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"bytesWrite",
-                                                       "%"PRIu64, bytes_write);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.client%d.opversion",
-                          brick_index, i);
-                ret = dict_get_uint32 (dict, key, &opversion);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opVersion",
-                                                       "%"PRIu32, opversion);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </client> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    int ret = -1;
+    int arena = 0;
+    int ordblks = 0;
+    int smblks = 0;
+    int hblks = 0;
+    int hblkhd = 0;
+    int usmblks = 0;
+    int fsmblks = 0;
+    int uordblks = 0;
+    int fordblks = 0;
+    int keepcost = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <memStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"memStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <mallinfo> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"mallinfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.arena", brick_index);
+    ret = dict_get_int32(dict, key, &arena);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"arena", "%d",
+                                          arena);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.ordblks", brick_index);
+    ret = dict_get_int32(dict, key, &ordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"ordblks", "%d",
+                                          ordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.smblks", brick_index);
+    ret = dict_get_int32(dict, key, &smblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"smblks", "%d",
+                                          smblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.hblks", brick_index);
+    ret = dict_get_int32(dict, key, &hblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hblks", "%d",
+                                          hblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.hblkhd", brick_index);
+    ret = dict_get_int32(dict, key, &hblkhd);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hblkhd", "%d",
+                                          hblkhd);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.usmblks", brick_index);
+    ret = dict_get_int32(dict, key, &usmblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"usmblks", "%d",
+                                          usmblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.fsmblks", brick_index);
+    ret = dict_get_int32(dict, key, &fsmblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fsmblks", "%d",
+                                          fsmblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.uordblks", brick_index);
+    ret = dict_get_int32(dict, key, &uordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uordblks", "%d",
+                                          uordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.fordblks", brick_index);
+    ret = dict_get_int32(dict, key, &fordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fordblks", "%d",
+                                          fordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.keepcost", brick_index);
+    ret = dict_get_int32(dict, key, &keepcost);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"keepcost", "%d",
+                                          keepcost);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </mallinfo> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d", brick_index);
+    ret = cli_xml_output_vol_status_mempool(writer, dict, key);
+    if (ret)
+        goto out;
+
+    /* </memStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </clientsStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_inode_entry (xmlTextWriterPtr writer, dict_t *dict,
-                                       char *prefix)
+cli_xml_output_vol_status_clients(xmlTextWriterPtr writer, dict_t *dict,
+                                  int brick_index)
 {
-        int             ret = -1;
-        char            *gfid = NULL;
-        uint64_t        nlookup = 0;
-        uint32_t        ref = 0;
-        int             ia_type = 0;
-        char            key[1024] = {0,};
-
-        /* <inode> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"inode");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_get_str (dict, key, &gfid);
+    int ret = -1;
+    int client_count = 0;
+    char *hostname = NULL;
+    uint64_t bytes_read = 0;
+    uint64_t bytes_write = 0;
+    uint32_t opversion = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <clientsStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"clientsStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.clientcount", brick_index);
+    ret = dict_get_int32(dict, key, &client_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"clientCount",
+                                          "%d", client_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < client_count; i++) {
+        /* <client> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"client");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "brick%d.client%d.hostname", brick_index, i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gfid",
-                                               "%s", gfid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key,0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_get_uint64 (dict, key, &nlookup);
+        snprintf(key, sizeof(key), "brick%d.client%d.bytesread", brick_index,
+                 i);
+        ret = dict_get_uint64(dict, key, &bytes_read);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nLookup",
-                                               "%"PRIu64, nlookup);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"bytesRead",
+                                              "%" PRIu64, bytes_read);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key,0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_get_uint32 (dict, key, &ref);
+        snprintf(key, sizeof(key), "brick%d.client%d.byteswrite", brick_index,
+                 i);
+        ret = dict_get_uint64(dict, key, &bytes_write);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ref",
-                                               "%"PRIu32, ref);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"bytesWrite",
+                                              "%" PRIu64, bytes_write);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key,0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_get_int32 (dict, key, &ia_type);
+        snprintf(key, sizeof(key), "brick%d.client%d.opversion", brick_index,
+                 i);
+        ret = dict_get_uint32(dict, key, &opversion);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"iaType",
-                                               "%d", ia_type);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opVersion",
+                                              "%" PRIu32, opversion);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </inode> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </client> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
+    /* </clientsStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_itable (xmlTextWriterPtr writer, dict_t *dict,
-                                  char *prefix)
+cli_xml_output_vol_status_inode_entry(xmlTextWriterPtr writer, dict_t *dict,
+                                      char *prefix)
 {
-        int             ret = -1;
-        uint32_t        active_size = 0;
-        uint32_t        lru_size = 0;
-        uint32_t        purge_size = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        snprintf (key, sizeof (key), "%s.active_size", prefix);
-        ret = dict_get_uint32 (dict, key, &active_size);
-        if (ret)
+    int ret = -1;
+    char *gfid = NULL;
+    uint64_t nlookup = 0;
+    uint32_t ref = 0;
+    int ia_type = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <inode> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"inode");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_get_str(dict, key, &gfid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"gfid", "%s",
+                                          gfid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    ret = dict_get_uint64(dict, key, &nlookup);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nLookup",
+                                          "%" PRIu64, nlookup);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_get_uint32(dict, key, &ref);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"ref", "%" PRIu32,
+                                          ref);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_get_int32(dict, key, &ia_type);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"iaType", "%d",
+                                          ia_type);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </inode> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+out:
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
+}
+
+int
+cli_xml_output_vol_status_itable(xmlTextWriterPtr writer, dict_t *dict,
+                                 char *prefix)
+{
+    int ret = -1;
+    uint32_t active_size = 0;
+    uint32_t lru_size = 0;
+    uint32_t purge_size = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    snprintf(key, sizeof(key), "%s.active_size", prefix);
+    ret = dict_get_uint32(dict, key, &active_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"activeSize",
+                                          "%" PRIu32, active_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (active_size != 0) {
+        /* <active> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"active");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        for (i = 0; i < active_size; i++) {
+            snprintf(key, sizeof(key), "%s.active%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"activeSize",
-                                               "%"PRIu32, active_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (active_size != 0) {
-                /* <active> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"active");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < active_size; i++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.active%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </active> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </active> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    snprintf(key, sizeof(key), "%s.lru_size", prefix);
+    ret = dict_get_uint32(dict, key, &lru_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lruSize",
+                                          "%" PRIu32, lru_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (lru_size != 0) {
+        /* <lru> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"lru");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.lru_size", prefix);
-        ret = dict_get_uint32 (dict, key, &lru_size);
-        if (ret)
+        for (i = 0; i < lru_size; i++) {
+            snprintf(key, sizeof(key), "%s.lru%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"lruSize",
-                                               "%"PRIu32, lru_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (lru_size != 0) {
-                /* <lru> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"lru");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < lru_size; i++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </lru> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </lru> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    snprintf(key, sizeof(key), "%s.purge_size", prefix);
+    ret = dict_get_uint32(dict, key, &purge_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"purgeSize",
+                                          "%" PRIu32, purge_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (purge_size != 0) {
+        /* <purge> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"purge");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.purge_size", prefix);
-        ret = dict_get_uint32 (dict, key, &purge_size);
-        if (ret)
+        for (i = 0; i < purge_size; i++) {
+            snprintf(key, sizeof(key), "%s.purge%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"purgeSize",
-                                               "%"PRIu32, purge_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (purge_size != 0) {
-                /* <purge> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"purge");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < purge_size; i++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </purge> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </purge> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_inode (xmlTextWriterPtr writer, dict_t *dict,
-                                 int brick_index)
+cli_xml_output_vol_status_inode(xmlTextWriterPtr writer, dict_t *dict,
+                                int brick_index)
 {
-        int             ret = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <inodeStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"inodeStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <inodeStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"inodeStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.conncount", brick_index);
+    ret = dict_get_int32(dict, key, &conn_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connections",
+                                          "%d", conn_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < conn_count; i++) {
+        /* <connection> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"connection");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
-        ret = dict_get_int32 (dict, key, &conn_count);
+        snprintf(key, sizeof(key), "brick%d.conn%d.itable", brick_index, i);
+        ret = cli_xml_output_vol_status_itable(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
-                                               "%d", conn_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < conn_count; i++) {
-                /* <connection> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"connection");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.conn%d.itable",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_itable (writer, dict, key);
-                if (ret)
-                        goto out;
+            goto out;
 
-                /* </connection> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </connection> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </inodeStatus> */
-        ret= xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </inodeStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_fdtable (xmlTextWriterPtr writer, dict_t *dict,
-                                   char *prefix)
+cli_xml_output_vol_status_fdtable(xmlTextWriterPtr writer, dict_t *dict,
+                                  char *prefix)
 {
-        int             ret = -1;
-        int             refcount = 0;
-        uint32_t        maxfds = 0;
-        int             firstfree = 0;
-        int             openfds = 0;
-        int             fd_pid = 0;
-        int             fd_refcount = 0;
-        int             fd_flags = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <fdTable> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdTable");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &refcount);
+    int ret = -1;
+    int refcount = 0;
+    uint32_t maxfds = 0;
+    int firstfree = 0;
+    int openfds = 0;
+    int fd_pid = 0;
+    int fd_refcount = 0;
+    int fd_flags = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <fdTable> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fdTable");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &refcount);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount", "%d",
+                                          refcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.maxfds", prefix);
+    ret = dict_get_uint32(dict, key, &maxfds);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxFds",
+                                          "%" PRIu32, maxfds);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.firstfree", prefix);
+    ret = dict_get_int32(dict, key, &firstfree);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"firstFree", "%d",
+                                          firstfree);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.openfds", prefix);
+    ret = dict_get_int32(dict, key, &openfds);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"openFds", "%d",
+                                          openfds);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < maxfds; i++) {
+        snprintf(key, sizeof(key), "%s.fdentry%d.pid", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_pid);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
-                                               "%d", refcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.maxfds", prefix);
-        ret = dict_get_uint32 (dict, key, &maxfds);
+        snprintf(key, sizeof(key), "%s.fdentry%d.refcount", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_refcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"maxFds",
-                                               "%"PRIu32, maxfds);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.firstfree", prefix);
-        ret = dict_get_int32 (dict, key, &firstfree);
+        snprintf(key, sizeof(key), "%s.fdentry%d.flags", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_flags);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"firstFree",
-                                               "%d", firstfree);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.openfds", prefix);
-        ret = dict_get_int32 (dict, key, &openfds);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"openFds",
-                                               "%d", openfds);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < maxfds; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_pid);
-                if (ret)
-                        continue;
+        /* <fd> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fd");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
-                          prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_refcount);
-                if (ret)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"entry", "%d",
+                                              i + 1);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_flags);
-                if (ret)
-                        continue;
-
-                /* <fd> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fd");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"entry",
-                                                       "%d", i+1);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"pid",
-                                                       "%d", fd_pid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"refCount",
-                                                       "%d", fd_refcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"flags",
-                                                       "%d", fd_flags);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </fd> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d",
+                                              fd_pid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </fdTable> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount",
+                                              "%d", fd_refcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"flags", "%d",
+                                              fd_flags);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        /* </fd> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </fdTable> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_fd (xmlTextWriterPtr writer, dict_t *dict,
-                              int brick_index)
+cli_xml_output_vol_status_fd(xmlTextWriterPtr writer, dict_t *dict,
+                             int brick_index)
 {
-        int             ret = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <fdStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <fdStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fdStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.conncount", brick_index);
+    ret = dict_get_int32(dict, key, &conn_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connections",
+                                          "%d", conn_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < conn_count; i++) {
+        /* <connection> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"connection");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
-        ret = dict_get_int32 (dict, key, &conn_count);
+        snprintf(key, sizeof(key), "brick%d.conn%d.fdtable", brick_index, i);
+        ret = cli_xml_output_vol_status_fdtable(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
-                                               "%d", conn_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < conn_count; i++) {
-                /* <connection> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"connection");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_fdtable (writer, dict, key);
-                if (ret)
-                        goto out;
+            goto out;
 
-                /* </connection> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </connection> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </fdStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </fdStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callframe (xmlTextWriterPtr writer, dict_t *dict,
-                                     char *prefix)
+cli_xml_output_vol_status_callframe(xmlTextWriterPtr writer, dict_t *dict,
+                                    char *prefix)
 {
-        int             ret = -1;
-        int             ref_count = 0;
-        char            *translator = NULL;
-        int             complete = 0;
-        char            *parent = NULL;
-        char            *wind_from = NULL;
-        char            *wind_to = NULL;
-        char            *unwind_from = NULL;
-        char            *unwind_to = NULL;
-        char            key[1024] = {0,};
-
-        /* <callFrame> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callFrame");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &ref_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
-                                               "%d", ref_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_get_str (dict, key, &translator);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"translator",
-                                               "%s", translator);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_get_int32 (dict, key, &complete);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"complete",
-                                               "%d", complete);
-        XML_RET_CHECK_AND_GOTO (ret ,out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.parent", prefix);
-        ret = dict_get_str (dict, key, &parent);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"parent",
-                                                       "%s", parent);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    int ret = -1;
+    int ref_count = 0;
+    char *translator = NULL;
+    int complete = 0;
+    char *parent = NULL;
+    char *wind_from = NULL;
+    char *wind_to = NULL;
+    char *unwind_from = NULL;
+    char *unwind_to = NULL;
+    char key[1024] = {
+        0,
+    };
+
+    /* <callFrame> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callFrame");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &ref_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount", "%d",
+                                          ref_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_get_str(dict, key, &translator);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"translator", "%s",
+                                          translator);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_get_int32(dict, key, &complete);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"complete", "%d",
+                                          complete);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.parent", prefix);
+    ret = dict_get_str(dict, key, &parent);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"parent", "%s",
+                                              parent);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.windfrom", prefix);
-        ret = dict_get_str (dict, key, &wind_from);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"windFrom",
-                                                       "%s", wind_from);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.windfrom", prefix);
+    ret = dict_get_str(dict, key, &wind_from);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"windFrom",
+                                              "%s", wind_from);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.windto", prefix);
-        ret = dict_get_str (dict, key, &wind_to);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"windTo",
-                                                       "%s", wind_to);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.windto", prefix);
+    ret = dict_get_str(dict, key, &wind_to);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"windTo", "%s",
+                                              wind_to);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-        ret = dict_get_str (dict, key, &unwind_from);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"unwindFrom",
-                                                       "%s", unwind_from);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+    ret = dict_get_str(dict, key, &unwind_from);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unwindFrom",
+                                              "%s", unwind_from);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unwindto", prefix);
-        ret = dict_get_str (dict, key, &unwind_to);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"unwindTo",
-                                                       "%s", unwind_to);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.unwindto", prefix);
+    ret = dict_get_str(dict, key, &unwind_to);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unwindTo",
+                                              "%s", unwind_to);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </callFrame> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callFrame> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callstack (xmlTextWriterPtr writer, dict_t *dict,
-                                     char *prefix)
+cli_xml_output_vol_status_callstack(xmlTextWriterPtr writer, dict_t *dict,
+                                    char *prefix)
 {
-        int             ret = -1;
-        int             uid = 0;
-        int             gid = 0;
-        int             pid = 0;
-        uint64_t        unique = 0;
-        int             frame_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <callStack> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callStack");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_get_int32 (dict, key, &uid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uid",
-                                               "%d", uid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_get_int32 (dict, key, &gid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gid",
-                                               "%d", gid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
-                                               "%d", pid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_get_uint64 (dict, key, &unique);
+    int ret = -1;
+    int uid = 0;
+    int gid = 0;
+    int pid = 0;
+    uint64_t unique = 0;
+    int frame_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <callStack> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callStack");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_get_int32(dict, key, &uid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uid", "%d", uid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_get_int32(dict, key, &gid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"gid", "%d", gid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d", pid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_get_uint64(dict, key, &unique);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unique",
+                                          "%" PRIu64, unique);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &frame_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"frameCount", "%d",
+                                          frame_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < frame_count; i++) {
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        ret = cli_xml_output_vol_status_callframe(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"unique",
-                                               "%"PRIu64, unique);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &frame_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"frameCount",
-                                               "%d", frame_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < frame_count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
-                ret = cli_xml_output_vol_status_callframe (writer, dict,
-                                                           key);
-                if (ret)
-                        goto out;
-        }
-
-        /* </callStack> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callStack> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callpool (xmlTextWriterPtr writer, dict_t *dict,
-                                    int brick_index)
+cli_xml_output_vol_status_callpool(xmlTextWriterPtr writer, dict_t *dict,
+                                   int brick_index)
 {
-        int             ret = -1;
-        int             call_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <callpoolStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callpoolStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.callpool.count", brick_index);
-        ret = dict_get_int32 (dict, key, &call_count);
+    int ret = -1;
+    int call_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <callpoolStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callpoolStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.callpool.count", brick_index);
+    ret = dict_get_int32(dict, key, &call_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          call_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < call_count; i++) {
+        snprintf(key, sizeof(key), "brick%d.callpool.stack%d", brick_index, i);
+        ret = cli_xml_output_vol_status_callstack(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", call_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < call_count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "brick%d.callpool.stack%d",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_callstack (writer, dict,
-                                                           key);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        /* </callpoolStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callpoolStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                 char *op_errstr)
+cli_xml_output_vol_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "volStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volumes> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volumes> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volumes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_status_end (cli_local_t *local)
+cli_xml_output_vol_status_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        /* </volumes> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volumes> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </volStatus> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </volStatus> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_remove_brick_task_params (xmlTextWriterPtr writer, dict_t *dict,
-                                         char *prefix)
+cli_xml_output_remove_brick_task_params(xmlTextWriterPtr writer, dict_t *dict,
+                                        char *prefix)
 {
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             count = 0;
-        int             i = 0;
-        char            *brick = NULL;
-
-        /* <params> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"params");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &count);
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int count = 0;
+    int i = 0;
+    char *brick = NULL;
+
+    /* <params> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"params");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &count);
+    if (ret)
+        goto out;
+
+    for (i = 1; i <= count; i++) {
+        snprintf(key, sizeof(key), "%s.brick%d", prefix, i);
+        ret = dict_get_str(dict, key, &brick);
         if (ret)
-                goto out;
-
-        for (i = 1; i <= count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.brick%d", prefix, i);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"brick",
-                                                       "%s", brick);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                brick = NULL;
-        }
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brick", "%s",
+                                              brick);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        brick = NULL;
+    }
 
-        /* </param> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </param> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
-        int                     ret = -1;
-        char                    *task_type = NULL;
-        char                    *task_id_str = NULL;
-        int                     status = 0;
-        int                     tasks = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-
-        /* <tasks> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"tasks");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "tasks", &tasks);
+cli_xml_output_vol_status_tasks(cli_local_t *local, dict_t *dict)
+{
+    int ret = -1;
+    char *task_type = NULL;
+    char *task_id_str = NULL;
+    int status = 0;
+    int tasks = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <tasks> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"tasks");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "tasks", &tasks);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < tasks; i++) {
+        /* <task> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"task");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "task%d.type", i);
+        ret = dict_get_str(dict, key, &task_type);
         if (ret)
-                goto out;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%s", task_type);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < tasks; i++) {
-                /* <task> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"task");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d.id", i);
+        ret = dict_get_str(dict, key, &task_id_str);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.type", i);
-                ret = dict_get_str (dict, key, &task_type);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"type",
-                                                       "%s", task_type);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.id", i);
-                ret = dict_get_str (dict, key, &task_id_str);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s",
-                                             cli_vol_task_status_str[status]);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "task%d", i);
-                if (!strcmp (task_type, "Remove brick")) {
-                        ret = cli_xml_output_remove_brick_task_params
-                                (local->writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
+        snprintf(key, sizeof(key), "task%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"status", "%d", status);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"statusStr", "%s",
+                                              cli_vol_task_status_str[status]);
 
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </task> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d", i);
+        if (!strcmp(task_type, "Remove brick")) {
+            ret = cli_xml_output_remove_brick_task_params(local->writer, dict,
+                                                          key);
+            if (ret)
+                goto out;
         }
 
-        /* </tasks> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </task> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </tasks> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 #endif
 
 int
-cli_xml_output_vol_status_tasks_detail (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_status_tasks_detail(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int    ret     = -1;
-        char  *volname = NULL;
+    int ret = -1;
+    char *volname = NULL;
 
-        /*<volume>*/
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /*<volume>*/
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"volName", "%s",
-                                               volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"volName",
+                                          "%s", volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_vol_status_tasks (local, dict);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_vol_status_tasks(local, dict);
+    if (ret)
+        goto out;
 
-        /* </volume> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volume> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_status (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_status(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        char                    *volname = NULL;
-        int                     brick_count = 0;
-        int                     brick_index_max = -1;
-        int                     other_count = 0;
-        int                     index_max = 0;
-        uint32_t                cmd = GF_CLI_STATUS_NONE;
-        int                     online = 0;
-        gf_boolean_t            node_present = _gf_true;
-        int                     i;
-        int                     type            = -1;
-        int                     hot_brick_count = -1;
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"volName", "%s",
-                                               volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"nodeCount", "%d",
-                                               brick_count);
-
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret)
+    int ret = -1;
+    char *volname = NULL;
+    int brick_count = 0;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    uint32_t cmd = GF_CLI_STATUS_NONE;
+    int online = 0;
+    gf_boolean_t node_present = _gf_true;
+    int i;
+    int type = -1;
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"volName",
+                                          "%s", volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"nodeCount",
+                                          "%d", brick_count);
+
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret)
+        goto out;
+
+    for (i = 0; i <= index_max; i++) {
+        ret = cli_xml_output_vol_status_common(local->writer, dict, i, &online,
+                                               &node_present);
+        if (ret) {
+            if (node_present)
                 goto out;
-
-        if (type == GF_CLUSTER_TYPE_TIER) {
-                ret = dict_get_int32 (dict, "hot_brick_count",
-                                      &hot_brick_count);
-                if (ret)
-                        goto out;
-
-                ret = xmlTextWriterStartElement
-                        (local->writer, (xmlChar *)"hotBricks");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
+            else
+                continue;
         }
-        for (i = 0; i <= index_max; i++) {
 
-                if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
+        switch (cmd & GF_CLI_STATUS_MASK) {
+            case GF_CLI_STATUS_DETAIL:
+                ret = cli_xml_output_vol_status_detail(local->writer, dict, i);
+                if (ret)
+                    goto out;
+                break;
 
-                        /* </hotBricks>*/
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        ret = xmlTextWriterStartElement (local->writer,
-                                        (xmlChar *)"coldBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
-                ret = cli_xml_output_vol_status_common (local->writer, dict, i,
-                                                        &online, &node_present);
-                if (ret) {
-                        if (node_present)
-                                goto out;
-                        else
-                                continue;
+            case GF_CLI_STATUS_MEM:
+                if (online) {
+                    ret = cli_xml_output_vol_status_mem(local->writer, dict, i);
+                    if (ret)
+                        goto out;
                 }
+                break;
 
-                switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_DETAIL:
-                        ret = cli_xml_output_vol_status_detail (local->writer,
-                                                                dict, i);
-                        if (ret)
-                                goto out;
-                        break;
-
-                case GF_CLI_STATUS_MEM:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_mem
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_clients
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_inode
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_fd
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_callpool
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-                default:
-                        break;
-
+            case GF_CLI_STATUS_CLIENTS:
+                if (online) {
+                    ret = cli_xml_output_vol_status_clients(local->writer, dict,
+                                                            i);
+                    if (ret)
+                        goto out;
                 }
+                break;
 
-                /* </node>  was opened in cli_xml_output_vol_status_common()*/
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            case GF_CLI_STATUS_INODE:
+                if (online) {
+                    ret = cli_xml_output_vol_status_inode(local->writer, dict,
+                                                          i);
+                    if (ret)
+                        goto out;
+                }
+                break;
 
-                /* </coldBricks>*/
-                if (type == GF_CLUSTER_TYPE_TIER && i == brick_index_max) {
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+            case GF_CLI_STATUS_FD:
+                if (online) {
+                    ret = cli_xml_output_vol_status_fd(local->writer, dict, i);
+                    if (ret)
+                        goto out;
                 }
-        }
+                break;
 
-        /* Tasks are only present when a normal volume status call is done on a
-         * single volume or on all volumes
-         */
-        if (((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE) &&
-            (cmd & (GF_CLI_STATUS_VOL|GF_CLI_STATUS_ALL))) {
-                ret = cli_xml_output_vol_status_tasks (local, dict);
-                if (ret)
+            case GF_CLI_STATUS_CALLPOOL:
+                if (online) {
+                    ret = cli_xml_output_vol_status_callpool(local->writer,
+                                                             dict, i);
+                    if (ret)
                         goto out;
+                }
+                break;
+            default:
+                break;
         }
 
-        /* </volume> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </node>  was opened in cli_xml_output_vol_status_common()*/
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* Tasks are only present when a normal volume status call is done on a
+     * single volume or on all volumes
+     */
+    if (((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE) &&
+        (cmd & (GF_CLI_STATUS_VOL | GF_CLI_STATUS_ALL))) {
+        ret = cli_xml_output_vol_status_tasks(local, dict);
+        if (ret)
+            goto out;
+    }
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_top_rw_perf (xmlTextWriterPtr writer, dict_t *dict,
-                                int brick_index, int member_index)
+cli_xml_output_vol_top_rw_perf(xmlTextWriterPtr writer, dict_t *dict,
+                               int brick_index, int member_index)
 {
-        int        ret = -1;
-        char      *filename = NULL;
-        uint64_t   throughput = 0;
-        long int   time_sec = 0;
-        long int   time_usec = 0;
-        char       timestr[256] = {0,};
-        char       key[1024] = {0,};
-
-        /* <file> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
-                  member_index);
-        ret = dict_get_str (dict, key, &filename);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
-                                               "%s", filename);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
-        ret = dict_get_uint64 (dict, key, &throughput);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%"PRIu64, throughput);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-time-sec-%d", brick_index,
-                  member_index);
-        ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-time-usec-%d", brick_index,
-                  member_index);
-        ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
-        if (ret)
-                goto out;
-
-        gf_time_fmt (timestr, sizeof timestr, time_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr),
-                  sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, time_usec);
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"time",
-                                               "%s", timestr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </file> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *filename = NULL;
+    uint64_t throughput = 0;
+    struct timeval tv = {
+        0,
+    };
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char key[1024] = {
+        0,
+    };
+
+    /* <file> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-filename-%d", brick_index, member_index);
+    ret = dict_get_str(dict, key, &filename);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"filename", "%s",
+                                          filename);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-value-%d", brick_index, member_index);
+    ret = dict_get_uint64(dict, key, &throughput);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count",
+                                          "%" PRIu64, throughput);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-time-sec-%d", brick_index, member_index);
+    ret = dict_get_int32(dict, key, (int32_t *)&tv.tv_sec);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%d-time-usec-%d", brick_index, member_index);
+    ret = dict_get_int32(dict, key, (int32_t *)&tv.tv_usec);
+    if (ret)
+        goto out;
+
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"time", "%s",
+                                          timestr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </file> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_top_other (xmlTextWriterPtr writer, dict_t *dict,
-                                int brick_index, int member_index)
+cli_xml_output_vol_top_other(xmlTextWriterPtr writer, dict_t *dict,
+                             int brick_index, int member_index)
 {
-        int             ret = -1;
-        char            *filename = NULL;
-        uint64_t        count = 0;
-        char            key[1024] = {0,};
-
-        /* <file> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
-                  member_index);
-        ret = dict_get_str (dict, key, &filename);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
-                                               "%s", filename);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
-        ret = dict_get_uint64 (dict, key, &count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%"PRIu64, count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </file> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *filename = NULL;
+    uint64_t count = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <file> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-filename-%d", brick_index, member_index);
+    ret = dict_get_str(dict, key, &filename);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"filename", "%s",
+                                          filename);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-value-%d", brick_index, member_index);
+    ret = dict_get_uint64(dict, key, &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count",
+                                          "%" PRIu64, count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </file> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_top (dict_t *dict, int op_ret, int op_errno,
-                        char *op_errstr)
+cli_xml_output_vol_top(dict_t *dict, int op_ret, int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     brick_count = 0;
-        int                     top_op = GF_CLI_TOP_NONE;
-        char                    *brick_name = NULL;
-        int                     members = 0;
-        uint64_t                current_open = 0;
-        uint64_t                max_open = 0;
-        char                    *max_open_time = NULL;
-        double                  throughput = 0.0;
-        double                  time_taken = 0.0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     j = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int brick_count = 0;
+    int top_op = GF_CLI_TOP_NONE;
+    char *brick_name = NULL;
+    int members = 0;
+    uint64_t current_open = 0;
+    uint64_t max_open = 0;
+    char *max_open_time = NULL;
+    double throughput = 0.0;
+    double time_taken = 0.0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volTop> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volTop");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brick_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "1-top-op", &top_op);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"topOp", "%d",
+                                          top_op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    while (i < brick_count) {
+        i++;
+
+        /* <brick> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_str(dict, key, &brick_name);
         if (ret)
-                goto out;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              brick_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+        snprintf(key, sizeof(key), "%d-members", i);
+        ret = dict_get_int32(dict, key, &members);
         if (ret)
-                goto out;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"members",
+                                              "%d", members);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volTop> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volTop");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        switch (top_op) {
+            case GF_CLI_TOP_OPEN:
+                snprintf(key, sizeof(key), "%d-current-open", i);
+                ret = dict_get_uint64(dict, key, &current_open);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"currentOpen", "%" PRIu64, current_open);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
-                                               "%d", brick_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+                snprintf(key, sizeof(key), "%d-max-open", i);
+                ret = dict_get_uint64(dict, key, &max_open);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"maxOpen", "%" PRIu64, max_open);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "1-top-op", &top_op);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"topOp",
-                                               "%d", top_op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+                snprintf(key, sizeof(key), "%d-max-openfd-time", i);
+                ret = dict_get_str(dict, key, &max_open_time);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"maxOpenTime", "%s", max_open_time);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-        while (i < brick_count) {
-                i++;
+            case GF_CLI_TOP_READ:
+            case GF_CLI_TOP_WRITE:
+            case GF_CLI_TOP_OPENDIR:
+            case GF_CLI_TOP_READDIR:
 
-                /* <brick> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                break;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick_name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", brick_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key , sizeof (key), "%d-members", i);
-                ret = dict_get_int32 (dict, key, &members);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"members",
-                                                       "%d", members);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                switch (top_op) {
-                case GF_CLI_TOP_OPEN:
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-current-open", i);
-                        ret = dict_get_uint64 (dict, key, &current_open);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"currentOpen", "%"PRIu64,
-                                 current_open);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-max-open", i);
-                        ret = dict_get_uint64 (dict, key, &max_open);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"maxOpen", "%"PRIu64,
-                                 max_open);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-max-openfd-time", i);
-                        ret = dict_get_str (dict, key, &max_open_time);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"maxOpenTime", "%s",
-                                 max_open_time);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                case GF_CLI_TOP_READ:
-                case GF_CLI_TOP_WRITE:
-                case GF_CLI_TOP_OPENDIR:
-                case GF_CLI_TOP_READDIR:
-
-                        break;
-
-                case GF_CLI_TOP_READ_PERF:
-                case GF_CLI_TOP_WRITE_PERF:
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-throughput", i);
-                        ret = dict_get_double (dict, key, &throughput);
-                        if (!ret) {
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key), "%d-time", i);
-                                ret = dict_get_double (dict, key, &time_taken);
-                        }
-
-                        if (!ret) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (writer, (xmlChar *)"throughput",
-                                         "%f", throughput);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (writer, (xmlChar *)"timeTaken",
-                                         "%f", time_taken);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-
-                        break;
-
-                default:
-                        ret = -1;
-                        goto out;
+            case GF_CLI_TOP_READ_PERF:
+            case GF_CLI_TOP_WRITE_PERF:
+                snprintf(key, sizeof(key), "%d-throughput", i);
+                ret = dict_get_double(dict, key, &throughput);
+                if (!ret) {
+                    snprintf(key, sizeof(key), "%d-time", i);
+                    ret = dict_get_double(dict, key, &time_taken);
                 }
 
-                for (j = 1; j <= members; j++) {
-                        if (top_op == GF_CLI_TOP_READ_PERF ||
-                            top_op == GF_CLI_TOP_WRITE_PERF) {
-                                ret = cli_xml_output_vol_top_rw_perf
-                                        (writer, dict, i, j);
-                        } else {
-                                ret = cli_xml_output_vol_top_other
-                                        (writer, dict, i, j);
-                        }
-                        if (ret)
-                                goto out;
+                if (!ret) {
+                    ret = xmlTextWriterWriteFormatElement(
+                        writer, (xmlChar *)"throughput", "%f", throughput);
+                    XML_RET_CHECK_AND_GOTO(ret, out);
+
+                    ret = xmlTextWriterWriteFormatElement(
+                        writer, (xmlChar *)"timeTaken", "%f", time_taken);
+                    XML_RET_CHECK_AND_GOTO(ret, out);
                 }
 
+                break;
 
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            default:
+                ret = -1;
+                goto out;
         }
 
-        /* </volTop> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        ret = cli_end_xml_output (writer, doc);
+        for (j = 1; j <= members; j++) {
+            if (top_op == GF_CLI_TOP_READ_PERF ||
+                top_op == GF_CLI_TOP_WRITE_PERF) {
+                ret = cli_xml_output_vol_top_rw_perf(writer, dict, i, j);
+            } else {
+                ret = cli_xml_output_vol_top_other(writer, dict, i, j);
+            }
+            if (ret)
+                goto out;
+        }
+
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </volTop> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_profile_stats (xmlTextWriterPtr writer, dict_t *dict,
-                                  int brick_index, int interval)
+cli_xml_output_vol_profile_stats(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index, int interval)
 {
-        int                     ret = -1;
-        uint64_t                read_count = 0;
-        uint64_t                write_count = 0;
-        uint64_t                hits = 0;
-        double                  avg_latency = 0.0;
-        double                  max_latency = 0.0;
-        double                  min_latency = 0.0;
-        uint64_t                duration = 0;
-        uint64_t                total_read = 0;
-        uint64_t                total_write = 0;
-        char                    key[1024] = {0};
-        int                     i = 0;
-
-        /* <cumulativeStats> || <intervalStats> */
-        if (interval == -1)
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"cumulativeStats");
-        else
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"intervalStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <blockStats> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"blockStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < 32; i++) {
-                /* <block> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"block");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"size", "%"PRIu32, (1 << i));
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-read-%d", brick_index,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &read_count);
-                if (ret)
-                        read_count = 0;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"reads", "%"PRIu64, read_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-write-%d", brick_index,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &write_count);
-                if (ret)
-                        write_count = 0;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"writes", "%"PRIu64, write_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </block> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        /* </blockStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <fopStats> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fopStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-hits", brick_index,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &hits);
-                if (ret)
-                        goto cont;
+    int ret = -1;
+    uint64_t read_count = 0;
+    uint64_t write_count = 0;
+    uint64_t hits = 0;
+    double avg_latency = 0.0;
+    double max_latency = 0.0;
+    double min_latency = 0.0;
+    uint64_t duration = 0;
+    uint64_t total_read = 0;
+    uint64_t total_write = 0;
+    char key[1024] = {0};
+    int i = 0;
+
+    /* <cumulativeStats> || <intervalStats> */
+    if (interval == -1)
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"cumulativeStats");
+    else
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"intervalStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <blockStats> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"blockStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < 32; i++) {
+        /* <block> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"block");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-avglatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &avg_latency);
-                if (ret)
-                        goto cont;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size",
+                                              "%" PRIu32, (1U << i));
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-minlatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &min_latency);
-                if (ret)
-                        goto cont;
+        snprintf(key, sizeof(key), "%d-%d-read-%" PRIu32, brick_index, interval,
+                 (1U << i));
+        ret = dict_get_uint64(dict, key, &read_count);
+        if (ret)
+            read_count = 0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"reads",
+                                              "%" PRIu64, read_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &max_latency);
-                if (ret)
-                        goto cont;
+        snprintf(key, sizeof(key), "%d-%d-write-%" PRIu32, brick_index,
+                 interval, (1U << i));
+        ret = dict_get_uint64(dict, key, &write_count);
+        if (ret)
+            write_count = 0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"writes",
+                                              "%" PRIu64, write_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <fop> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fop");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </block> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"name","%s", gf_fop_list[i]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </blockStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hits", "%"PRIu64, hits);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <fopStats> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fopStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"avgLatency", "%f", avg_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-hits", brick_index, interval, i);
+        ret = dict_get_uint64(dict, key, &hits);
+        if (ret)
+            goto cont;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"minLatency", "%f", min_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-avglatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &avg_latency);
+        if (ret)
+            goto cont;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"maxLatency", "%f", max_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-minlatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &min_latency);
+        if (ret)
+            goto cont;
 
-                /* </fop> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-maxlatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &max_latency);
+        if (ret)
+            goto cont;
 
-cont:
-                hits = 0;
-                avg_latency = 0.0;
-                min_latency = 0.0;
-                max_latency = 0.0;
-        }
+        /* <fop> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fop");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                hits = 0;
-                avg_latency = 0.0;
-                min_latency = 0.0;
-                max_latency = 0.0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              gf_fop_list[i]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%d-%d-%d-upcall-hits", brick_index,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &hits);
-                if (ret)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hits",
+                                              "%" PRIu64, hits);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <fop> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fop");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"avgLatency",
+                                              "%f", avg_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"name", "%s", gf_fop_list[i]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"minLatency",
+                                              "%f", min_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hits", "%"PRIu64, hits);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxLatency",
+                                              "%f", max_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"avgLatency", "%f", avg_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </fop> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"minLatency", "%f", min_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    cont:
+        hits = 0;
+        avg_latency = 0.0;
+        min_latency = 0.0;
+        max_latency = 0.0;
+    }
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        hits = 0;
+        avg_latency = 0.0;
+        min_latency = 0.0;
+        max_latency = 0.0;
+
+        snprintf(key, sizeof(key), "%d-%d-%d-upcall-hits", brick_index,
+                 interval, i);
+        ret = dict_get_uint64(dict, key, &hits);
+        if (ret)
+            continue;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"maxLatency", "%f", max_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <fop> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fop");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </fop> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              gf_fop_list[i]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </fopStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hits",
+                                              "%" PRIu64, hits);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-duration", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &duration);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"duration",
-                                               "%"PRIu64, duration);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"avgLatency",
+                                              "%f", avg_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-total-read", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &total_read);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalRead",
-                                               "%"PRIu64, total_read);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"minLatency",
+                                              "%f", min_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%d-%d-total-write", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &total_write);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalWrite",
-                                               "%"PRIu64, total_write);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxLatency",
+                                              "%f", max_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </cumulativeStats> || </intervalStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </fop> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </fopStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-duration", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &duration);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"duration",
+                                          "%" PRIu64, duration);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-total-read", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &total_read);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"totalRead",
+                                          "%" PRIu64, total_read);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-total-write", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &total_write);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"totalWrite",
+                                          "%" PRIu64, total_write);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </cumulativeStats> || </intervalStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_profile (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_vol_profile(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        int                     op = GF_CLI_STATS_NONE;
-        int                     info_op = GF_CLI_INFO_NONE;
-        int                     brick_count = 0;
-        char                    *brick_name = NULL;
-        int                     interval = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     stats_cleared = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <volProfile> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volProfile");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"volname",
-                                               "%s", volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "op", &op);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"profileOp",
-                                               "%d", op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (GF_CLI_STATS_INFO != op)
-                goto cont;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    int op = GF_CLI_STATS_NONE;
+    int info_op = GF_CLI_INFO_NONE;
+    int brick_count = 0;
+    char *brick_name = NULL;
+    int interval = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int stats_cleared = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volProfile> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volProfile");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volname", "%s",
+                                          volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "op", &op);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"profileOp", "%d",
+                                          op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    if (GF_CLI_STATS_INFO != op)
+        goto cont;
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brick_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "info-op", &info_op);
+    if (ret)
+        goto out;
+
+    while (i < brick_count) {
+        i++;
+
+        /* <brick> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
+        snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_str(dict, key, &brick_name);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
-                                               "%d", brick_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickName",
+                                              "%s", brick_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "info-op", &info_op);
-        if (ret)
+        if (GF_CLI_INFO_CLEAR == info_op) {
+            snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32(dict, key, &stats_cleared);
+            if (ret)
                 goto out;
 
-        while (i < brick_count) {
-                i++;
-
-                /* <brick> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick_name);
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"clearStats", "%s",
+                stats_cleared ? "Cleared stats." : "Failed to clear stats.");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        } else {
+            snprintf(key, sizeof(key), "%d-cumulative", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0) {
+                ret = cli_xml_output_vol_profile_stats(writer, dict, i,
+                                                       interval);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"brickName", "%s", brick_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                if (GF_CLI_INFO_CLEAR == info_op) {
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"clearStats", "%s",
-                                stats_cleared ? "Cleared stats." :
-                                                 "Failed to clear stats.");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                } else {
-                        snprintf (key, sizeof (key), "%d-cumulative", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0) {
-                                ret = cli_xml_output_vol_profile_stats
-                                        (writer, dict, i, interval);
-                                if (ret)
-                                        goto out;
-                        }
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%d-interval", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0) {
-                                ret = cli_xml_output_vol_profile_stats
-                                        (writer, dict, i, interval);
-                                if (ret)
-                                        goto out;
-                        }
-                }
-
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+            }
+
+            snprintf(key, sizeof(key), "%d-interval", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0) {
+                ret = cli_xml_output_vol_profile_stats(writer, dict, i,
+                                                       interval);
+                if (ret)
+                    goto out;
+            }
         }
 
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
 cont:
-        /* </volProfile> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volProfile> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_list (dict_t *dict, int op_ret, int op_errno,
-                         char *op_errstr)
+cli_xml_output_vol_list(dict_t *dict, int op_ret, int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     count = 0;
-        char                    *volname = NULL;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int count = 0;
+    char *volname = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volList> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volList");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < count; i++) {
+        snprintf(key, sizeof(key), "volume%d", i);
+        ret = dict_get_str(dict, key, &volname);
         if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <volList> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volList");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"volume",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volume", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </volList> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volList> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_info_option (xmlTextWriterPtr writer, char *substr,
-                                char *optstr, char *valstr)
+cli_xml_output_vol_info_option(xmlTextWriterPtr writer, char *substr,
+                               char *optstr, char *valstr)
 {
-        int             ret = -1;
-        char            *ptr1 = NULL;
-        char            *ptr2 = NULL;
-
-        ptr1 = substr;
-        ptr2 = optstr;
-
-        while (ptr1) {
-                if (*ptr1 != *ptr2)
-                        break;
-                ptr1++;
-                ptr2++;
-                if (!ptr1)
-                        goto out;
-                if (!ptr2)
-                        goto out;
-        }
-        if (*ptr2 == '\0')
-                goto out;
-
-        /* <option> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"option");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"name",
-                                               "%s", ptr2);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"value",
-                                               "%s", valstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </option> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *ptr1 = NULL;
+    char *ptr2 = NULL;
+
+    ptr1 = substr;
+    ptr2 = optstr;
+
+    while (ptr1) {
+        if (*ptr1 != *ptr2)
+            break;
+        ptr1++;
+        ptr2++;
+        if (!*ptr1)
+            break;
+        if (!*ptr2)
+            break;
+    }
+    if (*ptr2 == '\0')
+        goto out;
+
+    /* <option> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"option");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          ptr2);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"value", "%s",
+                                          valstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </option> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 struct tmp_xml_option_logger {
-        char *key;
-        xmlTextWriterPtr writer;
+    char *key;
+    xmlTextWriterPtr writer;
 };
 
 static int
-_output_vol_info_option (dict_t *d, char *k, data_t *v,
-                         void *data)
+_output_vol_info_option(dict_t *d, char *k, data_t *v, void *data)
 {
-        int                           ret   = 0;
-        char                         *ptr   = NULL;
-        struct tmp_xml_option_logger *tmp   = NULL;
+    int ret = 0;
+    char *ptr = NULL;
+    struct tmp_xml_option_logger *tmp = NULL;
 
-        tmp = data;
+    tmp = data;
 
-        ptr = strstr (k, "option.");
-        if (!ptr)
-                goto out;
+    ptr = strstr(k, "option.");
+    if (!ptr)
+        goto out;
 
-        if (!v) {
-                ret = -1;
-                goto out;
-        }
-        ret = cli_xml_output_vol_info_option (tmp->writer, tmp->key, k,
-                                              v->data);
+    if (!v) {
+        ret = -1;
+        goto out;
+    }
+    ret = cli_xml_output_vol_info_option(tmp->writer, tmp->key, k, v->data);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_output_vol_info_options (xmlTextWriterPtr writer, dict_t *dict,
-                                 char *prefix)
+cli_xml_output_vol_info_options(xmlTextWriterPtr writer, dict_t *dict,
+                                char *prefix)
 {
-        int             ret = -1;
-        int             opt_count = 0;
-        char            key[1024] = {0,};
-        struct tmp_xml_option_logger tmp = {0,};
-
-        snprintf (key, sizeof (key), "%s.opt_count", prefix);
-        ret = dict_get_int32 (dict, key, &opt_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"optCount",
-                                               "%d", opt_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <options> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"options");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        snprintf (key, sizeof (key), "%s.option.", prefix);
-
-        tmp.key = key;
-        tmp.writer = writer;
-        ret = dict_foreach (dict, _output_vol_info_option, &tmp);
-        if (ret)
-                goto out;
-
-        /* </options> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int opt_count = 0;
+    char key[1024] = {
+        0,
+    };
+    struct tmp_xml_option_logger tmp = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "%s.opt_count", prefix);
+    ret = dict_get_int32(dict, key, &opt_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"optCount", "%d",
+                                          opt_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <options> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"options");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    snprintf(key, sizeof(key), "%s.option.", prefix);
+
+    tmp.key = key;
+    tmp.writer = writer;
+    ret = dict_foreach(dict, _output_vol_info_option, &tmp);
+    if (ret)
+        goto out;
+
+    /* </options> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_info (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_info(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = 0;
-        int                     count = 0;
-        char                    *volname = NULL;
-        char                    *volume_id = NULL;
-        char                    *uuid = NULL;
-        int                     type = 0;
-        int                     status = 0;
-        int                     brick_count = 0;
-        int                     dist_count = 0;
-        int                     stripe_count = 0;
-        int                     replica_count = 0;
-        int                     arbiter_count = 0;
-        int                     snap_count    = 0;
-        int                     isArbiter = 0;
-        int                     disperse_count = 0;
-        int                     redundancy_count = 0;
-        int                     transport = 0;
-        char                    *brick = NULL;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     j = 1;
-        char                    *caps __attribute__((unused)) = NULL;
-        int                     k __attribute__((unused)) = 0;
-        int                     index = 1;
-        int                     tier_vol_type          = 0;
-        /* hot dist count is always zero so need for it to be
-         * included in the array.*/
-        int                     hot_dist_count         = 0;
-        values                  c                      = 0;
-        char                    *keys[MAX]              = {
-                [COLD_BRICK_COUNT]      = "volume%d.cold_brick_count",
-                [COLD_TYPE]             = "volume%d.cold_type",
-                [COLD_DIST_COUNT]       = "volume%d.cold_dist_count",
-                [COLD_REPLICA_COUNT]    = "volume%d.cold_replica_count",
-                [COLD_ARBITER_COUNT]    = "volume%d.cold_arbiter_count",
-                [COLD_DISPERSE_COUNT]   = "volume%d.cold_disperse_count",
-                [COLD_REDUNDANCY_COUNT] = "volume%d.cold_redundancy_count",
-                [HOT_BRICK_COUNT]       = "volume%d.hot_brick_count",
-                [HOT_TYPE]              = "volume%d.hot_type",
-                [HOT_REPLICA_COUNT]     = "volume%d.hot_replica_count"};
-        int                     value[MAX]             = {};
-
-
-        ret = dict_get_int32 (dict, "count", &count);
+    int ret = 0;
+    int count = 0;
+    char *volname = NULL;
+    char *volume_id = NULL;
+    char *uuid = NULL;
+    int type = 0;
+    int status = 0;
+    int brick_count = 0;
+    int dist_count = 0;
+    int stripe_count = 0;
+    int replica_count = 0;
+    int arbiter_count = 0;
+    int snap_count = 0;
+    int isArbiter = 0;
+    int disperse_count = 0;
+    int redundancy_count = 0;
+    int transport = 0;
+    char *brick = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 1;
+    char *caps __attribute__((unused)) = NULL;
+    int k __attribute__((unused)) = 0;
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < count; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.name", i);
+        ret = dict_get_str(dict, key, &volname);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"name",
+                                              "%s", volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.volume_id", i);
+        ret = dict_get_str(dict, key, &volume_id);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"id",
+                                              "%s", volume_id);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"status", "%d", status);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"statusStr", "%s",
+                                              cli_vol_status_str[status]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.snap_count", i);
+        ret = dict_get_int32(dict, key, &snap_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"snapshotCount", "%d", snap_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.brick_count", i);
+        ret = dict_get_int32(dict, key, &brick_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"brickCount", "%d", brick_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.dist_count", i);
+        ret = dict_get_int32(dict, key, &dist_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"distCount", "%d",
+                                              (brick_count / dist_count));
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.stripe_count", i);
+        ret = dict_get_int32(dict, key, &stripe_count);
         if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"stripeCount", "%d", stripe_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.replica_count", i);
+        ret = dict_get_int32(dict, key, &replica_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"replicaCount", "%d", replica_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.arbiter_count", i);
+        ret = dict_get_int32(dict, key, &arbiter_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"arbiterCount", "%d", arbiter_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.disperse_count", i);
+        ret = dict_get_int32(dict, key, &disperse_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"disperseCount", "%d", disperse_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.redundancy_count", i);
+        ret = dict_get_int32(dict, key, &redundancy_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"redundancyCount",
+                                              "%d", redundancy_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.type", i);
+        ret = dict_get_int32(dict, key, &type);
+        if (ret)
+            goto out;
+        /* For Distributed-(stripe,replicate,stipe-replicate,disperse)
+           types
+         */
+        type = get_vol_type(type, dist_count, brick_count);
+
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%d", type);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"typeStr", "%s", vol_type_str[type]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.transport", i);
+        ret = dict_get_int32(dict, key, &transport);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"transport", "%d", transport);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        j = 1;
+
+        /* <bricks> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"bricks");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        while (j <= brick_count) {
+            ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"brick");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            snprintf(key, sizeof(key), "volume%d.brick%d.uuid", i, j);
+            ret = dict_get_str(dict, key, &uuid);
+            if (ret)
                 goto out;
+            ret = xmlTextWriterWriteFormatAttribute(
+                local->writer, (xmlChar *)"uuid", "%s", uuid);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < count; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            snprintf(key, sizeof(key), "volume%d.brick%d", i, j);
+            ret = dict_get_str(dict, key, &brick);
+            if (ret)
+                goto out;
+            ret = xmlTextWriterWriteFormatString(local->writer, "%s", brick);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.name", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.volume_id", i);
-                ret = dict_get_str (dict, key, &volume_id);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", volume_id);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret =xmlTextWriterWriteFormatElement
-                        (local->writer, (xmlChar *)"statusStr", "%s",
-                         cli_vol_status_str[status]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.snap_count", i);
-                ret = dict_get_int32 (dict, key, &snap_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                     (xmlChar *)"snapshotCount",
-                                                     "%d", snap_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"name", "%s", brick);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"hostUuid", "%s", uuid);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.brick_count", i);
-                ret = dict_get_int32 (dict, key, &brick_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"brickCount",
-                                                       "%d", brick_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.dist_count", i);
-                ret = dict_get_int32 (dict, key, &dist_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"distCount",
-                                                       "%d", dist_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.stripe_count", i);
-                ret = dict_get_int32 (dict, key, &stripe_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"stripeCount",
-                                                       "%d", stripe_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.replica_count", i);
-                ret = dict_get_int32 (dict, key, &replica_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"replicaCount",
-                                                       "%d", replica_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.arbiter_count", i);
-                ret = dict_get_int32 (dict, key, &arbiter_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                      (xmlChar *)"arbiterCount",
-                                                      "%d", arbiter_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.disperse_count", i);
-                ret = dict_get_int32 (dict, key, &disperse_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"disperseCount",
-                                                       "%d", disperse_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.redundancy_count", i);
-                ret = dict_get_int32 (dict, key, &redundancy_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"redundancyCount",
-                                                       "%d", redundancy_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.type", i);
-                ret = dict_get_int32 (dict, key, &type);
-                if (ret)
-                        goto out;
-                /* For Distributed-(stripe,replicate,stipe-replicate,disperse)
-                   types
-                 */
-                type = get_vol_type (type, dist_count, brick_count);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"type",
-                                                       "%d", type);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"typeStr",
-                                                       "%s",
-                                                       vol_type_str[type]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d.transport", i);
-                ret = dict_get_int32 (dict, key, &transport);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"transport",
-                                                       "%d", transport);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-#ifdef HAVE_BD_XLATOR
-                /* <xlators> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"xlators");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (k = 0; ; k++) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key),"volume%d.xlator%d", i, k);
-                        ret = dict_get_str (dict, key, &caps);
-                        if (ret)
-                                break;
-
-                        /* <xlator> */
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)"xlator");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"name", "%s", caps);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        /* <capabilities> */
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "capabilities");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        j = 0;
-                        for (j = 0; ;j++) {
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.xlator%d.caps%d", i, k, j);
-                                ret = dict_get_str (dict, key, &caps);
-                                if (ret)
-                                        break;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"capability",
-                                         "%s", caps);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-                        /* </capabilities> */
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        /* </xlator> */
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
-                ret = xmlTextWriterFullEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                /* </xlators> */
-#endif
-                j = 1;
-
-                /* <bricks> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"bricks");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                if (type == GF_CLUSTER_TYPE_TIER) {
-                        /*the values for hot stripe, disperse and redundancy
-                         * should not be looped in here as they are zero
-                         * always */
-                        for (c = COLD_BRICK_COUNT; c < MAX; c++) {
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, 256, keys[c], i);
-                                ret = dict_get_int32 (dict, key, &value[c]);
-                                if (ret)
-                                        goto out;
-                        }
-
-                        hot_dist_count = (value[HOT_REPLICA_COUNT] ?
-                                          value[HOT_REPLICA_COUNT] : 1);
-
-                        tier_vol_type = get_vol_type (value[HOT_TYPE],
-                                                      hot_dist_count,
-                                                      value[HOT_BRICK_COUNT]);
-
-                        if ((value[HOT_TYPE] != GF_CLUSTER_TYPE_TIER) &&
-                            (value[HOT_TYPE] > 0) &&
-                            (hot_dist_count < value[HOT_BRICK_COUNT]))
-                                tier_vol_type = value[HOT_TYPE] +
-                                        GF_CLUSTER_TYPE_MAX - 1;
-
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "hotBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"hotBrickType",
-                                 "%s", vol_type_str[tier_vol_type]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"hotreplicaCount",
-                                                    "%d",
-                                                    value[HOT_REPLICA_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"hotbrickCount",
-                                                    "%d",
-                                                    value[HOT_BRICK_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        if (value[HOT_TYPE] == GF_CLUSTER_TYPE_NONE ||
-                                        value[HOT_TYPE] ==
-                                        GF_CLUSTER_TYPE_TIER) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d", value[HOT_BRICK_COUNT]);
-                        } else {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d x %d = %d",
-                                         (value[HOT_BRICK_COUNT] /
-                                          hot_dist_count),
-                                         hot_dist_count,
-                                         value[HOT_BRICK_COUNT]);
-                        }
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        while (index <= value[HOT_BRICK_COUNT]) {
-                                snprintf (key, 1024, "volume%d.brick%d", i,
-                                          index);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, j);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                index++;
-                        }
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        tier_vol_type = get_vol_type (value[COLD_TYPE],
-                                                      value[COLD_DIST_COUNT],
-                                                      value[COLD_BRICK_COUNT]);
-
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "coldBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"coldBrickType",
-                                 "%s", vol_type_str[tier_vol_type]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                        (xmlChar *)"coldreplicaCount",
-                                        "%d", value[COLD_REPLICA_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                        (xmlChar *)"coldarbiterCount",
-                                        "%d", value[COLD_ARBITER_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"coldbrickCount",
-                                                    "%d",
-                                                    value[COLD_BRICK_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"colddisperseCount",
-                                              "%d", value[COLD_DISPERSE_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        if (value[COLD_TYPE] == GF_CLUSTER_TYPE_NONE ||
-                                        value[COLD_TYPE] ==
-                                        GF_CLUSTER_TYPE_TIER) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d", value[COLD_BRICK_COUNT]);
-                        } else if (value[COLD_TYPE] ==
-                                        GF_CLUSTER_TYPE_DISPERSE) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         " %d x (%d + %d) = %d",
-                                         (value[COLD_BRICK_COUNT] /
-                                          value[COLD_DIST_COUNT]),
-                                         value[COLD_DISPERSE_COUNT] -
-                                         value[COLD_REDUNDANCY_COUNT],
-                                         value[COLD_REDUNDANCY_COUNT],
-                                         value[COLD_BRICK_COUNT]);
-                        } else {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d x %d = %d",
-                                         (value[COLD_BRICK_COUNT] /
-                                          value[COLD_DIST_COUNT]),
-                                         value[COLD_DIST_COUNT],
-                                         value[COLD_BRICK_COUNT]);
-                        }
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        index = value[HOT_BRICK_COUNT] + 1;
-
-                        while (index <= brick_count) {
-                                snprintf (key, 1024, "volume%d.brick%d", i,
-                                          index);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, j);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.isArbiter", i,
-                                          index);
-                                if (dict_get (dict, key))
-                                        isArbiter = 1;
-                                else
-                                        isArbiter = 0;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"isArbiter",
-                                         "%d", isArbiter);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                index++;
-                        }
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                } else {
-                        while (j <= brick_count) {
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, j);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d", i, j);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.isArbiter", i, j);
-                                if (dict_get (dict, key))
-                                        isArbiter = 1;
-                                else
-                                        isArbiter = 0;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"isArbiter",
-                                         "%d", isArbiter);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                /* </brick> */
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                j++;
-                        }
-                }
-                /* </bricks> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "volume%d", i);
-                ret = cli_xml_output_vol_info_options (local->writer, dict,
-                                                       key);
-                if (ret)
-                        goto out;
+            snprintf(key, sizeof(key), "volume%d.brick%d.isArbiter", i, j);
+            if (dict_get(dict, key))
+                isArbiter = 1;
+            else
+                isArbiter = 0;
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"isArbiter", "%d", isArbiter);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+            /* </brick> */
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (volname) {
-                GF_FREE (local->get_vol.volname);
-                local->get_vol.volname = gf_strdup (volname);
-                local->vol_count += count;
+            j++;
         }
+        /* </bricks> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d", i);
+        ret = cli_xml_output_vol_info_options(local->writer, dict, key);
+        if (ret)
+            goto out;
+
+        /* </volume> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    if (volname) {
+        GF_FREE(local->get_vol.volname);
+        local->get_vol.volname = gf_strdup(volname);
+        local->vol_count += count;
+    }
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_info_begin (cli_local_t *local, int op_ret, int op_errno,
-                               char *op_errstr)
+cli_xml_output_vol_info_begin(cli_local_t *local, int op_ret, int op_errno,
+                              char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        /* <volInfo> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volInfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volInfo> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volInfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volumes> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volumes> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volumes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Init vol count */
-        local->vol_count = 0;
+    /* Init vol count */
+    local->vol_count = 0;
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_info_end (cli_local_t *local)
+cli_xml_output_vol_info_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int             ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"count",
-                                               "%d", local->vol_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        /* </volumes> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"count",
+                                          "%d", local->vol_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </volumes> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </volInfo> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volInfo> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_quota_limit_list_end (cli_local_t *local)
+cli_xml_output_vol_quota_limit_list_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_quota_limit_list_begin (cli_local_t *local, int op_ret,
-                                           int op_errno, char *op_errstr)
+cli_xml_output_vol_quota_limit_list_begin(cli_local_t *local, int op_ret,
+                                          int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    if (ret)
+        goto out;
 
-        /* <volQuota> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volQuota");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
+    /* <volQuota> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volQuota");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 static int
-cli_xml_output_peer_hostnames (xmlTextWriterPtr writer, dict_t *dict,
-                               const char *prefix, int count)
+cli_xml_output_peer_hostnames(xmlTextWriterPtr writer, dict_t *dict,
+                              const char *prefix, int count)
 {
-        int   ret       = -1;
-        int   i         = 0;
-        char *hostname  = NULL;
-        char  key[1024] = {0,};
-
-        /* <hostnames> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"hostnames");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < count; i++) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.hostname%d", prefix, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hostname", "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                hostname = NULL;
-        }
+    int ret = -1;
+    int i = 0;
+    char *hostname = NULL;
+    char key[1024] = {
+        0,
+    };
+
+    /* <hostnames> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"hostnames");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < count; i++) {
+        ret = snprintf(key, sizeof(key), "%s.hostname%d", prefix, i);
+        if (ret < 0)
+            goto out;
+        ret = dict_get_str(dict, key, &hostname);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        hostname = NULL;
+    }
 
-        /* </hostnames> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </hostnames> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_peer_status (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_peer_status(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     count = 0;
-        char                    *uuid = NULL;
-        char                    *hostname = NULL;
-        int                     connected = 0;
-        int                     state_id = 0;
-        char                    *state_str = NULL;
-        int                     hostname_count = 0;
-        int                     i = 1;
-        char                    key[1024] = {0,};
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int count = 0;
+    char *uuid = NULL;
+    char *hostname = NULL;
+    int connected = 0;
+    int state_id = 0;
+    char *state_str = NULL;
+    int hostname_count = 0;
+    int i = 1;
+    char key[1024] = {
+        0,
+    };
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <peerStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"peerStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    if (!dict)
+        goto cont;
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+
+    while (i <= count) {
+        /* <peer> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"peer");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+        snprintf(key, sizeof(key), "friend%d.uuid", i);
+        ret = dict_get_str(dict, key, &uuid);
         if (ret)
-                goto out;
-
-        /* <peerStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"peerStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
 
-        if (!dict)
-                goto cont;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                              uuid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &count);
+        snprintf(key, sizeof(key), "friend%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-
-        while (i <= count) {
-                /* <peer> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"peer");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid);
-                if (ret)
-                        goto out;
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"uuid",
-                                                       "%s", uuid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hostname",
-                                                       "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.hostname_count", i);
-                ret = dict_get_int32 (dict, key, &hostname_count);
-                if ((ret == 0) && (hostname_count > 0)) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "friend%d", i);
-                        ret = cli_xml_output_peer_hostnames (writer, dict, key,
-                                                             hostname_count);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+        snprintf(key, sizeof(key), "friend%d.hostname_count", i);
+        ret = dict_get_int32(dict, key, &hostname_count);
+        if ((ret == 0) && (hostname_count > 0)) {
+            snprintf(key, sizeof(key), "friend%d", i);
+            ret = cli_xml_output_peer_hostnames(writer, dict, key,
+                                                hostname_count);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "friend%d.connected", i);
+        ret = dict_get_int32(dict, key, &connected);
+        if (ret)
+            goto out;
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"connected",
-                                                       "%d", connected);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connected",
+                                              "%d", connected);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.stateId", i);
-                ret = dict_get_int32 (dict, key, &state_id);
-                if (!ret) {
-                        /* ignore */
+        snprintf(key, sizeof(key), "friend%d.stateId", i);
+        ret = dict_get_int32(dict, key, &state_id);
+        if (!ret) {
+            /* ignore */
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                           (xmlChar *)"state", "%d", state_id);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"state",
+                                                  "%d", state_id);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "friend%d.state", i);
-                ret = dict_get_str (dict, key, &state_str);
-                if (!ret) {
-                        /* ignore */
+        snprintf(key, sizeof(key), "friend%d.state", i);
+        ret = dict_get_str(dict, key, &state_str);
+        if (!ret) {
+            /* ignore */
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                       (xmlChar *)"stateStr", "%s", state_str);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"stateStr",
+                                                  "%s", state_str);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                /* </peer> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </peer> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                i++;
-        }
+        i++;
+    }
 
 cont:
-        /* </peerStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </peerStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 /* Used for rebalance stop/status, remove-brick status */
 int
-cli_xml_output_vol_rebalance_status (xmlTextWriterPtr writer, dict_t *dict,
-                                     enum gf_task_types task_type)
+cli_xml_output_vol_rebalance_status(xmlTextWriterPtr writer, dict_t *dict,
+                                    enum gf_task_types task_type)
 {
-        int                     ret = -1;
-        int                     count = 0;
-        char                    *node_name = NULL;
-        char                    *node_uuid = NULL;
-        uint64_t                files = 0;
-        uint64_t                size = 0;
-        uint64_t                lookups = 0;
-        int                     status_rcd = 0;
-        uint64_t                failures = 0;
-        uint64_t                skipped = 0;
-        uint64_t                total_files = 0;
-        uint64_t                total_size = 0;
-        uint64_t                total_lookups = 0;
-        uint64_t                total_failures = 0;
-        uint64_t                total_skipped = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     overall_status = -1;
-        double                  elapsed = 0;
-        double                  overall_elapsed = 0;
-
-        if (!dict) {
-                ret = 0;
-                goto out;
-        }
+    int ret = -1;
+    int count = 0;
+    char *node_name = NULL;
+    char *node_uuid = NULL;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookups = 0;
+    int status_rcd = 0;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    uint64_t total_files = 0;
+    uint64_t total_size = 0;
+    uint64_t total_lookups = 0;
+    uint64_t total_failures = 0;
+    uint64_t total_skipped = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int overall_status = -1;
+    double elapsed = 0;
+    double overall_elapsed = 0;
+
+    if (!dict) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeCount", "%d",
+                                          count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    while (i < count) {
+        i++;
+        /* Getting status early, to skip nodes that don't have the
+         * rebalance process started
+         */
+        snprintf(key, sizeof(key), "status-%d", i);
+        ret = dict_get_int32(dict, key, &status_rcd);
 
-        ret = dict_get_int32 (dict, "count", &count);
+        /* If glusterd is down it fails to get the status, try
+         getting status from other nodes */
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        while (i < count) {
-                i++;
-                /* Getting status early, to skip nodes that don't have the
-                 * rebalance process started
-                 */
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "status-%d", i);
-                ret = dict_get_int32 (dict, key, &status_rcd);
-
-                /* If glusterd is down it fails to get the status, try
-                 getting status from other nodes */
-                if (ret)
-                    continue;
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
-
-                /* <node> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"nodeName",
-                                                       "%s", node_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "node-uuid-%d", i);
-                ret = dict_get_str (dict, key, &node_uuid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", node_uuid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "files-%d", i);
-                ret = dict_get_uint64 (dict, key, &files);
-                if (ret)
-                        goto out;
-                total_files += files;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"files",
-                                                       "%"PRIu64, files);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "size-%d", i);
-                ret = dict_get_uint64 (dict, key, &size);
-                if (ret)
-                        goto out;
-                total_size += size;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"size",
-                                                       "%"PRIu64,size);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "lookups-%d", i);
-                ret = dict_get_uint64 (dict, key, &lookups);
-                if (ret)
-                        goto out;
-                total_lookups += lookups;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"lookups",
-                                                       "%"PRIu64, lookups);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "failures-%d", i);
-                ret = dict_get_uint64 (dict, key, &failures);
-                if (ret)
-                        goto out;
+            continue;
+        if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
+            continue;
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "skipped-%d", i);
-
-                ret = dict_get_uint64 (dict, key, &skipped);
-                if (ret)
-                        goto out;
+        /* <node> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"node");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                if (task_type == GF_TASK_TYPE_REMOVE_BRICK) {
-                        failures += skipped;
-                        skipped = 0;
-                }
+        snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeName",
+                                              "%s", node_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                total_failures += failures;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"failures",
-                                               "%"PRIu64, failures);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                total_skipped += skipped;
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"skipped",
-                                               "%"PRIu64, skipped);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status_rcd);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s",
-                                         cli_vol_task_status_str[status_rcd]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, 256);
-                snprintf (key, 256, "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"runtime",
-                                                       "%.2f", elapsed);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "node-uuid-%d", i);
+        ret = dict_get_str(dict, key, &node_uuid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              node_uuid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                if (elapsed > overall_elapsed) {
-                    overall_elapsed = elapsed;
-                }
+        snprintf(key, sizeof(key), "files-%d", i);
+        ret = dict_get_uint64(dict, key, &files);
+        if (ret)
+            goto out;
+        total_files += files;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"files",
+                                              "%" PRIu64, files);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* Rebalance has 5 states,
-                 * NOT_STARTED, STARTED, STOPPED, COMPLETE, FAILED
-                 * The precedence used to determine the aggregate status is as
-                 * below,
-                 * STARTED > FAILED > STOPPED > COMPLETE > NOT_STARTED
-                 */
-                /* TODO: Move this to a common place utilities that both CLI and
-                 * glusterd need.
-                 * Till then if the below algorithm is changed, change it in
-                 * glusterd_volume_status_aggregate_tasks_status in
-                 * glusterd-utils.c
-                 */
-
-                if (-1 == overall_status)
-                        overall_status = status_rcd;
-                int rank[] = {
-                        [GF_DEFRAG_STATUS_STARTED] = 1,
-                        [GF_DEFRAG_STATUS_FAILED] = 2,
-                        [GF_DEFRAG_STATUS_STOPPED] = 3,
-                        [GF_DEFRAG_STATUS_COMPLETE] = 4,
-                        [GF_DEFRAG_STATUS_NOT_STARTED] = 5
-                };
-                if (rank[status_rcd] <= rank[overall_status])
-                        overall_status = status_rcd;
-
-                /* </node> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        snprintf(key, sizeof(key), "size-%d", i);
+        ret = dict_get_uint64(dict, key, &size);
+        if (ret)
+            goto out;
+        total_size += size;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size",
+                                              "%" PRIu64, size);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Aggregate status */
-        /* <aggregate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"aggregate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "lookups-%d", i);
+        ret = dict_get_uint64(dict, key, &lookups);
+        if (ret)
+            goto out;
+        total_lookups += lookups;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lookups",
+                                              "%" PRIu64, lookups);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"files",
-                                               "%"PRIu64, total_files);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "failures-%d", i);
+        ret = dict_get_uint64(dict, key, &failures);
+        if (ret)
+            goto out;
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"size",
-                                               "%"PRIu64, total_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "skipped-%d", i);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"lookups",
-                                               "%"PRIu64, total_lookups);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_uint64(dict, key, &skipped);
+        if (ret)
+            goto out;
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"failures",
-                                               "%"PRIu64, total_failures);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        if (task_type == GF_TASK_TYPE_REMOVE_BRICK) {
+            failures += skipped;
+            skipped = 0;
+        }
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"skipped",
-                                               "%"PRIu64, total_skipped);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        total_failures += failures;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"failures",
+                                              "%" PRIu64, failures);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"status",
-                                               "%d", overall_status);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        total_skipped += skipped;
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"statusStr",
-                                               "%s",
-                                      cli_vol_task_status_str[overall_status]);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"skipped",
+                                              "%" PRIu64, skipped);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"runtime",
-                                               "%.2f", overall_elapsed);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                              status_rcd);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </aggregate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"statusStr", "%s",
+            cli_vol_task_status_str[status_rcd]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
+        snprintf(key, sizeof(key), "run-time-%d", i);
+        ret = dict_get_double(dict, key, &elapsed);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"runtime",
+                                              "%.2f", elapsed);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-int
-cli_xml_output_vol_tier_status (xmlTextWriterPtr writer, dict_t *dict,
-                enum gf_task_types task_type)
-{
-        int                     ret = -1;
-        int                     count = 0;
-        char                    *node_name = NULL;
-        char                    *status_str  = NULL;
-        uint64_t                promoted     = 0;
-        uint64_t                demoted      = 0;
-        int                     i = 1;
-        char                    key[1024] = {0,};
-        gf_defrag_status_t      status_rcd   = GF_DEFRAG_STATUS_NOT_STARTED;
+        if (elapsed > overall_elapsed) {
+            overall_elapsed = elapsed;
+        }
 
+        /* Rebalance has 5 states,
+         * NOT_STARTED, STARTED, STOPPED, COMPLETE, FAILED
+         * The precedence used to determine the aggregate status is as
+         * below,
+         * STARTED > FAILED > STOPPED > COMPLETE > NOT_STARTED
+         */
+        /* TODO: Move this to a common place utilities that both CLI and
+         * glusterd need.
+         * Till then if the below algorithm is changed, change it in
+         * glusterd_volume_status_aggregate_tasks_status in
+         * glusterd-utils.c
+         */
 
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
+        if (-1 == overall_status)
+            overall_status = status_rcd;
+        int rank[] = {[GF_DEFRAG_STATUS_STARTED] = 1,
+                      [GF_DEFRAG_STATUS_FAILED] = 2,
+                      [GF_DEFRAG_STATUS_STOPPED] = 3,
+                      [GF_DEFRAG_STATUS_COMPLETE] = 4,
+                      [GF_DEFRAG_STATUS_NOT_STARTED] = 5};
+        if (rank[status_rcd] <= rank[overall_status])
+            overall_status = status_rcd;
+
+        /* </node> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
-        }
+    /* Aggregate status */
+    /* <aggregate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"aggregate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"files",
+                                          "%" PRIu64, total_files);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        while (i <= count) {
-                promoted = 0;
-                node_name = NULL;
-                demoted = 0;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size", "%" PRIu64,
+                                          total_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lookups",
+                                          "%" PRIu64, total_lookups);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"nodeName",
-                                                       "%s", node_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "promoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &promoted);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"promoted"
-                                                       "Files", "%"PRIu64,
-                                                       promoted);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "demoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &demoted);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"demoted"
-                                                       "Files", "%"PRIu64,
-                                                       demoted);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"failures",
+                                          "%" PRIu64, total_failures);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                memset (key, 0, 256);
-                snprintf (key, 256, "status-%d", i);
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"skipped",
+                                          "%" PRIu64, total_skipped);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                status_str = cli_vol_task_status_str[status_rcd];
+    if (overall_status == -1) {
+        overall_status = status_rcd;
+    }
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s", status_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                          overall_status);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterWriteFormatElement(
+        writer, (xmlChar *)"statusStr", "%s",
+        cli_vol_task_status_str[overall_status]);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"runtime", "%.2f",
+                                          overall_elapsed);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                i++;
-        }
+    /* </aggregate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_rebalance (gf_cli_defrag_type op, dict_t *dict, int op_ret,
-                              int op_errno, char *op_errstr)
+cli_xml_output_vol_rebalance(gf_cli_defrag_type op, dict_t *dict, int op_ret,
+                             int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *task_id_str = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *task_id_str = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volRebalance> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volRebalance");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, GF_REBALANCE_TID_KEY, &task_id_str);
+    if (ret == 0) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"task-id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"op", "%d", op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    if ((GF_DEFRAG_CMD_STOP == op) || (GF_DEFRAG_CMD_STATUS == op)) {
+        ret = cli_xml_output_vol_rebalance_status(writer, dict,
+                                                  GF_TASK_TYPE_REBALANCE);
         if (ret)
-                goto out;
-
-        /* <volRebalance> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volRebalance");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);
-        if (ret == 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"task-id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"op",
-                                               "%d", op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (GF_DEFRAG_CMD_STATUS_TIER == op) {
-                ret = cli_xml_output_vol_tier_status (writer,
-                                dict, GF_TASK_TYPE_REBALANCE);
-                if (ret)
-                        goto out;
-                }
-        if ((GF_DEFRAG_CMD_STOP == op) || (GF_DEFRAG_CMD_STATUS == op)) {
-
-                ret = cli_xml_output_vol_rebalance_status (writer, dict,
-                                                      GF_TASK_TYPE_REBALANCE);
-                if (ret)
-                        goto out;
-        }
-
-        /* </volRebalance> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+    }
 
+    /* </volRebalance> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_remove_brick_detach_tier (gf_boolean_t status_op,
-                                             dict_t *dict, int op_ret,
-                                             int op_errno, char *op_errstr,
-                                             const char *op)
+cli_xml_output_vol_remove_brick(gf_boolean_t status_op, dict_t *dict,
+                                int op_ret, int op_errno, char *op_errstr,
+                                const char *op)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *task_id_str = NULL;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *task_id_str = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
+    if (ret == 0) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"task-id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    if (status_op) {
+        ret = cli_xml_output_vol_rebalance_status(writer, dict,
+                                                  GF_TASK_TYPE_REMOVE_BRICK);
         if (ret)
-                goto out;
-
-        ret = xmlTextWriterStartElement (writer, (xmlChar *) op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+    }
 
-        ret = dict_get_str (dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
-        if (ret == 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"task-id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        if (status_op) {
-                ret = cli_xml_output_vol_rebalance_status (writer, dict,
-                                                   GF_TASK_TYPE_REMOVE_BRICK);
-                if (ret)
-                        goto out;
-        }
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_replace_brick (dict_t *dict,
-                                  int op_ret, int op_errno, char *op_errstr)
+cli_xml_output_vol_replace_brick(dict_t *dict, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_create (dict_t *dict, int op_ret, int op_errno,
-                           char *op_errstr)
+cli_xml_output_vol_create(dict_t *dict, int op_ret, int op_errno,
+                          char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        char                    *volid = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    char *volid = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    if (dict) {
+        /* <volCreate> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volCreate");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+        ret = dict_get_str(dict, "volname", &volname);
         if (ret)
-                goto out;
-
-        if (dict) {
-                /* <volCreate> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"volCreate");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "volume-id", &volid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
-                                                       "%s", volid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "volume-id", &volid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              volid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volCreate> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </volCreate> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_generic_volume (char *op, dict_t *dict, int op_ret, int op_errno,
-                               char *op_errstr)
+cli_xml_output_generic_volume(char *op, dict_t *dict, int op_ret, int op_errno,
+                              char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        char                    *volid = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    char *volid = NULL;
 
-        GF_ASSERT (op);
+    GF_ASSERT(op);
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        if (dict) {
-                /* <"op"> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    if (dict) {
+        /* <"op"> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "volname", &volname);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "vol-id", &volid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
-                                                       "%s", volid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "vol-id", &volid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              volid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </"op"> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </"op"> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-_output_gsync_config (FILE *fp, xmlTextWriterPtr writer, char *op_name)
+_output_gsync_config(FILE *fp, xmlTextWriterPtr writer, char *op_name)
 {
-        char  resbuf[256 + PATH_MAX] = {0,};
-        char *ptr                    = NULL;
-        char *v                      = NULL;
-        int   blen                   = sizeof(resbuf);
-        int   ret                    = 0;
-
-        for (;;) {
-                ptr = fgets (resbuf, blen, fp);
-                if (!ptr)
-                        break;
-
-                v = resbuf + strlen (resbuf) - 1;
-                while (isspace (*v)) {
-                        /* strip trailing space */
-                        *v-- = '\0';
-                }
-                if (v == resbuf) {
-                        /* skip empty line */
-                        continue;
-                }
+    char resbuf[256 + PATH_MAX] = {
+        0,
+    };
+    char *ptr = NULL;
+    char *v = NULL;
+    int blen = sizeof(resbuf);
+    int ret = 0;
+
+    for (;;) {
+        ptr = fgets(resbuf, blen, fp);
+        if (!ptr)
+            break;
 
-                if (op_name!= NULL){
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)op_name,
-                                                        "%s", resbuf);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        goto out;
-                }
+        v = resbuf + strlen(resbuf) - 1;
+        while (isspace(*v)) {
+            /* strip trailing space */
+            *v-- = '\0';
+        }
+        if (v == resbuf) {
+            /* skip empty line */
+            continue;
+        }
 
-                v = strchr (resbuf, ':');
-                if (!v) {
-                        ret = -1;
-                        goto out;
-                }
-                *v++ = '\0';
-                while (isspace (*v))
-                        v++;
-                v = gf_strdup (v);
-                if (!v) {
-                        ret = -1;
-                        goto out;
-                }
+        if (op_name != NULL) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)op_name,
+                                                  "%s", resbuf);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            goto out;
+        }
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)resbuf,
-                                                       "%s", v);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        v = strchr(resbuf, ':');
+        if (!v) {
+            ret = -1;
+            goto out;
         }
+        *v++ = '\0';
+        while (isspace(*v))
+            v++;
+        v = gf_strdup(v);
+        if (!v) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)resbuf, "%s",
+                                              v);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-get_gsync_config (runner_t *runner,
-                  int (*op_conf)(FILE *fp,
-                              xmlTextWriterPtr writer,
-                              char *op_name),
-                  xmlTextWriterPtr writer, char *op_name)
+get_gsync_config(runner_t *runner,
+                 int (*op_conf)(FILE *fp, xmlTextWriterPtr writer,
+                                char *op_name),
+                 xmlTextWriterPtr writer, char *op_name)
 {
-        int ret = 0;
+    int ret = 0;
 
-        runner_redir (runner, STDOUT_FILENO, RUN_PIPE);
-        if (runner_start (runner) != 0) {
-                gf_log ("cli", GF_LOG_ERROR, "spawning child failed");
-                return -1;
-        }
+    runner_redir(runner, STDOUT_FILENO, RUN_PIPE);
+    if (runner_start(runner) != 0) {
+        gf_log("cli", GF_LOG_ERROR, "spawning child failed");
+        return -1;
+    }
 
-        ret = op_conf (runner_chio (runner, STDOUT_FILENO), writer, op_name);
+    ret = op_conf(runner_chio(runner, STDOUT_FILENO), writer, op_name);
 
-        ret |= runner_end (runner);
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "reading data from child failed");
+    ret |= runner_end(runner);
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "reading data from child failed");
 
-        return ret ? -1 : 0;
+    return ret ? -1 : 0;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_generate_gsync_config (dict_t *dict, xmlTextWriterPtr writer)
+cli_xml_generate_gsync_config(dict_t *dict, xmlTextWriterPtr writer)
 {
-        runner_t runner           = {0,};
-        char *subop               = NULL;
-        char *gwd                 = NULL;
-        char *slave               = NULL;
-        char *confpath            = NULL;
-        char *master              = NULL;
-        char *op_name             = NULL;
-        int   ret                 = -1;
-        char  conf_path[PATH_MAX] = "";
-
-        if (dict_get_str (dict, "subop", &subop) != 0) {
-                ret = -1;
-                goto out;
-        }
-
-        if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                 (xmlChar *)"message",
-                                 "%s",GEOREP" config updated successfully" );
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                ret = 0;
-                goto out;
-        }
+    runner_t runner = {
+        0,
+    };
+    char *subop = NULL;
+    char *gwd = NULL;
+    char *slave = NULL;
+    char *confpath = NULL;
+    char *master = NULL;
+    char *op_name = NULL;
+    int ret = -1;
+    char conf_path[PATH_MAX] = "";
+
+    if (dict_get_str(dict, "subop", &subop) != 0) {
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(subop, "get") != 0 && strcmp(subop, "get-all") != 0) {
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"message", "%s",
+            GEOREP " config updated successfully");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        ret = 0;
+        goto out;
+    }
 
-        if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
-            dict_get_str (dict, "slave", &slave) != 0) {
-                ret = -1;
-                goto out;
-        }
+    if (dict_get_str(dict, "glusterd_workdir", &gwd) != 0 ||
+        dict_get_str(dict, "slave", &slave) != 0) {
+        ret = -1;
+        goto out;
+    }
 
-        if (dict_get_str (dict, "master", &master) != 0)
-                master = NULL;
+    if (dict_get_str(dict, "master", &master) != 0)
+        master = NULL;
 
-        if (dict_get_str (dict, "op_name", &op_name) != 0)
-                op_name = NULL;
+    if (dict_get_str(dict, "op_name", &op_name) != 0)
+        op_name = NULL;
 
-        ret = dict_get_str (dict, "conf_path", &confpath);
-        if (!confpath) {
-                ret = snprintf (conf_path, sizeof (conf_path) - 1,
-                                "%s/"GEOREP"/gsyncd_template.conf", gwd);
-                conf_path[ret] = '\0';
-                confpath = conf_path;
-        }
+    ret = dict_get_str(dict, "conf_path", &confpath);
+    if (!confpath) {
+        ret = snprintf(conf_path, sizeof(conf_path) - 1,
+                       "%s/" GEOREP "/gsyncd_template.conf", gwd);
+        conf_path[ret] = '\0';
+        confpath = conf_path;
+    }
 
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "-c", NULL);
-        runner_argprintf (&runner, "%s", confpath);
-        runner_argprintf (&runner, "--iprefix=%s", DATADIR);
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "-c", NULL);
+    runner_argprintf(&runner, "%s", confpath);
+    runner_argprintf(&runner, "--iprefix=%s", DATADIR);
 
-        if (master)
-                runner_argprintf (&runner, ":%s", master);
+    if (master)
+        runner_argprintf(&runner, ":%s", master);
 
-        runner_add_arg (&runner, slave);
-        runner_argprintf (&runner, "--config-%s", subop);
+    runner_add_arg(&runner, slave);
+    runner_argprintf(&runner, "--config-%s", subop);
 
-        if (op_name)
-                runner_add_arg (&runner, op_name);
+    if (op_name)
+        runner_add_arg(&runner, op_name);
 
-        ret =  get_gsync_config (&runner, _output_gsync_config,
-                                 writer, op_name);
+    ret = get_gsync_config(&runner, _output_gsync_config, writer, op_name);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_gsync_status (dict_t *dict,
-                                 xmlTextWriterPtr writer)
+cli_xml_output_vol_gsync_status(dict_t *dict, xmlTextWriterPtr writer)
 {
-        int                  ret                         = -1;
-        int                  i                           = 1;
-        int                  j                           = 0;
-        int                  count                       = 0;
-        const int            number_of_fields            = 20;
-        int                  closed                      = 1;
-        int                  session_closed              = 1;
-        gf_gsync_status_t  **status_values               = NULL;
-        char                 status_value_name[PATH_MAX] = "";
-        char                *tmp                         = NULL;
-        char                *volume                      = NULL;
-        char                *volume_next                 = NULL;
-        char                *slave                       = NULL;
-        char                *slave_next                  = NULL;
-        char                *title_values[]              = {"master_node",
-                                                            "",
-                                                            "master_brick",
-                                                            "slave_user",
-                                                            "slave",
-                                                            "slave_node",
-                                                            "status",
-                                                            "crawl_status",
-                                                            /* last_synced */
-                                                            "",
-                                                            "entry",
-                                                            "data",
-                                                            "meta",
-                                                            "failures",
-                                                           /* checkpoint_time */
-                                                            "",
-                                                         "checkpoint_completed",
-                                               /* checkpoint_completion_time */
-                                                            "",
-                                                            "master_node_uuid",
-                                                           /* last_synced_utc */
-                                                            "last_synced",
-                                                       /* checkpoint_time_utc */
-                                                            "checkpoint_time",
-                                            /* checkpoint_completion_time_utc */
-                                                 "checkpoint_completion_time"};
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_int32 (dict, "gsync-count", &count);
-        if (ret)
-                goto out;
-
-        status_values = GF_CALLOC (count, sizeof (gf_gsync_status_t *),
+    int ret = -1;
+    int i = 1;
+    int j = 0;
+    int count = 0;
+    const int number_of_fields = 20;
+    int closed = 1;
+    int session_closed = 1;
+    gf_gsync_status_t **status_values = NULL;
+    char status_value_name[PATH_MAX] = "";
+    char *tmp = NULL;
+    char *volume = NULL;
+    char *volume_next = NULL;
+    char *slave = NULL;
+    char *slave_next = NULL;
+    static const char *title_values[] = {
+        "master_node", "", "master_brick", "slave_user", "slave", "slave_node",
+        "status", "crawl_status",
+        /* last_synced */
+        "", "entry", "data", "meta", "failures",
+        /* checkpoint_time */
+        "", "checkpoint_completed",
+        /* checkpoint_completion_time */
+        "", "master_node_uuid",
+        /* last_synced_utc */
+        "last_synced",
+        /* checkpoint_time_utc */
+        "checkpoint_time",
+        /* checkpoint_completion_time_utc */
+        "checkpoint_completion_time"};
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_int32(dict, "gsync-count", &count);
+    if (ret)
+        goto out;
+
+    status_values = GF_MALLOC(count * sizeof(gf_gsync_status_t *),
                               gf_common_mt_char);
-        if (!status_values) {
-                ret = -1;
-                goto out;
-        }
+    if (!status_values) {
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0; i < count; i++) {
-                status_values[i] = GF_CALLOC (1, sizeof (gf_gsync_status_t),
-                                         gf_common_mt_char);
-                if (!status_values[i]) {
-                        ret = -1;
-                        goto out;
-                }
+    for (i = 0; i < count; i++) {
+        status_values[i] = GF_CALLOC(1, sizeof(gf_gsync_status_t),
+                                     gf_common_mt_char);
+        if (!status_values[i]) {
+            ret = -1;
+            goto out;
+        }
 
-                snprintf (status_value_name, sizeof (status_value_name),
-                          "status_value%d", i);
+        snprintf(status_value_name, sizeof(status_value_name), "status_value%d",
+                 i);
 
-                ret = dict_get_bin (dict, status_value_name,
-                                    (void **)&(status_values[i]));
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "struct member empty.");
-                        goto out;
-                }
+        ret = dict_get_bin(dict, status_value_name,
+                           (void **)&(status_values[i]));
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+            goto out;
         }
+    }
 
-        qsort(status_values, count, sizeof (gf_gsync_status_t *),
-              gf_gsync_status_t_comparator);
-
-        for (i = 0; i < count; i++) {
-                if (closed) {
-                        ret = xmlTextWriterStartElement (writer,
-                                                         (xmlChar *)"volume");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        tmp = get_struct_variable (1, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)"name",
-                                                        "%s",tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterStartElement (writer,
-                                                    (xmlChar *)"sessions");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        closed = 0;
-                }
+    qsort(status_values, count, sizeof(gf_gsync_status_t *),
+          gf_gsync_status_t_comparator);
 
-                if (session_closed) {
-                        ret = xmlTextWriterStartElement (writer,
-                                                         (xmlChar *)"session");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+    for (i = 0; i < count; i++) {
+        if (closed) {
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        session_closed = 0;
+            tmp = get_struct_variable(1, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                        tmp = get_struct_variable (21, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name",
+                                                  "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"session_slave", "%s", tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"sessions");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"pair");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            closed = 0;
+        }
 
-                for (j = 0; j < number_of_fields; j++) {
-                        /* XML ignore fields */
-                        if (strcmp(title_values[j], "") == 0)
-                                continue;
+        if (session_closed) {
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"session");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        tmp = get_struct_variable (j, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+            session_closed = 0;
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                  (xmlChar *)title_values[j],
-                                                  "%s", tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            tmp = get_struct_variable(21, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"session_slave", "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                if (i+1 < count) {
-                        slave = get_struct_variable (20, status_values[i]);
-                        slave_next = get_struct_variable (20,
-                                                          status_values[i+1]);
-                        volume = get_struct_variable (1, status_values[i]);
-                        volume_next = get_struct_variable (1,
-                                                           status_values[i+1]);
-                        if (!slave || !slave_next || !volume || !volume_next) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"pair");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        if (strcmp (volume, volume_next)!=0) {
-                                closed = 1;
-                                session_closed = 1;
+        for (j = 0; j < number_of_fields; j++) {
+            /* XML ignore fields */
+            if (strcmp(title_values[j], "") == 0)
+                continue;
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
+            tmp = get_struct_variable(j, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
+
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)title_values[j], "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        } else if (strcmp (slave, slave_next)!=0) {
+        if (i + 1 < count) {
+            slave = get_struct_variable(20, status_values[i]);
+            slave_next = get_struct_variable(20, status_values[i + 1]);
+            volume = get_struct_variable(1, status_values[i]);
+            volume_next = get_struct_variable(1, status_values[i + 1]);
+            if (!slave || !slave_next || !volume || !volume_next) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                                session_closed = 1;
+            if (strcmp(volume, volume_next) != 0) {
+                closed = 1;
+                session_closed = 1;
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-                } else {
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            } else if (strcmp(slave, slave_next) != 0) {
+                session_closed = 1;
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            }
+        } else {
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
         }
+    }
 out:
-        gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (status_values)
+        GF_FREE(status_values);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_gsync (dict_t *dict, int op_ret, int op_errno,
-                          char *op_errstr)
+cli_xml_output_vol_gsync(dict_t *dict, int op_ret, int op_errno,
+                         char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *master = NULL;
-        char                    *slave = NULL;
-        int                     type = 0;
-
-        GF_ASSERT (dict);
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <geoRep> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"geoRep");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get type");
-                goto out;
-        }
-
-        switch (type) {
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *master = NULL;
+    char *slave = NULL;
+    int type = 0;
+
+    GF_ASSERT(dict);
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <geoRep> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"geoRep");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get type");
+        goto out;
+    }
+
+    switch (type) {
         case GF_GSYNC_OPTION_TYPE_START:
         case GF_GSYNC_OPTION_TYPE_STOP:
         case GF_GSYNC_OPTION_TYPE_PAUSE:
         case GF_GSYNC_OPTION_TYPE_RESUME:
         case GF_GSYNC_OPTION_TYPE_CREATE:
         case GF_GSYNC_OPTION_TYPE_DELETE:
-                if (dict_get_str (dict, "master", &master) != 0)
-                        master = "???";
-                if (dict_get_str (dict, "slave", &slave) != 0)
-                        slave = "???";
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"master",
-                                                       "%s", master);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"master",
+                                                  "%s", master);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"slave",
-                                                       "%s", slave);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"slave",
+                                                  "%s", slave);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                break;
+            break;
 
         case GF_GSYNC_OPTION_TYPE_CONFIG:
-                if (op_ret == 0) {
-                        ret = xmlTextWriterStartElement (writer, (xmlChar *)"config");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+            if (op_ret == 0) {
+                ret = xmlTextWriterStartElement(writer, (xmlChar *)"config");
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = cli_xml_generate_gsync_config (dict, writer);
-                        if (ret)
-                                goto out;
+                ret = cli_xml_generate_gsync_config(dict, writer);
+                if (ret)
+                    goto out;
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            }
 
-                break;
+            break;
         case GF_GSYNC_OPTION_TYPE_STATUS:
-                ret = cli_xml_output_vol_gsync_status (dict, writer);
-                break;
+            ret = cli_xml_output_vol_gsync_status(dict, writer);
+            if (ret) {
+                gf_log("cli", GF_LOG_DEBUG, "Failed to get gsync status");
+                goto out;
+            }
+            break;
         default:
-                ret = 0;
-                break;
-        }
+            ret = 0;
+            break;
+    }
 
-        /* </geoRep> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </geoRep> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
@@ -4526,54 +3842,54 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_create (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_create(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapCreate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapCreate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapCreate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapCreate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapCreate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapCreate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot clone output in xml format.
@@ -4585,57 +3901,55 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_clone (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_clone(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("cli", writer, out);
-        GF_VALIDATE_OR_GOTO ("cli", doc, out);
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-
-        /* <CloneCreate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"CloneCreate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "clonename", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get clone name");
-                goto out;
-        }
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get clone uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </CloneCreate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_VALIDATE_OR_GOTO("cli", writer, out);
+    GF_VALIDATE_OR_GOTO("cli", doc, out);
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
+
+    /* <CloneCreate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"CloneCreate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "clonename", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+        goto out;
+    }
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get clone uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </CloneCreate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* This function will generate snapshot restore output in xml format.
  *
  * @param writer        xmlTextWriterPtr
@@ -4645,84 +3959,83 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_restore (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_restore(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapRestore> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapRestore");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get vol name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume id");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapRestore> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapRestore> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapRestore");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get vol name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume id");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapRestore> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot list output in xml format.
@@ -4734,57 +4047,57 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_list (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_list(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        int     i               = 0;
-        int     snapcount       = 0;
-        char   *str_value       = NULL;
-        char    key[PATH_MAX]   = "";
+    int ret = -1;
+    int i = 0;
+    int snapcount = 0;
+    char *str_value = NULL;
+    char key[PATH_MAX] = "";
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
 
-        /* <snapList> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapList");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapList> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapList");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapcount");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapcount");
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "count",
-                                               "%d", snapcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          snapcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 1; i <= snapcount; ++i) {
-                ret = snprintf (key, sizeof (key), "snapname%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
+    for (i = 1; i <= snapcount; ++i) {
+        ret = snprintf(key, sizeof(key), "snapname%d", i);
+        if (ret < 0) {
+            goto out;
+        }
 
-                ret = dict_get_str (dict, key, &str_value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                } else {
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *)"snapshot", "%s", str_value);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+        ret = dict_get_str(dict, key, &str_value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
+        } else {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapshot",
+                                                  "%s", str_value);
+            XML_RET_CHECK_AND_GOTO(ret, out);
         }
+    }
 
-        /* </snapList> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapList> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate xml output for origin volume
@@ -4798,66 +4111,66 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_orig_vol (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix)
+cli_xml_snapshot_info_orig_vol(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix)
 {
-        int     ret             = -1;
-        int     value           = 0;
-        char   *buffer          = NULL;
-        char    key [PATH_MAX]  = "";
+    int ret = -1;
+    int value = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
 
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
 
-        /* <originVolume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"originVolume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <originVolume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"originVolume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%sorigin-volname", keyprefix);
+    snprintf(key, sizeof(key), "%sorigin-volname", keyprefix);
 
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_WARNING, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_WARNING, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%ssnapcount", keyprefix);
+    snprintf(key, sizeof(key), "%ssnapcount", keyprefix);
 
-        ret = dict_get_int32 (dict, key, &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_int32(dict, key, &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "snapCount",
-                                               "%d", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapCount", "%d",
+                                          value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%ssnaps-available", keyprefix);
+    snprintf(key, sizeof(key), "%ssnaps-available", keyprefix);
 
-        ret = dict_get_int32 (dict, key, &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_int32(dict, key, &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "snapRemaining", "%d", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapRemaining",
+                                          "%d", value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </originVolume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </originVolume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate xml output of snapshot volume info.
@@ -4872,66 +4185,74 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_snap_vol (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix,
-                                gf_boolean_t snap_driven)
+cli_xml_snapshot_info_snap_vol(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix,
+                               gf_boolean_t snap_driven)
 {
-        char            key [PATH_MAX]          = "";
-        char           *buffer                  = NULL;
-        int             ret                     = -1;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-
-        /* <snapVolume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapVolume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.volname", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+    int ret = -1;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+
+    /* <snapVolume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapVolume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key, sizeof(key), "%s.volname", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key, sizeof(key), "%s.vol-status", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* If the command is snap_driven then we need to show origin volume
+     * info. Else this is shown in the start of info display.*/
+    if (snap_driven) {
+        ret = snprintf(key, sizeof(key), "%s.", keyprefix);
+        if (ret < 0)
+            goto out;
+
+        ret = cli_xml_snapshot_info_orig_vol(writer, doc, dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot's origin volume");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.vol-status", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
+    /* </snapVolume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "status",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* If the command is snap_driven then we need to show origin volume
-         * info. Else this is shown in the start of info display.*/
-        if (snap_driven) {
-                snprintf (key, sizeof (key), "%s.", keyprefix);
-                ret = cli_xml_snapshot_info_orig_vol (writer, doc, dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot's origin volume");
-                        goto out;
-                }
-        }
-
-        /* </snapVolume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot info of individual snapshot
@@ -4947,112 +4268,118 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_per_snap (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix,
-                                gf_boolean_t snap_driven)
+cli_xml_snapshot_info_per_snap(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix,
+                               gf_boolean_t snap_driven)
 {
-        char            key_buffer[PATH_MAX]    = "";
-        char           *buffer                  = NULL;
-        int             volcount                = 0;
-        int             ret                     = -1;
-        int             i                       = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snapname",
-                  keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
+    char key_buffer[PATH_MAX] = "";
+    char *buffer = NULL;
+    int volcount = 0;
+    int ret = -1;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snapname", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ", key_buffer);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-id", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ", key_buffer);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-desc", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description",
+                                              "%s", buffer);
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description",
+                                              "%s", "");
+    }
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-time", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ", keyprefix);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"createTime", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.vol-count", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_int32(dict, key_buffer, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Fail to get snap vol count");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volCount", "%d",
+                                          volcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, key_buffer, &volcount);
+    /* Display info of each snapshot volume */
+    for (i = 1; i <= volcount; i++) {
+        ret = snprintf(key_buffer, sizeof(key_buffer), "%s.vol%d", keyprefix,
+                       i);
+        if (ret < 0)
+            goto out;
+
+        ret = cli_xml_snapshot_info_snap_vol(writer, doc, dict, key_buffer,
+                                             snap_driven);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ",
-                        key_buffer);
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-id", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ",
-                                key_buffer);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not list "
+                   "details of volume in a snap");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-desc", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "description",
-                                                "%s", buffer);
-        } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "description",
-                                                "%s", "");
-        }
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-time", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
-                                keyprefix);
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *) "createTime",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.vol-count", keyprefix);
-        ret = dict_get_int32 (dict, key_buffer, &volcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Fail to get snap vol count");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *) "volCount",
-                                               "%d", volcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, key_buffer, &volcount);
-        /* Display info of each snapshot volume */
-        for (i = 1 ; i <= volcount ; i++) {
-                snprintf (key_buffer, sizeof (key_buffer), "%s.vol%d",
-                          keyprefix, i);
-
-                ret = cli_xml_snapshot_info_snap_vol (writer, doc, dict,
-                                                      key_buffer, snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not list "
-                                        "details of volume in a snap");
-                        goto out;
-                }
-        }
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot info output in xml format.
@@ -5064,73 +4391,74 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_info(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int             ret             = -1;
-        int             i               = 0;
-        int             snapcount       = 0;
-        char            key [PATH_MAX]  = "";
-        gf_boolean_t    snap_driven     = _gf_false;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapInfo> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapInfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snap_driven = dict_get_str_boolean (dict, "snap-driven", _gf_false);
-
-        /* If the approach is volume based then we should display orgin volume
-         * information first followed by per snap info*/
-        if (!snap_driven) {
-                ret = cli_xml_snapshot_info_orig_vol (writer, doc, dict, "");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot's origin volume");
-                        goto out;
-                }
-        }
-
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
+    int ret = -1;
+    int i = 0;
+    int snapcount = 0;
+    char key[PATH_MAX] = "";
+    gf_boolean_t snap_driven = _gf_false;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapInfo> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapInfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snap_driven = dict_get_str_boolean(dict, "snap-driven", _gf_false);
+
+    /* If the approach is volume based then we should display origin volume
+     * information first followed by per snap info*/
+    if (!snap_driven) {
+        ret = cli_xml_snapshot_info_orig_vol(writer, doc, dict, "");
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot's origin volume");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "count",
-                                               "%d", snapcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = dict_get_int32(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapcount");
+        goto out;
+    }
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          snapcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Get snapshot info of individual snapshots */
-        for (i = 1; i <= snapcount; ++i) {
-                snprintf (key, sizeof (key), "snap%d", i);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = cli_xml_snapshot_info_per_snap (writer, doc, dict,
-                                                      key, snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                }
+    /* Get snapshot info of individual snapshots */
+    for (i = 1; i <= snapcount; ++i) {
+        snprintf(key, sizeof(key), "snap%d", i);
+
+        ret = cli_xml_snapshot_info_per_snap(writer, doc, dict, key,
+                                             snap_driven);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
         }
+    }
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapInfo> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapInfo> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status of individual
@@ -5144,139 +4472,148 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_volume_status (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, const char *keyprefix)
+cli_xml_snapshot_volume_status(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, const char *keyprefix)
 {
-        int     ret             = -1;
-        int     brickcount      = 0;
-        int     i               = 0;
-        int     pid             = 0;
-        char   *buffer          = NULL;
-        char    key[PATH_MAX]   = "";
+    int ret = -1;
+    int brickcount = 0;
+    int i = 0;
+    int pid = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    ret = snprintf(key, sizeof(key), "%s.brickcount", keyprefix);
+    if (ret < 0)
+        goto out;
+
+    ret = dict_get_int32(dict, key, &brickcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brickcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* Get status of every brick belonging to the snapshot volume */
+    for (i = 0; i < brickcount; i++) {
+        /* <snapInfo> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.path", keyprefix, i);
+        if (ret < 0)
+            goto out;
 
-        snprintf (key, sizeof (key), "%s.brickcount", keyprefix);
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Brick Path");
+            /*
+             * If path itself is not present, then end *
+             * this brick's status and continue to the *
+             * brick                                   *
+             */
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            continue;
+        }
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"path", "%s",
+                                              buffer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = snprintf(key, sizeof(key), "%s.brick%d.vgname", keyprefix, i);
+        if (ret < 0)
+            goto out;
 
-        ret = dict_get_int32 (dict, key, &brickcount);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Volume Group");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"volumeGroup", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"volumeGroup", "%s", buffer);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "brickCount",
-                                               "%d", brickcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* Get status of every brick belonging to the snapshot volume */
-        for (i = 0 ; i < brickcount ; i++) {
-                /* <snapInfo> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.path", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to get Brick Path");
-                        /*
-                         * If path itself is not present, then end *
-                         * this brick's status and continue to the *
-                         * brick                                   *
-                         */
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        continue;
-                }
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *) "path", "%s", buffer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.vgname",
-                          keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to get Volume Group");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                              (xmlChar *) "volumeGroup", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                       (xmlChar *) "volumeGroup", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.status", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Running");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                            (xmlChar *) "brick_running", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                     (xmlChar *) "brick_running", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.pid", keyprefix, i);
-
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO, "Unable to get pid");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                      (xmlChar *) "pid", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                  (xmlChar *) "pid", "%d", pid);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.data", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                        "Unable to get Data Percent");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                          (xmlChar *) "data_percentage", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                   (xmlChar *) "data_percentage", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.lvsize",
-                          keyprefix, i);
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get LV Size");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                 (xmlChar *) "lvSize", "N/A");
-                } else {
-                        /* Truncate any newline character */
-                        buffer = strtok (buffer, "\n");
-
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                          (xmlChar *) "lvSize", "%s", buffer);
-                }
+        ret = snprintf(key, sizeof(key), "%s.brick%d.status", keyprefix, i);
+        if (ret < 0)
+            goto out;
 
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Running");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"brick_running", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"brick_running", "%s", buffer);
 
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = snprintf(key, sizeof(key), "%s.brick%d.pid", keyprefix, i);
+        if (ret < 0)
+            goto out;
+
+        ret = dict_get_int32(dict, key, &pid);
+        if (ret) {
+            gf_log("cli", GF_LOG_INFO, "Unable to get pid");
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid",
+                                                  "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid",
+                                                  "%d", pid);
+
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = snprintf(key, sizeof(key), "%s.brick%d.data", keyprefix, i);
+        if (ret < 0)
+            goto out;
+
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Data Percent");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"data_percentage", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"data_percentage", "%s", buffer);
+
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = snprintf(key, sizeof(key), "%s.brick%d.lvsize", keyprefix, i);
+        if (ret < 0)
+            goto out;
+
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get LV Size");
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lvSize",
+                                                  "N/A");
+        } else {
+            /* Truncate any newline character */
+            buffer = strtok(buffer, "\n");
+
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lvSize",
+                                                  "%s", buffer);
         }
 
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status of individual
@@ -5289,87 +4626,85 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_status_per_snap (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                  dict_t *dict, const char *keyprefix)
+cli_xml_snapshot_status_per_snap(xmlTextWriterPtr writer, xmlDocPtr doc,
+                                 dict_t *dict, const char *keyprefix)
 {
-        int     ret             = -1;
-        int     volcount        = 0;
-        int     i               = 0;
-        char   *buffer          = NULL;
-        char    key [PATH_MAX]  = "";
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.snapname", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapname");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.uuid", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snap UUID");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int volcount = 0;
+    int i = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.snapname", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapname");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.uuid", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snap UUID");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.volcount", keyprefix);
+
+    ret = dict_get_int32(dict, key, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get volume count");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volCount", "%d",
+                                          volcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* Get snapshot status of individual snapshot volume */
+    for (i = 0; i < volcount; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.volcount", keyprefix);
+        snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
 
-        ret = dict_get_int32 (dict, key, &volcount);
+        ret = cli_xml_snapshot_volume_status(writer, doc, dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get volume count");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snap volume status");
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "volCount",
-                                               "%d", volcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* Get snapshot status of individual snapshot volume */
-        for (i = 0 ; i < volcount ; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.vol%d", keyprefix, i);
-
-                ret = cli_xml_snapshot_volume_status (writer, doc,
-                                                             dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                        "Could not get snap volume status");
-                        goto out;
-                }
-
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status output in xml format.
@@ -5381,64 +4716,63 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_status (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_status(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        int     snapcount       = 0;
-        int     i               = 0;
-        int     status_cmd      = 0;
-        char    key [PATH_MAX]  = "";
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "sub-cmd", &status_cmd);
+    int ret = -1;
+    int snapcount = 0;
+    int i = 0;
+    int status_cmd = 0;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "sub-cmd", &status_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch status type");
+        goto out;
+    }
+
+    if ((GF_SNAP_STATUS_TYPE_SNAP == status_cmd) ||
+        (GF_SNAP_STATUS_TYPE_ITER == status_cmd)) {
+        snapcount = 1;
+    } else {
+        ret = dict_get_int32(dict, "status.snapcount", &snapcount);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch status type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snapcount");
+            goto out;
         }
 
-        if ((GF_SNAP_STATUS_TYPE_SNAP == status_cmd) ||
-            (GF_SNAP_STATUS_TYPE_ITER == status_cmd)) {
-                snapcount = 1;
-        } else {
-                ret = dict_get_int32 (dict, "status.snapcount", &snapcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get snapcount");
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "count",
-                                                       "%d", snapcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                              snapcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        for (i = 0 ; i < snapcount; i++) {
-                snprintf (key, sizeof (key), "status.snap%d", i);
+    for (i = 0; i < snapcount; i++) {
+        snprintf(key, sizeof(key), "status.snap%d", i);
 
-                ret = cli_xml_snapshot_status_per_snap (writer, doc,
-                                                               dict, key);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR, "failed to create xml "
-                                "output for snapshot status");
-                        goto out;
-                }
+        ret = cli_xml_snapshot_status_per_snap(writer, doc, dict, key);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "failed to create xml "
+                   "output for snapshot status");
+            goto out;
         }
+    }
 
-        /* </snapStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config show output in xml format.
@@ -5450,153 +4784,149 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config_show (xmlTextWriterPtr writer,
-                              xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_config_show(xmlTextWriterPtr writer, xmlDocPtr doc,
+                             dict_t *dict)
 {
-        int             ret             = -1;
-        uint64_t        i               = 0;
-        uint64_t        value           = 0;
-        uint64_t        volcount        = 0;
-        char            buf[PATH_MAX]   = "";
-        char           *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <systemConfig> */
-        ret = xmlTextWriterStartElement (writer,
-                        (xmlChar *)"systemConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "snap-max-hard-limit");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "hardLimit", "%"PRIu64, value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t i = 0;
+    uint64_t value = 0;
+    uint64_t volcount = 0;
+    char buf[PATH_MAX] = "";
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <systemConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"systemConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "snap-max-hard-limit");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hardLimit",
+                                          "%" PRIu64, value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "snap-max-soft-limit");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"softLimit",
+                                          "%" PRIu64 "%%", value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "auto-delete", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch auto-delete");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"autoDelete", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snap-activate-on-create", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not fetch snap-activate-on-create-delete");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"activateOnCreate",
+                                          "%s", str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </systemConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volumeConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volumeConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "voldisplaycount", &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch volcount");
+        goto out;
+    }
+
+    /* Get config of all the volumes */
+    for (i = 0; i < volcount; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-volname", i);
+        ret = dict_get_str(dict, buf, &str_value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "snap-max-soft-limit");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "softLimit",
-                        "%"PRIu64"%%", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              str_value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "auto-delete", &str_value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-snap-max-hard-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch auto-delete");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "autoDelete", "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hardLimit",
+                                              "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "snap-activate-on-create", &str_value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-active-hard-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not fetch snap-activate-on-create-delete");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not fetch"
+                   " effective snap_max_hard_limit for "
+                   "%s",
+                   str_value);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "activateOnCreate", "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </systemConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volumeConfig> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volumeConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"effectiveHardLimit", "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_uint64 (dict, "voldisplaycount", &volcount);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-snap-max-soft-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch volcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        /* Get config of all the volumes */
-        for (i = 0; i < volcount; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i);
-                ret = dict_get_str (dict, buf, &str_value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "name", "%s", str_value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-snap-max-hard-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "hardLimit", "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-active-hard-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch"
-                                " effective snap_max_hard_limit for "
-                                "%s", str_value);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "effectiveHardLimit",
-                                "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-snap-max-soft-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *) "softLimit",
-                                        "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"softLimit",
+                                              "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
         /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = 0;
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config set output in xml format.
@@ -5608,87 +4938,84 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config_set (xmlTextWriterPtr writer, xmlDocPtr doc,
-                             dict_t *dict)
+cli_xml_snapshot_config_set(xmlTextWriterPtr writer, xmlDocPtr doc,
+                            dict_t *dict)
 {
-        int             ret             = -1;
-        uint64_t        hard_limit      = 0;
-        uint64_t        soft_limit      = 0;
-        char           *volname         = NULL;
-        char           *auto_delete     = NULL;
-        char           *snap_activate   = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* This is optional parameter therefore ignore the error */
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &hard_limit);
-        /* This is optional parameter therefore ignore the error */
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &soft_limit);
-        ret = dict_get_str (dict, "auto-delete", &auto_delete);
-        ret = dict_get_str (dict, "snap-activate-on-create", &snap_activate);
-
-        if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "At least one option from "
-                        "snap-max-hard-limit, snap-max-soft-limit, auto-delete"
-                        " and snap-activate-on-create should be set");
-                goto out;
-        }
-
-        /* Ignore the error, as volname is optional */
-        ret = dict_get_str (dict, "volname", &volname);
-
-        if (NULL == volname) {
-                /* <systemConfig> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"systemConfig");
-        } else {
-                /* <volumeConfig> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"volumeConfig");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    char *volname = NULL;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* This is optional parameter therefore ignore the error */
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+    /* This is optional parameter therefore ignore the error */
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+    ret = dict_get_str(dict, "auto-delete", &auto_delete);
+    ret = dict_get_str(dict, "snap-activate-on-create", &snap_activate);
+
+    if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR,
+               "At least one option from "
+               "snap-max-hard-limit, snap-max-soft-limit, auto-delete"
+               " and snap-activate-on-create should be set");
+        goto out;
+    }
+
+    /* Ignore the error, as volname is optional */
+    ret = dict_get_str(dict, "volname", &volname);
+
+    if (NULL == volname) {
+        /* <systemConfig> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"systemConfig");
+    } else {
+        /* <volumeConfig> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volumeConfig");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "name", "%s", volname);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+    }
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (hard_limit) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "newHardLimit",
-                                                "%"PRIu64, hard_limit);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (hard_limit) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"newHardLimit",
+                                              "%" PRIu64, hard_limit);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (soft_limit) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "newSoftLimit",
-                                "%"PRIu64, soft_limit);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (soft_limit) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"newSoftLimit",
+                                              "%" PRIu64, soft_limit);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (auto_delete) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "autoDelete", "%s", auto_delete);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (auto_delete) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"autoDelete",
+                                              "%s", auto_delete);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (snap_activate) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                           (xmlChar *) "activateOnCreate", "%s", snap_activate);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (snap_activate) {
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"activateOnCreate", "%s", snap_activate);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </volumeConfig> or </systemConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volumeConfig> or </systemConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config output in xml format.
@@ -5700,58 +5027,60 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_config(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int             ret             = -1;
-        int             config_command  = 0;
+    int ret = -1;
+    int config_command = 0;
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
 
-        /* <snapConfig> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "config-command", &config_command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch config type");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "config-command", &config_command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+        goto out;
+    }
 
-        switch (config_command) {
+    switch (config_command) {
         case GF_SNAP_CONFIG_TYPE_SET:
-                ret = cli_xml_snapshot_config_set (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create xml "
-                                "output for snapshot config set command");
-                        goto out;
-                }
+            ret = cli_xml_snapshot_config_set(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create xml "
+                       "output for snapshot config set command");
+                goto out;
+            }
 
-                break;
+            break;
         case GF_SNAP_CONFIG_DISPLAY:
-                ret = cli_xml_snapshot_config_show (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create xml "
-                                "output for snapshot config show command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_config_show(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create xml "
+                       "output for snapshot config show command");
+                goto out;
+            }
+            break;
         default:
-                gf_log ("cli", GF_LOG_ERROR, "Unknown config command :%d",
-                        config_command);
-                ret = -1;
-                goto out;
-        }
+            gf_log("cli", GF_LOG_ERROR, "Unknown config command :%d",
+                   config_command);
+            ret = -1;
+            goto out;
+    }
 
-        /* </snapConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot activate or
@@ -5764,67 +5093,66 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_activate_deactivate (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                      dict_t *dict, int cmd)
+cli_xml_snapshot_activate_deactivate(xmlTextWriterPtr writer, xmlDocPtr doc,
+                                     dict_t *dict, int cmd)
 {
-        int     ret     = -1;
-        char   *buffer  = NULL;
-        char   *tag     = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        if (GF_SNAP_OPTION_TYPE_ACTIVATE == cmd) {
-                tag = "snapActivate";
-        } else if (GF_SNAP_OPTION_TYPE_DEACTIVATE == cmd) {
-                tag = "snapDeactivate";
-        } else {
-                gf_log ("cli", GF_LOG_ERROR, "invalid command %d", cmd);
-                goto out;
-        }
-
-        /* <snapActivate> or <snapDeactivate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)tag);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        /* </snapActivate> or </snapDeactivate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *buffer = NULL;
+    char *tag = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    if (GF_SNAP_OPTION_TYPE_ACTIVATE == cmd) {
+        tag = "snapActivate";
+    } else if (GF_SNAP_OPTION_TYPE_DEACTIVATE == cmd) {
+        tag = "snapDeactivate";
+    } else {
+        gf_log("cli", GF_LOG_ERROR, "invalid command %d", cmd);
+        goto out;
+    }
+
+    /* <snapActivate> or <snapDeactivate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)tag);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapActivate> or </snapDeactivate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 #endif /* HAVE_LIB_XML */
 
@@ -5838,190 +5166,183 @@ out:
  * @return 0 on success and -1 on failure
  */
 int
-cli_xml_snapshot_delete (cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp)
+cli_xml_snapshot_delete(cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp)
 {
-        int     ret             = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        char   *str_value       = NULL;
-        xmlTextWriterPtr writer = local->writer;
-        xmlDocPtr doc           = local->doc;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto xmlend;
-        }
-
-        if (!rsp->op_ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "status",
-                                                       "Success");
-        } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "status",
-                                                       "Failure");
-                XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-                ret = cli_xml_output_common (writer, rsp->op_ret,
-                                             rsp->op_errno,
-                                             rsp->op_errstr);
-        }
-        XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto xmlend;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    char *str_value = NULL;
+    xmlTextWriterPtr writer = local->writer;
+    xmlDocPtr doc = local->doc;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto xmlend;
+    }
+
+    if (!rsp->op_ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status",
+                                              "Success");
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status",
+                                              "Failure");
+        XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+        ret = cli_xml_output_common(writer, rsp->op_ret, rsp->op_errno,
+                                    rsp->op_errstr);
+    }
+    XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto xmlend;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 xmlend:
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 #endif /* HAVE_LIB_XML */
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_output_snap_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr)
+cli_xml_output_snap_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "snapStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_status_end (cli_local_t *local)
+cli_xml_output_snap_status_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapStatus> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </snapStatus> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_delete_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr)
+cli_xml_output_snap_delete_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int ret = -1;
-        int delete_cmd = -1;
+    int ret = -1;
+    int delete_cmd = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (local->dict, "sub-cmd", &delete_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
-                goto out;
-        }
+    ret = dict_get_int32(local->dict, "sub-cmd", &delete_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
+        goto out;
+    }
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                             op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "snapDelete");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapDelete");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_delete_end (cli_local_t *local)
+cli_xml_output_snap_delete_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapDelete> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </snapDelete> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 /* This function will generate xml output for all the snapshot commands
@@ -6035,493 +5356,484 @@ out:
  * @return 0 on success and -1 on failure
  */
 int
-cli_xml_output_snapshot (int cmd_type, dict_t *dict, int op_ret,
-                         int op_errno, char *op_errstr)
+cli_xml_output_snapshot(int cmd_type, dict_t *dict, int op_ret, int op_errno,
+                        char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret     = -1;
-        xmlTextWriterPtr        writer  = NULL;
-        xmlDocPtr               doc     = NULL;
-
-        GF_ASSERT (dict);
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml begin block");
-                goto out;
-        }
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml common block");
-                goto out;
-        }
-
-        /* In case of command failure just printing the error message is good
-         * enough */
-        if (0 != op_ret) {
-                goto end;
-        }
-
-        switch (cmd_type) {
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+
+    GF_ASSERT(dict);
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml begin block");
+        goto out;
+    }
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml common block");
+        goto out;
+    }
+
+    /* In case of command failure just printing the error message is good
+     * enough */
+    if (0 != op_ret) {
+        goto end;
+    }
+
+    switch (cmd_type) {
         case GF_SNAP_OPTION_TYPE_CREATE:
-                ret = cli_xml_snapshot_create (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot create command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_create(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot create command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_CLONE:
-                ret = cli_xml_snapshot_clone (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot clone command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_clone(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot clone command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_RESTORE:
-                ret = cli_xml_snapshot_restore (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot restore command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_restore(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot restore command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_LIST:
-                ret = cli_xml_snapshot_list (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot list command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_list(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot list command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_STATUS:
-                ret = cli_xml_snapshot_status (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create"
-                                "xml output for snapshot status command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_status(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create"
+                       "xml output for snapshot status command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_INFO:
-                ret = cli_xml_snapshot_info (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot info command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_info(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot info command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_ACTIVATE:
         case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                ret = cli_xml_snapshot_activate_deactivate (writer, doc,
-                                                            dict, cmd_type);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot config command");
-                }
-                break;
+            ret = cli_xml_snapshot_activate_deactivate(writer, doc, dict,
+                                                       cmd_type);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot config command");
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_CONFIG:
-                ret = cli_xml_snapshot_config (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot config command");
-                }
-                break;
+            ret = cli_xml_snapshot_config(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot config command");
+            }
+            break;
         default:
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unexpected snapshot command: %d", cmd_type);
-                goto out;
-        }
+            gf_log("cli", GF_LOG_ERROR, "Unexpected snapshot command: %d",
+                   cmd_type);
+            goto out;
+    }
 
 end:
-        ret = cli_end_xml_output (writer, doc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml end block");
-                goto out;
-        }
-
-        ret = 0;
+    ret = cli_end_xml_output(writer, doc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml end block");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_xml_snapshot_begin_composite_op (cli_local_t *local)
+cli_xml_snapshot_begin_composite_op(cli_local_t *local)
 {
-        int ret         = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        int cmd         = -1;
-        int type        =  -1;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                ret = 0;
-                goto out;
-        }
-
-        if (cmd == GF_SNAP_STATUS_TYPE_ITER ||
-            cmd == GF_SNAP_DELETE_TYPE_SNAP){
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapshot "
-                        "command type from dictionary");
-                goto out;
-        }
-
-        if (GF_SNAP_OPTION_TYPE_STATUS == type)
-                ret = cli_xml_output_snap_status_begin (local, 0, 0, NULL);
-        else if (GF_SNAP_OPTION_TYPE_DELETE == type)
-                ret = cli_xml_output_snap_delete_begin (local, 0, 0, NULL);
+    int cmd = -1;
+    int type = -1;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "sub-cmd");
+        ret = 0;
+        goto out;
+    }
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Error creating xml output");
-                goto out;
-        }
+    if (cmd == GF_SNAP_STATUS_TYPE_ITER || cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get snapshot "
+               "command type from dictionary");
+        goto out;
+    }
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type)
+        ret = cli_xml_output_snap_status_begin(local, 0, 0, NULL);
+    else if (GF_SNAP_OPTION_TYPE_DELETE == type)
+        ret = cli_xml_output_snap_delete_begin(local, 0, 0, NULL);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Error creating xml output");
+        goto out;
+    }
 
 #endif /* HAVE_LIB_XML */
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_snapshot_end_composite_op (cli_local_t *local)
+cli_xml_snapshot_end_composite_op(cli_local_t *local)
 {
-        int ret         = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        int cmd         = -1;
-        int type        = -1;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                ret = 0;
-                goto out;
-        }
-
-        if (cmd == GF_SNAP_STATUS_TYPE_ITER ||
-            cmd == GF_SNAP_DELETE_TYPE_SNAP){
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapshot "
-                        "command type from dictionary");
-                goto out;
-        }
-
-        if (GF_SNAP_OPTION_TYPE_STATUS == type)
-                ret = cli_xml_output_snap_status_end (local);
-        else if (GF_SNAP_OPTION_TYPE_DELETE == type)
-                ret = cli_xml_output_snap_delete_end (local);
+    int cmd = -1;
+    int type = -1;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "sub-cmd");
+        ret = 0;
+        goto out;
+    }
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Error creating xml "
-                                "output");
-                goto out;
-        }
-#endif /* HAVE_LIB_XML */
+    if (cmd == GF_SNAP_STATUS_TYPE_ITER || cmd == GF_SNAP_DELETE_TYPE_SNAP) {
         ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get snapshot "
+               "command type from dictionary");
+        goto out;
+    }
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type)
+        ret = cli_xml_output_snap_status_end(local);
+    else if (GF_SNAP_OPTION_TYPE_DELETE == type)
+        ret = cli_xml_output_snap_delete_end(local);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Error creating xml "
+               "output");
+        goto out;
+    }
+#endif /* HAVE_LIB_XML */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_snapshot_status_single_snap (cli_local_t *local, dict_t *dict,
-                                     char *key)
+cli_xml_snapshot_status_single_snap(cli_local_t *local, dict_t *dict, char *key)
 {
 #if (HAVE_LIB_XML)
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("cli", (local != NULL), out);
-        GF_VALIDATE_OR_GOTO ("cli", (dict != NULL), out);
-        GF_VALIDATE_OR_GOTO ("cli", (key != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (local != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (dict != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (key != NULL), out);
 
-        ret = cli_xml_snapshot_status_per_snap (local->writer, local->doc, dict,
-                                                key);
+    ret = cli_xml_snapshot_status_per_snap(local->writer, local->doc, dict,
+                                           key);
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_xml_output_vol_getopts (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_vol_getopts(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     i = 0;
-        int                     ret = -1;
-        int                     count = 0;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *key = NULL;
-        char                    *value = NULL;
-        char                    dict_key[50] = {0,};
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volGetopts");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &count);
+    int i = 0;
+    int ret = -1;
+    int count = 0;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char dict_key[50] = {
+        0,
+    };
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volGetopts");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to retrieve count "
+               "from the dictionary");
+        goto out;
+    }
+    if (count <= 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Value of count :%d is "
+               "invalid",
+               count);
+        ret = -1;
+        goto out;
+    }
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          count);
+
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 1; i <= count; i++) {
+        sprintf(dict_key, "key%d", i);
+        ret = dict_get_str(dict, dict_key, &key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to retrieve count "
-                        "from the dictionary");
-                goto out;
-        }
-        if (count <= 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Value of count :%d is "
-                        "invalid", count);
-                ret = -1;
-                goto out;
-        }
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", count);
-
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i=1; i<=count; i++) {
-                sprintf (dict_key, "key%d", i);
-                ret = dict_get_str (dict, dict_key, &key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to"
-                                " retrieve %s from the "
-                                "dictionary", dict_key);
-                        goto out;
-                }
-                sprintf (dict_key, "value%d", i);
-                ret = dict_get_str (dict, dict_key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "retrieve key value for %s from"
-                                "the dictionary", dict_key);
-                        goto out;
-                }
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"Opt");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to"
+                   " retrieve %s from the "
+                   "dictionary",
+                   dict_key);
+            goto out;
+        }
+        sprintf(dict_key, "value%d", i);
+        ret = dict_get_str(dict, dict_key, &value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to "
+                   "retrieve key value for %s from"
+                   "the dictionary",
+                   dict_key);
+            goto out;
+        }
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"Opt");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"Option",
-                                                       "%s", key);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"Option", "%s",
+                                              key);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"Value",
-                                                       "%s", value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"Value", "%s",
+                                              value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        ret = cli_end_xml_output (writer, doc);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_quota_list_xml_error (cli_local_t *local, char *path,
-                          char *errstr)
+cli_quota_list_xml_error(cli_local_t *local, char *path, char *errstr)
 {
 #if (HAVE_LIB_XML)
-        int     ret     =       -1;
+    int ret = -1;
 
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"errstr",
-                                               "%s", errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"errstr",
+                                          "%s", errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_quota_xml_output (cli_local_t *local, char *path, int64_t hl_str,
-                      char *sl_final, int64_t sl_num, int64_t used,
-                      int64_t avail, char *sl, char *hl,
-                      gf_boolean_t limit_set)
+cli_quota_xml_output(cli_local_t *local, char *path, int64_t hl_str,
+                     char *sl_final, int64_t sl_num, int64_t used,
+                     int64_t avail, char *sl, char *hl, gf_boolean_t limit_set)
 {
 #if (HAVE_LIB_XML)
-        int     ret             = -1;
-
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hard_limit",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, hl_str);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_percent",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl_final);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_value",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, sl_num);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"used_space",
-                                               "%"PRId64, used);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"avail_space",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, avail);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"sl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hard_limit", !limit_set ? "N/A" : "%" PRId64,
+        hl_str);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"soft_limit_percent",
+                                          !limit_set ? "N/A" : "%s", sl_final);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"soft_limit_value",
+        !limit_set ? "N/A" : "%" PRId64, sl_num);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"used_space", "%" PRId64, used);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"avail_space",
+        !limit_set ? "N/A" : "%" PRId64, avail);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"sl_exceeded", !limit_set ? "N/A" : "%s", sl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hl_exceeded", !limit_set ? "N/A" : "%s", hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_quota_object_xml_output (cli_local_t *local, char *path, char *sl_str,
-                             int64_t sl_val, quota_limits_t *limits,
-                             quota_meta_t *used_space, int64_t avail,
-                             char *sl, char *hl, gf_boolean_t limit_set)
+cli_quota_object_xml_output(cli_local_t *local, char *path, char *sl_str,
+                            int64_t sl_val, quota_limits_t *limits,
+                            quota_meta_t *used_space, int64_t avail, char *sl,
+                            char *hl, gf_boolean_t limit_set)
 {
 #if (HAVE_LIB_XML)
-        int     ret             = -1;
-
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"path",
-                                              "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hard_limit",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, limits->hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_percent",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl_str);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_value",
-                                               !limit_set ? "N/A" :
-                                               "%"PRIu64, sl_val);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hard_limit", !limit_set ? "N/A" : "%" PRId64,
+        limits->hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"file_count",
-                                               "%"PRId64,
-                                               used_space->file_count);
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"soft_limit_percent",
+                                          !limit_set ? "N/A" : "%s", sl_str);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"soft_limit_value",
+        !limit_set ? "N/A" : "%" PRIu64, sl_val);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"dir_count",
-                                               "%"PRIu64,
-                                               used_space->dir_count);
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"file_count", "%" PRId64,
+                                          used_space->file_count);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"dir_count",
+                                          "%" PRIu64, used_space->dir_count);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"available",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, avail);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"available",
+                                          !limit_set ? "N/A" : "%" PRId64,
+                                          avail);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"sl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"sl_exceeded", !limit_set ? "N/A" : "%s", sl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hl_exceeded", !limit_set ? "N/A" : "%s", hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
diff --git a/cli/src/cli.c b/cli/src/cli.c
index ce06366da9f..a52b39c5fb8 100644
--- a/cli/src/cli.c
+++ b/cli/src/cli.c
@@ -33,280 +33,322 @@
 #include <malloc.h>
 #endif
 
-#ifdef HAVE_MALLOC_STATS
-#ifdef DEBUG
-#include <mcheck.h>
-#endif
-#endif
-
 #include "cli.h"
 #include "cli-quotad-client.h"
 #include "cli-cmd.h"
 #include "cli-mem-types.h"
 
-#include "xlator.h"
-#include "glusterfs.h"
-#include "compat.h"
-#include "logging.h"
-#include "dict.h"
-#include "list.h"
-#include "timer.h"
-#include "stack.h"
-#include "revision.h"
-#include "common-utils.h"
-#include "event.h"
-#include "globals.h"
-#include "syscall.h"
-#include "call-stub.h"
+#include <glusterfs/xlator.h>
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/dict.h>
+#include <glusterfs/list.h>
+#include <glusterfs/timer.h>
+#include <glusterfs/stack.h>
+#include <glusterfs/revision.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/gf-event.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/call-stub.h>
 #include <fnmatch.h>
 
 #include "xdr-generic.h"
 
-extern int connected;
 /* using argp for command line parsing */
 
-const char *argp_program_version = ""                                         \
-        PACKAGE_NAME" "PACKAGE_VERSION                                        \
-        "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n"          \
-        "Copyright (c) 2006-2016 Red Hat, Inc. "                              \
-        "<https://www.gluster.org/>\n"                                        \
-        "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"                      \
-        "It is licensed to you under your choice of the GNU Lesser\n"         \
-        "General Public License, version 3 or any later version (LGPLv3\n"    \
-        "or later), or the GNU General Public License, version 2 (GPLv2),\n"  \
-        "in all cases as published by the Free Software Foundation.";
+const char *argp_program_version =
+    "" PACKAGE_NAME " " PACKAGE_VERSION
+    "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION
+    "\n"
+    "Copyright (c) 2006-2016 Red Hat, Inc. "
+    "<https://www.gluster.org/>\n"
+    "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"
+    "It is licensed to you under your choice of the GNU Lesser\n"
+    "General Public License, version 3 or any later version (LGPLv3\n"
+    "or later), or the GNU General Public License, version 2 (GPLv2),\n"
+    "in all cases as published by the Free Software Foundation.";
 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 
 struct rpc_clnt *global_quotad_rpc;
+
 struct rpc_clnt *global_rpc;
 
 rpc_clnt_prog_t *cli_rpc_prog;
 
-
 extern struct rpc_clnt_program cli_prog;
 
+int cli_default_conn_timeout = 120;
+int cli_ten_minutes_timeout = 600;
+
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t    *cmd_args = NULL;
-        struct rlimit  lim = {0, };
-        call_pool_t   *pool = NULL;
-        int            ret         = -1;
-
-        ret = xlator_mem_acct_init (THIS, cli_mt_end);
-        if (ret != 0) {
-                return ret;
-        }
-
-        ctx->process_uuid = generate_glusterfs_ctx_id ();
-        if (!ctx->process_uuid)
-                return -1;
-
-        ctx->page_size  = 128 * GF_UNIT_KB;
-
-        ctx->iobuf_pool = iobuf_pool_new ();
-        if (!ctx->iobuf_pool)
-                return -1;
-
-        ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-        if (!ctx->event_pool)
-                return -1;
-
-        pool = GF_CALLOC (1, sizeof (call_pool_t),
-                          cli_mt_call_pool_t);
-        if (!pool)
-                return -1;
-
-        /* frame_mem_pool size 112 * 64 */
-        pool->frame_mem_pool = mem_pool_new (call_frame_t, 32);
-        if (!pool->frame_mem_pool)
-                return -1;
-
-        /* stack_mem_pool size 256 * 128 */
-        pool->stack_mem_pool = mem_pool_new (call_stack_t, 16);
-
-        if (!pool->stack_mem_pool)
-                return -1;
-
-        ctx->stub_mem_pool = mem_pool_new (call_stub_t, 16);
-        if (!ctx->stub_mem_pool)
-                return -1;
-
-        ctx->dict_pool = mem_pool_new (dict_t, 32);
-        if (!ctx->dict_pool)
-                return -1;
-
-        ctx->dict_pair_pool = mem_pool_new (data_pair_t, 512);
-        if (!ctx->dict_pair_pool)
-                return -1;
-
-        ctx->dict_data_pool = mem_pool_new (data_t, 512);
-        if (!ctx->dict_data_pool)
-                return -1;
-
-        ctx->logbuf_pool = mem_pool_new (log_buf_t, 256);
-        if (!ctx->logbuf_pool)
-                return -1;
-
-        INIT_LIST_HEAD (&pool->all_frames);
-        LOCK_INIT (&pool->lock);
-        ctx->pool = pool;
-
-        cmd_args = &ctx->cmd_args;
-
-        INIT_LIST_HEAD (&cmd_args->xlator_options);
+    cmd_args_t *cmd_args = NULL;
+    struct rlimit lim = {
+        0,
+    };
+    call_pool_t *pool = NULL;
+    int ret = -1;
+
+    if (!ctx)
+        return ret;
 
-        lim.rlim_cur = RLIM_INFINITY;
-        lim.rlim_max = RLIM_INFINITY;
-        setrlimit (RLIMIT_CORE, &lim);
+    ret = xlator_mem_acct_init(THIS, cli_mt_end);
+    if (ret != 0) {
+        gf_log("cli", GF_LOG_ERROR, "Memory accounting init failed.");
+        return ret;
+    }
+
+    /* Resetting ret to -1 to so in case of failure
+     * we can relese allocated resource.
+     */
+    ret = -1;
+
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to generate uuid.");
+        goto out;
+    }
+
+    ctx->page_size = 128 * GF_UNIT_KB;
+
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create iobuf pool.");
+        goto out;
+    }
+
+    ctx->event_pool = gf_event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                        STARTING_EVENT_THREADS);
+    if (!ctx->event_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create event pool.");
+        goto out;
+    }
+
+    pool = GF_CALLOC(1, sizeof(call_pool_t), cli_mt_call_pool_t);
+    if (!pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create call pool.");
+        goto out;
+    }
+
+    /* frame_mem_pool size 112 * 64 */
+    pool->frame_mem_pool = mem_pool_new(call_frame_t, 32);
+    if (!pool->frame_mem_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create frame mem pool.");
+        goto out;
+    }
+
+    /* stack_mem_pool size 256 * 128 */
+    pool->stack_mem_pool = mem_pool_new(call_stack_t, 16);
+
+    if (!pool->stack_mem_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create stack mem pool.");
+        goto out;
+    }
+
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 16);
+    if (!ctx->stub_mem_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to stub mem pool.");
+        goto out;
+    }
+
+    ctx->dict_pool = mem_pool_new(dict_t, 32);
+    if (!ctx->dict_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create dict pool.");
+        goto out;
+    }
+
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t, 512);
+    if (!ctx->dict_pair_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create dict pair pool.");
+        goto out;
+    }
+
+    ctx->dict_data_pool = mem_pool_new(data_t, 512);
+    if (!ctx->dict_data_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create dict data pool.");
+        goto out;
+    }
+
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, 256);
+    if (!ctx->logbuf_pool) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to create logbuf pool.");
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&pool->all_frames);
+    LOCK_INIT(&pool->lock);
+    ctx->pool = pool;
+
+    cmd_args = &ctx->cmd_args;
+
+    INIT_LIST_HEAD(&cmd_args->xlator_options);
+
+    lim.rlim_cur = RLIM_INFINITY;
+    lim.rlim_max = RLIM_INFINITY;
+    setrlimit(RLIMIT_CORE, &lim);
+
+    ret = 0;
 
-        return 0;
+out:
+    if (ret != 0) {
+        if (pool) {
+            mem_pool_destroy(pool->frame_mem_pool);
+            mem_pool_destroy(pool->stack_mem_pool);
+        }
+        GF_FREE(pool);
+        pool = NULL;
+        GF_FREE(ctx->process_uuid);
+        mem_pool_destroy(ctx->stub_mem_pool);
+        mem_pool_destroy(ctx->dict_pool);
+        mem_pool_destroy(ctx->dict_pair_pool);
+        mem_pool_destroy(ctx->dict_data_pool);
+        mem_pool_destroy(ctx->logbuf_pool);
+    }
+
+    return ret;
 }
 
-
 static int
-logging_init (glusterfs_ctx_t *ctx, struct cli_state *state)
+logging_init(glusterfs_ctx_t *ctx, struct cli_state *state)
 {
-        char *log_file = state->log_file ? state->log_file :
-                         DEFAULT_CLI_LOG_FILE_DIRECTORY "/cli.log";
-
-        /* passing ident as NULL means to use default ident for syslog */
-        if (gf_log_init (ctx, log_file, NULL) == -1) {
-                fprintf (stderr, "ERROR: failed to open logfile %s\n",
-                         log_file);
-                return -1;
-        }
-
-        /* CLI should not have something to DEBUG after the release,
-           hence defaulting to INFO loglevel */
-        gf_log_set_loglevel ((state->log_level == GF_LOG_NONE) ? GF_LOG_INFO :
-                             state->log_level);
-
-        return 0;
+    char *log_file = state->log_file ? state->log_file
+                                     : DEFAULT_CLI_LOG_FILE_DIRECTORY
+                         "/cli.log";
+
+    /* passing ident as NULL means to use default ident for syslog */
+    if (gf_log_init(ctx, log_file, NULL) == -1) {
+        fprintf(stderr, "ERROR: failed to open logfile %s\n", log_file);
+    }
+
+    /* CLI should not have something to DEBUG after the release,
+       hence defaulting to INFO loglevel */
+    gf_log_set_loglevel(ctx, (state->log_level == GF_LOG_NONE)
+                                 ? GF_LOG_INFO
+                                 : state->log_level);
+
+    return 0;
 }
 
 int
-cli_submit_request (struct rpc_clnt *rpc, void *req, call_frame_t *frame,
-                    rpc_clnt_prog_t *prog,
-                    int procnum, struct iobref *iobref,
-                    xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+cli_submit_request(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+                   rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+                   xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
 {
-        int                     ret         = -1;
-        int                     count      = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf = NULL;
-        char                    new_iobref = 0;
-        ssize_t                 xdr_size   = 0;
-
-        GF_ASSERT (this);
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-                iobuf = iobuf_get2 (this->ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                if (!iobref) {
-                        iobref = iobref_new ();
-                        if (!iobref) {
-                                goto out;
-                        }
-
-                        new_iobref = 1;
-                }
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_size (iobuf);
-
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    char new_iobref = 0;
+    ssize_t xdr_size = 0;
+
+    GF_ASSERT(this);
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+        iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        if (!iobref) {
+            iobref = iobref_new();
+            if (!iobref) {
+                goto out;
+            }
+
+            new_iobref = 1;
         }
 
-        if (!rpc)
-                rpc = global_rpc;
-        /* Send the msg */
-        ret = rpc_clnt_submit (rpc, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
-        ret = 0;
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_size(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            goto out;
+        }
+        iov.iov_len = ret;
+        count = 1;
+    }
+
+    if (!rpc)
+        rpc = global_rpc;
+    /* Send the msg */
+    ret = rpc_clnt_submit(rpc, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
+    ret = 0;
 
 out:
-        if (new_iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    if (new_iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 int
-cli_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-                void *data)
+cli_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+               void *data)
 {
-        xlator_t                *this = NULL;
-        int                     ret = 0;
+    xlator_t *this = NULL;
+    int ret = 0;
 
-        this = mydata;
+    this = mydata;
 
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-        {
-
-                cli_cmd_broadcast_connected ();
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
-               break;
+    switch (event) {
+        case RPC_CLNT_CONNECT: {
+            cli_cmd_broadcast_connected(_gf_true);
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
+            break;
         }
 
-        case RPC_CLNT_DISCONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
-                connected = 0;
-                if (!global_state->prompt && global_state->await_connected) {
-                        ret = 1;
-                        cli_out ("Connection failed. Please check if gluster "
-                                  "daemon is operational.");
-                        exit (ret);
-                }
-                break;
+        case RPC_CLNT_DISCONNECT: {
+            cli_cmd_broadcast_connected(_gf_false);
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
+            if (!global_state->prompt && global_state->await_connected) {
+                ret = 1;
+                cli_out(
+                    "Connection failed. Please check if gluster "
+                    "daemon is operational.");
+                exit(ret);
+            }
+            break;
         }
 
         default:
-                gf_log (this->name, GF_LOG_TRACE,
-                        "got some other RPC event %d", event);
-                ret = 0;
-                break;
-        }
+            gf_log(this->name, GF_LOG_TRACE, "got some other RPC event %d",
+                   event);
+            ret = 0;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-is_valid_int (char *str)
+is_valid_int(char *str)
 {
-        if (*str == '-')
-                ++str;
+    if (*str == '-')
+        ++str;
 
-        /* Handle empty string or just "-".*/
-        if (!*str)
-                return _gf_false;
+    /* Handle empty string or just "-".*/
+    if (!*str)
+        return _gf_false;
 
-        /* Check for non-digit chars in the rest of the string */
-        while (*str) {
-                if (!isdigit(*str))
-                        return _gf_false;
+    /* Check for non-digit chars in the rest of the string */
+    while (*str) {
+        if (!isdigit(*str))
+            return _gf_false;
         else
-                ++str;
-        }
-        return _gf_true;
+            ++str;
+    }
+    return _gf_true;
 }
 
 /*
@@ -316,523 +358,555 @@ is_valid_int (char *str)
  *     -2: parsing issue (avoid unknown option error)
  */
 int
-cli_opt_parse (char *opt, struct cli_state *state)
+cli_opt_parse(char *opt, struct cli_state *state)
 {
-        char            *oarg           = NULL;
-        gf_boolean_t    secure_mgmt_tmp = 0;
-
-        if (strcmp (opt, "") == 0)
-                return 1;
-
-        if (strcmp (opt, "version") == 0) {
-                cli_out ("%s", argp_program_version);
-                exit (0);
-        }
-
-        if (strcmp (opt, "print-logdir") == 0) {
-                cli_out ("%s", DEFAULT_LOG_FILE_DIRECTORY);
-                exit (0);
-        }
-
-        if (strcmp (opt, "print-statedumpdir") == 0) {
-                cli_out ("%s", DEFAULT_VAR_RUN_DIRECTORY);
-                exit (0);
-        }
-
-        if (strcmp (opt, "xml") == 0) {
+    char *oarg = NULL;
+    gf_boolean_t secure_mgmt_tmp = 0;
+
+    if (strcmp(opt, "") == 0)
+        return 1;
+    if (strcmp(opt, "help") == 0) {
+        cli_out(
+            " peer help                - display help for peer commands\n"
+            " volume help              - display help for volume commands\n"
+            " volume bitrot help       - display help for volume"
+            " bitrot commands\n"
+            " volume quota help        - display help for volume"
+            " quota commands\n"
+            " snapshot help            - display help for snapshot commands\n"
+            " global help              - list global commands\n");
+        exit(0);
+    }
+
+    if (strcmp(opt, "version") == 0) {
+        cli_out("%s", argp_program_version);
+        exit(0);
+    }
+
+    if (strcmp(opt, "print-logdir") == 0) {
+        cli_out("%s", DEFAULT_LOG_FILE_DIRECTORY);
+        exit(0);
+    }
+
+    if (strcmp(opt, "print-statedumpdir") == 0) {
+        cli_out("%s", DEFAULT_VAR_RUN_DIRECTORY);
+        exit(0);
+    }
+
+    if (strcmp(opt, "xml") == 0) {
 #if (HAVE_LIB_XML)
-                state->mode |= GLUSTER_MODE_XML;
+        state->mode |= GLUSTER_MODE_XML;
 #else
-                cli_err ("XML output not supported. Ignoring '--xml' option");
+        cli_err("XML output not supported. Ignoring '--xml' option");
 #endif
-                return 0;
-        }
-
-        if (strcmp (opt, "wignore-partition") == 0) {
-                state->mode |= GLUSTER_MODE_WIGNORE_PARTITION;
-                return 0;
-        }
-
-        if (strcmp (opt, "wignore") == 0) {
-                state->mode |= GLUSTER_MODE_WIGNORE;
-                return 0;
-        }
-
-        oarg = strtail (opt, "mode=");
-        if (oarg) {
-                if (strcmp (oarg, "script") == 0) {
-                        state->mode |= GLUSTER_MODE_SCRIPT;
-                        return 0;
-                }
+        return 0;
+    }
 
-                if (strcmp (oarg, "interactive") == 0)
-                        return 0;
+    if (strcmp(opt, "nolog") == 0) {
+        state->mode |= GLUSTER_MODE_GLFSHEAL_NOLOG;
+        return 0;
+    }
 
-                return -1;
-        }
+    if (strcmp(opt, "wignore-partition") == 0) {
+        state->mode |= GLUSTER_MODE_WIGNORE_PARTITION;
+        return 0;
+    }
 
-        oarg = strtail (opt, "remote-host=");
-        if (oarg) {
-                state->remote_host = oarg;
-                return 0;
-        }
+    if (strcmp(opt, "wignore") == 0) {
+        state->mode |= GLUSTER_MODE_WIGNORE;
+        return 0;
+    }
 
-        oarg = strtail (opt, "log-file=");
-        if (oarg) {
-                state->log_file = oarg;
-                return 0;
-        }
-        oarg = strtail (opt, "timeout=");
-        if (oarg) {
-                if (!is_valid_int (oarg) || atoi(oarg) <= 0) {
-                        cli_err ("timeout value should be a positive integer");
-                        return -2; /* -2 instead of -1 to avoid unknown option
-                                      error */
-                }
-                cli_default_conn_timeout = atoi(oarg);
-                return 0;
+    oarg = strtail(opt, "mode=");
+    if (oarg) {
+        if (strcmp(oarg, "script") == 0) {
+            state->mode |= GLUSTER_MODE_SCRIPT;
+            return 0;
         }
 
-        oarg = strtail (opt, "log-level=");
-        if (oarg) {
-                int log_level = glusterd_check_log_level(oarg);
-                if (log_level == -1)
-                        return -1;
-                state->log_level = (gf_loglevel_t) log_level;
-                return 0;
-        }
+        if (strcmp(oarg, "interactive") == 0)
+            return 0;
 
-        oarg = strtail (opt, "glusterd-sock=");
-        if (oarg) {
-                state->glusterd_sock = oarg;
-                return 0;
-        }
+        return -1;
+    }
 
-        oarg = strtail (opt, "secure-mgmt=");
-        if (oarg) {
-                if (gf_string2boolean(oarg,&secure_mgmt_tmp) == 0) {
-                        if (secure_mgmt_tmp) {
-                                /* See declaration for why this is an int. */
-                                state->ctx->secure_mgmt = 1;
-                        }
-                }
-                else {
-                        cli_err ("invalide secure-mgmt value (ignored)");
-                }
-                return 0;
-        }
+    oarg = strtail(opt, "remote-host=");
+    if (oarg) {
+        state->remote_host = oarg;
+        return 0;
+    }
 
-        return -1;
-}
+    oarg = strtail(opt, "inet6");
+    if (oarg) {
+        state->address_family = "inet6";
+        return 0;
+    }
 
-int
-parse_cmdline (int argc, char *argv[], struct cli_state *state)
-{
-        int                 ret            = 0;
-        int                 i              = 0;
-        int                 j              = 0;
-        char               *opt            = NULL;
-        gf_boolean_t       geo_rep_config  = _gf_false;
+    oarg = strtail(opt, "log-file=");
+    if (oarg) {
+        state->log_file = oarg;
+        return 0;
+    }
+    oarg = strtail(opt, "timeout=");
+    if (oarg) {
+        if (!is_valid_int(oarg) || atoi(oarg) <= 0) {
+            cli_err("timeout value should be a positive integer");
+            return -2; /* -2 instead of -1 to avoid unknown option
+                          error */
+        }
+        cli_default_conn_timeout = atoi(oarg);
+        return 0;
+    }
+
+    oarg = strtail(opt, "log-level=");
+    if (oarg) {
+        int log_level = glusterd_check_log_level(oarg);
+        if (log_level == -1)
+            return -1;
+        state->log_level = (gf_loglevel_t)log_level;
+        return 0;
+    }
 
-        state->argc=argc-1;
-        state->argv=&argv[1];
+    oarg = strtail(opt, "glusterd-sock=");
+    if (oarg) {
+        state->glusterd_sock = oarg;
+        return 0;
+    }
 
-        /* Do this first so that an option can override. */
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
+    oarg = strtail(opt, "secure-mgmt=");
+    if (oarg) {
+        if (gf_string2boolean(oarg, &secure_mgmt_tmp) == 0) {
+            if (secure_mgmt_tmp) {
+                /* See declaration for why this is an int. */
                 state->ctx->secure_mgmt = 1;
+            }
+        } else {
+            cli_err("invalid secure-mgmt value (ignored)");
         }
+        return 0;
+    }
 
-        if (state->argc > GEO_REP_CMD_CONFIG_INDEX &&
-            strtail (state->argv[GEO_REP_CMD_INDEX], "geo") &&
-            strtail (state->argv[GEO_REP_CMD_CONFIG_INDEX], "co"))
-                geo_rep_config = _gf_true;
-
-        for (i = 0; i < state->argc; i++) {
-                opt = strtail (state->argv[i], "--");
-                if (opt && !geo_rep_config) {
-                        ret = cli_opt_parse (opt, state);
-                        if (ret == -1) {
-                                cli_out ("unrecognized option --%s", opt);
-                                return ret;
-                        } else if (ret == -2) {
-                                return ret;
-                        }
-                        for (j = i; j < state->argc - 1; j++)
-                                state->argv[j] = state->argv[j + 1];
-                        state->argc--;
-                        /* argv shifted, next check should be at i again */
-                        i--;
-                        if (ret == 1) {
-                                /* end of cli options */
-                                ret = 0;
-                                break;
-                        }
-                }
-        }
-
-        state->argv[state->argc] = NULL;
-
-        return ret;
+    return -1;
 }
 
+int
+parse_cmdline(int argc, char *argv[], struct cli_state *state)
+{
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+    char *opt = NULL;
+
+    state->argc = argc - 1;
+    state->argv = &argv[1];
+
+    /* Do this first so that an option can override. */
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        state->ctx->secure_mgmt = 1;
+        state->ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+
+    if (state->argc > GEO_REP_CMD_CONFIG_INDEX &&
+        strtail(state->argv[GEO_REP_CMD_INDEX], "geo") &&
+        strtail(state->argv[GEO_REP_CMD_CONFIG_INDEX], "co"))
+        goto done;
+
+    for (i = 0; i < state->argc; i++) {
+        opt = strtail(state->argv[i], "--");
+        if (!opt)
+            continue;
+        ret = cli_opt_parse(opt, state);
+        if (ret == -1) {
+            cli_out("unrecognized option --%s\n", opt);
+            usage();
+            return ret;
+        } else if (ret == -2) {
+            return ret;
+        }
+        for (j = i; j < state->argc - 1; j++)
+            state->argv[j] = state->argv[j + 1];
+        state->argc--;
+        /* argv shifted, next check should be at i again */
+        i--;
+        if (ret == 1) {
+            /* end of cli options */
+            ret = 0;
+            break;
+        }
+    }
+
+done:
+    state->argv[state->argc] = NULL;
+
+    return ret;
+}
 
 int
-cli_cmd_tree_init (struct cli_cmd_tree *tree)
+cli_cmd_tree_init(struct cli_cmd_tree *tree)
 {
-        struct cli_cmd_word  *root = NULL;
-        int                   ret = 0;
+    struct cli_cmd_word *root = NULL;
+    int ret = 0;
 
-        root = &tree->root;
-        root->tree = tree;
+    root = &tree->root;
+    root->tree = tree;
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_state_init (struct cli_state *state)
+cli_state_init(struct cli_state *state)
 {
-        struct cli_cmd_tree  *tree = NULL;
-        int                   ret = 0;
-
+    struct cli_cmd_tree *tree = NULL;
+    int ret = 0;
 
-        state->log_level = GF_LOG_NONE;
+    state->log_level = GF_LOG_NONE;
 
-        tree = &state->tree;
-        tree->state = state;
+    tree = &state->tree;
+    tree->state = state;
 
-        ret = cli_cmd_tree_init (tree);
+    ret = cli_cmd_tree_init(tree);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_usage_out (const char *usage)
+cli_usage_out(const char *usage)
 {
-        GF_ASSERT (usage);
-        GF_ASSERT (usage[0] != '\0');
+    GF_ASSERT(usage);
 
-        if (!usage || usage[0] == '\0')
-                return -1;
+    if (!usage || usage[0] == '\0')
+        return -1;
 
-        cli_err ("\nUsage:\n%s\n", usage);
-        return 0;
+    cli_err("\nUsage:\n%s\n", usage);
+    return 0;
 }
 
 int
-_cli_err (const char *fmt, ...)
+_cli_err(const char *fmt, ...)
 {
-        va_list           ap;
-        int               ret = 0;
+    va_list ap;
+    int ret = 0;
 #ifdef HAVE_READLINE
-        struct cli_state *state = global_state;
+    struct cli_state *state = global_state;
 #endif
 
-        va_start (ap, fmt);
+    va_start(ap, fmt);
 
 #ifdef HAVE_READLINE
-        if (state->rl_enabled && !state->rl_processing) {
-                ret = cli_rl_err (state, fmt, ap);
-                va_end (ap);
-                return ret;
-        }
+    if (state->rl_enabled && !state->rl_processing) {
+        ret = cli_rl_err(state, fmt, ap);
+        va_end(ap);
+        return ret;
+    }
 #endif
 
-        ret = vfprintf (stderr, fmt, ap);
-        fprintf (stderr, "\n");
-        va_end (ap);
+    ret = vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
-
 int
-_cli_out (const char *fmt, ...)
+_cli_out(const char *fmt, ...)
 {
-        va_list           ap;
-        int               ret = 0;
+    va_list ap;
+    int ret = 0;
 #ifdef HAVE_READLINE
-        struct cli_state *state = global_state;
+    struct cli_state *state = global_state;
 #endif
 
-        va_start (ap, fmt);
+    va_start(ap, fmt);
 #ifdef HAVE_READLINE
-        if (state->rl_enabled && !state->rl_processing) {
-                ret = cli_rl_out (state, fmt, ap);
-                va_end (ap);
-                return ret;
-        }
+    if (state->rl_enabled && !state->rl_processing) {
+        ret = cli_rl_out(state, fmt, ap);
+        va_end(ap);
+        return ret;
+    }
 #endif
 
-        ret = vprintf (fmt, ap);
-        printf ("\n");
-        va_end (ap);
+    ret = vprintf(fmt, ap);
+    printf("\n");
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 struct rpc_clnt *
-cli_quotad_clnt_rpc_init (void)
+cli_quotad_clnt_rpc_init(void)
 {
-        struct rpc_clnt *rpc = NULL;
-        dict_t          *rpc_opts = NULL;
-        int             ret = -1;
-
-        rpc_opts = dict_new ();
-        if (!rpc_opts) {
-                        ret = -1;
-                        goto out;
-                }
-
-        ret = dict_set_str (rpc_opts, "transport.address-family", "unix");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (rpc_opts, "transport-type", "socket");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (rpc_opts, "transport.socket.connect-path",
-                                            "/var/run/gluster/quotad.socket");
-        if (ret)
-                goto out;
-
-        rpc = cli_quotad_clnt_init (THIS, rpc_opts);
-        if (!rpc)
-                goto out;
-
-        global_quotad_rpc = rpc;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *rpc_opts = NULL;
+    int ret = -1;
+
+    rpc_opts = dict_new();
+    if (!rpc_opts) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_str(rpc_opts, "transport.address-family", "unix");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(rpc_opts, "transport-type", "socket");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(rpc_opts, "transport.socket.connect-path",
+                       "/var/run/gluster/quotad.socket");
+    if (ret)
+        goto out;
+
+    rpc = cli_quotad_clnt_init(THIS, rpc_opts);
+    if (!rpc)
+        goto out;
+
+    global_quotad_rpc = rpc;
 out:
-        if (ret) {
-                if (rpc_opts)
-                        dict_unref(rpc_opts);
-        }
-        return rpc;
+    if (rpc_opts) {
+        dict_unref(rpc_opts);
+    }
+    return rpc;
 }
 
 struct rpc_clnt *
-cli_rpc_init (struct cli_state *state)
+cli_rpc_init(struct cli_state *state)
 {
-        struct rpc_clnt         *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
-        int                     port = CLI_GLUSTERD_PORT;
-        xlator_t                *this = NULL;
-        char                    *addr_family = "inet";
-
-        this = THIS;
-        cli_rpc_prog = &cli_prog;
-        options = dict_new ();
-        if (!options)
-                goto out;
-
-        /* Connect to glusterd using the specified method, giving preference
-         * to a unix socket connection.  If nothing is specified, connect to
-         * the default glusterd socket.
-         */
-        if (state->glusterd_sock) {
-                gf_log ("cli", GF_LOG_INFO, "Connecting to glusterd using "
-                        "sockfile %s", state->glusterd_sock);
-                ret = rpc_transport_unix_options_build (&options,
-                                                        state->glusterd_sock,
-                                                        0);
-                if (ret)
-                        goto out;
-        }
-        else if (state->remote_host) {
-                gf_log ("cli", GF_LOG_INFO, "Connecting to remote glusterd at "
-                        "%s", state->remote_host);
-                ret = dict_set_str (options, "remote-host", state->remote_host);
-                if (ret)
-                        goto out;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = CLI_GLUSTERD_PORT;
+    xlator_t *this = NULL;
+#ifdef IPV6_DEFAULT
+    char *addr_family = "inet6";
+#else
+    char *addr_family = "inet";
+#endif
 
-                if (state->remote_port)
-                        port = state->remote_port;
+    this = THIS;
+    cli_rpc_prog = &cli_prog;
+
+    options = dict_new();
+    if (!options)
+        goto out;
+
+    /* If address family specified in CLI */
+    if (state->address_family) {
+        addr_family = state->address_family;
+    }
+
+    /* Connect to glusterd using the specified method, giving preference
+     * to a unix socket connection.  If nothing is specified, connect to
+     * the default glusterd socket.
+     */
+    if (state->glusterd_sock) {
+        gf_log("cli", GF_LOG_INFO,
+               "Connecting to glusterd using "
+               "sockfile %s",
+               state->glusterd_sock);
+        ret = rpc_transport_unix_options_build(options, state->glusterd_sock,
+                                               0);
+        if (ret)
+            goto out;
+    } else if (state->remote_host) {
+        gf_log("cli", GF_LOG_INFO,
+               "Connecting to remote glusterd at "
+               "%s",
+               state->remote_host);
+
+        ret = dict_set_str(options, "remote-host", state->remote_host);
+        if (ret)
+            goto out;
 
-                ret = dict_set_int32 (options, "remote-port", port);
-                if (ret)
-                        goto out;
+        if (state->remote_port)
+            port = state->remote_port;
 
-                ret = dict_set_str (options, "transport.address-family",
-                                        addr_family);
+        ret = dict_set_int32(options, "remote-port", port);
+        if (ret)
+            goto out;
 
-                if (ret)
-                        goto out;
-        }
-        else {
-                gf_log ("cli", GF_LOG_DEBUG, "Connecting to glusterd using "
-                        "default socket");
-                ret = rpc_transport_unix_options_build
-                        (&options, DEFAULT_GLUSTERD_SOCKFILE, 0);
-                if (ret)
-                        goto out;
-        }
+        ret = dict_set_str(options, "transport.address-family", addr_family);
+        if (ret)
+            goto out;
+    } else {
+        gf_log("cli", GF_LOG_DEBUG,
+               "Connecting to glusterd using "
+               "default socket");
+        ret = rpc_transport_unix_options_build(options,
+                                               DEFAULT_GLUSTERD_SOCKFILE, 0);
+        if (ret)
+            goto out;
+    }
 
-        rpc = rpc_clnt_new (options, this, this->name, 16);
-        if (!rpc)
-                goto out;
+    rpc = rpc_clnt_new(options, this, this->name, 16);
+    if (!rpc)
+        goto out;
 
-        ret = rpc_clnt_register_notify (rpc, cli_rpc_notify, this);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "failed to register notify");
-                goto out;
-        }
+    ret = rpc_clnt_register_notify(rpc, cli_rpc_notify, this);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "failed to register notify");
+        goto out;
+    }
 
-        ret = rpc_clnt_start (rpc);
+    ret = rpc_clnt_start(rpc);
 out:
-        if (ret) {
-                if (rpc)
-                        rpc_clnt_unref (rpc);
-                rpc = NULL;
-        }
-        return rpc;
+    if (options)
+        dict_unref(options);
+
+    if (ret) {
+        if (rpc)
+            rpc_clnt_unref(rpc);
+        rpc = NULL;
+    }
+    return rpc;
 }
 
 cli_local_t *
-cli_local_get ()
+cli_local_get()
 {
-        cli_local_t     *local = NULL;
+    cli_local_t *local = NULL;
 
-        local = GF_CALLOC (1, sizeof (*local), cli_mt_cli_local_t);
-        LOCK_INIT (&local->lock);
-        INIT_LIST_HEAD (&local->dict_list);
+    local = GF_CALLOC(1, sizeof(*local), cli_mt_cli_local_t);
+    LOCK_INIT(&local->lock);
+    INIT_LIST_HEAD(&local->dict_list);
 
-        return local;
+    return local;
 }
 
 void
-cli_local_wipe (cli_local_t *local)
+cli_local_wipe(cli_local_t *local)
 {
-        if (local) {
-                GF_FREE (local->get_vol.volname);
-                if (local->dict)
-                        dict_unref (local->dict);
-                GF_FREE (local);
-        }
-
-        return;
+    if (local) {
+        GF_FREE(local->get_vol.volname);
+        if (local->dict)
+            dict_unref(local->dict);
+        GF_FREE(local);
+    }
+
+    return;
 }
 
 struct cli_state *global_state;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        struct cli_state   state = {0, };
-        int                ret = -1;
-        glusterfs_ctx_t   *ctx = NULL;
+    struct cli_state state = {
+        0,
+    };
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
 
-       mem_pools_init_early ();
-       mem_pools_init_late ();
+    mem_pools_init();
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return ENOMEM;
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return ENOMEM;
 
 #ifdef DEBUG
-        gf_mem_acct_enable_set (ctx);
+    gf_mem_acct_enable_set(ctx);
 #endif
 
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                return ret;
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        return ret;
 
-	THIS->ctx = ctx;
+    THIS->ctx = ctx;
 
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        cli_default_conn_timeout = 120;
-        cli_ten_minutes_timeout = 600;
+    cli_default_conn_timeout = 120;
+    cli_ten_minutes_timeout = 600;
 
-        ret = cli_state_init (&state);
-        if (ret)
-                goto out;
+    ret = cli_state_init(&state);
+    if (ret)
+        goto out;
 
-        state.ctx = ctx;
-        global_state = &state;
+    state.ctx = ctx;
+    global_state = &state;
 
-        ret = parse_cmdline (argc, argv, &state);
-        if (ret)
-                goto out;
+    ret = parse_cmdline(argc, argv, &state);
+    if (ret)
+        goto out;
 
-        ret = logging_init (ctx, &state);
-        if (ret)
-                goto out;
+    ret = logging_init(ctx, &state);
+    if (ret)
+        goto out;
 
-        gf_log ("cli", GF_LOG_INFO, "Started running %s with version %s",
-                argv[0], PACKAGE_VERSION);
+    gf_log("cli", GF_LOG_INFO, "Started running %s with version %s", argv[0],
+           PACKAGE_VERSION);
 
-        global_rpc = cli_rpc_init (&state);
-        if (!global_rpc)
-                goto out;
+    global_rpc = cli_rpc_init(&state);
+    if (!global_rpc)
+        goto out;
 
-        global_quotad_rpc = cli_quotad_clnt_rpc_init ();
-        if (!global_quotad_rpc)
-                goto out;
+    global_quotad_rpc = cli_quotad_clnt_rpc_init();
+    if (!global_quotad_rpc)
+        goto out;
 
-        ret = cli_cmds_register (&state);
-        if (ret)
-                goto out;
+    ret = cli_cmds_register(&state);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_cond_init ();
-        if (ret)
-                goto out;
+    ret = cli_input_init(&state);
+    if (ret)
+        goto out;
 
-        ret = cli_input_init (&state);
-        if (ret)
-                goto out;
-
-        ret = event_dispatch (ctx->event_pool);
+    ret = gf_event_dispatch(ctx->event_pool);
 
 out:
-//        glusterfs_ctx_destroy (ctx);
+    //        glusterfs_ctx_destroy (ctx);
 
-        mem_pools_fini ();
+    mem_pools_fini();
 
-        return ret;
+    return ret;
 }
 
 void
-cli_print_line (int len)
+cli_print_line(int len)
 {
-        GF_ASSERT (len > 0);
+    GF_ASSERT(len > 0);
 
-        while (len--)
-                printf ("-");
+    while (len--)
+        printf("-");
 
-        printf ("\n");
+    printf("\n");
 }
 
 void
-print_quota_list_header (int type)
+print_quota_list_header(int type)
 {
-        if (type == GF_QUOTA_OPTION_TYPE_LIST) {
-                cli_out ("                  Path                   Hard-limit "
-                         " Soft-limit      Used  Available  Soft-limit "
-                         "exceeded? Hard-limit exceeded?");
-                cli_out ("-----------------------------------------------------"
-                         "-----------------------------------------------------"
-                         "---------------------");
-        } else {
-                cli_out ("                  Path                   Hard-limit  "
-                         " Soft-limit      Files       Dirs     Available  "
-                         "Soft-limit exceeded? Hard-limit exceeded?");
-                cli_out ("-----------------------------------------------------"
-                         "-----------------------------------------------------"
-                         "-------------------------------------");
-        }
+    if (type == GF_QUOTA_OPTION_TYPE_LIST) {
+        cli_out(
+            "                  Path                   Hard-limit "
+            " Soft-limit      Used  Available  Soft-limit "
+            "exceeded? Hard-limit exceeded?");
+        cli_out(
+            "-----------------------------------------------------"
+            "-----------------------------------------------------"
+            "---------------------");
+    } else {
+        cli_out(
+            "                  Path                   Hard-limit  "
+            " Soft-limit      Files       Dirs     Available  "
+            "Soft-limit exceeded? Hard-limit exceeded?");
+        cli_out(
+            "-----------------------------------------------------"
+            "-----------------------------------------------------"
+            "-------------------------------------");
+    }
 }
 
 void
-print_quota_list_empty (char *path, int type)
+print_quota_list_empty(char *path, int type)
 {
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                cli_out ("%-40s %7s %9s %10s %7s %15s %20s", path,
-                         "N/A", "N/A", "N/A", "N/A", "N/A", "N/A");
-        else
-                cli_out ("%-40s %9s %9s %12s %10s %10s %15s %20s", path,
-                         "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A");
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        cli_out("%-40s %7s %9s %10s %7s %15s %20s", path, "N/A", "N/A", "N/A",
+                "N/A", "N/A", "N/A");
+    else
+        cli_out("%-40s %9s %9s %12s %10s %10s %15s %20s", path, "N/A", "N/A",
+                "N/A", "N/A", "N/A", "N/A", "N/A");
 }
-
diff --git a/cli/src/cli.h b/cli/src/cli.h
index 68dcb8c531f..c0d933e8f8a 100644
--- a/cli/src/cli.h
+++ b/cli/src/cli.h
@@ -11,62 +11,64 @@
 #define __CLI_H__
 
 #include "rpc-clnt.h"
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "protocol-common.h"
-#include "logging.h"
-#include "quota-common-utils.h"
+#include <glusterfs/logging.h>
+#include <glusterfs/quota-common-utils.h>
 
 #include "cli1-xdr.h"
+#include "gd-common-utils.h"
 
 #if (HAVE_LIB_XML)
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 #endif
 
-#define DEFAULT_EVENT_POOL_SIZE            16384
-#define CLI_GLUSTERD_PORT                  24007
-#define DEFAULT_CLI_LOG_FILE_DIRECTORY     DATADIR "/log/glusterfs"
-#define CLI_VOL_STATUS_BRICK_LEN              43
-#define CLI_TAB_LENGTH                         8
-#define CLI_BRICK_STATUS_LINE_LEN             78
+#define DEFAULT_EVENT_POOL_SIZE 16384
+#define CLI_GLUSTERD_PORT 24007
+#define DEFAULT_CLI_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
+#define CLI_VOL_STATUS_BRICK_LEN 43
+#define CLI_TAB_LENGTH 8
+#define CLI_BRICK_STATUS_LINE_LEN 78
 
 /* Geo-rep command positional arguments' index  */
-#define GEO_REP_CMD_INDEX                      1
-#define GEO_REP_CMD_CONFIG_INDEX               4
+#define GEO_REP_CMD_INDEX 1
+#define GEO_REP_CMD_CONFIG_INDEX 4
 
 enum argp_option_keys {
-	ARGP_DEBUG_KEY = 133,
-	ARGP_PORT_KEY = 'p',
+    ARGP_DEBUG_KEY = 133,
+    ARGP_PORT_KEY = 'p',
 };
 
-int cli_default_conn_timeout;
-int cli_ten_minutes_timeout;
+extern int cli_default_conn_timeout;
+extern int cli_ten_minutes_timeout;
 
 typedef enum {
-        COLD_BRICK_COUNT,
-        COLD_TYPE,
-        COLD_DIST_COUNT,
-        COLD_REPLICA_COUNT,
-        COLD_ARBITER_COUNT,
-        COLD_DISPERSE_COUNT,
-        COLD_REDUNDANCY_COUNT,
-        HOT_BRICK_COUNT,
-        HOT_TYPE,
-        HOT_REPLICA_COUNT,
-        MAX
+    COLD_BRICK_COUNT,
+    COLD_TYPE,
+    COLD_DIST_COUNT,
+    COLD_REPLICA_COUNT,
+    COLD_ARBITER_COUNT,
+    COLD_DISPERSE_COUNT,
+    COLD_REDUNDANCY_COUNT,
+    HOT_BRICK_COUNT,
+    HOT_TYPE,
+    HOT_REPLICA_COUNT,
+    MAX
 } values;
 
-#define GLUSTER_MODE_SCRIPT             (1 << 0)
-#define GLUSTER_MODE_ERR_FATAL          (1 << 1)
-#define GLUSTER_MODE_XML                (1 << 2)
-#define GLUSTER_MODE_WIGNORE            (1 << 3)
-#define GLUSTER_MODE_WIGNORE_PARTITION  (1 << 4)
+#define GLUSTER_MODE_SCRIPT (1 << 0)
+#define GLUSTER_MODE_ERR_FATAL (1 << 1)
+#define GLUSTER_MODE_XML (1 << 2)
+#define GLUSTER_MODE_WIGNORE (1 << 3)
+#define GLUSTER_MODE_WIGNORE_PARTITION (1 << 4)
+#define GLUSTER_MODE_GLFSHEAL_NOLOG (1 << 5)
 
-
-#define GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(abspath, volname, path) do {       \
-        snprintf (abspath, sizeof (abspath)-1,                                \
-                  DEFAULT_VAR_RUN_DIRECTORY"/%s_quota_list%s", volname, path);\
-        } while (0)
+#define GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(abspath, volname, path)             \
+    do {                                                                       \
+        snprintf(abspath, sizeof(abspath) - 1,                                 \
+                 DEFAULT_VAR_RUN_DIRECTORY "/%s_quota_list%s", volname, path); \
+    } while (0)
 
 struct cli_state;
 struct cli_cmd_word;
@@ -76,420 +78,439 @@ struct cli_cmd;
 extern char *cli_vol_status_str[];
 extern char *cli_vol_task_status_str[];
 
-typedef int (cli_cmd_cbk_t)(struct cli_state *state,
-                            struct cli_cmd_word *word,
-                            const char **words,
-                            int wordcount);
-typedef void (cli_cmd_reg_cbk_t)( struct cli_cmd *this);
+typedef int(cli_cmd_cbk_t)(struct cli_state *state, struct cli_cmd_word *word,
+                           const char **words, int wordcount);
+typedef void(cli_cmd_reg_cbk_t)(struct cli_cmd *this);
 
-typedef int (cli_cmd_match_t)(struct cli_cmd_word *word);
-typedef int (cli_cmd_filler_t)(struct cli_cmd_word *word);
+typedef int(cli_cmd_match_t)(struct cli_cmd_word *word);
+typedef int(cli_cmd_filler_t)(struct cli_cmd_word *word);
 
 struct cli_cmd_word {
-        struct cli_cmd_tree   *tree;
-        const char            *word;
-        cli_cmd_filler_t      *filler;
-        cli_cmd_match_t       *match;
-        cli_cmd_cbk_t         *cbkfn;
-        const char            *desc;
-        const char            *pattern;
-        int                    nextwords_cnt;
-        struct cli_cmd_word  **nextwords;
+    struct cli_cmd_tree *tree;
+    const char *word;
+    cli_cmd_filler_t *filler;
+    cli_cmd_match_t *match;
+    cli_cmd_cbk_t *cbkfn;
+    const char *desc;
+    const char *pattern;
+    int nextwords_cnt;
+    struct cli_cmd_word **nextwords;
 };
 
-
 struct cli_cmd_tree {
-        struct cli_state      *state;
-        struct cli_cmd_word    root;
+    struct cli_state *state;
+    struct cli_cmd_word root;
 };
 
-
 struct cli_state {
-        int                   argc;
-        char                **argv;
+    int argc;
+    char **argv;
 
-        char                  debug;
+    char debug;
 
-        /* for events dispatching */
-        glusterfs_ctx_t      *ctx;
+    /* for events dispatching */
+    glusterfs_ctx_t *ctx;
 
-        /* registry of known commands */
-        struct cli_cmd_tree   tree;
+    /* registry of known commands */
+    struct cli_cmd_tree tree;
 
-        /* the thread which "executes" the command in non-interactive mode */
-        /* also the thread which reads from stdin in non-readline mode */
-        pthread_t             input;
+    /* the thread which "executes" the command in non-interactive mode */
+    /* also the thread which reads from stdin in non-readline mode */
+    pthread_t input;
 
-        /* terminal I/O */
-        const char           *prompt;
-        int                   rl_enabled;
-        int                   rl_async;
-        int                   rl_processing;
+    /* terminal I/O */
+    const char *prompt;
+    int rl_enabled;
+    int rl_async;
+    int rl_processing;
 
-        /* autocompletion state */
-        char                **matches;
-        char                **matchesp;
+    /* autocompletion state */
+    char **matches;
+    char **matchesp;
 
-        char                 *remote_host;
-        int                   remote_port;
-        int                   mode;
-        int                   await_connected;
+    char *remote_host;
+    int remote_port;
+    int mode;
+    int await_connected;
 
-        char                 *log_file;
-        gf_loglevel_t         log_level;
+    char *log_file;
+    gf_loglevel_t log_level;
 
-        char                 *glusterd_sock;
+    char *glusterd_sock;
+    char *address_family;
 };
 
 struct cli_local {
-        struct {
-                char    *volname;
-                int     flags;
-        } get_vol;
-
-        dict_t          *dict;
-        const char      **words;
-        /* Marker for volume status all */
-        gf_boolean_t    all;
+    struct {
+        char *volname;
+        int flags;
+    } get_vol;
+
+    dict_t *dict;
+    const char **words;
+    /* Marker for volume status all */
+    gf_boolean_t all;
 #if (HAVE_LIB_XML)
-        xmlTextWriterPtr        writer;
-        xmlDocPtr               doc;
-        int                     vol_count;
+    xmlTextWriterPtr writer;
+    xmlDocPtr doc;
+    int vol_count;
 #endif
-        gf_lock_t               lock;
-        struct list_head        dict_list;
+    gf_lock_t lock;
+    struct list_head dict_list;
 };
 
 struct cli_volume_status {
-        int            port;
-        int            rdma_port;
-        int            online;
-        uint64_t       block_size;
-        uint64_t       total_inodes;
-        uint64_t       free_inodes;
-        char          *brick;
-        char          *pid_str;
-        char          *free;
-        char          *total;
-        char          *fs_name;
-        char          *mount_options;
-        char          *device;
-        char          *inode_size;
+    int port;
+    int rdma_port;
+    int online;
+    uint64_t block_size;
+    uint64_t total_inodes;
+    uint64_t free_inodes;
+    char *brick;
+    char *pid_str;
+    char *free;
+    char *total;
+    char *fs_name;
+    char *mount_options;
+    char *device;
+    char *inode_size;
 };
 
 struct snap_config_opt_vals_ {
-        char           *op_name;
-        char           *question;
+    char *op_name;
+    char *question;
 };
 
 typedef struct cli_volume_status cli_volume_status_t;
 
 typedef struct cli_local cli_local_t;
 
-typedef ssize_t (*cli_serialize_t) (struct iovec outmsg, void *args);
+typedef ssize_t (*cli_serialize_t)(struct iovec outmsg, void *args);
 
 extern struct cli_state *global_state; /* use only in readline callback */
 
-typedef const char *(*cli_selector_t) (void *wcon);
+extern struct rpc_clnt *global_quotad_rpc;
 
-char *get_struct_variable (int mem_num, gf_gsync_status_t *sts_val);
+extern struct rpc_clnt *global_rpc;
 
-void *cli_getunamb (const char *tok, void **choices, cli_selector_t sel);
+extern rpc_clnt_prog_t *cli_rpc_prog;
 
-int cli_cmd_register (struct cli_cmd_tree *tree, struct cli_cmd *cmd);
-int cli_cmds_register (struct cli_state *state);
+typedef const char *(*cli_selector_t)(void *wcon);
 
-int cli_input_init (struct cli_state *state);
+char *
+get_struct_variable(int mem_num, gf_gsync_status_t *sts_val);
 
-int cli_cmd_process (struct cli_state *state, int argc, char *argv[]);
-int cli_cmd_process_line (struct cli_state *state, const char *line);
+void *
+cli_getunamb(const char *tok, void **choices, cli_selector_t sel);
 
-int cli_rl_enable (struct cli_state *state);
-int cli_rl_out (struct cli_state *state, const char *fmt, va_list ap);
-int cli_rl_err (struct cli_state *state, const char *fmt, va_list ap);
+int
+cli_cmd_register(struct cli_cmd_tree *tree, struct cli_cmd *cmd);
+int
+cli_cmds_register(struct cli_state *state);
 
-int cli_usage_out (const char *usage);
+int
+cli_input_init(struct cli_state *state);
 
-int _cli_out (const char *fmt, ...);
-int _cli_err (const char *fmt, ...);
+int
+cli_cmd_process(struct cli_state *state, int argc, char *argv[]);
+int
+cli_cmd_process_line(struct cli_state *state, const char *line);
 
-#define cli_out(fmt...) do {                       \
-                FMT_WARN (fmt);                    \
-                                                   \
-                _cli_out(fmt);                     \
-                                                   \
-        } while (0)
+int
+cli_rl_enable(struct cli_state *state);
+int
+cli_rl_out(struct cli_state *state, const char *fmt, va_list ap);
+int
+cli_rl_err(struct cli_state *state, const char *fmt, va_list ap);
 
-#define cli_err(fmt...) do {                       \
-                FMT_WARN (fmt);                    \
-                                                   \
-                _cli_err(fmt);                     \
-                                                   \
-        } while (0)
+int
+cli_usage_out(const char *usage);
 
 int
-cli_submit_request (struct rpc_clnt *rpc, void *req, call_frame_t *frame,
-                    rpc_clnt_prog_t *prog,
-                    int procnum, struct iobref *iobref,
-                    xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc);
+_cli_out(const char *fmt, ...);
+int
+_cli_err(const char *fmt, ...);
 
-int32_t
-cli_cmd_volume_create_parse (struct cli_state *state, const char **words,
-                             int wordcount, dict_t **options, char **bricks);
+#define cli_out(fmt...)                                                        \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+                                                                               \
+        _cli_out(fmt);                                                         \
+                                                                               \
+    } while (0)
 
-int32_t
-cli_cmd_volume_reset_parse (const char **words, int wordcount, dict_t **opt);
+#define cli_err(fmt...)                                                        \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+                                                                               \
+        _cli_err(fmt);                                                         \
+                                                                               \
+    } while (0)
+
+#define usage()                                                                \
+    do {                                                                       \
+        cli_out(                                                               \
+            " Usage: gluster [options] <help> <peer>"                          \
+            " <pool> <volume>\n"                                               \
+            " Options:\n"                                                      \
+            " --help  Shows the help information\n"                            \
+            " --version  Shows the version\n"                                  \
+            " --print-logdir  Shows the log directory\n"                       \
+            " --print-statedumpdir Shows the state dump directory\n");         \
+                                                                               \
+    } while (0)
+
+int
+cli_submit_request(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+                   rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+                   xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc);
 
 int32_t
-cli_cmd_gsync_set_parse (const char **words, int wordcount, dict_t **opt);
+cli_cmd_volume_create_parse(struct cli_state *state, const char **words,
+                            int wordcount, dict_t **options, char **bricks);
 
 int32_t
-cli_cmd_quota_parse (const char **words, int wordcount, dict_t **opt);
+cli_cmd_volume_reset_parse(const char **words, int wordcount, dict_t **opt);
 
 int32_t
-cli_cmd_inode_quota_parse (const char **words, int wordcount, dict_t **opt);
+cli_cmd_gsync_set_parse(struct cli_state *state, const char **words,
+                        int wordcount, dict_t **opt, char **errstr);
 
 int32_t
-cli_cmd_bitrot_parse (const char **words, int wordcount, dict_t **opt);
+cli_cmd_quota_parse(const char **words, int wordcount, dict_t **opt);
 
 int32_t
-cli_cmd_volume_set_parse (struct cli_state *state, const char **words,
-                          int wordcount, dict_t **options, char **op_errstr);
+cli_cmd_inode_quota_parse(const char **words, int wordcount, dict_t **opt);
 
 int32_t
-cli_cmd_get_state_parse (struct cli_state *state, const char **words,
-                         int wordcount, dict_t **options, char **op_errstr);
+cli_cmd_bitrot_parse(const char **words, int wordcount, dict_t **opt);
 
 int32_t
-cli_cmd_volume_add_brick_parse (const char **words, int wordcount,
-                                dict_t **options, int *type);
+cli_cmd_volume_set_parse(struct cli_state *state, const char **words,
+                         int wordcount, dict_t **options, char **op_errstr);
 
 int32_t
-cli_cmd_volume_detach_tier_parse (const char **words, int wordcount,
-                                  dict_t **options, int *question);
+cli_cmd_ganesha_parse(struct cli_state *state, const char **words,
+                      int wordcount, dict_t **options, char **op_errstr);
 
 int32_t
-cli_cmd_volume_tier_parse (const char **words, int wordcount,
-                           dict_t **options);
+cli_cmd_get_state_parse(struct cli_state *state, const char **words,
+                        int wordcount, dict_t **options, char **op_errstr);
 
 int32_t
-cli_cmd_volume_old_tier_parse (const char **words, int wordcount,
-                           dict_t **options);
+cli_cmd_volume_add_brick_parse(struct cli_state *state, const char **words,
+                               int wordcount, dict_t **options, int *type);
 
 int32_t
-cli_cmd_volume_remove_brick_parse (const char **words, int wordcount,
-                                   dict_t **options, int *question,
-                                   int *brick_count);
+cli_cmd_volume_remove_brick_parse(struct cli_state *state, const char **words,
+                                  int wordcount, dict_t **options,
+                                  int *question, int *brick_count,
+                                  int32_t *command);
 
 int32_t
-cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
+cli_cmd_volume_replace_brick_parse(const char **words, int wordcount,
                                    dict_t **options);
 
 int32_t
-cli_cmd_volume_reset_brick_parse (const char **words, int wordcount,
-                                  dict_t **options);
+cli_cmd_volume_reset_brick_parse(const char **words, int wordcount,
+                                 dict_t **options);
 
 int32_t
-cli_cmd_log_rotate_parse (const char **words, int wordcount, dict_t **options);
+cli_cmd_log_rotate_parse(const char **words, int wordcount, dict_t **options);
 int32_t
-cli_cmd_log_locate_parse (const char **words, int wordcount, dict_t **options);
+cli_cmd_log_locate_parse(const char **words, int wordcount, dict_t **options);
 int32_t
-cli_cmd_log_filename_parse (const char **words, int wordcount, dict_t **options);
+cli_cmd_log_filename_parse(const char **words, int wordcount, dict_t **options);
 
 int32_t
-cli_cmd_volume_statedump_options_parse (const char **words, int wordcount,
-                                        dict_t **options);
+cli_cmd_volume_statedump_options_parse(const char **words, int wordcount,
+                                       dict_t **options);
 int32_t
-cli_cmd_volume_clrlks_opts_parse (const char **words, int wordcount,
-                                  dict_t **options);
+cli_cmd_volume_clrlks_opts_parse(const char **words, int wordcount,
+                                 dict_t **options);
 
-cli_local_t * cli_local_get ();
+cli_local_t *
+cli_local_get();
 
 void
-cli_local_wipe (cli_local_t *local);
+cli_local_wipe(cli_local_t *local);
+
+gf_boolean_t
+cli_cmd_connected();
 
 int32_t
-cli_cmd_await_connected ();
+cli_cmd_await_connected(unsigned timeout);
 
 int32_t
-cli_cmd_broadcast_connected ();
+cli_cmd_broadcast_connected(gf_boolean_t status);
 
 int
-cli_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-                void *data);
+cli_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+               void *data);
 
 int32_t
-cli_cmd_volume_profile_parse (const char **words, int wordcount,
-                              dict_t **options);
+cli_cmd_volume_profile_parse(const char **words, int wordcount,
+                             dict_t **options);
 int32_t
-cli_cmd_volume_top_parse (const char **words, int wordcount,
-                              dict_t **options);
+cli_cmd_volume_top_parse(const char **words, int wordcount, dict_t **options);
 
 int32_t
-cli_cmd_log_level_parse (const char **words, int wordcount,
-                         dict_t **options);
+cli_cmd_log_level_parse(const char **words, int wordcount, dict_t **options);
 
 int32_t
-cli_cmd_volume_status_parse (const char **words, int wordcount,
-                             dict_t **options);
+cli_cmd_volume_status_parse(const char **words, int wordcount,
+                            dict_t **options);
 
 int
-cli_cmd_volume_heal_options_parse (const char **words, int wordcount,
-                                   dict_t **options);
+cli_cmd_volume_heal_options_parse(const char **words, int wordcount,
+                                  dict_t **options);
 
 int
-cli_cmd_volume_defrag_parse (const char **words, int wordcount,
-                             dict_t **options);
+cli_cmd_volume_defrag_parse(const char **words, int wordcount,
+                            dict_t **options);
 
 int
-cli_print_brick_status (cli_volume_status_t *status);
+cli_print_brick_status(cli_volume_status_t *status);
 
 void
-cli_print_detailed_status (cli_volume_status_t *status);
+cli_print_detailed_status(cli_volume_status_t *status);
 
 int
-cli_get_detail_status (dict_t *dict, int i, cli_volume_status_t *status);
+cli_get_detail_status(dict_t *dict, int i, cli_volume_status_t *status);
 
 void
-cli_print_line (int len);
+cli_print_line(int len);
 
 int
-cli_xml_output_str (char *op, char *str, int op_ret, int op_errno,
-                    char *op_errstr);
+cli_xml_output_str(char *op, char *str, int op_ret, int op_errno,
+                   char *op_errstr);
 
 int
-cli_xml_output_dict (char *op, dict_t *dict, int op_ret, int op_errno,
-                     char *op_errstr);
+cli_xml_output_dict(char *op, dict_t *dict, int op_ret, int op_errno,
+                    char *op_errstr);
 
 int
-cli_xml_output_vol_top (dict_t *dict, int op_ret, int op_errno,
-                        char *op_errstr);
+cli_xml_output_vol_top(dict_t *dict, int op_ret, int op_errno, char *op_errstr);
 
 int
-cli_xml_output_vol_profile (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr);
+cli_xml_output_vol_profile(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr);
 
 int
-cli_xml_output_vol_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                 char *op_errstr);
+cli_xml_output_vol_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                char *op_errstr);
 
 int
-cli_xml_output_vol_status_end (cli_local_t *local);
+cli_xml_output_vol_status_end(cli_local_t *local);
 
 int
-cli_xml_output_vol_status (cli_local_t *local, dict_t *dict);
+cli_xml_output_vol_status(cli_local_t *local, dict_t *dict);
 
 int
-cli_xml_output_vol_list (dict_t *dict, int op_ret, int op_errno,
-                         char *op_errstr);
+cli_xml_output_vol_list(dict_t *dict, int op_ret, int op_errno,
+                        char *op_errstr);
 
 int
-cli_xml_output_vol_info_begin (cli_local_t *local, int op_ret, int op_errno,
-                               char *op_errstr);
+cli_xml_output_vol_info_begin(cli_local_t *local, int op_ret, int op_errno,
+                              char *op_errstr);
 
 int
-cli_xml_output_vol_info_end (cli_local_t *local);
+cli_xml_output_vol_info_end(cli_local_t *local);
 
 int
-cli_xml_output_vol_info (cli_local_t *local, dict_t *dict);
+cli_xml_output_vol_info(cli_local_t *local, dict_t *dict);
 
 int
-cli_xml_output_vol_quota_limit_list_begin (cli_local_t *local, int op_ret,
-                                           int op_errno, char *op_errstr);
+cli_xml_output_vol_quota_limit_list_begin(cli_local_t *local, int op_ret,
+                                          int op_errno, char *op_errstr);
 int
-cli_xml_output_vol_quota_limit_list_end (cli_local_t *local);
+cli_xml_output_vol_quota_limit_list_end(cli_local_t *local);
 
 int
-cli_quota_list_xml_error (cli_local_t *local, char *path,
-                          char *errstr);
+cli_quota_list_xml_error(cli_local_t *local, char *path, char *errstr);
 
 int
-cli_quota_xml_output (cli_local_t *local, char *path, int64_t hl_str,
-                      char *sl_final, int64_t sl_num, int64_t used,
-                      int64_t avail, char *sl, char *hl,
-                      gf_boolean_t limit_set);
+cli_quota_xml_output(cli_local_t *local, char *path, int64_t hl_str,
+                     char *sl_final, int64_t sl_num, int64_t used,
+                     int64_t avail, char *sl, char *hl, gf_boolean_t limit_set);
 
 int
-cli_quota_object_xml_output (cli_local_t *local, char *path, char *sl_str,
-                             int64_t sl_val, quota_limits_t *limits,
-                             quota_meta_t *used_space, int64_t avail,
-                             char *sl, char *hl, gf_boolean_t limit_set);
+cli_quota_object_xml_output(cli_local_t *local, char *path, char *sl_str,
+                            int64_t sl_val, quota_limits_t *limits,
+                            quota_meta_t *used_space, int64_t avail, char *sl,
+                            char *hl, gf_boolean_t limit_set);
 
 int
-cli_xml_output_peer_status (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr);
+cli_xml_output_peer_status(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr);
 
 int
-cli_xml_output_vol_rebalance (gf_cli_defrag_type op, dict_t *dict, int op_ret,
-                              int op_errno, char *op_errstr);
+cli_xml_output_vol_rebalance(gf_cli_defrag_type op, dict_t *dict, int op_ret,
+                             int op_errno, char *op_errstr);
 
 int
-cli_xml_output_vol_remove_brick_detach_tier (gf_boolean_t status_op,
-                                             dict_t *dict, int op_ret,
-                                             int op_errno, char *op_errstr,
-                                             const char *op);
+cli_xml_output_vol_remove_brick(gf_boolean_t status_op, dict_t *dict,
+                                int op_ret, int op_errno, char *op_errstr,
+                                const char *op);
 
 int
-cli_xml_output_vol_replace_brick (dict_t *dict, int op_ret,
-                                  int op_errno, char *op_errstr);
+cli_xml_output_vol_replace_brick(dict_t *dict, int op_ret, int op_errno,
+                                 char *op_errstr);
 
 int
-cli_xml_output_vol_create (dict_t *dict, int op_ret, int op_errno,
-                           char *op_errstr);
+cli_xml_output_vol_create(dict_t *dict, int op_ret, int op_errno,
+                          char *op_errstr);
 
 int
-cli_xml_output_generic_volume (char *op, dict_t *dict, int op_ret, int op_errno,
-                               char *op_errstr);
+cli_xml_output_generic_volume(char *op, dict_t *dict, int op_ret, int op_errno,
+                              char *op_errstr);
 
 int
-cli_xml_output_vol_gsync (dict_t *dict, int op_ret, int op_errno,
-                          char *op_errstr);
+cli_xml_output_vol_gsync(dict_t *dict, int op_ret, int op_errno,
+                         char *op_errstr);
 int
-cli_xml_output_vol_status_tasks_detail (cli_local_t *local, dict_t *dict);
+cli_xml_output_vol_status_tasks_detail(cli_local_t *local, dict_t *dict);
 
 int
-cli_xml_snapshot_delete (cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp);
+cli_xml_snapshot_delete(cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp);
 
 int
-cli_xml_snapshot_begin_composite_op (cli_local_t *local);
+cli_xml_snapshot_begin_composite_op(cli_local_t *local);
 
 int
-cli_xml_snapshot_end_composite_op (cli_local_t *local);
+cli_xml_snapshot_end_composite_op(cli_local_t *local);
 
 int
-cli_xml_output_snap_delete_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr);
+cli_xml_output_snap_delete_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr);
 int
-cli_xml_output_snap_delete_end (cli_local_t *local);
+cli_xml_output_snap_delete_end(cli_local_t *local);
 
 int
-cli_xml_output_snap_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr);
+cli_xml_output_snap_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr);
 int
-cli_xml_output_snap_status_end (cli_local_t *local);
+cli_xml_output_snap_status_end(cli_local_t *local);
 int
-cli_xml_output_snapshot (int cmd_type, dict_t *dict, int op_ret,
-                         int op_errno, char *op_errstr);
+cli_xml_output_snapshot(int cmd_type, dict_t *dict, int op_ret, int op_errno,
+                        char *op_errstr);
 int
-cli_xml_snapshot_status_single_snap (cli_local_t *local, dict_t *dict,
-                                     char *key);
-char *
-is_server_debug_xlator (void *myframe);
-
+cli_xml_snapshot_status_single_snap(cli_local_t *local, dict_t *dict,
+                                    char *key);
 int32_t
-cli_cmd_snapshot_parse (const char **words, int wordcount, dict_t **options,
-                        struct cli_state *state);
+cli_cmd_snapshot_parse(const char **words, int wordcount, dict_t **options,
+                       struct cli_state *state);
 
 int
-cli_xml_output_vol_getopts (dict_t *dict, int op_ret, int op_errno,
-                             char *op_errstr);
+cli_xml_output_vol_getopts(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr);
 
 void
-print_quota_list_header (int type);
+print_quota_list_header(int type);
 
 void
-print_quota_list_empty (char *path, int type);
+print_quota_list_empty(char *path, int type);
 
 int
-gf_gsync_status_t_comparator (const void *p, const void *q);
+gf_gsync_status_t_comparator(const void *p, const void *q);
 #endif /* __CLI_H__ */
diff --git a/cli/src/input.c b/cli/src/input.c
index 10fc39cd6b4..5ac1a20edb1 100644
--- a/cli/src/input.c
+++ b/cli/src/input.c
@@ -19,74 +19,75 @@
 #define CMDBUFSIZ 1024
 
 void *
-cli_batch (void *d)
+cli_batch(void *d)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
+    struct cli_state *state = NULL;
+    int ret = 0;
 
-        state = d;
+    state = d;
 
-        ret = cli_cmd_process (state, state->argc, state->argv);
+    ret = cli_cmd_process(state, state->argc, state->argv);
 
-        gf_log ("", GF_LOG_INFO, "Exiting with: %d", ret);
-        exit (-ret);
+    gf_log("", GF_LOG_INFO, "Exiting with: %d", ret);
+    exit(-ret);
 
-        return NULL;
+    return NULL;
 }
 
-
 void *
-cli_input (void *d)
+cli_input(void *d)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
-        char              cmdbuf[CMDBUFSIZ];
-        char             *cmd = NULL;
-        size_t            len = 0;
-
-        state = d;
-
-        for (;;) {
-                printf ("%s", state->prompt);
-
-                cmd = fgets (cmdbuf, CMDBUFSIZ, stdin);
-                if (!cmd)
-                        break;
-                len = strlen(cmd);
-                if (len > 0 && cmd[len - 1] == '\n') //strip trailing \n
-                        cmd[len - 1] = '\0';
-                ret = cli_cmd_process_line (state, cmd);
-                if (ret != 0 && state->mode & GLUSTER_MODE_ERR_FATAL)
-                        break;
-        }
-
-        exit (-ret);
-
-        return NULL;
+    struct cli_state *state = NULL;
+    int ret = 0;
+    char cmdbuf[CMDBUFSIZ];
+    char *cmd = NULL;
+    size_t len = 0;
+
+    state = d;
+
+    fprintf(stderr,
+            "Welcome to gluster prompt, type 'help' to see the available "
+            "commands.\n");
+    for (;;) {
+        printf("%s", state->prompt);
+
+        cmd = fgets(cmdbuf, CMDBUFSIZ, stdin);
+        if (!cmd)
+            break;
+        len = strlen(cmd);
+        if (len > 0 && cmd[len - 1] == '\n')  // strip trailing \n
+            cmd[len - 1] = '\0';
+        ret = cli_cmd_process_line(state, cmd);
+        if (ret != 0 && state->mode & GLUSTER_MODE_ERR_FATAL)
+            break;
+    }
+
+    exit(-ret);
+
+    return NULL;
 }
 
-
 int
-cli_input_init (struct cli_state *state)
+cli_input_init(struct cli_state *state)
 {
-        int  ret = 0;
+    int ret = 0;
 
-        if (state->argc) {
-                ret = pthread_create (&state->input, NULL, cli_batch, state);
-                return ret;
-        }
+    if (state->argc) {
+        ret = pthread_create(&state->input, NULL, cli_batch, state);
+        return ret;
+    }
 
-        if (isatty (STDIN_FILENO)) {
-                state->prompt = "gluster> ";
+    if (isatty(STDIN_FILENO)) {
+        state->prompt = "gluster> ";
 
-                cli_rl_enable (state);
-        } else {
-                state->prompt = "";
-                state->mode |= GLUSTER_MODE_SCRIPT | GLUSTER_MODE_ERR_FATAL;
-        }
+        cli_rl_enable(state);
+    } else {
+        state->prompt = "";
+        state->mode |= GLUSTER_MODE_SCRIPT | GLUSTER_MODE_ERR_FATAL;
+    }
 
-        if (!state->rl_enabled)
-                ret = pthread_create (&state->input, NULL, cli_input, state);
+    if (!state->rl_enabled)
+        ret = pthread_create(&state->input, NULL, cli_input, state);
 
-        return ret;
+    return ret;
 }
diff --git a/cli/src/registry.c b/cli/src/registry.c
index 1adf7d6e572..85f7686ade1 100644
--- a/cli/src/registry.c
+++ b/cli/src/registry.c
@@ -15,20 +15,18 @@
 #include "cli.h"
 #include "cli-cmd.h"
 
-
 static int
-__is_spc (int ch)
+__is_spc(int ch)
 {
-        if (ch == ' ')
-                return 1;
-        return 0;
+    if (ch == ' ')
+        return 1;
+    return 0;
 }
 
-
 static int
-__is_div (int ch)
+__is_div(int ch)
 {
-        switch (ch) {
+    switch (ch) {
         case '(':
         case ')':
         case '<':
@@ -38,369 +36,356 @@ __is_div (int ch)
         case '{':
         case '}':
         case '|':
-                return 1;
-        }
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-__is_word (const char *word)
+__is_word(const char *word)
 {
-        return (!__is_div (*word) && !__is_spc (*word));
+    return (!__is_div(*word) && !__is_spc(*word));
 }
 
-
 int
-counter_char (int ch)
+counter_char(int ch)
 {
-        switch (ch) {
+    switch (ch) {
         case '(':
-                return ')';
+            return ')';
         case '<':
-                return '>';
+            return '>';
         case '[':
-                return ']';
+            return ']';
         case '{':
-                return '}';
-        }
+            return '}';
+    }
 
-        return -1;
+    return -1;
 }
 
-
 const char *
-__is_template_balanced (const char *template)
+__is_template_balanced(const char *template)
 {
-        const char *trav = NULL;
-        int   ch = 0;
-
-        trav = template;
-
-        while (*trav) {
-                ch = *trav;
-
-                switch (ch) {
-                case '<':
-                case '(':
-                case '[':
-                        trav = __is_template_balanced (trav+1);
-                        if (!trav)
-                                return NULL;
-                        if (*trav != counter_char (ch))
-                                return NULL;
-                        break;
-                case '>':
-                case ')':
-                case ']':
-                        return trav;
-                }
+    const char *trav = NULL;
+    int ch = 0;
 
-                trav++;
+    trav = template;
+
+    while (*trav) {
+        ch = *trav;
+
+        switch (ch) {
+            case '<':
+            case '(':
+            case '[':
+                trav = __is_template_balanced(trav + 1);
+                if (!trav)
+                    return NULL;
+                if (*trav != counter_char(ch))
+                    return NULL;
+                break;
+            case '>':
+            case ')':
+            case ']':
+                return trav;
         }
 
-        return trav;
-}
+        trav++;
+    }
 
+    return trav;
+}
 
 int
-is_template_balanced (const char *template)
+is_template_balanced(const char *template)
 {
-        const char *trav = NULL;
+    const char *trav = NULL;
 
-        trav = __is_template_balanced (template);
-        if (!trav || *trav)
-                return -1;
+    trav = __is_template_balanced(template);
+    if (!trav || *trav)
+        return -1;
 
-        return 0;
+    return 0;
 }
 
-
 int
-cli_cmd_token_count (const char *template)
+cli_cmd_token_count(const char *template)
 {
-        int         count = 0;
-        const char *trav = NULL;
-        int         is_alnum = 0;
-
-        for (trav = template; *trav; trav++) {
-                switch (*trav) {
-                case '<':
-                case '>':
-                case '(':
-                case ')':
-                case '[':
-                case ']':
-                case '{':
-                case '}':
-                case '|':
-                        count++;
-                        /* fall through */
-                case ' ':
-                        is_alnum = 0;
-                        break;
-                default:
-                        if (!is_alnum) {
-                                is_alnum = 1;
-                                count++;
-                        }
+    int count = 0;
+    const char *trav = NULL;
+    int is_alnum = 0;
+
+    for (trav = template; *trav; trav++) {
+        switch (*trav) {
+            case '<':
+            case '>':
+            case '(':
+            case ')':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '|':
+                count++;
+                /* fall through */
+            case ' ':
+                is_alnum = 0;
+                break;
+            default:
+                if (!is_alnum) {
+                    is_alnum = 1;
+                    count++;
                 }
         }
+    }
 
-        return count + 1;
+    return count + 1;
 }
 
-
 void
-cli_cmd_tokens_destroy (char **tokens)
+cli_cmd_tokens_destroy(char **tokens)
 {
-        char **tokenp = NULL;
+    char **tokenp = NULL;
 
-        if (!tokens)
-                return;
+    if (!tokens)
+        return;
 
-        tokenp = tokens;
-        while (*tokenp) {
-                free (*tokenp);
-                tokenp++;
-        }
+    tokenp = tokens;
+    while (*tokenp) {
+        free(*tokenp);
+        tokenp++;
+    }
 
-        free (tokens);
+    free(tokens);
 }
 
-
 int
-cli_cmd_tokens_fill (char **tokens, const char *template)
+cli_cmd_tokens_fill(char **tokens, const char *template)
 {
-        const char  *trav = NULL;
-        char       **tokenp = NULL;
-        char        *token = NULL;
-        int          ret = 0;
-        int          ch = 0;
+    const char *trav = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    int ret = 0;
+    int ch = 0;
 
-        tokenp = tokens;
+    tokenp = tokens;
 
-        for (trav = template; *trav; trav++) {
-                ch = *trav;
+    for (trav = template; *trav; trav++) {
+        ch = *trav;
 
-                if (__is_spc (ch))
-                        continue;
+        if (__is_spc(ch))
+            continue;
 
-                if (__is_div (ch)) {
-                        token = calloc (2, 1);
-                        if (!token)
-                                return -1;
-                        token[0] = ch;
+        if (__is_div(ch)) {
+            token = calloc(2, 1);
+            if (!token)
+                return -1;
+            token[0] = ch;
 
-                        *tokenp = token;
-                        tokenp++;
+            *tokenp = token;
+            tokenp++;
 
-                        continue;
-                }
+            continue;
+        }
 
-                token = strdup (trav);
-                *tokenp = token;
-                tokenp++;
+        token = strdup(trav);
+        *tokenp = token;
+        tokenp++;
 
-                for (token++; *token; token++) {
-                        if (__is_spc (*token) || __is_div (*token)) {
-                                *token = 0;
-                                break;
-                        }
-                        trav++;
-                }
+        for (token++; *token; token++) {
+            if (__is_spc(*token) || __is_div(*token)) {
+                *token = 0;
+                break;
+            }
+            trav++;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 char **
-cli_cmd_tokenize (const char *template)
+cli_cmd_tokenize(const char *template)
 {
-        char **tokens = NULL;
-        int    ret = 0;
-        int    count = 0;
+    char **tokens = NULL;
+    int ret = 0;
+    int count = 0;
 
-        ret = is_template_balanced (template);
-        if (ret)
-                return NULL;
+    ret = is_template_balanced(template);
+    if (ret)
+        return NULL;
 
-        count = cli_cmd_token_count (template);
-        if (count <= 0)
-                return NULL;
+    count = cli_cmd_token_count(template);
+    if (count <= 0)
+        return NULL;
 
-        tokens = calloc (count + 1, sizeof (char *));
-        if (!tokens)
-                return NULL;
+    tokens = calloc(count + 1, sizeof(char *));
+    if (!tokens)
+        return NULL;
 
-        ret = cli_cmd_tokens_fill (tokens, template);
-        if (ret)
-                goto err;
+    ret = cli_cmd_tokens_fill(tokens, template);
+    if (ret)
+        goto err;
 
-        return tokens;
+    return tokens;
 err:
-        cli_cmd_tokens_destroy (tokens);
-        return NULL;
+    cli_cmd_tokens_destroy(tokens);
+    return NULL;
 }
 
 void *
-cli_getunamb (const char *tok, void **choices, cli_selector_t sel)
+cli_getunamb(const char *tok, void **choices, cli_selector_t sel)
 {
-        void  **wcon = NULL;
-        char      *w = NULL;
-        unsigned  mn = 0;
-        void    *ret = NULL;
-
-        if (!choices || !tok || !*tok)
-                return NULL;
-
-        for (wcon = choices; *wcon; wcon++) {
-                w = strtail ((char *)sel (*wcon), tok);
-                if (!w)
-                        /* no match */
-                        continue;
-                if (!*w)
-                        /* exact match */
-                        return *wcon;
-
-                ret = *wcon;
-                mn++;
-        }
+    void **wcon = NULL;
+    char *w = NULL;
+    unsigned mn = 0;
+    void *ret = NULL;
 
-#ifdef FORCE_MATCH_EXACT
+    if (!choices || !tok || !*tok)
         return NULL;
+
+    for (wcon = choices; *wcon; wcon++) {
+        w = strtail((char *)sel(*wcon), tok);
+        if (!w)
+            /* no match */
+            continue;
+        if (!*w)
+            /* exact match */
+            return *wcon;
+
+        ret = *wcon;
+        mn++;
+    }
+
+#ifdef FORCE_MATCH_EXACT
+    return NULL;
 #else
-        return (mn == 1) ? ret : NULL;
+    return (mn == 1) ? ret : NULL;
 #endif
 }
 
 static const char *
-sel_cmd_word (void *wcon)
+sel_cmd_word(void *wcon)
 {
-        return ((struct cli_cmd_word *)wcon)->word;
+    return ((struct cli_cmd_word *)wcon)->word;
 }
 
 struct cli_cmd_word *
-cli_cmd_nextword (struct cli_cmd_word *word, const char *token)
+cli_cmd_nextword(struct cli_cmd_word *word, const char *token)
 {
-        return (struct cli_cmd_word *)cli_getunamb (token,
-                                                    (void **)word->nextwords,
-                                                    sel_cmd_word);
+    return (struct cli_cmd_word *)cli_getunamb(token, (void **)word->nextwords,
+                                               sel_cmd_word);
 }
 
-
 struct cli_cmd_word *
-cli_cmd_newword (struct cli_cmd_word *word, const char *token)
+cli_cmd_newword(struct cli_cmd_word *word, const char *token)
 {
-        struct cli_cmd_word **nextwords = NULL;
-        struct cli_cmd_word  *nextword = NULL;
+    struct cli_cmd_word **nextwords = NULL;
+    struct cli_cmd_word *nextword = NULL;
 
-        nextwords = realloc (word->nextwords,
-                             (word->nextwords_cnt + 2) * sizeof (*nextwords));
-        if (!nextwords)
-                return NULL;
+    nextwords = realloc(word->nextwords,
+                        (word->nextwords_cnt + 2) * sizeof(*nextwords));
+    if (!nextwords)
+        return NULL;
 
-        word->nextwords = nextwords;
+    word->nextwords = nextwords;
 
-        nextword = calloc (1, sizeof (*nextword));
-        if (!nextword)
-                return NULL;
+    nextword = calloc(1, sizeof(*nextword));
+    if (!nextword)
+        return NULL;
 
-        nextword->word = strdup (token);
-        if (!nextword->word) {
-                free (nextword);
-                return NULL;
-        }
+    nextword->word = strdup(token);
+    if (!nextword->word) {
+        free(nextword);
+        return NULL;
+    }
 
-        nextword->tree = word->tree;
-        nextwords[word->nextwords_cnt++] = nextword;
-        nextwords[word->nextwords_cnt] = NULL;
+    nextword->tree = word->tree;
+    nextwords[word->nextwords_cnt++] = nextword;
+    nextwords[word->nextwords_cnt] = NULL;
 
-        return nextword;
+    return nextword;
 }
 
-
 int
-cli_cmd_ingest (struct cli_cmd_tree *tree, char **tokens, cli_cmd_cbk_t *cbkfn,
-                const char *desc, const char *pattern)
+cli_cmd_ingest(struct cli_cmd_tree *tree, char **tokens, cli_cmd_cbk_t *cbkfn,
+               const char *desc, const char *pattern)
 {
-        int                    ret = 0;
-        char                 **tokenp = NULL;
-        char                  *token = NULL;
-        struct cli_cmd_word   *word = NULL;
-        struct cli_cmd_word   *next = NULL;
-
-        word = &tree->root;
+    int ret = 0;
+    char **tokenp = NULL;
+    char *token = NULL;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
 
-        for (tokenp = tokens; (token = *tokenp); tokenp++) {
-                if (!__is_word (token))
-                        break;
+    word = &tree->root;
 
-                next = cli_cmd_nextword (word, token);
-                if (!next)
-                        next = cli_cmd_newword (word, token);
+    for (tokenp = tokens; (token = *tokenp); tokenp++) {
+        if (!__is_word(token))
+            break;
 
-                word = next;
-                if (!word)
-                        break;
-        }
+        next = cli_cmd_nextword(word, token);
+        if (!next)
+            next = cli_cmd_newword(word, token);
 
+        word = next;
         if (!word)
-                return -1;
+            break;
+    }
 
-        if (word->cbkfn) {
-                /* warning - command already registered */
-        }
+    if (!word)
+        return -1;
 
-        word->cbkfn = cbkfn;
-        word->desc  = desc;
-        word->pattern = pattern;
+    if (word->cbkfn) {
+        /* warning - command already registered */
+    }
 
-        /* end of static strings in command template */
+    word->cbkfn = cbkfn;
+    word->desc = desc;
+    word->pattern = pattern;
 
-        /* TODO: autocompletion beyond this point is just "nice to have" */
+    /* end of static strings in command template */
 
-        return ret;
-}
+    /* TODO: autocompletion beyond this point is just "nice to have" */
 
+    return ret;
+}
 
 int
-cli_cmd_register (struct cli_cmd_tree *tree, struct cli_cmd *cmd)
+cli_cmd_register(struct cli_cmd_tree *tree, struct cli_cmd *cmd)
 {
-        char **tokens = NULL;
-        int    ret = 0;
+    char **tokens = NULL;
+    int ret = 0;
 
-        GF_ASSERT (cmd);
+    GF_ASSERT(cmd);
 
-        if (cmd->reg_cbk)
-                cmd->reg_cbk (cmd);
+    if (cmd->reg_cbk)
+        cmd->reg_cbk(cmd);
 
-        if (cmd->disable) {
-                ret = 0;
-                goto out;
-        }
+    if (cmd->disable) {
+        ret = 0;
+        goto out;
+    }
 
-        tokens = cli_cmd_tokenize (cmd->pattern);
-        if (!tokens) {
-                ret = -1;
-                goto out;
-        }
+    tokens = cli_cmd_tokenize(cmd->pattern);
+    if (!tokens) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_ingest (tree, tokens, cmd->cbk, cmd->desc, cmd->pattern);
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    ret = cli_cmd_ingest(tree, tokens, cmd->cbk, cmd->desc, cmd->pattern);
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (tokens)
-                cli_cmd_tokens_destroy (tokens);
+    if (tokens)
+        cli_cmd_tokens_destroy(tokens);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
-
diff --git a/configure.ac b/configure.ac
index ce689225c5d..e2d6fd66cec 100644
--- a/configure.ac
+++ b/configure.ac
@@ -13,7 +13,7 @@ AC_INIT([glusterfs],
 AC_SUBST([PACKAGE_RELEASE],
          [m4_esyscmd([build-aux/pkg-version --release])])
 
-AM_INIT_AUTOMAKE(tar-pax)
+AM_INIT_AUTOMAKE([tar-pax foreign])
 
 # Removes warnings when using automake 1.14 around (...but option 'subdir-objects' is disabled )
 #but libglusterfs fails to build with contrib (Then are not set up that way?)
@@ -21,30 +21,20 @@ AM_INIT_AUTOMAKE(tar-pax)
 
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES(yes)])
 
-if make --help 2>&1 | grep -q no-print-directory; then
-   AM_MAKEFLAGS="$AM_MAKEFLAGS --no-print-directory";
-fi
-
-if make --help 2>&1 | grep -q quiet; then
-   AM_MAKEFLAGS="$AM_MAKEFLAGS --quiet"
-fi
-
-if libtool --help 2>&1 | grep -q quiet; then
-   AM_LIBTOOLFLAGS="--quiet";
-fi
-
 AC_CONFIG_HEADERS([config.h site.h])
 
 AC_CONFIG_FILES([Makefile
                 libglusterfs/Makefile
                 libglusterfs/src/Makefile
-                libglusterfs/src/gfdb/Makefile
+                libglusterd/Makefile
+                libglusterd/src/Makefile
                 geo-replication/src/peer_gsec_create
                 geo-replication/src/peer_mountbroker
                 geo-replication/src/peer_mountbroker.py
                 geo-replication/src/peer_georep-sshkey.py
                 extras/peer_add_secret_pub
                 geo-replication/syncdaemon/conf.py
+                geo-replication/gsyncd.conf
                 extras/snap_scheduler/conf.py
                 glusterfsd/Makefile
                 glusterfsd/src/Makefile
@@ -54,11 +44,8 @@ AC_CONFIG_FILES([Makefile
                 rpc/rpc-transport/Makefile
                 rpc/rpc-transport/socket/Makefile
                 rpc/rpc-transport/socket/src/Makefile
-                rpc/rpc-transport/rdma/Makefile
-                rpc/rpc-transport/rdma/src/Makefile
                 rpc/xdr/Makefile
                 rpc/xdr/src/Makefile
-                rpc/xdr/gen/Makefile
                 xlators/Makefile
                 xlators/meta/Makefile
                 xlators/meta/src/Makefile
@@ -71,13 +58,9 @@ AC_CONFIG_FILES([Makefile
                 xlators/storage/Makefile
                 xlators/storage/posix/Makefile
                 xlators/storage/posix/src/Makefile
-                xlators/storage/bd/Makefile
-                xlators/storage/bd/src/Makefile
                 xlators/cluster/Makefile
                 xlators/cluster/afr/Makefile
                 xlators/cluster/afr/src/Makefile
-                xlators/cluster/stripe/Makefile
-                xlators/cluster/stripe/src/Makefile
                 xlators/cluster/dht/Makefile
                 xlators/cluster/dht/src/Makefile
                 xlators/cluster/ec/Makefile
@@ -93,16 +76,12 @@ AC_CONFIG_FILES([Makefile
                 xlators/performance/io-threads/src/Makefile
                 xlators/performance/io-cache/Makefile
                 xlators/performance/io-cache/src/Makefile
-                xlators/performance/symlink-cache/Makefile
-                xlators/performance/symlink-cache/src/Makefile
                 xlators/performance/quick-read/Makefile
                 xlators/performance/quick-read/src/Makefile
                 xlators/performance/open-behind/Makefile
                 xlators/performance/open-behind/src/Makefile
                 xlators/performance/md-cache/Makefile
                 xlators/performance/md-cache/src/Makefile
-                xlators/performance/decompounder/Makefile
-                xlators/performance/decompounder/src/Makefile
                 xlators/performance/nl-cache/Makefile
                 xlators/performance/nl-cache/src/Makefile
                 xlators/debug/Makefile
@@ -112,6 +91,8 @@ AC_CONFIG_FILES([Makefile
                 xlators/debug/trace/src/Makefile
                 xlators/debug/error-gen/Makefile
                 xlators/debug/error-gen/src/Makefile
+                xlators/debug/delay-gen/Makefile
+                xlators/debug/delay-gen/src/Makefile
                 xlators/debug/io-stats/Makefile
                 xlators/debug/io-stats/src/Makefile
                 xlators/protocol/Makefile
@@ -127,18 +108,12 @@ AC_CONFIG_FILES([Makefile
                 xlators/features/Makefile
                 xlators/features/arbiter/Makefile
                 xlators/features/arbiter/src/Makefile
+                xlators/features/thin-arbiter/Makefile
+                xlators/features/thin-arbiter/src/Makefile
                 xlators/features/changelog/Makefile
                 xlators/features/changelog/src/Makefile
                 xlators/features/changelog/lib/Makefile
                 xlators/features/changelog/lib/src/Makefile
-                xlators/features/changetimerecorder/Makefile
-                xlators/features/changetimerecorder/src/Makefile
-                xlators/features/glupy/Makefile
-                xlators/features/glupy/examples/Makefile
-                xlators/features/glupy/src/Makefile
-                xlators/features/glupy/src/setup.py
-                xlators/features/glupy/src/__init__.py
-                xlators/features/glupy/src/glupy/Makefile
                 xlators/features/locks/Makefile
                 xlators/features/locks/src/Makefile
                 xlators/features/quota/Makefile
@@ -147,10 +122,14 @@ AC_CONFIG_FILES([Makefile
                 xlators/features/marker/src/Makefile
                 xlators/features/selinux/Makefile
                 xlators/features/selinux/src/Makefile
+                xlators/features/sdfs/Makefile
+                xlators/features/sdfs/src/Makefile
                 xlators/features/read-only/Makefile
                 xlators/features/read-only/src/Makefile
                 xlators/features/compress/Makefile
                 xlators/features/compress/src/Makefile
+                xlators/features/namespace/Makefile
+                xlators/features/namespace/src/Makefile
                 xlators/features/quiesce/Makefile
                 xlators/features/quiesce/src/Makefile
                 xlators/features/barrier/Makefile
@@ -175,14 +154,21 @@ AC_CONFIG_FILES([Makefile
                 xlators/features/bit-rot/src/bitd/Makefile
                 xlators/features/leases/Makefile
                 xlators/features/leases/src/Makefile
+                xlators/features/cloudsync/Makefile
+                xlators/features/cloudsync/src/Makefile
+                xlators/features/utime/Makefile
+                xlators/features/utime/src/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/src/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/src/cloudsyncs3/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/src/cloudsyncs3/src/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/src/cvlt/Makefile
+                xlators/features/cloudsync/src/cloudsync-plugins/src/cvlt/src/Makefile
+                xlators/features/metadisp/Makefile
+                xlators/features/metadisp/src/Makefile
                 xlators/playground/Makefile
                 xlators/playground/template/Makefile
                 xlators/playground/template/src/Makefile
-                xlators/encryption/Makefile
-                xlators/encryption/rot-13/Makefile
-                xlators/encryption/rot-13/src/Makefile
-                xlators/encryption/crypt/Makefile
-                xlators/encryption/crypt/src/Makefile
                 xlators/system/Makefile
                 xlators/system/posix-acl/Makefile
                 xlators/system/posix-acl/src/Makefile
@@ -207,10 +193,15 @@ AC_CONFIG_FILES([Makefile
                 extras/init.d/glustereventsd-Debian
                 extras/init.d/glustereventsd-Redhat
                 extras/init.d/glustereventsd-FreeBSD
+                extras/ganesha/Makefile
+                extras/ganesha/config/Makefile
+                extras/ganesha/scripts/Makefile
+                extras/ganesha/ocf/Makefile
                 extras/systemd/Makefile
                 extras/systemd/glusterd.service
                 extras/systemd/glustereventsd.service
                 extras/systemd/glusterfssharedstorage.service
+                extras/systemd/gluster-ta-volume.service
                 extras/run-gluster.tmpfiles
                 extras/benchmarking/Makefile
                 extras/hook-scripts/Makefile
@@ -237,6 +228,7 @@ AC_CONFIG_FILES([Makefile
                 extras/hook-scripts/reset/Makefile
                 extras/hook-scripts/reset/post/Makefile
                 extras/hook-scripts/reset/pre/Makefile
+                extras/python/Makefile
                 extras/snap_scheduler/Makefile
                 events/Makefile
                 events/src/Makefile
@@ -244,10 +236,8 @@ AC_CONFIG_FILES([Makefile
                 events/tools/Makefile
                 contrib/fuse-util/Makefile
                 contrib/umountd/Makefile
-                contrib/uuid/uuid_types.h
                 glusterfs-api.pc
                 libgfchangelog.pc
-                libgfdb.pc
                 api/Makefile
                 api/src/Makefile
                 api/examples/Makefile
@@ -259,9 +249,9 @@ AC_CONFIG_FILES([Makefile
                 heal/Makefile
                 heal/src/Makefile
                 glusterfs.spec
-		tools/glusterfind/src/tool.conf
-	        tools/glusterfind/glusterfind
-	        tools/glusterfind/Makefile
+                tools/glusterfind/src/tool.conf
+                tools/glusterfind/glusterfind
+                tools/glusterfind/Makefile
                 tools/glusterfind/src/Makefile
                 tools/setgfid2path/Makefile
                 tools/setgfid2path/src/Makefile])
@@ -285,12 +275,116 @@ AC_ARG_ENABLE([debug],
                              [Enable debug build options.]))
 if test "x$enable_debug" = "xyes"; then
         BUILD_DEBUG=yes
-        CFLAGS="${CFLAGS} -g -rdynamic -O0 -DDEBUG"
+        GF_CFLAGS="${GF_CFLAGS} -g -O0 -DDEBUG"
 else
         BUILD_DEBUG=no
-        CFLAGS="${CFLAGS} -g -rdynamic"
 fi
 
+SANITIZER=none
+
+AC_ARG_ENABLE([asan],
+              AC_HELP_STRING([--enable-asan],
+                             [Enable Address Sanitizer support]))
+if test "x$enable_asan" = "xyes"; then
+        SANITIZER=asan
+        AC_CHECK_LIB([asan], [__asan_init], ,
+                [AC_MSG_ERROR([--enable-asan requires libasan.so, exiting])])
+        GF_CFLAGS="${GF_CFLAGS} -O2 -g -fsanitize=address -fno-omit-frame-pointer"
+        GF_LDFLAGS="${GF_LDFLAGS} -lasan"
+fi
+
+AC_ARG_ENABLE([tsan],
+              AC_HELP_STRING([--enable-tsan],
+                             [Enable Thread Sanitizer support]))
+if test "x$enable_tsan" = "xyes"; then
+        if test "x$SANITIZER" != "xnone"; then
+                AC_MSG_ERROR([only one sanitizer can be enabled at once])
+        fi
+        SANITIZER=tsan
+        AC_CHECK_LIB([tsan], [__tsan_init], ,
+                [AC_MSG_ERROR([--enable-tsan requires libtsan.so, exiting])])
+        if test "x$ac_cv_lib_tsan___tsan_init" = xyes; then
+                AC_MSG_CHECKING([whether tsan API can be used])
+                saved_CFLAGS=${CFLAGS}
+                CFLAGS="${CFLAGS} -fsanitize=thread"
+                AC_COMPILE_IFELSE(
+                [AC_LANG_PROGRAM([
+                   [#include <sanitizer/tsan_interface.h>]],
+                   [[__tsan_create_fiber(0)]])],
+                   [TSAN_API=yes], [TSAN_API=no])
+                AC_MSG_RESULT([$TSAN_API])
+                if test x$TSAN_API = "xyes"; then
+                   AC_DEFINE(HAVE_TSAN_API, 1, [Define if tsan API can be used.])
+                fi
+                CFLAGS=${saved_CFLAGS}
+        fi
+        GF_CFLAGS="${GF_CFLAGS} -O2 -g -fsanitize=thread -fno-omit-frame-pointer"
+        GF_LDFLAGS="${GF_LDFLAGS} -ltsan"
+fi
+
+AC_ARG_ENABLE([ubsan],
+              AC_HELP_STRING([--enable-ubsan],
+                             [Enable Undefined Behavior Sanitizer support]))
+if test "x$enable_ubsan" = "xyes"; then
+        if test "x$SANITIZER" != "xnone"; then
+                AC_MSG_ERROR([only one sanitizer can be enabled at once])
+        fi
+        SANITIZER=ubsan
+        AC_CHECK_LIB([ubsan], [__ubsan_default_options], ,
+                [AC_MSG_ERROR([--enable-ubsan requires libubsan.so, exiting])])
+        GF_CFLAGS="${GF_CFLAGS} -O2 -g -fsanitize=undefined -fno-omit-frame-pointer"
+        GF_LDFLAGS="${GF_LDFLAGS} -lubsan"
+fi
+
+# Initialize CFLAGS before usage
+BUILD_TCMALLOC=no
+AC_ARG_ENABLE([tcmalloc],
+              AC_HELP_STRING([--enable-tcmalloc],
+                             [Enable linking with tcmalloc library.]))
+if test "x$enable_tcmalloc" = "xyes"; then
+    BUILD_TCMALLOC=yes
+    GF_CFLAGS="${GF_CFLAGS} -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free"
+    AC_CHECK_LIB([tcmalloc], [malloc], [],
+                 [AC_MSG_ERROR([when --enable-tcmalloc is used, tcmalloc library needs to be present])])
+    GF_LDFLAGS="-ltcmalloc ${GF_LDFLAGS}"
+fi
+
+
+dnl When possible, prefer libtirpc over glibc rpc.
+dnl
+dnl On newer linux with only libtirpc, use libtirpc. (Specifying
+dnl --without-libtirpc is an error.)
+dnl
+dnl on older linux with glibc rpc and WITH libtirpc, use libtirpc
+dnl by default except when configured with --without-libtirpc.
+dnl
+dnl on old linux with glibc rpc and WITHOUT libtirpc, default to
+dnl use glibc rpc.
+dnl
+AC_ARG_WITH([libtirpc],
+        [AC_HELP_STRING([--without-libtirpc], [Use legacy glibc RPC.])],
+        [with_libtirpc="no"], [with_libtirpc="yes"])
+
+dnl ipv6-default is off by default
+dnl
+dnl ipv6-default requires libtirpc. (glibc rpc does not support IPv6.)
+dnl ipv6-default can only be enabled if libtipc is enabled.
+dnl
+AC_ARG_WITH([ipv6-default],
+        AC_HELP_STRING([--with-ipv6-default], [Set IPv6 as default.]),
+        [with_ipv6_default=${with_libtirpc}], [with_ipv6_default="no"])
+
+AC_CHECK_FILE([/etc/centos-release])
+if test "x$ac_cv_file__etc_centos_release" = "xyes"; then
+        if grep "release 6" /etc/centos-release; then
+                with_ipv6_default="no"
+        fi
+fi
+
+dnl On some distributions '-ldl' isn't automatically added to LIBS
+AC_CHECK_LIB([dl], [dlopen], [LIB_DL=-ldl])
+AC_SUBST(LIB_DL)
+
 AC_ARG_ENABLE([privport_tracking],
               AC_HELP_STRING([--disable-privport_tracking],
                              [Disable internal tracking of privileged ports.]))
@@ -308,19 +402,34 @@ case $host_os in
     fi
     # OSX version lesser than 9 has llvm/clang optimization issues which leads to various segfaults
     if test "`/usr/bin/sw_vers | grep ProductVersion: | cut -f 2 | cut -d. -f2`" -lt 9; then
-       CFLAGS="${CFLAGS} -g -O0 -DDEBUG"
+       GF_CFLAGS="${GF_CFLAGS} -g -O0 -DDEBUG"
     fi
     ;;
 esac
 
 # --enable-valgrind prevents calling dlclose(), this leaks memory
 AC_ARG_ENABLE([valgrind],
-              AC_HELP_STRING([--enable-valgrind],
-                             [Enable valgrind for resource leak debugging.]))
-if test "x$enable_valgrind" = "xyes"; then
-        AC_DEFINE(RUN_WITH_VALGRIND, 1, [define if all processes should run under valgrind])
-fi
-
+              AC_HELP_STRING([--enable-valgrind@<:@=memcheck,drd@:>@],
+                             [Enable valgrind for resource leak (memcheck, which is
+                              the default) or thread synchronization (drd) debugging.]))
+case x$enable_valgrind in
+  xmemcheck|xyes)
+    AC_DEFINE(RUN_WITH_MEMCHECK, 1,
+              [Define if all processes should run under 'valgrind --tool=memcheck'.])
+    VALGRIND_TOOL=memcheck
+    ;;
+  xdrd)
+    AC_DEFINE(RUN_WITH_DRD, 1,
+              [Define if all processes should run under 'valgrind --tool=drd'.])
+    VALGRIND_TOOL=drd
+    ;;
+  x|xno)
+    VALGRIND_TOOL=no
+    ;;
+  *)
+    AC_MSG_ERROR([Please specify --enable-valgrind@<:@=memcheck,drd@:>@])
+    ;;
+esac
 
 AC_ARG_WITH([previous-options],
         [AS_HELP_STRING([--with-previous-options],
@@ -328,7 +437,7 @@ AC_ARG_WITH([previous-options],
         ],
         [ if test -r ./config.status && \
              args=$(grep 'ac_cs_config=' config.status | \
-                    sed -e 's/.*"\(.*\)".*/\1/'| sed -e "s/'//g") ; then
+                    sed -e 's/.*"\(.*\)".*/\1/' -e "s/'//g" -e "s/--with-previous-options//g") ; then
             echo "###"
             echo "### Rerunning as '$0 $args'"
             echo "###"
@@ -381,6 +490,13 @@ AC_ARG_WITH([ocf],
             )
 AC_SUBST(OCF_SUBDIR)
 
+AC_ARG_WITH([server],
+            [AS_HELP_STRING([--without-server], [do not build server components])],
+            [with_server='no'],
+            [with_server='yes'],
+            )
+AM_CONDITIONAL([WITH_SERVER], [test x$with_server = xyes])
+
 # LEX needs a check
 AC_PROG_LEX
 if test  "x${LEX}" != "xflex" -a "x${FLEX}" != "xlex"; then
@@ -431,17 +547,18 @@ AC_CHECK_HEADERS([openssl/dh.h])
 
 AC_CHECK_HEADERS([openssl/ecdh.h])
 
+AC_CHECK_LIB([ssl], [SSL_CTX_get0_param], [AC_DEFINE([HAVE_SSL_CTX_GET0_PARAM], [1], [define if found OpenSSL SSL_CTX_get0_param])])
+
 dnl Math library
 AC_CHECK_LIB([m], [pow], [MATH_LIB='-lm'], [MATH_LIB=''])
 AC_SUBST(MATH_LIB)
 
-dnl use libuuid.so or fall-back to contrib/uuid
+dnl depend on libuuid.so
 PKG_CHECK_MODULES([UUID], [uuid],
         [have_uuid=yes
          AC_DEFINE(HAVE_LIBUUID, 1, [have libuuid.so])
          PKGCONFIG_UUID=uuid],
-        [have_uuid=no
-         UUID_CFLAGS='-I$(CONTRIBDIR)/uuid'])
+        [have_uuid=no])
 AM_CONDITIONAL([HAVE_LIBUUID], [test x$have_uuid = xyes])
 
 dnl older version of libuuid (from e2fsprogs) require including uuid/uuid.h
@@ -455,10 +572,25 @@ AC_CHECK_HEADER([uuid.h], [], [AC_CHECK_HEADER([uuid/uuid.h])],
 CFLAGS=${saved_CFLAGS}
 if test "x$ac_cv_header_uuid_uuid_h" = "xyes"; then
     UUID_CFLAGS="${UUID_CFLAGS} -I$(pkg-config --variable=includedir uuid)/uuid"
+    have_uuid=yes
+fi
+
+if test "x$have_uuid" != "xyes"; then
+    case $host_os in
+        *freebsd*)
+            AC_MSG_ERROR([e2fsprogs-libuuid is required to build glusterfs])
+            ;;
+        linux*)
+            AC_MSG_ERROR([libuuid is required to build glusterfs])
+            ;;
+        *)
+            AC_MSG_ERROR([a Linux compatible libuuid is required to build glusterfs])
+            ;;
+    esac
 fi
 
 dnl libglusterfs needs uuid.h, practically everything depends on it
-GF_CPPFLAGS="${GF_CPPFLAGS} ${UUID_CFLAGS}"
+GF_CFLAGS="${GF_CFLAGS} ${UUID_CFLAGS}"
 dnl PKGCONFIG_UUID is used for the dependency in *.pc.in files
 AC_SUBST(PKGCONFIG_UUID)
 
@@ -537,48 +669,54 @@ fi
 
 dnl Check Python Availability
 have_python=no
-AM_PATH_PYTHON(,, [:])
-if test "$PYTHON" != ":"; then
+dnl if the user has not specified a python, pick one
+if test -z "${PYTHON}"; then
+  case $host_os in
+    freebsd*)
+      if test -x /usr/local/bin/python3; then
+        PYTHON=/usr/local/bin/python3
+      else
+        PYTHON=/usr/local/bin/python2
+      fi
+      ;;
+    *)
+      if test -x /usr/bin/python3; then
+        PYTHON=/usr/bin/python3
+      else
+        PYTHON=/usr/bin/python2
+      fi
+      ;;
+  esac
+fi
+AM_PATH_PYTHON([2.6],,[:])
+if test -n "${PYTHON}"; then
    have_python=yes
 fi
+AM_CONDITIONAL(HAVE_PYTHON, test "x$have_python" = "xyes")
 
-dnl Check if version matches that we require
-PYTHONDEV_CPPFLAGS=
-PYTHONDEV_LDFLAGS=
-BUILD_PYTHON_SITE_PACKAGES=
-BUILD_PYTHON_INC=
-BUILD_PYTHON_LIB=
-have_python2=no
-have_Python_h=no
-
-if echo $PYTHON_VERSION | grep -q ^2; then
-   have_python2=yes
-
-   dnl Use pkg-config to get runtime search patch missing from ${PYTHON}-config
-   dnl Just do "true" on failure so that configure does not bail out
-   PKG_CHECK_MODULES([PYTHON], "python-$PYTHON_VERSION",,true)
-
-   PYTHONDEV_CPPFLAGS="`${PYTHON}-config --cflags`"
-   dnl Edit out the flags that are not required or are conflicting
-   PYTHONDEV_CPPFLAGS=`echo ${PYTHONDEV_CPPFLAGS} | sed -e 's/-Wp,-D_FORTIFY_SOURCE=[[0-9]]//g'`
-
-   dnl Find python libs at user configured libdir and also "lib" under prefix
-   PYTHONDEV_LDFLAGS="${PYTHON_LIBS} -L`${PYTHON}-config --prefix`/lib -L`${PYTHON}-config --prefix`/$libdir `${PYTHON}-config --ldflags`"
-
-   BUILD_PYTHON_SITE_PACKAGES=${pythondir}
-   BUILD_PYTHON_INC=`$PYTHON -c "import sys; from distutils import sysconfig; sys.stdout.write(sysconfig.get_python_inc())" 2>/dev/null`
-   BUILD_PYTHON_LIB=python$PYTHON_VERSION
-
-   dnl Now check for python header using the include path obtained above
-   AC_CHECK_HEADERS([${BUILD_PYTHON_INC}/Python.h],[have_Python_h=yes],[])
+dnl Use pkg-config to get runtime search path missing from ${PYTHON}-config
+dnl Just do "true" on failure so that configure does not bail out
+dnl Note: python 2.6's devel pkg (e.g. in CentOS/RHEL 6) does not have
+dnl pkg-config files, so this work-around instead
+if test "x${PYTHON_VERSION}" = "x2.6"; then
+  PYTHON_CFLAGS=$(python-config --includes)
+  PYTHON_LIBS=$(python-config --libs)
+else
+  PKG_CHECK_MODULES([PYTHON], "python-${PYTHON_VERSION}",,true)
 fi
 
-AC_SUBST(PYTHONDEV_CPPFLAGS)
-AC_SUBST(PYTHONDEV_LDFLAGS)
+PYTHON_CFLAGS=$(echo ${PYTHON_CFLAGS} | sed -e 's|-I|-isystem |')
+
+BUILD_PYTHON_SITE_PACKAGES=${pythondir}
 AC_SUBST(BUILD_PYTHON_SITE_PACKAGES)
-AC_SUBST(BUILD_PYTHON_INC)
-AC_SUBST(BUILD_PYTHON_LIB)
 
+# Eval two times to expand fully. First eval replaces $exec_prefix into $prefix
+# Second eval will expand $prefix
+build_python_site_packages_temp="${pythondir}"
+eval build_python_site_packages_temp=\"${build_python_site_packages_temp}\"
+eval build_python_site_packages_temp=\"${build_python_site_packages_temp}\"
+BUILD_PYTHON_SITE_PACKAGES_EXPANDED=${build_python_site_packages_temp}
+AC_SUBST(BUILD_PYTHON_SITE_PACKAGES_EXPANDED)
 
 # FUSE section
 AC_ARG_ENABLE([fuse-client],
@@ -591,45 +729,17 @@ if test "x$enable_fuse_client" != "xno"; then
    BUILD_FUSE_CLIENT="yes"
 fi
 
-AC_ARG_ENABLE([bd-xlator],
-              AC_HELP_STRING([--enable-bd-xlator], [Build BD xlator]))
-
-if test "x$enable_bd_xlator" != "xno"; then
-  AC_CHECK_LIB([lvm2app],
-               [lvm_init,lvm_lv_from_name],
-               [HAVE_BD_LIB="yes"],
-               [HAVE_BD_LIB="no"])
-
-if test "x$HAVE_BD_LIB" = "xyes"; then
-    # lvm_lv_from_name() has been made public with lvm2-2.02.79
-    AC_CHECK_DECLS(
-                  [lvm_lv_from_name],
-                  [NEED_LVM_LV_FROM_NAME_DECL="no"],
-                  [NEED_LVM_LV_FROM_NAME_DECL="yes"],
-                  [[#include <lvm2app.h>]])
-  fi
-fi
+AC_SUBST(FUSE_CLIENT_SUBDIR)
 
-if test "x$enable_bd_xlator" = "xyes" -a "x$HAVE_BD_LIB" = "xno"; then
-   echo "BD xlator requested but required lvm2 development library not found."
-   exit 1
-fi
+AC_ARG_ENABLE([fuse-notifications],
+  AS_HELP_STRING([--disable-fuse-notifications], [Disable FUSE notifications]))
 
-BUILD_BD_XLATOR=no
-if test "x${enable-bd-xlator}" != "xno" -a "x${HAVE_BD_LIB}" = "xyes"; then
-  BUILD_BD_XLATOR=yes
-  AC_DEFINE(HAVE_BD_XLATOR, 1, [define if lvm2app library found and bd xlator
-                            enabled])
-  if test "x$NEED_LVM_LV_FROM_NAME_DECL" = "xyes"; then
-    AC_DEFINE(NEED_LVM_LV_FROM_NAME_DECL, 1, [defined if lvm_lv_from_name()
-                  was not found in the lvm2app.h header, but can be linked])
-  fi
-fi
+AS_IF([test "x$enable_fuse_notifications" != "xno"], [
+  AC_DEFINE([HAVE_FUSE_NOTIFICATIONS], [1], [Use FUSE notifications])
+])
 
-AM_CONDITIONAL([ENABLE_BD_XLATOR], [test x$BUILD_BD_XLATOR = xyes])
+# end FUSE section
 
-dnl check for old openssl
-AC_CHECK_LIB([crypto], CRYPTO_THREADID_set_callback, [AC_DEFINE([HAVE_CRYPTO_THREADID], [1], [use new OpenSSL functions])])
 
 AC_CHECK_LIB([ssl], TLS_method, [HAVE_OPENSSL_1_1="yes"], [HAVE_OPENSSL_1_1="no"])
 if test "x$HAVE_OPENSSL_1_1" = "xyes"; then
@@ -638,28 +748,6 @@ else
     AC_CHECK_LIB([ssl], TLSv1_2_method, [AC_DEFINE([HAVE_TLSV1_2_METHOD], [1], [Using OpenSSL-1.0 TLSv1_2_method])])
 fi
 
-# start encryption/crypt section
-
-AC_CHECK_HEADERS([openssl/cmac.h], [have_cmac_h=yes], [have_cmac_h=no])
-
-AC_ARG_ENABLE([crypt-xlator],
-        AC_HELP_STRING([--enable-crypt-xlator], [Build crypt encryption xlator]))
-
-if test "x$enable_crypt_xlator" = "xyes" -a "x$have_cmac_h" = "xno"; then
-   AC_MSG_ERROR([Encryption xlator requires OpenSSL with cmac.h])
-fi
-
-BUILD_CRYPT_XLATOR=no
-if test "x$enable_crypt_xlator" != "xno" -a "x$have_cmac_h" = "xyes"; then
-   BUILD_CRYPT_XLATOR=yes
-   AC_DEFINE(HAVE_CRYPT_XLATOR, 1, [enable building crypt encryption xlator])
-fi
-
-AM_CONDITIONAL([ENABLE_CRYPT_XLATOR], [test x$BUILD_CRYPT_XLATOR = xyes])
-
-AC_SUBST(FUSE_CLIENT_SUBDIR)
-# end FUSE section
-
 
 # FUSERMOUNT section
 AC_ARG_ENABLE([fusermount],
@@ -690,53 +778,6 @@ if test "x$enable_epoll" != "xno"; then
 fi
 # end EPOLL section
 
-
-# IBVERBS section
-AC_ARG_ENABLE([ibverbs],
-              AC_HELP_STRING([--disable-ibverbs],
-                             [Do not build the ibverbs transport]))
-
-if test "x$enable_ibverbs" != "xno"; then
-  AC_CHECK_LIB([ibverbs],
-               [ibv_get_device_list],
-               [HAVE_LIBIBVERBS="yes"],
-               [HAVE_LIBIBVERBS="no"])
-  AC_CHECK_LIB([rdmacm], [rdma_create_id], [HAVE_RDMACM="yes"], [HAVE_RDMACM="no"])
-  if test "x$HAVE_RDMACM" = "xyes" ; then
-    AC_CHECK_DECLS(
-                  [RDMA_OPTION_ID_REUSEADDR],
-                  [],
-                  [AC_ERROR([Need at least version 1.0.15 of librdmacm])],
-                  [[#include <rdma/rdma_cma.h>]])
-  fi
-fi
-
-if test "x$enable_ibverbs" = "xyes"; then
-   if test "x$HAVE_LIBIBVERBS" = "xno"; then
-      echo "ibverbs-transport requested, but libibverbs is not present."
-      exit 1
-   fi
-
-   if test "x$HAVE_RDMACM" = "xno"; then
-      echo "ibverbs-transport requested, but librdmacm is not present."
-      exit 1
-   fi
-fi
-
-BUILD_RDMA=no
-BUILD_IBVERBS=no
-if test "x$enable_ibverbs" != "xno" -a "x$HAVE_LIBIBVERBS" = "xyes" -a "x$HAVE_RDMACM" = "xyes"; then
-  IBVERBS_SUBDIR=ib-verbs
-  BUILD_IBVERBS=yes
-  RDMA_SUBDIR=rdma
-  BUILD_RDMA=yes
-fi
-
-AC_SUBST(IBVERBS_SUBDIR)
-AC_SUBST(RDMA_SUBDIR)
-# end IBVERBS section
-
-
 # SYNCDAEMON section
 AC_ARG_ENABLE([georeplication],
               AC_HELP_STRING([--disable-georeplication],
@@ -744,6 +785,9 @@ AC_ARG_ENABLE([georeplication],
 
 BUILD_SYNCDAEMON=no
 case $host_os in
+     freebsd*)
+#do nothing
+       ;;
      linux*)
 #do nothing
        ;;
@@ -756,25 +800,20 @@ case $host_os in
         ;;
 esac
 SYNCDAEMON_COMPILE=0
-if test "x$enable_georeplication" != "xno"; then
-  SYNCDAEMON_SUBDIR=geo-replication
-  SYNCDAEMON_COMPILE=1
-
-  BUILD_SYNCDAEMON="yes"
-  AM_PATH_PYTHON([2.4])
-  echo -n "checking if python is python 2.x... "
-  if echo $PYTHON_VERSION | grep ^2; then
-    :
+if test "x${with_server}" = "xyes" -a "x${enable_georeplication}" != "xno"; then
+  if test "x${have_python}" = "xno" ; then
+    AC_MSG_ERROR([only python 2 and 3 are supported])
   else
-    echo no
-    AC_MSG_ERROR([only python 2.x is supported])
-  fi
-  echo -n "checking if python has ctypes support... "
-  if "$PYTHON" -c 'import ctypes' 2>/dev/null; then
-    echo yes
-  else
-    echo no
-    AC_MSG_ERROR([python does not have ctypes support])
+    SYNCDAEMON_SUBDIR=geo-replication
+    SYNCDAEMON_COMPILE=1
+
+    BUILD_SYNCDAEMON="yes"
+    AC_MSG_CHECKING([if python has ctypes support...])
+    if "${PYTHON}" -c 'import ctypes' 2>/dev/null; then
+      AC_MSG_RESULT("yes")
+    else
+      AC_MSG_ERROR([python does not have ctypes support])
+    fi
   fi
 fi
 AC_SUBST(SYNCDAEMON_COMPILE)
@@ -782,12 +821,23 @@ AC_SUBST(SYNCDAEMON_SUBDIR)
 # end SYNCDAEMON section
 
 # only install scripts from extras/geo-rep when enabled
-if test "x$enable_georeplication" != "xno"; then
+if test "x${with_server}" = "xyes" -a "x$enable_georeplication" != "xno"; then
   GEOREP_EXTRAS_SUBDIR=geo-rep
 fi
 AC_SUBST(GEOREP_EXTRAS_SUBDIR)
 AM_CONDITIONAL(USE_GEOREP, test "x$enable_georeplication" != "xno")
 
+# METADISP section
+AC_ARG_ENABLE([metadisp],
+              AC_HELP_STRING([--enable-metadisp],
+                             [Enable the metadata dispersal xlator]))
+BUILD_METADISP=no
+if test "x${enable_metadisp}" = "xyes"; then
+  BUILD_METADISP=yes
+fi
+AM_CONDITIONAL([BUILD_METADISP], [test "x$BUILD_METADISP" = "xyes"])
+# end METADISP section
+
 # Events section
 AC_ARG_ENABLE([events],
               AC_HELP_STRING([--disable-events],
@@ -802,11 +852,11 @@ if test "x$enable_events" != "xno"; then
 
   BUILD_EVENTS="yes"
 
-  if test "x$have_python2" = "xno"; then
-     if test "x$enable_events" = "xyes"; then
-        AC_MSG_ERROR([python 2.x packages required. exiting..])
+  if test "x${have_python}" = "xno"; then
+     if test "x${enable_events}" = "xyes"; then
+        AC_MSG_ERROR([python 2 or 3 required. exiting.])
      fi
-     AC_MSG_WARN([python 2.x not found, disabling events])
+     AC_MSG_WARN([python not found, disabling events])
      EVENTS_SUBDIR=
      EVENTS_ENABLED=0
      BUILD_EVENTS="no"
@@ -816,7 +866,7 @@ if test "x$enable_events" != "xno"; then
 fi
 AC_SUBST(EVENTS_ENABLED)
 AC_SUBST(EVENTS_SUBDIR)
-AM_CONDITIONAL([BUILD_EVENTS], [test x$BUILD_EVENTS = xyes])
+AM_CONDITIONAL([BUILD_EVENTS], [test "x${BUILD_EVENTS}" = "xyes"])
 # end Events section
 
 # CDC xlator - check if libz is present if so enable HAVE_LIB_Z
@@ -842,7 +892,7 @@ AC_ARG_ENABLE([firewalld],
                              [enable installation configuration for firewalld]),
               [BUILD_FIREWALLD="${enableval}"], [BUILD_FIREWALLD="no"])
 
-if test "x${BUILD_FIREWALLD}" = "xyes"; then
+if test "x${with_server}" = "xyes" -a "x${BUILD_FIREWALLD}" = "xyes"; then
         if !(test -d /usr/lib/firewalld/services 1>/dev/null 2>&1) ; then
                 BUILD_FIREWALLD="no (firewalld not installed)"
         fi
@@ -851,41 +901,13 @@ AM_CONDITIONAL([USE_FIREWALLD],test ["x${BUILD_FIREWALLD}" =  "xyes"])
 
 #endof firewald section
 
-# Data tiering requires sqlite
-AC_ARG_ENABLE([tiering],
-               AC_HELP_STRING([--disable-tiering],
-                             [Disable data classification/tiering]),
-              [BUILD_GFDB="${enableval}"], [BUILD_GFDB="yes"])
-
-case $host_os in
-  darwin*)
-    SQLITE_LIBS="-lsqlite3"
-    AC_CHECK_HEADERS([sqlite3.h], AC_DEFINE(USE_GFDB, 1))
-    ;;
-  *)
-    if test "x${BUILD_GFDB}" = "xyes"; then
-      PKG_CHECK_MODULES([SQLITE], [sqlite3],
-                        AC_DEFINE(USE_GFDB, 1),
-                        AC_MSG_ERROR([pass --disable-tiering to build without sqlite]))
-    else
-      AC_DEFINE(USE_GFDB, 0, [no sqlite, gfdb is disabled])
-    fi
-    ;;
-esac
-
-AC_SUBST(SQLITE_CFLAGS)
-AC_SUBST(SQLITE_LIBS)
-AM_CONDITIONAL(BUILD_GFDB, test "x${BUILD_GFDB}" = "xyes")
-AM_CONDITIONAL(USE_GFDB, test "x${BUILD_GFDB}" = "xyes")
-
 # xml-output
 AC_ARG_ENABLE([xml-output],
               AC_HELP_STRING([--disable-xml-output],
                              [Disable the xml output]))
 BUILD_XML_OUTPUT="yes"
 if test "x$enable_xml_output" != "xno"; then
-    #check if libxml is present if so enable HAVE_LIB_XML
-    m4_ifdef([AM_PATH_XML2],[AM_PATH_XML2([2.6.19])], [no_xml=yes])
+    PKG_CHECK_MODULES([XML], [libxml-2.0], [], [no_xml="yes"])
     if test "x${no_xml}" = "x"; then
         AC_DEFINE([HAVE_LIB_XML], [1], [Define to 1 if using libxml2.])
     else
@@ -905,6 +927,34 @@ else
 fi
 # end of xml-output
 
+dnl cloudsync section
+BUILD_CLOUDSYNC="no"
+AC_CHECK_LIB([curl], [curl_easy_setopt], [LIBCURL="-lcurl"])
+if test -n "$LIBCURL";then
+        HAVE_LIBCURL="yes"
+fi
+AC_CHECK_HEADERS([openssl/hmac.h openssl/evp.h openssl/bio.h openssl/buffer.h], [HAVE_OPENSSL="yes"])
+if test "x$HAVE_LIBCURL" = "xyes" -a "x$HAVE_OPENSSL" = "xyes";then
+   HAVE_AMAZONS3="yes"
+fi
+AM_CONDITIONAL([BUILD_AMAZONS3_PLUGIN], [test "x$HAVE_AMAZONS3" = "xyes"])
+if test "x$HAVE_AMAZONS3" = "xyes";then
+   BUILD_CLOUDSYNC="yes"
+fi
+BUILD_CVLT_PLUGIN="no"
+case $host_os in
+#enable cvlt plugin only for linux platforms
+     linux*)
+       BUILD_CVLT_PLUGIN="yes"
+       BUILD_CLOUDSYNC="yes"
+       ;;
+     *)
+       ;;
+esac
+AM_CONDITIONAL([BUILD_CVLT_PLUGIN], [test "x$BUILD_CVLT_PLUGIN" = "xyes"])
+AM_CONDITIONAL([BUILD_CLOUDSYNC], [test "x$BUILD_CLOUDSYNC" = "xyes"])
+dnl end cloudsync section
+
 dnl SELinux feature enablement
 case $host_os in
   linux*)
@@ -926,6 +976,25 @@ if test "x${have_backtrace}" = "xyes"; then
 fi
 AC_SUBST(HAVE_BACKTRACE)
 
+dnl Old (before C11) compiler can compile (but not link) this:
+dnl
+dnl int main () {
+dnl     _Static_assert(1, "True");
+dnl     return 0;
+dnl }
+dnl
+dnl assuming that _Static_assert is an implicitly declared function. So
+dnl we're trying to link just to make sure that this is not the case.
+
+AC_MSG_CHECKING([whether $CC supports C11 _Static_assert])
+AC_TRY_LINK([], [_Static_assert(1, "True");],
+            [STATIC_ASSERT=yes], [STATIC_ASSERT=no])
+
+AC_MSG_RESULT([$STATIC_ASSERT])
+if test x$STATIC_ASSERT = "xyes"; then
+   AC_DEFINE(HAVE_STATIC_ASSERT, 1, [Define if C11 _Static_assert is supported.])
+fi
+
 if test "x${have_backtrace}" != "xyes"; then
 AC_TRY_COMPILE([#include <math.h>], [double x=0.0; x=ceil(0.0);],
    [],
@@ -933,11 +1002,11 @@ AC_TRY_COMPILE([#include <math.h>], [double x=0.0; x=ceil(0.0);],
 fi
 
 dnl glusterfs prints memory usage to stderr by sending it SIGUSR1
-AC_CHECK_FUNC([malloc_stats], [have_malloc_stats=yes])
-if test "x${have_malloc_stats}" = "xyes"; then
-   AC_DEFINE(HAVE_MALLOC_STATS, 1, [define if found malloc_stats])
+AC_CHECK_FUNC([mallinfo], [have_mallinfo=yes])
+if test "x${have_mallinfo}" = "xyes"; then
+   AC_DEFINE(HAVE_MALLINFO, 1, [define if found mallinfo])
 fi
-AC_SUBST(HAVE_MALLOC_STATS)
+AC_SUBST(HAVE_MALLINFO)
 
 dnl Linux, Solaris, Cygwin
 AC_CHECK_MEMBERS([struct stat.st_atim.tv_nsec])
@@ -945,7 +1014,7 @@ dnl FreeBSD, NetBSD
 AC_CHECK_MEMBERS([struct stat.st_atimespec.tv_nsec])
 case $host_os in
         *netbsd*)
-        CFLAGS="${CFLAGS} -D_INCOMPLETE_XOPEN_C063 -DCONFIG_MACHINE_BSWAP_H"
+        GF_CFLAGS="${GF_CFLAGS} -D_INCOMPLETE_XOPEN_C063 -DCONFIG_MACHINE_BSWAP_H"
         ;;
 esac
 AC_CHECK_FUNC([linkat], [have_linkat=yes])
@@ -958,38 +1027,42 @@ dnl check for Monotonic clock
 AC_CHECK_LIB([rt], [clock_gettime], ,
              AC_MSG_WARN([System doesn't have monotonic clock using contrib]))
 
-dnl Check for argp
+dnl check for argp, FreeBSD has the header in /usr/local/include
+case $host_os in
+    *freebsd*)
+    CFLAGS="${CFLAGS} -isystem /usr/local/include"
+    ARGP_LDADD=-largp
+    ;;
+    *netbsd*)
+    ARGP_LDADD=-largp
+    ;;
+esac
+dnl argp-standalone does not provide a pkg-config file
 AC_CHECK_HEADER([argp.h], AC_DEFINE(HAVE_ARGP, 1, [have argp]))
-
-BUILD_ARGP_STANDALONE=no
-if test "x${ac_cv_header_argp_h}" = "xno"; then
-   AC_CONFIG_SUBDIRS(contrib/argp-standalone)
-   BUILD_ARGP_STANDALONE=yes
-   ARGP_STANDALONE_CPPFLAGS='-I${top_srcdir}/contrib/argp-standalone'
-   ARGP_STANDALONE_LDADD='${top_builddir}/contrib/argp-standalone/libargp.a'
-   ARGP_STANDALONE_DIR='${top_builddir}/contrib/argp-standalone'
+if test "x$ac_cv_header_argp_h" != "xyes"; then
+    AC_MSG_ERROR([argp.h not found, install libargp or argp-standalone])
 fi
-
-dnl libglusterfs needs argp.h, practically everything depends on it
-GF_CPPFLAGS="${GF_CPPFLAGS} ${ARGP_STANDALONE_CPPFLAGS}"
-
-AC_SUBST(ARGP_STANDALONE_CPPFLAGS)
-AC_SUBST(ARGP_STANDALONE_LDADD)
-AC_SUBST(ARGP_STANDALONE_DIR)
+AC_SUBST(ARGP_LDADD)
 
 dnl Check for atomic operation support
-AC_CHECK_FUNC([__atomic_load], [have_atomic_builtins])
+AC_MSG_CHECKING([for gcc __atomic builtins])
+AC_TRY_LINK([], [int v; __atomic_load_n(&v, __ATOMIC_ACQUIRE);],
+            [have_atomic_builtins=yes], [have_atomic_builtins=no])
 if test "x${have_atomic_builtins}" = "xyes"; then
    AC_DEFINE(HAVE_ATOMIC_BUILTINS, 1, [define if __atomic_*() builtins are available])
 fi
 AC_SUBST(HAVE_ATOMIC_BUILTINS)
+AC_MSG_RESULT([$have_atomic_builtins])
 
 dnl __sync_*() will not be needed if __atomic_*() is available
-AC_CHECK_FUNC([__sync_fetch_and_add], [have_sync_builtins])
-if test "x${have_sync_builtind}" = "xyes"; then
+AC_MSG_CHECKING([for gcc __sync builtins])
+AC_TRY_LINK([], [__sync_synchronize();],
+            [have_sync_builtins=yes], [have_sync_builtins=no])
+if test "x${have_sync_builtins}" = "xyes"; then
    AC_DEFINE(HAVE_SYNC_BUILTINS, 1, [define if __sync_*() builtins are available])
 fi
 AC_SUBST(HAVE_SYNC_BUILTINS)
+AC_MSG_RESULT([$have_sync_builtins])
 
 AC_CHECK_HEADER([malloc.h], AC_DEFINE(HAVE_MALLOC_H, 1, [have malloc.h]))
 
@@ -1013,6 +1086,38 @@ if test "x${have_posix_fallocate}" = "xyes"; then
    AC_DEFINE(HAVE_POSIX_FALLOCATE, 1, [define if posix_fallocate exists])
 fi
 
+# On fedora-29, copy_file_range syscall and the libc API both are present.
+# Whereas, on some machines such as centos-7, RHEL-7, the API is not there.
+# Only the system call is present. So, this change is to determine whether
+# the API is present or not. If not, then check whether the system call is
+# present or not. Accordingly sys_copy_file_range function will first call
+# the API if it is there. Otherwise it will call syscall(SYS_copy_file_range).
+AC_CHECK_FUNC([copy_file_range], [have_copy_file_range=yes])
+if test "x${have_copy_file_range}" = "xyes"; then
+   AC_DEFINE(HAVE_COPY_FILE_RANGE, 1, [define if copy_file_range exists])
+else
+   OLD_CFLAGS=${CFLAGS}
+   CFLAGS="-D_GNU_SOURCE"
+   AC_CHECK_DECL([SYS_copy_file_range], , , [#include <sys/syscall.h>])
+   if test "x${ac_cv_have_decl_SYS_copy_file_range}" = "xyes"; then
+      AC_DEFINE(HAVE_COPY_FILE_RANGE_SYS, 1, [define if SYS_copy_file_range is available])
+   fi
+   CFLAGS=${OLD_CFLAGS}
+fi
+
+AC_CHECK_FUNC([syncfs], [have_syncfs=yes])
+if test "x${have_syncfs}" = "xyes"; then
+   AC_DEFINE(HAVE_SYNCFS, 1, [define if syncfs exists])
+else
+   OLD_CFLAGS=${CFLAGS}
+   CFLAGS="-D_GNU_SOURCE"
+   AC_CHECK_DECL([SYS_syncfs], , , [#include <sys/syscall.h>])
+   if test "x${ac_cv_have_decl_SYS_syncfs}" = "xyes"; then
+      AC_DEFINE(HAVE_SYNCFS_SYS, 1, [define if SYS_syncfs is available])
+   fi
+   CFLAGS=${OLD_CFLAGS}
+fi
+
 BUILD_NANOSECOND_TIMESTAMPS=no
 AC_CHECK_FUNC([utimensat], [have_utimensat=yes])
 if test "x${have_utimensat}" = "xyes"; then
@@ -1028,6 +1133,16 @@ if test "x${ac_cv_have_decl_SEEK_HOLE}" = "xyes"; then
 fi
 CFLAGS=${OLD_CFLAGS}
 
+AC_CHECK_FUNC([accept4], [have_accept4=yes])
+if test "x${have_accept4}" = "xyes"; then
+   AC_DEFINE(HAVE_ACCEPT4, 1, [define if accept4 exists])
+fi
+
+AC_CHECK_FUNC([paccept], [have_paccept=yes])
+if test "x${have_paccept}" = "xyes"; then
+AC_DEFINE(HAVE_PACCEPT, 1, [define if paccept exists])
+fi
+
 # Check the distribution where you are compiling glusterfs on
 
 GF_DISTRIBUTION=
@@ -1048,7 +1163,34 @@ fi
 AC_SUBST(GF_DISTRIBUTION)
 
 GF_HOST_OS=""
-GF_LDFLAGS="-rdynamic"
+GF_LDFLAGS="${GF_LDFLAGS} -rdynamic"
+
+dnl see --with-libtirpc option check above, libtirpc(-devel) is required for
+dnl ipv6-default
+if test "x${with_libtirpc}" = "xyes" || test "x${with_ipv6_default}" = "xyes" ; then
+    PKG_CHECK_MODULES([TIRPC], [libtirpc],
+       [with_libtirpc="yes"; GF_CFLAGS="$GF_CFLAGS $TIRPC_CFLAGS"; GF_LDFLAGS="$GF_LDFLAGS $TIRPC_LIBS";],
+       [with_libtirpc="missing"; with_ipv6_default="no"])
+fi
+
+if test "x${with_libtirpc}" = "xmissing" ; then
+    AC_CHECK_HEADERS([rpc/rpc.h],[
+        AC_MSG_WARN([
+            ---------------------------------------------------------------------------------
+            libtirpc (and/or ipv6-default) were enabled but libtirpc-devel is not installed.
+            Disabling libtirpc and ipv6-default and falling back to legacy glibc rpc headers.
+            This is a transitional warning message. Eventually it will be an error message.
+            ---------------------------------------------------------------------------------])],[
+        AC_MSG_ERROR([
+            ---------------------------------------------------------------------------------
+            libtirpc (and/or ipv6-default) were enabled but libtirpc-devel is not installed
+            and there were no legacy glibc rpc headers and library to fall back to.
+            ---------------------------------------------------------------------------------])])
+fi
+
+if test "x$with_ipv6_default" = "xyes" ; then
+   GF_CFLAGS="$GF_CFLAGS -DIPV6_DEFAULT"
+fi
 
 dnl check for gcc -Werror=format-security
 saved_CFLAGS=$CFLAGS
@@ -1056,28 +1198,21 @@ CFLAGS="-Wformat -Werror=format-security"
 AC_MSG_CHECKING([whether $CC accepts -Werror=format-security])
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [cc_werror_format_security=yes], [cc_werror_format_security=no])
 echo $cc_werror_format_security
-if test "x$cc_werror_format_security" = "xno"; then
-    CFLAGS="$saved_CFLAGS"
-else
-    CFLAGS="$saved_CFLAGS $CFLAGS"
-    GF_CFLAGS="$GF_CFLAGS $CFLAGS"
+if test "x$cc_werror_format_security" = "xyes"; then
+    GF_CFLAGS="$GF_CFLAGS ${CFLAGS}"
 fi
+CFLAGS="$saved_CFLAGS"
 
 dnl check for gcc -Werror=implicit-function-declaration
 saved_CFLAGS=$CFLAGS
-saved_GF_CFLAGS=$GF_CFLAGS
 CFLAGS="-Werror=implicit-function-declaration"
-GF_CFLAGS="-Werror=implicit-function-declaration"
 AC_MSG_CHECKING([whether $CC accepts -Werror=implicit-function-declaration])
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [cc_werror_implicit=yes], [cc_werror_implicit=no])
 echo $cc_werror_implicit
-if test "x$cc_werror_implicit" = "xno"; then
-    CFLAGS="$saved_CFLAGS"
-    GF_CFLAGS="$saved_GF_CFLAGS"
-else
-    CFLAGS="$saved_CFLAGS $CFLAGS"
-    GF_CFLAGS="$saved_GF_CFLAGS $GF_CFLAGS"
+if test "x$cc_werror_implicit" = "xyes"; then
+    GF_CFLAGS="${GF_CFLAGS} ${CFLAGS}"
 fi
+CFLAGS="$saved_CFLAGS"
 
 dnl clang is mostly GCC-compatible, but its version is much lower,
 dnl so we have to check for it.
@@ -1114,14 +1249,13 @@ fi
 
 old_prefix=$prefix
 if test "x$prefix" = xNONE; then
-	prefix=$ac_default_prefix
+        prefix=$ac_default_prefix
 fi
 old_exec_prefix=$exec_prefix
 if test "x$exec_prefix" = xNONE; then
-	exec_prefix="$(eval echo $prefix)"
+        exec_prefix="$(eval echo $prefix)"
 fi
 GLUSTERFS_LIBEXECDIR="$(eval echo $libexecdir)/glusterfs"
-GLUSTERFSD_MISCDIR="$(eval echo $prefix)/var/lib/misc/glusterfsd"
 prefix=$old_prefix
 exec_prefix=$old_exec_prefix
 
@@ -1133,6 +1267,8 @@ fi
 localstatedir="$(eval echo ${localstatedir})"
 LOCALSTATEDIR=$localstatedir
 
+GLUSTERFSD_MISCDIR="$(eval echo ${localstatedir})/lib/misc/glusterfsd"
+
 old_prefix=$prefix
 if test "x$prefix" = xNONE; then
     prefix=$ac_default_prefix
@@ -1141,6 +1277,7 @@ GLUSTERD_VOLFILE="$(eval echo ${sysconfdir})/glusterfs/glusterd.vol"
 prefix=$old_prefix
 
 
+GFAPI_EXTRA_LDFLAGS='-Wl,--version-script=$(top_srcdir)/api/src/gfapi.map'
 case $host_os in
      linux*)
         GF_HOST_OS="GF_LINUX_HOST_OS"
@@ -1160,9 +1297,9 @@ case $host_os in
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME"
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME"
         GF_FUSE_CFLAGS="-DFUSERMOUNT_DIR=\\\"\$(sbindir)\\\""
-        GF_LDADD="${ARGP_STANDALONE_LDADD}"
+        GF_LDADD="${ARGP_LDADD}"
         if test "x$ac_cv_header_execinfo_h" = "xyes"; then
-           GF_LDFLAGS="-lexecinfo"
+           GF_LDFLAGS="${GF_LDFLAGS} -lexecinfo"
         fi
         GF_FUSE_LDADD="-lperfuse"
         BUILD_FUSE_CLIENT=yes
@@ -1173,17 +1310,13 @@ case $host_os in
         ;;
      *freebsd*)
         GF_HOST_OS="GF_BSD_HOST_OS"
-        GF_CFLAGS="${GF_CFLAGS} ${ARGP_STANDALONE_CPPFLAGS} -O0"
-        GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME"
-        GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME"
-        GF_CFLAGS="${GF_CFLAGS} -D_LIBGEN_H_"
         GF_CFLAGS="${GF_CFLAGS} -DO_DSYNC=0"
         GF_CFLAGS="${GF_CFLAGS} -Dxdr_quad_t=xdr_longlong_t"
         GF_CFLAGS="${GF_CFLAGS} -Dxdr_u_quad_t=xdr_u_longlong_t"
         GF_FUSE_CFLAGS="-DFUSERMOUNT_DIR=\\\"\$(sbindir)\\\""
-        GF_LDADD="${ARGP_STANDALONE_LDADD}"
+        GF_LDADD="${ARGP_LDADD}"
         if test "x$ac_cv_header_execinfo_h" = "xyes"; then
-           GF_LDFLAGS="-lexecinfo"
+           GF_LDFLAGS="${GF_LDFLAGS} -lexecinfo"
         fi
         BUILD_FUSE_CLIENT=yes
         BUILD_FUSERMOUNT=no
@@ -1193,27 +1326,18 @@ case $host_os in
      darwin*)
         GF_HOST_OS="GF_DARWIN_HOST_OS"
         LIBTOOL=glibtool
-        GF_CFLAGS="${GF_CFLAGS} ${ARGP_STANDALONE_CPPFLAGS} "
         GF_CFLAGS="${GF_CFLAGS} -D_REENTRANT -D_XOPEN_SOURCE "
         GF_CFLAGS="${GF_CFLAGS} -D_DARWIN_USE_64_BIT_INODE "
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME"
         GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME"
-        GF_LDADD="${ARGP_STANDALONE_LDADD}"
-        GF_LDFLAGS=""
+        GF_LDADD="${ARGP_LDADD}"
+        GF_LDFLAGS="${GF_LDFLAGS}"
         GF_FUSE_CFLAGS="-I\$(CONTRIBDIR)/macfuse"
         BUILD_FUSERMOUNT="no"
         FUSERMOUNT_SUBDIR=""
         GLUSTERD_WORKDIR="${LOCALSTATEDIR}/db/glusterd"
-        ;;
-esac
-
-case $host_os in
-     darwin*)
         GFAPI_EXTRA_LDFLAGS='-Wl,-alias_list,$(top_srcdir)/api/src/gfapi.aliases'
         ;;
-     *)
-        GFAPI_EXTRA_LDFLAGS='-Wl,--version-script=$(top_srcdir)/api/src/gfapi.map'
-        ;;
 esac
 
 # Default value for sbindir
@@ -1231,19 +1355,11 @@ sysconfdirtemp="${sysconfdir}"
 eval sysconfdirtemp=\"${sysconfdirtemp}\"
 SYSCONF_DIR=${sysconfdirtemp}
 
-# Eval two times to expand fully. First eval replaces $exec_prefix into $prefix
-# Second eval will expand $prefix
-build_python_site_packages_temp="${BUILD_PYTHON_SITE_PACKAGES}"
-eval build_python_site_packages_temp=\"${build_python_site_packages_temp}\"
-eval build_python_site_packages_temp=\"${build_python_site_packages_temp}\"
-BUILD_PYTHON_SITE_PACKAGES_EXPANDED=${build_python_site_packages_temp}
-
 prefix=$prefix_temp
 exec_prefix=$exec_prefix_temp
 
 AC_SUBST(SBIN_DIR)
 AC_SUBST(SYSCONF_DIR)
-AC_SUBST(BUILD_PYTHON_SITE_PACKAGES_EXPANDED)
 
 # lazy umount emulation
 UMOUNTD_SUBDIR=""
@@ -1287,7 +1403,7 @@ AC_CHECK_LIB([readline -lcurses],[readline],[RLLIBS="-lreadline -lcurses"])
 AC_CHECK_LIB([readline -ltermcap],[readline],[RLLIBS="-lreadline -ltermcap"])
 AC_CHECK_LIB([readline -lncurses],[readline],[RLLIBS="-lreadline -lncurses"])
 
-if test "x$RLLIBS" != "x"; then
+if test -n "$RLLIBS"; then
    if test "x$RL_UNDO" = "xyes"; then
       AC_DEFINE(HAVE_READLINE, 1, [readline enabled CLI])
       BUILD_READLINE=yes
@@ -1300,58 +1416,25 @@ fi
 BUILD_LIBAIO=no
 AC_CHECK_LIB([aio],[io_setup],[LIBAIO="-laio"])
 
-if test "x$LIBAIO" != "x"; then
+if test -n "$LIBAIO"; then
    AC_DEFINE(HAVE_LIBAIO, 1, [libaio based POSIX enabled])
    BUILD_LIBAIO=yes
 fi
 
-dnl glupy section
-BUILD_GLUPY=no
-
-AC_ARG_ENABLE([glupy], AS_HELP_STRING([--enable-glupy], [build glupy]))
-if test "x$enable_glupy" != "xno"; then enable_glupy=yes; fi
-
-if test "x$enable_glupy" = "xyes"; then
-    GLUPY_SUBDIR=glupy
-    GLUPY_SUBDIR_MAKEFILE=xlators/features/glupy/Makefile
-    GLUPY_SUBDIR_SRC_MAKEFILE=xlators/features/glupy/src/Makefile
-
-    if test "x$have_python2" = "xyes" -a "x$have_Python_h" = "xyes"; then
-        case $host_os in
-            darwin*)
-                BUILD_GLUPY=no
-                ;;
-            *)
-                BUILD_GLUPY=yes
-                ;;
-        esac
-    else
-        AC_MSG_WARN([
-        ---------------------------------------------------------------------------------
-        cannot build glupy. python 2.x and python-devel/python-dev package are required.
-        ---------------------------------------------------------------------------------])
-    fi
-
-    if test "x$BUILD_GLUPY" = "xyes"; then
-
-        echo "building glupy with -isystem $BUILD_PYTHON_INC -l $BUILD_PYTHON_LIB"
-
-        AC_SUBST(GLUPY_SUBDIR)
-        AC_SUBST(GLUPY_SUBDIR_MAKEFILE)
-        AC_SUBST(GLUPY_SUBDIR_SRC_MAKEFILE)
-    fi
-fi
-dnl end glupy section
-
 dnl gnfs section
 BUILD_GNFS="no"
+RPCBIND_SERVICE=""
 AC_ARG_ENABLE([gnfs],
               AC_HELP_STRING([--enable-gnfs],
                              [Enable legacy gnfs server xlator.]))
-if test "x$enable_gnfs" = "xyes"; then
+if test "x${with_server}" = "xyes" -a "x$enable_gnfs" = "xyes"; then
     BUILD_GNFS="yes"
+    GF_CFLAGS="$GF_CFLAGS -DBUILD_GNFS"
+    RPCBIND_SERVICE="rpcbind.service"
 fi
 AM_CONDITIONAL([BUILD_GNFS], [test x$BUILD_GNFS = xyes])
+AC_SUBST(BUILD_GNFS)
+AC_SUBST(RPCBIND_SERVICE)
 dnl end gnfs section
 
 dnl Check for userspace-rcu
@@ -1361,10 +1444,12 @@ PKG_CHECK_MODULES([URCU], [liburcu-bp], [],
      AC_MSG_ERROR([liburcu-bp not found]))])
 PKG_CHECK_MODULES([URCU_CDS], [liburcu-cds >= 0.8], [],
   [PKG_CHECK_MODULES([URCU_CDS], [liburcu-cds >= 0.7],
-    [AC_DEFINE(URCU_OLD, 1, [Define if liburcu 0.6 or 0.7 is found])],
+    [AC_DEFINE(URCU_OLD, 1, [Define if liburcu 0.6 or 0.7 is found])
+     USE_CONTRIB_URCU='yes'],
     [AC_CHECK_HEADERS([urcu/cds.h],
       [AC_DEFINE(URCU_OLD, 1, [Define if liburcu 0.6 or 0.7 is found])
-       URCU_CDS_LIBS='-lurcu-cds'],
+       URCU_CDS_LIBS='-lurcu-cds'
+       USE_CONTRIB_URCU='yes'],
       [AC_MSG_ERROR([liburcu-cds not found])])])])
 
 BUILD_UNITTEST="no"
@@ -1491,7 +1576,23 @@ AC_SUBST(USE_EC_DYNAMIC_NEON)
 dnl libglusterfs.so uses math functions
 GF_LDADD="${GF_LDADD} ${MATH_LIB}"
 
-GF_XLATOR_DEFAULT_LDFLAGS='-avoid-version -export-symbols $(top_srcdir)/xlators/xlator.sym'
+case $host_os in
+  dnl Can't use libtool's portable "-no-undefined" as it seems to be ignored on Linux
+  linux*)
+    GF_NO_UNDEFINED='-Wl,--no-undefined'
+    ;;
+  darwin*)
+    GF_NO_UNDEFINED='-Wl,-undefined'
+    ;;
+  *)
+  dnl There's an issue on FreeBSD with reference to __progname used in some parts of code
+    GF_NO_UNDEFINED=''
+    ;;
+esac
+dnl GF_XLATOR_DEFAULT_LDFLAGS is for most xlators that expose a common set of symbols
+GF_XLATOR_DEFAULT_LDFLAGS='-avoid-version -export-symbols $(top_srcdir)/xlators/xlator.sym $(UUID_LIBS) $(GF_NO_UNDEFINED) $(TIRPC_LIBS)'
+dnl GF_XLATOR_LDFLAGS is for xlators that expose extra symbols, e.g. dht
+GF_XLATOR_LDFLAGS='-avoid-version $(UUID_LIBS) $(GF_NO_UNDEFINED) $(TIRPC_LIBS)'
 
 AC_SUBST(GF_HOST_OS)
 AC_SUBST(GF_CFLAGS)
@@ -1503,19 +1604,34 @@ AC_SUBST(RLLIBS)
 AC_SUBST(LIBAIO)
 AC_SUBST(AM_MAKEFLAGS)
 AC_SUBST(AM_LIBTOOLFLAGS)
+AC_SUBST(GF_NO_UNDEFINED)
 AC_SUBST(GF_XLATOR_DEFAULT_LDFLAGS)
+AC_SUBST(GF_XLATOR_LDFLAGS)
+AC_SUBST(GF_XLATOR_MGNT_LIBADD)
+
+case $host_os in
+     *freebsd*)
+        GF_XLATOR_MGNT_LIBADD="-lutil -lprocstat"
+        ;;
+esac
 
 CONTRIBDIR='$(top_srcdir)/contrib'
 AC_SUBST(CONTRIBDIR)
 
 GF_CPPDEFINES='-D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS)'
 GF_CPPINCLUDES='-include $(top_builddir)/config.h -include $(top_builddir)/site.h -I$(top_srcdir)/libglusterfs/src -I$(top_builddir)/libglusterfs/src'
+if test "x${USE_CONTRIB_URCU}" = "xyes"; then
+    GF_CPPINCLUDES="${GF_CPPINCLUDES} -I\$(CONTRIBDIR)/userspace-rcu"
+fi
 GF_CPPFLAGS="$GF_CPPFLAGS $GF_CPPDEFINES $GF_CPPINCLUDES"
 AC_SUBST([GF_CPPFLAGS])
 
 AM_CONDITIONAL([GF_LINUX_HOST_OS], test "${GF_HOST_OS}" = "GF_LINUX_HOST_OS")
 AM_CONDITIONAL([GF_DARWIN_HOST_OS], test "${GF_HOST_OS}" = "GF_DARWIN_HOST_OS")
 AM_CONDITIONAL([GF_BSD_HOST_OS], test "${GF_HOST_OS}" = "GF_BSD_HOST_OS")
+if  test "${GF_HOST_OS}" = "GF_BSD_HOST_OS"; then
+    AC_DEFINE(GF_BSD_HOST_OS, 1, [This is a BSD compatible OS.])
+fi
 
 AC_SUBST(GLUSTERD_WORKDIR)
 AM_CONDITIONAL([GF_INSTALL_GLUSTERD_WORKDIR], test ! -d ${GLUSTERD_WORKDIR} && test -d ${sysconfdir}/glusterd )
@@ -1537,8 +1653,6 @@ GFAPI_VERSION="7."${PACKAGE_VERSION}
 LIBGFCHANGELOG_VERSION="0.0.1"
 AC_SUBST(GFAPI_VERSION)
 AC_SUBST(LIBGFCHANGELOG_VERSION)
-LIBGFDB_VERSION="0.0.1"
-AC_SUBST(LIBGFDB_VERSION)
 
 dnl libtool versioning
 LIBGFXDR_LT_VERSION="0:1:0"
@@ -1565,28 +1679,39 @@ echo
 echo "GlusterFS configure summary"
 echo "==========================="
 echo "FUSE client          : $BUILD_FUSE_CLIENT"
-echo "Infiniband verbs     : $BUILD_IBVERBS"
 echo "epoll IO multiplex   : $BUILD_EPOLL"
-echo "argp-standalone      : $BUILD_ARGP_STANDALONE"
 echo "fusermount           : $BUILD_FUSERMOUNT"
 echo "readline             : $BUILD_READLINE"
 echo "georeplication       : $BUILD_SYNCDAEMON"
 echo "Linux-AIO            : $BUILD_LIBAIO"
 echo "Enable Debug         : $BUILD_DEBUG"
-echo "Block Device xlator  : $BUILD_BD_XLATOR"
-echo "glupy                : $BUILD_GLUPY"
+echo "Run with Valgrind    : $VALGRIND_TOOL"
+echo "Sanitizer enabled    : $SANITIZER"
 echo "Use syslog           : $USE_SYSLOG"
 echo "XML output           : $BUILD_XML_OUTPUT"
-echo "Encryption xlator    : $BUILD_CRYPT_XLATOR"
 echo "Unit Tests           : $BUILD_UNITTEST"
 echo "Track priv ports     : $TRACK_PRIVPORTS"
 echo "POSIX ACLs           : $BUILD_POSIX_ACLS"
-echo "Data Classification  : $BUILD_GFDB"
 echo "SELinux features     : $USE_SELINUX"
 echo "firewalld-config     : $BUILD_FIREWALLD"
 echo "Events               : $BUILD_EVENTS"
 echo "EC dynamic support   : $EC_DYNAMIC_SUPPORT"
 echo "Use memory pools     : $USE_MEMPOOL"
 echo "Nanosecond m/atimes  : $BUILD_NANOSECOND_TIMESTAMPS"
+echo "Server components    : $with_server"
 echo "Legacy gNFS server   : $BUILD_GNFS"
+echo "IPV6 default         : $with_ipv6_default"
+echo "Use TIRPC            : $with_libtirpc"
+echo "With Python          : ${PYTHON_VERSION}"
+echo "Cloudsync            : $BUILD_CLOUDSYNC"
+echo "Metadata dispersal   : $BUILD_METADISP"
+echo "Link with TCMALLOC   : $BUILD_TCMALLOC"
 echo
+
+# dnl Note: ${X^^} capitalization assumes bash >= 4.x
+if test "x$SANITIZER" != "xnone"; then
+        echo "Note: since glusterfs processes are daemon processes, use"
+        echo "'export ${SANITIZER^^}_OPTIONS=log_path=/path/to/xxx.log' to collect"
+        echo "sanitizer output. Further details and more options can be"
+        echo "found at https://github.com/google/sanitizers."
+fi
diff --git a/contrib/argp-standalone/Makefile.am b/contrib/argp-standalone/Makefile.am
deleted file mode 100644
index 4775d4876aa..00000000000
--- a/contrib/argp-standalone/Makefile.am
+++ /dev/null
@@ -1,38 +0,0 @@
-# From glibc
-
-# Copyright (C) 1997, 2003, 2004 Free Software Foundation, Inc.
-# This file is part of the GNU C Library.
-
-# The GNU C Library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-
-# The GNU C Library 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
-# Library General Public License for more details.
-
-# You should have received a copy of the GNU Library General Public
-# License along with the GNU C Library; see the file COPYING.LIB.  If
-# not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-AUTOMAKE_OPTIONS = foreign
-SUBDIRS = .
-
-LIBOBJS = @LIBOBJS@
-
-noinst_LIBRARIES = libargp.a
-
-noinst_HEADERS = argp.h argp-fmtstream.h argp-namefrob.h
-
-EXTRA_DIST = mempcpy.c strchrnul.c strndup.c strcasecmp.c vsnprintf.c autogen.sh
-
-# Leaves out argp-fs-xinl.c and argp-xinl.c 
-libargp_a_SOURCES = argp-ba.c argp-eexst.c argp-fmtstream.c \
-		    argp-help.c argp-parse.c argp-pv.c \
-		    argp-pvh.c
-
-libargp_a_LIBADD = $(LIBOBJS)
-
-
diff --git a/contrib/argp-standalone/acinclude.m4 b/contrib/argp-standalone/acinclude.m4
deleted file mode 100644
index fb61e957dfa..00000000000
--- a/contrib/argp-standalone/acinclude.m4
+++ /dev/null
@@ -1,1084 +0,0 @@
-dnl Try to detect the type of the third arg to getsockname() et al
-AC_DEFUN([LSH_TYPE_SOCKLEN_T],
-[AH_TEMPLATE([socklen_t], [Length type used by getsockopt])
-AC_CACHE_CHECK([for socklen_t in sys/socket.h], ac_cv_type_socklen_t,
-[AC_EGREP_HEADER(socklen_t, sys/socket.h,
-  [ac_cv_type_socklen_t=yes], [ac_cv_type_socklen_t=no])])
-if test $ac_cv_type_socklen_t = no; then
-        AC_MSG_CHECKING(for AIX)
-        AC_EGREP_CPP(yes, [
-#ifdef _AIX
- yes
-#endif
-],[
-AC_MSG_RESULT(yes)
-AC_DEFINE(socklen_t, size_t)
-],[
-AC_MSG_RESULT(no)
-AC_DEFINE(socklen_t, int)
-])
-fi
-])
-
-dnl Choose cc flags for compiling position independent code
-AC_DEFUN([LSH_CCPIC],
-[AC_MSG_CHECKING(CCPIC)
-AC_CACHE_VAL(lsh_cv_sys_ccpic,[
-  if test -z "$CCPIC" ; then
-    if test "$GCC" = yes ; then
-      case `uname -sr` in
-	BSD/OS*)
-         case `uname -r` in
-           4.*) CCPIC="-fPIC";;
-           *) CCPIC="";;
-         esac
-	;;
-	Darwin*)
-	  CCPIC="-fPIC"
-	;;
-	SunOS\ 5.*)
-	  # Could also use -fPIC, if there are a large number of symbol reference
-	  CCPIC="-fPIC"
-	;;
-	CYGWIN*)
-	  CCPIC=""
-	;;
-	*)
-	  CCPIC="-fpic"
-	;;
-      esac
-    else
-      case `uname -sr` in
-	Darwin*)
-	  CCPIC="-fPIC"
-	;;
-        IRIX*)
-          CCPIC="-share"
-        ;;
-	hp*|HP*) CCPIC="+z"; ;;
-	FreeBSD*) CCPIC="-fpic";;
-	SCO_SV*) CCPIC="-KPIC -dy -Bdynamic";;
-        UnixWare*|OpenUNIX*) CCPIC="-KPIC -dy -Bdynamic";;
-	Solaris*) CCPIC="-KPIC -Bdynamic";;
-	Windows_NT*) CCPIC="-shared" ;;
-      esac
-    fi
-  fi
-  OLD_CFLAGS="$CFLAGS"
-  CFLAGS="$CFLAGS $CCPIC"
-  AC_TRY_COMPILE([], [exit(0);],
-    lsh_cv_sys_ccpic="$CCPIC", lsh_cv_sys_ccpic='')
-  CFLAGS="$OLD_CFLAGS"
-])
-CCPIC="$lsh_cv_sys_ccpic"
-AC_MSG_RESULT($CCPIC)
-AC_SUBST([CCPIC])])
-
-dnl LSH_PATH_ADD(path-id, directory)
-AC_DEFUN([LSH_PATH_ADD],
-[AC_MSG_CHECKING($2)
-ac_exists=no
-if test -d "$2/." ; then
-  ac_real_dir=`cd $2 && pwd`
-  if test -n "$ac_real_dir" ; then
-    ac_exists=yes
-    for old in $1_REAL_DIRS ; do
-      ac_found=no
-      if test x$ac_real_dir = x$old ; then
-        ac_found=yes;
-	break;
-      fi
-    done
-    if test $ac_found = yes ; then
-      AC_MSG_RESULT(already added)
-    else
-      AC_MSG_RESULT(added)
-      # LDFLAGS="$LDFLAGS -L $2"
-      $1_REAL_DIRS="$ac_real_dir [$]$1_REAL_DIRS"
-      $1_DIRS="$2 [$]$1_DIRS"
-    fi
-  fi
-fi
-if test $ac_exists = no ; then
-  AC_MSG_RESULT(not found)
-fi
-])
-
-dnl LSH_RPATH_ADD(dir)
-AC_DEFUN([LSH_RPATH_ADD], [LSH_PATH_ADD(RPATH_CANDIDATE, $1)])
-
-dnl LSH_RPATH_INIT(candidates)
-AC_DEFUN([LSH_RPATH_INIT],
-[AC_MSG_CHECKING([for -R flag])
-RPATHFLAG=''
-case `uname -sr` in
-  OSF1\ V4.*)
-    RPATHFLAG="-rpath "
-    ;;
-  IRIX\ 6.*)
-    RPATHFLAG="-rpath "
-    ;;
-  IRIX\ 5.*)
-    RPATHFLAG="-rpath "
-    ;;
-  SunOS\ 5.*)
-    if test "$TCC" = "yes"; then
-      # tcc doesn't know about -R
-      RPATHFLAG="-Wl,-R,"
-    else
-      RPATHFLAG=-R
-    fi
-    ;;
-  Linux\ 2.*)
-    RPATHFLAG="-Wl,-rpath,"
-    ;;
-  *)
-    :
-    ;;
-esac
-
-if test x$RPATHFLAG = x ; then
-  AC_MSG_RESULT(none)
-else
-  AC_MSG_RESULT([using $RPATHFLAG])
-fi
-
-RPATH_CANDIDATE_REAL_DIRS=''
-RPATH_CANDIDATE_DIRS=''
-
-AC_MSG_RESULT([Searching for libraries])
-
-for d in $1 ; do
-  LSH_RPATH_ADD($d)
-done
-])    
-
-dnl Try to execute a main program, and if it fails, try adding some
-dnl -R flag.
-dnl LSH_RPATH_FIX
-AC_DEFUN([LSH_RPATH_FIX],
-[if test $cross_compiling = no -a "x$RPATHFLAG" != x ; then
-  ac_success=no
-  AC_TRY_RUN([int main(int argc, char **argv) { return 0; }],
-    ac_success=yes, ac_success=no, :)
-  
-  if test $ac_success = no ; then
-    AC_MSG_CHECKING([Running simple test program failed. Trying -R flags])
-dnl echo RPATH_CANDIDATE_DIRS = $RPATH_CANDIDATE_DIRS
-    ac_remaining_dirs=''
-    ac_rpath_save_LDFLAGS="$LDFLAGS"
-    for d in $RPATH_CANDIDATE_DIRS ; do
-      if test $ac_success = yes ; then
-  	ac_remaining_dirs="$ac_remaining_dirs $d"
-      else
-  	LDFLAGS="$RPATHFLAG$d $LDFLAGS"
-dnl echo LDFLAGS = $LDFLAGS
-  	AC_TRY_RUN([int main(int argc, char **argv) { return 0; }],
-  	  [ac_success=yes
-  	  ac_rpath_save_LDFLAGS="$LDFLAGS"
-  	  AC_MSG_RESULT([adding $RPATHFLAG$d])
-  	  ],
-  	  [ac_remaining_dirs="$ac_remaining_dirs $d"], :)
-  	LDFLAGS="$ac_rpath_save_LDFLAGS"
-      fi
-    done
-    RPATH_CANDIDATE_DIRS=$ac_remaining_dirs
-  fi
-  if test $ac_success = no ; then
-    AC_MSG_RESULT(failed)
-  fi
-fi
-])
-
-dnl Like AC_CHECK_LIB, but uses $KRB_LIBS rather than $LIBS.
-dnl LSH_CHECK_KRB_LIB(LIBRARY, FUNCTION, [, ACTION-IF-FOUND [,
-dnl                  ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
-
-AC_DEFUN([LSH_CHECK_KRB_LIB],
-[AC_CHECK_LIB([$1], [$2],
-  ifelse([$3], ,
-      [[ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
-     	    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
-        AC_DEFINE_UNQUOTED($ac_tr_lib)
-        KRB_LIBS="-l$1 $KRB_LIBS"
-      ]], [$3]),
-  ifelse([$4], , , [$4
-])dnl
-, [$5 $KRB_LIBS])
-])
-
-dnl LSH_LIB_ARGP(ACTION-IF-OK, ACTION-IF-BAD)
-AC_DEFUN([LSH_LIB_ARGP],
-[ ac_argp_save_LIBS="$LIBS"
-  ac_argp_save_LDFLAGS="$LDFLAGS"
-  ac_argp_ok=no
-  # First check if we can link with argp.
-  AC_SEARCH_LIBS(argp_parse, argp,
-  [ LSH_RPATH_FIX
-    AC_CACHE_CHECK([for working argp],
-      lsh_cv_lib_argp_works,
-      [ AC_TRY_RUN(
-[#include <argp.h>
-#include <stdlib.h>
-
-static const struct argp_option
-options[] =
-{
-  { NULL, 0, NULL, 0, NULL, 0 }
-};
-
-struct child_state
-{
-  int n;
-};
-
-static error_t
-child_parser(int key, char *arg, struct argp_state *state)
-{
-  struct child_state *input = (struct child_state *) state->input;
-  
-  switch(key)
-    {
-    default:
-      return ARGP_ERR_UNKNOWN;
-    case ARGP_KEY_END:
-      if (!input->n)
-	input->n = 1;
-      break;
-    }
-  return 0;
-}
-
-const struct argp child_argp =
-{
-  options,
-  child_parser,
-  NULL, NULL, NULL, NULL, NULL
-};
-
-struct main_state
-{
-  struct child_state child;
-  int m;
-};
-
-static error_t
-main_parser(int key, char *arg, struct argp_state *state)
-{
-  struct main_state *input = (struct main_state *) state->input;
-
-  switch(key)
-    {
-    default:
-      return ARGP_ERR_UNKNOWN;
-    case ARGP_KEY_INIT:
-      state->child_inputs[0] = &input->child;
-      break;
-    case ARGP_KEY_END:
-      if (!input->m)
-	input->m = input->child.n;
-      
-      break;
-    }
-  return 0;
-}
-
-static const struct argp_child
-main_children[] =
-{
-  { &child_argp, 0, "", 0 },
-  { NULL, 0, NULL, 0}
-};
-
-static const struct argp
-main_argp =
-{ options, main_parser, 
-  NULL,
-  NULL,
-  main_children,
-  NULL, NULL
-};
-
-int main(int argc, char **argv)
-{
-  struct main_state input = { { 0 }, 0 };
-  char *v[2] = { "foo", NULL };
-
-  argp_parse(&main_argp, 1, v, 0, NULL, &input);
-
-  if ( (input.m == 1) && (input.child.n == 1) )
-    return 0;
-  else
-    return 1;
-}
-], lsh_cv_lib_argp_works=yes,
-   lsh_cv_lib_argp_works=no,
-   lsh_cv_lib_argp_works=no)])
-
-  if test x$lsh_cv_lib_argp_works = xyes ; then
-    ac_argp_ok=yes
-  else
-    # Reset link flags
-    LIBS="$ac_argp_save_LIBS"
-    LDFLAGS="$ac_argp_save_LDFLAGS"
-  fi])
-
-  if test x$ac_argp_ok = xyes ; then
-    ifelse([$1],, true, [$1])
-  else
-    ifelse([$2],, true, [$2])
-  fi   
-])
-
-dnl LSH_GCC_ATTRIBUTES
-dnl Check for gcc's __attribute__ construction
-
-AC_DEFUN([LSH_GCC_ATTRIBUTES],
-[AC_CACHE_CHECK(for __attribute__,
-	       lsh_cv_c_attribute,
-[ AC_TRY_COMPILE([
-#include <stdlib.h>
-],
-[
-static void foo(void) __attribute__ ((noreturn));
-
-static void __attribute__ ((noreturn))
-foo(void)
-{
-  exit(1);
-}
-],
-lsh_cv_c_attribute=yes,
-lsh_cv_c_attribute=no)])
-
-AH_TEMPLATE([HAVE_GCC_ATTRIBUTE], [Define if the compiler understands __attribute__])
-if test "x$lsh_cv_c_attribute" = "xyes"; then
-  AC_DEFINE(HAVE_GCC_ATTRIBUTE)
-fi
-
-AH_BOTTOM(
-[#if __GNUC__ || HAVE_GCC_ATTRIBUTE
-# define NORETURN __attribute__ ((__noreturn__))
-# define PRINTF_STYLE(f, a) __attribute__ ((__format__ (__printf__, f, a)))
-# define UNUSED __attribute__ ((__unused__))
-#else
-# define NORETURN
-# define PRINTF_STYLE(f, a)
-# define UNUSED
-#endif
-])])
-
-AC_DEFUN([LSH_GCC_FUNCTION_NAME],
-[# Check for gcc's __FUNCTION__ variable
-AH_TEMPLATE([HAVE_GCC_FUNCTION],
-	    [Define if the compiler understands __FUNCTION__])
-AH_BOTTOM(
-[#if HAVE_GCC_FUNCTION
-# define FUNCTION_NAME __FUNCTION__
-#else
-# define FUNCTION_NAME "Unknown"
-#endif
-])
-
-AC_CACHE_CHECK(for __FUNCTION__,
-	       lsh_cv_c_FUNCTION,
-  [ AC_TRY_COMPILE(,
-      [ #if __GNUC__ == 3
-	#  error __FUNCTION__ is broken in gcc-3
-	#endif
-        void foo(void) { char c = __FUNCTION__[0]; } ],
-      lsh_cv_c_FUNCTION=yes,
-      lsh_cv_c_FUNCTION=no)])
-
-if test "x$lsh_cv_c_FUNCTION" = "xyes"; then
-  AC_DEFINE(HAVE_GCC_FUNCTION)
-fi
-])
-
-# Check for alloca, and include the standard blurb in config.h
-AC_DEFUN([LSH_FUNC_ALLOCA],
-[AC_FUNC_ALLOCA
-AC_CHECK_HEADERS([malloc.h])
-AH_BOTTOM(
-[/* AIX requires this to be the first thing in the file.  */
-#ifndef __GNUC__
-# if HAVE_ALLOCA_H
-#  include <alloca.h>
-# else
-#  ifdef _AIX
- #pragma alloca
-#  else
-#   ifndef alloca /* predefined by HP cc +Olibcalls */
-char *alloca ();
-#   endif
-#  endif
-# endif
-#else /* defined __GNUC__ */
-# if HAVE_ALLOCA_H
-#  include <alloca.h>
-# endif
-#endif
-/* Needed for alloca on windows */
-#if HAVE_MALLOC_H
-# include <malloc.h>
-#endif
-])])
-
-AC_DEFUN([LSH_FUNC_STRERROR],
-[AC_CHECK_FUNCS(strerror)
-AH_BOTTOM(
-[#if HAVE_STRERROR
-#define STRERROR strerror
-#else
-#define STRERROR(x) (sys_errlist[x])
-#endif
-])])
-
-AC_DEFUN([LSH_FUNC_STRSIGNAL],
-[AC_CHECK_FUNCS(strsignal)
-AC_CHECK_DECLS([sys_siglist, _sys_siglist])
-AH_BOTTOM(
-[#if HAVE_STRSIGNAL
-# define STRSIGNAL strsignal
-#else /* !HAVE_STRSIGNAL */
-# if HAVE_DECL_SYS_SIGLIST
-#  define STRSIGNAL(x) (sys_siglist[x])
-# else
-#  if HAVE_DECL__SYS_SIGLIST
-#   define STRSIGNAL(x) (_sys_siglist[x])
-#  else
-#   define STRSIGNAL(x) "Unknown signal"
-#   if __GNUC__
-#    warning Using dummy STRSIGNAL
-#   endif
-#  endif
-# endif
-#endif /* !HAVE_STRSIGNAL */
-])])
-
-dnl LSH_MAKE_CONDITIONAL(symbol, test)
-AC_DEFUN([LSH_MAKE_CONDITIONAL],
-[if $2 ; then
-  IF_$1=''
-  UNLESS_$1='# '
-else
-  IF_$1='# '
-  UNLESS_$1=''
-fi 
-AC_SUBST(IF_$1)
-AC_SUBST(UNLESS_$1)])
-
-dnl LSH_DEPENDENCY_TRACKING
-
-dnl Defines compiler flags DEP_FLAGS to generate dependency
-dnl information, and DEP_PROCESS that is any shell commands needed for
-dnl massaging the dependency information further. Dependencies are
-dnl generated as a side effect of compilation. Dependency files
-dnl themselves are not treated as targets.
-
-AC_DEFUN([LSH_DEPENDENCY_TRACKING],
-[AC_ARG_ENABLE(dependency_tracking,
-  AC_HELP_STRING([--disable-dependency-tracking],
-    [Disable dependency tracking. Dependency tracking doesn't work with BSD make]),,
-  [enable_dependency_tracking=yes])
-
-DEP_FLAGS=''
-DEP_PROCESS='true'
-if test x$enable_dependency_tracking = xyes ; then
-  if test x$GCC = xyes ; then
-    gcc_version=`gcc --version | head -1`
-    case "$gcc_version" in
-      2.*|*[[!0-9.]]2.*)
-        enable_dependency_tracking=no
-        AC_MSG_WARN([Dependency tracking disabled, gcc-3.x is needed])
-      ;;
-      *)
-        DEP_FLAGS='-MT $[]@ -MD -MP -MF $[]@.d'
-        DEP_PROCESS='true'
-      ;;
-    esac
-  else
-    enable_dependency_tracking=no
-    AC_MSG_WARN([Dependency tracking disabled])
-  fi
-fi
-
-if test x$enable_dependency_tracking = xyes ; then
-  DEP_INCLUDE='include '
-else
-  DEP_INCLUDE='# '
-fi
-
-AC_SUBST([DEP_INCLUDE])
-AC_SUBST([DEP_FLAGS])
-AC_SUBST([DEP_PROCESS])])
-
-dnl @synopsis AX_CREATE_STDINT_H [( HEADER-TO-GENERATE [, HEADERS-TO-CHECK])]
-dnl
-dnl the "ISO C9X: 7.18 Integer types <stdint.h>" section requires the
-dnl existence of an include file <stdint.h> that defines a set of 
-dnl typedefs, especially uint8_t,int32_t,uintptr_t.
-dnl Many older installations will not provide this file, but some will
-dnl have the very same definitions in <inttypes.h>. In other enviroments
-dnl we can use the inet-types in <sys/types.h> which would define the
-dnl typedefs int8_t and u_int8_t respectivly.
-dnl
-dnl This macros will create a local "_stdint.h" or the headerfile given as 
-dnl an argument. In many cases that file will just "#include <stdint.h>" 
-dnl or "#include <inttypes.h>", while in other environments it will provide 
-dnl the set of basic 'stdint's definitions/typedefs: 
-dnl   int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,intptr_t,uintptr_t
-dnl   int_least32_t.. int_fast32_t.. intmax_t
-dnl which may or may not rely on the definitions of other files,
-dnl or using the AC_CHECK_SIZEOF macro to determine the actual
-dnl sizeof each type.
-dnl
-dnl if your header files require the stdint-types you will want to create an
-dnl installable file mylib-int.h that all your other installable header
-dnl may include. So if you have a library package named "mylib", just use
-dnl      AX_CREATE_STDINT_H(mylib-int.h) 
-dnl in configure.ac and go to install that very header file in Makefile.am
-dnl along with the other headers (mylib.h) - and the mylib-specific headers
-dnl can simply use "#include <mylib-int.h>" to obtain the stdint-types.
-dnl
-dnl Remember, if the system already had a valid <stdint.h>, the generated
-dnl file will include it directly. No need for fuzzy HAVE_STDINT_H things...
-dnl
-dnl @, (status: used on new platforms) (see http://ac-archive.sf.net/gstdint/)
-dnl @version $Id: acinclude.m4,v 1.27 2004/11/23 21:27:35 nisse Exp $
-dnl @author  Guido Draheim <guidod@gmx.de> 
-
-AC_DEFUN([AX_CREATE_STDINT_H],
-[# ------ AX CREATE STDINT H -------------------------------------
-AC_MSG_CHECKING([for stdint types])
-ac_stdint_h=`echo ifelse($1, , _stdint.h, $1)`
-# try to shortcircuit - if the default include path of the compiler
-# can find a "stdint.h" header then we assume that all compilers can.
-AC_CACHE_VAL([ac_cv_header_stdint_t],[
-old_CXXFLAGS="$CXXFLAGS" ; CXXFLAGS=""
-old_CPPFLAGS="$CPPFLAGS" ; CPPFLAGS=""
-old_CFLAGS="$CFLAGS"     ; CFLAGS=""
-AC_TRY_COMPILE([#include <stdint.h>],[int_least32_t v = 0;],
-[ac_cv_stdint_result="(assuming C99 compatible system)"
- ac_cv_header_stdint_t="stdint.h"; ],
-[ac_cv_header_stdint_t=""])
-CXXFLAGS="$old_CXXFLAGS"
-CPPFLAGS="$old_CPPFLAGS"
-CFLAGS="$old_CFLAGS" ])
-
-v="... $ac_cv_header_stdint_h"
-if test "$ac_stdint_h" = "stdint.h" ; then
- AC_MSG_RESULT([(are you sure you want them in ./stdint.h?)])
-elif test "$ac_stdint_h" = "inttypes.h" ; then
- AC_MSG_RESULT([(are you sure you want them in ./inttypes.h?)])
-elif test "_$ac_cv_header_stdint_t" = "_" ; then
- AC_MSG_RESULT([(putting them into $ac_stdint_h)$v])
-else
- ac_cv_header_stdint="$ac_cv_header_stdint_t"
- AC_MSG_RESULT([$ac_cv_header_stdint (shortcircuit)])
-fi
-
-if test "_$ac_cv_header_stdint_t" = "_" ; then # can not shortcircuit..
-
-dnl .....intro message done, now do a few system checks.....
-dnl btw, all CHECK_TYPE macros do automatically "DEFINE" a type, therefore
-dnl we use the autoconf implementation detail _AC CHECK_TYPE_NEW instead
-
-inttype_headers=`echo $2 | sed -e 's/,/ /g'`
-
-ac_cv_stdint_result="(no helpful system typedefs seen)"
-AC_CACHE_CHECK([for stdint uintptr_t], [ac_cv_header_stdint_x],[
- ac_cv_header_stdint_x="" # the 1997 typedefs (inttypes.h)
-  AC_MSG_RESULT([(..)])
-  for i in stdint.h inttypes.h sys/inttypes.h $inttype_headers ; do
-   unset ac_cv_type_uintptr_t 
-   unset ac_cv_type_uint64_t
-   _AC_CHECK_TYPE_NEW(uintptr_t,[ac_cv_header_stdint_x=$i],dnl
-     continue,[#include <$i>])
-   AC_CHECK_TYPE(uint64_t,[and64="/uint64_t"],[and64=""],[#include<$i>])
-   ac_cv_stdint_result="(seen uintptr_t$and64 in $i)"
-   break;
-  done
-  AC_MSG_CHECKING([for stdint uintptr_t])
- ])
-
-if test "_$ac_cv_header_stdint_x" = "_" ; then
-AC_CACHE_CHECK([for stdint uint32_t], [ac_cv_header_stdint_o],[
- ac_cv_header_stdint_o="" # the 1995 typedefs (sys/inttypes.h)
-  AC_MSG_RESULT([(..)])
-  for i in inttypes.h sys/inttypes.h stdint.h $inttype_headers ; do
-   unset ac_cv_type_uint32_t
-   unset ac_cv_type_uint64_t
-   AC_CHECK_TYPE(uint32_t,[ac_cv_header_stdint_o=$i],dnl
-     continue,[#include <$i>])
-   AC_CHECK_TYPE(uint64_t,[and64="/uint64_t"],[and64=""],[#include<$i>])
-   ac_cv_stdint_result="(seen uint32_t$and64 in $i)"
-   break;
-  done
-  AC_MSG_CHECKING([for stdint uint32_t])
- ])
-fi
-
-if test "_$ac_cv_header_stdint_x" = "_" ; then
-if test "_$ac_cv_header_stdint_o" = "_" ; then
-AC_CACHE_CHECK([for stdint u_int32_t], [ac_cv_header_stdint_u],[
- ac_cv_header_stdint_u="" # the BSD typedefs (sys/types.h)
-  AC_MSG_RESULT([(..)])
-  for i in sys/types.h inttypes.h sys/inttypes.h $inttype_headers ; do
-   unset ac_cv_type_u_int32_t
-   unset ac_cv_type_u_int64_t
-   AC_CHECK_TYPE(u_int32_t,[ac_cv_header_stdint_u=$i],dnl
-     continue,[#include <$i>])
-   AC_CHECK_TYPE(u_int64_t,[and64="/u_int64_t"],[and64=""],[#include<$i>])
-   ac_cv_stdint_result="(seen u_int32_t$and64 in $i)"
-   break;
-  done
-  AC_MSG_CHECKING([for stdint u_int32_t])
- ])
-fi fi
-
-dnl if there was no good C99 header file, do some typedef checks...
-if test "_$ac_cv_header_stdint_x" = "_" ; then
-   AC_MSG_CHECKING([for stdint datatype model])
-   AC_MSG_RESULT([(..)])
-   AC_CHECK_SIZEOF(char)
-   AC_CHECK_SIZEOF(short)
-   AC_CHECK_SIZEOF(int)
-   AC_CHECK_SIZEOF(long)
-   AC_CHECK_SIZEOF(void*)
-   ac_cv_stdint_char_model=""
-   ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_char"
-   ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_short"
-   ac_cv_stdint_char_model="$ac_cv_stdint_char_model$ac_cv_sizeof_int"
-   ac_cv_stdint_long_model=""
-   ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_int"
-   ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_long"
-   ac_cv_stdint_long_model="$ac_cv_stdint_long_model$ac_cv_sizeof_voidp"
-   name="$ac_cv_stdint_long_model"
-   case "$ac_cv_stdint_char_model/$ac_cv_stdint_long_model" in
-    122/242)     name="$name,  IP16 (standard 16bit machine)" ;;
-    122/244)     name="$name,  LP32 (standard 32bit mac/win)" ;;
-    122/*)       name="$name        (unusual int16 model)" ;; 
-    124/444)     name="$name, ILP32 (standard 32bit unixish)" ;;
-    124/488)     name="$name,  LP64 (standard 64bit unixish)" ;;
-    124/448)     name="$name, LLP64 (unusual  64bit unixish)" ;;
-    124/*)       name="$name        (unusual int32 model)" ;; 
-    128/888)     name="$name, ILP64 (unusual  64bit numeric)" ;;
-    128/*)       name="$name        (unusual int64 model)" ;; 
-    222/*|444/*) name="$name        (unusual dsptype)" ;;
-     *)          name="$name        (very unusal model)" ;;
-   esac
-   AC_MSG_RESULT([combined for stdint datatype model...  $name])
-fi
-
-if test "_$ac_cv_header_stdint_x" != "_" ; then
-   ac_cv_header_stdint="$ac_cv_header_stdint_x"
-elif  test "_$ac_cv_header_stdint_o" != "_" ; then
-   ac_cv_header_stdint="$ac_cv_header_stdint_o"
-elif  test "_$ac_cv_header_stdint_u" != "_" ; then
-   ac_cv_header_stdint="$ac_cv_header_stdint_u"
-else
-   ac_cv_header_stdint="stddef.h"
-fi
-
-AC_MSG_CHECKING([for extra inttypes in chosen header])
-AC_MSG_RESULT([($ac_cv_header_stdint)])
-dnl see if int_least and int_fast types are present in _this_ header.
-unset ac_cv_type_int_least32_t
-unset ac_cv_type_int_fast32_t
-AC_CHECK_TYPE(int_least32_t,,,[#include <$ac_cv_header_stdint>])
-AC_CHECK_TYPE(int_fast32_t,,,[#include<$ac_cv_header_stdint>])
-AC_CHECK_TYPE(intmax_t,,,[#include <$ac_cv_header_stdint>])
-
-fi # shortcircut to system "stdint.h"
-# ------------------ PREPARE VARIABLES ------------------------------
-if test "$GCC" = "yes" ; then
-ac_cv_stdint_message="using gnu compiler "`$CC --version | head -1` 
-else
-ac_cv_stdint_message="using $CC"
-fi
-
-AC_MSG_RESULT([make use of $ac_cv_header_stdint in $ac_stdint_h dnl
-$ac_cv_stdint_result])
-
-# ----------------- DONE inttypes.h checks START header -------------
-AC_CONFIG_COMMANDS([$ac_stdint_h],[
-AC_MSG_NOTICE(creating $ac_stdint_h : $_ac_stdint_h)
-ac_stdint=$tmp/_stdint.h
-
-echo "#ifndef" $_ac_stdint_h >$ac_stdint
-echo "#define" $_ac_stdint_h "1" >>$ac_stdint
-echo "#ifndef" _GENERATED_STDINT_H >>$ac_stdint
-echo "#define" _GENERATED_STDINT_H '"'$PACKAGE $VERSION'"' >>$ac_stdint
-echo "/* generated $ac_cv_stdint_message */" >>$ac_stdint
-if test "_$ac_cv_header_stdint_t" != "_" ; then 
-echo "#define _STDINT_HAVE_STDINT_H" "1" >>$ac_stdint
-fi
-
-cat >>$ac_stdint <<STDINT_EOF
-
-/* ................... shortcircuit part ........................... */
-
-#if defined HAVE_STDINT_H || defined _STDINT_HAVE_STDINT_H
-#include <stdint.h>
-#else
-#include <stddef.h>
-
-/* .................... configured part ............................ */
-
-STDINT_EOF
-
-echo "/* whether we have a C99 compatible stdint header file */" >>$ac_stdint
-if test "_$ac_cv_header_stdint_x" != "_" ; then
-  ac_header="$ac_cv_header_stdint_x"
-  echo "#define _STDINT_HEADER_INTPTR" '"'"$ac_header"'"' >>$ac_stdint
-else
-  echo "/* #undef _STDINT_HEADER_INTPTR */" >>$ac_stdint
-fi
-
-echo "/* whether we have a C96 compatible inttypes header file */" >>$ac_stdint
-if  test "_$ac_cv_header_stdint_o" != "_" ; then
-  ac_header="$ac_cv_header_stdint_o"
-  echo "#define _STDINT_HEADER_UINT32" '"'"$ac_header"'"' >>$ac_stdint
-else
-  echo "/* #undef _STDINT_HEADER_UINT32 */" >>$ac_stdint
-fi
-
-echo "/* whether we have a BSD compatible inet types header */" >>$ac_stdint
-if  test "_$ac_cv_header_stdint_u" != "_" ; then
-  ac_header="$ac_cv_header_stdint_u"
-  echo "#define _STDINT_HEADER_U_INT32" '"'"$ac_header"'"' >>$ac_stdint
-else
-  echo "/* #undef _STDINT_HEADER_U_INT32 */" >>$ac_stdint
-fi
-
-echo "" >>$ac_stdint
-
-if test "_$ac_header" != "_" ; then if test "$ac_header" != "stddef.h" ; then
-  echo "#include <$ac_header>" >>$ac_stdint
-  echo "" >>$ac_stdint
-fi fi
-
-echo "/* which 64bit typedef has been found */" >>$ac_stdint
-if test "$ac_cv_type_uint64_t" = "yes" ; then
-echo "#define   _STDINT_HAVE_UINT64_T" "1"  >>$ac_stdint
-else
-echo "/* #undef _STDINT_HAVE_UINT64_T */" >>$ac_stdint
-fi
-if test "$ac_cv_type_u_int64_t" = "yes" ; then
-echo "#define   _STDINT_HAVE_U_INT64_T" "1"  >>$ac_stdint
-else
-echo "/* #undef _STDINT_HAVE_U_INT64_T */" >>$ac_stdint
-fi
-echo "" >>$ac_stdint
-
-echo "/* which type model has been detected */" >>$ac_stdint
-if test "_$ac_cv_stdint_char_model" != "_" ; then
-echo "#define   _STDINT_CHAR_MODEL" "$ac_cv_stdint_char_model" >>$ac_stdint
-echo "#define   _STDINT_LONG_MODEL" "$ac_cv_stdint_long_model" >>$ac_stdint
-else
-echo "/* #undef _STDINT_CHAR_MODEL // skipped */" >>$ac_stdint
-echo "/* #undef _STDINT_LONG_MODEL // skipped */" >>$ac_stdint
-fi
-echo "" >>$ac_stdint
-
-echo "/* whether int_least types were detected */" >>$ac_stdint
-if test "$ac_cv_type_int_least32_t" = "yes"; then
-echo "#define   _STDINT_HAVE_INT_LEAST32_T" "1"  >>$ac_stdint
-else
-echo "/* #undef _STDINT_HAVE_INT_LEAST32_T */" >>$ac_stdint
-fi
-echo "/* whether int_fast types were detected */" >>$ac_stdint
-if test "$ac_cv_type_int_fast32_t" = "yes"; then
-echo "#define   _STDINT_HAVE_INT_FAST32_T" "1" >>$ac_stdint
-else
-echo "/* #undef _STDINT_HAVE_INT_FAST32_T */" >>$ac_stdint
-fi
-echo "/* whether intmax_t type was detected */" >>$ac_stdint
-if test "$ac_cv_type_intmax_t" = "yes"; then
-echo "#define   _STDINT_HAVE_INTMAX_T" "1" >>$ac_stdint
-else
-echo "/* #undef _STDINT_HAVE_INTMAX_T */" >>$ac_stdint
-fi
-echo "" >>$ac_stdint
-
-  cat >>$ac_stdint <<STDINT_EOF
-/* .................... detections part ............................ */
-
-/* whether we need to define bitspecific types from compiler base types */
-#ifndef _STDINT_HEADER_INTPTR
-#ifndef _STDINT_HEADER_UINT32
-#ifndef _STDINT_HEADER_U_INT32
-#define _STDINT_NEED_INT_MODEL_T
-#else
-#define _STDINT_HAVE_U_INT_TYPES
-#endif
-#endif
-#endif
-
-#ifdef _STDINT_HAVE_U_INT_TYPES
-#undef _STDINT_NEED_INT_MODEL_T
-#endif
-
-#ifdef  _STDINT_CHAR_MODEL
-#if     _STDINT_CHAR_MODEL+0 == 122 || _STDINT_CHAR_MODEL+0 == 124
-#ifndef _STDINT_BYTE_MODEL
-#define _STDINT_BYTE_MODEL 12
-#endif
-#endif
-#endif
-
-#ifndef _STDINT_HAVE_INT_LEAST32_T
-#define _STDINT_NEED_INT_LEAST_T
-#endif
-
-#ifndef _STDINT_HAVE_INT_FAST32_T
-#define _STDINT_NEED_INT_FAST_T
-#endif
-
-#ifndef _STDINT_HEADER_INTPTR
-#define _STDINT_NEED_INTPTR_T
-#ifndef _STDINT_HAVE_INTMAX_T
-#define _STDINT_NEED_INTMAX_T
-#endif
-#endif
-
-
-/* .................... definition part ............................ */
-
-/* some system headers have good uint64_t */
-#ifndef _HAVE_UINT64_T
-#if     defined _STDINT_HAVE_UINT64_T  || defined HAVE_UINT64_T
-#define _HAVE_UINT64_T
-#elif   defined _STDINT_HAVE_U_INT64_T || defined HAVE_U_INT64_T
-#define _HAVE_UINT64_T
-typedef u_int64_t uint64_t;
-#endif
-#endif
-
-#ifndef _HAVE_UINT64_T
-/* .. here are some common heuristics using compiler runtime specifics */
-#if defined __STDC_VERSION__ && defined __STDC_VERSION__ >= 199901L
-#define _HAVE_UINT64_T
-typedef long long int64_t;
-typedef unsigned long long uint64_t;
-
-#elif !defined __STRICT_ANSI__
-#if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
-#define _HAVE_UINT64_T
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-
-#elif defined __GNUC__ || defined __MWERKS__ || defined __ELF__
-/* note: all ELF-systems seem to have loff-support which needs 64-bit */
-#if !defined _NO_LONGLONG
-#define _HAVE_UINT64_T
-typedef long long int64_t;
-typedef unsigned long long uint64_t;
-#endif
-
-#elif defined __alpha || (defined __mips && defined _ABIN32)
-#if !defined _NO_LONGLONG
-typedef long int64_t;
-typedef unsigned long uint64_t;
-#endif
-  /* compiler/cpu type to define int64_t */
-#endif
-#endif
-#endif
-
-#if defined _STDINT_HAVE_U_INT_TYPES
-/* int8_t int16_t int32_t defined by inet code, redeclare the u_intXX types */
-typedef u_int8_t uint8_t;
-typedef u_int16_t uint16_t;
-typedef u_int32_t uint32_t;
-
-/* glibc compatibility */
-#ifndef __int8_t_defined
-#define __int8_t_defined
-#endif
-#endif
-
-#ifdef _STDINT_NEED_INT_MODEL_T
-/* we must guess all the basic types. Apart from byte-adressable system, */
-/* there a few 32-bit-only dsp-systems that we guard with BYTE_MODEL 8-} */
-/* (btw, those nibble-addressable systems are way off, or so we assume) */
-
-dnl   /* have a look at "64bit and data size neutrality" at */
-dnl   /* http://unix.org/version2/whatsnew/login_64bit.html */
-dnl   /* (the shorthand "ILP" types always have a "P" part) */
-
-#if defined _STDINT_BYTE_MODEL
-#if _STDINT_LONG_MODEL+0 == 242
-/* 2:4:2 =  IP16 = a normal 16-bit system                */
-typedef unsigned char   uint8_t;
-typedef unsigned short  uint16_t;
-typedef unsigned long   uint32_t;
-#ifndef __int8_t_defined
-#define __int8_t_defined
-typedef          char    int8_t;
-typedef          short   int16_t;
-typedef          long    int32_t;
-#endif
-#elif _STDINT_LONG_MODEL+0 == 244 || _STDINT_LONG_MODEL == 444
-/* 2:4:4 =  LP32 = a 32-bit system derived from a 16-bit */
-/* 4:4:4 = ILP32 = a normal 32-bit system                */
-typedef unsigned char   uint8_t;
-typedef unsigned short  uint16_t;
-typedef unsigned int    uint32_t;
-#ifndef __int8_t_defined
-#define __int8_t_defined
-typedef          char    int8_t;
-typedef          short   int16_t;
-typedef          int     int32_t;
-#endif
-#elif _STDINT_LONG_MODEL+0 == 484 || _STDINT_LONG_MODEL+0 == 488
-/* 4:8:4 =  IP32 = a 32-bit system prepared for 64-bit    */
-/* 4:8:8 =  LP64 = a normal 64-bit system                 */
-typedef unsigned char   uint8_t;
-typedef unsigned short  uint16_t;
-typedef unsigned int    uint32_t;
-#ifndef __int8_t_defined
-#define __int8_t_defined
-typedef          char    int8_t;
-typedef          short   int16_t;
-typedef          int     int32_t;
-#endif
-/* this system has a "long" of 64bit */
-#ifndef _HAVE_UINT64_T
-#define _HAVE_UINT64_T
-typedef unsigned long   uint64_t;
-typedef          long    int64_t;
-#endif
-#elif _STDINT_LONG_MODEL+0 == 448
-/*      LLP64   a 64-bit system derived from a 32-bit system */
-typedef unsigned char   uint8_t;
-typedef unsigned short  uint16_t;
-typedef unsigned int    uint32_t;
-#ifndef __int8_t_defined
-#define __int8_t_defined
-typedef          char    int8_t;
-typedef          short   int16_t;
-typedef          int     int32_t;
-#endif
-/* assuming the system has a "long long" */
-#ifndef _HAVE_UINT64_T
-#define _HAVE_UINT64_T
-typedef unsigned long long uint64_t;
-typedef          long long  int64_t;
-#endif
-#else
-#define _STDINT_NO_INT32_T
-#endif
-#else
-#define _STDINT_NO_INT8_T
-#define _STDINT_NO_INT32_T
-#endif
-#endif
-
-/*
- * quote from SunOS-5.8 sys/inttypes.h:
- * Use at your own risk.  As of February 1996, the committee is squarely
- * behind the fixed sized types; the "least" and "fast" types are still being
- * discussed.  The probability that the "fast" types may be removed before
- * the standard is finalized is high enough that they are not currently
- * implemented.
- */
-
-#if defined _STDINT_NEED_INT_LEAST_T
-typedef  int8_t    int_least8_t;
-typedef  int16_t   int_least16_t;
-typedef  int32_t   int_least32_t;
-#ifdef _HAVE_UINT64_T
-typedef  int64_t   int_least64_t;
-#endif
-
-typedef uint8_t   uint_least8_t;
-typedef uint16_t  uint_least16_t;
-typedef uint32_t  uint_least32_t;
-#ifdef _HAVE_UINT64_T
-typedef uint64_t  uint_least64_t;
-#endif
-  /* least types */
-#endif
-
-#if defined _STDINT_NEED_INT_FAST_T
-typedef  int8_t    int_fast8_t; 
-typedef  int       int_fast16_t;
-typedef  int32_t   int_fast32_t;
-#ifdef _HAVE_UINT64_T
-typedef  int64_t   int_fast64_t;
-#endif
-
-typedef uint8_t   uint_fast8_t; 
-typedef unsigned  uint_fast16_t;
-typedef uint32_t  uint_fast32_t;
-#ifdef _HAVE_UINT64_T
-typedef uint64_t  uint_fast64_t;
-#endif
-  /* fast types */
-#endif
-
-#ifdef _STDINT_NEED_INTMAX_T
-#ifdef _HAVE_UINT64_T
-typedef  int64_t       intmax_t;
-typedef uint64_t      uintmax_t;
-#else
-typedef          long  intmax_t;
-typedef unsigned long uintmax_t;
-#endif
-#endif
-
-#ifdef _STDINT_NEED_INTPTR_T
-#ifndef __intptr_t_defined
-#define __intptr_t_defined
-/* we encourage using "long" to store pointer values, never use "int" ! */
-#if   _STDINT_LONG_MODEL+0 == 242 || _STDINT_LONG_MODEL+0 == 484
-typedef  unsinged int   uintptr_t;
-typedef           int    intptr_t;
-#elif _STDINT_LONG_MODEL+0 == 244 || _STDINT_LONG_MODEL+0 == 444
-typedef  unsigned long  uintptr_t;
-typedef           long   intptr_t;
-#elif _STDINT_LONG_MODEL+0 == 448 && defined _HAVE_UINT64_T
-typedef        uint64_t uintptr_t;
-typedef         int64_t  intptr_t;
-#else /* matches typical system types ILP32 and LP64 - but not IP16 or LLP64 */
-typedef  unsigned long  uintptr_t;
-typedef           long   intptr_t;
-#endif
-#endif
-#endif
-
-  /* shortcircuit*/
-#endif
-  /* once */
-#endif
-#endif
-STDINT_EOF
-    if cmp -s $ac_stdint_h $ac_stdint 2>/dev/null; then
-      AC_MSG_NOTICE([$ac_stdint_h is unchanged])
-    else
-      ac_dir=`AS_DIRNAME(["$ac_stdint_h"])`
-      AS_MKDIR_P(["$ac_dir"])
-      rm -f $ac_stdint_h
-      mv $ac_stdint $ac_stdint_h
-    fi
-],[# variables for create stdint.h replacement
-PACKAGE="$PACKAGE"
-VERSION="$VERSION"
-ac_stdint_h="$ac_stdint_h"
-_ac_stdint_h=AS_TR_CPP(_$PACKAGE-$ac_stdint_h)
-ac_cv_stdint_message="$ac_cv_stdint_message"
-ac_cv_header_stdint_t="$ac_cv_header_stdint_t"
-ac_cv_header_stdint_x="$ac_cv_header_stdint_x"
-ac_cv_header_stdint_o="$ac_cv_header_stdint_o"
-ac_cv_header_stdint_u="$ac_cv_header_stdint_u"
-ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
-ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
-ac_cv_stdint_char_model="$ac_cv_stdint_char_model"
-ac_cv_stdint_long_model="$ac_cv_stdint_long_model"
-ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
-ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
-ac_cv_type_intmax_t="$ac_cv_type_intmax_t"
-])
-])
diff --git a/contrib/argp-standalone/argp-ba.c b/contrib/argp-standalone/argp-ba.c
deleted file mode 100644
index 0d3958c1151..00000000000
--- a/contrib/argp-standalone/argp-ba.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Default definition for ARGP_PROGRAM_BUG_ADDRESS.
-   Copyright (C) 1996, 1997, 1999, 2004 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* If set by the user program, it should point to string that is the
-   bug-reporting address for the program.  It will be printed by argp_help if
-   the ARGP_HELP_BUG_ADDR flag is set (as it is by various standard help
-   messages), embedded in a sentence that says something like `Report bugs to
-   ADDR.'.  */
-const char *argp_program_bug_address = 0;
diff --git a/contrib/argp-standalone/argp-eexst.c b/contrib/argp-standalone/argp-eexst.c
deleted file mode 100644
index 46b27847ad4..00000000000
--- a/contrib/argp-standalone/argp-eexst.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/* Default definition for ARGP_ERR_EXIT_STATUS
-   Copyright (C) 1997 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#if HAVE_SYSEXITS_H
-# include <sysexits.h>
-#else
-# define EX_USAGE 64
-#endif
-
-#include "argp.h"
-
-/* The exit status that argp will use when exiting due to a parsing error.
-   If not defined or set by the user program, this defaults to EX_USAGE from
-   <sysexits.h>.  */
-error_t argp_err_exit_status = EX_USAGE;
diff --git a/contrib/argp-standalone/argp-fmtstream.c b/contrib/argp-standalone/argp-fmtstream.c
deleted file mode 100644
index 494b6b31d12..00000000000
--- a/contrib/argp-standalone/argp-fmtstream.c
+++ /dev/null
@@ -1,477 +0,0 @@
-/* Word-wrapping and line-truncating streams
-   Copyright (C) 1997, 1998, 1999, 2001 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* This package emulates glibc `line_wrap_stream' semantics for systems that
-   don't have that.  */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <ctype.h>
-
-#include "argp-fmtstream.h"
-#include "argp-namefrob.h"
-
-#ifndef ARGP_FMTSTREAM_USE_LINEWRAP
-
-#ifndef isblank
-#define isblank(ch) ((ch)==' ' || (ch)=='\t')
-#endif
-
-#if defined _LIBC && defined USE_IN_LIBIO
-# include <libio/libioP.h>
-# define __vsnprintf(s, l, f, a) _IO_vsnprintf (s, l, f, a)
-#endif
-
-#define INIT_BUF_SIZE 200
-#define PRINTF_SIZE_GUESS 150
-
-/* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
-   written on it with LMARGIN spaces and limits them to RMARGIN columns
-   total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
-   replacing the whitespace before them with a newline and WMARGIN spaces.
-   Otherwise, chars beyond RMARGIN are simply dropped until a newline.
-   Returns NULL if there was an error.  */
-argp_fmtstream_t
-__argp_make_fmtstream (FILE *stream,
-		       size_t lmargin, size_t rmargin, ssize_t wmargin)
-{
-  argp_fmtstream_t fs = malloc (sizeof (struct argp_fmtstream));
-  if (fs)
-    {
-      fs->stream = stream;
-
-      fs->lmargin = lmargin;
-      fs->rmargin = rmargin;
-      fs->wmargin = wmargin;
-      fs->point_col = 0;
-      fs->point_offs = 0;
-
-      fs->buf = malloc (INIT_BUF_SIZE);
-      if (! fs->buf)
-	{
-	  free (fs);
-	  fs = 0;
-	}
-      else
-	{
-	  fs->p = fs->buf;
-	  fs->end = fs->buf + INIT_BUF_SIZE;
-	}
-    }
-
-  return fs;
-}
-#ifdef weak_alias
-weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
-#endif
-
-/* Flush FS to its stream, and free it (but don't close the stream).  */
-void
-__argp_fmtstream_free (argp_fmtstream_t fs)
-{
-  __argp_fmtstream_update (fs);
-  if (fs->p > fs->buf)
-    FWRITE_UNLOCKED (fs->buf, 1, fs->p - fs->buf, fs->stream);
-  free (fs->buf);
-  free (fs);
-}
-#ifdef weak_alias
-weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
-#endif
-
-/* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
-   end of its buffer.  This code is mostly from glibc stdio/linewrap.c.  */
-void
-__argp_fmtstream_update (argp_fmtstream_t fs)
-{
-  char *buf, *nl;
-  size_t len;
-
-  /* Scan the buffer for newlines.  */
-  buf = fs->buf + fs->point_offs;
-  while (buf < fs->p)
-    {
-      size_t r;
-
-      if (fs->point_col == 0 && fs->lmargin != 0)
-	{
-	  /* We are starting a new line.  Print spaces to the left margin.  */
-	  const size_t pad = fs->lmargin;
-	  if (fs->p + pad < fs->end)
-	    {
-	      /* We can fit in them in the buffer by moving the
-		 buffer text up and filling in the beginning.  */
-	      memmove (buf + pad, buf, fs->p - buf);
-	      fs->p += pad; /* Compensate for bigger buffer. */
-	      memset (buf, ' ', pad); /* Fill in the spaces.  */
-	      buf += pad; /* Don't bother searching them.  */
-	    }
-	  else
-	    {
-	      /* No buffer space for spaces.  Must flush.  */
-	      size_t i;
-	      for (i = 0; i < pad; i++)
-		PUTC_UNLOCKED (' ', fs->stream);
-	    }
-	  fs->point_col = pad;
-	}
-
-      len = fs->p - buf;
-      nl = memchr (buf, '\n', len);
-
-      if (fs->point_col < 0)
-	fs->point_col = 0;
-
-      if (!nl)
-	{
-	  /* The buffer ends in a partial line.  */
-
-	  if (fs->point_col + len < fs->rmargin)
-	    {
-	      /* The remaining buffer text is a partial line and fits
-		 within the maximum line width.  Advance point for the
-		 characters to be written and stop scanning.  */
-	      fs->point_col += len;
-	      break;
-	    }
-	  else
-	    /* Set the end-of-line pointer for the code below to
-	       the end of the buffer.  */
-	    nl = fs->p;
-	}
-      else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
-	{
-	  /* The buffer contains a full line that fits within the maximum
-	     line width.  Reset point and scan the next line.  */
-	  fs->point_col = 0;
-	  buf = nl + 1;
-	  continue;
-	}
-
-      /* This line is too long.  */
-      r = fs->rmargin - 1;
-
-      if (fs->wmargin < 0)
-	{
-	  /* Truncate the line by overwriting the excess with the
-	     newline and anything after it in the buffer.  */
-	  if (nl < fs->p)
-	    {
-	      memmove (buf + (r - fs->point_col), nl, fs->p - nl);
-	      fs->p -= buf + (r - fs->point_col) - nl;
-	      /* Reset point for the next line and start scanning it.  */
-	      fs->point_col = 0;
-	      buf += r + 1; /* Skip full line plus \n. */
-	    }
-	  else
-	    {
-	      /* The buffer ends with a partial line that is beyond the
-		 maximum line width.  Advance point for the characters
-		 written, and discard those past the max from the buffer.  */
-	      fs->point_col += len;
-	      fs->p -= fs->point_col - r;
-	      break;
-	    }
-	}
-      else
-	{
-	  /* Do word wrap.  Go to the column just past the maximum line
-	     width and scan back for the beginning of the word there.
-	     Then insert a line break.  */
-
-	  char *p, *nextline;
-	  int i;
-
-	  p = buf + (r + 1 - fs->point_col);
-	  while (p >= buf && !isblank (*p))
-	    --p;
-	  nextline = p + 1;	/* This will begin the next line.  */
-
-	  if (nextline > buf)
-	    {
-	      /* Swallow separating blanks.  */
-	      if (p >= buf)
-		do
-		  --p;
-		while (p >= buf && isblank (*p));
-	      nl = p + 1;	/* The newline will replace the first blank. */
-	    }
-	  else
-	    {
-	      /* A single word that is greater than the maximum line width.
-		 Oh well.  Put it on an overlong line by itself.  */
-	      p = buf + (r + 1 - fs->point_col);
-	      /* Find the end of the long word.  */
-	      do
-		++p;
-	      while (p < nl && !isblank (*p));
-	      if (p == nl)
-		{
-		  /* It already ends a line.  No fussing required.  */
-		  fs->point_col = 0;
-		  buf = nl + 1;
-		  continue;
-		}
-	      /* We will move the newline to replace the first blank.  */
-	      nl = p;
-	      /* Swallow separating blanks.  */
-	      do
-		++p;
-	      while (isblank (*p));
-	      /* The next line will start here.  */
-	      nextline = p;
-	    }
-
-	  /* Note: There are a bunch of tests below for
-	     NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
-	     at the end of the buffer, and NEXTLINE is in fact empty (and so
-	     we need not be careful to maintain its contents).  */
-
-	  if (nextline == buf + len + 1
-	      ? fs->end - nl < fs->wmargin + 1
-	      : nextline - (nl + 1) < fs->wmargin)
-	    {
-	      /* The margin needs more blanks than we removed.  */
-	      if (fs->end - fs->p > fs->wmargin + 1)
-		/* Make some space for them.  */
-		{
-		  size_t mv = fs->p - nextline;
-		  memmove (nl + 1 + fs->wmargin, nextline, mv);
-		  nextline = nl + 1 + fs->wmargin;
-		  len = nextline + mv - buf;
-		  *nl++ = '\n';
-		}
-	      else
-		/* Output the first line so we can use the space.  */
-		{
-		  if (nl > fs->buf)
-		    FWRITE_UNLOCKED (fs->buf, 1, nl - fs->buf, fs->stream);
-		  PUTC_UNLOCKED ('\n', fs->stream);
-		  len += buf - fs->buf;
-		  nl = buf = fs->buf;
-		}
-	    }
-	  else
-	    /* We can fit the newline and blanks in before
-	       the next word.  */
-	    *nl++ = '\n';
-
-	  if (nextline - nl >= fs->wmargin
-	      || (nextline == buf + len + 1 && fs->end - nextline >= fs->wmargin))
-	    /* Add blanks up to the wrap margin column.  */
-	    for (i = 0; i < fs->wmargin; ++i)
-	      *nl++ = ' ';
-	  else
-	    for (i = 0; i < fs->wmargin; ++i)
-	      PUTC_UNLOCKED (' ', fs->stream);
-
-	  /* Copy the tail of the original buffer into the current buffer
-	     position.  */
-	  if (nl < nextline)
-	    memmove (nl, nextline, buf + len - nextline);
-	  len -= nextline - buf;
-
-	  /* Continue the scan on the remaining lines in the buffer.  */
-	  buf = nl;
-
-	  /* Restore bufp to include all the remaining text.  */
-	  fs->p = nl + len;
-
-	  /* Reset the counter of what has been output this line.  If wmargin
-	     is 0, we want to avoid the lmargin getting added, so we set
-	     point_col to a magic value of -1 in that case.  */
-	  fs->point_col = fs->wmargin ? fs->wmargin : -1;
-	}
-    }
-
-  /* Remember that we've scanned as far as the end of the buffer.  */
-  fs->point_offs = fs->p - fs->buf;
-}
-
-/* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
-   growing the buffer, or by flushing it.  True is returned iff we succeed. */
-int
-__argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
-{
-  if ((size_t) (fs->end - fs->p) < amount)
-    {
-      ssize_t wrote;
-
-      /* Flush FS's buffer.  */
-      __argp_fmtstream_update (fs);
-
-      wrote = FWRITE_UNLOCKED (fs->buf, 1, fs->p - fs->buf, fs->stream);
-      if (wrote == fs->p - fs->buf)
-	{
-	  fs->p = fs->buf;
-	  fs->point_offs = 0;
-	}
-      else
-	{
-	  fs->p -= wrote;
-	  fs->point_offs -= wrote;
-	  memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
-	  return 0;
-	}
-
-      if ((size_t) (fs->end - fs->buf) < amount)
-	/* Gotta grow the buffer.  */
-	{
-	  size_t new_size = fs->end - fs->buf + amount;
-	  char *new_buf = realloc (fs->buf, new_size);
-
-	  if (! new_buf)
-	    {
-	      __set_errno (ENOMEM);
-	      return 0;
-	    }
-
-	  fs->buf = new_buf;
-	  fs->end = new_buf + new_size;
-	  fs->p = fs->buf;
-	}
-    }
-
-  return 1;
-}
-
-ssize_t
-__argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
-{
-  size_t out;
-  size_t avail;
-  size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
-
-  do
-    {
-      va_list args;
-
-      if (! __argp_fmtstream_ensure (fs, size_guess))
-	return -1;
-
-      va_start (args, fmt);
-      avail = fs->end - fs->p;
-      out = __vsnprintf (fs->p, avail, fmt, args);
-      va_end (args);
-      if (out >= avail)
-	size_guess = out + 1;
-    }
-  while (out >= avail);
-
-  fs->p += out;
-
-  return out;
-}
-#ifdef weak_alias
-weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
-#endif
-
-#if __STDC_VERSION__ - 199900L < 1
-/* Duplicate the inline definitions in argp-fmtstream.h, for compilers
- * that don't do inlining. */
-size_t
-__argp_fmtstream_write (argp_fmtstream_t __fs,
-			__const char *__str, size_t __len)
-{
-  if (__fs->p + __len <= __fs->end || __argp_fmtstream_ensure (__fs, __len))
-    {
-      memcpy (__fs->p, __str, __len);
-      __fs->p += __len;
-      return __len;
-    }
-  else
-    return 0;
-}
-
-int
-__argp_fmtstream_puts (argp_fmtstream_t __fs, __const char *__str)
-{
-  size_t __len = strlen (__str);
-  if (__len)
-    {
-      size_t __wrote = __argp_fmtstream_write (__fs, __str, __len);
-      return __wrote == __len ? 0 : -1;
-    }
-  else
-    return 0;
-}
-
-int
-__argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch)
-{
-  if (__fs->p < __fs->end || __argp_fmtstream_ensure (__fs, 1))
-    return *__fs->p++ = __ch;
-  else
-    return EOF;
-}
-
-/* Set __FS's left margin to __LMARGIN and return the old value.  */
-size_t
-__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->lmargin;
-  __fs->lmargin = __lmargin;
-  return __old;
-}
-
-/* Set __FS's right margin to __RMARGIN and return the old value.  */
-size_t
-__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->rmargin;
-  __fs->rmargin = __rmargin;
-  return __old;
-}
-
-/* Set FS's wrap margin to __WMARGIN and return the old value.  */
-size_t
-__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->wmargin;
-  __fs->wmargin = __wmargin;
-  return __old;
-}
-
-/* Return the column number of the current output point in __FS.  */
-size_t
-__argp_fmtstream_point (argp_fmtstream_t __fs)
-{
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  return __fs->point_col >= 0 ? __fs->point_col : 0;
-}
-#endif /* __STDC_VERSION__ - 199900L < 1 */
-
-#endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */
diff --git a/contrib/argp-standalone/argp-fmtstream.h b/contrib/argp-standalone/argp-fmtstream.h
deleted file mode 100644
index 828f4357d56..00000000000
--- a/contrib/argp-standalone/argp-fmtstream.h
+++ /dev/null
@@ -1,327 +0,0 @@
-/* Word-wrapping and line-truncating streams.
-   Copyright (C) 1997, 2003 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* This package emulates glibc `line_wrap_stream' semantics for systems that
-   don't have that.  If the system does have it, it is just a wrapper for
-   that.  This header file is only used internally while compiling argp, and
-   shouldn't be installed.  */
-
-#ifndef _ARGP_FMTSTREAM_H
-#define _ARGP_FMTSTREAM_H
-
-#include <stdio.h>
-#include <string.h>
-
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#else
-/* This is a kludge to make the code compile on windows. Perhaps it
-   would be better to just replace ssize_t with int through out the
-   code. */
-# define ssize_t int
-#endif
-
-#if _LIBC || (defined (HAVE_FLOCKFILE) && defined(HAVE_PUTC_UNLOCKED) \
-     && defined (HAVE_FPUTS_UNLOCKED) && defined (HAVE_FWRITE_UNLOCKED) )
-/* Use locking funxtions */
-# define FLOCKFILE(f) flockfile(f)
-# define FUNLOCKFILE(f) funlockfile(f)
-# define PUTC_UNLOCKED(c, f) putc_unlocked((c), (f))
-# define FPUTS_UNLOCKED(s, f) fputs_unlocked((s), (f))
-# define FWRITE_UNLOCKED(b, s, n, f) fwrite_unlocked((b), (s), (n), (f))
-#else
-/* Disable stdio locking */
-# define FLOCKFILE(f)
-# define FUNLOCKFILE(f)
-# define PUTC_UNLOCKED(c, f) putc((c), (f))
-# define FPUTS_UNLOCKED(s, f) fputs((s), (f))
-# define FWRITE_UNLOCKED(b, s, n, f) fwrite((b), (s), (n), (f))
-#endif /* No thread safe i/o */
-
-#if    (_LIBC - 0 && !defined (USE_IN_LIBIO)) \
-    || (defined (__GNU_LIBRARY__) && defined (HAVE_LINEWRAP_H))
-/* line_wrap_stream is available, so use that.  */
-#define ARGP_FMTSTREAM_USE_LINEWRAP
-#endif
-
-#ifdef ARGP_FMTSTREAM_USE_LINEWRAP
-/* Just be a simple wrapper for line_wrap_stream; the semantics are
-   *slightly* different, as line_wrap_stream doesn't actually make a new
-   object, it just modifies the given stream (reversibly) to do
-   line-wrapping.  Since we control who uses this code, it doesn't matter.  */
-
-#include <linewrap.h>
-
-typedef FILE *argp_fmtstream_t;
-
-#define argp_make_fmtstream line_wrap_stream
-#define __argp_make_fmtstream line_wrap_stream
-#define argp_fmtstream_free line_unwrap_stream
-#define __argp_fmtstream_free line_unwrap_stream
-
-#define __argp_fmtstream_putc(fs,ch) putc(ch,fs)
-#define argp_fmtstream_putc(fs,ch) putc(ch,fs)
-#define __argp_fmtstream_puts(fs,str) fputs(str,fs)
-#define argp_fmtstream_puts(fs,str) fputs(str,fs)
-#define __argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
-#define argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
-#define __argp_fmtstream_printf fprintf
-#define argp_fmtstream_printf fprintf
-
-#define __argp_fmtstream_lmargin line_wrap_lmargin
-#define argp_fmtstream_lmargin line_wrap_lmargin
-#define __argp_fmtstream_set_lmargin line_wrap_set_lmargin
-#define argp_fmtstream_set_lmargin line_wrap_set_lmargin
-#define __argp_fmtstream_rmargin line_wrap_rmargin
-#define argp_fmtstream_rmargin line_wrap_rmargin
-#define __argp_fmtstream_set_rmargin line_wrap_set_rmargin
-#define argp_fmtstream_set_rmargin line_wrap_set_rmargin
-#define __argp_fmtstream_wmargin line_wrap_wmargin
-#define argp_fmtstream_wmargin line_wrap_wmargin
-#define __argp_fmtstream_set_wmargin line_wrap_set_wmargin
-#define argp_fmtstream_set_wmargin line_wrap_set_wmargin
-#define __argp_fmtstream_point line_wrap_point
-#define argp_fmtstream_point line_wrap_point
-
-#else /* !ARGP_FMTSTREAM_USE_LINEWRAP */
-/* Guess we have to define our own version.  */
-
-#ifndef __const
-#define __const const
-#endif
-
-
-struct argp_fmtstream
-{
-  FILE *stream;			/* The stream we're outputting to.  */
-
-  size_t lmargin, rmargin;	/* Left and right margins.  */
-  ssize_t wmargin;		/* Margin to wrap to, or -1 to truncate.  */
-
-  /* Point in buffer to which we've processed for wrapping, but not output.  */
-  size_t point_offs;
-  /* Output column at POINT_OFFS, or -1 meaning 0 but don't add lmargin.  */
-  ssize_t point_col;
-
-  char *buf;			/* Output buffer.  */
-  char *p;			/* Current end of text in BUF. */
-  char *end;			/* Absolute end of BUF.  */
-};
-
-typedef struct argp_fmtstream *argp_fmtstream_t;
-
-/* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
-   written on it with LMARGIN spaces and limits them to RMARGIN columns
-   total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
-   replacing the whitespace before them with a newline and WMARGIN spaces.
-   Otherwise, chars beyond RMARGIN are simply dropped until a newline.
-   Returns NULL if there was an error.  */
-extern argp_fmtstream_t __argp_make_fmtstream (FILE *__stream,
-					       size_t __lmargin,
-					       size_t __rmargin,
-					       ssize_t __wmargin);
-extern argp_fmtstream_t argp_make_fmtstream (FILE *__stream,
-					     size_t __lmargin,
-					     size_t __rmargin,
-					     ssize_t __wmargin);
-
-/* Flush __FS to its stream, and free it (but don't close the stream).  */
-extern void __argp_fmtstream_free (argp_fmtstream_t __fs);
-extern void argp_fmtstream_free (argp_fmtstream_t __fs);
-
-extern ssize_t __argp_fmtstream_printf (argp_fmtstream_t __fs,
-				       __const char *__fmt, ...)
-     PRINTF_STYLE(2,3);
-extern ssize_t argp_fmtstream_printf (argp_fmtstream_t __fs,
-				      __const char *__fmt, ...)
-     PRINTF_STYLE(2,3);
-
-#if __STDC_VERSION__ - 199900L < 1
-extern int __argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
-extern int argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
-
-extern int __argp_fmtstream_puts (argp_fmtstream_t __fs, __const char *__str);
-extern int argp_fmtstream_puts (argp_fmtstream_t __fs, __const char *__str);
-
-extern size_t __argp_fmtstream_write (argp_fmtstream_t __fs,
-				      __const char *__str, size_t __len);
-extern size_t argp_fmtstream_write (argp_fmtstream_t __fs,
-				    __const char *__str, size_t __len);
-#endif /* __STDC_VERSION__ - 199900L < 1 */
-
-/* Access macros for various bits of state.  */
-#define argp_fmtstream_lmargin(__fs) ((__fs)->lmargin)
-#define argp_fmtstream_rmargin(__fs) ((__fs)->rmargin)
-#define argp_fmtstream_wmargin(__fs) ((__fs)->wmargin)
-#define __argp_fmtstream_lmargin argp_fmtstream_lmargin
-#define __argp_fmtstream_rmargin argp_fmtstream_rmargin
-#define __argp_fmtstream_wmargin argp_fmtstream_wmargin
-
-#if __STDC_VERSION__ - 199900L < 1
-/* Set __FS's left margin to LMARGIN and return the old value.  */
-extern size_t argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
-					  size_t __lmargin);
-extern size_t __argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
-					    size_t __lmargin);
-
-/* Set __FS's right margin to __RMARGIN and return the old value.  */
-extern size_t argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
-					  size_t __rmargin);
-extern size_t __argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
-					    size_t __rmargin);
-
-/* Set __FS's wrap margin to __WMARGIN and return the old value.  */
-extern size_t argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
-					  size_t __wmargin);
-extern size_t __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
-					    size_t __wmargin);
-
-/* Return the column number of the current output point in __FS.  */
-extern size_t argp_fmtstream_point (argp_fmtstream_t __fs);
-extern size_t __argp_fmtstream_point (argp_fmtstream_t __fs);
-#endif /* __STDC_VERSION__ - 199900L < 1 */
-
-/* Internal routines.  */
-extern void _argp_fmtstream_update (argp_fmtstream_t __fs);
-extern void __argp_fmtstream_update (argp_fmtstream_t __fs);
-extern int _argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
-extern int __argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
-
-#ifdef __OPTIMIZE__
-/* Inline versions of above routines.  */
-
-#if !_LIBC
-#define __argp_fmtstream_putc argp_fmtstream_putc
-#define __argp_fmtstream_puts argp_fmtstream_puts
-#define __argp_fmtstream_write argp_fmtstream_write
-#define __argp_fmtstream_set_lmargin argp_fmtstream_set_lmargin
-#define __argp_fmtstream_set_rmargin argp_fmtstream_set_rmargin
-#define __argp_fmtstream_set_wmargin argp_fmtstream_set_wmargin
-#define __argp_fmtstream_point argp_fmtstream_point
-#define __argp_fmtstream_update _argp_fmtstream_update
-#define __argp_fmtstream_ensure _argp_fmtstream_ensure
-#endif
-
-#ifndef ARGP_FS_EI
-#if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__)
-#define ARGP_FS_EI extern inline
-#else
-#define ARGP_FS_EI inline
-#endif
-#endif
-
-ARGP_FS_EI size_t
-__argp_fmtstream_write (argp_fmtstream_t __fs,
-			__const char *__str, size_t __len)
-{
-  if (__fs->p + __len <= __fs->end || __argp_fmtstream_ensure (__fs, __len))
-    {
-      memcpy (__fs->p, __str, __len);
-      __fs->p += __len;
-      return __len;
-    }
-  else
-    return 0;
-}
-
-ARGP_FS_EI int
-__argp_fmtstream_puts (argp_fmtstream_t __fs, __const char *__str)
-{
-  size_t __len = strlen (__str);
-  if (__len)
-    {
-      size_t __wrote = __argp_fmtstream_write (__fs, __str, __len);
-      return __wrote == __len ? 0 : -1;
-    }
-  else
-    return 0;
-}
-
-ARGP_FS_EI int
-__argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch)
-{
-  if (__fs->p < __fs->end || __argp_fmtstream_ensure (__fs, 1))
-    return *__fs->p++ = __ch;
-  else
-    return EOF;
-}
-
-/* Set __FS's left margin to __LMARGIN and return the old value.  */
-ARGP_FS_EI size_t
-__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->lmargin;
-  __fs->lmargin = __lmargin;
-  return __old;
-}
-
-/* Set __FS's right margin to __RMARGIN and return the old value.  */
-ARGP_FS_EI size_t
-__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->rmargin;
-  __fs->rmargin = __rmargin;
-  return __old;
-}
-
-/* Set FS's wrap margin to __WMARGIN and return the old value.  */
-ARGP_FS_EI size_t
-__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
-{
-  size_t __old;
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  __old = __fs->wmargin;
-  __fs->wmargin = __wmargin;
-  return __old;
-}
-
-/* Return the column number of the current output point in __FS.  */
-ARGP_FS_EI size_t
-__argp_fmtstream_point (argp_fmtstream_t __fs)
-{
-  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
-    __argp_fmtstream_update (__fs);
-  return __fs->point_col >= 0 ? __fs->point_col : 0;
-}
-
-#if !_LIBC
-#undef __argp_fmtstream_putc
-#undef __argp_fmtstream_puts
-#undef __argp_fmtstream_write
-#undef __argp_fmtstream_set_lmargin
-#undef __argp_fmtstream_set_rmargin
-#undef __argp_fmtstream_set_wmargin
-#undef __argp_fmtstream_point
-#undef __argp_fmtstream_update
-#undef __argp_fmtstream_ensure
-#endif
-
-#endif /* __OPTIMIZE__ */
-
-#endif /* ARGP_FMTSTREAM_USE_LINEWRAP */
-
-#endif /* argp-fmtstream.h */
diff --git a/contrib/argp-standalone/argp-help.c b/contrib/argp-standalone/argp-help.c
deleted file mode 100644
index ced78c4cb26..00000000000
--- a/contrib/argp-standalone/argp-help.c
+++ /dev/null
@@ -1,1849 +0,0 @@
-/* Hierarchial argument parsing help output
-   Copyright (C) 1995,96,97,98,99,2000, 2003 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE	1
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#if HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <stdarg.h>
-#include <ctype.h>
-#if HAVE_MALLOC_H
-/* Needed, for alloca on windows */
-# include <malloc.h>
-#endif
-
-#ifndef _
-/* This is for other GNU distributions with internationalized messages.  */
-# if defined HAVE_LIBINTL_H || defined _LIBC
-#  include <libintl.h>
-#  ifdef _LIBC
-#   undef dgettext
-#   define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
-#  endif
-# else
-#  define dgettext(domain, msgid) (msgid)
-# endif
-#endif
-
-#include "argp.h"
-#include "argp-fmtstream.h"
-#include "argp-namefrob.h"
-
-
-#ifndef _LIBC
-# ifndef __strchrnul
-#  define __strchrnul strchrnul
-# endif
-# ifndef __mempcpy
-#  define __mempcpy mempcpy
-# endif
-/* We need to use a different name, as __strndup is likely a macro. */
-# define STRNDUP strndup
-# if HAVE_STRERROR
-#  define STRERROR strerror
-# else
-#  define STRERROR(x) (sys_errlist[x])
-# endif
-#else /* _LIBC */
-# define FLOCKFILE __flockfile
-# define FUNLOCKFILE __funlockfile
-# define STRNDUP __strndup
-# define STRERROR strerror
-#endif
-
-#if !_LIBC
-# if !HAVE_STRNDUP
-char *strndup (const char *s, size_t size);
-# endif /* !HAVE_STRNDUP */
-
-# if !HAVE_MEMPCPY
-void *mempcpy (void *to, const void *from, size_t size);
-# endif /* !HAVE_MEMPCPY */
-
-# if !HAVE_STRCHRNUL
-char *strchrnul(const char *s, int c);
-# endif /* !HAVE_STRCHRNUL */
-
-# if !HAVE_STRCASECMP
-int strcasecmp(const char *s1, const char *s2);
-#endif
-
-#endif /* !_LIBC */
-
-
-/* User-selectable (using an environment variable) formatting parameters.
-
-   These may be specified in an environment variable called `ARGP_HELP_FMT',
-   with a contents like:  VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
-   Where VALn must be a positive integer.  The list of variables is in the
-   UPARAM_NAMES vector, below.  */
-
-/* Default parameters.  */
-#define DUP_ARGS      0		/* True if option argument can be duplicated. */
-#define DUP_ARGS_NOTE 1		/* True to print a note about duplicate args. */
-#define SHORT_OPT_COL 2		/* column in which short options start */
-#define LONG_OPT_COL  6		/* column in which long options start */
-#define DOC_OPT_COL   2		/* column in which doc options start */
-#define OPT_DOC_COL  29		/* column in which option text starts */
-#define HEADER_COL    1		/* column in which group headers are printed */
-#define USAGE_INDENT 12		/* indentation of wrapped usage lines */
-#define RMARGIN      79		/* right margin used for wrapping */
-
-/* User-selectable (using an environment variable) formatting parameters.
-   They must all be of type `int' for the parsing code to work.  */
-struct uparams
-{
-  /* If true, arguments for an option are shown with both short and long
-     options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
-     If false, then if an option has both, the argument is only shown with
-     the long one, e.g., `-x, --longx=ARG', and a message indicating that
-     this really means both is printed below the options.  */
-  int dup_args;
-
-  /* This is true if when DUP_ARGS is false, and some duplicate arguments have
-     been suppressed, an explanatory message should be printed.  */
-  int dup_args_note;
-
-  /* Various output columns.  */
-  int short_opt_col;
-  int long_opt_col;
-  int doc_opt_col;
-  int opt_doc_col;
-  int header_col;
-  int usage_indent;
-  int rmargin;
-
-  int valid;			/* True when the values in here are valid.  */
-};
-
-/* This is a global variable, as user options are only ever read once.  */
-static struct uparams uparams = {
-  DUP_ARGS, DUP_ARGS_NOTE,
-  SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
-  USAGE_INDENT, RMARGIN,
-  0
-};
-
-/* A particular uparam, and what the user name is.  */
-struct uparam_name
-{
-  const char *name;		/* User name.  */
-  int is_bool;			/* Whether it's `boolean'.  */
-  size_t uparams_offs;		/* Location of the (int) field in UPARAMS.  */
-};
-
-/* The name-field mappings we know about.  */
-static const struct uparam_name uparam_names[] =
-{
-  { "dup-args",       1, offsetof (struct uparams, dup_args) },
-  { "dup-args-note",  1, offsetof (struct uparams, dup_args_note) },
-  { "short-opt-col",  0, offsetof (struct uparams, short_opt_col) },
-  { "long-opt-col",   0, offsetof (struct uparams, long_opt_col) },
-  { "doc-opt-col",    0, offsetof (struct uparams, doc_opt_col) },
-  { "opt-doc-col",    0, offsetof (struct uparams, opt_doc_col) },
-  { "header-col",     0, offsetof (struct uparams, header_col) },
-  { "usage-indent",   0, offsetof (struct uparams, usage_indent) },
-  { "rmargin",        0, offsetof (struct uparams, rmargin) },
-  { 0, 0, 0 }
-};
-
-/* Read user options from the environment, and fill in UPARAMS appropiately.  */
-static void
-fill_in_uparams (const struct argp_state *state)
-{
-
-  const char *var = getenv ("ARGP_HELP_FMT");
-
-#define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
-
-  if (var)
-    /* Parse var. */
-    while (*var)
-      {
-	SKIPWS (var);
-
-	if (isalpha (*var))
-	  {
-	    size_t var_len;
-	    const struct uparam_name *un;
-	    int unspec = 0, val = 0;
-	    const char *arg = var;
-
-	    while (isalnum (*arg) || *arg == '-' || *arg == '_')
-	      arg++;
-	    var_len = arg - var;
-
-	    SKIPWS (arg);
-
-	    if (*arg == '\0' || *arg == ',')
-	      unspec = 1;
-	    else if (*arg == '=')
-	      {
-		arg++;
-		SKIPWS (arg);
-	      }
-
-	    if (unspec)
-	      {
-		if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
-		  {
-		    val = 0;
-		    var += 3;
-		    var_len -= 3;
-		  }
-		else
-		  val = 1;
-	      }
-	    else if (isdigit (*arg))
-	      {
-		val = atoi (arg);
-		while (isdigit (*arg))
-		  arg++;
-		SKIPWS (arg);
-	      }
-
-	    for (un = uparam_names; un->name; un++)
-	      if (strlen (un->name) == var_len
-		  && strncmp (var, un->name, var_len) == 0)
-		{
-		  if (unspec && !un->is_bool)
-		    __argp_failure (state, 0, 0,
-				    dgettext (state->root_argp->argp_domain, "\
-%.*s: ARGP_HELP_FMT parameter requires a value"),
-				    (int) var_len, var);
-		  else
-		    *(int *)((char *)&uparams + un->uparams_offs) = val;
-		  break;
-		}
-	    if (! un->name)
-	      __argp_failure (state, 0, 0,
-			      dgettext (state->root_argp->argp_domain, "\
-%.*s: Unknown ARGP_HELP_FMT parameter"),
-			      (int) var_len, var);
-
-	    var = arg;
-	    if (*var == ',')
-	      var++;
-	  }
-	else if (*var)
-	  {
-	    __argp_failure (state, 0, 0,
-			    dgettext (state->root_argp->argp_domain,
-				      "Garbage in ARGP_HELP_FMT: %s"), var);
-	    break;
-	  }
-      }
-}
-
-/* Returns true if OPT hasn't been marked invisible.  Visibility only affects
-   whether OPT is displayed or used in sorting, not option shadowing.  */
-#define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
-
-/* Returns true if OPT is an alias for an earlier option.  */
-#define oalias(opt) ((opt)->flags & OPTION_ALIAS)
-
-/* Returns true if OPT is an documentation-only entry.  */
-#define odoc(opt) ((opt)->flags & OPTION_DOC)
-
-/* Returns true if OPT is the end-of-list marker for a list of options.  */
-#define oend(opt) __option_is_end (opt)
-
-/* Returns true if OPT has a short option.  */
-#define oshort(opt) __option_is_short (opt)
-
-/*
-   The help format for a particular option is like:
-
-     -xARG, -yARG, --long1=ARG, --long2=ARG        Documentation...
-
-   Where ARG will be omitted if there's no argument, for this option, or
-   will be surrounded by "[" and "]" appropiately if the argument is
-   optional.  The documentation string is word-wrapped appropiately, and if
-   the list of options is long enough, it will be started on a separate line.
-   If there are no short options for a given option, the first long option is
-   indented slighly in a way that's supposed to make most long options appear
-   to be in a separate column.
-
-   For example, the following output (from ps):
-
-     -p PID, --pid=PID          List the process PID
-	 --pgrp=PGRP            List processes in the process group PGRP
-     -P, -x, --no-parent        Include processes without parents
-     -Q, --all-fields           Don't elide unusable fields (normally if there's
-				some reason ps can't print a field for any
-				process, it's removed from the output entirely)
-     -r, --reverse, --gratuitously-long-reverse-option
-				Reverse the order of any sort
-	 --session[=SID]        Add the processes from the session SID (which
-				defaults to the sid of the current process)
-
-    Here are some more options:
-     -f ZOT, --foonly=ZOT       Glork a foonly
-     -z, --zaza                 Snit a zar
-
-     -?, --help                 Give this help list
-	 --usage                Give a short usage message
-     -V, --version              Print program version
-
-   The struct argp_option array for the above could look like:
-
-   {
-     {"pid",       'p',      "PID",  0, "List the process PID"},
-     {"pgrp",      OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
-     {"no-parent", 'P',	      0,     0, "Include processes without parents"},
-     {0,           'x',       0,     OPTION_ALIAS},
-     {"all-fields",'Q',       0,     0, "Don't elide unusable fields (normally"
-                                        " if there's some reason ps can't"
-					" print a field for any process, it's"
-                                        " removed from the output entirely)" },
-     {"reverse",   'r',       0,     0, "Reverse the order of any sort"},
-     {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
-     {"session",   OPT_SESS,  "SID", OPTION_ARG_OPTIONAL,
-                                        "Add the processes from the session"
-					" SID (which defaults to the sid of"
-					" the current process)" },
-
-     {0,0,0,0, "Here are some more options:"},
-     {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
-     {"zaza", 'z', 0, 0, "Snit a zar"},
-
-     {0}
-   }
-
-   Note that the last three options are automatically supplied by argp_parse,
-   unless you tell it not to with ARGP_NO_HELP.
-
-*/
-
-/* Returns true if CH occurs between BEG and END.  */
-static int
-find_char (char ch, char *beg, char *end)
-{
-  while (beg < end)
-    if (*beg == ch)
-      return 1;
-    else
-      beg++;
-  return 0;
-}
-
-struct hol_cluster;		/* fwd decl */
-
-struct hol_entry
-{
-  /* First option.  */
-  const struct argp_option *opt;
-  /* Number of options (including aliases).  */
-  unsigned num;
-
-  /* A pointers into the HOL's short_options field, to the first short option
-     letter for this entry.  The order of the characters following this point
-     corresponds to the order of options pointed to by OPT, and there are at
-     most NUM.  A short option recorded in a option following OPT is only
-     valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
-     probably been shadowed by some other entry).  */
-  char *short_options;
-
-  /* Entries are sorted by their group first, in the order:
-       1, 2, ..., n, 0, -m, ..., -2, -1
-     and then alphabetically within each group.  The default is 0.  */
-  int group;
-
-  /* The cluster of options this entry belongs to, or 0 if none.  */
-  struct hol_cluster *cluster;
-
-  /* The argp from which this option came.  */
-  const struct argp *argp;
-};
-
-/* A cluster of entries to reflect the argp tree structure.  */
-struct hol_cluster
-{
-  /* A descriptive header printed before options in this cluster.  */
-  const char *header;
-
-  /* Used to order clusters within the same group with the same parent,
-     according to the order in which they occurred in the parent argp's child
-     list.  */
-  int index;
-
-  /* How to sort this cluster with respect to options and other clusters at the
-     same depth (clusters always follow options in the same group).  */
-  int group;
-
-  /* The cluster to which this cluster belongs, or 0 if it's at the base
-     level.  */
-  struct hol_cluster *parent;
-
-  /* The argp from which this cluster is (eventually) derived.  */
-  const struct argp *argp;
-
-  /* The distance this cluster is from the root.  */
-  int depth;
-
-  /* Clusters in a given hol are kept in a linked list, to make freeing them
-     possible.  */
-  struct hol_cluster *next;
-};
-
-/* A list of options for help.  */
-struct hol
-{
-  /* An array of hol_entry's.  */
-  struct hol_entry *entries;
-  /* The number of entries in this hol.  If this field is zero, the others
-     are undefined.  */
-  unsigned num_entries;
-
-  /* A string containing all short options in this HOL.  Each entry contains
-     pointers into this string, so the order can't be messed with blindly.  */
-  char *short_options;
-
-  /* Clusters of entries in this hol.  */
-  struct hol_cluster *clusters;
-};
-
-/* Create a struct hol from the options in ARGP.  CLUSTER is the
-   hol_cluster in which these entries occur, or 0, if at the root.  */
-static struct hol *
-make_hol (const struct argp *argp, struct hol_cluster *cluster)
-{
-  char *so;
-  const struct argp_option *o;
-  const struct argp_option *opts = argp->options;
-  struct hol_entry *entry;
-  unsigned num_short_options = 0;
-  struct hol *hol = malloc (sizeof (struct hol));
-
-  assert (hol);
-
-  hol->num_entries = 0;
-  hol->clusters = 0;
-
-  if (opts)
-    {
-      int cur_group = 0;
-
-      /* The first option must not be an alias.  */
-      assert (! oalias (opts));
-
-      /* Calculate the space needed.  */
-      for (o = opts; ! oend (o); o++)
-	{
-	  if (! oalias (o))
-	    hol->num_entries++;
-	  if (oshort (o))
-	    num_short_options++;	/* This is an upper bound.  */
-	}
-
-      hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
-      hol->short_options = malloc (num_short_options + 1);
-
-      assert (hol->entries && hol->short_options);
-
-      /* Fill in the entries.  */
-      so = hol->short_options;
-      for (o = opts, entry = hol->entries; ! oend (o); entry++)
-	{
-	  entry->opt = o;
-	  entry->num = 0;
-	  entry->short_options = so;
-	  entry->group = cur_group =
-	    o->group
-	    ? o->group
-	    : ((!o->name && !o->key)
-	       ? cur_group + 1
-	       : cur_group);
-	  entry->cluster = cluster;
-	  entry->argp = argp;
-
-	  do
-	    {
-	      entry->num++;
-	      if (oshort (o) && ! find_char (o->key, hol->short_options, so))
-		/* O has a valid short option which hasn't already been used.*/
-		*so++ = o->key;
-	      o++;
-	    }
-	  while (! oend (o) && oalias (o));
-	}
-      *so = '\0';		/* null terminated so we can find the length */
-    }
-
-  return hol;
-}
-
-/* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
-   associated argp child list entry), INDEX, and PARENT, and return a pointer
-   to it.  ARGP is the argp that this cluster results from.  */
-static struct hol_cluster *
-hol_add_cluster (struct hol *hol, int group, const char *header, int index,
-		 struct hol_cluster *parent, const struct argp *argp)
-{
-  struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
-  if (cl)
-    {
-      cl->group = group;
-      cl->header = header;
-
-      cl->index = index;
-      cl->parent = parent;
-      cl->argp = argp;
-      cl->depth = parent ? parent->depth + 1 : 0;
-
-      cl->next = hol->clusters;
-      hol->clusters = cl;
-    }
-  return cl;
-}
-
-/* Free HOL and any resources it uses.  */
-static void
-hol_free (struct hol *hol)
-{
-  struct hol_cluster *cl = hol->clusters;
-
-  while (cl)
-    {
-      struct hol_cluster *next = cl->next;
-      free (cl);
-      cl = next;
-    }
-
-  if (hol->num_entries > 0)
-    {
-      free (hol->entries);
-      free (hol->short_options);
-    }
-
-  free (hol);
-}
-
-static inline int
-hol_entry_short_iterate (const struct hol_entry *entry,
-			 int (*func)(const struct argp_option *opt,
-				     const struct argp_option *real,
-				     const char *domain, void *cookie),
-			 const char *domain, void *cookie)
-{
-  unsigned nopts;
-  int val = 0;
-  const struct argp_option *opt, *real = entry->opt;
-  char *so = entry->short_options;
-
-  for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
-    if (oshort (opt) && *so == opt->key)
-      {
-	if (!oalias (opt))
-	  real = opt;
-	if (ovisible (opt))
-	  val = (*func)(opt, real, domain, cookie);
-	so++;
-      }
-
-  return val;
-}
-
-static inline int
-hol_entry_long_iterate (const struct hol_entry *entry,
-			int (*func)(const struct argp_option *opt,
-				    const struct argp_option *real,
-				    const char *domain, void *cookie),
-			const char *domain, void *cookie)
-{
-  unsigned nopts;
-  int val = 0;
-  const struct argp_option *opt, *real = entry->opt;
-
-  for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
-    if (opt->name)
-      {
-	if (!oalias (opt))
-	  real = opt;
-	if (ovisible (opt))
-	  val = (*func)(opt, real, domain, cookie);
-      }
-
-  return val;
-}
-
-/* Iterator that returns true for the first short option.  */
-static inline int
-until_short (const struct argp_option *opt, const struct argp_option *real UNUSED,
-	     const char *domain UNUSED, void *cookie UNUSED)
-{
-  return oshort (opt) ? opt->key : 0;
-}
-
-/* Returns the first valid short option in ENTRY, or 0 if there is none.  */
-static char
-hol_entry_first_short (const struct hol_entry *entry)
-{
-  return hol_entry_short_iterate (entry, until_short,
-				  entry->argp->argp_domain, 0);
-}
-
-/* Returns the first valid long option in ENTRY, or 0 if there is none.  */
-static const char *
-hol_entry_first_long (const struct hol_entry *entry)
-{
-  const struct argp_option *opt;
-  unsigned num;
-  for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
-    if (opt->name && ovisible (opt))
-      return opt->name;
-  return 0;
-}
-
-/* Returns the entry in HOL with the long option name NAME, or 0 if there is
-   none.  */
-static struct hol_entry *
-hol_find_entry (struct hol *hol, const char *name)
-{
-  struct hol_entry *entry = hol->entries;
-  unsigned num_entries = hol->num_entries;
-
-  while (num_entries-- > 0)
-    {
-      const struct argp_option *opt = entry->opt;
-      unsigned num_opts = entry->num;
-
-      while (num_opts-- > 0)
-	if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
-	  return entry;
-	else
-	  opt++;
-
-      entry++;
-    }
-
-  return 0;
-}
-
-/* If an entry with the long option NAME occurs in HOL, set it's special
-   sort position to GROUP.  */
-static void
-hol_set_group (struct hol *hol, const char *name, int group)
-{
-  struct hol_entry *entry = hol_find_entry (hol, name);
-  if (entry)
-    entry->group = group;
-}
-
-/* Order by group:  0, 1, 2, ..., n, -m, ..., -2, -1.
-   EQ is what to return if GROUP1 and GROUP2 are the same.  */
-static int
-group_cmp (int group1, int group2, int eq)
-{
-  if (group1 == group2)
-    return eq;
-  else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
-    return group1 - group2;
-  else
-    return group2 - group1;
-}
-
-/* Compare clusters CL1 & CL2 by the order that they should appear in
-   output.  */
-static int
-hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
-{
-  /* If one cluster is deeper than the other, use its ancestor at the same
-     level, so that finding the common ancestor is straightforward.  */
-  while (cl1->depth < cl2->depth)
-    cl1 = cl1->parent;
-  while (cl2->depth < cl1->depth)
-    cl2 = cl2->parent;
-
-  /* Now reduce both clusters to their ancestors at the point where both have
-     a common parent; these can be directly compared.  */
-  while (cl1->parent != cl2->parent)
-    cl1 = cl1->parent, cl2 = cl2->parent;
-
-  return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
-}
-
-/* Return the ancestor of CL that's just below the root (i.e., has a parent
-   of 0).  */
-static struct hol_cluster *
-hol_cluster_base (struct hol_cluster *cl)
-{
-  while (cl->parent)
-    cl = cl->parent;
-  return cl;
-}
-
-/* Return true if CL1 is a child of CL2.  */
-static int
-hol_cluster_is_child (const struct hol_cluster *cl1,
-		      const struct hol_cluster *cl2)
-{
-  while (cl1 && cl1 != cl2)
-    cl1 = cl1->parent;
-  return cl1 == cl2;
-}
-
-/* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
-   that should be used for comparisons, and returns true iff it should be
-   treated as a non-option.  */
-
-/* FIXME: Can we use unsigned char * for the argument? */
-static int
-canon_doc_option (const char **name)
-{
-  int non_opt;
-  /* Skip initial whitespace.  */
-  while (isspace ( (unsigned char) **name))
-    (*name)++;
-  /* Decide whether this looks like an option (leading `-') or not.  */
-  non_opt = (**name != '-');
-  /* Skip until part of name used for sorting.  */
-  while (**name && !isalnum ( (unsigned char) **name))
-    (*name)++;
-  return non_opt;
-}
-
-/* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
-   listing.  */
-static int
-hol_entry_cmp (const struct hol_entry *entry1,
-	       const struct hol_entry *entry2)
-{
-  /* The group numbers by which the entries should be ordered; if either is
-     in a cluster, then this is just the group within the cluster.  */
-  int group1 = entry1->group, group2 = entry2->group;
-
-  if (entry1->cluster != entry2->cluster)
-    {
-      /* The entries are not within the same cluster, so we can't compare them
-	 directly, we have to use the appropiate clustering level too.  */
-      if (! entry1->cluster)
-	/* ENTRY1 is at the `base level', not in a cluster, so we have to
-	   compare it's group number with that of the base cluster in which
-	   ENTRY2 resides.  Note that if they're in the same group, the
-	   clustered option always comes laster.  */
-	return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
-      else if (! entry2->cluster)
-	/* Likewise, but ENTRY2's not in a cluster.  */
-	return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
-      else
-	/* Both entries are in clusters, we can just compare the clusters.  */
-	return hol_cluster_cmp (entry1->cluster, entry2->cluster);
-    }
-  else if (group1 == group2)
-    /* The entries are both in the same cluster and group, so compare them
-       alphabetically.  */
-    {
-      int short1 = hol_entry_first_short (entry1);
-      int short2 = hol_entry_first_short (entry2);
-      int doc1 = odoc (entry1->opt);
-      int doc2 = odoc (entry2->opt);
-      /* FIXME: Can we use unsigned char * instead? */
-      const char *long1 = hol_entry_first_long (entry1);
-      const char *long2 = hol_entry_first_long (entry2);
-
-      if (doc1)
-	doc1 = canon_doc_option (&long1);
-      if (doc2)
-	doc2 = canon_doc_option (&long2);
-
-      if (doc1 != doc2)
-	/* `documentation' options always follow normal options (or
-	   documentation options that *look* like normal options).  */
-	return doc1 - doc2;
-      else if (!short1 && !short2 && long1 && long2)
-	/* Only long options.  */
-	return __strcasecmp (long1, long2);
-      else
-	/* Compare short/short, long/short, short/long, using the first
-	   character of long options.  Entries without *any* valid
-	   options (such as options with OPTION_HIDDEN set) will be put
-	   first, but as they're not displayed, it doesn't matter where
-	   they are.  */
-	{
-	  unsigned char first1 = short1 ? short1 : long1 ? *long1 : 0;
-	  unsigned char first2 = short2 ? short2 : long2 ? *long2 : 0;
-#ifdef _tolower
-	  int lower_cmp = _tolower (first1) - _tolower (first2);
-#else
-	  int lower_cmp = tolower (first1) - tolower (first2);
-#endif
-	  /* Compare ignoring case, except when the options are both the
-	     same letter, in which case lower-case always comes first.  */
-	  /* NOTE: The subtraction below does the right thing
-	     even with eight-bit chars: first1 and first2 are
-	     converted to int *before* the subtraction. */
-	  return lower_cmp ? lower_cmp : first2 - first1;
-	}
-    }
-  else
-    /* Within the same cluster, but not the same group, so just compare
-       groups.  */
-    return group_cmp (group1, group2, 0);
-}
-
-/* Version of hol_entry_cmp with correct signature for qsort.  */
-static int
-hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
-{
-  return hol_entry_cmp (entry1_v, entry2_v);
-}
-
-/* Sort HOL by group and alphabetically by option name (with short options
-   taking precedence over long).  Since the sorting is for display purposes
-   only, the shadowing of options isn't effected.  */
-static void
-hol_sort (struct hol *hol)
-{
-  if (hol->num_entries > 0)
-    qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
-	   hol_entry_qcmp);
-}
-
-/* Append MORE to HOL, destroying MORE in the process.  Options in HOL shadow
-   any in MORE with the same name.  */
-static void
-hol_append (struct hol *hol, struct hol *more)
-{
-  struct hol_cluster **cl_end = &hol->clusters;
-
-  /* Steal MORE's cluster list, and add it to the end of HOL's.  */
-  while (*cl_end)
-    cl_end = &(*cl_end)->next;
-  *cl_end = more->clusters;
-  more->clusters = 0;
-
-  /* Merge entries.  */
-  if (more->num_entries > 0)
-    {
-      if (hol->num_entries == 0)
-	{
-	  hol->num_entries = more->num_entries;
-	  hol->entries = more->entries;
-	  hol->short_options = more->short_options;
-	  more->num_entries = 0;	/* Mark MORE's fields as invalid.  */
-	}
-      else
-	/* Append the entries in MORE to those in HOL, taking care to only add
-	   non-shadowed SHORT_OPTIONS values.  */
-	{
-	  unsigned left;
-	  char *so, *more_so;
-	  struct hol_entry *e;
-	  unsigned num_entries = hol->num_entries + more->num_entries;
-	  struct hol_entry *entries =
-	    malloc (num_entries * sizeof (struct hol_entry));
-	  unsigned hol_so_len = strlen (hol->short_options);
-	  char *short_options =
-	    malloc (hol_so_len + strlen (more->short_options) + 1);
-
-	  __mempcpy (__mempcpy (entries, hol->entries,
-				hol->num_entries * sizeof (struct hol_entry)),
-		     more->entries,
-		     more->num_entries * sizeof (struct hol_entry));
-
-	  __mempcpy (short_options, hol->short_options, hol_so_len);
-
-	  /* Fix up the short options pointers from HOL.  */
-	  for (e = entries, left = hol->num_entries; left > 0; e++, left--)
-	    e->short_options += (short_options - hol->short_options);
-
-	  /* Now add the short options from MORE, fixing up its entries
-	     too.  */
-	  so = short_options + hol_so_len;
-	  more_so = more->short_options;
-	  for (left = more->num_entries; left > 0; e++, left--)
-	    {
-	      int opts_left;
-	      const struct argp_option *opt;
-
-	      e->short_options = so;
-
-	      for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
-		{
-		  int ch = *more_so;
-		  if (oshort (opt) && ch == opt->key)
-		    /* The next short option in MORE_SO, CH, is from OPT.  */
-		    {
-		      if (! find_char (ch, short_options,
-				       short_options + hol_so_len))
-			/* The short option CH isn't shadowed by HOL's options,
-			   so add it to the sum.  */
-			*so++ = ch;
-		      more_so++;
-		    }
-		}
-	    }
-
-	  *so = '\0';
-
-	  free (hol->entries);
-	  free (hol->short_options);
-
-	  hol->entries = entries;
-	  hol->num_entries = num_entries;
-	  hol->short_options = short_options;
-	}
-    }
-
-  hol_free (more);
-}
-
-/* Inserts enough spaces to make sure STREAM is at column COL.  */
-static void
-indent_to (argp_fmtstream_t stream, unsigned col)
-{
-  int needed = col - __argp_fmtstream_point (stream);
-  while (needed-- > 0)
-    __argp_fmtstream_putc (stream, ' ');
-}
-
-/* Output to STREAM either a space, or a newline if there isn't room for at
-   least ENSURE characters before the right margin.  */
-static void
-space (argp_fmtstream_t stream, size_t ensure)
-{
-  if (__argp_fmtstream_point (stream) + ensure
-      >= __argp_fmtstream_rmargin (stream))
-    __argp_fmtstream_putc (stream, '\n');
-  else
-    __argp_fmtstream_putc (stream, ' ');
-}
-
-/* If the option REAL has an argument, we print it in using the printf
-   format REQ_FMT or OPT_FMT depending on whether it's a required or
-   optional argument.  */
-static void
-arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
-     const char *domain UNUSED, argp_fmtstream_t stream)
-{
-  if (real->arg)
-    {
-      if (real->flags & OPTION_ARG_OPTIONAL)
-	__argp_fmtstream_printf (stream, opt_fmt,
-				 dgettext (domain, real->arg));
-      else
-	__argp_fmtstream_printf (stream, req_fmt,
-				 dgettext (domain, real->arg));
-    }
-}
-
-/* Helper functions for hol_entry_help.  */
-
-/* State used during the execution of hol_help.  */
-struct hol_help_state
-{
-  /* PREV_ENTRY should contain the previous entry printed, or 0.  */
-  struct hol_entry *prev_entry;
-
-  /* If an entry is in a different group from the previous one, and SEP_GROUPS
-     is true, then a blank line will be printed before any output. */
-  int sep_groups;
-
-  /* True if a duplicate option argument was suppressed (only ever set if
-     UPARAMS.dup_args is false).  */
-  int suppressed_dup_arg;
-};
-
-/* Some state used while printing a help entry (used to communicate with
-   helper functions).  See the doc for hol_entry_help for more info, as most
-   of the fields are copied from its arguments.  */
-struct pentry_state
-{
-  const struct hol_entry *entry;
-  argp_fmtstream_t stream;
-  struct hol_help_state *hhstate;
-
-  /* True if nothing's been printed so far.  */
-  int first;
-
-  /* If non-zero, the state that was used to print this help.  */
-  const struct argp_state *state;
-};
-
-/* If a user doc filter should be applied to DOC, do so.  */
-static const char *
-filter_doc (const char *doc, int key, const struct argp *argp,
-	    const struct argp_state *state)
-{
-  if (argp->help_filter)
-    /* We must apply a user filter to this output.  */
-    {
-      void *input = __argp_input (argp, state);
-      return (*argp->help_filter) (key, doc, input);
-    }
-  else
-    /* No filter.  */
-    return doc;
-}
-
-/* Prints STR as a header line, with the margin lines set appropiately, and
-   notes the fact that groups should be separated with a blank line.  ARGP is
-   the argp that should dictate any user doc filtering to take place.  Note
-   that the previous wrap margin isn't restored, but the left margin is reset
-   to 0.  */
-static void
-print_header (const char *str, const struct argp *argp,
-	      struct pentry_state *pest)
-{
-  const char *tstr = dgettext (argp->argp_domain, str);
-  const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
-
-  if (fstr)
-    {
-      if (*fstr)
-	{
-	  if (pest->hhstate->prev_entry)
-	    /* Precede with a blank line.  */
-	    __argp_fmtstream_putc (pest->stream, '\n');
-	  indent_to (pest->stream, uparams.header_col);
-	  __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
-	  __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
-	  __argp_fmtstream_puts (pest->stream, fstr);
-	  __argp_fmtstream_set_lmargin (pest->stream, 0);
-	  __argp_fmtstream_putc (pest->stream, '\n');
-	}
-
-      pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
-    }
-
-  if (fstr != tstr)
-    free ((char *) fstr);
-}
-
-/* Inserts a comma if this isn't the first item on the line, and then makes
-   sure we're at least to column COL.  If this *is* the first item on a line,
-   prints any pending whitespace/headers that should precede this line. Also
-   clears FIRST.  */
-static void
-comma (unsigned col, struct pentry_state *pest)
-{
-  if (pest->first)
-    {
-      const struct hol_entry *pe = pest->hhstate->prev_entry;
-      const struct hol_cluster *cl = pest->entry->cluster;
-
-      if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
-	__argp_fmtstream_putc (pest->stream, '\n');
-
-      if (cl && cl->header && *cl->header
-	  && (!pe
-	      || (pe->cluster != cl
-		  && !hol_cluster_is_child (pe->cluster, cl))))
-	/* If we're changing clusters, then this must be the start of the
-	   ENTRY's cluster unless that is an ancestor of the previous one
-	   (in which case we had just popped into a sub-cluster for a bit).
-	   If so, then print the cluster's header line.  */
-	{
-	  int old_wm = __argp_fmtstream_wmargin (pest->stream);
-	  print_header (cl->header, cl->argp, pest);
-	  __argp_fmtstream_set_wmargin (pest->stream, old_wm);
-	}
-
-      pest->first = 0;
-    }
-  else
-    __argp_fmtstream_puts (pest->stream, ", ");
-
-  indent_to (pest->stream, col);
-}
-
-/* Print help for ENTRY to STREAM.  */
-static void
-hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
-		argp_fmtstream_t stream, struct hol_help_state *hhstate)
-{
-  unsigned num;
-  const struct argp_option *real = entry->opt, *opt;
-  char *so = entry->short_options;
-  int have_long_opt = 0;	/* We have any long options.  */
-  /* Saved margins.  */
-  int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
-  int old_wm = __argp_fmtstream_wmargin (stream);
-  /* PEST is a state block holding some of our variables that we'd like to
-     share with helper functions.  */
-
-  /* Decent initializers are a GNU extension, so don't use it here. */
-  struct pentry_state pest;
-  pest.entry = entry;
-  pest.stream = stream;
-  pest.hhstate = hhstate;
-  pest.first = 1;
-  pest.state = state;
-
-  if (! odoc (real))
-    for (opt = real, num = entry->num; num > 0; opt++, num--)
-      if (opt->name && ovisible (opt))
-	{
-	  have_long_opt = 1;
-	  break;
-	}
-
-  /* First emit short options.  */
-  __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
-  for (opt = real, num = entry->num; num > 0; opt++, num--)
-    if (oshort (opt) && opt->key == *so)
-      /* OPT has a valid (non shadowed) short option.  */
-      {
-	if (ovisible (opt))
-	  {
-	    comma (uparams.short_opt_col, &pest);
-	    __argp_fmtstream_putc (stream, '-');
-	    __argp_fmtstream_putc (stream, *so);
-	    if (!have_long_opt || uparams.dup_args)
-	      arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
-	    else if (real->arg)
-	      hhstate->suppressed_dup_arg = 1;
-	  }
-	so++;
-      }
-
-  /* Now, long options.  */
-  if (odoc (real))
-    /* A `documentation' option.  */
-    {
-      __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
-      for (opt = real, num = entry->num; num > 0; opt++, num--)
-	if (opt->name && ovisible (opt))
-	  {
-	    comma (uparams.doc_opt_col, &pest);
-	    /* Calling gettext here isn't quite right, since sorting will
-	       have been done on the original; but documentation options
-	       should be pretty rare anyway...  */
-	    __argp_fmtstream_puts (stream,
-				   dgettext (state->root_argp->argp_domain,
-					     opt->name));
-	  }
-    }
-  else
-    /* A real long option.  */
-    {
-      int first_long_opt = 1;
-
-      __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
-      for (opt = real, num = entry->num; num > 0; opt++, num--)
-	if (opt->name && ovisible (opt))
-	  {
-	    comma (uparams.long_opt_col, &pest);
-	    __argp_fmtstream_printf (stream, "--%s", opt->name);
-	    if (first_long_opt || uparams.dup_args)
-	      arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
-		   stream);
-	    else if (real->arg)
-	      hhstate->suppressed_dup_arg = 1;
-	  }
-    }
-
-  /* Next, documentation strings.  */
-  __argp_fmtstream_set_lmargin (stream, 0);
-
-  if (pest.first)
-    {
-      /* Didn't print any switches, what's up?  */
-      if (!oshort (real) && !real->name)
-	/* This is a group header, print it nicely.  */
-	print_header (real->doc, entry->argp, &pest);
-      else
-	/* Just a totally shadowed option or null header; print nothing.  */
-	goto cleanup;		/* Just return, after cleaning up.  */
-    }
-  else
-    {
-      const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
-					       real->doc) : 0;
-      const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
-      if (fstr && *fstr)
-	{
-	  unsigned int col = __argp_fmtstream_point (stream);
-
-	  __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
-	  __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
-
-	  if (col > (unsigned int) (uparams.opt_doc_col + 3))
-	    __argp_fmtstream_putc (stream, '\n');
-	  else if (col >= (unsigned int) uparams.opt_doc_col)
-	    __argp_fmtstream_puts (stream, "   ");
-	  else
-	    indent_to (stream, uparams.opt_doc_col);
-
-	  __argp_fmtstream_puts (stream, fstr);
-	}
-      if (fstr && fstr != tstr)
-	free ((char *) fstr);
-
-      /* Reset the left margin.  */
-      __argp_fmtstream_set_lmargin (stream, 0);
-      __argp_fmtstream_putc (stream, '\n');
-    }
-
-  hhstate->prev_entry = entry;
-
-cleanup:
-  __argp_fmtstream_set_lmargin (stream, old_lm);
-  __argp_fmtstream_set_wmargin (stream, old_wm);
-}
-
-/* Output a long help message about the options in HOL to STREAM.  */
-static void
-hol_help (struct hol *hol, const struct argp_state *state,
-	  argp_fmtstream_t stream)
-{
-  unsigned num;
-  struct hol_entry *entry;
-  struct hol_help_state hhstate = { 0, 0, 0 };
-
-  for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
-    hol_entry_help (entry, state, stream, &hhstate);
-
-  if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
-    {
-      const char *tstr = dgettext (state->root_argp->argp_domain, "\
-Mandatory or optional arguments to long options are also mandatory or \
-optional for any corresponding short options.");
-      const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
-				     state ? state->root_argp : 0, state);
-      if (fstr && *fstr)
-	{
-	  __argp_fmtstream_putc (stream, '\n');
-	  __argp_fmtstream_puts (stream, fstr);
-	  __argp_fmtstream_putc (stream, '\n');
-	}
-      if (fstr && fstr != tstr)
-	free ((char *) fstr);
-    }
-}
-
-/* Helper functions for hol_usage.  */
-
-/* If OPT is a short option without an arg, append its key to the string
-   pointer pointer to by COOKIE, and advance the pointer.  */
-static int
-add_argless_short_opt (const struct argp_option *opt,
-		       const struct argp_option *real,
-		       const char *domain UNUSED, void *cookie)
-{
-  char **snao_end = cookie;
-  if (!(opt->arg || real->arg)
-      && !((opt->flags | real->flags) & OPTION_NO_USAGE))
-    *(*snao_end)++ = opt->key;
-  return 0;
-}
-
-/* If OPT is a short option with an arg, output a usage entry for it to the
-   stream pointed at by COOKIE.  */
-static int
-usage_argful_short_opt (const struct argp_option *opt,
-			const struct argp_option *real,
-			const char *domain UNUSED, void *cookie)
-{
-  argp_fmtstream_t stream = cookie;
-  const char *arg = opt->arg;
-  int flags = opt->flags | real->flags;
-
-  if (! arg)
-    arg = real->arg;
-
-  if (arg && !(flags & OPTION_NO_USAGE))
-    {
-      arg = dgettext (domain, arg);
-
-      if (flags & OPTION_ARG_OPTIONAL)
-	__argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
-      else
-	{
-	  /* Manually do line wrapping so that it (probably) won't
-	     get wrapped at the embedded space.  */
-	  space (stream, 6 + strlen (arg));
-	  __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
-	}
-    }
-
-  return 0;
-}
-
-/* Output a usage entry for the long option opt to the stream pointed at by
-   COOKIE.  */
-static int
-usage_long_opt (const struct argp_option *opt,
-		const struct argp_option *real,
-		const char *domain UNUSED, void *cookie)
-{
-  argp_fmtstream_t stream = cookie;
-  const char *arg = opt->arg;
-  int flags = opt->flags | real->flags;
-
-  if (! arg)
-    arg = real->arg;
-
-  if (! (flags & OPTION_NO_USAGE))
-    {
-      if (arg)
-	{
-	  arg = dgettext (domain, arg);
-	  if (flags & OPTION_ARG_OPTIONAL)
-	    __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
-	  else
-	    __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
-	}
-      else
-	__argp_fmtstream_printf (stream, " [--%s]", opt->name);
-    }
-
-  return 0;
-}
-
-/* Print a short usage description for the arguments in HOL to STREAM.  */
-static void
-hol_usage (struct hol *hol, argp_fmtstream_t stream)
-{
-  if (hol->num_entries > 0)
-    {
-      unsigned nentries;
-      struct hol_entry *entry;
-      char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
-      char *snao_end = short_no_arg_opts;
-
-      /* First we put a list of short options without arguments.  */
-      for (entry = hol->entries, nentries = hol->num_entries
-	   ; nentries > 0
-	   ; entry++, nentries--)
-	hol_entry_short_iterate (entry, add_argless_short_opt,
-				 entry->argp->argp_domain, &snao_end);
-      if (snao_end > short_no_arg_opts)
-	{
-	  *snao_end++ = 0;
-	  __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
-	}
-
-      /* Now a list of short options *with* arguments.  */
-      for (entry = hol->entries, nentries = hol->num_entries
-	   ; nentries > 0
-	   ; entry++, nentries--)
-	hol_entry_short_iterate (entry, usage_argful_short_opt,
-				 entry->argp->argp_domain, stream);
-
-      /* Finally, a list of long options (whew!).  */
-      for (entry = hol->entries, nentries = hol->num_entries
-	   ; nentries > 0
-	   ; entry++, nentries--)
-	hol_entry_long_iterate (entry, usage_long_opt,
-				entry->argp->argp_domain, stream);
-    }
-}
-
-/* Make a HOL containing all levels of options in ARGP.  CLUSTER is the
-   cluster in which ARGP's entries should be clustered, or 0.  */
-static struct hol *
-argp_hol (const struct argp *argp, struct hol_cluster *cluster)
-{
-  const struct argp_child *child = argp->children;
-  struct hol *hol = make_hol (argp, cluster);
-  if (child)
-    while (child->argp)
-      {
-	struct hol_cluster *child_cluster =
-	  ((child->group || child->header)
-	   /* Put CHILD->argp within its own cluster.  */
-	   ? hol_add_cluster (hol, child->group, child->header,
-			      child - argp->children, cluster, argp)
-	   /* Just merge it into the parent's cluster.  */
-	   : cluster);
-	hol_append (hol, argp_hol (child->argp, child_cluster)) ;
-	child++;
-      }
-  return hol;
-}
-
-/* Calculate how many different levels with alternative args strings exist in
-   ARGP.  */
-static size_t
-argp_args_levels (const struct argp *argp)
-{
-  size_t levels = 0;
-  const struct argp_child *child = argp->children;
-
-  if (argp->args_doc && strchr (argp->args_doc, '\n'))
-    levels++;
-
-  if (child)
-    while (child->argp)
-      levels += argp_args_levels ((child++)->argp);
-
-  return levels;
-}
-
-/* Print all the non-option args documented in ARGP to STREAM.  Any output is
-   preceded by a space.  LEVELS is a pointer to a byte vector the length
-   returned by argp_args_levels; it should be initialized to zero, and
-   updated by this routine for the next call if ADVANCE is true.  True is
-   returned as long as there are more patterns to output.  */
-static int
-argp_args_usage (const struct argp *argp, const struct argp_state *state,
-		 char **levels, int advance, argp_fmtstream_t stream)
-{
-  char *our_level = *levels;
-  int multiple = 0;
-  const struct argp_child *child = argp->children;
-  const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
-  const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
-
-  if (fdoc)
-    {
-      const char *cp = fdoc;
-      nl = __strchrnul (cp, '\n');
-      if (*nl != '\0')
-	/* This is a `multi-level' args doc; advance to the correct position
-	   as determined by our state in LEVELS, and update LEVELS.  */
-	{
-	  int i;
-	  multiple = 1;
-	  for (i = 0; i < *our_level; i++)
-	    cp = nl + 1, nl = __strchrnul (cp, '\n');
-	  (*levels)++;
-	}
-
-      /* Manually do line wrapping so that it (probably) won't get wrapped at
-	 any embedded spaces.  */
-      space (stream, 1 + nl - cp);
-
-      __argp_fmtstream_write (stream, cp, nl - cp);
-    }
-  if (fdoc && fdoc != tdoc)
-    free ((char *)fdoc);	/* Free user's modified doc string.  */
-
-  if (child)
-    while (child->argp)
-      advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
-
-  if (advance && multiple)
-    {
-      /* Need to increment our level.  */
-      if (*nl)
-	/* There's more we can do here.  */
-	{
-	  (*our_level)++;
-	  advance = 0;		/* Our parent shouldn't advance also. */
-	}
-      else if (*our_level > 0)
-	/* We had multiple levels, but used them up; reset to zero.  */
-	*our_level = 0;
-    }
-
-  return !advance;
-}
-
-/* Print the documentation for ARGP to STREAM; if POST is false, then
-   everything preceeding a `\v' character in the documentation strings (or
-   the whole string, for those with none) is printed, otherwise, everything
-   following the `\v' character (nothing for strings without).  Each separate
-   bit of documentation is separated a blank line, and if PRE_BLANK is true,
-   then the first is as well.  If FIRST_ONLY is true, only the first
-   occurrence is output.  Returns true if anything was output.  */
-static int
-argp_doc (const struct argp *argp, const struct argp_state *state,
-	  int post, int pre_blank, int first_only,
-	  argp_fmtstream_t stream)
-{
-  const char *text;
-  const char *inp_text;
-  void *input = 0;
-  int anything = 0;
-  size_t inp_text_limit = 0;
-  const char *doc = dgettext (argp->argp_domain, argp->doc);
-  const struct argp_child *child = argp->children;
-
-  if (doc)
-    {
-      char *vt = strchr (doc, '\v');
-      inp_text = post ? (vt ? vt + 1 : 0) : doc;
-      inp_text_limit = (!post && vt) ? (vt - doc) : 0;
-    }
-  else
-    inp_text = 0;
-
-  if (argp->help_filter)
-    /* We have to filter the doc strings.  */
-    {
-      if (inp_text_limit)
-	/* Copy INP_TEXT so that it's nul-terminated.  */
-	inp_text = STRNDUP (inp_text, inp_text_limit);
-      input = __argp_input (argp, state);
-      text =
-	(*argp->help_filter) (post
-			      ? ARGP_KEY_HELP_POST_DOC
-			      : ARGP_KEY_HELP_PRE_DOC,
-			      inp_text, input);
-    }
-  else
-    text = (const char *) inp_text;
-
-  if (text)
-    {
-      if (pre_blank)
-	__argp_fmtstream_putc (stream, '\n');
-
-      if (text == inp_text && inp_text_limit)
-	__argp_fmtstream_write (stream, inp_text, inp_text_limit);
-      else
-	__argp_fmtstream_puts (stream, text);
-
-      if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
-	__argp_fmtstream_putc (stream, '\n');
-
-      anything = 1;
-    }
-
-  if (text && text != inp_text)
-    free ((char *) text);	/* Free TEXT returned from the help filter.  */
-  if (inp_text && inp_text_limit && argp->help_filter)
-    free ((char *) inp_text);	/* We copied INP_TEXT, so free it now.  */
-
-  if (post && argp->help_filter)
-    /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text.  */
-    {
-      text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
-      if (text)
-	{
-	  if (anything || pre_blank)
-	    __argp_fmtstream_putc (stream, '\n');
-	  __argp_fmtstream_puts (stream, text);
-	  free ((char *) text);
-	  if (__argp_fmtstream_point (stream)
-	      > __argp_fmtstream_lmargin (stream))
-	    __argp_fmtstream_putc (stream, '\n');
-	  anything = 1;
-	}
-    }
-
-  if (child)
-    while (child->argp && !(first_only && anything))
-      anything |=
-	argp_doc ((child++)->argp, state,
-		  post, anything || pre_blank, first_only,
-		  stream);
-
-  return anything;
-}
-
-/* Output a usage message for ARGP to STREAM.  If called from
-   argp_state_help, STATE is the relevent parsing state.  FLAGS are from the
-   set ARGP_HELP_*.  NAME is what to use wherever a `program name' is
-   needed. */
-
-static void
-_help (const struct argp *argp, const struct argp_state *state, FILE *stream,
-       unsigned flags, const char *name)
-{
-  int anything = 0;		/* Whether we've output anything.  */
-  struct hol *hol = 0;
-  argp_fmtstream_t fs;
-
-  if (! stream)
-    return;
-
-  FLOCKFILE (stream);
-
-  if (! uparams.valid)
-    fill_in_uparams (state);
-
-  fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
-  if (! fs)
-    {
-      FUNLOCKFILE (stream);
-      return;
-    }
-
-  if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
-    {
-      hol = argp_hol (argp, 0);
-
-      /* If present, these options always come last.  */
-      hol_set_group (hol, "help", -1);
-      hol_set_group (hol, "version", -1);
-
-      hol_sort (hol);
-    }
-
-  if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
-    /* Print a short `Usage:' message.  */
-    {
-      int first_pattern = 1, more_patterns;
-      size_t num_pattern_levels = argp_args_levels (argp);
-      char *pattern_levels = alloca (num_pattern_levels);
-
-      memset (pattern_levels, 0, num_pattern_levels);
-
-      do
-	{
-	  int old_lm;
-	  int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
-	  char *levels = pattern_levels;
-
-	  if (first_pattern)
-	    __argp_fmtstream_printf (fs, "%s %s",
-				     dgettext (argp->argp_domain, "Usage:"),
-				     name);
-	  else
-	    __argp_fmtstream_printf (fs, "%s %s",
-				     dgettext (argp->argp_domain, "  or: "),
-				     name);
-
-	  /* We set the lmargin as well as the wmargin, because hol_usage
-	     manually wraps options with newline to avoid annoying breaks.  */
-	  old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
-
-	  if (flags & ARGP_HELP_SHORT_USAGE)
-	    /* Just show where the options go.  */
-	    {
-	      if (hol->num_entries > 0)
-		__argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
-						     " [OPTION...]"));
-	    }
-	  else
-	    /* Actually print the options.  */
-	    {
-	      hol_usage (hol, fs);
-	      flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once.  */
-	    }
-
-	  more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
-
-	  __argp_fmtstream_set_wmargin (fs, old_wm);
-	  __argp_fmtstream_set_lmargin (fs, old_lm);
-
-	  __argp_fmtstream_putc (fs, '\n');
-	  anything = 1;
-
-	  first_pattern = 0;
-	}
-      while (more_patterns);
-    }
-
-  if (flags & ARGP_HELP_PRE_DOC)
-    anything |= argp_doc (argp, state, 0, 0, 1, fs);
-
-  if (flags & ARGP_HELP_SEE)
-    {
-      __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
-Try `%s --help' or `%s --usage' for more information.\n"),
-			       name, name);
-      anything = 1;
-    }
-
-  if (flags & ARGP_HELP_LONG)
-    /* Print a long, detailed help message.  */
-    {
-      /* Print info about all the options.  */
-      if (hol->num_entries > 0)
-	{
-	  if (anything)
-	    __argp_fmtstream_putc (fs, '\n');
-	  hol_help (hol, state, fs);
-	  anything = 1;
-	}
-    }
-
-  if (flags & ARGP_HELP_POST_DOC)
-    /* Print any documentation strings at the end.  */
-    anything |= argp_doc (argp, state, 1, anything, 0, fs);
-
-  if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
-    {
-      if (anything)
-	__argp_fmtstream_putc (fs, '\n');
-      __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
-					     "Report bugs to %s.\n"),
- 			       argp_program_bug_address);
-      anything = 1;
-    }
-
-  FUNLOCKFILE (stream);
-
-  if (hol)
-    hol_free (hol);
-
-  __argp_fmtstream_free (fs);
-}
-
-/* Output a usage message for ARGP to STREAM.  FLAGS are from the set
-   ARGP_HELP_*.  NAME is what to use wherever a `program name' is needed. */
-void __argp_help (const struct argp *argp, FILE *stream,
-		  unsigned flags, char *name)
-{
-  _help (argp, 0, stream, flags, name);
-}
-#ifdef weak_alias
-weak_alias (__argp_help, argp_help)
-#endif
-
-char *__argp_basename(char *name)
-{
-  char *short_name = strrchr(name, '/');
-  return short_name ? short_name + 1 : name;
-}
-
-char *
-__argp_short_program_name(const struct argp_state *state)
-{
-  if (state)
-    return state->name;
-#if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
-  return program_invocation_short_name;
-#elif HAVE_DECL_PROGRAM_INVOCATION_NAME
-  return __argp_basename(program_invocation_name);
-#else /* !HAVE_DECL_PROGRAM_INVOCATION_NAME */
-  /* FIXME: What now? Miles suggests that it is better to use NULL,
-     but currently the value is passed on directly to fputs_unlocked,
-     so that requires more changes. */
-# if __GNUC__
-  return "";
-# endif /* __GNUC__ */
-#endif /* !HAVE_DECL_PROGRAM_INVOCATION_NAME */
-}
-
-/* Output, if appropriate, a usage message for STATE to STREAM.  FLAGS are
-   from the set ARGP_HELP_*.  */
-void
-__argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
-{
-  if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
-    {
-      if (state && (state->flags & ARGP_LONG_ONLY))
-	flags |= ARGP_HELP_LONG_ONLY;
-
-      _help (state ? state->root_argp : 0, state, stream, flags,
-	     __argp_short_program_name(state));
-
-      if (!state || ! (state->flags & ARGP_NO_EXIT))
-	{
-	  if (flags & ARGP_HELP_EXIT_ERR)
-	    exit (argp_err_exit_status);
-	  if (flags & ARGP_HELP_EXIT_OK)
-	    exit (0);
-	}
-  }
-}
-#ifdef weak_alias
-weak_alias (__argp_state_help, argp_state_help)
-#endif
-
-/* If appropriate, print the printf string FMT and following args, preceded
-   by the program name and `:', to stderr, and followed by a `Try ... --help'
-   message, then exit (1).  */
-void
-__argp_error (const struct argp_state *state, const char *fmt, ...)
-{
-  if (!state || !(state->flags & ARGP_NO_ERRS))
-    {
-      FILE *stream = state ? state->err_stream : stderr;
-
-      if (stream)
-	{
-	  va_list ap;
-
-	  FLOCKFILE (stream);
-
-	  FPUTS_UNLOCKED (__argp_short_program_name(state),
-			  stream);
-	  PUTC_UNLOCKED (':', stream);
-	  PUTC_UNLOCKED (' ', stream);
-
-	  va_start (ap, fmt);
-	  vfprintf (stream, fmt, ap);
-	  va_end (ap);
-
-	  PUTC_UNLOCKED ('\n', stream);
-
-	  __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
-
-	  FUNLOCKFILE (stream);
-	}
-    }
-}
-#ifdef weak_alias
-weak_alias (__argp_error, argp_error)
-#endif
-
-/* Similar to the standard gnu error-reporting function error(), but will
-   respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
-   to STATE->err_stream.  This is useful for argument parsing code that is
-   shared between program startup (when exiting is desired) and runtime
-   option parsing (when typically an error code is returned instead).  The
-   difference between this function and argp_error is that the latter is for
-   *parsing errors*, and the former is for other problems that occur during
-   parsing but don't reflect a (syntactic) problem with the input.  */
-void
-__argp_failure (const struct argp_state *state, int status, int errnum,
-		const char *fmt, ...)
-{
-  if (!state || !(state->flags & ARGP_NO_ERRS))
-    {
-      FILE *stream = state ? state->err_stream : stderr;
-
-      if (stream)
-	{
-	  FLOCKFILE (stream);
-
-	  FPUTS_UNLOCKED (__argp_short_program_name(state),
-			  stream);
-
-	  if (fmt)
-	    {
-	      va_list ap;
-
-	      PUTC_UNLOCKED (':', stream);
-	      PUTC_UNLOCKED (' ', stream);
-
-	      va_start (ap, fmt);
-	      vfprintf (stream, fmt, ap);
-	      va_end (ap);
-	    }
-
-	  if (errnum)
-	    {
-	      PUTC_UNLOCKED (':', stream);
-	      PUTC_UNLOCKED (' ', stream);
-	      fputs (STRERROR (errnum), stream);
-	    }
-
-	  PUTC_UNLOCKED ('\n', stream);
-
-	  FUNLOCKFILE (stream);
-
-	  if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
-	    exit (status);
-	}
-    }
-}
-#ifdef weak_alias
-weak_alias (__argp_failure, argp_failure)
-#endif
diff --git a/contrib/argp-standalone/argp-namefrob.h b/contrib/argp-standalone/argp-namefrob.h
deleted file mode 100644
index 0ce11481a7b..00000000000
--- a/contrib/argp-standalone/argp-namefrob.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Name frobnication for compiling argp outside of glibc
-   Copyright (C) 1997 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#if !_LIBC
-/* This code is written for inclusion in gnu-libc, and uses names in the
-   namespace reserved for libc.  If we're not compiling in libc, define those
-   names to be the normal ones instead.  */
-
-/* argp-parse functions */
-#undef __argp_parse
-#define __argp_parse argp_parse
-#undef __option_is_end
-#define __option_is_end _option_is_end
-#undef __option_is_short
-#define __option_is_short _option_is_short
-#undef __argp_input
-#define __argp_input _argp_input
-
-/* argp-help functions */
-#undef __argp_help
-#define __argp_help argp_help
-#undef __argp_error
-#define __argp_error argp_error
-#undef __argp_failure
-#define __argp_failure argp_failure
-#undef __argp_state_help
-#define __argp_state_help argp_state_help
-#undef __argp_usage
-#define __argp_usage argp_usage
-#undef __argp_basename
-#define __argp_basename _argp_basename
-#undef __argp_short_program_name
-#define __argp_short_program_name _argp_short_program_name
-
-/* argp-fmtstream functions */
-#undef __argp_make_fmtstream
-#define __argp_make_fmtstream argp_make_fmtstream
-#undef __argp_fmtstream_free
-#define __argp_fmtstream_free argp_fmtstream_free
-#undef __argp_fmtstream_putc
-#define __argp_fmtstream_putc argp_fmtstream_putc
-#undef __argp_fmtstream_puts
-#define __argp_fmtstream_puts argp_fmtstream_puts
-#undef __argp_fmtstream_write
-#define __argp_fmtstream_write argp_fmtstream_write
-#undef __argp_fmtstream_printf
-#define __argp_fmtstream_printf argp_fmtstream_printf
-#undef __argp_fmtstream_set_lmargin
-#define __argp_fmtstream_set_lmargin argp_fmtstream_set_lmargin
-#undef __argp_fmtstream_set_rmargin
-#define __argp_fmtstream_set_rmargin argp_fmtstream_set_rmargin
-#undef __argp_fmtstream_set_wmargin
-#define __argp_fmtstream_set_wmargin argp_fmtstream_set_wmargin
-#undef __argp_fmtstream_point
-#define __argp_fmtstream_point argp_fmtstream_point
-#undef __argp_fmtstream_update
-#define __argp_fmtstream_update _argp_fmtstream_update
-#undef __argp_fmtstream_ensure
-#define __argp_fmtstream_ensure _argp_fmtstream_ensure
-#undef __argp_fmtstream_lmargin
-#define __argp_fmtstream_lmargin argp_fmtstream_lmargin
-#undef __argp_fmtstream_rmargin
-#define __argp_fmtstream_rmargin argp_fmtstream_rmargin
-#undef __argp_fmtstream_wmargin
-#define __argp_fmtstream_wmargin argp_fmtstream_wmargin
-
-/* normal libc functions we call */
-#undef __sleep
-#define __sleep sleep
-#undef __strcasecmp
-#define __strcasecmp strcasecmp
-#undef __vsnprintf
-#define __vsnprintf vsnprintf
-
-#endif /* !_LIBC */
-
-#ifndef __set_errno
-#define __set_errno(e) (errno = (e))
-#endif
diff --git a/contrib/argp-standalone/argp-parse.c b/contrib/argp-standalone/argp-parse.c
deleted file mode 100644
index 78f7bf139b6..00000000000
--- a/contrib/argp-standalone/argp-parse.c
+++ /dev/null
@@ -1,1305 +0,0 @@
-/* Hierarchial argument parsing
-   Copyright (C) 1995, 96, 97, 98, 99, 2000,2003 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE	1
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#if HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-#include <limits.h>
-#include <assert.h>
-
-#if HAVE_MALLOC_H
-/* Needed, for alloca on windows */
-# include <malloc.h>
-#endif
-
-#ifndef _
-/* This is for other GNU distributions with internationalized messages.
-   When compiling libc, the _ macro is predefined.  */
-# if defined HAVE_LIBINTL_H || defined _LIBC
-#  include <libintl.h>
-#  ifdef _LIBC
-#   undef dgettext
-#   define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
-#  endif
-# else
-#  define dgettext(domain, msgid) (msgid)
-#  define gettext(msgid) (msgid)
-# endif
-#endif
-#ifndef N_
-# define N_(msgid) (msgid)
-#endif
-
-#if _LIBC - 0
-#include <bits/libc-lock.h>
-#else
-#ifdef HAVE_CTHREADS_H
-#include <cthreads.h>
-#endif
-#endif /* _LIBC */
-
-#include "argp.h"
-#include "argp-namefrob.h"
-
-
-/* The meta-argument used to prevent any further arguments being interpreted
-   as options.  */
-#define QUOTE "--"
-
-/* EZ alias for ARGP_ERR_UNKNOWN.  */
-#define EBADKEY ARGP_ERR_UNKNOWN
-
-
-/* Default options.  */
-
-/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
-   for one second intervals, decrementing _ARGP_HANG until it's zero.  Thus
-   you can force the program to continue by attaching a debugger and setting
-   it to 0 yourself.  */
-volatile int _argp_hang;
-
-#define OPT_PROGNAME	-2
-#define OPT_USAGE	-3
-#if HAVE_SLEEP && HAVE_GETPID
-#define OPT_HANG	-4
-#endif
-
-static const struct argp_option argp_default_options[] =
-{
-  {"help",	  '?',    	0, 0,  N_("Give this help list"), -1},
-  {"usage",	  OPT_USAGE,	0, 0,  N_("Give a short usage message"), 0 },
-  {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN,
-     N_("Set the program name"), 0},
-#if OPT_HANG
-  {"HANG",	  OPT_HANG,    "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
-     N_("Hang for SECS seconds (default 3600)"), 0 },
-#endif
-  {0, 0, 0, 0, 0, 0}
-};
-
-static error_t
-argp_default_parser (int key, char *arg, struct argp_state *state)
-{
-  switch (key)
-    {
-    case '?':
-      __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
-      break;
-    case OPT_USAGE:
-      __argp_state_help (state, state->out_stream,
-		       ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
-      break;
-
-    case OPT_PROGNAME:		/* Set the program name.  */
-#if HAVE_DECL_PROGRAM_INVOCATION_NAME
-      program_invocation_name = arg;
-#endif
-      /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
-	 __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
-	 to be that, so we have to be a bit careful here.]  */
-
-      /* Update what we use for messages.  */
-
-      state->name = __argp_basename(arg);
-      
-#if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
-      program_invocation_short_name = state->name;
-#endif
-
-      if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
-	  == ARGP_PARSE_ARGV0)
-	/* Update what getopt uses too.  */
-	state->argv[0] = arg;
-
-      break;
-      
-#if OPT_HANG
-    case OPT_HANG:
-      _argp_hang = atoi (arg ? arg : "3600");
-      fprintf(state->err_stream, "%s: pid = %ld\n",
-	      state->name, (long) getpid());
-      while (_argp_hang-- > 0)
-	__sleep (1);
-      break;
-#endif
-      
-    default:
-      return EBADKEY;
-    }
-  return 0;
-}
-
-static const struct argp argp_default_argp =
-  {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
-
-
-static const struct argp_option argp_version_options[] =
-{
-  {"version",	  'V',    	0, 0,  N_("Print program version"), -1},
-  {0, 0, 0, 0, 0, 0 }
-};
-
-static error_t
-argp_version_parser (int key, char *arg UNUSED, struct argp_state *state)
-{
-  switch (key)
-    {
-    case 'V':
-      if (argp_program_version_hook)
-	(*argp_program_version_hook) (state->out_stream, state);
-      else if (argp_program_version)
-	fprintf (state->out_stream, "%s\n", argp_program_version);
-      else
-	__argp_error (state, dgettext (state->root_argp->argp_domain,
-				       "(PROGRAM ERROR) No version known!?"));
-      if (! (state->flags & ARGP_NO_EXIT))
-	exit (0);
-      break;
-    default:
-      return EBADKEY;
-    }
-  return 0;
-}
-
-static const struct argp argp_version_argp =
-  {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
-
-
-
-/* The state of a `group' during parsing.  Each group corresponds to a
-   particular argp structure from the tree of such descending from the top
-   level argp passed to argp_parse.  */
-struct group
-{
-  /* This group's parsing function.  */
-  argp_parser_t parser;
-
-  /* Which argp this group is from.  */
-  const struct argp *argp;
-
-  /* The number of non-option args sucessfully handled by this parser.  */
-  unsigned args_processed;
-
-  /* This group's parser's parent's group.  */
-  struct group *parent;
-  unsigned parent_index;	/* And the our position in the parent.   */
-
-  /* These fields are swapped into and out of the state structure when
-     calling this group's parser.  */
-  void *input, **child_inputs;
-  void *hook;
-};
-
-/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
-   from STATE before calling, and back into state afterwards.  If GROUP has
-   no parser, EBADKEY is returned.  */
-static error_t
-group_parse (struct group *group, struct argp_state *state, int key, char *arg)
-{
-  if (group->parser)
-    {
-      error_t err;
-      state->hook = group->hook;
-      state->input = group->input;
-      state->child_inputs = group->child_inputs;
-      state->arg_num = group->args_processed;
-      err = (*group->parser)(key, arg, state);
-      group->hook = state->hook;
-      return err;
-    }
-  else
-    return EBADKEY;
-}
-
-struct parser
-{
-  const struct argp *argp;
-
-  const char *posixly_correct;
-  
-  /* True if there are only no-option arguments left, which are just
-     passed verbatim with ARGP_KEY_ARG. This is set if we encounter a
-     quote, or the end of the proper options, but may be cleared again
-     if the user moves the next argument pointer backwards. */
-  int args_only;
-
-  /* Describe how to deal with options that follow non-option ARGV-elements.
-
-     If the caller did not specify anything, the default is
-     REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is
-     defined, PERMUTE otherwise.
-
-     REQUIRE_ORDER means don't recognize them as options; stop option
-     processing when the first non-option is seen. This is what Unix
-     does. This mode of operation is selected by either setting the
-     environment variable POSIXLY_CORRECT, or using `+' as the first
-     character of the list of option characters.
-
-     PERMUTE is the default. We permute the contents of ARGV as we
-     scan, so that eventually all the non-options are at the end. This
-     allows options to be given in any order, even with programs that
-     were not written to expect this.
-
-     RETURN_IN_ORDER is an option available to programs that were
-     written to expect options and other ARGV-elements in any order
-     and that care about the ordering of the two. We describe each
-     non-option ARGV-element as if it were the argument of an option
-     with character code 1. Using `-' as the first character of the
-     list of option characters selects this mode of operation.
-
-  */
-  enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering;
-
-  /* A segment of non-option arguments that have been skipped for
-     later processing, after all options. `first_nonopt' is the index
-     in ARGV of the first of them; `last_nonopt' is the index after
-     the last of them.
-
-     If quoted or args_only is non-zero, this segment should be empty. */
-
-  /* FIXME: I'd prefer to use unsigned, but it's more consistent to
-     use the same type as for state.next. */
-  int first_nonopt;
-  int last_nonopt;
-  
-  /* String of all recognized short options. Needed for ARGP_LONG_ONLY. */
-  /* FIXME: Perhaps change to a pointer to a suitable bitmap instead? */
-  char *short_opts;
-
-  /* For parsing combined short options. */
-  char *nextchar;
-  
-  /* States of the various parsing groups.  */
-  struct group *groups;
-  /* The end of the GROUPS array.  */
-  struct group *egroup;
-  /* An vector containing storage for the CHILD_INPUTS field in all groups.  */
-  void **child_inputs;
-  
-  /* State block supplied to parsing routines.  */
-  struct argp_state state;
-
-  /* Memory used by this parser.  */
-  void *storage;
-};
-
-/* Search for a group defining a short option. */
-static const struct argp_option *
-find_short_option(struct parser *parser, int key, struct group **p)
-{
-  struct group *group;
-  
-  assert(key >= 0);
-  assert(isascii(key));
-
-  for (group = parser->groups; group < parser->egroup; group++)
-    {
-      const struct argp_option *opts;
-
-      for (opts = group->argp->options; !__option_is_end(opts); opts++)
-	if (opts->key == key)
-	  {
-	    *p = group;
-	    return opts;
-	  }
-    }
-  return NULL;
-}
-
-enum match_result { MATCH_EXACT, MATCH_PARTIAL, MATCH_NO };
-
-/* If defined, allow complete.el-like abbreviations of long options. */
-#ifndef ARGP_COMPLETE
-#define ARGP_COMPLETE 0
-#endif
-
-/* Matches an encountern long-option argument ARG against an option NAME.
- * ARG is terminated by NUL or '='. */
-static enum match_result
-match_option(const char *arg, const char *name)
-{
-  unsigned i, j;
-  for (i = j = 0;; i++, j++)
-    {
-      switch(arg[i])
-	{
-	case '\0':
-	case '=':
-	  return name[j] ? MATCH_PARTIAL : MATCH_EXACT;
-#if ARGP_COMPLETE
-	case '-':
-	  while (name[j] != '-')
-	    if (!name[j++])
-	      return MATCH_NO;
-	  break;
-#endif
-	default:
-	  if (arg[i] != name[j])
-	    return MATCH_NO;
-	}
-    }
-}
-
-static const struct argp_option *
-find_long_option(struct parser *parser,
-		 const char *arg,
-		 struct group **p)
-{
-  struct group *group;
-
-  /* Partial match found so far. */
-  struct group *matched_group = NULL;
-  const struct argp_option *matched_option = NULL;
-
-  /* Number of partial matches. */
-  int num_partial = 0;
-
-  for (group = parser->groups; group < parser->egroup; group++)
-    {
-      const struct argp_option *opts;
-
-      for (opts = group->argp->options; !__option_is_end(opts); opts++)
-	{
-	  if (!opts->name)
-	    continue;
-	  switch (match_option(arg, opts->name))
-	    {
-	    case MATCH_NO:
-	      break;
-	    case MATCH_PARTIAL:
-	      num_partial++;
-
-	      matched_group = group;
-	      matched_option = opts;
-
-	      break;
-	    case MATCH_EXACT:
-	      /* Exact match. */
-	      *p = group;
-	      return opts;
-	    }
-	}
-    }
-  if (num_partial == 1)
-    {
-      *p = matched_group;
-      return matched_option;
-    }
-
-  return NULL;
-}
-
-
-/* The next usable entries in the various parser tables being filled in by
-   convert_options.  */
-struct parser_convert_state
-{
-  struct parser *parser;
-  char *short_end;
-  void **child_inputs_end;
-};
-
-/* Initialize GROUP from ARGP. If CVT->SHORT_END is non-NULL, short
-   options are recorded in the short options string. Returns the next
-   unused group entry. CVT holds state used during the conversion. */
-static struct group *
-convert_options (const struct argp *argp,
-		 struct group *parent, unsigned parent_index,
-		 struct group *group, struct parser_convert_state *cvt)
-{
-  const struct argp_option *opt = argp->options;
-  const struct argp_child *children = argp->children;
-
-  if (opt || argp->parser)
-    {
-      /* This parser needs a group. */
-      if (cvt->short_end)
-	{
-	  /* Record any short options. */
-	  for ( ; !__option_is_end (opt); opt++)
-	    if (__option_is_short(opt))
-	      *cvt->short_end++ = opt->key;
-	}
-      
-      group->parser = argp->parser;
-      group->argp = argp;
-      group->args_processed = 0;
-      group->parent = parent;
-      group->parent_index = parent_index;
-      group->input = 0;
-      group->hook = 0;
-      group->child_inputs = 0;
-      
-      if (children)
-	/* Assign GROUP's CHILD_INPUTS field some space from
-	   CVT->child_inputs_end.*/
-	{
-	  unsigned num_children = 0;
-	  while (children[num_children].argp)
-	    num_children++;
-	  group->child_inputs = cvt->child_inputs_end;
-	  cvt->child_inputs_end += num_children;
-	}
-      parent = group++;
-    }
-  else
-    parent = 0;
-
-  if (children)
-    {
-      unsigned index = 0;
-      while (children->argp)
-	group =
-	  convert_options (children++->argp, parent, index++, group, cvt);
-    }
-
-  return group;
-}
-/* Allocate and initialize the group structures, so that they are
-   ordered as if by traversing the corresponding argp parser tree in
-   pre-order. Also build the list of short options, if that is needed. */
-static void
-parser_convert (struct parser *parser, const struct argp *argp)
-{
-  struct parser_convert_state cvt;
-
-  cvt.parser = parser;
-  cvt.short_end = parser->short_opts;
-  cvt.child_inputs_end = parser->child_inputs;
-
-  parser->argp = argp;
-
-  if (argp)
-    parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
-  else
-    parser->egroup = parser->groups; /* No parsers at all! */
-
-  if (parser->short_opts)
-    *cvt.short_end ='\0';
-}
-
-/* Lengths of various parser fields which we will allocated.  */
-struct parser_sizes
-{
-  /* Needed only ARGP_LONG_ONLY */
-  size_t short_len;		/* Number of short options.  */
-
-  size_t num_groups;		/* Group structures we allocate.  */
-  size_t num_child_inputs;	/* Child input slots.  */
-};
-
-/* For ARGP, increments the NUM_GROUPS field in SZS by the total
-   number of argp structures descended from it, and the SHORT_LEN by
-   the total number of short options. */
-static void
-calc_sizes (const struct argp *argp,  struct parser_sizes *szs)
-{
-  const struct argp_child *child = argp->children;
-  const struct argp_option *opt = argp->options;
-
-  if (opt || argp->parser)
-    {
-      /* This parser needs a group. */
-      szs->num_groups++;
-      if (opt)
-	{
-	  while (__option_is_short (opt++))
-	    szs->short_len++;
-	}
-    }
-
-  if (child)
-    while (child->argp)
-      {
-	calc_sizes ((child++)->argp, szs);
-	szs->num_child_inputs++;
-      }
-}
-
-/* Initializes PARSER to parse ARGP in a manner described by FLAGS.  */
-static error_t
-parser_init (struct parser *parser, const struct argp *argp,
-	     int argc, char **argv, int flags, void *input)
-{
-  error_t err = 0;
-  struct group *group;
-  struct parser_sizes szs;
-
-  parser->posixly_correct = getenv ("POSIXLY_CORRECT");
-
-  if (flags & ARGP_IN_ORDER)
-    parser->ordering = RETURN_IN_ORDER;
-  else if (flags & ARGP_NO_ARGS)
-    parser->ordering = REQUIRE_ORDER;
-  else if (parser->posixly_correct)
-    parser->ordering = REQUIRE_ORDER;
-  else
-    parser->ordering = PERMUTE;
-  
-  szs.short_len = 0;
-  szs.num_groups = 0;
-  szs.num_child_inputs = 0;
-
-  if (argp)
-    calc_sizes (argp, &szs);
-
-  if (!(flags & ARGP_LONG_ONLY))
-    /* We have no use for the short option array. */
-    szs.short_len = 0;
-  
-  /* Lengths of the various bits of storage used by PARSER.  */
-#define GLEN (szs.num_groups + 1) * sizeof (struct group)
-#define CLEN (szs.num_child_inputs * sizeof (void *))
-#define SLEN (szs.short_len + 1)
-#define STORAGE(offset) ((void *) (((char *) parser->storage) + (offset)))
-
-  parser->storage = malloc (GLEN + CLEN + SLEN);
-  if (! parser->storage)
-    return ENOMEM;
-
-  parser->groups = parser->storage;
-
-  parser->child_inputs = STORAGE(GLEN);
-  memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
-
-  if (flags & ARGP_LONG_ONLY)
-    parser->short_opts = STORAGE(GLEN + CLEN);
-  else
-    parser->short_opts = NULL;
-
-  parser_convert (parser, argp);
-
-  memset (&parser->state, 0, sizeof (struct argp_state));
-  
-  parser->state.root_argp = parser->argp;
-  parser->state.argc = argc;
-  parser->state.argv = argv;
-  parser->state.flags = flags;
-  parser->state.err_stream = stderr;
-  parser->state.out_stream = stdout;
-  parser->state.pstate = parser;
-
-  parser->args_only = 0;
-  parser->nextchar = NULL;
-  parser->first_nonopt = parser->last_nonopt = 0;
-    
-  /* Call each parser for the first time, giving it a chance to propagate
-     values to child parsers.  */
-  if (parser->groups < parser->egroup)
-    parser->groups->input = input;
-  for (group = parser->groups;
-       group < parser->egroup && (!err || err == EBADKEY);
-       group++)
-    {
-      if (group->parent)
-	/* If a child parser, get the initial input value from the parent. */
-	group->input = group->parent->child_inputs[group->parent_index];
-
-      if (!group->parser
-	  && group->argp->children && group->argp->children->argp)
-	/* For the special case where no parsing function is supplied for an
-	   argp, propagate its input to its first child, if any (this just
-	   makes very simple wrapper argps more convenient).  */
-	group->child_inputs[0] = group->input;
-
-      err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
-    }
-  if (err == EBADKEY)
-    err = 0;			/* Some parser didn't understand.  */
-
-  if (err)
-    return err;
-
-  if (argv[0] && !(parser->state.flags & ARGP_PARSE_ARGV0))
-    /* There's an argv[0]; use it for messages.  */
-    {
-      parser->state.name = __argp_basename(argv[0]);
-
-      /* Don't parse it as an argument. */
-      parser->state.next = 1;
-    }
-  else
-    parser->state.name = __argp_short_program_name(NULL);
-  
-  return 0;
-}
-
-/* Free any storage consumed by PARSER (but not PARSER itself).  */
-static error_t
-parser_finalize (struct parser *parser,
-		 error_t err, int arg_ebadkey, int *end_index)
-{
-  struct group *group;
-
-  if (err == EBADKEY && arg_ebadkey)
-    /* Suppress errors generated by unparsed arguments.  */
-    err = 0;
-
-  if (! err)
-    {
-      if (parser->state.next == parser->state.argc)
-	/* We successfully parsed all arguments!  Call all the parsers again,
-	   just a few more times... */
-	{
-	  for (group = parser->groups;
-	       group < parser->egroup && (!err || err==EBADKEY);
-	       group++)
-	    if (group->args_processed == 0)
-	      err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
-	  for (group = parser->egroup - 1;
-	       group >= parser->groups && (!err || err==EBADKEY);
-	       group--)
-	    err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
-
-	  if (err == EBADKEY)
-	    err = 0;		/* Some parser didn't understand.  */
-
-	  /* Tell the user that all arguments are parsed.  */
-	  if (end_index)
-	    *end_index = parser->state.next;
-	}
-      else if (end_index)
-	/* Return any remaining arguments to the user.  */
-	*end_index = parser->state.next;
-      else
-	/* No way to return the remaining arguments, they must be bogus. */
-	{
-	  if (!(parser->state.flags & ARGP_NO_ERRS)
-	      && parser->state.err_stream)
-	    fprintf (parser->state.err_stream,
-		     dgettext (parser->argp->argp_domain,
-			       "%s: Too many arguments\n"),
-		     parser->state.name);
-	  err = EBADKEY;
-	}
-    }
-
-  /* Okay, we're all done, with either an error or success; call the parsers
-     to indicate which one.  */
-
-  if (err)
-    {
-      /* Maybe print an error message.  */
-      if (err == EBADKEY)
-	/* An appropriate message describing what the error was should have
-	   been printed earlier.  */
-	__argp_state_help (&parser->state, parser->state.err_stream,
-			   ARGP_HELP_STD_ERR);
-
-      /* Since we didn't exit, give each parser an error indication.  */
-      for (group = parser->groups; group < parser->egroup; group++)
-	group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
-    }
-  else
-    /* Notify parsers of success, and propagate back values from parsers.  */
-    {
-      /* We pass over the groups in reverse order so that child groups are
-	 given a chance to do there processing before passing back a value to
-	 the parent.  */
-      for (group = parser->egroup - 1
-	   ; group >= parser->groups && (!err || err == EBADKEY)
-	   ; group--)
-	err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
-      if (err == EBADKEY)
-	err = 0;		/* Some parser didn't understand.  */
-    }
-
-  /* Call parsers once more, to do any final cleanup.  Errors are ignored.  */
-  for (group = parser->egroup - 1; group >= parser->groups; group--)
-    group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
-
-  if (err == EBADKEY)
-    err = EINVAL;
-
-  free (parser->storage);
-
-  return err;
-}
-
-/* Call the user parsers to parse the non-option argument VAL, at the
-   current position, returning any error. The state NEXT pointer
-   should point to the argument; this function will adjust it
-   correctly to reflect however many args actually end up being
-   consumed. */
-static error_t
-parser_parse_arg (struct parser *parser, char *val)
-{
-  /* Save the starting value of NEXT */
-  int index = parser->state.next;
-  error_t err = EBADKEY;
-  struct group *group;
-  int key = 0;			/* Which of ARGP_KEY_ARG[S] we used.  */
-
-  /* Try to parse the argument in each parser.  */
-  for (group = parser->groups
-       ; group < parser->egroup && err == EBADKEY
-       ; group++)
-    {
-      parser->state.next++;	/* For ARGP_KEY_ARG, consume the arg.  */
-      key = ARGP_KEY_ARG;
-      err = group_parse (group, &parser->state, key, val);
-
-      if (err == EBADKEY)
-	/* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
-	{
-	  parser->state.next--;	/* For ARGP_KEY_ARGS, put back the arg.  */
-	  key = ARGP_KEY_ARGS;
-	  err = group_parse (group, &parser->state, key, 0);
-	}
-    }
-
-  if (! err)
-    {
-      if (key == ARGP_KEY_ARGS)
-	/* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
-	   changed by the user, *all* arguments should be considered
-	   consumed.  */
-	parser->state.next = parser->state.argc;
-
-      if (parser->state.next > index)
-	/* Remember that we successfully processed a non-option
-	   argument -- but only if the user hasn't gotten tricky and set
-	   the clock back.  */
-	(--group)->args_processed += (parser->state.next - index);
-      else
-	/* The user wants to reparse some args, so try looking for options again.  */
-	parser->args_only = 0;
-    }
-
-  return err;
-}
-
-/* Exchange two adjacent subsequences of ARGV.
-   One subsequence is elements [first_nonopt,last_nonopt)
-   which contains all the non-options that have been skipped so far.
-   The other is elements [last_nonopt,next), which contains all
-   the options processed since those non-options were skipped.
-
-   `first_nonopt' and `last_nonopt' are relocated so that they describe
-   the new indices of the non-options in ARGV after they are moved.  */
-
-static void
-exchange (struct parser *parser)
-{
-  int bottom = parser->first_nonopt;
-  int middle = parser->last_nonopt;
-  int top = parser->state.next;
-  char **argv = parser->state.argv;
-  
-  char *tem;
-
-  /* Exchange the shorter segment with the far end of the longer segment.
-     That puts the shorter segment into the right place.
-     It leaves the longer segment in the right place overall,
-     but it consists of two parts that need to be swapped next.  */
-
-  while (top > middle && middle > bottom)
-    {
-      if (top - middle > middle - bottom)
-	{
-	  /* Bottom segment is the short one.  */
-	  int len = middle - bottom;
-	  register int i;
-
-	  /* Swap it with the top part of the top segment.  */
-	  for (i = 0; i < len; i++)
-	    {
-	      tem = argv[bottom + i];
-	      argv[bottom + i] = argv[top - (middle - bottom) + i];
-	      argv[top - (middle - bottom) + i] = tem;
-	    }
-	  /* Exclude the moved bottom segment from further swapping.  */
-	  top -= len;
-	}
-      else
-	{
-	  /* Top segment is the short one.  */
-	  int len = top - middle;
-	  register int i;
-
-	  /* Swap it with the bottom part of the bottom segment.  */
-	  for (i = 0; i < len; i++)
-	    {
-	      tem = argv[bottom + i];
-	      argv[bottom + i] = argv[middle + i];
-	      argv[middle + i] = tem;
-	    }
-	  /* Exclude the moved top segment from further swapping.  */
-	  bottom += len;
-	}
-    }
-
-  /* Update records for the slots the non-options now occupy.  */
-
-  parser->first_nonopt += (parser->state.next - parser->last_nonopt);
-  parser->last_nonopt = parser->state.next;
-}
-
-
-
-enum arg_type { ARG_ARG, ARG_SHORT_OPTION,
-		ARG_LONG_OPTION, ARG_LONG_ONLY_OPTION,
-		ARG_QUOTE };
-
-static enum arg_type
-classify_arg(struct parser *parser, char *arg, char **opt)
-{
-  if (arg[0] == '-')
-    /* Looks like an option... */
-    switch (arg[1])
-      {
-      case '\0':
-	/* "-" is not an option. */
-	return ARG_ARG;
-      case '-':
-	/* Long option, or quote. */
-	if (!arg[2])
-	  return ARG_QUOTE;
-	  
-	/* A long option. */
-	if (opt)
-	  *opt = arg + 2;
-	return ARG_LONG_OPTION;
-
-      default:
-	/* Short option. But if ARGP_LONG_ONLY, it can also be a long option. */
-
-	if (opt)
-	  *opt = arg + 1;
-
-	if (parser->state.flags & ARGP_LONG_ONLY)
-	  {
-	    /* Rules from getopt.c:
-
-	       If long_only and the ARGV-element has the form "-f",
-	       where f is a valid short option, don't consider it an
-	       abbreviated form of a long option that starts with f.
-	       Otherwise there would be no way to give the -f short
-	       option.
-
-	       On the other hand, if there's a long option "fubar" and
-	       the ARGV-element is "-fu", do consider that an
-	       abbreviation of the long option, just like "--fu", and
-	       not "-f" with arg "u".
-
-	       This distinction seems to be the most useful approach. */
-
-	    assert(parser->short_opts);
-	    
-	    if (arg[2] || !strchr(parser->short_opts, arg[1]))
-	      return ARG_LONG_ONLY_OPTION;
-	  }
-
-	return ARG_SHORT_OPTION;
-      }
-  
-  else
-    return ARG_ARG;
-}
-
-/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
-   Any error from the parsers is returned, and *ARGP_EBADKEY indicates
-   whether a value of EBADKEY is due to an unrecognized argument (which is
-   generally not fatal).  */
-static error_t
-parser_parse_next (struct parser *parser, int *arg_ebadkey)
-{
-  if (parser->state.quoted && parser->state.next < parser->state.quoted)
-    /* The next argument pointer has been moved to before the quoted
-       region, so pretend we never saw the quoting `--', and start
-       looking for options again. If the `--' is still there we'll just
-       process it one more time. */
-    parser->state.quoted = parser->args_only = 0;
-
-  /* Give FIRST_NONOPT & LAST_NONOPT rational values if NEXT has been
-     moved back by the user (who may also have changed the arguments).  */
-  if (parser->last_nonopt > parser->state.next)
-    parser->last_nonopt = parser->state.next;
-  if (parser->first_nonopt > parser->state.next)
-    parser->first_nonopt = parser->state.next;
-
-  if (parser->nextchar)
-    /* Deal with short options. */
-    {
-      struct group *group;
-      char c;
-      const struct argp_option *option;
-      char *value = NULL;;
-
-      assert(!parser->args_only);
-
-      c = *parser->nextchar++;
-      
-      option = find_short_option(parser, c, &group);
-      if (!option)
-	{
-	  if (parser->posixly_correct)
-	    /* 1003.2 specifies the format of this message.  */
-	    fprintf (parser->state.err_stream,
-		     dgettext(parser->state.root_argp->argp_domain,
-			      "%s: illegal option -- %c\n"),
-		     parser->state.name, c);
-	  else
-	    fprintf (parser->state.err_stream,
-		     dgettext(parser->state.root_argp->argp_domain,
-			      "%s: invalid option -- %c\n"),
-		     parser->state.name, c);
-
-	  *arg_ebadkey = 0;
-	  return EBADKEY;
-	}
-
-      if (!*parser->nextchar)
-	parser->nextchar = NULL;
-
-      if (option->arg)
-	{
-	  value = parser->nextchar;
-	  parser->nextchar = NULL;
-	      
-	  if (!value
-	      && !(option->flags & OPTION_ARG_OPTIONAL))
-	    /* We need an mandatory argument. */
-	    {
-	      if (parser->state.next == parser->state.argc)
-		/* Missing argument */
-		{
-		  /* 1003.2 specifies the format of this message.  */
-		  fprintf (parser->state.err_stream,
-			   dgettext(parser->state.root_argp->argp_domain,
-				    "%s: option requires an argument -- %c\n"),
-			   parser->state.name, c);
-
-		  *arg_ebadkey = 0;
-		  return EBADKEY;
-		}
-	      value = parser->state.argv[parser->state.next++];
-	    }
-	}
-      return group_parse(group, &parser->state,
-			 option->key, value);
-    }
-  else
-    /* Advance to the next ARGV-element.  */
-    {
-      if (parser->args_only)
-	{
-	  *arg_ebadkey = 1;
-	  if (parser->state.next >= parser->state.argc)
-	    /* We're done. */
-	    return EBADKEY;
-	  else
-	    return parser_parse_arg(parser,
-				    parser->state.argv[parser->state.next]);
-	}
-      
-      if (parser->state.next >= parser->state.argc)
-	/* Almost done. If there are non-options that we skipped
-	   previously, we should process them now. */
-	{
-	  *arg_ebadkey = 1;
-	  if (parser->first_nonopt != parser->last_nonopt)
-	    {
-	      exchange(parser);
-	      
-	      /* Start processing the arguments we skipped previously. */
-	      parser->state.next = parser->first_nonopt;
-	      
-	      parser->first_nonopt = parser->last_nonopt = 0;
-
-	      parser->args_only = 1;
-	      return 0;
-	    }
-	  else
-	    /* Indicate that we're really done. */
-	    return EBADKEY;
-	}
-      else
-	/* Look for options. */
-	{
-	  char *arg = parser->state.argv[parser->state.next];
-
-	  char *optstart;
-	  enum arg_type token = classify_arg(parser, arg, &optstart);
-	  
-	  switch (token)
-	    {
-	    case ARG_ARG:
-	      switch (parser->ordering)
-		{
-		case PERMUTE:
-		  if (parser->first_nonopt == parser->last_nonopt)
-		    /* Skipped sequence is empty; start a new one. */
-		    parser->first_nonopt = parser->last_nonopt = parser->state.next;
-
-		  else if (parser->last_nonopt != parser->state.next)
-		    /* We have a non-empty skipped sequence, and
-		       we're not at the end-point, so move it. */
-		    exchange(parser);
-
-		  assert(parser->last_nonopt == parser->state.next);
-		  
-		  /* Skip this argument for now. */
-		  parser->state.next++;
-		  parser->last_nonopt = parser->state.next; 
-		  
-		  return 0;
-
-		case REQUIRE_ORDER:
-		  /* Implicit quote before the first argument. */
-		   parser->args_only = 1;
-		   return 0;
-		   
-		case RETURN_IN_ORDER:
-		  *arg_ebadkey = 1;
-		  return parser_parse_arg(parser, arg);
-
-		default:
-		  abort();
-		}
-	    case ARG_QUOTE:
-	      /* Skip it, then exchange with any previous non-options. */
-	      parser->state.next++;
-	      assert (parser->last_nonopt != parser->state.next);
-
-	      if (parser->first_nonopt != parser->last_nonopt)
-		{
-		  exchange(parser);
-		  
-		  /* Start processing the skipped and the quoted
-		     arguments. */
-
-		  parser->state.quoted = parser->state.next = parser->first_nonopt;
-
-		  /* Also empty the skipped-list, to avoid confusion
-		     if the user resets the next pointer. */
-		  parser->first_nonopt = parser->last_nonopt = 0;
-		}
-	      else
-		parser->state.quoted = parser->state.next;
-
-	      parser->args_only = 1;	      
-	      return 0;
-
-	    case ARG_LONG_ONLY_OPTION:
-	    case ARG_LONG_OPTION:
-	      {
-		struct group *group;
-		const struct argp_option *option;
-		char *value;
-
-		parser->state.next++;
-		option = find_long_option(parser, optstart, &group);
-		
-		if (!option)
-		  {
-		    /* NOTE: This includes any "=something" in the output. */
-		    fprintf (parser->state.err_stream,
-			     dgettext(parser->state.root_argp->argp_domain,
-				      "%s: unrecognized option `%s'\n"),
-			     parser->state.name, arg);
-		    *arg_ebadkey = 0;
-		    return EBADKEY;
-		  }
-
-		value = strchr(optstart, '=');
-		if (value)
-		  value++;
-		
-		if (value && !option->arg)
-		  /* Unexpected argument. */
-		  {
-		    if (token == ARG_LONG_OPTION)
-		      /* --option */
-		      fprintf (parser->state.err_stream,
-			       dgettext(parser->state.root_argp->argp_domain,
-					"%s: option `--%s' doesn't allow an argument\n"),
-			       parser->state.name, option->name);
-		    else
-		      /* +option or -option */
-		      fprintf (parser->state.err_stream,
-			       dgettext(parser->state.root_argp->argp_domain,
-					"%s: option `%c%s' doesn't allow an argument\n"),
-			       parser->state.name, arg[0], option->name);
-
-		    *arg_ebadkey = 0;
-		    return EBADKEY;
-		  }
-		
-		if (option->arg && !value
-		    && !(option->flags & OPTION_ARG_OPTIONAL))
-		  /* We need an mandatory argument. */
-		  {
-		    if (parser->state.next == parser->state.argc)
-		      /* Missing argument */
-		      {
-			if (token == ARG_LONG_OPTION)
-			  /* --option */
-			  fprintf (parser->state.err_stream,
-				   dgettext(parser->state.root_argp->argp_domain,
-					    "%s: option `--%s' requires an argument\n"),
-				 parser->state.name, option->name);
-			else
-			  /* +option or -option */
-			  fprintf (parser->state.err_stream,
-				   dgettext(parser->state.root_argp->argp_domain,
-					    "%s: option `%c%s' requires an argument\n"),
-				   parser->state.name, arg[0], option->name);
-
-			*arg_ebadkey = 0;
-			return EBADKEY;
-		      }
-
-		    value = parser->state.argv[parser->state.next++];
-		  }
-		*arg_ebadkey = 0;
-		return group_parse(group, &parser->state,
-				   option->key, value);
-	      }
-	    case ARG_SHORT_OPTION:
-	      parser->state.next++;
-	      parser->nextchar = optstart;
-	      return 0;
-
-	    default:
-	      abort();
-	    }
-	}
-    }
-}
-
-/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
-   FLAGS is one of the ARGP_ flags above.  If END_INDEX is non-NULL, the
-   index in ARGV of the first unparsed option is returned in it.  If an
-   unknown option is present, EINVAL is returned; if some parser routine
-   returned a non-zero value, it is returned; otherwise 0 is returned.  */
-error_t
-__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
-	      int *end_index, void *input)
-{
-  error_t err;
-  struct parser parser;
-
-  /* If true, then err == EBADKEY is a result of a non-option argument failing
-     to be parsed (which in some cases isn't actually an error).  */
-  int arg_ebadkey = 0;
-
-  if (! (flags & ARGP_NO_HELP))
-    /* Add our own options.  */
-    {
-      struct argp_child *child = alloca (4 * sizeof (struct argp_child));
-      struct argp *top_argp = alloca (sizeof (struct argp));
-
-      /* TOP_ARGP has no options, it just serves to group the user & default
-	 argps.  */
-      memset (top_argp, 0, sizeof (*top_argp));
-      top_argp->children = child;
-
-      memset (child, 0, 4 * sizeof (struct argp_child));
-
-      if (argp)
-	(child++)->argp = argp;
-      (child++)->argp = &argp_default_argp;
-      if (argp_program_version || argp_program_version_hook)
-	(child++)->argp = &argp_version_argp;
-      child->argp = 0;
-
-      argp = top_argp;
-    }
-
-  /* Construct a parser for these arguments.  */
-  err = parser_init (&parser, argp, argc, argv, flags, input);
-
-  if (! err)
-    /* Parse! */
-    {
-      while (! err)
-	err = parser_parse_next (&parser, &arg_ebadkey);
-      err = parser_finalize (&parser, err, arg_ebadkey, end_index);
-    }
-
-  return err;
-}
-#ifdef weak_alias
-weak_alias (__argp_parse, argp_parse)
-#endif
-
-/* Return the input field for ARGP in the parser corresponding to STATE; used
-   by the help routines.  */
-void *
-__argp_input (const struct argp *argp, const struct argp_state *state)
-{
-  if (state)
-    {
-      struct group *group;
-      struct parser *parser = state->pstate;
-
-      for (group = parser->groups; group < parser->egroup; group++)
-	if (group->argp == argp)
-	  return group->input;
-    }
-
-  return 0;
-}
-#ifdef weak_alias
-weak_alias (__argp_input, _argp_input)
-#endif
-
-/* Defined here, in case a user is not inlining the definitions in
- * argp.h */
-void
-__argp_usage (__const struct argp_state *__state)
-{
-  __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
-}
-
-int
-__option_is_short (__const struct argp_option *__opt)
-{
-  if (__opt->flags & OPTION_DOC)
-    return 0;
-  else
-    {
-      int __key = __opt->key;
-      /* FIXME: whether or not a particular key implies a short option
-       * ought not to be locale dependent. */
-      return __key > 0 && isprint (__key);
-    }
-}
-
-int
-__option_is_end (__const struct argp_option *__opt)
-{
-  return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
-}
diff --git a/contrib/argp-standalone/argp-pv.c b/contrib/argp-standalone/argp-pv.c
deleted file mode 100644
index d7d374a66bd..00000000000
--- a/contrib/argp-standalone/argp-pv.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Default definition for ARGP_PROGRAM_VERSION.
-   Copyright (C) 1996, 1997, 1999, 2004 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* If set by the user program to a non-zero value, then a default option
-   --version is added (unless the ARGP_NO_HELP flag is used), which will
-   print this this string followed by a newline and exit (unless the
-   ARGP_NO_EXIT flag is used).  Overridden by ARGP_PROGRAM_VERSION_HOOK.  */
-const char *argp_program_version = 0;
diff --git a/contrib/argp-standalone/argp-pvh.c b/contrib/argp-standalone/argp-pvh.c
deleted file mode 100644
index 829a1cda80d..00000000000
--- a/contrib/argp-standalone/argp-pvh.c
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Default definition for ARGP_PROGRAM_VERSION_HOOK.
-   Copyright (C) 1996, 1997, 1999, 2004 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "argp.h"
-
-/* If set by the user program to a non-zero value, then a default option
-   --version is added (unless the ARGP_NO_HELP flag is used), which calls
-   this function with a stream to print the version to and a pointer to the
-   current parsing state, and then exits (unless the ARGP_NO_EXIT flag is
-   used).  This variable takes precedent over ARGP_PROGRAM_VERSION.  */
-void (*argp_program_version_hook) (FILE *stream, struct argp_state *state) = 0;
diff --git a/contrib/argp-standalone/argp.h b/contrib/argp-standalone/argp.h
deleted file mode 100644
index 29d3dfe9720..00000000000
--- a/contrib/argp-standalone/argp.h
+++ /dev/null
@@ -1,602 +0,0 @@
-/* Hierarchial argument parsing.
-   Copyright (C) 1995, 96, 97, 98, 99, 2003 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Miles Bader <miles@gnu.ai.mit.edu>.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _ARGP_H
-#define _ARGP_H
-
-#include <stdio.h>
-#include <ctype.h>
-
-#define __need_error_t
-#include <errno.h>
-
-#ifndef __THROW
-# define __THROW
-#endif
-
-#ifndef __const
-# define __const const
-#endif
-
-#ifndef __error_t_defined
-typedef int error_t;
-# define __error_t_defined
-#endif
-
-/* FIXME: What's the right way to check for __restrict? Sun's cc seems
-   not to have it. Perhaps it's easiest to just delete the use of
-   __restrict from the prototypes. */
-#ifndef __restrict
-# ifndef __GNUC___
-#  define __restrict
-# endif
-#endif
-
-/* NOTE: We can't use the autoconf tests, since this is supposed to be
-   an installed header file and argp's config.h is of course not
-   installed. */
-#ifndef PRINTF_STYLE
-# if __GNUC__ >= 2
-#  define PRINTF_STYLE(f, a) __attribute__ ((__format__ (__printf__, f, a)))
-# else
-#  define PRINTF_STYLE(f, a)
-# endif
-#endif
-
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-/* A description of a particular option.  A pointer to an array of
-   these is passed in the OPTIONS field of an argp structure.  Each option
-   entry can correspond to one long option and/or one short option; more
-   names for the same option can be added by following an entry in an option
-   array with options having the OPTION_ALIAS flag set.  */
-struct argp_option
-{
-  /* The long option name.  For more than one name for the same option, you
-     can use following options with the OPTION_ALIAS flag set.  */
-  __const char *name;
-
-  /* What key is returned for this option.  If > 0 and printable, then it's
-     also accepted as a short option.  */
-  int key;
-
-  /* If non-NULL, this is the name of the argument associated with this
-     option, which is required unless the OPTION_ARG_OPTIONAL flag is set. */
-  __const char *arg;
-
-  /* OPTION_ flags.  */
-  int flags;
-
-  /* The doc string for this option.  If both NAME and KEY are 0, This string
-     will be printed outdented from the normal option column, making it
-     useful as a group header (it will be the first thing printed in its
-     group); in this usage, it's conventional to end the string with a `:'.  */
-  __const char *doc;
-
-  /* The group this option is in.  In a long help message, options are sorted
-     alphabetically within each group, and the groups presented in the order
-     0, 1, 2, ..., n, -m, ..., -2, -1.  Every entry in an options array with
-     if this field 0 will inherit the group number of the previous entry, or
-     zero if it's the first one, unless its a group header (NAME and KEY both
-     0), in which case, the previous entry + 1 is the default.  Automagic
-     options such as --help are put into group -1.  */
-  int group;
-};
-
-/* The argument associated with this option is optional.  */
-#define OPTION_ARG_OPTIONAL	0x1
-
-/* This option isn't displayed in any help messages.  */
-#define OPTION_HIDDEN	       	0x2
-
-/* This option is an alias for the closest previous non-alias option.  This
-   means that it will be displayed in the same help entry, and will inherit
-   fields other than NAME and KEY from the aliased option.  */
-#define OPTION_ALIAS		0x4
-
-/* This option isn't actually an option (and so should be ignored by the
-   actual option parser), but rather an arbitrary piece of documentation that
-   should be displayed in much the same manner as the options.  If this flag
-   is set, then the option NAME field is displayed unmodified (e.g., no `--'
-   prefix is added) at the left-margin (where a *short* option would normally
-   be displayed), and the documentation string in the normal place.  For
-   purposes of sorting, any leading whitespace and puncuation is ignored,
-   except that if the first non-whitespace character is not `-', this entry
-   is displayed after all options (and OPTION_DOC entries with a leading `-')
-   in the same group.  */
-#define OPTION_DOC		0x8
-
-/* This option shouldn't be included in `long' usage messages (but is still
-   included in help messages).  This is mainly intended for options that are
-   completely documented in an argp's ARGS_DOC field, in which case including
-   the option in the generic usage list would be redundant.  For instance,
-   if ARGS_DOC is "FOO BAR\n-x BLAH", and the `-x' option's purpose is to
-   distinguish these two cases, -x should probably be marked
-   OPTION_NO_USAGE.  */
-#define OPTION_NO_USAGE		0x10
-
-struct argp;			/* fwd declare this type */
-struct argp_state;		/* " */
-struct argp_child;		/* " */
-
-/* The type of a pointer to an argp parsing function.  */
-typedef error_t (*argp_parser_t) (int key, char *arg,
-				  struct argp_state *state);
-
-/* What to return for unrecognized keys.  For special ARGP_KEY_ keys, such
-   returns will simply be ignored.  For user keys, this error will be turned
-   into EINVAL (if the call to argp_parse is such that errors are propagated
-   back to the user instead of exiting); returning EINVAL itself would result
-   in an immediate stop to parsing in *all* cases.  */
-#define ARGP_ERR_UNKNOWN	E2BIG /* Hurd should never need E2BIG.  XXX */
-
-/* Special values for the KEY argument to an argument parsing function.
-   ARGP_ERR_UNKNOWN should be returned if they aren't understood.
-
-   The sequence of keys to a parsing function is either (where each
-   uppercased word should be prefixed by `ARGP_KEY_' and opt is a user key):
-
-       INIT opt... NO_ARGS END SUCCESS  -- No non-option arguments at all
-   or  INIT (opt | ARG)... END SUCCESS  -- All non-option args parsed
-   or  INIT (opt | ARG)... SUCCESS      -- Some non-option arg unrecognized
-
-   The third case is where every parser returned ARGP_KEY_UNKNOWN for an
-   argument, in which case parsing stops at that argument (returning the
-   unparsed arguments to the caller of argp_parse if requested, or stopping
-   with an error message if not).
-
-   If an error occurs (either detected by argp, or because the parsing
-   function returned an error value), then the parser is called with
-   ARGP_KEY_ERROR, and no further calls are made.  */
-
-/* This is not an option at all, but rather a command line argument.  If a
-   parser receiving this key returns success, the fact is recorded, and the
-   ARGP_KEY_NO_ARGS case won't be used.  HOWEVER, if while processing the
-   argument, a parser function decrements the NEXT field of the state it's
-   passed, the option won't be considered processed; this is to allow you to
-   actually modify the argument (perhaps into an option), and have it
-   processed again.  */
-#define ARGP_KEY_ARG		0
-/* There are remaining arguments not parsed by any parser, which may be found
-   starting at (STATE->argv + STATE->next).  If success is returned, but
-   STATE->next left untouched, it's assumed that all arguments were consume,
-   otherwise, the parser should adjust STATE->next to reflect any arguments
-   consumed.  */
-#define ARGP_KEY_ARGS		0x1000006
-/* There are no more command line arguments at all.  */
-#define ARGP_KEY_END		0x1000001
-/* Because it's common to want to do some special processing if there aren't
-   any non-option args, user parsers are called with this key if they didn't
-   successfully process any non-option arguments.  Called just before
-   ARGP_KEY_END (where more general validity checks on previously parsed
-   arguments can take place).  */
-#define ARGP_KEY_NO_ARGS	0x1000002
-/* Passed in before any parsing is done.  Afterwards, the values of each
-   element of the CHILD_INPUT field, if any, in the state structure is
-   copied to each child's state to be the initial value of the INPUT field.  */
-#define ARGP_KEY_INIT		0x1000003
-/* Use after all other keys, including SUCCESS & END.  */
-#define ARGP_KEY_FINI		0x1000007
-/* Passed in when parsing has successfully been completed (even if there are
-   still arguments remaining).  */
-#define ARGP_KEY_SUCCESS	0x1000004
-/* Passed in if an error occurs.  */
-#define ARGP_KEY_ERROR		0x1000005
-
-/* An argp structure contains a set of options declarations, a function to
-   deal with parsing one, documentation string, a possible vector of child
-   argp's, and perhaps a function to filter help output.  When actually
-   parsing options, getopt is called with the union of all the argp
-   structures chained together through their CHILD pointers, with conflicts
-   being resolved in favor of the first occurrence in the chain.  */
-struct argp
-{
-  /* An array of argp_option structures, terminated by an entry with both
-     NAME and KEY having a value of 0.  */
-  __const struct argp_option *options;
-
-  /* What to do with an option from this structure.  KEY is the key
-     associated with the option, and ARG is any associated argument (NULL if
-     none was supplied).  If KEY isn't understood, ARGP_ERR_UNKNOWN should be
-     returned.  If a non-zero, non-ARGP_ERR_UNKNOWN value is returned, then
-     parsing is stopped immediately, and that value is returned from
-     argp_parse().  For special (non-user-supplied) values of KEY, see the
-     ARGP_KEY_ definitions below.  */
-  argp_parser_t parser;
-
-  /* A string describing what other arguments are wanted by this program.  It
-     is only used by argp_usage to print the `Usage:' message.  If it
-     contains newlines, the strings separated by them are considered
-     alternative usage patterns, and printed on separate lines (lines after
-     the first are prefix by `  or: ' instead of `Usage:').  */
-  __const char *args_doc;
-
-  /* If non-NULL, a string containing extra text to be printed before and
-     after the options in a long help message (separated by a vertical tab
-     `\v' character).  */
-  __const char *doc;
-
-  /* A vector of argp_children structures, terminated by a member with a 0
-     argp field, pointing to child argps should be parsed with this one.  Any
-     conflicts are resolved in favor of this argp, or early argps in the
-     CHILDREN list.  This field is useful if you use libraries that supply
-     their own argp structure, which you want to use in conjunction with your
-     own.  */
-  __const struct argp_child *children;
-
-  /* If non-zero, this should be a function to filter the output of help
-     messages.  KEY is either a key from an option, in which case TEXT is
-     that option's help text, or a special key from the ARGP_KEY_HELP_
-     defines, below, describing which other help text TEXT is.  The function
-     should return either TEXT, if it should be used as-is, a replacement
-     string, which should be malloced, and will be freed by argp, or NULL,
-     meaning `print nothing'.  The value for TEXT is *after* any translation
-     has been done, so if any of the replacement text also needs translation,
-     that should be done by the filter function.  INPUT is either the input
-     supplied to argp_parse, or NULL, if argp_help was called directly.  */
-  char *(*help_filter) (int __key, __const char *__text, void *__input);
-
-  /* If non-zero the strings used in the argp library are translated using
-     the domain described by this string.  Otherwise the currently installed
-     default domain is used.  */
-  const char *argp_domain;
-};
-
-/* Possible KEY arguments to a help filter function.  */
-#define ARGP_KEY_HELP_PRE_DOC	0x2000001 /* Help text preceeding options. */
-#define ARGP_KEY_HELP_POST_DOC	0x2000002 /* Help text following options. */
-#define ARGP_KEY_HELP_HEADER	0x2000003 /* Option header string. */
-#define ARGP_KEY_HELP_EXTRA	0x2000004 /* After all other documentation;
-					     TEXT is NULL for this key.  */
-/* Explanatory note emitted when duplicate option arguments have been
-   suppressed.  */
-#define ARGP_KEY_HELP_DUP_ARGS_NOTE 0x2000005
-#define ARGP_KEY_HELP_ARGS_DOC	0x2000006 /* Argument doc string.  */
-
-/* When an argp has a non-zero CHILDREN field, it should point to a vector of
-   argp_child structures, each of which describes a subsidiary argp.  */
-struct argp_child
-{
-  /* The child parser.  */
-  __const struct argp *argp;
-
-  /* Flags for this child.  */
-  int flags;
-
-  /* If non-zero, an optional header to be printed in help output before the
-     child options.  As a side-effect, a non-zero value forces the child
-     options to be grouped together; to achieve this effect without actually
-     printing a header string, use a value of "".  */
-  __const char *header;
-
-  /* Where to group the child options relative to the other (`consolidated')
-     options in the parent argp; the values are the same as the GROUP field
-     in argp_option structs, but all child-groupings follow parent options at
-     a particular group level.  If both this field and HEADER are zero, then
-     they aren't grouped at all, but rather merged with the parent options
-     (merging the child's grouping levels with the parents).  */
-  int group;
-};
-
-/* Parsing state.  This is provided to parsing functions called by argp,
-   which may examine and, as noted, modify fields.  */
-struct argp_state
-{
-  /* The top level ARGP being parsed.  */
-  __const struct argp *root_argp;
-
-  /* The argument vector being parsed.  May be modified.  */
-  int argc;
-  char **argv;
-
-  /* The index in ARGV of the next arg that to be parsed.  May be modified. */
-  int next;
-
-  /* The flags supplied to argp_parse.  May be modified.  */
-  unsigned flags;
-
-  /* While calling a parsing function with a key of ARGP_KEY_ARG, this is the
-     number of the current arg, starting at zero, and incremented after each
-     such call returns.  At all other times, this is the number of such
-     arguments that have been processed.  */
-  unsigned arg_num;
-
-  /* If non-zero, the index in ARGV of the first argument following a special
-     `--' argument (which prevents anything following being interpreted as an
-     option).  Only set once argument parsing has proceeded past this point. */
-  int quoted;
-
-  /* An arbitrary pointer passed in from the user.  */
-  void *input;
-  /* Values to pass to child parsers.  This vector will be the same length as
-     the number of children for the current parser.  */
-  void **child_inputs;
-
-  /* For the parser's use.  Initialized to 0.  */
-  void *hook;
-
-  /* The name used when printing messages.  This is initialized to ARGV[0],
-     or PROGRAM_INVOCATION_NAME if that is unavailable.  */
-  char *name;
-
-  /* Streams used when argp prints something.  */
-  FILE *err_stream;		/* For errors; initialized to stderr. */
-  FILE *out_stream;		/* For information; initialized to stdout. */
-
-  void *pstate;			/* Private, for use by argp.  */
-};
-
-/* Flags for argp_parse (note that the defaults are those that are
-   convenient for program command line parsing): */
-
-/* Don't ignore the first element of ARGV.  Normally (and always unless
-   ARGP_NO_ERRS is set) the first element of the argument vector is
-   skipped for option parsing purposes, as it corresponds to the program name
-   in a command line.  */
-#define ARGP_PARSE_ARGV0  0x01
-
-/* Don't print error messages for unknown options to stderr; unless this flag
-   is set, ARGP_PARSE_ARGV0 is ignored, as ARGV[0] is used as the program
-   name in the error messages.  This flag implies ARGP_NO_EXIT (on the
-   assumption that silent exiting upon errors is bad behaviour).  */
-#define ARGP_NO_ERRS	0x02
-
-/* Don't parse any non-option args.  Normally non-option args are parsed by
-   calling the parse functions with a key of ARGP_KEY_ARG, and the actual arg
-   as the value.  Since it's impossible to know which parse function wants to
-   handle it, each one is called in turn, until one returns 0 or an error
-   other than ARGP_ERR_UNKNOWN; if an argument is handled by no one, the
-   argp_parse returns prematurely (but with a return value of 0).  If all
-   args have been parsed without error, all parsing functions are called one
-   last time with a key of ARGP_KEY_END.  This flag needn't normally be set,
-   as the normal behavior is to stop parsing as soon as some argument can't
-   be handled.  */
-#define ARGP_NO_ARGS	0x04
-
-/* Parse options and arguments in the same order they occur on the command
-   line -- normally they're rearranged so that all options come first. */
-#define ARGP_IN_ORDER	0x08
-
-/* Don't provide the standard long option --help, which causes usage and
-      option help information to be output to stdout, and exit (0) called. */
-#define ARGP_NO_HELP	0x10
-
-/* Don't exit on errors (they may still result in error messages).  */
-#define ARGP_NO_EXIT	0x20
-
-/* Use the gnu getopt `long-only' rules for parsing arguments.  */
-#define ARGP_LONG_ONLY	0x40
-
-/* Turns off any message-printing/exiting options.  */
-#define ARGP_SILENT    (ARGP_NO_EXIT | ARGP_NO_ERRS | ARGP_NO_HELP)
-
-/* Parse the options strings in ARGC & ARGV according to the options in ARGP.
-   FLAGS is one of the ARGP_ flags above.  If ARG_INDEX is non-NULL, the
-   index in ARGV of the first unparsed option is returned in it.  If an
-   unknown option is present, ARGP_ERR_UNKNOWN is returned; if some parser
-   routine returned a non-zero value, it is returned; otherwise 0 is
-   returned.  This function may also call exit unless the ARGP_NO_HELP flag
-   is set.  INPUT is a pointer to a value to be passed in to the parser.  */
-extern error_t argp_parse (__const struct argp *__restrict argp,
-			   int argc, char **__restrict argv,
-			   unsigned flags, int *__restrict arg_index,
-			   void *__restrict input) __THROW;
-extern error_t __argp_parse (__const struct argp *__restrict argp,
-			     int argc, char **__restrict argv,
-			     unsigned flags, int *__restrict arg_index,
-			     void *__restrict input) __THROW;
-
-/* Global variables.  */
-
-/* If defined or set by the user program to a non-zero value, then a default
-   option --version is added (unless the ARGP_NO_HELP flag is used), which
-   will print this string followed by a newline and exit (unless the
-   ARGP_NO_EXIT flag is used).  Overridden by ARGP_PROGRAM_VERSION_HOOK.  */
-extern __const char *argp_program_version;
-
-/* If defined or set by the user program to a non-zero value, then a default
-   option --version is added (unless the ARGP_NO_HELP flag is used), which
-   calls this function with a stream to print the version to and a pointer to
-   the current parsing state, and then exits (unless the ARGP_NO_EXIT flag is
-   used).  This variable takes precedent over ARGP_PROGRAM_VERSION.  */
-extern void (*argp_program_version_hook) (FILE *__restrict __stream,
-					  struct argp_state *__restrict
-					  __state);
-
-/* If defined or set by the user program, it should point to string that is
-   the bug-reporting address for the program.  It will be printed by
-   argp_help if the ARGP_HELP_BUG_ADDR flag is set (as it is by various
-   standard help messages), embedded in a sentence that says something like
-   `Report bugs to ADDR.'.  */
-extern __const char *argp_program_bug_address;
-
-/* The exit status that argp will use when exiting due to a parsing error.
-   If not defined or set by the user program, this defaults to EX_USAGE from
-   <sysexits.h>.  */
-extern error_t argp_err_exit_status;
-
-/* Flags for argp_help.  */
-#define ARGP_HELP_USAGE		0x01 /* a Usage: message. */
-#define ARGP_HELP_SHORT_USAGE	0x02 /*  " but don't actually print options. */
-#define ARGP_HELP_SEE		0x04 /* a `Try ... for more help' message. */
-#define ARGP_HELP_LONG		0x08 /* a long help message. */
-#define ARGP_HELP_PRE_DOC	0x10 /* doc string preceding long help.  */
-#define ARGP_HELP_POST_DOC	0x20 /* doc string following long help.  */
-#define ARGP_HELP_DOC		(ARGP_HELP_PRE_DOC | ARGP_HELP_POST_DOC)
-#define ARGP_HELP_BUG_ADDR	0x40 /* bug report address */
-#define ARGP_HELP_LONG_ONLY	0x80 /* modify output appropriately to
-					reflect ARGP_LONG_ONLY mode.  */
-
-/* These ARGP_HELP flags are only understood by argp_state_help.  */
-#define ARGP_HELP_EXIT_ERR	0x100 /* Call exit(1) instead of returning.  */
-#define ARGP_HELP_EXIT_OK	0x200 /* Call exit(0) instead of returning.  */
-
-/* The standard thing to do after a program command line parsing error, if an
-   error message has already been printed.  */
-#define ARGP_HELP_STD_ERR \
-  (ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)
-/* The standard thing to do after a program command line parsing error, if no
-   more specific error message has been printed.  */
-#define ARGP_HELP_STD_USAGE \
-  (ARGP_HELP_SHORT_USAGE | ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)
-/* The standard thing to do in response to a --help option.  */
-#define ARGP_HELP_STD_HELP \
-  (ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG | ARGP_HELP_EXIT_OK \
-   | ARGP_HELP_DOC | ARGP_HELP_BUG_ADDR)
-
-/* Output a usage message for ARGP to STREAM.  FLAGS are from the set
-   ARGP_HELP_*.  */
-extern void argp_help (__const struct argp *__restrict __argp,
-		       FILE *__restrict __stream,
-		       unsigned __flags, char *__restrict __name) __THROW;
-extern void __argp_help (__const struct argp *__restrict __argp,
-			 FILE *__restrict __stream, unsigned __flags,
-			 char *__name) __THROW;
-
-/* The following routines are intended to be called from within an argp
-   parsing routine (thus taking an argp_state structure as the first
-   argument).  They may or may not print an error message and exit, depending
-   on the flags in STATE -- in any case, the caller should be prepared for
-   them *not* to exit, and should return an appropiate error after calling
-   them.  [argp_usage & argp_error should probably be called argp_state_...,
-   but they're used often enough that they should be short]  */
-
-/* Output, if appropriate, a usage message for STATE to STREAM.  FLAGS are
-   from the set ARGP_HELP_*.  */
-extern void argp_state_help (__const struct argp_state *__restrict __state,
-			     FILE *__restrict __stream,
-			     unsigned int __flags) __THROW;
-extern void __argp_state_help (__const struct argp_state *__restrict __state,
-			       FILE *__restrict __stream,
-			       unsigned int __flags) __THROW;
-
-/* Possibly output the standard usage message for ARGP to stderr and exit.  */
-extern void argp_usage (__const struct argp_state *__state) __THROW;
-extern void __argp_usage (__const struct argp_state *__state) __THROW;
-
-/* If appropriate, print the printf string FMT and following args, preceded
-   by the program name and `:', to stderr, and followed by a `Try ... --help'
-   message, then exit (1).  */
-extern void argp_error (__const struct argp_state *__restrict __state,
-			__const char *__restrict __fmt, ...) __THROW
-     PRINTF_STYLE(2,3);
-extern void __argp_error (__const struct argp_state *__restrict __state,
-			  __const char *__restrict __fmt, ...) __THROW
-     PRINTF_STYLE(2,3);
-
-/* Similar to the standard gnu error-reporting function error(), but will
-   respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
-   to STATE->err_stream.  This is useful for argument parsing code that is
-   shared between program startup (when exiting is desired) and runtime
-   option parsing (when typically an error code is returned instead).  The
-   difference between this function and argp_error is that the latter is for
-   *parsing errors*, and the former is for other problems that occur during
-   parsing but don't reflect a (syntactic) problem with the input.  */
-extern void argp_failure (__const struct argp_state *__restrict __state,
-			  int __status, int __errnum,
-			  __const char *__restrict __fmt, ...) __THROW
-     PRINTF_STYLE(4,5);
-extern void __argp_failure (__const struct argp_state *__restrict __state,
-			    int __status, int __errnum,
-			    __const char *__restrict __fmt, ...) __THROW
-     PRINTF_STYLE(4,5);
-
-/* Returns true if the option OPT is a valid short option.  */
-extern int _option_is_short (__const struct argp_option *__opt) __THROW;
-extern int __option_is_short (__const struct argp_option *__opt) __THROW;
-
-/* Returns true if the option OPT is in fact the last (unused) entry in an
-   options array.  */
-extern int _option_is_end (__const struct argp_option *__opt) __THROW;
-extern int __option_is_end (__const struct argp_option *__opt) __THROW;
-
-/* Return the input field for ARGP in the parser corresponding to STATE; used
-   by the help routines.  */
-extern void *_argp_input (__const struct argp *__restrict __argp,
-			  __const struct argp_state *__restrict __state)
-     __THROW;
-extern void *__argp_input (__const struct argp *__restrict __argp,
-			   __const struct argp_state *__restrict __state)
-     __THROW;
-
-/* Used for extracting the program name from argv[0] */
-extern char *_argp_basename(char *name) __THROW;
-extern char *__argp_basename(char *name) __THROW;
-
-/* Getting the program name given an argp state */
-extern char *
-_argp_short_program_name(const struct argp_state *state) __THROW;
-extern char *
-__argp_short_program_name(const struct argp_state *state) __THROW;
-
-
-#ifdef __USE_EXTERN_INLINES
-
-# if !_LIBC
-#  define __argp_usage argp_usage
-#  define __argp_state_help argp_state_help
-#  define __option_is_short _option_is_short
-#  define __option_is_end _option_is_end
-# endif
-
-# ifndef ARGP_EI
-#  define ARGP_EI extern __inline__
-# endif
-
-ARGP_EI void
-__argp_usage (__const struct argp_state *__state)
-{
-  __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
-}
-
-ARGP_EI int
-__option_is_short (__const struct argp_option *__opt)
-{
-  if (__opt->flags & OPTION_DOC)
-    return 0;
-  else
-    {
-      int __key = __opt->key;
-      return __key > 0 && isprint (__key);
-    }
-}
-
-ARGP_EI int
-__option_is_end (__const struct argp_option *__opt)
-{
-  return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
-}
-
-# if !_LIBC
-#  undef __argp_usage
-#  undef __argp_state_help
-#  undef __option_is_short
-#  undef __option_is_end
-# endif
-#endif /* Use extern inlines.  */
-
-#ifdef  __cplusplus
-}
-#endif
-
-#endif /* argp.h */
diff --git a/contrib/argp-standalone/autogen.sh b/contrib/argp-standalone/autogen.sh
deleted file mode 100755
index 8337353b5ae..00000000000
--- a/contrib/argp-standalone/autogen.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/sh
-
-aclocal -I .
-autoheader
-autoconf
-automake --add-missing --copy --foreign
diff --git a/contrib/argp-standalone/configure.ac b/contrib/argp-standalone/configure.ac
deleted file mode 100644
index c0867eb5b35..00000000000
--- a/contrib/argp-standalone/configure.ac
+++ /dev/null
@@ -1,105 +0,0 @@
-dnl Process this file with autoconf to produce a configure script.
-
-dnl This configure.ac is only for building a standalone argp library.
-AC_INIT([argp], [standalone-1.3])
-AC_PREREQ(2.54)
-AC_CONFIG_SRCDIR([argp-ba.c])
-# Needed to stop autoconf from looking for files in parent directories.
-AC_CONFIG_AUX_DIR([.])
-
-AM_INIT_AUTOMAKE
-AC_CONFIG_HEADERS(config.h)
-
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES(yes)])
-
-# GNU libc defaults to supplying the ISO C library functions only. The
-# _GNU_SOURCE define enables these extensions, in particular we want
-# errno.h to declare program_invocation_name. Enable it on all
-# systems; no problems have been reported with it so far.
-AC_GNU_SOURCE
-
-# Checks for programs.
-AC_PROG_CC
-AC_PROG_MAKE_SET
-AC_PROG_RANLIB
-AC_PROG_CC
-
-if test "x$am_cv_prog_cc_stdc" = xno ; then
-  AC_ERROR([the C compiler doesn't handle ANSI-C])
-fi
-
-# Checks for libraries.
-
-# Checks for header files.
-AC_HEADER_STDC
-AC_CHECK_HEADERS(libintl.h limits.h malloc.h unistd.h sysexits.h stdarg.h)
-
-# Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_C_INLINE
-AC_TYPE_SIZE_T
-
-LSH_GCC_ATTRIBUTES
-
-# Checks for library functions.
-AC_FUNC_ALLOCA
-AC_FUNC_VPRINTF
-AC_CHECK_FUNCS(strerror sleep getpid snprintf)
-
-AC_REPLACE_FUNCS(mempcpy strndup strchrnul strcasecmp vsnprintf)
-
-dnl ARGP_CHECK_FUNC(includes, function-call [, if-found [, if-not-found]])
-AC_DEFUN([ARGP_CHECK_FUNC],
-  [AS_VAR_PUSHDEF([ac_func], m4_substr([$2], 0, m4_index([$2], [(])))
-   AS_VAR_PUSHDEF([ac_var], [ac_cv_func_call_]ac_func)
-   AH_TEMPLATE(AS_TR_CPP(HAVE_[]ac_func),
-               [Define to 1 if you have the `]ac_func[' function.])
-   AC_CACHE_CHECK([for $2], ac_var,
-     [AC_TRY_LINK([$1], [$2],
-                  [AS_VAR_SET(ac_var, yes)],
-                  [AS_VAR_SET(ac_var, no)])])
-   if test AS_VAR_GET(ac_var) = yes ; then
-     ifelse([$3],,
-            [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_[]ac_func))],
-            [$3
-])
-   else
-     ifelse([$4],, true, [$4])
-   fi
-   AS_VAR_POPDEF([ac_var])
-   AS_VAR_POPDEF([ac_func])
-   ])
-
-# At least on freebsd, putc_unlocked is a macro, so the standard
-# AC_CHECK_FUNCS doesn't work well.
-ARGP_CHECK_FUNC([#include <stdio.h>], [putc_unlocked('x', stdout)])
-
-AC_CHECK_FUNCS(flockfile)
-AC_CHECK_FUNCS(fputs_unlocked fwrite_unlocked)
-
-# Used only by argp-test.c, so don't use AC_REPLACE_FUNCS.
-AC_CHECK_FUNCS(strdup asprintf)
-
-AC_CHECK_DECLS([program_invocation_name, program_invocation_short_name],
-               [], [], [[#include <errno.h>]])
-
-# Set these flags *last*, or else the test programs won't compile
-if test x$GCC = xyes ; then
-  # Using -ggdb3 makes (some versions of) Redhat's gcc-2.96 dump core
-  if "$CC" --version | grep '^2\.96$' 1>/dev/null 2>&1; then
-    true
-  else
-    CFLAGS="$CFLAGS -ggdb3"
-  fi
-  CFLAGS="$CFLAGS -Wall -W \
- -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes \
- -Waggregate-return \
- -Wpointer-arith -Wbad-function-cast -Wnested-externs"
-fi
-
-CPPFLAGS="$CPPFLAGS -I$srcdir"
-
-dnl Added for C99 standards
-CFLAGS="$CFLAGS -std=gnu89 -static"
-
-AC_OUTPUT(Makefile)
diff --git a/contrib/argp-standalone/mempcpy.c b/contrib/argp-standalone/mempcpy.c
deleted file mode 100644
index 21d8bd2ed94..00000000000
--- a/contrib/argp-standalone/mempcpy.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* strndup.c
- *
- */
-
-/* Written by Niels M�ller <nisse@lysator.liu.se>
- *
- * This file is hereby placed in the public domain.
- */
-
-#include <string.h>
-
-void *
-mempcpy (void *, const void *, size_t) ;
-
-void *
-mempcpy (void *to, const void *from, size_t size)
-{
-  memcpy(to, from, size);
-  return (char *) to + size;
-}
-
diff --git a/contrib/argp-standalone/strcasecmp.c b/contrib/argp-standalone/strcasecmp.c
deleted file mode 100644
index 9c1637232fd..00000000000
--- a/contrib/argp-standalone/strcasecmp.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/* strcasecmp.c
- *
- */
-
-/* Written by Niels M�ller <nisse@lysator.liu.se>
- *
- * This file is hereby placed in the public domain.
- */
-
-#include <ctype.h>
-int strcasecmp(const char *, const char *);
-
-int strcasecmp(const char *s1, const char *s2)
-{
-  unsigned i;
-  
-  for (i = 0; s1[i] && s2[i]; i++)
-    {
-      unsigned char c1 = tolower( (unsigned char) s1[i]);
-      unsigned char c2 = tolower( (unsigned char) s2[i]);
-
-      if (c1 < c2)
-	return -1;
-      else if (c1 > c2)
-	return 1;
-    }
-
-  return !s2[i] - !s1[i];	
-}
diff --git a/contrib/argp-standalone/strchrnul.c b/contrib/argp-standalone/strchrnul.c
deleted file mode 100644
index ee4145e4eda..00000000000
--- a/contrib/argp-standalone/strchrnul.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* strchrnul.c
- *
- */
-
-/* Written by Niels M�ller <nisse@lysator.liu.se>
- *
- * This file is hereby placed in the public domain.
- */
-
-/* FIXME: What is this function supposed to do? My guess is that it is
- * like strchr, but returns a pointer to the NUL character, not a NULL
- * pointer, if the character isn't found. */
-
-char *strchrnul(const char *, int );
-
-char *strchrnul(const char *s, int c)
-{
-  const char *p = s;
-  while (*p && (*p != c))
-    p++;
-
-  return (char *) p;
-}
diff --git a/contrib/argp-standalone/strndup.c b/contrib/argp-standalone/strndup.c
deleted file mode 100644
index 4147b7a2051..00000000000
--- a/contrib/argp-standalone/strndup.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/* strndup.c
- *
- */
-
-/* Written by Niels M�ller <nisse@lysator.liu.se>
- *
- * This file is hereby placed in the public domain.
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-char *
-strndup (const char *, size_t);
-
-char *
-strndup (const char *s, size_t size)
-{
-  char *r;
-  char *end = memchr(s, 0, size);
-  
-  if (end)
-    /* Length + 1 */
-    size = end - s + 1;
-  
-  r = malloc(size);
-
-  if (size)
-    {
-      memcpy(r, s, size-1);
-      r[size-1] = '\0';
-    }
-  return r;
-}
diff --git a/contrib/argp-standalone/vsnprintf.c b/contrib/argp-standalone/vsnprintf.c
deleted file mode 100644
index 33c9a5d0042..00000000000
--- a/contrib/argp-standalone/vsnprintf.c
+++ /dev/null
@@ -1,839 +0,0 @@
-/* Copied from http://www.fiction.net/blong/programs/snprintf.c */
-
-/*
- * Copyright Patrick Powell 1995
- * This code is based on code written by Patrick Powell (papowell@astart.com)
- * It may be used for any purpose as long as this notice remains intact
- * on all source code distributions
- */
-
-/**************************************************************
- * Original:
- * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
- * A bombproof version of doprnt (dopr) included.
- * Sigh.  This sort of thing is always nasty do deal with.  Note that
- * the version here does not include floating point...
- *
- * snprintf() is used instead of sprintf() as it does limit checks
- * for string length.  This covers a nasty loophole.
- *
- * The other functions are there to prevent NULL pointers from
- * causing nast effects.
- *
- * More Recently:
- *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
- *  This was ugly.  It is still ugly.  I opted out of floating point
- *  numbers, but the formatter understands just about everything
- *  from the normal C string format, at least as far as I can tell from
- *  the Solaris 2.5 printf(3S) man page.
- *
- *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
- *    Ok, added some minimal floating point support, which means this
- *    probably requires libm on most operating systems.  Don't yet
- *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
- *    was pretty badly broken, it just wasn't being exercised in ways
- *    which showed it, so that's been fixed.  Also, formated the code
- *    to mutt conventions, and removed dead code left over from the
- *    original.  Also, there is now a builtin-test, just compile with:
- *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
- *    and run snprintf for results.
- * 
- *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
- *    The PGP code was using unsigned hexadecimal formats. 
- *    Unfortunately, unsigned formats simply didn't work.
- *
- *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
- *    The original code assumed that both snprintf() and vsnprintf() were
- *    missing.  Some systems only have snprintf() but not vsnprintf(), so
- *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
- *
- *  Andrew Tridgell (tridge@samba.org) Oct 1998
- *    fixed handling of %.0f
- *    added test for HAVE_LONG_DOUBLE
- *
- *  Russ Allbery <rra@stanford.edu> 2000-08-26
- *    fixed return value to comply with C99
- *    fixed handling of snprintf(NULL, ...)
- *
- * Niels M�ller <nisse@lysator.liu.se> 2004-03-05
- *    fixed calls to isdigit to use unsigned char.
- *    fixed calls to va_arg; short arguments are always passed as int.
- *
- **************************************************************/
-
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
-
-#include <string.h>
-#include <ctype.h>
-#include <sys/types.h>
-
-/* Define this as a fall through, HAVE_STDARG_H is probably already set */
-
-#define HAVE_VARARGS_H
-
-
-/* varargs declarations: */
-
-#if defined(HAVE_STDARG_H)
-# include <stdarg.h>
-# define HAVE_STDARGS    /* let's hope that works everywhere (mj) */
-# define VA_LOCAL_DECL   va_list ap
-# define VA_START(f)     va_start(ap, f)
-# define VA_SHIFT(v,t)  ;   /* no-op for ANSI */
-# define VA_END          va_end(ap)
-#else
-# if defined(HAVE_VARARGS_H)
-#  include <varargs.h>
-#  undef HAVE_STDARGS
-#  define VA_LOCAL_DECL   va_list ap
-#  define VA_START(f)     va_start(ap)      /* f is ignored! */
-#  define VA_SHIFT(v,t) v = va_arg(ap,t)
-#  define VA_END        va_end(ap)
-# else
-/*XX ** NO VARARGS ** XX*/
-# endif
-#endif
-
-#ifdef HAVE_LONG_DOUBLE
-#define LDOUBLE long double
-#else
-#define LDOUBLE double
-#endif
-
-int snprintf (char *str, size_t count, const char *fmt, ...);
-int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);
-
-static int dopr (char *buffer, size_t maxlen, const char *format, 
-                 va_list args);
-static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
-		   char *value, int flags, int min, int max);
-static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
-		   long value, int base, int min, int max, int flags);
-static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
-		  LDOUBLE fvalue, int min, int max, int flags);
-static int dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
-
-/*
- * dopr(): poor man's version of doprintf
- */
-
-/* format read states */
-#define DP_S_DEFAULT 0
-#define DP_S_FLAGS   1
-#define DP_S_MIN     2
-#define DP_S_DOT     3
-#define DP_S_MAX     4
-#define DP_S_MOD     5
-#define DP_S_CONV    6
-#define DP_S_DONE    7
-
-/* format flags - Bits */
-#define DP_F_MINUS 	(1 << 0)
-#define DP_F_PLUS  	(1 << 1)
-#define DP_F_SPACE 	(1 << 2)
-#define DP_F_NUM   	(1 << 3)
-#define DP_F_ZERO  	(1 << 4)
-#define DP_F_UP    	(1 << 5)
-#define DP_F_UNSIGNED 	(1 << 6)
-
-/* Conversion Flags */
-#define DP_C_SHORT   1
-#define DP_C_LONG    2
-#define DP_C_LDOUBLE 3
-
-#define char_to_int(p) (p - '0')
-#define MAX(p,q) ((p >= q) ? p : q)
-#define MIN(p,q) ((p <= q) ? p : q)
-
-static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
-{
-  unsigned char ch;
-  long value;
-  LDOUBLE fvalue;
-  char *strvalue;
-  int min;
-  int max;
-  int state;
-  int flags;
-  int cflags;
-  int total;
-  size_t currlen;
-  
-  state = DP_S_DEFAULT;
-  currlen = flags = cflags = min = 0;
-  max = -1;
-  ch = *format++;
-  total = 0;
-
-  while (state != DP_S_DONE)
-  {
-    if (ch == '\0')
-      state = DP_S_DONE;
-
-    switch(state) 
-    {
-    case DP_S_DEFAULT:
-      if (ch == '%') 
-	state = DP_S_FLAGS;
-      else 
-	total += dopr_outch (buffer, &currlen, maxlen, ch);
-      ch = *format++;
-      break;
-    case DP_S_FLAGS:
-      switch (ch) 
-      {
-      case '-':
-	flags |= DP_F_MINUS;
-        ch = *format++;
-	break;
-      case '+':
-	flags |= DP_F_PLUS;
-        ch = *format++;
-	break;
-      case ' ':
-	flags |= DP_F_SPACE;
-        ch = *format++;
-	break;
-      case '#':
-	flags |= DP_F_NUM;
-        ch = *format++;
-	break;
-      case '0':
-	flags |= DP_F_ZERO;
-        ch = *format++;
-	break;
-      default:
-	state = DP_S_MIN;
-	break;
-      }
-      break;
-    case DP_S_MIN:
-      if (isdigit(ch)) 
-      {
-	min = 10*min + char_to_int (ch);
-	ch = *format++;
-      } 
-      else if (ch == '*') 
-      {
-	min = va_arg (args, int);
-	ch = *format++;
-	state = DP_S_DOT;
-      } 
-      else 
-	state = DP_S_DOT;
-      break;
-    case DP_S_DOT:
-      if (ch == '.') 
-      {
-	state = DP_S_MAX;
-	ch = *format++;
-      } 
-      else 
-	state = DP_S_MOD;
-      break;
-    case DP_S_MAX:
-      if (isdigit(ch)) 
-      {
-	if (max < 0)
-	  max = 0;
-	max = 10*max + char_to_int (ch);
-	ch = *format++;
-      } 
-      else if (ch == '*') 
-      {
-	max = va_arg (args, int);
-	ch = *format++;
-	state = DP_S_MOD;
-      } 
-      else 
-	state = DP_S_MOD;
-      break;
-    case DP_S_MOD:
-      /* Currently, we don't support Long Long, bummer */
-      switch (ch) 
-      {
-      case 'h':
-	cflags = DP_C_SHORT;
-	ch = *format++;
-	break;
-      case 'l':
-	cflags = DP_C_LONG;
-	ch = *format++;
-	break;
-      case 'L':
-	cflags = DP_C_LDOUBLE;
-	ch = *format++;
-	break;
-      default:
-	break;
-      }
-      state = DP_S_CONV;
-      break;
-    case DP_S_CONV:
-      switch (ch) 
-      {
-      case 'd':
-      case 'i':
-	if (cflags == DP_C_SHORT) 
-	  value = (short) va_arg (args, int);
-	else if (cflags == DP_C_LONG)
-	  value = va_arg (args, long int);
-	else
-	  value = va_arg (args, int);
-	total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
-	break;
-      case 'o':
-	flags |= DP_F_UNSIGNED;
-	if (cflags == DP_C_SHORT)
-	  value = (unsigned short) va_arg (args, unsigned);
-	else if (cflags == DP_C_LONG)
-	  value = va_arg (args, unsigned long int);
-	else
-	  value = va_arg (args, unsigned int);
-	total += fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
-	break;
-      case 'u':
-	flags |= DP_F_UNSIGNED;
-	if (cflags == DP_C_SHORT)
-	  value = (unsigned short) va_arg (args, unsigned);
-	else if (cflags == DP_C_LONG)
-	  value = va_arg (args, unsigned long int);
-	else
-	  value = va_arg (args, unsigned int);
-	total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
-	break;
-      case 'X':
-	flags |= DP_F_UP;
-      case 'x':
-	flags |= DP_F_UNSIGNED;
-	if (cflags == DP_C_SHORT)
-	  value = (unsigned short) va_arg (args, unsigned);
-	else if (cflags == DP_C_LONG)
-	  value = va_arg (args, unsigned long int);
-	else
-	  value = va_arg (args, unsigned int);
-	total += fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
-	break;
-      case 'f':
-	if (cflags == DP_C_LDOUBLE)
-	  fvalue = va_arg (args, LDOUBLE);
-	else
-	  fvalue = va_arg (args, double);
-	/* um, floating point? */
-	total += fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
-	break;
-      case 'E':
-	flags |= DP_F_UP;
-      case 'e':
-	if (cflags == DP_C_LDOUBLE)
-	  fvalue = va_arg (args, LDOUBLE);
-	else
-	  fvalue = va_arg (args, double);
-	break;
-      case 'G':
-	flags |= DP_F_UP;
-      case 'g':
-	if (cflags == DP_C_LDOUBLE)
-	  fvalue = va_arg (args, LDOUBLE);
-	else
-	  fvalue = va_arg (args, double);
-	break;
-      case 'c':
-	total += dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
-	break;
-      case 's':
-	strvalue = va_arg (args, char *);
-	total += fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
-	break;
-      case 'p':
-	strvalue = va_arg (args, void *);
-	total += fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min,
-                         max, flags);
-	break;
-      case 'n':
-	if (cflags == DP_C_SHORT) 
-	{
-	  short int *num;
-	  num = va_arg (args, short int *);
-	  *num = currlen;
-        } 
-	else if (cflags == DP_C_LONG) 
-	{
-	  long int *num;
-	  num = va_arg (args, long int *);
-	  *num = currlen;
-        } 
-	else 
-	{
-	  int *num;
-	  num = va_arg (args, int *);
-	  *num = currlen;
-        }
-	break;
-      case '%':
-	total += dopr_outch (buffer, &currlen, maxlen, ch);
-	break;
-      case 'w':
-	/* not supported yet, treat as next char */
-	ch = *format++;
-	break;
-      default:
-	/* Unknown, skip */
-	break;
-      }
-      ch = *format++;
-      state = DP_S_DEFAULT;
-      flags = cflags = min = 0;
-      max = -1;
-      break;
-    case DP_S_DONE:
-      break;
-    default:
-      /* hmm? */
-      break; /* some picky compilers need this */
-    }
-  }
-  if (buffer != NULL)
-  {
-    if (currlen < maxlen - 1) 
-      buffer[currlen] = '\0';
-    else 
-      buffer[maxlen - 1] = '\0';
-  }
-  return total;
-}
-
-static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
-                   char *value, int flags, int min, int max)
-{
-  int padlen, strln;     /* amount to pad */
-  int cnt = 0;
-  int total = 0;
-  
-  if (value == 0)
-  {
-    value = "<NULL>";
-  }
-
-  for (strln = 0; value[strln]; ++strln); /* strlen */
-  if (max >= 0 && max < strln)
-    strln = max;
-  padlen = min - strln;
-  if (padlen < 0) 
-    padlen = 0;
-  if (flags & DP_F_MINUS) 
-    padlen = -padlen; /* Left Justify */
-
-  while (padlen > 0)
-  {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    --padlen;
-  }
-  while (*value && ((max < 0) || (cnt < max)))
-  {
-    total += dopr_outch (buffer, currlen, maxlen, *value++);
-    ++cnt;
-  }
-  while (padlen < 0)
-  {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    ++padlen;
-  }
-  return total;
-}
-
-/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
-
-static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
-		   long value, int base, int min, int max, int flags)
-{
-  int signvalue = 0;
-  unsigned long uvalue;
-  char convert[20];
-  int place = 0;
-  int spadlen = 0; /* amount to space pad */
-  int zpadlen = 0; /* amount to zero pad */
-  int caps = 0;
-  int total = 0;
-  
-  if (max < 0)
-    max = 0;
-
-  uvalue = value;
-
-  if(!(flags & DP_F_UNSIGNED))
-  {
-    if( value < 0 ) {
-      signvalue = '-';
-      uvalue = -value;
-    }
-    else
-      if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
-	signvalue = '+';
-    else
-      if (flags & DP_F_SPACE)
-	signvalue = ' ';
-  }
-  
-  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
-
-  do {
-    convert[place++] =
-      (caps? "0123456789ABCDEF":"0123456789abcdef")
-      [uvalue % (unsigned)base  ];
-    uvalue = (uvalue / (unsigned)base );
-  } while(uvalue && (place < 20));
-  if (place == 20) place--;
-  convert[place] = 0;
-
-  zpadlen = max - place;
-  spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
-  if (zpadlen < 0) zpadlen = 0;
-  if (spadlen < 0) spadlen = 0;
-  if (flags & DP_F_ZERO)
-  {
-    zpadlen = MAX(zpadlen, spadlen);
-    spadlen = 0;
-  }
-  if (flags & DP_F_MINUS) 
-    spadlen = -spadlen; /* Left Justifty */
-
-#ifdef DEBUG_SNPRINTF
-  dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
-      zpadlen, spadlen, min, max, place));
-#endif
-
-  /* Spaces */
-  while (spadlen > 0) 
-  {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    --spadlen;
-  }
-
-  /* Sign */
-  if (signvalue) 
-    total += dopr_outch (buffer, currlen, maxlen, signvalue);
-
-  /* Zeros */
-  if (zpadlen > 0) 
-  {
-    while (zpadlen > 0)
-    {
-      total += dopr_outch (buffer, currlen, maxlen, '0');
-      --zpadlen;
-    }
-  }
-
-  /* Digits */
-  while (place > 0) 
-    total += dopr_outch (buffer, currlen, maxlen, convert[--place]);
-  
-  /* Left Justified spaces */
-  while (spadlen < 0) {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    ++spadlen;
-  }
-
-  return total;
-}
-
-static LDOUBLE abs_val (LDOUBLE value)
-{
-  LDOUBLE result = value;
-
-  if (value < 0)
-    result = -value;
-
-  return result;
-}
-
-static LDOUBLE pow10_argp (int exp)
-{
-  LDOUBLE result = 1;
-
-  while (exp)
-  {
-    result *= 10;
-    exp--;
-  }
-  
-  return result;
-}
-
-static long round_argp (LDOUBLE value)
-{
-  long intpart;
-
-  intpart = value;
-  value = value - intpart;
-  if (value >= 0.5)
-    intpart++;
-
-  return intpart;
-}
-
-static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
-		  LDOUBLE fvalue, int min, int max, int flags)
-{
-  int signvalue = 0;
-  LDOUBLE ufvalue;
-  char iconvert[20];
-  char fconvert[20];
-  int iplace = 0;
-  int fplace = 0;
-  int padlen = 0; /* amount to pad */
-  int zpadlen = 0; 
-  int caps = 0;
-  int total = 0;
-  long intpart;
-  long fracpart;
-  
-  /* 
-   * AIX manpage says the default is 0, but Solaris says the default
-   * is 6, and sprintf on AIX defaults to 6
-   */
-  if (max < 0)
-    max = 6;
-
-  ufvalue = abs_val (fvalue);
-
-  if (fvalue < 0)
-    signvalue = '-';
-  else
-    if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
-      signvalue = '+';
-    else
-      if (flags & DP_F_SPACE)
-	signvalue = ' ';
-
-#if 0
-  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
-#endif
-
-  intpart = ufvalue;
-
-  /* 
-   * Sorry, we only support 9 digits past the decimal because of our 
-   * conversion method
-   */
-  if (max > 9)
-    max = 9;
-
-  /* We "cheat" by converting the fractional part to integer by
-   * multiplying by a factor of 10
-   */
-  fracpart = round_argp ((pow10_argp (max)) * (ufvalue - intpart));
-
-  if (fracpart >= pow10_argp (max))
-  {
-    intpart++;
-    fracpart -= pow10_argp (max);
-  }
-
-#ifdef DEBUG_SNPRINTF
-  dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
-#endif
-
-  /* Convert integer part */
-  do {
-    iconvert[iplace++] =
-      (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
-    intpart = (intpart / 10);
-  } while(intpart && (iplace < 20));
-  if (iplace == 20) iplace--;
-  iconvert[iplace] = 0;
-
-  /* Convert fractional part */
-  do {
-    fconvert[fplace++] =
-      (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
-    fracpart = (fracpart / 10);
-  } while(fracpart && (fplace < 20));
-  if (fplace == 20) fplace--;
-  fconvert[fplace] = 0;
-
-  /* -1 for decimal point, another -1 if we are printing a sign */
-  padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
-  zpadlen = max - fplace;
-  if (zpadlen < 0)
-    zpadlen = 0;
-  if (padlen < 0) 
-    padlen = 0;
-  if (flags & DP_F_MINUS) 
-    padlen = -padlen; /* Left Justifty */
-
-  if ((flags & DP_F_ZERO) && (padlen > 0)) 
-  {
-    if (signvalue) 
-    {
-      total += dopr_outch (buffer, currlen, maxlen, signvalue);
-      --padlen;
-      signvalue = 0;
-    }
-    while (padlen > 0)
-    {
-      total += dopr_outch (buffer, currlen, maxlen, '0');
-      --padlen;
-    }
-  }
-  while (padlen > 0)
-  {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    --padlen;
-  }
-  if (signvalue) 
-    total += dopr_outch (buffer, currlen, maxlen, signvalue);
-
-  while (iplace > 0) 
-    total += dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
-
-  /*
-   * Decimal point.  This should probably use locale to find the correct
-   * char to print out.
-   */
-  if (max > 0)
-  {
-    total += dopr_outch (buffer, currlen, maxlen, '.');
-
-    while (fplace > 0) 
-      total += dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
-  }
-
-  while (zpadlen > 0)
-  {
-    total += dopr_outch (buffer, currlen, maxlen, '0');
-    --zpadlen;
-  }
-
-  while (padlen < 0) 
-  {
-    total += dopr_outch (buffer, currlen, maxlen, ' ');
-    ++padlen;
-  }
-
-  return total;
-}
-
-static int dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
-{
-  if (*currlen + 1 < maxlen)
-    buffer[(*currlen)++] = c;
-  return 1;
-}
-
-#ifndef HAVE_VSNPRINTF
-int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
-{
-  if (str != NULL)
-    str[0] = 0;
-  return dopr(str, count, fmt, args);
-}
-#endif /* !HAVE_VSNPRINTF */
-
-#ifndef HAVE_SNPRINTF
-/* VARARGS3 */
-#ifdef HAVE_STDARGS
-int snprintf (char *str,size_t count,const char *fmt,...)
-#else
-int snprintf (va_alist) va_dcl
-#endif
-{
-#ifndef HAVE_STDARGS
-  char *str;
-  size_t count;
-  char *fmt;
-#endif
-  VA_LOCAL_DECL;
-  int total;
-    
-  VA_START (fmt);
-  VA_SHIFT (str, char *);
-  VA_SHIFT (count, size_t );
-  VA_SHIFT (fmt, char *);
-  total = vsnprintf(str, count, fmt, ap);
-  VA_END;
-  return total;
-}
-#endif /* !HAVE_SNPRINTF */
-
-#ifdef TEST_SNPRINTF
-#ifndef LONG_STRING
-#define LONG_STRING 1024
-#endif
-int main (void)
-{
-  char buf1[LONG_STRING];
-  char buf2[LONG_STRING];
-  char *fp_fmt[] = {
-    "%-1.5f",
-    "%1.5f",
-    "%123.9f",
-    "%10.5f",
-    "% 10.5f",
-    "%+22.9f",
-    "%+4.9f",
-    "%01.3f",
-    "%4f",
-    "%3.1f",
-    "%3.2f",
-    "%.0f",
-    "%.1f",
-    NULL
-  };
-  double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
-    0.9996, 1.996, 4.136, 0};
-  char *int_fmt[] = {
-    "%-1.5d",
-    "%1.5d",
-    "%123.9d",
-    "%5.5d",
-    "%10.5d",
-    "% 10.5d",
-    "%+22.33d",
-    "%01.3d",
-    "%4d",
-    NULL
-  };
-  long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
-  int x, y;
-  int fail = 0;
-  int num = 0;
-
-  printf ("Testing snprintf format codes against system sprintf...\n");
-
-  for (x = 0; fp_fmt[x] != NULL ; x++)
-    for (y = 0; fp_nums[y] != 0 ; y++)
-    {
-      snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
-      sprintf (buf2, fp_fmt[x], fp_nums[y]);
-      if (strcmp (buf1, buf2))
-      {
-	printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
-	    fp_fmt[x], buf1, buf2);
-	fail++;
-      }
-      num++;
-    }
-
-  for (x = 0; int_fmt[x] != NULL ; x++)
-    for (y = 0; int_nums[y] != 0 ; y++)
-    {
-      snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
-      sprintf (buf2, int_fmt[x], int_nums[y]);
-      if (strcmp (buf1, buf2))
-      {
-	printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
-	    int_fmt[x], buf1, buf2);
-	fail++;
-      }
-      num++;
-    }
-  printf ("%d tests failed out of %d.\n", fail, num);
-}
-#endif /* SNPRINTF_TEST */
-
-#endif /* !HAVE_SNPRINTF */
diff --git a/contrib/fuse-lib/misc.c b/contrib/fuse-lib/misc.c
index 0c41b1a1917..1a9b418e511 100644
--- a/contrib/fuse-lib/misc.c
+++ b/contrib/fuse-lib/misc.c
@@ -10,7 +10,7 @@
 #include <string.h>
 #include <limits.h>
 #include <fcntl.h>
-#include "glusterfs.h"
+#include "glusterfs/glusterfs.h"
 #include "fuse_kernel.h"
 #include "fuse-misc.h"
 
@@ -41,7 +41,6 @@ void
 convert_fuse_file_lock (struct fuse_file_lock *fl, struct gf_flock *flock,
                         uint64_t lk_owner)
 {
-        memset (flock, 0, sizeof (struct flock));
         flock->l_type = fl->type;
         flock->l_whence = SEEK_SET;
         flock->l_start = fl->start;
diff --git a/contrib/fuse-lib/mount-common.c b/contrib/fuse-lib/mount-common.c
index e9f80fe8154..cffd4c01ed5 100644
--- a/contrib/fuse-lib/mount-common.c
+++ b/contrib/fuse-lib/mount-common.c
@@ -32,7 +32,7 @@ mtab_needs_update (const char *mnt)
         struct stat stbuf;
 
         /* If mtab is within new mount, don't touch it */
-        if (strncmp (mnt, _PATH_MOUNTED, strlen (mnt)) == 0 &&
+        if (strncmp (mnt, _PATH_MOUNTED, sizeof (_PATH_MOUNTED) - 1) == 0 &&
             _PATH_MOUNTED[strlen (mnt)] == '/')
                 return 0;
 
@@ -255,16 +255,16 @@ fuse_mnt_umount (const char *progname, const char *abs_mnt,
                         exit (1);
                 }
 #ifdef GF_LINUX_HOST_OS
-                execl ("/bin/umount", "/bin/umount", "-i", rel_mnt,
+                execl ("umount", "umount", "-i", rel_mnt,
                        lazy ? "-l" : NULL, NULL);
-                GFFUSE_LOGERR ("%s: failed to execute /bin/umount: %s",
+                GFFUSE_LOGERR ("%s: failed to execute umount: %s",
                                progname, strerror (errno));
 #elif __NetBSD__
                 /* exitting the filesystem causes the umount */
                 exit (0);
 #else
-                execl ("/sbin/umount", "/sbin/umount", "-f", rel_mnt, NULL);
-                GFFUSE_LOGERR ("%s: failed to execute /sbin/umount: %s",
+                execl ("umount", "umount", "-f", rel_mnt, NULL);
+                GFFUSE_LOGERR ("%s: failed to execute umount: %s",
                                progname, strerror (errno));
 #endif /* GF_LINUX_HOST_OS */
                 exit (1);
diff --git a/contrib/fuse-lib/mount-gluster-compat.h b/contrib/fuse-lib/mount-gluster-compat.h
index a16103e0fbb..d3646d08d8e 100644
--- a/contrib/fuse-lib/mount-gluster-compat.h
+++ b/contrib/fuse-lib/mount-gluster-compat.h
@@ -96,9 +96,9 @@ typedef long long mount_flag_t;
 #define FREE(ptr) free (ptr)
 #define GFFUSE_LOGERR(...) fprintf (stderr, ## __VA_ARGS__)
 #else /* FUSE_UTIL */
-#include "glusterfs.h"
-#include "logging.h"
-#include "common-utils.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/common-utils.h"
 
 #define GFFUSE_LOGERR(...) \
         gf_log ("glusterfs-fuse", GF_LOG_ERROR, ## __VA_ARGS__)
diff --git a/contrib/fuse-lib/mount.c b/contrib/fuse-lib/mount.c
index 05d04b769e5..06ff191f542 100644
--- a/contrib/fuse-lib/mount.c
+++ b/contrib/fuse-lib/mount.c
@@ -52,12 +52,16 @@ gf_fuse_unmount (const char *mountpoint, int fd)
         if (geteuid () == 0) {
                 fuse_mnt_umount ("fuse", mountpoint, mountpoint, 1);
                 return;
+        } else {
+            GFFUSE_LOGERR ("fuse: Effective-uid: %d", geteuid());
         }
 
         res = umount2 (mountpoint, 2);
         if (res == 0)
                 return;
 
+        GFFUSE_LOGERR ("fuse: failed to unmount %s: %s",
+                       mountpoint, strerror (errno));
         pid = fork ();
         if (pid == -1)
                 return;
@@ -67,6 +71,8 @@ gf_fuse_unmount (const char *mountpoint, int fd)
                                        "--", mountpoint, NULL };
 
                 execvp (FUSERMOUNT_PROG, (char **)argv);
+                GFFUSE_LOGERR ("fuse: failed to execute fuserumount: %s",
+                               strerror (errno));
                 _exit (1);
         }
         waitpid (pid, NULL, 0);
@@ -95,14 +101,15 @@ gf_fuse_unmount_daemon (const char *mountpoint, int fd)
 
         pid = fork ();
         switch (pid) {
+        case 0:
+        {
                 char c = 0;
                 sigset_t sigset;
-        case 0:
 
                 close_fds_except (ump, 1);
 
                 setsid();
-                chdir("/");
+                (void)chdir("/");
                 sigfillset(&sigset);
                 sigprocmask(SIG_BLOCK, &sigset, NULL);
 
@@ -110,6 +117,7 @@ gf_fuse_unmount_daemon (const char *mountpoint, int fd)
 
                 gf_fuse_unmount (mountpoint, fd);
                 exit (0);
+        }
         case -1:
                 close (fd);
                 fd = -1;
@@ -382,6 +390,7 @@ fuse_mount_sys (const char *mountpoint, char *fsname,
         build_iovec (&iov, &iovlen, "from", "/dev/fuse", -1);
         build_iovec (&iov, &iovlen, "volname", source, -1);
         build_iovec (&iov, &iovlen, "fd", fdstr, -1);
+        build_iovec (&iov, &iovlen, "allow_other", NULL, -1);
         ret = nmount (iov, iovlen, mountflags);
 #else
         ret = mount (source, mountpoint, fstype, mountflags,
diff --git a/contrib/fuse-util/fusermount.c b/contrib/fuse-util/fusermount.c
index a64d8e102ff..ff743f75a21 100644
--- a/contrib/fuse-util/fusermount.c
+++ b/contrib/fuse-util/fusermount.c
@@ -520,20 +520,22 @@ static void parse_line(char *line, int linenum)
 
 static void read_conf(void)
 {
+	int  len;
 	FILE *fp = fopen(FUSE_CONF, "r");
 	if (fp != NULL) {
 		int linenum = 1;
 		char line[256];
 		int isnewline = 1;
 		while (fgets(line, sizeof(line), fp) != NULL) {
+			len = strlen (line);
 			if (isnewline) {
-				if (strlen(line) && line[strlen(line)-1] == '\n') {
+				if (len && line[len-1] == '\n') {
 					strip_line(line);
 					parse_line(line, linenum);
 				} else {
 					isnewline = 0;
 				}
-			} else if(strlen(line) && line[strlen(line)-1] == '\n') {
+			} else if (len && line[len-1] == '\n') {
 				fprintf(stderr, "%s: reading %s: line %i too long\n", progname, FUSE_CONF, linenum);
 
 				isnewline = 1;
diff --git a/contrib/ipaddr-py/COPYING b/contrib/ipaddr-py/COPYING
deleted file mode 100644
index d6456956733..00000000000
--- a/contrib/ipaddr-py/COPYING
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/contrib/ipaddr-py/MANIFEST.in b/contrib/ipaddr-py/MANIFEST.in
deleted file mode 100644
index f572804441b..00000000000
--- a/contrib/ipaddr-py/MANIFEST.in
+++ /dev/null
@@ -1,3 +0,0 @@
-include COPYING
-include ipaddr_test.py
-include RELEASENOTES
diff --git a/contrib/ipaddr-py/OWNERS b/contrib/ipaddr-py/OWNERS
deleted file mode 100644
index 501673e0395..00000000000
--- a/contrib/ipaddr-py/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-pmoody
-harro
-mshields
-smart
diff --git a/contrib/ipaddr-py/README b/contrib/ipaddr-py/README
deleted file mode 100644
index 1b54294bb10..00000000000
--- a/contrib/ipaddr-py/README
+++ /dev/null
@@ -1,8 +0,0 @@
-ipaddr.py is a library for working with IP addresses, both IPv4 and IPv6.
-It was developed by Google for internal use, and is now open source.
-
-Project home page: http://code.google.com/p/ipaddr-py/
-
-Please send contributions to ipaddr-py-dev@googlegroups.com.  Code should
-include unit tests and follow the Google Python style guide:
-http://code.google.com/p/soc/wiki/PythonStyleGuide
diff --git a/contrib/ipaddr-py/ipaddr.py b/contrib/ipaddr-py/ipaddr.py
deleted file mode 100644
index a89298a315d..00000000000
--- a/contrib/ipaddr-py/ipaddr.py
+++ /dev/null
@@ -1,1907 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2007 Google Inc.
-#  Licensed to PSF under a Contributor Agreement.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# permissions and limitations under the License.
-
-"""A fast, lightweight IPv4/IPv6 manipulation library in Python.
-
-This library is used to create/poke/manipulate IPv4 and IPv6 addresses
-and networks.
-
-"""
-
-__version__ = 'trunk'
-
-import struct
-
-IPV4LENGTH = 32
-IPV6LENGTH = 128
-
-
-class AddressValueError(ValueError):
-    """A Value Error related to the address."""
-
-
-class NetmaskValueError(ValueError):
-    """A Value Error related to the netmask."""
-
-
-def IPAddress(address, version=None):
-    """Take an IP string/int and return an object of the correct type.
-
-    Args:
-        address: A string or integer, the IP address.  Either IPv4 or
-          IPv6 addresses may be supplied; integers less than 2**32 will
-          be considered to be IPv4 by default.
-        version: An Integer, 4 or 6. If set, don't try to automatically
-          determine what the IP address type is. important for things
-          like IPAddress(1), which could be IPv4, '0.0.0.1',  or IPv6,
-          '::1'.
-
-    Returns:
-        An IPv4Address or IPv6Address object.
-
-    Raises:
-        ValueError: if the string passed isn't either a v4 or a v6
-          address.
-
-    """
-    if version:
-        if version == 4:
-            return IPv4Address(address)
-        elif version == 6:
-            return IPv6Address(address)
-
-    try:
-        return IPv4Address(address)
-    except (AddressValueError, NetmaskValueError):
-        pass
-
-    try:
-        return IPv6Address(address)
-    except (AddressValueError, NetmaskValueError):
-        pass
-
-    raise ValueError('%r does not appear to be an IPv4 or IPv6 address' %
-                     address)
-
-
-def IPNetwork(address, version=None, strict=False):
-    """Take an IP string/int and return an object of the correct type.
-
-    Args:
-        address: A string or integer, the IP address.  Either IPv4 or
-          IPv6 addresses may be supplied; integers less than 2**32 will
-          be considered to be IPv4 by default.
-        version: An Integer, if set, don't try to automatically
-          determine what the IP address type is. important for things
-          like IPNetwork(1), which could be IPv4, '0.0.0.1/32', or IPv6,
-          '::1/128'.
-
-    Returns:
-        An IPv4Network or IPv6Network object.
-
-    Raises:
-        ValueError: if the string passed isn't either a v4 or a v6
-          address. Or if a strict network was requested and a strict
-          network wasn't given.
-
-    """
-    if version:
-        if version == 4:
-            return IPv4Network(address, strict)
-        elif version == 6:
-            return IPv6Network(address, strict)
-
-    try:
-        return IPv4Network(address, strict)
-    except (AddressValueError, NetmaskValueError):
-        pass
-
-    try:
-        return IPv6Network(address, strict)
-    except (AddressValueError, NetmaskValueError):
-        pass
-
-    raise ValueError('%r does not appear to be an IPv4 or IPv6 network' %
-                     address)
-
-
-def v4_int_to_packed(address):
-    """The binary representation of this address.
-
-    Args:
-        address: An integer representation of an IPv4 IP address.
-
-    Returns:
-        The binary representation of this address.
-
-    Raises:
-        ValueError: If the integer is too large to be an IPv4 IP
-          address.
-    """
-    if address > _BaseV4._ALL_ONES:
-        raise ValueError('Address too large for IPv4')
-    return struct.pack('!I', address)
-
-
-def v6_int_to_packed(address):
-    """The binary representation of this address.
-
-    Args:
-        address: An integer representation of an IPv4 IP address.
-
-    Returns:
-        The binary representation of this address.
-    """
-    return struct.pack('!QQ', address >> 64, address & (2**64 - 1))
-
-
-def _find_address_range(addresses):
-    """Find a sequence of addresses.
-
-    Args:
-        addresses: a list of IPv4 or IPv6 addresses.
-
-    Returns:
-        A tuple containing the first and last IP addresses in the sequence.
-
-    """
-    first = last = addresses[0]
-    for ip in addresses[1:]:
-        if ip._ip == last._ip + 1:
-            last = ip
-        else:
-            break
-    return (first, last)
-
-def _get_prefix_length(number1, number2, bits):
-    """Get the number of leading bits that are same for two numbers.
-
-    Args:
-        number1: an integer.
-        number2: another integer.
-        bits: the maximum number of bits to compare.
-
-    Returns:
-        The number of leading bits that are the same for two numbers.
-
-    """
-    for i in range(bits):
-        if number1 >> i == number2 >> i:
-            return bits - i
-    return 0
-
-def _count_righthand_zero_bits(number, bits):
-    """Count the number of zero bits on the right hand side.
-
-    Args:
-        number: an integer.
-        bits: maximum number of bits to count.
-
-    Returns:
-        The number of zero bits on the right hand side of the number.
-
-    """
-    if number == 0:
-        return bits
-    for i in range(bits):
-        if (number >> i) % 2:
-            return i
-
-def summarize_address_range(first, last):
-    """Summarize a network range given the first and last IP addresses.
-
-    Example:
-        >>> summarize_address_range(IPv4Address('1.1.1.0'),
-            IPv4Address('1.1.1.130'))
-        [IPv4Network('1.1.1.0/25'), IPv4Network('1.1.1.128/31'),
-        IPv4Network('1.1.1.130/32')]
-
-    Args:
-        first: the first IPv4Address or IPv6Address in the range.
-        last: the last IPv4Address or IPv6Address in the range.
-
-    Returns:
-        The address range collapsed to a list of IPv4Network's or
-        IPv6Network's.
-
-    Raise:
-        TypeError:
-            If the first and last objects are not IP addresses.
-            If the first and last objects are not the same version.
-        ValueError:
-            If the last object is not greater than the first.
-            If the version is not 4 or 6.
-
-    """
-    if not (isinstance(first, _BaseIP) and isinstance(last, _BaseIP)):
-        raise TypeError('first and last must be IP addresses, not networks')
-    if first.version != last.version:
-        raise TypeError("%s and %s are not of the same version" % (
-                str(first), str(last)))
-    if first > last:
-        raise ValueError('last IP address must be greater than first')
-
-    networks = []
-
-    if first.version == 4:
-        ip = IPv4Network
-    elif first.version == 6:
-        ip = IPv6Network
-    else:
-        raise ValueError('unknown IP version')
-
-    ip_bits = first._max_prefixlen
-    first_int = first._ip
-    last_int = last._ip
-    while first_int <= last_int:
-        nbits = _count_righthand_zero_bits(first_int, ip_bits)
-        current = None
-        while nbits >= 0:
-            addend = 2**nbits - 1
-            current = first_int + addend
-            nbits -= 1
-            if current <= last_int:
-                break
-        prefix = _get_prefix_length(first_int, current, ip_bits)
-        net = ip('%s/%d' % (str(first), prefix))
-        networks.append(net)
-        if current == ip._ALL_ONES:
-            break
-        first_int = current + 1
-        first = IPAddress(first_int, version=first._version)
-    return networks
-
-def _collapse_address_list_recursive(addresses):
-    """Loops through the addresses, collapsing concurrent netblocks.
-
-    Example:
-
-        ip1 = IPv4Network('1.1.0.0/24')
-        ip2 = IPv4Network('1.1.1.0/24')
-        ip3 = IPv4Network('1.1.2.0/24')
-        ip4 = IPv4Network('1.1.3.0/24')
-        ip5 = IPv4Network('1.1.4.0/24')
-        ip6 = IPv4Network('1.1.0.1/22')
-
-        _collapse_address_list_recursive([ip1, ip2, ip3, ip4, ip5, ip6]) ->
-          [IPv4Network('1.1.0.0/22'), IPv4Network('1.1.4.0/24')]
-
-        This shouldn't be called directly; it is called via
-          collapse_address_list([]).
-
-    Args:
-        addresses: A list of IPv4Network's or IPv6Network's
-
-    Returns:
-        A list of IPv4Network's or IPv6Network's depending on what we were
-        passed.
-
-    """
-    ret_array = []
-    optimized = False
-
-    for cur_addr in addresses:
-        if not ret_array:
-            ret_array.append(cur_addr)
-            continue
-        if cur_addr in ret_array[-1]:
-            optimized = True
-        elif cur_addr == ret_array[-1].supernet().subnet()[1]:
-            ret_array.append(ret_array.pop().supernet())
-            optimized = True
-        else:
-            ret_array.append(cur_addr)
-
-    if optimized:
-        return _collapse_address_list_recursive(ret_array)
-
-    return ret_array
-
-
-def collapse_address_list(addresses):
-    """Collapse a list of IP objects.
-
-    Example:
-        collapse_address_list([IPv4('1.1.0.0/24'), IPv4('1.1.1.0/24')]) ->
-          [IPv4('1.1.0.0/23')]
-
-    Args:
-        addresses: A list of IPv4Network or IPv6Network objects.
-
-    Returns:
-        A list of IPv4Network or IPv6Network objects depending on what we
-        were passed.
-
-    Raises:
-        TypeError: If passed a list of mixed version objects.
-
-    """
-    i = 0
-    addrs = []
-    ips = []
-    nets = []
-
-    # split IP addresses and networks
-    for ip in addresses:
-        if isinstance(ip, _BaseIP):
-            if ips and ips[-1]._version != ip._version:
-                raise TypeError("%s and %s are not of the same version" % (
-                        str(ip), str(ips[-1])))
-            ips.append(ip)
-        elif ip._prefixlen == ip._max_prefixlen:
-            if ips and ips[-1]._version != ip._version:
-                raise TypeError("%s and %s are not of the same version" % (
-                        str(ip), str(ips[-1])))
-            ips.append(ip.ip)
-        else:
-            if nets and nets[-1]._version != ip._version:
-                raise TypeError("%s and %s are not of the same version" % (
-                        str(ip), str(ips[-1])))
-            nets.append(ip)
-
-    # sort and dedup
-    ips = sorted(set(ips))
-    nets = sorted(set(nets))
-
-    while i < len(ips):
-        (first, last) = _find_address_range(ips[i:])
-        i = ips.index(last) + 1
-        addrs.extend(summarize_address_range(first, last))
-
-    return _collapse_address_list_recursive(sorted(
-        addrs + nets, key=_BaseNet._get_networks_key))
-
-# backwards compatibility
-CollapseAddrList = collapse_address_list
-
-# Test whether this Python implementation supports byte objects that
-# are not identical to str ones.
-# We need to exclude platforms where bytes == str so that we can
-# distinguish between packed representations and strings, for example
-# b'12::' (the IPv4 address 49.50.58.58) and '12::' (an IPv6 address).
-try:
-    _compat_has_real_bytes = bytes is not str
-except NameError: # <Python2.6
-    _compat_has_real_bytes = False
-
-def get_mixed_type_key(obj):
-    """Return a key suitable for sorting between networks and addresses.
-
-    Address and Network objects are not sortable by default; they're
-    fundamentally different so the expression
-
-        IPv4Address('1.1.1.1') <= IPv4Network('1.1.1.1/24')
-
-    doesn't make any sense.  There are some times however, where you may wish
-    to have ipaddr sort these for you anyway. If you need to do this, you
-    can use this function as the key= argument to sorted().
-
-    Args:
-      obj: either a Network or Address object.
-    Returns:
-      appropriate key.
-
-    """
-    if isinstance(obj, _BaseNet):
-        return obj._get_networks_key()
-    elif isinstance(obj, _BaseIP):
-        return obj._get_address_key()
-    return NotImplemented
-
-class _IPAddrBase(object):
-
-    """The mother class."""
-
-    def __index__(self):
-        return self._ip
-
-    def __int__(self):
-        return self._ip
-
-    def __hex__(self):
-        return hex(self._ip)
-
-    @property
-    def exploded(self):
-        """Return the longhand version of the IP address as a string."""
-        return self._explode_shorthand_ip_string()
-
-    @property
-    def compressed(self):
-        """Return the shorthand version of the IP address as a string."""
-        return str(self)
-
-
-class _BaseIP(_IPAddrBase):
-
-    """A generic IP object.
-
-    This IP class contains the version independent methods which are
-    used by single IP addresses.
-
-    """
-
-    def __init__(self, address):
-        if (not (_compat_has_real_bytes and isinstance(address, bytes))
-            and '/' in str(address)):
-            raise AddressValueError(address)
-
-    def __eq__(self, other):
-        try:
-            return (self._ip == other._ip
-                    and self._version == other._version)
-        except AttributeError:
-            return NotImplemented
-
-    def __ne__(self, other):
-        eq = self.__eq__(other)
-        if eq is NotImplemented:
-            return NotImplemented
-        return not eq
-
-    def __le__(self, other):
-        gt = self.__gt__(other)
-        if gt is NotImplemented:
-            return NotImplemented
-        return not gt
-
-    def __ge__(self, other):
-        lt = self.__lt__(other)
-        if lt is NotImplemented:
-            return NotImplemented
-        return not lt
-
-    def __lt__(self, other):
-        if self._version != other._version:
-            raise TypeError('%s and %s are not of the same version' % (
-                    str(self), str(other)))
-        if not isinstance(other, _BaseIP):
-            raise TypeError('%s and %s are not of the same type' % (
-                    str(self), str(other)))
-        if self._ip != other._ip:
-            return self._ip < other._ip
-        return False
-
-    def __gt__(self, other):
-        if self._version != other._version:
-            raise TypeError('%s and %s are not of the same version' % (
-                    str(self), str(other)))
-        if not isinstance(other, _BaseIP):
-            raise TypeError('%s and %s are not of the same type' % (
-                    str(self), str(other)))
-        if self._ip != other._ip:
-            return self._ip > other._ip
-        return False
-
-    # Shorthand for Integer addition and subtraction. This is not
-    # meant to ever support addition/subtraction of addresses.
-    def __add__(self, other):
-        if not isinstance(other, int):
-            return NotImplemented
-        return IPAddress(int(self) + other, version=self._version)
-
-    def __sub__(self, other):
-        if not isinstance(other, int):
-            return NotImplemented
-        return IPAddress(int(self) - other, version=self._version)
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, str(self))
-
-    def __str__(self):
-        return  '%s' % self._string_from_ip_int(self._ip)
-
-    def __hash__(self):
-        return hash(hex(long(self._ip)))
-
-    def _get_address_key(self):
-        return (self._version, self)
-
-    @property
-    def version(self):
-        raise NotImplementedError('BaseIP has no version')
-
-
-class _BaseNet(_IPAddrBase):
-
-    """A generic IP object.
-
-    This IP class contains the version independent methods which are
-    used by networks.
-
-    """
-
-    def __init__(self, address):
-        self._cache = {}
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, str(self))
-
-    def iterhosts(self):
-        """Generate Iterator over usable hosts in a network.
-
-           This is like __iter__ except it doesn't return the network
-           or broadcast addresses.
-
-        """
-        cur = int(self.network) + 1
-        bcast = int(self.broadcast) - 1
-        while cur <= bcast:
-            cur += 1
-            yield IPAddress(cur - 1, version=self._version)
-
-    def __iter__(self):
-        cur = int(self.network)
-        bcast = int(self.broadcast)
-        while cur <= bcast:
-            cur += 1
-            yield IPAddress(cur - 1, version=self._version)
-
-    def __getitem__(self, n):
-        network = int(self.network)
-        broadcast = int(self.broadcast)
-        if n >= 0:
-            if network + n > broadcast:
-                raise IndexError
-            return IPAddress(network + n, version=self._version)
-        else:
-            n += 1
-            if broadcast + n < network:
-                raise IndexError
-            return IPAddress(broadcast + n, version=self._version)
-
-    def __lt__(self, other):
-        if self._version != other._version:
-            raise TypeError('%s and %s are not of the same version' % (
-                    str(self), str(other)))
-        if not isinstance(other, _BaseNet):
-            raise TypeError('%s and %s are not of the same type' % (
-                    str(self), str(other)))
-        if self.network != other.network:
-            return self.network < other.network
-        if self.netmask != other.netmask:
-            return self.netmask < other.netmask
-        return False
-
-    def __gt__(self, other):
-        if self._version != other._version:
-            raise TypeError('%s and %s are not of the same version' % (
-                    str(self), str(other)))
-        if not isinstance(other, _BaseNet):
-            raise TypeError('%s and %s are not of the same type' % (
-                    str(self), str(other)))
-        if self.network != other.network:
-            return self.network > other.network
-        if self.netmask != other.netmask:
-            return self.netmask > other.netmask
-        return False
-
-    def __le__(self, other):
-        gt = self.__gt__(other)
-        if gt is NotImplemented:
-            return NotImplemented
-        return not gt
-
-    def __ge__(self, other):
-        lt = self.__lt__(other)
-        if lt is NotImplemented:
-            return NotImplemented
-        return not lt
-
-    def __eq__(self, other):
-        try:
-            return (self._version == other._version
-                    and self.network == other.network
-                    and int(self.netmask) == int(other.netmask))
-        except AttributeError:
-            if isinstance(other, _BaseIP):
-                return (self._version == other._version
-                        and self._ip == other._ip)
-
-    def __ne__(self, other):
-        eq = self.__eq__(other)
-        if eq is NotImplemented:
-            return NotImplemented
-        return not eq
-
-    def __str__(self):
-        return  '%s/%s' % (str(self.ip),
-                           str(self._prefixlen))
-
-    def __hash__(self):
-        return hash(int(self.network) ^ int(self.netmask))
-
-    def __contains__(self, other):
-        # always false if one is v4 and the other is v6.
-        if self._version != other._version:
-          return False
-        # dealing with another network.
-        if isinstance(other, _BaseNet):
-            return (self.network <= other.network and
-                    self.broadcast >= other.broadcast)
-        # dealing with another address
-        else:
-            return (int(self.network) <= int(other._ip) <=
-                    int(self.broadcast))
-
-    def overlaps(self, other):
-        """Tell if self is partly contained in other."""
-        return self.network in other or self.broadcast in other or (
-            other.network in self or other.broadcast in self)
-
-    @property
-    def network(self):
-        x = self._cache.get('network')
-        if x is None:
-            x = IPAddress(self._ip & int(self.netmask), version=self._version)
-            self._cache['network'] = x
-        return x
-
-    @property
-    def broadcast(self):
-        x = self._cache.get('broadcast')
-        if x is None:
-            x = IPAddress(self._ip | int(self.hostmask), version=self._version)
-            self._cache['broadcast'] = x
-        return x
-
-    @property
-    def hostmask(self):
-        x = self._cache.get('hostmask')
-        if x is None:
-            x = IPAddress(int(self.netmask) ^ self._ALL_ONES,
-                          version=self._version)
-            self._cache['hostmask'] = x
-        return x
-
-    @property
-    def with_prefixlen(self):
-        return '%s/%d' % (str(self.ip), self._prefixlen)
-
-    @property
-    def with_netmask(self):
-        return '%s/%s' % (str(self.ip), str(self.netmask))
-
-    @property
-    def with_hostmask(self):
-        return '%s/%s' % (str(self.ip), str(self.hostmask))
-
-    @property
-    def numhosts(self):
-        """Number of hosts in the current subnet."""
-        return int(self.broadcast) - int(self.network) + 1
-
-    @property
-    def version(self):
-        raise NotImplementedError('BaseNet has no version')
-
-    @property
-    def prefixlen(self):
-        return self._prefixlen
-
-    def address_exclude(self, other):
-        """Remove an address from a larger block.
-
-        For example:
-
-            addr1 = IPNetwork('10.1.1.0/24')
-            addr2 = IPNetwork('10.1.1.0/26')
-            addr1.address_exclude(addr2) =
-                [IPNetwork('10.1.1.64/26'), IPNetwork('10.1.1.128/25')]
-
-        or IPv6:
-
-            addr1 = IPNetwork('::1/32')
-            addr2 = IPNetwork('::1/128')
-            addr1.address_exclude(addr2) = [IPNetwork('::0/128'),
-                IPNetwork('::2/127'),
-                IPNetwork('::4/126'),
-                IPNetwork('::8/125'),
-                ...
-                IPNetwork('0:0:8000::/33')]
-
-        Args:
-            other: An IPvXNetwork object of the same type.
-
-        Returns:
-            A sorted list of IPvXNetwork objects addresses which is self
-            minus other.
-
-        Raises:
-            TypeError: If self and other are of difffering address
-              versions, or if other is not a network object.
-            ValueError: If other is not completely contained by self.
-
-        """
-        if not self._version == other._version:
-            raise TypeError("%s and %s are not of the same version" % (
-                str(self), str(other)))
-
-        if not isinstance(other, _BaseNet):
-            raise TypeError("%s is not a network object" % str(other))
-
-        if other not in self:
-            raise ValueError('%s not contained in %s' % (str(other),
-                                                         str(self)))
-        if other == self:
-            return []
-
-        ret_addrs = []
-
-        # Make sure we're comparing the network of other.
-        other = IPNetwork('%s/%s' % (str(other.network), str(other.prefixlen)),
-                   version=other._version)
-
-        s1, s2 = self.subnet()
-        while s1 != other and s2 != other:
-            if other in s1:
-                ret_addrs.append(s2)
-                s1, s2 = s1.subnet()
-            elif other in s2:
-                ret_addrs.append(s1)
-                s1, s2 = s2.subnet()
-            else:
-                # If we got here, there's a bug somewhere.
-                assert True == False, ('Error performing exclusion: '
-                                       's1: %s s2: %s other: %s' %
-                                       (str(s1), str(s2), str(other)))
-        if s1 == other:
-            ret_addrs.append(s2)
-        elif s2 == other:
-            ret_addrs.append(s1)
-        else:
-            # If we got here, there's a bug somewhere.
-            assert True == False, ('Error performing exclusion: '
-                                   's1: %s s2: %s other: %s' %
-                                   (str(s1), str(s2), str(other)))
-
-        return sorted(ret_addrs, key=_BaseNet._get_networks_key)
-
-    def compare_networks(self, other):
-        """Compare two IP objects.
-
-        This is only concerned about the comparison of the integer
-        representation of the network addresses.  This means that the
-        host bits aren't considered at all in this method.  If you want
-        to compare host bits, you can easily enough do a
-        'HostA._ip < HostB._ip'
-
-        Args:
-            other: An IP object.
-
-        Returns:
-            If the IP versions of self and other are the same, returns:
-
-            -1 if self < other:
-              eg: IPv4('1.1.1.0/24') < IPv4('1.1.2.0/24')
-              IPv6('1080::200C:417A') < IPv6('1080::200B:417B')
-            0 if self == other
-              eg: IPv4('1.1.1.1/24') == IPv4('1.1.1.2/24')
-              IPv6('1080::200C:417A/96') == IPv6('1080::200C:417B/96')
-            1 if self > other
-              eg: IPv4('1.1.1.0/24') > IPv4('1.1.0.0/24')
-              IPv6('1080::1:200C:417A/112') >
-              IPv6('1080::0:200C:417A/112')
-
-            If the IP versions of self and other are different, returns:
-
-            -1 if self._version < other._version
-              eg: IPv4('10.0.0.1/24') < IPv6('::1/128')
-            1 if self._version > other._version
-              eg: IPv6('::1/128') > IPv4('255.255.255.0/24')
-
-        """
-        if self._version < other._version:
-            return -1
-        if self._version > other._version:
-            return 1
-        # self._version == other._version below here:
-        if self.network < other.network:
-            return -1
-        if self.network > other.network:
-            return 1
-        # self.network == other.network below here:
-        if self.netmask < other.netmask:
-            return -1
-        if self.netmask > other.netmask:
-            return 1
-        # self.network == other.network and self.netmask == other.netmask
-        return 0
-
-    def _get_networks_key(self):
-        """Network-only key function.
-
-        Returns an object that identifies this address' network and
-        netmask. This function is a suitable "key" argument for sorted()
-        and list.sort().
-
-        """
-        return (self._version, self.network, self.netmask)
-
-    def _ip_int_from_prefix(self, prefixlen=None):
-        """Turn the prefix length netmask into a int for comparison.
-
-        Args:
-            prefixlen: An integer, the prefix length.
-
-        Returns:
-            An integer.
-
-        """
-        if not prefixlen and prefixlen != 0:
-            prefixlen = self._prefixlen
-        return self._ALL_ONES ^ (self._ALL_ONES >> prefixlen)
-
-    def _prefix_from_ip_int(self, ip_int, mask=32):
-        """Return prefix length from the decimal netmask.
-
-        Args:
-            ip_int: An integer, the IP address.
-            mask: The netmask.  Defaults to 32.
-
-        Returns:
-            An integer, the prefix length.
-
-        """
-        while mask:
-            if ip_int & 1 == 1:
-                break
-            ip_int >>= 1
-            mask -= 1
-
-        return mask
-
-    def _ip_string_from_prefix(self, prefixlen=None):
-        """Turn a prefix length into a dotted decimal string.
-
-        Args:
-            prefixlen: An integer, the netmask prefix length.
-
-        Returns:
-            A string, the dotted decimal netmask string.
-
-        """
-        if not prefixlen:
-            prefixlen = self._prefixlen
-        return self._string_from_ip_int(self._ip_int_from_prefix(prefixlen))
-
-    def iter_subnets(self, prefixlen_diff=1, new_prefix=None):
-        """The subnets which join to make the current subnet.
-
-        In the case that self contains only one IP
-        (self._prefixlen == 32 for IPv4 or self._prefixlen == 128
-        for IPv6), return a list with just ourself.
-
-        Args:
-            prefixlen_diff: An integer, the amount the prefix length
-              should be increased by. This should not be set if
-              new_prefix is also set.
-            new_prefix: The desired new prefix length. This must be a
-              larger number (smaller prefix) than the existing prefix.
-              This should not be set if prefixlen_diff is also set.
-
-        Returns:
-            An iterator of IPv(4|6) objects.
-
-        Raises:
-            ValueError: The prefixlen_diff is too small or too large.
-                OR
-            prefixlen_diff and new_prefix are both set or new_prefix
-              is a smaller number than the current prefix (smaller
-              number means a larger network)
-
-        """
-        if self._prefixlen == self._max_prefixlen:
-            yield self
-            return
-
-        if new_prefix is not None:
-            if new_prefix < self._prefixlen:
-                raise ValueError('new prefix must be longer')
-            if prefixlen_diff != 1:
-                raise ValueError('cannot set prefixlen_diff and new_prefix')
-            prefixlen_diff = new_prefix - self._prefixlen
-
-        if prefixlen_diff < 0:
-            raise ValueError('prefix length diff must be > 0')
-        new_prefixlen = self._prefixlen + prefixlen_diff
-
-        if not self._is_valid_netmask(str(new_prefixlen)):
-            raise ValueError(
-                'prefix length diff %d is invalid for netblock %s' % (
-                    new_prefixlen, str(self)))
-
-        first = IPNetwork('%s/%s' % (str(self.network),
-                                     str(self._prefixlen + prefixlen_diff)),
-                         version=self._version)
-
-        yield first
-        current = first
-        while True:
-            broadcast = current.broadcast
-            if broadcast == self.broadcast:
-                return
-            new_addr = IPAddress(int(broadcast) + 1, version=self._version)
-            current = IPNetwork('%s/%s' % (str(new_addr), str(new_prefixlen)),
-                                version=self._version)
-
-            yield current
-
-    def masked(self):
-        """Return the network object with the host bits masked out."""
-        return IPNetwork('%s/%d' % (self.network, self._prefixlen),
-                         version=self._version)
-
-    def subnet(self, prefixlen_diff=1, new_prefix=None):
-        """Return a list of subnets, rather than an iterator."""
-        return list(self.iter_subnets(prefixlen_diff, new_prefix))
-
-    def supernet(self, prefixlen_diff=1, new_prefix=None):
-        """The supernet containing the current network.
-
-        Args:
-            prefixlen_diff: An integer, the amount the prefix length of
-              the network should be decreased by.  For example, given a
-              /24 network and a prefixlen_diff of 3, a supernet with a
-              /21 netmask is returned.
-
-        Returns:
-            An IPv4 network object.
-
-        Raises:
-            ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have a
-              negative prefix length.
-                OR
-            If prefixlen_diff and new_prefix are both set or new_prefix is a
-              larger number than the current prefix (larger number means a
-              smaller network)
-
-        """
-        if self._prefixlen == 0:
-            return self
-
-        if new_prefix is not None:
-            if new_prefix > self._prefixlen:
-                raise ValueError('new prefix must be shorter')
-            if prefixlen_diff != 1:
-                raise ValueError('cannot set prefixlen_diff and new_prefix')
-            prefixlen_diff = self._prefixlen - new_prefix
-
-
-        if self.prefixlen - prefixlen_diff < 0:
-            raise ValueError(
-                'current prefixlen is %d, cannot have a prefixlen_diff of %d' %
-                (self.prefixlen, prefixlen_diff))
-        return IPNetwork('%s/%s' % (str(self.network),
-                                    str(self.prefixlen - prefixlen_diff)),
-                         version=self._version)
-
-    # backwards compatibility
-    Subnet = subnet
-    Supernet = supernet
-    AddressExclude = address_exclude
-    CompareNetworks = compare_networks
-    Contains = __contains__
-
-
-class _BaseV4(object):
-
-    """Base IPv4 object.
-
-    The following methods are used by IPv4 objects in both single IP
-    addresses and networks.
-
-    """
-
-    # Equivalent to 255.255.255.255 or 32 bits of 1's.
-    _ALL_ONES = (2**IPV4LENGTH) - 1
-    _DECIMAL_DIGITS = frozenset('0123456789')
-
-    def __init__(self, address):
-        self._version = 4
-        self._max_prefixlen = IPV4LENGTH
-
-    def _explode_shorthand_ip_string(self, ip_str=None):
-        if not ip_str:
-            ip_str = str(self)
-        return ip_str
-
-    def _ip_int_from_string(self, ip_str):
-        """Turn the given IP string into an integer for comparison.
-
-        Args:
-            ip_str: A string, the IP ip_str.
-
-        Returns:
-            The IP ip_str as an integer.
-
-        Raises:
-            AddressValueError: if ip_str isn't a valid IPv4 Address.
-
-        """
-        octets = ip_str.split('.')
-        if len(octets) != 4:
-            raise AddressValueError(ip_str)
-
-        packed_ip = 0
-        for oc in octets:
-            try:
-                packed_ip = (packed_ip << 8) | self._parse_octet(oc)
-            except ValueError:
-                raise AddressValueError(ip_str)
-        return packed_ip
-
-    def _parse_octet(self, octet_str):
-        """Convert a decimal octet into an integer.
-
-        Args:
-            octet_str: A string, the number to parse.
-
-        Returns:
-            The octet as an integer.
-
-        Raises:
-            ValueError: if the octet isn't strictly a decimal from [0..255].
-
-        """
-        # Whitelist the characters, since int() allows a lot of bizarre stuff.
-        if not self._DECIMAL_DIGITS.issuperset(octet_str):
-            raise ValueError
-        octet_int = int(octet_str, 10)
-        # Disallow leading zeroes, because no clear standard exists on
-        # whether these should be interpreted as decimal or octal.
-        if octet_int > 255 or (octet_str[0] == '0' and len(octet_str) > 1):
-            raise ValueError
-        return octet_int
-
-    def _string_from_ip_int(self, ip_int):
-        """Turns a 32-bit integer into dotted decimal notation.
-
-        Args:
-            ip_int: An integer, the IP address.
-
-        Returns:
-            The IP address as a string in dotted decimal notation.
-
-        """
-        octets = []
-        for _ in xrange(4):
-            octets.insert(0, str(ip_int & 0xFF))
-            ip_int >>= 8
-        return '.'.join(octets)
-
-    @property
-    def max_prefixlen(self):
-        return self._max_prefixlen
-
-    @property
-    def packed(self):
-        """The binary representation of this address."""
-        return v4_int_to_packed(self._ip)
-
-    @property
-    def version(self):
-        return self._version
-
-    @property
-    def is_reserved(self):
-       """Test if the address is otherwise IETF reserved.
-
-        Returns:
-            A boolean, True if the address is within the
-            reserved IPv4 Network range.
-
-       """
-       return self in IPv4Network('240.0.0.0/4')
-
-    @property
-    def is_private(self):
-        """Test if this address is allocated for private networks.
-
-        Returns:
-            A boolean, True if the address is reserved per RFC 1918.
-
-        """
-        return (self in IPv4Network('10.0.0.0/8') or
-                self in IPv4Network('172.16.0.0/12') or
-                self in IPv4Network('192.168.0.0/16'))
-
-    @property
-    def is_multicast(self):
-        """Test if the address is reserved for multicast use.
-
-        Returns:
-            A boolean, True if the address is multicast.
-            See RFC 3171 for details.
-
-        """
-        return self in IPv4Network('224.0.0.0/4')
-
-    @property
-    def is_unspecified(self):
-        """Test if the address is unspecified.
-
-        Returns:
-            A boolean, True if this is the unspecified address as defined in
-            RFC 5735 3.
-
-        """
-        return self in IPv4Network('0.0.0.0')
-
-    @property
-    def is_loopback(self):
-        """Test if the address is a loopback address.
-
-        Returns:
-            A boolean, True if the address is a loopback per RFC 3330.
-
-        """
-        return self in IPv4Network('127.0.0.0/8')
-
-    @property
-    def is_link_local(self):
-        """Test if the address is reserved for link-local.
-
-        Returns:
-            A boolean, True if the address is link-local per RFC 3927.
-
-        """
-        return self in IPv4Network('169.254.0.0/16')
-
-
-class IPv4Address(_BaseV4, _BaseIP):
-
-    """Represent and manipulate single IPv4 Addresses."""
-
-    def __init__(self, address):
-
-        """
-        Args:
-            address: A string or integer representing the IP
-              '192.168.1.1'
-
-              Additionally, an integer can be passed, so
-              IPv4Address('192.168.1.1') == IPv4Address(3232235777).
-              or, more generally
-              IPv4Address(int(IPv4Address('192.168.1.1'))) ==
-                IPv4Address('192.168.1.1')
-
-        Raises:
-            AddressValueError: If ipaddr isn't a valid IPv4 address.
-
-        """
-        _BaseIP.__init__(self, address)
-        _BaseV4.__init__(self, address)
-
-        # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
-            self._ip = address
-            if address < 0 or address > self._ALL_ONES:
-                raise AddressValueError(address)
-            return
-
-        # Constructing from a packed address
-        if _compat_has_real_bytes:
-            if isinstance(address, bytes) and len(address) == 4:
-                self._ip = struct.unpack('!I', address)[0]
-                return
-
-        # Assume input argument to be string or any object representation
-        # which converts into a formatted IP string.
-        addr_str = str(address)
-        self._ip = self._ip_int_from_string(addr_str)
-
-
-class IPv4Network(_BaseV4, _BaseNet):
-
-    """This class represents and manipulates 32-bit IPv4 networks.
-
-    Attributes: [examples for IPv4Network('1.2.3.4/27')]
-        ._ip: 16909060
-        .ip: IPv4Address('1.2.3.4')
-        .network: IPv4Address('1.2.3.0')
-        .hostmask: IPv4Address('0.0.0.31')
-        .broadcast: IPv4Address('1.2.3.31')
-        .netmask: IPv4Address('255.255.255.224')
-        .prefixlen: 27
-
-    """
-
-    # the valid octets for host and netmasks. only useful for IPv4.
-    _valid_mask_octets = set((255, 254, 252, 248, 240, 224, 192, 128, 0))
-
-    def __init__(self, address, strict=False):
-        """Instantiate a new IPv4 network object.
-
-        Args:
-            address: A string or integer representing the IP [& network].
-              '192.168.1.1/24'
-              '192.168.1.1/255.255.255.0'
-              '192.168.1.1/0.0.0.255'
-              are all functionally the same in IPv4. Similarly,
-              '192.168.1.1'
-              '192.168.1.1/255.255.255.255'
-              '192.168.1.1/32'
-              are also functionaly equivalent. That is to say, failing to
-              provide a subnetmask will create an object with a mask of /32.
-
-              If the mask (portion after the / in the argument) is given in
-              dotted quad form, it is treated as a netmask if it starts with a
-              non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it
-              starts with a zero field (e.g. 0.255.255.255 == /8), with the
-              single exception of an all-zero mask which is treated as a
-              netmask == /0. If no mask is given, a default of /32 is used.
-
-              Additionally, an integer can be passed, so
-              IPv4Network('192.168.1.1') == IPv4Network(3232235777).
-              or, more generally
-              IPv4Network(int(IPv4Network('192.168.1.1'))) ==
-                IPv4Network('192.168.1.1')
-
-            strict: A boolean. If true, ensure that we have been passed
-              A true network address, eg, 192.168.1.0/24 and not an
-              IP address on a network, eg, 192.168.1.1/24.
-
-        Raises:
-            AddressValueError: If ipaddr isn't a valid IPv4 address.
-            NetmaskValueError: If the netmask isn't valid for
-              an IPv4 address.
-            ValueError: If strict was True and a network address was not
-              supplied.
-
-        """
-        _BaseNet.__init__(self, address)
-        _BaseV4.__init__(self, address)
-
-        # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
-            self._ip = address
-            self.ip = IPv4Address(self._ip)
-            self._prefixlen = self._max_prefixlen
-            self.netmask = IPv4Address(self._ALL_ONES)
-            if address < 0 or address > self._ALL_ONES:
-                raise AddressValueError(address)
-            return
-
-        # Constructing from a packed address
-        if _compat_has_real_bytes:
-            if isinstance(address, bytes) and len(address) == 4:
-                self._ip = struct.unpack('!I', address)[0]
-                self.ip = IPv4Address(self._ip)
-                self._prefixlen = self._max_prefixlen
-                self.netmask = IPv4Address(self._ALL_ONES)
-                return
-
-        # Assume input argument to be string or any object representation
-        # which converts into a formatted IP prefix string.
-        addr = str(address).split('/')
-
-        if len(addr) > 2:
-            raise AddressValueError(address)
-
-        self._ip = self._ip_int_from_string(addr[0])
-        self.ip = IPv4Address(self._ip)
-
-        if len(addr) == 2:
-            mask = addr[1].split('.')
-            if len(mask) == 4:
-                # We have dotted decimal netmask.
-                if self._is_valid_netmask(addr[1]):
-                    self.netmask = IPv4Address(self._ip_int_from_string(
-                            addr[1]))
-                elif self._is_hostmask(addr[1]):
-                    self.netmask = IPv4Address(
-                        self._ip_int_from_string(addr[1]) ^ self._ALL_ONES)
-                else:
-                    raise NetmaskValueError('%s is not a valid netmask'
-                                                     % addr[1])
-
-                self._prefixlen = self._prefix_from_ip_int(int(self.netmask))
-            else:
-                # We have a netmask in prefix length form.
-                if not self._is_valid_netmask(addr[1]):
-                    raise NetmaskValueError(addr[1])
-                self._prefixlen = int(addr[1])
-                self.netmask = IPv4Address(self._ip_int_from_prefix(
-                    self._prefixlen))
-        else:
-            self._prefixlen = self._max_prefixlen
-            self.netmask = IPv4Address(self._ip_int_from_prefix(
-                self._prefixlen))
-        if strict:
-            if self.ip != self.network:
-                raise ValueError('%s has host bits set' %
-                                 self.ip)
-
-    def _is_hostmask(self, ip_str):
-        """Test if the IP string is a hostmask (rather than a netmask).
-
-        Args:
-            ip_str: A string, the potential hostmask.
-
-        Returns:
-            A boolean, True if the IP string is a hostmask.
-
-        """
-        bits = ip_str.split('.')
-        try:
-            parts = [int(x) for x in bits if int(x) in self._valid_mask_octets]
-        except ValueError:
-            return False
-        if len(parts) != len(bits):
-            return False
-        if parts[0] < parts[-1]:
-            return True
-        return False
-
-    def _is_valid_netmask(self, netmask):
-        """Verify that the netmask is valid.
-
-        Args:
-            netmask: A string, either a prefix or dotted decimal
-              netmask.
-
-        Returns:
-            A boolean, True if the prefix represents a valid IPv4
-            netmask.
-
-        """
-        mask = netmask.split('.')
-        if len(mask) == 4:
-            if [x for x in mask if int(x) not in self._valid_mask_octets]:
-                return False
-            if [y for idx, y in enumerate(mask) if idx > 0 and
-                y > mask[idx - 1]]:
-                return False
-            return True
-        try:
-            netmask = int(netmask)
-        except ValueError:
-            return False
-        return 0 <= netmask <= self._max_prefixlen
-
-    # backwards compatibility
-    IsRFC1918 = lambda self: self.is_private
-    IsMulticast = lambda self: self.is_multicast
-    IsLoopback = lambda self: self.is_loopback
-    IsLinkLocal = lambda self: self.is_link_local
-
-
-class _BaseV6(object):
-
-    """Base IPv6 object.
-
-    The following methods are used by IPv6 objects in both single IP
-    addresses and networks.
-
-    """
-
-    _ALL_ONES = (2**IPV6LENGTH) - 1
-    _HEXTET_COUNT = 8
-    _HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
-
-    def __init__(self, address):
-        self._version = 6
-        self._max_prefixlen = IPV6LENGTH
-
-    def _ip_int_from_string(self, ip_str):
-        """Turn an IPv6 ip_str into an integer.
-
-        Args:
-            ip_str: A string, the IPv6 ip_str.
-
-        Returns:
-            A long, the IPv6 ip_str.
-
-        Raises:
-            AddressValueError: if ip_str isn't a valid IPv6 Address.
-
-        """
-        parts = ip_str.split(':')
-
-        # An IPv6 address needs at least 2 colons (3 parts).
-        if len(parts) < 3:
-            raise AddressValueError(ip_str)
-
-        # If the address has an IPv4-style suffix, convert it to hexadecimal.
-        if '.' in parts[-1]:
-            ipv4_int = IPv4Address(parts.pop())._ip
-            parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF))
-            parts.append('%x' % (ipv4_int & 0xFFFF))
-
-        # An IPv6 address can't have more than 8 colons (9 parts).
-        if len(parts) > self._HEXTET_COUNT + 1:
-            raise AddressValueError(ip_str)
-
-        # Disregarding the endpoints, find '::' with nothing in between.
-        # This indicates that a run of zeroes has been skipped.
-        try:
-            skip_index, = (
-                [i for i in xrange(1, len(parts) - 1) if not parts[i]] or
-                [None])
-        except ValueError:
-            # Can't have more than one '::'
-            raise AddressValueError(ip_str)
-
-        # parts_hi is the number of parts to copy from above/before the '::'
-        # parts_lo is the number of parts to copy from below/after the '::'
-        if skip_index is not None:
-            # If we found a '::', then check if it also covers the endpoints.
-            parts_hi = skip_index
-            parts_lo = len(parts) - skip_index - 1
-            if not parts[0]:
-                parts_hi -= 1
-                if parts_hi:
-                    raise AddressValueError(ip_str)  # ^: requires ^::
-            if not parts[-1]:
-                parts_lo -= 1
-                if parts_lo:
-                    raise AddressValueError(ip_str)  # :$ requires ::$
-            parts_skipped = self._HEXTET_COUNT - (parts_hi + parts_lo)
-            if parts_skipped < 1:
-                raise AddressValueError(ip_str)
-        else:
-            # Otherwise, allocate the entire address to parts_hi.  The endpoints
-            # could still be empty, but _parse_hextet() will check for that.
-            if len(parts) != self._HEXTET_COUNT:
-                raise AddressValueError(ip_str)
-            parts_hi = len(parts)
-            parts_lo = 0
-            parts_skipped = 0
-
-        try:
-            # Now, parse the hextets into a 128-bit integer.
-            ip_int = 0L
-            for i in xrange(parts_hi):
-                ip_int <<= 16
-                ip_int |= self._parse_hextet(parts[i])
-            ip_int <<= 16 * parts_skipped
-            for i in xrange(-parts_lo, 0):
-                ip_int <<= 16
-                ip_int |= self._parse_hextet(parts[i])
-            return ip_int
-        except ValueError:
-            raise AddressValueError(ip_str)
-
-    def _parse_hextet(self, hextet_str):
-        """Convert an IPv6 hextet string into an integer.
-
-        Args:
-            hextet_str: A string, the number to parse.
-
-        Returns:
-            The hextet as an integer.
-
-        Raises:
-            ValueError: if the input isn't strictly a hex number from [0..FFFF].
-
-        """
-        # Whitelist the characters, since int() allows a lot of bizarre stuff.
-        if not self._HEX_DIGITS.issuperset(hextet_str):
-            raise ValueError
-        hextet_int = int(hextet_str, 16)
-        if hextet_int > 0xFFFF:
-            raise ValueError
-        return hextet_int
-
-    def _compress_hextets(self, hextets):
-        """Compresses a list of hextets.
-
-        Compresses a list of strings, replacing the longest continuous
-        sequence of "0" in the list with "" and adding empty strings at
-        the beginning or at the end of the string such that subsequently
-        calling ":".join(hextets) will produce the compressed version of
-        the IPv6 address.
-
-        Args:
-            hextets: A list of strings, the hextets to compress.
-
-        Returns:
-            A list of strings.
-
-        """
-        best_doublecolon_start = -1
-        best_doublecolon_len = 0
-        doublecolon_start = -1
-        doublecolon_len = 0
-        for index in range(len(hextets)):
-            if hextets[index] == '0':
-                doublecolon_len += 1
-                if doublecolon_start == -1:
-                    # Start of a sequence of zeros.
-                    doublecolon_start = index
-                if doublecolon_len > best_doublecolon_len:
-                    # This is the longest sequence of zeros so far.
-                    best_doublecolon_len = doublecolon_len
-                    best_doublecolon_start = doublecolon_start
-            else:
-                doublecolon_len = 0
-                doublecolon_start = -1
-
-        if best_doublecolon_len > 1:
-            best_doublecolon_end = (best_doublecolon_start +
-                                    best_doublecolon_len)
-            # For zeros at the end of the address.
-            if best_doublecolon_end == len(hextets):
-                hextets += ['']
-            hextets[best_doublecolon_start:best_doublecolon_end] = ['']
-            # For zeros at the beginning of the address.
-            if best_doublecolon_start == 0:
-                hextets = [''] + hextets
-
-        return hextets
-
-    def _string_from_ip_int(self, ip_int=None):
-        """Turns a 128-bit integer into hexadecimal notation.
-
-        Args:
-            ip_int: An integer, the IP address.
-
-        Returns:
-            A string, the hexadecimal representation of the address.
-
-        Raises:
-            ValueError: The address is bigger than 128 bits of all ones.
-
-        """
-        if not ip_int and ip_int != 0:
-            ip_int = int(self._ip)
-
-        if ip_int > self._ALL_ONES:
-            raise ValueError('IPv6 address is too large')
-
-        hex_str = '%032x' % ip_int
-        hextets = []
-        for x in range(0, 32, 4):
-            hextets.append('%x' % int(hex_str[x:x+4], 16))
-
-        hextets = self._compress_hextets(hextets)
-        return ':'.join(hextets)
-
-    def _explode_shorthand_ip_string(self, ip_str=None):
-        """Expand a shortened IPv6 address.
-
-        Args:
-            ip_str: A string, the IPv6 address.
-
-        Returns:
-            A string, the expanded IPv6 address.
-
-        """
-        if not ip_str:
-            ip_str = str(self)
-            if isinstance(self, _BaseNet):
-                ip_str = str(self.ip)
-
-        ip_int = self._ip_int_from_string(ip_str)
-        parts = []
-        for i in xrange(self._HEXTET_COUNT):
-            parts.append('%04x' % (ip_int & 0xFFFF))
-            ip_int >>= 16
-        parts.reverse()
-        return ':'.join(parts)
-
-    @property
-    def max_prefixlen(self):
-        return self._max_prefixlen
-
-    @property
-    def packed(self):
-        """The binary representation of this address."""
-        return v6_int_to_packed(self._ip)
-
-    @property
-    def version(self):
-        return self._version
-
-    @property
-    def is_multicast(self):
-        """Test if the address is reserved for multicast use.
-
-        Returns:
-            A boolean, True if the address is a multicast address.
-            See RFC 2373 2.7 for details.
-
-        """
-        return self in IPv6Network('ff00::/8')
-
-    @property
-    def is_reserved(self):
-        """Test if the address is otherwise IETF reserved.
-
-        Returns:
-            A boolean, True if the address is within one of the
-            reserved IPv6 Network ranges.
-
-        """
-        return (self in IPv6Network('::/8') or
-                self in IPv6Network('100::/8') or
-                self in IPv6Network('200::/7') or
-                self in IPv6Network('400::/6') or
-                self in IPv6Network('800::/5') or
-                self in IPv6Network('1000::/4') or
-                self in IPv6Network('4000::/3') or
-                self in IPv6Network('6000::/3') or
-                self in IPv6Network('8000::/3') or
-                self in IPv6Network('A000::/3') or
-                self in IPv6Network('C000::/3') or
-                self in IPv6Network('E000::/4') or
-                self in IPv6Network('F000::/5') or
-                self in IPv6Network('F800::/6') or
-                self in IPv6Network('FE00::/9'))
-
-    @property
-    def is_unspecified(self):
-        """Test if the address is unspecified.
-
-        Returns:
-            A boolean, True if this is the unspecified address as defined in
-            RFC 2373 2.5.2.
-
-        """
-        return self._ip == 0 and getattr(self, '_prefixlen', 128) == 128
-
-    @property
-    def is_loopback(self):
-        """Test if the address is a loopback address.
-
-        Returns:
-            A boolean, True if the address is a loopback address as defined in
-            RFC 2373 2.5.3.
-
-        """
-        return self._ip == 1 and getattr(self, '_prefixlen', 128) == 128
-
-    @property
-    def is_link_local(self):
-        """Test if the address is reserved for link-local.
-
-        Returns:
-            A boolean, True if the address is reserved per RFC 4291.
-
-        """
-        return self in IPv6Network('fe80::/10')
-
-    @property
-    def is_site_local(self):
-        """Test if the address is reserved for site-local.
-
-        Note that the site-local address space has been deprecated by RFC 3879.
-        Use is_private to test if this address is in the space of unique local
-        addresses as defined by RFC 4193.
-
-        Returns:
-            A boolean, True if the address is reserved per RFC 3513 2.5.6.
-
-        """
-        return self in IPv6Network('fec0::/10')
-
-    @property
-    def is_private(self):
-        """Test if this address is allocated for private networks.
-
-        Returns:
-            A boolean, True if the address is reserved per RFC 4193.
-
-        """
-        return self in IPv6Network('fc00::/7')
-
-    @property
-    def ipv4_mapped(self):
-        """Return the IPv4 mapped address.
-
-        Returns:
-            If the IPv6 address is a v4 mapped address, return the
-            IPv4 mapped address. Return None otherwise.
-
-        """
-        if (self._ip >> 32) != 0xFFFF:
-            return None
-        return IPv4Address(self._ip & 0xFFFFFFFF)
-
-    @property
-    def teredo(self):
-        """Tuple of embedded teredo IPs.
-
-        Returns:
-            Tuple of the (server, client) IPs or None if the address
-            doesn't appear to be a teredo address (doesn't start with
-            2001::/32)
-
-        """
-        if (self._ip >> 96) != 0x20010000:
-            return None
-        return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF),
-                IPv4Address(~self._ip & 0xFFFFFFFF))
-
-    @property
-    def sixtofour(self):
-        """Return the IPv4 6to4 embedded address.
-
-        Returns:
-            The IPv4 6to4-embedded address if present or None if the
-            address doesn't appear to contain a 6to4 embedded address.
-
-        """
-        if (self._ip >> 112) != 0x2002:
-            return None
-        return IPv4Address((self._ip >> 80) & 0xFFFFFFFF)
-
-
-class IPv6Address(_BaseV6, _BaseIP):
-
-    """Represent and manipulate single IPv6 Addresses.
-    """
-
-    def __init__(self, address):
-        """Instantiate a new IPv6 address object.
-
-        Args:
-            address: A string or integer representing the IP
-
-              Additionally, an integer can be passed, so
-              IPv6Address('2001:4860::') ==
-                IPv6Address(42541956101370907050197289607612071936L).
-              or, more generally
-              IPv6Address(IPv6Address('2001:4860::')._ip) ==
-                IPv6Address('2001:4860::')
-
-        Raises:
-            AddressValueError: If address isn't a valid IPv6 address.
-
-        """
-        _BaseIP.__init__(self, address)
-        _BaseV6.__init__(self, address)
-
-        # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
-            self._ip = address
-            if address < 0 or address > self._ALL_ONES:
-                raise AddressValueError(address)
-            return
-
-        # Constructing from a packed address
-        if _compat_has_real_bytes:
-            if isinstance(address, bytes) and len(address) == 16:
-                tmp = struct.unpack('!QQ', address)
-                self._ip = (tmp[0] << 64) | tmp[1]
-                return
-
-        # Assume input argument to be string or any object representation
-        # which converts into a formatted IP string.
-        addr_str = str(address)
-        if not addr_str:
-            raise AddressValueError('')
-
-        self._ip = self._ip_int_from_string(addr_str)
-
-
-class IPv6Network(_BaseV6, _BaseNet):
-
-    """This class represents and manipulates 128-bit IPv6 networks.
-
-    Attributes: [examples for IPv6('2001:658:22A:CAFE:200::1/64')]
-        .ip: IPv6Address('2001:658:22a:cafe:200::1')
-        .network: IPv6Address('2001:658:22a:cafe::')
-        .hostmask: IPv6Address('::ffff:ffff:ffff:ffff')
-        .broadcast: IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff')
-        .netmask: IPv6Address('ffff:ffff:ffff:ffff::')
-        .prefixlen: 64
-
-    """
-
-
-    def __init__(self, address, strict=False):
-        """Instantiate a new IPv6 Network object.
-
-        Args:
-            address: A string or integer representing the IPv6 network or the IP
-              and prefix/netmask.
-              '2001:4860::/128'
-              '2001:4860:0000:0000:0000:0000:0000:0000/128'
-              '2001:4860::'
-              are all functionally the same in IPv6.  That is to say,
-              failing to provide a subnetmask will create an object with
-              a mask of /128.
-
-              Additionally, an integer can be passed, so
-              IPv6Network('2001:4860::') ==
-                IPv6Network(42541956101370907050197289607612071936L).
-              or, more generally
-              IPv6Network(IPv6Network('2001:4860::')._ip) ==
-                IPv6Network('2001:4860::')
-
-            strict: A boolean. If true, ensure that we have been passed
-              A true network address, eg, 192.168.1.0/24 and not an
-              IP address on a network, eg, 192.168.1.1/24.
-
-        Raises:
-            AddressValueError: If address isn't a valid IPv6 address.
-            NetmaskValueError: If the netmask isn't valid for
-              an IPv6 address.
-            ValueError: If strict was True and a network address was not
-              supplied.
-
-        """
-        _BaseNet.__init__(self, address)
-        _BaseV6.__init__(self, address)
-
-        # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
-            self._ip = address
-            self.ip = IPv6Address(self._ip)
-            self._prefixlen = self._max_prefixlen
-            self.netmask = IPv6Address(self._ALL_ONES)
-            if address < 0 or address > self._ALL_ONES:
-                raise AddressValueError(address)
-            return
-
-        # Constructing from a packed address
-        if _compat_has_real_bytes:
-            if isinstance(address, bytes) and len(address) == 16:
-                tmp = struct.unpack('!QQ', address)
-                self._ip = (tmp[0] << 64) | tmp[1]
-                self.ip = IPv6Address(self._ip)
-                self._prefixlen = self._max_prefixlen
-                self.netmask = IPv6Address(self._ALL_ONES)
-                return
-
-        # Assume input argument to be string or any object representation
-        # which converts into a formatted IP prefix string.
-        addr = str(address).split('/')
-
-        if len(addr) > 2:
-            raise AddressValueError(address)
-
-        self._ip = self._ip_int_from_string(addr[0])
-        self.ip = IPv6Address(self._ip)
-
-        if len(addr) == 2:
-            if self._is_valid_netmask(addr[1]):
-                self._prefixlen = int(addr[1])
-            else:
-                raise NetmaskValueError(addr[1])
-        else:
-            self._prefixlen = self._max_prefixlen
-
-        self.netmask = IPv6Address(self._ip_int_from_prefix(self._prefixlen))
-
-        if strict:
-            if self.ip != self.network:
-                raise ValueError('%s has host bits set' %
-                                 self.ip)
-
-    def _is_valid_netmask(self, prefixlen):
-        """Verify that the netmask/prefixlen is valid.
-
-        Args:
-            prefixlen: A string, the netmask in prefix length format.
-
-        Returns:
-            A boolean, True if the prefix represents a valid IPv6
-            netmask.
-
-        """
-        try:
-            prefixlen = int(prefixlen)
-        except ValueError:
-            return False
-        return 0 <= prefixlen <= self._max_prefixlen
-
-    @property
-    def with_netmask(self):
-        return self.with_prefixlen
diff --git a/contrib/ipaddr-py/ipaddr_test.py b/contrib/ipaddr-py/ipaddr_test.py
deleted file mode 100755
index 09bece0e751..00000000000
--- a/contrib/ipaddr-py/ipaddr_test.py
+++ /dev/null
@@ -1,1099 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2007 Google Inc.
-#  Licensed to PSF under a Contributor Agreement.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Unittest for ipaddr module."""
-
-
-import unittest
-import time
-import ipaddr
-
-# Compatibility function to cast str to bytes objects
-if ipaddr._compat_has_real_bytes:
-    _cb = lambda bytestr: bytes(bytestr, 'charmap')
-else:
-    _cb = str
-
-class IpaddrUnitTest(unittest.TestCase):
-
-    def setUp(self):
-        self.ipv4 = ipaddr.IPv4Network('1.2.3.4/24')
-        self.ipv4_hostmask = ipaddr.IPv4Network('10.0.0.1/0.255.255.255')
-        self.ipv6 = ipaddr.IPv6Network('2001:658:22a:cafe:200:0:0:1/64')
-
-    def tearDown(self):
-        del(self.ipv4)
-        del(self.ipv4_hostmask)
-        del(self.ipv6)
-        del(self)
-
-    def testRepr(self):
-        self.assertEqual("IPv4Network('1.2.3.4/32')",
-                         repr(ipaddr.IPv4Network('1.2.3.4')))
-        self.assertEqual("IPv6Network('::1/128')",
-                         repr(ipaddr.IPv6Network('::1')))
-
-    def testAutoMasking(self):
-        addr1 = ipaddr.IPv4Network('1.1.1.255/24')
-        addr1_masked = ipaddr.IPv4Network('1.1.1.0/24')
-        self.assertEqual(addr1_masked, addr1.masked())
-
-        addr2 = ipaddr.IPv6Network('2000:cafe::efac:100/96')
-        addr2_masked = ipaddr.IPv6Network('2000:cafe::/96')
-        self.assertEqual(addr2_masked, addr2.masked())
-
-    # issue57
-    def testAddressIntMath(self):
-        self.assertEqual(ipaddr.IPv4Address('1.1.1.1') + 255,
-                         ipaddr.IPv4Address('1.1.2.0'))
-        self.assertEqual(ipaddr.IPv4Address('1.1.1.1') - 256,
-                         ipaddr.IPv4Address('1.1.0.1'))
-        self.assertEqual(ipaddr.IPv6Address('::1') + (2**16 - 2),
-                         ipaddr.IPv6Address('::ffff'))
-        self.assertEqual(ipaddr.IPv6Address('::ffff') - (2**16 - 2),
-                         ipaddr.IPv6Address('::1'))
-
-    def testInvalidStrings(self):
-        def AssertInvalidIP(ip_str):
-            self.assertRaises(ValueError, ipaddr.IPAddress, ip_str)
-        AssertInvalidIP("")
-        AssertInvalidIP("016.016.016.016")
-        AssertInvalidIP("016.016.016")
-        AssertInvalidIP("016.016")
-        AssertInvalidIP("016")
-        AssertInvalidIP("000.000.000.000")
-        AssertInvalidIP("000")
-        AssertInvalidIP("0x0a.0x0a.0x0a.0x0a")
-        AssertInvalidIP("0x0a.0x0a.0x0a")
-        AssertInvalidIP("0x0a.0x0a")
-        AssertInvalidIP("0x0a")
-        AssertInvalidIP("42.42.42.42.42")
-        AssertInvalidIP("42.42.42")
-        AssertInvalidIP("42.42")
-        AssertInvalidIP("42")
-        AssertInvalidIP("42..42.42")
-        AssertInvalidIP("42..42.42.42")
-        AssertInvalidIP("42.42.42.42.")
-        AssertInvalidIP("42.42.42.42...")
-        AssertInvalidIP(".42.42.42.42")
-        AssertInvalidIP("...42.42.42.42")
-        AssertInvalidIP("42.42.42.-0")
-        AssertInvalidIP("42.42.42.+0")
-        AssertInvalidIP(".")
-        AssertInvalidIP("...")
-        AssertInvalidIP("bogus")
-        AssertInvalidIP("bogus.com")
-        AssertInvalidIP("192.168.0.1.com")
-        AssertInvalidIP("12345.67899.-54321.-98765")
-        AssertInvalidIP("257.0.0.0")
-        AssertInvalidIP("42.42.42.-42")
-        AssertInvalidIP("3ffe::1.net")
-        AssertInvalidIP("3ffe::1::1")
-        AssertInvalidIP("1::2::3::4:5")
-        AssertInvalidIP("::7:6:5:4:3:2:")
-        AssertInvalidIP(":6:5:4:3:2:1::")
-        AssertInvalidIP("2001::db:::1")
-        AssertInvalidIP("FEDC:9878")
-        AssertInvalidIP("+1.+2.+3.4")
-        AssertInvalidIP("1.2.3.4e0")
-        AssertInvalidIP("::7:6:5:4:3:2:1:0")
-        AssertInvalidIP("7:6:5:4:3:2:1:0::")
-        AssertInvalidIP("9:8:7:6:5:4:3::2:1")
-        AssertInvalidIP("0:1:2:3::4:5:6:7")
-        AssertInvalidIP("3ffe:0:0:0:0:0:0:0:1")
-        AssertInvalidIP("3ffe::10000")
-        AssertInvalidIP("3ffe::goog")
-        AssertInvalidIP("3ffe::-0")
-        AssertInvalidIP("3ffe::+0")
-        AssertInvalidIP("3ffe::-1")
-        AssertInvalidIP(":")
-        AssertInvalidIP(":::")
-        AssertInvalidIP("::1.2.3")
-        AssertInvalidIP("::1.2.3.4.5")
-        AssertInvalidIP("::1.2.3.4:")
-        AssertInvalidIP("1.2.3.4::")
-        AssertInvalidIP("2001:db8::1:")
-        AssertInvalidIP(":2001:db8::1")
-        AssertInvalidIP(":1:2:3:4:5:6:7")
-        AssertInvalidIP("1:2:3:4:5:6:7:")
-        AssertInvalidIP(":1:2:3:4:5:6:")
-
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network, '')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
-                          'google.com')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
-                          '::1.2.3.4')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network, '')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          'google.com')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          '1.2.3.4')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          'cafe:cafe::/128/190')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          '1234:axy::b')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
-                          '1234:axy::b')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
-                          '2001:db8:::1')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
-                          '2001:888888::1')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Address(1)._ip_int_from_string,
-                          '1.a.2.3')
-        self.assertEqual(False, ipaddr.IPv4Network(1)._is_hostmask('1.a.2.3'))
-
-    def testGetNetwork(self):
-        self.assertEqual(int(self.ipv4.network), 16909056)
-        self.assertEqual(str(self.ipv4.network), '1.2.3.0')
-        self.assertEqual(str(self.ipv4_hostmask.network), '10.0.0.0')
-
-        self.assertEqual(int(self.ipv6.network),
-                         42540616829182469433403647294022090752)
-        self.assertEqual(str(self.ipv6.network),
-                         '2001:658:22a:cafe::')
-        self.assertEqual(str(self.ipv6.hostmask),
-                         '::ffff:ffff:ffff:ffff')
-
-    def testBadVersionComparison(self):
-        # These should always raise TypeError
-        v4addr = ipaddr.IPAddress('1.1.1.1')
-        v4net = ipaddr.IPNetwork('1.1.1.1')
-        v6addr = ipaddr.IPAddress('::1')
-        v6net = ipaddr.IPAddress('::1')
-
-        self.assertRaises(TypeError, v4addr.__lt__, v6addr)
-        self.assertRaises(TypeError, v4addr.__gt__, v6addr)
-        self.assertRaises(TypeError, v4net.__lt__, v6net)
-        self.assertRaises(TypeError, v4net.__gt__, v6net)
-
-        self.assertRaises(TypeError, v6addr.__lt__, v4addr)
-        self.assertRaises(TypeError, v6addr.__gt__, v4addr)
-        self.assertRaises(TypeError, v6net.__lt__, v4net)
-        self.assertRaises(TypeError, v6net.__gt__, v4net)
-
-    def testMixedTypeComparison(self):
-        v4addr = ipaddr.IPAddress('1.1.1.1')
-        v4net = ipaddr.IPNetwork('1.1.1.1/32')
-        v6addr = ipaddr.IPAddress('::1')
-        v6net = ipaddr.IPNetwork('::1/128')
-
-        self.assertFalse(v4net.__contains__(v6net))
-        self.assertFalse(v6net.__contains__(v4net))
-
-        self.assertRaises(TypeError, lambda: v4addr < v4net)
-        self.assertRaises(TypeError, lambda: v4addr > v4net)
-        self.assertRaises(TypeError, lambda: v4net < v4addr)
-        self.assertRaises(TypeError, lambda: v4net > v4addr)
-
-        self.assertRaises(TypeError, lambda: v6addr < v6net)
-        self.assertRaises(TypeError, lambda: v6addr > v6net)
-        self.assertRaises(TypeError, lambda: v6net < v6addr)
-        self.assertRaises(TypeError, lambda: v6net > v6addr)
-
-        # with get_mixed_type_key, you can sort addresses and network.
-        self.assertEqual([v4addr, v4net], sorted([v4net, v4addr],
-                                                 key=ipaddr.get_mixed_type_key))
-        self.assertEqual([v6addr, v6net], sorted([v6net, v6addr],
-                                                 key=ipaddr.get_mixed_type_key))
-
-    def testIpFromInt(self):
-        self.assertEqual(self.ipv4.ip, ipaddr.IPv4Network(16909060).ip)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Network, 2**32)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Network, -1)
-
-        ipv4 = ipaddr.IPNetwork('1.2.3.4')
-        ipv6 = ipaddr.IPNetwork('2001:658:22a:cafe:200:0:0:1')
-        self.assertEqual(ipv4, ipaddr.IPNetwork(int(ipv4)))
-        self.assertEqual(ipv6, ipaddr.IPNetwork(int(ipv6)))
-
-        v6_int = 42540616829182469433547762482097946625
-        self.assertEqual(self.ipv6.ip, ipaddr.IPv6Network(v6_int).ip)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Network, 2**128)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Network, -1)
-
-        self.assertEqual(ipaddr.IPNetwork(self.ipv4.ip).version, 4)
-        self.assertEqual(ipaddr.IPNetwork(self.ipv6.ip).version, 6)
-
-    if ipaddr._compat_has_real_bytes: # on python3+
-        def testIpFromPacked(self):
-            ip = ipaddr.IPNetwork
-
-            self.assertEqual(self.ipv4.ip,
-                             ip(_cb('\x01\x02\x03\x04')).ip)
-            self.assertEqual(ip('255.254.253.252'),
-                             ip(_cb('\xff\xfe\xfd\xfc')))
-            self.assertRaises(ValueError, ipaddr.IPNetwork, _cb('\x00' * 3))
-            self.assertRaises(ValueError, ipaddr.IPNetwork, _cb('\x00' * 5))
-            self.assertEqual(self.ipv6.ip,
-                             ip(_cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
-                               '\x02\x00\x00\x00\x00\x00\x00\x01')).ip)
-            self.assertEqual(ip('ffff:2:3:4:ffff::'),
-                             ip(_cb('\xff\xff\x00\x02\x00\x03\x00\x04' +
-                                   '\xff\xff' + '\x00' * 6)))
-            self.assertEqual(ip('::'),
-                             ip(_cb('\x00' * 16)))
-            self.assertRaises(ValueError, ip, _cb('\x00' * 15))
-            self.assertRaises(ValueError, ip, _cb('\x00' * 17))
-
-    def testGetIp(self):
-        self.assertEqual(int(self.ipv4.ip), 16909060)
-        self.assertEqual(str(self.ipv4.ip), '1.2.3.4')
-        self.assertEqual(str(self.ipv4_hostmask.ip), '10.0.0.1')
-
-        self.assertEqual(int(self.ipv6.ip),
-                         42540616829182469433547762482097946625)
-        self.assertEqual(str(self.ipv6.ip),
-                         '2001:658:22a:cafe:200::1')
-
-    def testGetNetmask(self):
-        self.assertEqual(int(self.ipv4.netmask), 4294967040L)
-        self.assertEqual(str(self.ipv4.netmask), '255.255.255.0')
-        self.assertEqual(str(self.ipv4_hostmask.netmask), '255.0.0.0')
-        self.assertEqual(int(self.ipv6.netmask),
-                         340282366920938463444927863358058659840)
-        self.assertEqual(self.ipv6.prefixlen, 64)
-
-    def testZeroNetmask(self):
-        ipv4_zero_netmask = ipaddr.IPv4Network('1.2.3.4/0')
-        self.assertEqual(int(ipv4_zero_netmask.netmask), 0)
-        self.assertTrue(ipv4_zero_netmask._is_valid_netmask(str(0)))
-
-        ipv6_zero_netmask = ipaddr.IPv6Network('::1/0')
-        self.assertEqual(int(ipv6_zero_netmask.netmask), 0)
-        self.assertTrue(ipv6_zero_netmask._is_valid_netmask(str(0)))
-
-    def testGetBroadcast(self):
-        self.assertEqual(int(self.ipv4.broadcast), 16909311L)
-        self.assertEqual(str(self.ipv4.broadcast), '1.2.3.255')
-
-        self.assertEqual(int(self.ipv6.broadcast),
-                         42540616829182469451850391367731642367)
-        self.assertEqual(str(self.ipv6.broadcast),
-                         '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
-
-    def testGetPrefixlen(self):
-        self.assertEqual(self.ipv4.prefixlen, 24)
-
-        self.assertEqual(self.ipv6.prefixlen, 64)
-
-    def testGetSupernet(self):
-        self.assertEqual(self.ipv4.supernet().prefixlen, 23)
-        self.assertEqual(str(self.ipv4.supernet().network), '1.2.2.0')
-        self.assertEqual(ipaddr.IPv4Network('0.0.0.0/0').supernet(),
-                         ipaddr.IPv4Network('0.0.0.0/0'))
-
-        self.assertEqual(self.ipv6.supernet().prefixlen, 63)
-        self.assertEqual(str(self.ipv6.supernet().network),
-                         '2001:658:22a:cafe::')
-        self.assertEqual(ipaddr.IPv6Network('::0/0').supernet(),
-                         ipaddr.IPv6Network('::0/0'))
-
-    def testGetSupernet3(self):
-        self.assertEqual(self.ipv4.supernet(3).prefixlen, 21)
-        self.assertEqual(str(self.ipv4.supernet(3).network), '1.2.0.0')
-
-        self.assertEqual(self.ipv6.supernet(3).prefixlen, 61)
-        self.assertEqual(str(self.ipv6.supernet(3).network),
-                         '2001:658:22a:caf8::')
-
-    def testGetSupernet4(self):
-        self.assertRaises(ValueError, self.ipv4.supernet, prefixlen_diff=2,
-                          new_prefix=1)
-        self.assertRaises(ValueError, self.ipv4.supernet, new_prefix=25)
-        self.assertEqual(self.ipv4.supernet(prefixlen_diff=2),
-                         self.ipv4.supernet(new_prefix=22))
-
-        self.assertRaises(ValueError, self.ipv6.supernet, prefixlen_diff=2,
-                          new_prefix=1)
-        self.assertRaises(ValueError, self.ipv6.supernet, new_prefix=65)
-        self.assertEqual(self.ipv6.supernet(prefixlen_diff=2),
-                         self.ipv6.supernet(new_prefix=62))
-
-    def testIterSubnets(self):
-        self.assertEqual(self.ipv4.subnet(), list(self.ipv4.iter_subnets()))
-        self.assertEqual(self.ipv6.subnet(), list(self.ipv6.iter_subnets()))
-
-    def testFancySubnetting(self):
-        self.assertEqual(sorted(self.ipv4.subnet(prefixlen_diff=3)),
-                         sorted(self.ipv4.subnet(new_prefix=27)))
-        self.assertRaises(ValueError, self.ipv4.subnet, new_prefix=23)
-        self.assertRaises(ValueError, self.ipv4.subnet,
-                          prefixlen_diff=3, new_prefix=27)
-        self.assertEqual(sorted(self.ipv6.subnet(prefixlen_diff=4)),
-                         sorted(self.ipv6.subnet(new_prefix=68)))
-        self.assertRaises(ValueError, self.ipv6.subnet, new_prefix=63)
-        self.assertRaises(ValueError, self.ipv6.subnet,
-                          prefixlen_diff=4, new_prefix=68)
-
-    def testGetSubnet(self):
-        self.assertEqual(self.ipv4.subnet()[0].prefixlen, 25)
-        self.assertEqual(str(self.ipv4.subnet()[0].network), '1.2.3.0')
-        self.assertEqual(str(self.ipv4.subnet()[1].network), '1.2.3.128')
-
-        self.assertEqual(self.ipv6.subnet()[0].prefixlen, 65)
-
-    def testGetSubnetForSingle32(self):
-        ip = ipaddr.IPv4Network('1.2.3.4/32')
-        subnets1 = [str(x) for x in ip.subnet()]
-        subnets2 = [str(x) for x in ip.subnet(2)]
-        self.assertEqual(subnets1, ['1.2.3.4/32'])
-        self.assertEqual(subnets1, subnets2)
-
-    def testGetSubnetForSingle128(self):
-        ip = ipaddr.IPv6Network('::1/128')
-        subnets1 = [str(x) for x in ip.subnet()]
-        subnets2 = [str(x) for x in ip.subnet(2)]
-        self.assertEqual(subnets1, ['::1/128'])
-        self.assertEqual(subnets1, subnets2)
-
-    def testSubnet2(self):
-        ips = [str(x) for x in self.ipv4.subnet(2)]
-        self.assertEqual(
-            ips,
-            ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26'])
-
-        ipsv6 = [str(x) for x in self.ipv6.subnet(2)]
-        self.assertEqual(
-            ipsv6,
-            ['2001:658:22a:cafe::/66',
-             '2001:658:22a:cafe:4000::/66',
-             '2001:658:22a:cafe:8000::/66',
-             '2001:658:22a:cafe:c000::/66'])
-
-    def testSubnetFailsForLargeCidrDiff(self):
-        self.assertRaises(ValueError, self.ipv4.subnet, 9)
-        self.assertRaises(ValueError, self.ipv6.subnet, 65)
-
-    def testSupernetFailsForLargeCidrDiff(self):
-        self.assertRaises(ValueError, self.ipv4.supernet, 25)
-        self.assertRaises(ValueError, self.ipv6.supernet, 65)
-
-    def testSubnetFailsForNegativeCidrDiff(self):
-        self.assertRaises(ValueError, self.ipv4.subnet, -1)
-        self.assertRaises(ValueError, self.ipv6.subnet, -1)
-
-    def testGetNumHosts(self):
-        self.assertEqual(self.ipv4.numhosts, 256)
-        self.assertEqual(self.ipv4.subnet()[0].numhosts, 128)
-        self.assertEqual(self.ipv4.supernet().numhosts, 512)
-
-        self.assertEqual(self.ipv6.numhosts, 18446744073709551616)
-        self.assertEqual(self.ipv6.subnet()[0].numhosts, 9223372036854775808)
-        self.assertEqual(self.ipv6.supernet().numhosts, 36893488147419103232)
-
-    def testContains(self):
-        self.assertTrue(ipaddr.IPv4Network('1.2.3.128/25') in self.ipv4)
-        self.assertFalse(ipaddr.IPv4Network('1.2.4.1/24') in self.ipv4)
-        self.assertTrue(self.ipv4 in self.ipv4)
-        self.assertTrue(self.ipv6 in self.ipv6)
-        # We can test addresses and string as well.
-        addr1 = ipaddr.IPv4Address('1.2.3.37')
-        self.assertTrue(addr1 in self.ipv4)
-        # issue 61, bad network comparison on like-ip'd network objects
-        # with identical broadcast addresses.
-        self.assertFalse(ipaddr.IPv4Network('1.1.0.0/16').__contains__(
-                ipaddr.IPv4Network('1.0.0.0/15')))
-
-    def testBadAddress(self):
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
-                          'poop')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Network, '1.2.3.256')
-
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          'poopv6')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Network, '1.2.3.4/32/24')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Network, '10/8')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Network, '10/8')
-
-
-    def testBadNetMask(self):
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Network, '1.2.3.4/')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Network, '1.2.3.4/33')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Network, '1.2.3.4/254.254.255.256')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Network, '1.1.1.1/240.255.0.0')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv6Network, '::1/')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv6Network, '::1/129')
-
-    def testNth(self):
-        self.assertEqual(str(self.ipv4[5]), '1.2.3.5')
-        self.assertRaises(IndexError, self.ipv4.__getitem__, 256)
-
-        self.assertEqual(str(self.ipv6[5]),
-                         '2001:658:22a:cafe::5')
-
-    def testGetitem(self):
-        # http://code.google.com/p/ipaddr-py/issues/detail?id=15
-        addr = ipaddr.IPv4Network('172.31.255.128/255.255.255.240')
-        self.assertEqual(28, addr.prefixlen)
-        addr_list = list(addr)
-        self.assertEqual('172.31.255.128', str(addr_list[0]))
-        self.assertEqual('172.31.255.128', str(addr[0]))
-        self.assertEqual('172.31.255.143', str(addr_list[-1]))
-        self.assertEqual('172.31.255.143', str(addr[-1]))
-        self.assertEqual(addr_list[-1], addr[-1])
-
-    def testEqual(self):
-        self.assertTrue(self.ipv4 == ipaddr.IPv4Network('1.2.3.4/24'))
-        self.assertFalse(self.ipv4 == ipaddr.IPv4Network('1.2.3.4/23'))
-        self.assertFalse(self.ipv4 == ipaddr.IPv6Network('::1.2.3.4/24'))
-        self.assertFalse(self.ipv4 == '')
-        self.assertFalse(self.ipv4 == [])
-        self.assertFalse(self.ipv4 == 2)
-        self.assertTrue(ipaddr.IPNetwork('1.1.1.1/32') ==
-                        ipaddr.IPAddress('1.1.1.1'))
-        self.assertTrue(ipaddr.IPNetwork('1.1.1.1/24') ==
-                        ipaddr.IPAddress('1.1.1.1'))
-        self.assertFalse(ipaddr.IPNetwork('1.1.1.0/24') ==
-                         ipaddr.IPAddress('1.1.1.1'))
-
-        self.assertTrue(self.ipv6 ==
-            ipaddr.IPv6Network('2001:658:22a:cafe:200::1/64'))
-        self.assertTrue(ipaddr.IPNetwork('::1/128') ==
-                        ipaddr.IPAddress('::1'))
-        self.assertTrue(ipaddr.IPNetwork('::1/127') ==
-                        ipaddr.IPAddress('::1'))
-        self.assertFalse(ipaddr.IPNetwork('::0/127') ==
-                         ipaddr.IPAddress('::1'))
-        self.assertFalse(self.ipv6 ==
-            ipaddr.IPv6Network('2001:658:22a:cafe:200::1/63'))
-        self.assertFalse(self.ipv6 == ipaddr.IPv4Network('1.2.3.4/23'))
-        self.assertFalse(self.ipv6 == '')
-        self.assertFalse(self.ipv6 == [])
-        self.assertFalse(self.ipv6 == 2)
-
-    def testNotEqual(self):
-        self.assertFalse(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/24'))
-        self.assertTrue(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/23'))
-        self.assertTrue(self.ipv4 != ipaddr.IPv6Network('::1.2.3.4/24'))
-        self.assertTrue(self.ipv4 != '')
-        self.assertTrue(self.ipv4 != [])
-        self.assertTrue(self.ipv4 != 2)
-
-        addr2 = ipaddr.IPAddress('2001:658:22a:cafe:200::1')
-        self.assertFalse(self.ipv6 !=
-            ipaddr.IPv6Network('2001:658:22a:cafe:200::1/64'))
-        self.assertTrue(self.ipv6 !=
-            ipaddr.IPv6Network('2001:658:22a:cafe:200::1/63'))
-        self.assertTrue(self.ipv6 != ipaddr.IPv4Network('1.2.3.4/23'))
-        self.assertTrue(self.ipv6 != '')
-        self.assertTrue(self.ipv6 != [])
-        self.assertTrue(self.ipv6 != 2)
-
-    def testSlash32Constructor(self):
-        self.assertEqual(str(ipaddr.IPv4Network('1.2.3.4/255.255.255.255')),
-                          '1.2.3.4/32')
-
-    def testSlash128Constructor(self):
-        self.assertEqual(str(ipaddr.IPv6Network('::1/128')),
-                                  '::1/128')
-
-    def testSlash0Constructor(self):
-        self.assertEqual(str(ipaddr.IPv4Network('1.2.3.4/0.0.0.0')),
-                          '1.2.3.4/0')
-
-    def testCollapsing(self):
-        # test only IP addresses including some duplicates
-        ip1 = ipaddr.IPv4Address('1.1.1.0')
-        ip2 = ipaddr.IPv4Address('1.1.1.1')
-        ip3 = ipaddr.IPv4Address('1.1.1.2')
-        ip4 = ipaddr.IPv4Address('1.1.1.3')
-        ip5 = ipaddr.IPv4Address('1.1.1.4')
-        ip6 = ipaddr.IPv4Address('1.1.1.0')
-        # check that addreses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.1.0/30'),
-                                     ipaddr.IPv4Network('1.1.1.4/32')])
-
-        # test a mix of IP addresses and networks including some duplicates
-        ip1 = ipaddr.IPv4Address('1.1.1.0')
-        ip2 = ipaddr.IPv4Address('1.1.1.1')
-        ip3 = ipaddr.IPv4Address('1.1.1.2')
-        ip4 = ipaddr.IPv4Address('1.1.1.3')
-        ip5 = ipaddr.IPv4Network('1.1.1.4/30')
-        ip6 = ipaddr.IPv4Network('1.1.1.4/30')
-        # check that addreses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip5, ip1, ip2, ip3, ip4, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.1.0/29')])
-
-        # test only IP networks
-        ip1 = ipaddr.IPv4Network('1.1.0.0/24')
-        ip2 = ipaddr.IPv4Network('1.1.1.0/24')
-        ip3 = ipaddr.IPv4Network('1.1.2.0/24')
-        ip4 = ipaddr.IPv4Network('1.1.3.0/24')
-        ip5 = ipaddr.IPv4Network('1.1.4.0/24')
-        # stored in no particular order b/c we want CollapseAddr to call [].sort
-        ip6 = ipaddr.IPv4Network('1.1.0.0/22')
-        # check that addreses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.0.0/22'),
-                                     ipaddr.IPv4Network('1.1.4.0/24')])
-
-        # test that two addresses are supernet'ed properly
-        collapsed = ipaddr.collapse_address_list([ip1, ip2])
-        self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.0.0/23')])
-
-        # test same IP networks
-        ip_same1 = ip_same2 = ipaddr.IPv4Network('1.1.1.1/32')
-        self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
-                         [ip_same1])
-
-        # test same IP addresses
-        ip_same1 = ip_same2 = ipaddr.IPv4Address('1.1.1.1')
-        self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
-                         [ipaddr.IPNetwork('1.1.1.1/32')])
-        ip1 = ipaddr.IPv6Network('::2001:1/100')
-        ip2 = ipaddr.IPv6Network('::2002:1/120')
-        ip3 = ipaddr.IPv6Network('::2001:1/96')
-        # test that ipv6 addresses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3])
-        self.assertEqual(collapsed, [ip3])
-
-        # the toejam test
-        ip1 = ipaddr.IPAddress('1.1.1.1')
-        ip2 = ipaddr.IPAddress('::1')
-        self.assertRaises(TypeError, ipaddr.collapse_address_list,
-                          [ip1, ip2])
-
-    def testSummarizing(self):
-        #ip = ipaddr.IPAddress
-        #ipnet = ipaddr.IPNetwork
-        summarize = ipaddr.summarize_address_range
-        ip1 = ipaddr.IPAddress('1.1.1.0')
-        ip2 = ipaddr.IPAddress('1.1.1.255')
-        # test a /24 is sumamrized properly
-        self.assertEqual(summarize(ip1, ip2)[0], ipaddr.IPNetwork('1.1.1.0/24'))
-        # test an  IPv4 range that isn't on a network byte boundary
-        ip2 = ipaddr.IPAddress('1.1.1.8')
-        self.assertEqual(summarize(ip1, ip2), [ipaddr.IPNetwork('1.1.1.0/29'),
-                                               ipaddr.IPNetwork('1.1.1.8')])
-
-        ip1 = ipaddr.IPAddress('1::')
-        ip2 = ipaddr.IPAddress('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
-        # test a IPv6 is sumamrized properly
-        self.assertEqual(summarize(ip1, ip2)[0], ipaddr.IPNetwork('1::/16'))
-        # test an IPv6 range that isn't on a network byte boundary
-        ip2 = ipaddr.IPAddress('2::')
-        self.assertEqual(summarize(ip1, ip2), [ipaddr.IPNetwork('1::/16'),
-                                               ipaddr.IPNetwork('2::/128')])
-
-        # test exception raised when first is greater than last
-        self.assertRaises(ValueError, summarize, ipaddr.IPAddress('1.1.1.0'),
-            ipaddr.IPAddress('1.1.0.0'))
-        # test exception raised when first and last aren't IP addresses
-        self.assertRaises(TypeError, summarize,
-                          ipaddr.IPNetwork('1.1.1.0'),
-                          ipaddr.IPNetwork('1.1.0.0'))
-        self.assertRaises(TypeError, summarize,
-            ipaddr.IPNetwork('1.1.1.0'), ipaddr.IPNetwork('1.1.0.0'))
-        # test exception raised when first and last are not same version
-        self.assertRaises(TypeError, summarize, ipaddr.IPAddress('::'),
-            ipaddr.IPNetwork('1.1.0.0'))
-
-    def testAddressComparison(self):
-        self.assertTrue(ipaddr.IPAddress('1.1.1.1') <=
-                        ipaddr.IPAddress('1.1.1.1'))
-        self.assertTrue(ipaddr.IPAddress('1.1.1.1') <=
-                        ipaddr.IPAddress('1.1.1.2'))
-        self.assertTrue(ipaddr.IPAddress('::1') <= ipaddr.IPAddress('::1'))
-        self.assertTrue(ipaddr.IPAddress('::1') <= ipaddr.IPAddress('::2'))
-
-    def testNetworkComparison(self):
-        # ip1 and ip2 have the same network address
-        ip1 = ipaddr.IPv4Network('1.1.1.0/24')
-        ip2 = ipaddr.IPv4Network('1.1.1.1/24')
-        ip3 = ipaddr.IPv4Network('1.1.2.0/24')
-
-        self.assertTrue(ip1 < ip3)
-        self.assertTrue(ip3 > ip2)
-
-        self.assertEqual(ip1.compare_networks(ip2), 0)
-        self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
-        self.assertEqual(ip1.compare_networks(ip3), -1)
-        self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
-
-        ip1 = ipaddr.IPv6Network('2001::2000/96')
-        ip2 = ipaddr.IPv6Network('2001::2001/96')
-        ip3 = ipaddr.IPv6Network('2001:ffff::2000/96')
-
-        self.assertTrue(ip1 < ip3)
-        self.assertTrue(ip3 > ip2)
-        self.assertEqual(ip1.compare_networks(ip2), 0)
-        self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
-        self.assertEqual(ip1.compare_networks(ip3), -1)
-        self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
-
-        # Test comparing different protocols.
-        # Should always raise a TypeError.
-        ipv6 = ipaddr.IPv6Network('::/0')
-        ipv4 = ipaddr.IPv4Network('0.0.0.0/0')
-        self.assertRaises(TypeError, ipv4.__lt__, ipv6)
-        self.assertRaises(TypeError, ipv4.__gt__, ipv6)
-        self.assertRaises(TypeError, ipv6.__lt__, ipv4)
-        self.assertRaises(TypeError, ipv6.__gt__, ipv4)
-
-        # Regression test for issue 19.
-        ip1 = ipaddr.IPNetwork('10.1.2.128/25')
-        self.assertFalse(ip1 < ip1)
-        self.assertFalse(ip1 > ip1)
-        ip2 = ipaddr.IPNetwork('10.1.3.0/24')
-        self.assertTrue(ip1 < ip2)
-        self.assertFalse(ip2 < ip1)
-        self.assertFalse(ip1 > ip2)
-        self.assertTrue(ip2 > ip1)
-        ip3 = ipaddr.IPNetwork('10.1.3.0/25')
-        self.assertTrue(ip2 < ip3)
-        self.assertFalse(ip3 < ip2)
-        self.assertFalse(ip2 > ip3)
-        self.assertTrue(ip3 > ip2)
-
-        # Regression test for issue 28.
-        ip1 = ipaddr.IPNetwork('10.10.10.0/31')
-        ip2 = ipaddr.IPNetwork('10.10.10.0')
-        ip3 = ipaddr.IPNetwork('10.10.10.2/31')
-        ip4 = ipaddr.IPNetwork('10.10.10.2')
-        sorted = [ip1, ip2, ip3, ip4]
-        unsorted = [ip2, ip4, ip1, ip3]
-        unsorted.sort()
-        self.assertEqual(sorted, unsorted)
-        unsorted = [ip4, ip1, ip3, ip2]
-        unsorted.sort()
-        self.assertEqual(sorted, unsorted)
-        self.assertRaises(TypeError, ip1.__lt__, ipaddr.IPAddress('10.10.10.0'))
-        self.assertRaises(TypeError, ip2.__lt__, ipaddr.IPAddress('10.10.10.0'))
-
-        # <=, >=
-        self.assertTrue(ipaddr.IPNetwork('1.1.1.1') <=
-                        ipaddr.IPNetwork('1.1.1.1'))
-        self.assertTrue(ipaddr.IPNetwork('1.1.1.1') <=
-                        ipaddr.IPNetwork('1.1.1.2'))
-        self.assertFalse(ipaddr.IPNetwork('1.1.1.2') <=
-                        ipaddr.IPNetwork('1.1.1.1'))
-        self.assertTrue(ipaddr.IPNetwork('::1') <= ipaddr.IPNetwork('::1'))
-        self.assertTrue(ipaddr.IPNetwork('::1') <= ipaddr.IPNetwork('::2'))
-        self.assertFalse(ipaddr.IPNetwork('::2') <= ipaddr.IPNetwork('::1'))
-
-    def testStrictNetworks(self):
-        self.assertRaises(ValueError, ipaddr.IPNetwork, '192.168.1.1/24',
-                          strict=True)
-        self.assertRaises(ValueError, ipaddr.IPNetwork, '::1/120', strict=True)
-
-    def testOverlaps(self):
-        other = ipaddr.IPv4Network('1.2.3.0/30')
-        other2 = ipaddr.IPv4Network('1.2.2.0/24')
-        other3 = ipaddr.IPv4Network('1.2.2.64/26')
-        self.assertTrue(self.ipv4.overlaps(other))
-        self.assertFalse(self.ipv4.overlaps(other2))
-        self.assertTrue(other2.overlaps(other3))
-
-    def testEmbeddedIpv4(self):
-        ipv4_string = '192.168.0.1'
-        ipv4 = ipaddr.IPv4Network(ipv4_string)
-        v4compat_ipv6 = ipaddr.IPv6Network('::%s' % ipv4_string)
-        self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
-        v4mapped_ipv6 = ipaddr.IPv6Network('::ffff:%s' % ipv4_string)
-        self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
-                          '2001:1.1.1.1:1.1.1.1')
-
-    # Issue 67: IPv6 with embedded IPv4 address not recognized.
-    def testIPv6AddressTooLarge(self):
-        # RFC4291 2.5.5.2
-        self.assertEqual(ipaddr.IPAddress('::FFFF:192.0.2.1'),
-                          ipaddr.IPAddress('::FFFF:c000:201'))
-        # RFC4291 2.2 (part 3) x::d.d.d.d 
-        self.assertEqual(ipaddr.IPAddress('FFFF::192.0.2.1'),
-                          ipaddr.IPAddress('FFFF::c000:201'))
-
-    def testIPVersion(self):
-        self.assertEqual(self.ipv4.version, 4)
-        self.assertEqual(self.ipv6.version, 6)
-
-    def testMaxPrefixLength(self):
-        self.assertEqual(self.ipv4.max_prefixlen, 32)
-        self.assertEqual(self.ipv6.max_prefixlen, 128)
-
-    def testPacked(self):
-        self.assertEqual(self.ipv4.packed,
-                         _cb('\x01\x02\x03\x04'))
-        self.assertEqual(ipaddr.IPv4Network('255.254.253.252').packed,
-                         _cb('\xff\xfe\xfd\xfc'))
-        self.assertEqual(self.ipv6.packed,
-                         _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
-                             '\x02\x00\x00\x00\x00\x00\x00\x01'))
-        self.assertEqual(ipaddr.IPv6Network('ffff:2:3:4:ffff::').packed,
-                         _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
-                            + '\x00' * 6))
-        self.assertEqual(ipaddr.IPv6Network('::1:0:0:0:0').packed,
-                         _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
-
-    def testIpStrFromPrefixlen(self):
-        ipv4 = ipaddr.IPv4Network('1.2.3.4/24')
-        self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0')
-        self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240')
-
-    def testIpType(self):
-        ipv4net = ipaddr.IPNetwork('1.2.3.4')
-        ipv4addr = ipaddr.IPAddress('1.2.3.4')
-        ipv6net = ipaddr.IPNetwork('::1.2.3.4')
-        ipv6addr = ipaddr.IPAddress('::1.2.3.4')
-        self.assertEqual(ipaddr.IPv4Network, type(ipv4net))
-        self.assertEqual(ipaddr.IPv4Address, type(ipv4addr))
-        self.assertEqual(ipaddr.IPv6Network, type(ipv6net))
-        self.assertEqual(ipaddr.IPv6Address, type(ipv6addr))
-
-    def testReservedIpv4(self):
-        # test networks
-        self.assertEqual(True, ipaddr.IPNetwork('224.1.1.1/31').is_multicast)
-        self.assertEqual(False, ipaddr.IPNetwork('240.0.0.0').is_multicast)
-
-        self.assertEqual(True, ipaddr.IPNetwork('192.168.1.1/17').is_private)
-        self.assertEqual(False, ipaddr.IPNetwork('192.169.0.0').is_private)
-        self.assertEqual(True, ipaddr.IPNetwork('10.255.255.255').is_private)
-        self.assertEqual(False, ipaddr.IPNetwork('11.0.0.0').is_private)
-        self.assertEqual(True, ipaddr.IPNetwork('172.31.255.255').is_private)
-        self.assertEqual(False, ipaddr.IPNetwork('172.32.0.0').is_private)
-
-        self.assertEqual(True,
-                          ipaddr.IPNetwork('169.254.100.200/24').is_link_local)
-        self.assertEqual(False,
-                          ipaddr.IPNetwork('169.255.100.200/24').is_link_local)
-
-        self.assertEqual(True,
-                          ipaddr.IPNetwork('127.100.200.254/32').is_loopback)
-        self.assertEqual(True, ipaddr.IPNetwork('127.42.0.0/16').is_loopback)
-        self.assertEqual(False, ipaddr.IPNetwork('128.0.0.0').is_loopback)
-
-        # test addresses
-        self.assertEqual(True, ipaddr.IPAddress('224.1.1.1').is_multicast)
-        self.assertEqual(False, ipaddr.IPAddress('240.0.0.0').is_multicast)
-
-        self.assertEqual(True, ipaddr.IPAddress('192.168.1.1').is_private)
-        self.assertEqual(False, ipaddr.IPAddress('192.169.0.0').is_private)
-        self.assertEqual(True, ipaddr.IPAddress('10.255.255.255').is_private)
-        self.assertEqual(False, ipaddr.IPAddress('11.0.0.0').is_private)
-        self.assertEqual(True, ipaddr.IPAddress('172.31.255.255').is_private)
-        self.assertEqual(False, ipaddr.IPAddress('172.32.0.0').is_private)
-
-        self.assertEqual(True,
-                          ipaddr.IPAddress('169.254.100.200').is_link_local)
-        self.assertEqual(False,
-                          ipaddr.IPAddress('169.255.100.200').is_link_local)
-
-        self.assertEqual(True,
-                          ipaddr.IPAddress('127.100.200.254').is_loopback)
-        self.assertEqual(True, ipaddr.IPAddress('127.42.0.0').is_loopback)
-        self.assertEqual(False, ipaddr.IPAddress('128.0.0.0').is_loopback)
-        self.assertEqual(True, ipaddr.IPNetwork('0.0.0.0').is_unspecified)
-
-    def testReservedIpv6(self):
-
-        self.assertEqual(True, ipaddr.IPNetwork('ffff::').is_multicast)
-        self.assertEqual(True, ipaddr.IPNetwork(2**128-1).is_multicast)
-        self.assertEqual(True, ipaddr.IPNetwork('ff00::').is_multicast)
-        self.assertEqual(False, ipaddr.IPNetwork('fdff::').is_multicast)
-
-        self.assertEqual(True, ipaddr.IPNetwork('fecf::').is_site_local)
-        self.assertEqual(True, ipaddr.IPNetwork(
-                'feff:ffff:ffff:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.IPNetwork('fbf:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.IPNetwork('ff00::').is_site_local)
-
-        self.assertEqual(True, ipaddr.IPNetwork('fc00::').is_private)
-        self.assertEqual(True, ipaddr.IPNetwork(
-                'fc00:ffff:ffff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.IPNetwork('fbff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.IPNetwork('fe00::').is_private)
-
-        self.assertEqual(True, ipaddr.IPNetwork('fea0::').is_link_local)
-        self.assertEqual(True, ipaddr.IPNetwork('febf:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.IPNetwork('fe7f:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.IPNetwork('fec0::').is_link_local)
-
-        self.assertEqual(True, ipaddr.IPNetwork('0:0::0:01').is_loopback)
-        self.assertEqual(False, ipaddr.IPNetwork('::1/127').is_loopback)
-        self.assertEqual(False, ipaddr.IPNetwork('::').is_loopback)
-        self.assertEqual(False, ipaddr.IPNetwork('::2').is_loopback)
-
-        self.assertEqual(True, ipaddr.IPNetwork('0::0').is_unspecified)
-        self.assertEqual(False, ipaddr.IPNetwork('::1').is_unspecified)
-        self.assertEqual(False, ipaddr.IPNetwork('::/127').is_unspecified)
-
-        # test addresses
-        self.assertEqual(True, ipaddr.IPAddress('ffff::').is_multicast)
-        self.assertEqual(True, ipaddr.IPAddress(2**128-1).is_multicast)
-        self.assertEqual(True, ipaddr.IPAddress('ff00::').is_multicast)
-        self.assertEqual(False, ipaddr.IPAddress('fdff::').is_multicast)
-
-        self.assertEqual(True, ipaddr.IPAddress('fecf::').is_site_local)
-        self.assertEqual(True, ipaddr.IPAddress(
-                'feff:ffff:ffff:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.IPAddress('fbf:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.IPAddress('ff00::').is_site_local)
-
-        self.assertEqual(True, ipaddr.IPAddress('fc00::').is_private)
-        self.assertEqual(True, ipaddr.IPAddress(
-                'fc00:ffff:ffff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.IPAddress('fbff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.IPAddress('fe00::').is_private)
-
-        self.assertEqual(True, ipaddr.IPAddress('fea0::').is_link_local)
-        self.assertEqual(True, ipaddr.IPAddress('febf:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.IPAddress('fe7f:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.IPAddress('fec0::').is_link_local)
-
-        self.assertEqual(True, ipaddr.IPAddress('0:0::0:01').is_loopback)
-        self.assertEqual(True, ipaddr.IPAddress('::1').is_loopback)
-        self.assertEqual(False, ipaddr.IPAddress('::2').is_loopback)
-
-        self.assertEqual(True, ipaddr.IPAddress('0::0').is_unspecified)
-        self.assertEqual(False, ipaddr.IPAddress('::1').is_unspecified)
-
-        # some generic IETF reserved addresses
-        self.assertEqual(True, ipaddr.IPAddress('100::').is_reserved)
-        self.assertEqual(True, ipaddr.IPNetwork('4000::1/128').is_reserved)
-
-    def testIpv4Mapped(self):
-        self.assertEqual(ipaddr.IPAddress('::ffff:192.168.1.1').ipv4_mapped,
-                         ipaddr.IPAddress('192.168.1.1'))
-        self.assertEqual(ipaddr.IPAddress('::c0a8:101').ipv4_mapped, None)
-        self.assertEqual(ipaddr.IPAddress('::ffff:c0a8:101').ipv4_mapped,
-                         ipaddr.IPAddress('192.168.1.1'))
-
-    def testAddrExclude(self):
-        addr1 = ipaddr.IPNetwork('10.1.1.0/24')
-        addr2 = ipaddr.IPNetwork('10.1.1.0/26')
-        addr3 = ipaddr.IPNetwork('10.2.1.0/24')
-        addr4 = ipaddr.IPAddress('10.1.1.0')
-        self.assertEqual(addr1.address_exclude(addr2),
-                         [ipaddr.IPNetwork('10.1.1.64/26'),
-                          ipaddr.IPNetwork('10.1.1.128/25')])
-        self.assertRaises(ValueError, addr1.address_exclude, addr3)
-        self.assertRaises(TypeError, addr1.address_exclude, addr4)
-        self.assertEqual(addr1.address_exclude(addr1), [])
-
-    def testHash(self):
-        self.assertEqual(hash(ipaddr.IPNetwork('10.1.1.0/24')),
-                          hash(ipaddr.IPNetwork('10.1.1.0/24')))
-        self.assertEqual(hash(ipaddr.IPAddress('10.1.1.0')),
-                          hash(ipaddr.IPAddress('10.1.1.0')))
-        # i70
-        self.assertEqual(hash(ipaddr.IPAddress('1.2.3.4')),
-                          hash(ipaddr.IPAddress(
-                    long(ipaddr.IPAddress('1.2.3.4')._ip))))
-        ip1 = ipaddr.IPAddress('10.1.1.0')
-        ip2 = ipaddr.IPAddress('1::')
-        dummy = {}
-        dummy[self.ipv4] = None
-        dummy[self.ipv6] = None
-        dummy[ip1] = None
-        dummy[ip2] = None
-        self.assertTrue(self.ipv4 in dummy)
-        self.assertTrue(ip2 in dummy)
-
-    def testCopyConstructor(self):
-        addr1 = ipaddr.IPNetwork('10.1.1.0/24')
-        addr2 = ipaddr.IPNetwork(addr1)
-        addr3 = ipaddr.IPNetwork('2001:658:22a:cafe:200::1/64')
-        addr4 = ipaddr.IPNetwork(addr3)
-        addr5 = ipaddr.IPv4Address('1.1.1.1')
-        addr6 = ipaddr.IPv6Address('2001:658:22a:cafe:200::1')
-
-        self.assertEqual(addr1, addr2)
-        self.assertEqual(addr3, addr4)
-        self.assertEqual(addr5, ipaddr.IPv4Address(addr5))
-        self.assertEqual(addr6, ipaddr.IPv6Address(addr6))
-
-    def testCompressIPv6Address(self):
-        test_addresses = {
-            '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
-            '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
-            '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
-            '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
-            '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
-            '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
-            '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
-            '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
-            '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
-            '0:0:0:0:0:0:0:0': '::/128',
-            '0:0:0:0:0:0:0:0/0': '::/0',
-            '0:0:0:0:0:0:0:1': '::1/128',
-            '2001:0658:022a:cafe:0000:0000:0000:0000/66':
-            '2001:658:22a:cafe::/66',
-            '::1.2.3.4': '::102:304/128',
-            '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
-            '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
-            '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
-            '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
-            '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
-            }
-        for uncompressed, compressed in test_addresses.items():
-            self.assertEqual(compressed, str(ipaddr.IPv6Network(uncompressed)))
-
-    def testExplodeShortHandIpStr(self):
-        addr1 = ipaddr.IPv6Network('2001::1')
-        addr2 = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
-        self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001',
-                         addr1._explode_shorthand_ip_string(str(addr1.ip)))
-        self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001',
-                         ipaddr.IPv6Network('::1/128').exploded)
-        # issue 77
-        self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
-                         addr2.exploded)
-
-    def testIntRepresentation(self):
-        self.assertEqual(16909060, int(self.ipv4))
-        self.assertEqual(42540616829182469433547762482097946625, int(self.ipv6))
-
-    def testHexRepresentation(self):
-        self.assertEqual(hex(0x1020304),
-                         hex(self.ipv4))
-
-        self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
-                         hex(self.ipv6))
-
-    # backwards compatibility
-    def testBackwardsCompability(self):
-        self.assertEqual(ipaddr.CollapseAddrList(
-            [ipaddr.IPNetwork('1.1.0.0/24'), ipaddr.IPNetwork('1.1.1.0/24')]),
-                         [ipaddr.IPNetwork('1.1.0.0/23')])
-
-        self.assertEqual(ipaddr.IPNetwork('::42:0/112').AddressExclude(
-            ipaddr.IPNetwork('::42:8000/113')),
-                         [ipaddr.IPNetwork('::42:0/113')])
-
-        self.assertTrue(ipaddr.IPNetwork('1::/8').CompareNetworks(
-            ipaddr.IPNetwork('2::/9')) < 0)
-
-        self.assertEqual(ipaddr.IPNetwork('1::/16').Contains(
-            ipaddr.IPNetwork('2::/16')), False)
-
-        self.assertEqual(ipaddr.IPNetwork('0.0.0.0/0').Subnet(),
-                         [ipaddr.IPNetwork('0.0.0.0/1'),
-                          ipaddr.IPNetwork('128.0.0.0/1')])
-        self.assertEqual(ipaddr.IPNetwork('::/127').Subnet(),
-                         [ipaddr.IPNetwork('::/128'),
-                          ipaddr.IPNetwork('::1/128')])
-
-        self.assertEqual(ipaddr.IPNetwork('1.0.0.0/32').Supernet(),
-                         ipaddr.IPNetwork('1.0.0.0/31'))
-        self.assertEqual(ipaddr.IPNetwork('::/121').Supernet(),
-                         ipaddr.IPNetwork('::/120'))
-
-        self.assertEqual(ipaddr.IPNetwork('10.0.0.2').IsRFC1918(), True)
-        self.assertEqual(ipaddr.IPNetwork('10.0.0.0').IsMulticast(), False)
-        self.assertEqual(ipaddr.IPNetwork('127.255.255.255').IsLoopback(), True)
-        self.assertEqual(ipaddr.IPNetwork('169.255.255.255').IsLinkLocal(),
-                         False)
-
-    def testForceVersion(self):
-        self.assertEqual(ipaddr.IPNetwork(1).version, 4)
-        self.assertEqual(ipaddr.IPNetwork(1, version=6).version, 6)
-
-    def testWithStar(self):
-        self.assertEqual(str(self.ipv4.with_prefixlen), "1.2.3.4/24")
-        self.assertEqual(str(self.ipv4.with_netmask), "1.2.3.4/255.255.255.0")
-        self.assertEqual(str(self.ipv4.with_hostmask), "1.2.3.4/0.0.0.255")
-
-        self.assertEqual(str(self.ipv6.with_prefixlen),
-                         '2001:658:22a:cafe:200::1/64')
-        # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
-        # subnets
-        self.assertEqual(str(self.ipv6.with_netmask),
-                         '2001:658:22a:cafe:200::1/64')
-        # this probably don't make much sense, but it's included for
-        # compatibility with ipv4
-        self.assertEqual(str(self.ipv6.with_hostmask),
-                         '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
-
-    def testNetworkElementCaching(self):
-        # V4 - make sure we're empty
-        self.assertFalse(self.ipv4._cache.has_key('network'))
-        self.assertFalse(self.ipv4._cache.has_key('broadcast'))
-        self.assertFalse(self.ipv4._cache.has_key('hostmask'))
-
-        # V4 - populate and test
-        self.assertEqual(self.ipv4.network, ipaddr.IPv4Address('1.2.3.0'))
-        self.assertEqual(self.ipv4.broadcast, ipaddr.IPv4Address('1.2.3.255'))
-        self.assertEqual(self.ipv4.hostmask, ipaddr.IPv4Address('0.0.0.255'))
-
-        # V4 - check we're cached
-        self.assertTrue(self.ipv4._cache.has_key('network'))
-        self.assertTrue(self.ipv4._cache.has_key('broadcast'))
-        self.assertTrue(self.ipv4._cache.has_key('hostmask'))
-
-        # V6 - make sure we're empty
-        self.assertFalse(self.ipv6._cache.has_key('network'))
-        self.assertFalse(self.ipv6._cache.has_key('broadcast'))
-        self.assertFalse(self.ipv6._cache.has_key('hostmask'))
-
-        # V6 - populate and test
-        self.assertEqual(self.ipv6.network,
-                         ipaddr.IPv6Address('2001:658:22a:cafe::'))
-        self.assertEqual(self.ipv6.broadcast, ipaddr.IPv6Address(
-            '2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
-        self.assertEqual(self.ipv6.hostmask,
-                         ipaddr.IPv6Address('::ffff:ffff:ffff:ffff'))
-
-        # V6 - check we're cached
-        self.assertTrue(self.ipv6._cache.has_key('network'))
-        self.assertTrue(self.ipv6._cache.has_key('broadcast'))
-        self.assertTrue(self.ipv6._cache.has_key('hostmask'))
-
-    def testTeredo(self):
-        # stolen from wikipedia
-        server = ipaddr.IPv4Address('65.54.227.120')
-        client = ipaddr.IPv4Address('192.0.2.45')
-        teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
-        self.assertEqual((server, client),
-                         ipaddr.IPAddress(teredo_addr).teredo)
-        bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
-        self.assertFalse(ipaddr.IPAddress(bad_addr).teredo)
-        bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
-        self.assertFalse(ipaddr.IPAddress(bad_addr).teredo)
-
-        # i77
-        teredo_addr = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
-        self.assertEqual((ipaddr.IPv4Address('94.245.121.253'),
-                          ipaddr.IPv4Address('95.26.244.94')),
-                         teredo_addr.teredo)
-
-
-    def testsixtofour(self):
-        sixtofouraddr = ipaddr.IPAddress('2002:ac1d:2d64::1')
-        bad_addr = ipaddr.IPAddress('2000:ac1d:2d64::1')
-        self.assertEqual(ipaddr.IPv4Address('172.29.45.100'),
-                         sixtofouraddr.sixtofour)
-        self.assertFalse(bad_addr.sixtofour)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/contrib/ipaddr-py/setup.py b/contrib/ipaddr-py/setup.py
deleted file mode 100755
index 33564320e45..00000000000
--- a/contrib/ipaddr-py/setup.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from distutils.core import setup
-
-import ipaddr
-
-
-setup(name='ipaddr',
-      maintainer='Google',
-      maintainer_email='ipaddr-py-dev@googlegroups.com',
-      version=ipaddr.__version__,
-      url='http://code.google.com/p/ipaddr-py/',
-      license='Apache License, Version 2.0',
-      classifiers=[
-          'Development Status :: 5 - Production/Stable',
-          'Intended Audience :: Developers',
-          'License :: OSI Approved :: Apache Software License',
-          'Operating System :: OS Independent',
-          'Topic :: Internet',
-          'Topic :: Software Development :: Libraries',
-          'Topic :: System :: Networking'],
-      py_modules=['ipaddr'])
diff --git a/contrib/ipaddr-py/test-2to3.sh b/contrib/ipaddr-py/test-2to3.sh
deleted file mode 100755
index 408d665bcc2..00000000000
--- a/contrib/ipaddr-py/test-2to3.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-# Converts the python2 ipaddr files to python3 and runs the unit tests
-# with both python versions.
-
-mkdir -p 2to3output && \
-cp -f *.py 2to3output && \
-( cd 2to3output && 2to3 . | patch -p0 ) && \
-py3version=$(python3 --version 2>&1) && \
-echo -e "\nTesting with ${py3version}" && \
-python3 2to3output/ipaddr_test.py && \
-rm -r 2to3output && \
-pyversion=$(python --version 2>&1) && \
-echo -e "\nTesting with ${pyversion}" && \
-./ipaddr_test.py
diff --git a/contrib/macfuse/mount_darwin.c b/contrib/macfuse/mount_darwin.c
index f4ecacad86a..d1d1c34e761 100644
--- a/contrib/macfuse/mount_darwin.c
+++ b/contrib/macfuse/mount_darwin.c
@@ -34,9 +34,9 @@
 #include "fuse_param.h"
 #include "fuse_ioctl.h"
 
-#include "glusterfs.h"
-#include "logging.h"
-#include "common-utils.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/common-utils.h"
 
 #define GFFUSE_LOGERR(...) \
         gf_log ("glusterfs-fuse", GF_LOG_ERROR, ## __VA_ARGS__)
@@ -94,7 +94,7 @@ gf_fuse_mount (const char *mountpoint, char *fsname, char *mnt_param,
         }
 
         /* sysctlbyname() includes the trailing '\0' in version_len */
-        version_len_desired = strlen("2.x.y") + 1;
+        version_len_desired = sizeof ("2.x.y");
 
         if (version_len != version_len_desired) {
                 gf_log ("glusterfs-fuse", GF_LOG_ERROR,
diff --git a/contrib/stdlib/gf_mkostemp.c b/contrib/stdlib/gf_mkostemp.c
deleted file mode 100644
index 931249a4520..00000000000
--- a/contrib/stdlib/gf_mkostemp.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/* Borrowed from glibc-2.16/sysdeps/posix/tempname.c */
-
-/* Copyright (C) 1991-2001, 2006, 2007, 2009 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library 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
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <time.h>
-#include <inttypes.h>
-
-static const char letters[] =
-"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-
-/* Generate a temporary file name based on TMPL.  TMPL must match the
-   rules for mk[s]temp (i.e. end in "XXXXXX", possibly with a suffix).
-*/
-
-#if !defined(TMP_MAX)
-#define TMP_MAX 238328
-#endif
-
-int
-gf_mkostemp (char *tmpl, int suffixlen, int flags)
-{
-        int len;
-        char *XXXXXX;
-        static uint64_t value;
-        uint64_t random_time_bits;
-        unsigned int count;
-        int fd = -1;
-
-  /* A lower bound on the number of temporary files to attempt to
-     generate.  The maximum total number of temporary file names that
-     can exist for a given template is 62**6.  It should never be
-     necessary to try all these combinations.  Instead if a reasonable
-     number of names is tried (we define reasonable as 62**3) fail to
-     give the system administrator the chance to remove the problems.  */
-
-        unsigned int attempts = TMP_MAX; /* TMP_MAX == 62³ */
-
-        len = strlen (tmpl);
-        if (len < 6 + suffixlen || memcmp (&tmpl[len - 6 - suffixlen],
-                                           "XXXXXX", 6))
-                return -1;
-
-  /* This is where the Xs start.  */
-        XXXXXX = &tmpl[len - 6 - suffixlen];
-
-  /* Get some more or less random data.  */
-# if HAVE_GETTIMEOFDAY
-        struct timeval tv;
-        gettimeofday (&tv, NULL);
-        random_time_bits = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec;
-# else
-        random_time_bits = time (NULL);
-# endif
-
-        value += random_time_bits ^ getpid ();
-
-        for (count = 0; count < attempts; value += 7777, ++count) {
-                uint64_t v = value;
-
-                /* Fill in the random bits.  */
-                XXXXXX[0] = letters[v % 62];
-                v /= 62;
-                XXXXXX[1] = letters[v % 62];
-                v /= 62;
-                XXXXXX[2] = letters[v % 62];
-                v /= 62;
-                XXXXXX[3] = letters[v % 62];
-                v /= 62;
-                XXXXXX[4] = letters[v % 62];
-                v /= 62;
-                XXXXXX[5] = letters[v % 62];
-
-                fd = open (tmpl, (flags & ~O_ACCMODE)
-                           | O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
-
-                if (fd >= 0)
-                        return fd;
-                else if (errno != EEXIST)
-                        return -1;
-        }
-
-        /* We got out of the loop because we ran out of combinations to try.  */
-        return -1;
-}
diff --git a/contrib/sunrpc/xdr_sizeof.c b/contrib/sunrpc/xdr_sizeof.c
deleted file mode 100644
index ca1f7bf0a5e..00000000000
--- a/contrib/sunrpc/xdr_sizeof.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
- * Reserved.  This file contains Original Code and/or Modifications of
- * Original Code as defined in and that are subject to the Apple Public
- * Source License Version 1.1 (the "License").  You may not use this file
- * except in compliance with the License.  Please obtain a copy of the
- * License at http://www.apple.com/publicsource and read it before using
- * this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-/*
- * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
- * unrestricted use provided that this legend is included on all tape
- * media and as a part of the software program in whole or part.  Users
- * may copy or modify Sun RPC without charge, but are not authorized
- * to license or distribute it to anyone else except as part of a product or
- * program developed by the user.
- *
- * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
- * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
- *
- * Sun RPC is provided with no support and without any obligation on the
- * part of Sun Microsystems, Inc. to assist in its use, correction,
- * modification or enhancement.
- *
- * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
- * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
- * OR ANY PART THEREOF.
- *
- * In no event will Sun Microsystems, Inc. be liable for any lost revenue
- * or profits or other special, indirect and consequential damages, even if
- * Sun has been advised of the possibility of such damages.
- *
- * Sun Microsystems, Inc.
- * 2550 Garcia Avenue
- * Mountain View, California  94043
- */
-
-/*
- * xdr_sizeof.c
- *
- * Copyright 1990 Sun Microsystems, Inc.
- *
- * General purpose routine to see how much space something will use
- * when serialized using XDR.
- */
-
-#ifdef GF_DARWIN_HOST_OS
-
-#include <rpc/types.h>
-#include <rpc/xdr.h>
-#include <sys/types.h>
-#include <sys/cdefs.h>
-
-#include <stdlib.h>
-
-/* ARGSUSED */
-#ifdef GF_DARWIN_HOST_OS
-static bool_t
-x_putlong (XDR *xdrs, const int *longp)
-{
-        xdrs->x_handy += BYTES_PER_XDR_UNIT;
-        return TRUE;
-}
-
-#else
-static bool_t
-x_putlong (XDR *xdrs, const long *longp)
-{
-        xdrs->x_handy += BYTES_PER_XDR_UNIT;
-        return TRUE;
-}
-#endif
-
-/* ARGSUSED */
-static bool_t
-x_putbytes (XDR *xdrs, const char *bp, u_int len)
-{
-        xdrs->x_handy += len;
-        return TRUE;
-}
-
-#ifdef GF_DARWIN_HOST_OS
-static u_int
-x_getpostn (XDR *xdrs)
-{
-        return xdrs->x_handy;
-}
-#else
-static u_int
-x_getpostn (const XDR *xdrs)
-{
-        return xdrs->x_handy;
-}
-#endif
-
-/* ARGSUSED */
-static bool_t
-x_setpostn (XDR *xdrs, u_int len)
-{
-        /* This is not allowed */
-        return FALSE;
-}
-
-static int32_t *
-x_inline (XDR *xdrs, u_int len)
-{
-        if (len == 0)
-                return NULL;
-        if (xdrs->x_op != XDR_ENCODE)
-                return NULL;
-        if (len < (u_int) (long int) xdrs->x_base)
-        {
-                /* x_private was already allocated */
-                xdrs->x_handy += len;
-                return (int32_t *) xdrs->x_private;
-        }
-        else
-        {
-                /* Free the earlier space and allocate new area */
-                free (xdrs->x_private);
-                if ((xdrs->x_private = (caddr_t) malloc (len)) == NULL)
-                {
-                        xdrs->x_base = 0;
-                        return NULL;
-                }
-                xdrs->x_base = (void *) (long) len;
-                xdrs->x_handy += len;
-                return (int32_t *) xdrs->x_private;
-        }
-}
-
-static int
-harmless (void)
-{
-        /* Always return FALSE/NULL, as the case may be */
-        return 0;
-}
-
-static void
-x_destroy (XDR *xdrs)
-{
-        xdrs->x_handy = 0;
-        xdrs->x_base = 0;
-        if (xdrs->x_private)
-        {
-                free (xdrs->x_private);
-                xdrs->x_private = NULL;
-        }
-        return;
-}
-
-unsigned long
-xdr_sizeof (xdrproc_t func, void *data)
-{
-        XDR x;
-        struct xdr_ops ops;
-        bool_t stat;
-
-#ifdef GF_DARWIN_HOST_OS
-        typedef bool_t (*dummyfunc1) (XDR *, int *);
-#else
-        typedef bool_t (*dummyfunc1) (XDR *, long *);
-#endif
-        typedef bool_t (*dummyfunc2) (XDR *, caddr_t, u_int);
-
-        ops.x_putlong = x_putlong;
-        ops.x_putbytes = x_putbytes;
-        ops.x_inline = x_inline;
-        ops.x_getpostn = x_getpostn;
-        ops.x_setpostn = x_setpostn;
-        ops.x_destroy = x_destroy;
-
-        /* the other harmless ones */
-        ops.x_getlong = (dummyfunc1) harmless;
-        ops.x_getbytes = (dummyfunc2) harmless;
-
-        x.x_op = XDR_ENCODE;
-        x.x_ops = &ops;
-        x.x_handy = 0;
-        x.x_private = (caddr_t) NULL;
-        x.x_base = (caddr_t) 0;
-
-        stat = func (&x, data, 0);
-        if (x.x_private)
-                free (x.x_private);
-        return (stat == TRUE ? (unsigned) x.x_handy : 0);
-}
-#endif /* GF_DARWIN_HOST_OS */
diff --git a/contrib/timer-wheel/timer-wheel.c b/contrib/timer-wheel/timer-wheel.c
index cfbd74e166f..58e0607bf0c 100644
--- a/contrib/timer-wheel/timer-wheel.c
+++ b/contrib/timer-wheel/timer-wheel.c
@@ -159,7 +159,14 @@ run_timers (struct tvec_base *base)
                         data = timer->data;
 
                         __gf_tw_detach_timer (timer);
-                        fn (timer, data, call_time);
+                        pthread_spin_unlock(&base->lock);
+                        {
+                            /* It is required to run the actual function outside
+                               of the locked zone, so we don't bother about
+                               locked operations inside that function */
+                            fn(timer, data, call_time);
+                        }
+                        pthread_spin_lock(&base->lock);
                 }
         }
         pthread_spin_unlock (&base->lock);
diff --git a/contrib/timer-wheel/timer-wheel.h b/contrib/timer-wheel/timer-wheel.h
index baa029ebb30..5637735ec22 100644
--- a/contrib/timer-wheel/timer-wheel.h
+++ b/contrib/timer-wheel/timer-wheel.h
@@ -17,9 +17,9 @@
 #ifndef __TIMER_WHEEL_H
 #define __TIMER_WHEEL_H
 
-#include "locking.h"
+#include "glusterfs/locking.h"
 
-#include "list.h"
+#include "glusterfs/list.h"
 
 #define TVR_BITS  8
 #define TVN_BITS  6
diff --git a/contrib/umountd/umountd.c b/contrib/umountd/umountd.c
index 0d2c6f20b60..3f933ecb554 100644
--- a/contrib/umountd/umountd.c
+++ b/contrib/umountd/umountd.c
@@ -23,11 +23,11 @@
 #include <sys/stat.h>
 #include <sys/mount.h>
 
-#include "glusterfs.h"
-#include "globals.h"
-#include "logging.h"
-#include "syscall.h"
-#include "mem-types.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/globals.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/mem-types.h"
 
 static void
 usage (void)
@@ -56,7 +56,8 @@ sanity_check (char *path, dev_t *devp)
                         break;
                 default:
                         gf_log ("umountd", GF_LOG_ERROR,
-                                "Cannot access %s\n", path, strerror (errno));
+                                "Cannot access %s: %s\n",
+                                path, strerror (errno));
                         goto out;
                 }
         }
@@ -65,12 +66,13 @@ sanity_check (char *path, dev_t *devp)
         if (*devp == -1 && ret == 0)
                 *devp = st.st_dev;
 
-        strncpy (pathtmp, path, PATH_MAX);
+        snprintf (pathtmp, PATH_MAX, "%s", path);
         parent = dirname (pathtmp);
 
         if (stat (parent, &parent_st) != 0) {
                 gf_log ("umountd", GF_LOG_ERROR,
-                        "Cannot access %s\n", parent, strerror (errno));
+                        "Cannot access %s: %s\n",
+                        parent, strerror (errno));
                 goto out;
         }
 
diff --git a/contrib/userspace-rcu/static-wfcqueue.h b/contrib/userspace-rcu/static-wfcqueue.h
new file mode 100644
index 00000000000..37d14ad674b
--- /dev/null
+++ b/contrib/userspace-rcu/static-wfcqueue.h
@@ -0,0 +1,685 @@
+#ifndef _URCU_WFCQUEUE_STATIC_H
+#define _URCU_WFCQUEUE_STATIC_H
+
+/*
+ * urcu/static/wfcqueue.h
+ *
+ * Userspace RCU library - Concurrent Queue with Wait-Free Enqueue/Blocking Dequeue
+ *
+ * TO BE INCLUDED ONLY IN LGPL-COMPATIBLE CODE. See urcu/wfcqueue.h for
+ * linking dynamically with the userspace rcu library.
+ *
+ * Copyright 2010-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright 2011-2012 - Lai Jiangshan <laijs@cn.fujitsu.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Copied from userspace-rcu 0.10 because version 0.7 doesn't contain it. */
+
+#include <pthread.h>
+#include <assert.h>
+#include <poll.h>
+#include <stdbool.h>
+#include <urcu/compiler.h>
+#include <urcu/uatomic.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Concurrent queue with wait-free enqueue/blocking dequeue.
+ *
+ * This queue has been designed and implemented collaboratively by
+ * Mathieu Desnoyers and Lai Jiangshan. Inspired from
+ * half-wait-free/half-blocking queue implementation done by Paul E.
+ * McKenney.
+ *
+ * Mutual exclusion of cds_wfcq_* / __cds_wfcq_* API
+ *
+ * Synchronization table:
+ *
+ * External synchronization techniques described in the API below is
+ * required between pairs marked with "X". No external synchronization
+ * required between pairs marked with "-".
+ *
+ * Legend:
+ * [1] cds_wfcq_enqueue
+ * [2] __cds_wfcq_splice (destination queue)
+ * [3] __cds_wfcq_dequeue
+ * [4] __cds_wfcq_splice (source queue)
+ * [5] __cds_wfcq_first
+ * [6] __cds_wfcq_next
+ *
+ *     [1] [2] [3] [4] [5] [6]
+ * [1]  -   -   -   -   -   -
+ * [2]  -   -   -   -   -   -
+ * [3]  -   -   X   X   X   X
+ * [4]  -   -   X   -   X   X
+ * [5]  -   -   X   X   -   -
+ * [6]  -   -   X   X   -   -
+ *
+ * Mutual exclusion can be ensured by holding cds_wfcq_dequeue_lock().
+ *
+ * For convenience, cds_wfcq_dequeue_blocking() and
+ * cds_wfcq_splice_blocking() hold the dequeue lock.
+ *
+ * Besides locking, mutual exclusion of dequeue, splice and iteration
+ * can be ensured by performing all of those operations from a single
+ * thread, without requiring any lock.
+ */
+
+#define WFCQ_ADAPT_ATTEMPTS		10	/* Retry if being set */
+#define WFCQ_WAIT			10	/* Wait 10 ms if being set */
+
+/*
+ * cds_wfcq_node_init: initialize wait-free queue node.
+ */
+static inline void _cds_wfcq_node_init(struct cds_wfcq_node *node)
+{
+	node->next = NULL;
+}
+
+/*
+ * cds_wfcq_init: initialize wait-free queue (with lock). Pair with
+ * cds_wfcq_destroy().
+ */
+static inline void _cds_wfcq_init(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	int ret;
+
+	/* Set queue head and tail */
+	_cds_wfcq_node_init(&head->node);
+	tail->p = &head->node;
+	ret = pthread_mutex_init(&head->lock, NULL);
+	assert(!ret);
+}
+
+/*
+ * cds_wfcq_destroy: destroy wait-free queue (with lock). Pair with
+ * cds_wfcq_init().
+ */
+static inline void _cds_wfcq_destroy(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	int ret = pthread_mutex_destroy(&head->lock);
+	assert(!ret);
+}
+
+/*
+ * __cds_wfcq_init: initialize wait-free queue (without lock). Don't
+ * pair with any destroy function.
+ */
+static inline void ___cds_wfcq_init(struct __cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	/* Set queue head and tail */
+	_cds_wfcq_node_init(&head->node);
+	tail->p = &head->node;
+}
+
+/*
+ * cds_wfcq_empty: return whether wait-free queue is empty.
+ *
+ * No memory barrier is issued. No mutual exclusion is required.
+ *
+ * We perform the test on head->node.next to check if the queue is
+ * possibly empty, but we confirm this by checking if the tail pointer
+ * points to the head node because the tail pointer is the linearisation
+ * point of the enqueuers. Just checking the head next pointer could
+ * make a queue appear empty if an enqueuer is preempted for a long time
+ * between xchg() and setting the previous node's next pointer.
+ */
+static inline bool _cds_wfcq_empty(cds_wfcq_head_ptr_t u_head,
+		struct cds_wfcq_tail *tail)
+{
+	struct __cds_wfcq_head *head = u_head._h;
+	/*
+	 * Queue is empty if no node is pointed by head->node.next nor
+	 * tail->p. Even though the tail->p check is sufficient to find
+	 * out of the queue is empty, we first check head->node.next as a
+	 * common case to ensure that dequeuers do not frequently access
+	 * enqueuer's tail->p cache line.
+	 */
+	return CMM_LOAD_SHARED(head->node.next) == NULL
+		&& CMM_LOAD_SHARED(tail->p) == &head->node;
+}
+
+static inline void _cds_wfcq_dequeue_lock(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	int ret;
+
+	ret = pthread_mutex_lock(&head->lock);
+	assert(!ret);
+}
+
+static inline void _cds_wfcq_dequeue_unlock(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	int ret;
+
+	ret = pthread_mutex_unlock(&head->lock);
+	assert(!ret);
+}
+
+static inline bool ___cds_wfcq_append(cds_wfcq_head_ptr_t u_head,
+		struct cds_wfcq_tail *tail,
+		struct cds_wfcq_node *new_head,
+		struct cds_wfcq_node *new_tail)
+{
+	struct __cds_wfcq_head *head = u_head._h;
+	struct cds_wfcq_node *old_tail;
+
+	/*
+	 * Implicit memory barrier before uatomic_xchg() orders earlier
+	 * stores to data structure containing node and setting
+	 * node->next to NULL before publication.
+	 */
+	old_tail = uatomic_xchg(&tail->p, new_tail);
+
+	/*
+	 * Implicit memory barrier after uatomic_xchg() orders store to
+	 * q->tail before store to old_tail->next.
+	 *
+	 * At this point, dequeuers see a NULL tail->p->next, which
+	 * indicates that the queue is being appended to. The following
+	 * store will append "node" to the queue from a dequeuer
+	 * perspective.
+	 */
+	CMM_STORE_SHARED(old_tail->next, new_head);
+	/*
+	 * Return false if queue was empty prior to adding the node,
+	 * else return true.
+	 */
+	return old_tail != &head->node;
+}
+
+/*
+ * cds_wfcq_enqueue: enqueue a node into a wait-free queue.
+ *
+ * Issues a full memory barrier before enqueue. No mutual exclusion is
+ * required.
+ *
+ * Returns false if the queue was empty prior to adding the node.
+ * Returns true otherwise.
+ */
+static inline bool _cds_wfcq_enqueue(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail,
+		struct cds_wfcq_node *new_tail)
+{
+	return ___cds_wfcq_append(head, tail, new_tail, new_tail);
+}
+
+/*
+ * CDS_WFCQ_WAIT_SLEEP:
+ *
+ * By default, this sleeps for the given @msec milliseconds.
+ * This is a macro which LGPL users may #define themselves before
+ * including wfcqueue.h to override the default behavior (e.g.
+ * to log a warning or perform other background work).
+ */
+#ifndef CDS_WFCQ_WAIT_SLEEP
+#define CDS_WFCQ_WAIT_SLEEP(msec) ___cds_wfcq_wait_sleep(msec)
+#endif
+
+static inline void ___cds_wfcq_wait_sleep(int msec)
+{
+	(void) poll(NULL, 0, msec);
+}
+
+/*
+ * ___cds_wfcq_busy_wait: adaptative busy-wait.
+ *
+ * Returns 1 if nonblocking and needs to block, 0 otherwise.
+ */
+static inline bool
+___cds_wfcq_busy_wait(int *attempt, int blocking)
+{
+	if (!blocking)
+		return 1;
+	if (++(*attempt) >= WFCQ_ADAPT_ATTEMPTS) {
+		CDS_WFCQ_WAIT_SLEEP(WFCQ_WAIT);		/* Wait for 10ms */
+		*attempt = 0;
+	} else {
+		caa_cpu_relax();
+	}
+	return 0;
+}
+
+/*
+ * Waiting for enqueuer to complete enqueue and return the next node.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_node_sync_next(struct cds_wfcq_node *node, int blocking)
+{
+	struct cds_wfcq_node *next;
+	int attempt = 0;
+
+	/*
+	 * Adaptative busy-looping waiting for enqueuer to complete enqueue.
+	 */
+	while ((next = CMM_LOAD_SHARED(node->next)) == NULL) {
+		if (___cds_wfcq_busy_wait(&attempt, blocking))
+			return CDS_WFCQ_WOULDBLOCK;
+	}
+
+	return next;
+}
+
+static inline struct cds_wfcq_node *
+___cds_wfcq_first(cds_wfcq_head_ptr_t u_head,
+		struct cds_wfcq_tail *tail,
+		int blocking)
+{
+	struct __cds_wfcq_head *head = u_head._h;
+	struct cds_wfcq_node *node;
+
+	if (_cds_wfcq_empty(__cds_wfcq_head_cast(head), tail))
+		return NULL;
+	node = ___cds_wfcq_node_sync_next(&head->node, blocking);
+	/* Load head->node.next before loading node's content */
+	cmm_smp_read_barrier_depends();
+	return node;
+}
+
+/*
+ * __cds_wfcq_first_blocking: get first node of a queue, without dequeuing.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Dequeue/splice/iteration mutual exclusion should be ensured by the
+ * caller.
+ *
+ * Used by for-like iteration macros in urcu/wfqueue.h:
+ * __cds_wfcq_for_each_blocking()
+ * __cds_wfcq_for_each_blocking_safe()
+ *
+ * Returns NULL if queue is empty, first node otherwise.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_first_blocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail)
+{
+	return ___cds_wfcq_first(head, tail, 1);
+}
+
+
+/*
+ * __cds_wfcq_first_nonblocking: get first node of a queue, without dequeuing.
+ *
+ * Same as __cds_wfcq_first_blocking, but returns CDS_WFCQ_WOULDBLOCK if
+ * it needs to block.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_first_nonblocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail)
+{
+	return ___cds_wfcq_first(head, tail, 0);
+}
+
+static inline struct cds_wfcq_node *
+___cds_wfcq_next(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail,
+		struct cds_wfcq_node *node,
+		int blocking)
+{
+	struct cds_wfcq_node *next;
+
+	/*
+	 * Even though the following tail->p check is sufficient to find
+	 * out if we reached the end of the queue, we first check
+	 * node->next as a common case to ensure that iteration on nodes
+	 * do not frequently access enqueuer's tail->p cache line.
+	 */
+	if ((next = CMM_LOAD_SHARED(node->next)) == NULL) {
+		/* Load node->next before tail->p */
+		cmm_smp_rmb();
+		if (CMM_LOAD_SHARED(tail->p) == node)
+			return NULL;
+		next = ___cds_wfcq_node_sync_next(node, blocking);
+	}
+	/* Load node->next before loading next's content */
+	cmm_smp_read_barrier_depends();
+	return next;
+}
+
+/*
+ * __cds_wfcq_next_blocking: get next node of a queue, without dequeuing.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Dequeue/splice/iteration mutual exclusion should be ensured by the
+ * caller.
+ *
+ * Used by for-like iteration macros in urcu/wfqueue.h:
+ * __cds_wfcq_for_each_blocking()
+ * __cds_wfcq_for_each_blocking_safe()
+ *
+ * Returns NULL if reached end of queue, non-NULL next queue node
+ * otherwise.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_next_blocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail,
+		struct cds_wfcq_node *node)
+{
+	return ___cds_wfcq_next(head, tail, node, 1);
+}
+
+/*
+ * __cds_wfcq_next_blocking: get next node of a queue, without dequeuing.
+ *
+ * Same as __cds_wfcq_next_blocking, but returns CDS_WFCQ_WOULDBLOCK if
+ * it needs to block.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_next_nonblocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail,
+		struct cds_wfcq_node *node)
+{
+	return ___cds_wfcq_next(head, tail, node, 0);
+}
+
+static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_with_state(cds_wfcq_head_ptr_t u_head,
+		struct cds_wfcq_tail *tail,
+		int *state,
+		int blocking)
+{
+	struct __cds_wfcq_head *head = u_head._h;
+	struct cds_wfcq_node *node, *next;
+
+	if (state)
+		*state = 0;
+
+	if (_cds_wfcq_empty(__cds_wfcq_head_cast(head), tail)) {
+		return NULL;
+	}
+
+	node = ___cds_wfcq_node_sync_next(&head->node, blocking);
+	if (!blocking && node == CDS_WFCQ_WOULDBLOCK) {
+		return CDS_WFCQ_WOULDBLOCK;
+	}
+
+	if ((next = CMM_LOAD_SHARED(node->next)) == NULL) {
+		/*
+		 * @node is probably the only node in the queue.
+		 * Try to move the tail to &q->head.
+		 * q->head.next is set to NULL here, and stays
+		 * NULL if the cmpxchg succeeds. Should the
+		 * cmpxchg fail due to a concurrent enqueue, the
+		 * q->head.next will be set to the next node.
+		 * The implicit memory barrier before
+		 * uatomic_cmpxchg() orders load node->next
+		 * before loading q->tail.
+		 * The implicit memory barrier before uatomic_cmpxchg
+		 * orders load q->head.next before loading node's
+		 * content.
+		 */
+		_cds_wfcq_node_init(&head->node);
+		if (uatomic_cmpxchg(&tail->p, node, &head->node) == node) {
+			if (state)
+				*state |= CDS_WFCQ_STATE_LAST;
+			return node;
+		}
+		next = ___cds_wfcq_node_sync_next(node, blocking);
+		/*
+		 * In nonblocking mode, if we would need to block to
+		 * get node's next, set the head next node pointer
+		 * (currently NULL) back to its original value.
+		 */
+		if (!blocking && next == CDS_WFCQ_WOULDBLOCK) {
+			head->node.next = node;
+			return CDS_WFCQ_WOULDBLOCK;
+		}
+	}
+
+	/*
+	 * Move queue head forward.
+	 */
+	head->node.next = next;
+
+	/* Load q->head.next before loading node's content */
+	cmm_smp_read_barrier_depends();
+	return node;
+}
+
+/*
+ * __cds_wfcq_dequeue_with_state_blocking: dequeue node from queue, with state.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * It is valid to reuse and free a dequeued node immediately.
+ * Dequeue/splice/iteration mutual exclusion should be ensured by the
+ * caller.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_with_state_blocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail, int *state)
+{
+	return ___cds_wfcq_dequeue_with_state(head, tail, state, 1);
+}
+
+/*
+ * ___cds_wfcq_dequeue_blocking: dequeue node from queue.
+ *
+ * Same as __cds_wfcq_dequeue_with_state_blocking, but without saving
+ * state.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_blocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail)
+{
+	return ___cds_wfcq_dequeue_with_state_blocking(head, tail, NULL);
+}
+
+/*
+ * __cds_wfcq_dequeue_with_state_nonblocking: dequeue node, with state.
+ *
+ * Same as __cds_wfcq_dequeue_blocking, but returns CDS_WFCQ_WOULDBLOCK
+ * if it needs to block.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_with_state_nonblocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail, int *state)
+{
+	return ___cds_wfcq_dequeue_with_state(head, tail, state, 0);
+}
+
+/*
+ * ___cds_wfcq_dequeue_nonblocking: dequeue node from queue.
+ *
+ * Same as __cds_wfcq_dequeue_with_state_nonblocking, but without saving
+ * state.
+ */
+static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_nonblocking(cds_wfcq_head_ptr_t head,
+		struct cds_wfcq_tail *tail)
+{
+	return ___cds_wfcq_dequeue_with_state_nonblocking(head, tail, NULL);
+}
+
+/*
+ * __cds_wfcq_splice: enqueue all src_q nodes at the end of dest_q.
+ *
+ * Dequeue all nodes from src_q.
+ * dest_q must be already initialized.
+ * Mutual exclusion for src_q should be ensured by the caller as
+ * specified in the "Synchronisation table".
+ * Returns enum cds_wfcq_ret which indicates the state of the src or
+ * dest queue.
+ */
+static inline enum cds_wfcq_ret
+___cds_wfcq_splice(
+		cds_wfcq_head_ptr_t u_dest_q_head,
+		struct cds_wfcq_tail *dest_q_tail,
+		cds_wfcq_head_ptr_t u_src_q_head,
+		struct cds_wfcq_tail *src_q_tail,
+		int blocking)
+{
+	struct __cds_wfcq_head *dest_q_head = u_dest_q_head._h;
+	struct __cds_wfcq_head *src_q_head = u_src_q_head._h;
+	struct cds_wfcq_node *head, *tail;
+	int attempt = 0;
+
+	/*
+	 * Initial emptiness check to speed up cases where queue is
+	 * empty: only require loads to check if queue is empty.
+	 */
+	if (_cds_wfcq_empty(__cds_wfcq_head_cast(src_q_head), src_q_tail))
+		return CDS_WFCQ_RET_SRC_EMPTY;
+
+	for (;;) {
+		/*
+		 * Open-coded _cds_wfcq_empty() by testing result of
+		 * uatomic_xchg, as well as tail pointer vs head node
+		 * address.
+		 */
+		head = uatomic_xchg(&src_q_head->node.next, NULL);
+		if (head)
+			break;	/* non-empty */
+		if (CMM_LOAD_SHARED(src_q_tail->p) == &src_q_head->node)
+			return CDS_WFCQ_RET_SRC_EMPTY;
+		if (___cds_wfcq_busy_wait(&attempt, blocking))
+			return CDS_WFCQ_RET_WOULDBLOCK;
+	}
+
+	/*
+	 * Memory barrier implied before uatomic_xchg() orders store to
+	 * src_q->head before store to src_q->tail. This is required by
+	 * concurrent enqueue on src_q, which exchanges the tail before
+	 * updating the previous tail's next pointer.
+	 */
+	tail = uatomic_xchg(&src_q_tail->p, &src_q_head->node);
+
+	/*
+	 * Append the spliced content of src_q into dest_q. Does not
+	 * require mutual exclusion on dest_q (wait-free).
+	 */
+	if (___cds_wfcq_append(__cds_wfcq_head_cast(dest_q_head), dest_q_tail,
+			head, tail))
+		return CDS_WFCQ_RET_DEST_NON_EMPTY;
+	else
+		return CDS_WFCQ_RET_DEST_EMPTY;
+}
+
+/*
+ * __cds_wfcq_splice_blocking: enqueue all src_q nodes at the end of dest_q.
+ *
+ * Dequeue all nodes from src_q.
+ * dest_q must be already initialized.
+ * Mutual exclusion for src_q should be ensured by the caller as
+ * specified in the "Synchronisation table".
+ * Returns enum cds_wfcq_ret which indicates the state of the src or
+ * dest queue. Never returns CDS_WFCQ_RET_WOULDBLOCK.
+ */
+static inline enum cds_wfcq_ret
+___cds_wfcq_splice_blocking(
+		cds_wfcq_head_ptr_t dest_q_head,
+		struct cds_wfcq_tail *dest_q_tail,
+		cds_wfcq_head_ptr_t src_q_head,
+		struct cds_wfcq_tail *src_q_tail)
+{
+	return ___cds_wfcq_splice(dest_q_head, dest_q_tail,
+		src_q_head, src_q_tail, 1);
+}
+
+/*
+ * __cds_wfcq_splice_nonblocking: enqueue all src_q nodes at the end of dest_q.
+ *
+ * Same as __cds_wfcq_splice_blocking, but returns
+ * CDS_WFCQ_RET_WOULDBLOCK if it needs to block.
+ */
+static inline enum cds_wfcq_ret
+___cds_wfcq_splice_nonblocking(
+		cds_wfcq_head_ptr_t dest_q_head,
+		struct cds_wfcq_tail *dest_q_tail,
+		cds_wfcq_head_ptr_t src_q_head,
+		struct cds_wfcq_tail *src_q_tail)
+{
+	return ___cds_wfcq_splice(dest_q_head, dest_q_tail,
+		src_q_head, src_q_tail, 0);
+}
+
+/*
+ * cds_wfcq_dequeue_with_state_blocking: dequeue a node from a wait-free queue.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Mutual exclusion with cds_wfcq_splice_blocking and dequeue lock is
+ * ensured.
+ * It is valid to reuse and free a dequeued node immediately.
+ */
+static inline struct cds_wfcq_node *
+_cds_wfcq_dequeue_with_state_blocking(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail, int *state)
+{
+	struct cds_wfcq_node *retval;
+
+	_cds_wfcq_dequeue_lock(head, tail);
+	retval = ___cds_wfcq_dequeue_with_state_blocking(cds_wfcq_head_cast(head),
+			tail, state);
+	_cds_wfcq_dequeue_unlock(head, tail);
+	return retval;
+}
+
+/*
+ * cds_wfcq_dequeue_blocking: dequeue node from queue.
+ *
+ * Same as cds_wfcq_dequeue_blocking, but without saving state.
+ */
+static inline struct cds_wfcq_node *
+_cds_wfcq_dequeue_blocking(struct cds_wfcq_head *head,
+		struct cds_wfcq_tail *tail)
+{
+	return _cds_wfcq_dequeue_with_state_blocking(head, tail, NULL);
+}
+
+/*
+ * cds_wfcq_splice_blocking: enqueue all src_q nodes at the end of dest_q.
+ *
+ * Dequeue all nodes from src_q.
+ * dest_q must be already initialized.
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Mutual exclusion with cds_wfcq_dequeue_blocking and dequeue lock is
+ * ensured.
+ * Returns enum cds_wfcq_ret which indicates the state of the src or
+ * dest queue. Never returns CDS_WFCQ_RET_WOULDBLOCK.
+ */
+static inline enum cds_wfcq_ret
+_cds_wfcq_splice_blocking(
+		struct cds_wfcq_head *dest_q_head,
+		struct cds_wfcq_tail *dest_q_tail,
+		struct cds_wfcq_head *src_q_head,
+		struct cds_wfcq_tail *src_q_tail)
+{
+	enum cds_wfcq_ret ret;
+
+	_cds_wfcq_dequeue_lock(src_q_head, src_q_tail);
+	ret = ___cds_wfcq_splice_blocking(cds_wfcq_head_cast(dest_q_head), dest_q_tail,
+			cds_wfcq_head_cast(src_q_head), src_q_tail);
+	_cds_wfcq_dequeue_unlock(src_q_head, src_q_tail);
+	return ret;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _URCU_WFCQUEUE_STATIC_H */
diff --git a/contrib/userspace-rcu/static-wfstack.h b/contrib/userspace-rcu/static-wfstack.h
new file mode 100644
index 00000000000..29b81c3aac3
--- /dev/null
+++ b/contrib/userspace-rcu/static-wfstack.h
@@ -0,0 +1,455 @@
+#ifndef _URCU_STATIC_WFSTACK_H
+#define _URCU_STATIC_WFSTACK_H
+
+/*
+ * urcu/static/wfstack.h
+ *
+ * Userspace RCU library - Stack with with wait-free push, blocking traversal.
+ *
+ * TO BE INCLUDED ONLY IN LGPL-COMPATIBLE CODE. See urcu/wfstack.h for
+ * linking dynamically with the userspace rcu library.
+ *
+ * Copyright 2010-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Adapted from userspace-rcu 0.10 because version 0.7 doesn't support a stack
+ * without mutex. */
+
+#include <pthread.h>
+#include <assert.h>
+#include <poll.h>
+#include <stdbool.h>
+#include <urcu/compiler.h>
+#include <urcu/uatomic.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CDS_WFS_END			((void *) 0x1UL)
+#define CDS_WFS_ADAPT_ATTEMPTS		10	/* Retry if being set */
+#define CDS_WFS_WAIT			10	/* Wait 10 ms if being set */
+
+/*
+ * Stack with wait-free push, blocking traversal.
+ *
+ * Stack implementing push, pop, pop_all operations, as well as iterator
+ * on the stack head returned by pop_all.
+ *
+ * Wait-free operations: cds_wfs_push, __cds_wfs_pop_all, cds_wfs_empty,
+ *                       cds_wfs_first.
+ * Blocking operations: cds_wfs_pop, cds_wfs_pop_all, cds_wfs_next,
+ *                      iteration on stack head returned by pop_all.
+ *
+ * Synchronization table:
+ *
+ * External synchronization techniques described in the API below is
+ * required between pairs marked with "X". No external synchronization
+ * required between pairs marked with "-".
+ *
+ *                      cds_wfs_push  __cds_wfs_pop  __cds_wfs_pop_all
+ * cds_wfs_push               -              -                  -
+ * __cds_wfs_pop              -              X                  X
+ * __cds_wfs_pop_all          -              X                  -
+ *
+ * cds_wfs_pop and cds_wfs_pop_all use an internal mutex to provide
+ * synchronization.
+ */
+
+/*
+ * cds_wfs_node_init: initialize wait-free stack node.
+ */
+static inline
+void _cds_wfs_node_init(struct cds_wfs_node *node)
+{
+	node->next = NULL;
+}
+
+/*
+ * __cds_wfs_init: initialize wait-free stack. Don't pair with
+ * any destroy function.
+ */
+static inline void ___cds_wfs_init(struct __cds_wfs_stack *s)
+{
+	s->head = CDS_WFS_END;
+}
+
+/*
+ * cds_wfs_init: initialize wait-free stack. Pair with
+ * cds_wfs_destroy().
+ */
+static inline
+void _cds_wfs_init(struct cds_wfs_stack *s)
+{
+	int ret;
+
+	s->head = CDS_WFS_END;
+	ret = pthread_mutex_init(&s->lock, NULL);
+	assert(!ret);
+}
+
+/*
+ * cds_wfs_destroy: destroy wait-free stack. Pair with
+ * cds_wfs_init().
+ */
+static inline
+void _cds_wfs_destroy(struct cds_wfs_stack *s)
+{
+	int ret = pthread_mutex_destroy(&s->lock);
+	assert(!ret);
+}
+
+static inline bool ___cds_wfs_end(void *node)
+{
+	return node == CDS_WFS_END;
+}
+
+/*
+ * cds_wfs_empty: return whether wait-free stack is empty.
+ *
+ * No memory barrier is issued. No mutual exclusion is required.
+ */
+static inline bool _cds_wfs_empty(cds_wfs_stack_ptr_t u_stack)
+{
+	struct __cds_wfs_stack *s = u_stack._s;
+
+	return ___cds_wfs_end(CMM_LOAD_SHARED(s->head));
+}
+
+/*
+ * cds_wfs_push: push a node into the stack.
+ *
+ * Issues a full memory barrier before push. No mutual exclusion is
+ * required.
+ *
+ * Returns 0 if the stack was empty prior to adding the node.
+ * Returns non-zero otherwise.
+ */
+static inline
+int _cds_wfs_push(cds_wfs_stack_ptr_t u_stack, struct cds_wfs_node *node)
+{
+	struct __cds_wfs_stack *s = u_stack._s;
+	struct cds_wfs_head *old_head, *new_head;
+
+	assert(node->next == NULL);
+	new_head = caa_container_of(node, struct cds_wfs_head, node);
+	/*
+	 * uatomic_xchg() implicit memory barrier orders earlier stores
+	 * to node (setting it to NULL) before publication.
+	 */
+	old_head = uatomic_xchg(&s->head, new_head);
+	/*
+	 * At this point, dequeuers see a NULL node->next, they should
+	 * busy-wait until node->next is set to old_head.
+	 */
+	CMM_STORE_SHARED(node->next, &old_head->node);
+	return !___cds_wfs_end(old_head);
+}
+
+/*
+ * Waiting for push to complete enqueue and return the next node.
+ */
+static inline struct cds_wfs_node *
+___cds_wfs_node_sync_next(struct cds_wfs_node *node, int blocking)
+{
+	struct cds_wfs_node *next;
+	int attempt = 0;
+
+	/*
+	 * Adaptative busy-looping waiting for push to complete.
+	 */
+	while ((next = CMM_LOAD_SHARED(node->next)) == NULL) {
+		if (!blocking)
+			return CDS_WFS_WOULDBLOCK;
+		if (++attempt >= CDS_WFS_ADAPT_ATTEMPTS) {
+			(void) poll(NULL, 0, CDS_WFS_WAIT);	/* Wait for 10ms */
+			attempt = 0;
+		} else {
+			caa_cpu_relax();
+		}
+	}
+
+	return next;
+}
+
+static inline
+struct cds_wfs_node *
+___cds_wfs_pop(cds_wfs_stack_ptr_t u_stack, int *state, int blocking)
+{
+	struct cds_wfs_head *head, *new_head;
+	struct cds_wfs_node *next;
+	struct __cds_wfs_stack *s = u_stack._s;
+
+	if (state)
+		*state = 0;
+	for (;;) {
+		head = CMM_LOAD_SHARED(s->head);
+		if (___cds_wfs_end(head)) {
+			return NULL;
+		}
+		next = ___cds_wfs_node_sync_next(&head->node, blocking);
+		if (!blocking && next == CDS_WFS_WOULDBLOCK) {
+			return CDS_WFS_WOULDBLOCK;
+		}
+		new_head = caa_container_of(next, struct cds_wfs_head, node);
+		if (uatomic_cmpxchg(&s->head, head, new_head) == head) {
+			if (state && ___cds_wfs_end(new_head))
+				*state |= CDS_WFS_STATE_LAST;
+			return &head->node;
+		}
+		if (!blocking) {
+			return CDS_WFS_WOULDBLOCK;
+		}
+		/* busy-loop if head changed under us */
+	}
+}
+
+/*
+ * __cds_wfs_pop_with_state_blocking: pop a node from the stack, with state.
+ *
+ * Returns NULL if stack is empty.
+ *
+ * __cds_wfs_pop_blocking needs to be synchronized using one of the
+ * following techniques:
+ *
+ * 1) Calling __cds_wfs_pop_blocking under rcu read lock critical
+ *    section. The caller must wait for a grace period to pass before
+ *    freeing the returned node or modifying the cds_wfs_node structure.
+ * 2) Using mutual exclusion (e.g. mutexes) to protect
+ *     __cds_wfs_pop_blocking and __cds_wfs_pop_all callers.
+ * 3) Ensuring that only ONE thread can call __cds_wfs_pop_blocking()
+ *    and __cds_wfs_pop_all(). (multi-provider/single-consumer scheme).
+ *
+ * "state" saves state flags atomically sampled with pop operation.
+ */
+static inline
+struct cds_wfs_node *
+___cds_wfs_pop_with_state_blocking(cds_wfs_stack_ptr_t u_stack, int *state)
+{
+	return ___cds_wfs_pop(u_stack, state, 1);
+}
+
+static inline
+struct cds_wfs_node *
+___cds_wfs_pop_blocking(cds_wfs_stack_ptr_t u_stack)
+{
+	return ___cds_wfs_pop_with_state_blocking(u_stack, NULL);
+}
+
+/*
+ * __cds_wfs_pop_with_state_nonblocking: pop a node from the stack.
+ *
+ * Same as __cds_wfs_pop_with_state_blocking, but returns
+ * CDS_WFS_WOULDBLOCK if it needs to block.
+ *
+ * "state" saves state flags atomically sampled with pop operation.
+ */
+static inline
+struct cds_wfs_node *
+___cds_wfs_pop_with_state_nonblocking(cds_wfs_stack_ptr_t u_stack, int *state)
+{
+	return ___cds_wfs_pop(u_stack, state, 0);
+}
+
+/*
+ * __cds_wfs_pop_nonblocking: pop a node from the stack.
+ *
+ * Same as __cds_wfs_pop_blocking, but returns CDS_WFS_WOULDBLOCK if
+ * it needs to block.
+ */
+static inline
+struct cds_wfs_node *
+___cds_wfs_pop_nonblocking(cds_wfs_stack_ptr_t u_stack)
+{
+	return ___cds_wfs_pop_with_state_nonblocking(u_stack, NULL);
+}
+
+/*
+ * __cds_wfs_pop_all: pop all nodes from a stack.
+ *
+ * __cds_wfs_pop_all does not require any synchronization with other
+ * push, nor with other __cds_wfs_pop_all, but requires synchronization
+ * matching the technique used to synchronize __cds_wfs_pop_blocking:
+ *
+ * 1) If __cds_wfs_pop_blocking is called under rcu read lock critical
+ *    section, both __cds_wfs_pop_blocking and cds_wfs_pop_all callers
+ *    must wait for a grace period to pass before freeing the returned
+ *    node or modifying the cds_wfs_node structure. However, no RCU
+ *    read-side critical section is needed around __cds_wfs_pop_all.
+ * 2) Using mutual exclusion (e.g. mutexes) to protect
+ *     __cds_wfs_pop_blocking and __cds_wfs_pop_all callers.
+ * 3) Ensuring that only ONE thread can call __cds_wfs_pop_blocking()
+ *    and __cds_wfs_pop_all(). (multi-provider/single-consumer scheme).
+ */
+static inline
+struct cds_wfs_head *
+___cds_wfs_pop_all(cds_wfs_stack_ptr_t u_stack)
+{
+	struct __cds_wfs_stack *s = u_stack._s;
+	struct cds_wfs_head *head;
+
+	/*
+	 * Implicit memory barrier after uatomic_xchg() matches implicit
+	 * memory barrier before uatomic_xchg() in cds_wfs_push. It
+	 * ensures that all nodes of the returned list are consistent.
+	 * There is no need to issue memory barriers when iterating on
+	 * the returned list, because the full memory barrier issued
+	 * prior to each uatomic_cmpxchg, which each write to head, are
+	 * taking care to order writes to each node prior to the full
+	 * memory barrier after this uatomic_xchg().
+	 */
+	head = uatomic_xchg(&s->head, CDS_WFS_END);
+	if (___cds_wfs_end(head))
+		return NULL;
+	return head;
+}
+
+/*
+ * cds_wfs_pop_lock: lock stack pop-protection mutex.
+ */
+static inline void _cds_wfs_pop_lock(struct cds_wfs_stack *s)
+{
+	int ret;
+
+	ret = pthread_mutex_lock(&s->lock);
+	assert(!ret);
+}
+
+/*
+ * cds_wfs_pop_unlock: unlock stack pop-protection mutex.
+ */
+static inline void _cds_wfs_pop_unlock(struct cds_wfs_stack *s)
+{
+	int ret;
+
+	ret = pthread_mutex_unlock(&s->lock);
+	assert(!ret);
+}
+
+/*
+ * Call __cds_wfs_pop_with_state_blocking with an internal pop mutex held.
+ */
+static inline
+struct cds_wfs_node *
+_cds_wfs_pop_with_state_blocking(struct cds_wfs_stack *s, int *state)
+{
+	struct cds_wfs_node *retnode;
+
+	_cds_wfs_pop_lock(s);
+	retnode = ___cds_wfs_pop_with_state_blocking(s, state);
+	_cds_wfs_pop_unlock(s);
+	return retnode;
+}
+
+/*
+ * Call _cds_wfs_pop_with_state_blocking without saving any state.
+ */
+static inline
+struct cds_wfs_node *
+_cds_wfs_pop_blocking(struct cds_wfs_stack *s)
+{
+	return _cds_wfs_pop_with_state_blocking(s, NULL);
+}
+
+/*
+ * Call __cds_wfs_pop_all with an internal pop mutex held.
+ */
+static inline
+struct cds_wfs_head *
+_cds_wfs_pop_all_blocking(struct cds_wfs_stack *s)
+{
+	struct cds_wfs_head *rethead;
+
+	_cds_wfs_pop_lock(s);
+	rethead = ___cds_wfs_pop_all(s);
+	_cds_wfs_pop_unlock(s);
+	return rethead;
+}
+
+/*
+ * cds_wfs_first: get first node of a popped stack.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ *
+ * Used by for-like iteration macros in urcu/wfstack.h:
+ * cds_wfs_for_each_blocking()
+ * cds_wfs_for_each_blocking_safe()
+ *
+ * Returns NULL if popped stack is empty, top stack node otherwise.
+ */
+static inline struct cds_wfs_node *
+_cds_wfs_first(struct cds_wfs_head *head)
+{
+	if (___cds_wfs_end(head))
+		return NULL;
+	return &head->node;
+}
+
+static inline struct cds_wfs_node *
+___cds_wfs_next(struct cds_wfs_node *node, int blocking)
+{
+	struct cds_wfs_node *next;
+
+	next = ___cds_wfs_node_sync_next(node, blocking);
+	/*
+	 * CDS_WFS_WOULDBLOCK != CSD_WFS_END, so we can check for end
+	 * even if ___cds_wfs_node_sync_next returns CDS_WFS_WOULDBLOCK,
+	 * and still return CDS_WFS_WOULDBLOCK.
+	 */
+	if (___cds_wfs_end(next))
+		return NULL;
+	return next;
+}
+
+/*
+ * cds_wfs_next_blocking: get next node of a popped stack.
+ *
+ * Content written into the node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ *
+ * Used by for-like iteration macros in urcu/wfstack.h:
+ * cds_wfs_for_each_blocking()
+ * cds_wfs_for_each_blocking_safe()
+ *
+ * Returns NULL if reached end of popped stack, non-NULL next stack
+ * node otherwise.
+ */
+static inline struct cds_wfs_node *
+_cds_wfs_next_blocking(struct cds_wfs_node *node)
+{
+	return ___cds_wfs_next(node, 1);
+}
+
+
+/*
+ * cds_wfs_next_nonblocking: get next node of a popped stack.
+ *
+ * Same as cds_wfs_next_blocking, but returns CDS_WFS_WOULDBLOCK if it
+ * needs to block.
+ */
+static inline struct cds_wfs_node *
+_cds_wfs_next_nonblocking(struct cds_wfs_node *node)
+{
+	return ___cds_wfs_next(node, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _URCU_STATIC_WFSTACK_H */
diff --git a/contrib/userspace-rcu/wfcqueue.h b/contrib/userspace-rcu/wfcqueue.h
new file mode 100644
index 00000000000..0292585ac79
--- /dev/null
+++ b/contrib/userspace-rcu/wfcqueue.h
@@ -0,0 +1,216 @@
+#ifndef _URCU_WFCQUEUE_H
+#define _URCU_WFCQUEUE_H
+
+/*
+ * urcu/wfcqueue.h
+ *
+ * Userspace RCU library - Concurrent Queue with Wait-Free Enqueue/Blocking Dequeue
+ *
+ * Copyright 2010-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright 2011-2012 - Lai Jiangshan <laijs@cn.fujitsu.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Adapted from userspace-rcu 0.10 because version 0.7 doesn't contain it.
+ * The non-LGPL section has been removed. */
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <urcu/compiler.h>
+#include <urcu/arch.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Concurrent queue with wait-free enqueue/blocking dequeue.
+ *
+ * This queue has been designed and implemented collaboratively by
+ * Mathieu Desnoyers and Lai Jiangshan. Inspired from
+ * half-wait-free/half-blocking queue implementation done by Paul E.
+ * McKenney.
+ */
+
+#define CDS_WFCQ_WOULDBLOCK	((struct cds_wfcq_node *) -1UL)
+
+enum cds_wfcq_ret {
+	CDS_WFCQ_RET_WOULDBLOCK =	-1,
+	CDS_WFCQ_RET_DEST_EMPTY =	0,
+	CDS_WFCQ_RET_DEST_NON_EMPTY =	1,
+	CDS_WFCQ_RET_SRC_EMPTY = 	2,
+};
+
+enum cds_wfcq_state {
+	CDS_WFCQ_STATE_LAST =		(1U << 0),
+};
+
+struct cds_wfcq_node {
+	struct cds_wfcq_node *next;
+};
+
+/*
+ * Do not put head and tail on the same cache-line if concurrent
+ * enqueue/dequeue are expected from many CPUs. This eliminates
+ * false-sharing between enqueue and dequeue.
+ */
+struct __cds_wfcq_head {
+	struct cds_wfcq_node node;
+};
+
+struct cds_wfcq_head {
+	struct cds_wfcq_node node;
+	pthread_mutex_t lock;
+};
+
+#ifndef __cplusplus
+/*
+ * The transparent union allows calling functions that work on both
+ * struct cds_wfcq_head and struct __cds_wfcq_head on any of those two
+ * types.
+ */
+typedef union {
+	struct __cds_wfcq_head *_h;
+	struct cds_wfcq_head *h;
+} __attribute__((__transparent_union__)) cds_wfcq_head_ptr_t;
+
+/*
+ * This static inline is only present for compatibility with C++. It is
+ * effect-less in C.
+ */
+static inline struct __cds_wfcq_head *__cds_wfcq_head_cast(struct __cds_wfcq_head *head)
+{
+	return head;
+}
+
+/*
+ * This static inline is only present for compatibility with C++. It is
+ * effect-less in C.
+ */
+static inline struct cds_wfcq_head *cds_wfcq_head_cast(struct cds_wfcq_head *head)
+{
+	return head;
+}
+#else /* #ifndef __cplusplus */
+
+/* C++ ignores transparent union. */
+typedef union {
+	struct __cds_wfcq_head *_h;
+	struct cds_wfcq_head *h;
+} cds_wfcq_head_ptr_t;
+
+/* C++ ignores transparent union. Requires an explicit conversion. */
+static inline cds_wfcq_head_ptr_t __cds_wfcq_head_cast(struct __cds_wfcq_head *head)
+{
+	cds_wfcq_head_ptr_t ret = { ._h = head };
+	return ret;
+}
+/* C++ ignores transparent union. Requires an explicit conversion. */
+static inline cds_wfcq_head_ptr_t cds_wfcq_head_cast(struct cds_wfcq_head *head)
+{
+	cds_wfcq_head_ptr_t ret = { .h = head };
+	return ret;
+}
+#endif /* #else #ifndef __cplusplus */
+
+struct cds_wfcq_tail {
+	struct cds_wfcq_node *p;
+};
+
+#include "static-wfcqueue.h"
+
+#define cds_wfcq_node_init		_cds_wfcq_node_init
+#define cds_wfcq_init			_cds_wfcq_init
+#define __cds_wfcq_init			___cds_wfcq_init
+#define cds_wfcq_destroy		_cds_wfcq_destroy
+#define cds_wfcq_empty			_cds_wfcq_empty
+#define cds_wfcq_enqueue		_cds_wfcq_enqueue
+
+/* Dequeue locking */
+#define cds_wfcq_dequeue_lock		_cds_wfcq_dequeue_lock
+#define cds_wfcq_dequeue_unlock		_cds_wfcq_dequeue_unlock
+
+/* Locking performed within cds_wfcq calls. */
+#define cds_wfcq_dequeue_blocking	_cds_wfcq_dequeue_blocking
+#define cds_wfcq_dequeue_with_state_blocking	\
+					_cds_wfcq_dequeue_with_state_blocking
+#define cds_wfcq_splice_blocking	_cds_wfcq_splice_blocking
+#define cds_wfcq_first_blocking		_cds_wfcq_first_blocking
+#define cds_wfcq_next_blocking		_cds_wfcq_next_blocking
+
+/* Locking ensured by caller by holding cds_wfcq_dequeue_lock() */
+#define __cds_wfcq_dequeue_blocking	___cds_wfcq_dequeue_blocking
+#define __cds_wfcq_dequeue_with_state_blocking	\
+					___cds_wfcq_dequeue_with_state_blocking
+#define __cds_wfcq_splice_blocking	___cds_wfcq_splice_blocking
+#define __cds_wfcq_first_blocking	___cds_wfcq_first_blocking
+#define __cds_wfcq_next_blocking	___cds_wfcq_next_blocking
+
+/*
+ * Locking ensured by caller by holding cds_wfcq_dequeue_lock().
+ * Non-blocking: deque, first, next return CDS_WFCQ_WOULDBLOCK if they
+ * need to block. splice returns nonzero if it needs to block.
+ */
+#define __cds_wfcq_dequeue_nonblocking	___cds_wfcq_dequeue_nonblocking
+#define __cds_wfcq_dequeue_with_state_nonblocking	\
+				___cds_wfcq_dequeue_with_state_nonblocking
+#define __cds_wfcq_splice_nonblocking	___cds_wfcq_splice_nonblocking
+#define __cds_wfcq_first_nonblocking	___cds_wfcq_first_nonblocking
+#define __cds_wfcq_next_nonblocking	___cds_wfcq_next_nonblocking
+
+/*
+ * __cds_wfcq_for_each_blocking: Iterate over all nodes in a queue,
+ * without dequeuing them.
+ * @head: head of the queue (struct cds_wfcq_head or __cds_wfcq_head pointer).
+ * @tail: tail of the queue (struct cds_wfcq_tail pointer).
+ * @node: iterator on the queue (struct cds_wfcq_node pointer).
+ *
+ * Content written into each node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Dequeue/splice/iteration mutual exclusion should be ensured by the
+ * caller.
+ */
+#define __cds_wfcq_for_each_blocking(head, tail, node)		\
+	for (node = __cds_wfcq_first_blocking(head, tail);	\
+		node != NULL;					\
+		node = __cds_wfcq_next_blocking(head, tail, node))
+
+/*
+ * __cds_wfcq_for_each_blocking_safe: Iterate over all nodes in a queue,
+ * without dequeuing them. Safe against deletion.
+ * @head: head of the queue (struct cds_wfcq_head or __cds_wfcq_head pointer).
+ * @tail: tail of the queue (struct cds_wfcq_tail pointer).
+ * @node: iterator on the queue (struct cds_wfcq_node pointer).
+ * @n: struct cds_wfcq_node pointer holding the next pointer (used
+ *     internally).
+ *
+ * Content written into each node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ * Dequeue/splice/iteration mutual exclusion should be ensured by the
+ * caller.
+ */
+#define __cds_wfcq_for_each_blocking_safe(head, tail, node, n)		       \
+	for (node = __cds_wfcq_first_blocking(head, tail),		       \
+			n = (node ? __cds_wfcq_next_blocking(head, tail, node) : NULL); \
+		node != NULL;						       \
+		node = n, n = (node ? __cds_wfcq_next_blocking(head, tail, node) : NULL))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _URCU_WFCQUEUE_H */
diff --git a/contrib/userspace-rcu/wfstack.h b/contrib/userspace-rcu/wfstack.h
new file mode 100644
index 00000000000..738fd1cfd33
--- /dev/null
+++ b/contrib/userspace-rcu/wfstack.h
@@ -0,0 +1,178 @@
+#ifndef _URCU_WFSTACK_H
+#define _URCU_WFSTACK_H
+
+/*
+ * urcu/wfstack.h
+ *
+ * Userspace RCU library - Stack with wait-free push, blocking traversal.
+ *
+ * Copyright 2010-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Adapted from userspace-rcu 0.10 because version 0.7 doesn't support a stack
+ * without mutex. The non-LGPL section has been removed. */
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <urcu/compiler.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Stack with wait-free push, blocking traversal.
+ *
+ * Stack implementing push, pop, pop_all operations, as well as iterator
+ * on the stack head returned by pop_all.
+ *
+ * Wait-free operations: cds_wfs_push, __cds_wfs_pop_all, cds_wfs_empty,
+ *                       cds_wfs_first.
+ * Blocking operations: cds_wfs_pop, cds_wfs_pop_all, cds_wfs_next,
+ *                      iteration on stack head returned by pop_all.
+ *
+ * Synchronization table:
+ *
+ * External synchronization techniques described in the API below is
+ * required between pairs marked with "X". No external synchronization
+ * required between pairs marked with "-".
+ *
+ *                      cds_wfs_push  __cds_wfs_pop  __cds_wfs_pop_all
+ * cds_wfs_push               -              -                  -
+ * __cds_wfs_pop              -              X                  X
+ * __cds_wfs_pop_all          -              X                  -
+ *
+ * cds_wfs_pop and cds_wfs_pop_all use an internal mutex to provide
+ * synchronization.
+ */
+
+#define CDS_WFS_WOULDBLOCK	((void *) -1UL)
+
+enum cds_wfs_state {
+	CDS_WFS_STATE_LAST =		(1U << 0),
+};
+
+/*
+ * struct cds_wfs_node is returned by __cds_wfs_pop, and also used as
+ * iterator on stack. It is not safe to dereference the node next
+ * pointer when returned by __cds_wfs_pop_blocking.
+ */
+struct cds_wfs_node {
+	struct cds_wfs_node *next;
+};
+
+/*
+ * struct cds_wfs_head is returned by __cds_wfs_pop_all, and can be used
+ * to begin iteration on the stack. "node" needs to be the first field of
+ * cds_wfs_head, so the end-of-stack pointer value can be used for both
+ * types.
+ */
+struct cds_wfs_head {
+	struct cds_wfs_node node;
+};
+
+struct __cds_wfs_stack {
+	struct cds_wfs_head *head;
+};
+
+struct cds_wfs_stack {
+	struct cds_wfs_head *head;
+	pthread_mutex_t lock;
+};
+
+/*
+ * The transparent union allows calling functions that work on both
+ * struct cds_wfs_stack and struct __cds_wfs_stack on any of those two
+ * types.
+ */
+typedef union {
+	struct __cds_wfs_stack *_s;
+	struct cds_wfs_stack *s;
+} __attribute__((__transparent_union__)) cds_wfs_stack_ptr_t;
+
+#include "static-wfstack.h"
+
+#define cds_wfs_node_init		_cds_wfs_node_init
+#define cds_wfs_init			_cds_wfs_init
+#define cds_wfs_destroy			_cds_wfs_destroy
+#define __cds_wfs_init			___cds_wfs_init
+#define cds_wfs_empty			_cds_wfs_empty
+#define cds_wfs_push			_cds_wfs_push
+
+/* Locking performed internally */
+#define cds_wfs_pop_blocking		_cds_wfs_pop_blocking
+#define cds_wfs_pop_with_state_blocking	_cds_wfs_pop_with_state_blocking
+#define cds_wfs_pop_all_blocking	_cds_wfs_pop_all_blocking
+
+/*
+ * For iteration on cds_wfs_head returned by __cds_wfs_pop_all or
+ * cds_wfs_pop_all_blocking.
+ */
+#define cds_wfs_first			_cds_wfs_first
+#define cds_wfs_next_blocking		_cds_wfs_next_blocking
+#define cds_wfs_next_nonblocking	_cds_wfs_next_nonblocking
+
+/* Pop locking with internal mutex */
+#define cds_wfs_pop_lock		_cds_wfs_pop_lock
+#define cds_wfs_pop_unlock		_cds_wfs_pop_unlock
+
+/* Synchronization ensured by the caller. See synchronization table. */
+#define __cds_wfs_pop_blocking		___cds_wfs_pop_blocking
+#define __cds_wfs_pop_with_state_blocking	\
+					___cds_wfs_pop_with_state_blocking
+#define __cds_wfs_pop_nonblocking	___cds_wfs_pop_nonblocking
+#define __cds_wfs_pop_with_state_nonblocking	\
+					___cds_wfs_pop_with_state_nonblocking
+#define __cds_wfs_pop_all		___cds_wfs_pop_all
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * cds_wfs_for_each_blocking: Iterate over all nodes returned by
+ * __cds_wfs_pop_all().
+ * @head: head of the queue (struct cds_wfs_head pointer).
+ * @node: iterator (struct cds_wfs_node pointer).
+ *
+ * Content written into each node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ */
+#define cds_wfs_for_each_blocking(head, node)			\
+	for (node = cds_wfs_first(head);			\
+		node != NULL;					\
+		node = cds_wfs_next_blocking(node))
+
+/*
+ * cds_wfs_for_each_blocking_safe: Iterate over all nodes returned by
+ * __cds_wfs_pop_all(). Safe against deletion.
+ * @head: head of the queue (struct cds_wfs_head pointer).
+ * @node: iterator (struct cds_wfs_node pointer).
+ * @n: struct cds_wfs_node pointer holding the next pointer (used
+ *     internally).
+ *
+ * Content written into each node before enqueue is guaranteed to be
+ * consistent, but no other memory ordering is ensured.
+ */
+#define cds_wfs_for_each_blocking_safe(head, node, n)			   \
+	for (node = cds_wfs_first(head),				   \
+			n = (node ? cds_wfs_next_blocking(node) : NULL);   \
+		node != NULL;						   \
+		node = n, n = (node ? cds_wfs_next_blocking(node) : NULL))
+
+#endif /* _URCU_WFSTACK_H */
diff --git a/contrib/uuid/clear.c b/contrib/uuid/clear.c
deleted file mode 100644
index 0362d073e3d..00000000000
--- a/contrib/uuid/clear.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * clear.c -- Clear a UUID
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include "string.h"
-
-#include "uuidP.h"
-
-void gf_uuid_clear(uuid_t uu)
-{
-	memset(uu, 0, 16);
-}
-
diff --git a/contrib/uuid/compare.c b/contrib/uuid/compare.c
deleted file mode 100644
index dba4c5bf8cf..00000000000
--- a/contrib/uuid/compare.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * compare.c --- compare whether or not two UUID's are the same
- *
- * Returns 0 if the two UUID's are different, and 1 if they are the same.
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include "uuidP.h"
-#include <string.h>
-
-#define UUCMP(u1,u2) if (u1 != u2) return((u1 < u2) ? -1 : 1);
-
-int gf_uuid_compare(const uuid_t uu1, const uuid_t uu2)
-{
-	struct uuid	uuid1, uuid2;
-
-	uuid_unpack(uu1, &uuid1);
-	uuid_unpack(uu2, &uuid2);
-
-	UUCMP(uuid1.time_low, uuid2.time_low);
-	UUCMP(uuid1.time_mid, uuid2.time_mid);
-	UUCMP(uuid1.time_hi_and_version, uuid2.time_hi_and_version);
-	UUCMP(uuid1.clock_seq, uuid2.clock_seq);
-	return memcmp(uuid1.node, uuid2.node, 6);
-}
-
diff --git a/contrib/uuid/copy.c b/contrib/uuid/copy.c
deleted file mode 100644
index 45983bfd48b..00000000000
--- a/contrib/uuid/copy.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * copy.c --- copy UUIDs
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include "uuidP.h"
-
-void gf_uuid_copy(uuid_t dst, const uuid_t src)
-{
-	unsigned char		*cp1;
-	const unsigned char	*cp2;
-	int			i;
-
-	for (i=0, cp1 = dst, cp2 = src; i < 16; i++)
-		*cp1++ = *cp2++;
-}
diff --git a/contrib/uuid/gen_uuid.c b/contrib/uuid/gen_uuid.c
deleted file mode 100644
index 1ec156f76ff..00000000000
--- a/contrib/uuid/gen_uuid.c
+++ /dev/null
@@ -1,686 +0,0 @@
-/*
- * gen_uuid.c --- generate a DCE-compatible uuid
- *
- * Copyright (C) 1996, 1997, 1998, 1999 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-/*
- * Force inclusion of SVID stuff since we need it if we're compiling in
- * gcc-wall wall mode
- */
-#define _SVID_SOURCE
-
-#include "config.h"
-#ifdef _WIN32
-#define _WIN32_WINNT 0x0500
-#include <windows.h>
-#define UUID MYUUID
-#endif
-#include <stdio.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <string.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#include <sys/wait.h>
-#include <sys/stat.h>
-#ifdef HAVE_SYS_FILE_H
-#include <sys/file.h>
-#endif
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_UN_H
-#include <sys/un.h>
-#endif
-#ifdef HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h>
-#endif
-#ifdef HAVE_NET_IF_H
-#include <net/if.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-#ifdef HAVE_NET_IF_DL_H
-#include <net/if_dl.h>
-#endif
-#if defined(__linux__) && defined(HAVE_SYS_SYSCALL_H)
-#include <sys/syscall.h>
-#endif
-#ifdef HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
-#endif
-#include <limits.h>
-
-#include "uuidP.h"
-#include "uuidd.h"
-
-#ifdef HAVE_SRANDOM
-#define srand(x) 	srandom(x)
-#define rand() 		random()
-#endif
-
-#ifdef TLS
-#define THREAD_LOCAL static TLS
-#else
-#define THREAD_LOCAL static
-#endif
-
-#if defined(__linux__) && defined(__NR_gettid) && defined(HAVE_JRAND48)
-#define DO_JRAND_MIX
-THREAD_LOCAL unsigned short jrand_seed[3];
-#endif
-
-#ifndef OPEN_MAX
-#define OPEN_MAX 1024
-#endif
-
-#ifdef _WIN32
-static void gettimeofday (struct timeval *tv, void *dummy)
-{
-	FILETIME	ftime;
-	uint64_t	n;
-
-	GetSystemTimeAsFileTime (&ftime);
-	n = (((uint64_t) ftime.dwHighDateTime << 32)
-	     + (uint64_t) ftime.dwLowDateTime);
-	if (n) {
-		n /= 10;
-		n -= ((369 * 365 + 89) * (uint64_t) 86400) * 1000000;
-	}
-
-	tv->tv_sec = n / 1000000;
-	tv->tv_usec = n % 1000000;
-}
-
-static int getuid (void)
-{
-	return 1;
-}
-#endif
-
-static int get_random_fd(void)
-{
-	struct timeval	tv;
-	static int	fd = -2;
-	int		i;
-
-	if (fd == -2) {
-		gettimeofday(&tv, 0);
-#ifndef _WIN32
-		fd = open("/dev/urandom", O_RDONLY);
-		if (fd == -1)
-			fd = open("/dev/random", O_RDONLY | O_NONBLOCK);
-		if (fd >= 0) {
-			i = fcntl(fd, F_GETFD);
-			if (i >= 0)
-				fcntl(fd, F_SETFD, i | FD_CLOEXEC);
-		}
-#endif
-		srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec);
-#ifdef DO_JRAND_MIX
-		jrand_seed[0] = getpid() ^ (tv.tv_sec & 0xFFFF);
-		jrand_seed[1] = getppid() ^ (tv.tv_usec & 0xFFFF);
-		jrand_seed[2] = (tv.tv_sec ^ tv.tv_usec) >> 16;
-#endif
-	}
-	/* Crank the random number generator a few times */
-	gettimeofday(&tv, 0);
-	for (i = (tv.tv_sec ^ tv.tv_usec) & 0x1F; i > 0; i--)
-		rand();
-	return fd;
-}
-
-
-/*
- * Generate a series of random bytes.  Use /dev/urandom if possible,
- * and if not, use srandom/random.
- */
-static void get_random_bytes(void *buf, int nbytes)
-{
-	int i, n = nbytes, fd = get_random_fd();
-	int lose_counter = 0;
-	unsigned char *cp = (unsigned char *) buf;
-#ifdef DO_JRAND_MIX
-	unsigned short tmp_seed[3];
-#endif
-	if (fd >= 0) {
-		while (n > 0) {
-			i = read(fd, cp, n);
-			if (i <= 0) {
-				if (lose_counter++ > 16)
-					break;
-				continue;
-			}
-			n -= i;
-			cp += i;
-			lose_counter = 0;
-		}
-	}
-
-	/*
-	 * We do this all the time, but this is the only source of
-	 * randomness if /dev/random/urandom is out to lunch.
-	 */
-	for (cp = buf, i = 0; i < nbytes; i++)
-		*cp++ ^= (rand() >> 7) & 0xFF;
-#ifdef DO_JRAND_MIX
-	memcpy(tmp_seed, jrand_seed, sizeof(tmp_seed));
-	jrand_seed[2] = jrand_seed[2] ^ syscall(__NR_gettid);
-	for (cp = buf, i = 0; i < nbytes; i++)
-		*cp++ ^= (jrand48(tmp_seed) >> 7) & 0xFF;
-	memcpy(jrand_seed, tmp_seed,
-	       sizeof(jrand_seed)-sizeof(unsigned short));
-#endif
-
-	return;
-}
-
-/*
- * Get the ethernet hardware address, if we can find it...
- *
- * XXX for a windows version, probably should use GetAdaptersInfo:
- * http://www.codeguru.com/cpp/i-n/network/networkinformation/article.php/c5451
- * commenting out get_node_id just to get gen_uuid to compile under windows
- * is not the right way to go!
- */
-static int get_node_id(unsigned char *node_id)
-{
-#ifdef HAVE_NET_IF_H
-	int 		sd;
-	struct ifreq 	ifr, *ifrp;
-	struct ifconf 	ifc;
-	char buf[1024];
-	int		n, i;
-	unsigned char 	*a;
-#ifdef HAVE_NET_IF_DL_H
-	struct sockaddr_dl *sdlp;
-#endif
-
-/*
- * BSD 4.4 defines the size of an ifreq to be
- * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
- * However, under earlier systems, sa_len isn't present, so the size is
- * just sizeof(struct ifreq)
- */
-#ifdef HAVE_SA_LEN
-#ifndef max
-#define max(a,b) ((a) > (b) ? (a) : (b))
-#endif
-#define ifreq_size(i) max(sizeof(struct ifreq),\
-     sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
-#else
-#define ifreq_size(i) sizeof(struct ifreq)
-#endif /* HAVE_SA_LEN*/
-
-	sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
-	if (sd < 0) {
-		return -1;
-	}
-	memset(buf, 0, sizeof(buf));
-	ifc.ifc_len = sizeof(buf);
-	ifc.ifc_buf = buf;
-	if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
-		close(sd);
-		return -1;
-	}
-	n = ifc.ifc_len;
-	for (i = 0; i < n; i+= ifreq_size(*ifrp) ) {
-		ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
-		strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
-#ifdef SIOCGIFHWADDR
-		if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
-			continue;
-		a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
-#else
-#ifdef SIOCGENADDR
-		if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
-			continue;
-		a = (unsigned char *) ifr.ifr_enaddr;
-#else
-#ifdef HAVE_NET_IF_DL_H
-		sdlp = (struct sockaddr_dl *) &ifrp->ifr_addr;
-		if ((sdlp->sdl_family != AF_LINK) || (sdlp->sdl_alen != 6))
-			continue;
-		a = (unsigned char *) &sdlp->sdl_data[sdlp->sdl_nlen];
-#else
-		/*
-		 * XXX we don't have a way of getting the hardware
-		 * address
-		 */
-		close(sd);
-		return 0;
-#endif /* HAVE_NET_IF_DL_H */
-#endif /* SIOCGENADDR */
-#endif /* SIOCGIFHWADDR */
-		if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
-			continue;
-		if (node_id) {
-			memcpy(node_id, a, 6);
-			close(sd);
-			return 1;
-		}
-	}
-	close(sd);
-#endif
-	return 0;
-}
-
-/* Assume that the gettimeofday() has microsecond granularity */
-#define MAX_ADJUSTMENT 10
-
-static int get_clock(uint32_t *clock_high, uint32_t *clock_low,
-		     uint16_t *ret_clock_seq, int *num)
-{
-	THREAD_LOCAL int		adjustment = 0;
-	THREAD_LOCAL struct timeval	last = {0, 0};
-	THREAD_LOCAL int		state_fd = -2;
-	THREAD_LOCAL FILE		*state_f;
-	THREAD_LOCAL uint16_t		clock_seq;
-	struct timeval 			tv;
-	struct flock			fl;
-	uint64_t			clock_reg;
-	mode_t				save_umask;
-	int				len;
-
-	if (state_fd == -2) {
-		save_umask = umask(0);
-		state_fd = open("/var/lib/libuuid/clock.txt",
-				O_RDWR|O_CREAT, 0660);
-		(void) umask(save_umask);
-		state_f = fdopen(state_fd, "r+");
-		if (!state_f) {
-			close(state_fd);
-			state_fd = -1;
-		}
-	}
-	fl.l_type = F_WRLCK;
-	fl.l_whence = SEEK_SET;
-	fl.l_start = 0;
-	fl.l_len = 0;
-	fl.l_pid = 0;
-	if (state_fd >= 0) {
-		rewind(state_f);
-		while (fcntl(state_fd, F_SETLKW, &fl) < 0) {
-			if ((errno == EAGAIN) || (errno == EINTR))
-				continue;
-			fclose(state_f);
-			close(state_fd);
-			state_fd = -1;
-			break;
-		}
-	}
-	if (state_fd >= 0) {
-		unsigned int cl;
-		unsigned long tv1, tv2;
-		int a;
-
-		if (fscanf(state_f, "clock: %04x tv: %lu %lu adj: %d\n",
-			   &cl, &tv1, &tv2, &a) == 4) {
-			clock_seq = cl & 0x3FFF;
-			last.tv_sec = tv1;
-			last.tv_usec = tv2;
-			adjustment = a;
-		}
-	}
-
-	if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
-		get_random_bytes(&clock_seq, sizeof(clock_seq));
-		clock_seq &= 0x3FFF;
-		gettimeofday(&last, 0);
-		last.tv_sec--;
-	}
-
-try_again:
-	gettimeofday(&tv, 0);
-	if ((tv.tv_sec < last.tv_sec) ||
-	    ((tv.tv_sec == last.tv_sec) &&
-	     (tv.tv_usec < last.tv_usec))) {
-		clock_seq = (clock_seq+1) & 0x3FFF;
-		adjustment = 0;
-		last = tv;
-	} else if ((tv.tv_sec == last.tv_sec) &&
-	    (tv.tv_usec == last.tv_usec)) {
-		if (adjustment >= MAX_ADJUSTMENT)
-			goto try_again;
-		adjustment++;
-	} else {
-		adjustment = 0;
-		last = tv;
-	}
-
-	clock_reg = tv.tv_usec*10 + adjustment;
-	clock_reg += ((uint64_t) tv.tv_sec)*10000000;
-	clock_reg += (((uint64_t) 0x01B21DD2) << 32) + 0x13814000;
-
-	if (num && (*num > 1)) {
-		adjustment += *num - 1;
-		last.tv_usec += adjustment / 10;
-		adjustment = adjustment % 10;
-		last.tv_sec += last.tv_usec / 1000000;
-		last.tv_usec = last.tv_usec % 1000000;
-	}
-
-	if (state_fd > 0) {
-		rewind(state_f);
-		len = fprintf(state_f, 
-			      "clock: %04x tv: %016lu %08lu adj: %08d\n",
-			      clock_seq, last.tv_sec, last.tv_usec, adjustment);
-		fflush(state_f);
-		if (ftruncate(state_fd, len) < 0) {
-			fprintf(state_f, "                   \n");
-			fflush(state_f);
-		}
-		rewind(state_f);
-		fl.l_type = F_UNLCK;
-		fcntl(state_fd, F_SETLK, &fl);
-	}
-
-	*clock_high = clock_reg >> 32;
-	*clock_low = clock_reg;
-	*ret_clock_seq = clock_seq;
-	return 0;
-}
-
-#if defined(USE_UUIDD) && defined(HAVE_SYS_UN_H)
-static ssize_t read_all(int fd, char *buf, size_t count)
-{
-	ssize_t ret;
-	ssize_t c = 0;
-	int tries = 0;
-
-	memset(buf, 0, count);
-	while (count > 0) {
-		ret = read(fd, buf, count);
-		if (ret <= 0) {
-			if ((errno == EAGAIN || errno == EINTR || ret == 0) &&
-			    (tries++ < 5))
-				continue;
-			return c ? c : -1;
-		}
-		if (ret > 0)
-			tries = 0;
-		count -= ret;
-		buf += ret;
-		c += ret;
-	}
-	return c;
-}
-#endif
-
-/*
- * Close all file descriptors
- */
-#if defined(USE_UUIDD) && defined(HAVE_SYS_UN_H)
-static void close_all_fds(void)
-{
-#ifdef F_CLOSEM
-	(void)fcntl(0, F_CLOSEM);
-	(void)open("/dev/null", O_RDWR); /* stdin */
-	(void)open("/dev/null", O_RDWR); /* stdout */
-	(void)open("/dev/null", O_RDWR); /* stderr */
-#else /* F_CLOSEM */
-	int i, max;
-
-#if defined(HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
-	max = sysconf(_SC_OPEN_MAX);
-#elif defined(HAVE_GETDTABLESIZE)
-	max = getdtablesize();
-#elif defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
-	struct rlimit rl;
-
-	getrlimit(RLIMIT_NOFILE, &rl);
-	max = rl.rlim_cur;
-#else
-	max = OPEN_MAX;
-#endif
-
-	for (i=0; i < max; i++) {
-		close(i);
-		if (i <= 2)
-			open("/dev/null", O_RDWR);
-	}
-#endif /* F_CLOSEM */
-}
-#endif
-
-
-/*
- * Try using the uuidd daemon to generate the UUID
- *
- * Returns 0 on success, non-zero on failure.
- */
-static int get_uuid_via_daemon(int op, uuid_t out, int *num)
-{
-#if defined(USE_UUIDD) && defined(HAVE_SYS_UN_H)
-	char op_buf[64];
-	int op_len;
-	int s;
-	ssize_t ret;
-	int32_t reply_len = 0, expected = 16;
-	struct sockaddr_un srv_addr;
-	struct stat st;
-	pid_t pid;
-	static const char *uuidd_path = UUIDD_PATH;
-	static int access_ret = -2;
-	static int start_attempts = 0;
-
-	if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
-		return -1;
-
-	srv_addr.sun_family = AF_UNIX;
-	strcpy(srv_addr.sun_path, UUIDD_SOCKET_PATH);
-
-	if (connect(s, (const struct sockaddr *) &srv_addr,
-		    sizeof(struct sockaddr_un)) < 0) {
-		if (access_ret == -2)
-			access_ret = access(uuidd_path, X_OK);
-		if (access_ret == 0)
-			access_ret = stat(uuidd_path, &st);
-		if (access_ret == 0 && (st.st_mode & (S_ISUID | S_ISGID)) == 0)
-			access_ret = access(UUIDD_DIR, W_OK);
-		if (access_ret == 0 && start_attempts++ < 5) {
-			if ((pid = fork()) == 0) {
-				close_all_fds();
-				execl(uuidd_path, "uuidd", "-qT", "300",
-				      (char *) NULL);
-				exit(1);
-			}
-			(void) waitpid(pid, 0, 0);
-			if (connect(s, (const struct sockaddr *) &srv_addr,
-				    sizeof(struct sockaddr_un)) < 0)
-				goto fail;
-		} else
-			goto fail;
-	}
-	op_buf[0] = op;
-	op_len = 1;
-	if (op == UUIDD_OP_BULK_TIME_UUID) {
-		memcpy(op_buf+1, num, sizeof(*num));
-		op_len += sizeof(*num);
-		expected += sizeof(*num);
-	}
-
-	ret = write(s, op_buf, op_len);
-	if (ret < 1)
-		goto fail;
-
-	ret = read_all(s, (char *) &reply_len, sizeof(reply_len));
-	if (ret < 0)
-		goto fail;
-
-	if (reply_len != expected)
-		goto fail;
-
-	ret = read_all(s, op_buf, reply_len);
-
-	if (op == UUIDD_OP_BULK_TIME_UUID)
-		memcpy(op_buf+16, num, sizeof(int));
-
-	memcpy(out, op_buf, 16);
-
-	close(s);
-	return ((ret == expected) ? 0 : -1);
-
-fail:
-	close(s);
-#endif
-	return -1;
-}
-
-void uuid__generate_time(uuid_t out, int *num)
-{
-	static unsigned char node_id[6];
-	static int has_init = 0;
-	struct uuid uu;
-	uint32_t	clock_mid;
-
-	if (!has_init) {
-		if (get_node_id(node_id) <= 0) {
-			get_random_bytes(node_id, 6);
-			/*
-			 * Set multicast bit, to prevent conflicts
-			 * with IEEE 802 addresses obtained from
-			 * network cards
-			 */
-			node_id[0] |= 0x01;
-		}
-		has_init = 1;
-	}
-	get_clock(&clock_mid, &uu.time_low, &uu.clock_seq, num);
-	uu.clock_seq |= 0x8000;
-	uu.time_mid = (uint16_t) clock_mid;
-	uu.time_hi_and_version = ((clock_mid >> 16) & 0x0FFF) | 0x1000;
-	memcpy(uu.node, node_id, 6);
-	uuid_pack(&uu, out);
-}
-
-void gf_uuid_generate_time(uuid_t out)
-{
-#ifdef TLS
-	THREAD_LOCAL int		num = 0;
-	THREAD_LOCAL struct uuid	uu;
-	THREAD_LOCAL time_t		last_time = 0;
-	time_t				now;
-
-	if (num > 0) {
-		now = time(0);
-		if (now > last_time+1)
-			num = 0;
-	}
-	if (num <= 0) {
-		num = 1000;
-		if (get_uuid_via_daemon(UUIDD_OP_BULK_TIME_UUID,
-					out, &num) == 0) {
-			last_time = time(0);
-			uuid_unpack(out, &uu);
-			num--;
-			return;
-		}
-		num = 0;
-	}
-	if (num > 0) {
-		uu.time_low++;
-		if (uu.time_low == 0) {
-			uu.time_mid++;
-			if (uu.time_mid == 0)
-				uu.time_hi_and_version++;
-		}
-		num--;
-		uuid_pack(&uu, out);
-		return;
-	}
-#else
-	if (get_uuid_via_daemon(UUIDD_OP_TIME_UUID, out, 0) == 0)
-		return;
-#endif
-
-	uuid__generate_time(out, 0);
-}
-
-
-void uuid__generate_random(uuid_t out, int *num)
-{
-	uuid_t	buf;
-	struct uuid uu;
-	int i, n;
-
-	if (!num || !*num)
-		n = 1;
-	else
-		n = *num;
-
-	for (i = 0; i < n; i++) {
-		get_random_bytes(buf, sizeof(buf));
-		uuid_unpack(buf, &uu);
-
-		uu.clock_seq = (uu.clock_seq & 0x3FFF) | 0x8000;
-		uu.time_hi_and_version = (uu.time_hi_and_version & 0x0FFF)
-			| 0x4000;
-		uuid_pack(&uu, out);
-		out += sizeof(uuid_t);
-	}
-}
-
-void gf_uuid_generate_random(uuid_t out)
-{
-	int	num = 1;
-	/* No real reason to use the daemon for random uuid's -- yet */
-
-	uuid__generate_random(out, &num);
-}
-
-
-/*
- * This is the generic front-end to gf_uuid_generate_random and
- * gf_uuid_generate_time.  It uses gf_uuid_generate_random only if
- * /dev/urandom is available, since otherwise we won't have
- * high-quality randomness.
- */
-void gf_uuid_generate(uuid_t out)
-{
-	if (get_random_fd() >= 0)
-		gf_uuid_generate_random(out);
-	else
-		gf_uuid_generate_time(out);
-}
diff --git a/contrib/uuid/gen_uuid_nt.c b/contrib/uuid/gen_uuid_nt.c
deleted file mode 100644
index 91828b7a13b..00000000000
--- a/contrib/uuid/gen_uuid_nt.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * gen_uuid_nt.c -- Use NT api to generate uuid
- *
- * Written by Andrey Shedel (andreys@ns.cr.cyco.com)
- */
-
-
-#include "uuidP.h"
-
-#pragma warning(push,4)
-
-#pragma comment(lib, "ntdll.lib")
-
-//
-// Here is a nice example why it's not a good idea
-// to use native API in ordinary applications.
-// Number of parameters in function below was changed from 3 to 4
-// for NT5.
-//
-//
-// NTSYSAPI
-// NTSTATUS
-// NTAPI
-// NtAllocateUuids(
-//     OUT PULONG p1,
-//     OUT PULONG p2,
-//     OUT PULONG p3,
-//     OUT PUCHAR Seed // 6 bytes
-//   );
-//
-//
-
-unsigned long
-__stdcall
-NtAllocateUuids(
-   void* p1,  // 8 bytes
-   void* p2,  // 4 bytes
-   void* p3   // 4 bytes
-   );
-
-typedef
-unsigned long
-(__stdcall*
-NtAllocateUuids_2000)(
-   void* p1,  // 8 bytes
-   void* p2,  // 4 bytes
-   void* p3,  // 4 bytes
-   void* seed // 6 bytes
-   );
-
-
-
-//
-// Nice, but instead of including ntddk.h ot winnt.h
-// I should define it here because they MISSED __stdcall in those headers.
-//
-
-__declspec(dllimport)
-struct _TEB*
-__stdcall
-NtCurrentTeb(void);
-
-
-//
-// The only way to get version information from the system is to examine
-// one stored in PEB. But it's pretty dangerouse because this value could
-// be altered in image header.
-//
-
-static
-int
-Nt5(void)
-{
-	//return NtCuttentTeb()->Peb->OSMajorVersion >= 5;
-	return (int)*(int*)((char*)(int)(*(int*)((char*)NtCurrentTeb() + 0x30)) + 0xA4) >= 5;
-}
-
-
-
-
-void gf_uuid_generate(uuid_t out)
-{
-	if(Nt5())
-	{
-		unsigned char seed[6];
-		((NtAllocateUuids_2000)NtAllocateUuids)(out, ((char*)out)+8, ((char*)out)+12, &seed[0] );
-	}
-	else
-	{
-		NtAllocateUuids(out, ((char*)out)+8, ((char*)out)+12);
-	}
-}
diff --git a/contrib/uuid/isnull.c b/contrib/uuid/isnull.c
deleted file mode 100644
index 20d8fcef6da..00000000000
--- a/contrib/uuid/isnull.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * isnull.c --- Check whether or not the UUID is null
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include "uuidP.h"
-
-/* Returns 1 if the uuid is the NULL uuid */
-int gf_uuid_is_null(const uuid_t uu)
-{
-	const unsigned char 	*cp;
-	int			i;
-
-	for (i=0, cp = uu; i < 16; i++)
-		if (*cp++)
-			return 0;
-	return 1;
-}
-
diff --git a/contrib/uuid/pack.c b/contrib/uuid/pack.c
deleted file mode 100644
index 097516d2e2f..00000000000
--- a/contrib/uuid/pack.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Internal routine for packing UUID's
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include <string.h>
-#include "uuidP.h"
-
-void uuid_pack(const struct uuid *uu, uuid_t ptr)
-{
-	uint32_t	tmp;
-	unsigned char	*out = ptr;
-
-	tmp = uu->time_low;
-	out[3] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[2] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[1] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[0] = (unsigned char) tmp;
-
-	tmp = uu->time_mid;
-	out[5] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[4] = (unsigned char) tmp;
-
-	tmp = uu->time_hi_and_version;
-	out[7] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[6] = (unsigned char) tmp;
-
-	tmp = uu->clock_seq;
-	out[9] = (unsigned char) tmp;
-	tmp >>= 8;
-	out[8] = (unsigned char) tmp;
-
-	memcpy(out+10, uu->node, 6);
-}
-
diff --git a/contrib/uuid/parse.c b/contrib/uuid/parse.c
deleted file mode 100644
index 059ae437805..00000000000
--- a/contrib/uuid/parse.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * parse.c --- UUID parsing
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <string.h>
-
-#include "uuidP.h"
-
-int gf_uuid_parse(const char *in, uuid_t uu)
-{
-	struct uuid	uuid;
-	int 		i;
-	const char	*cp;
-	char		buf[3];
-
-	if (strlen(in) != 36)
-		return -1;
-	for (i=0, cp = in; i <= 36; i++,cp++) {
-		if ((i == 8) || (i == 13) || (i == 18) ||
-		    (i == 23)) {
-			if (*cp == '-')
-				continue;
-			else
-				return -1;
-		}
-		if (i== 36)
-			if (*cp == 0)
-				continue;
-		if (!isxdigit(*cp))
-			return -1;
-	}
-	uuid.time_low = strtoul(in, NULL, 16);
-	uuid.time_mid = strtoul(in+9, NULL, 16);
-	uuid.time_hi_and_version = strtoul(in+14, NULL, 16);
-	uuid.clock_seq = strtoul(in+19, NULL, 16);
-	cp = in+24;
-	buf[2] = 0;
-	for (i=0; i < 6; i++) {
-		buf[0] = *cp++;
-		buf[1] = *cp++;
-		uuid.node[i] = strtoul(buf, NULL, 16);
-	}
-
-	uuid_pack(&uuid, uu);
-	return 0;
-}
diff --git a/contrib/uuid/tst_uuid.c b/contrib/uuid/tst_uuid.c
deleted file mode 100644
index 865564b0c34..00000000000
--- a/contrib/uuid/tst_uuid.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * tst_uuid.c --- test program from the UUID library
- *
- * Copyright (C) 1996, 1997, 1998 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#ifdef _WIN32
-#define _WIN32_WINNT 0x0500
-#include <windows.h>
-#define UUID MYUUID
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "uuid.h"
-
-static int test_uuid(const char * uuid, int isValid)
-{
-	static const char * validStr[2] = {"invalid", "valid"};
-	uuid_t uuidBits;
-	int parsedOk;
-
-	parsedOk = gf_uuid_parse(uuid, uuidBits) == 0;
-
-	printf("%s is %s", uuid, validStr[isValid]);
-	if (parsedOk != isValid) {
-		printf(" but gf_uuid_parse says %s\n", validStr[parsedOk]);
-		return 1;
-	}
-	printf(", OK\n");
-	return 0;
-}
-
-#ifdef __GNUC__
-#define ATTR(x) __attribute__(x)
-#else
-#define ATTR(x)
-#endif
-
-int
-main(int argc ATTR((unused)) , char **argv ATTR((unused)))
-{
-	uuid_t		buf, tst;
-	char		str[100];
-	struct timeval	tv;
-	time_t		time_reg;
-	unsigned char	*cp;
-	int i;
-	int failed = 0;
-	int type, variant;
-
-	gf_uuid_generate(buf);
-	gf_uuid_unparse(buf, str);
-	printf("UUID generate = %s\n", str);
-	printf("UUID: ");
-	for (i=0, cp = (unsigned char *) &buf; i < 16; i++) {
-		printf("%02x", *cp++);
-	}
-	printf("\n");
-	type = gf_uuid_type(buf); 	variant = gf_uuid_variant(buf);
-	printf("UUID type = %d, UUID variant = %d\n", type, variant);
-	if (variant != UUID_VARIANT_DCE) {
-		printf("Incorrect UUID Variant; was expecting DCE!\n");
-		failed++;
-	}
-	printf("\n");
-
-	gf_uuid_generate_random(buf);
-	gf_uuid_unparse(buf, str);
-	printf("UUID random string = %s\n", str);
-	printf("UUID: ");
-	for (i=0, cp = (unsigned char *) &buf; i < 16; i++) {
-		printf("%02x", *cp++);
-	}
-	printf("\n");
-	type = gf_uuid_type(buf); 	variant = gf_uuid_variant(buf);
-	printf("UUID type = %d, UUID variant = %d\n", type, variant);
-	if (variant != UUID_VARIANT_DCE) {
-		printf("Incorrect UUID Variant; was expecting DCE!\n");
-		failed++;
-	}
-	if (type != 4) {
-		printf("Incorrect UUID type; was expecting "
-		       "4 (random type)!\n");
-		failed++;
-	}
-	printf("\n");
-
-	gf_uuid_generate_time(buf);
-	gf_uuid_unparse(buf, str);
-	printf("UUID string = %s\n", str);
-	printf("UUID time: ");
-	for (i=0, cp = (unsigned char *) &buf; i < 16; i++) {
-		printf("%02x", *cp++);
-	}
-	printf("\n");
-	type = gf_uuid_type(buf); 	variant = gf_uuid_variant(buf);
-	printf("UUID type = %d, UUID variant = %d\n", type, variant);
-	if (variant != UUID_VARIANT_DCE) {
-		printf("Incorrect UUID Variant; was expecting DCE!\n");
-		failed++;
-	}
-	if (type != 1) {
-		printf("Incorrect UUID type; was expecting "
-		       "1 (time-based type)!\\n");
-		failed++;
-	}
-	tv.tv_sec = 0;
-	tv.tv_usec = 0;
-	time_reg = gf_uuid_time(buf, &tv);
-	printf("UUID time is: (%ld, %ld): %s\n", tv.tv_sec, tv.tv_usec,
-	       ctime(&time_reg));
-	gf_uuid_parse(str, tst);
-	if (!gf_uuid_compare(buf, tst))
-		printf("UUID parse and compare succeeded.\n");
-	else {
-		printf("UUID parse and compare failed!\n");
-		failed++;
-	}
-	gf_uuid_clear(tst);
-	if (gf_uuid_is_null(tst))
-		printf("UUID clear and is null succeeded.\n");
-	else {
-		printf("UUID clear and is null failed!\n");
-		failed++;
-	}
-	gf_uuid_copy(buf, tst);
-	if (!gf_uuid_compare(buf, tst))
-		printf("UUID copy and compare succeeded.\n");
-	else {
-		printf("UUID copy and compare failed!\n");
-		failed++;
-	}
-	failed += test_uuid("84949cc5-4701-4a84-895b-354c584a981b", 1);
-	failed += test_uuid("84949CC5-4701-4A84-895B-354C584A981B", 1);
-	failed += test_uuid("84949cc5-4701-4a84-895b-354c584a981bc", 0);
-	failed += test_uuid("84949cc5-4701-4a84-895b-354c584a981", 0);
-	failed += test_uuid("84949cc5x4701-4a84-895b-354c584a981b", 0);
-	failed += test_uuid("84949cc504701-4a84-895b-354c584a981b", 0);
-	failed += test_uuid("84949cc5-470104a84-895b-354c584a981b", 0);
-	failed += test_uuid("84949cc5-4701-4a840895b-354c584a981b", 0);
-	failed += test_uuid("84949cc5-4701-4a84-895b0354c584a981b", 0);
-	failed += test_uuid("g4949cc5-4701-4a84-895b-354c584a981b", 0);
-	failed += test_uuid("84949cc5-4701-4a84-895b-354c584a981g", 0);
-
-	if (failed) {
-		printf("%d failures.\n", failed);
-		exit(1);
-	}
-	return 0;
-}
diff --git a/contrib/uuid/unpack.c b/contrib/uuid/unpack.c
deleted file mode 100644
index beaaff3ca8a..00000000000
--- a/contrib/uuid/unpack.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Internal routine for unpacking UUID
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include <string.h>
-#include "uuidP.h"
-
-void uuid_unpack(const uuid_t in, struct uuid *uu)
-{
-	const uint8_t	*ptr = in;
-	uint32_t		tmp;
-
-	tmp = *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	uu->time_low = tmp;
-
-	tmp = *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	uu->time_mid = tmp;
-
-	tmp = *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	uu->time_hi_and_version = tmp;
-
-	tmp = *ptr++;
-	tmp = (tmp << 8) | *ptr++;
-	uu->clock_seq = tmp;
-
-	memcpy(uu->node, ptr, 6);
-}
-
diff --git a/contrib/uuid/unparse.c b/contrib/uuid/unparse.c
deleted file mode 100644
index f6e29534140..00000000000
--- a/contrib/uuid/unparse.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * unparse.c -- convert a UUID to string
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include <stdio.h>
-
-#include "uuidP.h"
-
-static const char *fmt_lower =
-	"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
-
-static const char *fmt_upper =
-	"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X";
-
-#ifdef UUID_UNPARSE_DEFAULT_UPPER
-#define FMT_DEFAULT fmt_upper
-#else
-#define FMT_DEFAULT fmt_lower
-#endif
-
-static void gf_uuid_unparse_x(const uuid_t uu, char *out, const char *fmt)
-{
-	struct uuid uuid;
-
-	uuid_unpack(uu, &uuid);
-	sprintf(out, fmt,
-		uuid.time_low, uuid.time_mid, uuid.time_hi_and_version,
-		uuid.clock_seq >> 8, uuid.clock_seq & 0xFF,
-		uuid.node[0], uuid.node[1], uuid.node[2],
-		uuid.node[3], uuid.node[4], uuid.node[5]);
-}
-
-void gf_uuid_unparse_lower(const uuid_t uu, char *out)
-{
-	gf_uuid_unparse_x(uu, out,	fmt_lower);
-}
-
-void gf_uuid_unparse_upper(const uuid_t uu, char *out)
-{
-	gf_uuid_unparse_x(uu, out,	fmt_upper);
-}
-
-void gf_uuid_unparse(const uuid_t uu, char *out)
-{
-	gf_uuid_unparse_x(uu, out, FMT_DEFAULT);
-}
diff --git a/contrib/uuid/uuid.h b/contrib/uuid/uuid.h
deleted file mode 100644
index 97de360ad52..00000000000
--- a/contrib/uuid/uuid.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Public include file for the UUID library
- *
- * Copyright (C) 1996, 1997, 1998 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#ifndef _UUID_UUID_H
-#define _UUID_UUID_H
-
-#include "config.h"
-#include <sys/types.h>
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-#include <time.h>
-
-typedef unsigned char uuid_t[16];
-
-/* UUID Variant definitions */
-#define UUID_VARIANT_NCS 	0
-#define UUID_VARIANT_DCE 	1
-#define UUID_VARIANT_MICROSOFT	2
-#define UUID_VARIANT_OTHER	3
-
-/* UUID Type definitions */
-#define UUID_TYPE_DCE_TIME   1
-#define UUID_TYPE_DCE_RANDOM 4
-
-/* Allow UUID constants to be defined */
-#ifdef __GNUC__
-#define UUID_DEFINE(name,u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15) \
-	static const uuid_t name __attribute__ ((unused)) = {u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15}
-#else
-#define UUID_DEFINE(name,u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15) \
-	static const uuid_t name = {u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15}
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* clear.c */
-void gf_uuid_clear(uuid_t uu);
-
-/* compare.c */
-int gf_uuid_compare(const uuid_t uu1, const uuid_t uu2);
-
-/* copy.c */
-void gf_uuid_copy(uuid_t dst, const uuid_t src);
-
-/* gen_uuid.c */
-void gf_uuid_generate(uuid_t out);
-void gf_uuid_generate_random(uuid_t out);
-void gf_uuid_generate_time(uuid_t out);
-
-/* isnull.c */
-int gf_uuid_is_null(const uuid_t uu);
-
-/* parse.c */
-int gf_uuid_parse(const char *in, uuid_t uu);
-
-/* unparse.c */
-void gf_uuid_unparse(const uuid_t uu, char *out);
-void gf_uuid_unparse_lower(const uuid_t uu, char *out);
-void gf_uuid_unparse_upper(const uuid_t uu, char *out);
-
-/* uuid_time.c */
-time_t gf_uuid_time(const uuid_t uu, struct timeval *ret_tv);
-int gf_uuid_type(const uuid_t uu);
-int gf_uuid_variant(const uuid_t uu);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _UUID_UUID_H */
diff --git a/contrib/uuid/uuidP.h b/contrib/uuid/uuidP.h
deleted file mode 100644
index 9a2de6132fe..00000000000
--- a/contrib/uuid/uuidP.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * uuid.h -- private header file for uuids
- *
- * Copyright (C) 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#include "uuid.h"
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#else
-#include "uuid_types.h"
-#endif
-#include <sys/types.h>
-
-
-/*
- * Offset between 15-Oct-1582 and 1-Jan-70
- */
-#define TIME_OFFSET_HIGH 0x01B21DD2
-#define TIME_OFFSET_LOW  0x13814000
-
-struct uuid {
-	uint32_t	time_low;
-	uint16_t	time_mid;
-	uint16_t	time_hi_and_version;
-	uint16_t	clock_seq;
-	uint8_t	node[6];
-};
-
-
-/*
- * prototypes
- */
-void uuid_pack(const struct uuid *uu, uuid_t ptr);
-void uuid_unpack(const uuid_t in, struct uuid *uu);
diff --git a/contrib/uuid/uuid_time.c b/contrib/uuid/uuid_time.c
deleted file mode 100644
index 35f727018b1..00000000000
--- a/contrib/uuid/uuid_time.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * uuid_time.c --- Interpret the time field from a uuid.  This program
- * 	violates the UUID abstraction barrier by reaching into the guts
- *	of a UUID and interpreting it.
- *
- * Copyright (C) 1998, 1999 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#ifdef _WIN32
-#define _WIN32_WINNT 0x0500
-#include <windows.h>
-#define UUID MYUUID
-#endif
-
-#include <stdio.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <stdlib.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#include <time.h>
-
-#include "uuidP.h"
-#include "logging.h"
-
-time_t gf_uuid_time(const uuid_t uu, struct timeval *ret_tv)
-{
-	struct timeval		tv;
-	struct uuid		uuid;
-	uint32_t		high;
-	uint64_t		clock_reg;
-
-	uuid_unpack(uu, &uuid);
-
-	high = uuid.time_mid | ((uuid.time_hi_and_version & 0xFFF) << 16);
-	clock_reg = uuid.time_low | ((uint64_t) high << 32);
-
-	clock_reg -= (((uint64_t) 0x01B21DD2) << 32) + 0x13814000;
-	tv.tv_sec = clock_reg / 10000000;
-	tv.tv_usec = (clock_reg % 10000000) / 10;
-
-	if (ret_tv)
-		*ret_tv = tv;
-
-	return tv.tv_sec;
-}
-
-int gf_uuid_type(const uuid_t uu)
-{
-	struct uuid		uuid;
-
-	uuid_unpack(uu, &uuid);
-	return ((uuid.time_hi_and_version >> 12) & 0xF);
-}
-
-int gf_uuid_variant(const uuid_t uu)
-{
-	struct uuid		uuid;
-	int			var;
-
-	uuid_unpack(uu, &uuid);
-	var = uuid.clock_seq;
-
-	if ((var & 0x8000) == 0)
-		return UUID_VARIANT_NCS;
-	if ((var & 0x4000) == 0)
-		return UUID_VARIANT_DCE;
-	if ((var & 0x2000) == 0)
-		return UUID_VARIANT_MICROSOFT;
-	return UUID_VARIANT_OTHER;
-}
-
-#ifdef DEBUG
-static const char *variant_string(int variant)
-{
-	switch (variant) {
-	case UUID_VARIANT_NCS:
-		return "NCS";
-	case UUID_VARIANT_DCE:
-		return "DCE";
-	case UUID_VARIANT_MICROSOFT:
-		return "Microsoft";
-	default:
-		return "Other";
-	}
-}
-
-
-int
-main(int argc, char **argv)
-{
-	uuid_t		buf;
-	time_t		time_reg;
-	struct timeval	tv;
-	int		type, variant;
-
-	if (argc != 2) {
-		fprintf(stderr, "Usage: %s uuid\n", argv[0]);
-		exit(1);
-	}
-	if (gf_uuid_parse(argv[1], buf)) {
-		fprintf(stderr, "Invalid UUID: %s\n", argv[1]);
-		exit(1);
-	}
-	variant = gf_uuid_variant(buf);
-	type = gf_uuid_type(buf);
-	time_reg = gf_uuid_time(buf, &tv);
-
-	printf("UUID variant is %d (%s)\n", variant, variant_string(variant));
-	if (variant != UUID_VARIANT_DCE) {
-		printf("Warning: This program only knows how to interpret "
-		       "DCE UUIDs.\n\tThe rest of the output is likely "
-		       "to be incorrect!!\n");
-	}
-	printf("UUID type is %d", type);
-	switch (type) {
-	case 1:
-		printf(" (time based)\n");
-		break;
-	case 2:
-		printf(" (DCE)\n");
-		break;
-	case 3:
-		printf(" (name-based)\n");
-		break;
-	case 4:
-		printf(" (random)\n");
-		break;
-	default:
-		printf("\n");
-	}
-	if (type != 1) {
-		printf("Warning: not a time-based UUID, so UUID time "
-		       "decoding will likely not work!\n");
-	}
-	printf("UUID time is: (%" GF_PRI_SECOND ", %" GF_PRI_USEC "): %s\n", tv.tv_sec, tv.tv_usec, ctime(&time_reg));
-
-	return 0;
-}
-#endif
diff --git a/contrib/uuid/uuid_types.h.in b/contrib/uuid/uuid_types.h.in
deleted file mode 100644
index f21ff4ee183..00000000000
--- a/contrib/uuid/uuid_types.h.in
+++ /dev/null
@@ -1,50 +0,0 @@
-/* 
- * If linux/types.h is already been included, assume it has defined
- * everything we need.  (cross fingers)  Other header files may have 
- * also defined the types that we need.
- */
-#if (!defined(_STDINT_H) && !defined(_UUID_STDINT_H))
-#define _UUID_STDINT_H
-
-typedef unsigned char uint8_t;
-typedef signed char int8_t;
-
-#if (@SIZEOF_INT@ == 8)
-typedef int		int64_t;
-typedef unsigned int	uint64_t;
-#elif (@SIZEOF_LONG@ == 8)
-typedef long		int64_t;
-typedef unsigned long	uint64_t;
-#elif (@SIZEOF_LONG_LONG@ == 8)
-#if defined(__GNUC__)
-typedef __signed__ long long 	int64_t;
-#else
-typedef signed long long 	int64_t;
-#endif
-typedef unsigned long long	uint64_t;
-#endif
-
-#if (@SIZEOF_INT@ == 2)
-typedef	int		int16_t;
-typedef	unsigned int	uint16_t;
-#elif (@SIZEOF_SHORT@ == 2)
-typedef	short		int16_t;
-typedef	unsigned short	uint16_t;
-#else
-  ?==error: undefined 16 bit type
-#endif
-
-#if (@SIZEOF_INT@ == 4)
-typedef	int		int32_t;
-typedef	unsigned int	uint32_t;
-#elif (@SIZEOF_LONG@ == 4)
-typedef	long		int32_t;
-typedef	unsigned long	uint32_t;
-#elif (@SIZEOF_SHORT@ == 4)
-typedef	short		int32_t;
-typedef	unsigned short	uint32_t;
-#else
- ?== error: undefined 32 bit type
-#endif
-
-#endif
diff --git a/contrib/uuid/uuidd.h b/contrib/uuid/uuidd.h
deleted file mode 100644
index c71f4b78835..00000000000
--- a/contrib/uuid/uuidd.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Definitions used by the uuidd daemon
- *
- * Copyright (C) 2007 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#ifndef _UUID_UUIDD_H
-#define _UUID_UUIDD_H
-
-#define UUIDD_DIR		"/var/lib/libuuid"
-#define UUIDD_SOCKET_PATH	UUIDD_DIR "/request"
-#define UUIDD_PIDFILE_PATH	UUIDD_DIR "/uuidd.pid"
-#define UUIDD_PATH		"/usr/sbin/uuidd"
-
-#define UUIDD_OP_GETPID			0
-#define UUIDD_OP_GET_MAXOP		1
-#define UUIDD_OP_TIME_UUID		2
-#define UUIDD_OP_RANDOM_UUID		3
-#define UUIDD_OP_BULK_TIME_UUID		4
-#define UUIDD_OP_BULK_RANDOM_UUID	5
-#define UUIDD_MAX_OP			UUIDD_OP_BULK_RANDOM_UUID
-
-extern void uuid__generate_time(uuid_t out, int *num);
-extern void uuid__generate_random(uuid_t out, int *num);
-
-#endif /* _UUID_UUID_H */
diff --git a/contrib/xxhash/xxhash.c b/contrib/xxhash/xxhash.c
index d5592c2d7ee..56f80f8811d 100644
--- a/contrib/xxhash/xxhash.c
+++ b/contrib/xxhash/xxhash.c
@@ -50,26 +50,32 @@
  * Prefer these methods in priority order (0 > 1 > 2)
  */
 #ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
+                        || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \
+                        || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
 #    define XXH_FORCE_MEMORY_ACCESS 2
-#  elif defined(__INTEL_COMPILER) || \
-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
+                    || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
+                    || defined(__ARM_ARCH_7S__) ))
 #    define XXH_FORCE_MEMORY_ACCESS 1
 #  endif
 #endif
 
 /*!XXH_ACCEPT_NULL_INPUT_POINTER :
- * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
- * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
- * By default, this option is disabled. To enable it, uncomment below define :
+ * If input pointer is NULL, xxHash default behavior is to dereference it, triggering a segfault.
+ * When this macro is enabled, xxHash actively checks input for null pointer.
+ * It it is, result for null input pointers is the same as a null-length input.
  */
-/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */
+#ifndef XXH_ACCEPT_NULL_INPUT_POINTER   /* can be defined externally */
+#  define XXH_ACCEPT_NULL_INPUT_POINTER 0
+#endif
 
 /*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independant Hash values, based on little-endian convention.
+ * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
  * Results are therefore identical for little-endian and big-endian CPU.
  * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independance be of no importance for your application, you may set the #define below to 1,
+ * Should endian-independence be of no importance for your application, you may set the #define below to 1,
  * to improve speed for Big-endian CPU.
  * This option has no impact on Little_Endian CPU.
  */
@@ -80,8 +86,9 @@
 /*!XXH_FORCE_ALIGN_CHECK :
  * This is a minor performance trick, only useful with lots of very small keys.
  * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash; set to 0 when the input data
- * is guaranteed to be aligned.
+ * The check costs one initial branch per hash;
+ * set it to 0 when the input is guaranteed to be aligned,
+ * or when alignment doesn't matter for performance.
  */
 #ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
 #  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
@@ -95,15 +102,17 @@
 /* *************************************
 *  Includes & Memory related functions
 ***************************************/
-/* Modify the local functions below should you wish to use some other memory routines */
-/* for malloc(), free() */
+/*! Modify the local functions below should you wish to use some other memory routines
+*   for malloc(), free() */
 #include <stdlib.h>
 static void* XXH_malloc(size_t s) { return malloc(s); }
 static void  XXH_free  (void* p)  { free(p); }
-/* for memcpy() */
+/*! and for memcpy() */
 #include <string.h>
 static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
 
+#include <assert.h>   /* assert */
+
 #define XXH_STATIC_LINKING_ONLY
 #include "xxhash.h"
 
@@ -115,7 +124,7 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcp
 #  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #  define FORCE_INLINE static __forceinline
 #else
-#  if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
@@ -131,17 +140,17 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcp
 *  Basic Types
 ***************************************/
 #ifndef MEM_MODULE
-# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
 #   include <stdint.h>
     typedef uint8_t  BYTE;
     typedef uint16_t U16;
     typedef uint32_t U32;
-    typedef  int32_t S32;
 # else
     typedef unsigned char      BYTE;
     typedef unsigned short     U16;
     typedef unsigned int       U32;
-    typedef   signed int       S32;
 # endif
 #endif
 
@@ -208,8 +217,12 @@ typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
 
 /* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
 #ifndef XXH_CPU_LITTLE_ENDIAN
-    static const int g_one = 1;
-#   define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
+static int XXH_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
 #endif
 
 
@@ -240,12 +253,12 @@ static U32 XXH_readBE32(const void* ptr)
 /* *************************************
 *  Macros
 ***************************************/
-#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */
-XXH_PUBLIC_API unsigned GF_XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
+#define XXH_STATIC_ASSERT(c)  { enum { XXH_sa = 1/(int)(!!(c)) }; }  /* use after variable declarations */
+XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
 
 
 /* *******************************************************************
-*  32-bits hash functions
+*  32-bit hash functions
 *********************************************************************/
 static const U32 PRIME32_1 = 2654435761U;
 static const U32 PRIME32_2 = 2246822519U;
@@ -261,14 +274,89 @@ static U32 XXH32_round(U32 seed, U32 input)
     return seed;
 }
 
-FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
+/* mix all bits */
+static U32 XXH32_avalanche(U32 h32)
+{
+    h32 ^= h32 >> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+    return(h32);
+}
+
+#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
+
+static U32
+XXH32_finalize(U32 h32, const void* ptr, size_t len,
+                XXH_endianess endian, XXH_alignment align)
+
+{
+    const BYTE* p = (const BYTE*)ptr;
+#define PROCESS1             \
+    h32 += (*p) * PRIME32_5; \
+    p++;                     \
+    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
+
+#define PROCESS4                         \
+    h32 += XXH_get32bits(p) * PRIME32_3; \
+    p+=4;                                \
+    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
+
+    switch(len&15)  /* or switch(bEnd - p) */
+    {
+      case 12:      PROCESS4;
+                    /* fallthrough */
+      case 8:       PROCESS4;
+                    /* fallthrough */
+      case 4:       PROCESS4;
+                    return XXH32_avalanche(h32);
+
+      case 13:      PROCESS4;
+                    /* fallthrough */
+      case 9:       PROCESS4;
+                    /* fallthrough */
+      case 5:       PROCESS4;
+                    PROCESS1;
+                    return XXH32_avalanche(h32);
+
+      case 14:      PROCESS4;
+                    /* fallthrough */
+      case 10:      PROCESS4;
+                    /* fallthrough */
+      case 6:       PROCESS4;
+                    PROCESS1;
+                    PROCESS1;
+                    return XXH32_avalanche(h32);
+
+      case 15:      PROCESS4;
+                    /* fallthrough */
+      case 11:      PROCESS4;
+                    /* fallthrough */
+      case 7:       PROCESS4;
+                    /* fallthrough */
+      case 3:       PROCESS1;
+                    /* fallthrough */
+      case 2:       PROCESS1;
+                    /* fallthrough */
+      case 1:       PROCESS1;
+                    /* fallthrough */
+      case 0:       return XXH32_avalanche(h32);
+    }
+    assert(0);
+    return h32;   /* reaching this point is deemed impossible */
+}
+
+
+FORCE_INLINE U32
+XXH32_endian_align(const void* input, size_t len, U32 seed,
+                    XXH_endianess endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* bEnd = p + len;
     U32 h32;
-#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
 
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
     if (p==NULL) {
         len=0;
         bEnd=p=(const BYTE*)(size_t)16;
@@ -276,7 +364,7 @@ FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH
 #endif
 
     if (len>=16) {
-        const BYTE* const limit = bEnd - 16;
+        const BYTE* const limit = bEnd - 15;
         U32 v1 = seed + PRIME32_1 + PRIME32_2;
         U32 v2 = seed + PRIME32_2;
         U32 v3 = seed + 0;
@@ -287,45 +375,28 @@ FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH
             v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
             v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
             v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
-        } while (p<=limit);
+        } while (p < limit);
 
-        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
+            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
     } else {
         h32  = seed + PRIME32_5;
     }
 
-    h32 += (U32) len;
-
-    while (p+4<=bEnd) {
-        h32 += XXH_get32bits(p) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
-        p+=4;
-    }
+    h32 += (U32)len;
 
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
+    return XXH32_finalize(h32, p, len&15, endian, align);
 }
 
 
-XXH_PUBLIC_API unsigned int GF_XXH32 (const void* input, size_t len, unsigned int seed)
+XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
 {
 #if 0
     /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH32_CREATESTATE_STATIC(state);
-    GF_XXH32_reset(state, seed);
-    GF_XXH32_update(state, input, len);
-    return GF_XXH32_digest(state);
+    XXH32_state_t state;
+    XXH32_reset(&state, seed);
+    XXH32_update(&state, input, len);
+    return XXH32_digest(&state);
 #else
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -348,41 +419,46 @@ XXH_PUBLIC_API unsigned int GF_XXH32 (const void* input, size_t len, unsigned in
 
 /*======   Hash streaming   ======*/
 
-XXH_PUBLIC_API GF_XXH32_state_t* GF_XXH32_createState(void)
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
 {
-    return (GF_XXH32_state_t*)XXH_malloc(sizeof(GF_XXH32_state_t));
+    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
 }
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_freeState(GF_XXH32_state_t* statePtr)
+XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
 {
     XXH_free(statePtr);
     return XXH_OK;
 }
 
-XXH_PUBLIC_API void GF_XXH32_copyState(GF_XXH32_state_t* restrict dstState, const GF_XXH32_state_t* restrict srcState)
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
 {
     memcpy(dstState, srcState, sizeof(*dstState));
 }
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_reset(GF_XXH32_state_t* statePtr, unsigned int seed)
+XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
 {
-    GF_XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
+    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
     state.v1 = seed + PRIME32_1 + PRIME32_2;
     state.v2 = seed + PRIME32_2;
     state.v3 = seed + 0;
     state.v4 = seed - PRIME32_1;
-    memcpy(statePtr, &state, sizeof(state));
+    /* do not write into reserved, planned to be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
     return XXH_OK;
 }
 
 
-FORCE_INLINE GF_XXH_errorcode XXH32_update_endian (GF_XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
+FORCE_INLINE
+XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* const bEnd = p + len;
 
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
 #endif
 
     state->total_len_32 += (unsigned)len;
@@ -400,7 +476,7 @@ FORCE_INLINE GF_XXH_errorcode XXH32_update_endian (GF_XXH32_state_t* state, cons
             state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
             state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
             state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
-            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++;
+            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
         }
         p += 16-state->memsize;
         state->memsize = 0;
@@ -434,7 +510,8 @@ FORCE_INLINE GF_XXH_errorcode XXH32_update_endian (GF_XXH32_state_t* state, cons
     return XXH_OK;
 }
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_update (GF_XXH32_state_t* state_in, const void* input, size_t len)
+
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
 {
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -445,44 +522,27 @@ XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_update (GF_XXH32_state_t* state_in, con
 }
 
 
-
-FORCE_INLINE U32 XXH32_digest_endian (const GF_XXH32_state_t* state, XXH_endianess endian)
+FORCE_INLINE U32
+XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
 {
-    const BYTE * p = (const BYTE*)state->mem32;
-    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
     U32 h32;
 
     if (state->large_len) {
-        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
+        h32 = XXH_rotl32(state->v1, 1)
+            + XXH_rotl32(state->v2, 7)
+            + XXH_rotl32(state->v3, 12)
+            + XXH_rotl32(state->v4, 18);
     } else {
         h32 = state->v3 /* == seed */ + PRIME32_5;
     }
 
     h32 += state->total_len_32;
 
-    while (p+4<=bEnd) {
-        h32 += XXH_readLE32(p, endian) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
+    return XXH32_finalize(h32, state->mem32, state->memsize, endian, XXH_aligned);
 }
 
 
-XXH_PUBLIC_API unsigned int GF_XXH32_digest (const GF_XXH32_state_t* state_in)
+XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
 {
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -498,17 +558,17 @@ XXH_PUBLIC_API unsigned int GF_XXH32_digest (const GF_XXH32_state_t* state_in)
 /*! Default XXH result types are basic unsigned 32 and 64 bits.
 *   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
 *   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.
+*   This way, hash values can be written into a file or buffer, remaining comparable across different systems.
 */
 
-XXH_PUBLIC_API void GF_XXH32_canonicalFromHash(GF_XXH32_canonical_t* dst, GF_XXH32_hash_t hash)
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
 {
-    XXH_STATIC_ASSERT(sizeof(GF_XXH32_canonical_t) == sizeof(GF_XXH32_hash_t));
+    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
     if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
     memcpy(dst, &hash, sizeof(*dst));
 }
 
-XXH_PUBLIC_API GF_XXH32_hash_t GF_XXH32_hashFromCanonical(const GF_XXH32_canonical_t* src)
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
 {
     return XXH_readBE32(src);
 }
@@ -517,18 +577,21 @@ XXH_PUBLIC_API GF_XXH32_hash_t GF_XXH32_hashFromCanonical(const GF_XXH32_canonic
 #ifndef XXH_NO_LONG_LONG
 
 /* *******************************************************************
-*  64-bits hash functions
+*  64-bit hash functions
 *********************************************************************/
 
 /*======   Memory access   ======*/
 
 #ifndef MEM_MODULE
 # define MEM_MODULE
-# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
 #   include <stdint.h>
     typedef uint64_t U64;
 # else
-    typedef unsigned long long U64;   /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */
+    /* if compiler doesn't support unsigned long long, replace by another 64-bit type */
+    typedef unsigned long long U64;
 # endif
 #endif
 
@@ -543,7 +606,6 @@ static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
 /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
 /* currently only defined for gcc and icc */
 typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign64;
-
 static U64 XXH_read64(const void* ptr) { return ((const unalign64*)ptr)->u64; }
 
 #else
@@ -622,14 +684,138 @@ static U64 XXH64_mergeRound(U64 acc, U64 val)
     return acc;
 }
 
-FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
+static U64 XXH64_avalanche(U64 h64)
+{
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+    return h64;
+}
+
+
+#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
+
+static U64
+XXH64_finalize(U64 h64, const void* ptr, size_t len,
+               XXH_endianess endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)ptr;
+
+#define PROCESS1_64          \
+    h64 ^= (*p) * PRIME64_5; \
+    p++;                     \
+    h64 = XXH_rotl64(h64, 11) * PRIME64_1;
+
+#define PROCESS4_64          \
+    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
+    p+=4;                    \
+    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
+
+#define PROCESS8_64 {        \
+    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
+    p+=8;                    \
+    h64 ^= k1;               \
+    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
+}
+
+    switch(len&31) {
+      case 24: PROCESS8_64;
+                    /* fallthrough */
+      case 16: PROCESS8_64;
+                    /* fallthrough */
+      case  8: PROCESS8_64;
+               return XXH64_avalanche(h64);
+
+      case 28: PROCESS8_64;
+                    /* fallthrough */
+      case 20: PROCESS8_64;
+                    /* fallthrough */
+      case 12: PROCESS8_64;
+                    /* fallthrough */
+      case  4: PROCESS4_64;
+               return XXH64_avalanche(h64);
+
+      case 25: PROCESS8_64;
+                    /* fallthrough */
+      case 17: PROCESS8_64;
+                    /* fallthrough */
+      case  9: PROCESS8_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 29: PROCESS8_64;
+                    /* fallthrough */
+      case 21: PROCESS8_64;
+                    /* fallthrough */
+      case 13: PROCESS8_64;
+                    /* fallthrough */
+      case  5: PROCESS4_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 26: PROCESS8_64;
+                    /* fallthrough */
+      case 18: PROCESS8_64;
+                    /* fallthrough */
+      case 10: PROCESS8_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 30: PROCESS8_64;
+                    /* fallthrough */
+      case 22: PROCESS8_64;
+                    /* fallthrough */
+      case 14: PROCESS8_64;
+                    /* fallthrough */
+      case  6: PROCESS4_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 27: PROCESS8_64;
+                    /* fallthrough */
+      case 19: PROCESS8_64;
+                    /* fallthrough */
+      case 11: PROCESS8_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 31: PROCESS8_64;
+                    /* fallthrough */
+      case 23: PROCESS8_64;
+                    /* fallthrough */
+      case 15: PROCESS8_64;
+                    /* fallthrough */
+      case  7: PROCESS4_64;
+                    /* fallthrough */
+      case  3: PROCESS1_64;
+                    /* fallthrough */
+      case  2: PROCESS1_64;
+                    /* fallthrough */
+      case  1: PROCESS1_64;
+                    /* fallthrough */
+      case  0: return XXH64_avalanche(h64);
+    }
+
+    /* impossible to reach */
+    assert(0);
+    return 0;  /* unreachable, but some compilers complain without it */
+}
+
+FORCE_INLINE U64
+XXH64_endian_align(const void* input, size_t len, U64 seed,
+                XXH_endianess endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
+    const BYTE* bEnd = p + len;
     U64 h64;
-#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
 
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
     if (p==NULL) {
         len=0;
         bEnd=p=(const BYTE*)(size_t)32;
@@ -662,43 +848,18 @@ FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH
 
     h64 += (U64) len;
 
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_get64bits(p));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
-        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
+    return XXH64_finalize(h64, p, len, endian, align);
 }
 
 
-XXH_PUBLIC_API unsigned long long GF_XXH64 (const void* input, size_t len, unsigned long long seed)
+XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
 {
 #if 0
     /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH64_CREATESTATE_STATIC(state);
-    GF_XXH64_reset(state, seed);
-    GF_XXH64_update(state, input, len);
-    return GF_XXH64_digest(state);
+    XXH64_state_t state;
+    XXH64_reset(&state, seed);
+    XXH64_update(&state, input, len);
+    return XXH64_digest(&state);
 #else
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -719,40 +880,45 @@ XXH_PUBLIC_API unsigned long long GF_XXH64 (const void* input, size_t len, unsig
 
 /*======   Hash Streaming   ======*/
 
-XXH_PUBLIC_API GF_XXH64_state_t* GF_XXH64_createState(void)
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
 {
-    return (GF_XXH64_state_t*)XXH_malloc(sizeof(GF_XXH64_state_t));
+    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
 }
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_freeState(GF_XXH64_state_t* statePtr)
+XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
 {
     XXH_free(statePtr);
     return XXH_OK;
 }
 
-XXH_PUBLIC_API void GF_XXH64_copyState(GF_XXH64_state_t* restrict dstState, const GF_XXH64_state_t* restrict srcState)
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
 {
     memcpy(dstState, srcState, sizeof(*dstState));
 }
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_reset(GF_XXH64_state_t* statePtr, unsigned long long seed)
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
 {
-    GF_XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
+    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
     state.v1 = seed + PRIME64_1 + PRIME64_2;
     state.v2 = seed + PRIME64_2;
     state.v3 = seed + 0;
     state.v4 = seed - PRIME64_1;
-    memcpy(statePtr, &state, sizeof(state));
+     /* do not write into reserved, planned to be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
     return XXH_OK;
 }
 
-FORCE_INLINE GF_XXH_errorcode XXH64_update_endian (GF_XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
+FORCE_INLINE
+XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* const bEnd = p + len;
 
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
 #endif
 
     state->total_len += len;
@@ -801,7 +967,7 @@ FORCE_INLINE GF_XXH_errorcode XXH64_update_endian (GF_XXH64_state_t* state, cons
     return XXH_OK;
 }
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_update (GF_XXH64_state_t* state_in, const void* input, size_t len)
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
 {
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -811,10 +977,8 @@ XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_update (GF_XXH64_state_t* state_in, con
         return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
 }
 
-FORCE_INLINE U64 XXH64_digest_endian (const GF_XXH64_state_t* state, XXH_endianess endian)
+FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
 {
-    const BYTE * p = (const BYTE*)state->mem64;
-    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
     U64 h64;
 
     if (state->total_len >= 32) {
@@ -829,40 +993,15 @@ FORCE_INLINE U64 XXH64_digest_endian (const GF_XXH64_state_t* state, XXH_endiane
         h64 = XXH64_mergeRound(h64, v3);
         h64 = XXH64_mergeRound(h64, v4);
     } else {
-        h64  = state->v3 + PRIME64_5;
+        h64  = state->v3 /*seed*/ + PRIME64_5;
     }
 
     h64 += (U64) state->total_len;
 
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
-        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64  = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
+    return XXH64_finalize(h64, state->mem64, (size_t)state->total_len, endian, XXH_aligned);
 }
 
-XXH_PUBLIC_API unsigned long long GF_XXH64_digest (const GF_XXH64_state_t* state_in)
+XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
 {
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
@@ -875,14 +1014,14 @@ XXH_PUBLIC_API unsigned long long GF_XXH64_digest (const GF_XXH64_state_t* state
 
 /*====== Canonical representation   ======*/
 
-XXH_PUBLIC_API void GF_XXH64_canonicalFromHash(GF_XXH64_canonical_t* dst, GF_XXH64_hash_t hash)
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
 {
-    XXH_STATIC_ASSERT(sizeof(GF_XXH64_canonical_t) == sizeof(GF_XXH64_hash_t));
+    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
     if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
     memcpy(dst, &hash, sizeof(*dst));
 }
 
-XXH_PUBLIC_API GF_XXH64_hash_t GF_XXH64_hashFromCanonical(const GF_XXH64_canonical_t* src)
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
 {
     return XXH_readBE64(src);
 }
diff --git a/contrib/xxhash/xxhash.h b/contrib/xxhash/xxhash.h
index 98352b9018e..d6bad943358 100644
--- a/contrib/xxhash/xxhash.h
+++ b/contrib/xxhash/xxhash.h
@@ -57,8 +57,8 @@ Q.Score is a measure of quality of the hash function.
 It depends on successfully passing SMHasher test set.
 10 is a perfect score.
 
-A 64-bits version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bits applications only.
+A 64-bit version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bit applications only.
 Name     Speed on 64 bits    Speed on 32 bits
 XXH64       13.8 GB/s            1.9 GB/s
 XXH32        6.8 GB/s            6.0 GB/s
@@ -73,33 +73,26 @@ extern "C" {
 
 
 /* ****************************
-*  Compiler specifics
-******************************/
-#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))   /* ! C99 */
-#  define restrict   /* disable restrict */
-#endif
-
-
-/* ****************************
 *  Definitions
 ******************************/
 #include <stddef.h>   /* size_t */
-typedef enum { XXH_OK=0, XXH_ERROR } GF_XXH_errorcode;
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
 
 
 /* ****************************
-*  API modifier
-******************************/
-/** XXH_PRIVATE_API
-*   This is useful to include xxhash functions in `static` mode
-*   in order to inline them, and remove their symbol from the public list.
-*   Methodology :
-*     #define XXH_PRIVATE_API
-*     #include "xxhash.h"
-*   `xxhash.c` is automatically included.
-*   It's not useful to compile and link it as a separate module.
-*/
-#ifdef XXH_PRIVATE_API
+ *  API modifier
+ ******************************/
+/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ *  This is useful to include xxhash functions in `static` mode
+ *  in order to inline them, and remove their symbol from the public list.
+ *  Inlining can offer dramatic performance improvement on small keys.
+ *  Methodology :
+ *     #define XXH_INLINE_ALL
+ *     #include "xxhash.h"
+ * `xxhash.c` is automatically included.
+ *  It's not useful to compile and link it as a separate module.
+ */
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
 #  ifndef XXH_STATIC_LINKING_ONLY
 #    define XXH_STATIC_LINKING_ONLY
 #  endif
@@ -110,45 +103,46 @@ typedef enum { XXH_OK=0, XXH_ERROR } GF_XXH_errorcode;
 #  elif defined(_MSC_VER)
 #    define XXH_PUBLIC_API static __inline
 #  else
-#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
+     /* this version may generate warnings for unused static functions */
+#    define XXH_PUBLIC_API static
 #  endif
 #else
 #  define XXH_PUBLIC_API   /* do nothing */
-#endif /* XXH_PRIVATE_API */
-
-/*!XXH_NAMESPACE, aka Namespace Emulation :
-
-If you want to include _and expose_ xxHash functions from within your own library,
-but also want to avoid symbol collisions with other libraries which may also include xxHash,
-
-you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
-with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
-
-Note that no change is required within the calling program as long as it includes `xxhash.h` :
-regular symbol name will be automatically translated by this header.
-*/
+#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
+
+/*! XXH_NAMESPACE, aka Namespace Emulation :
+ *
+ * If you want to include _and expose_ xxHash functions from within your own library,
+ * but also want to avoid symbol collisions with other libraries which may also include xxHash,
+ *
+ * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+ * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+ *
+ * Note that no change is required within the calling program as long as it includes `xxhash.h` :
+ * regular symbol name will be automatically translated by this header.
+ */
 #ifdef XXH_NAMESPACE
 #  define XXH_CAT(A,B) A##B
 #  define XXH_NAME2(A,B) XXH_CAT(A,B)
-#  define GF_XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, GF_XXH_versionNumber)
-#  define GF_XXH32 XXH_NAME2(XXH_NAMESPACE, GF_XXH32)
-#  define GF_XXH32_createState XXH_NAME2(XXH_NAMESPACE, GF_XXH32_createState)
-#  define GF_XXH32_freeState XXH_NAME2(XXH_NAMESPACE, GF_XXH32_freeState)
-#  define GF_XXH32_reset XXH_NAME2(XXH_NAMESPACE, GF_XXH32_reset)
-#  define GF_XXH32_update XXH_NAME2(XXH_NAMESPACE, GF_XXH32_update)
-#  define GF_XXH32_digest XXH_NAME2(XXH_NAMESPACE, GF_XXH32_digest)
-#  define GF_XXH32_copyState XXH_NAME2(XXH_NAMESPACE, GF_XXH32_copyState)
-#  define GF_XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, GF_XXH32_canonicalFromHash)
-#  define GF_XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, GF_XXH32_hashFromCanonical)
-#  define GF_XXH64 XXH_NAME2(XXH_NAMESPACE, GF_XXH64)
-#  define GF_XXH64_createState XXH_NAME2(XXH_NAMESPACE, GF_XXH64_createState)
-#  define GF_XXH64_freeState XXH_NAME2(XXH_NAMESPACE, GF_XXH64_freeState)
-#  define GF_XXH64_reset XXH_NAME2(XXH_NAMESPACE, GF_XXH64_reset)
-#  define GF_XXH64_update XXH_NAME2(XXH_NAMESPACE, GF_XXH64_update)
-#  define GF_XXH64_digest XXH_NAME2(XXH_NAMESPACE, GF_XXH64_digest)
-#  define GF_XXH64_copyState XXH_NAME2(XXH_NAMESPACE, GF_XXH64_copyState)
-#  define GF_XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, GF_XXH64_canonicalFromHash)
-#  define GF_XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, GF_XXH64_hashFromCanonical)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
 #endif
 
 
@@ -157,140 +151,173 @@ regular symbol name will be automatically translated by this header.
 ***************************************/
 #define XXH_VERSION_MAJOR    0
 #define XXH_VERSION_MINOR    6
-#define XXH_VERSION_RELEASE  2
+#define XXH_VERSION_RELEASE  5
 #define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
-XXH_PUBLIC_API unsigned GF_XXH_versionNumber (void);
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
 
 
 /*-**********************************************************************
-*  32-bits hash
+*  32-bit hash
 ************************************************************************/
-typedef unsigned int       GF_XXH32_hash_t;
+typedef unsigned int XXH32_hash_t;
 
 /*! XXH32() :
-    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
+    Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
     The memory between input & input+length must be valid (allocated and read-accessible).
     "seed" can be used to alter the result predictably.
     Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
-XXH_PUBLIC_API GF_XXH32_hash_t GF_XXH32 (const void* input, size_t length, unsigned int seed);
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
 
 /*======   Streaming   ======*/
-typedef struct XXH32_state_s GF_XXH32_state_t;   /* incomplete type */
-XXH_PUBLIC_API GF_XXH32_state_t* GF_XXH32_createState(void);
-XXH_PUBLIC_API GF_XXH_errorcode  GF_XXH32_freeState(GF_XXH32_state_t* statePtr);
-XXH_PUBLIC_API void GF_XXH32_copyState(GF_XXH32_state_t* restrict dst_state, const GF_XXH32_state_t* restrict src_state);
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_reset  (GF_XXH32_state_t* statePtr, unsigned int seed);
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH32_update (GF_XXH32_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API GF_XXH32_hash_t  GF_XXH32_digest (const GF_XXH32_state_t* statePtr);
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
 
 /*
-These functions generate the xxHash of an input provided in multiple segments.
-Note that, for small input, they are slower than single-call functions, due to state management.
-For small input, prefer `XXH32()` and `XXH64()` .
-
-XXH state must first be allocated, using XXH*_createState() .
-
-Start a new hash by initializing state with a seed, using XXH*_reset().
-
-Then, feed the hash state by calling XXH*_update() as many times as necessary.
-Obviously, input must be allocated and read accessible.
-The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
-
-Finally, a hash value can be produced anytime, by using XXH*_digest().
-This function returns the nn-bits hash as an int or long long.
-
-It's still possible to continue inserting input into the hash state after a digest,
-and generate some new hashes later on, by calling again XXH*_digest().
-
-When done, free XXH state space if it was allocated dynamically.
-*/
+ * Streaming functions generate the xxHash of an input provided in multiple segments.
+ * Note that, for small input, they are slower than single-call functions, due to state management.
+ * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
+ *
+ * XXH state must first be allocated, using XXH*_createState() .
+ *
+ * Start a new hash by initializing state with a seed, using XXH*_reset().
+ *
+ * Then, feed the hash state by calling XXH*_update() as many times as necessary.
+ * The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+ *
+ * Finally, a hash value can be produced anytime, by using XXH*_digest().
+ * This function returns the nn-bits hash as an int or long long.
+ *
+ * It's still possible to continue inserting input into the hash state after a digest,
+ * and generate some new hashes later on, by calling again XXH*_digest().
+ *
+ * When done, free XXH state space if it was allocated dynamically.
+ */
 
 /*======   Canonical representation   ======*/
 
-typedef struct { unsigned char digest[4]; } GF_XXH32_canonical_t;
-XXH_PUBLIC_API void GF_XXH32_canonicalFromHash(GF_XXH32_canonical_t* dst, GF_XXH32_hash_t hash);
-XXH_PUBLIC_API GF_XXH32_hash_t GF_XXH32_hashFromCanonical(const GF_XXH32_canonical_t* src);
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
 
 /* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
-*  The canonical representation uses human-readable write convention, aka big-endian (large digits first).
-*  These functions allow transformation of hash result into and from its canonical format.
-*  This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
-*/
+ * The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+ * These functions allow transformation of hash result into and from its canonical format.
+ * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+ */
 
 
 #ifndef XXH_NO_LONG_LONG
 /*-**********************************************************************
-*  64-bits hash
+*  64-bit hash
 ************************************************************************/
-typedef unsigned long long GF_XXH64_hash_t;
+typedef unsigned long long XXH64_hash_t;
 
 /*! XXH64() :
-    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
+    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
     "seed" can be used to alter the result predictably.
-    This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
+    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
 */
-XXH_PUBLIC_API GF_XXH64_hash_t GF_XXH64 (const void* input, size_t length, unsigned long long seed);
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
 
 /*======   Streaming   ======*/
-typedef struct XXH64_state_s GF_XXH64_state_t;   /* incomplete type */
-XXH_PUBLIC_API GF_XXH64_state_t* GF_XXH64_createState(void);
-XXH_PUBLIC_API GF_XXH_errorcode  GF_XXH64_freeState(GF_XXH64_state_t* statePtr);
-XXH_PUBLIC_API void GF_XXH64_copyState(GF_XXH64_state_t* restrict dst_state, const GF_XXH64_state_t* restrict src_state);
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
 
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_reset  (GF_XXH64_state_t* statePtr, unsigned long long seed);
-XXH_PUBLIC_API GF_XXH_errorcode GF_XXH64_update (GF_XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API GF_XXH64_hash_t  GF_XXH64_digest (const GF_XXH64_state_t* statePtr);
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
 
 /*======   Canonical representation   ======*/
-typedef struct { unsigned char digest[8]; } GF_XXH64_canonical_t;
-XXH_PUBLIC_API void GF_XXH64_canonicalFromHash(GF_XXH64_canonical_t* dst, GF_XXH64_hash_t hash);
-XXH_PUBLIC_API GF_XXH64_hash_t GF_XXH64_hashFromCanonical(const GF_XXH64_canonical_t* src);
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
 #endif  /* XXH_NO_LONG_LONG */
 
 
+
 #ifdef XXH_STATIC_LINKING_ONLY
 
 /* ================================================================================================
-   This section contains definitions which are not guaranteed to remain stable.
+   This section contains declarations which are not guaranteed to remain stable.
    They may change in future versions, becoming incompatible with a different version of the library.
-   They shall only be used with static linking.
-   Never use these definitions in association with dynamic linking !
+   These declarations should only be used with static linking.
+   Never use them in association with dynamic linking !
 =================================================================================================== */
 
-/* These definitions are only meant to allow allocation of XXH state
-   statically, on stack, or in a struct for example.
-   Do not use members directly. */
-
-   struct XXH32_state_s {
-       unsigned total_len_32;
-       unsigned large_len;
-       unsigned v1;
-       unsigned v2;
-       unsigned v3;
-       unsigned v4;
-       unsigned mem32[4];   /* buffer defined as U32 for alignment */
-       unsigned memsize;
-       unsigned reserved;   /* never read nor write, will be removed in a future version */
-   };   /* typedef'd to XXH32_state_t */
-
-#ifndef XXH_NO_LONG_LONG
-   struct XXH64_state_s {
-       unsigned long long total_len;
-       unsigned long long v1;
-       unsigned long long v2;
-       unsigned long long v3;
-       unsigned long long v4;
-       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
-       unsigned memsize;
-       unsigned reserved[2];          /* never read nor write, will be removed in a future version */
-   };   /* typedef'd to XXH64_state_t */
+/* These definitions are only present to allow
+ * static allocation of XXH state, on stack or in a struct for example.
+ * Never **ever** use members directly. */
+
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+
+struct XXH32_state_s {
+   uint32_t total_len_32;
+   uint32_t large_len;
+   uint32_t v1;
+   uint32_t v2;
+   uint32_t v3;
+   uint32_t v4;
+   uint32_t mem32[4];
+   uint32_t memsize;
+   uint32_t reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+struct XXH64_state_s {
+   uint64_t total_len;
+   uint64_t v1;
+   uint64_t v2;
+   uint64_t v3;
+   uint64_t v4;
+   uint64_t mem64[4];
+   uint32_t memsize;
+   uint32_t reserved[2];          /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+
+# else
+
+struct XXH32_state_s {
+   unsigned total_len_32;
+   unsigned large_len;
+   unsigned v1;
+   unsigned v2;
+   unsigned v3;
+   unsigned v4;
+   unsigned mem32[4];
+   unsigned memsize;
+   unsigned reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+#   ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
+struct XXH64_state_s {
+   unsigned long long total_len;
+   unsigned long long v1;
+   unsigned long long v2;
+   unsigned long long v3;
+   unsigned long long v4;
+   unsigned long long mem64[4];
+   unsigned memsize;
+   unsigned reserved[2];     /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+#    endif
+
+# endif
+
+
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
 #endif
 
-#  ifdef XXH_PRIVATE_API
-#    include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
-#  endif
-
 #endif /* XXH_STATIC_LINKING_ONLY */
 
 
diff --git a/contrib/xxhash/xxhsum.c b/contrib/xxhash/xxhsum.c
index 0148e3c4566..69931f727f0 100644
--- a/contrib/xxhash/xxhsum.c
+++ b/contrib/xxhash/xxhsum.c
@@ -32,8 +32,8 @@
 #define XXHASH_C_2097394837
 
 /* ************************************
-*  Compiler Options
-**************************************/
+ *  Compiler Options
+ **************************************/
 /* MS Visual */
 #if defined(_MSC_VER) || defined(_WIN32)
 #  define _CRT_SECURE_NO_WARNINGS   /* removes visual warnings */
@@ -46,28 +46,26 @@
 
 
 /* ************************************
-*  Includes
-**************************************/
-#include <stdlib.h>     /* malloc */
-#include <stdio.h>      /* fprintf, fopen, ftello64, fread, stdin, stdout; when present : _fileno */
+ *  Includes
+ **************************************/
+#include <stdlib.h>     /* malloc, calloc, free, exit */
+#include <stdio.h>      /* fprintf, fopen, ftello64, fread, stdin, stdout, _fileno (when present) */
 #include <string.h>     /* strcmp */
-#include <sys/types.h>  /* stat64 */
-#include <sys/stat.h>   /* stat64 */
+#include <sys/types.h>  /* stat, stat64, _stat64 */
+#include <sys/stat.h>   /* stat, stat64, _stat64 */
 #include <time.h>       /* clock_t, clock, CLOCKS_PER_SEC */
+#include <assert.h>     /* assert */
 
 #define XXH_STATIC_LINKING_ONLY   /* *_state_t */
 #include "xxhash.h"
 
 
-/*-************************************
-*  OS-Specific Includes
-**************************************/
+/* ************************************
+ *  OS-Specific Includes
+ **************************************/
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
 #  include <fcntl.h>    /* _O_BINARY */
 #  include <io.h>       /* _setmode, _isatty */
-#  ifdef __MINGW32__
-   int _fileno(FILE *stream);   /* MINGW somehow forgets to include this windows declaration into <stdio.h> */
-#  endif
 #  define SET_BINARY_MODE(file) _setmode(_fileno(file), _O_BINARY)
 #  define IS_CONSOLE(stdStream) _isatty(_fileno(stdStream))
 #else
@@ -110,8 +108,8 @@ static unsigned BMK_isLittleEndian(void)
 
 
 /* *************************************
-*  Constants
-***************************************/
+ *  Constants
+ ***************************************/
 #define LIB_VERSION XXH_VERSION_MAJOR.XXH_VERSION_MINOR.XXH_VERSION_RELEASE
 #define QUOTE(str) #str
 #define EXPAND_AND_QUOTE(str) QUOTE(str)
@@ -121,18 +119,20 @@ static const char g_lename[] = "little endian";
 static const char g_bename[] = "big endian";
 #define ENDIAN_NAME (BMK_isLittleEndian() ? g_lename : g_bename)
 static const char author[] = "Yann Collet";
-#define WELCOME_MESSAGE(exename) "%s %s (%i-bits %s), by %s \n", exename, PROGRAM_VERSION,  g_nbBits, ENDIAN_NAME, author
+#define WELCOME_MESSAGE(exename) "%s %s (%i-bits %s), by %s \n", \
+                    exename, PROGRAM_VERSION, g_nbBits, ENDIAN_NAME, author
+
+#define KB *( 1<<10)
+#define MB *( 1<<20)
+#define GB *(1U<<30)
 
+static size_t XXH_DEFAULT_SAMPLE_SIZE = 100 KB;
 #define NBLOOPS    3                              /* Default number of benchmark iterations */
 #define TIMELOOP_S 1
 #define TIMELOOP  (TIMELOOP_S * CLOCKS_PER_SEC)   /* Minimum timing per iteration */
 #define XXHSUM32_DEFAULT_SEED 0                   /* Default seed for algo_xxh32 */
 #define XXHSUM64_DEFAULT_SEED 0                   /* Default seed for algo_xxh64 */
 
-#define KB *( 1<<10)
-#define MB *( 1<<20)
-#define GB *(1U<<30)
-
 #define MAX_MEM    (2 GB - 64 MB)
 
 static const char stdinName[] = "-";
@@ -141,31 +141,30 @@ static const algoType g_defaultAlgo = algo_xxh64;    /* required within main() &
 
 /* <16 hex char> <SPC> <SPC> <filename> <'\0'>
  * '4096' is typical Linux PATH_MAX configuration. */
-#define DEFAULT_LINE_LENGTH (sizeof(GF_XXH64_hash_t) * 2 + 2 + 4096 + 1)
+#define DEFAULT_LINE_LENGTH (sizeof(XXH64_hash_t) * 2 + 2 + 4096 + 1)
 
 /* Maximum acceptable line length. */
 #define MAX_LINE_LENGTH (32 KB)
 
 
 /* ************************************
-*  Display macros
-**************************************/
+ *  Display macros
+ **************************************/
 #define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
 #define DISPLAYRESULT(...)   fprintf(stdout, __VA_ARGS__)
-#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) DISPLAY(__VA_ARGS__);
-static U32 g_displayLevel = 1;
+#define DISPLAYLEVEL(l, ...) do { if (g_displayLevel>=l) DISPLAY(__VA_ARGS__); } while (0)
+static int g_displayLevel = 2;
 
 
 /* ************************************
-*  Local variables
-**************************************/
-static size_t g_sampleSize = 100 KB;
+ *  Local variables
+ **************************************/
 static U32 g_nbIterations = NBLOOPS;
 
 
 /* ************************************
-*  Benchmark Functions
-**************************************/
+ *  Benchmark Functions
+ **************************************/
 static clock_t BMK_clockSpan( clock_t start )
 {
     return clock() - start;   /* works even if overflow; Typical max span ~ 30 mn */
@@ -212,59 +211,80 @@ static U64 BMK_GetFileSize(const char* infilename)
 
 typedef U32 (*hashFunction)(const void* buffer, size_t bufferSize, U32 seed);
 
-static U32 localXXH32(const void* buffer, size_t bufferSize, U32 seed) { return GF_XXH32(buffer, bufferSize, seed); }
+static U32 localXXH32(const void* buffer, size_t bufferSize, U32 seed) { return XXH32(buffer, bufferSize, seed); }
 
-static U32 localXXH64(const void* buffer, size_t bufferSize, U32 seed) { return (U32)GF_XXH64(buffer, bufferSize, seed); }
+static U32 localXXH64(const void* buffer, size_t bufferSize, U32 seed) { return (U32)XXH64(buffer, bufferSize, seed); }
 
 static void BMK_benchHash(hashFunction h, const char* hName, const void* buffer, size_t bufferSize)
 {
-    static const U32 nbh_perloop = 100;
+    U32 nbh_perIteration = ((300 MB) / (bufferSize+1)) + 1;  /* first loop conservatively aims for 300 MB/s */
     U32 iterationNb;
     double fastestH = 100000000.;
 
-    DISPLAY("\r%79s\r", "");       /* Clean display line */
+    DISPLAYLEVEL(2, "\r%70s\r", "");       /* Clean display line */
     if (g_nbIterations<1) g_nbIterations=1;
     for (iterationNb = 1; iterationNb <= g_nbIterations; iterationNb++) {
-        U32 nbHashes = 0, r=0;
+        U32 r=0;
         clock_t cStart;
 
-        DISPLAY("%1i-%-17.17s : %10u ->\r", iterationNb, hName, (U32)bufferSize);
+        DISPLAYLEVEL(2, "%1i-%-17.17s : %10u ->\r", iterationNb, hName, (U32)bufferSize);
         cStart = clock();
         while (clock() == cStart);   /* starts clock() at its exact beginning */
         cStart = clock();
 
-        while (BMK_clockSpan(cStart) < TIMELOOP) {
-            U32 i;
-            for (i=0; i<nbh_perloop; i++)
+        {   U32 i;
+            for (i=0; i<nbh_perIteration; i++)
                 r += h(buffer, bufferSize, i);
-            nbHashes += nbh_perloop;
         }
-        if (r==0) DISPLAY(".\r");   /* need to do something with r to avoid compiler optimizing away the hash function */
-        {   double const timeS = ((double)BMK_clockSpan(cStart) / CLOCKS_PER_SEC) / nbHashes;
+        if (r==0) DISPLAYLEVEL(3,".\r");  /* do something with r to avoid compiler "optimizing" away hash function */
+        {   double const timeS = ((double)BMK_clockSpan(cStart) / CLOCKS_PER_SEC) / nbh_perIteration;
             if (timeS < fastestH) fastestH = timeS;
-            DISPLAY("%1i-%-17.17s : %10u -> %7.1f MB/s\r", iterationNb, hName, (U32)bufferSize, ((double)bufferSize / (1<<20)) / fastestH );
+            DISPLAYLEVEL(2, "%1i-%-17.17s : %10u -> %8.0f it/s (%7.1f MB/s) \r",
+                    iterationNb, hName, (U32)bufferSize,
+                    (double)1 / fastestH,
+                    ((double)bufferSize / (1<<20)) / fastestH );
         }
+        assert(fastestH > 1./2000000000);  /* avoid U32 overflow */
+        nbh_perIteration = (U32)(1 / fastestH) + 1;  /* adjust nbh_perIteration to last roughtly one second */
     }
-    DISPLAY("%-19.19s : %10u -> %7.1f MB/s  \n", hName, (U32)bufferSize, ((double)bufferSize / (1<<20)) / fastestH);
+    DISPLAYLEVEL(1, "%-19.19s : %10u -> %8.0f it/s (%7.1f MB/s) \n", hName, (U32)bufferSize,
+        (double)1 / fastestH,
+        ((double)bufferSize / (1<<20)) / fastestH);
+    if (g_displayLevel<1)
+        DISPLAYLEVEL(0, "%u, ", (U32)((double)1 / fastestH));
 }
 
 
-/* Note : buffer is supposed malloc'ed, hence aligned */
-static void BMK_benchMem(const void* buffer, size_t bufferSize)
+/* BMK_benchMem():
+ * specificTest : 0 == run all tests, 1+ run only specific test
+ * buffer : is supposed 8-bytes aligned (if malloc'ed, it should be)
+ * the real allocated size of buffer is supposed to be >= (bufferSize+3).
+ * @return : 0 on success, 1 if error (invalid mode selected) */
+static int BMK_benchMem(const void* buffer, size_t bufferSize, U32 specificTest)
 {
+    assert((((size_t)buffer) & 8) == 0);  /* ensure alignment */
+
     /* XXH32 bench */
-    BMK_benchHash(localXXH32, "XXH32", buffer, bufferSize);
+    if ((specificTest==0) | (specificTest==1))
+        BMK_benchHash(localXXH32, "XXH32", buffer, bufferSize);
 
     /* Bench XXH32 on Unaligned input */
-    if (bufferSize>1)
-        BMK_benchHash(localXXH32, "XXH32 unaligned", ((const char*)buffer)+1, bufferSize-1);
+    if ((specificTest==0) | (specificTest==2))
+        BMK_benchHash(localXXH32, "XXH32 unaligned", ((const char*)buffer)+1, bufferSize);
 
     /* Bench XXH64 */
-    BMK_benchHash(localXXH64, "XXH64", buffer, bufferSize);
+    if ((specificTest==0) | (specificTest==3))
+        BMK_benchHash(localXXH64, "XXH64", buffer, bufferSize);
 
     /* Bench XXH64 on Unaligned input */
-    if (bufferSize>1)
-        BMK_benchHash(localXXH64, "XXH64 unaligned", ((const char*)buffer)+1, bufferSize-1);
+    if ((specificTest==0) | (specificTest==4))
+        BMK_benchHash(localXXH64, "XXH64 unaligned", ((const char*)buffer)+3, bufferSize);
+
+    if (specificTest > 4) {
+        DISPLAY("benchmark mode invalid \n");
+        return 1;
+    }
+    return 0;
 }
 
 
@@ -279,19 +299,21 @@ static size_t BMK_selectBenchedSize(const char* fileName)
 }
 
 
-static int BMK_benchFiles(const char** fileNamesTable, int nbFiles)
+static int BMK_benchFiles(const char** fileNamesTable, int nbFiles, U32 specificTest)
 {
+    int result = 0;
     int fileIdx;
+
     for (fileIdx=0; fileIdx<nbFiles; fileIdx++) {
         const char* const inFileName = fileNamesTable[fileIdx];
         FILE* const inFile = fopen( inFileName, "rb" );
         size_t const benchedSize = BMK_selectBenchedSize(inFileName);
-        char* const buffer = (char*)malloc(benchedSize+16);
-        void* const alignedBuffer = (buffer+15) - (((size_t)(buffer+15)) & 0xF);   /* align on next 16 bytes boundaries */
+        char* const buffer = (char*)calloc(benchedSize+16+3, 1);
+        void* const alignedBuffer = (buffer+15) - (((size_t)(buffer+15)) & 0xF);  /* align on next 16 bytes */
 
         /* Checks */
         if ((inFile==NULL) || (inFileName==NULL)) {
-            DISPLAY( "Pb opening %s\n", inFileName);
+            DISPLAY("Pb opening %s\n", inFileName);
             free(buffer);
             return 11;
         }
@@ -302,7 +324,7 @@ static int BMK_benchFiles(const char** fileNamesTable, int nbFiles)
         }
 
         /* Fill input buffer */
-        DISPLAY("\rLoading %s...        \n", inFileName);
+        DISPLAYLEVEL(1, "\rLoading %s...        \n", inFileName);
         {   size_t const readSize = fread(alignedBuffer, 1, benchedSize, inFile);
             fclose(inFile);
             if(readSize != benchedSize) {
@@ -312,39 +334,47 @@ static int BMK_benchFiles(const char** fileNamesTable, int nbFiles)
         }   }
 
         /* bench */
-        BMK_benchMem(alignedBuffer, benchedSize);
+        result |= BMK_benchMem(alignedBuffer, benchedSize, specificTest);
 
         free(buffer);
     }
 
-    return 0;
+    return result;
 }
 
 
 
-static int BMK_benchInternal(void)
+static int BMK_benchInternal(size_t keySize, int specificTest)
 {
-    size_t const benchedSize = g_sampleSize;
-    void* const buffer = malloc(benchedSize);
+    void* const buffer = calloc(keySize+16+3, 1);
+    void* const alignedBuffer = ((char*)buffer+15) - (((size_t)((char*)buffer+15)) & 0xF);  /* align on next 16 bytes */
     if(!buffer) {
         DISPLAY("\nError: not enough memory!\n");
         return 12;
     }
 
     /* bench */
-    DISPLAY("\rSample of %u KB...        \n", (U32)(benchedSize >> 10));
-    BMK_benchMem(buffer, benchedSize);
+    DISPLAYLEVEL(1, "Sample of ");
+    if (keySize > 10 KB) {
+        DISPLAYLEVEL(1, "%u KB", (U32)(keySize >> 10));
+    } else {
+        DISPLAYLEVEL(1, "%u bytes", (U32)keySize);
+    }
+    DISPLAYLEVEL(1, "...        \n");
 
-    free(buffer);
-    return 0;
+    {   int const result = BMK_benchMem(alignedBuffer, keySize, specificTest);
+        free(buffer);
+        return result;
+    }
 }
 
 
 static void BMK_checkResult(U32 r1, U32 r2)
 {
     static int nbTests = 1;
-    if (r1==r2) DISPLAY("\rTest%3i : %08X == %08X   ok   ", nbTests, r1, r2);
-    else {
+    if (r1==r2) {
+        DISPLAYLEVEL(3, "\rTest%3i : %08X == %08X   ok   ", nbTests, r1, r2);
+    } else {
         DISPLAY("\rERROR : Test%3i : %08X <> %08X   !!!!!   \n", nbTests, r1, r2);
         exit(1);
     }
@@ -356,7 +386,7 @@ static void BMK_checkResult64(U64 r1, U64 r2)
 {
     static int nbTests = 1;
     if (r1!=r2) {
-        DISPLAY("\rERROR : Test%3i : 64-bits values non equals   !!!!!   \n", nbTests);
+        DISPLAY("\rERROR : Test%3i : 64-bit values non equals   !!!!!   \n", nbTests);
         DISPLAY("\r %08X%08X != %08X%08X \n", (U32)(r1>>32), (U32)r1, (U32)(r2>>32), (U32)r2);
         exit(1);
     }
@@ -366,42 +396,44 @@ static void BMK_checkResult64(U64 r1, U64 r2)
 
 static void BMK_testSequence64(void* sentence, size_t len, U64 seed, U64 Nresult)
 {
-    GF_XXH64_state_t state;
+    XXH64_state_t state;
     U64 Dresult;
     size_t pos;
 
-    Dresult = GF_XXH64(sentence, len, seed);
+    Dresult = XXH64(sentence, len, seed);
     BMK_checkResult64(Dresult, Nresult);
 
-    GF_XXH64_reset(&state, seed);
-    GF_XXH64_update(&state, sentence, len);
-    Dresult = GF_XXH64_digest(&state);
+    XXH64_reset(&state, seed);
+    XXH64_update(&state, sentence, len);
+    Dresult = XXH64_digest(&state);
     BMK_checkResult64(Dresult, Nresult);
 
-    GF_XXH64_reset(&state, seed);
-    for (pos=0; pos<len; pos++) GF_XXH64_update(&state, ((char*)sentence)+pos, 1);
-    Dresult = GF_XXH64_digest(&state);
+    XXH64_reset(&state, seed);
+    for (pos=0; pos<len; pos++)
+        XXH64_update(&state, ((char*)sentence)+pos, 1);
+    Dresult = XXH64_digest(&state);
     BMK_checkResult64(Dresult, Nresult);
 }
 
 
 static void BMK_testSequence(const void* sequence, size_t len, U32 seed, U32 Nresult)
 {
-    GF_XXH32_state_t state;
+    XXH32_state_t state;
     U32 Dresult;
     size_t pos;
 
-    Dresult = GF_XXH32(sequence, len, seed);
+    Dresult = XXH32(sequence, len, seed);
     BMK_checkResult(Dresult, Nresult);
 
-    GF_XXH32_reset(&state, seed);
-    GF_XXH32_update(&state, sequence, len);
-    Dresult = GF_XXH32_digest(&state);
+    XXH32_reset(&state, seed);
+    XXH32_update(&state, sequence, len);
+    Dresult = XXH32_digest(&state);
     BMK_checkResult(Dresult, Nresult);
 
-    GF_XXH32_reset(&state, seed);
-    for (pos=0; pos<len; pos++) GF_XXH32_update(&state, ((const char*)sequence)+pos, 1);
-    Dresult = GF_XXH32_digest(&state);
+    XXH32_reset(&state, seed);
+    for (pos=0; pos<len; pos++)
+        XXH32_update(&state, ((const char*)sequence)+pos, 1);
+    Dresult = XXH32_digest(&state);
     BMK_checkResult(Dresult, Nresult);
 }
 
@@ -437,8 +469,8 @@ static void BMK_sanityCheck(void)
     BMK_testSequence64(sanityBuffer, SANITY_BUFFER_SIZE, 0,     0x0EAB543384F878ADULL);
     BMK_testSequence64(sanityBuffer, SANITY_BUFFER_SIZE, prime, 0xCAA65939306F1E21ULL);
 
-    DISPLAY("\r%79s\r", "");       /* Clean display line */
-    DISPLAYLEVEL(2, "Sanity check -- all tests ok\n");
+    DISPLAYLEVEL(3, "\r%70s\r", "");       /* Clean display line */
+    DISPLAYLEVEL(3, "Sanity check -- all tests ok\n");
 }
 
 
@@ -464,13 +496,13 @@ static void BMK_display_BigEndian(const void* ptr, size_t length)
 
 static void BMK_hashStream(void* xxhHashValue, const algoType hashType, FILE* inFile, void* buffer, size_t blockSize)
 {
-    GF_XXH64_state_t state64;
-    GF_XXH32_state_t state32;
+    XXH64_state_t state64;
+    XXH32_state_t state32;
     size_t readSize;
 
     /* Init */
-    GF_XXH32_reset(&state32, XXHSUM32_DEFAULT_SEED);
-    GF_XXH64_reset(&state64, XXHSUM64_DEFAULT_SEED);
+    XXH32_reset(&state32, XXHSUM32_DEFAULT_SEED);
+    XXH64_reset(&state64, XXHSUM64_DEFAULT_SEED);
 
     /* Load file & update hash */
     readSize = 1;
@@ -479,10 +511,10 @@ static void BMK_hashStream(void* xxhHashValue, const algoType hashType, FILE* in
         switch(hashType)
         {
         case algo_xxh32:
-            GF_XXH32_update(&state32, buffer, readSize);
+            XXH32_update(&state32, buffer, readSize);
             break;
         case algo_xxh64:
-            GF_XXH64_update(&state64, buffer, readSize);
+            XXH64_update(&state64, buffer, readSize);
             break;
         default:
             break;
@@ -492,12 +524,12 @@ static void BMK_hashStream(void* xxhHashValue, const algoType hashType, FILE* in
     switch(hashType)
     {
     case algo_xxh32:
-        {   U32 const h32 = GF_XXH32_digest(&state32);
+        {   U32 const h32 = XXH32_digest(&state32);
             memcpy(xxhHashValue, &h32, sizeof(h32));
             break;
         }
     case algo_xxh64:
-        {   U64 const h64 = GF_XXH64_digest(&state64);
+        {   U64 const h64 = XXH64_digest(&state64);
             memcpy(xxhHashValue, &h64, sizeof(h64));
             break;
         }
@@ -542,45 +574,46 @@ static int BMK_hash(const char* fileName,
     /* loading notification */
     {   const size_t fileNameSize = strlen(fileName);
         const char* const fileNameEnd = fileName + fileNameSize;
-        const size_t maxInfoFilenameSize = fileNameSize > 30 ? 30 : fileNameSize;
-        size_t infoFilenameSize = 1;
-        while ( (infoFilenameSize < maxInfoFilenameSize)
-              &&(fileNameEnd[-1-infoFilenameSize] != '/')
-              &&(fileNameEnd[-1-infoFilenameSize] != '\\') )
+        const int maxInfoFilenameSize = (int)(fileNameSize > 30 ? 30 : fileNameSize);
+        int infoFilenameSize = 1;
+        while ((infoFilenameSize < maxInfoFilenameSize)
+            && (fileNameEnd[-1-infoFilenameSize] != '/')
+            && (fileNameEnd[-1-infoFilenameSize] != '\\') )
               infoFilenameSize++;
-        DISPLAY("\rLoading %s...                        \r", fileNameEnd - infoFilenameSize);
-    }
+        DISPLAY("\rLoading %s...  \r", fileNameEnd - infoFilenameSize);
 
-    /* Load file & update hash */
-    switch(hashType)
-    {
-    case algo_xxh32:
-        BMK_hashStream(&h32, algo_xxh32, inFile, buffer, blockSize);
-        break;
-    case algo_xxh64:
-        BMK_hashStream(&h64, algo_xxh64, inFile, buffer, blockSize);
-        break;
-    default:
-        break;
-    }
+        /* Load file & update hash */
+        switch(hashType)
+        {
+        case algo_xxh32:
+            BMK_hashStream(&h32, algo_xxh32, inFile, buffer, blockSize);
+            break;
+        case algo_xxh64:
+            BMK_hashStream(&h64, algo_xxh64, inFile, buffer, blockSize);
+            break;
+        default:
+            break;
+        }
 
-    fclose(inFile);
-    free(buffer);
+        fclose(inFile);
+        free(buffer);
+        DISPLAY("%s             \r", fileNameEnd - infoFilenameSize);  /* erase line */
+    }
 
     /* display Hash */
     switch(hashType)
     {
     case algo_xxh32:
-        {   GF_XXH32_canonical_t hcbe32;
-            GF_XXH32_canonicalFromHash(&hcbe32, h32);
+        {   XXH32_canonical_t hcbe32;
+            XXH32_canonicalFromHash(&hcbe32, h32);
             displayEndianess==big_endian ?
                 BMK_display_BigEndian(&hcbe32, sizeof(hcbe32)) : BMK_display_LittleEndian(&hcbe32, sizeof(hcbe32));
             DISPLAYRESULT("  %s\n", fileName);
             break;
         }
     case algo_xxh64:
-        {   GF_XXH64_canonical_t hcbe64;
-            GF_XXH64_canonicalFromHash(&hcbe64, h64);
+        {   XXH64_canonical_t hcbe64;
+            XXH64_canonicalFromHash(&hcbe64, h64);
             displayEndianess==big_endian ?
                 BMK_display_BigEndian(&hcbe64, sizeof(hcbe64)) : BMK_display_LittleEndian(&hcbe64, sizeof(hcbe64));
             DISPLAYRESULT("  %s\n", fileName);
@@ -634,8 +667,8 @@ typedef enum {
 } LineStatus;
 
 typedef union {
-    GF_XXH32_canonical_t xxh32;
-    GF_XXH64_canonical_t xxh64;
+    XXH32_canonical_t xxh32;
+    XXH64_canonical_t xxh64;
 } Canonical;
 
 typedef struct {
@@ -680,10 +713,12 @@ static GetLineResult getLine(char** lineBuf, int* lineMax, FILE* inFile)
     GetLineResult result = GetLine_ok;
     int len = 0;
 
-    if (*lineBuf == NULL || *lineMax < 1) {
-        *lineMax = DEFAULT_LINE_LENGTH;
-        *lineBuf = (char*) realloc(*lineBuf, *lineMax);
+    if ((*lineBuf == NULL) || (*lineMax<1)) {
+        free(*lineBuf);  /* in case it's != NULL */
+        *lineMax = 0;
+        *lineBuf = (char*)malloc(DEFAULT_LINE_LENGTH);
         if(*lineBuf == NULL) return GetLine_outOfMemory;
+        *lineMax = DEFAULT_LINE_LENGTH;
     }
 
     for (;;) {
@@ -788,7 +823,7 @@ static ParseLineResult parseLine(ParsedLine* parsedLine, const char* line)
     switch (firstSpace - line)
     {
     case 8:
-        {   GF_XXH32_canonical_t* xxh32c = &parsedLine->canonical.xxh32;
+        {   XXH32_canonical_t* xxh32c = &parsedLine->canonical.xxh32;
             if (canonicalFromString(xxh32c->digest, sizeof(xxh32c->digest), line)
                 != CanonicalFromString_ok) {
                 return ParseLine_invalidFormat;
@@ -798,7 +833,7 @@ static ParseLineResult parseLine(ParsedLine* parsedLine, const char* line)
         }
 
     case 16:
-        {   GF_XXH64_canonical_t* xxh64c = &parsedLine->canonical.xxh64;
+        {   XXH64_canonical_t* xxh64c = &parsedLine->canonical.xxh64;
             if (canonicalFromString(xxh64c->digest, sizeof(xxh64c->digest), line)
                 != CanonicalFromString_ok) {
                 return ParseLine_invalidFormat;
@@ -905,17 +940,17 @@ static void parseFile1(ParseFileArg* parseFileArg)
             switch (parsedLine.xxhBits)
             {
             case 32:
-                {   GF_XXH32_hash_t xxh;
+                {   XXH32_hash_t xxh;
                     BMK_hashStream(&xxh, algo_xxh32, fp, parseFileArg->blockBuf, parseFileArg->blockSize);
-                    if (xxh == GF_XXH32_hashFromCanonical(&parsedLine.canonical.xxh32)) {
+                    if (xxh == XXH32_hashFromCanonical(&parsedLine.canonical.xxh32)) {
                         lineStatus = LineStatus_hashOk;
                 }   }
                 break;
 
             case 64:
-                {   GF_XXH64_hash_t xxh;
+                {   XXH64_hash_t xxh;
                     BMK_hashStream(&xxh, algo_xxh64, fp, parseFileArg->blockBuf, parseFileArg->blockSize);
-                    if (xxh == GF_XXH64_hashFromCanonical(&parsedLine.canonical.xxh64)) {
+                    if (xxh == XXH64_hashFromCanonical(&parsedLine.canonical.xxh64)) {
                         lineStatus = LineStatus_hashOk;
                 }   }
                 break;
@@ -1122,10 +1157,30 @@ static int badusage(const char* exename)
     return 1;
 }
 
+/*! readU32FromChar() :
+   @return : unsigned integer value read from input in `char` format,
+             0 is no figure at *stringPtr position.
+    Interprets K, KB, KiB, M, MB and MiB suffix.
+    Modifies `*stringPtr`, advancing it to position where reading stopped.
+    Note : function result can overflow if digit string > MAX_UINT */
+static unsigned readU32FromChar(const char** stringPtr)
+{
+    unsigned result = 0;
+    while ((**stringPtr >='0') && (**stringPtr <='9'))
+        result *= 10, result += **stringPtr - '0', (*stringPtr)++ ;
+    if ((**stringPtr=='K') || (**stringPtr=='M')) {
+        result <<= 10;
+        if (**stringPtr=='M') result <<= 10;
+        (*stringPtr)++ ;
+        if (**stringPtr=='i') (*stringPtr)++;
+        if (**stringPtr=='B') (*stringPtr)++;
+    }
+    return result;
+}
 
 int main(int argc, const char** argv)
 {
-    int i, filenamesStart=0;
+    int i, filenamesStart = 0;
     const char* const exename = argv[0];
     U32 benchmarkMode = 0;
     U32 fileCheckMode = 0;
@@ -1133,7 +1188,9 @@ int main(int argc, const char** argv)
     U32 statusOnly    = 0;
     U32 warn          = 0;
     U32 quiet         = 0;
-    algoType algo = g_defaultAlgo;
+    U32 specificTest  = 0;
+    size_t keySize    = XXH_DEFAULT_SAMPLE_SIZE;
+    algoType algo     = g_defaultAlgo;
     endianess displayEndianess = big_endian;
 
     /* special case : xxh32sum default to 32 bits checksum */
@@ -1193,21 +1250,26 @@ int main(int argc, const char** argv)
             /* Trigger benchmark mode */
             case 'b':
                 argument++;
-                benchmarkMode=1;
+                benchmarkMode = 1;
+                specificTest = readU32FromChar(&argument);   /* select one specific test (hidden option) */
                 break;
 
             /* Modify Nb Iterations (benchmark only) */
             case 'i':
-                g_nbIterations = argument[1] - '0';
-                argument+=2;
+                argument++;
+                g_nbIterations = readU32FromChar(&argument);
                 break;
 
             /* Modify Block size (benchmark only) */
             case 'B':
                 argument++;
-                g_sampleSize = 0;
-                while (argument[0]>='0' && argument[0]<='9')
-                    g_sampleSize *= 10, g_sampleSize += argument[0]-'0', argument++;
+                keySize = readU32FromChar(&argument);
+                break;
+
+            /* Modify verbosity of benchmark output (hidden option) */
+            case 'q':
+                argument++;
+                g_displayLevel--;
                 break;
 
             default:
@@ -1218,10 +1280,10 @@ int main(int argc, const char** argv)
 
     /* Check benchmark mode */
     if (benchmarkMode) {
-        DISPLAY( WELCOME_MESSAGE(exename) );
+        DISPLAYLEVEL(2, WELCOME_MESSAGE(exename) );
         BMK_sanityCheck();
-        if (filenamesStart==0) return BMK_benchInternal();
-        return BMK_benchFiles(argv+filenamesStart, argc-filenamesStart);
+        if (filenamesStart==0) return BMK_benchInternal(keySize, specificTest);
+        return BMK_benchFiles(argv+filenamesStart, argc-filenamesStart, specificTest);
     }
 
     /* Check if input is defined as console; trigger an error in this case */
@@ -1229,7 +1291,8 @@ int main(int argc, const char** argv)
 
     if (filenamesStart==0) filenamesStart = argc;
     if (fileCheckMode) {
-        return checkFiles(argv+filenamesStart, argc-filenamesStart, displayEndianess, strictMode, statusOnly, warn, quiet);
+        return checkFiles(argv+filenamesStart, argc-filenamesStart,
+                          displayEndianess, strictMode, statusOnly, warn, quiet);
     } else {
         return BMK_hashFiles(argv+filenamesStart, argc-filenamesStart, algo, displayEndianess);
     }
diff --git a/doc/Makefile.am b/doc/Makefile.am
index 1103b607dba..de68c20b4d7 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -1,6 +1,9 @@
 EXTRA_DIST = glusterfs.8 mount.glusterfs.8 gluster.8 \
 			glusterd.8 glusterfsd.8
 
-man8_MANS = glusterfs.8 mount.glusterfs.8 gluster.8 glusterd.8 glusterfsd.8
+man8_MANS = glusterfs.8 mount.glusterfs.8 gluster.8
+if WITH_SERVER
+man8_MANS += glusterd.8 glusterfsd.8
+endif
 
 CLEANFILES =
diff --git a/doc/README.md b/doc/README.md
index e057437fcba..6aa28642ef4 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -1,6 +1,14 @@
+## Developer Guide
+
+Gluster's contributors can check about the internals by visiting [Developer Guide Section](developer-guide). While it is not 'comprehensive', it can help you to get started.
+
+Also while coding, keep [Coding Standard](developer-guide/coding-standard.md) in mind.
+
+When you are ready to commit the changes, make sure you meet our [Commit message standard](developer-guide/commit-guidelines.md).
+
 ## Admin Guide ##
 
-The gluster administration guide is maintained at [github](https://github.com/gluster/glusterdocs). The browsable admin guide can be found [here](http://gluster.readthedocs.org/en/latest/Administrator%20Guide/README/).
+The gluster administration guide is maintained at [github](https://github.com/gluster/glusterdocs). The browsable admin guide can be found [here](http://docs.gluster.org/en/latest/Administrator%20Guide/).
 
 The doc patch has to be sent against the above mentioned repository.
 
@@ -10,7 +18,7 @@ The Gluster features which are 'in progress' or implemented can be found at [git
 
 ## Upgrade Guide ##
 
-The gluster upgrade guide is maintained at [github](https://github.com/gluster/glusterdocs). The browsable upgrade guide can be found [here](http://gluster.readthedocs.org/en/latest/Upgrade-Guide/README/)
+The gluster upgrade guide is maintained at [github](https://github.com/gluster/glusterdocs). The browsable upgrade guide can be found [here](http://docs.gluster.org/en/latest/Upgrade-Guide)
 
 The doc patch has to be sent against the above mentioned repository.
 
diff --git a/doc/developer-guide/coredump-analysis.md b/doc/debugging/analyzing-regression-cores.md
index 16fa9165fd0..5e10f41c6eb 100644
--- a/doc/developer-guide/coredump-analysis.md
+++ b/doc/debugging/analyzing-regression-cores.md
@@ -1,36 +1,35 @@
-This document explains how to analyze core-dumps obtained from regression
-machines, with examples.  
-1) Download the core-tarball and extract it.  
-2) 'cd' into directory where the tarball is extracted.
-~~~
-[root@atalur Downloads]# pwd
-/home/atalur/Downloads
-[root@atalur Downloads]# ls
+# Analyzing Regression Cores
+This document explains how to analyze core-dumps obtained from regression machines, with examples.
+1. Download the core-tarball and extract it.
+2. `cd` into directory where the tarball is extracted.
+```
+[sh]# pwd
+/home/user/Downloads
+[sh]# ls
 build  build-install-20150625_05_42_39.tar.bz2  lib64  usr
-~~~
-3) Determine the core file you need to examine. There can be more than one core file.  
-You can list them from './build/install/cores' directory.
-~~~
-[root@atalur Downloads]# ls build/install/cores/
+```
+3. Determine the core file you need to examine. There can be more than one core file. You can list them from './build/install/cores' directory.
+```
+[sh]# ls build/install/cores/
 core.9341  liblist.txt  liblist.txt.tmp
-~~~
+```
 In case you are unsure which binary generated the core-file, executing 'file' command on it will help.
-~~~
-[root@atalur Downloads]# file ./build/install/cores/core.9341 
+```
+[sh]# file ./build/install/cores/core.9341 
 ./build/install/cores/core.9341: ELF 64-bit LSB core file x86-64, version 1 (SYSV), SVR4-style, from '/build/install/sbin/glusterfsd -s slave26.cloud.gluster.org --volfile-id patchy'
-~~~
-As seen, the core file was generated by glusterfsd binary, and path to it is provided (/build/install/sbin/glusterfsd).  
-4) Now, run the following command on the core:
-~~~
+```
+As seen, the core file was generated by glusterfsd binary, and path to it is provided (/build/install/sbin/glusterfsd).
+
+4. Now, run the following command on the core:
+```
 gdb -ex 'set sysroot ./' -ex 'core-file ./build/install/cores/core.xxx' <target, say ./build/install/sbin/glusterd>
 In this case,
 gdb -ex 'set sysroot ./' -ex 'core-file ./build/install/cores/core.9341' ./build/install/sbin/glusterfsd
-~~~
-5) You can cross check if all shared libraries are available and loaded by using 'info sharedlibrary' command from
-inside gdb.  
-6) Once verified, usual gdb commands based on requirement can be used to debug the core.
-'bt' or 'backtrace' from gdb of core used in examples:
-~~~
+```
+5. You can cross check if all shared libraries are available and loaded by using 'info sharedlibrary' command from inside gdb.
+6. Once verified, usual gdb commands based on requirement can be used to debug the core.
+   `bt` or `backtrace` from gdb of core used in examples:
+```
 Core was generated by `/build/install/sbin/glusterfsd -s slave26.cloud.gluster.org --volfile-id patchy'.
 Program terminated with signal SIGABRT, Aborted.
 #0  0x00007f512a54e625 in raise () from ./lib64/libc.so.6
@@ -52,4 +51,4 @@ Program terminated with signal SIGABRT, Aborted.
 #12 0x00007f512a55f8f0 in ?? () from ./lib64/libc.so.6
 #13 0x0000000000000000 in ?? ()
 (gdb) 
-~~~
+```
diff --git a/doc/debugging/coredump-analysis.md b/doc/debugging/coredump-analysis.md
deleted file mode 100644
index f9ecf73216e..00000000000
--- a/doc/debugging/coredump-analysis.md
+++ /dev/null
@@ -1,31 +0,0 @@
-This document explains how to analyze core-dumps obtained from regression
-machines, with examples.  
-1) Download the core-tarball and extract it.  
-2) 'cd' into the root of extracted tarball.
-~~~
-[root@atalur Downloads]# pwd
-/home/atalur/Downloads
-[root@atalur Downloads]# ls
-build  build-install-20150625_05_42_39.tar.bz2  lib64  usr
-~~~
-3) Determine the core file you need to examine. There can be more than one core file.  
-You can list them from './build/install/cores' directory.
-~~~
-[root@atalur Downloads]# ls build/install/cores/
-core.9341  liblist.txt  liblist.txt.tmp
-~~~
-In case you are unsure which binary generated the core-file, executing 'file' command on it will help.
-~~~
-[root@atalur Downloads]# file ./build/install/cores/core.9341 
-./build/install/cores/core.9341: ELF 64-bit LSB core file x86-64, version 1 (SYSV), SVR4-style, from '/build/install/sbin/glusterfsd -s slave26.cloud.gluster.org --volfile-id patchy'
-~~~
-As seen, the core file was generated by glusterfsd binary, and path to it is provide (/build/install/sbin/glusterfsd).  
-4) Now, run the following command on the core:
-~~~
-gdb -ex 'set sysroot ./' -ex 'core-file ./build/install/cores/core.xxx' <target, say ./build/install/sbin/glusterd>
-In this case,
-gdb -ex 'set sysroot ./' -ex 'core-file ./build/install/cores/core.9341' ./build/install/sbin/glusterfsd
-~~~
-5) You can cross check if all shared libraries are available and loaded by using 'info sharedlibrary' command from
-inside gdb.  
-6) Once verified, usual gdb commands based on requirement can be used to debug the core.
diff --git a/doc/debugging/gfid-to-path.md b/doc/debugging/gfid-to-path.md
index 09c459e52c8..1917bf2cca1 100644
--- a/doc/debugging/gfid-to-path.md
+++ b/doc/debugging/gfid-to-path.md
@@ -1,37 +1,37 @@
-#Convert GFID to Path
+# Convert GFID to Path
 
 GlusterFS internal file identifier (GFID) is a uuid that is unique to each
 file across the entire cluster. This is analogous to inode number in a
 normal filesystem. The GFID of a file is stored in its xattr named
 `trusted.gfid`.
 
-####Special mount using [gfid-access translator][1]:
-~~~
+#### Special mount using [gfid-access translator][1]:
+```
 mount -t glusterfs -o aux-gfid-mount vm1:test /mnt/testvol
-~~~
+```
 
 Assuming, you have `GFID` of a file from changelog (or somewhere else).
 For trying this out, you can get `GFID` of a file from mountpoint:
-~~~
+```
 getfattr -n glusterfs.gfid.string /mnt/testvol/dir/file
-~~~
+```
 
 
 ---
-###Get file path from GFID (Method 1):
+### Get file path from GFID (Method 1):
 **(Lists hardlinks delimited by `:`, returns path as seen from mountpoint)**
 
-####Turn on build-pgfid option
-~~~
+#### Turn on build-pgfid option
+```
 gluster volume set test build-pgfid on
-~~~
+```
 Read virtual xattr `glusterfs.ancestry.path` which contains the file path
-~~~
+```
 getfattr -n glusterfs.ancestry.path -e text /mnt/testvol/.gfid/<GFID>
-~~~
+```
 
 **Example:**
-~~~
+```
 [root@vm1 glusterfs]# ls -il /mnt/testvol/dir/
 total 1
 10610563327990022372 -rw-r--r--. 2 root root 3 Jul 17 18:05 file
@@ -46,28 +46,23 @@ glusterfs.gfid.string="11118443-1894-4273-9340-4b212fa1c0e4"
 getfattr: Removing leading '/' from absolute path names
 # file: mnt/testvol/.gfid/11118443-1894-4273-9340-4b212fa1c0e4
 glusterfs.ancestry.path="/dir/file:/dir/file3"
-~~~
+```
 
 ---
-###Get file path from GFID (Method 2):
+### Get file path from GFID (Method 2):
 **(Does not list all hardlinks, returns backend brick path)**
-~~~
+```
 getfattr -n trusted.glusterfs.pathinfo -e text /mnt/testvol/.gfid/<GFID>
-~~~
+```
 
 **Example:**
-~~~
+```
 [root@vm1 glusterfs]# getfattr -n trusted.glusterfs.pathinfo -e text /mnt/testvol/.gfid/11118443-1894-4273-9340-4b212fa1c0e4
 getfattr: Removing leading '/' from absolute path names
 # file: mnt/testvol/.gfid/11118443-1894-4273-9340-4b212fa1c0e4
 trusted.glusterfs.pathinfo="(<DISTRIBUTE:test-dht> <POSIX(/mnt/brick-test/b):vm1:/mnt/brick-test/b/dir//file3>)"
-~~~
+```
 
 ---
-###Get file path from GFID (Method 3):
-https://gist.github.com/semiosis/4392640
-
----
-####References and links:
+#### References and links:
 [posix: placeholders for GFID to path conversion](http://review.gluster.org/5951)
-[1]: https://github.com/gluster/glusterfs/blob/master/doc/features/gfid-access.md
diff --git a/doc/debugging/mem-alloc-list.md b/doc/debugging/mem-alloc-list.md
new file mode 100644
index 00000000000..1c68e65d323
--- /dev/null
+++ b/doc/debugging/mem-alloc-list.md
@@ -0,0 +1,19 @@
+## Viewing Memory Allocations
+
+While statedumps provide stats of the number of allocations, size etc for a
+particular mem type, there is no easy way to examine all the allocated objects of that type
+in memory.Being able to view this information could help with determining how an object is used,
+and if there are any memory leaks.
+
+The mem_acct_rec structures have been updated to include lists to which the allocated object is
+added. These can be examined in gdb using simple scripts.
+
+`gdb> plist xl->mem_acct.rec[$type]->obj_list`
+
+will print out the pointers of all allocations of $type.
+
+These changes are primarily targeted at developers and need to enabled
+at compile-time using `configure --enable-debug`.
+
+
+
diff --git a/doc/debugging/split-brain.md b/doc/debugging/split-brain.md
index b0d938e26bc..6b122c40551 100644
--- a/doc/debugging/split-brain.md
+++ b/doc/debugging/split-brain.md
@@ -1,33 +1,36 @@
-Steps to recover from File split-brain.
-======================================
-
-Quick Start:
-============
-1. Get the path of the file that is in split-brain:  
->  It can be obtained either by  
->       a) The command `gluster volume heal info split-brain`.  
->       b) Identify the files for which file operations performed
-           from the client keep failing with Input/Output error.
-
-2. Close the applications that opened this file from the mount point.
+# Steps to recover from File split-brain
+This document contains steps to recover from a file split-brain.
+## Quick Start:
+### Step 1. Get the path of the file that is in split-brain:
+It can be obtained either by
+1. The command `gluster volume heal info split-brain`.
+2. Identify the files for which file operations performed from the client keep failing with Input/Output error.
+
+### Step 2. Close the applications that opened this file from the mount point.
 In case of VMs, they need to be powered-off.
 
-3. Decide on the correct copy:  
-> This is done by observing the afr changelog extended attributes of the file on
+### Step 3. Decide on the correct copy:  
+This is done by observing the afr changelog extended attributes of the file on
 the bricks using the getfattr command; then identifying the type of split-brain 
 (data split-brain, metadata split-brain, entry split-brain or split-brain due to
 gfid-mismatch); and finally determining which of the bricks contains the 'good copy'
 of the file.  
->   `getfattr -d -m . -e hex <file-path-on-brick>`.  
+```
+getfattr -d -m . -e hex <file-path-on-brick>
+```
+  
 It is also possible that one brick might contain the correct data while the
 other might contain the correct metadata.
 
-4. Reset the relevant extended attribute on the brick(s) that contains the
-'bad copy' of the file data/metadata using the setfattr command.  
->   `setfattr -n <attribute-name> -v <attribute-value> <file-path-on-brick>`
+### Step 4. Reset the relevant extended attribute on the brick(s) that contains the 'bad copy' of the file data/metadata using the setfattr command.  
+```
+setfattr -n <attribute-name> -v <attribute-value> <file-path-on-brick>
+```
 
-5. Trigger self-heal on the file by performing lookup from the client:  
->   `ls -l <file-path-on-gluster-mount>`
+### Step 5. Trigger self-heal on the file by performing lookup from the client:  
+```
+ls -l <file-path-on-gluster-mount>
+```
 
 Detailed Instructions for steps 3 through 5:  
 ===========================================
@@ -36,13 +39,15 @@ afr changelog extended attributes.
 
 Execute `getfattr -d -m . -e hex <file-path-on-brick>`
 
-* Example:  
+Example:  
+```
 [root@store3 ~]# getfattr -d -e hex -m. brick-a/file.txt  
 \#file: brick-a/file.txt  
 security.selinux=0x726f6f743a6f626a6563745f723a66696c655f743a733000  
 trusted.afr.vol-client-2=0x000000000000000000000000  
 trusted.afr.vol-client-3=0x000000000200000000000000  
 trusted.gfid=0x307a5c9efddd4e7c96e94fd4bcdcbd1b  
+```
 
 The extended attributes with `trusted.afr.<volname>-client-<subvolume-index>`
 are used by afr to maintain changelog of the file.The values of the
@@ -51,10 +56,11 @@ client (fuse or nfs-server) processes. When the glusterfs client modifies a file
 or directory, the client contacts each brick and updates the changelog extended 
 attribute according to the response of the brick.
 
-'subvolume-index' is nothing but (brick number - 1) in
+`subvolume-index` is nothing but (brick number - 1) in
 `gluster volume info <volname>` output.
 
-* Example:  
+Example:
+```
 [root@pranithk-laptop ~]# gluster volume info vol  
  Volume Name: vol  
  Type: Distributed-Replicate  
@@ -71,6 +77,7 @@ attribute according to the response of the brick.
  brick-f: pranithk-laptop:/gfs/brick-f  
  brick-g: pranithk-laptop:/gfs/brick-g  
  brick-h: pranithk-laptop:/gfs/brick-h  
+```
 
 In the example above:  
 ```
@@ -91,12 +98,15 @@ present in all the other bricks in it's replica set as seen by that brick.
 
 In the example volume given above, all files in brick-a will have 2 entries, 
 one for itself and the other for the file present in it's replica pair, i.e.brick-b:  
+```
 trusted.afr.vol-client-0=0x000000000000000000000000 -->changelog for itself (brick-a)  
 trusted.afr.vol-client-1=0x000000000000000000000000 -->changelog for brick-b as seen by brick-a  
-
+```
 Likewise, all files in brick-b will have:  
+```
 trusted.afr.vol-client-0=0x000000000000000000000000 -->changelog for brick-a as seen by brick-b  
 trusted.afr.vol-client-1=0x000000000000000000000000 -->changelog for itself (brick-b)  
+```
 
 The same can be extended for other replica pairs.  
 
@@ -122,7 +132,8 @@ When a file split-brain happens it could be either data split-brain or
 meta-data split-brain or both. When a split-brain happens the changelog of the
 file would be something like this:  
 
-* Example:(Lets consider both data, metadata split-brain on same file).  
+Example:(Lets consider both data, metadata split-brain on same file).  
+```
 [root@pranithk-laptop vol]# getfattr -d -m . -e hex /gfs/brick-?/a  
 getfattr: Removing leading '/' from absolute path names  
 \#file: gfs/brick-a/a  
@@ -133,10 +144,11 @@ trusted.gfid=0x80acdbd886524f6fbefa21fc356fed57
 trusted.afr.vol-client-0=0x000003b00000000100000000  
 trusted.afr.vol-client-1=0x000000000000000000000000  
 trusted.gfid=0x80acdbd886524f6fbefa21fc356fed57  
+```
 
-###Observations:
+### Observations:
 
-####According to changelog extended attributes on file /gfs/brick-a/a:  
+#### According to changelog extended attributes on file /gfs/brick-a/a:  
 The first 8 digits of trusted.afr.vol-client-0 are all
 zeros (0x00000000................), and the first 8 digits of
 trusted.afr.vol-client-1 are not all zeros (0x000003d7................).
@@ -149,7 +161,7 @@ trusted.afr.vol-client-1 are not all zeros (0x........00000001........).
 So the changelog on /gfs/brick-a/a implies that some metadata operations succeeded 
 on itself but failed on /gfs/brick-b/a.
 
-####According to Changelog extended attributes on file /gfs/brick-b/a:  
+#### According to Changelog extended attributes on file /gfs/brick-b/a:  
 The first 8 digits of trusted.afr.vol-client-0 are not all
 zeros (0x000003b0................), and the first 8 digits of
 trusted.afr.vol-client-1 are all zeros (0x00000000................).
@@ -205,6 +217,7 @@ Hence execute
 `setfattr -n trusted.afr.vol-client-1 -v 0x000003d70000000000000000 /gfs/brick-a/a`
 
 Thus after the above operations are done, the changelogs look like this:  
+```
 [root@pranithk-laptop vol]# getfattr -d -m . -e hex /gfs/brick-?/a  
 getfattr: Removing leading '/' from absolute path names  
 \#file: gfs/brick-a/a  
@@ -216,7 +229,7 @@ trusted.gfid=0x80acdbd886524f6fbefa21fc356fed57
 trusted.afr.vol-client-0=0x000000000000000100000000  
 trusted.afr.vol-client-1=0x000000000000000000000000  
 trusted.gfid=0x80acdbd886524f6fbefa21fc356fed57  
-
+```
 
 Triggering Self-heal:
 ---------------------
@@ -243,9 +256,9 @@ needs to be removed.The gfid-link files are present in the .glusterfs folder
 in the top-level directory of the brick. If the gfid of the file is
 0x307a5c9efddd4e7c96e94fd4bcdcbd1b (the trusted.gfid extended attribute got
 from the getfattr command earlier),the gfid-link file can be found at
-> /gfs/brick-a/.glusterfs/30/7a/307a5c9efddd4e7c96e94fd4bcdcbd1b
+`/gfs/brick-a/.glusterfs/30/7a/307a5c9efddd4e7c96e94fd4bcdcbd1b`
 
-####Word of caution:
+#### Word of caution:
 Before deleting the gfid-link, we have to ensure that there are no hard links
 to the file present on that brick. If hard-links exist,they must be deleted as
 well.
diff --git a/doc/debugging/statedump.md b/doc/debugging/statedump.md
index 9939576e270..9dfdce15fad 100644
--- a/doc/debugging/statedump.md
+++ b/doc/debugging/statedump.md
@@ -1,21 +1,30 @@
-#Statedump
+# Statedump
 Statedump is a file generated by glusterfs process with different data structure state which may contain the active inodes, fds, mempools, iobufs, memory allocation stats of different types of datastructures per xlator etc.
 
-##How to generate statedump
-We can find the directory where statedump files are created using 'gluster --print-statedumpdir' command.
+## How to generate statedump
+We can find the directory where statedump files are created using `gluster --print-statedumpdir` command.
 Create that directory if not already present based on the type of installation.
 Lets call this directory `statedump-directory`.
 
-We can generate statedump using 'kill -USR1 <pid-of-gluster-process>'.
+We can generate statedump using `kill -USR1 <pid-of-gluster-process>`.
 gluster-process is nothing but glusterd/glusterfs/glusterfsd process.
 
 There are also commands to generate statedumps for brick processes/nfs server/quotad
 
-For bricks:     `gluster volume statedump <volname>`
+For bricks: 
+```
+gluster volume statedump <volname>
+```
 
-For nfs server: `gluster volume statedump <volname> nfs`
+For nfs server:
+```
+gluster volume statedump <volname> nfs
+```
 
-For quotad:     `gluster volume statedump <volname> quotad`
+For quotad:
+```
+gluster volume statedump <volname> quotad
+```
 
 For brick-processes files will be created in `statedump-directory` with name of the file as `hyphenated-brick-path.<pid>.dump.timestamp`. For all other processes it will be `glusterdump.<pid>.dump.timestamp`.
 
@@ -24,21 +33,21 @@ processes could have used the `SIGUSR1` signal already for other purposes.
 To generate statedump for the processes, using libgfapi, below command can be
 executed from one of the nodes in the gluster cluster to which the libgfapi
 application is connected to.
-
-    gluster volume statedump <volname> client <hostname>:<process id>
-
+```
+gluster volume statedump <volname> client <hostname>:<process id>
+```
 The statedumps can be found in the `statedump-directory`, the name of the
 statedumps being `glusterdump.<pid>.dump.timestamp`. For a process there can be
 multiple such files created depending on the number of times the volume is
 accessed by the process (related to the number of `glfs_init()` calls).
 
-##How to read statedump
+## How to read statedump
 We shall see snippets of each type of statedump.
 
 First and last lines of the file have starting and ending time of writing the statedump file. Times will be in UTC timezone.
 
 mallinfo return status is printed in the following format. Please read man mallinfo for more information about what each field means.
-###Mallinfo
+### Mallinfo
 ```
 [mallinfo]
 mallinfo_arena=100020224 /* Non-mmapped space allocated (bytes) */
@@ -53,7 +62,7 @@ mallinfo_fordblks=3310112 /* Total free space (bytes) */
 mallinfo_keepcost=133712 /* Top-most, releasable space (bytes) */
 ```
 
-###Data structure allocation stats
+### Data structure allocation stats
 For every xlator data structure memory per translator loaded in the call-graph is displayed in the following format:
 
 For xlator with name: glusterfs
@@ -74,7 +83,7 @@ max_num_allocs=3 #Maximum number of active allocations at any point in the life
 total_allocs=7 #Number of times this data is allocated in the life of the process.
 ```
 
-###Mempools
+### Mempools
 
 Mempools are optimization to reduce the number of allocations of a data type. If we create a mem-pool of lets say 1024 elements for a data-type, new elements will be allocated from heap using syscalls like calloc, only if all the 1024 elements in the pool are in active use.
 
@@ -94,7 +103,7 @@ cur-stdalloc=0 #Denotes the number of allocations made from heap once cold-count
 max-stdalloc=0 #Maximum number of allocations from heap that are in active use at any point in the life of the process.
 ```
 
-###Iobufs
+### Iobufs
 ```
 [iobuf.global]
 iobuf_pool=0x1f0d970 #The memory pool for iobufs
@@ -105,7 +114,7 @@ iobuf_pool.arena_cnt=8 #Total number of arenas in the pool
 iobuf_pool.request_misses=0 #The number of iobufs that were stdalloc'd (as they exceeded the default max page size provided by iobuf_pool).
 ```
 
-There are 3 lists of arenas
+There are 3 lists of arenas:
 
 1. Arena list: arenas allocated during iobuf pool creation and the arenas that are in use(active_cnt != 0) will be part of this list.
 2. Purge list: arenas that can be purged(no active iobufs, active_cnt == 0).
@@ -142,7 +151,7 @@ arena.6.active_iobuf.2.ptr=0x7fdb92189000
 
 At any given point in time if there are lots of filled arenas then that could be a sign of iobuf leaks.
 
-###Call stack
+### Call stack
 All the fops received by gluster are handled using call-stacks. Call stack contains the information about uid/gid/pid etc of the process that is executing the fop. Each call-stack contains different call-frames per xlator which handles that fop.
 
 ```
@@ -157,7 +166,7 @@ op=LOOKUP #Fop
 type=1 #Type of the op i.e. FOP/MGMT-OP
 cnt=9 #Number of frames in this stack.
 ```
-###Call-frame
+### Call-frame
 Each frame will have information about which xlator the frame belongs to, what is the function it wound to/from and will be unwind to. It also mentions if the unwind happened or not. If we observe hangs in the system and want to find out which xlator is causing it. Take a statedump and see what is the final xlator which is yet to be unwound.
 
 ```
@@ -172,7 +181,7 @@ wind_to=priv->children[i]->fops->lookup
 unwind_to=afr_lookup_cbk #Parent xlator function to which unwind happened
 ```
 
-###History of operations in Fuse
+### History of operations in Fuse
 
 Fuse maintains history of operations that happened in fuse.
 
@@ -188,7 +197,7 @@ TIME=2014-07-09 16:44:57.523394
 message=[0] fuse_getattr_resume: 4591, STAT, path: (/iozone.tmp), gfid: (3afb4968-5100-478d-91e9-76264e634c9f)
 ```
 
-###Xlator configuration
+### Xlator configuration
 ```
 [cluster/replicate.r2-replicate-0] #Xlator type, name information
 child_count=2 #Number of children to the xlator
@@ -208,7 +217,7 @@ favorite_child=-1
 wait_count=1
 ```
 
-###Graph/inode table
+### Graph/inode table
 ```
 [active graph - 1]
 
@@ -220,7 +229,7 @@ conn.1.bound_xl./data/brick01a/homegfs.lru_size=183 #Number of inodes present in
 conn.1.bound_xl./data/brick01a/homegfs.purge_size=0 #Number of inodes present in purge list
 ```
 
-###Inode
+### Inode
 ```
 [conn.1.bound_xl./data/brick01a/homegfs.active.324] #324th inode in active inode list
 gfid=e6d337cf-97eb-44b3-9492-379ba3f6ad42 #Gfid of the inode
@@ -239,7 +248,7 @@ ia_type=2
 Ref by xl:.fuse=1
 Ref by xl:.patchy-client-0=-1
 ```
-###Inode context
+### Inode context
 For each inode per xlator some context could be stored. This context can also be printed in the statedump. Here is the inode ctx of locks xlator
 ```
 [xlator.features.locks.homegfs-locks.inode]
@@ -256,12 +265,12 @@ lock-dump.domain.domain=homegfs-replicate-0 #Domain name where entry/data operat
 inodelk.inodelk[0](ACTIVE)=type=WRITE, whence=0, start=11141120, len=131072, pid = 18446744073709551615, owner=080b1ada117f0000, client=0xb7fc30, connection-id=compute-30-029.com-3505-2014/06/29-14:46:12:477358-homegfs-client-0-0-1, granted at Sun Jun 29 11:10:36 2014 #Active lock information
 ```
 
-##FAQ
-###How to debug Memory leaks using statedump?
+## FAQ
+### How to debug Memory leaks using statedump?
 
-####Using memory accounting feature:
+#### Using memory accounting feature:
 
-`https://bugzilla.redhat.com/show_bug.cgi?id=1120151` is one of the bugs which was debugged using statedump to see which data-structure is leaking. Here is the process used to find what the leak is using statedump. According to the bug the observation is that the process memory usage is increasing whenever one of the bricks is wiped in a replicate volume and a `full` self-heal is invoked to heal the contents. Statedump of the process is taken using kill -USR1 `<pid-of-gluster-self-heal-daemon>`.
+[Bug 1120151](https://bugzilla.redhat.com/show_bug.cgi?id=1120151) is one of the bugs which was debugged using statedump to see which data-structure is leaking. Here is the process used to find what the leak is using statedump. According to the bug the observation is that the process memory usage is increasing whenever one of the bricks is wiped in a replicate volume and a `full` self-heal is invoked to heal the contents. Statedump of the process is taken using `kill -USR1 <pid-of-gluster-self-heal-daemon>`.
 ```
 grep -w num_allocs glusterdump.5225.dump.1405493251
 num_allocs=77078
@@ -284,10 +293,10 @@ grep of the statedump revealed too many allocations for the following data-types
 3. gf_common_mt_mem_pool.
 
 After checking afr-code for allocations with tag `gf_common_mt_char` found `data-self-heal` code path does not free one such allocated memory. `gf_common_mt_mem_pool` suggests that there is a leak in pool memory. `replicate-0:dict_t`, `glusterfs:data_t` and `glusterfs:data_pair_t` pools are using lot of memory, i.e. cold_count is `0` and too many allocations. Checking source code of dict.c revealed that `key` in `dict` is allocated with `gf_common_mt_char` i.e. `2.` tag and value is created using gf_asprintf which in-turn uses `gf_common_mt_asprintf` i.e. `1.`. Browsing the code for leak in self-heal code paths lead to a line which over-writes a variable with new dictionary even when it was already holding a reference to another dictionary. After fixing these leaks, ran the same test to verify that none of the `num_allocs` are increasing even after healing 10,000 files directory hierarchy in statedump of self-heal daemon.
-Please check http://review.gluster.org/8316 for more info about patch/code.
+Please check this [patch](http://review.gluster.org/8316) for more info about the fix.
 
-####Debugging leaks in memory pools:
-Statedump output of memory pools was used to test and verify the fixes to https://bugzilla.redhat.com/show_bug.cgi?id=1134221. On code analysis, dict_t objects were found to be leaking (in terms of not being unref'd enough number of times, during name self-heal. The test involved creating 100 files on plain replicate volume, removing them from one of the bricks's backend, and then triggering lookup on them from the mount point. Statedump of the mount process was taken before executing the test case and after it, after compiling glusterfs with -DDEBUG flags (to have cold count set to 0 by default).
+#### Debugging leaks in memory pools:
+Statedump output of memory pools was used to test and verify the fixes to [Bug 1134221](https://bugzilla.redhat.com/show_bug.cgi?id=1134221). On code analysis, dict_t objects were found to be leaking (in terms of not being unref'd enough number of times, during name self-heal. The test involved creating 100 files on plain replicate volume, removing them from one of the brick's backend, and then triggering lookup on them from the mount point. Statedump of the mount process was taken before executing the test case and after it, after compiling glusterfs with -DDEBUG flags (to have cold count set to 0 by default).
 
 Statedump output of the fuse mount process before the test case was executed:
 
@@ -319,7 +328,7 @@ cur-stdalloc=214
 max-stdalloc=220
 
 ```
-Here, with cold count being 0 by default, cur-stdalloc indicated the number of dict_t objects that were allocated in heap using mem_get(), and yet to be freed using mem_put() (refer to https://github.com/gluster/glusterfs/blob/master/doc/data-structures/mem-pool.md for more details on how mempool works). After the test case (name selfheal of 100 files), there was a rise in the cur-stdalloc value (from 14 to 214) for dict_t.
+Here, with cold count being 0 by default, `cur-stdalloc` indicated the number of `dict_t` objects that were allocated in heap using `mem_get()`, and yet to be freed using `mem_put()` (refer to this [page](../developer-guide/datastructure-mem-pool.md) for more details on how mempool works). After the test case (name selfheal of 100 files), there was a rise in the cur-stdalloc value (from 14 to 214) for `dict_t`.
 
 After these leaks were fixed, glusterfs was again compiled with -DDEBUG flags, and the same steps were performed again and statedump was taken before and after executing the test case, of the mount. This was done to ascertain the validity of the fix. And the following are the results:
 
@@ -353,8 +362,8 @@ max-stdalloc=119
 ```
 The value of cur-stdalloc remained 14 before and after the test, indicating that the fix indeed does what it's supposed to do.
 
-###How to debug hangs because of frame-loss?
-`https://bugzilla.redhat.com/show_bug.cgi?id=994959` is one of the bugs where statedump was helpful in finding where the frame was lost. Here is the process used to find where the hang is using statedump.
+### How to debug hangs because of frame-loss?
+[Bug 994959](https://bugzilla.redhat.com/show_bug.cgi?id=994959) is one of the bugs where statedump was helpful in finding where the frame was lost. Here is the process used to find where the hang is using statedump.
 When the hang was observed, statedumps are taken for all the processes. On mount's statedump the following stack is shown:
 ```
 [global.callpool.stack.1.frame.1]
@@ -402,4 +411,4 @@ unwind_to=qr_readdirp_cbk
 ```
 `unwind_to` shows that call was unwound to `afr_readdirp_cbk` from client xlator.
 Inspecting that function revealed that afr is not unwinding the stack when fop failed.
-Check http://review.gluster.org/5531 for more info about patch/code changes.
+Check this [patch](http://review.gluster.org/5531) for more info about the fix.
diff --git a/doc/developer-guide/Language-Bindings.md b/doc/developer-guide/Language-Bindings.md
index 89ef6df3d78..951f5fae2f6 100644
--- a/doc/developer-guide/Language-Bindings.md
+++ b/doc/developer-guide/Language-Bindings.md
@@ -1,10 +1,11 @@
+# Language Bindings
 GlusterFS 3.4 introduced the libgfapi client API for C programs. This
 page lists bindings to the libgfapi C library from other languages.
 
 Go
 --
 
--   [gogfapi](https://forge.gluster.org/gogfapi) - Go language bindings
+-   [gogfapi](https://github.com/gluster/gogfapi) - Go language bindings
     for libgfapi, aiming to provide an api consistent with the default
     Go file apis.
 
@@ -37,3 +38,8 @@ Rust
 -   [gfapi-sys](https://github.com/cholcombe973/Gfapi-sys) - Libgfapi
     bindings for Rust using FFI
 
+Perl
+----
+
+-   [libgfapi-perl](https://github.com/gluster/libgfapi-perl) - Libgfapi
+    bindings for Perl using FFI
diff --git a/doc/developer-guide/Developers-Index.md b/doc/developer-guide/README.md
index 4c6346e83d4..aaf9c7476b0 100644
--- a/doc/developer-guide/Developers-Index.md
+++ b/doc/developer-guide/README.md
@@ -18,11 +18,9 @@ code check-in.
     the GPL v2 and the LGPL v3 or later
 -   [GlusterFS Coding Standards](./coding-standard.md)
 
-Developing
-----------
+-   If you are not sure of where to start, and what to do, we have a small
+    write-up on what you can pick. [Check it out](./options-to-contribute.md)
 
--   [Language Bindings](./Language Bindings.md) - Connect to
-    GlusterFS using various language bindings
 
 Adding File operations
 ----------------------
@@ -53,20 +51,29 @@ Daemon Management Framework
 Translators
 -----------
 
--   [Block Device Tanslator](./bd-xlator.md)
 -   [Performance/write-Behind Translator](./write-behind.md)
 -   [Translator Development](./translator-development.md)
 -   [Storage/posix Translator](./posix.md)
--   [Compression translator](./network_compression.md)
+
+
+Brick multiplex
+---------------
+
+-   [Brick mux resource reduction](./brickmux-thread-reduction.md)
+
+Fuse
+----
+
+-   [Interrupt handling](./fuse-interrupt.md)
 
 Testing/Debugging
 -----------------
 
 -   [Unit Tests in GlusterFS](./unittest.md)
 -   [Using the Gluster Test
-    Framework](./Using Gluster Test Framework.md) - Step by
+    Framework](./Using-Gluster-Test-Framework.md) - Step by
     step instructions for running the Gluster Test Framework
--   [Coredump Analysis](./coredump-analysis.md) - Steps to analize coredumps generated by regression machines.
+-   [Coredump Analysis](../debugging/analyzing-regression-cores.md) - Steps to analize coredumps generated by regression machines.
 -   [Identifying Resource Leaks](./identifying-resource-leaks.md)
 
 Release Process
diff --git a/doc/developer-guide/Using-Gluster-Test-Framework.md b/doc/developer-guide/Using-Gluster-Test-Framework.md
index 96fa9247e84..d2bb1c391da 100644
--- a/doc/developer-guide/Using-Gluster-Test-Framework.md
+++ b/doc/developer-guide/Using-Gluster-Test-Framework.md
@@ -1,3 +1,4 @@
+# USing Gluster Test Framwork
 Description
 -----------
 
diff --git a/doc/developer-guide/afr-locks-evolution.md b/doc/developer-guide/afr-locks-evolution.md
index 7d2a136d871..2dabbcfeb13 100644
--- a/doc/developer-guide/afr-locks-evolution.md
+++ b/doc/developer-guide/afr-locks-evolution.md
@@ -32,10 +32,10 @@ AFR makes use of locks xlator extensively:
 * For Entry self-heal, it is `entrylk(NULL name, parent inode)`. Specifying NULL for the name takes full lock on the directory referred to by the inode.
 * For data self-heal, there is a bit of history as to how locks evolved:
 
-###Initial version (say version 1) :
+### Initial version (say version 1) :
 There was no concept of selfheal daemon (shd). Only client lookups triggered heals. so AFR always took `inodelk(0,0,DATA_DOMAIN)` for healing. The issue with this approach was that when heal was in progress, I/O from clients was blocked .
 
-###version 2:
+### version 2:
 shd was introduced. We needed to allow I/O to go through when heal was going,provided the ranges did not overlap. To that extent, the following approach was adopted:
 
 + 1.shd takes (full inodelk in DATA_DOMAIN). Thus client FOPS are blocked and cannot modify changelog-xattrs
@@ -79,7 +79,7 @@ It modifies data but the FOP succeeds only on brick 2. writev returns success, a
 and thus goes ahead and copies stale 128Kb from brick 1 to brick2. Thus as far as application is concerned, `writev` returned success but bricks have stale data.
 What needs to be done is `writev` must return success only if it succeeded on atleast one source brick (brick b1 in this case). Otherwise  The heal still happens in reverse direction but as far as the application is concerned, it received an error.  
 
-###Note on lock **domains**
+### Note on lock **domains**
 We have used conceptual names in this document like DATA_DOMAIN/ METADATA_DOMAIN/ SELF_HEAL_DOMAIN. In the code, these are mapped to strings that are based on the AFR xlator name like so:
 
 DATA_DOMAIN     --->"vol_name-replicate-n"
diff --git a/doc/developer-guide/afr-self-heal-daemon.md b/doc/developer-guide/afr-self-heal-daemon.md
index b85ddd1c856..65940d420b7 100644
--- a/doc/developer-guide/afr-self-heal-daemon.md
+++ b/doc/developer-guide/afr-self-heal-daemon.md
@@ -39,7 +39,7 @@ When a client (mount) performs an operation on the file, the index xlator presen
 and removes it in post-op phase if the operation is successful. Thus if an entry is present inside the .glusterfs/indices/xattrop/ directory when there is no I/O 
 happening on the file, it means the file needs healing (or atleast an examination if the brick crashed after the post-op completed but just before the removal of the hardlink).
 
-####Index heal steps:
+#### Index heal steps:
 <pre><code>
 In shd process of *each node* {
         opendir +readdir (.glusterfs/indices/xattrop/)
diff --git a/doc/developer-guide/bd-xlator.md b/doc/developer-guide/bd-xlator.md
deleted file mode 100644
index 1771fb6e24b..00000000000
--- a/doc/developer-guide/bd-xlator.md
+++ /dev/null
@@ -1,469 +0,0 @@
-#Block device translator
-
-Block device translator (BD xlator) is a translator added to GlusterFS  which provides block backend for GlusterFS. This replaces the existing bd_map translator in GlusterFS that provided similar but very limited functionality. GlusterFS expects the underlying brick to be formatted with a POSIX compatible file system. BD xlator changes that and allows for having bricks that are raw block devices like LVM which needn’t have any file systems on them. Hence with BD xlator, it becomes possible to build a GlusterFS volume comprising of bricks that are logical volumes (LV).
-
-##bd
-
-BD xlator maps underlying LVs to files and hence the LVs appear as files to GlusterFS clients. Though BD volume externally appears very similar to the usual Posix volume, not all operations are supported or possible for the files on a BD volume. Only those operations that make sense for a block device are supported and the exact semantics are described in subsequent sections.
-
-While Posix volume takes a file system directory as brick, BD volume needs a volume group (VG) as brick. In the usual use case of BD volume, a file created on BD volume will result in an LV being created in the brick VG. In addition to a VG, BD volume also needs a file system directory that should be specified at the volume creation time. This directory is necessary for supporting the notion of directories and directory hierarchy for the BD volume. Metadata about LVs (size, mapping info) is stored in this directory.
-
-BD xlator was mainly developed to use block devices directly as VM images when GlusterFS is used as storage for KVM virtualization. Some of the salient points of BD xlator are
-
-* Since BD supports file level snapshots and clones by leveraging the snapshot and clone capabilities of LVM, it can be used to fully off-load snapshot and cloning operations from QEMU to the storage (GlusterFS) itself.
-
-* BD understands dm-thin LVs and hence can support files that are backed by thinly provisioned LVs. This capability of BD xlator translates to having thinly provisioned raw VM images.
-
-* BD enables thin LVs from a thin pool to be used from multiple nodes that have visibility to GlusterFS BD volume. Thus thin pool can be used as a VM image repository allowing access/visibility to it from multiple nodes.
-
-* BD supports true zerofill by using BLKZEROOUT ioctl on underlying block devices. Thus BD allows SCSI WRITESAME to be used on underlying block device if the device supports it.
-
-Though BD xlator is primarily intended to be used with block devices, it does provide full Posix xlator compatibility for files that are created on BD volume but are not backed by or mapped to a block device. Such files which don’t have a block device mapping exist on the Posix directory that is specified during BD volume creation. BD xlator is available from GlusterFS-3.5 release.
-
-###Compiling BD translator
-
-BD xlator needs lvm2 development library. –enable-bd-xlator option can be used with `./configure` script to explicitly enable BD translator. The following snippet from the output of configure script shows that BD xlator is enabled for compilation.
-
-
-#####GlusterFS configure summary
-
- …
- Block Device xlator  : yes
-
-
-###Creating a BD volume
-
-BD supports hosting of both linear LV and thin LV within the same volume. However seperate examples are provided below. As noted above, the prerequisite for a BD volume is VG which is created from a loop device here, but it can be any other device too.
-
-
-* Creating BD volume with linear LV backend
-
-* Create a loop device
-
-
-    [root@node ~]# dd if=/dev/zero of=bd-loop count=1024 bs=1M
-
-    [root@node ~]# losetup /dev/loop0 bd-loop
-
-
-* Prepare a brick by creating a VG
-
-    [root@node ~]# pvcreate /dev/loop0
-
-    [root@node ~]# vgcreate bd-vg /dev/loop0
-
-
-* Create the BD volume
-
-* Create a POSIX directory first
-
-
-    [root@node ~]# mkdir /bd-meta
-
-It is recommended that this directory is created on an LV in the brick VG itself so that both data and metadata live together on the same device.
-
-
-* Create and mount the volume
-
-    [root@node ~]# gluster volume create bd node:/bd-meta?bd-vg force
-
-
-The general syntax for specifying the brick is `host:/posix-dir?volume-group-name` where “?” is the separator.
-
-
-
-    [root@node ~]# gluster volume start bd
-    [root@node ~]# gluster volume info bd
-    Volume Name: bd
-    Type: Distribute
-    Volume ID: cb042d2a-f435-4669-b886-55f5927a4d7f
-    Status: Started
-    Xlator 1: BD
-    Capability 1: offload_copy
-    Capability 2: offload_snapshot
-    Number of Bricks: 1
-    Transport-type: tcp
-    Bricks:
-    Brick1: node:/bd-meta
-    Brick1 VG: bd-vg
-
-
-
-    [root@node ~]# mount -t glusterfs node:/bd /mnt
-
-* Create a file that is backed by an LV
-
-    [root@node ~]# ls /mnt
-
-    [root@node ~]#
-
-Since the volume is empty now, so is the underlying VG.
-
-    [root@node ~]# lvdisplay bd-vg
-    [root@node ~]#
-
-Creating a file that is mapped to an LV is a 2 step operation. First the file should be created on the mount point and a specific extended attribute should be set to map the file to LV.
-
-    [root@node ~]# touch /mnt/lv
-    [root@node ~]# setfattr -n “user.glusterfs.bd” -v “lv” /mnt/lv
-
-Now an LV got created in the VG brick and the file /mnt/lv maps to this LV. Any read/write to this file ends up as read/write to the underlying LV.
-
-    [root@node ~]# lvdisplay bd-vg
-    — Logical volume —
-    LV Path                 /dev/bd-vg/6ff0f25f-2776-4d19-adfb-df1a3cab8287
-    LV Name                 6ff0f25f-2776-4d19-adfb-df1a3cab8287
-    VG Name                 bd-vg
-    LV UUID                 PjMPcc-RkD5-RADz-6ixG-UYsk-oclz-vL0nv6
-    LV Write Access         read/write
-    LV Creation host, time node, 2013-11-26 16:15:45 +0530
-    LV Status               available
-    open                    0
-    LV Size                 4.00 MiB
-    Current LE              1
-    Segments                1
-    Allocation              inherit
-    Read ahead sectors      0
-    Block device            253:6
-
-The file gets created with default LV size which is 1 LE which is 4MB in this case.
-
-    [root@node ~]# ls -lh /mnt/lv
-    -rw-r–r–. 1 root root 4.0M Nov 26 16:15 /mnt/lv
-
-truncate can be used to set the required file size.
-
-    [root@node ~]# truncate /mnt/lv -s 256M
-    [root@node ~]# lvdisplay bd-vg
-    — Logical volume —
-    LV Path               /dev/bd-vg/6ff0f25f-2776-4d19-adfb-df1a3cab8287
-    LV Name               6ff0f25f-2776-4d19-adfb-df1a3cab8287
-    VG Name               bd-vg
-    LV UUID               PjMPcc-RkD5-RADz-6ixG-UYsk-oclz-vL0nv6
-    LV Write Access       read/write
-    LV Creation host, time node, 2013-11-26 16:15:45 +0530
-    LV Status             available
-    # open                   0
-    LV Size               256.00 MiB
-    Current LE             64
-    Segments                1
-    Allocation            inherit
-    Read ahead sectors     0
-    Block device          253:6
-
-
-    [root@node ~]# ls -lh /mnt/lv
-    -rw-r–r–. 1 root root 256M Nov 26 16:15 /mnt/lv
-
-    currently LV size has been set to        256
-
-The size of the file/LV can be specified during creation/mapping time itself like this:
-
-    setfattr -n “user.glusterfs.bd” -v “lv:256MB” /mnt/lv
-
-2. Creating BD volume with thin LV backend
-
-* Create a loop device
-
-
-    [root@node ~]# dd if=/dev/zero of=bd-loop-thin count=1024 bs=1M
-
-    [root@node ~]# losetup /dev/loop0 bd-loop-thin
-
-
-* Prepare a brick by creating a VG and thin pool
-
-
-    [root@node ~]# pvcreate /dev/loop0
-
-    [root@node ~]# vgcreate bd-vg-thin /dev/loop0
-
-
-* Create a thin pool
-
-
-    [root@node ~]# lvcreate –thin bd-vg-thin -L 1000M
-
-    Rounding up size to full physical extent 4.00 MiB
-    Logical volume “lvol0″ created
-
-lvdisplay shows the thin pool
-
-    [root@node ~]# lvdisplay bd-vg-thin
-    — Logical volume —
-    LV Name                      lvol0
-    VG Name                      bd-vg-thin
-    LV UUID                      HVa3EM-IVMS-QG2g-oqU6-1UxC-RgqS-g8zhVn
-    LV Write Access              read/write
-    LV Creation host, time node, 2013-11-26 16:39:06 +0530
-    LV Pool transaction ID       0
-    LV Pool metadata             lvol0_tmeta
-    LV Pool data                 lvol0_tdata
-    LV Pool chunk size           64.00 KiB
-    LV Zero new blocks           yes
-    LV Status                    available
-    # open                       0
-    LV Size                      1000.00 MiB
-    Allocated pool data          0.00%
-    Allocated metadata           0.88%
-    Current LE                   250
-    Segments                     1
-    Allocation                     inherit
-    Read ahead sectors     auto
-    Block device                253:9
-
-* Create the BD volume
-
-* Create a POSIX directory first
-
-
-    [root@node ~]# mkdir /bd-meta-thin
-
-* Create and mount the volume
-
-    [root@node ~]# gluster volume create bd-thin node:/bd-meta-thin?bd-vg-thin force
-
-    [root@node ~]# gluster volume start bd-thin
-
-
-    [root@node ~]# gluster volume info bd-thin
-    Volume Name: bd-thin
-    Type: Distribute
-    Volume ID: 27aa7eb0-4ffa-497e-b639-7cbda0128793
-    Status: Started
-    Xlator 1: BD
-    Capability 1: thin
-    Capability 2: offload_copy
-    Capability 3: offload_snapshot
-    Number of Bricks: 1
-    Transport-type: tcp
-    Bricks:
-    Brick1: node:/bd-meta-thin
-    Brick1 VG: bd-vg-thin
-
-
-    [root@node ~]# mount -t glusterfs node:/bd-thin /mnt
-
-* Create a file that is backed by a thin LV
-
-
-    [root@node ~]# ls /mnt
-
-    [root@node ~]#
-
-Creating a file that is mapped to a thin LV is a 2 step operation. First the file should be created on the mount point and a specific extended attribute should be set to map the file to a thin LV.
-
-    [root@node ~]# touch /mnt/thin-lv
- 
-    [root@node ~]# setfattr -n “user.glusterfs.bd” -v “thin:256MB” /mnt/thin-lv
-
-Now /mnt/thin-lv is a thin provisioned file that is backed by a thin LV and size has been set to 256.
-
-    [root@node ~]# lvdisplay bd-vg-thin
-    — Logical volume —
-    LV Name             lvol0
-    VG Name             bd-vg-thin
-    LV UUID             HVa3EM-IVMS-QG2g-oqU6-1UxC-RgqS-g8zhVn
-    LV Write Access     read/write
-    LV Creation host, time node, 2013-11-26 16:39:06 +0530
-    LV Pool transaction ID 1
-    LV Pool metadata    lvol0_tmeta
-    LV Pool data        lvol0_tdata
-    LV Pool chunk size  64.00 KiB
-    LV Zero new blocks  yes
-    LV Status           available
-    # open               0
-    LV Size             000.00 MiB
-    Allocated pool data 0.00%
-    Allocated metadata  0.98%
-    Current LE          250
-    Segments            1
-    Allocation          inherit
-    Read ahead sectors  auto
-    Block device         253:9
-
-
-
-
-    — Logical volume —
-    LV Path             dev/bd-vg-thin/081b01d1-1436-4306-9baf-41c7bf5a2c73
-    LV Name             081b01d1-1436-4306-9baf-41c7bf5a2c73
-    VG Name             bd-vg-thin
-    LV UUID             coxpTY-2UZl-9293-8H2X-eAZn-wSp6-csZIeB
-    LV Write Access     read/write
-    LV Creation host, time node, 2013-11-26 16:43:19 +0530
-    LV Pool name        lvol0
-    LV Status           available
-    # open               0
-    LV Size             256.00 MiB
-    Mapped size          0.00%
-    Current LE           64
-    Segments             1
-    Allocation          inherit
-    Read ahead sectors   auto
-    Block device                 253:10
-
-
-
-
-
-As can be seen from above, creation of a file resulted in creation of a thin LV in the brick.
-
-
-###Improvisation on BD translator:
-
-First version of BD xlator  ( block backend) had few limitations  such as
-
-* Creation of directories not supported
-* Supports only single brick
-* Does not use extended attributes (and client gfid) like posix xlator
-* Creation of special files (symbolic links, device nodes etc) not
-  supported
-
-Basic limitation of not allowing directory creation was blocking
-oVirt/VDSM to consume BD xlator as part of Gluster domain since VDSM
-creates multi-level directories when GlusterFS is used as storage
-backend for storing VM images.
-
-To overcome these limitations a new BD xlator with following
-improvements are implemented.
-
-* New hybrid BD xlator that handles both regular files and block device
-  files
-* The volume will have both POSIX and BD bricks. Regular files are
-  created on POSIX bricks, block devices are created on the BD brick (VG)
-* BD xlator leverages exiting POSIX xlator for most POSIX calls and
-  hence sits above the POSIX xlator
-* Block device file is differentiated from regular file by an extended
-  attribute
-* The xattr 'user.glusterfs.bd' (BD_XATTR) plays a role in mapping a
-  posix file to Logical Volume (LV).
-* When a client sends a request to set BD_XATTR on a posix file, a new
-  LV is created and mapped to posix file. So every block device will
-  have a representative file in POSIX brick with 'user.glusterfs.bd'
-  (BD_XATTR) set.
-* Here after all operations on this file results in LV related
-  operations.
-
-For example, opening a file that has BD_XATTR set results in opening
-the LV block device, reading results in reading the corresponding LV
-block device.
-
-When BD xlator gets request to set BD_XATTR via setxattr call, it
-creates a LV and information about this LV is placed in the xattr of the
-posix file. xattr "user.glusterfs.bd" used to identify that posix file
-is mapped to BD.
-
-Usage:
-Server side:
-
-    [root@host1 ~]# gluster volume create bdvol host1:/storage/vg1_info?vg1 host2:/storage/vg2_info?vg2
-
-It creates a distributed gluster volume 'bdvol' with Volume Group vg1
-using posix brick /storage/vg1_info in host1 and Volume Group vg2 using
-/storage/vg2_info in host2.
-
-
-    [root@host1 ~]# gluster volume start bdvol
-
-Client side:
-
-    [root@node ~]# mount -t glusterfs host1:/bdvol /media
-    [root@node ~]# touch /media/posix
-
-It creates regular posix file 'posix' in either host1:/vg1 or host2:/vg2 brick
-
-    [root@node ~]# mkdir /media/image
-
-    [root@node ~]# touch /media/image/lv1
-
-
-It also creates regular posix file 'lv1' in either host1:/vg1 or
-host2:/vg2 brick
-
-    [root@node ~]# setfattr -n "user.glusterfs.bd" -v "lv" /media/image/lv1
-
-    [root@node ~]#
-
-
-Above setxattr results in creating a new LV in corresponding brick's VG
-and it sets 'user.glusterfs.bd' with value 'lv:<default-extent-size''
-
-
-    [root@node ~]# truncate -s5G /media/image/lv1
-
-
-It results in resizig LV 'lv1'to 5G
-
-New BD xlator code is placed in `xlators/storage/bd` directory.
-
-Also add volume-uuid to the VG so that same VG cannot be used for other
-bricks/volumes. After deleting a gluster volume, one has to manually
-remove the associated tag using vgchange <vg-name> --deltag
-`<trusted.glusterfs.volume-id:<volume-id>>`
-
-
-#### Exposing volume capabilities
-
-With multiple storage translators (posix and bd) being supported in GlusterFS, it becomes
-necessary to know the volume type so that user can issue appropriate calls that are relevant
-only to the a given volume type. Hence there needs to be a way to expose the type of
-the storage translator of the volume to the user.
-
-BD xlator is capable of providing server offloaded file copy, server/storage offloaded
-zeroing of a file etc. This capabilities should be visible to the client/user, so that these
-features can be exploited.
-
-BD xlator exports capability information through gluster volume info (and --xml) output. For eg:
-
-`snip of gluster volume info output for a BD based volume`
-
-        Xlator 1: BD
-        Capability 1: thin
-
-`snip of gluster volume info --xml output for a BD based volume`
-
-        <xlators>
-          <xlator>
-                <name>BD</name>
-                <capabilities>
-                        <capability>thin</capability>
-                </capabilities>
-          </xlator>
-        </xlators>
-
-But this capability information should also exposed through some other means so that a host
-which is not part of Gluster peer could also avail this capabilities.
-
-* Type
-
-BD translator supports both regular files and block device, i,e., one can create files on
-GlusterFS volume backed by BD translator and this file could end up as regular posix file or
-a logical volume (block device) based on the user''s choice. User can do a setxattr on the
-created file to convert it to a logical volume.
-
-Users of BD backed volume like QEMU would like to know that it is working with BD type of volume
-so that it can issue an additional setxattr call after creating a VM image on GlusterFS backend.
-This is necessary to ensure that the created VM image is backed by LV instead of file.
-
-There are different ways to expose this information (BD type of volume) to user.
-One way is to export it via a `getxattr` call. That said, When a client issues getxattr("volume_type")
-on a root gfid, bd xlator will return 1 implying its BD xlator. But posix xlator will return ENODATA
-and client code can interpret this as posix xlator. Also capability list can be returned via
-getxattr("caps") for root gfid.
-
-* Capabilities
-
-BD xlator supports new features such as server offloaded file copy, thin provisioned VM images etc.
-
-There is no standard way of exploiting these features from client side (such as syscall
-to exploit server offloaded copy). So these features need to be exported to the client so that
-they can be used. BD xlator latest version exports these capabilities information through
-gluster volume info (and --xml) output. But if a client is not part of GlusterFS peer
-it can''t run volume info command to get the list of capabilities of a given GlusterFS volume.
-For example, GlusterFS block driver in qemu need to get the capability list so that these features are used.
-
-
-
-Parts of this documentation were originally published here
-#http://raobharata.wordpress.com/2013/11/27/glusterfs-block-device-translator/
diff --git a/doc/developer-guide/brickmux-thread-reduction.md b/doc/developer-guide/brickmux-thread-reduction.md
new file mode 100644
index 00000000000..7d76e8ff579
--- /dev/null
+++ b/doc/developer-guide/brickmux-thread-reduction.md
@@ -0,0 +1,64 @@
+# Resource usage reduction in brick multiplexing
+
+Each brick is regresented with a graph of translators in a brick process.
+Each translator in the graph has its own set of threads and mem pools
+and other system resources allocations. Most of the times all these
+resources are not put to full use. Reducing the resource consumption
+of each brick is a problem in itself that needs to be addressed. The other
+aspect to it is, sharing of resources across brick graph, this becomes
+critical in brick multiplexing scenario. In this document we will be discussing
+only about the threads.
+
+If a brick mux process hosts 50 bricks there are atleast 600+ threads created
+in that process. Some of these are global threads that are shared by all the
+brick graphs, and others are per translator threads. The global threads like
+synctask threads, timer threads, sigwaiter, poller etc. are configurable and
+do not needs to be reduced. The per translator threads keeps growing as the
+number of bricks in the process increases. Each brick spawns atleast 10+
+threads:
+- io-threads
+- posix threads:
+     1. Janitor
+     2. Fsyncer
+     3. Helper
+     4. aio-thread
+- changelog and bitrot threads(even when the features are not enabled)
+
+## io-threads
+
+io-threads should be made global to the process, having 16+ threads for
+each brick does not make sense. But io-thread translator is loaded in
+the graph, and the position of io-thread translator decides from when
+the fops will be parallelised across threads. We cannot entirely move
+the io-threads to libglusterfs and say the multiplexing happens from
+the master translator or so. Hence, the io-thread orchestrator code
+is moved to libglusterfs, which ensures there is only one set of
+io-threads that is shared among the io-threads translator in each brick.
+This poses performance issues due to lock-contention in the io-threds
+layer. This also shall be addressed by having multiple locks instead of
+one global lock for io-threads.
+
+## Posix threads
+Most of the posix threads execute tasks in a timely manner, hence it can be
+replaced with a timer whose handler register a task to synctask framework, once
+the task is complete, the timer is registered again. With this we can eliminate
+the need of one thread for each task. The problem with using synctasks is
+the performance impact it will have due to make/swapcontext. For task that
+does not involve network wait, we need not do makecontext, instead the task
+function with arg can be stored and executed when a synctask thread is free.
+We need to implement an api in synctask to execute atomic tasks(no network wait)
+without the overhead of make/swapcontext. This will solve the performance
+impact associated with using synctask framework.
+
+And the other challenge, is to cancel all the tasks pending from a translator.
+This is important to cleanly detach brick. For this, we need to implement an
+api in synctask that can cancel all the tasks from a given translator.
+
+For future, this will be replced to use global thread-pool(once implemented).
+
+## Changelog and bitrot threads
+
+In the initial implementation, the threads are not created if the feature is
+not enabled. We need to share threads across changelog instances if we plan
+to enable these features in brick mux scenario.
+
diff --git a/doc/developer-guide/coding-standard.md b/doc/developer-guide/coding-standard.md
index 368c5553464..031c6c0da99 100644
--- a/doc/developer-guide/coding-standard.md
+++ b/doc/developer-guide/coding-standard.md
@@ -1,11 +1,38 @@
 GlusterFS Coding Standards
 ==========================
 
+Before you get started
+----------------------
+Before starting with other part of coding standard, install `clang-format`
+
+On Fedora:
+```
+$ dnf install clang
+```
+On debian/Ubuntu:
+```
+$ apt-get install clang
+```
+Once you are done with all the local changes, you need to run below set of commands,
+before submitting the patch for review.
+```
+$ git add $file # if any
+$ git commit -a -s -m "commit message"
+$ git show --pretty="format:" --name-only | grep -v "contrib/" | egrep "*\.[ch]$" | xargs clang-format -i
+$ git diff # see if there are any changes
+$ git commit -a --amend # get the format changes done
+$ ./submit-for-review.sh
+```
+
+
 Structure definitions should have a comment per member
 ------------------------------------------------------
 
-Every member in a structure definition must have a comment about its
-purpose. The comment should be descriptive without being overly verbose.
+Every member in a structure definition must have a comment about its purpose.
+The comment should be descriptive without being overly verbose.  For pointer
+members, lifecycle concerns for the pointed-to object should be noted.  For lock
+members, the relationship between the lock member and the other members it
+protects should be explicit.
 
 *Bad:*
 
@@ -23,59 +50,182 @@ DBTYPE      access_mode;    /* access mode for accessing
                              */
 ```
 
-Declare all variables at the beginning of the function
-------------------------------------------------------
+Structure members should be aligned based on the padding requirements
+---------------------------------------------------------------------
 
-All local variables in a function must be declared immediately after the
-opening brace. This makes it easy to keep track of memory that needs to be freed
-during exit. It also helps debugging, since gdb cannot handle variables
-declared inside loops or other such blocks.
+The compiler will make sure that structure members have optimum alignment,
+but at the expense of suboptimal padding. More important is to optimize the
+padding. The compiler won't do that for you.
 
-Always initialize local variables
----------------------------------
+This also will help utilize the memory better
 
-Every local variable should be initialized to a sensible default value
-at the point of its declaration. All pointers should be initialized to NULL,
-and all integers should be zero or (if it makes sense) an error value.
+*Bad:*
+```
+struct bad {
+    bool  b; /* 0 */
+             /* 1..7 pad */
+    void *p; /* 8..15 */
+    char  c; /* 16 */
+    char  a[16]; /* 17..33 */
+             /* 34..39 pad */
+    int64_t ii; /* 40..47 */
+    int32_t i; /* 48..51 */
+             /* 52..55 pad */
+    int64_t iii; /* 56..63 */
+};
+```
 
+*Good:*
+```
+struct good {
+   int64_t ii; /* explicit 64-bit types */
+   void *p; /* may be 64- or 32-bit */
+   long  l;   /* may be 64- or 32-bit */
+   int   i;   /* 32-bit */
+   short s;   /* 16-bit */
+   char  c;   /* 8-bit */
+   bool  b;   /* 8-bit */
+   char  a[1024];
+);
+```
+Make sure the items with the most stringent alignment requirements will need
+to come earliest (ie, pointers and  perhaps uint64_t etc), and those with less
+stringent alignment requirements at the end (uint16/uint8 and char). Also note
+that the long array (if any) should be at the end of the structure, regardless
+of the type.
+
+Also note, if your structure's overall size is crossing 1k-4k limit, it is
+recommended to mention the reason why the particular structure needs so much
+memory as a comment at the top.
+
+Use \_typename for struct tags and typename\_t for typedefs
+---------------------------------------------------------
+
+Being consistent here makes it possible to automate navigation from use of a
+type to its true definition (not just the typedef).
+
+*Bad:*
+
+```
+struct thing {...};
+struct thing_t {...};
+typedef struct _thing thing;
+```
 
 *Good:*
 
 ```
-int ret       = 0;
-char *databuf = NULL;
-int _fd       = -1;
+typedef struct _thing {...} thing_t;
 ```
 
-Initialization should always be done with a constant value
-----------------------------------------------------------
+No double underscores
+---------------------
+
+Identifiers beginning with double underscores are supposed to reserved for the
+compiler.
 
-Never use a non-constant expression as the initialization value for a variable.
+http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
 
+When you need to define inner/outer functions, use a different prefix/suffix.
 
 *Bad:*
 
 ```
+void __do_something (void);
+
+void
+do_something (void)
+{
+        LOCK ();
+        __do_something ();
+        UNLOCK ();
+}
+```
+
+*Good:*
+
+```
+void do_something_locked (void);
+```
+
+Only use safe pointers in initializers
+----------------------------------------------------------
+
+Some pointers, such as `this` in a fop function, can be assumed to be non-NULL.
+However, other parameters and further-derived values might be NULL.
+
+*Good:*
+
+```
 pid_t pid     = frame->root->pid;
-char *databuf = malloc (1024);
 ```
 
+
+*Bad:*
+
+```
+data_t *my_data = dict_get (xdata, "fubar");
+```
+
+No giant stack allocations
+--------------------------
+
+Synctasks have small finite stacks.  To avoid overflowing these stacks, avoid
+allocating any large data structures on the stack.  Use dynamic allocation
+instead.
+
+*Bad:*
+
+```
+gf_boolean_t port_inuse[65536]; /* 256KB, this actually happened */
+```
+
+NOTE: Ideal is to limit the stack array to less than 256 bytes.
+
+
+Character array initializing
+----------------------------
+
+It is recommended to keep the character array initializing to empty string.
+
+*Good:*
+```
+char msg[1024] = "";
+```
+
+Not so much recommended, even though it means the same.
+
+```
+char msg[1024] = {0,};
+```
+
+We recommend above to structure initialization.
+
+
+
 Validate all arguments to a function
 ------------------------------------
 
 All pointer arguments to a function must be checked for `NULL`.
-A macro named `VALIDATE` (in `common-utils.h`)
-takes one argument, and if it is `NULL`, writes a log message and
-jumps to a label called `err` after setting op_ret and op_errno
-appropriately. It is recommended to use this template.
+A macro named `GF_VALIDATE_OR_GOTO` (in `common-utils.h`)
+takes two arguments; if the first is `NULL`, it writes a log message and
+jumps to a label specified by the second aergument after setting errno
+appropriately. There are several variants of this function for more
+specific purposes, and their use is recommended.
+
+*Bad:*
 
+```
+/* top of function */
+ret = dict_get (xdata, ...)
+```
 
 *Good:*
 
 ```
-VALIDATE(frame);
-VALIDATE(this);
-VALIDATE(inode);
+/* top of function */
+GF_VALIDATE_OR_GOTO(xdata,out);
+ret = dict_get (xdata, ...)
 ```
 
 Never rely on precedence of operators
@@ -83,25 +233,34 @@ Never rely on precedence of operators
 
 Never write code that relies on the precedence of operators to execute
 correctly.  Such code can be hard to read and someone else might not
-know the precedence of operators as accurately as you do.
+know the precedence of operators as accurately as you do.  This includes
+precedence of increment/decrement vs. field/subscript.  The only exceptions are
+arithmetic operators (which have had defined precedence since before computers
+even existed) and boolean negation.
 
 *Bad:*
 
 ```
 if (op_ret == -1 && errno != ENOENT)
+++foo->bar      /* incrementing foo, or incrementing foo->bar? */
+a && b || !c
 ```
 
 *Good:*
 
 ```
 if ((op_ret == -1) && (errno != ENOENT))
+(++foo)->bar
+++(foo->bar)
+(a && b) || !c
+a && (b || !c)
 ```
 
 Use exactly matching types
 --------------------------
 
 Use a variable of the exact type declared in the manual to hold the
-return value of a function. Do not use an ``equivalent'' type.
+return value of a function. Do not use an 'equivalent' type.
 
 
 *Bad:*
@@ -116,42 +275,56 @@ int len = strlen (path);
 size_t len = strlen (path);
 ```
 
-Never write code such as `foo->bar->baz`; check every pointer
+Avoid code such as `foo->bar->baz`; check every pointer
 -------------------------------------------------------------
 
-Do not write code that blindly follows a chain of pointer
-references. Any pointer in the chain may be `NULL` and thus
-cause a crash. Verify that each pointer is non-null before following
-it.
+Do not write code that blindly follows a chain of pointer references. Any
+pointer in the chain may be `NULL` and thus cause a crash. Verify that each
+pointer is non-null before following it.  Even if `foo->bar` has been checked
+and is known safe, repeating it can make code more verbose and less clear.
 
-Check return value of all functions and system calls
+This rule includes `[]` as well as `->` because both dereference pointers.
+
+*Bad:*
+
+```
+foo->bar->field1 = value1;
+xyz = foo->bar->field2 + foo->bar->field3 * foo->bar->field4;
+foo->bar[5].baz
+```
+
+*Good:*
+
+```
+my_bar = foo->bar;
+if (!my_bar) ... return;
+my_bar->field1 = value1;
+xyz = my_bar->field2 + my_bar->field3 * my_bar->field4;
+```
+
+Document unchecked return values
 ----------------------------------------------------
 
-The return value of all system calls and API functions must be checked
-for success or failure.
+In general, return values should be checked.  If a function is being called
+for its side effects and the return value really doesn't matter, an explicit
+cast to void is required (to keep static analyzers happy) and a comment is
+recommended.
 
 *Bad:*
 
 ```
 close (fd);
+do_important_thing ();
 ```
 
-*Good:*
+*Good (or at least OK):*
 
 ```
-op_ret = close (_fd);
-if (op_ret == -1) {
-        gf_log (this->name, GF_LOG_ERROR,
-                "close on file %s failed (%s)", real_path,
-                strerror (errno));
-        op_errno = errno;
-        goto out;
-}
+(void) sleep (1);
 ```
 
-
-Gracefully handle failure of malloc
------------------------------------
+Gracefully handle failure of malloc (and other allocation functions)
+--------------------------------------------------------------------
 
 GlusterFS should never crash or exit due to lack of memory. If a
 memory allocation fails, the call should be unwound and an error
@@ -176,7 +349,7 @@ int32_t dict_get_int32 (dict_t *this, char *key);
 int dict_get_int32 (dict_t *this, char *key, int32_t *val);
 ```
 
-Always use the `n' versions of string functions
+Always use the 'n' versions of string functions
 -----------------------------------------------
 
 Unless impossible, use the length-limited versions of the string functions.
@@ -193,18 +366,43 @@ strcpy (entry_path, real_path);
 strncpy (entry_path, real_path, entry_path_len);
 ```
 
+Do not use memset prior to sprintf/snprintf/vsnprintf etc...
+------------------------------------------------------------
+snprintf(and other similar string functions) terminates the buffer with a
+'\0'(null character). Hence, there is no need to do a memset before using
+snprintf. (Of course you need to account one extra byte for the null character
+in your allocation).
+
+Note: Similarly if you are doing pre-memory allocation for the buffer, use
+GF_MALLOC instead of GF_CALLOC, since the later is bit costlier.
+
+*Bad:*
+
+```
+char buffer[x];
+memset (buffer, 0, x);
+bytes_read = snprintf (buffer, sizeof buffer, "bad standard");
+```
+
+*Good:*
+```
+char buffer[x];
+bytes_read = snprintf (buffer, sizeof (buffer), "good standard");
+```
+
+And it is always to good initialize the char array if the string is static.
+
+E.g.
+```
+char buffer[] = "good standard";
+```
+
 No dead or commented code
 -------------------------
 
 There must be no dead code (code to which control can never be passed) or
 commented out code in the codebase.
 
-Only one unwind and return per function
----------------------------------------
-
-There must be only one exit out of a function. `UNWIND` and return
-should happen at only point in the function.
-
 Function length or Keep functions small
 ---------------------------------------
 
@@ -226,20 +424,35 @@ same_owner (posix_lock_t *l1, posix_lock_t *l2)
 }
 ```
 
-Defining functions as static
-----------------------------
+Define functions as static
+--------------------------
+
+Declare functions as static unless they're exposed via a module-level API for
+use from other modules.
+
+No nested functions
+-------------------
+
+Nested functions have proven unreliable, e.g. as callbacks in code that uses
+ucontext (green) threads,
+
+Use inline functions instead of macros whenever possible
+--------------------------------------------------------
 
-Define internal functions as static only if you're
-very sure that there will not be a crash(..of any kind..) emanating in
-that function. If there is even a remote possibility, perhaps due to
-pointer derefering, etc, declare the function as non-static. This
-ensures that when a crash does happen, the function name shows up the
-in the back-trace generated by libc. However, doing so has potential
-for polluting the function namespace, so to avoid conflicts with other
-components in other parts, ensure that the function names are
-prepended with a prefix that identify the component to which it
-belongs. For eg. non-static functions in io-threads translator start
-with iot_.
+Inline functions enforce type safety; macros do not.  Use macros only for things
+that explicitly need to be type-agnostic (e.g. cases where one might use
+generics or templates in other languages), or that use other preprocessor
+features such as `#` for stringification or `##` for token pasting.  In general,
+"static inline" is the preferred form.
+
+Avoid copypasta
+---------------
+
+Code that is copied and then pasted into multiple functions often creates
+maintenance problems later, e.g. updating all but one instance for a subsequent
+change.  If you find yourself copying the same "boilerplate" many places,
+consider refactoring to use helper functions (including inline) or macros, or
+code generation.
 
 Ensure function calls wrap around after 80-columns
 --------------------------------------------------
@@ -335,13 +548,95 @@ pthread_mutex_lock (&mutex);
 pthread_mutex_unlock (&mutex);
 ```
 
-*A skeleton fop function:*
+### Always use braces
+
+Even around single statements.
+
+*Bad:*
+
+```
+if (condition) action ();
+
+if (condition)
+        action ();
+```
+
+*Good:*
+
+```
+if (condition) {
+        action ();
+}
+```
+
+### Avoid multi-line conditionals
+
+These can be hard to read and even harder to modify later.  Predicate functions
+and helper variables are always better for maintainability.
+
+*Bad:*
+
+```
+if ((thing1 && other_complex_condition (thing1, lots, of, args))
+    || (!thing2 || even_more_complex_condition (thing2))
+    || all_sorts_of_stuff_with_thing3) {
+    return;
+}
+
+```
+
+*Better:*
+
+```
+thing1_ok = predicate1 (thing1, lots, of, args
+thing2_ok = predicate2 (thing2);
+thing3_ok = predicate3 (thing3);
+
+if (!thing1_ok || !thing2_ok || !thing3_ok) {
+        return;
+}
+```
+
+*Best:*
+
+```
+if (thing1 && other_complex_condition (thing1, lots, of, args)) {
+        return;
+}
+if (!thing2 || even_more_complex_condition (thing2)) {
+        /* Note potential for a different message here. */
+        return;
+}
+if (all_sorts_of_stuff_with_thing3) {
+        /* And here too. */
+        return;
+}
+```
+
+### Use 'const' liberally
+
+If a value isn't supposed/expected to change, there's no cost to adding a
+'const' keyword and it will help prevent violation of expectations.
+
+### Avoid global variables (including 'static' auto variables)
+Almost all state in Gluster is contextual and should be contained in the
+appropriate structure reflecting its scope (e.g. `call\_frame\_t`, `call\_stack\_t`,
+`xlator\_t`, `glusterfs\_ctx\_t`).  With dynamic loading and graph switches in play,
+each global requires careful consideration of when it should be initialized or
+reinitialized, when it might _accidentally_ be reinitialized, when its value
+might become stale, and so on.  A few global variables are needed to serve as
+'anchor points' for these structures, and more exceptions to the rule might be
+approved in the future, but new globals should not be added to the codebase
+without explicit approval.
+
+## A skeleton fop function
 
-This is the recommended template for any fop. In the beginning come
-the initializations. After that, the `success' control flow should be
-linear.  Any error conditions should cause a `goto` to a single
-point, `out`.  At that point, the code should detect the error
-that has occurred and do appropriate cleanup.
+This is the recommended template for any fop. In the beginning come the
+initializations. After that, the 'success' control flow should be linear.  Any
+error conditions should cause a `goto` to a label at the end.  By convention
+this is 'out' if there is only one such label, but a cascade of such labels is
+allowable to support multi-stage cleanup.  At that point, the code should detect
+the error that has occurred and do appropriate cleanup.
 
 ```
 int32_t
diff --git a/doc/developer-guide/commit-guidelines.md b/doc/developer-guide/commit-guidelines.md
new file mode 100644
index 00000000000..38bbe525cbd
--- /dev/null
+++ b/doc/developer-guide/commit-guidelines.md
@@ -0,0 +1,136 @@
+## Git Commit Good Practice
+
+The following document is based on experience doing code development, bug troubleshooting and code review across a number of projects using Git. The document is mostly borrowed from [Open Stack](https://wiki.openstack.org/wiki/GitCommitMessages), but made more meaningful in the context of GlusterFS project.
+
+This topic can be split into two areas of concern
+
+* The structured set/split of the code changes
+* The information provided in the commit message
+
+### Executive Summary
+The points and examples that will be raised in this document ought to clearly demonstrate the value in splitting up changes into a sequence of individual commits, and the importance in writing good commit messages to go along with them. If these guidelines were widely applied it would result in a significant improvement in the quality of the GlusterFS Git history. Both a carrot & stick will be required to effect changes. This document intends to be the carrot by alerting people to the benefits, while anyone doing Gerrit code review can act as the stick ;-P
+
+In other words, when reviewing a change in Gerrit:
+* Do not simply look at the correctness of the code.
+* Review the commit message itself and request improvements to its content.
+* Look out for commits which are mixing multiple logical changes and require the submitter to split them into separate commits.
+* Ensure whitespace changes are not mixed in with functional changes.
+* Ensure no-op code refactoring is done separately from functional changes.
+
+And so on.
+
+It might be mentioned that Gerrit's handling of patch series is not entirely perfect. Let that not become a valid reason to avoid creating patch series. The tools being used should be subservient to developers needs, and since they are open source they can be fixed / improved. Software source code is "read mostly, write occassionally" and thus the most important criteria is to improve the long term maintainability by the large pool of developers in the community, and not to sacrifice too much for the sake of the single author who may never touch the code again.
+
+And now the long detailed guidelines & examples of good & bad practice
+
+### Structural split of changes
+The cardinal rule for creating good commits is to ensure there is only one "logical change" per commit. There are many reasons why this is an important rule:
+
+* The smaller the amount of code being changed, the quicker & easier it is to review & identify potential flaws.
+* If a change is found to be flawed later, it may be necessary to revert the broken commit. This is much easier to do if there are not other unrelated code changes entangled with the original commit.
+* When troubleshooting problems using Git's bisect capability, small well defined changes will aid in isolating exactly where the code problem was introduced.
+* When browsing history using Git annotate/blame, small well defined changes also aid in isolating exactly where & why a piece of code came from.
+
+#### Things to avoid when creating commits
+With the above points in mind, there are some commonly encountered examples of bad things to avoid
+
+* Mixing whitespace changes with functional code changes.
+
+The whitespace changes will obscure the important functional changes, making it harder for a reviewer to correctly determine whether the change is correct. Solution: Create 2 commits, one with the whitespace changes, one with the functional changes. Typically the whitespace change would be done first, but that need not be a hard rule.
+
+* Mixing two unrelated functional changes.
+
+Again the reviewer will find it harder to identify flaws if two unrelated changes are mixed together. If it becomes necessary to later revert a broken commit, the two unrelated changes will need to be untangled, with further risk of bug creation.
+
+* Sending large new features in a single giant commit.
+
+It may well be the case that the code for a new feature is only useful when all of it is present. This does not, however, imply that the entire feature should be provided in a single commit. New features often entail refactoring existing code. It is highly desirable that any refactoring is done in commits which are separate from those implementing the new feature. This helps reviewers and test suites validate that the refactoring has no unintentional functional changes.
+
+Even the newly written code can often be split up into multiple pieces that can be independently reviewed. For example, changes which add new internal fops or library functions, can be in self-contained commits. Again this leads to easier code review. It also allows other developers to cherry-pick small parts of the work, if the entire new feature is not immediately ready for merge. This will encourage the author & reviewers to think about the generic library functions' design, and not simply pick a design that is easier for their currently chosen internal implementation.
+
+The basic rule to follow is
+
+If a code change can be split into a sequence of patches/commits, then it should be split. Less is not more. More is more.
+
+##### Examples of bad practice
+
+TODO: Pick glusterfs specific example.
+
+
+##### Examples of good practice
+
+
+### Information in commit messages
+As important as the content of the change, is the content of the commit message describing it. When writing a commit message there are some important things to remember
+
+* Do not assume the reviewer understands what the original problem was.
+
+When reading bug reports, after a number of back & forth comments, it is often as clear as mud, what the root cause problem is. The commit message should have a clear statement as to what the original problem is. The bug is merely interesting historical background on /how/ the problem was identified. It should be possible to review a proposed patch for correctness without needing to read the bug ticket.
+
+* Do not assume the reviewer has access to external web services/site.
+
+In 6 months time when someone is on a train/plane/coach/beach/pub troubleshooting a problem & browsing Git history, there is no guarantee they will have access to the online bug tracker, or online blueprint documents. The great step forward with distributed SCM is that you no longer need to be "online" to have access to all information about the code repository. The commit message should be totally self-contained, to maintain that benefit.
+
+* Do not assume the code is self-evident/self-documenting.
+
+What is self-evident to one person, might be clear as mud to another person. Always document what the original problem was and how it is being fixed, for any change except the most obvious typos, or whitespace only commits.
+
+* Describe why a change is being made.
+
+A common mistake is to just document how the code has been written, without describing /why/ the developer chose to do it that way. By all means describe the overall code structure, particularly for large changes, but more importantly describe the intent/motivation behind the changes.
+
+* Read the commit message to see if it hints at improved code structure.
+
+Often when describing a large commit message, it becomes obvious that a commit should have in fact been split into 2 or more parts. Don't be afraid to go back and rebase the change to split it up into separate commits.
+
+* Ensure sufficient information to decide whether to review.
+
+When Gerrit sends out email alerts for new patch submissions there is minimal information included, principally the commit message and the list of files changes. Given the high volume of patches, it is not reasonable to expect all reviewers to examine the patches in detail. The commit message must thus contain sufficient information to alert the potential reviewers to the fact that this is a patch they need to look at.
+
+* The first commit line is the most important.
+
+In Git commits the first line of the commit message has special significance. It is used as email subject line, git annotate messages, gitk viewer annotations, merge commit messages and many more places where space is at a premium. As well as summarizing the change itself, it should take care to detail what part of the code is affected. eg if it is 'afr', 'dht' or any translator. Or in some cases, it can be touching all these components, but the commit message can be 'coverity:', 'txn-framework:', 'new-fop: ', etc.
+
+* Describe any limitations of the current code.
+
+If the code being changed still has future scope for improvements, or any known limitations then mention these in the commit message. This demonstrates to the reviewer that the broader picture has been considered and what tradeoffs have been done in terms of short term goals vs. long term wishes.
+
+* Do not include patch set-specific comments.
+
+In other words, if you rebase your change please don't add "Patch set 2: rebased" to your commit message. That isn't going to be relevant once your change has merged. Please do make a note of that in Gerrit as a comment on your change, however. It helps reviewers know what changed between patch sets. This also applies to comments such as "Added unit tests", "Fixed localization problems", or any other such patch set to patch set changes that don't affect the overall intent of your commit.
+
+**The main rule to follow is:**
+
+The commit message must contain all the information required to fully understand & review the patch for correctness. Less is not more. More is more.
+
+
+#### Including external references
+
+The commit message is primarily targeted towards human interpretation, but there is always some metadata provided for machine use. In the case of GlusterFS this includes at least the 'Change-id', "bug"/"feature" ID references and "Signed-off-by" tag (generated by 'git commit -s').
+
+The 'Change-id' line is a unique hash describing the change, which is generated by a Git commit hook. This should not be changed when rebasing a commit following review feedback, since it is used by Gerrit, to track versions of a patch.
+
+The 'bug' line can reference a bug in a few ways. Gerrit creates a link to the bug when viewing the patch on review.gluster.org so that reviewers can quickly access the bug/issue on Bugzilla or Github.
+
+**Fixes: bz#1601166** -- use 'Fixes: bz#NNNNN' if the commit is intended to fully fix and close the bug being referenced.
+**Fixes: #411** -- use 'Fixes: #NNN' if the patch fixes the github issue completely.
+
+**Updates: bz#1193929** -- use 'Updates: bz#NNNN' if the commit is only a partial fix and more work is needed.
+**Updates: #175** -- use 'Updates: #NNNN' if the commit is only a partial fix and more work is needed for the feature completion.
+
+We encourage the use of `Co-Authored-By: name <name@example.com>` in commit messages to indicate people who worked on a particular patch. It's a convention for recognizing multiple authors, and our projects would encourage the stats tools to observe it when collecting statistics.
+
+### Summary of Git commit message structure
+
+* Provide a brief description of the change in the first line.
+* The first line should be limited to 50 characters and should not end with a period.
+
+* Insert a single blank line after the first line.
+
+* Provide a detailed description of the change in the following lines, breaking paragraphs where needed.
+
+* Subsequent lines should be wrapped at 72 characters.
+
+Put the 'Change-id', 'Fixes bz#NNNNN' and 'Signed-off-by: <>' lines at the very end.
+
+TODO: Add good examples
diff --git a/doc/developer-guide/datastructure-inode.md b/doc/developer-guide/datastructure-inode.md
index a340ab9ca8e..45d7a941e5f 100644
--- a/doc/developer-guide/datastructure-inode.md
+++ b/doc/developer-guide/datastructure-inode.md
@@ -1,6 +1,6 @@
-#Inode and dentry management in GlusterFS:
+# Inode and dentry management in GlusterFS:
 
-##Background
+## Background
 Filesystems internally refer to files and directories via inodes. Inodes
 are unique identifiers of the entities stored in a filesystem. Whenever an
 application has to operate on a file/directory (read/modify), the filesystem
@@ -41,11 +41,10 @@ struct _inode_table {
 };
 ```
 
-#Life-cycle
+# Life-cycle
 ```
-
 inode_table_new (size_t lru_limit, xlator_t *xl)
-
+```
 This is a function which allocates a new inode table. Usually the top xlators in
 the graph such as protocol/server (for bricks), fuse and nfs (for fuse and nfs
 mounts) and libgfapi do inode managements. Hence they are the ones which will
@@ -59,11 +58,8 @@ new inode table.
 Thus an allocated inode table is destroyed only when the filesystem daemon is
 killed or unmounted.
 
-```
-
-#what it contains.
-```
 
+# what it contains.
 Inode table in glusterfs mainly contains a hash table for maintaining inodes.
 In general a file/directory is considered to be existing if there is a
 corresponding inode present in the inode table. If a inode for a file/directory
@@ -76,21 +72,21 @@ size of the hash table (as of now it is hard coded to 14057. The hash value of
 a inode is calculated using its gfid).
 
 Apart from the hash table, inode table also maintains 3 important list of inodes
-1) Active list:
+1. Active list:
 Active list contains all the active inodes (i.e inodes which are currently part
 of some fop).
-2) Lru list:
+2. Lru list:
 Least recently used inodes list. A limit can be set for the size of the lru
 list. For bricks it is 16384 and for clients it is infinity.
-3) Purge list:
+3. Purge list:
 List of all the inodes which have to be purged (i.e inodes which have to be
 deleted from the inode table due to unlink/rmdir/forget).
 
 And at last it also contains the mem-pool for allocating inodes, dentries so
 that frequent malloc/calloc and free of the data structures can be avoided.
-```
 
-#Data structure (inode)
+
+# Data structure (inode)
 ```
 struct _inode {
         inode_table_t       *table;         /* the table this inode belongs to */
@@ -108,7 +104,7 @@ struct _inode {
         struct _inode_ctx   *_ctx;          /* place holder for keeping the
         information about the inode by different xlators */
 };
-
+```
 As said above, inodes are internal way of identifying the files/directories. A
 inode uniquely represents a file/directory. A new inode is created whenever a
 create/mkdir/symlink/mknod operations are performed. Apart from that a new inode
@@ -128,9 +124,9 @@ inodes are those inodes whose refcount is greater than zero. Whenever some
 operation comes on a file/directory, and the resolver tries to find the inode
 for it, it increments the refcount of the inode before returning the inode. The
 refcount of an inode can be incremented by calling the below function
-
+```
 inode_ref (inode_t *inode)
-
+```
 Any xlator which wants to operate on a inode as part of some fop (or wants the
 inode in the callback), should hold a ref on the inode.
 Once the fop is completed before sending the reply of the fop to the above
@@ -139,18 +135,18 @@ zero, it is removed from the active inodes list and put into LRU list maintained
 by the inode table. Thus in short if some fop is happening on a file/directory,
 the corresponding inode will be in the active list or it will be in the LRU
 list.
-```
 
-#Life Cycle
+
+# Life Cycle
 
 A new inode is created whenever a new file/directory/symlink is created OR a
 successful lookup of an existing entry is done. The xlators which does inode
 management (as of now protocol/server, fuse, nfs, gfapi) will perform inode_link
 operation upon successful lookup or successful creation of a new entry.
-
+```
 inode_link (inode_t *inode, inode_t *parent, const char *name,
             struct iatt *buf);
-
+```
 inode_link actually adds the inode to the inode table (to be precise it adds
 the inode to the hash table maintained by the inode table. The hash value is
 calculated based on the gfid). Copies the gfid to the inode (the gfid is
@@ -160,7 +156,7 @@ A inode is removed from the inode table and eventually destroyed when unlink
 or rmdir operation is performed on a file/directory, or the the lru limit of
 the inode table has been exceeded.
 
-#Data structure (dentry)
+# Data structure (dentry)
 ```
 
 struct _dentry {
@@ -170,22 +166,22 @@ struct _dentry {
         char              *name;         /* name of the directory entry */
         inode_t           *parent;       /* directory of the entry */
 };
-
+```
 A dentry is the presence of an entry for a file/directory within its parent
 directory. A dentry usually points to the inode to which it belongs to. In
 glusterfs a dentry contains the following fields.
-1) a hook using which it can add itself to the list of
+1. a hook using which it can add itself to the list of
 the dentries maintained by the inode to which it points to.
-2) A hash table pointer.
-3) Pointer to the inode to which it belongs to.
-4) Name of the dentry
-5) Pointer to the inode of the parent directory in which the dentry is present
+2. A hash table pointer.
+3. Pointer to the inode to which it belongs to.
+4. Name of the dentry
+5. Pointer to the inode of the parent directory in which the dentry is present
 
 A new dentry is created when a new file/directory/symlink is created or a hard
 link to an existing file is created.
-
+```
 __dentry_create (inode_t *inode, inode_t *parent, const char *name);
-
+```
 A dentry holds a refcount on the parent
 directory so that the parent inode is never removed from the active inode's list
 and put to the lru list (If the lru limit of the lru list is exceeded, there is
@@ -212,15 +208,14 @@ deleted due to file removal or lru limit being exceeded  the inode is retired
 purge list maintained by the inode table), the nlookup count is set to 0 via
 inode_forget api. The inode table, then prunes all the inodes from the purge
 list by destroying the inode contexts maintained by each xlator.
-
+```
 unlinking of the dentry is done via inode_unlink;
 
 void
 inode_unlink (inode_t *inode, inode_t *parent, const char *name);
-
+```
 If the inode has multiple hard links, then the unlink operation performed by
 the application results just in the removal of the dentry with the name provided
 by the application. For the inode to be removed, all the dentries of the inode
 should be unlinked.
-```
 
diff --git a/doc/developer-guide/datastructure-iobuf.md b/doc/developer-guide/datastructure-iobuf.md
index 5f521f1485f..03604e3672c 100644
--- a/doc/developer-guide/datastructure-iobuf.md
+++ b/doc/developer-guide/datastructure-iobuf.md
@@ -1,6 +1,6 @@
-#Iobuf-pool
-##Datastructures
-###iobuf
+# Iobuf-pool
+## Datastructures
+### iobuf
 Short for IO Buffer. It is one allocatable unit for the consumers of the IOBUF
 API, each unit hosts @page_size(defined in arena structure) bytes of memory. As
 initial step of processing a fop, the IO buffer passed onto GlusterFS by the
@@ -28,7 +28,7 @@ struct iobuf {
 };
 ```
 
-###iobref
+### iobref
 There may be need of multiple iobufs for a single fop, like in vectored read/write.
 Hence multiple iobufs(default 16) are encapsulated under one iobref.
 ```
@@ -40,7 +40,7 @@ struct iobref {
         int                used;    /* number of iobufs added to this iobref */
 };
 ```
-###iobuf_arenas
+### iobuf_arenas
 One region of memory MMAPed from the operating system. Each region MMAPs
 @arena_size bytes of memory, and hosts @arena_size / @page_size IOBUFs.
 The same sized iobufs are grouped into one arena, for sanity of access.
@@ -77,7 +77,7 @@ struct iobuf_arena {
 };
 
 ```
-###iobuf_pool
+### iobuf_pool
 Pool of Iobufs. As there may be many Io buffers required by the filesystem,
 a pool of iobufs are preallocated and kept, if these preallocated ones are
 exhausted only then the standard malloc/free is called, thus improving the
@@ -139,8 +139,8 @@ arenas in the purge list are destroyed only if there is  atleast one arena in
 (e.g: If there is an arena (page_size=128KB, count=32) in purge list, this arena
 is destroyed(munmap) only if there is an arena in 'arenas' list with page_size=128KB).
 
-##APIs
-###iobuf_get
+## APIs
+### iobuf_get
 
 ```
 struct iobuf *iobuf_get (struct iobuf_pool *iobuf_pool);
@@ -149,7 +149,7 @@ Creates a new iobuf of the default page size(128KB hard coded as of yet).
 Also takes a reference(increments ref count), hence no need of doing it
 explicitly after getting iobuf.
 
-###iobuf_get2
+### iobuf_get2
 
 ```
 struct iobuf * iobuf_get2 (struct iobuf_pool *iobuf_pool, size_t page_size);
@@ -179,7 +179,7 @@ if (requested iobuf size > Max iobuf size in the pool(1MB as of yet))
 Also takes a reference(increments ref count), hence no need of doing it
 explicitly after getting iobuf.
 
-###iobuf_ref
+### iobuf_ref
 
 ```
 struct iobuf *iobuf_ref (struct iobuf *iobuf);
@@ -188,7 +188,7 @@ struct iobuf *iobuf_ref (struct iobuf *iobuf);
 xlator/function/, its a good practice to take a reference so that iobuf is not
 deleted by the allocator.
 
-###iobuf_unref
+### iobuf_unref
 ```
 void iobuf_unref (struct iobuf *iobuf);
 ```
@@ -203,33 +203,33 @@ Unreference the iobuf, if the ref count is zero iobuf is considered free.
 Every iobuf_ref should have a corresponding iobuf_unref, and also every
 iobuf_get/2 should have a correspondning iobuf_unref.
 
-###iobref_new
+### iobref_new
 ```
 struct iobref *iobref_new ();
 ```
 Creates a new iobref structure and returns its pointer.
 
-###iobref_ref
+### iobref_ref
 ```
 struct iobref *iobref_ref (struct iobref *iobref);
 ```
 Take a reference on the iobref.
 
-###iobref_unref
+### iobref_unref
 ```
 void iobref_unref (struct iobref *iobref);
 ```
 Decrements the reference count of the iobref. If the ref count is 0, then unref
 all the iobufs(iobuf_unref) in the iobref, and destroy the iobref.
 
-###iobref_add
+### iobref_add
 ```
 int iobref_add (struct iobref *iobref, struct iobuf *iobuf);
 ```
 Adds the given iobuf into the iobref, it takes a ref on the iobuf before adding
 it, hence explicit iobuf_ref is not required if adding to the iobref.
 
-###iobref_merge
+### iobref_merge
 ```
 int iobref_merge (struct iobref *to, struct iobref *from);
 ```
@@ -239,13 +239,13 @@ on all the iobufs added to the 'to' iobref. Hence iobref_unref should be
 performed both on 'from' and 'to' iobrefs (performing iobref_unref only on 'to'
 will not free the iobufs and may result in leak).
 
-###iobref_clear
+### iobref_clear
 ```
 void iobref_clear (struct iobref *iobref);
 ```
 Unreference all the iobufs in the iobref, and also unref the iobref.
 
-##Iobuf Leaks
+## Iobuf Leaks
 If all iobuf_refs/iobuf_new do not have correspondning iobuf_unref, then the
 iobufs are not freed and recurring execution of such code path may lead to huge
 memory leaks. The easiest way to identify if a memory leak is caused by iobufs
diff --git a/doc/developer-guide/datastructure-mem-pool.md b/doc/developer-guide/datastructure-mem-pool.md
index c71aa2a8ddd..225567cbf9f 100644
--- a/doc/developer-guide/datastructure-mem-pool.md
+++ b/doc/developer-guide/datastructure-mem-pool.md
@@ -1,5 +1,5 @@
-#Mem-pool
-##Background
+# Mem-pool
+## Background
 There was a time when every fop in glusterfs used to incur cost of allocations/de-allocations for every stack wind/unwind between xlators because stack/frame/*_localt_t in every wind/unwind was allocated and de-allocated. Because of all these system calls in the fop path there was lot of latency and the worst part is that most of the times the number of frames/stacks active at any time wouldn't cross a threshold. So it was decided that this threshold number of frames/stacks would be allocated in the beginning of the process only once. Get one of them from the pool of stacks/frames whenever `STACK_WIND` is performed and put it back into the pool in `STACK_UNWIND`/`STACK_DESTROY` without incurring any extra system calls. The data structures are allocated only when threshold number of such items are in active use i.e. pool is in complete use.% increase in the performance once this was added to all the common data structures (inode/fd/dict etc) in xlators throughout the stack was tremendous.
 
 ## Data structure
@@ -27,7 +27,7 @@ will be served from here until all the elements in the pool are in use i.e. cold
 };
 ```
 
-##Life-cycle
+## Life-cycle
 ```
 mem_pool_new (data_type, unsigned long count)
 
@@ -120,5 +120,5 @@ mem_pool_destroy (struct mem_pool *pool)
 Deletes this pool from the `global_list` maintained by `glusterfs-ctx` and frees all the memory allocated in `mem_pool_new`.
 
 
-###How to pick pool-size
+### How to pick pool-size
 This varies from work-load to work-load. Create the mem-pool with some random size and run the work-load. Take the statedump after the work-load is complete. In the statedump if `max_alloc` is always less than `cold_count` may be reduce the size of the pool closer to `max_alloc`. On the otherhand if there are lots of `pool-misses` then increase the `pool_size` by `max_stdalloc` to achieve better 'hit-rate' of the pool.
diff --git a/doc/developer-guide/dirops-transactions-in-dht.md b/doc/developer-guide/dirops-transactions-in-dht.md
index 83f63be3f45..909a97001aa 100644
--- a/doc/developer-guide/dirops-transactions-in-dht.md
+++ b/doc/developer-guide/dirops-transactions-in-dht.md
@@ -1,3 +1,4 @@
+# dirops transactions in dht
 Need for transactions during operations on directories arise from two
 basic design elements of DHT:
 
@@ -269,4 +270,4 @@ And the examples are:
          *  Both _dst_ and _dst/dst_ have same gfid - _gfid-src_. As observed earlier, symptom might be directory listing being incomplete
  - mkdir (dst) vs renamedir ("src", "dst")
  - rmdir (src) vs renamedir ("src", "dst")
- - rmdir (dst) vs renamedir ("src", "dst")
-\ No newline at end of file
+ - rmdir (dst) vs renamedir ("src", "dst")
diff --git a/doc/developer-guide/fuse-interrupt.md b/doc/developer-guide/fuse-interrupt.md
new file mode 100644
index 00000000000..ec991b81ec5
--- /dev/null
+++ b/doc/developer-guide/fuse-interrupt.md
@@ -0,0 +1,211 @@
+# Fuse interrupt handling
+
+## Conventions followed
+
+- *FUSE* refers to the "wire protocol" between kernel and userspace and
+  related specifications.
+- *fuse* refers to the kernel subsystem and also to the GlusterFs translator.
+
+## FUSE interrupt handling spec
+
+The [Linux kernel FUSE documentation](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/fuse.txt?h=v4.18#n148)
+desrcibes how interrupt handling happens in fuse.
+
+## Interrupt handling in the fuse translator
+
+### Declarations
+
+This document describes the internal API in the fuse translator with which
+interrupt can be handled.
+
+The API being internal (to be used only in fuse-bridge.c; the functions are
+not exported to a header file).
+
+```
+enum fuse_interrupt_state {
+    /* ... */
+    INTERRUPT_SQUELCHED,
+    INTERRUPT_HANDLED,
+    /* ... */
+};
+typedef enum fuse_interrupt_state fuse_interrupt_state_t;
+struct fuse_interrupt_record;
+typedef struct fuse_interrupt_record fuse_interrupt_record_t;
+typedef void (*fuse_interrupt_handler_t)(xlator_t *this,
+                                         fuse_interrupt_record_t *);
+struct fuse_interrupt_record {
+    fuse_in_header_t fuse_in_header;
+    void *data;
+    /*
+       ...
+     */
+};
+
+fuse_interrupt_record_t *
+fuse_interrupt_record_new(fuse_in_header_t *finh,
+                          fuse_interrupt_handler_t handler);
+
+void
+fuse_interrupt_record_insert(xlator_t *this, fuse_interrupt_record_t *fir);
+
+gf_boolean_t
+fuse_interrupt_finish_fop(call_frame_t *frame, xlator_t *this,
+                          gf_boolean_t sync, void **datap);
+
+void
+fuse_interrupt_finish_interrupt(xlator_t *this, fuse_interrupt_record_t *fir,
+                                fuse_interrupt_state_t intstat,
+                                gf_boolean_t sync, void **datap);
+```
+
+The code demonstrates the usage of the API through `fuse_flush()`. (It's a
+dummy implementation only for demonstration purposes.) Flush is chosen
+because a `FLUSH` interrupt is easy to trigger (see
+*tests/features/interrupt.t*). Interrupt handling for flush is switched on
+by `--fuse-flush-handle-interrupt` (a hidden glusterfs command line flag).
+The implementation of flush interrupt is contained in the
+`fuse_flush_interrupt_handler()` function and blocks guarded by the
+
+```
+if (priv->flush_handle_interrupt) { ...
+```
+
+conditional (where `priv` is a `*fuse_private_t`).
+
+### Overview
+
+"Regular" fuse fops and interrupt handlers interact via a list containing
+interrupt records.
+
+If a fop wishes to have its interrupts handled, it needs to set up an
+interrupt record and insert it into the list; also when it's to finish
+(ie. in its "cbk" stage) it needs to delete the record from the list.
+
+If no interrupt happens, basically that's all to it - a list insertion
+and deletion.
+
+However, if an interrupt comes for the fop, the interrupt FUSE request
+will carry the data identifying an ongoing fop (that is, its `unique`),
+and based on that, the interrupt record will be looked up in the list, and
+the specific interrupt handler (a member of the interrupt record) will be
+called.
+
+Usually the fop needs to share some data with the interrupt handler to
+enable it to perform its task (also shared via the interrupt record).
+The interrupt API offers two approaches to manage shared data:
+- _Async or reference-counting strategy_: from the point on when the interrupt
+  record is inserted to the list, it's owned jointly by the regular fop and
+  the prospective interrupt handler. Both of them need to check before they
+  return if the other is still holding a reference; if not, then they are
+  responsible for reclaiming the shared data.
+- _Sync or borrow strategy_: the interrupt handler is considered a borrower
+  of the shared data. The interrupt handler should not reclaim the shared
+  data. The fop will wait for the interrupt handler to finish (ie., the borrow
+  to be returned), then it has to reclaim the shared data.
+
+The user of the interrupt API need to call the following functions to
+instrument this control flow:
+- `fuse_interrupt_record_insert()` in the fop to insert the interrupt record to
+   the list;
+- `fuse_interrupt_finish_fop()`in the fop (cbk) and
+- `fuse_interrupt_finish_interrupt()`in the interrupt handler
+
+to perform needed synchronization at the end their tenure. The data management
+strategies are implemented by the `fuse_interrupt_finish_*()` functions (which
+have an argument to specify which strategy to use); these routines take care
+of freeing the interrupt record itself, while the reclamation of the shared data
+is left to the API user.
+
+### Usage
+
+A given FUSE fop can be enabled to handle interrupts via the following
+steps:
+
+- Define a handler function (of type `fuse_interrupt_handler_t`).
+  It should implement the interrupt handling logic and in the end
+  call (directly or as async callback) `fuse_interrupt_finish_interrupt()`.
+  The `intstat` argument to `fuse_interrupt_finish_interrupt` should be
+  either `INTERRUPT_SQUELCHED` or `INTERRUPT_HANDLED`.
+    - `INTERRUPT_SQUELCHED` means that the interrupt could not be delivered
+      and the fop is going on uninterrupted.
+    - `INTERRUPT_HANDLED` means that the interrupt was actually handled. In
+      this case the fop will be answered from interrupt context with errno
+      `EINTR` (that is, the fop should not send a response to the kernel).
+
+  (the enum `fuse_interrupt_state` includes further members, which are reserved
+  for internal use).
+
+  We return to the `sync` and `datap` arguments later.
+- In the `fuse_<FOP>` function create an interrupt record using
+  `fuse_interrupt_record_new()`, passing the incoming `fuse_in_header` and
+  the above handler function to it.
+    - Arbitrary further data can be referred to via the `data` member of the
+      interrupt record that is to be passed on from fop context to
+      interrupt context.
+- When it's set up, pass the interrupt record to
+  `fuse_interrupt_record_insert()`.
+- In `fuse_<FOP>_cbk` call `fuse_interrupt_finish_fop()`.
+    - `fuse_interrupt_finish_fop()` returns a Boolean according to whether the
+      interrupt was handled. If it was, then the FUSE request is already
+      answered and the stack gets destroyed in `fuse_interrupt_finish_fop` so
+      `fuse_<FOP>_cbk()` can just return (zero). Otherwise follow the standard
+      cbk logic (answer the FUSE request and destroy the stack -- these are
+      typically accomplished by `fuse_err_cbk()`).
+- The last two argument of `fuse_interrupt_finish_fop()` and
+  `fuse_interrupt_finish_interrupt()` are `gf_boolean_t sync` and
+  `void **datap`.
+    - `sync` represents the strategy for freeing the interrupt record. The
+      interrupt handler and the fop handler are in race to get at the interrupt
+      record first (interrupt handler for purposes of doing the interrupt
+      handling, fop handler for purposes of deactivating the interrupt record
+      upon completion of the fop handling).
+        - If `sync` is true, then the fop handler will wait for the interrupt
+          handler to finish and it takes care of freeing.
+        - If `sync` is false, the loser of the above race will perform freeing.
+
+      Freeing is done within the respective interrupt finish routines, except
+      for the `data` field of the interrupt record; with respect to that, see
+      the discussion of the `datap` parameter below. The strategy has to be
+      consensual, that is, `fuse_interrupt_finish_fop()` and
+      `fuse_interrupt_finish_interrupt()` must pass the same value for `sync`.
+      If dismantling the resources associated with the interrupt record is
+      simple, `sync = _gf_false` is the suggested choice; `sync = _gf_true` can
+      be useful in the opposite case, when dismantling those resources would
+      be inconvenient to implement in two places or to enact in non-fop context.
+    - If `datap` is `NULL`, the `data` member of the interrupt record will be
+      freed within the interrupt finish routine.  If it points to a valid
+      `void *` pointer, and if caller is doing the cleanup (see `sync` above),
+      then that pointer will be directed to the `data` member of the interrupt
+      record and it's up to the caller what it's doing with it.
+        - If `sync` is true, interrupt handler can use `datap = NULL`, and
+          fop handler will have `datap` point to a valid pointer.
+        - If `sync` is false, and handlers pass a pointer to a pointer for
+          `datap`, they should check if the pointed pointer is NULL before
+          attempting to deal with the data.
+
+### FUSE answer for the interrupted fop
+
+The kernel acknowledges a successful interruption for a given FUSE request
+if the filesystem daemon answers it with errno EINTR; upon that, the syscall
+which induced the request will be abruptly terminated with an interrupt, rather
+than returning a value.
+
+In glusterfs, this can be arranged in two ways.
+
+- If the interrupt handler wins the race for the interrupt record, ie.
+  `fuse_interrupt_finish_fop()` returns true to `fuse_<FOP>_cbk()`, then, as
+  said above, `fuse_<FOP>_cbk()` does not need to answer the FUSE request.
+  That's because then the interrupt handler will take care about answering
+  it (with errno EINTR).
+- If `fuse_interrupt_finish_fop()` returns false to `fuse_<FOP>_cbk()`, then
+  this return value does not inform the fop handler whether there was an interrupt
+  or not. This return value occurs both when fop handler won the race for the
+  interrupt record against the interrupt handler, and when there was no interrupt
+  at all.
+
+  However, the internal logic of the fop handler might detect from other
+  circumstances that an interrupt was delivered. For example, the fop handler
+  might be sleeping, waiting for some data to arrive, so that a premature
+  wakeup (with no data present) occurs if the interrupt handler intervenes. In
+  such cases it's the responsibility of the fop handler to reply the FUSE
+  request with errro EINTR.
diff --git a/doc/developer-guide/identifying-resource-leaks.md b/doc/developer-guide/identifying-resource-leaks.md
index 851fc4424bc..950cae79b0a 100644
--- a/doc/developer-guide/identifying-resource-leaks.md
+++ b/doc/developer-guide/identifying-resource-leaks.md
@@ -174,3 +174,27 @@ In this case, the resource leak can be addressed by adding a single line to the
 
 Running the same Valgrind command and comparing the output will show that the
 memory leak in `xlators/meta/src/meta.c:init` is not reported anymore.
+
+### Running DRD, the Valgrind thread error detector
+
+When configuring GlusterFS with:
+
+```shell
+./configure --enable-valgrind
+```
+
+the default Valgrind tool (Memcheck) is enabled. But it's also possble to select
+one of Memcheck or DRD by using:
+
+```shell
+./configure --enable-valgrind=memcheck
+```
+
+or:
+
+```shell
+./configure --enable-valgrind=drd
+```
+
+respectively. When using DRD, it's recommended to consult
+https://valgrind.org/docs/manual/drd-manual.html before running.
diff --git a/doc/developer-guide/logging-guidelines.md b/doc/developer-guide/logging-guidelines.md
index 58adf944b67..0e6b2588535 100644
--- a/doc/developer-guide/logging-guidelines.md
+++ b/doc/developer-guide/logging-guidelines.md
@@ -62,7 +62,7 @@ There are 2 interfaces provided to log messages,
       headers (like the time stamp, dom, errnum etc.). The primary users of
       the above interfaces are, when printing the final graph, or printing
       the configuration when a process is about dump core or abort, or
-      printing the backtrace when a process recieves a critical signal
+      printing the backtrace when a process receives a critical signal
       - These interfaces should not be used outside the scope of the users
       above, unless you know what you are doing
 
diff --git a/doc/developer-guide/network_compression.md b/doc/developer-guide/network_compression.md
index 7327591ef63..1222a765276 100644
--- a/doc/developer-guide/network_compression.md
+++ b/doc/developer-guide/network_compression.md
@@ -1,9 +1,9 @@
-#On-Wire Compression + Decompression
+# On-Wire Compression + Decompression
 
 The 'compression translator' compresses and decompresses data in-flight
 between client and bricks.
 
-###Working
+### Working
 When a writev call occurs, the client compresses the data before sending it to
 brick. On the brick, compressed data is decompressed. Similarly, when a readv
 call occurs, the brick compresses the data before sending it to client. On the
@@ -19,7 +19,7 @@ During normal operation, this is the format of data sent over wire:
 The trailer contains the CRC32 checksum and length of original uncompressed
 data. This is used for validation.
 
-###Usage
+### Usage
 
 Turning on compression xlator:
 
@@ -27,7 +27,7 @@ Turning on compression xlator:
 gluster volume set <vol_name> network.compression on
 ~~~
 
-###Configurable parameters (optional)
+### Configurable parameters (optional)
 
 **Compression level**
 ~~~
@@ -35,10 +35,10 @@ gluster volume set <vol_name> network.compression.compression-level 8
 ~~~
 
 ~~~
-0  : no compression
-1  : best speed
-9  : best compression
--1 : default compression
+ 0  : no compression
+ 1  : best speed
+ 9  : best compression
+-1  : default compression
 ~~~
 
 **Minimum file size**
@@ -55,7 +55,7 @@ Other less frequently used parameters include `network.compression.mem-level`
 and `network.compression.window-size`. More details can about these options
 can be found by running `gluster volume set help` command.
 
-###Known Issues and Limitations
+### Known Issues and Limitations
 
 * Compression translator cannot work with striped volumes.
 * Mount point hangs when writing a file with write-behind xlator turned on. To
@@ -65,7 +65,7 @@ set`performance.strict-write-ordering` to on.
 distribute volumes. This limitation is caused by AFR not being able to
 propagate xdata. This issue has been fixed in glusterfs versions > 3.5
 
-###TODO
+### TODO
 Although zlib offers high compression ratio, it is very slow. We can make the
 translator pluggable to add support for other compression methods such as
 [lz4 compression](https://code.google.com/p/lz4/)
diff --git a/doc/developer-guide/options-to-contribute.md b/doc/developer-guide/options-to-contribute.md
new file mode 100644
index 00000000000..3f0d84e7645
--- /dev/null
+++ b/doc/developer-guide/options-to-contribute.md
@@ -0,0 +1,212 @@
+# A guide for contributors
+
+While you have gone through 'how to contribute' guides, if you are
+not sure what to work on, but really want to help the project, you
+have now landed on the right document :-)
+
+### Basic
+
+Instead of planning to fix **all** the below issues in one patch,
+we recommend you to have a a constant, continuous flow of improvements
+for the project. We recommend you to pick 1 file (or just few files) at
+a time to address below issues.
+Pick any `.c` (or `.h`) file, and you can send a patch which fixes **any**
+of the below themes. Ideally, fix all such occurrences in the file, even
+though, the reviewers would review even a single line change patch
+from you.
+
+1. Check for variable definitions, and if there is an array definition,
+which is very large at the top of the function, see if you can re-scope
+the variable to relevant sections (if it helps).
+
+Most of the time, some of these arrays may be used for 'error' handling,
+and it is possible to use them only in that scope.
+
+Reference: https://review.gluster.org/20846/
+
+
+2. Check for complete string initialization at the beginning of a function.
+Ideally, there is no reason to initialize a string. Fix it across the file.
+
+Example:
+
+`char new_path_name[PATH_MAX] = {0};` to `char new_path_name[PATH_MAX];`
+
+
+3. Change `calloc()` to `malloc()` wherever it makes sense.
+
+In a case of allocating a structures, where you expect certain (or most of)
+variables to be 0 (or NULL), it makes sense to use calloc(). But otherwise,
+there is an extra cost to `memset()` the whole object after allocating it.
+While it is not a significant improvement in performance, code which gets
+hit 1000s of times in a second, it would add some value.
+
+Reference: https://review.gluster.org/20878/
+
+
+4. You can consider using `snprintf()`, instead of `strncpy()` while dealing
+with strings.
+
+strncpy() won't null terminate if the dest buffer isn't big enough; snprintf()
+does. While most of the string operations in the code is on array, and larger
+size than required, strncpy() does an extra copy of 0s at the end of
+string till the size of the array. It makes sense to use `snprintf()`,
+which doesn't suffer from that behavior.
+
+Also check the return value from snprintf() for buffer overflow and handle
+accordingly
+
+Reference: https://review.gluster.org/20925/
+
+
+5. Now, pick a `.h` file, and see if a structure is very large, and see
+if re-aligning them as per [coding-standard](./coding-standard.md) gives any size benefit,
+if yes, go ahead and change it. Make sure you check all the structures
+in the file for similar pattern.
+
+Reference: [Check this section](https://github.com/gluster/glusterfs/blob/master/doc/developer-guide/coding-standard.md#structure-members-should-be-aligned-based-on-the-padding-requirements
+
+
+### If you are up for more :-)
+
+Good progress! Glad you are interested to know more. We are surely interested
+in next level of contributions from you!
+
+#### Coverity
+
+Visit [Coverity Dashboard](https://scan.coverity.com/projects/gluster-glusterfs?tab=overview).
+
+Now, if the number of defect is not 0, you have an opportunity to contribute.
+
+You get all the detail on why the particular defect is mentioned there, and
+most probable hint on how to fix it. Do it!
+
+Reference: https://review.gluster.org/21394/
+
+Use the same reference Id (789278) as the patch, so we can capture it is in
+single bugzilla.
+
+#### Clang-Scan
+
+Clang-Scan is a tool which scans the .c files and reports the possible issues,
+similar to coverity, but a different tool. Over the years we have seen, they
+both report very different set of issues, and hence there is a value in fixing it.
+
+GlusterFS project gets tested with clang-scan job every night, and the report is
+posted in the [job details page](https://build.gluster.org/job/clang-scan/lastCompletedBuild/clangScanBuildBugs/).
+As long as the number is not 0 in the report here, you have an opportunity to
+contribute! Similar to coverity dashboard, click on 'Details' to find out the
+reason behind that report, and send a patch.
+
+Reference: https://review.gluster.org/21025
+
+Again, you can use reference Id (1622665) for these patches!
+
+
+### I am good with programming, I would like to do more than above!
+
+#### Locked regions / Critical sections
+
+In the file you open, see if the lock is taken only to increment or decrement
+a flag, counter etc. If yes, then recommend you to convert it to ATOMIC locks.
+It is simple activity, but, if you know programing, you would know the benefit
+here.
+
+NOTE: There may not always a possibility to do this! You may have to check
+with developers first before going ahead.
+
+Reference: https://review.gluster.org/21221/
+
+
+#### ASan (address sanitizer)
+
+[The job](https://build.gluster.org/job/asan/) runs regression with asan builds,
+and you can also run glusterfs with asan on your workload to identify the leaks.
+If there are any leaks reported, feel free to check it, and send us patch.
+
+You can also run `valgrind` and let us know what it reports.
+
+Reference: https://review.gluster.org/21397
+
+
+#### Porting to different architecture
+
+This is something which we are not focusing right now, happy to collaborate!
+
+Reference: https://review.gluster.org/21276
+
+
+#### Fix 'TODO/FIXME' in codebase
+
+There are few cases of pending features, or pending validations, which are
+pending from sometime. You can pick them in the given file, and choose to
+fix it.
+
+
+### I don't know C, but I am interested to contribute in some way!
+
+You are most welcome! Our community is open for your contribution! First thing
+which comes to our mind is **documentation**. Next is, **testing** or validation.
+
+If you have some hardware, and want to run some performance comparisons with
+different version, or options, and help us to tune better is also a great help.
+
+
+#### Documentation
+
+1. We have some documentation in [glusterfs repo](../), go through these, and
+see if you can help us to keep up-to-date.
+
+2. The https://docs.gluster.org is powered by https://github.com/gluster/glusterdocs
+repo. You can check out the repo, and help in keeping that up-to-date.
+
+3. [Our website](https://gluster.org) is maintained by https://github.com/gluster/glusterweb
+repo. Help us to keep this up-to-date, and add content there.
+
+4. Write blogs about Gluster, and your experience, and make world know little
+more about Gluster, and your use-case, and how it helped to solve the problem.
+
+
+#### Testing
+
+1. There is a regression test suite in glusterfs, which runs with every patch, and is
+triggered by just running `./run-tests.sh` from the root of the project repo.
+
+You can add more test case to match your use-case, and send it as a patch, so you
+can make sure all future patches in glusterfs would keep your usecase intact.
+
+2. [Glusto-Tests](https://github.com/gluster/glusto-tests): This is another testing
+framework written for gluster, and makes use of clustered setup to test different
+use-cases, and helps to validate many bugs.
+
+
+#### Ansible
+
+Gluster Organization has rich set of ansible roles, which are actively maintained.
+Feel free to check them out here - https://github.com/gluster/gluster-ansible
+
+
+#### Monitoring
+
+We have prometheus repo, and are actively working on adding more metrics. Add what
+you need @ https://github.com/gluster/gluster-prometheus
+
+
+#### Health-Report
+
+This is a project, where at any given point in time, you want to run some set of
+commands locally, and get an output to analyze the status, it can be added.
+Contribute @ https://github.com/gluster/gluster-health-report
+
+
+### All these C/bash/python is old-school, I want something in containers.
+
+We have something for you too :-)
+
+Please visit our https://github.com/gluster/gcs repo for checking how you can help,
+and how gluster can help you in container world.
+
+
+### Note
+
+For any queries, best way is to contact us through mailing-list, <mailto:gluster-devel@gluster.org>
diff --git a/doc/developer-guide/syncop.md b/doc/developer-guide/syncop.md
index 4e30451f30e..bcc8bd08e01 100644
--- a/doc/developer-guide/syncop.md
+++ b/doc/developer-guide/syncop.md
@@ -1,4 +1,4 @@
-#syncop framework
+# syncop framework
 A coroutines-based, cooperative multi-tasking framework.
 
 ## Topics
diff --git a/doc/developer-guide/thread-naming.md b/doc/developer-guide/thread-naming.md
index 204cd7681b4..513140d4437 100644
--- a/doc/developer-guide/thread-naming.md
+++ b/doc/developer-guide/thread-naming.md
@@ -29,10 +29,10 @@ gf_thread_create_detached (pthread_t *thread,
 As max name length for a thread in POSIX is only 16 characters including the
 '\0' character, you have to be a little creative with naming. Also, it is
 important that all Gluster threads have common prefix. Considering these
-conditions, we have "gluster" as prefix for all the threads created by these
+conditions, we have "glfs_" as prefix for all the threads created by these
 wrapper functions. It is responsibility of the owner of thread to provide the
 suffix part of the name. It does not have to be a descriptive name, as it has
-only 8 letters to work with. However, it should be unique enough such that it
+only 10 letters to work with. However, it should be unique enough such that it
 can be matched with a table which describes it.
 
 If n number of threads are spwaned to perform same function, it is must that the
@@ -87,6 +87,7 @@ such that it can be matched with a table below without ambiguity.
 - posixfsy - posix fsync
 - posixhc  - posix heal
 - posixjan - posix janitor
+- posixrsv - posix reserve
 - quiesce  - quiesce dequeue
 - rdmaAsyn - rdma async event handler
 - rdmaehan - rdma completion handler
@@ -99,6 +100,5 @@ such that it can be matched with a table below without ambiguity.
 - spoller  - socket poller
 - sprocN   - syncop worker thread
 - tbfclock - token bucket filter token generator thread
-- tierfixl - tier fix layout
 - timer    - timer thread
 - upreaper - upcall reaper
diff --git a/doc/developer-guide/translator-development.md b/doc/developer-guide/translator-development.md
index 3bf7e153354..f75935519f6 100644
--- a/doc/developer-guide/translator-development.md
+++ b/doc/developer-guide/translator-development.md
@@ -472,7 +472,7 @@ hello
 Now let's interrupt the process and see where we are.
 
 ```
-^C
+
 Program received signal SIGINT, Interrupt.
 0x0000003a0060b3dc in pthread_cond_wait@@GLIBC_2.3.2 ()
                    from /lib64/libpthread.so.0
@@ -680,4 +680,4 @@ Original author's site:
 
 Gluster community site:
 
- * [Translators](http://www.gluster.org/community/documentation/index.php/Translators)
+ * [Translators](https://docs.gluster.org/en/latest/Quick-Start-Guide/Architecture/#translators)
diff --git a/doc/developer-guide/writing-a-cloudsync-plugin.md b/doc/developer-guide/writing-a-cloudsync-plugin.md
new file mode 100644
index 00000000000..907860aaed8
--- /dev/null
+++ b/doc/developer-guide/writing-a-cloudsync-plugin.md
@@ -0,0 +1,164 @@
+## How to write your Cloudsync Plugin
+
+### Background
+
+Cloudsync translator is part of the archival feature in Gluster. This translator
+does the retrieval/download part. Each cold  file will be archived to a remote
+storage (public or private cloud). On future access to the file, it will be
+retrieved from the remote storage by Cloudsync translator. Each remote storage
+would need a unique plugin. Cloudsync translator will load this plugin and
+call the necessary plugin functions.
+
+Upload can be done by a script or program. There are some basic mandatory steps
+for uploading the data. There is a sample script for crawl and upload given at
+the end of this guide.
+
+### Necessary changes to create a plugin
+
+1. Define store_methods:
+
+* This structure is the container of basic functions that will be called by
+  cloudsync xlator.
+
+        typedef struct store_methodds {
+                int (*fop_download) (call_frame_t *frame, void *config);
+                /* return type should be the store config */
+                void *(*fop_init) (xlator_t *this);
+                int (*fop_reconfigure) (xlator_t *this, dict_t *options);
+                void (*fop_fini) (void *config);
+        } store_methods_t;
+
+
+        Member details:
+        fop_download:
+                This is the download function pointer.
+
+                frame: This will have the fd to write data downloaded from
+                       cloud to GlusterFS.(frame->local->fd)
+
+                config: This is the plugin configuration variable.
+
+                Note: Structure cs_local_t has member dlfd and dloffset which
+                      can be used to manage the writes to Glusterfs.
+                      Include cloudsync-common.h to access these structures.
+
+        fop_init:
+                This is similar to xlator init. But here the return value is
+                the plugin configuration pointer. This pointer will be stored
+                in the cloudsync private object (priv->stores->config). And
+                the cloudsync private object can be accessed by "this->private"
+                where "this" is of type xlator_t.
+
+        fop_reconfigure:
+                This is similar to xlator_reconfigure.
+
+        fop_fini:
+                Free plugin resources.
+
+        Note: Store_methods_t is part of cs_private_t which in turn part of
+              xlator_t. Create a store_methods_t object named "store_ops" in
+              your plugin. For example
+
+              store_methods_t store_ops = {
+                .fop_download = aws_download_s3,
+                .fop_init     = aws_init,
+                .fop_reconfigure = aws_reconfigure,
+                .fop_fini     = aws_fini,
+              };
+
+
+2 - Making Cloudsync xlator aware of the plugin:
+
+        Add an entry in to the cs_plugin structure. For example
+        struct cs_plugin plugins[] = {
+                {
+                  .name = "amazons3",
+                  .library = "libamazons3.so",
+                  .description = "amazon s3 store."
+                },
+
+                {.name = NULL},
+        };
+
+        Description about individual members:
+                name: name of the plugin
+                library: This is the shared object created. Cloudsync will load
+                         this library during init.
+                description: Describe about the plugin.
+
+3- Makefile Changes in Cloudsync:
+
+		Add <plugin.la> to cloudsync_la_LIBADD variable.
+
+4 - Configure.ac changes:
+
+                In cloudsync section add the necessary dependency checks for
+                the plugin.
+
+5 - Export symbols:
+
+        Cloudsync needs "store_ops" to resolve all plugin functions.
+        Create a file <plugin>.sym and add write "store_ops" to it.
+
+
+### Sample script for upload
+This script assumes amazon s3 is the target cloud and bucket name is
+gluster-bucket. User can do necessary aws configuration using command
+"aws configure". Currently for amazons3 there are four gluster settings
+available.
+1- features.s3plugin-seckey -> s3 secret key
+2- features.s3plugin-keyid -> s3 key id
+3- features.s3plugin-bucketid -> bucketid
+4- features.s3plugin-hostname -> hostname e.g. s3.amazonaws.com
+
+Additionally set cloudsync storetype to amazons3.
+
+gluster v set <VOLNAME> cloudsync-storetype amazons3
+
+Now create a mount dedicated for this upload task.
+
+That covers necessary configurations needed.
+
+Below is the sample script for upload. The script will crawl directly on the
+brick and will upload those files which are not modified for last one month.
+It needs two arguments.
+1st arguement - Gluster Brick path
+2nd arguement - coldness that is how many days since the file was modified.
+3rd argument - dedicated gluster mount point created for uploading.
+
+Once the cloud setup is done, run the following script on individual bricks.
+Note: For an AFR volume, pick only the fully synchronized brick among the
+replica bricks.
+
+```
+target_folder=$1
+coldness=$2
+mnt=$3
+
+cd $target_folder
+for i in `find . -type f  | grep -v "glusterfs" | sed 's/..//'`
+do
+        echo "processing $mnt/$i"
+
+        #check whether the file is already archived
+        getfattr -n trusted.glusterfs.cs.remote $i &> /dev/null
+        if [ $? -eq 0 ]
+        then
+                echo "file $mnt/$i is already archived"
+        else
+                #upload to cloud
+                aws s3 cp $mnt/$i s3://gluster-bucket/
+                mtime=`stat -c "%Y" $mnt/$i`
+
+                #post processing of upload
+                setfattr -n trusted.glusterfs.csou.complete -v $mtime $mnt/$i
+                if [ $? -ne 0 ]
+                then
+                        echo "archiving of file $mnt/$i failed"
+                else
+                        echo "archiving of file $mnt/$i succeeded"
+                fi
+
+        fi
+done
+```
diff --git a/doc/developer-guide/xlator-classification.md b/doc/developer-guide/xlator-classification.md
new file mode 100644
index 00000000000..6073df9375f
--- /dev/null
+++ b/doc/developer-guide/xlator-classification.md
@@ -0,0 +1,221 @@
+# xlator categories and expectations
+
+The purpose of the document is to define a category for various xlators
+and expectations around what each category means from a perspective of
+health and maintenance of a xlator.
+
+The need to do this is to ensure certain categories are kept in good
+health, and helps the community and contributors focus their efforts around the
+same.
+
+This document also provides implementation details for xlator developers to
+declare a category for any xlator.
+
+## Table of contents
+1. Audience
+2. Categories (and expectations of each category)
+3. Implementation and usage details
+
+## Audience
+
+This document is intended for the following community participants,
+- New xlator contributors
+- Existing xlator maintainers
+- Packaging and gluster management stack maintainers
+
+For a more user facing understanding it is recommended to read section (TBD)
+in the gluster documentation.
+
+## Categories
+1. Experimental (E)
+2. TechPreview  (TP)
+3. Maintained (M)
+4. Deprecated (D)
+5. Obsolete (O)
+
+### Experimental (E)
+
+Developed in the experimental branch, for exploring new features. These xlators
+are NEVER packaged as a part of releases, interested users and contributors can
+build and work with these from sources. In the future, these maybe available as
+an package based on a weekly build of the same.
+
+#### Quality expectations
+- Compiles or passes smoke tests
+- Does not break nightly experimental regressions
+  - NOTE: If a nightly is broken, then all patches that were merged are reverted
+  till the errant patch is found and subsequently fixed
+
+### TechPreview (TP)
+
+Xlators in master or release branches that are not deemed fit to be in
+production deployments, but are feature complete to invite feedback and host
+user data.
+
+These xlators will be worked upon with priority by maintainers/authors who are
+involved in making them more stable than xlators in the Experimental/Deprecated/
+Obsolete categories.
+
+There is no guarantee that these xlators will move to the Maintained state, and
+may just get Obsoleted based on feedback, or other project goals or technical
+alternatives.
+
+#### Quality expectations
+- Same as Maintained, minus
+  - Performance, Scale, other(?)
+  - *TBD* *NOTE* Need inputs, Intention is all quality goals as in Maintained,
+  other than the list above (which for now has scale and performance)
+
+### Maintained (M)
+
+These xltors are part of the core Gluster functionality and are maintained
+actively. These are part of master and release branches and are higher in
+priority of maintainers and other interested contributors.
+
+#### Quality expectations
+
+NOTE: A short note on what each of these mean are added here, details to follow.
+
+NOTE: Out of the gate all of the following are not mandated, consider the
+following a desirable state to reach as we progress on each
+
+- Bug backlog: Actively address bug backlog
+- Enhancement backlog: Actively maintain outstanding enhancement backlog (need
+        not be acted on, but should be visible to all)
+- Review backlog: Actively keep this below desired counts and states
+- Static code health:  Actively meet near-zero issues in this regard
+  - Coverity, spellcheck and other checks
+- Runtime code health: Actively meet defined coverage levels in this regard
+  - Coverage, others?
+  - Per-patch regressions
+  - Glusto runs
+  - Performance
+  - Scalability
+- Technical specifications: Implementation details should be documented and
+        updated at regular cadence (even per patch that change assumptions in
+        here)
+- User documentation: User facing details should be maintained to current
+        status in the documentation
+- Debuggability: Steps, tools, procedures should be documented and maintained
+        each release/patch as applicable
+- Troubleshooting: Steps, tools, procedures should be documented and maintained
+        each release/patch as applicable
+  - Steps/guides for self service
+  - Knowledge base for problems
+- Other common criteria that will apply: Required metrics/desired states to be
+        defined per criteria
+  - Monitoring, usability, statedump, and other such xlator expectations
+
+### Deprecated (D)
+
+Xlators on master or release branches that would be obsoleted and/or replaced
+with similar or other functionality in the next major release.
+
+#### Quality expectations
+- Retain status-quo when moved to this state, till it is moved to obsoleted
+- Provide migration steps if feature provided by the xlator is replaced with
+other xlators
+
+### Obsolete (O)
+
+Xlator/code still in tree, but not packaged or shipped or maintained in any
+form. This is noted as a category till the code is removed from the tree.
+
+These xlators and their corresponding code and test health will not be executed.
+
+#### Quality expectations
+- None
+
+## Implementation and usage details
+
+### How to specify an xlators category
+
+While defining 'xlator_api_t' structure for the corresponding xlator, add a
+flag like below:
+
+```
+diff --git a/xlators/performance/nl-cache/src/nl-cache.c b/xlators/performance/nl-cache/src/nl-cache.c
+index 0f0e53bac2..8267d6897c 100644
+--- a/xlators/performance/nl-cache/src/nl-cache.c
++++ b/xlators/performance/nl-cache/src/nl-cache.c
+@@ -869,4 +869,5 @@ xlator_api_t xlator_api = {
+         .cbks          = &nlc_cbks,
+         .options       = nlc_options,
+         .identifier    = "nl-cache",
++        .category      = GF_TECH_PREVIEW,
+ };
+diff --git a/xlators/performance/quick-read/src/quick-read.c b/xlators/performance/quick-read/src/quick-read.c
+index 8d39720e7f..235de27c19 100644
+--- a/xlators/performance/quick-read/src/quick-read.c
++++ b/xlators/performance/quick-read/src/quick-read.c
+@@ -1702,4 +1702,5 @@ xlator_api_t xlator_api = {
+         .cbks          = &qr_cbks,
+         .options       = qr_options,
+         .identifier    = "quick-read",
++        .category      = GF_MAINTAINED,
+ };
+```
+
+Similarly, if a particular option is in different state other than
+the xlator state, one can add the same flag in options structure too.
+
+```
+diff --git a/xlators/cluster/afr/src/afr.c b/xlators/cluster/afr/src/afr.c
+index 0e86e33d03..81996743d1 100644
+--- a/xlators/cluster/afr/src/afr.c
++++ b/xlators/cluster/afr/src/afr.c
+@@ -772,6 +772,7 @@ struct volume_options options[] = {
+           .description = "Maximum latency for shd halo replication in msec."
+         },
+         { .key   = {"halo-enabled"},
++          .category = GF_TECH_PREVIEW,
+           .type  = GF_OPTION_TYPE_BOOL,
+           .default_value = "False",
+
+```
+
+
+### User experience using the categories
+
+#### Ability to use a category
+
+This section details which category of xlators can be used when and specifics
+around when each category is enabled.
+
+1. Maintained category xlators can be used by default, this implies, volumes
+created with these xlators enabled will throw no warnings, or need no user
+intervention to use the xlator.
+
+2. Tech Preview category xlators needs cluster configuration changes to allow
+these xlatorss to be used in volumes, further, logs will contain a message
+stating TP xlators are in use. Without the cluster configured to allow TP
+xlators, volumes created or edited to use such xlators would result in errors.
+  - (TBD) Cluster configuration option
+  - (TBD) Warning message
+  - (TBD) Code mechanics on how this is achieved
+
+3. Deprecated category xlators can be used by default, but will throw a warning
+in the logs that such are in use and will be deprecated in the future.
+  - (TBD) Warning message
+
+4. Obsolete category xlators will not be packaged and hence cannot be used from
+release builds.
+
+5. Experimental category xlators will not be packaged and hence cannot be used
+from release builds, if running experimental (weekly or other such) builds,
+these will throw a warning in the logs stating experimental xlators are in use.
+  - (TBD) Warning message
+
+#### Ability to query xlator category
+
+(TBD) Need to provide the ability to query xlator categories, or list xlators
+and their respective categories.
+
+#### User facing changes
+
+User facing changes that are expected due to this change include the following,
+- Cluster wide option to enable TP xlators, or more generically a category
+level of xlators
+- Errors in commands that fail due to invalid categories
+- Warning messages in logs to denote certain categories of xlators are in use
+- (TBD) Ability to query xlators and their respective categories
diff --git a/doc/features/ctime.md b/doc/features/ctime.md
new file mode 100644
index 00000000000..74a77abed4b
--- /dev/null
+++ b/doc/features/ctime.md
@@ -0,0 +1,68 @@
+# Consistent time attributes in gluster across replica/distribute
+
+
+#### Problem:
+Traditionally gluster has been using time attributes (ctime, atime, mtime) of files/dirs from bricks. The problem with this approach is that, it is not consisteant  across replica and distribute bricks. And applications which depend on it breaks as replica  might not  always return time attributes from same brick.
+
+Tar especially gives "file changed as we read it" whenever it detects ctime differences when stat is served from  different bricks. The way we have been trying to solve it is to serve  the stat structures from same brick in afr, max-time in dht. But it doesn't avoid the problem completely. Because there is no way to change ctime at the moment(lutimes() only allows mtime, atime), there is little we can do to make sure ctimes match after self-heals/xattr updates/rebalance.
+
+#### Solution Proposed:
+Store time attribues (ctime, mtime, atime) as an xattr of the file. The xattr is updated based
+on the fop. If a filesystem fop changes only mtime and ctime, update only those in xattr for
+that file.
+
+#### Design Overview:
+1) As part of each fop, top layer will generate a time stamp and pass it to the down along
+ with other information
+  - This will bring a dependency for NTP synced clients along with servers
+  - There can be a diff in time if the fop stuck in the xlator for various reason,
+for ex: because of locks.
+
+ 2)  On the server, posix layer stores the value in the memory (inode ctx) and will sync the data periodically to the disk as an extended attr
+  -  Of course sync call also will force it. And fop comes for an inode which is not linked, we do the sync immediately.
+
+ 3)  Each time when inodes are created or initialized it read the data from disk and store in inode ctx.
+
+ 4)  Before setting to inode_ctx we compare the timestamp stored and the timestamp received, and only store if the stored value is lesser than the current value.
+
+ 5)  So in best case data will be stored and retrieved from the memory. We replace the values in iatt with the values in inode_ctx.
+
+ 6)  File ops that changes the parent directory attr time need to be consistent across all the distributed directories across the subvolumes. (for eg: a create call will change ctime and mtime of parent dir)
+
+  - This has to handle separately because we only send the fop to the hashed subvolume.
+  - We can asynchronously send the timeupdate setattr fop to the other subvoumes and change the values for parent directory if the file fops is successful on hashed subvolume.
+  -  This will have a window where the times are inconsistent across dht subvolume (Please provide your suggestions)
+
+7)  Currently we have couple of mount options for time attributes like noatime, relatime , nodiratime etc. But we are not explicitly handled those options even if it is given as mount option when gluster mount.
+
+
+#### Implementation Overview:
+This features involves changes in following xlators.
+ - utime xlator
+ - posix xlator
+
+##### utime xlator:
+This is a new client side xlator which does following tasks.
+
+1. It will generate a time stamp and passes it down in frame->root->ctime  and over the network.
+2.  Based on fop, it also decides the time attributes to be updated and this passed using "frame->root->flags"
+
+    Patches:
+    1. https://review.gluster.org/#/c/19857/
+
+##### posix xlator:
+Following tasks are done in posix xlator:
+
+1. Provides APIs to set and get the xattr from backend. It also caches the xattr in inode context. During get, it updates time attributes stored in xattr into iatt structure.
+2. Based on the flags from utime xlator, relevant fops update the time attributes in the xattr.
+
+    Patches:
+    1. https://review.gluster.org/#/c/19267/
+    2. https://review.gluster.org/#/c/19795/
+    3. https://review.gluster.org/#/c/19796/
+
+#### Pending Work:
+1. Handling of time related mount options (noatime, realatime,etc)
+2. flag based create (depending on flags in open, create behaviour might change)
+3. Changes in dht for direcotory sync acrosss multiple subvolumes
+4. readdirp stat need to be worked on.
diff --git a/doc/gluster.8 b/doc/gluster.8
index d04c23d9e36..ba595edca15 100644
--- a/doc/gluster.8
+++ b/doc/gluster.8
@@ -35,10 +35,13 @@ The Gluster Console Manager is a command line utility for elastic volume managem
 \fB\ volume info [all|<VOLNAME>] \fR
 Display information about all volumes, or the specified volume.
 .TP
-\fB\ volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad|tierd]] [detail|clients|mem|inode|fd|callpool|tasks|client-list] \fR
+\fB\ volume list \fR
+List all volumes in cluster
+.TP
+\fB\ volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad]] [detail|clients|mem|inode|fd|callpool|tasks|client-list] \fR
 Display status of all or specified volume(s)/brick
 .TP
-\fB\ volume create <NEW-VOLNAME> [stripe <COUNT>] [replica <COUNT>] [disperse [<COUNT>]] [redundancy <COUNT>] [transport <tcp|rdma|tcp,rdma>] <NEW-BRICK> ... \fR
+\fB\ volume create <NEW-VOLNAME> [stripe <COUNT>] [[replica <COUNT> [arbiter <COUNT>]]|[replica 2 thin-arbiter 1]] [disperse [<COUNT>]] [disperse-data <COUNT>] [redundancy <COUNT>] [transport <tcp|rdma|tcp,rdma>] <NEW-BRICK> ... <TA-BRICK> \fR
 Create a new volume of the specified type using the specified bricks and transport type (the default transport type is tcp).
 To create a volume with both transports (tcp and rdma), give 'transport tcp,rdma' as an option.
 .TP
@@ -54,8 +57,17 @@ Stop the specified volume.
 \fB\ volume set <VOLNAME> <OPTION> <PARAMETER> [<OPTION> <PARAMETER>] ... \fR
 Set the volume options.
 .TP
-\fB\ volume get <VOLNAME> <OPTION/all>\fR
-Get the volume options.
+\fB\ volume get <VOLNAME/all> <OPTION/all> \fR
+Get the value of the all options or given option for volume <VOLNAME> or all option. gluster volume get all all is to get all global options
+.TP
+\fB\ volume reset <VOLNAME> [option] [force] \fR
+Reset all the reconfigured options
+.TP
+\fB\ volume barrier <VOLNAME> {enable|disable} \fR
+Barrier/unbarrier file operations on a volume
+.TP
+\fB\ volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}{inode [range]|entry [basename]|posix [range]} \fR
+Clear locks held on path
 .TP
 \fB\ volume help \fR
 Display help for the volume command.
@@ -73,6 +85,9 @@ If you remove the brick, the data stored in that brick will not be available. Yo
 .B replace-brick
 option.
 .TP
+\fB\ volume reset-brick <VOLNAME> <SOURCE-BRICK> {{start} | {<NEW-BRICK> commit}} \fR
+Brings down or replaces the specified source brick with the new brick.
+.TP
 \fB\ volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> commit force \fR
 Replace the specified source brick with a new brick.
 .TP
@@ -94,6 +109,18 @@ Locate the log file for corresponding volume/brick.
 .TP
 \fB\ volume log rotate <VOLNAME> [BRICK] \fB
 Rotate the log file for corresponding volume/brick.
+.TP
+\fB\ volume profile <VOLNAME> {start|info [peek|incremental [peek]|cumulative|clear]|stop} [nfs] \fR
+Profile operations on the volume. Once started, volume profile <volname> info provides cumulative statistics of the FOPs performed.
+.TP
+\fB\ volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick <brick>] [list-cnt <value>] | {read-perf|write-perf} [bs <size> count <count>] [brick <brick>] [list-cnt <value>] \fR
+Generates a profile of a volume representing the performance and bottlenecks/hotspots of each brick.
+.TP
+\fB\ volume statedump <VOLNAME> [[nfs|quotad] [all|mem|iobuf|callpool|priv|fd|inode|history]... | [client <hostname:process-id>]] \fR
+Dumps the in memory state of the specified process or the bricks of the volume.
+.TP
+\fB\ volume sync <HOSTNAME> [all|<VOLNAME>] \fR
+Sync the volume information from a peer
 .SS "Peer Commands"
 .TP
 \fB\ peer probe <HOSTNAME> \fR
@@ -105,27 +132,58 @@ Detach the specified peer.
 \fB\ peer status \fR
 Display the status of peers.
 .TP
+\fB\ pool list \fR
+List all the nodes in the pool (including localhost)
+.TP
 \fB\ peer help \fR
 Display help for the peer command.
-.SS "Tier Commands"
+.SS "Quota Commands"
+.TP
+\fB\ volume quota <VOLNAME> enable \fR
+Enable quota on the specified volume. This will cause all the directories in the filesystem hierarchy to be accounted and updated thereafter on each operation in the the filesystem. To kick start this accounting, a crawl is done over the hierarchy with an auxiliary client.
+.TP
+\fB\ volume quota <VOLNAME> disable \fR
+Disable quota on the volume. This will disable enforcement and accounting in the filesystem. Any configured limits will be lost.
 .TP
-\fB\ volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... \fR
-Attach to an existing volume a tier of specified type using the specified bricks.
+\fB\ volume quota <VOLNAME> limit-usage <PATH> <SIZE> [<PERCENT>] \fR
+Set a usage  limit on the given path. Any previously set limit is overridden to the new value. The soft limit can optionally be specified (as a percentage of hard limit). If soft limit percentage is not provided the default soft limit value for the volume is used to decide the soft limit.
 .TP
-\fB\ volume tier <VOLNAME> status \fR
-Display statistics on data migration between the hot and cold tiers.
+\fB\ volume quota <VOLNAME> limit-objects <PATH> <SIZE> [<PERCENT>] \fR
+Set an inode limit on the given path. Any previously set limit is overridden to the new value. The soft limit can optionally be specified (as a percentage of hard limit). If soft limit percentage is not provided the default soft limit value for the volume is used to decide the soft limit.
 .TP
-\fB\ volume tier <VOLNAME> detach start\fR
-Begin detaching the hot tier from the volume. Data will be moved from the hot tier to the cold tier.
+NOTE: valid units of SIZE are : B, KB, MB, GB, TB, PB. If no unit is specified, the unit defaults to bytes.
 .TP
-\fB\ volume tier <VOLNAME> detach commit [force]\fR
-Commit detaching the hot tier from the volume. The volume will revert to its original state before the hot tier was attached.
+\fB\ volume quota <VOLNAME> remove <PATH> \fR
+Remove any usage limit configured on the specified directory. Note that if any limit is configured on the ancestors of this directory (previous directories along the path), they will still be honored and enforced.
 .TP
-\fB\ volume tier <VOLNAME> detach status\fR
-Check status of data movement from the hot to cold tier.
+\fB\ volume quota <VOLNAME> remove-objects <PATH> \fR
+Remove any inode limit configured on the specified directory. Note that if any limit is configured on the ancestors of this directory (previous directories along the path), they will still be honored and enforced.
 .TP
-\fB\ volume tier <VOLNAME> detach stop\fR
-Stop detaching the hot tier from the volume.
+\fB\ volume quota <VOLNAME> list <PATH> \fR
+Lists the  usage and limits configured on directory(s). If a path is given only the limit that has been configured on the directory(if any) is displayed along with the directory's usage. If no path is given, usage and limits are displayed for all directories that has limits configured.
+.TP
+\fB\ volume quota <VOLNAME> list-objects <PATH> \fR
+Lists the inode usage and inode limits configured on directory(s). If a path is given only the limit that has been configured on the directory(if any) is displayed along with the directory's inode usage. If no path is given, usage and limits are displayed for all directories that has limits configured.
+.TP
+\fB\ volume quota <VOLNAME> default-soft-limit <PERCENT> \fR
+Set the percentage value for default soft limit for the volume.
+.TP
+\fB\ volume quota <VOLNAME> soft-timeout <TIME> \fR
+Set the soft timeout for the volume. The interval in which limits are retested before the soft limit is breached.
+.TP
+\fB\ volume quota <VOLNAME> hard-timeout <TIME> \fR
+Set the hard timeout for the volume. The interval in which limits are retested after the soft limit is breached.
+.TP
+\fB\ volume quota <VOLNAME> alert-time <TIME> \fR
+Set the frequency in which warning messages need to be logged (in the brick logs) once soft limit is breached.
+.TP
+\fB\ volume inode-quota <VOLNAME> enable/disable \fR
+Enable/disable inode-quota for <VOLNAME>
+.TP
+\fB\ volume quota help \fR
+Display help for volume quota commands
+.TP
+NOTE: valid units of time and their symbols are : hours(h/hr), minutes(m/min), seconds(s/sec), weeks(w/wk), Days(d/days).
 .SS "Geo-replication Commands"
 .TP
 \fI\ Note\fR: password-less ssh, from the master node (where these commands are executed) to the slave node <SLAVE_HOST>, is a prerequisite for the geo-replication commands.
@@ -133,8 +191,10 @@ Stop detaching the hot tier from the volume.
 \fB\ system:: execute gsec_create\fR
 Generates pem keys which are required for push-pem
 .TP
-\fB\ volume geo-replication <MASTER_VOL> <SLAVE_HOST>::<SLAVE_VOL> create [push-pem] [force]\fR
+\fB\ volume geo-replication <MASTER_VOL> <SLAVE_HOST>::<SLAVE_VOL> create [[ssh-port n][[no-verify]|[push-pem]]] [force]\fR
 Create a new geo-replication session from <MASTER_VOL> to <SLAVE_HOST> host machine having <SLAVE_VOL>.
+Use ssh-port n if custom SSH port is configured in slave nodes.
+Use no-verify if the rsa-keys of nodes in master volume is distributed to slave nodes through an external agent.
 Use push-pem to push the keys automatically.
 .TP
 \fB\ volume geo-replication <MASTER_VOL> <SLAVE_HOST>::<SLAVE_VOL> {start|stop} [force] \fR
@@ -158,17 +218,25 @@ Use "!<OPTION>" to reset option <OPTION> to default value.
 \fB\ volume bitrot <VOLNAME> {enable|disable} \fR
 Enable/disable bitrot for volume <VOLNAME>
 .TP
+\fB\ volume bitrot <VOLNAME> signing-time <time-in-secs> \fR
+Waiting time for an object after last fd is closed to start signing process.
+.TP
+\fB\ volume bitrot <VOLNAME> signer-threads <count> \fR
+Number of signing process threads. Usually set to number of available cores.
+.TP
 \fB\ volume bitrot <VOLNAME> scrub-throttle {lazy|normal|aggressive} \fR
 Scrub-throttle value is a measure of how fast or slow the scrubber scrubs the filesystem for volume <VOLNAME>
 .TP
-\fB\ volume bitrot <VOLNAME> scrub-frequency {daily|weekly|biweekly|monthly} \fR
+\fB\ volume bitrot <VOLNAME> scrub-frequency {hourly|daily|weekly|biweekly|monthly} \fR
 Scrub frequency for volume <VOLNAME>
 .TP
 \fB\ volume bitrot <VOLNAME> scrub {pause|resume|status|ondemand} \fR
 Pause/Resume scrub. Upon resume, scrubber continues where it left off. status option shows the statistics of scrubber. ondemand option starts the scrubbing immediately if the scrubber is not paused or already running.
 .TP
+\fB\ volume bitrot help \fR
+Display help for volume bitrot commands
+.TP
 .SS "Snapshot Commands"
-.PP
 .TP
 \fB\ snapshot create <snapname> <volname> [no-timestamp] [description <description>] [force] \fR
 Creates a snapshot of a GlusterFS volume. User can provide a snap-name and a description to identify the snap. Snap will be created by appending timestamp in GMT. User can override this behaviour using "no-timestamp" option. The description cannot be more than 1024 characters. To be able to take a snapshot, volume should be present and it should be in started state.
diff --git a/doc/glusterd.8 b/doc/glusterd.8
index 3ef7c2b72d1..e3768c78761 100644
--- a/doc/glusterd.8
+++ b/doc/glusterd.8
@@ -30,8 +30,8 @@ File to use for logging.
 \fB\-L <LOGLEVEL>, \fB\-\-log\-level=<LOGLEVEL>\fR
 Logging severity.  Valid options are TRACE, DEBUG, INFO, WARNING, ERROR and CRITICAL (the default is INFO).
 .TP
-\fB\-L, \fB\-\-localtime\-logging=on|off\fR
-Enable or disable localtime log timestamps. Valid options are on and off (the default is off).
+\fB\-\-localtime\-logging\fR
+Enable localtime log timestamps.
 .TP
 \fB\-\-debug\fR
 Run the program in debug mode. This option sets \fB\-\-no\-daemon\fR, \fB\-\-log\-level\fR to DEBUG
diff --git a/doc/glusterfs.8 b/doc/glusterfs.8
index 520150a55e9..3d359ea85e4 100644
--- a/doc/glusterfs.8
+++ b/doc/glusterfs.8
@@ -53,8 +53,8 @@ Maximum number of connect attempts to server. This option should be provided wit
 \fB\-\-acl\fR
 Mount the filesystem with POSIX ACL support.
 .TP
-\fB\-L, \fB\-\-localtime\-logging=on|off\fR
-Enable or disable localtime log timestamps. Valid options are on and off (the default is off).
+\fB\-\-localtime\-logging\fR
+Enable localtime log timestamps.
 .TP
 \fB\-\-debug\fR
 Run in debug mode.  This option sets \fB\-\-no\-daemon\fR, \fB\-\-log\-level\fR to DEBUG,
@@ -63,8 +63,8 @@ and \fB\-\-log\-file\fR to console.
 \fB\-\-enable\-ino32=BOOL\fR
 Use 32-bit inodes when mounting to workaround application that doesn't support 64-bit inodes.
 .TP
-\fB\-\-fopen\-keep\-cache\fR
-Do not purge the cache on file open.
+\fB\-\-fopen\-keep\-cache[=BOOL]\fR
+Do not purge the cache on file open (default: false).
 .TP
 \fB\-\-mac\-compat=BOOL\fR
 Provide stubs for attributes needed for seamless operation on Macs (the default is off).
@@ -109,6 +109,9 @@ Mount subdirectory instead of the '/' of volume.
 .PP
 .TP
 
+\fB\-\-attr\-times\-granularity=NANOSECONDS\fR
+Declare supported granularity of file attribute times (default is 0 which kernel handles as unspecified; valid real values are between 1 and 1000000000).
+.TP
 \fB\-\-attribute\-timeout=SECONDS\fR
 Set attribute timeout to SECONDS for inodes in fuse kernel module (the default is 1).
 .TP
@@ -118,8 +121,8 @@ Set fuse module's background queue length to N (the default is 64).
 \fB\-\-congestion\-threshold=N\fR
 Set fuse module's congestion threshold to N (the default is 48).
 .TP
-\fB\-\-direct\-io\-mode=BOOL\fR
-Enable/Disable the direct-I/O mode in fuse module (the default is enable).
+\fB\-\-direct\-io\-mode=BOOL|auto\fR
+Specify fuse direct I/O strategy (the default is auto).
 .TP
 \fB\-\-dump-fuse=PATH\f\R
 Dump fuse traffic to PATH
@@ -130,9 +133,17 @@ Set entry timeout to SECONDS in fuse kernel module (the default is 1).
 \fB\-\-gid\-timeout=SECONDS\fR
 Set auxiliary group list timeout to SECONDS for fuse translator (the default is 0).
 .TP
+\fB\-\-kernel-writeback-cache=BOOL\fR
+Enable fuse in-kernel writeback cache.
+.TP
 \fB\-\-negative\-timeout=SECONDS\fR
 Set negative timeout to SECONDS in fuse kernel module (the default is 0).
 .TP
+\fB\-\-auto\-invalidation=BOOL\fR
+controls whether fuse-kernel can auto-invalidate attribute, dentry and
+page-cache. Disable this only if same files/directories are not
+accessed across two different mounts concurrently [default: on].
+.TP
 \fB\-\-volfile-check\fR
 Enable strict volume file checking.
 
diff --git a/doc/glusterfsd.8 b/doc/glusterfsd.8
index c5a95d1611f..bc1de2a8c80 100644
--- a/doc/glusterfsd.8
+++ b/doc/glusterfsd.8
@@ -51,8 +51,8 @@ Server to get the volume from.  This option overrides \fB\-\-volfile option
 .PP
 .TP
 
-\fB\-L, \fB\-\-localtime\-logging=on|off\fR
-Enable or disable localtime log timestamps. Valid options are on and off (the default is off).
+\fB\-\-localtime\-logging\fR
+Enable localtime log timestamps.
 .TP
 \fB\-\-debug\fR
 Run in debug mode.  This option sets \fB\-\-no\-daemon\fR, \fB\-\-log\-level\fR to DEBUG
@@ -107,6 +107,11 @@ Enable/Disable direct-io mode in fuse module [default: enable]
 .TP
 \fB\-\-resolve-gids\fR
 Resolve all auxiliary groups in fuse translator (max 32 otherwise)
+.TP
+\fB\-\-auto\-invalidation=BOOL\fR
+controls whether fuse-kernel can auto-invalidate attribute, dentry and
+page-cache. Disable this only if same files/directories are not
+accessed across two different mounts concurrently [default: on]
 
 .SS "Miscellaneous Options"
 .PP
diff --git a/doc/mount.glusterfs.8 b/doc/mount.glusterfs.8
index e16bbecb8b0..ce16e9e40b7 100644
--- a/doc/mount.glusterfs.8
+++ b/doc/mount.glusterfs.8
@@ -44,8 +44,8 @@ INFO and NONE [default: INFO]
 \fBacl
 Mount the filesystem with POSIX ACL support
 .TP
-\fBfopen\-keep\-cache
-Do not purge the cache on file open
+\fBfopen\-keep\-cache[=BOOL]
+Do not purge the cache on file open (default: false)
 .TP
 \fBworm
 Mount the filesystem in 'worm' mode
@@ -65,6 +65,9 @@ Enable internal memory accounting
 .TP
 \fBcapability
 Enable file capability setting and retrival
+.TP
+\fBthin-client
+Enables thin mount and connects via gfproxyd daemon
 
 .PP
 .SS "Advanced options"
@@ -89,8 +92,8 @@ Set negative timeout to SECONDS in fuse kernel module [default: 0]
 Volume name to be used for MOUNT-POINT [default: top most volume in
 VOLUME-FILE]
 .TP
-\fBdirect\-io\-mode=\fRdisable
-Disable direct I/O mode in fuse kernel module
+\fBdirect\-io\-mode=\fRBOOL|auto
+Specify fuse direct I/O strategy [default: auto]
 .TP
 \fBcongestion\-threshold=\fRN
 Set fuse module's congestion threshold to N [default: 48]
@@ -119,6 +122,15 @@ Provide list of backup volfile servers in the following format [default: None]
 \fBDeprecated\fR option - placed here for backward compatibility [default: 1]
 .TP
 .TP
+\fBlru-limit=\fRN
+Set fuse module's limit for number of inodes kept in LRU list to N [default: 65536]
+.TP
+.TP
+\fBinvalidate-limit=\fRN
+Suspend fuse invalidations implied by 'lru-limit' if  number of outstanding
+invalidations reaches N
+.TP
+.TP
 \fBbackground-qlen=\fRN
 Set fuse module's background queue length to N [default: 64]
 .TP
@@ -130,6 +142,20 @@ enable root squashing for the trusted client [default: on]
 .TP
 \fBuse\-readdirp=\fRBOOL
 Use readdirp() mode in fuse kernel module [default: on]
+.TP
+\fBdump\-fuse=\fRPATH
+Dump fuse traffic to PATH
+.TP
+\fBkernel\-writeback\-cache=\fRBOOL
+Enable fuse in-kernel writeback cache [default: off]
+.TP
+\fBattr\-times\-granularity=\fRNS
+Declare supported granularity of file attribute [default: 0]
+.TP
+\fBauto\-invalidation=\fRBOOL
+controls whether fuse-kernel can auto-invalidate attribute, dentry and
+page-cache. Disable this only if same files/directories are not
+accessed across two different mounts concurrently [default: on]
 .PP
 .SH FILES
 .TP
diff --git a/doc/release-notes/3.12.0.md b/doc/release-notes/3.12.0.md
deleted file mode 100644
index da5deb1826d..00000000000
--- a/doc/release-notes/3.12.0.md
+++ /dev/null
@@ -1,437 +0,0 @@
-# Release notes for Gluster 3.12.0
-
-This is a major Gluster release that includes, ability to mount sub-directories
-using the Gluster native protocol (FUSE), further brick multiplexing
-enhancements that help scale to larger brick counts per node, enhancements to
-gluster get-state CLI enabling better understanding of various bricks and nodes
-participation/roles in the cluster, ability to resolve GFID split-brain using
-existing CLI, easier GFID to real path mapping thus enabling easier diagnostics
-and correction for reported GFID issues (healing among other uses where GFID is
-the only available source for identifying a file), and other changes and fixes.
-
-The most notable features and changes are documented on this page. A full list
-of bugs that have been addressed is included further below.
-
-Further, as 3.11 release is a short term maintenance release, features included
-in that release are available with 3.12 as well, and could be of interest to
-users upgrading to 3.12 from older than 3.11 releases. The 3.11 [release notes](https://gluster.readthedocs.io/en/latest/release-notes/)
-captures the list of features that were introduced with 3.11.
-
-## Major changes and features
-
-### Ability to mount sub-directories using the Gluster FUSE protocol
-**Notes for users:**
-
-With this release, it is possible define sub-directories to be mounted by
-specific clients and additional granularity in the form of clients to mount
-only that portion of the volume for access.
-
-Until recently, Gluster FUSE mounts enabled mounting the entire volume on the
-client. This feature helps sharing a volume among the multiple consumers along
-with enabling restricting access to the sub-directory of choice.
-
-Option controlling sub-directory allow/deny rules can be set as follows:
-```
-# gluster volume set <volname> auth.allow "/subdir1(192.168.1.*),/(192.168.10.*),/subdir2(192.168.8.*)"
-```
-
-How to mount from the client:
-```
-# mount -t glusterfs <hostname>:/<volname>/<subdir> /<mount_point>
-```
-Or,
-```
-# mount -t glusterfs <hostname>:/<volname> -osubdir_mount=<subdir> /<mount_point>
-```
-
-**Limitations:**
-
-- There are no throttling or QoS support for this feature. The feature will
-just provide the namespace isolation for the different clients.
-
-**Known Issues:**
-
-- Once we cross more than 1000s of subdirs in 'auth.allow' option, the
-performance of reconnect / authentication would be impacted.
-
-### GFID to path conversion is enabled by default
-**Notes for users:**
-
-Prior to this feature, only when quota was enabled, did the on disk data have
-pointers back from GFID to their respective filenames. As a result, if there
-were a need to locate the path given a GFID, quota had to be enabled.
-
-The change brought in by this feature, is to enable this on disk data to be
-present, for all cases, than just quota. Further, enhancements here have been
-to improve the manner of storing this information on disk as extended
-attributes.
-
-The internal on disk xattr that is now stored to reference the filename and
-parent for a GFID is, `trusted.gfid2path.<xxhash>`
-
-This feature is enabled by default with this release.
-
-**Limitations:**
-
-None
-
-**Known Issues:**
-
-None
-
-### Various enhancements have been made to the output of get-state CLI command
-**Notes for users:**
-
-The command `#gluster get-state` has been enhanced to output more information
-as below,
-- Arbiter bricks are marked more clearly in a volume that has the feature
-enabled
-- Ability to get all volume options (both set and defaults) in the get-state
-output
-- Rebalance time estimates, for ongoing rebalance, is captured in the get-state
-output
-- If geo-replication is configured, then get-state now captures the session
-details of the same
-
-**Limitations:**
-
-None
-
-**Known Issues:**
-
-None
-
-### Provided an option to set a limit on number of bricks multiplexed in a processes
-**Notes for users:**
-
-This release includes a global option to be switched on only if brick
-multiplexing is enabled for the cluster. The introduction of this option allows
-the user to control the number of bricks that are multiplexed in a process on a
-node. If the limit set by this option is insufficient for a single process,
-more processes are spawned for the subsequent bricks.
-
-Usage:
-```
-#gluster volume set all cluster.max-bricks-per-process <value>
-```
-
-### Provided an option to use localtime timestamps in log entries
-**Limitations:**
-
-Gluster defaults to UTC timestamps. glusterd, glusterfsd, and server-side
-glusterfs daemons will use UTC until one of,
-1. command line option is processed,
-2. gluster config (/var/lib/glusterd/options) is loaded,
-3. admin manually sets localtime-logging (cluster.localtime-logging, e.g.
-`#gluster volume set all cluster.localtime-logging enable`).
-
-There is no mount option to make the FUSE client enable localtime logging.
-
-There is no option in gfapi to enable localtime logging.
-
-### Enhanced the option to export statfs data for bricks sharing the same backend filesystem
-
-**Notes for users:**
-In the past 'storage/posix' xlator had an option called option
-`export-statfs-size`, which, when set to 'no', exports zero as values for few
-fields in `struct statvfs`. These are typically reflected in an output of `df`
-command, from a user perspective.
-
-When backend bricks are shared between multiple brick processes, the values
-of these variables have been corrected to reflect
-`field_value / number-of-bricks-at-node`. Thus enabling better usage reporting
-and also enhancing the ability for file placement in the distribute translator
-when used with the option `min-free-disk`.
-
-### Provided a means to resolve GFID split-brain using the gluster CLI
-**Notes for users:**
-
-The existing CLI commands to heal files under split-brain did not handle cases
-where there was a GFID mismatch between the files. With the provided enhancement
-the same CLI commands can now address GFID split-brain situations based on the
-choices provided.
-
-The CLI options that are enhanced to help with this situation are,
-```
-volume heal <VOLNAME> split-brain {bigger-file <FILE> |
-	latest-mtime <FILE> |
-	source-brick <HOSTNAME:BRICKNAME> [<FILE>]}
-```
-
-**Limitations:**
-
-None
-
-**Known Issues:**
-
-None
-
-### Developer related: Added a 'site.h' for more vendor/company specific defaults
-**Notes for developers:**
-
-**NOTE**: Also relevant for users building from sources and needing different
-defaults for some options
-
-Most people consume Gluster in one of two ways:
-* From packages provided by their OS/distribution vendor
-* By building themselves from source
-
-For the first group it doesn't matter whether configuration is done in a
-configure script, via command-line options to that configure script, or in a
-header file. All of these end up as edits to some file under the packager's
-control, which is then run through their tools and process (e.g. rpmbuild) to
-create the packages that users will install.
-
-For the second group, convenience matters. Such users might not even have a
-script wrapped around the configure process, and editing one line in a header
-file is a lot easier than editing several in the configure script. This also
-prevents a messy profusion of configure options, dozens of which might need to
-be added to support a single such user's preferences. This comes back around as
-greater simplicity for packagers as well. This patch defines site.h as the
-header file for options and parameters that someone building the code for
-themselves might want to tweak.
-
-The project ships one version to reflect the developers' guess at the best
-defaults for most users, and sophisticated users with unusual needs can
-override many options at once just by maintaining their own version of that
-file. Further guidelines for how to determine whether an option should go in
-configure.ac or site.h are explained within site.h itself.
-
-### Developer related: Added xxhash library to libglusterfs for required use
-**Notes for developers:**
-
-Function gf_xxh64_wrapper has been added as a wrapper into libglusterfs for
-consumption by interested developers.
-
-Reference to code can be found [here](https://github.com/gluster/glusterfs/blob/v3.12.0alpha1/libglusterfs/src/common-utils.h#L835)
-
-### Developer related: glfs_ipc API in libgfapi is removed as a public interface
-**Notes for users:**
-
-glfs_ipc API was maintained as a public API in the GFAPI libraries. This has
-been removed as a public interface, from this release onwards.
-
-Any application, written directly to consume gfapi as a means of interfacing
-with Gluster, using the mentioned API, would need to be modified to adapt to
-this change.
-
-**NOTE:** As of this release there are no known public consumers of this
-API
-
-## Major issues
-1. Expanding a gluster volume that is sharded may cause file corruption
-    - Sharded volumes are typically used for VM images, if such volumes are
-  expanded or possibly contracted (i.e add/remove bricks and rebalance) there
-  are reports of VM images getting corrupted.
-    - The last known cause for corruption (Bug #1465123) has a fix with this
-  release. As further testing is still in progress, the issue is retained as
-  a major issue.
-    - Status of this bug can be tracked here, #1465123
-
-## Bugs addressed
-
-Bugs addressed since release-3.11.0 are listed below.
-
-- [#1047975](https://bugzilla.redhat.com/1047975): glusterfs/extras: add a convenience script to label (selinux) gluster bricks
-- [#1254002](https://bugzilla.redhat.com/1254002): [RFE] Have named pthreads for easier debugging
-- [#1318100](https://bugzilla.redhat.com/1318100): RFE : SELinux translator to support setting SELinux contexts on files in a glusterfs volume
-- [#1318895](https://bugzilla.redhat.com/1318895): Heal info shows incorrect status
-- [#1326219](https://bugzilla.redhat.com/1326219): Make Gluster/NFS an optional component
-- [#1356453](https://bugzilla.redhat.com/1356453): DHT: slow readdirp performance
-- [#1366817](https://bugzilla.redhat.com/1366817): AFR returns the node uuid of the same node for every file in the replica
-- [#1381970](https://bugzilla.redhat.com/1381970): GlusterFS Daemon stops working after a longer runtime and higher file workload due to design flaws?
-- [#1400924](https://bugzilla.redhat.com/1400924): [RFE] Rsync flags for performance improvements
-- [#1402406](https://bugzilla.redhat.com/1402406): Client stale file handle error in dht-linkfile.c under SPEC SFS 2014 VDA workload
-- [#1414242](https://bugzilla.redhat.com/1414242): [whql][virtio-block+glusterfs]"Disk Stress" and "Disk Verification" job always failed on win7-32/win2012/win2k8R2 guest
-- [#1421938](https://bugzilla.redhat.com/1421938): systemic testing: seeing lot of ping time outs  which would lead to splitbrains
-- [#1424817](https://bugzilla.redhat.com/1424817): Fix wrong operators, found by coverty
-- [#1428061](https://bugzilla.redhat.com/1428061): Halo Replication feature for AFR translator
-- [#1428673](https://bugzilla.redhat.com/1428673): possible repeatedly  recursive healing of same file with background heal not happening when IO is going on
-- [#1430608](https://bugzilla.redhat.com/1430608): [RFE] Pass slave volume in geo-rep as read-only
-- [#1431908](https://bugzilla.redhat.com/1431908): Enabling parallel-readdir causes dht linkto files to be visible on the mount,
-- [#1433906](https://bugzilla.redhat.com/1433906): quota: limit-usage command failed  with error " Failed to start aux mount"
-- [#1437748](https://bugzilla.redhat.com/1437748): Spacing issue in fix-layout status output
-- [#1438966](https://bugzilla.redhat.com/1438966): Multiple bricks WILL crash after TCP port probing
-- [#1439068](https://bugzilla.redhat.com/1439068): Segmentation fault when creating a qcow2 with qemu-img
-- [#1442569](https://bugzilla.redhat.com/1442569): Implement Negative lookup cache feature to improve create performance
-- [#1442788](https://bugzilla.redhat.com/1442788): Cleanup timer wheel in glfs_fini()
-- [#1442950](https://bugzilla.redhat.com/1442950): RFE: Enhance handleops readdirplus operation to return handles along with dirents
-- [#1444596](https://bugzilla.redhat.com/1444596): [Brick Multiplexing] : Bricks for multiple volumes going down after glusterd restart and not coming back up after volume start force
-- [#1445609](https://bugzilla.redhat.com/1445609): [perf-xlators/write-behind] write-behind-window-size could be set greater than its allowed MAX value 1073741824
-- [#1446172](https://bugzilla.redhat.com/1446172): Brick Multiplexing :- resetting a brick bring down other bricks with same PID
-- [#1446362](https://bugzilla.redhat.com/1446362): cli xml status of detach tier broken
-- [#1446412](https://bugzilla.redhat.com/1446412): error-gen don't need to convert error string to int in every fop
-- [#1446516](https://bugzilla.redhat.com/1446516): [Parallel Readdir] : Mounts fail when performance.parallel-readdir is set to "off"
-- [#1447116](https://bugzilla.redhat.com/1447116): gfapi exports non-existing glfs_upcall_inode_get_event symbol
-- [#1447266](https://bugzilla.redhat.com/1447266): [snapshot cifs]ls on .snaps directory is throwing input/output error over cifs mount
-- [#1447389](https://bugzilla.redhat.com/1447389): Brick Multiplexing: seeing Input/Output Error for .trashcan
-- [#1447609](https://bugzilla.redhat.com/1447609): server: fd should be refed before put into fdtable
-- [#1447630](https://bugzilla.redhat.com/1447630): Don't allow rebalance/fix-layout operation on sharding enabled volumes till dht+sharding bugs are fixed
-- [#1447826](https://bugzilla.redhat.com/1447826): potential endless loop in function glusterfs_graph_validate_options
-- [#1447828](https://bugzilla.redhat.com/1447828): Should use dict_set_uint64 to set fd->pid when dump fd's info to dict
-- [#1447953](https://bugzilla.redhat.com/1447953): Remove inadvertently merged IPv6 code
-- [#1447960](https://bugzilla.redhat.com/1447960): [Tiering]: High and low watermark values  when set to the same level, is allowed
-- [#1447966](https://bugzilla.redhat.com/1447966): 'make cscope' fails on a clean tree due to missing generated XDR files
-- [#1448150](https://bugzilla.redhat.com/1448150): USS: stale snap entries are seen when activation/deactivation performed during one of the glusterd's unavailability
-- [#1448265](https://bugzilla.redhat.com/1448265): use common function iov_length to instead of duplicate code
-- [#1448293](https://bugzilla.redhat.com/1448293): Implement FALLOCATE FOP for EC
-- [#1448299](https://bugzilla.redhat.com/1448299): Mismatch in checksum of the image file after copying to a new image file
-- [#1448364](https://bugzilla.redhat.com/1448364): limited throughput with disperse volume over small number of bricks
-- [#1448640](https://bugzilla.redhat.com/1448640): Seeing error "Failed to get the total number of files. Unable to estimate time to complete rebalance" in rebalance logs
-- [#1448692](https://bugzilla.redhat.com/1448692): use GF_ATOMIC to generate callid
-- [#1448804](https://bugzilla.redhat.com/1448804): afr: include quorum type and count when dumping afr priv
-- [#1448914](https://bugzilla.redhat.com/1448914): [geo-rep]: extended attributes are not synced if the entry and extended attributes are done within changelog roleover/or entry sync
-- [#1449008](https://bugzilla.redhat.com/1449008): remove useless options from glusterd's volume set table
-- [#1449232](https://bugzilla.redhat.com/1449232): race condition between client_ctx_get and client_ctx_set
-- [#1449329](https://bugzilla.redhat.com/1449329): When either killing or restarting a brick with performance.stat-prefetch on, stat sometimes returns a bad st_size value.
-- [#1449348](https://bugzilla.redhat.com/1449348): disperse seek does not correctly handle the end of file
-- [#1449495](https://bugzilla.redhat.com/1449495): glfsheal: crashed(segfault) with disperse volume in RDMA
-- [#1449610](https://bugzilla.redhat.com/1449610): [New] - Replacing an arbiter brick while I/O happens  causes vm pause
-- [#1450010](https://bugzilla.redhat.com/1450010): [gluster-block]:Need a volume group profile option for gluster-block volume to add necessary options to be added.
-- [#1450559](https://bugzilla.redhat.com/1450559): Error 0-socket.management: socket_poller XX.XX.XX.XX:YYY failed (Input/output error) during any volume operation
-- [#1450630](https://bugzilla.redhat.com/1450630): [brick multiplexing] detach a brick if posix health check thread complaints about underlying brick
-- [#1450730](https://bugzilla.redhat.com/1450730): Add tests/basic/afr/gfid-mismatch-resolution-with-fav-child-policy.t to bad tests
-- [#1450975](https://bugzilla.redhat.com/1450975): Fix on demand file migration from client
-- [#1451083](https://bugzilla.redhat.com/1451083): crash in dht_rmdir_do
-- [#1451162](https://bugzilla.redhat.com/1451162): dht: Make throttle option "normal" value uniform across dht_init and dht_reconfigure
-- [#1451248](https://bugzilla.redhat.com/1451248): Brick Multiplexing: On reboot of a node Brick multiplexing feature lost on that node as multiple brick processes get spawned
-- [#1451588](https://bugzilla.redhat.com/1451588): [geo-rep + nl]: Multiple crashes observed on slave with "nlc_lookup_cbk"
-- [#1451724](https://bugzilla.redhat.com/1451724): glusterfind pre crashes with "UnicodeDecodeError: 'utf8' codec can't decode" error when the `--no-encode` is used
-- [#1452006](https://bugzilla.redhat.com/1452006): tierd listens to a port.
-- [#1452084](https://bugzilla.redhat.com/1452084): [Ganesha] : Stale linkto files after unsuccessfuly hardlinks
-- [#1452102](https://bugzilla.redhat.com/1452102): [DHt] : segfault in dht_selfheal_dir_setattr  while running regressions
-- [#1452378](https://bugzilla.redhat.com/1452378): Cleanup unnecessary logs in fix_quorum_options
-- [#1452527](https://bugzilla.redhat.com/1452527): Shared volume doesn't get mounted on few nodes after rebooting all nodes in cluster.
-- [#1452956](https://bugzilla.redhat.com/1452956): glusterd on a node crashed after running volume profile command
-- [#1453151](https://bugzilla.redhat.com/1453151): [RFE] glusterfind: add --end-time and --field-separator options
-- [#1453977](https://bugzilla.redhat.com/1453977): Brick Multiplexing: Deleting brick directories of the base volume must gracefully detach from glusterfsd without impacting other volumes IO(currently seeing transport end point error)
-- [#1454317](https://bugzilla.redhat.com/1454317): [Bitrot]: Brick process crash observed while trying to recover a bad file in disperse volume
-- [#1454375](https://bugzilla.redhat.com/1454375): ignore incorrect uuid validation in gd_validate_mgmt_hndsk_req
-- [#1454418](https://bugzilla.redhat.com/1454418): Glusterd segmentation fault in ' _Unwind_Backtrace' while running peer probe
-- [#1454701](https://bugzilla.redhat.com/1454701): DHT: Pass errno as an argument to gf_msg
-- [#1454865](https://bugzilla.redhat.com/1454865): [Brick Multiplexing] heal info shows the status of the bricks as  "Transport endpoint is not connected" though bricks are up
-- [#1454872](https://bugzilla.redhat.com/1454872): [Geo-rep]: Make changelog batch size configurable
-- [#1455049](https://bugzilla.redhat.com/1455049): [GNFS+EC] Unable to release the lock when the other client tries to acquire the lock on the same file
-- [#1455104](https://bugzilla.redhat.com/1455104): dht: dht self heal fails with no hashed subvol error
-- [#1455179](https://bugzilla.redhat.com/1455179): [Geo-rep]: Log time taken to sync entry ops, metadata ops and data ops for each batch
-- [#1455301](https://bugzilla.redhat.com/1455301): gluster-block is not working as expected when shard is enabled
-- [#1455559](https://bugzilla.redhat.com/1455559): [Geo-rep]: METADATA errors are seen even though everything is in sync
-- [#1455831](https://bugzilla.redhat.com/1455831): libglusterfs: updates old comment for 'arena_size'
-- [#1456361](https://bugzilla.redhat.com/1456361): DHT : for many operation directory/file path is  '(null)' in brick  log
-- [#1456385](https://bugzilla.redhat.com/1456385): glusterfs client crash on io-cache.so(__ioc_page_wakeup+0x44)
-- [#1456405](https://bugzilla.redhat.com/1456405): Brick Multiplexing:dmesg shows request_sock_TCP: Possible SYN flooding on port 49152 and memory related backtraces
-- [#1456582](https://bugzilla.redhat.com/1456582): "split-brain observed [Input/output error]" error messages in samba logs during parallel rm -rf
-- [#1456653](https://bugzilla.redhat.com/1456653): nlc_lookup_cbk floods logs
-- [#1456898](https://bugzilla.redhat.com/1456898): Regression test for add-brick failing with brick multiplexing enabled
-- [#1457202](https://bugzilla.redhat.com/1457202): Use of force with volume start, creates brick directory even it is not present
-- [#1457808](https://bugzilla.redhat.com/1457808): all: spelling errors (debian package maintainer)
-- [#1457812](https://bugzilla.redhat.com/1457812): extras/hook-scripts: non-portable shell syntax (debian package maintainer)
-- [#1457981](https://bugzilla.redhat.com/1457981): client fails to connect to the brick due to an incorrect port reported back by glusterd
-- [#1457985](https://bugzilla.redhat.com/1457985): Rebalance estimate time sometimes shows negative values
-- [#1458127](https://bugzilla.redhat.com/1458127): Upcall missing invalidations
-- [#1458193](https://bugzilla.redhat.com/1458193): Implement seek() fop in trace translator
-- [#1458197](https://bugzilla.redhat.com/1458197): io-stats usability/performance statistics enhancements
-- [#1458539](https://bugzilla.redhat.com/1458539): [Negative Lookup]: negative lookup features doesn't seem to work on restart of volume
-- [#1458582](https://bugzilla.redhat.com/1458582): add all as volume option in gluster volume get usage
-- [#1458768](https://bugzilla.redhat.com/1458768): [Perf] 35% drop in small file creates on smbv3 on *2
-- [#1459402](https://bugzilla.redhat.com/1459402): brick process crashes while running bug-1432542-mpx-restart-crash.t in a loop
-- [#1459530](https://bugzilla.redhat.com/1459530): [RFE] Need a way to resolve gfid split brains
-- [#1459620](https://bugzilla.redhat.com/1459620): [geo-rep]: Worker crashed with TypeError: expected string or buffer
-- [#1459781](https://bugzilla.redhat.com/1459781): Brick Multiplexing:Even clean Deleting of the brick directories of base volume is resulting in posix health check errors(just as we see in ungraceful delete methods)
-- [#1459971](https://bugzilla.redhat.com/1459971): posix-acl: Whitelist virtual ACL xattrs
-- [#1460225](https://bugzilla.redhat.com/1460225): Not cleaning up stale socket file is resulting in spamming glusterd logs with warnings of "got disconnect from stale rpc"
-- [#1460514](https://bugzilla.redhat.com/1460514): [Ganesha] : Ganesha crashes while cluster enters failover/failback mode
-- [#1460585](https://bugzilla.redhat.com/1460585): Revert CLI restrictions on running rebalance in VM store use case
-- [#1460638](https://bugzilla.redhat.com/1460638): ec-data-heal.t fails with brick mux enabled
-- [#1460659](https://bugzilla.redhat.com/1460659): Avoid one extra call of l(get|list)xattr system call after use buffer in posix_getxattr
-- [#1461129](https://bugzilla.redhat.com/1461129): malformed cluster.server-quorum-ratio setting can lead to split brain
-- [#1461648](https://bugzilla.redhat.com/1461648): Update GlusterFS README
-- [#1461655](https://bugzilla.redhat.com/1461655): glusterd crashes when statedump is taken
-- [#1461792](https://bugzilla.redhat.com/1461792): lk fop succeeds even when lock is not acquired on at least quorum number of bricks
-- [#1461845](https://bugzilla.redhat.com/1461845): [Bitrot]: Inconsistency seen with 'scrub ondemand' - fails to trigger scrub
-- [#1462200](https://bugzilla.redhat.com/1462200): glusterd status showing failed when it's stopped in  RHEL7
-- [#1462241](https://bugzilla.redhat.com/1462241): glusterfind: syntax error due to uninitialized variable 'end'
-- [#1462790](https://bugzilla.redhat.com/1462790): with AFR now making both nodes to return UUID for a file will result in georep consuming more resources
-- [#1463178](https://bugzilla.redhat.com/1463178): [Ganesha]Bricks got crashed  while running posix compliance test suit on V4 mount
-- [#1463365](https://bugzilla.redhat.com/1463365): Changes for Maintainers 2.0
-- [#1463648](https://bugzilla.redhat.com/1463648): Use GF_XATTR_LIST_NODE_UUIDS_KEY to figure out local subvols
-- [#1464072](https://bugzilla.redhat.com/1464072): cns-brick-multiplexing: brick process fails to restart after gluster pod failure
-- [#1464091](https://bugzilla.redhat.com/1464091): Regression: Heal info takes longer time when a brick is down
-- [#1464110](https://bugzilla.redhat.com/1464110): [Scale] : Rebalance ETA (towards the end) may be inaccurate,even on a moderately large data set.
-- [#1464327](https://bugzilla.redhat.com/1464327): glusterfs client crashes when reading large directory
-- [#1464359](https://bugzilla.redhat.com/1464359): selfheal deamon cpu consumption not reducing when IOs are going on and  all redundant bricks are brought down one after another
-- [#1465024](https://bugzilla.redhat.com/1465024): glusterfind: DELETE path needs to be unquoted before further processing
-- [#1465075](https://bugzilla.redhat.com/1465075): Fd based fops fail with EBADF on file migration
-- [#1465214](https://bugzilla.redhat.com/1465214): build failed with GF_DISABLE_MEMPOOL
-- [#1465559](https://bugzilla.redhat.com/1465559): multiple brick processes seen on gluster(fs)d restart in brick multiplexing
-- [#1466037](https://bugzilla.redhat.com/1466037): Fuse mount crashed with continuous dd on a file and reading the file in parallel
-- [#1466110](https://bugzilla.redhat.com/1466110): dht_rename_lock_cbk crashes in upstream regression test
-- [#1466188](https://bugzilla.redhat.com/1466188): Add scripts to analyze quota xattr in backend and identify accounting issues
-- [#1466785](https://bugzilla.redhat.com/1466785): assorted typos and spelling mistakes from Debian lintian
-- [#1467209](https://bugzilla.redhat.com/1467209): [Scale] : Rebalance ETA shows the initial estimate to be ~140 days,finishes within 18 hours though.
-- [#1467277](https://bugzilla.redhat.com/1467277): [GSS] [RFE] add documentation on --xml and --mode=script options to gluster interactive help and man pages
-- [#1467313](https://bugzilla.redhat.com/1467313): cthon04 can cause segfault in gNFS/NLM
-- [#1467513](https://bugzilla.redhat.com/1467513): CIFS:[USS]: .snaps is not accessible from the CIFS client after volume stop/start
-- [#1467718](https://bugzilla.redhat.com/1467718): [Geo-rep]: entry failed to sync to slave with ENOENT errror
-- [#1467841](https://bugzilla.redhat.com/1467841): gluster volume status --xml fails when there are 100 volumes
-- [#1467986](https://bugzilla.redhat.com/1467986): possible memory leak in glusterfsd with multiplexing
-- [#1468191](https://bugzilla.redhat.com/1468191): Enable stat-prefetch in group virt
-- [#1468261](https://bugzilla.redhat.com/1468261): Regression: non-disruptive(in-service) upgrade on EC volume fails
-- [#1468279](https://bugzilla.redhat.com/1468279): metadata heal not happening despite having an active sink
-- [#1468291](https://bugzilla.redhat.com/1468291): NFS Sub directory is getting mounted on solaris 10 even when the permission is restricted in nfs.export-dir volume option
-- [#1468432](https://bugzilla.redhat.com/1468432): tests: fix stats-dump.t failure
-- [#1468433](https://bugzilla.redhat.com/1468433): rpc: include current second in timed out frame cleanup on client
-- [#1468863](https://bugzilla.redhat.com/1468863): Assert in mem_pools_fini during libgfapi-fini-hang.t on NetBSD
-- [#1469029](https://bugzilla.redhat.com/1469029): Rebalance hangs on remove-brick if the target volume changes
-- [#1469179](https://bugzilla.redhat.com/1469179): invoke checkpatch.pl with strict
-- [#1469964](https://bugzilla.redhat.com/1469964): cluster/dht: Fix hardlink migration failures
-- [#1470170](https://bugzilla.redhat.com/1470170): mem-pool: mem_pool_fini() doesn't release entire memory allocated
-- [#1470220](https://bugzilla.redhat.com/1470220): glusterfs process leaking memory when error occurs
-- [#1470489](https://bugzilla.redhat.com/1470489): bulk removexattr shouldn't allow removal of trusted.gfid/trusted.glusterfs.volume-id
-- [#1470533](https://bugzilla.redhat.com/1470533): Brick Mux Setup: brick processes(glusterfsd) crash after a restart of volume which was preceded with some actions
-- [#1470768](https://bugzilla.redhat.com/1470768): file /usr/lib64/glusterfs/3.12dev/xlator is not owned by any package
-- [#1471790](https://bugzilla.redhat.com/1471790): [Brick Multiplexing] : cluster.brick-multiplex has no description.
-- [#1472094](https://bugzilla.redhat.com/1472094): Test script failing with brick multiplexing enabled
-- [#1472250](https://bugzilla.redhat.com/1472250): Remove fop_enum_to_string, get_fop_int usage in libglusterfs
-- [#1472417](https://bugzilla.redhat.com/1472417): No clear method to multiplex all bricks to one process(glusterfsd) with cluster.max-bricks-per-process option
-- [#1472949](https://bugzilla.redhat.com/1472949): [distribute] crashes seen upon rmdirs
-- [#1475181](https://bugzilla.redhat.com/1475181): dht remove-brick status does not indicate failures files not migrated because of a lack of space
-- [#1475192](https://bugzilla.redhat.com/1475192): [Scale] : Rebalance ETA shows the initial estimate to be ~140 days,finishes within 18 hours though.
-- [#1475258](https://bugzilla.redhat.com/1475258): [Geo-rep]: Geo-rep hangs in changelog mode
-- [#1475399](https://bugzilla.redhat.com/1475399): Rebalance estimate time sometimes shows negative values
-- [#1475635](https://bugzilla.redhat.com/1475635): [Scale] : Client logs flooded with "inode context is NULL" error messages
-- [#1475641](https://bugzilla.redhat.com/1475641): gluster core dump due to assert failed GF_ASSERT (brick_index < wordcount);
-- [#1475662](https://bugzilla.redhat.com/1475662): [Scale] : Rebalance Logs are bulky.
-- [#1476109](https://bugzilla.redhat.com/1476109): Brick Multiplexing: Brick process crashed at changetimerecorder(ctr) translator when restarting volumes
-- [#1476208](https://bugzilla.redhat.com/1476208): [geo-rep]: few of the self healed hardlinks on master did not sync to slave
-- [#1476653](https://bugzilla.redhat.com/1476653): cassandra fails on gluster-block with both replicate and ec volumes
-- [#1476654](https://bugzilla.redhat.com/1476654): gluster-block default shard-size should be 64MB
-- [#1476819](https://bugzilla.redhat.com/1476819): scripts: invalid test in S32gluster_enable_shared_storage.sh
-- [#1476863](https://bugzilla.redhat.com/1476863): packaging: /var/lib/glusterd/options should be %config(noreplace)
-- [#1476868](https://bugzilla.redhat.com/1476868): [EC]: md5sum mismatches every time for a file from the fuse client on EC volume
-- [#1477152](https://bugzilla.redhat.com/1477152): [Remove-brick] Few files are getting migrated eventhough the bricks crossed cluster.min-free-disk value
-- [#1477190](https://bugzilla.redhat.com/1477190): [GNFS] GNFS got crashed while mounting volume on solaris client
-- [#1477381](https://bugzilla.redhat.com/1477381): Revert experimental and 4.0 features to prepare for 3.12 release
-- [#1477405](https://bugzilla.redhat.com/1477405): eager-lock should be off for cassandra to work at the moment
-- [#1477994](https://bugzilla.redhat.com/1477994): [Ganesha] : Ganesha crashes while cluster enters failover/failback mode
-- [#1478276](https://bugzilla.redhat.com/1478276): separating attach tier and add brick
-- [#1479118](https://bugzilla.redhat.com/1479118): AFR entry self heal removes a directory's .glusterfs symlink.
-- [#1479263](https://bugzilla.redhat.com/1479263): nfs process crashed in "nfs3svc_getattr"
-- [#1479303](https://bugzilla.redhat.com/1479303): [Perf] : Large file sequential reads are off target by ~38% on FUSE/Ganesha
-- [#1479474](https://bugzilla.redhat.com/1479474): Add NULL gfid checks before creating file
-- [#1479655](https://bugzilla.redhat.com/1479655): Permission denied errors when appending files after readdir
-- [#1479662](https://bugzilla.redhat.com/1479662): when gluster pod is restarted, bricks from the restarted pod fails to connect to fuse, self-heal etc
-- [#1479717](https://bugzilla.redhat.com/1479717): Running sysbench on vm disk from plain distribute gluster volume causes disk corruption
-- [#1480448](https://bugzilla.redhat.com/1480448): More useful error - replace 'not optimal'
-- [#1480459](https://bugzilla.redhat.com/1480459): Gluster puts PID files in wrong place
-- [#1481931](https://bugzilla.redhat.com/1481931): [Scale] : I/O errors on  multiple gNFS mounts with "Stale file handle" during rebalance of an erasure coded volume.
-- [#1482804](https://bugzilla.redhat.com/1482804): Negative Test: glusterd crashes for some of the volume options if set at cluster level
-- [#1482835](https://bugzilla.redhat.com/1482835): glusterd fails to start
-- [#1483402](https://bugzilla.redhat.com/1483402): DHT: readdirp fails to read some directories.
-- [#1483996](https://bugzilla.redhat.com/1483996): packaging: use rdma-core(-devel) instead of ibverbs, rdmacm; disable rdma on armv7hl
-- [#1484440](https://bugzilla.redhat.com/1484440): packaging: /run and /var/run; prefer /run
-- [#1484885](https://bugzilla.redhat.com/1484885): [rpc]: EPOLLERR - disconnecting now messages every 3 secs after completing rebalance
-- [#1486107](https://bugzilla.redhat.com/1486107): /var/lib/glusterd/peers File had a blank line, Stopped Glusterd from starting
-- [#1486110](https://bugzilla.redhat.com/1486110): [quorum]: Replace brick is happened  when Quorum not met.
-- [#1486120](https://bugzilla.redhat.com/1486120): symlinks trigger faulty geo-replication state (rsnapshot usecase)
-- [#1486122](https://bugzilla.redhat.com/1486122): gluster-block profile needs to have strict-o-direct
diff --git a/doc/release-notes/3.12.1.md b/doc/release-notes/3.12.1.md
deleted file mode 100644
index 04ce830a221..00000000000
--- a/doc/release-notes/3.12.1.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# Release notes for Gluster 3.12.1
-
-This is a bugfix release. The [Release Notes for 3.12.0](3.12.0.md),
-     [3.12.1](3.12.1.md) contain a listing of all the new features that
-     were added and bugs fixed in the GlusterFS 3.12 stable release.
-
-## Major changes, features and limitations addressed in this release
-     No Major changes
-
-## Major issues
-1. Expanding a gluster volume that is sharded may cause file corruption
-    - Sharded volumes are typically used for VM images, if such volumes are
-  expanded or possibly contracted (i.e add/remove bricks and rebalance) there
-  are reports of VM images getting corrupted.
-    - The last known cause for corruption (Bug #1465123) has a fix with this
-  release. As further testing is still in progress, the issue is retained as
-  a major issue.
-    - Status of this bug can be tracked here, #1465123
-
-## Bugs addressed
-
-     A total of 12 patches have been merged, addressing 11 bugs
-
-- [#1486538](https://bugzilla.redhat.com/1486538): [geo-rep+qr]: Crashes observed at slave from qr_lookup_sbk during rename/hardlink/rebalance
-- [#1486557](https://bugzilla.redhat.com/1486557): Log entry of files skipped/failed during rebalance operation
-- [#1487033](https://bugzilla.redhat.com/1487033): rpc: client_t and related objects leaked due to incorrect ref counts
-- [#1487319](https://bugzilla.redhat.com/1487319): afr: check op_ret value in __afr_selfheal_name_impunge
-- [#1488119](https://bugzilla.redhat.com/1488119): scripts: mount.glusterfs contains non-portable bashisms
-- [#1488168](https://bugzilla.redhat.com/1488168): Launch metadata heal in discover code path.
-- [#1488387](https://bugzilla.redhat.com/1488387): gluster-blockd process crashed and core generated
-- [#1488718](https://bugzilla.redhat.com/1488718): [RHHI] cannot boot vms created from template when disk format = qcow2
-- [#1489260](https://bugzilla.redhat.com/1489260): Crash in dht_check_and_open_fd_on_subvol_task()
-- [#1489296](https://bugzilla.redhat.com/1489296): glusterfsd (brick) process crashed
-- [#1489511](https://bugzilla.redhat.com/1489511): return ENOSYS for 'non readable' FOPs
diff --git a/doc/release-notes/3.12.2.md b/doc/release-notes/3.12.2.md
deleted file mode 100644
index 3f0ab9abc17..00000000000
--- a/doc/release-notes/3.12.2.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# Release notes for Gluster 3.12.2
-
-This is a bugfix release. The release notes for [3.12.0](3.12.0.md), [3.12.1](3.12.1.md),
-[3.12.2](3.12.2.md) contain a listing of all the new features that were added and bugs
-fixed in the GlusterFS 3.12 stable release.
-
-## Major changes, features and limitations addressed in this release
-     1.) In a pure distribute volume there is no source to heal the replaced brick
-     from and hence would cause a loss of data that was present in the replaced brick.
-     The CLI has been enhanced to prevent a user from inadvertently using replace brick
-     in a pure distribute volume. It is advised to use add/remove brick to migrate from
-     an existing brick in a pure distribute volume.
-
-## Major issues
-1. Expanding a gluster volume that is sharded may cause file corruption
-    - Sharded volumes are typically used for VM images, if such volumes are
-  expanded or possibly contracted (i.e add/remove bricks and rebalance) there
-  are reports of VM images getting corrupted.
-    - The last known cause for corruption #1465123 is still pending, and not yet
-    part of this release.
-
-2. Gluster volume restarts fail if the sub directory export feature is in use.
-   Status of this issue can be tracked here, #1501315
-
-3. Mounting a gluster snapshot will fail, when attempting a FUSE based mount of
-   the snapshot. So for the current users, it is recommend to only access snapshot
-   via ".snaps" directory on a mounted gluster volume.
-   Status of this issue can be tracked here, #1501378
-
-## Bugs addressed
-
-     A total of 31 patches have been merged, addressing 28 bugs
-
-
-- [#1490493](https://bugzilla.redhat.com/1490493): Sub-directory mount details are incorrect in /proc/mounts
-- [#1491178](https://bugzilla.redhat.com/1491178): GlusterD returns a bad memory pointer in glusterd_get_args_from_dict()
-- [#1491292](https://bugzilla.redhat.com/1491292): Provide brick list as part of VOLUME_CREATE event.
-- [#1491690](https://bugzilla.redhat.com/1491690): rpc: TLSv1_2_method() is deprecated in OpenSSL-1.1
-- [#1492026](https://bugzilla.redhat.com/1492026): set the shard-block-size to  64MB in virt profile
-- [#1492061](https://bugzilla.redhat.com/1492061): CLIENT_CONNECT event not being raised
-- [#1492066](https://bugzilla.redhat.com/1492066): AFR_SUBVOL_UP and AFR_SUBVOLS_DOWN events not working
-- [#1493975](https://bugzilla.redhat.com/1493975): disallow replace brick operation on plain distribute volume
-- [#1494523](https://bugzilla.redhat.com/1494523): Spelling errors in 3.12.1
-- [#1495162](https://bugzilla.redhat.com/1495162): glusterd ends up with multiple uuids for the same node
-- [#1495397](https://bugzilla.redhat.com/1495397): Make event-history feature configurable and have it disabled by default
-- [#1495858](https://bugzilla.redhat.com/1495858): gluster volume create asks for confirmation for replica-2 volume even with force
-- [#1496238](https://bugzilla.redhat.com/1496238): [geo-rep]: Scheduler help needs correction for description of --no-color
-- [#1496317](https://bugzilla.redhat.com/1496317): [afr] split-brain observed on T files post hardlink and rename in x3 volume
-- [#1496326](https://bugzilla.redhat.com/1496326): [GNFS+EC] lock is being granted to 2 different client for the same data range at a time after performing lock acquire/release from the clients1
-- [#1497084](https://bugzilla.redhat.com/1497084): glusterfs process consume huge memory on both server and client node
-- [#1499123](https://bugzilla.redhat.com/1499123): Readdirp is considerably slower than readdir on acl clients
-- [#1499150](https://bugzilla.redhat.com/1499150): Improve performance with xattrop update.
-- [#1499158](https://bugzilla.redhat.com/1499158): client-io-threads option not working for replicated volumes
-- [#1499202](https://bugzilla.redhat.com/1499202): self-heal daemon stuck
-- [#1499392](https://bugzilla.redhat.com/1499392): [geo-rep]: Improve the output message to reflect the real failure with schedule_georep script
-- [#1500396](https://bugzilla.redhat.com/1500396): [geo-rep]: Observed "Operation not supported" error with traceback on slave log
-- [#1500472](https://bugzilla.redhat.com/1500472): Use a bitmap to store local node info instead of conf->local_nodeuuids[i].uuids
-- [#1500662](https://bugzilla.redhat.com/1500662): gluster volume heal info "healed" and "heal-failed" showing wrong information
-- [#1500835](https://bugzilla.redhat.com/1500835): [geo-rep]: Status shows ACTIVE for most workers in EC before it becomes the PASSIVE
-- [#1500841](https://bugzilla.redhat.com/1500841): [geo-rep]: Worker crashes with OSError: [Errno 61] No data available
-- [#1500845](https://bugzilla.redhat.com/1500845): [geo-rep] master worker crash with interrupted system call
-- [#1500853](https://bugzilla.redhat.com/1500853): [geo-rep]: Incorrect last sync "0" during hystory crawl after upgrade/stop-start
-- [#1501022](https://bugzilla.redhat.com/1501022): Make choose-local configurable through `volume-set` command
-- [#1501154](https://bugzilla.redhat.com/1501154): Brick Multiplexing: Gluster volume start force complains with command "Error : Request timed out" when there are multiple volumes
diff --git a/events/eventskeygen.py b/events/eventskeygen.py
index 23dfb478904..e28ebe9b7e6 100644
--- a/events/eventskeygen.py
+++ b/events/eventskeygen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -22,7 +22,7 @@ gen_header_type = sys.argv[1]
 # When adding new keys add it to the END
 keys = (
     # user driven events
-    #peer and volume managment events
+    #peer and volume management events
     "EVENT_PEER_ATTACH",
     "EVENT_PEER_DETACH",
     "EVENT_VOLUME_CREATE",
@@ -191,6 +191,10 @@ keys = (
     #tier events
     "EVENT_TIER_START",
     "EVENT_TIER_START_FORCE",
+
+    #brick/inodes events
+    "EVENT_DHT_DISK_USAGE",
+    "EVENT_DHT_INODES_USAGE",
 )
 
 LAST_EVENT = "EVENT_LAST"
diff --git a/events/src/Makefile.am b/events/src/Makefile.am
index 4308ccdbb22..3b229691897 100644
--- a/events/src/Makefile.am
+++ b/events/src/Makefile.am
@@ -5,9 +5,11 @@ EXTRA_DIST = glustereventsd.py __init__.py  eventsapiconf.py.in \
 BUILT_SOURCES = eventtypes.py
 CLEANFILES = eventtypes.py
 
-eventsdir = $(GLUSTERFS_LIBEXECDIR)/events
+eventsdir = $(GLUSTERFS_LIBEXECDIR)/gfevents
+if BUILD_EVENTS
 events_PYTHON = __init__.py gf_event.py eventsapiconf.py eventtypes.py \
 	utils.py
+endif
 # this does not work, see the Makefile.am in the root for a workaround
 #nodist_events_PYTHON = eventtypes.py
 
@@ -26,7 +28,7 @@ eventspeerscript_SCRIPTS = peer_eventsapi.py
 install-exec-hook:
 	$(mkdir_p) $(DESTDIR)$(sbindir)
 	rm -f $(DESTDIR)$(sbindir)/glustereventsd
-	ln -s $(GLUSTERFS_LIBEXECDIR)/events/glustereventsd.py \
+	ln -s $(GLUSTERFS_LIBEXECDIR)/gfevents/glustereventsd.py \
 		$(DESTDIR)$(sbindir)/glustereventsd
 	rm -f $(DESTDIR)$(sbindir)/gluster-eventsapi
 	ln -s $(GLUSTERFS_LIBEXECDIR)/peer_eventsapi.py \
diff --git a/events/src/eventsapiconf.py.in b/events/src/eventsapiconf.py.in
index 687eaa39c00..700093bee60 100644
--- a/events/src/eventsapiconf.py.in
+++ b/events/src/eventsapiconf.py.in
@@ -9,12 +9,32 @@
 #  cases as published by the Free Software Foundation.
 #
 
+import subprocess
+glusterd_workdir = None
+
+# Methods
+def get_glusterd_workdir():
+    global glusterd_workdir
+    if glusterd_workdir is not None:
+        return glusterd_workdir
+    proc = subprocess.Popen(["gluster", "system::", "getwd"],
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                            universal_newlines = True)
+    out, err = proc.communicate()
+    if proc.returncode == 0:
+        glusterd_workdir = out.strip()
+    else:
+        glusterd_workdir = "@GLUSTERD_WORKDIR@"
+    return glusterd_workdir
+
 SERVER_ADDRESS = "0.0.0.0"
+SERVER_ADDRESSv4 = "0.0.0.0"
+SERVER_ADDRESSv6 = "::1"
 DEFAULT_CONFIG_FILE = "@SYSCONF_DIR@/glusterfs/eventsconfig.json"
 CUSTOM_CONFIG_FILE_TO_SYNC = "/events/config.json"
-CUSTOM_CONFIG_FILE = "@GLUSTERD_WORKDIR@" + CUSTOM_CONFIG_FILE_TO_SYNC
+CUSTOM_CONFIG_FILE = get_glusterd_workdir() + CUSTOM_CONFIG_FILE_TO_SYNC
 WEBHOOKS_FILE_TO_SYNC = "/events/webhooks.json"
-WEBHOOKS_FILE = "@GLUSTERD_WORKDIR@" + WEBHOOKS_FILE_TO_SYNC
+WEBHOOKS_FILE = get_glusterd_workdir() + WEBHOOKS_FILE_TO_SYNC
 LOG_FILE = "@localstatedir@/log/glusterfs/events.log"
 EVENTSD = "glustereventsd"
 CONFIG_KEYS = ["log-level", "port", "disable-events-log"]
@@ -22,11 +42,11 @@ BOOL_CONFIGS = ["disable-events-log"]
 INT_CONFIGS = ["port"]
 RESTART_CONFIGS = ["port"]
 EVENTS_ENABLED = @EVENTS_ENABLED@
-UUID_FILE = "@GLUSTERD_WORKDIR@/glusterd.info"
+UUID_FILE = get_glusterd_workdir() + "/glusterd.info"
 PID_FILE = "@localstatedir@/run/glustereventsd.pid"
 AUTO_BOOL_ATTRIBUTES = ["force", "push-pem", "no-verify"]
 AUTO_INT_ATTRIBUTES = ["ssh-port"]
-CERTS_DIR = "@GLUSTERD_WORKDIR@/events"
+CERTS_DIR = get_glusterd_workdir() + "/events"
 
 # Errors
 ERROR_SAME_CONFIG = 2
diff --git a/events/src/gf_event.py b/events/src/gf_event.py
index f9ece6adc28..260b0d9aa48 100644
--- a/events/src/gf_event.py
+++ b/events/src/gf_event.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -13,10 +12,10 @@
 import socket
 import time
 
-from eventsapiconf import SERVER_ADDRESS, EVENTS_ENABLED
-from eventtypes import all_events
+from gfevents.eventsapiconf import SERVER_ADDRESS, EVENTS_ENABLED
+from gfevents.eventtypes import all_events
 
-from utils import logger, setup_logger, get_config
+from gfevents.utils import logger, setup_logger, get_config
 
 # Run this when this lib loads
 setup_logger()
@@ -36,18 +35,18 @@ def gf_event(event_type, **kwargs):
         logger.error("Unable to connect to events Server: {0}".format(e))
         return
 
+    port = get_config("port")
+    if port is None:
+        logger.error("Unable to get eventsd port details")
+        return
+
     # Convert key value args into KEY1=VALUE1;KEY2=VALUE2;..
     msg = ""
     for k, v in kwargs.items():
         msg += "{0}={1};".format(k, v)
 
     # <TIMESTAMP> <EVENT_TYPE> <MSG>
-    msg = "{0} {1} {2}".format(int(time.time()), event_type, msg.strip(";"))
-
-    port = get_config("port")
-    if port is None:
-        logger.error("Unable to get eventsd port details")
-        return
+    msg = "{0} {1} {2}".format(int(time.time()), event_type, msg.strip(";")).encode()
 
     try:
         sent = client.sendto(msg, (SERVER_ADDRESS, port))
diff --git a/events/src/glustereventsd.py b/events/src/glustereventsd.py
index 606b89cbd7f..341a3b60947 100644
--- a/events/src/glustereventsd.py
+++ b/events/src/glustereventsd.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -13,22 +13,36 @@
 from __future__ import print_function
 import sys
 import signal
-import SocketServer
+import threading
+try:
+    import socketserver
+except ImportError:
+    import SocketServer as socketserver
 import socket
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 
 from eventtypes import all_events
 import handlers
 import utils
-from eventsapiconf import SERVER_ADDRESS, PID_FILE
+from eventsapiconf import SERVER_ADDRESSv4, SERVER_ADDRESSv6, PID_FILE
 from eventsapiconf import AUTO_BOOL_ATTRIBUTES, AUTO_INT_ATTRIBUTES
 from utils import logger, PidFile, PidFileLockFailed, boolify
 
+# Subclass so that specifically IPv4 packets are captured
+class UDPServerv4(socketserver.ThreadingUDPServer):
+    address_family = socket.AF_INET
 
-class GlusterEventsRequestHandler(SocketServer.BaseRequestHandler):
+# Subclass so that specifically IPv6 packets are captured
+class UDPServerv6(socketserver.ThreadingUDPServer):
+    address_family = socket.AF_INET6
+
+class GlusterEventsRequestHandler(socketserver.BaseRequestHandler):
 
     def handle(self):
         data = self.request[0].strip()
+        if sys.version_info >= (3,):
+            data = self.request[0].strip().decode("utf-8")
+
         logger.debug("EVENT: {0} from {1}".format(repr(data),
                                                   self.client_address[0]))
         try:
@@ -46,7 +60,7 @@ class GlusterEventsRequestHandler(SocketServer.BaseRequestHandler):
             logger.warn("Unable to parse Event {0}".format(data))
             return
 
-        for k, v in data_dict.iteritems():
+        for k, v in data_dict.items():
             try:
                 if k in AUTO_BOOL_ATTRIBUTES:
                     data_dict[k] = boolify(v)
@@ -83,6 +97,10 @@ def signal_handler_sigusr2(sig, frame):
     utils.restart_webhook_pool()
 
 
+def UDP_server_thread(sock):
+    sock.serve_forever()
+
+
 def init_event_server():
     utils.setup_logger()
     utils.load_all()
@@ -93,15 +111,26 @@ def init_event_server():
         sys.stderr.write("Unable to get Port details from Config\n")
         sys.exit(1)
 
-    # Start the Eventing Server, UDP Server
+    # Creating the Eventing Server, UDP Server for IPv4 packets
+    try:
+        serverv4 = UDPServerv4((SERVER_ADDRESSv4, port),
+                   GlusterEventsRequestHandler)
+    except socket.error as e:
+        sys.stderr.write("Failed to start Eventsd for IPv4: {0}\n".format(e))
+        sys.exit(1)
+    # Creating the Eventing Server, UDP Server for IPv6 packets
     try:
-        server = SocketServer.ThreadingUDPServer(
-            (SERVER_ADDRESS, port),
-            GlusterEventsRequestHandler)
+        serverv6 = UDPServerv6((SERVER_ADDRESSv6, port),
+                   GlusterEventsRequestHandler)
     except socket.error as e:
-        sys.stderr.write("Failed to start Eventsd: {0}\n".format(e))
+        sys.stderr.write("Failed to start Eventsd for IPv6: {0}\n".format(e))
         sys.exit(1)
-    server.serve_forever()
+    server_thread1 = threading.Thread(target=UDP_server_thread,
+                     args=(serverv4,))
+    server_thread2 = threading.Thread(target=UDP_server_thread,
+                     args=(serverv6,))
+    server_thread1.start()
+    server_thread2.start()
 
 
 def get_args():
diff --git a/events/src/peer_eventsapi.py b/events/src/peer_eventsapi.py
index d72fdbe99c4..4d2e5f35b1c 100644
--- a/events/src/peer_eventsapi.py
+++ b/events/src/peer_eventsapi.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -27,28 +27,28 @@ from gluster.cliutils import (Cmd, node_output_ok, node_output_notok,
                               sync_file_to_peers, GlusterCmdException,
                               output_error, execute_in_peers, runcli,
                               set_common_args_func)
-from events.utils import LockedOpen, get_jwt_token, save_https_cert
-
-from events.eventsapiconf import (WEBHOOKS_FILE_TO_SYNC,
-                                  WEBHOOKS_FILE,
-                                  DEFAULT_CONFIG_FILE,
-                                  CUSTOM_CONFIG_FILE,
-                                  CUSTOM_CONFIG_FILE_TO_SYNC,
-                                  EVENTSD,
-                                  CONFIG_KEYS,
-                                  BOOL_CONFIGS,
-                                  INT_CONFIGS,
-                                  PID_FILE,
-                                  RESTART_CONFIGS,
-                                  ERROR_INVALID_CONFIG,
-                                  ERROR_WEBHOOK_NOT_EXISTS,
-                                  ERROR_CONFIG_SYNC_FAILED,
-                                  ERROR_WEBHOOK_ALREADY_EXISTS,
-                                  ERROR_PARTIAL_SUCCESS,
-                                  ERROR_ALL_NODES_STATUS_NOT_OK,
-                                  ERROR_SAME_CONFIG,
-                                  ERROR_WEBHOOK_SYNC_FAILED,
-                                  CERTS_DIR)
+from gfevents.utils import LockedOpen, get_jwt_token, save_https_cert
+
+from gfevents.eventsapiconf import (WEBHOOKS_FILE_TO_SYNC,
+                                    WEBHOOKS_FILE,
+                                    DEFAULT_CONFIG_FILE,
+                                    CUSTOM_CONFIG_FILE,
+                                    CUSTOM_CONFIG_FILE_TO_SYNC,
+                                    EVENTSD,
+                                    CONFIG_KEYS,
+                                    BOOL_CONFIGS,
+                                    INT_CONFIGS,
+                                    PID_FILE,
+                                    RESTART_CONFIGS,
+                                    ERROR_INVALID_CONFIG,
+                                    ERROR_WEBHOOK_NOT_EXISTS,
+                                    ERROR_CONFIG_SYNC_FAILED,
+                                    ERROR_WEBHOOK_ALREADY_EXISTS,
+                                    ERROR_PARTIAL_SUCCESS,
+                                    ERROR_ALL_NODES_STATUS_NOT_OK,
+                                    ERROR_SAME_CONFIG,
+                                    ERROR_WEBHOOK_SYNC_FAILED,
+                                    CERTS_DIR)
 
 
 def handle_output_error(err, errcode=1, json_output=False):
@@ -173,8 +173,10 @@ def sync_to_peers(args):
         try:
             sync_file_to_peers(WEBHOOKS_FILE_TO_SYNC)
         except GlusterCmdException as e:
+            # Print stdout if stderr is empty
+            errmsg = e.message[2] if e.message[2] else e.message[1]
             handle_output_error("Failed to sync Webhooks file: [Error: {0}]"
-                                "{1}".format(e[0], e[2]),
+                                "{1}".format(e.message[0], errmsg),
                                 errcode=ERROR_WEBHOOK_SYNC_FAILED,
                                 json_output=args.json)
 
@@ -182,8 +184,10 @@ def sync_to_peers(args):
         try:
             sync_file_to_peers(CUSTOM_CONFIG_FILE_TO_SYNC)
         except GlusterCmdException as e:
+            # Print stdout if stderr is empty
+            errmsg = e.message[2] if e.message[2] else e.message[1]
             handle_output_error("Failed to sync Config file: [Error: {0}]"
-                                "{1}".format(e[0], e[2]),
+                                "{1}".format(e.message[0], errmsg),
                                 errcode=ERROR_CONFIG_SYNC_FAILED,
                                 json_output=args.json)
 
@@ -349,8 +353,7 @@ class WebhookModCmd(Cmd):
                                     errcode=ERROR_WEBHOOK_NOT_EXISTS,
                                     json_output=args.json)
 
-            if isinstance(data[args.url], str) or \
-               isinstance(data[args.url], unicode):
+            if isinstance(data[args.url], str):
                 data[args.url]["token"] = data[args.url]
 
             if args.bearer_token != "":
diff --git a/events/src/utils.py b/events/src/utils.py
index 851543e8f3b..6d4e0791a2b 100644
--- a/events/src/utils.py
+++ b/events/src/utils.py
@@ -9,23 +9,34 @@
 #  cases as published by the Free Software Foundation.
 #
 
+import sys
 import json
 import os
 import logging
+import logging.handlers
 import fcntl
 from errno import EBADF
 from threading import Thread
 import multiprocessing
-from Queue import Queue
+try:
+    from queue import Queue
+except ImportError:
+    from Queue import Queue
 from datetime import datetime, timedelta
+import base64
+import hmac
+from hashlib import sha256
+from calendar import timegm
 
-from eventsapiconf import (LOG_FILE,
-                           WEBHOOKS_FILE,
-                           DEFAULT_CONFIG_FILE,
-                           CUSTOM_CONFIG_FILE,
-                           UUID_FILE,
-                           CERTS_DIR)
-import eventtypes
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from gfevents.eventsapiconf import (LOG_FILE,
+                                    WEBHOOKS_FILE,
+                                    DEFAULT_CONFIG_FILE,
+                                    CUSTOM_CONFIG_FILE,
+                                    UUID_FILE,
+                                    CERTS_DIR)
+from gfevents import eventtypes
 
 
 # Webhooks list
@@ -88,7 +99,7 @@ def setup_logger():
     logger.setLevel(logging.INFO)
 
     # create the logging file handler
-    fh = logging.FileHandler(LOG_FILE)
+    fh = logging.handlers.WatchedFileHandler(LOG_FILE)
 
     formatter = logging.Formatter("[%(asctime)s] %(levelname)s "
                                   "[%(module)s - %(lineno)s:%(funcName)s] "
@@ -185,15 +196,25 @@ def autoload_webhooks():
             load_webhooks()
 
 
+def base64_urlencode(inp):
+    return base64.urlsafe_b64encode(inp).replace("=", "").strip()
+
+
 def get_jwt_token(secret, event_type, event_ts, jwt_expiry_time_seconds=60):
-    import jwt
+    exp = datetime.utcnow() + timedelta(seconds=jwt_expiry_time_seconds)
     payload = {
-        "exp": datetime.utcnow() + timedelta(seconds=jwt_expiry_time_seconds),
+        "exp": timegm(exp.utctimetuple()),
         "iss": "gluster",
         "sub": event_type,
         "iat": event_ts
     }
-    return jwt.encode(payload, secret, algorithm='HS256')
+    header = '{"alg":"HS256","typ":"JWT"}'
+    payload = json.dumps(payload, separators=(',', ':'), sort_keys=True)
+    msg = base64_urlencode(header) + "." + base64_urlencode(payload)
+    return "%s.%s" % (
+        msg,
+        base64_urlencode(hmac.HMAC(str(secret), msg, sha256).digest())
+    )
 
 
 def save_https_cert(domain, port, cert_path):
@@ -370,7 +391,7 @@ class PidFile(object):
 def webhook_monitor(proc_queue, webhooks):
     queues = {}
     for url, data in webhooks.items():
-        if isinstance(data, str) or isinstance(data, unicode):
+        if isinstance(data, str):
             token = data
             secret = None
         else:
@@ -391,8 +412,8 @@ def webhook_monitor(proc_queue, webhooks):
 
 class WebhookThreadPool(object):
     def start(self):
-        # Seperate process to emit messages to webhooks
-        # which maintains one thread per webhook. Seperate
+        # Separate process to emit messages to webhooks
+        # which maintains one thread per webhook. Separate
         # process is required since on reload we need to stop
         # and start the thread pool. In Python Threads can't be stopped
         # so terminate the process and start again. Note: In transit
diff --git a/events/tools/eventsdash.py b/events/tools/eventsdash.py
index 47fc56dda6e..6479ea59da6 100644
--- a/events/tools/eventsdash.py
+++ b/events/tools/eventsdash.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -10,6 +10,7 @@
 #  cases as published by the Free Software Foundation.
 #
 
+from __future__ import print_function
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 import logging
 from datetime import datetime
@@ -41,11 +42,11 @@ def listen():
     for k, v in data.get("message", {}).items():
         message.append("{0}={1}".format(k, v))
 
-    print ("{0:20s} {1:20s} {2:36} {3}".format(
+    print(("{0:20s} {1:20s} {2:36} {3}".format(
         human_time(data.get("ts")),
         data.get("event"),
         data.get("nodeid"),
-        " ".join(message)))
+        " ".join(message))))
 
     return "OK"
 
@@ -58,12 +59,12 @@ def main():
                         action="store_true")
     args = parser.parse_args()
 
-    print ("{0:20s} {1:20s} {2:36} {3}".format(
+    print(("{0:20s} {1:20s} {2:36} {3}".format(
         "TIMESTAMP", "EVENT", "NODE ID", "MESSAGE"
-    ))
-    print ("{0:20s} {1:20s} {2:36} {3}".format(
+    )))
+    print(("{0:20s} {1:20s} {2:36} {3}".format(
         "-"*20, "-"*20, "-"*36, "-"*20
-    ))
+    )))
     if args.debug:
         app.debug = True
 
diff --git a/extras/Makefile.am b/extras/Makefile.am
index 68637724a48..983f014cca6 100644
--- a/extras/Makefile.am
+++ b/extras/Makefile.am
@@ -1,33 +1,58 @@
 addonexecdir = $(GLUSTERFS_LIBEXECDIR)
-addonexec_SCRIPTS = peer_add_secret_pub
+addonexec_SCRIPTS =
+if WITH_SERVER
+addonexec_SCRIPTS += peer_add_secret_pub
 if USE_SYSTEMD
 addonexec_SCRIPTS += mount-shared-storage.sh
 endif
+endif
 
 EditorModedir = $(docdir)
 EditorMode_DATA = glusterfs-mode.el glusterfs.vim
 
 SUBDIRS = init.d systemd benchmarking hook-scripts $(OCF_SUBDIR) LinuxRPM \
-          $(GEOREP_EXTRAS_SUBDIR) snap_scheduler firewalld cliutils
+          $(GEOREP_EXTRAS_SUBDIR) snap_scheduler firewalld cliutils python \
+		  ganesha
 
 confdir = $(sysconfdir)/glusterfs
+if WITH_SERVER
 conf_DATA = glusterfs-logrotate gluster-rsyslog-7.2.conf gluster-rsyslog-5.8.conf \
-	logger.conf.example glusterfs-georep-logrotate group-virt.example group-metadata-cache group-gluster-block group-nl-cache
+	    logger.conf.example glusterfs-georep-logrotate group-virt.example \
+	    group-metadata-cache group-gluster-block group-nl-cache \
+	    group-db-workload group-distributed-virt group-samba
+endif
 
 voldir = $(sysconfdir)/glusterfs
-vol_DATA = glusterd.vol
+vol_DATA = thin-arbiter/thin-arbiter.vol
+if WITH_SERVER
+vol_DATA += glusterd.vol
+endif
+
 scriptsdir = $(datadir)/glusterfs/scripts
-scripts_SCRIPTS = post-upgrade-script-for-quota.sh \
+scripts_SCRIPTS = thin-arbiter/setup-thin-arbiter.sh
+if WITH_SERVER
+scripts_SCRIPTS += post-upgrade-script-for-quota.sh \
 	pre-upgrade-script-for-quota.sh stop-all-gluster-processes.sh
+if USE_SYSTEMD
+scripts_SCRIPTS += control-cpu-load.sh
+scripts_SCRIPTS += control-mem.sh
+endif
+endif
 
-EXTRA_DIST = $(conf_DATA) specgen.scm glusterfs-mode.el glusterfs.vim \
-	migrate-unify-to-distribute.sh backend-xattr-sanitize.sh backend-cleanup.sh \
-	disk_usage_sync.sh clear_xattrs.sh glusterd-sysconfig glusterd.vol \
-	post-upgrade-script-for-quota.sh pre-upgrade-script-for-quota.sh \
-	command-completion/gluster.bash command-completion/Makefile \
-	command-completion/README stop-all-gluster-processes.sh clang-checker.sh \
-	mount-shared-storage.sh
+EXTRA_DIST = glusterfs-logrotate gluster-rsyslog-7.2.conf gluster-rsyslog-5.8.conf \
+	logger.conf.example glusterfs-georep-logrotate group-virt.example \
+	group-metadata-cache group-gluster-block group-nl-cache \
+	group-db-workload group-samba specgen.scm glusterfs-mode.el glusterfs.vim \
+	migrate-unify-to-distribute.sh backend-xattr-sanitize.sh \
+	backend-cleanup.sh disk_usage_sync.sh clear_xattrs.sh \
+	glusterd-sysconfig glusterd.vol post-upgrade-script-for-quota.sh \
+	pre-upgrade-script-for-quota.sh command-completion/gluster.bash \
+	command-completion/Makefile command-completion/README \
+	stop-all-gluster-processes.sh clang-checker.sh mount-shared-storage.sh \
+	control-cpu-load.sh control-mem.sh group-distributed-virt \
+	thin-arbiter/thin-arbiter.vol thin-arbiter/setup-thin-arbiter.sh
 
+if WITH_SERVER
 install-data-local:
 	if [ -n "$(tmpfilesdir)" ]; then \
 		$(mkdir_p) $(DESTDIR)$(tmpfilesdir); \
@@ -43,3 +68,10 @@ install-data-local:
 		$(DESTDIR)$(GLUSTERD_WORKDIR)/groups/gluster-block
 	$(INSTALL_DATA) $(top_srcdir)/extras/group-nl-cache \
 		$(DESTDIR)$(GLUSTERD_WORKDIR)/groups/nl-cache
+	$(INSTALL_DATA) $(top_srcdir)/extras/group-db-workload \
+		$(DESTDIR)$(GLUSTERD_WORKDIR)/groups/db-workload
+	$(INSTALL_DATA) $(top_srcdir)/extras/group-distributed-virt \
+		$(DESTDIR)$(GLUSTERD_WORKDIR)/groups/distributed-virt
+	$(INSTALL_DATA) $(top_srcdir)/extras/group-samba \
+		$(DESTDIR)$(GLUSTERD_WORKDIR)/groups/samba
+endif
diff --git a/extras/benchmarking/glfs-bm.c b/extras/benchmarking/glfs-bm.c
index dc717f33c16..f7f5873f84d 100644
--- a/extras/benchmarking/glfs-bm.c
+++ b/extras/benchmarking/glfs-bm.c
@@ -25,365 +25,338 @@
 #include <sys/time.h>
 
 struct state {
-        char need_op_write:1;
-        char need_op_read:1;
+    char need_op_write : 1;
+    char need_op_read : 1;
 
-        char need_iface_fileio:1;
-        char need_iface_xattr:1;
+    char need_iface_fileio : 1;
+    char need_iface_xattr : 1;
 
-        char need_mode_posix:1;
+    char need_mode_posix : 1;
 
-        char prefix[512];
-        long int count;
+    char prefix[512];
+    long int count;
 
-        size_t block_size;
+    size_t block_size;
 
-        char *specfile;
+    char *specfile;
 
-        long int io_size;
+    long int io_size;
 };
 
-
-#define MEASURE(func, arg) measure (func, #func, arg)
-
+#define MEASURE(func, arg) measure(func, #func, arg)
 
 void
-tv_difference (struct timeval *tv_stop,
-               struct timeval *tv_start,
-               struct timeval *tv_diff)
+tv_difference(struct timeval *tv_stop, struct timeval *tv_start,
+              struct timeval *tv_diff)
 {
-        if (tv_stop->tv_usec < tv_start->tv_usec) {
-                tv_diff->tv_usec = (tv_stop->tv_usec + 1000000) - tv_start->tv_usec;
-                tv_diff->tv_sec = (tv_stop->tv_sec - 1 - tv_start->tv_sec);
-        } else {
-                tv_diff->tv_usec = tv_stop->tv_usec - tv_start->tv_usec;
-                tv_diff->tv_sec = tv_stop->tv_sec - tv_start->tv_sec;
-        }
+    if (tv_stop->tv_usec < tv_start->tv_usec) {
+        tv_diff->tv_usec = (tv_stop->tv_usec + 1000000) - tv_start->tv_usec;
+        tv_diff->tv_sec = (tv_stop->tv_sec - 1 - tv_start->tv_sec);
+    } else {
+        tv_diff->tv_usec = tv_stop->tv_usec - tv_start->tv_usec;
+        tv_diff->tv_sec = tv_stop->tv_sec - tv_start->tv_sec;
+    }
 }
 
-
 void
-measure (int (*func)(struct state *state),
-         char *func_name, struct state *state)
+measure(int (*func)(struct state *state), char *func_name, struct state *state)
 {
-        struct timeval tv_start, tv_stop, tv_diff;
-        state->io_size = 0;
-        long int count;
+    struct timeval tv_start, tv_stop, tv_diff;
+    state->io_size = 0;
+    long int count;
 
-        gettimeofday (&tv_start, NULL);
-        count = func (state);
-        gettimeofday (&tv_stop, NULL);
+    gettimeofday(&tv_start, NULL);
+    count = func(state);
+    gettimeofday(&tv_stop, NULL);
 
-        tv_difference (&tv_stop, &tv_start, &tv_diff);
+    tv_difference(&tv_stop, &tv_start, &tv_diff);
 
-        fprintf (stdout, "%s: count=%ld, size=%ld, time=%ld:%ld\n",
-                 func_name, count, state->io_size,
-                 tv_diff.tv_sec, tv_diff.tv_usec);
+    fprintf(stdout, "%s: count=%ld, size=%ld, time=%ld:%ld\n", func_name, count,
+            state->io_size, tv_diff.tv_sec, tv_diff.tv_usec);
 }
 
-
 static error_t
-parse_opts (int key, char *arg,
-            struct argp_state *_state)
+parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        struct state *state = _state->input;
+    struct state *state = _state->input;
 
-        switch (key)
-        {
+    switch (key) {
         case 'o':
-                if (strcasecmp (arg, "read") == 0) {
-                        state->need_op_write = 0;
-                        state->need_op_read = 1;
-                } else if (strcasecmp (arg, "write") == 0) {
-                        state->need_op_write = 1;
-                        state->need_op_read = 0;
-                } else if (strcasecmp (arg, "both") == 0) {
-                        state->need_op_write = 1;
-                        state->need_op_read = 1;
-                } else {
-                        fprintf (stderr, "unknown op: %s\n", arg);
-                        return -1;
-                }
-                break;
+            if (strcasecmp(arg, "read") == 0) {
+                state->need_op_write = 0;
+                state->need_op_read = 1;
+            } else if (strcasecmp(arg, "write") == 0) {
+                state->need_op_write = 1;
+                state->need_op_read = 0;
+            } else if (strcasecmp(arg, "both") == 0) {
+                state->need_op_write = 1;
+                state->need_op_read = 1;
+            } else {
+                fprintf(stderr, "unknown op: %s\n", arg);
+                return -1;
+            }
+            break;
         case 'i':
-                if (strcasecmp (arg, "fileio") == 0) {
-                        state->need_iface_fileio = 1;
-                        state->need_iface_xattr = 0;
-                } else if (strcasecmp (arg, "xattr") == 0) {
-                        state->need_iface_fileio = 0;
-                        state->need_iface_xattr = 1;
-                } else if (strcasecmp (arg, "both") == 0) {
-                        state->need_iface_fileio = 1;
-                        state->need_iface_xattr = 1;
-                } else {
-                        fprintf (stderr, "unknown interface: %s\n", arg);
-                        return -1;
-                }
-                break;
-        case 'b':
-        {
-                size_t block_size = atoi (arg);
-                if (!block_size) {
-                        fprintf (stderr, "incorrect size: %s\n", arg);
-                        return -1;
-                }
-                state->block_size = block_size;
-        }
-        break;
+            if (strcasecmp(arg, "fileio") == 0) {
+                state->need_iface_fileio = 1;
+                state->need_iface_xattr = 0;
+            } else if (strcasecmp(arg, "xattr") == 0) {
+                state->need_iface_fileio = 0;
+                state->need_iface_xattr = 1;
+            } else if (strcasecmp(arg, "both") == 0) {
+                state->need_iface_fileio = 1;
+                state->need_iface_xattr = 1;
+            } else {
+                fprintf(stderr, "unknown interface: %s\n", arg);
+                return -1;
+            }
+            break;
+        case 'b': {
+            size_t block_size = atoi(arg);
+            if (!block_size) {
+                fprintf(stderr, "incorrect size: %s\n", arg);
+                return -1;
+            }
+            state->block_size = block_size;
+        } break;
         case 's':
-                state->specfile = strdup (arg);
-                break;
+            state->specfile = strdup(arg);
+            break;
         case 'p':
-                fprintf (stderr, "using prefix: %s\n", arg);
-                strncpy (state->prefix, arg, 512);
-                break;
-        case 'c':
-        {
-                long count = atol (arg);
-                if (!count) {
-                        fprintf (stderr, "incorrect count: %s\n", arg);
-                        return -1;
-                }
-                state->count = count;
-        }
-        break;
+            fprintf(stderr, "using prefix: %s\n", arg);
+            strncpy(state->prefix, arg, 512);
+            break;
+        case 'c': {
+            long count = atol(arg);
+            if (!count) {
+                fprintf(stderr, "incorrect count: %s\n", arg);
+                return -1;
+            }
+            state->count = count;
+        } break;
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
-        }
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-do_mode_posix_iface_fileio_write (struct state *state)
+do_mode_posix_iface_fileio_write(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-
-        for (i=0; i<state->count; i++) {
-                int fd = -1;
-                char filename[512];
-
-                sprintf (filename, "%s.%06ld", state->prefix, i);
-
-                fd = open (filename, O_CREAT|O_WRONLY, 00600);
-                if (fd == -1) {
-                        fprintf (stderr, "open(%s) => %s\n", filename, strerror (errno));
-                        break;
-                }
-                ret = write (fd, block, state->block_size);
-                if (ret != state->block_size) {
-                        fprintf (stderr, "write (%s) => %d/%s\n", filename, ret,
-                                 strerror (errno));
-                        close (fd);
-                        break;
-                }
-                close (fd);
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+
+    for (i = 0; i < state->count; i++) {
+        int fd = -1;
+        char filename[512];
+
+        sprintf(filename, "%s.%06ld", state->prefix, i);
+
+        fd = open(filename, O_CREAT | O_WRONLY, 00600);
+        if (fd == -1) {
+            fprintf(stderr, "open(%s) => %s\n", filename, strerror(errno));
+            break;
+        }
+        ret = write(fd, block, state->block_size);
+        if (ret != state->block_size) {
+            fprintf(stderr, "write (%s) => %d/%s\n", filename, ret,
+                    strerror(errno));
+            close(fd);
+            break;
         }
+        close(fd);
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_fileio_read (struct state *state)
+do_mode_posix_iface_fileio_read(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-
-        for (i=0; i<state->count; i++) {
-                int fd = -1;
-                char filename[512];
-
-                sprintf (filename, "%s.%06ld", state->prefix, i);
-
-                fd = open (filename, O_RDONLY);
-                if (fd == -1) {
-                        fprintf (stderr, "open(%s) => %s\n", filename, strerror (errno));
-                        break;
-                }
-                ret = read (fd, block, state->block_size);
-                if (ret == -1) {
-                        fprintf (stderr, "read(%s) => %d/%s\n", filename, ret, strerror (errno));
-                        close (fd);
-                        break;
-                }
-                close (fd);
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+
+    for (i = 0; i < state->count; i++) {
+        int fd = -1;
+        char filename[512];
+
+        sprintf(filename, "%s.%06ld", state->prefix, i);
+
+        fd = open(filename, O_RDONLY);
+        if (fd == -1) {
+            fprintf(stderr, "open(%s) => %s\n", filename, strerror(errno));
+            break;
         }
+        ret = read(fd, block, state->block_size);
+        if (ret == -1) {
+            fprintf(stderr, "read(%s) => %d/%s\n", filename, ret,
+                    strerror(errno));
+            close(fd);
+            break;
+        }
+        close(fd);
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_fileio (struct state *state)
+do_mode_posix_iface_fileio(struct state *state)
 {
-        if (state->need_op_write)
-                MEASURE (do_mode_posix_iface_fileio_write, state);
+    if (state->need_op_write)
+        MEASURE(do_mode_posix_iface_fileio_write, state);
 
-        if (state->need_op_read)
-                MEASURE (do_mode_posix_iface_fileio_read, state);
+    if (state->need_op_read)
+        MEASURE(do_mode_posix_iface_fileio_read, state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-do_mode_posix_iface_xattr_write (struct state *state)
+do_mode_posix_iface_xattr_write(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-        char *dname = NULL, *dirc = NULL;
-        char *bname = NULL, *basec = NULL;
-
-        dirc = strdup (state->prefix);
-        basec = strdup (state->prefix);
-        dname = dirname (dirc);
-        bname = basename (basec);
-
-        for (i=0; i<state->count; i++) {
-                char key[512];
-
-                sprintf (key, "glusterfs.file.%s.%06ld", bname, i);
-
-                ret = lsetxattr (dname, key, block, state->block_size, 0);
-
-                if (ret != 0) {
-                        fprintf (stderr, "lsetxattr (%s, %s, %p) => %s\n",
-                                 dname, key, block, strerror (errno));
-                        break;
-                }
-                state->io_size += state->block_size;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+    char *dname = NULL, *dirc = NULL;
+    char *bname = NULL, *basec = NULL;
+
+    dirc = strdup(state->prefix);
+    basec = strdup(state->prefix);
+    dname = dirname(dirc);
+    bname = basename(basec);
+
+    for (i = 0; i < state->count; i++) {
+        char key[512];
+
+        sprintf(key, "glusterfs.file.%s.%06ld", bname, i);
+
+        ret = lsetxattr(dname, key, block, state->block_size, 0);
+
+        if (ret != 0) {
+            fprintf(stderr, "lsetxattr (%s, %s, %p) => %s\n", dname, key, block,
+                    strerror(errno));
+            break;
         }
+        state->io_size += state->block_size;
+    }
 
-        free (dirc);
-        free (basec);
+    free(dirc);
+    free(basec);
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_xattr_read (struct state *state)
+do_mode_posix_iface_xattr_read(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-        char *dname = NULL, *dirc = NULL;
-        char *bname = NULL, *basec = NULL;
-
-        dirc = strdup (state->prefix);
-        basec = strdup (state->prefix);
-        dname = dirname (dirc);
-        bname = basename (basec);
-
-        for (i=0; i<state->count; i++) {
-                char key[512];
-
-                sprintf (key, "glusterfs.file.%s.%06ld", bname, i);
-
-                ret = lgetxattr (dname, key, block, state->block_size);
-
-                if (ret < 0) {
-                        fprintf (stderr, "lgetxattr (%s, %s, %p) => %s\n",
-                                 dname, key, block, strerror (errno));
-                        break;
-                }
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+    char *dname = NULL, *dirc = NULL;
+    char *bname = NULL, *basec = NULL;
+
+    dirc = strdup(state->prefix);
+    basec = strdup(state->prefix);
+    dname = dirname(dirc);
+    bname = basename(basec);
+
+    for (i = 0; i < state->count; i++) {
+        char key[512];
+
+        sprintf(key, "glusterfs.file.%s.%06ld", bname, i);
+
+        ret = lgetxattr(dname, key, block, state->block_size);
+
+        if (ret < 0) {
+            fprintf(stderr, "lgetxattr (%s, %s, %p) => %s\n", dname, key, block,
+                    strerror(errno));
+            break;
         }
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_xattr (struct state *state)
+do_mode_posix_iface_xattr(struct state *state)
 {
-        if (state->need_op_write)
-                MEASURE (do_mode_posix_iface_xattr_write, state);
+    if (state->need_op_write)
+        MEASURE(do_mode_posix_iface_xattr_write, state);
 
-        if (state->need_op_read)
-                MEASURE (do_mode_posix_iface_xattr_read, state);
+    if (state->need_op_read)
+        MEASURE(do_mode_posix_iface_xattr_read, state);
 
-        return 0;
+    return 0;
 }
 
 int
-do_mode_posix (struct state *state)
+do_mode_posix(struct state *state)
 {
-        if (state->need_iface_fileio)
-                do_mode_posix_iface_fileio (state);
+    if (state->need_iface_fileio)
+        do_mode_posix_iface_fileio(state);
 
-        if (state->need_iface_xattr)
-                do_mode_posix_iface_xattr (state);
+    if (state->need_iface_xattr)
+        do_mode_posix_iface_xattr(state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-do_actions (struct state *state)
+do_actions(struct state *state)
 {
-        if (state->need_mode_posix)
-                do_mode_posix (state);
+    if (state->need_mode_posix)
+        do_mode_posix(state);
 
-        return 0;
+    return 0;
 }
 
 static struct argp_option options[] = {
-        {"op", 'o', "OPERATIONS", 0,
-         "WRITE|READ|BOTH - defaults to BOTH"},
-        {"iface", 'i', "INTERFACE", 0,
-         "FILEIO|XATTR|BOTH - defaults to FILEIO"},
-        {"block", 'b', "BLOCKSIZE", 0,
-         "<NUM> - defaults to 4096"},
-        {"specfile", 's', "SPECFILE", 0,
-         "absolute path to specfile"},
-        {"prefix", 'p', "PREFIX", 0,
-         "filename prefix"},
-        {"count", 'c', "COUNT", 0,
-         "number of files"},
-        {0, 0, 0, 0, 0}
-};
+    {"op", 'o', "OPERATIONS", 0, "WRITE|READ|BOTH - defaults to BOTH"},
+    {"iface", 'i', "INTERFACE", 0, "FILEIO|XATTR|BOTH - defaults to FILEIO"},
+    {"block", 'b', "BLOCKSIZE", 0, "<NUM> - defaults to 4096"},
+    {"specfile", 's', "SPECFILE", 0, "absolute path to specfile"},
+    {"prefix", 'p', "PREFIX", 0, "filename prefix"},
+    {"count", 'c', "COUNT", 0, "number of files"},
+    {0, 0, 0, 0, 0}};
 
-static struct argp argp = {
-        options,
-        parse_opts,
-        "tool",
-        "tool to benchmark small file performance"
-};
+static struct argp argp = {options, parse_opts, "tool",
+                           "tool to benchmark small file performance"};
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        struct state state = {0, };
+    struct state state = {
+        0,
+    };
 
-        state.need_op_write = 1;
-        state.need_op_read = 1;
+    state.need_op_write = 1;
+    state.need_op_read = 1;
 
-        state.need_iface_fileio = 1;
-        state.need_iface_xattr = 0;
+    state.need_iface_fileio = 1;
+    state.need_iface_xattr = 0;
 
-        state.need_mode_posix = 1;
+    state.need_mode_posix = 1;
 
-        state.block_size = 4096;
+    state.block_size = 4096;
 
-        strcpy (state.prefix, "tmpfile");
-        state.count = 1048576;
+    strcpy(state.prefix, "tmpfile");
+    state.count = 1048576;
 
-        if (argp_parse (&argp, argc, argv, 0, 0, &state) != 0) {
-                fprintf (stderr, "argp_parse() failed\n");
-                return 1;
-        }
+    if (argp_parse(&argp, argc, argv, 0, 0, &state) != 0) {
+        fprintf(stderr, "argp_parse() failed\n");
+        return 1;
+    }
 
-        do_actions (&state);
+    do_actions(&state);
 
-        return 0;
+    return 0;
 }
diff --git a/extras/benchmarking/rdd.c b/extras/benchmarking/rdd.c
index a667c6a1d65..efc9d342a37 100644
--- a/extras/benchmarking/rdd.c
+++ b/extras/benchmarking/rdd.c
@@ -20,633 +20,586 @@
 
 #define TWO_POWER(power) (2UL << (power))
 
-#define RDD_INTEGER_VALUE ((TWO_POWER ((sizeof (int) * 8))) - 1)
+#define RDD_INTEGER_VALUE ((TWO_POWER((sizeof(int) * 8))) - 1)
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX 108
 #endif
 
 #define UNIT_KB 1024ULL
-#define UNIT_MB UNIT_KB*1024ULL
-#define UNIT_GB UNIT_MB*1024ULL
-#define UNIT_TB UNIT_GB*1024ULL
-#define UNIT_PB UNIT_TB*1024ULL
+#define UNIT_MB UNIT_KB * 1024ULL
+#define UNIT_GB UNIT_MB * 1024ULL
+#define UNIT_TB UNIT_GB * 1024ULL
+#define UNIT_PB UNIT_TB * 1024ULL
 
-#define UNIT_KB_STRING    "KB"
-#define UNIT_MB_STRING    "MB"
-#define UNIT_GB_STRING    "GB"
-#define UNIT_TB_STRING    "TB"
-#define UNIT_PB_STRING    "PB"
+#define UNIT_KB_STRING "KB"
+#define UNIT_MB_STRING "MB"
+#define UNIT_GB_STRING "GB"
+#define UNIT_TB_STRING "TB"
+#define UNIT_PB_STRING "PB"
 
 struct rdd_file {
-        char path[UNIX_PATH_MAX];
-        struct stat st;
-        int fd;
+    char path[UNIX_PATH_MAX];
+    struct stat st;
+    int fd;
 };
 
 struct rdd_config {
-        long iters;
-        long max_ops_per_seq;
-        size_t max_bs;
-        size_t min_bs;
-        int thread_count;
-        pthread_t *threads;
-        pthread_barrier_t barrier;
-        pthread_mutex_t lock;
-        struct rdd_file in_file;
-        struct rdd_file out_file;
-        ssize_t file_size;
+    long iters;
+    long max_ops_per_seq;
+    size_t max_bs;
+    size_t min_bs;
+    int thread_count;
+    pthread_t *threads;
+    pthread_barrier_t barrier;
+    pthread_mutex_t lock;
+    struct rdd_file in_file;
+    struct rdd_file out_file;
+    ssize_t file_size;
 };
 static struct rdd_config rdd_config;
 
 enum rdd_keys {
-        RDD_MIN_BS_KEY = 1,
-        RDD_MAX_BS_KEY,
+    RDD_MIN_BS_KEY = 1,
+    RDD_MAX_BS_KEY,
 };
 
 static error_t
-rdd_parse_opts (int key, char *arg,
-                struct argp_state *_state)
+rdd_parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        switch (key) {
-        case 'o':
-        {
-                int len = 0;
-                len = strlen (arg);
-                if (len > UNIX_PATH_MAX) {
-                        fprintf (stderr, "output file name too long (%s)\n",
-                                 arg);
-                        return -1;
-                }
-
-                strncpy (rdd_config.out_file.path, arg, len);
-        }
-        break;
-
-        case 'i':
-        {
-                int len = 0;
-                len = strlen (arg);
-                if (len > UNIX_PATH_MAX) {
-                        fprintf (stderr, "input file name too long (%s)\n",
-                                 arg);
-                        return -1;
-                }
-
-                strncpy (rdd_config.in_file.path, arg, len);
-                rdd_config.in_file.path[len] = '\0';
-        }
-        break;
-
-        case 'f':
-        {
-                char *tmp = NULL;
-                unsigned long long fs = 0;
-                if (string2bytesize (arg, &fs) == -1) {
-                        fprintf (stderr, "invalid argument for file size "
-                                 "(%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.file_size = fs;
-        }
-        break;
-
-        case RDD_MIN_BS_KEY:
-        {
-                char *tmp = NULL;
-                long bs = 0;
-                bs = strtol (arg, &tmp, 10);
-                if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for minimum block"
-                                 "size (%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.min_bs = bs;
-        }
-        break;
-
-        case RDD_MAX_BS_KEY:
-        {
-                char *tmp = NULL;
-                long bs = 0;
-                bs = strtol (arg, &tmp, 10);
-                if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for maximum block"
-                                 "size (%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.max_bs = bs;
-        }
-        break;
-
-        case 'r':
-        {
-                char *tmp = NULL;
-                long iters = 0;
-                iters = strtol (arg, &tmp, 10);
-                if ((iters == LONG_MAX) ||
-                    (iters == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for iterations"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.iters = iters;
-        }
-        break;
-
-        case 'm':
-        {
-                char *tmp = NULL;
-                long max_ops = 0;
-                max_ops = strtol (arg, &tmp, 10);
-                if ((max_ops == LONG_MAX) ||
-                    (max_ops == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for max-ops"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
+    switch (key) {
+        case 'o': {
+            int len = 0;
+            len = strlen(arg);
+            if (len > UNIX_PATH_MAX) {
+                fprintf(stderr, "output file name too long (%s)\n", arg);
+                return -1;
+            }
 
-                rdd_config.max_ops_per_seq = max_ops;
-        }
-        break;
+            strncpy(rdd_config.out_file.path, arg, len);
+        } break;
 
-        case 't':
-        {
-                char *tmp = NULL;
-                long threads = 0;
-                threads = strtol (arg, &tmp, 10);
-                if ((threads == LONG_MAX) ||
-                    (threads == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for thread count"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
+        case 'i': {
+            int len = 0;
+            len = strlen(arg);
+            if (len > UNIX_PATH_MAX) {
+                fprintf(stderr, "input file name too long (%s)\n", arg);
+                return -1;
+            }
+
+            strncpy(rdd_config.in_file.path, arg, len);
+            rdd_config.in_file.path[len] = '\0';
+        } break;
+
+        case 'f': {
+            char *tmp = NULL;
+            unsigned long long fs = 0;
+            if (string2bytesize(arg, &fs) == -1) {
+                fprintf(stderr,
+                        "invalid argument for file size "
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.file_size = fs;
+        } break;
+
+        case RDD_MIN_BS_KEY: {
+            char *tmp = NULL;
+            long bs = 0;
+            bs = strtol(arg, &tmp, 10);
+            if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for minimum block"
+                        "size (%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.min_bs = bs;
+        } break;
+
+        case RDD_MAX_BS_KEY: {
+            char *tmp = NULL;
+            long bs = 0;
+            bs = strtol(arg, &tmp, 10);
+            if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for maximum block"
+                        "size (%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.max_bs = bs;
+        } break;
+
+        case 'r': {
+            char *tmp = NULL;
+            long iters = 0;
+            iters = strtol(arg, &tmp, 10);
+            if ((iters == LONG_MAX) || (iters == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for iterations"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.iters = iters;
+        } break;
+
+        case 'm': {
+            char *tmp = NULL;
+            long max_ops = 0;
+            max_ops = strtol(arg, &tmp, 10);
+            if ((max_ops == LONG_MAX) || (max_ops == LONG_MIN) ||
+                (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for max-ops"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.max_ops_per_seq = max_ops;
+        } break;
+
+        case 't': {
+            char *tmp = NULL;
+            long threads = 0;
+            threads = strtol(arg, &tmp, 10);
+            if ((threads == LONG_MAX) || (threads == LONG_MIN) ||
+                (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for thread count"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
 
-                rdd_config.thread_count = threads;
-        }
-        break;
+            rdd_config.thread_count = threads;
+        } break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
+            break;
         case ARGP_KEY_END:
-                if (_state->argc == 1) {
-                        argp_usage (_state);
-                }
+            if (_state->argc == 1) {
+                argp_usage(_state);
+            }
+    }
 
-        }
-
-        return 0;
+    return 0;
 }
 
 int
-string2bytesize (const char *str, unsigned long long *n)
+string2bytesize(const char *str, unsigned long long *n)
 {
-        unsigned long long value = 0ULL;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL)
-        {
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++)
-        {
-                if (isspace (*s))
-                {
-                        continue;
-                }
-                if (*s == '-')
-                {
-                        return -1;
-                }
-                break;
+    unsigned long long value = 0ULL;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+
+    if (str == NULL || n == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s)) {
+            continue;
         }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoull (str, &tail, 10);
-
-        if (errno == ERANGE || errno == EINVAL)
-        {
-                return -1;
+        if (*s == '-') {
+            return -1;
         }
-
-        if (errno == 0)
-        {
-                errno = old_errno;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoull(str, &tail, 10);
+
+    if (errno == ERANGE || errno == EINVAL) {
+        return -1;
+    }
+
+    if (errno == 0) {
+        errno = old_errno;
+    }
+
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, UNIT_KB_STRING) == 0) {
+            value *= UNIT_KB;
+        } else if (strcasecmp(tail, UNIT_MB_STRING) == 0) {
+            value *= UNIT_MB;
+        } else if (strcasecmp(tail, UNIT_GB_STRING) == 0) {
+            value *= UNIT_GB;
+        } else if (strcasecmp(tail, UNIT_TB_STRING) == 0) {
+            value *= UNIT_TB;
+        } else if (strcasecmp(tail, UNIT_PB_STRING) == 0) {
+            value *= UNIT_PB;
         }
 
-        if (tail[0] != '\0')
-        {
-                if (strcasecmp (tail, UNIT_KB_STRING) == 0)
-                {
-                        value *= UNIT_KB;
-                }
-                else if (strcasecmp (tail, UNIT_MB_STRING) == 0)
-                {
-                        value *= UNIT_MB;
-                }
-                else if (strcasecmp (tail, UNIT_GB_STRING) == 0)
-                {
-                        value *= UNIT_GB;
-                }
-                else if (strcasecmp (tail, UNIT_TB_STRING) == 0)
-                {
-                        value *= UNIT_TB;
-                }
-                else if (strcasecmp (tail, UNIT_PB_STRING) == 0)
-                {
-                        value *= UNIT_PB;
-                }
-
-                else
-                {
-                        return -1;
-                }
+        else {
+            return -1;
         }
+    }
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static struct argp_option rdd_options[] = {
-        {"if", 'i', "INPUT_FILE", 0, "input-file"},
-        {"of", 'o', "OUTPUT_FILE", 0, "output-file"},
-        {"threads", 't', "COUNT", 0, "number of threads to spawn (defaults to 2)"},
-        {"min-bs", RDD_MIN_BS_KEY, "MIN_BLOCK_SIZE", 0,
-         "Minimum block size in bytes (defaults to 1024)"},
-        {"max-bs", RDD_MAX_BS_KEY, "MAX_BLOCK_SIZE", 0,
-         "Maximum block size in bytes (defaults to 4096)"},
-        {"iters", 'r', "ITERS", 0,
-         "Number of read-write sequences (defaults to 1000000)"},
-        {"max-ops", 'm', "MAXOPS", 0,
-         "maximum number of read-writes to be performed in a sequence (defaults to 1)"},
-        {"file-size", 'f', "FILESIZE", 0,
-         "the size of the file which will be created and upon it I/O will be done"
-         " (defaults to 100MB"},
-        {0, 0, 0, 0, 0}
-};
+    {"if", 'i', "INPUT_FILE", 0, "input-file"},
+    {"of", 'o', "OUTPUT_FILE", 0, "output-file"},
+    {"threads", 't', "COUNT", 0, "number of threads to spawn (defaults to 2)"},
+    {"min-bs", RDD_MIN_BS_KEY, "MIN_BLOCK_SIZE", 0,
+     "Minimum block size in bytes (defaults to 1024)"},
+    {"max-bs", RDD_MAX_BS_KEY, "MAX_BLOCK_SIZE", 0,
+     "Maximum block size in bytes (defaults to 4096)"},
+    {"iters", 'r', "ITERS", 0,
+     "Number of read-write sequences (defaults to 1000000)"},
+    {"max-ops", 'm', "MAXOPS", 0,
+     "maximum number of read-writes to be performed in a sequence (defaults to "
+     "1)"},
+    {"file-size", 'f', "FILESIZE", 0,
+     "the size of the file which will be created and upon it I/O will be done"
+     " (defaults to 100MB"},
+    {0, 0, 0, 0, 0}};
 
 static struct argp argp = {
-  rdd_options,
-  rdd_parse_opts,
-  "",
-  "random dd - tool to do a sequence of random block-sized continuous"
-  "read writes starting at a random offset"
-};
-
+    rdd_options, rdd_parse_opts, "",
+    "random dd - tool to do a sequence of random block-sized continuous"
+    "read writes starting at a random offset"};
 
 static void
-rdd_default_config (void)
+rdd_default_config(void)
 {
-        char *tmp_path = "rdd.in";
-
-        rdd_config.thread_count = 2;
-        rdd_config.iters = 1000000;
-        rdd_config.max_bs = 4096;
-        rdd_config.min_bs = 1024;
-        rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
-        rdd_config.max_ops_per_seq = 1;
-        strncpy (rdd_config.in_file.path, tmp_path, strlen (tmp_path));
-        rdd_config.file_size = 104857600;
-
-        return;
+    char *tmp_path = "rdd.in";
+
+    rdd_config.thread_count = 2;
+    rdd_config.iters = 1000000;
+    rdd_config.max_bs = 4096;
+    rdd_config.min_bs = 1024;
+    rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
+    rdd_config.max_ops_per_seq = 1;
+    strncpy(rdd_config.in_file.path, tmp_path, strlen(tmp_path));
+    rdd_config.file_size = 104857600;
+
+    return;
 }
 
-
 static char
-rdd_valid_config (void)
+rdd_valid_config(void)
 {
-        char ret = 1;
-        int fd = -1;
+    char ret = 1;
+    int fd = -1;
 
-        fd = open (rdd_config.in_file.path, O_RDONLY);
-        if (fd == -1 && (errno != ENOENT)) {
-                fprintf (stderr, "open: (%s)", strerror (errno));
-                ret = 0;
-                goto out;
-        }
-        close (fd);
-
-        if (rdd_config.min_bs > rdd_config.max_bs) {
-                fprintf (stderr, "minimum blocksize %ld is greater than the "
-                         "maximum blocksize %ld", rdd_config.min_bs,
-                         rdd_config.max_bs);
-                ret = 0;
-                goto out;
-        }
+    fd = open(rdd_config.in_file.path, O_RDONLY);
+    if (fd == -1 && (errno != ENOENT)) {
+        fprintf(stderr, "open: (%s)", strerror(errno));
+        ret = 0;
+        goto out;
+    }
+    close(fd);
+
+    if (rdd_config.min_bs > rdd_config.max_bs) {
+        fprintf(stderr,
+                "minimum blocksize %ld is greater than the "
+                "maximum blocksize %ld",
+                rdd_config.min_bs, rdd_config.max_bs);
+        ret = 0;
+        goto out;
+    }
 
-        if (strlen (rdd_config.out_file.path) == 0) {
-                sprintf (rdd_config.out_file.path, "%s.rddout",
-                         rdd_config.in_file.path);
-        }
+    if (strlen(rdd_config.out_file.path) == 0) {
+        sprintf(rdd_config.out_file.path, "%s.rddout", rdd_config.in_file.path);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static void *
-rdd_read_write (void *arg)
+rdd_read_write(void *arg)
 {
-        int i = 0, ret = 0;
-        size_t bs = 0;
-        off_t offset = 0;
-        long rand = 0;
-        long max_ops = 0;
-        char *buf = NULL;
-
-        buf = calloc (1, rdd_config.max_bs);
-        if (!buf) {
-                fprintf (stderr, "calloc failed (%s)\n", strerror (errno));
+    int i = 0, ret = 0;
+    size_t bs = 0;
+    off_t offset = 0;
+    long rand = 0;
+    long max_ops = 0;
+    char *buf = NULL;
+
+    buf = calloc(1, rdd_config.max_bs);
+    if (!buf) {
+        fprintf(stderr, "calloc failed (%s)\n", strerror(errno));
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < rdd_config.iters; i++) {
+        pthread_mutex_lock(&rdd_config.lock);
+        {
+            int bytes = 0;
+            rand = random();
+
+            if (rdd_config.min_bs == rdd_config.max_bs) {
+                bs = rdd_config.max_bs;
+            } else {
+                bs = rdd_config.min_bs +
+                     (rand % (rdd_config.max_bs - rdd_config.min_bs));
+            }
+
+            offset = rand % rdd_config.in_file.st.st_size;
+            max_ops = rand % rdd_config.max_ops_per_seq;
+            if (!max_ops) {
+                max_ops++;
+            }
+
+            ret = lseek(rdd_config.in_file.fd, offset, SEEK_SET);
+            if (ret != offset) {
+                fprintf(stderr, "lseek failed (%s)\n", strerror(errno));
                 ret = -1;
-                goto out;
-        }
+                goto unlock;
+            }
 
-        for (i = 0; i < rdd_config.iters; i++)
-        {
-                pthread_mutex_lock (&rdd_config.lock);
-                {
-                        int bytes = 0;
-                        rand = random ();
-
-                        if (rdd_config.min_bs == rdd_config.max_bs) {
-                                bs = rdd_config.max_bs;
-                        } else {
-                                bs = rdd_config.min_bs +
-                                        (rand %
-                                         (rdd_config.max_bs -
-                                          rdd_config.min_bs));
-                        }
-
-                        offset = rand % rdd_config.in_file.st.st_size;
-                        max_ops = rand % rdd_config.max_ops_per_seq;
-                        if (!max_ops) {
-                                max_ops ++;
-                        }
-
-                        ret = lseek (rdd_config.in_file.fd, offset, SEEK_SET);
-                        if (ret != offset) {
-                                fprintf (stderr, "lseek failed (%s)\n",
-                                         strerror (errno));
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        ret = lseek (rdd_config.out_file.fd, offset, SEEK_SET);
-                        if (ret != offset) {
-                                fprintf (stderr, "lseek failed (%s)\n",
-                                         strerror (errno));
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        while (max_ops--)
-                        {
-                                bytes = read (rdd_config.in_file.fd, buf, bs);
-                                if (!bytes) {
-                                        break;
-                                }
-
-                                if (bytes == -1) {
-                                        fprintf (stderr, "read failed (%s)\n",
-                                                 strerror (errno));
-                                        ret = -1;
-                                        goto unlock;
-                                }
-
-                                if (write (rdd_config.out_file.fd, buf, bytes)
-                                    != bytes) {
-                                        fprintf (stderr, "write failed (%s)\n",
-                                                 strerror (errno));
-                                        ret = -1;
-                                        goto unlock;
-                                }
-                        }
+            ret = lseek(rdd_config.out_file.fd, offset, SEEK_SET);
+            if (ret != offset) {
+                fprintf(stderr, "lseek failed (%s)\n", strerror(errno));
+                ret = -1;
+                goto unlock;
+            }
+
+            while (max_ops--) {
+                bytes = read(rdd_config.in_file.fd, buf, bs);
+                if (!bytes) {
+                    break;
                 }
-        unlock:
-                pthread_mutex_unlock (&rdd_config.lock);
-                if (ret == -1) {
-                        goto out;
+
+                if (bytes == -1) {
+                    fprintf(stderr, "read failed (%s)\n", strerror(errno));
+                    ret = -1;
+                    goto unlock;
+                }
+
+                if (write(rdd_config.out_file.fd, buf, bytes) != bytes) {
+                    fprintf(stderr, "write failed (%s)\n", strerror(errno));
+                    ret = -1;
+                    goto unlock;
                 }
-                ret = 0;
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&rdd_config.lock);
+        if (ret == -1) {
+            goto out;
+        }
+        ret = 0;
+    }
 out:
-        free (buf);
-        pthread_barrier_wait (&rdd_config.barrier);
+    free(buf);
+    pthread_barrier_wait(&rdd_config.barrier);
 
-        return NULL;
+    return NULL;
 }
 
 static void
-cleanup (void)
+cleanup(void)
 {
-        close (rdd_config.in_file.fd);
-        close (rdd_config.out_file.fd);
-        rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
+    close(rdd_config.in_file.fd);
+    close(rdd_config.out_file.fd);
+    rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
 }
 
 static int
-check_and_create (void)
+check_and_create(void)
 {
-        int ret = -1;
-        char buf[4096] = {0,};
-        struct stat stbuf = {0,};
-        int  fd[2] = {-1,};
-        size_t  total_size = -1;
-
-        total_size = rdd_config.file_size;
-
-        ret = stat (rdd_config.in_file.path, &stbuf);
-        if (ret == -1 && (errno != ENOENT))
+    int ret = -1;
+    char buf[4096] = {
+        0,
+    };
+    struct stat stbuf = {
+        0,
+    };
+    int fd[2] = {
+        -1,
+    };
+    size_t total_size = -1;
+
+    total_size = rdd_config.file_size;
+
+    ret = stat(rdd_config.in_file.path, &stbuf);
+    if (ret == -1 && (errno != ENOENT))
+        goto out;
+
+    fd[1] = open(rdd_config.in_file.path, O_CREAT | O_WRONLY | O_TRUNC);
+    if (fd[1] == -1)
+        goto out;
+
+    fd[0] = open("/dev/urandom", O_RDONLY);
+    if (fd[0] == -1)
+        goto out;
+
+    while (total_size > 0) {
+        if (total_size >= 4096) {
+            ret = read(fd[0], buf, 4096);
+            if (ret == -1)
                 goto out;
-
-        fd[1] = open (rdd_config.in_file.path, O_CREAT | O_WRONLY | O_TRUNC);
-        if (fd[1] == -1)
+            ret = write(fd[1], buf, 4096);
+            if (ret == -1)
                 goto out;
-
-        fd[0] = open ("/dev/urandom", O_RDONLY);
-        if (fd[0] == -1)
+            total_size = total_size - 4096;
+        } else {
+            ret = read(fd[0], buf, total_size);
+            if (ret == -1)
                 goto out;
-
-        while (total_size > 0) {
-                if (total_size >= 4096) {
-                        ret = read (fd[0], buf, 4096);
-                        if (ret == -1)
-                                goto out;
-                        ret = write (fd[1], buf, 4096);
-                        if (ret == -1)
-                                goto out;
-                        total_size = total_size - 4096;
-                } else {
-                        ret = read (fd[0], buf, total_size);
-                        if (ret == -1)
-                                goto out;
-                        ret = write (fd[1], buf, total_size);
-                        if (ret == -1)
-                                goto out;
-                        total_size = total_size - total_size;
-                }
-
+            ret = write(fd[1], buf, total_size);
+            if (ret == -1)
+                goto out;
+            total_size = total_size - total_size;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd[0] > 0)
-                close (fd[0]);
-        if (fd[1] > 0)
-                close (fd[1]);
-        return ret;
+    if (fd[0] > 0)
+        close(fd[0]);
+    if (fd[1] > 0)
+        close(fd[1]);
+    return ret;
 }
 
 static int
-rdd_spawn_threads (void)
+rdd_spawn_threads(void)
 {
-        int i = 0, ret = -1, fd = -1;
-        char buf[4096];
-
-        ret = check_and_create ();
-        if (ret == -1)
-                goto out;
-
-        fd = open (rdd_config.in_file.path, O_RDONLY);
-        if (fd < 0) {
-                fprintf (stderr, "cannot open %s (%s)\n",
-                         rdd_config.in_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        ret = fstat (fd, &rdd_config.in_file.st);
-        if (ret != 0) {
-                close (fd);
-                fprintf (stderr, "cannot stat %s (%s)\n",
-                         rdd_config.in_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        rdd_config.in_file.fd = fd;
-
-        fd = open (rdd_config.out_file.path, O_WRONLY | O_CREAT | O_TRUNC,
-                   S_IRWXU | S_IROTH);
-        if (fd < 0) {
-                close (rdd_config.in_file.fd);
-                rdd_config.in_file.fd = -1;
-                fprintf (stderr, "cannot open %s (%s)\n",
-                         rdd_config.out_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        rdd_config.out_file.fd = fd;
-
-        while ((ret = read (rdd_config.in_file.fd, buf, 4096)) > 0) {
-                if (write (rdd_config.out_file.fd, buf, ret) != ret) {
-                        fprintf (stderr, "write failed (%s)\n",
-                                 strerror (errno));
-                        cleanup ();
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        rdd_config.threads = calloc (rdd_config.thread_count,
-                                     sizeof (pthread_t));
-        if (rdd_config.threads == NULL) {
-                fprintf (stderr, "calloc() failed (%s)\n", strerror (errno));
-
-                ret = -1;
-                cleanup ();
-                goto out;
-        }
-
-        ret = pthread_barrier_init (&rdd_config.barrier, NULL,
-                                    rdd_config.thread_count + 1);
-        if (ret != 0) {
-                fprintf (stderr, "pthread_barrier_init() failed (%s)\n",
-                         strerror (ret));
-
-                free (rdd_config.threads);
-                cleanup ();
-                ret = -1;
-                goto out;
+    int i = 0, ret = -1, fd = -1;
+    char buf[4096];
+
+    ret = check_and_create();
+    if (ret == -1)
+        goto out;
+
+    fd = open(rdd_config.in_file.path, O_RDONLY);
+    if (fd < 0) {
+        fprintf(stderr, "cannot open %s (%s)\n", rdd_config.in_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    ret = fstat(fd, &rdd_config.in_file.st);
+    if (ret != 0) {
+        close(fd);
+        fprintf(stderr, "cannot stat %s (%s)\n", rdd_config.in_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    rdd_config.in_file.fd = fd;
+
+    fd = open(rdd_config.out_file.path, O_WRONLY | O_CREAT | O_TRUNC,
+              S_IRWXU | S_IROTH);
+    if (fd < 0) {
+        close(rdd_config.in_file.fd);
+        rdd_config.in_file.fd = -1;
+        fprintf(stderr, "cannot open %s (%s)\n", rdd_config.out_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    rdd_config.out_file.fd = fd;
+
+    while ((ret = read(rdd_config.in_file.fd, buf, 4096)) > 0) {
+        if (write(rdd_config.out_file.fd, buf, ret) != ret) {
+            fprintf(stderr, "write failed (%s)\n", strerror(errno));
+            cleanup();
+            ret = -1;
+            goto out;
         }
-
-        ret = pthread_mutex_init (&rdd_config.lock, NULL);
+    }
+
+    rdd_config.threads = calloc(rdd_config.thread_count, sizeof(pthread_t));
+    if (rdd_config.threads == NULL) {
+        fprintf(stderr, "calloc() failed (%s)\n", strerror(errno));
+
+        ret = -1;
+        cleanup();
+        goto out;
+    }
+
+    ret = pthread_barrier_init(&rdd_config.barrier, NULL,
+                               rdd_config.thread_count + 1);
+    if (ret != 0) {
+        fprintf(stderr, "pthread_barrier_init() failed (%s)\n", strerror(ret));
+
+        free(rdd_config.threads);
+        cleanup();
+        ret = -1;
+        goto out;
+    }
+
+    ret = pthread_mutex_init(&rdd_config.lock, NULL);
+    if (ret != 0) {
+        fprintf(stderr, "pthread_mutex_init() failed (%s)\n", strerror(ret));
+
+        free(rdd_config.threads);
+        pthread_barrier_destroy(&rdd_config.barrier);
+        cleanup();
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < rdd_config.thread_count; i++) {
+        ret = pthread_create(&rdd_config.threads[i], NULL, rdd_read_write,
+                             NULL);
         if (ret != 0) {
-                fprintf (stderr, "pthread_mutex_init() failed (%s)\n",
-                         strerror (ret));
-
-                free (rdd_config.threads);
-                pthread_barrier_destroy (&rdd_config.barrier);
-                cleanup ();
-                ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < rdd_config.thread_count; i++)
-        {
-                ret = pthread_create (&rdd_config.threads[i], NULL,
-                                      rdd_read_write, NULL);
-                if (ret != 0) {
-                        fprintf (stderr, "pthread_create failed (%s)\n",
-                                 strerror (errno));
-                        exit (1);
-                }
+            fprintf(stderr, "pthread_create failed (%s)\n", strerror(errno));
+            exit(1);
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static void
-rdd_wait_for_completion (void)
+rdd_wait_for_completion(void)
 {
-        pthread_barrier_wait (&rdd_config.barrier);
+    pthread_barrier_wait(&rdd_config.barrier);
 }
 
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int ret = -1;
+    int ret = -1;
 
-        rdd_default_config ();
+    rdd_default_config();
 
-        ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "%s: argp_parse() failed\n", argv[0]);
-                goto err;
-        }
+    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "%s: argp_parse() failed\n", argv[0]);
+        goto err;
+    }
 
-        if (!rdd_valid_config ()) {
-                ret = -1;
-                fprintf (stderr, "%s: configuration validation failed\n",
-                         argv[0]);
-                goto err;
-        }
+    if (!rdd_valid_config()) {
+        ret = -1;
+        fprintf(stderr, "%s: configuration validation failed\n", argv[0]);
+        goto err;
+    }
 
-        ret = rdd_spawn_threads ();
-        if (ret != 0) {
-                fprintf (stderr, "%s: spawning threads failed\n", argv[0]);
-                goto err;
-        }
+    ret = rdd_spawn_threads();
+    if (ret != 0) {
+        fprintf(stderr, "%s: spawning threads failed\n", argv[0]);
+        goto err;
+    }
 
-        rdd_wait_for_completion ();
+    rdd_wait_for_completion();
 
 err:
-        return ret;
+    return ret;
 }
diff --git a/extras/cliutils/README.md b/extras/cliutils/README.md
index ccb60802c3d..309beb1ca25 100644
--- a/extras/cliutils/README.md
+++ b/extras/cliutils/README.md
@@ -81,7 +81,7 @@ to address the following issues
 Create a file in `$LIBEXEC/glusterfs/peer_message.py` with following
 content.
 
-    #!/usr/bin/env python
+    #!/usr/bin/python3
     from gluster.cliutils import Cmd, runcli, execute_in_peers, node_output_ok
 
     class NodeHello(Cmd):
@@ -149,7 +149,7 @@ Now users can use `gluster-message` instead of calling
 Following example uses prettytable library, which can be installed
 using `pip install prettytable` or `dnf install python-prettytable`
 
-    #!/usr/bin/env python
+    #!/usr/bin/python3
     from prettytable import PrettyTable
     from gluster.cliutils import Cmd, runcli, execute_in_peers, node_output_ok
 
@@ -221,7 +221,7 @@ required.(Under `%files` section)
 - gluster-mountbroker   http://review.gluster.org/14544
 - gluster-eventsapi     http://review.gluster.org/14248
 - gluster-georep-sshkey http://review.gluster.org/14732
-- gluster-restapi       https://github.com/aravindavk/glusterfs-restapi
+- gluster-restapi       https://github.com/gluster/restapi
 
 ## Limitations/TODOs
 - Not yet possible to create CLI without any subcommand, For example
diff --git a/extras/cliutils/__init__.py b/extras/cliutils/__init__.py
index 9c930982be0..8765cc85099 100644
--- a/extras/cliutils/__init__.py
+++ b/extras/cliutils/__init__.py
@@ -1,18 +1,18 @@
 # -*- coding: utf-8 -*-
 # Reexporting the utility funcs and classes
-from cliutils import (runcli,
-                      sync_file_to_peers,
-                      execute_in_peers,
-                      execute,
-                      node_output_ok,
-                      node_output_notok,
-                      output_error,
-                      oknotok,
-                      yesno,
-                      get_node_uuid,
-                      Cmd,
-                      GlusterCmdException,
-                      set_common_args_func)
+from .cliutils import (runcli,
+                       sync_file_to_peers,
+                       execute_in_peers,
+                       execute,
+                       node_output_ok,
+                       node_output_notok,
+                       output_error,
+                       oknotok,
+                       yesno,
+                       get_node_uuid,
+                       Cmd,
+                       GlusterCmdException,
+                       set_common_args_func)
 
 
 # This will be useful when `from cliutils import *`
diff --git a/extras/cliutils/cliutils.py b/extras/cliutils/cliutils.py
index d805ac6d100..55fbaf56704 100644
--- a/extras/cliutils/cliutils.py
+++ b/extras/cliutils/cliutils.py
@@ -20,7 +20,14 @@ _common_args_func = lambda p: True
 
 
 class GlusterCmdException(Exception):
-    pass
+    def __init__(self, message):
+        self.message = message
+        try:
+            # Python 3
+            super().__init__(message)
+        except TypeError:
+            # Python 2
+            super(GlusterCmdException, self).__init__(message)
 
 
 def get_node_uuid():
@@ -71,7 +78,8 @@ def node_output_notok(message):
 
 
 def execute(cmd):
-    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                         universal_newlines=True)
     out, err = p.communicate()
     return p.returncode, out, err
 
diff --git a/extras/collect-system-stats.sh b/extras/collect-system-stats.sh
new file mode 100755
index 00000000000..865e70bbc11
--- /dev/null
+++ b/extras/collect-system-stats.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+################################################################################
+# Usage: collect-system-stats.sh <delay-in-seconds>
+# This script starts sar/top/iostat/vmstat processes which collect system stats
+# with the interval <delay-in-seconds> given as argument to the script. When
+# the script is stopped either by entering any input or Ctrl+C the list of
+# files where output is captured will be printed on the screen which can be
+# observed to find any problems/bottlenecks.
+###############################################################################
+
+function stop_processes {
+        echo "Stopping the monitoring processes"
+        echo "sar pid:$sar_pid", "top pid: $top_pid", "iostat pid: $iostat_pid", "vmstat pid: $vmstat_pid"
+        kill "$sar_pid" "$top_pid" "$iostat_pid" "$vmstat_pid"
+        echo "Files created: ${timestamp}-network.out, ${timestamp}-top.out, ${timestamp}-iostat.out, ${timestamp}-vmstat.out"
+}
+
+function check_dependent_commands_exist()
+{
+        declare -a arr=("sar" "top" "iostat" "vmstat")
+        for i in "${arr[@]}"
+        do
+                if ! command -v "$i" > /dev/null 2>&1
+                then
+                        echo "ERROR: '$i' command is not found"
+                        exit 1
+                fi
+        done
+
+}
+
+case "$1" in
+    ''|*[!0-9]*) echo "Usage: $0 <delay-between-successive-metrics-collection-in-seconds>"; exit 1 ;;
+    *) interval="$1" ;;
+esac
+
+timestamp=$(date +"%s")
+
+check_dependent_commands_exist
+sar -n DEV "$interval" > "${timestamp}"-network.out &
+sar_pid="$!"
+top -bHd "$interval" > "${timestamp}"-top.out &
+top_pid="$!"
+iostat -Ntkdx "$interval" > "${timestamp}"-iostat.out &
+iostat_pid="$!"
+vmstat -t "$interval" > "${timestamp}"-vmstat.out &
+vmstat_pid="$!"
+echo "Started sar, vmstat, iostat, top for collecting stats"
+
+
+trap stop_processes EXIT
+read -r -p "Press anything and ENTER to exit";
diff --git a/extras/command-completion/gluster.bash b/extras/command-completion/gluster.bash
index 680ecd964d5..73d16098875 100644
--- a/extras/command-completion/gluster.bash
+++ b/extras/command-completion/gluster.bash
@@ -26,28 +26,28 @@ GLUSTER_TOP_SUBOPTIONS2="
 "
 GLUSTER_TOP_OPTIONS="
         {open
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {read
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {write
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {opendir
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {readdir
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {clear
-                [ $TOP_SUBOPTIONS1 ]
+                [ $GLUSTER_TOP_SUBOPTIONS1 ]
         },
         {read-perf
-                [ $TOP_SUBOPTIONS2 ]
+                [ $GLUSTER_TOP_SUBOPTIONS2 ]
         },
         {write-perf
-                [ $TOP_SUBOPTIONS2 ]
+                [ $GLUSTER_TOP_SUBOPTIONS2 ]
         }
 "
 
@@ -282,16 +282,16 @@ _gluster_throw () {
         exit
 }
 
-declare FINAL_LIST=''
-declare LIST=''
-declare -i TOP=0
+declare GLUSTER_FINAL_LIST=''
+declare GLUSTER_LIST=''
+declare -i GLUSTER_TOP=0
 _gluster_push () {
-        TOP=$((TOP + 1))
-        return $TOP
+        GLUSTER_TOP=$((GLUSTER_TOP + 1))
+        return $GLUSTER_TOP
 }
 _gluster_pop () {
-        TOP=$((TOP - 1))
-        return $TOP
+        GLUSTER_TOP=$((GLUSTER_TOP - 1))
+        return $GLUSTER_TOP
 }
 
 _gluster_goto_end ()
@@ -333,7 +333,7 @@ _gluster_form_list ()
                 top=$?
                 read -r key
                 if [ "X$cur_word" == "X" -o "${cur_word:0:1}" == "${key:0:1}" -o "${key:0:1}" == "_" ]; then
-                        LIST="$LIST $key"
+                        GLUSTER_LIST="$GLUSTER_LIST $key"
                 fi
 
                 _gluster_goto_end $top
@@ -452,10 +452,10 @@ _gluster_parse ()
 
         elif [ "$token" == '{' ]; then
                 read -r tmp_token
-                LIST="$tmp_token"
+                GLUSTER_LIST="$tmp_token"
         fi
 
-        echo $LIST
+        echo $GLUSTER_LIST
 }
 
 _gluster_handle_list ()
@@ -479,12 +479,12 @@ _gluster_handle_list ()
 
 _gluster_completion ()
 {
-        FINAL_LIST=`echo $GLUSTER_COMMAND_TREE |                              \
+        GLUSTER_FINAL_LIST=`echo $GLUSTER_COMMAND_TREE |                      \
                 egrep -ao --color=never "([A-Za-z0-9_.-]+)|[[:space:]]+|." |  \
                         egrep -v --color=never "^[[:space:]]*$" |             \
                                 _gluster_parse`
 
-        ARG="FINAL_LIST"
+        ARG="GLUSTER_FINAL_LIST"
         _gluster_handle_list $ARG ${COMP_WORDS[COMP_CWORD]}
         return
 }
diff --git a/extras/control-cpu-load.sh b/extras/control-cpu-load.sh
new file mode 100755
index 00000000000..52dcf62fd9f
--- /dev/null
+++ b/extras/control-cpu-load.sh
@@ -0,0 +1,116 @@
+#!/bin/bash
+
+USAGE="This script provides a utility to control CPU utilization for any
+gluster daemon.In this, we use cgroup framework to configure CPU quota
+for a process(like selfheal daemon). Before running this script, make
+sure that daemon is running.Every time daemon restarts, it is required
+to rerun this command to set CPU quota on new daemon process id.
+User can enter any value between 10 to 100 for CPU quota.
+Recommended value of quota period is 25. 25 means, kernel will allocate
+25 ms period to this group of tasks in every 100 ms period. This 25ms
+could be considered as the maximum percentage of CPU quota daemon can take.
+This value will be reflected on CPU usage of "top" command.If provided pid
+is the only process and no other process is in competition to get CPU, more
+ than 25% could be allocated to daemon to speed up the process."
+
+if [  $# -ge 1 ]; then
+  case $1 in
+    -h|--help) echo " " "$USAGE" | sed -r -e 's/^[ ]+//g'
+               exit 0;
+               ;;
+  *) echo "Please Provide correct input for script."
+     echo "For help correct options are -h or --help."
+     exit 1;
+               ;;
+  esac
+fi
+
+DIR_EXIST=0
+LOC="/sys/fs/cgroup/cpu,cpuacct/system.slice/glusterd.service"
+echo "Enter gluster daemon pid for which you want to control CPU."
+read daemon_pid
+
+if expr ${daemon_pid} + 0 > /dev/null 2>&1 ;then
+  CHECK_PID=$(pgrep -f gluster | grep ${daemon_pid})
+  if [ -z "${CHECK_PID}" ]; then
+    echo "No daemon is running or pid ${daemon_pid} does not match."
+    echo "with running gluster processes."
+    exit 1
+  fi
+else
+  echo "Entered daemon_pid is not numeric so Rerun the script."
+  exit 1
+fi
+
+
+if [ -f ${LOC}/tasks ];then
+  CHECK_CGROUP=$(grep ${daemon_pid} ${LOC}/tasks)
+  if [ ${CHECK_CGROUP} ]; then
+    echo "pid ${daemon_pid} is attached with glusterd.service cgroup."
+  fi
+fi
+
+cgroup_name=cgroup_gluster_${daemon_pid}
+if [ -f ${LOC}/${cgroup_name}/tasks ]; then
+  CHECK_CGROUP=$(grep ${daemon_pid} ${LOC}/${cgroup_name}/tasks)
+  if [ ${CHECK_CGROUP} ]; then
+    val=`cat ${LOC}/${cgroup_name}/cpu.cfs_quota_us`
+    qval=$((val / 1000))
+    echo "pid ${daemon_pid} is already attached ${cgroup_name} with quota value ${qval}."
+    echo "Press n if you don't want to reassign ${daemon_pid} with new quota value."
+    DIR_EXIST=1
+  else
+    echo "pid ${daemon_pid} is not attached with ${cgroup_name}."
+  fi
+fi
+
+read -p "If you want to continue the script to attach ${daemon_pid} with new ${cgroup_name} cgroup Press (y/n)?" choice
+case "$choice" in
+  y|Y ) echo "yes";;
+  n|N ) echo "no";exit;;
+  * ) echo "invalid";exit;;
+esac
+
+systemctl set-property glusterd.service CPUShares=1024
+
+if [ ${DIR_EXIST} -eq 0 ];then
+  echo "Creating child cgroup directory '${cgroup_name} cgroup' for glusterd.service."
+  mkdir -p ${LOC}/${cgroup_name}
+  if [ ! -f ${LOC}/${cgroup_name}/tasks ];then
+    echo "Not able to create ${cgroup_name} directory so exit."
+    exit 1
+  fi
+fi
+
+echo "Enter quota value in range [10,100]:  "
+
+read quota_value
+if expr ${quota_value} + 0 > /dev/null 2>&1 ;then
+  if [ ${quota_value} -lt 10 ] || [ ${quota_value} -gt 100 ]; then
+    echo "Entered quota value is not correct,it should be in the range ."
+    echo "10-100. Ideal value is 25."
+    echo "Rerun the sript with correct value."
+    exit 1
+  else
+    echo "Entered quota value is $quota_value"
+  fi
+else
+  echo "Entered quota value is not numeric so Rerun the script."
+  exit 1
+fi
+
+quota_value=$((quota_value * 1000))
+echo "Setting $quota_value to cpu.cfs_quota_us for gluster_cgroup."
+echo ${quota_value} > ${LOC}/${cgroup_name}/cpu.cfs_quota_us
+
+if ps -T -p ${daemon_pid} | grep gluster > /dev/null; then
+  for thid in `ps -T -p ${daemon_pid} | grep -v SPID | awk -F " " '{print $2}'`;
+    do
+      echo ${thid} > ${LOC}/${cgroup_name}/tasks ;
+    done
+  if cat /proc/${daemon_pid}/cgroup | grep -w ${cgroup_name} > /dev/null; then
+    echo "Tasks are attached successfully specific to ${daemon_pid} to ${cgroup_name}."
+  else
+    echo "Tasks are not attached successfully."
+  fi
+fi
diff --git a/extras/control-mem.sh b/extras/control-mem.sh
new file mode 100755
index 00000000000..91b36f8107a
--- /dev/null
+++ b/extras/control-mem.sh
@@ -0,0 +1,128 @@
+#!/bin/bash
+
+USAGE="This commands provides a utility to control MEMORY utilization for any
+gluster daemon.In this, we use cgroup framework to configure MEMORY limit for
+a process. Before running this script, make sure that daemon is running.Every
+time daemon restarts, it is required to rerun this command to set memory limit
+(in bytes) on new daemon process id.User can enter any value between 100
+(in Mega bytes) to 8000000000000 for Memory limit in Mega bytes.
+Memory limit value is depends on how much maximum memory user wants to restrict
+for specific daemon process.If a process will try to consume memore more than
+configured value then cgroup will hang/sleep this task and to resume the task
+rerun the script with new increase memory limit value ."
+
+if [  $# -ge 1 ]; then
+  case $1 in
+    -h|--help) echo " " "$USAGE" | sed -r -e 's/^[ ]+//g'
+               exit 0;
+               ;;
+    *) echo "Please Provide correct input for script."
+       echo "For help correct options are -h of --help."
+       exit 1;
+               ;;
+  esac
+fi
+
+DIR_EXIST=0
+LOC="/sys/fs/cgroup/memory/system.slice/glusterd.service"
+echo "Enter Any gluster daemon pid for that you want to control MEMORY."
+read daemon_pid
+
+if expr ${daemon_pid} + 0 > /dev/null 2>&1 ;then
+  CHECK_PID=$(pgrep -f gluster | grep ${daemon_pid})
+  if [ -z "${CHECK_PID}" ]; then
+    echo "No daemon is running or pid ${daemon_pid} does not match."
+    echo "with running gluster processes."
+    exit 1
+  fi
+else
+  echo "Entered daemon_pid is not numeric so Rerun the script."
+  exit 1
+fi
+
+
+if [ -f ${LOC}/tasks ]; then
+  CHECK_CGROUP=$(grep ${daemon_pid} ${LOC}/tasks)
+  if [ ${CHECK_CGROUP} ] ;then
+    echo "pid ${daemon_pid} is attached with default glusterd.service cgroup."
+  fi
+fi
+
+cgroup_name=cgroup_gluster_${daemon_pid}
+if [ -f ${LOC}/${cgroup_name}/tasks ];then
+  CHECK_CGROUP=$(grep ${daemon_pid} ${LOC}/${cgroup_name}/tasks)
+  if [ ${CHECK_CGROUP} ]; then
+    val=`cat ${LOC}/${cgroup_name}/memory.limit_in_bytes`
+    mval=$((val / 1024 / 1024))
+    echo "pid ${daemon_pid} is already attached ${cgroup_name} with mem value ${mval}."
+    echo "Press n if you don't want to reassign ${daemon_pid} with new mem value."
+    DIR_EXIST=1
+  else
+    echo "pid ${daemon_pid} is not attached with ${cgroup_name}."
+  fi
+fi
+
+read -p "If you want to continue the script to attach daeomon with new cgroup. Press (y/n)?" choice
+case "$choice" in
+  y|Y ) echo "yes";;
+  n|N ) echo "no";exit;;
+  * ) echo "invalid";exit;;
+esac
+
+systemctl set-property glusterd.service CPUShares=1024
+
+if [ ${DIR_EXIST} -eq 0 ];then
+  echo "Creating child cgroup directory '${cgroup_name} cgroup' for glusterd.service."
+  mkdir -p ${LOC}/${cgroup_name}
+  if [ ! -f ${LOC}/${cgroup_name}/tasks ];then
+    echo "Not able to create ${LOC}/${cgroup_name} directory so exit."
+    exit 1
+  fi
+fi
+
+echo "Enter Memory value in Mega bytes [100,8000000000000]:  "
+
+read mem_value
+if expr ${mem_value} + 0 > /dev/null 2>&1 ;then
+  if [ ${mem_value} -lt 100 ] || [ ${mem_value} -gt 8000000000000 ]; then
+    echo "Entered memory value is not correct,it should be in the range ."
+    echo "100-8000000000000, Rerun the script with correct value ."
+    exit 1
+  else
+    echo "Entered memory limit value is ${mem_value}."
+  fi
+else
+  echo "Entered memory value is not numeric so Rerun the script."
+  exit 1
+fi
+
+mem_value=$(($mem_value * 1024 * 1024))
+if [ ${DIR_EXIST} -eq 0 ];then
+  echo "Setting ${mem_value} to memory.limit_in_bytes for ${LOC}/${cgroup_name}."
+  echo ${mem_value} > ${LOC}/${cgroup_name}/memory.limit_in_bytes
+  #Set memory value to memory.memsw.limit_in_bytes
+  echo ${mem_value} > ${LOC}/${cgroup_name}/memory.memsw.limit_in_bytes
+  # disable oom_control so that kernel will not send kill signal to the
+  # task once limit has reached
+  echo 1 > ${LOC}/${cgroup_name}/memory.oom_control
+else
+  #Increase mem_value to memory.memsw.limit_in_bytes
+  echo ${mem_value} > ${LOC}/${cgroup_name}/memory.memsw.limit_in_bytes
+  echo "Increase ${mem_value} to memory.limit_in_bytes for ${LOC}/${cgroup_name}."
+  echo ${mem_value} > ${LOC}/${cgroup_name}/memory.limit_in_bytes
+  # disable oom_control so that kernel will not send kill signal to the
+  # task once limit has reached
+  echo 1 > ${LOC}/${cgroup_name}/memory.oom_control
+fi
+
+if ps -T -p ${daemon_pid} | grep gluster > /dev/null; then
+  for thid in `ps -T -p ${daemon_pid} | grep -v SPID | awk -F " " '{print $2}'`;
+    do
+      echo ${thid} > ${LOC}/${cgroup_name}/tasks ;
+    done
+  if cat /proc/${daemon_pid}/cgroup | grep -iw ${cgroup_name} > /dev/null; then
+    echo "Tasks are attached successfully specific to ${daemon_pid} to ${cgroup_name}."
+  else
+    echo "Tasks are not attached successfully."
+  fi
+fi
diff --git a/extras/create_new_xlator/generate_xlator.py b/extras/create_new_xlator/generate_xlator.py
index 2dbf470eafb..983868c04db 100755
--- a/extras/create_new_xlator/generate_xlator.py
+++ b/extras/create_new_xlator/generate_xlator.py
@@ -1,4 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
+
+from __future__ import print_function
 import os
 import re
 import sys
@@ -34,11 +36,11 @@ def get_error_arg(type_str):
 
 def get_param(names, types):
         # Convert two separate tuples to one of (name, type) sub-tuples.
-        as_tuples = zip(types, names)
+        as_tuples = list(zip(types, names))
         # Convert each sub-tuple into a "type name" string.
-        as_strings = map(string.join, as_tuples)
+        as_strings = [' '.join(item) for item in as_tuples]
         # Join all of those into one big string.
-        return string.join(as_strings, ",\n\t")
+        return ',\n\t'.join(as_strings)
 
 
 def generate(tmpl, name, table):
@@ -54,18 +56,18 @@ def generate(tmpl, name, table):
         sdict = {}
         #Parameters are (t1, var1), (t2, var2)...
         #Args are (var1, var2,...)
-        sdict["@WIND_ARGS@"] = string.join(w_arg_names, ", ")
-        sdict["@UNWIND_ARGS@"] = string.join(u_arg_names, ", ")
-        sdict["@ERROR_ARGS@"] = string.join(map(get_error_arg, u_arg_types), ", ")
+        sdict["@WIND_ARGS@"] = ', '.join(w_arg_names)
+        sdict["@UNWIND_ARGS@"] = ', '.join(u_arg_names)
+        sdict["@ERROR_ARGS@"] = ', '.join(list(map(get_error_arg, u_arg_types)))
         sdict["@WIND_PARAMS@"] = get_param(w_arg_names, w_arg_types)
         sdict["@UNWIND_PARAMS@"] = get_param(u_arg_names, u_arg_types)
         sdict["@FUNC_PARAMS@"] = get_param(fn_arg_names, fn_arg_types)
         sdict["@NAME@"] = name
         sdict["@FOP_PREFIX@"] = fop_prefix
-        sdict["@RET_TYPE@"] = string.join(ret_type, "")
-        sdict["@RET_VAR@"] = string.join(ret_var, "")
+        sdict["@RET_TYPE@"] = ''.join(ret_type)
+        sdict["@RET_VAR@"] = ''.join(ret_var)
 
-        for old, new in sdict.iteritems():
+        for old, new in sdict.items():
                 tmpl = tmpl.replace(old, new)
         # TBD: reindent/reformat the result for maximum readability.
         return tmpl
@@ -74,42 +76,44 @@ def generate(tmpl, name, table):
 def gen_xlator():
         xl = open(src_dir_path+"/"+xl_name+".c", 'w+')
 
-        print >> xl, COPYRIGHT
-        print >> xl, fragments["INCLUDE_IN_SRC_FILE"].replace("@XL_NAME@",
-                                                              xl_name)
+        print(COPYRIGHT, file=xl)
+        print(fragments["INCLUDE_IN_SRC_FILE"].replace("@XL_NAME@",
+                                                              xl_name), file=xl)
 
         #Generate cbks and fops
         for fop in ops:
-                print >> xl, generate(fragments["CBK_TEMPLATE"], fop, ops)
-                print >> xl, generate(fragments["FOP_TEMPLATE"], fop, ops)
+                print(generate(fragments["CBK_TEMPLATE"], fop, ops), file=xl)
+                print(generate(fragments["FOP_TEMPLATE"], fop, ops), file=xl)
 
         for cbk in xlator_cbks:
-                print >> xl, generate(fragments["FUNC_TEMPLATE"], cbk,
-                                      xlator_cbks)
+                print(generate(fragments["FUNC_TEMPLATE"], cbk,
+                                      xlator_cbks), file=xl)
 
         for dops in xlator_dumpops:
-                print >> xl, generate(fragments["FUNC_TEMPLATE"], dops,
-                                      xlator_dumpops)
-
-        print >> xl, fragments["XLATOR_METHODS"]
+                print(generate(fragments["FUNC_TEMPLATE"], dops,
+                                      xlator_dumpops), file=xl)
 
         #Generate fop table
-        print >> xl, "struct xlator_fops fops = {"
+        print("struct xlator_fops fops = {", file=xl)
         for fop in ops:
-                print >> xl, "        .{0:20} = {1}_{2},".format(fop, fop_prefix, fop)
-        print >> xl, "};"
+                print("        .{0:20} = {1}_{2},".format(fop, fop_prefix, fop), file=xl)
+        print("};", file=xl)
 
         #Generate xlator_cbks table
-        print >> xl, "struct xlator_cbks cbks = {"
+        print("struct xlator_cbks cbks = {", file=xl)
         for cbk in xlator_cbks:
-                print >> xl, "        .{0:20} = {1}_{2},".format(cbk, fop_prefix, cbk)
-        print >> xl, "};"
+                print("        .{0:20} = {1}_{2},".format(cbk, fop_prefix, cbk), file=xl)
+        print("};", file=xl)
 
         #Generate xlator_dumpops table
-        print >> xl, "struct xlator_dumpops dumpops = {"
+        print("struct xlator_dumpops dumpops = {", file=xl)
         for dops in xlator_dumpops:
-                print >> xl, "        .{0:20} = {1}_{2},".format(dops, fop_prefix, dops)
-        print >> xl, "};"
+                print("        .{0:20} = {1}_{2},".format(dops, fop_prefix, dops), file=xl)
+        print("};", file=xl)
+
+        xlator_methods = fragments["XLATOR_METHODS"].replace("@XL_NAME@", xl_name)
+        xlator_methods = xlator_methods.replace("@FOP_PREFIX@", fop_prefix)
+        print(xlator_methods, file=xl)
 
         xl.close()
 
@@ -122,38 +126,37 @@ def create_dir_struct():
 def gen_header_files():
         upname = xl_name_no_hyphen.upper()
         h = open(src_dir_path+"/"+xl_name+".h", 'w+')
-        print >> h, COPYRIGHT
+        print(COPYRIGHT, file=h)
         txt = fragments["HEADER_FMT"].replace("@HFL_NAME@", upname)
-        txt2 = fragments["INCLUDE_IN_HEADER_FILE"].replace("@XL_NAME@", xl_name)
-        txt = txt.replace("@INCLUDE_SECT@",txt2)
-        print >> h, txt
+        txt = txt.replace("@XL_NAME@", xl_name)
+        print(txt, file=h)
         h.close()
 
         h = open(src_dir_path+"/"+xl_name+"-mem-types.h", 'w+')
-        print >> h, COPYRIGHT
-        txt = fragments["HEADER_FMT"].replace("@HFL_NAME@", upname+"_MEM_TYPES")
-        txt = txt.replace("@INCLUDE_SECT@", '#include "mem-types.h"')
-        print >> h, txt
+        print(COPYRIGHT, file=h)
+        txt = fragments["MEM_HEADER_FMT"].replace("@HFL_NAME@", upname+"_MEM_TYPES")
+        txt = txt.replace("@FOP_PREFIX@", fop_prefix)
+        print(txt, file=h)
         h.close()
 
         h = open(src_dir_path+"/"+xl_name+"-messages.h", 'w+')
-        print >> h, COPYRIGHT
-        txt = fragments["HEADER_FMT"].replace("@HFL_NAME@", upname+"_MESSAGES")
-        txt = txt.replace("@INCLUDE_SECT@", '')
-        print >> h, txt
+        print(COPYRIGHT, file=h)
+        txt = fragments["MSG_HEADER_FMT"].replace("@HFL_NAME@", upname+"_MESSAGES")
+        txt = txt.replace("@FOP_PREFIX@", fop_prefix.upper())
+        print(txt, file=h)
         h.close()
 
 
 def gen_makefiles():
         m = open(dir_path+"/Makefile.am", 'w+')
-        print >> m, "SUBDIRS = src\n\nCLEANFILES ="
+        print("SUBDIRS = src\n\nCLEANFILES =", file=m)
         m.close()
 
         m = open(src_dir_path+"/Makefile.am", 'w+')
         txt = MAKEFILE_FMT.replace("@XL_NAME@", xl_name)
         txt = txt.replace("@XL_NAME_NO_HYPHEN@", xl_name_no_hyphen)
-        txt = txt.replace("@XL_TYPE@",xlator_type)
-        print >> m, txt
+        txt = txt.replace("@XL_TYPE@", xlator_type)
+        print(txt, file=m)
         m.close()
 
 def get_copyright ():
@@ -166,8 +169,8 @@ def load_fragments ():
         cur_value = ""
         result = {}
         basepath = os.path.abspath(os.path.dirname(__file__))
-        fragpath = basepath + "/new-xlator-tmpl.c"
-        for line in open(fragpath,"r").readlines():
+        fragpath = basepath + "/new-xlator.c.tmpl"
+        for line in open(fragpath, "r").readlines():
                 m = pragma_re.search(line)
                 if m:
                         if cur_symbol:
@@ -183,7 +186,7 @@ def load_fragments ():
 if __name__ == '__main__':
 
         if len(sys.argv) < 3:
-                print "USAGE: ./gen_xlator <XLATOR_DIR> <XLATOR_NAME> <FOP_PREFIX>"
+                print("USAGE: ./gen_xlator <XLATOR_DIR> <XLATOR_NAME> <FOP_PREFIX>")
                 sys.exit(0)
 
         xl_name = sys.argv[2]
diff --git a/extras/create_new_xlator/new-xlator-tmpl.c b/extras/create_new_xlator/new-xlator-tmpl.c
deleted file mode 100644
index ac08f3732a7..00000000000
--- a/extras/create_new_xlator/new-xlator-tmpl.c
+++ /dev/null
@@ -1,89 +0,0 @@
-#pragma fragment CBK_TEMPLATE
-int32_t
-@FOP_PREFIX@_@NAME@_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-        int32_t op_ret, int32_t op_errno, @UNWIND_PARAMS@)
-{
-        STACK_UNWIND_STRICT (@NAME@, frame, op_ret, op_errno,
-                             @UNWIND_ARGS@);
-        return 0;
-}
-
-#pragma fragment COMMENT
-If you are generating the leaf xlators, remove the STACK_WIND
-and replace the @ERROR_ARGS@ to @UNWIND_ARGS@ if necessary
-
-#pragma fragment FOP_TEMPLATE
-int32_t
-@FOP_PREFIX@_@NAME@ (call_frame_t *frame, xlator_t *this,
-        @WIND_PARAMS@)
-{
-        STACK_WIND (frame, @FOP_PREFIX@_@NAME@_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->@NAME@,
-                    @WIND_ARGS@);
-        return 0;
-err:
-        STACK_UNWIND_STRICT (@NAME@, frame, -1, errno,
-                             @ERROR_ARGS@);
-        return 0;
-}
-
-#pragma fragment FUNC_TEMPLATE
-@RET_TYPE@
-@FOP_PREFIX@_@NAME@ (@FUNC_PARAMS@)
-{
-        return @RET_VAR@;
-}
-
-#pragma fragment CP
-/*
- *   Copyright (c) @CURRENT_YEAR@ Red Hat, Inc. <http://www.redhat.com>
- *   This file is part of GlusterFS.
- *
- *   This file is licensed to you under your choice of the GNU Lesser
- *   General Public License, version 3 or any later version (LGPLv3 or
- *   later), or the GNU General Public License, version 2 (GPLv2), in all
- *   cases as published by the Free Software Foundation.
- */
-
-#pragma fragment INCLUDE_IN_SRC_FILE
-#include "@XL_NAME@.h"
-
-#pragma fragment INCLUDE_IN_HEADER_FILE
-#include "@XL_NAME@-mem-types.h"
-#include "@XL_NAME@-messages.h"
-#include "glusterfs.h"
-#include "xlator.h"
-#include "defaults.h"
-
-#pragma fragment XLATOR_METHODS
-int32_t
-init (xlator_t *this)
-{
-        return 0;
-}
-
-void
-fini (xlator_t *this)
-{
-        return;
-}
-
-int32_t
-reconfigure (xlator_t *this, dict_t *dict)
-{
-        return 0;
-}
-
-int
-notify (xlator_t *this, int event, void *data, ...)
-{
-        return default_notify (this, event, data);
-}
-
-#pragma fragment HEADER_FMT
-#ifndef __@HFL_NAME@_H__
-#define __@HFL_NAME@_H__
-
-@INCLUDE_SECT@
-
-#endif /* __@HFL_NAME@_H__ */
diff --git a/extras/create_new_xlator/new-xlator.c.tmpl b/extras/create_new_xlator/new-xlator.c.tmpl
new file mode 100644
index 00000000000..fe9735bfcf1
--- /dev/null
+++ b/extras/create_new_xlator/new-xlator.c.tmpl
@@ -0,0 +1,151 @@
+#pragma fragment CBK_TEMPLATE
+int32_t @FOP_PREFIX@_@NAME@_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, @UNWIND_PARAMS@)
+{
+    STACK_UNWIND_STRICT(@NAME@, frame, op_ret, op_errno, @UNWIND_ARGS@);
+    return 0;
+}
+
+#pragma fragment COMMENT
+If you are generating the leaf xlators, remove the STACK_WIND and replace the
+    @ERROR_ARGS@ to @UNWIND_ARGS@ if necessary
+
+#pragma fragment FOP_TEMPLATE
+        int32_t @FOP_PREFIX@_@NAME@(call_frame_t *frame, xlator_t *this, @WIND_PARAMS@)
+{
+    STACK_WIND(frame, @FOP_PREFIX@_@NAME@_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->@NAME@, @WIND_ARGS@);
+    return 0;
+err:
+    STACK_UNWIND_STRICT(@NAME@, frame, -1, errno, @ERROR_ARGS@);
+    return 0;
+}
+
+#pragma fragment FUNC_TEMPLATE
+@RET_TYPE@ @FOP_PREFIX@_@NAME@(@FUNC_PARAMS@)
+{
+    return @RET_VAR@;
+}
+
+#pragma fragment CP
+/*
+ *   Copyright (c) @CURRENT_YEAR@ Red Hat, Inc. <http://www.redhat.com>
+ *   This file is part of GlusterFS.
+ *
+ *   This file is licensed to you under your choice of the GNU Lesser
+ *   General Public License, version 3 or any later version (LGPLv3 or
+ *   later), or the GNU General Public License, version 2 (GPLv2), in all
+ *   cases as published by the Free Software Foundation.
+ */
+
+#pragma fragment INCLUDE_IN_SRC_FILE
+#include "@XL_NAME@.h"
+
+#pragma fragment XLATOR_METHODS
+
+static int32_t @FOP_PREFIX@_init(xlator_t *this)
+{
+    return 0;
+}
+
+static void @FOP_PREFIX@_fini(xlator_t *this)
+{
+    return;
+}
+
+static int32_t @FOP_PREFIX@_reconfigure(xlator_t *this, dict_t *dict)
+{
+    return 0;
+}
+
+static int @FOP_PREFIX@_notify(xlator_t *this, int event, void *data, ...)
+{
+    return default_notify(this, event, data);
+}
+
+static int32_t @FOP_PREFIX@_mem_acct_init(xlator_t *this)
+{
+    int ret = -1;
+
+    ret = xlator_mem_acct_init(this, gf_@FOP_PREFIX@_mt_end + 1);
+    return ret;
+}
+
+static int32_t @FOP_PREFIX@_dump_metrics(xlator_t *this, int fd)
+{
+    return 0;
+}
+
+struct volume_options @FOP_PREFIX@_options[] = {
+    /*{ .key  = {""},
+      .type = GF_OPTION_TYPE_BOOL,
+      .default_value = "",
+      .op_version = {GD_OP_VERSION_},
+      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT,
+      .tags = {""},
+      .description = "",
+      .category = GF_EXPERIMENTAL,
+    },
+    { .key = {NULL} },
+    */
+};
+
+xlator_api_t xlator_api = {
+    .init = @FOP_PREFIX@_init,
+    .fini = @FOP_PREFIX@_fini,
+    .notify = @FOP_PREFIX@_notify,
+    .reconfigure = @FOP_PREFIX@_reconfigure,
+    .mem_acct_init = @FOP_PREFIX@_mem_acct_init,
+    .dump_metrics = @FOP_PREFIX@_dump_metrics,
+    .op_version = {GD_OP_VERSION_},
+    .dumpops = &@FOP_PREFIX@_dumpops,
+    .fops = &@FOP_PREFIX@_fops,
+    .cbks = &@FOP_PREFIX @_cbks,
+    .options = @FOP_PREFIX@_options,
+    .identifier = "@XL_NAME@",
+    .category = GF_EXPERIMENTAL,
+};
+#pragma fragment HEADER_FMT
+#ifndef __ @HFL_NAME@_H__
+#define __ @HFL_NAME@_H__
+
+#include "@XL_NAME@-mem-types.h"
+#include "@XL_NAME@-messages.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/xlator.h>
+#include <glusterfs/defaults.h>
+
+#endif /* __@HFL_NAME@_H__ */
+
+#pragma fragment MEM_HEADER_FMT
+#ifndef __ @HFL_NAME@_H__
+#define __ @HFL_NAME@_H__
+
+#include <glusterfs/mem-types.h>
+
+enum gf_mdc_mem_types_ {
+    gf_@FOP_PREFIX@_mt_ = gf_common_mt_end + 1,
+    gf_@FOP_PREFIX@_mt_end
+};
+
+#endif /* __@HFL_NAME@_H__ */
+
+#pragma fragment MSG_HEADER_FMT
+#ifndef __@HFL_NAME@_H__
+#define __@HFL_NAME@_H__
+
+#include <glusterfs/glfs-message-id.h>
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
+ */
+
+GLFS_MSGID(@FOP_PREFIX@, @FOP_PREFIX@_MSG_NO_MEMORY);
+
+#endif /* __@HFL_NAME@_H__ */
diff --git a/extras/devel-tools/print-backtrace.sh b/extras/devel-tools/print-backtrace.sh
index 873b6bc692d..33fbae288bc 100755
--- a/extras/devel-tools/print-backtrace.sh
+++ b/extras/devel-tools/print-backtrace.sh
@@ -20,6 +20,8 @@
 # Usage with source install:
 # print-packtrace.sh none bt-file.txt
 
+function version_compare() { test $(echo $1|awk -F '.' '{print $1 $2 $3}') -gt $(echo $2|awk -F '.' '{print $1 $2 $3}'); }
+
 function Usage()
 {
         echo -e "Usage:\n\t$0 { none | <debuginfo-rpm> } <backtrace-file>"
@@ -38,9 +40,11 @@ if [ ! $debuginfo_rpm ] || [ ! $backtrace_file ]; then
         exit 1
 fi
 
-if [ $debuginfo_rpm != "none" ] && [ ! -f $debuginfo_rpm ]; then
-        echo "no such rpm file: $debuginfo_rpm"
-        exit 1
+if [ $debuginfo_rpm != "none" ]; then
+        if [ ! -f $debuginfo_rpm ]; then
+                echo "no such rpm file: $debuginfo_rpm"
+                exit 1
+        fi
 fi
 
 if [ ! -f $backtrace_file ]; then
@@ -48,11 +52,14 @@ if [ ! -f $backtrace_file ]; then
         exit 1
 fi
 
-if ! file $debuginfo_rpm | grep RPM >/dev/null 2>&1 ; then
-        echo "file does not look like an rpm: $debuginfo_rpm"
-        exit 1
+if [ "$debuginfo_rpm" != "none" ]; then
+        if ! file $debuginfo_rpm | grep RPM >/dev/null 2>&1 ; then
+                echo "file does not look like an rpm: $debuginfo_rpm"
+                exit 1
+        fi
 fi
 
+cpio_version=$(cpio --version|grep cpio|cut -f 2 -d ')'|sed -e 's/^[[:space:]]*//')
 rpm_name=""
 debuginfo_path=""
 debuginfo_extension=""
@@ -66,8 +73,21 @@ if [ $debuginfo_rpm != "none" ]; then
                 exit 1
         fi
         mkdir -p $rpm_name
-        rpm2cpio $debuginfo_rpm | cpio --quiet --extract --make-directories --preserve-modification-time --directory=$rpm_name
-
+        if version_compare $cpio_version "2.11"; then
+                rpm2cpio $debuginfo_rpm | cpio --quiet --extract --make-directories --preserve-modification-time --directory=$rpm_name
+                ret=$?
+        else
+                current_dir="$PWD"
+                cd $rpm_name
+                rpm2cpio $debuginfo_rpm | cpio --quiet --extract --make-directories --preserve-modification-time
+                ret=$?
+                cd $current_dir
+        fi
+        if [ $ret -eq 1 ]; then
+                echo "failed to extract rpm $debuginfo_rpm to $PWD/$rpm_name directory"
+                rm -rf $rpm_name
+                exit 1
+        fi
         debuginfo_path="$PWD/$rpm_name/usr/lib/debug"
         debuginfo_extension=".debug"
 else
@@ -76,15 +96,16 @@ else
 fi
 
 # NOTE: backtrace file should contain only the lines which need to be resolved
-for bt in $(grep glusterfs $backtrace_file)
+for bt in $(cat $backtrace_file)
 do
         libname=$(echo $bt | cut -f 1 -d '(')
         addr=$(echo $bt | cut -f 2 -d '(' | cut -f 1 -d ')')
-        # only unresolved addresses start with a '+'
-        if echo $addr | egrep '^\+' >/dev/null 2>&1 ; then
-                newbt=( $(eu-addr2line --functions --exe=${debuginfo_path}${libname}${debuginfo_extension} $addr) )
-                echo "$bt ${newbt[*]}"
+        libpath=${debuginfo_path}${libname}${debuginfo_extension}
+        if [ ! -f $libpath ]; then
+                continue
         fi
+        newbt=( $(eu-addr2line --functions --exe=$libpath $addr) )
+        echo "$bt ${newbt[*]}"
 done
 
 # remove the temporary directory
diff --git a/extras/devel-tools/strace-brick.sh b/extras/devel-tools/strace-brick.sh
new file mode 100755
index 00000000000..a140729111c
--- /dev/null
+++ b/extras/devel-tools/strace-brick.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+# Usage:
+# nice -n -19 strace-brick.sh glusterfsd 50
+
+brick_process_name=$1
+min_watch_cpu=$2
+if [ ! $brick_process_name ]; then
+        brick_process_name=glusterfsd
+fi
+
+if [ ! $min_watch_cpu ]; then
+        min_watch_cpu=50
+fi
+
+echo "min_watch_cpu: $min_watch_cpu"
+
+break=false
+
+while ! $break;
+do
+        mypids=( $(pgrep $brick_process_name) )
+        echo "mypids: ${mypids[*]}"
+
+        pid_args=$(echo ${mypids[*]} | sed -e 's/ / -p /g;s/^/-p /')
+        echo "pid_args: $pid_args"
+
+        pcpu=( $(ps $pid_args -o pcpu -h ) )
+        echo "pcpu: ${pcpu[*]}"
+
+        wait_longer=false
+
+        for i in $( seq 0 $((${#pcpu[*]} - 1)) )
+        do
+                echo "i: $i"
+                echo "mypids[$i]: ${mypids[$i]}"
+
+                int_pcpu=$(echo ${pcpu[$i]} | cut -f 1 -d '.')
+                echo "int_pcpu: $int_pcpu"
+                if [ ! $int_pcpu ] || [ ! $min_watch_cpu ]; then
+                        break=true
+                        echo "breaking"
+                fi
+                if [ $int_pcpu -ge $min_watch_cpu ]; then
+                        wait_longer=true
+                        mydirname="${brick_process_name}-${mypids[$i]}-$(date --utc +'%Y%m%d-%H%M%S.%N')"
+                        $(mkdir $mydirname && cd $mydirname && timeout --kill-after=5 --signal=KILL 60 nice -n -19 strace -p ${mypids[$i]} -ff -tt -T -o $brick_process_name) &
+                fi
+        done
+
+        if $wait_longer; then
+                sleep 90
+        else
+                sleep 15
+        fi
+done
diff --git a/extras/distributed-testing/README b/extras/distributed-testing/README
new file mode 100644
index 00000000000..928d943f211
--- /dev/null
+++ b/extras/distributed-testing/README
@@ -0,0 +1,28 @@
+PROBLEM
+
+The testing methodology of Gluster is extremely slow. It takes a very long time (6+ hrs) to run the basic tests on a single machine. It takes about 20+ hours to run code analysis version of tests like valgrind, asan, tsan etc.
+
+SOLUTION
+
+The fundamental problem is that the tests cannot be parallelized on a single machine. The natural solution is to run these tests on a cluster of machines. In a nutshell, apply map-reduce to run unit tests.
+
+WORK @ Facebook
+
+At Facebook we have applied the map-reduce approach to testing and have observed 10X improvements.
+
+The solution supports the following
+
+Distribute tests across machines, collect results/logs
+Share worker pool across different testers
+Try failure 3 times on 3 different machines before calling it a failure
+Support running asan, valgrind, asan-noleaks
+Self management of worker pools. The clients will manage the worker pool including version update, no manual maintenance required
+WORK
+
+Port the code from gluster-fb-3.8 to gluster master
+
+HOW TO RUN
+
+./extras/distributed-testing/distributed-test.sh --hosts '<h1> <h2> <h3>'
+
+All hosts should have no password for ssh via root. This can be achieved with keys setup on the client and the server machines.
diff --git a/extras/distributed-testing/distributed-test-build-env b/extras/distributed-testing/distributed-test-build-env
new file mode 100644
index 00000000000..cd68ff717da
--- /dev/null
+++ b/extras/distributed-testing/distributed-test-build-env
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+GF_CONF_OPTS="--localstatedir=/var --sysconfdir /var/lib --prefix /usr --libdir /usr/lib64 \
+            --enable-bd-xlator=yes --enable-debug --enable-gnfs"
+
+if [ -x /usr/lib/rpm/redhat/dist.sh ]; then
+  REDHAT_MAJOR=$(/usr/lib/rpm/redhat/dist.sh --distnum)
+else
+  REDHAT_MAJOR=0
+fi
+
+ASAN_ENABLED=${ASAN_ENABLED:=0}
+if [ "$ASAN_ENABLED" -eq "1" ]; then
+    GF_CONF_OPTS="$GF_CONF_OPTS --with-asan"
+fi
+
+GF_CONF_OPTS="$GF_CONF_OPTS --with-systemd"
+export GF_CONF_OPTS
+
+export CFLAGS="-O0 -ggdb -fPIC -Wall"
diff --git a/extras/distributed-testing/distributed-test-build.sh b/extras/distributed-testing/distributed-test-build.sh
new file mode 100755
index 00000000000..e8910d8425c
--- /dev/null
+++ b/extras/distributed-testing/distributed-test-build.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -e
+
+EXTRA_CONFIGURE_ARGS="$@"
+ASAN_REQUESTED=false
+for arg in $EXTRA_CONFIGURE_ARGS; do
+  if [ $arg == "--with-asan" ]; then
+    echo "Requested ASAN, cleaning build first."
+    make -j distclean || true
+    touch .with_asan
+    ASAN_REQUESTED=true
+  fi
+done
+
+if [ $ASAN_REQUESTED == false ]; then
+  if [ -f .with_asan ]; then
+    echo "Previous build was with ASAN, cleaning build first."
+    make -j distclean || true
+    rm -v .with_asan
+  fi
+fi
+
+source extras/distributed-testing/distributed-test-build-env
+./autogen.sh
+./configure $GF_CONF_OPTS $EXTRA_CONFIGURE_ARGS
+make -j
diff --git a/extras/distributed-testing/distributed-test-env b/extras/distributed-testing/distributed-test-env
new file mode 100644
index 00000000000..36fdd82e5dd
--- /dev/null
+++ b/extras/distributed-testing/distributed-test-env
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+SMOKE_TESTS="\
+    tests/basic/*.t\
+    tests/basic/afr/*.t\
+    tests/basic/distribute/*.t\
+    tests/bugs/fb*.t\
+    tests/features/brick-min-free-space.t\
+"
+
+KNOWN_FLAKY_TESTS="\
+"
+
+BROKEN_TESTS="\
+  tests/features/lock_revocation.t\
+  tests/features/recon.t\
+  tests/features/fdl-overflow.t\
+  tests/features/fdl.t\
+  tests/features/ipc.t\
+  tests/bugs/distribute/bug-1247563.t\
+  tests/bugs/distribute/bug-1543279.t\
+  tests/bugs/distribute/bug-1066798.t\
+  tests/bugs/ec/bug-1304988.t\
+  tests/bugs/unclassified/bug-1357397.t\
+  tests/bugs/quota/bug-1235182.t\
+  tests/bugs/fuse/bug-1309462.t\
+  tests/bugs/glusterd/bug-1238706-daemons-stop-on-peer-cleanup.t\
+  tests/bugs/stripe/bug-1002207.t\
+  tests/bugs/stripe/bug-1111454.t\
+  tests/bugs/snapshot/bug-1140162-file-snapshot-features-encrypt-opts-validation.t\
+  tests/bugs/write-behind/bug-1279730.t\
+  tests/bugs/gfapi/bug-1093594.t\
+  tests/bugs/replicate/bug-1473026.t\
+  tests/bugs/replicate/bug-802417.t\
+  tests/basic/inode-leak.t\
+  tests/basic/distribute/force-migration.t\
+  tests/basic/ec/heal-info.t\
+  tests/basic/ec/ec-seek.t\
+  tests/basic/jbr/jbr-volgen.t\
+  tests/basic/jbr/jbr.t\
+  tests/basic/afr/tarissue.t\
+  tests/basic/tier/tierd_check.t\
+  tests/basic/gfapi/bug1291259.t\
+"
+
+SMOKE_TESTS=$(echo $SMOKE_TESTS | tr -s ' ' ' ')
+KNOWN_FLAKY_TESTS=$(echo $KNOWN_FLAKY_TESTS | tr -s ' ' ' ')
+BROKEN_TESTS=$(echo $BROKEN_TESTS | tr -s ' ' ' ')
diff --git a/extras/distributed-testing/distributed-test-runner.py b/extras/distributed-testing/distributed-test-runner.py
new file mode 100755
index 00000000000..5a07e2feab1
--- /dev/null
+++ b/extras/distributed-testing/distributed-test-runner.py
@@ -0,0 +1,859 @@
+#!/usr/bin/python3
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+from __future__ import print_function
+import re
+import sys
+import fcntl
+import base64
+import threading
+import socket
+import os
+import shlex
+import argparse
+import subprocess
+import time
+import SimpleXMLRPCServer
+import xmlrpclib
+import md5
+import httplib
+import uuid
+
+DEFAULT_PORT = 9999
+TEST_TIMEOUT_S = 15 * 60
+CLIENT_CONNECT_TIMEOUT_S = 10
+CLIENT_TIMEOUT_S = 60
+PATCH_FILE_UID = str(uuid.uuid4())
+SSH_TIMEOUT_S = 10
+MAX_ATTEMPTS = 3
+ADDRESS_FAMILY = 'IPv4'
+
+
+def socket_instance(address_family):
+    if address_family.upper() == 'ipv4'.upper():
+        return socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    elif address_family.upper() == 'ipv6'.upper():
+        return socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+    else:
+        Log.error("Invalid IP address family")
+        sys.exit(1)
+
+
+def patch_file():
+    return "/tmp/%s-patch.tar.gz" % PATCH_FILE_UID
+
+# ..............................................................................
+# SimpleXMLRPCServer IPvX Wrapper
+# ..............................................................................
+
+
+class GeneralXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer):
+    def __init__(self, addr):
+        SimpleXMLRPCServer.SimpleXMLRPCServer.__init__(self, addr)
+
+    def server_bind(self):
+        if self.socket:
+            self.socket.close()
+        self.socket = socket_instance(args.address_family)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        SimpleXMLRPCServer.SimpleXMLRPCServer.server_bind(self)
+
+
+class HTTPConnection(httplib.HTTPConnection):
+    def __init__(self, host):
+        self.host = host
+        httplib.HTTPConnection.__init__(self, host)
+
+    def connect(self):
+        old_timeout = socket.getdefaulttimeout()
+        self.sock = socket.create_connection((self.host, self.port),
+                                             timeout=CLIENT_CONNECT_TIMEOUT_S)
+        self.sock.settimeout(old_timeout)
+
+
+class IPTransport(xmlrpclib.Transport):
+    def __init__(self, *args, **kwargs):
+        xmlrpclib.Transport.__init__(self, *args, **kwargs)
+
+    def make_connection(self, host):
+        return HTTPConnection(host)
+
+
+# ..............................................................................
+# Common
+# ..............................................................................
+
+
+class Timer:
+    def __init__(self):
+        self.start = time.time()
+
+    def elapsed_s(self):
+        return int(time.time() - self.start)
+
+    def reset(self):
+        ret = self.elapsed_s()
+        self.start = time.time()
+        return ret
+
+
+def encode(buf):
+    return base64.b16encode(buf)
+
+
+def decode(buf):
+    return base64.b16decode(buf)
+
+
+def get_file_content(path):
+    with open(path, "r") as f:
+        return f.read()
+
+
+def write_to_file(path, data):
+    with open(path, "w") as f:
+        f.write(data)
+
+
+def failsafe(fn, args=()):
+    try:
+        return (True, fn(*args))
+    except (xmlrpclib.Fault, xmlrpclib.ProtocolError, xmlrpclib.ResponseError,
+            Exception) as err:
+        Log.debug(str(err))
+    return (False, None)
+
+
+class LogLevel:
+    DEBUG = 2
+    ERROR = 1
+    CLI = 0
+
+
+class Log:
+    LOGLEVEL = LogLevel.ERROR
+
+    @staticmethod
+    def _normalize(msg):
+        return msg[:100]
+
+    @staticmethod
+    def debug(msg):
+        if Log.LOGLEVEL >= LogLevel.DEBUG:
+            sys.stdout.write("<debug> %s\n" % Log._normalize(msg))
+            sys.stdout.flush()
+
+    @staticmethod
+    def error(msg):
+        sys.stderr.write("<error> %s\n" % Log._normalize(msg))
+
+    @staticmethod
+    def header(msg):
+        sys.stderr.write("* %s *\n" % Log._normalize(msg))
+
+    @staticmethod
+    def cli(msg):
+        sys.stderr.write("%s\n" % msg)
+
+
+class Shell:
+    def __init__(self, cwd=None, logpath=None):
+        self.cwd = cwd
+        self.shell = True
+        self.redirect = open(os.devnull if not logpath else logpath, "wr+")
+
+    def __del__(self):
+        self.redirect.close()
+
+    def cd(self, cwd):
+        Log.debug("cd %s" % cwd)
+        self.cwd = cwd
+
+    def truncate(self):
+        self.redirect.truncate(0)
+
+    def read_logs(self):
+        self.redirect.seek(0)
+        return self.redirect.read()
+
+    def check_call(self, cmd):
+        status = self.call(cmd)
+        if status:
+            raise Exception("Error running command %s. status=%s"
+                            % (cmd, status))
+
+    def call(self, cmd):
+        if isinstance(cmd, list):
+            return self._calls(cmd)
+
+        return self._call(cmd)
+
+    def ssh(self, hostname, cmd, id_rsa=None):
+        flags = "" if not id_rsa else "-i " + id_rsa
+        return self.call("timeout %s ssh %s root@%s \"%s\"" %
+                            (SSH_TIMEOUT_S, flags, hostname, cmd))
+
+    def scp(self, hostname, src, dest, id_rsa=None):
+        flags = "" if not id_rsa else "-i " + id_rsa
+        return self.call("timeout %s scp %s %s root@%s:%s" %
+                            (SSH_TIMEOUT_S, flags, src, hostname, dest))
+
+    def output(self, cmd, cwd=None):
+        Log.debug("%s> %s" % (cwd, cmd))
+        return subprocess.check_output(shlex.split(cmd), cwd=self.cwd)
+
+    def _calls(self, cmds):
+        Log.debug("Running commands. %s" % cmds)
+        for c in cmds:
+            status = self.call(c)
+            if status:
+                Log.error("Commands failed with %s" % status)
+                return status
+        return 0
+
+    def _call(self, cmd):
+        if not self.shell:
+            cmd = shlex.split(cmd)
+
+        Log.debug("%s> %s" % (self.cwd, cmd))
+
+        status = subprocess.call(cmd, cwd=self.cwd, shell=self.shell,
+                                 stdout=self.redirect, stderr=self.redirect)
+
+        Log.debug("return %s" % status)
+        return status
+
+
+# ..............................................................................
+# Server role
+# ..............................................................................
+
+class TestServer:
+    def __init__(self, port, scratchdir):
+        self.port = port
+        self.scratchdir = scratchdir
+        self.shell = Shell()
+        self.rpc = None
+        self.pidf = None
+
+        self.shell.check_call("mkdir -p %s" % self.scratchdir)
+        self._process_lock()
+
+    def __del__(self):
+        if self.pidf:
+            self.pidf.close()
+
+    def init(self):
+        Log.debug("Starting xmlrpc server on port %s" % self.port)
+        self.rpc = GeneralXMLRPCServer(("", self.port))
+        self.rpc.register_instance(Handlers(self.scratchdir))
+
+    def serve(self):
+        (status, _) = failsafe(self.rpc.serve_forever)
+        Log.cli("== End ==")
+
+    def _process_lock(self):
+        pid_filename = os.path.basename(__file__).replace("/", "-")
+        pid_filepath = "%s/%s.pid" % (self.scratchdir, pid_filename)
+        self.pidf = open(pid_filepath, "w")
+        try:
+            fcntl.lockf(self.pidf, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            # We have the lock, kick anybody listening on this port
+            self.shell.call("kill $(lsof -t -i:%s)" % self.port)
+        except IOError:
+            Log.error("Another process instance is running")
+            sys.exit(0)
+
+#
+# Server Handler
+#
+
+
+handler_lock = threading.Lock()
+handler_serving_since = Timer()
+
+
+def synchronized(func):
+    def decorator(*args, **kws):
+        handler_lock.acquire()
+        h = args[0]
+        try:
+            h.shell.truncate()
+            ret = func(*args, **kws)
+            return ret
+        except Exception() as err:
+            Log.error(str(err))
+            Log.error(decode(h._log_content()))
+            raise
+        finally:
+            handler_lock.release()
+            handler_serving_since.reset()
+
+    return decorator
+
+
+class Handlers:
+    def __init__(self, scratchdir):
+        self.client_id = None
+        self.scratchdir = scratchdir
+        self.gluster_root = "%s/glusterfs" % self.scratchdir
+        self.shell = Shell(logpath="%s/test-handlers.log" % self.scratchdir)
+
+    def hello(self, id):
+        if not handler_lock.acquire(False):
+            return False
+        try:
+            return self._hello_locked(id)
+        finally:
+            handler_lock.release()
+
+    def _hello_locked(self, id):
+        if handler_serving_since.elapsed_s() > CLIENT_TIMEOUT_S:
+            Log.debug("Disconnected client %s" % self.client_id)
+            self.client_id = None
+
+        if not self.client_id:
+            self.client_id = id
+            handler_serving_since.reset()
+            return True
+
+        return (id == self.client_id)
+
+    @synchronized
+    def ping(self, id=None):
+        if id:
+            return id == self.client_id
+        return True
+
+    @synchronized
+    def bye(self, id):
+        assert id == self.client_id
+        self.client_id = None
+        handler_serving_since.reset()
+        return True
+
+    @synchronized
+    def cleanup(self, id):
+        assert id == self.client_id
+        self.shell.cd(self.gluster_root)
+        self.shell.check_call("PATH=.:$PATH; sudo ./clean_gfs_devserver.sh")
+        return True
+
+    @synchronized
+    def copy(self, id, name, content):
+        with open("%s/%s" % (self.scratchdir, name), "w+") as f:
+            f.write(decode(content))
+        return True
+
+    @synchronized
+    def copygzip(self, id, content):
+        assert id == self.client_id
+        gzipfile = "%s/tmp.tar.gz" % self.scratchdir
+        tarfile = "%s/tmp.tar" % self.scratchdir
+        self.shell.check_call("rm -f %s" % gzipfile)
+        self.shell.check_call("rm -f %s" % tarfile)
+        write_to_file(gzipfile, decode(content))
+
+        self.shell.cd(self.scratchdir)
+        self.shell.check_call("rm -r -f %s" % self.gluster_root)
+        self.shell.check_call("mkdir -p %s" % self.gluster_root)
+
+        self.shell.cd(self.gluster_root)
+        cmds = [
+            "gunzip -f -q %s" % gzipfile,
+            "tar -xvf %s" % tarfile
+        ]
+        return self.shell.call(cmds) == 0
+
+    @synchronized
+    def build(self, id, asan=False):
+        assert id == self.client_id
+        self.shell.cd(self.gluster_root)
+        self.shell.call("make clean")
+        env = "ASAN_ENABLED=1" if asan else ""
+        return self.shell.call(
+		"%s ./extras/distributed-testing/distributed-test-build.sh" % env) == 0
+
+    @synchronized
+    def install(self, id):
+        assert id == self.client_id
+        self.shell.cd(self.gluster_root)
+        return self.shell.call("make install") == 0
+
+    @synchronized
+    def prove(self, id, test, timeout, valgrind="no", asan_noleaks=True):
+        assert id == self.client_id
+        self.shell.cd(self.gluster_root)
+        env = "DEBUG=1 "
+        if valgrind == "memcheck" or valgrind == "yes":
+            cmd = "valgrind"
+            cmd += " --tool=memcheck --leak-check=full --track-origins=yes"
+            cmd += " --show-leak-kinds=all -v prove -v"
+        elif valgrind == "drd":
+            cmd = "valgrind"
+            cmd += " --tool=drd -v prove -v"
+        elif asan_noleaks:
+            cmd = "prove -v"
+            env += "ASAN_OPTIONS=detect_leaks=0 "
+        else:
+            cmd = "prove -v"
+
+        status = self.shell.call(
+		"%s timeout %s %s %s" % (env, timeout, cmd, test))
+
+        if status != 0:
+            return (False, self._log_content())
+        return (True, "")
+
+    def _log_content(self):
+        return encode(self.shell.read_logs())
+
+# ..............................................................................
+# Cli role
+# ..............................................................................
+
+
+class RPCConnection((threading.Thread)):
+    def __init__(self, host, port, path, cb):
+        threading.Thread.__init__(self)
+        self.host = host
+        self.port = port
+        self.path = path
+        self.shell = Shell()
+        self.cb = cb
+        self.stop = False
+        self.proxy = None
+        self.logid = "%s:%s" % (self.host, self.port)
+
+    def connect(self):
+        (status, ret) = failsafe(self._connect)
+        return (status and ret)
+
+    def _connect(self):
+        url = "http://%s:%s" % (self.host, self.port)
+        self.proxy = xmlrpclib.ServerProxy(url, transport=IPTransport())
+        return self.proxy.hello(self.cb.id)
+
+    def disconnect(self):
+        self.stop = True
+
+    def ping(self):
+        return self.proxy.ping()
+
+    def init(self):
+        return self._copy() and self._compile_and_install()
+
+    def run(self):
+        (status, ret) = failsafe(self.init)
+        if not status:
+            self.cb.note_lost_connection(self)
+            return
+        elif not ret:
+            self.cb.note_setup_failed(self)
+            return
+
+        while not self.stop:
+            (status, ret) = failsafe(self._run)
+            if not status or not ret:
+                self.cb.note_lost_connection(self)
+                break
+            time.sleep(0)
+
+        failsafe(self.proxy.bye, (self.cb.id,))
+        Log.debug("%s connection thread stopped" % self.host)
+
+    def _run(self):
+        test = self.cb.next_test()
+        (status, _) = failsafe(self._execute_next, (test,))
+        if not status:
+            self.cb.note_retry(test)
+            return False
+        return True
+
+    def _execute_next(self, test):
+        if not test:
+            time.sleep(1)
+            return
+
+        (status, error) = self.proxy.prove(self.cb.id, test,
+                                           self.cb.test_timeout,
+                                           self.cb.valgrind,
+                                           self.cb.asan_noleaks)
+        if status:
+            self.cb.note_done(test)
+        else:
+            self.cb.note_error(test, error)
+
+    def _compile_and_install(self):
+        Log.debug("<%s> Build " % self.logid)
+        asan = self.cb.asan or self.cb.asan_noleaks
+        return (self.proxy.build(self.cb.id, asan) and
+                self.proxy.install(self.cb.id))
+
+    def _copy(self):
+        return self._copy_gzip()
+
+    def _copy_gzip(self):
+        Log.cli("<%s> copying and compiling %s to remote" %
+                 (self.logid, self.path))
+        data = encode(get_file_content(patch_file()))
+        Log.debug("GZIP size = %s B" % len(data))
+        return self.proxy.copygzip(self.cb.id, data)
+
+
+class RPCConnectionPool:
+    def __init__(self, gluster_path, hosts, n, id_rsa):
+        self.gluster_path = gluster_path
+        self.hosts = hosts
+        self.conns = []
+        self.faulty = []
+        self.n = int(len(hosts) / 2) + 1 if not n else n
+        self.id_rsa = id_rsa
+        self.stop = False
+        self.scanner = threading.Thread(target=self._scan_hosts_loop)
+        self.kicker = threading.Thread(target=self._kick_hosts_loop)
+        self.shell = Shell()
+        self.since_start = Timer()
+
+        self.shell.check_call("rm -f %s" % patch_file())
+        self.shell.check_call("tar -zcvf %s ." % patch_file())
+        self.id = md5.new(get_file_content(patch_file())).hexdigest()
+        Log.cli("client UID %s" % self.id)
+        Log.cli("patch UID %s" % PATCH_FILE_UID)
+
+    def __del__(self):
+        self.shell.check_call("rm -f %s" % patch_file())
+
+    def pool_status(self):
+        elapsed_m = int(self.since_start.elapsed_s() / 60)
+        return "%s/%s connected, %smin elapsed" % (len(self.conns), self.n,
+                                                   elapsed_m)
+
+    def connect(self):
+        Log.debug("Starting scanner")
+        self.scanner.start()
+        self.kicker.start()
+
+    def disconnect(self):
+        self.stop = True
+        for conn in self.conns:
+            conn.disconnect()
+
+    def note_lost_connection(self, conn):
+        Log.cli("lost connection to %s" % conn.host)
+        self.conns.remove(conn)
+        self.hosts.append((conn.host, conn.port))
+
+    def note_setup_failed(self, conn):
+        Log.error("Setup failed on %s:%s" % (conn.host, conn.port))
+        self.conns.remove(conn)
+        self.faulty.append((conn.host, conn.port))
+
+    def _scan_hosts_loop(self):
+        Log.debug("Scanner thread started")
+        while not self.stop:
+            failsafe(self._scan_hosts)
+            time.sleep(5)
+
+    def _scan_hosts(self):
+        if len(self.hosts) == 0 and len(self.conns) == 0:
+            Log.error("no more hosts available to loadbalance")
+            sys.exit(1)
+
+        for (host, port) in self.hosts:
+            if (len(self.conns) >= self.n) or self.stop:
+                break
+            self._scan_host(host, port)
+
+    def _scan_host(self, host, port):
+        Log.debug("scanning %s:%s" % (host, port))
+        c = RPCConnection(host, port, self.gluster_path, self)
+        (status, result) = failsafe(c.connect)
+        if status and result:
+            self.hosts.remove((host, port))
+            Log.debug("Connected to %s:%s" % (host, port))
+            self.conns.append(c)
+            c.start()
+            Log.debug("%s / %s connected" % (len(self.conns), self.n))
+        else:
+            Log.debug("Failed to connect to %s:%s" % (host, port))
+
+    def _kick_hosts_loop(self):
+        Log.debug("Kick thread started")
+        while not self.stop:
+            time.sleep(10)
+            failsafe(self._kick_hosts)
+
+        Log.debug("Kick thread stopped")
+
+    def _is_pingable(self, host, port):
+        c = RPCConnection(host, port, self.gluster_path, self)
+        failsafe(c.connect)
+        (status, result) = failsafe(c.ping)
+        return status and result
+
+    def _kick_hosts(self):
+        # Do not kick hosts if we have the optimal number of connections
+        if (len(self.conns) >= self.n) or self.stop:
+            Log.debug("Skip kicking hosts")
+            return
+
+        # Check and if dead kick all hosts
+        for (host, port) in self.hosts:
+            if self.stop:
+                Log.debug("Break kicking hosts")
+                break
+
+            if self._is_pingable(host, port):
+                Log.debug("Host=%s is alive. Won't kick" % host)
+                continue
+
+            Log.debug("Kicking %s" % host)
+            mypath = sys.argv[0]
+            myname = os.path.basename(mypath)
+            destpath = "/tmp/%s" % myname
+            sh = Shell()
+            sh.scp(host, mypath, destpath, self.id_rsa)
+            sh.ssh(host, "nohup %s --server &>> %s.log &" %
+                         (destpath, destpath), self.id_rsa)
+
+    def join(self):
+        self.scanner.join()
+        self.kicker.join()
+        for c in self.conns:
+            c.join()
+
+
+# ..............................................................................
+# test role
+# ..............................................................................
+
+class TestRunner(RPCConnectionPool):
+    def __init__(self, gluster_path, hosts, n, tests, flaky_tests, valgrind,
+                 asan, asan_noleaks, id_rsa, test_timeout):
+        RPCConnectionPool.__init__(self, gluster_path, self._parse_hosts(hosts),
+                                   n, id_rsa)
+        self.flaky_tests = flaky_tests.split(" ")
+        self.pending = []
+        self.done = []
+        self.error = []
+        self.retry = {}
+        self.error_logs = []
+        self.stats_timer = Timer()
+        self.valgrind = valgrind
+        self.asan = asan
+        self.asan_noleaks = asan_noleaks
+        self.test_timeout = test_timeout
+
+        self.tests = self._get_tests(tests)
+
+        Log.debug("tests: %s" % self.tests)
+
+    def _get_tests(self, tests):
+        if not tests or tests == "all":
+            return self._not_flaky(self._all())
+        elif tests == "flaky":
+            return self.flaky_tests
+        else:
+            return self._not_flaky(tests.strip().split(" "))
+
+    def run(self):
+        self.connect()
+        self.join()
+        return len(self.error)
+
+    def _pretty_print(self, data):
+        if isinstance(data, list):
+            str = ""
+            for i in data:
+                str = "%s %s" % (str, i)
+            return str
+        return "%s" % data
+
+    def print_result(self):
+        Log.cli("== RESULTS ==")
+        Log.cli("SUCCESS  : %s" % len(self.done))
+        Log.cli("ERRORS   : %s" % len(self.error))
+        Log.cli("== ERRORS ==")
+        Log.cli(self._pretty_print(self.error))
+        Log.cli("== LOGS ==")
+        Log.cli(self._pretty_print(self.error_logs))
+        Log.cli("== END ==")
+
+    def next_test(self):
+        if len(self.tests):
+            test = self.tests.pop()
+            self.pending.append(test)
+            return test
+
+        if not len(self.pending):
+            self.disconnect()
+
+        return None
+
+    def _pct_completed(self):
+        total = len(self.tests) + len(self.pending) + len(self.done)
+        total += len(self.error)
+        completed = len(self.done) + len(self.error)
+        return 0 if not total else int(completed / total * 100)
+
+    def note_done(self, test):
+        Log.cli("%s PASS (%s%% done) (%s)" % (test, self._pct_completed(),
+                                              self.pool_status()))
+        self.pending.remove(test)
+        self.done.append(test)
+        if test in self.retry:
+            del self.retry[test]
+
+    def note_error(self, test, errstr):
+        Log.cli("%s FAIL" % test)
+        self.pending.remove(test)
+        if test not in self.retry:
+            self.retry[test] = 1
+
+        if errstr:
+            path = "%s/%s-%s.log" % ("/tmp", test.replace("/", "-"),
+                                     self.retry[test])
+            failsafe(write_to_file, (path, decode(errstr),))
+            self.error_logs.append(path)
+
+        if self.retry[test] < MAX_ATTEMPTS:
+            self.retry[test] += 1
+            Log.debug("retry test %s attempt %s" % (test, self.retry[test]))
+            self.tests.append(test)
+        else:
+            Log.debug("giveup attempt test %s" % test)
+            del self.retry[test]
+            self.error.append(test)
+
+    def note_retry(self, test):
+        Log.cli("retry %s on another host" % test)
+        self.pending.remove(test)
+        self.tests.append(test)
+
+    #
+    # test classifications
+    #
+    def _all(self):
+        return self._list_tests(["tests"], recursive=True)
+
+    def _not_flaky(self, tests):
+        for t in self.flaky_tests:
+            if t in tests:
+                tests.remove(t)
+        return tests
+
+    def _list_tests(self, prefixes, recursive=False, ignore_ifnotexist=False):
+        tests = []
+        for prefix in prefixes:
+            real_path = "%s/%s" % (self.gluster_path, prefix)
+            if not os.path.exists(real_path) and ignore_ifnotexist:
+                continue
+            for f in os.listdir(real_path):
+                if os.path.isdir(real_path + "/" + f):
+                    if recursive:
+                        tests += self._list_tests([prefix + "/" + f], recursive)
+                else:
+                    if re.match(r".*\.t$", f):
+                        tests += [prefix + "/" + f]
+        return tests
+
+    def _parse_hosts(self, hosts):
+        ret = []
+        for h in args.hosts.split(" "):
+            ret.append((h, DEFAULT_PORT))
+        Log.debug(ret)
+        return ret
+
+# ..............................................................................
+# Roles entry point
+# ..............................................................................
+
+
+def run_as_server(args):
+    if not args.server_path:
+        Log.error("please provide server path")
+        return 1
+
+    server = TestServer(args.port, args.server_path)
+    server.init()
+    server.serve()
+    return 0
+
+
+def run_as_tester(args):
+    Log.header("GLUSTER TEST CLI")
+
+    Log.debug("args = %s" % args)
+
+    tests = TestRunner(args.gluster_path, args.hosts, args.n, args.tests,
+                       args.flaky_tests, valgrind=args.valgrind,
+                       asan=args.asan, asan_noleaks=args.asan_noleaks,
+                       id_rsa=args.id_rsa, test_timeout=args.test_timeout)
+    result = tests.run()
+    tests.print_result()
+    return result
+
+# ..............................................................................
+# main
+# ..............................................................................
+
+
+def main(args):
+    if args.v:
+        Log.LOGLEVEL = LogLevel.DEBUG
+
+    if args.server and args.tester:
+        Log.error("Invalid arguments. More than one role specified")
+        sys.exit(1)
+
+    if args.server:
+        sys.exit(run_as_server(args))
+    elif args.tester:
+        sys.exit(run_as_tester(args))
+    else:
+        Log.error("please specify a mode for CI")
+        parser.print_help()
+        sys.exit(1)
+
+
+parser = argparse.ArgumentParser(description="Gluster CI")
+
+# server role
+parser.add_argument("--server", help="start server", action="store_true")
+parser.add_argument("--server_path", help="server scratch space",
+                    default="/tmp/gluster-test")
+parser.add_argument("--host", help="server address to listen", default="")
+parser.add_argument("--port", help="server port to listen",
+                    type=int, default=DEFAULT_PORT)
+# test role
+parser.add_argument("--tester", help="start tester", action="store_true")
+parser.add_argument("--valgrind[=memcheck,drd]",
+                    help="run tests with valgrind tool 'memcheck' or 'drd'",
+                    default="no")
+parser.add_argument("--asan", help="test with asan enabled",
+                    action="store_true")
+parser.add_argument("--asan-noleaks", help="test with asan but no mem leaks",
+                    action="store_true")
+parser.add_argument("--tests", help="all/flaky/list of tests", default=None)
+parser.add_argument("--flaky_tests", help="list of flaky tests", default=None)
+parser.add_argument("--n", help="max number of machines to use", type=int,
+                    default=0)
+parser.add_argument("--hosts", help="list of worker machines")
+parser.add_argument("--gluster_path", help="gluster path to test",
+                    default=os.getcwd())
+parser.add_argument("--id-rsa", help="private key to use for ssh",
+                    default=None)
+parser.add_argument("--test-timeout",
+                    help="test timeout in sec (default 15min)",
+                    default=TEST_TIMEOUT_S)
+# general
+parser.add_argument("-v", help="verbose", action="store_true")
+parser.add_argument("--address_family", help="IPv6 or IPv4 to use",
+                    default=ADDRESS_FAMILY)
+
+args = parser.parse_args()
+
+main(args)
diff --git a/extras/distributed-testing/distributed-test.sh b/extras/distributed-testing/distributed-test.sh
new file mode 100755
index 00000000000..8f1e0310f33
--- /dev/null
+++ b/extras/distributed-testing/distributed-test.sh
@@ -0,0 +1,95 @@
+#!/bin/bash
+
+source ./extras/distributed-testing/distributed-test-env
+
+N=0
+TESTS='all'
+FLAKY=$KNOWN_FLAKY_TESTS
+BROKEN=$BROKEN_TESTS
+TEST_TIMEOUT_S=900
+ADDRESS_FAMILY='IPv4'
+
+FLAGS=""
+
+function print_env {
+    echo "Settings:"
+    echo "N=$N"
+    echo -e "-------\nHOSTS\n$HOSTS\n-------"
+    echo -e "TESTS\n$TESTS\n-------"
+    echo -e "SKIP\n$FLAKY $BROKEN\n-------"
+    echo -e "TEST_TIMEOUT_S=$TEST_TIMEOUT_S s\n"
+}
+
+function cleanup {
+    rm -f /tmp/test*.log
+}
+
+function usage {
+    echo "Usage: $0 [-h or --help] [-v or --verbose]
+             [--all] [--flaky] [--smoke] [--broken]
+             [--valgrind] [--asan] [--asan-noleaks]
+             [--hosts <hosts>] [-n <parallelism>]
+             [--tests <tests>]
+             [--id-rsa <ssh private key>]
+             [--address_family <IPv4 or IPv6>]
+    "
+}
+
+function parse_args () {
+    args=`getopt \
+            -o hvn: \
+            --long help,verbose,address_family:,valgrind,asan,asan-noleaks,all,\
+smoke,flaky,broken,hosts:,tests:,id-rsa:,test-timeout: \
+            -n 'fb-remote-test.sh' --  "$@"`
+
+    if [ $? != 0 ]; then
+        echo "Error parsing getopt"
+        exit 1
+    fi
+
+    eval set -- "$args"
+
+    while true; do
+        case "$1" in
+            -h | --help) usage ; exit 1 ;;
+            -v | --verbose) FLAGS="$FLAGS -v" ; shift ;;
+            --address_family) ADDRESS_FAMILY=$2; shift 2 ;;
+            --valgrind) FLAGS="$FLAGS --valgrind" ; shift ;;
+            --asan-noleaks) FLAGS="$FLAGS --asan-noleaks"; shift ;;
+            --asan) FLAGS="$FLAGS --asan" ; shift ;;
+            --hosts) HOSTS=$2; shift 2 ;;
+            --tests) TESTS=$2; FLAKY= ; BROKEN= ; shift 2 ;;
+            --test-timeout) TEST_TIMEOUT_S=$2; shift 2 ;;
+            --all) TESTS='all' ; shift 1 ;;
+            --flaky) TESTS=$FLAKY; FLAKY= ; shift 1 ;;
+            --smoke) TESTS=$SMOKE_TESTS; shift 1 ;;
+            --broken) TESTS=$BROKEN_TESTS; FLAKY= ; BROKEN= ; shift 1 ;;
+            --id-rsa) FLAGS="$FLAGS --id-rsa $2" ; shift 2 ;;
+            -n) N=$2; shift 2 ;;
+            *) break ;;
+            esac
+        done
+        run_tests_args="$@"
+}
+
+function main {
+    parse_args "$@"
+
+    if [ -z "$HOSTS" ]; then
+        echo "Please provide hosts to run the tests in"
+	exit -1
+    fi
+
+    print_env
+
+    cleanup
+
+    "extras/distributed-testing/distributed-test-runner.py" $FLAGS --tester \
+        --n "$N" --hosts "$HOSTS" --tests "$TESTS" \
+        --flaky_tests "$FLAKY $BROKEN" --test-timeout "$TEST_TIMEOUT_S" \
+        --address_family "$ADDRESS_FAMILY"
+
+    exit $?
+}
+
+main "$@"
diff --git a/extras/ec-heal-script/README.md b/extras/ec-heal-script/README.md
new file mode 100644
index 00000000000..aaefd6681f6
--- /dev/null
+++ b/extras/ec-heal-script/README.md
@@ -0,0 +1,69 @@
+# gluster-heal-scripts
+Scripts to correct extended attributes of fragments of files to make them healble.
+
+Following are the guidelines/suggestions to use these scripts.
+
+1 - Passwordless ssh should be setup for all the nodes of the cluster.
+
+2 - Scripts should be executed from one of these nodes.
+
+3 - Make sure NO "IO" is going on for the files for which we are running
+these two scripts.
+
+4 - There should be no heal going on for the file for which xattrs are being
+set by correct_pending_heals.sh. Disable the self heal while running this script.
+
+5 - All the bricks of the volume should be UP to identify good and bad fragments
+and to decide if an entry is healble or not.
+
+6 - If correct_pending_heals.sh is stopped in the middle while it was processing
+healble entries, it is suggested to re-run gfid_needing_heal_parallel.sh to create
+latest list of healble and non healble entries and "potential_heal" "can_not_heal" files.
+
+7 - Based on the number of entries, these files might take time to get and set the
+stats and xattrs of entries.
+
+8 - A backup of the fragments will be taken on <brick path>/.glusterfs/correct_pending_heals
+    directory with a file name same as gfid.
+
+9 - Once the correctness of the file gets verified by user, these backup should be removed.
+
+10 - Make sure we have enough space on bricks to take these backups.
+
+11 - At the end this will create two files -
+     1 - modified_and_backedup_files - Contains list of files which have been modified and should be healed.
+     2 - can_not_heal - Contains list of files which can not be healed.
+
+12 - It is suggested that the integrity of the data of files, which were modified and healed,
+     should be checked by the user.
+
+
+Usage:
+
+Following are the sequence of steps to use these scripts -
+
+1 - ./gfid_needing_heal_parallel.sh <volume name>
+
+    Execute gfid_needing_heal_parallel.sh with volume name to create list of files which could
+    be healed and can not be healed. It creates "potential_heal" and "can_not_heal" files.
+    During execution, it also displays the list of files on consol with the verdict.
+
+2 - ./correct_pending_heals.sh
+
+    Execute correct_pending_heals.sh without any argument. This script processes entries present
+    in "heal" file. It asks user to enter how many files we want to process in one attempt.
+    Once the count is provided, this script will fetch the entries one by one from "potential_heal" file and takes necessary action.
+    If at this point also a file can not be healed, it will be pushed to "can_not_heal" file.
+    If a file can be healed, this script will modify the xattrs of that file fragments and create an entry in "modified_and_backedup_files" file
+
+3 - At the end, all the entries of "potential_heal" will be processed and based on the processing only two files will be left.
+
+     1 - modified_and_backedup_files - Contains list of files which have been modified and should be healed.
+     2 - can_not_heal - Contains list of files which can not be healed.
+
+Logs and other files -
+
+1 - modified_and_backedup_files  - It contains all the files which could be healed and the location of backup of each fragments.
+2 - can_not_heal - It contains all the files which can not be healed.
+3 - potential_heal - List of files which could be healed and should be processed by "correct_pending_heals.sh"
+4 - /var/log/glusterfs/ec-heal-script.log - It contains logs of both the files.
diff --git a/extras/ec-heal-script/correct_pending_heals.sh b/extras/ec-heal-script/correct_pending_heals.sh
new file mode 100755
index 00000000000..c9f19dd7c89
--- /dev/null
+++ b/extras/ec-heal-script/correct_pending_heals.sh
@@ -0,0 +1,415 @@
+#!/bin/bash
+#  Copyright (c) 2019-2020 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+
+# This script finally resets the xattrs of all the fragments of a file
+# which can be healed as per gfid_needing_heal_parallel.sh.
+# gfid_needing_heal_parallel.sh will produce two files, potential_heal and can_not_heal.
+# This script takes potential_heal as input and resets xattrs of all the fragments
+# of those files present in this file and which could be healed as per
+# trusted.ec.size xattar of the file else it will place the entry in can_not_heal
+# file.  Those entries which must be healed will be place in must_heal file
+# after setting xattrs so that user can track those files.
+
+
+MOD_BACKUP_FILES="modified_and_backedup_files"
+CAN_NOT_HEAL="can_not_heal"
+LOG_DIR="/var/log/glusterfs"
+LOG_FILE="$LOG_DIR/ec-heal-script.log"
+LINE_SEP="==================================================="
+
+function heal_log()
+{
+    echo "$1" >> "$LOG_FILE"
+}
+
+function desc ()
+{
+    echo ""
+    echo "This script finally resets the xattrs of all the fragments of a file
+which can be healed as per gfid_needing_heal_parallel.sh.
+gfid_needing_heal_parallel.sh will produce two files, potential_heal and can_not_heal.
+This script takes potential_heal as input and resets xattrs of all the fragments
+of those files present in this file and which could be healed as per
+trusted.ec.size xattar of the file else it will place the entry in can_not_heal
+file.  Those entries which must be healed will be place in must_heal file
+after setting xattrs so that user can track those files."
+}
+
+function _init ()
+{
+    if [ $# -ne 0 ]
+    then
+        echo "usage: $0"
+        desc
+        exit 2
+    fi
+
+    if [ ! -f "potential_heal" ]
+    then
+        echo "Nothing to correct. File "potential_heal" does not exist"
+        echo ""
+        desc
+        exit 2
+    fi
+}
+
+function total_file_size_in_hex()
+{
+    local frag_size=$1
+    local size=0
+    local hex_size=""
+
+    size=$((frag_size * 4))
+    hex_size=$(printf '0x%016x' $size)
+    echo "$hex_size"
+}
+
+function backup_file_fragment()
+{
+    local file_host=$1
+    local file_entry=$2
+    local gfid_actual_paths=$3
+    local brick_root=""
+    local temp=""
+    local backup_dir=""
+    local cmd=""
+    local gfid=""
+
+    brick_root=$(echo "$file_entry" | cut -d "#" -f 1)
+    temp=$(echo "$(basename "$BASH_SOURCE")" | cut -d '.' -f 1)
+    backup_dir=$(echo "${brick_root}/.glusterfs/${temp}")
+    file_entry=${file_entry//#}
+
+    gfid=$(echo "${gfid_actual_paths}" | cut -d '|' -f 1 | cut -d '/' -f 5)
+    echo "${file_host}:${backup_dir}/${gfid}" >> "$MOD_BACKUP_FILES"
+
+    cmd="mkdir -p ${backup_dir} && yes | cp -af ${file_entry} ${backup_dir}/${gfid} 2>/dev/null"
+    ssh -n "${file_host}" "${cmd}"
+}
+
+function set_frag_xattr ()
+{
+    local file_host=$1
+    local file_entry=$2
+    local good=$3
+    local cmd1=""
+    local cmd2=""
+    local cmd=""
+    local version="0x00000000000000010000000000000001"
+    local dirty="0x00000000000000010000000000000001"
+
+    if [[ $good -eq 0 ]]
+    then
+            version="0x00000000000000000000000000000000"
+    fi
+
+    cmd1=" setfattr -n trusted.ec.version -v ${version} ${file_entry} &&"
+    cmd2=" setfattr -n trusted.ec.dirty -v ${dirty} ${file_entry}"
+    cmd=${cmd1}${cmd2}
+    ssh -n "${file_host}" "${cmd}"
+}
+
+function set_version_dirty_xattr ()
+{
+    local file_paths=$1
+    local good=$2
+    local gfid_actual_paths=$3
+    local file_entry=""
+    local file_host=""
+    local bpath=""
+
+    for bpath in ${file_paths//,/ }
+    do
+        file_host=$(echo "$bpath" | cut -d ":" -f 1)
+        file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+        backup_file_fragment "$file_host" "$file_entry" "$gfid_actual_paths"
+        file_entry=${file_entry//#}
+        set_frag_xattr "$file_host" "$file_entry" "$good"
+    done
+}
+
+function match_size_xattr_quorum ()
+{
+    local file_paths=$1
+    local file_entry=""
+    local file_host=""
+    local cmd=""
+    local size_xattr=""
+    local bpath=""
+    declare -A xattr_count
+
+    for bpath in ${file_paths//,/ }
+    do
+        size_xattr=""
+        file_host=$(echo "$bpath" | cut -d ":" -f 1)
+        file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+        file_entry=${file_entry//#}
+
+        cmd="getfattr -n trusted.ec.size -d -e hex ${file_entry} 2>/dev/null | grep -w "trusted.ec.size" | cut -d '=' -f 2"
+        size_xattr=$(ssh -n "${file_host}" "${cmd}")
+        if [[ -n $size_xattr ]]
+        then
+            count=$((xattr_count["$size_xattr"] + 1))
+            xattr_count["$size_xattr"]=${count}
+            if [[ $count -ge 4 ]]
+            then
+                echo "${size_xattr}"
+                return
+            fi
+        fi
+    done
+    echo "False"
+}
+
+function match_version_xattr ()
+{
+    local file_paths=$1
+    local file_entry=""
+    local file_host=""
+    local cmd=""
+    local version=""
+    local bpath=""
+    declare -A ver_count
+
+    for bpath in ${file_paths//,/ }
+    do
+        version=""
+        file_host=$(echo "$bpath" | cut -d ":" -f 1)
+        file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+        file_entry=${file_entry//#}
+
+        cmd="getfattr -n trusted.ec.version -d -e hex ${file_entry} 2>/dev/null | grep -w "trusted.ec.version" | cut -d '=' -f 2"
+        version=$(ssh -n "${file_host}" "${cmd}")
+        ver_count["$version"]=$((ver_count["$version"] + 1))
+    done
+    for key in "${ver_count[@]}"
+    do
+        if [[ $key -ge 4 ]]
+        then
+            echo "True"
+            return
+        else
+            echo "False"
+            return
+        fi
+    done
+}
+
+function match_stat_size_with_xattr ()
+{
+    local bpath=$1
+    local size=$2
+    local file_stat=$3
+    local xattr=$4
+    local file_entry=""
+    local file_host=""
+    local cmd=""
+    local stat_output=""
+    local hex_size=""
+
+    file_host=$(echo "$bpath" | cut -d ":" -f 1)
+    file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+
+    file_entry=${file_entry//#}
+    cmd="stat --format=%F:%B:%s $file_entry 2>/dev/null"
+    stat_output=$(ssh -n "${file_host}" "${cmd}")
+    echo "$stat_output" | grep -w "${file_stat}" > /dev/null
+
+    if [[ $? -eq 0 ]]
+    then
+        cmd="getfattr -n trusted.ec.size -d -e hex ${file_entry} 2>/dev/null | grep -w "trusted.ec.size" | cut -d '=' -f 2"
+        hex_size=$(ssh -n "${file_host}" "${cmd}")
+
+        if [[ -z $hex_size || "$hex_size" != "$xattr" ]]
+        then
+            echo "False"
+            return
+        fi
+        size_diff=$(printf '%d' $(( size - hex_size )))
+        if [[ $size_diff -gt 2047 ]]
+        then
+            echo "False"
+            return
+        else
+            echo "True"
+            return
+        fi
+    else
+        echo "False"
+        return
+    fi
+}
+
+function find_file_paths ()
+{
+    local bpath=$1
+    local file_entry=""
+    local file_host=""
+    local cmd=""
+    local brick_root=""
+    local gfid=""
+    local actual_path=""
+    local gfid_path=""
+
+    file_host=$(echo "$bpath" | cut -d ":" -f 1)
+    file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+    brick_root=$(echo "$file_entry" | cut -d "#" -f 1)
+
+    gfid=$(echo "${file_entry}" | grep ".glusterfs")
+    if [[ -n "$gfid" ]]
+    then
+        gfid_path=$(echo "$file_entry" | cut -d "#" -f 2)
+        file_entry=${file_entry//#}
+        cmd="find -L '$brick_root' -samefile '$file_entry' 2>/dev/null | grep -v '.glusterfs' "
+        actual_path=$(ssh -n "${file_host}" "${cmd}")
+        #removing absolute path so that user can refer this from mount point
+        actual_path=${actual_path#"$brick_root"}
+    else
+        actual_path=$(echo "$file_entry" | cut -d "#" -f 2)
+        file_entry=${file_entry//#}
+        cmd="find -L '$brick_root' -samefile '$file_entry' 2>/dev/null | grep '.glusterfs' "
+        gfid_path=$(ssh -n "${file_host}" "${cmd}")
+        gfid_path=${gfid_path#"$brick_root"}
+    fi
+
+    echo "${gfid_path}|${actual_path}"
+}
+
+function log_can_not_heal ()
+{
+    local gfid_actual_paths=$1
+    local file_paths=$2
+    file_paths=${file_paths//#}
+
+    echo "${LINE_SEP}" >> "$CAN_NOT_HEAL"
+    echo "Can Not Heal : $(echo "$gfid_actual_paths" | cut -d '|' -f 2)" >> "$CAN_NOT_HEAL"
+    for bpath in ${file_paths//,/ }
+    do
+        echo "${bpath}" >> "$CAN_NOT_HEAL"
+    done
+}
+
+function check_all_frag_and_set_xattr ()
+{
+    local file_paths=$1
+    local total_size=$2
+    local file_stat=$3
+    local bpath=""
+    local healthy_count=0
+    local match="False"
+    local matching_bricks=""
+    local bad_bricks=""
+    local gfid_actual_paths=""
+
+    for bpath in ${file_paths//,/ }
+    do
+        if [[ -n "$gfid_actual_paths" ]]
+        then
+            break
+        fi
+        gfid_actual_paths=$(find_file_paths "$bpath")
+    done
+
+   match=$(match_size_xattr_quorum "$file_paths")
+
+#   echo "${match} : $bpath" >> "$MOD_BACKUP_FILES"
+
+    if [[ "$match" != "False" ]]
+    then
+        xattr="$match"
+        for bpath in ${file_paths//,/ }
+        do
+            match="False"
+            match=$(match_stat_size_with_xattr "$bpath" "$total_size" "$file_stat" "$xattr")
+            if [[ "$match" == "True" ]]
+            then
+                matching_bricks="${bpath},${matching_bricks}"
+                healthy_count=$((healthy_count + 1))
+            else
+                bad_bricks="${bpath},${bad_bricks}"
+            fi
+        done
+    fi
+
+    if [[ $healthy_count -ge 4 ]]
+    then
+        match="True"
+        echo "${LINE_SEP}" >> "$MOD_BACKUP_FILES"
+        echo "Modified : $(echo "$gfid_actual_paths" | cut -d '|' -f 2)" >> "$MOD_BACKUP_FILES"
+        set_version_dirty_xattr  "$matching_bricks" 1 "$gfid_actual_paths"
+        set_version_dirty_xattr  "$bad_bricks" 0 "$gfid_actual_paths"
+    else
+        log_can_not_heal "$gfid_actual_paths" "${file_paths}"
+    fi
+
+    echo "$match"
+}
+function set_xattr()
+{
+    local count=$1
+    local heal_entry=""
+    local file_stat=""
+    local frag_size=""
+    local total_size=""
+    local file_paths=""
+    local num=""
+    local can_heal_count=0
+
+    heal_log "Started $(basename $BASH_SOURCE) on $(date) "
+
+    while read -r heal_entry
+    do
+        heal_log "$LINE_SEP"
+        heal_log "${heal_entry}"
+
+        file_stat=$(echo "$heal_entry" | cut -d "|" -f 1)
+        frag_size=$(echo "$file_stat" | rev | cut -d ":" -f 1 | rev)
+        total_size="$(total_file_size_in_hex "$frag_size")"
+        file_paths=$(echo "$heal_entry" | cut -d "|" -f 2)
+        match=$(check_all_frag_and_set_xattr "$file_paths" "$total_size" "$file_stat")
+        if [[ "$match" == "True" ]]
+        then
+            can_heal_count=$((can_heal_count + 1))
+        fi
+
+        sed -i '1d' potential_heal
+        count=$((count - 1))
+        if [ $count == 0 ]
+        then
+            num=$(cat potential_heal | wc -l)
+            heal_log "$LINE_SEP"
+            heal_log "${1} : Processed"
+            heal_log "${can_heal_count} : Modified to Heal"
+            heal_log "$((${1} - can_heal_count)) : Moved to can_not_heal."
+            heal_log "${num} : Pending as Potential Heal"
+            exit 0
+        fi
+
+    done < potential_heal
+}
+
+function main ()
+{
+    local count=0
+
+    read -p "Number of files to correct: [choose between 1-1000] (0 for All):" count
+    if [[ $count -lt 0 || $count -gt 1000 ]]
+    then
+        echo "Provide correct value:"
+        exit 2
+    fi
+
+    if [[ $count -eq 0 ]]
+    then
+        count=$(cat potential_heal | wc -l)
+    fi
+    set_xattr "$count"
+}
+
+_init "$@" && main "$@"
diff --git a/extras/ec-heal-script/gfid_needing_heal_parallel.sh b/extras/ec-heal-script/gfid_needing_heal_parallel.sh
new file mode 100755
index 00000000000..d7f53c97c33
--- /dev/null
+++ b/extras/ec-heal-script/gfid_needing_heal_parallel.sh
@@ -0,0 +1,278 @@
+#!/bin/bash
+#  Copyright (c) 2019-2020 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+
+# This script provides a list of all the files which can be healed or not healed.
+# It also generates two files, potential_heal and can_not_heal, which contains the information
+# of all theose files. These files could be used by correct_pending_heals.sh to correct
+# the fragmnets so that files could be healed by shd.
+
+CAN_NOT_HEAL="can_not_heal"
+CAN_HEAL="potential_heal"
+LINE_SEP="==================================================="
+LOG_DIR="/var/log/glusterfs"
+LOG_FILE="$LOG_DIR/ec-heal-script.log"
+
+function heal_log()
+{
+    echo "$1" >> "$LOG_FILE"
+}
+
+function _init ()
+{
+    if [ $# -ne 1 ]; then
+    echo "usage: $0 <gluster volume name>";
+    echo "This script provides a list of all the files which can be healed or not healed.
+It also generates two files, potential_heal and can_not_heal, which contains the information
+of all theose files. These files could be used by correct_pending_heals.sh to correct
+the fragmnets so that files could be healed by shd."
+    exit 2;
+    fi
+
+    volume=$1;
+}
+
+function get_pending_entries ()
+{
+    local volume_name=$1
+
+    gluster volume heal "$volume_name" info | grep -v ":/" | grep -v "Number of entries" | grep -v "Status:" | sort -u | sed '/^$/d'
+}
+
+function get_entry_path_on_brick()
+{
+    local path="$1"
+    local gfid_string=""
+    if [[ "${path:0:1}" == "/" ]];
+    then
+        echo "$path"
+    else
+        gfid_string="$(echo "$path" | cut -f2 -d':' | cut -f1 -d '>')"
+        echo "/.glusterfs/${gfid_string:0:2}/${gfid_string:2:2}/$gfid_string"
+    fi
+}
+
+function run_command_on_server()
+{
+	local subvolume="$1"
+	local host="$2"
+	local cmd="$3"
+	local output
+        output=$(ssh -n "${host}" "${cmd}")
+	if [ -n "$output" ]
+	then
+            echo "$subvolume:$output"
+	fi
+}
+
+function get_entry_path_all_bricks ()
+{
+    local entry="$1"
+    local bricks="$2"
+    local cmd=""
+    for brick in $bricks
+    do
+	    echo "${brick}#$(get_entry_path_on_brick "$entry")"
+    done | tr '\n' ','
+}
+
+function get_stat_for_entry_from_all_bricks ()
+{
+    local entry="$1"
+    local bricks="$2"
+    local subvolume=0
+    local host=""
+    local bpath=""
+    local cmd=""
+
+    for brick in $bricks
+    do
+        if [[ "$((subvolume % 6))" == "0" ]]
+        then
+            subvolume=$((subvolume+1))
+        fi
+        host=$(echo "$brick" | cut -f1 -d':')
+        bpath=$(echo "$brick" | cut -f2 -d':')
+
+	cmd="stat --format=%F:%B:%s $bpath$(get_entry_path_on_brick "$entry") 2>/dev/null"
+    run_command_on_server "$subvolume" "${host}" "${cmd}" &
+    done | sort | uniq -c | sort -rnk1
+}
+
+function get_bricks_from_volume()
+{
+    local v=$1
+    gluster volume info "$v" | grep -E "^Brick[0-9][0-9]*:" | cut -f2- -d':'
+}
+
+function print_entry_gfid()
+{
+    local host="$1"
+    local dirpath="$2"
+    local entry="$3"
+    local gfid
+    gfid="$(ssh -n "${host}" "getfattr -d -m. -e hex $dirpath/$entry 2>/dev/null | grep trusted.gfid=|cut -f2 -d'='")"
+    echo "$entry" - "$gfid"
+}
+
+function print_brick_directory_info()
+{
+    local h="$1"
+    local dirpath="$2"
+    while read -r e
+    do
+        print_entry_gfid "${h}" "${dirpath}" "${e}"
+    done < <(ssh -n "${h}" "ls $dirpath 2>/dev/null")
+}
+
+function print_directory_info()
+{
+    local entry="$1"
+    local bricks="$2"
+    local h
+    local b
+    local gfid
+    for brick in $bricks;
+    do
+        h="$(echo "$brick" | cut -f1 -d':')"
+        b="$(echo "$brick" | cut -f2 -d':')"
+        dirpath="$b$(get_entry_path_on_brick "$entry")"
+	print_brick_directory_info "${h}" "${dirpath}" &
+    done | sort | uniq -c
+}
+
+function print_entries_needing_heal()
+{
+    local quorum=0
+    local entry="$1"
+    local bricks="$2"
+    while read -r line
+    do
+        quorum=$(echo "$line" | awk '{print $1}')
+        if [[ "$quorum" -lt 4 ]]
+        then
+            echo "$line - Not in Quorum"
+        else
+            echo "$line - In Quorum"
+        fi
+    done < <(print_directory_info "$entry" "$bricks")
+}
+
+function find_file_paths ()
+{
+    local bpath=$1
+    local file_entry=""
+    local file_host=""
+    local cmd=""
+    local brick_root=""
+    local gfid=""
+    local actual_path=""
+    local gfid_path=""
+
+    file_host=$(echo "$bpath" | cut -d ":" -f 1)
+    file_entry=$(echo "$bpath" | cut -d ":" -f 2)
+    brick_root=$(echo "$file_entry" | cut -d "#" -f 1)
+
+    gfid=$(echo "${file_entry}" | grep ".glusterfs")
+
+    if [[ -n "$gfid" ]]
+    then
+        gfid_path=$(echo "$file_entry" | cut -d "#" -f 2)
+        file_entry=${file_entry//#}
+        cmd="find -L '$brick_root' -samefile '$file_entry' 2>/dev/null | grep -v '.glusterfs' "
+        actual_path=$(ssh -n "${file_host}" "${cmd}")
+        #removing absolute path so that user can refer this from mount point
+        actual_path=${actual_path#"$brick_root"}
+    else
+        actual_path=$(echo "$file_entry" | cut -d "#" -f 2)
+        file_entry=${file_entry//#}
+        cmd="find -L '$brick_root' -samefile '$file_entry' 2>/dev/null | grep '.glusterfs' "
+        gfid_path=$(ssh -n "${file_host}" "${cmd}")
+        gfid_path=${gfid_path#"$brick_root"}
+    fi
+
+    echo "${gfid_path}|${actual_path}"
+}
+
+function log_can_not_heal ()
+{
+    local gfid_actual_paths=$1
+    local file_paths=$2
+    file_paths=${file_paths//#}
+
+    echo "${LINE_SEP}" >> "$CAN_NOT_HEAL"
+    echo "Can Not Heal : $(echo "$gfid_actual_paths" | cut -d '|' -f 2)" >> "$CAN_NOT_HEAL"
+    for bpath in ${file_paths//,/ }
+    do
+        echo "${bpath}" >> "$CAN_NOT_HEAL"
+    done
+}
+
+function main ()
+{
+    local bricks=""
+    local quorum=0
+    local stat_info=""
+    local file_type=""
+    local gfid_actual_paths=""
+    local bpath=""
+    local file_paths=""
+    local good=0
+    local bad=0
+    bricks=$(get_bricks_from_volume "$volume")
+    rm -f "$CAN_HEAL"
+    rm -f "$CAN_NOT_HEAL"
+    mkdir "$LOG_DIR" -p
+
+    heal_log "Started $(basename "$BASH_SOURCE") on $(date) "
+    while read -r heal_entry
+    do
+        heal_log "------------------------------------------------------------------"
+        heal_log "$heal_entry"
+
+        gfid_actual_paths=""
+        file_paths="$(get_entry_path_all_bricks "$heal_entry" "$bricks")"
+        stat_info="$(get_stat_for_entry_from_all_bricks "$heal_entry" "$bricks")"
+        heal_log "$stat_info"
+
+        quorum=$(echo "$stat_info" | head -1 | awk '{print $1}')
+        good_stat=$(echo "$stat_info" | head -1 | awk '{print $3}')
+        file_type="$(echo "$stat_info" | head -1 | cut -f2 -d':')"
+        if [[ "$file_type" == "directory" ]]
+        then
+            print_entries_needing_heal "$heal_entry" "$bricks"
+        else
+            if [[ "$quorum" -ge 4 ]]
+            then
+                good=$((good + 1))
+                heal_log "Verdict: Healable"
+
+                echo "${good_stat}|$file_paths" >> "$CAN_HEAL"
+            else
+                bad=$((bad + 1))
+                heal_log "Verdict: Not Healable"
+                for bpath in ${file_paths//,/ }
+                do
+                    if [[ -z "$gfid_actual_paths" ]]
+                    then
+                        gfid_actual_paths=$(find_file_paths "$bpath")
+                    else
+                        break
+                    fi
+                done
+                log_can_not_heal "$gfid_actual_paths" "${file_paths}"
+            fi
+        fi
+    done < <(get_pending_entries "$volume")
+    heal_log "========================================="
+    heal_log "Total number of  potential heal : ${good}"
+    heal_log "Total number of can not heal    : ${bad}"
+    heal_log "========================================="
+}
+
+_init "$@" && main "$@"
diff --git a/extras/failed-tests.py b/extras/failed-tests.py
index 476e24331e5..f7f110246b5 100755
--- a/extras/failed-tests.py
+++ b/extras/failed-tests.py
@@ -1,5 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
+from __future__ import print_function
 import blessings
 import requests
 from requests.packages.urllib3.exceptions import InsecureRequestWarning
@@ -25,7 +26,7 @@ def process_failure(url, node):
         if t.find("Result: FAIL") != -1:
             for t2 in accum:
                 if VERBOSE:
-                    print t2.encode('utf-8')
+                    print(t2.encode('utf-8'))
                 if t2.find("Wstat") != -1:
                     test_case = re.search('\./tests/.*\.t', t2)
                     if test_case:
@@ -69,26 +70,26 @@ def print_summary(failed_builds, total_builds, html=False):
     template = 0
     if html:
         template = 1
-    print render(
+    print(render(
             count[template],
             {'failed': failed_builds, 'total': total_builds}
-    )
-    for k, v in summary.iteritems():
+    ))
+    for k, v in summary.items():
         if k == 'core':
-            print ''.join([TERM.red, "Found cores:", TERM.normal])
+            print(''.join([TERM.red, "Found cores:", TERM.normal]))
             for comp, link in zip(v[::2], v[1::2]):
-                print render(component[template], {'comp': comp})
-                print render(
+                print(render(component[template], {'comp': comp}))
+                print(render(
                         regression_link[template],
                         {'link': link[0], 'node': link[1]}
-                )
+                ))
         else:
-            print render(failure_count[template], {'test': k, 'count': len(v)})
+            print(render(failure_count[template], {'test': k, 'count': len(v)}))
             for link in v:
-                print render(
+                print(render(
                         regression_link[template],
                         {'link': link[0], 'node': link[1]}
-                )
+                ))
 
 
 def get_summary(cut_off_date, reg_link):
@@ -97,7 +98,7 @@ def get_summary(cut_off_date, reg_link):
     '''
     success_count = 0
     failure_count = 0
-    for page in xrange(0, MAX_BUILDS, 100):
+    for page in range(0, MAX_BUILDS, 100):
         build_info = requests.get(''.join([
                 BASE,
                 reg_link,
@@ -114,11 +115,11 @@ def get_summary(cut_off_date, reg_link):
                 success_count += 1
                 continue
             if VERBOSE:
-                print ''.join([
+                print(''.join([
                     TERM.red,
                     'FAILURE on {0}'.format(build['url']),
                     TERM.normal
-                ])
+                ]))
             url = ''.join([build['url'], 'consoleText'])
             failure_count += 1
             process_failure(url, build['builtOn'])
diff --git a/extras/firewalld/Makefile.am b/extras/firewalld/Makefile.am
index a5c11b0b783..530881fb8eb 100644
--- a/extras/firewalld/Makefile.am
+++ b/extras/firewalld/Makefile.am
@@ -1,6 +1,8 @@
 EXTRA_DIST = glusterfs.xml
 
 if USE_FIREWALLD
+if WITH_SERVER
 staticdir = /usr/lib/firewalld/services/
 static_DATA = glusterfs.xml
 endif
+endif
diff --git a/extras/ganesha/Makefile.am b/extras/ganesha/Makefile.am
new file mode 100644
index 00000000000..9eaa401b6c8
--- /dev/null
+++ b/extras/ganesha/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = scripts config ocf
+CLEANFILES =
diff --git a/extras/ganesha/config/Makefile.am b/extras/ganesha/config/Makefile.am
new file mode 100644
index 00000000000..c729273096e
--- /dev/null
+++ b/extras/ganesha/config/Makefile.am
@@ -0,0 +1,4 @@
+EXTRA_DIST= ganesha-ha.conf.sample
+
+confdir = $(sysconfdir)/ganesha
+conf_DATA = ganesha-ha.conf.sample
diff --git a/extras/ganesha/config/ganesha-ha.conf.sample b/extras/ganesha/config/ganesha-ha.conf.sample
new file mode 100644
index 00000000000..c22892bde56
--- /dev/null
+++ b/extras/ganesha/config/ganesha-ha.conf.sample
@@ -0,0 +1,19 @@
+# Name of the HA cluster created.
+# must be unique within the subnet
+HA_NAME="ganesha-ha-360"
+#
+# N.B. you may use short names or long names; you may not use IP addrs.
+# Once you select one, stay with it as it will be mildly unpleasant to
+# clean up if you switch later on. Ensure that all names - short and/or
+# long - are in DNS or /etc/hosts on all machines in the cluster.
+#
+# The subset of nodes of the Gluster Trusted Pool that form the ganesha
+# HA cluster. Hostname is specified.
+HA_CLUSTER_NODES="server1,server2,..."
+#HA_CLUSTER_NODES="server1.lab.redhat.com,server2.lab.redhat.com,..."
+#
+# Virtual IPs for each of the nodes specified above.
+VIP_server1="10.0.2.1"
+VIP_server2="10.0.2.2"
+#VIP_server1_lab_redhat_com="10.0.2.1"
+#VIP_server2_lab_redhat_com="10.0.2.2"
diff --git a/extras/ganesha/ocf/Makefile.am b/extras/ganesha/ocf/Makefile.am
new file mode 100644
index 00000000000..990a609f254
--- /dev/null
+++ b/extras/ganesha/ocf/Makefile.am
@@ -0,0 +1,11 @@
+EXTRA_DIST= ganesha_grace ganesha_mon ganesha_nfsd
+
+# The root of the OCF resource agent hierarchy
+# Per the OCF standard, it's always "lib",
+# not "lib64" (even on 64-bit platforms).
+ocfdir = $(prefix)/lib/ocf
+
+# The provider directory
+radir = $(ocfdir)/resource.d/heartbeat
+
+ra_SCRIPTS = ganesha_grace ganesha_mon ganesha_nfsd
diff --git a/extras/ganesha/ocf/ganesha_grace b/extras/ganesha/ocf/ganesha_grace
new file mode 100644
index 00000000000..825f7164597
--- /dev/null
+++ b/extras/ganesha/ocf/ganesha_grace
@@ -0,0 +1,221 @@
+#!/bin/bash
+#
+# Copyright (c) 2014 Anand Subramanian anands@redhat.com
+# Copyright (c) 2015 Red Hat Inc.
+#                    All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Further, this software is distributed without any warranty that it is
+# free of the rightful claim of any third person regarding infringement
+# or the like.  Any license provided herein, whether implied or
+# otherwise, applies only to this software file.  Patent licenses, if
+# any, provided herein do not apply to combinations of this program with
+# other software, or any other product whatsoever.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
+#
+#
+
+# Initialization:
+: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+
+if [ -n "$OCF_DEBUG_LIBRARY" ]; then
+	. $OCF_DEBUG_LIBRARY
+else
+	: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+	. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+fi
+
+OCF_RESKEY_grace_active_default="grace-active"
+: ${OCF_RESKEY_grace_active=${OCF_RESKEY_grace_active_default}}
+
+ganesha_meta_data() {
+	cat <<END
+<?xml version="1.0"?>
+<!DOCTYPE resource-agent SYSTEM "ra-api-1.dtd">
+<resource-agent name="ganesha_grace">
+<version>1.0</version>
+
+<longdesc lang="en">
+This Linux-specific resource agent acts as a dummy
+resource agent for nfs-ganesha.
+</longdesc>
+
+<shortdesc lang="en">Manages the user-space nfs-ganesha NFS server</shortdesc>
+
+<parameters>
+<parameter name="grace_active">
+<longdesc lang="en">NFS-Ganesha grace active attribute</longdesc>
+<shortdesc lang="en">NFS-Ganesha grace active attribute</shortdesc>
+<content type="string" default="grace-active" />
+</parameter>
+</parameters>
+
+<actions>
+<action name="start"   timeout="40s" />
+<action name="stop"    timeout="40s" />
+<action name="status"  timeout="20s" interval="60s" />
+<action name="monitor" depth="0" timeout="10s" interval="5s" />
+<action name="notify"  timeout="10s" />
+<action name="meta-data"  timeout="20s" />
+</actions>
+</resource-agent>
+END
+
+return ${OCF_SUCCESS}
+}
+
+ganesha_grace_usage() {
+	echo "ganesha.nfsd USAGE"
+}
+
+# Make sure meta-data and usage always succeed
+case $__OCF_ACTION in
+	meta-data)	ganesha_meta_data
+			exit ${OCF_SUCCESS}
+			;;
+	usage|help)	ganesha_usage
+			exit ${OCF_SUCCESS}
+			;;
+	*)
+			;;
+esac
+
+ganesha_grace_start()
+{
+	local rc=${OCF_ERR_GENERIC}
+	local host=$(hostname -s)
+
+	ocf_log debug "ganesha_grace_start()"
+	# give ganesha_mon RA a chance to set the crm_attr first
+	# I mislike the sleep, but it's not clear that looping
+	# with a small sleep is necessarily better
+	# start has a 40sec timeout, so a 5sec sleep here is okay
+        sleep 5
+	attr=$(crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} 2> /dev/null)
+        if [ $? -ne 0 ]; then
+		host=$(hostname)
+		attr=$(crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} 2> /dev/null )
+                if [ $? -ne 0 ]; then
+	                ocf_log info "grace start: crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} failed"
+                fi
+        fi
+
+	# Three possibilities:
+	# 1. There is no attribute at all and attr_updater returns
+	#    a zero length string. This happens when
+	#    ganesha_mon::monitor hasn't run at least once to set
+	#    the attribute. The assumption here is that the system
+	#    is coming up. We pretend, for now, that the node is
+	#    healthy, to allow the system to continue coming up.
+	#    It will cure itself in a few seconds
+	# 2. There is an attribute, and it has the value "1"; this
+	#    node is healthy.
+	# 3. There is an attribute, but it has no value or the value
+	#    "0"; this node is not healthy.
+
+	# case 1
+	if [[ -z "${attr}" ]]; then
+		return ${OCF_SUCCESS}
+	fi
+
+	# case 2
+	if [[ "${attr}" = *"value=1" ]]; then
+		return ${OCF_SUCCESS}
+	fi
+
+	# case 3
+	return ${OCF_NOT_RUNNING}
+}
+
+ganesha_grace_stop()
+{
+
+	ocf_log debug "ganesha_grace_stop()"
+	return ${OCF_SUCCESS}
+}
+
+ganesha_grace_notify()
+{
+        # since this is a clone RA we should only ever see pre-start
+        # or post-stop
+	mode="${OCF_RESKEY_CRM_meta_notify_type}-${OCF_RESKEY_CRM_meta_notify_operation}"
+	case "${mode}" in
+	pre-start | post-stop)
+		dbus-send --print-reply --system --dest=org.ganesha.nfsd /org/ganesha/nfsd/admin org.ganesha.nfsd.admin.grace string:${OCF_RESKEY_CRM_meta_notify_stop_uname}
+		if [ $? -ne 0 ]; then
+			ocf_log info "dbus-send --print-reply --system --dest=org.ganesha.nfsd /org/ganesha/nfsd/admin org.ganesha.nfsd.admin.grace string:${OCF_RESKEY_CRM_meta_notify_stop_uname} failed"
+		fi
+		;;
+	esac
+
+	return ${OCF_SUCCESS}
+}
+
+ganesha_grace_monitor()
+{
+	local host=$(hostname -s)
+
+	ocf_log debug "monitor"
+
+	attr=$(crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} 2> /dev/null)
+        if [ $? -ne 0 ]; then
+		host=$(hostname)
+	        attr=$(crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} 2> /dev/null)
+                if [ $? -ne 0 ]; then
+	                ocf_log info "crm_attribute --query --node=${host} --name=${OCF_RESKEY_grace_active} failed"
+                fi
+        fi
+
+	# if there is no attribute (yet), maybe it's because
+	# this RA started before ganesha_mon (nfs-mon) has had
+	# chance to create it. In which case we'll pretend
+	# everything is okay this time around
+	if [[ -z "${attr}" ]]; then
+		return ${OCF_SUCCESS}
+	fi
+
+	if [[ "${attr}" = *"value=1" ]]; then
+		return ${OCF_SUCCESS}
+	fi
+
+	return ${OCF_NOT_RUNNING}
+}
+
+ganesha_grace_validate()
+{
+	return ${OCF_SUCCESS}
+}
+
+ganesha_grace_validate
+
+# Translate each action into the appropriate function call
+case $__OCF_ACTION in
+start)          ganesha_grace_start
+		;;
+stop)           ganesha_grace_stop
+		;;
+status|monitor) ganesha_grace_monitor
+		;;
+notify)         ganesha_grace_notify
+		;;
+*)              ganesha_grace_usage
+		exit ${OCF_ERR_UNIMPLEMENTED}
+		;;
+esac
+
+rc=$?
+
+# The resource agent may optionally log a debug message
+ocf_log debug "${OCF_RESOURCE_INSTANCE} ${__OCF_ACTION} returned $rc"
+exit $rc
diff --git a/extras/ganesha/ocf/ganesha_mon b/extras/ganesha/ocf/ganesha_mon
new file mode 100644
index 00000000000..2b4a9d6da84
--- /dev/null
+++ b/extras/ganesha/ocf/ganesha_mon
@@ -0,0 +1,234 @@
+#!/bin/bash
+#
+# Copyright (c) 2014 Anand Subramanian anands@redhat.com
+# Copyright (c) 2015 Red Hat Inc.
+#                    All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Further, this software is distributed without any warranty that it is
+# free of the rightful claim of any third person regarding infringement
+# or the like.  Any license provided herein, whether implied or
+# otherwise, applies only to this software file.  Patent licenses, if
+# any, provided herein do not apply to combinations of this program with
+# other software, or any other product whatsoever.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
+#
+#
+
+# Initialization:
+: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+
+if [ -n "${OCF_DEBUG_LIBRARY}" ]; then
+	. ${OCF_DEBUG_LIBRARY}
+else
+	: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+	. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+fi
+
+# Defaults
+OCF_RESKEY_ganesha_active_default="ganesha-active"
+OCF_RESKEY_grace_active_default="grace-active"
+OCF_RESKEY_grace_delay_default="5"
+
+: ${OCF_RESKEY_ganesha_active=${OCF_RESKEY_ganesha_active_default}}
+: ${OCF_RESKEY_grace_active=${OCF_RESKEY_grace_active_default}}
+: ${OCF_RESKEY_grace_delay=${OCF_RESKEY_grace_delay_default}}
+
+ganesha_meta_data() {
+	cat <<END
+<?xml version="1.0"?>
+<!DOCTYPE resource-agent SYSTEM "ra-api-1.dtd">
+<resource-agent name="ganesha_mon">
+<version>1.0</version>
+
+<longdesc lang="en">
+This Linux-specific resource agent acts as a dummy
+resource agent for nfs-ganesha.
+</longdesc>
+
+<shortdesc lang="en">Manages the user-space nfs-ganesha NFS server</shortdesc>
+
+<parameters>
+<parameter name="ganesha_active">
+<longdesc lang="en">NFS-Ganesha daemon active attribute</longdesc>
+<shortdesc lang="en">NFS-Ganesha daemon active attribute</shortdesc>
+<content type="string" default="ganesha-active" />
+</parameter>
+<parameter name="grace_active">
+<longdesc lang="en">NFS-Ganesha grace active attribute</longdesc>
+<shortdesc lang="en">NFS-Ganesha grace active attribute</shortdesc>
+<content type="string" default="grace-active" />
+</parameter>
+<parameter name="grace_delay">
+<longdesc lang="en">
+NFS-Ganesha grace delay.
+When changing this, adjust the ganesha_grace RA's monitor interval to match.
+</longdesc>
+<shortdesc lang="en">NFS-Ganesha grace delay</shortdesc>
+<content type="string" default="5" />
+</parameter>
+</parameters>
+
+<actions>
+<action name="start"   timeout="40s" />
+<action name="stop"    timeout="40s" />
+<action name="status"  timeout="20s" interval="60s" />
+<action name="monitor" depth="0"  timeout="10s" interval="10s" />
+<action name="meta-data"  timeout="20s" />
+</actions>
+</resource-agent>
+END
+
+return ${OCF_SUCCESS}
+}
+
+ganesha_mon_usage() {
+	echo "ganesha.nfsd USAGE"
+}
+
+# Make sure meta-data and usage always succeed
+case ${__OCF_ACTION} in
+	meta-data)	ganesha_meta_data
+			exit ${OCF_SUCCESS}
+			;;
+	usage|help)	ganesha_usage
+			exit ${OCF_SUCCESS}
+			;;
+	*)
+			;;
+esac
+
+ganesha_mon_start()
+{
+	ocf_log debug "ganesha_mon_start"
+	ganesha_mon_monitor
+	return $OCF_SUCCESS
+}
+
+ganesha_mon_stop()
+{
+	ocf_log debug "ganesha_mon_stop"
+	return $OCF_SUCCESS
+}
+
+ganesha_mon_monitor()
+{
+	local host=$(hostname -s)
+	local pid_file="/var/run/ganesha.pid"
+	local rhel6_pid_file="/var/run/ganesha.nfsd.pid"
+	local proc_pid="/proc/"
+
+	# RHEL6 /etc/init.d/nfs-ganesha adds -p /var/run/ganesha.nfsd.pid
+	# RHEL7 systemd does not. Would be nice if all distros used the
+	# same pid file.
+	if [ -e ${rhel6_pid_file} ]; then
+		pid_file=${rhel6_pid_file}
+	fi
+	if [ -e ${pid_file} ]; then
+		proc_pid="${proc_pid}$(cat ${pid_file})"
+	fi
+
+	if [ "x${proc_pid}" != "x/proc/" -a -d ${proc_pid} ]; then
+
+		attrd_updater -n ${OCF_RESKEY_ganesha_active} -v 1
+		if [ $? -ne 0 ]; then
+			ocf_log info "warning: attrd_updater -n ${OCF_RESKEY_ganesha_active} -v 1 failed"
+		fi
+
+		# ganesha_grace (nfs-grace) RA follows grace-active attr
+		# w/ constraint location
+		attrd_updater -n ${OCF_RESKEY_grace_active} -v 1
+		if [ $? -ne 0 ]; then
+			ocf_log info "warning: attrd_updater -n ${OCF_RESKEY_grace_active} -v 1 failed"
+		fi
+
+		# ganesha_mon (nfs-mon) and ganesha_grace (nfs-grace)
+		# track grace-active crm_attr (attr != crm_attr)
+		# we can't just use the attr as there's no way to query
+		# its value in RHEL6 pacemaker
+
+		crm_attribute --node=${host} --lifetime=forever --name=${OCF_RESKEY_grace_active} --update=1 2> /dev/null
+		if [ $? -ne 0 ]; then
+			host=$(hostname)
+			crm_attribute --node=${host} --lifetime=forever --name=${OCF_RESKEY_grace_active} --update=1 2> /dev/null
+			if [ $? -ne 0 ]; then
+				ocf_log info "mon monitor warning: crm_attribute --node=${host} --lifetime=forever --name=${OCF_RESKEY_grace_active} --update=1 failed"
+			fi
+		fi
+
+		return ${OCF_SUCCESS}
+	fi
+
+	# VIP fail-over is triggered by clearing the
+	# ganesha-active node attribute on this node.
+	#
+	# Meanwhile the ganesha_grace notify() runs when its
+	# nfs-grace resource is disabled on a node; which
+	# is triggered by clearing the grace-active attribute
+	# on this node.
+	#
+	# We need to allow time for it to run and put
+	# the remaining ganesha.nfsds into grace before
+	# initiating the VIP fail-over.
+
+	attrd_updater -D -n ${OCF_RESKEY_grace_active}
+	if [ $? -ne 0 ]; then
+		ocf_log info "warning: attrd_updater -D -n ${OCF_RESKEY_grace_active} failed"
+	fi
+
+	host=$(hostname -s)
+	crm_attribute --node=${host} --name=${OCF_RESKEY_grace_active} --update=0 2> /dev/null
+	if [ $? -ne 0 ]; then
+		host=$(hostname)
+		crm_attribute --node=${host} --name=${OCF_RESKEY_grace_active} --update=0 2> /dev/null
+		if [ $? -ne 0 ]; then
+			ocf_log info "mon monitor warning: crm_attribute --node=${host} --name=${OCF_RESKEY_grace_active} --update=0 failed"
+		fi
+	fi
+
+	sleep ${OCF_RESKEY_grace_delay}
+
+	attrd_updater -D -n ${OCF_RESKEY_ganesha_active}
+	if [ $? -ne 0 ]; then
+		ocf_log info "warning: attrd_updater -D -n ${OCF_RESKEY_ganesha_active} failed"
+	fi
+
+	return ${OCF_SUCCESS}
+}
+
+ganesha_mon_validate()
+{
+	return ${OCF_SUCCESS}
+}
+
+ganesha_mon_validate
+
+# Translate each action into the appropriate function call
+case ${__OCF_ACTION} in
+start)          ganesha_mon_start
+		;;
+stop)           ganesha_mon_stop
+		;;
+status|monitor) ganesha_mon_monitor
+		;;
+*)              ganesha_mon_usage
+		exit ${OCF_ERR_UNIMPLEMENTED}
+		;;
+esac
+
+rc=$?
+
+# The resource agent may optionally log a debug message
+ocf_log debug "${OCF_RESOURCE_INSTANCE} ${__OCF_ACTION} returned $rc"
+exit $rc
diff --git a/extras/ganesha/ocf/ganesha_nfsd b/extras/ganesha/ocf/ganesha_nfsd
new file mode 100644
index 00000000000..f91e8b6b8f7
--- /dev/null
+++ b/extras/ganesha/ocf/ganesha_nfsd
@@ -0,0 +1,167 @@
+#!/bin/bash
+#
+# Copyright (c) 2014 Anand Subramanian anands@redhat.com
+# Copyright (c) 2015 Red Hat Inc.
+#                    All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Further, this software is distributed without any warranty that it is
+# free of the rightful claim of any third person regarding infringement
+# or the like.  Any license provided herein, whether implied or
+# otherwise, applies only to this software file.  Patent licenses, if
+# any, provided herein do not apply to combinations of this program with
+# other software, or any other product whatsoever.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
+#
+#
+
+# Initialization:
+: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+
+if [ -n "${OCF_DEBUG_LIBRARY}" ]; then
+	. ${OCF_DEBUG_LIBRARY}
+else
+	: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
+	. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
+fi
+
+OCF_RESKEY_ha_vol_mnt_default="/run/gluster/shared_storage"
+: ${OCF_RESKEY_ha_vol_mnt=${OCF_RESKEY_ha_vol_mnt_default}}
+
+ganesha_meta_data() {
+	cat <<END
+<?xml version="1.0"?>
+<!DOCTYPE resource-agent SYSTEM "ra-api-1.dtd">
+<resource-agent name="ganesha_nfsd">
+<version>1.0</version>
+
+<longdesc lang="en">
+This Linux-specific resource agent acts as a dummy
+resource agent for nfs-ganesha.
+</longdesc>
+
+<shortdesc lang="en">Manages the user-space nfs-ganesha NFS server</shortdesc>
+
+<parameters>
+<parameter name="ha_vol_mnt">
+<longdesc lang="en">HA State Volume Mount Point</longdesc>
+<shortdesc lang="en">HA_State Volume Mount Point</shortdesc>
+<content type="string" default="" />
+</parameter>
+</parameters>
+
+<actions>
+<action name="start"   timeout="5s" />
+<action name="stop"    timeout="5s" />
+<action name="status" depth="0"  timeout="5s" interval="0" />
+<action name="monitor" depth="0"  timeout="5s" interval="0" />
+<action name="meta-data"  timeout="20s" />
+</actions>
+</resource-agent>
+END
+
+return ${OCF_SUCCESS}
+}
+
+ganesha_nfsd_usage() {
+	echo "ganesha.nfsd USAGE"
+}
+
+# Make sure meta-data and usage always succeed
+case $__OCF_ACTION in
+	meta-data)	ganesha_meta_data
+			exit ${OCF_SUCCESS}
+			;;
+	usage|help)	ganesha_usage
+			exit ${OCF_SUCCESS}
+			;;
+	*)
+			;;
+esac
+
+ganesha_nfsd_start()
+{
+	local long_host=$(hostname)
+
+	if [[ -d /var/lib/nfs ]]; then
+		mv /var/lib/nfs /var/lib/nfs.backup
+		if [ $? -ne 0 ]; then
+			ocf_log notice "mv /var/lib/nfs /var/lib/nfs.backup failed"
+		fi
+		ln -s ${OCF_RESKEY_ha_vol_mnt}/nfs-ganesha/${long_host}/nfs /var/lib/nfs
+		if [ $? -ne 0 ]; then
+			ocf_log notice "ln -s ${OCF_RESKEY_ha_vol_mnt}/nfs-ganesha/${long_host}/nfs /var/lib/nfs failed"
+		fi
+	fi
+
+	return ${OCF_SUCCESS}
+}
+
+ganesha_nfsd_stop()
+{
+
+	if [ -L /var/lib/nfs -a -d /var/lib/nfs.backup ]; then
+		rm -f /var/lib/nfs
+		if [ $? -ne 0 ]; then
+			ocf_log notice "rm -f /var/lib/nfs failed"
+		fi
+		mv /var/lib/nfs.backup /var/lib/nfs
+		if [ $? -ne 0 ]; then
+			ocf_log notice "mv /var/lib/nfs.backup /var/lib/nfs failed"
+		fi
+	fi
+
+	return ${OCF_SUCCESS}
+}
+
+ganesha_nfsd_monitor()
+{
+	# pacemaker checks to see if RA is already running before starting it.
+	# if we return success, then it's presumed it's already running and
+	# doesn't need to be started, i.e. invoke the start action.
+	# return something other than success to make pacemaker invoke the
+	# start action
+	if [[ -L /var/lib/nfs ]]; then
+		return ${OCF_SUCCESS}
+	fi
+	return ${OCF_NOT_RUNNING}
+}
+
+ganesha_nfsd_validate()
+{
+	return ${OCF_SUCCESS}
+}
+
+ganesha_nfsd_validate
+
+# ocf_log notice "ganesha_nfsd ${OCF_RESOURCE_INSTANCE} $__OCF_ACTION"
+
+# Translate each action into the appropriate function call
+case $__OCF_ACTION in
+start)          ganesha_nfsd_start
+		;;
+stop)           ganesha_nfsd_stop
+		;;
+status|monitor) ganesha_nfsd_monitor
+		;;
+*)              ganesha_nfsd_usage
+		exit ${OCF_ERR_UNIMPLEMENTED}
+		;;
+esac
+
+rc=$?
+
+# The resource agent may optionally log a debug message
+ocf_log debug "${OCF_RESOURCE_INSTANCE} ${__OCF_ACTION} returned $rc"
+exit $rc
diff --git a/extras/ganesha/scripts/Makefile.am b/extras/ganesha/scripts/Makefile.am
new file mode 100644
index 00000000000..7e345fd5f19
--- /dev/null
+++ b/extras/ganesha/scripts/Makefile.am
@@ -0,0 +1,6 @@
+EXTRA_DIST= create-export-ganesha.sh generate-epoch.py dbus-send.sh \
+			ganesha-ha.sh
+
+scriptsdir = $(libexecdir)/ganesha
+scripts_SCRIPTS = create-export-ganesha.sh dbus-send.sh generate-epoch.py \
+				  ganesha-ha.sh
diff --git a/extras/ganesha/scripts/create-export-ganesha.sh b/extras/ganesha/scripts/create-export-ganesha.sh
new file mode 100755
index 00000000000..3040e8138b0
--- /dev/null
+++ b/extras/ganesha/scripts/create-export-ganesha.sh
@@ -0,0 +1,92 @@
+#!/bin/bash
+
+#This script is called by glusterd when the user
+#tries to export a volume via NFS-Ganesha.
+#An export file specific to a volume
+#is created in GANESHA_DIR/exports.
+
+# Try loading the config from any of the distro
+# specific configuration locations
+if [ -f /etc/sysconfig/ganesha ]
+        then
+        . /etc/sysconfig/ganesha
+fi
+if [ -f /etc/conf.d/ganesha ]
+        then
+        . /etc/conf.d/ganesha
+fi
+if [ -f /etc/default/ganesha ]
+        then
+        . /etc/default/ganesha
+fi
+
+GANESHA_DIR=${1%/}
+OPTION=$2
+VOL=$3
+CONF=$GANESHA_DIR"/ganesha.conf"
+declare -i EXPORT_ID
+
+function check_cmd_status()
+{
+        if [ "$1" != "0" ]
+                 then
+                 rm -rf $GANESHA_DIR/exports/export.$VOL.conf
+                 sed -i /$VOL.conf/d $CONF
+                 exit 1
+        fi
+}
+
+
+if [ ! -d "$GANESHA_DIR/exports" ];
+        then
+        mkdir $GANESHA_DIR/exports
+        check_cmd_status `echo $?`
+fi
+
+function write_conf()
+{
+echo -e "# WARNING : Using Gluster CLI will overwrite manual
+# changes made to this file. To avoid it, edit the
+# file and run ganesha-ha.sh --refresh-config."
+
+echo "EXPORT{"
+echo "      Export_Id = 2;"
+echo "      Path = \"/$VOL\";"
+echo "      FSAL {"
+echo "           name = "GLUSTER";"
+echo "           hostname=\"localhost\";"
+echo  "          volume=\"$VOL\";"
+echo "           }"
+echo "      Access_type = RW;"
+echo "      Disable_ACL = true;"
+echo '      Squash="No_root_squash";'
+echo "      Pseudo=\"/$VOL\";"
+echo '      Protocols = "3", "4" ;'
+echo '      Transports = "UDP","TCP";'
+echo '      SecType = "sys";'
+echo '      Security_Label = False;'
+echo "     }"
+}
+if [ "$OPTION" = "on" ];
+then
+        if ! (cat $CONF | grep  $VOL.conf\"$ )
+        then
+                write_conf $@ > $GANESHA_DIR/exports/export.$VOL.conf
+                echo "%include \"$GANESHA_DIR/exports/export.$VOL.conf\"" >> $CONF
+                count=`ls -l $GANESHA_DIR/exports/*.conf | wc -l`
+                if [ "$count" = "1" ] ; then
+                        EXPORT_ID=2
+                else
+                        EXPORT_ID=`cat $GANESHA_DIR/.export_added`
+                        check_cmd_status `echo $?`
+                        EXPORT_ID=EXPORT_ID+1
+                        sed -i s/Export_Id.*/"Export_Id= $EXPORT_ID ;"/ \
+                        $GANESHA_DIR/exports/export.$VOL.conf
+                        check_cmd_status `echo $?`
+                fi
+                echo $EXPORT_ID > $GANESHA_DIR/.export_added
+        fi
+else
+        rm -rf $GANESHA_DIR/exports/export.$VOL.conf
+        sed -i /$VOL.conf/d $CONF
+fi
diff --git a/extras/ganesha/scripts/dbus-send.sh b/extras/ganesha/scripts/dbus-send.sh
new file mode 100755
index 00000000000..9d613a0e7ad
--- /dev/null
+++ b/extras/ganesha/scripts/dbus-send.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Try loading the config from any of the distro
+# specific configuration locations
+if [ -f /etc/sysconfig/ganesha ]
+        then
+        . /etc/sysconfig/ganesha
+fi
+if [ -f /etc/conf.d/ganesha ]
+        then
+        . /etc/conf.d/ganesha
+fi
+if [ -f /etc/default/ganesha ]
+        then
+        . /etc/default/ganesha
+fi
+
+GANESHA_DIR=${1%/}
+OPTION=$2
+VOL=$3
+CONF=$GANESHA_DIR"/ganesha.conf"
+
+function check_cmd_status()
+{
+        if [ "$1" != "0" ]
+        then
+                logger "dynamic export failed on node :${hostname -s}"
+        fi
+}
+
+#This function keeps track of export IDs and increments it with every new entry
+function dynamic_export_add()
+{
+        dbus-send  --system \
+--dest=org.ganesha.nfsd  /org/ganesha/nfsd/ExportMgr \
+org.ganesha.nfsd.exportmgr.AddExport  string:$GANESHA_DIR/exports/export.$VOL.conf \
+string:"EXPORT(Path=/$VOL)"
+        check_cmd_status `echo $?`
+}
+
+#This function removes an export dynamically(uses the export_id of the export)
+function dynamic_export_remove()
+{
+        # Below bash fetch all the export from ShowExport command and search
+        # export entry based on path and then get its export entry.
+        # There are two possiblities for path, either entire volume will be
+        # exported or subdir. It handles both cases. But it remove only first
+        # entry from the list based on assumption that entry exported via cli
+        # has lowest export id value
+	removed_id=$(dbus-send --type=method_call --print-reply --system \
+                    --dest=org.ganesha.nfsd /org/ganesha/nfsd/ExportMgr \
+                    org.ganesha.nfsd.exportmgr.ShowExports | grep -B 1 -we \
+                    "/"$VOL -e "/"$VOL"/" | grep uint16 | awk '{print $2}' \
+		    | head -1)
+
+        dbus-send --print-reply --system \
+--dest=org.ganesha.nfsd /org/ganesha/nfsd/ExportMgr \
+org.ganesha.nfsd.exportmgr.RemoveExport uint16:$removed_id
+        check_cmd_status `echo $?`
+}
+
+if [ "$OPTION" = "on" ];
+then
+        dynamic_export_add $@
+fi
+
+if [ "$OPTION" = "off" ];
+then
+        dynamic_export_remove $@
+fi
diff --git a/extras/ganesha/scripts/ganesha-ha.sh b/extras/ganesha/scripts/ganesha-ha.sh
new file mode 100644
index 00000000000..9790a719e10
--- /dev/null
+++ b/extras/ganesha/scripts/ganesha-ha.sh
@@ -0,0 +1,1199 @@
+#!/bin/bash
+
+# Copyright 2015-2016 Red Hat Inc.  All Rights Reserved
+#
+# Pacemaker+Corosync High Availability for NFS-Ganesha
+#
+# setup, teardown, add, delete, refresh-config, and status
+#
+# Each participating node in the cluster is assigned a virtual IP (VIP)
+# which fails over to another node when its associated ganesha.nfsd dies
+# for any reason. After the VIP is moved to another node all the
+# ganesha.nfsds are send a signal using DBUS to put them into NFS GRACE.
+#
+# There are six resource agent types used: ganesha_mon, ganesha_grace,
+# ganesha_nfsd, IPaddr, and Dummy. ganesha_mon is used to monitor the
+# ganesha.nfsd. ganesha_grace is used to send the DBUS signal to put
+# the remaining ganesha.nfsds into grace. ganesha_nfsd is used to start
+# and stop the ganesha.nfsd during setup and teardown. IPaddr manages
+# the VIP. A Dummy resource named $hostname-trigger_ip-1 is used to
+# ensure that the NFS GRACE DBUS signal is sent after the VIP moves to
+# the new host.
+
+GANESHA_HA_SH=$(realpath $0)
+HA_NUM_SERVERS=0
+HA_SERVERS=""
+HA_VOL_NAME="gluster_shared_storage"
+HA_VOL_MNT="/run/gluster/shared_storage"
+HA_CONFDIR=$HA_VOL_MNT"/nfs-ganesha"
+SERVICE_MAN="DISTRO_NOT_FOUND"
+
+# rhel, fedora id, version
+ID=""
+VERSION_ID=""
+
+PCS9OR10_PCS_CNAME_OPTION=""
+PCS9OR10_PCS_CLONE_OPTION="clone"
+SECRET_PEM="/var/lib/glusterd/nfs/secret.pem"
+
+# UNBLOCK RA uses shared_storage which may become unavailable
+# during any of the nodes reboot. Hence increase timeout value.
+PORTBLOCK_UNBLOCK_TIMEOUT="60s"
+
+# Try loading the config from any of the distro
+# specific configuration locations
+if [ -f /etc/sysconfig/ganesha ]
+        then
+        . /etc/sysconfig/ganesha
+fi
+if [ -f /etc/conf.d/ganesha ]
+        then
+        . /etc/conf.d/ganesha
+fi
+if [ -f /etc/default/ganesha ]
+        then
+        . /etc/default/ganesha
+fi
+
+GANESHA_CONF=
+
+function find_rhel7_conf
+{
+ while [[ $# > 0 ]]
+        do
+                key="$1"
+                case $key in
+                        -f)
+                         CONFFILE="$2"
+                         break;
+                         ;;
+                         *)
+                         ;;
+                 esac
+                 shift
+         done
+}
+
+if [ -z ${CONFFILE} ]
+        then
+        find_rhel7_conf ${OPTIONS}
+
+fi
+
+GANESHA_CONF=${CONFFILE:-/etc/ganesha/ganesha.conf}
+
+usage() {
+
+        echo "Usage      : add|delete|refresh-config|status"
+        echo "Add-node   : ganesha-ha.sh --add <HA_CONF_DIR> \
+<NODE-HOSTNAME>  <NODE-VIP>"
+        echo "Delete-node: ganesha-ha.sh --delete <HA_CONF_DIR> \
+<NODE-HOSTNAME>"
+        echo "Refresh-config : ganesha-ha.sh --refresh-config <HA_CONFDIR> \
+<volume>"
+        echo "Status : ganesha-ha.sh --status <HA_CONFDIR>"
+}
+
+determine_service_manager () {
+
+        if [ -e "/bin/systemctl" ];
+        then
+                SERVICE_MAN="/bin/systemctl"
+        elif [ -e "/sbin/invoke-rc.d" ];
+        then
+                SERVICE_MAN="/sbin/invoke-rc.d"
+        elif [ -e "/sbin/service" ];
+        then
+                SERVICE_MAN="/sbin/service"
+        fi
+        if [[ "${SERVICE_MAN}X" == "DISTRO_NOT_FOUNDX" ]]
+        then
+                logger "Service manager not recognized, exiting"
+                exit 1
+        fi
+}
+
+manage_service ()
+{
+        local action=${1}
+        local new_node=${2}
+        local option=
+
+        if [[ "${action}" == "start" ]]; then
+                option="yes"
+        else
+                option="no"
+        fi
+        ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i \
+${SECRET_PEM} root@${new_node} "${GANESHA_HA_SH} --setup-ganesha-conf-files $HA_CONFDIR $option"
+
+        if [[ "${SERVICE_MAN}" == "/bin/systemctl" ]]
+        then
+                ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i \
+${SECRET_PEM} root@${new_node} "${SERVICE_MAN}  ${action} nfs-ganesha"
+        else
+                ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i \
+${SECRET_PEM} root@${new_node} "${SERVICE_MAN} nfs-ganesha ${action}"
+        fi
+}
+
+
+check_cluster_exists()
+{
+    local name=${1}
+    local cluster_name=""
+
+    if [ -e /var/run/corosync.pid ]; then
+        cluster_name=$(pcs status | grep "Cluster name:" | cut -d ' ' -f 3)
+        if [[ "${cluster_name}X" == "${name}X" ]]; then
+            logger "$name already exists, exiting"
+            exit 0
+        fi
+    fi
+}
+
+
+determine_servers()
+{
+    local cmd=${1}
+    local num_servers=0
+    local tmp_ifs=${IFS}
+    local ha_servers=""
+
+    if [ "${cmd}X" != "setupX" -a "${cmd}X" != "statusX" ]; then
+        ha_servers=$(pcs status | grep "Online:" | grep -o '\[.*\]' | sed -e 's/\[//' | sed -e 's/\]//')
+        IFS=$' '
+        for server in ${ha_servers} ; do
+            num_servers=$(expr ${num_servers} + 1)
+        done
+        IFS=${tmp_ifs}
+        HA_NUM_SERVERS=${num_servers}
+        HA_SERVERS="${ha_servers}"
+    else
+        IFS=$','
+        for server in ${HA_CLUSTER_NODES} ; do
+            num_servers=$(expr ${num_servers} + 1)
+        done
+        IFS=${tmp_ifs}
+        HA_NUM_SERVERS=${num_servers}
+        HA_SERVERS="${HA_CLUSTER_NODES//,/ }"
+    fi
+}
+
+stop_ganesha_all()
+{
+    local serverlist=${1}
+    for node in ${serverlist} ; do
+        manage_service "stop" ${node}
+    done
+}
+
+setup_cluster()
+{
+    local name=${1}
+    local num_servers=${2}
+    local servers=${3}
+    local unclean=""
+    local quorum_policy="stop"
+
+    logger "setting up cluster ${name} with the following ${servers}"
+
+    # pcs cluster setup --force ${PCS9OR10_PCS_CNAME_OPTION} ${name} ${servers}
+    pcs cluster setup --force ${PCS9OR10_PCS_CNAME_OPTION} ${name} --enable ${servers}
+    if [ $? -ne 0 ]; then
+        logger "pcs cluster setup ${PCS9OR10_PCS_CNAME_OPTION} ${name} --enable ${servers} failed, shutting down ganesha and bailing out"
+        #set up failed stop all ganesha process and clean up symlinks in cluster
+        stop_ganesha_all "${servers}"
+        exit 1;
+    fi
+
+    # pcs cluster auth ${servers}
+    pcs cluster auth
+    if [ $? -ne 0 ]; then
+        logger "pcs cluster auth failed"
+    fi
+
+    pcs cluster start --all
+    if [ $? -ne 0 ]; then
+        logger "pcs cluster start failed"
+        exit 1;
+    fi
+
+    sleep 1
+    # wait for the cluster to elect a DC before querying or writing
+    # to the CIB. BZ 1334092
+    crmadmin --dc_lookup --timeout=5000 > /dev/null 2>&1
+    while [ $? -ne 0 ]; do
+        crmadmin --dc_lookup --timeout=5000 > /dev/null 2>&1
+    done
+
+    unclean=$(pcs status | grep -u "UNCLEAN")
+    while [[ "${unclean}X" == "UNCLEANX" ]]; do
+         sleep 1
+         unclean=$(pcs status | grep -u "UNCLEAN")
+    done
+    sleep 1
+
+    if [ ${num_servers} -lt 3 ]; then
+        quorum_policy="ignore"
+    fi
+    pcs property set no-quorum-policy=${quorum_policy}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs property set no-quorum-policy=${quorum_policy} failed"
+    fi
+
+    pcs property set stonith-enabled=false
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs property set stonith-enabled=false failed"
+    fi
+}
+
+
+setup_finalize_ha()
+{
+    local cibfile=${1}
+    local stopped=""
+
+    stopped=$(pcs status | grep -u "Stopped")
+    while [[ "${stopped}X" == "StoppedX" ]]; do
+         sleep 1
+         stopped=$(pcs status | grep -u "Stopped")
+    done
+}
+
+
+refresh_config ()
+{
+        local short_host=$(hostname -s)
+        local VOL=${1}
+        local HA_CONFDIR=${2}
+        local short_host=$(hostname -s)
+
+        local export_id=$(grep ^[[:space:]]*Export_Id $HA_CONFDIR/exports/export.$VOL.conf |\
+                          awk -F"[=,;]" '{print $2}' | tr -d '[[:space:]]')
+
+
+        if [ -e ${SECRET_PEM} ]; then
+        while [[ ${3} ]]; do
+            current_host=`echo ${3} | cut -d "." -f 1`
+            if [[ ${short_host} != ${current_host} ]]; then
+                output=$(ssh -oPasswordAuthentication=no \
+-oStrictHostKeyChecking=no -i ${SECRET_PEM} root@${current_host} \
+"dbus-send --print-reply --system --dest=org.ganesha.nfsd \
+/org/ganesha/nfsd/ExportMgr org.ganesha.nfsd.exportmgr.UpdateExport \
+string:$HA_CONFDIR/exports/export.$VOL.conf \
+string:\"EXPORT(Export_Id=$export_id)\" 2>&1")
+                ret=$?
+                logger <<< "${output}"
+                if [ ${ret} -ne 0 ]; then
+                        echo "Refresh-config failed on ${current_host}. Please check logs on ${current_host}"
+                else
+                        echo "Refresh-config completed on ${current_host}."
+                fi
+
+          fi
+          shift
+        done
+    else
+        echo "Error: refresh-config failed. Passwordless ssh is not enabled."
+        exit 1
+    fi
+
+    # Run the same command on the localhost,
+        output=$(dbus-send --print-reply --system --dest=org.ganesha.nfsd \
+/org/ganesha/nfsd/ExportMgr org.ganesha.nfsd.exportmgr.UpdateExport \
+string:$HA_CONFDIR/exports/export.$VOL.conf \
+string:"EXPORT(Export_Id=$export_id)" 2>&1)
+        ret=$?
+        logger <<< "${output}"
+        if [ ${ret} -ne 0 ] ; then
+                echo "Refresh-config failed on localhost."
+        else
+                echo "Success: refresh-config completed."
+        fi
+}
+
+
+teardown_cluster()
+{
+    local name=${1}
+
+    for server in ${HA_SERVERS} ; do
+        if [[ ${HA_CLUSTER_NODES} != *${server}* ]]; then
+            logger "info: ${server} is not in config, removing"
+
+            pcs cluster stop ${server} --force
+            if [ $? -ne 0 ]; then
+                logger "warning: pcs cluster stop ${server} failed"
+            fi
+
+            pcs cluster node remove ${server}
+            if [ $? -ne 0 ]; then
+                logger "warning: pcs cluster node remove ${server} failed"
+            fi
+        fi
+    done
+
+    # BZ 1193433 - pcs doesn't reload cluster.conf after modification
+    # after teardown completes, a subsequent setup will appear to have
+    # 'remembered' the deleted node. You can work around this by
+    # issuing another `pcs cluster node remove $node`,
+    # `crm_node -f -R $server`, or
+    # `cibadmin --delete --xml-text '<node id="$server"
+    # uname="$server"/>'
+
+    pcs cluster stop --all
+    if [ $? -ne 0 ]; then
+        logger "warning pcs cluster stop --all failed"
+    fi
+
+    pcs cluster destroy
+    if [ $? -ne 0 ]; then
+        logger "error pcs cluster destroy failed"
+        exit 1
+    fi
+}
+
+
+cleanup_ganesha_config ()
+{
+    rm -f /etc/corosync/corosync.conf
+    rm -rf /etc/cluster/cluster.conf*
+    rm -rf /var/lib/pacemaker/cib/*
+    sed -r -i -e '/^%include[[:space:]]+".+\.conf"$/d'  $HA_CONFDIR/ganesha.conf
+}
+
+do_create_virt_ip_constraints()
+{
+    local cibfile=${1}; shift
+    local primary=${1}; shift
+    local weight="1000"
+
+    # first a constraint location rule that says the VIP must be where
+    # there's a ganesha.nfsd running
+    pcs -f ${cibfile} constraint location ${primary}-group rule score=-INFINITY ganesha-active ne 1
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs constraint location ${primary}-group rule score=-INFINITY ganesha-active ne 1 failed"
+    fi
+
+    # then a set of constraint location prefers to set the prefered order
+    # for where a VIP should move
+    while [[ ${1} ]]; do
+        pcs -f ${cibfile} constraint location ${primary}-group prefers ${1}=${weight}
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs constraint location ${primary}-group prefers ${1}=${weight} failed"
+        fi
+        weight=$(expr ${weight} + 1000)
+        shift
+    done
+    # and finally set the highest preference for the VIP to its home node
+    # default weight when created is/was 100.
+    # on Fedora setting appears to be additive, so to get the desired
+    # value we adjust the weight
+    # weight=$(expr ${weight} - 100)
+    pcs -f ${cibfile} constraint location ${primary}-group prefers ${primary}=${weight}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs constraint location ${primary}-group prefers ${primary}=${weight} failed"
+    fi
+}
+
+
+wrap_create_virt_ip_constraints()
+{
+    local cibfile=${1}; shift
+    local primary=${1}; shift
+    local head=""
+    local tail=""
+
+    # build a list of peers, e.g. for a four node cluster, for node1,
+    # the result is "node2 node3 node4"; for node2, "node3 node4 node1"
+    # and so on.
+    while [[ ${1} ]]; do
+        if [[ ${1} == ${primary} ]]; then
+            shift
+            while [[ ${1} ]]; do
+                tail=${tail}" "${1}
+                shift
+            done
+        else
+            head=${head}" "${1}
+        fi
+        shift
+    done
+    do_create_virt_ip_constraints ${cibfile} ${primary} ${tail} ${head}
+}
+
+
+create_virt_ip_constraints()
+{
+    local cibfile=${1}; shift
+
+    while [[ ${1} ]]; do
+        wrap_create_virt_ip_constraints ${cibfile} ${1} ${HA_SERVERS}
+        shift
+    done
+}
+
+
+setup_create_resources()
+{
+    local cibfile=$(mktemp -u)
+
+    # fixup /var/lib/nfs
+    logger "pcs resource create nfs_setup ocf:heartbeat:ganesha_nfsd ha_vol_mnt=${HA_VOL_MNT} ${PCS9OR10_PCS_CLONE_OPTION}"
+    pcs resource create nfs_setup ocf:heartbeat:ganesha_nfsd ha_vol_mnt=${HA_VOL_MNT} ${PCS9OR10_PCS_CLONE_OPTION}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource create nfs_setup ocf:heartbeat:ganesha_nfsd ha_vol_mnt=${HA_VOL_MNT} ${PCS9OR10_PCS_CLONE_OPTION} failed"
+    fi
+
+    pcs resource create nfs-mon ocf:heartbeat:ganesha_mon ${PCS9OR10_PCS_CLONE_OPTION}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource create nfs-mon ocf:heartbeat:ganesha_mon ${PCS9OR10_PCS_CLONE_OPTION} failed"
+    fi
+
+    # see comment in (/usr/lib/ocf/resource.d/heartbeat/ganesha_grace
+    # start method. Allow time for ganesha_mon to start and set the
+    # ganesha-active crm_attribute
+    sleep 5
+
+    pcs resource create nfs-grace ocf:heartbeat:ganesha_grace ${PCS9OR10_PCS_CLONE_OPTION} notify=true
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource create nfs-grace ocf:heartbeat:ganesha_grace ${PCS9OR10_PCS_CLONE_OPTION} failed"
+    fi
+
+    pcs constraint location nfs-grace-clone rule score=-INFINITY grace-active ne 1
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs constraint location nfs-grace-clone rule score=-INFINITY grace-active ne 1"
+    fi
+
+    pcs cluster cib ${cibfile}
+
+    while [[ ${1} ]]; do
+
+        # this is variable indirection
+        # from a nvs like 'VIP_host1=10.7.6.5' or 'VIP_host1="10.7.6.5"'
+        # (or VIP_host-1=..., or VIP_host-1.my.domain.name=...)
+        # a variable 'clean_name' is created (e.g. w/ value 'VIP_host_1')
+        # and a clean nvs (e.g. w/ value 'VIP_host_1="10_7_6_5"')
+        # after the `eval ${clean_nvs}` there is a variable VIP_host_1
+        # with the value '10_7_6_5', and the following \$$ magic to
+        # reference it, i.e. `eval tmp_ipaddr=\$${clean_name}` gives us
+        # ${tmp_ipaddr} with 10_7_6_5 and then convert the _s back to .s
+        # to give us ipaddr="10.7.6.5". whew!
+        name="VIP_${1}"
+        clean_name=${name//[-.]/_}
+        nvs=$(grep "^${name}=" ${HA_CONFDIR}/ganesha-ha.conf)
+        clean_nvs=${nvs//[-.]/_}
+        eval ${clean_nvs}
+        eval tmp_ipaddr=\$${clean_name}
+        ipaddr=${tmp_ipaddr//_/.}
+
+        pcs -f ${cibfile} resource create ${1}-nfs_block ocf:heartbeat:portblock protocol=tcp \
+        portno=2049 action=block ip=${ipaddr} --group ${1}-group
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-nfs_block failed"
+        fi
+        pcs -f ${cibfile} resource create ${1}-cluster_ip-1 ocf:heartbeat:IPaddr ip=${ipaddr} \
+        cidr_netmask=32 op monitor interval=15s --group ${1}-group --after ${1}-nfs_block
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-cluster_ip-1 ocf:heartbeat:IPaddr ip=${ipaddr} \
+            cidr_netmask=32 op monitor interval=15s failed"
+        fi
+
+        pcs -f ${cibfile} constraint order nfs-grace-clone then ${1}-cluster_ip-1
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs constraint order nfs-grace-clone then ${1}-cluster_ip-1 failed"
+        fi
+
+        pcs -f ${cibfile} resource create ${1}-nfs_unblock ocf:heartbeat:portblock protocol=tcp \
+        portno=2049 action=unblock ip=${ipaddr} reset_local_on_unblock_stop=true \
+        tickle_dir=${HA_VOL_MNT}/nfs-ganesha/tickle_dir/ --group ${1}-group --after ${1}-cluster_ip-1 \
+        op stop timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} op start timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} \
+        op monitor interval=10s timeout=${PORTBLOCK_UNBLOCK_TIMEOUT}
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-nfs_unblock failed"
+        fi
+
+
+        shift
+    done
+
+    create_virt_ip_constraints ${cibfile} ${HA_SERVERS}
+
+    pcs cluster cib-push ${cibfile}
+    if [ $? -ne 0 ]; then
+        logger "warning pcs cluster cib-push ${cibfile} failed"
+    fi
+    rm -f ${cibfile}
+}
+
+
+teardown_resources()
+{
+    # local mntpt=$(grep ha-vol-mnt ${HA_CONFIG_FILE} | cut -d = -f 2)
+
+    # restore /var/lib/nfs
+    logger "notice: pcs resource delete nfs_setup-clone"
+    pcs resource delete nfs_setup-clone
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource delete nfs_setup-clone failed"
+    fi
+
+    # delete -clone resource agents
+    # in particular delete the ganesha monitor so we don't try to
+    # trigger anything when we shut down ganesha next.
+    pcs resource delete nfs-mon-clone
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource delete nfs-mon-clone failed"
+    fi
+
+    pcs resource delete nfs-grace-clone
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs resource delete nfs-grace-clone failed"
+    fi
+
+    while [[ ${1} ]]; do
+        pcs resource delete ${1}-group
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs resource delete ${1}-group failed"
+        fi
+        shift
+    done
+
+}
+
+
+recreate_resources()
+{
+    local cibfile=${1}; shift
+
+    while [[ ${1} ]]; do
+        # this is variable indirection
+        # see the comment on the same a few lines up
+        name="VIP_${1}"
+        clean_name=${name//[-.]/_}
+        nvs=$(grep "^${name}=" ${HA_CONFDIR}/ganesha-ha.conf)
+        clean_nvs=${nvs//[-.]/_}
+        eval ${clean_nvs}
+        eval tmp_ipaddr=\$${clean_name}
+        ipaddr=${tmp_ipaddr//_/.}
+
+        pcs -f ${cibfile} resource create ${1}-nfs_block ocf:heartbeat:portblock protocol=tcp \
+        portno=2049 action=block ip=${ipaddr} --group ${1}-group
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-nfs_block failed"
+        fi
+        pcs -f ${cibfile} resource create ${1}-cluster_ip-1 ocf:heartbeat:IPaddr ip=${ipaddr} \
+        cidr_netmask=32 op monitor interval=15s --group ${1}-group --after ${1}-nfs_block
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-cluster_ip-1 ocf:heartbeat:IPaddr ip=${ipaddr} \
+            cidr_netmask=32 op monitor interval=15s failed"
+        fi
+
+        pcs -f ${cibfile} constraint order nfs-grace-clone then ${1}-cluster_ip-1
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs constraint order nfs-grace-clone then ${1}-cluster_ip-1 failed"
+        fi
+
+        pcs -f ${cibfile} resource create ${1}-nfs_unblock ocf:heartbeat:portblock protocol=tcp \
+        portno=2049 action=unblock ip=${ipaddr} reset_local_on_unblock_stop=true \
+        tickle_dir=${HA_VOL_MNT}/nfs-ganesha/tickle_dir/ --group ${1}-group --after ${1}-cluster_ip-1 \
+        op stop timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} op start timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} \
+        op monitor interval=10s timeout=${PORTBLOCK_UNBLOCK_TIMEOUT}
+        if [ $? -ne 0 ]; then
+            logger "warning pcs resource create ${1}-nfs_unblock failed"
+        fi
+
+        shift
+    done
+}
+
+
+addnode_recreate_resources()
+{
+    local cibfile=${1}; shift
+    local add_node=${1}; shift
+    local add_vip=${1}; shift
+
+    recreate_resources ${cibfile} ${HA_SERVERS}
+
+    pcs -f ${cibfile} resource create ${add_node}-nfs_block ocf:heartbeat:portblock \
+    protocol=tcp portno=2049 action=block ip=${add_vip} --group ${add_node}-group
+    if [ $? -ne 0 ]; then
+        logger "warning pcs resource create ${add_node}-nfs_block failed"
+    fi
+    pcs -f ${cibfile} resource create ${add_node}-cluster_ip-1 ocf:heartbeat:IPaddr \
+    ip=${add_vip} cidr_netmask=32 op monitor interval=15s --group ${add_node}-group \
+    --after ${add_node}-nfs_block
+    if [ $? -ne 0 ]; then
+        logger "warning pcs resource create ${add_node}-cluster_ip-1 ocf:heartbeat:IPaddr \
+        ip=${add_vip} cidr_netmask=32 op monitor interval=15s failed"
+    fi
+
+    pcs -f ${cibfile} constraint order nfs-grace-clone then ${add_node}-cluster_ip-1
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs constraint order nfs-grace-clone then ${add_node}-cluster_ip-1 failed"
+    fi
+    pcs -f ${cibfile} resource create ${add_node}-nfs_unblock ocf:heartbeat:portblock \
+    protocol=tcp portno=2049 action=unblock ip=${add_vip} reset_local_on_unblock_stop=true \
+    tickle_dir=${HA_VOL_MNT}/nfs-ganesha/tickle_dir/ --group ${add_node}-group --after \
+    ${add_node}-cluster_ip-1 op stop timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} op start \
+    timeout=${PORTBLOCK_UNBLOCK_TIMEOUT} op monitor interval=10s \
+    timeout=${PORTBLOCK_UNBLOCK_TIMEOUT}
+    if [ $? -ne 0 ]; then
+        logger "warning pcs resource create ${add_node}-nfs_unblock failed"
+    fi
+}
+
+
+clear_resources()
+{
+    local cibfile=${1}; shift
+
+    while [[ ${1} ]]; do
+        pcs -f ${cibfile} resource delete ${1}-group
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs -f ${cibfile} resource delete ${1}-group"
+        fi
+
+        shift
+    done
+}
+
+
+addnode_create_resources()
+{
+    local add_node=${1}; shift
+    local add_vip=${1}; shift
+    local cibfile=$(mktemp -u)
+
+    # start HA on the new node
+    pcs cluster start ${add_node}
+    if [ $? -ne 0 ]; then
+       logger "warning: pcs cluster start ${add_node} failed"
+    fi
+
+    pcs cluster cib ${cibfile}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs cluster cib ${cibfile} failed"
+    fi
+
+    # delete all the -cluster_ip-1 resources, clearing
+    # their constraints, then create them again so we can
+    # recompute their constraints
+    clear_resources ${cibfile} ${HA_SERVERS}
+    addnode_recreate_resources ${cibfile} ${add_node} ${add_vip}
+
+    HA_SERVERS="${HA_SERVERS} ${add_node}"
+    create_virt_ip_constraints ${cibfile} ${HA_SERVERS}
+
+    pcs cluster cib-push ${cibfile}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs cluster cib-push ${cibfile} failed"
+    fi
+    rm -f ${cibfile}
+}
+
+
+deletenode_delete_resources()
+{
+    local node=${1}; shift
+    local ha_servers=$(echo "${HA_SERVERS}" | sed s/${node}//)
+    local cibfile=$(mktemp -u)
+
+    pcs cluster cib ${cibfile}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs cluster cib ${cibfile} failed"
+    fi
+
+    # delete all the -cluster_ip-1 and -trigger_ip-1 resources,
+    # clearing their constraints, then create them again so we can
+    # recompute their constraints
+    clear_resources ${cibfile} ${HA_SERVERS}
+    recreate_resources ${cibfile} ${ha_servers}
+    HA_SERVERS=$(echo "${ha_servers}" | sed -e "s/  / /")
+
+    create_virt_ip_constraints ${cibfile} ${HA_SERVERS}
+
+    pcs cluster cib-push ${cibfile}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs cluster cib-push ${cibfile} failed"
+    fi
+    rm -f ${cibfile}
+
+}
+
+
+deletenode_update_haconfig()
+{
+    local name="VIP_${1}"
+    local clean_name=${name//[-.]/_}
+
+    ha_servers=$(echo ${HA_SERVERS} | sed -e "s/ /,/")
+    sed -i -e "s/^HA_CLUSTER_NODES=.*$/HA_CLUSTER_NODES=\"${ha_servers// /,}\"/" -e "s/^${name}=.*$//" -e "/^$/d" ${HA_CONFDIR}/ganesha-ha.conf
+}
+
+
+setup_state_volume()
+{
+    local mnt=${HA_VOL_MNT}
+    local longname=""
+    local shortname=""
+    local dname=""
+    local dirname=""
+
+    longname=$(hostname)
+    dname=${longname#$(hostname -s)}
+
+    while [[ ${1} ]]; do
+
+        if [[ ${1} == *${dname} ]]; then
+            dirname=${1}
+        else
+            dirname=${1}${dname}
+        fi
+
+        if [ ! -d ${mnt}/nfs-ganesha/tickle_dir ]; then
+            mkdir ${mnt}/nfs-ganesha/tickle_dir
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname} ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd
+            chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd
+        fi
+        if [ ! -e ${mnt}/nfs-ganesha/${dirname}/nfs/state ]; then
+            touch ${mnt}/nfs-ganesha/${dirname}/nfs/state
+            chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/state
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4recov ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4recov
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4old ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4old
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm
+            chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm
+        fi
+        if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak ]; then
+            mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak
+            chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak
+        fi
+        if [ ! -e ${mnt}/nfs-ganesha/${dirname}/nfs/statd/state ]; then
+            touch ${mnt}/nfs-ganesha/${dirname}/nfs/statd/state
+        fi
+        for server in ${HA_SERVERS} ; do
+            if [[ ${server} != ${dirname} ]]; then
+                ln -s ${mnt}/nfs-ganesha/${server}/nfs/ganesha ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/${server}
+                ln -s ${mnt}/nfs-ganesha/${server}/nfs/statd ${mnt}/nfs-ganesha/${dirname}/nfs/statd/${server}
+            fi
+        done
+        shift
+    done
+
+}
+
+
+enable_pacemaker()
+{
+    while [[ ${1} ]]; do
+        if [[ "${SERVICE_MAN}" == "/bin/systemctl" ]]; then
+            ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i \
+${SECRET_PEM} root@${1} "${SERVICE_MAN} enable pacemaker"
+        else
+            ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i \
+${SECRET_PEM} root@${1} "${SERVICE_MAN} pacemaker enable"
+        fi
+        shift
+    done
+}
+
+
+addnode_state_volume()
+{
+    local newnode=${1}; shift
+    local mnt=${HA_VOL_MNT}
+    local longname=""
+    local dname=""
+    local dirname=""
+
+    longname=$(hostname)
+    dname=${longname#$(hostname -s)}
+
+    if [[ ${newnode} == *${dname} ]]; then
+        dirname=${newnode}
+    else
+        dirname=${newnode}${dname}
+    fi
+
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname} ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd
+        chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd
+    fi
+    if [ ! -e ${mnt}/nfs-ganesha/${dirname}/nfs/state ]; then
+        touch ${mnt}/nfs-ganesha/${dirname}/nfs/state
+        chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/state
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4recov ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4recov
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4old ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/v4old
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm
+        chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm
+    fi
+    if [ ! -d ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak ]; then
+        mkdir ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak
+        chown rpcuser:rpcuser ${mnt}/nfs-ganesha/${dirname}/nfs/statd/sm.bak
+    fi
+    if [ ! -e ${mnt}/nfs-ganesha/${dirname}/nfs/statd/state ]; then
+        touch ${mnt}/nfs-ganesha/${dirname}/nfs/statd/state
+    fi
+
+    for server in ${HA_SERVERS} ; do
+
+        if [[ ${server} != ${dirname} ]]; then
+            ln -s ${mnt}/nfs-ganesha/${server}/nfs/ganesha ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha/${server}
+            ln -s ${mnt}/nfs-ganesha/${server}/nfs/statd ${mnt}/nfs-ganesha/${dirname}/nfs/statd/${server}
+
+            ln -s ${mnt}/nfs-ganesha/${dirname}/nfs/ganesha ${mnt}/nfs-ganesha/${server}/nfs/ganesha/${dirname}
+            ln -s ${mnt}/nfs-ganesha/${dirname}/nfs/statd ${mnt}/nfs-ganesha/${server}/nfs/statd/${dirname}
+        fi
+    done
+
+}
+
+
+delnode_state_volume()
+{
+    local delnode=${1}; shift
+    local mnt=${HA_VOL_MNT}
+    local longname=""
+    local dname=""
+    local dirname=""
+
+    longname=$(hostname)
+    dname=${longname#$(hostname -s)}
+
+    if [[ ${delnode} == *${dname} ]]; then
+        dirname=${delnode}
+    else
+        dirname=${delnode}${dname}
+    fi
+
+    rm -rf ${mnt}/nfs-ganesha/${dirname}
+
+    for server in ${HA_SERVERS} ; do
+        if [[ ${server} != ${dirname} ]]; then
+            rm -f ${mnt}/nfs-ganesha/${server}/nfs/ganesha/${dirname}
+            rm -f ${mnt}/nfs-ganesha/${server}/nfs/statd/${dirname}
+        fi
+    done
+}
+
+
+status()
+{
+    local scratch=$(mktemp)
+    local regex_str="^${1}-cluster_ip-1"
+    local healthy=0
+    local index=1
+    local nodes
+
+    # change tabs to spaces, strip leading spaces, including any 
+    # new '*' at the beginning of a line introduced in pcs-0.10.x
+    pcs status | sed -e "s/\t/ /g" -e "s/^[ ]*\*//" -e "s/^[ ]*//" > ${scratch}
+
+    nodes[0]=${1}; shift
+
+    # make a regex of the configured nodes
+    # and initalize the nodes array for later
+    while [[ ${1} ]]; do
+
+        regex_str="${regex_str}|^${1}-cluster_ip-1"
+        nodes[${index}]=${1}
+        ((index++))
+        shift
+    done
+
+    # print the nodes that are expected to be online
+    grep -E "Online:" ${scratch}
+
+    echo
+
+    # print the VIPs and which node they are on
+    grep -E "${regex_str}" < ${scratch} | cut -d ' ' -f 1,4
+
+    echo
+
+    # check if the VIP and port block/unblock RAs are on the expected nodes
+    for n in ${nodes[*]}; do
+
+        grep -E -x "${n}-nfs_block \(ocf::heartbeat:portblock\): Started ${n}" > /dev/null 2>&1 ${scratch}
+        result=$?
+        ((healthy+=${result}))
+        grep -E -x "${n}-cluster_ip-1 \(ocf::heartbeat:IPaddr\): Started ${n}" > /dev/null 2>&1 ${scratch}
+        result=$?
+        ((healthy+=${result}))
+        grep -E -x "${n}-nfs_unblock \(ocf::heartbeat:portblock\): Started ${n}" > /dev/null 2>&1 ${scratch}
+        result=$?
+        ((healthy+=${result}))
+    done
+
+    grep -E "\):\ Stopped|FAILED" > /dev/null 2>&1 ${scratch}
+    result=$?
+
+    if [ ${result} -eq 0 ]; then
+        echo "Cluster HA Status: BAD"
+    elif [ ${healthy} -eq 0 ]; then
+        echo "Cluster HA Status: HEALTHY"
+    else
+        echo "Cluster HA Status: FAILOVER"
+    fi
+
+    rm -f ${scratch}
+}
+
+create_ganesha_conf_file()
+{
+        if [[ "$1" == "yes" ]];
+        then
+                if [  -e $GANESHA_CONF ];
+                then
+                        rm -rf $GANESHA_CONF
+                fi
+        # The symlink /etc/ganesha/ganesha.conf need to be
+        # created using ganesha conf file mentioned in the
+        # shared storage. Every node will only have this
+        # link and actual file will stored in shared storage,
+        # so that ganesha conf editing of ganesha conf will
+        # be easy as well as it become more consistent.
+
+                ln -s $HA_CONFDIR/ganesha.conf $GANESHA_CONF
+        else
+        # Restoring previous file
+                rm -rf $GANESHA_CONF
+                cp $HA_CONFDIR/ganesha.conf $GANESHA_CONF
+                sed -r -i -e '/^%include[[:space:]]+".+\.conf"$/d' $GANESHA_CONF
+        fi
+}
+
+set_quorum_policy()
+{
+    local quorum_policy="stop"
+    local num_servers=${1}
+
+    if [ ${num_servers} -lt 3 ]; then
+        quorum_policy="ignore"
+    fi
+    pcs property set no-quorum-policy=${quorum_policy}
+    if [ $? -ne 0 ]; then
+        logger "warning: pcs property set no-quorum-policy=${quorum_policy} failed"
+    fi
+}
+
+main()
+{
+
+    local cmd=${1}; shift
+    if [[ ${cmd} == *help ]]; then
+        usage
+        exit 0
+    fi
+
+    if (selinuxenabled) ;then
+     semanage boolean -m gluster_use_execmem --on
+    fi
+
+    local osid=""
+
+    osid=$(grep ^ID= /etc/os-release)
+    eval $(echo ${osid} | grep -F ID=)
+    osid=$(grep ^VERSION_ID= /etc/os-release)
+    eval $(echo ${osid} | grep -F VERSION_ID=)
+
+    HA_CONFDIR=${1%/}; shift
+    local ha_conf=${HA_CONFDIR}/ganesha-ha.conf
+    local node=""
+    local vip=""
+
+    # ignore any comment lines
+    cfgline=$(grep  ^HA_NAME= ${ha_conf})
+    eval $(echo ${cfgline} | grep -F HA_NAME=)
+    cfgline=$(grep  ^HA_CLUSTER_NODES= ${ha_conf})
+    eval $(echo ${cfgline} | grep -F HA_CLUSTER_NODES=)
+
+    case "${cmd}" in
+
+    setup | --setup)
+        logger "setting up ${HA_NAME}"
+
+        check_cluster_exists ${HA_NAME}
+
+        determine_servers "setup"
+
+        # Fedora 29+ and rhel/centos 8 has PCS-0.10.x
+        # default is pcs-0.10.x options but check for
+        # rhel/centos 7 (pcs-0.9.x) and adjust accordingly
+        if [[ ! ${ID} =~ {rhel,centos} ]]; then
+            if [[ ${VERSION_ID} == 7.* ]]; then
+                PCS9OR10_PCS_CNAME_OPTION="--name"
+                PCS9OR10_PCS_CLONE_OPTION="--clone"
+            fi
+        fi
+
+        if [[ "${HA_NUM_SERVERS}X" != "1X" ]]; then
+
+            determine_service_manager
+
+            setup_cluster ${HA_NAME} ${HA_NUM_SERVERS} "${HA_SERVERS}"
+
+            setup_create_resources ${HA_SERVERS}
+
+            setup_finalize_ha
+
+            setup_state_volume ${HA_SERVERS}
+
+            enable_pacemaker ${HA_SERVERS}
+
+        else
+
+            logger "insufficient servers for HA, aborting"
+        fi
+        ;;
+
+    teardown | --teardown)
+        logger "tearing down ${HA_NAME}"
+
+        determine_servers "teardown"
+
+        teardown_resources ${HA_SERVERS}
+
+        teardown_cluster ${HA_NAME}
+
+        cleanup_ganesha_config ${HA_CONFDIR}
+        ;;
+
+    cleanup | --cleanup)
+        cleanup_ganesha_config ${HA_CONFDIR}
+        ;;
+
+    add | --add)
+        node=${1}; shift
+        vip=${1}; shift
+
+        logger "adding ${node} with ${vip} to ${HA_NAME}"
+
+        determine_service_manager
+
+        manage_service "start" ${node}
+
+        determine_servers "add"
+
+        pcs cluster node add ${node}
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs cluster node add ${node} failed"
+        fi
+
+        addnode_create_resources ${node} ${vip}
+        # Subsequent add-node recreates resources for all the nodes
+        # that already exist in the cluster. The nodes are picked up
+        # from the entries in the ganesha-ha.conf file. Adding the
+        # newly added node to the file so that the resources specfic
+        # to this node is correctly recreated in the future.
+        clean_node=${node//[-.]/_}
+        echo "VIP_${node}=\"${vip}\"" >> ${HA_CONFDIR}/ganesha-ha.conf
+
+        NEW_NODES="$HA_CLUSTER_NODES,${node}"
+
+        sed -i s/HA_CLUSTER_NODES.*/"HA_CLUSTER_NODES=\"$NEW_NODES\""/ \
+$HA_CONFDIR/ganesha-ha.conf
+
+        addnode_state_volume ${node}
+
+        # addnode_create_resources() already appended ${node} to
+        # HA_SERVERS, so only need to increment HA_NUM_SERVERS
+        # and set quorum policy
+        HA_NUM_SERVERS=$(expr ${HA_NUM_SERVERS} + 1)
+        set_quorum_policy ${HA_NUM_SERVERS}
+        ;;
+
+    delete | --delete)
+        node=${1}; shift
+
+        logger "deleting ${node} from ${HA_NAME}"
+
+        determine_servers "delete"
+
+        deletenode_delete_resources ${node}
+
+        pcs cluster node remove ${node}
+        if [ $? -ne 0 ]; then
+            logger "warning: pcs cluster node remove ${node} failed"
+        fi
+
+        deletenode_update_haconfig ${node}
+
+        delnode_state_volume ${node}
+
+        determine_service_manager
+
+        manage_service "stop" ${node}
+
+        HA_NUM_SERVERS=$(expr ${HA_NUM_SERVERS} - 1)
+        set_quorum_policy ${HA_NUM_SERVERS}
+        ;;
+
+    status | --status)
+        determine_servers "status"
+
+        status ${HA_SERVERS}
+        ;;
+
+    refresh-config | --refresh-config)
+        VOL=${1}
+
+        determine_servers "refresh-config"
+
+        refresh_config ${VOL} ${HA_CONFDIR} ${HA_SERVERS}
+        ;;
+
+    setup-ganesha-conf-files | --setup-ganesha-conf-files)
+
+        create_ganesha_conf_file ${1}
+        ;;
+
+    *)
+        # setup and teardown are not intended to be used by a
+        # casual user
+        usage
+        logger "Usage: ganesha-ha.sh add|delete|status"
+        ;;
+
+    esac
+
+    if (selinuxenabled) ;then
+     semanage boolean -m gluster_use_execmem --off
+    fi
+}
+
+main $*
diff --git a/extras/ganesha/scripts/generate-epoch.py b/extras/ganesha/scripts/generate-epoch.py
new file mode 100755
index 00000000000..77af014bab9
--- /dev/null
+++ b/extras/ganesha/scripts/generate-epoch.py
@@ -0,0 +1,48 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+# This file is part of GlusterFS.
+#
+# This file is licensed to you under your choice of the GNU Lesser
+# General Public License, version 3 or any later version (LGPLv3 or
+# later), or the GNU General Public License, version 2 (GPLv2), in all
+# cases as published by the Free Software Foundation.
+#
+# Generates unique epoch value on each gluster node to be used by
+# nfs-ganesha service on that node.
+#
+# Configure 'EPOCH_EXEC' option to this script path in
+# '/etc/sysconfig/ganesha' file used by nfs-ganesha service.
+#
+# Construct epoch as follows -
+#        first 32-bit contains the now() time
+#        rest 32-bit value contains the local glusterd node uuid
+
+import time
+import binascii
+
+# Calculate the now() time into a 64-bit integer value
+def epoch_now():
+        epoch_time = int(time.mktime(time.localtime())) << 32
+        return epoch_time
+
+# Read glusterd UUID and extract first 32-bit of it
+def epoch_uuid():
+        file_name = '/var/lib/glusterd/glusterd.info'
+
+        for line in open(file_name):
+                if "UUID" in line:
+                        glusterd_uuid = line.split('=')[1].strip()
+
+        uuid_bin = binascii.unhexlify(glusterd_uuid.replace("-",""))
+
+        epoch_uuid = int(binascii.hexlify(uuid_bin), 32) & 0xFFFF0000
+        return epoch_uuid
+
+# Construct epoch as follows -
+#        first 32-bit contains the now() time
+#        rest 32-bit value contains the local glusterd node uuid
+epoch = (epoch_now() | epoch_uuid())
+print((str(epoch)))
+
+exit(0)
diff --git a/extras/geo-rep/Makefile.am b/extras/geo-rep/Makefile.am
index e4603ae80b8..09eff308ac4 100644
--- a/extras/geo-rep/Makefile.am
+++ b/extras/geo-rep/Makefile.am
@@ -1,4 +1,4 @@
-scriptsdir = $(datadir)/glusterfs/scripts
+scriptsdir = $(libexecdir)/glusterfs/scripts
 scripts_SCRIPTS =  gsync-upgrade.sh generate-gfid-file.sh get-gfid.sh \
 	slave-upgrade.sh schedule_georep.py
 
diff --git a/extras/geo-rep/gsync-sync-gfid.c b/extras/geo-rep/gsync-sync-gfid.c
index e9b9e633402..47dca0413e9 100644
--- a/extras/geo-rep/gsync-sync-gfid.c
+++ b/extras/geo-rep/gsync-sync-gfid.c
@@ -7,103 +7,103 @@
 #include <libgen.h>
 #include <ctype.h>
 #include <stdlib.h>
-#include "glusterfs.h"
-#include "syscall.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/syscall.h>
 
 #ifndef UUID_CANONICAL_FORM_LEN
 #define UUID_CANONICAL_FORM_LEN 36
 #endif
 
 #ifndef GF_FUSE_AUX_GFID_HEAL
-#define GF_FUSE_AUX_GFID_HEAL    "glusterfs.gfid.heal"
+#define GF_FUSE_AUX_GFID_HEAL "glusterfs.gfid.heal"
 #endif
 
-#define GLFS_LINE_MAX           (PATH_MAX + (2 * UUID_CANONICAL_FORM_LEN))
+#define GLFS_LINE_MAX (PATH_MAX + (2 * UUID_CANONICAL_FORM_LEN))
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char *file                = NULL;
-        char *tmp = NULL;
-        char *tmp1 = NULL;
-        char *parent_dir = NULL;
-        char *gfid                = NULL;
-        char *bname = NULL;
-        int   ret                 = -1;
-        int len = 0;
-        FILE *fp                  = NULL;
-        char  line[GLFS_LINE_MAX] = {0,};
-        char *path = NULL;
-        void  *blob               = NULL;
-        void  *tmp_blob               = NULL;
-
-        if (argc != 2) {
-                /* each line in the file has the following format
-                 * uuid-in-canonical-form path-relative-to-gluster-mount.
-                 * Both uuid and relative path are from master mount.
-                 */
-                fprintf (stderr, "usage: %s <file-of-paths-to-be-synced>\n",
-                         argv[0]);
-                goto out;
+    char *file = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *parent_dir = NULL;
+    char *gfid = NULL;
+    char *bname = NULL;
+    int ret = -1;
+    int len = 0;
+    FILE *fp = NULL;
+    char line[GLFS_LINE_MAX] = {
+        0,
+    };
+    char *path = NULL;
+    void *blob = NULL;
+    void *tmp_blob = NULL;
+
+    if (argc != 2) {
+        /* each line in the file has the following format
+         * uuid-in-canonical-form path-relative-to-gluster-mount.
+         * Both uuid and relative path are from master mount.
+         */
+        fprintf(stderr, "usage: %s <file-of-paths-to-be-synced>\n", argv[0]);
+        goto out;
+    }
+
+    file = argv[1];
+
+    fp = fopen(file, "r");
+    if (fp == NULL) {
+        fprintf(stderr, "cannot open %s for reading (%s)\n", file,
+                strerror(errno));
+        goto out;
+    }
+
+    while (fgets(line, GLFS_LINE_MAX, fp) != NULL) {
+        tmp = line;
+        path = gfid = line;
+
+        path += UUID_CANONICAL_FORM_LEN + 1;
+
+        while (isspace(*path))
+            path++;
+
+        len = strlen(line);
+        if ((len < GLFS_LINE_MAX) && (line[len - 1] == '\n'))
+            line[len - 1] = '\0';
+
+        line[UUID_CANONICAL_FORM_LEN] = '\0';
+
+        tmp = strdup(path);
+        tmp1 = strdup(path);
+        parent_dir = dirname(tmp);
+        bname = basename(tmp1);
+
+        /* gfid + '\0' + bname + '\0' */
+        len = UUID_CANONICAL_FORM_LEN + 1 + strlen(bname) + 1;
+
+        blob = malloc(len);
+
+        memcpy(blob, gfid, UUID_CANONICAL_FORM_LEN);
+
+        tmp_blob = blob + UUID_CANONICAL_FORM_LEN + 1;
+
+        memcpy(tmp_blob, bname, strlen(bname));
+
+        ret = sys_lsetxattr(parent_dir, GF_FUSE_AUX_GFID_HEAL, blob, len, 0);
+        if (ret < 0) {
+            fprintf(stderr, "setxattr on %s/%s failed (%s)\n", parent_dir,
+                    bname, strerror(errno));
         }
+        memset(line, 0, GLFS_LINE_MAX);
 
-        file = argv[1];
+        free(blob);
+        free(tmp);
+        free(tmp1);
+        blob = NULL;
+    }
 
-        fp = fopen (file, "r");
-        if (fp == NULL) {
-                fprintf (stderr, "cannot open %s for reading (%s)\n",
-                         file, strerror (errno));
-                goto out;
-        }
-
-        while (fgets (line, GLFS_LINE_MAX, fp) != NULL) {
-                tmp = line;
-                path = gfid = line;
-
-                path += UUID_CANONICAL_FORM_LEN + 1;
-
-                while(isspace (*path))
-                        path++;
-
-                if ((strlen (line) < GLFS_LINE_MAX) &&
-                    (line[strlen (line) - 1] == '\n'))
-                        line[strlen (line) - 1] = '\0';
-
-                line[UUID_CANONICAL_FORM_LEN] = '\0';
-
-                tmp = strdup (path);
-                tmp1 = strdup (path);
-                parent_dir = dirname (tmp);
-                bname = basename (tmp1);
-
-                /* gfid + '\0' + bname + '\0' */
-                len = UUID_CANONICAL_FORM_LEN + 1 + strlen (bname) + 1;
-
-                blob = calloc (1, len);
-
-                memcpy (blob, gfid, UUID_CANONICAL_FORM_LEN);
-
-                tmp_blob = blob + UUID_CANONICAL_FORM_LEN + 1;
-
-                memcpy (tmp_blob, bname, strlen (bname));
-
-                ret = sys_lsetxattr (parent_dir, GF_FUSE_AUX_GFID_HEAL, 
-                                blob, len, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "setxattr on %s/%s failed (%s)\n",
-                                 parent_dir, bname, strerror (errno));
-                }
-                memset (line, 0, GLFS_LINE_MAX);
-
-                free (blob);
-                free (tmp); free (tmp1);
-                blob = NULL;
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        if (fp)
-                fclose(fp);
-        return ret;
+    if (fp)
+        fclose(fp);
+    return ret;
 }
-
diff --git a/extras/geo-rep/schedule_georep.py.in b/extras/geo-rep/schedule_georep.py.in
index 1887fe7ba87..48b2b507060 100644
--- a/extras/geo-rep/schedule_georep.py.in
+++ b/extras/geo-rep/schedule_georep.py.in
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 """
 Schedule Geo-replication
 ------------------------
@@ -43,7 +43,7 @@ SESSION_MOUNT_LOG_FILE = ("/var/log/glusterfs/geo-replication"
                           "/schedule_georep.mount.log")
 
 USE_CLI_COLOR = True
-
+mnt_list = []
 
 class GlusterBadXmlFormat(Exception):
     """
@@ -83,13 +83,15 @@ def execute(cmd, success_msg="", failure_msg="", exitcode=-1):
     On success it can print message in stdout if specified.
     On failure, exits after writing to stderr.
     """
-    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
     out, err = p.communicate()
     if p.returncode == 0:
         if success_msg:
             output_ok(success_msg)
         return out
     else:
+        if exitcode == 0:
+            return
         err_msg = err if err else out
         output_notok(failure_msg, err=err_msg, exitcode=exitcode)
 
@@ -112,12 +114,12 @@ def cleanup(hostname, volname, mnt):
     """
     Unmount the Volume and Remove the temporary directory
     """
-    execute(["umount", mnt],
+    execute(["umount", "-l", mnt],
             failure_msg="Unable to Unmount Gluster Volume "
             "{0}:{1}(Mounted at {2})".format(hostname, volname, mnt))
     execute(["rmdir", mnt],
             failure_msg="Unable to Remove temp directory "
-            "{0}".format(mnt))
+            "{0}".format(mnt), exitcode=0)
 
 
 @contextmanager
@@ -130,6 +132,7 @@ def glustermount(hostname, volname):
     Automatically unmounts it in case of Exceptions/out of context
     """
     mnt = tempfile.mkdtemp(prefix="georepsetup_")
+    mnt_list.append(mnt)
     execute(["@SBIN_DIR@/glusterfs",
              "--volfile-server", hostname,
              "--volfile-id", volname,
@@ -297,6 +300,7 @@ def get_summary(mastervol, slave_url):
     status_data = get(mastervol, slave_url)
 
     for session in status_data:
+        session_name = ""
         summary = {
             "active": 0,
             "passive": 0,
@@ -339,7 +343,8 @@ def get_summary(mastervol, slave_url):
         if summary["faulty"] == 0 and summary["offline"] == 0:
             summary["ok"] = True
 
-        out.append([session_name, summary, faulty_rows, down_rows])
+        if session_name != "":
+                out.append([session_name, summary, faulty_rows, down_rows])
 
     return out
 
@@ -347,7 +352,7 @@ def get_summary(mastervol, slave_url):
 def touch_mount_root(mastervol):
     # Create a Mount and Touch the Mount point root,
     # Hack to make sure some event available after
-    # setting Checkpoint. Without this their is a chance of
+    # setting Checkpoint. Without this there is a chance of
     # Checkpoint never completes.
     with glustermount("localhost", mastervol) as mnt:
         execute(["touch", mnt])
@@ -376,14 +381,14 @@ def main(args):
     output_ok("Started Geo-replication and watching Status for "
               "Checkpoint completion")
 
-    touch_mount_root(args.mastervol)
-
     start_time = int(time.time())
     duration = 0
 
     # Sleep till Geo-rep initializes
     time.sleep(60)
 
+    touch_mount_root(args.mastervol)
+
     slave_url = "{0}::{1}".format(args.slave, args.slavevol)
 
     # Loop to Check the Geo-replication Status and Checkpoint
@@ -397,41 +402,39 @@ def main(args):
             # or any other error. Gluster cmd still produces XML output
             # with different message
             output_warning("Unable to get Geo-replication Status")
-            time.sleep(1)
-            continue
-
-        session_name, summary, faulty_rows, down_rows = session_summary[0]
-        chkpt_status = "COMPLETE" if summary["checkpoints_ok"] else \
-                       "NOT COMPLETE"
-        ok_status = "OK" if summary["ok"] else "NOT OK"
-
-        if summary["ok"]:
-            output_ok("All Checkpoints {1}, "
-                      "All status {2} (Turns {0:>3})".format(
-                          turns, chkpt_status, ok_status))
-        else:
-            output_warning("All Checkpoints {1}, "
-                           "All status {2} (Turns {0:>3})".format(
-                               turns, chkpt_status, ok_status))
-
-            output_warning("Geo-rep workers Faulty/Offline, "
-                           "Faulty: {0} Offline: {1}".format(
-                               repr(faulty_rows),
-                               repr(down_rows)))
-
-        if summary["checkpoints_ok"]:
-            output_ok("Stopping Geo-replication session now")
-            cmd = ["@SBIN_DIR@/gluster", "volume", "geo-replication",
-                   args.mastervol,
-                   "%s::%s" % (args.slave, args.slavevol), "stop"]
-            execute(cmd)
-            break
         else:
-            # If Checkpoint is not complete after a iteration means brick
-            # was down and came online now. SETATTR on mount is not
-            # recorded, So again issue touch on mount root So that
-            # Stime will increase and Checkpoint will complete.
-            touch_mount_root(args.mastervol)
+            session_name, summary, faulty_rows, down_rows = session_summary[0]
+            chkpt_status = "COMPLETE" if summary["checkpoints_ok"] else \
+                           "NOT COMPLETE"
+            ok_status = "OK" if summary["ok"] else "NOT OK"
+
+            if summary["ok"]:
+                output_ok("All Checkpoints {1}, "
+                          "All status {2} (Turns {0:>3})".format(
+                              turns, chkpt_status, ok_status))
+            else:
+                output_warning("All Checkpoints {1}, "
+                               "All status {2} (Turns {0:>3})".format(
+                                   turns, chkpt_status, ok_status))
+
+                output_warning("Geo-rep workers Faulty/Offline, "
+                               "Faulty: {0} Offline: {1}".format(
+                                   repr(faulty_rows),
+                                   repr(down_rows)))
+
+            if summary["checkpoints_ok"]:
+                output_ok("Stopping Geo-replication session now")
+                cmd = ["@SBIN_DIR@/gluster", "volume", "geo-replication",
+                       args.mastervol,
+                       "%s::%s" % (args.slave, args.slavevol), "stop"]
+                execute(cmd)
+                break
+            else:
+                # If Checkpoint is not complete after a iteration means brick
+                # was down and came online now. SETATTR on mount is not
+                # recorded, So again issue touch on mount root So that
+                # Stime will increase and Checkpoint will complete.
+                touch_mount_root(args.mastervol)
 
         # Increment the turns and Sleep for 10 sec
         turns += 1
@@ -446,13 +449,18 @@ def main(args):
 
         time.sleep(args.interval)
 
+    for mnt in mnt_list:
+        execute(["rmdir", mnt],
+                failure_msg="Unable to Remove temp directory "
+                "{0}".format(mnt), exitcode=0)
+
 if __name__ == "__main__":
     parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
                             description=__doc__)
     parser.add_argument("mastervol", help="Master Volume Name")
     parser.add_argument("slave",
-                        help="SLAVEHOST or root@SLAVEHOST "
-                        "or user@SLAVEHOST",
+                        help="Slave hostname "
+                        "(<username>@SLAVEHOST or SLAVEHOST)",
                         metavar="SLAVE")
     parser.add_argument("slavevol", help="Slave Volume Name")
     parser.add_argument("--interval", help="Interval in Seconds. "
@@ -474,4 +482,11 @@ if __name__ == "__main__":
         execute(cmd)
         main(args)
     except KeyboardInterrupt:
+        for mnt in mnt_list:
+            execute(["umount", "-l", mnt],
+                    failure_msg="Unable to Unmount Gluster Volume "
+                    "Mounted at {0}".format(mnt), exitcode=0)
+            execute(["rmdir", mnt],
+                    failure_msg="Unable to Remove temp directory "
+                    "{0}".format(mnt), exitcode=0)
         output_notok("Exiting...")
diff --git a/extras/git-branch-diff.py b/extras/git-branch-diff.py
index c8d74ec9f31..382513e069e 100755
--- a/extras/git-branch-diff.py
+++ b/extras/git-branch-diff.py
@@ -1,4 +1,4 @@
-#!/bin/env python
+#!/bin/python2
 
 """
   Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -75,6 +75,7 @@
   Prasanna Kumar Kalever <prasanna.kalever@redhat.com>
 """
 
+from __future__ import print_function
 import os
 import sys
 import argparse
@@ -118,16 +119,16 @@ class GitBranchDiff:
         status_tbr, op = commands.getstatusoutput('git log ' +
                                                   self.t_pattern)
         if status_sbr != 0:
-            print "Error: --source=" + self.s_pattern + " doesn't exit\n"
+            print("Error: --source=" + self.s_pattern + " doesn't exit\n")
             self.parser.print_help()
             exit(status_sbr)
         elif status_tbr != 0:
-            print "Error: --target=" + self.t_pattern + " doesn't exit\n"
+            print("Error: --target=" + self.t_pattern + " doesn't exit\n")
             self.parser.print_help()
             exit(status_tbr)
 
     def check_author_exist (self):
-        " defend to check given author exist, format incase of multiple"
+        " defend to check given author exist, format in case of multiple"
         contrib_list = ['', '*', 'all', 'All', 'ALL', 'null', 'Null', 'NULL']
         if self.g_author in contrib_list:
             self.g_author = ""
@@ -137,8 +138,8 @@ class GitBranchDiff:
                 cmd4 = 'git log ' + self.s_pattern + ' --author=' + ide
                 c_list = subprocess.check_output(cmd4, shell = True)
                 if len(c_list) is 0:
-                    print "Error: --author=%s doesn't exit" %self.g_author
-                    print "see '%s --help'" %__file__
+                    print("Error: --author=%s doesn't exit" %self.g_author)
+                    print("see '%s --help'" %__file__)
                     exit(1)
             if len(ide_list) > 1:
                 self.g_author = "\|".join(ide_list)
@@ -150,16 +151,16 @@ class GitBranchDiff:
             return True
         except requests.Timeout as err:
             " request timed out"
-            print "Warning: failed to get list of open review commits on " \
+            print("Warning: failed to get list of open review commits on " \
                             "gerrit.\n" \
                   "hint: Request timed out! gerrit server could possibly " \
-                  "slow ...\n"
+                  "slow ...\n")
             return False
         except requests.RequestException as err:
             " handle other errors"
-            print "Warning: failed to get list of open review commits on " \
+            print("Warning: failed to get list of open review commits on " \
                             "gerrit\n" \
-                  "hint: check with internet connection ...\n"
+                  "hint: check with internet connection ...\n")
             return False
 
     def parse_cmd_args (self):
@@ -189,7 +190,7 @@ class GitBranchDiff:
                                  '--author',
                                  help = 'default: git config name/email, '
                                         'to provide multiple specify comma'
-                                        ' seperated values',
+                                        ' separated values',
                                  default = author,
                                  dest = 'author')
         self.parser.add_argument('-p',
@@ -212,39 +213,39 @@ class GitBranchDiff:
 
     def print_output (self):
         " display the result list"
-        print "\n------------------------------------------------------------\n"
-        print self.tick + " Successfully Backported changes:"
-        print '      {' + 'from: ' + self.s_pattern + \
-              '  to: '+ self.t_pattern + '}\n'
-        for key, value in self.s_dict.iteritems():
+        print("\n------------------------------------------------------------\n")
+        print(self.tick + " Successfully Backported changes:")
+        print('      {' + 'from: ' + self.s_pattern + \
+              '  to: '+ self.t_pattern + '}\n')
+        for key, value in self.s_dict.items():
             if value in self.t_dict.itervalues():
-                print "[%s%s%s] %s" %(self.yello_set,
+                print("[%s%s%s] %s" %(self.yello_set,
                                       key,
                                       self.color_unset,
-                                      value)
-        print "\n------------------------------------------------------------\n"
-        print self.cross + " Missing patches in " + self.t_pattern + ':\n'
+                                      value))
+        print("\n------------------------------------------------------------\n")
+        print(self.cross + " Missing patches in " + self.t_pattern + ':\n')
         if self.connected_to_gerrit():
             cmd3 = "git review -r origin -l"
             review_list = subprocess.check_output(cmd3, shell = True).split('\n')
         else:
             review_list = []
 
-        for key, value in self.s_dict.iteritems():
+        for key, value in self.s_dict.items():
             if value not in self.t_dict.itervalues():
                 if any(value in s for s in review_list):
-                    print "[%s%s%s] %s %s(under review)%s" %(self.yello_set,
+                    print("[%s%s%s] %s %s(under review)%s" %(self.yello_set,
                                                             key,
                                                             self.color_unset,
                                                             value,
                                                             self.green_set,
-                                                            self.color_unset)
+                                                            self.color_unset))
                 else:
-                    print "[%s%s%s] %s" %(self.yello_set,
+                    print("[%s%s%s] %s" %(self.yello_set,
                                           key,
                                           self.color_unset,
-                                          value)
-        print "\n------------------------------------------------------------\n"
+                                          value))
+        print("\n------------------------------------------------------------\n")
 
     def main (self):
         self.check_pattern_exist()
@@ -262,8 +263,8 @@ class GitBranchDiff:
         t_list = subprocess.check_output(cmd2, shell = True)
 
         if len(t_list) is 0:
-            print "No commits in the target: %s" %self.t_pattern
-            print "see '%s --help'" %__file__
+            print("No commits in the target: %s" %self.t_pattern)
+            print("see '%s --help'" %__file__)
             exit()
         else:
             t_list = t_list.split('\n')
diff --git a/extras/glusterd.vol.in b/extras/glusterd.vol.in
index 5338aa25b0d..5d7bad0e4c8 100644
--- a/extras/glusterd.vol.in
+++ b/extras/glusterd.vol.in
@@ -1,13 +1,15 @@
 volume management
     type mgmt/glusterd
     option working-directory @GLUSTERD_WORKDIR@
-    option transport-type socket,rdma
+    option transport-type socket
     option transport.socket.keepalive-time 10
     option transport.socket.keepalive-interval 2
     option transport.socket.read-fail-log off
+    option transport.socket.listen-port 24007
     option ping-timeout 0
     option event-threads 1
 #   option lock-timer 180
 #   option transport.address-family inet6
 #   option base-port 49152
+    option max-port  60999
 end-volume
diff --git a/extras/glusterfs-georep-logrotate b/extras/glusterfs-georep-logrotate
index 6fdb8c65aaf..3e7ecf373a1 100644
--- a/extras/glusterfs-georep-logrotate
+++ b/extras/glusterfs-georep-logrotate
@@ -1,6 +1,12 @@
 /var/log/glusterfs/geo-replication/*/*.log {
     sharedscripts
-    rotate 52
+    weekly
+    maxsize 10M
+    minsize 100k
+
+    # 6 months of logs are good enough
+    rotate 26
+
     missingok
     compress
     delaycompress
@@ -15,7 +21,13 @@
 
 /var/log/glusterfs/geo-replication-slaves/*.log {
     sharedscripts
-    rotate 52
+    weekly
+    maxsize 10M
+    minsize 100k
+
+    # 6 months of logs are good enough
+    rotate 26
+
     missingok
     compress
     delaycompress
@@ -30,7 +42,13 @@
 
 /var/log/glusterfs/geo-replication-slaves/*/*.log {
     sharedscripts
-    rotate 52
+    weekly
+    maxsize 10M
+    minsize 100k
+
+    # 6 months of logs are good enough
+    rotate 26
+
     missingok
     compress
     delaycompress
diff --git a/extras/glusterfs-georep-upgrade.py b/extras/glusterfs-georep-upgrade.py
new file mode 100755
index 00000000000..634576058d6
--- /dev/null
+++ b/extras/glusterfs-georep-upgrade.py
@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+"""
+
+Copyright (c) 2020 Red Hat, Inc. <http://www.redhat.com>
+This file is part of GlusterFS.
+
+This file is licensed to you under your choice of the GNU Lesser
+General Public License, version 3 or any later version (LGPLv3 or
+later), or the GNU General Public License, version 2 (GPLv2), in all
+cases as published by the Free Software Foundation.
+
+"""
+
+import argparse
+import errno
+import os, sys
+import shutil
+from datetime import datetime
+
+def find_htime_path(brick_path):
+    dirs = []
+    htime_dir = os.path.join(brick_path, '.glusterfs/changelogs/htime')
+    for file in os.listdir(htime_dir):
+        if os.path.isfile(os.path.join(htime_dir,file)) and file.startswith("HTIME"):
+            dirs.append(os.path.join(htime_dir, file))
+        else:
+            raise FileNotFoundError("%s unavailable" % (os.path.join(htime_dir, file)))
+    return dirs
+
+def modify_htime_file(brick_path):
+    htime_file_path_list = find_htime_path(brick_path)
+
+    for htime_file_path in htime_file_path_list:
+        changelog_path = os.path.join(brick_path, '.glusterfs/changelogs')
+        temp_htime_path = os.path.join(changelog_path, 'htime/temp_htime_file')
+        with open(htime_file_path, 'r') as htime_file, open(temp_htime_path, 'w') as temp_htime_file:
+            #extract epoch times from htime file
+            paths = htime_file.read().split("\x00")
+
+            for pth in paths:
+                epoch_no = pth.split(".")[-1]
+                changelog = os.path.basename(pth)
+                #convert epoch time to year, month and day
+                if epoch_no != '':
+                    date=(datetime.fromtimestamp(float(int(epoch_no))).strftime("%Y/%m/%d"))
+                    #update paths in temp htime file
+                    temp_htime_file.write("%s/%s/%s\x00" % (changelog_path, date, changelog))
+                    #create directory in the format year/month/days
+                    path = os.path.join(changelog_path, date)
+
+                if changelog.startswith("CHANGELOG."):
+                    try:
+                        os.makedirs(path, mode = 0o600);
+                    except OSError as exc:
+                        if exc.errno == errno.EEXIST:
+                            pass
+                        else:
+                            raise
+
+                    #copy existing changelogs to new directory structure, delete old changelog files
+                    shutil.copyfile(pth, os.path.join(path, changelog))
+                    os.remove(pth)
+
+        #rename temp_htime_file with htime file
+        os.rename(htime_file_path, os.path.join('%s.bak'%htime_file_path))
+        os.rename(temp_htime_path, htime_file_path)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('brick_path', help="This upgrade script, which is to be run on\
+                         server side, takes brick path as the argument, \
+                         updates paths inside htime file and alters the directory structure \
+                         above the changelog files inorder to support new optimised format \
+                         of the directory structure as per \
+                         https://review.gluster.org/#/c/glusterfs/+/23733/")
+    args = parser.parse_args()
+    modify_htime_file(args.brick_path)
diff --git a/extras/glusterfs-logrotate b/extras/glusterfs-logrotate
index 575c0eee771..6ba6ef18e9f 100644
--- a/extras/glusterfs-logrotate
+++ b/extras/glusterfs-logrotate
@@ -2,7 +2,12 @@
 /var/log/glusterfs/*.log {
   sharedscripts
   weekly
-  rotate 52
+  maxsize 10M
+  minsize 100k
+
+# 6 months of logs are good enough
+  rotate 26
+
   missingok
   compress
   delaycompress
@@ -17,7 +22,12 @@
 /var/log/glusterfs/bricks/*.log {
   sharedscripts
   weekly
-  rotate 52
+  maxsize 10M
+  minsize 100k
+
+# 6 months of logs are good enough
+  rotate 26
+
   missingok
   compress
   delaycompress
@@ -35,3 +45,24 @@
   compress
   delaycompress
 }
+
+# Rotate snapd log
+/var/log/glusterfs/snaps/*/*.log {
+    sharedscripts
+    weekly
+    maxsize 10M
+    minsize 100k
+
+    # 6 months of logs are good enough
+    rotate 26
+
+    missingok
+    compress
+    delaycompress
+    notifempty
+    postrotate
+    for pid in `ps -aef | grep glusterfs | egrep "snapd" | awk '{print $2}'`; do
+        /usr/bin/kill -HUP $pid > /dev/null 2>&1 || true
+    done
+    endscript
+}
diff --git a/extras/gnfs-loganalyse.py b/extras/gnfs-loganalyse.py
index 71e79b6be4e..6341d007188 100644..100755
--- a/extras/gnfs-loganalyse.py
+++ b/extras/gnfs-loganalyse.py
@@ -10,6 +10,7 @@
 
 """
 
+from __future__ import print_function
 import os
 import string
 import sys
@@ -72,7 +73,7 @@ class NFSRequest:
                         self.replygfid = tokens [gfididx + 1].strip(",")
 
         def dump (self):
-                print "ReqLine: " + str(self.calllinecount) + " TimeStamp: " + self.timestamp + ", XID: " + self.xid + " " + self.op + " ARGS: " + self.opdata + " RepLine: " + str(self.replylinecount) + " " + self.replydata
+                print("ReqLine: " + str(self.calllinecount) + " TimeStamp: " + self.timestamp + ", XID: " + self.xid + " " + self.op + " ARGS: " + self.opdata + " RepLine: " + str(self.replylinecount) + " " + self.replydata)
 
 class NFSLogAnalyzer:
 
@@ -149,7 +150,7 @@ class NFSLogAnalyzer:
                         return
                 rcount = len (self.xid_request_map.keys ())
                 orphancount = len (self.orphan_replies.keys ())
-                print "Requests: " + str(rcount) + ", Orphans: " + str(orphancount)
+                print("Requests: " + str(rcount) + ", Orphans: " + str(orphancount))
 
         def dump (self):
                 self.getStats ()
diff --git a/extras/group-db-workload b/extras/group-db-workload
new file mode 100644
index 00000000000..9334d6fb942
--- /dev/null
+++ b/extras/group-db-workload
@@ -0,0 +1,12 @@
+performance.open-behind=on
+performance.write-behind=off
+performance.stat-prefetch=off
+performance.quick-read=off
+performance.strict-o-direct=on
+performance.read-ahead=off
+performance.io-cache=off
+performance.readdir-ahead=off
+performance.client-io-threads=on
+server.event-threads=4
+client.event-threads=4
+performance.read-after-open=yes
diff --git a/extras/group-distributed-virt b/extras/group-distributed-virt
new file mode 100644
index 00000000000..a960b76c694
--- /dev/null
+++ b/extras/group-distributed-virt
@@ -0,0 +1,10 @@
+performance.quick-read=off
+performance.read-ahead=off
+performance.io-cache=off
+performance.low-prio-threads=32
+network.remote-dio=enable
+features.shard=on
+user.cifs=off
+client.event-threads=4
+server.event-threads=4
+performance.client-io-threads=on
diff --git a/extras/group-gluster-block b/extras/group-gluster-block
index e94f834d420..1e398019e6b 100644
--- a/extras/group-gluster-block
+++ b/extras/group-gluster-block
@@ -5,8 +5,16 @@ performance.stat-prefetch=off
 performance.open-behind=off
 performance.readdir-ahead=off
 performance.strict-o-direct=on
+performance.client-io-threads=on
+performance.io-thread-count=32
+performance.high-prio-threads=32
+performance.normal-prio-threads=32
+performance.low-prio-threads=32
+performance.least-prio-threads=4
+client.event-threads=8
+server.event-threads=8
 network.remote-dio=disable
-cluster.eager-lock=disable
+cluster.eager-lock=enable
 cluster.quorum-type=auto
 cluster.data-self-heal-algorithm=full
 cluster.locking-scheme=granular
@@ -16,3 +24,4 @@ features.shard=on
 features.shard-block-size=64MB
 user.cifs=off
 server.allow-insecure=on
+cluster.choose-local=off
diff --git a/extras/group-metadata-cache b/extras/group-metadata-cache
index 0f780eb91aa..b890b288fc7 100644
--- a/extras/group-metadata-cache
+++ b/extras/group-metadata-cache
@@ -3,4 +3,4 @@ features.cache-invalidation-timeout=600
 performance.stat-prefetch=on
 performance.cache-invalidation=on
 performance.md-cache-timeout=600
-network.inode-lru-limit=50000
+network.inode-lru-limit=200000
diff --git a/extras/group-nl-cache b/extras/group-nl-cache
index a41e8ecfd64..897807e8933 100644
--- a/extras/group-nl-cache
+++ b/extras/group-nl-cache
@@ -2,4 +2,4 @@ features.cache-invalidation=on
 features.cache-invalidation-timeout=600
 performance.nl-cache=on
 performance.nl-cache-timeout=600
-network.inode-lru-limit=50000
+network.inode-lru-limit=200000
diff --git a/extras/group-samba b/extras/group-samba
new file mode 100644
index 00000000000..eeee6e06031
--- /dev/null
+++ b/extras/group-samba
@@ -0,0 +1,11 @@
+features.cache-invalidation=on
+features.cache-invalidation-timeout=600
+performance.cache-samba-metadata=on
+performance.stat-prefetch=on
+performance.cache-invalidation=on
+performance.md-cache-timeout=600
+network.inode-lru-limit=200000
+performance.nl-cache=on
+performance.nl-cache-timeout=600
+performance.readdir-ahead=on
+performance.parallel-readdir=on
diff --git a/extras/group-virt.example b/extras/group-virt.example
index 403bed6714f..cc37c98a25c 100644
--- a/extras/group-virt.example
+++ b/extras/group-virt.example
@@ -2,7 +2,8 @@ performance.quick-read=off
 performance.read-ahead=off
 performance.io-cache=off
 performance.low-prio-threads=32
-network.remote-dio=enable
+network.remote-dio=disable
+performance.strict-o-direct=on
 cluster.eager-lock=enable
 cluster.quorum-type=auto
 cluster.server-quorum-type=server
@@ -12,3 +13,12 @@ cluster.shd-max-threads=8
 cluster.shd-wait-qlength=10000
 features.shard=on
 user.cifs=off
+cluster.choose-local=off
+client.event-threads=4
+server.event-threads=4
+performance.client-io-threads=on
+network.ping-timeout=20
+server.tcp-user-timeout=20
+server.keepalive-time=10
+server.keepalive-interval=2
+server.keepalive-count=5
diff --git a/extras/hook-scripts/S40ufo-stop.py b/extras/hook-scripts/S40ufo-stop.py
index 107f1968355..2c79eb1d54a 100755
--- a/extras/hook-scripts/S40ufo-stop.py
+++ b/extras/hook-scripts/S40ufo-stop.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 
 import os
 from optparse import OptionParser
diff --git a/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh b/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh
index a5e472e9267..7d6052315bb 100755
--- a/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh
+++ b/extras/hook-scripts/S56glusterd-geo-rep-create-post.sh
@@ -77,18 +77,28 @@ if [ "$val" == "" ]; then
     exit;
 fi
 SSH_PORT=`echo $val`
+SSH_OPT="-oPasswordAuthentication=no -oStrictHostKeyChecking=no"
 
 if [ -f $pub_file ]; then
     # For a non-root user copy the pub file to the user's home directory
     # For a root user copy the pub files to priv_dir->geo-rep.
     if [ "$slave_user" != "root" ]; then
-        slave_user_home_dir=`ssh -p ${SSH_PORT} $slave_user@$slave_ip "getent passwd $slave_user | cut -d ':' -f 6"`
-        scp -P ${SSH_PORT} $pub_file $slave_user@$slave_ip:$slave_user_home_dir/common_secret.pem.pub_tmp
-        ssh -p ${SSH_PORT} $slave_user@$slave_ip "mv $slave_user_home_dir/common_secret.pem.pub_tmp $slave_user_home_dir/${mastervol}_${slavevol}_common_secret.pem.pub"
+        slave_user_home_dir=`ssh -p ${SSH_PORT} ${SSH_OPT} $slave_user@$slave_ip "getent passwd $slave_user | cut -d ':' -f 6"`
+        scp -P ${SSH_PORT} ${SSH_OPT} $pub_file $slave_user@$slave_ip:$slave_user_home_dir/common_secret.pem.pub_tmp
+        ssh -p ${SSH_PORT} ${SSH_OPT} $slave_user@$slave_ip "mv $slave_user_home_dir/common_secret.pem.pub_tmp $slave_user_home_dir/${mastervol}_${slavevol}_common_secret.pem.pub"
     else
-        scp -P ${SSH_PORT} $pub_file $slave_ip:$pub_file_tmp
-        ssh -p ${SSH_PORT} $slave_ip "mv $pub_file_tmp ${pub_file_dname}/${mastervol}_${slavevol}_${pub_file_bname}"
-        ssh -p ${SSH_PORT} $slave_ip "gluster system:: copy file /geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
-        ssh -p ${SSH_PORT} $slave_ip "gluster system:: execute add_secret_pub root geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
+        if [[ -z "${GR_SSH_IDENTITY_KEY}" ]]; then
+            scp -P ${SSH_PORT} ${SSH_OPT} $pub_file $slave_ip:$pub_file_tmp
+            ssh -p ${SSH_PORT} ${SSH_OPT} $slave_ip "mv $pub_file_tmp ${pub_file_dname}/${mastervol}_${slavevol}_${pub_file_bname}"
+            ssh -p ${SSH_PORT} ${SSH_OPT} $slave_ip "gluster system:: copy file /geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
+            ssh -p ${SSH_PORT} ${SSH_OPT} $slave_ip "gluster system:: execute add_secret_pub root geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
+            ssh -p ${SSH_PORT} ${SSH_OPT} $slave_ip "gluster vol set ${slavevol} features.read-only on"
+        else
+            scp -P ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} ${SSH_OPT} $pub_file $slave_ip:$pub_file_tmp
+            ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} ${SSH_OPT} $slave_ip "mv $pub_file_tmp ${pub_file_dname}/${mastervol}_${slavevol}_${pub_file_bname}"
+            ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} ${SSH_OPT} $slave_ip "gluster system:: copy file /geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
+            ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} ${SSH_OPT} $slave_ip "gluster system:: execute add_secret_pub root geo-replication/${mastervol}_${slavevol}_common_secret.pem.pub > /dev/null"
+            ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} ${SSH_OPT} $slave_ip "gluster vol set ${slavevol} features.read-only on"
+        fi
     fi
 fi
diff --git a/extras/hook-scripts/add-brick/post/Makefile.am b/extras/hook-scripts/add-brick/post/Makefile.am
index 5ca5a669de9..9b236df096d 100644
--- a/extras/hook-scripts/add-brick/post/Makefile.am
+++ b/extras/hook-scripts/add-brick/post/Makefile.am
@@ -1,4 +1,6 @@
-EXTRA_DIST = disabled-quota-root-xattr-heal.sh
+EXTRA_DIST = disabled-quota-root-xattr-heal.sh S10selinux-label-brick.sh S13create-subdir-mounts.sh
 
 hookdir = $(GLUSTERD_WORKDIR)/hooks/1/add-brick/post/
-hook_SCRIPTS = disabled-quota-root-xattr-heal.sh
+if WITH_SERVER
+hook_SCRIPTS = disabled-quota-root-xattr-heal.sh S10selinux-label-brick.sh S13create-subdir-mounts.sh
+endif
diff --git a/extras/hook-scripts/add-brick/post/S10selinux-label-brick.sh b/extras/hook-scripts/add-brick/post/S10selinux-label-brick.sh
new file mode 100755
index 00000000000..4a17c993a77
--- /dev/null
+++ b/extras/hook-scripts/add-brick/post/S10selinux-label-brick.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+#
+# Install to hooks/<HOOKS_VER>/add-brick/post
+#
+# Add an SELinux file context for each brick using the glusterd_brick_t type.
+# This ensures that the brick is relabeled correctly on an SELinux restart or
+# restore. Subsequently, run a restore on the brick path to set the selinux
+# labels.
+#
+###
+
+PROGNAME="Sselinux"
+OPTSPEC="volname:,version:,gd-workdir:,volume-op:"
+VOL=
+
+parse_args () {
+  ARGS=$(getopt -o '' -l ${OPTSPEC} -n ${PROGNAME} -- "$@")
+  eval set -- "${ARGS}"
+
+  while true; do
+    case ${1} in
+      --volname)
+        shift
+        VOL=${1}
+        ;;
+      --gd-workdir)
+          shift
+          GLUSTERD_WORKDIR=$1
+          ;;
+      --version)
+          shift
+          ;;
+      --volume-op)
+          shift
+          ;;
+      *)
+          shift
+          break
+          ;;
+    esac
+    shift
+  done
+}
+
+set_brick_labels()
+{
+  local volname="${1}"
+  local fctx
+  local list=()
+
+  fctx="$(semanage fcontext --list -C)"
+
+  # wait for new brick path to be updated under
+  # ${GLUSTERD_WORKDIR}/vols/${volname}/bricks/
+  sleep 5
+
+  # grab the path for each local brick
+  brickpath="${GLUSTERD_WORKDIR}/vols/${volname}/bricks/"
+  brickdirs=$(
+    find "${brickpath}" -type f -exec grep '^path=' {} \; | \
+    cut -d= -f 2 | \
+    sort -u
+  )
+
+  # create a list of bricks for which custom SELinux
+  # label doesn't exist
+  for b in ${brickdirs}; do
+    pattern="${b}(/.*)?"
+    echo "${fctx}" | grep "^${pattern}\s" >/dev/null
+    if [[ $? -ne 0 ]]; then
+      list+=("${pattern}")
+    fi
+  done
+
+  # Add a file context for each brick path in the list and associate with the
+  # glusterd_brick_t SELinux type.
+  for p in ${list[@]}
+  do
+    semanage fcontext --add -t glusterd_brick_t -r s0 "${p}"
+  done
+
+  # Set the labels for which SELinux label was added above
+  for b in ${brickdirs}
+  do
+    echo "${list[@]}" | grep "${b}" >/dev/null
+    if [[ $? -eq 0 ]]; then
+      restorecon -R "${b}"
+    fi
+  done
+}
+
+SELINUX_STATE=$(which getenforce && getenforce)
+[ "${SELINUX_STATE}" = 'Disabled' ] && exit 0
+
+parse_args "$@"
+[ -z "${VOL}" ] && exit 1
+
+set_brick_labels "${VOL}"
+
+exit 0
diff --git a/extras/hook-scripts/add-brick/post/S13create-subdir-mounts.sh b/extras/hook-scripts/add-brick/post/S13create-subdir-mounts.sh
new file mode 100755
index 00000000000..1a6923ee7aa
--- /dev/null
+++ b/extras/hook-scripts/add-brick/post/S13create-subdir-mounts.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+
+##---------------------------------------------------------------------------
+## This script runs the self-heal of the directories which are expected to
+## be present as they are mounted as subdirectory mounts.
+##---------------------------------------------------------------------------
+
+MOUNT_DIR=`mktemp -d -t ${0##*/}.XXXXXX`;
+OPTSPEC="volname:,version:,gd-workdir:,volume-op:"
+PROGNAME="add-brick-create-subdir"
+VOL_NAME=test
+GLUSTERD_WORKDIR="/var/lib/glusterd"
+
+cleanup_mountpoint ()
+{
+        umount -f $MOUNT_DIR;
+        if [ 0 -ne $? ]
+        then
+                return $?
+        fi
+
+        rmdir $MOUNT_DIR;
+        if [ 0 -ne $? ]
+        then
+                return $?
+        fi
+}
+
+##------------------------------------------
+## Parse the arguments
+##------------------------------------------
+ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+eval set -- "$ARGS"
+
+while true;
+do
+    case $1 in
+        --volname)
+            shift
+            VOL_NAME=$1
+            ;;
+        --gd-workdir)
+            shift
+            GLUSTERD_WORKDIR=$1
+            ;;
+	--version)
+	    shift
+	    ;;
+	--volume-op)
+	    shift
+	    ;;
+	*)
+	    shift
+	    break
+	    ;;
+    esac
+    shift
+done
+
+## See if we have any subdirs to be healed before going further
+subdirs=$(grep 'auth.allow' ${GLUSTERD_WORKDIR}/vols/${VOL_NAME}/info | cut -f2 -d'=' | tr ',' '\n' | cut -f1 -d'(');
+
+if [ -z ${subdirs} ]; then
+    rmdir $MOUNT_DIR;
+    exit 0;
+fi
+
+##----------------------------------------
+## Mount the volume in temp directory.
+## -----------------------------------
+glusterfs -s localhost --volfile-id=$VOL_NAME --client-pid=-50 $MOUNT_DIR;
+if [ 0 -ne $? ]
+then
+    exit $?;
+fi
+
+## -----------------------------------
+# Do the 'stat' on all the directory for now. Ideal fix is to look at subdir
+# list from 'auth.allow' option and only stat them.
+for subdir in ${subdirs}
+do
+    stat ${MOUNT_DIR}/${subdir} > /dev/null;
+done
+
+## Clean up and exit
+cleanup_mountpoint;
diff --git a/extras/hook-scripts/add-brick/post/disabled-quota-root-xattr-heal.sh b/extras/hook-scripts/add-brick/post/disabled-quota-root-xattr-heal.sh
index bde7249d429..ca17a903549 100755
--- a/extras/hook-scripts/add-brick/post/disabled-quota-root-xattr-heal.sh
+++ b/extras/hook-scripts/add-brick/post/disabled-quota-root-xattr-heal.sh
@@ -13,123 +13,133 @@
 
 QUOTA_LIMIT_XATTR="trusted.glusterfs.quota.limit-set"
 QUOTA_OBJECT_LIMIT_XATTR="trusted.glusterfs.quota.limit-objects"
-MOUNT_DIR=`mktemp -d -t ${0##*/}.XXXXXX`;
+MOUNT_DIR=$(mktemp -d -t "${0##*/}.XXXXXX");
 OPTSPEC="volname:,version:,gd-workdir:,volume-op:"
 PROGNAME="Quota-xattr-heal-add-brick"
 VOL_NAME=
 VERSION=
 VOLUME_OP=
 GLUSTERD_WORKDIR=
-ENABLED_NAME="S28Quota-root-xattr-heal.sh"
+ENABLED_NAME_PREFIX="S28"
+ENABLED_NAME="Quota-root-xattr-heal.sh"
+
+THIS_SCRIPT=$(echo "${0}" | awk -F'/' '{print $NF}')
 
 cleanup_mountpoint ()
 {
-        umount -f $MOUNT_DIR;
-        if [ 0 -ne $? ]
-        then
-                return $?
-        fi
-
-        rmdir $MOUNT_DIR;
-        if [ 0 -ne $? ]
-        then
-                return $?
-        fi
+
+  if umount -f "${MOUNT_DIR}"; then
+    return $?
+  fi
+
+  if rmdir "${MOUNT_DIR}"; then
+    return $?
+  fi
 }
 
 disable_and_exit ()
 {
-        if [ -e "$ENABLED_STATE" ]
-        then
-                unlink $ENABLED_STATE;
-                exit $?
-        fi
+  if [ -e "${ENABLED_STATE}" ]
+  then
+    unlink "${ENABLED_STATE}";
+    exit $?
+  fi
 
-        exit 0
+  exit 0
 }
 
 get_and_set_xattr ()
 {
-        XATTR=$1
-
-        VALUE=$(getfattr -n $XATTR -e hex --absolute-names $MOUNT_DIR 2>&1)
-        RET=$?
-        if [ 0 -eq $RET ]; then
-                VALUE=$(echo $VALUE | grep $XATTR | awk -F'=' '{print $NF}')
-                setfattr -n $XATTR -v $VALUE $MOUNT_DIR;
-                RET=$?
-        else
-                echo $VALUE | grep -iq "No such attribute"
-                if [ 0 -eq $? ]; then
-                        RET=0
-                fi
-        fi
-
-        return $RET;
+  XATTR=$1
+
+  VALUE=$(getfattr -n "${XATTR}" -e hex --absolute-names "${MOUNT_DIR}" 2>&1)
+  RET=$?
+  if [ 0 -eq ${RET} ]; then
+    VALUE=$(echo "${VALUE}" | grep "${XATTR}" | awk -F'=' '{print $NF}')
+    setfattr -n "${XATTR}" -v "${VALUE}" "${MOUNT_DIR}";
+    RET=$?
+  else
+    if echo "${VALUE}" | grep -iq "No such attribute" ; then
+      RET=0
+    fi
+  fi
+
+  return ${RET};
 }
 
 ##------------------------------------------
 ## Parse the arguments
 ##------------------------------------------
-ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+ARGS=$(getopt -o '' -l ${OPTSPEC} -n ${PROGNAME} -- "$@")
 eval set -- "$ARGS"
 
 while true;
 do
-    case $1 in
-        --volname)
-            shift
-            VOL_NAME=$1
-            ;;
-        --version)
-            shift
-            VERSION=$1
-            ;;
-        --gd-workdir)
-            shift
-            GLUSTERD_WORKDIR=$1
-            ;;
-        --volume-op)
-            shift
-            VOLUME_OP=$1
-            ;;
-        *)
-            shift
-            break
-            ;;
-    esac
-    shift
+  case $1 in
+    --volname)
+      shift
+      VOL_NAME=$1
+    ;;
+    --version)
+      shift
+      VERSION=$1
+    ;;
+    --gd-workdir)
+      shift
+      GLUSTERD_WORKDIR=$1
+    ;;
+    --volume-op)
+      shift
+      VOLUME_OP=$1
+    ;;
+    *)
+      shift
+      break
+    ;;
+  esac
+  shift
 done
 ##----------------------------------------
 
-ENABLED_STATE="$GLUSTERD_WORKDIR/hooks/$VERSION/$VOLUME_OP/post/$ENABLED_NAME"
+# Avoid long lines
+ENABLED_STATE_1="${GLUSTERD_WORKDIR}/hooks/${VERSION}/${VOLUME_OP}/"
+ENABLED_STATE_2="post/${ENABLED_NAME_PREFIX}${VOL_NAME}-${ENABLED_NAME}"
+ENABLED_STATE="${ENABLED_STATE_1}${ENABLED_STATE_2}"
+
+if [ "${THIS_SCRIPT}" != *"${VOL_NAME}"* ]; then
+  exit 0
+fi
 
 ## Is quota enabled?
-FLAG=`grep "^features.quota=" $GLUSTERD_WORKDIR/vols/$VOL_NAME/info \
-      | awk -F'=' '{print $NF}'`;
-if [ "$FLAG" != "on" ]
+FLAG=$(grep "^features.quota=" "${GLUSTERD_WORKDIR}/vols/${VOL_NAME}/info" \
+| awk -F'=' '{print $NF}');
+if [ "${FLAG}" != "on" ]
 then
-        disable_and_exit
+  disable_and_exit
 fi
 
 ## -----------------------------------
 ## Mount the volume in temp directory.
 ## -----------------------------------
-glusterfs -s localhost --volfile-id=$VOL_NAME --client-pid=-42 $MOUNT_DIR;
-if [ 0 -ne $? ]
+# Avoid long lines
+CMD_1="glusterfs -s localhost"
+CMD_2="--volfile-id=${VOL_NAME} client-pid=-42 ${MOUNT_DIR}"
+CMD="${CMD_1}${CMD_2}"
+
+if ${CMD}
 then
-        exit $?;
+  exit $?;
 fi
 ## -----------------------------------
 
-RET1=$(get_and_set_xattr $QUOTA_LIMIT_XATTR)
-RET2=$(get_and_set_xattr $QUOTA_OBJECT_LIMIT_XATTR)
+RET1=$(get_and_set_xattr "${QUOTA_LIMIT_XATTR}")
+RET2=$(get_and_set_xattr "${QUOTA_OBJECT_LIMIT_XATTR}")
 
 ## Clean up and exit
 cleanup_mountpoint;
 
-if [ $RET1 -ne 0 -o $RET2 -ne 0 ]; then
-        exit 1
+if [ "${RET1}" -ne 0 ] || [ "${RET2}" -ne 0 ]; then
+  exit 1
 fi
 
 disable_and_exit;
diff --git a/extras/hook-scripts/add-brick/pre/Makefile.am b/extras/hook-scripts/add-brick/pre/Makefile.am
index 6329ad1d4bd..3288581aa57 100644
--- a/extras/hook-scripts/add-brick/pre/Makefile.am
+++ b/extras/hook-scripts/add-brick/pre/Makefile.am
@@ -1,4 +1,6 @@
 EXTRA_DIST = S28Quota-enable-root-xattr-heal.sh
 
 hookdir = $(GLUSTERD_WORKDIR)/hooks/1/add-brick/pre/
+if WITH_SERVER
 hook_SCRIPTS = S28Quota-enable-root-xattr-heal.sh
+endif
diff --git a/extras/hook-scripts/add-brick/pre/S28Quota-enable-root-xattr-heal.sh b/extras/hook-scripts/add-brick/pre/S28Quota-enable-root-xattr-heal.sh
index 348f34ec3db..27e85231f45 100755
--- a/extras/hook-scripts/add-brick/pre/S28Quota-enable-root-xattr-heal.sh
+++ b/extras/hook-scripts/add-brick/pre/S28Quota-enable-root-xattr-heal.sh
@@ -26,10 +26,11 @@ VOL_NAME=
 GLUSTERD_WORKDIR=
 VOLUME_OP=
 VERSION=
-ENABLED_NAME="S28Quota-root-xattr-heal.sh"
+ENABLED_NAME_PREFIX="S28"
+ENABLED_NAME="Quota-root-xattr-heal.sh"
 DISABLED_NAME="disabled-quota-root-xattr-heal.sh"
 
-enable ()
+activate ()
 {
         ln -sf $DISABLED_STATE $1;
 }
@@ -37,7 +38,7 @@ enable ()
 ##------------------------------------------
 ## Parse the arguments
 ##------------------------------------------
-ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+ARGS=$(getopt -o '' -l $OPTSPEC -n $PROGNAME -- "$@")
 eval set -- "$ARGS"
 
 while true;
@@ -69,8 +70,8 @@ done
 ##----------------------------------------
 
 DISABLED_STATE="$GLUSTERD_WORKDIR/hooks/$VERSION/add-brick/post/$DISABLED_NAME"
-ENABLED_STATE_START="$GLUSTERD_WORKDIR/hooks/$VERSION/start/post/$ENABLED_NAME"
-ENABLED_STATE_ADD_BRICK="$GLUSTERD_WORKDIR/hooks/$VERSION/add-brick/post/$ENABLED_NAME";
+ENABLED_STATE_START="$GLUSTERD_WORKDIR/hooks/$VERSION/start/post/""$ENABLED_NAME_PREFIX$VOL_NAME""-""$ENABLED_NAME"
+ENABLED_STATE_ADD_BRICK="$GLUSTERD_WORKDIR/hooks/$VERSION/add-brick/post/""$ENABLED_NAME_PREFIX""$VOL_NAME""-""$ENABLED_NAME";
 
 ## Why to proceed if the required script itself is not present?
 ls $DISABLED_STATE;
@@ -92,9 +93,9 @@ FLAG=`cat $GLUSTERD_WORKDIR/vols/$VOL_NAME/info | grep "^status=" \
       | awk -F'=' '{print $NF}'`;
 if [ "$FLAG" != "1" ]
 then
-        enable $ENABLED_STATE_START;
+        activate $ENABLED_STATE_START;
         exit $?
 fi
 
-enable $ENABLED_STATE_ADD_BRICK;
+activate $ENABLED_STATE_ADD_BRICK;
 exit $?
diff --git a/extras/hook-scripts/create/post/Makefile.am b/extras/hook-scripts/create/post/Makefile.am
index adbce78d249..fd1892e9589 100644
--- a/extras/hook-scripts/create/post/Makefile.am
+++ b/extras/hook-scripts/create/post/Makefile.am
@@ -1,6 +1,8 @@
 EXTRA_DIST = S10selinux-label-brick.sh
 
 scriptsdir = $(GLUSTERD_WORKDIR)/hooks/1/create/post/
+if WITH_SERVER
 if USE_SELINUX
 scripts_SCRIPTS = S10selinux-label-brick.sh
 endif
+endif
diff --git a/extras/hook-scripts/create/post/S10selinux-label-brick.sh b/extras/hook-scripts/create/post/S10selinux-label-brick.sh
index f38555c26c0..f9b4b1a57e3 100755
--- a/extras/hook-scripts/create/post/S10selinux-label-brick.sh
+++ b/extras/hook-scripts/create/post/S10selinux-label-brick.sh
@@ -14,48 +14,52 @@ OPTSPEC="volname:"
 VOL=
 
 parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
-        eval set -- "$ARGS"
-
-        while true; do
-        case $1 in
-        --volname)
-         shift
-         VOL=$1
-         ;;
-        *)
-         shift
-         break
-         ;;
-        esac
+  ARGS=$(getopt -o '' -l ${OPTSPEC} -n ${PROGNAME} -- "$@")
+  eval set -- "${ARGS}"
+
+  while true; do
+    case ${1} in
+      --volname)
+        shift
+        VOL=${1}
+      ;;
+      *)
         shift
-        done
+        break
+      ;;
+    esac
+    shift
+  done
 }
 
 set_brick_labels()
 {
-        volname=$1
-
-        # grab the path for each local brick
-        brickdirs=$(grep '^path=' /var/lib/glusterd/vols/${volname}/bricks/* | cut -d= -f 2)
+  volname="${1}"
 
-        for b in $brickdirs
-        do
-                # Add a file context for each brick path and associate with the
-                # glusterd_brick_t SELinux type.
-                semanage fcontext --add -t glusterd_brick_t -r s0 $b(/.*)?
+  # grab the path for each local brick
+  brickpath="/var/lib/glusterd/vols/${volname}/bricks/"
+  brickdirs=$(
+    find "${brickpath}" -type f -exec grep '^path=' {} \; | \
+    cut -d= -f 2 | \
+    sort -u
+  )
 
-                # Set the labels on the new brick path.
-                restorecon -R $b
-        done
+  for b in ${brickdirs}; do
+    # Add a file context for each brick path and associate with the
+    # glusterd_brick_t SELinux type.
+    pattern="${b}(/.*)?"
+    semanage fcontext --add -t glusterd_brick_t -r s0 "${pattern}"
+    # Set the labels on the new brick path.
+    restorecon -R "${b}"
+  done
 }
 
 SELINUX_STATE=$(which getenforce && getenforce)
 [ "${SELINUX_STATE}" = 'Disabled' ] && exit 0
 
-parse_args $@
-[ -z "$VOL" ] && exit 1
+parse_args "$@"
+[ -z "${VOL}" ] && exit 1
 
-set_brick_labels $VOL
+set_brick_labels "${VOL}"
 
 exit 0
diff --git a/extras/hook-scripts/delete/pre/Makefile.am b/extras/hook-scripts/delete/pre/Makefile.am
index bf0eabe255c..4fbfbe7311f 100644
--- a/extras/hook-scripts/delete/pre/Makefile.am
+++ b/extras/hook-scripts/delete/pre/Makefile.am
@@ -1,6 +1,8 @@
 EXTRA_DIST = S10selinux-del-fcontext.sh
 
 scriptsdir = $(GLUSTERD_WORKDIR)/hooks/1/delete/pre/
+if WITH_SERVER
 if USE_SELINUX
 scripts_SCRIPTS = S10selinux-del-fcontext.sh
 endif
+endif
diff --git a/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh b/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
index 2c83331d5cd..056b52afe76 100755
--- a/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
+++ b/extras/hook-scripts/delete/pre/S10selinux-del-fcontext.sh
@@ -13,50 +13,61 @@
 PROGNAME="Sselinux"
 OPTSPEC="volname:"
 VOL=
-CONFIGFILE=
-LOGFILEBASE=
-PIDDIR=
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
-        eval set -- "$ARGS"
-
-        while true; do
-        case $1 in
-        --volname)
-         shift
-         VOL=$1
-         ;;
-        *)
-         shift
-         break
-         ;;
-        esac
+  ARGS=$(getopt -o '' -l ${OPTSPEC} -n ${PROGNAME} -- "$@")
+  eval set -- "${ARGS}"
+
+  while true; do
+    case ${1} in
+      --volname)
+        shift
+        VOL=${1}
+      ;;
+      *)
         shift
-        done
+        break
+      ;;
+    esac
+    shift
+  done
 }
 
 function delete_brick_fcontext()
 {
-        volname=$1
-
-        # grab the path for each local brick
-        brickdirs=$(grep '^path=' /var/lib/glusterd/vols/${volname}/bricks/* | cut -d= -f 2)
+  local volname=$1
+  local fctx
+  local list=()
 
-        for b in $brickdirs
-        do
-                # remove the file context associated with the brick path
-                semanage fcontext --delete $b\(/.*\)?
-        done
+  fctx="$(semanage fcontext --list -C)"
+  # grab the path for each local brick
+  brickpath="/var/lib/glusterd/vols/${volname}/bricks/"
+  brickdirs=$(find "${brickpath}" -type f -exec grep '^path=' {} \; | \
+    cut -d= -f 2 | sort -u)
+  for b in ${brickdirs}
+  do
+    pattern="${b}(/.*)?"
+    echo "${fctx}" | grep "^${pattern}\s" >/dev/null
+    if [[ $? -eq 0 ]]; then
+      list+=("${pattern}")
+    fi
+  done
+  if [[ ${#list[@]} -gt 0 ]]; then
+    printf 'fcontext --delete %s\n' "${list[@]}" | semanage -i -
+  fi
+  for b in ${brickdirs}
+  do
+    restorecon -R "${b}"
+  done
 }
 
 SELINUX_STATE=$(which getenforce && getenforce)
 [ "${SELINUX_STATE}" = 'Disabled' ] && exit 0
 
-parse_args $@
-[ -z "$VOL" ] && exit 1
+parse_args "$@"
+[ -z "${VOL}" ] && exit 1
 
-delete_brick_fcontext $VOL
+delete_brick_fcontext "${VOL}"
 
 # failure to delete the fcontext is not fatal
 exit 0
diff --git a/extras/hook-scripts/set/post/Makefile.am b/extras/hook-scripts/set/post/Makefile.am
index cea579cb2d9..506a25a8666 100644
--- a/extras/hook-scripts/set/post/Makefile.am
+++ b/extras/hook-scripts/set/post/Makefile.am
@@ -1,4 +1,6 @@
 EXTRA_DIST = S30samba-set.sh S32gluster_enable_shared_storage.sh
 
 hookdir = $(GLUSTERD_WORKDIR)/hooks/1/set/post/
+if WITH_SERVER
 hook_SCRIPTS = $(EXTRA_DIST)
+endif
diff --git a/extras/hook-scripts/set/post/S30samba-set.sh b/extras/hook-scripts/set/post/S30samba-set.sh
index 97d067fc33f..854f131f6c8 100755
--- a/extras/hook-scripts/set/post/S30samba-set.sh
+++ b/extras/hook-scripts/set/post/S30samba-set.sh
@@ -28,7 +28,7 @@ USERSMB_SET=""
 USERCIFS_SET=""
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  --name $PROGNAME -o "o:" -- $@)
+        ARGS=$(getopt -o 'o:' -l $OPTSPEC -n $PROGNAME -- "$@")
         eval set -- "$ARGS"
 
         while true; do
@@ -89,7 +89,7 @@ function add_samba_share () {
         STRING+="glusterfs:loglevel = 7\n"
         STRING+="path = /\n"
         STRING+="read only = no\n"
-        STRING+="guest ok = yes\n"
+        STRING+="kernel share modes = no\n"
         printf "$STRING"  >> ${CONFIGFILE}
 }
 
@@ -103,9 +103,9 @@ function sighup_samba () {
         fi
 }
 
-function del_samba_share () {
+function deactivate_samba_share () {
         volname=$1
-        sed -i "/\[gluster-$volname\]/,/^$/d" ${CONFIGFILE}
+        sed -i -e '/^\[gluster-'"$volname"'\]/{ :a' -e 'n; /available = no/H; /^$/!{$!ba;}; x; /./!{ s/^/available = no/; $!{G;x}; $H; }; s/.*//; x; };' ${CONFIGFILE}
 }
 
 function is_volume_started () {
@@ -123,29 +123,39 @@ function get_smb () {
         usersmbvalue=$(grep user.smb $GLUSTERD_WORKDIR/vols/"$volname"/info |\
                        cut -d"=" -f2)
 
-        if [[ $usercifsvalue = "disable" || $usersmbvalue = "disable" ]]; then
-                uservalue="disable"
+        if [ -n "$usercifsvalue" ]; then
+                if [ "$usercifsvalue" = "disable" ] || [ "$usercifsvalue" = "off" ]; then
+                        uservalue="disable"
+                fi
         fi
+
+        if [ -n "$usersmbvalue" ]; then
+                if [ "$usersmbvalue" = "disable" ] || [ "$usersmbvalue" = "off" ]; then
+                        uservalue="disable"
+                fi
+        fi
+
         echo "$uservalue"
 }
 
-parse_args $@
-if [ "0" = $(is_volume_started "$VOL") ]; then
+parse_args "$@"
+if [ "0" = "$(is_volume_started "$VOL")" ]; then
     exit 0
 fi
 
 
-if [[ "$USERCIFS_SET" = "YES" || "$USERSMB_SET" = "YES" ]]; then
+if [ "$USERCIFS_SET" = "YES" ] || [ "$USERSMB_SET" = "YES" ]; then
     #Find smb.conf, smbd pid directory and smbd logfile path
     find_config_info
 
-    if [ $(get_smb "$VOL") = "disable" ]; then
-        del_samba_share $VOL
-        sighup_samba
+    if [ "$(get_smb "$VOL")" = "disable" ]; then
+        deactivate_samba_share $VOL
     else
         if ! grep --quiet "\[gluster-$VOL\]" ${CONFIGFILE} ; then
             add_samba_share $VOL
-            sighup_samba
+        else
+            sed -i '/\[gluster-'"$VOL"'\]/,/^$/!b;/available = no/d' ${CONFIGFILE}
         fi
     fi
+    sighup_samba
 fi
diff --git a/extras/hook-scripts/set/post/S32gluster_enable_shared_storage.sh b/extras/hook-scripts/set/post/S32gluster_enable_shared_storage.sh
index c0aa73548fd..1f2564b44ff 100755
--- a/extras/hook-scripts/set/post/S32gluster_enable_shared_storage.sh
+++ b/extras/hook-scripts/set/post/S32gluster_enable_shared_storage.sh
@@ -79,9 +79,9 @@ done
 
 if [ "$option" == "disable" ]; then
     # Unmount the volume on all the nodes
-    umount /var/run/gluster/shared_storage
-    cat /etc/fstab  | grep -v "gluster_shared_storage /var/run/gluster/shared_storage/" > /var/run/gluster/fstab.tmp
-    mv /var/run/gluster/fstab.tmp /etc/fstab
+    umount /run/gluster/shared_storage
+    cat /etc/fstab  | grep -v "gluster_shared_storage /run/gluster/shared_storage/" > /run/gluster/fstab.tmp
+    mv /run/gluster/fstab.tmp /etc/fstab
 fi
 
 if [ "$is_originator" == 1 ]; then
@@ -104,8 +104,15 @@ function check_volume_status()
     echo $status
 }
 
-mount_cmd="mount -t glusterfs "$local_node_hostname":/gluster_shared_storage \
-           /var/run/gluster/shared_storage"
+key=`echo $5 | cut -d '=' -f 1`
+val=`echo $5 | cut -d '=' -f 2`
+if [ "$key" == "transport.address-family" ]; then
+    mount_cmd="mount -t glusterfs -o xlator-option=transport.address-family=inet6 \
+               $local_node_hostname:/gluster_shared_storage /run/gluster/shared_storage"
+else
+    mount_cmd="mount -t glusterfs $local_node_hostname:/gluster_shared_storage \
+           /run/gluster/shared_storage"
+fi
 
 if [ "$option" == "enable" ]; then
     retry=0;
@@ -117,13 +124,13 @@ if [ "$option" == "enable" ]; then
         if [ "$retry" == 3 ]; then
             break;
         fi
-        status = check_volume_status;
+        status=$(check_volume_status)
     done
     # Mount the volume on all the nodes
-    umount /var/run/gluster/shared_storage
-    mkdir -p /var/run/gluster/shared_storage
+    umount /run/gluster/shared_storage
+    mkdir -p /run/gluster/shared_storage
     $mount_cmd
-    cp /etc/fstab /var/run/gluster/fstab.tmp
-    echo "$local_node_hostname:/gluster_shared_storage /var/run/gluster/shared_storage/ glusterfs defaults        0 0" >> /var/run/gluster/fstab.tmp
-    mv /var/run/gluster/fstab.tmp /etc/fstab
+    cp /etc/fstab /run/gluster/fstab.tmp
+    echo "$local_node_hostname:/gluster_shared_storage /run/gluster/shared_storage/ glusterfs defaults        0 0" >> /run/gluster/fstab.tmp
+    mv /run/gluster/fstab.tmp /etc/fstab
 fi
diff --git a/extras/hook-scripts/start/post/Makefile.am b/extras/hook-scripts/start/post/Makefile.am
index 384a5822a0c..792019d3c9f 100644
--- a/extras/hook-scripts/start/post/Makefile.am
+++ b/extras/hook-scripts/start/post/Makefile.am
@@ -1,4 +1,6 @@
-EXTRA_DIST = S29CTDBsetup.sh S30samba-start.sh
+EXTRA_DIST = S29CTDBsetup.sh S30samba-start.sh S31ganesha-start.sh
 
 hookdir = $(GLUSTERD_WORKDIR)/hooks/1/start/post/
+if WITH_SERVER
 hook_SCRIPTS = $(EXTRA_DIST)
+endif
diff --git a/extras/hook-scripts/start/post/S29CTDBsetup.sh b/extras/hook-scripts/start/post/S29CTDBsetup.sh
index 4265cba54ee..69a0d89a3eb 100755
--- a/extras/hook-scripts/start/post/S29CTDBsetup.sh
+++ b/extras/hook-scripts/start/post/S29CTDBsetup.sh
@@ -9,10 +9,14 @@ CTDB_MNT=/gluster/lock
 # Make sure ping-timeout is not default for CTDB volume
 PING_TIMEOUT_SECS=10
 PROGNAME="ctdb"
-OPTSPEC="volname:"
+OPTSPEC="volname:,gd-workdir:,version:,volume-op:,first:"
 HOSTNAME=`hostname`
 MNTOPTS="_netdev,transport=tcp,xlator-option=*client*.ping-timeout=${PING_TIMEOUT_SECS}"
 VOL=
+GLUSTERD_WORKDIR=
+VERSION=
+VOLUME_OP=
+FIRST=
 # $META is the volume that will be used by CTDB as a shared filesystem.
 # It is not desirable to use this volume for storing 'data' as well.
 # META is set to 'all' (viz. a keyword and hence not a legal volume name)
@@ -21,7 +25,7 @@ VOL=
 META="all"
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+        ARGS=$(getopt -o '' -l $OPTSPEC -n $PROGNAME -- "$@")
         eval set -- "$ARGS"
 
         while true; do
@@ -29,13 +33,27 @@ function parse_args () {
                 --volname)
                     shift
                     VOL=$1
-                ;;
-
+                    ;;
+                --gd-workdir)
+                    shift
+                    GLUSTERD_WORKDIR=$1
+                    ;;
+                --version)
+                    shift
+                    VERSION=$1
+                    ;;
+                --volume-op)
+                    shift
+                    VOLUME_OP=$1
+                    ;;
+                --first)
+                    shift
+                    FIRST=$1
+                    ;;
                 *)
-                     shift
-                     break
-                ;;
-
+                    shift
+                    break
+                    ;;
             esac
 
             shift
@@ -55,7 +73,7 @@ function add_fstab_entry () {
         fi
 }
 
-parse_args $@
+parse_args "$@"
 if [ "$META" = "$VOL" ]
 then
         mkdir -p $CTDB_MNT
diff --git a/extras/hook-scripts/start/post/S30samba-start.sh b/extras/hook-scripts/start/post/S30samba-start.sh
index 3e0f2573b60..cac0cbf1464 100755
--- a/extras/hook-scripts/start/post/S30samba-start.sh
+++ b/extras/hook-scripts/start/post/S30samba-start.sh
@@ -21,15 +21,18 @@
 #volume.
 
 PROGNAME="Ssamba-start"
-OPTSPEC="volname:,gd-workdir:"
+OPTSPEC="volname:,gd-workdir:,version:,volume-op:,first:"
 VOL=
 CONFIGFILE=
 LOGFILEBASE=
 PIDDIR=
 GLUSTERD_WORKDIR=
+VERSION=
+VOLUME_OP=
+FIRST=
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+        ARGS=$(getopt -o '' -l $OPTSPEC -n $PROGNAME -- "$@")
         eval set -- "$ARGS"
 
         while true; do
@@ -42,24 +45,37 @@ function parse_args () {
                     shift
                     GLUSTERD_WORKDIR=$1
                     ;;
+                --version)
+                    shift
+                    VERSION=$1
+                    ;;
+                --volume-op)
+                    shift
+                    VOLUME_OP=$1
+                    ;;
+                --first)
+                    shift
+                    FIRST=$1
+                    ;;
                 *)
                     shift
                     break
                     ;;
             esac
+
             shift
         done
 }
 
 function find_config_info () {
-        cmdout=`smbd -b | grep smb.conf`
-        if [ $? -ne 0 ];then
+        cmdout=$(smbd -b 2> /dev/null)
+        CONFIGFILE=$(echo "$cmdout" | grep CONFIGFILE | awk '{print $2}')
+        if [ -z "$CONFIGFILE" ]; then
                 echo "Samba is not installed"
                 exit 1
         fi
-        CONFIGFILE=`echo $cmdout | awk {'print $2'}`
-        PIDDIR=`smbd -b | grep PIDDIR | awk {'print $2'}`
-        LOGFILEBASE=`smbd -b | grep 'LOGFILEBASE' | awk '{print $2}'`
+        PIDDIR=$(echo "$cmdout" | grep PIDDIR | awk '{print $2}')
+        LOGFILEBASE=$(echo "$cmdout" | grep 'LOGFILEBASE' | awk '{print $2}')
 }
 
 function add_samba_share () {
@@ -72,12 +88,12 @@ function add_samba_share () {
         STRING+="glusterfs:loglevel = 7\n"
         STRING+="path = /\n"
         STRING+="read only = no\n"
-        STRING+="guest ok = yes\n"
-        printf "$STRING"  >> ${CONFIGFILE}
+        STRING+="kernel share modes = no\n"
+        printf "$STRING"  >> "${CONFIGFILE}"
 }
 
 function sighup_samba () {
-        pid=`cat ${PIDDIR}/smbd.pid`
+        pid=$(cat "${PIDDIR}/smbd.pid" 2> /dev/null)
         if [ "x$pid" != "x" ]
         then
                 kill -HUP "$pid";
@@ -90,26 +106,40 @@ function get_smb () {
         volname=$1
         uservalue=
 
-        usercifsvalue=$(grep user.cifs $GLUSTERD_WORKDIR/vols/"$volname"/info |\
+        usercifsvalue=$(grep user.cifs "$GLUSTERD_WORKDIR"/vols/"$volname"/info |\
                         cut -d"=" -f2)
-        usersmbvalue=$(grep user.smb $GLUSTERD_WORKDIR/vols/"$volname"/info |\
+        usersmbvalue=$(grep user.smb "$GLUSTERD_WORKDIR"/vols/"$volname"/info |\
                        cut -d"=" -f2)
 
-        if [[ $usercifsvalue = "disable" || $usersmbvalue = "disable" ]]; then
-                uservalue="disable"
+        if [ -n "$usercifsvalue" ]; then
+                if [ "$usercifsvalue" = "enable" ] || [ "$usercifsvalue" = "on" ]; then
+                        uservalue="enable"
+                fi
+        fi
+
+        if [ -n "$usersmbvalue" ]; then
+                if [ "$usersmbvalue" = "enable" ] || [ "$usersmbvalue" = "on" ]; then
+                        uservalue="enable"
+                fi
         fi
+
         echo "$uservalue"
 }
 
-parse_args $@
-if [ "$(get_smb "$VOL")" = "disable" ]; then
+parse_args "$@"
+
+value=$(get_smb "$VOL")
+
+if [ -z "$value" ] || [ "$value" != "enable" ]; then
         exit 0
 fi
 
 #Find smb.conf, smbd pid directory and smbd logfile path
 find_config_info
 
-if ! grep --quiet "\[gluster-$VOL\]" ${CONFIGFILE} ; then
-        add_samba_share $VOL
-        sighup_samba
+if ! grep --quiet "\[gluster-$VOL\]" "${CONFIGFILE}" ; then
+        add_samba_share "$VOL"
+else
+        sed -i '/\[gluster-'"$VOL"'\]/,/^$/!b;/available = no/d' "${CONFIGFILE}"
 fi
+sighup_samba
diff --git a/extras/hook-scripts/start/post/S31ganesha-start.sh b/extras/hook-scripts/start/post/S31ganesha-start.sh
new file mode 100755
index 00000000000..7ad6f23ad06
--- /dev/null
+++ b/extras/hook-scripts/start/post/S31ganesha-start.sh
@@ -0,0 +1,122 @@
+#!/bin/bash
+PROGNAME="Sganesha-start"
+OPTSPEC="volname:,gd-workdir:"
+VOL=
+declare -i EXPORT_ID
+ganesha_key="ganesha.enable"
+GANESHA_DIR="/run/gluster/shared_storage/nfs-ganesha"
+CONF1="$GANESHA_DIR/ganesha.conf"
+GLUSTERD_WORKDIR=
+
+function parse_args ()
+{
+        ARGS=$(getopt -l $OPTSPEC  -o "o" -name $PROGNAME $@)
+        eval set -- "$ARGS"
+
+        while true; do
+            case $1 in
+                --volname)
+                    shift
+                    VOL=$1
+                    ;;
+                --gd-workdir)
+                    shift
+                    GLUSTERD_WORKDIR=$1
+                    ;;
+                *)
+                    shift
+                    break
+                    ;;
+            esac
+            shift
+        done
+}
+
+
+
+#This function generates a new export entry as export.volume_name.conf
+function write_conf()
+{
+echo -e "# WARNING : Using Gluster CLI will overwrite manual
+# changes made to this file. To avoid it, edit the
+# file, copy it over to all the NFS-Ganesha nodes
+# and run ganesha-ha.sh --refresh-config."
+
+echo "EXPORT{"
+echo "      Export_Id = 2;"
+echo "      Path = \"/$VOL\";"
+echo "      FSAL {"
+echo "           name = \"GLUSTER\";"
+echo "           hostname=\"localhost\";"
+echo "           volume=\"$VOL\";"
+echo "           }"
+echo "      Access_type = RW;"
+echo "      Disable_ACL = true;"
+echo "      Squash=\"No_root_squash\";"
+echo "      Pseudo=\"/$VOL\";"
+echo "      Protocols = \"3\", \"4\" ;"
+echo "      Transports = \"UDP\",\"TCP\";"
+echo "      SecType = \"sys\";"
+echo "}"
+}
+
+#It adds the export dynamically by sending dbus signals
+function export_add()
+{
+        dbus-send --print-reply --system --dest=org.ganesha.nfsd \
+/org/ganesha/nfsd/ExportMgr org.ganesha.nfsd.exportmgr.AddExport \
+string:$GANESHA_DIR/exports/export.$VOL.conf string:"EXPORT(Export_Id=$EXPORT_ID)"
+
+}
+
+# based on src/scripts/ganeshactl/Ganesha/export_mgr.py
+function is_exported()
+{
+        local volume="${1}"
+
+        dbus-send --type=method_call --print-reply --system \
+                  --dest=org.ganesha.nfsd /org/ganesha/nfsd/ExportMgr \
+                  org.ganesha.nfsd.exportmgr.ShowExports \
+            | grep -w -q "/${volume}"
+
+        return $?
+}
+
+# Check the info file (contains the volume options) to see if Ganesha is
+# enabled for this volume.
+function ganesha_enabled()
+{
+        local volume="${1}"
+        local info_file="${GLUSTERD_WORKDIR}/vols/${VOL}/info"
+        local enabled="off"
+
+        enabled=$(grep -w ${ganesha_key} ${info_file} | cut -d"=" -f2)
+
+        [ "${enabled}" == "on" ]
+
+        return $?
+}
+
+parse_args $@
+
+if ganesha_enabled ${VOL} && ! is_exported ${VOL}
+then
+        if [ ! -e ${GANESHA_DIR}/exports/export.${VOL}.conf ]
+        then
+                #Remove export entry from nfs-ganesha.conf
+                sed -i /$VOL.conf/d  $CONF1
+                write_conf ${VOL} > ${GANESHA_DIR}/exports/export.${VOL}.conf
+                EXPORT_ID=`cat $GANESHA_DIR/.export_added`
+                EXPORT_ID=EXPORT_ID+1
+                echo $EXPORT_ID > $GANESHA_DIR/.export_added
+                sed -i s/Export_Id.*/"Export_Id=$EXPORT_ID;"/ \
+                        $GANESHA_DIR/exports/export.$VOL.conf
+                echo "%include \"$GANESHA_DIR/exports/export.$VOL.conf\"" >> $CONF1
+        else
+                EXPORT_ID=$(grep ^[[:space:]]*Export_Id $GANESHA_DIR/exports/export.$VOL.conf |\
+                          awk -F"[=,;]" '{print $2}' | tr -d '[[:space:]]')
+        fi
+        export_add $VOL
+fi
+
+exit 0
diff --git a/extras/hook-scripts/stop/pre/Makefile.am b/extras/hook-scripts/stop/pre/Makefile.am
index bf63e7393d3..9e8d1565e93 100644
--- a/extras/hook-scripts/stop/pre/Makefile.am
+++ b/extras/hook-scripts/stop/pre/Makefile.am
@@ -1,4 +1,6 @@
 EXTRA_DIST =  S29CTDB-teardown.sh S30samba-stop.sh
 
 hookdir = $(GLUSTERD_WORKDIR)/hooks/1/stop/pre/
+if WITH_SERVER
 hook_SCRIPTS = $(EXTRA_DIST)
+endif
diff --git a/extras/hook-scripts/stop/pre/S29CTDB-teardown.sh b/extras/hook-scripts/stop/pre/S29CTDB-teardown.sh
index 5fb49bd9e97..0975a00f18d 100755
--- a/extras/hook-scripts/stop/pre/S29CTDB-teardown.sh
+++ b/extras/hook-scripts/stop/pre/S29CTDB-teardown.sh
@@ -2,8 +2,9 @@
 
 CTDB_MNT=/gluster/lock
 PROGNAME="ctdb"
-OPTSPEC="volname:"
+OPTSPEC="volname:,last:"
 VOL=
+LAST=
 # $META is the volume that will be used by CTDB as a shared filesystem.
 # It is not desirable to use this volume for storing 'data' as well.
 # META is set to 'all' (viz. a keyword and hence not a legal volume name)
@@ -12,7 +13,7 @@ VOL=
 META="all"
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+        ARGS=$(getopt -o '' -l $OPTSPEC -n $PROGNAME -- "$@")
         eval set -- "$ARGS"
 
         while true; do
@@ -20,15 +21,16 @@ function parse_args () {
                 --volname)
                     shift
                     VOL=$1
-                ;;
-
+                    ;;
+                --last)
+                    shift
+                    LAST=$1
+                    ;;
                 *)
-                     shift
-                     break
-                ;;
-
+                    shift
+                    break
+                    ;;
             esac
-
             shift
         done
 }
@@ -51,7 +53,7 @@ function remove_fstab_entry () {
         fi
 }
 
-parse_args $@
+parse_args "$@"
 if [ "$META" = "$VOL" ]
 then
         umount "$CTDB_MNT"
diff --git a/extras/hook-scripts/stop/pre/S30samba-stop.sh b/extras/hook-scripts/stop/pre/S30samba-stop.sh
index 62cf7d1e0d2..ea799381d62 100755
--- a/extras/hook-scripts/stop/pre/S30samba-stop.sh
+++ b/extras/hook-scripts/stop/pre/S30samba-stop.sh
@@ -16,27 +16,33 @@
 #event by removing the volume related entries(if any) in smb.conf file.
 
 PROGNAME="Ssamba-stop"
-OPTSPEC="volname:"
+OPTSPEC="volname:,last:"
 VOL=
 CONFIGFILE=
 PIDDIR=
+LAST=
 
 function parse_args () {
-        ARGS=$(getopt -l $OPTSPEC  -name $PROGNAME $@)
+        ARGS=$(getopt -o '' -l $OPTSPEC -n $PROGNAME -- "$@")
         eval set -- "$ARGS"
 
         while true; do
-        case $1 in
-        --volname)
-         shift
-         VOL=$1
-         ;;
-        *)
-         shift
-         break
-         ;;
-        esac
-        shift
+            case $1 in
+                --volname)
+                    shift
+                    VOL=$1
+                    ;;
+                --last)
+                    shift
+                    LAST=$1
+                    ;;
+                *)
+                    shift
+                    break
+                    ;;
+            esac
+
+            shift
         done
 }
 
@@ -46,13 +52,13 @@ function find_config_info () {
                 echo "Samba is not installed"
                 exit 1
         fi
-        CONFIGFILE=`echo $cmdout | awk {'print $2'}`
-        PIDDIR=`smbd -b | grep PIDDIR | awk {'print $2'}`
+        CONFIGFILE=`echo $cmdout | awk '{print $2}'`
+        PIDDIR=`smbd -b | grep PIDDIR | awk '{print $2}'`
 }
 
-function del_samba_share () {
+function deactivate_samba_share () {
         volname=$1
-        sed -i "/\[gluster-$volname\]/,/^$/d" ${CONFIGFILE}
+        sed -i -e '/^\[gluster-'"$volname"'\]/{ :a' -e 'n; /available = no/H; /^$/!{$!ba;}; x; /./!{ s/^/available = no/; $!{G;x}; $H; }; s/.*//; x; };' ${CONFIGFILE}
 }
 
 function sighup_samba () {
@@ -65,7 +71,7 @@ function sighup_samba () {
         fi
 }
 
-parse_args $@
+parse_args "$@"
 find_config_info
-del_samba_share $VOL
+deactivate_samba_share $VOL
 sighup_samba
diff --git a/extras/identify-hangs.sh b/extras/identify-hangs.sh
new file mode 100755
index 00000000000..ebc6bf144aa
--- /dev/null
+++ b/extras/identify-hangs.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+function get_statedump_fnames_without_timestamps
+{
+    ls | grep -E "[.]dump[.][0-9][0-9]*" | cut -f1-3 -d'.' | sort -u
+}
+
+function get_non_uniq_fields
+{
+    local statedump_fname_prefix=$1
+    print_stack_lkowner_unique_in_one_line "$statedump_fname_prefix" | sort | uniq -c | grep -vE "^\s*1 " | awk '{$1="repeats="$1; print $0}'
+}
+
+function print_stack_lkowner_unique_in_one_line
+{
+    local statedump_fname_prefix=$1
+    sed -e '/./{H;$!d;}' -e 'x;/unique=/!d;/stack=/!d;/lk-owner=/!d;/pid=/!d;' "${statedump_fname_prefix}"* | grep -E "(stack|lk-owner|unique|pid)=" | paste -d " " - - - -
+}
+
+function get_stacks_that_appear_in_multiple_statedumps
+{
+    #If a stack with same 'unique/lk-owner/stack' appears in multiple statedumps
+    #print the stack
+    local statedump_fname_prefix=$1
+    while read -r non_uniq_stack;
+    do
+        if [ -z "$printed" ];
+        then
+            printed="1"
+        fi
+        echo "$statedump_fname_prefix" "$non_uniq_stack"
+    done < <(get_non_uniq_fields "$statedump_fname_prefix")
+}
+
+statedumpdir=${1}
+if [ -z "$statedumpdir" ];
+then
+    echo "Usage: $0 <statedump-dir>"
+    exit 1
+fi
+
+if [ ! -d "$statedumpdir" ];
+then
+    echo "$statedumpdir: Is not a directory"
+    echo "Usage: $0 <statedump-dir>"
+    exit 1
+fi
+
+cd "$statedumpdir" || exit 1
+for statedump_fname_prefix in $(get_statedump_fnames_without_timestamps);
+do
+    get_stacks_that_appear_in_multiple_statedumps "$statedump_fname_prefix"
+done | column -t
+echo "NOTE: stacks with lk-owner=\"\"/lk-owner=0000000000000000/unique=0 may not be hung frames and need further inspection" >&2
diff --git a/extras/init.d/Makefile.am b/extras/init.d/Makefile.am
index a9ac3b42d84..8d8cc69571a 100644
--- a/extras/init.d/Makefile.am
+++ b/extras/init.d/Makefile.am
@@ -1,7 +1,7 @@
 
-EXTRA_DIST = glusterd-Debian glusterd-FreeBSD glusterd-Redhat glusterd-SuSE \
-	glusterd.plist rhel5-load-fuse.modules \
-	glustereventsd-FreeBSD glustereventsd-Redhat glustereventsd-Debian
+EXTRA_DIST = glusterd-Debian glusterd-FreeBSD glusterd-Redhat \
+	glusterd-SuSE glusterd.plist glustereventsd-FreeBSD \
+	glustereventsd-Redhat glustereventsd-Debian
 
 CLEANFILES =
 
@@ -10,11 +10,12 @@ SYSTEMD_DIR = @systemddir@
 LAUNCHD_DIR = @launchddir@
 
 $(GF_DISTRIBUTION):
+if WITH_SERVER
 	@if [ ! -d $(SYSTEMD_DIR) ]; then \
 		$(mkdir_p) $(DESTDIR)$(INIT_DIR); \
 		$(INSTALL_PROGRAM) glusterd-$(GF_DISTRIBUTION) $(DESTDIR)$(INIT_DIR)/glusterd; \
 	fi
-
+endif
 if BUILD_EVENTS
 	@if [ ! -d $(SYSTEMD_DIR) ]; then \
 		$(mkdir_p) $(DESTDIR)$(INIT_DIR); \
diff --git a/extras/init.d/rhel5-load-fuse.modules b/extras/init.d/rhel5-load-fuse.modules
deleted file mode 100755
index ee194db99b8..00000000000
--- a/extras/init.d/rhel5-load-fuse.modules
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh
-#
-# fusermount-glusterfs requires the /dev/fuse character device. The fuse module
-# provides this and is loaded on demand in newer Linux distributions.
-#
-
-[ -c /dev/fuse ] || /sbin/modprobe fuse
diff --git a/extras/mount-shared-storage.sh b/extras/mount-shared-storage.sh
index 3645a0f42fd..cc40e13c3e3 100755
--- a/extras/mount-shared-storage.sh
+++ b/extras/mount-shared-storage.sh
@@ -2,35 +2,38 @@
 #Post reboot there is a chance in which mounting of shared storage will fail
 #This will impact starting of features like NFS-Ganesha. So this script will
 #try to mount the shared storage if it fails
-#TODO : Do it for other glusterfs clients in /etc/fstab
 
-volume="gluster_shared_storage"
-mp="/var/run/gluster/shared_storage"
-#check if there is fstab entry for shared storage
-gfc=$(sed -e 's/#.$//' </etc/fstab | grep -c $volume)
-if [ $gfc -eq 0 ]
-then
-	exit 0
-fi
+exitStatus=0
 
-#check whether shared storage is mounted
-#if it is mounted then mount has inode value 1
-inode=$(ls -id $mp | awk '{print $1}')
+while IFS= read -r glm
+do
+	IFS=$' \t' read -r -a arr <<< "$glm"
 
-if [ $inode -eq 1 ]
-then
-	exit 0
-fi
+	#Validate storage type is glusterfs
+	if [ "${arr[2]}" == "glusterfs" ]
+	then
 
-mount -t glusterfs localhost:/$volume $mp
-#wait for few seconds
-sleep 5
+		#check whether shared storage is mounted
+		#if it is mounted then mountpoint -q will return a 0 success code
+		if mountpoint -q "${arr[1]}"
+		then
+			echo "${arr[1]} is already mounted"
+			continue
+		fi
 
-#recheck mount got succeed
-inode=$(ls -id $mp | awk '{print $1}')
-if [ $inode -eq 1 ]
-then
-	exit 0
-else
-	exit 1
-fi
+		mount -t glusterfs -o "${arr[3]}" "${arr[0]}" "${arr[1]}"
+		#wait for few seconds
+		sleep 10
+
+		#recheck mount got succeed
+		if mountpoint -q "${arr[1]}"
+		then
+			echo "${arr[1]} has been mounted"
+			continue
+		else
+			echo "${arr[1]} failed to mount"
+			exitStatus=1
+		fi
+	fi
+done <<< "$(sed '/^#/ d' </etc/fstab | grep 'glusterfs')"
+exit $exitStatus
diff --git a/extras/ocf/volume.in b/extras/ocf/volume.in
index de05373b9e3..76cc649e55f 100755
--- a/extras/ocf/volume.in
+++ b/extras/ocf/volume.in
@@ -6,6 +6,7 @@
 #               HA resource
 #
 # Authors:      Florian Haas (hastexo Professional Services GmbH)
+#               Jiri Lunacek (Hosting90 Systems s.r.o.)
 #
 # License:      GNU General Public License (GPL)
 
@@ -54,6 +55,14 @@ must have clone ordering enabled.
       <shortdesc lang="en">gluster executable</shortdesc>
       <content type="string" default="$OCF_RESKEY_binary_default"/>
     </parameter>
+    <parameter name="peer_map">
+      <longdesc lang="en">
+      Mapping of hostname - peer name in the gluster cluster
+      in format hostname1:peername1,hostname2:peername2,...
+      </longdesc>
+      <shortdesc lang="en">gluster peer map</shortdesc>
+      <content type="string" default=""/>
+    </parameter>
   </parameters>
   <actions>
     <action name="start"        timeout="20" />
@@ -68,9 +77,13 @@ EOF
 
 }
 
+if [ -n "${OCF_RESKEY_peer_map}" ]; then
+    SHORTHOSTNAME=`echo "${OCF_RESKEY_peer_map}" | egrep -o "$SHORTHOSTNAME\:[^,]+" | awk -F: '{print $2}'`
+fi
+
 volume_getdir() {
     local voldir
-    voldir="@sysconfdir@/glusterd/vols/${OCF_RESKEY_volname}"
+    voldir="@GLUSTERD_WORKDIR@/vols/${OCF_RESKEY_volname}"
 
     [ -d ${voldir} ] || return 1
 
@@ -108,6 +121,10 @@ volume_getpids() {
 
     volpid_dir=`volume_getpid_dir`
     bricks=`volume_getbricks`
+    
+    if [ -z "$bricks" ]; then
+        return 1
+    fi
 
     for brick in ${bricks}; do
 	pidfile="${volpid_dir}/${SHORTHOSTNAME}${brick}.pid"
@@ -214,6 +231,11 @@ volume_validate_all() {
 
     # Test for required binaries
     check_binary $OCF_RESKEY_binary
+	
+	if [ -z "$SHORTHOSTNAME" ]; then
+		ocf_log err 'Unable to get host in node map'
+		return $OCF_ERR_CONFIGURED
+	fi
 
     return $OCF_SUCCESS
 }
diff --git a/extras/profiler/glusterfs-profiler b/extras/profiler/glusterfs-profiler
index 65d445864aa..aaafd088648 100755
--- a/extras/profiler/glusterfs-profiler
+++ b/extras/profiler/glusterfs-profiler
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 
 #  Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com>
 #  This file is part of GlusterFS.
@@ -291,7 +291,7 @@ class Texttable:
         s = "%s%s%s" % (horiz, [horiz, self._char_corner][self._has_vlines()],
             horiz)
         # build the line
-        l = string.join([horiz*n for n in self._width], s)
+        l = s.join([horiz*n for n in self._width])
         # add border if needed
         if self._has_border():
             l = "%s%s%s%s%s\n" % (self._char_corner, horiz, l, horiz,
diff --git a/extras/prot_filter.py b/extras/prot_filter.py
deleted file mode 100755
index 7dccacf155e..00000000000
--- a/extras/prot_filter.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/python
-
-"""
-  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-"""
-
-"""
-  INSTRUCTIONS
-  Put this in /usr/lib64/glusterfs/$version/filter to have it run automatically,
-  or else you'll have to run it by hand every time you change the volume
-  configuration.  Give it a list of volume names on which to enable the
-  protection functionality; it will deliberately ignore client volfiles for
-  other volumes, and all server volfiles.  It *will* include internal client
-  volfiles such as those used for NFS or rebalance/self-heal; this is a
-  deliberate choice so that it will catch deletions from those sources as well.
-"""
-
-volume_list = [ "jdtest" ]
-
-import copy
-import string
-import sys
-import types
-
-class Translator:
-    def __init__ (self, name):
-        self.name = name
-        self.xl_type = ""
-        self.opts = {}
-        self.subvols = []
-        self.dumped = False
-    def __repr__ (self):
-        return "<Translator %s>" % self.name
-
-def load (path):
-    # If it's a string, open it; otherwise, assume it's already a
-    # file-like object (most notably from urllib*).
-    if type(path) in types.StringTypes:
-        fp = file(path,"r")
-    else:
-        fp = path
-    all_xlators = {}
-    xlator = None
-    last_xlator = None
-    while True:
-        text = fp.readline()
-        if text == "":
-            break
-        text = text.split()
-        if not len(text):
-            continue
-        if text[0] == "volume":
-            if xlator:
-                raise RuntimeError, "nested volume definition"
-            xlator = Translator(text[1])
-            continue
-        if not xlator:
-            raise RuntimeError, "text outside volume definition"
-        if text[0] == "type":
-            xlator.xl_type = text[1]
-            continue
-        if text[0] == "option":
-            xlator.opts[text[1]] = string.join(text[2:])
-            continue
-        if text[0] == "subvolumes":
-            for sv in text[1:]:
-                xlator.subvols.append(all_xlators[sv])
-            continue
-        if text[0] == "end-volume":
-            all_xlators[xlator.name] = xlator
-            last_xlator = xlator
-            xlator = None
-            continue
-        raise RuntimeError, "unrecognized keyword %s" % text[0]
-    if xlator:
-        raise RuntimeError, "unclosed volume definition"
-    return all_xlators, last_xlator
-
-def generate (graph, last, stream=sys.stdout):
-    for sv in last.subvols:
-        if not sv.dumped:
-            generate(graph,sv,stream)
-            print >> stream, ""
-            sv.dumped = True
-    print >> stream, "volume %s" % last.name
-    print >> stream, "    type %s" % last.xl_type
-    for k, v in last.opts.iteritems():
-        print >> stream, "    option %s %s" % (k, v)
-    if last.subvols:
-        print >> stream, "    subvolumes %s" % string.join(
-            [ sv.name for sv in last.subvols ])
-    print >> stream, "end-volume"
-
-def push_filter (graph, old_xl, filt_type, opts={}):
-    new_type = "-" + filt_type.split("/")[1]
-    old_type = "-" + old_xl.xl_type.split("/")[1]
-    pos = old_xl.name.find(old_type)
-    if pos >= 0:
-        new_name = old_xl.name
-        old_name = new_name[:pos] + new_type + new_name[len(old_type)+pos:]
-    else:
-        new_name = old_xl.name + old_type
-        old_name = old_xl.name + new_type
-    new_xl = Translator(new_name)
-    new_xl.xl_type = old_xl.xl_type
-    new_xl.opts = old_xl.opts
-    new_xl.subvols = old_xl.subvols
-    graph[new_xl.name] = new_xl
-    old_xl.name = old_name
-    old_xl.xl_type = filt_type
-    old_xl.opts = opts
-    old_xl.subvols = [new_xl]
-    graph[old_xl.name] = old_xl
-
-if __name__ == "__main__":
-    path = sys.argv[1]
-    # Alow an override for debugging.
-    for extra in sys.argv[2:]:
-        volume_list.append(extra)
-    graph, last = load(path)
-    for v in volume_list:
-        if graph.has_key(v):
-            break
-    else:
-        print "No configured volumes found - aborting."
-        sys.exit(0)
-    for v in graph.values():
-        if v.xl_type == "cluster/distribute":
-            push_filter(graph,v,"features/prot_dht")
-        elif v.xl_type == "protocol/client":
-            push_filter(graph,v,"features/prot_client")
-    # We push debug/trace so that every fop gets a real frame, because DHT
-    # gets confused if STACK_WIND_TAIL causes certain fops to be invoked
-    # from anything other than a direct child.
-    for v in graph.values():
-        if v.xl_type == "features/prot_client":
-            push_filter(graph,v,"debug/trace")
-    generate(graph,last,stream=open(path,"w"))
diff --git a/extras/python/Makefile.am b/extras/python/Makefile.am
new file mode 100644
index 00000000000..7d81fa0319b
--- /dev/null
+++ b/extras/python/Makefile.am
@@ -0,0 +1,7 @@
+if HAVE_PYTHON
+# Install __init__.py into the Python site-packages area
+pypkgdir = @BUILD_PYTHON_SITE_PACKAGES@/gluster
+pypkg_PYTHON = __init__.py
+endif
+
+EXTRA_DIST = __init__.py
diff --git a/xlators/features/glupy/src/__init__.py.in b/extras/python/__init__.py
index 3ad9513f40e..3ad9513f40e 100644
--- a/xlators/features/glupy/src/__init__.py.in
+++ b/extras/python/__init__.py
diff --git a/extras/quota/log_accounting.sh b/extras/quota/log_accounting.sh
index 9c2381f6a95..e2dd87b84d7 100755
--- a/extras/quota/log_accounting.sh
+++ b/extras/quota/log_accounting.sh
@@ -1,4 +1,4 @@
-#!/usr/bin/bash
+#!/bin/bash
 # The script does an accounting of all directories using command 'du' and
 # using gluster. We can then compare the two to identify accounting mismatch
 # THere can be minor mismatch because gluster only accounts for the size of
diff --git a/extras/quota/quota_fsck.py b/extras/quota/quota_fsck.py
new file mode 100755
index 00000000000..e62f7fc52a3
--- /dev/null
+++ b/extras/quota/quota_fsck.py
@@ -0,0 +1,377 @@
+#!/usr/bin/python3
+# The following script enables, Detecting, Reporting and Fixing
+# anomalies in quota accounting. Run this script with -h option
+# for further details.
+
+'''
+   Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+'''
+from __future__ import print_function
+import os, sys, re
+from stat import *
+import subprocess
+import argparse
+import xattr
+
+aggr_size = {}
+verbose_mode = False
+mnt_path = None
+brick_path = None
+obj_fix_count = 0
+file_count = 0
+dir_count = 0
+
+#CONSTANTS
+KB = 1024
+MB = 1048576
+GB = 1048576 * 1024
+TB = 1048576 * 1048576
+
+QUOTA_VERBOSE = 0
+QUOTA_META_ABSENT = 1
+QUOTA_SIZE_MISMATCH = 2
+
+IS_DIRTY ='0x3100'
+IS_CLEAN ='0x3000'
+
+
+epilog_msg='''
+            The script attempts to find any gluster accounting issues in the
+            filesystem at the given subtree. The script crawls the given
+            subdirectory tree doing a stat for all files and compares the
+            size reported by gluster quota with the size reported by stat
+            calls. Any mismatch is reported. In addition integrity of marker
+            xattrs are verified.
+            '''
+
+def print_msg(log_type, path, xattr_dict = {}, stbuf = "", dir_size = None):
+    if log_type == QUOTA_VERBOSE:
+        print('%-24s %-60s\nxattr_values: %s\n%s\n' % ("Verbose", path, xattr_dict, stbuf))
+    elif log_type == QUOTA_META_ABSENT:
+        print('%-24s %-60s\n%s\n' % ("Quota-Meta Absent", path, xattr_dict))
+    elif log_type == QUOTA_SIZE_MISMATCH:
+        print("mismatch")
+        if dir_size is not None:
+            print('%24s %60s %12s %12s' % ("Size Mismatch", path,
+                xattr_dict, dir_size))
+        else:
+            print('%-24s %-60s %-12s %-12s' % ("Size Mismatch", path, xattr_dict,
+                   stbuf.st_size))
+
+def size_differs_lot(s1, s2):
+    '''
+    There could be minor accounting differences between the stat based
+    accounting and gluster accounting. To avoid these from throwing lot
+    of false positives in our logs. using a threshold of 1M for now.
+    TODO: For a deeply nested directory, at higher levels in hierarchy
+    differences may not be significant, hence this check needs to be improved.
+    '''
+    if abs(s1-s2) > 0:
+        return True
+    else:
+        return False
+
+def fix_hardlink_accounting(curr_dict, accounted_dict, curr_size):
+    '''
+            Hard links are messy.. we have to account them for their parent
+            directory. But, stop accounting at the most common ancestor.
+            Eg:
+                say we have 3 hardlinks : /d1/d2/h1, /d1/d3/h2 and /d1/h3
+
+            suppose we encounter the hard links h1 first , then h2 and then h3.
+            while accounting for h1, we account the size until root(d2->d1->/)
+            while accounting for h2, we need to account only till d3. (as d1
+            and / are accounted for this inode).
+            while accounting for h3 we should not account at all.. as all
+            its ancestors are already accounted for same inode.
+
+            curr_dict                : dict of hardlinks that were seen and
+                                       accounted by the current iteration.
+            accounted_dict           : dict of hardlinks that has already been
+                                       accounted for.
+
+            size                     : size of the object as accounted by the
+                                       curr_iteration.
+
+            Return vale:
+            curr_size                : size reduced by hardlink sizes for those
+                                       hardlinks that has already been accounted
+                                       in current subtree.
+            Also delete the duplicate link from curr_dict.
+    '''
+
+    dual_accounted_links = set(curr_dict.keys()) & set(accounted_dict.keys())
+    for link in dual_accounted_links:
+        curr_size = curr_size - curr_dict[link]
+        del curr_dict[link]
+    return curr_size
+
+
+def fix_xattr(file_name, mark_dirty):
+    global obj_fix_count
+    global mnt_path
+
+    if mnt_path is None:
+        return
+    if mark_dirty:
+        print("MARKING DIRTY: " + file_name)
+        out = subprocess.check_output (["/usr/bin/setfattr", "-n",
+                                       "trusted.glusterfs.quota.dirty",
+                                       "-v", IS_DIRTY, file_name])
+    rel_path = os.path.relpath(file_name, brick_path)
+    print("stat on "  + mnt_path + "/" + rel_path)
+    stbuf = os.lstat(mnt_path + "/" + rel_path)
+
+    obj_fix_count += 1
+
+def get_quota_xattr_brick(dpath):
+    out = subprocess.check_output (["/usr/bin/getfattr", "--no-dereference",
+                                    "-d", "-m.", "-e", "hex", dpath])
+    pairs = out.splitlines()
+
+    '''
+    Sample output to be parsed:
+    [root@dhcp35-100 mnt]# getfattr -d -m. -e hex /export/b1/B0/d14/d13/
+    # file: export/b1/B0/d14/d13/
+    security.selinux=0x756e636f6e66696e65645f753a6f626a6563745f723a7573725f743a733000
+    trusted.gfid=0xbae5e0d2d05043de9fd851d91ecf63e8
+    trusted.glusterfs.dht=0x000000010000000000000000ffffffff
+    trusted.glusterfs.dht.mds=0x00000000
+    trusted.glusterfs.quota.6a7675a3-b85a-40c5-830b-de9229d702ce.contri.39=0x00000000000000000000000000000000000000000000000e
+    trusted.glusterfs.quota.dirty=0x3000
+    trusted.glusterfs.quota.size.39=0x00000000000000000000000000000000000000000000000e
+    '''
+
+    '''
+    xattr_dict dictionary holds quota related xattrs
+    eg:
+    '''
+
+    xattr_dict = {}
+    xattr_dict['parents'] = {}
+
+    for xattr in pairs[1:]:
+        xattr = xattr.decode("utf-8")
+        xattr_key = xattr.split("=")[0]
+        if xattr_key == "":
+            # skip any empty lines
+            continue
+        elif not re.search("quota", xattr_key):
+            # skip all non quota xattr.
+            continue
+
+        xattr_value = xattr.split("=")[1]
+        if re.search("contri", xattr_key):
+
+            xattr_version = xattr_key.split(".")[5]
+            if 'version' not in xattr_dict:
+                xattr_dict['version'] = xattr_version
+            else:
+                if xattr_version != xattr_dict['version']:
+                   print("Multiple xattr version found")
+
+
+            cur_parent = xattr_key.split(".")[3]
+            if cur_parent not in xattr_dict['parents']:
+                xattr_dict['parents'][cur_parent] = {}
+
+            contri_dict = xattr_dict['parents'][cur_parent]
+            if len(xattr_value) == 34:
+                # 34 bytes implies file contri xattr
+                # contri format =0x< 16bytes file size><16bytes file count>
+                # size is obtained in iatt, file count = 1, dir count=0
+                contri_dict['contri_size'] = int(xattr_value[2:18], 16)
+                contri_dict['contri_file_count'] = int(xattr_value[18:34], 16)
+                contri_dict['contri_dir_count'] = 0
+            else:
+                # This is a directory contri.
+                contri_dict['contri_size'] = int(xattr_value[2:18], 16)
+                contri_dict['contri_file_count'] = int(xattr_value[18:34], 16)
+                contri_dict['contri_dir_count'] = int(xattr_value[34:], 16)
+
+        elif re.search("size", xattr_key):
+            xattr_dict['size'] = int(xattr_value[2:18], 16)
+            xattr_dict['file_count'] = int(xattr_value[18:34], 16)
+            xattr_dict['dir_count'] = int(xattr_value[34:], 16)
+        elif re.search("dirty", xattr_key):
+            if xattr_value == IS_CLEAN:
+                xattr_dict['dirty'] = False
+            elif xattr_value == IS_DIRTY:
+                xattr_dict['dirty'] = True
+        elif re.search("limit_objects", xattr_key):
+            xattr_dict['limit_objects'] = int(xattr_value[2:18], 16)
+        elif re.search("limit_set", xattr_key):
+            xattr_dict['limit_set'] = int(xattr_value[2:18], 16)
+
+    return xattr_dict
+
+def verify_file_xattr(path, stbuf = None):
+
+    global file_count
+    file_count += 1
+
+    if stbuf is None:
+        stbuf = os.lstat(path)
+
+    xattr_dict = get_quota_xattr_brick(path)
+
+    for parent in xattr_dict['parents']:
+        contri_dict = xattr_dict['parents'][parent]
+
+        if 'contri_size' not in contri_dict or \
+           'contri_file_count' not in contri_dict or \
+           'contri_dir_count' not in contri_dict:
+            print_msg(QUOTA_META_ABSENT, path, xattr_dict, stbuf)
+            fix_xattr(path, False)
+            return
+        elif size_differs_lot(contri_dict['contri_size'], stbuf.st_size):
+            print_msg(QUOTA_SIZE_MISMATCH, path, xattr_dict, stbuf)
+            fix_xattr(path, False)
+            return
+
+    if verbose_mode is True:
+        print_msg(QUOTA_VERBOSE, path, xattr_dict, stbuf)
+
+
+def verify_dir_xattr(path, dir_size):
+
+    global dir_count
+    dir_count += 1
+    xattr_dict = get_quota_xattr_brick(path)
+
+    stbuf = os.lstat(path)
+
+    for parent in xattr_dict['parents']:
+        contri_dict = xattr_dict['parents'][parent]
+
+        if 'size' not in xattr_dict or 'contri_size' not in contri_dict:
+            print_msg(QUOTA_META_ABSENT, path)
+            fix_xattr(path, True)
+            return
+        elif size_differs_lot(dir_size, xattr_dict['size']) or \
+             size_differs_lot(contri_dict['contri_size'], xattr_dict['size']):
+            print_msg(QUOTA_SIZE_MISMATCH, path, xattr_dict, stbuf, dir_size)
+            fix_xattr(path, True)
+            return
+
+    if verbose_mode is True:
+        print_msg("VERBOSE", path, xattr_dict, stbuf, dir_size)
+
+
+def walktree(t_dir, hard_link_dict):
+    '''recursively descend the directory tree rooted at dir,
+       aggregating the size
+       t_dir            : directory to walk over.
+       hard_link_dict   : dict of inodes with multiple hard_links under t_dir
+    '''
+    global aggr_size
+    aggr_size[t_dir] = 0
+
+    for entry in os.listdir(t_dir):
+        pathname = os.path.join(t_dir, entry)
+        stbuf = os.lstat(pathname)
+        if S_ISDIR(stbuf.st_mode):
+            # It's a directory, recurse into it
+            if entry == '.glusterfs':
+                print("skipping " + pathname)
+                continue
+            descendent_hardlinks = {}
+            subtree_size = walktree(pathname, descendent_hardlinks)
+
+            subtree_size = fix_hardlink_accounting(descendent_hardlinks,
+                                                   hard_link_dict,
+                                                   subtree_size)
+
+            aggr_size[t_dir] = aggr_size[t_dir] + subtree_size
+
+        elif S_ISREG(stbuf.st_mode) or S_ISLNK(stbuf.st_mode):
+            # Even a symbolic link file may have multiple hardlinks.
+
+            file_size = stbuf.st_size
+            if stbuf.st_nlink > 2:
+                # send a single element dict to check if file is accounted.
+                file_size = fix_hardlink_accounting({stbuf.st_ino:stbuf.st_size},
+                                                    hard_link_dict,
+                                                    stbuf.st_size)
+
+                if file_size == 0:
+                    print_msg("HARD_LINK (skipped)", pathname, "",
+                                stbuf)
+                else:
+                    print_msg("HARD_LINK (accounted)", pathname, "",
+                               stbuf)
+                    hard_link_dict[stbuf.st_ino] = stbuf.st_size
+
+            if t_dir in aggr_size:
+                aggr_size[t_dir] = aggr_size[t_dir] + file_size
+            else:
+                aggr_size[t_dir] = file_size
+            verify_file_xattr(pathname, stbuf)
+
+        else:
+            # Unknown file type, print a message
+            print('Skipping %s, due to file mode' % (pathname))
+
+    if t_dir not in aggr_size:
+        aggr_size[t_dir] = 0
+
+    verify_dir_xattr(t_dir, aggr_size[t_dir])
+    # du also accounts for t_directory sizes
+    # aggr_size[t_dir] += 4096
+
+    #cleanup
+    ret = aggr_size[t_dir]
+    del aggr_size[t_dir]
+    return ret
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(description='Diagnose quota accounting issues.', epilog=epilog_msg)
+    parser.add_argument('brick_path', nargs=1,
+                        help='The brick path (or any descendent sub-directory of brick path)',
+                        )
+    parser.add_argument('--full-logs', dest='verbose', action='store_true',
+                   help='''
+                         log all the xattr values and stat values reported
+                         for analysis. [CAUTION: This can give lot of output
+                         depending on FS depth. So one has to make sure enough
+                         disk space exists if redirecting to file]
+                        '''
+                        )
+    parser.add_argument('--fix-issues', metavar='mount_path', dest='mnt', action='store',
+                   help='''
+                         fix accounting issues where the xattr values disagree
+                         with stat sizes reported by gluster. A mount is also
+                         required for this option to be used.
+                         [CAUTION: This will directly modify backend xattr]
+                        '''
+                        )
+    parser.add_argument('--sub-dir', metavar='sub_dir', dest='sub_dir', action='store',
+                   help='''
+                         limit the crawling and accounting verification/correction
+                         to a specific subdirectory.
+                        '''
+                        )
+
+    args = parser.parse_args()
+    verbose_mode = args.verbose
+    brick_path = args.brick_path[0]
+    sub_dir = args.sub_dir
+    mnt_path = args.mnt
+    hard_link_dict = {}
+    if sub_dir is not None:
+        walktree(os.path.join(brick_path, sub_dir), hard_link_dict)
+    else:
+        walktree(brick_path, hard_link_dict)
+
+    print("Files verified : " + str(file_count))
+    print("Directories verified : " + str(dir_count))
+    if mnt_path is not None:
+        print("Objects Fixed : " + str(obj_fix_count))
diff --git a/extras/quota/xattr_analysis.py b/extras/quota/xattr_analysis.py
index d3d1a74170b..7bd7d96374c 100755
--- a/extras/quota/xattr_analysis.py
+++ b/extras/quota/xattr_analysis.py
@@ -1,12 +1,13 @@
-#!/usr/bin/python
-# Below script has to purpose
+#!/usr/bin/python3
+# Below script has two purposes
 #  1. Display xattr of entire FS tree in a human readable form
 #  2. Display all the directory where contri and size mismatch.
 #      (If there are any directory with contri and size mismatch that are not dirty
-#       then that highlights a propogation issue)
+#       then that highlights a propagation issue)
 #  The script takes only one input LOG _FILE generated from the command,
 #  find <brick_path> | xargs  getfattr -d -m. -e hex  > log_gluster_xattr
 
+from __future__ import print_function
 import re
 import subprocess
 import sys
@@ -14,7 +15,7 @@ from hurry.filesize import size
 
 if len(sys.argv) < 2:
     sys.exit('Usage: %s log_gluster_xattr \n'
-              'to genereate log_gluster_xattr use: \n'
+              'to generate log_gluster_xattr use: \n'
               'find <brick_path> | xargs  getfattr -d -m. -e hex  > log_gluster_xattr'
               % sys.argv[0])
 LOG_FILE=sys.argv[1]
@@ -27,17 +28,17 @@ def get_quota_xattr_brick():
     mismatch_size = [('====contri_size===', '====size====')]
     for xattr in pairs:
         k = xattr.split("=")[0]
-        if re.search("# file:",k):
-            print xdict
+        if re.search("# file:", k):
+            print(xdict)
             filename=k
-            print "=====" + filename + "======="
+            print("=====" + filename + "=======")
             xdict = {}
         elif k is "":
             pass
         else:
-            print xattr
+            print(xattr)
             v = xattr.split("=")[1]
-            if re.search("contri",k):
+            if re.search("contri", k):
                 if len(v) == 34:
                     # for files size is obtained in iatt, file count should be 1, dir count=0
                     xdict['contri_file_count'] = int(v[18:34], 16)
@@ -46,25 +47,25 @@ def get_quota_xattr_brick():
                     xdict['contri_size'] = size(int(v[2:18], 16))
                     xdict['contri_file_count'] = int(v[18:34], 16)
                     xdict['contri_dir_count'] = int(v[34:], 16)
-            elif re.search("size",k):
+            elif re.search("size", k):
                 xdict['size'] = size(int(v[2:18], 16))
                 xdict['file_count'] = int(v[18:34], 16)
                 xdict['dir_count'] = int(v[34:], 16)
-            elif re.search("dirty",k):
+            elif re.search("dirty", k):
                 if v == '0x3000':
                     xdict['dirty'] = False
                 elif v == '0x3100':
                     xdict['dirty'] = True
-            elif re.search("limit_objects",k):
+            elif re.search("limit_objects", k):
                 xdict['limit_objects'] = int(v[2:18], 16)
-            elif re.search("limit_set",k):
+            elif re.search("limit_set", k):
                 xdict['limit_set'] = size(int(v[2:18], 16))
 
             if 'size' in xdict and 'contri_size' in xdict and xdict['size'] != xdict['contri_size']:
                 mismatch_size.append((xdict['contri_size'], xdict['size'], filename))
 
     for values in mismatch_size:
-        print values
+        print(values)
 
 
 if __name__ == '__main__':
diff --git a/extras/rebalance.py b/extras/rebalance.py
index 9579e5616ad..37c68ebbb42 100755
--- a/extras/rebalance.py
+++ b/extras/rebalance.py
@@ -1,4 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
+
+from __future__ import print_function
 
 import atexit
 import copy
@@ -38,20 +40,20 @@ class Brick:
 
 def get_bricks (host, vol):
         t = pipes.Template()
-        t.prepend("gluster --remote-host=%s system getspec %s"%(host,vol),".-")
-        return t.open(None,"r")
+        t.prepend("gluster --remote-host=%s system getspec %s"%(host, vol), ".-")
+        return t.open(None, "r")
 
 def generate_stanza (vf, all_xlators, cur_subvol):
         sv_list = []
         for sv in cur_subvol.subvols:
-                generate_stanza(vf,all_xlators,sv)
+                generate_stanza(vf, all_xlators, sv)
                 sv_list.append(sv.name)
-        vf.write("volume %s\n"%cur_subvol.name)
-        vf.write("  type %s\n"%cur_subvol.type)
-        for kvpair in cur_subvol.opts.iteritems():
-                vf.write("  option %s %s\n"%kvpair)
+        vf.write("volume %s\n" % cur_subvol.name)
+        vf.write("  type %s\n" % cur_subvol.type)
+        for kvpair in cur_subvol.opts.items():
+                vf.write("  option %s %s\n" % kvpair)
         if sv_list:
-                vf.write("  subvolumes %s\n"%string.join(sv_list))
+                vf.write("  subvolumes %s\n" % ''.join(sv_list))
         vf.write("end-volume\n\n")
 
 
@@ -59,14 +61,14 @@ def mount_brick (localpath, all_xlators, dht_subvol):
 
         # Generate a volfile.
         vf_name = localpath + ".vol"
-        vf = open(vf_name,"w")
-        generate_stanza(vf,all_xlators,dht_subvol)
+        vf = open(vf_name, "w")
+        generate_stanza(vf, all_xlators, dht_subvol)
         vf.flush()
         vf.close()
 
         # Create a brick directory and mount the brick there.
         os.mkdir(localpath)
-        subprocess.call(["glusterfs","-f",vf_name,localpath])
+        subprocess.call(["glusterfs", "-f", vf_name, localpath])
 
 # We use the command-line tools because there's no getxattr support in the
 # Python standard library (which is ridiculous IMO).  Adding the xattr package
@@ -80,16 +82,16 @@ def mount_brick (localpath, all_xlators, dht_subvol):
 def get_range (brick):
         t = pipes.Template()
         cmd = "getfattr -e hex -n trusted.glusterfs.dht %s 2> /dev/null"
-        t.prepend(cmd%brick,".-")
-        t.append("grep ^trusted.glusterfs.dht=","--")
-        f = t.open(None,"r")
+        t.prepend(cmd%brick, ".-")
+        t.append("grep ^trusted.glusterfs.dht=", "--")
+        f = t.open(None, "r")
         try:
                 value = f.readline().rstrip().split('=')[1][2:]
         except:
-                print "could not get layout for %s (might be OK)" % brick
+                print("could not get layout for %s (might be OK)" % brick)
                 return None
-        v_start = int("0x"+value[16:24],16)
-        v_end = int("0x"+value[24:32],16)
+        v_start = int("0x"+value[16:24], 16)
+        v_end = int("0x"+value[24:32], 16)
         return (v_start, v_end)
 
 def calc_sizes (bricks, total):
@@ -126,7 +128,7 @@ def normalize (in_bricks):
                                 curr_hash = b.r_end + 1
                                 break
                 else:
-                        print "gap found at 0x%08x" % curr_hash
+                        print("gap found at 0x%08x" % curr_hash)
                         sys.exit(1)
         return out_bricks + in_bricks, used
 
@@ -154,8 +156,8 @@ def get_score (bricks):
 
 if __name__ == "__main__":
 
-	my_usage = "%prog [options] server volume [directory]"
-	parser = optparse.OptionParser(usage=my_usage)
+        my_usage = "%prog [options] server volume [directory]"
+        parser = optparse.OptionParser(usage=my_usage)
         parser.add_option("-f", "--free-space", dest="free_space",
                           default=False, action="store_true",
                           help="use free space instead of total space")
@@ -165,7 +167,7 @@ if __name__ == "__main__":
         parser.add_option("-v", "--verbose", dest="verbose",
                           default=False, action="store_true",
                           help="verbose output")
-	options, args = parser.parse_args()
+        options, args = parser.parse_args()
 
         if len(args) == 3:
                 fix_dir = args[2]
@@ -183,9 +185,9 @@ if __name__ == "__main__":
         def cleanup_workdir ():
                 os.chdir(orig_dir)
                 if options.verbose:
-                        print "Cleaning up %s" % work_dir
+                        print("Cleaning up %s" % work_dir)
                 for b in bricks:
-                        subprocess.call(["umount",b.path])
+                        subprocess.call(["umount", b.path])
                 shutil.rmtree(work_dir)
         if not options.leave_mounted:
                 atexit.register(cleanup_workdir)
@@ -193,29 +195,29 @@ if __name__ == "__main__":
 
         # Mount each brick individually, so we can issue brick-specific calls.
         if options.verbose:
-                print "Mounting subvolumes..."
+                print("Mounting subvolumes...")
         index = 0
-        volfile_pipe = get_bricks(hostname,volname)
+        volfile_pipe = get_bricks(hostname, volname)
         all_xlators, last_xlator = volfilter.load(volfile_pipe)
         for dht_vol in all_xlators.itervalues():
                 if dht_vol.type == "cluster/distribute":
                         break
         else:
-                print "no DHT volume found"
+                print("no DHT volume found")
                 sys.exit(1)
         for sv in dht_vol.subvols:
                 #print "found subvol %s" % sv.name
                 lpath = "%s/brick%s" % (work_dir, index)
                 index += 1
-                mount_brick(lpath,all_xlators,sv)
-                bricks.append(Brick(lpath,sv.name))
+                mount_brick(lpath, all_xlators, sv)
+                bricks.append(Brick(lpath, sv.name))
         if index == 0:
-                print "no bricks"
+                print("no bricks")
                 sys.exit(1)
 
         # Collect all of the sizes.
         if options.verbose:
-                print "Collecting information..."
+                print("Collecting information...")
         total = 0
         for b in bricks:
                 info = os.statvfs(b.path)
@@ -237,7 +239,7 @@ if __name__ == "__main__":
                 else:
                         size = info[2] / blocksper100mb
                 if size <= 0:
-                        print "brick %s has invalid size %d" % (b.path, size)
+                        print("brick %s has invalid size %d" % (b.path, size))
                         sys.exit(1)
                 b.set_size(size)
                 total += size
@@ -248,13 +250,13 @@ if __name__ == "__main__":
                 if hash_range is not None:
                         rs, re = hash_range
                         if rs > re:
-                                print "%s has backwards hash range" % b.path
+                                print("%s has backwards hash range" % b.path)
                                 sys.exit(1)
-                        b.set_range(hash_range[0],hash_range[1])
+                        b.set_range(hash_range[0], hash_range[1])
 
         if options.verbose:
-                print "Calculating new layouts..."
-        calc_sizes(bricks,total)
+                print("Calculating new layouts...")
+        calc_sizes(bricks, total)
         bricks, used = normalize(bricks)
 
         # We can't afford O(n!) here, but O(n^2) should be OK and the result
@@ -262,10 +264,10 @@ if __name__ == "__main__":
         while used < len(bricks):
                 best_place = used
                 best_score = get_score(bricks)
-                for i in xrange(used):
+                for i in range(used):
                         new_bricks = bricks[:]
                         del new_bricks[used]
-                        new_bricks.insert(i,bricks[used])
+                        new_bricks.insert(i, bricks[used])
                         new_score = get_score(new_bricks)
                         if new_score > best_score:
                                 best_place = i
@@ -273,7 +275,7 @@ if __name__ == "__main__":
                 if best_place != used:
                         nb = bricks[used]
                         del bricks[used]
-                        bricks.insert(best_place,nb)
+                        bricks.insert(best_place, nb)
                 used += 1
 
         # Finalize whatever we decided on.
@@ -283,25 +285,25 @@ if __name__ == "__main__":
                 curr_hash += b.good_size
                 b.r_end = curr_hash - 1
 
-        print "Here are the xattr values for your size-weighted layout:"
+        print("Here are the xattr values for your size-weighted layout:")
         for b in bricks:
-                print "  %s: 0x0000000200000000%08x%08x" % (
-                        b.sv_name, b.r_start, b.r_end)
+                print("  %s: 0x0000000200000000%08x%08x" % (
+                        b.sv_name, b.r_start, b.r_end))
 
         if fix_dir:
                 if options.verbose:
-                        print "Fixing layout for %s" % fix_dir
+                        print("Fixing layout for %s" % fix_dir)
                 for b in bricks:
                         value = "0x0000000200000000%08x%08x" % (
                                 b.r_start, b.r_end)
                         path = "%s/%s" % (b.path, fix_dir)
                         cmd = "setfattr -n trusted.glusterfs.dht -v %s %s" % (
                                 value, path)
-                        print cmd
+                        print(cmd)
 
         if options.leave_mounted:
-                print "The following subvolumes are still mounted:"
+                print("The following subvolumes are still mounted:")
                 for b in bricks:
-                        print "%s on %s" % (b.sv_name, b.path)
-                print "Don't forget to clean up when you're done."
+                        print("%s on %s" % (b.sv_name, b.path))
+                print("Don't forget to clean up when you're done.")
 
diff --git a/extras/snap_scheduler/Makefile.am b/extras/snap_scheduler/Makefile.am
index ffc157935a3..782f139016f 100644
--- a/extras/snap_scheduler/Makefile.am
+++ b/extras/snap_scheduler/Makefile.am
@@ -1,6 +1,8 @@
 snap_schedulerdir = $(sbindir)/
 
+if WITH_SERVER
 snap_scheduler_SCRIPTS = gcron.py snap_scheduler.py conf.py
+endif
 
 EXTRA_DIST = gcron.py snap_scheduler.py conf.py
 
diff --git a/extras/snap_scheduler/gcron.py b/extras/snap_scheduler/gcron.py
index d72057861ff..0e4df77d481 100755
--- a/extras/snap_scheduler/gcron.py
+++ b/extras/snap_scheduler/gcron.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 #
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -19,10 +19,10 @@ import logging.handlers
 import fcntl
 
 
-GCRON_TASKS = "/var/run/gluster/shared_storage/snaps/glusterfs_snap_cron_tasks"
+GCRON_TASKS = "/run/gluster/shared_storage/snaps/glusterfs_snap_cron_tasks"
 GCRON_CROND_TASK = "/etc/cron.d/glusterfs_snap_cron_tasks"
 GCRON_RELOAD_FLAG = "/var/run/gluster/crond_task_reload_flag"
-LOCK_FILE_DIR = "/var/run/gluster/shared_storage/snaps/lock_files/"
+LOCK_FILE_DIR = "/run/gluster/shared_storage/snaps/lock_files/"
 log = logging.getLogger("gcron-logger")
 start_time = 0.0
 
@@ -38,7 +38,8 @@ def initLogger(script_name):
     sh.setFormatter(formatter)
 
     process = subprocess.Popen(["gluster", "--print-logdir"],
-                               stdout=subprocess.PIPE)
+                               stdout=subprocess.PIPE,
+                               universal_newlines=True)
     out, err = process.communicate()
     if process.returncode == 0:
         logfile = os.path.join(out.strip(), script_name[:-3]+".log")
@@ -88,7 +89,7 @@ def takeSnap(volname="", snapname=""):
 def doJob(name, lockFile, jobFunc, volname):
     success = True
     try:
-        f = os.open(lockFile, os.O_RDWR | os.O_NONBLOCK)
+        f = os.open(lockFile, os.O_CREAT | os.O_RDWR | os.O_NONBLOCK)
         try:
             fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
             mtime = os.path.getmtime(lockFile)
@@ -105,11 +106,11 @@ def doJob(name, lockFile, jobFunc, volname):
             else:
                 log.info("Job %s has been processed already", name)
             fcntl.flock(f, fcntl.LOCK_UN)
-        except IOError as (errno, strerror):
+        except (OSError, IOError):
             log.info("Job %s is being processed by another agent", name)
         os.close(f)
-    except IOError as (errno, strerror):
-        log.debug("Failed to open lock file %s : %s", lockFile, strerror)
+    except (OSError, IOError) as e:
+        log.debug("Failed to open lock file %s : %s", lockFile, e)
         log.error("Failed to process job %s", name)
         success = False
 
@@ -122,19 +123,20 @@ def main():
     global start_time
     if sys.argv[1] == "--update":
         if not os.path.exists(GCRON_TASKS):
-            # Create a flag in /var/run/gluster which indicates that this nodes
-            # doesn't have access to GCRON_TASKS right now, so that
+            # Create a flag in /var/run/gluster which indicates that this
+            # node doesn't have access to GCRON_TASKS right now, so that
             # when the mount is available and GCRON_TASKS is available
             # the flag will tell this routine to reload GCRON_CROND_TASK
             try:
-                f = os.open(GCRON_RELOAD_FLAG, os.O_CREAT | os.O_NONBLOCK, 0644)
+                f = os.open(GCRON_RELOAD_FLAG,
+                            os.O_CREAT | os.O_NONBLOCK, 0o644)
                 os.close(f)
-            except OSError as (errno, strerror):
+            except OSError as e:
                 if errno != EEXIST:
                     log.error("Failed to create %s : %s",
-                              GCRON_RELOAD_FLAG, strerror)
+                              GCRON_RELOAD_FLAG, e)
                     output("Failed to create %s. Error: %s"
-                           % (GCRON_RELOAD_FLAG, strerror))
+                           % (GCRON_RELOAD_FLAG, e))
             return
 
         if not os.path.exists(GCRON_CROND_TASK):
@@ -153,9 +155,9 @@ def main():
                 if process.returncode != 0:
                     log.error("Failed to touch %s. Error: %s.",
                               GCRON_CROND_TASK, err)
-            except (IOError, OSError) as (errno, strerror):
+            except (IOError, OSError) as e:
                 log.error("Failed to touch %s. Error: %s.",
-                          GCRON_CROND_TASK, strerror)
+                          GCRON_CROND_TASK, e)
             return
         if os.lstat(GCRON_TASKS).st_mtime > \
            os.lstat(GCRON_CROND_TASK).st_mtime:
@@ -167,9 +169,9 @@ def main():
                 if process.returncode != 0:
                     log.error("Failed to touch %s. Error: %s.",
                               GCRON_CROND_TASK, err)
-            except IOError as (errno, strerror):
+            except IOError as e:
                 log.error("Failed to touch %s. Error: %s.",
-                          GCRON_CROND_TASK, strerror)
+                          GCRON_CROND_TASK, e)
         return
 
     volname = sys.argv[1]
diff --git a/extras/snap_scheduler/snap_scheduler.py b/extras/snap_scheduler/snap_scheduler.py
index 61d1c514a9a..e8fcc449a9b 100755
--- a/extras/snap_scheduler/snap_scheduler.py
+++ b/extras/snap_scheduler/snap_scheduler.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 #
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -67,7 +67,7 @@ except ImportError:
 SCRIPT_NAME = "snap_scheduler"
 scheduler_enabled = False
 log = logging.getLogger(SCRIPT_NAME)
-SHARED_STORAGE_DIR="/var/run/gluster/shared_storage"
+SHARED_STORAGE_DIR="/run/gluster/shared_storage"
 GCRON_DISABLED = SHARED_STORAGE_DIR+"/snaps/gcron_disabled"
 GCRON_ENABLED = SHARED_STORAGE_DIR+"/snaps/gcron_enabled"
 GCRON_TASKS = SHARED_STORAGE_DIR+"/snaps/glusterfs_snap_cron_tasks"
@@ -149,7 +149,7 @@ def initLogger():
     sh.setFormatter(formatter)
 
     process = subprocess.Popen(["gluster", "--print-logdir"],
-                               stdout=subprocess.PIPE)
+                               stdout=subprocess.PIPE, universal_newlines=True)
     logfile = os.path.join(process.stdout.read()[:-1], SCRIPT_NAME + ".log")
 
     fh = logging.FileHandler(logfile)
@@ -207,11 +207,11 @@ def enable_scheduler():
                     os.remove(GCRON_TASKS)
                 try:
                     f = os.open(GCRON_ENABLED, os.O_CREAT | os.O_NONBLOCK,
-                                0644)
+                                0o644)
                     os.close(f)
-                except OSError as (errno, strerror):
+                except OSError as e:
                     log.error("Failed to open %s. Error: %s.",
-                              GCRON_ENABLED, strerror)
+                              GCRON_ENABLED, e)
                     ret = INTERNAL_ERROR
                     return ret
                 os.symlink(GCRON_ENABLED, GCRON_TASKS)
@@ -219,8 +219,9 @@ def enable_scheduler():
                 log.info("Snapshot scheduling is enabled")
                 output("Snapshot scheduling is enabled")
                 ret = 0
-            except OSError as (errno, strerror):
-                print_str = "Failed to enable snapshot scheduling. Error: "+strerror
+            except OSError as e:
+                print_str = ("Failed to enable snapshot scheduling."
+                             "Error: {{}}" + e)
                 log.error(print_str)
                 output(print_str)
                 ret = INTERNAL_ERROR
@@ -262,14 +263,15 @@ def disable_scheduler():
                     os.remove(GCRON_DISABLED)
                 if os.path.lexists(GCRON_TASKS):
                     os.remove(GCRON_TASKS)
-                f = os.open(GCRON_DISABLED, os.O_CREAT, 0644)
+                f = os.open(GCRON_DISABLED, os.O_CREAT, 0o644)
                 os.close(f)
                 os.symlink(GCRON_DISABLED, GCRON_TASKS)
                 log.info("Snapshot scheduling is disabled")
                 output("Snapshot scheduling is disabled")
                 ret = 0
-            except OSError as (errno, strerror):
-                print_str = "Failed to disable snapshot scheduling. Error: "+strerror
+            except OSError as e:
+                print_str = ("Failed to disable snapshot scheduling. Error: "
+                             + e)
                 log.error(print_str)
                 output(print_str)
                 ret = INTERNAL_ERROR
@@ -308,8 +310,8 @@ def load_tasks_from_file():
                 tasks[jobname] = schedule+":"+volname
             f.close()
         ret = 0
-    except IOError as (errno, strerror):
-        log.error("Failed to open %s. Error: %s.", GCRON_ENABLED, strerror)
+    except IOError as e:
+        log.error("Failed to open %s. Error: %s.", GCRON_ENABLED, e)
         ret = INTERNAL_ERROR
 
     return ret
@@ -322,8 +324,8 @@ def get_current_scheduler():
             current_scheduler = f.readline().rstrip('\n')
             f.close()
         ret = 0
-    except IOError as (errno, strerror):
-        log.error("Failed to open %s. Error: %s.", CURRENT_SCHEDULER, strerror)
+    except IOError as e:
+        log.error("Failed to open %s. Error: %s.", CURRENT_SCHEDULER, e)
         ret = INTERNAL_ERROR
 
     return ret
@@ -363,7 +365,7 @@ def list_schedules():
 
 def write_tasks_to_file():
     try:
-        with open(TMP_FILE, "w", 0644) as f:
+        with open(TMP_FILE, "w", 0o644) as f:
             # If tasks is empty, just create an empty tmp file
             if len(tasks) != 0:
                 for key in sorted(tasks):
@@ -376,8 +378,8 @@ def write_tasks_to_file():
                 f.flush()
                 os.fsync(f.fileno())
             f.close()
-    except IOError as (errno, strerror):
-        log.error("Failed to open %s. Error: %s.", TMP_FILE, strerror)
+    except IOError as e:
+        log.error("Failed to open %s. Error: %s.", TMP_FILE, e)
         ret = INTERNAL_ERROR
         return ret
 
@@ -388,13 +390,13 @@ def write_tasks_to_file():
 
 def update_current_scheduler(data):
     try:
-        with open(TMP_FILE, "w", 0644) as f:
+        with open(TMP_FILE, "w", 0o644) as f:
             f.write("%s" % data)
             f.flush()
             os.fsync(f.fileno())
             f.close()
-    except IOError as (errno, strerror):
-        log.error("Failed to open %s. Error: %s.", TMP_FILE, strerror)
+    except IOError as e:
+        log.error("Failed to open %s. Error: %s.", TMP_FILE, e)
         ret = INTERNAL_ERROR
         return ret
 
@@ -457,11 +459,11 @@ def add_schedules(jobname, schedule, volname):
                     job_lockfile = LOCK_FILE_DIR + jobname
                     try:
                         f = os.open(job_lockfile, os.O_CREAT | os.O_NONBLOCK,
-                                    0644)
+                                    0o644)
                         os.close(f)
-                    except OSError as (errno, strerror):
+                    except OSError as e:
                         log.error("Failed to open %s. Error: %s.",
-                                  job_lockfile, strerror)
+                                  job_lockfile, e)
                         ret = INTERNAL_ERROR
                         return ret
                     log.info("Successfully added snapshot schedule %s" %
@@ -489,9 +491,9 @@ def delete_schedules(jobname):
                 job_lockfile = LOCK_FILE_DIR+jobname
                 try:
                     os.remove(job_lockfile)
-                except OSError as (errno, strerror):
+                except OSError as e:
                     log.error("Failed to open %s. Error: %s.",
-                              job_lockfile, strerror)
+                              job_lockfile, e)
                     ret = INTERNAL_ERROR
                     return ret
                 log.info("Successfully deleted snapshot schedule %s"
@@ -575,8 +577,13 @@ def get_selinux_status():
     getenforce_cli = ["getenforce"]
     log.debug("Running command '%s'", " ".join(getenforce_cli))
 
-    p1 = subprocess.Popen(getenforce_cli, stdout=subprocess.PIPE,
-                          stderr=subprocess.PIPE)
+    try:
+        p1 = subprocess.Popen(getenforce_cli, stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE)
+    except OSError as oserr:
+        log.error("Failed to run the command \"getenforce\". Error: %s" %\
+                  oserr)
+        return -1
 
     output, err = p1.communicate()
     rv = p1.returncode
@@ -638,15 +645,15 @@ def initialise_scheduler():
         return ret
 
     try:
-        with open(TMP_FILE, "w+", 0644) as f:
+        with open(TMP_FILE, "w+", 0o644) as f:
             updater = ("* * * * * root PATH=$PATH:/usr/local/sbin:"
                        "/usr/sbin gcron.py --update\n")
             f.write("%s\n" % updater)
             f.flush()
             os.fsync(f.fileno())
             f.close()
-    except IOError as (errno, strerror):
-        log.error("Failed to open %s. Error: %s.", TMP_FILE, strerror)
+    except IOError as e:
+        log.error("Failed to open %s. Error: %s.", TMP_FILE, e)
         ret = INIT_FAILED
         return ret
 
@@ -654,10 +661,10 @@ def initialise_scheduler():
 
     if not os.path.lexists(GCRON_TASKS):
         try:
-            f = open(GCRON_TASKS, "w", 0644)
+            f = open(GCRON_TASKS, "w", 0o644)
             f.close()
-        except IOError as (errno, strerror):
-            log.error("Failed to open %s. Error: %s.", GCRON_TASKS, strerror)
+        except IOError as e:
+            log.error("Failed to open %s. Error: %s.", GCRON_TASKS, e)
             ret = INIT_FAILED
             return ret
 
@@ -725,7 +732,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_DISABLED,
-                      status="Successfuly Disabled")
+                      status="Successfully Disabled")
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_DISABLE_FAILED,
                       error=print_error(ret))
@@ -760,7 +767,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_ENABLED,
-                      status="Successfuly Enabled")
+                      status="Successfully Enabled")
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_ENABLE_FAILED,
                       error=print_error(ret))
@@ -772,7 +779,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_DISABLED,
-                      status="Successfuly Disabled")
+                      status="Successfully Disabled")
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_DISABLE_FAILED,
                       error=print_error(ret))
@@ -792,7 +799,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_ADDED,
-                      status="Successfuly added job "+args.jobname)
+                      status="Successfully added job "+args.jobname)
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_ADD_FAILED,
                       status="Failed to add job "+args.jobname,
@@ -808,7 +815,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_DELETED,
-                      status="Successfuly deleted job "+args.jobname)
+                      status="Successfully deleted job "+args.jobname)
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_DELETE_FAILED,
                       status="Failed to delete job "+args.jobname,
@@ -824,7 +831,7 @@ def perform_operation(args):
         if ret == 0:
             subprocess.Popen(["touch", "-h", GCRON_TASKS])
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_EDITED,
-                      status="Successfuly edited job "+args.jobname)
+                      status="Successfully edited job "+args.jobname)
         else:
             gf_event (EVENT_SNAPSHOT_SCHEDULER_SCHEDULE_EDIT_FAILED,
                       status="Failed to edit job "+args.jobname,
@@ -889,42 +896,42 @@ def main(argv):
     if not os.path.exists(SHARED_STORAGE_DIR+"/snaps/"):
         try:
             os.makedirs(SHARED_STORAGE_DIR+"/snaps/")
-        except OSError as (errno, strerror):
+        except OSError as e:
             if errno != EEXIST:
-                log.error("Failed to create %s : %s", SHARED_STORAGE_DIR+"/snaps/", strerror)
+                log.error("Failed to create %s : %s", SHARED_STORAGE_DIR+"/snaps/", e)
                 output("Failed to create %s. Error: %s"
-                       % (SHARED_STORAGE_DIR+"/snaps/", strerror))
+                       % (SHARED_STORAGE_DIR+"/snaps/", e))
                 return INTERNAL_ERROR
 
     if not os.path.exists(GCRON_ENABLED):
-        f = os.open(GCRON_ENABLED, os.O_CREAT | os.O_NONBLOCK, 0644)
+        f = os.open(GCRON_ENABLED, os.O_CREAT | os.O_NONBLOCK, 0o644)
         os.close(f)
 
     if not os.path.exists(LOCK_FILE_DIR):
         try:
             os.makedirs(LOCK_FILE_DIR)
-        except OSError as (errno, strerror):
+        except OSError as e:
             if errno != EEXIST:
-                log.error("Failed to create %s : %s", LOCK_FILE_DIR, strerror)
+                log.error("Failed to create %s : %s", LOCK_FILE_DIR, e)
                 output("Failed to create %s. Error: %s"
-                       % (LOCK_FILE_DIR, strerror))
+                       % (LOCK_FILE_DIR, e))
                 return INTERNAL_ERROR
 
     try:
-        f = os.open(LOCK_FILE, os.O_CREAT | os.O_RDWR | os.O_NONBLOCK, 0644)
+        f = os.open(LOCK_FILE, os.O_CREAT | os.O_RDWR | os.O_NONBLOCK, 0o644)
         try:
             fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
             ret = perform_operation(args)
             fcntl.flock(f, fcntl.LOCK_UN)
-        except IOError as (errno, strerror):
+        except IOError:
             log.info("%s is being processed by another agent.", LOCK_FILE)
             output("Another snap_scheduler command is running. "
                    "Please try again after some time.")
             return ANOTHER_TRANSACTION_IN_PROGRESS
         os.close(f)
-    except OSError as (errno, strerror):
-        log.error("Failed to open %s : %s", LOCK_FILE, strerror)
-        output("Failed to open %s. Error: %s" % (LOCK_FILE, strerror))
+    except OSError as e:
+        log.error("Failed to open %s : %s", LOCK_FILE, e)
+        output("Failed to open %s. Error: %s" % (LOCK_FILE, e))
         return INTERNAL_ERROR
 
     return ret
diff --git a/extras/statedumpparse.rb b/extras/statedumpparse.rb
new file mode 100755
index 00000000000..1aff43377db
--- /dev/null
+++ b/extras/statedumpparse.rb
@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+
+require 'time'
+require 'optparse'
+
+unless Array.instance_methods.include? :to_h
+  class Array
+    def to_h
+      h = {}
+      each { |k,v| h[k]=v }
+      h
+    end
+  end
+end
+
+# statedump.c:gf_proc_dump_mempool_info uses a five-dash record separator,
+# client.c:client_fd_lk_ctx_dump uses a six-dash record separator.
+ARRSEP = /^(-{5,6}=-{5,6})?$/
+HEAD = /^\[(.*)\]$/
+INPUT_FORMATS = %w[statedump json]
+
+format = 'json'
+input_format = 'statedump'
+tz = '+0000'
+memstat_select,memstat_reject = //,/\Z./
+OptionParser.new do |op|
+  op.banner << " [<] <STATEDUMP>"
+  op.on("-f", "--format=F", "json/yaml/memstat(-[plain|human|json])") { |s| format = s }
+  op.on("--input-format=F", INPUT_FORMATS.join(?/)) { |s| input_format = s }
+  op.on("--timezone=T",
+        "time zone to apply to zoneless timestamps [default UTC]") { |s| tz = s }
+  op.on("--memstat-select=RX", "memstat: select memory types matching RX") { |s|
+    memstat_select = Regexp.new s
+  }
+  op.on("--memstat-reject=RX", "memstat: reject memory types matching RX") { |s|
+    memstat_reject = Regexp.new s
+  }
+end.parse!
+
+
+if format =~ /\Amemstat(?:-(.*))?/
+  memstat_type = $1 || 'plain'
+  unless %w[plain human json].include? memstat_type
+    raise "unknown memstat type #{memstat_type.dump}"
+  end
+  format = 'memstat'
+end
+
+repr, logsep = case format
+when 'yaml'
+  require 'yaml'
+
+  [proc { |e| e.to_yaml }, "\n"]
+when 'json', 'memstat'
+  require 'json'
+
+  [proc { |e| e.to_json }, " "]
+else
+  raise "unkonwn format '#{format}'"
+end
+formatter = proc { |e| puts repr.call(e) }
+
+INPUT_FORMATS.include? input_format or raise "unkwown input format '#{input_format}'"
+
+dumpinfo = {}
+
+# parse a statedump entry
+elem_cbk = proc { |s,&cbk|
+  arraylike = false
+  s.grep(/\S/).empty? and next
+  head = nil
+  while s.last =~ /^\s*$/
+    s.pop
+  end
+  body = catch { |misc2|
+    s[0] =~ HEAD ? (head = $1) : (throw misc2)
+    body = [[]]
+    s[1..-1].each { |l|
+      if l =~ ARRSEP
+        arraylike = true
+        body << []
+        next
+      end
+      body.last << l
+    }
+
+    body.reject(&:empty?).map { |e|
+      ea = e.map { |l|
+        k,v = l.split("=",2)
+        m = /\A(0|-?[1-9]\d*)(\.\d+)?\Z/.match v
+        [k, m ? (m[2] ? Float(v) : Integer(v)) : v]
+      }
+      begin
+        ea.to_h
+      rescue
+        throw misc2
+      end
+    }
+  }
+
+  if body
+    cbk.call [head, arraylike ? body : (body.empty? ? {} : body[0])]
+  else
+    STDERR.puts ["WARNING: failed to parse record:", repr.call(s)].join(logsep)
+  end
+}
+
+# aggregator routine
+aggr = case format
+when 'memstat'
+  meminfo = {}
+  # commit memory-related entries to meminfo
+  proc { |k,r|
+    case k
+    when /memusage/
+      (meminfo["GF_MALLOC"]||={})[k] ||= r["size"] if k =~ memstat_select and k !~ memstat_reject
+    when "mempool"
+      r.each {|e|
+        kk = "mempool:#{e['pool-name']}"
+        (meminfo["mempool"]||={})[kk] ||= e["size"] if kk =~ memstat_select and kk !~ memstat_reject
+      }
+    end
+  }
+else
+  # just format data, don't actually aggregate anything
+  proc { |pair| formatter.call pair }
+end
+
+# processing the data
+case input_format
+when 'statedump'
+  acc = []
+  $<.each { |l|
+    l = l.strip
+    if l =~ /^(DUMP-(?:START|END)-TIME):\s+(.*)/
+      dumpinfo["_meta"]||={}
+      (dumpinfo["_meta"]["date"]||={})[$1] = Time.parse([$2, tz].join " ")
+      next
+    end
+
+    if l =~ HEAD
+      elem_cbk.call(acc, &aggr)
+      acc = [l]
+      next
+    end
+
+    acc << l
+  }
+  elem_cbk.call(acc, &aggr)
+when 'json'
+  $<.each { |l|
+    r = JSON.load l
+    case r
+    when Array
+      aggr[r]
+    when Hash
+      dumpinfo.merge! r
+    end
+  }
+end
+
+# final actions: output aggregated data
+case format
+when 'memstat'
+  ma = meminfo.values.map(&:to_a).inject(:+)
+  totals = meminfo.map { |coll,h| [coll, h.values.inject(:+)] }.to_h
+  tt = ma.transpose[1].inject(:+)
+
+  summary_sep,showm = case memstat_type
+  when 'json'
+    ["", proc { |k,v| puts({type: k, value: v}.to_json) }]
+  when 'plain', 'human'
+    # human-friendly number representation
+    hr = proc { |n|
+      qa = %w[B kB MB GB]
+      q = ((1...qa.size).find {|i| n < (1 << i*10)} || qa.size) - 1
+      "%.2f%s" % [n.to_f / (1 << q*10), qa[q]]
+    }
+
+    templ = "%{val} %{key}"
+    tft = proc { |t| t }
+    nft = if memstat_type == 'human'
+      nw = [ma.transpose[1], totals.values, tt].flatten.map{|n| hr[n].size}.max
+      proc { |n|
+        hn = hr[n]
+        " " * (nw - hn.size) + hn
+      }
+    else
+      nw = tt.to_s.size
+      proc { |n| "%#{nw}d" % n }
+    end
+    ## Alternative template, key first:
+    # templ = "%{key} %{val}"
+    # tw = ma.transpose[0].map(&:size).max
+    # tft = proc { |t| t + " " * [tw - t.size, 0].max }
+    # nft = (memstat_type == 'human') ? hr : proc { |n| n }
+    ["\n", proc { |k,v| puts templ % {key: tft[k], val: nft[v]} }]
+  else
+    raise 'this should be impossible'
+  end
+
+  ma.sort_by { |k,v| v }.each(&showm)
+  print summary_sep
+  totals.each { |coll,t| showm.call "Total #{coll}", t }
+  showm.call "TOTAL", tt
+else
+  formatter.call dumpinfo
+end
diff --git a/extras/stop-all-gluster-processes.sh b/extras/stop-all-gluster-processes.sh
index ea2b48ee88b..710aaf5fd3c 100755
--- a/extras/stop-all-gluster-processes.sh
+++ b/extras/stop-all-gluster-processes.sh
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 #
 # Kill all the processes/services except glusterd
 #
diff --git a/extras/stripe-merge.c b/extras/stripe-merge.c
index 74bd47e303e..e013a6e6e8a 100644
--- a/extras/stripe-merge.c
+++ b/extras/stripe-merge.c
@@ -28,7 +28,7 @@
 #include <stdint.h>
 #include <errno.h>
 #include <string.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <fnmatch.h>
 
 #define ATTRNAME_STRIPE_INDEX "trusted.*.stripe-index"
@@ -40,33 +40,33 @@
 #define INVALID_MODE UINT32_MAX
 
 struct file_stripe_info {
-	int stripe_count;
-	int stripe_size;
-	int coalesce;
-	mode_t mode;
-	int fd[0];
+    int stripe_count;
+    int stripe_size;
+    int coalesce;
+    mode_t mode;
+    int fd[0];
 };
 
-static int close_files(struct file_stripe_info *);
+static int
+close_files(struct file_stripe_info *);
 
-static struct
-file_stripe_info *alloc_file_stripe_info(int count)
+static struct file_stripe_info *
+alloc_file_stripe_info(int count)
 {
-	int i;
-	struct file_stripe_info *finfo;
+    int i;
+    struct file_stripe_info *finfo;
 
-	finfo = calloc(1, sizeof(struct file_stripe_info) +
-		(sizeof(int) * count));
-	if (!finfo)
-		return NULL;
+    finfo = calloc(1, sizeof(struct file_stripe_info) + (sizeof(int) * count));
+    if (!finfo)
+        return NULL;
 
-	for (i = 0; i < count; i++)
-		finfo->fd[i] = INVALID_FD;
+    for (i = 0; i < count; i++)
+        finfo->fd[i] = INVALID_FD;
 
-	finfo->mode = INVALID_MODE;
-	finfo->coalesce = INVALID_FD;
+    finfo->mode = INVALID_MODE;
+    finfo->coalesce = INVALID_FD;
 
-	return finfo;
+    return finfo;
 }
 
 /*
@@ -77,39 +77,39 @@ file_stripe_info *alloc_file_stripe_info(int count)
 static int
 get_stripe_attr_name(const char *path, const char *pattern, char **attrname)
 {
-	char attrbuf[4096];
-	char *ptr, *match = NULL;
-	int len, r, match_count = 0;
-
-	if (!path || !pattern || !attrname)
-		return -1;
-
-	len = listxattr(path, attrbuf, sizeof(attrbuf));
-	if (len < 0)
-		return len;
-
-	ptr = attrbuf;
-	while (ptr) {
-		r = fnmatch(pattern, ptr, 0);
-		if (!r) {
-			if (!match)
-				match = ptr;
-			match_count++;
-		} else if (r != FNM_NOMATCH) {
-			return -1;
-		}
-
-		len -= strlen(ptr) + 1;
-		if (len > 0)
-			ptr += strlen(ptr) + 1;
-		else
-			ptr = NULL;
-	}
-
-	if (match)
-		*attrname = strdup(match);
-
-	return match_count;
+    char attrbuf[4096];
+    char *ptr, *match = NULL;
+    int len, r, match_count = 0;
+
+    if (!path || !pattern || !attrname)
+        return -1;
+
+    len = listxattr(path, attrbuf, sizeof(attrbuf));
+    if (len < 0)
+        return len;
+
+    ptr = attrbuf;
+    while (ptr) {
+        r = fnmatch(pattern, ptr, 0);
+        if (!r) {
+            if (!match)
+                match = ptr;
+            match_count++;
+        } else if (r != FNM_NOMATCH) {
+            return -1;
+        }
+
+        len -= strlen(ptr) + 1;
+        if (len > 0)
+            ptr += strlen(ptr) + 1;
+        else
+            ptr = NULL;
+    }
+
+    if (match)
+        *attrname = strdup(match);
+
+    return match_count;
 }
 
 /*
@@ -118,19 +118,19 @@ get_stripe_attr_name(const char *path, const char *pattern, char **attrname)
 static int
 get_stripe_attr_val(const char *path, const char *attr, int *val)
 {
-	char attrbuf[4096];
-	int len;
+    char attrbuf[4096];
+    int len;
 
-	if (!path || !attr || !val)
-		return -1;
+    if (!path || !attr || !val)
+        return -1;
 
-	len = getxattr(path, attr, attrbuf, sizeof(attrbuf));
-	if (len < 0)
-		return len;
+    len = getxattr(path, attr, attrbuf, sizeof(attrbuf));
+    if (len < 0)
+        return len;
 
-	*val = atoi(attrbuf);
+    *val = atoi(attrbuf);
 
-	return 0;
+    return 0;
 }
 
 /*
@@ -145,29 +145,31 @@ get_stripe_attr_val(const char *path, const char *attr, int *val)
 static int
 get_attr(const char *path, const char *pattern, char **buf, int *val)
 {
-	int count = 1;
-
-	if (!buf)
-		return -1;
-
-	if (!*buf) {
-		count = get_stripe_attr_name(path, pattern, buf);
-		if (count > 1) {
-			/* pattern isn't good enough */
-			fprintf(stderr, "ERROR: duplicate attributes found "
-				"matching pattern: %s\n", pattern);
-			free(*buf);
-			*buf = NULL;
-			return count;
-		} else if (count < 1) {
-			return count;
-		}
-	}
-
-	if (get_stripe_attr_val(path, *buf, val) < 0)
-		return -1;
-
-	return count;
+    int count = 1;
+
+    if (!buf)
+        return -1;
+
+    if (!*buf) {
+        count = get_stripe_attr_name(path, pattern, buf);
+        if (count > 1) {
+            /* pattern isn't good enough */
+            fprintf(stderr,
+                    "ERROR: duplicate attributes found "
+                    "matching pattern: %s\n",
+                    pattern);
+            free(*buf);
+            *buf = NULL;
+            return count;
+        } else if (count < 1) {
+            return count;
+        }
+    }
+
+    if (get_stripe_attr_val(path, *buf, val) < 0)
+        return -1;
+
+    return count;
 }
 
 /*
@@ -178,164 +180,168 @@ get_attr(const char *path, const char *pattern, char **buf, int *val)
  * print a warning if any files are missing. We proceed without error in the
  * latter case to support partial recovery.
  */
-static struct
-file_stripe_info *validate_and_open_files(char *paths[], int count)
+static struct file_stripe_info *
+validate_and_open_files(char *paths[], int count)
 {
-	int i, val, tmp;
-	struct stat sbuf;
-	char *stripe_count_attr = NULL;
-	char *stripe_size_attr = NULL;
-	char *stripe_index_attr = NULL;
-	char *stripe_coalesce_attr = NULL;
-	struct file_stripe_info *finfo = NULL;
-
-	for (i = 0; i < count; i++) {
-		if (!paths[i])
-			goto err;
-
-		/*
-		 * Check the stripe count first so we can allocate the info
-		 * struct with the appropriate number of fds.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_COUNT,
-				&stripe_count_attr, &val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_COUNT);
-			goto err;
-		}
-		if (!finfo) {
-			finfo = alloc_file_stripe_info(val);
-			if (!finfo)
-				goto err;
-
-			if (val != count)
-				fprintf(stderr, "WARNING: %s: stripe-count "
-					"(%d) != file count (%d). Result may "
-					"be incomplete.\n", paths[i], val,
-					count);
-
-			finfo->stripe_count = val;
-		} else if (val != finfo->stripe_count) {
-			fprintf(stderr, "ERROR %s: invalid stripe count: %d "
-				"(expected %d)\n", paths[i], val,
-				finfo->stripe_count);
-			goto err;
-		}
-
-		/*
-		 * Get and validate the chunk size.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_SIZE, &stripe_size_attr,
-				&val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_SIZE);
-			goto err;
-		}
-
-		if (!finfo->stripe_size) {
-			finfo->stripe_size = val;
-		} else if (val != finfo->stripe_size) {
-			fprintf(stderr, "ERROR: %s: invalid stripe size: %d "
-				"(expected %d)\n", paths[i], val,
-				finfo->stripe_size);
-			goto err;
-		}
-
-		/*
-		 * stripe-coalesce is a backward compatible attribute. If the
-		 * attribute does not exist, assume a value of zero for the
-		 * traditional stripe format.
-		 */
-		tmp = get_attr(paths[i], ATTRNAME_STRIPE_COALESCE,
-				&stripe_coalesce_attr, &val);
-		if (!tmp) {
-			val = 0;
-		} else if (tmp != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_COALESCE);
-			goto err;
-		}
-
-		if (finfo->coalesce == INVALID_FD) {
-			finfo->coalesce = val;
-		} else if (val != finfo->coalesce) {
-			fprintf(stderr, "ERROR: %s: invalid coalesce flag\n",
-				paths[i]);
-			goto err;
-		}
-
-		/*
-		 * Get/validate the stripe index and open the file in the
-		 * appropriate fd slot.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_INDEX,
-				&stripe_index_attr, &val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_INDEX);
-			goto err;
-		}
-		if (finfo->fd[val] != INVALID_FD) {
-			fprintf(stderr, "ERROR: %s: duplicate stripe index: "
-				"%d\n", paths[i], val);
-			goto err;
-		}
-
-		finfo->fd[val] = open(paths[i], O_RDONLY);
-		if (finfo->fd[val] < 0)
-			goto err;
-
-		/*
-		 * Get the creation mode for the file.
-		 */
-		if (fstat(finfo->fd[val], &sbuf) < 0)
-			goto err;
-		if (finfo->mode == INVALID_MODE) {
-			finfo->mode = sbuf.st_mode;
-		} else if (sbuf.st_mode != finfo->mode) {
-			fprintf(stderr, "ERROR: %s: invalid mode\n", paths[i]);
-			goto err;
-		}
-	}
-
-	free(stripe_count_attr);
-	free(stripe_size_attr);
-	free(stripe_index_attr);
-	free(stripe_coalesce_attr);
-
-	return finfo;
+    int i, val, tmp;
+    struct stat sbuf;
+    char *stripe_count_attr = NULL;
+    char *stripe_size_attr = NULL;
+    char *stripe_index_attr = NULL;
+    char *stripe_coalesce_attr = NULL;
+    struct file_stripe_info *finfo = NULL;
+
+    for (i = 0; i < count; i++) {
+        if (!paths[i])
+            goto err;
+
+        /*
+         * Check the stripe count first so we can allocate the info
+         * struct with the appropriate number of fds.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_COUNT, &stripe_count_attr,
+                     &val) != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_COUNT);
+            goto err;
+        }
+        if (!finfo) {
+            finfo = alloc_file_stripe_info(val);
+            if (!finfo)
+                goto err;
+
+            if (val != count)
+                fprintf(stderr,
+                        "WARNING: %s: stripe-count "
+                        "(%d) != file count (%d). Result may "
+                        "be incomplete.\n",
+                        paths[i], val, count);
+
+            finfo->stripe_count = val;
+        } else if (val != finfo->stripe_count) {
+            fprintf(stderr,
+                    "ERROR %s: invalid stripe count: %d "
+                    "(expected %d)\n",
+                    paths[i], val, finfo->stripe_count);
+            goto err;
+        }
+
+        /*
+         * Get and validate the chunk size.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_SIZE, &stripe_size_attr, &val) !=
+            1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_SIZE);
+            goto err;
+        }
+
+        if (!finfo->stripe_size) {
+            finfo->stripe_size = val;
+        } else if (val != finfo->stripe_size) {
+            fprintf(stderr,
+                    "ERROR: %s: invalid stripe size: %d "
+                    "(expected %d)\n",
+                    paths[i], val, finfo->stripe_size);
+            goto err;
+        }
+
+        /*
+         * stripe-coalesce is a backward compatible attribute. If the
+         * attribute does not exist, assume a value of zero for the
+         * traditional stripe format.
+         */
+        tmp = get_attr(paths[i], ATTRNAME_STRIPE_COALESCE,
+                       &stripe_coalesce_attr, &val);
+        if (!tmp) {
+            val = 0;
+        } else if (tmp != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_COALESCE);
+            goto err;
+        }
+
+        if (finfo->coalesce == INVALID_FD) {
+            finfo->coalesce = val;
+        } else if (val != finfo->coalesce) {
+            fprintf(stderr, "ERROR: %s: invalid coalesce flag\n", paths[i]);
+            goto err;
+        }
+
+        /*
+         * Get/validate the stripe index and open the file in the
+         * appropriate fd slot.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_INDEX, &stripe_index_attr,
+                     &val) != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_INDEX);
+            goto err;
+        }
+        if (finfo->fd[val] != INVALID_FD) {
+            fprintf(stderr,
+                    "ERROR: %s: duplicate stripe index: "
+                    "%d\n",
+                    paths[i], val);
+            goto err;
+        }
+
+        finfo->fd[val] = open(paths[i], O_RDONLY);
+        if (finfo->fd[val] < 0)
+            goto err;
+
+        /*
+         * Get the creation mode for the file.
+         */
+        if (fstat(finfo->fd[val], &sbuf) < 0)
+            goto err;
+        if (finfo->mode == INVALID_MODE) {
+            finfo->mode = sbuf.st_mode;
+        } else if (sbuf.st_mode != finfo->mode) {
+            fprintf(stderr, "ERROR: %s: invalid mode\n", paths[i]);
+            goto err;
+        }
+    }
+
+    free(stripe_count_attr);
+    free(stripe_size_attr);
+    free(stripe_index_attr);
+    free(stripe_coalesce_attr);
+
+    return finfo;
 err:
 
-	free(stripe_count_attr);
-	free(stripe_size_attr);
-	free(stripe_index_attr);
-	free(stripe_coalesce_attr);
+    free(stripe_count_attr);
+    free(stripe_size_attr);
+    free(stripe_index_attr);
+    free(stripe_coalesce_attr);
 
-	if (finfo) {
-		close_files(finfo);
-		free(finfo);
-	}
+    if (finfo) {
+        close_files(finfo);
+        free(finfo);
+    }
 
-	return NULL;
+    return NULL;
 }
 
 static int
 close_files(struct file_stripe_info *finfo)
 {
-	int i, ret;
+    int i, ret;
 
-	if (!finfo)
-		return -1;
+    if (!finfo)
+        return -1;
 
-	for (i = 0; i < finfo->stripe_count; i++) {
-		if (finfo->fd[i] == INVALID_FD)
-			continue;
+    for (i = 0; i < finfo->stripe_count; i++) {
+        if (finfo->fd[i] == INVALID_FD)
+            continue;
 
-		ret = close(finfo->fd[i]);
-		if (ret < 0)
-			return ret;
-	}
+        ret = close(finfo->fd[i]);
+        if (ret < 0)
+            return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 /*
@@ -351,43 +357,43 @@ close_files(struct file_stripe_info *finfo)
 static int
 generate_file_coalesce(int target, struct file_stripe_info *finfo)
 {
-	char *buf;
-	int ret = 0;
-	int r, w, i;
-
-	buf = malloc(finfo->stripe_size);
-	if (!buf)
-		return -1;
-
-	i = 0;
-	while (1) {
-		if (finfo->fd[i] == INVALID_FD) {
-			if (lseek(target, finfo->stripe_size, SEEK_CUR) < 0)
-				break;
-
-			i = (i + 1) % finfo->stripe_count;
-			continue;
-		}
-
-		r = read(finfo->fd[i], buf, finfo->stripe_size);
-		if (r < 0) {
-			ret = r;
-			break;
-		}
-		if (!r)
-			break;
-
-		w = write(target, buf, r);
-		if (w < 0) {
-			ret = w;
-			break;
-		}
-
-		i = (i + 1) % finfo->stripe_count;
-	}
-
-	free(buf);
-	return ret;
+    char *buf;
+    int ret = 0;
+    int r, w, i;
+
+    buf = malloc(finfo->stripe_size);
+    if (!buf)
+        return -1;
+
+    i = 0;
+    while (1) {
+        if (finfo->fd[i] == INVALID_FD) {
+            if (lseek(target, finfo->stripe_size, SEEK_CUR) < 0)
+                break;
+
+            i = (i + 1) % finfo->stripe_count;
+            continue;
+        }
+
+        r = read(finfo->fd[i], buf, finfo->stripe_size);
+        if (r < 0) {
+            ret = r;
+            break;
+        }
+        if (!r)
+            break;
+
+        w = write(target, buf, r);
+        if (w < 0) {
+            ret = w;
+            break;
+        }
+
+        i = (i + 1) % finfo->stripe_count;
+    }
+
+    free(buf);
+    return ret;
 }
 
 /*
@@ -398,97 +404,100 @@ generate_file_coalesce(int target, struct file_stripe_info *finfo)
 static int
 generate_file_traditional(int target, struct file_stripe_info *finfo)
 {
-	int i, j, max_ret, ret;
-	char buf[finfo->stripe_count][4096];
-
-	do {
-		char newbuf[4096] = {0, };
-
-		max_ret = 0;
-		for (i = 0; i < finfo->stripe_count; i++) {
-			memset(buf[i], 0, 4096);
-			ret = read(finfo->fd[i], buf[i], 4096);
-			if (ret > max_ret)
-				max_ret = ret;
-		}
-		for (i = 0; i < max_ret; i++)
-			for (j = 0; j < finfo->stripe_count; j++)
-				newbuf[i] |= buf[j][i];
-			write(target, newbuf, max_ret);
-	} while (max_ret);
-
-	return 0;
+    int i, j, max_ret, ret;
+    char buf[finfo->stripe_count][4096];
+
+    do {
+        char newbuf[4096] = {
+            0,
+        };
+
+        max_ret = 0;
+        for (i = 0; i < finfo->stripe_count; i++) {
+            memset(buf[i], 0, 4096);
+            ret = read(finfo->fd[i], buf[i], 4096);
+            if (ret > max_ret)
+                max_ret = ret;
+        }
+        for (i = 0; i < max_ret; i++)
+            for (j = 0; j < finfo->stripe_count; j++)
+                newbuf[i] |= buf[j][i];
+        write(target, newbuf, max_ret);
+    } while (max_ret);
+
+    return 0;
 }
 
 static int
 generate_file(int target, struct file_stripe_info *finfo)
 {
-	if (finfo->coalesce)
-		return generate_file_coalesce(target, finfo);
+    if (finfo->coalesce)
+        return generate_file_coalesce(target, finfo);
 
-	return generate_file_traditional(target, finfo);
+    return generate_file_traditional(target, finfo);
 }
 
 static void
 usage(char *name)
 {
-	fprintf(stderr, "Usage: %s [-o <outputfile>] <inputfile1> "
-		"<inputfile2> ...\n", name);
+    fprintf(stderr,
+            "Usage: %s [-o <outputfile>] <inputfile1> "
+            "<inputfile2> ...\n",
+            name);
 }
 
 int
 main(int argc, char *argv[])
 {
-	int file_count, opt;
-	char *opath = NULL;
-	int targetfd;
-	struct file_stripe_info *finfo;
-
-	while ((opt = getopt(argc, argv, "o:")) != -1) {
-		switch (opt) {
-		case 'o':
-			opath = optarg;
-			break;
-		default:
-			usage(argv[0]);
-			return -1;
-		}
-	}
-
-	file_count = argc - optind;
-
-	if (!opath || !file_count) {
-		usage(argv[0]);
-		return -1;
-	}
-
-	finfo = validate_and_open_files(&argv[optind], file_count);
-	if (!finfo)
-		goto err;
-
-	targetfd = open(opath, O_RDWR|O_CREAT, finfo->mode);
-	if (targetfd < 0)
-		goto err;
-
-	if (generate_file(targetfd, finfo) < 0)
-		goto err;
-
-	if (fsync(targetfd) < 0)
-		fprintf(stderr, "ERROR: %s\n", strerror(errno));
-	if (close(targetfd) < 0)
-		fprintf(stderr, "ERROR: %s\n", strerror(errno));
-
-	close_files(finfo);
-	free(finfo);
-
-	return 0;
+    int file_count, opt;
+    char *opath = NULL;
+    int targetfd;
+    struct file_stripe_info *finfo;
+
+    while ((opt = getopt(argc, argv, "o:")) != -1) {
+        switch (opt) {
+            case 'o':
+                opath = optarg;
+                break;
+            default:
+                usage(argv[0]);
+                return -1;
+        }
+    }
+
+    file_count = argc - optind;
+
+    if (!opath || !file_count) {
+        usage(argv[0]);
+        return -1;
+    }
+
+    finfo = validate_and_open_files(&argv[optind], file_count);
+    if (!finfo)
+        goto err;
+
+    targetfd = open(opath, O_RDWR | O_CREAT, finfo->mode);
+    if (targetfd < 0)
+        goto err;
+
+    if (generate_file(targetfd, finfo) < 0)
+        goto err;
+
+    if (fsync(targetfd) < 0)
+        fprintf(stderr, "ERROR: %s\n", strerror(errno));
+    if (close(targetfd) < 0)
+        fprintf(stderr, "ERROR: %s\n", strerror(errno));
+
+    close_files(finfo);
+    free(finfo);
+
+    return 0;
 
 err:
-	if (finfo) {
-		close_files(finfo);
-		free(finfo);
-	}
+    if (finfo) {
+        close_files(finfo);
+        free(finfo);
+    }
 
-	return -1;
+    return -1;
 }
-
diff --git a/extras/systemd/Makefile.am b/extras/systemd/Makefile.am
index 3988b40bce6..61446a9b84a 100644
--- a/extras/systemd/Makefile.am
+++ b/extras/systemd/Makefile.am
@@ -1,11 +1,17 @@
-CLEANFILES = glusterd.service glustereventsd.service glusterfssharedstorage.service
-EXTRA_DIST = glusterd.service.in glustereventsd.service.in glusterfssharedstorage.service.in
+CLEANFILES = glusterd.service glustereventsd.service glusterfssharedstorage.service gluster-ta-volume.service
+EXTRA_DIST = glusterd.service.in glustereventsd.service.in glusterfssharedstorage.service.in gluster-ta-volume.service.in
 
 if USE_SYSTEMD
+systemd_DATA = gluster-ta-volume.service
+endif
+
+if WITH_SERVER
+if USE_SYSTEMD
 # systemddir is already defined through configure.ac
-systemd_DATA = glusterd.service glusterfssharedstorage.service
+systemd_DATA += glusterd.service glusterfssharedstorage.service
 
 if BUILD_EVENTS
 systemd_DATA += glustereventsd.service
 endif
 endif
+endif
diff --git a/extras/systemd/gluster-ta-volume.service.in b/extras/systemd/gluster-ta-volume.service.in
new file mode 100644
index 00000000000..2802bca05bf
--- /dev/null
+++ b/extras/systemd/gluster-ta-volume.service.in
@@ -0,0 +1,13 @@
+[Unit]
+Description=GlusterFS, Thin-arbiter process to maintain quorum for replica volume
+After=network.target
+
+[Service]
+Environment="LOG_LEVEL=WARNING"
+ExecStart=@prefix@/sbin/glusterfsd -N --volfile-id ta -f @GLUSTERD_WORKDIR@/thin-arbiter/thin-arbiter.vol --brick-port 24007 --xlator-option ta-server.transport.socket.listen-port=24007 -LWARNING
+Restart=always
+KillMode=process
+SuccessExitStatus=15
+
+[Install]
+WantedBy=multi-user.target
diff --git a/extras/systemd/glusterd.service.in b/extras/systemd/glusterd.service.in
index 78f8e40b0e4..abb0d82911f 100644
--- a/extras/systemd/glusterd.service.in
+++ b/extras/systemd/glusterd.service.in
@@ -1,7 +1,10 @@
 [Unit]
 Description=GlusterFS, a clustered file-system server
-Requires=rpcbind.service
-After=network.target rpcbind.service
+Documentation=man:glusterd(8)
+StartLimitBurst=6
+StartLimitIntervalSec=3600
+Requires=@RPCBIND_SERVICE@
+After=network.target @RPCBIND_SERVICE@
 Before=network-online.target
 
 [Service]
@@ -9,10 +12,15 @@ Type=forking
 PIDFile=@localstatedir@/run/glusterd.pid
 LimitNOFILE=65536
 Environment="LOG_LEVEL=INFO"
-EnvironmentFile=-@sysconfdir@/sysconfig/glusterd
+EnvironmentFile=-@SYSCONF_DIR@/sysconfig/glusterd
 ExecStart=@prefix@/sbin/glusterd -p @localstatedir@/run/glusterd.pid  --log-level $LOG_LEVEL $GLUSTERD_OPTIONS
 KillMode=process
+TimeoutSec=300
 SuccessExitStatus=15
+Restart=on-abnormal
+RestartSec=60
+StartLimitBurst=6
+StartLimitInterval=3600
 
 [Install]
 WantedBy=multi-user.target
diff --git a/extras/systemd/glustereventsd.service.in b/extras/systemd/glustereventsd.service.in
index 4bfcf42f386..f80b78199f6 100644
--- a/extras/systemd/glustereventsd.service.in
+++ b/extras/systemd/glustereventsd.service.in
@@ -1,6 +1,8 @@
 [Unit]
 Description=Gluster Events Notifier
-After=syslog.target network.target
+After=network.target
+Documentation=man:glustereventsd(8)
+
 
 [Service]
 Environment=PYTHONPATH=@BUILD_PYTHON_SITE_PACKAGES_EXPANDED@:$PYTHONPATH
diff --git a/extras/test/ld-preload-test/ld-preload-lib.c b/extras/test/ld-preload-test/ld-preload-lib.c
index 8f74a25cf68..d120c053a69 100644
--- a/extras/test/ld-preload-test/ld-preload-lib.c
+++ b/extras/test/ld-preload-test/ld-preload-lib.c
@@ -34,594 +34,582 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <dirent.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <sys/sendfile.h>
 
 /* Err number that is assigned to errno so that test application can
  * verify that the function was intercepted correctly.
  */
-#define PRELOAD_ERRNO_VERF      6449
-#define set_errno()             (errno = PRELOAD_ERRNO_VERF)
+#define PRELOAD_ERRNO_VERF 6449
+#define set_errno() (errno = PRELOAD_ERRNO_VERF)
 
 void
-intercept (char *call, int tabs)
+intercept(char *call, int tabs)
 {
-        while (tabs > 0) {
-                fprintf (stdout, "\t");
-                --tabs;
-        }
+    while (tabs > 0) {
+        fprintf(stdout, "\t");
+        --tabs;
+    }
 
-        fprintf (stdout, "Intercepted by %s", call);
+    fprintf(stdout, "Intercepted by %s", call);
 }
 
 int
-creat64 (const char *pathname, mode_t mode)
+creat64(const char *pathname, mode_t mode)
 {
-        intercept ("creat64", 2);
-        set_errno ();
-        return -1;
+    intercept("creat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-creat (const char *pathname, mode_t mode)
+creat(const char *pathname, mode_t mode)
 {
-        intercept ("creat", 2);
-        set_errno ();
-        return -1;
+    intercept("creat", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-close (int fd)
+close(int fd)
 {
-        intercept ("close", 2);
-        set_errno ();
-        return -1;
+    intercept("close", 2);
+    set_errno();
+    return -1;
 }
 
 int
-open64 (const char *pathname, int flags, ...)
+open64(const char *pathname, int flags, ...)
 {
-        intercept ("open64", 2);
-        set_errno ();
-        return -1;
+    intercept("open64", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-open (const char *pathname, int flags, ...)
+open(const char *pathname, int flags, ...)
 {
-        intercept ("open", 2);
-        set_errno ();
-        return -1;
+    intercept("open", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-read (int fd, void *buf, size_t count)
+read(int fd, void *buf, size_t count)
 {
-        intercept ("read", 2);
-        set_errno ();
-        return -1;
+    intercept("read", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-readv (int fd, const struct iovec *vector, int count)
+readv(int fd, const struct iovec *vector, int count)
 {
-        intercept ("readv", 2);
-        set_errno ();
-        return -1;
+    intercept("readv", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pread (int fd, void *buf, size_t count, unsigned long offset)
+pread(int fd, void *buf, size_t count, unsigned long offset)
 {
-        intercept ("pread", 2);
-        set_errno ();
-        return -1;
+    intercept("pread", 2);
+    set_errno();
+    return -1;
 }
 
-
 ssize_t
-pread64 (int fd, void *buf, size_t count, uint64_t offset)
+pread64(int fd, void *buf, size_t count, uint64_t offset)
 {
-        intercept ("pread64", 2);
-        set_errno ();
-        return -1;
+    intercept("pread64", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-write (int fd, const void *buf, size_t count)
+write(int fd, const void *buf, size_t count)
 {
-        intercept ("write", 2);
-        set_errno ();
-        return -1;
+    intercept("write", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-writev (int fd, const struct iovec *vector, int count)
+writev(int fd, const struct iovec *vector, int count)
 {
-        intercept ("writev", 2);
-        set_errno ();
-        return -1;
+    intercept("writev", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pwrite (int fd, const void *buf, size_t count, unsigned long offset)
+pwrite(int fd, const void *buf, size_t count, unsigned long offset)
 {
-        intercept ("pwrite", 2);
-        set_errno ();
-        return -1;
+    intercept("pwrite", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pwrite64 (int fd, const void *buf, size_t count, uint64_t offset)
+pwrite64(int fd, const void *buf, size_t count, uint64_t offset)
 {
-        intercept ("pwrite64", 2);
-        set_errno ();
-        return -1;
+    intercept("pwrite64", 2);
+    set_errno();
+    return -1;
 }
 
-
 off_t
-lseek (int fildes, unsigned long offset, int whence)
+lseek(int fildes, unsigned long offset, int whence)
 {
-        intercept ("lseek", 2);
-        set_errno ();
-        return -1;
+    intercept("lseek", 2);
+    set_errno();
+    return -1;
 }
 
 off_t
-lseek64 (int fildes, uint64_t offset, int whence)
+lseek64(int fildes, uint64_t offset, int whence)
 {
-        intercept ("lseek64", 2);
-        set_errno ();
-        return -1;
+    intercept("lseek64", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-dup (int fd)
+dup(int fd)
 {
-        intercept ("dup", 2);
-        set_errno ();
-        return -1;
+    intercept("dup", 2);
+    set_errno();
+    return -1;
 }
 
 int
-dup2 (int oldfd, int newfd)
+dup2(int oldfd, int newfd)
 {
-        intercept ("dup2", 2);
-        set_errno ();
-        return -1;
+    intercept("dup2", 2);
+    set_errno();
+    return -1;
 }
 
 int
-mkdir (const char *pathname, mode_t mode)
+mkdir(const char *pathname, mode_t mode)
 {
-        intercept ("mkdir", 2);
-        set_errno ();
-        return -1;
+    intercept("mkdir", 2);
+    set_errno();
+    return -1;
 }
 
 int
-rmdir (const char *pathname)
+rmdir(const char *pathname)
 {
-        intercept ("rmdir", 2);
-        set_errno ();
-        return -1;
+    intercept("rmdir", 2);
+    set_errno();
+    return -1;
 }
 
 int
-chmod (const char *pathname, mode_t mode)
+chmod(const char *pathname, mode_t mode)
 {
-        intercept ("chmod", 2);
-        set_errno ();
-        return -1;
+    intercept("chmod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-chown (const char *pathname, uid_t owner, gid_t group)
+chown(const char *pathname, uid_t owner, gid_t group)
 {
-        intercept ("chown", 2);
-        set_errno ();
-        return -1;
+    intercept("chown", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fchmod (int fd, mode_t mode)
+fchmod(int fd, mode_t mode)
 {
-        intercept ("fchmod", 2);
-        set_errno ();
-        return -1;
+    intercept("fchmod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fchown (int fd, uid_t uid, gid_t gid)
+fchown(int fd, uid_t uid, gid_t gid)
 {
-        intercept ("fchown", 2);
-        set_errno ();
-        return -1;
+    intercept("fchown", 2);
+    set_errno();
+    return -1;
 }
 
-int fsync (int fd)
+int
+fsync(int fd)
 {
-        intercept ("fsync", 2);
-        set_errno ();
-        return -1;
+    intercept("fsync", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-ftruncate (int fd, off_t length)
+ftruncate(int fd, off_t length)
 {
-        intercept ("ftruncate", 1);
-        set_errno ();
-        return -1;
+    intercept("ftruncate", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-ftruncate64 (int fd, off_t length)
+ftruncate64(int fd, off_t length)
 {
-        intercept ("ftruncate64", 1);
-        set_errno ();
-        return -1;
+    intercept("ftruncate64", 1);
+    set_errno();
+    return -1;
 }
 
 int
-link (const char *oldpath, const char *newname)
+link(const char *oldpath, const char *newname)
 {
-        intercept ("link", 2);
-        set_errno ();
-        return -1;
+    intercept("link", 2);
+    set_errno();
+    return -1;
 }
 
 int
-rename (const char *oldpath, const char *newpath)
+rename(const char *oldpath, const char *newpath)
 {
-        intercept ("rename", 2);
-        set_errno ();
-        return -1;
+    intercept("rename", 2);
+    set_errno();
+    return -1;
 }
 
 int
-utimes (const char *path, const struct timeval times[2])
+utimes(const char *path, const struct timeval times[2])
 {
-        intercept ("utimes", 2);
-        set_errno ();
-        return -1;
+    intercept("utimes", 2);
+    set_errno();
+    return -1;
 }
 
 int
-utime (const char *path, const struct utimbuf *buf)
+futimes(int fd, const struct timeval times[2])
 {
-        intercept ("utime", 2);
-        set_errno ();
-        return -1;
+    intercept("futimes", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-mknod (const char *path, mode_t mode, dev_t dev)
+utime(const char *path, const struct utimbuf *buf)
 {
-        intercept ("mknod", 2);
-        set_errno ();
-        return -1;
+    intercept("utime", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__xmknod (int ver, const char *path, mode_t mode, dev_t *dev)
+mknod(const char *path, mode_t mode, dev_t dev)
 {
-        intercept ("__xmknod", 2);
-        set_errno ();
-        return -1;
+    intercept("mknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-mkfifo (const char *path, mode_t mode)
+__xmknod(int ver, const char *path, mode_t mode, dev_t *dev)
 {
-        intercept ("mkfifo", 2);
-        set_errno ();
-        return -1;
+    intercept("__xmknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-unlink (const char *path)
+mkfifo(const char *path, mode_t mode)
 {
-        intercept ("unlink", 2);
-        set_errno ();
-        return -1;
+    intercept("mkfifo", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-symlink (const char *oldpath, const char *newpath)
+unlink(const char *path)
 {
-        intercept ("symlink", 2);
-        set_errno ();
-        return -1;
+    intercept("unlink", 2);
+    set_errno();
+    return -1;
 }
 
 int
-readlink (const char *path, char *buf, size_t bufsize)
+symlink(const char *oldpath, const char *newpath)
 {
-        intercept ("readlink", 1);
-        set_errno ();
-        return -1;
+    intercept("symlink", 2);
+    set_errno();
+    return -1;
 }
 
+int
+readlink(const char *path, char *buf, size_t bufsize)
+{
+    intercept("readlink", 1);
+    set_errno();
+    return -1;
+}
 
 char *
-realpath (const char *path, char *resolved)
+realpath(const char *path, char *resolved)
 {
-        intercept ("realpath", 1);
-        set_errno ();
-        return NULL;
+    intercept("realpath", 1);
+    set_errno();
+    return NULL;
 }
 
-
 DIR *
-opendir (const char *path)
+opendir(const char *path)
 {
-        intercept ("opendir", 2);
-        set_errno ();
-        return NULL;
+    intercept("opendir", 2);
+    set_errno();
+    return NULL;
 }
 
-
 struct dirent *
-readdir (DIR *dir)
+readdir(DIR *dir)
 {
-        intercept ("readdir\t", 2);
-        set_errno ();
-        return NULL;
+    intercept("readdir\t", 2);
+    set_errno();
+    return NULL;
 }
 
 struct dirent *
-readdir64 (DIR *dir)
+readdir64(DIR *dir)
 {
-        intercept ("readdir64", 2);
-        set_errno ();
-        return NULL;
+    intercept("readdir64", 2);
+    set_errno();
+    return NULL;
 }
 
-
 int
-readdir_r (DIR *dir, struct dirent *entry, struct dirent **result)
+readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
 {
-        intercept ("readdir_r", 1);
-        set_errno ();
-        return -1;
+    intercept("readdir_r", 1);
+    set_errno();
+    return -1;
 }
 
 int
-readdir64_r (DIR *dir, struct dirent *entry, struct dirent **result)
+readdir64_r(DIR *dir, struct dirent *entry, struct dirent **result)
 {
-        intercept ("readdir64_r", 1);
-        set_errno ();
-        return -1;
+    intercept("readdir64_r", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-closedir (DIR *dh)
+closedir(DIR *dh)
 {
-        intercept ("closedir", 1);
-        set_errno ();
-        return -1;
+    intercept("closedir", 1);
+    set_errno();
+    return -1;
 }
 
 int
-__xstat (int ver, const char *path, struct stat *buf)
+__xstat(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__xstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__xstat\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-__xstat64 (int ver, const char *path, struct stat *buf)
+__xstat64(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__xstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__xstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-stat (const char *path, struct stat *buf)
+stat(const char *path, struct stat *buf)
 {
-        intercept ("stat", 2);
-        set_errno ();
-        return -1;
+    intercept("stat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-stat64 (const char *path, struct stat *buf)
+stat64(const char *path, struct stat *buf)
 {
-        intercept ("stat64", 2);
-        set_errno ();
-        return -1;
+    intercept("stat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__fxstat (int ver, int fd, struct stat *buf)
+__fxstat(int ver, int fd, struct stat *buf)
 {
-        intercept ("__fxstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__fxstat\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-__fxstat64 (int ver, int fd, struct stat *buf)
+__fxstat64(int ver, int fd, struct stat *buf)
 {
-        intercept ("__fxstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__fxstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fstat (int fd, struct stat *buf)
+fstat(int fd, struct stat *buf)
 {
-        intercept ("fstat", 2);
-        set_errno ();
-        return -1;
+    intercept("fstat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fstat64 (int fd , struct stat *buf)
+fstat64(int fd, struct stat *buf)
 {
-        intercept ("fstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("fstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__lxstat (int ver, const char *path, struct stat *buf)
+__lxstat(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__lxstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__lxstat\t", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__lxstat64 (int ver, const char *path, struct stat *buf)
+__lxstat64(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__lxstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__lxstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lstat (const char *path, struct stat *buf)
+lstat(const char *path, struct stat *buf)
 {
-        intercept ("lstat", 2);
-        set_errno ();
-        return -1;
+    intercept("lstat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lstat64 (const char *path, struct stat *buf)
+lstat64(const char *path, struct stat *buf)
 {
-        intercept ("lstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("lstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-statfs (const char *path, struct statfs *buf)
+statfs(const char *path, struct statfs *buf)
 {
-        intercept ("statfs", 2);
-        set_errno ();
-        return -1;
+    intercept("statfs", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-statfs64 (const char *path, struct statfs *buf)
+statfs64(const char *path, struct statfs *buf)
 {
-        intercept ("statfs64", 2);
-        set_errno ();
-        return -1;
+    intercept("statfs64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-statvfs (const char *path, struct statvfs *buf)
+statvfs(const char *path, struct statvfs *buf)
 {
-        intercept ("statvfs\t", 2);
-        set_errno ();
-        return -1;
+    intercept("statvfs\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-statvfs64 (const char *path, struct statvfs *buf)
+statvfs64(const char *path, struct statvfs *buf)
 {
-        intercept ("statvfs64", 2);
-        set_errno ();
-        return -1;
+    intercept("statvfs64", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-getxattr (const char *path, const char *name, void *value, size_t size)
+getxattr(const char *path, const char *name, void *value, size_t size)
 {
-        intercept ("getxattr", 1);
-        set_errno ();
-        return -1;
+    intercept("getxattr", 1);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-lgetxattr (const char *path, const char *name, void *value, size_t size)
+lgetxattr(const char *path, const char *name, void *value, size_t size)
 {
-        intercept ("lgetxattr", 1);
-        set_errno ();
-        return -1;
+    intercept("lgetxattr", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-remove (const char* path)
+remove(const char *path)
 {
-        intercept ("remove", 2);
-        set_errno ();
-        return -1;
+    intercept("remove", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lchown (const char *path, uid_t owner, gid_t group)
+lchown(const char *path, uid_t owner, gid_t group)
 {
-        intercept ("lchown", 2);
-        set_errno ();
-        return -1;
+    intercept("lchown", 2);
+    set_errno();
+    return -1;
 }
 
 void
-rewinddir (DIR *dirp)
+rewinddir(DIR *dirp)
 {
-        intercept ("rewinddir", 1);
-        set_errno ();
-        return;
+    intercept("rewinddir", 1);
+    set_errno();
+    return;
 }
 
 void
-seekdir (DIR *dirp, off_t offset)
+seekdir(DIR *dirp, off_t offset)
 {
-        intercept ("seekdir", 2);
-        set_errno ();
-        return;
+    intercept("seekdir", 2);
+    set_errno();
+    return;
 }
 
 off_t
-telldir (DIR *dirp)
+telldir(DIR *dirp)
 {
-        intercept ("telldir", 2);
-        set_errno ();
-        return -1;
+    intercept("telldir", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-sendfile (int out_fd, int in_fd, off_t *offset, size_t count)
+sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
 {
-        intercept ("sendfile\t", 1);
-        set_errno ();
-        return -1;
+    intercept("sendfile\t", 1);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-sendfile64 (int out_fd, int in_fd, off_t *offset, size_t count)
+sendfile64(int out_fd, int in_fd, off_t *offset, size_t count)
 {
-        intercept ("sendfile64", 1);
-        set_errno ();
-        return -1;
+    intercept("sendfile64", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-fcntl (int fd, int cmd, ...)
+fcntl(int fd, int cmd, ...)
 {
-        intercept ("fcntl", 2);
-        set_errno ();
-        return -1;
+    intercept("fcntl", 2);
+    set_errno();
+    return -1;
 }
-
diff --git a/extras/test/ld-preload-test/ld-preload-test.c b/extras/test/ld-preload-test/ld-preload-test.c
index cf8dd52c3e1..54dde8c7d54 100644
--- a/extras/test/ld-preload-test/ld-preload-test.c
+++ b/extras/test/ld-preload-test/ld-preload-test.c
@@ -46,322 +46,313 @@
 #include <sys/uio.h>
 #include <utime.h>
 #include <sys/time.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <sys/sendfile.h>
 
-
-#define PRELOAD_ERRNO_VERF      6449
+#define PRELOAD_ERRNO_VERF 6449
 void
 check_err(int ret, char *call, int tabs)
 {
-        while (tabs > 0) {
-                fprintf (stdout, "\t");
-                --tabs;
-        }
-        if (ret != -1) {
-                fprintf (stdout, "Not intercepted: %s\n", call);
-                return;
-        }
-
-        if (errno != PRELOAD_ERRNO_VERF) {
-                fprintf (stdout, "Not intercepted: %s: err: %s\n", call,
-                         strerror (errno));
-                return;
-        }
+    while (tabs > 0) {
+        fprintf(stdout, "\t");
+        --tabs;
+    }
+    if (ret != -1) {
+        fprintf(stdout, "Not intercepted: %s\n", call);
+        return;
+    }
 
-        fprintf (stdout, "Intercept verified: %s\n", call);
+    if (errno != PRELOAD_ERRNO_VERF) {
+        fprintf(stdout, "Not intercepted: %s: err: %s\n", call,
+                strerror(errno));
         return;
+    }
+
+    fprintf(stdout, "Intercept verified: %s\n", call);
+    return;
 }
 
 void
-usage (FILE *fp)
+usage(FILE *fp)
 {
-        fprintf (fp, "Usage: ld-preload-test <Options>\n");
-        fprintf (fp, "Options\n");
-        fprintf (fp, "\t--path\t\tPathname is used as the file/directory"
-                     " created for the test.\n");
-
+    fprintf(fp, "Usage: ld-preload-test <Options>\n");
+    fprintf(fp, "Options\n");
+    fprintf(fp,
+            "\t--path\t\tPathname is used as the file/directory"
+            " created for the test.\n");
 }
 
-
 int
-run_file_tests (char *testfile)
+run_file_tests(char *testfile)
 {
-        int             ret = -1;
-        struct stat     buf;
+    int ret = -1;
+    struct stat buf;
 
-        assert (testfile);
-        fprintf (stdout, "Testing creat");
-        ret = creat (testfile, S_IRWXU);
-        check_err (ret, "creat", 2);
+    assert(testfile);
+    fprintf(stdout, "Testing creat");
+    ret = creat(testfile, S_IRWXU);
+    check_err(ret, "creat", 2);
 
-        fprintf (stdout, "Testing close");
-        ret = close (ret);
-        check_err (ret, "close", 2);
+    fprintf(stdout, "Testing close");
+    ret = close(ret);
+    check_err(ret, "close", 2);
 
-        fprintf (stdout, "Testing open");
-        ret = open (testfile, O_RDONLY);
-        check_err (ret, "open", 2);
+    fprintf(stdout, "Testing open");
+    ret = open(testfile, O_RDONLY);
+    check_err(ret, "open", 2);
 
-        fprintf (stdout, "Testing read");
-        ret = read (0, NULL, 0);
-        check_err (ret, "read", 2);
+    fprintf(stdout, "Testing read");
+    ret = read(0, NULL, 0);
+    check_err(ret, "read", 2);
 
-        fprintf (stdout, "Testing readv");
-        ret = readv (0, NULL, 0);
-        check_err (ret, "readv", 2);
+    fprintf(stdout, "Testing readv");
+    ret = readv(0, NULL, 0);
+    check_err(ret, "readv", 2);
 
-        fprintf (stdout, "Testing pread");
-        ret = pread (0, NULL, 0, 0);
-        check_err (ret, "pread", 2);
+    fprintf(stdout, "Testing pread");
+    ret = pread(0, NULL, 0, 0);
+    check_err(ret, "pread", 2);
 
-        fprintf (stdout, "Testing write");
-        ret = write (0, NULL, 0);
-        check_err (ret, "write", 2);
+    fprintf(stdout, "Testing write");
+    ret = write(0, NULL, 0);
+    check_err(ret, "write", 2);
 
-        fprintf (stdout, "Testing writev");
-        ret = writev (0, NULL, 0);
-        check_err (ret, "writev", 2);
+    fprintf(stdout, "Testing writev");
+    ret = writev(0, NULL, 0);
+    check_err(ret, "writev", 2);
 
-        fprintf (stdout, "Testing pwrite");
-        ret = pwrite (0, NULL, 0, 0);
-        check_err (ret, "pwrite", 2);
+    fprintf(stdout, "Testing pwrite");
+    ret = pwrite(0, NULL, 0, 0);
+    check_err(ret, "pwrite", 2);
 
-        fprintf (stdout, "Testing lseek");
-        ret = lseek (0, 0, 0);
-        check_err (ret, "lseek", 2);
+    fprintf(stdout, "Testing lseek");
+    ret = lseek(0, 0, 0);
+    check_err(ret, "lseek", 2);
 
-        fprintf (stdout, "Testing dup");
-        ret = dup (0);
-        check_err (ret, "dup", 2);
+    fprintf(stdout, "Testing dup");
+    ret = dup(0);
+    check_err(ret, "dup", 2);
 
-        fprintf (stdout, "Testing dup2");
-        ret = dup2 (0, 0);
-        check_err (ret, "dup2", 2);
+    fprintf(stdout, "Testing dup2");
+    ret = dup2(0, 0);
+    check_err(ret, "dup2", 2);
 
-        fprintf (stdout, "Testing fchmod");
-        ret = fchmod (0, 0);
-        check_err (ret, "fchmod", 2);
+    fprintf(stdout, "Testing fchmod");
+    ret = fchmod(0, 0);
+    check_err(ret, "fchmod", 2);
 
-        fprintf (stdout, "Testing fchown");
-        ret = fchown (0, 0, 0);
-        check_err (ret, "fchown", 2);
+    fprintf(stdout, "Testing fchown");
+    ret = fchown(0, 0, 0);
+    check_err(ret, "fchown", 2);
 
-        fprintf (stdout, "Testing fsync");
-        ret = fsync (0);
-        check_err (ret, "fsync", 2);
+    fprintf(stdout, "Testing fsync");
+    ret = fsync(0);
+    check_err(ret, "fsync", 2);
 
-        fprintf (stdout, "Testing ftruncate");
-        ret = ftruncate (0, 0);
-        check_err (ret, "ftruncate", 1);
+    fprintf(stdout, "Testing ftruncate");
+    ret = ftruncate(0, 0);
+    check_err(ret, "ftruncate", 1);
 
-        fprintf (stdout, "Testing fstat");
-        ret = fstat (0, &buf);
-        check_err (ret, "fstat", 1);
+    fprintf(stdout, "Testing fstat");
+    ret = fstat(0, &buf);
+    check_err(ret, "fstat", 1);
 
-        fprintf (stdout, "Testing sendfile");
-        ret = sendfile (0, 0, NULL, 0);
-        check_err (ret, "sendfile", 1);
+    fprintf(stdout, "Testing sendfile");
+    ret = sendfile(0, 0, NULL, 0);
+    check_err(ret, "sendfile", 1);
 
-        fprintf (stdout, "Testing fcntl");
-        ret = fcntl (0, 0, NULL);
-        check_err (ret, "fcntl", 2);
+    fprintf(stdout, "Testing fcntl");
+    ret = fcntl(0, 0, NULL);
+    check_err(ret, "fcntl", 2);
 
-        fprintf (stdout, "Testing close");
-        ret = close (ret);
-        check_err (ret, "close", 2);
+    fprintf(stdout, "Testing close");
+    ret = close(ret);
+    check_err(ret, "close", 2);
 
-        fprintf (stdout, "Testing remove");
-        ret = remove (testfile);
-        check_err (ret, "remove", 2);
+    fprintf(stdout, "Testing remove");
+    ret = remove(testfile);
+    check_err(ret, "remove", 2);
 
-        return ret;
+    return ret;
 }
 
-
 int
-run_attr_tests (char *testfile)
+run_attr_tests(char *testfile)
 {
-        int             ret = -1;
-        char            *res = NULL;
-        struct stat     buf;
-        struct statfs   sbuf;
-        struct statvfs  svbuf;
-
-        assert (testfile);
-
-        fprintf (stdout, "Testing chmod");
-        ret = chmod (testfile, 0);
-        check_err (ret, "chmod", 2);
-
-        fprintf (stdout, "Testing chown");
-        ret = chown (testfile, 0, 0);
-        check_err (ret, "chown", 2);
-
-        fprintf (stdout, "Testing link");
-        ret = link (testfile, testfile);
-        check_err (ret, "link", 2);
-
-        fprintf (stdout, "Testing rename");
-        ret = rename (testfile, testfile);
-        check_err (ret, "rename", 2);
-
-        fprintf (stdout, "Testing utimes");
-        ret = utimes (testfile, NULL);
-        check_err (ret, "utimes", 2);
-
-        fprintf (stdout, "Testing utime");
-        ret = utime (testfile, NULL);
-        check_err (ret, "utime", 2);
-
-        fprintf (stdout, "Testing unlink");
-        ret = unlink (testfile);
-        check_err (ret, "unlink", 2);
-
-        fprintf (stdout, "Testing symlink");
-        ret = symlink (testfile, testfile);
-        check_err (ret, "symlink", 2);
-
-        fprintf (stdout, "Testing readlink");
-        ret = readlink (testfile, testfile, 0);
-        check_err (ret, "readlink", 2);
-
-        fprintf (stdout, "Testing realpath");
-        ret = 0;
-        res = realpath ((const char *)testfile, testfile);
-        if (!res)
-                ret = -1;
-        check_err (ret, "realpath", 2);
-
-        fprintf (stdout, "Testing stat");
-        ret = stat (testfile, &buf);
-        check_err (ret, "stat", 1);
-
-        fprintf (stdout, "Testing lstat");
-        ret = lstat (testfile, &buf);
-        check_err (ret, "lstat", 1);
-
-        fprintf (stdout, "Testing statfs");
-        ret = statfs (testfile, &sbuf);
-        check_err (ret, "statfs", 2);
-
-        fprintf (stdout, "Testing statvfs");
-        ret = statvfs (testfile, &svbuf);
-        check_err (ret, "statvfs", 1);
-
-        fprintf (stdout, "Testing getxattr");
-        ret = getxattr (testfile, NULL, NULL, 0);
-        check_err (ret, "getxattr", 2);
-
-        fprintf (stdout, "Testing lgetxattr");
-        ret = lgetxattr (testfile, NULL, NULL, 0);
-        check_err (ret, "lgetxattr", 1);
-
-        fprintf (stdout, "Testing lchown");
-        ret = lchown (testfile, 0, 0);
-        check_err (ret, "lchown", 2);
-        return 0;
+    int ret = -1;
+    char *res = NULL;
+    struct stat buf;
+    struct statfs sbuf;
+    struct statvfs svbuf;
+
+    assert(testfile);
+
+    fprintf(stdout, "Testing chmod");
+    ret = chmod(testfile, 0);
+    check_err(ret, "chmod", 2);
+
+    fprintf(stdout, "Testing chown");
+    ret = chown(testfile, 0, 0);
+    check_err(ret, "chown", 2);
+
+    fprintf(stdout, "Testing link");
+    ret = link(testfile, testfile);
+    check_err(ret, "link", 2);
+
+    fprintf(stdout, "Testing rename");
+    ret = rename(testfile, testfile);
+    check_err(ret, "rename", 2);
+
+    fprintf(stdout, "Testing utimes");
+    ret = utimes(testfile, NULL);
+    check_err(ret, "utimes", 2);
+
+    fprintf(stdout, "Testing utime");
+    ret = utime(testfile, NULL);
+    check_err(ret, "utime", 2);
+
+    fprintf(stdout, "Testing unlink");
+    ret = unlink(testfile);
+    check_err(ret, "unlink", 2);
+
+    fprintf(stdout, "Testing symlink");
+    ret = symlink(testfile, testfile);
+    check_err(ret, "symlink", 2);
+
+    fprintf(stdout, "Testing readlink");
+    ret = readlink(testfile, testfile, 0);
+    check_err(ret, "readlink", 2);
+
+    fprintf(stdout, "Testing realpath");
+    ret = 0;
+    res = realpath((const char *)testfile, testfile);
+    if (!res)
+        ret = -1;
+    check_err(ret, "realpath", 2);
+
+    fprintf(stdout, "Testing stat");
+    ret = stat(testfile, &buf);
+    check_err(ret, "stat", 1);
+
+    fprintf(stdout, "Testing lstat");
+    ret = lstat(testfile, &buf);
+    check_err(ret, "lstat", 1);
+
+    fprintf(stdout, "Testing statfs");
+    ret = statfs(testfile, &sbuf);
+    check_err(ret, "statfs", 2);
+
+    fprintf(stdout, "Testing statvfs");
+    ret = statvfs(testfile, &svbuf);
+    check_err(ret, "statvfs", 1);
+
+    fprintf(stdout, "Testing getxattr");
+    ret = getxattr(testfile, NULL, NULL, 0);
+    check_err(ret, "getxattr", 2);
+
+    fprintf(stdout, "Testing lgetxattr");
+    ret = lgetxattr(testfile, NULL, NULL, 0);
+    check_err(ret, "lgetxattr", 1);
+
+    fprintf(stdout, "Testing lchown");
+    ret = lchown(testfile, 0, 0);
+    check_err(ret, "lchown", 2);
+    return 0;
 }
 
-
 int
-run_dev_tests (char *testfile)
+run_dev_tests(char *testfile)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        assert (testfile);
+    assert(testfile);
 
-        fprintf (stdout, "Testing mknod");
-        ret = mknod (testfile, 0, 0);
-        check_err (ret, "mknod", 2);
+    fprintf(stdout, "Testing mknod");
+    ret = mknod(testfile, 0, 0);
+    check_err(ret, "mknod", 2);
 
-        fprintf (stdout, "Testing mkfifo");
-        ret = mkfifo (testfile, 0);
-        check_err (ret, "mkfifo", 2);
-        return 0;
+    fprintf(stdout, "Testing mkfifo");
+    ret = mkfifo(testfile, 0);
+    check_err(ret, "mkfifo", 2);
+    return 0;
 }
 
 int
-run_dir_tests (char *testpath)
+run_dir_tests(char *testpath)
 {
-        int             ret = -1;
-        DIR             *dh = NULL;
-        struct dirent   *dire = NULL;
-
-        assert (testpath);
-
-        fprintf (stdout, "Testing mkdir");
-        ret = mkdir (testpath, 0);
-        check_err (ret, "mkdir", 2);
-
-        fprintf (stdout, "Testing rmdir");
-        ret = rmdir (testpath);
-        check_err (ret, "rmdir", 2);
-
-        fprintf (stdout, "Testing opendir");
-        ret = 0;
-        dh = opendir (testpath);
-        if (!dh)
-                ret = -1;
-        check_err (ret, "opendir", 2);
-
-        fprintf (stdout, "Testing readdir");
-        ret = 0;
-        dire = readdir (dh);
-        if (!dire)
-                ret = -1;
-        check_err (ret, "readdir", 1);
-
-        fprintf (stdout, "Testing readdir_r");
-        ret = readdir_r (dh, dire, &dire);
-        check_err (ret, "readdir_r", 1);
-
-        fprintf (stdout, "Testing rewinddir");
-        rewinddir (dh);
-        check_err (-1, "rewinddir", 1);
-
-        fprintf (stdout, "Testing seekdir");
-        seekdir (dh, 0);
-        check_err (-1, "seekdir", 2);
-
-        fprintf (stdout, "Testing telldir");
-        ret = telldir (dh);
-        check_err (ret, "telldir", 2);
-
-        fprintf (stdout, "Testing closedir");
-        ret = closedir (dh);
-        check_err (ret, "closedir", 2);
-        return 0;
+    int ret = -1;
+    DIR *dh = NULL;
+    struct dirent *dire = NULL;
+
+    assert(testpath);
+
+    fprintf(stdout, "Testing mkdir");
+    ret = mkdir(testpath, 0);
+    check_err(ret, "mkdir", 2);
+
+    fprintf(stdout, "Testing rmdir");
+    ret = rmdir(testpath);
+    check_err(ret, "rmdir", 2);
+
+    fprintf(stdout, "Testing opendir");
+    ret = 0;
+    dh = opendir(testpath);
+    if (!dh)
+        ret = -1;
+    check_err(ret, "opendir", 2);
+
+    fprintf(stdout, "Testing readdir");
+    ret = 0;
+    dire = readdir(dh);
+    if (!dire)
+        ret = -1;
+    check_err(ret, "readdir", 1);
+
+    fprintf(stdout, "Testing readdir_r");
+    ret = readdir_r(dh, dire, &dire);
+    check_err(ret, "readdir_r", 1);
+
+    fprintf(stdout, "Testing rewinddir");
+    rewinddir(dh);
+    check_err(-1, "rewinddir", 1);
+
+    fprintf(stdout, "Testing seekdir");
+    seekdir(dh, 0);
+    check_err(-1, "seekdir", 2);
+
+    fprintf(stdout, "Testing telldir");
+    ret = telldir(dh);
+    check_err(ret, "telldir", 2);
+
+    fprintf(stdout, "Testing closedir");
+    ret = closedir(dh);
+    check_err(ret, "closedir", 2);
+    return 0;
 }
 
-
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char            *testpath = NULL;
-        int             x = 0;
-
-        for (;x < argc; ++x) {
-                if (strcmp (argv[x], "--path") == 0) {
-                        testpath = argv[x+1];
-                        continue;
-                }
+    char *testpath = NULL;
+    int x = 0;
 
+    for (; x < argc; ++x) {
+        if (strcmp(argv[x], "--path") == 0) {
+            testpath = argv[x + 1];
+            continue;
         }
+    }
 
-        if (!testpath) {
-                fprintf (stderr, "--path not specified\n");
-                usage (stderr);
-                return -1;
-        }
+    if (!testpath) {
+        fprintf(stderr, "--path not specified\n");
+        usage(stderr);
+        return -1;
+    }
 
-        run_file_tests (testpath);
-        run_dir_tests (testpath);
-        run_attr_tests (testpath);
-        run_dev_tests (testpath);
+    run_file_tests(testpath);
+    run_dir_tests(testpath);
+    run_attr_tests(testpath);
+    run_dev_tests(testpath);
 
-        return 0;
+    return 0;
 }
-
-
diff --git a/extras/test/open-fd-tests.c b/extras/test/open-fd-tests.c
index 4184079d043..509952b4180 100644
--- a/extras/test/open-fd-tests.c
+++ b/extras/test/open-fd-tests.c
@@ -4,61 +4,64 @@
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <errno.h>
 #include <string.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          ret      = -1;
-        int          fd       = 0;
-        char        *filename = NULL;
-        int          loop     = 0;
-        struct stat  stbuf    = {0,};
-        char         string[1024] = {0,};
+    int ret = -1;
+    int fd = 0;
+    char *filename = NULL;
+    int loop = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char string[1024] = {
+        0,
+    };
 
-        if (argc > 1)
-                filename = argv[1];
+    if (argc > 1)
+        filename = argv[1];
 
-        if (!filename)
-                filename = "temp-fd-test-file";
+    if (!filename)
+        filename = "temp-fd-test-file";
 
-        fd = open (filename, O_RDWR|O_CREAT|O_TRUNC);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        while (loop < 1000) {
-                /* Use it as a mechanism to test time delays */
-                memset (string, 0, 1024);
-                scanf ("%s", string);
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
 
-                ret = write (fd, string, strlen (string));
-                if (ret != strlen (string)) {
-                        fprintf (stderr, "write failed : %s (%s %d)\n",
-                                 strerror (errno), string, loop);
-                        goto out;
-                }
+    while (loop < 1000) {
+        /* Use it as a mechanism to test time delays */
+        memset(string, 0, 1024);
+        scanf("%s", string);
 
-                ret = write (fd, "\n", 1);
-                if (ret != 1) {
-                        fprintf (stderr, "write failed : %s (%d)\n",
-                                 strerror (errno), loop);
-                        goto out;
-                }
+        ret = write(fd, string, strlen(string));
+        if (ret != strlen(string)) {
+            fprintf(stderr, "write failed : %s (%s %d)\n", strerror(errno),
+                    string, loop);
+            goto out;
+        }
 
-                loop++;
+        ret = write(fd, "\n", 1);
+        if (ret != 1) {
+            fprintf(stderr, "write failed : %s (%d)\n", strerror(errno), loop);
+            goto out;
         }
 
-        fprintf (stdout, "finishing the test after %d loops\n", loop);
+        loop++;
+    }
+
+    fprintf(stdout, "finishing the test after %d loops\n", loop);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/extras/test/test-ffop.c b/extras/test/test-ffop.c
index 219dd6a2da2..1d9c125db67 100644
--- a/extras/test/test-ffop.c
+++ b/extras/test/test-ffop.c
@@ -3,777 +3,825 @@
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <errno.h>
 #include <string.h>
 #include <dirent.h>
 
-int fd_based_fops_1 (char *filename); //for fd based fops after unlink
-int fd_based_fops_2 (char *filename); //for fd based fops before unlink
-int dup_fd_based_fops (char *filename); // fops based on fd after dup
-int path_based_fops (char *filename); //for fops based on path
-int dir_based_fops (char *filename); // for fops which operate on directory
-int link_based_fops (char *filename); //for fops which operate in link files (symlinks)
-int test_open_modes (char *filename); // to test open syscall with open modes available.
-int generic_open_read_write (char *filename, int flag); // generic function which does open write and read.
+int
+fd_based_fops_1(char *filename);  // for fd based fops after unlink
+int
+fd_based_fops_2(char *filename);  // for fd based fops before unlink
+int
+dup_fd_based_fops(char *filename);  // fops based on fd after dup
+int
+path_based_fops(char *filename);  // for fops based on path
+int
+dir_based_fops(char *filename);  // for fops which operate on directory
+int
+link_based_fops(
+    char *filename);  // for fops which operate in link files (symlinks)
+int
+test_open_modes(
+    char *filename);  // to test open syscall with open modes available.
+int
+generic_open_read_write(
+    char *filename,
+    int flag);  // generic function which does open write and read.
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret           = -1;
-        char  filename[255] = {0,};
-
-        if (argc > 1)
-                strcpy(filename, argv[1]);
-        else
-                strcpy(filename, "temp-xattr-test-file");
-
-        ret = fd_based_fops_1 (strcat(filename, "_1"));
-        if (ret < 0)
-                fprintf (stderr, "fd based file operation 1 failed\n");
-        else
-                fprintf (stdout, "fd based file operation 1 passed\n");
-
-        ret = fd_based_fops_2 (strcat(filename, "_2"));
-        if (ret < 0)
-                fprintf (stderr, "fd based file operation 2 failed\n");
-        else
-                fprintf (stdout, "fd based file operation 2 passed\n");
-
-        ret = dup_fd_based_fops (strcat (filename, "_3"));
-        if (ret < 0)
-                fprintf (stderr, "dup fd based file operation failed\n");
-        else
-                fprintf (stdout, "dup fd based file operation passed\n");
-
-        ret = path_based_fops (strcat (filename, "_4"));
-        if (ret < 0)
-                fprintf (stderr, "path based file operation failed\n");
-        else
-                fprintf (stdout, "path based file operation passed\n");
-
-        ret = dir_based_fops (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "directory based file operation failed\n");
-        else
-                fprintf (stdout, "directory based file operation passed\n");
-
-        ret = link_based_fops (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "link based file operation failed\n");
-        else
-                fprintf (stdout, "link based file operation passed\n");
-
-        ret = test_open_modes (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "testing modes of 'open' call failed\n");
-        else
-                fprintf (stdout, "testing modes of 'open' call passed\n");
+    int ret = -1;
+    char filename[255] = {
+        0,
+    };
+
+    if (argc > 1)
+        strcpy(filename, argv[1]);
+    else
+        strcpy(filename, "temp-xattr-test-file");
+
+    ret = fd_based_fops_1(strcat(filename, "_1"));
+    if (ret < 0)
+        fprintf(stderr, "fd based file operation 1 failed\n");
+    else
+        fprintf(stdout, "fd based file operation 1 passed\n");
+
+    ret = fd_based_fops_2(strcat(filename, "_2"));
+    if (ret < 0)
+        fprintf(stderr, "fd based file operation 2 failed\n");
+    else
+        fprintf(stdout, "fd based file operation 2 passed\n");
+
+    ret = dup_fd_based_fops(strcat(filename, "_3"));
+    if (ret < 0)
+        fprintf(stderr, "dup fd based file operation failed\n");
+    else
+        fprintf(stdout, "dup fd based file operation passed\n");
+
+    ret = path_based_fops(strcat(filename, "_4"));
+    if (ret < 0)
+        fprintf(stderr, "path based file operation failed\n");
+    else
+        fprintf(stdout, "path based file operation passed\n");
+
+    ret = dir_based_fops(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "directory based file operation failed\n");
+    else
+        fprintf(stdout, "directory based file operation passed\n");
+
+    ret = link_based_fops(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "link based file operation failed\n");
+    else
+        fprintf(stdout, "link based file operation passed\n");
+
+    ret = test_open_modes(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "testing modes of 'open' call failed\n");
+    else
+        fprintf(stdout, "testing modes of 'open' call passed\n");
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_based_fops_1 (char *filename)
+fd_based_fops_1(char *filename)
 {
-        int         fd        = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (fd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (fd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
+    int fd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        return ret;
+    return ret;
 }
 
-
 int
-fd_based_fops_2 (char *filename)
+fd_based_fops_2(char *filename)
 {
-        int         fd    = 0;
-        int         ret   = -1;
-        struct stat stbuf = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = ftruncate (fd, 0);
-
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (wstr, "This is my second string\n");
-        ret = write (fd, wstr, strlen (wstr));
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (fd, rstr, strlen (wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
+    int fd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = ftruncate(fd, 0);
+
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(wstr, "This is my second string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
 
 out:
-        if (fd)
-                close (fd);
-        unlink (filename);
+    if (fd)
+        close(fd);
+    unlink(filename);
 
-        return ret;
+    return ret;
 }
 
 int
-path_based_fops (char *filename)
+path_based_fops(char *filename)
 {
-        int         ret              = -1;
-        int         fd               = 0;
-        struct stat stbuf            = {0,};
-        char        newfilename[255] = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = truncate (filename, 0);
-        if (ret < 0) {
-                fprintf (stderr, "truncate failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = stat (filename, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chmod (filename, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chown (filename, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chown failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = listxattr (filename, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = removexattr (filename, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = access (filename, R_OK|W_OK);
-        if (ret < 0) {
-                fprintf (stderr, "access failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newfilename, filename);
-        strcat(newfilename, "_new");
-        ret = rename (filename, newfilename);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                goto out;
-        }
-        unlink (newfilename);
+    int ret = -1;
+    int fd = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char newfilename[255] = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = truncate(filename, 0);
+    if (ret < 0) {
+        fprintf(stderr, "truncate failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = stat(filename, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chmod(filename, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chown(filename, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chown failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = listxattr(filename, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = removexattr(filename, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = access(filename, R_OK | W_OK);
+    if (ret < 0) {
+        fprintf(stderr, "access failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newfilename, filename);
+    strcat(newfilename, "_new");
+    ret = rename(filename, newfilename);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        goto out;
+    }
+    unlink(newfilename);
 
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        unlink (filename);
-        return ret;
+    unlink(filename);
+    return ret;
 }
 
 int
-dup_fd_based_fops (char *filename)
+dup_fd_based_fops(char *filename)
 {
-        int         fd        = 0;
-        int         newfd     = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        newfd = dup (fd);
-        if (newfd < 0) {
-                ret = -1;
-                fprintf (stderr, "dup failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        close (fd);
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (newfd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lseek (newfd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (newfd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = ftruncate (newfd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fstat (newfd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (newfd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (newfd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (newfd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (newfd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
+    int fd = 0;
+    int newfd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    newfd = dup(fd);
+    if (newfd < 0) {
+        ret = -1;
+        fprintf(stderr, "dup failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    close(fd);
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(newfd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lseek(newfd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(newfd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = ftruncate(newfd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fstat(newfd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(newfd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(newfd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(newfd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(newfd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (newfd)
-                close (newfd);
-        ret = unlink (filename);
-        if (ret < 0)
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
+    if (newfd)
+        close(newfd);
+    ret = unlink(filename);
+    if (ret < 0)
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
 
-        return ret;
+    return ret;
 }
 
 int
-dir_based_fops (char *dirname)
+dir_based_fops(char *dirname)
 {
-        int            ret           = -1;
-        DIR           *dp            = NULL;
-        char           buff[255]     = {0,};
-        struct dirent *dbuff         = {0,};
-        struct stat    stbuff        = {0,};
-        char           newdname[255] = {0,};
-        char          *cwd           = NULL;
-
-        ret = mkdir (dirname, 0755);
-        if (ret < 0) {
-                fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        dp = opendir (dirname);
-        if (dp == NULL) {
-                fprintf (stderr, "opendir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        dbuff = readdir (dp);
-        if (NULL == dbuff) {
-                fprintf (stderr, "readdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = closedir (dp);
-        if (ret < 0) {
-                fprintf (stderr, "closedir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = stat (dirname, &stbuff);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chmod (dirname, 0744);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chown (dirname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = listxattr (dirname, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = removexattr (dirname, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "/../");
-        ret = chdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "chdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        cwd = getcwd (buff, 255);
-        if (NULL == cwd) {
-                fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "new");
-        ret = rename (dirname, newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = rmdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
-                return ret;
-        }
+    int ret = -1;
+    DIR *dp = NULL;
+    char buff[255] = {
+        0,
+    };
+    struct dirent *dbuff = {
+        0,
+    };
+    struct stat stbuff = {
+        0,
+    };
+    char newdname[255] = {
+        0,
+    };
+    char *cwd = NULL;
+
+    ret = mkdir(dirname, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    dp = opendir(dirname);
+    if (dp == NULL) {
+        fprintf(stderr, "opendir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    dbuff = readdir(dp);
+    if (NULL == dbuff) {
+        fprintf(stderr, "readdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = closedir(dp);
+    if (ret < 0) {
+        fprintf(stderr, "closedir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = stat(dirname, &stbuff);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chmod(dirname, 0744);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chown(dirname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = listxattr(dirname, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = getxattr(dirname, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = removexattr(dirname, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "/../");
+    ret = chdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "chdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    cwd = getcwd(buff, 255);
+    if (NULL == cwd) {
+        fprintf(stderr, "getcwd failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "new");
+    ret = rename(dirname, newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = rmdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rmdir failed: %s\n", strerror(errno));
+        return ret;
+    }
 
 out:
-        rmdir (dirname);
-        return ret;
+    rmdir(dirname);
+    return ret;
 }
 
 int
-link_based_fops (char *filename)
+link_based_fops(char *filename)
 {
-        int         ret           = -1;
-        int         fd            = 0;
-        char        newname[255]  = {0,};
-        char        linkname[255] = {0,};
-        struct stat lstbuf        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newname, filename);
-        strcat (newname, "_hlink");
-        ret = link (filename, newname);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (linkname, filename);
-        strcat (linkname, "_slink");
-        ret = symlink (newname, linkname);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lstat (linkname, &lstbuf);
-        if (ret < 0) {
-                fprintf (stderr, "lstbuf failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lchown (linkname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "lchown failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = llistxattr (linkname, NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "llistxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lremovexattr (linkname, "trusted.lxattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
+    int ret = -1;
+    int fd = 0;
+    char newname[255] = {
+        0,
+    };
+    char linkname[255] = {
+        0,
+    };
+    struct stat lstbuf = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newname, filename);
+    strcat(newname, "_hlink");
+    ret = link(filename, newname);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(linkname, filename);
+    strcat(linkname, "_slink");
+    ret = symlink(newname, linkname);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lstat(linkname, &lstbuf);
+    if (ret < 0) {
+        fprintf(stderr, "lstbuf failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lchown(linkname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "lchown failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = llistxattr(linkname, NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "llistxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lremovexattr(linkname, "trusted.lxattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
 
 out:
-        if (fd)
-                close(fd);
-        unlink (linkname);
-        unlink (newname);
+    if (fd)
+        close(fd);
+    unlink(linkname);
+    unlink(newname);
 }
 
 int
-test_open_modes (char *filename)
+test_open_modes(char *filename)
 {
-        int ret = -1;
-
-        ret = generic_open_read_write (filename, O_CREAT|O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n");
-               goto out;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR failed\n");
-               goto out;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDONLY);
-        if (ret != 0) {
-                fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n");
-                goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_WRONLY failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDWR);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDWR failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDONLY);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDONLY failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n");
-               goto out;
-        }
+    int ret = -1;
+
+    ret = generic_open_read_write(filename, O_CREAT | O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n");
+        goto out;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR failed\n");
+        goto out;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDONLY);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_WRONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDWR);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDWR failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDONLY);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n");
+        goto out;
+    }
 
 #if 0 /* undefined behaviour, unable to reliably test */
         ret = creat (filename, 0644);
@@ -785,84 +833,88 @@ test_open_modes (char *filename)
         }
 #endif
 
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
-               goto out;
-        }
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
+        goto out;
+    }
 
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_CREAT|O_EXCL);
-        if (0 != ret) {
-                fprintf (stderr, "flag O_CREAT|O_EXCL failed\n");
-                goto out;
-        }
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_CREAT | O_EXCL);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_EXCL failed\n");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-int generic_open_read_write (char *filename, int flag)
+int
+generic_open_read_write(char *filename, int flag)
 {
-        int  fd          = 0;
-        int  ret         = -1;
-        char wstring[50] = {0,};
-        char rstring[50] = {0,};
-
-        fd = open (filename, flag);
-        if (fd < 0) {
-                if (flag == O_CREAT|O_EXCL && errno == EEXIST) {
-                        unlink (filename);
-                        return 0;
-                }
-                else {
-                        fd = 0;
-                        fprintf (stderr, "open failed: %s\n", strerror (errno));
-                        return 1;
-                }
-        }
-
-        strcpy (wstring, "My string to write\n");
-        ret = write (fd, wstring, strlen(wstring));
-        if (ret <= 0) {
-                if (errno != EBADF) {
-                        fprintf (stderr, "write failed: %s\n", strerror (errno));
-                        close (fd);
-                        unlink(filename);
-                        return 2;
-                }
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                close (fd);
-                unlink(filename);
-                return 4;
-        }
-
-        ret = read (fd, rstring, strlen(wstring));
-        if (ret < 0) {
-                close (fd);
-                unlink (filename);
-                return 3;
-        }
-
-        /* Compare the rstring with wstring. But we do not want to return
-         * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
-         * O_TRUNC|O_RDONLY. Because in that case we are not writing
-         * anything to the file.*/
-
-        ret = memcmp (wstring, rstring, strlen (wstring));
-        if (0 != ret  && !(flag == O_CREAT|O_RDONLY || flag == O_RDONLY ||\
-            flag == O_TRUNC|O_RDONLY)) {
-                fprintf (stderr, "read is returning junk\n");
-                close (fd);
-                unlink (filename);
-                return 4;
-        }
-
-        close (fd);
-        unlink (filename);
-        return 0;
+    int fd = 0;
+    int ret = -1;
+    char wstring[50] = {
+        0,
+    };
+    char rstring[50] = {
+        0,
+    };
+
+    fd = open(filename, flag);
+    if (fd < 0) {
+        if (flag == O_CREAT | O_EXCL && errno == EEXIST) {
+            unlink(filename);
+            return 0;
+        } else {
+            fd = 0;
+            fprintf(stderr, "open failed: %s\n", strerror(errno));
+            return 1;
+        }
+    }
+
+    strcpy(wstring, "My string to write\n");
+    ret = write(fd, wstring, strlen(wstring));
+    if (ret <= 0) {
+        if (errno != EBADF) {
+            fprintf(stderr, "write failed: %s\n", strerror(errno));
+            close(fd);
+            unlink(filename);
+            return 2;
+        }
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return 4;
+    }
+
+    ret = read(fd, rstring, strlen(wstring));
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return 3;
+    }
+
+    /* Compare the rstring with wstring. But we do not want to return
+     * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
+     * O_TRUNC|O_RDONLY. Because in that case we are not writing
+     * anything to the file.*/
+
+    ret = memcmp(wstring, rstring, strlen(wstring));
+    if (0 != ret && !(flag == O_CREAT | O_RDONLY || flag == O_RDONLY ||
+                      flag == O_TRUNC | O_RDONLY)) {
+        fprintf(stderr, "read is returning junk\n");
+        close(fd);
+        unlink(filename);
+        return 4;
+    }
+
+    close(fd);
+    unlink(filename);
+    return 0;
 }
diff --git a/extras/thin-arbiter/setup-thin-arbiter.sh b/extras/thin-arbiter/setup-thin-arbiter.sh
new file mode 100755
index 00000000000..0681b30ef3f
--- /dev/null
+++ b/extras/thin-arbiter/setup-thin-arbiter.sh
@@ -0,0 +1,184 @@
+#!/bin/bash
+#  Copyright (c) 2018-2019 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+
+
+#  This tool has been developed to setup thin-arbiter process on a node.
+#  Seting up a thin arbiter process involves following files -
+#  1 - thin-arbiter.vol
+#  Thin-arbiter (TA) process will use the graph in this file to load the
+#  required translators.
+#  2 - gluster-ta-volume.service (generated by gluster-ta-volume.service.in)
+#  TA process would be running as systemd service.
+#
+#  TA process uses a location to save TA id files for every subvolume.
+#  This location can be taken as input from user. Once provided and the
+#  TA process is started on a node, it can not be changed using this
+#  script or by any other mean. The same location should be used in
+#  the gluster CLI when creating thin-arbiter volumes.
+
+MYPATH=`dirname $0`
+
+volloc="/var/lib/glusterd/thin-arbiter"
+mkdir -p $volloc
+
+if [ -f /etc/glusterfs/thin-arbiter.vol ]; then
+    volfile=/etc/glusterfs/thin-arbiter.vol
+else
+    volfile=$MYPATH/thin-arbiter.vol
+fi
+
+tafile="$volloc/thin-arbiter.vol"
+
+
+help () {
+    echo " "
+    echo '  This tool helps to setup thin-arbiter (TA) process on a node.
+  TA process uses a location to save TA id files for every subvolume.
+  This location can be taken as input from user. Once provided and the
+  TA process is started on a node, it can not be changed using this script
+  or by any other mean. The same location should be used in gluster CLI
+  when creating thin-arbiter volumes.
+
+  usage: setup-thin-arbiter.sh [-s] [-h]
+    options:
+    -s - Setup thin-arbiter file path and start process
+    -h - Show this help message and exit
+'
+}
+
+volfile_set_brick_path () {
+    while read -r line
+    do
+        dir=`echo "$line" | cut -d' ' -f 2`
+        if [ "$dir" = "directory" ]; then
+            bpath=`echo "$line" | cut -d' ' -f 3`
+            sed -i -- 's?'$bpath'?'$1'?g' $tafile
+            return
+        fi
+    done < $tafile
+}
+
+check_ta_proc () {
+    pro=`ps aux | grep thin-arbiter.vol | grep "volfile-id"`
+    if [ "${pro}" = '' ]; then
+            echo ""
+    else
+        curr_loc=`cat $volloc/thin-arbiter.vol | grep option | grep directory`
+        loc=`echo "${curr_loc##* }"`
+        echo "******************************************************"
+        echo "Error:"
+        echo "Thin-arbiter process is running with thin-arbiter path = $loc"
+        echo "Can not change TA path on this host now."
+        echo "$pro"
+        echo "******************************************************"
+        exit 1
+    fi
+}
+
+getpath () {
+    check_ta_proc
+    echo "******************************************************"
+    echo "User will be required to enter a path/folder for arbiter volume."
+    echo "Please note that this path will be used for ALL VOLUMES using this"
+    echo "node to host thin-arbiter. After setting, if a volume"
+    echo "has been created using this host and path then path for"
+    echo "thin-arbiter can not be changed "
+    echo "******************************************************"
+    echo " "
+    while true;
+    do
+        echo -n "Enter brick path for thin arbiter volumes: "
+        echo " "
+        read tapath
+        if [ "${tapath}" = '' ]; then
+            echo "Please enter valid path"
+            continue
+        else
+            echo "Entered brick path : $tapath "
+            echo "Please note that this brick path will be used for ALL"
+            echo "VOLUMES using this node to host thin-arbiter brick"
+            echo -n "Want to continue? (y/N): "
+            echo " "
+            read cont
+
+            if [ "${cont}" = 'N' ] || [ "${cont}" = 'n' ]; then
+                exit 0
+            else
+                break
+            fi
+        fi
+    done
+}
+
+setup () {
+    getpath
+    mkdir -p $tapath/.glusterfs/indices
+    if [ -d $tapath/.glusterfs/indices ]; then
+        echo " "
+    else
+        echo "Could not create $tapath/.glusterfs/indices directory, check provided ta path."
+        exit 1
+    fi
+
+    cp -f --backup --suffix=_old $volfile $volloc/thin-arbiter.vol
+    volfile_set_brick_path "$tapath"
+
+    echo "Directory path to be used for thin-arbiter volume is: $tapath"
+    echo " "
+    echo "========================================================"
+
+    if [ -f /usr/lib/systemd/system/gluster-ta-volume.service ]; then
+        echo "Starting thin-arbiter process"
+    else
+        cp $MYPATH/../systemd/gluster-ta-volume.service /etc/systemd/system/
+        echo "Starting thin-arbiter process"
+        chmod 0644 /etc/systemd/system/gluster-ta-volume.service
+    fi
+
+    systemctl daemon-reload
+    systemctl enable gluster-ta-volume
+    systemctl stop gluster-ta-volume
+    systemctl start gluster-ta-volume
+
+    if [ $? == 0 ]; then
+        echo "thin-arbiter process has been setup and running"
+    else
+        echo "Failed to setup thin arbiter"
+        exit 1
+    fi
+
+}
+
+main()
+{
+
+    if [ "$#" -ne 1 ]; then
+        help
+        exit 0
+    fi
+
+    while getopts "sh" opt; do
+        case $opt in
+            h)
+                help
+                exit 0
+                ;;
+            s)
+                setup
+                exit 0
+                ;;
+            *)
+                help
+                exit 0
+                ;;
+        esac
+    done
+}
+
+main "$@"
diff --git a/extras/thin-arbiter/thin-arbiter.vol b/extras/thin-arbiter/thin-arbiter.vol
new file mode 100644
index 00000000000..c76babc7b3c
--- /dev/null
+++ b/extras/thin-arbiter/thin-arbiter.vol
@@ -0,0 +1,57 @@
+volume ta-posix
+    type storage/posix
+    option directory /mnt/thin-arbiter
+end-volume
+
+volume ta-thin-arbiter
+    type features/thin-arbiter
+    subvolumes ta-posix
+end-volume
+
+volume ta-locks
+    type features/locks
+    option notify-contention yes
+    subvolumes ta-thin-arbiter
+end-volume
+
+volume ta-upcall
+    type features/upcall
+    option cache-invalidation off
+    subvolumes ta-locks
+end-volume
+
+volume ta-io-threads
+    type performance/io-threads
+    subvolumes ta-upcall
+end-volume
+
+volume ta-index
+    type features/index
+    option xattrop-pending-watchlist trusted.afr.ta-
+    option xattrop-dirty-watchlist trusted.afr.dirty
+    option index-base /mnt/thin-arbiter/.glusterfs/indices
+    subvolumes ta-io-threads
+end-volume
+
+volume /mnt/thin-arbiter
+    type debug/io-stats
+    option count-fop-hits off
+    option latency-measurement off
+    option unique-id /mnt/thin-arbiter
+    subvolumes ta-index
+end-volume
+
+volume ta-server
+    type protocol/server
+    option transport.listen-backlog 10
+    option transport.socket.keepalive-count 9
+    option transport.socket.keepalive-interval 2
+    option transport.socket.keepalive-time 20
+    option transport.tcp-user-timeout 0
+    option transport.socket.keepalive 1
+    option auth.addr./mnt/thin-arbiter.allow *
+    option auth-path /mnt/thin-arbiter
+    option transport.address-family inet
+    option transport-type tcp
+    subvolumes /mnt/thin-arbiter
+end-volume
diff --git a/extras/volfilter.py b/extras/volfilter.py
index 0ca456a7882..5558a1beff4 100644
--- a/extras/volfilter.py
+++ b/extras/volfilter.py
@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU General Public License * along
 # with HekaFS.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import print_function
 import copy
 import string
 import sys
@@ -35,7 +36,7 @@ good_xlators = [
 	"storage/posix",
 ]
 
-def copy_stack (old_xl,suffix,recursive=False):
+def copy_stack (old_xl, suffix, recursive=False):
 	if recursive:
 		new_name = old_xl.name + "-" + suffix
 	else:
@@ -45,7 +46,7 @@ def copy_stack (old_xl,suffix,recursive=False):
 	# The results with normal assignment here are . . . amusing.
 	new_xl.opts = copy.deepcopy(old_xl.opts)
 	for sv in old_xl.subvols:
-		new_xl.subvols.append(copy_stack(sv,suffix,True))
+		new_xl.subvols.append(copy_stack(sv, suffix, True))
 	# Patch up the path at the bottom.
 	if new_xl.type == "storage/posix":
 		new_xl.opts["directory"] += ("/" + suffix)
@@ -63,10 +64,10 @@ def cleanup (parent, graph):
 			parent.opts["transport-type"] = "ssl"
 		sv = []
 		for child in parent.subvols:
-			sv.append(cleanup(child,graph))
+			sv.append(cleanup(child, graph))
 		parent.subvols = sv
 	else:
-		parent = cleanup(parent.subvols[0],graph)
+		parent = cleanup(parent.subvols[0], graph)
 	return parent
 
 class Translator:
@@ -82,8 +83,8 @@ class Translator:
 def load (path):
 	# If it's a string, open it; otherwise, assume it's already a
 	# file-like object (most notably from urllib*).
-	if type(path) in types.StringTypes:
-		fp = file(path,"r")
+	if type(path) in (str,):
+		fp = file(path, "r")
 	else:
 		fp = path
 	all_xlators = {}
@@ -98,16 +99,16 @@ def load (path):
 			continue
 		if text[0] == "volume":
 			if xlator:
-				raise RuntimeError, "nested volume definition"
+				raise RuntimeError("nested volume definition")
 			xlator = Translator(text[1])
 			continue
 		if not xlator:
-			raise RuntimeError, "text outside volume definition"
+			raise RuntimeError("text outside volume definition")
 		if text[0] == "type":
 			xlator.type = text[1]
 			continue
 		if text[0] == "option":
-			xlator.opts[text[1]] = string.join(text[2:])
+			xlator.opts[text[1]] = ''.join(text[2:])
 			continue
 		if text[0] == "subvolumes":
 			for sv in text[1:]:
@@ -118,25 +119,25 @@ def load (path):
 			last_xlator = xlator
 			xlator = None
 			continue
-		raise RuntimeError, "unrecognized keyword %s" % text[0]
+		raise RuntimeError("unrecognized keyword %s" % text[0])
 	if xlator:
-		raise RuntimeError, "unclosed volume definition"
+		raise RuntimeError("unclosed volume definition")
 	return all_xlators, last_xlator
 
 def generate (graph, last, stream=sys.stdout):
 	for sv in last.subvols:
 		if not sv.dumped:
-			generate(graph,sv,stream)
-			print >> stream, ""
+			generate(graph, sv, stream)
+			print("", file=stream)
 			sv.dumped = True
-	print >> stream, "volume %s" % last.name
-	print >> stream, "    type %s" % last.type
-	for k, v in last.opts.iteritems():
-		print >> stream, "    option %s %s" % (k, v)
+	print("volume %s" % last.name, file=stream)
+	print("    type %s" % last.type, file=stream)
+	for k, v in last.opts.items():
+		print("    option %s %s" % (k, v), file=stream)
 	if last.subvols:
-		print >> stream, "    subvolumes %s" % string.join(
-			[ sv.name for sv in last.subvols ])
-	print >> stream, "end-volume"
+		print("    subvolumes %s" % ''.join(
+			[ sv.name for sv in last.subvols ]), file=stream)
+	print("end-volume", file=stream)
 
 def push_filter (graph, old_xl, filt_type, opts={}):
 	suffix = "-" + old_xl.type.split("/")[1]
@@ -156,7 +157,7 @@ def push_filter (graph, old_xl, filt_type, opts={}):
 
 def delete (graph, victim):
 	if len(victim.subvols) != 1:
-		raise RuntimeError, "attempt to delete non-unary translator"
+		raise RuntimeError("attempt to delete non-unary translator")
 	for xl in graph.itervalues():
 		while xl.subvols.count(victim):
 			i = xl.subvols.index(victim)
@@ -164,4 +165,4 @@ def delete (graph, victim):
 
 if __name__ == "__main__":
 	graph, last = load(sys.argv[1])
-	generate(graph,last)
+	generate(graph, last)
diff --git a/extras/who-wrote-glusterfs/gitdm.aliases b/extras/who-wrote-glusterfs/gitdm.aliases
index 1fcdda7138b..901c12418e3 100644
--- a/extras/who-wrote-glusterfs/gitdm.aliases
+++ b/extras/who-wrote-glusterfs/gitdm.aliases
@@ -55,3 +55,4 @@ vijay@dev.gluster.com	vbellur@redhat.com
 vijaykumar.koppad@gmail.com	vkoppad@redhat.com
 vikas@zresearch.com	vikas@gluster.com
 shishirng@gluster.com	sgowda@redhat.com
+potatogim@potatogim.net	potatogim@gluesys.com
diff --git a/extras/who-wrote-glusterfs/gitdm.domain-map b/extras/who-wrote-glusterfs/gitdm.domain-map
index d9ea7f235a0..7cd2bbd605b 100644
--- a/extras/who-wrote-glusterfs/gitdm.domain-map
+++ b/extras/who-wrote-glusterfs/gitdm.domain-map
@@ -4,6 +4,7 @@
 active.by       ActiveCloud
 appeartv.com    Appear TV
 cern.ch         CERN
+cmss.chinamobile.com    China Mobile(Suzhou) Software Technology
 datalab.es      DataLab S.L.
 fb.com          Facebook
 fedoraproject.org       Fedora Project
@@ -25,3 +26,4 @@ stepping-stone.ch       stepping stone GmbH
 xtaotech.com    XTAO Co.
 yahoo.in        (personal contributions)
 zresearch.com   Red Hat
+gluesys.com     Gluesys
diff --git a/geo-replication/Makefile.am b/geo-replication/Makefile.am
index 556951d9fb7..591b23d0eaf 100644
--- a/geo-replication/Makefile.am
+++ b/geo-replication/Makefile.am
@@ -1,3 +1,8 @@
 SUBDIRS = syncdaemon src
 
 CLEANFILES =
+
+EXTRA_DIST = gsyncd.conf.in
+
+gsyncdconfdir = $(sysconfdir)/glusterfs/
+gsyncdconf_DATA = gsyncd.conf
diff --git a/geo-replication/gsyncd.conf.in b/geo-replication/gsyncd.conf.in
new file mode 100644
index 00000000000..9688c79fab7
--- /dev/null
+++ b/geo-replication/gsyncd.conf.in
@@ -0,0 +1,349 @@
+[__meta__]
+version = 4.0
+
+[master-bricks]
+configurable=false
+
+[slave-bricks]
+configurable=false
+
+[master-volume-id]
+configurable=false
+
+[slave-volume-id]
+configurable=false
+
+[master-replica-count]
+configurable=false
+type=int
+value=1
+
+[master-disperse-count]
+configurable=false
+type=int
+value=1
+
+[master-distribution-count]
+configurable=false
+type=int
+value=1
+
+[glusterd-workdir]
+value = @GLUSTERD_WORKDIR@
+
+[gluster-logdir]
+value = /var/log/glusterfs
+
+[gluster-rundir]
+value = /var/run/gluster
+
+[gsyncd-miscdir]
+value = /var/lib/misc/gluster/gsyncd
+
+[stime-xattr-prefix]
+value=
+
+[checkpoint]
+value=0
+help=Set Checkpoint
+validation=unixtime
+type=int
+
+[gluster-cli-options]
+value=
+help=Gluster CLI Options
+
+[pid-file]
+value=${gluster_rundir}/gsyncd-${master}-${primary_slave_host}-${slavevol}.pid
+configurable=false
+template = true
+help=PID file path
+
+[state-file]
+value=${glusterd_workdir}/geo-replication/${master}_${primary_slave_host}_${slavevol}/monitor.status
+configurable=false
+template=true
+help=Status File path
+
+[georep-session-working-dir]
+value=${glusterd_workdir}/geo-replication/${master}_${primary_slave_host}_${slavevol}/
+template=true
+help=Session Working directory
+configurable=false
+
+[access-mount]
+value=false
+type=bool
+validation=bool
+help=Do not lazy unmount the master volume. This allows admin to access the mount for debugging.
+
+[slave-access-mount]
+value=false
+type=bool
+validation=bool
+help=Do not lazy unmount the slave volume. This allows admin to access the mount for debugging.
+
+[isolated-slaves]
+value=
+help=List of Slave nodes which are isolated
+
+[changelog-batch-size]
+# Max size of Changelogs to process per batch, Changelogs Processing is
+# not limited by the number of changelogs but instead based on
+# size of the changelog file, One sample changelog file size was 145408
+# with ~1000 CREATE and ~1000 DATA. 5 such files in one batch is 727040
+# If geo-rep worker crashes while processing a batch, it has to retry only
+# that batch since stime will get updated after each batch.
+value=727040
+help=Max size of Changelogs to process per batch.
+type=int
+
+[slave-timeout]
+value=120
+type=int
+help=Timeout in seconds for Slave Gsyncd. If no activity from master for this timeout, Slave gsyncd will be disconnected. Set Timeout to zero to skip this check.
+
+[connection-timeout]
+value=60
+type=int
+help=Timeout for mounts
+
+[replica-failover-interval]
+value=1
+type=int
+help=Minimum time interval in seconds for passive worker to become Active
+
+[changelog-archive-format]
+value=%Y%m
+help=Processed changelogs will be archived in working directory. Pattern for archive file
+
+[use-meta-volume]
+value=false
+type=bool
+help=Use this to set Active Passive mode to meta-volume.
+
+[meta-volume-mnt]
+value=/run/gluster/shared_storage
+help=Meta Volume or Shared Volume mount path
+
+[allow-network]
+value=
+
+[change-interval]
+value=5
+type=int
+
+[sync-method]
+value=rsync
+help=Sync method for data sync. Available methods are tar over ssh and rsync. Default is rsync.
+validation=choice
+allowed_values=tarssh,rsync
+
+[remote-gsyncd]
+value =
+help=If SSH keys are not secured with gsyncd prefix then use this configuration to set the actual path of gsyncd(Usually /usr/libexec/glusterfs/gsyncd)
+
+[gluster-command-dir]
+value=@SBIN_DIR@
+help=Directory where Gluster binaries exist on master
+
+[slave-gluster-command-dir]
+value=@SBIN_DIR@
+help=Directory where Gluster binaries exist on slave
+
+[gluster-params]
+value = aux-gfid-mount acl
+help=Parameters for Gluster Geo-rep mount in Master
+
+[slave-gluster-params]
+value = aux-gfid-mount acl
+help=Parameters for Gluster Geo-rep mount in Slave
+
+[ignore-deletes]
+value = false
+type=bool
+help=Do not sync deletes in Slave
+
+[special-sync-mode]
+# tunables for failover/failback mechanism:
+# None   - gsyncd behaves as normal
+# blind  - gsyncd works with xtime pairs to identify
+#          candidates for synchronization
+# wrapup - same as normal mode but does not assign
+#          xtimes to orphaned files
+# see crawl() for usage of the above tunables
+value =
+help=
+
+[gfid-conflict-resolution]
+value = true
+validation=bool
+type=bool
+help=Disables automatic gfid conflict resolution while syncing
+
+[working-dir]
+value = ${gsyncd_miscdir}/${master}_${primary_slave_host}_${slavevol}/
+template=true
+configurable=false
+help=Working directory for storing Changelogs
+
+[change-detector]
+value=changelog
+help=Change detector
+validation=choice
+allowed_values=changelog,xsync
+
+[cli-log-file]
+value=${gluster_logdir}/geo-replication/cli.log
+template=true
+configurable=false
+
+[cli-log-level]
+value=INFO
+help=Set CLI Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[log-file]
+value=${gluster_logdir}/geo-replication/${master}_${primary_slave_host}_${slavevol}/gsyncd.log
+configurable=false
+template=true
+
+[changelog-log-file]
+value=${gluster_logdir}/geo-replication/${master}_${primary_slave_host}_${slavevol}/changes-${local_id}.log
+configurable=false
+template=true
+
+[gluster-log-file]
+value=${gluster_logdir}/geo-replication/${master}_${primary_slave_host}_${slavevol}/mnt-${local_id}.log
+template=true
+configurable=false
+
+[slave-log-file]
+value=${gluster_logdir}/geo-replication-slaves/${master}_${primary_slave_host}_${slavevol}/gsyncd.log
+template=true
+configurable=false
+
+[slave-gluster-log-file]
+value=${gluster_logdir}/geo-replication-slaves/${master}_${primary_slave_host}_${slavevol}/mnt-${master_node}-${master_brick_id}.log
+template=true
+configurable=false
+
+[slave-gluster-log-file-mbr]
+value=${gluster_logdir}/geo-replication-slaves/${master}_${primary_slave_host}_${slavevol}/mnt-mbr-${master_node}-${master_brick_id}.log
+template=true
+configurable=false
+
+[log-level]
+value=INFO
+help=Set Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[gluster-log-level]
+value=INFO
+help=Set Gluster mount Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[changelog-log-level]
+value=INFO
+help=Set Changelog Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[slave-log-level]
+value=INFO
+help=Set Slave Gsyncd Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[slave-gluster-log-level]
+value=INFO
+help=Set Slave Gluster mount Log Level
+validation=choice
+allowed_values=ERROR,INFO,WARNING,DEBUG
+
+[ssh-port]
+value=22
+validation=minmax
+min=1
+max=65535
+help=Set SSH port
+type=int
+
+[ssh-command]
+value=ssh
+help=Set ssh binary path
+validation=execpath
+
+[tar-command]
+value=tar
+help=Set tar command path
+validation=execpath
+
+[ssh-options]
+value = -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i ${glusterd_workdir}/geo-replication/secret.pem
+template=true
+
+[ssh-options-tar]
+value = -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i ${glusterd_workdir}/geo-replication/tar_ssh.pem
+template=true
+
+[gluster-command]
+value=gluster
+help=Set gluster binary path
+validation=execpath
+
+[sync-jobs]
+value=3
+help=Number of Syncer jobs
+validation=minmax
+min=1
+max=100
+type=int
+
+[rsync-command]
+value=rsync
+help=Set rsync command path
+validation=execpath
+
+[rsync-options]
+value=
+
+[rsync-ssh-options]
+value=
+
+[rsync-opt-ignore-missing-args]
+value=true
+type=bool
+
+[rsync-opt-existing]
+value=true
+type=bool
+
+[log-rsync-performance]
+value=false
+help=Log Rsync performance
+validation=bool
+type=bool
+
+[use-rsync-xattrs]
+value=false
+type=bool
+
+[sync-xattrs]
+value=true
+type=bool
+
+[sync-acls]
+value=true
+type=bool
+
+[max-rsync-retries]
+value=10
+type=int
+
+[state_socket_unencoded]
+# Unused, For backward compatibility
+value=
diff --git a/geo-replication/setup.py b/geo-replication/setup.py
index 6d678baa2f7..0eae469d2d6 100644
--- a/geo-replication/setup.py
+++ b/geo-replication/setup.py
@@ -1,7 +1,7 @@
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
-
+#
 # This file is licensed to you under your choice of the GNU Lesser
 # General Public License, version 3 or any later version (LGPLv3 or
 # later), or the GNU General Public License, version 2 (GPLv2), in all
@@ -20,11 +20,11 @@ setup(
     name=name,
     version="",
     description='GlusterFS Geo Replication',
-    license='',
+    license='GPLV2 and LGPLV3+',
     author='Red Hat, Inc.',
     author_email='gluster-devel@gluster.org',
     url='http://www.gluster.org',
-    packages=['syncdaemon', ],
+    packages=[name, ],
     test_suite='nose.collector',
     install_requires=[],
     scripts=[],
diff --git a/geo-replication/src/gsyncd.c b/geo-replication/src/gsyncd.c
index 2c48ca5d540..b5aeec5bf33 100644
--- a/geo-replication/src/gsyncd.c
+++ b/geo-replication/src/gsyncd.c
@@ -7,8 +7,8 @@
    later), or the GNU General Public License, version 2 (GPLv2), in all
    cases as published by the Free Software Foundation.
 */
-#include "compat.h"
-#include "syscall.h"
+#include <glusterfs/compat.h>
+#include <glusterfs/syscall.h>
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -24,13 +24,13 @@
  * We unconditionally pass then while building gsyncd binary.
  */
 #ifdef USE_LIBGLUSTERFS
-#include "glusterfs.h"
-#include "globals.h"
-#include "defaults.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/globals.h>
+#include <glusterfs/defaults.h>
 #endif
 
-#include "common-utils.h"
-#include "run.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/run.h>
 #include "procdiggy.h"
 
 #define _GLUSTERD_CALLED_ "_GLUSTERD_CALLED_"
@@ -42,395 +42,361 @@
 int restricted = 0;
 
 static int
-duplexpand (void **buf, size_t tsiz, size_t *len)
+duplexpand(void **buf, size_t tsiz, size_t *len)
 {
-        size_t osiz = tsiz * *len;
-        char *p = realloc (*buf, osiz << 1);
-        if (!p) {
-                free(*buf);
-                return -1;
-        }
+    size_t osiz = tsiz * *len;
+    char *p = realloc(*buf, osiz << 1);
+    if (!p) {
+        return -1;
+    }
 
-        memset (p + osiz, 0, osiz);
-        *buf = p;
-        *len <<= 1;
+    memset(p + osiz, 0, osiz);
+    *buf = p;
+    *len <<= 1;
 
-        return 0;
+    return 0;
 }
 
 static int
-str2argv (char *str, char ***argv)
+str2argv(char *str, char ***argv)
 {
-        char *p         = NULL;
-        char *savetok   = NULL;
-        char *temp      = NULL;
-        char *temp1     = NULL;
-        int argc        = 0;
-        size_t argv_len = 32;
-        int ret         = 0;
-        int i           = 0;
-
-        assert (str);
-        temp = str = strdup (str);
-        if (!str)
+    char *p = NULL;
+    char *savetok = NULL;
+    char *temp = NULL;
+    char *temp1 = NULL;
+    int argc = 0;
+    size_t argv_len = 32;
+    int ret = 0;
+    int i = 0;
+
+    assert(str);
+    temp = str = strdup(str);
+    if (!str)
+        goto error;
+
+    *argv = calloc(argv_len, sizeof(**argv));
+    if (!*argv)
+        goto error;
+
+    while ((p = strtok_r(str, " ", &savetok))) {
+        str = NULL;
+
+        argc++;
+        if (argc == argv_len) {
+            ret = duplexpand((void *)argv, sizeof(**argv), &argv_len);
+            if (ret == -1)
                 goto error;
-
-        *argv = calloc (argv_len, sizeof (**argv));
-        if (!*argv)
-                goto error;
-
-        while ((p = strtok_r (str, " ", &savetok))) {
-                str = NULL;
-
-                argc++;
-                if (argc == argv_len) {
-                        ret = duplexpand ((void *)argv,
-                                          sizeof (**argv),
-                                          &argv_len);
-                        if (ret == -1)
-                                goto error;
-                }
-                temp1 = strdup (p);
-                if (!temp1)
-                        goto error;
-                (*argv)[argc - 1] = temp1;
         }
-
-        free(temp);
-        return argc;
-
- error:
-        fprintf (stderr, "out of memory\n");
-        free(temp);
-        for (i = 0; i < argc - 1; i++)
-                free((*argv)[i]);
-        free(*argv);
-        return -1;
+        temp1 = strdup(p);
+        if (!temp1)
+            goto error;
+        (*argv)[argc - 1] = temp1;
+    }
+
+    free(temp);
+    return argc;
+
+error:
+    fprintf(stderr, "out of memory\n");
+    free(temp);
+    for (i = 0; i < argc - 1; i++)
+        free((*argv)[i]);
+    free(*argv);
+    return -1;
 }
 
 static int
-invoke_gsyncd (int argc, char **argv)
+invoke_gsyncd(int argc, char **argv)
 {
-        char config_file[PATH_MAX] = {0,};
-        size_t gluster_workdir_len = 0;
-        runner_t runner            = {0,};
-        int i                      = 0;
-        int j                      = 0;
-        char *nargv[argc + 4];
-        char *python = NULL;
-
-        if (restricted) {
-                size_t len;
-                /* in restricted mode we forcibly use the system-wide config */
-                runinit (&runner);
-                runner_add_args (&runner, SBIN_DIR"/gluster",
-                                 "--remote-host=localhost",
-                                 "--log-file=-", "system::", "getwd",
-                                 NULL);
-                runner_redir (&runner, STDOUT_FILENO, RUN_PIPE);
-                if (runner_start (&runner) == 0 &&
-                    fgets (config_file, PATH_MAX,
-                           runner_chio (&runner, STDOUT_FILENO)) != NULL &&
-                    (len = strlen (config_file)) &&
-                    config_file[len - 1] == '\n' &&
-                    runner_end (&runner) == 0)
-                        gluster_workdir_len = len - 1;
-
-                if (gluster_workdir_len) {
-                        if (gluster_workdir_len + 1 + strlen (GSYNCD_CONF_TEMPLATE) + 1 >
-                            PATH_MAX)
-                                goto error;
-                        config_file[gluster_workdir_len] = '/';
-                        strcat (config_file, GSYNCD_CONF_TEMPLATE);
-                } else
-                        goto error;
-
-                if (setenv ("_GSYNCD_RESTRICTED_", "1", 1) == -1)
-                        goto error;
-        }
+    int i = 0;
+    int j = 0;
+    char *nargv[argc + 4];
+    char *python = NULL;
 
-        if (chdir ("/") == -1)
-                goto error;
+    if (chdir("/") == -1)
+        goto error;
 
-        j = 0;
-        python = getenv("PYTHON");
-        if(!python)
-                python = PYTHON;
-        nargv[j++] = python;
-        nargv[j++] = GSYNCD_PREFIX"/python/syncdaemon/"GSYNCD_PY;
-        for (i = 1; i < argc; i++)
-                nargv[j++] = argv[i];
-        if (config_file[0]) {
-                nargv[j++] = "-c";
-                nargv[j++] = config_file;
-        }
-        nargv[j++] = NULL;
+    j = 0;
+    python = getenv("PYTHON");
+    if (!python)
+        python = PYTHON;
+    nargv[j++] = python;
+    nargv[j++] = GSYNCD_PREFIX "/python/syncdaemon/" GSYNCD_PY;
+    for (i = 1; i < argc; i++)
+        nargv[j++] = argv[i];
 
-        execvp (python, nargv);
+    nargv[j++] = NULL;
 
-        fprintf (stderr, "exec of '%s' failed\n", python);
-        return 127;
+    execvp(python, nargv);
 
- error:
-        fprintf (stderr, "gsyncd initializaion failed\n");
-        return 1;
-}
+    fprintf(stderr, "exec of '%s' failed\n", python);
+    return 127;
 
+error:
+    fprintf(stderr, "gsyncd initializaion failed\n");
+    return 1;
+}
 
 static int
-find_gsyncd (pid_t pid, pid_t ppid, char *name, void *data)
+find_gsyncd(pid_t pid, pid_t ppid, char *name, void *data)
 {
-        char buf[NAME_MAX * 2] = {0,};
-        char path[PATH_MAX]    = {0,};
-        char *p                = NULL;
-        int zeros              = 0;
-        int ret                = 0;
-        int fd                 = -1;
-        pid_t *pida            = (pid_t *)data;
-
-        if (ppid != pida[0])
-                return 0;
-
-        snprintf (path, sizeof path, PROC"/%d/cmdline", pid);
-        fd = open (path, O_RDONLY);
-        if (fd == -1)
-                return 0;
-        ret = sys_read (fd, buf, sizeof (buf));
-        sys_close (fd);
-        if (ret == -1)
-                return 0;
-        for (zeros = 0, p = buf; zeros < 2 && p < buf + ret; p++)
-                zeros += !*p;
-
-        ret = 0;
-        switch (zeros) {
+    char buf[NAME_MAX * 2] = {
+        0,
+    };
+    char path[PATH_MAX] = {
+        0,
+    };
+    char *p = NULL;
+    int zeros = 0;
+    int ret = 0;
+    int fd = -1;
+    pid_t *pida = (pid_t *)data;
+
+    if (ppid != pida[0])
+        return 0;
+
+    snprintf(path, sizeof path, PROC "/%d/cmdline", pid);
+    fd = open(path, O_RDONLY);
+    if (fd == -1)
+        return 0;
+    ret = sys_read(fd, buf, sizeof(buf));
+    sys_close(fd);
+    if (ret == -1)
+        return 0;
+    for (zeros = 0, p = buf; zeros < 2 && p < buf + ret; p++)
+        zeros += !*p;
+
+    ret = 0;
+    switch (zeros) {
         case 2:
-                if ((strcmp (basename (buf), basename (PYTHON)) ||
-                     strcmp (basename (buf + strlen (buf) + 1), GSYNCD_PY)) == 0) {
-                        ret = 1;
-                        break;
-                }
-                /* fallthrough */
+            if ((strcmp(basename(buf), basename(PYTHON)) ||
+                 strcmp(basename(buf + strlen(buf) + 1), GSYNCD_PY)) == 0) {
+                ret = 1;
+                break;
+            }
+            /* fallthrough */
         case 1:
-                if (strcmp (basename (buf), GSYNCD_PY) == 0)
-                        ret = 1;
+            if (strcmp(basename(buf), GSYNCD_PY) == 0)
+                ret = 1;
+    }
+
+    if (ret == 1) {
+        if (pida[1] != -1) {
+            fprintf(stderr, GSYNCD_PY " sibling is not unique");
+            return -1;
         }
+        pida[1] = pid;
+    }
 
-        if (ret == 1) {
-                if (pida[1] != -1) {
-                        fprintf (stderr, GSYNCD_PY" sibling is not unique");
-                        return -1;
-                }
-                pida[1] = pid;
-        }
-
-        return 0;
+    return 0;
 }
 
 static int
-invoke_rsync (int argc, char **argv)
+invoke_rsync(int argc, char **argv)
 {
-        int i                  = 0;
-        char path[PATH_MAX]    = {0,};
-        pid_t pid              = -1;
-        pid_t ppid             = -1;
-        pid_t pida[]           = {-1, -1};
-        char *name             = NULL;
-        char buf[PATH_MAX + 1] = {0,};
-        int ret                = 0;
-
-        assert (argv[argc] == NULL);
-
-        if (argc < 2 || strcmp (argv[1], "--server") != 0)
-                goto error;
-
-        for (i = 2; i < argc && argv[i][0] == '-'; i++);
-
-        if (!(i == argc - 2 && strcmp (argv[i], ".") == 0 && argv[i + 1][0] == '/')) {
-                fprintf (stderr, "need an rsync invocation without protected args\n");
-                goto error;
-        }
-
-        /* look up sshd we are spawned from */
-        for (pid = getpid () ;; pid = ppid) {
-                ppid = pidinfo (pid, &name);
-                if (ppid < 0) {
-                        fprintf (stderr, "sshd ancestor not found\n");
-                        goto error;
-                }
-                if (strcmp (name, "sshd") == 0) {
-                        GF_FREE (name);
-                        break;
-                }
-                GF_FREE (name);
+    int i = 0;
+    char path[PATH_MAX] = {
+        0,
+    };
+    pid_t pid = -1;
+    pid_t ppid = -1;
+    pid_t pida[] = {-1, -1};
+    char *name = NULL;
+    char buf[PATH_MAX + 1] = {
+        0,
+    };
+    int ret = 0;
+
+    assert(argv[argc] == NULL);
+
+    if (argc < 2 || strcmp(argv[1], "--server") != 0)
+        goto error;
+
+    for (i = 2; i < argc && argv[i][0] == '-'; i++)
+        ;
+
+    if (!(i == argc - 2 && strcmp(argv[i], ".") == 0 &&
+          argv[i + 1][0] == '/')) {
+        fprintf(stderr, "need an rsync invocation without protected args\n");
+        goto error;
+    }
+
+    /* look up sshd we are spawned from */
+    for (pid = getpid();; pid = ppid) {
+        ppid = pidinfo(pid, &name);
+        if (ppid < 0) {
+            fprintf(stderr, "sshd ancestor not found\n");
+            goto error;
         }
-        /* look up "ssh-sibling" gsyncd */
-        pida[0] = pid;
-        ret = prociter (find_gsyncd, pida);
-        if (ret == -1 || pida[1] == -1) {
-                fprintf (stderr, "gsyncd sibling not found\n");
-                goto error;
-        }
-        /* check if rsync target matches gsyncd target */
-        snprintf (path, sizeof path, PROC"/%d/cwd", pida[1]);
-        ret = sys_readlink (path, buf, sizeof (buf));
-        if (ret == -1 || ret == sizeof (buf))
-                goto error;
-        if (strcmp (argv[argc - 1], "/") == 0 /* root dir cannot be a target */ ||
-            (strcmp (argv[argc - 1], path) /* match against gluster target */ &&
-             strcmp (argv[argc - 1], buf) /* match against file target */) != 0) {
-                fprintf (stderr, "rsync target does not match "GEOREP" session\n");
-                goto error;
+        if (strcmp(name, "sshd") == 0) {
+            GF_FREE(name);
+            break;
         }
-
-        argv[0] = RSYNC;
-
-        execvp (RSYNC, argv);
-
-        fprintf (stderr, "exec of "RSYNC" failed\n");
-        return 127;
-
- error:
-        fprintf (stderr, "disallowed "RSYNC" invocation\n");
-        return 1;
+        GF_FREE(name);
+    }
+    /* look up "ssh-sibling" gsyncd */
+    pida[0] = pid;
+    ret = prociter(find_gsyncd, pida);
+    if (ret == -1 || pida[1] == -1) {
+        fprintf(stderr, "gsyncd sibling not found\n");
+        goto error;
+    }
+    /* check if rsync target matches gsyncd target */
+    snprintf(path, sizeof path, PROC "/%d/cwd", pida[1]);
+    ret = sys_readlink(path, buf, sizeof(buf));
+    if (ret == -1 || ret == sizeof(buf))
+        goto error;
+    if (strcmp(argv[argc - 1], "/") == 0 /* root dir cannot be a target */ ||
+        (strcmp(argv[argc - 1], path) /* match against gluster target */ &&
+         strcmp(argv[argc - 1], buf) /* match against file target */) != 0) {
+        fprintf(stderr, "rsync target does not match " GEOREP " session\n");
+        goto error;
+    }
+
+    argv[0] = RSYNC;
+
+    execvp(RSYNC, argv);
+
+    fprintf(stderr, "exec of " RSYNC " failed\n");
+    return 127;
+
+error:
+    fprintf(stderr, "disallowed " RSYNC " invocation\n");
+    return 1;
 }
 
 static int
-invoke_gluster (int argc, char **argv)
+invoke_gluster(int argc, char **argv)
 {
-        int i = 0;
-        int j = 0;
-        int optsover = 0;
-        char *ov = NULL;
-
-        for (i = 1; i < argc; i++) {
-                ov = strtail (argv[i], "--");
-                if (ov && !optsover) {
-                        if (*ov == '\0')
-                                optsover = 1;
-                        continue;
-                }
-                switch (++j) {
-                case 1:
-                        if (strcmp (argv[i], "volume") != 0)
-                                goto error;
-                        break;
-                case 2:
-                        if (strcmp (argv[i], "info") != 0)
-                                goto error;
-                        break;
-                case 3:
-                        break;
-                default:
-                        goto error;
-                }
+    int i = 0;
+    int j = 0;
+    int optsover = 0;
+    char *ov = NULL;
+
+    for (i = 1; i < argc; i++) {
+        ov = strtail(argv[i], "--");
+        if (ov && !optsover) {
+            if (*ov == '\0')
+                optsover = 1;
+            continue;
+        }
+        switch (++j) {
+            case 1:
+                if (strcmp(argv[i], "volume") != 0)
+                    goto error;
+                break;
+            case 2:
+                if (strcmp(argv[i], "info") != 0)
+                    goto error;
+                break;
+            case 3:
+                break;
+            default:
+                goto error;
         }
+    }
 
-        argv[0] = "gluster";
-        execvp (SBIN_DIR"/gluster", argv);
-        fprintf (stderr, "exec of gluster failed\n");
-        return 127;
+    argv[0] = "gluster";
+    execvp(SBIN_DIR "/gluster", argv);
+    fprintf(stderr, "exec of gluster failed\n");
+    return 127;
 
- error:
-        fprintf (stderr, "disallowed gluster invocation\n");
-        return 1;
+error:
+    fprintf(stderr, "disallowed gluster invocation\n");
+    return 1;
 }
 
 struct invocable {
-        char *name;
-        int (*invoker) (int argc, char **argv);
+    char *name;
+    int (*invoker)(int argc, char **argv);
 };
 
-struct invocable invocables[] = {
-        { "rsync",   invoke_rsync  },
-        { "gsyncd",  invoke_gsyncd },
-        { "gluster", invoke_gluster },
-        { NULL, NULL}
-};
+struct invocable invocables[] = {{"rsync", invoke_rsync},
+                                 {"gsyncd", invoke_gsyncd},
+                                 {"gluster", invoke_gluster},
+                                 {NULL, NULL}};
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int               ret   = -1;
-        char             *evas  = NULL;
-        struct invocable *i     = NULL;
-        char             *b     = NULL;
-        char             *sargv = NULL;
-        int               j     = 0;
+    int ret = -1;
+    char *evas = NULL;
+    struct invocable *i = NULL;
+    char *b = NULL;
+    char *sargv = NULL;
+    int j = 0;
 
 #ifdef USE_LIBGLUSTERFS
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return ENOMEM;
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return ENOMEM;
 
-        if (glusterfs_globals_init (ctx))
-                return 1;
+    if (glusterfs_globals_init(ctx))
+        return 1;
 
-        THIS->ctx = ctx;
-        ret = default_mem_acct_init (THIS);
-        if (ret) {
-                fprintf (stderr, "internal error: mem accounting failed\n");
-                return 1;
-        }
+    THIS->ctx = ctx;
+    ret = default_mem_acct_init(THIS);
+    if (ret) {
+        fprintf(stderr, "internal error: mem accounting failed\n");
+        return 1;
+    }
 #endif
 
-        evas = getenv (_GLUSTERD_CALLED_);
-        if (evas && strcmp (evas, "1") == 0)
-                /* OK, we know glusterd called us, no need to look for further config
-                 *...although this conclusion should not inherit to our children
-                 */
-                unsetenv (_GLUSTERD_CALLED_);
-        else {
-                /* we regard all gsyncd invocations unsafe
-                 * that do not come from glusterd and
-                 * therefore restrict it
-                 */
-                restricted = 1;
-
-                if (!getenv (_GSYNCD_DISPATCHED_)) {
-                        evas = getenv ("SSH_ORIGINAL_COMMAND");
-                        if (evas)
-                                sargv = evas;
-                        else {
-                                evas = getenv ("SHELL");
-                                if (evas && strcmp (basename (evas), "gsyncd") == 0 &&
-                                    argc == 3 && strcmp (argv[1], "-c") == 0)
-                                        sargv = argv[2];
-                        }
-                }
-
+    evas = getenv(_GLUSTERD_CALLED_);
+    if (evas && strcmp(evas, "1") == 0)
+        /* OK, we know glusterd called us, no need to look for further config
+         *...although this conclusion should not inherit to our children
+         */
+        unsetenv(_GLUSTERD_CALLED_);
+    else {
+        /* we regard all gsyncd invocations unsafe
+         * that do not come from glusterd and
+         * therefore restrict it
+         */
+        restricted = 1;
+
+        if (!getenv(_GSYNCD_DISPATCHED_)) {
+            evas = getenv("SSH_ORIGINAL_COMMAND");
+            if (evas)
+                sargv = evas;
+            else {
+                evas = getenv("SHELL");
+                if (evas && strcmp(basename(evas), "gsyncd") == 0 &&
+                    argc == 3 && strcmp(argv[1], "-c") == 0)
+                    sargv = argv[2];
+            }
         }
+    }
 
-        if (!(sargv && restricted))
-                return invoke_gsyncd (argc, argv);
+    if (!(sargv && restricted))
+        return invoke_gsyncd(argc, argv);
 
-        argc = str2argv (sargv, &argv);
+    argc = str2argv(sargv, &argv);
 
-        if (argc == -1) {
-                fprintf (stderr, "internal error\n");
-                return 1;
-        }
-
-        if (setenv (_GSYNCD_DISPATCHED_, "1", 1) == -1) {
-                fprintf (stderr, "internal error\n");
-                goto out;
-        }
+    if (argc == -1) {
+        fprintf(stderr, "internal error\n");
+        return 1;
+    }
 
+    if (setenv(_GSYNCD_DISPATCHED_, "1", 1) == -1) {
+        fprintf(stderr, "internal error\n");
+        goto out;
+    }
 
-        b = basename (argv[0]);
-        for (i = invocables; i->name; i++) {
-                if (strcmp (b, i->name) == 0)
-                        return i->invoker (argc, argv);
-        }
+    b = basename(argv[0]);
+    for (i = invocables; i->name; i++) {
+        if (strcmp(b, i->name) == 0)
+            return i->invoker(argc, argv);
+    }
 
-        fprintf (stderr, "invoking %s in restricted SSH session is not allowed\n",
-                 b);
+    fprintf(stderr, "invoking %s in restricted SSH session is not allowed\n",
+            b);
 
 out:
-        for (j = 1; j < argc; j++)
-                free(argv[j]);
-        free(argv);
-        return 1;
+    for (j = 1; j < argc; j++)
+        free(argv[j]);
+    free(argv);
+    return 1;
 }
diff --git a/geo-replication/src/gverify.sh b/geo-replication/src/gverify.sh
index 9b1328aa631..f5f70d245e0 100755
--- a/geo-replication/src/gverify.sh
+++ b/geo-replication/src/gverify.sh
@@ -7,15 +7,24 @@
 # Considering buffer_size 100MB
 BUFFER_SIZE=104857600;
 SSH_PORT=$5;
-slave_log_file=`gluster --print-logdir`/geo-replication-slaves/slave.log
+master_log_file=`gluster --print-logdir`/geo-replication/gverify-mastermnt.log
+slave_log_file=`gluster --print-logdir`/geo-replication/gverify-slavemnt.log
 
 function SSHM()
 {
-    ssh -p ${SSH_PORT} -q \
-	-oPasswordAuthentication=no \
-	-oStrictHostKeyChecking=no \
-	-oControlMaster=yes \
-	"$@";
+    if [[ -z "${GR_SSH_IDENTITY_KEY}" ]]; then
+        ssh -p ${SSH_PORT} -q \
+	    -oPasswordAuthentication=no \
+	    -oStrictHostKeyChecking=no \
+	    -oControlMaster=yes \
+	    "$@";
+    else
+        ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} -q \
+	    -oPasswordAuthentication=no \
+	    -oStrictHostKeyChecking=no \
+	    -oControlMaster=yes \
+	    "$@";
+    fi
 }
 
 function get_inode_num()
@@ -85,6 +94,7 @@ echo $cmd_line;
 function master_stats()
 {
     MASTERVOL=$1;
+    local inet6=$2;
     local d;
     local i;
     local disk_size;
@@ -93,7 +103,12 @@ function master_stats()
     local m_status;
 
     d=$(mktemp -d -t ${0##*/}.XXXXXX 2>/dev/null);
-    glusterfs -s localhost --xlator-option="*dht.lookup-unhashed=off" --volfile-id $MASTERVOL -l $slave_log_file $d;
+    if [ "$inet6" = "inet6" ]; then
+        glusterfs -s localhost --xlator-option="*dht.lookup-unhashed=off" --xlator-option="transport.address-family=inet6" --volfile-id $MASTERVOL -l $master_log_file $d;
+    else
+        glusterfs -s localhost --xlator-option="*dht.lookup-unhashed=off" --volfile-id $MASTERVOL -l $master_log_file $d;
+    fi
+
     i=$(get_inode_num $d);
     if [[ "$i" -ne "1" ]]; then
         echo 0:0;
@@ -115,12 +130,18 @@ function slave_stats()
     SLAVEUSER=$1;
     SLAVEHOST=$2;
     SLAVEVOL=$3;
+    local inet6=$4;
     local cmd_line;
     local ver;
     local status;
 
     d=$(mktemp -d -t ${0##*/}.XXXXXX 2>/dev/null);
-    glusterfs --xlator-option="*dht.lookup-unhashed=off" --volfile-server $SLAVEHOST --volfile-id $SLAVEVOL -l $slave_log_file $d;
+    if [ "$inet6" = "inet6" ]; then
+        glusterfs --xlator-option="*dht.lookup-unhashed=off" --xlator-option="transport.address-family=inet6" --volfile-server $SLAVEHOST --volfile-id $SLAVEVOL -l $slave_log_file $d;
+    else
+        glusterfs --xlator-option="*dht.lookup-unhashed=off" --volfile-server $SLAVEHOST --volfile-id $SLAVEVOL -l $slave_log_file $d;
+    fi
+
     i=$(get_inode_num $d);
     if [[ "$i" -ne "1" ]]; then
         echo 0:0;
@@ -158,6 +179,10 @@ function main()
     log_file=$6
     > $log_file
 
+    inet6=$7
+    local cmd_line
+    local ver
+
     # Use FORCE_BLOCKER flag in the error message to differentiate
     # between the errors which the force command should bypass
 
@@ -172,15 +197,32 @@ function main()
         exit 1;
     fi;
 
-    ssh -p ${SSH_PORT} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 "echo Testing_Passwordless_SSH";
+    if [[ -z "${GR_SSH_IDENTITY_KEY}" ]]; then
+        ssh -p ${SSH_PORT} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 "echo Testing_Passwordless_SSH";
+    else
+        ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 "echo Testing_Passwordless_SSH";
+    fi
+
     if [ $? -ne 0 ]; then
         echo "FORCE_BLOCKER|Passwordless ssh login has not been setup with $3 for user $2." > $log_file
         exit 1;
     fi;
 
+    cmd_line=$(cmd_slave);
+    if [[ -z "${GR_SSH_IDENTITY_KEY}" ]]; then
+        ver=$(ssh -p ${SSH_PORT} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 bash -c "'$cmd_line'")
+    else
+        ver=$(ssh -p ${SSH_PORT} -i ${GR_SSH_IDENTITY_KEY} -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $2@$3 bash -c "'$cmd_line'")
+    fi
+
+    if [ -z "$ver" ]; then
+        echo "FORCE_BLOCKER|gluster command not found on $3 for user $2." > $log_file
+        exit 1;
+    fi;
+
     ERRORS=0;
-    master_data=$(master_stats $1);
-    slave_data=$(slave_stats $2 $3 $4);
+    master_data=$(master_stats $1 ${inet6});
+    slave_data=$(slave_stats $2 $3 $4 ${inet6});
     master_disk_size=$(echo $master_data | cut -f1 -d':');
     slave_disk_size=$(echo $slave_data | cut -f1 -d':');
     master_used_size=$(echo $master_data | cut -f2 -d':');
@@ -190,12 +232,12 @@ function main()
     slave_no_of_files=$(echo $slave_data | cut -f4 -d':');
 
     if [[ "x$master_disk_size" = "x" || "x$master_version" = "x" || "$master_disk_size" -eq "0" ]]; then
-        echo "FORCE_BLOCKER|Unable to fetch master volume details. Please check the master cluster and master volume." > $log_file;
+        echo "FORCE_BLOCKER|Unable to mount and fetch master volume details. Please check the log: $master_log_file" > $log_file;
 	exit 1;
     fi;
 
     if [[ "x$slave_disk_size" = "x" || "x$slave_version" = "x" || "$slave_disk_size" -eq "0" ]]; then
-	echo "FORCE_BLOCKER|Unable to fetch slave volume details. Please check the slave cluster and slave volume." > $log_file;
+	echo "FORCE_BLOCKER|Unable to mount and fetch slave volume details. Please check the log: $slave_log_file" > $log_file;
 	exit 1;
     fi;
 
@@ -223,7 +265,7 @@ function main()
     fi;
 
     if [[ $master_version != $slave_version ]]; then
-        echo "Gluster version mismatch between master and slave." >> $log_file;
+        echo "Gluster version mismatch between master and slave. Master version: $master_version Slave version: $slave_version" >> $log_file;
         ERRORS=$(($ERRORS + 1));
     fi;
 
diff --git a/geo-replication/src/peer_georep-sshkey.py.in b/geo-replication/src/peer_georep-sshkey.py.in
index 400f29d64f3..58696e9a616 100644
--- a/geo-replication/src/peer_georep-sshkey.py.in
+++ b/geo-replication/src/peer_georep-sshkey.py.in
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #
 #  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
@@ -30,8 +30,8 @@ from prettytable import PrettyTable
 
 SECRET_PEM = "@GLUSTERD_WORKDIR@/geo-replication/secret.pem"
 TAR_SSH_PEM = "@GLUSTERD_WORKDIR@/geo-replication/tar_ssh.pem"
-GSYNCD_CMD = 'command="@GLUSTERFS_LIBEXECDIR@/gsyncd"  '
-TAR_CMD = 'command="tar ${SSH_ORIGINAL_COMMAND#* }"  '
+GSYNCD_CMD = 'command="@GLUSTERFS_LIBEXECDIR@/gsyncd" '
+TAR_CMD = 'command="tar ${SSH_ORIGINAL_COMMAND#* }" '
 COMMON_SECRET_FILE = "@GLUSTERD_WORKDIR@/geo-replication/common_secret.pem.pub"
 
 
diff --git a/geo-replication/src/peer_gsec_create.in b/geo-replication/src/peer_gsec_create.in
index 05c1638bdcd..6d4a4847013 100755
--- a/geo-replication/src/peer_gsec_create.in
+++ b/geo-replication/src/peer_gsec_create.in
@@ -18,7 +18,7 @@ if [ "Xcontainer" = "X$1" ]; then
     output1=`cat "$GLUSTERD_WORKDIR"/geo-replication/secret.pem.pub`
     output2=`cat "$GLUSTERD_WORKDIR"/geo-replication/tar_ssh.pem.pub`
 else
-    output1=`echo command=\"${libexecdir}/glusterfs/gsyncd\" " "``cat "$GLUSTERD_WORKDIR"/geo-replication/secret.pem.pub`
-    output2=`echo command=\"tar \$\{SSH_ORIGINAL_COMMAND#* \}\" " "``cat "$GLUSTERD_WORKDIR"/geo-replication/tar_ssh.pem.pub`
+    output1=`echo command=\"${libexecdir}/glusterfs/gsyncd\" ""``cat "$GLUSTERD_WORKDIR"/geo-replication/secret.pem.pub`
+    output2=`echo command=\"tar \$\{SSH_ORIGINAL_COMMAND#* \}\" ""``cat "$GLUSTERD_WORKDIR"/geo-replication/tar_ssh.pem.pub`
 fi
 echo -e "$output1\n$output2"
diff --git a/geo-replication/src/peer_mountbroker.in b/geo-replication/src/peer_mountbroker.in
index ec514f038e1..8ecf38ded41 100644
--- a/geo-replication/src/peer_mountbroker.in
+++ b/geo-replication/src/peer_mountbroker.in
@@ -1,10 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
+
+from __future__ import print_function
+
 import os
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 import json
 import sys
 
-
 PROG_DESCRIPTION = """
 GlusterFS Mountbroker user management
 """
@@ -14,19 +16,19 @@ args = None
 
 def ok(message=""):
     if (not args and "-j" in sys.argv) or (args and args.json):
-        print json.dumps({"ok": True, "message": message})
+        print(json.dumps({"ok": True, "message": message}))
     else:
         if message:
-            print message
+            print(message)
 
     sys.exit(0)
 
 
 def notok(message=""):
     if (not args and "-j" in sys.argv) or (args and args.json):
-        print json.dumps({"ok": False, "message": message})
+        print(json.dumps({"ok": False, "message": message}))
     else:
-        print "error: %s" % message
+        print("error: %s" % message)
 
     # Always return zero due to limitation while executing
     # as `gluster system:: execute`
@@ -64,7 +66,7 @@ class MountbrokerUserMgmt(object):
     def _get_write_data(self):
         op = "volume management\n"
         op += "    type mgmt/glusterd\n"
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             op += "    option %s %s\n" % (k, v)
         for line in self.commented_lines:
             op += "    %s\n" % line
@@ -87,7 +89,7 @@ class MountbrokerUserMgmt(object):
 
     def add_user(self, user, volumes):
         vols = set()
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             if k.startswith("mountbroker-geo-replication.") \
                and user == k.split(".")[-1]:
                 vols.update(v.split(","))
@@ -98,7 +100,7 @@ class MountbrokerUserMgmt(object):
 
     def remove_volume(self, user, volumes):
         vols = set()
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             if k.startswith("mountbroker-geo-replication.") \
                and user == k.split(".")[-1]:
                 vols.update(v.split(","))
@@ -118,7 +120,7 @@ class MountbrokerUserMgmt(object):
     def info(self):
         data = {"users": []}
 
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             if k.startswith("mountbroker-geo-replication."):
                 data["users"].append(
                     {"name": k.split(".")[-1], "volumes": v.split(",")}
@@ -132,7 +134,7 @@ class MountbrokerUserMgmt(object):
 def format_info(data):
     op = "%s %s\n" % ("Option".ljust(50), "Value".ljust(50))
     op += ("-" * 101) + "\n"
-    for key, value in data.iteritems():
+    for key, value in data.items():
         if key != "users":
             op += "%s %s\n" % (key.ljust(50), value)
 
diff --git a/geo-replication/src/peer_mountbroker.py.in b/geo-replication/src/peer_mountbroker.py.in
index be182c5a7de..40b90ffc560 100644
--- a/geo-replication/src/peer_mountbroker.py.in
+++ b/geo-replication/src/peer_mountbroker.py.in
@@ -1,4 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
+
+from __future__ import print_function
+
 import os
 from errno import EEXIST, ENOENT
 
@@ -8,6 +11,7 @@ from gluster.cliutils import (execute, Cmd, node_output_ok,
 from prettytable import PrettyTable
 
 LOG_DIR = "@localstatedir@/log/glusterfs/geo-replication-slaves"
+CLI_LOG = "@localstatedir@/log/glusterfs/cli.log"
 GEOREP_DIR = "@GLUSTERD_WORKDIR@/geo-replication"
 GLUSTERD_VOLFILE = "@GLUSTERD_VOLFILE@"
 
@@ -43,12 +47,12 @@ class MountbrokerUserMgmt(object):
             for line in f:
                 line = line.strip()
                 if line.startswith("option "):
-                    key, value = line.split(" ")[1:]
+                    key, value = line.split()[1:]
                     self._options[key] = value
                 if line.startswith("#"):
                     self.commented_lines.append(line)
 
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             if k.startswith("mountbroker-geo-replication."):
                 user = k.split(".")[-1]
                 self.user_volumes[user] = set(v.split(","))
@@ -59,7 +63,7 @@ class MountbrokerUserMgmt(object):
     def _get_write_data(self):
         op = "volume management\n"
         op += "    type mgmt/glusterd\n"
-        for k, v in self._options.iteritems():
+        for k, v in self._options.items():
             if k.startswith("mountbroker-geo-replication."):
                 # Users will be added seperately
                 continue
@@ -142,7 +146,7 @@ class NodeSetup(Cmd):
     # chgrp -R <grp> /var/log/glusterfs/geo-replication-slaves
     # chgrp -R <grp> /var/lib/glusterd/geo-replication
     # chmod -R 770 /var/log/glusterfs/geo-replication-slaves
-    # chmod -R 770 /var/lib/glusterd/geo-replication
+    # chmod 770 /var/lib/glusterd/geo-replication
     # mkdir -p <mnt_root>
     # chmod 0711 <mnt_root>
     # If selinux,
@@ -192,8 +196,13 @@ class NodeSetup(Cmd):
 
         execute(["chgrp", "-R", args.group, GEOREP_DIR])
         execute(["chgrp", "-R", args.group, LOG_DIR])
-        execute(["chmod", "-R", "770", GEOREP_DIR])
-        execute(["chmod", "-R", "770", args.group, LOG_DIR])
+        execute(["chgrp", args.group, CLI_LOG])
+        execute(["chmod", "770", GEOREP_DIR])
+        execute(["find", LOG_DIR, "-type", "d", "-exec", "chmod", "770", "{}",
+                 "+"])
+        execute(["find", LOG_DIR, "-type", "f", "-exec", "chmod", "660", "{}",
+                 "+"])
+        execute(["chmod", "660", CLI_LOG])
 
         m.set_mount_root_and_group(args.mount_root, args.group)
         m.save()
@@ -213,8 +222,10 @@ class CliSetup(Cmd):
     name = "setup"
 
     def args(self, parser):
-        parser.add_argument("mount_root")
-        parser.add_argument("group")
+        parser.add_argument("mount_root",
+                            help="Path to the mountbroker-root directory.")
+        parser.add_argument("group",
+                            help="Group to be used for setup.")
 
     def run(self, args):
         out = execute_in_peers("node-setup", [args.mount_root,
@@ -270,7 +281,7 @@ class CliStatus(Cmd):
 
         for p in out:
             node_data = p.output
-            if node_data == "":
+            if node_data == "" or node_data == "N/A":
                 node_data = {}
 
             users_row_data = ""
@@ -324,8 +335,10 @@ class CliAdd(Cmd):
     name = "add"
 
     def args(self, parser):
-        parser.add_argument("volume")
-        parser.add_argument("user")
+        parser.add_argument("volume",
+                            help="Volume to be added.")
+        parser.add_argument("user",
+                            help="User for which volume is to be added.")
 
     def run(self, args):
         out = execute_in_peers("node-add", [args.volume,
@@ -365,8 +378,9 @@ class CliRemove(Cmd):
     name = "remove"
 
     def args(self, parser):
-        parser.add_argument("--volume", default=".")
-        parser.add_argument("--user", default=".")
+        parser.add_argument("--volume", default=".", help="Volume to be removed.")
+        parser.add_argument("--user", default=".",
+                            help="User for which volume has to be removed.")
 
     def run(self, args):
         out = execute_in_peers("node-remove", [args.volume,
diff --git a/geo-replication/src/procdiggy.c b/geo-replication/src/procdiggy.c
index 35125d20ba8..8068ef79a42 100644
--- a/geo-replication/src/procdiggy.c
+++ b/geo-replication/src/procdiggy.c
@@ -15,110 +15,122 @@
 #include <ctype.h>
 #include <sys/param.h> /* for PATH_MAX */
 
-#include "common-utils.h"
-#include "syscall.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/syscall.h>
 #include "procdiggy.h"
 
 pid_t
-pidinfo (pid_t pid, char **name)
+pidinfo(pid_t pid, char **name)
 {
-        char buf[NAME_MAX * 2] = {0,};
-        FILE *f                = NULL;
-        char path[PATH_MAX]    = {0,};
-        char *p                = NULL;
-        int ret                = 0;
-
-        snprintf (path, sizeof path, PROC"/%d/status", pid);
-
-        f = fopen (path, "r");
-        if (!f)
-                return -1;
-
-        if (name)
-                *name = NULL;
-        for (;;) {
-                size_t len;
-                memset (buf, 0, sizeof (buf));
-                if (fgets (buf, sizeof (buf), f) == NULL ||
-                    (len = strlen (buf)) == 0 ||
-                    buf[len - 1] != '\n') {
-                        pid = -1;
-                        goto out;
-                }
-                buf[len - 1] = '\0';
-
-                if (name && !*name) {
-                        p = strtail (buf, "Name:");
-                        if (p) {
-                                while (isspace (*++p));
-                                *name = gf_strdup (p);
-                                if (!*name) {
-                                        pid = -2;
-                                        goto out;
-                                }
-                                continue;
-                        }
+    char buf[NAME_MAX * 2] = {
+        0,
+    };
+    FILE *f = NULL;
+    char path[PATH_MAX] = {
+        0,
+    };
+    char *p = NULL;
+    int ret = 0;
+    pid_t lpid = -1;
+
+    if (name)
+        *name = NULL;
+
+    snprintf(path, sizeof path, PROC "/%d/status", pid);
+
+    f = fopen(path, "r");
+    if (!f)
+        return -1;
+
+    for (;;) {
+        size_t len;
+        memset(buf, 0, sizeof(buf));
+        if (fgets(buf, sizeof(buf), f) == NULL || (len = strlen(buf)) == 0 ||
+            buf[len - 1] != '\n') {
+            lpid = -1;
+            goto out;
+        }
+        buf[len - 1] = '\0';
+
+        if (name && !*name) {
+            p = strtail(buf, "Name:");
+            if (p) {
+                while (isspace(*++p))
+                    ;
+                *name = gf_strdup(p);
+                if (!*name) {
+                    lpid = -2;
+                    goto out;
                 }
-
-                p = strtail (buf, "PPid:");
-                if (p)
-                        break;
+                continue;
+            }
         }
 
-        while (isspace (*++p));
-        ret = gf_string2int (p, &pid);
-        if (ret == -1)
-                pid = -1;
-
- out:
-        fclose (f);
-        if (pid == -1 && name && *name)
-                GF_FREE (name);
-        if (pid == -2)
-                fprintf (stderr, "out of memory\n");
-        return pid;
+        p = strtail(buf, "PPid:");
+        if (p)
+            break;
+    }
+
+    while (isspace(*++p))
+        ;
+    ret = gf_string2int(p, &lpid);
+    if (ret == -1)
+        lpid = -1;
+
+out:
+    fclose(f);
+    if (lpid == -1 && name && *name)
+        GF_FREE(*name);
+    if (lpid == -2)
+        fprintf(stderr, "out of memory\n");
+    return lpid;
 }
 
 int
-prociter (int (*proch) (pid_t pid, pid_t ppid, char *tmpname, void *data),
-          void *data)
+prociter(int (*proch)(pid_t pid, pid_t ppid, char *tmpname, void *data),
+         void *data)
 {
-        char *name        = NULL;
-        DIR *d            = NULL;
-        struct dirent *de = NULL;
-        struct dirent scratch[2] = {{0,},};
-        pid_t pid         = -1;
-        pid_t ppid        = -1;
-        int ret           = 0;
-
-        d = sys_opendir (PROC);
-        if (!d)
-                return -1;
-
-        for (;;) {
-                errno = 0;
-                de = sys_readdir (d, scratch);
-                if (!de || errno != 0)
-                        break;
-
-                if (gf_string2int (de->d_name, &pid) != -1 && pid >= 0) {
-                        ppid = pidinfo (pid, &name);
-                        switch (ppid) {
-                        case -1: continue;
-                        case -2: ret = -1; break;
-                        }
-                        ret = proch (pid, ppid, name, data);
-                        GF_FREE (name);
-                        if (ret)
-                                break;
-                }
-        }
-        sys_closedir (d);
-        if (!de && errno) {
-                fprintf (stderr, "failed to traverse "PROC" (%s)\n",
-                         strerror (errno));
-                ret = -1;
+    char *name = NULL;
+    DIR *d = NULL;
+    struct dirent *de = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    pid_t pid = -1;
+    pid_t ppid = -1;
+    int ret = 0;
+
+    d = sys_opendir(PROC);
+    if (!d)
+        return -1;
+
+    for (;;) {
+        errno = 0;
+        de = sys_readdir(d, scratch);
+        if (!de || errno != 0)
+            break;
+
+        if (gf_string2int(de->d_name, &pid) != -1 && pid >= 0) {
+            ppid = pidinfo(pid, &name);
+            switch (ppid) {
+                case -1:
+                    continue;
+                case -2:
+                    break;
+            }
+            ret = proch(pid, ppid, name, data);
+            GF_FREE(name);
+            if (ret)
+                break;
         }
-
-        return ret;
+    }
+    sys_closedir(d);
+    if (!de && errno) {
+        fprintf(stderr, "failed to traverse " PROC " (%s)\n", strerror(errno));
+        ret = -1;
+    }
+
+    return ret;
 }
diff --git a/geo-replication/src/procdiggy.h b/geo-replication/src/procdiggy.h
index 56dfc4eb213..e17ccd31c89 100644
--- a/geo-replication/src/procdiggy.h
+++ b/geo-replication/src/procdiggy.h
@@ -13,8 +13,9 @@
 
 #define PROC "/proc"
 
-pid_t pidinfo (pid_t pid, char **name);
-
-int prociter (int (*proch) (pid_t pid, pid_t ppid, char *name, void *data),
-              void *data);
+pid_t
+pidinfo(pid_t pid, char **name);
 
+int
+prociter(int (*proch)(pid_t pid, pid_t ppid, char *name, void *data),
+         void *data);
diff --git a/geo-replication/src/set_geo_rep_pem_keys.sh b/geo-replication/src/set_geo_rep_pem_keys.sh
index ae23f4ff0c6..8a43fa39d1f 100755
--- a/geo-replication/src/set_geo_rep_pem_keys.sh
+++ b/geo-replication/src/set_geo_rep_pem_keys.sh
@@ -47,6 +47,7 @@ function main()
         cp $home_dir/${COMMON_SECRET_PEM_PUB} ${GLUSTERD_WORKDIR}/geo-replication/
         gluster system:: copy file /geo-replication/${COMMON_SECRET_PEM_PUB}
         gluster system:: execute add_secret_pub $user geo-replication/${master_vol}_${slave_vol}_common_secret.pem.pub
+        gluster vol set ${slave_vol} features.read-only on
     else
         echo "$home_dir/common_secret.pem.pub not present. Please run geo-replication command on master with push-pem option to generate the file"
         exit 1;
diff --git a/geo-replication/syncdaemon/Makefile.am b/geo-replication/syncdaemon/Makefile.am
index f80fb26c28a..d70e3368faf 100644
--- a/geo-replication/syncdaemon/Makefile.am
+++ b/geo-replication/syncdaemon/Makefile.am
@@ -1,8 +1,8 @@
 syncdaemondir = $(GLUSTERFS_LIBEXECDIR)/python/syncdaemon
 
-syncdaemon_PYTHON = gconf.py gsyncd.py __init__.py master.py README.md repce.py \
-	resource.py configinterface.py syncdutils.py monitor.py libcxattr.py \
-	$(top_builddir)/contrib/ipaddr-py/ipaddr.py libgfchangelog.py changelogagent.py \
-	gsyncdstatus.py conf.py
+syncdaemon_PYTHON = rconf.py gsyncd.py __init__.py master.py README.md repce.py \
+	resource.py syncdutils.py monitor.py libcxattr.py gsyncdconfig.py \
+	libgfchangelog.py gsyncdstatus.py conf.py logutils.py \
+	subcmds.py argsupgrade.py py2py3.py
 
 CLEANFILES =
diff --git a/geo-replication/syncdaemon/README.md b/geo-replication/syncdaemon/README.md
index 2a202e3f99e..5ab785ae669 100644
--- a/geo-replication/syncdaemon/README.md
+++ b/geo-replication/syncdaemon/README.md
@@ -19,7 +19,6 @@ INSTALLATION
 
 As of now, the supported way of operation is running from the source directory or using the RPMs given.
 
-If you use Python 2.4.x, you need to install the [Ctypes module](http://python.net/crew/theller/ctypes/).
 
 CONFIGURATION
 -------------
diff --git a/geo-replication/syncdaemon/__codecheck.py b/geo-replication/syncdaemon/__codecheck.py
index 45dbd26bb64..9437147f7d9 100644
--- a/geo-replication/syncdaemon/__codecheck.py
+++ b/geo-replication/syncdaemon/__codecheck.py
@@ -8,6 +8,7 @@
 # cases as published by the Free Software Foundation.
 #
 
+from __future__ import print_function
 import os
 import os.path
 import sys
@@ -45,7 +46,7 @@ class IPNetwork(list):
     gsyncd = sys.modules['gsyncd']
     for a in [['--help'], ['--version'],
               ['--canonicalize-escape-url', '/foo']]:
-        print('>>> invoking program with args: %s' % ' '.join(a))
+        print(('>>> invoking program with args: %s' % ' '.join(a)))
         pid = os.fork()
         if not pid:
             sys_argv_set(a)
diff --git a/geo-replication/syncdaemon/argsupgrade.py b/geo-replication/syncdaemon/argsupgrade.py
new file mode 100644
index 00000000000..7af40633ef8
--- /dev/null
+++ b/geo-replication/syncdaemon/argsupgrade.py
@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+#
+# Converts old style args into new style args
+
+from __future__ import print_function
+import sys
+from argparse import ArgumentParser
+import socket
+import os
+
+from syncdutils import GsyncdError
+from conf import GLUSTERD_WORKDIR
+
+
+def gethostbyname(hnam):
+    """gethostbyname wrapper"""
+    try:
+        return socket.gethostbyname(hnam)
+    except socket.gaierror:
+        ex = sys.exc_info()[1]
+        raise GsyncdError("failed to resolve %s: %s" %
+                          (hnam, ex.strerror))
+
+
+def slave_url(urldata):
+    urldata = urldata.replace("ssh://", "")
+    host, vol = urldata.split("::")
+    vol = vol.split(":")[0]
+    return "%s::%s" % (host, vol)
+
+
+def init_gsyncd_template_conf():
+    path = GLUSTERD_WORKDIR + "/geo-replication/gsyncd_template.conf"
+    dname = os.path.dirname(path)
+    if not os.path.exists(dname):
+        try:
+            os.mkdir(dname)
+        except OSError:
+            pass
+
+    if not os.path.exists(path):
+        fd = os.open(path, os.O_CREAT | os.O_RDWR)
+        os.close(fd)
+
+
+def init_gsyncd_session_conf(master, slave):
+    slave = slave_url(slave)
+    master = master.strip(":")
+    slavehost, slavevol = slave.split("::")
+    slavehost = slavehost.split("@")[-1]
+
+    # Session Config File
+    path = "%s/geo-replication/%s_%s_%s/gsyncd.conf" % (
+        GLUSTERD_WORKDIR, master, slavehost, slavevol)
+
+    if os.path.exists(os.path.dirname(path)) and not os.path.exists(path):
+        fd = os.open(path, os.O_CREAT | os.O_RDWR)
+        os.close(fd)
+
+
+def init_gsyncd_conf(path):
+    dname = os.path.dirname(path)
+    if not os.path.exists(dname):
+        try:
+            os.mkdir(dname)
+        except OSError:
+            pass
+
+    if os.path.exists(dname) and not os.path.exists(path):
+        fd = os.open(path, os.O_CREAT | os.O_RDWR)
+        os.close(fd)
+
+
+def upgrade():
+    # Create dummy template conf(empty), hack to avoid glusterd
+    # fail when it does stat to check the existence.
+    init_gsyncd_template_conf()
+
+    inet6 = False
+    if "--inet6" in sys.argv:
+        inet6 = True
+
+    if "--monitor" in sys.argv:
+        # python gsyncd.py --path=/bricks/b1
+        # --monitor -c gsyncd.conf
+        # --iprefix=/var :gv1
+        # --glusterd-uuid=f26ac7a8-eb1b-4ea7-959c-80b27d3e43d0
+        # f241::gv2
+        p = ArgumentParser()
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("--glusterd-uuid")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        p.add_argument("--path", action="append")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        # Overwrite the sys.argv after rearrange
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+        sys.argv = [
+            sys.argv[0],
+            "monitor",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            "--local-node-id",
+            pargs.glusterd_uuid
+        ]
+    elif "--status-get" in sys.argv:
+        # -c gsyncd.conf --iprefix=/var :gv1 f241::gv2
+        # --status-get --path /bricks/b1
+        p = ArgumentParser()
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("-c")
+        p.add_argument("--path")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        sys.argv = [
+            sys.argv[0],
+            "status",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            "--local-path",
+            pargs.path
+        ]
+    elif "--canonicalize-url" in sys.argv:
+        # This can accept multiple URLs and converts each URL to the
+        # format ssh://USER@IP:gluster://127.0.0.1:VOLUME
+        # This format not used in gsyncd, but added for glusterd compatibility
+        p = ArgumentParser()
+        p.add_argument("--canonicalize-url", nargs="+")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        for url in pargs.canonicalize_url:
+            host, vol = url.split("::")
+            host = host.replace("ssh://", "")
+            remote_addr = host
+            if "@" not in remote_addr:
+                remote_addr = "root@" + remote_addr
+
+            user, hname = remote_addr.split("@")
+
+            if not inet6:
+                hname = gethostbyname(hname)
+
+            print(("ssh://%s@%s:gluster://127.0.0.1:%s" % (
+                user, hname, vol)))
+
+        sys.exit(0)
+    elif "--normalize-url" in sys.argv:
+        # Adds schema prefix as ssh://
+        # This format not used in gsyncd, but added for glusterd compatibility
+        p = ArgumentParser()
+        p.add_argument("--normalize-url")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+        print(("ssh://%s" % slave_url(pargs.normalize_url)))
+        sys.exit(0)
+    elif "--config-get-all" in sys.argv:
+        #  -c gsyncd.conf --iprefix=/var :gv1 f241::gv2 --config-get-all
+        p = ArgumentParser()
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        sys.argv = [
+            sys.argv[0],
+            "config-get",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            "--show-defaults",
+            "--use-underscore"
+        ]
+    elif "--verify" in sys.argv and "spawning" in sys.argv:
+        # Just checks that able to spawn gsyncd or not
+        sys.exit(0)
+    elif "--slavevoluuid-get" in sys.argv:
+        # --slavevoluuid-get f241::gv2
+        p = ArgumentParser()
+        p.add_argument("--slavevoluuid-get")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+        host, vol = pargs.slavevoluuid_get.split("::")
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "voluuidget",
+            host,
+            vol
+        ]
+    elif "--config-set-rx" in sys.argv:
+        # Not required since default conf is not generated
+        # and custom conf generated only when required
+        # -c gsyncd.conf --config-set-rx remote-gsyncd
+        # /usr/local/libexec/glusterfs/gsyncd . .
+        # Touch the gsyncd.conf file and create session
+        # directory if required
+        p = ArgumentParser()
+        p.add_argument("-c", dest="config_file")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        # If not template conf then it is trying to create
+        # session config, create a empty file instead
+        if pargs.config_file.endswith("gsyncd.conf"):
+            init_gsyncd_conf(pargs.config_file)
+        sys.exit(0)
+    elif "--create" in sys.argv:
+        # To update monitor status file
+        # --create Created -c gsyncd.conf
+        # --iprefix=/var :gv1 f241::gv2
+        p = ArgumentParser()
+        p.add_argument("--create")
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "monitor-status",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            pargs.create
+        ]
+    elif "--config-get" in sys.argv:
+        # -c gsyncd.conf --iprefix=/var :gv1 f241::gv2 --config-get pid-file
+        p = ArgumentParser()
+        p.add_argument("--config-get")
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "config-get",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            "--only-value",
+            "--show-defaults",
+            "--name",
+            pargs.config_get.replace("_", "-")
+        ]
+    elif "--config-set" in sys.argv:
+        # ignore session-owner
+        if "session-owner" in sys.argv:
+            sys.exit(0)
+
+        # --path=/bricks/b1  -c gsyncd.conf :gv1 f241::gv2
+        # --config-set log_level DEBUG
+        p = ArgumentParser()
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("--config-set", action='store_true')
+        p.add_argument("name")
+        p.add_argument("--value")
+        p.add_argument("-c")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "config-set",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            "--name=%s" % pargs.name,
+            "--value=%s" % pargs.value
+        ]
+    elif "--config-check" in sys.argv:
+        # --config-check georep_session_working_dir
+        p = ArgumentParser()
+        p.add_argument("--config-check")
+        p.add_argument("-c")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "config-check",
+            pargs.config_check.replace("_", "-")
+        ]
+    elif "--config-del" in sys.argv:
+        # -c gsyncd.conf --iprefix=/var :gv1 f241::gv2 --config-del log_level
+        p = ArgumentParser()
+        p.add_argument("--config-del")
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("-c")
+        p.add_argument("--iprefix")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "config-reset",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave),
+            pargs.config_del.replace("_", "-")
+        ]
+    elif "--delete" in sys.argv:
+        # --delete -c gsyncd.conf --iprefix=/var
+        # --path-list=--path=/bricks/b1  :gv1 f241::gv2
+        p = ArgumentParser()
+        p.add_argument("--reset-sync-time", action="store_true")
+        p.add_argument("--path-list")
+        p.add_argument("master")
+        p.add_argument("slave")
+        p.add_argument("--iprefix")
+        p.add_argument("-c")
+        pargs = p.parse_known_args(sys.argv[1:])[0]
+
+        init_gsyncd_session_conf(pargs.master, pargs.slave)
+
+        paths = pargs.path_list.split("--path=")
+        paths = ["--path=%s" % x.strip() for x in paths if x.strip() != ""]
+
+        # Modified sys.argv
+        sys.argv = [
+            sys.argv[0],
+            "delete",
+            pargs.master.strip(":"),
+            slave_url(pargs.slave)
+        ]
+        sys.argv += paths
+
+        if pargs.reset_sync_time:
+            sys.argv.append("--reset-sync-time")
+
+    if inet6:
+        # Add `--inet6` as first argument
+        sys.argv = [sys.argv[0], "--inet6"] + sys.argv[1:]
diff --git a/geo-replication/syncdaemon/changelogagent.py b/geo-replication/syncdaemon/changelogagent.py
deleted file mode 100644
index 731dbd06f57..00000000000
--- a/geo-replication/syncdaemon/changelogagent.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
-# This file is part of GlusterFS.
-
-# This file is licensed to you under your choice of the GNU Lesser
-# General Public License, version 3 or any later version (LGPLv3 or
-# later), or the GNU General Public License, version 2 (GPLv2), in all
-# cases as published by the Free Software Foundation.
-#
-
-import os
-import logging
-import syncdutils
-from syncdutils import select, CHANGELOG_AGENT_SERVER_VERSION
-from repce import RepceServer
-
-
-class _MetaChangelog(object):
-
-    def __getattr__(self, meth):
-        from libgfchangelog import Changes as LChanges
-        xmeth = [m for m in dir(LChanges) if m[0] != '_']
-        if meth not in xmeth:
-            return
-        for m in xmeth:
-            setattr(self, m, getattr(LChanges, m))
-        return getattr(self, meth)
-
-Changes = _MetaChangelog()
-
-
-class Changelog(object):
-    def version(self):
-        return CHANGELOG_AGENT_SERVER_VERSION
-
-    def init(self):
-        return Changes.cl_init()
-
-    def register(self, cl_brick, cl_dir, cl_log, cl_level, retries=0):
-        return Changes.cl_register(cl_brick, cl_dir, cl_log, cl_level, retries)
-
-    def scan(self):
-        return Changes.cl_scan()
-
-    def getchanges(self):
-        return Changes.cl_getchanges()
-
-    def done(self, clfile):
-        return Changes.cl_done(clfile)
-
-    def history(self, changelog_path, start, end, num_parallel):
-        return Changes.cl_history_changelog(changelog_path, start, end,
-                                            num_parallel)
-
-    def history_scan(self):
-        return Changes.cl_history_scan()
-
-    def history_getchanges(self):
-        return Changes.cl_history_getchanges()
-
-    def history_done(self, clfile):
-        return Changes.cl_history_done(clfile)
-
-
-class ChangelogAgent(object):
-    def __init__(self, obj, fd_tup):
-        (inf, ouf, rw, ww) = fd_tup.split(',')
-        repce = RepceServer(obj, int(inf), int(ouf), 1)
-        t = syncdutils.Thread(target=lambda: (repce.service_loop(),
-                                              syncdutils.finalize()))
-        t.start()
-        logging.info('Agent listining...')
-
-        select((), (), ())
-
-
-def agent(obj, fd_tup):
-    return ChangelogAgent(obj, fd_tup)
diff --git a/geo-replication/syncdaemon/conf.py.in b/geo-replication/syncdaemon/conf.py.in
index 9b7c64df9d7..2042fa9cdfb 100644
--- a/geo-replication/syncdaemon/conf.py.in
+++ b/geo-replication/syncdaemon/conf.py.in
@@ -13,3 +13,5 @@ GLUSTERD_WORKDIR = "@GLUSTERD_WORKDIR@"
 
 LOCALSTATEDIR = "@localstatedir@"
 UUID_FILE = "@GLUSTERD_WORKDIR@/glusterd.info"
+GLUSTERFS_CONFDIR = "@SYSCONF_DIR@/glusterfs"
+GCONF_VERSION = 4.0
diff --git a/geo-replication/syncdaemon/configinterface.py b/geo-replication/syncdaemon/configinterface.py
deleted file mode 100644
index a59dee7a4a6..00000000000
--- a/geo-replication/syncdaemon/configinterface.py
+++ /dev/null
@@ -1,434 +0,0 @@
-#
-# Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
-# This file is part of GlusterFS.
-
-# This file is licensed to you under your choice of the GNU Lesser
-# General Public License, version 3 or any later version (LGPLv3 or
-# later), or the GNU General Public License, version 2 (GPLv2), in all
-# cases as published by the Free Software Foundation.
-#
-
-try:
-    import ConfigParser
-except ImportError:
-    # py 3
-    import configparser as ConfigParser
-import re
-from string import Template
-import os
-import errno
-import sys
-from stat import ST_DEV, ST_INO, ST_MTIME
-import tempfile
-import shutil
-
-from syncdutils import escape, unescape, norm, update_file, GsyncdError
-from conf import GLUSTERD_WORKDIR, LOCALSTATEDIR
-
-SECT_ORD = '__section_order__'
-SECT_META = '__meta__'
-config_version = 2.0
-
-re_type = type(re.compile(''))
-
-TMPL_CONFIG_FILE = GLUSTERD_WORKDIR + "/geo-replication/gsyncd_template.conf"
-
-# (SECTION, OPTION, OLD VALUE, NEW VALUE)
-CONFIGS = (
-    ("peersrx . .",
-     "georep_session_working_dir",
-     "",
-     GLUSTERD_WORKDIR + "/geo-replication/${mastervol}_${remotehost}_"
-     "${slavevol}/"),
-    ("peersrx .",
-     "gluster_params",
-     "aux-gfid-mount xlator-option=\*-dht.assert-no-child-down=true",
-     "aux-gfid-mount"),
-    ("peersrx .",
-     "gluster_params",
-     "aux-gfid-mount",
-     "aux-gfid-mount acl"),
-    ("peersrx . .",
-     "ssh_command_tar",
-     "",
-     "ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no "
-     "-i " + GLUSTERD_WORKDIR + "/geo-replication/tar_ssh.pem"),
-    ("peersrx . .",
-     "changelog_log_file",
-     "",
-     "${iprefix}/log/glusterfs/geo-replication/${mastervol}"
-     "/${eSlave}${local_id}-changes.log"),
-    ("peersrx . .",
-     "working_dir",
-     LOCALSTATEDIR + "/run/gluster/${mastervol}/${eSlave}",
-     "${iprefix}/lib/misc/glusterfsd/${mastervol}/${eSlave}"),
-    ("peersrx . .",
-     "ignore_deletes",
-     "true",
-     "false"),
-    ("peersrx . .",
-     "pid-file",
-     GLUSTERD_WORKDIR + "/geo-replication/${mastervol}_${remotehost}_"
-     "${slavevol}/${eSlave}.pid",
-     GLUSTERD_WORKDIR + "/geo-replication/${mastervol}_${remotehost}_"
-     "${slavevol}/monitor.pid"),
-    ("peersrx . .",
-     "state-file",
-     GLUSTERD_WORKDIR + "/geo-replication/${mastervol}_${remotehost}_"
-     "${slavevol}/${eSlave}.status",
-     GLUSTERD_WORKDIR + "/geo-replication/${mastervol}_${remotehost}_"
-     "${slavevol}/monitor.status"),
-    ("peersrx .",
-     "log_file",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/${session_owner}:${eSlave}.log",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/${session_owner}:${local_node}${local_id}.${slavevol}.log"),
-    ("peersrx .",
-     "log_file_mbr",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/mbr/${session_owner}:${eSlave}.log",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/mbr/${session_owner}:${local_node}${local_id}.${slavevol}.log"),
-    ("peersrx .",
-     "gluster_log_file",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/${session_owner}:${eSlave}.gluster.log",
-     "${iprefix}/log/glusterfs/geo-replication-slaves/${session_owner}:${local_node}${local_id}.${slavevol}.gluster.log")
-)
-
-
-def upgrade_config_file(path, confdata):
-    config_change = False
-    config = ConfigParser.RawConfigParser()
-    # If confdata.rx present then glusterd is adding config values,
-    # it will create config file if not exists. config.read is fine in
-    # this case since any other error will be raised during write.
-    if getattr(confdata, "rx", False):
-        config.read(path)
-    else:
-        with open(path) as fp:
-            config.readfp(fp)
-
-    for sec, opt, oldval, newval in CONFIGS:
-        try:
-            val = config.get(sec, opt)
-        except ConfigParser.NoOptionError:
-            # if new config opt not exists
-            config_change = True
-            config.set(sec, opt, newval)
-            continue
-        except ConfigParser.Error:
-            """
-            When gsyncd invoked at the time of create, config file
-            will not be their. Ignore any ConfigParser errors
-            """
-            continue
-
-        if val == newval:
-            # value is same as new val
-            continue
-
-        if val == oldval:
-            # config value needs update
-            config_change = True
-            config.set(sec, opt, newval)
-
-    # To convert from old peers section format to new peers section format.
-    # Old format: peers gluster://<master ip>:<master vol> \
-    #              ssh://root@<slave ip>:gluster://<master ip>:<slave vol>
-    # New format: peers <master vol name> <slave vol name>
-    for old_sect in config.sections():
-        if old_sect.startswith("peers "):
-            peers_data = old_sect.split(" ")
-            mvol = peers_data[1].split("%3A")[-1]
-            svol = peers_data[2].split("%3A")[-1]
-            new_sect = "peers {0} {1}".format(mvol, svol)
-
-            if old_sect == new_sect:
-                # Already in new format "peers mastervol slavevol"
-                continue
-
-            # Create new section if not exists
-            try:
-                config.add_section(new_sect)
-            except ConfigParser.DuplicateSectionError:
-                pass
-
-            config_change = True
-            # Add all the items of old_sect to new_sect
-            for key, val in config.items(old_sect):
-                config.set(new_sect, key, val)
-
-            # Delete old section
-            config.remove_section(old_sect)
-
-    if config_change:
-        tempConfigFile = tempfile.NamedTemporaryFile(mode="wb", delete=False)
-        with open(tempConfigFile.name, 'wb') as configFile:
-            config.write(configFile)
-
-        # If src and dst are two different file system, then os.rename
-        # fails, In this case if temp file created in /tmp and if /tmp is
-        # separate fs then os.rename gives following error, so use shutil
-        # OSError: [Errno 18] Invalid cross-device link
-        # mail.python.org/pipermail/python-list/2005-February/342893.html
-        shutil.move(tempConfigFile.name, path)
-
-
-class MultiDict(object):
-
-    """a virtual dict-like class which functions as the union
-    of underlying dicts"""
-
-    def __init__(self, *dd):
-        self.dicts = dd
-
-    def __getitem__(self, key):
-        val = None
-        for d in self.dicts:
-            if d.get(key) is not None:
-                val = d[key]
-        if val is None:
-            raise KeyError(key)
-        return val
-
-
-class GConffile(object):
-
-    """A high-level interface to ConfigParser which flattens the two-tiered
-       config layout by implenting automatic section dispatch based on initial
-       parameters.
-
-    Also ensure section ordering in terms of their time of addition -- a compat
-    hack for Python < 2.7.
-    """
-
-    def _normconfig(self):
-        """normalize config keys by s/-/_/g"""
-        for n, s in self.config._sections.items():
-            if n.find('__') == 0:
-                continue
-            s2 = type(s)()
-            for k, v in s.items():
-                if k.find('__') != 0:
-                    k = norm(k)
-                s2[k] = v
-            self.config._sections[n] = s2
-
-    def __init__(self, path, peers, confdata, *dd):
-        """
-        - .path: location of config file
-        - .config: underlying ConfigParser instance
-        - .peers: on behalf of whom we flatten .config
-          (master, or master-slave url pair)
-        - .auxdicts: template subtituents
-        """
-        self.peers = peers
-        self.path = path
-        self.auxdicts = dd
-        self.config = ConfigParser.RawConfigParser()
-        if getattr(confdata, "rx", False):
-            self.config.read(path)
-        else:
-            with open(path) as fp:
-                self.config.readfp(fp)
-
-        self.dev, self.ino, self.mtime = -1, -1, -1
-        self._normconfig()
-
-    def _load(self):
-        try:
-            sres = os.stat(self.path)
-            self.dev = sres[ST_DEV]
-            self.ino = sres[ST_INO]
-            self.mtime = sres[ST_MTIME]
-        except (OSError, IOError):
-            if sys.exc_info()[1].errno == errno.ENOENT:
-                sres = None
-
-        self.config = ConfigParser.RawConfigParser()
-        with open(self.path) as fp:
-            self.config.readfp(fp)
-        self._normconfig()
-
-    def get_realtime(self, opt, default_value=None):
-        try:
-            sres = os.stat(self.path)
-        except (OSError, IOError):
-            if sys.exc_info()[1].errno == errno.ENOENT:
-                sres = None
-            else:
-                raise
-
-        # compare file system stat with that of our stream file handle
-        if not sres or sres[ST_DEV] != self.dev or \
-           sres[ST_INO] != self.ino or self.mtime != sres[ST_MTIME]:
-            self._load()
-
-        return self.get(opt, printValue=False, default_value=default_value)
-
-    def section(self, rx=False):
-        """get the section name of the section representing .peers
-        in .config"""
-        peers = self.peers
-        if not peers:
-            peers = ['.', '.']
-            rx = True
-        if rx:
-            return ' '.join(['peersrx'] + [escape(u) for u in peers])
-        else:
-            return ' '.join(['peers'] + [u.split(':')[-1] for u in peers])
-
-    @staticmethod
-    def parse_section(section):
-        """retrieve peers sequence encoded by section name
-           (as urls or regexen, depending on section type)
-        """
-        sl = section.split()
-        st = sl.pop(0)
-        sl = [unescape(u) for u in sl]
-        if st == 'peersrx':
-            sl = [re.compile(u) for u in sl]
-        return sl
-
-    def ord_sections(self):
-        """Return an ordered list of sections.
-
-        Ordering happens based on the auxiliary
-        SECT_ORD section storing indices for each
-        section added through the config API.
-
-        To not to go corrupt in case of manually
-        written config files, we take care to append
-        also those sections which are not registered
-        in SECT_ORD.
-
-        Needed for python 2.{4,5,6} where ConfigParser
-        cannot yet order sections/options internally.
-        """
-        so = {}
-        if self.config.has_section(SECT_ORD):
-            so = self.config._sections[SECT_ORD]
-        so2 = {}
-        for k, v in so.items():
-            if k != '__name__':
-                so2[k] = int(v)
-        tv = 0
-        if so2:
-            tv = max(so2.values()) + 1
-        ss = [s for s in self.config.sections() if s.find('__') != 0]
-        for s in ss:
-            if s in so.keys():
-                continue
-            so2[s] = tv
-            tv += 1
-
-        def scmp(x, y):
-            return cmp(*(so2[s] for s in (x, y)))
-        ss.sort(scmp)
-        return ss
-
-    def update_to(self, dct, allow_unresolved=False):
-        """update @dct from key/values of ours.
-
-        key/values are collected from .config by filtering the regexp sections
-        according to match, and from .section. The values are treated as
-        templates, which are substituted from .auxdicts and (in case of regexp
-        sections) match groups.
-        """
-        if not self.peers:
-            raise GsyncdError('no peers given, cannot select matching options')
-
-        def update_from_sect(sect, mud):
-            for k, v in self.config._sections[sect].items():
-                # Template expects String to be passed
-                # if any config value is not string then it
-                # fails with ValueError
-                v = "{0}".format(v)
-
-                if k == '__name__':
-                    continue
-                if allow_unresolved:
-                    dct[k] = Template(v).safe_substitute(mud)
-                else:
-                    dct[k] = Template(v).substitute(mud)
-
-        for sect in self.ord_sections():
-            sp = self.parse_section(sect)
-            if isinstance(sp[0], re_type) and len(sp) == len(self.peers):
-                match = True
-                mad = {}
-                for i in range(len(sp)):
-                    m = sp[i].search(self.peers[i])
-                    if not m:
-                        match = False
-                        break
-                    for j in range(len(m.groups())):
-                        mad['match%d_%d' % (i + 1, j + 1)] = m.groups()[j]
-                if match:
-                    update_from_sect(sect, MultiDict(dct, mad, *self.auxdicts))
-        if self.config.has_section(self.section()):
-            update_from_sect(self.section(), MultiDict(dct, *self.auxdicts))
-
-    def get(self, opt=None, printValue=True, default_value=None):
-        """print the matching key/value pairs from .config,
-           or if @opt given, the value for @opt (according to the
-           logic described in .update_to)
-        """
-        d = {}
-        self.update_to(d, allow_unresolved=True)
-        if opt:
-            opt = norm(opt)
-            v = d.get(opt, default_value)
-
-            if printValue:
-                if v is not None:
-                    print(v)
-            else:
-                return v
-        else:
-            for k, v in d.iteritems():
-                if k == '__name__':
-                    continue
-                print("%s: %s" % (k, v))
-
-    def write(self, trfn, opt, *a, **kw):
-        """update on-disk config transactionally
-
-        @trfn is the transaction function
-        """
-        def mergeconf(f):
-            self.config = ConfigParser.RawConfigParser()
-            self.config.readfp(f)
-            self._normconfig()
-            if not self.config.has_section(SECT_META):
-                self.config.add_section(SECT_META)
-            self.config.set(SECT_META, 'version', config_version)
-            return trfn(norm(opt), *a, **kw)
-
-        def updateconf(f):
-            self.config.write(f)
-        update_file(self.path, updateconf, mergeconf)
-
-    def _set(self, opt, val, rx=False):
-        """set @opt to @val in .section"""
-        sect = self.section(rx)
-        if not self.config.has_section(sect):
-            self.config.add_section(sect)
-            # regarding SECT_ORD, cf. ord_sections
-            if not self.config.has_section(SECT_ORD):
-                self.config.add_section(SECT_ORD)
-            self.config.set(
-                SECT_ORD, sect, len(self.config._sections[SECT_ORD]))
-        self.config.set(sect, opt, val)
-        return True
-
-    def set(self, opt, *a, **kw):
-        """perform ._set transactionally"""
-        self.write(self._set, opt, *a, **kw)
-
-    def _delete(self, opt, rx=False):
-        """delete @opt from .section"""
-        sect = self.section(rx)
-        if self.config.has_section(sect):
-            return self.config.remove_option(sect, opt)
-
-    def delete(self, opt, *a, **kw):
-        """perform ._delete transactionally"""
-        self.write(self._delete, opt, *a, **kw)
diff --git a/geo-replication/syncdaemon/gsyncd.py b/geo-replication/syncdaemon/gsyncd.py
index 932e37d1124..257ed72c6ae 100644
--- a/geo-replication/syncdaemon/gsyncd.py
+++ b/geo-replication/syncdaemon/gsyncd.py
@@ -1,805 +1,325 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
 #
-# Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
-# This file is part of GlusterFS.
-
-# This file is licensed to you under your choice of the GNU Lesser
-# General Public License, version 3 or any later version (LGPLv3 or
-# later), or the GNU General Public License, version 2 (GPLv2), in all
-# cases as published by the Free Software Foundation.
+#  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
 #
 
+from argparse import ArgumentParser
+import time
 import os
-import os.path
-import glob
+from errno import EEXIST
 import sys
-import time
 import logging
-import shutil
-import optparse
-import fcntl
-import fnmatch
-from optparse import OptionParser, SUPPRESS_HELP
-from logging import Logger, handlers
-from errno import ENOENT
-
-from ipaddr import IPAddress, IPNetwork
-
-from gconf import gconf
-from syncdutils import FreeObject, norm, grabpidfile, finalize
-from syncdutils import log_raise_exception, privileged, boolify
-from syncdutils import GsyncdError, select, set_term_handler
-from configinterface import GConffile, upgrade_config_file, TMPL_CONFIG_FILE
-import resource
-from monitor import monitor
-import xml.etree.ElementTree as XET
-from subprocess import PIPE
-import subprocess
-from changelogagent import agent, Changelog
-from gsyncdstatus import set_monitor_status, GeorepStatus, human_time_utc
-from libcxattr import Xattr
-import struct
-from syncdutils import get_master_and_slave_data_from_args, lf
-
-ParseError = XET.ParseError if hasattr(XET, 'ParseError') else SyntaxError
-
-
-class GLogger(Logger):
-
-    """Logger customizations for gsyncd.
-
-    It implements a log format similar to that of glusterfs.
-    """
-
-    def makeRecord(self, name, level, *a):
-        rv = Logger.makeRecord(self, name, level, *a)
-        rv.nsecs = (rv.created - int(rv.created)) * 1000000
-        fr = sys._getframe(4)
-        callee = fr.f_locals.get('self')
-        if callee:
-            ctx = str(type(callee)).split("'")[1].split('.')[-1]
-        else:
-            ctx = '<top>'
-        if not hasattr(rv, 'funcName'):
-            rv.funcName = fr.f_code.co_name
-        rv.lvlnam = logging.getLevelName(level)[0]
-        rv.ctx = ctx
-        return rv
-
-    @classmethod
-    def setup(cls, **kw):
-        lbl = kw.get('label', "")
-        if lbl:
-            lbl = '(' + lbl + ')'
-        lprm = {'datefmt': "%Y-%m-%d %H:%M:%S",
-                'format': "[%(asctime)s.%(nsecs)d] %(lvlnam)s [%(module)s" +
-                lbl + ":%(lineno)s:%(funcName)s] %(ctx)s: %(message)s"}
-        lprm.update(kw)
-        lvl = kw.get('level', logging.INFO)
-        lprm['level'] = lvl
-        logging.root = cls("root", lvl)
-        logging.setLoggerClass(cls)
-        logging.getLogger().handlers = []
-        logging.getLogger().setLevel(lprm['level'])
-        logging.Formatter.converter = time.gmtime  # Log in GMT/UTC time
-
-        if 'filename' in lprm:
-            try:
-                logging_handler = handlers.WatchedFileHandler(lprm['filename'])
-                formatter = logging.Formatter(fmt=lprm['format'],
-                                              datefmt=lprm['datefmt'])
-                logging_handler.setFormatter(formatter)
-                logging.getLogger().addHandler(logging_handler)
-            except AttributeError:
-                # Python version < 2.6 will not have WatchedFileHandler
-                # so fallback to logging without any handler.
-                # Note: logrotate will not work if Python version is < 2.6
-                logging.basicConfig(**lprm)
-        else:
-            # If filename not passed(not available in lprm) then it may be
-            # streaming.(Ex: {"stream": "/dev/stdout"})
-            logging.basicConfig(**lprm)
-
-    @classmethod
-    def _gsyncd_loginit(cls, **kw):
-        lkw = {}
-        if gconf.log_level:
-            lkw['level'] = gconf.log_level
-        if kw.get('log_file'):
-            if kw['log_file'] in ('-', '/dev/stderr'):
-                lkw['stream'] = sys.stderr
-            elif kw['log_file'] == '/dev/stdout':
-                lkw['stream'] = sys.stdout
-            else:
-                lkw['filename'] = kw['log_file']
-
-        cls.setup(label=kw.get('label'), **lkw)
-
-        lkw.update({'saved_label': kw.get('label')})
-        gconf.log_metadata = lkw
-        gconf.log_exit = True
-
-
-# Given slave host and its volume name, get corresponding volume uuid
-def slave_vol_uuid_get(host, vol):
-    po = subprocess.Popen(['gluster', '--xml', '--remote-host=' + host,
-                           'volume', 'info', vol], bufsize=0,
-                          stdin=None, stdout=PIPE, stderr=PIPE)
-    vix, err = po.communicate()
-    if po.returncode != 0:
-        logging.info(lf("Volume info failed, unable to get "
-                        "volume uuid of slavevol, "
-                        "returning empty string",
-                        slavevol=vol,
-                        slavehost=host,
-                        error=po.returncode))
-        return ""
-    vi = XET.fromstring(vix)
-    if vi.find('opRet').text != '0':
-        logging.info(lf("Unable to get volume uuid of slavevol, "
-                        "returning empty string",
-                        slavevol=vol,
-                        slavehost=host,
-                        error=vi.find('opErrstr').text))
-        return ""
 
-    try:
-        voluuid = vi.find("volInfo/volumes/volume/id").text
-    except (ParseError, AttributeError, ValueError) as e:
-        logging.info(lf("Parsing failed to volume uuid of slavevol, "
-                        "returning empty string",
-                        slavevol=vol,
-                        slavehost=host,
-                        error=e))
-        voluuid = ""
-
-    return voluuid
-
-
-def startup(**kw):
-    """set up logging, pidfile grabbing, daemonization"""
-    if getattr(gconf, 'pid_file', None) and kw.get('go_daemon') != 'postconn':
-        if not grabpidfile():
-            sys.stderr.write("pidfile is taken, exiting.\n")
-            sys.exit(2)
-        gconf.pid_file_owned = True
-
-    if kw.get('go_daemon') == 'should':
-        x, y = os.pipe()
-        gconf.cpid = os.fork()
-        if gconf.cpid:
-            os.close(x)
-            sys.exit()
-        os.close(y)
-        os.setsid()
-        dn = os.open(os.devnull, os.O_RDWR)
-        for f in (sys.stdin, sys.stdout, sys.stderr):
-            os.dup2(dn, f.fileno())
-        if getattr(gconf, 'pid_file', None):
-            if not grabpidfile(gconf.pid_file + '.tmp'):
-                raise GsyncdError("cannot grab temporary pidfile")
-            os.rename(gconf.pid_file + '.tmp', gconf.pid_file)
-        # wait for parent to terminate
-        # so we can start up with
-        # no messing from the dirty
-        # ol' bustard
-        select((x,), (), ())
-        os.close(x)
-
-    GLogger._gsyncd_loginit(**kw)
-
-
-def _unlink(path):
-    try:
-        os.unlink(path)
-    except (OSError, IOError):
-        if sys.exc_info()[1].errno == ENOENT:
-            pass
-        else:
-            raise GsyncdError('Unlink error: %s' % path)
+from logutils import setup_logging
+import gsyncdconfig as gconf
+from rconf import rconf
+import subcmds
+from conf import GLUSTERD_WORKDIR, GLUSTERFS_CONFDIR, GCONF_VERSION
+from syncdutils import (set_term_handler, finalize, lf,
+                        log_raise_exception, FreeObject, escape)
+import argsupgrade
+
+
+GSYNCD_VERSION = "gsyncd.py %s.0" % GCONF_VERSION
 
 
 def main():
-    """main routine, signal/exception handling boilerplates"""
-    gconf.starttime = time.time()
+    rconf.starttime = time.time()
+
+    # If old Glusterd sends commands in old format, below function
+    # converts the sys.argv to new format. This conversion is added
+    # temporarily for backward compatibility. This can be removed
+    # once integrated with Glusterd2
+    # This modifies sys.argv globally, so rest of the code works as usual
+    argsupgrade.upgrade()
+
+    # Default argparse version handler prints to stderr, which is fixed in
+    # 3.x series but not in 2.x, using custom parser to fix this issue
+    if "--version" in sys.argv:
+        print(GSYNCD_VERSION)
+        sys.exit(0)
+
+    parser = ArgumentParser()
+    parser.add_argument("--inet6", action="store_true")
+    sp = parser.add_subparsers(dest="subcmd")
+
+    # Monitor Status File update
+    p = sp.add_parser("monitor-status")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave details user@host::vol format")
+    p.add_argument("status", help="Update Monitor Status")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+
+    # Monitor
+    p = sp.add_parser("monitor")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave details user@host::vol format")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--pause-on-start",
+                   action="store_true",
+                   help="Start with Paused state")
+    p.add_argument("--local-node-id", help="Local Node ID")
+    p.add_argument("--debug", action="store_true")
+    p.add_argument("--use-gconf-volinfo", action="store_true")
+
+    # Worker
+    p = sp.add_parser("worker")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave details user@host::vol format")
+    p.add_argument("--local-path", help="Local Brick Path")
+    p.add_argument("--feedback-fd", type=int,
+                   help="feedback fd between monitor and worker")
+    p.add_argument("--local-node", help="Local master node")
+    p.add_argument("--local-node-id", help="Local Node ID")
+    p.add_argument("--subvol-num", type=int, help="Subvolume number")
+    p.add_argument("--is-hottier", action="store_true",
+                   help="Is this brick part of hot tier")
+    p.add_argument("--resource-remote",
+                   help="Remote node to connect to Slave Volume")
+    p.add_argument("--resource-remote-id",
+                   help="Remote node ID to connect to Slave Volume")
+    p.add_argument("--slave-id", help="Slave Volume ID")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+
+    # Slave
+    p = sp.add_parser("slave")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave details user@host::vol format")
+    p.add_argument("--session-owner")
+    p.add_argument("--master-brick",
+                   help="Master brick which is connected to the Slave")
+    p.add_argument("--master-node",
+                   help="Master node which is connected to the Slave")
+    p.add_argument("--master-node-id",
+                   help="Master node ID which is connected to the Slave")
+    p.add_argument("--local-node", help="Local Slave node")
+    p.add_argument("--local-node-id", help="Local Slave ID")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+
+    # All configurations which are configured via "slave-" options
+    # DO NOT add default values for these configurations, default values
+    # will be picked from template config file
+    p.add_argument("--slave-timeout", type=int,
+                   help="Timeout to end gsyncd at Slave side")
+    p.add_argument("--use-rsync-xattrs", action="store_true")
+    p.add_argument("--slave-log-level", help="Slave Gsyncd Log level")
+    p.add_argument("--slave-gluster-log-level",
+                   help="Slave Gluster mount Log level")
+    p.add_argument("--slave-gluster-command-dir",
+                   help="Directory where Gluster binaries exist on slave")
+    p.add_argument("--slave-access-mount", action="store_true",
+                   help="Do not lazy umount the slave volume")
+    p.add_argument("--master-dist-count", type=int,
+                   help="Master Distribution count")
+
+    # Status
+    p = sp.add_parser("status")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--local-path", help="Local Brick Path")
+    p.add_argument("--debug", action="store_true")
+    p.add_argument("--json", action="store_true")
+
+    # Config-check
+    p = sp.add_parser("config-check")
+    p.add_argument("name", help="Config Name")
+    p.add_argument("--value", help="Config Value")
+    p.add_argument("--debug", action="store_true")
+
+    # Config-get
+    p = sp.add_parser("config-get")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave")
+    p.add_argument("--name", help="Config Name")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+    p.add_argument("--show-defaults", action="store_true")
+    p.add_argument("--only-value", action="store_true")
+    p.add_argument("--use-underscore", action="store_true")
+    p.add_argument("--json", action="store_true")
+
+    # Config-set
+    p = sp.add_parser("config-set")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave")
+    p.add_argument("-n", "--name", help="Config Name")
+    p.add_argument("-v", "--value", help="Config Value")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+
+    # Config-reset
+    p = sp.add_parser("config-reset")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave")
+    p.add_argument("name", help="Config Name")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument("--debug", action="store_true")
+
+    # voluuidget
+    p = sp.add_parser("voluuidget")
+    p.add_argument("host", help="Hostname")
+    p.add_argument("volname", help="Volume Name")
+    p.add_argument("--debug", action="store_true")
+
+    # Delete
+    p = sp.add_parser("delete")
+    p.add_argument("master", help="Master Volume Name")
+    p.add_argument("slave", help="Slave")
+    p.add_argument("-c", "--config-file", help="Config File")
+    p.add_argument('--path', dest='paths', action="append")
+    p.add_argument("--reset-sync-time", action="store_true",
+                   help="Reset Sync Time")
+    p.add_argument("--debug", action="store_true")
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Extra template values, All arguments are already part of template
+    # variables, use this for adding extra variables
+    extra_tmpl_args = {}
+
+    # Add First/Primary Slave host, user and volume
+    if getattr(args, "slave", None) is not None:
+        hostdata, slavevol = args.slave.split("::")
+        hostdata = hostdata.split("@")
+        slavehost = hostdata[-1]
+        slaveuser = "root"
+        if len(hostdata) == 2:
+            slaveuser = hostdata[0]
+        extra_tmpl_args["primary_slave_host"] = slavehost
+        extra_tmpl_args["slaveuser"] = slaveuser
+        extra_tmpl_args["slavevol"] = slavevol
+
+    # Add Bricks encoded path
+    if getattr(args, "local_path", None) is not None:
+        extra_tmpl_args["local_id"] = escape(args.local_path)
+
+    # Add Master Bricks encoded path(For Slave)
+    if getattr(args, "master_brick", None) is not None:
+        extra_tmpl_args["master_brick_id"] = escape(args.master_brick)
+
+    # Load configurations
+    config_file = getattr(args, "config_file", None)
+
+    # Subcmd accepts config file argument but not passed
+    # Set default path for config file in that case
+    # If an subcmd accepts config file then it also accepts
+    # master and Slave arguments.
+    if config_file is None and hasattr(args, "config_file") \
+        and args.subcmd != "slave":
+        config_file = "%s/geo-replication/%s_%s_%s/gsyncd.conf" % (
+            GLUSTERD_WORKDIR,
+            args.master,
+            extra_tmpl_args["primary_slave_host"],
+            extra_tmpl_args["slavevol"])
+
+    # If Config file path not exists, log error and continue using default conf
+    config_file_error_msg = None
+    if config_file is not None and not os.path.exists(config_file):
+        # Logging not yet initialized, create the error message to
+        # log later and reset the config_file to None
+        config_file_error_msg = lf(
+            "Session config file not exists, using the default config",
+            path=config_file)
+        config_file = None
+
+    rconf.config_file = config_file
+
+    # Override gconf values from argument values only if it is slave gsyncd
+    override_from_args = False
+    if args.subcmd == "slave":
+        override_from_args = True
+
+    if config_file is not None and \
+       args.subcmd in ["monitor", "config-get", "config-set", "config-reset"]:
+        ret = gconf.is_config_file_old(config_file, args.master, extra_tmpl_args["slavevol"])
+        if ret is not None:
+           gconf.config_upgrade(config_file, ret)
+
+    # Load Config file
+    gconf.load(GLUSTERFS_CONFDIR + "/gsyncd.conf",
+               config_file,
+               vars(args),
+               extra_tmpl_args,
+               override_from_args)
+
+    # Default label to print in log file
+    label = args.subcmd
+    if args.subcmd in ("worker"):
+        # If Worker, then add brick path also to label
+        label = "%s %s" % (args.subcmd, args.local_path)
+    elif args.subcmd == "slave":
+        # If Slave add Master node and Brick details
+        label = "%s %s%s" % (args.subcmd, args.master_node, args.master_brick)
+
+    # Setup Logger
+    # Default log file
+    log_file = gconf.get("cli-log-file")
+    log_level = gconf.get("cli-log-level")
+    if getattr(args, "master", None) is not None and \
+       getattr(args, "slave", None) is not None:
+        log_file = gconf.get("log-file")
+        log_level = gconf.get("log-level")
+
+    # Use different log file location for Slave log file
+    if args.subcmd == "slave":
+        log_file = gconf.get("slave-log-file")
+        log_level = gconf.get("slave-log-level")
+
+    if args.debug:
+        log_file = "-"
+        log_level = "DEBUG"
+
+    # Create Logdir if not exists
+    try:
+        if log_file != "-":
+            os.mkdir(os.path.dirname(log_file))
+    except OSError as e:
+        if e.errno != EEXIST:
+            raise
+
+    setup_logging(
+        log_file=log_file,
+        level=log_level,
+        label=label
+    )
+
+    if config_file_error_msg is not None:
+        logging.warn(config_file_error_msg)
+
+    # Log message for loaded config file
+    if config_file is not None:
+        logging.debug(lf("Using session config file", path=config_file))
+
     set_term_handler()
-    GLogger.setup()
     excont = FreeObject(exval=0)
+
+    # Gets the function name based on the input argument. For example
+    # if subcommand passed as argument is monitor then it looks for
+    # function with name "subcmd_monitor" in subcmds file
+    func = getattr(subcmds, "subcmd_" + args.subcmd.replace("-", "_"), None)
+
     try:
         try:
-            main_i()
+            if func is not None:
+                rconf.args = args
+                func(args)
         except:
             log_raise_exception(excont)
     finally:
         finalize(exval=excont.exval)
 
 
-def main_i():
-    """internal main routine
-
-    parse command line, decide what action will be taken;
-    we can either:
-    - query/manipulate configuration
-    - format gsyncd urls using gsyncd's url parsing engine
-    - start service in following modes, in given stages:
-      - agent: startup(), ChangelogAgent()
-      - monitor: startup(), monitor()
-      - master: startup(), connect_remote(), connect(), service_loop()
-      - slave: startup(), connect(), service_loop()
-    """
-    rconf = {'go_daemon': 'should'}
-
-    def store_abs(opt, optstr, val, parser):
-        if val and val != '-':
-            val = os.path.abspath(val)
-        setattr(parser.values, opt.dest, val)
-
-    def store_local(opt, optstr, val, parser):
-        rconf[opt.dest] = val
-
-    def store_local_curry(val):
-        return lambda o, oo, vx, p: store_local(o, oo, val, p)
-
-    def store_local_obj(op, dmake):
-        return lambda o, oo, vx, p: store_local(
-            o, oo, FreeObject(op=op, **dmake(vx)), p)
-
-    op = OptionParser(
-        usage="%prog [options...] <master> <slave>", version="%prog 0.0.1")
-    op.add_option('--gluster-command-dir', metavar='DIR', default='')
-    op.add_option('--gluster-log-file', metavar='LOGF',
-                  default=os.devnull, type=str, action='callback',
-                  callback=store_abs)
-    op.add_option('--gluster-log-level', metavar='LVL')
-    op.add_option('--changelog-log-level', metavar='LVL', default="INFO")
-    op.add_option('--gluster-params', metavar='PRMS', default='')
-    op.add_option(
-        '--glusterd-uuid', metavar='UUID', type=str, default='',
-        help=SUPPRESS_HELP)
-    op.add_option(
-        '--gluster-cli-options', metavar='OPTS', default='--log-file=-')
-    op.add_option('--mountbroker', metavar='LABEL')
-    op.add_option('-p', '--pid-file', metavar='PIDF', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('-l', '--log-file', metavar='LOGF', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--iprefix', metavar='LOGD', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--changelog-log-file', metavar='LOGF', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--log-file-mbr', metavar='LOGF', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--state-file', metavar='STATF', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--state-detail-file', metavar='STATF',
-                  type=str, action='callback', callback=store_abs)
-    op.add_option('--georep-session-working-dir', metavar='STATF',
-                  type=str, action='callback', callback=store_abs)
-    op.add_option('--access-mount', default=False, action='store_true')
-    op.add_option('--ignore-deletes', default=False, action='store_true')
-    op.add_option('--isolated-slave', default=False, action='store_true')
-    op.add_option('--use-rsync-xattrs', default=False, action='store_true')
-    op.add_option('--sync-xattrs', default=True, action='store_true')
-    op.add_option('--sync-acls', default=True, action='store_true')
-    op.add_option('--log-rsync-performance', default=False,
-                  action='store_true')
-    op.add_option('--max-rsync-retries', type=int, default=10)
-    # Max size of Changelogs to process per batch, Changelogs Processing is
-    # not limited by the number of changelogs but instead based on
-    # size of the changelog file, One sample changelog file size was 145408
-    # with ~1000 CREATE and ~1000 DATA. 5 such files in one batch is 727040
-    # If geo-rep worker crashes while processing a batch, it has to retry only
-    # that batch since stime will get updated after each batch.
-    op.add_option('--changelog-batch-size', type=int, default=727040)
-    op.add_option('--pause-on-start', default=False, action='store_true')
-    op.add_option('-L', '--log-level', metavar='LVL')
-    op.add_option('-r', '--remote-gsyncd', metavar='CMD',
-                  default=os.path.abspath(sys.argv[0]))
-    op.add_option('--volume-id', metavar='UUID')
-    op.add_option('--slave-id', metavar='ID')
-    op.add_option('--session-owner', metavar='ID')
-    op.add_option('--local-id', metavar='ID', help=SUPPRESS_HELP, default='')
-    op.add_option(
-        '--local-node', metavar='NODE', help=SUPPRESS_HELP, default='')
-    op.add_option(
-        '--local-node-id', metavar='NODEID', help=SUPPRESS_HELP, default='')
-    op.add_option(
-        '--local-path', metavar='PATH', help=SUPPRESS_HELP, default='')
-    op.add_option('-s', '--ssh-command', metavar='CMD', default='ssh')
-    op.add_option('--ssh-port', metavar='PORT', type=int, default=22)
-    op.add_option('--ssh-command-tar', metavar='CMD', default='ssh')
-    op.add_option('--rsync-command', metavar='CMD', default='rsync')
-    op.add_option('--rsync-options', metavar='OPTS', default='')
-    op.add_option('--rsync-ssh-options', metavar='OPTS', default='--compress')
-    op.add_option('--rsync-opt-ignore-missing-args', default="true")
-    op.add_option('--rsync-opt-existing', default="true")
-    op.add_option('--timeout', metavar='SEC', type=int, default=120)
-    op.add_option('--connection-timeout', metavar='SEC',
-                  type=int, default=60, help=SUPPRESS_HELP)
-    op.add_option('--sync-jobs', metavar='N', type=int, default=3)
-    op.add_option('--replica-failover-interval', metavar='N',
-                  type=int, default=1)
-    op.add_option('--changelog-archive-format', metavar='N',
-                  type=str, default="%Y%m")
-    op.add_option('--use-meta-volume', default=False, action='store_true')
-    op.add_option('--meta-volume-mnt', metavar='N',
-                  type=str, default="/var/run/gluster/shared_storage")
-    op.add_option(
-        '--turns', metavar='N', type=int, default=0, help=SUPPRESS_HELP)
-    op.add_option('--allow-network', metavar='IPS', default='')
-    op.add_option('--socketdir', metavar='DIR')
-    op.add_option('--state-socket-unencoded', metavar='SOCKF',
-                  type=str, action='callback', callback=store_abs)
-    op.add_option('--checkpoint', metavar='LABEL', default='0')
-
-    # tunables for failover/failback mechanism:
-    # None   - gsyncd behaves as normal
-    # blind  - gsyncd works with xtime pairs to identify
-    #          candidates for synchronization
-    # wrapup - same as normal mode but does not assign
-    #          xtimes to orphaned files
-    # see crawl() for usage of the above tunables
-    op.add_option('--special-sync-mode', type=str, help=SUPPRESS_HELP)
-
-    # changelog or xtime? (TODO: Change the default)
-    op.add_option(
-        '--change-detector', metavar='MODE', type=str, default='xtime')
-    # sleep interval for change detection (xtime crawl uses a hardcoded 1
-    # second sleep time)
-    op.add_option('--change-interval', metavar='SEC', type=int, default=3)
-    # working directory for changelog based mechanism
-    op.add_option('--working-dir', metavar='DIR', type=str,
-                  action='callback', callback=store_abs)
-    op.add_option('--use-tarssh', default=False, action='store_true')
-
-    op.add_option('-c', '--config-file', metavar='CONF',
-                  type=str, action='callback', callback=store_local)
-    # duh. need to specify dest or value will be mapped to None :S
-    op.add_option('--monitor', dest='monitor', action='callback',
-                  callback=store_local_curry(True))
-    op.add_option('--agent', dest='agent', action='callback',
-                  callback=store_local_curry(True))
-    op.add_option('--resource-local', dest='resource_local',
-                  type=str, action='callback', callback=store_local)
-    op.add_option('--resource-remote', dest='resource_remote',
-                  type=str, action='callback', callback=store_local)
-    op.add_option('--feedback-fd', dest='feedback_fd', type=int,
-                  help=SUPPRESS_HELP, action='callback', callback=store_local)
-    op.add_option('--rpc-fd', dest='rpc_fd', type=str, help=SUPPRESS_HELP)
-    op.add_option('--subvol-num', dest='subvol_num', type=str,
-                  help=SUPPRESS_HELP)
-    op.add_option('--listen', dest='listen', help=SUPPRESS_HELP,
-                  action='callback', callback=store_local_curry(True))
-    op.add_option('-N', '--no-daemon', dest="go_daemon",
-                  action='callback', callback=store_local_curry('dont'))
-    op.add_option('--verify', type=str, dest="verify",
-                  action='callback', callback=store_local)
-    op.add_option('--slavevoluuid-get', type=str, dest="slavevoluuid_get",
-                  action='callback', callback=store_local)
-    op.add_option('--create', type=str, dest="create",
-                  action='callback', callback=store_local)
-    op.add_option('--delete', dest='delete', action='callback',
-                  callback=store_local_curry(True))
-    op.add_option('--path-list', dest='path_list', action='callback',
-                  type=str, callback=store_local)
-    op.add_option('--reset-sync-time', default=False, action='store_true')
-    op.add_option('--status-get', dest='status_get', action='callback',
-                  callback=store_local_curry(True))
-    op.add_option('--debug', dest="go_daemon", action='callback',
-                  callback=lambda *a: (store_local_curry('dont')(*a),
-                                       setattr(
-                                           a[-1].values, 'log_file', '-'),
-                                       setattr(a[-1].values, 'log_level',
-                                               'DEBUG'),
-                                       setattr(a[-1].values,
-                                               'changelog_log_file', '-')))
-    op.add_option('--path', type=str, action='append')
-
-    for a in ('check', 'get'):
-        op.add_option('--config-' + a, metavar='OPT', type=str, dest='config',
-                      action='callback',
-                      callback=store_local_obj(a, lambda vx: {'opt': vx}))
-    op.add_option('--config-get-all', dest='config', action='callback',
-                  callback=store_local_obj('get', lambda vx: {'opt': None}))
-    for m in ('', '-rx', '-glob'):
-        # call this code 'Pythonic' eh?
-        # have to define a one-shot local function to be able
-        # to inject (a value depending on the)
-        # iteration variable into the inner lambda
-        def conf_mod_opt_regex_variant(rx):
-            op.add_option('--config-set' + m, metavar='OPT VAL', type=str,
-                          nargs=2, dest='config', action='callback',
-                          callback=store_local_obj('set', lambda vx: {
-                              'opt': vx[0], 'val': vx[1], 'rx': rx}))
-            op.add_option('--config-del' + m, metavar='OPT', type=str,
-                          dest='config', action='callback',
-                          callback=store_local_obj('del', lambda vx: {
-                              'opt': vx, 'rx': rx}))
-        conf_mod_opt_regex_variant(m and m[1:] or False)
-
-    op.add_option('--normalize-url', dest='url_print',
-                  action='callback', callback=store_local_curry('normal'))
-    op.add_option('--canonicalize-url', dest='url_print',
-                  action='callback', callback=store_local_curry('canon'))
-    op.add_option('--canonicalize-escape-url', dest='url_print',
-                  action='callback', callback=store_local_curry('canon_esc'))
-    op.add_option('--is-hottier', default=False, action='store_true')
-
-    tunables = [norm(o.get_opt_string()[2:])
-                for o in op.option_list
-                if (o.callback in (store_abs, 'store_true', None) and
-                    o.get_opt_string() not in ('--version', '--help'))]
-    remote_tunables = ['listen', 'go_daemon', 'timeout',
-                       'session_owner', 'config_file', 'use_rsync_xattrs',
-                       'local_id', 'local_node', 'access_mount']
-    rq_remote_tunables = {'listen': True}
-
-    # precedence for sources of values: 1) commandline, 2) cfg file, 3)
-    # defaults for this to work out we need to tell apart defaults from
-    # explicitly set options... so churn out the defaults here and call
-    # the parser with virgin values container.
-    defaults = op.get_default_values()
-    opts, args = op.parse_args(values=optparse.Values())
-    # slave url cleanup, if input comes with vol uuid as follows
-    # 'ssh://fvm1::gv2:07dfddca-94bb-4841-a051-a7e582811467'
-    temp_args = []
-    for arg in args:
-        # Split based on ::
-        data = arg.split("::")
-        if len(data)>1:
-            slavevol_name = data[1].split(":")[0]
-            temp_args.append("%s::%s" % (data[0], slavevol_name))
-        else:
-            temp_args.append(data[0])
-    args = temp_args
-    args_orig = args[:]
-
-    voluuid_get = rconf.get('slavevoluuid_get')
-    if voluuid_get:
-        slave_host, slave_vol = voluuid_get.split("::")
-        svol_uuid = slave_vol_uuid_get(slave_host, slave_vol)
-        print svol_uuid
-        return
-
-    r = rconf.get('resource_local')
-    if r:
-        if len(args) == 0:
-            args.append(None)
-        args[0] = r
-    r = rconf.get('resource_remote')
-    if r:
-        if len(args) == 0:
-            raise GsyncdError('local resource unspecfied')
-        elif len(args) == 1:
-            args.append(None)
-        args[1] = r
-    confdata = rconf.get('config')
-    if not (len(args) == 2 or
-            (len(args) == 1 and rconf.get('listen')) or
-            (len(args) <= 2 and confdata) or
-            rconf.get('url_print')):
-        sys.stderr.write("error: incorrect number of arguments\n\n")
-        sys.stderr.write(op.get_usage() + "\n")
-        sys.exit(1)
-
-    verify = rconf.get('verify')
-    if verify:
-        logging.info(verify)
-        logging.info("Able to spawn gsyncd.py")
-        return
-
-    restricted = os.getenv('_GSYNCD_RESTRICTED_')
-
-    if restricted:
-        allopts = {}
-        allopts.update(opts.__dict__)
-        allopts.update(rconf)
-        bannedtuns = set(allopts.keys()) - set(remote_tunables)
-        if bannedtuns:
-            raise GsyncdError('following tunables cannot be set with '
-                              'restricted SSH invocaton: ' +
-                              ', '.join(bannedtuns))
-        for k, v in rq_remote_tunables.items():
-            if not k in allopts or allopts[k] != v:
-                raise GsyncdError('tunable %s is not set to value %s required '
-                                  'for restricted SSH invocaton' %
-                                  (k, v))
-
-    confrx = getattr(confdata, 'rx', None)
-
-    def makersc(aa, check=True):
-        if not aa:
-            return ([], None, None)
-        ra = [resource.parse_url(u) for u in aa]
-        local = ra[0]
-        remote = None
-        if len(ra) > 1:
-            remote = ra[1]
-        if check and not local.can_connect_to(remote):
-            raise GsyncdError("%s cannot work with %s" %
-                              (local.path, remote and remote.path))
-        return (ra, local, remote)
-    if confrx:
-        # peers are regexen, don't try to parse them
-        if confrx == 'glob':
-            args = ['\A' + fnmatch.translate(a) for a in args]
-        canon_peers = args
-        namedict = {}
-    else:
-        dc = rconf.get('url_print')
-        rscs, local, remote = makersc(args_orig, not dc)
-        if dc:
-            for r in rscs:
-                print(r.get_url(**{'normal': {},
-                                   'canon': {'canonical': True},
-                                   'canon_esc': {'canonical': True,
-                                                 'escaped': True}}[dc]))
-            return
-        pa = ([], [], [])
-        urlprms = (
-            {}, {'canonical': True}, {'canonical': True, 'escaped': True})
-        for x in rscs:
-            for i in range(len(pa)):
-                pa[i].append(x.get_url(**urlprms[i]))
-        _, canon_peers, canon_esc_peers = pa
-        # creating the namedict, a dict representing various ways of referring
-        # to / repreenting peers to be fillable in config templates
-        mods = (lambda x: x, lambda x: x[
-                0].upper() + x[1:], lambda x: 'e' + x[0].upper() + x[1:])
-        if remote:
-            rmap = {local: ('local', 'master'), remote: ('remote', 'slave')}
-        else:
-            rmap = {local: ('local', 'slave')}
-        namedict = {}
-        for i in range(len(rscs)):
-            x = rscs[i]
-            for name in rmap[x]:
-                for j in range(3):
-                    namedict[mods[j](name)] = pa[j][i]
-                namedict[name + 'vol'] = x.volume
-                if name == 'remote':
-                    namedict['remotehost'] = x.remotehost
-
-    if not 'config_file' in rconf:
-        rconf['config_file'] = TMPL_CONFIG_FILE
-
-    # Upgrade Config File only if it is session conf file
-    if rconf['config_file'] != TMPL_CONFIG_FILE:
-        upgrade_config_file(rconf['config_file'], confdata)
-
-    gcnf = GConffile(
-        rconf['config_file'], canon_peers, confdata,
-        defaults.__dict__, opts.__dict__, namedict)
-
-    conf_change = False
-    if confdata:
-        opt_ok = norm(confdata.opt) in tunables + [None]
-        if confdata.op == 'check':
-            if opt_ok:
-                sys.exit(0)
-            else:
-                sys.exit(1)
-        elif not opt_ok:
-            raise GsyncdError("not a valid option: " + confdata.opt)
-        if confdata.op == 'get':
-            gcnf.get(confdata.opt)
-        elif confdata.op == 'set':
-            gcnf.set(confdata.opt, confdata.val, confdata.rx)
-        elif confdata.op == 'del':
-            gcnf.delete(confdata.opt, confdata.rx)
-        # when modifying checkpoint, it's important to make a log
-        # of that, so in that case we go on to set up logging even
-        # if its just config invocation
-        if confdata.op in ('set', 'del') and not confdata.rx:
-            conf_change = True
-
-        if not conf_change:
-            return
-
-    gconf.__dict__.update(defaults.__dict__)
-    gcnf.update_to(gconf.__dict__)
-    gconf.__dict__.update(opts.__dict__)
-    gconf.configinterface = gcnf
-
-    delete = rconf.get('delete')
-    if delete:
-        logging.info('geo-replication delete')
-        # remove the stime xattr from all the brick paths so that
-        # a re-create of a session will start sync all over again
-        stime_xattr_name = getattr(gconf, 'master.stime_xattr_name', None)
-
-        # Delete pid file, status file, socket file
-        cleanup_paths = []
-        if getattr(gconf, 'pid_file', None):
-            cleanup_paths.append(gconf.pid_file)
-
-        if getattr(gconf, 'state_file', None):
-            cleanup_paths.append(gconf.state_file)
-
-        if getattr(gconf, 'state_detail_file', None):
-            cleanup_paths.append(gconf.state_detail_file)
-
-        if getattr(gconf, 'state_socket_unencoded', None):
-            cleanup_paths.append(gconf.state_socket_unencoded)
-
-        cleanup_paths.append(rconf['config_file'][:-11] + "*")
-
-        # Cleanup changelog working dirs
-        if getattr(gconf, 'working_dir', None):
-            try:
-                shutil.rmtree(gconf.working_dir)
-            except (IOError, OSError):
-                if sys.exc_info()[1].errno == ENOENT:
-                    pass
-                else:
-                    raise GsyncdError(
-                        'Error while removing working dir: %s' %
-                        gconf.working_dir)
-
-        for path in cleanup_paths:
-            # To delete temp files
-            for f in glob.glob(path + "*"):
-                _unlink(f)
-
-        reset_sync_time = boolify(gconf.reset_sync_time)
-        if reset_sync_time and stime_xattr_name:
-            path_list = rconf.get('path_list')
-            paths = []
-            for p in path_list.split('--path='):
-                stripped_path = p.strip()
-                if stripped_path != "":
-                    # set stime to (0,0) to trigger full volume content resync
-                    # to slave on session recreation
-                    # look at master.py::Xcrawl   hint: zero_zero
-                    Xattr.lsetxattr(stripped_path, stime_xattr_name,
-                                    struct.pack("!II", 0, 0))
-
-        return
-
-    if restricted and gconf.allow_network:
-        ssh_conn = os.getenv('SSH_CONNECTION')
-        if not ssh_conn:
-            # legacy env var
-            ssh_conn = os.getenv('SSH_CLIENT')
-        if ssh_conn:
-            allowed_networks = [IPNetwork(a)
-                                for a in gconf.allow_network.split(',')]
-            client_ip = IPAddress(ssh_conn.split()[0])
-            allowed = False
-            for nw in allowed_networks:
-                if client_ip in nw:
-                    allowed = True
-                    break
-            if not allowed:
-                raise GsyncdError("client IP address is not allowed")
-
-    ffd = rconf.get('feedback_fd')
-    if ffd:
-        fcntl.fcntl(ffd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
-
-    # normalize loglevel
-    lvl0 = gconf.log_level
-    if isinstance(lvl0, str):
-        lvl1 = lvl0.upper()
-        lvl2 = logging.getLevelName(lvl1)
-        # I have _never_ _ever_ seen such an utterly braindead
-        # error condition
-        if lvl2 == "Level " + lvl1:
-            raise GsyncdError('cannot recognize log level "%s"' % lvl0)
-        gconf.log_level = lvl2
-
-    if not privileged() and gconf.log_file_mbr:
-        gconf.log_file = gconf.log_file_mbr
-
-    if conf_change:
-        try:
-            GLogger._gsyncd_loginit(log_file=gconf.log_file, label='conf')
-            gconf.log_exit = False
-
-            if confdata.op == 'set':
-                if confdata.opt == 'checkpoint':
-                    logging.info(lf("Checkpoint Set",
-                                    time=human_time_utc(confdata.val)))
-                else:
-                    logging.info(lf("Config Set",
-                                    config=confdata.opt,
-                                    value=confdata.val))
-            elif confdata.op == 'del':
-                if confdata.opt == 'checkpoint':
-                    logging.info("Checkpoint Reset")
-                else:
-                    logging.info(lf("Config Reset",
-                                    config=confdata.opt))
-        except IOError:
-            if sys.exc_info()[1].errno == ENOENT:
-                # directory of log path is not present,
-                # which happens if we get here from
-                # a peer-multiplexed "config-set checkpoint"
-                # (as that directory is created only on the
-                # original node)
-                pass
-            else:
-                raise
-        return
-
-    create = rconf.get('create')
-    if create:
-        if getattr(gconf, 'state_file', None):
-            set_monitor_status(gconf.state_file, create)
-
-        try:
-            GLogger._gsyncd_loginit(log_file=gconf.log_file, label='monitor')
-            gconf.log_exit = False
-            logging.info(lf("Monitor Status Change",
-                            status=create))
-        except IOError:
-            if sys.exc_info()[1].errno == ENOENT:
-                # If log dir not present
-                pass
-            else:
-                raise
-        return
-
-    go_daemon = rconf['go_daemon']
-    be_monitor = rconf.get('monitor')
-    be_agent = rconf.get('agent')
-
-    rscs, local, remote = makersc(args)
-
-    status_get = rconf.get('status_get')
-    if status_get:
-        master_name, slave_data = get_master_and_slave_data_from_args(args)
-        for brick in gconf.path:
-            brick_status = GeorepStatus(gconf.state_file,
-                                        gconf.local_node,
-                                        brick,
-                                        gconf.local_node_id,
-                                        master_name,
-                                        slave_data,
-                                        getattr(gconf, "pid_file", None))
-            checkpoint_time = int(getattr(gconf, "checkpoint", "0"))
-            brick_status.print_status(checkpoint_time=checkpoint_time)
-        return
-
-    if not be_monitor and isinstance(remote, resource.SSH) and \
-       go_daemon == 'should':
-        go_daemon = 'postconn'
-        log_file = None
-    else:
-        log_file = gconf.log_file
-    if be_monitor:
-        label = 'monitor'
-    elif be_agent:
-        label = gconf.local_path
-    elif remote:
-        # master
-        label = gconf.local_path
-    else:
-        label = 'slave'
-    startup(go_daemon=go_daemon, log_file=log_file, label=label)
-    resource.Popen.init_errhandler()
-
-    if be_agent:
-        os.setsid()
-        logging.debug(lf("RPC FD",
-                         rpc_fd=repr(gconf.rpc_fd)))
-        return agent(Changelog(), gconf.rpc_fd)
-
-    if be_monitor:
-        return monitor(*rscs)
-
-    if remote:
-        go_daemon = remote.connect_remote(go_daemon=go_daemon)
-        if go_daemon:
-            startup(go_daemon=go_daemon, log_file=gconf.log_file)
-            # complete remote connection in child
-            remote.connect_remote(go_daemon='done')
-    local.connect()
-    if ffd:
-        logging.info("Closing feedback fd, waking up the monitor")
-        os.close(ffd)
-    local.service_loop(*[r for r in [remote] if r])
-
-
 if __name__ == "__main__":
     main()
diff --git a/geo-replication/syncdaemon/gsyncdconfig.py b/geo-replication/syncdaemon/gsyncdconfig.py
new file mode 100644
index 00000000000..8848071997a
--- /dev/null
+++ b/geo-replication/syncdaemon/gsyncdconfig.py
@@ -0,0 +1,485 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+#
+
+try:
+    from ConfigParser import RawConfigParser, NoSectionError
+except ImportError:
+    from configparser import RawConfigParser, NoSectionError
+import os
+import shutil
+from string import Template
+from datetime import datetime
+from threading import Lock
+
+
+# Global object which can be used in other modules
+# once load_config is called
+_gconf = {}
+
+
+class GconfNotConfigurable(Exception):
+    pass
+
+
+class GconfInvalidValue(Exception):
+    pass
+
+
+class Gconf(object):
+    def __init__(self, default_conf_file, custom_conf_file=None,
+                 args={}, extra_tmpl_args={}, override_from_args=False):
+        self.lock = Lock()
+        self.default_conf_file = default_conf_file
+        self.custom_conf_file = custom_conf_file
+        self.tmp_conf_file = None
+        self.gconf = {}
+        self.gconfdata = {}
+        self.gconf_typecast = {}
+        self.template_conf = []
+        self.non_configurable_configs = []
+        self.prev_mtime = 0
+        if custom_conf_file is not None:
+            self.tmp_conf_file = custom_conf_file + ".tmp"
+
+        self.session_conf_items = []
+        self.args = args
+        self.extra_tmpl_args = extra_tmpl_args
+        self.override_from_args = override_from_args
+        # Store default values only if overwritten, Only for JSON/CLI output
+        self.default_values = {}
+        self._load()
+
+    def _tmpl_substitute(self):
+        tmpl_values = {}
+        for k, v in self.gconf.items():
+            tmpl_values[k.replace("-", "_")] = v
+
+        # override the config file values with the one user passed
+        for k, v in self.args.items():
+            # override the existing value only if set by user
+            if v is not None:
+                tmpl_values[k] = v
+
+        for k, v in self.extra_tmpl_args.items():
+            tmpl_values[k] = v
+
+        for k, v in self.gconf.items():
+            if k in self.template_conf and \
+               (isinstance(v, str) or isinstance(v, unicode)):
+                self.gconf[k] = Template(v).safe_substitute(tmpl_values)
+
+    def _do_typecast(self):
+        for k, v in self.gconf.items():
+            cast_func = globals().get(
+                "to_" + self.gconf_typecast.get(k, "string"), None)
+            if cast_func is not None:
+                self.gconf[k] = cast_func(v)
+                if self.default_values.get(k, None) is not None:
+                    self.default_values[k] = cast_func(v)
+
+    def reset(self, name):
+        # If custom conf file is not set then it is only read only configs
+        if self.custom_conf_file is None:
+            raise GconfNotConfigurable()
+
+        # If a config can not be modified
+        if name != "all" and not self._is_configurable(name):
+            raise GconfNotConfigurable()
+
+        cnf = RawConfigParser()
+        with open(self.custom_conf_file) as f:
+            cnf.readfp(f)
+
+            # Nothing to Reset, Not configured
+            if name != "all":
+                if not cnf.has_option("vars", name):
+                    return True
+
+                # Remove option from custom conf file
+                cnf.remove_option("vars", name)
+            else:
+                # Remove and add empty section, do not disturb if config file
+                # already has any other section
+                try:
+                    cnf.remove_section("vars")
+                except NoSectionError:
+                    pass
+
+                cnf.add_section("vars")
+
+        with open(self.tmp_conf_file, "w") as fw:
+            cnf.write(fw)
+
+        os.rename(self.tmp_conf_file, self.custom_conf_file)
+
+        self.reload()
+
+        return True
+
+    def set(self, name, value):
+        if self.custom_conf_file is None:
+            raise GconfNotConfigurable()
+
+        if not self._is_configurable(name):
+            raise GconfNotConfigurable()
+
+        if not self._is_valid_value(name, value):
+            raise GconfInvalidValue()
+
+        curr_val = self.gconf.get(name, None)
+        if curr_val == value:
+            return True
+
+        cnf = RawConfigParser()
+        with open(self.custom_conf_file) as f:
+            cnf.readfp(f)
+
+        if not cnf.has_section("vars"):
+            cnf.add_section("vars")
+
+        cnf.set("vars", name, value)
+        with open(self.tmp_conf_file, "w") as fw:
+            cnf.write(fw)
+
+        os.rename(self.tmp_conf_file, self.custom_conf_file)
+
+        self.reload()
+
+        return True
+
+    def check(self, name, value=None, with_conffile=True):
+        if with_conffile and self.custom_conf_file is None:
+            raise GconfNotConfigurable()
+
+        if not self._is_configurable(name):
+            raise GconfNotConfigurable()
+
+        if value is not None and not self._is_valid_value(name, value):
+            raise GconfInvalidValue()
+
+
+    def _load_with_lock(self):
+        with self.lock:
+            self._load()
+
+    def _load(self):
+        self.gconf = {}
+        self.template_conf = []
+        self.gconf_typecast = {}
+        self.non_configurable_configs = []
+        self.session_conf_items = []
+        self.default_values = {}
+
+        conf = RawConfigParser()
+        # Default Template config file
+        with open(self.default_conf_file) as f:
+            conf.readfp(f)
+
+        # Custom Config file
+        if self.custom_conf_file is not None:
+            with open(self.custom_conf_file) as f:
+                conf.readfp(f)
+
+        # Get version from default conf file
+        self.version = conf.get("__meta__", "version")
+
+        # Populate default values
+        for sect in conf.sections():
+            if sect in ["__meta__", "vars"]:
+                continue
+
+            # Collect list of available options with help details
+            self.gconfdata[sect] = {}
+            for k, v in conf.items(sect):
+                self.gconfdata[sect][k] = v.strip()
+
+            # Collect the Type cast information
+            if conf.has_option(sect, "type"):
+                self.gconf_typecast[sect] = conf.get(sect, "type")
+
+            # Prepare list of configurable conf
+            if conf.has_option(sect, "configurable"):
+                if conf.get(sect, "configurable").lower() == "false":
+                    self.non_configurable_configs.append(sect)
+
+            # if it is a template conf value which needs to be substituted
+            if conf.has_option(sect, "template"):
+                if conf.get(sect, "template").lower().strip() == "true":
+                    self.template_conf.append(sect)
+
+            # Set default values
+            if conf.has_option(sect, "value"):
+                self.gconf[sect] = conf.get(sect, "value").strip()
+
+        # Load the custom conf elements and overwrite
+        if conf.has_section("vars"):
+            for k, v in conf.items("vars"):
+                self.session_conf_items.append(k)
+                self.default_values[k] = self.gconf.get(k, "")
+                self.gconf[k] = v.strip()
+
+        # Overwrite the Slave configurations which are sent as
+        # arguments to gsyncd slave
+        if self.override_from_args:
+            for k, v in self.args.items():
+                k = k.replace("_", "-")
+                if k.startswith("slave-") and k in self.gconf:
+                    self.gconf[k] = v
+
+        self._tmpl_substitute()
+        self._do_typecast()
+
+    def reload(self, with_lock=True):
+        if self._is_config_changed():
+            if with_lock:
+                self._load_with_lock()
+            else:
+                self._load()
+
+    def get(self, name, default_value=None, with_lock=True):
+        if with_lock:
+            with self.lock:
+                return self.gconf.get(name, default_value)
+        else:
+            return self.gconf.get(name, default_value)
+
+    def getall(self, show_defaults=False, show_non_configurable=False):
+        cnf = {}
+        if not show_defaults:
+            for k in self.session_conf_items:
+                if k not in self.non_configurable_configs:
+                    dv = self.default_values.get(k, "")
+                    cnf[k] = {
+                        "value": self.get(k),
+                        "default": dv,
+                        "configurable": True,
+                        "modified": False if dv == "" else True
+                    }
+            return cnf
+
+        # Show all configs including defaults
+        for k, v in self.gconf.items():
+            configurable = False if k in self.non_configurable_configs \
+                           else True
+            dv = self.default_values.get(k, "")
+            modified = False if dv == "" else True
+            if show_non_configurable:
+                cnf[k] = {
+                    "value": v,
+                    "default": dv,
+                    "configurable": configurable,
+                    "modified": modified
+                }
+            else:
+                if k not in self.non_configurable_configs:
+                    cnf[k] = {
+                        "value": v,
+                        "default": dv,
+                        "configurable": configurable,
+                        "modified": modified
+                    }
+
+        return cnf
+
+    def getr(self, name, default_value=None):
+        with self.lock:
+            self.reload(with_lock=False)
+            return self.get(name, default_value, with_lock=False)
+
+    def get_help(self, name=None):
+        pass
+
+    def _is_configurable(self, name):
+        item = self.gconfdata.get(name, None)
+        if item is None:
+            return False
+
+        return item.get("configurable", True)
+
+    def _is_valid_value(self, name, value):
+        item = self.gconfdata.get(name, None)
+        if item is None:
+            return False
+
+        # If validation func not defined
+        if item.get("validation", None) is None:
+            return True
+
+        # minmax validation
+        if item["validation"] == "minmax":
+            return validate_minmax(value, item["min"], item["max"])
+
+        if item["validation"] == "choice":
+            return validate_choice(value, item["allowed_values"])
+
+        if item["validation"] == "bool":
+            return validate_bool(value)
+
+        if item["validation"] == "execpath":
+            return validate_execpath(value)
+
+        if item["validation"] == "unixtime":
+            return validate_unixtime(value)
+
+        if item["validation"] == "int":
+            return validate_int(value)
+
+        return False
+
+    def _is_config_changed(self):
+        if self.custom_conf_file is not None and \
+           os.path.exists(self.custom_conf_file):
+                st = os.lstat(self.custom_conf_file)
+                if st.st_mtime > self.prev_mtime:
+                    self.prev_mtime = st.st_mtime
+                    return True
+
+        return False
+
+def is_config_file_old(config_file, mastervol, slavevol):
+    cnf = RawConfigParser()
+    cnf.read(config_file)
+    session_section = "peers %s %s" % (mastervol, slavevol)
+    try:
+        return dict(cnf.items(session_section))
+    except NoSectionError:
+        return None
+
+def config_upgrade(config_file, ret):
+    config_file_backup = os.path.join(os.path.dirname(config_file), "gsyncd.conf.bkp")
+
+    #copy old config file in a backup file
+    shutil.copyfile(config_file, config_file_backup)
+
+    #write a new config file
+    config = RawConfigParser()
+    config.add_section('vars')
+
+    for key, value in ret.items():
+        #handle option name changes
+        if key == "use_tarssh":
+            new_key = "sync-method"
+            if value == "true":
+                new_value = "tarssh"
+            else:
+                new_value = "rsync"
+            config.set('vars', new_key, new_value)
+        elif key == "timeout":
+            new_key = "slave-timeout"
+            config.set('vars', new_key, value)
+        #for changes like: ignore_deletes to ignore-deletes
+        else:
+            new_key = key.replace("_", "-")
+            config.set('vars', new_key, value)
+
+    with open(config_file, 'w') as configfile:
+        config.write(configfile)
+
+
+def validate_int(value):
+    try:
+        _ = int(value)
+        return True
+    except ValueError:
+        return False
+
+
+def validate_unixtime(value):
+    try:
+        y = datetime.fromtimestamp(int(value)).strftime("%Y")
+        if y == "1970":
+            return False
+
+        return True
+    except ValueError:
+        return False
+
+
+def validate_minmax(value, minval, maxval):
+    try:
+        value = int(value)
+        minval = int(minval)
+        maxval = int(maxval)
+        return value >= minval and value <= maxval
+    except ValueError:
+        return False
+
+
+def validate_choice(value, allowed_values):
+    allowed_values = allowed_values.split(",")
+    allowed_values = [v.strip() for v in allowed_values]
+
+    return value in allowed_values
+
+
+def validate_bool(value):
+    return value in ["true", "false"]
+
+
+def validate_execpath(value):
+    return os.path.isfile(value) and os.access(value, os.X_OK)
+
+
+def validate_filepath(value):
+    return os.path.isfile(value)
+
+
+def validate_path(value):
+    return os.path.exists(value)
+
+
+def to_int(value):
+    return int(value)
+
+
+def to_float(value):
+    return float(value)
+
+
+def to_bool(value):
+    if isinstance(value, bool):
+        return value
+    return True if value in ["true", "True"] else False
+
+
+def get(name, default_value=None):
+    return _gconf.get(name, default_value)
+
+
+def getall(show_defaults=False, show_non_configurable=False):
+    return _gconf.getall(show_defaults=show_defaults,
+                         show_non_configurable=show_non_configurable)
+
+
+def getr(name, default_value=None):
+    return _gconf.getr(name, default_value)
+
+
+def load(default_conf, custom_conf=None, args={}, extra_tmpl_args={},
+         override_from_args=False):
+    global _gconf
+    _gconf = Gconf(default_conf, custom_conf, args, extra_tmpl_args,
+                   override_from_args)
+
+
+def setconfig(name, value):
+    global _gconf
+    _gconf.set(name, value)
+
+
+def resetconfig(name):
+    global _gconf
+    _gconf.reset(name)
+
+
+def check(name, value=None, with_conffile=True):
+    global _gconf
+    _gconf.check(name, value=value, with_conffile=with_conffile)
diff --git a/geo-replication/syncdaemon/gsyncdstatus.py b/geo-replication/syncdaemon/gsyncdstatus.py
index 38ca92c73a9..1a655ff8887 100644
--- a/geo-replication/syncdaemon/gsyncdstatus.py
+++ b/geo-replication/syncdaemon/gsyncdstatus.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -9,18 +9,22 @@
 # cases as published by the Free Software Foundation.
 #
 
+from __future__ import print_function
 import fcntl
 import os
 import tempfile
-import urllib
+try:
+    import urllib.parse as urllib
+except ImportError:
+    import urllib
 import json
 import time
 from datetime import datetime
 from errno import EACCES, EAGAIN, ENOENT
 import logging
 
-from syncdutils import EVENT_GEOREP_ACTIVE, EVENT_GEOREP_PASSIVE, gf_event
-from syncdutils import EVENT_GEOREP_CHECKPOINT_COMPLETED, lf
+from syncdutils import (EVENT_GEOREP_ACTIVE, EVENT_GEOREP_PASSIVE, gf_event,
+                        EVENT_GEOREP_CHECKPOINT_COMPLETED, lf)
 
 DEFAULT_STATUS = "N/A"
 MONITOR_STATUS = ("Created", "Started", "Paused", "Stopped")
@@ -99,6 +103,7 @@ class LockedOpen(object):
         return f
 
     def __exit__(self, _exc_type, _exc_value, _traceback):
+        fcntl.flock(self.fileobj, fcntl.LOCK_UN)
         self.fileobj.close()
 
 
@@ -152,11 +157,12 @@ class GeorepStatus(object):
                  **kwargs)
 
     def _update(self, mergerfunc):
+        data = self.default_values
         with LockedOpen(self.filename, 'r+') as f:
             try:
-                data = json.load(f)
+                data.update(json.load(f))
             except ValueError:
-                data = self.default_values
+                pass
 
             data = mergerfunc(data)
             # If Data is not changed by merger func
@@ -399,6 +405,15 @@ class GeorepStatus(object):
 
         return data
 
-    def print_status(self, checkpoint_time=0):
-        for key, value in self.get_status(checkpoint_time).items():
-            print ("%s: %s" % (key, value))
+    def print_status(self, checkpoint_time=0, json_output=False):
+        status_out = self.get_status(checkpoint_time)
+        if json_output:
+            out = {}
+            # Convert all values as string
+            for k, v in status_out.items():
+                out[k] = str(v)
+            print(json.dumps(out))
+            return
+
+        for key, value in status_out.items():
+            print(("%s: %s" % (key, value)))
diff --git a/geo-replication/syncdaemon/libcxattr.py b/geo-replication/syncdaemon/libcxattr.py
index 3671e102c7f..e6406c36bd7 100644
--- a/geo-replication/syncdaemon/libcxattr.py
+++ b/geo-replication/syncdaemon/libcxattr.py
@@ -9,13 +9,14 @@
 #
 
 import os
-from ctypes import CDLL, create_string_buffer, get_errno
-from ctypes.util import find_library
+from ctypes import CDLL, get_errno
+from py2py3 import (bytearray_to_str, gr_create_string_buffer,
+                    gr_query_xattr, gr_lsetxattr, gr_lremovexattr)
 
 
 class Xattr(object):
 
-    """singleton that wraps the extended attribues system
+    """singleton that wraps the extended attributes system
        interface for python using ctypes
 
        Just implement it to the degree we need it, in particular
@@ -25,7 +26,7 @@ class Xattr(object):
          sizes we expect
     """
 
-    libc = CDLL(find_library("c"), use_errno=True)
+    libc = CDLL("libc.so.6", use_errno=True)
 
     @classmethod
     def geterrno(cls):
@@ -39,20 +40,23 @@ class Xattr(object):
     @classmethod
     def _query_xattr(cls, path, siz, syscall, *a):
         if siz:
-            buf = create_string_buffer('\0' * siz)
+            buf = gr_create_string_buffer(siz)
         else:
             buf = None
         ret = getattr(cls.libc, syscall)(*((path,) + a + (buf, siz)))
         if ret == -1:
             cls.raise_oserr()
         if siz:
-            return buf.raw[:ret]
+            # py2 and py3 compatibility. Convert bytes array
+            # to string
+            result = bytearray_to_str(buf.raw)
+            return result[:ret]
         else:
             return ret
 
     @classmethod
     def lgetxattr(cls, path, attr, siz=0):
-        return cls._query_xattr(path, siz, 'lgetxattr', attr)
+        return gr_query_xattr(cls, path, siz, 'lgetxattr', attr)
 
     @classmethod
     def lgetxattr_buf(cls, path, attr):
@@ -66,7 +70,7 @@ class Xattr(object):
 
     @classmethod
     def llistxattr(cls, path, siz=0):
-        ret = cls._query_xattr(path, siz, 'llistxattr')
+        ret = gr_query_xattr(cls, path, siz, 'llistxattr')
         if isinstance(ret, str):
             ret = ret.strip('\0')
             ret = ret.split('\0') if ret else []
@@ -74,13 +78,13 @@ class Xattr(object):
 
     @classmethod
     def lsetxattr(cls, path, attr, val):
-        ret = cls.libc.lsetxattr(path, attr, val, len(val), 0)
+        ret = gr_lsetxattr(cls, path, attr, val)
         if ret == -1:
             cls.raise_oserr()
 
     @classmethod
     def lremovexattr(cls, path, attr):
-        ret = cls.libc.lremovexattr(path, attr)
+        ret = gr_lremovexattr(cls, path, attr)
         if ret == -1:
             cls.raise_oserr()
 
diff --git a/geo-replication/syncdaemon/libgfchangelog.py b/geo-replication/syncdaemon/libgfchangelog.py
index d87b56cd941..a3bda7282c0 100644
--- a/geo-replication/syncdaemon/libgfchangelog.py
+++ b/geo-replication/syncdaemon/libgfchangelog.py
@@ -9,129 +9,135 @@
 #
 
 import os
-from ctypes import CDLL, RTLD_GLOBAL, create_string_buffer, get_errno, byref, c_ulong
+from ctypes import CDLL, RTLD_GLOBAL, get_errno, byref, c_ulong
 from ctypes.util import find_library
 from syncdutils import ChangelogException, ChangelogHistoryNotAvailable
+from py2py3 import (gr_cl_history_changelog, gr_cl_done,
+                    gr_create_string_buffer, gr_cl_register,
+                    gr_cl_history_done, bytearray_to_str)
 
 
-class Changes(object):
-    libgfc = CDLL(find_library("gfchangelog"), mode=RTLD_GLOBAL, use_errno=True)
-
-    @classmethod
-    def geterrno(cls):
-        return get_errno()
-
-    @classmethod
-    def raise_changelog_err(cls):
-        errn = cls.geterrno()
-        raise ChangelogException(errn, os.strerror(errn))
-
-    @classmethod
-    def _get_api(cls, call):
-        return getattr(cls.libgfc, call)
-
-    @classmethod
-    def cl_init(cls):
-        ret = cls._get_api('gf_changelog_init')(None)
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_register(cls, brick, path, log_file, log_level, retries=0):
-        ret = cls._get_api('gf_changelog_register')(brick, path,
-                                                    log_file,
-                                                    log_level, retries)
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_scan(cls):
-        ret = cls._get_api('gf_changelog_scan')()
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_startfresh(cls):
-        ret = cls._get_api('gf_changelog_start_fresh')()
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_getchanges(cls):
-        """ remove hardcoding for path name length """
-        def clsort(f):
-            return f.split('.')[-1]
-        changes = []
-        buf = create_string_buffer('\0', 4096)
-        call = cls._get_api('gf_changelog_next_change')
-
-        while True:
-            ret = call(buf, 4096)
-            if ret in (0, -1):
-                break
-            changes.append(buf.raw[:ret - 1])
-        if ret == -1:
-            cls.raise_changelog_err()
-        # cleanup tracker
-        cls.cl_startfresh()
-        return sorted(changes, key=clsort)
-
-    @classmethod
-    def cl_done(cls, clfile):
-        ret = cls._get_api('gf_changelog_done')(clfile)
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_history_scan(cls):
-        ret = cls._get_api('gf_history_changelog_scan')()
-        if ret == -1:
-            cls.raise_changelog_err()
-
-        return ret
-
-    @classmethod
-    def cl_history_changelog(cls, changelog_path, start, end, num_parallel):
-        actual_end = c_ulong()
-        ret = cls._get_api('gf_history_changelog')(changelog_path, start, end,
-                                                   num_parallel,
-                                                   byref(actual_end))
-        if ret == -1:
-            cls.raise_changelog_err()
-
-        if ret == -2:
-            raise ChangelogHistoryNotAvailable()
-
-        return (ret, actual_end.value)
-
-    @classmethod
-    def cl_history_startfresh(cls):
-        ret = cls._get_api('gf_history_changelog_start_fresh')()
-        if ret == -1:
-            cls.raise_changelog_err()
-
-    @classmethod
-    def cl_history_getchanges(cls):
-        """ remove hardcoding for path name length """
-        def clsort(f):
-            return f.split('.')[-1]
-
-        changes = []
-        buf = create_string_buffer('\0', 4096)
-        call = cls._get_api('gf_history_changelog_next_change')
-
-        while True:
-            ret = call(buf, 4096)
-            if ret in (0, -1):
-                break
-            changes.append(buf.raw[:ret - 1])
-        if ret == -1:
-            cls.raise_changelog_err()
-
-        return sorted(changes, key=clsort)
-
-    @classmethod
-    def cl_history_done(cls, clfile):
-        ret = cls._get_api('gf_history_changelog_done')(clfile)
-        if ret == -1:
-            cls.raise_changelog_err()
+libgfc = CDLL(
+    find_library("gfchangelog"),
+    mode=RTLD_GLOBAL,
+    use_errno=True
+)
+
+
+def _raise_changelog_err():
+    errn = get_errno()
+    raise ChangelogException(errn, os.strerror(errn))
+
+
+def _init():
+    if libgfc.gf_changelog_init(None) == -1:
+        _raise_changelog_err()
+
+
+def register(brick, path, log_file, log_level, retries=0):
+    _init()
+
+    ret = gr_cl_register(libgfc, brick, path, log_file, log_level, retries)
+
+    if ret == -1:
+        _raise_changelog_err()
+
+
+def scan():
+    ret = libgfc.gf_changelog_scan()
+    if ret == -1:
+        _raise_changelog_err()
+
+
+def startfresh():
+    ret = libgfc.gf_changelog_start_fresh()
+    if ret == -1:
+        _raise_changelog_err()
+
+
+def getchanges():
+    def clsort(cfile):
+        return cfile.split('.')[-1]
+
+    changes = []
+    buf = gr_create_string_buffer(4096)
+    call = libgfc.gf_changelog_next_change
+
+    while True:
+        ret = call(buf, 4096)
+        if ret in (0, -1):
+            break
+
+        # py2 and py3 compatibility
+        result = bytearray_to_str(buf.raw[:ret - 1])
+        changes.append(result)
+
+    if ret == -1:
+        _raise_changelog_err()
+
+    # cleanup tracker
+    startfresh()
+
+    return sorted(changes, key=clsort)
+
+
+def done(clfile):
+    ret = gr_cl_done(libgfc, clfile)
+    if ret == -1:
+        _raise_changelog_err()
+
+
+def history_scan():
+    ret = libgfc.gf_history_changelog_scan()
+    if ret == -1:
+        _raise_changelog_err()
+
+    return ret
+
+
+def history_changelog(changelog_path, start, end, num_parallel):
+    actual_end = c_ulong()
+    ret = gr_cl_history_changelog(libgfc, changelog_path, start, end,
+                                  num_parallel, byref(actual_end))
+    if ret == -1:
+        _raise_changelog_err()
+
+    if ret == -2:
+        raise ChangelogHistoryNotAvailable()
+
+    return (ret, actual_end.value)
+
+
+def history_startfresh():
+    ret = libgfc.gf_history_changelog_start_fresh()
+    if ret == -1:
+        _raise_changelog_err()
+
+
+def history_getchanges():
+    def clsort(cfile):
+        return cfile.split('.')[-1]
+
+    changes = []
+    buf = gr_create_string_buffer(4096)
+    call = libgfc.gf_history_changelog_next_change
+
+    while True:
+        ret = call(buf, 4096)
+        if ret in (0, -1):
+            break
+
+        # py2 and py3 compatibility
+        result = bytearray_to_str(buf.raw[:ret - 1])
+        changes.append(result)
+
+    if ret == -1:
+        _raise_changelog_err()
+
+    return sorted(changes, key=clsort)
+
+
+def history_done(clfile):
+    ret = gr_cl_history_done(libgfc, clfile)
+    if ret == -1:
+        _raise_changelog_err()
diff --git a/geo-replication/syncdaemon/logutils.py b/geo-replication/syncdaemon/logutils.py
new file mode 100644
index 00000000000..01ae7852f23
--- /dev/null
+++ b/geo-replication/syncdaemon/logutils.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+#
+
+import logging
+from logging import Logger, handlers
+import sys
+import time
+
+
+class GLogger(Logger):
+
+    """Logger customizations for gsyncd.
+
+    It implements a log format similar to that of glusterfs.
+    """
+
+    def makeRecord(self, name, level, *a):
+        rv = Logger.makeRecord(self, name, level, *a)
+        rv.nsecs = (rv.created - int(rv.created)) * 1000000
+        fr = sys._getframe(4)
+        callee = fr.f_locals.get('self')
+        if callee:
+            ctx = str(type(callee)).split("'")[1].split('.')[-1]
+        else:
+            ctx = '<top>'
+        if not hasattr(rv, 'funcName'):
+            rv.funcName = fr.f_code.co_name
+        rv.lvlnam = logging.getLevelName(level)[0]
+        rv.ctx = ctx
+        return rv
+
+
+LOGFMT = ("[%(asctime)s.%(nsecs)d] %(lvlnam)s [%(module)s{0}"
+          ":%(lineno)s:%(funcName)s] %(ctx)s: %(message)s")
+
+
+def setup_logging(level="INFO", label="", log_file=""):
+    if label:
+        label = "(" + label + ")"
+
+    filename = None
+    stream = None
+    if log_file:
+        if log_file in ('-', '/dev/stderr'):
+            stream = sys.stderr
+        elif log_file == '/dev/stdout':
+            stream = sys.stdout
+        else:
+            filename = log_file
+
+    datefmt = "%Y-%m-%d %H:%M:%S"
+    fmt = LOGFMT.format(label)
+    logging.root = GLogger("root", level)
+    logging.setLoggerClass(GLogger)
+    logging.Formatter.converter = time.gmtime  # Log in GMT/UTC time
+    logging.getLogger().handlers = []
+    logging.getLogger().setLevel(level)
+
+    if filename is not None:
+        logging_handler = handlers.WatchedFileHandler(filename)
+        formatter = logging.Formatter(fmt=fmt,
+                                      datefmt=datefmt)
+        logging_handler.setFormatter(formatter)
+        logging.getLogger().addHandler(logging_handler)
+    else:
+        logging.basicConfig(stream=stream,
+                            format=fmt,
+                            datefmt=datefmt,
+                            level=level)
diff --git a/geo-replication/syncdaemon/master.py b/geo-replication/syncdaemon/master.py
index 4c1a529a3ed..9501aeae6b5 100644
--- a/geo-replication/syncdaemon/master.py
+++ b/geo-replication/syncdaemon/master.py
@@ -12,7 +12,6 @@ import os
 import sys
 import time
 import stat
-import json
 import logging
 import fcntl
 import string
@@ -21,11 +20,15 @@ import tarfile
 from errno import ENOENT, ENODATA, EEXIST, EACCES, EAGAIN, ESTALE, EINTR
 from threading import Condition, Lock
 from datetime import datetime
-from gconf import gconf
-from syncdutils import Thread, GsyncdError, boolify, escape_space_newline
-from syncdutils import unescape_space_newline, gauxpfx, md5hex, selfkill
-from syncdutils import lstat, errno_wrap, FreeObject, lf, matching_disk_gfid
-from syncdutils import NoStimeAvailable, PartialHistoryAvailable
+
+import gsyncdconfig as gconf
+import libgfchangelog
+from rconf import rconf
+from syncdutils import (Thread, GsyncdError, escape_space_newline,
+                        unescape_space_newline, gauxpfx, escape,
+                        lstat, errno_wrap, FreeObject, lf, matching_disk_gfid,
+                        NoStimeAvailable, PartialHistoryAvailable,
+                        host_brick_split)
 
 URXTIME = (-1, 0)
 
@@ -64,6 +67,9 @@ def _volinfo_hook_relax_foreign(self):
 def edct(op, **ed):
     dct = {}
     dct['op'] = op
+    # This is used in automatic gfid conflict resolution.
+    # When marked True, it's skipped during re-processing.
+    dct['skip_entry'] = False
     for k in ed:
         if k == 'stat':
             st = ed[k]
@@ -85,24 +91,41 @@ def gmaster_builder(excrawl=None):
     """produce the GMaster class variant corresponding
        to sync mode"""
     this = sys.modules[__name__]
-    modemixin = gconf.special_sync_mode
+    modemixin = gconf.get("special-sync-mode")
     if not modemixin:
         modemixin = 'normal'
-    changemixin = 'xsync' if gconf.change_detector == 'xsync' \
-                  else excrawl or gconf.change_detector
+
+    if gconf.get("change-detector") == 'xsync':
+        changemixin = 'xsync'
+    elif excrawl:
+        changemixin = excrawl
+    else:
+        changemixin = gconf.get("change-detector")
+
     logging.debug(lf('setting up change detection mode',
                      mode=changemixin))
     modemixin = getattr(this, modemixin.capitalize() + 'Mixin')
     crawlmixin = getattr(this, 'GMaster' + changemixin.capitalize() + 'Mixin')
-    sendmarkmixin = boolify(
-        gconf.use_rsync_xattrs) and SendmarkRsyncMixin or SendmarkNormalMixin
-    purgemixin = boolify(
-        gconf.ignore_deletes) and PurgeNoopMixin or PurgeNormalMixin
-    syncengine = boolify(gconf.use_tarssh) and TarSSHEngine or RsyncEngine
+
+    if gconf.get("use-rsync-xattrs"):
+        sendmarkmixin = SendmarkRsyncMixin
+    else:
+        sendmarkmixin = SendmarkNormalMixin
+
+    if gconf.get("ignore-deletes"):
+        purgemixin = PurgeNoopMixin
+    else:
+        purgemixin = PurgeNormalMixin
+
+    if gconf.get("sync-method") == "tarssh":
+        syncengine = TarSSHEngine
+    else:
+        syncengine = RsyncEngine
 
     class _GMaster(crawlmixin, modemixin, sendmarkmixin,
                    purgemixin, syncengine):
         pass
+
     return _GMaster
 
 
@@ -139,9 +162,9 @@ class NormalMixin(object):
         return xt0 >= xt1
 
     def make_xtime_opts(self, is_master, opts):
-        if not 'create' in opts:
+        if 'create' not in opts:
             opts['create'] = is_master
-        if not 'default_xtime' in opts:
+        if 'default_xtime' not in opts:
             opts['default_xtime'] = URXTIME
 
     def xtime_low(self, rsc, path, **opts):
@@ -174,7 +197,7 @@ class NormalMixin(object):
             vi = vi.copy()
             vi['timeout'] = int(time.time()) + timo
         else:
-            # send keep-alives more frequently to
+            # send keep-alive more frequently to
             # avoid a delay in announcing our volume info
             # to slave if it becomes established in the
             # meantime
@@ -212,9 +235,9 @@ class RecoverMixin(NormalMixin):
 
     @staticmethod
     def make_xtime_opts(is_master, opts):
-        if not 'create' in opts:
+        if 'create' not in opts:
             opts['create'] = False
-        if not 'default_xtime' in opts:
+        if 'default_xtime' not in opts:
             opts['default_xtime'] = URXTIME
 
     def keepalive_payload_hook(self, timo, gap):
@@ -385,7 +408,7 @@ class GMasterCommon(object):
         self.master = master
         self.slave = slave
         self.jobtab = {}
-        if boolify(gconf.use_tarssh):
+        if gconf.get("sync-method") == "tarssh":
             self.syncer = Syncer(slave, self.slave.tarssh, [2])
         else:
             # partial transfer (cf. rsync(1)), that's normal
@@ -401,7 +424,7 @@ class GMasterCommon(object):
         # 0.
         self.crawls = 0
         self.turns = 0
-        self.total_turns = int(gconf.turns)
+        self.total_turns = rconf.turns
         self.crawl_start = datetime.now()
         self.lastreport = {'crawls': 0, 'turns': 0, 'time': 0}
         self.start = None
@@ -414,7 +437,7 @@ class GMasterCommon(object):
 
     def init_keep_alive(cls):
         """start the keep-alive thread """
-        timo = int(gconf.timeout or 0)
+        timo = gconf.get("slave-timeout", 0)
         if timo > 0:
             def keep_alive():
                 while True:
@@ -427,28 +450,20 @@ class GMasterCommon(object):
     def mgmt_lock(self):
 
         """Take management volume lock """
-        if gconf.mgmt_lock_fd:
+        if rconf.mgmt_lock_fd:
             try:
-                fcntl.lockf(gconf.mgmt_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                if not gconf.active_earlier:
-                    gconf.active_earlier = True
-                    logging.info(lf("Got lock Becoming ACTIVE",
-                                    brick=gconf.local_path))
+                fcntl.lockf(rconf.mgmt_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
                 return True
             except:
                 ex = sys.exc_info()[1]
                 if isinstance(ex, IOError) and ex.errno in (EACCES, EAGAIN):
-                    if not gconf.passive_earlier:
-                        gconf.passive_earlier = True
-                        logging.info(lf("Didn't get lock Becoming PASSIVE",
-                                        brick=gconf.local_path))
                     return False
                 raise
 
         fd = None
-        bname = str(self.uuid) + "_" + str(gconf.slave_id) + "_subvol_" \
-            + str(gconf.subvol_num) + ".lock"
-        mgmt_lock_dir = os.path.join(gconf.meta_volume_mnt, "geo-rep")
+        bname = str(self.uuid) + "_" + rconf.args.slave_id + "_subvol_" \
+            + str(rconf.args.subvol_num) + ".lock"
+        mgmt_lock_dir = os.path.join(gconf.get("meta-volume-mnt"), "geo-rep")
         path = os.path.join(mgmt_lock_dir, bname)
         logging.debug(lf("lock file path", path=path))
         try:
@@ -471,30 +486,22 @@ class GMasterCommon(object):
         try:
             fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
             # Save latest FD for future use
-            gconf.mgmt_lock_fd = fd
+            rconf.mgmt_lock_fd = fd
         except:
             ex = sys.exc_info()[1]
             if isinstance(ex, IOError) and ex.errno in (EACCES, EAGAIN):
                 # cannot grab, it's taken
-                if not gconf.passive_earlier:
-                    gconf.passive_earlier = True
-                    logging.info(lf("Didn't get lock Becoming PASSIVE",
-                                    brick=gconf.local_path))
-                gconf.mgmt_lock_fd = fd
+                rconf.mgmt_lock_fd = fd
                 return False
             raise
 
-        if not gconf.active_earlier:
-            gconf.active_earlier = True
-            logging.info(lf("Got lock Becoming ACTIVE",
-                            brick=gconf.local_path))
         return True
 
     def should_crawl(self):
-        if not boolify(gconf.use_meta_volume):
-            return gconf.glusterd_uuid in self.master.server.node_uuid()
+        if not gconf.get("use-meta-volume"):
+            return rconf.args.local_node_id in self.master.server.node_uuid()
 
-        if not os.path.ismount(gconf.meta_volume_mnt):
+        if not os.path.ismount(gconf.get("meta-volume-mnt")):
             logging.error("Meta-volume is not mounted. Worker Exiting...")
             sys.exit(1)
         return self.mgmt_lock()
@@ -511,8 +518,8 @@ class GMasterCommon(object):
 
         # If crawlwrap is called when partial history available,
         # then it sets register_time which is the time when geo-rep
-        # worker registerd to changelog consumption. Since nsec is
-        # not considered in register time, their are chances of skipping
+        # worker registered to changelog consumption. Since nsec is
+        # not considered in register time, there are chances of skipping
         # changes detection in xsync crawl. This limit will be reset when
         # crawlwrap is called again.
         self.live_changelog_start_time = None
@@ -522,7 +529,7 @@ class GMasterCommon(object):
         # no need to maintain volinfo state machine.
         # in a cascading setup, each geo-replication session is
         # independent (ie. 'volume-mark' and 'xtime' are not
-        # propogated). This is because the slave's xtime is now
+        # propagated). This is because the slave's xtime is now
         # stored on the master itself. 'volume-mark' just identifies
         # that we are in a cascading setup and need to enable
         # 'geo-replication.ignore-pid-check' option.
@@ -532,7 +539,7 @@ class GMasterCommon(object):
         logging.debug("%s master with volume id %s ..." %
                       (inter_master and "intermediate" or "primary",
                        self.uuid))
-        gconf.configinterface.set('volume_id', self.uuid)
+        rconf.volume_id = self.uuid
         if self.volinfo:
             if self.volinfo['retval']:
                 logging.warn(lf("master cluster's info may not be valid",
@@ -557,7 +564,7 @@ class GMasterCommon(object):
                                        turns=self.turns,
                                        time=self.start)
             t1 = time.time()
-            if int(t1 - t0) >= int(gconf.replica_failover_interval):
+            if int(t1 - t0) >= gconf.get("replica-failover-interval"):
                 crawl = self.should_crawl()
                 t0 = t1
             self.update_worker_remote_node()
@@ -567,7 +574,7 @@ class GMasterCommon(object):
                 # which is min of cluster (but max of the replicas)
                 brick_stime = self.xtime('.', self.slave)
                 cluster_stime = self.master.server.aggregated.stime_mnt(
-                    '.', '.'.join([str(self.uuid), str(gconf.slave_id)]))
+                    '.', '.'.join([str(self.uuid), rconf.args.slave_id]))
                 logging.debug(lf("Crawl info",
                                  cluster_stime=cluster_stime,
                                  brick_stime=brick_stime))
@@ -675,6 +682,7 @@ class XCrawlMetadata(object):
         self.st_atime = float(st_atime)
         self.st_mtime = float(st_mtime)
 
+
 class GMasterChangelogMixin(GMasterCommon):
 
     """ changelog based change detection and syncing """
@@ -692,7 +700,8 @@ class GMasterChangelogMixin(GMasterCommon):
     TYPE_GFID = "D "
     TYPE_ENTRY = "E "
 
-    MAX_EF_RETRIES = 15
+    MAX_EF_RETRIES = 10
+    MAX_OE_RETRIES = 10
 
     # flat directory hierarchy for gfid based access
     FLAT_DIR_HIERARCHY = '.'
@@ -701,34 +710,34 @@ class GMasterChangelogMixin(GMasterCommon):
 
     def init_fop_batch_stats(self):
         self.batch_stats = {
-            "CREATE":0,
-            "MKNOD":0,
-            "UNLINK":0,
-            "MKDIR":0,
-            "RMDIR":0,
-            "LINK":0,
-            "SYMLINK":0,
-            "RENAME":0,
-            "SETATTR":0,
-            "SETXATTR":0,
-            "XATTROP":0,
-            "DATA":0,
-            "ENTRY_SYNC_TIME":0,
-            "META_SYNC_TIME":0,
-            "DATA_START_TIME":0
+            "CREATE": 0,
+            "MKNOD": 0,
+            "UNLINK": 0,
+            "MKDIR": 0,
+            "RMDIR": 0,
+            "LINK": 0,
+            "SYMLINK": 0,
+            "RENAME": 0,
+            "SETATTR": 0,
+            "SETXATTR": 0,
+            "XATTROP": 0,
+            "DATA": 0,
+            "ENTRY_SYNC_TIME": 0,
+            "META_SYNC_TIME": 0,
+            "DATA_START_TIME": 0
         }
 
     def update_fop_batch_stats(self, ty):
         if ty in ['FSETXATTR']:
-           ty = 'SETXATTR'
-        self.batch_stats[ty] = self.batch_stats.get(ty,0) + 1
+            ty = 'SETXATTR'
+        self.batch_stats[ty] = self.batch_stats.get(ty, 0) + 1
 
     def archive_and_purge_changelogs(self, changelogs):
         # Creates tar file instead of tar.gz, since changelogs will
         # be appended to existing tar. archive name is
         # archive_<YEAR><MONTH>.tar
         archive_name = "archive_%s.tar" % datetime.today().strftime(
-            gconf.changelog_archive_format)
+            gconf.get("changelog-archive-format"))
 
         try:
             tar = tarfile.open(os.path.join(self.processed_changelogs_dir,
@@ -764,13 +773,9 @@ class GMasterChangelogMixin(GMasterCommon):
                 else:
                     raise
 
-    def fallback_xsync(self):
-        logging.info('falling back to xsync mode')
-        gconf.configinterface.set('change-detector', 'xsync')
-        selfkill()
-
     def setup_working_dir(self):
-        workdir = os.path.join(gconf.working_dir, md5hex(gconf.local_path))
+        workdir = os.path.join(gconf.get("working-dir"),
+                               escape(rconf.args.local_path))
         logging.debug('changelog working dir %s' % workdir)
         return workdir
 
@@ -788,103 +793,198 @@ class GMasterChangelogMixin(GMasterCommon):
 
         self.status.inc_value("failures", num_failures)
 
-    def fix_possible_entry_failures(self, failures, retry_count):
+    def fix_possible_entry_failures(self, failures, retry_count, entries):
         pfx = gauxpfx()
         fix_entry_ops = []
         failures1 = []
+        remove_gfids = set()
         for failure in failures:
-            if failure[2]['dst']:
+            if failure[2]['name_mismatch']:
+                pbname = failure[2]['slave_entry']
+            elif failure[2]['dst']:
                 pbname = failure[0]['entry1']
             else:
                 pbname = failure[0]['entry']
-            if failure[2]['gfid_mismatch']:
+
+            op = failure[0]['op']
+            # name exists but gfid is different
+            if failure[2]['gfid_mismatch'] or failure[2]['name_mismatch']:
                 slave_gfid = failure[2]['slave_gfid']
                 st = lstat(os.path.join(pfx, slave_gfid))
+                # Takes care of scenarios with no hardlinks
                 if isinstance(st, int) and st == ENOENT:
-                    logging.info(lf('Fixing gfid mismatch in slave. Deleting'
-                                    ' the entry', retry_count=retry_count,
+                    logging.debug(lf('Entry not present on master. Fixing gfid '
+                                    'mismatch in slave. Deleting the entry',
+                                    retry_count=retry_count,
                                     entry=repr(failure)))
-                    #Add deletion to fix_entry_ops list
+                    # Add deletion to fix_entry_ops list
                     if failure[2]['slave_isdir']:
-                        fix_entry_ops.append(edct('RMDIR',
-                                                  gfid=failure[2]['slave_gfid'],
-                                                  entry=pbname))
+                        fix_entry_ops.append(
+                            edct('RMDIR',
+                                 gfid=failure[2]['slave_gfid'],
+                                 entry=pbname))
                     else:
-                        fix_entry_ops.append(edct('UNLINK',
-                                                  gfid=failure[2]['slave_gfid'],
-                                                  entry=pbname))
+                        fix_entry_ops.append(
+                            edct('UNLINK',
+                                 gfid=failure[2]['slave_gfid'],
+                                 entry=pbname))
+                    remove_gfids.add(slave_gfid)
+                    if op in ['RENAME']:
+                        # If renamed gfid doesn't exists on master, remove
+                        # rename entry and unlink src on slave
+                        st = lstat(os.path.join(pfx, failure[0]['gfid']))
+                        if isinstance(st, int) and st == ENOENT:
+                            logging.debug("Unlink source %s" % repr(failure))
+                            remove_gfids.add(failure[0]['gfid'])
+                            fix_entry_ops.append(
+                                edct('UNLINK',
+                                     gfid=failure[0]['gfid'],
+                                     entry=failure[0]['entry']))
+                # Takes care of scenarios of hardlinks/renames on master
                 elif not isinstance(st, int):
-                    #The file exists on master but with different name.
-                    #Probabaly renamed and got missed during xsync crawl.
-                    if failure[2]['slave_isdir']:
-                        logging.info(lf('Fixing gfid mismatch in slave',
+                    if matching_disk_gfid(slave_gfid, pbname):
+                        # Safe to ignore the failure as master contains same
+                        # file with same gfid. Remove entry from entries list
+                        logging.debug(lf('Fixing gfid mismatch in slave. '
+                                        ' Safe to ignore, take out entry',
                                         retry_count=retry_count,
                                         entry=repr(failure)))
-                        realpath = os.readlink(os.path.join(gconf.local_path,
-                                                            ".glusterfs",
-                                                            slave_gfid[0:2],
-                                                            slave_gfid[2:4],
-                                                            slave_gfid))
+                        remove_gfids.add(failure[0]['gfid'])
+                        if op == 'RENAME':
+                            fix_entry_ops.append(
+                                edct('UNLINK',
+                                     gfid=failure[0]['gfid'],
+                                     entry=failure[0]['entry']))
+                    # The file exists on master but with different name.
+                    # Probably renamed and got missed during xsync crawl.
+                    elif failure[2]['slave_isdir']:
+                        realpath = os.readlink(os.path.join(
+                                               rconf.args.local_path,
+                                               ".glusterfs",
+                                               slave_gfid[0:2],
+                                               slave_gfid[2:4],
+                                               slave_gfid))
                         dst_entry = os.path.join(pfx, realpath.split('/')[-2],
                                                  realpath.split('/')[-1])
-                        rename_dict = edct('RENAME', gfid=slave_gfid,
-                                           entry=failure[0]['entry'],
-                                           entry1=dst_entry, stat=st,
-                                           link=None)
-                        logging.info(lf('Fixing gfid mismatch in slave. '
-                                        'Renaming', retry_count=retry_count,
-                                        entry=repr(rename_dict)))
-                        fix_entry_ops.append(rename_dict)
+                        src_entry = pbname
+                        logging.debug(lf('Fixing dir name/gfid mismatch in '
+                                        'slave', retry_count=retry_count,
+                                        entry=repr(failure)))
+                        if src_entry == dst_entry:
+                            # Safe to ignore the failure as master contains
+                            # same directory as in slave with same gfid.
+                            # Remove the failure entry from entries list
+                            logging.debug(lf('Fixing dir name/gfid mismatch'
+                                            ' in slave. Safe to ignore, '
+                                            'take out entry',
+                                            retry_count=retry_count,
+                                            entry=repr(failure)))
+                            try:
+                                entries.remove(failure[0])
+                            except ValueError:
+                                pass
+                        else:
+                            rename_dict = edct('RENAME', gfid=slave_gfid,
+                                               entry=src_entry,
+                                               entry1=dst_entry, stat=st,
+                                               link=None)
+                            logging.debug(lf('Fixing dir name/gfid mismatch'
+                                            ' in slave. Renaming',
+                                            retry_count=retry_count,
+                                            entry=repr(rename_dict)))
+                            fix_entry_ops.append(rename_dict)
                     else:
-                        logging.info(lf('Fixing gfid mismatch in slave. '
-                                        ' Deleting the entry',
+                        # A hardlink file exists with different name or
+                        # renamed file exists and we are sure from
+                        # matching_disk_gfid check that the entry doesn't
+                        # exist with same gfid so we can safely delete on slave
+                        logging.debug(lf('Fixing file gfid mismatch in slave. '
+                                        'Hardlink/Rename Case. Deleting entry',
                                         retry_count=retry_count,
                                         entry=repr(failure)))
-                        fix_entry_ops.append(edct('UNLINK',
-                                                  gfid=failure[2]['slave_gfid'],
-                                                  entry=pbname))
-                        logging.error(lf('Entry cannot be fixed in slave due '
-                                         'to GFID mismatch, find respective '
-                                         'path for the GFID and trigger sync',
-                                         gfid=slave_gfid))
+                        fix_entry_ops.append(
+                            edct('UNLINK',
+                                 gfid=failure[2]['slave_gfid'],
+                                 entry=pbname))
+            elif failure[1] == ENOENT:
+                if op in ['RENAME']:
+                    pbname = failure[0]['entry1']
+                else:
+                    pbname = failure[0]['entry']
+
+                pargfid = pbname.split('/')[1]
+                st = lstat(os.path.join(pfx, pargfid))
+                # Safe to ignore the failure as master doesn't contain
+                # parent directory.
+                if isinstance(st, int):
+                    logging.debug(lf('Fixing ENOENT error in slave. Parent '
+                                    'does not exist on master. Safe to '
+                                    'ignore, take out entry',
+                                    retry_count=retry_count,
+                                    entry=repr(failure)))
+                    try:
+                        entries.remove(failure[0])
+                    except ValueError:
+                        pass
+                else:
+                    logging.debug(lf('Fixing ENOENT error in slave. Create '
+                                    'parent directory on slave.',
+                                    retry_count=retry_count,
+                                    entry=repr(failure)))
+                    realpath = os.readlink(os.path.join(rconf.args.local_path,
+                                                        ".glusterfs",
+                                                        pargfid[0:2],
+                                                        pargfid[2:4],
+                                                        pargfid))
+                    dir_entry = os.path.join(pfx, realpath.split('/')[-2],
+                                             realpath.split('/')[-1])
+                    fix_entry_ops.append(
+                        edct('MKDIR', gfid=pargfid, entry=dir_entry,
+                             mode=st.st_mode, uid=st.st_uid, gid=st.st_gid))
+
+        logging.debug("remove_gfids: %s" % repr(remove_gfids))
+        if remove_gfids:
+            for e in entries:
+                if e['op'] in ['MKDIR', 'MKNOD', 'CREATE', 'RENAME'] \
+                   and e['gfid'] in remove_gfids:
+                    logging.debug("Removed entry op from retrial list: entry: %s" % repr(e))
+                    e['skip_entry'] = True
 
         if fix_entry_ops:
-            #Process deletions of entries whose gfids are mismatched
+            # Process deletions of entries whose gfids are mismatched
             failures1 = self.slave.server.entry_ops(fix_entry_ops)
-            if not failures1:
-                logging.info ("Sucessfully fixed entry ops with gfid mismatch")
 
-        return failures1
+        return (failures1, fix_entry_ops)
 
     def handle_entry_failures(self, failures, entries):
         retries = 0
         pending_failures = False
         failures1 = []
         failures2 = []
+        entry_ops1 = []
+        entry_ops2 = []
 
         if failures:
             pending_failures = True
             failures1 = failures
+            entry_ops1 = entries
 
             while pending_failures and retries < self.MAX_EF_RETRIES:
                 retries += 1
-                failures2 = self.fix_possible_entry_failures(failures1,
-                                                             retries)
+                (failures2, entry_ops2) = self.fix_possible_entry_failures(
+                    failures1, retries, entry_ops1)
                 if not failures2:
                     pending_failures = False
+                    logging.info(lf('Successfully fixed entry ops with gfid '
+                                 'mismatch', retry_count=retries))
                 else:
                     pending_failures = True
                     failures1 = failures2
+                    entry_ops1 = entry_ops2
 
             if pending_failures:
                 for failure in failures1:
                     logging.error("Failed to fix entry ops %s", repr(failure))
-            else:
-                #Retry original entry list 5 times
-                failures = self.slave.server.entry_ops(entries)
-
-            self.log_failures(failures, 'gfid', gauxpfx(), 'ENTRY')
-
 
     def process_change(self, change, done, retry):
         pfx = gauxpfx()
@@ -930,7 +1030,7 @@ class GMasterChangelogMixin(GMasterCommon):
             # skip ENTRY operation if hot tier brick
             if self.name == 'live_changelog' or \
                self.name == 'history_changelog':
-                if boolify(gconf.is_hottier) and et == self.TYPE_ENTRY:
+                if rconf.args.is_hottier and et == self.TYPE_ENTRY:
                     logging.debug(lf('skip ENTRY op if hot tier brick',
                                      op=ec[self.POS_TYPE]))
                     continue
@@ -978,14 +1078,14 @@ class GMasterChangelogMixin(GMasterCommon):
                                         'master', gfid=gfid, pgfid_bname=en))
                         continue
 
-                    if not boolify(gconf.ignore_deletes):
+                    if not gconf.get("ignore-deletes"):
                         if not ignore_entry_ops:
                             entries.append(edct(ty, gfid=gfid, entry=en))
                 elif ty in ['CREATE', 'MKDIR', 'MKNOD']:
                     # Special case: record mknod as link
                     if ty in ['MKNOD']:
                         mode = int(ec[2])
-                        if mode & 01000:
+                        if mode & 0o1000:
                                 # Avoid stat'ing the file as it
                                 # may be deleted in the interim
                                 st = FreeObject(st_mode=int(ec[2]),
@@ -1026,6 +1126,11 @@ class GMasterChangelogMixin(GMasterCommon):
                         os.path.join(pfx, ec[self.POS_ENTRY1 - 1]))
                     entries.append(edct(ty, gfid=gfid, entry=e1, entry1=en,
                                         stat=st, link=rl))
+                    # If src doesn't exist while doing rename, destination
+                    # is created. If data is not followed by rename, this
+                    # remains zero byte file on slave. Hence add data entry
+                    # for renames
+                    datas.add(os.path.join(pfx, gfid))
                 else:
                     # stat() to get mode and other information
                     if not matching_disk_gfid(gfid, en):
@@ -1049,6 +1154,12 @@ class GMasterChangelogMixin(GMasterCommon):
                                 rl = None
                         entries.append(edct(ty, stat=st, entry=en, gfid=gfid,
                                        link=rl))
+                        # If src doesn't exist while doing link, destination
+                        # is created based on file type. If data is not
+                        # followed by link, this remains zero byte file on
+                        # slave. Hence add data entry for links
+                        if rl is None:
+                            datas.add(os.path.join(pfx, gfid))
                     elif ty == 'SYMLINK':
                         rl = errno_wrap(os.readlink, [en], [ENOENT],
                                         [ESTALE, EINTR])
@@ -1084,12 +1195,11 @@ class GMasterChangelogMixin(GMasterCommon):
                                                       st_mtime=ec[6])))
                     else:
                         meta_gfid.add((os.path.join(pfx, ec[0]), ))
-                elif ec[1] == 'SETXATTR' or ec[1] == 'XATTROP' or \
-                     ec[1] == 'FXATTROP':
+                elif ec[1] in ['SETXATTR', 'XATTROP', 'FXATTROP']:
                     # To sync xattr/acls use rsync/tar, --xattrs and --acls
                     # switch to rsync and tar
-                    if not boolify(gconf.use_tarssh) and \
-                       (boolify(gconf.sync_xattrs) or boolify(gconf.sync_acls)):
+                    if not gconf.get("sync-method") == "tarssh" and \
+                       (gconf.get("sync-xattrs") or gconf.get("sync-acls")):
                         datas.add(os.path.join(pfx, ec[0]))
             else:
                 logging.warn(lf('got invalid fop type',
@@ -1097,13 +1207,12 @@ class GMasterChangelogMixin(GMasterCommon):
         logging.debug('entries: %s' % repr(entries))
 
         # Increment counters for Status
-        self.status.inc_value("entry", len(entries))
         self.files_in_batch += len(datas)
         self.status.inc_value("data", len(datas))
 
         self.batch_stats["DATA"] += self.files_in_batch - \
-                                    self.batch_stats["SETXATTR"] - \
-                                    self.batch_stats["XATTROP"]
+            self.batch_stats["SETXATTR"] - \
+            self.batch_stats["XATTROP"]
 
         entry_start_time = time.time()
         # sync namespace
@@ -1112,7 +1221,23 @@ class GMasterChangelogMixin(GMasterCommon):
             self.status.inc_value("entry", len(entries))
 
             failures = self.slave.server.entry_ops(entries)
-            self.handle_entry_failures(failures, entries)
+
+            if gconf.get("gfid-conflict-resolution"):
+                count = 0
+                if failures:
+                    logging.info(lf('Entry ops failed with gfid mismatch',
+                                count=len(failures)))
+                while failures and count < self.MAX_OE_RETRIES:
+                    count += 1
+                    self.handle_entry_failures(failures, entries)
+                    logging.info(lf('Retry original entries', count=count))
+                    failures = self.slave.server.entry_ops(entries)
+                    if not failures:
+                        logging.info("Successfully fixed all entry ops with "
+                                     "gfid mismatch")
+                        break
+
+            self.log_failures(failures, 'gfid', gauxpfx(), 'ENTRY')
             self.status.dec_value("entry", len(entries))
 
             # Update Entry stime in Brick Root only in case of Changelog mode
@@ -1147,10 +1272,10 @@ class GMasterChangelogMixin(GMasterCommon):
                     continue
                 meta_entries.append(edct('META', go=go[0], stat=st))
             if meta_entries:
-                self.status.inc_value("meta", len(entries))
+                self.status.inc_value("meta", len(meta_entries))
                 failures = self.slave.server.meta_ops(meta_entries)
                 self.log_failures(failures, 'go', '', 'META')
-                self.status.dec_value("meta", len(entries))
+                self.status.dec_value("meta", len(meta_entries))
 
         self.batch_stats["META_SYNC_TIME"] += time.time() - meta_start_time
 
@@ -1185,7 +1310,7 @@ class GMasterChangelogMixin(GMasterCommon):
             # with data of other changelogs.
 
             if retry:
-                if tries == (int(gconf.max_rsync_retries) - 1):
+                if tries == (gconf.get("max-rsync-retries") - 1):
                     # Enable Error logging if it is last retry
                     self.syncer.enable_errorlog()
 
@@ -1231,7 +1356,7 @@ class GMasterChangelogMixin(GMasterCommon):
                 if done:
                     xtl = (int(change.split('.')[-1]) - 1, 0)
                     self.upd_stime(xtl)
-                    map(self.changelog_done_func, changes)
+                    list(map(self.changelog_done_func, changes))
                     self.archive_and_purge_changelogs(changes)
 
                 # Reset Data counter after sync
@@ -1243,10 +1368,10 @@ class GMasterChangelogMixin(GMasterCommon):
             # We do not know which changelog transfer failed, retry everything.
             retry = True
             tries += 1
-            if tries == int(gconf.max_rsync_retries):
+            if tries == gconf.get("max-rsync-retries"):
                 logging.error(lf('changelogs could not be processed '
                                  'completely - moving on...',
-                                 files=map(os.path.basename, changes)))
+                                 files=list(map(os.path.basename, changes))))
 
                 # Reset data counter on failure
                 self.status.dec_value("data", self.files_in_batch)
@@ -1256,7 +1381,7 @@ class GMasterChangelogMixin(GMasterCommon):
                 if done:
                     xtl = (int(change.split('.')[-1]) - 1, 0)
                     self.upd_stime(xtl)
-                    map(self.changelog_done_func, changes)
+                    list(map(self.changelog_done_func, changes))
                     self.archive_and_purge_changelogs(changes)
                 break
             # it's either entry_ops() or Rsync that failed to do it's
@@ -1267,7 +1392,7 @@ class GMasterChangelogMixin(GMasterCommon):
             # again.
             # TODO: remove entry retries when it's gets fixed.
             logging.warn(lf('incomplete sync, retrying changelogs',
-                            files=map(os.path.basename, changes)))
+                            files=list(map(os.path.basename, changes))))
 
             # Reset the Data counter before Retry
             self.status.dec_value("data", self.files_in_batch)
@@ -1331,8 +1456,7 @@ class GMasterChangelogMixin(GMasterCommon):
         # Update last_synced_time in status file based on stime
         # only update stime if stime xattr set to Brick root
         if path == self.FLAT_DIR_HIERARCHY:
-            chkpt_time = gconf.configinterface.get_realtime(
-                "checkpoint")
+            chkpt_time = gconf.getr("checkpoint")
             checkpoint_time = 0
             if chkpt_time is not None:
                 checkpoint_time = int(chkpt_time)
@@ -1340,10 +1464,10 @@ class GMasterChangelogMixin(GMasterCommon):
             self.status.set_last_synced(stime, checkpoint_time)
 
     def update_worker_remote_node(self):
-        node = sys.argv[-1]
+        node = rconf.args.resource_remote
         node_data = node.split("@")
         node = node_data[-1]
-        remote_node_ip = node.split(":")[0]
+        remote_node_ip, _ = host_brick_split(node)
         self.status.set_slave_node(remote_node_ip)
 
     def changelogs_batch_process(self, changes):
@@ -1351,7 +1475,7 @@ class GMasterChangelogMixin(GMasterCommon):
         current_size = 0
         for c in changes:
             si = os.lstat(c).st_size
-            if (si + current_size) > int(gconf.changelog_batch_size):
+            if (si + current_size) > gconf.get("changelog-batch-size"):
                 # Create new batch if single Changelog file greater than
                 # Max Size! or current batch size exceeds Max size
                 changelogs_batches.append([c])
@@ -1376,9 +1500,9 @@ class GMasterChangelogMixin(GMasterCommon):
         # that are _historical_ to that time.
         data_stime = self.get_data_stime()
 
-        self.changelog_agent.scan()
+        libgfchangelog.scan()
         self.crawls += 1
-        changes = self.changelog_agent.getchanges()
+        changes = libgfchangelog.getchanges()
         if changes:
             if data_stime:
                 logging.info(lf("slave's time",
@@ -1395,10 +1519,9 @@ class GMasterChangelogMixin(GMasterCommon):
 
         self.changelogs_batch_process(changes)
 
-    def register(self, register_time, changelog_agent, status):
-        self.changelog_agent = changelog_agent
-        self.sleep_interval = int(gconf.change_interval)
-        self.changelog_done_func = self.changelog_agent.done
+    def register(self, register_time, status):
+        self.sleep_interval = gconf.get("change-interval")
+        self.changelog_done_func = libgfchangelog.done
         self.tempdir = self.setup_working_dir()
         self.processed_changelogs_dir = os.path.join(self.tempdir,
                                                      ".processed")
@@ -1407,11 +1530,10 @@ class GMasterChangelogMixin(GMasterCommon):
 
 
 class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
-    def register(self, register_time, changelog_agent, status):
-        self.changelog_agent = changelog_agent
+    def register(self, register_time, status):
         self.changelog_register_time = register_time
         self.history_crawl_start_time = register_time
-        self.changelog_done_func = self.changelog_agent.history_done
+        self.changelog_done_func = libgfchangelog.history_done
         self.history_turns = 0
         self.tempdir = self.setup_working_dir()
         self.processed_changelogs_dir = os.path.join(self.tempdir,
@@ -1425,6 +1547,12 @@ class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
         data_stime = self.get_data_stime()
 
         end_time = int(time.time())
+
+        #as start of historical crawl marks Geo-rep worker restart
+        if gconf.get("ignore-deletes"):
+            logging.info(lf('ignore-deletes config option is set',
+                         stime=data_stime))
+
         logging.info(lf('starting history crawl',
                         turns=self.history_turns,
                         stime=data_stime,
@@ -1437,13 +1565,13 @@ class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
         # Changelogs backend path is hardcoded as
         # <BRICK_PATH>/.glusterfs/changelogs, if user configured to different
         # location then consuming history will not work(Known issue as of now)
-        changelog_path = os.path.join(gconf.local_path,
+        changelog_path = os.path.join(rconf.args.local_path,
                                       ".glusterfs/changelogs")
-        ret, actual_end = self.changelog_agent.history(
+        ret, actual_end = libgfchangelog.history_changelog(
             changelog_path,
             data_stime[0],
             end_time,
-            int(gconf.sync_jobs))
+            gconf.get("sync-jobs"))
 
         # scan followed by getchanges till scan returns zero.
         # history_scan() is blocking call, till it gets the number
@@ -1451,10 +1579,10 @@ class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
         # to be processed. returns positive value as number of changelogs
         # to be processed, which will be fetched using
         # history_getchanges()
-        while self.changelog_agent.history_scan() > 0:
+        while libgfchangelog.history_scan() > 0:
             self.crawls += 1
 
-            changes = self.changelog_agent.history_getchanges()
+            changes = libgfchangelog.history_getchanges()
             if changes:
                 if data_stime:
                     logging.info(lf("slave's time",
@@ -1488,7 +1616,7 @@ class GMasterChangeloghistoryMixin(GMasterChangelogMixin):
                 self.history_crawl_start_time = int(time.time())
                 self.crawl()
             else:
-                # This exeption will be catched in resource.py and
+                # This exception will be caught in resource.py and
                 # fallback to xsync for the small gap.
                 raise PartialHistoryAvailable(str(actual_end))
 
@@ -1507,7 +1635,7 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
 
     XSYNC_MAX_ENTRIES = 1 << 13
 
-    def register(self, register_time=None, changelog_agent=None, status=None):
+    def register(self, register_time=None, status=None):
         self.status = status
         self.counter = 0
         self.comlist = []
@@ -1527,6 +1655,11 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
                 pass
             else:
                 raise
+        # Purge stale unprocessed xsync changelogs
+        for f in os.listdir(self.tempdir):
+            if f.startswith("XSYNC-CHANGELOG"):
+                os.remove(os.path.join(self.tempdir, f))
+
 
     def crawl(self):
         """
@@ -1620,7 +1753,7 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
     def is_sticky(self, path, mo):
         """check for DHTs linkto sticky bit file"""
         sticky = False
-        if mo & 01000:
+        if mo & 0o1000:
             sticky = self.master.server.linkto_check(path)
         return sticky
 
@@ -1639,8 +1772,8 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
             if isinstance(xtr_root, int):
                 if xtr_root != ENOENT:
                     logging.warn(lf("slave cluster not returning the "
-                                    "correct xtime for root",
-                                    xtime=xtr_root))
+                                    "xtime for root",
+                                    error=xtr_root))
                 xtr_root = self.minus_infinity
         xtl = self.xtime(path)
         if isinstance(xtl, int):
@@ -1649,9 +1782,9 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
         if isinstance(xtr, int):
             if xtr != ENOENT:
                 logging.warn(lf("slave cluster not returning the "
-                                "correct xtime",
+                                "xtime for dir",
                                 path=path,
-                                xtime=xtr))
+                                error=xtr))
             xtr = self.minus_infinity
         xtr = max(xtr, xtr_root)
         zero_zero = (0, 0)
@@ -1736,7 +1869,8 @@ class GMasterXsyncMixin(GMasterChangelogMixin):
                                             [gfid, 'MKNOD', str(mo),
                                              str(0), str(0),
                                              escape_space_newline(
-                                                 os.path.join(pargfid, bname))])
+                                                 os.path.join(
+                                                     pargfid, bname))])
                 else:
                     self.write_entry_change(
                         "E", [gfid, 'LINK', escape_space_newline(
@@ -1837,8 +1971,8 @@ class Syncer(object):
         self.pb = PostBox()
         self.sync_engine = sync_engine
         self.errnos_ok = resilient_errnos
-        for i in range(int(gconf.sync_jobs)):
-            t = Thread(target=self.syncjob, args=(i+1, ))
+        for i in range(gconf.get("sync-jobs")):
+            t = Thread(target=self.syncjob, args=(i + 1, ))
             t.start()
 
     def syncjob(self, job_id):
diff --git a/geo-replication/syncdaemon/monitor.py b/geo-replication/syncdaemon/monitor.py
index 4da933047c8..6aa7b9dfc99 100644
--- a/geo-replication/syncdaemon/monitor.py
+++ b/geo-replication/syncdaemon/monitor.py
@@ -13,22 +13,23 @@ import sys
 import time
 import signal
 import logging
-import uuid
 import xml.etree.ElementTree as XET
-from subprocess import PIPE
-from resource import Popen, FILE, GLUSTER, SSH
 from threading import Lock
 from errno import ECHILD, ESRCH
-import re
 import random
-from gconf import gconf
-from syncdutils import select, waitpid, errno_wrap, lf
-from syncdutils import set_term_handler, is_host_local, GsyncdError
-from syncdutils import escape, Thread, finalize, memoize
-from syncdutils import gf_event, EVENT_GEOREP_FAULTY
 
+from resource import SSH
+import gsyncdconfig as gconf
+import libgfchangelog
+from rconf import rconf
+from syncdutils import (select, waitpid, errno_wrap, lf, grabpidfile,
+                        set_term_handler, GsyncdError,
+                        Thread, finalize, Volinfo, VolinfoFromGconf,
+                        gf_event, EVENT_GEOREP_FAULTY, get_up_nodes,
+                        unshare_propagation_supported)
 from gsyncdstatus import GeorepStatus, set_monitor_status
-
+import py2py3
+from py2py3 import pipe
 
 ParseError = XET.ParseError if hasattr(XET, 'ParseError') else SyntaxError
 
@@ -37,6 +38,8 @@ def get_subvol_num(brick_idx, vol, hot):
     tier = vol.is_tier()
     disperse_count = vol.disperse_count(tier, hot)
     replica_count = vol.replica_count(tier, hot)
+    distribute_count = vol.distribution_count(tier, hot)
+    gconf.setconfig("master-distribution-count", distribute_count)
 
     if (tier and not hot):
         brick_idx = brick_idx - vol.get_hot_bricks_count(tier)
@@ -55,122 +58,6 @@ def get_subvol_num(brick_idx, vol, hot):
         return str(cnt)
 
 
-def get_slave_bricks_status(host, vol):
-    po = Popen(['gluster', '--xml', '--remote-host=' + host,
-                'volume', 'status', vol, "detail"],
-               stdout=PIPE, stderr=PIPE)
-    vix = po.stdout.read()
-    po.wait()
-    po.terminate_geterr(fail_on_err=False)
-    if po.returncode != 0:
-        logging.info(lf("Volume status command failed, unable to get "
-                        "list of up nodes, returning empty list",
-                        volume=vol,
-                        error=po.returncode))
-        return []
-    vi = XET.fromstring(vix)
-    if vi.find('opRet').text != '0':
-        logging.info(lf("Unable to get list of up nodes, "
-                        "returning empty list",
-                        volume=vol,
-                        error=vi.find('opErrstr').text))
-        return []
-
-    up_hosts = set()
-
-    try:
-        for el in vi.findall('volStatus/volumes/volume/node'):
-            if el.find('status').text == '1':
-                up_hosts.add(el.find('hostname').text)
-    except (ParseError, AttributeError, ValueError) as e:
-        logging.info(lf("Parsing failed to get list of up nodes, "
-                        "returning empty list",
-                        volume=vol,
-                        error=e))
-
-    return list(up_hosts)
-
-
-class Volinfo(object):
-
-    def __init__(self, vol, host='localhost', prelude=[]):
-        po = Popen(prelude + ['gluster', '--xml', '--remote-host=' + host,
-                              'volume', 'info', vol],
-                   stdout=PIPE, stderr=PIPE)
-        vix = po.stdout.read()
-        po.wait()
-        po.terminate_geterr()
-        vi = XET.fromstring(vix)
-        if vi.find('opRet').text != '0':
-            if prelude:
-                via = '(via %s) ' % prelude.join(' ')
-            else:
-                via = ' '
-            raise GsyncdError('getting volume info of %s%s '
-                              'failed with errorcode %s' %
-                              (vol, via, vi.find('opErrno').text))
-        self.tree = vi
-        self.volume = vol
-        self.host = host
-
-    def get(self, elem):
-        return self.tree.findall('.//' + elem)
-
-    def is_tier(self):
-        return (self.get('typeStr')[0].text == 'Tier')
-
-    def is_hot(self, brickpath):
-        logging.debug('brickpath: ' + repr(brickpath))
-        return brickpath in self.hot_bricks
-
-    @property
-    @memoize
-    def bricks(self):
-        def bparse(b):
-            host, dirp = b.find("name").text.split(':', 2)
-            return {'host': host, 'dir': dirp, 'uuid': b.find("hostUuid").text}
-        return [bparse(b) for b in self.get('brick')]
-
-    @property
-    @memoize
-    def uuid(self):
-        ids = self.get('id')
-        if len(ids) != 1:
-            raise GsyncdError("volume info of %s obtained from %s: "
-                              "ambiguous uuid" % (self.volume, self.host))
-        return ids[0].text
-
-    def replica_count(self, tier, hot):
-        if (tier and hot):
-            return int(self.get('hotBricks/hotreplicaCount')[0].text)
-        elif (tier and not hot):
-            return int(self.get('coldBricks/coldreplicaCount')[0].text)
-        else:
-            return int(self.get('replicaCount')[0].text)
-
-    def disperse_count(self, tier, hot):
-        if (tier and hot):
-            # Tiering doesn't support disperse volume as hot brick,
-            # hence no xml output, so returning 0. In case, if it's
-            # supported later, we should change here.
-            return 0
-        elif (tier and not hot):
-            return int(self.get('coldBricks/colddisperseCount')[0].text)
-        else:
-            return int(self.get('disperseCount')[0].text)
-
-    @property
-    @memoize
-    def hot_bricks(self):
-        return [b.text for b in self.get('hotBricks/brick')]
-
-    def get_hot_bricks_count(self, tier):
-        if (tier):
-            return int(self.get('hotBricks/hotbrickCount')[0].text)
-        else:
-            return 0
-
-
 class Monitor(object):
 
     """class which spawns and manages gsyncd workers"""
@@ -195,7 +82,8 @@ class Monitor(object):
         # give a chance to graceful exit
         errno_wrap(os.kill, [-os.getpid(), signal.SIGTERM], [ESRCH])
 
-    def monitor(self, w, argv, cpids, agents, slave_vol, slave_host, master):
+    def monitor(self, w, argv, cpids, slave_vol, slave_host, master,
+                suuid, slavenodes):
         """the monitor loop
 
         Basic logic is a blantantly simple blunt heuristics:
@@ -215,17 +103,13 @@ class Monitor(object):
         due to the keep-alive thread)
         """
         if not self.status.get(w[0]['dir'], None):
-            self.status[w[0]['dir']] = GeorepStatus(gconf.state_file,
+            self.status[w[0]['dir']] = GeorepStatus(gconf.get("state-file"),
                                                     w[0]['host'],
                                                     w[0]['dir'],
                                                     w[0]['uuid'],
                                                     master,
                                                     "%s::%s" % (slave_host,
                                                                 slave_vol))
-
-        set_monitor_status(gconf.state_file, self.ST_STARTED)
-        self.status[w[0]['dir']].set_worker_status(self.ST_INIT)
-
         ret = 0
 
         def nwait(p, o=0):
@@ -243,7 +127,7 @@ class Monitor(object):
                     raise
 
         def exit_signalled(s):
-            """ child teminated due to receipt of SIGUSR1 """
+            """ child terminated due to receipt of SIGUSR1 """
             return (os.WIFSIGNALED(s) and (os.WTERMSIG(s) == signal.SIGUSR1))
 
         def exit_status(s):
@@ -251,84 +135,76 @@ class Monitor(object):
                 return os.WEXITSTATUS(s)
             return 1
 
-        conn_timeout = int(gconf.connection_timeout)
+        conn_timeout = gconf.get("connection-timeout")
         while ret in (0, 1):
-            remote_host = w[1]
+            remote_user, remote_host = w[1][0].split("@")
+            remote_id = w[1][1]
             # Check the status of the connected slave node
             # If the connected slave node is down then try to connect to
             # different up node.
-            m = re.match("(ssh|gluster|file):\/\/(.+)@([^:]+):(.+)",
-                         remote_host)
-            if m:
-                current_slave_host = m.group(3)
-                slave_up_hosts = get_slave_bricks_status(
-                    slave_host, slave_vol)
-
-                if current_slave_host not in slave_up_hosts:
-                    if len(slave_up_hosts) > 0:
-                        remote_host = "%s://%s@%s:%s" % (m.group(1),
-                                                         m.group(2),
-                                                         random.choice(
-                                                             slave_up_hosts),
-                                                         m.group(4))
-
-            # Spawn the worker and agent in lock to avoid fd leak
+            current_slave_host = remote_host
+            slave_up_hosts = get_up_nodes(slavenodes, gconf.get("ssh-port"))
+
+            if (current_slave_host, remote_id) not in slave_up_hosts:
+                if len(slave_up_hosts) > 0:
+                    remote_new = random.choice(slave_up_hosts)
+                    remote_host = "%s@%s" % (remote_user, remote_new[0])
+                    remote_id = remote_new[1]
+
+            # Spawn the worker in lock to avoid fd leak
             self.lock.acquire()
 
+            self.status[w[0]['dir']].set_worker_status(self.ST_INIT)
             logging.info(lf('starting gsyncd worker',
                             brick=w[0]['dir'],
                             slave_node=remote_host))
 
-            # Couple of pipe pairs for RPC communication b/w
-            # worker and changelog agent.
-
-            # read/write end for agent
-            (ra, ww) = os.pipe()
-            # read/write end for worker
-            (rw, wa) = os.pipe()
-
-            # spawn the agent process
-            apid = os.fork()
-            if apid == 0:
-                os.close(rw)
-                os.close(ww)
-                os.execv(sys.executable, argv + ['--local-path', w[0]['dir'],
-                                                 '--local-node', w[0]['host'],
-                                                 '--local-node-id',
-                                                 w[0]['uuid'],
-                                                 '--agent',
-                                                 '--rpc-fd',
-                                                 ','.join([str(ra), str(wa),
-                                                           str(rw), str(ww)])])
-            pr, pw = os.pipe()
+            pr, pw = pipe()
             cpid = os.fork()
             if cpid == 0:
                 os.close(pr)
-                os.close(ra)
-                os.close(wa)
-                os.execv(sys.executable, argv + ['--feedback-fd', str(pw),
-                                                 '--local-path', w[0]['dir'],
-                                                 '--local-node', w[0]['host'],
-                                                 '--local-node-id',
-                                                 w[0]['uuid'],
-                                                 '--local-id',
-                                                 '.' + escape(w[0]['dir']),
-                                                 '--rpc-fd',
-                                                 ','.join([str(rw), str(ww),
-                                                           str(ra), str(wa)]),
-                                                 '--subvol-num', str(w[2])] +
-                         (['--is-hottier'] if w[3] else []) +
-                         ['--resource-remote', remote_host])
+
+                args_to_worker = argv + [
+                    'worker',
+                    rconf.args.master,
+                    rconf.args.slave,
+                    '--feedback-fd', str(pw),
+                    '--local-path', w[0]['dir'],
+                    '--local-node', w[0]['host'],
+                    '--local-node-id', w[0]['uuid'],
+                    '--slave-id', suuid,
+                    '--subvol-num', str(w[2]),
+                    '--resource-remote', remote_host,
+                    '--resource-remote-id', remote_id
+                ]
+
+                if rconf.args.config_file is not None:
+                    args_to_worker += ['-c', rconf.args.config_file]
+
+                if w[3]:
+                    args_to_worker.append("--is-hottier")
+
+                if rconf.args.debug:
+                    args_to_worker.append("--debug")
+
+                access_mount = gconf.get("access-mount")
+                if access_mount:
+                    os.execv(sys.executable, args_to_worker)
+                else:
+                    if unshare_propagation_supported():
+                        logging.debug("Worker would mount volume privately")
+                        unshare_cmd = ['unshare', '-m', '--propagation',
+                                       'private']
+                        cmd = unshare_cmd + args_to_worker
+                        os.execvp("unshare", cmd)
+                    else:
+                        logging.debug("Mount is not private. It would be lazy"
+                                      " umounted")
+                        os.execv(sys.executable, args_to_worker)
 
             cpids.add(cpid)
-            agents.add(apid)
             os.close(pw)
 
-            # close all RPC pipes in monitor
-            os.close(ra)
-            os.close(wa)
-            os.close(rw)
-            os.close(ww)
             self.lock.release()
 
             t0 = time.time()
@@ -337,41 +213,19 @@ class Monitor(object):
 
             if so:
                 ret = nwait(cpid, os.WNOHANG)
-                ret_agent = nwait(apid, os.WNOHANG)
-
-                if ret_agent is not None:
-                    # Agent is died Kill Worker
-                    logging.info(lf("Changelog Agent died, Aborting Worker",
-                                    brick=w[0]['dir']))
-                    errno_wrap(os.kill, [cpid, signal.SIGKILL], [ESRCH])
-                    nwait(cpid)
-                    nwait(apid)
 
                 if ret is not None:
                     logging.info(lf("worker died before establishing "
                                     "connection",
                                     brick=w[0]['dir']))
-                    nwait(apid)  # wait for agent
                 else:
                     logging.debug("worker(%s) connected" % w[0]['dir'])
                     while time.time() < t0 + conn_timeout:
                         ret = nwait(cpid, os.WNOHANG)
-                        ret_agent = nwait(apid, os.WNOHANG)
 
                         if ret is not None:
                             logging.info(lf("worker died in startup phase",
                                             brick=w[0]['dir']))
-                            nwait(apid)  # wait for agent
-                            break
-
-                        if ret_agent is not None:
-                            # Agent is died Kill Worker
-                            logging.info(lf("Changelog Agent died, Aborting "
-                                            "Worker",
-                                            brick=w[0]['dir']))
-                            errno_wrap(os.kill, [cpid, signal.SIGKILL], [ESRCH])
-                            nwait(cpid)
-                            nwait(apid)
                             break
 
                         time.sleep(1)
@@ -386,12 +240,8 @@ class Monitor(object):
                        brick=w[0]['dir'],
                        timeout=conn_timeout))
                 errno_wrap(os.kill, [cpid, signal.SIGKILL], [ESRCH])
-                nwait(apid)  # wait for agent
                 ret = nwait(cpid)
             if ret is None:
-                # If worker dies, agent terminates on EOF.
-                # So lets wait for agent first.
-                nwait(apid)
                 ret = nwait(cpid)
             if exit_signalled(ret):
                 ret = 0
@@ -411,104 +261,135 @@ class Monitor(object):
         self.status[w[0]['dir']].set_worker_status(self.ST_INCON)
         return ret
 
-    def multiplex(self, wspx, suuid, slave_vol, slave_host, master):
-        argv = sys.argv[:]
-        for o in ('-N', '--no-daemon', '--monitor'):
-            while o in argv:
-                argv.remove(o)
-        argv.extend(('-N', '-p', '', '--slave-id', suuid))
-        argv.insert(0, os.path.basename(sys.executable))
+    def multiplex(self, wspx, suuid, slave_vol, slave_host, master, slavenodes):
+        argv = [os.path.basename(sys.executable), sys.argv[0]]
 
         cpids = set()
-        agents = set()
         ta = []
         for wx in wspx:
             def wmon(w):
-                cpid, _ = self.monitor(w, argv, cpids, agents, slave_vol,
-                                       slave_host, master)
+                cpid, _ = self.monitor(w, argv, cpids, slave_vol,
+                                       slave_host, master, suuid, slavenodes)
                 time.sleep(1)
                 self.lock.acquire()
                 for cpid in cpids:
                     errno_wrap(os.kill, [cpid, signal.SIGKILL], [ESRCH])
-                for apid in agents:
-                    errno_wrap(os.kill, [apid, signal.SIGKILL], [ESRCH])
                 self.lock.release()
                 finalize(exval=1)
             t = Thread(target=wmon, args=[wx])
             t.start()
             ta.append(t)
+
+        # monitor status was being updated in each monitor thread. It
+        # should not be done as it can cause deadlock for a worker start.
+        # set_monitor_status uses flock to synchronize multple instances
+        # updating the file. Since each monitor thread forks worker,
+        # these processes can hold the reference to fd of status
+        # file causing deadlock to workers which starts later as flock
+        # will not be release until all references to same fd is closed.
+        # It will also cause fd leaks.
+
+        self.lock.acquire()
+        set_monitor_status(gconf.get("state-file"), self.ST_STARTED)
+        self.lock.release()
         for t in ta:
             t.join()
 
 
-def distribute(*resources):
-    master, slave = resources
-    mvol = Volinfo(master.volume, master.host)
+def distribute(master, slave):
+    if rconf.args.use_gconf_volinfo:
+        mvol = VolinfoFromGconf(master.volume, master=True)
+    else:
+        mvol = Volinfo(master.volume, master.host, master=True)
     logging.debug('master bricks: ' + repr(mvol.bricks))
     prelude = []
-    si = slave
     slave_host = None
     slave_vol = None
 
-    if isinstance(slave, SSH):
-        prelude = gconf.ssh_command.split() + [slave.remote_addr]
-        si = slave.inner_rsc
-        logging.debug('slave SSH gateway: ' + slave.remote_addr)
-    if isinstance(si, FILE):
-        sbricks = {'host': 'localhost', 'dir': si.path}
-        suuid = uuid.uuid5(uuid.NAMESPACE_URL, slave.get_url(canonical=True))
-    elif isinstance(si, GLUSTER):
-        svol = Volinfo(si.volume, slave.remote_addr.split('@')[-1])
-        sbricks = svol.bricks
-        suuid = svol.uuid
-        slave_host = slave.remote_addr.split('@')[-1]
-        slave_vol = si.volume
-
-        # save this xattr for the session delete command
-        old_stime_xattr_name = getattr(gconf, "master.stime_xattr_name", None)
-        new_stime_xattr_name = "trusted.glusterfs." + mvol.uuid + "." + \
-            svol.uuid + ".stime"
-        if not old_stime_xattr_name or \
-           old_stime_xattr_name != new_stime_xattr_name:
-            gconf.configinterface.set("master.stime_xattr_name",
-                                      new_stime_xattr_name)
+    prelude = [gconf.get("ssh-command")] + \
+        gconf.get("ssh-options").split() + \
+        ["-p", str(gconf.get("ssh-port"))] + \
+        [slave.remote_addr]
+
+    logging.debug('slave SSH gateway: ' + slave.remote_addr)
+
+    if rconf.args.use_gconf_volinfo:
+        svol = VolinfoFromGconf(slave.volume, master=False)
     else:
-        raise GsyncdError("unknown slave type " + slave.url)
+        svol = Volinfo(slave.volume, "localhost", prelude, master=False)
+
+    sbricks = svol.bricks
+    suuid = svol.uuid
+    slave_host = slave.remote_addr.split('@')[-1]
+    slave_vol = slave.volume
+
+    # save this xattr for the session delete command
+    old_stime_xattr_prefix = gconf.get("stime-xattr-prefix", None)
+    new_stime_xattr_prefix = "trusted.glusterfs." + mvol.uuid + "." + \
+                             svol.uuid
+    if not old_stime_xattr_prefix or \
+       old_stime_xattr_prefix != new_stime_xattr_prefix:
+        gconf.setconfig("stime-xattr-prefix", new_stime_xattr_prefix)
+
     logging.debug('slave bricks: ' + repr(sbricks))
-    if isinstance(si, FILE):
-        slaves = [slave.url]
-    else:
-        slavenodes = set(b['host'] for b in sbricks)
-        if isinstance(slave, SSH) and not gconf.isolated_slave:
-            rap = SSH.parse_ssh_address(slave)
-            slaves = ['ssh://' + rap['user'] + '@' + h + ':' + si.url
-                      for h in slavenodes]
-        else:
-            slavevols = [h + ':' + si.volume for h in slavenodes]
-            if isinstance(slave, SSH):
-                slaves = ['ssh://' + rap.remote_addr + ':' + v
-                          for v in slavevols]
-            else:
-                slaves = slavevols
+
+    slavenodes = set((b['host'], b["uuid"]) for b in sbricks)
+    rap = SSH.parse_ssh_address(slave)
+    slaves = [(rap['user'] + '@' + h[0], h[1]) for h in slavenodes]
 
     workerspex = []
     for idx, brick in enumerate(mvol.bricks):
-        if is_host_local(brick['uuid']):
+        if rconf.args.local_node_id == brick['uuid']:
             is_hot = mvol.is_hot(":".join([brick['host'], brick['dir']]))
             workerspex.append((brick,
                                slaves[idx % len(slaves)],
                                get_subvol_num(idx, mvol, is_hot),
                                is_hot))
     logging.debug('worker specs: ' + repr(workerspex))
-    return workerspex, suuid, slave_vol, slave_host, master
+    return workerspex, suuid, slave_vol, slave_host, master, slavenodes
 
 
-def monitor(*resources):
+def monitor(local, remote):
     # Check if gsyncd restarted in pause state. If
     # yes, send SIGSTOP to negative of monitor pid
     # to go back to pause state.
-    if gconf.pause_on_start:
+    if rconf.args.pause_on_start:
         errno_wrap(os.kill, [-os.getpid(), signal.SIGSTOP], [ESRCH])
 
     """oh yeah, actually Monitor is used as singleton, too"""
-    return Monitor().multiplex(*distribute(*resources))
+    return Monitor().multiplex(*distribute(local, remote))
+
+
+def startup(go_daemon=True):
+    """set up logging, pidfile grabbing, daemonization"""
+    pid_file = gconf.get("pid-file")
+    if not grabpidfile():
+        sys.stderr.write("pidfile is taken, exiting.\n")
+        sys.exit(2)
+    rconf.pid_file_owned = True
+
+    if not go_daemon:
+        return
+
+    x, y = pipe()
+    cpid = os.fork()
+    if cpid:
+        os.close(x)
+        sys.exit()
+    os.close(y)
+    os.setsid()
+    dn = os.open(os.devnull, os.O_RDWR)
+    for f in (sys.stdin, sys.stdout, sys.stderr):
+        os.dup2(dn, f.fileno())
+
+    if not grabpidfile(pid_file + '.tmp'):
+        raise GsyncdError("cannot grab temporary pidfile")
+
+    os.rename(pid_file + '.tmp', pid_file)
+
+    # wait for parent to terminate
+    # so we can start up with
+    # no messing from the dirty
+    # ol' bustard
+    select((x,), (), ())
+    os.close(x)
diff --git a/geo-replication/syncdaemon/py2py3.py b/geo-replication/syncdaemon/py2py3.py
new file mode 100644
index 00000000000..f9c76e1b50a
--- /dev/null
+++ b/geo-replication/syncdaemon/py2py3.py
@@ -0,0 +1,184 @@
+#
+# Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+# This file is part of GlusterFS.
+
+# This file is licensed to you under your choice of the GNU Lesser
+# General Public License, version 3 or any later version (LGPLv3 or
+# later), or the GNU General Public License, version 2 (GPLv2), in all
+# cases as published by the Free Software Foundation.
+#
+
+# All python2/python3 compatibility routines
+
+import sys
+import os
+import stat
+import struct
+from syncdutils import umask
+from ctypes import create_string_buffer
+
+if sys.version_info >= (3,):
+    def pipe():
+        (r, w) = os.pipe()
+        os.set_inheritable(r, True)
+        os.set_inheritable(w, True)
+        return (r, w)
+
+    # Raw conversion of bytearray to string. Used in the cases where
+    # buffer is created by create_string_buffer which is a 8-bit char
+    # array and passed to syscalls to fetch results. Using encode/decode
+    # doesn't work as it converts to string altering the size.
+    def bytearray_to_str(byte_arr):
+        return ''.join([chr(b) for b in byte_arr])
+
+    # Raw conversion of string to bytes. This is required to convert
+    # back the string into bytearray(c char array) to use in struc
+    # pack/unpacking. Again encode/decode can't be used as it
+    # converts it alters size.
+    def str_to_bytearray(string):
+        return bytes([ord(c) for c in string])
+
+    def gr_create_string_buffer(size):
+        return create_string_buffer(b'\0', size)
+
+    def gr_query_xattr(cls, path, size, syscall, attr=None):
+        if attr:
+            return cls._query_xattr(path.encode(), size, syscall,
+                                    attr.encode())
+        else:
+            return cls._query_xattr(path.encode(), size, syscall)
+
+    def gr_lsetxattr(cls, path, attr, val):
+        return cls.libc.lsetxattr(path.encode(), attr.encode(), val,
+                                  len(val), 0)
+
+    def gr_lremovexattr(cls, path, attr):
+        return cls.libc.lremovexattr(path.encode(), attr.encode())
+
+    def gr_cl_register(libgfapi, brick, path, log_file, log_level, retries):
+        return libgfapi.gf_changelog_register(brick.encode(),
+                                              path.encode(),
+                                              log_file.encode(),
+                                              log_level, retries)
+
+    def gr_cl_done(libgfapi, clfile):
+        return libgfapi.gf_changelog_done(clfile.encode())
+
+    def gr_cl_history_changelog(libgfapi, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return libgfapi.gf_history_changelog(changelog_path.encode(),
+                                             start, end, num_parallel,
+                                             actual_end)
+
+    def gr_cl_history_done(libgfapi, clfile):
+        return libgfapi.gf_history_changelog_done(clfile.encode())
+
+    # regular file
+
+    def entry_pack_reg(cls, gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(cls._fmt_mknod(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), 0, umask())
+
+    def entry_pack_reg_stat(cls, gf, bn, st):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        mo = st['mode']
+        return struct.pack(cls._fmt_mknod(blen),
+                           st['uid'], st['gid'],
+                           gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), 0, umask())
+    # mkdir
+
+    def entry_pack_mkdir(cls, gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(cls._fmt_mkdir(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), umask())
+    # symlink
+
+    def entry_pack_symlink(cls, gf, bn, lnk, st):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        lnk_encoded = lnk.encode()
+        llen = len(lnk_encoded)
+        return struct.pack(cls._fmt_symlink(blen, llen),
+                           st['uid'], st['gid'],
+                           gf.encode(), st['mode'], bn_encoded,
+                           lnk_encoded)
+else:
+    def pipe():
+        (r, w) = os.pipe()
+        return (r, w)
+
+    # Raw conversion of bytearray to string
+    def bytearray_to_str(byte_arr):
+        return byte_arr
+
+    # Raw conversion of string to bytearray
+    def str_to_bytearray(string):
+        return string
+
+    def gr_create_string_buffer(size):
+        return create_string_buffer('\0', size)
+
+    def gr_query_xattr(cls, path, size, syscall, attr=None):
+        if attr:
+            return cls._query_xattr(path, size, syscall, attr)
+        else:
+            return cls._query_xattr(path, size, syscall)
+
+    def gr_lsetxattr(cls, path, attr, val):
+        return cls.libc.lsetxattr(path, attr, val, len(val), 0)
+
+    def gr_lremovexattr(cls, path, attr):
+        return cls.libc.lremovexattr(path, attr)
+
+    def gr_cl_register(libgfapi, brick, path, log_file, log_level, retries):
+        return libgfapi.gf_changelog_register(brick, path, log_file,
+                                              log_level, retries)
+
+    def gr_cl_done(libgfapi, clfile):
+        return libgfapi.gf_changelog_done(clfile)
+
+    def gr_cl_history_changelog(libgfapi, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return libgfapi.gf_history_changelog(changelog_path, start, end,
+                                             num_parallel, actual_end)
+
+    def gr_cl_history_done(libgfapi, clfile):
+        return libgfapi.gf_history_changelog_done(clfile)
+
+    # regular file
+
+    def entry_pack_reg(cls, gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(cls._fmt_mknod(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), 0, umask())
+
+    def entry_pack_reg_stat(cls, gf, bn, st):
+        blen = len(bn)
+        mo = st['mode']
+        return struct.pack(cls._fmt_mknod(blen),
+                           st['uid'], st['gid'],
+                           gf, mo, bn,
+                           stat.S_IMODE(mo), 0, umask())
+    # mkdir
+
+    def entry_pack_mkdir(cls, gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(cls._fmt_mkdir(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), umask())
+    # symlink
+
+    def entry_pack_symlink(cls, gf, bn, lnk, st):
+        blen = len(bn)
+        llen = len(lnk)
+        return struct.pack(cls._fmt_symlink(blen, llen),
+                           st['uid'], st['gid'],
+                           gf, st['mode'], bn, lnk)
diff --git a/geo-replication/syncdaemon/gconf.py b/geo-replication/syncdaemon/rconf.py
index 97395b41b06..ff716ee4d6d 100644
--- a/geo-replication/syncdaemon/gconf.py
+++ b/geo-replication/syncdaemon/rconf.py
@@ -9,9 +9,9 @@
 #
 
 
-class GConf(object):
+class RConf(object):
 
-    """singleton class to store globals
+    """singleton class to store runtime globals
        shared between gsyncd modules"""
 
     ssh_ctl_dir = None
@@ -21,12 +21,11 @@ class GConf(object):
     log_exit = False
     permanent_handles = []
     log_metadata = {}
-    """One variable is sufficient to track the
-       switching of worker to ACTIVE. Two variables
-       are intentionally used to track worker going
-       to PASSIVE as well mainly for debugging"""
-    active_earlier = False
-    passive_earlier = False
     mgmt_lock_fd = None
+    args = None
+    turns = 0
+    mountbroker = False
+    mount_point = None
+    mbr_umount_cmd = []
 
-gconf = GConf()
+rconf = RConf()
diff --git a/geo-replication/syncdaemon/repce.py b/geo-replication/syncdaemon/repce.py
index 0ac144930db..c622afa6373 100644
--- a/geo-replication/syncdaemon/repce.py
+++ b/geo-replication/syncdaemon/repce.py
@@ -14,30 +14,27 @@ import time
 import logging
 from threading import Condition
 try:
-    import thread
-except ImportError:
-    # py 3
     import _thread as thread
-try:
-    from Queue import Queue
 except ImportError:
-    # py 3
+    import thread
+try:
     from queue import Queue
+except ImportError:
+    from Queue import Queue
 try:
     import cPickle as pickle
 except ImportError:
-    # py 3
     import pickle
 
 from syncdutils import Thread, select, lf
 
-pickle_proto = -1
+pickle_proto = 2
 repce_version = 1.0
 
 
 def ioparse(i, o):
     if isinstance(i, int):
-        i = os.fdopen(i)
+        i = os.fdopen(i, 'rb')
     # rely on duck typing for recognizing
     # streams as that works uniformly
     # in py2 and py3
@@ -57,8 +54,15 @@ def send(out, *args):
 
 
 def recv(inf):
-    """load an object from input stream"""
-    return pickle.load(inf)
+    """load an object from input stream
+    python2 and python3 compatibility, inf is sys.stdin
+    and is opened as text stream by default. Hence using the
+    buffer attribute in python3
+    """
+    if hasattr(inf, "buffer"):
+        return pickle.load(inf.buffer)
+    else:
+        return pickle.load(inf)
 
 
 class RepceServer(object):
@@ -196,14 +200,14 @@ class RepceClient(object):
         """RePCe client is callabe, calling it implements a synchronous
         remote call.
 
-        We do a .push with a cbk which does a wakeup upon receiving anwser,
+        We do a .push with a cbk which does a wakeup upon receiving answer,
         then wait on the RepceJob.
         """
         rjob = self.push(
             meth, *args, **{'cbk': lambda rj, res: rj.wakeup(res)})
         exc, res = rjob.wait()
         if exc:
-            logging.error(lf('call failed on peer',
+            logging.error(lf('call failed',
                              call=repr(rjob),
                              method=meth,
                              error=str(type(res).__name__)))
diff --git a/geo-replication/syncdaemon/resource.py b/geo-replication/syncdaemon/resource.py
index 0ca023cd8c5..f12c7ceaa36 100644
--- a/geo-replication/syncdaemon/resource.py
+++ b/geo-replication/syncdaemon/resource.py
@@ -13,248 +13,43 @@ import os
 import sys
 import stat
 import time
-import signal
 import fcntl
-import errno
 import types
 import struct
-import socket
 import logging
 import tempfile
-import threading
 import subprocess
+from errno import (EEXIST, ENOENT, ENODATA, ENOTDIR, ELOOP, EACCES,
+                   EISDIR, ENOTEMPTY, ESTALE, EINVAL, EBUSY, EPERM)
 import errno
-from errno import EEXIST, ENOENT, ENODATA, ENOTDIR, ELOOP, EACCES
-from errno import EISDIR, ENOTEMPTY, ESTALE, EINVAL, EBUSY, EPERM
-from select import error as SelectError
-import shutil
 
-from gconf import gconf
+from rconf import rconf
+import gsyncdconfig as gconf
+import libgfchangelog
+
 import repce
 from repce import RepceServer, RepceClient
 from master import gmaster_builder
 import syncdutils
-from syncdutils import GsyncdError, select, privileged, boolify, funcode
-from syncdutils import umask, entry2pb, gauxpfx, errno_wrap, lstat
-from syncdutils import NoStimeAvailable, PartialHistoryAvailable
-from syncdutils import ChangelogException, ChangelogHistoryNotAvailable
-from syncdutils import get_changelog_log_level, get_rsync_version
-from syncdutils import CHANGELOG_AGENT_CLIENT_VERSION
-from syncdutils import GX_GFID_CANONICAL_LEN
+from syncdutils import (GsyncdError, select, privileged, funcode,
+                        entry2pb, gauxpfx, errno_wrap, lstat,
+                        NoStimeAvailable, PartialHistoryAvailable,
+                        ChangelogException, ChangelogHistoryNotAvailable,
+                        get_changelog_log_level, get_rsync_version,
+                        GX_GFID_CANONICAL_LEN,
+                        gf_mount_ready, lf, Popen, sup,
+                        Xattr, matching_disk_gfid, get_gfid_from_mnt,
+                        unshare_propagation_supported, get_slv_dir_path)
 from gsyncdstatus import GeorepStatus
-from syncdutils import get_master_and_slave_data_from_args
-from syncdutils import mntpt_list, lf
-from syncdutils import Xattr, matching_disk_gfid, get_gfid_from_mnt
+from py2py3 import (pipe, str_to_bytearray, entry_pack_reg,
+                    entry_pack_reg_stat, entry_pack_mkdir,
+                    entry_pack_symlink)
 
-UrlRX = re.compile('\A(\w+)://([^ *?[]*)\Z')
-HostRX = re.compile('[a-zA-Z\d](?:[a-zA-Z\d.-]*[a-zA-Z\d])?', re.I)
-UserRX = re.compile("[\w!\#$%&'*+-\/=?^_`{|}~]+")
 
 ENOTSUP = getattr(errno, 'ENOTSUP', 'EOPNOTSUPP')
 
-def sup(x, *a, **kw):
-    """a rubyesque "super" for python ;)
-
-    invoke caller method in parent class with given args.
-    """
-    return getattr(super(type(x), x),
-                   sys._getframe(1).f_code.co_name)(*a, **kw)
-
-
-def desugar(ustr):
-    """transform sugared url strings to standard <scheme>://<urlbody> form
-
-    parsing logic enforces the constraint that sugared forms should contatin
-    a ':' or a '/', which ensures that sugared urls do not conflict with
-    gluster volume names.
-    """
-    m = re.match('([^:]*):(.*)', ustr)
-    if m:
-        if not m.groups()[0]:
-            return "gluster://localhost" + ustr
-        elif '@' in m.groups()[0] or re.search('[:/]', m.groups()[1]):
-            return "ssh://" + ustr
-        else:
-            return "gluster://" + ustr
-    else:
-        if ustr[0] != '/':
-            raise GsyncdError("cannot resolve sugared url '%s'" % ustr)
-        ap = os.path.normpath(ustr)
-        if ap.startswith('//'):
-            ap = ap[1:]
-        return "file://" + ap
-
-
-def gethostbyname(hnam):
-    """gethostbyname wrapper"""
-    try:
-        return socket.gethostbyname(hnam)
-    except socket.gaierror:
-        ex = sys.exc_info()[1]
-        raise GsyncdError("failed to resolve %s: %s" %
-                          (hnam, ex.strerror))
-
-
-def parse_url(ustr):
-    """instantiate an url object by scheme-to-class dispatch
-
-    The url classes taken into consideration are the ones in
-    this module whose names are full-caps.
-    """
-    m = UrlRX.match(ustr)
-    if not m:
-        ustr = desugar(ustr)
-    m = UrlRX.match(ustr)
-    if not m:
-        raise GsyncdError("malformed url")
-    sch, path = m.groups()
-    this = sys.modules[__name__]
-    if not hasattr(this, sch.upper()):
-        raise GsyncdError("unknown url scheme " + sch)
-    return getattr(this, sch.upper())(path)
-
-
-class Popen(subprocess.Popen):
-
-    """customized subclass of subprocess.Popen with a ring
-    buffer for children error output"""
-
-    @classmethod
-    def init_errhandler(cls):
-        """start the thread which handles children's error output"""
-        cls.errstore = {}
-
-        def tailer():
-            while True:
-                errstore = cls.errstore.copy()
-                try:
-                    poe, _, _ = select(
-                        [po.stderr for po in errstore], [], [], 1)
-                except (ValueError, SelectError):
-                    # stderr is already closed wait for some time before
-                    # checking next error
-                    time.sleep(0.5)
-                    continue
-                for po in errstore:
-                    if po.stderr not in poe:
-                        continue
-                    po.lock.acquire()
-                    try:
-                        if po.on_death_row:
-                            continue
-                        la = errstore[po]
-                        try:
-                            fd = po.stderr.fileno()
-                        except ValueError:  # file is already closed
-                            time.sleep(0.5)
-                            continue
-
-                        try:
-                            l = os.read(fd, 1024)
-                        except OSError:
-                            time.sleep(0.5)
-                            continue
-
-                        if not l:
-                            continue
-                        tots = len(l)
-                        for lx in la:
-                            tots += len(lx)
-                        while tots > 1 << 20 and la:
-                            tots -= len(la.pop(0))
-                        la.append(l)
-                    finally:
-                        po.lock.release()
-        t = syncdutils.Thread(target=tailer)
-        t.start()
-        cls.errhandler = t
-
-    @classmethod
-    def fork(cls):
-        """fork wrapper that restarts errhandler thread in child"""
-        pid = os.fork()
-        if not pid:
-            cls.init_errhandler()
-        return pid
-
-    def __init__(self, args, *a, **kw):
-        """customizations for subprocess.Popen instantiation
-
-        - 'close_fds' is taken to be the default
-        - if child's stderr is chosen to be managed,
-          register it with the error handler thread
-        """
-        self.args = args
-        if 'close_fds' not in kw:
-            kw['close_fds'] = True
-        self.lock = threading.Lock()
-        self.on_death_row = False
-        self.elines = []
-        try:
-            sup(self, args, *a, **kw)
-        except:
-            ex = sys.exc_info()[1]
-            if not isinstance(ex, OSError):
-                raise
-            raise GsyncdError("""execution of "%s" failed with %s (%s)""" %
-                              (args[0], errno.errorcode[ex.errno],
-                               os.strerror(ex.errno)))
-        if kw.get('stderr') == subprocess.PIPE:
-            assert(getattr(self, 'errhandler', None))
-            self.errstore[self] = []
-
-    def errlog(self):
-        """make a log about child's failure event"""
-        logging.error(lf("command returned error",
-                         cmd=" ".join(self.args),
-                         error=self.returncode))
-        lp = ''
-
-        def logerr(l):
-            logging.error(self.args[0] + "> " + l)
-        for l in self.elines:
-            ls = l.split('\n')
-            ls[0] = lp + ls[0]
-            lp = ls.pop()
-            for ll in ls:
-                logerr(ll)
-        if lp:
-            logerr(lp)
-
-    def errfail(self):
-        """fail nicely if child did not terminate with success"""
-        self.errlog()
-        syncdutils.finalize(exval=1)
-
-    def terminate_geterr(self, fail_on_err=True):
-        """kill child, finalize stderr harvesting (unregister
-        from errhandler, set up .elines), fail on error if
-        asked for
-        """
-        self.lock.acquire()
-        try:
-            self.on_death_row = True
-        finally:
-            self.lock.release()
-        elines = self.errstore.pop(self)
-        if self.poll() is None:
-            self.terminate()
-            if self.poll() is None:
-                time.sleep(0.1)
-                self.kill()
-                self.wait()
-        while True:
-            if not select([self.stderr], [], [], 0.1)[0]:
-                break
-            b = os.read(self.stderr.fileno(), 1024)
-            if b:
-                elines.append(b)
-            else:
-                break
-        self.stderr.close()
-        self.elines = elines
-        if fail_on_err and self.returncode != 0:
-            self.errfail()
+slv_volume = None
+slv_host = None
 
 
 class Server(object):
@@ -300,14 +95,14 @@ class Server(object):
         fc = funcode(f)
         pi = list(fc.co_varnames).index('path')
 
-        def ff(*a):
-            path = a[pi]
+        def ff(*args):
+            path = args[pi]
             ps = path.split('/')
             if path[0] == '/' or '..' in ps:
                 raise ValueError('unsafe path')
-            a = list(a)
-            a[pi] = os.path.join(a[0].local_path, path)
-            return f(*a)
+            args = list(args)
+            args[pi] = os.path.join(args[0].local_path, path)
+            return f(*args)
         return ff
 
     @classmethod
@@ -353,6 +148,7 @@ class Server(object):
         if buf == ENOENT:
             return buf
         else:
+            buf = str_to_bytearray(buf)
             m = re.match('(.{8})(.{4})(.{4})(.{4})(.{12})', "".join(
                 ['%02x' % x for x in struct.unpack(cls.GFID_FMTSTR, buf)]))
             return '-'.join(m.groups())
@@ -443,6 +239,7 @@ class Server(object):
             val = Xattr.lgetxattr(path,
                                   '.'.join([cls.GX_NSPACE, uuid, 'xtime']),
                                   8)
+            val = str_to_bytearray(val)
             return struct.unpack('!II', val)
         except OSError:
             ex = sys.exc_info()[1]
@@ -465,6 +262,7 @@ class Server(object):
             val = Xattr.lgetxattr(path,
                                   '.'.join([cls.GX_NSPACE, uuid, 'stime']),
                                   8)
+            val = str_to_bytearray(val)
             return struct.unpack('!II', val)
         except OSError:
             ex = sys.exc_info()[1]
@@ -487,6 +285,7 @@ class Server(object):
             val = Xattr.lgetxattr(path,
                                   '.'.join([cls.GX_NSPACE, uuid, 'stime']),
                                   8)
+            val = str_to_bytearray(val)
             return struct.unpack('!II', val)
         except OSError:
             ex = sys.exc_info()[1]
@@ -510,6 +309,7 @@ class Server(object):
                                   '.'.join([cls.GX_NSPACE, uuid,
                                             'entry_stime']),
                                   8)
+            val = str_to_bytearray(val)
             return struct.unpack('!II', val)
         except OSError:
             ex = sys.exc_info()[1]
@@ -578,50 +378,31 @@ class Server(object):
     def entry_ops(cls, entries):
         pfx = gauxpfx()
         logging.debug('entries: %s' % repr(entries))
-        # regular file
-
-        def entry_pack_reg(gf, bn, mo, uid, gid):
-            blen = len(bn)
-            return struct.pack(cls._fmt_mknod(blen),
-                               uid, gid, gf, mo, bn,
-                               stat.S_IMODE(mo), 0, umask())
-
-        def entry_pack_reg_stat(gf, bn, st):
-            blen = len(bn)
-            mo = st['mode']
-            return struct.pack(cls._fmt_mknod(blen),
-                               st['uid'], st['gid'],
-                               gf, mo, bn,
-                               stat.S_IMODE(mo), 0, umask())
-        # mkdir
-
-        def entry_pack_mkdir(gf, bn, mo, uid, gid):
-            blen = len(bn)
-            return struct.pack(cls._fmt_mkdir(blen),
-                               uid, gid, gf, mo, bn,
-                               stat.S_IMODE(mo), umask())
-        # symlink
-
-        def entry_pack_symlink(gf, bn, lnk, st):
-            blen = len(bn)
-            llen = len(lnk)
-            return struct.pack(cls._fmt_symlink(blen, llen),
-                               st['uid'], st['gid'],
-                               gf, st['mode'], bn, lnk)
-
-        def entry_purge(op, entry, gfid, e):
+        dist_count = rconf.args.master_dist_count
+
+        def entry_purge(op, entry, gfid, e, uid, gid):
             # This is an extremely racy code and needs to be fixed ASAP.
             # The GFID check here is to be sure that the pargfid/bname
             # to be purged is the GFID gotten from the changelog.
             # (a stat(changelog_gfid) would also be valid here)
             # The race here is between the GFID check and the purge.
+
+            # If the entry or the gfid of the file to be deleted is not present
+            # on slave, we can ignore the unlink/rmdir
+            if isinstance(lstat(entry), int) or \
+               isinstance(lstat(os.path.join(pfx, gfid)), int):
+                return
+
             if not matching_disk_gfid(gfid, entry):
-                collect_failure(e, EEXIST)
+                collect_failure(e, EEXIST, uid, gid)
                 return
 
             if op == 'UNLINK':
                 er = errno_wrap(os.unlink, [entry], [ENOENT, ESTALE], [EBUSY])
-                return er
+                # EISDIR is safe error, ignore. This can only happen when
+                # unlink is sent from master while fixing gfid conflicts.
+                if er != EISDIR:
+                    return er
 
             elif op == 'RMDIR':
                 er = errno_wrap(os.rmdir, [entry], [ENOENT, ESTALE,
@@ -629,27 +410,40 @@ class Server(object):
                 if er == ENOTEMPTY:
                     return er
 
-        def collect_failure(e, cmd_ret, dst=False):
+        def collect_failure(e, cmd_ret, uid, gid, dst=False):
             slv_entry_info = {}
             slv_entry_info['gfid_mismatch'] = False
+            slv_entry_info['name_mismatch'] = False
             slv_entry_info['dst'] = dst
+            slv_entry_info['slave_isdir'] = False
+            slv_entry_info['slave_name'] = None
+            slv_entry_info['slave_gfid'] = None
             # We do this for failing fops on Slave
             # Master should be logging this
             if cmd_ret is None:
                 return False
 
-            if cmd_ret == EEXIST:
+            if e.get("stat", {}):
+                # Copy actual UID/GID value back to entry stat
+                e['stat']['uid'] = uid
+                e['stat']['gid'] = gid
+
+            if cmd_ret in [EEXIST, ESTALE]:
                 if dst:
                     en = e['entry1']
                 else:
                     en = e['entry']
                 disk_gfid = get_gfid_from_mnt(en)
-                if isinstance(disk_gfid, basestring) and e['gfid'] != disk_gfid:
+                if isinstance(disk_gfid, str) and \
+                   e['gfid'] != disk_gfid:
                     slv_entry_info['gfid_mismatch'] = True
                     st = lstat(en)
                     if not isinstance(st, int):
                         if st and stat.S_ISDIR(st.st_mode):
                             slv_entry_info['slave_isdir'] = True
+                            dir_name = get_slv_dir_path(slv_host, slv_volume,
+                                                        disk_gfid)
+                            slv_entry_info['slave_name'] = dir_name
                         else:
                             slv_entry_info['slave_isdir'] = False
                     slv_entry_info['slave_gfid'] = disk_gfid
@@ -695,7 +489,7 @@ class Server(object):
 
             errno_wrap(os.rmdir, [path], [ENOENT, ESTALE], [EBUSY])
 
-        def rename_with_disk_gfid_confirmation(gfid, entry, en):
+        def rename_with_disk_gfid_confirmation(gfid, entry, en, uid, gid):
             if not matching_disk_gfid(gfid, entry):
                 logging.error(lf("RENAME ignored: source entry does not match "
                                  "with on-disk gfid",
@@ -703,14 +497,13 @@ class Server(object):
                                  gfid=gfid,
                                  disk_gfid=get_gfid_from_mnt(entry),
                                  target=en))
-                collect_failure(e, EEXIST)
+                collect_failure(e, EEXIST, uid, gid)
                 return
 
             cmd_ret = errno_wrap(os.rename,
                                  [entry, en],
                                  [ENOENT, EEXIST], [ESTALE, EBUSY])
-            collect_failure(e, cmd_ret)
-
+            collect_failure(e, cmd_ret, uid, gid)
 
         for e in entries:
             blob = None
@@ -719,6 +512,12 @@ class Server(object):
             entry = e['entry']
             uid = 0
             gid = 0
+
+            # Skip entry processing if it's marked true during gfid
+            # conflict resolution
+            if e['skip_entry']:
+                continue
+
             if e.get("stat", {}):
                 # Copy UID/GID value and then reset to zero. Copied UID/GID
                 # will be used to run chown once entry is created.
@@ -731,7 +530,7 @@ class Server(object):
             if op in ['RMDIR', 'UNLINK']:
                 # Try once, if rmdir failed with ENOTEMPTY
                 # then delete recursively.
-                er = entry_purge(op, entry, gfid, e)
+                er = entry_purge(op, entry, gfid, e, uid, gid)
                 if isinstance(er, int):
                     if er == ENOTEMPTY and op == 'RMDIR':
                         # Retry if ENOTEMPTY, ESTALE
@@ -759,8 +558,8 @@ class Server(object):
                 st = lstat(slink)
                 # don't create multiple entries with same gfid
                 if isinstance(st, int):
-                    blob = entry_pack_reg(
-                        gfid, bname, e['mode'], e['uid'], e['gid'])
+                    blob = entry_pack_reg(cls, gfid, bname,
+                                          e['mode'], e['uid'], e['gid'])
                 # Self healed hardlinks are recorded as MKNOD.
                 # So if the gfid already exists, it should be
                 # processed as hard link not mknod.
@@ -768,58 +567,104 @@ class Server(object):
                     cmd_ret = errno_wrap(os.link,
                                          [slink, entry],
                                          [ENOENT, EEXIST], [ESTALE])
-                    collect_failure(e, cmd_ret)
+                    collect_failure(e, cmd_ret, uid, gid)
             elif op == 'MKDIR':
+                en = e['entry']
                 slink = os.path.join(pfx, gfid)
                 st = lstat(slink)
                 # don't create multiple entries with same gfid
                 if isinstance(st, int):
-                    blob = entry_pack_mkdir(
-                        gfid, bname, e['mode'], e['uid'], e['gid'])
+                    blob = entry_pack_mkdir(cls, gfid, bname,
+                                            e['mode'], e['uid'], e['gid'])
+                elif (isinstance(lstat(en), int) or
+                      not matching_disk_gfid(gfid, en)):
+                    # If gfid of a directory exists on slave but path based
+                    # create is getting EEXIST. This means the directory is
+                    # renamed in master but recorded as MKDIR during hybrid
+                    # crawl. Get the directory path by reading the backend
+                    # symlink and trying to rename to new name as said by
+                    # master.
+                    logging.info(lf("Special case: rename on mkdir",
+                                    gfid=gfid, entry=repr(entry)))
+                    src_entry = get_slv_dir_path(slv_host, slv_volume, gfid)
+                    if src_entry is None:
+                        collect_failure(e, ENOENT, uid, gid)
+                    if src_entry is not None and src_entry != entry:
+                        slv_entry_info = {}
+                        slv_entry_info['gfid_mismatch'] = False
+                        slv_entry_info['name_mismatch'] = True
+                        slv_entry_info['dst'] = False
+                        slv_entry_info['slave_isdir'] = True
+                        slv_entry_info['slave_gfid'] = gfid
+                        slv_entry_info['slave_entry'] = src_entry
+
+                        failures.append((e, EEXIST, slv_entry_info))
             elif op == 'LINK':
                 slink = os.path.join(pfx, gfid)
                 st = lstat(slink)
                 if isinstance(st, int):
                     (pg, bname) = entry2pb(entry)
                     if stat.S_ISREG(e['stat']['mode']):
-                        blob = entry_pack_reg_stat(gfid, bname, e['stat'])
+                        blob = entry_pack_reg_stat(cls, gfid, bname, e['stat'])
                     elif stat.S_ISLNK(e['stat']['mode']):
-                        blob = entry_pack_symlink(gfid, bname, e['link'],
+                        blob = entry_pack_symlink(cls, gfid, bname, e['link'],
                                                   e['stat'])
                 else:
                     cmd_ret = errno_wrap(os.link,
                                          [slink, entry],
                                          [ENOENT, EEXIST], [ESTALE])
-                    collect_failure(e, cmd_ret)
+                    collect_failure(e, cmd_ret, uid, gid)
             elif op == 'SYMLINK':
                 en = e['entry']
                 st = lstat(entry)
                 if isinstance(st, int):
-                    blob = entry_pack_symlink(gfid, bname, e['link'],
+                    blob = entry_pack_symlink(cls, gfid, bname, e['link'],
                                               e['stat'])
                 elif not matching_disk_gfid(gfid, en):
-                    collect_failure(e, EEXIST)
+                    collect_failure(e, EEXIST, uid, gid)
             elif op == 'RENAME':
                 en = e['entry1']
-                st = lstat(entry)
-                if isinstance(st, int):
+                # The matching disk gfid check validates two things
+                #  1. Validates name is present, return false otherwise
+                #  2. Validates gfid is same, returns false otherwise
+                # So both validations are necessary to decide src doesn't
+                # exist. We can't rely on only gfid stat as hardlink could
+                # be present and we can't rely only on name as name could
+                # exist with different gfid.
+                if not matching_disk_gfid(gfid, entry):
                     if e['stat'] and not stat.S_ISDIR(e['stat']['mode']):
-                        if stat.S_ISLNK(e['stat']['mode']) and \
-                           e['link'] is not None:
-                            st1 = lstat(en)
-                            if isinstance(st1, int):
-                                (pg, bname) = entry2pb(en)
-                                blob = entry_pack_symlink(gfid, bname,
-                                                          e['link'], e['stat'])
-                            elif not matching_disk_gfid(gfid, en):
-                                collect_failure(e, EEXIST, True)
+                        if stat.S_ISLNK(e['stat']['mode']):
+                            # src is not present, so don't sync symlink as
+                            # we don't know target. It's ok to ignore. If
+                            # it's unliked, it's fine. If it's renamed to
+                            # something else, it will be synced then.
+                            if e['link'] is not None:
+                                st1 = lstat(en)
+                                if isinstance(st1, int):
+                                    (pg, bname) = entry2pb(en)
+                                    blob = entry_pack_symlink(cls, gfid, bname,
+                                                              e['link'],
+                                                              e['stat'])
+                                elif not matching_disk_gfid(gfid, en):
+                                    collect_failure(e, EEXIST, uid, gid, True)
                         else:
-                            (pg, bname) = entry2pb(en)
-                            blob = entry_pack_reg_stat(gfid, bname, e['stat'])
+                            slink = os.path.join(pfx, gfid)
+                            st = lstat(slink)
+                            # don't create multiple entries with same gfid
+                            if isinstance(st, int):
+                                (pg, bname) = entry2pb(en)
+                                blob = entry_pack_reg_stat(cls, gfid, bname,
+                                                           e['stat'])
+                            else:
+                                cmd_ret = errno_wrap(os.link, [slink, en],
+                                                    [ENOENT, EEXIST], [ESTALE])
+                                collect_failure(e, cmd_ret, uid, gid)
                 else:
+                    st = lstat(entry)
                     st1 = lstat(en)
                     if isinstance(st1, int):
-                        rename_with_disk_gfid_confirmation(gfid, entry, en)
+                        rename_with_disk_gfid_confirmation(gfid, entry, en,
+                                                           uid, gid)
                     else:
                         if st.st_ino == st1.st_ino:
                             # we have a hard link, we can now unlink source
@@ -834,8 +679,8 @@ class Server(object):
                                     except OSError as e:
                                         if e.errno == ENOTEMPTY:
                                             logging.error(
-                                                lf("Unable to delete directory"
-                                                   ", Both Old and New"
+                                                lf("Directory Rename failed. "
+                                                   "Both Old and New"
                                                    " directories exists",
                                                    old=entry,
                                                    new=en))
@@ -843,25 +688,32 @@ class Server(object):
                                             raise
                                 else:
                                     raise
-                        elif not matching_disk_gfid(gfid, en):
-                            collect_failure(e, EEXIST, True)
+                        elif not matching_disk_gfid(gfid, en) and dist_count > 1:
+                            collect_failure(e, EEXIST, uid, gid, True)
                         else:
-                            rename_with_disk_gfid_confirmation(gfid, entry, en)
+                            # We are here which means matching_disk_gfid for
+                            # both source and destination has returned false
+                            # and distribution count for master vol is greater
+                            # then one. Which basically says both the source and
+                            # destination exist and not hardlinks.
+                            # So we are safe to go ahead with rename here.
+                            rename_with_disk_gfid_confirmation(gfid, entry, en,
+                                                               uid, gid)
             if blob:
                 cmd_ret = errno_wrap(Xattr.lsetxattr,
                                      [pg, 'glusterfs.gfid.newfile', blob],
-                                     [EEXIST, ENOENT],
+                                     [EEXIST, ENOENT, ESTALE],
                                      [ESTALE, EINVAL, EBUSY])
-                failed = collect_failure(e, cmd_ret)
+                collect_failure(e, cmd_ret, uid, gid)
 
                 # If UID/GID is different than zero that means we are trying
                 # create Entry with different UID/GID. Create Entry with
                 # UID:0 and GID:0, and then call chown to set UID/GID
                 if uid != 0 or gid != 0:
                     path = os.path.join(pfx, gfid)
-                    cmd_ret = errno_wrap(os.chown, [path, uid, gid], [ENOENT],
+                    cmd_ret = errno_wrap(os.lchown, [path, uid, gid], [ENOENT],
                                          [ESTALE, EINVAL])
-                    collect_failure(e, cmd_ret)
+                    collect_failure(e, cmd_ret, uid, gid)
 
         return failures
 
@@ -888,10 +740,8 @@ class Server(object):
             # 'lchown' 'lchmod' 'utime with no-deference' blindly.
             # But since 'lchmod' and 'utime with no de-reference' is
             # not supported in python3, we have to rely on 'chmod'
-            # and 'utime with de-reference'. But 'chmod'
-            # de-reference the symlink and gets ENOENT, EACCES,
-            # EPERM errors, hence ignoring those errors if it's on
-            # symlink file.
+            # and 'utime with de-reference'. Hence avoiding 'chmod'
+            # and 'utime' if it's symlink file.
 
             is_symlink = False
             cmd_ret = errno_wrap(os.lchown, [go, uid, gid], [ENOENT],
@@ -899,19 +749,17 @@ class Server(object):
             if isinstance(cmd_ret, int):
                 continue
 
-            cmd_ret = errno_wrap(os.chmod, [go, mode],
-                                 [ENOENT, EACCES, EPERM], [ESTALE, EINVAL])
-            if isinstance(cmd_ret, int):
-                is_symlink = os.path.islink(go)
-                if not is_symlink:
+            is_symlink = os.path.islink(go)
+
+            if not is_symlink:
+                cmd_ret = errno_wrap(os.chmod, [go, mode],
+                                     [ENOENT, EACCES, EPERM], [ESTALE, EINVAL])
+                if isinstance(cmd_ret, int):
                     failures.append((e, cmd_ret, "chmod"))
 
-            cmd_ret = errno_wrap(os.utime, [go, (atime, mtime)],
-                                 [ENOENT, EACCES, EPERM], [ESTALE, EINVAL])
-            if isinstance(cmd_ret, int):
-                if not is_symlink:
-                    is_symlink = os.path.islink(go)
-                if not is_symlink:
+                cmd_ret = errno_wrap(os.utime, [go, (atime, mtime)],
+                                     [ENOENT, EACCES, EPERM], [ESTALE, EINVAL])
+                if isinstance(cmd_ret, int):
                     failures.append((e, cmd_ret, "utime"))
         return failures
 
@@ -969,274 +817,273 @@ class Server(object):
         return 1.0
 
 
-class SlaveLocal(object):
-
-    """mix-in class to implement some factes of a slave server
-
-    ("mix-in" is sort of like "abstract class", ie. it's not
-    instantiated just included in the ancesty DAG. I use "mix-in"
-    to indicate that it's not used as an abstract base class,
-    rather just taken in to implement additional functionality
-    on the basis of the assumed availability of certain interfaces.)
-    """
-
-    def can_connect_to(self, remote):
-        """determine our position in the connectibility matrix"""
-        return not remote
-
-    def service_loop(self):
-        """start a RePCe server serving self's server
+class Mounter(object):
 
-        stop servicing if a timeout is configured and got no
-        keep-alime in that inteval
-        """
+    """Abstract base class for mounter backends"""
 
-        if boolify(gconf.use_rsync_xattrs) and not privileged():
-            raise GsyncdError(
-                "using rsync for extended attributes is not supported")
-
-        repce = RepceServer(
-            self.server, sys.stdin, sys.stdout, int(gconf.sync_jobs))
-        t = syncdutils.Thread(target=lambda: (repce.service_loop(),
-                                              syncdutils.finalize()))
-        t.start()
-        logging.info("slave listening")
-        if gconf.timeout and int(gconf.timeout) > 0:
-            while True:
-                lp = self.server.last_keep_alive
-                time.sleep(int(gconf.timeout))
-                if lp == self.server.last_keep_alive:
-                    logging.info(
-                        lf("connection inactive, stopping",
-                           timeout=int(gconf.timeout)))
-                    break
-        else:
-            select((), (), ())
+    def __init__(self, params):
+        self.params = params
+        self.mntpt = None
+        self.umount_cmd = []
 
+    @classmethod
+    def get_glusterprog(cls):
+        gluster_cmd_dir = gconf.get("gluster-command-dir")
+        if rconf.args.subcmd == "slave":
+            gluster_cmd_dir = gconf.get("slave-gluster-command-dir")
+        return os.path.join(gluster_cmd_dir, cls.glusterprog)
+
+    def umount_l(self, d):
+        """perform lazy umount"""
+        po = Popen(self.make_umount_argv(d), stderr=subprocess.PIPE,
+                   universal_newlines=True)
+        po.wait()
+        return po
 
-class SlaveRemote(object):
+    @classmethod
+    def make_umount_argv(cls, d):
+        raise NotImplementedError
 
-    """mix-in class to implement an interface to a remote slave"""
+    def make_mount_argv(self, label=None):
+        raise NotImplementedError
 
-    def connect_remote(self, rargs=[], **opts):
-        """connects to a remote slave
+    def cleanup_mntpt(self, *a):
+        pass
 
-        Invoke an auxiliary utility (slave gsyncd, possibly wrapped)
-        which sets up the connection and set up a RePCe client to
-        communicate throuh its stdio.
-        """
-        slave = opts.get('slave', self.url)
-        extra_opts = []
-        so = getattr(gconf, 'session_owner', None)
-        if so:
-            extra_opts += ['--session-owner', so]
-        li = getattr(gconf, 'local_id', None)
-        if li:
-            extra_opts += ['--local-id', li]
-        ln = getattr(gconf, 'local_node', None)
-        if ln:
-            extra_opts += ['--local-node', ln]
-        if boolify(gconf.use_rsync_xattrs):
-            extra_opts.append('--use-rsync-xattrs')
-        if boolify(gconf.access_mount):
-            extra_opts.append('--access-mount')
-        po = Popen(rargs + gconf.remote_gsyncd.split() + extra_opts +
-                   ['-N', '--listen', '--timeout', str(gconf.timeout),
-                    slave],
-                   stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                   stderr=subprocess.PIPE)
-        gconf.transport = po
-        return self.start_fd_client(po.stdout, po.stdin, **opts)
+    def handle_mounter(self, po):
+        po.wait()
 
-    def start_fd_client(self, i, o, **opts):
-        """set up RePCe client, handshake with server
+    def inhibit(self, label):
+        """inhibit a gluster filesystem
 
-        It's cut out as a separate method to let
-        subclasses hook into client startup
+        Mount glusterfs over a temporary mountpoint,
+        change into the mount, and lazy unmount the
+        filesystem.
         """
-        self.server = RepceClient(i, o)
-        rv = self.server.__version__()
-        exrv = {'proto': repce.repce_version, 'object': Server.version()}
-        da0 = (rv, exrv)
-        da1 = ({}, {})
-        for i in range(2):
-            for k, v in da0[i].iteritems():
-                da1[i][k] = int(v)
-        if da1[0] != da1[1]:
-            raise GsyncdError(
-                "RePCe major version mismatch: local %s, remote %s" %
-                (exrv, rv))
-
-    def rsync(self, files, *args, **kw):
-        """invoke rsync"""
-        if not files:
-            raise GsyncdError("no files to sync")
-        logging.debug("files: " + ", ".join(files))
-
-        extra_rsync_flags = []
-        # Performance flag, --ignore-missing-args, if rsync version is
-        # greater than 3.1.0 then include this flag.
-        if boolify(gconf.rsync_opt_ignore_missing_args) and \
-           get_rsync_version(gconf.rsync_command) >= "3.1.0":
-            extra_rsync_flags = ["--ignore-missing-args"]
-
-        argv = gconf.rsync_command.split() + \
-            ['-aR0', '--inplace', '--files-from=-', '--super',
-             '--stats', '--numeric-ids', '--no-implied-dirs'] + \
-            (boolify(gconf.rsync_opt_existing) and ['--existing'] or []) + \
-            gconf.rsync_options.split() + \
-            (boolify(gconf.sync_xattrs) and ['--xattrs'] or []) + \
-            (boolify(gconf.sync_acls) and ['--acls'] or []) + \
-            extra_rsync_flags + \
-            ['.'] + list(args)
-
-        log_rsync_performance = boolify(gconf.configinterface.get_realtime(
-            "log_rsync_performance", default_value=False))
+        mpi, mpo = pipe()
+        mh = Popen.fork()
+        if mh:
+            # Parent
+            os.close(mpi)
+            fcntl.fcntl(mpo, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
+            d = None
+            margv = self.make_mount_argv(label)
+            if self.mntpt:
+                # mntpt is determined pre-mount
+                d = self.mntpt
+                mnt_msg = d + '\0'
+                encoded_msg = mnt_msg.encode()
+                os.write(mpo, encoded_msg)
+            po = Popen(margv, **self.mountkw)
+            self.handle_mounter(po)
+            po.terminate_geterr()
+            logging.debug('auxiliary glusterfs mount in place')
+            if not d:
+                # mntpt is determined during mount
+                d = self.mntpt
+                mnt_msg = d + '\0'
+                encoded_msg = mnt_msg.encode()
+                os.write(mpo, encoded_msg)
+            encoded_msg = 'M'.encode()
+            os.write(mpo, encoded_msg)
+            t = syncdutils.Thread(target=lambda: os.chdir(d))
+            t.start()
+            tlim = rconf.starttime + gconf.get("connection-timeout")
+            while True:
+                if not t.isAlive():
+                    break
 
-        if log_rsync_performance:
-            # use stdout=PIPE only when log_rsync_performance enabled
-            # Else rsync will write to stdout and nobody is their
-            # to consume. If PIPE is full rsync hangs.
-            po = Popen(argv, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                       stderr=subprocess.PIPE)
+                if time.time() >= tlim:
+                    syncdutils.finalize(exval=1)
+                time.sleep(1)
+            os.close(mpo)
+            _, rv = syncdutils.waitpid(mh, 0)
+            if rv:
+                rv = (os.WIFEXITED(rv) and os.WEXITSTATUS(rv) or 0) - \
+                     (os.WIFSIGNALED(rv) and os.WTERMSIG(rv) or 0)
+                logging.warn(lf('stale mount possibly left behind',
+                                path=d))
+                raise GsyncdError("cleaning up temp mountpoint %s "
+                                  "failed with status %d" %
+                                  (d, rv))
         else:
-            po = Popen(argv, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
-
-        for f in files:
-            po.stdin.write(f)
-            po.stdin.write('\0')
-
-        stdout, stderr = po.communicate()
-
-        if kw.get("log_err", False):
-            for errline in stderr.strip().split("\n")[:-1]:
-                logging.error(lf("SYNC Error",
-                                 sync_engine="Rsync",
-                                 error=errline))
-
-        if log_rsync_performance:
-            rsync_msg = []
-            for line in stdout.split("\n"):
-                if line.startswith("Number of files:") or \
-                   line.startswith("Number of regular files transferred:") or \
-                   line.startswith("Total file size:") or \
-                   line.startswith("Total transferred file size:") or \
-                   line.startswith("Literal data:") or \
-                   line.startswith("Matched data:") or \
-                   line.startswith("Total bytes sent:") or \
-                   line.startswith("Total bytes received:") or \
-                   line.startswith("sent "):
-                    rsync_msg.append(line)
-            logging.info(lf("rsync performance",
-                            data=", ".join(rsync_msg)))
-
-        return po
-
-    def tarssh(self, files, slaveurl, log_err=False):
-        """invoke tar+ssh
-        -z (compress) can be use if needed, but omitting it now
-        as it results in weird error (tar+ssh errors out (errcode: 2)
-        """
-        if not files:
-            raise GsyncdError("no files to sync")
-        logging.debug("files: " + ", ".join(files))
-        (host, rdir) = slaveurl.split(':')
-        tar_cmd = ["tar"] + \
-            ["--sparse", "-cf", "-", "--files-from", "-"]
-        ssh_cmd = gconf.ssh_command_tar.split() + \
-            ["-p", str(gconf.ssh_port)] + \
-            [host, "tar"] + \
-            ["--overwrite", "-xf", "-", "-C", rdir]
-        p0 = Popen(tar_cmd, stdout=subprocess.PIPE,
-                   stdin=subprocess.PIPE, stderr=subprocess.PIPE)
-        p1 = Popen(ssh_cmd, stdin=p0.stdout, stderr=subprocess.PIPE)
-        for f in files:
-            p0.stdin.write(f)
-            p0.stdin.write('\n')
+            rv = 0
+            try:
+                os.setsid()
+                os.close(mpo)
+                mntdata = ''
+                while True:
+                    c = os.read(mpi, 1)
+                    c = c.decode()
+                    if not c:
+                        break
+                    mntdata += c
+                if mntdata:
+                    mounted = False
+                    if mntdata[-1] == 'M':
+                        mntdata = mntdata[:-1]
+                        assert(mntdata)
+                        mounted = True
+                    assert(mntdata[-1] == '\0')
+                    mntpt = mntdata[:-1]
+                    assert(mntpt)
+
+                    umount_master = False
+                    umount_slave = False
+                    if rconf.args.subcmd == "worker" \
+                       and not unshare_propagation_supported() \
+                       and not gconf.get("access-mount"):
+                        umount_master = True
+                    if rconf.args.subcmd == "slave" \
+                       and not gconf.get("slave-access-mount"):
+                        umount_slave = True
+
+                    if mounted and (umount_master or umount_slave):
+                        po = self.umount_l(mntpt)
+                        po.terminate_geterr(fail_on_err=False)
+                        if po.returncode != 0:
+                            po.errlog()
+                            rv = po.returncode
+                        logging.debug("Lazy umount done: %s" % mntpt)
+                    if umount_master or umount_slave:
+                        self.cleanup_mntpt(mntpt)
+            except:
+                logging.exception('mount cleanup failure:')
+                rv = 200
+            os._exit(rv)
+
+        #Polling the dht.subvol.status value.
+        RETRIES = 10
+        while not gf_mount_ready():
+            if RETRIES < 0:
+                logging.error('Subvols are not up')
+                break
+            RETRIES -= 1
+            time.sleep(0.2)
 
-        p0.stdin.close()
-        p0.stdout.close()  # Allow p0 to receive a SIGPIPE if p1 exits.
-        # wait for tar to terminate, collecting any errors, further
-        # waiting for transfer to complete
-        _, stderr1 = p1.communicate()
+        logging.debug('auxiliary glusterfs mount prepared')
 
-        # stdin and stdout of p0 is already closed, Reset to None and
-        # wait for child process to complete
-        p0.stdin = None
-        p0.stdout = None
-        p0.communicate()
 
-        if log_err:
-            for errline in stderr1.strip().split("\n")[:-1]:
-                logging.error(lf("SYNC Error",
-                                 sync_engine="Tarssh",
-                                 error=errline))
+class DirectMounter(Mounter):
 
-        return p1
+    """mounter backend which calls mount(8), umount(8) directly"""
 
+    mountkw = {'stderr': subprocess.PIPE, 'universal_newlines': True}
+    glusterprog = 'glusterfs'
 
-class AbstractUrl(object):
+    @staticmethod
+    def make_umount_argv(d):
+        return ['umount', '-l', d]
 
-    """abstract base class for url scheme classes"""
+    def make_mount_argv(self, label=None):
+        self.mntpt = tempfile.mkdtemp(prefix='gsyncd-aux-mount-')
+        rconf.mount_point = self.mntpt
+        return [self.get_glusterprog()] + \
+            ['--' + p for p in self.params] + [self.mntpt]
 
-    def __init__(self, path, pattern):
-        m = re.search(pattern, path)
-        if not m:
-            raise GsyncdError("malformed path")
-        self.path = path
-        return m.groups()
+    def cleanup_mntpt(self, mntpt=None):
+        if not mntpt:
+            mntpt = self.mntpt
+        errno_wrap(os.rmdir, [mntpt], [ENOENT, EBUSY])
 
-    @property
-    def scheme(self):
-        return type(self).__name__.lower()
 
-    def canonical_path(self):
-        return self.path
+class MountbrokerMounter(Mounter):
 
-    def get_url(self, canonical=False, escaped=False):
-        """format self's url in various styles"""
-        if canonical:
-            pa = self.canonical_path()
-        else:
-            pa = self.path
-        u = "://".join((self.scheme, pa))
-        if escaped:
-            u = syncdutils.escape(u)
-        return u
+    """mounter backend using the mountbroker gluster service"""
 
-    @property
-    def url(self):
-        return self.get_url()
+    mountkw = {'stderr': subprocess.PIPE, 'stdout': subprocess.PIPE,
+               'universal_newlines': True}
+    glusterprog = 'gluster'
 
+    @classmethod
+    def make_cli_argv(cls):
+        return [cls.get_glusterprog()] + ['--remote-host=localhost'] + \
+            gconf.get("gluster-cli-options").split() + ['system::']
 
-class FILE(AbstractUrl, SlaveLocal, SlaveRemote):
+    @classmethod
+    def make_umount_argv(cls, d):
+        return cls.make_cli_argv() + ['umount', d, 'lazy']
 
-    """scheme class for file:// urls
+    def make_mount_argv(self, label):
+        return self.make_cli_argv() + \
+            ['mount', label, 'user-map-root=' +
+                syncdutils.getusername()] + self.params
 
-    can be used to represent a file slave server
-    on slave side, or interface to a remote file
-    file server on master side
-    """
+    def handle_mounter(self, po):
+        self.mntpt = po.stdout.readline()[:-1]
+        rconf.mount_point = self.mntpt
+        rconf.mountbroker = True
+        self.umount_cmd = self.make_cli_argv() + ['umount']
+        rconf.mbr_umount_cmd = self.umount_cmd
+        po.stdout.close()
+        sup(self, po)
+        if po.returncode != 0:
+            # if cli terminated with error due to being
+            # refused by glusterd, what it put
+            # out on stdout is a diagnostic message
+            logging.error(lf('glusterd answered', mnt=self.mntpt))
 
-    class FILEServer(Server):
 
-        """included server flavor"""
-        pass
+class GLUSTERServer(Server):
 
-    server = FILEServer
+    "server enhancements for a glusterfs backend"""
 
-    def __init__(self, path):
-        sup(self, path, '^/')
+    @classmethod
+    def _attr_unpack_dict(cls, xattr, extra_fields=''):
+        """generic volume mark fetching/parsing backed"""
+        fmt_string = cls.NTV_FMTSTR + extra_fields
+        buf = Xattr.lgetxattr('.', xattr, struct.calcsize(fmt_string))
+        buf = str_to_bytearray(buf)
+        vm = struct.unpack(fmt_string, buf)
+        m = re.match(
+            '(.{8})(.{4})(.{4})(.{4})(.{12})',
+            "".join(['%02x' % x for x in vm[2:18]]))
+        uuid = '-'.join(m.groups())
+        volinfo = {'version': vm[0:2],
+                   'uuid': uuid,
+                   'retval': vm[18],
+                   'volume_mark': vm[19:21],
+                   }
+        if extra_fields:
+            return volinfo, vm[-len(extra_fields):]
+        else:
+            return volinfo
 
-    def connect(self):
-        """inhibit the resource beyond"""
-        os.chdir(self.path)
+    @classmethod
+    def foreign_volume_infos(cls):
+        """return list of valid (not expired) foreign volume marks"""
+        dict_list = []
+        xattr_list = Xattr.llistxattr_buf('.')
+        for ele in xattr_list:
+            if ele.find('.'.join([cls.GX_NSPACE, 'volume-mark', ''])) == 0:
+                d, x = cls._attr_unpack_dict(ele, cls.FRGN_XTRA_FMT)
+                now = int(time.time())
+                if x[0] > now:
+                    logging.debug("volinfo[%s] expires: %d "
+                                  "(%d sec later)" %
+                                  (d['uuid'], x[0], x[0] - now))
+                    d['timeout'] = x[0]
+                    dict_list.append(d)
+                else:
+                    try:
+                        Xattr.lremovexattr('.', ele)
+                    except OSError:
+                        pass
+        return dict_list
 
-    def rsync(self, files, log_err=False):
-        return sup(self, files, self.path, log_err=log_err)
+    @classmethod
+    def native_volume_info(cls):
+        """get the native volume mark of the underlying gluster volume"""
+        try:
+            return cls._attr_unpack_dict('.'.join([cls.GX_NSPACE,
+                                                   'volume-mark']))
+        except OSError:
+            ex = sys.exc_info()[1]
+            if ex.errno != ENODATA:
+                raise
 
 
-class GLUSTER(AbstractUrl, SlaveLocal, SlaveRemote):
+class GLUSTER(object):
 
     """scheme class for gluster:// urls
 
@@ -1246,241 +1093,17 @@ class GLUSTER(AbstractUrl, SlaveLocal, SlaveRemote):
     (slave-ish features come from the mixins, master
     functionality is outsourced to GMaster from master)
     """
-
-    class GLUSTERServer(Server):
-
-        "server enhancements for a glusterfs backend"""
-
-        @classmethod
-        def _attr_unpack_dict(cls, xattr, extra_fields=''):
-            """generic volume mark fetching/parsing backed"""
-            fmt_string = cls.NTV_FMTSTR + extra_fields
-            buf = Xattr.lgetxattr('.', xattr, struct.calcsize(fmt_string))
-            vm = struct.unpack(fmt_string, buf)
-            m = re.match(
-                '(.{8})(.{4})(.{4})(.{4})(.{12})',
-                "".join(['%02x' % x for x in vm[2:18]]))
-            uuid = '-'.join(m.groups())
-            volinfo = {'version': vm[0:2],
-                       'uuid': uuid,
-                       'retval': vm[18],
-                       'volume_mark': vm[19:21],
-                       }
-            if extra_fields:
-                return volinfo, vm[-len(extra_fields):]
-            else:
-                return volinfo
-
-        @classmethod
-        def foreign_volume_infos(cls):
-            """return list of valid (not expired) foreign volume marks"""
-            dict_list = []
-            xattr_list = Xattr.llistxattr_buf('.')
-            for ele in xattr_list:
-                if ele.find('.'.join([cls.GX_NSPACE, 'volume-mark', ''])) == 0:
-                    d, x = cls._attr_unpack_dict(ele, cls.FRGN_XTRA_FMT)
-                    now = int(time.time())
-                    if x[0] > now:
-                        logging.debug("volinfo[%s] expires: %d "
-                                      "(%d sec later)" %
-                                      (d['uuid'], x[0], x[0] - now))
-                        d['timeout'] = x[0]
-                        dict_list.append(d)
-                    else:
-                        try:
-                            Xattr.lremovexattr('.', ele)
-                        except OSError:
-                            pass
-            return dict_list
-
-        @classmethod
-        def native_volume_info(cls):
-            """get the native volume mark of the underlying gluster volume"""
-            try:
-                return cls._attr_unpack_dict('.'.join([cls.GX_NSPACE,
-                                                       'volume-mark']))
-            except OSError:
-                ex = sys.exc_info()[1]
-                if ex.errno != ENODATA:
-                    raise
-
     server = GLUSTERServer
 
-    def __init__(self, path):
-        self.host, self.volume = sup(self, path, '^(%s):(.+)' % HostRX.pattern)
-
-    def canonical_path(self):
-        return ':'.join([gethostbyname(self.host), self.volume])
-
-    def can_connect_to(self, remote):
-        """determine our position in the connectibility matrix"""
-        return not remote or \
-            (isinstance(remote, SSH) and isinstance(remote.inner_rsc, GLUSTER))
+    def __init__(self, host, volume):
+        self.path = "%s:%s" % (host, volume)
+        self.host = host
+        self.volume = volume
 
-    class Mounter(object):
-
-        """Abstract base class for mounter backends"""
-
-        def __init__(self, params):
-            self.params = params
-            self.mntpt = None
-
-        @classmethod
-        def get_glusterprog(cls):
-            return os.path.join(gconf.gluster_command_dir, cls.glusterprog)
-
-        def umount_l(self, d):
-            """perform lazy umount"""
-            po = Popen(self.make_umount_argv(d), stderr=subprocess.PIPE)
-            po.wait()
-            return po
-
-        @classmethod
-        def make_umount_argv(cls, d):
-            raise NotImplementedError
-
-        def make_mount_argv(self, *a):
-            raise NotImplementedError
-
-        def cleanup_mntpt(self, *a):
-            pass
-
-        def handle_mounter(self, po):
-            po.wait()
-
-        def inhibit(self, *a):
-            """inhibit a gluster filesystem
-
-            Mount glusterfs over a temporary mountpoint,
-            change into the mount, and lazy unmount the
-            filesystem.
-            """
-
-            mpi, mpo = os.pipe()
-            mh = Popen.fork()
-            if mh:
-                os.close(mpi)
-                fcntl.fcntl(mpo, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
-                d = None
-                margv = self.make_mount_argv(*a)
-                if self.mntpt:
-                    # mntpt is determined pre-mount
-                    d = self.mntpt
-                    os.write(mpo, d + '\0')
-                po = Popen(margv, **self.mountkw)
-                self.handle_mounter(po)
-                po.terminate_geterr()
-                logging.debug('auxiliary glusterfs mount in place')
-                if not d:
-                    # mntpt is determined during mount
-                    d = self.mntpt
-                    os.write(mpo, d + '\0')
-                os.write(mpo, 'M')
-                t = syncdutils.Thread(target=lambda: os.chdir(d))
-                t.start()
-                tlim = gconf.starttime + int(gconf.connection_timeout)
-                while True:
-                    if not t.isAlive():
-                        break
-                    if time.time() >= tlim:
-                        syncdutils.finalize(exval=1)
-                    time.sleep(1)
-                os.close(mpo)
-                _, rv = syncdutils.waitpid(mh, 0)
-                if rv:
-                    rv = (os.WIFEXITED(rv) and os.WEXITSTATUS(rv) or 0) - \
-                         (os.WIFSIGNALED(rv) and os.WTERMSIG(rv) or 0)
-                    logging.warn(lf('stale mount possibly left behind',
-                                    path=d))
-                    raise GsyncdError("cleaning up temp mountpoint %s "
-                                      "failed with status %d" %
-                                      (d, rv))
-            else:
-                rv = 0
-                try:
-                    os.setsid()
-                    os.close(mpo)
-                    mntdata = ''
-                    while True:
-                        c = os.read(mpi, 1)
-                        if not c:
-                            break
-                        mntdata += c
-                    if mntdata:
-                        mounted = False
-                        if mntdata[-1] == 'M':
-                            mntdata = mntdata[:-1]
-                            assert(mntdata)
-                            mounted = True
-                        assert(mntdata[-1] == '\0')
-                        mntpt = mntdata[:-1]
-                        assert(mntpt)
-                        if mounted and not boolify(gconf.access_mount):
-                            po = self.umount_l(mntpt)
-                            po.terminate_geterr(fail_on_err=False)
-                            if po.returncode != 0:
-                                po.errlog()
-                                rv = po.returncode
-                        if not boolify(gconf.access_mount):
-                            self.cleanup_mntpt(mntpt)
-                except:
-                    logging.exception('mount cleanup failure:')
-                    rv = 200
-                os._exit(rv)
-            logging.debug('auxiliary glusterfs mount prepared')
-
-    class DirectMounter(Mounter):
-
-        """mounter backend which calls mount(8), umount(8) directly"""
-
-        mountkw = {'stderr': subprocess.PIPE}
-        glusterprog = 'glusterfs'
-
-        @staticmethod
-        def make_umount_argv(d):
-            return ['umount', '-l', d]
-
-        def make_mount_argv(self):
-            self.mntpt = tempfile.mkdtemp(prefix='gsyncd-aux-mount-')
-            mntpt_list.append(self.mntpt)
-            return [self.get_glusterprog()] + \
-                ['--' + p for p in self.params] + [self.mntpt]
-
-        def cleanup_mntpt(self, mntpt=None):
-            if not mntpt:
-                mntpt = self.mntpt
-            errno_wrap(os.rmdir, [mntpt], [ENOENT, EBUSY])
-
-    class MountbrokerMounter(Mounter):
-
-        """mounter backend using the mountbroker gluster service"""
-
-        mountkw = {'stderr': subprocess.PIPE, 'stdout': subprocess.PIPE}
-        glusterprog = 'gluster'
-
-        @classmethod
-        def make_cli_argv(cls):
-            return [cls.get_glusterprog()] + ['--remote-host=localhost'] + \
-                gconf.gluster_cli_options.split() + ['system::']
-
-        @classmethod
-        def make_umount_argv(cls, d):
-            return cls.make_cli_argv() + ['umount', d, 'lazy']
-
-        def make_mount_argv(self, label):
-            return self.make_cli_argv() + \
-                ['mount', label, 'user-map-root=' +
-                    syncdutils.getusername()] + self.params
-
-        def handle_mounter(self, po):
-            self.mntpt = po.stdout.readline()[:-1]
-            po.stdout.close()
-            sup(self, po)
-            if po.returncode != 0:
-                # if cli terminated with error due to being
-                # refused by glusterd, what it put
-                # out on stdout is a diagnostic message
-                logging.error(lf('glusterd answered', mnt=self.mntpt))
+        global slv_volume
+        global slv_host
+        slv_volume = self.volume
+        slv_host = self.host
 
     def connect(self):
         """inhibit the resource beyond
@@ -1492,23 +1115,29 @@ class GLUSTER(AbstractUrl, SlaveLocal, SlaveRemote):
 
         logging.info("Mounting gluster volume locally...")
         t0 = time.time()
-        label = getattr(gconf, 'mountbroker', None)
+        label = gconf.get('mountbroker', None)
         if not label and not privileged():
             label = syncdutils.getusername()
-        mounter = label and self.MountbrokerMounter or self.DirectMounter
-        params = gconf.gluster_params.split() + \
-            (gconf.gluster_log_level and ['log-level=' +
-                                          gconf.gluster_log_level] or []) + \
-            ['log-file=' + gconf.gluster_log_file, 'volfile-server=' +
-             self.host, 'volfile-id=' + self.volume, 'client-pid=-1']
-        mounter(params).inhibit(*[l for l in [label] if l])
+        mounter = label and MountbrokerMounter or DirectMounter
+
+        log_file = gconf.get("gluster-log-file")
+        if rconf.args.subcmd == "slave":
+            log_file = gconf.get("slave-gluster-log-file")
+
+        log_level = gconf.get("gluster-log-level")
+        if rconf.args.subcmd == "slave":
+            log_level = gconf.get("slave-gluster-log-level")
+
+        params = gconf.get("gluster-params").split() + \
+            ['log-level=' + log_level] + \
+            ['log-file=' + log_file, 'volfile-server=' + self.host] + \
+            ['volfile-id=' + self.volume, 'client-pid=-1']
+
+        self.mounter = mounter(params)
+        self.mounter.inhibit(label)
         logging.info(lf("Mounted gluster volume",
                         duration="%.4f" % (time.time() - t0)))
 
-    def connect_remote(self, *a, **kw):
-        sup(self, *a, **kw)
-        self.slavedir = "/proc/%d/cwd" % self.server.pid()
-
     def gmaster_instantiate_tuple(self, slave):
         """return a tuple of the 'one shot' and the 'main crawl'
         class instance"""
@@ -1516,7 +1145,7 @@ class GLUSTER(AbstractUrl, SlaveLocal, SlaveRemote):
                 gmaster_builder()(self, slave),
                 gmaster_builder('changeloghistory')(self, slave))
 
-    def service_loop(self, *args):
+    def service_loop(self, slave=None):
         """enter service loop
 
         - if slave given, instantiate GMaster and
@@ -1524,171 +1153,173 @@ class GLUSTER(AbstractUrl, SlaveLocal, SlaveRemote):
           master behavior
         - else do that's what's inherited
         """
-        if args:
-            slave = args[0]
-            if gconf.local_path:
-                class brickserver(FILE.FILEServer):
-                    local_path = gconf.local_path
-                    aggregated = self.server
-
-                    @classmethod
-                    def entries(cls, path):
-                        e = super(brickserver, cls).entries(path)
-                        # on the brick don't mess with /.glusterfs
-                        if path == '.':
-                            try:
-                                e.remove('.glusterfs')
-                                e.remove('.trashcan')
-                            except ValueError:
-                                pass
-                        return e
-
-                    @classmethod
-                    def lstat(cls, e):
-                        """ path based backend stat """
-                        return super(brickserver, cls).lstat(e)
-
-                    @classmethod
-                    def gfid(cls, e):
-                        """ path based backend gfid fetch """
-                        return super(brickserver, cls).gfid(e)
-
-                    @classmethod
-                    def linkto_check(cls, e):
-                        return super(brickserver, cls).linkto_check(e)
-                if gconf.slave_id:
-                    # define {,set_}xtime in slave, thus preempting
-                    # the call to remote, so that it takes data from
-                    # the local brick
-                    slave.server.xtime = types.MethodType(
-                        lambda _self, path, uuid: (
-                            brickserver.xtime(path,
-                                              uuid + '.' + gconf.slave_id)
-                        ),
-                        slave.server)
-                    slave.server.stime = types.MethodType(
-                        lambda _self, path, uuid: (
-                            brickserver.stime(path,
-                                              uuid + '.' + gconf.slave_id)
-                        ),
-                        slave.server)
-                    slave.server.entry_stime = types.MethodType(
-                        lambda _self, path, uuid: (
-                            brickserver.entry_stime(
-                                path,
-                                uuid + '.' + gconf.slave_id)
-                        ),
-                        slave.server)
-                    slave.server.set_stime = types.MethodType(
-                        lambda _self, path, uuid, mark: (
-                            brickserver.set_stime(path,
-                                                  uuid + '.' + gconf.slave_id,
-                                                  mark)
-                        ),
-                        slave.server)
-                    slave.server.set_entry_stime = types.MethodType(
-                        lambda _self, path, uuid, mark: (
-                            brickserver.set_entry_stime(
-                                path,
-                                uuid + '.' + gconf.slave_id,
-                                mark)
-                        ),
-                        slave.server)
-                (g1, g2, g3) = self.gmaster_instantiate_tuple(slave)
-                g1.master.server = brickserver
-                g2.master.server = brickserver
-                g3.master.server = brickserver
-            else:
-                (g1, g2, g3) = self.gmaster_instantiate_tuple(slave)
-                g1.master.server.aggregated = gmaster.master.server
-                g2.master.server.aggregated = gmaster.master.server
-                g3.master.server.aggregated = gmaster.master.server
-            # bad bad bad: bad way to do things like this
-            # need to make this elegant
-            # register the crawlers and start crawling
-            # g1 ==> Xsync, g2 ==> config.change_detector(changelog by default)
-            # g3 ==> changelog History
-            changelog_register_failed = False
-            (inf, ouf, ra, wa) = gconf.rpc_fd.split(',')
-            changelog_agent = RepceClient(int(inf), int(ouf))
-            master_name, slave_data = get_master_and_slave_data_from_args(
-                sys.argv)
-            status = GeorepStatus(gconf.state_file, gconf.local_node,
-                                  gconf.local_path,
-                                  gconf.local_node_id,
-                                  master_name, slave_data)
-            status.reset_on_worker_start()
-            rv = changelog_agent.version()
-            if int(rv) != CHANGELOG_AGENT_CLIENT_VERSION:
+        if rconf.args.subcmd == "slave":
+            if gconf.get("use-rsync-xattrs") and not privileged():
                 raise GsyncdError(
-                    "RePCe major version mismatch(changelog agent): "
-                    "local %s, remote %s" %
-                    (CHANGELOG_AGENT_CLIENT_VERSION, rv))
+                    "using rsync for extended attributes is not supported")
+
+            repce = RepceServer(
+                self.server, sys.stdin, sys.stdout, gconf.get("sync-jobs"))
+            t = syncdutils.Thread(target=lambda: (repce.service_loop(),
+                                                  syncdutils.finalize()))
+            t.start()
+            logging.info("slave listening")
+            if gconf.get("slave-timeout") and gconf.get("slave-timeout") > 0:
+                while True:
+                    lp = self.server.last_keep_alive
+                    time.sleep(gconf.get("slave-timeout"))
+                    if lp == self.server.last_keep_alive:
+                        logging.info(
+                            lf("connection inactive, stopping",
+                               timeout=gconf.get("slave-timeout")))
+                        break
+            else:
+                select((), (), ())
 
-            try:
-                workdir = g2.setup_working_dir()
-                # Register only when change_detector is not set to
-                # xsync, else agent will generate changelog files
-                # in .processing directory of working dir
-                if gconf.change_detector != 'xsync':
-                    # register with the changelog library
-                    # 9 == log level (DEBUG)
-                    # 5 == connection retries
-                    changelog_agent.init()
-                    changelog_agent.register(gconf.local_path,
-                                             workdir, gconf.changelog_log_file,
-                                             get_changelog_log_level(
-                                                 gconf.changelog_log_level),
-                                             g2.CHANGELOG_CONN_RETRIES)
-
-                register_time = int(time.time())
-                g2.register(register_time, changelog_agent, status)
-                g3.register(register_time, changelog_agent, status)
-            except ChangelogException as e:
-                logging.error(lf("Changelog register failed", error=e))
-                sys.exit(1)
-
-            g1.register(status=status)
-            logging.info(lf("Register time",
-                            time=register_time))
-            # oneshot: Try to use changelog history api, if not
-            # available switch to FS crawl
-            # Note: if config.change_detector is xsync then
-            # it will not use changelog history api
-            try:
-                g3.crawlwrap(oneshot=True)
-            except PartialHistoryAvailable as e:
-                logging.info(lf('Partial history available, using xsync crawl'
-                                ' after consuming history',
-                                till=e))
-                g1.crawlwrap(oneshot=True, register_time=register_time)
-            except ChangelogHistoryNotAvailable:
-                logging.info('Changelog history not available, using xsync')
-                g1.crawlwrap(oneshot=True, register_time=register_time)
-            except NoStimeAvailable:
-                logging.info('No stime available, using xsync crawl')
-                g1.crawlwrap(oneshot=True, register_time=register_time)
-            except ChangelogException as e:
-                logging.error(lf("Changelog History Crawl failed",
-                                 error=e))
-                sys.exit(1)
+            return
 
-            try:
-                g2.crawlwrap()
-            except ChangelogException as e:
-                logging.error(lf("Changelog crawl failed", error=e))
-                sys.exit(1)
-        else:
-            sup(self, *args)
+        class brickserver(Server):
+            local_path = rconf.args.local_path
+            aggregated = self.server
 
-    def rsync(self, files, log_err=False):
-        return sup(self, files, self.slavedir, log_err=log_err)
+            @classmethod
+            def entries(cls, path):
+                e = super(brickserver, cls).entries(path)
+                # on the brick don't mess with /.glusterfs
+                if path == '.':
+                    try:
+                        e.remove('.glusterfs')
+                        e.remove('.trashcan')
+                    except ValueError:
+                        pass
+                return e
+
+            @classmethod
+            def lstat(cls, e):
+                """ path based backend stat """
+                return super(brickserver, cls).lstat(e)
+
+            @classmethod
+            def gfid(cls, e):
+                """ path based backend gfid fetch """
+                return super(brickserver, cls).gfid(e)
+
+            @classmethod
+            def linkto_check(cls, e):
+                return super(brickserver, cls).linkto_check(e)
+
+        # define {,set_}xtime in slave, thus preempting
+        # the call to remote, so that it takes data from
+        # the local brick
+        slave.server.xtime = types.MethodType(
+            lambda _self, path, uuid: (
+                brickserver.xtime(path,
+                                  uuid + '.' + rconf.args.slave_id)
+            ),
+            slave.server)
+        slave.server.stime = types.MethodType(
+            lambda _self, path, uuid: (
+                brickserver.stime(path,
+                                  uuid + '.' + rconf.args.slave_id)
+            ),
+            slave.server)
+        slave.server.entry_stime = types.MethodType(
+            lambda _self, path, uuid: (
+                brickserver.entry_stime(
+                    path,
+                    uuid + '.' + rconf.args.slave_id)
+            ),
+            slave.server)
+        slave.server.set_stime = types.MethodType(
+            lambda _self, path, uuid, mark: (
+                brickserver.set_stime(path,
+                                      uuid + '.' + rconf.args.slave_id,
+                                      mark)
+            ),
+            slave.server)
+        slave.server.set_entry_stime = types.MethodType(
+            lambda _self, path, uuid, mark: (
+                brickserver.set_entry_stime(
+                    path,
+                    uuid + '.' + rconf.args.slave_id,
+                    mark)
+            ),
+            slave.server)
+
+        (g1, g2, g3) = self.gmaster_instantiate_tuple(slave)
+        g1.master.server = brickserver
+        g2.master.server = brickserver
+        g3.master.server = brickserver
+
+        # bad bad bad: bad way to do things like this
+        # need to make this elegant
+        # register the crawlers and start crawling
+        # g1 ==> Xsync, g2 ==> config.change_detector(changelog by default)
+        # g3 ==> changelog History
+        status = GeorepStatus(gconf.get("state-file"),
+                              rconf.args.local_node,
+                              rconf.args.local_path,
+                              rconf.args.local_node_id,
+                              rconf.args.master,
+                              rconf.args.slave)
+        status.reset_on_worker_start()
 
-    def tarssh(self, files, log_err=False):
-        return sup(self, files, self.slavedir, log_err=log_err)
+        try:
+            workdir = g2.setup_working_dir()
+            # Register only when change_detector is not set to
+            # xsync, else agent will generate changelog files
+            # in .processing directory of working dir
+            if gconf.get("change-detector") != 'xsync':
+                # register with the changelog library
+                # 9 == log level (DEBUG)
+                # 5 == connection retries
+                libgfchangelog.register(rconf.args.local_path,
+                                        workdir,
+                                        gconf.get("changelog-log-file"),
+                                        get_changelog_log_level(
+                                            gconf.get("changelog-log-level")),
+                                        g2.CHANGELOG_CONN_RETRIES)
+
+            register_time = int(time.time())
+            g2.register(register_time, status)
+            g3.register(register_time, status)
+        except ChangelogException as e:
+            logging.error(lf("Changelog register failed", error=e))
+            sys.exit(1)
+
+        g1.register(status=status)
+        logging.info(lf("Register time",
+                        time=register_time))
+        # oneshot: Try to use changelog history api, if not
+        # available switch to FS crawl
+        # Note: if config.change_detector is xsync then
+        # it will not use changelog history api
+        try:
+            g3.crawlwrap(oneshot=True)
+        except PartialHistoryAvailable as e:
+            logging.info(lf('Partial history available, using xsync crawl'
+                            ' after consuming history',
+                            till=e))
+            g1.crawlwrap(oneshot=True, register_time=register_time)
+        except ChangelogHistoryNotAvailable:
+            logging.info('Changelog history not available, using xsync')
+            g1.crawlwrap(oneshot=True, register_time=register_time)
+        except NoStimeAvailable:
+            logging.info('No stime available, using xsync crawl')
+            g1.crawlwrap(oneshot=True, register_time=register_time)
+        except ChangelogException as e:
+            logging.error(lf("Changelog History Crawl failed",
+                             error=e))
+            sys.exit(1)
+
+        try:
+            g2.crawlwrap()
+        except ChangelogException as e:
+            logging.error(lf("Changelog crawl failed", error=e))
+            sys.exit(1)
 
 
-class SSH(AbstractUrl, SlaveRemote):
+class SSH(object):
 
     """scheme class for ssh:// urls
 
@@ -1696,13 +1327,9 @@ class SSH(AbstractUrl, SlaveRemote):
     implementing an ssh based proxy
     """
 
-    def __init__(self, path):
-        self.remote_addr, inner_url = sup(self, path,
-                                          '^((?:%s@)?%s):(.+)' %
-                                          tuple([r.pattern
-                                                 for r in (UserRX, HostRX)]))
-        self.inner_rsc = parse_url(inner_url)
-        self.volume = inner_url[1:]
+    def __init__(self, host, volume):
+        self.remote_addr = host
+        self.volume = volume
 
     @staticmethod
     def parse_ssh_address(self):
@@ -1714,35 +1341,28 @@ class SSH(AbstractUrl, SlaveRemote):
         self.remotehost = h
         return {'user': u, 'host': h}
 
-    def canonical_path(self):
-        rap = self.parse_ssh_address(self)
-        remote_addr = '@'.join([rap['user'], gethostbyname(rap['host'])])
-        return ':'.join([remote_addr, self.inner_rsc.get_url(canonical=True)])
-
-    def can_connect_to(self, remote):
-        """determine our position in the connectibility matrix"""
-        return False
-
-    def start_fd_client(self, *a, **opts):
-        """customizations for client startup
+    def start_fd_client(self, i, o):
+        """set up RePCe client, handshake with server
 
-        - be a no-op if we are to daemonize (client startup is deferred
-          to post-daemon stage)
-        - determine target url for rsync after consulting server
+        It's cut out as a separate method to let
+        subclasses hook into client startup
         """
-        if opts.get('deferred'):
-            return a
-        sup(self, *a)
-        ityp = type(self.inner_rsc)
-        if ityp == FILE:
-            slavepath = self.inner_rsc.path
-        elif ityp == GLUSTER:
-            slavepath = "/proc/%d/cwd" % self.server.pid()
-        else:
-            raise NotImplementedError
+        self.server = RepceClient(i, o)
+        rv = self.server.__version__()
+        exrv = {'proto': repce.repce_version, 'object': Server.version()}
+        da0 = (rv, exrv)
+        da1 = ({}, {})
+        for i in range(2):
+            for k, v in da0[i].items():
+                da1[i][k] = int(v)
+        if da1[0] != da1[1]:
+            raise GsyncdError(
+                "RePCe major version mismatch: local %s, remote %s" %
+                (exrv, rv))
+        slavepath = "/proc/%d/cwd" % self.server.pid()
         self.slaveurl = ':'.join([self.remote_addr, slavepath])
 
-    def connect_remote(self, go_daemon=None):
+    def connect_remote(self):
         """connect to inner slave url through outer ssh url
 
         Wrap the connecting utility in ssh.
@@ -1760,49 +1380,204 @@ class SSH(AbstractUrl, SlaveRemote):
         [NB. ATM gluster product does not makes use of interactive
         authentication.]
         """
-        if go_daemon == 'done':
-            return self.start_fd_client(*self.fd_pair)
-
         syncdutils.setup_ssh_ctl(tempfile.mkdtemp(prefix='gsyncd-aux-ssh-'),
                                  self.remote_addr,
-                                 self.inner_rsc.url)
+                                 self.volume)
 
-        deferred = go_daemon == 'postconn'
         logging.info("Initializing SSH connection between master and slave...")
         t0 = time.time()
-        ret = sup(self, gconf.ssh_command.split() +
-                  ["-p", str(gconf.ssh_port)] +
-                  gconf.ssh_ctl_args + [self.remote_addr],
-                  slave=self.inner_rsc.url, deferred=deferred)
+
+        extra_opts = []
+        remote_gsyncd = gconf.get("remote-gsyncd")
+        if remote_gsyncd == "":
+            remote_gsyncd = "/nonexistent/gsyncd"
+
+        if gconf.get("use-rsync-xattrs"):
+            extra_opts.append('--use-rsync-xattrs')
+
+        args_to_slave = [gconf.get("ssh-command")] + \
+            gconf.get("ssh-options").split() + \
+            ["-p", str(gconf.get("ssh-port"))] + \
+            rconf.ssh_ctl_args + [self.remote_addr] + \
+            [remote_gsyncd, "slave"] + \
+            extra_opts + \
+            [rconf.args.master, rconf.args.slave] + \
+            [
+                '--master-node', rconf.args.local_node,
+                '--master-node-id', rconf.args.local_node_id,
+                '--master-brick', rconf.args.local_path,
+                '--local-node', rconf.args.resource_remote,
+                '--local-node-id', rconf.args.resource_remote_id] + \
+            [
+                # Add all config arguments here, slave gsyncd will not use
+                # config file in slave side, so all overriding options should
+                # be sent as arguments
+                '--slave-timeout', str(gconf.get("slave-timeout")),
+                '--slave-log-level', gconf.get("slave-log-level"),
+                '--slave-gluster-log-level',
+                gconf.get("slave-gluster-log-level"),
+                '--slave-gluster-command-dir',
+                gconf.get("slave-gluster-command-dir"),
+                '--master-dist-count',
+                str(gconf.get("master-distribution-count"))]
+
+        if gconf.get("slave-access-mount"):
+            args_to_slave.append('--slave-access-mount')
+
+        if rconf.args.debug:
+            args_to_slave.append('--debug')
+
+        po = Popen(args_to_slave,
+                   stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                   stderr=subprocess.PIPE)
+        rconf.transport = po
+        self.start_fd_client(po.stdout, po.stdin)
         logging.info(lf("SSH connection between master and slave established.",
                         duration="%.4f" % (time.time() - t0)))
 
-        if deferred:
-            # send a message to peer so that we can wait for
-            # the answer from which we know connection is
-            # established and we can proceed with daemonization
-            # (doing that too early robs the ssh passwd prompt...)
-            # However, we'd better not start the RepceClient
-            # before daemonization (that's not preserved properly
-            # in daemon), we just do a an ad-hoc linear put/get.
-            i, o = ret
-            inf = os.fdopen(i)
-            repce.send(o, None, '__repce_version__')
-            select((inf,), (), ())
-            repce.recv(inf)
-            # hack hack hack: store a global reference to the file
-            # to save it from getting GC'd which implies closing it
-            gconf.permanent_handles.append(inf)
-            self.fd_pair = (i, o)
-            return 'should'
-
-    def rsync(self, files, log_err=False):
-        return sup(self, files, '-e',
-                   " ".join(gconf.ssh_command.split() +
-                            ["-p", str(gconf.ssh_port)] +
-                            gconf.ssh_ctl_args),
-                   *(gconf.rsync_ssh_options.split() + [self.slaveurl]),
-                   log_err=log_err)
+    def rsync(self, files, *args, **kw):
+        """invoke rsync"""
+        if not files:
+            raise GsyncdError("no files to sync")
+        logging.debug("files: " + ", ".join(files))
+
+        extra_rsync_flags = []
+        # Performance flag, --ignore-missing-args, if rsync version is
+        # greater than 3.1.0 then include this flag.
+        if gconf.get("rsync-opt-ignore-missing-args") and \
+           get_rsync_version(gconf.get("rsync-command")) >= "3.1.0":
+            extra_rsync_flags = ["--ignore-missing-args"]
+
+        rsync_ssh_opts = [gconf.get("ssh-command")] + \
+            gconf.get("ssh-options").split() + \
+            ["-p", str(gconf.get("ssh-port"))] + \
+            rconf.ssh_ctl_args + \
+            gconf.get("rsync-ssh-options").split()
+
+        argv = [
+            gconf.get("rsync-command"),
+            '-aR0',
+            '--inplace',
+            '--files-from=-',
+            '--super',
+            '--stats',
+            '--numeric-ids',
+            '--no-implied-dirs'
+        ]
+
+        if gconf.get("rsync-opt-existing"):
+            argv += ["--existing"]
+
+        if gconf.get("sync-xattrs"):
+            argv += ['--xattrs']
+
+        if gconf.get("sync-acls"):
+            argv += ['--acls']
+
+        argv = argv + \
+            gconf.get("rsync-options").split() + \
+            extra_rsync_flags + ['.'] + \
+            ["-e", " ".join(rsync_ssh_opts)] + \
+            [self.slaveurl]
+
+        log_rsync_performance = gconf.getr("log-rsync-performance", False)
+
+        if log_rsync_performance:
+            # use stdout=PIPE only when log_rsync_performance enabled
+            # Else rsync will write to stdout and nobody is there
+            # to consume. If PIPE is full rsync hangs.
+            po = Popen(argv, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                       stderr=subprocess.PIPE, universal_newlines=True)
+        else:
+            po = Popen(argv, stdin=subprocess.PIPE, stderr=subprocess.PIPE,
+                       universal_newlines=True)
+
+        for f in files:
+            po.stdin.write(f)
+            po.stdin.write('\0')
+
+        stdout, stderr = po.communicate()
+
+        if kw.get("log_err", False):
+            for errline in stderr.strip().split("\n")[:-1]:
+                logging.error(lf("SYNC Error",
+                                 sync_engine="Rsync",
+                                 error=errline))
+
+        if log_rsync_performance:
+            rsync_msg = []
+            for line in stdout.split("\n"):
+                if line.startswith("Number of files:") or \
+                   line.startswith("Number of regular files transferred:") or \
+                   line.startswith("Total file size:") or \
+                   line.startswith("Total transferred file size:") or \
+                   line.startswith("Literal data:") or \
+                   line.startswith("Matched data:") or \
+                   line.startswith("Total bytes sent:") or \
+                   line.startswith("Total bytes received:") or \
+                   line.startswith("sent "):
+                    rsync_msg.append(line)
+            logging.info(lf("rsync performance",
+                            data=", ".join(rsync_msg)))
+
+        return po
 
     def tarssh(self, files, log_err=False):
-        return sup(self, files, self.slaveurl, log_err=log_err)
+        """invoke tar+ssh
+        -z (compress) can be use if needed, but omitting it now
+        as it results in weird error (tar+ssh errors out (errcode: 2)
+        """
+        if not files:
+            raise GsyncdError("no files to sync")
+        logging.debug("files: " + ", ".join(files))
+        (host, rdir) = self.slaveurl.split(':')
+
+        tar_cmd = ["tar"] + \
+            ["--sparse", "-cf", "-", "--files-from", "-"]
+        ssh_cmd = gconf.get("ssh-command").split() + \
+            gconf.get("ssh-options-tar").split() + \
+            ["-p", str(gconf.get("ssh-port"))] + \
+            [host, "tar"] + \
+            ["--overwrite", "-xf", "-", "-C", rdir]
+        p0 = Popen(tar_cmd, stdout=subprocess.PIPE,
+                   stdin=subprocess.PIPE, stderr=subprocess.PIPE,
+                   universal_newlines=True)
+        p1 = Popen(ssh_cmd, stdin=p0.stdout, stderr=subprocess.PIPE,
+                   universal_newlines=True)
+        for f in files:
+            p0.stdin.write(f)
+            p0.stdin.write('\n')
+
+        p0.stdin.close()
+        p0.stdout.close()  # Allow p0 to receive a SIGPIPE if p1 exits.
+
+        # stdin and stdout of p0 is already closed, Reset to None and
+        # wait for child process to complete
+        p0.stdin = None
+        p0.stdout = None
+
+        def wait_for_tar(p0):
+            _, stderr = p0.communicate()
+            if log_err:
+                for errline in stderr.strip().split("\n")[:-1]:
+                    if "No such file or directory" not in errline:
+                        logging.error(lf("SYNC Error",
+                                         sync_engine="Tarssh",
+                                         error=errline))
+
+        t = syncdutils.Thread(target=wait_for_tar, args=(p0, ))
+        # wait for tar to terminate, collecting any errors, further
+        # waiting for transfer to complete
+        t.start()
+
+        # wait for ssh process
+        _, stderr1 = p1.communicate()
+        t.join()
+
+        if log_err:
+            for errline in stderr1.strip().split("\n")[:-1]:
+                logging.error(lf("SYNC Error",
+                                 sync_engine="Tarssh",
+                                 error=errline))
+
+        return p1
diff --git a/geo-replication/syncdaemon/subcmds.py b/geo-replication/syncdaemon/subcmds.py
new file mode 100644
index 00000000000..b8508532e30
--- /dev/null
+++ b/geo-replication/syncdaemon/subcmds.py
@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+#  This file is part of GlusterFS.
+#
+#  This file is licensed to you under your choice of the GNU Lesser
+#  General Public License, version 3 or any later version (LGPLv3 or
+#  later), or the GNU General Public License, version 2 (GPLv2), in all
+#  cases as published by the Free Software Foundation.
+#
+
+from __future__ import print_function
+from syncdutils import lf
+import logging
+import gsyncdconfig as gconf
+
+
+ERROR_CONFIG_INVALID = 2
+ERROR_CONFIG_INVALID_VALUE = 3
+ERROR_CONFIG_NOT_CONFIGURABLE = 4
+
+
+def subcmd_monitor_status(args):
+    from gsyncdstatus import set_monitor_status
+    from rconf import rconf
+
+    set_monitor_status(gconf.get("state-file"), args.status)
+    rconf.log_exit = False
+    logging.info(lf("Monitor Status Change", status=args.status))
+
+
+def subcmd_status(args):
+    from gsyncdstatus import GeorepStatus
+
+    master_name = args.master.replace(":", "")
+    slave_data = args.slave.replace("ssh://", "")
+
+    brick_status = GeorepStatus(gconf.get("state-file"),
+                                "",
+                                args.local_path,
+                                "",
+                                master_name,
+                                slave_data,
+                                gconf.get("pid-file"))
+    checkpoint_time = gconf.get("checkpoint", 0)
+    brick_status.print_status(checkpoint_time=checkpoint_time,
+                              json_output=args.json)
+
+
+def subcmd_monitor(args):
+    import monitor
+    from resource import GLUSTER, SSH, Popen
+    go_daemon = False if args.debug else True
+
+    monitor.startup(go_daemon)
+    Popen.init_errhandler()
+    local = GLUSTER("localhost", args.master)
+    slavehost, slavevol = args.slave.split("::")
+    remote = SSH(slavehost, slavevol)
+    return monitor.monitor(local, remote)
+
+
+def subcmd_verify_spawning(args):
+    logging.info("Able to spawn gsyncd.py")
+
+
+def subcmd_worker(args):
+    import os
+    import fcntl
+
+    from resource import GLUSTER, SSH, Popen
+
+    Popen.init_errhandler()
+    fcntl.fcntl(args.feedback_fd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
+    local = GLUSTER("localhost", args.master)
+    slave_url, slavevol = args.slave.split("::")
+    if "@" not in slave_url:
+        slavehost = args.resource_remote
+    else:
+        slavehost = "%s@%s" % (slave_url.split("@")[0], args.resource_remote)
+    remote = SSH(slavehost, slavevol)
+    remote.connect_remote()
+    local.connect()
+    logging.info("Worker spawn successful. Acknowledging back to monitor")
+    os.close(args.feedback_fd)
+    local.service_loop(remote)
+
+
+def subcmd_slave(args):
+    from resource import GLUSTER, Popen
+
+    Popen.init_errhandler()
+    slavevol = args.slave.split("::")[-1]
+    local = GLUSTER("localhost", slavevol)
+
+    local.connect()
+    local.service_loop()
+
+
+def subcmd_voluuidget(args):
+    from subprocess import Popen, PIPE
+    import xml.etree.ElementTree as XET
+
+    ParseError = XET.ParseError if hasattr(XET, 'ParseError') else SyntaxError
+
+    cmd = ['gluster', '--xml', '--remote-host=' + args.host,
+           'volume', 'info', args.volname]
+
+    if args.inet6:
+        cmd.append("--inet6")
+
+    po = Popen(cmd, bufsize=0,
+               stdin=None, stdout=PIPE, stderr=PIPE,
+               universal_newlines=True)
+
+    vix, err = po.communicate()
+    if po.returncode != 0:
+        logging.info(lf("Volume info failed, unable to get "
+                        "volume uuid of slavevol, "
+                        "returning empty string",
+                        slavevol=args.volname,
+                        slavehost=args.host,
+                        error=po.returncode))
+        return ""
+    vi = XET.fromstring(vix)
+    if vi.find('opRet').text != '0':
+        logging.info(lf("Unable to get volume uuid of slavevol, "
+                        "returning empty string",
+                        slavevol=args.volname,
+                        slavehost=args.host,
+                        error=vi.find('opErrstr').text))
+        return ""
+
+    try:
+        voluuid = vi.find("volInfo/volumes/volume/id").text
+    except (ParseError, AttributeError, ValueError) as e:
+        logging.info(lf("Parsing failed to volume uuid of slavevol, "
+                        "returning empty string",
+                        slavevol=args.volname,
+                        slavehost=args.host,
+                        error=e))
+        voluuid = ""
+
+    print(voluuid)
+
+
+def _unlink(path):
+    import os
+    from errno import ENOENT
+    from syncdutils import GsyncdError
+    import sys
+
+    try:
+        os.unlink(path)
+    except (OSError, IOError):
+        if sys.exc_info()[1].errno == ENOENT:
+            pass
+        else:
+            raise GsyncdError('Unlink error: %s' % path)
+
+
+def subcmd_delete(args):
+    import logging
+    import shutil
+    import glob
+    import sys
+    from errno import ENOENT, ENODATA
+    import struct
+
+    from syncdutils import GsyncdError, Xattr, errno_wrap
+    import gsyncdconfig as gconf
+
+    logging.info('geo-replication delete')
+    # remove the stime xattr from all the brick paths so that
+    # a re-create of a session will start sync all over again
+    stime_xattr_prefix = gconf.get('stime-xattr-prefix', None)
+
+    # Delete pid file, status file, socket file
+    cleanup_paths = []
+    cleanup_paths.append(gconf.get("pid-file"))
+
+    # Cleanup Session dir
+    try:
+        shutil.rmtree(gconf.get("georep-session-working-dir"))
+    except (IOError, OSError):
+        if sys.exc_info()[1].errno == ENOENT:
+            pass
+        else:
+            raise GsyncdError(
+                'Error while removing working dir: %s' %
+                gconf.get("georep-session-working-dir"))
+
+    # Cleanup changelog working dirs
+    try:
+        shutil.rmtree(gconf.get("working-dir"))
+    except (IOError, OSError):
+        if sys.exc_info()[1].errno == ENOENT:
+            pass
+        else:
+            raise GsyncdError(
+                'Error while removing working dir: %s' %
+                gconf.get("working-dir"))
+
+    for path in cleanup_paths:
+        # To delete temp files
+        for f in glob.glob(path + "*"):
+            _unlink(f)
+
+    if args.reset_sync_time and stime_xattr_prefix:
+        for p in args.paths:
+            if p != "":
+                # set stime to (0,0) to trigger full volume content resync
+                # to slave on session recreation
+                # look at master.py::Xcrawl   hint: zero_zero
+                errno_wrap(Xattr.lsetxattr,
+                           (p, stime_xattr_prefix + ".stime",
+                            struct.pack("!II", 0, 0)),
+                           [ENOENT, ENODATA])
+                errno_wrap(Xattr.lremovexattr,
+                           (p, stime_xattr_prefix + ".entry_stime"),
+                           [ENOENT, ENODATA])
+
+    return
+
+
+def print_config(name, value, only_value=False, use_underscore=False):
+    val = value
+    if isinstance(value, bool):
+        val = str(value).lower()
+
+    if only_value:
+        print(val)
+    else:
+        if use_underscore:
+            name = name.replace("-", "_")
+
+        print(("%s:%s" % (name, val)))
+
+
+def config_name_format(val):
+    return val.replace("_", "-")
+
+
+def subcmd_config_get(args):
+    import sys
+    import json
+
+    all_config = gconf.getall(show_defaults=args.show_defaults,
+                              show_non_configurable=True)
+    if args.name is not None:
+        val = all_config.get(config_name_format(args.name), None)
+        if val is None:
+            sys.stderr.write("Invalid config name \"%s\"\n" % args.name)
+            sys.exit(ERROR_CONFIG_INVALID)
+
+        print_config(args.name, val["value"], only_value=args.only_value,
+                     use_underscore=args.use_underscore)
+        return
+
+    if args.json:
+        out = []
+        # Convert all values as string
+        for k in sorted(all_config):
+            v = all_config[k]
+            out.append({
+                "name": k,
+                "value": str(v["value"]),
+                "default": str(v["default"]),
+                "configurable": v["configurable"],
+                "modified": v["modified"]
+            })
+
+        print((json.dumps(out)))
+        return
+
+    for k in sorted(all_config):
+        print_config(k, all_config[k]["value"],
+                     use_underscore=args.use_underscore)
+
+
+def subcmd_config_check(args):
+    import sys
+
+    try:
+        gconf.check(config_name_format(args.name), value=args.value,
+                    with_conffile=False)
+    except gconf.GconfNotConfigurable:
+        cnf_val = gconf.get(config_name_format(args.name), None)
+        if cnf_val is None:
+            sys.stderr.write("Invalid config name \"%s\"\n" % args.name)
+            sys.exit(ERROR_CONFIG_INVALID)
+
+        # Not configurable
+        sys.stderr.write("Not configurable \"%s\"\n" % args.name)
+        sys.exit(ERROR_CONFIG_NOT_CONFIGURABLE)
+    except gconf.GconfInvalidValue:
+        sys.stderr.write("Invalid config value \"%s=%s\"\n" % (args.name,
+                                                               args.value))
+        sys.exit(ERROR_CONFIG_INVALID_VALUE)
+
+
+def subcmd_config_set(args):
+    import sys
+
+    try:
+        gconf.setconfig(config_name_format(args.name), args.value)
+    except gconf.GconfNotConfigurable:
+        cnf_val = gconf.get(config_name_format(args.name), None)
+        if cnf_val is None:
+            sys.stderr.write("Invalid config name \"%s\"\n" % args.name)
+            sys.exit(ERROR_CONFIG_INVALID)
+
+        # Not configurable
+        sys.stderr.write("Not configurable \"%s\"\n" % args.name)
+        sys.exit(ERROR_CONFIG_NOT_CONFIGURABLE)
+    except gconf.GconfInvalidValue:
+        sys.stderr.write("Invalid config value \"%s=%s\"\n" % (args.name,
+                                                               args.value))
+        sys.exit(ERROR_CONFIG_INVALID_VALUE)
+
+
+def subcmd_config_reset(args):
+    import sys
+
+    try:
+        gconf.resetconfig(config_name_format(args.name))
+    except gconf.GconfNotConfigurable:
+        cnf_val = gconf.get(config_name_format(args.name), None)
+        if cnf_val is None:
+            sys.stderr.write("Invalid config name \"%s\"\n" % args.name)
+            sys.exit(ERROR_CONFIG_INVALID)
+
+        # Not configurable
+        sys.stderr.write("Not configurable \"%s\"\n" % args.name)
+        sys.exit(ERROR_CONFIG_NOT_CONFIGURABLE)
diff --git a/geo-replication/syncdaemon/syncdutils.py b/geo-replication/syncdaemon/syncdutils.py
index 2187ecd226b..a3df103e76c 100644
--- a/geo-replication/syncdaemon/syncdutils.py
+++ b/geo-replication/syncdaemon/syncdutils.py
@@ -15,24 +15,32 @@ import time
 import fcntl
 import shutil
 import logging
-import socket
+import errno
+import threading
 import subprocess
+import socket
+from subprocess import PIPE
 from threading import Lock, Thread as baseThread
-from errno import EACCES, EAGAIN, EPIPE, ENOTCONN, ECONNABORTED
-from errno import EINTR, ENOENT, EPERM, ESTALE, EBUSY, errorcode
+from errno import (EACCES, EAGAIN, EPIPE, ENOTCONN, ENOMEM, ECONNABORTED,
+                   EINTR, ENOENT, ESTALE, EBUSY, ENODATA, errorcode, EIO)
 from signal import signal, SIGTERM
 import select as oselect
 from os import waitpid as owaitpid
-import subprocess
+import xml.etree.ElementTree as XET
+from select import error as SelectError
+try:
+    from cPickle import PickleError
+except ImportError:
+    from pickle import PickleError
 
 from conf import GLUSTERFS_LIBEXECDIR, UUID_FILE
 sys.path.insert(1, GLUSTERFS_LIBEXECDIR)
 EVENTS_ENABLED = True
 try:
-    from events.eventtypes import GEOREP_FAULTY as EVENT_GEOREP_FAULTY
-    from events.eventtypes import GEOREP_ACTIVE as EVENT_GEOREP_ACTIVE
-    from events.eventtypes import GEOREP_PASSIVE as EVENT_GEOREP_PASSIVE
-    from events.eventtypes import GEOREP_CHECKPOINT_COMPLETED \
+    from gfevents.eventtypes import GEOREP_FAULTY as EVENT_GEOREP_FAULTY
+    from gfevents.eventtypes import GEOREP_ACTIVE as EVENT_GEOREP_ACTIVE
+    from gfevents.eventtypes import GEOREP_PASSIVE as EVENT_GEOREP_PASSIVE
+    from gfevents.eventtypes import GEOREP_CHECKPOINT_COMPLETED \
         as EVENT_GEOREP_CHECKPOINT_COMPLETED
 except ImportError:
     # Events APIs not installed, dummy eventtypes with None
@@ -42,50 +50,43 @@ except ImportError:
     EVENT_GEOREP_PASSIVE = None
     EVENT_GEOREP_CHECKPOINT_COMPLETED = None
 
-try:
-    from cPickle import PickleError
-except ImportError:
-    # py 3
-    from pickle import PickleError
+import gsyncdconfig as gconf
+from rconf import rconf
 
-from gconf import gconf
+from hashlib import sha256 as sha256
 
-try:
-    # py 3
-    from urllib import parse as urllib
-except ImportError:
-    import urllib
-
-try:
-    from hashlib import md5 as md5
-except ImportError:
-    # py 2.4
-    from md5 import new as md5
+ENOTSUP = getattr(errno, 'ENOTSUP', 'EOPNOTSUPP')
 
 # auxiliary gfid based access prefix
 _CL_AUX_GFID_PFX = ".gfid/"
+ROOT_GFID = "00000000-0000-0000-0000-000000000001"
 GF_OP_RETRIES = 10
 
 GX_GFID_CANONICAL_LEN = 37  # canonical gfid len + '\0'
 
-CHANGELOG_AGENT_SERVER_VERSION = 1.0
-CHANGELOG_AGENT_CLIENT_VERSION = 1.0
 NodeID = None
 rsync_version = None
+unshare_mnt_propagation = None
+slv_bricks = None
 SPACE_ESCAPE_CHAR = "%20"
 NEWLINE_ESCAPE_CHAR = "%0A"
 PERCENTAGE_ESCAPE_CHAR = "%25"
 
+final_lock = Lock()
+
+def sup(x, *a, **kw):
+    """a rubyesque "super" for python ;)
+
+    invoke caller method in parent class with given args.
+    """
+    return getattr(super(type(x), x),
+                   sys._getframe(1).f_code.co_name)(*a, **kw)
+
 
 def escape(s):
     """the chosen flavor of string escaping, used all over
        to turn whatever data to creatable representation"""
-    return urllib.quote_plus(s)
-
-
-def unescape(s):
-    """inverse of .escape"""
-    return urllib.unquote_plus(s)
+    return s.replace("/", "-").strip("-")
 
 
 def escape_space_newline(s):
@@ -99,6 +100,19 @@ def unescape_space_newline(s):
             .replace(NEWLINE_ESCAPE_CHAR, "\n")\
             .replace(PERCENTAGE_ESCAPE_CHAR, "%")
 
+# gf_mount_ready() returns 1 if all subvols are up, else 0
+def gf_mount_ready():
+    ret = errno_wrap(Xattr.lgetxattr,
+                     ['.', 'dht.subvol.status', 16],
+                     [ENOENT, ENOTSUP, ENODATA], [ENOMEM])
+
+    if isinstance(ret, int):
+       logging.error("failed to get the xattr value")
+       return 1
+    ret = ret.rstrip('\x00')
+    if ret == "1":
+       return 1
+    return 0
 
 def norm(s):
     if s:
@@ -157,17 +171,26 @@ def setup_ssh_ctl(ctld, remote_addr, resource_url):
     """
     Setup GConf ssh control path parameters
     """
-    gconf.ssh_ctl_dir = ctld
+    rconf.ssh_ctl_dir = ctld
     content = "SLAVE_HOST=%s\nSLAVE_RESOURCE_URL=%s" % (remote_addr,
                                                         resource_url)
-    content_md5 = md5hex(content)
-    fname = os.path.join(gconf.ssh_ctl_dir,
-                         "%s.mft" % content_md5)
+    encoded_content = content.encode()
+    content_sha256 = sha256hex(encoded_content)
+    """
+    The length of ctl_path for ssh connection should not be > 108.
+    ssh fails with ctl_path too long if it is so. But when rsync
+    is piped to ssh, it is not taking > 90. Hence using first 32
+    bytes of hash. Hash collision doesn't matter as only one sock
+    file is created per directory.
+    """
+    content_sha256 = content_sha256[:32]
+    fname = os.path.join(rconf.ssh_ctl_dir,
+                         "%s.mft" % content_sha256)
 
-    create_manifest(fname, content)
-    ssh_ctl_path = os.path.join(gconf.ssh_ctl_dir,
-                                "%s.sock" % content_md5)
-    gconf.ssh_ctl_args = ["-oControlMaster=auto", "-S", ssh_ctl_path]
+    create_manifest(fname, encoded_content)
+    ssh_ctl_path = os.path.join(rconf.ssh_ctl_dir,
+                                "%s.sock" % content_sha256)
+    rconf.ssh_ctl_args = ["-oControlMaster=auto", "-S", ssh_ctl_path]
 
 
 def grabfile(fname, content=None):
@@ -177,7 +200,7 @@ def grabfile(fname, content=None):
     """
     # damn those messy open() mode codes
     fd = os.open(fname, os.O_CREAT | os.O_RDWR)
-    f = os.fdopen(fd, 'r+b', 0)
+    f = os.fdopen(fd, 'r+')
     try:
         fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
     except:
@@ -191,35 +214,34 @@ def grabfile(fname, content=None):
         try:
             f.truncate()
             f.write(content)
+            f.flush()
         except:
             f.close()
             raise
-    gconf.permanent_handles.append(f)
+    rconf.permanent_handles.append(f)
     return f
 
 
 def grabpidfile(fname=None, setpid=True):
     """.grabfile customization for pid files"""
     if not fname:
-        fname = gconf.pid_file
+        fname = gconf.get("pid-file")
     content = None
     if setpid:
         content = str(os.getpid()) + '\n'
     return grabfile(fname, content=content)
 
-final_lock = Lock()
 
-mntpt_list = []
-def finalize(*a, **kw):
+def finalize(*args, **kwargs):
     """all those messy final steps we go trough upon termination
 
     Do away with pidfile, ssh control dir and logging.
     """
 
     final_lock.acquire()
-    if getattr(gconf, 'pid_file', None):
-        rm_pidf = gconf.pid_file_owned
-        if gconf.cpid:
+    if gconf.get('pid_file'):
+        rm_pidf = rconf.pid_file_owned
+        if rconf.cpid:
             # exit path from parent branch of daemonization
             rm_pidf = False
             while True:
@@ -227,52 +249,50 @@ def finalize(*a, **kw):
                 if not f:
                     # child has already taken over pidfile
                     break
-                if os.waitpid(gconf.cpid, os.WNOHANG)[0] == gconf.cpid:
+                if os.waitpid(rconf.cpid, os.WNOHANG)[0] == rconf.cpid:
                     # child has terminated
                     rm_pidf = True
                     break
                 time.sleep(0.1)
         if rm_pidf:
             try:
-                os.unlink(gconf.pid_file)
+                os.unlink(rconf.pid_file)
             except:
                 ex = sys.exc_info()[1]
                 if ex.errno == ENOENT:
                     pass
                 else:
                     raise
-    if gconf.ssh_ctl_dir and not gconf.cpid:
+    if rconf.ssh_ctl_dir and not rconf.cpid:
         def handle_rm_error(func, path, exc_info):
             if exc_info[1].errno == ENOENT:
                 return
             raise exc_info[1]
 
-        shutil.rmtree(gconf.ssh_ctl_dir, onerror=handle_rm_error)
-    if getattr(gconf, 'state_socket', None):
-        try:
-            os.unlink(gconf.state_socket)
-        except:
-            if sys.exc_info()[0] == OSError:
-                pass
+        shutil.rmtree(rconf.ssh_ctl_dir, onerror=handle_rm_error)
 
     """ Unmount if not done """
-    for mnt in mntpt_list:
-        p0 = subprocess.Popen (["umount", "-l", mnt], stderr=subprocess.PIPE)
+    if rconf.mount_point:
+        if rconf.mountbroker:
+            umount_cmd = rconf.mbr_umount_cmd + [rconf.mount_point, 'lazy']
+        else:
+            umount_cmd = ['umount', '-l', rconf.mount_point]
+        p0 = subprocess.Popen(umount_cmd, stderr=subprocess.PIPE,
+                              universal_newlines=True)
         _, errdata = p0.communicate()
         if p0.returncode == 0:
             try:
-                os.rmdir(mnt)
+                os.rmdir(rconf.mount_point)
             except OSError:
                 pass
         else:
             pass
 
-    if gconf.log_exit:
+    if rconf.log_exit:
         logging.info("exiting.")
     sys.stdout.flush()
     sys.stderr.flush()
-    os._exit(kw.get('exval', 0))
-
+    os._exit(kwargs.get('exval', 0))
 
 
 def log_raise_exception(excont):
@@ -282,6 +302,7 @@ def log_raise_exception(excont):
     Translate some weird sounding but well understood exceptions
     into human-friendly lingo
     """
+
     is_filelog = False
     for h in logging.getLogger().handlers:
         fno = getattr(getattr(h, 'stream', None), 'fileno', None)
@@ -302,9 +323,9 @@ def log_raise_exception(excont):
             ((isinstance(exc, OSError) or isinstance(exc, IOError)) and
              exc.errno == EPIPE):
             logging.error('connection to peer is broken')
-            if hasattr(gconf, 'transport'):
-                gconf.transport.wait()
-                if gconf.transport.returncode == 127:
+            if hasattr(rconf, 'transport'):
+                rconf.transport.wait()
+                if rconf.transport.returncode == 127:
                     logging.error("getting \"No such file or directory\""
                                   "errors is most likely due to "
                                   "MISCONFIGURATION, please remove all "
@@ -318,18 +339,29 @@ def log_raise_exception(excont):
                                   "<SLAVEVOL> config remote-gsyncd "
                                   "<GSYNCD_PATH> (Example GSYNCD_PATH: "
                                   "`/usr/libexec/glusterfs/gsyncd`)")
-                gconf.transport.terminate_geterr()
+                rconf.transport.terminate_geterr()
         elif isinstance(exc, OSError) and exc.errno in (ENOTCONN,
                                                         ECONNABORTED):
-            logging.error(lf('glusterfs session went down',
+            logging.error(lf('Gluster Mount process exited',
                              error=errorcode[exc.errno]))
+        elif isinstance(exc, OSError) and exc.errno == EIO:
+            logging.error("Getting \"Input/Output error\" "
+                          "is most likely due to "
+                          "a. Brick is down or "
+                          "b. Split brain issue.")
+            logging.error("This is expected as per design to "
+                          "keep the consistency of the file system. "
+                          "Once the above issue is resolved "
+                          "geo-replication would automatically "
+                          "proceed further.")
+            logtag = "FAIL"
         else:
             logtag = "FAIL"
         if not logtag and logging.getLogger().isEnabledFor(logging.DEBUG):
             logtag = "FULL EXCEPTION TRACE"
         if logtag:
             logging.exception(logtag + ": ")
-            sys.stderr.write("failed with %s.\n" % type(exc).__name__)
+            sys.stderr.write("failed with %s: %s.\n" % (type(exc).__name__, exc))
         excont.exval = 1
         sys.exit(excont.exval)
 
@@ -352,20 +384,20 @@ class Thread(baseThread):
       function coughs up an exception
     """
 
-    def __init__(self, *a, **kw):
-        tf = kw.get('target')
+    def __init__(self, *args, **kwargs):
+        tf = kwargs.get('target')
         if tf:
-            def twrap(*aa):
+            def twrap(*aargs):
                 excont = FreeObject(exval=0)
                 try:
-                    tf(*aa)
+                    tf(*aargs)
                 except:
                     try:
                         log_raise_exception(excont)
                     finally:
                         finalize(exval=excont.exval)
-            kw['target'] = twrap
-        baseThread.__init__(self, *a, **kw)
+            kwargs['target'] = twrap
+        baseThread.__init__(self, *args, **kwargs)
         self.setDaemon(True)
 
 
@@ -430,7 +462,7 @@ def boolify(s):
     lstr = s.lower()
     if lstr in true_list:
         rv = True
-    elif not lstr in false_list:
+    elif lstr not in false_list:
         logging.warn(lf("Unknown string in \"string to boolean\" conversion, "
                         "defaulting to False",
                         str=s))
@@ -438,29 +470,33 @@ def boolify(s):
     return rv
 
 
-def eintr_wrap(func, exc, *a):
+def eintr_wrap(func, exc, *args):
     """
     wrapper around syscalls resilient to interrupt caused
     by signals
     """
     while True:
         try:
-            return func(*a)
+            return func(*args)
         except exc:
             ex = sys.exc_info()[1]
             if not ex.args[0] == EINTR:
                 raise
 
 
-def select(*a):
-    return eintr_wrap(oselect.select, oselect.error, *a)
+def select(*args):
+    return eintr_wrap(oselect.select, oselect.error, *args)
 
 
-def waitpid(*a):
-    return eintr_wrap(owaitpid, OSError, *a)
+def waitpid(*args):
+    return eintr_wrap(owaitpid, OSError, *args)
 
 
-def set_term_handler(hook=lambda *a: finalize(*a, **{'exval': 1})):
+def term_handler_default_hook(signum, frame):
+    finalize(signum, frame, exval=1)
+
+
+def set_term_handler(hook=term_handler_default_hook):
     signal(SIGTERM, hook)
 
 
@@ -518,8 +554,8 @@ def gauxpfx():
     return _CL_AUX_GFID_PFX
 
 
-def md5hex(s):
-    return md5(s).hexdigest()
+def sha256hex(s):
+    return sha256(s).hexdigest()
 
 
 def selfkill(sig=SIGTERM):
@@ -537,7 +573,7 @@ def errno_wrap(call, arg=[], errnos=[], retry_errnos=[]):
             ex = sys.exc_info()[1]
             if ex.errno in errnos:
                 return ex.errno
-            if not ex.errno in retry_errnos:
+            if ex.errno not in retry_errnos:
                 raise
             nr_tries += 1
             if nr_tries == GF_OP_RETRIES:
@@ -552,7 +588,6 @@ def errno_wrap(call, arg=[], errnos=[], retry_errnos=[]):
 def lstat(e):
     return errno_wrap(os.lstat, [e], [ENOENT], [ESTALE, EBUSY])
 
-
 def get_gfid_from_mnt(gfidpath):
     return errno_wrap(Xattr.lgetxattr,
                       [gfidpath, 'glusterfs.gfid.string',
@@ -588,7 +623,7 @@ class ChangelogException(OSError):
 
 def gf_event(event_type, **kwargs):
     if EVENTS_ENABLED:
-        from events.gf_event import gf_event as gfevent
+        from gfevents.gf_event import gf_event as gfevent
         gfevent(event_type, **kwargs)
 
 
@@ -620,6 +655,23 @@ def get_master_and_slave_data_from_args(args):
 
     return (master_name, slave_data)
 
+def unshare_propagation_supported():
+    global unshare_mnt_propagation
+    if unshare_mnt_propagation is not None:
+        return unshare_mnt_propagation
+
+    unshare_mnt_propagation = False
+    p = subprocess.Popen(["unshare", "--help"],
+                         stderr=subprocess.PIPE,
+                         stdout=subprocess.PIPE,
+                         universal_newlines=True)
+    out, err = p.communicate()
+    if p.returncode == 0:
+        if "propagation" in out:
+            unshare_mnt_propagation = True
+
+    return unshare_mnt_propagation
+
 
 def get_rsync_version(rsync_cmd):
     global rsync_version
@@ -629,7 +681,8 @@ def get_rsync_version(rsync_cmd):
     rsync_version = "0"
     p = subprocess.Popen([rsync_cmd, "--version"],
                          stderr=subprocess.PIPE,
-                         stdout=subprocess.PIPE)
+                         stdout=subprocess.PIPE,
+                         universal_newlines=True)
     out, err = p.communicate()
     if p.returncode == 0:
         rsync_version = out.split(" ", 4)[3]
@@ -637,14 +690,426 @@ def get_rsync_version(rsync_cmd):
     return rsync_version
 
 
+def get_slv_dir_path(slv_host, slv_volume, gfid):
+    global slv_bricks
+
+    dir_path = ENOENT
+    pfx = gauxpfx()
+
+    if not slv_bricks:
+        slv_info = Volinfo(slv_volume, slv_host, master=False)
+        slv_bricks = slv_info.bricks
+    # Result of readlink would be of format as below.
+    # readlink = "../../pgfid[0:2]/pgfid[2:4]/pgfid/basename"
+    for brick in slv_bricks:
+        dir_path = errno_wrap(os.path.join,
+                              [brick['dir'],
+                               ".glusterfs", gfid[0:2],
+                               gfid[2:4],
+                               gfid], [ENOENT], [ESTALE])
+        if dir_path != ENOENT:
+            try:
+                realpath = errno_wrap(os.readlink, [dir_path],
+                                      [ENOENT], [ESTALE])
+                if not isinstance(realpath, int):
+                    realpath_parts = realpath.split('/')
+                    pargfid = realpath_parts[-2]
+                    basename = realpath_parts[-1]
+                    dir_entry = os.path.join(pfx, pargfid, basename)
+                    return dir_entry
+            except OSError:
+                # .gfid/GFID
+                gfidpath = unescape_space_newline(os.path.join(pfx, gfid))
+                realpath = errno_wrap(Xattr.lgetxattr_buf,
+                      [gfidpath, 'glusterfs.gfid2path'], [ENOENT], [ESTALE])
+                if not isinstance(realpath, int):
+                    basename = os.path.basename(realpath).rstrip('\x00')
+                    dirpath = os.path.dirname(realpath)
+                    if dirpath == "/":
+                        pargfid = ROOT_GFID
+                    else:
+                        dirpath = dirpath.strip("/")
+                        pargfid = get_gfid_from_mnt(dirpath)
+                        if isinstance(pargfid, int):
+                            return None
+                    dir_entry = os.path.join(pfx, pargfid, basename)
+                    return dir_entry
+
+    return None
+
+
 def lf(event, **kwargs):
     """
     Log Format helper function, log messages can be
     easily modified to structured log format.
     lf("Config Change", sync_jobs=4, brick=/bricks/b1) will be
-    converted as "Config Change<TAB>brick=/bricks/b1<TAB>sync_jobs=4"
+    converted as "Config Change [{brick=/bricks/b1}, {sync_jobs=4}]"
     """
-    msg = event
+    msgparts = []
     for k, v in kwargs.items():
-        msg += "\t{0}={1}".format(k, v)
-    return msg
+        msgparts.append("{%s=%s}" % (k, v))
+    return "%s [%s]" % (event, ", ".join(msgparts))
+
+
+class Popen(subprocess.Popen):
+
+    """customized subclass of subprocess.Popen with a ring
+    buffer for children error output"""
+
+    @classmethod
+    def init_errhandler(cls):
+        """start the thread which handles children's error output"""
+        cls.errstore = {}
+
+        def tailer():
+            while True:
+                errstore = cls.errstore.copy()
+                try:
+                    poe, _, _ = select(
+                        [po.stderr for po in errstore], [], [], 1)
+                except (ValueError, SelectError):
+                    # stderr is already closed wait for some time before
+                    # checking next error
+                    time.sleep(0.5)
+                    continue
+                for po in errstore:
+                    if po.stderr not in poe:
+                        continue
+                    po.lock.acquire()
+                    try:
+                        if po.on_death_row:
+                            continue
+                        la = errstore[po]
+                        try:
+                            fd = po.stderr.fileno()
+                        except ValueError:  # file is already closed
+                            time.sleep(0.5)
+                            continue
+
+                        try:
+                            l = os.read(fd, 1024)
+                        except OSError:
+                            time.sleep(0.5)
+                            continue
+
+                        if not l:
+                            continue
+                        tots = len(l)
+                        for lx in la:
+                            tots += len(lx)
+                        while tots > 1 << 20 and la:
+                            tots -= len(la.pop(0))
+                        la.append(l)
+                    finally:
+                        po.lock.release()
+        t = Thread(target=tailer)
+        t.start()
+        cls.errhandler = t
+
+    @classmethod
+    def fork(cls):
+        """fork wrapper that restarts errhandler thread in child"""
+        pid = os.fork()
+        if not pid:
+            cls.init_errhandler()
+        return pid
+
+    def __init__(self, args, *a, **kw):
+        """customizations for subprocess.Popen instantiation
+
+        - 'close_fds' is taken to be the default
+        - if child's stderr is chosen to be managed,
+          register it with the error handler thread
+        """
+        self.args = args
+        if 'close_fds' not in kw:
+            kw['close_fds'] = True
+        self.lock = threading.Lock()
+        self.on_death_row = False
+        self.elines = []
+        try:
+            sup(self, args, *a, **kw)
+        except:
+            ex = sys.exc_info()[1]
+            if not isinstance(ex, OSError):
+                raise
+            raise GsyncdError("""execution of "%s" failed with %s (%s)""" %
+                              (args[0], errno.errorcode[ex.errno],
+                               os.strerror(ex.errno)))
+        if kw.get('stderr') == subprocess.PIPE:
+            assert(getattr(self, 'errhandler', None))
+            self.errstore[self] = []
+
+    def errlog(self):
+        """make a log about child's failure event"""
+        logging.error(lf("command returned error",
+                         cmd=" ".join(self.args),
+                         error=self.returncode))
+        lp = ''
+
+        def logerr(l):
+            logging.error(self.args[0] + "> " + l)
+        for l in self.elines:
+            ls = l.split('\n')
+            ls[0] = lp + ls[0]
+            lp = ls.pop()
+            for ll in ls:
+                logerr(ll)
+        if lp:
+            logerr(lp)
+
+    def errfail(self):
+        """fail nicely if child did not terminate with success"""
+        self.errlog()
+        finalize(exval=1)
+
+    def terminate_geterr(self, fail_on_err=True):
+        """kill child, finalize stderr harvesting (unregister
+        from errhandler, set up .elines), fail on error if
+        asked for
+        """
+        self.lock.acquire()
+        try:
+            self.on_death_row = True
+        finally:
+            self.lock.release()
+        elines = self.errstore.pop(self)
+        if self.poll() is None:
+            self.terminate()
+            if self.poll() is None:
+                time.sleep(0.1)
+                self.kill()
+                self.wait()
+        while True:
+            if not select([self.stderr], [], [], 0.1)[0]:
+                break
+            b = os.read(self.stderr.fileno(), 1024)
+            if b:
+                elines.append(b.decode())
+            else:
+                break
+        self.stderr.close()
+        self.elines = elines
+        if fail_on_err and self.returncode != 0:
+            self.errfail()
+
+
+def host_brick_split(value):
+    """
+    IPv6 compatible way to split and get the host
+    and brick information. Example inputs:
+    node1.example.com:/exports/bricks/brick1/brick
+    fe80::af0f:df82:844f:ef66%utun0:/exports/bricks/brick1/brick
+    """
+    parts = value.split(":")
+    brick = parts[-1]
+    hostparts = parts[0:-1]
+    return (":".join(hostparts), brick)
+
+
+class Volinfo(object):
+
+    def __init__(self, vol, host='localhost', prelude=[], master=True):
+        if master:
+            gluster_cmd_dir = gconf.get("gluster-command-dir")
+        else:
+            gluster_cmd_dir = gconf.get("slave-gluster-command-dir")
+
+        gluster_cmd = os.path.join(gluster_cmd_dir, 'gluster')
+        po = Popen(prelude + [gluster_cmd, '--xml', '--remote-host=' + host,
+                              'volume', 'info', vol],
+                   stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        vix = po.stdout.read()
+        po.wait()
+        po.terminate_geterr()
+        vi = XET.fromstring(vix)
+        if vi.find('opRet').text != '0':
+            if prelude:
+                via = '(via %s) ' % prelude.join(' ')
+            else:
+                via = ' '
+            raise GsyncdError('getting volume info of %s%s '
+                              'failed with errorcode %s' %
+                              (vol, via, vi.find('opErrno').text))
+        self.tree = vi
+        self.volume = vol
+        self.host = host
+
+    def get(self, elem):
+        return self.tree.findall('.//' + elem)
+
+    def is_tier(self):
+        return (self.get('typeStr')[0].text == 'Tier')
+
+    def is_hot(self, brickpath):
+        logging.debug('brickpath: ' + repr(brickpath))
+        return brickpath in self.hot_bricks
+
+    @property
+    @memoize
+    def bricks(self):
+        def bparse(b):
+            host, dirp = host_brick_split(b.find("name").text)
+            return {'host': host, 'dir': dirp, 'uuid': b.find("hostUuid").text}
+        return [bparse(b) for b in self.get('brick')]
+
+    @property
+    @memoize
+    def uuid(self):
+        ids = self.get('id')
+        if len(ids) != 1:
+            raise GsyncdError("volume info of %s obtained from %s: "
+                              "ambiguous uuid" % (self.volume, self.host))
+        return ids[0].text
+
+    def replica_count(self, tier, hot):
+        if (tier and hot):
+            return int(self.get('hotBricks/hotreplicaCount')[0].text)
+        elif (tier and not hot):
+            return int(self.get('coldBricks/coldreplicaCount')[0].text)
+        else:
+            return int(self.get('replicaCount')[0].text)
+
+    def disperse_count(self, tier, hot):
+        if (tier and hot):
+            # Tiering doesn't support disperse volume as hot brick,
+            # hence no xml output, so returning 0. In case, if it's
+            # supported later, we should change here.
+            return 0
+        elif (tier and not hot):
+            return int(self.get('coldBricks/colddisperseCount')[0].text)
+        else:
+            return int(self.get('disperseCount')[0].text)
+
+    def distribution_count(self, tier, hot):
+        if (tier and hot):
+            return int(self.get('hotBricks/hotdistCount')[0].text)
+        elif (tier and not hot):
+            return int(self.get('coldBricks/colddistCount')[0].text)
+        else:
+            return int(self.get('distCount')[0].text)
+
+    @property
+    @memoize
+    def hot_bricks(self):
+        return [b.text for b in self.get('hotBricks/brick')]
+
+    def get_hot_bricks_count(self, tier):
+        if (tier):
+            return int(self.get('hotBricks/hotbrickCount')[0].text)
+        else:
+            return 0
+
+
+class VolinfoFromGconf(object):
+    # Glusterd will generate following config items before Geo-rep start
+    # So that Geo-rep need not run gluster commands from inside
+    # Volinfo object API/interface kept as is so that caller need not
+    # change anything except calling this instead of Volinfo()
+    #
+    # master-bricks=
+    # master-bricks=NODEID:HOSTNAME:PATH,..
+    # slave-bricks=NODEID:HOSTNAME,..
+    # master-volume-id=
+    # slave-volume-id=
+    # master-replica-count=
+    # master-disperse_count=
+    def __init__(self, vol, host='localhost', master=True):
+        self.volume = vol
+        self.host = host
+        self.master = master
+
+    def is_tier(self):
+        return False
+
+    def is_hot(self, brickpath):
+        return False
+
+    def is_uuid(self, value):
+        try:
+            uuid.UUID(value)
+            return True
+        except ValueError:
+            return False
+
+    def possible_path(self, value):
+        return "/" in value
+
+    @property
+    @memoize
+    def bricks(self):
+        pfx = "master-" if self.master else "slave-"
+        bricks_data = gconf.get(pfx + "bricks")
+        if bricks_data is None:
+            return []
+
+        bricks_data = bricks_data.split(",")
+        bricks_data = [b.strip() for b in bricks_data]
+        out = []
+        for b in bricks_data:
+            parts = b.split(":")
+            b_uuid = None
+            if self.is_uuid(parts[0]):
+                b_uuid = parts[0]
+                # Set all parts except first
+                parts = parts[1:]
+
+            if self.possible_path(parts[-1]):
+                bpath = parts[-1]
+                # Set all parts except last
+                parts = parts[0:-1]
+
+            out.append({
+                "host": ":".join(parts),   # if remaining parts are IPv6 name
+                "dir": bpath,
+                "uuid": b_uuid
+            })
+
+        return out
+
+    @property
+    @memoize
+    def uuid(self):
+        if self.master:
+            return gconf.get("master-volume-id")
+        else:
+            return gconf.get("slave-volume-id")
+
+    def replica_count(self, tier, hot):
+        return gconf.get("master-replica-count")
+
+    def disperse_count(self, tier, hot):
+        return gconf.get("master-disperse-count")
+
+    def distribution_count(self, tier, hot):
+        return gconf.get("master-distribution-count")
+
+    @property
+    @memoize
+    def hot_bricks(self):
+        return []
+
+    def get_hot_bricks_count(self, tier):
+        return 0
+
+
+def can_ssh(host, port=22):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        s.connect((host, port))
+        flag = True
+    except socket.error:
+        flag = False
+
+    s.close()
+    return flag
+
+
+def get_up_nodes(hosts, port):
+    # List of hosts with Hostname/IP and UUID
+    up_nodes = []
+    for h in hosts:
+        if can_ssh(h[0], port):
+            up_nodes.append(h)
+
+    return up_nodes
diff --git a/geo-replication/tests/__init__.py b/geo-replication/tests/__init__.py
index 23adbfa5171..b4648b69645 100644
--- a/geo-replication/tests/__init__.py
+++ b/geo-replication/tests/__init__.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
diff --git a/geo-replication/tests/unit/__init__.py b/geo-replication/tests/unit/__init__.py
index 23adbfa5171..b4648b69645 100644
--- a/geo-replication/tests/unit/__init__.py
+++ b/geo-replication/tests/unit/__init__.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
diff --git a/geo-replication/tests/unit/test_gsyncdstatus.py b/geo-replication/tests/unit/test_gsyncdstatus.py
index a65d659e356..9c1aa2ad4ad 100644..100755
--- a/geo-replication/tests/unit/test_gsyncdstatus.py
+++ b/geo-replication/tests/unit/test_gsyncdstatus.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -13,11 +13,11 @@ import unittest
 import os
 import urllib
 
-from syncdaemon.gstatus import GeorepStatus, set_monitor_status
-from syncdaemon.gstatus import get_default_values
-from syncdaemon.gstatus import MONITOR_STATUS, DEFAULT_STATUS
-from syncdaemon.gstatus import STATUS_VALUES, CRAWL_STATUS_VALUES
-from syncdaemon.gstatus import human_time, human_time_utc
+from syncdaemon.gstatus import (GeorepStatus, set_monitor_status,
+                                get_default_values,
+                                MONITOR_STATUS, DEFAULT_STATUS,
+                                STATUS_VALUES, CRAWL_STATUS_VALUES,
+                                human_time, human_time_utc)
 
 
 class GeorepStatusTestCase(unittest.TestCase):
diff --git a/geo-replication/tests/unit/test_syncdutils.py b/geo-replication/tests/unit/test_syncdutils.py
index 736ae274b85..ff537ab2660 100644
--- a/geo-replication/tests/unit/test_syncdutils.py
+++ b/geo-replication/tests/unit/test_syncdutils.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
diff --git a/glusterfs-api.pc.in b/glusterfs-api.pc.in
index 5d234543414..4a2edb7bf07 100644
--- a/glusterfs-api.pc.in
+++ b/glusterfs-api.pc.in
@@ -9,4 +9,4 @@ Description: GlusterFS API
 Version: @GFAPI_VERSION@
 Requires: @PKGCONFIG_UUID@
 Libs: -L${libdir} @GFAPI_LIBS@ -lgfapi -lglusterfs -lgfrpc -lgfxdr
-Cflags: -I${includedir}/glusterfs -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -DUSE_POSIX_ACLS=@USE_POSIX_ACLS@
+Cflags: -I${includedir} -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D__USE_LARGEFILE64 -DUSE_POSIX_ACLS=@USE_POSIX_ACLS@
diff --git a/glusterfs.spec.in b/glusterfs.spec.in
index 8b4fa349e76..b6d63146e14 100644
--- a/glusterfs.spec.in
+++ b/glusterfs.spec.in
@@ -9,52 +9,78 @@
 ## All argument definitions should be placed here and keep them sorted
 ##
 
-# if you wish to compile an rpm with debugging...
-# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with debug
-%{?_with_debug:%global _with_debug --enable-debug}
+# asan
+# if you wish to compile an rpm with address sanitizer...
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with asan
+%{?_with_asan:%global _with_asan --enable-asan}
 
-# if you wish to compile an rpm to run all processes under valgrind...
-# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with valgrind
-%{?_with_valgrind:%global _with_valgrind --enable-valgrind}
+%if ( 0%{?rhel} && 0%{?rhel} < 7 )
+%global _with_asan %{nil}
+%endif
 
+# cmocka
 # if you wish to compile an rpm with cmocka unit testing...
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with cmocka
 %{?_with_cmocka:%global _with_cmocka --enable-cmocka}
 
-# if you wish to compile an rpm without rdma support, compile like this...
-# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without rdma
-%{?_without_rdma:%global _without_rdma --disable-ibverbs}
-
-# No RDMA Support on s390(x)
-%ifarch s390 s390x armv7hl
-%global _without_rdma --disable-ibverbs
-%endif
+# debug
+# if you wish to compile an rpm with debugging...
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with debug
+%{?_with_debug:%global _with_debug --enable-debug}
 
+# epoll
 # if you wish to compile an rpm without epoll...
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without epoll
 %{?_without_epoll:%global _without_epoll --disable-epoll}
 
+# fusermount
 # if you wish to compile an rpm without fusermount...
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without fusermount
 %{?_without_fusermount:%global _without_fusermount --disable-fusermount}
 
+# geo-rep
 # if you wish to compile an rpm without geo-replication support, compile like this...
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without georeplication
 %{?_without_georeplication:%global _without_georeplication --disable-georeplication}
 
-# Disable geo-replication on EL5, as its default Python is too old
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-%global _without_georeplication --disable-georeplication
-%endif
-
+# gnfs
 # if you wish to compile an rpm with the legacy gNFS server xlator
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with gnfs
 %{?_with_gnfs:%global _with_gnfs --enable-gnfs}
 
+# ipv6default
+# if you wish to compile an rpm with IPv6 default...
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with ipv6default
+%{?_with_ipv6default:%global _with_ipv6default --with-ipv6-default}
+
+# libtirpc
+# if you wish to compile an rpm without TIRPC (i.e. use legacy glibc rpc)
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without libtirpc
+%{?_without_libtirpc:%global _without_libtirpc --without-libtirpc}
+
+# Do not use libtirpc on EL6, it does not have xdr_uint64_t() and xdr_uint32_t
+# Do not use libtirpc on EL7, it does not have xdr_sizeof()
+%if ( 0%{?rhel} && 0%{?rhel} <= 7 )
+%global _without_libtirpc --without-libtirpc
+%endif
+
+
+# ocf
 # if you wish to compile an rpm without the OCF resource agents...
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without ocf
 %{?_without_ocf:%global _without_ocf --without-ocf}
 
+# server
+# if you wish to build rpms without server components, compile like this
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without server
+%{?_without_server:%global _without_server --without-server}
+
+# disable server components forcefully as rhel <= 6
+%if ( 0%{?rhel} && 0%{?rhel} <= 6 )
+%global _without_server --without-server
+%endif
+
+# syslog
 # if you wish to build rpms without syslog logging, compile like this
 # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without syslog
 %{?_without_syslog:%global _without_syslog --disable-syslog}
@@ -67,24 +93,31 @@
 %global _without_syslog --disable-syslog
 %endif
 
-# if you wish to compile an rpm without the BD map support...
-# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without bd
-%{?_without_bd:%global _without_bd --disable-bd-xlator}
+# tsan
+# if you wish to compile an rpm with thread sanitizer...
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with tsan
+%{?_with_tsan:%global _with_tsan --enable-tsan}
 
-%if ( 0%{?rhel} && 0%{?rhel} < 6 || 0%{?sles_version} )
-%global _without_bd --disable-bd-xlator
+%if ( 0%{?rhel} && 0%{?rhel} < 7 )
+%global _with_tsan %{nil}
 %endif
 
-# Disable data-tiering on EL5, sqlite is too old
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-%global _without_tiering --disable-tiering
-%endif
+# valgrind
+# if you wish to compile an rpm to run all processes under valgrind...
+# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with valgrind
+%{?_with_valgrind:%global _with_valgrind --enable-valgrind}
 
 ##-----------------------------------------------------------------------------
 ## All %%global definitions should be placed here and keep them sorted
 ##
 
-%if ( 0%{?fedora} && 0%{?fedora} > 16 ) || ( 0%{?rhel} && 0%{?rhel} > 6 )
+# selinux booleans whose defalut value needs modification
+# these booleans will be consumed by "%%selinux_set_booleans" macro.
+%if ( 0%{?rhel} && 0%{?rhel} >= 8 )
+%global selinuxbooleans rsync_full_access=1 rsync_client=1
+%endif
+
+%if ( 0%{?fedora} ) || ( 0%{?rhel} && 0%{?rhel} > 6 )
 %global _with_systemd true
 %endif
 
@@ -98,9 +131,20 @@
 %global _with_tmpfilesdir --without-tmpfilesdir
 %endif
 
-# Eventing
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
+# without server should also disable some server-only components
+%if 0%{?_without_server:1}
 %global _without_events --disable-events
+%global _without_georeplication --disable-georeplication
+%global _with_gnfs %{nil}
+%global _without_ocf --without-ocf
+%endif
+
+%if ( 0%{?fedora} ) || ( 0%{?rhel} && 0%{?rhel} > 7 )
+%global _usepython3 1
+%global _pythonver 3
+%else
+%global _usepython3 0
+%global _pythonver 2
 %endif
 
 # From https://fedoraproject.org/wiki/Packaging:Python#Macros
@@ -111,45 +155,39 @@
 %endif
 
 %if ( 0%{?_with_systemd:1} )
-%global _init_enable()  /bin/systemctl enable %1.service ;
-%global _init_disable() /bin/systemctl disable %1.service ;
-%global _init_restart() /bin/systemctl try-restart %1.service ;
-%global _init_start()   /bin/systemctl start %1.service ;
-%global _init_stop()    /bin/systemctl stop %1.service ;
-%global _init_install() install -D -p -m 0644 %1 %{buildroot}%{_unitdir}/%2.service ;
+%global service_start()   /bin/systemctl --quiet start %1.service || : \
+%{nil}
+%global service_stop()    /bin/systemctl --quiet stop %1.service || :\
+%{nil}
+%global service_install() install -D -p -m 0644 %1.service %{buildroot}%2 \
+%{nil}
 # can't seem to make a generic macro that works
-%global _init_glusterd   %{_unitdir}/glusterd.service
-%global _init_glusterfsd %{_unitdir}/glusterfsd.service
-%global _init_glustereventsd %{_unitdir}/glustereventsd.service
-%global _init_glusterfssharedstorage %{_unitdir}/glusterfssharedstorage.service
+%global glusterd_svcfile   %{_unitdir}/glusterd.service
+%global glusterfsd_svcfile %{_unitdir}/glusterfsd.service
+%global glusterta_svcfile %{_unitdir}/gluster-ta-volume.service
+%global glustereventsd_svcfile %{_unitdir}/glustereventsd.service
+%global glusterfssharedstorage_svcfile %{_unitdir}/glusterfssharedstorage.service
 %else
-%global _init_enable()  /sbin/chkconfig --add %1 ;
-%global _init_disable() /sbin/chkconfig --del %1 ;
-%global _init_restart() /sbin/service %1 condrestart &>/dev/null ;
-%global _init_start()   /sbin/service %1 start &>/dev/null ;
-%global _init_stop()    /sbin/service %1 stop &>/dev/null ;
-%global _init_install() install -D -p -m 0755 %1 %{buildroot}%{_sysconfdir}/init.d/%2 ;
+%global systemd_post()  /sbin/chkconfig --add %1 >/dev/null 2>&1 || : \
+%{nil}
+%global systemd_preun() /sbin/chkconfig --del %1 >/dev/null 2>&1 || : \
+%{nil}
+%global systemd_postun_with_restart() /sbin/service %1 condrestart >/dev/null 2>&1 || : \
+%{nil}
+%global service_start()   /sbin/service %1 start >/dev/null 2>&1 || : \
+%{nil}
+%global service_stop()    /sbin/service %1 stop >/dev/null 2>&1 || : \
+%{nil}
+%global service_install() install -D -p -m 0755 %1.init %{buildroot}%2 \
+%{nil}
 # can't seem to make a generic macro that works
-%global _init_glusterd   %{_sysconfdir}/init.d/glusterd
-%global _init_glusterfsd %{_sysconfdir}/init.d/glusterfsd
-%global _init_glustereventsd %{_sysconfdir}/init.d/glustereventsd
-%endif
-
-%if ( 0%{_for_fedora_koji_builds} )
-%if ( 0%{?_with_systemd:1} )
-%global glusterfsd_service glusterfsd.service
-%else
-%global glusterfsd_service glusterfsd.init
-%endif
+%global glusterd_svcfile   %{_sysconfdir}/init.d/glusterd
+%global glusterfsd_svcfile %{_sysconfdir}/init.d/glusterfsd
+%global glustereventsd_svcfile %{_sysconfdir}/init.d/glustereventsd
 %endif
 
 %{!?_pkgdocdir: %global _pkgdocdir %{_docdir}/%{name}-%{version}}
 
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-# _sharedstatedir is not provided by RHEL5
-%global _sharedstatedir /var/lib
-%endif
-
 # We do not want to generate useless provides and requires for xlator
 # .so files to be set for glusterfs packages.
 # Filter all generated:
@@ -181,13 +219,11 @@ Version:          @PACKAGE_VERSION@
 Release:          0.@PACKAGE_RELEASE@%{?dist}
 %endif
 License:          GPLv2 or LGPLv3+
-Group:            System Environment/Base
-URL:              http://gluster.readthedocs.io/en/latest/
+URL:              http://docs.gluster.org/
 %if ( 0%{_for_fedora_koji_builds} )
 Source0:          http://bits.gluster.org/pub/gluster/glusterfs/src/glusterfs-%{version}%{?prereltag}.tar.gz
 Source1:          glusterd.sysconfig
 Source2:          glusterfsd.sysconfig
-Source6:          rhel5-load-fuse-modules
 Source7:          glusterfsd.service
 Source8:          glusterfsd.init
 %else
@@ -197,44 +233,45 @@ Source0:          @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz
 BuildRoot:        %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
 
 Requires(pre):    shadow-utils
-%if ( 0%{?rhel} && 0%{?rhel} <= 5 )
-BuildRequires:    python-simplejson
-%endif
 %if ( 0%{?_with_systemd:1} )
 BuildRequires:    systemd
 %endif
 
-Requires:         %{name}-libs%{?_isa} = %{version}-%{release}
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Requires:         libgfrpc0%{?_isa} = %{version}-%{release}
+Requires:         libgfxdr0%{?_isa} = %{version}-%{release}
 %if ( 0%{?_with_systemd:1} )
 %{?systemd_requires}
 %endif
+%if 0%{?_with_asan:1} && !( 0%{?rhel} && 0%{?rhel} < 7 )
+BuildRequires:    libasan
+%endif
+%if 0%{?_with_tsan:1} && !( 0%{?rhel} && 0%{?rhel} < 7 )
+BuildRequires:    libtsan
+%endif
 BuildRequires:    bison flex
 BuildRequires:    gcc make libtool
 BuildRequires:    ncurses-devel readline-devel
 BuildRequires:    libxml2-devel openssl-devel
 BuildRequires:    libaio-devel libacl-devel
-BuildRequires:    python2-devel
-%if ( 0%{?fedora} && 0%{?fedora} < 26 ) || ( 0%{?rhel} )
+BuildRequires:    python%{_pythonver}-devel
+%if ( 0%{?rhel} && 0%{?rhel} < 8 )
 BuildRequires:    python-ctypes
 %endif
+%if ( 0%{?_with_ipv6default:1} ) || ( 0%{!?_without_libtirpc:1} )
+BuildRequires:    libtirpc-devel
+%endif
+%if ( 0%{?fedora} && 0%{?fedora} > 27 ) || ( 0%{?rhel} && 0%{?rhel} > 7 )
+BuildRequires:    rpcgen
+%endif
 BuildRequires:    userspace-rcu-devel >= 0.7
 %if ( 0%{?rhel} && 0%{?rhel} <= 6 )
 BuildRequires:    automake
 %endif
-%if ( 0%{?rhel} && 0%{?rhel} <= 5 )
-BuildRequires:    e2fsprogs-devel
-%else
 BuildRequires:    libuuid-devel
-%endif
 %if ( 0%{?_with_cmocka:1} )
 BuildRequires:    libcmocka-devel >= 1.0.1
 %endif
-%if ( 0%{!?_without_tiering:1} )
-BuildRequires:    sqlite-devel
-%endif
-%if ( 0%{!?_without_bd:1} )
-BuildRequires:    lvm2-devel
-%endif
 %if ( 0%{!?_without_georeplication:1} )
 BuildRequires:    libattr-devel
 %endif
@@ -243,122 +280,77 @@ BuildRequires:    libattr-devel
 BuildRequires:    firewalld
 %endif
 
-Obsoletes:        hekafs
 Obsoletes:        %{name}-common < %{version}-%{release}
 Obsoletes:        %{name}-core < %{version}-%{release}
-Obsoletes:        %{name}-ufo
 Obsoletes:        %{name}-ganesha
+Obsoletes:        %{name}-rdma < %{version}-%{release}
+%if ( 0%{!?_with_gnfs:1} )
+Obsoletes:        %{name}-gnfs < %{version}-%{release}
+%endif
 Provides:         %{name}-common = %{version}-%{release}
 Provides:         %{name}-core = %{version}-%{release}
 
 %description
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package includes the glusterfs binary, the glusterfsd daemon and the
 libglusterfs and glusterfs translator modules common to both GlusterFS server
 and client framework.
 
-%package api
-Summary:          GlusterFS api library
-Group:            System Environment/Daemons
-Requires:         %{name}%{?_isa} = %{version}-%{release}
-Requires:         %{name}-client-xlators%{?_isa} = %{version}-%{release}
-
-%description api
-GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
-
-This package provides the glusterfs libgfapi library.
-
-%package api-devel
-Summary:          Development Libraries
-Group:            Development/Libraries
-Requires:         %{name}%{?_isa} = %{version}-%{release}
-Requires:         %{name}-devel%{?_isa} = %{version}-%{release}
-Requires:         libacl-devel
-
-%description api-devel
-GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
-
-This package provides the api include files.
-
 %package cli
 Summary:          GlusterFS CLI
-Group:            Applications/File
-Requires:         %{name}-libs%{?_isa} = %{version}-%{release}
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Requires:         libglusterd0%{?_isa} = %{version}-%{release}
 
 %description cli
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides the GlusterFS CLI application and its man page
 
-%package devel
-Summary:          Development Libraries
-Group:            Development/Libraries
-Requires:         %{name}%{?_isa} = %{version}-%{release}
-# Needed for the Glupy examples to work
-Requires:         %{name}-extra-xlators%{?_isa} = %{version}-%{release}
+%package cloudsync-plugins
+Summary:          Cloudsync Plugins
+BuildRequires:    libcurl-devel
 
-%description devel
+%description cloudsync-plugins
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
-This package provides the development libraries and include files.
+This package provides cloudsync plugins for archival feature.
 
 %package extra-xlators
 Summary:          Extra Gluster filesystem Translators
-Group:            Applications/File
 # We need python-gluster rpm for gluster module's __init__.py in Python
 # site-packages area
-Requires:         python2-gluster = %{version}-%{release}
-Requires:         python2
-%if ( 0%{?fedora} && 0%{?fedora} < 26 ) || ( 0%{?rhel} )
-BuildRequires:    python-ctypes
-%endif
+Requires:         python%{_pythonver}-gluster = %{version}-%{release}
+Requires:         python%{_pythonver}
 
 %description extra-xlators
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides extra filesystem Translators, such as Glupy,
 for GlusterFS.
 
 %package fuse
 Summary:          Fuse client
-Group:            Applications/File
 BuildRequires:    fuse-devel
 Requires:         attr
 Requires:         psmisc
@@ -371,6 +363,49 @@ Provides:         %{name}-client = %{version}-%{release}
 
 %description fuse
 GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides support to FUSE based clients and inlcudes the
+glusterfs(d) binary.
+
+%if ( 0%{!?_without_server:1} )
+%package ganesha
+Summary:          NFS-Ganesha configuration
+Group:            Applications/File
+
+Requires:         %{name}-server%{?_isa} = %{version}-%{release}
+Requires:         nfs-ganesha-selinux >= 2.7.6
+Requires:         nfs-ganesha-gluster >= 2.7.6
+Requires:         pcs >= 0.10.0
+Requires:         resource-agents >= 4.2.0
+Requires:         dbus
+
+%if ( 0%{?rhel} && 0%{?rhel} == 6 )
+Requires:         cman, pacemaker, corosync
+%endif
+
+%if ( 0%{?fedora} ) || ( 0%{?rhel} && 0%{?rhel} > 5 )
+# we need portblock resource-agent in 3.9.5 and later.
+Requires:         net-tools
+%endif
+
+%if ( 0%{?fedora} && 0%{?fedora} > 25  || ( 0%{?rhel} && 0%{?rhel} > 6 ) )
+%if ( 0%{?rhel} && 0%{?rhel} < 8 )
+Requires: selinux-policy >= 3.13.1-160
+Requires(post):   policycoreutils-python
+Requires(postun): policycoreutils-python
+%else
+Requires(post):   policycoreutils-python-utils
+Requires(postun): policycoreutils-python-utils
+%endif
+%endif
+
+%description ganesha
+GlusterFS is a distributed file-system capable of scaling to several
 petabytes. It aggregates various storage bricks over Infiniband RDMA
 or TCP/IP interconnect into one large parallel network file
 system. GlusterFS is one of the most sophisticated file systems in
@@ -378,31 +413,37 @@ terms of features and extensibility.  It borrows a powerful concept
 called Translators from GNU Hurd kernel. Much of the code in GlusterFS
 is in user space and easily manageable.
 
-This package provides support to FUSE based clients and inlcudes the
-glusterfs(d) binary.
+This package provides the configuration and related files for using
+NFS-Ganesha as the NFS server using GlusterFS
+%endif
 
 %if ( 0%{!?_without_georeplication:1} )
 %package geo-replication
 Summary:          GlusterFS Geo-replication
-Group:            Applications/File
 Requires:         %{name}%{?_isa} = %{version}-%{release}
 Requires:         %{name}-server%{?_isa} = %{version}-%{release}
-Requires:         python2
-Requires:         python-prettytable
-%if ( 0%{?fedora} && 0%{?fedora} < 26 ) || ( 0%{?rhel} )
-BuildRequires:    python-ctypes
-%endif
-Requires:         python2-gluster = %{version}-%{release}
+Requires:         python%{_pythonver}
+Requires:         python%{_pythonver}-prettytable
+Requires:         python%{_pythonver}-gluster = %{version}-%{release}
+
 Requires:         rsync
+Requires:         util-linux
+# required for setting selinux bools
+%if ( 0%{?rhel} && 0%{?rhel} >= 8 )
+Requires(post):      policycoreutils-python-utils
+Requires(postun):    policycoreutils-python-utils
+Requires:            selinux-policy-targeted
+Requires(post):      selinux-policy-targeted
+BuildRequires:       selinux-policy-devel
+%endif
 
 %description geo-replication
 GlusterFS is a distributed file-system capable of scaling to several
-peta-bytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file system in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in userspace and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides support to geo-replication.
 %endif
@@ -410,104 +451,224 @@ This package provides support to geo-replication.
 %if ( 0%{?_with_gnfs:1} )
 %package gnfs
 Summary:          GlusterFS gNFS server
-Group:            System Environment/Daemons
 Requires:         %{name}%{?_isa} = %{version}-%{release}
 Requires:         %{name}-client-xlators%{?_isa} = %{version}-%{release}
 Requires:         nfs-utils
 
 %description gnfs
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides the glusterfs legacy gNFS server xlator
 %endif
 
-%package libs
-Summary:          GlusterFS common libraries
-Group:            Applications/File
+%package -n libglusterfs0
+Summary:          GlusterFS libglusterfs library
+Requires:         libgfrpc0%{?_isa} = %{version}-%{release}
+Requires:         libgfxdr0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-libs <= %{version}-%{release}
+Provides:         %{name}-libs = %{version}-%{release}
 
-%description libs
+%description -n libglusterfs0
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the base libglusterfs library
+
+%package -n libglusterfs-devel
+Summary:          GlusterFS libglusterfs library
+Requires:         libgfrpc-devel%{?_isa} = %{version}-%{release}
+Requires:         libgfxdr-devel%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-devel <= %{version}-%{release}
+Provides:         %{name}-devel = %{version}-%{release}
+
+%description -n libglusterfs-devel
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
-This package provides the base GlusterFS libraries
+This package provides libglusterfs.so and the gluster C header files.
 
-%package -n python-gluster
-Summary:          GlusterFS python library
-Group:            Development/Tools
-%if ( ! ( 0%{?rhel} && 0%{?rhel} < 6 || 0%{?sles_version} ) )
-# EL5 does not support noarch sub-packages
-BuildArch:        noarch
-%endif
+%package -n libgfapi0
+Summary:          GlusterFS api library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Requires:         %{name}-client-xlators%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-api <= %{version}-%{release}
+Provides:         %{name}-api = %{version}-%{release}
 
-%global _python_gluster_description \
-GlusterFS is a distributed file-system capable of scaling to several\
-petabytes. It aggregates various storage bricks over Infiniband RDMA\
-or TCP/IP interconnect into one large parallel network file\
-system. GlusterFS is one of the most sophisticated file systems in\
-terms of features and extensibility.  It borrows a powerful concept\
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS\
-is in user space and easily manageable.\
-\
-This package contains the python modules of GlusterFS and own gluster\
-namespace.
+%description -n libgfapi0
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the glusterfs libgfapi library.
+
+%package -n libgfapi-devel
+Summary:          Development Libraries
+Requires:         libglusterfs-devel%{?_isa} = %{version}-%{release}
+Requires:         libacl-devel
+Obsoletes:        %{name}-api-devel <= %{version}-%{release}
+Provides:         %{name}-api-devel = %{version}-%{release}
+
+%description -n libgfapi-devel
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides libgfapi.so and the api C header files.
+
+%package -n libgfchangelog0
+Summary:          GlusterFS libchangelog library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-libs <= %{version}-%{release}
+
+%description -n libgfchangelog0
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the libgfchangelog library
+
+%package -n libgfchangelog-devel
+Summary:          GlusterFS libchangelog library
+Requires:         libglusterfs-devel%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-devel <= %{version}-%{release}
+
+%description -n libgfchangelog-devel
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides libgfchangelog.so and changelog C header files.
+
+%package -n libgfrpc0
+Summary:          GlusterFS libgfrpc0 library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-libs <= %{version}-%{release}
+
+%description -n libgfrpc0
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the libgfrpc library
+
+%package -n libgfrpc-devel
+Summary:          GlusterFS libgfrpc library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-devel <= %{version}-%{release}
+
+%description -n libgfrpc-devel
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides libgfrpc.so and rpc C header files.
+
+%package -n libgfxdr0
+Summary:          GlusterFS libgfxdr0 library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-libs <= %{version}-%{release}
+
+%description -n libgfxdr0
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the libgfxdr library
+
+%package -n libgfxdr-devel
+Summary:          GlusterFS libgfxdr library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-devel <= %{version}-%{release}
 
-%description -n python-gluster %{_python_gluster_description}
+%description -n libgfxdr-devel
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides libgfxdr.so.
+
+%package -n libglusterd0
+Summary:          GlusterFS libglusterd library
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Obsoletes:        %{name}-libs <= %{version}-%{release}
+
+%description -n libglusterd0
+GlusterFS is a distributed file-system capable of scaling to several
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
+
+This package provides the libglusterd library
 
-%package -n python2-gluster
+%package -n python%{_pythonver}-gluster
 Summary:          GlusterFS python library
-Group:            Development/Tools
-%{?python_provide:%python_provide python2-gluster}
-Requires:         python2
+Requires:         python%{_pythonver}
+%if ( ! %{_usepython3} )
+%{?python_provide:%python_provide python-gluster}
 Provides:         python-gluster = %{version}-%{release}
 Obsoletes:        python-gluster < 3.10
-
-%description -n python2-gluster %{_python_gluster_description}
-
-%if ( 0%{!?_without_rdma:1} )
-%package rdma
-Summary:          GlusterFS rdma support for ib-verbs
-Group:            Applications/File
-%if ( 0%{?fedora} && 0%{?fedora} > 26 )
-BuildRequires:    rdma-core-devel
-%else
-BuildRequires:    libibverbs-devel
-BuildRequires:    librdmacm-devel >= 1.0.15
 %endif
-Requires:         %{name}%{?_isa} = %{version}-%{release}
 
-%description rdma
+%description -n python%{_pythonver}-gluster
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
-This package provides support to ib-verbs library.
-%endif
+This package contains the python modules of GlusterFS and own gluster
+namespace.
 
 %package regression-tests
 Summary:          Development Tools
-Group:            Development/Tools
 Requires:         %{name}%{?_isa} = %{version}-%{release}
 Requires:         %{name}-fuse%{?_isa} = %{version}-%{release}
 Requires:         %{name}-server%{?_isa} = %{version}-%{release}
 ## thin provisioning support
 Requires:         lvm2 >= 2.02.89
 Requires:         perl(App::Prove) perl(Test::Harness) gcc util-linux-ng
-Requires:         python2 attr dbench file git libacl-devel net-tools
+Requires:         python%{_pythonver}
+Requires:         attr dbench file git libacl-devel net-tools
 Requires:         nfs-utils xfsprogs yajl psmisc bc
 
 %description regression-tests
@@ -518,16 +679,8 @@ regression testing of Gluster.
 %package resource-agents
 Summary:          OCF Resource Agents for GlusterFS
 License:          GPLv3+
-%if ( ! ( 0%{?rhel} && 0%{?rhel} < 6 || 0%{?sles_version} ) )
-# EL5 does not support noarch sub-packages
 BuildArch:        noarch
-%endif
 # this Group handling comes from the Fedora resource-agents package
-%if ( 0%{?fedora} || 0%{?centos_version} || 0%{?rhel} )
-Group:            System Environment/Base
-%else
-Group:            Productivity/Clustering/HA
-%endif
 # for glusterd
 Requires:         %{name}-server = %{version}-%{release}
 # depending on the distribution, we need pacemaker or resource-agents
@@ -535,28 +688,31 @@ Requires:         %{_prefix}/lib/ocf/resource.d
 
 %description resource-agents
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides the resource agents which plug glusterd into
 Open Cluster Framework (OCF) compliant cluster resource managers,
 like Pacemaker.
 %endif
 
+%if ( 0%{!?_without_server:1} )
 %package server
 Summary:          Clustered file-system server
-Group:            System Environment/Daemons
 Requires:         %{name}%{?_isa} = %{version}-%{release}
 Requires:         %{name}-cli%{?_isa} = %{version}-%{release}
-Requires:         %{name}-libs%{?_isa} = %{version}-%{release}
+Requires:         libglusterfs0%{?_isa} = %{version}-%{release}
+Requires:         libgfchangelog0%{?_isa} = %{version}-%{release}
+%if ( 0%{?fedora} && 0%{?fedora} >= 30  || ( 0%{?rhel} && 0%{?rhel} >= 8 ) )
+Requires:         glusterfs-selinux >= 0.1.0-2
+%endif
 # some daemons (like quota) use a fuse-mount, glusterfsd is part of -fuse
 Requires:         %{name}-fuse%{?_isa} = %{version}-%{release}
 # self-heal daemon, rebalance, nfs-server etc. are actually clients
-Requires:         %{name}-api%{?_isa} = %{version}-%{release}
+Requires:         libgfapi0%{?_isa} = %{version}-%{release}
 Requires:         %{name}-client-xlators%{?_isa} = %{version}-%{release}
 # lvm2 for snapshot, and nfs-utils and rpcbind/portmap for gnfs server
 Requires:         lvm2
@@ -581,54 +737,64 @@ Requires:         rpcbind
 %else
 Requires:         portmap
 %endif
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-Obsoletes:        %{name}-geo-replication = %{version}-%{release}
-%endif
 %if ( 0%{?rhel} && 0%{?rhel} <= 6 )
 Requires:         python-argparse
 %endif
+%if ( 0%{?fedora} && 0%{?fedora} > 27 ) || ( 0%{?rhel} && 0%{?rhel} > 7 )
+Requires:         python%{_pythonver}-pyxattr
+%else
 Requires:         pyxattr
+%endif
 %if (0%{?_with_valgrind:1})
 Requires:         valgrind
 %endif
 
 %description server
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides the glusterfs server daemon.
+%endif
+
+%package thin-arbiter
+Summary:          GlusterFS thin-arbiter module
+Requires:         %{name}%{?_isa} = %{version}-%{release}
+Requires:         %{name}-server%{?_isa} = %{version}-%{release}
+
+%description thin-arbiter
+This package provides a tie-breaker functionality to GlusterFS
+replicate volume. It includes translators required to provide the
+functionality, and also few other scripts required for getting the setup done.
+
+This package provides the glusterfs thin-arbiter translator.
 
 %package client-xlators
 Summary:          GlusterFS client-side translators
-Group:            Applications/File
 
 %description client-xlators
 GlusterFS is a distributed file-system capable of scaling to several
-petabytes. It aggregates various storage bricks over Infiniband RDMA
-or TCP/IP interconnect into one large parallel network file
-system. GlusterFS is one of the most sophisticated file systems in
-terms of features and extensibility.  It borrows a powerful concept
-called Translators from GNU Hurd kernel. Much of the code in GlusterFS
-is in user space and easily manageable.
+petabytes. It aggregates various storage bricks over TCP/IP interconnect
+into one large parallel network filesystem. GlusterFS is one of the
+most sophisticated file systems in terms of features and extensibility.
+It borrows a powerful concept called Translators from GNU Hurd kernel.
+Much of the code in GlusterFS is in user space and easily manageable.
 
 This package provides the translators needed on any GlusterFS client.
 
 %if ( 0%{!?_without_events:1} )
 %package events
 Summary:          GlusterFS Events
-Group:            Applications/File
 Requires:         %{name}-server%{?_isa} = %{version}-%{release}
-Requires:         python2 python-prettytable
-Requires:         python2-gluster = %{version}-%{release}
-%if ( 0%{?rhel} )
-Requires:         python-requests python-jwt
+Requires:         python%{_pythonver} python%{_pythonver}-prettytable
+Requires:         python%{_pythonver}-gluster = %{version}-%{release}
+%if ( 0%{?rhel} && 0%{?rhel} < 8 )
+Requires:         python-requests
 %else
-Requires:         python2-requests python2-jwt
+Requires:         python%{_pythonver}-requests
 %endif
 %if ( 0%{?rhel} && 0%{?rhel} < 7 )
 Requires:         python-argparse
@@ -644,12 +810,14 @@ GlusterFS Events
 
 %prep
 %setup -q -n %{name}-%{version}%{?prereltag}
+%if ( ! %{_usepython3} )
+echo "fixing python shebangs..."
+for f in api events extras geo-replication libglusterfs tools xlators; do
+find $f -type f -exec sed -i 's|/usr/bin/python3|/usr/bin/python2|' {} \;
+done
+%endif
 
 %build
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-CFLAGS=-DUSE_INSECURE_OPENSSL
-export CFLAGS
-%endif
 
 # RHEL6 and earlier need to manually replace config.guess and config.sub
 %if ( 0%{?rhel} && 0%{?rhel} <= 6 )
@@ -657,21 +825,23 @@ export CFLAGS
 %endif
 
 %configure \
+        %{?_with_asan} \
         %{?_with_cmocka} \
         %{?_with_debug} \
         %{?_with_firewalld} \
         %{?_with_gnfs} \
         %{?_with_tmpfilesdir} \
+        %{?_with_tsan} \
         %{?_with_valgrind} \
-        %{?_without_bd} \
         %{?_without_epoll} \
         %{?_without_events} \
         %{?_without_fusermount} \
         %{?_without_georeplication} \
         %{?_without_ocf} \
-        %{?_without_rdma} \
+        %{?_without_server} \
         %{?_without_syslog} \
-        %{?_without_tiering}
+        %{?_with_ipv6default} \
+        %{?_without_libtirpc}
 
 # fix hardening and remove rpath in shlibs
 %if ( 0%{?fedora} && 0%{?fedora} > 17 ) || ( 0%{?rhel} && 0%{?rhel} > 6 )
@@ -688,9 +858,7 @@ make check
 %install
 rm -rf %{buildroot}
 make install DESTDIR=%{buildroot}
-# Install include directory
-install -p -m 0644 contrib/uuid/*.h \
-    %{buildroot}%{_includedir}/glusterfs/
+%if ( 0%{!?_without_server:1} )
 %if ( 0%{_for_fedora_koji_builds} )
 install -D -p -m 0644 %{SOURCE1} \
     %{buildroot}%{_sysconfdir}/sysconfig/glusterd
@@ -700,12 +868,6 @@ install -D -p -m 0644 %{SOURCE2} \
 install -D -p -m 0644 extras/glusterd-sysconfig \
     %{buildroot}%{_sysconfdir}/sysconfig/glusterd
 %endif
-
-%if ( 0%{_for_fedora_koji_builds} )
-%if ( 0%{?rhel} && 0%{?rhel} <= 5 )
-install -D -p -m 0755 %{SOURCE6} \
-    %{buildroot}%{_sysconfdir}/sysconfig/modules/glusterfs-fuse.modules
-%endif
 %endif
 
 mkdir -p %{buildroot}%{_localstatedir}/log/glusterd
@@ -734,33 +896,40 @@ https://forge.gluster.org/glusterfs-core/glusterfs/commits/v%{version}%{?prerelt
 EOM
 
 # Remove benchmarking and other unpackaged files
-%if ( 0%{?rhel} && 0%{?rhel} < 6 )
-rm -rf %{buildroot}/benchmarking
-rm -f %{buildroot}/glusterfs-mode.el
-rm -f %{buildroot}/glusterfs.vim
-%else
 # make install always puts these in %%{_defaultdocdir}/%%{name} so don't
 # use %%{_pkgdocdir}; that will be wrong on later Fedora distributions
 rm -rf %{buildroot}%{_defaultdocdir}/%{name}/benchmarking
 rm -f %{buildroot}%{_defaultdocdir}/%{name}/glusterfs-mode.el
 rm -f %{buildroot}%{_defaultdocdir}/%{name}/glusterfs.vim
-%endif
 
+%if ( 0%{!?_without_server:1} )
 # Create working directory
 mkdir -p %{buildroot}%{_sharedstatedir}/glusterd
 
 # Update configuration file to /var/lib working directory
 sed -i 's|option working-directory /etc/glusterd|option working-directory %{_sharedstatedir}/glusterd|g' \
     %{buildroot}%{_sysconfdir}/glusterfs/glusterd.vol
+%endif
 
 # Install glusterfsd .service or init.d file
+%if ( 0%{!?_without_server:1} )
 %if ( 0%{_for_fedora_koji_builds} )
-%_init_install %{glusterfsd_service} glusterfsd
+%service_install glusterfsd %{glusterfsd_svcfile}
+%endif
 %endif
 
 install -D -p -m 0644 extras/glusterfs-logrotate \
     %{buildroot}%{_sysconfdir}/logrotate.d/glusterfs
 
+# ganesha ghosts
+%if ( 0%{!?_without_server:1} )
+mkdir -p %{buildroot}%{_sysconfdir}/ganesha
+touch %{buildroot}%{_sysconfdir}/ganesha/ganesha-ha.conf
+mkdir -p %{buildroot}%{_localstatedir}/run/gluster/shared_storage/nfs-ganesha/
+touch %{buildroot}%{_localstatedir}/run/gluster/shared_storage/nfs-ganesha/ganesha.conf
+touch %{buildroot}%{_localstatedir}/run/gluster/shared_storage/nfs-ganesha/ganesha-ha.conf
+%endif
+
 %if ( 0%{!?_without_georeplication:1} )
 # geo-rep ghosts
 mkdir -p %{buildroot}%{_sharedstatedir}/glusterd/geo-replication
@@ -769,6 +938,7 @@ install -D -p -m 0644 extras/glusterfs-georep-logrotate \
     %{buildroot}%{_sysconfdir}/logrotate.d/glusterfs-georep
 %endif
 
+%if ( 0%{!?_without_server:1} )
 # the rest of the ghosts
 touch %{buildroot}%{_sharedstatedir}/glusterd/glusterd.info
 touch %{buildroot}%{_sharedstatedir}/glusterd/options
@@ -787,6 +957,7 @@ mkdir -p %{buildroot}%{_sharedstatedir}/glusterd/snaps
 mkdir -p %{buildroot}%{_sharedstatedir}/glusterd/ss_brick
 touch %{buildroot}%{_sharedstatedir}/glusterd/nfs/nfs-server.vol
 touch %{buildroot}%{_sharedstatedir}/glusterd/nfs/run/nfs.pid
+%endif
 
 find ./tests ./run-tests.sh -type f | cpio -pd %{buildroot}%{_prefix}/share/glusterfs
 
@@ -804,41 +975,59 @@ rm -rf %{buildroot}
 /sbin/ldconfig
 %if ( 0%{!?_without_syslog:1} )
 %if ( 0%{?fedora} ) || ( 0%{?rhel} && 0%{?rhel} >= 6 )
-%_init_restart rsyslog
+%systemd_postun_with_restart rsyslog
 %endif
 %endif
 exit 0
 
-%post api
-/sbin/ldconfig
-
 %if ( 0%{!?_without_events:1} )
 %post events
-%_init_restart glustereventsd
+%systemd_post glustereventsd
 %endif
 
-%if ( 0%{?rhel} == 5 )
-%post fuse
-modprobe fuse
+%if ( 0%{!?_without_server:1} )
+%if ( 0%{?fedora} && 0%{?fedora} > 25 || ( 0%{?rhel} && 0%{?rhel} > 6 ) )
+%post ganesha
+semanage boolean -m ganesha_use_fusefs --on
 exit 0
 %endif
+%endif
 
 %if ( 0%{!?_without_georeplication:1} )
 %post geo-replication
+%if ( 0%{?rhel} && 0%{?rhel} >= 8 )
+%selinux_set_booleans %{selinuxbooleans}
+%endif
 if [ $1 -ge 1 ]; then
-    %_init_restart glusterd
+    %systemd_postun_with_restart glusterd
 fi
 exit 0
 %endif
 
-%post libs
+%post -n libglusterfs0
 /sbin/ldconfig
 
+%post -n libgfapi0
+/sbin/ldconfig
+
+%post -n libgfchangelog0
+/sbin/ldconfig
+
+%post -n libgfrpc0
+/sbin/ldconfig
+
+%post -n libgfxdr0
+/sbin/ldconfig
+
+%post -n libglusterd0
+/sbin/ldconfig
+
+%if ( 0%{!?_without_server:1} )
 %post server
 # Legacy server
-%_init_enable glusterd
+%systemd_post glusterd
 %if ( 0%{_for_fedora_koji_builds} )
-%_init_enable glusterfsd
+%systemd_post glusterfsd
 %endif
 # ".cmd_log_history" is renamed to "cmd_history.log" in GlusterFS-3.7 .
 # While upgrading glusterfs-server package form GlusterFS version <= 3.6 to
@@ -896,7 +1085,7 @@ if [ $? -eq 0 ]; then
 
     # glusterd _was_ running, we killed it, it exited after *.upgrade=on,
     # so start it again
-    %_init_start glusterd
+    %service_start glusterd
 else
     glusterd --xlator-option *.upgrade=on -N
 
@@ -905,6 +1094,7 @@ else
     rm -f %{_rundir}/glusterd.socket
 fi
 exit 0
+%endif
 
 ##-----------------------------------------------------------------------------
 ## All %%pre should be placed here and keep them sorted
@@ -914,79 +1104,113 @@ getent group gluster > /dev/null || groupadd -r gluster
 getent passwd gluster > /dev/null || useradd -r -g gluster -d %{_rundir}/gluster -s /sbin/nologin -c "GlusterFS daemons" gluster
 exit 0
 
-
 ##-----------------------------------------------------------------------------
 ## All %%preun should be placed here and keep them sorted
 ##
 %if ( 0%{!?_without_events:1} )
 %preun events
 if [ $1 -eq 0 ]; then
-    if [ -f %_init_glustereventsd ]; then
-        %_init_stop glustereventsd
-        %_init_disable glustereventsd
+    if [ -f %glustereventsd_svcfile ]; then
+        %service_stop glustereventsd
+        %systemd_preun glustereventsd
     fi
 fi
 exit 0
 %endif
 
+%if ( 0%{!?_without_server:1} )
 %preun server
 if [ $1 -eq 0 ]; then
-    if [ -f %_init_glusterfsd ]; then
-        %_init_stop glusterfsd
+    if [ -f %glusterfsd_svcfile ]; then
+        %service_stop glusterfsd
     fi
-    %_init_stop glusterd
-    if [ -f %_init_glusterfsd ]; then
-        %_init_disable glusterfsd
+    %service_stop glusterd
+    if [ -f %glusterfsd_svcfile ]; then
+        %systemd_preun glusterfsd
     fi
-    %_init_disable glusterd
+    %systemd_preun glusterd
 fi
 if [ $1 -ge 1 ]; then
-    if [ -f %_init_glusterfsd ]; then
-        %_init_restart glusterfsd
+    if [ -f %glusterfsd_svcfile ]; then
+        %systemd_postun_with_restart glusterfsd
     fi
-    %_init_restart glusterd
+    %systemd_postun_with_restart glusterd
 fi
 exit 0
+%endif
+
+%preun thin-arbiter
+if [ $1 -eq 0 ]; then
+    if [ -f %glusterta_svcfile ]; then
+        %service_stop gluster-ta-volume
+        %systemd_preun gluster-ta-volume
+    fi
+fi
 
 ##-----------------------------------------------------------------------------
 ## All %%postun should be placed here and keep them sorted
 ##
 %postun
-/sbin/ldconfig
 %if ( 0%{!?_without_syslog:1} )
 %if ( 0%{?fedora} ) || ( 0%{?rhel} && 0%{?rhel} >= 6 )
-%_init_restart rsyslog
+%systemd_postun_with_restart rsyslog
 %endif
 %endif
 
-%postun api
-/sbin/ldconfig
-
-%postun libs
-/sbin/ldconfig
-
+%if ( 0%{!?_without_server:1} )
 %postun server
-/sbin/ldconfig
 %if (0%{?_with_firewalld:1})
     %firewalld_reload
 %endif
 exit 0
+%endif
+
+%if ( 0%{!?_without_server:1} )
+%if ( 0%{?fedora} && 0%{?fedora} > 25  || ( 0%{?rhel} && 0%{?rhel} > 6 ) )
+%postun ganesha
+semanage boolean -m ganesha_use_fusefs --off
+exit 0
+%endif
+%endif
+
+##-----------------------------------------------------------------------------
+## All %%trigger should be placed here and keep them sorted
+##
+%if ( 0%{!?_without_server:1} )
+%if ( 0%{?fedora} && 0%{?fedora} > 25  || ( 0%{?rhel} && 0%{?rhel} > 6 ) )
+%trigger ganesha -- selinux-policy-targeted
+semanage boolean -m ganesha_use_fusefs --on
+exit 0
+%endif
+%endif
+
+##-----------------------------------------------------------------------------
+## All %%triggerun should be placed here and keep them sorted
+##
+%if ( 0%{!?_without_server:1} )
+%if ( 0%{?fedora} && 0%{?fedora} > 25  || ( 0%{?rhel} && 0%{?rhel} > 6 ) )
+%triggerun ganesha -- selinux-policy-targeted
+semanage boolean -m ganesha_use_fusefs --off
+exit 0
+%endif
+%endif
 
 ##-----------------------------------------------------------------------------
 ## All %%files should be placed here and keep them grouped
 ##
 %files
-%doc ChangeLog COPYING-GPLV2 COPYING-LGPLV3 INSTALL README.md THANKS
+%doc ChangeLog COPYING-GPLV2 COPYING-LGPLV3 INSTALL README.md THANKS COMMITMENT
 %{_mandir}/man8/*gluster*.8*
+%if ( 0%{!?_without_server:1} )
 %exclude %{_mandir}/man8/gluster.8*
-%dir %{_localstatedir}/log/glusterfs
-%if ( 0%{!?_without_rdma:1} )
-%exclude %{_libdir}/glusterfs/%{version}%{?prereltag}/rpc-transport/rdma*
 %endif
+%dir %{_localstatedir}/log/glusterfs
+%if 0%{?!_without_server:1}
 %dir %{_datadir}/glusterfs
 %dir %{_datadir}/glusterfs/scripts
      %{_datadir}/glusterfs/scripts/post-upgrade-script-for-quota.sh
      %{_datadir}/glusterfs/scripts/pre-upgrade-script-for-quota.sh
+%endif
 # xlators that are needed on the client- and on the server-side
 %dir %{_libdir}/glusterfs
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}
@@ -998,24 +1222,23 @@ exit 0
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug/error-gen.so
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug/delay-gen.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug/io-stats.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug/sink.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/debug/trace.so
-%if ( ! ( 0%{?rhel} && 0%{?rhel} < 6 ) )
-# RHEL-5 based distributions have a too old openssl
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption/crypt.so
-%endif
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/access-control.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/barrier.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/cdc.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/changelog.so
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/utime.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/gfid-access.so
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/namespace.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/read-only.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/shard.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/snapview-client.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/worm.so
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/cloudsync.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/meta.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/io-cache.so
@@ -1031,47 +1254,53 @@ exit 0
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/system
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/system/posix-acl.so
 %dir %attr(0775,gluster,gluster) %{_rundir}/gluster
-%if 0%{?_tmpfilesdir:1}
+%if 0%{?_tmpfilesdir:1} && 0%{!?_without_server:1}
 %{_tmpfilesdir}/gluster.conf
 %endif
 
-%files api
-%exclude %{_libdir}/*.so
-# libgfapi files
-%{_libdir}/libgfapi.*
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/mount
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/mount/api.so
-
-%files api-devel
-%{_libdir}/pkgconfig/glusterfs-api.pc
-%{_libdir}/libgfapi.so
-%dir %{_includedir}/glusterfs
-%dir %{_includedir}/glusterfs/api
-     %{_includedir}/glusterfs/api/*
+%if ( 0%{?_without_server:1} )
+#exclude ganesha related files
+%exclude %{_sysconfdir}/ganesha/ganesha-ha.conf.sample
+%exclude %{_libexecdir}/ganesha/*
+%exclude %{_prefix}/lib/ocf/resource.d/heartbeat/*
+%endif
 
 %files cli
 %{_sbindir}/gluster
 %{_mandir}/man8/gluster.8*
 %{_sysconfdir}/bash_completion.d/gluster
 
-%files devel
+%files cloudsync-plugins
+%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/cloudsync-plugins
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/cloudsync-plugins/cloudsyncs3.so
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/cloudsync-plugins/cloudsynccvlt.so
+
+%files -n libglusterfs-devel
 %dir %{_includedir}/glusterfs
-     %{_includedir}/glusterfs/*
-%exclude %{_includedir}/glusterfs/api
-%exclude %{_libdir}/libgfapi.so
-%{_libdir}/*.so
-# Glupy Translator examples
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/debug-trace.*
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/helloworld.*
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/negative.*
+     %{_includedir}/glusterfs/*.h
+     %{_includedir}/glusterfs/server/*.h
+%{_libdir}/libglusterfs.so
+
+%files -n libgfapi-devel
+%dir %{_includedir}/glusterfs/api
+     %{_includedir}/glusterfs/api/*.h
+%{_libdir}/libgfapi.so
+%{_libdir}/pkgconfig/glusterfs-api.pc
+
+
+%files -n libgfchangelog-devel
+%dir %{_includedir}/glusterfs/gfchangelog
+     %{_includedir}/glusterfs/gfchangelog/*.h
+%{_libdir}/libgfchangelog.so
 %{_libdir}/pkgconfig/libgfchangelog.pc
-%if ( 0%{!?_without_tiering:1} )
-%{_libdir}/pkgconfig/libgfdb.pc
-%endif
+
+%files -n libgfrpc-devel
+%dir %{_includedir}/glusterfs/rpc
+     %{_includedir}/glusterfs/rpc/*.h
+%{_libdir}/libgfrpc.so
+
+%files -n libgfxdr-devel
+%{_libdir}/libgfxdr.so
 
 %files client-xlators
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
@@ -1082,20 +1311,10 @@ exit 0
 
 %files extra-xlators
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption/rot-13.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/quiesce.so
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/features
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/features/template.so
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/performance
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/performance/symlink-cache.so
-# Glupy Python files
-%dir %{python2_sitelib}/gluster
-%dir %{python2_sitelib}/gluster/glupy
-     %{python2_sitelib}/gluster/glupy/*
+%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/playground
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/playground/template.so
 
 %files fuse
 # glusterfs is a symlink to glusterfsd, -server depends on -fuse.
@@ -1109,13 +1328,8 @@ exit 0
 %if ( 0%{!?_without_fusermount:1} )
 %{_bindir}/fusermount-glusterfs
 %endif
-%if ( 0%{_for_fedora_koji_builds} )
-%if ( 0%{?rhel} && 0%{?rhel} <= 5 )
-%{_sysconfdir}/sysconfig/modules/glusterfs-fuse.modules
-%endif
-%endif
 
-%if ( 0%{?_with_gnfs:1} )
+%if ( 0%{?_with_gnfs:1} && 0%{!?_without_server:1} )
 %files gnfs
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/nfs
@@ -1126,6 +1340,18 @@ exit 0
 %ghost      %attr(0600,-,-) %{_sharedstatedir}/glusterd/nfs/run/nfs.pid
 %endif
 
+%files thin-arbiter
+%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator
+%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/thin-arbiter.so
+%dir %{_datadir}/glusterfs/scripts
+     %{_datadir}/glusterfs/scripts/setup-thin-arbiter.sh
+%config %{_sysconfdir}/glusterfs/thin-arbiter.vol
+
+%if ( 0%{?_with_systemd:1} )
+%{_unitdir}/gluster-ta-volume.service
+%endif
+
 %if ( 0%{!?_without_georeplication:1} )
 %files geo-replication
 %config(noreplace) %{_sysconfdir}/logrotate.d/glusterfs-georep
@@ -1137,6 +1363,13 @@ exit 0
 %dir %{_libexecdir}/glusterfs/python/syncdaemon
      %{_libexecdir}/glusterfs/gsyncd
      %{_libexecdir}/glusterfs/python/syncdaemon/*
+%dir %{_libexecdir}/glusterfs/scripts
+     %{_libexecdir}/glusterfs/scripts/get-gfid.sh
+     %{_libexecdir}/glusterfs/scripts/slave-upgrade.sh
+     %{_libexecdir}/glusterfs/scripts/gsync-upgrade.sh
+     %{_libexecdir}/glusterfs/scripts/generate-gfid-file.sh
+     %{_libexecdir}/glusterfs/scripts/gsync-sync-gfid
+     %{_libexecdir}/glusterfs/scripts/schedule_georep.py*
      %{_libexecdir}/glusterfs/gverify.sh
      %{_libexecdir}/glusterfs/set_geo_rep_pem_keys.sh
      %{_libexecdir}/glusterfs/peer_gsec_create
@@ -1153,35 +1386,41 @@ exit 0
             %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/gsync-create/post/S56glusterd-geo-rep-create-post.sh
 %ghost %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/gsync-create/pre
 
-%dir %{_datadir}/glusterfs
-%dir %{_datadir}/glusterfs/scripts
-     %{_datadir}/glusterfs/scripts/get-gfid.sh
-     %{_datadir}/glusterfs/scripts/slave-upgrade.sh
-     %{_datadir}/glusterfs/scripts/gsync-upgrade.sh
-     %{_datadir}/glusterfs/scripts/generate-gfid-file.sh
-     %{_datadir}/glusterfs/scripts/gsync-sync-gfid
-     %{_datadir}/glusterfs/scripts/schedule_georep.py*
 %endif
 
-%files libs
-%{_libdir}/*.so.*
-%exclude %{_libdir}/libgfapi.*
-%if ( 0%{!?_without_tiering:1} )
-# libgfdb is only needed server-side
-%exclude %{_libdir}/libgfdb.*
-%endif
+%files -n libglusterfs0
+%{_libdir}/libglusterfs.so.*
+
+%files -n libgfapi0
+%{_libdir}/libgfapi.so.*
+%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/mount
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/mount/api.so
+
+%files -n libgfchangelog0
+%{_libdir}/libgfchangelog.so.*
+
+%files -n libgfrpc0
+%{_libdir}/libgfrpc.so.*
 
-%files -n python2-gluster
+%files -n libgfxdr0
+%{_libdir}/libgfxdr.so.*
+
+%files -n libglusterd0
+%{_libdir}/libglusterd.so.*
+%exclude %{_libdir}/libglusterd.so
+
+%files -n python%{_pythonver}-gluster
 # introducing glusterfs module in site packages.
 # so that all other gluster submodules can reside in the same namespace.
+%if ( %{_usepython3} )
+%dir %{python3_sitelib}/gluster
+     %{python3_sitelib}/gluster/__init__.*
+     %{python3_sitelib}/gluster/__pycache__
+     %{python3_sitelib}/gluster/cliutils
+%else
 %dir %{python2_sitelib}/gluster
      %{python2_sitelib}/gluster/__init__.*
      %{python2_sitelib}/gluster/cliutils
-
-%if ( 0%{!?_without_rdma:1} )
-%files rdma
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/rpc-transport
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/rpc-transport/rdma*
 %endif
 
 %files regression-tests
@@ -1190,16 +1429,31 @@ exit 0
      %{_datadir}/glusterfs/tests
 %exclude %{_datadir}/glusterfs/tests/vagrant
 
+%if ( 0%{!?_without_server:1} )
+%files ganesha
+%dir %{_libexecdir}/ganesha
+%{_sysconfdir}/ganesha/ganesha-ha.conf.sample
+%{_libexecdir}/ganesha/*
+%{_prefix}/lib/ocf/resource.d/heartbeat/*
+%{_sharedstatedir}/glusterd/hooks/1/start/post/S31ganesha-start.sh
+%ghost      %attr(0644,-,-) %config(noreplace) %{_sysconfdir}/ganesha/ganesha-ha.conf
+%ghost %dir %attr(0755,-,-) %{_localstatedir}/run/gluster/shared_storage/nfs-ganesha
+%ghost      %attr(0644,-,-) %config(noreplace) %{_localstatedir}/run/gluster/shared_storage/nfs-ganesha/ganesha.conf
+%ghost      %attr(0644,-,-) %config(noreplace) %{_localstatedir}/run/gluster/shared_storage/nfs-ganesha/ganesha-ha.conf
+%endif
+
 %if ( 0%{!?_without_ocf:1} )
 %files resource-agents
 # /usr/lib is the standard for OCF, also on x86_64
 %{_prefix}/lib/ocf/resource.d/glusterfs
 %endif
 
+%if ( 0%{!?_without_server:1} )
 %files server
 %doc extras/clear_xattrs.sh
 # sysconf
 %config(noreplace) %{_sysconfdir}/glusterfs
+%exclude %{_sysconfdir}/glusterfs/thin-arbiter.vol
 %exclude %{_sysconfdir}/glusterfs/eventsconfig.json
 %exclude %{_sharedstatedir}/glusterd/nfs/nfs-server.vol
 %exclude %{_sharedstatedir}/glusterd/nfs/run/nfs.pid
@@ -1212,17 +1466,17 @@ exit 0
 %endif
 
 # init files
-%_init_glusterd
+%glusterd_svcfile
 %if ( 0%{_for_fedora_koji_builds} )
-%_init_glusterfsd
+%glusterfsd_svcfile
 %endif
 %if ( 0%{?_with_systemd:1} )
-%_init_glusterfssharedstorage
+%glusterfssharedstorage_svcfile
 %endif
 
 # binaries
 %{_sbindir}/glusterd
-%{_sbindir}/glfsheal
+%{_libexecdir}/glusterfs/glfsheal
 %{_sbindir}/gf_attach
 %{_sbindir}/gluster-setgfid2path
 # {_sbindir}/glusterfsd is the actual binary, but glusterfs (client) is a
@@ -1238,10 +1492,7 @@ exit 0
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/arbiter.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/bit-rot.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/bitrot-stub.so
-%if ( 0%{!?_without_tiering:1} )
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/changetimerecorder.so
-     %{_libdir}/libgfdb.so.*
-%endif
+     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/sdfs.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/index.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/locks.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/posix*
@@ -1257,10 +1508,7 @@ exit 0
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/protocol
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/protocol/server.so
 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/storage
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/storage/bd.so
      %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/storage/posix.so
-%dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance
-     %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/decompounder.so
 
 # snap_scheduler
 %{_sbindir}/snap_scheduler.py
@@ -1276,6 +1524,9 @@ exit 0
             %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/metadata-cache
             %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/gluster-block
             %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/nl-cache
+            %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/db-workload
+            %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/distributed-virt
+            %attr(0644,-,-) %{_sharedstatedir}/glusterd/groups/samba
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/glusterfind
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/glusterfind/.keys
 %ghost %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/glustershd
@@ -1284,8 +1535,10 @@ exit 0
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/post
             %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/post/disabled-quota-root-xattr-heal.sh
-            %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/pre/S28Quota-enable-root-xattr-heal.sh
+            %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/post/S10selinux-label-brick.sh
+            %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/post/S13create-subdir-mounts.sh
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/pre
+            %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/add-brick/pre/S28Quota-enable-root-xattr-heal.sh
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/create
        %dir %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/create/post
             %attr(0755,-,-) %{_sharedstatedir}/glusterd/hooks/1/create/post/S10selinux-label-brick.sh
@@ -1333,6 +1586,8 @@ exit 0
      %{_datadir}/glusterfs/scripts/stop-all-gluster-processes.sh
 %if ( 0%{?_with_systemd:1} )
      %{_libexecdir}/glusterfs/mount-shared-storage.sh
+     %{_datadir}/glusterfs/scripts/control-cpu-load.sh
+     %{_datadir}/glusterfs/scripts/control-mem.sh
 %endif
 
 # Incrementalapi
@@ -1343,6 +1598,8 @@ exit 0
 %if ( 0%{?_with_firewalld:1} )
 %{_prefix}/lib/firewalld/services/glusterfs.xml
 %endif
+# end of server files
+%endif
 
 # Events
 %if ( 0%{!?_without_events:1} )
@@ -1351,7 +1608,7 @@ exit 0
 %dir %{_sharedstatedir}/glusterd
 %dir %{_sharedstatedir}/glusterd/events
 %dir %{_libexecdir}/glusterfs
-     %{_libexecdir}/glusterfs/events
+     %{_libexecdir}/glusterfs/gfevents
      %{_libexecdir}/glusterfs/peer_eventsapi.py*
 %{_sbindir}/glustereventsd
 %{_sbindir}/gluster-eventsapi
@@ -1364,8 +1621,77 @@ exit 0
 %endif
 
 %changelog
+* Thu May 14 2020 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- refactor, common practice, Issue #1126
+
+* Mon May 11 2020 Sunny Kumar <sunkumar@redhat.com>
+- added requires policycoreutils-python-utils on rhel8 for geo-replication
+
+* Wed Oct 9 2019 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- remove leftover bd xlator cruft
+
+* Fri Aug 23 2019 Shwetha K Acharya <sacharya@redhat.com>
+- removed {name}-ufs from Obsoletes
+- added  "< version" for obsoletes {name}-gnfs and {name}-rdma
+
+* Mon Jul 15 2019 Jiffin Tony Thottan <jthottan@redhat.com>
+- Adding ganesha ha bits back in gluster repository
+
+* Fri Jul 12 2019 Amar Tumballi <amarts@redhat.com>
+- Remove rdma package, and mark older rdma package as 'Obsoletes'
+
+* Fri Jun 14 2019 Niels de Vos <ndevos@redhat.com>
+- always build glusterfs-cli to allow monitoring/managing from clients
+
+* Wed Mar 6 2019 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- remove unneeded ldconfig in scriptlets
+-  reported by Igor Gnatenko in Fedora
+-   https://src.fedoraproject.org/rpms/glusterfs/pull-request/5
+
+* Mon Mar 4 2019 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- s390x has RDMA, since around Fedora 27 and in RHEL7 since June 2016.
+
+* Tue Feb 26 2019 Ashish Pandey <aspandey@redhat.com>
+- Add thin-arbiter package
+
+* Sun Feb 24 2019 Aravinda VK <avishwan@redhat.com>
+- Renamed events package to gfevents
+
+* Thu Feb 21 2019 Jiffin Tony Thottan <jthottan@redhat.com>
+- Obsoleting gluster-gnfs package
+
+* Wed Nov 28 2018 Krutika Dhananjay <kdhananj@redhat.com>
+- Install /var/lib/glusterd/groups/distributed-virt by default
+
+* Tue Nov 13 2018 Niels de Vos <ndevos@redhat.com>
+- Add an option to build with ThreadSanitizer (TSAN)
+
+* Fri Sep 7 2018 Niels de Vos <ndevos@redhat.com>
+- Add an option to build with address sanitizer (ASAN)
+
+* Sun Jul 29 2018 Niels de Vos <ndevos@redhat.com>
+- Disable building glusterfs-resource-agents on el6 (#1609551)
+
+* Thu Feb 22 2018 Kotresh HR <khiremat@redhat.com>
+- Added util-linux as dependency to georeplication rpm (#1544382)
+
+* Thu Feb 1 2018 Niels de Vos <ndevos@redhat.com>
+- Add '--without server' option to facilitate el6 builds (#1074947)
+
+* Wed Jan 24 2018 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- python-ctypes no long exists, now in python stdlib (#1538258)
+
+* Thu Jan 18 2018 Kaleb S. KEITHLEY <kkeithle@redhat.com>
+- Fedora 28 glibc has removed rpc headers and rpcgen, use libtirpc
+
+* Mon Dec 25 2017 Niels de Vos <ndevos@redhat.com>
+- Fedora 28 has renamed pyxattr
+
+* Wed Sep 27 2017 Mohit Agrawal <moagrawa@redhat.com>
+- Added control-cpu-load.sh and control-mem.sh scripts to glusterfs-server section(#1496335)
+
 * Tue Aug 22 2017 Kaleb S. KEITHLEY <kkeithle@redhat.com>
-- libibverbs-devel, librdmacm-devel -> rdma-core-devel #1483996
+- libibverbs-devel, librdmacm-devel -> rdma-core-devel #1483995
 
 * Thu Jul 20 2017 Aravinda VK <avishwan@redhat.com>
 - Added new tool/binary to set the gfid2path xattr on files
@@ -1404,9 +1730,6 @@ exit 0
 * Thu Feb 16 2017 Niels de Vos <ndevos@redhat.com>
 - Obsolete and Provide python-gluster for upgrading from glusterfs < 3.10
 
-* Tue Feb 7 2017 Kaleb S. KEITHLEY <kkeithle@redhat.com>
-- remove ganesha (#1418417)
-
 * Wed Feb 1 2017 Poornima G <pgurusid@redhat.com>
 - Install /var/lib/glusterd/groups/metadata-cache by default
 
diff --git a/glusterfsd/src/Makefile.am b/glusterfsd/src/Makefile.am
index 0196204bdd6..a0a778158d8 100644
--- a/glusterfsd/src/Makefile.am
+++ b/glusterfsd/src/Makefile.am
@@ -1,9 +1,12 @@
-sbin_PROGRAMS = glusterfsd gf_attach
+sbin_PROGRAMS = glusterfsd
+if WITH_SERVER
+sbin_PROGRAMS += glusterfsd gf_attach
+endif
 
 glusterfsd_SOURCES = glusterfsd.c glusterfsd-mgmt.c
 glusterfsd_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 	$(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
-	$(top_builddir)/rpc/xdr/src/libgfxdr.la ${GF_LDADD}
+	$(top_builddir)/rpc/xdr/src/libgfxdr.la $(GF_LDADD) $(LIB_DL)
 glusterfsd_LDFLAGS = $(GF_LDFLAGS)
 
 gf_attach_SOURCES = gf_attach.c
@@ -11,6 +14,7 @@ gf_attach_LDADD   = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 		    $(top_builddir)/api/src/libgfapi.la \
 		    $(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
 		    $(top_builddir)/rpc/xdr/src/libgfxdr.la
+gf_attach_LDFLAGS = $(GF_LDFLAGS)
 
 noinst_HEADERS = glusterfsd.h glusterfsd-mem-types.h glusterfsd-messages.h
 
@@ -18,10 +22,12 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \
 	-I$(top_srcdir)/libglusterfs/src -DDATADIR=\"$(localstatedir)\" \
 	-DCONFDIR=\"$(sysconfdir)/glusterfs\" $(GF_GLUSTERFS_CFLAGS) \
 	-DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" \
+	-DLIBEXECDIR=\"$(GLUSTERFS_LIBEXECDIR)\"\
 	-I$(top_srcdir)/rpc/rpc-lib/src \
 	-I$(top_srcdir)/rpc/xdr/src \
 	-I$(top_builddir)/rpc/xdr/src \
 	-I$(top_srcdir)/xlators/nfs/server/src \
+	-I$(top_srcdir)/xlators/protocol/server/src \
 	-I$(top_srcdir)/api/src
 
 AM_CFLAGS = -Wall $(GF_CFLAGS)
@@ -41,6 +47,8 @@ install-data-local:
 	$(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/log/glusterfs
 	$(INSTALL) -d -m 755 $(DESTDIR)$(sbindir)
 	rm -f $(DESTDIR)$(sbindir)/glusterfs
-	rm -f $(DESTDIR)$(sbindir)/glusterd
 	ln -s glusterfsd $(DESTDIR)$(sbindir)/glusterfs
+if WITH_SERVER
+	rm -f $(DESTDIR)$(sbindir)/glusterd
 	ln -s glusterfsd $(DESTDIR)$(sbindir)/glusterd
+endif
diff --git a/glusterfsd/src/gf_attach.c b/glusterfsd/src/gf_attach.c
index 3f248292ddf..c553b0b1f61 100644
--- a/glusterfsd/src/gf_attach.c
+++ b/glusterfsd/src/gf_attach.c
@@ -12,235 +12,230 @@
 #include <stdlib.h>
 #include <unistd.h>
 
-//#include "config.h"
-#include "glusterfs.h"
-#include "globals.h"
+#include <glusterfs/glusterfs.h>
 #include "glfs-internal.h"
 #include "rpc-clnt.h"
 #include "protocol-common.h"
 #include "xdr-generic.h"
 #include "glusterd1-xdr.h"
 
+/* In seconds */
+#define CONNECT_TIMEOUT 60
+#define REPLY_TIMEOUT 120
+
 int done = 0;
 int rpc_status;
 
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+
 struct rpc_clnt_procedure gf_attach_actors[GLUSTERD_BRICK_MAXVALUE] = {
-        [GLUSTERD_BRICK_NULL] = {"NULL", NULL },
-        [GLUSTERD_BRICK_OP]   = {"BRICK_OP", NULL },
+    [GLUSTERD_BRICK_NULL] = {"NULL", NULL},
+    [GLUSTERD_BRICK_OP] = {"BRICK_OP", NULL},
 };
 
 struct rpc_clnt_program gf_attach_prog = {
-        .progname  = "brick operations",
-        .prognum   = GD_BRICK_PROGRAM,
-        .progver   = GD_BRICK_VERSION,
-        .proctable = gf_attach_actors,
-        .numproc   = GLUSTERD_BRICK_MAXVALUE,
+    .progname = "brick operations",
+    .prognum = GD_BRICK_PROGRAM,
+    .progver = GD_BRICK_VERSION,
+    .proctable = gf_attach_actors,
+    .numproc = GLUSTERD_BRICK_MAXVALUE,
 };
 
-/*
- * In a sane world, the generic RPC layer would be capable of tracking
- * connection status by itself, with no help from us.  It might invoke our
- * callback if we had registered one, but only to provide information.  Sadly,
- * we don't live in that world.  Instead, the callback *must* exist and *must*
- * call rpc_clnt_{set,unset}_connected, because that's the only way those
- * fields get set (with RPC both above and below us on the stack).  If we don't
- * do that, then rpc_clnt_submit doesn't think we're connected even when we
- * are.  It calls the socket code to reconnect, but the socket code tracks this
- * stuff in a sane way so it knows we're connected and returns EINPROGRESS.
- * Then we're stuck, connected but unable to use the connection.  To make it
- * work, we define and register this trivial callback.
- */
-int
-my_notify (struct rpc_clnt *rpc, void *mydata,
-           rpc_clnt_event_t event, void *data)
-{
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-                printf ("connected\n");
-                rpc_clnt_set_connected (&rpc->conn);
-                break;
-        case RPC_CLNT_DISCONNECT:
-                printf ("disconnected\n");
-                rpc_clnt_unset_connected (&rpc->conn);
-                break;
-        default:
-                fprintf (stderr, "unknown RPC event\n");
-        }
-
-        return 0;
-}
-
 int32_t
-my_callback (struct rpc_req *req, struct iovec *iov, int count, void *frame)
+my_callback(struct rpc_req *req, struct iovec *iov, int count, void *frame)
 {
-        rpc_status = req->rpc_status;
-        done = 1;
-        return 0;
+    pthread_mutex_lock(&mutex);
+    rpc_status = req->rpc_status;
+    done = 1;
+    /* Signal main thread which is the only waiter */
+    pthread_cond_signal(&cond);
+    pthread_mutex_unlock(&mutex);
+    return 0;
 }
 
 /* copied from gd_syncop_submit_request */
 int
-send_brick_req (xlator_t *this, struct rpc_clnt *rpc, char *path, int op)
+send_brick_req(xlator_t *this, struct rpc_clnt *rpc, char *path, int op)
 {
-        int            ret      = -1;
-        struct iobuf  *iobuf    = NULL;
-        struct iobref *iobref   = NULL;
-        struct iovec   iov      = {0, };
-        ssize_t        req_size = 0;
-        call_frame_t  *frame    = NULL;
-        gd1_mgmt_brick_op_req   brick_req;
-        void                    *req = &brick_req;
-        int                     i;
-
-        brick_req.op = op;
-        brick_req.name = path;
-        brick_req.input.input_val = NULL;
-        brick_req.input.input_len = 0;
-
-        req_size = xdr_sizeof ((xdrproc_t)xdr_gd1_mgmt_brick_op_req, req);
-        iobuf = iobuf_get2 (rpc->ctx->iobuf_pool, req_size);
-        if (!iobuf)
-                goto out;
-
-        iobref = iobref_new ();
-        if (!iobref)
-                goto out;
-
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        iobref_add (iobref, iobuf);
-
-        iov.iov_base = iobuf->ptr;
-        iov.iov_len  = iobuf_pagesize (iobuf);
-
-        /* Create the xdr payload */
-        ret = xdr_serialize_generic (iov, req,
-                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret == -1)
-                goto out;
-
-        iov.iov_len = ret;
-
-        for (i = 0; i < 60; ++i) {
-                if (rpc->conn.connected) {
-                        break;
-                }
-                sleep (1);
-        }
-
-        /* Send the msg */
-        ret = rpc_clnt_submit (rpc, &gf_attach_prog, op,
-                               my_callback, &iov, 1, NULL, 0, iobref, frame,
-                               NULL, 0, NULL, 0, NULL);
-        if (!ret) {
-                for (i = 0; !done && (i < 120); ++i) {
-                        sleep (1);
+    int ret = -1;
+    struct timespec ts;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t req_size = 0;
+    call_frame_t *frame = NULL;
+    gd1_mgmt_brick_op_req brick_req;
+    void *req = &brick_req;
+
+    brick_req.op = op;
+    brick_req.name = path;
+    brick_req.input.input_val = NULL;
+    brick_req.input.input_len = 0;
+    brick_req.dict.dict_val = NULL;
+    brick_req.dict.dict_len = 0;
+
+    req_size = xdr_sizeof((xdrproc_t)xdr_gd1_mgmt_brick_op_req, req);
+    iobuf = iobuf_get2(rpc->ctx->iobuf_pool, req_size);
+    if (!iobuf)
+        goto out;
+
+    iobref = iobref_new();
+    if (!iobref)
+        goto out;
+
+    iobref_add(iobref, iobuf);
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    /* Create the xdr payload */
+    ret = xdr_serialize_generic(iov, req, (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret == -1)
+        goto out;
+
+    iov.iov_len = ret;
+
+    /* Wait for connection */
+    timespec_now_realtime(&ts);
+    ts.tv_sec += CONNECT_TIMEOUT;
+    pthread_mutex_lock(&rpc->conn.lock);
+    {
+        while (!rpc->conn.connected)
+            if (pthread_cond_timedwait(&rpc->conn.cond, &rpc->conn.lock, &ts) ==
+                ETIMEDOUT) {
+                fprintf(stderr, "timeout waiting for RPC connection\n");
+                pthread_mutex_unlock(&rpc->conn.lock);
+                return EXIT_FAILURE;
+            }
+    }
+    pthread_mutex_unlock(&rpc->conn.lock);
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Send the msg */
+    ret = rpc_clnt_submit(rpc, &gf_attach_prog, op, my_callback, &iov, 1, NULL,
+                          0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    if (!ret) {
+        /* OK, wait for callback */
+        timespec_now_realtime(&ts);
+        ts.tv_sec += REPLY_TIMEOUT;
+        pthread_mutex_lock(&mutex);
+        {
+            while (!done)
+                if (pthread_cond_timedwait(&cond, &mutex, &ts) == ETIMEDOUT) {
+                    fprintf(stderr, "timeout waiting for RPC reply\n");
+                    pthread_mutex_unlock(&mutex);
+                    return EXIT_FAILURE;
                 }
         }
+        pthread_mutex_unlock(&mutex);
+    }
 
 out:
 
-        iobref_unref (iobref);
-        iobuf_unref (iobuf);
-        if (frame)
-                STACK_DESTROY (frame->root);
+    iobref_unref(iobref);
+    iobuf_unref(iobuf);
+    if (frame)
+        STACK_DESTROY(frame->root);
 
-        if (rpc_status != 0) {
-                fprintf (stderr, "got error %d on RPC\n", rpc_status);
-                return EXIT_FAILURE;
-        }
+    if (rpc_status != 0) {
+        fprintf(stderr, "got error %d on RPC\n", rpc_status);
+        return EXIT_FAILURE;
+    }
 
-        printf ("OK\n");
-        return EXIT_SUCCESS;
+    printf("OK\n");
+    return EXIT_SUCCESS;
 }
 
 int
-usage (char *prog)
+usage(char *prog)
 {
-        fprintf (stderr, "Usage: %s uds_path volfile_path (to attach)\n",
-                 prog);
-        fprintf (stderr, "       %s -d uds_path brick_path (to detach)\n",
-                 prog);
+    fprintf(stderr, "Usage: %s uds_path volfile_path (to attach)\n", prog);
+    fprintf(stderr, "       %s -d uds_path brick_path (to detach)\n", prog);
 
-        return EXIT_FAILURE;
+    return EXIT_FAILURE;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                  *fs;
-        struct rpc_clnt         *rpc;
-        dict_t                  *options;
-        int                     ret;
-        int                     op = GLUSTERD_BRICK_ATTACH;
-
-        for (;;) {
-                switch (getopt (argc, argv, "d")) {
-                case 'd':
-                        op = GLUSTERD_BRICK_TERMINATE;
-                        break;
-                case -1:
-                        goto done_parsing;
-                default:
-                        return usage (argv[0]);
-                }
+    glfs_t *fs;
+    struct rpc_clnt *rpc;
+    dict_t *options;
+    int ret;
+    int op = GLUSTERD_BRICK_ATTACH;
+
+    for (;;) {
+        switch (getopt(argc, argv, "d")) {
+            case 'd':
+                op = GLUSTERD_BRICK_TERMINATE;
+                break;
+            case -1:
+                goto done_parsing;
+            default:
+                return usage(argv[0]);
         }
+    }
 done_parsing:
-        if (optind != (argc - 2)) {
-                return usage (argv[0]);
-        }
+    if (optind != (argc - 2)) {
+        return usage(argv[0]);
+    }
 
-        fs = glfs_new ("gf-attach");
-        if (!fs) {
-                fprintf (stderr, "glfs_new failed\n");
-                return EXIT_FAILURE;
-        }
+    fs = glfs_new("gf-attach");
+    if (!fs) {
+        fprintf(stderr, "glfs_new failed\n");
+        return EXIT_FAILURE;
+    }
 
-        (void) glfs_set_logging (fs, "/dev/stderr", 7);
-        /*
-         * This will actually fail because we haven't defined a volume, but
-         * it will do enough initialization to get us going.
-         */
-        (void) glfs_init (fs);
+    (void)glfs_set_logging(fs, "/dev/stderr", 7);
+    /*
+     * This will actually fail because we haven't defined a volume, but
+     * it will do enough initialization to get us going.
+     */
+    (void)glfs_init(fs);
 
-        options = dict_new();
-        if (!options) {
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret != 0) {
-                fprintf (stderr, "failed to set transport type\n");
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport.address-family", "unix");
-        if (ret != 0) {
-                fprintf (stderr, "failed to set address family\n");
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport.socket.connect-path",
-                            argv[optind]);
-        if (ret != 0) {
-                fprintf (stderr, "failed to set connect path\n");
-                return EXIT_FAILURE;
-        }
+    options = dict_new();
+    if (!options) {
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret != 0) {
+        fprintf(stderr, "failed to set transport type\n");
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport.address-family", "unix");
+    if (ret != 0) {
+        fprintf(stderr, "failed to set address family\n");
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport.socket.connect-path", argv[optind]);
+    if (ret != 0) {
+        fprintf(stderr, "failed to set connect path\n");
+        return EXIT_FAILURE;
+    }
 
-        rpc = rpc_clnt_new (options, fs->ctx->master, "gf-attach-rpc", 0);
-        if (!rpc) {
-                fprintf (stderr, "rpc_clnt_new failed\n");
-                return EXIT_FAILURE;
-        }
+    rpc = rpc_clnt_new(options, fs->ctx->master, "gf-attach-rpc", 0);
+    if (!rpc) {
+        fprintf(stderr, "rpc_clnt_new failed\n");
+        return EXIT_FAILURE;
+    }
 
-        if (rpc_clnt_register_notify (rpc, my_notify, NULL) != 0) {
-                fprintf (stderr, "rpc_clnt_register_notify failed\n");
-                return EXIT_FAILURE;
-        }
+    if (rpc_clnt_register_notify(rpc, NULL, NULL) != 0) {
+        fprintf(stderr, "rpc_clnt_register_notify failed\n");
+        return EXIT_FAILURE;
+    }
 
-        if (rpc_clnt_start(rpc) != 0) {
-                fprintf (stderr, "rpc_clnt_start failed\n");
-                return EXIT_FAILURE;
-        }
+    if (rpc_clnt_start(rpc) != 0) {
+        fprintf(stderr, "rpc_clnt_start failed\n");
+        return EXIT_FAILURE;
+    }
 
-        return send_brick_req (fs->ctx->master, rpc, argv[optind+1], op);
+    return send_brick_req(fs->ctx->master, rpc, argv[optind + 1], op);
 }
diff --git a/glusterfsd/src/glusterfsd-mem-types.h b/glusterfsd/src/glusterfsd-mem-types.h
index 7135c0ada9e..e59b558deb0 100644
--- a/glusterfsd/src/glusterfsd-mem-types.h
+++ b/glusterfsd/src/glusterfsd-mem-types.h
@@ -10,18 +10,18 @@
 #ifndef __GLUSTERFSD_MEM_TYPES_H__
 #define __GLUSTERFSD_MEM_TYPES_H__
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 #define GF_MEM_TYPE_START (gf_common_mt_end + 1)
 
 enum gfd_mem_types_ {
-        gfd_mt_xlator_list_t = GF_MEM_TYPE_START,
-        gfd_mt_xlator_t,
-        gfd_mt_server_cmdline_t,
-        gfd_mt_xlator_cmdline_option_t,
-        gfd_mt_char,
-        gfd_mt_call_pool_t,
-        gfd_mt_end
+    gfd_mt_xlator_list_t = GF_MEM_TYPE_START,
+    gfd_mt_xlator_t,
+    gfd_mt_server_cmdline_t,
+    gfd_mt_xlator_cmdline_option_t,
+    gfd_mt_char,
+    gfd_mt_call_pool_t,
+    gfd_mt_end
 
 };
 #endif
diff --git a/glusterfsd/src/glusterfsd-messages.h b/glusterfsd/src/glusterfsd-messages.h
index e9c28f71263..0cdbffa71ea 100644
--- a/glusterfsd/src/glusterfsd-messages.h
+++ b/glusterfsd/src/glusterfsd-messages.h
@@ -11,107 +11,83 @@
 #ifndef _GLUSTERFSD_MESSAGES_H_
 #define _GLUSTERFSD_MESSAGES_H_
 
-#include "glfs-message-id.h"
+#include <glusterfs/glfs-message-id.h>
 
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
  */
 
-#define GLFS_COMP_BASE          GLFS_MSGID_COMP_GLUSTERFSD
-#define GLFS_NUM_MESSAGES       37
-#define GLFS_MSGID_END          (GLFS_COMP_BASE + GLFS_NUM_MESSAGES + 1)
-/* Messaged with message IDs */
-#define glfs_msg_start_x GLFS_COMP_BASE, "Invalid: Start of messages"
-/*------------*/
-#define glusterfsd_msg_1 (GLFS_COMP_BASE + 1), "Could not create absolute" \
-                        " mountpoint path"
-#define glusterfsd_msg_2 (GLFS_COMP_BASE + 2), "Could not get current " \
-                        "working directory"
-#define glusterfsd_msg_3 (GLFS_COMP_BASE + 3), "failed to set mount-point" \
-                        " to options dictionary"
-#define glusterfsd_msg_4 (GLFS_COMP_BASE + 4), "failed to set dict value" \
-                        " for key %s"
-#define glusterfsd_msg_5 (GLFS_COMP_BASE + 5), "failed to set 'disable'" \
-                        " for key %s"
-#define glusterfsd_msg_6 (GLFS_COMP_BASE + 6), "failed to set 'enable'" \
-                        " for key %s"
-#define glusterfsd_msg_7 (GLFS_COMP_BASE + 7), "Not a client process, not" \
-                        " performing mount operation"
-#define glusterfsd_msg_8 (GLFS_COMP_BASE + 8), "MOUNT-POINT %s" \
-                        " initialization failed"
-#define glusterfsd_msg_9 (GLFS_COMP_BASE + 9), "loading volume file %s" \
-                        " failed"
-#define glusterfsd_msg_10 (GLFS_COMP_BASE + 10), "xlator option %s is" \
-                        " invalid"
-#define glusterfsd_msg_11 (GLFS_COMP_BASE + 11), "Fetching the volume" \
-                        " file from server..."
-#define glusterfsd_msg_12 (GLFS_COMP_BASE + 12), "volume initialization" \
-                        " failed."
-#define glusterfsd_msg_13 (GLFS_COMP_BASE + 13), "ERROR: glusterfs uuid" \
-                        " generation failed"
-#define glusterfsd_msg_14 (GLFS_COMP_BASE + 14), "ERROR: glusterfs %s" \
-                        " pool creation failed"
-#define glusterfsd_msg_15 (GLFS_COMP_BASE + 15), "ERROR: '--volfile-id' is" \
-                        " mandatory if '-s' OR '--volfile-server'" \
-                        " option is given"
-#define glusterfsd_msg_16 (GLFS_COMP_BASE + 16), "ERROR: parsing the" \
-                        " volfile failed"
-#define glusterfsd_msg_17 (GLFS_COMP_BASE + 17), "pidfile %s open failed"
-#define glusterfsd_msg_18 (GLFS_COMP_BASE + 18), "pidfile %s lock failed"
-#define glusterfsd_msg_19 (GLFS_COMP_BASE + 19), "pidfile %s unlock failed"
-#define glusterfsd_msg_20 (GLFS_COMP_BASE + 20), "pidfile %s truncation" \
-                        " failed"
-#define glusterfsd_msg_21 (GLFS_COMP_BASE + 21), "pidfile %s write failed"
-#define glusterfsd_msg_22 (GLFS_COMP_BASE + 22), "failed to execute" \
-                        " pthread_sigmask"
-#define glusterfsd_msg_23 (GLFS_COMP_BASE + 23), "failed to create pthread"
-#define glusterfsd_msg_24 (GLFS_COMP_BASE + 24), "daemonization failed"
-#define glusterfsd_msg_25 (GLFS_COMP_BASE + 25), "mount failed"
-#define glusterfsd_msg_26 (GLFS_COMP_BASE + 26), "failed to construct" \
-                        " the graph"
-#define glusterfsd_msg_27 (GLFS_COMP_BASE + 27), "fuse xlator cannot be" \
-                        " specified in volume file"
-#define glusterfsd_msg_28 (GLFS_COMP_BASE + 28), "Cannot reach volume" \
-                        " specification file"
-#define glusterfsd_msg_29 (GLFS_COMP_BASE + 29), "ERROR: glusterfs context" \
-                        " not initialized"
-#define glusterfsd_msg_30 (GLFS_COMP_BASE + 30), "Started running %s" \
-                        " version %s (args: %s)"
-#define glusterfsd_msg_31 (GLFS_COMP_BASE + 31), "Could not create new" \
-                        " sync-environment"
-#define glusterfsd_msg_32 (GLFS_COMP_BASE + 32), "received signum (%d)," \
-                        " shutting down"
-#define glusterfsd_msg_33 (GLFS_COMP_BASE + 33), "obsolete option " \
-                        "'--volfile-max-fetch-attempts or fetch-attempts' " \
-                        "was provided"
-#define glusterfsd_msg_34 (GLFS_COMP_BASE + 34), "memory accounting init" \
-                        " failed."
-#define glusterfsd_msg_35 (GLFS_COMP_BASE + 35), "rpc req buffer " \
-                        " unserialization failed."
-#define glusterfsd_msg_36 (GLFS_COMP_BASE + 36), "problem in xlator " \
-                        " loading."
-#define glusterfsd_msg_37 (GLFS_COMP_BASE + 37), "failed to get dict value"
-
-/*------------*/
-#define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
+GLFS_MSGID(
+    GLUSTERFSD, glusterfsd_msg_1, glusterfsd_msg_2, glusterfsd_msg_3,
+    glusterfsd_msg_4, glusterfsd_msg_5, glusterfsd_msg_6, glusterfsd_msg_7,
+    glusterfsd_msg_8, glusterfsd_msg_9, glusterfsd_msg_10, glusterfsd_msg_11,
+    glusterfsd_msg_12, glusterfsd_msg_13, glusterfsd_msg_14, glusterfsd_msg_15,
+    glusterfsd_msg_16, glusterfsd_msg_17, glusterfsd_msg_18, glusterfsd_msg_19,
+    glusterfsd_msg_20, glusterfsd_msg_21, glusterfsd_msg_22, glusterfsd_msg_23,
+    glusterfsd_msg_24, glusterfsd_msg_25, glusterfsd_msg_26, glusterfsd_msg_27,
+    glusterfsd_msg_28, glusterfsd_msg_29, glusterfsd_msg_30, glusterfsd_msg_31,
+    glusterfsd_msg_32, glusterfsd_msg_33, glusterfsd_msg_34, glusterfsd_msg_35,
+    glusterfsd_msg_36, glusterfsd_msg_37, glusterfsd_msg_38, glusterfsd_msg_39,
+    glusterfsd_msg_40, glusterfsd_msg_41, glusterfsd_msg_42, glusterfsd_msg_43,
+    glusterfsd_msg_029, glusterfsd_msg_041, glusterfsd_msg_042);
 
+#define glusterfsd_msg_1_STR "Could not create absolute mountpoint path"
+#define glusterfsd_msg_2_STR "Could not get current working directory"
+#define glusterfsd_msg_4_STR "failed to set mount-point to options dictionary"
+#define glusterfsd_msg_3_STR "failed to set dict value for key"
+#define glusterfsd_msg_5_STR "failed to set disable for key"
+#define glusterfsd_msg_6_STR "failed to set enable for key"
+#define glusterfsd_msg_7_STR                                                   \
+    "Not a client process, not performing mount operation"
+#define glusterfsd_msg_8_STR "MOUNT_POINT initialization failed"
+#define glusterfsd_msg_9_STR "loading volume file failed"
+#define glusterfsd_msg_10_STR "xlator option is invalid"
+#define glusterfsd_msg_11_STR "Fetching the volume file from server..."
+#define glusterfsd_msg_12_STR "volume initialization failed"
+#define glusterfsd_msg_34_STR "memory init failed"
+#define glusterfsd_msg_13_STR "ERROR: glusterfs uuid generation failed"
+#define glusterfsd_msg_14_STR "ERROR: glusterfs pool creation failed"
+#define glusterfsd_msg_15_STR                                                  \
+    "ERROR: '--volfile-id' is mandatory if '-s' OR '--volfile-server' option " \
+    "is given"
+#define glusterfsd_msg_16_STR "ERROR: parsing the volfile failed"
+#define glusterfsd_msg_33_STR                                                  \
+    "obsolete option '--volfile-max-fecth-attempts or fetch-attempts' was "    \
+    "provided"
+#define glusterfsd_msg_17_STR "pidfile open failed"
+#define glusterfsd_msg_18_STR "pidfile lock failed"
+#define glusterfsd_msg_20_STR "pidfile truncation failed"
+#define glusterfsd_msg_21_STR "pidfile write failed"
+#define glusterfsd_msg_22_STR "failed to exeute pthread_sigmask"
+#define glusterfsd_msg_23_STR "failed to create pthread"
+#define glusterfsd_msg_24_STR "daemonization failed"
+#define glusterfsd_msg_25_STR "mount failed"
+#define glusterfsd_msg_26_STR "failed to construct the graph"
+#define glusterfsd_msg_27_STR "fuse xlator cannot be specified in volume file"
+#define glusterfsd_msg_28_STR "Cannot reach volume specification file"
+#define glusterfsd_msg_29_STR "ERROR: glusterfsd context not initialized"
+#define glusterfsd_msg_43_STR                                                  \
+    "command line argument --brick-mux is valid only for brick process"
+#define glusterfsd_msg_029_STR "failed to create command line string"
+#define glusterfsd_msg_30_STR "Started running version"
+#define glusterfsd_msg_31_STR "Could not create new sync-environment"
+#define glusterfsd_msg_40_STR "No change in volfile, countinuing"
+#define glusterfsd_msg_39_STR "Unable to create/delete temporary file"
+#define glusterfsd_msg_38_STR                                                  \
+    "Not processing brick-op since volume graph is not yet active"
+#define glusterfsd_msg_35_STR "rpc req buffer unserialization failed"
+#define glusterfsd_msg_36_STR "problem in xlator loading"
+#define glusterfsd_msg_37_STR "failed to get dict value"
+#define glusterfsd_msg_41_STR "received attach request for volfile"
+#define glusterfsd_msg_42_STR "failed to unserialize xdata to dictionary"
+#define glusterfsd_msg_041_STR "can't detach. flie not found"
+#define glusterfsd_msg_042_STR                                                 \
+    "couldnot detach old graph. Aborting the reconfiguration operation"
 
 #endif /* !_GLUSTERFSD_MESSAGES_H_ */
diff --git a/glusterfsd/src/glusterfsd-mgmt.c b/glusterfsd/src/glusterfsd-mgmt.c
index ca706d1020d..eaf6796e4c3 100644
--- a/glusterfsd/src/glusterfsd-mgmt.c
+++ b/glusterfsd/src/glusterfsd-mgmt.c
@@ -13,11 +13,10 @@
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
-#include "stack.h"
-#include "dict.h"
-#include "event.h"
-#include "defaults.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/dict.h>
+#include <glusterfs/gf-event.h>
+#include <glusterfs/defaults.h>
 
 #include "rpc-clnt.h"
 #include "protocol-common.h"
@@ -29,2685 +28,3028 @@
 #include "glusterfsd.h"
 #include "rpcsvc.h"
 #include "cli1-xdr.h"
-#include "statedump.h"
-#include "syncop.h"
-#include "xlator.h"
-#include "syscall.h"
+#include <glusterfs/statedump.h>
+#include <glusterfs/syncop.h>
+#include <glusterfs/xlator.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/monitoring.h>
+#include "server.h"
 
 static gf_boolean_t is_mgmt_rpc_reconnect = _gf_false;
 int need_emancipate = 0;
 
-int glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx);
-int glusterfs_volfile_fetch (glusterfs_ctx_t *ctx);
-int glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp);
-int glusterfs_graph_unknown_options (glusterfs_graph_t *graph);
-int emancipate(glusterfs_ctx_t *ctx, int ret);
+int
+glusterfs_mgmt_pmap_signin(glusterfs_ctx_t *ctx);
+int
+glusterfs_volfile_fetch(glusterfs_ctx_t *ctx);
+int
+glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp);
+int
+emancipate(glusterfs_ctx_t *ctx, int ret);
+int
+glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp,
+                                   char *volfile_id, char *checksum,
+                                   dict_t *dict);
+int
+glusterfs_mux_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx,
+                                  gf_volfile_t *volfile_obj, char *checksum,
+                                  dict_t *dict);
+int
+glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp,
+                                   char *volfile_id, char *checksum,
+                                   dict_t *dict);
+int
+glusterfs_process_svc_detach(glusterfs_ctx_t *ctx, gf_volfile_t *volfile_obj);
+
+gf_boolean_t
+mgmt_is_multiplexed_daemon(char *name);
+
+static int
+glusterfs_volume_top_perf(const char *brick_path, dict_t *dict,
+                          gf_boolean_t write_test);
 
 int
-mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = glusterfsd_ctx;
-        gf_log ("mgmt", GF_LOG_INFO, "Volume file changed");
+    ctx = glusterfsd_ctx;
+    gf_log("mgmt", GF_LOG_INFO, "Volume file changed");
 
-        glusterfs_volfile_fetch (ctx);
-        return 0;
+    glusterfs_volfile_fetch(ctx);
+    return 0;
 }
 
-
 int
-mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_process_volfile(const char *volfile, ssize_t size, char *volfile_id,
+                     dict_t *dict)
 {
-        return 0;
-}
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    FILE *tmpfp = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+    gf_volfile_t *volfile_tmp = NULL;
+    char sha256_hash[SHA256_DIGEST_LENGTH] = {
+        0,
+    };
+    int tmp_fd = -1;
+    char template[] = "/tmp/glfs.volfile.XXXXXX";
+
+    glusterfs_compute_sha256((const unsigned char *)volfile, size, sha256_hash);
+    ctx = THIS->ctx;
+    LOCK(&ctx->volfile_lock);
+    {
+        list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list)
+        {
+            if (!strcmp(volfile_id, volfile_obj->vol_id)) {
+                if (!memcmp(sha256_hash, volfile_obj->volfile_checksum,
+                            sizeof(volfile_obj->volfile_checksum))) {
+                    UNLOCK(&ctx->volfile_lock);
+                    gf_smsg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_40,
+                            NULL);
+                    goto out;
+                }
+                volfile_tmp = volfile_obj;
+                break;
+            }
+        }
 
-struct iobuf *
-glusterfs_serialize_reply (rpcsvc_request_t *req, void *arg,
-                           struct iovec *outmsg, xdrproc_t xdrproc)
-{
-        struct iobuf            *iob = NULL;
-        ssize_t                  retlen = -1;
-        ssize_t                  xdr_size = 0;
+        /* coverity[secure_temp] mkstemp uses 0600 as the mode */
+        tmp_fd = mkstemp(template);
+        if (-1 == tmp_fd) {
+            UNLOCK(&ctx->volfile_lock);
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0, glusterfsd_msg_39,
+                    "create template=%s", template, NULL);
+            ret = -1;
+            goto out;
+        }
 
-        /* First, get the io buffer into which the reply in arg will
-         * be serialized.
+        /* Calling unlink so that when the file is closed or program
+         * terminates the temporary file is deleted.
          */
-        xdr_size = xdr_sizeof (xdrproc, arg);
-        iob = iobuf_get2 (req->svc->ctx->iobuf_pool, xdr_size);
-        if (!iob) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to get iobuf");
-                goto ret;
+        ret = sys_unlink(template);
+        if (ret < 0) {
+            gf_smsg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_39,
+                    "delete template=%s", template, NULL);
+            ret = 0;
         }
 
-        iobuf_to_iovec (iob, outmsg);
-        /* Use the given serializer to translate the give C structure in arg
-         * to XDR format which will be written into the buffer in outmsg.
-         */
-        /* retlen is used to received the error since size_t is unsigned and we
-         * need -1 for error notification during encoding.
-         */
-        retlen = xdr_serialize_generic (*outmsg, arg, xdrproc);
-        if (retlen == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to encode message");
-                goto ret;
+        tmpfp = fdopen(tmp_fd, "w+b");
+        if (!tmpfp) {
+            ret = -1;
+            goto unlock;
         }
 
-        outmsg->iov_len = retlen;
-ret:
-        if (retlen == -1) {
-                iob = NULL;
+        fwrite(volfile, size, 1, tmpfp);
+        fflush(tmpfp);
+        if (ferror(tmpfp)) {
+            ret = -1;
+            goto unlock;
         }
 
-        return iob;
+        if (!volfile_tmp) {
+            /* There is no checksum in the list, which means simple attach
+             * the volfile
+             */
+            ret = glusterfs_process_svc_attach_volfp(ctx, tmpfp, volfile_id,
+                                                     sha256_hash, dict);
+            goto unlock;
+        }
+        ret = glusterfs_mux_volfile_reconfigure(tmpfp, ctx, volfile_obj,
+                                                sha256_hash, dict);
+        if (ret < 0) {
+            gf_msg_debug("glusterfsd-mgmt", EINVAL, "Reconfigure failed !!");
+        }
+    }
+unlock:
+    UNLOCK(&ctx->volfile_lock);
+out:
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
+    return ret;
 }
 
 int
-glusterfs_submit_reply (rpcsvc_request_t *req, void *arg,
-                        struct iovec *payload, int payloadcount,
-                        struct iobref *iobref, xdrproc_t xdrproc)
+mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        struct iobuf           *iob        = NULL;
-        int                     ret        = -1;
-        struct iovec            rsp        = {0,};
-        char                    new_iobref = 0;
+    return 0;
+}
 
-        if (!req) {
-                GF_ASSERT (req);
-                goto out;
-        }
+struct iobuf *
+glusterfs_serialize_reply(rpcsvc_request_t *req, void *arg,
+                          struct iovec *outmsg, xdrproc_t xdrproc)
+{
+    struct iobuf *iob = NULL;
+    ssize_t retlen = -1;
+    ssize_t xdr_size = 0;
+
+    /* First, get the io buffer into which the reply in arg will
+     * be serialized.
+     */
+    xdr_size = xdr_sizeof(xdrproc, arg);
+    iob = iobuf_get2(req->svc->ctx->iobuf_pool, xdr_size);
+    if (!iob) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to get iobuf");
+        goto ret;
+    }
+
+    iobuf_to_iovec(iob, outmsg);
+    /* Use the given serializer to translate the give C structure in arg
+     * to XDR format which will be written into the buffer in outmsg.
+     */
+    /* retlen is used to received the error since size_t is unsigned and we
+     * need -1 for error notification during encoding.
+     */
+    retlen = xdr_serialize_generic(*outmsg, arg, xdrproc);
+    if (retlen == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to encode message");
+        GF_FREE(iob);
+        goto ret;
+    }
+
+    outmsg->iov_len = retlen;
+ret:
+    if (retlen == -1) {
+        iob = NULL;
+    }
 
-        if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "out of memory");
-                        goto out;
-                }
+    return iob;
+}
 
-                new_iobref = 1;
+int
+glusterfs_submit_reply(rpcsvc_request_t *req, void *arg, struct iovec *payload,
+                       int payloadcount, struct iobref *iobref,
+                       xdrproc_t xdrproc)
+{
+    struct iobuf *iob = NULL;
+    int ret = -1;
+    struct iovec rsp = {
+        0,
+    };
+    char new_iobref = 0;
+
+    if (!req) {
+        GF_ASSERT(req);
+        goto out;
+    }
+
+    if (!iobref) {
+        iobref = iobref_new();
+        if (!iobref) {
+            gf_log(THIS->name, GF_LOG_ERROR, "out of memory");
+            goto out;
         }
 
-        iob = glusterfs_serialize_reply (req, arg, &rsp, xdrproc);
-        if (!iob) {
-                gf_log_callingfn (THIS->name, GF_LOG_ERROR, "Failed to serialize reply");
-        } else {
-                iobref_add (iobref, iob);
-        }
+        new_iobref = 1;
+    }
 
-        ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount,
-                                     iobref);
+    iob = glusterfs_serialize_reply(req, arg, &rsp, xdrproc);
+    if (!iob) {
+        gf_log_callingfn(THIS->name, GF_LOG_ERROR, "Failed to serialize reply");
+    } else {
+        iobref_add(iobref, iob);
+    }
 
-        /* Now that we've done our job of handing the message to the RPC layer
-         * we can safely unref the iob in the hope that RPC layer must have
-         * ref'ed the iob on receiving into the txlist.
-         */
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Reply submission failed");
-                goto out;
-        }
+    ret = rpcsvc_submit_generic(req, &rsp, 1, payload, payloadcount, iobref);
 
-        ret = 0;
+    /* Now that we've done our job of handing the message to the RPC layer
+     * we can safely unref the iob in the hope that RPC layer must have
+     * ref'ed the iob on receiving into the txlist.
+     */
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Reply submission failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (iob)
-                iobuf_unref (iob);
+    if (iob)
+        iobuf_unref(iob);
 
-        if (new_iobref && iobref)
-                iobref_unref (iobref);
+    if (new_iobref && iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_terminate_response_send (rpcsvc_request_t *req, int op_ret)
+glusterfs_terminate_response_send(rpcsvc_request_t *req, int op_ret)
 {
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        dict_t                  *dict = NULL;
-        int                     ret = 0;
-
-        rsp.op_ret = op_ret;
-        rsp.op_errno = 0;
-        rsp.op_errstr = "";
-        dict = dict_new ();
-
-        if (dict)
-                ret = dict_allocate_and_serialize (dict, &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-
-
-        if (ret == 0)
-                ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                              (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-
-        GF_FREE (rsp.output.output_val);
-        if (dict)
-                dict_unref (dict);
-        return ret;
-}
-
-void
-glusterfs_autoscale_threads (glusterfs_ctx_t *ctx, int incr)
-{
-        struct event_pool       *pool           = ctx->event_pool;
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    int ret = 0;
+
+    rsp.op_ret = op_ret;
+    rsp.op_errno = 0;
+    rsp.op_errstr = "";
+    dict = dict_new();
+
+    if (dict)
+        ret = dict_allocate_and_serialize(dict, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+
+    if (ret == 0)
+        ret = glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
-        pool->auto_thread_count += incr;
-        (void) event_reconfigure_threads (pool, pool->eventthreadcount+incr);
+    GF_FREE(rsp.output.output_val);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int
-glusterfs_handle_terminate (rpcsvc_request_t *req)
+glusterfs_handle_terminate(rpcsvc_request_t *req)
 {
-        gd1_mgmt_brick_op_req   xlator_req      = {0,};
-        ssize_t                 ret;
-        glusterfs_ctx_t         *ctx            = NULL;
-        xlator_t                *top            = NULL;
-        xlator_t                *victim         = NULL;
-        xlator_list_t           **trav_p        = NULL;
-        gf_boolean_t            lockflag        = _gf_false;
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                return -1;
-        }
-        ctx = glusterfsd_ctx;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                /* Find the xlator_list_t that points to our victim. */
-                if (glusterfsd_ctx->active) {
-                        top = glusterfsd_ctx->active->first;
-                        for (trav_p = &top->children; *trav_p;
-                                                    trav_p = &(*trav_p)->next) {
-                                victim = (*trav_p)->xlator;
-                                if (strcmp (victim->name, xlator_req.name) == 0) {
-                                        break;
-                                }
-                        }
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    ssize_t ret;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *top = NULL;
+    xlator_t *victim = NULL;
+    xlator_t *tvictim = NULL;
+    xlator_list_t **trav_p = NULL;
+    gf_boolean_t lockflag = _gf_false;
+    gf_boolean_t still_bricks_attached = _gf_false;
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ctx = glusterfsd_ctx;
+
+    LOCK(&ctx->volfile_lock);
+    {
+        /* Find the xlator_list_t that points to our victim. */
+        if (glusterfsd_ctx->active) {
+            top = glusterfsd_ctx->active->first;
+            for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+                victim = (*trav_p)->xlator;
+                if (!victim->cleanup_starting &&
+                    strcmp(victim->name, xlator_req.name) == 0) {
+                    break;
                 }
-        }
-        if (!*trav_p) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "can't terminate %s - not found",
-                          xlator_req.name);
-                /*
-                 * Used to be -ENOENT.  However, the caller asked us to
-                 * make sure it's down and if it's already down that's
-                 * good enough.
-                 */
-                glusterfs_terminate_response_send (req, 0);
-                goto err;
+            }
         }
 
-        glusterfs_terminate_response_send (req, 0);
-        if ((trav_p == &top->children) && !(*trav_p)->next) {
-                gf_log (THIS->name, GF_LOG_INFO,
-                        "terminating after loss of last child %s",
-                        xlator_req.name);
-                glusterfs_mgmt_pmap_signout (glusterfsd_ctx, xlator_req.name);
-                kill (getpid(), SIGTERM);
-        } else {
-                /*
-                 * This is terribly unsafe without quiescing or shutting
-                 * things down properly but it gets us to the point
-                 * where we can test other stuff.
-                 *
-                 * TBD: finish implementing this "detach" code properly
-                 */
-                UNLOCK (&ctx->volfile_lock);
-                lockflag = _gf_true;
-                gf_log (THIS->name, GF_LOG_INFO, "detaching not-only"
-                         " child %s", xlator_req.name);
-                top->notify (top, GF_EVENT_CLEANUP, victim);
-        }
+        if (!top)
+            goto err;
+    }
+    if (!*trav_p) {
+        gf_log(THIS->name, GF_LOG_ERROR, "can't terminate %s - not found",
+               xlator_req.name);
+        /*
+         * Used to be -ENOENT.  However, the caller asked us to
+         * make sure it's down and if it's already down that's
+         * good enough.
+         */
+        glusterfs_terminate_response_send(req, 0);
+        goto err;
+    }
+
+    glusterfs_terminate_response_send(req, 0);
+    for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+        tvictim = (*trav_p)->xlator;
+        if (!tvictim->cleanup_starting &&
+            !strcmp(tvictim->name, xlator_req.name)) {
+            continue;
+        }
+        if (!tvictim->cleanup_starting) {
+            still_bricks_attached = _gf_true;
+            break;
+        }
+    }
+    if (!still_bricks_attached) {
+        gf_log(THIS->name, GF_LOG_INFO,
+               "terminating after loss of last child %s", xlator_req.name);
+        rpc_clnt_mgmt_pmap_signout(glusterfsd_ctx, xlator_req.name);
+        kill(getpid(), SIGTERM);
+    } else {
+        /* TODO cleanup sequence needs to be done properly for
+           Quota and Changelog
+        */
+        if (victim->cleanup_starting)
+            goto err;
+
+        rpc_clnt_mgmt_pmap_signout(glusterfsd_ctx, xlator_req.name);
+        victim->cleanup_starting = 1;
+
+        UNLOCK(&ctx->volfile_lock);
+        lockflag = _gf_true;
+
+        gf_log(THIS->name, GF_LOG_INFO,
+               "detaching not-only"
+               " child %s",
+               xlator_req.name);
+        top->notify(top, GF_EVENT_CLEANUP, victim);
+    }
 err:
-        if (!lockflag)
-                UNLOCK (&ctx->volfile_lock);
-        free (xlator_req.name);
-        xlator_req.name = NULL;
-        return 0;
+    if (!lockflag)
+        UNLOCK(&ctx->volfile_lock);
+    if (xlator_req.input.input_val)
+        free(xlator_req.input.input_val);
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    free(xlator_req.name);
+    xlator_req.name = NULL;
+    return 0;
 }
 
 int
-glusterfs_translator_info_response_send (rpcsvc_request_t *req, int ret,
-                                         char *msg, dict_t *output)
+glusterfs_translator_info_response_send(rpcsvc_request_t *req, int ret,
+                                        char *msg, dict_t *output)
 {
-        gd1_mgmt_brick_op_rsp    rsp = {0,};
-        gf_boolean_t             free_ptr = _gf_false;
-        GF_ASSERT (req);
-
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg && msg[0])
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        ret = -1;
-        if (output) {
-                ret = dict_allocate_and_serialize (output,
-                                                   &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-        }
-        if (!ret)
-                free_ptr = _gf_true;
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    gf_boolean_t free_ptr = _gf_false;
+    GF_ASSERT(req);
+
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg && msg[0])
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
-        if (free_ptr)
-                GF_FREE (rsp.output.output_val);
-        return ret;
+    ret = -1;
+    if (output) {
+        ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+    }
+    if (!ret)
+        free_ptr = _gf_true;
+
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
+    if (free_ptr)
+        GF_FREE(rsp.output.output_val);
+    return ret;
 }
 
 int
-glusterfs_xlator_op_response_send (rpcsvc_request_t *req, int op_ret,
-                                   char *msg, dict_t *output)
+glusterfs_xlator_op_response_send(rpcsvc_request_t *req, int op_ret, char *msg,
+                                  dict_t *output)
 {
-        gd1_mgmt_brick_op_rsp    rsp = {0,};
-        int                      ret = -1;
-        gf_boolean_t             free_ptr = _gf_false;
-        GF_ASSERT (req);
-
-        rsp.op_ret = op_ret;
-        rsp.op_errno = 0;
-        if (op_ret && msg && msg[0])
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        if (output) {
-                ret = dict_allocate_and_serialize (output,
-                                                   &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-        }
-        if (!ret)
-                free_ptr = _gf_true;
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    gf_boolean_t free_ptr = _gf_false;
+    GF_ASSERT(req);
+
+    rsp.op_ret = op_ret;
+    rsp.op_errno = 0;
+    if (op_ret && msg && msg[0])
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    if (output) {
+        ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+    }
+    if (!ret)
+        free_ptr = _gf_true;
+
+    ret = glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                                 (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
-        if (free_ptr)
-                GF_FREE (rsp.output.output_val);
+    if (free_ptr)
+        GF_FREE(rsp.output.output_val);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_handle_translator_info_get (rpcsvc_request_t *req)
+glusterfs_handle_translator_info_get(rpcsvc_request_t *req)
 {
-        int32_t                 ret     = -1;
-        gd1_mgmt_brick_op_req   xlator_req = {0,};
-        dict_t                  *dict    = NULL;
-        xlator_t                *this = NULL;
-        gf1_cli_top_op          top_op = 0;
-        uint32_t                blk_size = 0;
-        uint32_t                blk_count = 0;
-        double                  time = 0;
-        double                  throughput = 0;
-        xlator_t                *any = NULL;
-        xlator_t                *xlator = NULL;
-        glusterfs_graph_t       *active = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        char                    msg[2048] = {0,};
-        dict_t                  *output = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *this = NULL;
+    gf1_cli_top_op top_op = 0;
+    xlator_t *any = NULL;
+    xlator_t *xlator = NULL;
+    glusterfs_graph_t *active = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char msg[2048] = {
+        0,
+    };
+    dict_t *output = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "top-op", (int32_t *)&top_op);
+    if (ret)
+        goto cont;
+    if (GF_CLI_TOP_READ_PERF == top_op) {
+        ret = glusterfs_volume_top_perf(xlator_req.name, dict, _gf_false);
+    } else if (GF_CLI_TOP_WRITE_PERF == top_op) {
+        ret = glusterfs_volume_top_perf(xlator_req.name, dict, _gf_true);
+    }
 
-        dict = dict_new ();
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "top-op", (int32_t *)&top_op);
-        if ((!ret) && (GF_CLI_TOP_READ_PERF == top_op ||
-            GF_CLI_TOP_WRITE_PERF == top_op)) {
-                ret = dict_get_uint32 (dict, "blk-size", &blk_size);
-                if (ret)
-                        goto cont;
-                ret = dict_get_uint32 (dict, "blk-cnt", &blk_count);
-                if (ret)
-                        goto cont;
-
-                if (GF_CLI_TOP_READ_PERF == top_op) {
-                        ret = glusterfs_volume_top_read_perf
-                                (blk_size, blk_count, xlator_req.name,
-                                 &throughput, &time);
-                } else if ( GF_CLI_TOP_WRITE_PERF == top_op) {
-                        ret = glusterfs_volume_top_write_perf
-                                (blk_size, blk_count, xlator_req.name,
-                                 &throughput, &time);
-                }
-                ret = dict_set_double (dict, "time", time);
-                if (ret)
-                        goto cont;
-                ret = dict_set_double (dict, "throughput", throughput);
-                if (ret)
-                        goto cont;
-        }
 cont:
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        any = active->first;
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    if (active == NULL) {
+        gf_log(THIS->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    any = active->first;
+
+    xlator = get_xlator_by_name(any, xlator_req.name);
+    if (!xlator) {
+        ret = -1;
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
 
-        xlator = get_xlator_by_name (any, xlator_req.name);
+    if (strcmp(xlator->type, "debug/io-stats")) {
+        xlator = get_xlator_by_type(xlator, "debug/io-stats");
         if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
+            ret = -1;
+            snprintf(msg, sizeof(msg),
+                     "xlator-type debug/io-stats is not loaded");
+            goto out;
         }
+    }
 
-        /*
-         * Searching by name will only get us to the decompounder translator,
-         * but we really want io-stats.  Since we know the exact relationship
-         * between these two, it's easy to get from one to the other.
-         *
-         * TBD: should this even be notify, or something else?
-         */
-        xlator = FIRST_CHILD(xlator);
-
-        output = dict_new ();
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_INFO, dict, output);
+    output = dict_new();
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_INFO, dict, output);
 
 out:
-        ret = glusterfs_translator_info_response_send (req, ret, msg, output);
-
-        free (xlator_req.name);
-        free (xlator_req.input.input_val);
-        if (output)
-                dict_unref (output);
-        if (dict)
-                dict_unref (dict);
-        return ret;
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
+
+    free(xlator_req.name);
+    free(xlator_req.input.input_val);
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    if (output)
+        dict_unref(output);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
-int
-glusterfs_volume_top_write_perf (uint32_t blk_size, uint32_t blk_count,
-                                 char *brick_path, double *throughput,
-                                 double *time)
+static int
+glusterfs_volume_top_perf(const char *brick_path, dict_t *dict,
+                          gf_boolean_t write_test)
 {
-        int32_t                 fd = -1;
-        int32_t                 input_fd = -1;
-        char                    export_path[PATH_MAX] = {0,};
-        char                    *buf = NULL;
-        int32_t                 iter = 0;
-        int32_t                 ret = -1;
-        uint64_t                total_blks = 0;
-        struct timeval          begin, end = {0,};
-
-        GF_ASSERT (brick_path);
-        GF_ASSERT (throughput);
-        GF_ASSERT (time);
-        if (!(blk_size > 0) || ! (blk_count > 0))
-                goto out;
-
-        snprintf (export_path, sizeof (export_path), "%s/%s",
-                  brick_path, ".gf-tmp-stats-perf");
-
-        fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU);
-        if (-1 == fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open tmp file");
-                goto out;
-        }
-
-        buf = GF_MALLOC (blk_size * sizeof(*buf), gf_common_mt_char);
-        if (!buf) {
-                ret = -1;
-                goto out;
-        }
-
-        input_fd = open ("/dev/zero", O_RDONLY);
-        if (-1 == input_fd) {
-                ret = -1;
-                gf_log ("glusterd",GF_LOG_ERROR, "Unable to open input file");
-                goto out;
-        }
-
-        gettimeofday (&begin, NULL);
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (input_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                total_blks += ret;
-        }
+    int32_t fd = -1;
+    int32_t output_fd = -1;
+    char export_path[PATH_MAX] = {
+        0,
+    };
+    char *buf = NULL;
+    int32_t iter = 0;
+    int32_t ret = -1;
+    uint64_t total_blks = 0;
+    uint32_t blk_size;
+    uint32_t blk_count;
+    double throughput = 0;
+    double time = 0;
+    struct timeval begin, end = {
+                              0,
+                          };
+
+    GF_ASSERT(brick_path);
+
+    ret = dict_get_uint32(dict, "blk-size", &blk_size);
+    if (ret)
+        goto out;
+    ret = dict_get_uint32(dict, "blk-cnt", &blk_count);
+    if (ret)
+        goto out;
+
+    if (!(blk_size > 0) || !(blk_count > 0))
+        goto out;
+
+    buf = GF_CALLOC(1, blk_size * sizeof(*buf), gf_common_mt_char);
+    if (!buf) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not allocate memory");
+        goto out;
+    }
+
+    snprintf(export_path, sizeof(export_path), "%s/%s", brick_path,
+             ".gf-tmp-stats-perf");
+    fd = open(export_path, O_CREAT | O_RDWR, S_IRWXU);
+    if (-1 == fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open tmp file");
+        goto out;
+    }
+
+    gettimeofday(&begin, NULL);
+    for (iter = 0; iter < blk_count; iter++) {
+        ret = sys_write(fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        total_blks += ret;
+    }
+    gettimeofday(&end, NULL);
+    if (total_blks != ((uint64_t)blk_size * blk_count)) {
+        gf_log("glusterd", GF_LOG_WARNING, "Error in write");
+        ret = -1;
+        goto out;
+    }
+
+    time = gf_tvdiff(&begin, &end);
+    throughput = total_blks / time;
+    gf_log("glusterd", GF_LOG_INFO,
+           "Throughput %.2f Mbps time %.2f secs "
+           "bytes written %" PRId64,
+           throughput, time, total_blks);
+
+    /* if it's a write test, we are done. Otherwise, we continue to the read
+     * part */
+    if (write_test == _gf_true) {
         ret = 0;
-        if (total_blks != ((uint64_t)blk_size * blk_count)) {
-                gf_log ("glusterd", GF_LOG_WARNING, "Error in write");
-                ret = -1;
-                goto out;
-        }
-
-        gettimeofday (&end, NULL);
-        *time = (end.tv_sec - begin.tv_sec) * 1e6
-                     + (end.tv_usec - begin.tv_usec);
-        *throughput = total_blks / *time;
-        gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs "
-                "bytes written %"PRId64, *throughput, *time, total_blks);
+        goto out;
+    }
+
+    ret = sys_fsync(fd);
+    if (ret) {
+        gf_log("glusterd", GF_LOG_ERROR, "could not flush cache");
+        goto out;
+    }
+    ret = sys_lseek(fd, 0L, 0);
+    if (ret != 0) {
+        gf_log("glusterd", GF_LOG_ERROR, "could not seek back to start");
+        ret = -1;
+        goto out;
+    }
 
+    output_fd = open("/dev/null", O_RDWR);
+    if (-1 == output_fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open output file");
+        goto out;
+    }
+
+    total_blks = 0;
+
+    gettimeofday(&begin, NULL);
+    for (iter = 0; iter < blk_count; iter++) {
+        ret = sys_read(fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        ret = sys_write(output_fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        total_blks += ret;
+    }
+    gettimeofday(&end, NULL);
+    if (total_blks != ((uint64_t)blk_size * blk_count)) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_WARNING, "Error in read");
+        goto out;
+    }
+
+    time = gf_tvdiff(&begin, &end);
+    throughput = total_blks / time;
+    gf_log("glusterd", GF_LOG_INFO,
+           "Throughput %.2f Mbps time %.2f secs "
+           "bytes read %" PRId64,
+           throughput, time, total_blks);
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
-        if (input_fd >= 0)
-                sys_close (input_fd);
-        GF_FREE (buf);
-        sys_unlink (export_path);
-
-        return ret;
+    if (fd >= 0)
+        sys_close(fd);
+    if (output_fd >= 0)
+        sys_close(output_fd);
+    GF_FREE(buf);
+    sys_unlink(export_path);
+    if (ret == 0) {
+        ret = dict_set_double(dict, "time", time);
+        if (ret)
+            goto end;
+        ret = dict_set_double(dict, "throughput", throughput);
+        if (ret)
+            goto end;
+    }
+end:
+    return ret;
 }
 
 int
-glusterfs_volume_top_read_perf (uint32_t blk_size, uint32_t blk_count,
-                                char *brick_path, double *throughput,
-                                double *time)
+glusterfs_handle_translator_op(rpcsvc_request_t *req)
 {
-        int32_t                 fd = -1;
-        int32_t                 input_fd = -1;
-        int32_t                 output_fd = -1;
-        char                    export_path[PATH_MAX] = {0,};
-        char                    *buf = NULL;
-        int32_t                 iter = 0;
-        int32_t                 ret = -1;
-        uint64_t                total_blks = 0;
-        struct timeval          begin, end = {0,};
-
-        GF_ASSERT (brick_path);
-        GF_ASSERT (throughput);
-        GF_ASSERT (time);
-        if (!(blk_size > 0) || ! (blk_count > 0))
-                goto out;
-
-        snprintf (export_path, sizeof (export_path), "%s/%s",
-                  brick_path, ".gf-tmp-stats-perf");
-        fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU);
-        if (-1 == fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open tmp file");
-                goto out;
-        }
-
-        buf = GF_MALLOC (blk_size * sizeof(*buf), gf_common_mt_char);
-        if (!buf) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not allocate memory");
-                goto out;
-        }
-
-        input_fd = open ("/dev/zero", O_RDONLY);
-        if (-1 == input_fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open input file");
-                goto out;
-        }
-
-        output_fd = open ("/dev/null", O_RDWR);
-        if (-1 == output_fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open output file");
-                goto out;
-        }
-
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (input_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    int32_t ret = -1;
+    int32_t op_ret = 0;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *input = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char key[32] = {0};
+    int len;
+    char *xname = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+    int i = 0;
+    int count = 0;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    active = ctx->active;
+    if (!active) {
+        ret = -1;
+        gf_smsg(this->name, GF_LOG_ERROR, EAGAIN, glusterfsd_msg_38,
+                "brick-op_no.=%d", xlator_req.op, NULL);
+        goto out;
+    }
+    any = active->first;
+    input = dict_new();
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &input);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    } else {
+        input->extra_stdfree = xlator_req.input.input_val;
+    }
+
+    ret = dict_get_int32(input, "count", &count);
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = sys_fsync (fd);
+    for (i = 0; i < count; i++) {
+        len = snprintf(key, sizeof(key), "xl-%d", i);
+        ret = dict_get_strn(input, key, len, &xname);
         if (ret) {
-                gf_log ("glusterd", GF_LOG_ERROR, "could not flush cache");
-                goto out;
-        }
-        ret = sys_lseek (fd, 0L, 0);
-        if (ret != 0) {
-                gf_log ("glusterd", GF_LOG_ERROR,
-                        "could not seek back to start");
-                ret = -1;
-                goto out;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Couldn't get "
+                   "xlator %s ",
+                   key);
+            goto out;
         }
-        gettimeofday (&begin, NULL);
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (output_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                total_blks += ret;
-        }
-        ret = 0;
-        if (total_blks != ((uint64_t)blk_size * blk_count)) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_WARNING, "Error in read");
-                goto out;
-        }
-
-        gettimeofday (&end, NULL);
-        *time = (end.tv_sec - begin.tv_sec) * 1e6
-                + (end.tv_usec - begin.tv_usec);
-        *throughput = total_blks / *time;
-        gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs "
-                "bytes read %"PRId64, *throughput, *time, total_blks);
-
+        xlator = xlator_search_by_name(any, xname);
+        if (!xlator) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "xlator %s is not "
+                   "loaded",
+                   xname);
+            goto out;
+        }
+    }
+    for (i = 0; i < count; i++) {
+        len = snprintf(key, sizeof(key), "xl-%d", i);
+        ret = dict_get_strn(input, key, len, &xname);
+        xlator = xlator_search_by_name(any, xname);
+        XLATOR_NOTIFY(ret, xlator, GF_EVENT_TRANSLATOR_OP, input, output);
+        /* If notify fails for an xlator we need to capture it but
+         * continue with the loop. */
+        if (ret)
+            op_ret = -1;
+    }
+    ret = op_ret;
 out:
-        if (fd >= 0)
-                sys_close (fd);
-        if (input_fd >= 0)
-                sys_close (input_fd);
-        if (output_fd >= 0)
-                sys_close (output_fd);
-        GF_FREE (buf);
-        sys_unlink (export_path);
-
-        return ret;
+    glusterfs_xlator_op_response_send(req, ret, "", output);
+    if (input)
+        dict_unref(input);
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return 0;
 }
 
 int
-glusterfs_handle_translator_op (rpcsvc_request_t *req)
+glusterfs_handle_bitrot(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        int32_t                  op_ret  = 0;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *input    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     key[2048] = {0};
-        char                    *xname = NULL;
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-        int                      i = 0;
-        int                      count = 0;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        active = ctx->active;
-        any = active->first;
-        input = dict_new ();
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &input);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        } else {
-                input->extra_stdfree = xlator_req.input.input_val;
-        }
-
-        ret = dict_get_int32 (input, "count", &count);
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *input = NULL;
+    dict_t *output = NULL;
+    xlator_t *any = NULL;
+    xlator_t *this = NULL;
+    xlator_t *xlator = NULL;
+    char msg[2048] = {
+        0,
+    };
+    char xname[1024] = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    char *scrub_opt = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+
+    input = dict_new();
+    if (!input)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &input);
+
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_35, NULL);
+        goto out;
+    }
+
+    /* Send scrubber request to bitrot xlator */
+    snprintf(xname, sizeof(xname), "%s-bit-rot-0", xlator_req.name);
+    xlator = xlator_search_by_name(any, xname);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xname);
+        gf_smsg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_36, NULL);
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0; i < count; i++)  {
-                snprintf (key, sizeof (key), "xl-%d", i);
-                ret = dict_get_str (input, key, &xname);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "Couldn't get "
-                                "xlator %s ", key);
-                        goto out;
-                }
-                xlator = xlator_search_by_name (any, xname);
-                if (!xlator) {
-                        gf_log (this->name, GF_LOG_ERROR, "xlator %s is not "
-                                "loaded", xname);
-                        goto out;
-                }
-        }
-        for (i = 0; i < count; i++)  {
-                snprintf (key, sizeof (key), "xl-%d", i);
-                ret = dict_get_str (input, key, &xname);
-                xlator = xlator_search_by_name (any, xname);
-                XLATOR_NOTIFY (xlator, GF_EVENT_TRANSLATOR_OP, input, output);
-                /* If notify fails for an xlator we need to capture it but
-                 * continue with the loop. */
-                if (ret)
-                        op_ret = -1;
-        }
-        ret = op_ret;
+    ret = dict_get_str(input, "scrub-value", &scrub_opt);
+    if (ret) {
+        snprintf(msg, sizeof(msg), "Failed to get scrub value");
+        gf_smsg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_37, NULL);
+        ret = -1;
+        goto out;
+    }
+
+    if (!strncmp(scrub_opt, "status", SLEN("status"))) {
+        ret = xlator->notify(xlator, GF_EVENT_SCRUB_STATUS, input, output);
+    } else if (!strncmp(scrub_opt, "ondemand", SLEN("ondemand"))) {
+        ret = xlator->notify(xlator, GF_EVENT_SCRUB_ONDEMAND, input, output);
+        if (ret == -2) {
+            snprintf(msg, sizeof(msg),
+                     "Scrubber is in "
+                     "Pause/Inactive/Running state");
+            ret = -1;
+            goto out;
+        }
+    }
 out:
-        glusterfs_xlator_op_response_send (req, ret, "", output);
-        if (input)
-                dict_unref (input);
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
-
-        return 0;
+    glusterfs_translator_info_response_send(req, ret, msg, output);
+
+    if (input)
+        dict_unref(input);
+    free(xlator_req.input.input_val); /*malloced by xdr*/
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);
+
+    return 0;
 }
 
 int
-glusterfs_handle_bitrot (rpcsvc_request_t *req)
+glusterfs_handle_attach(rpcsvc_request_t *req)
 {
-        int32_t                  ret          = -1;
-        gd1_mgmt_brick_op_req    xlator_req   = {0,};
-        dict_t                   *input       = NULL;
-        dict_t                   *output      = NULL;
-        xlator_t                 *any         = NULL;
-        xlator_t                 *this        = NULL;
-        xlator_t                 *xlator      = NULL;
-        char                     msg[2048]    = {0,};
-        char                     xname[1024]  = {0,};
-        glusterfs_ctx_t          *ctx         = NULL;
-        glusterfs_graph_t        *active      = NULL;
-        char                     *scrub_opt   = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-
-        if (ret < 0) {
-                /*failed to decode msg;*/
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    xlator_t *this = NULL;
+    xlator_t *nextchild = NULL;
+    glusterfs_graph_t *newgraph = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *srv_xl = NULL;
+    server_conf_t *srv_conf = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = this->ctx;
+    if (!ctx->cmd_args.volfile_id) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "No volfile-id provided, erroring out");
+        return -1;
+    }
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ret = 0;
+
+    if (!this->ctx->active) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "got attach for %s but no active graph", xlator_req.name);
+        goto post_unlock;
+    }
+
+    gf_log(this->name, GF_LOG_INFO, "got attach for %s", xlator_req.name);
+
+    LOCK(&ctx->volfile_lock);
+    {
+        ret = glusterfs_graph_attach(this->ctx->active, xlator_req.name,
+                                     &newgraph);
+        if (!ret && (newgraph && newgraph->first)) {
+            nextchild = newgraph->first;
+            ret = xlator_notify(nextchild, GF_EVENT_PARENT_UP, nextchild);
+            if (ret) {
+                gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+                        "event=ParentUp", "name=%s", nextchild->name, NULL);
+                goto unlock;
+            }
+            /* we need a protocol/server xlator as
+             * nextchild
+             */
+            srv_xl = this->ctx->active->first;
+            srv_conf = (server_conf_t *)srv_xl->private;
+            rpcsvc_autoscale_threads(this->ctx, srv_conf->rpc, 1);
         }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        any = active->first;
-
-        input = dict_new ();
-        if (!input)
-                goto out;
-
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &input);
-
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_35);
-                goto out;
-        }
-
-        /* Send scrubber request to bitrot xlator */
-        snprintf (xname, sizeof (xname), "%s-bit-rot-0", xlator_req.name);
-        xlator = xlator_search_by_name (any, xname);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded", xname);
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_36);
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_get_str (input, "scrub-value", &scrub_opt);
         if (ret) {
-                snprintf (msg, sizeof (msg), "Failed to get scrub value");
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_37);
-                ret = -1;
-                goto out;
+            ret = -1;
         }
+        ret = glusterfs_translator_info_response_send(req, ret, NULL, NULL);
+        if (ret) {
+            /* Response sent back to glusterd, req is already destroyed. So
+             * resetting the ret to 0. Otherwise another response will be
+             * send from rpcsvc_check_and_reply_error. Which will lead to
+             * double resource leak.
+             */
+            ret = 0;
+        }
+    unlock:
+        UNLOCK(&ctx->volfile_lock);
+    }
+post_unlock:
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    free(xlator_req.input.input_val);
+    free(xlator_req.name);
+
+    return ret;
+}
 
-        if (!strncmp (scrub_opt, "status", strlen ("status"))) {
-                ret = xlator->notify (xlator, GF_EVENT_SCRUB_STATUS, input,
-                                      output);
-        } else if (!strncmp (scrub_opt, "ondemand", strlen ("ondemand"))) {
-                ret = xlator->notify (xlator, GF_EVENT_SCRUB_ONDEMAND, input,
-                                      output);
-                if (ret == -2) {
-                        snprintf (msg, sizeof (msg), "Scrubber is in "
-                                  "Pause/Inactive/Running state");
-                        ret = -1;
-                        goto out;
-                }
-        }
+int
+glusterfs_handle_svc_attach(rpcsvc_request_t *req)
+{
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    xlator_t *this = NULL;
+    dict_t *dict = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    gf_smsg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_41, "volfile-id=%s",
+            xlator_req.name, NULL);
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(xlator_req.dict.dict_val, xlator_req.dict.dict_len,
+                           &dict);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_WARNING, EINVAL, glusterfsd_msg_42, NULL);
+        goto out;
+    }
+    dict->extra_stdfree = xlator_req.dict.dict_val;
+
+    ret = 0;
+
+    ret = mgmt_process_volfile(xlator_req.input.input_val,
+                               xlator_req.input.input_len, xlator_req.name,
+                               dict);
 out:
-        glusterfs_translator_info_response_send (req, ret, msg, output);
-
-        if (input)
-                dict_unref (input);
-        free (xlator_req.input.input_val); /*malloced by xdr*/
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name);
-
-        return 0;
+    if (dict)
+        dict_unref(dict);
+    if (xlator_req.input.input_val)
+        free(xlator_req.input.input_val);
+    if (xlator_req.name)
+        free(xlator_req.name);
+    glusterfs_translator_info_response_send(req, ret, NULL, NULL);
+    return 0;
 }
 
 int
-glusterfs_handle_attach (rpcsvc_request_t *req)
+glusterfs_handle_svc_detach(rpcsvc_request_t *req)
 {
-        int32_t                 ret             = -1;
-        gd1_mgmt_brick_op_req   xlator_req      = {0,};
-        xlator_t                *this           = NULL;
-        xlator_t                *nextchild      = NULL;
-        glusterfs_graph_t       *newgraph       = NULL;
-        glusterfs_ctx_t         *ctx            = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-
-        if (ret < 0) {
-                /*failed to decode msg;*/
-                req->rpc_err = GARBAGE_ARGS;
-                return -1;
-        }
-        ret = 0;
-        ctx = this->ctx;
-
-        LOCK (&ctx->volfile_lock);
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    ssize_t ret;
+    gf_volfile_t *volfile_obj = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_volfile_t *volfile_tmp = NULL;
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ctx = glusterfsd_ctx;
+
+    LOCK(&ctx->volfile_lock);
+    {
+        list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list)
         {
-                if (this->ctx->active) {
-                        gf_log (this->name, GF_LOG_INFO,
-                                "got attach for %s", xlator_req.name);
-                        ret = glusterfs_graph_attach (this->ctx->active,
-                                              xlator_req.name, &newgraph);
-                        if (!ret && (newgraph && newgraph->first)) {
-                                nextchild = newgraph->first;
-                                ret = xlator_notify (nextchild,
-                                                     GF_EVENT_PARENT_UP,
-                                                     nextchild);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                0,
-                                                LG_MSG_EVENT_NOTIFY_FAILED,
-                                                "Parent up notification "
-                                                "failed for %s ",
-                                                nextchild->name);
-                                        goto out;
-                                }
-                                glusterfs_autoscale_threads (this->ctx, 1);
-                        }
-                } else {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "got attach for %s but no active graph",
-                                xlator_req.name);
-                }
-
-                glusterfs_translator_info_response_send (req, ret, NULL, NULL);
-
-out:
-                UNLOCK (&ctx->volfile_lock);
+            if (!strcmp(xlator_req.name, volfile_obj->vol_id)) {
+                volfile_tmp = volfile_obj;
+                break;
+            }
+        }
+
+        if (!volfile_tmp) {
+            UNLOCK(&ctx->volfile_lock);
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0, glusterfsd_msg_041, "name=%s",
+                    xlator_req.name, NULL);
+            /*
+             * Used to be -ENOENT.  However, the caller asked us to
+             * make sure it's down and if it's already down that's
+             * good enough.
+             */
+            ret = 0;
+            goto out;
+        }
+        /* coverity[ORDER_REVERSAL] */
+        ret = glusterfs_process_svc_detach(ctx, volfile_tmp);
+        if (ret) {
+            UNLOCK(&ctx->volfile_lock);
+            gf_smsg("glusterfsd-mgmt", GF_LOG_ERROR, EINVAL, glusterfsd_msg_042,
+                    NULL);
+            goto out;
         }
-        free (xlator_req.input.input_val);
-        free (xlator_req.name);
+    }
+    UNLOCK(&ctx->volfile_lock);
+out:
+    glusterfs_terminate_response_send(req, ret);
+    free(xlator_req.name);
+    xlator_req.name = NULL;
 
-        return ret;
+    return 0;
 }
 
 int
-glusterfs_handle_defrag (rpcsvc_request_t *req)
+glusterfs_handle_dump_metrics(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *dict    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     msg[2048] = {0};
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        any = active->first;
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
-        xlator = xlator_search_by_name (any, xlator_req.name);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = xlator->notify (xlator, GF_EVENT_VOLUME_DEFRAG, dict, output);
-
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char *filepath = NULL;
+    int fd = -1;
+    struct stat statbuf = {
+        0,
+    };
+    char *msg = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ret = -1;
+    ctx = this->ctx;
+
+    /* Infra for monitoring */
+    filepath = gf_monitor_metrics(ctx);
+    if (!filepath)
+        goto out;
+
+    fd = sys_open(filepath, O_RDONLY, 0);
+    if (fd < 0)
+        goto out;
+
+    if (sys_fstat(fd, &statbuf) < 0)
+        goto out;
+
+    if (statbuf.st_size > GF_UNIT_MB) {
+        gf_smsg(this->name, GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+                "reconsider logic (%" PRId64 ")", statbuf.st_size, NULL);
+    }
+    msg = GF_CALLOC(1, (statbuf.st_size + 1), gf_common_mt_char);
+    if (!msg)
+        goto out;
+
+    ret = sys_read(fd, msg, statbuf.st_size);
+    if (ret < 0)
+        goto out;
+
+    /* Send all the data in errstr, instead of dictionary for now */
+    glusterfs_translator_info_response_send(req, 0, msg, NULL);
+
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
-        free (xlator_req.input.input_val); // malloced by xdr
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
+    if (fd >= 0)
+        sys_close(fd);
 
-        return ret;
+    GF_FREE(msg);
+    GF_FREE(filepath);
+    if (xlator_req.input.input_val)
+        free(xlator_req.input.input_val);
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
 
+    return ret;
 }
+
 int
-glusterfs_handle_brick_status (rpcsvc_request_t *req)
+glusterfs_handle_defrag(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   brick_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *this = NULL;
-        xlator_t                *any = NULL;
-        xlator_t                *xlator = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *output = NULL;
-        char                    *volname = NULL;
-        char                    *xname = NULL;
-        uint32_t                cmd = 0;
-        char                    *msg = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &brick_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (brick_req.input.input_val,
-                                brick_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "req-buffer to dictionary");
-                goto out;
-        }
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Couldn't get status op");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        any = active->first;
-
-        ret = gf_asprintf (&xname, "%s-server", volname);
-        if (-1 == ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Out of memory");
-                goto out;
-        }
-
-        xlator = xlator_search_by_name (any, xname);
-        if (!xlator) {
-                gf_log (this->name, GF_LOG_ERROR, "xlator %s is not loaded",
-                        xname);
-                ret = -1;
-                goto out;
-        }
-
-
-        output = dict_new ();
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        ret = 0;
-                        gf_proc_dump_mem_info_to_dict (output);
-                        gf_proc_dump_mempool_info_to_dict (ctx, output);
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                        ret = xlator->dumpops->priv_to_dict (xlator, output);
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        ret = xlator->dumpops->inode_to_dict (xlator, output);
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        ret = xlator->dumpops->fd_to_dict (xlator, output);
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        ret = 0;
-                        gf_proc_dump_pending_frames_to_dict (ctx->pool, output);
-                        break;
-
-                default:
-                        ret = -1;
-                        msg = gf_strdup ("Unknown status op");
-                        break;
-        }
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg)
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char msg[2048] = {0};
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+    xlator = xlator_search_by_name(any, xlator_req.name);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    ret = xlator->notify(xlator, GF_EVENT_VOLUME_DEFRAG, dict, output);
 
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
 out:
-        if (dict)
-                dict_unref (dict);
-        if (output)
-                dict_unref (output);
-        free (brick_req.input.input_val);
-        GF_FREE (xname);
-        GF_FREE (msg);
-        GF_FREE (rsp.output.output_val);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(xlator_req.input.input_val);  // malloced by xdr
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return ret;
 }
-
-
 int
-glusterfs_handle_node_status (rpcsvc_request_t *req)
+glusterfs_handle_brick_status(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   node_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *any = NULL;
-        xlator_t                *node = NULL;
-        xlator_t                *subvol = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *output = NULL;
-        char                    *volname = NULL;
-        char                    *node_name = NULL;
-        char                    *subvol_name = NULL;
-        uint32_t                cmd = 0;
-        char                    *msg = NULL;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic (req->msg[0], &node_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (node_req.input.input_val,
-                                node_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "req buffer to dictionary");
-                goto out;
-        }
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get status op");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        any = active->first;
-
-        if ((cmd & GF_CLI_STATUS_NFS) != 0)
-                ret = gf_asprintf (&node_name, "%s", "nfs-server");
-        else if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "glustershd");
-        else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "quotad");
-        else if ((cmd & GF_CLI_STATUS_BITD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "bitd");
-        else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
-                ret = gf_asprintf (&node_name, "%s", "scrubber");
-
-        else {
-                ret = -1;
-                goto out;
-        }
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to set node xlator name");
-                goto out;
-        }
-
-        node = xlator_search_by_name (any, node_name);
-        if (!node) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        node_name);
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req brick_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+    xlator_t *server_xl = NULL;
+    xlator_t *brick_xl = NULL;
+    dict_t *dict = NULL;
+    dict_t *output = NULL;
+    uint32_t cmd = 0;
+    char *msg = NULL;
+    char *brickname = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &brick_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(brick_req.input.input_val, brick_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "req-buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Couldn't get status op");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "brick-name", &brickname);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Couldn't get brickname from"
+               " dict");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    if (ctx == NULL) {
+        gf_log(this->name, GF_LOG_ERROR, "ctx returned NULL");
+        ret = -1;
+        goto out;
+    }
+    if (ctx->active == NULL) {
+        gf_log(this->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    active = ctx->active;
+    if (ctx->active->first == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "ctx->active->first "
+               "returned NULL");
+        ret = -1;
+        goto out;
+    }
+    server_xl = active->first;
 
-        if ((cmd & GF_CLI_STATUS_NFS) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s-replicate-0", volname);
-        else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_BITD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else {
-                ret = -1;
-                goto out;
-        }
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to set node xlator name");
-                goto out;
-        }
+    brick_xl = get_xlator_by_name(server_xl, brickname);
+    if (!brick_xl) {
+        gf_log(this->name, GF_LOG_ERROR, "xlator is not loaded");
+        ret = -1;
+        goto out;
+    }
+
+    output = dict_new();
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            ret = 0;
+            gf_proc_dump_mem_info_to_dict(output);
+            gf_proc_dump_mempool_info_to_dict(ctx, output);
+            break;
+
+        case GF_CLI_STATUS_CLIENTS:
+        case GF_CLI_STATUS_CLIENT_LIST:
+            ret = server_xl->dumpops->priv_to_dict(server_xl, output,
+                                                   brickname);
+            break;
+
+        case GF_CLI_STATUS_INODE:
+            ret = server_xl->dumpops->inode_to_dict(brick_xl, output);
+            break;
+
+        case GF_CLI_STATUS_FD:
+            ret = server_xl->dumpops->fd_to_dict(brick_xl, output);
+            break;
+
+        case GF_CLI_STATUS_CALLPOOL:
+            ret = 0;
+            gf_proc_dump_pending_frames_to_dict(ctx->pool, output);
+            break;
 
-        subvol = xlator_search_by_name (node, subvol_name);
-        if (!subvol) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        subvol_name);
-                goto out;
-        }
+        default:
+            ret = -1;
+            msg = gf_strdup("Unknown status op");
+            break;
+    }
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg)
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        output = dict_new ();
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        ret = 0;
-                        gf_proc_dump_mem_info_to_dict (output);
-                        gf_proc_dump_mempool_info_to_dict (ctx, output);
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                        // clients not availbale for SHD
-                        if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                                break;
-
-                        ret = dict_set_str (output, "volname", volname);
-                        if (ret) {
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Error setting volname to dict");
-                                goto out;
-                        }
-                        ret = node->dumpops->priv_to_dict (node, output);
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        ret = 0;
-                        inode_table_dump_to_dict (subvol->itable, "conn0",
-                                                  output);
-                        ret = dict_set_int32 (output, "conncount", 1);
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        // cannot find fd-tables in nfs-server graph
-                        // TODO: finish once found
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        ret = 0;
-                        gf_proc_dump_pending_frames_to_dict (ctx->pool, output);
-                        break;
-
-                default:
-                        ret = -1;
-                        msg = gf_strdup ("Unknown status op");
-                        gf_log (THIS->name, GF_LOG_ERROR, "%s", msg);
-                        break;
-        }
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg)
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (node_req.input.input_val);
-        GF_FREE (msg);
-        GF_FREE (rsp.output.output_val);
-        GF_FREE (node_name);
-        GF_FREE (subvol_name);
-
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    if (output)
+        dict_unref(output);
+    free(brick_req.input.input_val);
+    if (brick_req.dict.dict_val)
+        free(brick_req.dict.dict_val);
+    free(brick_req.name);
+    GF_FREE(msg);
+    GF_FREE(rsp.output.output_val);
+
+    return ret;
 }
 
 int
-glusterfs_handle_nfs_profile (rpcsvc_request_t *req)
+glusterfs_handle_node_status(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   nfs_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        dict_t                  *dict = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *any = NULL;
-        xlator_t                *nfs = NULL;
-        xlator_t                *subvol = NULL;
-        char                    *volname = NULL;
-        dict_t                  *output = NULL;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic (req->msg[0], &nfs_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req node_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *any = NULL;
+    xlator_t *node = NULL;
+    xlator_t *subvol = NULL;
+    dict_t *dict = NULL;
+    dict_t *output = NULL;
+    char *volname = NULL;
+    char *node_name = NULL;
+    char *subvol_name = NULL;
+    uint32_t cmd = 0;
+    char *msg = NULL;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &node_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(node_req.input.input_val, node_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "req buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get status op");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get volname");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    if (active == NULL) {
+        gf_log(THIS->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    any = active->first;
+
+    if ((cmd & GF_CLI_STATUS_SHD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "glustershd");
+#ifdef BUILD_GNFS
+    else if ((cmd & GF_CLI_STATUS_NFS) != 0)
+        ret = gf_asprintf(&node_name, "%s", "nfs-server");
+#endif
+    else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "quotad");
+    else if ((cmd & GF_CLI_STATUS_BITD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "bitd");
+    else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
+        ret = gf_asprintf(&node_name, "%s", "scrubber");
+
+    else {
+        ret = -1;
+        goto out;
+    }
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to set node xlator name");
+        goto out;
+    }
+
+    node = xlator_search_by_name(any, node_name);
+    if (!node) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded", node_name);
+        goto out;
+    }
+
+    if ((cmd & GF_CLI_STATUS_NFS) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_SHD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s-replicate-0", volname);
+    else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_BITD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else {
+        ret = -1;
+        goto out;
+    }
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to set node xlator name");
+        goto out;
+    }
+
+    subvol = xlator_search_by_name(node, subvol_name);
+    if (!subvol) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               subvol_name);
+        goto out;
+    }
+
+    output = dict_new();
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            ret = 0;
+            gf_proc_dump_mem_info_to_dict(output);
+            gf_proc_dump_mempool_info_to_dict(ctx, output);
+            break;
+
+        case GF_CLI_STATUS_CLIENTS:
+            // clients not available for SHD
+            if ((cmd & GF_CLI_STATUS_SHD) != 0)
+                break;
 
-        dict = dict_new ();
-        ret = dict_unserialize (nfs_req.input.input_val,
-                                nfs_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to "
-                        "unserialize req-buffer to dict");
+            ret = dict_set_str(output, "volname", volname);
+            if (ret) {
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Error setting volname to dict");
                 goto out;
-        }
+            }
+            ret = node->dumpops->priv_to_dict(node, output, NULL);
+            break;
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        any = active->first;
-
-        // is this needed?
-        // are problems possible by searching for subvol directly from "any"?
-        nfs = xlator_search_by_name (any, "nfs-server");
-        if (!nfs) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "xlator nfs-server is "
-                        "not loaded");
-                goto out;
-        }
+        case GF_CLI_STATUS_INODE:
+            ret = 0;
+            inode_table_dump_to_dict(subvol->itable, "conn0", output);
+            ret = dict_set_int32(output, "conncount", 1);
+            break;
 
-        subvol = xlator_search_by_name (nfs, volname);
-        if (!subvol) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "xlator %s is no loaded",
-                        volname);
-                goto out;
-        }
+        case GF_CLI_STATUS_FD:
+            // cannot find fd-tables in nfs-server graph
+            // TODO: finish once found
+            break;
 
-        output = dict_new ();
-        ret = subvol->notify (subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
+        case GF_CLI_STATUS_CALLPOOL:
+            ret = 0;
+            gf_proc_dump_pending_frames_to_dict(ctx->pool, output);
+            break;
 
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
+        default:
+            ret = -1;
+            msg = gf_strdup("Unknown status op");
+            gf_log(THIS->name, GF_LOG_ERROR, "%s", msg);
+            break;
+    }
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg)
+        rsp.op_errstr = msg;
+    else
         rsp.op_errstr = "";
 
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
 out:
-        free (nfs_req.input.input_val);
-        if (dict)
-                dict_unref (dict);
-        if (output)
-                dict_unref (output);
-        GF_FREE (rsp.output.output_val);
-
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(node_req.input.input_val);
+    if (node_req.dict.dict_val)
+        free(node_req.dict.dict_val);
+    GF_FREE(msg);
+    GF_FREE(rsp.output.output_val);
+    GF_FREE(node_name);
+    GF_FREE(subvol_name);
+
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_volume_barrier_op (rpcsvc_request_t *req)
+glusterfs_handle_nfs_profile(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *dict    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     msg[2048] = {0};
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req nfs_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *any = NULL;
+    xlator_t *nfs = NULL;
+    xlator_t *subvol = NULL;
+    char *volname = NULL;
+    dict_t *output = NULL;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &nfs_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(nfs_req.input.input_val, nfs_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to "
+               "unserialize req-buffer to dict");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get volname");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (active == NULL) {
+        gf_log(THIS->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    any = active->first;
+
+    // is this needed?
+    // are problems possible by searching for subvol directly from "any"?
+    nfs = xlator_search_by_name(any, "nfs-server");
+    if (!nfs) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "xlator nfs-server is "
+               "not loaded");
+        goto out;
+    }
+
+    subvol = xlator_search_by_name(nfs, volname);
+    if (!subvol) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "xlator %s is no loaded", volname);
+        goto out;
+    }
 
-        any = active->first;
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    output = dict_new();
+    ret = subvol->notify(subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
 
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
-        xlator = xlator_search_by_name (any, xlator_req.name);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
-        }
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    rsp.op_errstr = "";
 
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        ret = xlator->notify (xlator, GF_EVENT_VOLUME_BARRIER_OP,
-                              dict, output);
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
 out:
-        if (dict)
-                dict_unref (dict);
-        free (xlator_req.input.input_val); // malloced by xdr
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
-
-        return ret;
-
+    free(nfs_req.input.input_val);
+    if (nfs_req.dict.dict_val)
+        free(nfs_req.dict.dict_val);
+    if (dict)
+        dict_unref(dict);
+    if (output)
+        dict_unref(output);
+    GF_FREE(rsp.output.output_val);
+
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_barrier (rpcsvc_request_t *req)
+glusterfs_handle_volume_barrier_op(rpcsvc_request_t *req)
 {
-        int                     ret         = -1;
-        gd1_mgmt_brick_op_req   brick_req   = {0,};
-        gd1_mgmt_brick_op_rsp   brick_rsp   = {0,};
-        glusterfs_ctx_t         *ctx        = NULL;
-        glusterfs_graph_t       *active     = NULL;
-        xlator_t                *top        = NULL;
-        xlator_t                *xlator     = NULL;
-        xlator_t                *old_THIS   = NULL;
-        dict_t                  *dict       = NULL;
-        gf_boolean_t            barrier     = _gf_true;
-        gf_boolean_t            barrier_err = _gf_false;
-        xlator_list_t           *trav;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic(req->msg[0], &brick_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        top = active->first;
-
-        for (trav = top->children; trav; trav = trav->next) {
-                if (strcmp (trav->xlator->name, brick_req.name) == 0) {
-                        break;
-                }
-        }
-        if (!trav) {
-                ret = -1;
-                goto out;
-        }
-        top = trav->xlator;
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char msg[2048] = {0};
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+    xlator = xlator_search_by_name(any, xlator_req.name);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = dict_new();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    ret = xlator->notify(xlator, GF_EVENT_VOLUME_BARRIER_OP, dict, output);
 
-        ret = dict_unserialize(brick_req.input.input_val,
-                               brick_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "request dictionary");
-                goto out;
-        }
-
-        brick_rsp.op_ret = 0;
-        brick_rsp.op_errstr = ""; // initing to prevent serilaztion failures
-        old_THIS = THIS;
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
+out:
+    if (dict)
+        dict_unref(dict);
+    free(xlator_req.input.input_val);  // malloced by xdr
+    if (xlator_req.dict.dict_val)
+        free(xlator_req.dict.dict_val);
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return ret;
+}
 
-        /* Send barrier request to the barrier xlator */
-        xlator = get_xlator_by_type (top, "features/barrier");
-        if (!xlator) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        "features/barrier");
-                goto out;
-        }
+int
+glusterfs_handle_barrier(rpcsvc_request_t *req)
+{
+    int ret = -1;
+    gd1_mgmt_brick_op_req brick_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp brick_rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *top = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *old_THIS = NULL;
+    dict_t *dict = NULL;
+    gf_boolean_t barrier = _gf_true;
+    xlator_list_t *trav;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &brick_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    if (active == NULL) {
+        gf_log(THIS->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    top = active->first;
 
-        THIS = xlator;
-        // TODO: Extend this to accept return of errnos
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_OP, dict);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "barrier notify failed");
-                brick_rsp.op_ret = ret;
-                brick_rsp.op_errstr = gf_strdup ("Failed to reconfigure "
-                                                 "barrier.");
-                /* This is to invoke changelog-barrier disable if barrier
-                 * disable fails and don't invoke if barrier enable fails.
-                 */
-                barrier = dict_get_str_boolean (dict, "barrier", _gf_true);
-                if (barrier)
-                        goto submit_reply;
-                else
-                        barrier_err = _gf_true;
+    for (trav = top->children; trav; trav = trav->next) {
+        if (strcmp(trav->xlator->name, brick_req.name) == 0) {
+            break;
         }
+    }
+    if (!trav) {
+        ret = -1;
+        goto out;
+    }
+    top = trav->xlator;
 
-        /* Reset THIS so that we have it correct in case of an error below
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(brick_req.input.input_val, brick_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "request dictionary");
+        goto out;
+    }
+
+    brick_rsp.op_ret = 0;
+    brick_rsp.op_errstr = "";  // initing to prevent serilaztion failures
+    old_THIS = THIS;
+
+    /* Send barrier request to the barrier xlator */
+    xlator = get_xlator_by_type(top, "features/barrier");
+    if (!xlator) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               "features/barrier");
+        goto out;
+    }
+
+    THIS = xlator;
+    // TODO: Extend this to accept return of errnos
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_OP, dict);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "barrier notify failed");
+        brick_rsp.op_ret = ret;
+        brick_rsp.op_errstr = gf_strdup(
+            "Failed to reconfigure "
+            "barrier.");
+        /* This is to invoke changelog-barrier disable if barrier
+         * disable fails and don't invoke if barrier enable fails.
          */
-        THIS = old_THIS;
-
-        /* Send barrier request to changelog as well */
-        xlator = get_xlator_by_type (top, "features/changelog");
-        if (!xlator) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        "features/changelog");
-                goto out;
-        }
-
-        THIS = xlator;
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_OP, dict);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "changelog notify failed");
-                brick_rsp.op_ret = ret;
-                brick_rsp.op_errstr = gf_strdup ("changelog notify failed");
-                goto submit_reply;
-        }
-
-        if (barrier_err)
-                ret = -1;
+        barrier = dict_get_str_boolean(dict, "barrier", _gf_true);
+        if (barrier)
+            goto submit_reply;
+    }
+
+    /* Reset THIS so that we have it correct in case of an error below
+     */
+    THIS = old_THIS;
+
+    /* Send barrier request to changelog as well */
+    xlator = get_xlator_by_type(top, "features/changelog");
+    if (!xlator) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               "features/changelog");
+        goto out;
+    }
+
+    THIS = xlator;
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_OP, dict);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "changelog notify failed");
+        brick_rsp.op_ret = ret;
+        brick_rsp.op_errstr = gf_strdup("changelog notify failed");
+        goto submit_reply;
+    }
 
 submit_reply:
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        ret = glusterfs_submit_reply (req, &brick_rsp, NULL, 0, NULL,
-                                      (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = glusterfs_submit_reply(req, &brick_rsp, NULL, 0, NULL,
+                                 (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (brick_req.input.input_val);
-
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(brick_req.input.input_val);
+    if (brick_req.dict.dict_val)
+        free(brick_req.dict.dict_val);
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_rpc_msg (rpcsvc_request_t *req)
+glusterfs_handle_rpc_msg(rpcsvc_request_t *req)
 {
-        int ret = -1;
-        /* for now, nothing */
-        return ret;
+    int ret = -1;
+    /* for now, nothing */
+    return ret;
 }
 
-rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
-        [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec },
-        [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
-                                 mgmt_cbk_event},
-        [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_event},
+static rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
+    [GF_CBK_FETCHSPEC] = {"FETCHSPEC", mgmt_cbk_spec, GF_CBK_FETCHSPEC},
+    [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", mgmt_cbk_event,
+                             GF_CBK_EVENT_NOTIFY},
+    [GF_CBK_STATEDUMP] = {"STATEDUMP", mgmt_cbk_event, GF_CBK_STATEDUMP},
 };
 
-
-struct rpcclnt_cb_program mgmt_cbk_prog = {
-        .progname  = "GlusterFS Callback",
-        .prognum   = GLUSTER_CBK_PROGRAM,
-        .progver   = GLUSTER_CBK_VERSION,
-        .actors    = mgmt_cbk_actors,
-        .numactors = GF_CBK_MAXVALUE,
+static struct rpcclnt_cb_program mgmt_cbk_prog = {
+    .progname = "GlusterFS Callback",
+    .prognum = GLUSTER_CBK_PROGRAM,
+    .progver = GLUSTER_CBK_VERSION,
+    .actors = mgmt_cbk_actors,
+    .numactors = GF_CBK_MAXVALUE,
 };
 
-char *clnt_pmap_procs[GF_PMAP_MAXVALUE] = {
-        [GF_PMAP_NULL]        = "NULL",
-        [GF_PMAP_PORTBYBRICK] = "PORTBYBRICK",
-        [GF_PMAP_BRICKBYPORT] = "BRICKBYPORT",
-        [GF_PMAP_SIGNIN]      = "SIGNIN",
-        [GF_PMAP_SIGNOUT]     = "SIGNOUT",
-        [GF_PMAP_SIGNUP]      = "SIGNUP",       /* DEPRECATED - DON'T USE! */
+static char *clnt_pmap_procs[GF_PMAP_MAXVALUE] = {
+    [GF_PMAP_NULL] = "NULL",
+    [GF_PMAP_PORTBYBRICK] = "PORTBYBRICK",
+    [GF_PMAP_BRICKBYPORT] = "BRICKBYPORT",
+    [GF_PMAP_SIGNIN] = "SIGNIN",
+    [GF_PMAP_SIGNOUT] = "SIGNOUT",
+    [GF_PMAP_SIGNUP] = "SIGNUP", /* DEPRECATED - DON'T USE! */
 };
 
-
-rpc_clnt_prog_t clnt_pmap_prog = {
-        .progname  = "Gluster Portmap",
-        .prognum   = GLUSTER_PMAP_PROGRAM,
-        .progver   = GLUSTER_PMAP_VERSION,
-        .procnames = clnt_pmap_procs,
+static rpc_clnt_prog_t clnt_pmap_prog = {
+    .progname = "Gluster Portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
+    .procnames = clnt_pmap_procs,
 };
 
-char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
-        [GF_HNDSK_NULL]         = "NULL",
-        [GF_HNDSK_SETVOLUME]    = "SETVOLUME",
-        [GF_HNDSK_GETSPEC]      = "GETSPEC",
-        [GF_HNDSK_PING]         = "PING",
-        [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
+static char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
+    [GF_HNDSK_NULL] = "NULL",
+    [GF_HNDSK_SETVOLUME] = "SETVOLUME",
+    [GF_HNDSK_GETSPEC] = "GETSPEC",
+    [GF_HNDSK_PING] = "PING",
+    [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
 };
 
-rpc_clnt_prog_t clnt_handshake_prog = {
-        .progname  = "GlusterFS Handshake",
-        .prognum   = GLUSTER_HNDSK_PROGRAM,
-        .progver   = GLUSTER_HNDSK_VERSION,
-        .procnames = clnt_handshake_procs,
+static rpc_clnt_prog_t clnt_handshake_prog = {
+    .progname = "GlusterFS Handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
+    .procnames = clnt_handshake_procs,
 };
 
-rpcsvc_actor_t glusterfs_actors[GLUSTERD_BRICK_MAXVALUE] = {
-        [GLUSTERD_BRICK_NULL]          = {"NULL",
-                                          GLUSTERD_BRICK_NULL,
-                                          glusterfs_handle_rpc_msg,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_TERMINATE]     = {"TERMINATE",
-                                          GLUSTERD_BRICK_TERMINATE,
-                                          glusterfs_handle_terminate,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_INFO]   = {"TRANSLATOR INFO",
-                                          GLUSTERD_BRICK_XLATOR_INFO,
-                                          glusterfs_handle_translator_info_get,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_OP]     = {"TRANSLATOR OP",
-                                          GLUSTERD_BRICK_XLATOR_OP,
-                                          glusterfs_handle_translator_op,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_STATUS]        = {"STATUS",
-                                          GLUSTERD_BRICK_STATUS,
-                                          glusterfs_handle_brick_status,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_DEFRAG] = {"TRANSLATOR DEFRAG",
-                                          GLUSTERD_BRICK_XLATOR_DEFRAG,
-                                          glusterfs_handle_defrag,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_PROFILE]        = {"NFS PROFILE",
-                                          GLUSTERD_NODE_PROFILE,
-                                          glusterfs_handle_nfs_profile,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_STATUS]         = {"NFS STATUS",
-                                          GLUSTERD_NODE_STATUS,
-                                          glusterfs_handle_node_status,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_VOLUME_BARRIER_OP]   = {"VOLUME BARRIER OP",
-                                          GLUSTERD_VOLUME_BARRIER_OP,
-                                          glusterfs_handle_volume_barrier_op,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_BARRIER]       = {"BARRIER",
-                                          GLUSTERD_BRICK_BARRIER,
-                                          glusterfs_handle_barrier,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_BITROT]         = {"BITROT",
-                                          GLUSTERD_NODE_BITROT,
-                                          glusterfs_handle_bitrot,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_ATTACH]        = {"ATTACH",
-                                          GLUSTERD_BRICK_ATTACH,
-                                          glusterfs_handle_attach,
-                                          NULL, 0, DRC_NA},
+static rpcsvc_actor_t glusterfs_actors[GLUSTERD_BRICK_MAXVALUE] = {
+    [GLUSTERD_BRICK_NULL] = {"NULL", glusterfs_handle_rpc_msg, NULL,
+                             GLUSTERD_BRICK_NULL, DRC_NA, 0},
+    [GLUSTERD_BRICK_TERMINATE] = {"TERMINATE", glusterfs_handle_terminate, NULL,
+                                  GLUSTERD_BRICK_TERMINATE, DRC_NA, 0},
+    [GLUSTERD_BRICK_XLATOR_INFO] = {"TRANSLATOR INFO",
+                                    glusterfs_handle_translator_info_get, NULL,
+                                    GLUSTERD_BRICK_XLATOR_INFO, DRC_NA, 0},
+    [GLUSTERD_BRICK_XLATOR_OP] = {"TRANSLATOR OP",
+                                  glusterfs_handle_translator_op, NULL,
+                                  GLUSTERD_BRICK_XLATOR_OP, DRC_NA, 0},
+    [GLUSTERD_BRICK_STATUS] = {"STATUS", glusterfs_handle_brick_status, NULL,
+                               GLUSTERD_BRICK_STATUS, DRC_NA, 0},
+    [GLUSTERD_BRICK_XLATOR_DEFRAG] = {"TRANSLATOR DEFRAG",
+                                      glusterfs_handle_defrag, NULL,
+                                      GLUSTERD_BRICK_XLATOR_DEFRAG, DRC_NA, 0},
+    [GLUSTERD_NODE_PROFILE] = {"NFS PROFILE", glusterfs_handle_nfs_profile,
+                               NULL, GLUSTERD_NODE_PROFILE, DRC_NA, 0},
+    [GLUSTERD_NODE_STATUS] = {"NFS STATUS", glusterfs_handle_node_status, NULL,
+                              GLUSTERD_NODE_STATUS, DRC_NA, 0},
+    [GLUSTERD_VOLUME_BARRIER_OP] = {"VOLUME BARRIER OP",
+                                    glusterfs_handle_volume_barrier_op, NULL,
+                                    GLUSTERD_VOLUME_BARRIER_OP, DRC_NA, 0},
+    [GLUSTERD_BRICK_BARRIER] = {"BARRIER", glusterfs_handle_barrier, NULL,
+                                GLUSTERD_BRICK_BARRIER, DRC_NA, 0},
+    [GLUSTERD_NODE_BITROT] = {"BITROT", glusterfs_handle_bitrot, NULL,
+                              GLUSTERD_NODE_BITROT, DRC_NA, 0},
+    [GLUSTERD_BRICK_ATTACH] = {"ATTACH", glusterfs_handle_attach, NULL,
+                               GLUSTERD_BRICK_ATTACH, DRC_NA, 0},
+
+    [GLUSTERD_DUMP_METRICS] = {"DUMP METRICS", glusterfs_handle_dump_metrics,
+                               NULL, GLUSTERD_DUMP_METRICS, DRC_NA, 0},
+
+    [GLUSTERD_SVC_ATTACH] = {"ATTACH CLIENT", glusterfs_handle_svc_attach, NULL,
+                             GLUSTERD_SVC_ATTACH, DRC_NA, 0},
+
+    [GLUSTERD_SVC_DETACH] = {"DETACH CLIENT", glusterfs_handle_svc_detach, NULL,
+                             GLUSTERD_SVC_DETACH, DRC_NA, 0},
+
 };
 
-struct rpcsvc_program glusterfs_mop_prog = {
-        .progname  = "Gluster Brick operations",
-        .prognum   = GD_BRICK_PROGRAM,
-        .progver   = GD_BRICK_VERSION,
-        .actors    = glusterfs_actors,
-        .numactors = GLUSTERD_BRICK_MAXVALUE,
-	.synctask  = _gf_true,
+static struct rpcsvc_program glusterfs_mop_prog = {
+    .progname = "Gluster Brick operations",
+    .prognum = GD_BRICK_PROGRAM,
+    .progver = GD_BRICK_VERSION,
+    .actors = glusterfs_actors,
+    .numactors = GLUSTERD_BRICK_MAXVALUE,
+    .synctask = _gf_true,
 };
 
 int
-mgmt_submit_request (void *req, call_frame_t *frame,
-                     glusterfs_ctx_t *ctx,
-                     rpc_clnt_prog_t *prog, int procnum,
-                     fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx,
+                    rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbkfn,
+                    xdrproc_t xdrproc)
 {
-        int                     ret         = -1;
-        int                     count      = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf = NULL;
-        struct iobref           *iobref = NULL;
-        ssize_t                 xdr_size = 0;
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                goto out;
-        }
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-
-                iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_pagesize (iobuf);
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        gf_log (THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+
+        iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_pagesize(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+            goto out;
         }
+        iov.iov_len = ret;
+        count = 1;
+    }
 
-        /* Send the msg */
-        ret = rpc_clnt_submit (ctx->mgmt, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    /* Send the msg */
+    ret = rpc_clnt_submit(ctx->mgmt, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
 
 out:
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 int
-mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                  void *myframe)
+mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf_getspec_rsp           rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        int                      ret   = 0, locked = 0;
-        ssize_t                  size = 0;
-        FILE                    *tmpfp = NULL;
-        char                    *volfile_id = NULL;
-        gf_volfile_t            *volfile_obj = NULL;
-        gf_volfile_t            *volfile_tmp = NULL;
-        char                     sha256_hash[SHA256_DIGEST_LENGTH] = {0, };
-
-        frame = myframe;
-        ctx = frame->this->ctx;
-
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the 'volume file' from server");
-                ret = rsp.op_errno;
-                goto out;
-        }
-
-        ret = 0;
-        size = rsp.op_ret;
-
-        glusterfs_compute_sha256 ((const unsigned char *) rsp.spec, size,
-                                  sha256_hash);
-
-        volfile_id = frame->local;
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0, locked = 0;
+    ssize_t size = 0;
+    FILE *tmpfp = NULL;
+    char *volfile_id = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+    gf_volfile_t *volfile_tmp = NULL;
+    char sha256_hash[SHA256_DIGEST_LENGTH] = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *servers_list = NULL;
+    int tmp_fd = -1;
+    char template[] = "/tmp/glfs.volfile.XXXXXX";
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        goto out;
+    }
 
-        LOCK (&ctx->volfile_lock);
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the 'volume file' from server");
+        ret = rsp.op_errno;
+        goto out;
+    }
+
+    if (!rsp.xdata.xdata_len) {
+        goto volfile;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.xdata.xdata_val, rsp.xdata.xdata_len, &dict);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to unserialize xdata to dictionary");
+        goto out;
+    }
+    dict->extra_stdfree = rsp.xdata.xdata_val;
+
+    ret = dict_get_str(dict, "servers-list", &servers_list);
+    if (ret) {
+        /* Server list is set by glusterd at the time of getspec */
+        ret = dict_get_str(dict, GLUSTERD_BRICK_SERVERS, &servers_list);
+        if (ret)
+            goto volfile;
+    }
+
+    gf_log(frame->this->name, GF_LOG_INFO,
+           "Received list of available volfile servers: %s", servers_list);
+
+    ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed (%s) to process servers list: %s", strerror(errno),
+               servers_list);
+    }
+
+volfile:
+    size = rsp.op_ret;
+    volfile_id = frame->local;
+    if (mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name)) {
+        ret = mgmt_process_volfile((const char *)rsp.spec, size, volfile_id,
+                                   dict);
+        goto post_graph_mgmt;
+    }
+
+    ret = 0;
+    glusterfs_compute_sha256((const unsigned char *)rsp.spec, size,
+                             sha256_hash);
+
+    LOCK(&ctx->volfile_lock);
+    {
+        locked = 1;
+
+        list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list)
         {
-                locked = 1;
-
-                list_for_each_entry (volfile_obj,  &ctx->volfile_list,
-                                     volfile_list) {
-                        if (!strcmp (volfile_id, volfile_obj->vol_id)) {
-                               if (!strncmp (sha256_hash,
-                                      volfile_obj->volfile_checksum,
-                                      sizeof (volfile_obj->volfile_checksum))) {
-                                        gf_log (frame->this->name, GF_LOG_INFO,
-                                                "No change in volfile,"
-                                                "continuing");
-                                        goto out;
-                               }
-                               volfile_tmp = volfile_obj;
-                               break;
-                        }
-                }
-
-                tmpfp = tmpfile ();
-                if (!tmpfp) {
-                        ret = -1;
-                        goto out;
-                }
-
-                fwrite (rsp.spec, size, 1, tmpfp);
-                fflush (tmpfp);
-                if (ferror (tmpfp)) {
-                        ret = -1;
-                        goto out;
-                }
-
-                /*  Check if only options have changed. No need to reload the
-                 *  volfile if topology hasn't changed.
-                 *  glusterfs_volfile_reconfigure returns 3 possible return states
-                 *  return 0          =======> reconfiguration of options has succeeded
-                 *  return 1          =======> the graph has to be reconstructed and all the xlators should be inited
-                 *  return -1(or -ve) =======> Some Internal Error occurred during the operation
-                 */
-
-                ret = glusterfs_volfile_reconfigure (tmpfp, ctx);
-                if (ret == 0) {
-                        gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG,
-                                "No need to re-load volfile, reconfigure done");
-                        if (!volfile_tmp) {
-                                ret = -1;
-                                gf_log ("mgmt", GF_LOG_ERROR, "Graph "
-                                        "reconfigure succeeded with out having "
-                                        "checksum.");
-                                goto out;
-                        }
-                        strncpy (volfile_tmp->volfile_checksum, sha256_hash,
-                                 sizeof (volfile_tmp->volfile_checksum));
-                        goto out;
+            if (!strcmp(volfile_id, volfile_obj->vol_id)) {
+                if (!memcmp(sha256_hash, volfile_obj->volfile_checksum,
+                            sizeof(volfile_obj->volfile_checksum))) {
+                    UNLOCK(&ctx->volfile_lock);
+                    gf_log(frame->this->name, GF_LOG_INFO,
+                           "No change in volfile,"
+                           "continuing");
+                    goto post_unlock;
                 }
+                volfile_tmp = volfile_obj;
+                break;
+            }
+        }
 
-                if (ret < 0) {
-                        gf_log ("glusterfsd-mgmt",
-                                GF_LOG_DEBUG, "Reconfigure failed !!");
-                        goto out;
-                }
+        /* coverity[secure_temp] mkstemp uses 0600 as the mode */
+        tmp_fd = mkstemp(template);
+        if (-1 == tmp_fd) {
+            UNLOCK(&ctx->volfile_lock);
+            gf_smsg(frame->this->name, GF_LOG_ERROR, 0, glusterfsd_msg_39,
+                    "create template=%s", template, NULL);
+            ret = -1;
+            goto post_unlock;
+        }
 
-                ret = glusterfs_process_volfp (ctx, tmpfp);
-                /* tmpfp closed */
-                tmpfp = NULL;
-                if (ret)
-                        goto out;
-
-                if (!volfile_tmp) {
-                        volfile_tmp = GF_CALLOC (1, sizeof (gf_volfile_t),
-                                                 gf_common_volfile_t);
-                        if (!volfile_tmp) {
-                                ret = -1;
-                                goto out;
-                        }
-
-                        INIT_LIST_HEAD (&volfile_tmp->volfile_list);
-                        list_add (&volfile_tmp->volfile_list,
-                                  &ctx->volfile_list);
-                        snprintf (volfile_tmp->vol_id,
-                                  sizeof (volfile_tmp->vol_id), "%s",
-                                  volfile_id);
-                }
-                strncpy (volfile_tmp->volfile_checksum, sha256_hash,
-                         sizeof (volfile_tmp->volfile_checksum));
+        /* Calling unlink so that when the file is closed or program
+         * terminates the temporary file is deleted.
+         */
+        ret = sys_unlink(template);
+        if (ret < 0) {
+            gf_smsg(frame->this->name, GF_LOG_INFO, 0, glusterfsd_msg_39,
+                    "delete template=%s", template, NULL);
+            ret = 0;
         }
-        UNLOCK (&ctx->volfile_lock);
 
-        locked = 0;
+        tmpfp = fdopen(tmp_fd, "w+b");
+        if (!tmpfp) {
+            ret = -1;
+            goto out;
+        }
 
-        if (!is_mgmt_rpc_reconnect) {
-                need_emancipate = 1;
-                glusterfs_mgmt_pmap_signin (ctx);
-                is_mgmt_rpc_reconnect =  _gf_true;
+        fwrite(rsp.spec, size, 1, tmpfp);
+        fflush(tmpfp);
+        if (ferror(tmpfp)) {
+            ret = -1;
+            goto out;
         }
 
-out:
+        /*  Check if only options have changed. No need to reload the
+         *  volfile if topology hasn't changed.
+         *  glusterfs_volfile_reconfigure returns 3 possible return states
+         *  return 0          =======> reconfiguration of options has succeeded
+         *  return 1          =======> the graph has to be reconstructed and all
+         * the xlators should be inited return -1(or -ve) =======> Some Internal
+         * Error occurred during the operation
+         */
 
-        if (locked)
-                UNLOCK (&ctx->volfile_lock);
+        ret = glusterfs_volfile_reconfigure(tmpfp, ctx);
+        if (ret == 0) {
+            gf_log("glusterfsd-mgmt", GF_LOG_DEBUG,
+                   "No need to re-load volfile, reconfigure done");
+            if (!volfile_tmp) {
+                ret = -1;
+                UNLOCK(&ctx->volfile_lock);
+                gf_log("mgmt", GF_LOG_ERROR,
+                       "Graph reconfigure succeeded with out having "
+                       "checksum.");
+                goto post_unlock;
+            }
+            memcpy(volfile_tmp->volfile_checksum, sha256_hash,
+                   sizeof(volfile_tmp->volfile_checksum));
+            goto out;
+        }
 
-        if (frame) {
-                GF_FREE (frame->local);
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
+        if (ret < 0) {
+            UNLOCK(&ctx->volfile_lock);
+            gf_log("glusterfsd-mgmt", GF_LOG_DEBUG, "Reconfigure failed !!");
+            goto post_unlock;
         }
 
-        free (rsp.spec);
+        ret = glusterfs_process_volfp(ctx, tmpfp);
+        /* tmpfp closed */
+        tmpfp = NULL;
+        tmp_fd = -1;
+        if (ret)
+            goto out;
 
-        // Stop if server is running at an unsupported op-version
-        if (ENOTSUP == ret) {
-                gf_log ("mgmt", GF_LOG_ERROR, "Server is operating at an "
-                        "op-version which is not supported");
-                cleanup_and_exit (0);
-        }
+        if (!volfile_tmp) {
+            volfile_tmp = GF_CALLOC(1, sizeof(gf_volfile_t),
+                                    gf_common_volfile_t);
+            if (!volfile_tmp) {
+                ret = -1;
+                goto out;
+            }
 
-        if (ret && ctx && !ctx->active) {
-                /* Do it only for the first time */
-                /* Failed to get the volume file, something wrong,
-                   restart the process */
-                gf_log ("mgmt", GF_LOG_ERROR,
-                        "failed to fetch volume file (key:%s)",
-                        ctx->cmd_args.volfile_id);
-                cleanup_and_exit (0);
+            INIT_LIST_HEAD(&volfile_tmp->volfile_list);
+            volfile_tmp->graph = ctx->active;
+            list_add(&volfile_tmp->volfile_list, &ctx->volfile_list);
+            snprintf(volfile_tmp->vol_id, sizeof(volfile_tmp->vol_id), "%s",
+                     volfile_id);
         }
+        memcpy(volfile_tmp->volfile_checksum, sha256_hash,
+               sizeof(volfile_tmp->volfile_checksum));
+    }
+    UNLOCK(&ctx->volfile_lock);
 
+    locked = 0;
 
-        if (tmpfp)
-                fclose (tmpfp);
+post_graph_mgmt:
+    if (!is_mgmt_rpc_reconnect) {
+        need_emancipate = 1;
+        glusterfs_mgmt_pmap_signin(ctx);
+        is_mgmt_rpc_reconnect = _gf_true;
+    }
 
-        return 0;
-}
+out:
 
+    if (locked)
+        UNLOCK(&ctx->volfile_lock);
+post_unlock:
+    GF_FREE(frame->local);
+    frame->local = NULL;
+    STACK_DESTROY(frame->root);
+    free(rsp.spec);
+
+    if (dict)
+        dict_unref(dict);
+
+    // Stop if server is running at an unsupported op-version
+    if (ENOTSUP == ret) {
+        gf_log("mgmt", GF_LOG_ERROR,
+               "Server is operating at an "
+               "op-version which is not supported");
+        cleanup_and_exit(0);
+    }
+
+    if (ret && ctx && !ctx->active) {
+        /* Do it only for the first time */
+        /* Failed to get the volume file, something wrong,
+           restart the process */
+        gf_log("mgmt", GF_LOG_ERROR, "failed to fetch volume file (key:%s)",
+               ctx->cmd_args.volfile_id);
+        cleanup_and_exit(0);
+    }
+
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
+
+    return 0;
+}
 
 static int
-glusterfs_volfile_fetch_one (glusterfs_ctx_t *ctx, char *volfile_id)
+glusterfs_volfile_fetch_one(glusterfs_ctx_t *ctx, char *volfile_id)
 {
-        cmd_args_t       *cmd_args = NULL;
-        gf_getspec_req    req = {0, };
-        int               ret = 0;
-        call_frame_t     *frame = NULL;
-        dict_t           *dict = NULL;
-
-        cmd_args = &ctx->cmd_args;
+    cmd_args_t *cmd_args = NULL;
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+
+    cmd_args = &ctx->cmd_args;
+    if (!volfile_id) {
+        volfile_id = ctx->cmd_args.volfile_id;
         if (!volfile_id) {
-                volfile_id = ctx->cmd_args.volfile_id;
-        }
-
-        frame = create_frame (THIS, ctx->pool);
-
-        req.key = volfile_id;
-        req.flags = 0;
-        /*
-         * We are only storing one variable in local, hence using the same
-         * variable. If multiple local variable is required, create a struct.
-         */
-        frame->local = gf_strdup (volfile_id);
-        if (!frame->local) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "No volfile-id provided, erroring out");
+            return -1;
         }
+    }
 
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version"
-                        " in request dict");
-                goto out;
-        }
+    frame = create_frame(THIS, ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    req.key = volfile_id;
+    req.flags = 0;
+    /*
+     * We are only storing one variable in local, hence using the same
+     * variable. If multiple local variable is required, create a struct.
+     */
+    frame->local = gf_strdup(volfile_id);
+    if (!frame->local) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX);
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set min-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set max-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    /* Ask for a list of volfile (glusterd2 only) servers */
+    if (GF_CLIENT_PROCESS == ctx->process_mode) {
+        req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
+    }
+
+    if (cmd_args->brick_name) {
+        ret = dict_set_dynstr_with_alloc(dict, "brick_name",
+                                         cmd_args->brick_name);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version"
-                        " in request dict");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "Failed to set brick_name in request dict");
+            goto out;
         }
+    }
 
-        if (cmd_args->brick_name) {
-                ret = dict_set_dynstr_with_alloc (dict, "brick_name",
-                                                  cmd_args->brick_name);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "Failed to set brick_name in request dict");
-                        goto out;
-                }
-        }
+    ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to serialize dictionary");
+        goto out;
+    }
 
-        ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
-
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_GETSPEC, mgmt_getspec_cbk,
-                                   (xdrproc_t)xdr_gf_getspec_req);
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GETSPEC, mgmt_getspec_cbk,
+                              (xdrproc_t)xdr_gf_getspec_req);
 
 out:
-        GF_FREE (req.xdata.xdata_val);
-        if (dict)
-                dict_unref (dict);
-        if (ret && frame) {
-                /* Free the frame->local fast, because we have not used memget
-                 */
-                GF_FREE (frame->local);
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
-        }
+    GF_FREE(req.xdata.xdata_val);
+    if (dict)
+        dict_unref(dict);
+    if (ret && frame) {
+        /* Free the frame->local fast, because we have not used memget
+         */
+        GF_FREE(frame->local);
+        frame->local = NULL;
+        STACK_DESTROY(frame->root);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_volfile_fetch (glusterfs_ctx_t *ctx)
+glusterfs_volfile_fetch(glusterfs_ctx_t *ctx)
 {
-        xlator_t        *server_xl      = NULL;
-        xlator_list_t   *trav;
-        int             ret;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                if (ctx->active) {
-                        server_xl = ctx->active->first;
-                        if (strcmp (server_xl->type, "protocol/server") != 0) {
-                                server_xl = NULL;
-                        }
-                }
-                if (!server_xl) {
-                        /* Startup (ctx->active not set) or non-server. */
-                        UNLOCK (&ctx->volfile_lock);
-                        return glusterfs_volfile_fetch_one
-                                (ctx, ctx->cmd_args.volfile_id);
-                }
+    xlator_t *server_xl = NULL;
+    xlator_list_t *trav;
+    gf_volfile_t *volfile_obj = NULL;
+    int ret = 0;
+
+    LOCK(&ctx->volfile_lock);
+    {
+        if (ctx->active &&
+            mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name)) {
+            list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list)
+            {
+                ret |= glusterfs_volfile_fetch_one(ctx, volfile_obj->vol_id);
+            }
+            UNLOCK(&ctx->volfile_lock);
+            return ret;
+        }
+
+        if (ctx->active) {
+            server_xl = ctx->active->first;
+            if (strcmp(server_xl->type, "protocol/server") != 0) {
+                server_xl = NULL;
+            }
+        }
+        if (!server_xl) {
+            /* Startup (ctx->active not set) or non-server. */
+            UNLOCK(&ctx->volfile_lock);
+            return glusterfs_volfile_fetch_one(ctx, ctx->cmd_args.volfile_id);
+        }
 
-                ret = 0;
-                for (trav = server_xl->children; trav; trav = trav->next) {
-                        ret |= glusterfs_volfile_fetch_one
-                                (ctx, trav->xlator->volfile_id);
-                }
+        ret = 0;
+        for (trav = server_xl->children; trav; trav = trav->next) {
+            ret |= glusterfs_volfile_fetch_one(ctx, trav->xlator->volfile_id);
         }
-        UNLOCK (&ctx->volfile_lock);
-        return ret;
+    }
+    UNLOCK(&ctx->volfile_lock);
+    return ret;
 }
 
-
 int32_t
-mgmt_event_notify_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                  void *myframe)
+mgmt_event_notify_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-        gf_event_notify_rsp      rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        int                      ret   = 0;
+    gf_event_notify_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        frame = myframe;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
 
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the rsp from server");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the rsp from server");
+        ret = -1;
+        goto out;
+    }
 out:
-        free (rsp.dict.dict_val); //malloced by xdr
-        return ret;
-
+    free(rsp.dict.dict_val);  // malloced by xdr
+    return ret;
 }
 
 int32_t
-glusterfs_rebalance_event_notify_cbk (struct rpc_req *req, struct iovec *iov,
-                                      int count, void *myframe)
+glusterfs_rebalance_event_notify_cbk(struct rpc_req *req, struct iovec *iov,
+                                     int count, void *myframe)
 {
-        gf_event_notify_rsp      rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        int                      ret   = 0;
+    gf_event_notify_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        frame = myframe;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the rsp from server");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the rsp from server");
+        ret = -1;
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
 
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Received error (%s) from server",
-                        strerror (rsp.op_errno));
-                ret = -1;
-                goto out;
-        }
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Received error (%s) from server", strerror(rsp.op_errno));
+        ret = -1;
+        goto out;
+    }
 out:
-        free (rsp.dict.dict_val); //malloced by xdr
-
-        if (frame) {
-                STACK_DESTROY (frame->root);
-        }
+    free(rsp.dict.dict_val);  // malloced by xdr
 
-        return ret;
+    if (frame) {
+        STACK_DESTROY(frame->root);
+    }
 
+    return ret;
 }
 
 int32_t
-glusterfs_rebalance_event_notify (dict_t *dict)
+glusterfs_rebalance_event_notify(dict_t *dict)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        gf_event_notify_req      req = {0,};
-        int32_t                  ret = -1;
-        cmd_args_t              *cmd_args = NULL;
-        call_frame_t            *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_event_notify_req req = {
+        0,
+    };
+    int32_t ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    call_frame_t *frame = NULL;
 
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
 
-        frame = create_frame (THIS, ctx->pool);
+    frame = create_frame(THIS, ctx->pool);
 
-        req.op = GF_EN_DEFRAG_STATUS;
+    req.op = GF_EN_DEFRAG_STATUS;
 
-        if (dict) {
-                ret = dict_set_str (dict, "volname", cmd_args->volfile_id);
-                if (ret)
-                        gf_log ("", GF_LOG_ERROR, "failed to set volname");
-
-                ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                                   &req.dict.dict_len);
+    if (dict) {
+        ret = dict_set_str(dict, "volname", cmd_args->volfile_id);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "failed to set volname");
         }
+        ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                          &req.dict.dict_len);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "failed to serialize dict");
+        }
+    }
 
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_EVENT_NOTIFY,
-                                   glusterfs_rebalance_event_notify_cbk,
-                                   (xdrproc_t)xdr_gf_event_notify_req);
-
-        GF_FREE (req.dict.dict_val);
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_EVENT_NOTIFY,
+                              glusterfs_rebalance_event_notify_cbk,
+                              (xdrproc_t)xdr_gf_event_notify_req);
 
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 static int
-mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-                 void *data)
+mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                void *data)
 {
-        xlator_t         *this = NULL;
-        glusterfs_ctx_t  *ctx = NULL;
-        int              ret = 0;
-        server_cmdline_t *server = NULL;
-        rpc_transport_t  *rpc_trans = NULL;
-        int              need_term = 0;
-        int              emval = 0;
-        static           int log_ctr1;
-        static           int log_ctr2;
-        struct dnscache6 *dnscache = NULL;
-
-        this = mydata;
-        rpc_trans = rpc->conn.trans;
-        ctx = this->ctx;
-
-        switch (event) {
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    server_cmdline_t *server = NULL;
+    rpc_transport_t *rpc_trans = NULL;
+    int need_term = 0;
+    int emval = 0;
+    static int log_ctr1;
+    static int log_ctr2;
+    struct dnscache6 *dnscache = NULL;
+
+    this = mydata;
+    rpc_trans = rpc->conn.trans;
+    ctx = this->ctx;
+
+    switch (event) {
         case RPC_CLNT_DISCONNECT:
-                if (rpc_trans->connect_failed) {
-                        GF_LOG_OCCASIONALLY (log_ctr1, "glusterfsd-mgmt",
-                                             GF_LOG_ERROR,
-                                             "failed to connect to remote-"
-                                             "host: %s",
-                                             ctx->cmd_args.volfile_server);
-                } else {
-                        GF_LOG_OCCASIONALLY (log_ctr1, "glusterfsd-mgmt",
-                                             GF_LOG_INFO,
-                                             "disconnected from remote-"
-                                             "host: %s",
-                                             ctx->cmd_args.volfile_server);
-                }
-
-                if (!rpc->disabled) {
-                        /*
-                         * Check if dnscache is exhausted for current server
-                         * and continue until cache is exhausted
-                         */
-                        dnscache = rpc_trans->dnscache;
-                        if (dnscache && dnscache->next) {
-                                break;
-                        }
+            if (rpc_trans->connect_failed) {
+                GF_LOG_OCCASIONALLY(log_ctr1, "glusterfsd-mgmt", GF_LOG_ERROR,
+                                    "failed to connect to remote-"
+                                    "host: %s",
+                                    ctx->cmd_args.volfile_server);
+            } else {
+                GF_LOG_OCCASIONALLY(log_ctr1, "glusterfsd-mgmt", GF_LOG_INFO,
+                                    "disconnected from remote-"
+                                    "host: %s",
+                                    ctx->cmd_args.volfile_server);
+            }
+
+            if (!rpc->disabled) {
+                /*
+                 * Check if dnscache is exhausted for current server
+                 * and continue until cache is exhausted
+                 */
+                dnscache = rpc_trans->dnscache;
+                if (dnscache && dnscache->next) {
+                    break;
                 }
-                server = ctx->cmd_args.curr_server;
-                if (server->list.next == &ctx->cmd_args.volfile_servers) {
-                        if (!ctx->active) {
-                                need_term = 1;
-                        }
-                        emval = ENOTCONN;
-                        GF_LOG_OCCASIONALLY (log_ctr2, "glusterfsd-mgmt",
-                                             GF_LOG_INFO,
-                                             "Exhausted all volfile servers");
-                        break;
+            }
+            server = ctx->cmd_args.curr_server;
+            if (server->list.next == &ctx->cmd_args.volfile_servers) {
+                if (!ctx->active) {
+                    need_term = 1;
                 }
-                server = list_entry (server->list.next, typeof(*server), list);
-                ctx->cmd_args.curr_server = server;
-                ctx->cmd_args.volfile_server = server->volfile_server;
-
-                ret = dict_set_str (rpc_trans->options, "remote-host",
-                                    server->volfile_server);
-                if (ret != 0) {
-                        gf_log ("glusterfsd-mgmt", GF_LOG_ERROR,
-                                "failed to set remote-host: %s",
-                                server->volfile_server);
-                        if (!ctx->active) {
-                                need_term = 1;
-                        }
-                        emval = ENOTCONN;
-                        break;
+                emval = ENOTCONN;
+                GF_LOG_OCCASIONALLY(log_ctr2, "glusterfsd-mgmt", GF_LOG_INFO,
+                                    "Exhausted all volfile servers");
+                break;
+            }
+            server = list_entry(server->list.next, typeof(*server), list);
+            ctx->cmd_args.curr_server = server;
+            ctx->cmd_args.volfile_server = server->volfile_server;
+
+            ret = dict_set_str(rpc_trans->options, "remote-host",
+                               server->volfile_server);
+            if (ret != 0) {
+                gf_log("glusterfsd-mgmt", GF_LOG_ERROR,
+                       "failed to set remote-host: %s", server->volfile_server);
+                if (!ctx->active) {
+                    need_term = 1;
                 }
-                gf_log ("glusterfsd-mgmt", GF_LOG_INFO,
-                        "connecting to next volfile server %s",
-                        server->volfile_server);
+                emval = ENOTCONN;
                 break;
+            }
+            gf_log("glusterfsd-mgmt", GF_LOG_INFO,
+                   "connecting to next volfile server %s",
+                   server->volfile_server);
+            break;
         case RPC_CLNT_CONNECT:
-                rpc_clnt_set_connected (&((struct rpc_clnt*)ctx->mgmt)->conn);
-
-                ret = glusterfs_volfile_fetch (ctx);
-                if (ret) {
-                        emval = ret;
-                        if (!ctx->active) {
-                                need_term = 1;
-                                gf_log ("glusterfsd-mgmt", GF_LOG_ERROR,
-                                        "failed to fetch volume file (key:%s)",
-                                        ctx->cmd_args.volfile_id);
-                                break;
-
-                        }
+            ret = glusterfs_volfile_fetch(ctx);
+            if (ret) {
+                emval = ret;
+                if (!ctx->active) {
+                    need_term = 1;
+                    gf_log("glusterfsd-mgmt", GF_LOG_ERROR,
+                           "failed to fetch volume file (key:%s)",
+                           ctx->cmd_args.volfile_id);
+                    break;
                 }
+            }
 
-                if (is_mgmt_rpc_reconnect)
-                        glusterfs_mgmt_pmap_signin (ctx);
+            if (is_mgmt_rpc_reconnect)
+                glusterfs_mgmt_pmap_signin(ctx);
 
-                break;
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        if (need_term) {
-                emancipate (ctx, emval);
-                cleanup_and_exit (1);
-        }
+    if (need_term) {
+        emancipate(ctx, emval);
+        cleanup_and_exit(1);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_rpcsvc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
-                     void *data)
+glusterfs_rpcsvc_notify(rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
+                        void *data)
 {
-        if (!xl || !data) {
-                goto out;
-        }
+    if (!xl || !data) {
+        goto out;
+    }
 
-        switch (event) {
-        case RPCSVC_EVENT_ACCEPT:
-        {
-                break;
+    switch (event) {
+        case RPCSVC_EVENT_ACCEPT: {
+            break;
         }
-        case RPCSVC_EVENT_DISCONNECT:
-        {
-                break;
+        case RPCSVC_EVENT_DISCONNECT: {
+            break;
         }
 
         default:
-                break;
-        }
+            break;
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_listener_init (glusterfs_ctx_t *ctx)
+glusterfs_listener_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t              *cmd_args = NULL;
-        rpcsvc_t                *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
-
-        cmd_args = &ctx->cmd_args;
-
-        if (ctx->listener)
-                return 0;
-
-        if (!cmd_args->sock_file)
-                return 0;
-
-        ret = rpcsvc_transport_unix_options_build (&options,
-                                                   cmd_args->sock_file);
-        if (ret)
-                goto out;
-
-        rpc = rpcsvc_init (THIS, ctx, options, 8);
-        if (rpc == NULL) {
-                goto out;
-        }
-
-        ret = rpcsvc_register_notify (rpc, glusterfs_rpcsvc_notify, THIS);
-        if (ret) {
-                goto out;
-        }
-
-        ret = rpcsvc_create_listeners (rpc, options, "glusterfsd");
-        if (ret < 1) {
-                goto out;
-        }
-
-        ret = rpcsvc_program_register (rpc, &glusterfs_mop_prog);
-        if (ret) {
-                goto out;
-        }
+    cmd_args_t *cmd_args = NULL;
+    rpcsvc_t *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
 
-        ctx->listener = rpc;
+    cmd_args = &ctx->cmd_args;
 
-out:
-        return ret;
-}
+    if (ctx->listener)
+        return 0;
 
-int
-glusterfs_listener_stop (glusterfs_ctx_t *ctx)
-{
-        cmd_args_t              *cmd_args = NULL;
-        rpcsvc_t                *rpc = NULL;
-        rpcsvc_listener_t       *listener = NULL;
-        rpcsvc_listener_t       *next = NULL;
-        int                     ret = 0;
-        xlator_t                *this = NULL;
+    if (!cmd_args->sock_file)
+        return 0;
 
-        GF_ASSERT (ctx);
+    options = dict_new();
+    if (!options)
+        goto out;
 
-        rpc = ctx->listener;
-        ctx->listener = NULL;
+    ret = rpcsvc_transport_unix_options_build(options, cmd_args->sock_file);
+    if (ret)
+        goto out;
 
-        (void) rpcsvc_program_unregister(rpc, &glusterfs_mop_prog);
+    rpc = rpcsvc_init(THIS, ctx, options, 8);
+    if (rpc == NULL) {
+        goto out;
+    }
 
-        list_for_each_entry_safe (listener, next, &rpc->listeners, list) {
-                rpcsvc_listener_destroy (listener);
-        }
+    ret = rpcsvc_register_notify(rpc, glusterfs_rpcsvc_notify, THIS);
+    if (ret) {
+        goto out;
+    }
 
-        (void) rpcsvc_unregister_notify (rpc, glusterfs_rpcsvc_notify, THIS);
+    ret = rpcsvc_create_listeners(rpc, options, "glusterfsd");
+    if (ret < 1) {
+        goto out;
+    }
 
-        GF_FREE (rpc);
+    ret = rpcsvc_program_register(rpc, &glusterfs_mop_prog, _gf_false);
+    if (ret) {
+        goto out;
+    }
 
-        cmd_args = &ctx->cmd_args;
-        if (cmd_args->sock_file) {
-                ret = sys_unlink (cmd_args->sock_file);
-                if (ret && (ENOENT == errno)) {
-                        ret = 0;
-                }
-        }
+    ctx->listener = rpc;
 
-        if (ret) {
-                this = THIS;
-                gf_log (this->name, GF_LOG_ERROR, "Failed to unlink listener "
-                        "socket %s, error: %s", cmd_args->sock_file,
-                        strerror (errno));
-        }
-        return ret;
+out:
+    if (options)
+        dict_unref(options);
+    return ret;
 }
 
 int
-glusterfs_mgmt_notify (int32_t op, void *data, ...)
+glusterfs_mgmt_notify(int32_t op, void *data, ...)
 {
-        int ret = 0;
-        switch (op)
-        {
-                case GF_EN_DEFRAG_STATUS:
-                        ret = glusterfs_rebalance_event_notify ((dict_t*) data);
-                        break;
+    int ret = 0;
+    switch (op) {
+        case GF_EN_DEFRAG_STATUS:
+            ret = glusterfs_rebalance_event_notify((dict_t *)data);
+            break;
 
-                default:
-                        gf_log ("", GF_LOG_ERROR, "Invalid op");
-                        break;
-        }
+        default:
+            gf_log("", GF_LOG_ERROR, "Invalid op");
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_mgmt_init (glusterfs_ctx_t *ctx)
+glusterfs_mgmt_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t              *cmd_args = NULL;
-        struct rpc_clnt         *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
-        int                     port = GF_DEFAULT_BASE_PORT;
-        char                    *host = NULL;
-
-        cmd_args = &ctx->cmd_args;
-        GF_VALIDATE_OR_GOTO (THIS->name, cmd_args->volfile_server, out);
-
-        if (ctx->mgmt)
-                return 0;
-
-        LOCK_INIT (&ctx->volfile_lock);
-
-        if (cmd_args->volfile_server_port)
-                port = cmd_args->volfile_server_port;
+    cmd_args_t *cmd_args = NULL;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = GF_DEFAULT_BASE_PORT;
+    char *host = NULL;
+    xlator_cmdline_option_t *opt = NULL;
+
+    cmd_args = &ctx->cmd_args;
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args->volfile_server, out);
+
+    if (ctx->mgmt)
+        return 0;
 
-        host = cmd_args->volfile_server;
+    options = dict_new();
+    if (!options)
+        goto out;
 
-        if (cmd_args->volfile_server_transport &&
-            !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                ret = rpc_transport_unix_options_build (&options, host, 0);
-        } else {
-                ret = rpc_transport_inet_options_build (&options, host, port);
-        }
-        if (ret)
-                goto out;
+    LOCK_INIT(&ctx->volfile_lock);
 
-        /* Explicitly turn on encrypted transport. */
-        if (ctx->secure_mgmt) {
-                ret = dict_set_dynstr_with_alloc
-                        (options, "transport.socket.ssl-enabled", "yes");
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "failed to set 'transport.socket.ssl-enabled' "
-                                "in options dict");
-                        goto out;
+    if (cmd_args->volfile_server_port)
+        port = cmd_args->volfile_server_port;
 
-                }
-        }
+    host = cmd_args->volfile_server;
 
-        rpc = rpc_clnt_new (options, THIS, THIS->name, 8);
-        if (!rpc) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_WARNING, "failed to create rpc clnt");
-                goto out;
-        }
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        ret = rpc_transport_unix_options_build(options, host, 0);
+    } else {
+        opt = find_xlator_option_in_cmd_args_t("address-family", cmd_args);
+        ret = rpc_transport_inet_options_build(options, host, port,
+                                               (opt ? opt->value : NULL));
+    }
+    if (ret)
+        goto out;
 
-        ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS);
+    /* Explicitly turn on encrypted transport. */
+    if (ctx->secure_mgmt) {
+        ret = dict_set_dynstr_with_alloc(options,
+                                         "transport.socket.ssl-enabled", "yes");
         if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to register notify function");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set 'transport.socket.ssl-enabled' "
+                   "in options dict");
+            goto out;
         }
 
-        ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to register callback function");
-                goto out;
-        }
-
-        ctx->notify = glusterfs_mgmt_notify;
-
-        /* This value should be set before doing the 'rpc_clnt_start()' as
-           the notify function uses this variable */
-        ctx->mgmt = rpc;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
 
-        ret = rpc_clnt_start (rpc);
+    rpc = rpc_clnt_new(options, THIS, THIS->name, 8);
+    if (!rpc) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create rpc clnt");
+        goto out;
+    }
+
+    ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to register notify function");
+        goto out;
+    }
+
+    ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to register callback function");
+        goto out;
+    }
+
+    ctx->notify = glusterfs_mgmt_notify;
+
+    /* This value should be set before doing the 'rpc_clnt_start()' as
+       the notify function uses this variable */
+    ctx->mgmt = rpc;
+
+    ret = rpc_clnt_start(rpc);
 out:
-        return ret;
+    if (options)
+        dict_unref(options);
+    return ret;
 }
 
 static int
-mgmt_pmap_signin2_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
+mgmt_pmap_signin2_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-        pmap_signin_rsp  rsp   = {0,};
-        glusterfs_ctx_t *ctx   = NULL;
-        call_frame_t    *frame = NULL;
-        int              ret   = 0;
+    pmap_signin_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        ctx = glusterfsd_ctx;
-        frame = myframe;
+    ctx = glusterfsd_ctx;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decode error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decode error");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (need_emancipate)
-                emancipate (ctx, ret);
-
-        STACK_DESTROY (frame->root);
-        return 0;
+    if (need_emancipate)
+        emancipate(ctx, ret);
 
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static int
-mgmt_pmap_signin_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
+mgmt_pmap_signin_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        pmap_signin_rsp  rsp   = {0,};
-        call_frame_t    *frame = NULL;
-        int              ret   = 0;
-        int              emancipate_ret  = -1;
-        pmap_signin_req  pmap_req = {0, };
-        cmd_args_t      *cmd_args = NULL;
-        glusterfs_ctx_t *ctx      = NULL;
-        char             brick_name[PATH_MAX] = {0,};
-
-        frame = myframe;
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
-
-
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decode error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                ret = -1;
-                goto out;
-        }
-
-        if (!cmd_args->brick_port2) {
-                /* We are done with signin process */
-                emancipate_ret = 0;
-                goto out;
-        }
-
-        snprintf (brick_name, PATH_MAX, "%s.rdma", cmd_args->brick_name);
-        pmap_req.port  = cmd_args->brick_port2;
-        pmap_req.brick = brick_name;
-
-        ret = mgmt_submit_request (&pmap_req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNIN, mgmt_pmap_signin2_cbk,
-                                   (xdrproc_t)xdr_pmap_signin_req);
-        if (ret)
-                goto out;
-
-        return 0;
-
-out:
-        if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
-                emancipate (ctx, emancipate_ret);
-
-        STACK_DESTROY (frame->root);
-        return 0;
-}
+    pmap_signin_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
+    int emancipate_ret = -1;
+    pmap_signin_req pmap_req = {
+        0,
+    };
+    cmd_args_t *cmd_args = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+
+    frame = myframe;
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decode error");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        ret = -1;
+        goto out;
+    }
 
-int
-glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx)
-{
-        call_frame_t     *frame                 = NULL;
-        pmap_signin_req   req                   = {0, };
-        int               ret                   = -1;
-        int               emancipate_ret        = -1;
-        cmd_args_t       *cmd_args              = NULL;
-        char              brick_name[PATH_MAX]  = {0,};
-
-        frame = create_frame (THIS, ctx->pool);
-        cmd_args = &ctx->cmd_args;
-
-        if (!cmd_args->brick_port || !cmd_args->brick_name) {
-                gf_log ("fsd-mgmt", GF_LOG_DEBUG,
-                        "portmapper signin arguments not given");
-                emancipate_ret = 0;
-                goto out;
-        }
+    if (!cmd_args->brick_port2) {
+        /* We are done with signin process */
+        emancipate_ret = 0;
+        goto out;
+    }
 
-        if (cmd_args->volfile_server_transport &&
-                      !strcmp(cmd_args->volfile_server_transport, "rdma")) {
-                snprintf (brick_name, sizeof(brick_name), "%s.rdma",
-                          cmd_args->brick_name);
-                req.brick = brick_name;
-        } else
-                req.brick = cmd_args->brick_name;
+    snprintf(brick_name, PATH_MAX, "%s.rdma", cmd_args->brick_name);
+    pmap_req.port = cmd_args->brick_port2;
+    pmap_req.brick = brick_name;
 
-        req.port  = cmd_args->brick_port;
+    ret = mgmt_submit_request(&pmap_req, frame, ctx, &clnt_pmap_prog,
+                              GF_PMAP_SIGNIN, mgmt_pmap_signin2_cbk,
+                              (xdrproc_t)xdr_pmap_signin_req);
+    if (ret)
+        goto out;
 
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNIN, mgmt_pmap_signin_cbk,
-                                   (xdrproc_t)xdr_pmap_signin_req);
+    return 0;
 
 out:
-        if (need_emancipate && ret < 0)
-                emancipate (ctx, emancipate_ret);
-        return ret;
-}
-
-
-static int
-mgmt_pmap_signout_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        pmap_signout_rsp  rsp   = {0,};
-        int              ret   = 0;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
+    if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
+        emancipate(ctx, emancipate_ret);
 
-        if (-1 == rsp.op_ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                goto out;
-        }
-out:
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
-
 int
-glusterfs_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brickname)
+glusterfs_mgmt_pmap_signin(glusterfs_ctx_t *ctx)
 {
-        int               ret = 0;
-        pmap_signout_req  req = {0, };
-        call_frame_t     *frame = NULL;
-        cmd_args_t       *cmd_args = NULL;
-        char              brick_name[PATH_MAX]  = {0,};
-
-        frame = create_frame (THIS, ctx->pool);
-        cmd_args = &ctx->cmd_args;
-
-        if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) {
-                gf_log ("fsd-mgmt", GF_LOG_DEBUG,
-                        "portmapper signout arguments not given");
-                goto out;
-        }
-
-        if (cmd_args->volfile_server_transport &&
-                      !strcmp(cmd_args->volfile_server_transport, "rdma")) {
-                snprintf (brick_name, sizeof(brick_name), "%s.rdma",
-                          cmd_args->brick_name);
-                req.brick = brick_name;
-        } else {
-                if (brickname)
-                        req.brick = brickname;
-                else
-                        req.brick = cmd_args->brick_name;
-        }
+    call_frame_t *frame = NULL;
+    xlator_list_t **trav_p;
+    xlator_t *top;
+    pmap_signin_req req = {
+        0,
+    };
+    int ret = -1;
+    int emancipate_ret = -1;
+    cmd_args_t *cmd_args = NULL;
+
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args->brick_port || !cmd_args->brick_name) {
+        gf_log("fsd-mgmt", GF_LOG_DEBUG,
+               "portmapper signin arguments not given");
+        emancipate_ret = 0;
+        goto out;
+    }
+
+    req.port = cmd_args->brick_port;
+    req.pid = (int)getpid(); /* only glusterd2 consumes this */
+
+    if (ctx->active) {
+        top = ctx->active->first;
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            frame = create_frame(THIS, ctx->pool);
+            req.brick = (*trav_p)->xlator->name;
+            ret = mgmt_submit_request(&req, frame, ctx, &clnt_pmap_prog,
+                                      GF_PMAP_SIGNIN, mgmt_pmap_signin_cbk,
+                                      (xdrproc_t)xdr_pmap_signin_req);
+            if (ret < 0) {
+                gf_log(THIS->name, GF_LOG_WARNING,
+                       "failed to send sign in request; brick = %s", req.brick);
+            }
+        }
+    }
+
+    /* unfortunately, the caller doesn't care about the returned value */
 
-        req.port  = cmd_args->brick_port;
-        req.rdma_port = cmd_args->brick_port2;
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNOUT, mgmt_pmap_signout_cbk,
-                                   (xdrproc_t)xdr_pmap_signout_req);
 out:
-        return ret;
+    if (need_emancipate && ret < 0)
+        emancipate(ctx, emancipate_ret);
+    return ret;
 }
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
index eeffdc5c34e..dae41f33fef 100644
--- a/glusterfsd/src/glusterfsd.c
+++ b/glusterfsd/src/glusterfsd.c
@@ -37,9 +37,9 @@
 #include <linux/oom.h>
 #else
 #define OOM_SCORE_ADJ_MIN (-1000)
-#define OOM_SCORE_ADJ_MAX   1000
-#define OOM_DISABLE       (-17)
-#define OOM_ADJUST_MAX      15
+#define OOM_SCORE_ADJ_MAX 1000
+#define OOM_DISABLE (-17)
+#define OOM_ADJUST_MAX 15
 #endif
 #endif
 
@@ -47,1357 +47,1415 @@
 #include <malloc.h>
 #endif
 
-#ifdef HAVE_MALLOC_STATS
-#ifdef DEBUG
-#include <mcheck.h>
-#endif
-#endif
-
-#include "xlator.h"
-#include "glusterfs.h"
-#include "compat.h"
-#include "logging.h"
+#include <glusterfs/xlator.h>
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/logging.h>
 #include "glusterfsd-messages.h"
-#include "dict.h"
-#include "list.h"
-#include "timer.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/list.h>
+#include <glusterfs/timer.h>
 #include "glusterfsd.h"
-#include "stack.h"
-#include "revision.h"
-#include "common-utils.h"
-#include "event.h"
-#include "globals.h"
-#include "statedump.h"
-#include "latency.h"
+#include <glusterfs/revision.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/gf-event.h>
+#include <glusterfs/statedump.h>
+#include <glusterfs/latency.h>
 #include "glusterfsd-mem-types.h"
-#include "syscall.h"
-#include "call-stub.h"
+#include <glusterfs/syscall.h>
+#include <glusterfs/call-stub.h>
 #include <fnmatch.h>
 #include "rpc-clnt.h"
-#include "syncop.h"
-#include "client_t.h"
+#include <glusterfs/syncop.h>
+#include <glusterfs/client_t.h>
 #include "netgroups.h"
 #include "exports.h"
+#include <glusterfs/monitoring.h>
 
-#include "daemon.h"
-
+#include <glusterfs/daemon.h>
 
 /* using argp for command line parsing */
 static char gf_doc[] = "";
-static char argp_doc[] = "--volfile-server=SERVER [MOUNT-POINT]\n"       \
-        "--volfile=VOLFILE [MOUNT-POINT]";
-const char *argp_program_version = ""                                         \
-        PACKAGE_NAME" "PACKAGE_VERSION                                        \
-        "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n"          \
-        "Copyright (c) 2006-2016 Red Hat, Inc. "                              \
-        "<https://www.gluster.org/>\n"                                        \
-        "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"                      \
-        "It is licensed to you under your choice of the GNU Lesser\n"         \
-        "General Public License, version 3 or any later version (LGPLv3\n"    \
-        "or later), or the GNU General Public License, version 2 (GPLv2),\n"  \
-        "in all cases as published by the Free Software Foundation.";
+static char argp_doc[] =
+    "--volfile-server=SERVER [MOUNT-POINT]\n"
+    "--volfile=VOLFILE [MOUNT-POINT]";
+const char *argp_program_version =
+    "" PACKAGE_NAME " " PACKAGE_VERSION
+    "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION
+    "\n"
+    "Copyright (c) 2006-2016 Red Hat, Inc. "
+    "<https://www.gluster.org/>\n"
+    "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"
+    "It is licensed to you under your choice of the GNU Lesser\n"
+    "General Public License, version 3 or any later version (LGPLv3\n"
+    "or later), or the GNU General Public License, version 2 (GPLv2),\n"
+    "in all cases as published by the Free Software Foundation.";
 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 
-static error_t parse_opts (int32_t key, char *arg, struct argp_state *_state);
+static error_t
+parse_opts(int32_t key, char *arg, struct argp_state *_state);
 
 static struct argp_option gf_options[] = {
-        {0, 0, 0, 0, "Basic options:"},
-        {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
-         "Server to get the volume file from. Unix domain socket path when "
-         "transport type 'unix'. This option overrides --volfile option"},
-        {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
-         "File to use as VOLUME_FILE"},
-        {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
-         "File to use as VOLUME FILE"},
-
-        {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
-         "Logging severity.  Valid options are DEBUG, INFO, WARNING, ERROR, "
-         "CRITICAL, TRACE and NONE [default: INFO]"},
-        {"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
-         "File to use for logging [default: "
-         DEFAULT_LOG_FILE_DIRECTORY "/" PACKAGE_NAME ".log" "]"},
-        {"logger", ARGP_LOGGER, "LOGGER", 0, "Set which logging sub-system to "
-        "log to, valid options are: gluster-log and syslog, "
-        "[default: \"gluster-log\"]"},
-        {"log-format", ARGP_LOG_FORMAT, "LOG-FORMAT", 0, "Set log format, valid"
-         " options are: no-msg-id and with-msg-id, [default: \"with-msg-id\"]"},
-        {"log-buf-size", ARGP_LOG_BUF_SIZE, "LOG-BUF-SIZE", 0, "Set logging "
-         "buffer size, [default: 5]"},
-        {"log-flush-timeout", ARGP_LOG_FLUSH_TIMEOUT, "LOG-FLUSH-TIMEOUT", 0,
-         "Set log flush timeout, [default: 2 minutes]"},
-
-        {0, 0, 0, 0, "Advanced Options:"},
-        {"volfile-server-port", ARGP_VOLFILE_SERVER_PORT_KEY, "PORT", 0,
-         "Listening port number of volfile server"},
-        {"volfile-server-transport", ARGP_VOLFILE_SERVER_TRANSPORT_KEY,
-         "TRANSPORT", 0,
-         "Transport type to get volfile from server [default: socket]"},
-        {"volfile-id", ARGP_VOLFILE_ID_KEY, "KEY", 0,
-         "'key' of the volfile to be fetched from server"},
-        {"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0,
-         "File to use as pid file"},
-        {"socket-file", ARGP_SOCK_FILE_KEY, "SOCKFILE", 0,
-         "File to use as unix-socket"},
-        {"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0,
-         "Run in foreground"},
-        {"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
-         "Run ID for the process, used by scripts to keep track of process "
-         "they started, defaults to none"},
-        {"debug", ARGP_DEBUG_KEY, 0, 0,
-         "Run in debug mode.  This option sets --no-daemon, --log-level "
-         "to DEBUG and --log-file to console"},
-        {"volume-name", ARGP_VOLUME_NAME_KEY, "XLATOR-NAME", 0,
-         "Translator name to be used for MOUNT-POINT [default: top most volume "
-         "definition in VOLFILE]"},
-        {"xlator-option", ARGP_XLATOR_OPTION_KEY,"XLATOR-NAME.OPTION=VALUE", 0,
-         "Add/override an option for a translator in volume file with specified"
-         " value"},
-        {"read-only", ARGP_READ_ONLY_KEY, 0, 0,
-         "Mount the filesystem in 'read-only' mode"},
-        {"acl", ARGP_ACL_KEY, 0, 0,
-         "Mount the filesystem with POSIX ACL support"},
-        {"selinux", ARGP_SELINUX_KEY, 0, 0,
-         "Enable SELinux label (extended attributes) support on inodes"},
-        {"capability", ARGP_CAPABILITY_KEY, 0, 0,
-         "Enable Capability (extended attributes) support on inodes"},
-        {"subdir-mount", ARGP_SUBDIR_MOUNT_KEY, "SUBDIR-PATH", 0,
-         "Mount subdirectory given [default: NULL]"},
-
-        {"print-netgroups", ARGP_PRINT_NETGROUPS, "NETGROUP-FILE", 0,
-         "Validate the netgroups file and print it out"},
-        {"print-exports", ARGP_PRINT_EXPORTS, "EXPORTS-FILE", 0,
-        "Validate the exports file and print it out"},
-
-        {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS, "0",
-         OPTION_HIDDEN, "Maximum number of attempts to fetch the volfile"},
-        {"aux-gfid-mount", ARGP_AUX_GFID_MOUNT_KEY, 0, 0,
-         "Enable access to filesystem through gfid directly"},
-        {"enable-ino32", ARGP_INODE32_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Use 32-bit inodes when mounting to workaround broken applications"
-         "that don't support 64-bit inodes"},
-        {"worm", ARGP_WORM_KEY, 0, 0,
-         "Mount the filesystem in 'worm' mode"},
-        {"mac-compat", ARGP_MAC_COMPAT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Provide stubs for attributes needed for seamless operation on Macs "
+    {0, 0, 0, 0, "Basic options:"},
+    {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
+     "Server to get the volume file from. Unix domain socket path when "
+     "transport type 'unix'. This option overrides --volfile option"},
+    {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
+     "File to use as VOLUME_FILE"},
+    {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
+     "File to use as VOLUME FILE"},
+
+    {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
+     "Logging severity.  Valid options are DEBUG, INFO, WARNING, ERROR, "
+     "CRITICAL, TRACE and NONE [default: INFO]"},
+    {"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
+     "File to use for logging [default: " DEFAULT_LOG_FILE_DIRECTORY
+     "/" PACKAGE_NAME ".log"
+     "]"},
+    {"logger", ARGP_LOGGER, "LOGGER", 0,
+     "Set which logging sub-system to "
+     "log to, valid options are: gluster-log and syslog, "
+     "[default: \"gluster-log\"]"},
+    {"log-format", ARGP_LOG_FORMAT, "LOG-FORMAT", 0,
+     "Set log format, valid"
+     " options are: no-msg-id and with-msg-id, [default: \"with-msg-id\"]"},
+    {"log-buf-size", ARGP_LOG_BUF_SIZE, "LOG-BUF-SIZE", 0,
+     "Set logging "
+     "buffer size, [default: 5]"},
+    {"log-flush-timeout", ARGP_LOG_FLUSH_TIMEOUT, "LOG-FLUSH-TIMEOUT", 0,
+     "Set log flush timeout, [default: 2 minutes]"},
+
+    {0, 0, 0, 0, "Advanced Options:"},
+    {"volfile-server-port", ARGP_VOLFILE_SERVER_PORT_KEY, "PORT", 0,
+     "Listening port number of volfile server"},
+    {"volfile-server-transport", ARGP_VOLFILE_SERVER_TRANSPORT_KEY, "TRANSPORT",
+     0, "Transport type to get volfile from server [default: socket]"},
+    {"volfile-id", ARGP_VOLFILE_ID_KEY, "KEY", 0,
+     "'key' of the volfile to be fetched from server"},
+    {"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0, "File to use as pid file"},
+    {"socket-file", ARGP_SOCK_FILE_KEY, "SOCKFILE", 0,
+     "File to use as unix-socket"},
+    {"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0, "Run in foreground"},
+    {"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
+     "Run ID for the process, used by scripts to keep track of process "
+     "they started, defaults to none"},
+    {"debug", ARGP_DEBUG_KEY, 0, 0,
+     "Run in debug mode.  This option sets --no-daemon, --log-level "
+     "to DEBUG and --log-file to console"},
+    {"volume-name", ARGP_VOLUME_NAME_KEY, "XLATOR-NAME", 0,
+     "Translator name to be used for MOUNT-POINT [default: top most volume "
+     "definition in VOLFILE]"},
+    {"xlator-option", ARGP_XLATOR_OPTION_KEY, "XLATOR-NAME.OPTION=VALUE", 0,
+     "Add/override an option for a translator in volume file with specified"
+     " value"},
+    {"read-only", ARGP_READ_ONLY_KEY, 0, 0,
+     "Mount the filesystem in 'read-only' mode"},
+    {"acl", ARGP_ACL_KEY, 0, 0, "Mount the filesystem with POSIX ACL support"},
+    {"selinux", ARGP_SELINUX_KEY, 0, 0,
+     "Enable SELinux label (extended attributes) support on inodes"},
+    {"capability", ARGP_CAPABILITY_KEY, 0, 0,
+     "Enable Capability (extended attributes) support on inodes"},
+    {"subdir-mount", ARGP_SUBDIR_MOUNT_KEY, "SUBDIR-PATH", 0,
+     "Mount subdirectory given [default: NULL]"},
+
+    {"print-netgroups", ARGP_PRINT_NETGROUPS, "NETGROUP-FILE", 0,
+     "Validate the netgroups file and print it out"},
+    {"print-exports", ARGP_PRINT_EXPORTS, "EXPORTS-FILE", 0,
+     "Validate the exports file and print it out"},
+    {"print-xlatordir", ARGP_PRINT_XLATORDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print xlator directory path"},
+    {"print-statedumpdir", ARGP_PRINT_STATEDUMPDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print directory path in which statedumps shall be generated"},
+    {"print-logdir", ARGP_PRINT_LOGDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print path of default log directory"},
+    {"print-libexecdir", ARGP_PRINT_LIBEXECDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print path of default libexec directory"},
+
+    {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS, "0",
+     OPTION_HIDDEN, "Maximum number of attempts to fetch the volfile"},
+    {"aux-gfid-mount", ARGP_AUX_GFID_MOUNT_KEY, 0, 0,
+     "Enable access to filesystem through gfid directly"},
+    {"enable-ino32", ARGP_INODE32_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Use 32-bit inodes when mounting to workaround broken applications"
+     "that don't support 64-bit inodes"},
+    {"worm", ARGP_WORM_KEY, 0, 0, "Mount the filesystem in 'worm' mode"},
+    {"mac-compat", ARGP_MAC_COMPAT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Provide stubs for attributes needed for seamless operation on Macs "
 #ifdef GF_DARWIN_HOST_OS
-         "[default: \"on\" on client side, else \"off\"]"
+     "[default: \"on\" on client side, else \"off\"]"
 #else
-         "[default: \"off\"]"
+     "[default: \"off\"]"
 #endif
-        },
-        {"brick-name", ARGP_BRICK_NAME_KEY, "BRICK-NAME", OPTION_HIDDEN,
-         "Brick name to be registered with Gluster portmapper" },
-        {"brick-port", ARGP_BRICK_PORT_KEY, "BRICK-PORT", OPTION_HIDDEN,
-         "Brick Port to be registered with Gluster portmapper" },
-	{"fopen-keep-cache", ARGP_FOPEN_KEEP_CACHE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-	 "Do not purge the cache on file open"},
-        {"global-timer-wheel", ARGP_GLOBAL_TIMER_WHEEL, "BOOL",
-         OPTION_ARG_OPTIONAL, "Instantiate process global timer-wheel"},
-
-        {0, 0, 0, 0, "Fuse options:"},
-        {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Use direct I/O mode in fuse kernel module"
-         " [default: \"off\" if big writes are supported, else "
-         "\"on\" for fds not opened with O_RDONLY]"},
-        {"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
-         "Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
-        {"negative-timeout", ARGP_NEGATIVE_TIMEOUT_KEY, "SECONDS", 0,
-         "Set negative timeout to SECONDS in fuse kernel module [default: 0]"},
-        {"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
-         "Set attribute timeout to SECONDS for inodes in fuse kernel module "
-         "[default: 1]"},
-	{"gid-timeout", ARGP_GID_TIMEOUT_KEY, "SECONDS", 0,
-	 "Set auxiliary group list timeout to SECONDS for fuse translator "
-	 "[default: 300]"},
-        {"resolve-gids", ARGP_RESOLVE_GIDS_KEY, 0, 0,
-         "Resolve all auxiliary groups in fuse translator (max 32 otherwise)"},
-	{"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0,
-	 "Set fuse module's background queue length to N "
-	 "[default: 64]"},
-	{"congestion-threshold", ARGP_FUSE_CONGESTION_THRESHOLD_KEY, "N", 0,
-	 "Set fuse module's congestion threshold to N "
-	 "[default: 48]"},
+    },
+    {"brick-name", ARGP_BRICK_NAME_KEY, "BRICK-NAME", OPTION_HIDDEN,
+     "Brick name to be registered with Gluster portmapper"},
+    {"brick-port", ARGP_BRICK_PORT_KEY, "BRICK-PORT", OPTION_HIDDEN,
+     "Brick Port to be registered with Gluster portmapper"},
+    {"fopen-keep-cache", ARGP_FOPEN_KEEP_CACHE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Do not purge the cache on file open [default: false]"},
+    {"global-timer-wheel", ARGP_GLOBAL_TIMER_WHEEL, "BOOL", OPTION_ARG_OPTIONAL,
+     "Instantiate process global timer-wheel"},
+    {"thin-client", ARGP_THIN_CLIENT_KEY, 0, 0,
+     "Enables thin mount and connects via gfproxyd daemon"},
+    {"global-threading", ARGP_GLOBAL_THREADING_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Use the global thread pool instead of io-threads"},
+    {0, 0, 0, 0, "Fuse options:"},
+    {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL|auto",
+     OPTION_ARG_OPTIONAL, "Specify direct I/O strategy [default: \"auto\"]"},
+    {"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
+     "Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
+    {"negative-timeout", ARGP_NEGATIVE_TIMEOUT_KEY, "SECONDS", 0,
+     "Set negative timeout to SECONDS in fuse kernel module [default: 0]"},
+    {"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
+     "Set attribute timeout to SECONDS for inodes in fuse kernel module "
+     "[default: 1]"},
+    {"gid-timeout", ARGP_GID_TIMEOUT_KEY, "SECONDS", 0,
+     "Set auxiliary group list timeout to SECONDS for fuse translator "
+     "[default: 300]"},
+    {"resolve-gids", ARGP_RESOLVE_GIDS_KEY, 0, 0,
+     "Resolve all auxiliary groups in fuse translator (max 32 otherwise)"},
+    {"lru-limit", ARGP_FUSE_LRU_LIMIT_KEY, "N", 0,
+     "Set fuse module's limit for number of inodes kept in LRU list to N "
+     "[default: 65536]"},
+    {"invalidate-limit", ARGP_FUSE_INVALIDATE_LIMIT_KEY, "N", 0,
+     "Suspend inode invalidations implied by 'lru-limit' if the number of "
+     "outstanding invalidations reaches N"},
+    {"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0,
+     "Set fuse module's background queue length to N "
+     "[default: 64]"},
+    {"congestion-threshold", ARGP_FUSE_CONGESTION_THRESHOLD_KEY, "N", 0,
+     "Set fuse module's congestion threshold to N "
+     "[default: 48]"},
 #ifdef GF_LINUX_HOST_OS
-        {"oom-score-adj", ARGP_OOM_SCORE_ADJ_KEY, "INTEGER", 0,
-         "Set oom_score_adj value for process"
-         "[default: 0]"},
+    {"oom-score-adj", ARGP_OOM_SCORE_ADJ_KEY, "INTEGER", 0,
+     "Set oom_score_adj value for process"
+     "[default: 0]"},
 #endif
-        {"client-pid", ARGP_CLIENT_PID_KEY, "PID", OPTION_HIDDEN,
-         "client will authenticate itself with process id PID to server"},
-        {"no-root-squash", ARGP_FUSE_NO_ROOT_SQUASH_KEY, "BOOL",
-         OPTION_ARG_OPTIONAL, "disable/enable root squashing for the trusted "
-         "client"},
-        {"user-map-root", ARGP_USER_MAP_ROOT_KEY, "USER", OPTION_HIDDEN,
-         "replace USER with root in messages"},
-        {"dump-fuse", ARGP_DUMP_FUSE_KEY, "PATH", 0,
-         "Dump fuse traffic to PATH"},
-        {"volfile-check", ARGP_VOLFILE_CHECK_KEY, 0, 0,
-         "Enable strict volume file checking"},
-        {"no-mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN,
-         "disable internal memory accounting"},
-        {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN,
-         "Extra mount options to pass to FUSE"},
-        {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Use readdirp mode in fuse kernel module"
-         " [default: \"yes\"]"},
-        {"secure-mgmt", ARGP_SECURE_MGMT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Override default for secure (SSL) management connections"},
-        {"localtime-logging", ARGP_LOCALTIME_LOGGING_KEY, 0, 0,
-         "Enable localtime logging"},
-        {"event-history", ARGP_FUSE_EVENT_HISTORY_KEY, "BOOL",
-         OPTION_ARG_OPTIONAL, "disable/enable fuse event-history"},
-        {0, 0, 0, 0, "Miscellaneous Options:"},
-        {0, }
-};
-
-
-static struct argp argp = { gf_options, parse_opts, argp_doc, gf_doc };
-
-
-int glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx);
-int glusterfs_volumes_init (glusterfs_ctx_t *ctx);
-int glusterfs_mgmt_init (glusterfs_ctx_t *ctx);
-int glusterfs_listener_init (glusterfs_ctx_t *ctx);
-int glusterfs_listener_stop (glusterfs_ctx_t *ctx);
+    {"client-pid", ARGP_CLIENT_PID_KEY, "PID", OPTION_HIDDEN,
+     "client will authenticate itself with process id PID to server"},
+    {"no-root-squash", ARGP_FUSE_NO_ROOT_SQUASH_KEY, "BOOL",
+     OPTION_ARG_OPTIONAL,
+     "disable/enable root squashing for the trusted "
+     "client"},
+    {"user-map-root", ARGP_USER_MAP_ROOT_KEY, "USER", OPTION_HIDDEN,
+     "replace USER with root in messages"},
+    {"dump-fuse", ARGP_DUMP_FUSE_KEY, "PATH", 0, "Dump fuse traffic to PATH"},
+    {"volfile-check", ARGP_VOLFILE_CHECK_KEY, 0, 0,
+     "Enable strict volume file checking"},
+    {"no-mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN,
+     "disable internal memory accounting"},
+    {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN,
+     "Extra mount options to pass to FUSE"},
+    {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Use readdirp mode in fuse kernel module"
+     " [default: \"yes\"]"},
+    {"secure-mgmt", ARGP_SECURE_MGMT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Override default for secure (SSL) management connections"},
+    {"localtime-logging", ARGP_LOCALTIME_LOGGING_KEY, 0, 0,
+     "Enable localtime logging"},
+    {"process-name", ARGP_PROCESS_NAME_KEY, "PROCESS-NAME", OPTION_HIDDEN,
+     "option to specify the process type"},
+    {"event-history", ARGP_FUSE_EVENT_HISTORY_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "disable/enable fuse event-history"},
+    {"reader-thread-count", ARGP_READER_THREAD_COUNT_KEY, "INTEGER",
+     OPTION_ARG_OPTIONAL, "set fuse reader thread count"},
+    {"kernel-writeback-cache", ARGP_KERNEL_WRITEBACK_CACHE_KEY, "BOOL",
+     OPTION_ARG_OPTIONAL, "enable fuse in-kernel writeback cache"},
+    {"attr-times-granularity", ARGP_ATTR_TIMES_GRANULARITY_KEY, "NS",
+     OPTION_ARG_OPTIONAL,
+     "declare supported granularity of file attribute"
+     " times in nanoseconds"},
+    {"fuse-flush-handle-interrupt", ARGP_FUSE_FLUSH_HANDLE_INTERRUPT_KEY,
+     "BOOL", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
+     "handle interrupt in fuse FLUSH handler"},
+    {"auto-invalidation", ARGP_FUSE_AUTO_INVAL_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "controls whether fuse-kernel can auto-invalidate "
+     "attribute, dentry and page-cache. "
+     "Disable this only if same files/directories are not accessed across "
+     "two different mounts concurrently [default: \"on\"]"},
+    {"fuse-dev-eperm-ratelimit-ns", ARGP_FUSE_DEV_EPERM_RATELIMIT_NS_KEY,
+     "OPTIONS", OPTION_HIDDEN,
+     "rate limit reading from fuse device upon EPERM failure"},
+    {"brick-mux", ARGP_BRICK_MUX_KEY, 0, 0, "Enable brick mux. "},
+    {0, 0, 0, 0, "Miscellaneous Options:"},
+    {
+        0,
+    }};
+
+static struct argp argp = {gf_options, parse_opts, argp_doc, gf_doc};
+
+int
+glusterfs_pidfile_cleanup(glusterfs_ctx_t *ctx);
+int
+glusterfs_volumes_init(glusterfs_ctx_t *ctx);
+int
+glusterfs_mgmt_init(glusterfs_ctx_t *ctx);
+int
+glusterfs_listener_init(glusterfs_ctx_t *ctx);
 
+#define DICT_SET_VAL(method, dict, key, val, msgid)                            \
+    if (method(dict, key, val)) {                                              \
+        gf_smsg("glusterfsd", GF_LOG_ERROR, 0, msgid, "key=%s", key);          \
+        goto err;                                                              \
+    }
 
 static int
-set_fuse_mount_options (glusterfs_ctx_t *ctx, dict_t *options)
+set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options)
 {
-        int              ret = 0;
-        cmd_args_t      *cmd_args = NULL;
-        char            *mount_point = NULL;
-        char            cwd[PATH_MAX] = {0,};
-
-        cmd_args = &ctx->cmd_args;
-
-        /* Check if mount-point is absolute path,
-         * if not convert to absolute path by concating with CWD
-         */
-        if (cmd_args->mount_point[0] != '/') {
-                if (getcwd (cwd, PATH_MAX) != NULL) {
-                        ret = gf_asprintf (&mount_point, "%s/%s", cwd,
-                                           cmd_args->mount_point);
-                        if (ret == -1) {
-                                gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                        glusterfsd_msg_1);
-                                goto err;
-                        }
-                } else {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                glusterfsd_msg_2);
-                        goto err;
-                }
-        } else
-                mount_point = gf_strdup (cmd_args->mount_point);
-
-        ret = dict_set_dynstr (options, ZR_MOUNTPOINT_OPT, mount_point);
-        if (ret < 0) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3);
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    char *mount_point = NULL;
+    char cwd[PATH_MAX] = {
+        0,
+    };
+
+    cmd_args = &ctx->cmd_args;
+
+    /* Check if mount-point is absolute path,
+     * if not convert to absolute path by concatenating with CWD
+     */
+    if (cmd_args->mount_point[0] != '/') {
+        if (getcwd(cwd, PATH_MAX) != NULL) {
+            ret = gf_asprintf(&mount_point, "%s/%s", cwd,
+                              cmd_args->mount_point);
+            if (ret == -1) {
+                gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_1,
+                        "gf_asprintf failed", NULL);
                 goto err;
-        }
-
-        if (cmd_args->fuse_attribute_timeout >= 0) {
-                ret = dict_set_double (options, ZR_ATTR_TIMEOUT_OPT,
-                                       cmd_args->fuse_attribute_timeout);
-
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, errno, 
-                                glusterfsd_msg_4, ZR_ATTR_TIMEOUT_OPT);
-                        goto err;
-                }
-        }
-
-        if (cmd_args->fuse_entry_timeout >= 0) {
-                ret = dict_set_double (options, ZR_ENTRY_TIMEOUT_OPT,
-                                       cmd_args->fuse_entry_timeout);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                ZR_ENTRY_TIMEOUT_OPT);
-                        goto err;
-                }
-        }
-
-        if (cmd_args->fuse_negative_timeout >= 0) {
-                ret = dict_set_double (options, ZR_NEGATIVE_TIMEOUT_OPT,
-                                       cmd_args->fuse_negative_timeout);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                ZR_NEGATIVE_TIMEOUT_OPT);
-                        goto err;
-                }
-        }
-
-        if (cmd_args->client_pid_set) {
-                ret = dict_set_int32 (options, "client-pid",
-                                      cmd_args->client_pid);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "client-pid");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->uid_map_root) {
-                ret = dict_set_int32 (options, "uid-map-root",
-                                      cmd_args->uid_map_root);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "uid-map-root");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->volfile_check) {
-                ret = dict_set_int32 (options, ZR_STRICT_VOLFILE_CHECK,
-                                      cmd_args->volfile_check);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                ZR_STRICT_VOLFILE_CHECK);
-                        goto err;
-                }
-        }
-
-        if (cmd_args->dump_fuse) {
-                ret = dict_set_static_ptr (options, ZR_DUMP_FUSE,
-                                           cmd_args->dump_fuse);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                ZR_DUMP_FUSE);
-                        goto err;
-                }
-        }
-
-        if (cmd_args->acl) {
-                ret = dict_set_static_ptr (options, "acl", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "acl");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->selinux) {
-                ret = dict_set_static_ptr (options, "selinux", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "selinux");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->capability) {
-                ret = dict_set_static_ptr (options, "capability", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "capability");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->aux_gfid_mount) {
-                ret = dict_set_static_ptr (options, "virtual-gfid-access",
-                                           "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "aux-gfid-mount");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->enable_ino32) {
-                ret = dict_set_static_ptr (options, "enable-ino32", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "enable-ino32");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->read_only) {
-                ret = dict_set_static_ptr (options, "read-only", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "read-only");
-                        goto err;
-                }
-        }
-
-	switch (cmd_args->fopen_keep_cache) {
-	case GF_OPTION_ENABLE:
-		ret = dict_set_static_ptr(options, "fopen-keep-cache",
-			"on");
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-				"fopen-keep-cache");
-			goto err;
-		}
-		break;
-	case GF_OPTION_DISABLE:
-		ret = dict_set_static_ptr(options, "fopen-keep-cache",
-			"off");
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-				"fopen-keep-cache");
-			goto err;
-		}
-		break;
-        case GF_OPTION_DEFERRED: /* default */
+            }
+        } else {
+            gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_2,
+                    "getcwd failed", NULL);
+            goto err;
+        }
+
+    } else {
+        mount_point = gf_strdup(cmd_args->mount_point);
+    }
+    DICT_SET_VAL(dict_set_dynstr_sizen, options, ZR_MOUNTPOINT_OPT, mount_point,
+                 glusterfsd_msg_3);
+
+    if (cmd_args->fuse_attribute_timeout >= 0) {
+        DICT_SET_VAL(dict_set_double, options, ZR_ATTR_TIMEOUT_OPT,
+                     cmd_args->fuse_attribute_timeout, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->fuse_entry_timeout >= 0) {
+        DICT_SET_VAL(dict_set_double, options, ZR_ENTRY_TIMEOUT_OPT,
+                     cmd_args->fuse_entry_timeout, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->fuse_negative_timeout >= 0) {
+        DICT_SET_VAL(dict_set_double, options, ZR_NEGATIVE_TIMEOUT_OPT,
+                     cmd_args->fuse_negative_timeout, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->client_pid_set) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "client-pid",
+                     cmd_args->client_pid, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->uid_map_root) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "uid-map-root",
+                     cmd_args->uid_map_root, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->volfile_check) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, ZR_STRICT_VOLFILE_CHECK,
+                     cmd_args->volfile_check, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->dump_fuse) {
+        DICT_SET_VAL(dict_set_static_ptr, options, ZR_DUMP_FUSE,
+                     cmd_args->dump_fuse, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->acl) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "acl", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->selinux) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "selinux", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->capability) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "capability", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->aux_gfid_mount) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "virtual-gfid-access", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->enable_ino32) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "enable-ino32", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->read_only) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "read-only", "on",
+                     glusterfsd_msg_3);
+    }
+
+    switch (cmd_args->fopen_keep_cache) {
+        case GF_OPTION_ENABLE:
+
+            DICT_SET_VAL(dict_set_static_ptr, options, "fopen-keep-cache", "on",
+                         glusterfsd_msg_3);
+            break;
+        case GF_OPTION_DISABLE:
+            DICT_SET_VAL(dict_set_static_ptr, options, "fopen-keep-cache",
+                         "off", glusterfsd_msg_3);
+            break;
         default:
-                gf_msg_debug ("glusterfsd", 0, "fopen-keep-cache mode %d",
-                              cmd_args->fopen_keep_cache);
-                break;
-	}
-
-	if (cmd_args->gid_timeout_set) {
-		ret = dict_set_int32(options, "gid-timeout",
-			cmd_args->gid_timeout);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "gid-timeout");
-			goto err;
-		}
-	}
-
-        if (cmd_args->resolve_gids) {
-                ret = dict_set_static_ptr (options, "resolve-gids", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "resolve-gids");
-                        goto err;
-                }
-        }
-
-	if (cmd_args->background_qlen) {
-		ret = dict_set_int32 (options, "background-qlen",
-                                      cmd_args->background_qlen);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "background-qlen");
-			goto err;
-		}
-	}
-	if (cmd_args->congestion_threshold) {
-		ret = dict_set_int32 (options, "congestion-threshold",
-                                      cmd_args->congestion_threshold);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "congestion-threshold");
-			goto err;
-		}
-	}
-
-        switch (cmd_args->fuse_direct_io_mode) {
+            gf_msg_debug("glusterfsd", 0, "fopen-keep-cache mode %d",
+                         cmd_args->fopen_keep_cache);
+            break;
+    }
+
+    if (cmd_args->gid_timeout_set) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "gid-timeout",
+                     cmd_args->gid_timeout, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->resolve_gids) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "resolve-gids", "on",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->lru_limit >= 0) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "lru-limit",
+                     cmd_args->lru_limit, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->invalidate_limit >= 0) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "invalidate-limit",
+                     cmd_args->invalidate_limit, glusterfsd_msg_3);
+    }
+
+    if (cmd_args->background_qlen) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "background-qlen",
+                     cmd_args->background_qlen, glusterfsd_msg_3);
+    }
+    if (cmd_args->congestion_threshold) {
+        DICT_SET_VAL(dict_set_int32_sizen, options, "congestion-threshold",
+                     cmd_args->congestion_threshold, glusterfsd_msg_3);
+    }
+
+    switch (cmd_args->fuse_direct_io_mode) {
         case GF_OPTION_DISABLE: /* disable */
-                ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
-                                           "disable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
-                                ZR_DIRECT_IO_OPT);
-                        goto err;
-                }
-                break;
+            DICT_SET_VAL(dict_set_static_ptr, options, ZR_DIRECT_IO_OPT,
+                         "disable", glusterfsd_msg_3);
+            break;
         case GF_OPTION_ENABLE: /* enable */
-                ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
-                                ZR_DIRECT_IO_OPT);
-                        goto err;
-                }
-                break;
-        case GF_OPTION_DEFERRED: /* default */
+            DICT_SET_VAL(dict_set_static_ptr, options, ZR_DIRECT_IO_OPT,
+                         "enable", glusterfsd_msg_3);
+            break;
         default:
-                gf_msg_debug ("glusterfsd", 0, "fuse direct io type %d",
-                              cmd_args->fuse_direct_io_mode);
-                break;
-        }
+            gf_msg_debug("glusterfsd", 0, "fuse direct io type %d",
+                         cmd_args->fuse_direct_io_mode);
+            break;
+    }
 
-        switch (cmd_args->no_root_squash) {
+    switch (cmd_args->no_root_squash) {
         case GF_OPTION_ENABLE: /* enable */
-                ret = dict_set_static_ptr (options, "no-root-squash",
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
-                                "no-root-squash");
-                        goto err;
-                }
-                break;
-        case GF_OPTION_DISABLE: /* disable/default */
+            DICT_SET_VAL(dict_set_static_ptr, options, "no-root-squash",
+                         "enable", glusterfsd_msg_3);
+            break;
         default:
-                ret = dict_set_static_ptr (options, "no-root-squash",
-                                           "disable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
-                                "no-root-squash");
-                        goto err;
-                }
-                gf_msg_debug ("glusterfsd", 0, "fuse no-root-squash mode %d",
-                        cmd_args->no_root_squash);
-                break;
-        }
-
-        if (!cmd_args->no_daemon_mode) {
-                ret = dict_set_static_ptr (options, "sync-to-mount",
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "sync-mtab");
-                        goto err;
-                }
-        }
-
-        if (cmd_args->use_readdirp) {
-                ret = dict_set_str (options, "use-readdirp",
-                                    cmd_args->use_readdirp);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "use-readdirp");
-                        goto err;
-                }
-        }
-        if (cmd_args->event_history) {
-                ret = dict_set_str (options, "event-history",
-                                    cmd_args->event_history);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "event-history");
-                        goto err;
-                }
-        }
-        ret = 0;
+            DICT_SET_VAL(dict_set_static_ptr, options, "no-root-squash",
+                         "disable", glusterfsd_msg_3);
+            gf_msg_debug("glusterfsd", 0, "fuse no-root-squash mode %d",
+                         cmd_args->no_root_squash);
+            break;
+    }
+
+    if (!cmd_args->no_daemon_mode) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "sync-to-mount", "enable",
+                     glusterfsd_msg_3);
+    }
+
+    if (cmd_args->use_readdirp) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "use-readdirp",
+                     cmd_args->use_readdirp, glusterfsd_msg_3);
+    }
+    if (cmd_args->event_history) {
+        ret = dict_set_str(options, "event-history", cmd_args->event_history);
+        DICT_SET_VAL(dict_set_static_ptr, options, "event-history",
+                     cmd_args->event_history, glusterfsd_msg_3);
+    }
+    if (cmd_args->thin_client) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "thin-client", "on",
+                     glusterfsd_msg_3);
+    }
+    if (cmd_args->reader_thread_count) {
+        DICT_SET_VAL(dict_set_uint32, options, "reader-thread-count",
+                     cmd_args->reader_thread_count, glusterfsd_msg_3);
+    }
+
+    DICT_SET_VAL(dict_set_uint32, options, "auto-invalidation",
+                 cmd_args->fuse_auto_inval, glusterfsd_msg_3);
+
+    switch (cmd_args->kernel_writeback_cache) {
+        case GF_OPTION_ENABLE:
+            DICT_SET_VAL(dict_set_static_ptr, options, "kernel-writeback-cache",
+                         "on", glusterfsd_msg_3);
+            break;
+        case GF_OPTION_DISABLE:
+            DICT_SET_VAL(dict_set_static_ptr, options, "kernel-writeback-cache",
+                         "off", glusterfsd_msg_3);
+            break;
+        default:
+            gf_msg_debug("glusterfsd", 0, "kernel-writeback-cache mode %d",
+                         cmd_args->kernel_writeback_cache);
+            break;
+    }
+    if (cmd_args->attr_times_granularity) {
+        DICT_SET_VAL(dict_set_uint32, options, "attr-times-granularity",
+                     cmd_args->attr_times_granularity, glusterfsd_msg_3);
+    }
+    switch (cmd_args->fuse_flush_handle_interrupt) {
+        case GF_OPTION_ENABLE:
+            DICT_SET_VAL(dict_set_static_ptr, options, "flush-handle-interrupt",
+                         "on", glusterfsd_msg_3);
+            break;
+        case GF_OPTION_DISABLE:
+            DICT_SET_VAL(dict_set_static_ptr, options, "flush-handle-interrupt",
+                         "off", glusterfsd_msg_3);
+            break;
+        default:
+            gf_msg_debug("glusterfsd", 0, "fuse-flush-handle-interrupt mode %d",
+                         cmd_args->fuse_flush_handle_interrupt);
+            break;
+    }
+    if (cmd_args->global_threading) {
+        DICT_SET_VAL(dict_set_static_ptr, options, "global-threading", "on",
+                     glusterfsd_msg_3);
+    }
+    if (cmd_args->fuse_dev_eperm_ratelimit_ns) {
+        DICT_SET_VAL(dict_set_uint32, options, "fuse-dev-eperm-ratelimit-ns",
+                     cmd_args->fuse_dev_eperm_ratelimit_ns, glusterfsd_msg_3);
+    }
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-create_fuse_mount (glusterfs_ctx_t *ctx)
+create_fuse_mount(glusterfs_ctx_t *ctx)
 {
-        int              ret = 0;
-        cmd_args_t      *cmd_args = NULL;
-        xlator_t        *master = NULL;
-
-        cmd_args = &ctx->cmd_args;
-
-        if (!cmd_args->mount_point) {
-                gf_msg_trace ("glusterfsd", 0,
-                              "mount point not found, not a client process");
-                return 0;
-        }
-
-        if (ctx->process_mode != GF_CLIENT_PROCESS) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7);
-                return -1;
-        }
-
-        master = GF_CALLOC (1, sizeof (*master),
-                            gfd_mt_xlator_t);
-        if (!master)
-                goto err;
-
-        master->name = gf_strdup ("fuse");
-        if (!master->name)
-                goto err;
-
-        if (xlator_set_type (master, "mount/fuse") == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8,
-                        cmd_args->mount_point);
-                goto err;
-        }
-
-        master->ctx      = ctx;
-        master->options  = get_new_dict ();
-        if (!master->options)
-                goto err;
-
-        ret = set_fuse_mount_options (ctx, master->options);
-        if (ret)
-                goto err;
-
-        if (cmd_args->fuse_mountopts) {
-                ret = dict_set_static_ptr (master->options, ZR_FUSE_MOUNTOPTS,
-                                           cmd_args->fuse_mountopts);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                ZR_FUSE_MOUNTOPTS);
-                        goto err;
-                }
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    xlator_t *master = NULL;
+
+    cmd_args = &ctx->cmd_args;
+    if (!cmd_args->mount_point) {
+        gf_msg_trace("glusterfsd", 0,
+                     "mount point not found, not a client process");
+        return 0;
+    }
+
+    if (ctx->process_mode != GF_CLIENT_PROCESS) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7, NULL);
+        return -1;
+    }
+
+    master = GF_CALLOC(1, sizeof(*master), gfd_mt_xlator_t);
+    if (!master)
+        goto err;
+
+    master->name = gf_strdup("fuse");
+    if (!master->name)
+        goto err;
+
+    if (xlator_set_type(master, "mount/fuse") == -1) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8,
+                "MOUNT-POINT=%s", cmd_args->mount_point, NULL);
+        goto err;
+    }
+
+    master->ctx = ctx;
+    master->options = dict_new();
+    if (!master->options)
+        goto err;
+
+    ret = set_fuse_mount_options(ctx, master->options);
+    if (ret)
+        goto err;
+
+    if (cmd_args->fuse_mountopts) {
+        ret = dict_set_static_ptr(master->options, ZR_FUSE_MOUNTOPTS,
+                                  cmd_args->fuse_mountopts);
+        if (ret < 0) {
+            gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3,
+                    ZR_FUSE_MOUNTOPTS, NULL);
+            goto err;
         }
+    }
 
-        ret = xlator_init (master);
-        if (ret) {
-                gf_msg_debug ("glusterfsd", 0,
-                              "failed to initialize fuse translator");
-                goto err;
-        }
+    ret = xlator_init(master);
+    if (ret) {
+        gf_msg_debug("glusterfsd", 0, "failed to initialize fuse translator");
+        goto err;
+    }
 
-        ctx->master = master;
+    ctx->master = master;
 
-        return 0;
+    return 0;
 
 err:
-        if (master) {
-                xlator_destroy (master);
-        }
+    if (master) {
+        xlator_destroy(master);
+    }
 
-        return 1;
+    return 1;
 }
 
-
 static FILE *
-get_volfp (glusterfs_ctx_t *ctx)
+get_volfp(glusterfs_ctx_t *ctx)
 {
-        int          ret = 0;
-        cmd_args_t  *cmd_args = NULL;
-        FILE        *specfp = NULL;
-        struct stat  statbuf;
+    cmd_args_t *cmd_args = NULL;
+    FILE *specfp = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        ret = sys_lstat (cmd_args->volfile, &statbuf);
-        if (ret == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
-                        cmd_args->volfile);
-                return NULL;
-        }
-
-        if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
-                        cmd_args->volfile);
-                return NULL;
-        }
+    if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
+                "volume_file=%s", cmd_args->volfile, NULL);
+        return NULL;
+    }
 
-        gf_msg_debug ("glusterfsd", 0, "loading volume file %s",
-                      cmd_args->volfile);
+    gf_msg_debug("glusterfsd", 0, "loading volume file %s", cmd_args->volfile);
 
-        return specfp;
+    return specfp;
 }
 
 static int
-gf_remember_backup_volfile_server (char *arg)
+gf_remember_backup_volfile_server(char *arg)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        cmd_args_t              *cmd_args = NULL;
-        int                      ret = -1;
-        server_cmdline_t        *server = NULL;
-
-        ctx = glusterfsd_ctx;
-        if (!ctx)
-                goto out;
-        cmd_args = &ctx->cmd_args;
-
-        if(!cmd_args)
-                goto out;
-
-        server = GF_CALLOC (1, sizeof (server_cmdline_t),
-                            gfd_mt_server_cmdline_t);
-        if (!server)
-                goto out;
-
-        INIT_LIST_HEAD(&server->list);
-
-        server->volfile_server = gf_strdup(arg);
-
-        if (!cmd_args->volfile_server) {
-                cmd_args->volfile_server = server->volfile_server;
-                cmd_args->curr_server = server;
-        }
-
-        if (!server->volfile_server) {
-                gf_msg ("glusterfsd", GF_LOG_WARNING, 0, glusterfsd_msg_10,
-                        arg);
-                goto out;
-        }
-
-        list_add_tail (&server->list, &cmd_args->volfile_servers);
-
-        ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+
+    ctx = glusterfsd_ctx;
+    if (!ctx)
+        goto out;
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args)
+        goto out;
+
+    ret = gf_set_volfile_server_common(
+        cmd_args, arg, GF_DEFAULT_VOLFILE_TRANSPORT, GF_DEFAULT_BASE_PORT);
+    if (ret) {
+        gf_log("glusterfs", GF_LOG_ERROR, "failed to set volfile server: %s",
+               strerror(errno));
+    }
 out:
-        if (ret == -1) {
-                if (server) {
-                        GF_FREE (server->volfile_server);
-                        GF_FREE (server);
-                }
-        }
-
-        return ret;
-
+    return ret;
 }
 
 static int
-gf_remember_xlator_option (char *arg)
+gf_remember_xlator_option(char *arg)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        cmd_args_t              *cmd_args  = NULL;
-        xlator_cmdline_option_t *option = NULL;
-        int                      ret = -1;
-        char                    *dot = NULL;
-        char                    *equals = NULL;
-
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
-
-        option = GF_CALLOC (1, sizeof (xlator_cmdline_option_t),
-                            gfd_mt_xlator_cmdline_option_t);
-        if (!option)
-                goto out;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    xlator_cmdline_option_t *option = NULL;
+    int ret = -1;
+    char *dot = NULL;
+    char *equals = NULL;
 
-        INIT_LIST_HEAD (&option->cmd_args);
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
 
-        dot = strchr (arg, '.');
-        if (!dot) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10, arg);
-                goto out;
-        }
+    option = GF_CALLOC(1, sizeof(xlator_cmdline_option_t),
+                       gfd_mt_xlator_cmdline_option_t);
+    if (!option)
+        goto out;
 
-        option->volume = GF_CALLOC ((dot - arg) + 1, sizeof (char),
-                                    gfd_mt_char);
-        if (!option->volume)
-                goto out;
+    INIT_LIST_HEAD(&option->cmd_args);
 
-        strncpy (option->volume, arg, (dot - arg));
+    dot = strchr(arg, '.');
+    if (!dot) {
+        gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL);
+        goto out;
+    }
 
-        equals = strchr (arg, '=');
-        if (!equals) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10, arg);
-                goto out;
-        }
+    option->volume = GF_MALLOC((dot - arg) + 1, gfd_mt_char);
+    if (!option->volume)
+        goto out;
 
-        option->key = GF_CALLOC ((equals - dot) + 1, sizeof (char),
-                                 gfd_mt_char);
-        if (!option->key)
-                goto out;
+    strncpy(option->volume, arg, (dot - arg));
+    option->volume[(dot - arg)] = '\0';
 
-        strncpy (option->key, dot + 1, (equals - dot - 1));
+    equals = strchr(arg, '=');
+    if (!equals) {
+        gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL);
+        goto out;
+    }
 
-        if (!*(equals + 1)) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10, arg);
-                goto out;
-        }
+    option->key = GF_MALLOC((equals - dot) + 1, gfd_mt_char);
+    if (!option->key)
+        goto out;
 
-        option->value = gf_strdup (equals + 1);
+    strncpy(option->key, dot + 1, (equals - dot - 1));
+    option->key[(equals - dot - 1)] = '\0';
 
-        list_add (&option->cmd_args, &cmd_args->xlator_options);
+    if (!*(equals + 1)) {
+        gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL);
+        goto out;
+    }
 
-        ret = 0;
+    option->value = gf_strdup(equals + 1);
+
+    list_add(&option->cmd_args, &cmd_args->xlator_options);
+
+    ret = 0;
 out:
-        if (ret == -1) {
-                if (option) {
-                        GF_FREE (option->volume);
-                        GF_FREE (option->key);
-                        GF_FREE (option->value);
+    if (ret == -1) {
+        if (option) {
+            GF_FREE(option->volume);
+            GF_FREE(option->key);
+            GF_FREE(option->value);
 
-                        GF_FREE (option);
-                }
+            GF_FREE(option);
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 #ifdef GF_LINUX_HOST_OS
 static struct oom_api_info {
-        char *oom_api_file;
-        int32_t oom_min;
-        int32_t oom_max;
+    char *oom_api_file;
+    int32_t oom_min;
+    int32_t oom_max;
 } oom_api_info[] = {
-        { "/proc/self/oom_score_adj", OOM_SCORE_ADJ_MIN, OOM_SCORE_ADJ_MAX },
-        { "/proc/self/oom_adj",       OOM_DISABLE,       OOM_ADJUST_MAX },
-        { NULL, 0, 0 }
-};
-
+    {"/proc/self/oom_score_adj", OOM_SCORE_ADJ_MIN, OOM_SCORE_ADJ_MAX},
+    {"/proc/self/oom_adj", OOM_DISABLE, OOM_ADJUST_MAX},
+    {NULL, 0, 0}};
 
 static struct oom_api_info *
-get_oom_api_info (void)
+get_oom_api_info(void)
 {
-        struct oom_api_info *api = NULL;
+    struct oom_api_info *api = NULL;
 
-        for (api = oom_api_info; api->oom_api_file; api++) {
-                if (sys_access (api->oom_api_file, F_OK) != -1) {
-                        return api;
-                }
+    for (api = oom_api_info; api->oom_api_file; api++) {
+        if (sys_access(api->oom_api_file, F_OK) != -1) {
+            return api;
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 #endif
 
 static error_t
-parse_opts (int key, char *arg, struct argp_state *state)
+parse_opts(int key, char *arg, struct argp_state *state)
 {
-        cmd_args_t          *cmd_args      = NULL;
-        uint32_t             n             = 0;
+    cmd_args_t *cmd_args = NULL;
+    uint32_t n = 0;
 #ifdef GF_LINUX_HOST_OS
-        int32_t              k             = 0;
-        struct oom_api_info *api           = NULL;
+    int32_t k = 0;
+    struct oom_api_info *api = NULL;
 #endif
-        double               d             = 0.0;
-        gf_boolean_t         b             = _gf_false;
-        char                *pwd           = NULL;
-        char                 tmp_buf[2048] = {0,};
-        char                *tmp_str       = NULL;
-        char                *port_str      = NULL;
-        struct passwd       *pw            = NULL;
-        int                  ret           = 0;
-
-        cmd_args = state->input;
-
-        switch (key) {
+    double d = 0.0;
+    gf_boolean_t b = _gf_false;
+    char *pwd = NULL;
+    char *tmp_str = NULL;
+    char *port_str = NULL;
+    struct passwd *pw = NULL;
+    int ret = 0;
+
+    cmd_args = state->input;
+
+    switch (key) {
         case ARGP_VOLFILE_SERVER_KEY:
-                gf_remember_backup_volfile_server (arg);
+            gf_remember_backup_volfile_server(arg);
 
-                break;
+            break;
 
         case ARGP_READ_ONLY_KEY:
-                cmd_args->read_only = 1;
-                break;
+            cmd_args->read_only = 1;
+            break;
 
         case ARGP_ACL_KEY:
-                cmd_args->acl = 1;
-                gf_remember_xlator_option ("*-md-cache.cache-posix-acl=true");
-                break;
+            cmd_args->acl = 1;
+            gf_remember_xlator_option("*-md-cache.cache-posix-acl=true");
+            break;
 
         case ARGP_SELINUX_KEY:
-                cmd_args->selinux = 1;
-                gf_remember_xlator_option ("*-md-cache.cache-selinux=true");
-                break;
+            cmd_args->selinux = 1;
+            gf_remember_xlator_option("*-md-cache.cache-selinux=true");
+            break;
 
         case ARGP_CAPABILITY_KEY:
-                cmd_args->capability = 1;
-                break;
+            cmd_args->capability = 1;
+            break;
 
         case ARGP_AUX_GFID_MOUNT_KEY:
-                cmd_args->aux_gfid_mount = 1;
-                break;
+            cmd_args->aux_gfid_mount = 1;
+            break;
 
         case ARGP_INODE32_KEY:
-                cmd_args->enable_ino32 = 1;
-                break;
+            cmd_args->enable_ino32 = 1;
+            break;
 
         case ARGP_WORM_KEY:
-                cmd_args->worm = 1;
-                break;
+            cmd_args->worm = 1;
+            break;
 
         case ARGP_PRINT_NETGROUPS:
-                cmd_args->print_netgroups = arg;
-                break;
+            cmd_args->print_netgroups = arg;
+            break;
 
         case ARGP_PRINT_EXPORTS:
-                cmd_args->print_exports = arg;
-                break;
+            cmd_args->print_exports = arg;
+            break;
 
-        case ARGP_MAC_COMPAT_KEY:
-                if (!arg)
-                        arg = "on";
+        case ARGP_PRINT_XLATORDIR_KEY:
+            cmd_args->print_xlatordir = _gf_true;
+            break;
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->mac_compat = b;
+        case ARGP_PRINT_STATEDUMPDIR_KEY:
+            cmd_args->print_statedumpdir = _gf_true;
+            break;
 
-                        break;
-                }
+        case ARGP_PRINT_LOGDIR_KEY:
+            cmd_args->print_logdir = _gf_true;
+            break;
+
+        case ARGP_PRINT_LIBEXECDIR_KEY:
+            cmd_args->print_libexecdir = _gf_true;
+            break;
+
+        case ARGP_MAC_COMPAT_KEY:
+            if (!arg)
+                arg = "on";
+
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->mac_compat = b;
 
-                argp_failure (state, -1, 0,
-                              "invalid value \"%s\" for mac-compat", arg);
                 break;
+            }
+
+            argp_failure(state, -1, 0, "invalid value \"%s\" for mac-compat",
+                         arg);
+            break;
 
         case ARGP_VOLUME_FILE_KEY:
-                GF_FREE (cmd_args->volfile);
-
-                if (arg[0] != '/') {
-                        pwd = getcwd (NULL, PATH_MAX);
-                        if (!pwd) {
-                               argp_failure (state, -1, errno,
-                                            "getcwd failed with error no %d",
-                                             errno);
-                               break;
-                        }
-                        snprintf (tmp_buf, 1024, "%s/%s", pwd, arg);
-                        cmd_args->volfile = gf_strdup (tmp_buf);
-                        free (pwd);
-                } else {
-                        cmd_args->volfile = gf_strdup (arg);
+            GF_FREE(cmd_args->volfile);
+
+            if (arg[0] != '/') {
+                pwd = getcwd(NULL, PATH_MAX);
+                if (!pwd) {
+                    argp_failure(state, -1, errno,
+                                 "getcwd failed with error no %d", errno);
+                    break;
                 }
+                char tmp_buf[1024];
+                snprintf(tmp_buf, sizeof(tmp_buf), "%s/%s", pwd, arg);
+                cmd_args->volfile = gf_strdup(tmp_buf);
+                free(pwd);
+            } else {
+                cmd_args->volfile = gf_strdup(arg);
+            }
 
-                break;
+            break;
 
         case ARGP_LOG_LEVEL_KEY:
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_NONE;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_CRITICAL;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_ERROR;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_WARNING;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_INFO_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_INFO;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_DEBUG;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_TRACE;
-                        break;
-                }
-
-                argp_failure (state, -1, 0, "unknown log level %s", arg);
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_NONE;
                 break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_CRITICAL;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_ERROR;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_WARNING;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_INFO_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_INFO;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_DEBUG;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_TRACE;
+                break;
+            }
+
+            argp_failure(state, -1, 0, "unknown log level %s", arg);
+            break;
 
         case ARGP_LOG_FILE_KEY:
-                cmd_args->log_file = gf_strdup (arg);
-                break;
+            cmd_args->log_file = gf_strdup(arg);
+            break;
 
         case ARGP_VOLFILE_SERVER_PORT_KEY:
-                n = 0;
+            n = 0;
 
-                if (gf_string2uint_base10 (arg, &n) == 0) {
-                        cmd_args->volfile_server_port = n;
-                        break;
-                }
-
-                argp_failure (state, -1, 0,
-                              "unknown volfile server port %s", arg);
+            if (gf_string2uint_base10(arg, &n) == 0) {
+                cmd_args->volfile_server_port = n;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown volfile server port %s", arg);
+            break;
 
         case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
-                cmd_args->volfile_server_transport = gf_strdup (arg);
-                break;
+            cmd_args->volfile_server_transport = gf_strdup(arg);
+            break;
 
         case ARGP_VOLFILE_ID_KEY:
-                cmd_args->volfile_id = gf_strdup (arg);
-                break;
+            cmd_args->volfile_id = gf_strdup(arg);
+            break;
+
+        case ARGP_THIN_CLIENT_KEY:
+            cmd_args->thin_client = _gf_true;
+            break;
+
+        case ARGP_BRICK_MUX_KEY:
+            cmd_args->brick_mux = _gf_true;
+            break;
 
         case ARGP_PID_FILE_KEY:
-                cmd_args->pid_file = gf_strdup (arg);
-                break;
+            cmd_args->pid_file = gf_strdup(arg);
+            break;
 
         case ARGP_SOCK_FILE_KEY:
-                cmd_args->sock_file = gf_strdup (arg);
-                break;
+            cmd_args->sock_file = gf_strdup(arg);
+            break;
 
         case ARGP_NO_DAEMON_KEY:
-                cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
-                break;
+            cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+            break;
 
         case ARGP_RUN_ID_KEY:
-                cmd_args->run_id = gf_strdup (arg);
-                break;
+            cmd_args->run_id = gf_strdup(arg);
+            break;
 
         case ARGP_DEBUG_KEY:
-                cmd_args->debug_mode = ENABLE_DEBUG_MODE;
-                break;
+            cmd_args->debug_mode = ENABLE_DEBUG_MODE;
+            break;
         case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS:
-                cmd_args->max_connect_attempts = 1;
-                break;
+            cmd_args->max_connect_attempts = 1;
+            break;
 
         case ARGP_DIRECT_IO_MODE_KEY:
-                if (!arg)
-                        arg = "on";
+            if (!arg)
+                arg = "on";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->fuse_direct_io_mode = b;
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fuse_direct_io_mode = b;
 
-                        break;
-                }
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown direct I/O mode setting \"%s\"", arg);
+            if (strcmp(arg, "auto") == 0)
                 break;
 
+            argp_failure(state, -1, 0, "unknown direct I/O mode setting \"%s\"",
+                         arg);
+            break;
+
         case ARGP_FUSE_NO_ROOT_SQUASH_KEY:
-                cmd_args->no_root_squash = _gf_true;
-                break;
+            cmd_args->no_root_squash = _gf_true;
+            break;
 
         case ARGP_ENTRY_TIMEOUT_KEY:
-                d = 0.0;
+            d = 0.0;
 
-                gf_string2double (arg, &d);
-                if (!(d < 0.0)) {
-                        cmd_args->fuse_entry_timeout = d;
-                        break;
-                }
-
-                argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
+            gf_string2double(arg, &d);
+            if (!(d < 0.0)) {
+                cmd_args->fuse_entry_timeout = d;
                 break;
+            }
 
-        case ARGP_NEGATIVE_TIMEOUT_KEY:
-                d = 0.0;
+            argp_failure(state, -1, 0, "unknown entry timeout %s", arg);
+            break;
 
-                ret = gf_string2double (arg, &d);
-                if ((ret == 0) && !(d < 0.0)) {
-                        cmd_args->fuse_negative_timeout = d;
-                        break;
-                }
+        case ARGP_NEGATIVE_TIMEOUT_KEY:
+            d = 0.0;
 
-                argp_failure (state, -1, 0, "unknown negative timeout %s", arg);
+            ret = gf_string2double(arg, &d);
+            if ((ret == 0) && !(d < 0.0)) {
+                cmd_args->fuse_negative_timeout = d;
                 break;
+            }
 
-        case ARGP_ATTRIBUTE_TIMEOUT_KEY:
-                d = 0.0;
+            argp_failure(state, -1, 0, "unknown negative timeout %s", arg);
+            break;
 
-                gf_string2double (arg, &d);
-                if (!(d < 0.0)) {
-                        cmd_args->fuse_attribute_timeout = d;
-                        break;
-                }
+        case ARGP_ATTRIBUTE_TIMEOUT_KEY:
+            d = 0.0;
 
-                argp_failure (state, -1, 0,
-                              "unknown attribute timeout %s", arg);
+            gf_string2double(arg, &d);
+            if (!(d < 0.0)) {
+                cmd_args->fuse_attribute_timeout = d;
                 break;
+            }
 
-        case ARGP_CLIENT_PID_KEY:
-                if (gf_string2int (arg, &cmd_args->client_pid) == 0) {
-                        cmd_args->client_pid_set = 1;
-                        break;
-                }
+            argp_failure(state, -1, 0, "unknown attribute timeout %s", arg);
+            break;
 
-                argp_failure (state, -1, 0,
-                              "unknown client pid %s", arg);
+        case ARGP_CLIENT_PID_KEY:
+            if (gf_string2int(arg, &cmd_args->client_pid) == 0) {
+                cmd_args->client_pid_set = 1;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown client pid %s", arg);
+            break;
 
         case ARGP_USER_MAP_ROOT_KEY:
-                pw = getpwnam (arg);
-                if (pw)
-                        cmd_args->uid_map_root = pw->pw_uid;
-                else
-                        argp_failure (state, -1, 0,
-                                      "user %s does not exist", arg);
-                break;
+            pw = getpwnam(arg);
+            if (pw)
+                cmd_args->uid_map_root = pw->pw_uid;
+            else
+                argp_failure(state, -1, 0, "user %s does not exist", arg);
+            break;
 
         case ARGP_VOLFILE_CHECK_KEY:
-                cmd_args->volfile_check = 1;
-                break;
+            cmd_args->volfile_check = 1;
+            break;
 
         case ARGP_VOLUME_NAME_KEY:
-                cmd_args->volume_name = gf_strdup (arg);
-                break;
+            cmd_args->volume_name = gf_strdup(arg);
+            break;
 
         case ARGP_XLATOR_OPTION_KEY:
-                if (gf_remember_xlator_option (arg))
-                        argp_failure (state, -1, 0, "invalid xlator option  %s",
-                                      arg);
+            if (gf_remember_xlator_option(arg))
+                argp_failure(state, -1, 0, "invalid xlator option  %s", arg);
 
-                break;
+            break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
 
         case ARGP_KEY_ARG:
-                if (state->arg_num >= 1)
-                        argp_usage (state);
-
-                cmd_args->mount_point = gf_strdup (arg);
-                break;
+            if (state->arg_num >= 1)
+                argp_usage(state);
+            cmd_args->mount_point = gf_strdup(arg);
+            break;
 
         case ARGP_DUMP_FUSE_KEY:
-                cmd_args->dump_fuse = gf_strdup (arg);
-                break;
+            cmd_args->dump_fuse = gf_strdup(arg);
+            break;
         case ARGP_BRICK_NAME_KEY:
-                cmd_args->brick_name = gf_strdup (arg);
-                break;
+            cmd_args->brick_name = gf_strdup(arg);
+            break;
         case ARGP_BRICK_PORT_KEY:
-                n = 0;
-
-                port_str = strtok_r (arg, ",", &tmp_str);
-                if (gf_string2uint_base10 (port_str, &n) == 0) {
-                        cmd_args->brick_port = n;
-                        port_str = strtok_r (NULL, ",", &tmp_str);
-                        if (port_str) {
-                                if (gf_string2uint_base10 (port_str, &n) == 0)
-                                        cmd_args->brick_port2 = n;
-                                break;
-
-                                argp_failure (state, -1, 0,
-                                              "wrong brick (listen) port %s", arg);
+            n = 0;
+
+            if (arg != NULL) {
+                port_str = strtok_r(arg, ",", &tmp_str);
+                if (gf_string2uint_base10(port_str, &n) == 0) {
+                    cmd_args->brick_port = n;
+                    port_str = strtok_r(NULL, ",", &tmp_str);
+                    if (port_str) {
+                        if (gf_string2uint_base10(port_str, &n) == 0) {
+                            cmd_args->brick_port2 = n;
+                            break;
                         }
-                        break;
+                        argp_failure(state, -1, 0,
+                                     "wrong brick (listen) port %s", arg);
+                    }
+                    break;
                 }
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown brick (listen) port %s", arg);
-                break;
+            argp_failure(state, -1, 0, "unknown brick (listen) port %s", arg);
+            break;
 
         case ARGP_MEM_ACCOUNTING_KEY:
-                /* TODO: it should have got handled much earlier */
-		//gf_mem_acct_enable_set (THIS->ctx);
-                break;
+            /* TODO: it should have got handled much earlier */
+            // gf_mem_acct_enable_set (THIS->ctx);
+            break;
 
-	case ARGP_FOPEN_KEEP_CACHE_KEY:
-                if (!arg)
-                        arg = "on";
+        case ARGP_FOPEN_KEEP_CACHE_KEY:
+            if (!arg)
+                arg = "on";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->fopen_keep_cache = b;
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fopen_keep_cache = b;
 
-                        break;
-                }
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown cache setting \"%s\"", arg);
+            argp_failure(state, -1, 0, "unknown cache setting \"%s\"", arg);
 
-		break;
+            break;
 
         case ARGP_GLOBAL_TIMER_WHEEL:
-                cmd_args->global_timer_wheel = 1;
-                break;
+            cmd_args->global_timer_wheel = 1;
+            break;
 
-	case ARGP_GID_TIMEOUT_KEY:
-		if (!gf_string2int(arg, &cmd_args->gid_timeout)) {
-			cmd_args->gid_timeout_set = _gf_true;
-			break;
-		}
+        case ARGP_GID_TIMEOUT_KEY:
+            if (!gf_string2int(arg, &cmd_args->gid_timeout)) {
+                cmd_args->gid_timeout_set = _gf_true;
+                break;
+            }
 
-		argp_failure(state, -1, 0, "unknown group list timeout %s", arg);
-		break;
+            argp_failure(state, -1, 0, "unknown group list timeout %s", arg);
+            break;
 
         case ARGP_RESOLVE_GIDS_KEY:
-                cmd_args->resolve_gids = 1;
+            cmd_args->resolve_gids = 1;
+            break;
+
+        case ARGP_FUSE_LRU_LIMIT_KEY:
+            if (!gf_string2int32(arg, &cmd_args->lru_limit))
                 break;
 
-        case ARGP_FUSE_BACKGROUND_QLEN_KEY:
-                if (!gf_string2int (arg, &cmd_args->background_qlen))
-                        break;
+            argp_failure(state, -1, 0, "unknown LRU limit option %s", arg);
+            break;
 
-                argp_failure (state, -1, 0,
-                              "unknown background qlen option %s", arg);
+        case ARGP_FUSE_INVALIDATE_LIMIT_KEY:
+            if (!gf_string2int32(arg, &cmd_args->invalidate_limit))
                 break;
-        case ARGP_FUSE_CONGESTION_THRESHOLD_KEY:
-                if (!gf_string2int (arg, &cmd_args->congestion_threshold))
-                        break;
 
-                argp_failure (state, -1, 0,
-                              "unknown congestion threshold option %s", arg);
+            argp_failure(state, -1, 0, "unknown invalidate limit option %s",
+                         arg);
+            break;
+
+        case ARGP_FUSE_BACKGROUND_QLEN_KEY:
+            if (!gf_string2int(arg, &cmd_args->background_qlen))
                 break;
 
+            argp_failure(state, -1, 0, "unknown background qlen option %s",
+                         arg);
+            break;
+        case ARGP_FUSE_CONGESTION_THRESHOLD_KEY:
+            if (!gf_string2int(arg, &cmd_args->congestion_threshold))
+                break;
+
+            argp_failure(state, -1, 0, "unknown congestion threshold option %s",
+                         arg);
+            break;
+
 #ifdef GF_LINUX_HOST_OS
         case ARGP_OOM_SCORE_ADJ_KEY:
-                k = 0;
+            k = 0;
 
-                api = get_oom_api_info();
-                if (!api)
-                        goto no_oom_api;
+            api = get_oom_api_info();
+            if (!api)
+                goto no_oom_api;
 
-                if (gf_string2int (arg, &k) == 0 &&
-                    k >= api->oom_min && k <= api->oom_max) {
-                        cmd_args->oom_score_adj = gf_strdup (arg);
-                        break;
-                }
+            if (gf_string2int(arg, &k) == 0 && k >= api->oom_min &&
+                k <= api->oom_max) {
+                cmd_args->oom_score_adj = gf_strdup(arg);
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown oom_score_adj value %s", arg);
+            argp_failure(state, -1, 0, "unknown oom_score_adj value %s", arg);
 
-no_oom_api:
-                break;
+        no_oom_api:
+            break;
 #endif
 
         case ARGP_FUSE_MOUNTOPTS_KEY:
-                cmd_args->fuse_mountopts = gf_strdup (arg);
-                break;
+            cmd_args->fuse_mountopts = gf_strdup(arg);
+            break;
 
         case ARGP_FUSE_USE_READDIRP_KEY:
-                if (!arg)
-                        arg = "yes";
-
-                if (gf_string2boolean (arg, &b) == 0) {
-                        if (b) {
-                                cmd_args->use_readdirp = "yes";
-                        } else {
-                                cmd_args->use_readdirp = "no";
-                        }
+            if (!arg)
+                arg = "yes";
 
-                        break;
+            if (gf_string2boolean(arg, &b) == 0) {
+                if (b) {
+                    cmd_args->use_readdirp = "yes";
+                } else {
+                    cmd_args->use_readdirp = "no";
                 }
 
-                argp_failure (state, -1, 0,
-                              "unknown use-readdirp setting \"%s\"", arg);
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown use-readdirp setting \"%s\"",
+                         arg);
+            break;
 
         case ARGP_LOGGER:
-                if (strcasecmp (arg, GF_LOGGER_GLUSTER_LOG) == 0)
-                        cmd_args->logger = gf_logger_glusterlog;
-                else if (strcasecmp (arg, GF_LOGGER_SYSLOG) == 0)
-                        cmd_args->logger = gf_logger_syslog;
-                else
-                        argp_failure (state, -1, 0, "unknown logger %s", arg);
+            if (strcasecmp(arg, GF_LOGGER_GLUSTER_LOG) == 0)
+                cmd_args->logger = gf_logger_glusterlog;
+            else if (strcasecmp(arg, GF_LOGGER_SYSLOG) == 0)
+                cmd_args->logger = gf_logger_syslog;
+            else
+                argp_failure(state, -1, 0, "unknown logger %s", arg);
 
-                break;
+            break;
 
         case ARGP_LOG_FORMAT:
-                if (strcasecmp (arg, GF_LOG_FORMAT_NO_MSG_ID) == 0)
-                        cmd_args->log_format = gf_logformat_traditional;
-                else if (strcasecmp (arg, GF_LOG_FORMAT_WITH_MSG_ID) == 0)
-                        cmd_args->log_format = gf_logformat_withmsgid;
-                else
-                        argp_failure (state, -1, 0, "unknown log format %s",
-                                      arg);
+            if (strcasecmp(arg, GF_LOG_FORMAT_NO_MSG_ID) == 0)
+                cmd_args->log_format = gf_logformat_traditional;
+            else if (strcasecmp(arg, GF_LOG_FORMAT_WITH_MSG_ID) == 0)
+                cmd_args->log_format = gf_logformat_withmsgid;
+            else
+                argp_failure(state, -1, 0, "unknown log format %s", arg);
 
-                break;
+            break;
 
         case ARGP_LOG_BUF_SIZE:
-                if (gf_string2uint32 (arg, &cmd_args->log_buf_size)) {
-                        argp_failure (state, -1, 0,
-                                      "unknown log buf size option %s", arg);
-                } else if (cmd_args->log_buf_size > GF_LOG_LRU_BUFSIZE_MAX) {
-                        argp_failure (state, -1, 0,
-                                      "Invalid log buf size %s. "
-                                      "Valid range: ["
-                                      GF_LOG_LRU_BUFSIZE_MIN_STR","
-                                      GF_LOG_LRU_BUFSIZE_MAX_STR"]", arg);
-                }
-
-                break;
+            if (gf_string2uint32(arg, &cmd_args->log_buf_size)) {
+                argp_failure(state, -1, 0, "unknown log buf size option %s",
+                             arg);
+            } else if (cmd_args->log_buf_size > GF_LOG_LRU_BUFSIZE_MAX) {
+                argp_failure(state, -1, 0,
+                             "Invalid log buf size %s. "
+                             "Valid range: [" GF_LOG_LRU_BUFSIZE_MIN_STR
+                             "," GF_LOG_LRU_BUFSIZE_MAX_STR "]",
+                             arg);
+            }
+
+            break;
 
         case ARGP_LOG_FLUSH_TIMEOUT:
-                if (gf_string2uint32 (arg, &cmd_args->log_flush_timeout)) {
-                        argp_failure (state, -1, 0,
-                                "unknown log flush timeout option %s", arg);
-                } else if ((cmd_args->log_flush_timeout <
-                            GF_LOG_FLUSH_TIMEOUT_MIN) ||
-                           (cmd_args->log_flush_timeout >
-                            GF_LOG_FLUSH_TIMEOUT_MAX)) {
-                            argp_failure (state, -1, 0,
-                                          "Invalid log flush timeout %s. "
-                                          "Valid range: ["
-                                          GF_LOG_FLUSH_TIMEOUT_MIN_STR","
-                                          GF_LOG_FLUSH_TIMEOUT_MAX_STR"]", arg);
-                }
-
-                break;
+            if (gf_string2uint32(arg, &cmd_args->log_flush_timeout)) {
+                argp_failure(state, -1, 0,
+                             "unknown log flush timeout option %s", arg);
+            } else if ((cmd_args->log_flush_timeout <
+                        GF_LOG_FLUSH_TIMEOUT_MIN) ||
+                       (cmd_args->log_flush_timeout >
+                        GF_LOG_FLUSH_TIMEOUT_MAX)) {
+                argp_failure(state, -1, 0,
+                             "Invalid log flush timeout %s. "
+                             "Valid range: [" GF_LOG_FLUSH_TIMEOUT_MIN_STR
+                             "," GF_LOG_FLUSH_TIMEOUT_MAX_STR "]",
+                             arg);
+            }
+
+            break;
 
         case ARGP_SECURE_MGMT_KEY:
-                if (!arg)
-                        arg = "yes";
-
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->secure_mgmt = b ? 1 : 0;
-                        break;
-                }
+            if (!arg)
+                arg = "yes";
 
-                argp_failure (state, -1, 0,
-                              "unknown secure-mgmt setting \"%s\"", arg);
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->secure_mgmt = b ? 1 : 0;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown secure-mgmt setting \"%s\"",
+                         arg);
+            break;
 
         case ARGP_LOCALTIME_LOGGING_KEY:
-                cmd_args->localtime_logging = 1;
-                break;
+            cmd_args->localtime_logging = 1;
+            break;
+        case ARGP_PROCESS_NAME_KEY:
+            cmd_args->process_name = gf_strdup(arg);
+            break;
         case ARGP_SUBDIR_MOUNT_KEY:
-                if (arg[0] != '/') {
-                        argp_failure (state, -1, 0,
-                                      "expect '/%s', provided just \"%s\"", arg, arg);
-                        break;
-                }
-                cmd_args->subdir_mount = gf_strdup (arg);
+            if (arg[0] != '/') {
+                argp_failure(state, -1, 0, "expect '/%s', provided just \"%s\"",
+                             arg, arg);
                 break;
+            }
+            cmd_args->subdir_mount = gf_strdup(arg);
+            break;
         case ARGP_FUSE_EVENT_HISTORY_KEY:
-                if (!arg)
-                        arg = "no";
-
-                if (gf_string2boolean (arg, &b) == 0) {
-                        if (b) {
-                                cmd_args->event_history = "yes";
-                        } else {
-                                cmd_args->event_history = "no";
-                        }
+            if (!arg)
+                arg = "no";
 
-                        break;
+            if (gf_string2boolean(arg, &b) == 0) {
+                if (b) {
+                    cmd_args->event_history = "yes";
+                } else {
+                    cmd_args->event_history = "no";
                 }
 
-                argp_failure (state, -1, 0,
-                              "unknown event-history setting \"%s\"", arg);
                 break;
-	}
+            }
+
+            argp_failure(state, -1, 0, "unknown event-history setting \"%s\"",
+                         arg);
+            break;
+        case ARGP_READER_THREAD_COUNT_KEY:
+            if (gf_string2uint32(arg, &cmd_args->reader_thread_count)) {
+                argp_failure(state, -1, 0,
+                             "unknown reader thread count option %s", arg);
+            } else if ((cmd_args->reader_thread_count < 1) ||
+                       (cmd_args->reader_thread_count > 64)) {
+                argp_failure(state, -1, 0,
+                             "Invalid reader thread count %s. "
+                             "Valid range: [\"1, 64\"]",
+                             arg);
+            }
+
+            break;
+
+        case ARGP_KERNEL_WRITEBACK_CACHE_KEY:
+            if (!arg)
+                arg = "yes";
+
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->kernel_writeback_cache = b;
 
-        return 0;
+                break;
+            }
+
+            argp_failure(state, -1, 0,
+                         "unknown kernel writeback cache setting \"%s\"", arg);
+            break;
+        case ARGP_ATTR_TIMES_GRANULARITY_KEY:
+            if (gf_string2uint32(arg, &cmd_args->attr_times_granularity)) {
+                argp_failure(state, -1, 0,
+                             "unknown attribute times granularity option %s",
+                             arg);
+            } else if (cmd_args->attr_times_granularity > 1000000000) {
+                argp_failure(state, -1, 0,
+                             "Invalid attribute times granularity value %s. "
+                             "Valid range: [\"0, 1000000000\"]",
+                             arg);
+            }
+
+            break;
+
+        case ARGP_FUSE_FLUSH_HANDLE_INTERRUPT_KEY:
+            if (!arg)
+                arg = "yes";
+
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fuse_flush_handle_interrupt = b;
+
+                break;
+            }
+
+            argp_failure(state, -1, 0,
+                         "unknown fuse flush handle interrupt setting \"%s\"",
+                         arg);
+            break;
+
+        case ARGP_FUSE_AUTO_INVAL_KEY:
+            if (!arg)
+                arg = "yes";
+
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fuse_auto_inval = b;
+                break;
+            }
+
+            break;
+
+        case ARGP_GLOBAL_THREADING_KEY:
+            if (!arg || (*arg == 0)) {
+                arg = "yes";
+            }
+
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->global_threading = b;
+                break;
+            }
+
+            argp_failure(state, -1, 0,
+                         "Invalid value for global threading \"%s\"", arg);
+            break;
+
+        case ARGP_FUSE_DEV_EPERM_RATELIMIT_NS_KEY:
+            if (gf_string2uint32(arg, &cmd_args->fuse_dev_eperm_ratelimit_ns)) {
+                argp_failure(state, -1, 0,
+                             "Non-numerical value for "
+                             "'fuse-dev-eperm-ratelimit-ns' option %s",
+                             arg);
+            } else if (cmd_args->fuse_dev_eperm_ratelimit_ns > 1000000000) {
+                argp_failure(state, -1, 0,
+                             "Invalid 'fuse-dev-eperm-ratelimit-ns' value %s. "
+                             "Valid range: [\"0, 1000000000\"]",
+                             arg);
+            }
+
+            break;
+    }
+    return 0;
 }
 
 gf_boolean_t
-should_call_fini (glusterfs_ctx_t *ctx, xlator_t *trav)
+should_call_fini(glusterfs_ctx_t *ctx, xlator_t *trav)
 {
-        /* There's nothing to call, so the other checks don't matter. */
-        if (!trav->fini) {
-                return _gf_false;
-        }
-
-        /* This preserves previous behavior in glusterd. */
-        if (ctx->process_mode == GF_GLUSTERD_PROCESS) {
-                return _gf_true;
-        }
+    /* There's nothing to call, so the other checks don't matter. */
+    if (!trav->fini) {
+        return _gf_false;
+    }
 
-        /* This is the only one known to be safe in glusterfsd. */
-        if (!strcmp(trav->type,"experimental/fdl")) {
-                return _gf_true;
-        }
+    /* This preserves previous behavior in glusterd. */
+    if (ctx->process_mode == GF_GLUSTERD_PROCESS) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 void
-cleanup_and_exit (int signum)
+cleanup_and_exit(int signum)
 {
-        glusterfs_ctx_t *ctx      = NULL;
-        xlator_t        *trav     = NULL;
-        xlator_t        *top;
-        xlator_t        *victim;
-        xlator_list_t   **trav_p;
-
-        ctx = glusterfsd_ctx;
-
-        if (!ctx)
-                return;
-
-        /* To take or not to take the mutex here and in the other
-         * signal handler - gf_print_trace() - is the big question here.
-         *
-         * Taking mutex in signal handler would mean that if the process
-         * receives a fatal signal while another thread is holding
-         * ctx->log.log_buf_lock to perhaps log a message in _gf_msg_internal(),
-         * the offending thread hangs on the mutex lock forever without letting
-         * the process exit.
-         *
-         * On the other hand. not taking the mutex in signal handler would cause
-         * it to modify the lru_list of buffered log messages in a racy manner,
-         * corrupt the list and potentially give rise to an unending
-         * cascade of SIGSEGVs and other re-entrancy issues.
-         */
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *trav = NULL;
+    xlator_t *top;
+    xlator_t *victim;
+    xlator_list_t **trav_p;
 
-        gf_log_disable_suppression_before_exit (ctx);
+    ctx = glusterfsd_ctx;
 
-        gf_msg_callingfn ("", GF_LOG_WARNING, 0, glusterfsd_msg_32, signum);
-
-        if (ctx->cleanup_started)
-                return;
+    if (!ctx)
+        return;
 
+    /* To take or not to take the mutex here and in the other
+     * signal handler - gf_print_trace() - is the big question here.
+     *
+     * Taking mutex in signal handler would mean that if the process
+     * receives a fatal signal while another thread is holding
+     * ctx->log.log_buf_lock to perhaps log a message in _gf_msg_internal(),
+     * the offending thread hangs on the mutex lock forever without letting
+     * the process exit.
+     *
+     * On the other hand. not taking the mutex in signal handler would cause
+     * it to modify the lru_list of buffered log messages in a racy manner,
+     * corrupt the list and potentially give rise to an unending
+     * cascade of SIGSEGVs and other re-entrancy issues.
+     */
+
+    gf_log_disable_suppression_before_exit(ctx);
+
+    gf_msg_callingfn("", GF_LOG_WARNING, 0, glusterfsd_msg_32,
+                     "received signum (%d), shutting down", signum);
+
+    if (ctx->cleanup_started)
+        return;
+    pthread_mutex_lock(&ctx->cleanup_lock);
+    {
         ctx->cleanup_started = 1;
 
         /* signout should be sent to all the bricks in case brick mux is enabled
          * and multiple brick instances are attached to this process
          */
         if (ctx->active) {
-                top = ctx->active->first;
-                for (trav_p = &top->children; *trav_p;
-                     trav_p = &(*trav_p)->next) {
-                        victim = (*trav_p)->xlator;
-                        glusterfs_mgmt_pmap_signout (ctx, victim->name);
-                }
+            top = ctx->active->first;
+            for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+                victim = (*trav_p)->xlator;
+                rpc_clnt_mgmt_pmap_signout(ctx, victim->name);
+            }
         } else {
-                glusterfs_mgmt_pmap_signout (ctx, NULL);
+            rpc_clnt_mgmt_pmap_signout(ctx, NULL);
         }
 
         /* below part is a racy code where the rpcsvc object is freed.
          * But in another thread (epoll thread), upon poll error in the
          * socket the transports are cleaned up where again rpcsvc object
          * is accessed (which is already freed by the below function).
-         * Since the process is about to be killed dont execute the function
+         * Since the process is about to be killed don't execute the function
          * below.
          */
         /* if (ctx->listener) { */
@@ -1409,11 +1467,11 @@ cleanup_and_exit (int signum)
          * 'umount' of mount point is done properly */
         trav = ctx->master;
         if (trav && trav->fini) {
-                THIS = trav;
-                trav->fini (trav);
+            THIS = trav;
+            trav->fini(trav);
         }
 
-        glusterfs_pidfile_cleanup (ctx);
+        glusterfs_pidfile_cleanup(ctx);
 
 #if 0
         /* TODO: Properly do cleanup_and_exit(), with synchronization */
@@ -1424,299 +1482,308 @@ cleanup_and_exit (int signum)
         }
 #endif
 
-        /* call fini() of each xlator */
-
-        /*call fini for glusterd xlator */
-        /* TODO : Invoke fini for rest of the xlators */
         trav = NULL;
-        if (ctx->active)
-                trav = ctx->active->top;
-        while (trav) {
-                if (should_call_fini(ctx,trav)) {
-                        THIS = trav;
-                        trav->fini (trav);
-                }
-                trav = trav->next;
-        }
 
+        /* previously we were releasing the cleanup mutex lock before the
+           process exit. As we are releasing the cleanup mutex lock, before
+           the process can exit some other thread which is blocked on
+           cleanup mutex lock is acquiring the cleanup mutex lock and
+           trying to acquire some resources which are already freed as a
+           part of cleanup. To avoid this, we are exiting the process without
+           releasing the cleanup mutex lock. This will not cause any lock
+           related issues as the process which acquired the lock is going down
+         */
         /* NOTE: Only the least significant 8 bits i.e (signum & 255)
            will be available to parent process on calling exit() */
         exit(abs(signum));
+    }
 }
 
-
 static void
-reincarnate (int signum)
+reincarnate(int signum)
 {
-        int                 ret = 0;
-        glusterfs_ctx_t    *ctx = NULL;
-        cmd_args_t         *cmd_args = NULL;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
 
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->volfile_server) {
-                gf_msg ("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11);
-                ret = glusterfs_volfile_fetch (ctx);
-        } else {
-                gf_msg_debug ("glusterfsd", 0,
-                              "Not reloading volume specification file"
-                              " on SIGHUP");
-        }
+    gf_msg_trace("gluster", 0, "received reincarnate request (sig:HUP)");
 
-        /* Also, SIGHUP should do logrotate */
-        gf_log_logrotate (1);
+    if (cmd_args->volfile_server) {
+        gf_smsg("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11, NULL);
+        ret = glusterfs_volfile_fetch(ctx);
+    }
 
-        if (ret < 0)
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12);
+    /* Also, SIGHUP should do logrotate */
+    gf_log_logrotate(1);
 
-        return;
+    if (ret < 0)
+        gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12, NULL);
+
+    return;
 }
 
 void
-emancipate (glusterfs_ctx_t *ctx, int ret)
+emancipate(glusterfs_ctx_t *ctx, int ret)
 {
-        /* break free from the parent */
-        if (ctx->daemon_pipe[1] != -1) {
-                sys_write (ctx->daemon_pipe[1], (void *) &ret, sizeof (ret));
-                sys_close (ctx->daemon_pipe[1]);
-                ctx->daemon_pipe[1] = -1;
-        }
+    /* break free from the parent */
+    if (ctx->daemon_pipe[1] != -1) {
+        sys_write(ctx->daemon_pipe[1], (void *)&ret, sizeof(ret));
+        sys_close(ctx->daemon_pipe[1]);
+        ctx->daemon_pipe[1] = -1;
+    }
 }
 
 static uint8_t
-gf_get_process_mode (char *exec_name)
+gf_get_process_mode(char *exec_name)
 {
-        char *dup_execname = NULL, *base = NULL;
-        uint8_t ret = 0;
+    char *dup_execname = NULL, *base = NULL;
+    uint8_t ret = 0;
 
-        dup_execname = gf_strdup (exec_name);
-        base = basename (dup_execname);
+    dup_execname = gf_strdup(exec_name);
+    base = basename(dup_execname);
 
-        if (!strncmp (base, "glusterfsd", 10)) {
-                ret = GF_SERVER_PROCESS;
-        } else if (!strncmp (base, "glusterd", 8)) {
-                ret = GF_GLUSTERD_PROCESS;
-        } else {
-                ret = GF_CLIENT_PROCESS;
-        }
+    if (!strncmp(base, "glusterfsd", 10)) {
+        ret = GF_SERVER_PROCESS;
+    } else if (!strncmp(base, "glusterd", 8)) {
+        ret = GF_GLUSTERD_PROCESS;
+    } else {
+        ret = GF_CLIENT_PROCESS;
+    }
 
-        GF_FREE (dup_execname);
+    GF_FREE(dup_execname);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t          *cmd_args = NULL;
-        struct rlimit        lim      = {0, };
-        int                  ret      = -1;
-
-        ret = xlator_mem_acct_init (THIS, gfd_mt_end);
-        if (ret != 0) {
-                gf_msg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34);
-                return ret;
-        }
-
-        /* reset ret to -1 so that we don't need to explicitly
-         * set it in all error paths before "goto err"
-         */
-        ret = -1;
-
-        ctx->process_uuid = generate_glusterfs_ctx_id ();
-        if (!ctx->process_uuid) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13);
-                goto out;
-        }
-
-        ctx->page_size  = 128 * GF_UNIT_KB;
-
-        ctx->iobuf_pool = iobuf_pool_new ();
-        if (!ctx->iobuf_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "iobuf");
-                goto out;
-        }
-
-        ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-        if (!ctx->event_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "event");
-                goto out;
-        }
-
-        ctx->pool = GF_CALLOC (1, sizeof (call_pool_t), gfd_mt_call_pool_t);
-        if (!ctx->pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "call");
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&ctx->pool->all_frames);
-        LOCK_INIT (&ctx->pool->lock);
-
-        /* frame_mem_pool size 112 * 4k */
-        ctx->pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096);
-        if (!ctx->pool->frame_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "frame");
-                goto out;
-        }
-        /* stack_mem_pool size 256 * 1024 */
-        ctx->pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024);
-        if (!ctx->pool->stack_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stack");
-                goto out;
-        }
-
-        ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
-        if (!ctx->stub_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stub");
-                goto out;
-        }
-
-        ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
-        if (!ctx->dict_pool)
-                goto out;
-
-        ctx->dict_pair_pool = mem_pool_new (data_pair_t,
-                                            GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
-        if (!ctx->dict_pair_pool)
-                goto out;
-
-        ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
-        if (!ctx->dict_data_pool)
-                goto out;
+    cmd_args_t *cmd_args = NULL;
+    struct rlimit lim = {
+        0,
+    };
+    int ret = -1;
 
-        ctx->logbuf_pool = mem_pool_new (log_buf_t,
-                                         GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
-        if (!ctx->logbuf_pool)
-                goto out;
-
-        pthread_mutex_init (&ctx->notify_lock, NULL);
-        pthread_cond_init (&ctx->notify_cond, NULL);
-
-        ctx->clienttable = gf_clienttable_alloc();
-        if (!ctx->clienttable)
-                goto out;
-
-        cmd_args = &ctx->cmd_args;
-
-        /* parsing command line arguments */
-        cmd_args->log_level = DEFAULT_LOG_LEVEL;
-        cmd_args->logger    = gf_logger_glusterlog;
-        cmd_args->log_format = gf_logformat_withmsgid;
-        cmd_args->log_buf_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
-        cmd_args->log_flush_timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+    if (!ctx)
+        return ret;
 
-        cmd_args->mac_compat = GF_OPTION_DISABLE;
+    ret = xlator_mem_acct_init(THIS, gfd_mt_end);
+    if (ret != 0) {
+        gf_smsg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34, NULL);
+        return ret;
+    }
+
+    /* reset ret to -1 so that we don't need to explicitly
+     * set it in all error paths before "goto err"
+     */
+    ret = -1;
+
+    /* monitoring should be enabled by default */
+    ctx->measure_latency = true;
+
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13, NULL);
+        goto out;
+    }
+
+    ctx->page_size = 128 * GF_UNIT_KB;
+
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "iobuf", NULL);
+        goto out;
+    }
+
+    ctx->event_pool = gf_event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                        STARTING_EVENT_THREADS);
+    if (!ctx->event_pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "event", NULL);
+        goto out;
+    }
+
+    ctx->pool = GF_CALLOC(1, sizeof(call_pool_t), gfd_mt_call_pool_t);
+    if (!ctx->pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "call", NULL);
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&ctx->pool->all_frames);
+    LOCK_INIT(&ctx->pool->lock);
+
+    /* frame_mem_pool size 112 * 4k */
+    ctx->pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096);
+    if (!ctx->pool->frame_mem_pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "frame", NULL);
+        goto out;
+    }
+    /* stack_mem_pool size 256 * 1024 */
+    ctx->pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024);
+    if (!ctx->pool->stack_mem_pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stack", NULL);
+        goto out;
+    }
+
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024);
+    if (!ctx->stub_mem_pool) {
+        gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stub", NULL);
+        goto out;
+    }
+
+    ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
+    if (!ctx->dict_pool)
+        goto out;
+
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t,
+                                       GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
+    if (!ctx->dict_pair_pool)
+        goto out;
+
+    ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
+    if (!ctx->dict_data_pool)
+        goto out;
+
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
+    if (!ctx->logbuf_pool)
+        goto out;
+
+    pthread_mutex_init(&ctx->notify_lock, NULL);
+    pthread_mutex_init(&ctx->cleanup_lock, NULL);
+    pthread_cond_init(&ctx->notify_cond, NULL);
+
+    ctx->clienttable = gf_clienttable_alloc();
+    if (!ctx->clienttable)
+        goto out;
+
+    cmd_args = &ctx->cmd_args;
+
+    /* parsing command line arguments */
+    cmd_args->log_level = DEFAULT_LOG_LEVEL;
+    cmd_args->logger = gf_logger_glusterlog;
+    cmd_args->log_format = gf_logformat_withmsgid;
+    cmd_args->log_buf_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
+    cmd_args->log_flush_timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+
+    cmd_args->mac_compat = GF_OPTION_DISABLE;
 #ifdef GF_DARWIN_HOST_OS
-        /* On Darwin machines, O_APPEND is not handled,
-         * which may corrupt the data
-         */
-        cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
+    /* On Darwin machines, O_APPEND is not handled,
+     * which may corrupt the data
+     */
+    cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
 #else
-        cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
+    cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
 #endif
-        cmd_args->fuse_attribute_timeout = -1;
-        cmd_args->fuse_entry_timeout = -1;
-	cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;
-
-        if (ctx->mem_acct_enable)
-                cmd_args->mem_acct = 1;
-
-        INIT_LIST_HEAD (&cmd_args->xlator_options);
-        INIT_LIST_HEAD (&cmd_args->volfile_servers);
-
-        lim.rlim_cur = RLIM_INFINITY;
-        lim.rlim_max = RLIM_INFINITY;
-        setrlimit (RLIMIT_CORE, &lim);
-
-        ret = 0;
+    cmd_args->fuse_attribute_timeout = -1;
+    cmd_args->fuse_entry_timeout = -1;
+    cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;
+    cmd_args->kernel_writeback_cache = GF_OPTION_DEFERRED;
+    cmd_args->fuse_flush_handle_interrupt = GF_OPTION_DEFERRED;
+
+    if (ctx->mem_acct_enable)
+        cmd_args->mem_acct = 1;
+
+    INIT_LIST_HEAD(&cmd_args->xlator_options);
+    INIT_LIST_HEAD(&cmd_args->volfile_servers);
+    ctx->pxl_count = 0;
+    pthread_mutex_init(&ctx->fd_lock, NULL);
+    pthread_cond_init(&ctx->fd_cond, NULL);
+    INIT_LIST_HEAD(&ctx->janitor_fds);
+
+    lim.rlim_cur = RLIM_INFINITY;
+    lim.rlim_max = RLIM_INFINITY;
+    setrlimit(RLIMIT_CORE, &lim);
+
+    ret = 0;
 out:
 
-        if (ret && ctx) {
-                if (ctx->pool) {
-                        mem_pool_destroy (ctx->pool->frame_mem_pool);
-                        mem_pool_destroy (ctx->pool->stack_mem_pool);
-                }
-                GF_FREE (ctx->pool);
-                mem_pool_destroy (ctx->stub_mem_pool);
-                mem_pool_destroy (ctx->dict_pool);
-                mem_pool_destroy (ctx->dict_data_pool);
-                mem_pool_destroy (ctx->dict_pair_pool);
-                mem_pool_destroy (ctx->logbuf_pool);
+    if (ret) {
+        if (ctx->pool) {
+            mem_pool_destroy(ctx->pool->frame_mem_pool);
+            mem_pool_destroy(ctx->pool->stack_mem_pool);
         }
+        GF_FREE(ctx->pool);
+        mem_pool_destroy(ctx->stub_mem_pool);
+        mem_pool_destroy(ctx->dict_pool);
+        mem_pool_destroy(ctx->dict_data_pool);
+        mem_pool_destroy(ctx->dict_pair_pool);
+        mem_pool_destroy(ctx->logbuf_pool);
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-logging_init (glusterfs_ctx_t *ctx, const char *progpath)
+logging_init(glusterfs_ctx_t *ctx, const char *progpath)
 {
-        cmd_args_t *cmd_args = NULL;
-        int         ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->log_file == NULL) {
-                ret = gf_set_log_file_path (cmd_args, ctx);
-                if (ret == -1) {
-                        fprintf (stderr, "ERROR: failed to set the log file "
-                                         "path\n");
-                        return -1;
-                }
+    if (cmd_args->log_file == NULL) {
+        ret = gf_set_log_file_path(cmd_args, ctx);
+        if (ret == -1) {
+            fprintf(stderr,
+                    "ERROR: failed to set the log file "
+                    "path\n");
+            return -1;
         }
+    }
 
-        if (cmd_args->log_ident == NULL) {
-                ret = gf_set_log_ident (cmd_args);
-                if (ret == -1) {
-                        fprintf (stderr, "ERROR: failed to set the log "
-                                         "identity\n");
-                        return -1;
-                }
+    if (cmd_args->log_ident == NULL) {
+        ret = gf_set_log_ident(cmd_args);
+        if (ret == -1) {
+            fprintf(stderr,
+                    "ERROR: failed to set the log "
+                    "identity\n");
+            return -1;
         }
+    }
 
-        /* finish log set parameters before init */
-        gf_log_set_loglevel (cmd_args->log_level);
+    /* finish log set parameters before init */
+    gf_log_set_loglevel(ctx, cmd_args->log_level);
 
-        gf_log_set_localtime (cmd_args->localtime_logging);
+    gf_log_set_localtime(cmd_args->localtime_logging);
 
-        gf_log_set_logger (cmd_args->logger);
+    gf_log_set_logger(cmd_args->logger);
 
-        gf_log_set_logformat (cmd_args->log_format);
+    gf_log_set_logformat(cmd_args->log_format);
 
-        gf_log_set_log_buf_size (cmd_args->log_buf_size);
+    gf_log_set_log_buf_size(cmd_args->log_buf_size);
 
-        gf_log_set_log_flush_timeout (cmd_args->log_flush_timeout);
+    gf_log_set_log_flush_timeout(cmd_args->log_flush_timeout);
 
-        if (gf_log_init (ctx, cmd_args->log_file, cmd_args->log_ident) == -1) {
-                fprintf (stderr, "ERROR: failed to open logfile %s\n",
-                         cmd_args->log_file);
-                return -1;
-        }
+    if (gf_log_init(ctx, cmd_args->log_file, cmd_args->log_ident) == -1) {
+        fprintf(stderr, "ERROR: failed to open logfile %s\n",
+                cmd_args->log_file);
+        return -1;
+    }
 
-        /* At this point, all the logging related parameters are initialised
-         * except for the log flush timer, which will be injected post fork(2)
-         * in daemonize() . During this time, any log message that is logged
-         * will be kept buffered. And if the list that holds these messages
-         * overflows, then the same lru policy is used to drive out the least
-         * recently used message and displace it with the message just logged.
-         */
+    /* At this point, all the logging related parameters are initialised
+     * except for the log flush timer, which will be injected post fork(2)
+     * in daemonize() . During this time, any log message that is logged
+     * will be kept buffered. And if the list that holds these messages
+     * overflows, then the same lru policy is used to drive out the least
+     * recently used message and displace it with the message just logged.
+     */
 
-        return 0;
+    return 0;
 }
 
 void
-gf_check_and_set_mem_acct (int argc, char *argv[])
+gf_check_and_set_mem_acct(int argc, char *argv[])
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < argc; i++) {
-                if (strcmp (argv[i], "--no-mem-accounting") == 0) {
-			gf_global_mem_acct_enable_set (0);
-                        break;
-                }
+    for (i = 0; i < argc; i++) {
+        if (strcmp(argv[i], "--no-mem-accounting") == 0) {
+            gf_global_mem_acct_enable_set(0);
+            break;
         }
+    }
 }
 
 /**
@@ -1734,87 +1801,85 @@ gf_check_and_set_mem_acct (int argc, char *argv[])
  * error messages. Hence there are different return values.
  */
 int
-print_exports_file (const char *exports_file)
+print_exports_file(const char *exports_file)
 {
-        void                   *libhandle = NULL;
-        char                   *libpathfull = NULL;
-        struct exports_file    *file = NULL;
-        int                     ret = 0;
-
-        int  (*exp_file_parse)(const char *filepath,
-                               struct exports_file **expfile,
-                               struct mount3_state *ms) = NULL;
-        void (*exp_file_print)(const struct exports_file *file) = NULL;
-        void (*exp_file_deinit)(struct exports_file *ptr) = NULL;
-
-        /* XLATORDIR passed through a -D flag to GCC */
-        ret = gf_asprintf (&libpathfull, "%s/%s/server.so", XLATORDIR,
-                           "nfs");
-        if (ret < 0) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the library */
-        libhandle = dlopen (libpathfull, RTLD_NOW);
-        if (!libhandle) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error loading NFS server library : "
-                        "%s\n", dlerror ());
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the function */
-        exp_file_parse = dlsym (libhandle, "exp_file_parse");
-        if (!exp_file_parse) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_parse "
-                        "in symbol.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Parse the file */
-        ret = exp_file_parse (exports_file, &file, NULL);
-        if (ret < 0) {
-                ret = 1;        /* This means we failed to parse */
-                goto out;
-        }
-
-        /* Load up the function */
-        exp_file_print = dlsym (libhandle, "exp_file_print");
-        if (!exp_file_print) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_print in symbol.");
-                ret = -1;
-                goto out;
-        }
+    void *libhandle = NULL;
+    char *libpathfull = NULL;
+    struct exports_file *file = NULL;
+    int ret = 0;
+
+    int (*exp_file_parse)(const char *filepath, struct exports_file **expfile,
+                          struct mount3_state *ms) = NULL;
+    void (*exp_file_print)(const struct exports_file *file) = NULL;
+    void (*exp_file_deinit)(struct exports_file * ptr) = NULL;
+
+    /* XLATORDIR passed through a -D flag to GCC */
+    ret = gf_asprintf(&libpathfull, "%s/%s/server.so", XLATORDIR, "nfs");
+    if (ret < 0) {
+        gf_log("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the library */
+    libhandle = dlopen(libpathfull, RTLD_NOW);
+    if (!libhandle) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error loading NFS server library : "
+               "%s\n",
+               dlerror());
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the function */
+    exp_file_parse = dlsym(libhandle, "exp_file_parse");
+    if (!exp_file_parse) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_parse "
+               "in symbol.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Parse the file */
+    ret = exp_file_parse(exports_file, &file, NULL);
+    if (ret < 0) {
+        ret = 1; /* This means we failed to parse */
+        goto out;
+    }
+
+    /* Load up the function */
+    exp_file_print = dlsym(libhandle, "exp_file_print");
+    if (!exp_file_print) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_print in symbol.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Print it out to screen */
-        exp_file_print (file);
+    /* Print it out to screen */
+    exp_file_print(file);
 
-        /* Load up the function */
-        exp_file_deinit = dlsym (libhandle, "exp_file_deinit");
-        if (!exp_file_deinit) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_deinit in lib.");
-                ret = -1;
-                goto out;
-        }
+    /* Load up the function */
+    exp_file_deinit = dlsym(libhandle, "exp_file_deinit");
+    if (!exp_file_deinit) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_deinit in lib.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Free the file */
-        exp_file_deinit (file);
+    /* Free the file */
+    exp_file_deinit(file);
 
 out:
-        if (libhandle)
-                dlclose(libhandle);
-        GF_FREE (libpathfull);
-        return ret;
+    if (libhandle)
+        dlclose(libhandle);
+    GF_FREE(libpathfull);
+    return ret;
 }
 
-
 /**
  * print_netgroups_file - Print out & verify the syntax
  *                        of the netgroups file specified
@@ -1832,744 +1897,842 @@ out:
  * we want to print out a different error messages based on the ret value.
  */
 int
-print_netgroups_file (const char *netgroups_file)
+print_netgroups_file(const char *netgroups_file)
 {
-        void                   *libhandle = NULL;
-        char                   *libpathfull = NULL;
-        struct netgroups_file  *file = NULL;
-        int                     ret = 0;
-
-        struct netgroups_file  *(*ng_file_parse)(const char *file_path) = NULL;
-        void         (*ng_file_print)(const struct netgroups_file *file) = NULL;
-        void         (*ng_file_deinit)(struct netgroups_file *ptr) = NULL;
-
-        /* XLATORDIR passed through a -D flag to GCC */
-        ret = gf_asprintf (&libpathfull, "%s/%s/server.so", XLATORDIR,
-                        "nfs");
-        if (ret < 0) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
-                ret = -1;
-                goto out;
-        }
-        /* Load up the library */
-        libhandle = dlopen (libpathfull, RTLD_NOW);
-        if (!libhandle) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error loading NFS server library : %s\n", dlerror ());
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the function */
-        ng_file_parse = dlsym (libhandle, "ng_file_parse");
-        if (!ng_file_parse) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_parse in symbol.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Parse the file */
-        file = ng_file_parse (netgroups_file);
-        if (!file) {
-                ret = 1;        /* This means we failed to parse */
-                goto out;
-        }
-
-        /* Load up the function */
-        ng_file_print = dlsym (libhandle, "ng_file_print");
-        if (!ng_file_print) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_print in symbol.");
-                ret = -1;
-                goto out;
-        }
+    void *libhandle = NULL;
+    char *libpathfull = NULL;
+    struct netgroups_file *file = NULL;
+    int ret = 0;
+
+    struct netgroups_file *(*ng_file_parse)(const char *file_path) = NULL;
+    void (*ng_file_print)(const struct netgroups_file *file) = NULL;
+    void (*ng_file_deinit)(struct netgroups_file * ptr) = NULL;
+
+    /* XLATORDIR passed through a -D flag to GCC */
+    ret = gf_asprintf(&libpathfull, "%s/%s/server.so", XLATORDIR, "nfs");
+    if (ret < 0) {
+        gf_log("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
+        ret = -1;
+        goto out;
+    }
+    /* Load up the library */
+    libhandle = dlopen(libpathfull, RTLD_NOW);
+    if (!libhandle) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error loading NFS server library : %s\n", dlerror());
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the function */
+    ng_file_parse = dlsym(libhandle, "ng_file_parse");
+    if (!ng_file_parse) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_parse in symbol.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Parse the file */
+    file = ng_file_parse(netgroups_file);
+    if (!file) {
+        ret = 1; /* This means we failed to parse */
+        goto out;
+    }
+
+    /* Load up the function */
+    ng_file_print = dlsym(libhandle, "ng_file_print");
+    if (!ng_file_print) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_print in symbol.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Print it out to screen */
-        ng_file_print (file);
+    /* Print it out to screen */
+    ng_file_print(file);
 
-        /* Load up the function */
-        ng_file_deinit = dlsym (libhandle, "ng_file_deinit");
-        if (!ng_file_deinit) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_deinit in lib.");
-                ret = -1;
-                goto out;
-        }
+    /* Load up the function */
+    ng_file_deinit = dlsym(libhandle, "ng_file_deinit");
+    if (!ng_file_deinit) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_deinit in lib.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Free the file */
-        ng_file_deinit (file);
+    /* Free the file */
+    ng_file_deinit(file);
 
 out:
-        if (libhandle)
-                dlclose(libhandle);
-        GF_FREE (libpathfull);
-        return ret;
+    if (libhandle)
+        dlclose(libhandle);
+    GF_FREE(libpathfull);
+    return ret;
 }
 
-
 int
-parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx)
+parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx)
 {
-        int          process_mode = 0;
-        int          ret = 0;
-        struct stat  stbuf = {0, };
-        char         timestr[32];
-        char         tmp_logfile[1024] = { 0 };
-        char        *tmp_logfile_dyn = NULL;
-        char        *tmp_logfilebase = NULL;
-        cmd_args_t  *cmd_args = NULL;
-
-        cmd_args = &ctx->cmd_args;
-
-        /* Do this before argp_parse so it can be overridden. */
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
-                cmd_args->secure_mgmt = 1;
-        }
-
-        argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
-        if (cmd_args->print_netgroups) {
-                /* When this option is set we don't want to do anything else
-                 * except for printing & verifying the netgroups file.
-                 */
-                ret = 0;
-                goto out;
-        }
-
-        if (cmd_args->print_exports) {
-                /* When this option is set we don't want to do anything else
-                 * except for printing & verifying the exports file.
-                  */
-                ret = 0;
-                goto out;
-        }
-
-
-        ctx->secure_mgmt = cmd_args->secure_mgmt;
-
-        if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
-                cmd_args->log_level = GF_LOG_DEBUG;
-                cmd_args->log_file = gf_strdup ("/dev/stderr");
-                cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
-        }
-
-        process_mode = gf_get_process_mode (argv[0]);
-        ctx->process_mode = process_mode;
+    int process_mode = 0;
+    int ret = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char timestr[GF_TIMESTR_SIZE];
+    char tmp_logfile[1024] = {0};
+    char *tmp_logfile_dyn = NULL;
+    char *tmp_logfilebase = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int len = 0;
+    char *thin_volfileid = NULL;
+
+    cmd_args = &ctx->cmd_args;
+
+    /* Do this before argp_parse so it can be overridden. */
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        cmd_args->secure_mgmt = 1;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+
+    /* Need to set lru_limit to below 0 to indicate there was nothing
+       specified. This is needed as 0 is a valid option, and may not be
+       default value. */
+    cmd_args->lru_limit = -1;
+
+    argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
+
+    if (cmd_args->print_xlatordir || cmd_args->print_statedumpdir ||
+        cmd_args->print_logdir || cmd_args->print_libexecdir) {
+        /* Just print, nothing else to do */
+        goto out;
+    }
+
+    if (cmd_args->print_netgroups) {
+        /* When this option is set we don't want to do anything else
+         * except for printing & verifying the netgroups file.
+         */
+        ret = 0;
+        goto out;
+    }
 
-        /* Make sure after the parsing cli, if '--volfile-server' option is
-           given, then '--volfile-id' is mandatory */
-        if (cmd_args->volfile_server && !cmd_args->volfile_id) {
-                gf_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15);
-                ret = -1;
+    if (cmd_args->print_exports) {
+        /* When this option is set we don't want to do anything else
+         * except for printing & verifying the exports file.
+         */
+        ret = 0;
+        goto out;
+    }
+
+    ctx->secure_mgmt = cmd_args->secure_mgmt;
+
+    if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
+        cmd_args->log_level = GF_LOG_DEBUG;
+        cmd_args->log_file = gf_strdup("/dev/stderr");
+        cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+    }
+
+    process_mode = gf_get_process_mode(argv[0]);
+    ctx->process_mode = process_mode;
+
+    if (cmd_args->process_name) {
+        ctx->cmd_args.process_name = cmd_args->process_name;
+    }
+    /* Make sure after the parsing cli, if '--volfile-server' option is
+       given, then '--volfile-id' is mandatory */
+    if (cmd_args->volfile_server && !cmd_args->volfile_id) {
+        gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15, NULL);
+        ret = -1;
+        goto out;
+    }
+
+    if ((cmd_args->volfile_server == NULL) && (cmd_args->volfile == NULL)) {
+        if (process_mode == GF_SERVER_PROCESS)
+            cmd_args->volfile = gf_strdup(DEFAULT_SERVER_VOLFILE);
+        else if (process_mode == GF_GLUSTERD_PROCESS)
+            cmd_args->volfile = gf_strdup(DEFAULT_GLUSTERD_VOLFILE);
+        else
+            cmd_args->volfile = gf_strdup(DEFAULT_CLIENT_VOLFILE);
+
+        /* Check if the volfile exists, if not give usage output
+           and exit */
+        ret = sys_stat(cmd_args->volfile, &stbuf);
+        if (ret) {
+            gf_smsg("glusterfs", GF_LOG_CRITICAL, errno, glusterfsd_msg_16,
+                    NULL);
+            /* argp_usage (argp.) */
+            fprintf(stderr, "USAGE: %s [options] [mountpoint]\n", argv[0]);
+            goto out;
+        }
+    }
+
+    if (cmd_args->thin_client) {
+        len = strlen(cmd_args->volfile_id) + SLEN("gfproxy-client/");
+        thin_volfileid = GF_MALLOC(len + 1, gf_common_mt_char);
+        snprintf(thin_volfileid, len + 1, "gfproxy-client/%s",
+                 cmd_args->volfile_id);
+        GF_FREE(cmd_args->volfile_id);
+        cmd_args->volfile_id = thin_volfileid;
+    }
+
+    if (cmd_args->run_id) {
+        ret = sys_lstat(cmd_args->log_file, &stbuf);
+        /* If its /dev/null, or /dev/stdout, /dev/stderr,
+         * let it use the same, no need to alter
+         */
+        if (((ret == 0) &&
+             (S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) ||
+            (ret == -1)) {
+            /* Have separate logfile per run. */
+            gf_time_fmt(timestr, sizeof timestr, gf_time(), gf_timefmt_FT);
+            sprintf(tmp_logfile, "%s.%s.%d", cmd_args->log_file, timestr,
+                    getpid());
+
+            /* Create symlink to actual log file */
+            sys_unlink(cmd_args->log_file);
+
+            tmp_logfile_dyn = gf_strdup(tmp_logfile);
+            tmp_logfilebase = basename(tmp_logfile_dyn);
+            ret = sys_symlink(tmp_logfilebase, cmd_args->log_file);
+            if (ret == -1) {
+                fprintf(stderr, "ERROR: symlink of logfile failed\n");
                 goto out;
-        }
-
-        if ((cmd_args->volfile_server == NULL)
-            && (cmd_args->volfile == NULL)) {
-                if (process_mode == GF_SERVER_PROCESS)
-                        cmd_args->volfile = gf_strdup (DEFAULT_SERVER_VOLFILE);
-                else if (process_mode == GF_GLUSTERD_PROCESS)
-                        cmd_args->volfile = gf_strdup (DEFAULT_GLUSTERD_VOLFILE);
-                else
-                        cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
-
-                /* Check if the volfile exists, if not give usage output
-                   and exit */
-                ret = sys_stat (cmd_args->volfile, &stbuf);
-                if (ret) {
-                        gf_msg ("glusterfs", GF_LOG_CRITICAL, errno,
-                                glusterfsd_msg_16);
-                        /* argp_usage (argp.) */
-                        fprintf (stderr, "USAGE: %s [options] [mountpoint]\n",
-                                 argv[0]);
-                        goto out;
-                }
-        }
+            }
 
-        if (cmd_args->run_id) {
-                ret = sys_lstat (cmd_args->log_file, &stbuf);
-                /* If its /dev/null, or /dev/stdout, /dev/stderr,
-                 * let it use the same, no need to alter
-                 */
-                if (((ret == 0) &&
-                     (S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) ||
-                    (ret == -1)) {
-                        /* Have separate logfile per run */
-                        gf_time_fmt (timestr, sizeof timestr, time (NULL),
-                                     gf_timefmt_FT);
-                        sprintf (tmp_logfile, "%s.%s.%d",
-                                 cmd_args->log_file, timestr, getpid ());
-
-                        /* Create symlink to actual log file */
-                        sys_unlink (cmd_args->log_file);
-
-                        tmp_logfile_dyn = gf_strdup (tmp_logfile);
-                        tmp_logfilebase = basename (tmp_logfile_dyn);
-                        ret = sys_symlink (tmp_logfilebase,
-                                           cmd_args->log_file);
-                        if (ret == -1) {
-                                fprintf (stderr, "ERROR: symlink of logfile failed\n");
-                                goto out;
-                        }
-
-                        GF_FREE (cmd_args->log_file);
-                        cmd_args->log_file = gf_strdup (tmp_logfile);
+            GF_FREE(cmd_args->log_file);
+            cmd_args->log_file = gf_strdup(tmp_logfile);
 
-                        GF_FREE (tmp_logfile_dyn);
-                }
+            GF_FREE(tmp_logfile_dyn);
         }
+    }
 
-        /*
-           This option was made obsolete but parsing it for backward
-           compatibility with third party applications
-         */
-        if (cmd_args->max_connect_attempts) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33);
-        }
+    /*
+       This option was made obsolete but parsing it for backward
+       compatibility with third party applications
+     */
+    if (cmd_args->max_connect_attempts) {
+        gf_smsg("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33, NULL);
+    }
 
 #ifdef GF_DARWIN_HOST_OS
-        if (cmd_args->mount_point)
-               cmd_args->mac_compat = GF_OPTION_DEFERRED;
+    if (cmd_args->mount_point)
+        cmd_args->mac_compat = GF_OPTION_DEFERRED;
 #endif
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
+glusterfs_pidfile_setup(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t  *cmd_args = NULL;
-        int          ret = -1;
-        FILE        *pidfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+    FILE *pidfp = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->pid_file)
-                return 0;
+    if (!cmd_args->pid_file)
+        return 0;
 
-        pidfp = fopen (cmd_args->pid_file, "a+");
-        if (!pidfp) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17,
-                        cmd_args->pid_file);
-                goto out;
-        }
+    pidfp = fopen(cmd_args->pid_file, "a+");
+    if (!pidfp) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17,
+                "pidfile=%s", cmd_args->pid_file, NULL);
+        goto out;
+    }
 
-        ctx->pidfp = pidfp;
+    ctx->pidfp = pidfp;
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx)
+glusterfs_pidfile_cleanup(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t      *cmd_args = NULL;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!ctx->pidfp)
-                return 0;
+    if (!ctx->pidfp)
+        return 0;
 
-        gf_msg_trace ("glusterfsd", 0, "pidfile %s cleanup",
-                      cmd_args->pid_file);
+    gf_msg_trace("glusterfsd", 0, "pidfile %s cleanup", cmd_args->pid_file);
 
-        if (ctx->cmd_args.pid_file) {
-                ctx->cmd_args.pid_file = NULL;
-        }
+    if (ctx->cmd_args.pid_file) {
+        GF_FREE(ctx->cmd_args.pid_file);
+        ctx->cmd_args.pid_file = NULL;
+    }
 
-        lockf (fileno (ctx->pidfp), F_ULOCK, 0);
-        fclose (ctx->pidfp);
-        ctx->pidfp = NULL;
+    lockf(fileno(ctx->pidfp), F_ULOCK, 0);
+    fclose(ctx->pidfp);
+    ctx->pidfp = NULL;
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_pidfile_update (glusterfs_ctx_t *ctx)
+glusterfs_pidfile_update(glusterfs_ctx_t *ctx, pid_t pid)
 {
-        cmd_args_t  *cmd_args = NULL;
-        int          ret = 0;
-        FILE        *pidfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
+    FILE *pidfp = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        pidfp = ctx->pidfp;
-        if (!pidfp)
-                return 0;
+    pidfp = ctx->pidfp;
+    if (!pidfp)
+        return 0;
 
-        ret = lockf (fileno (pidfp), F_TLOCK, 0);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18,
-                        cmd_args->pid_file);
-                return ret;
-        }
+    ret = lockf(fileno(pidfp), F_TLOCK, 0);
+    if (ret) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18,
+                "pidfile=%s", cmd_args->pid_file, NULL);
+        return ret;
+    }
 
-        ret = sys_ftruncate (fileno (pidfp), 0);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20,
-                        cmd_args->pid_file);
-                return ret;
-        }
+    ret = sys_ftruncate(fileno(pidfp), 0);
+    if (ret) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20,
+                "pidfile=%s", cmd_args->pid_file, NULL);
+        return ret;
+    }
 
-        ret = fprintf (pidfp, "%d\n", getpid ());
-        if (ret <= 0) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
-                        cmd_args->pid_file);
-                return ret;
-        }
+    ret = fprintf(pidfp, "%d\n", pid);
+    if (ret <= 0) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
+                "pidfile=%s", cmd_args->pid_file, NULL);
+        return ret;
+    }
 
-        ret = fflush (pidfp);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
-                        cmd_args->pid_file);
-                return ret;
-        }
+    ret = fflush(pidfp);
+    if (ret) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
+                "pidfile=%s", cmd_args->pid_file, NULL);
+        return ret;
+    }
 
-        gf_msg_debug ("glusterfsd", 0, "pidfile %s updated with pid %d",
-                      cmd_args->pid_file, getpid ());
+    gf_msg_debug("glusterfsd", 0, "pidfile %s updated with pid %d",
+                 cmd_args->pid_file, pid);
 
-        return 0;
+    return 0;
 }
 
-
 void *
-glusterfs_sigwaiter (void *arg)
+glusterfs_sigwaiter(void *arg)
 {
-        sigset_t  set;
-        int       ret = 0;
-        int       sig = 0;
+    sigset_t set;
+    int ret = 0;
+    int sig = 0;
+    char *file = NULL;
+
+    sigemptyset(&set);
+    sigaddset(&set, SIGINT);  /* cleanup_and_exit */
+    sigaddset(&set, SIGTERM); /* cleanup_and_exit */
+    sigaddset(&set, SIGHUP);  /* reincarnate */
+    sigaddset(&set, SIGUSR1); /* gf_proc_dump_info */
+    sigaddset(&set, SIGUSR2);
+
+    for (;;) {
+        ret = sigwait(&set, &sig);
+        if (ret)
+            continue;
 
+        switch (sig) {
+            case SIGINT:
+            case SIGTERM:
+                cleanup_and_exit(sig);
+                break;
+            case SIGHUP:
+                reincarnate(sig);
+                break;
+            case SIGUSR1:
+                gf_proc_dump_info(sig, glusterfsd_ctx);
+                break;
+            case SIGUSR2:
+                file = gf_monitor_metrics(glusterfsd_ctx);
 
-        sigemptyset (&set);
-        sigaddset (&set, SIGINT);   /* cleanup_and_exit */
-        sigaddset (&set, SIGTERM);  /* cleanup_and_exit */
-        sigaddset (&set, SIGHUP);   /* reincarnate */
-        sigaddset (&set, SIGUSR1);  /* gf_proc_dump_info */
-        sigaddset (&set, SIGUSR2);  /* gf_latency_toggle */
+                /* Nothing needed to be done here */
+                GF_FREE(file);
 
-        for (;;) {
-                ret = sigwait (&set, &sig);
-                if (ret)
-                        continue;
-
-
-                switch (sig) {
-                case SIGINT:
-                case SIGTERM:
-                        cleanup_and_exit (sig);
-                        break;
-                case SIGHUP:
-                        reincarnate (sig);
-                        break;
-                case SIGUSR1:
-                        gf_proc_dump_info (sig, glusterfsd_ctx);
-                        break;
-                case SIGUSR2:
-                        gf_latency_toggle (sig, glusterfsd_ctx);
-                        break;
-                default:
-
-                        break;
-                }
+                break;
+            default:
+
+                break;
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 void
-glusterfsd_print_trace (int signum)
+glusterfsd_print_trace(int signum)
 {
-	gf_print_trace (signum, glusterfsd_ctx);
+    gf_print_trace(signum, glusterfsd_ctx);
 }
 
-
 int
-glusterfs_signals_setup (glusterfs_ctx_t *ctx)
+glusterfs_signals_setup(glusterfs_ctx_t *ctx)
 {
-        sigset_t  set;
-        int       ret = 0;
-
-        sigemptyset (&set);
-
-        /* common setting for all threads */
-        signal (SIGSEGV, glusterfsd_print_trace);
-        signal (SIGABRT, glusterfsd_print_trace);
-        signal (SIGILL, glusterfsd_print_trace);
-        signal (SIGTRAP, glusterfsd_print_trace);
-        signal (SIGFPE, glusterfsd_print_trace);
-        signal (SIGBUS, glusterfsd_print_trace);
-        signal (SIGINT, cleanup_and_exit);
-        signal (SIGPIPE, SIG_IGN);
-
-        /* block these signals from non-sigwaiter threads */
-        sigaddset (&set, SIGTERM);  /* cleanup_and_exit */
-        sigaddset (&set, SIGHUP);   /* reincarnate */
-        sigaddset (&set, SIGUSR1);  /* gf_proc_dump_info */
-        sigaddset (&set, SIGUSR2);  /* gf_latency_toggle */
-
-        ret = pthread_sigmask (SIG_BLOCK, &set, NULL);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22);
-                return ret;
-        }
-
-        ret = gf_thread_create (&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
-                                (void *) &set, "sigwait");
-        if (ret) {
-                /*
-                  TODO:
-                  fallback to signals getting handled by other threads.
-                  setup the signal handlers
-                */
-                gf_msg ("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23);
-                return ret;
-        }
+    sigset_t set;
+    int ret = 0;
+
+    sigemptyset(&set);
+
+    /* common setting for all threads */
+    signal(SIGSEGV, glusterfsd_print_trace);
+    signal(SIGABRT, glusterfsd_print_trace);
+    signal(SIGILL, glusterfsd_print_trace);
+    signal(SIGTRAP, glusterfsd_print_trace);
+    signal(SIGFPE, glusterfsd_print_trace);
+    signal(SIGBUS, glusterfsd_print_trace);
+    signal(SIGINT, cleanup_and_exit);
+    signal(SIGPIPE, SIG_IGN);
+
+    /* block these signals from non-sigwaiter threads */
+    sigaddset(&set, SIGTERM); /* cleanup_and_exit */
+    sigaddset(&set, SIGHUP);  /* reincarnate */
+    sigaddset(&set, SIGUSR1); /* gf_proc_dump_info */
+    sigaddset(&set, SIGUSR2);
+
+    /* Signals needed for asynchronous framework. */
+    sigaddset(&set, GF_ASYNC_SIGQUEUE);
+    sigaddset(&set, GF_ASYNC_SIGCTRL);
+
+    ret = pthread_sigmask(SIG_BLOCK, &set, NULL);
+    if (ret) {
+        gf_smsg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22, NULL);
+        return ret;
+    }
 
+    ret = gf_thread_create(&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
+                           (void *)&set, "sigwait");
+    if (ret) {
+        /*
+          TODO:
+          fallback to signals getting handled by other threads.
+          setup the signal handlers
+        */
+        gf_smsg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23, NULL);
         return ret;
-}
+    }
 
+    return ret;
+}
 
 int
-daemonize (glusterfs_ctx_t *ctx)
+daemonize(glusterfs_ctx_t *ctx)
 {
-        int            ret = -1;
-        cmd_args_t    *cmd_args = NULL;
-        int            cstatus = 0;
-        int            err = 1;
-
-        cmd_args = &ctx->cmd_args;
-
-        ret = glusterfs_pidfile_setup (ctx);
-        if (ret)
-                goto out;
-
-        if (cmd_args->no_daemon_mode)
-                goto postfork;
-
-        if (cmd_args->debug_mode)
-                goto postfork;
-
-        ret = pipe (ctx->daemon_pipe);
-        if (ret) {
-                /* If pipe() fails, retain daemon_pipe[] = {-1, -1}
-                   and parent will just not wait for child status
-                */
-                ctx->daemon_pipe[0] = -1;
-                ctx->daemon_pipe[1] = -1;
-        }
-
-        ret = os_daemon_return (0, 0);
-        switch (ret) {
+    int ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    int cstatus = 0;
+    int err = 1;
+    int child_pid = 0;
+
+    cmd_args = &ctx->cmd_args;
+
+    ret = glusterfs_pidfile_setup(ctx);
+    if (ret)
+        goto out;
+
+    if (cmd_args->no_daemon_mode) {
+        goto postfork;
+    }
+
+    if (cmd_args->debug_mode)
+        goto postfork;
+
+    ret = pipe(ctx->daemon_pipe);
+    if (ret) {
+        /* If pipe() fails, retain daemon_pipe[] = {-1, -1}
+           and parent will just not wait for child status
+        */
+        ctx->daemon_pipe[0] = -1;
+        ctx->daemon_pipe[1] = -1;
+    }
+
+    ret = os_daemon_return(0, 0);
+    switch (ret) {
         case -1:
-                if (ctx->daemon_pipe[0] != -1) {
-                        sys_close (ctx->daemon_pipe[0]);
-                        sys_close (ctx->daemon_pipe[1]);
-                }
+            if (ctx->daemon_pipe[0] != -1) {
+                sys_close(ctx->daemon_pipe[0]);
+                sys_close(ctx->daemon_pipe[1]);
+            }
 
-                gf_msg ("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24);
-                goto out;
+            gf_smsg("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24, NULL);
+            goto out;
         case 0:
-                /* child */
-                /* close read */
-                sys_close (ctx->daemon_pipe[0]);
-                break;
+            /* child */
+            /* close read */
+            sys_close(ctx->daemon_pipe[0]);
+            break;
         default:
-                /* parent */
-                /* close write */
-                sys_close (ctx->daemon_pipe[1]);
-
-                if (ctx->mnt_pid > 0) {
-                        ret = waitpid (ctx->mnt_pid, &cstatus, 0);
-                        if (!(ret == ctx->mnt_pid)) {
-                                if (WIFEXITED(cstatus)) {
-                                        err = WEXITSTATUS(cstatus);
-                                } else {
-                                        err = cstatus;
-                                }
-                                gf_msg ("daemonize", GF_LOG_ERROR, 0,
-                                        glusterfsd_msg_25);
-                                exit (err);
-                        }
-                }
-                sys_read (ctx->daemon_pipe[0], (void *)&err, sizeof (err));
-                /* NOTE: Only the least significant 8 bits i.e (err & 255)
-                   will be available to parent process on calling exit() */
-                _exit (abs(err));
-        }
+            /* parent */
+            /* close write */
+            child_pid = ret;
+            sys_close(ctx->daemon_pipe[1]);
+
+            if (ctx->mnt_pid > 0) {
+                ret = waitpid(ctx->mnt_pid, &cstatus, 0);
+                if (!(ret == ctx->mnt_pid)) {
+                    if (WIFEXITED(cstatus)) {
+                        err = WEXITSTATUS(cstatus);
+                    } else {
+                        err = cstatus;
+                    }
+                    gf_smsg("daemonize", GF_LOG_ERROR, 0, glusterfsd_msg_25,
+                            NULL);
+                    exit(err);
+                }
+            }
+            sys_read(ctx->daemon_pipe[0], (void *)&err, sizeof(err));
+            /* NOTE: Only the least significant 8 bits i.e (err & 255)
+               will be available to parent process on calling exit() */
+            if (err)
+                _exit(abs(err));
+
+            /* Update pid in parent only for glusterd process */
+            if (ctx->process_mode == GF_GLUSTERD_PROCESS) {
+                ret = glusterfs_pidfile_update(ctx, child_pid);
+                if (ret)
+                    exit(1);
+            }
+            _exit(0);
+    }
 
 postfork:
-        ret = glusterfs_pidfile_update (ctx);
+    /* Update pid in child either process_mode is not belong to glusterd
+       or process is spawned in no daemon mode
+    */
+    if ((ctx->process_mode != GF_GLUSTERD_PROCESS) ||
+        (cmd_args->no_daemon_mode)) {
+        ret = glusterfs_pidfile_update(ctx, getpid());
         if (ret)
-                goto out;
+            goto out;
+    }
+    gf_log("glusterfs", GF_LOG_INFO, "Pid of current running process is %d",
+           getpid());
+    ret = gf_log_inject_timer_event(ctx);
 
-        ret = gf_log_inject_timer_event (ctx);
-
-        glusterfs_signals_setup (ctx);
+    glusterfs_signals_setup(ctx);
 out:
-        return ret;
+    return ret;
 }
 
-
 #ifdef GF_LINUX_HOST_OS
 static int
-set_oom_score_adj (glusterfs_ctx_t *ctx)
+set_oom_score_adj(glusterfs_ctx_t *ctx)
 {
-        int                  ret           = -1;
-        cmd_args_t          *cmd_args      =  NULL;
-        int                  fd            = -1;
-        size_t               oom_score_len =  0;
-        struct oom_api_info *api           =  NULL;
+    int ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    int fd = -1;
+    size_t oom_score_len = 0;
+    struct oom_api_info *api = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->oom_score_adj)
-                goto success;
+    if (!cmd_args->oom_score_adj)
+        goto success;
 
-        api = get_oom_api_info();
-        if (!api)
-                goto out;
+    api = get_oom_api_info();
+    if (!api)
+        goto out;
 
-        fd = open (api->oom_api_file, O_WRONLY);
-        if (fd < 0)
-                goto out;
+    fd = open(api->oom_api_file, O_WRONLY);
+    if (fd < 0)
+        goto out;
 
-        oom_score_len = strlen (cmd_args->oom_score_adj);
-        if (sys_write (fd,
-                  cmd_args->oom_score_adj, oom_score_len) != oom_score_len) {
-                sys_close (fd);
-                goto out;
-        }
+    oom_score_len = strlen(cmd_args->oom_score_adj);
+    if (sys_write(fd, cmd_args->oom_score_adj, oom_score_len) !=
+        oom_score_len) {
+        sys_close(fd);
+        goto out;
+    }
 
-        if (sys_close (fd) < 0)
-                goto out;
+    if (sys_close(fd) < 0)
+        goto out;
 
 success:
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 #endif
 
-
 int
-glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp)
+glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp)
 {
-        glusterfs_graph_t  *graph = NULL;
-        int                 ret = -1;
-        xlator_t           *trav = NULL;
+    glusterfs_graph_t *graph = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
 
-        graph = glusterfs_graph_construct (fp);
-        if (!graph) {
-                gf_msg ("", GF_LOG_ERROR, 0, glusterfsd_msg_26);
-                goto out;
-        }
+    if (!ctx)
+        return -1;
 
-        for (trav = graph->first; trav; trav = trav->next) {
-                if (strcmp (trav->type, "mount/fuse") == 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0,
-                                glusterfsd_msg_27);
-                        goto out;
-                }
-        }
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_smsg("", GF_LOG_ERROR, 0, glusterfsd_msg_26, NULL);
+        goto out;
+    }
 
-        xlator_t *xl = graph->first;
-        if (strcmp (xl->type, "protocol/server") == 0) {
-                (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*");
+    for (trav = graph->first; trav; trav = trav->next) {
+        if (strcmp(trav->type, "mount/fuse") == 0) {
+            gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_27, NULL);
+            goto out;
         }
+    }
 
-        ret = glusterfs_graph_prepare (graph, ctx, ctx->cmd_args.volume_name);
-        if (ret) {
-                goto out;
-        }
+    xlator_t *xl = graph->first;
+    if (xl && (strcmp(xl->type, "protocol/server") == 0)) {
+        (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*");
+    }
 
-        ret = glusterfs_graph_activate (graph, ctx);
+    ret = glusterfs_graph_prepare(graph, ctx, ctx->cmd_args.volume_name);
+    if (ret) {
+        goto out;
+    }
 
-        if (ret) {
-                goto out;
-        }
+    ret = glusterfs_graph_activate(graph, ctx);
 
-        gf_log_dump_graph (fp, graph);
+    if (ret) {
+        goto out;
+    }
 
-        ret = 0;
+    gf_log_dump_graph(fp, graph);
+
+    ret = 0;
 out:
-        if (fp)
-                fclose (fp);
-
-        if (ret && !ctx->active) {
-                glusterfs_graph_destroy (graph);
-                /* there is some error in setting up the first graph itself */
-                emancipate (ctx, ret);
-                cleanup_and_exit (ret);
+    if (fp)
+        fclose(fp);
+
+    if (ret) {
+        /* TODO This code makes to generic for all graphs
+           client as well as servers.For now it destroys
+           graph only for server-side xlators not for client-side
+           xlators, before destroying a graph call xlator fini for
+           xlators those call xlator_init to avoid leak
+        */
+        if (graph) {
+            xl = graph->first;
+            if ((ctx->active != graph) &&
+                (xl && !strcmp(xl->type, "protocol/server"))) {
+                /* Take dict ref for every graph xlator to avoid dict leak
+                   at the time of graph destroying
+                */
+                glusterfs_graph_fini(graph);
+                glusterfs_graph_destroy(graph);
+            }
         }
 
-        return ret;
-}
+        /* there is some error in setting up the first graph itself */
+        if (!ctx->active) {
+            emancipate(ctx, ret);
+            cleanup_and_exit(ret);
+        }
+    }
 
+    return ret;
+}
 
 int
-glusterfs_volumes_init (glusterfs_ctx_t *ctx)
+glusterfs_volumes_init(glusterfs_ctx_t *ctx)
 {
-        FILE               *fp = NULL;
-        cmd_args_t         *cmd_args = NULL;
-        int                 ret = 0;
+    FILE *fp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->sock_file) {
-                ret = glusterfs_listener_init (ctx);
-                if (ret)
-                        goto out;
-        }
+    if (cmd_args->sock_file) {
+        ret = glusterfs_listener_init(ctx);
+        if (ret)
+            goto out;
+    }
 
-        if (cmd_args->volfile_server) {
-                ret = glusterfs_mgmt_init (ctx);
-                /* return, do not emancipate() yet */
-                return ret;
-        }
+    if (cmd_args->volfile_server) {
+        ret = glusterfs_mgmt_init(ctx);
+        /* return, do not emancipate() yet */
+        return ret;
+    }
 
-        fp = get_volfp (ctx);
+    fp = get_volfp(ctx);
 
-        if (!fp) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28);
-                ret = -1;
-                goto out;
-        }
+    if (!fp) {
+        gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28, NULL);
+        ret = -1;
+        goto out;
+    }
 
-        ret = glusterfs_process_volfp (ctx, fp);
-        if (ret)
-                goto out;
+    ret = glusterfs_process_volfp(ctx, fp);
+    if (ret)
+        goto out;
 
 out:
-        emancipate (ctx, ret);
-        return ret;
+    emancipate(ctx, ret);
+    return ret;
 }
 
 /* This is the only legal global pointer  */
 glusterfs_ctx_t *glusterfsd_ctx;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        int               ret = -1;
-        char              cmdlinestr[PATH_MAX] = {0,};
-        cmd_args_t       *cmd = NULL;
-
-        mem_pools_init_early ();
-
-	gf_check_and_set_mem_acct (argc, argv);
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = -1;
+    char cmdlinestr[PATH_MAX] = {
+        0,
+    };
+    cmd_args_t *cmd = NULL;
+
+    gf_check_and_set_mem_acct(argc, argv);
+
+    ctx = glusterfs_ctx_new();
+    if (!ctx) {
+        gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29, NULL);
+        return ENOMEM;
+    }
+    glusterfsd_ctx = ctx;
+
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        return ret;
 
-	ctx = glusterfs_ctx_new ();
-        if (!ctx) {
-                gf_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29);
-                return ENOMEM;
-        }
-	glusterfsd_ctx = ctx;
+    THIS->ctx = ctx;
 
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                return ret;
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-	THIS->ctx = ctx;
-
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
+    ret = parse_cmdline(argc, argv, ctx);
+    if (ret)
+        goto out;
+    cmd = &ctx->cmd_args;
 
-        ret = parse_cmdline (argc, argv, ctx);
-        if (ret)
-                goto out;
-        cmd = &ctx->cmd_args;
-        if (cmd->print_netgroups) {
-                /* If this option is set we want to print & verify the file,
-                 * set the return value (exit code in this case) and exit.
-                 */
-                ret =  print_netgroups_file (cmd->print_netgroups);
-                goto out;
-        }
-
-        if (cmd->print_exports) {
-                /* If this option is set we want to print & verify the file,
-                 * set the return value (exit code in this case)
-                 * and exit.
-                 */
-                ret = print_exports_file (cmd->print_exports);
+    if (cmd->print_xlatordir) {
+        /* XLATORDIR passed through a -D flag to GCC */
+        printf("%s\n", XLATORDIR);
+        goto out;
+    }
+
+    if (cmd->print_statedumpdir) {
+        printf("%s\n", DEFAULT_VAR_RUN_DIRECTORY);
+        goto out;
+    }
+
+    if (cmd->print_logdir) {
+        printf("%s\n", DEFAULT_LOG_FILE_DIRECTORY);
+        goto out;
+    }
+
+    if (cmd->print_libexecdir) {
+        printf("%s\n", LIBEXECDIR);
+        goto out;
+    }
+
+    if (cmd->print_netgroups) {
+        /* If this option is set we want to print & verify the file,
+         * set the return value (exit code in this case) and exit.
+         */
+        ret = print_netgroups_file(cmd->print_netgroups);
+        goto out;
+    }
+
+    if (cmd->print_exports) {
+        /* If this option is set we want to print & verify the file,
+         * set the return value (exit code in this case)
+         * and exit.
+         */
+        ret = print_exports_file(cmd->print_exports);
+        goto out;
+    }
+
+    ret = logging_init(ctx, argv[0]);
+    if (ret)
+        goto out;
+
+    /* set brick_mux mode only for server process */
+    if ((ctx->process_mode != GF_SERVER_PROCESS) && cmd->brick_mux) {
+        gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_43, NULL);
+        goto out;
+    }
+
+    /* log the version of glusterfs running here along with the actual
+       command line options. */
+    {
+        int i = 0;
+        int pos = 0;
+        int len = snprintf(cmdlinestr, sizeof(cmdlinestr), "%s", argv[0]);
+        for (i = 1; (i < argc) && (len > 0); i++) {
+            pos += len;
+            len = snprintf(cmdlinestr + pos, sizeof(cmdlinestr) - pos, " %s",
+                           argv[i]);
+            if ((len <= 0) || (len >= (sizeof(cmdlinestr) - pos))) {
+                gf_smsg("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_029, NULL);
+                ret = -1;
                 goto out;
+            }
         }
+        gf_smsg(argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30, "arg=%s", argv[0],
+                "version=%s", PACKAGE_VERSION, "cmdlinestr=%s", cmdlinestr,
+                NULL);
 
-        ret = logging_init (ctx, argv[0]);
-        if (ret)
-                goto out;
-
+        ctx->cmdlinestr = gf_strdup(cmdlinestr);
+    }
 
-        /* log the version of glusterfs running here along with the actual
-           command line options. */
-        {
-                int i = 0;
-                strcpy (cmdlinestr, argv[0]);
-                for (i = 1; i < argc; i++) {
-                        strcat (cmdlinestr, " ");
-                        strncat (cmdlinestr, argv[i],
-                                 (sizeof (cmdlinestr) - 1));
-                }
-                gf_msg (argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30,
-                        argv[0], PACKAGE_VERSION, cmdlinestr);
-
-		ctx->cmdlinestr = gf_strdup (cmdlinestr);
-        }
+    gf_proc_dump_init();
 
-        gf_proc_dump_init();
+    ret = create_fuse_mount(ctx);
+    if (ret)
+        goto out;
 
-        ret = create_fuse_mount (ctx);
-        if (ret)
-                goto out;
+    ret = daemonize(ctx);
+    if (ret)
+        goto out;
 
-        ret = daemonize (ctx);
-        if (ret)
-                goto out;
+    /*
+     * If we do this before daemonize, the pool-sweeper thread dies with
+     * the parent, but we want to do it as soon as possible after that in
+     * case something else depends on pool allocations.
+     */
+    mem_pools_init();
 
-        /*
-         * If we do this before daemonize, the pool-sweeper thread dies with
-         * the parent, but we want to do it as soon as possible after that in
-         * case something else depends on pool allocations.
-         */
-        mem_pools_init_late ();
+    ret = gf_async_init(ctx);
+    if (ret < 0) {
+        goto out;
+    }
 
 #ifdef GF_LINUX_HOST_OS
-        ret = set_oom_score_adj (ctx);
-        if (ret)
-                goto out;
+    ret = set_oom_score_adj(ctx);
+    if (ret)
+        goto out;
 #endif
 
-	ctx->env = syncenv_new (0, 0, 0);
-        if (!ctx->env) {
-                gf_msg ("", GF_LOG_ERROR, 0, glusterfsd_msg_31);
-                goto out;
-        }
+    ctx->env = syncenv_new(0, 0, 0);
+    if (!ctx->env) {
+        gf_smsg("", GF_LOG_ERROR, 0, glusterfsd_msg_31, NULL);
+        goto out;
+    }
 
-        /* do this _after_ daemonize() */
-        if (cmd->global_timer_wheel) {
-                if (!glusterfs_ctx_tw_get (ctx)) {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    /* do this _after_ daemonize() */
+    if (!glusterfs_ctx_tw_get(ctx)) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = glusterfs_volumes_init (ctx);
-        if (ret)
-                goto out;
+    ret = glusterfs_volumes_init(ctx);
+    if (ret)
+        goto out;
 
-        ret = event_dispatch (ctx->event_pool);
+    ret = gf_event_dispatch(ctx->event_pool);
 
 out:
-//        glusterfs_ctx_destroy (ctx);
-        return ret;
+    //    glusterfs_ctx_destroy (ctx);
+    gf_async_fini();
+    return ret;
 }
diff --git a/glusterfsd/src/glusterfsd.h b/glusterfsd/src/glusterfsd.h
index 6d1e16594b1..4e1413caa70 100644
--- a/glusterfsd/src/glusterfsd.h
+++ b/glusterfsd/src/glusterfsd.h
@@ -13,118 +13,130 @@
 #include "rpcsvc.h"
 #include "glusterd1-xdr.h"
 
-#define DEFAULT_GLUSTERD_VOLFILE              CONFDIR "/glusterd.vol"
-#define DEFAULT_CLIENT_VOLFILE                CONFDIR "/glusterfs.vol"
-#define DEFAULT_SERVER_VOLFILE                CONFDIR "/glusterfsd.vol"
+#define DEFAULT_GLUSTERD_VOLFILE CONFDIR "/glusterd.vol"
+#define DEFAULT_CLIENT_VOLFILE CONFDIR "/glusterfs.vol"
+#define DEFAULT_SERVER_VOLFILE CONFDIR "/glusterfsd.vol"
 
-#define DEFAULT_EVENT_POOL_SIZE            16384
+#define DEFAULT_EVENT_POOL_SIZE 16384
 
-#define ARGP_LOG_LEVEL_NONE_OPTION        "NONE"
-#define ARGP_LOG_LEVEL_TRACE_OPTION       "TRACE"
-#define ARGP_LOG_LEVEL_CRITICAL_OPTION    "CRITICAL"
-#define ARGP_LOG_LEVEL_ERROR_OPTION       "ERROR"
-#define ARGP_LOG_LEVEL_WARNING_OPTION     "WARNING"
-#define ARGP_LOG_LEVEL_INFO_OPTION        "INFO"
-#define ARGP_LOG_LEVEL_DEBUG_OPTION       "DEBUG"
+#define ARGP_LOG_LEVEL_NONE_OPTION "NONE"
+#define ARGP_LOG_LEVEL_TRACE_OPTION "TRACE"
+#define ARGP_LOG_LEVEL_CRITICAL_OPTION "CRITICAL"
+#define ARGP_LOG_LEVEL_ERROR_OPTION "ERROR"
+#define ARGP_LOG_LEVEL_WARNING_OPTION "WARNING"
+#define ARGP_LOG_LEVEL_INFO_OPTION "INFO"
+#define ARGP_LOG_LEVEL_DEBUG_OPTION "DEBUG"
 
-#define ENABLE_NO_DAEMON_MODE     1
-#define ENABLE_DEBUG_MODE         1
+#define ENABLE_NO_DAEMON_MODE 1
+#define ENABLE_DEBUG_MODE 1
 
-#define GF_MEMPOOL_COUNT_OF_DICT_T        4096
+#define GF_MEMPOOL_COUNT_OF_DICT_T 4096
 /* Considering 4 key/value pairs in a dictionary on an average */
-#define GF_MEMPOOL_COUNT_OF_DATA_T        (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
-#define GF_MEMPOOL_COUNT_OF_DATA_PAIR_T   (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
+#define GF_MEMPOOL_COUNT_OF_DATA_T (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
+#define GF_MEMPOOL_COUNT_OF_DATA_PAIR_T (GF_MEMPOOL_COUNT_OF_DICT_T * 4)
 
-#define GF_MEMPOOL_COUNT_OF_LRU_BUF_T     256
+#define GF_MEMPOOL_COUNT_OF_LRU_BUF_T 256
 
 enum argp_option_keys {
-        ARGP_VOLFILE_SERVER_KEY           = 's',
-        ARGP_VOLUME_FILE_KEY              = 'f',
-        ARGP_LOG_LEVEL_KEY                = 'L',
-        ARGP_LOG_FILE_KEY                 = 'l',
-        ARGP_VOLFILE_SERVER_PORT_KEY      = 131,
-        ARGP_VOLFILE_SERVER_TRANSPORT_KEY = 132,
-        ARGP_PID_FILE_KEY                 = 'p',
-        ARGP_SOCK_FILE_KEY                = 'S',
-        ARGP_NO_DAEMON_KEY                = 'N',
-        ARGP_RUN_ID_KEY                   = 'r',
-        ARGP_PRINT_NETGROUPS              = 'n',
-        ARGP_PRINT_EXPORTS                = 'e',
-        ARGP_DEBUG_KEY                    = 133,
-        ARGP_NEGATIVE_TIMEOUT_KEY         = 134,
-        ARGP_ENTRY_TIMEOUT_KEY            = 135,
-        ARGP_ATTRIBUTE_TIMEOUT_KEY        = 136,
-        ARGP_VOLUME_NAME_KEY              = 137,
-        ARGP_XLATOR_OPTION_KEY            = 138,
-        ARGP_DIRECT_IO_MODE_KEY           = 139,
+    ARGP_VOLFILE_SERVER_KEY = 's',
+    ARGP_VOLUME_FILE_KEY = 'f',
+    ARGP_LOG_LEVEL_KEY = 'L',
+    ARGP_LOG_FILE_KEY = 'l',
+    ARGP_VOLFILE_SERVER_PORT_KEY = 131,
+    ARGP_VOLFILE_SERVER_TRANSPORT_KEY = 132,
+    ARGP_PID_FILE_KEY = 'p',
+    ARGP_SOCK_FILE_KEY = 'S',
+    ARGP_NO_DAEMON_KEY = 'N',
+    ARGP_RUN_ID_KEY = 'r',
+    ARGP_PRINT_NETGROUPS = 'n',
+    ARGP_PRINT_EXPORTS = 'e',
+    ARGP_DEBUG_KEY = 133,
+    ARGP_NEGATIVE_TIMEOUT_KEY = 134,
+    ARGP_ENTRY_TIMEOUT_KEY = 135,
+    ARGP_ATTRIBUTE_TIMEOUT_KEY = 136,
+    ARGP_VOLUME_NAME_KEY = 137,
+    ARGP_XLATOR_OPTION_KEY = 138,
+    ARGP_DIRECT_IO_MODE_KEY = 139,
 #ifdef GF_DARWIN_HOST_OS
-        ARGP_NON_LOCAL_KEY                = 140,
+    ARGP_NON_LOCAL_KEY = 140,
 #endif /* DARWIN */
-        ARGP_VOLFILE_ID_KEY               = 143,
-        ARGP_VOLFILE_CHECK_KEY            = 144,
-        ARGP_VOLFILE_MAX_FETCH_ATTEMPTS   = 145,
-        ARGP_LOG_SERVER_KEY               = 146,
-        ARGP_LOG_SERVER_PORT_KEY          = 147,
-        ARGP_READ_ONLY_KEY                = 148,
-        ARGP_MAC_COMPAT_KEY               = 149,
-        ARGP_DUMP_FUSE_KEY                = 150,
-        ARGP_BRICK_NAME_KEY               = 151,
-        ARGP_BRICK_PORT_KEY               = 152,
-        ARGP_CLIENT_PID_KEY               = 153,
-        ARGP_ACL_KEY                      = 154,
-        ARGP_WORM_KEY                     = 155,
-        ARGP_USER_MAP_ROOT_KEY            = 156,
-        ARGP_MEM_ACCOUNTING_KEY           = 157,
-        ARGP_SELINUX_KEY                  = 158,
-	ARGP_FOPEN_KEEP_CACHE_KEY	  = 159,
-	ARGP_GID_TIMEOUT_KEY		  = 160,
-	ARGP_FUSE_BACKGROUND_QLEN_KEY     = 161,
-	ARGP_FUSE_CONGESTION_THRESHOLD_KEY = 162,
-        ARGP_INODE32_KEY                  = 163,
-	ARGP_FUSE_MOUNTOPTS_KEY		  = 164,
-        ARGP_FUSE_USE_READDIRP_KEY        = 165,
-	ARGP_AUX_GFID_MOUNT_KEY		  = 166,
-        ARGP_FUSE_NO_ROOT_SQUASH_KEY      = 167,
-        ARGP_LOGGER                       = 168,
-        ARGP_LOG_FORMAT                   = 169,
-        ARGP_LOG_BUF_SIZE                 = 170,
-        ARGP_LOG_FLUSH_TIMEOUT            = 171,
-        ARGP_SECURE_MGMT_KEY              = 172,
-        ARGP_GLOBAL_TIMER_WHEEL           = 173,
-        ARGP_RESOLVE_GIDS_KEY             = 174,
-        ARGP_CAPABILITY_KEY               = 175,
+    ARGP_VOLFILE_ID_KEY = 143,
+    ARGP_VOLFILE_CHECK_KEY = 144,
+    ARGP_VOLFILE_MAX_FETCH_ATTEMPTS = 145,
+    ARGP_LOG_SERVER_KEY = 146,
+    ARGP_LOG_SERVER_PORT_KEY = 147,
+    ARGP_READ_ONLY_KEY = 148,
+    ARGP_MAC_COMPAT_KEY = 149,
+    ARGP_DUMP_FUSE_KEY = 150,
+    ARGP_BRICK_NAME_KEY = 151,
+    ARGP_BRICK_PORT_KEY = 152,
+    ARGP_CLIENT_PID_KEY = 153,
+    ARGP_ACL_KEY = 154,
+    ARGP_WORM_KEY = 155,
+    ARGP_USER_MAP_ROOT_KEY = 156,
+    ARGP_MEM_ACCOUNTING_KEY = 157,
+    ARGP_SELINUX_KEY = 158,
+    ARGP_FOPEN_KEEP_CACHE_KEY = 159,
+    ARGP_GID_TIMEOUT_KEY = 160,
+    ARGP_FUSE_BACKGROUND_QLEN_KEY = 161,
+    ARGP_FUSE_CONGESTION_THRESHOLD_KEY = 162,
+    ARGP_INODE32_KEY = 163,
+    ARGP_FUSE_MOUNTOPTS_KEY = 164,
+    ARGP_FUSE_USE_READDIRP_KEY = 165,
+    ARGP_AUX_GFID_MOUNT_KEY = 166,
+    ARGP_FUSE_NO_ROOT_SQUASH_KEY = 167,
+    ARGP_LOGGER = 168,
+    ARGP_LOG_FORMAT = 169,
+    ARGP_LOG_BUF_SIZE = 170,
+    ARGP_LOG_FLUSH_TIMEOUT = 171,
+    ARGP_SECURE_MGMT_KEY = 172,
+    ARGP_GLOBAL_TIMER_WHEEL = 173,
+    ARGP_RESOLVE_GIDS_KEY = 174,
+    ARGP_CAPABILITY_KEY = 175,
 #ifdef GF_LINUX_HOST_OS
-        ARGP_OOM_SCORE_ADJ_KEY            = 176,
+    ARGP_OOM_SCORE_ADJ_KEY = 176,
 #endif
-        ARGP_LOCALTIME_LOGGING_KEY        = 177,
-        ARGP_SUBDIR_MOUNT_KEY             = 178,
-        ARGP_FUSE_EVENT_HISTORY_KEY       = 179,
+    ARGP_LOCALTIME_LOGGING_KEY = 177,
+    ARGP_SUBDIR_MOUNT_KEY = 178,
+    ARGP_PROCESS_NAME_KEY = 179,
+    ARGP_FUSE_EVENT_HISTORY_KEY = 180,
+    ARGP_THIN_CLIENT_KEY = 181,
+    ARGP_READER_THREAD_COUNT_KEY = 182,
+    ARGP_PRINT_XLATORDIR_KEY = 183,
+    ARGP_PRINT_STATEDUMPDIR_KEY = 184,
+    ARGP_PRINT_LOGDIR_KEY = 185,
+    ARGP_KERNEL_WRITEBACK_CACHE_KEY = 186,
+    ARGP_ATTR_TIMES_GRANULARITY_KEY = 187,
+    ARGP_PRINT_LIBEXECDIR_KEY = 188,
+    ARGP_FUSE_FLUSH_HANDLE_INTERRUPT_KEY = 189,
+    ARGP_FUSE_LRU_LIMIT_KEY = 190,
+    ARGP_FUSE_AUTO_INVAL_KEY = 191,
+    ARGP_GLOBAL_THREADING_KEY = 192,
+    ARGP_BRICK_MUX_KEY = 193,
+    ARGP_FUSE_DEV_EPERM_RATELIMIT_NS_KEY = 194,
+    ARGP_FUSE_INVALIDATE_LIMIT_KEY = 195,
 };
 
 struct _gfd_vol_top_priv {
-        rpcsvc_request_t        *req;
-        gd1_mgmt_brick_op_req   xlator_req;
-        uint32_t                blk_count;
-        uint32_t                blk_size;
-        double                  throughput;
-        double                  time;
-        int32_t                 ret;
+    rpcsvc_request_t *req;
+    gd1_mgmt_brick_op_req xlator_req;
+    uint32_t blk_count;
+    uint32_t blk_size;
+    double throughput;
+    double time;
+    int32_t ret;
 };
 typedef struct _gfd_vol_top_priv gfd_vol_top_priv_t;
 
-int glusterfs_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brick_name);
-int glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx);
-int glusterfs_volfile_fetch (glusterfs_ctx_t *ctx);
-void cleanup_and_exit (int signum);
+int
+glusterfs_mgmt_pmap_signin(glusterfs_ctx_t *ctx);
+int
+glusterfs_volfile_fetch(glusterfs_ctx_t *ctx);
+void
+cleanup_and_exit(int signum);
 
-int glusterfs_volume_top_write_perf (uint32_t blk_size, uint32_t blk_count,
-                                     char *brick_path, double *throughput,
-                                     double *time);
-int glusterfs_volume_top_read_perf (uint32_t blk_size, uint32_t blk_count,
-                                    char *brick_path, double *throughput,
-                                    double *time);
 void
-glusterfs_autoscale_threads (glusterfs_ctx_t *ctx, int incr);
+xlator_mem_cleanup(xlator_t *this);
 
 extern glusterfs_ctx_t *glusterfsd_ctx;
 #endif /* __GLUSTERFSD_H__ */
diff --git a/heal/src/Makefile.am b/heal/src/Makefile.am
index 830f9d9238b..aa18d3eff88 100644
--- a/heal/src/Makefile.am
+++ b/heal/src/Makefile.am
@@ -1,4 +1,7 @@
-sbin_PROGRAMS = glfsheal
+if WITH_SERVER
+scriptdir = $(GLUSTERFS_LIBEXECDIR)
+script_PROGRAMS = glfsheal
+endif
 
 glfsheal_SOURCES = glfs-heal.c
 
@@ -16,12 +19,9 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \
 	-I$(top_srcdir)/rpc/xdr/src\
 	-I$(top_builddir)/rpc/xdr/src\
 	-I$(top_srcdir)/api/src\
-	-I$(top_srcdir)/contrib/argp-standalone\
-	-DDATADIR=\"$(localstatedir)\" \
-	-DSBIN_DIR=\"$(sbindir)\" \
-	$(XML_CPPFLAGS)
+	-DDATADIR=\"$(localstatedir)\"
 
-AM_CFLAGS = -Wall $(GF_CFLAGS)
+AM_CFLAGS = -Wall $(GF_CFLAGS) $(XML_CFLAGS)
 
 CLEANFILES =
 
diff --git a/heal/src/glfs-heal.c b/heal/src/glfs-heal.c
index 27115f3ca6c..bf4b47f8760 100644
--- a/heal/src/glfs-heal.c
+++ b/heal/src/glfs-heal.c
@@ -12,15 +12,13 @@
 #include <stdlib.h>
 #include <errno.h>
 #include "glfs.h"
-#include "glfs-handles.h"
 #include "glfs-internal.h"
 #include "protocol-common.h"
-#include "syscall.h"
-#include "syncop.h"
-#include "syncop-utils.h"
+#include <glusterfs/syscall.h>
+#include <glusterfs/syncop.h>
+#include <glusterfs/syncop-utils.h>
 #include <string.h>
-#include <time.h>
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include <libgen.h>
 
 #if (HAVE_LIB_XML)
@@ -28,1292 +26,1459 @@
 #include <libxml/xmlwriter.h>
 
 xmlTextWriterPtr glfsh_writer;
-xmlDocPtr        glfsh_doc = NULL;
+xmlDocPtr glfsh_doc = NULL;
 #endif
 
-#define XML_RET_CHECK_AND_GOTO(ret, label)      do {            \
-                if (ret < 0) {                                  \
-                        ret = -1;                               \
-                        goto label;                             \
-                }                                               \
-                else                                            \
-                        ret = 0;                                \
-        } while (0)                                             \
+#define XML_RET_CHECK_AND_GOTO(ret, label)                                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        } else                                                                 \
+            ret = 0;                                                           \
+    } while (0)
 
-typedef int    (*print_status) (dict_t *, char *, uuid_t, uint64_t *,
-                 gf_boolean_t flag);
+#define MODE_XML (1 << 0)
+#define MODE_NO_LOG (1 << 1)
 
-int glfsh_heal_splitbrain_file (glfs_t *fs, xlator_t *top_subvol,
-                                loc_t *rootloc, char *file, dict_t *xattr_req);
+typedef struct num_entries {
+    uint64_t num_entries;
+    uint64_t pending_entries;
+    uint64_t spb_entries;
+    uint64_t possibly_healing_entries;
+} num_entries_t;
 
+typedef int (*print_status)(dict_t *, char *, uuid_t, num_entries_t *,
+                            gf_boolean_t flag);
+
+int
+glfsh_heal_splitbrain_file(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *file, dict_t *xattr_req);
 
 typedef struct glfs_info {
-        int (*init)(void);
-        int (*print_brick_from_xl)(xlator_t *xl, loc_t *rootloc);
-        int (*print_heal_op_status)(int ret, uint64_t num_entries,
-                        char *fmt_str);
-        void (*print_heal_status)(char *path, uuid_t gfid, char *status);
-        void (*print_spb_status)(char *path, uuid_t gfid, char *status);
-        int (*end) (int op_ret, char *op_errstr);
+    int (*init)(void);
+    int (*print_brick_from_xl)(xlator_t *xl, loc_t *rootloc);
+    int (*print_heal_op_status)(int ret, uint64_t num_entries, char *fmt_str);
+    int (*print_heal_op_summary)(int ret, num_entries_t *num_entries);
+    int (*print_heal_status)(char *path, uuid_t gfid, char *status);
+    int (*print_spb_status)(char *path, uuid_t gfid, char *status);
+    int (*end)(int op_ret, char *op_errstr);
 } glfsh_info_t;
 
 glfsh_info_t *glfsh_output = NULL;
 int32_t is_xml;
 
 #define DEFAULT_HEAL_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
-#define USAGE_STR "Usage: %s <VOLNAME> [bigger-file <FILE> | "\
-                  "latest-mtime <FILE> | "\
-                  "source-brick <HOSTNAME:BRICKNAME> [<FILE>] | "\
-                  "split-brain-info]\n"
+#define USAGE_STR                                                              \
+    "Usage: %s <VOLNAME> [bigger-file <FILE> | "                               \
+    "latest-mtime <FILE> | "                                                   \
+    "source-brick <HOSTNAME:BRICKNAME> [<FILE>] | "                            \
+    "split-brain-info | info-summary] [glusterd-sock <FILE>"                   \
+    "]\n"
 
 typedef enum {
-        GLFSH_MODE_CONTINUE_ON_ERROR = 1,
-        GLFSH_MODE_EXIT_ON_FIRST_FAILURE,
+    GLFSH_MODE_CONTINUE_ON_ERROR = 1,
+    GLFSH_MODE_EXIT_ON_FIRST_FAILURE,
 } glfsh_fail_mode_t;
 
 int
-glfsh_init ()
+glfsh_init()
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_end_op_granular_entry_heal (int op_ret, char *op_errstr)
+glfsh_end_op_granular_entry_heal(int op_ret, char *op_errstr)
 {
-        /* If error sting is available, give it higher precedence.*/
-
-        if (op_errstr) {
-                printf ("%s\n", op_errstr);
-        } else if (op_ret < 0) {
-                if (op_ret == -EAGAIN)
-                        printf ("One or more entries need heal. Please execute "
-                                "the command again after there are no entries "
-                                "to be healed\n");
-                else if (op_ret == -ENOTCONN)
-                        printf ("One or more bricks could be down. Please "
-                                "execute the command again after bringing all "
-                                "bricks online and finishing any pending "
-                                "heals\n");
-                else
-                        printf ("Command failed - %s. Please check the logs for"
-                                " more details\n", strerror (-op_ret));
-        }
-        return 0;
+    /* If error string is available, give it higher precedence.*/
+
+    if (op_errstr) {
+        printf("%s\n", op_errstr);
+    } else if (op_ret < 0) {
+        if (op_ret == -EAGAIN)
+            printf(
+                "One or more entries need heal. Please execute "
+                "the command again after there are no entries "
+                "to be healed\n");
+        else if (op_ret == -ENOTCONN)
+            printf(
+                "One or more bricks could be down. Please "
+                "execute the command again after bringing all "
+                "bricks online and finishing any pending "
+                "heals\n");
+        else
+            printf(
+                "Command failed - %s. Please check the logs for"
+                " more details\n",
+                strerror(-op_ret));
+    }
+    return 0;
 }
 
 int
-glfsh_end (int op_ret, char *op_errstr)
+glfsh_end(int op_ret, char *op_errstr)
 {
-        if (op_errstr)
-                printf ("%s\n", op_errstr);
-        return 0;
+    if (op_errstr)
+        printf("%s\n", op_errstr);
+    return 0;
 }
 
-void
-glfsh_print_hr_spb_status (char *path, uuid_t gfid, char *status)
+int
+glfsh_print_hr_spb_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s\n", path);
-        return;
+    printf("%s\n", path);
+    fflush(stdout);
+    return 0;
 }
 
-void
-glfsh_no_print_hr_heal_status (char *path, uuid_t gfid, char *status)
+int
+glfsh_no_print_hr_status(char *path, uuid_t gfid, char *status)
 {
-        return;
+    return 0;
 }
 
-void
-glfsh_print_hr_heal_status (char *path, uuid_t gfid, char *status)
+int
+glfsh_print_hr_heal_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s%s\n", path, status);
+    printf("%s%s\n", path, status);
+    fflush(stdout);
+    return 0;
 }
 
 #if (HAVE_LIB_XML)
 
 int
-glfsh_xml_init ()
+glfsh_xml_init()
 {
-        int     ret     = -1;
-        glfsh_writer = xmlNewTextWriterDoc (&glfsh_doc, 0);
-        if (glfsh_writer == NULL) {
-                return -1;
-        }
-
-        ret = xmlTextWriterStartDocument (glfsh_writer, "1.0", "UTF-8",
-                        "yes");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* <cliOutput> */
-        ret = xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"cliOutput");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* <healInfo> */
-        xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"healInfo");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-        /* <bricks> */
-        xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"bricks");
-        xmlTextWriterFlush (glfsh_writer);
+    int ret = -1;
+    glfsh_writer = xmlNewTextWriterDoc(&glfsh_doc, 0);
+    if (glfsh_writer == NULL) {
+        return -1;
+    }
+
+    ret = xmlTextWriterStartDocument(glfsh_writer, "1.0", "UTF-8", "yes");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* <cliOutput> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"cliOutput");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* <healInfo> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"healInfo");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    /* <bricks> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"bricks");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    xmlTextWriterFlush(glfsh_writer);
 xml_out:
-        return ret;
+    return ret;
 }
 
 int
-glfsh_xml_end (int op_ret, char *op_errstr)
+glfsh_xml_end(int op_ret, char *op_errstr)
 {
-        int                     ret             = -1;
-        int                     op_errno        = 0;
-        gf_boolean_t            alloc           = _gf_false;
-
-        if (op_ret < 0) {
-                op_errno = -op_ret;
-                op_ret = -1;
-                if (op_errstr == NULL) {
-                        op_errstr = gf_strdup (strerror (op_errno));
-                        alloc = _gf_true;
-                }
-        } else {
-                op_errstr = NULL;
+    int ret = -1;
+    int op_errno = 0;
+    gf_boolean_t alloc = _gf_false;
+
+    if (op_ret < 0) {
+        op_errno = -op_ret;
+        op_ret = -1;
+        if (op_errstr == NULL) {
+            op_errstr = gf_strdup(strerror(op_errno));
+            alloc = _gf_true;
         }
-
-        /* </bricks> */
-        ret = xmlTextWriterEndElement (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* </healInfo> */
-        ret = xmlTextWriterEndElement (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"opRet", "%d", op_ret);
-
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"opErrno",
-                        "%d", op_errno);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        if (op_errstr)
-                ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"opErrstr",
-                                "%s", op_errstr);
-        else
-                ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"opErrstr",
-                                "%s", "");
-        ret = xmlTextWriterEndDocument (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-
-        /* Dump xml document to stdout and pretty format it */
-        xmlSaveFormatFileEnc ("-", glfsh_doc, "UTF-8", 1);
-
-        xmlFreeTextWriter (glfsh_writer);
-        xmlFreeDoc (glfsh_doc);
+    } else {
+        op_errstr = NULL;
+    }
+
+    /* </bricks> */
+    ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* </healInfo> */
+    ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    ret = xmlTextWriterWriteFormatElement(glfsh_writer, (xmlChar *)"opRet",
+                                          "%d", op_ret);
+
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    ret = xmlTextWriterWriteFormatElement(glfsh_writer, (xmlChar *)"opErrno",
+                                          "%d", op_errno);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    if (op_errstr)
+        ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"opErrstr", "%s", op_errstr);
+    else
+        ret = xmlTextWriterWriteFormatElement(glfsh_writer,
+                                              (xmlChar *)"opErrstr", "%s", "");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    ret = xmlTextWriterEndDocument(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* Dump xml document to stdout and pretty format it */
+    xmlSaveFormatFileEnc("-", glfsh_doc, "UTF-8", 1);
+
+    xmlFreeTextWriter(glfsh_writer);
+    xmlFreeDoc(glfsh_doc);
 xml_out:
-        if (alloc)
-                GF_FREE (op_errstr);
-        return ret;
+    if (alloc)
+        GF_FREE(op_errstr);
+    return ret;
 }
 
 int
-glfsh_print_xml_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_print_xml_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        if (ret < 0 && num_entries == 0) {
-                xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"status",
-                                "%s", strerror (-ret));
-                if (fmt_str) {
-                        xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"numberOfEntries",
-                                        "-");
-                }
-                goto out;
-        } else if (ret == 0) {
-                xmlTextWriterWriteFormatElement (glfsh_writer,
-                                                 (xmlChar *)"status",
-                                                 "%s", "Connected");
+    int x_ret = 0;
+    if (ret < 0 && num_entries == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", strerror(-ret));
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"numberOfEntries", "-");
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
         }
-
-        if (ret < 0) {
-                if (fmt_str) {
-                        xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"status",
-                                        "Failed to process entries completely. "
-                                        "(%s)%s %"PRIu64"", strerror (-ret),
-                                        fmt_str,
-                                        num_entries);
-                }
-        } else {
-                if (fmt_str)
-                        xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"numberOfEntries",
-                                        "%"PRIu64"", num_entries);
+        goto out;
+    } else if (ret == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", "Connected");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
+
+    if (ret < 0) {
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"status",
+                "Failed to process entries completely. "
+                "(%s)%s %" PRIu64 "",
+                strerror(-ret), fmt_str, num_entries);
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
         }
+    } else {
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"numberOfEntries", "%" PRIu64 "",
+                num_entries);
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
+        }
+    }
 out:
-        ret = xmlTextWriterEndElement (glfsh_writer);
-        xmlTextWriterFlush (glfsh_writer);
-        return ret;
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
+        if (x_ret >= 0) {
+            xmlTextWriterFlush(glfsh_writer);
+            x_ret = 0;
+        } else {
+            x_ret = -1;
+        }
+    }
+    return x_ret;
 }
 
-void
-glfsh_print_xml_file_status (char *path, uuid_t gfid, char *status)
+int
+glfsh_print_xml_heal_op_summary(int ret, num_entries_t *num_entries)
 {
-        xmlTextWriterStartElement (glfsh_writer, (xmlChar *)"file");
-        xmlTextWriterWriteFormatAttribute (glfsh_writer, (xmlChar *)"gfid",
-                                           "%s", uuid_utoa (gfid));
-        xmlTextWriterWriteFormatString (glfsh_writer, "%s", path);
-        xmlTextWriterEndElement (glfsh_writer);
-        xmlTextWriterFlush (glfsh_writer);
-        return;
+    int x_ret = 0;
+
+    if (ret < 0 && num_entries == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", strerror(-ret));
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"totalNumberOfEntries", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInHealPending", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInSplitBrain", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesPossiblyHealing", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        goto out;
+    } else if (ret == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", "Connected");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
+
+    if (ret < 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status",
+            "Failed to process entries"
+            " completely. "
+            "(%s)totalNumberOfEntries%" PRIu64 "",
+            strerror(-ret), num_entries->num_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    } else {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"totalNumberOfEntries", "%" PRIu64 "",
+            num_entries->num_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInHealPending",
+            "%" PRIu64 "", num_entries->pending_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInSplitBrain",
+            "%" PRIu64 "", num_entries->spb_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesPossiblyHealing",
+            "%" PRIu64 "", num_entries->possibly_healing_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
+out:
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
+    }
+    return x_ret;
 }
 
 int
-glfsh_print_xml_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_print_xml_file_status(char *path, uuid_t gfid, char *status)
 {
-        char    *remote_host = NULL;
-        char    *remote_subvol = NULL;
-        char    *uuid = NULL;
-        int     ret = 0;
-        int     x_ret = 0;
-
-        ret = dict_get_str (xl->options, "remote-host", &remote_host);
-        if (ret < 0)
-                goto print;
-
-        ret = dict_get_str (xl->options, "remote-subvolume", &remote_subvol);
-        if (ret < 0)
-                goto print;
-        ret = syncop_getxattr (xl, rootloc, &xl->options,
-                        GF_XATTR_NODE_UUID_KEY, NULL, NULL);
-        if (ret < 0)
-                goto print;
+    int x_ret = 0;
+
+    x_ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterWriteFormatAttribute(glfsh_writer, (xmlChar *)"gfid",
+                                              "%s", uuid_utoa(gfid));
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterWriteFormatString(glfsh_writer, "%s", path);
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    xmlTextWriterFlush(glfsh_writer);
+out:
+    return x_ret;
+}
 
-        ret = dict_get_str (xl->options, GF_XATTR_NODE_UUID_KEY, &uuid);
-        if (ret < 0)
-                goto print;
+int
+glfsh_print_xml_brick_from_xl(xlator_t *xl, loc_t *rootloc)
+{
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
+    char *uuid = NULL;
+    int ret = 0;
+    int x_ret = 0;
+
+    ret = dict_get_str(xl->options, "remote-host", &remote_host);
+    if (ret < 0)
+        goto print;
+
+    ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+    if (ret < 0)
+        goto print;
+    ret = syncop_getxattr(xl, rootloc, &xl->options, GF_XATTR_NODE_UUID_KEY,
+                          NULL, NULL);
+    if (ret < 0)
+        goto print;
+
+    ret = dict_get_str(xl->options, GF_XATTR_NODE_UUID_KEY, &uuid);
+    if (ret < 0)
+        goto print;
 print:
 
-        x_ret = xmlTextWriterStartElement (glfsh_writer, (xmlChar *)"brick");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-        x_ret = xmlTextWriterWriteFormatAttribute (glfsh_writer,
-                        (xmlChar *)"hostUuid", "%s", uuid?uuid:"-");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-
-        x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"name", "%s:%s",
-                        remote_host ? remote_host : "-",
-                        remote_subvol ? remote_subvol : "-");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-        xmlTextWriterFlush (glfsh_writer);
+    x_ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"brick");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+    x_ret = xmlTextWriterWriteFormatAttribute(
+        glfsh_writer, (xmlChar *)"hostUuid", "%s", uuid ? uuid : "-");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+
+    x_ret = xmlTextWriterWriteFormatElement(
+        glfsh_writer, (xmlChar *)"name", "%s:%s",
+        remote_host ? remote_host : "-", remote_subvol ? remote_subvol : "-");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+    xmlTextWriterFlush(glfsh_writer);
 xml_out:
-        return ret;
+    return ret;
 }
 #endif
 
 int
-glfsh_link_inode_update_loc (loc_t *loc, struct iatt *iattr)
+glfsh_link_inode_update_loc(loc_t *loc, struct iatt *iattr)
 {
-        inode_t       *link_inode = NULL;
-        int           ret = -1;
+    inode_t *link_inode = NULL;
+    int ret = -1;
 
-        link_inode = inode_link (loc->inode, NULL, NULL, iattr);
-        if (link_inode == NULL)
-                goto out;
+    link_inode = inode_link(loc->inode, NULL, NULL, iattr);
+    if (link_inode == NULL)
+        goto out;
 
-        inode_unref (loc->inode);
-        loc->inode = link_inode;
-        ret = 0;
+    inode_unref(loc->inode);
+    loc->inode = link_inode;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfsh_no_print_hr_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_no_print_hr_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_print_hr_heal_op_summary(int ret, num_entries_t *num_entries)
 {
-        if (ret < 0 && num_entries == 0) {
-                printf ("Status: %s\n", strerror (-ret));
-                if (fmt_str)
-                        printf ("%s -\n", fmt_str);
-                goto out;
-        } else if (ret == 0) {
-                printf ("Status: Connected\n");
-        }
-
-        if (ret < 0) {
-                if (fmt_str)
-                        printf ("Status: Failed to process entries completely. "
-                                "(%s)\n%s %"PRIu64"\n",
-                         strerror (-ret), fmt_str, num_entries);
-        } else {
-                if (fmt_str)
-                        printf ("%s %"PRIu64"\n", fmt_str, num_entries);
-        }
+    if (ret < 0 && num_entries->num_entries == 0) {
+        printf("Status: %s\n", strerror(-ret));
+        printf("Total Number of entries: -\n");
+        printf("Number of entries in heal pending: -\n");
+        printf("Number of entries in split-brain: -\n");
+        printf("Number of entries possibly healing: -\n");
+        goto out;
+    } else if (ret == 0) {
+        printf("Status: Connected\n");
+    }
+
+    if (ret < 0) {
+        printf(
+            "Status: Failed to process entries completely. "
+            "(%s)\nTotal Number of entries: %" PRIu64 "\n",
+            strerror(-ret), num_entries->num_entries);
+    } else {
+        printf("Total Number of entries: %" PRIu64 "\n",
+               num_entries->num_entries);
+        printf("Number of entries in heal pending: %" PRIu64 "\n",
+               num_entries->pending_entries);
+        printf("Number of entries in split-brain: %" PRIu64 "\n",
+               num_entries->spb_entries);
+        printf("Number of entries possibly healing: %" PRIu64 "\n",
+               num_entries->possibly_healing_entries);
+    }
 out:
-        printf ("\n");
-        return 0;
+    printf("\n");
+    fflush(stdout);
+    return 0;
 }
 
 int
-glfsh_print_heal_op_status (int ret, uint64_t num_entries,
-                            gf_xl_afr_op_t heal_op)
+glfsh_print_hr_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        char *fmt_str = NULL;
-
-        if (heal_op == GF_SHD_OP_INDEX_SUMMARY)
-                fmt_str = "Number of entries:";
-        else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES)
-                fmt_str = "Number of entries in split-brain:";
-        else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK)
-                fmt_str = "Number of healed entries:";
+    if (ret < 0 && num_entries == 0) {
+        printf("Status: %s\n", strerror(-ret));
+        if (fmt_str)
+            printf("%s -\n", fmt_str);
+        goto out;
+    } else if (ret == 0) {
+        printf("Status: Connected\n");
+    }
+
+    if (ret < 0) {
+        if (fmt_str)
+            printf(
+                "Status: Failed to process entries completely. "
+                "(%s)\n%s %" PRIu64 "\n",
+                strerror(-ret), fmt_str, num_entries);
+    } else {
+        if (fmt_str)
+            printf("%s %" PRIu64 "\n", fmt_str, num_entries);
+    }
+out:
+    printf("\n");
+    return 0;
+}
 
-        return glfsh_output->print_heal_op_status (ret, num_entries, fmt_str);
+int
+glfsh_print_info_summary(int ret, num_entries_t *num_entries)
+{
+    return glfsh_output->print_heal_op_summary(ret, num_entries);
 }
 
 int
-glfsh_get_index_dir_loc (loc_t *rootloc, xlator_t *xl, loc_t *dirloc,
-                         int32_t *op_errno, char *vgfid)
+glfsh_print_heal_op_status(int ret, uint64_t num_entries,
+                           gf_xl_afr_op_t heal_op)
 {
-        void      *index_gfid = NULL;
-        int       ret = 0;
-        dict_t    *xattr = NULL;
-        struct iatt   iattr = {0};
-        struct iatt   parent = {0};
-
-        ret = syncop_getxattr (xl, rootloc, &xattr, vgfid, NULL, NULL);
-        if (ret < 0) {
-                *op_errno = -ret;
-                goto out;
-        }
+    char *fmt_str = NULL;
 
-        ret = dict_get_ptr (xattr, vgfid, &index_gfid);
-        if (ret < 0) {
-                *op_errno = EINVAL;
-                goto out;
-        }
+    if (heal_op == GF_SHD_OP_INDEX_SUMMARY)
+        fmt_str = "Number of entries:";
+    else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES)
+        fmt_str = "Number of entries in split-brain:";
+    else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK)
+        fmt_str = "Number of healed entries:";
 
-        gf_uuid_copy (dirloc->gfid, index_gfid);
-        dirloc->path = "";
-        dirloc->inode = inode_new (rootloc->inode->table);
-        ret = syncop_lookup (xl, dirloc, &iattr, &parent, NULL, NULL);
-        dirloc->path = NULL;
-        if (ret < 0) {
-                *op_errno = -ret;
-                goto out;
-        }
-        ret = glfsh_link_inode_update_loc (dirloc, &iattr);
-        if (ret)
-                goto out;
-        glfs_loc_touchup (dirloc);
+    return glfsh_output->print_heal_op_status(ret, num_entries, fmt_str);
+}
 
-        ret = 0;
+int
+glfsh_get_index_dir_loc(loc_t *rootloc, xlator_t *xl, loc_t *dirloc,
+                        int32_t *op_errno, char *vgfid)
+{
+    void *index_gfid = NULL;
+    int ret = 0;
+    dict_t *xattr = NULL;
+    struct iatt iattr = {0};
+    struct iatt parent = {0};
+
+    ret = syncop_getxattr(xl, rootloc, &xattr, vgfid, NULL, NULL);
+    if (ret < 0) {
+        *op_errno = -ret;
+        goto out;
+    }
+
+    ret = dict_get_ptr(xattr, vgfid, &index_gfid);
+    if (ret < 0) {
+        *op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_uuid_copy(dirloc->gfid, index_gfid);
+    dirloc->path = "";
+    dirloc->inode = inode_new(rootloc->inode->table);
+    ret = syncop_lookup(xl, dirloc, &iattr, &parent, NULL, NULL);
+    dirloc->path = NULL;
+    if (ret < 0) {
+        *op_errno = -ret;
+        goto out;
+    }
+    ret = glfsh_link_inode_update_loc(dirloc, &iattr);
+    if (ret)
+        goto out;
+
+    ret = glfs_loc_touchup(dirloc);
+    if (ret < 0) {
+        *op_errno = errno;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (xattr)
-                dict_unref (xattr);
-        return ret;
+    if (xattr)
+        dict_unref(xattr);
+    return ret;
 }
 
-static xlator_t*
-_get_ancestor (xlator_t *xl, gf_xl_afr_op_t heal_op)
+static xlator_t *
+_get_ancestor(xlator_t *xl, gf_xl_afr_op_t heal_op)
 {
-        static char *replica_xl[] = {"cluster/replicate", NULL};
-        static char *heal_xls[] = {"cluster/replicate", "cluster/disperse",
-                                         NULL};
-        char **ancestors = NULL;
+    static char *replica_xl[] = {"cluster/replicate", NULL};
+    static char *heal_xls[] = {"cluster/replicate", "cluster/disperse", NULL};
+    char **ancestors = NULL;
 
-        if (heal_op == GF_SHD_OP_INDEX_SUMMARY)
-                ancestors = heal_xls;
-        else
-                ancestors = replica_xl;
+    if (heal_op == GF_SHD_OP_INDEX_SUMMARY || heal_op == GF_SHD_OP_HEAL_SUMMARY)
+        ancestors = heal_xls;
+    else
+        ancestors = replica_xl;
 
-        if (!xl || !xl->parents)
-                return NULL;
+    if (!xl || !xl->parents)
+        return NULL;
 
-        while (xl->parents) {
-                xl = xl->parents->xlator;
-                if (!xl)
-                        break;
-                if (gf_get_index_by_elem (ancestors, xl->type) != -1)
-                        return xl;
-        }
+    while (xl->parents) {
+        xl = xl->parents->xlator;
+        if (!xl)
+            break;
+        if (gf_get_index_by_elem(ancestors, xl->type) != -1)
+            return xl;
+    }
 
-        return NULL;
+    return NULL;
 }
 
 int
-glfsh_index_purge (xlator_t *subvol, inode_t *inode, char *name)
+glfsh_index_purge(xlator_t *subvol, inode_t *inode, char *name)
 {
-        loc_t loc = {0, };
-        int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
 
-        loc.parent = inode_ref (inode);
-        loc.name = name;
+    loc.parent = inode_ref(inode);
+    loc.name = name;
 
-        ret = syncop_unlink (subvol, &loc, NULL, NULL);
+    ret = syncop_unlink(subvol, &loc, NULL, NULL);
 
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-glfsh_print_spb_status (dict_t *dict, char *path, uuid_t gfid,
-                        uint64_t *num_entries, gf_boolean_t flag)
+glfsh_print_summary_status(dict_t *dict, char *path, uuid_t gfid,
+                           num_entries_t *num_entries, gf_boolean_t flag)
 {
-        int   ret    = 0;
-        gf_boolean_t    pending         = _gf_false;
-        gf_boolean_t    split_b         = _gf_false;
-        char            *value          = NULL;
-        char            gfid_str[64]    = {0};
+    int ret = 0;
+    char *value = NULL;
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret)
+        goto out;
+
+    if ((!strcmp(value, "heal")) || (!strcmp(value, "heal-pending"))) {
+        (num_entries->pending_entries)++;
+    } else if ((!strcmp(value, "split-brain")) ||
+               (!strcmp(value, "split-brain-pending"))) {
+        (num_entries->spb_entries)++;
+    } else if ((!strcmp(value, "possibly-healing-pending")) ||
+               (!strcmp(value, "possibly-healing"))) {
+        (num_entries->possibly_healing_entries)++;
+    } else {
+        goto out;
+    }
+    (num_entries->num_entries)++;
+out:
+    return ret;
+}
 
-        ret = dict_get_str (dict, "heal-info", &value);
-        if (ret)
-                return 0;
+int
+glfsh_print_spb_status(dict_t *dict, char *path, uuid_t gfid,
+                       num_entries_t *num_entries, gf_boolean_t flag)
+{
+    int ret = 0;
+    gf_boolean_t pending = _gf_false;
+    gf_boolean_t split_b = _gf_false;
+    char *value = NULL;
+    char gfid_str[64] = {0};
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret)
+        return 0;
 
-        if (!strcmp (value, "split-brain")) {
-                split_b = _gf_true;
-        } else if (!strcmp (value, "split-brain-pending")) {
-                split_b = _gf_true;
-                pending = _gf_true;
-        }
-        /* Consider the entry only iff :
-         * 1) The dir being processed is not indices/dirty, indicated by
-         *    flag == _gf_false
-         * 2) The dir being processed is indices/dirty but the entry also
-         *    exists in indices/xattrop dir and has already been processed.
-         */
-        if (split_b) {
-                if (!flag || (flag && !pending)) {
-                        (*num_entries)++;
-                        glfsh_output->print_spb_status (path ? path :
-                                                uuid_utoa_r (gfid, gfid_str),
-                                                gfid, NULL);
-                }
+    if (!strcmp(value, "split-brain")) {
+        split_b = _gf_true;
+    } else if (!strcmp(value, "split-brain-pending")) {
+        split_b = _gf_true;
+        pending = _gf_true;
+    }
+    /* Consider the entry only iff :
+     * 1) The dir being processed is not indices/dirty, indicated by
+     *    flag == _gf_false
+     * 2) The dir being processed is indices/dirty but the entry also
+     *    exists in indices/xattrop dir and has already been processed.
+     */
+    if (split_b) {
+        if (!flag || (flag && !pending)) {
+            (num_entries->num_entries)++;
+            glfsh_output->print_spb_status(
+                path ? path : uuid_utoa_r(gfid, gfid_str), gfid, NULL);
         }
-        return 0;
+    }
+    return 0;
 }
 
 int
-glfsh_print_heal_status (dict_t *dict, char *path, uuid_t gfid,
-                         uint64_t *num_entries, gf_boolean_t ignore_dirty)
+glfsh_print_heal_status(dict_t *dict, char *path, uuid_t gfid,
+                        num_entries_t *num_entries, gf_boolean_t ignore_dirty)
 {
-        int             ret             = 0;
-        gf_boolean_t    pending         = _gf_false;
-        char            *status         = NULL;
-        char            *value          = NULL;
-        char            gfid_str[64]    = {0};
-
-        ret = dict_get_str (dict, "heal-info", &value);
-        if (ret || (!strcmp (value, "no-heal")))
-                return 0;
-
-        if (!strcmp (value, "heal")) {
-                ret = gf_asprintf (&status, " ");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "possibly-healing")) {
-                ret = gf_asprintf (&status,
-                                   " - Possibly undergoing heal\n");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "split-brain")) {
-                ret = gf_asprintf (&status, " - Is in split-brain\n");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "heal-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status, " ");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "split-brain-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status, " - Is in split-brain\n");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "possibly-healing-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status,
-                                   " - Possibly undergoing heal\n");
-                if (ret < 0)
-                        goto out;
-        }
+    int ret = 0;
+    gf_boolean_t pending = _gf_false;
+    char *status = NULL;
+    char *value = NULL;
+    char gfid_str[64] = {0};
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret || (!strcmp(value, "no-heal")))
+        return 0;
+
+    if (!strcmp(value, "heal")) {
+        ret = gf_asprintf(&status, " ");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "possibly-healing")) {
+        ret = gf_asprintf(&status, " - Possibly undergoing heal");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "split-brain")) {
+        ret = gf_asprintf(&status, " - Is in split-brain");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "heal-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " ");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "split-brain-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " - Is in split-brain");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "possibly-healing-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " - Possibly undergoing heal");
+        if (ret < 0)
+            goto out;
+    }
 out:
-        /* If ignore_dirty is set, it means indices/dirty directory is
-         * being processed. Ignore the entry if it also exists in
-         * indices/xattrop.
-         * Boolean pending is set to true if the entry also exists in
-         * indices/xattrop directory.
-         */
-        if (ignore_dirty) {
-                if (pending) {
-                        GF_FREE (status);
-                        status = NULL;
-                        return 0;
-                }
+    /* If ignore_dirty is set, it means indices/dirty directory is
+     * being processed. Ignore the entry if it also exists in
+     * indices/xattrop.
+     * Boolean pending is set to true if the entry also exists in
+     * indices/xattrop directory.
+     */
+    if (ignore_dirty) {
+        if (pending) {
+            GF_FREE(status);
+            status = NULL;
+            return 0;
         }
-        if (ret == -1)
-                status = NULL;
+    }
+    if (ret == -1)
+        status = NULL;
 
-        (*num_entries)++;
-        glfsh_output->print_heal_status (path ? path :
-                                         uuid_utoa_r (gfid, gfid_str),
-                                         gfid,
-                                         status ? status : "");
+    (num_entries->num_entries)++;
+    glfsh_output->print_heal_status(path ? path : uuid_utoa_r(gfid, gfid_str),
+                                    gfid, status ? status : "");
 
-        GF_FREE (status);
-        return 0;
+    GF_FREE(status);
+    return 0;
 }
 
 int
-glfsh_heal_status_boolean (dict_t *dict, char *path, uuid_t gfid,
-                           uint64_t *num_entries, gf_boolean_t ignore_dirty)
+glfsh_heal_status_boolean(dict_t *dict, char *path, uuid_t gfid,
+                          num_entries_t *num_entries, gf_boolean_t ignore_dirty)
 {
-        int             ret             = 0;
-        char            *value          = NULL;
+    int ret = 0;
+    char *value = NULL;
 
-        ret = dict_get_str (dict, "heal-info", &value);
-        if ((!ret) && (!strcmp (value, "no-heal")))
-                return 0;
-        else
-                return -1;
+    ret = dict_get_str(dict, "heal-info", &value);
+    if ((!ret) && (!strcmp(value, "no-heal")))
+        return 0;
+    else
+        return -1;
 }
 
-static int
-glfsh_heal_entries (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                    gf_dirent_t *entries,  uint64_t *offset,
-                    uint64_t *num_entries, dict_t *xattr_req) {
-
-        gf_dirent_t      *entry          = NULL;
-        gf_dirent_t      *tmp            = NULL;
-        int               ret            = 0;
-        char              file[64]      = {0};
-
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                *offset = entry->d_off;
-                if ((strcmp (entry->d_name, ".") == 0) ||
-                    (strcmp (entry->d_name, "..") == 0))
-                        continue;
-                memset (file, 0, sizeof(file));
-                snprintf (file, sizeof(file), "gfid:%s", entry->d_name);
-                ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                                 xattr_req);
-                if (ret)
-                        continue;
-                (*num_entries)++;
-        }
-
-        return ret;
+static void
+glfsh_heal_entries(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                   gf_dirent_t *entries, uint64_t *offset,
+                   num_entries_t *num_entries, dict_t *xattr_req)
+{
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    int ret = 0;
+    char file[64] = {0};
+
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        *offset = entry->d_off;
+        if ((strcmp(entry->d_name, ".") == 0) ||
+            (strcmp(entry->d_name, "..") == 0))
+            continue;
+        snprintf(file, sizeof(file), "gfid:%s", entry->d_name);
+        ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file,
+                                         xattr_req);
+        if (ret)
+            continue;
+        (num_entries->num_entries)++;
+    }
 }
 
 static int
-glfsh_process_entries (xlator_t *xl, fd_t *fd, gf_dirent_t *entries,
-                       uint64_t *offset, uint64_t *num_entries,
-                       print_status glfsh_print_status,
-                       gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode)
+glfsh_process_entries(xlator_t *xl, fd_t *fd, gf_dirent_t *entries,
+                      uint64_t *offset, num_entries_t *num_entries,
+                      print_status glfsh_print_status,
+                      gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode)
 {
-        gf_dirent_t      *entry = NULL;
-        gf_dirent_t      *tmp = NULL;
-        int              ret = 0;
-        int              print_status = 0;
-        char            *path = NULL;
-        uuid_t          gfid = {0};
-        xlator_t        *this = NULL;
-        dict_t          *dict = NULL;
-        loc_t           loc   = {0,};
-        this = THIS;
-
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                *offset = entry->d_off;
-                if ((strcmp (entry->d_name, ".") == 0) ||
-                    (strcmp (entry->d_name, "..") == 0))
-                        continue;
-
-                if (dict) {
-                        dict_unref (dict);
-                        dict = NULL;
-                }
-                gf_uuid_clear (gfid);
-                GF_FREE (path);
-                path = NULL;
-
-                gf_uuid_parse (entry->d_name, gfid);
-                gf_uuid_copy (loc.gfid, gfid);
-                ret = syncop_getxattr (this, &loc, &dict, GF_HEAL_INFO, NULL,
-                                       NULL);
-                if (ret) {
-                        if ((mode != GLFSH_MODE_CONTINUE_ON_ERROR) &&
-                            (ret == -ENOTCONN))
-                                goto out;
-                        else
-                                continue;
-                }
-
-                ret = syncop_gfid_to_path (this->itable, xl, gfid, &path);
-
-                if (ret == -ENOENT || ret == -ESTALE) {
-                        glfsh_index_purge (xl, fd->inode, entry->d_name);
-                        ret = 0;
-                        continue;
-                }
-                if (dict) {
-                        print_status = glfsh_print_status (dict, path, gfid,
-                                                           num_entries,
-                                                           ignore_dirty);
-                        if ((print_status) &&
-                            (mode != GLFSH_MODE_CONTINUE_ON_ERROR)) {
-                                ret = -EAGAIN;
-                                goto out;
-                        }
-                }
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    int ret = 0;
+    int print_status = 0;
+    char *path = NULL;
+    uuid_t gfid = {0};
+    xlator_t *this = NULL;
+    dict_t *dict = NULL;
+    loc_t loc = {
+        0,
+    };
+    this = THIS;
+
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        *offset = entry->d_off;
+        if ((strcmp(entry->d_name, ".") == 0) ||
+            (strcmp(entry->d_name, "..") == 0))
+            continue;
+
+        if (dict) {
+            dict_unref(dict);
+            dict = NULL;
+        }
+        gf_uuid_clear(gfid);
+        GF_FREE(path);
+        path = NULL;
+
+        gf_uuid_parse(entry->d_name, gfid);
+        gf_uuid_copy(loc.gfid, gfid);
+        ret = syncop_getxattr(this, &loc, &dict, GF_HEAL_INFO, NULL, NULL);
+        if (ret) {
+            if ((mode != GLFSH_MODE_CONTINUE_ON_ERROR) && (ret == -ENOTCONN))
+                goto out;
+            else
+                continue;
+        }
+
+        ret = syncop_gfid_to_path(this->itable, xl, gfid, &path);
+
+        if (ret == -ENOENT || ret == -ESTALE) {
+            glfsh_index_purge(xl, fd->inode, entry->d_name);
+            ret = 0;
+            continue;
         }
-        ret = 0;
-out:
-        GF_FREE (path);
         if (dict) {
-                dict_unref (dict);
-                dict = NULL;
+            print_status = glfsh_print_status(dict, path, gfid, num_entries,
+                                              ignore_dirty);
+            if ((print_status) && (mode != GLFSH_MODE_CONTINUE_ON_ERROR)) {
+                ret = -EAGAIN;
+                goto out;
+            }
         }
-        return ret;
+    }
+    ret = 0;
+out:
+    GF_FREE(path);
+    if (dict) {
+        dict_unref(dict);
+        dict = NULL;
+    }
+    return ret;
 }
 
 static int
-glfsh_crawl_directory (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                       xlator_t *readdir_xl, fd_t *fd, loc_t *loc,
-                       dict_t *xattr_req, uint64_t *num_entries,
-                       gf_boolean_t ignore)
+glfsh_crawl_directory(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                      xlator_t *readdir_xl, fd_t *fd, loc_t *loc,
+                      dict_t *xattr_req, num_entries_t *num_entries,
+                      gf_boolean_t ignore)
 {
-        int             ret          = 0;
-        int             heal_op      = -1;
-        uint64_t        offset       = 0;
-        gf_dirent_t     entries;
-        gf_boolean_t    free_entries = _gf_false;
-        glfsh_fail_mode_t mode = GLFSH_MODE_CONTINUE_ON_ERROR;
-
-        INIT_LIST_HEAD (&entries.list);
-        ret = dict_get_int32 (xattr_req, "heal-op", &heal_op);
-        if (ret)
-                return ret;
+    int ret = 0;
+    int heal_op = -1;
+    uint64_t offset = 0;
+    gf_dirent_t entries;
+    gf_boolean_t free_entries = _gf_false;
+    glfsh_fail_mode_t mode = GLFSH_MODE_CONTINUE_ON_ERROR;
+
+    INIT_LIST_HEAD(&entries.list);
+    ret = dict_get_int32(xattr_req, "heal-op", &heal_op);
+    if (ret)
+        return ret;
 
-        if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                mode = GLFSH_MODE_EXIT_ON_FIRST_FAILURE;
+    if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        mode = GLFSH_MODE_EXIT_ON_FIRST_FAILURE;
 
-        while (1) {
-                ret = syncop_readdir (readdir_xl, fd, 131072, offset, &entries,
-                                      NULL, NULL);
-                if (ret <= 0)
-                        break;
-                ret = 0;
-                free_entries = _gf_true;
-
-                if (list_empty (&entries.list))
-                        goto out;
-
-                if (heal_op == GF_SHD_OP_INDEX_SUMMARY) {
-                        ret = glfsh_process_entries (readdir_xl, fd,
-                                                     &entries, &offset,
-                                                     num_entries,
-                                                     glfsh_print_heal_status,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) {
-                        ret = glfsh_process_entries (readdir_xl, fd,
-                                                     &entries, &offset,
-                                                     num_entries,
-                                                     glfsh_print_spb_status,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
-                        ret = glfsh_heal_entries (fs, top_subvol, rootloc,
-                                                  &entries, &offset,
-                                                  num_entries, xattr_req);
-                } else if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) {
-                        ret = glfsh_process_entries (readdir_xl, fd, &entries,
-                                                     &offset, num_entries,
-                                                     glfsh_heal_status_boolean,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                }
-                gf_dirent_free (&entries);
-                free_entries = _gf_false;
-        }
+    while (1) {
+        ret = syncop_readdir(readdir_xl, fd, 131072, offset, &entries, NULL,
+                             NULL);
+        if (ret <= 0)
+            break;
         ret = 0;
+        free_entries = _gf_true;
+
+        if (list_empty(&entries.list))
+            goto out;
+
+        if (heal_op == GF_SHD_OP_INDEX_SUMMARY) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_heal_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_spb_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_summary_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
+            glfsh_heal_entries(fs, top_subvol, rootloc, &entries, &offset,
+                               num_entries, xattr_req);
+        } else if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_heal_status_boolean,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        }
+        gf_dirent_free(&entries);
+        free_entries = _gf_false;
+    }
+    ret = 0;
 out:
-        if (free_entries)
-                gf_dirent_free (&entries);
-        return ret;
+    if (free_entries)
+        gf_dirent_free(&entries);
+    return ret;
 }
 
 static int
-glfsh_no_print_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_no_print_brick_from_xl(xlator_t *xl, loc_t *rootloc)
 {
-        return 0;
+    return 0;
 }
 
 static int
-glfsh_print_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_print_brick_from_xl(xlator_t *xl, loc_t *rootloc)
 {
-        char    *remote_host = NULL;
-        char    *remote_subvol = NULL;
-        int     ret = 0;
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
+    int ret = 0;
 
-        ret = dict_get_str (xl->options, "remote-host", &remote_host);
-        if (ret < 0)
-                goto out;
+    ret = dict_get_str(xl->options, "remote-host", &remote_host);
+    if (ret < 0)
+        goto out;
 
-        ret = dict_get_str (xl->options, "remote-subvolume", &remote_subvol);
-        if (ret < 0)
-                goto out;
+    ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+    if (ret < 0)
+        goto out;
 out:
-        if (ret < 0)
-                printf ("Brick - Not able to get brick information\n");
-        else
-                printf ("Brick %s:%s\n", remote_host, remote_subvol);
-        return ret;
+    if (ret < 0)
+        printf("Brick - Not able to get brick information\n");
+    else
+        printf("Brick %s:%s\n", remote_host, remote_subvol);
+    return ret;
 }
 
 int
-glfsh_print_pending_heals_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                                xlator_t *xl, gf_xl_afr_op_t heal_op,
-                                dict_t *xattr_req, char *vgfid,
-                                uint64_t *num_entries)
+glfsh_print_pending_heals_type(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                               xlator_t *xl, gf_xl_afr_op_t heal_op,
+                               dict_t *xattr_req, char *vgfid,
+                               num_entries_t *num_entries)
 {
-        int ret = 0;
-        loc_t   dirloc = {0};
-        fd_t    *fd = NULL;
-        int32_t op_errno = 0;
-        gf_boolean_t ignore = _gf_false;
-
-        if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID))
-                ignore = _gf_true;
-
-        ret = glfsh_get_index_dir_loc (rootloc, xl, &dirloc, &op_errno,
-                                       vgfid);
-        if (ret < 0) {
-                if (op_errno == ESTALE || op_errno == ENOENT ||
-                    op_errno == ENOTSUP)
-                        ret = 0;
-                else
-                        ret = -op_errno;
-                goto out;
-        }
-
-        ret = syncop_dirfd (xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
-        if (ret)
-                goto out;
-
-        ret = glfsh_crawl_directory (fs, top_subvol, rootloc, xl, fd, &dirloc,
-                                     xattr_req, num_entries, ignore);
-        if (fd)
-                fd_unref (fd);
+    int ret = 0;
+    loc_t dirloc = {0};
+    fd_t *fd = NULL;
+    int32_t op_errno = 0;
+    gf_boolean_t ignore = _gf_false;
+
+    if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID))
+        ignore = _gf_true;
+
+    ret = glfsh_get_index_dir_loc(rootloc, xl, &dirloc, &op_errno, vgfid);
+    if (ret < 0) {
+        if (op_errno == ESTALE || op_errno == ENOENT || op_errno == ENOTSUP)
+            ret = 0;
+        else
+            ret = -op_errno;
+        goto out;
+    }
+
+    ret = syncop_dirfd(xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
+    if (ret)
+        goto out;
+
+    ret = glfsh_crawl_directory(fs, top_subvol, rootloc, xl, fd, &dirloc,
+                                xattr_req, num_entries, ignore);
+    if (fd)
+        fd_unref(fd);
 out:
-        loc_wipe (&dirloc);
-        return ret;
+    loc_wipe(&dirloc);
+    return ret;
 }
 
 int
-glfsh_print_pending_heals (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                           xlator_t *xl, gf_xl_afr_op_t heal_op, gf_boolean_t
-                           is_parent_replicate)
+glfsh_print_pending_heals(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                          xlator_t *xl, gf_xl_afr_op_t heal_op,
+                          gf_boolean_t is_parent_replicate)
 {
-        int ret = 0;
-        uint64_t count = 0, total = 0;
-
-        dict_t *xattr_req = NULL;
+    int ret = 0;
+    num_entries_t num_entries = {
+        0,
+    };
+    num_entries_t total = {
+        0,
+    };
+
+    dict_t *xattr_req = NULL;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op", heal_op);
+    if (ret)
+        goto out;
+
+    if ((!is_parent_replicate) &&
+        ((heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||
+         (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE))) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfsh_output->print_brick_from_xl(xl, rootloc);
+    if (ret < 0)
+        goto out;
+
+    ret = glfsh_print_pending_heals_type(fs, top_subvol, rootloc, xl, heal_op,
+                                         xattr_req, GF_XATTROP_INDEX_GFID,
+                                         &num_entries);
+
+    if (ret < 0 && heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        goto out;
+
+    total.num_entries += num_entries.num_entries;
+    total.pending_entries += num_entries.pending_entries;
+    total.spb_entries += num_entries.spb_entries;
+    total.possibly_healing_entries += num_entries.possibly_healing_entries;
+    num_entries.num_entries = 0;
+    num_entries.pending_entries = 0;
+    num_entries.spb_entries = 0;
+    num_entries.possibly_healing_entries = 0;
+    if (ret == -ENOTCONN)
+        goto out;
+
+    if (is_parent_replicate) {
+        ret = glfsh_print_pending_heals_type(
+            fs, top_subvol, rootloc, xl, heal_op, xattr_req,
+            GF_XATTROP_DIRTY_GFID, &num_entries);
+        total.num_entries += num_entries.num_entries;
+        total.pending_entries += num_entries.pending_entries;
+        total.spb_entries += num_entries.spb_entries;
+        total.possibly_healing_entries += num_entries.possibly_healing_entries;
+    }
+out:
+    if (xattr_req)
+        dict_unref(xattr_req);
+    if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
+        glfsh_print_info_summary(ret, &total);
+    } else {
+        glfsh_print_heal_op_status(ret, total.num_entries, heal_op);
+    }
+    return ret;
+}
 
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op", heal_op);
-        if (ret)
-                goto out;
+static int
+glfsh_set_heal_options(glfs_t *fs, gf_xl_afr_op_t heal_op)
+{
+    int ret = 0;
 
-        if ((!is_parent_replicate) &&
-            ((heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||
-             (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE))) {
-                ret = 0;
-                goto out;
-        }
+    ret = glfs_set_xlator_option(fs, "*-replicate-*",
+                                 "background-self-heal-count", "0");
+    if (ret)
+        goto out;
 
-        ret = glfsh_output->print_brick_from_xl (xl, rootloc);
-        if (ret < 0)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "halo-enabled", "off");
+    if (ret)
+        goto out;
 
-        ret = glfsh_print_pending_heals_type (fs, top_subvol, rootloc, xl,
-                                              heal_op, xattr_req,
-                                              GF_XATTROP_INDEX_GFID, &count);
+    if ((heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) &&
+        (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) &&
+        (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME))
+        return 0;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "data-self-heal", "on");
+    if (ret)
+        goto out;
 
-        if (ret < 0 && heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "metadata-self-heal",
+                                 "on");
+    if (ret)
+        goto out;
 
-        total += count;
-        count = 0;
-        if (ret == -ENOTCONN)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "entry-self-heal", "on");
 
-        if (is_parent_replicate) {
-                ret = glfsh_print_pending_heals_type (fs, top_subvol,
-                                                      rootloc, xl,
-                                                      heal_op, xattr_req,
-                                                      GF_XATTROP_DIRTY_GFID,
-                                                      &count);
-                total += count;
-        }
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        glfsh_print_heal_op_status (ret, total, heal_op);
-        return ret;
-
+    return ret;
 }
 
 static int
-glfsh_set_heal_options (glfs_t *fs, gf_xl_afr_op_t heal_op)
+glfsh_validate_volume(xlator_t *xl, gf_xl_afr_op_t heal_op)
 {
-        int ret = 0;
-
-        ret = glfs_set_xlator_option (fs, "*-replicate-*",
-                                      "background-self-heal-count", "0");
-        if (ret)
-                goto out;
+    xlator_t *heal_xl = NULL;
+    int ret = -1;
 
-        if ((heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) &&
-            (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) &&
-            (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME))
-                return 0;
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "data-self-heal",
-                                      "on");
-        if (ret)
-                goto out;
+    while (xl->next)
+        xl = xl->next;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "metadata-self-heal",
-                                      "on");
-        if (ret)
-                goto out;
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0) {
+            heal_xl = _get_ancestor(xl, heal_op);
+            if (heal_xl) {
+                ret = 0;
+                break;
+            }
+        }
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "entry-self-heal",
-                                      "on");
+        xl = xl->prev;
+    }
 
-out:
-        return ret;
+    return ret;
 }
 
-static int
-glfsh_validate_volume (xlator_t *xl, gf_xl_afr_op_t heal_op)
+static xlator_t *
+_brick_path_to_client_xlator(xlator_t *top_subvol, char *hostname,
+                             char *brickpath)
 {
-        xlator_t        *heal_xl = NULL;
-        int             ret = -1;
-
-        while (xl->next)
-                xl = xl->next;
-
-        while (xl) {
-                if (strcmp (xl->type, "protocol/client") == 0) {
-                        heal_xl = _get_ancestor (xl, heal_op);
-                        if (heal_xl) {
-                                ret = 0;
-                                break;
-                        }
-                }
-
-                xl = xl->prev;
-        }
+    int ret = 0;
+    xlator_t *xl = NULL;
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
 
-        return ret;
-}
+    xl = top_subvol;
 
-static xlator_t*
-_brick_path_to_client_xlator (xlator_t *top_subvol, char *hostname,
-                              char *brickpath)
-{
-        int ret             = 0;
-        xlator_t *xl        = NULL;
-        char *remote_host   = NULL;
-        char *remote_subvol = NULL;
-
-        xl = top_subvol;
-
-        while (xl->next)
-                xl = xl->next;
-
-        while (xl) {
-                if (!strcmp (xl->type, "protocol/client")) {
-                        ret = dict_get_str (xl->options, "remote-host",
-                                                    &remote_host);
-                        if (ret < 0)
-                                goto out;
-                        ret = dict_get_str (xl->options,
-                                            "remote-subvolume", &remote_subvol);
-                        if (ret < 0)
-                                goto out;
-                        if (!strcmp (hostname, remote_host) &&
-                            !strcmp (brickpath, remote_subvol))
-                                return xl;
-                }
-                xl = xl->prev;
+    while (xl->next)
+        xl = xl->next;
+
+    while (xl) {
+        if (!strcmp(xl->type, "protocol/client")) {
+            ret = dict_get_str(xl->options, "remote-host", &remote_host);
+            if (ret < 0)
+                goto out;
+            ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+            if (ret < 0)
+                goto out;
+            if (!strcmp(hostname, remote_host) &&
+                !strcmp(brickpath, remote_subvol))
+                return xl;
         }
+        xl = xl->prev;
+    }
 
 out:
-        return NULL;
+    return NULL;
 }
 
 int
-glfsh_gather_heal_info (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                        gf_xl_afr_op_t heal_op)
+glfsh_gather_heal_info(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                       gf_xl_afr_op_t heal_op)
 {
-        int        ret       = 0;
-        xlator_t  *xl        = NULL;
-        xlator_t  *heal_xl   = NULL;
-        xlator_t  *old_THIS  = NULL;
-
-        xl = top_subvol;
-        while (xl->next)
-                xl = xl->next;
-        while (xl) {
-                if (strcmp (xl->type, "protocol/client") == 0) {
-                        heal_xl = _get_ancestor (xl, heal_op);
-                        if (heal_xl) {
-                                old_THIS = THIS;
-                                THIS = heal_xl;
-                                ret = glfsh_print_pending_heals (fs, top_subvol,
-                                                                 rootloc, xl,
-                                                                 heal_op,
-                                                                 !strcmp
-                                                                (heal_xl->type,
-                                                          "cluster/replicate"));
-                                THIS = old_THIS;
-
-                                if ((ret < 0) &&
-                              (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE))
-                                        goto out;
-                        }
-                }
-
-                xl = xl->prev;
+    int ret = 0;
+    xlator_t *xl = NULL;
+    xlator_t *heal_xl = NULL;
+    xlator_t *old_THIS = NULL;
+
+    xl = top_subvol;
+    while (xl->next)
+        xl = xl->next;
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0 &&
+            !strstr(xl->name, "-ta-")) {
+            heal_xl = _get_ancestor(xl, heal_op);
+            if (heal_xl) {
+                old_THIS = THIS;
+                THIS = heal_xl;
+                ret = glfsh_print_pending_heals(
+                    fs, top_subvol, rootloc, xl, heal_op,
+                    !strcmp(heal_xl->type, "cluster/replicate"));
+                THIS = old_THIS;
+
+                if ((ret < 0) &&
+                    (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE))
+                    goto out;
+            }
         }
 
+        xl = xl->prev;
+    }
+
 out:
-        if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                ret = 0;
+    if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int
-_validate_directory (dict_t *xattr_req, char *file)
+_validate_directory(dict_t *xattr_req, char *file)
 {
-        int heal_op = -1;
-        int ret = 0;
-
-        ret = dict_get_int32 (xattr_req, "heal-op", &heal_op);
-        if (ret)
-                return ret;
-
-        if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) {
-                printf ("'bigger-file' not a valid option for directories.\n");
-                ret = -1;
-        } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
-                printf ("'source-brick' option used on a directory (%s). "
-                        "Performing conservative merge.\n", file);
-        }
+    int heal_op = -1;
+    int ret = 0;
 
+    ret = dict_get_int32(xattr_req, "heal-op", &heal_op);
+    if (ret)
         return ret;
+
+    if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) {
+        printf("'bigger-file' not a valid option for directories.\n");
+        ret = -1;
+    } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
+        printf(
+            "'source-brick' option used on a directory (%s). "
+            "Performing conservative merge.\n",
+            file);
+    }
+
+    return ret;
 }
 
 int
-glfsh_heal_splitbrain_file (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                            char *file, dict_t *xattr_req)
+glfsh_heal_splitbrain_file(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *file, dict_t *xattr_req)
 {
-        int          ret           = -1;
-        int          reval         = 0;
-        loc_t        loc           = {0, };
-        char        *path          = NULL;
-        char        *path1         = NULL;
-        char        *path2         = NULL;
-        char        *filename      = NULL;
-        char        *filename1     = NULL;
-        struct iatt  iatt          = {0, };
-        xlator_t    *xl            = top_subvol;
-        dict_t      *xattr_rsp     = NULL;
-        char        *sh_fail_msg   = NULL;
-        char        *gfid_heal_msg = NULL;
-        int32_t      op_errno      = 0;
-        gf_boolean_t flag          = _gf_false;
-
-        if (!strncmp (file, "gfid:", 5)) {
-                filename = gf_strdup(file);
-                if (!filename) {
-                        printf ("Error allocating memory to filename\n");
-                        goto out;
-                }
-                path = strtok (filename, ":");
-                path = strtok (NULL, ";");
-                gf_uuid_parse (path, loc.gfid);
-                loc.path = gf_strdup (uuid_utoa (loc.gfid));
-                if (!loc.path) {
-                        printf ("Error allocating memory to path\n");
-                        goto out;
-                }
-                loc.inode = inode_new (rootloc->inode->table);
-                if (!loc.inode) {
-                        printf ("Error getting inode\n");
-                        goto out;
-                }
-                ret = syncop_lookup (xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
-                if (ret) {
-                        op_errno = -ret;
-                        printf ("Lookup failed on %s:%s.\n", file,
-                                strerror(op_errno));
-                        goto out;
-                }
-        } else {
-                if (file[0] != '/') {
-                        printf ("<FILE> must be absolute path w.r.t. the "
-                                "volume, starting with '/'\n");
-                        ret = -1;
-                        goto out;
-                }
-                path1 = gf_strdup (file);
-                if (!path1) {
-                        printf ("Error allocating memory to path\n");
-                        ret = -1;
-                        goto out;
-                }
-                path2 = gf_strdup (file);
-                if (!path2) {
-                        printf ("Error allocating memory to path\n");
-                        ret = -1;
-                        goto out;
-                }
-                path = dirname (path1);
-                filename1 = basename (path2);
-retry1:
-                ret = glfs_resolve (fs, xl, path, &loc, &iatt, reval);
-                ESTALE_RETRY (ret, errno, reval, &loc, retry1);
-                if (ret) {
-                        printf("Lookup failed on %s:%s\n",
-                               path, strerror (errno));
-                        goto out;
-                }
-                GF_FREE ((char *)loc.path);
-                loc.path = gf_strdup (file);
-                if (!loc.path) {
-                        printf ("Error allocating memory for path\n");
-                        ret = -1;
-                        goto out;
-                }
-                loc.parent = inode_unref (loc.parent);
-                loc.parent = inode_ref (loc.inode);
-                loc.inode = inode_unref (loc.inode);
-                loc.inode = inode_new (rootloc->inode->table);
-                if (!loc.inode) {
-                        printf ("Error getting inode\n");
-                        ret = -1;
-                        goto out;
-                }
-                loc.name = filename1;
-                gf_uuid_copy (loc.pargfid, loc.gfid);
-                gf_uuid_clear (loc.gfid);
-
-                ret = syncop_lookup (xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
-                if (ret) {
-                        op_errno = -ret;
-                        printf ("Lookup failed on %s:%s.\n", file,
-                                strerror(op_errno));
-                        flag = _gf_true;
-                }
-
-                ret = dict_get_str (xattr_rsp, "gfid-heal-msg", &gfid_heal_msg);
-                if (!ret) {
-                        printf ("%s for file %s\n", gfid_heal_msg, file);
-                        loc_wipe (&loc);
-                        goto out;
-                }
-                if (flag)
-                        goto out;
-
-                reval = 0;
-                loc_wipe (&loc);
-                memset (&iatt, 0, sizeof(iatt));
-
-retry2:
-                ret = glfs_resolve (fs, xl, file, &loc, &iatt, reval);
-                ESTALE_RETRY (ret, errno, reval, &loc, retry2);
-                if (ret) {
-                        printf("Lookup failed on %s:%s\n",
-                               file, strerror (errno));
-                        goto out;
-                }
+    int ret = -1;
+    int reval = 0;
+    loc_t loc = {
+        0,
+    };
+    char *path = NULL;
+    char *path1 = NULL;
+    char *path2 = NULL;
+    char *filename = NULL;
+    char *filename1 = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    xlator_t *xl = top_subvol;
+    dict_t *xattr_rsp = NULL;
+    char *sh_fail_msg = NULL;
+    char *gfid_heal_msg = NULL;
+    int32_t op_errno = 0;
+    gf_boolean_t flag = _gf_false;
+
+    if (!strncmp(file, "gfid:", 5)) {
+        filename = gf_strdup(file);
+        if (!filename) {
+            printf("Error allocating memory to filename\n");
+            goto out;
         }
-
-        if (iatt.ia_type == IA_IFDIR) {
-                ret = _validate_directory (xattr_req, file);
-                if (ret)
-                        goto out;
+        path = strtok(filename, ":");
+        path = strtok(NULL, ";");
+        gf_uuid_parse(path, loc.gfid);
+        loc.path = gf_strdup(uuid_utoa(loc.gfid));
+        if (!loc.path) {
+            printf("Error allocating memory to path\n");
+            goto out;
+        }
+        loc.inode = inode_new(rootloc->inode->table);
+        if (!loc.inode) {
+            printf("Error getting inode\n");
+            goto out;
         }
-        ret = syncop_getxattr (xl, &loc, &xattr_rsp, GF_AFR_HEAL_SBRAIN,
-                               xattr_req, NULL);
+        ret = syncop_lookup(xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
         if (ret) {
-                op_errno = -ret;
-                printf ("Healing %s failed:%s.\n", file, strerror(op_errno));
-                goto out;
+            op_errno = -ret;
+            printf("Lookup failed on %s:%s.\n", file, strerror(op_errno));
+            goto out;
+        }
+    } else {
+        if (file[0] != '/') {
+            printf(
+                "<FILE> must be absolute path w.r.t. the "
+                "volume, starting with '/'\n");
+            ret = -1;
+            goto out;
         }
-        ret = dict_get_str (xattr_rsp, "sh-fail-msg", &sh_fail_msg);
+        path1 = gf_strdup(file);
+        if (!path1) {
+            printf("Error allocating memory to path\n");
+            ret = -1;
+            goto out;
+        }
+        path2 = gf_strdup(file);
+        if (!path2) {
+            printf("Error allocating memory to path\n");
+            ret = -1;
+            goto out;
+        }
+        path = dirname(path1);
+        filename1 = basename(path2);
+    retry1:
+        ret = glfs_resolve(fs, xl, path, &loc, &iatt, reval);
+        ESTALE_RETRY(ret, errno, reval, &loc, retry1);
+        if (ret) {
+            printf("Lookup failed on %s:%s\n", path, strerror(errno));
+            goto out;
+        }
+        GF_FREE((char *)loc.path);
+        loc.path = gf_strdup(file);
+        if (!loc.path) {
+            printf("Error allocating memory for path\n");
+            ret = -1;
+            goto out;
+        }
+        loc.parent = inode_unref(loc.parent);
+        loc.parent = inode_ref(loc.inode);
+        loc.inode = inode_unref(loc.inode);
+        loc.inode = inode_new(rootloc->inode->table);
+        if (!loc.inode) {
+            printf("Error getting inode\n");
+            ret = -1;
+            goto out;
+        }
+        loc.name = filename1;
+        gf_uuid_copy(loc.pargfid, loc.gfid);
+        gf_uuid_clear(loc.gfid);
+
+        ret = syncop_lookup(xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
+        if (ret) {
+            op_errno = -ret;
+            printf("Lookup failed on %s:%s.\n", file, strerror(op_errno));
+            flag = _gf_true;
+        }
+
+        ret = dict_get_str(xattr_rsp, "gfid-heal-msg", &gfid_heal_msg);
         if (!ret) {
-                printf ("Healing %s failed: %s.\n", file, sh_fail_msg);
-                ret = -1;
-                goto out;
+            printf("%s for file %s\n", gfid_heal_msg, file);
+            loc_wipe(&loc);
+            goto out;
         }
-        printf ("Healed %s.\n", file);
-        ret = 0;
+        if (flag)
+            goto out;
+
+        reval = 0;
+        loc_wipe(&loc);
+        memset(&iatt, 0, sizeof(iatt));
+
+    retry2:
+        ret = glfs_resolve(fs, xl, file, &loc, &iatt, reval);
+        ESTALE_RETRY(ret, errno, reval, &loc, retry2);
+        if (ret) {
+            printf("Lookup failed on %s:%s\n", file, strerror(errno));
+            goto out;
+        }
+    }
+
+    if (iatt.ia_type == IA_IFDIR) {
+        ret = _validate_directory(xattr_req, file);
+        if (ret)
+            goto out;
+    }
+    ret = syncop_getxattr(xl, &loc, &xattr_rsp, GF_AFR_HEAL_SBRAIN, xattr_req,
+                          NULL);
+    if (ret) {
+        op_errno = -ret;
+        printf("Healing %s failed:%s.\n", file, strerror(op_errno));
+        goto out;
+    }
+    ret = dict_get_str(xattr_rsp, "sh-fail-msg", &sh_fail_msg);
+    if (!ret) {
+        printf("Healing %s failed: %s.\n", file, sh_fail_msg);
+        ret = -1;
+        goto out;
+    }
+    printf("Healed %s.\n", file);
+    ret = 0;
 out:
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
-        if (path1)
-                GF_FREE (path1);
-        if (path2)
-                GF_FREE (path2);
-        if (filename)
-                GF_FREE (filename);
-        loc_wipe (&loc);
-        return ret;
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
+    if (path1)
+        GF_FREE(path1);
+    if (path2)
+        GF_FREE(path2);
+    if (filename)
+        GF_FREE(filename);
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-glfsh_heal_from_brick_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                            char *hostname, char *brickpath, xlator_t *client,
-                            dict_t *xattr_req, char *vgfid,
-                            uint64_t *num_entries)
+glfsh_heal_from_brick_type(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *hostname, char *brickpath, xlator_t *client,
+                           dict_t *xattr_req, char *vgfid,
+                           num_entries_t *num_entries)
 {
-        fd_t     *fd        = NULL;
-        loc_t     dirloc    = {0};
-        int32_t   op_errno  = 0;
-        int       ret       = -1;
-
-        ret = glfsh_get_index_dir_loc (rootloc, client, &dirloc,
-                                       &op_errno, vgfid);
-        if (ret < 0) {
-                if (op_errno == ESTALE || op_errno == ENOENT)
-                        ret = 0;
-                else
-                        ret = -op_errno;
-                goto out;
-        }
-
-        ret = syncop_dirfd (client, &dirloc, &fd,
-                            GF_CLIENT_PID_GLFS_HEAL);
-        if (ret)
-                goto out;
-        ret = glfsh_crawl_directory (fs, top_subvol, rootloc, client,
-                                     fd, &dirloc, xattr_req, num_entries,
-                                     _gf_false);
-        if (fd)
-                fd_unref (fd);
+    fd_t *fd = NULL;
+    loc_t dirloc = {0};
+    int32_t op_errno = 0;
+    int ret = -1;
+
+    ret = glfsh_get_index_dir_loc(rootloc, client, &dirloc, &op_errno, vgfid);
+    if (ret < 0) {
+        if (op_errno == ESTALE || op_errno == ENOENT)
+            ret = 0;
+        else
+            ret = -op_errno;
+        goto out;
+    }
+
+    ret = syncop_dirfd(client, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
+    if (ret)
+        goto out;
+    ret = glfsh_crawl_directory(fs, top_subvol, rootloc, client, fd, &dirloc,
+                                xattr_req, num_entries, _gf_false);
+    if (fd)
+        fd_unref(fd);
 out:
-        loc_wipe (&dirloc);
-        return ret;
+    loc_wipe(&dirloc);
+    return ret;
 }
 
 int
-glfsh_heal_from_brick (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+glfsh_heal_from_brick(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
                       char *hostname, char *brickpath, char *file)
 {
-        int       ret       = -1;
-        uint64_t   count     = 0, total = 0;
-        dict_t   *xattr_req = NULL;
-        xlator_t *client    = NULL;
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+    xlator_t *client = NULL;
+    num_entries_t num_entries = {
+        0,
+    };
+    num_entries_t total = {
+        0,
+    };
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op",
+                         GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (ret)
+        goto out;
+    client = _brick_path_to_client_xlator(top_subvol, hostname, brickpath);
+    if (!client) {
+        printf("\"%s:%s\"- No such brick available in the volume.\n", hostname,
+               brickpath);
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str(xattr_req, "child-name", client->name);
+    if (ret)
+        goto out;
+    if (file)
+        ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file,
+                                         xattr_req);
+    else {
+        ret = glfsh_heal_from_brick_type(fs, top_subvol, rootloc, hostname,
+                                         brickpath, client, xattr_req,
+                                         GF_XATTROP_INDEX_GFID, &num_entries);
+        total.num_entries += num_entries.num_entries;
+        num_entries.num_entries = 0;
+        if (ret == -ENOTCONN)
+            goto out;
 
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op",
-                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-        if (ret)
-                goto out;
-        client = _brick_path_to_client_xlator (top_subvol, hostname, brickpath);
-        if (!client) {
-                printf("\"%s:%s\"- No such brick available in the volume.\n",
-                       hostname, brickpath);
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str (xattr_req, "child-name", client->name);
-        if (ret)
-                goto out;
-        if (file)
-                ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                                  xattr_req);
-        else {
-                ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc,
-                                                  hostname, brickpath,
-                                                  client, xattr_req,
-                                                  GF_XATTROP_INDEX_GFID,
-                                                  &count);
-                total += count;
-                count = 0;
-                if (ret == -ENOTCONN)
-                        goto out;
-
-                ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc,
-                                                  hostname, brickpath,
-                                                  client, xattr_req,
-                                                  GF_XATTROP_DIRTY_GFID,
-                                                  &count);
-                total += count;
-                if (ret < 0)
-                        goto out;
-        }
+        ret = glfsh_heal_from_brick_type(fs, top_subvol, rootloc, hostname,
+                                         brickpath, client, xattr_req,
+                                         GF_XATTROP_DIRTY_GFID, &num_entries);
+        total.num_entries += num_entries.num_entries;
+        if (ret < 0)
+            goto out;
+    }
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        if (!file)
-                glfsh_print_heal_op_status (ret, total,
-                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (xattr_req)
+        dict_unref(xattr_req);
+    if (!file)
+        glfsh_print_heal_op_status(ret, total.num_entries,
+                                   GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
 
-        return ret;
+    return ret;
 }
 
 int
-glfsh_heal_from_bigger_file_or_mtime (glfs_t *fs, xlator_t *top_subvol,
-                                      loc_t *rootloc, char *file,
-                                      gf_xl_afr_op_t heal_op)
+glfsh_heal_from_bigger_file_or_mtime(glfs_t *fs, xlator_t *top_subvol,
+                                     loc_t *rootloc, char *file,
+                                     gf_xl_afr_op_t heal_op)
 {
-
-        int ret = -1;
-        dict_t *xattr_req = NULL;
-
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op", heal_op);
-        if (ret)
-                goto out;
-        ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                         xattr_req);
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op", heal_op);
+    if (ret)
+        goto out;
+    ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file, xattr_req);
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        return ret;
+    if (xattr_req)
+        dict_unref(xattr_req);
+    return ret;
 }
 
 static void
-cleanup (glfs_t *fs)
+cleanup(glfs_t *fs)
 {
-        if (!fs)
-                return;
+    if (!fs)
+        return;
 #if 0
         /* glfs fini path is still racy and crashing the program. Since
-         * this program any way has to die, we are not gonna call fini
+         * this program any way has to die, we are not going to call fini
          * in the released versions. i.e. final builds. For all
          * internal testing lets enable this so that glfs_fini code
          * path becomes stable. */
@@ -1321,246 +1486,308 @@ cleanup (glfs_t *fs)
 #endif
 }
 
-
 glfsh_info_t glfsh_human_readable = {
-        .init = glfsh_init,
-        .print_brick_from_xl = glfsh_print_brick_from_xl,
-        .print_heal_op_status = glfsh_print_hr_heal_op_status,
-        .print_heal_status = glfsh_print_hr_heal_status,
-        .print_spb_status = glfsh_print_hr_spb_status,
-        .end = glfsh_end
-};
+    .init = glfsh_init,
+    .print_brick_from_xl = glfsh_print_brick_from_xl,
+    .print_heal_op_status = glfsh_print_hr_heal_op_status,
+    .print_heal_op_summary = glfsh_print_hr_heal_op_summary,
+    .print_heal_status = glfsh_print_hr_heal_status,
+    .print_spb_status = glfsh_print_hr_spb_status,
+    .end = glfsh_end};
 
 glfsh_info_t glfsh_no_print = {
-        .init = glfsh_init,
-        .print_brick_from_xl = glfsh_no_print_brick_from_xl,
-        .print_heal_op_status = glfsh_no_print_hr_heal_op_status,
-        .print_heal_status = glfsh_no_print_hr_heal_status,
-        .print_spb_status = glfsh_no_print_hr_heal_status,
-        .end = glfsh_end_op_granular_entry_heal
-};
+    .init = glfsh_init,
+    .print_brick_from_xl = glfsh_no_print_brick_from_xl,
+    .print_heal_op_status = glfsh_no_print_hr_heal_op_status,
+    .print_heal_status = glfsh_no_print_hr_status,
+    .print_spb_status = glfsh_no_print_hr_status,
+    .end = glfsh_end_op_granular_entry_heal};
 
 #if (HAVE_LIB_XML)
 glfsh_info_t glfsh_xml_output = {
-        .init = glfsh_xml_init,
-        .print_brick_from_xl = glfsh_print_xml_brick_from_xl,
-        .print_heal_op_status = glfsh_print_xml_heal_op_status,
-        .print_heal_status = glfsh_print_xml_file_status,
-        .print_spb_status = glfsh_print_xml_file_status,
-        .end = glfsh_xml_end
-};
+    .init = glfsh_xml_init,
+    .print_brick_from_xl = glfsh_print_xml_brick_from_xl,
+    .print_heal_op_status = glfsh_print_xml_heal_op_status,
+    .print_heal_op_summary = glfsh_print_xml_heal_op_summary,
+    .print_heal_status = glfsh_print_xml_file_status,
+    .print_spb_status = glfsh_print_xml_file_status,
+    .end = glfsh_xml_end};
 #endif
 
+static void
+parse_flags(int *argc, char **argv, int *flags)
+{
+    int i = 0;
+    char *opt = NULL;
+    int count = 0;
+
+    for (i = 0; i < *argc; i++) {
+        opt = strtail(argv[i], "--");
+        if (!opt)
+            continue;
+        if (strcmp(opt, "nolog") == 0) {
+            *flags |= MODE_NO_LOG;
+            count++;
+        } else if (strcmp(opt, "xml") == 0) {
+            *flags |= MODE_XML;
+            count++;
+        }
+    }
+    *argc = *argc - count;
+}
+
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0;
-        char      *volname = NULL;
-        xlator_t  *top_subvol = NULL;
-        loc_t     rootloc = {0};
-        char      logfilepath[PATH_MAX] = {0};
-        char      *hostname = NULL;
-        char      *path = NULL;
-        char      *file = NULL;
-        char      *op_errstr = NULL;
-        gf_xl_afr_op_t heal_op = -1;
-
-        if (argc < 2) {
-                printf (USAGE_STR, argv[0]);
-                ret = -1;
-                goto out;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    char *volname = NULL;
+    xlator_t *top_subvol = NULL;
+    loc_t rootloc = {0};
+    char logfilepath[PATH_MAX] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *file = NULL;
+    char *op_errstr = NULL;
+    char *socket_filepath = NULL;
+    gf_xl_afr_op_t heal_op = -1;
+    gf_loglevel_t log_level = GF_LOG_INFO;
+    int flags = 0;
+
+    if (argc < 2) {
+        printf(USAGE_STR, argv[0]);
+        ret = -1;
+        goto out;
+    } else if (argc >= 4) {
+        if (!strcmp(argv[argc - 2], "glusterd-sock")) {
+            socket_filepath = argv[argc - 1];
+            argc = argc - 2;
         }
+    }
+    volname = argv[1];
+
+    parse_flags(&argc, argv, &flags);
+    if (flags & MODE_NO_LOG)
+        log_level = GF_LOG_NONE;
+    if (flags & MODE_XML)
+        is_xml = 1;
 
-        volname = argv[1];
-        switch (argc) {
+    switch (argc) {
         case 2:
-                heal_op = GF_SHD_OP_INDEX_SUMMARY;
-                break;
+            heal_op = GF_SHD_OP_INDEX_SUMMARY;
+            break;
         case 3:
-                if (!strcmp (argv[2], "split-brain-info")) {
-                        heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
-                } else if (!strcmp (argv[2], "xml")) {
-                        heal_op = GF_SHD_OP_INDEX_SUMMARY;
-                        is_xml = 1;
-                } else if (!strcmp (argv[2], "granular-entry-heal-op")) {
-                        heal_op = GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE;
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
+            if (!strcmp(argv[2], "split-brain-info")) {
+                heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
+            } else if (!strcmp(argv[2], "granular-entry-heal-op")) {
+                heal_op = GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE;
+            } else if (!strcmp(argv[2], "info-summary")) {
+                heal_op = GF_SHD_OP_HEAL_SUMMARY;
+            } else {
+                printf(USAGE_STR, argv[0]);
+                ret = -1;
+                goto out;
+            }
+            break;
         case 4:
-                if ((!strcmp (argv[2], "split-brain-info"))
-                                && (!strcmp (argv[3], "xml"))) {
-                        heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
-                        is_xml = 1;
-                } else if (!strcmp (argv[2], "bigger-file")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE;
-                        file = argv[3];
-                } else if (!strcmp (argv[2], "latest-mtime")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME;
-                        file = argv[3];
-                } else if (!strcmp (argv[2], "source-brick")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
-                        hostname = strtok (argv[3], ":");
-                        path = strtok (NULL, ":");
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
+            if (!strcmp(argv[2], "bigger-file")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE;
+                file = argv[3];
+            } else if (!strcmp(argv[2], "latest-mtime")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME;
+                file = argv[3];
+            } else if (!strcmp(argv[2], "source-brick")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
+                hostname = strtok(argv[3], ":");
+                path = strtok(NULL, ":");
+            } else {
+                printf(USAGE_STR, argv[0]);
+                ret = -1;
+                goto out;
+            }
+            break;
         case 5:
-                if (!strcmp (argv[2], "source-brick")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
-                        hostname = strtok (argv[3], ":");
-                        path = strtok (NULL, ":");
-                        file = argv[4];
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
-        default:
-                printf (USAGE_STR, argv[0]);
+            if (!strcmp(argv[2], "source-brick")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
+                hostname = strtok(argv[3], ":");
+                path = strtok(NULL, ":");
+                file = argv[4];
+            } else {
+                printf(USAGE_STR, argv[0]);
                 ret = -1;
                 goto out;
-        }
+            }
+            break;
+        default:
+            printf(USAGE_STR, argv[0]);
+            ret = -1;
+            goto out;
+    }
 
-        glfsh_output = &glfsh_human_readable;
-        if (is_xml) {
+    glfsh_output = &glfsh_human_readable;
+    if (is_xml) {
 #if (HAVE_LIB_XML)
-                glfsh_output = &glfsh_xml_output;
+        if ((heal_op == GF_SHD_OP_INDEX_SUMMARY) ||
+            (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) ||
+            (heal_op == GF_SHD_OP_HEAL_SUMMARY)) {
+            glfsh_output = &glfsh_xml_output;
+        } else {
+            printf(USAGE_STR, argv[0]);
+            ret = -1;
+            goto out;
+        }
 #else
-                /*No point doing anything, just fail the command*/
-                exit (EXIT_FAILURE);
+        /*No point doing anything, just fail the command*/
+        exit(EXIT_FAILURE);
 #endif
-
-        }
-
-        if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                glfsh_output = &glfsh_no_print;
-
-        ret = glfsh_output->init ();
-        if (ret)
-                exit (EXIT_FAILURE);
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Not able to initialize volume '%s'",
-                             volname);
-                goto out;
-        }
-
-        if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
-                fs->ctx->secure_mgmt = 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "unix", DEFAULT_GLUSTERD_SOCKFILE, 0);
-        if (ret) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Setting the volfile server failed, "
-                             "%s", strerror (errno));
-                goto out;
-        }
-
-        ret = glfsh_set_heal_options (fs, heal_op);
-        if (ret) {
-                printf ("Setting xlator heal options failed, %s\n",
-                        strerror(errno));
-                goto out;
-        }
-        snprintf (logfilepath, sizeof (logfilepath),
-                  DEFAULT_HEAL_LOG_FILE_DIRECTORY"/glfsheal-%s.log", volname);
-        ret = glfs_set_logging(fs, logfilepath, GF_LOG_INFO);
-        if (ret < 0) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Failed to set the log file path, "
-                             "%s", strerror (errno));
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                ret = -errno;
-                if (errno == ENOENT) {
-                        gf_asprintf (&op_errstr, "Volume %s does not exist",
-                                     volname);
-                } else {
-                        gf_asprintf (&op_errstr, "%s: Not able to fetch "
-                                     "volfile from glusterd", volname);
-                }
-                goto out;
-        }
-
-        top_subvol = glfs_active_subvol (fs);
-        if (!top_subvol) {
-                ret = -errno;
-                if (errno == ENOTCONN) {
-                        gf_asprintf (&op_errstr, "Volume %s is not started "
-                                                 "(Or) All the bricks are not "
-                                                 "running.", volname);
-                }
-                else {
-                        gf_asprintf (&op_errstr, "%s: Not able to mount the "
-                                             "volume, %s", volname,
-                                             strerror (errno));
-                }
-                goto out;
+    }
+
+    if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        glfsh_output = &glfsh_no_print;
+
+    ret = glfsh_output->init();
+    if (ret)
+        exit(EXIT_FAILURE);
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        ret = -errno;
+        gf_asprintf(&op_errstr, "Not able to initialize volume '%s'", volname);
+        goto out;
+    }
+
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        fs->ctx->secure_mgmt = 1;
+        fs->ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+    if (socket_filepath != NULL) {
+        ret = glfs_set_volfile_server(fs, "unix", socket_filepath, 0);
+    } else {
+        ret = glfs_set_volfile_server(fs, "unix", DEFAULT_GLUSTERD_SOCKFILE, 0);
+    }
+    if (ret) {
+        ret = -errno;
+        gf_asprintf(&op_errstr,
+                    "Setting the volfile server failed, "
+                    "%s",
+                    strerror(errno));
+        goto out;
+    }
+
+    ret = glfsh_set_heal_options(fs, heal_op);
+    if (ret) {
+        printf("Setting xlator heal options failed, %s\n", strerror(errno));
+        goto out;
+    }
+    snprintf(logfilepath, sizeof(logfilepath),
+             DEFAULT_HEAL_LOG_FILE_DIRECTORY "/glfsheal-%s.log", volname);
+    ret = glfs_set_logging(fs, logfilepath, log_level);
+    if (ret < 0) {
+        ret = -errno;
+        gf_asprintf(&op_errstr,
+                    "Failed to set the log file path, "
+                    "%s",
+                    strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_setfspid(fs, GF_CLIENT_PID_GLFS_HEAL);
+    if (ret) {
+        printf("Setting client pid failed, %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        ret = -errno;
+        if (errno == ENOENT) {
+            gf_asprintf(&op_errstr, "Volume %s does not exist", volname);
+        } else {
+            gf_asprintf(&op_errstr,
+                        "%s: Not able to fetch "
+                        "volfile from glusterd",
+                        volname);
         }
-
-        ret = glfsh_validate_volume (top_subvol, heal_op);
-        if (ret < 0) {
-                ret = -EINVAL;
-                gf_asprintf (&op_errstr, "Volume %s is not of type %s", volname,
-                                     (heal_op == GF_SHD_OP_INDEX_SUMMARY) ?
-                                     "replicate/disperse":"replicate");
-                goto out;
+        goto out;
+    }
+
+    top_subvol = glfs_active_subvol(fs);
+    if (!top_subvol) {
+        ret = -errno;
+        if (errno == ENOTCONN) {
+            gf_asprintf(&op_errstr,
+                        "Volume %s is not started "
+                        "(Or) All the bricks are not "
+                        "running.",
+                        volname);
+        } else {
+            gf_asprintf(&op_errstr,
+                        "%s: Not able to mount the "
+                        "volume, %s",
+                        volname, strerror(errno));
         }
-        rootloc.inode = inode_ref (top_subvol->itable->root);
-        glfs_loc_touchup (&rootloc);
-
-        switch (heal_op) {
+        goto out;
+    }
+
+    char *var_str = (heal_op == GF_SHD_OP_INDEX_SUMMARY ||
+                     heal_op == GF_SHD_OP_HEAL_SUMMARY)
+                        ? "replicate/disperse"
+                        : "replicate";
+
+    ret = glfsh_validate_volume(top_subvol, heal_op);
+    if (ret < 0) {
+        ret = -EINVAL;
+        gf_asprintf(&op_errstr,
+                    "This command is supported "
+                    "for only volumes of %s type. Volume %s "
+                    "is not of type %s",
+                    var_str, volname, var_str);
+        goto out;
+    }
+    rootloc.inode = inode_ref(top_subvol->itable->root);
+    ret = glfs_loc_touchup(&rootloc);
+    if (ret < 0) {
+        ret = -errno;
+        goto out;
+    }
+
+    switch (heal_op) {
         case GF_SHD_OP_INDEX_SUMMARY:
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
-                ret = glfsh_gather_heal_info (fs, top_subvol, &rootloc,
-                                              heal_op);
-                break;
+        case GF_SHD_OP_HEAL_SUMMARY:
+            ret = glfsh_gather_heal_info(fs, top_subvol, &rootloc, heal_op);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                ret = glfsh_heal_from_bigger_file_or_mtime (fs, top_subvol,
-                                                   &rootloc, file, heal_op);
-                        break;
+            ret = glfsh_heal_from_bigger_file_or_mtime(fs, top_subvol, &rootloc,
+                                                       file, heal_op);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = glfsh_heal_from_brick (fs, top_subvol, &rootloc,
-                                             hostname, path, file);
-                break;
+            ret = glfsh_heal_from_brick(fs, top_subvol, &rootloc, hostname,
+                                        path, file);
+            break;
         default:
-                ret = -EINVAL;
-                break;
-        }
-
-        glfsh_output->end (ret, NULL);
-        if (ret < 0)
-                ret = -ret;
-        loc_wipe (&rootloc);
-        glfs_subvol_done (fs, top_subvol);
-        cleanup (fs);
-
-        return ret;
+            ret = -EINVAL;
+            break;
+    }
+
+    glfsh_output->end(ret, NULL);
+    if (ret < 0)
+        ret = -ret;
+    loc_wipe(&rootloc);
+    glfs_subvol_done(fs, top_subvol);
+    cleanup(fs);
+
+    return ret;
 out:
-        if (fs && top_subvol)
-                glfs_subvol_done (fs, top_subvol);
-        loc_wipe (&rootloc);
-        cleanup (fs);
-        if (glfsh_output)
-                glfsh_output->end (ret, op_errstr);
-        if (op_errstr)
-                GF_FREE (op_errstr);
-        return ret;
+    if (fs && top_subvol)
+        glfs_subvol_done(fs, top_subvol);
+    loc_wipe(&rootloc);
+    cleanup(fs);
+    if (glfsh_output)
+        glfsh_output->end(ret, op_errstr);
+    if (op_errstr)
+        GF_FREE(op_errstr);
+    return ret;
 }
diff --git a/libgfchangelog.pc.in b/libgfchangelog.pc.in
index 91c85e6f1f8..79eac2ad2d3 100644
--- a/libgfchangelog.pc.in
+++ b/libgfchangelog.pc.in
@@ -9,4 +9,4 @@ Description: GlusterFS Changelog Consumer Library
 Version: @LIBGFCHANGELOG_VERSION@
 Requires: @PKGCONFIG_UUID@
 Libs: -L${libdir} -lgfchangelog -lglusterfs
-Cflags: -I${includedir}/glusterfs/gfchangelog -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64
+Cflags: -I${includedir} -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D__USE_LARGEFILE64
diff --git a/libgfdb.pc.in b/libgfdb.pc.in
deleted file mode 100644
index 945685cde98..00000000000
--- a/libgfdb.pc.in
+++ /dev/null
@@ -1,12 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-
-Name: libgfdb
-Description: GlusterFS Database Library
-Version: @LIBGFDB_VERSION@
-Libs: -L${libdir} -lgfchangedb -lglusterfs
-Cflags: -I${includedir}/glusterfs/gfdb
-Requires: sqlite3 @PKGCONFIG_UUID@
diff --git a/xlators/features/changetimerecorder/Makefile.am b/libglusterd/Makefile.am
index a985f42a877..a985f42a877 100644
--- a/xlators/features/changetimerecorder/Makefile.am
+++ b/libglusterd/Makefile.am
diff --git a/libglusterd/src/Makefile.am b/libglusterd/src/Makefile.am
new file mode 100644
index 00000000000..684d2bac96b
--- /dev/null
+++ b/libglusterd/src/Makefile.am
@@ -0,0 +1,31 @@
+libglusterd_la_CFLAGS = $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) \
+	-DDATADIR=\"$(localstatedir)\"
+
+libglusterd_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 \
+	-DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" \
+	-DXLATORPARENTDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)\" \
+	-DXXH_NAMESPACE=GF_ -D__USE_LARGEFILE64 \
+	-I$(CONTRIBDIR)/rbtree \
+	-I$(CONTRIBDIR)/libexecinfo ${ARGP_STANDALONE_CPPFLAGS} \
+	-DSBIN_DIR=\"$(sbindir)\" -I$(CONTRIBDIR)/timer-wheel \
+	-I$(CONTRIBDIR)/xxhash \
+	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
+	-I$(top_srcdir)/rpc/rpc-lib/src/
+
+libglusterd_la_LIBADD = $(ZLIB_LIBS) $(MATH_LIB) $(UUID_LIBS)
+libglusterd_la_LDFLAGS = -version-info $(LIBGLUSTERFS_LT_VERSION) $(GF_LDFLAGS) \
+	-export-symbols $(top_srcdir)/libglusterd/src/libglusterd.sym
+
+lib_LTLIBRARIES = libglusterd.la
+
+libglusterd_la_SOURCES = gd-common-utils.c
+
+libglusterd_la_HEADERS = gd-common-utils.h
+
+libglusterd_ladir = $(includedir)/glusterfs
+
+noinst_HEADERS = gd-common-utils.h
+
+EXTRA_DIST = libglusterd.sym
+
+CLEANFILES =
diff --git a/libglusterd/src/gd-common-utils.c b/libglusterd/src/gd-common-utils.c
new file mode 100644
index 00000000000..243fab215e6
--- /dev/null
+++ b/libglusterd/src/gd-common-utils.c
@@ -0,0 +1,78 @@
+/*
+  Copyright (c) 2019 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#include "gd-common-utils.h"
+#include "cli1-xdr.h"
+
+int
+get_vol_type(int type, int dist_count, int brick_count)
+{
+    if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) &&
+        (dist_count < brick_count))
+        type = type + GF_CLUSTER_TYPE_MAX - 1;
+
+    return type;
+}
+
+char *
+get_struct_variable(int mem_num, gf_gsync_status_t *sts_val)
+{
+    switch (mem_num) {
+        case 0:
+            return (sts_val->node);
+        case 1:
+            return (sts_val->master);
+        case 2:
+            return (sts_val->brick);
+        case 3:
+            return (sts_val->slave_user);
+        case 4:
+            return (sts_val->slave);
+        case 5:
+            return (sts_val->slave_node);
+        case 6:
+            return (sts_val->worker_status);
+        case 7:
+            return (sts_val->crawl_status);
+        case 8:
+            return (sts_val->last_synced);
+        case 9:
+            return (sts_val->entry);
+        case 10:
+            return (sts_val->data);
+        case 11:
+            return (sts_val->meta);
+        case 12:
+            return (sts_val->failures);
+        case 13:
+            return (sts_val->checkpoint_time);
+        case 14:
+            return (sts_val->checkpoint_completed);
+        case 15:
+            return (sts_val->checkpoint_completion_time);
+        case 16:
+            return (sts_val->brick_host_uuid);
+        case 17:
+            return (sts_val->last_synced_utc);
+        case 18:
+            return (sts_val->checkpoint_time_utc);
+        case 19:
+            return (sts_val->checkpoint_completion_time_utc);
+        case 20:
+            return (sts_val->slavekey);
+        case 21:
+            return (sts_val->session_slave);
+        default:
+            goto out;
+    }
+
+out:
+    return NULL;
+}
diff --git a/libglusterd/src/gd-common-utils.h b/libglusterd/src/gd-common-utils.h
new file mode 100644
index 00000000000..b9bb4f956fe
--- /dev/null
+++ b/libglusterd/src/gd-common-utils.h
@@ -0,0 +1,28 @@
+/*
+  Copyright (c) 2019 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GD_COMMON_UTILS_H
+#define _GD_COMMON_UTILS_H
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stddef.h>
+
+#include "protocol-common.h"
+#include "rpcsvc.h"
+
+int
+get_vol_type(int type, int dist_count, int brick_count);
+
+char *
+get_struct_variable(int mem_num, gf_gsync_status_t *sts_val);
+
+#endif /* _GD_COMMON_UTILS_H */
diff --git a/libglusterd/src/libglusterd.sym b/libglusterd/src/libglusterd.sym
new file mode 100644
index 00000000000..45969a87c12
--- /dev/null
+++ b/libglusterd/src/libglusterd.sym
@@ -0,0 +1,2 @@
+get_vol_type
+get_struct_variable
diff --git a/libglusterfs/Makefile.am b/libglusterfs/Makefile.am
index 8e5a4a0ccbf..d471a3f9243 100644
--- a/libglusterfs/Makefile.am
+++ b/libglusterfs/Makefile.am
@@ -1,3 +1,3 @@
-SUBDIRS = src src/gfdb
+SUBDIRS = src
 
 CLEANFILES = 
diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am
index d64ef9cd92e..385e8ef4600 100644
--- a/libglusterfs/src/Makefile.am
+++ b/libglusterfs/src/Makefile.am
@@ -6,14 +6,16 @@ libglusterfs_la_CFLAGS = $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) \
 libglusterfs_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 \
 	-DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" \
 	-DXLATORPARENTDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)\" \
-	-I$(top_srcdir)/rpc/xdr/src/ -I$(top_builddir)/rpc/xdr/src/ \
-	-I$(top_srcdir)/rpc/rpc-lib/src/ -I$(CONTRIBDIR)/rbtree \
+	-DXXH_NAMESPACE=GF_ -D__USE_LARGEFILE64 \
+	-I$(CONTRIBDIR)/rbtree \
 	-I$(CONTRIBDIR)/libexecinfo ${ARGP_STANDALONE_CPPFLAGS} \
 	-DSBIN_DIR=\"$(sbindir)\" -I$(CONTRIBDIR)/timer-wheel \
 	-I$(CONTRIBDIR)/xxhash
 
-libglusterfs_la_LIBADD = @LEXLIB@ $(ZLIB_LIBS) $(MATH_LIB) $(UUID_LIBS)
-libglusterfs_la_LDFLAGS = -version-info $(LIBGLUSTERFS_LT_VERSION)
+libglusterfs_la_LIBADD = $(ZLIB_LIBS) $(MATH_LIB) $(UUID_LIBS) $(LIB_DL) \
+	$(URCU_LIBS) $(URCU_CDS_LIBS)
+libglusterfs_la_LDFLAGS = -version-info $(LIBGLUSTERFS_LT_VERSION) $(GF_LDFLAGS) \
+	-export-symbols $(top_srcdir)/libglusterfs/src/libglusterfs.sym
 
 lib_LTLIBRARIES = libglusterfs.la
 libgfchangelogdir = $(includedir)/glusterfs/gfchangelog
@@ -29,36 +31,42 @@ libglusterfs_la_SOURCES = dict.c xlator.c logging.c \
 	circ-buff.c event-history.c gidcache.c ctx.c client_t.c event-poll.c \
 	event-epoll.c syncop-utils.c cluster-syncop.c refcount.c \
 	$(CONTRIBDIR)/libgen/basename_r.c \
-	$(CONTRIBDIR)/libgen/dirname_r.c $(CONTRIBDIR)/stdlib/gf_mkostemp.c \
+	$(CONTRIBDIR)/libgen/dirname_r.c \
 	strfd.c parse-utils.c $(CONTRIBDIR)/mount/mntent.c \
 	$(CONTRIBDIR)/libexecinfo/execinfo.c quota-common-utils.c rot-buffs.c \
 	$(CONTRIBDIR)/timer-wheel/timer-wheel.c \
 	$(CONTRIBDIR)/timer-wheel/find_last_bit.c default-args.c locking.c \
 	$(CONTRIBDIR)/xxhash/xxhash.c \
-	compound-fop-utils.c throttle-tbf.c
+	throttle-tbf.c monitoring.c async.c
 
 nodist_libglusterfs_la_SOURCES = y.tab.c graph.lex.c defaults.c
-nodist_libglusterfs_la_HEADERS = y.tab.h protocol-common.h
-
-BUILT_SOURCES = graph.lex.c defaults.c eventtypes.h protocol-common.h
-
-protocol-common.h: $(top_srcdir)/rpc/rpc-lib/src/protocol-common.h
-	cp $(top_srcdir)/rpc/rpc-lib/src/protocol-common.h .
-
-libglusterfs_la_HEADERS = common-utils.h defaults.h default-args.h \
-	dict.h glusterfs.h hashfn.h timespec.h logging.h xlator.h \
-	stack.h timer.h list.h inode.h call-stub.h compat.h fd.h \
-	revision.h compat-errno.h event.h mem-pool.h byte-order.h \
-	gf-dirent.h locking.h syscall.h iobuf.h globals.h statedump.h \
-	checksum.h daemon.h store.h rbthash.h iatt.h latency.h \
-	mem-types.h syncop.h cluster-syncop.h graph-utils.h trie.h \
-	refcount.h run.h options.h lkowner.h fd-lk.h circ-buff.h \
-	event-history.h gidcache.h client_t.h glusterfs-acl.h \
-	glfs-message-id.h template-component-messages.h strfd.h \
-	syncop-utils.h parse-utils.h libglusterfs-messages.h \
-	lvm-defaults.h quota-common-utils.h rot-buffs.h \
-	compat-uuid.h upcall-utils.h throttle-tbf.h events.h\
-	compound-fop-utils.h atomic.h
+nodist_libglusterfs_la_HEADERS = y.tab.h
+
+BUILT_SOURCES = graph.lex.c defaults.c eventtypes.h
+
+libglusterfs_la_HEADERS = glusterfs/common-utils.h glusterfs/defaults.h \
+	glusterfs/default-args.h glusterfs/dict.h glusterfs/glusterfs.h \
+	glusterfs/hashfn.h glusterfs/timespec.h glusterfs/logging.h \
+	glusterfs/xlator.h glusterfs/stack.h glusterfs/timer.h glusterfs/list.h \
+	glusterfs/inode.h glusterfs/call-stub.h glusterfs/compat.h glusterfs/fd.h \
+	glusterfs/revision.h glusterfs/compat-errno.h glusterfs/gf-event.h \
+	glusterfs/mem-pool.h glusterfs/byte-order.h glusterfs/gf-dirent.h \
+	glusterfs/locking.h glusterfs/syscall.h glusterfs/iobuf.h \
+	glusterfs/globals.h glusterfs/statedump.h glusterfs/checksum.h \
+	glusterfs/daemon.h glusterfs/store.h glusterfs/rbthash.h glusterfs/iatt.h \
+	glusterfs/latency.h glusterfs/mem-types.h glusterfs/syncop.h \
+	glusterfs/cluster-syncop.h glusterfs/graph-utils.h glusterfs/trie.h \
+	glusterfs/refcount.h glusterfs/run.h glusterfs/options.h \
+	glusterfs/lkowner.h glusterfs/fd-lk.h glusterfs/circ-buff.h \
+	glusterfs/event-history.h glusterfs/gidcache.h glusterfs/client_t.h \
+	glusterfs/glusterfs-acl.h glusterfs/glfs-message-id.h \
+	glusterfs/template-component-messages.h glusterfs/strfd.h \
+	glusterfs/syncop-utils.h glusterfs/parse-utils.h \
+	glusterfs/libglusterfs-messages.h glusterfs/lvm-defaults.h \
+	glusterfs/quota-common-utils.h glusterfs/rot-buffs.h \
+	glusterfs/compat-uuid.h glusterfs/upcall-utils.h glusterfs/throttle-tbf.h \
+	glusterfs/events.h glusterfs/atomic.h glusterfs/monitoring.h \
+	glusterfs/async.h glusterfs/glusterfs-fops.h
 
 libglusterfs_ladir = $(includedir)/glusterfs
 
@@ -68,18 +76,10 @@ noinst_HEADERS = unittest/unittest.h \
 	$(CONTRIBDIR)/libexecinfo/execinfo_compat.h \
 	$(CONTRIBDIR)/timer-wheel/timer-wheel.h \
 	$(CONTRIBDIR)/xxhash/xxhash.h \
-	tier-ctr-interface.h
-
-if !HAVE_LIBUUID
-# FIXME: unbundle libuuid, see compat-uuid.h.
-libglusterfs_la_SOURCES += $(CONTRIBDIR)/uuid/clear.c \
-	$(CONTRIBDIR)/uuid/copy.c $(CONTRIBDIR)/uuid/gen_uuid.c \
-	$(CONTRIBDIR)/uuid/pack.c $(CONTRIBDIR)/uuid/parse.c \
-	$(CONTRIBDIR)/uuid/unparse.c $(CONTRIBDIR)/uuid/uuid_time.c \
-	$(CONTRIBDIR)/uuid/compare.c $(CONTRIBDIR)/uuid/isnull.c \
-	$(CONTRIBDIR)/uuid/unpack.c
-endif
-
+	$(CONTRIBDIR)/userspace-rcu/wfcqueue.h \
+	$(CONTRIBDIR)/userspace-rcu/wfstack.h \
+	$(CONTRIBDIR)/userspace-rcu/static-wfcqueue.h \
+	$(CONTRIBDIR)/userspace-rcu/static-wfstack.h
 
 eventtypes.h: $(top_srcdir)/events/eventskeygen.py
 	$(PYTHON) $(top_srcdir)/events/eventskeygen.py C_HEADER
@@ -90,7 +90,7 @@ endif
 
 libgfchangelog_HEADERS = changelog.h
 
-EXTRA_DIST = graph.l graph.y defaults-tmpl.c
+EXTRA_DIST = graph.l graph.y defaults-tmpl.c libglusterfs.sym
 
 graph.lex.c: graph.l y.tab.h
 	$(LEX) -Pgraphyy -t $(srcdir)/graph.l > $@
diff --git a/libglusterfs/src/async.c b/libglusterfs/src/async.c
new file mode 100644
index 00000000000..1d6cfa374b6
--- /dev/null
+++ b/libglusterfs/src/async.c
@@ -0,0 +1,720 @@
+/*
+  Copyright (c) 2019 Red Hat, Inc <https://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+/* To implement an efficient thread pool with minimum contention we have used
+ * the following ideas:
+ *
+ *    - The queue of jobs has been implemented using a Wait-Free queue provided
+ *      by the userspace-rcu library. This queue requires a mutex when multiple
+ *      consumers can be extracting items from it concurrently, but the locked
+ *      region is very small, which minimizes the chances of contention. To
+ *      further minimize contention, the number of active worker threads that
+ *      are accessing the queue is dynamically adjusted so that we always have
+ *      the minimum required amount of workers contending for the queue. Adding
+ *      new items can be done with a single atomic operation, without locks.
+ *
+ *    - All queue management operations, like creating more threads, enabling
+ *      sleeping ones, etc. are done by a single thread. This makes it possible
+ *      to manage all scaling related information and workers lists without
+ *      locks. This functionality is implemented as a role that can be assigned
+ *      to any of the worker threads, which avoids that some lengthy operations
+ *      could interfere with this task.
+ *
+ *    - Management is based on signals. We used signals for management tasks to
+ *      avoid multiple system calls for each request (with signals we can wait
+ *      for multiple events and get some additional data for each request in a
+ *      single call, instead of first polling and then reading).
+ *
+ * TODO: There are some other changes that can take advantage of this new
+ *       thread pool.
+ *
+ *          - Use this thread pool as the core threading model for synctasks. I
+ *            think this would improve synctask performance because I think we
+ *            currently have some contention there for some workloads.
+ *
+ *          - Implement a per thread timer that will allow adding and removing
+ *            timers without using mutexes.
+ *
+ *          - Integrate with userspace-rcu library in QSBR mode, allowing
+ *            other portions of code to be implemented using RCU-based
+ *            structures with a extremely fast read side without contention.
+ *
+ *          - Integrate I/O into the thread pool so that the thread pool is
+ *            able to efficiently manage all loads and scale dynamically. This
+ *            could make it possible to minimize context switching when serving
+ *            requests from fuse or network.
+ *
+ *          - Dynamically scale the number of workers based on system load.
+ *            This will make it possible to reduce contention when system is
+ *            heavily loaded, improving performance under these circumstances
+ *            (or minimizing performance loss). This will also make it possible
+ *            that gluster can coexist with other processes that also consume
+ *            CPU, with minimal interference from each other.
+ */
+
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include "glusterfs/list.h"
+#include "glusterfs/mem-types.h"
+#include "glusterfs/async.h"
+
+/* These macros wrap a simple system/library call to check the returned error
+ * and log a message in case of failure. */
+#define GF_ASYNC_CHECK(_func, _args...)                                        \
+    ({                                                                         \
+        int32_t __async_error = -_func(_args);                                 \
+        if (caa_unlikely(__async_error != 0)) {                                \
+            gf_async_error(__async_error, #_func "() failed.");                \
+        }                                                                      \
+        __async_error;                                                         \
+    })
+
+#define GF_ASYNC_CHECK_ERRNO(_func, _args...)                                  \
+    ({                                                                         \
+        int32_t __async_error = _func(_args);                                  \
+        if (caa_unlikely(__async_error < 0)) {                                 \
+            __async_error = -errno;                                            \
+            gf_async_error(__async_error, #_func "() failed.");                \
+        }                                                                      \
+        __async_error;                                                         \
+    })
+
+/* These macros are used when, based on POSIX documentation, the function
+ * should never fail under the conditions we are using it. So any unexpected
+ * error will be handled as a fatal event. It probably means a critical bug
+ * or memory corruption. In both cases we consider that stopping the process
+ * is safer (otherwise it could cause more corruption with unknown effects
+ * that could be worse). */
+#define GF_ASYNC_CANTFAIL(_func, _args...)                                     \
+    do {                                                                       \
+        int32_t __async_error = -_func(_args);                                 \
+        if (caa_unlikely(__async_error != 0)) {                                \
+            gf_async_fatal(__async_error, #_func "() failed");                 \
+        }                                                                      \
+    } while (0)
+
+#define GF_ASYNC_CANTFAIL_ERRNO(_func, _args...)                               \
+    ({                                                                         \
+        int32_t __async_error = _func(_args);                                  \
+        if (caa_unlikely(__async_error < 0)) {                                 \
+            __async_error = -errno;                                            \
+            gf_async_fatal(__async_error, #_func "() failed");                 \
+        }                                                                      \
+        __async_error;                                                         \
+    })
+
+/* TODO: for now we allocate a static array of workers. There's an issue if we
+ *       try to use dynamic memory since these workers are initialized very
+ *       early in the process startup and it seems that sometimes not all is
+ *       ready to use dynamic memory. */
+static gf_async_worker_t gf_async_workers[GF_ASYNC_MAX_THREADS];
+
+/* This is the only global variable needed to manage the entire framework. */
+gf_async_control_t gf_async_ctrl = {};
+
+static __thread gf_async_worker_t *gf_async_current_worker = NULL;
+
+/* The main function of the worker threads. */
+static void *
+gf_async_worker(void *arg);
+
+static void
+gf_async_sync_init(void)
+{
+    GF_ASYNC_CANTFAIL(pthread_barrier_init, &gf_async_ctrl.sync, NULL, 2);
+}
+
+static void
+gf_async_sync_now(void)
+{
+    int32_t ret;
+
+    ret = pthread_barrier_wait(&gf_async_ctrl.sync);
+    if (ret == PTHREAD_BARRIER_SERIAL_THREAD) {
+        GF_ASYNC_CANTFAIL(pthread_barrier_destroy, &gf_async_ctrl.sync);
+        ret = 0;
+    }
+    if (caa_unlikely(ret != 0)) {
+        gf_async_fatal(-ret, "pthread_barrier_wait() failed");
+    }
+}
+
+static void
+gf_async_sigmask_empty(sigset_t *mask)
+{
+    GF_ASYNC_CANTFAIL_ERRNO(sigemptyset, mask);
+}
+
+static void
+gf_async_sigmask_add(sigset_t *mask, int32_t signal)
+{
+    GF_ASYNC_CANTFAIL_ERRNO(sigaddset, mask, signal);
+}
+
+static void
+gf_async_sigmask_set(int32_t mode, sigset_t *mask, sigset_t *old)
+{
+    GF_ASYNC_CANTFAIL(pthread_sigmask, mode, mask, old);
+}
+
+static void
+gf_async_sigaction(int32_t signum, const struct sigaction *action,
+                   struct sigaction *old)
+{
+    GF_ASYNC_CANTFAIL_ERRNO(sigaction, signum, action, old);
+}
+
+static int32_t
+gf_async_sigwait(sigset_t *set)
+{
+    int32_t ret, signum;
+
+    do {
+        ret = sigwait(set, &signum);
+    } while (caa_unlikely((ret < 0) && (errno == EINTR)));
+
+    if (caa_unlikely(ret < 0)) {
+        ret = -errno;
+        gf_async_fatal(ret, "sigwait() failed");
+    }
+
+    return signum;
+}
+
+static int32_t
+gf_async_sigtimedwait(sigset_t *set, struct timespec *timeout)
+{
+    int32_t ret;
+
+    do {
+        ret = sigtimedwait(set, NULL, timeout);
+    } while (caa_unlikely((ret < 0) && (errno == EINTR)));
+    if (caa_unlikely(ret < 0)) {
+        ret = -errno;
+        /* EAGAIN means that the timeout has expired, so we allow this error.
+         * Any other error shouldn't happen. */
+        if (caa_unlikely(ret != -EAGAIN)) {
+            gf_async_fatal(ret, "sigtimedwait() failed");
+        }
+        ret = 0;
+    }
+
+    return ret;
+}
+
+static void
+gf_async_sigbroadcast(int32_t signum)
+{
+    GF_ASYNC_CANTFAIL_ERRNO(kill, gf_async_ctrl.pid, signum);
+}
+
+static void
+gf_async_signal_handler(int32_t signum)
+{
+    /* We should never handle a signal in this function. */
+    gf_async_fatal(-EBUSY,
+                   "Unexpected processing of signal %d through a handler.",
+                   signum);
+}
+
+static void
+gf_async_signal_setup(void)
+{
+    struct sigaction action;
+
+    /* We configure all related signals so that we can detect threads using an
+     * invalid signal mask that doesn't block our critical signal. */
+    memset(&action, 0, sizeof(action));
+    action.sa_handler = gf_async_signal_handler;
+
+    gf_async_sigaction(GF_ASYNC_SIGCTRL, &action, &gf_async_ctrl.handler_ctrl);
+
+    gf_async_sigaction(GF_ASYNC_SIGQUEUE, &action,
+                       &gf_async_ctrl.handler_queue);
+}
+
+static void
+gf_async_signal_restore(void)
+{
+    /* Handlers we have previously changed are restored back to their original
+     * value. */
+
+    if (gf_async_ctrl.handler_ctrl.sa_handler != gf_async_signal_handler) {
+        gf_async_sigaction(GF_ASYNC_SIGCTRL, &gf_async_ctrl.handler_ctrl, NULL);
+    }
+
+    if (gf_async_ctrl.handler_queue.sa_handler != gf_async_signal_handler) {
+        gf_async_sigaction(GF_ASYNC_SIGQUEUE, &gf_async_ctrl.handler_queue,
+                           NULL);
+    }
+}
+
+static void
+gf_async_signal_flush(void)
+{
+    struct timespec delay;
+
+    delay.tv_sec = 0;
+    delay.tv_nsec = 0;
+
+    /* We read all pending signals so that they don't trigger once the signal
+     * mask of some thread is changed. */
+    while (gf_async_sigtimedwait(&gf_async_ctrl.sigmask_ctrl, &delay) > 0) {
+    }
+    while (gf_async_sigtimedwait(&gf_async_ctrl.sigmask_queue, &delay) > 0) {
+    }
+}
+
+static int32_t
+gf_async_thread_create(pthread_t *thread, int32_t id, void *data)
+{
+    int32_t ret;
+
+    ret = gf_thread_create(thread, NULL, gf_async_worker, data,
+                           GF_ASYNC_THREAD_NAME "%u", id);
+    if (caa_unlikely(ret < 0)) {
+        /* TODO: gf_thread_create() should return a more specific error
+         *       code. */
+        return -ENOMEM;
+    }
+
+    return 0;
+}
+
+static void
+gf_async_thread_wait(pthread_t thread)
+{
+    /* TODO: this is a blocking call executed inside one of the workers of the
+     *       thread pool. This is bad, but this is only executed once we have
+     *       received a notification from the thread that it's terminating, so
+     *       this should return almost immediately. However, to be more robust
+     *       it would be better to use pthread_timedjoin_np() (or even a call
+     *       to pthread_tryjoin_np() followed by a delayed recheck if it
+     *       fails), but they are not portable. We should see how to do this
+     *       in other platforms. */
+    GF_ASYNC_CANTFAIL(pthread_join, thread, NULL);
+}
+
+static int32_t
+gf_async_worker_create(void)
+{
+    struct cds_wfs_node *node;
+    gf_async_worker_t *worker;
+    uint32_t counts, running, max;
+    int32_t ret;
+
+    node = __cds_wfs_pop_blocking(&gf_async_ctrl.available);
+    if (caa_unlikely(node == NULL)) {
+        /* There are no more available workers. We have all threads running. */
+        return 1;
+    }
+    cds_wfs_node_init(node);
+
+    ret = 1;
+
+    counts = uatomic_read(&gf_async_ctrl.counts);
+    max = uatomic_read(&gf_async_ctrl.max_threads);
+    running = GF_ASYNC_COUNT_RUNNING(counts);
+    if (running < max) {
+        uatomic_add(&gf_async_ctrl.counts, GF_ASYNC_COUNTS(1, 0));
+
+        worker = caa_container_of(node, gf_async_worker_t, stack);
+
+        ret = gf_async_thread_create(&worker->thread, worker->id, worker);
+        if (caa_likely(ret >= 0)) {
+            return 0;
+        }
+
+        uatomic_add(&gf_async_ctrl.counts, GF_ASYNC_COUNTS(-1, 0));
+    }
+
+    cds_wfs_push(&gf_async_ctrl.available, node);
+
+    return ret;
+}
+
+static void
+gf_async_worker_enable(void)
+{
+    /* This will wake one of the spare workers. If all workers are busy now,
+     * the signal will be queued so that the first one that completes its
+     * work will become the leader. */
+    gf_async_sigbroadcast(GF_ASYNC_SIGCTRL);
+
+    /* We have consumed a spare worker. We create another one for future
+     * needs. */
+    gf_async_worker_create();
+}
+
+static void
+gf_async_worker_wait(void)
+{
+    int32_t signum;
+
+    signum = gf_async_sigwait(&gf_async_ctrl.sigmask_ctrl);
+    if (caa_unlikely(signum != GF_ASYNC_SIGCTRL)) {
+        gf_async_fatal(-EINVAL, "Worker received an unexpected signal (%d)",
+                       signum);
+    }
+}
+
+static void
+gf_async_leader_wait(void)
+{
+    int32_t signum;
+
+    signum = gf_async_sigwait(&gf_async_ctrl.sigmask_queue);
+    if (caa_unlikely(signum != GF_ASYNC_SIGQUEUE)) {
+        gf_async_fatal(-EINVAL, "Leader received an unexpected signal (%d)",
+                       signum);
+    }
+}
+
+static void
+gf_async_run(struct cds_wfcq_node *node)
+{
+    gf_async_t *async;
+
+    /* We've just got work from the queue. Process it. */
+    async = caa_container_of(node, gf_async_t, queue);
+    /* TODO: remove dependency from THIS and xl. */
+    THIS = async->xl;
+    async->cbk(async->xl, async);
+}
+
+static void
+gf_async_worker_run(void)
+{
+    struct cds_wfcq_node *node;
+
+    do {
+        /* We keep executing jobs from the queue while it's not empty. Note
+         * that while we do this, we are ignoring any stop request. That's
+         * fine, since we need to process our own 'join' messages to fully
+         * terminate all threads. Note that normal jobs should have already
+         * completed once a stop request is received. */
+        node = cds_wfcq_dequeue_blocking(&gf_async_ctrl.queue.head,
+                                         &gf_async_ctrl.queue.tail);
+        if (node != NULL) {
+            gf_async_run(node);
+        }
+    } while (node != NULL);
+
+    /* TODO: I've tried to keep the worker looking at the queue for some small
+     *       amount of time in a busy loop to see if more jobs come soon. With
+     *       this I attempted to avoid the overhead of signal management if
+     *       jobs come fast enough. However experimental results seem to
+     *       indicate that doing this, CPU utilization grows and performance
+     *       is actually reduced. We need to see if that's because I used bad
+     *       parameters or it's really better to do it as it's done now. */
+}
+
+static void
+gf_async_leader_run(void)
+{
+    struct cds_wfcq_node *node;
+
+    node = cds_wfcq_dequeue_blocking(&gf_async_ctrl.queue.head,
+                                     &gf_async_ctrl.queue.tail);
+    while (caa_unlikely(node == NULL)) {
+        gf_async_leader_wait();
+
+        node = cds_wfcq_dequeue_blocking(&gf_async_ctrl.queue.head,
+                                         &gf_async_ctrl.queue.tail);
+    }
+
+    /* Activate the next available worker thread. It will become the new
+     * leader. */
+    gf_async_worker_enable();
+
+    gf_async_run(node);
+}
+
+static uint32_t
+gf_async_stop_check(gf_async_worker_t *worker)
+{
+    uint32_t counts, old, running, max;
+
+    /* First we check if we should stop without doing any costly atomic
+     * operation. */
+    old = uatomic_read(&gf_async_ctrl.counts);
+    max = uatomic_read(&gf_async_ctrl.max_threads);
+    running = GF_ASYNC_COUNT_RUNNING(old);
+    while (running > max) {
+        /* There are too many threads. We try to stop the current worker. */
+        counts = uatomic_cmpxchg(&gf_async_ctrl.counts, old,
+                                 old + GF_ASYNC_COUNTS(-1, 1));
+        if (old != counts) {
+            /* Another thread has just updated the counts. We need to retry. */
+            old = counts;
+            running = GF_ASYNC_COUNT_RUNNING(old);
+
+            continue;
+        }
+
+        running--;
+        worker->running = false;
+    }
+
+    return running;
+}
+
+static void
+gf_async_stop_all(xlator_t *xl, gf_async_t *async)
+{
+    if (gf_async_stop_check(gf_async_current_worker) > 0) {
+        /* There are more workers running. We propagate the stop request to
+         * them. */
+        gf_async(async, xl, gf_async_stop_all);
+    }
+}
+
+static void
+gf_async_join(xlator_t *xl, gf_async_t *async)
+{
+    gf_async_worker_t *worker;
+
+    worker = caa_container_of(async, gf_async_worker_t, async);
+
+    gf_async_thread_wait(worker->thread);
+
+    cds_wfs_push(&gf_async_ctrl.available, &worker->stack);
+}
+
+static void
+gf_async_terminate(gf_async_worker_t *worker)
+{
+    uint32_t counts;
+
+    counts = uatomic_add_return(&gf_async_ctrl.counts, GF_ASYNC_COUNTS(0, -1));
+    if (counts == 0) {
+        /* This is the termination of the last worker thread. We need to
+         * synchronize the main thread that is waiting for all workers to
+         * finish. */
+        gf_async_ctrl.sync_thread = worker->thread;
+
+        gf_async_sync_now();
+    } else {
+        /* Force someone else to join this thread to release resources. */
+        gf_async(&worker->async, THIS, gf_async_join);
+    }
+}
+
+static void *
+gf_async_worker(void *arg)
+{
+    gf_async_worker_t *worker;
+
+    worker = (gf_async_worker_t *)arg;
+    gf_async_current_worker = worker;
+
+    worker->running = true;
+    do {
+        /* This thread does nothing until someone enables it to become a
+         * leader. */
+        gf_async_worker_wait();
+
+        /* This thread is now a leader. It will process jobs from the queue
+         * and, if necessary, enable another worker and transfer leadership
+         * to it. */
+        gf_async_leader_run();
+
+        /* This thread is not a leader anymore. It will continue processing
+         * queued jobs until it becomes empty. */
+        gf_async_worker_run();
+
+        /* Stop the current thread if there are too many threads running. */
+        gf_async_stop_check(worker);
+    } while (worker->running);
+
+    gf_async_terminate(worker);
+
+    return NULL;
+}
+
+static void
+gf_async_cleanup(void)
+{
+    /* We do some basic initialization of the global variable 'gf_async_ctrl'
+     * so that it's put into a relatively consistent state. */
+
+    gf_async_ctrl.enabled = false;
+
+    gf_async_ctrl.pid = 0;
+    gf_async_sigmask_empty(&gf_async_ctrl.sigmask_ctrl);
+    gf_async_sigmask_empty(&gf_async_ctrl.sigmask_queue);
+
+    /* This is used to later detect if the handler of these signals have been
+     * changed or not. */
+    gf_async_ctrl.handler_ctrl.sa_handler = gf_async_signal_handler;
+    gf_async_ctrl.handler_queue.sa_handler = gf_async_signal_handler;
+
+    gf_async_ctrl.table = NULL;
+    gf_async_ctrl.max_threads = 0;
+    gf_async_ctrl.counts = 0;
+}
+
+void
+gf_async_fini(void)
+{
+    gf_async_t async;
+
+    if (uatomic_read(&gf_async_ctrl.counts) != 0) {
+        /* We ensure that all threads will quit on the next check. */
+        gf_async_ctrl.max_threads = 0;
+
+        /* Send the stop request to the thread pool. This will cause the
+         * execution of gf_async_stop_all() by one of the worker threads which,
+         * eventually, will terminate all worker threads. */
+        gf_async(&async, THIS, gf_async_stop_all);
+
+        /* We synchronize here with the last thread. */
+        gf_async_sync_now();
+
+        /* We have just synchronized with the latest thread. Now just wait for
+         * it to terminate. */
+        gf_async_thread_wait(gf_async_ctrl.sync_thread);
+
+        gf_async_signal_flush();
+    }
+
+    gf_async_signal_restore();
+
+    gf_async_cleanup();
+}
+
+void
+gf_async_adjust_threads(int32_t threads)
+{
+    if (threads == 0) {
+        /* By default we allow a maximum of 2 * #cores worker threads. This
+         * value is to try to accommodate threads that will do some I/O. Having
+         * more threads than cores we can keep CPU busy even if some threads
+         * are blocked for I/O. In the most efficient case, we can have #cores
+         * computing threads and #cores blocked threads on I/O. However this is
+         * hard to achieve because we can end with more than #cores computing
+         * threads, which won't provide a real benefit and will increase
+         * contention.
+         *
+         * TODO: implement a more intelligent dynamic maximum based on CPU
+         *       usage and/or system load. */
+        threads = sysconf(_SC_NPROCESSORS_ONLN) * 2;
+        if (threads < 0) {
+            /* If we can't get the current number of processors, we pick a
+             * random number. */
+            threads = 16;
+        }
+    }
+    if (threads > GF_ASYNC_MAX_THREADS) {
+        threads = GF_ASYNC_MAX_THREADS;
+    }
+    uatomic_set(&gf_async_ctrl.max_threads, threads);
+}
+
+int32_t
+gf_async_init(glusterfs_ctx_t *ctx)
+{
+    sigset_t set;
+    gf_async_worker_t *worker;
+    uint32_t i;
+    int32_t ret;
+    bool running;
+
+    gf_async_cleanup();
+
+    if (!ctx->cmd_args.global_threading ||
+        (ctx->process_mode == GF_GLUSTERD_PROCESS)) {
+        return 0;
+    }
+
+    /* At the init time, the maximum number of threads has not yet been
+     * configured. We use a small starting value that will be layer dynamically
+     * adjusted when ctx->config.max_threads is updated. */
+    gf_async_adjust_threads(GF_ASYNC_SPARE_THREADS + 1);
+
+    gf_async_ctrl.pid = getpid();
+
+    __cds_wfs_init(&gf_async_ctrl.available);
+    cds_wfcq_init(&gf_async_ctrl.queue.head, &gf_async_ctrl.queue.tail);
+
+    gf_async_sync_init();
+
+    /* TODO: it would be cleaner to use dynamic memory, but at this point some
+     *       memory management resources are not yet initialized. */
+    gf_async_ctrl.table = gf_async_workers;
+
+    /* We keep all workers in a stack. It will be used when a new thread needs
+     * to be created. */
+    for (i = GF_ASYNC_MAX_THREADS; i > 0; i--) {
+        worker = &gf_async_ctrl.table[i - 1];
+
+        worker->id = i - 1;
+        cds_wfs_node_init(&worker->stack);
+        cds_wfs_push(&gf_async_ctrl.available, &worker->stack);
+    }
+
+    /* Prepare the signal mask for regular workers and the leader. */
+    gf_async_sigmask_add(&gf_async_ctrl.sigmask_ctrl, GF_ASYNC_SIGCTRL);
+    gf_async_sigmask_add(&gf_async_ctrl.sigmask_queue, GF_ASYNC_SIGQUEUE);
+
+    /* TODO: this is needed to block our special signals in the current thread
+     *       and all children that it starts. It would be cleaner to do it when
+     *       signals are initialized, but there doesn't seem to be a unique
+     *       place to do that, so for now we do it here. */
+    gf_async_sigmask_empty(&set);
+    gf_async_sigmask_add(&set, GF_ASYNC_SIGCTRL);
+    gf_async_sigmask_add(&set, GF_ASYNC_SIGQUEUE);
+    gf_async_sigmask_set(SIG_BLOCK, &set, NULL);
+
+    /* Configure the signal handlers. This is mostly for safety, not really
+     * needed, but it doesn't hurt. Note that the caller must ensure that the
+     * signals we need to run are already blocked in any thread already
+     * started. Otherwise this won't work. */
+    gf_async_signal_setup();
+
+    running = false;
+
+    /* We start the spare workers + 1 for the leader. */
+    for (i = 0; i < GF_ASYNC_SPARE_THREADS; i++) {
+        ret = gf_async_worker_create();
+        if (caa_unlikely(ret < 0)) {
+            /* This is the initial start up so we enforce that the spare
+             * threads are created. If this fails at the beginning, it's very
+             * unlikely that the async workers could do its job, so we abort
+             * the initialization. */
+            goto out;
+        }
+
+        /* Once the first thread is started, we can enable it to become the
+         * initial leader. */
+        if ((ret == 0) && !running) {
+            running = true;
+            gf_async_worker_enable();
+        }
+    }
+
+    if (caa_unlikely(!running)) {
+        gf_async_fatal(-ENOMEM, "No worker thread has started");
+    }
+
+    gf_async_ctrl.enabled = true;
+
+    ret = 0;
+
+out:
+    if (ret < 0) {
+        gf_async_error(ret, "Unable to initialize the thread pool.");
+        gf_async_fini();
+    }
+
+    return ret;
+}
diff --git a/libglusterfs/src/atomic.h b/libglusterfs/src/atomic.h
deleted file mode 100644
index 71fcb1ee972..00000000000
--- a/libglusterfs/src/atomic.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _ATOMIC_H
-#define _ATOMIC_H
-
-#include <inttypes.h>
-
-#if defined(HAVE_ATOMIC_BUILTINS) || defined(HAVE_SYNC_BUILTINS)
-/* optimized implementation, macros only */
-
-typedef struct gf_atomic_t {
-        int64_t    cnt;
-} gf_atomic_t;
-
-#if defined(HAVE_ATOMIC_BUILTINS)
-
-/* all macros have a 'gf_atomic_t' as 1st argument */
-#define GF_ATOMIC_INIT(op, n)     __atomic_store (&(op.cnt), __ATOMIC_RELEASE)
-#define GF_ATOMIC_GET(op)         __atomic_load (&(op.cnt), __ATOMIC_ACQUIRE)
-#define GF_ATOMIC_INC(op)         __atomic_add_and_fetch (&(op.cnt), 1, \
-                                                          __ATOMIC_ACQ_REL)
-#define GF_ATOMIC_DEC(op)         __atomic_sub_and_fetch (&(op.cnt), 1, \
-                                                          __ATOMIC_ACQ_REL)
-#define GF_ATOMIC_ADD(op, n)      __atomic_add_and_fetch (&(op.cnt), n, \
-                                                          __ATOMIC_ACQ_REL)
-#define GF_ATOMIC_SUB(op, n)      __atomic_sub_and_fetch (&(op.cnt), n, \
-                                                          __ATOMIC_ACQ_REL)
-
-#else /* !HAVE_ATOMIC_BUILTINS, but HAVE_SYNC_BUILTINS */
-
-/* all macros have a 'gf_atomic_t' as 1st argument */
-#define GF_ATOMIC_INIT(op, n)     ({ op.cnt = n; __sync_synchronize (); })
-#define GF_ATOMIC_GET(op)         __sync_add_and_fetch (&(op.cnt), 0)
-#define GF_ATOMIC_INC(op)         __sync_add_and_fetch (&(op.cnt), 1)
-#define GF_ATOMIC_DEC(op)         __sync_sub_and_fetch (&(op.cnt), 1)
-#define GF_ATOMIC_ADD(op, n)      __sync_add_and_fetch (&(op.cnt), n)
-#define GF_ATOMIC_SUB(op, n)      __sync_sub_and_fetch (&(op.cnt), n)
-
-#endif /* HAVE_ATOMIC_BUILTINS || HAVE_SYNC_BUILTINS */
-
-#else /* no HAVE_(ATOMIC|SYNC)_BUILTINS */
-/* fallback implementation, using small inline functions to improve type
- * checking while compiling */
-
-#include "locking.h"
-
-typedef struct gf_atomic_t {
-        int64_t    cnt;
-        gf_lock_t  lk;
-} gf_atomic_t;
-
-
-static inline void
-gf_atomic_init (gf_atomic_t *op, int64_t cnt)
-{
-        LOCK_INIT (&op->lk);
-        op->cnt = cnt;
-}
-
-
-static inline uint64_t
-gf_atomic_get (gf_atomic_t *op)
-{
-        uint64_t ret;
-
-        LOCK (&op->lk);
-        {
-               ret = op->cnt;
-        }
-        UNLOCK (&op->lk);
-
-        return ret;
-}
-
-
-static inline int64_t
-gf_atomic_add (gf_atomic_t *op, int64_t n)
-{
-        uint64_t ret;
-
-        LOCK (&op->lk);
-        {
-                op->cnt += n;
-                ret = op->cnt;
-        }
-        UNLOCK (&op->lk);
-
-        return ret;
-}
-
-
-#define GF_ATOMIC_INIT(op, cnt)   gf_atomic_init (&op, cnt)
-#define GF_ATOMIC_GET(op)         gf_atomic_get (&op)
-#define GF_ATOMIC_INC(op)         gf_atomic_add (&op, 1)
-#define GF_ATOMIC_DEC(op)         gf_atomic_add (&op, -1)
-#define GF_ATOMIC_ADD(op, n)      gf_atomic_add (&op, n)
-#define GF_ATOMIC_SUB(op, n)      gf_atomic_add (&op, -n)
-
-#endif /* HAVE_ATOMIC_SYNC_OPS */
-
-#endif /* _ATOMIC_H */
diff --git a/libglusterfs/src/byte-order.h b/libglusterfs/src/byte-order.h
deleted file mode 100644
index 4101db2c71d..00000000000
--- a/libglusterfs/src/byte-order.h
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _BYTE_ORDER_H
-#define _BYTE_ORDER_H
-
-#include <inttypes.h>
-
-#define LS1 0x00ffU
-#define MS1 0xff00U
-#define LS2 0x0000ffffU
-#define MS2 0xffff0000U
-#define LS4 0x00000000ffffffffULL
-#define MS4 0xffffffff00000000ULL
-
-
-static uint16_t (*hton16) (uint16_t);
-static uint32_t (*hton32) (uint32_t);
-static uint64_t (*hton64) (uint64_t);
-
-#define ntoh16 hton16
-#define ntoh32 hton32
-#define ntoh64 hton64
-
-static uint16_t (*htole16) (uint16_t);
-static uint32_t (*htole32) (uint32_t);
-static uint64_t (*htole64) (uint64_t);
-
-#define letoh16 htole16
-#define letoh32 htole32
-#define letoh64 htole64
-
-static uint16_t (*htobe16) (uint16_t);
-static uint32_t (*htobe32) (uint32_t);
-static uint64_t (*htobe64) (uint64_t);
-
-#define betoh16 htobe16
-#define betoh32 htobe32
-#define betoh64 htobe64
-
-
-#define do_swap2(x) (((x&LS1) << 8)|(((x&MS1) >> 8)))
-#define do_swap4(x) ((do_swap2(x&LS2) << 16)|(do_swap2((x&MS2) >> 16)))
-#define do_swap8(x) ((do_swap4(x&LS4) << 32)|(do_swap4((x&MS4) >> 32)))
-
-
-static inline uint16_t
-__swap16 (uint16_t x)
-{
-	return do_swap2(x);
-}
-
-
-static inline uint32_t
-__swap32 (uint32_t x)
-{
-	return do_swap4(x);
-}
-
-
-static inline uint64_t
-__swap64 (uint64_t x)
-{
-	return do_swap8(x);
-}
-
-
-static inline uint16_t
-__noswap16 (uint16_t x)
-{
-	return x;
-}
-
-
-static inline uint32_t
-__noswap32 (uint32_t x)
-{
-	return x;
-}
-
-
-static inline uint64_t
-__noswap64 (uint64_t x)
-{
-	return x;
-}
-
-
-static inline uint16_t
-__byte_order_n16 (uint16_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		hton16 = __swap16;
-		hton32 = __swap32;
-		hton64 = __swap64;
-	} else {
-                /* cpu is be */
-		hton16 = __noswap16;
-		hton32 = __noswap32;
-		hton64 = __noswap64;
-	}
-
-	return hton16 (i);
-}
-
-
-static inline uint32_t
-__byte_order_n32 (uint32_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		hton16 = __swap16;
-		hton32 = __swap32;
-		hton64 = __swap64;
-	} else {
-                /* cpu is be */
-		hton16 = __noswap16;
-		hton32 = __noswap32;
-		hton64 = __noswap64;
-	}
-
-	return hton32 (i);
-}
-
-
-static inline uint64_t
-__byte_order_n64 (uint64_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		hton16 = __swap16;
-		hton32 = __swap32;
-		hton64 = __swap64;
-	} else {
-                /* cpu is be */
-		hton16 = __noswap16;
-		hton32 = __noswap32;
-		hton64 = __noswap64;
-	}
-
-	return hton64 (i);
-}
-
-
-static uint16_t (*hton16) (uint16_t) = __byte_order_n16;
-static uint32_t (*hton32) (uint32_t) = __byte_order_n32;
-static uint64_t (*hton64) (uint64_t) = __byte_order_n64;
-
-
-static inline uint16_t
-__byte_order_le16 (uint16_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htole16 = __noswap16;
-		htole32 = __noswap32;
-		htole64 = __noswap64;
-	} else {
-                /* cpu is be */
-		htole16 = __swap16;
-		htole32 = __swap32;
-		htole64 = __swap64;
-	}
-
-	return htole16 (i);
-}
-
-
-static inline uint32_t
-__byte_order_le32 (uint32_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htole16 = __noswap16;
-		htole32 = __noswap32;
-		htole64 = __noswap64;
-	} else {
-                /* cpu is be */
-		htole16 = __swap16;
-		htole32 = __swap32;
-		htole64 = __swap64;
-	}
-
-	return htole32 (i);
-}
-
-
-static inline uint64_t
-__byte_order_le64 (uint64_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htole16 = __noswap16;
-		htole32 = __noswap32;
-		htole64 = __noswap64;
-	} else {
-                /* cpu is be */
-		htole16 = __swap16;
-		htole32 = __swap32;
-		htole64 = __swap64;
-	}
-
-	return htole64 (i);
-}
-
-
-static uint16_t (*htole16) (uint16_t) = __byte_order_le16;
-static uint32_t (*htole32) (uint32_t) = __byte_order_le32;
-static uint64_t (*htole64) (uint64_t) = __byte_order_le64;
-
-
-static inline uint16_t
-__byte_order_be16 (uint16_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htobe16 = __swap16;
-		htobe32 = __swap32;
-		htobe64 = __swap64;
-	} else {
-                /* cpu is be */
-		htobe16 = __noswap16;
-		htobe32 = __noswap32;
-		htobe64 = __noswap64;
-	}
-
-	return htobe16 (i);
-}
-
-
-static inline uint32_t
-__byte_order_be32 (uint32_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htobe16 = __swap16;
-		htobe32 = __swap32;
-		htobe64 = __swap64;
-	} else {
-                /* cpu is be */
-		htobe16 = __noswap16;
-		htobe32 = __noswap32;
-		htobe64 = __noswap64;
-	}
-
-	return htobe32 (i);
-}
-
-
-static inline uint64_t
-__byte_order_be64 (uint64_t i)
-{
-	uint32_t num = 1;
-
-	if (((char *)(&num))[0] == 1) {
-                /* cpu is le */
-		htobe16 = __swap16;
-		htobe32 = __swap32;
-		htobe64 = __swap64;
-	} else {
-                /* cpu is be */
-		htobe16 = __noswap16;
-		htobe32 = __noswap32;
-		htobe64 = __noswap64;
-	}
-
-	return htobe64 (i);
-}
-
-
-static uint16_t (*htobe16) (uint16_t) = __byte_order_be16;
-static uint32_t (*htobe32) (uint32_t) = __byte_order_be32;
-static uint64_t (*htobe64) (uint64_t) = __byte_order_be64;
-
-
-
-#endif /* _BYTE_ORDER_H */
diff --git a/libglusterfs/src/call-stub.c b/libglusterfs/src/call-stub.c
index 9aa67aab6c2..ee84f08acd4 100644
--- a/libglusterfs/src/call-stub.c
+++ b/libglusterfs/src/call-stub.c
@@ -11,2581 +11,2457 @@
 #include <openssl/md5.h>
 #include <inttypes.h>
 
-#include "call-stub.h"
-#include "mem-types.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/call-stub.h"
+#include "glusterfs/mem-types.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 static call_stub_t *
-stub_new (call_frame_t *frame,
-          char wind,
-          glusterfs_fop_t fop)
+stub_new(call_frame_t *frame, const char wind, const glusterfs_fop_t fop)
 {
-        call_stub_t *new = NULL;
+    call_stub_t *new = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        new = mem_get0 (frame->this->ctx->stub_mem_pool);
-        GF_VALIDATE_OR_GOTO ("call-stub", new, out);
+    new = mem_get0(frame->this->ctx->stub_mem_pool);
+    GF_VALIDATE_OR_GOTO("call-stub", new, out);
 
-        new->frame = frame;
-        new->wind = wind;
-        new->fop = fop;
-        new->stub_mem_pool = frame->this->ctx->stub_mem_pool;
-        INIT_LIST_HEAD (&new->list);
+    new->frame = frame;
+    new->wind = wind;
+    new->fop = fop;
+    new->stub_mem_pool = frame->this->ctx->stub_mem_pool;
+    INIT_LIST_HEAD(&new->list);
 
-        INIT_LIST_HEAD (&new->args_cbk.entries);
+    INIT_LIST_HEAD(&new->args_cbk.entries);
 out:
-        return new;
+    return new;
 }
 
-
 call_stub_t *
-fop_lookup_stub (call_frame_t *frame, fop_lookup_t fn, loc_t *loc,
-                 dict_t *xdata)
+fop_lookup_stub(call_frame_t *frame, fop_lookup_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LOOKUP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LOOKUP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lookup = fn;
-        args_lookup_store (&stub->args, loc, xdata);
+    stub->fn.lookup = fn;
+    args_lookup_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lookup_cbk_stub (call_frame_t *frame, fop_lookup_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     inode_t *inode, struct iatt *buf,
-                     dict_t *xdata, struct iatt *postparent)
+fop_lookup_cbk_stub(call_frame_t *frame, fop_lookup_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, inode_t *inode, struct iatt *buf,
+                    dict_t *xdata, struct iatt *postparent)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_LOOKUP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LOOKUP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.lookup = fn;
-        args_lookup_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                               buf, xdata, postparent);
+    stub->fn_cbk.lookup = fn;
+    args_lookup_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf, xdata,
+                          postparent);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_stat_stub (call_frame_t *frame, fop_stat_t fn,
-               loc_t *loc, dict_t *xdata)
+fop_stat_stub(call_frame_t *frame, fop_stat_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_STAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_STAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.stat = fn;
-        args_stat_store (&stub->args, loc, xdata);
+    stub->fn.stat = fn;
+    args_stat_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_stat_cbk_stub (call_frame_t *frame, fop_stat_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   struct iatt *buf, dict_t *xdata)
+fop_stat_cbk_stub(call_frame_t *frame, fop_stat_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_STAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_STAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.stat = fn;
-        args_stat_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                             xdata);
+    stub->fn_cbk.stat = fn;
+    args_stat_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fstat_stub (call_frame_t *frame, fop_fstat_t fn,
-                fd_t *fd, dict_t *xdata)
+fop_fstat_stub(call_frame_t *frame, fop_fstat_t fn, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_FSTAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSTAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fstat = fn;
-        args_fstat_store (&stub->args, fd, xdata);
+    stub->fn.fstat = fn;
+    args_fstat_store(&stub->args, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
+call_stub_t *
+fop_fstat_cbk_stub(call_frame_t *frame, fop_fstat_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *buf, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_FSTAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.fstat = fn;
+    args_fstat_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
+out:
+    return stub;
+}
 
 call_stub_t *
-fop_fstat_cbk_stub (call_frame_t *frame, fop_fstat_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *buf, dict_t *xdata)
+fop_truncate_stub(call_frame_t *frame, fop_truncate_t fn, loc_t *loc, off_t off,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSTAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_TRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fstat = fn;
-        args_fstat_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                              xdata);
+    stub->fn.truncate = fn;
+    args_truncate_store(&stub->args, loc, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
+call_stub_t *
+fop_truncate_cbk_stub(call_frame_t *frame, fop_truncate_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_TRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.truncate = fn;
+    args_truncate_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
+out:
+    return stub;
+}
 
 call_stub_t *
-fop_truncate_stub (call_frame_t *frame, fop_truncate_t fn,
-                   loc_t *loc, off_t off, dict_t *xdata)
+fop_ftruncate_stub(call_frame_t *frame, fop_ftruncate_t fn, fd_t *fd, off_t off,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    stub = stub_new(frame, 1, GF_FOP_FTRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_TRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn.ftruncate = fn;
+    args_ftruncate_store(&stub->args, fd, off, xdata);
 
-        stub->fn.truncate = fn;
-        args_truncate_store (&stub->args, loc, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_truncate_cbk_stub (call_frame_t *frame, fop_truncate_cbk_t fn,
+fop_ftruncate_cbk_stub(call_frame_t *frame, fop_ftruncate_cbk_t fn,
                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-		       struct iatt *postbuf, dict_t *xdata)
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FTRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_TRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.ftruncate = fn;
+    args_ftruncate_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                             xdata);
 
-        stub->fn_cbk.truncate = fn;
-        args_truncate_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                 prebuf, postbuf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_ftruncate_stub (call_frame_t *frame, fop_ftruncate_t fn,
-                    fd_t *fd, off_t off, dict_t *xdata)
+fop_access_stub(call_frame_t *frame, fop_access_t fn, loc_t *loc, int32_t mask,
+                dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FTRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn.ftruncate = fn;
-        args_ftruncate_store (&stub->args, fd, off, xdata);
+    stub = stub_new(frame, 1, GF_FOP_ACCESS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
+    stub->fn.access = fn;
+    args_access_store(&stub->args, loc, mask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_ftruncate_cbk_stub (call_frame_t *frame, fop_ftruncate_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-			struct iatt *postbuf, dict_t *xdata)
+fop_access_cbk_stub(call_frame_t *frame, fop_access_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-
-        stub = stub_new (frame, 0, GF_FOP_FTRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    call_stub_t *stub = NULL;
 
-        stub->fn_cbk.ftruncate = fn;
-        args_ftruncate_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                  prebuf, postbuf, xdata);
+    stub = stub_new(frame, 0, GF_FOP_ACCESS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
+    stub->fn_cbk.access = fn;
+    args_access_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_access_stub (call_frame_t *frame, fop_access_t fn,
-                 loc_t *loc, int32_t mask, dict_t *xdata)
+fop_readlink_stub(call_frame_t *frame, fop_readlink_t fn, loc_t *loc,
+                  size_t size, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ACCESS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.access = fn;
-        args_access_store (&stub->args, loc, mask, xdata);
+    stub->fn.readlink = fn;
+    args_readlink_store(&stub->args, loc, size, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_access_cbk_stub (call_frame_t *frame, fop_access_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_readlink_cbk_stub(call_frame_t *frame, fop_readlink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, const char *path,
+                      struct iatt *stbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_READLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ACCESS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.access = fn;
-        args_access_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.readlink = fn;
+    args_readlink_cbk_store(&stub->args_cbk, op_ret, op_errno, path, stbuf,
+                            xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readlink_stub (call_frame_t *frame, fop_readlink_t fn,
-                   loc_t *loc, size_t size, dict_t *xdata)
+fop_mknod_stub(call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
+               dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_READLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_MKNOD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readlink = fn;
-        args_readlink_store (&stub->args, loc, size, xdata);
+    stub->fn.mknod = fn;
+    args_mknod_store(&stub->args, loc, mode, rdev, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readlink_cbk_stub (call_frame_t *frame, fop_readlink_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       const char *path, struct iatt *stbuf, dict_t *xdata)
+fop_mknod_cbk_stub(call_frame_t *frame, fop_mknod_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_MKNOD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_READLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.readlink = fn;
-        args_readlink_cbk_store (&stub->args_cbk, op_ret, op_errno, path,
-                                 stbuf, xdata);
+    stub->fn_cbk.mknod = fn;
+    args_mknod_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                         preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mknod_stub (call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
-                dev_t rdev, mode_t umask, dict_t *xdata)
+fop_mkdir_stub(call_frame_t *frame, fop_mkdir_t fn, loc_t *loc, mode_t mode,
+               mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_MKNOD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_MKDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.mknod = fn;
-        args_mknod_store (&stub->args, loc, mode, rdev, umask, xdata);
+    stub->fn.mkdir = fn;
+    args_mkdir_store(&stub->args, loc, mode, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mknod_cbk_stub (call_frame_t *frame, fop_mknod_cbk_t fn, int32_t op_ret,
-                    int32_t op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-		    dict_t *xdata)
+fop_mkdir_cbk_stub(call_frame_t *frame, fop_mkdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_MKDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_MKNOD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.mknod = fn;
-        args_mknod_cbk_store (&stub->args_cbk, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
+    stub->fn_cbk.mkdir = fn;
+    args_mkdir_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                         preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mkdir_stub (call_frame_t *frame, fop_mkdir_t fn,
-                loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata)
+fop_unlink_stub(call_frame_t *frame, fop_unlink_t fn, loc_t *loc, int xflag,
+                dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_MKDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_UNLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn.unlink = fn;
+    args_unlink_store(&stub->args, loc, xflag, xdata);
 
-        stub->fn.mkdir = fn;
-        args_mkdir_store (&stub->args, loc, mode, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mkdir_cbk_stub (call_frame_t *frame, fop_mkdir_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
+fop_unlink_cbk_stub(call_frame_t *frame, fop_unlink_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *preparent,
                     struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_MKDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_UNLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.mkdir = fn;
-        args_mkdir_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                              buf, preparent, postparent, xdata);
+    stub->fn_cbk.unlink = fn;
+    args_unlink_cbk_store(&stub->args_cbk, op_ret, op_errno, preparent,
+                          postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_unlink_stub (call_frame_t *frame, fop_unlink_t fn,
-                 loc_t *loc, int xflag, dict_t *xdata)
+fop_rmdir_stub(call_frame_t *frame, fop_rmdir_t fn, loc_t *loc, int flags,
+               dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_UNLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RMDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.unlink = fn;
-        args_unlink_store (&stub->args, loc, xflag, xdata);
+    stub->fn.rmdir = fn;
+    args_rmdir_store(&stub->args, loc, flags, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_unlink_cbk_stub (call_frame_t *frame, fop_unlink_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preparent, struct iatt *postparent,
-		     dict_t *xdata)
+fop_rmdir_cbk_stub(call_frame_t *frame, fop_rmdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_UNLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_RMDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.unlink = fn;
-        args_unlink_cbk_store (&stub->args_cbk, op_ret, op_errno, preparent,
-                               postparent, xdata);
+    stub->fn_cbk.rmdir = fn;
+    args_rmdir_cbk_store(&stub->args_cbk, op_ret, op_errno, preparent,
+                         postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
-
 call_stub_t *
-fop_rmdir_stub (call_frame_t *frame, fop_rmdir_t fn,
-                loc_t *loc, int flags, dict_t *xdata)
+fop_symlink_stub(call_frame_t *frame, fop_symlink_t fn, const char *linkname,
+                 loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_RMDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", linkname, out);
 
-        stub->fn.rmdir = fn;
-        args_rmdir_store (&stub->args, loc, flags, xdata);
+    stub = stub_new(frame, 1, GF_FOP_SYMLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
+    stub->fn.symlink = fn;
+    args_symlink_store(&stub->args, linkname, loc, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rmdir_cbk_stub (call_frame_t *frame, fop_rmdir_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preparent, struct iatt *postparent,
-		    dict_t *xdata)
+fop_symlink_cbk_stub(call_frame_t *frame, fop_symlink_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_RMDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SYMLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.rmdir = fn;
-        args_rmdir_cbk_store (&stub->args_cbk, op_ret, op_errno, preparent,
-                              postparent, xdata);
+    stub->fn_cbk.symlink = fn;
+    args_symlink_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                           preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_symlink_stub (call_frame_t *frame, fop_symlink_t fn,
-                  const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata)
+fop_rename_stub(call_frame_t *frame, fop_rename_t fn, loc_t *oldloc,
+                loc_t *newloc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", linkname, out);
+    GF_VALIDATE_OR_GOTO("call-stub", oldloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", newloc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SYMLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RENAME);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.symlink = fn;
-        args_symlink_store (&stub->args, linkname, loc, umask, xdata);
+    stub->fn.rename = fn;
+    args_rename_store(&stub->args, oldloc, newloc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_symlink_cbk_stub (call_frame_t *frame, fop_symlink_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-		      dict_t *xdata)
+fop_rename_cbk_stub(call_frame_t *frame, fop_rename_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *buf,
+                    struct iatt *preoldparent, struct iatt *postoldparent,
+                    struct iatt *prenewparent, struct iatt *postnewparent,
+                    dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_RENAME);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SYMLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.symlink = fn;
-        args_symlink_cbk_store (&stub->args_cbk, op_ret, op_errno, inode, buf,
-                                preparent, postparent, xdata);
+    stub->fn_cbk.rename = fn;
+    args_rename_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, preoldparent,
+                          postoldparent, prenewparent, postnewparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rename_stub (call_frame_t *frame, fop_rename_t fn,
-                 loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+fop_link_stub(call_frame_t *frame, fop_link_t fn, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", newloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", oldloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", newloc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RENAME);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rename = fn;
-        args_rename_store (&stub->args, oldloc, newloc, xdata);
+    stub->fn.link = fn;
+    args_link_store(&stub->args, oldloc, newloc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rename_cbk_stub (call_frame_t *frame, fop_rename_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-		     dict_t *xdata)
+fop_link_cbk_stub(call_frame_t *frame, fop_link_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, inode_t *inode, struct iatt *buf,
+                  struct iatt *preparent, struct iatt *postparent,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_RENAME);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.rename = fn;
-        args_rename_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                               preoldparent, postoldparent, prenewparent,
-                               postnewparent, xdata);
+    stub->fn_cbk.link = fn;
+    args_link_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                        preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_link_stub (call_frame_t *frame, fop_link_t fn,
-               loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+fop_create_stub(call_frame_t *frame, fop_create_t fn, loc_t *loc, int32_t flags,
+                mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", newloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_CREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.link = fn;
-        args_link_store (&stub->args, oldloc, newloc, xdata);
+    stub->fn.create = fn;
+    args_create_store(&stub->args, loc, flags, mode, umask, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_link_cbk_stub (call_frame_t *frame, fop_link_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   inode_t *inode, struct iatt *buf,
-                   struct iatt *preparent, struct iatt *postparent,
-		   dict_t *xdata)
+fop_create_cbk_stub(call_frame_t *frame, fop_create_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, fd_t *fd, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_CREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.link = fn;
-        args_link_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                             inode, buf, preparent, postparent, xdata);
+    stub->fn_cbk.create = fn;
+    args_create_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, inode, buf,
+                          preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_create_stub (call_frame_t *frame, fop_create_t fn,
-                 loc_t *loc, int32_t flags, mode_t mode,
-                 mode_t umask, fd_t *fd, dict_t *xdata)
+fop_open_stub(call_frame_t *frame, fop_open_t fn, loc_t *loc, int32_t flags,
+              fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_CREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_OPEN);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.create = fn;
-        args_create_store (&stub->args, loc, flags, mode,
-                           umask, fd, xdata);
+    stub->fn.open = fn;
+    args_open_store(&stub->args, loc, flags, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_create_cbk_stub (call_frame_t *frame, fop_create_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-		     dict_t *xdata)
+fop_open_cbk_stub(call_frame_t *frame, fop_open_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_OPEN);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_CREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.create = fn;
-        args_create_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, inode,
-                               buf, preparent, postparent, xdata);
+    stub->fn_cbk.open = fn;
+    args_open_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_open_stub (call_frame_t *frame, fop_open_t fn,
-               loc_t *loc, int32_t flags, fd_t *fd, dict_t *xdata)
+fop_readv_stub(call_frame_t *frame, fop_readv_t fn, fd_t *fd, size_t size,
+               off_t off, uint32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    stub = stub_new(frame, 1, GF_FOP_READ);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_OPEN);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn.open = fn;
-        args_open_store (&stub->args, loc, flags, fd, xdata);
+    stub->fn.readv = fn;
+    args_readv_store(&stub->args, fd, size, off, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_open_cbk_stub (call_frame_t *frame, fop_open_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   fd_t *fd, dict_t *xdata)
+fop_readv_cbk_stub(call_frame_t *frame, fop_readv_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iovec *vector, int32_t count,
+                   struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_READ);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_OPEN);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.open = fn;
-        args_open_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, xdata);
+    stub->fn_cbk.readv = fn;
+    args_readv_cbk_store(&stub->args_cbk, op_ret, op_errno, vector, count,
+                         stbuf, iobref, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readv_stub (call_frame_t *frame, fop_readv_t fn,
-                fd_t *fd, size_t size, off_t off, uint32_t flags,
-		dict_t *xdata)
+fop_writev_stub(call_frame_t *frame, fop_writev_t fn, fd_t *fd,
+                struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+                struct iobref *iobref, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", vector, out);
 
-        stub = stub_new (frame, 1, GF_FOP_READ);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_WRITE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readv = fn;
-        args_readv_store (&stub->args, fd, size, off, flags, xdata);
+    stub->fn.writev = fn;
+    args_writev_store(&stub->args, fd, vector, count, off, flags, iobref,
+                      xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readv_cbk_stub (call_frame_t *frame, fop_readv_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-		    int32_t count, struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata)
+fop_writev_cbk_stub(call_frame_t *frame, fop_writev_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                    dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_READ);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_WRITE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readv = fn;
-        args_readv_cbk_store (&stub->args_cbk, op_ret, op_errno, vector,
-                              count, stbuf, iobref, xdata);
+    stub->fn_cbk.writev = fn;
+    args_writev_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                          xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_writev_stub (call_frame_t *frame, fop_writev_t fn,
-                 fd_t *fd, struct iovec *vector, int32_t count, off_t off,
-		 uint32_t flags, struct iobref *iobref, dict_t *xdata)
+fop_flush_stub(call_frame_t *frame, fop_flush_t fn, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", vector, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_WRITE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FLUSH);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.writev = fn;
-        args_writev_store (&stub->args, fd, vector, count, off, flags,
-                           iobref, xdata);
+    stub->fn.flush = fn;
+    args_flush_store(&stub->args, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_writev_cbk_stub (call_frame_t *frame, fop_writev_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+fop_flush_cbk_stub(call_frame_t *frame, fop_flush_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_WRITE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FLUSH);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.writev = fn;
-        args_writev_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                               prebuf, postbuf, xdata);
+    stub->fn_cbk.flush = fn;
+    args_flush_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_flush_stub (call_frame_t *frame, fop_flush_t fn,
-                fd_t *fd, dict_t *xdata)
+fop_fsync_stub(call_frame_t *frame, fop_fsync_t fn, fd_t *fd, int32_t datasync,
+               dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_FSYNC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FLUSH);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn.flush = fn;
-        args_flush_store (&stub->args, fd, xdata);
+    stub->fn.fsync = fn;
+    args_fsync_store(&stub->args, fd, datasync, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_flush_cbk_stub (call_frame_t *frame, fop_flush_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fsync_cbk_stub(call_frame_t *frame, fop_fsync_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FLUSH);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSYNC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.flush = fn;
-        args_flush_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fsync = fn;
+    args_fsync_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                         xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsync_stub (call_frame_t *frame, fop_fsync_t fn,
-                fd_t *fd, int32_t datasync, dict_t *xdata)
+fop_opendir_stub(call_frame_t *frame, fop_opendir_t fn, loc_t *loc, fd_t *fd,
+                 dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSYNC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_OPENDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsync = fn;
-        args_fsync_store (&stub->args, fd, datasync, xdata);
+    stub->fn.opendir = fn;
+    args_opendir_store(&stub->args, loc, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsync_cbk_stub (call_frame_t *frame, fop_fsync_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+fop_opendir_cbk_stub(call_frame_t *frame, fop_opendir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FSYNC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_OPENDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsync = fn;
-        args_fsync_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                              prebuf, postbuf, xdata);
+    stub->fn_cbk.opendir = fn;
+    args_opendir_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_opendir_stub (call_frame_t *frame, fop_opendir_t fn,
-                  loc_t *loc, fd_t *fd, dict_t *xdata)
+fop_fsyncdir_stub(call_frame_t *frame, fop_fsyncdir_t fn, fd_t *fd,
+                  int32_t datasync, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_OPENDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSYNCDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.opendir = fn;
-        args_opendir_store (&stub->args, loc, fd, xdata);
+    stub->fn.fsyncdir = fn;
+    args_fsyncdir_store(&stub->args, fd, datasync, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_opendir_cbk_stub (call_frame_t *frame, fop_opendir_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      fd_t *fd, dict_t *xdata)
+fop_fsyncdir_cbk_stub(call_frame_t *frame, fop_fsyncdir_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_FSYNCDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_OPENDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.opendir = fn;
-        args_opendir_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, xdata);
+    stub->fn_cbk.fsyncdir = fn;
+    args_fsyncdir_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsyncdir_stub (call_frame_t *frame, fop_fsyncdir_t fn,
-                   fd_t *fd, int32_t datasync, dict_t *xdata)
+fop_statfs_stub(call_frame_t *frame, fop_statfs_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSYNCDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_STATFS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsyncdir = fn;
-        args_fsyncdir_store (&stub->args, fd, datasync, xdata);
+    stub->fn.statfs = fn;
+    args_statfs_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsyncdir_cbk_stub (call_frame_t *frame, fop_fsyncdir_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_statfs_cbk_stub(call_frame_t *frame, fop_statfs_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FSYNCDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_STATFS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsyncdir = fn;
-        args_fsyncdir_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.statfs = fn;
+    args_statfs_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_statfs_stub (call_frame_t *frame, fop_statfs_t fn,
-                 loc_t *loc, dict_t *xdata)
+fop_setxattr_stub(call_frame_t *frame, fop_setxattr_t fn, loc_t *loc,
+                  dict_t *dict, int32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_STATFS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.statfs = fn;
-        args_statfs_store (&stub->args, loc, xdata);
+    stub->fn.setxattr = fn;
+    args_setxattr_store(&stub->args, loc, dict, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_statfs_cbk_stub (call_frame_t *frame, fop_statfs_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct statvfs *buf, dict_t *xdata)
+fop_setxattr_cbk_stub(call_frame_t *frame, fop_setxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_STATFS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.statfs = fn;
-        args_statfs_cbk_store (&stub->args_cbk, op_ret, op_errno, buf, xdata);
+    stub->fn_cbk.setxattr = fn;
+    args_setxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setxattr_stub (call_frame_t *frame, fop_setxattr_t fn,
-                   loc_t *loc, dict_t *dict,
-                   int32_t flags, dict_t *xdata)
+fop_getxattr_stub(call_frame_t *frame, fop_getxattr_t fn, loc_t *loc,
+                  const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.setxattr = fn;
-        args_setxattr_store (&stub->args, loc, dict, flags, xdata);
+    stub->fn.getxattr = fn;
+    args_getxattr_store(&stub->args, loc, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setxattr_cbk_stub (call_frame_t *frame,
-                       fop_setxattr_cbk_t fn,
-                       int32_t op_ret,
-                       int32_t op_errno, dict_t *xdata)
+fop_getxattr_cbk_stub(call_frame_t *frame, fop_getxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_SETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.setxattr = fn;
-        args_setxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.getxattr = fn;
+    args_getxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, dict, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getxattr_stub (call_frame_t *frame, fop_getxattr_t fn,
-                   loc_t *loc, const char *name, dict_t *xdata)
+fop_fsetxattr_stub(call_frame_t *frame, fop_fsetxattr_t fn, fd_t *fd,
+                   dict_t *dict, int32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.getxattr = fn;
-        args_getxattr_store (&stub->args, loc, name, xdata);
+    stub->fn.fsetxattr = fn;
+    args_fsetxattr_store(&stub->args, fd, dict, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getxattr_cbk_stub (call_frame_t *frame, fop_getxattr_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata)
+fop_fsetxattr_cbk_stub(call_frame_t *frame, fop_fsetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.getxattr = fn;
-        args_getxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, dict,
-                                 xdata);
+    stub->fn_cbk.fsetxattr = fn;
+    args_fsetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetxattr_stub (call_frame_t *frame, fop_fsetxattr_t fn,
-                    fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+fop_fgetxattr_stub(call_frame_t *frame, fop_fgetxattr_t fn, fd_t *fd,
+                   const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FGETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetxattr = fn;
-        args_fsetxattr_store (&stub->args, fd, dict, flags, xdata);
+    stub->fn.fgetxattr = fn;
+    args_fgetxattr_store(&stub->args, fd, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetxattr_cbk_stub (call_frame_t *frame, fop_fsetxattr_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fgetxattr_cbk_stub(call_frame_t *frame, fop_fgetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.fsetxattr = fn;
-        args_fsetxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fgetxattr = fn;
+    args_fgetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, dict, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fgetxattr_stub (call_frame_t *frame, fop_fgetxattr_t fn,
-                    fd_t *fd, const char *name, dict_t *xdata)
+fop_removexattr_stub(call_frame_t *frame, fop_removexattr_t fn, loc_t *loc,
+                     const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", name, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FGETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_REMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fgetxattr = fn;
-        args_fgetxattr_store (&stub->args, fd, name, xdata);
+    stub->fn.removexattr = fn;
+    args_removexattr_store(&stub->args, loc, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fgetxattr_cbk_stub (call_frame_t *frame, fop_fgetxattr_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+fop_removexattr_cbk_stub(call_frame_t *frame, fop_removexattr_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_REMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.fgetxattr = fn;
-        args_fgetxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, dict,
-                                  xdata);
+    stub->fn_cbk.removexattr = fn;
+    args_removexattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_removexattr_stub (call_frame_t *frame, fop_removexattr_t fn,
-                      loc_t *loc, const char *name, dict_t *xdata)
+fop_fremovexattr_stub(call_frame_t *frame, fop_fremovexattr_t fn, fd_t *fd,
+                      const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", name, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", name, out);
 
-        stub = stub_new (frame, 1, GF_FOP_REMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FREMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.removexattr = fn;
-        args_removexattr_store (&stub->args, loc, name, xdata);
+    stub->fn.fremovexattr = fn;
+    args_fremovexattr_store(&stub->args, fd, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_removexattr_cbk_stub (call_frame_t *frame, fop_removexattr_cbk_t fn,
+fop_fremovexattr_cbk_stub(call_frame_t *frame, fop_fremovexattr_cbk_t fn,
                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_REMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FREMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.removexattr = fn;
-        args_removexattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fremovexattr = fn;
+    args_fremovexattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fremovexattr_stub (call_frame_t *frame, fop_fremovexattr_t fn,
-                       fd_t *fd, const char *name, dict_t *xdata)
+fop_lk_stub(call_frame_t *frame, fop_lk_t fn, fd_t *fd, int32_t cmd,
+            struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", name, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FREMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fremovexattr = fn;
-        args_fremovexattr_store (&stub->args, fd, name, xdata);
+    stub->fn.lk = fn;
+    args_lk_store(&stub->args, fd, cmd, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fremovexattr_cbk_stub (call_frame_t *frame, fop_fremovexattr_cbk_t fn,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_lk_cbk_stub(call_frame_t *frame, fop_lk_cbk_t fn, int32_t op_ret,
+                int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_LK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FREMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.fremovexattr = fn;
-        args_fremovexattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.lk = fn;
+    args_lk_cbk_store(&stub->args_cbk, op_ret, op_errno, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lk_stub (call_frame_t *frame, fop_lk_t fn,
-             fd_t *fd, int32_t cmd,
-             struct gf_flock *lock, dict_t *xdata)
+fop_inodelk_stub(call_frame_t *frame, fop_inodelk_t fn, const char *volume,
+                 loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_INODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lk = fn;
-        args_lk_store (&stub->args, fd, cmd, lock, xdata);
+    stub->fn.inodelk = fn;
+    args_inodelk_store(&stub->args, volume, loc, cmd, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lk_cbk_stub (call_frame_t *frame, fop_lk_cbk_t fn,
-                 int32_t op_ret, int32_t op_errno,
-                 struct gf_flock *lock, dict_t *xdata)
+fop_inodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_LK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_INODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.lk = fn;
-        args_lk_cbk_store (&stub->args_cbk, op_ret, op_errno, lock, xdata);
+    stub->fn_cbk.inodelk = fn;
+    args_inodelk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_inodelk_stub (call_frame_t *frame, fop_inodelk_t fn,
-                  const char *volume, loc_t *loc, int32_t cmd,
-                  struct gf_flock *lock, dict_t *xdata)
+fop_finodelk_stub(call_frame_t *frame, fop_finodelk_t fn, const char *volume,
+                  fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
+
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    stub = stub_new(frame, 1, GF_FOP_FINODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_INODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn.finodelk = fn;
+    args_finodelk_store(&stub->args, volume, fd, cmd, lock, xdata);
 
-        stub->fn.inodelk = fn;
-        args_inodelk_store (&stub->args, volume, loc, cmd,
-                            lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
+call_stub_t *
+fop_finodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_FINODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.finodelk = fn;
+    args_finodelk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
+out:
+    return stub;
+}
 
 call_stub_t *
-fop_inodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_entrylk_stub(call_frame_t *frame, fop_entrylk_t fn, const char *volume,
+                 loc_t *loc, const char *name, entrylk_cmd cmd,
+                 entrylk_type type, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_ENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_INODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn.entrylk = fn;
+    args_entrylk_store(&stub->args, volume, loc, name, cmd, type, xdata);
 
-        stub->fn_cbk.inodelk       = fn;
-        args_inodelk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_finodelk_stub (call_frame_t *frame, fop_finodelk_t fn,
-                   const char *volume, fd_t *fd, int32_t cmd,
-                   struct gf_flock *lock, dict_t *xdata)
+fop_entrylk_cbk_stub(call_frame_t *frame, fop_entrylk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    stub = stub_new(frame, 0, GF_FOP_ENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FINODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.entrylk = fn;
+    args_entrylk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
+out:
+    return stub;
+}
 
-        stub->fn.finodelk = fn;
-        args_finodelk_store (&stub->args, volume, fd, cmd,
-                             lock, xdata);
+call_stub_t *
+fop_fentrylk_stub(call_frame_t *frame, fop_fentrylk_t fn, const char *volume,
+                  fd_t *fd, const char *name, entrylk_cmd cmd,
+                  entrylk_type type, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 1, GF_FOP_FENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
+    stub->fn.fentrylk = fn;
+    args_fentrylk_store(&stub->args, volume, fd, name, cmd, type, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_finodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fentrylk_cbk_stub(call_frame_t *frame, fop_fentrylk_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FINODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.finodelk       = fn;
-        args_finodelk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fentrylk = fn;
+    args_fentrylk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_entrylk_stub (call_frame_t *frame, fop_entrylk_t fn,
-                  const char *volume, loc_t *loc, const char *name,
-                  entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+fop_readdirp_cbk_stub(call_frame_t *frame, fop_readdirp_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_READDIRP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.readdirp = fn;
+    args_readdirp_cbk_store(&stub->args_cbk, op_ret, op_errno, entries, xdata);
+out:
+    return stub;
+}
+
+call_stub_t *
+fop_readdir_cbk_stub(call_frame_t *frame, fop_readdir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
 
-        stub->fn.entrylk = fn;
-        args_entrylk_store (&stub->args, volume, loc, name, cmd, type, xdata);
+    stub = stub_new(frame, 0, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
+    stub->fn_cbk.readdir = fn;
+    args_readdir_cbk_store(&stub->args_cbk, op_ret, op_errno, entries, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_entrylk_cbk_stub (call_frame_t *frame, fop_entrylk_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_readdir_stub(call_frame_t *frame, fop_readdir_t fn, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.entrylk       = fn;
-        args_entrylk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn.readdir = fn;
+    args_readdir_store(&stub->args, fd, size, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fentrylk_stub (call_frame_t *frame, fop_fentrylk_t fn,
-                   const char *volume, fd_t *fd, const char *name,
-                   entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+fop_readdirp_stub(call_frame_t *frame, fop_readdirp_t fn, fd_t *fd, size_t size,
+                  off_t off, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_FENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READDIRP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fentrylk = fn;
-        args_fentrylk_store (&stub->args, volume, fd, name, cmd, type, xdata);
+    stub->fn.readdirp = fn;
+    args_readdirp_store(&stub->args, fd, size, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fentrylk_cbk_stub (call_frame_t *frame, fop_fentrylk_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_rchecksum_stub(call_frame_t *frame, fop_rchecksum_t fn, fd_t *fd,
+                   off_t offset, int32_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RCHECKSUM);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fentrylk       = fn;
-        args_fentrylk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn.rchecksum = fn;
+    args_rchecksum_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdirp_cbk_stub (call_frame_t *frame, fop_readdirp_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata)
+fop_rchecksum_cbk_stub(call_frame_t *frame, fop_rchecksum_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                       uint8_t *strong_checksum, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_READDIRP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_RCHECKSUM);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readdirp = fn;
-        args_readdirp_cbk_store (&stub->args_cbk, op_ret, op_errno, entries,
-                                 xdata);
+    stub->fn_cbk.rchecksum = fn;
+    args_rchecksum_cbk_store(&stub->args_cbk, op_ret, op_errno, weak_checksum,
+                             strong_checksum, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdir_cbk_stub (call_frame_t *frame, fop_readdir_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      gf_dirent_t *entries, dict_t *xdata)
+fop_xattrop_cbk_stub(call_frame_t *frame, fop_xattrop_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_READDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_XATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readdir = fn;
-        args_readdir_cbk_store (&stub->args_cbk, op_ret, op_errno, entries,
-                                xdata);
+    stub->fn_cbk.xattrop = fn;
+    args_xattrop_cbk_store(&stub->args_cbk, op_ret, op_errno, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdir_stub (call_frame_t *frame, fop_readdir_t fn,
-                  fd_t *fd, size_t size,
-                  off_t off, dict_t *xdata)
+fop_fxattrop_cbk_stub(call_frame_t *frame, fop_fxattrop_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_READDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FXATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readdir = fn;
-        args_readdir_store (&stub->args, fd, size, off, xdata);
+    stub->fn_cbk.fxattrop = fn;
+    args_xattrop_cbk_store(&stub->args_cbk, op_ret, op_errno, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdirp_stub (call_frame_t *frame, fop_readdirp_t fn,
-                   fd_t *fd, size_t size, off_t off, dict_t *xdata)
+fop_xattrop_stub(call_frame_t *frame, fop_xattrop_t fn, loc_t *loc,
+                 gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
+
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_READDIRP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_XATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readdirp = fn;
-        args_readdirp_store (&stub->args, fd, size, off, xdata);
+    stub->fn.xattrop = fn;
+    args_xattrop_store(&stub->args, loc, optype, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rchecksum_stub (call_frame_t *frame, fop_rchecksum_t fn,
-                    fd_t *fd, off_t offset, int32_t len, dict_t *xdata)
+fop_fxattrop_stub(call_frame_t *frame, fop_fxattrop_t fn, fd_t *fd,
+                  gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RCHECKSUM);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FXATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rchecksum = fn;
-        args_rchecksum_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.fxattrop = fn;
+    args_fxattrop_store(&stub->args, fd, optype, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rchecksum_cbk_stub (call_frame_t *frame, fop_rchecksum_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno,
-                        uint32_t weak_checksum, uint8_t *strong_checksum,
-			dict_t *xdata)
+fop_setattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_SETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_RCHECKSUM);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
-
-        stub->fn_cbk.rchecksum = fn;
-        args_rchecksum_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                  weak_checksum, strong_checksum, xdata);
+    stub->fn_cbk.setattr = fn;
+    args_setattr_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre, statpost,
+                           xdata);
 out:
-        return stub;
+    return stub;
 }
 
+call_stub_t *
+fop_fsetattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.fsetattr = fn;
+    args_fsetattr_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, xdata);
+out:
+    return stub;
+}
 
 call_stub_t *
-fop_xattrop_cbk_stub (call_frame_t *frame, fop_xattrop_cbk_t fn, int32_t op_ret,
-                      int32_t op_errno, dict_t *xattr, dict_t *xdata)
+fop_setattr_stub(call_frame_t *frame, fop_setattr_t fn, loc_t *loc,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_XATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.xattrop       = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                xdata);
+    stub->fn.setattr = fn;
+    args_setattr_store(&stub->args, loc, stbuf, valid, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fxattrop_cbk_stub (call_frame_t *frame, fop_fxattrop_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+fop_fsetattr_stub(call_frame_t *frame, fop_fsetattr_t fn, fd_t *fd,
+                  struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FXATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub->fn_cbk.fxattrop = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                xdata);
+    stub = stub_new(frame, 1, GF_FOP_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn.fsetattr = fn;
+    args_fsetattr_store(&stub->args, fd, stbuf, valid, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_xattrop_stub (call_frame_t *frame, fop_xattrop_t fn,
-                  loc_t *loc, gf_xattrop_flags_t optype,
-                  dict_t *xattr, dict_t *xdata)
+fop_fallocate_cbk_stub(call_frame_t *frame, fop_fallocate_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", xattr, out);
+    stub = stub_new(frame, 0, GF_FOP_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_XATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.fallocate = fn;
 
-        stub->fn.xattrop = fn;
-        args_xattrop_store (&stub->args, loc, optype, xattr, xdata);
+    args_fallocate_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                             statpost, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fxattrop_stub (call_frame_t *frame, fop_fxattrop_t fn,
-                   fd_t *fd, gf_xattrop_flags_t optype,
-                   dict_t *xattr, dict_t *xdata)
+fop_fallocate_stub(call_frame_t *frame, fop_fallocate_t fn, fd_t *fd,
+                   int32_t mode, off_t offset, size_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", xattr, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FXATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fxattrop = fn;
-        args_fxattrop_store (&stub->args, fd, optype, xattr, xdata);
+    stub->fn.fallocate = fn;
+    args_fallocate_store(&stub->args, fd, mode, offset, len, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setattr_cbk_stub (call_frame_t *frame, fop_setattr_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt *statpre, struct iatt *statpost,
-		      dict_t *xdata)
+fop_discard_cbk_stub(call_frame_t *frame, fop_discard_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 0, GF_FOP_DISCARD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.discard = fn;
 
-        stub->fn_cbk.setattr = fn;
-        args_setattr_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                statpost, xdata);
+    args_discard_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre, statpost,
+                           xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetattr_cbk_stub (call_frame_t *frame, fop_setattr_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-		       dict_t *xdata)
+fop_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd, off_t offset,
+                 size_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_DISCARD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsetattr = fn;
-        args_fsetattr_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                 statpost, xdata);
+    stub->fn.discard = fn;
+    args_discard_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setattr_stub (call_frame_t *frame, fop_setattr_t fn,
-                  loc_t *loc, struct iatt *stbuf,
-                  int32_t valid, dict_t *xdata)
+fop_zerofill_cbk_stub(call_frame_t *frame, fop_zerofill_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    stub = stub_new(frame, 0, GF_FOP_ZEROFILL);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.zerofill = fn;
 
-        stub->fn.setattr = fn;
-        args_setattr_store (&stub->args, loc, stbuf, valid, xdata);
+    args_zerofill_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetattr_stub (call_frame_t *frame, fop_fsetattr_t fn,
-                   fd_t *fd, struct iatt *stbuf,
-                   int32_t valid, dict_t *xdata)
+fop_zerofill_stub(call_frame_t *frame, fop_zerofill_t fn, fd_t *fd,
+                  off_t offset, off_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_ZEROFILL);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetattr = fn;
-        args_fsetattr_store (&stub->args, fd, stbuf, valid, xdata);
+    stub->fn.zerofill = fn;
+    args_zerofill_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_fallocate_cbk_stub(call_frame_t *frame, fop_fallocate_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-		       dict_t *xdata)
+fop_ipc_cbk_stub(call_frame_t *frame, fop_ipc_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_FALLOCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_IPC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fallocate = fn;
+    stub->fn_cbk.ipc = fn;
 
-        args_fallocate_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                  statpost, xdata);
+    args_ipc_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_fallocate_stub(call_frame_t *frame, fop_fallocate_t fn, fd_t *fd,
-		   int32_t mode, off_t offset, size_t len, dict_t *xdata)
+fop_ipc_stub(call_frame_t *frame, fop_ipc_t fn, int32_t op, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FALLOCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_IPC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fallocate = fn;
-        args_fallocate_store (&stub->args, fd, mode, offset, len, xdata);
+    stub->fn.ipc = fn;
+    args_ipc_store(&stub->args, op, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_discard_cbk_stub(call_frame_t *frame, fop_discard_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-		     dict_t *xdata)
+fop_lease_cbk_stub(call_frame_t *frame, fop_lease_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_LEASE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.lease = fn;
+    args_lease_cbk_store(&stub->args_cbk, op_ret, op_errno, lease, xdata);
+out:
+    return stub;
+}
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+call_stub_t *
+fop_lease_stub(call_frame_t *frame, fop_lease_t fn, loc_t *loc,
+               struct gf_lease *lease, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 0, GF_FOP_DISCARD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lease, out);
 
-        stub->fn_cbk.discard = fn;
+    stub = stub_new(frame, 1, GF_FOP_LEASE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        args_discard_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                statpost, xdata);
+    stub->fn.lease = fn;
+    args_lease_store(&stub->args, loc, lease, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd,
-		 off_t offset, size_t len, dict_t *xdata)
+fop_seek_cbk_stub(call_frame_t *frame, fop_seek_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, off_t offset, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    stub = stub_new(frame, 0, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_DISCARD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.seek = fn;
 
-        stub->fn.discard = fn;
-        args_discard_store (&stub->args, fd, offset, len, xdata);
+    args_seek_cbk_store(&stub->args_cbk, op_ret, op_errno, offset, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_zerofill_cbk_stub(call_frame_t *frame, fop_zerofill_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+fop_seek_stub(call_frame_t *frame, fop_seek_t fn, fd_t *fd, off_t offset,
+              gf_seek_what_t what, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ZEROFILL);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.zerofill = fn;
-
-        args_zerofill_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                 statpost, xdata);
+    stub->fn.seek = fn;
+    args_seek_store(&stub->args, fd, offset, what, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_zerofill_stub(call_frame_t *frame, fop_zerofill_t fn, fd_t *fd,
-                 off_t offset, off_t len, dict_t *xdata)
+fop_getactivelk_cbk_stub(call_frame_t *frame, fop_getactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno,
+                         lock_migration_info_t *lmi, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    stub = stub_new(frame, 0, GF_FOP_GETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ZEROFILL);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.getactivelk = fn;
 
-        stub->fn.zerofill = fn;
-        args_zerofill_store (&stub->args, fd, offset, len, xdata);
+    args_getactivelk_cbk_store(&stub->args_cbk, op_ret, op_errno, lmi, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
-
 call_stub_t *
-fop_ipc_cbk_stub (call_frame_t *frame, fop_ipc_cbk_t fn,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_getactivelk_stub(call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
+
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_GETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_IPC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn.getactivelk = fn;
 
-        stub->fn_cbk.ipc = fn;
+    loc_copy(&stub->args.loc, loc);
 
-        args_ipc_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_ipc_stub (call_frame_t *frame, fop_ipc_t fn,
-              int32_t op, dict_t *xdata)
+fop_setactivelk_cbk_stub(call_frame_t *frame, fop_setactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    stub = stub_new(frame, 0, GF_FOP_SETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 1, GF_FOP_IPC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn_cbk.setactivelk = fn;
+    stub->args_cbk.op_ret = op_ret;
+    stub->args_cbk.op_errno = op_errno;
 
-        stub->fn.ipc = fn;
-        args_ipc_store (&stub->args, op, xdata);
-out:
-        return stub;
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
+out:
+    return stub;
 }
 
 call_stub_t *
-fop_lease_cbk_stub (call_frame_t *frame, fop_lease_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct gf_lease *lease, dict_t *xdata)
+fop_setactivelk_stub(call_frame_t *frame, fop_setactivelk_t fn, loc_t *loc,
+                     lock_migration_info_t *locklist, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn.setactivelk = fn;
+
+    args_setactivelk_store(&stub->args, loc, locklist, xdata);
 
-        stub->fn_cbk.lease = fn;
-        args_lease_cbk_store (&stub->args_cbk, op_ret, op_errno, lease, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_lease_stub (call_frame_t *frame, fop_lease_t fn,
-                loc_t *loc, struct gf_lease *lease, dict_t *xdata)
+fop_copy_file_range_stub(call_frame_t *frame, fop_copy_file_range_t fn,
+                         fd_t *fd_in, off64_t off_in, fd_t *fd_out,
+                         off64_t off_out, size_t len, uint32_t flags,
+                         dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lease, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_COPY_FILE_RANGE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lease = fn;
-        args_lease_store (&stub->args, loc, lease, xdata);
-out:
-        return stub;
+    stub->fn.copy_file_range = fn;
+
+    args_copy_file_range_store(&stub->args, fd_in, off_in, fd_out, off_out, len,
+                               flags, xdata);
 
+out:
+    return stub;
 }
 
 call_stub_t *
-fop_seek_cbk_stub (call_frame_t *frame, fop_seek_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno, off_t offset,
-                   dict_t *xdata)
+fop_copy_file_range_cbk_stub(call_frame_t *frame, fop_copy_file_range_cbk_t fn,
+                             int32_t op_ret, int32_t op_errno,
+                             struct iatt *stbuf, struct iatt *prebuf_dst,
+                             struct iatt *postbuf_dst, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_COPY_FILE_RANGE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.seek = fn;
+    stub->fn_cbk.copy_file_range = fn;
+    args_copy_file_range_cbk_store(&stub->args_cbk, op_ret, op_errno, stbuf,
+                                   prebuf_dst, postbuf_dst, xdata);
 
-        args_seek_cbk_store (&stub->args_cbk, op_ret, op_errno, offset, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_seek_stub (call_frame_t *frame, fop_seek_t fn, fd_t *fd,
-               off_t offset, gf_seek_what_t what, dict_t *xdata)
+fop_put_stub(call_frame_t *frame, fop_put_t fn, loc_t *loc, mode_t mode,
+             mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+             off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", vector, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_PUT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.seek = fn;
-        args_seek_store (&stub->args, fd, offset, what, xdata);
+    stub->fn.put = fn;
+    args_put_store(&stub->args, loc, mode, umask, flags, vector, count, offset,
+                   iobref, xattr, xdata);
 out:
-        return stub;
+    return stub;
+}
 
+call_stub_t *
+fop_put_cbk_stub(call_frame_t *frame, fop_put_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, inode_t *inode, struct iatt *buf,
+                 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
+
+    stub = stub_new(frame, 0, GF_FOP_PUT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
+
+    stub->fn_cbk.put = fn;
+    args_put_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf, preparent,
+                       postparent, xdata);
+out:
+    return stub;
 }
 
 call_stub_t *
-fop_getactivelk_cbk_stub (call_frame_t *frame, fop_getactivelk_cbk_t fn,
-                          int32_t op_ret, int32_t op_errno,
-                          lock_migration_info_t *lmi, dict_t *xdata)
+fop_icreate_stub(call_frame_t *frame, fop_icreate_t fn, loc_t *loc, mode_t mode,
+                 dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
+
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    stub = stub_new(frame, 1, GF_FOP_ICREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub = stub_new (frame, 0, GF_FOP_GETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub->fn.icreate = fn;
 
-        stub->fn_cbk.getactivelk = fn;
+    stub->args.mode = mode;
+    if (loc)
+        loc_copy(&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
-        args_getactivelk_cbk_store (&stub->args_cbk, op_ret, op_errno, lmi,
-                                    xdata);
 out:
-        return stub;
+    return stub;
 }
 
+static void
+args_icreate_store_cbk(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, inode_t *inode, struct iatt *buf,
+                       dict_t *xdata)
+{
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+}
 
 call_stub_t *
-fop_getactivelk_stub (call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
-                      dict_t *xdata)
+fop_icreate_cbk_stub(call_frame_t *frame, fop_icreate_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_GETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_ICREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.getactivelk = fn;
+    stub->fn_cbk.icreate = fn;
+    args_icreate_store_cbk(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                           xdata);
 
-        loc_copy (&stub->args.loc, loc);
-
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_setactivelk_cbk_stub (call_frame_t *frame, fop_setactivelk_cbk_t fn,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_namelink_stub(call_frame_t *frame, fop_namelink_t fn, loc_t *loc,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_NAMELINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.setactivelk = fn;
-        stub->args_cbk.op_ret = op_ret;
-        stub->args_cbk.op_errno = op_errno;
+    stub->fn.namelink = fn;
 
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    if (loc)
+        loc_copy(&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-call_stub_t *
-fop_setactivelk_stub (call_frame_t *frame, fop_setactivelk_t fn,
-                        loc_t *loc, lock_migration_info_t *locklist,
-                        dict_t *xdata)
+static void
+args_namelink_store_cbk(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+}
 
-        stub = stub_new (frame, 1, GF_FOP_SETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+call_stub_t *
+fop_namelink_cbk_stub(call_frame_t *frame, fop_namelink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
+{
+    call_stub_t *stub = NULL;
 
-        stub->fn.setactivelk = fn;
+    stub = stub_new(frame, 0, GF_FOP_NAMELINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        args_setactivelk_store (&stub->args, loc, locklist, xdata);
+    stub->fn_cbk.namelink = fn;
+    args_namelink_store_cbk(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
 
 out:
-        return stub;
-
+    return stub;
 }
 
 void
-call_resume_wind (call_stub_t *stub)
+call_resume_wind(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        switch (stub->fop) {
+    switch (stub->fop) {
         case GF_FOP_OPEN:
-                stub->fn.open (stub->frame, stub->frame->this,
-			       &stub->args.loc, stub->args.flags,
-			       stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.open(stub->frame, stub->frame->this, &stub->args.loc,
+                          stub->args.flags, stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_CREATE:
-                stub->fn.create (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.flags,
-				 stub->args.mode, stub->args.umask,
-				 stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.create(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.flags, stub->args.mode, stub->args.umask,
+                            stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_STAT:
-                stub->fn.stat (stub->frame, stub->frame->this,
-			       &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.stat(stub->frame, stub->frame->this, &stub->args.loc,
+                          stub->args.xdata);
+            break;
         case GF_FOP_READLINK:
-                stub->fn.readlink (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.size,
-				   stub->args.xdata);
-                break;
+            stub->fn.readlink(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.size, stub->args.xdata);
+            break;
         case GF_FOP_MKNOD:
-                stub->fn.mknod (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.mode,
-				stub->args.rdev, stub->args.umask,
-				stub->args.xdata);
-		break;
+            stub->fn.mknod(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.mode, stub->args.rdev, stub->args.umask,
+                           stub->args.xdata);
+            break;
         case GF_FOP_MKDIR:
-                stub->fn.mkdir (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.mode,
-				stub->args.umask, stub->args.xdata);
-		break;
+            stub->fn.mkdir(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.mode, stub->args.umask, stub->args.xdata);
+            break;
         case GF_FOP_UNLINK:
-                stub->fn.unlink (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xflag,
-				 stub->args.xdata);
-		break;
+            stub->fn.unlink(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xflag, stub->args.xdata);
+            break;
         case GF_FOP_RMDIR:
-                stub->fn.rmdir (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.flags,
-				stub->args.xdata);
-		break;
+            stub->fn.rmdir(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.flags, stub->args.xdata);
+            break;
         case GF_FOP_SYMLINK:
-                stub->fn.symlink (stub->frame, stub->frame->this,
-				  stub->args.linkname, &stub->args.loc,
-				  stub->args.umask, stub->args.xdata);
-		break;
+            stub->fn.symlink(stub->frame, stub->frame->this,
+                             stub->args.linkname, &stub->args.loc,
+                             stub->args.umask, stub->args.xdata);
+            break;
         case GF_FOP_RENAME:
-                stub->fn.rename (stub->frame, stub->frame->this,
-				 &stub->args.loc, &stub->args.loc2,
-				 stub->args.xdata);
-		break;
+            stub->fn.rename(stub->frame, stub->frame->this, &stub->args.loc,
+                            &stub->args.loc2, stub->args.xdata);
+            break;
         case GF_FOP_LINK:
-                stub->fn.link (stub->frame, stub->frame->this,
-			       &stub->args.loc, &stub->args.loc2,
-			       stub->args.xdata);
-		break;
+            stub->fn.link(stub->frame, stub->frame->this, &stub->args.loc,
+                          &stub->args.loc2, stub->args.xdata);
+            break;
         case GF_FOP_TRUNCATE:
-                stub->fn.truncate (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.offset,
-				   stub->args.xdata);
-                break;
+            stub->fn.truncate(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.offset, stub->args.xdata);
+            break;
         case GF_FOP_READ:
-                stub->fn.readv (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.size,
-				stub->args.offset, stub->args.flags,
-				stub->args.xdata);
-                break;
+            stub->fn.readv(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.size, stub->args.offset, stub->args.flags,
+                           stub->args.xdata);
+            break;
         case GF_FOP_WRITE:
-                stub->fn.writev (stub->frame, stub->frame->this,
-				 stub->args.fd, stub->args.vector,
-				 stub->args.count, stub->args.offset,
-				 stub->args.flags, stub->args.iobref,
-				 stub->args.xdata);
-                break;
+            stub->fn.writev(stub->frame, stub->frame->this, stub->args.fd,
+                            stub->args.vector, stub->args.count,
+                            stub->args.offset, stub->args.flags,
+                            stub->args.iobref, stub->args.xdata);
+            break;
         case GF_FOP_STATFS:
-                stub->fn.statfs (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.statfs(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xdata);
+            break;
         case GF_FOP_FLUSH:
-                stub->fn.flush (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.flush(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.xdata);
+            break;
         case GF_FOP_FSYNC:
-                stub->fn.fsync (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.datasync,
-				stub->args.xdata);
-                break;
+            stub->fn.fsync(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.datasync, stub->args.xdata);
+            break;
         case GF_FOP_SETXATTR:
-                stub->fn.setxattr (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.xattr,
-				   stub->args.flags, stub->args.xdata);
-                break;
+            stub->fn.setxattr(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.xattr, stub->args.flags,
+                              stub->args.xdata);
+            break;
         case GF_FOP_GETXATTR:
-                stub->fn.getxattr (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.name,
-				   stub->args.xdata);
-                break;
+            stub->fn.getxattr(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_FSETXATTR:
-                stub->fn.fsetxattr (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.xattr,
-				    stub->args.flags, stub->args.xdata);
-                break;
+            stub->fn.fsetxattr(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.xattr, stub->args.flags,
+                               stub->args.xdata);
+            break;
         case GF_FOP_FGETXATTR:
-                stub->fn.fgetxattr (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.name,
-				    stub->args.xdata);
-                break;
+            stub->fn.fgetxattr(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_REMOVEXATTR:
-                stub->fn.removexattr (stub->frame, stub->frame->this,
-				      &stub->args.loc, stub->args.name,
-				      stub->args.xdata);
-                break;
+            stub->fn.removexattr(stub->frame, stub->frame->this,
+                                 &stub->args.loc, stub->args.name,
+                                 stub->args.xdata);
+            break;
         case GF_FOP_FREMOVEXATTR:
-                stub->fn.fremovexattr (stub->frame, stub->frame->this,
-				       stub->args.fd, stub->args.name,
-				       stub->args.xdata);
-                break;
+            stub->fn.fremovexattr(stub->frame, stub->frame->this, stub->args.fd,
+                                  stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_OPENDIR:
-                stub->fn.opendir (stub->frame, stub->frame->this,
-				  &stub->args.loc, stub->args.fd,
-				  stub->args.xdata);
-                break;
+            stub->fn.opendir(stub->frame, stub->frame->this, &stub->args.loc,
+                             stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_FSYNCDIR:
-                stub->fn.fsyncdir (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.datasync,
-				   stub->args.xdata);
-                break;
+            stub->fn.fsyncdir(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.datasync, stub->args.xdata);
+            break;
         case GF_FOP_ACCESS:
-                stub->fn.access (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.mask,
-				 stub->args.xdata);
-                break;
+            stub->fn.access(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.mask, stub->args.xdata);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                stub->fn.ftruncate (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.offset,
-				    stub->args.xdata);
-                break;
+            stub->fn.ftruncate(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.offset, stub->args.xdata);
+            break;
         case GF_FOP_FSTAT:
-                stub->fn.fstat (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.fstat(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.xdata);
+            break;
         case GF_FOP_LK:
-                stub->fn.lk (stub->frame, stub->frame->this,
-			     stub->args.fd, stub->args.cmd,
-			     &stub->args.lock, stub->args.xdata);
-                break;
+            stub->fn.lk(stub->frame, stub->frame->this, stub->args.fd,
+                        stub->args.cmd, &stub->args.lock, stub->args.xdata);
+            break;
         case GF_FOP_INODELK:
-                stub->fn.inodelk (stub->frame, stub->frame->this,
-				  stub->args.volume, &stub->args.loc,
-				  stub->args.cmd, &stub->args.lock,
-				  stub->args.xdata);
-                break;
+            stub->fn.inodelk(stub->frame, stub->frame->this, stub->args.volume,
+                             &stub->args.loc, stub->args.cmd, &stub->args.lock,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FINODELK:
-                stub->fn.finodelk (stub->frame, stub->frame->this,
-				   stub->args.volume, stub->args.fd,
-				   stub->args.cmd, &stub->args.lock,
-				   stub->args.xdata);
-                break;
+            stub->fn.finodelk(stub->frame, stub->frame->this, stub->args.volume,
+                              stub->args.fd, stub->args.cmd, &stub->args.lock,
+                              stub->args.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                stub->fn.entrylk (stub->frame, stub->frame->this,
-				  stub->args.volume, &stub->args.loc,
-				  stub->args.name, stub->args.entrylkcmd,
-				  stub->args.entrylktype, stub->args.xdata);
-                break;
+            stub->fn.entrylk(stub->frame, stub->frame->this, stub->args.volume,
+                             &stub->args.loc, stub->args.name,
+                             stub->args.entrylkcmd, stub->args.entrylktype,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                stub->fn.fentrylk (stub->frame, stub->frame->this,
-				   stub->args.volume, stub->args.fd,
-				   stub->args.name, stub->args.entrylkcmd,
-				   stub->args.entrylktype, stub->args.xdata);
-		break;
+            stub->fn.fentrylk(stub->frame, stub->frame->this, stub->args.volume,
+                              stub->args.fd, stub->args.name,
+                              stub->args.entrylkcmd, stub->args.entrylktype,
+                              stub->args.xdata);
+            break;
         case GF_FOP_LOOKUP:
-                stub->fn.lookup (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.lookup(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xdata);
+            break;
         case GF_FOP_RCHECKSUM:
-                stub->fn.rchecksum (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.offset,
-				    stub->args.size, stub->args.xdata);
-                break;
+            stub->fn.rchecksum(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.offset, stub->args.size,
+                               stub->args.xdata);
+            break;
         case GF_FOP_READDIR:
-                stub->fn.readdir (stub->frame, stub->frame->this,
-				  stub->args.fd, stub->args.size,
-				  stub->args.offset, stub->args.xdata);
-                break;
+            stub->fn.readdir(stub->frame, stub->frame->this, stub->args.fd,
+                             stub->args.size, stub->args.offset,
+                             stub->args.xdata);
+            break;
         case GF_FOP_READDIRP:
-                stub->fn.readdirp (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.size,
-				   stub->args.offset, stub->args.xdata);
-                break;
+            stub->fn.readdirp(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.size, stub->args.offset,
+                              stub->args.xdata);
+            break;
         case GF_FOP_XATTROP:
-                stub->fn.xattrop (stub->frame, stub->frame->this,
-				  &stub->args.loc, stub->args.optype,
-				  stub->args.xattr, stub->args.xdata);
-                break;
+            stub->fn.xattrop(stub->frame, stub->frame->this, &stub->args.loc,
+                             stub->args.optype, stub->args.xattr,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FXATTROP:
-                stub->fn.fxattrop (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.optype,
-				   stub->args.xattr, stub->args.xdata);
-                break;
+            stub->fn.fxattrop(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.optype, stub->args.xattr,
+                              stub->args.xdata);
+            break;
         case GF_FOP_SETATTR:
-                stub->fn.setattr (stub->frame, stub->frame->this,
-				  &stub->args.loc, &stub->args.stat,
-				  stub->args.valid, stub->args.xdata);
-                break;
+            stub->fn.setattr(stub->frame, stub->frame->this, &stub->args.loc,
+                             &stub->args.stat, stub->args.valid,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FSETATTR:
-                stub->fn.fsetattr (stub->frame, stub->frame->this,
-				   stub->args.fd, &stub->args.stat,
-				   stub->args.valid, stub->args.xdata);
-                break;
-	case GF_FOP_FALLOCATE:
-		stub->fn.fallocate(stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.flags,
-				   stub->args.offset, stub->args.size,
-				   stub->args.xdata);
-		break;
-	case GF_FOP_DISCARD:
-		stub->fn.discard(stub->frame, stub->frame->this,
-				 stub->args.fd, stub->args.offset,
-				 stub->args.size, stub->args.xdata);
-		break;
+            stub->fn.fsetattr(stub->frame, stub->frame->this, stub->args.fd,
+                              &stub->args.stat, stub->args.valid,
+                              stub->args.xdata);
+            break;
+        case GF_FOP_FALLOCATE:
+            stub->fn.fallocate(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.flags, stub->args.offset,
+                               stub->args.size, stub->args.xdata);
+            break;
+        case GF_FOP_DISCARD:
+            stub->fn.discard(stub->frame, stub->frame->this, stub->args.fd,
+                             stub->args.offset, stub->args.size,
+                             stub->args.xdata);
+            break;
         case GF_FOP_ZEROFILL:
-                stub->fn.zerofill(stub->frame, stub->frame->this,
-                                 stub->args.fd, stub->args.offset,
-                                 stub->args.size, stub->args.xdata);
-                break;
+            stub->fn.zerofill(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.offset, stub->args.size,
+                              stub->args.xdata);
+            break;
         case GF_FOP_IPC:
-                stub->fn.ipc (stub->frame, stub->frame->this,
-                              stub->args.cmd, stub->args.xdata);
-                break;
+            stub->fn.ipc(stub->frame, stub->frame->this, stub->args.cmd,
+                         stub->args.xdata);
+            break;
         case GF_FOP_SEEK:
-                stub->fn.seek (stub->frame, stub->frame->this,
-                               stub->args.fd, stub->args.offset,
-                               stub->args.what, stub->args.xdata);
-                break;
+            stub->fn.seek(stub->frame, stub->frame->this, stub->args.fd,
+                          stub->args.offset, stub->args.what, stub->args.xdata);
+            break;
         case GF_FOP_LEASE:
-                stub->fn.lease (stub->frame, stub->frame->this,
-                                &stub->args.loc, &stub->args.lease,
-                                stub->args.xdata);
-                break;
+            stub->fn.lease(stub->frame, stub->frame->this, &stub->args.loc,
+                           &stub->args.lease, stub->args.xdata);
+            break;
 
         case GF_FOP_GETACTIVELK:
-                stub->fn.getactivelk (stub->frame, stub->frame->this,
-                                       &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.getactivelk(stub->frame, stub->frame->this,
+                                 &stub->args.loc, stub->args.xdata);
+            break;
 
         case GF_FOP_SETACTIVELK:
-                stub->fn.setactivelk (stub->frame, stub->frame->this,
-                                        &stub->args.loc, &stub->args.locklist,
-                                        stub->args.xdata);
-                break;
+            stub->fn.setactivelk(stub->frame, stub->frame->this,
+                                 &stub->args.loc, &stub->args.locklist,
+                                 stub->args.xdata);
+            break;
+
+        case GF_FOP_PUT:
+            stub->fn.put(stub->frame, stub->frame->this, &stub->args.loc,
+                         stub->args.mode, stub->args.umask, stub->args.flags,
+                         stub->args.vector, stub->args.count, stub->args.offset,
+                         stub->args.iobref, stub->args.xattr, stub->args.xdata);
+            break;
+
+        case GF_FOP_COPY_FILE_RANGE:
+            stub->fn.copy_file_range(
+                stub->frame, stub->frame->this, stub->args.fd,
+                stub->args.off_in, stub->args.fd_dst, stub->args.off_out,
+                stub->args.size, stub->args.flags, stub->args.xdata);
+            break;
 
         default:
-                gf_msg_callingfn ("call-stub", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ENTRY, "Invalid value of FOP"
-                                  " (%d)", stub->fop);
-                break;
-        }
-out:
-        return;
-}
-
-
-#define STUB_UNWIND(stb, fop, args ...) do {				\
-	if (stb->fn_cbk.fop)						\
-		stb->fn_cbk.fop (stb->frame, stb->frame->cookie,	\
-				 stb->frame->this, stb->args_cbk.op_ret, \
-				 stb->args_cbk.op_errno, args);		\
-	else								\
-		STACK_UNWIND_STRICT (fop, stb->frame, stb->args_cbk.op_ret, \
-				     stb->args_cbk.op_errno, args);	\
-	} while (0)
-
+            gf_msg_callingfn("call-stub", GF_LOG_ERROR, EINVAL,
+                             LG_MSG_INVALID_ENTRY,
+                             "Invalid value of FOP"
+                             " (%d)",
+                             stub->fop);
+            break;
+    }
+out:
+    return;
+}
+
+#define STUB_UNWIND(stb, fop, args...)                                         \
+    do {                                                                       \
+        if (stb->fn_cbk.fop)                                                   \
+            stb->fn_cbk.fop(stb->frame, stb->frame->cookie, stb->frame->this,  \
+                            stb->args_cbk.op_ret, stb->args_cbk.op_errno,      \
+                            args);                                             \
+        else                                                                   \
+            STACK_UNWIND_STRICT(fop, stb->frame, stb->args_cbk.op_ret,         \
+                                stb->args_cbk.op_errno, args);                 \
+    } while (0)
 
 static void
-call_resume_unwind (call_stub_t *stub)
+call_resume_unwind(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        switch (stub->fop) {
+    switch (stub->fop) {
         case GF_FOP_OPEN:
-		STUB_UNWIND (stub, open, stub->args_cbk.fd,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, open, stub->args_cbk.fd, stub->args_cbk.xdata);
+            break;
         case GF_FOP_CREATE:
-		STUB_UNWIND (stub, create, stub->args_cbk.fd,
-			     stub->args_cbk.inode, &stub->args_cbk.stat,
-			     &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, create, stub->args_cbk.fd, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_STAT:
-		STUB_UNWIND (stub, stat, &stub->args_cbk.stat,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, stat, &stub->args_cbk.stat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READLINK:
-		STUB_UNWIND (stub, readlink, stub->args_cbk.buf,
-			     &stub->args_cbk.stat, stub->args.xdata);
-		break;
+            STUB_UNWIND(stub, readlink, stub->args_cbk.buf,
+                        &stub->args_cbk.stat, stub->args.xdata);
+            break;
         case GF_FOP_MKNOD:
-		STUB_UNWIND (stub, mknod, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, mknod, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_MKDIR:
-		STUB_UNWIND (stub, mkdir, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, mkdir, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_UNLINK:
-		STUB_UNWIND (stub, unlink, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, unlink, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_RMDIR:
-		STUB_UNWIND (stub, rmdir, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rmdir, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SYMLINK:
-		STUB_UNWIND (stub, symlink, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, symlink, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_RENAME:
-		STUB_UNWIND (stub, rename, &stub->args_cbk.stat,
-			     &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent,
-			     &stub->args_cbk.preparent2,
-			     &stub->args_cbk.postparent2,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rename, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        &stub->args_cbk.preparent2, &stub->args_cbk.postparent2,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LINK:
-		STUB_UNWIND (stub, link, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, link, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_TRUNCATE:
-		STUB_UNWIND (stub, truncate, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, truncate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READ:
-		STUB_UNWIND (stub, readv, stub->args_cbk.vector,
-			     stub->args_cbk.count, &stub->args_cbk.stat,
-			     stub->args_cbk.iobref, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, readv, stub->args_cbk.vector,
+                        stub->args_cbk.count, &stub->args_cbk.stat,
+                        stub->args_cbk.iobref, stub->args_cbk.xdata);
+            break;
         case GF_FOP_WRITE:
-		STUB_UNWIND (stub, writev, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, writev, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_STATFS:
-		STUB_UNWIND (stub, statfs, &stub->args_cbk.statvfs,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, statfs, &stub->args_cbk.statvfs,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FLUSH:
-		STUB_UNWIND (stub, flush, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, flush, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSYNC:
-		STUB_UNWIND (stub, fsync, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsync, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SETXATTR:
-		STUB_UNWIND (stub, setxattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, setxattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_GETXATTR:
-		STUB_UNWIND (stub, getxattr, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, getxattr, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSETXATTR:
-		STUB_UNWIND (stub, fsetxattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsetxattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FGETXATTR:
-		STUB_UNWIND (stub, fgetxattr, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fgetxattr, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_REMOVEXATTR:
-		STUB_UNWIND (stub, removexattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, removexattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FREMOVEXATTR:
-		STUB_UNWIND (stub, fremovexattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fremovexattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_OPENDIR:
-		STUB_UNWIND (stub, opendir, stub->args_cbk.fd,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, opendir, stub->args_cbk.fd, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSYNCDIR:
-		STUB_UNWIND (stub, fsyncdir, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fsyncdir, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ACCESS:
-		STUB_UNWIND (stub, access, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, access, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FTRUNCATE:
-		STUB_UNWIND (stub, ftruncate, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, ftruncate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSTAT:
-		STUB_UNWIND (stub, fstat, &stub->args_cbk.stat,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fstat, &stub->args_cbk.stat,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LK:
-		STUB_UNWIND (stub, lk, &stub->args_cbk.lock,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, lk, &stub->args_cbk.lock, stub->args_cbk.xdata);
+            break;
         case GF_FOP_INODELK:
-		STUB_UNWIND (stub, inodelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, inodelk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FINODELK:
-		STUB_UNWIND (stub, finodelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, finodelk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-		STUB_UNWIND (stub, entrylk, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, entrylk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-		STUB_UNWIND (stub, fentrylk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fentrylk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_LOOKUP:
-		STUB_UNWIND (stub, lookup, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, stub->args_cbk.xdata,
-			     &stub->args_cbk.postparent);
-                break;
+            STUB_UNWIND(stub, lookup, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, stub->args_cbk.xdata,
+                        &stub->args_cbk.postparent);
+            break;
         case GF_FOP_RCHECKSUM:
-		STUB_UNWIND (stub, rchecksum, stub->args_cbk.weak_checksum,
-			     stub->args_cbk.strong_checksum, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rchecksum, stub->args_cbk.weak_checksum,
+                        stub->args_cbk.strong_checksum, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READDIR:
-		STUB_UNWIND (stub, readdir, &stub->args_cbk.entries,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, readdir, &stub->args_cbk.entries,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_READDIRP:
-		STUB_UNWIND (stub, readdir, &stub->args_cbk.entries,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, readdir, &stub->args_cbk.entries,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_XATTROP:
-		STUB_UNWIND (stub, xattrop, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, xattrop, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FXATTROP:
-		STUB_UNWIND (stub, fxattrop, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fxattrop, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_SETATTR:
-		STUB_UNWIND (stub, setattr, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, setattr, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSETATTR:
-		STUB_UNWIND (stub, fsetattr, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
-	case GF_FOP_FALLOCATE:
-		STUB_UNWIND(stub, fallocate, &stub->args_cbk.prestat,
-			    &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
-	case GF_FOP_DISCARD:
-		STUB_UNWIND(stub, discard, &stub->args_cbk.prestat,
-			    &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsetattr, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
+        case GF_FOP_FALLOCATE:
+            STUB_UNWIND(stub, fallocate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
+        case GF_FOP_DISCARD:
+            STUB_UNWIND(stub, discard, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ZEROFILL:
-                STUB_UNWIND(stub, zerofill, &stub->args_cbk.prestat,
-                            &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, zerofill, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_IPC:
-                STUB_UNWIND (stub, ipc, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, ipc, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SEEK:
-                STUB_UNWIND (stub, seek, stub->args_cbk.offset,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, seek, stub->args_cbk.offset,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LEASE:
-                STUB_UNWIND (stub, lease, &stub->args_cbk.lease,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, lease, &stub->args_cbk.lease,
+                        stub->args_cbk.xdata);
+            break;
 
         case GF_FOP_GETACTIVELK:
-                STUB_UNWIND (stub, getactivelk, &stub->args_cbk.locklist,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, getactivelk, &stub->args_cbk.locklist,
+                        stub->args_cbk.xdata);
+            break;
 
         case GF_FOP_SETACTIVELK:
-                STUB_UNWIND (stub, setactivelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, setactivelk, stub->args_cbk.xdata);
+            break;
+
+        case GF_FOP_PUT:
+            STUB_UNWIND(stub, put, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
+
+        case GF_FOP_COPY_FILE_RANGE:
+            STUB_UNWIND(stub, copy_file_range, &stub->args_cbk.stat,
+                        &stub->args_cbk.prestat, &stub->args_cbk.poststat,
+                        stub->args_cbk.xdata);
+            break;
 
         default:
-                gf_msg_callingfn ("call-stub", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ENTRY, "Invalid value of FOP"
-                                  " (%d)", stub->fop);
-                break;
-        }
+            gf_msg_callingfn("call-stub", GF_LOG_ERROR, EINVAL,
+                             LG_MSG_INVALID_ENTRY,
+                             "Invalid value of FOP"
+                             " (%d)",
+                             stub->fop);
+            break;
+    }
 out:
-        return;
+    return;
 }
 
-
 static void
-call_stub_wipe_args (call_stub_t *stub)
+call_stub_wipe_args(call_stub_t *stub)
 {
-        args_wipe (&stub->args);
+    args_wipe(&stub->args);
 }
 
 static void
-call_stub_wipe_args_cbk (call_stub_t *stub)
+call_stub_wipe_args_cbk(call_stub_t *stub)
 {
-        args_cbk_wipe (&stub->args_cbk);
+    args_cbk_wipe(&stub->args_cbk);
 }
 
-
 void
-call_stub_destroy (call_stub_t *stub)
+call_stub_destroy(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        if (stub->wind)
-                call_stub_wipe_args (stub);
-        else
-                call_stub_wipe_args_cbk (stub);
+    if (stub->wind)
+        call_stub_wipe_args(stub);
+    else
+        call_stub_wipe_args_cbk(stub);
 
-        stub->stub_mem_pool = NULL;
+    stub->stub_mem_pool = NULL;
 
-        mem_put (stub);
+    mem_put(stub);
 out:
-        return;
+    return;
 }
 
-
 void
-call_resume (call_stub_t *stub)
+call_resume(call_stub_t *stub)
 {
-        xlator_t *old_THIS = NULL;
+    xlator_t *old_THIS = NULL;
 
-        errno = EINVAL;
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    errno = EINVAL;
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                if (stub->wind)
-                        call_resume_wind (stub);
-                else
-                        call_resume_unwind (stub);
-        }
-        THIS = old_THIS;
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        if (stub->wind)
+            call_resume_wind(stub);
+        else
+            call_resume_unwind(stub);
+    }
+    THIS = old_THIS;
 
-        call_stub_destroy (stub);
+    call_stub_destroy(stub);
 out:
-        return;
+    return;
 }
 
-
 void
-call_unwind_error (call_stub_t *stub, int op_ret, int op_errno)
+call_unwind_error(call_stub_t *stub, int op_ret, int op_errno)
 {
-        xlator_t *old_THIS = NULL;
-
-        list_del_init (&stub->list);
+    xlator_t *old_THIS = NULL;
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-		stub->args_cbk.op_ret = op_ret;
-		stub->args_cbk.op_errno = op_errno;
-		call_resume_unwind (stub);
-        }
-        THIS = old_THIS;
+    list_del_init(&stub->list);
 
-        call_stub_destroy (stub);
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        stub->args_cbk.op_ret = op_ret;
+        stub->args_cbk.op_errno = op_errno;
+        call_resume_unwind(stub);
+    }
+    THIS = old_THIS;
 
-        return;
+    call_stub_destroy(stub);
 
+    return;
 }
 
-
 void
-call_unwind_error_keep_stub (call_stub_t *stub, int op_ret, int op_errno)
+call_unwind_error_keep_stub(call_stub_t *stub, int op_ret, int op_errno)
 {
-        xlator_t *old_THIS = NULL;
-
-        list_del_init (&stub->list);
+    xlator_t *old_THIS = NULL;
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                stub->args_cbk.op_ret = op_ret;
-                stub->args_cbk.op_errno = op_errno;
-                call_resume_unwind (stub);
-        }
+    list_del_init(&stub->list);
 
-        THIS = old_THIS;
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        stub->args_cbk.op_ret = op_ret;
+        stub->args_cbk.op_errno = op_errno;
+        call_resume_unwind(stub);
+    }
 
-        return;
+    THIS = old_THIS;
 
+    return;
 }
 
 void
-call_resume_keep_stub (call_stub_t *stub)
+call_resume_keep_stub(call_stub_t *stub)
 {
-        xlator_t *old_THIS = NULL;
+    xlator_t *old_THIS = NULL;
 
-        errno = EINVAL;
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    errno = EINVAL;
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                if (stub->wind)
-                        call_resume_wind (stub);
-                else
-                        call_resume_unwind (stub);
-        }
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        if (stub->wind)
+            call_resume_wind(stub);
+        else
+            call_resume_unwind(stub);
+    }
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/call-stub.h b/libglusterfs/src/call-stub.h
deleted file mode 100644
index 300b5935767..00000000000
--- a/libglusterfs/src/call-stub.h
+++ /dev/null
@@ -1,777 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _CALL_STUB_H_
-#define _CALL_STUB_H_
-
-#include "xlator.h"
-#include "defaults.h"
-#include "default-args.h"
-#include "stack.h"
-#include "list.h"
-
-typedef struct _call_stub {
-	struct list_head list;
-	char wind;
-	call_frame_t *frame;
-	glusterfs_fop_t fop;
-        struct mem_pool *stub_mem_pool; /* pointer to stub mempool in ctx_t */
-        uint32_t jnl_meta_len;
-        uint32_t jnl_data_len;
-        void (*serialize) (struct _call_stub *, char *, char *);
-
-	union {
-		fop_lookup_t lookup;
-		fop_stat_t stat;
-		fop_fstat_t fstat;
-		fop_truncate_t truncate;
-		fop_ftruncate_t ftruncate;
-		fop_access_t access;
-		fop_readlink_t readlink;
-		fop_mknod_t mknod;
-		fop_mkdir_t mkdir;
-		fop_unlink_t unlink;
-		fop_rmdir_t rmdir;
-		fop_symlink_t symlink;
-		fop_rename_t rename;
-		fop_link_t link;
-		fop_create_t create;
-		fop_open_t open;
-		fop_readv_t readv;
-		fop_writev_t writev;
-		fop_flush_t flush;
-		fop_fsync_t fsync;
-		fop_opendir_t opendir;
-		fop_fsyncdir_t fsyncdir;
-		fop_statfs_t statfs;
-		fop_setxattr_t setxattr;
-		fop_getxattr_t getxattr;
-		fop_fgetxattr_t fgetxattr;
-		fop_fsetxattr_t fsetxattr;
-		fop_removexattr_t removexattr;
-		fop_fremovexattr_t fremovexattr;
-		fop_lk_t lk;
-		fop_inodelk_t inodelk;
-		fop_finodelk_t finodelk;
-		fop_entrylk_t entrylk;
-		fop_fentrylk_t fentrylk;
-		fop_readdir_t readdir;
-		fop_readdirp_t readdirp;
-		fop_rchecksum_t rchecksum;
-		fop_xattrop_t xattrop;
-		fop_fxattrop_t fxattrop;
-		fop_setattr_t setattr;
-		fop_fsetattr_t fsetattr;
-		fop_fallocate_t fallocate;
-		fop_discard_t discard;
-                fop_zerofill_t zerofill;
-                fop_ipc_t ipc;
-                fop_seek_t seek;
-                fop_lease_t lease;
-                fop_getactivelk_t getactivelk;
-	        fop_setactivelk_t setactivelk;
-        } fn;
-
-	union {
-		fop_lookup_cbk_t lookup;
-		fop_stat_cbk_t stat;
-		fop_fstat_cbk_t fstat;
-		fop_truncate_cbk_t truncate;
-		fop_ftruncate_cbk_t ftruncate;
-		fop_access_cbk_t access;
-		fop_readlink_cbk_t readlink;
-		fop_mknod_cbk_t mknod;
-		fop_mkdir_cbk_t mkdir;
-		fop_unlink_cbk_t unlink;
-		fop_rmdir_cbk_t rmdir;
-		fop_symlink_cbk_t symlink;
-		fop_rename_cbk_t rename;
-		fop_link_cbk_t link;
-		fop_create_cbk_t create;
-		fop_open_cbk_t open;
-		fop_readv_cbk_t readv;
-		fop_writev_cbk_t writev;
-		fop_flush_cbk_t flush;
-		fop_fsync_cbk_t fsync;
-		fop_opendir_cbk_t opendir;
-		fop_fsyncdir_cbk_t fsyncdir;
-		fop_statfs_cbk_t statfs;
-		fop_setxattr_cbk_t setxattr;
-		fop_getxattr_cbk_t getxattr;
-		fop_fgetxattr_cbk_t fgetxattr;
-		fop_fsetxattr_cbk_t fsetxattr;
-		fop_removexattr_cbk_t removexattr;
-		fop_fremovexattr_cbk_t fremovexattr;
-		fop_lk_cbk_t lk;
-		fop_inodelk_cbk_t inodelk;
-		fop_finodelk_cbk_t finodelk;
-		fop_entrylk_cbk_t entrylk;
-		fop_fentrylk_cbk_t fentrylk;
-		fop_readdir_cbk_t readdir;
-		fop_readdirp_cbk_t readdirp;
-		fop_rchecksum_cbk_t rchecksum;
-		fop_xattrop_cbk_t xattrop;
-		fop_fxattrop_cbk_t fxattrop;
-		fop_setattr_cbk_t setattr;
-		fop_fsetattr_cbk_t fsetattr;
-		fop_fallocate_cbk_t fallocate;
-		fop_discard_cbk_t discard;
-                fop_zerofill_cbk_t zerofill;
-                fop_ipc_cbk_t ipc;
-                fop_seek_cbk_t seek;
-                fop_lease_cbk_t lease;
-                fop_getactivelk_cbk_t getactivelk;
-                fop_setactivelk_cbk_t setactivelk;
-	} fn_cbk;
-
-        default_args_t args;
-        default_args_cbk_t args_cbk;
-} call_stub_t;
-
-
-call_stub_t *
-fop_lookup_stub (call_frame_t *frame,
-		 fop_lookup_t fn,
-		 loc_t *loc,
-		 dict_t *xdata);
-
-call_stub_t *
-fop_lookup_cbk_stub (call_frame_t *frame,
-		     fop_lookup_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-		     inode_t *inode,
-		     struct iatt *buf,
-                     dict_t *xdata,
-                     struct iatt *postparent);
-call_stub_t *
-fop_stat_stub (call_frame_t *frame,
-	       fop_stat_t fn,
-	       loc_t *loc, dict_t *xdata);
-call_stub_t *
-fop_stat_cbk_stub (call_frame_t *frame,
-		   fop_stat_cbk_t fn,
-		   int32_t op_ret,
-		   int32_t op_errno,
-		   struct iatt *buf, dict_t *xdata);
-call_stub_t *
-fop_fstat_stub (call_frame_t *frame,
-		fop_fstat_t fn,
-		fd_t *fd, dict_t *xdata);
-call_stub_t *
-fop_fstat_cbk_stub (call_frame_t *frame,
-		    fop_fstat_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-		    struct iatt *buf, dict_t *xdata);
-
-call_stub_t *
-fop_truncate_stub (call_frame_t *frame,
-		   fop_truncate_t fn,
-		   loc_t *loc,
-		   off_t off, dict_t *xdata);
-
-call_stub_t *
-fop_truncate_cbk_stub (call_frame_t *frame,
-		       fop_truncate_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno,
-		       struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata);
-
-call_stub_t *
-fop_ftruncate_stub (call_frame_t *frame,
-		    fop_ftruncate_t fn,
-		    fd_t *fd,
-		    off_t off, dict_t *xdata);
-
-call_stub_t *
-fop_ftruncate_cbk_stub (call_frame_t *frame,
-			fop_ftruncate_cbk_t fn,
-			int32_t op_ret,
-			int32_t op_errno,
-			struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata);
-
-call_stub_t *
-fop_access_stub (call_frame_t *frame,
-		 fop_access_t fn,
-		 loc_t *loc,
-		 int32_t mask, dict_t *xdata);
-
-call_stub_t *
-fop_access_cbk_stub (call_frame_t *frame,
-		     fop_access_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_readlink_stub (call_frame_t *frame,
-		   fop_readlink_t fn,
-		   loc_t *loc,
-		   size_t size, dict_t *xdata);
-
-call_stub_t *
-fop_readlink_cbk_stub (call_frame_t *frame,
-		       fop_readlink_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno,
-		       const char *path,
-                       struct iatt *buf, dict_t *xdata);
-
-call_stub_t *
-fop_mknod_stub (call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
-                dev_t rdev, mode_t umask, dict_t *xdata);
-
-call_stub_t *
-fop_mknod_cbk_stub (call_frame_t *frame,
-		    fop_mknod_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-		    inode_t *inode,
-                    struct iatt *buf,
-                    struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_mkdir_stub (call_frame_t *frame, fop_mkdir_t fn, loc_t *loc, mode_t mode,
-                mode_t umask, dict_t *xdata);
-
-call_stub_t *
-fop_mkdir_cbk_stub (call_frame_t *frame,
-		    fop_mkdir_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-		    inode_t *inode,
-                    struct iatt *buf,
-                    struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_unlink_stub (call_frame_t *frame, fop_unlink_t fn,
-		 loc_t *loc, int xflag, dict_t *xdata);
-
-call_stub_t *
-fop_unlink_cbk_stub (call_frame_t *frame,
-		     fop_unlink_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-                     struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_rmdir_stub (call_frame_t *frame, fop_rmdir_t fn,
-		loc_t *loc, int flags, dict_t *xdata);
-
-call_stub_t *
-fop_rmdir_cbk_stub (call_frame_t *frame,
-		    fop_rmdir_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-                    struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_symlink_stub (call_frame_t *frame, fop_symlink_t fn,
-		  const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata);
-
-call_stub_t *
-fop_symlink_cbk_stub (call_frame_t *frame,
-		      fop_symlink_cbk_t fn,
-		      int32_t op_ret,
-		      int32_t op_errno,
-		      inode_t *inode,
-                      struct iatt *buf,
-                      struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_rename_stub (call_frame_t *frame,
-		 fop_rename_t fn,
-		 loc_t *oldloc,
-		 loc_t *newloc, dict_t *xdata);
-
-call_stub_t *
-fop_rename_cbk_stub (call_frame_t *frame,
-		     fop_rename_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-		     struct iatt *buf,
-                     struct iatt *preoldparent,
-                     struct iatt *postoldparent,
-                     struct iatt *prenewparent,
-                     struct iatt *postnewparent, dict_t *xdata);
-
-call_stub_t *
-fop_link_stub (call_frame_t *frame,
-	       fop_link_t fn,
-	       loc_t *oldloc,
-	       loc_t *newloc, dict_t *xdata);
-
-call_stub_t *
-fop_link_cbk_stub (call_frame_t *frame,
-		   fop_link_cbk_t fn,
-		   int32_t op_ret,
-		   int32_t op_errno,
-		   inode_t *inode,
-                   struct iatt *buf,
-                   struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_create_stub (call_frame_t *frame, fop_create_t fn,
-		 loc_t *loc, int32_t flags, mode_t mode,
-                 mode_t umask, fd_t *fd, dict_t *xdata);
-
-call_stub_t *
-fop_create_cbk_stub (call_frame_t *frame,
-		     fop_create_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-		     fd_t *fd,
-		     inode_t *inode,
-		     struct iatt *buf,
-                     struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata);
-
-call_stub_t *
-fop_open_stub (call_frame_t *frame,
-	       fop_open_t fn,
-	       loc_t *loc,
-	       int32_t flags,
-	       fd_t *fd,
-               dict_t *xdata);
-
-call_stub_t *
-fop_open_cbk_stub (call_frame_t *frame,
-		   fop_open_cbk_t fn,
-		   int32_t op_ret,
-		   int32_t op_errno,
-		   fd_t *fd, dict_t *xdata);
-
-call_stub_t *
-fop_readv_stub (call_frame_t *frame,
-		fop_readv_t fn,
-		fd_t *fd,
-		size_t size,
-		off_t off, uint32_t flags, dict_t *xdata);
-
-call_stub_t *
-fop_readv_cbk_stub (call_frame_t *frame,
-		    fop_readv_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-		    struct iovec *vector,
-		    int32_t count,
-		    struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata);
-
-call_stub_t *
-fop_writev_stub (call_frame_t *frame,
-		 fop_writev_t fn,
-		 fd_t *fd,
-		 struct iovec *vector,
-		 int32_t count,
-		 off_t off, uint32_t flags,
-                 struct iobref *iobref, dict_t *xdata);
-
-call_stub_t *
-fop_writev_cbk_stub (call_frame_t *frame,
-		     fop_writev_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-                     struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata);
-
-call_stub_t *
-fop_flush_stub (call_frame_t *frame,
-		fop_flush_t fn,
-		fd_t *fd, dict_t *xdata);
-
-call_stub_t *
-fop_flush_cbk_stub (call_frame_t *frame,
-		    fop_flush_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_fsync_stub (call_frame_t *frame,
-		fop_fsync_t fn,
-		fd_t *fd,
-		int32_t datasync, dict_t *xdata);
-
-call_stub_t *
-fop_fsync_cbk_stub (call_frame_t *frame,
-		    fop_fsync_cbk_t fn,
-		    int32_t op_ret,
-		    int32_t op_errno,
-                    struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata);
-
-call_stub_t *
-fop_opendir_stub (call_frame_t *frame,
-		  fop_opendir_t fn,
-		  loc_t *loc, fd_t *fd, dict_t *xdata);
-
-call_stub_t *
-fop_opendir_cbk_stub (call_frame_t *frame,
-		      fop_opendir_cbk_t fn,
-		      int32_t op_ret,
-		      int32_t op_errno,
-		      fd_t *fd, dict_t *xdata);
-
-call_stub_t *
-fop_fsyncdir_stub (call_frame_t *frame,
-		   fop_fsyncdir_t fn,
-		   fd_t *fd,
-		   int32_t datasync, dict_t *xdata);
-
-call_stub_t *
-fop_fsyncdir_cbk_stub (call_frame_t *frame,
-		       fop_fsyncdir_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_statfs_stub (call_frame_t *frame,
-		 fop_statfs_t fn,
-		 loc_t *loc, dict_t *xdata);
-
-call_stub_t *
-fop_statfs_cbk_stub (call_frame_t *frame,
-		     fop_statfs_cbk_t fn,
-		     int32_t op_ret,
-		     int32_t op_errno,
-		     struct statvfs *buf, dict_t *xdata);
-
-call_stub_t *
-fop_setxattr_stub (call_frame_t *frame,
-		   fop_setxattr_t fn,
-		   loc_t *loc,
-		   dict_t *dict,
-		   int32_t flags, dict_t *xdata);
-
-call_stub_t *
-fop_setxattr_cbk_stub (call_frame_t *frame,
-		       fop_setxattr_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_getxattr_stub (call_frame_t *frame,
-		   fop_getxattr_t fn,
-		   loc_t *loc,
-		   const char *name, dict_t *xdata);
-
-call_stub_t *
-fop_getxattr_cbk_stub (call_frame_t *frame,
-		       fop_getxattr_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno,
-		       dict_t *value, dict_t *xdata);
-
-call_stub_t *
-fop_fsetxattr_stub (call_frame_t *frame,
-                    fop_fsetxattr_t fn,
-                    fd_t *fd,
-                    dict_t *dict,
-                    int32_t flags, dict_t *xdata);
-
-call_stub_t *
-fop_fsetxattr_cbk_stub (call_frame_t *frame,
-                        fop_fsetxattr_cbk_t fn,
-                        int32_t op_ret,
-                        int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_fgetxattr_stub (call_frame_t *frame,
-                    fop_fgetxattr_t fn,
-                    fd_t *fd,
-                    const char *name, dict_t *xdata);
-
-call_stub_t *
-fop_fgetxattr_cbk_stub (call_frame_t *frame,
-                        fop_fgetxattr_cbk_t fn,
-                        int32_t op_ret,
-                        int32_t op_errno,
-                        dict_t *value, dict_t *xdata);
-
-call_stub_t *
-fop_removexattr_stub (call_frame_t *frame,
-		      fop_removexattr_t fn,
-		      loc_t *loc,
-		      const char *name, dict_t *xdata);
-
-call_stub_t *
-fop_removexattr_cbk_stub (call_frame_t *frame,
-			  fop_removexattr_cbk_t fn,
-			  int32_t op_ret,
-			  int32_t op_errno, dict_t *xdata);
-
-
-call_stub_t *
-fop_fremovexattr_stub (call_frame_t *frame,
-                       fop_fremovexattr_t fn,
-                       fd_t *fd,
-                       const char *name, dict_t *xdata);
-
-call_stub_t *
-fop_fremovexattr_cbk_stub (call_frame_t *frame,
-                           fop_fremovexattr_cbk_t fn,
-                           int32_t op_ret,
-                           int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_lk_stub (call_frame_t *frame,
-	     fop_lk_t fn,
-	     fd_t *fd,
-	     int32_t cmd,
-	     struct gf_flock *lock, dict_t *xdata);
-
-call_stub_t *
-fop_lk_cbk_stub (call_frame_t *frame,
-		 fop_lk_cbk_t fn,
-		 int32_t op_ret,
-		 int32_t op_errno,
-		 struct gf_flock *lock, dict_t *xdata);
-
-call_stub_t *
-fop_inodelk_stub (call_frame_t *frame, fop_inodelk_t fn,
-		  const char *volume, loc_t *loc, int32_t cmd,
-                  struct gf_flock *lock, dict_t *xdata);
-
-call_stub_t *
-fop_finodelk_stub (call_frame_t *frame, fop_finodelk_t fn,
-		   const char *volume, fd_t *fd, int32_t cmd,
-                   struct gf_flock *lock, dict_t *xdata);
-
-call_stub_t *
-fop_entrylk_stub (call_frame_t *frame, fop_entrylk_t fn,
-		  const char *volume, loc_t *loc, const char *basename,
-		  entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-call_stub_t *
-fop_fentrylk_stub (call_frame_t *frame, fop_fentrylk_t fn,
-		   const char *volume, fd_t *fd, const char *basename,
-		   entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-call_stub_t *
-fop_inodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-		      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_finodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-		       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_entrylk_cbk_stub (call_frame_t *frame, fop_entrylk_cbk_t fn,
-		      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_fentrylk_cbk_stub (call_frame_t *frame, fop_entrylk_cbk_t fn,
-		       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_readdir_stub (call_frame_t *frame,
-		  fop_readdir_t fn,
-		  fd_t *fd,
-		  size_t size,
-		  off_t off, dict_t *xdata);
-
-call_stub_t *
-fop_readdirp_stub (call_frame_t *frame,
-		   fop_readdirp_t fn,
-		   fd_t *fd,
-		   size_t size,
-		   off_t off,
-                   dict_t *xdata);
-
-call_stub_t *
-fop_readdirp_cbk_stub (call_frame_t *frame,
-		       fop_readdir_cbk_t fn,
-		       int32_t op_ret,
-		       int32_t op_errno,
-		       gf_dirent_t *entries, dict_t *xdata);
-
-call_stub_t *
-fop_readdir_cbk_stub (call_frame_t *frame,
-		      fop_readdir_cbk_t fn,
-		      int32_t op_ret,
-		      int32_t op_errno,
-		      gf_dirent_t *entries, dict_t *xdata);
-
-call_stub_t *
-fop_rchecksum_stub (call_frame_t *frame,
-                    fop_rchecksum_t fn,
-                    fd_t *fd, off_t offset,
-                    int32_t len, dict_t *xdata);
-
-call_stub_t *
-fop_rchecksum_cbk_stub (call_frame_t *frame,
-                        fop_rchecksum_cbk_t fn,
-                        int32_t op_ret,
-                        int32_t op_errno,
-                        uint32_t weak_checksum,
-                        uint8_t *strong_checksum, dict_t *xdata);
-
-call_stub_t *
-fop_xattrop_stub (call_frame_t *frame,
-		  fop_xattrop_t fn,
-		  loc_t *loc,
-		  gf_xattrop_flags_t optype,
-		  dict_t *xattr, dict_t *xdata);
-
-call_stub_t *
-fop_xattrop_stub_cbk_stub (call_frame_t *frame,
-			   fop_xattrop_cbk_t fn,
-			   int32_t op_ret,
-			   int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_fxattrop_stub (call_frame_t *frame,
-		   fop_fxattrop_t fn,
-		   fd_t *fd,
-		   gf_xattrop_flags_t optype,
-		   dict_t *xattr, dict_t *xdata);
-
-call_stub_t *
-fop_fxattrop_stub_cbk_stub (call_frame_t *frame,
-			    fop_xattrop_cbk_t fn,
-			    int32_t op_ret,
-			    int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_setattr_stub (call_frame_t *frame,
-                  fop_setattr_t fn,
-                  loc_t *loc,
-                  struct iatt *stbuf,
-                  int32_t valid, dict_t *xdata);
-
-call_stub_t *
-fop_setattr_cbk_stub (call_frame_t *frame,
-                      fop_setattr_cbk_t fn,
-                      int32_t op_ret,
-                      int32_t op_errno,
-                      struct iatt *statpre,
-                      struct iatt *statpost, dict_t *xdata);
-
-call_stub_t *
-fop_fsetattr_stub (call_frame_t *frame,
-                   fop_fsetattr_t fn,
-                   fd_t *fd,
-                   struct iatt *stbuf,
-                   int32_t valid, dict_t *xdata);
-
-call_stub_t *
-fop_fsetattr_cbk_stub (call_frame_t *frame,
-                       fop_setattr_cbk_t fn,
-                       int32_t op_ret,
-                       int32_t op_errno,
-                       struct iatt *statpre,
-                       struct iatt *statpost, dict_t *xdata);
-
-call_stub_t *
-fop_fallocate_stub(call_frame_t *frame,
-		   fop_fallocate_t fn,
-		   fd_t *fd,
-		   int32_t mode, off_t offset,
-		   size_t len, dict_t *xdata);
-
-call_stub_t *
-fop_fallocate_cbk_stub(call_frame_t *frame,
-		       fop_fallocate_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata);
-
-call_stub_t *
-fop_discard_stub(call_frame_t *frame,
-		 fop_discard_t fn,
-		 fd_t *fd,
-		 off_t offset,
-		 size_t len, dict_t *xdata);
-
-call_stub_t *
-fop_discard_cbk_stub(call_frame_t *frame,
-		     fop_discard_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata);
-
-call_stub_t *
-fop_zerofill_stub(call_frame_t *frame,
-                 fop_zerofill_t fn,
-                 fd_t *fd,
-                 off_t offset,
-                 off_t len, dict_t *xdata);
-
-call_stub_t *
-fop_zerofill_cbk_stub(call_frame_t *frame,
-                     fop_zerofill_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata);
-
-call_stub_t *
-fop_ipc_stub (call_frame_t *frame, fop_ipc_t fn, int32_t op, dict_t *xdata);
-
-call_stub_t *
-fop_ipc_cbk_stub (call_frame_t *frame, fop_ipc_cbk_t fn,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-call_stub_t *
-fop_seek_stub (call_frame_t *frame, fop_seek_t fn, fd_t *fd, off_t offset,
-               gf_seek_what_t what, dict_t *xdata);
-
-call_stub_t *
-fop_seek_cbk_stub (call_frame_t *frame, fop_seek_cbk_t fn,
-                  int32_t op_ret, int32_t op_errno, off_t offset,
-                  dict_t *xdata);
-
-call_stub_t *
-fop_lease_stub (call_frame_t *frame, fop_lease_t fn, loc_t *loc,
-                struct gf_lease *lease, dict_t *xdata);
-
-call_stub_t *
-fop_lease_cbk_stub (call_frame_t *frame, fop_lease_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct gf_lease *lease, dict_t *xdata);
-
-call_stub_t *
-fop_getactivelk_stub (call_frame_t *frame, fop_getactivelk_t fn,
-                       loc_t *loc, dict_t *xdata);
-
-call_stub_t *
-fop_getactivelk_cbk_stub (call_frame_t *frame, fop_getactivelk_cbk_t fn,
-                          int32_t op_ret, int32_t op_errno,
-                          lock_migration_info_t *lmi, dict_t *xdata);
-
-call_stub_t *
-fop_setactivelk_stub (call_frame_t *frame, fop_setactivelk_t fn,
-                        loc_t *loc, lock_migration_info_t *locklist,
-                        dict_t *xdata);
-
-call_stub_t *
-fop_setactivelk_cbk_stub (call_frame_t *frame, fop_setactivelk_cbk_t fn,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-void call_resume (call_stub_t *stub);
-void call_resume_keep_stub (call_stub_t *stub);
-void call_stub_destroy (call_stub_t *stub);
-void call_unwind_error (call_stub_t *stub, int op_ret, int op_errno);
-void call_unwind_error_keep_stub (call_stub_t *stub, int op_ret, int op_errno);
-
-/*
- * Sometimes we might want to call just this, perhaps repeatedly, without
- * having (or being able) to destroy and recreate it.
- */
-void call_resume_wind (call_stub_t *stub);
-
-#endif
diff --git a/libglusterfs/src/changelog.h b/libglusterfs/src/changelog.h
index 6f86e5a54cd..a09d9f25287 100644
--- a/libglusterfs/src/changelog.h
+++ b/libglusterfs/src/changelog.h
@@ -16,101 +16,100 @@ struct gf_brick_spec;
 /**
  * Max bit shiter for event selection
  */
-#define CHANGELOG_EV_SELECTION_RANGE  5
-
-#define CHANGELOG_OP_TYPE_JOURNAL    (1<<0)
-#define CHANGELOG_OP_TYPE_OPEN       (1<<1)
-#define CHANGELOG_OP_TYPE_CREATE     (1<<2)
-#define CHANGELOG_OP_TYPE_RELEASE    (1<<3)
-#define CHANGELOG_OP_TYPE_BR_RELEASE (1<<4)  /* logical release (last close()),
-                                                sent by bitrot stub */
-#define CHANGELOG_OP_TYPE_MAX        (1<<CHANGELOG_EV_SELECTION_RANGE)
+#define CHANGELOG_EV_SELECTION_RANGE 5
 
+#define CHANGELOG_OP_TYPE_JOURNAL (1 << 0)
+#define CHANGELOG_OP_TYPE_OPEN (1 << 1)
+#define CHANGELOG_OP_TYPE_CREATE (1 << 2)
+#define CHANGELOG_OP_TYPE_RELEASE (1 << 3)
+#define CHANGELOG_OP_TYPE_BR_RELEASE                                           \
+    (1 << 4) /* logical release (last close()),                                \
+                sent by bitrot stub */
+#define CHANGELOG_OP_TYPE_MAX (1 << CHANGELOG_EV_SELECTION_RANGE)
 
 struct ev_open {
-        unsigned char gfid[16];
-        int32_t flags;
+    unsigned char gfid[16];
+    int32_t flags;
 };
 
 struct ev_creat {
-        unsigned char gfid[16];
-        int32_t flags;
+    unsigned char gfid[16];
+    int32_t flags;
 };
 
 struct ev_release {
-        unsigned char gfid[16];
+    unsigned char gfid[16];
 };
 
 struct ev_release_br {
-        unsigned long version;
-        unsigned char gfid[16];
-        int32_t sign_info;
+    unsigned long version;
+    unsigned char gfid[16];
+    int32_t sign_info;
 };
 
 struct ev_changelog {
-        char path[PATH_MAX];
+    char path[PATH_MAX];
 };
 
 typedef struct changelog_event {
-        unsigned int ev_type;
-
-        union {
-                struct ev_open open;
-                struct ev_creat create;
-                struct ev_release release;
-                struct ev_changelog journal;
-                struct ev_release_br releasebr;
-        } u;
+    unsigned int ev_type;
+
+    union {
+        struct ev_open open;
+        struct ev_creat create;
+        struct ev_release release;
+        struct ev_changelog journal;
+        struct ev_release_br releasebr;
+    } u;
 } changelog_event_t;
 
-#define CHANGELOG_EV_SIZE  (sizeof (changelog_event_t))
+#define CHANGELOG_EV_SIZE (sizeof(changelog_event_t))
 
 /**
  * event callback, connected & disconnection defs
  */
-typedef void (CALLBACK) (void *, char *,
-                        void *, changelog_event_t *);
-typedef void *(INIT) (void *, struct gf_brick_spec *);
-typedef void (FINI) (void *, char *, void *);
-typedef void (CONNECT) (void *, char *, void *);
-typedef void (DISCONNECT) (void *, char *, void *);
+typedef void(CALLBACK)(void *, char *, void *, changelog_event_t *);
+typedef void *(INIT)(void *, struct gf_brick_spec *);
+typedef void(FINI)(void *, char *, void *);
+typedef void(CONNECT)(void *, char *, void *);
+typedef void(DISCONNECT)(void *, char *, void *);
 
 struct gf_brick_spec {
-        char         *brick_path;
-        unsigned int  filter;
+    char *brick_path;
+    unsigned int filter;
 
-        INIT       *init;
-        FINI       *fini;
-        CALLBACK   *callback;
-        CONNECT    *connected;
-        DISCONNECT *disconnected;
+    INIT *init;
+    FINI *fini;
+    CALLBACK *callback;
+    CONNECT *connected;
+    DISCONNECT *disconnected;
 
-        void *ptr;
+    void *ptr;
 };
 
 /* API set */
 
 int
-gf_changelog_register (char *brick_path, char *scratch_dir,
-                       char *log_file, int log_levl, int max_reconnects);
+gf_changelog_register(char *brick_path, char *scratch_dir, char *log_file,
+                      int log_levl, int max_reconnects);
 ssize_t
-gf_changelog_scan ();
+gf_changelog_scan();
 
 int
-gf_changelog_start_fresh ();
+gf_changelog_start_fresh();
 
 ssize_t
-gf_changelog_next_change (char *bufptr, size_t maxlen);
+gf_changelog_next_change(char *bufptr, size_t maxlen);
 
 int
-gf_changelog_done (char *file);
+gf_changelog_done(char *file);
 
 /* newer flexible API */
 int
-gf_changelog_init (void *xl);
+gf_changelog_init(void *xl);
 
 int
-gf_changelog_register_generic (struct gf_brick_spec *bricks, int count,
-                               int ordered, char *logfile, int lvl, void *xl);
+gf_changelog_register_generic(struct gf_brick_spec *bricks, int count,
+                              int ordered, char *logfile, int lvl, void *xl);
 
 #endif
diff --git a/libglusterfs/src/checksum.c b/libglusterfs/src/checksum.c
index 5fac1330094..acdaed04ae2 100644
--- a/libglusterfs/src/checksum.c
+++ b/libglusterfs/src/checksum.c
@@ -9,8 +9,10 @@
 */
 
 #include <openssl/md5.h>
+#include <openssl/sha.h>
 #include <zlib.h>
 #include <stdint.h>
+#include <string.h>
 
 /*
  * The "weak" checksum required for the rsync algorithm.
@@ -20,17 +22,23 @@
  * data. Thus int32_t and uint32_t are sufficient
  */
 uint32_t
-gf_rsync_weak_checksum (unsigned char *buf, size_t len)
+gf_rsync_weak_checksum(unsigned char *buf, size_t len)
 {
-        return adler32 (0, buf, len);
+    return adler32(0, buf, len);
 }
 
-
 /*
  * The "strong" checksum required for the rsync algorithm.
  */
 void
-gf_rsync_strong_checksum (unsigned char *data, size_t len, unsigned char *md5)
+gf_rsync_strong_checksum(unsigned char *data, size_t len,
+                         unsigned char *sha256_md)
+{
+    SHA256((const unsigned char *)data, len, sha256_md);
+}
+
+void
+gf_rsync_md5_checksum(unsigned char *data, size_t len, unsigned char *md5)
 {
-        MD5 (data, len, md5);
+    MD5(data, len, md5);
 }
diff --git a/libglusterfs/src/circ-buff.c b/libglusterfs/src/circ-buff.c
index 6259282a917..913115c7be1 100644
--- a/libglusterfs/src/circ-buff.c
+++ b/libglusterfs/src/circ-buff.c
@@ -8,194 +8,186 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "circ-buff.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/circ-buff.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 void
-cb_destroy_data (circular_buffer_t *cb,
-                 void (*destroy_buffer_data) (void *data))
+cb_destroy_data(circular_buffer_t *cb, void (*destroy_buffer_data)(void *data))
 {
-        if (destroy_buffer_data)
-                destroy_buffer_data (cb->data);
-        GF_FREE (cb->data);
-        return;
+    if (destroy_buffer_data)
+        destroy_buffer_data(cb->data);
+    GF_FREE(cb->data);
+    return;
 }
 
-
 /* hold lock while calling this function */
 int
-__cb_add_entry_buffer (buffer_t *buffer, void *item)
+__cb_add_entry_buffer(buffer_t *buffer, void *item)
 {
-        circular_buffer_t   *ptr  = NULL;
-        int    ret   = -1;
-        //DO we really need the assert here?
-        GF_ASSERT (buffer->used_len <= buffer->size_buffer);
-
-        if (buffer->use_once == _gf_true &&
-            buffer->used_len == buffer->size_buffer) {
-                gf_msg  ("circ-buff", GF_LOG_WARNING, 0, LG_MSG_BUFFER_ERROR,
-                         "buffer %p is use once buffer", buffer);
-                return -1;
-        } else {
-                if (buffer->used_len == buffer->size_buffer) {
-                        if (buffer->cb[buffer->w_index]) {
-                                ptr = buffer->cb[buffer->w_index];
-                                if (ptr->data) {
-                                        cb_destroy_data (ptr,
-                                                   buffer->destroy_buffer_data);
-                                        ptr->data = NULL;
-                                        GF_FREE (ptr);
-                                }
-                                buffer->cb[buffer->w_index] = NULL;
-                                ptr = NULL;
-                        }
+    circular_buffer_t *ptr = NULL;
+    int ret = -1;
+    // DO we really need the assert here?
+    GF_ASSERT(buffer->used_len <= buffer->size_buffer);
+
+    if (buffer->use_once == _gf_true &&
+        buffer->used_len == buffer->size_buffer) {
+        gf_msg("circ-buff", GF_LOG_WARNING, 0, LG_MSG_BUFFER_ERROR,
+               "buffer %p is use once buffer", buffer);
+        return -1;
+    } else {
+        if (buffer->used_len == buffer->size_buffer) {
+            if (buffer->cb[buffer->w_index]) {
+                ptr = buffer->cb[buffer->w_index];
+                if (ptr->data) {
+                    cb_destroy_data(ptr, buffer->destroy_buffer_data);
+                    ptr->data = NULL;
+                    GF_FREE(ptr);
                 }
-
-                buffer->cb[buffer->w_index] =
-                        GF_CALLOC (1, sizeof (circular_buffer_t),
-                                   gf_common_mt_circular_buffer_t);
-                if (!buffer->cb[buffer->w_index])
-                        return -1;
-
-                buffer->cb[buffer->w_index]->data = item;
-                ret = gettimeofday (&buffer->cb[buffer->w_index]->tv, NULL);
-                if (ret == -1)
-                        gf_msg_callingfn ("circ-buff", GF_LOG_WARNING, 0,
-                                          LG_MSG_GETTIMEOFDAY_FAILED,
-                                          "getting time of the day failed");
-                buffer->w_index++;
-                buffer->w_index %= buffer->size_buffer;
-                //used_buffer size cannot be greater than the total buffer size
-
-                if (buffer->used_len < buffer->size_buffer)
-                        buffer->used_len++;
-                return buffer->w_index;
+                buffer->cb[buffer->w_index] = NULL;
+                ptr = NULL;
+            }
         }
+
+        buffer->cb[buffer->w_index] = GF_CALLOC(1, sizeof(circular_buffer_t),
+                                                gf_common_mt_circular_buffer_t);
+        if (!buffer->cb[buffer->w_index])
+            return -1;
+
+        buffer->cb[buffer->w_index]->data = item;
+        ret = gettimeofday(&buffer->cb[buffer->w_index]->tv, NULL);
+        if (ret == -1)
+            gf_msg_callingfn("circ-buff", GF_LOG_WARNING, 0,
+                             LG_MSG_GETTIMEOFDAY_FAILED,
+                             "getting time of the day failed");
+        buffer->w_index++;
+        buffer->w_index %= buffer->size_buffer;
+        // used_buffer size cannot be greater than the total buffer size
+
+        if (buffer->used_len < buffer->size_buffer)
+            buffer->used_len++;
+        return buffer->w_index;
+    }
 }
 
 int
-cb_add_entry_buffer (buffer_t *buffer, void *item)
+cb_add_entry_buffer(buffer_t *buffer, void *item)
 {
-        int write_index = -1;
+    int write_index = -1;
 
-        pthread_mutex_lock (&buffer->lock);
-        {
-                write_index = __cb_add_entry_buffer (buffer, item);
-        }
-        pthread_mutex_unlock (&buffer->lock);
+    pthread_mutex_lock(&buffer->lock);
+    {
+        write_index = __cb_add_entry_buffer(buffer, item);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 
-        return write_index;
+    return write_index;
 }
 
 void
-cb_buffer_show (buffer_t *buffer)
+cb_buffer_show(buffer_t *buffer)
 {
-        pthread_mutex_lock (&buffer->lock);
-        {
-                gf_msg_debug ("circ-buff", 0, "w_index: %d, size: %"
-                              GF_PRI_SIZET" used_buffer: %d", buffer->w_index,
-                              buffer->size_buffer, buffer->used_len);
-        }
-        pthread_mutex_unlock (&buffer->lock);
+    pthread_mutex_lock(&buffer->lock);
+    {
+        gf_msg_debug("circ-buff", 0,
+                     "w_index: %d, size: %" GF_PRI_SIZET " used_buffer: %d",
+                     buffer->w_index, buffer->size_buffer, buffer->used_len);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 }
 
 void
-cb_buffer_dump (buffer_t *buffer, void *data,
-                int (fn) (circular_buffer_t *buffer, void *data))
+cb_buffer_dump(buffer_t *buffer, void *data,
+               int(fn)(circular_buffer_t *buffer, void *data))
 {
-        int index = 0;
-        circular_buffer_t *entry = NULL;
-        int  entries = 0;
-        int ul = 0;
-        int w_ind = 0;
-        int size_buff = 0;
-        int i = 0;
-
-        ul = buffer->used_len;
-        w_ind = buffer->w_index;
-        size_buff = buffer->size_buffer;
-
-        pthread_mutex_lock (&buffer->lock);
-        {
-                if (buffer->use_once == _gf_false) {
-                        index = (size_buff + (w_ind - ul))%size_buff;
-                        for (entries = 0; entries < buffer->used_len;
-                             entries++) {
-                                entry = buffer->cb[index];
-                                if (entry)
-                                        fn (entry, data);
-                                else
-                                        gf_msg_callingfn ("circ-buff",
-                                                          GF_LOG_WARNING, 0,
-                                                          LG_MSG_NULL_PTR,
-                                                          "Null entry in "
-                                                          "circular buffer at "
-                                                          "index %d.", index);
-
-                                index++;
-                                index %= buffer->size_buffer;
-                        }
-                } else {
-                        for (i = 0; i < buffer->used_len ; i++) {
-                                entry = buffer->cb[i];
-                                fn (entry, data);
-                        }
-                }
+    int index = 0;
+    circular_buffer_t *entry = NULL;
+    int entries = 0;
+    int ul = 0;
+    int w_ind = 0;
+    int size_buff = 0;
+    int i = 0;
+
+    ul = buffer->used_len;
+    w_ind = buffer->w_index;
+    size_buff = buffer->size_buffer;
+
+    pthread_mutex_lock(&buffer->lock);
+    {
+        if (buffer->use_once == _gf_false) {
+            index = (size_buff + (w_ind - ul)) % size_buff;
+            for (entries = 0; entries < buffer->used_len; entries++) {
+                entry = buffer->cb[index];
+                if (entry)
+                    fn(entry, data);
+                else
+                    gf_msg_callingfn("circ-buff", GF_LOG_WARNING, 0,
+                                     LG_MSG_NULL_PTR,
+                                     "Null entry in "
+                                     "circular buffer at "
+                                     "index %d.",
+                                     index);
+
+                index++;
+                index %= buffer->size_buffer;
+            }
+        } else {
+            for (i = 0; i < buffer->used_len; i++) {
+                entry = buffer->cb[i];
+                fn(entry, data);
+            }
         }
-        pthread_mutex_unlock (&buffer->lock);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 }
 
 buffer_t *
-cb_buffer_new (size_t buffer_size, gf_boolean_t use_once,
-               void (*destroy_buffer_data) (void *data))
+cb_buffer_new(size_t buffer_size, gf_boolean_t use_once,
+              void (*destroy_buffer_data)(void *data))
 {
-        buffer_t    *buffer = NULL;
-
-        buffer = GF_CALLOC (1, sizeof (*buffer), gf_common_mt_buffer_t);
-        if (!buffer) {
-                goto out;
-        }
-
-        buffer->cb = GF_CALLOC (buffer_size,
-                                sizeof (circular_buffer_t *),
-                                gf_common_mt_circular_buffer_t);
-        if (!buffer->cb) {
-                GF_FREE (buffer);
-                buffer = NULL;
-                goto out;
-        }
-
-        buffer->w_index = 0;
-        buffer->size_buffer = buffer_size;
-        buffer->use_once = use_once;
-        buffer->used_len = 0;
-        buffer->destroy_buffer_data = destroy_buffer_data;
-        pthread_mutex_init (&buffer->lock, NULL);
+    buffer_t *buffer = NULL;
+
+    buffer = GF_CALLOC(1, sizeof(*buffer), gf_common_mt_buffer_t);
+    if (!buffer) {
+        goto out;
+    }
+
+    buffer->cb = GF_CALLOC(buffer_size, sizeof(circular_buffer_t *),
+                           gf_common_mt_circular_buffer_t);
+    if (!buffer->cb) {
+        GF_FREE(buffer);
+        buffer = NULL;
+        goto out;
+    }
+
+    buffer->w_index = 0;
+    buffer->size_buffer = buffer_size;
+    buffer->use_once = use_once;
+    buffer->used_len = 0;
+    buffer->destroy_buffer_data = destroy_buffer_data;
+    pthread_mutex_init(&buffer->lock, NULL);
 
 out:
-        return buffer;
+    return buffer;
 }
 
 void
-cb_buffer_destroy (buffer_t *buffer)
+cb_buffer_destroy(buffer_t *buffer)
 {
-        int                     i = 0;
-        circular_buffer_t       *ptr = NULL;
-        if (buffer) {
-                if (buffer->cb) {
-                        for (i = 0; i < buffer->used_len ; i++) {
-                                ptr = buffer->cb[i];
-                                if (ptr->data) {
-                                        cb_destroy_data (ptr,
-                                                   buffer->destroy_buffer_data);
-                                        ptr->data = NULL;
-                                        GF_FREE (ptr);
-                                }
-                        }
-                        GF_FREE (buffer->cb);
+    int i = 0;
+    circular_buffer_t *ptr = NULL;
+    if (buffer) {
+        if (buffer->cb) {
+            for (i = 0; i < buffer->used_len; i++) {
+                ptr = buffer->cb[i];
+                if (ptr->data) {
+                    cb_destroy_data(ptr, buffer->destroy_buffer_data);
+                    ptr->data = NULL;
+                    GF_FREE(ptr);
                 }
-                pthread_mutex_destroy (&buffer->lock);
-                GF_FREE (buffer);
+            }
+            GF_FREE(buffer->cb);
         }
+        pthread_mutex_destroy(&buffer->lock);
+        GF_FREE(buffer);
+    }
 }
-
diff --git a/libglusterfs/src/circ-buff.h b/libglusterfs/src/circ-buff.h
deleted file mode 100644
index e3459f5e3d0..00000000000
--- a/libglusterfs/src/circ-buff.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _CB_H
-#define _CB_H
-
-#include "common-utils.h"
-#include "logging.h"
-#include "mem-types.h"
-
-#define BUFFER_SIZE 10
-#define TOTAL_SIZE BUFFER_SIZE + 1
-
-
-struct _circular_buffer {
-        struct timeval tv;
-        void *data;
-};
-
-typedef struct _circular_buffer circular_buffer_t;
-
-struct _buffer {
-        unsigned int w_index;
-        size_t  size_buffer;
-        gf_boolean_t use_once;
-        /* This variable is assigned the proper value at the time of initing */
-        /* the buffer. It indicates, whether the buffer should be used once */
-        /*  it becomes full. */
-
-        int  used_len;
-        /* indicates the amount of circular buffer used. */
-
-        circular_buffer_t **cb;
-        void (*destroy_buffer_data) (void *data);
-        pthread_mutex_t   lock;
-};
-
-typedef struct _buffer buffer_t;
-
-int
-cb_add_entry_buffer (buffer_t *buffer, void *item);
-
-void
-cb_buffer_show (buffer_t *buffer);
-
-buffer_t *
-cb_buffer_new (size_t buffer_size,gf_boolean_t use_buffer_once,
-               void (*destroy_data) (void *data));
-
-void
-cb_buffer_destroy (buffer_t *buffer);
-
-void
-cb_buffer_dump (buffer_t *buffer, void *data,
-                int (fn) (circular_buffer_t *buffer, void *data));
-
-#endif /* _CB_H */
diff --git a/libglusterfs/src/client_t.c b/libglusterfs/src/client_t.c
index eda1c465827..9d377c3c2e1 100644
--- a/libglusterfs/src/client_t.c
+++ b/libglusterfs/src/client_t.c
@@ -8,660 +8,541 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "glusterfs.h"
-#include "dict.h"
-#include "statedump.h"
-#include "client_t.h"
-#include "list.h"
-#include "rpcsvc.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/dict.h"
+#include "glusterfs/statedump.h"
+#include "glusterfs/client_t.h"
+#include "glusterfs/list.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 static int
-gf_client_chain_client_entries (cliententry_t *entries, uint32_t startidx,
-                        uint32_t endcount)
+gf_client_chain_client_entries(cliententry_t *entries, uint32_t startidx,
+                               uint32_t endcount)
 {
-        uint32_t        i = 0;
+    uint32_t i = 0;
 
-        if (!entries) {
-                gf_msg_callingfn ("client_t", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!entries");
-                return -1;
-        }
+    if (!entries) {
+        gf_msg_callingfn("client_t", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!entries");
+        return -1;
+    }
 
-        /* Chain only till the second to last entry because we want to
-         * ensure that the last entry has GF_CLIENTTABLE_END.
-         */
-        for (i = startidx; i < (endcount - 1); i++)
-                entries[i].next_free = i + 1;
+    /* Chain only till the second to last entry because we want to
+     * ensure that the last entry has GF_CLIENTTABLE_END.
+     */
+    for (i = startidx; i < (endcount - 1); i++)
+        entries[i].next_free = i + 1;
 
-        /* i has already been incremented up to the last entry. */
-        entries[i].next_free = GF_CLIENTTABLE_END;
+    /* i has already been incremented up to the last entry. */
+    entries[i].next_free = GF_CLIENTTABLE_END;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-gf_client_clienttable_expand (clienttable_t *clienttable, uint32_t nr)
+gf_client_clienttable_expand(clienttable_t *clienttable, uint32_t nr)
 {
-        cliententry_t   *oldclients     = NULL;
-        uint32_t         oldmax_clients = -1;
-        int              ret            = -1;
-
-        if (clienttable == NULL || nr <= clienttable->max_clients) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                ret = EINVAL;
-                goto out;
-        }
-
-        oldclients = clienttable->cliententries;
-        oldmax_clients = clienttable->max_clients;
-
-        clienttable->cliententries = GF_CALLOC (nr, sizeof (cliententry_t),
-                                                gf_common_mt_cliententry_t);
-        if (!clienttable->cliententries) {
-                clienttable->cliententries = oldclients;
-                ret = 0;
-                goto out;
-        }
-        clienttable->max_clients = nr;
-
-        if (oldclients) {
-                uint32_t cpy = oldmax_clients * sizeof (cliententry_t);
-                memcpy (clienttable->cliententries, oldclients, cpy);
-        }
-
-        gf_client_chain_client_entries (clienttable->cliententries,
-                                        oldmax_clients,
-                                        clienttable->max_clients);
-
-        /* Now that expansion is done, we must update the client list
-         * head pointer so that the client allocation functions can continue
-         * using the expanded table.
-         */
-        clienttable->first_free = oldmax_clients;
-        GF_FREE (oldclients);
+    cliententry_t *oldclients = NULL;
+    uint32_t oldmax_clients = -1;
+    int ret = -1;
+
+    if (clienttable == NULL || nr <= clienttable->max_clients) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        ret = EINVAL;
+        goto out;
+    }
+
+    oldclients = clienttable->cliententries;
+    oldmax_clients = clienttable->max_clients;
+
+    clienttable->cliententries = GF_CALLOC(nr, sizeof(cliententry_t),
+                                           gf_common_mt_cliententry_t);
+    if (!clienttable->cliententries) {
+        clienttable->cliententries = oldclients;
         ret = 0;
+        goto out;
+    }
+    clienttable->max_clients = nr;
+
+    if (oldclients) {
+        uint32_t cpy = oldmax_clients * sizeof(cliententry_t);
+        memcpy(clienttable->cliententries, oldclients, cpy);
+    }
+
+    gf_client_chain_client_entries(clienttable->cliententries, oldmax_clients,
+                                   clienttable->max_clients);
+
+    /* Now that expansion is done, we must update the client list
+     * head pointer so that the client allocation functions can continue
+     * using the expanded table.
+     */
+    clienttable->first_free = oldmax_clients;
+    GF_FREE(oldclients);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 clienttable_t *
-gf_clienttable_alloc (void)
+gf_clienttable_alloc(void)
 {
-        clienttable_t *clienttable = NULL;
-        int            result = 0;
-
-        clienttable =
-                GF_CALLOC (1, sizeof (clienttable_t), gf_common_mt_clienttable_t);
-        if (!clienttable)
-                return NULL;
-
-        LOCK_INIT (&clienttable->lock);
-
-        result = gf_client_clienttable_expand (clienttable,
-                                               GF_CLIENTTABLE_INITIAL_SIZE);
-        if (result != 0) {
-                gf_msg ("client_t", GF_LOG_ERROR, 0,
-                        LG_MSG_EXPAND_CLIENT_TABLE_FAILED,
-                        "gf_client_clienttable_expand failed");
-                GF_FREE (clienttable);
-                return NULL;
-        }
-
-        return clienttable;
+    clienttable_t *clienttable = NULL;
+    int result = 0;
+
+    clienttable = GF_CALLOC(1, sizeof(clienttable_t),
+                            gf_common_mt_clienttable_t);
+    if (!clienttable)
+        return NULL;
+
+    LOCK_INIT(&clienttable->lock);
+
+    result = gf_client_clienttable_expand(clienttable,
+                                          GF_CLIENTTABLE_INITIAL_SIZE);
+    if (result != 0) {
+        gf_msg("client_t", GF_LOG_ERROR, 0, LG_MSG_EXPAND_CLIENT_TABLE_FAILED,
+               "gf_client_clienttable_expand failed");
+        GF_FREE(clienttable);
+        return NULL;
+    }
+
+    return clienttable;
 }
 
-
-void
-gf_client_clienttable_destroy (clienttable_t *clienttable)
-{
-        client_t         *client        = NULL;
-        cliententry_t    *cliententries = NULL;
-        uint32_t          client_count  = 0;
-        int32_t           i             = 0;
-
-        if (!clienttable) {
-                gf_msg_callingfn ("client_t", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!clienttable");
-                return;
-        }
-
-        LOCK (&clienttable->lock);
-        {
-                client_count = clienttable->max_clients;
-                clienttable->max_clients = 0;
-                cliententries = clienttable->cliententries;
-                clienttable->cliententries = NULL;
-        }
-        UNLOCK (&clienttable->lock);
-
-        if (cliententries != NULL) {
-                for (i = 0; i < client_count; i++) {
-                        client = cliententries[i].client;
-                        if (client != NULL) {
-                                gf_client_unref (client);
-                        }
-                }
-
-                GF_FREE (cliententries);
-                LOCK_DESTROY (&clienttable->lock);
-                GF_FREE (clienttable);
-        }
-}
-
-
 /*
  * Increments ref.bind if the client is already present or creates a new
  * client with ref.bind = 1,ref.count = 1 it signifies that
  * as long as ref.bind is > 0 client should be alive.
  */
 client_t *
-gf_client_get (xlator_t *this, struct rpcsvc_auth_data *cred, char *client_uid,
-               char *subdir_mount)
+gf_client_get(xlator_t *this, client_auth_data_t *cred, char *client_uid,
+              char *subdir_mount)
 {
-        client_t      *client      = NULL;
-        cliententry_t *cliententry = NULL;
-        clienttable_t *clienttable = NULL;
-        unsigned int   i           = 0;
-
-        if (this == NULL || client_uid == NULL) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
-
-        clienttable = this->ctx->clienttable;
-
-        LOCK (&clienttable->lock);
-        {
-                for (; i < clienttable->max_clients; i++) {
-                        client = clienttable->cliententries[i].client;
-                        if (client == NULL)
-                                continue;
-                        /*
-                         * look for matching client_uid, _and_
-                         * if auth was used, matching auth flavour and data
-                         */
-                        if (strcmp (client_uid, client->client_uid) == 0 &&
-                                (cred->flavour != AUTH_NONE &&
-                                        (cred->flavour == client->auth.flavour &&
-                                        (size_t) cred->datalen == client->auth.len &&
-                                        memcmp (cred->authdata,
-                                                client->auth.data,
-                                                client->auth.len) == 0))) {
-                                GF_ATOMIC_INC (client->bind);
-                                goto unlock;
-                        }
-                }
-
-                client = GF_CALLOC (1, sizeof(client_t), gf_common_mt_client_t);
-                if (client == NULL) {
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-
-                client->this = this;
-                if (subdir_mount != NULL)
-                        client->subdir_mount = gf_strdup (subdir_mount);
-
-                LOCK_INIT (&client->scratch_ctx.lock);
-
-                client->client_uid = gf_strdup (client_uid);
-                if (client->client_uid == NULL) {
-                        GF_FREE (client);
-                        client = NULL;
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-                client->scratch_ctx.count = GF_CLIENTCTX_INITIAL_SIZE;
-                client->scratch_ctx.ctx =
-                        GF_CALLOC (GF_CLIENTCTX_INITIAL_SIZE,
-                                   sizeof (struct client_ctx),
-                                   gf_common_mt_client_ctx);
-                if (client->scratch_ctx.ctx == NULL) {
-                        GF_FREE (client->client_uid);
-                        GF_FREE (client);
-                        client = NULL;
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-
-                GF_ATOMIC_INIT (client->bind, 1);
-                GF_ATOMIC_INIT (client->count, 1);
-
-                client->auth.flavour = cred->flavour;
-                if (cred->flavour != AUTH_NONE) {
-                        client->auth.data =
-                                GF_CALLOC (1, cred->datalen,
-                                           gf_common_mt_client_t);
-                        if (client->auth.data == NULL) {
-                                GF_FREE (client->scratch_ctx.ctx);
-                                GF_FREE (client->client_uid);
-                                GF_FREE (client);
-                                client = NULL;
-                                errno = ENOMEM;
-                                goto unlock;
-                        }
-                        memcpy (client->auth.data, cred->authdata,
-                                cred->datalen);
-                        client->auth.len = cred->datalen;
-                }
-
-                client->tbl_index = clienttable->first_free;
-                cliententry = &clienttable->cliententries[clienttable->first_free];
-                if (cliententry->next_free == GF_CLIENTTABLE_END) {
-                        int result =
-                                gf_client_clienttable_expand (clienttable,
-                                        clienttable->max_clients +
-                                                GF_CLIENTTABLE_INITIAL_SIZE);
-                        if (result != 0) {
-                                GF_FREE (client->scratch_ctx.ctx);
-                                GF_FREE (client->client_uid);
-                                GF_FREE (client);
-                                client = NULL;
-                                errno = result;
-                                goto unlock;
-                        }
-                        cliententry = &clienttable->cliententries[client->tbl_index];
-                        cliententry->next_free = clienttable->first_free;
-                }
-                cliententry->client = client;
-                clienttable->first_free = cliententry->next_free;
-                cliententry->next_free = GF_CLIENTENTRY_ALLOCATED;
-        }
+    client_t *client = NULL;
+    cliententry_t *cliententry = NULL;
+    clienttable_t *clienttable = NULL;
+    unsigned int i = 0;
+
+    if (this == NULL || client_uid == NULL) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
+
+    clienttable = this->ctx->clienttable;
+
+    LOCK(&clienttable->lock);
+    {
+        for (; i < clienttable->max_clients; i++) {
+            client = clienttable->cliententries[i].client;
+            if (client == NULL)
+                continue;
+            /*
+             * look for matching client_uid, _and_
+             * if auth was used, matching auth flavour and data
+             */
+            if (strcmp(client_uid, client->client_uid) == 0 &&
+                (cred->flavour && (cred->flavour == client->auth.flavour &&
+                                   (size_t)cred->datalen == client->auth.len &&
+                                   memcmp(cred->authdata, client->auth.data,
+                                          client->auth.len) == 0))) {
+                GF_ATOMIC_INC(client->bind);
+                goto unlock;
+            }
+        }
+
+        client = GF_CALLOC(1, sizeof(client_t), gf_common_mt_client_t);
+        if (client == NULL) {
+            errno = ENOMEM;
+            goto unlock;
+        }
+
+        client->this = this;
+        if (subdir_mount != NULL)
+            client->subdir_mount = gf_strdup(subdir_mount);
+
+        LOCK_INIT(&client->scratch_ctx.lock);
+
+        client->client_uid = gf_strdup(client_uid);
+        if (client->client_uid == NULL) {
+            GF_FREE(client);
+            client = NULL;
+            errno = ENOMEM;
+            goto unlock;
+        }
+        client->scratch_ctx.count = GF_CLIENTCTX_INITIAL_SIZE;
+        client->scratch_ctx.ctx = GF_CALLOC(GF_CLIENTCTX_INITIAL_SIZE,
+                                            sizeof(struct client_ctx),
+                                            gf_common_mt_client_ctx);
+        if (client->scratch_ctx.ctx == NULL) {
+            GF_FREE(client->client_uid);
+            GF_FREE(client);
+            client = NULL;
+            errno = ENOMEM;
+            goto unlock;
+        }
+
+        GF_ATOMIC_INIT(client->bind, 1);
+        GF_ATOMIC_INIT(client->count, 1);
+        GF_ATOMIC_INIT(client->fd_cnt, 0);
+
+        client->auth.flavour = cred->flavour;
+        if (cred->flavour) {
+            client->auth.data = GF_MALLOC(cred->datalen, gf_common_mt_client_t);
+            if (client->auth.data == NULL) {
+                GF_FREE(client->scratch_ctx.ctx);
+                GF_FREE(client->client_uid);
+                GF_FREE(client);
+                client = NULL;
+                errno = ENOMEM;
+                goto unlock;
+            }
+            memcpy(client->auth.data, cred->authdata, cred->datalen);
+            client->auth.len = cred->datalen;
+        }
+
+        client->tbl_index = clienttable->first_free;
+        cliententry = &clienttable->cliententries[clienttable->first_free];
+        if (cliententry->next_free == GF_CLIENTTABLE_END) {
+            int result = gf_client_clienttable_expand(
+                clienttable,
+                clienttable->max_clients + GF_CLIENTTABLE_INITIAL_SIZE);
+            if (result != 0) {
+                GF_FREE(client->scratch_ctx.ctx);
+                GF_FREE(client->client_uid);
+                GF_FREE(client);
+                client = NULL;
+                errno = result;
+                goto unlock;
+            }
+            cliententry = &clienttable->cliententries[client->tbl_index];
+            cliententry->next_free = clienttable->first_free;
+        }
+        cliententry->client = client;
+        clienttable->first_free = cliententry->next_free;
+        cliententry->next_free = GF_CLIENTENTRY_ALLOCATED;
+    }
 unlock:
-        UNLOCK (&clienttable->lock);
-
-        if (client)
-                gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
-                                  "%s: bind_ref: %"GF_PRI_ATOMIC", ref: "
-                                  "%"GF_PRI_ATOMIC, client->client_uid,
-                                  GF_ATOMIC_GET (client->bind),
-                                  GF_ATOMIC_GET (client->count));
-        return client;
+    UNLOCK(&clienttable->lock);
+
+    if (client)
+        gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
+                         "%s: bind_ref: %" GF_PRI_ATOMIC
+                         ", ref: "
+                         "%" GF_PRI_ATOMIC,
+                         client->client_uid, GF_ATOMIC_GET(client->bind),
+                         GF_ATOMIC_GET(client->count));
+    return client;
 }
 
 void
-gf_client_put (client_t *client, gf_boolean_t *detached)
+gf_client_put(client_t *client, gf_boolean_t *detached)
 {
-        gf_boolean_t unref = _gf_false;
-        int bind_ref;
-
-        if (client == NULL)
-                goto out;
-
+    gf_boolean_t unref = _gf_false;
+    int bind_ref;
+
+    if (client == NULL)
+        goto out;
+
+    if (detached)
+        *detached = _gf_false;
+
+    bind_ref = GF_ATOMIC_DEC(client->bind);
+    if (bind_ref == 0)
+        unref = _gf_true;
+
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
+                     "%s: "
+                     "bind_ref: %" GF_PRI_ATOMIC ", ref: %" GF_PRI_ATOMIC
+                     ", "
+                     "unref: %d",
+                     client->client_uid, GF_ATOMIC_GET(client->bind),
+                     GF_ATOMIC_GET(client->count), unref);
+    if (unref) {
         if (detached)
-                *detached = _gf_false;
-
-        bind_ref = GF_ATOMIC_DEC (client->bind);
-        if (bind_ref == 0)
-                unref = _gf_true;
-
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF, "%s: "
-                          "bind_ref: %"GF_PRI_ATOMIC", ref: %"GF_PRI_ATOMIC", "
-                          "unref: %d", client->client_uid,
-                          GF_ATOMIC_GET (client->bind),
-                          GF_ATOMIC_GET (client->count), unref);
-        if (unref) {
-                if (detached)
-                        *detached = _gf_true;
-                gf_client_unref (client);
-        }
+            *detached = _gf_true;
+        gf_client_unref(client);
+    }
 
 out:
-        return;
+    return;
 }
 
 client_t *
-gf_client_ref (client_t *client)
+gf_client_ref(client_t *client)
 {
-        if (!client) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "null client");
-                return NULL;
-        }
-
-        GF_ATOMIC_INC (client->count);
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT, "%s: "
-                          "ref-count %"GF_PRI_ATOMIC, client->client_uid,
-                          GF_ATOMIC_GET (client->count));
-        return client;
+    if (!client) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "null client");
+        return NULL;
+    }
+
+    GF_ATOMIC_INC(client->count);
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT,
+                     "%s: "
+                     "ref-count %" GF_PRI_ATOMIC,
+                     client->client_uid, GF_ATOMIC_GET(client->count));
+    return client;
 }
 
-
 static void
-gf_client_destroy_recursive (xlator_t *xl, client_t *client)
+gf_client_destroy_recursive(xlator_t *xl, client_t *client)
 {
-        xlator_list_t   *trav;
+    xlator_list_t *trav;
 
-        if (xl->cbks->client_destroy) {
-                xl->cbks->client_destroy (xl, client);
-        }
+    if (!xl->call_cleanup && xl->cbks->client_destroy) {
+        xl->cbks->client_destroy(xl, client);
+    }
 
-        for (trav = xl->children; trav; trav = trav->next) {
-                gf_client_destroy_recursive (trav->xlator, client);
-        }
+    for (trav = xl->children; trav; trav = trav->next) {
+        gf_client_destroy_recursive(trav->xlator, client);
+    }
 }
 
-
 static void
-client_destroy (client_t *client)
+client_destroy(client_t *client)
 {
-        clienttable_t     *clienttable = NULL;
-        glusterfs_graph_t *gtrav       = NULL;
-
-        if (client == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                goto out;
-        }
-
-        clienttable = client->this->ctx->clienttable;
-
-        LOCK_DESTROY (&client->scratch_ctx.lock);
-
-        LOCK (&clienttable->lock);
-        {
-                clienttable->cliententries[client->tbl_index].client = NULL;
-                clienttable->cliententries[client->tbl_index].next_free =
-                        clienttable->first_free;
-                clienttable->first_free = client->tbl_index;
-        }
-        UNLOCK (&clienttable->lock);
-
-        list_for_each_entry (gtrav, &client->this->ctx->graphs, list) {
-                gf_client_destroy_recursive (gtrav->top, client);
-        }
-
-        if (client->subdir_inode)
-                inode_unref (client->subdir_inode);
-
-        GF_FREE (client->auth.data);
-        GF_FREE (client->auth.username);
-        GF_FREE (client->auth.passwd);
-        GF_FREE (client->scratch_ctx.ctx);
-        GF_FREE (client->client_uid);
-        GF_FREE (client->subdir_mount);
-        GF_FREE (client);
+    clienttable_t *clienttable = NULL;
+    glusterfs_graph_t *gtrav = NULL;
+
+    if (client == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        goto out;
+    }
+
+    clienttable = client->this->ctx->clienttable;
+
+    LOCK(&clienttable->lock);
+    {
+        clienttable->cliententries[client->tbl_index].client = NULL;
+        clienttable->cliententries[client->tbl_index]
+            .next_free = clienttable->first_free;
+        clienttable->first_free = client->tbl_index;
+    }
+    UNLOCK(&clienttable->lock);
+
+    list_for_each_entry(gtrav, &client->this->ctx->graphs, list)
+    {
+        gf_client_destroy_recursive(gtrav->top, client);
+    }
+
+    if (client->subdir_inode)
+        inode_unref(client->subdir_inode);
+
+    LOCK_DESTROY(&client->scratch_ctx.lock);
+
+    GF_FREE(client->auth.data);
+    GF_FREE(client->auth.username);
+    GF_FREE(client->auth.passwd);
+    GF_FREE(client->scratch_ctx.ctx);
+    GF_FREE(client->client_uid);
+    GF_FREE(client->subdir_mount);
+    GF_FREE(client->client_name);
+    GF_FREE(client);
 out:
-        return;
+    return;
 }
 
 static int
-gf_client_disconnect_recursive (xlator_t *xl, client_t *client)
+gf_client_disconnect_recursive(xlator_t *xl, client_t *client)
 {
-        int             ret     = 0;
-        xlator_list_t   *trav;
+    int ret = 0;
+    xlator_list_t *trav;
 
-        if (xl->cbks->client_disconnect) {
-                ret = xl->cbks->client_disconnect (xl, client);
-        }
+    if (!xl->call_cleanup && xl->cbks->client_disconnect) {
+        ret = xl->cbks->client_disconnect(xl, client);
+    }
 
-        for (trav = xl->children; trav; trav = trav->next) {
-                ret |= gf_client_disconnect_recursive (trav->xlator, client);
-        }
+    for (trav = xl->children; trav; trav = trav->next) {
+        ret |= gf_client_disconnect_recursive(trav->xlator, client);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-gf_client_disconnect (client_t *client)
+gf_client_disconnect(client_t *client)
 {
-        int                ret   = 0;
-        glusterfs_graph_t *gtrav = NULL;
+    int ret = 0;
+    glusterfs_graph_t *gtrav = NULL;
 
-        list_for_each_entry (gtrav, &client->this->ctx->graphs, list) {
-                ret |= gf_client_disconnect_recursive (gtrav->top, client);
-        }
+    list_for_each_entry(gtrav, &client->this->ctx->graphs, list)
+    {
+        ret |= gf_client_disconnect_recursive(gtrav->top, client);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 void
-gf_client_unref (client_t *client)
+gf_client_unref(client_t *client)
 {
-        uint64_t refcount;
+    uint64_t refcount;
 
-        if (!client) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "client is NULL");
-                return;
-        }
-
-        refcount = GF_ATOMIC_DEC (client->count);
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT, "%s: "
-                          "ref-count %"GF_PRI_ATOMIC, client->client_uid,
-                          refcount);
-        if (refcount == 0) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_DISCONNECT_CLIENT,
-                        "Shutting down connection %s", client->client_uid);
-                client_destroy (client);
-        }
+    if (!client) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "client is NULL");
+        return;
+    }
+
+    refcount = GF_ATOMIC_DEC(client->count);
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT,
+                     "%s: "
+                     "ref-count %" GF_PRI_ATOMIC,
+                     client->client_uid, refcount);
+    if (refcount == 0) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, LG_MSG_DISCONNECT_CLIENT,
+               "Shutting down connection %s", client->client_uid);
+        client_destroy(client);
+    }
 }
 
-
 static int
-__client_ctx_get_int (client_t *client, void *key, void **value)
+__client_ctx_get_int(client_t *client, void *key, void **value)
 {
-        int index = 0;
-        int ret   = 0;
+    int index = 0;
+    int ret = 0;
 
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (client->scratch_ctx.ctx[index].ctx_key == key)
-                        break;
-        }
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (client->scratch_ctx.ctx[index].ctx_key == key)
+            break;
+    }
 
-        if (index == client->scratch_ctx.count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == client->scratch_ctx.count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = client->scratch_ctx.ctx[index].ctx_value;
+    if (value)
+        *value = client->scratch_ctx.ctx[index].ctx_value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__client_ctx_set_int (client_t *client, void *key, void *value)
+__client_ctx_set_int(client_t *client, void *key, void *value)
 {
-        int index   = 0;
-        int ret     = 0;
-        int set_idx = -1;
-
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (!client->scratch_ctx.ctx[index].ctx_key) {
-                        if (set_idx == -1)
-                                set_idx = index;
-                        /* dont break, to check if key already exists
-                           further on */
-                }
-                if (client->scratch_ctx.ctx[index].ctx_key == key) {
-                        set_idx = index;
-                        break;
-                }
-        }
+    int index = 0;
+    int ret = 0;
+    int set_idx = -1;
 
-        if (set_idx == -1) {
-                ret = -1;
-                goto out;
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (!client->scratch_ctx.ctx[index].ctx_key) {
+            if (set_idx == -1)
+                set_idx = index;
+            /* don't break, to check if key already exists
+               further on */
         }
+        if (client->scratch_ctx.ctx[index].ctx_key == key) {
+            set_idx = index;
+            break;
+        }
+    }
+
+    if (set_idx == -1) {
+        ret = -1;
+        goto out;
+    }
 
-        client->scratch_ctx.ctx[set_idx].ctx_key = key;
-        client->scratch_ctx.ctx[set_idx].ctx_value  = value;
+    client->scratch_ctx.ctx[set_idx].ctx_key = key;
+    client->scratch_ctx.ctx[set_idx].ctx_value = value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /*will return success with old value if exist*/
 void *
-client_ctx_set (client_t *client, void *key, void *value)
+client_ctx_set(client_t *client, void *key, void *value)
 {
-        int ret = 0;
-        void *ret_value = NULL;
-
-        if (!client || !key || !value)
-                return NULL;
-
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_get_int (client, key, &ret_value);
-                if (!ret && ret_value) {
-                        UNLOCK (&client->scratch_ctx.lock);
-                        return ret_value;
-                }
+    int ret = 0;
+    void *ret_value = NULL;
 
-                ret = __client_ctx_set_int (client, key, value);
+    if (!client || !key || !value)
+        return NULL;
+
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_get_int(client, key, &ret_value);
+        if (!ret && ret_value) {
+            UNLOCK(&client->scratch_ctx.lock);
+            return ret_value;
         }
-        UNLOCK (&client->scratch_ctx.lock);
 
-        if (ret)
-                return NULL;
-        return value;
-}
+        ret = __client_ctx_set_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
+    if (ret)
+        return NULL;
+    return value;
+}
 
 int
-client_ctx_get (client_t *client, void *key, void **value)
+client_ctx_get(client_t *client, void *key, void **value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!client || !key)
-                return -1;
+    if (!client || !key)
+        return -1;
 
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_get_int (client, key, value);
-        }
-        UNLOCK (&client->scratch_ctx.lock);
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_get_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__client_ctx_del_int (client_t *client, void *key, void **value)
+__client_ctx_del_int(client_t *client, void *key, void **value)
 {
-        int index = 0;
-        int ret   = 0;
+    int index = 0;
+    int ret = 0;
 
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (client->scratch_ctx.ctx[index].ctx_key == key)
-                        break;
-        }
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (client->scratch_ctx.ctx[index].ctx_key == key)
+            break;
+    }
 
-        if (index == client->scratch_ctx.count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == client->scratch_ctx.count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = client->scratch_ctx.ctx[index].ctx_value;
+    if (value)
+        *value = client->scratch_ctx.ctx[index].ctx_value;
 
-        client->scratch_ctx.ctx[index].ctx_key   = 0;
-        client->scratch_ctx.ctx[index].ctx_value = 0;
+    client->scratch_ctx.ctx[index].ctx_key = 0;
+    client->scratch_ctx.ctx[index].ctx_value = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-client_ctx_del (client_t *client, void *key, void **value)
+client_ctx_del(client_t *client, void *key, void **value)
 {
-        int ret = 0;
-
-        if (!client || !key)
-                return -1;
-
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_del_int (client, key, value);
-        }
-        UNLOCK (&client->scratch_ctx.lock);
-
-        return ret;
-}
+    int ret = 0;
 
+    if (!client || !key)
+        return -1;
 
-void
-client_dump (client_t *client, char *prefix)
-{
-        char key[GF_DUMP_MAX_BUF_LEN];
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_del_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
-        if (!client)
-                return;
-
-        memset(key, 0, sizeof key);
-        gf_proc_dump_write("refcount", GF_PRI_ATOMIC,
-                           GF_ATOMIC_GET (client->count));
+    return ret;
 }
 
-
 void
-cliententry_dump (cliententry_t *cliententry, char *prefix)
-{
-        if (!cliententry)
-                return;
-
-        if (GF_CLIENTENTRY_ALLOCATED != cliententry->next_free)
-                return;
-
-        if (cliententry->client)
-                client_dump(cliententry->client, prefix);
-}
-
-
-void
-clienttable_dump (clienttable_t *clienttable, char *prefix)
-{
-        int     i   = 0;
-        int     ret = -1;
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0};
-
-        if (!clienttable)
-                return;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return;
-                }
-                memset(key, 0, sizeof key);
-                gf_proc_dump_build_key(key, prefix, "maxclients");
-                gf_proc_dump_write(key, "%d", clienttable->max_clients);
-                gf_proc_dump_build_key(key, prefix, "first_free");
-                gf_proc_dump_write(key, "%d", clienttable->first_free);
-                for ( i = 0 ; i < clienttable->max_clients; i++) {
-                        if (GF_CLIENTENTRY_ALLOCATED ==
-                            clienttable->cliententries[i].next_free) {
-                                gf_proc_dump_build_key(key, prefix,
-                                                       "cliententry[%d]", i);
-                                gf_proc_dump_add_section(key);
-                                cliententry_dump(&clienttable->cliententries[i],
-                                                 key);
-                        }
-                }
-        }
-        UNLOCK(&clienttable->lock);
-}
-
-
-void
-client_ctx_dump (client_t *client, char *prefix)
+client_ctx_dump(client_t *client, char *prefix)
 {
 #if 0 /* TBD, FIXME */
         struct client_ctx   *client_ctx = NULL;
@@ -704,250 +585,241 @@ out:
 #endif
 }
 
-
 /*
  * the following functions are here to preserve legacy behavior of the
  * protocol/server xlator dump, but perhaps they should just be folded
  * into the client dump instead?
  */
 int
-gf_client_dump_fdtables_to_dict (xlator_t *this, dict_t *dict)
+gf_client_dump_fdtables_to_dict(xlator_t *this, dict_t *dict)
 {
-        clienttable_t  *clienttable = NULL;
-        int             count       = 0;
-        int             ret         = -1;
+    clienttable_t *clienttable = NULL;
+    int count = 0;
+    int ret = -1;
 #ifdef NOTYET
-        client_t       *client      = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
+    client_t *client = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
 #endif
 
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, dict, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, dict, out);
 
-        clienttable = this->ctx->clienttable;
+    clienttable = this->ctx->clienttable;
 
-        if (!clienttable)
-                return -1;
+    if (!clienttable)
+        return -1;
 
 #ifdef NOTYET
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        memset(key, 0, sizeof key);
-                        snprintf (key, sizeof key, "conn%d", count++);
-                        fdtable_dump_to_dict (client->server_ctx.fdtable,
-                                              key, dict);
-                }
-        }
-        UNLOCK(&clienttable->lock);
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->bound_xl &&
+                !strcmp(client->bound_xl->name, this->name)) {
+                snprintf(key, sizeof(key), "conn%d", count++);
+                fdtable_dump_to_dict(client->server_ctx.fdtable, key, dict);
+            }
+        }
+    }
+    UNLOCK(&clienttable->lock);
 #endif
 
-        ret = dict_set_int32 (dict, "conncount", count);
+    ret = dict_set_int32(dict, "conncount", count);
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_client_dump_fdtables (xlator_t *this)
+gf_client_dump_fdtables(xlator_t *this)
 {
-        client_t       *client = NULL;
-        clienttable_t  *clienttable = NULL;
-        int             count = 1;
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                return -1;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-
-
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        memset(key, 0, sizeof key);
-                        if (client->client_uid) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.id", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->client_uid);
-                        }
-
-                        if (client->subdir_mount) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.subdir", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->subdir_mount);
-                        }
-                        gf_proc_dump_build_key (key, "conn", "%d.ref",
-                                                        count);
-                        gf_proc_dump_write (key, GF_PRI_ATOMIC,
-                                            GF_ATOMIC_GET (client->count));
-                        if (client->bound_xl) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.bound_xl", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->bound_xl->name);
-                        }
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    int count = 1;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        return -1;
+
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->client_uid) {
+                gf_proc_dump_build_key(key, "conn", "%d.id", count);
+                gf_proc_dump_write(key, "%s", client->client_uid);
+            }
+
+            if (client->subdir_mount) {
+                gf_proc_dump_build_key(key, "conn", "%d.subdir", count);
+                gf_proc_dump_write(key, "%s", client->subdir_mount);
+            }
+            gf_proc_dump_build_key(key, "conn", "%d.ref", count);
+            gf_proc_dump_write(key, "%" GF_PRI_ATOMIC,
+                               GF_ATOMIC_GET(client->count));
+            if (client->bound_xl) {
+                gf_proc_dump_build_key(key, "conn", "%d.bound_xl", count);
+                gf_proc_dump_write(key, "%s", client->bound_xl->name);
+            }
 
 #ifdef NOTYET
-                        gf_proc_dump_build_key (key, "conn","%d.id", count);
-                        fdtable_dump (client->server_ctx.fdtable, key);
+            gf_proc_dump_build_key(key, "conn", "%d.id", count);
+            fdtable_dump(client->server_ctx.fdtable, key);
 #endif
-                }
         }
+    }
 
-        UNLOCK(&clienttable->lock);
+    UNLOCK(&clienttable->lock);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-gf_client_dump_inodes_to_dict (xlator_t *this, dict_t *dict)
+gf_client_dump_inodes_to_dict(xlator_t *this, dict_t *dict)
 {
-        client_t       *client        = NULL;
-        clienttable_t  *clienttable   = NULL;
-        xlator_t       *prev_bound_xl = NULL;
-        char            key[32]       = {0,};
-        int             count         = 0;
-        int             ret           = -1;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, dict, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                return -1;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        memset(key, 0, sizeof key);
-                        if (client->bound_xl && client->bound_xl->itable) {
-                                /* Presently every brick contains only
-                                 * one bound_xl for all connections.
-                                 * This will lead to duplicating of
-                                 *  the inode lists, if listing is
-                                 * done for every connection. This
-                                 * simple check prevents duplication
-                                 * in the present case. If need arises
-                                 * the check can be improved.
-                                 */
-                                if (client->bound_xl == prev_bound_xl)
-                                        continue;
-                                prev_bound_xl = client->bound_xl;
-
-                                memset (key, 0, sizeof (key));
-                                snprintf (key, sizeof (key), "conn%d", count);
-                                inode_table_dump_to_dict (client->bound_xl->itable,
-                                                          key, dict);
-                        }
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    xlator_t *prev_bound_xl = NULL;
+    char key[32] = {
+        0,
+    };
+    int count = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, dict, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        return -1;
+
+    ret = LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (!strcmp(client->bound_xl->name, this->name)) {
+                if (client->bound_xl && client->bound_xl->itable) {
+                    /* Presently every brick contains only
+                     * one bound_xl for all connections.
+                     * This will lead to duplicating of
+                     *  the inode lists, if listing is
+                     * done for every connection. This
+                     * simple check prevents duplication
+                     * in the present case. If need arises
+                     * the check can be improved.
+                     */
+                    if (client->bound_xl == prev_bound_xl)
+                        continue;
+                    prev_bound_xl = client->bound_xl;
+
+                    snprintf(key, sizeof(key), "conn%d", count);
+                    inode_table_dump_to_dict(client->bound_xl->itable, key,
+                                             dict);
                 }
+            }
         }
-        UNLOCK(&clienttable->lock);
+    }
+    UNLOCK(&clienttable->lock);
 
-        ret = dict_set_int32 (dict, "conncount", count);
+    ret = dict_set_int32(dict, "conncount", count);
 
 out:
-        if (prev_bound_xl)
-                prev_bound_xl = NULL;
-        return ret;
+    if (prev_bound_xl)
+        prev_bound_xl = NULL;
+    return ret;
 }
 
 int
-gf_client_dump_inodes (xlator_t *this)
+gf_client_dump_inodes(xlator_t *this)
 {
-        client_t       *client        = NULL;
-        clienttable_t  *clienttable   = NULL;
-        xlator_t       *prev_bound_xl = NULL;
-        int             count         = 0;
-        int             ret           = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                goto out;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        goto out;
-                }
-
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        memset(key, 0, sizeof key);
-                        if (client->bound_xl && client->bound_xl->itable) {
-                                /* Presently every brick contains only
-                                 * one bound_xl for all connections.
-                                 * This will lead to duplicating of
-                                 * the inode lists, if listing is
-                                 * done for every connection. This
-                                 * simple check prevents duplication
-                                 * in the present case. If need arises
-                                 * the check can be improved.
-                                 */
-                                if (client->bound_xl == prev_bound_xl)
-                                        continue;
-                                prev_bound_xl = client->bound_xl;
-
-                                gf_proc_dump_build_key(key, "conn",
-                                                       "%d.bound_xl.%s", count,
-                                                       client->bound_xl->name);
-                                inode_table_dump(client->bound_xl->itable,key);
-                        }
-                }
-        }
-        UNLOCK(&clienttable->lock);
-
-        ret = 0;
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    xlator_t *prev_bound_xl = NULL;
+    int count = 0;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        goto out;
+
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            goto out;
+        }
+
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->bound_xl && client->bound_xl->itable) {
+                /* Presently every brick contains only
+                 * one bound_xl for all connections.
+                 * This will lead to duplicating of
+                 * the inode lists, if listing is
+                 * done for every connection. This
+                 * simple check prevents duplication
+                 * in the present case. If need arises
+                 * the check can be improved.
+                 */
+                if (client->bound_xl == prev_bound_xl)
+                    continue;
+                prev_bound_xl = client->bound_xl;
+
+                gf_proc_dump_build_key(key, "conn", "%d.bound_xl.%s", count,
+                                       client->bound_xl->name);
+                inode_table_dump(client->bound_xl->itable, key);
+            }
+        }
+    }
+    UNLOCK(&clienttable->lock);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
-
diff --git a/libglusterfs/src/client_t.h b/libglusterfs/src/client_t.h
deleted file mode 100644
index 530c0a331ea..00000000000
--- a/libglusterfs/src/client_t.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _CLIENT_T_H
-#define _CLIENT_T_H
-
-#include "glusterfs.h"
-#include "locking.h"  /* for gf_lock_t, not included by glusterfs.h */
-#include "atomic.h" /* for gf_atomic_t */
-
-struct client_ctx {
-        void     *ctx_key;
-        void     *ctx_value;
-};
-
-typedef struct _client {
-        struct {
-                /* e.g. protocol/server stashes its ctx here */
-                gf_lock_t            lock;
-                unsigned short       count;
-                struct client_ctx   *ctx;
-        }            scratch_ctx;
-        gf_atomic_t                  bind;
-        gf_atomic_t                  count;
-        xlator_t    *bound_xl;
-        xlator_t    *this;
-        int          tbl_index;
-        char        *client_uid;
-        struct {
-                int                  flavour;
-                size_t               len;
-                char                *data;
-                char                *username;
-                char                *passwd;
-        }            auth;
-
-        /* subdir_mount */
-        char    *subdir_mount;
-        inode_t *subdir_inode;
-        uuid_t   subdir_gfid;
-} client_t;
-
-#define GF_CLIENTCTX_INITIAL_SIZE 8
-
-struct client_table_entry {
-        client_t            *client;
-        int                  next_free;
-};
-typedef struct client_table_entry cliententry_t;
-
-struct clienttable {
-        unsigned int         max_clients;
-        gf_lock_t            lock;
-        cliententry_t       *cliententries;
-        int                  first_free;
-	client_t            *local;
-};
-typedef struct clienttable clienttable_t;
-
-#define GF_CLIENTTABLE_INITIAL_SIZE 128
-
-/* Signifies no more entries in the client table. */
-#define GF_CLIENTTABLE_END  -1
-
-/* This is used to invalidate
- * the next_free value in an cliententry that has been allocated
- */
-#define GF_CLIENTENTRY_ALLOCATED    -2
-
-struct rpcsvc_auth_data;
-
-client_t *
-gf_client_get (xlator_t *this, struct rpcsvc_auth_data *cred,
-               char *client_uid, char *subdir_mount);
-
-void
-gf_client_put (client_t *client, gf_boolean_t *detached);
-
-clienttable_t *
-gf_clienttable_alloc (void);
-
-void
-gf_client_clienttable_destroy (clienttable_t *clienttable);
-
-client_t *
-gf_client_ref (client_t *client);
-
-void
-gf_client_unref (client_t *client);
-
-int
-gf_client_dump_fdtable_to_dict (xlator_t *this, dict_t *dict);
-
-int
-gf_client_dump_fdtable (xlator_t *this);
-
-int
-gf_client_dump_inodes_to_dict (xlator_t *this, dict_t *dict);
-
-int
-gf_client_dump_inodes (xlator_t *this);
-
-void *
-client_ctx_set (client_t *client, void *key, void *value);
-
-int
-client_ctx_get (client_t *client, void *key, void **value);
-
-int
-client_ctx_del (client_t *client, void *key, void **value);
-
-void
-client_ctx_dump (client_t *client, char *prefix);
-
-int
-gf_client_dump_fdtables_to_dict (xlator_t *this, dict_t *dict);
-
-int
-gf_client_dump_fdtables (xlator_t *this);
-
-int
-gf_client_dump_inodes_to_dict (xlator_t *this, dict_t *dict);
-
-int
-gf_client_dump_inodes (xlator_t *this);
-
-int
-gf_client_disconnect (client_t *client);
-
-#endif /* _CLIENT_T_H */
diff --git a/libglusterfs/src/cluster-syncop.c b/libglusterfs/src/cluster-syncop.c
index b7f4dfe7701..6ee89ddfdcf 100644
--- a/libglusterfs/src/cluster-syncop.c
+++ b/libglusterfs/src/cluster-syncop.c
@@ -14,530 +14,499 @@
 /* NOTE: Cluster-syncop, like syncop blocks the executing thread until the
  * responses are gathered if it is not executed as part of synctask. So it
  * shouldn't be invoked in epoll worker thread */
-#include "cluster-syncop.h"
-#include "defaults.h"
-
-#define FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fop, args ...) do {\
-        int __i = 0;                                                    \
-        int __count = 0;					        \
-        cluster_local_t __local = {0,};                                 \
-        void    *__old_local = frame->local;                            \
-                                                                        \
-        __local.replies = replies;                                      \
-        memset (output, 0, numsubvols);                                 \
-        cluster_replies_wipe (replies, numsubvols);                     \
-        for (__i = 0; __i < numsubvols; __i++)                          \
-                INIT_LIST_HEAD (&replies[__i].entries.list);            \
-        if (syncbarrier_init (&__local.barrier))                        \
-                break;                                                  \
-        frame->local = &__local;                                        \
-        for (__i = 0; __i < numsubvols; __i++) {                        \
-                if (on[__i]) {                                          \
-                        __count++;                                      \
-                }                                                       \
-        }                                                               \
-        __local.barrier.waitfor = __count;                              \
-        for (__i = 0; __i < numsubvols; __i++) {		        \
-                if (!on[__i])                                           \
-                        continue;				        \
-                STACK_WIND_COOKIE (frame, cluster_##fop##_cbk,          \
-                                   (void *)(long) __i, subvols[__i],    \
-                                   subvols[__i]->fops->fop, args);      \
-        }								\
-        syncbarrier_wait (&__local.barrier, __count);			\
-        syncbarrier_destroy (&__local.barrier);                         \
-        frame->local = __old_local;                                     \
-        STACK_RESET (frame->root);                                      \
-        } while (0)
-
-#define FOP_SEQ(subvols, on, numsubvols, replies, output, frame, fop, args ...) do {\
-        int __i = 0;					                \
-                                                                        \
-        cluster_local_t __local = {0,};                                 \
-        void    *__old_local = frame->local;                            \
-        __local.replies = replies;                                      \
-        memset (output, 0, numsubvols);                                 \
-        cluster_replies_wipe (replies, numsubvols);                     \
-        for (__i = 0; __i < numsubvols; __i++)                          \
-                INIT_LIST_HEAD (&replies[__i].entries.list);            \
-        if (syncbarrier_init (&__local.barrier))                        \
-                break;                                                  \
-        frame->local = &__local;                                        \
-        for (__i = 0; __i < numsubvols; __i++) {		        \
-                if (!on[__i])                                           \
-                        continue;				        \
-                STACK_WIND_COOKIE (frame, cluster_##fop##_cbk,          \
-                                   (void *)(long) __i, subvols[__i],    \
-                                   subvols[__i]->fops->fop, args);      \
-                syncbarrier_wait (&__local.barrier, 1);                 \
-        }                                                               \
-        syncbarrier_destroy (&__local.barrier);                         \
-        frame->local = __old_local;                                     \
-        STACK_RESET (frame->root);                                      \
-        } while (0)
-
-#define FOP_CBK(fop, frame, cookie, args ...) do {\
-        cluster_local_t *__local = frame->local;                        \
-        int __i = (long)cookie;                                         \
-        args_##fop##_cbk_store (&__local->replies[__i], args);          \
-        __local->replies[__i].valid = 1;                                \
-        syncbarrier_wake (&__local->barrier);                           \
-        } while (0)
-
-int32_t
-cluster_fop_success_fill (default_args_cbk_t *replies, int numsubvols,
-                          unsigned char *success)
-{
-        int i = 0;
-        int count = 0;
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].valid && replies[i].op_ret >= 0) {
-                        success[i] = 1;
-                        count++;
-                } else {
-                        success[i] = 0;
-                }
+#include "glusterfs/cluster-syncop.h"
+#include "glusterfs/defaults.h"
+
+#define FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fop,       \
+                   args...)                                                    \
+    do {                                                                       \
+        int __i = 0;                                                           \
+        int __count = 0;                                                       \
+        cluster_local_t __local = {                                            \
+            0,                                                                 \
+        };                                                                     \
+        void *__old_local = frame->local;                                      \
+                                                                               \
+        __local.replies = replies;                                             \
+        memset(output, 0, numsubvols);                                         \
+        cluster_replies_wipe(replies, numsubvols);                             \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+        if (syncbarrier_init(&__local.barrier))                                \
+            break;                                                             \
+        frame->local = &__local;                                               \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (on[__i]) {                                                     \
+                __count++;                                                     \
+            }                                                                  \
+        }                                                                      \
+        __local.barrier.waitfor = __count;                                     \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (!on[__i])                                                      \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, cluster_##fop##_cbk, (void *)(long)__i,   \
+                              subvols[__i], subvols[__i]->fops->fop, args);    \
+        }                                                                      \
+        syncbarrier_wait(&__local.barrier, __count);                           \
+        syncbarrier_destroy(&__local.barrier);                                 \
+        frame->local = __old_local;                                            \
+        STACK_RESET(frame->root);                                              \
+    } while (0)
+
+#define FOP_SEQ(subvols, on, numsubvols, replies, output, frame, fop, args...) \
+    do {                                                                       \
+        int __i = 0;                                                           \
+                                                                               \
+        cluster_local_t __local = {                                            \
+            0,                                                                 \
+        };                                                                     \
+        void *__old_local = frame->local;                                      \
+        __local.replies = replies;                                             \
+        memset(output, 0, numsubvols);                                         \
+        cluster_replies_wipe(replies, numsubvols);                             \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+        if (syncbarrier_init(&__local.barrier))                                \
+            break;                                                             \
+        frame->local = &__local;                                               \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (!on[__i])                                                      \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, cluster_##fop##_cbk, (void *)(long)__i,   \
+                              subvols[__i], subvols[__i]->fops->fop, args);    \
+            syncbarrier_wait(&__local.barrier, 1);                             \
+        }                                                                      \
+        syncbarrier_destroy(&__local.barrier);                                 \
+        frame->local = __old_local;                                            \
+        STACK_RESET(frame->root);                                              \
+    } while (0)
+
+#define FOP_CBK(fop, frame, cookie, args...)                                   \
+    do {                                                                       \
+        cluster_local_t *__local = frame->local;                               \
+        int __i = (long)cookie;                                                \
+        args_##fop##_cbk_store(&__local->replies[__i], args);                  \
+        __local->replies[__i].valid = 1;                                       \
+        syncbarrier_wake(&__local->barrier);                                   \
+    } while (0)
+
+int32_t
+cluster_fop_success_fill(default_args_cbk_t *replies, int numsubvols,
+                         unsigned char *success)
+{
+    int i = 0;
+    int count = 0;
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret >= 0) {
+            success[i] = 1;
+            count++;
+        } else {
+            success[i] = 0;
         }
+    }
 
-        return count;
+    return count;
 }
 
 void
-cluster_replies_wipe (default_args_cbk_t *replies, int numsubvols)
+cluster_replies_wipe(default_args_cbk_t *replies, int numsubvols)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!replies)
-                return;
+    if (!replies)
+        return;
 
-        for (i = 0; i < numsubvols; i++)
-                args_cbk_wipe (&replies[i]);
-        memset (replies, 0, numsubvols * sizeof (*replies));
+    for (i = 0; i < numsubvols; i++)
+        args_cbk_wipe(&replies[i]);
+    memset(replies, 0, numsubvols * sizeof(*replies));
 }
 
 int32_t
-cluster_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, dict_t *xdata, struct iatt *postparent)
+cluster_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, dict_t *xdata, struct iatt *postparent)
 {
-        FOP_CBK (lookup, frame, cookie, op_ret, op_errno, inode, buf,
-                 xdata, postparent);
-        return 0;
+    FOP_CBK(lookup, frame, cookie, op_ret, op_errno, inode, buf, xdata,
+            postparent);
+    return 0;
 }
 
 int32_t
-cluster_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                  dict_t *xdata)
+cluster_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata)
 {
-        FOP_CBK (stat, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(stat, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
+int32_t
+cluster_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
+{
+    FOP_CBK(truncate, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
+}
 
 int32_t
-cluster_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf,
-                      dict_t *xdata)
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (truncate, frame, cookie, op_ret, op_errno, prebuf,
-                 postbuf, xdata);
-        return 0;
+    FOP_CBK(ftruncate, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf,
-                       dict_t *xdata)
+cluster_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (ftruncate, frame, cookie, op_ret, op_errno, prebuf,
-                 postbuf, xdata);
-        return 0;
+    FOP_CBK(access, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno,
-                    dict_t *xdata)
+cluster_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, const char *path,
+                     struct iatt *buf, dict_t *xdata)
 {
-        FOP_CBK (access, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(readlink, frame, cookie, op_ret, op_errno, path, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, const char *path,
-                      struct iatt *buf, dict_t *xdata)
+cluster_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (readlink, frame, cookie, op_ret, op_errno, path, buf,
-                 xdata);
-        return 0;
+    FOP_CBK(mknod, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
+int32_t
+cluster_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
+{
+    FOP_CBK(mkdir, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
+}
 
 int32_t
-cluster_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
+cluster_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
                    struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (mknod, frame, cookie, op_ret, op_errno, inode,
-                 buf, preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(unlink, frame, cookie, op_ret, op_errno, preparent, postparent,
+            xdata);
+    return 0;
 }
 
 int32_t
-cluster_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+cluster_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (mkdir, frame, cookie, op_ret, op_errno, inode,
-                 buf, preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(rmdir, frame, cookie, op_ret, op_errno, preparent, postparent,
+            xdata);
+    return 0;
 }
 
 int32_t
-cluster_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+cluster_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
                     struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (unlink, frame, cookie, op_ret, op_errno, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(symlink, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent,
+cluster_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
                    dict_t *xdata)
 {
-        FOP_CBK (rmdir, frame, cookie, op_ret, op_errno, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(rename, frame, cookie, op_ret, op_errno, buf, preoldparent,
+            postoldparent, prenewparent, postnewparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+cluster_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (symlink, frame, cookie, op_ret, op_errno, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(link, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
+cluster_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (rename, frame, cookie, op_ret, op_errno, buf, preoldparent,
-                 postoldparent, prenewparent, postnewparent, xdata);
-        return 0;
+    FOP_CBK(create, frame, cookie, op_ret, op_errno, fd, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent,
-                  dict_t *xdata)
+cluster_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        FOP_CBK (link, frame, cookie, op_ret, op_errno, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(open, frame, cookie, op_ret, op_errno, fd, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent,
-                    dict_t *xdata)
+cluster_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                  dict_t *xdata)
 {
-        FOP_CBK (create, frame, cookie, op_ret, op_errno, fd, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(readv, frame, cookie, op_ret, op_errno, vector, count, stbuf,
+            iobref, xdata);
+    return 0;
 }
 
 int32_t
-cluster_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd,
-                  dict_t *xdata)
+cluster_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (open, frame, cookie, op_ret, op_errno, fd, xdata);
-        return 0;
+    FOP_CBK(writev, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                   dict_t *xdata)
+cluster_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (readv, frame, cookie, op_ret, op_errno, vector, count,
-                 stbuf, iobref, xdata);
-        return 0;
+    FOP_CBK(put, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf,
-                    dict_t *xdata)
+cluster_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (writev, frame, cookie, op_ret, op_errno, prebuf, postbuf,
-                 xdata);
-        return 0;
+    FOP_CBK(flush, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno,
-                   dict_t *xdata)
+cluster_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (flush, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fsync, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
-
-
 int32_t
-cluster_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf,
-                   dict_t *xdata)
+cluster_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  dict_t *xdata)
 {
-        FOP_CBK (fsync, frame, cookie, op_ret, op_errno, prebuf, postbuf,
-                 xdata);
-        return 0;
+    FOP_CBK(fstat, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                   dict_t *xdata)
+cluster_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        FOP_CBK (fstat, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(opendir, frame, cookie, op_ret, op_errno, fd, xdata);
+    return 0;
 }
 
 int32_t
-cluster_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, fd_t *fd,
-                     dict_t *xdata)
+cluster_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (opendir, frame, cookie, op_ret, op_errno, fd, xdata);
-        return 0;
+    FOP_CBK(fsyncdir, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                   dict_t *xdata)
 {
-        FOP_CBK (fsyncdir, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(statfs, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct statvfs *buf,
-                    dict_t *xdata)
+cluster_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (statfs, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(setxattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (setxattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fsetxattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+cluster_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
-        FOP_CBK (fsetxattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fgetxattr, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
-
 int32_t
-cluster_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict,
-                       dict_t *xdata)
+cluster_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
 {
-        FOP_CBK (fgetxattr, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(getxattr, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict,
-                      dict_t *xdata)
+cluster_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata)
 {
-        FOP_CBK (getxattr, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(xattrop, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-cluster_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, dict_t *dict,
                      dict_t *xdata)
 {
-        FOP_CBK (xattrop, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(fxattrop, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict,
-                      dict_t *xdata)
+cluster_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (fxattrop, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(removexattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+cluster_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (removexattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fremovexattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          dict_t *xdata)
+cluster_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+               dict_t *xdata)
 {
-        FOP_CBK (fremovexattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(lk, frame, cookie, op_ret, op_errno, lock, xdata);
+    return 0;
 }
 
 int32_t
-cluster_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-                dict_t *xdata)
+cluster_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (lk, frame, cookie, op_ret, op_errno, lock, xdata);
-        return 0;
+    FOP_CBK(inodelk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     dict_t *xdata)
+cluster_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (inodelk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(finodelk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (finodelk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(entrylk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     dict_t *xdata)
+cluster_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (entrylk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fentrylk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                      uint8_t *strong_checksum, dict_t *xdata)
 {
-        FOP_CBK (fentrylk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(rchecksum, frame, cookie, op_ret, op_errno, weak_checksum,
+            strong_checksum, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
-                       uint8_t *strong_checksum,
-                       dict_t *xdata)
+cluster_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
 {
-        FOP_CBK (rchecksum, frame, cookie, op_ret, op_errno, weak_checksum,
-                             strong_checksum, xdata);
-        return 0;
+    FOP_CBK(readdir, frame, cookie, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
                      dict_t *xdata)
 {
-        FOP_CBK (readdir, frame, cookie, op_ret, op_errno, entries, xdata);
-        return 0;
+    FOP_CBK(readdirp, frame, cookie, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                      dict_t *xdata)
+cluster_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                    struct iatt *statpost, dict_t *xdata)
 {
-        FOP_CBK (readdirp, frame, cookie, op_ret, op_errno, entries, xdata);
-        return 0;
+    FOP_CBK(setattr, frame, cookie, op_ret, op_errno, statpre, statpost, xdata);
+    return 0;
 }
 
 int32_t
-cluster_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                     struct iatt *statpost,
-                     dict_t *xdata)
+                     struct iatt *statpost, dict_t *xdata)
 {
-        FOP_CBK (setattr, frame, cookie, op_ret, op_errno, statpre,
-                 statpost, xdata);
-        return 0;
-}
-
-int32_t
-cluster_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                      struct iatt *statpost,
-                      dict_t *xdata)
-{
-        FOP_CBK (fsetattr, frame, cookie, op_ret, op_errno, statpre,
-                 statpost, xdata);
-        return 0;
+    FOP_CBK(fsetattr, frame, cookie, op_ret, op_errno, statpre, statpost,
+            xdata);
+    return 0;
 }
 
 int32_t
@@ -545,8 +514,8 @@ cluster_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *pre,
                       struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (fallocate, frame, cookie, op_ret, op_errno, pre, post, xdata);
-        return 0;
+    FOP_CBK(fallocate, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
 int32_t
@@ -554,640 +523,739 @@ cluster_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
                     struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (discard, frame, cookie, op_ret, op_errno, pre, post, xdata);
-        return 0;
+    FOP_CBK(discard, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
 int32_t
 cluster_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                    struct iatt *post, dict_t *xdata)
+                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                     struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (zerofill, frame, cookie, op_ret, op_errno, pre,
-                 post, xdata);
-        return 0;
+    FOP_CBK(zerofill, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
+cluster_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (ipc, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(ipc, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fgetxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   const char *name, dict_t *xdata)
-{
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fgetxattr, fd,
-                    name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
-}
-
-int32_t
-cluster_fsetxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                   int32_t flags, dict_t *xdata)
+cluster_fgetxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd,
+                  const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsetxattr, fd,
-                    dict, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fgetxattr, fd,
+               name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_setxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fsetxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
                   default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
                   int32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, setxattr, loc,
-                    dict, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsetxattr, fd,
+               dict, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_statfs (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_setxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                 int32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, statfs, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, setxattr, loc,
+               dict, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsyncdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-                  dict_t *xdata)
+cluster_statfs(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsyncdir, fd,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, statfs, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_opendir (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fsyncdir(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
                  dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, opendir, loc,
-                    fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsyncdir, fd,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fstat (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+cluster_opendir(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fstat, fd,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, opendir, loc,
+               fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsync (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-               dict_t *xdata)
+cluster_fstat(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsync, fd,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fstat, fd,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_flush (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+cluster_fsync(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+              dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, flush, fd,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsync, fd,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_writev (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, fd_t *fd,
-                struct iovec *vector, int32_t count, off_t off, uint32_t flags,
-                struct iobref *iobref, dict_t *xdata)
+cluster_flush(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, writev, fd,
-                    vector, count, off, flags, iobref, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, flush, fd,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_readv (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_writev(xlator_t **subvols, unsigned char *on, int numsubvols,
                default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-               off_t offset, uint32_t flags, dict_t *xdata)
+               call_frame_t *frame, xlator_t *this, fd_t *fd,
+               struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+               struct iobref *iobref, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readv, fd, size,
-                    offset, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, writev, fd,
+               vector, count, off, flags, iobref, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
+int32_t
+cluster_put(xlator_t **subvols, unsigned char *on, int numsubvols,
+            default_args_cbk_t *replies, unsigned char *output,
+            call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+            off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata)
+{
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, put, loc, mode,
+               umask, flags, vector, count, offset, iobref, xattr, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int32_t
-cluster_open (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_readv(xlator_t **subvols, unsigned char *on, int numsubvols,
               default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-              fd_t *fd, dict_t *xdata)
+              call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+              off_t offset, uint32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, open, loc,
-                    flags, fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readv, fd, size,
+               offset, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_create (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-                mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+cluster_open(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, create, loc,
-                    flags, mode, umask, fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, open, loc,
+               flags, fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_link (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-              dict_t *xdata)
+cluster_create(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+               mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, link, oldloc,
-                    newloc, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, create, loc,
+               flags, mode, umask, fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_rename (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-                loc_t *newloc, dict_t *xdata)
+cluster_link(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rename, oldloc,
-                    newloc, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, link, oldloc,
+               newloc, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
+int32_t
+cluster_rename(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+               loc_t *newloc, dict_t *xdata)
+{
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rename, oldloc,
+               newloc, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int
-cluster_symlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, const char *linkpath,
-                 loc_t *loc, mode_t umask, dict_t *xdata)
+cluster_symlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, const char *linkpath,
+                loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, symlink,
-                    linkpath, loc, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, symlink,
+               linkpath, loc, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_rmdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-               dict_t *xdata)
+cluster_rmdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+              dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rmdir, loc,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rmdir, loc,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_unlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-                dict_t *xdata)
+cluster_unlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+               dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, unlink, loc,
-                    xflag, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, unlink, loc,
+               xflag, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_mkdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               mode_t umask, dict_t *xdata)
+cluster_mkdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, mkdir, loc,
-                    mode, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, mkdir, loc,
+               mode, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int
-cluster_mknod (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               dev_t rdev, mode_t umask, dict_t *xdata)
+cluster_mknod(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, mknod, loc,
-                    mode, rdev, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, mknod, loc,
+               mode, rdev, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_readlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-                  dict_t *xdata)
+cluster_readlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                 dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readlink, loc,
-                    size, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readlink, loc,
+               size, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_access (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-                dict_t *xdata)
+cluster_access(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+               dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, access, loc,
-                    mask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, access, loc,
+               mask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_ftruncate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   dict_t *xdata)
+cluster_ftruncate(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, ftruncate, fd,
-                    offset, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, ftruncate, fd,
+               offset, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_getxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  const char *name, dict_t *xdata)
+cluster_getxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, getxattr, loc,
-                    name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, getxattr, loc,
+               name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
+int32_t
+cluster_xattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+{
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, xattrop, loc,
+               flags, dict, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int32_t
-cluster_xattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fxattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, xattrop, loc,
-                    flags, dict, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fxattrop, fd,
+               flags, dict, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fxattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+cluster_removexattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                    default_args_cbk_t *replies, unsigned char *output,
+                    call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fxattrop, fd,
-                    flags, dict, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, removexattr,
+               loc, name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_removexattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fremovexattr(xlator_t **subvols, unsigned char *on, int numsubvols,
                      default_args_cbk_t *replies, unsigned char *output,
-                     call_frame_t *frame, xlator_t *this, loc_t *loc,
+                     call_frame_t *frame, xlator_t *this, fd_t *fd,
                      const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, removexattr,
-                    loc, name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fremovexattr,
+               fd, name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fremovexattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                      default_args_cbk_t *replies, unsigned char *output,
-                      call_frame_t *frame, xlator_t *this, fd_t *fd,
-                      const char *name, dict_t *xdata)
+cluster_lk(xlator_t **subvols, unsigned char *on, int numsubvols,
+           default_args_cbk_t *replies, unsigned char *output,
+           call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+           struct gf_flock *lock, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fremovexattr,
-                    fd, name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, lk, fd, cmd,
+               lock, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_lk (xlator_t **subvols, unsigned char *on, int numsubvols,
-            default_args_cbk_t *replies, unsigned char *output,
-            call_frame_t *frame, xlator_t *this, fd_t *fd,
-            int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+cluster_rchecksum(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  int32_t len, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, lk, fd, cmd,
-                    lock, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rchecksum, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_rchecksum (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   int32_t len, dict_t *xdata)
+cluster_readdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t off, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rchecksum, fd,
-                    offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readdir, fd,
+               size, off, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_readdir (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_readdirp(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 size_t size, off_t off, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readdir, fd,
-                    size, off, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readdirp, fd,
+               size, off, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_readdirp (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  size_t size, off_t off, dict_t *xdata)
+cluster_setattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readdirp, fd,
-                    size, off, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, setattr, loc,
+               stbuf, valid, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_setattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_truncate(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
-                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                 dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, setattr, loc,
-                    stbuf, valid, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, truncate, loc,
+               offset, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_truncate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-                  dict_t *xdata)
+cluster_stat(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, truncate, loc,
-                    offset, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, stat, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_stat (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_lookup(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, stat, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, lookup, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_lookup (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_fsetattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, lookup, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsetattr, fd,
+               stbuf, valid, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsetattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fallocate(xlator_t **subvols, unsigned char *on, int numsubvols,
                   default_args_cbk_t *replies, unsigned char *output,
                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  struct iatt *stbuf, int32_t valid, dict_t *xdata)
+                  int32_t keep_size, off_t offset, size_t len, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsetattr, fd,
-                    stbuf, valid, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fallocate, fd,
+               keep_size, offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fallocate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   int32_t keep_size, off_t offset, size_t len, dict_t *xdata)
-{
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fallocate, fd,
-                   keep_size, offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
-}
-
-int32_t
-cluster_discard (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 off_t offset, size_t len, dict_t *xdata)
+cluster_discard(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                size_t len, dict_t *xdata)
 {
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, discard, fd,
-                   offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, discard, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
 cluster_zerofill(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 off_t offset, off_t len, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                 off_t len, dict_t *xdata)
 {
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, zerofill, fd,
-                   offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, zerofill, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_ipc (xlator_t **subvols, unsigned char *on, int numsubvols,
-             default_args_cbk_t *replies, unsigned char *output,
-             call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+cluster_ipc(xlator_t **subvols, unsigned char *on, int numsubvols,
+            default_args_cbk_t *replies, unsigned char *output,
+            call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, ipc, op, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, ipc, op, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_uninodelk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, char *dom,
-                   inode_t *inode, off_t off, size_t size)
+cluster_uninodelk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, off_t off, size_t size)
 {
-        loc_t loc = {0,};
-        struct gf_flock flock = {0, };
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    flock.l_type = F_UNLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-        flock.l_type = F_UNLCK;
-        flock.l_start = off;
-        flock.l_len = size;
+    FOP_ONLIST(subvols, locked_on, numsubvols, replies, output, frame, inodelk,
+               dom, &loc, F_SETLK, &flock, NULL);
 
-        FOP_ONLIST (subvols, locked_on, numsubvols, replies, output, frame, inodelk,
-                    dom, &loc, F_SETLK, &flock, NULL);
+    loc_wipe(&loc);
 
-        loc_wipe (&loc);
-
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_tryinodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, off_t off, size_t size)
+cluster_tryinodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
+                   call_frame_t *frame, xlator_t *this, char *dom,
+                   inode_t *inode, off_t off, size_t size)
 {
-        struct gf_flock flock = {0, };
-        loc_t loc = {0};
+    struct gf_flock flock = {
+        0,
+    };
+    loc_t loc = {0};
 
-        flock.l_type = F_WRLCK;
-        flock.l_start = off;
-        flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
-                    &loc, F_SETLK, &flock, NULL);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_inodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, off_t off, size_t size)
-{
-        struct gf_flock flock = {0, };
-        int i = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-
-        flock.l_type = F_WRLCK;
-        flock.l_start = off;
-        flock.l_len = size;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    inodelk, dom, &loc, F_SETLK, &flock, NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_uninodelk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom, inode, off, size);
-
-                        FOP_SEQ (subvols, on, numsubvols, replies, locked_on,
-                                 frame, inodelk, dom, &loc, F_SETLKW, &flock,
-                                 NULL);
-                        break;
-                }
+cluster_inodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                off_t off, size_t size)
+{
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_uninodelk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, off, size);
+
+            FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame, inodelk,
+                    dom, &loc, F_SETLKW, &flock, NULL);
+            break;
         }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
+int
+cluster_unentrylk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, const char *name)
+{
+    loc_t loc = {
+        0,
+    };
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    FOP_ONLIST(subvols, locked_on, numsubvols, replies, output, frame, entrylk,
+               dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
+
+    loc_wipe(&loc);
+
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int
-cluster_unentrylk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
+cluster_tryentrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
                    call_frame_t *frame, xlator_t *this, char *dom,
                    inode_t *inode, const char *name)
 {
-        loc_t loc = {0,};
-
+    loc_t loc = {0};
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-        FOP_ONLIST (subvols, locked_on, numsubvols, replies, output, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK,
-                    NULL);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
+}
 
-        loc_wipe (&loc);
+int
+cluster_entrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                const char *name)
+{
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_unentrylk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, name);
+            FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame, entrylk,
+                    dom, &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+            break;
+        }
+    }
 
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_tryentrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, const char *name)
-{
-        loc_t loc = {0};
+cluster_tiebreaker_inodelk(xlator_t **subvols, unsigned char *on,
+                           int numsubvols, default_args_cbk_t *replies,
+                           unsigned char *locked_on, call_frame_t *frame,
+                           xlator_t *this, char *dom, inode_t *inode, off_t off,
+                           size_t size)
+{
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0;
+    int num_success = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            num_success++;
+            continue;
+        }
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
+        /* TODO: If earlier subvols fail with an error other
+         * than EAGAIN, we could still have 2 clients competing
+         * for the lock*/
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_uninodelk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, off, size);
+
+            if (num_success) {
+                FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame,
+                        inodelk, dom, &loc, F_SETLKW, &flock, NULL);
+            } else {
+                loc_wipe(&loc);
+                memset(locked_on, 0, numsubvols);
+                return 0;
+            }
+            break;
+        }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_entrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, const char *name)
-{
-        int i = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_unentrylk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom,
-                                           inode, name);
-                        FOP_SEQ (subvols, on, numsubvols, replies,
-                                 locked_on, frame, entrylk, dom, &loc, name,
-                                 ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                        break;
-                }
+cluster_tiebreaker_entrylk(xlator_t **subvols, unsigned char *on,
+                           int numsubvols, default_args_cbk_t *replies,
+                           unsigned char *locked_on, call_frame_t *frame,
+                           xlator_t *this, char *dom, inode_t *inode,
+                           const char *name)
+{
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+    int num_success = 0;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            num_success++;
+            continue;
+        }
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_unentrylk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, name);
+            if (num_success) {
+                FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame,
+                        entrylk, dom, &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK,
+                        NULL);
+            } else {
+                loc_wipe(&loc);
+                memset(locked_on, 0, numsubvols);
+                return 0;
+            }
+            break;
         }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
diff --git a/libglusterfs/src/cluster-syncop.h b/libglusterfs/src/cluster-syncop.h
deleted file mode 100644
index ff9387acace..00000000000
--- a/libglusterfs/src/cluster-syncop.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-  Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-
-#ifndef _CLUSTER_SYNCOP_H
-#define _CLUSTER_SYNCOP_H
-
-#include "xlator.h"
-#include <sys/time.h>
-#include <pthread.h>
-#include <ucontext.h>
-#include "defaults.h"
-#include "default-args.h"
-#include "syncop.h"
-
-/*********************************************************************
- *
- * PARALLEL_FOP_ONLIST:
- *          Performs file operations in parallel on bricks.
- * This macro expects a helper function(func) to implement the
- * functionality.
- *
- ********************************************************************/
-#define PARALLEL_FOP_ONLIST(subvols, on, numsubvols, replies, frame,    \
-                            func, args ...)                             \
-do {                                                                    \
-        int __i = 0;                                                    \
-        int __count = 0;                                                \
-        cluster_local_t __local = {0,};                                 \
-        void    *__old_local = frame->local;                            \
-                                                                        \
-        __local.replies = replies;                                      \
-        cluster_replies_wipe (replies, numsubvols);                     \
-        for (__i = 0; __i < numsubvols; __i++)                          \
-                INIT_LIST_HEAD (&replies[__i].entries.list);            \
-        if (syncbarrier_init (&__local.barrier))                        \
-                break;                                                  \
-        frame->local = &__local;                                        \
-        for (__i = 0; __i < numsubvols; __i++) {                        \
-                if (on[__i]) {                                          \
-                        __count++;                                      \
-                }                                                       \
-        }                                                               \
-        __local.barrier.waitfor = __count;                              \
-        for (__i = 0; __i < numsubvols; __i++) {                        \
-                if (on[__i]) {                                          \
-                        func (frame, subvols[__i], __i, ## args);       \
-                }                                                       \
-        }                                                               \
-        syncbarrier_wait (&__local.barrier, __count);                   \
-        syncbarrier_destroy (&__local.barrier);                         \
-        frame->local = __old_local;                                     \
-        STACK_RESET (frame->root);                                      \
-} while (0)
-
-typedef struct cluster_local_ {
-        default_args_cbk_t *replies;
-        syncbarrier_t barrier;
-} cluster_local_t;
-
-int32_t
-cluster_lookup (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
-int32_t
-cluster_setattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
-                 struct iatt *stbuf, int32_t valid, dict_t *xdata);
-int32_t
-cluster_getxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  const char *name, dict_t *xdata);
-int32_t
-cluster_setxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-                  int32_t flags, dict_t *xdata);
-
-int
-cluster_inodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, off_t off, size_t size);
-
-int
-cluster_uninodelk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, char *dom,
-                   inode_t *inode, off_t off, size_t size);
-
-int
-cluster_entrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, const char *name);
-
-int32_t
-cluster_rmdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-               dict_t *xdata);
-
-int32_t
-cluster_unlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-                dict_t *xdata);
-
-int
-cluster_mkdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               mode_t umask, dict_t *xdata);
-
-int32_t
-cluster_readlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-                  dict_t *xdata);
-
-int
-cluster_symlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, const char *linkpath,
-                 loc_t *loc, mode_t umask, dict_t *xdata);
-
-int32_t
-cluster_link (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-              dict_t *xdata);
-
-int
-cluster_mknod (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               dev_t rdev, mode_t umask, dict_t *xdata);
-
-int
-cluster_unentrylk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, char *dom,
-                   inode_t *inode, const char *name);
-
-int
-cluster_tryentrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, const char *name);
-
-int32_t
-cluster_fxattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
-
-int32_t
-cluster_xattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
-                 gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
-
-int32_t
-cluster_fstat (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
-
-int32_t
-cluster_ftruncate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   dict_t *xdata);
-
-int32_t
-cluster_open (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-              fd_t *fd, dict_t *xdata);
-
-int
-cluster_tryinodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, off_t off, size_t size);
-
-int32_t
-cluster_fsetattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  struct iatt *stbuf, int32_t valid, dict_t *xdata);
-
-void
-cluster_replies_wipe (default_args_cbk_t *replies, int num_subvols);
-
-int32_t
-cluster_fop_success_fill (default_args_cbk_t *replies, int numsubvols,
-                          unsigned char *success);
-
-int32_t
-cluster_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict,
-                     dict_t *xdata);
-#endif /* !_CLUSTER_SYNCOP_H */
diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c
index 772f4e05ad7..682cbf28055 100644
--- a/libglusterfs/src/common-utils.c
+++ b/libglusterfs/src/common-utils.c
@@ -24,7 +24,6 @@
 #include <time.h>
 #include <locale.h>
 #include <sys/socket.h>
-#include <sys/wait.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <signal.h>
@@ -35,173 +34,367 @@
 #if defined(GF_BSD_HOST_OS) || defined(GF_DARWIN_HOST_OS)
 #include <sys/sysctl.h>
 #endif
-#include <libgen.h>
 #ifndef GF_LINUX_HOST_OS
 #include <sys/resource.h>
 #endif
+#ifdef HAVE_SYNCFS_SYS
+#include <sys/syscall.h>
+#endif
 
-#include "compat-errno.h"
-#include "logging.h"
-#include "common-utils.h"
-#include "revision.h"
-#include "glusterfs.h"
-#include "stack.h"
-#include "globals.h"
-#include "lkowner.h"
-#include "syscall.h"
-#include "cli1-xdr.h"
+#include "glusterfs/compat-errno.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/revision.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/stack.h"
+#include "glusterfs/lkowner.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/globals.h"
+#define XXH_INLINE_ALL
 #include "xxhash.h"
 #include <ifaddrs.h>
-#include "libglusterfs-messages.h"
-#include "protocol-common.h"
+#include "glusterfs/libglusterfs-messages.h"
+#include "glusterfs/glusterfs-acl.h"
+#ifdef __FreeBSD__
+#include <pthread_np.h>
+#undef BIT_SET
+#endif
 
 #ifndef AI_ADDRCONFIG
 #define AI_ADDRCONFIG 0
 #endif /* AI_ADDRCONFIG */
 
-char *vol_type_str[] = {"Distribute",
-                        "Stripe",
-                        "Replicate",
-                        "Striped-Replicate",
-                        "Disperse",
-                        "Tier",
-                        "Distributed-Stripe",
-                        "Distributed-Replicate",
-                        "Distributed-Striped-Replicate",
-                        "Distributed-Disperse",
-                       };
+char *vol_type_str[] = {
+    "Distribute",
+    "Stripe [NOT SUPPORTED from v6.0]",
+    "Replicate",
+    "Striped-Replicate [NOT SUPPORTED from v6.0]",
+    "Disperse",
+    "Tier [NOT SUPPORTED from v6.0]",
+    "Distributed-Stripe [NOT SUPPORTED from v6.0]",
+    "Distributed-Replicate",
+    "Distributed-Striped-Replicate [NOT SUPPORTED from v6.0]",
+    "Distributed-Disperse",
+};
 
 typedef int32_t (*rw_op_t)(int32_t fd, char *buf, int32_t size);
 typedef int32_t (*rwv_op_t)(int32_t fd, const struct iovec *buf, int32_t size);
 
+char *xattrs_to_heal[] = {"user.",
+                          POSIX_ACL_ACCESS_XATTR,
+                          POSIX_ACL_DEFAULT_XATTR,
+                          QUOTA_LIMIT_KEY,
+                          QUOTA_LIMIT_OBJECTS_KEY,
+                          GF_SELINUX_XATTR_KEY,
+                          GF_XATTR_MDATA_KEY,
+                          NULL};
+
 void
-md5_wrapper(const unsigned char *data, size_t len, char *md5)
+gf_xxh64_wrapper(const unsigned char *data, size_t const len,
+                 unsigned long long const seed, char *xxh64)
 {
-        unsigned short i = 0;
-        unsigned short lim = MD5_DIGEST_LENGTH*2+1;
-        unsigned char scratch[MD5_DIGEST_LENGTH] = {0,};
-        MD5(data, len, scratch);
-        for (; i < MD5_DIGEST_LENGTH; i++)
-                snprintf(md5 + i * 2, lim-i*2, "%02x", scratch[i]);
+    unsigned short i = 0;
+    const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1;
+    XXH64_hash_t hash = 0;
+    XXH64_canonical_t c_hash = {
+        {
+            0,
+        },
+    };
+    const uint8_t *p = (const uint8_t *)&c_hash;
+
+    hash = XXH64(data, len, seed);
+    XXH64_canonicalFromHash(&c_hash, hash);
+
+    for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
+        snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]);
 }
 
-void
-gf_xxh64_wrapper(const unsigned char *data, size_t len, unsigned long long seed,
-                 char *xxh64)
-{
-        unsigned short         i      = 0;
-        unsigned short         lim    = GF_XXH64_DIGEST_LENGTH*2+1;
-        GF_XXH64_hash_t        hash   = 0;
-        GF_XXH64_canonical_t   c_hash = {{0,},};
-        const uint8_t         *p      = (const uint8_t *) &c_hash;
+/**
+ * This function takes following arguments
+ * @this: xlator
+ * @gfid: The gfid which has to be filled
+ * @hash: the 8 byte hash which has to be filled inside the gfid
+ * @index: the array element of the uuid_t structure (which is
+ *         a array of unsigned char) from where the 8 bytes of
+ *         the hash has to be filled. Since uuid_t contains 16
+ *        char elements in the array, each byte of the hash has
+ *        to be filled in one array element.
+ *
+ * This function is called twice for 2 hashes (of 8 byte each) to
+ * be filled in the gfid.
+ *
+ * The for loop in this function actually is doing these 2 things
+ * for each hash
+ *
+ * 1) One of the hashes
+ *      tmp[0] = (hash_2 >> 56) & 0xff;
+ *      tmp[1] = (hash_2 >> 48) & 0xff;
+ *      tmp[2] = (hash_2 >> 40) & 0xff;
+ *      tmp[3] = (hash_2 >> 32) & 0xff;
+ *      tmp[4] = (hash_2 >> 24) & 0xff;
+ *      tmp[5] = (hash_2 >> 16) & 0xff;
+ *      tmp[6] = (hash_2 >> 8) & 0xff;
+ *      tmp[7] = (hash_2) & 0xff;
+ *
+ * 2) The other hash:
+ *      tmp[8] = (hash_1 >> 56) & 0xff;
+ *      tmp[9] = (hash_1 >> 48) & 0xff;
+ *      tmp[10] = (hash_1 >> 40) & 0xff;
+ *      tmp[11] = (hash_1 >> 32) & 0xff;
+ *      tmp[12] = (hash_1 >> 24) & 0xff;
+ *      tmp[13] = (hash_1 >> 16) & 0xff;
+ *      tmp[14] = (hash_1 >> 8) & 0xff;
+ *      tmp[15] = (hash_1) & 0xff;
+ **/
+static int
+gf_gfid_from_xxh64(xlator_t *this, uuid_t gfid, XXH64_hash_t hash,
+                   unsigned short index)
+{
+    int ret = -1;
+    int i = -1;
+
+    if ((index != 0) && (index != 8)) {
+        gf_msg_callingfn("gfid-from-xxh64", GF_LOG_WARNING, 0,
+                         LG_MSG_INDEX_NOT_FOUND,
+                         "index can only be either 0 or 8, as this"
+                         "function's purpose is to encode a 8 byte "
+                         "hash inside the gfid (index: %d)",
+                         index);
+        goto out;
+    }
+
+    for (i = 0; i < sizeof(hash); i++) {
+        /*
+         * As of now the below statement is equivalent of this.
+         * gfid[index+i] = (hash >> (64 - (8 * (i+1)))) & 0xff;
+         */
+        gfid[index + i] = (hash >> ((sizeof(hash) * 8) - (8 * (i + 1)))) &
+                          (0xff);
+    }
+
+    ret = 0;
+
+out:
+    return ret;
+}
 
-        hash = GF_XXH64(data, len, seed);
-        GF_XXH64_canonicalFromHash(&c_hash, hash);
+/**
+ * This function does the same thing as gf_xxh64_wrapper. But gf_xxh64_wrapper
+ * does not return anything and in this xlator there is a need for both the
+ * actual hash and the canonicalized form of the hash.
+ *
+ * To summarize:
+ * - XXH64_hash_t is needed as return because, those bytes which contain the
+ *   hash can be used for different purposes as needed. One example is
+ *   to have those bytes copied into the uuid_t structure to be used as gfid
+ * - xxh64 string is needed because, it can be used as the key for generating
+ *   the next hash (and any other purpose which might require canonical form
+ *   of the hash).
+ **/
+XXH64_hash_t
+gf_xxh64_hash_wrapper(const unsigned char *data, size_t const len,
+                      unsigned long long const seed, char *xxh64)
+{
+    unsigned short i = 0;
+    const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1;
+    XXH64_hash_t hash = 0;
+    XXH64_canonical_t c_hash = {
+        {
+            0,
+        },
+    };
+    const uint8_t *p = (const uint8_t *)&c_hash;
+
+    hash = XXH64(data, len, seed);
+    XXH64_canonicalFromHash(&c_hash, hash);
+
+    for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
+        snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]);
+
+    return hash;
+}
+
+/**
+ * This is the algorithm followed for generating new gfid
+ * 1) generate xxh64 hash using snapname and original gfid of the object
+ * 2) Using the canonicalized form of above hash as the key, generate
+ *    another hash
+ * 3) Combine both of the  8 byte hashes to generate a 16 byte uuid_t type
+ * 4) Use the above uuid as the gfid
+ *
+ * Each byte of the hash is stored separately in different elements of the
+ * character array represented by uuid_t
+ * Ex: tmp[0] = (hash_2 >> 56) & 0xFF
+ *     This saves the most significant byte of hash_2 in tmp[0]
+ *     tmp[1] = (hash_2 >> 48) & 0xFF
+ *     This saves next most significant byte of hash_2 in tmp[1]
+ *     .
+ *     .
+ *     So on.
+ *     tmp[0] - tmp[7] holds the contents of hash_2
+ *     tmp[8] - tmp[15] hold the conents of hash_1
+ *
+ * The hash generated (i.e. of type XXH64_hash_t) is 8 bytes long. And for
+ * gfid 16 byte uuid is needed. Hecne the 2 hashes are combined to form
+ * one 16 byte entity.
+ **/
+int
+gf_gfid_generate_from_xxh64(uuid_t gfid, char *key)
+{
+    char xxh64_1[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    char xxh64_2[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    XXH64_hash_t hash_1 = 0;
+    XXH64_hash_t hash_2 = 0;
+    int ret = -1;
+    xlator_t *this = THIS;
+
+    hash_1 = gf_xxh64_hash_wrapper((unsigned char *)key, strlen(key),
+                                   GF_XXHSUM64_DEFAULT_SEED, xxh64_1);
+
+    hash_2 = gf_xxh64_hash_wrapper((unsigned char *)xxh64_1, strlen(xxh64_1),
+                                   GF_XXHSUM64_DEFAULT_SEED, xxh64_2);
+
+    /* hash_2 is saved in 1st 8 elements of uuid_t char array */
+    if (gf_gfid_from_xxh64(this, gfid, hash_2, 0)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         LG_MSG_XXH64_TO_GFID_FAILED,
+                         "failed to encode the hash %llx into the 1st"
+                         "half of gfid",
+                         hash_2);
+        goto out;
+    }
+
+    /* hash_1 is saved in the remaining 8 elements of uuid_t */
+    if (gf_gfid_from_xxh64(this, gfid, hash_1, 8)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         LG_MSG_XXH64_TO_GFID_FAILED,
+                         "failed to encode the hash %llx into the 2nd"
+                         "half of gfid",
+                         hash_1);
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "gfid generated is %s (hash1: %llx) "
+                 "hash2: %llx, xxh64_1: %s xxh64_2: %s",
+                 uuid_utoa(gfid), hash_1, hash_2, xxh64_1, xxh64_2);
+
+    ret = 0;
 
-        for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
-                snprintf(xxh64 + i * 2, lim-i*2, "%02x", p[i]);
+out:
+    return ret;
 }
 
 /* works similar to mkdir(1) -p.
  */
 int
-mkdir_p (char *path, mode_t mode, gf_boolean_t allow_symlinks)
-{
-        int             i               = 0;
-        int             ret             = -1;
-        char            dir[PATH_MAX]   = {0,};
-        struct stat     stbuf           = {0,};
-
-        strncpy (dir, path, (PATH_MAX - 1));
-        dir[PATH_MAX - 1] = '\0';
-
-        i = (dir[0] == '/')? 1: 0;
-        do {
-                if (path[i] != '/' && path[i] != '\0')
-                        continue;
-
-                dir[i] = '\0';
-                ret = sys_mkdir (dir, mode);
-                if (ret && errno != EEXIST) {
-                        gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-                                "Failed due to reason");
-                        goto out;
-                }
-
-                if (ret && errno == EEXIST && !allow_symlinks) {
-                        ret = sys_lstat (dir, &stbuf);
-                        if (ret)
-                                goto out;
-
-                        if (S_ISLNK (stbuf.st_mode)) {
-                                ret = -1;
-                                gf_msg ("", GF_LOG_ERROR, 0,
-                                        LG_MSG_DIR_IS_SYMLINK, "%s is a "
-                                        "symlink", dir);
-                                goto out;
-                        }
-                }
-                dir[i] = '/';
-
-        } while (path[i++] != '\0');
-
-        ret = sys_stat (dir, &stbuf);
-        if (ret || !S_ISDIR (stbuf.st_mode)) {
-                if (ret == 0)
-                        errno = 0;
+mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks)
+{
+    int i = 0;
+    int ret = -1;
+    char dir[PATH_MAX] = {
+        0,
+    };
+    struct stat stbuf = {
+        0,
+    };
+
+    const int path_len = min(strlen(path), PATH_MAX - 1);
+
+    snprintf(dir, path_len + 1, "%s", path);
+
+    i = (dir[0] == '/') ? 1 : 0;
+    do {
+        if (path[i] != '/' && path[i] != '\0')
+            continue;
+
+        dir[i] = '\0';
+        ret = sys_mkdir(dir, mode);
+        if (ret && errno != EEXIST) {
+            gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, NULL);
+            goto out;
+        }
+
+        if (ret && errno == EEXIST && !allow_symlinks) {
+            ret = sys_lstat(dir, &stbuf);
+            if (ret)
+                goto out;
+
+            if (S_ISLNK(stbuf.st_mode)) {
                 ret = -1;
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "Failed"
-                        " to create directory, possibly some of the components"
-                        " were not directories");
+                gf_smsg("", GF_LOG_ERROR, 0, LG_MSG_DIR_IS_SYMLINK, "dir=%s",
+                        dir, NULL);
                 goto out;
+            }
         }
+        dir[i] = '/';
 
-        ret = 0;
+    } while (path[i++] != '\0');
+
+    ret = sys_stat(dir, &stbuf);
+    if (ret || !S_ISDIR(stbuf.st_mode)) {
+        if (ret == 0)
+            errno = 0;
+        ret = -1;
+        gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                "possibly some of the components"
+                " were not directories",
+                NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int
-gf_lstat_dir (const char *path, struct stat *stbuf_in)
+gf_lstat_dir(const char *path, struct stat *stbuf_in)
 {
-        int ret           = -1;
-        struct stat stbuf = {0,};
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
 
-        if (path == NULL) {
-                errno = EINVAL;
-                goto out;
-        }
+    if (path == NULL) {
+        errno = EINVAL;
+        goto out;
+    }
 
-        ret = sys_lstat (path, &stbuf);
-        if (ret)
-                goto out;
+    ret = sys_lstat(path, &stbuf);
+    if (ret)
+        goto out;
 
-        if (!S_ISDIR (stbuf.st_mode)) {
-                errno = ENOTDIR;
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+    if (!S_ISDIR(stbuf.st_mode)) {
+        errno = ENOTDIR;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        if (!ret && stbuf_in)
-                *stbuf_in = stbuf;
+    if (!ret && stbuf_in)
+        *stbuf_in = stbuf;
 
-        return ret;
+    return ret;
 }
 
 int
-log_base2 (unsigned long x)
+log_base2(unsigned long x)
 {
-        int val = 0;
+    int val = 0;
 
-        while (x > 1) {
-                x /= 2;
-                val++;
-        }
+    while (x > 1) {
+        x /= 2;
+        val++;
+    }
 
-        return val;
+    return val;
 }
 
 /**
@@ -213,22 +406,21 @@ log_base2 (unsigned long x)
  *          failure: NULL
  */
 char *
-gf_rev_dns_lookup (const char *ip)
+gf_rev_dns_lookup(const char *ip)
 {
-        char               *fqdn = NULL;
-        int                ret  = 0;
+    char *fqdn = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("resolver", ip, out);
+    GF_VALIDATE_OR_GOTO("resolver", ip, out);
 
-        /* Get the FQDN */
-        ret =  gf_get_hostname_from_ip ((char *)ip, &fqdn);
-        if (ret != 0) {
-                gf_msg ("resolver", GF_LOG_INFO, errno,
-                        LG_MSG_RESOLVE_HOSTNAME_FAILED, "could not resolve "
-                        "hostname for %s", ip);
-        }
+    /* Get the FQDN */
+    ret = gf_get_hostname_from_ip((char *)ip, &fqdn);
+    if (ret != 0) {
+        gf_smsg("resolver", GF_LOG_INFO, errno, LG_MSG_RESOLVE_HOSTNAME_FAILED,
+                "hostname=%s", ip, NULL);
+    }
 out:
-       return fqdn;
+    return fqdn;
 }
 
 /**
@@ -238,144 +430,139 @@ out:
  * @return: The parent path if found, NULL otherwise
  */
 char *
-gf_resolve_path_parent (const char *path)
+gf_resolve_path_parent(const char *path)
 {
-        char    *parent = NULL;
-        char    *tmp    = NULL;
-        char    *pathc  = NULL;
+    char *parent = NULL;
+    char *tmp = NULL;
+    char *pathc = NULL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, path, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, path, out);
 
-        if (strlen (path) <= 0) {
-                gf_msg_callingfn (THIS->name, GF_LOG_DEBUG, 0,
-                                  LG_MSG_INVALID_STRING,
-                                  "invalid string for 'path'");
-                goto out;
-        }
+    if (0 == strlen(path)) {
+        gf_msg_callingfn(THIS->name, GF_LOG_DEBUG, 0, LG_MSG_INVALID_STRING,
+                         "invalid string for 'path'");
+        goto out;
+    }
 
-        /* dup the parameter, we don't want to modify it */
-        pathc = strdupa (path);
-        if (!pathc) {
-                goto out;
-        }
+    /* dup the parameter, we don't want to modify it */
+    pathc = strdupa(path);
+    if (!pathc) {
+        goto out;
+    }
 
-        /* Get the parent directory */
-        tmp = dirname (pathc);
-        if (strcmp (tmp, "/") == 0)
-                goto out;
+    /* Get the parent directory */
+    tmp = dirname(pathc);
+    if (strcmp(tmp, "/") == 0)
+        goto out;
 
-        parent = gf_strdup (tmp);
+    parent = gf_strdup(tmp);
 out:
-        return parent;
+    return parent;
 }
 
 int32_t
-gf_resolve_ip6 (const char *hostname,
-                uint16_t port,
-                int family,
-                void **dnscache,
-                struct addrinfo **addr_info)
-{
-        int32_t ret = 0;
-        struct addrinfo hints;
-        struct dnscache6 *cache = NULL;
-        char service[NI_MAXSERV], host[NI_MAXHOST];
-
-        if (!hostname) {
-                gf_msg_callingfn ("resolver", GF_LOG_WARNING, 0,
-                                  LG_MSG_HOSTNAME_NULL, "hostname is NULL");
-                return -1;
-        }
+gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
+               struct addrinfo **addr_info)
+{
+    int32_t ret = 0;
+    struct addrinfo hints;
+    struct dnscache6 *cache = NULL;
+    char service[NI_MAXSERV], host[NI_MAXHOST];
 
-        if (!*dnscache) {
-                *dnscache = GF_CALLOC (1, sizeof (struct dnscache6),
-                                       gf_common_mt_dnscache6);
-                if (!*dnscache)
-                        return -1;
+    if (!hostname) {
+        gf_msg_callingfn("resolver", GF_LOG_WARNING, 0, LG_MSG_HOSTNAME_NULL,
+                         "hostname is NULL");
+        return -1;
+    }
+
+    if (!*dnscache) {
+        *dnscache = GF_CALLOC(1, sizeof(struct dnscache6),
+                              gf_common_mt_dnscache6);
+        if (!*dnscache)
+            return -1;
+    }
+
+    cache = *dnscache;
+    if (cache->first && !cache->next) {
+        freeaddrinfo(cache->first);
+        cache->first = cache->next = NULL;
+        gf_msg_trace("resolver", 0, "flushing DNS cache");
+    }
+
+    if (!cache->first) {
+        char *port_str = NULL;
+        gf_msg_trace("resolver", 0,
+                     "DNS cache not present, freshly "
+                     "probing hostname: %s",
+                     hostname);
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = family;
+        hints.ai_socktype = SOCK_STREAM;
+
+        ret = gf_asprintf(&port_str, "%d", port);
+        if (-1 == ret) {
+            return -1;
+        }
+        if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) !=
+            0) {
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+                    "family=%d", family, "ret=%s", gai_strerror(ret), NULL);
+
+            GF_FREE(*dnscache);
+            *dnscache = NULL;
+            GF_FREE(port_str);
+            return -1;
+        }
+        GF_FREE(port_str);
+
+        cache->next = cache->first;
+    }
+
+    if (cache->next) {
+        ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
+                          cache->next->ai_addrlen, host, sizeof(host), service,
+                          sizeof(service), NI_NUMERICHOST);
+        if (ret != 0) {
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
+            goto err;
         }
 
-        cache = *dnscache;
-        if (cache->first && !cache->next) {
-                freeaddrinfo(cache->first);
-                cache->first = cache->next = NULL;
-                gf_msg_trace ("resolver", 0, "flushing DNS cache");
-        }
+        gf_msg_debug("resolver", 0,
+                     "returning ip-%s (port-%s) for "
+                     "hostname: %s and port: %d",
+                     host, service, hostname, port);
 
-        if (!cache->first) {
-                char *port_str = NULL;
-                gf_msg_trace ("resolver", 0, "DNS cache not present, freshly "
-                              "probing hostname: %s", hostname);
-
-                memset(&hints, 0, sizeof(hints));
-                hints.ai_family   = family;
-                hints.ai_socktype = SOCK_STREAM;
-
-                ret = gf_asprintf (&port_str, "%d", port);
-                if (-1 == ret) {
-                        return -1;
-                }
-                if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETADDRINFO_FAILED, "getaddrinfo failed"
-                                " (%s)", gai_strerror (ret));
-
-                        GF_FREE (*dnscache);
-                        *dnscache = NULL;
-                        GF_FREE (port_str);
-                        return -1;
-                }
-                GF_FREE (port_str);
-
-                cache->next = cache->first;
-        }
+        *addr_info = cache->next;
+    }
 
-        if (cache->next) {
-                ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
-                                  cache->next->ai_addrlen,
-                                  host, sizeof (host),
-                                  service, sizeof (service),
-                                  NI_NUMERICHOST);
-                if (ret != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed"
-                                " (%s)", gai_strerror (ret));
-                        goto err;
-                }
-
-                gf_msg_debug ("resolver", 0, "returning ip-%s (port-%s) for "
-                              "hostname: %s and port: %d", host, service,
-                              hostname, port);
-
-                *addr_info = cache->next;
+    if (cache->next)
+        cache->next = cache->next->ai_next;
+    if (cache->next) {
+        ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
+                          cache->next->ai_addrlen, host, sizeof(host), service,
+                          sizeof(service), NI_NUMERICHOST);
+        if (ret != 0) {
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
+            goto err;
         }
 
-        if (cache->next)
-                cache->next = cache->next->ai_next;
-        if (cache->next) {
-                ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
-                                  cache->next->ai_addrlen,
-                                  host, sizeof (host),
-                                  service, sizeof (service),
-                                  NI_NUMERICHOST);
-                if (ret != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed"
-                                " (%s)", gai_strerror (ret));
-                        goto err;
-                }
-
-                gf_msg_debug ("resolver", 0, "next DNS query will return: "
-                              "ip-%s port-%s", host, service);
-        }
+        gf_msg_debug("resolver", 0,
+                     "next DNS query will return: "
+                     "ip-%s port-%s",
+                     host, service);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        freeaddrinfo (cache->first);
-        cache->first = cache->next = NULL;
-        GF_FREE (cache);
-        *dnscache = NULL;
-        return -1;
+    freeaddrinfo(cache->first);
+    cache->first = cache->next = NULL;
+    GF_FREE(cache);
+    *dnscache = NULL;
+    return -1;
 }
 
 /**
@@ -387,13 +574,35 @@ err:
  *          FAILURE: NULL
  */
 struct dnscache *
-gf_dnscache_init (time_t ttl)
+gf_dnscache_init(time_t ttl)
 {
-        struct dnscache *cache = GF_MALLOC (sizeof (*cache),
-                                            gf_common_mt_dnscache);
-        cache->cache_dict = NULL;
+    struct dnscache *cache = GF_MALLOC(sizeof(*cache), gf_common_mt_dnscache);
+    if (!cache)
+        return NULL;
+
+    cache->cache_dict = dict_new();
+    if (!cache->cache_dict) {
+        GF_FREE(cache);
+        cache = NULL;
+    } else {
         cache->ttl = ttl;
-        return cache;
+    }
+
+    return cache;
+}
+
+/**
+ * gf_dnscache_deinit -- cleanup resources used by struct dnscache
+ */
+void
+gf_dnscache_deinit(struct dnscache *cache)
+{
+    if (!cache) {
+        gf_msg_plain(GF_LOG_WARNING, "dnscache is NULL");
+        return;
+    }
+    dict_unref(cache->cache_dict);
+    GF_FREE(cache);
 }
 
 /**
@@ -403,11 +612,11 @@ gf_dnscache_init (time_t ttl)
  *          FAILURE: NULL
  */
 struct dnscache_entry *
-gf_dnscache_entry_init ()
+gf_dnscache_entry_init()
 {
-        struct dnscache_entry *entry = GF_CALLOC (1, sizeof (*entry),
-                                                 gf_common_mt_dnscache_entry);
-        return entry;
+    struct dnscache_entry *entry = GF_CALLOC(1, sizeof(*entry),
+                                             gf_common_mt_dnscache_entry);
+    return entry;
 }
 
 /**
@@ -416,11 +625,11 @@ gf_dnscache_entry_init ()
  * @entry: Pointer to deallocate
  */
 void
-gf_dnscache_entry_deinit (struct dnscache_entry *entry)
+gf_dnscache_entry_deinit(struct dnscache_entry *entry)
 {
-        GF_FREE (entry->ip);
-        GF_FREE (entry->fqdn);
-        GF_FREE (entry);
+    GF_FREE(entry->ip);
+    GF_FREE(entry->fqdn);
+    GF_FREE(entry);
 }
 
 /**
@@ -432,1537 +641,1490 @@ gf_dnscache_entry_deinit (struct dnscache_entry *entry)
  *          failure: NULL
  */
 char *
-gf_rev_dns_lookup_cached (const char *ip, struct dnscache *dnscache)
-{
-        char               *fqdn = NULL;
-        int                ret  = 0;
-        dict_t             *cache = NULL;
-        data_t             *entrydata = NULL;
-        struct dnscache_entry *dnsentry = NULL;
-        gf_boolean_t        from_cache = _gf_false;
-
-        if (!dnscache)
-                goto out;
-
-        if (!dnscache->cache_dict) {
-                dnscache->cache_dict = dict_new ();
-                if (!dnscache->cache_dict) {
-                        goto out;
-                }
-        }
-        cache = dnscache->cache_dict;
-
-        /* Quick cache lookup to see if we already hold it */
-        entrydata = dict_get (cache, (char *)ip);
-        if (entrydata) {
-                dnsentry = (struct dnscache_entry *)entrydata->data;
-                /* First check the TTL & timestamp */
-                if (time (NULL) - dnsentry->timestamp > dnscache->ttl) {
-                        gf_dnscache_entry_deinit (dnsentry);
-                        entrydata->data = NULL; /* Mark this as 'null' so
-                                                 * dict_del () doesn't try free
-                                                 * this after we've already
-                                                 * freed it.
-                                                 */
-
-                        dict_del (cache, (char *)ip); /* Remove this entry */
-                } else {
-                        /* Cache entry is valid, get the FQDN and return */
-                        fqdn = dnsentry->fqdn;
-                        from_cache = _gf_true; /* Mark this as from cache */
-                        goto out;
-                }
+gf_rev_dns_lookup_cached(const char *ip, struct dnscache *dnscache)
+{
+    char *fqdn = NULL;
+    int ret = 0;
+    dict_t *cache = NULL;
+    data_t *entrydata = NULL;
+    struct dnscache_entry *dnsentry = NULL;
+    gf_boolean_t from_cache = _gf_false;
+
+    if (!dnscache)
+        goto out;
+
+    cache = dnscache->cache_dict;
+
+    /* Quick cache lookup to see if we already hold it */
+    entrydata = dict_get(cache, (char *)ip);
+    if (entrydata) {
+        dnsentry = (struct dnscache_entry *)entrydata->data;
+        /* First check the TTL & timestamp */
+        if (gf_time() - dnsentry->timestamp > dnscache->ttl) {
+            gf_dnscache_entry_deinit(dnsentry);
+            entrydata->data = NULL; /* Mark this as 'null' so
+                                     * dict_del () doesn't try free
+                                     * this after we've already
+                                     * freed it.
+                                     */
+
+            dict_del(cache, (char *)ip); /* Remove this entry */
+        } else {
+            /* Cache entry is valid, get the FQDN and return */
+            fqdn = dnsentry->fqdn;
+            from_cache = _gf_true; /* Mark this as from cache */
+            goto out;
         }
+    }
 
-        /* Get the FQDN */
-        ret =  gf_get_hostname_from_ip ((char *)ip, &fqdn);
-        if (ret != 0)
-                goto out;
+    /* Get the FQDN */
+    ret = gf_get_hostname_from_ip((char *)ip, &fqdn);
+    if (ret != 0)
+        goto out;
 
-        if (!fqdn) {
-                gf_log_callingfn ("resolver", GF_LOG_CRITICAL,
-                                  "Allocation failed for the host address");
-                goto out;
-        }
+    if (!fqdn) {
+        gf_log_callingfn("resolver", GF_LOG_CRITICAL,
+                         "Allocation failed for the host address");
+        goto out;
+    }
 
-        from_cache = _gf_false;
+    from_cache = _gf_false;
 out:
-        /* Insert into the cache */
-        if (fqdn && !from_cache) {
-                struct dnscache_entry *entry = gf_dnscache_entry_init ();
-
-                if (!entry) {
-                        goto out;
-                }
-                entry->fqdn = fqdn;
-                entry->ip = gf_strdup (ip);
-                if (!ip) {
-                        gf_dnscache_entry_deinit (entry);
-                        goto out;
-                }
-                entry->timestamp = time (NULL);
-
-                entrydata = bin_to_data (entry, sizeof (*entry));
-                dict_set (cache, (char *)ip, entrydata);
+    /* Insert into the cache */
+    if (fqdn && !from_cache && ip) {
+        struct dnscache_entry *entry = gf_dnscache_entry_init();
+
+        if (entry) {
+            entry->fqdn = fqdn;
+            entry->ip = gf_strdup(ip);
+            entry->timestamp = gf_time();
+            entrydata = bin_to_data(entry, sizeof(*entry));
+            dict_set(cache, (char *)ip, entrydata);
         }
-        return fqdn;
+    }
+    return fqdn;
 }
 
 struct xldump {
-	int lineno;
+    int lineno;
 };
 
 /* to catch any format discrepencies that may arise in code */
-static int nprintf (struct xldump *dump, const char *fmt, ...)
-                    __attribute__ ((__format__ (__printf__, 2, 3)));
 static int
-nprintf (struct xldump *dump, const char *fmt, ...)
+nprintf(struct xldump *dump, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+static int
+nprintf(struct xldump *dump, const char *fmt, ...)
 {
-        va_list  ap;
-        char    *msg = NULL;
-        char     header[32];
-        int      ret = 0;
+    va_list ap;
+    char *msg = NULL;
+    char header[32];
+    int ret = 0;
 
-        ret = snprintf (header, 32, "%3d:", ++dump->lineno);
-        if (ret < 0)
-                goto out;
+    ret = snprintf(header, 32, "%3d:", ++dump->lineno);
+    if (ret < 0)
+        goto out;
 
-        va_start (ap, fmt);
-        ret = vasprintf (&msg, fmt, ap);
-        va_end (ap);
-        if (-1 == ret)
-                goto out;
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret)
+        goto out;
 
-        /* NOTE: No ret value from gf_msg_plain, so unable to compute printed
-         * characters. The return value from nprintf is not used, so for now
-         * living with it */
-        gf_msg_plain (GF_LOG_WARNING, "%s %s", header, msg);
+    /* NOTE: No ret value from gf_msg_plain, so unable to compute printed
+     * characters. The return value from nprintf is not used, so for now
+     * living with it */
+    gf_msg_plain(GF_LOG_WARNING, "%s %s", header, msg);
 
 out:
-        FREE (msg);
-        return 0;
+    FREE(msg);
+    return 0;
 }
 
-
 static int
-xldump_options (dict_t *this, char *key, data_t *value,	void *d)
+xldump_options(dict_t *this, char *key, data_t *value, void *d)
 {
-	nprintf (d, "    option %s %s", key, value->data);
-	return 0;
+    nprintf(d, "    option %s %s", key, value->data);
+    return 0;
 }
 
-
 static void
-xldump_subvolumes (xlator_t *this, void *d)
+xldump_subvolumes(xlator_t *this, void *d)
 {
-	xlator_list_t *subv = NULL;
-	int len = 0;
-	char *subvstr = NULL;
+    xlator_list_t *subv = NULL;
+    int len = 0;
+    char *subvstr = NULL;
 
-	subv = this->children;
-	if (!this->children)
-		return;
+    if (!this->children)
+        return;
 
-	for (subv = this->children; subv; subv = subv->next)
-		len += (strlen (subv->xlator->name) + 1);
+    for (subv = this->children; subv; subv = subv->next)
+        len += (strlen(subv->xlator->name) + 1);
 
-	subvstr = GF_CALLOC (1, len, gf_common_mt_strdup);
+    subvstr = GF_MALLOC(len, gf_common_mt_strdup);
 
-	len = 0;
-	for (subv = this->children; subv; subv= subv->next)
-		len += sprintf (subvstr + len, "%s%s", subv->xlator->name,
-				subv->next ? " " : "");
+    len = 0;
+    for (subv = this->children; subv; subv = subv->next)
+        len += sprintf(subvstr + len, "%s%s", subv->xlator->name,
+                       subv->next ? " " : "");
 
-	nprintf (d, "    subvolumes %s", subvstr);
+    nprintf(d, "    subvolumes %s", subvstr);
 
-	GF_FREE (subvstr);
+    GF_FREE(subvstr);
 }
 
-
 static void
-xldump (xlator_t *each, void *d)
+xldump(xlator_t *each, void *d)
 {
-	nprintf (d, "volume %s", each->name);
-	nprintf (d, "    type %s", each->type);
-	dict_foreach (each->options, xldump_options, d);
+    nprintf(d, "volume %s", each->name);
+    nprintf(d, "    type %s", each->type);
+    dict_foreach(each->options, xldump_options, d);
 
-	xldump_subvolumes (each, d);
+    xldump_subvolumes(each, d);
 
-	nprintf (d, "end-volume");
-	nprintf (d, " ");
+    nprintf(d, "end-volume");
+    nprintf(d, " ");
 }
 
-
 void
-gf_log_dump_graph (FILE *specfp, glusterfs_graph_t *graph)
+gf_log_dump_graph(FILE *specfp, glusterfs_graph_t *graph)
 {
-	struct xldump xld = {0, };
+    struct xldump xld = {
+        0,
+    };
 
-        gf_msg_plain (GF_LOG_WARNING, "Final graph:");
-        gf_msg_plain (GF_LOG_WARNING,
-                      "+---------------------------------------"
-                      "---------------------------------------+");
+    gf_msg_plain(GF_LOG_WARNING, "Final graph:");
+    gf_msg_plain(GF_LOG_WARNING,
+                 "+---------------------------------------"
+                 "---------------------------------------+");
 
-	xlator_foreach_depth_first (graph->top, xldump, &xld);
+    xlator_foreach_depth_first(graph->top, xldump, &xld);
 
-        gf_msg_plain (GF_LOG_WARNING,
-                      "+---------------------------------------"
-                      "---------------------------------------+");
+    gf_msg_plain(GF_LOG_WARNING,
+                 "+---------------------------------------"
+                 "---------------------------------------+");
 }
 
 static void
-gf_dump_config_flags ()
+gf_dump_config_flags()
 {
-        gf_msg_plain_nomem (GF_LOG_ALERT, "configuration details:");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "configuration details:");
 
 /* have argp */
 #ifdef HAVE_ARGP
-        gf_msg_plain_nomem (GF_LOG_ALERT, "argp 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "argp 1");
 #endif
 
 /* ifdef if found backtrace */
 #ifdef HAVE_BACKTRACE
-        gf_msg_plain_nomem (GF_LOG_ALERT, "backtrace 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "backtrace 1");
 #endif
 
 /* Berkeley-DB version has cursor->get() */
 #ifdef HAVE_BDB_CURSOR_GET
-        gf_msg_plain_nomem (GF_LOG_ALERT, "bdb->cursor->get 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "bdb->cursor->get 1");
 #endif
 
 /* Define to 1 if you have the <db.h> header file. */
 #ifdef HAVE_DB_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "db.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "db.h 1");
 #endif
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #ifdef HAVE_DLFCN_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "dlfcn 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "dlfcn 1");
 #endif
 
 /* define if fdatasync exists */
 #ifdef HAVE_FDATASYNC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "fdatasync 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "fdatasync 1");
 #endif
 
 /* Define to 1 if you have the `pthread' library (-lpthread). */
 #ifdef HAVE_LIBPTHREAD
-        gf_msg_plain_nomem (GF_LOG_ALERT, "libpthread 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "libpthread 1");
 #endif
 
 /* define if llistxattr exists */
 #ifdef HAVE_LLISTXATTR
-        gf_msg_plain_nomem (GF_LOG_ALERT, "llistxattr 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "llistxattr 1");
 #endif
 
 /* define if found setfsuid setfsgid */
 #ifdef HAVE_SET_FSID
-        gf_msg_plain_nomem (GF_LOG_ALERT, "setfsid 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "setfsid 1");
 #endif
 
 /* define if found spinlock */
 #ifdef HAVE_SPINLOCK
-        gf_msg_plain_nomem (GF_LOG_ALERT, "spinlock 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "spinlock 1");
 #endif
 
 /* Define to 1 if you have the <sys/epoll.h> header file. */
 #ifdef HAVE_SYS_EPOLL_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "epoll.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "epoll.h 1");
 #endif
 
 /* Define to 1 if you have the <sys/extattr.h> header file. */
 #ifdef HAVE_SYS_EXTATTR_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "extattr.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "extattr.h 1");
 #endif
 
 /* Define to 1 if you have the <sys/xattr.h> header file. */
 #ifdef HAVE_SYS_XATTR_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "xattr.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "xattr.h 1");
 #endif
 
 /* define if found st_atim.tv_nsec */
 #ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "st_atim.tv_nsec 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "st_atim.tv_nsec 1");
 #endif
 
 /* define if found st_atimespec.tv_nsec */
 #ifdef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "st_atimespec.tv_nsec 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "st_atimespec.tv_nsec 1");
 #endif
 
 /* Define to the full name and version of this package. */
 #ifdef PACKAGE_STRING
-        {
-                char *msg = NULL;
-                int   ret = -1;
-
-                ret = gf_asprintf (&msg, "package-string: %s", PACKAGE_STRING);
-                if (ret >= 0) {
-                        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-                        GF_FREE (msg);
-                }
+    {
+        char *msg = NULL;
+        int ret = -1;
+
+        ret = gf_asprintf(&msg, "package-string: %s", PACKAGE_STRING);
+        if (ret >= 0) {
+            gf_msg_plain_nomem(GF_LOG_ALERT, msg);
+            GF_FREE(msg);
         }
+    }
 #endif
 
-        return;
+    return;
 }
 
 /* Obtain a backtrace and print it to the log */
 void
-gf_print_trace (int32_t signum, glusterfs_ctx_t *ctx)
-{
-        char         msg[1024] = {0,};
-        char         timestr[64] = {0,};
-        call_stack_t *stack = NULL;
-
-        /* Now every gf_log call will just write to a buffer and when the
-         * buffer becomes full, its written to the log-file. Suppose the process
-         * crashes and prints the backtrace in the log-file, then the previous
-         * log information will still be in the buffer itself. So flush the
-         * contents of the buffer to the log file before printing the backtrace
-         * which helps in debugging.
-         */
-        gf_log_flush();
-
-        gf_log_disable_suppression_before_exit (ctx);
-
-        /* Pending frames, (if any), list them in order */
-        gf_msg_plain_nomem (GF_LOG_ALERT, "pending frames:");
+gf_print_trace(int32_t signum, glusterfs_ctx_t *ctx)
+{
+    char msg[1024] = {
+        0,
+    };
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    call_stack_t *stack = NULL;
+
+    /* Now every gf_log call will just write to a buffer and when the
+     * buffer becomes full, its written to the log-file. Suppose the process
+     * crashes and prints the backtrace in the log-file, then the previous
+     * log information will still be in the buffer itself. So flush the
+     * contents of the buffer to the log file before printing the backtrace
+     * which helps in debugging.
+     */
+    gf_log_flush();
+
+    gf_log_disable_suppression_before_exit(ctx);
+
+    /* Pending frames, (if any), list them in order */
+    gf_msg_plain_nomem(GF_LOG_ALERT, "pending frames:");
+    {
+        /* FIXME: traversing stacks outside pool->lock */
+        list_for_each_entry(stack, &ctx->pool->all_frames, all_frames)
         {
-                /* FIXME: traversing stacks outside pool->lock */
-                list_for_each_entry (stack, &ctx->pool->all_frames,
-                                     all_frames) {
-                        if (stack->type == GF_OP_TYPE_FOP)
-                                sprintf (msg,"frame : type(%d) op(%s)",
-                                         stack->type,
-                                         gf_fop_list[stack->op]);
-                        else
-                                sprintf (msg,"frame : type(%d) op(%d)",
-                                         stack->type,
-                                         stack->op);
-
-                        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-                }
+            if (stack->type == GF_OP_TYPE_FOP)
+                sprintf(msg, "frame : type(%d) op(%s)", stack->type,
+                        gf_fop_list[stack->op]);
+            else
+                sprintf(msg, "frame : type(%d) op(%d)", stack->type, stack->op);
+
+            gf_msg_plain_nomem(GF_LOG_ALERT, msg);
         }
+    }
 
-        sprintf (msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION);
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
+    sprintf(msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION);
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
 
-        sprintf (msg, "signal received: %d", signum);
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-        {
-                /* Dump the timestamp of the crash too, so the previous logs
-                   can be related */
-                gf_time_fmt (timestr, sizeof timestr, time (NULL),
-                             gf_timefmt_FT);
-                gf_msg_plain_nomem (GF_LOG_ALERT, "time of crash: ");
-                gf_msg_plain_nomem (GF_LOG_ALERT, timestr);
-        }
+    sprintf(msg, "signal received: %d", signum);
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
+    {
+        /* Dump the timestamp of the crash too, so the previous logs
+           can be related */
+        gf_time_fmt(timestr, sizeof timestr, gf_time(), gf_timefmt_FT);
+        gf_msg_plain_nomem(GF_LOG_ALERT, "time of crash: ");
+        gf_msg_plain_nomem(GF_LOG_ALERT, timestr);
+    }
 
-        gf_dump_config_flags ();
-        gf_msg_backtrace_nomem (GF_LOG_ALERT, 200);
-        sprintf (msg, "---------");
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
+    gf_dump_config_flags();
+    gf_msg_backtrace_nomem(GF_LOG_ALERT, 200);
+    sprintf(msg, "---------");
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
 
-        /* Send a signal to terminate the process */
-        signal (signum, SIG_DFL);
-        raise (signum);
+    /* Send a signal to terminate the process */
+    signal(signum, SIG_DFL);
+    raise(signum);
 }
 
 void
-trap (void)
+trap(void)
 {
-
 }
 
 char *
-gf_trim (char *string)
+gf_trim(char *string)
 {
-        register char *s, *t;
-
-        if (string == NULL) {
-                return NULL;
-        }
-
-        for (s = string; isspace (*s); s++)
-                ;
+    register char *s, *t;
 
-        if (*s == 0)
-                return s;
+    if (string == NULL) {
+        return NULL;
+    }
 
-        t = s + strlen (s) - 1;
-        while (t > s && isspace (*t))
-                t--;
-        *++t = '\0';
+    for (s = string; isspace(*s); s++)
+        ;
 
+    if (*s == 0)
         return s;
-}
-
-int
-gf_strsplit (const char *str, const char *delim,
-             char ***tokens, int *token_count)
-{
-        char *_running = NULL;
-        char *running = NULL;
-        char *token = NULL;
-        char **token_list = NULL;
-        int count = 0;
-        int i = 0;
-        int j = 0;
-
-        if (str == NULL || delim == NULL || tokens == NULL || token_count == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return -1;
-        }
-
-        _running = gf_strdup (str);
-        if (_running == NULL)
-                return -1;
-
-        running = _running;
-
-        while ((token = strsep (&running, delim)) != NULL) {
-                if (token[0] != '\0')
-                        count++;
-        }
-        GF_FREE (_running);
-
-        _running = gf_strdup (str);
-        if (_running == NULL)
-                return -1;
-
-        running = _running;
-
-        if ((token_list = GF_CALLOC (count, sizeof (char *),
-                                     gf_common_mt_char)) == NULL) {
-                GF_FREE (_running);
-                return -1;
-        }
-
-        while ((token = strsep (&running, delim)) != NULL) {
-                if (token[0] == '\0')
-                        continue;
-
-                token_list[i] = gf_strdup (token);
-                if (token_list[i] == NULL)
-                        goto free_exit;
-                i++;
-        }
-
-        GF_FREE (_running);
-
-        *tokens = token_list;
-        *token_count = count;
-        return 0;
 
-free_exit:
-        GF_FREE (_running);
-        for (j = 0; j < i; j++)
-                GF_FREE (token_list[j]);
+    t = s + strlen(s) - 1;
+    while (t > s && isspace(*t))
+        t--;
+    *++t = '\0';
 
-        GF_FREE (token_list);
-        return -1;
+    return s;
 }
 
 int
-gf_strstr (const char *str, const char *delim, const char *match)
+gf_strstr(const char *str, const char *delim, const char *match)
 {
-        char *tmp      = NULL;
-        char *save_ptr = NULL;
-        char *tmp_str  = NULL;
+    char *tmp = NULL;
+    char *save_ptr = NULL;
+    char *tmp_str = NULL;
 
-        int  ret       = 0;
+    int ret = 0;
 
-        tmp_str = strdup (str);
+    tmp_str = strdup(str);
 
-        if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                ret = -1;
-                goto out;
-        }
+    if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        ret = -1;
+        goto out;
+    }
 
+    tmp = strtok_r(tmp_str, delim, &save_ptr);
 
-        tmp = strtok_r (tmp_str, delim, &save_ptr);
+    while (tmp) {
+        ret = strcmp(tmp, match);
 
-        while (tmp) {
-                ret = strcmp (tmp, match);
+        if (ret == 0)
+            break;
 
-                if (ret == 0)
-                        break;
-
-                tmp = strtok_r (NULL, delim, &save_ptr);
-        }
+        tmp = strtok_r(NULL, delim, &save_ptr);
+    }
 
 out:
-        free (tmp_str);
-
-        return ret;
+    free(tmp_str);
 
+    return ret;
 }
 
 int
-gf_volume_name_validate (const char *volume_name)
+gf_volume_name_validate(const char *volume_name)
 {
-        const char *vname = NULL;
+    const char *vname = NULL;
 
-        if (volume_name == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return -1;
-        }
+    if (volume_name == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return -1;
+    }
 
-        if (!isalpha (volume_name[0]))
-                return 1;
+    if (!isalpha(volume_name[0]))
+        return 1;
 
-        for (vname = &volume_name[1]; *vname != '\0'; vname++) {
-                if (!(isalnum (*vname) || *vname == '_'))
-                        return 1;
-        }
+    for (vname = &volume_name[1]; *vname != '\0'; vname++) {
+        if (!(isalnum(*vname) || *vname == '_'))
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-gf_string2time (const char *str, uint32_t *n)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtol (str, &tail, 0);
-        if (str == tail)
-                errno = EINVAL;
-
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
-
-        if (errno == 0)
-                errno = old_errno;
-
-        if (((tail[0] == '\0') ||
-              ((tail[0] == 's') && (tail[1] == '\0')) ||
-              ((tail[0] == 's') && (tail[1] == 'e') &&
-	       (tail[2] == 'c') && (tail[3] == '\0'))))
-               goto out;
-
-        else if (((tail[0] == 'm') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'm') && (tail[1] == 'i') &&
-                  (tail[2] == 'n') && (tail[3] == '\0'))) {
-                value = value * GF_MINUTE_IN_SECONDS;
-                goto out;
-        }
-
-        else if (((tail[0] == 'h') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'h') && (tail[1] == 'r') &&
-	         (tail[2] == '\0'))) {
-                value = value * GF_HOUR_IN_SECONDS;
-                goto out;
-        }
+gf_string2time(const char *str, uint32_t *n)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        else if (((tail[0] == 'd') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'd') && (tail[1] == 'a') &&
-	         (tail[2] == 'y') && (tail[3] == 's') &&
-                 (tail[4] == '\0'))) {
-                value = value * GF_DAY_IN_SECONDS;
-                goto out;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtol(str, &tail, 0);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        else if (((tail[0] == 'w') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'w') && (tail[1] == 'k') &&
-	         (tail[2] == '\0'))) {
-                value = value * GF_WEEK_IN_SECONDS;
-                goto out;
-        } else {
-                return -1;
-        }
+    if (errno == 0)
+        errno = old_errno;
+
+    if (((tail[0] == '\0') || ((tail[0] == 's') && (tail[1] == '\0')) ||
+         ((tail[0] == 's') && (tail[1] == 'e') && (tail[2] == 'c') &&
+          (tail[3] == '\0'))))
+        goto out;
+
+    else if (((tail[0] == 'm') && (tail[1] == '\0')) ||
+             ((tail[0] == 'm') && (tail[1] == 'i') && (tail[2] == 'n') &&
+              (tail[3] == '\0'))) {
+        value = value * GF_MINUTE_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'h') && (tail[1] == '\0')) ||
+             ((tail[0] == 'h') && (tail[1] == 'r') && (tail[2] == '\0'))) {
+        value = value * GF_HOUR_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'd') && (tail[1] == '\0')) ||
+             ((tail[0] == 'd') && (tail[1] == 'a') && (tail[2] == 'y') &&
+              (tail[3] == 's') && (tail[4] == '\0'))) {
+        value = value * GF_DAY_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'w') && (tail[1] == '\0')) ||
+             ((tail[0] == 'w') && (tail[1] == 'k') && (tail[2] == '\0'))) {
+        value = value * GF_WEEK_IN_SECONDS;
+        goto out;
+    } else {
+        return -1;
+    }
 
 out:
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2percent (const char *str, double *n)
-{
-        double value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
+gf_string2percent(const char *str, double *n)
+{
+    double value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (!((tail[0] == '\0') ||
-              ((tail[0] == '%') && (tail[1] == '\0'))))
-                return -1;
+    if (!((tail[0] == '\0') || ((tail[0] == '%') && (tail[1] == '\0'))))
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-_gf_string2long (const char *str, long *n, int base)
+_gf_string2long(const char *str, long *n, int base)
 {
-        long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
+    long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtol (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtol(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2ulong (const char *str, unsigned long *n, int base)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoul (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2ulong(const char *str, unsigned long *n, int base)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoul(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2uint (const char *str, unsigned int *n, int base)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoul (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2uint(const char *str, unsigned int *n, int base)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoul(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = (unsigned int)value;
+    *n = (unsigned int)value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2double (const char *str, double *n)
+_gf_string2double(const char *str, double *n)
 {
-        double value     = 0.0;
-        char   *tail     = NULL;
-        int    old_errno = 0;
+    double value = 0.0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2longlong (const char *str, long long *n, int base)
+_gf_string2longlong(const char *str, long long *n, int base)
 {
-        long long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
+    long long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtoll (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtoll(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2ulonglong (const char *str, unsigned long long *n, int base)
-{
-        unsigned long long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoull (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2ulonglong(const char *str, unsigned long long *n, int base)
+{
+    unsigned long long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoull(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2long (const char *str, long *n)
+gf_string2long(const char *str, long *n)
 {
-        return _gf_string2long (str, n, 0);
+    return _gf_string2long(str, n, 0);
 }
 
 int
-gf_string2ulong (const char *str, unsigned long *n)
+gf_string2ulong(const char *str, unsigned long *n)
 {
-        return _gf_string2ulong (str, n, 0);
+    return _gf_string2ulong(str, n, 0);
 }
 
 int
-gf_string2int (const char *str, int *n)
+gf_string2int(const char *str, int *n)
 {
-        long l = 0;
-        int  ret = 0;
+    long l = 0;
+    int ret = 0;
 
-        ret = _gf_string2long (str, &l, 0);
+    ret = _gf_string2long(str, &l, 0);
 
-        *n = l;
-        return ret;
+    *n = l;
+    return ret;
 }
 
 int
-gf_string2uint (const char *str, unsigned int *n)
+gf_string2uint(const char *str, unsigned int *n)
 {
-        return _gf_string2uint (str, n, 0);
+    return _gf_string2uint(str, n, 0);
 }
 
 int
-gf_string2double (const char *str, double *n)
+gf_string2double(const char *str, double *n)
 {
-        return _gf_string2double (str, n);
+    return _gf_string2double(str, n);
 }
 
 int
-gf_string2longlong (const char *str, long long *n)
+gf_string2longlong(const char *str, long long *n)
 {
-        return _gf_string2longlong (str, n, 0);
+    return _gf_string2longlong(str, n, 0);
 }
 
 int
-gf_string2ulonglong (const char *str, unsigned long long *n)
+gf_string2ulonglong(const char *str, unsigned long long *n)
 {
-        return _gf_string2ulonglong (str, n, 0);
+    return _gf_string2ulonglong(str, n, 0);
 }
 
 int
-gf_string2int8 (const char *str, int8_t *n)
+gf_string2int8(const char *str, int8_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT8_MIN) && (l <= INT8_MAX)) {
-                *n = (int8_t) l;
-                return 0;
-        }
+    if ((l >= INT8_MIN) && (l <= INT8_MAX)) {
+        *n = (int8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int16 (const char *str, int16_t *n)
+gf_string2int16(const char *str, int16_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT16_MIN) && (l <= INT16_MAX)) {
-                *n = (int16_t) l;
-                return 0;
-        }
+    if ((l >= INT16_MIN) && (l <= INT16_MAX)) {
+        *n = (int16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int32 (const char *str, int32_t *n)
+gf_string2int32(const char *str, int32_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT32_MIN) && (l <= INT32_MAX)) {
-                *n = (int32_t) l;
-                return 0;
-        }
+    if ((l >= INT32_MIN) && (l <= INT32_MAX)) {
+        *n = (int32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int64 (const char *str, int64_t *n)
+gf_string2int64(const char *str, int64_t *n)
 {
-        long long l = 0LL;
-        int rv = 0;
-
-        rv = _gf_string2longlong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    long long l = 0LL;
+    int rv = 0;
 
-        if (l <= INT64_MAX) {
-                *n = (int64_t) l;
-                return 0;
-        }
+    rv = _gf_string2longlong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        errno = ERANGE;
-        return -1;
+    *n = (int64_t)l;
+    return 0;
 }
 
 int
-gf_string2uint8 (const char *str, uint8_t *n)
+gf_string2uint8(const char *str, uint8_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT8_MAX) {
-                *n = (uint8_t) l;
-                return 0;
-        }
+    if (l <= UINT8_MAX) {
+        *n = (uint8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint16 (const char *str, uint16_t *n)
+gf_string2uint16(const char *str, uint16_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT16_MAX) {
-                *n = (uint16_t) l;
-                return 0;
-        }
+    if (l <= UINT16_MAX) {
+        *n = (uint16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint32 (const char *str, uint32_t *n)
+gf_string2uint32(const char *str, uint32_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-	if (l <= UINT32_MAX) {
-                *n = (uint32_t) l;
-                return 0;
-        }
+    if (l <= UINT32_MAX) {
+        *n = (uint32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint64 (const char *str, uint64_t *n)
+gf_string2uint64(const char *str, uint64_t *n)
 {
-        unsigned long long l = 0ULL;
-        int rv = 0;
+    unsigned long long l = 0ULL;
+    int rv = 0;
 
-        rv = _gf_string2ulonglong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulonglong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT64_MAX) {
-                *n = (uint64_t) l;
-                return 0;
-        }
+    if (l <= UINT64_MAX) {
+        *n = (uint64_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2ulong_base10 (const char *str, unsigned long *n)
+gf_string2ulong_base10(const char *str, unsigned long *n)
 {
-        return _gf_string2ulong (str, n, 10);
+    return _gf_string2ulong(str, n, 10);
 }
 
 int
-gf_string2uint_base10 (const char *str, unsigned int *n)
+gf_string2uint_base10(const char *str, unsigned int *n)
 {
-        return _gf_string2uint (str,  n, 10);
+    return _gf_string2uint(str, n, 10);
 }
 
 int
-gf_string2uint8_base10 (const char *str, uint8_t *n)
+gf_string2uint8_base10(const char *str, uint8_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT8_MAX) {
-                *n = (uint8_t) l;
-                return 0;
-        }
+    if (l <= UINT8_MAX) {
+        *n = (uint8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint16_base10 (const char *str, uint16_t *n)
+gf_string2uint16_base10(const char *str, uint16_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT16_MAX) {
-                *n = (uint16_t) l;
-                return 0;
-        }
+    if (l <= UINT16_MAX) {
+        *n = (uint16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint32_base10 (const char *str, uint32_t *n)
+gf_string2uint32_base10(const char *str, uint32_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT32_MAX) {
-                *n = (uint32_t) l;
-                return 0;
-        }
+    if (l <= UINT32_MAX) {
+        *n = (uint32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint64_base10 (const char *str, uint64_t *n)
+gf_string2uint64_base10(const char *str, uint64_t *n)
 {
-        unsigned long long l = 0ULL;
-        int rv = 0;
+    unsigned long long l = 0ULL;
+    int rv = 0;
 
-        rv = _gf_string2ulonglong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulonglong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT64_MAX) {
-                *n = (uint64_t) l;
-                return 0;
-        }
+    if (l <= UINT64_MAX) {
+        *n = (uint64_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 char *
-gf_uint64_2human_readable (uint64_t n)
-{
-        int   ret = 0;
-        char *str = NULL;
-
-        if (n >= GF_UNIT_PB) {
-                ret = gf_asprintf (&str, "%.1lfPB", ((double) n)/GF_UNIT_PB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_TB) {
-                ret = gf_asprintf (&str, "%.1lfTB", ((double) n)/GF_UNIT_TB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_GB) {
-                ret = gf_asprintf (&str, "%.1lfGB", ((double) n)/GF_UNIT_GB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_MB) {
-                ret = gf_asprintf (&str, "%.1lfMB", ((double) n)/GF_UNIT_MB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_KB) {
-                ret = gf_asprintf (&str, "%.1lfKB", ((double) n)/GF_UNIT_KB);
-                if (ret < 0)
-                        goto err;
-        } else {
-                ret = gf_asprintf (&str, "%luBytes", n);
-                if (ret < 0)
-                        goto err;
-        }
-        return str;
+gf_uint64_2human_readable(uint64_t n)
+{
+    int ret = 0;
+    char *str = NULL;
+
+    if (n >= GF_UNIT_PB) {
+        ret = gf_asprintf(&str, "%.1lfPB", ((double)n) / GF_UNIT_PB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_TB) {
+        ret = gf_asprintf(&str, "%.1lfTB", ((double)n) / GF_UNIT_TB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_GB) {
+        ret = gf_asprintf(&str, "%.1lfGB", ((double)n) / GF_UNIT_GB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_MB) {
+        ret = gf_asprintf(&str, "%.1lfMB", ((double)n) / GF_UNIT_MB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_KB) {
+        ret = gf_asprintf(&str, "%.1lfKB", ((double)n) / GF_UNIT_KB);
+        if (ret < 0)
+            goto err;
+    } else {
+        ret = gf_asprintf(&str, "%" PRIu64 "Bytes", n);
+        if (ret < 0)
+            goto err;
+    }
+    return str;
 err:
-        return NULL;
+    return NULL;
 }
 
 int
-gf_string2bytesize_range (const char *str, uint64_t *n, uint64_t umax)
-{
-        double        value      = 0.0;
-        int64_t       int_value  = 0;
-        uint64_t      unit       = 0;
-        int64_t       max        = 0;
-        char         *tail       = NULL;
-        int           old_errno  = 0;
-        const char   *s          = NULL;
-        gf_boolean_t  fraction   = _gf_false;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+gf_string2bytesize_range(const char *str, uint64_t *n, uint64_t umax)
+{
+    double value = 0.0;
+    int64_t int_value = 0;
+    uint64_t unit = 0;
+    int64_t max = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+    gf_boolean_t fraction = _gf_false;
+
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        max = umax & 0x7fffffffffffffffLL;
+    max = umax & 0x7fffffffffffffffLL;
 
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
 
-        if (strrchr (str, '.'))
-                fraction = _gf_true;
+    if (strrchr(str, '.'))
+        fraction = _gf_true;
 
-        old_errno = errno;
-        errno = 0;
-        if (fraction)
-                value = strtod (str, &tail);
-        else
-                int_value = strtoll (str, &tail, 10);
+    old_errno = errno;
+    errno = 0;
+    if (fraction)
+        value = strtod(str, &tail);
+    else
+        int_value = strtoll(str, &tail, 10);
 
-        if (str == tail)
-                errno = EINVAL;
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-        {
-                if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0)
-                        unit = GF_UNIT_KB;
-                else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0)
-                        unit = GF_UNIT_MB;
-                else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0)
-                        unit = GF_UNIT_GB;
-                else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0)
-                        unit = GF_UNIT_TB;
-                else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0)
-                        unit = GF_UNIT_PB;
-                else if (strcasecmp (tail, GF_UNIT_B_STRING) != 0)
-                        return -1;
-
-                if (unit > 0) {
-                        if (fraction)
-                                value *= unit;
-                        else
-                                int_value *= unit;
-                }
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0)
+            unit = GF_UNIT_KB;
+        else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0)
+            unit = GF_UNIT_MB;
+        else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0)
+            unit = GF_UNIT_GB;
+        else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0)
+            unit = GF_UNIT_TB;
+        else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0)
+            unit = GF_UNIT_PB;
+        else if (strcasecmp(tail, GF_UNIT_B_STRING) != 0)
+            return -1;
+
+        if (unit > 0) {
+            if (fraction)
+                value *= unit;
+            else
+                int_value *= unit;
         }
+    }
 
-        if (fraction) {
-                if ((max - value) < 0) {
-                        errno = ERANGE;
-                        return -1;
-                }
-                *n = (uint64_t) value;
-        } else {
-                if ((max - int_value) < 0) {
-                        errno = ERANGE;
-                        return -1;
-                }
-                *n = int_value;
+    if (fraction) {
+        if ((max - value) < 0) {
+            errno = ERANGE;
+            return -1;
         }
+        *n = (uint64_t)value;
+    } else {
+        if ((max - int_value) < 0) {
+            errno = ERANGE;
+            return -1;
+        }
+        *n = int_value;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2bytesize_size (const char *str, size_t *n)
+gf_string2bytesize_uint64(const char *str, uint64_t *n)
 {
-        uint64_t u64;
-        size_t max = (size_t) - 1;
-        int val = gf_string2bytesize_range (str, &u64, max);
-        *n = (size_t) u64;
-        return val;
+    return gf_string2bytesize_range(str, n, UINT64_MAX);
 }
 
 int
-gf_string2bytesize (const char *str, uint64_t *n)
+gf_string2bytesize_int64(const char *str, int64_t *n)
 {
-        return gf_string2bytesize_range(str, n, UINT64_MAX);
-}
+    uint64_t u64 = 0;
+    int ret = 0;
 
-int
-gf_string2bytesize_uint64 (const char *str, uint64_t *n)
-{
-        return gf_string2bytesize_range(str, n, UINT64_MAX);
+    ret = gf_string2bytesize_range(str, &u64, INT64_MAX);
+    *n = (int64_t)u64;
+    return ret;
 }
 
 int
-gf_string2bytesize_int64 (const char *str, int64_t *n)
-{
-        uint64_t u64 = 0;
-        int      ret = 0;
+gf_string2percent_or_bytesize(const char *str, double *n,
+                              gf_boolean_t *is_percent)
+{
+    double value = 0ULL;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        ret = gf_string2bytesize_range(str, &u64, INT64_MAX);
-        *n = (int64_t) u64;
-        return ret;
-}
+    if (errno == 0)
+        errno = old_errno;
+
+    /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0)
+            value *= GF_UNIT_KB;
+        else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0)
+            value *= GF_UNIT_MB;
+        else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0)
+            value *= GF_UNIT_GB;
+        else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0)
+            value *= GF_UNIT_TB;
+        else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0)
+            value *= GF_UNIT_PB;
+        else if (strcasecmp(tail, GF_UNIT_PERCENT_STRING) == 0)
+            *is_percent = _gf_true;
+        else
+            return -1;
+    }
 
-int
-gf_string2percent_or_bytesize (const char *str, double *n,
-			       gf_boolean_t *is_percent)
-{
-        double value = 0ULL;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    /* Error out if we cannot store the value in uint64 */
+    if ((UINT64_MAX - value) < 0) {
+        errno = ERANGE;
+        return -1;
+    }
 
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
+    *n = value;
 
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
-
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
-
-        if (errno == 0)
-                errno = old_errno;
-
-        /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/
-        if (tail[0] != '\0') {
-                if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0)
-                        value *= GF_UNIT_KB;
-                else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0)
-                        value *= GF_UNIT_MB;
-                else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0)
-                        value *= GF_UNIT_GB;
-                else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0)
-                        value *= GF_UNIT_TB;
-                else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0)
-                        value *= GF_UNIT_PB;
-		else if (strcasecmp (tail, GF_UNIT_PERCENT_STRING) == 0)
-			*is_percent = _gf_true;
-                else
-                        return -1;
-        }
+    return 0;
+}
 
-        /* Error out if we cannot store the value in uint64 */
-        if ((UINT64_MAX - value) < 0) {
-                errno = ERANGE;
-                return -1;
-        }
+int64_t
+gf_str_to_long_long(const char *number)
+{
+    int64_t unit = 1;
+    int64_t ret = 0;
+    char *endptr = NULL;
+    if (!number)
+        return 0;
 
-        *n = value;
+    ret = strtoll(number, &endptr, 0);
 
-        return 0;
+    if (endptr) {
+        switch (*endptr) {
+            case 'G':
+            case 'g':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024 * 1024 * 1024;
+                break;
+            case 'M':
+            case 'm':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024 * 1024;
+                break;
+            case 'K':
+            case 'k':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024;
+                break;
+            case '%':
+                unit = 1;
+                break;
+            default:
+                unit = 1;
+                break;
+        }
+    }
+    return ret * unit;
 }
 
-int64_t
-gf_str_to_long_long (const char *number)
+int
+gf_string2boolean(const char *str, gf_boolean_t *b)
 {
-        int64_t unit = 1;
-        int64_t ret = 0;
-        char *endptr = NULL ;
-        if (!number)
-                return 0;
+    if (str == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return -1;
+    }
 
-        ret = strtoll (number, &endptr, 0);
-
-        if (endptr) {
-                switch (*endptr) {
-                case 'G':
-                case 'g':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024 * 1024 * 1024;
-                        break;
-                case 'M':
-                case 'm':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024 * 1024;
-                        break;
-                case 'K':
-                case 'k':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024;
-                        break;
-                case '%':
-                        unit = 1;
-                        break;
-                default:
-                        unit = 1;
-                        break;
-                }
-        }
-        return ret * unit;
+    if ((strcasecmp(str, "1") == 0) || (strcasecmp(str, "on") == 0) ||
+        (strcasecmp(str, "yes") == 0) || (strcasecmp(str, "true") == 0) ||
+        (strcasecmp(str, "enable") == 0)) {
+        *b = _gf_true;
+        return 0;
+    }
+
+    if ((strcasecmp(str, "0") == 0) || (strcasecmp(str, "off") == 0) ||
+        (strcasecmp(str, "no") == 0) || (strcasecmp(str, "false") == 0) ||
+        (strcasecmp(str, "disable") == 0)) {
+        *b = _gf_false;
+        return 0;
+    }
+
+    return -1;
 }
 
 int
-gf_string2boolean (const char *str, gf_boolean_t *b)
+gf_strn2boolean(const char *str, const int len, gf_boolean_t *b)
 {
-        if (str == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return -1;
-        }
+    if (str == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return -1;
+    }
 
-        if ((strcasecmp (str, "1") == 0) ||
-            (strcasecmp (str, "on") == 0) ||
-            (strcasecmp (str, "yes") == 0) ||
-            (strcasecmp (str, "true") == 0) ||
-            (strcasecmp (str, "enable") == 0)) {
+    switch (len) {
+        case 1:
+            if (strcasecmp(str, "1") == 0) {
                 *b = _gf_true;
                 return 0;
-        }
-
-        if ((strcasecmp (str, "0") == 0) ||
-            (strcasecmp (str, "off") == 0) ||
-            (strcasecmp (str, "no") == 0) ||
-            (strcasecmp (str, "false") == 0) ||
-            (strcasecmp (str, "disable") == 0)) {
+            } else if (strcasecmp(str, "0") == 0) {
                 *b = _gf_false;
                 return 0;
-        }
-
-        return -1;
+            }
+            break;
+        case 2:
+            if (strcasecmp(str, "on") == 0) {
+                *b = _gf_true;
+                return 0;
+            } else if (strcasecmp(str, "no") == 0) {
+                *b = _gf_false;
+                return 0;
+            }
+            break;
+        case 3:
+            if (strcasecmp(str, "yes") == 0) {
+                *b = _gf_true;
+                return 0;
+            } else if (strcasecmp(str, "off") == 0) {
+                *b = _gf_false;
+                return 0;
+            }
+            break;
+        case 4:
+            if (strcasecmp(str, "true") == 0) {
+                *b = _gf_true;
+                return 0;
+            }
+            break;
+        case 5:
+            if (strcasecmp(str, "false") == 0) {
+                *b = _gf_false;
+                return 0;
+            }
+            break;
+        case 6:
+            if (strcasecmp(str, "enable") == 0) {
+                *b = _gf_true;
+                return 0;
+            }
+            break;
+        case 7:
+            if (strcasecmp(str, "disable") == 0) {
+                *b = _gf_false;
+                return 0;
+            }
+            break;
+        default:
+            return -1;
+            break;
+    }
+    return -1;
 }
 
-
 int
-gf_lockfd (int fd)
+gf_lockfd(int fd)
 {
-        struct gf_flock fl;
+    struct gf_flock fl;
 
-        fl.l_type = F_WRLCK;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = 0;
-        fl.l_len = 0;
+    fl.l_type = F_WRLCK;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
 
-        return fcntl (fd, F_SETLK, &fl);
+    return fcntl(fd, F_SETLK, &fl);
 }
 
-
 int
-gf_unlockfd (int fd)
+gf_unlockfd(int fd)
 {
-        struct gf_flock fl;
+    struct gf_flock fl;
 
-        fl.l_type = F_UNLCK;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = 0;
-        fl.l_len = 0;
+    fl.l_type = F_UNLCK;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
 
-        return fcntl (fd, F_SETLK, &fl);
+    return fcntl(fd, F_SETLK, &fl);
 }
 
 static void
-compute_checksum (char *buf, size_t size, uint32_t *checksum)
+compute_checksum(char *buf, const ssize_t size, uint32_t *checksum)
 {
-        int  ret = -1;
-        char *checksum_buf = NULL;
+    int ret = -1;
+    char *checksum_buf = NULL;
 
-        checksum_buf = (char *)(checksum);
+    checksum_buf = (char *)(checksum);
 
-        if (!(*checksum)) {
-                checksum_buf [0] = 0xba;
-                checksum_buf [1] = 0xbe;
-                checksum_buf [2] = 0xb0;
-                checksum_buf [3] = 0x0b;
-        }
+    if (!(*checksum)) {
+        checksum_buf[0] = 0xba;
+        checksum_buf[1] = 0xbe;
+        checksum_buf[2] = 0xb0;
+        checksum_buf[3] = 0x0b;
+    }
 
-        for (ret = 0; ret < (size - 4); ret += 4) {
-                checksum_buf[0] ^= (buf[ret]);
-                checksum_buf[1] ^= (buf[ret + 1] << 1) ;
-                checksum_buf[2] ^= (buf[ret + 2] << 2);
-                checksum_buf[3] ^= (buf[ret + 3] << 3);
-        }
+    for (ret = 0; ret < (size - 4); ret += 4) {
+        checksum_buf[0] ^= (buf[ret]);
+        checksum_buf[1] ^= (buf[ret + 1] << 1);
+        checksum_buf[2] ^= (buf[ret + 2] << 2);
+        checksum_buf[3] ^= (buf[ret + 3] << 3);
+    }
 
-        for (ret = 0; ret <= (size % 4); ret++) {
-                checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret);
-        }
+    for (ret = 0; ret <= (size % 4); ret++) {
+        checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret);
+    }
 
-        return;
+    return;
 }
 
 #define GF_CHECKSUM_BUF_SIZE 1024
 
 int
-get_checksum_for_file (int fd, uint32_t *checksum)
+get_checksum_for_file(int fd, uint32_t *checksum, int op_version)
 {
-        int ret = -1;
-        char buf[GF_CHECKSUM_BUF_SIZE] = {0,};
+    int ret = -1;
+    char buf[GF_CHECKSUM_BUF_SIZE] = {
+        0,
+    };
 
-        /* goto first place */
-        sys_lseek (fd, 0L, SEEK_SET);
-        do {
-                ret = sys_read (fd, &buf, GF_CHECKSUM_BUF_SIZE);
-                if (ret > 0)
-                        compute_checksum (buf, GF_CHECKSUM_BUF_SIZE,
-                                          checksum);
-        } while (ret > 0);
+    /* goto first place */
+    sys_lseek(fd, 0L, SEEK_SET);
+    do {
+        ret = sys_read(fd, &buf, GF_CHECKSUM_BUF_SIZE);
+        if (ret > 0) {
+            if (op_version < GD_OP_VERSION_5_4)
+                compute_checksum(buf, GF_CHECKSUM_BUF_SIZE, checksum);
+            else
+                compute_checksum(buf, ret, checksum);
+        }
+    } while (ret > 0);
 
-        /* set it back */
-        sys_lseek (fd, 0L, SEEK_SET);
+    /* set it back */
+    sys_lseek(fd, 0L, SEEK_SET);
 
-        return ret;
+    return ret;
 }
 
-
 int
-get_checksum_for_path (char *path, uint32_t *checksum)
+get_checksum_for_path(char *path, uint32_t *checksum, int op_version)
 {
-        int     ret = -1;
-        int     fd = -1;
+    int ret = -1;
+    int fd = -1;
 
-        GF_ASSERT (path);
-        GF_ASSERT (checksum);
+    GF_ASSERT(path);
+    GF_ASSERT(checksum);
 
-        fd = open (path, O_RDWR);
+    fd = open(path, O_RDWR);
 
-        if (fd == -1) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR,
-                        "Unable to open %s", path);
-                goto out;
-        }
+    if (fd == -1) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_OPEN_FAILED,
+                "path=%s", path, NULL);
+        goto out;
+    }
 
-        ret = get_checksum_for_file (fd, checksum);
+    ret = get_checksum_for_file(fd, checksum, op_version);
 
 out:
-        if (fd != -1)
-                sys_close (fd);
+    if (fd != -1)
+        sys_close(fd);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -1975,26 +2137,25 @@ out:
  *           errors : Errors returned by the stat () call
  */
 int
-get_file_mtime (const char *path, time_t *stamp)
+get_file_mtime(const char *path, time_t *stamp)
 {
-        struct stat     f_stat  = {0};
-        int             ret     = -EINVAL;
+    struct stat f_stat = {0};
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, path, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, stamp, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, path, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, stamp, out);
 
-        ret = sys_stat (path, &f_stat);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FILE_STAT_FAILED, "failed to stat %s",
-                        path);
-                goto out;
-        }
+    ret = sys_stat(path, &f_stat);
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+                "path=%s", path, NULL);
+        goto out;
+    }
 
-        /* Set the mtime */
-        *stamp = f_stat.st_mtime;
+    /* Set the mtime */
+    *stamp = f_stat.st_mtime;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2006,150 +2167,118 @@ out:
  * @ip_str : The IP to check
  * @network: The network to check the IP against.
  *
- * @return: success: 0
+ * @return: success: _gf_true
  *          failure: -EINVAL for bad args, retval of inet_pton otherwise
  */
 gf_boolean_t
-gf_is_ip_in_net (const char *network, const char *ip_str)
-{
-        unsigned long ip_buf       = 0;
-        unsigned long net_ip_buf   = 0;
-        unsigned long subnet_mask  = 0;
-        int           ret          = -EINVAL;
-        char          *slash       = NULL;
-        char          *net_ip      = NULL;
-        char          *subnet      = NULL;
-        char          *net_str     = NULL;
-        int           family       = AF_INET;
-        gf_boolean_t  result       = _gf_false;
-
-        GF_ASSERT (network);
-        GF_ASSERT (ip_str);
-
-        if (strchr (network, ':'))
-                family = AF_INET6;
-        else if (strchr (network, '.'))
-                family = AF_INET;
-        else {
-                family = -1;
-                goto out;
-        }
-
-        net_str = strdupa (network);
-        slash = strchr (net_str, '/');
-        if (!slash)
-                goto out;
-        *slash = '\0';
-
-        subnet = slash + 1;
-        net_ip = net_str;
-
-        /* Convert IP address to a long */
-        ret = inet_pton (family, ip_str, &ip_buf);
-        if (ret < 0)
-                gf_msg ("common-utils", GF_LOG_ERROR, errno,
-                        LG_MSG_INET_PTON_FAILED, "inet_pton() failed");
-
-        /* Convert network IP address to a long */
-        ret = inet_pton (family, net_ip, &net_ip_buf);
-        if (ret < 0) {
-                gf_msg ("common-utils", GF_LOG_ERROR, errno,
-                        LG_MSG_INET_PTON_FAILED, "inet_pton() failed");
-                goto out;
-        }
-
-        /* Converts /x into a mask */
-        subnet_mask = (1 << atoi (subnet)) - 1;
-
-        result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask));
+gf_is_ip_in_net(const char *network, const char *ip_str)
+{
+    unsigned long ip_buf = 0;
+    unsigned long net_ip_buf = 0;
+    unsigned long subnet_mask = 0;
+    int ret = -EINVAL;
+    char *slash = NULL;
+    char *net_ip = NULL;
+    char *subnet = NULL;
+    char *net_str = NULL;
+    int family = AF_INET;
+    gf_boolean_t result = _gf_false;
+
+    GF_ASSERT(network);
+    GF_ASSERT(ip_str);
+
+    if (strchr(network, ':'))
+        family = AF_INET6;
+    else if (strchr(network, '.'))
+        family = AF_INET;
+    else {
+        goto out;
+    }
+
+    net_str = strdupa(network);
+    slash = strchr(net_str, '/');
+    if (!slash)
+        goto out;
+    *slash = '\0';
+
+    subnet = slash + 1;
+    net_ip = net_str;
+
+    /* Convert IP address to a long */
+    ret = inet_pton(family, ip_str, &ip_buf);
+    if (ret < 0)
+        gf_smsg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+                NULL);
+
+    /* Convert network IP address to a long */
+    ret = inet_pton(family, net_ip, &net_ip_buf);
+    if (ret < 0) {
+        gf_smsg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+                NULL);
+        goto out;
+    }
+
+    /* Converts /x into a mask */
+    subnet_mask = (1 << atoi(subnet)) - 1;
+
+    result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask));
 out:
-        return result;
+    return result;
 }
 
 char *
-strtail (char *str, const char *pattern)
+strtail(char *str, const char *pattern)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; str[i] == pattern[i] && str[i]; i++);
+    for (i = 0; str[i] == pattern[i] && str[i]; i++)
+        ;
 
-        if (pattern[i] == '\0')
-                return str + i;
+    if (pattern[i] == '\0')
+        return str + i;
 
-        return NULL;
+    return NULL;
 }
 
 void
-skipwhite (char **s)
+skipwhite(char **s)
 {
-        while (isspace (**s))
-                (*s)++;
+    while (isspace(**s))
+        (*s)++;
 }
 
-char *
-nwstrtail (char *str, char *pattern)
+void
+gf_strTrim(char **s)
 {
-        for (;;) {
-                skipwhite (&str);
-                skipwhite (&pattern);
+    char *end = NULL;
 
-                if (*str != *pattern || !*str)
-                        break;
+    end = *s + strlen(*s) - 1;
+    while (end > *s && isspace((unsigned char)*end))
+        end--;
 
-                str++;
-                pattern++;
-        }
+    *(end + 1) = '\0';
 
-        return *pattern ? NULL : str;
-}
+    while (isspace(**s))
+        (*s)++;
 
-void
-skipword (char **s)
-{
-        if (!*s)
-                return;
-
-        skipwhite (s);
-
-        while (!isspace(**s))
-                (*s)++;
+    return;
 }
 
 char *
-get_nth_word (const char *str, int n)
+nwstrtail(char *str, char *pattern)
 {
-        char           buf[4096] = {0};
-        char          *start     = NULL;
-        char          *word      = NULL;
-        int            i         = 0;
-        int            word_len  = 0;
-        const char    *end       = NULL;
-
-        if (!str)
-                goto out;
-
-        snprintf (buf, sizeof (buf), "%s", str);
-        start = buf;
+    for (;;) {
+        skipwhite(&str);
+        skipwhite(&pattern);
 
-        for (i = 0; i < n-1; i++)
-                skipword (&start);
+        if (*str != *pattern || !*str)
+            break;
 
-        skipwhite (&start);
-        end = strpbrk ((const char *)start, " \t\n\0");
-
-        if (!end)
-                goto out;
+        str++;
+        pattern++;
+    }
 
-        word_len = labs (end - start);
-
-        word = GF_CALLOC (1, word_len + 1, gf_common_mt_strdup);
-        if (!word)
-                goto out;
-
-        strncpy (word, start, word_len);
-        *(word + word_len) = '\0';
- out:
-        return word;
+    return *pattern ? NULL : str;
 }
 
 /**
@@ -2166,12 +2295,12 @@ get_nth_word (const char *str, int n)
  * next_token().
  */
 char *
-token_iter_init (char *str, char sep, token_iter_t *tit)
+token_iter_init(char *str, char sep, token_iter_t *tit)
 {
-        tit->end = str + strlen (str);
-        tit->sep = sep;
+    tit->end = str + strlen(str);
+    tit->sep = sep;
 
-        return str;
+    return str;
 }
 
 /**
@@ -2191,30 +2320,32 @@ token_iter_init (char *str, char sep, token_iter_t *tit)
  * apart from dropped tokens (see drop_token()).
  */
 gf_boolean_t
-next_token (char **tokenp, token_iter_t *tit)
-{
-        char        *cursor  = NULL;
-        gf_boolean_t is_last = _gf_false;
-
-        for (cursor = *tokenp; *cursor; cursor++);
-        if (cursor < tit->end) {
-                /*
-                 * We detect that in between current token and end a zero
-                 * marker has already been inserted. This means that the
-                 * token has already been returned. We restore the
-                 * separator and move ahead.
-                 */
-                *cursor = tit->sep;
-                *tokenp = cursor + 1;
-        }
+next_token(char **tokenp, token_iter_t *tit)
+{
+    char *cursor = NULL;
+    gf_boolean_t is_last = _gf_false;
+
+    for (cursor = *tokenp; *cursor; cursor++)
+        ;
+    if (cursor < tit->end) {
+        /*
+         * We detect that in between current token and end a zero
+         * marker has already been inserted. This means that the
+         * token has already been returned. We restore the
+         * separator and move ahead.
+         */
+        *cursor = tit->sep;
+        *tokenp = cursor + 1;
+    }
 
-        for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++);
-        /* If the cursor ended up on a zero byte, then it's the last token. */
-        is_last = !*cursor;
-        /* Zero-terminate the token. */
-        *cursor = 0;
+    for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++)
+        ;
+    /* If the cursor ended up on a zero byte, then it's the last token. */
+    is_last = !*cursor;
+    /* Zero-terminate the token. */
+    *cursor = 0;
 
-        return is_last;
+    return is_last;
 }
 
 /*
@@ -2227,7 +2358,7 @@ next_token (char **tokenp, token_iter_t *tit)
  * #include <stdio.h>
  * #include <stdlib.h>
  * #include <string.h>
- * #include "common-utils.h"
+ * #include "glusterfs/common-utils.h"
  *
  * int
  * main (int argc, char **argv)
@@ -2265,148 +2396,173 @@ next_token (char **tokenp, token_iter_t *tit)
  * }
  */
 void
-drop_token (char *token, token_iter_t *tit)
-{
-        char *cursor = NULL;
-
-        for (cursor = token; *cursor; cursor++);
-        if (cursor < tit->end) {
-                /*
-                 * We detect a zero inserted by next_token().
-                 * Step the cursor and copy what comes after
-                 * to token.
-                 */
-                for (cursor++; cursor < tit->end; *token++ = *cursor++);
-        }
+drop_token(char *token, token_iter_t *tit)
+{
+    char *cursor = NULL;
 
+    for (cursor = token; *cursor; cursor++)
+        ;
+    if (cursor < tit->end) {
         /*
-         * Zero out the remainder of the buffer.
-         * It would be enough to insert just a single zero,
-         * but we continue 'till the end to have cleaner
-         * memory content.
+         * We detect a zero inserted by next_token().
+         * Step the cursor and copy what comes after
+         * to token.
          */
-        for (cursor = token; cursor < tit->end; *cursor++ = 0);
+        for (cursor++; cursor < tit->end; *token++ = *cursor++)
+            ;
+    }
+
+    /*
+     * Zero out the remainder of the buffer.
+     * It would be enough to insert just a single zero,
+     * but we continue 'till the end to have cleaner
+     * memory content.
+     */
+    for (cursor = token; cursor < tit->end; *cursor++ = 0)
+        ;
 
-        /* Adjust the end to point to the new terminating zero. */
-        tit->end = token;
+    /* Adjust the end to point to the new terminating zero. */
+    tit->end = token;
 }
 
 /* Syntax formed according to RFC 1912 (RFC 1123 & 952 are more restrictive)  *
    <hname> ::= <gen-name>*["."<gen-name>]                                     *
    <gen-name> ::= <let-or-digit> <[*[<let-or-digit-or-hyphen>]<let-or-digit>] */
 char
-valid_host_name (char *address, int length)
+valid_host_name(char *address, int length)
 {
-        int             i = 0;
-        int             str_len = 0;
-        char            ret = 1;
-        char            *dup_addr = NULL;
-        char            *temp_str = NULL;
-        char            *save_ptr = NULL;
+    int i = 0;
+    int str_len = 0;
+    char ret = 1;
+    char *dup_addr = NULL;
+    char *temp_str = NULL;
+    char *save_ptr = NULL;
 
-        if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) {
-                ret = 0;
-                goto out;
-        }
+    if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) {
+        ret = 0;
+        goto out;
+    }
 
-        dup_addr = gf_strdup (address);
-        if (!dup_addr) {
-                ret = 0;
-                goto out;
-        }
+    dup_addr = gf_strdup(address);
+    if (!dup_addr) {
+        ret = 0;
+        goto out;
+    }
 
-        if (!isalnum (dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) {
+    if (!isalnum(dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) {
+        ret = 0;
+        goto out;
+    }
+
+    /* Check for consecutive dots, which is invalid in a hostname and is
+     * ignored by strtok()
+     */
+    if (strstr(dup_addr, "..")) {
+        ret = 0;
+        goto out;
+    }
+
+    /* gen-name */
+    temp_str = strtok_r(dup_addr, ".", &save_ptr);
+    do {
+        str_len = strlen(temp_str);
+
+        if (!isalnum(temp_str[0]) || !isalnum(temp_str[str_len - 1])) {
+            ret = 0;
+            goto out;
+        }
+        for (i = 1; i < str_len; i++) {
+            if (!isalnum(temp_str[i]) && (temp_str[i] != '-')) {
                 ret = 0;
                 goto out;
+            }
         }
+    } while ((temp_str = strtok_r(NULL, ".", &save_ptr)));
 
-        /* Check for consecutive dots, which is invalid in a hostname and is
-         * ignored by strtok()
-         */
-        if (strstr (dup_addr, "..")) {
+out:
+    GF_FREE(dup_addr);
+    return ret;
+}
+
+/*  Matches all ipv4 address, if wildcard_acc is true  '*' wildcard pattern for*
+  subnets is considered as valid strings as well */
+char
+valid_ipv4_address(char *address, int length, gf_boolean_t wildcard_acc)
+{
+    int octets = 0;
+    int value = 0;
+    char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
+    char ret = 1;
+    int is_wildcard = 0;
+
+    tmp = gf_strdup(address);
+
+    /*
+     * To prevent cases where last character is '.' and which have
+     * consecutive dots like ".." as strtok ignore consecutive
+     * delimiters.
+     */
+    if (length <= 0 || (strstr(address, "..")) ||
+        (!isdigit(tmp[length - 1]) && (tmp[length - 1] != '*'))) {
+        ret = 0;
+        goto out;
+    }
+
+    prev = strtok_r(tmp, ".", &ptr);
+
+    while (prev != NULL) {
+        octets++;
+        if (wildcard_acc && !strcmp(prev, "*")) {
+            is_wildcard = 1;
+        } else {
+            value = strtol(prev, &endptr, 10);
+            if ((value > 255) || (value < 0) ||
+                (endptr != NULL && *endptr != '\0')) {
                 ret = 0;
                 goto out;
+            }
         }
+        prev = strtok_r(NULL, ".", &ptr);
+    }
 
-        /* gen-name */
-        temp_str = strtok_r (dup_addr, ".", &save_ptr);
-        do {
-                str_len = strlen (temp_str);
-
-                if (!isalnum (temp_str[0]) ||
-                    !isalnum (temp_str[str_len-1])) {
-                        ret = 0;
-                        goto out;
-                }
-                for (i = 1; i < str_len; i++) {
-                        if (!isalnum (temp_str[i]) && (temp_str[i] != '-')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-        } while ((temp_str = strtok_r (NULL, ".", &save_ptr)));
+    if ((octets > 4) || (octets < 4 && !is_wildcard)) {
+        ret = 0;
+    }
 
 out:
-        GF_FREE (dup_addr);
-        return ret;
+    GF_FREE(tmp);
+    return ret;
 }
 
-/*  Matches all ipv4 address, if wildcard_acc is true  '*' wildcard pattern for*
-  subnets is considered as valid strings as well                               */
 char
-valid_ipv4_address (char *address, int length, gf_boolean_t wildcard_acc)
+valid_cidr_address(char *cidr_address, gf_boolean_t wildcard_acc)
 {
-        int octets = 0;
-        int value = 0;
-        char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
-        char ret = 1;
-        int is_wildcard = 0;
+    unsigned int net_mask = 0, len = 0;
+    char *temp = NULL, *cidr_str = NULL, ret = 1;
 
-        tmp = gf_strdup (address);
+    cidr_str = strdupa(cidr_address);
+    temp = strstr(cidr_str, "/");
+    if (temp == NULL)
+        return 0; /* Since Invalid cidr ip address we return 0 */
 
-        /*
-         * To prevent cases where last character is '.' and which have
-         * consecutive dots like ".." as strtok ignore consecutive
-         * delimeters.
-         */
-        if (length <= 0 ||
-            (strstr (address, "..")) ||
-            (!isdigit (tmp[length - 1]) && (tmp[length - 1] != '*'))) {
-                ret = 0;
-                goto out;
-        }
+    *temp = '\0';
+    temp++;
+    net_mask = (unsigned int)atoi(temp);
 
-        prev = tmp;
-        prev = strtok_r (tmp, ".", &ptr);
-
-        while (prev != NULL) {
-                octets++;
-                if (wildcard_acc && !strcmp (prev, "*")) {
-                        is_wildcard = 1;
-                } else {
-                        value = strtol (prev, &endptr, 10);
-                        if ((value > 255) || (value < 0) ||
-                            (endptr != NULL && *endptr != '\0')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-                prev = strtok_r (NULL, ".", &ptr);
-        }
+    if (net_mask > 32 || net_mask < 1)
+        return 0; /* Since Invalid cidr ip address we return 0*/
 
-        if ((octets > 4) || (octets < 4 && !is_wildcard)) {
-                ret = 0;
-        }
+    len = strlen(cidr_str);
 
-out:
-        GF_FREE (tmp);
-        return ret;
+    ret = valid_ipv4_address(cidr_str, len, wildcard_acc);
+
+    return ret;
 }
 
 /**
  * valid_ipv4_subnetwork() takes the pattern and checks if it contains
  * a valid ipv4 subnetwork pattern i.e. xx.xx.xx.xx/n. IPv4 address
- * part (xx.xx.xx.xx) and mask bits lengh part (n). The mask bits lengh
+ * part (xx.xx.xx.xx) and mask bits length part (n). The mask bits length
  * must be in 0-32 range (ipv4 addr is 32 bit). The pattern must be
  * in this format.
  *
@@ -2414,149 +2570,158 @@ out:
  *         _gf_false otherwise.
  */
 gf_boolean_t
-valid_ipv4_subnetwork (const char *address)
+valid_ipv4_subnetwork(const char *address)
 {
-        char         *slash     = NULL;
-        char         *paddr     = NULL;
-        char         *endptr    = NULL;
-        long         prefixlen  = -1;
-        gf_boolean_t retv       = _gf_true;
+    char *slash = NULL;
+    char *paddr = NULL;
+    char *endptr = NULL;
+    long prefixlen = -1;
+    gf_boolean_t retv = _gf_true;
 
-        if (address == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return _gf_false;
-        }
-
-        paddr = gf_strdup (address);
-        if (paddr == NULL) /* ENOMEM */
-                return _gf_false;
-
-        /*
-         * INVALID: If '/' is not present OR
-         *          Nothing specified after '/'
-         */
-        slash = strchr(paddr, '/');
-        if ((slash == NULL) || (slash[1] == '\0')) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT, "Invalid IPv4 "
-                                  "subnetwork format");
-                retv = _gf_false;
-                goto out;
-        }
-
-        *slash = '\0';
-        retv = valid_ipv4_address (paddr, strlen(paddr), _gf_false);
-        if (retv == _gf_false) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT,
-                                  "Invalid IPv4 subnetwork address");
-                goto out;
-        }
+    if (address == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return _gf_false;
+    }
 
-        prefixlen = strtol (slash + 1, &endptr, 10);
-        if ((errno != 0) || (*endptr != '\0') ||
-            (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT,
-                                  "Invalid IPv4 subnetwork mask");
-                retv = _gf_false;
-                goto out;
-        }
+    paddr = gf_strdup(address);
+    if (paddr == NULL) /* ENOMEM */
+        return _gf_false;
 
-        retv = _gf_true;
+    /*
+     * INVALID: If '/' is not present OR
+     *          Nothing specified after '/'
+     */
+    slash = strchr(paddr, '/');
+    if ((slash == NULL) || (slash[1] == '\0')) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 "
+                         "subnetwork format");
+        retv = _gf_false;
+        goto out;
+    }
+
+    *slash = '\0';
+    retv = valid_ipv4_address(paddr, strlen(paddr), _gf_false);
+    if (retv == _gf_false) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 subnetwork address");
+        goto out;
+    }
+    /*
+     * Reset errno before checking it
+     */
+    errno = 0;
+    prefixlen = strtol(slash + 1, &endptr, 10);
+    if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) ||
+        (prefixlen > IPv4_ADDR_SIZE)) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 subnetwork mask");
+        retv = _gf_false;
+        goto out;
+    }
+
+    retv = _gf_true;
 out:
-        GF_FREE (paddr);
-        return retv;
+    GF_FREE(paddr);
+    return retv;
 }
 
 char
-valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc)
-{
-        int hex_numbers = 0;
-        int value = 0;
-        int i = 0;
-        char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
-        char ret = 1;
-        int is_wildcard = 0;
-        int is_compressed = 0;
-
-        tmp = gf_strdup (address);
-
-        /* Check for '%' for link local addresses */
-        endptr = strchr(tmp, '%');
-        if (endptr) {
-                *endptr = '\0';
-                length = strlen(tmp);
-                endptr = NULL;
-        }
-
-        /* Check for compressed form */
-        if (length <= 0 || tmp[length - 1] == ':') {
+valid_ipv6_address(char *address, int length, gf_boolean_t wildcard_acc)
+{
+    int hex_numbers = 0;
+    int value = 0;
+    int i = 0;
+    char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
+    char ret = 1;
+    int is_wildcard = 0;
+    int is_compressed = 0;
+
+    tmp = gf_strdup(address);
+
+    /* Check for '%' for link local addresses */
+    endptr = strchr(tmp, '%');
+    if (endptr) {
+        *endptr = '\0';
+        length = strlen(tmp);
+        endptr = NULL;
+    }
+
+    /* Check for compressed form */
+    if (length <= 0 || tmp[length - 1] == ':') {
+        ret = 0;
+        goto out;
+    }
+    for (i = 0; i < (length - 1); i++) {
+        if (tmp[i] == ':' && tmp[i + 1] == ':') {
+            if (is_compressed == 0)
+                is_compressed = 1;
+            else {
                 ret = 0;
                 goto out;
+            }
         }
-        for (i = 0; i < (length - 1) ; i++) {
-                if (tmp[i] == ':' && tmp[i + 1] == ':') {
-                        if (is_compressed == 0)
-                                is_compressed = 1;
-                        else {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-        }
+    }
 
-        prev = strtok_r (tmp, ":", &ptr);
-
-        while (prev != NULL) {
-                hex_numbers++;
-                if (wildcard_acc && !strcmp (prev, "*")) {
-                        is_wildcard = 1;
-                } else {
-                        value = strtol (prev, &endptr, 16);
-                        if ((value > 0xffff) || (value < 0)
-                        || (endptr != NULL && *endptr != '\0')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-                prev = strtok_r (NULL, ":", &ptr);
-        }
+    prev = strtok_r(tmp, ":", &ptr);
 
-        if ((hex_numbers > 8) || (hex_numbers < 8 && !is_wildcard
-            && !is_compressed)) {
+    while (prev != NULL) {
+        hex_numbers++;
+        if (wildcard_acc && !strcmp(prev, "*")) {
+            is_wildcard = 1;
+        } else {
+            value = strtol(prev, &endptr, 16);
+            if ((value > 0xffff) || (value < 0) ||
+                (endptr != NULL && *endptr != '\0')) {
                 ret = 0;
+                goto out;
+            }
         }
+        prev = strtok_r(NULL, ":", &ptr);
+    }
+
+    if ((hex_numbers > 8) ||
+        (hex_numbers < 8 && !is_wildcard && !is_compressed)) {
+        ret = 0;
+    }
 
 out:
-        GF_FREE (tmp);
-        return ret;
+    GF_FREE(tmp);
+    return ret;
 }
 
 char
-valid_internet_address (char *address, gf_boolean_t wildcard_acc)
+valid_internet_address(char *address, gf_boolean_t wildcard_acc,
+                       gf_boolean_t cidr)
 {
-        char ret = 0;
-        int length = 0;
+    char ret = 0;
+    int length = 0;
 
-        if (address == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                goto out;
-        }
+    if (address == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        goto out;
+    }
 
-        length = strlen (address);
-        if (length == 0)
-                goto out;
+    length = strlen(address);
+    if (length == 0)
+        goto out;
 
-        if (valid_ipv4_address (address, length, wildcard_acc)
-            || valid_ipv6_address (address, length, wildcard_acc)
-            || valid_host_name (address, length))
-                ret = 1;
+    if (cidr && valid_cidr_address(address, wildcard_acc)) {
+        ret = 1;
+    }
+
+    if (valid_ipv4_address(address, length, wildcard_acc) ||
+        valid_ipv6_address(address, length, wildcard_acc) ||
+        valid_host_name(address, length))
+        ret = 1;
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2566,56 +2731,56 @@ out:
  *
  * @return _gf_true if "address" is "*" (anonymous) 'OR'
  *                  if "address" is valid FQDN or valid IPv4/6 address 'OR'
- *                  if "address" contains wildcard chars e.g. "'*' or '?' or '['"
- *                  if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n)
- *         _gf_false otherwise
+ *                  if "address" contains wildcard chars e.g. "'*' or '?' or
+ * '['" if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n) _gf_false
+ * otherwise
  *
  *
  * NB: If the user/admin set for wildcard pattern, then it does not have
  *     to be validated. Make it similar to the way exportfs (kNFS) works.
  */
 gf_boolean_t
-valid_mount_auth_address (char *address)
+valid_mount_auth_address(char *address)
 {
-        int    length = 0;
-        char   *cp    = NULL;
+    int length = 0;
+    char *cp = NULL;
 
-        /* 1. Check for "NULL and empty string */
-        if ((address == NULL) || (address[0] == '\0')){
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return _gf_false;
-        }
+    /* 1. Check for "NULL and empty string */
+    if ((address == NULL) || (address[0] == '\0')) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return _gf_false;
+    }
 
-        /* 2. Check for Anonymous */
-        if (strcmp(address, "*") == 0)
-                return _gf_true;
+    /* 2. Check for Anonymous */
+    if (strcmp(address, "*") == 0)
+        return _gf_true;
 
-        for (cp = address; *cp; cp++) {
-                /* 3. Check for wildcard pattern */
-                if (*cp == '*' || *cp == '?' || *cp == '[') {
-                        return _gf_true;
-                }
-
-                /*
-                 * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n
-                 * TODO: check for IPv6 subnetwork
-                 * NB: Wildcard must not be mixed with subnetwork.
-                 */
-                if (*cp == '/') {
-                        return valid_ipv4_subnetwork (address);
-                }
+    for (cp = address; *cp; cp++) {
+        /* 3. Check for wildcard pattern */
+        if (*cp == '*' || *cp == '?' || *cp == '[') {
+            return _gf_true;
         }
 
-        /* 5. Check for v4/v6 IP addr and FQDN/hostname */
-        length = strlen (address);
-        if ((valid_ipv4_address (address, length, _gf_false)) ||
-            (valid_ipv6_address (address, length, _gf_false)) ||
-            (valid_host_name (address, length))) {
-                return _gf_true;
+        /*
+         * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n
+         * TODO: check for IPv6 subnetwork
+         * NB: Wildcard must not be mixed with subnetwork.
+         */
+        if (*cp == '/') {
+            return valid_ipv4_subnetwork(address);
         }
+    }
 
-        return _gf_false;
+    /* 5. Check for v4/v6 IP addr and FQDN/hostname */
+    length = strlen(address);
+    if ((valid_ipv4_address(address, length, _gf_false)) ||
+        (valid_ipv6_address(address, length, _gf_false)) ||
+        (valid_host_name(address, length))) {
+        return _gf_true;
+    }
+
+    return _gf_false;
 }
 
 /**
@@ -2626,40 +2791,39 @@ valid_mount_auth_address (char *address)
  * @return _gf_true if a and b have same ipv{4,6} addr, _gf_false otherwise
  */
 gf_boolean_t
-gf_sock_union_equal_addr (union gf_sock_union *a,
-                          union gf_sock_union *b)
+gf_sock_union_equal_addr(union gf_sock_union *a, union gf_sock_union *b)
 {
-        if (!a || !b) {
-                gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Invalid arguments to gf_sock_union_equal_addr");
-                return _gf_false;
-        }
+    if (!a || !b) {
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+                "gf_sock_union_equal_addr", NULL);
+        return _gf_false;
+    }
 
-        if (a->storage.ss_family != b->storage.ss_family)
-                return _gf_false;
+    if (a->storage.ss_family != b->storage.ss_family)
+        return _gf_false;
 
-        switch (a->storage.ss_family) {
+    switch (a->storage.ss_family) {
         case AF_INET:
-                if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr)
-                        return _gf_true;
-                else
-                        return _gf_false;
+            if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr)
+                return _gf_true;
+            else
+                return _gf_false;
 
         case AF_INET6:
-                if (memcmp ((void *)(&a->sin6.sin6_addr),
-                            (void *)(&b->sin6.sin6_addr),
-                            sizeof (a->sin6.sin6_addr)))
-                        return _gf_false;
-                else
-                        return _gf_true;
+            if (memcmp((void *)(&a->sin6.sin6_addr),
+                       (void *)(&b->sin6.sin6_addr), sizeof(a->sin6.sin6_addr)))
+                return _gf_false;
+            else
+                return _gf_true;
 
         default:
-                gf_msg_debug ("common-utils", 0, "Unsupported/invalid address "
-                              "family");
-                break;
-        }
+            gf_msg_debug("common-utils", 0,
+                         "Unsupported/invalid address "
+                         "family");
+            break;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 /*
@@ -2675,62 +2839,61 @@ gf_sock_union_equal_addr (union gf_sock_union *a,
 gf_boolean_t
 mask_match(const uint32_t a, const uint32_t b, const uint32_t m)
 {
-        return (((a ^ b) & m) == 0);
+    return (((a ^ b) & m) == 0);
 }
 
-
 /*Thread safe conversion function*/
 char *
-uuid_utoa (uuid_t uuid)
+uuid_utoa(uuid_t uuid)
 {
-        char *uuid_buffer = glusterfs_uuid_buf_get ();
-        gf_uuid_unparse (uuid, uuid_buffer);
-        return uuid_buffer;
+    char *uuid_buffer = glusterfs_uuid_buf_get();
+    gf_uuid_unparse(uuid, uuid_buffer);
+    return uuid_buffer;
 }
 
 /*Re-entrant conversion function*/
 char *
-uuid_utoa_r (uuid_t uuid, char *dst)
+uuid_utoa_r(uuid_t uuid, char *dst)
 {
-        if(!dst)
-                return NULL;
-        gf_uuid_unparse (uuid, dst);
-        return dst;
+    if (!dst)
+        return NULL;
+    gf_uuid_unparse(uuid, dst);
+    return dst;
 }
 
 /*Thread safe conversion function*/
 char *
-lkowner_utoa (gf_lkowner_t *lkowner)
+lkowner_utoa(gf_lkowner_t *lkowner)
 {
-        char *lkowner_buffer = glusterfs_lkowner_buf_get ();
-        lkowner_unparse (lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE);
-        return lkowner_buffer;
+    char *lkowner_buffer = glusterfs_lkowner_buf_get();
+    lkowner_unparse(lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE);
+    return lkowner_buffer;
 }
 
 /*Re-entrant conversion function*/
 char *
-lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len)
+lkowner_utoa_r(gf_lkowner_t *lkowner, char *dst, int len)
 {
-        if(!dst)
-                return NULL;
-        lkowner_unparse (lkowner, dst, len);
-        return dst;
+    if (!dst)
+        return NULL;
+    lkowner_unparse(lkowner, dst, len);
+    return dst;
 }
 
 gf_boolean_t
-is_valid_lease_id (const char *lease_id)
+is_valid_lease_id(const char *lease_id)
 {
-        int i = 0;
-        gf_boolean_t valid = _gf_false;
+    int i = 0;
+    gf_boolean_t valid = _gf_false;
 
-        for (i = 0; i < LEASE_ID_SIZE; i++) {
-                if (lease_id[i] != 0) {
-                        valid = _gf_true;
-                        goto out;
-                }
+    for (i = 0; i < LEASE_ID_SIZE; i++) {
+        if (lease_id[i] != 0) {
+            valid = _gf_true;
+            goto out;
         }
+    }
 out:
-        return valid;
+    return valid;
 }
 
 /* Lease_id can be a either in printable or non printable binary
@@ -2747,96 +2910,107 @@ out:
  * subsequent call to this function will override the same buffer.
  */
 char *
-leaseid_utoa (const char *lease_id)
-{
-        char *buf = NULL;
-        int   i   = 0;
-        int   j   = 0;
+leaseid_utoa(const char *lease_id)
+{
+    char *buf = NULL;
+    int i = 0;
+    int j = 0;
+
+    buf = glusterfs_leaseid_buf_get();
+    if (!buf)
+        goto out;
+
+    for (i = 0; i < LEASE_ID_SIZE; i++) {
+        if (i && !(i % 2)) {
+            buf[j] = '-';
+            j++;
+        }
+        sprintf(&buf[j], "%02hhx", lease_id[i]);
+        j += 2;
+        if (j == GF_LEASE_ID_BUF_SIZE)
+            break;
+    }
+    buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0';
+out:
+    return buf;
+}
 
-        buf = glusterfs_leaseid_buf_get ();
-        if (!buf)
-                goto out;
+char *
+gf_leaseid_get()
+{
+    return glusterfs_leaseid_buf_get();
+}
 
-        for (i = 0; i < LEASE_ID_SIZE; i++) {
-                if (i && !(i % 2)) {
-                        buf[j] = '-';
-                        j++;
-                }
-                sprintf (&buf[j], "%02hhx", lease_id[i]);
-                j += 2;
-                if (j == GF_LEASE_ID_BUF_SIZE)
-                        break;
-        }
-        buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0';
-out:
-        return buf;
+char *
+gf_existing_leaseid()
+{
+    return glusterfs_leaseid_exist();
 }
 
-void* gf_array_elem (void *a, int index, size_t elem_size)
+void *
+gf_array_elem(void *a, int index, size_t elem_size)
 {
-        uint8_t* ptr = a;
-        return (void*)(ptr + index * elem_size);
+    uint8_t *ptr = a;
+    return (void *)(ptr + index * elem_size);
 }
 
 void
-gf_elem_swap (void *x, void *y, size_t l) {
-        uint8_t *a = x, *b = y, c;
-        while(l--) {
-                c = *a;
-                *a++ = *b;
-                *b++ = c;
-        }
+gf_elem_swap(void *x, void *y, size_t l)
+{
+    uint8_t *a = x, *b = y, c;
+    while (l--) {
+        c = *a;
+        *a++ = *b;
+        *b++ = c;
+    }
 }
 
 void
-gf_array_insertionsort (void *A, int l, int r, size_t elem_size,
-                        gf_cmp cmp)
-{
-        int  i = l;
-        int  N = r+1;
-        void *Temp = NULL;
-        int  j = 0;
-
-        for(i = l; i < N; i++) {
-                Temp = gf_array_elem (A, i, elem_size);
-                j = i - 1;
-                while (j >= 0 && (cmp (Temp, gf_array_elem (A, j, elem_size))
-                      < 0)) {
-                        gf_elem_swap (Temp, gf_array_elem (A, j, elem_size),
-                                      elem_size);
-                        Temp = gf_array_elem (A, j, elem_size);
-                        j = j-1;
-                }
+gf_array_insertionsort(void *A, int l, int r, size_t elem_size, gf_cmp cmp)
+{
+    int i = l;
+    int N = r + 1;
+    void *Temp = NULL;
+    int j = 0;
+
+    for (i = l; i < N; i++) {
+        Temp = gf_array_elem(A, i, elem_size);
+        j = i - 1;
+        while (j >= 0 && (cmp(Temp, gf_array_elem(A, j, elem_size)) < 0)) {
+            gf_elem_swap(Temp, gf_array_elem(A, j, elem_size), elem_size);
+            Temp = gf_array_elem(A, j, elem_size);
+            j = j - 1;
         }
+    }
 }
 
 int
-gf_is_str_int (const char *value)
+gf_is_str_int(const char *value)
 {
-        int     flag = 0;
-        char   *str  = NULL;
-        char   *fptr = NULL;
+    int flag = 0;
+    char *str = NULL;
+    char *fptr = NULL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, value, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, value, out);
 
-        str = gf_strdup (value);
-        if (!str)
-                goto out;
+    str = gf_strdup(value);
+    if (!str)
+        goto out;
 
-        fptr = str;
+    fptr = str;
 
-        while (*str) {
-                if (!isdigit(*str)) {
-                        flag = 1;
-                        goto out;
-                }
-                str++;
+    while (*str) {
+        if (!isdigit(*str)) {
+            flag = 1;
+            goto out;
         }
+        str++;
+    }
 
 out:
-        GF_FREE (fptr);
+    GF_FREE(fptr);
 
-        return flag;
+    return flag;
 }
 /*
  * rounds up nr to power of two. If nr is already a power of two, just returns
@@ -2844,22 +3018,22 @@ out:
  */
 
 int32_t
-gf_roundup_power_of_two (int32_t nr)
+gf_roundup_power_of_two(int32_t nr)
 {
-        int32_t result = 1;
+    int32_t result = 1;
 
-        if (nr < 0) {
-                gf_msg ("common-utils", GF_LOG_WARNING, 0,
-                        LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed");
-                result = -1;
-                goto out;
-        }
+    if (nr < 0) {
+        gf_smsg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+                NULL);
+        result = -1;
+        goto out;
+    }
 
-        while (result < nr)
-                result *= 2;
+    while (result < nr)
+        result *= 2;
 
 out:
-        return result;
+    return result;
 }
 
 /*
@@ -2868,400 +3042,365 @@ out:
  */
 
 int32_t
-gf_roundup_next_power_of_two (int32_t nr)
+gf_roundup_next_power_of_two(int32_t nr)
 {
-        int32_t result = 1;
+    int32_t result = 1;
 
-        if (nr < 0) {
-                gf_msg ("common-utils", GF_LOG_WARNING, 0,
-                        LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed");
-                result = -1;
-                goto out;
-        }
+    if (nr < 0) {
+        gf_smsg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+                NULL);
+        result = -1;
+        goto out;
+    }
 
-        while (result <= nr)
-                result *= 2;
+    while (result <= nr)
+        result *= 2;
 
 out:
-        return result;
+    return result;
 }
 
 int
-get_vol_type (int type, int dist_count, int brick_count)
+validate_brick_name(char *brick)
 {
-        if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) &&
-             (dist_count < brick_count))
-              type = type + GF_CLUSTER_TYPE_MAX - 1;
+    char *delimiter = NULL;
+    int ret = 0;
+    delimiter = strrchr(brick, ':');
+    if (!delimiter || delimiter == brick || *(delimiter + 1) != '/')
+        ret = -1;
 
-        return type;
-}
-
-int
-validate_brick_name (char *brick)
-{
-        char *delimiter = NULL;
-        int  ret = 0;
-        delimiter = strrchr (brick, ':');
-        if (!delimiter || delimiter == brick
-            || *(delimiter+1) != '/')
-                ret = -1;
-
-        return ret;
+    return ret;
 }
 
 char *
-get_host_name (char *word, char **host)
+get_host_name(char *word, char **host)
 {
-        char *delimiter = NULL;
-        delimiter = strrchr (word, ':');
-        if (delimiter)
-                *delimiter = '\0';
-        else
-                return NULL;
-        *host = word;
-        return *host;
+    char *delimiter = NULL;
+    delimiter = strrchr(word, ':');
+    if (delimiter)
+        *delimiter = '\0';
+    else
+        return NULL;
+    *host = word;
+    return *host;
 }
 
-
 char *
-get_path_name (char *word, char **path)
+get_path_name(char *word, char **path)
 {
-        char *delimiter = NULL;
-        delimiter = strchr (word, '/');
-        if (!delimiter)
-                return NULL;
-        *path = delimiter;
-        return *path;
+    char *delimiter = NULL;
+    delimiter = strchr(word, '/');
+    if (!delimiter)
+        return NULL;
+    *path = delimiter;
+    return *path;
 }
 
 void
-gf_path_strip_trailing_slashes (char *path)
+gf_path_strip_trailing_slashes(char *path)
 {
-        int i = 0;
-        int len = 0;
+    int i = 0;
+    int len = 0;
 
-        if (!path)
-                return;
+    if (!path)
+        return;
 
-        len = strlen (path);
-        for (i = len - 1; i > 0; i--) {
-                if (path[i] != '/')
-                        break;
-	}
+    len = strlen(path);
+    for (i = len - 1; i > 0; i--) {
+        if (path[i] != '/')
+            break;
+    }
 
-        if (i < (len -1))
-                path [i+1] = '\0';
+    if (i < (len - 1))
+        path[i + 1] = '\0';
 
-        return;
+    return;
 }
 
 uint64_t
-get_mem_size ()
+get_mem_size()
 {
-        uint64_t memsize = -1;
+    uint64_t memsize = -1;
 
 #if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS
 
-	uint64_t page_size = 0;
-	uint64_t num_pages = 0;
+    uint64_t page_size = 0;
+    uint64_t num_pages = 0;
 
-	page_size = sysconf (_SC_PAGESIZE);
-	num_pages = sysconf (_SC_PHYS_PAGES);
+    page_size = sysconf(_SC_PAGESIZE);
+    num_pages = sysconf(_SC_PHYS_PAGES);
 
-	memsize = page_size * num_pages;
+    memsize = page_size * num_pages;
 #endif
 
-#if defined GF_BSD_HOST_OS || defined GF_DARWIN_HOST_OS
+#if defined GF_DARWIN_HOST_OS || defined __FreeBSD__
 
-	size_t len = sizeof(memsize);
-	int name [] = { CTL_HW, HW_PHYSMEM };
+    size_t len = sizeof(memsize);
+    int name[] = {CTL_HW, HW_PHYSMEM};
 
-	sysctl (name, 2, &memsize, &len, NULL, 0);
+    sysctl(name, 2, &memsize, &len, NULL, 0);
 #endif
-	return memsize;
+
+#if defined __NetBSD__
+
+    size_t len = sizeof(memsize);
+    int name64[] = {CTL_HW, HW_PHYSMEM64};
+
+    sysctl(name64, 2, &memsize, &len, NULL, 0);
+    if (memsize == -1)
+        sysctl(name64, 2, &memsize, &len, NULL, 0);
+#endif
+    return memsize;
 }
 
 /* Strips all whitespace characters in a string and returns length of new string
  * on success
  */
 int
-gf_strip_whitespace (char *str, int len)
+gf_strip_whitespace(char *str, int len)
 {
-        int     i = 0;
-        int     new_len = 0;
-        char    *new_str = NULL;
+    int i = 0;
+    int new_len = 0;
+    char *new_str = NULL;
 
-        GF_ASSERT (str);
+    GF_ASSERT(str);
 
-        new_str = GF_CALLOC (1, len + 1, gf_common_mt_char);
-        if (new_str == NULL)
-                return -1;
+    new_str = GF_MALLOC(len + 1, gf_common_mt_char);
+    if (new_str == NULL)
+        return -1;
 
-        for (i = 0; i < len; i++) {
-                if (!isspace (str[i]))
-                        new_str[new_len++] = str[i];
-        }
-        new_str[new_len] = '\0';
+    for (i = 0; i < len; i++) {
+        if (!isspace(str[i]))
+            new_str[new_len++] = str[i];
+    }
+    new_str[new_len] = '\0';
 
-        if (new_len != len) {
-                memset (str, 0, len);
-                strncpy (str, new_str, new_len);
-        }
+    if (new_len != len) {
+        snprintf(str, new_len + 1, "%s", new_str);
+    }
 
-        GF_FREE (new_str);
-        return new_len;
+    GF_FREE(new_str);
+    return new_len;
 }
 
 int
-gf_canonicalize_path (char *path)
+gf_canonicalize_path(char *path)
 {
-        int             ret                  = -1;
-        int             path_len             = 0;
-        int             dir_path_len         = 0;
-        char           *tmppath              = NULL;
-        char           *dir                  = NULL;
-        char           *tmpstr               = NULL;
+    int ret = -1;
+    int path_len = 0;
+    int dir_path_len = 0;
+    char *tmppath = NULL;
+    char *dir = NULL;
+    char *tmpstr = NULL;
 
-        if (!path || *path != '/')
-                goto out;
+    if (!path || *path != '/')
+        goto out;
 
-        if (!strcmp (path, "/"))
-                return 0;
+    if (!strcmp(path, "/"))
+        return 0;
 
-        tmppath = gf_strdup (path);
-        if (!tmppath)
-                goto out;
+    tmppath = gf_strdup(path);
+    if (!tmppath)
+        goto out;
+
+    /* Strip the extra slashes and return */
+    bzero(path, strlen(path));
+    path[0] = '/';
+    dir = strtok_r(tmppath, "/", &tmpstr);
 
-        /* Strip the extra slashes and return */
-        bzero (path, strlen(path));
-        path[0] = '/';
-        dir = strtok_r(tmppath, "/", &tmpstr);
-
-        while (dir) {
-                dir_path_len = strlen(dir);
-                strncpy ((path + path_len + 1), dir, dir_path_len);
-                path_len += dir_path_len + 1;
-                dir = strtok_r (NULL, "/", &tmpstr);
-                if (dir)
-                        strncpy ((path + path_len), "/", 1);
+    while (dir) {
+        dir_path_len = strlen(dir);
+        memcpy((path + path_len + 1), dir, dir_path_len);
+        path_len += dir_path_len + 1;
+        dir = strtok_r(NULL, "/", &tmpstr);
+        if (dir) {
+            path[path_len] = '/';
         }
-        path[path_len] = '\0';
-        ret = 0;
+    }
+    path[path_len] = '\0';
+    ret = 0;
 
- out:
-        if (ret)
-                gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR,
-                        "Path manipulation failed");
+out:
+    if (ret)
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR, NULL);
 
-        GF_FREE(tmppath);
+    GF_FREE(tmppath);
 
-        return ret;
+    return ret;
 }
 
 static const char *__gf_timefmts[] = {
-        "%F %T",
-        "%Y/%m/%d-%T",
-        "%b %d %T",
-        "%F %H%M%S",
-	"%Y-%m-%d-%T",
-        "%s",
+    "%F %T", "%Y/%m/%d-%T", "%b %d %T", "%F %H%M%S", "%Y-%m-%d-%T", "%s",
 };
 
 static const char *__gf_zerotimes[] = {
-        "0000-00-00 00:00:00",
-        "0000/00/00-00:00:00",
-        "xxx 00 00:00:00",
-        "0000-00-00 000000",
-	"0000-00-00-00:00:00",
-        "0",
+    "0000-00-00 00:00:00", "0000/00/00-00:00:00", "xxx 00 00:00:00",
+    "0000-00-00 000000",   "0000-00-00-00:00:00", "0",
 };
 
 void
-_gf_timestuff (gf_timefmts *fmt, const char ***fmts, const char ***zeros)
+_gf_timestuff(const char ***fmts, const char ***zeros)
 {
-        *fmt = gf_timefmt_last;
-        *fmts = __gf_timefmts;
-        *zeros = __gf_zerotimes;
+    *fmts = __gf_timefmts;
+    *zeros = __gf_zerotimes;
 }
 
-
 char *
-generate_glusterfs_ctx_id (void)
+generate_glusterfs_ctx_id(void)
 {
-        char           tmp_str[1024] = {0,};
-        char           hostname[256] = {0,};
-        struct timeval tv = {0,};
-        char           now_str[32];
+    uuid_t ctxid;
+    char *tmp = NULL;
 
-        if (gettimeofday (&tv, NULL) == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                        LG_MSG_GETTIMEOFDAY_FAILED, "gettimeofday: "
-                        "failed");
-        }
+    gf_uuid_generate(ctxid);
+    tmp = uuid_utoa(ctxid);
 
-        if (gethostname (hostname, 256) == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                        LG_MSG_GETHOSTNAME_FAILED, "gethostname: failed");
-        }
-
-        gf_time_fmt (now_str, sizeof now_str, tv.tv_sec, gf_timefmt_Ymd_T);
-        snprintf (tmp_str, sizeof tmp_str, "%s-%d-%s:%"
-#ifdef GF_DARWIN_HOST_OS
-                  PRId32,
-#else
-                  "ld",
-#endif
-                  hostname, getpid(), now_str, tv.tv_usec);
-
-        return gf_strdup (tmp_str);
+    return gf_strdup(tmp);
 }
 
 char *
-gf_get_reserved_ports ()
+gf_get_reserved_ports()
 {
-        char    *ports_info  = NULL;
+    char *ports_info = NULL;
 #if defined GF_LINUX_HOST_OS
-        int     proc_fd      = -1;
-        char    *proc_file   = "/proc/sys/net/ipv4/ip_local_reserved_ports";
-        char    buffer[4096] = {0,};
-        int32_t ret          = -1;
-
-        proc_fd = open (proc_file, O_RDONLY);
-        if (proc_fd == -1) {
-                /* What should be done in this case? error out from here
-                 * and thus stop the glusterfs process from starting or
-                 * continue with older method of using any of the available
-                 * port? For now 2nd option is considered.
-                 */
-                gf_msg ("glusterfs", GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "could not open the file "
-                        "/proc/sys/net/ipv4/ip_local_reserved_ports for "
-                        "getting reserved ports info");
-                goto out;
-        }
+    int proc_fd = -1;
+    char *proc_file = "/proc/sys/net/ipv4/ip_local_reserved_ports";
+    char buffer[4096] = {
+        0,
+    };
+    int32_t ret = -1;
+
+    proc_fd = open(proc_file, O_RDONLY);
+    if (proc_fd == -1) {
+        /* What should be done in this case? error out from here
+         * and thus stop the glusterfs process from starting or
+         * continue with older method of using any of the available
+         * port? For now 2nd option is considered.
+         */
+        gf_smsg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                " /proc/sys/net/ipv4/ip_local_reserved_ports", NULL);
+        goto out;
+    }
 
-        ret = sys_read (proc_fd, buffer, sizeof (buffer)-1);
-        if (ret < 0) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "could not read the file %s for"
-                        " getting reserved ports info", proc_file);
-                goto out;
-        }
-        ports_info = gf_strdup (buffer);
+    ret = sys_read(proc_fd, buffer, sizeof(buffer) - 1);
+    if (ret < 0) {
+        gf_smsg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                "file=%s", proc_file, NULL);
+        goto out;
+    }
+
+    buffer[ret] = '\0';
+    ports_info = gf_strdup(buffer);
 
 out:
-        if (proc_fd != -1)
-                sys_close (proc_fd);
+    if (proc_fd != -1)
+        sys_close(proc_fd);
 #endif /* GF_LINUX_HOST_OS */
-        return ports_info;
+    return ports_info;
 }
 
 int
-gf_process_reserved_ports (unsigned char *ports, uint32_t ceiling)
+gf_process_reserved_ports(unsigned char *ports, uint32_t ceiling)
 {
-        int      ret         = -1;
+    int ret = -1;
 
-        memset (ports, 0, GF_PORT_ARRAY_SIZE);
+    memset(ports, 0, GF_PORT_ARRAY_SIZE);
 
 #if defined GF_LINUX_HOST_OS
-        char    *ports_info  = NULL;
-        char    *tmp         = NULL;
-        char    *blocked_port = NULL;
-
-        ports_info = gf_get_reserved_ports ();
-        if (!ports_info) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, 0,
-                        LG_MSG_RESERVED_PORTS_ERROR, "Not able to get reserved"
-                        " ports, hence there is a possibility that glusterfs "
-                        "may consume reserved port");
-                goto out;
-        }
+    char *ports_info = NULL;
+    char *tmp = NULL;
+    char *blocked_port = NULL;
 
-        blocked_port = strtok_r (ports_info, ",\n",&tmp);
+    ports_info = gf_get_reserved_ports();
+    if (!ports_info) {
+        gf_smsg("glusterfs", GF_LOG_WARNING, 0, LG_MSG_RESERVED_PORTS_ERROR,
+                NULL);
+        goto out;
+    }
 
-        while (blocked_port) {
-                gf_ports_reserved (blocked_port, ports, ceiling);
-                blocked_port = strtok_r (NULL, ",\n", &tmp);
-        }
+    blocked_port = strtok_r(ports_info, ",\n", &tmp);
 
-        ret = 0;
+    while (blocked_port) {
+        gf_ports_reserved(blocked_port, ports, ceiling);
+        blocked_port = strtok_r(NULL, ",\n", &tmp);
+    }
+
+    ret = 0;
 
 out:
-        GF_FREE (ports_info);
+    GF_FREE(ports_info);
 
 #else  /* FIXME: Non Linux Host */
-        ret = 0;
+    ret = 0;
 #endif /* GF_LINUX_HOST_OS */
 
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-gf_ports_reserved (char *blocked_port, unsigned char *ports, uint32_t ceiling)
-{
-        gf_boolean_t    result      = _gf_false;
-        char            *range_port = NULL;
-        int32_t         tmp_port1   = -1;
-        int32_t         tmp_port2   = -1;
-
-        if (strstr (blocked_port, "-") == NULL) {
-                /* get rid of the new line character*/
-                if (blocked_port[strlen(blocked_port) -1] == '\n')
-                        blocked_port[strlen(blocked_port) -1] = '\0';
-                if (gf_string2int32 (blocked_port, &tmp_port1) == 0) {
-                        if (tmp_port1 > ceiling
-                            || tmp_port1 < 0) {
-                                gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0,
-                                        LG_MSG_INVALID_PORT, "invalid port %d",
-                                        tmp_port1);
-                                result = _gf_true;
-                                goto out;
-                        } else {
-                                gf_msg_debug ("glusterfs", 0, "blocking port "
-                                              "%d", tmp_port1);
-                                BIT_SET (ports, tmp_port1);
-                        }
-                } else {
-                        gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_PORT, "%s is not a valid port "
-                                "identifier", blocked_port);
-                        result = _gf_true;
-                        goto out;
-                }
+gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling)
+{
+    gf_boolean_t result = _gf_false;
+    char *range_port = NULL;
+    int32_t tmp_port1 = -1;
+    int32_t tmp_port2 = -1;
+
+    if (strstr(blocked_port, "-") == NULL) {
+        /* get rid of the new line character*/
+        if (blocked_port[strlen(blocked_port) - 1] == '\n')
+            blocked_port[strlen(blocked_port) - 1] = '\0';
+        if (gf_string2int32(blocked_port, &tmp_port1) == 0) {
+            if (tmp_port1 > GF_PORT_MAX || tmp_port1 < 0) {
+                gf_smsg("glusterfs-socket", GF_LOG_WARNING, 0,
+                        LG_MSG_INVALID_PORT, "port=%d", tmp_port1, NULL);
+                result = _gf_true;
+                goto out;
+            } else {
+                gf_msg_debug("glusterfs", 0,
+                             "blocking port "
+                             "%d",
+                             tmp_port1);
+                BIT_SET(ports, tmp_port1);
+            }
         } else {
-                range_port = strtok (blocked_port, "-");
-                if (!range_port){
-                        result = _gf_true;
-                        goto out;
-                }
-                if (gf_string2int32 (range_port, &tmp_port1) == 0) {
-                        if (tmp_port1 > ceiling)
-                                tmp_port1 = ceiling;
-                        if (tmp_port1 < 0)
-                                tmp_port1 = 0;
-                }
-                range_port = strtok (NULL, "-");
-                if (!range_port) {
-                        result = _gf_true;
-                        goto out;
-                }
-                /* get rid of the new line character*/
-                if (range_port[strlen(range_port) -1] == '\n')
-                        range_port[strlen(range_port) - 1] = '\0';
-                if (gf_string2int32 (range_port, &tmp_port2) == 0) {
-                        if (tmp_port2 > ceiling)
-                                tmp_port2 = ceiling;
-                        if (tmp_port2 < 0)
-                                tmp_port2 = 0;
-                }
-                gf_msg_debug ("glusterfs", 0, "lower: %d, higher: %d",
-                              tmp_port1, tmp_port2);
-                for (; tmp_port1 <= tmp_port2; tmp_port1++)
-                        BIT_SET (ports, tmp_port1);
-        }
+            gf_smsg("glusterfs-socket", GF_LOG_WARNING, 0, LG_MSG_INVALID_PORT,
+                    "port=%s", blocked_port, NULL);
+            result = _gf_true;
+            goto out;
+        }
+    } else {
+        range_port = strtok(blocked_port, "-");
+        if (!range_port) {
+            result = _gf_true;
+            goto out;
+        }
+        if (gf_string2int32(range_port, &tmp_port1) == 0) {
+            if (tmp_port1 > ceiling)
+                tmp_port1 = ceiling;
+            if (tmp_port1 < 0)
+                tmp_port1 = 0;
+        }
+        range_port = strtok(NULL, "-");
+        if (!range_port) {
+            result = _gf_true;
+            goto out;
+        }
+        /* get rid of the new line character*/
+        if (range_port[strlen(range_port) - 1] == '\n')
+            range_port[strlen(range_port) - 1] = '\0';
+        if (gf_string2int32(range_port, &tmp_port2) == 0) {
+            if (tmp_port2 > ceiling)
+                tmp_port2 = ceiling;
+            if (tmp_port2 < 0)
+                tmp_port2 = 0;
+        }
+        gf_msg_debug("glusterfs", 0, "lower: %d, higher: %d", tmp_port1,
+                     tmp_port2);
+        for (; tmp_port1 <= tmp_port2; tmp_port1++)
+            BIT_SET(ports, tmp_port1);
+    }
 
 out:
-        return result;
+    return result;
 }
 
 /* Takes in client ip{v4,v6} and returns associated hostname, if any
@@ -3269,691 +3408,890 @@ out:
  * Returns: 0 for success, -1 for failure
  */
 int
-gf_get_hostname_from_ip (char *client_ip, char **hostname)
-{
-        int                      ret                          = -1;
-        struct sockaddr         *client_sockaddr              = NULL;
-        struct sockaddr_in       client_sock_in               = {0};
-        struct sockaddr_in6      client_sock_in6              = {0};
-        char                     client_hostname[NI_MAXHOST]  = {0};
-        char                    *client_ip_copy               = NULL;
-        char                    *tmp                          = NULL;
-        char                    *ip                           = NULL;
-        size_t                   addr_sz                      = 0;
-
-        /* if ipv4, reverse lookup the hostname to
-         * allow FQDN based rpc authentication
-         */
-        if (!valid_ipv6_address (client_ip, strlen (client_ip), 0) &&
-            !valid_ipv4_address (client_ip, strlen (client_ip), 0)) {
-                /* most times, we get a.b.c.d:port form, so check that */
-                client_ip_copy = gf_strdup (client_ip);
-                if (!client_ip_copy)
-                        goto out;
-
-                ip = strtok_r (client_ip_copy, ":", &tmp);
-        } else {
-                ip = client_ip;
-        }
-
-        if (valid_ipv4_address (ip, strlen (ip), 0) == _gf_true) {
-                client_sockaddr = (struct sockaddr *)&client_sock_in;
-                addr_sz = sizeof (client_sock_in);
-                client_sock_in.sin_family = AF_INET;
-                ret = inet_pton (AF_INET, ip,
-                                 (void *)&client_sock_in.sin_addr.s_addr);
-
-        } else if (valid_ipv6_address (ip, strlen (ip), 0) == _gf_true) {
-                client_sockaddr = (struct sockaddr *) &client_sock_in6;
-                addr_sz = sizeof (client_sock_in6);
+gf_get_hostname_from_ip(char *client_ip, char **hostname)
+{
+    int ret = -1;
+    struct sockaddr *client_sockaddr = NULL;
+    struct sockaddr_in client_sock_in = {0};
+    struct sockaddr_in6 client_sock_in6 = {0};
+    char client_hostname[NI_MAXHOST] = {0};
+    char *client_ip_copy = NULL;
+    char *tmp = NULL;
+    char *ip = NULL;
+    size_t addr_sz = 0;
+
+    /* if ipv4, reverse lookup the hostname to
+     * allow FQDN based rpc authentication
+     */
+    if (!valid_ipv6_address(client_ip, strlen(client_ip), 0) &&
+        !valid_ipv4_address(client_ip, strlen(client_ip), 0)) {
+        /* most times, we get a.b.c.d:port form, so check that */
+        client_ip_copy = gf_strdup(client_ip);
+        if (!client_ip_copy)
+            goto out;
+
+        ip = strtok_r(client_ip_copy, ":", &tmp);
+    } else {
+        ip = client_ip;
+    }
+
+    if (valid_ipv4_address(ip, strlen(ip), 0) == _gf_true) {
+        client_sockaddr = (struct sockaddr *)&client_sock_in;
+        addr_sz = sizeof(client_sock_in);
+        client_sock_in.sin_family = AF_INET;
+        ret = inet_pton(AF_INET, ip, (void *)&client_sock_in.sin_addr.s_addr);
+
+    } else if (valid_ipv6_address(ip, strlen(ip), 0) == _gf_true) {
+        client_sockaddr = (struct sockaddr *)&client_sock_in6;
+        addr_sz = sizeof(client_sock_in6);
+
+        client_sock_in6.sin6_family = AF_INET6;
+        ret = inet_pton(AF_INET6, ip, (void *)&client_sock_in6.sin6_addr);
+    } else {
+        goto out;
+    }
+
+    if (ret != 1) {
+        ret = -1;
+        goto out;
+    }
+
+    /* You cannot just use sizeof (*client_sockaddr), as per the man page
+     * the (getnameinfo) size must be the size of the underlying sockaddr
+     * struct e.g. sockaddr_in6 or sockaddr_in.  Failure to do so will
+     * break IPv6 hostname resolution (IPv4 will work only because
+     * the sockaddr_in struct happens to be of the correct size).
+     */
+    ret = getnameinfo(client_sockaddr, addr_sz, client_hostname,
+                      sizeof(client_hostname), NULL, 0, 0);
+    if (ret) {
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                "ip=%s", client_ip, "ret=%s", gai_strerror(ret), NULL);
+        ret = -1;
+        goto out;
+    }
+
+    *hostname = gf_strdup((char *)client_hostname);
+out:
+    if (client_ip_copy)
+        GF_FREE(client_ip_copy);
 
-                client_sock_in6.sin6_family = AF_INET6;
-                ret = inet_pton (AF_INET6, ip,
-                                 (void *)&client_sock_in6.sin6_addr);
-        } else {
-                goto out;
-        }
+    return ret;
+}
 
-        if (ret != 1) {
-                ret = -1;
-                goto out;
-        }
+gf_boolean_t
+gf_interface_search(char *ip)
+{
+    int32_t ret = -1;
+    gf_boolean_t found = _gf_false;
+    struct ifaddrs *ifaddr, *ifa;
+    int family;
+    char host[NI_MAXHOST];
+    xlator_t *this = NULL;
+    char *pct = NULL;
 
-        /* You cannot just use sizeof (*client_sockaddr), as per the man page
-         * the (getnameinfo) size must be the size of the underlying sockaddr
-         * struct e.g. sockaddr_in6 or sockaddr_in.  Failure to do so will
-         * break IPv6 hostname resolution (IPv4 will work only because
-         * the sockaddr_in struct happens to be of the correct size).
-         */
-        ret = getnameinfo (client_sockaddr,
-                           addr_sz,
-                           client_hostname, sizeof (client_hostname),
-                           NULL, 0, 0);
-        if (ret) {
-                gf_msg ("common-utils", GF_LOG_ERROR, 0,
-                        LG_MSG_GETNAMEINFO_FAILED, "Could not lookup hostname "
-                        "of %s : %s", client_ip, gai_strerror (ret));
-                ret = -1;
-                goto out;
-        }
+    this = THIS;
 
-        *hostname = gf_strdup ((char *)client_hostname);
- out:
-        if (client_ip_copy)
-                GF_FREE (client_ip_copy);
+    ret = getifaddrs(&ifaddr);
 
-        return ret;
-}
+    if (ret != 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED, "ret=%s",
+                gai_strerror(ret), NULL);
+        goto out;
+    }
 
-gf_boolean_t
-gf_interface_search (char *ip)
-{
-        int32_t         ret = -1;
-        gf_boolean_t    found = _gf_false;
-        struct          ifaddrs *ifaddr, *ifa;
-        int             family;
-        char            host[NI_MAXHOST];
-        xlator_t        *this = NULL;
-        char            *pct = NULL;
+    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+        if (!ifa->ifa_addr) {
+            /*
+             * This seemingly happens if an interface hasn't
+             * been bound to a particular protocol (seen with
+             * TUN devices).
+             */
+            continue;
+        }
+        family = ifa->ifa_addr->sa_family;
 
-        this = THIS;
+        if (family != AF_INET && family != AF_INET6)
+            continue;
 
-        ret = getifaddrs (&ifaddr);
+        ret = getnameinfo(ifa->ifa_addr,
+                          (family == AF_INET) ? sizeof(struct sockaddr_in)
+                                              : sizeof(struct sockaddr_in6),
+                          host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 
         if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED,
-                        "getifaddrs() failed: %s\n", gai_strerror(ret));
-                goto out;
+            gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
+            goto out;
+        }
+
+        /*
+         * Sometimes the address comes back as addr%eth0 or
+         * similar.  Since % is an invalid character, we can
+         * strip it out with confidence that doing so won't
+         * harm anything.
+         */
+        pct = index(host, '%');
+        if (pct) {
+            *pct = '\0';
         }
 
-        for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
-                if (!ifa->ifa_addr) {
-                        /*
-                         * This seemingly happens if an interface hasn't
-                         * been bound to a particular protocol (seen with
-                         * TUN devices).
-                         */
-                        continue;
-                }
-                family = ifa->ifa_addr->sa_family;
-
-                if (family != AF_INET && family != AF_INET6)
-                        continue;
-
-                ret = getnameinfo (ifa->ifa_addr,
-                        (family == AF_INET) ? sizeof(struct sockaddr_in) :
-                                              sizeof(struct sockaddr_in6),
-                        host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
-
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo() "
-                                "failed: %s\n", gai_strerror(ret));
-                        goto out;
-                }
-
-                /*
-                 * Sometimes the address comes back as addr%eth0 or
-                 * similar.  Since % is an invalid character, we can
-                 * strip it out with confidence that doing so won't
-                 * harm anything.
-                 */
-                pct = index(host,'%');
-                if (pct) {
-                        *pct = '\0';
-                }
-
-                if (strncmp (ip, host, NI_MAXHOST) == 0) {
-                        gf_msg_debug (this->name, 0, "%s is local address at "
-                                      "interface %s", ip, ifa->ifa_name);
-                        found = _gf_true;
-                        goto out;
-                }
+        if (strncmp(ip, host, NI_MAXHOST) == 0) {
+            gf_msg_debug(this->name, 0,
+                         "%s is local address at "
+                         "interface %s",
+                         ip, ifa->ifa_name);
+            found = _gf_true;
+            goto out;
         }
+    }
 out:
-        if(ifaddr)
-                freeifaddrs (ifaddr);
-        return found;
+    if (ifaddr)
+        freeifaddrs(ifaddr);
+    return found;
 }
 
 char *
-get_ip_from_addrinfo (struct addrinfo *addr, char **ip)
+get_ip_from_addrinfo(struct addrinfo *addr, char **ip)
 {
-        char buf[64];
-        void *in_addr = NULL;
-        struct sockaddr_in *s4 = NULL;
-        struct sockaddr_in6 *s6 = NULL;
+    char buf[64];
+    void *in_addr = NULL;
+    struct sockaddr_in *s4 = NULL;
+    struct sockaddr_in6 *s6 = NULL;
 
-        switch (addr->ai_family)
-        {
-                case AF_INET:
-                        s4 = (struct sockaddr_in *)addr->ai_addr;
-                        in_addr = &s4->sin_addr;
-                        break;
-
-                case AF_INET6:
-                        s6 = (struct sockaddr_in6 *)addr->ai_addr;
-                        in_addr = &s6->sin6_addr;
-                        break;
-
-                default:
-                        gf_msg ("glusterd", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_FAMILY, "Invalid family");
-                        return NULL;
-        }
+    switch (addr->ai_family) {
+        case AF_INET:
+            s4 = (struct sockaddr_in *)addr->ai_addr;
+            in_addr = &s4->sin_addr;
+            break;
 
-        if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) {
-                gf_msg ("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED,
-                        "String conversion failed");
-                return NULL;
-        }
+        case AF_INET6:
+            s6 = (struct sockaddr_in6 *)addr->ai_addr;
+            in_addr = &s6->sin6_addr;
+            break;
 
-        *ip = gf_strdup (buf);
-        return *ip;
-}
+        default:
+            gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY, NULL);
+            return NULL;
+    }
 
-gf_boolean_t
-gf_is_loopback_localhost (const struct sockaddr *sa, char *hostname)
-{
-        GF_ASSERT (sa);
-
-        gf_boolean_t is_local = _gf_false;
-        const struct in_addr *addr4 = NULL;
-        const struct in6_addr *addr6 = NULL;
-        uint8_t      *ap   = NULL;
-        struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT;
-
-        switch (sa->sa_family) {
-                case AF_INET:
-                        addr4 = &(((struct sockaddr_in *)sa)->sin_addr);
-                        ap = (uint8_t*)&addr4->s_addr;
-                        if (ap[0] == 127)
-                                is_local = _gf_true;
-                        break;
-
-                case AF_INET6:
-                        addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr);
-                        if (memcmp (addr6, &loopbackaddr6,
-                                    sizeof (loopbackaddr6)) == 0)
-                                is_local = _gf_true;
-                        break;
-
-                default:
-                        if (hostname)
-                                gf_msg ("glusterd", GF_LOG_ERROR, 0,
-                                        LG_MSG_INVALID_FAMILY, "unknown "
-                                        "address family %d for %s",
-                                        sa->sa_family, hostname);
-                        break;
-        }
+    if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) {
+        gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED, NULL);
+        return NULL;
+    }
 
-        return is_local;
+    *ip = gf_strdup(buf);
+    return *ip;
 }
 
 gf_boolean_t
-gf_is_local_addr (char *hostname)
+gf_is_loopback_localhost(const struct sockaddr *sa, char *hostname)
 {
-        int32_t         ret = -1;
-        struct          addrinfo *result = NULL;
-        struct          addrinfo *res = NULL;
-        gf_boolean_t    found = _gf_false;
-        char            *ip = NULL;
-        xlator_t        *this = NULL;
-        struct          addrinfo hints;
+    GF_ASSERT(sa);
 
-        this = THIS;
+    gf_boolean_t is_local = _gf_false;
+    const struct in_addr *addr4 = NULL;
+    const struct in6_addr *addr6 = NULL;
+    uint8_t *ap = NULL;
+    struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT;
 
-        memset (&hints, 0, sizeof (hints));
-        /*
-         * Removing AI_ADDRCONFIG from default_hints
-         * for being able to use link local ipv6 addresses
-         */
-        hints.ai_family = AF_UNSPEC;
+    switch (sa->sa_family) {
+        case AF_INET:
+            addr4 = &(((struct sockaddr_in *)sa)->sin_addr);
+            ap = (uint8_t *)&addr4->s_addr;
+            if (ap[0] == 127)
+                is_local = _gf_true;
+            break;
 
-        ret = getaddrinfo (hostname, NULL, &hints, &result);
+        case AF_INET6:
+            addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr);
+            if (memcmp(addr6, &loopbackaddr6, sizeof(loopbackaddr6)) == 0)
+                is_local = _gf_true;
+            break;
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(ret));
-                goto out;
-        }
+        default:
+            if (hostname)
+                gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
+                        "family=%d", sa->sa_family, "hostname=%s", hostname,
+                        NULL);
+            break;
+    }
 
-        for (res = result; res != NULL; res = res->ai_next) {
-                gf_msg_debug (this->name, 0, "%s ",
-                              get_ip_from_addrinfo (res, &ip));
-
-                found = gf_is_loopback_localhost (res->ai_addr, hostname)
-                        || gf_interface_search (ip);
-                if (found) {
-                        GF_FREE (ip);
-                        goto out;
-                }
-                GF_FREE (ip);
-        }
+    return is_local;
+}
+
+gf_boolean_t
+gf_is_local_addr(char *hostname)
+{
+    int32_t ret = -1;
+    struct addrinfo *result = NULL;
+    struct addrinfo *res = NULL;
+    gf_boolean_t found = _gf_false;
+    char *ip = NULL;
+    xlator_t *this = NULL;
+    struct addrinfo hints;
+
+    this = THIS;
+
+    memset(&hints, 0, sizeof(hints));
+    /*
+     * Removing AI_ADDRCONFIG from default_hints
+     * for being able to use link local ipv6 addresses
+     */
+    hints.ai_family = AF_UNSPEC;
+
+    ret = getaddrinfo(hostname, NULL, &hints, &result);
+
+    if (ret != 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+                "ret=%s", gai_strerror(ret), NULL);
+        goto out;
+    }
+
+    for (res = result; res != NULL; res = res->ai_next) {
+        get_ip_from_addrinfo(res, &ip);
+        gf_msg_debug(this->name, 0, "%s ", ip);
+
+        if (ip) {
+            found = (gf_is_loopback_localhost(res->ai_addr, hostname) ||
+                     gf_interface_search(ip));
+        }
+        if (found) {
+            GF_FREE(ip);
+            goto out;
+        }
+        GF_FREE(ip);
+        /* the above free will not set ip to NULL, and hence, there is
+           double free possible as the loop continues. set ip to NULL. */
+        ip = NULL;
+    }
 
 out:
-        if (result)
-                freeaddrinfo (result);
+    if (result)
+        freeaddrinfo(result);
 
-        if (!found)
-                gf_msg_debug (this->name, 0, "%s is not local", hostname);
+    if (!found)
+        gf_msg_debug(this->name, 0, "%s is not local", hostname);
 
-        return found;
+    return found;
 }
 
 gf_boolean_t
-gf_is_same_address (char *name1, char *name2)
-{
-        struct addrinfo         *addr1 = NULL;
-        struct addrinfo         *addr2 = NULL;
-        struct addrinfo         *p = NULL;
-        struct addrinfo         *q = NULL;
-        gf_boolean_t            ret = _gf_false;
-        int                     gai_err = 0;
-        struct                  addrinfo hints;
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = AF_UNSPEC;
-
-        gai_err = getaddrinfo(name1, NULL, &hints, &addr1);
-        if (gai_err != 0) {
-                gf_msg (name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(gai_err));
-                goto out;
-        }
+gf_is_same_address(char *name1, char *name2)
+{
+    struct addrinfo *addr1 = NULL;
+    struct addrinfo *addr2 = NULL;
+    struct addrinfo *p = NULL;
+    struct addrinfo *q = NULL;
+    gf_boolean_t ret = _gf_false;
+    int gai_err = 0;
+    struct addrinfo hints;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+
+    gai_err = getaddrinfo(name1, NULL, &hints, &addr1);
+    if (gai_err != 0) {
+        gf_smsg(name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, "error=%s",
+                gai_strerror(gai_err), NULL);
+        goto out;
+    }
+
+    gai_err = getaddrinfo(name2, NULL, &hints, &addr2);
+    if (gai_err != 0) {
+        gf_smsg(name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, "error=%s",
+                gai_strerror(gai_err), NULL);
+        goto out;
+    }
+
+    for (p = addr1; p; p = p->ai_next) {
+        for (q = addr2; q; q = q->ai_next) {
+            if (p->ai_addrlen != q->ai_addrlen) {
+                continue;
+            }
+            if (memcmp(p->ai_addr, q->ai_addr, p->ai_addrlen)) {
+                continue;
+            }
+            ret = _gf_true;
+            goto out;
+        }
+    }
 
-        gai_err = getaddrinfo(name2, NULL, &hints, &addr2);
-        if (gai_err != 0) {
-                gf_msg (name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(gai_err));
-                goto out;
-        }
+out:
+    if (addr1) {
+        freeaddrinfo(addr1);
+    }
+    if (addr2) {
+        freeaddrinfo(addr2);
+    }
+    return ret;
+}
 
-        for (p = addr1; p; p = p->ai_next) {
-                for (q = addr2; q; q = q->ai_next) {
-                        if (p->ai_addrlen != q->ai_addrlen) {
-                                continue;
-                        }
-                        if (memcmp(p->ai_addr,q->ai_addr,p->ai_addrlen)) {
-                                continue;
-                        }
-                        ret = _gf_true;
-                        goto out;
-                }
-        }
+/*
+ * Processes list of volfile servers.
+ * Format: <host1>:<port1> <host2>:<port2>...
+ */
+int
+gf_process_getspec_servers_list(cmd_args_t *cmd_args, const char *servers_list)
+{
+    char *tmp = NULL;
+    char *address = NULL;
+    char *host = NULL;
+    char *last_colon = NULL;
+    char *save_ptr = NULL;
+    int port = 0;
+    int ret = -1;
+
+    tmp = gf_strdup(servers_list);
+    if (!tmp) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    address = strtok_r(tmp, " ", &save_ptr);
+    if (!address) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    while (1) {
+        last_colon = strrchr(address, ':');
+        if (!last_colon) {
+            errno = EINVAL;
+            ret = -1;
+            break;
+        }
+        *last_colon = '\0';
+        host = address;
+        port = atoi(last_colon + 1);
+        if (port <= 0) {
+            errno = EINVAL;
+            ret = -1;
+            break;
+        }
+        ret = gf_set_volfile_server_common(cmd_args, host,
+                                           GF_DEFAULT_VOLFILE_TRANSPORT, port);
+        if (ret && errno != EEXIST) {
+            break;
+        }
+        address = strtok_r(NULL, " ", &save_ptr);
+        if (!address) {
+            errno = 0;
+            ret = 0;
+            break;
+        }
+    }
 
 out:
-        if (addr1) {
-                freeaddrinfo(addr1);
-        }
-        if (addr2) {
-                freeaddrinfo(addr2);
+    if (tmp) {
+        GF_FREE(tmp);
+    }
+
+    return ret;
+}
+
+int
+gf_set_volfile_server_common(cmd_args_t *cmd_args, const char *host,
+                             const char *transport, int port)
+{
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, host, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, transport, out);
+
+    server = GF_CALLOC(1, sizeof(server_cmdline_t),
+                       gf_common_mt_server_cmdline_t);
+    if (!server) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&server->list);
+
+    server->volfile_server = gf_strdup(host);
+    if (!server->volfile_server) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    server->transport = gf_strdup(transport);
+    if (!server->transport) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    server->port = port;
+
+    if (!cmd_args->volfile_server) {
+        cmd_args->volfile_server = server->volfile_server;
+        cmd_args->volfile_server_transport = server->transport;
+        cmd_args->volfile_server_port = server->port;
+        cmd_args->curr_server = server;
+    }
+
+    list_for_each_entry(tmp, &cmd_args->volfile_servers, list)
+    {
+        if ((!strcmp(tmp->volfile_server, server->volfile_server) &&
+             !strcmp(tmp->transport, server->transport) &&
+             (tmp->port == server->port))) {
+            /* Duplicate option given, log and ignore */
+            gf_smsg("gluster", GF_LOG_INFO, EEXIST, LG_MSG_DUPLICATE_ENTRY,
+                    NULL);
+            ret = 0;
+            goto out;
+        }
+    }
+
+    list_add_tail(&server->list, &cmd_args->volfile_servers);
+
+    ret = 0;
+out:
+    if (-1 == ret) {
+        if (server) {
+            GF_FREE(server->volfile_server);
+            GF_FREE(server->transport);
+            GF_FREE(server);
         }
-        return ret;
+    }
 
+    return ret;
 }
 
 /* Sets log file path from user provided arguments */
 int
-gf_set_log_file_path (cmd_args_t *cmd_args, glusterfs_ctx_t *ctx)
-{
-        int   i = 0;
-        int   j = 0;
-        int   ret = 0;
-        char  tmp_str[1024] = {0,};
-
-        if (!cmd_args)
-                goto done;
-
-        if (cmd_args->mount_point) {
-                j = 0;
-                i = 0;
-                if (cmd_args->mount_point[0] == '/')
-                        i = 1;
-                for (; i < strlen (cmd_args->mount_point); i++,j++) {
-                        tmp_str[j] = cmd_args->mount_point[i];
-                        if (cmd_args->mount_point[i] == '/')
-                                tmp_str[j] = '-';
-                }
-
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   tmp_str);
-                if (ret > 0)
-                        ret = 0;
-                goto done;
-        }
+gf_set_log_file_path(cmd_args_t *cmd_args, glusterfs_ctx_t *ctx)
+{
+    int i = 0;
+    int j = 0;
+    int ret = 0;
+    int tmp_len = 0;
+    char tmp_str[1024] = {
+        0,
+    };
 
-        if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) {
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   GLUSTERD_NAME);
-                if (ret > 0)
-                        ret = 0;
+    if (!cmd_args)
+        goto done;
 
-                goto done;
+    if (cmd_args->mount_point) {
+        j = 0;
+        i = 0;
+        if (cmd_args->mount_point[0] == '/')
+            i = 1;
+        for (; i < strlen(cmd_args->mount_point); i++, j++) {
+            tmp_str[j] = cmd_args->mount_point[i];
+            if (cmd_args->mount_point[i] == '/')
+                tmp_str[j] = '-';
         }
 
-        if (cmd_args->volfile) {
-                j = 0;
-                i = 0;
-                if (cmd_args->volfile[0] == '/')
-                        i = 1;
-                for (; i < strlen (cmd_args->volfile); i++,j++) {
-                        tmp_str[j] = cmd_args->volfile[i];
-                        if (cmd_args->volfile[i] == '/')
-                                tmp_str[j] = '-';
-                }
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   tmp_str);
-                if (ret > 0)
-                        ret = 0;
-                goto done;
-        }
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str);
+        if (ret > 0)
+            ret = 0;
+        goto done;
+    }
+
+    if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) {
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", GLUSTERD_NAME);
+        if (ret > 0)
+            ret = 0;
 
-        if (cmd_args->volfile_server) {
+        goto done;
+    }
 
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s-%s-%d.log",
-                                   cmd_args->volfile_server,
-                                   cmd_args->volfile_id, getpid());
-                if (ret > 0)
-                        ret = 0;
+    if (cmd_args->volfile) {
+        j = 0;
+        i = 0;
+        if (cmd_args->volfile[0] == '/')
+            i = 1;
+        for (; i < strlen(cmd_args->volfile); i++, j++) {
+            tmp_str[j] = cmd_args->volfile[i];
+            if (cmd_args->volfile[i] == '/')
+                tmp_str[j] = '-';
+        }
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str);
+        if (ret > 0)
+            ret = 0;
+        goto done;
+    }
+
+    if (cmd_args->volfile_server) {
+        if (strncmp(cmd_args->volfile_server_transport, "unix", 4) == 0) {
+            if (cmd_args->volfile_server[0] == '/')
+                i = 1;
+            tmp_len = strlen(cmd_args->volfile_server);
+            for (j = 0; i < tmp_len; i++, j++) {
+                tmp_str[j] = cmd_args->volfile_server[i];
+                if (cmd_args->volfile_server[i] == '/')
+                    tmp_str[j] = '-';
+            }
+            ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log",
+                              DEFAULT_LOG_FILE_DIRECTORY, tmp_str,
+                              cmd_args->volfile_id, getpid());
+        } else {
+            ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log",
+                              DEFAULT_LOG_FILE_DIRECTORY,
+                              cmd_args->volfile_server, cmd_args->volfile_id,
+                              getpid());
         }
+        if (ret > 0)
+            ret = 0;
+    }
 done:
-        return ret;
+    return ret;
 }
 
 int
-gf_set_log_ident (cmd_args_t *cmd_args)
+gf_set_log_ident(cmd_args_t *cmd_args)
 {
-        int              ret = 0;
-        char            *ptr = NULL;
+    int ret = 0;
+    char *ptr = NULL;
 
-        if (cmd_args->log_file == NULL) {
-                /* no ident source */
-                return 0;
-        }
-
-        /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which
-         * seems ugly and can be bettered? */
-        /* just get the filename as the ident */
-        if (NULL != (ptr = strrchr (cmd_args->log_file, '/'))) {
-                ret = gf_asprintf (&cmd_args->log_ident, "%s", ptr + 1);
-        } else {
-                ret = gf_asprintf (&cmd_args->log_ident, "%s",
-                                   cmd_args->log_file);
-        }
-
-        if (ret > 0)
-                ret = 0;
-        else
-                return ret;
+    if (cmd_args->log_file == NULL) {
+        /* no ident source */
+        return 0;
+    }
+
+    /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which
+     * seems ugly and can be bettered? */
+    /* just get the filename as the ident */
+    if (NULL != (ptr = strrchr(cmd_args->log_file, '/'))) {
+        ret = gf_asprintf(&cmd_args->log_ident, "%s", ptr + 1);
+    } else {
+        ret = gf_asprintf(&cmd_args->log_ident, "%s", cmd_args->log_file);
+    }
+
+    if (ret > 0)
+        ret = 0;
+    else
+        return ret;
 
-        /* remove .log suffix */
-        if (NULL != (ptr = strrchr (cmd_args->log_ident, '.'))) {
-                if (strcmp (ptr, ".log") == 0) {
-                        ptr[0] = '\0';
-                }
+    /* remove .log suffix */
+    if (NULL != (ptr = strrchr(cmd_args->log_ident, '.'))) {
+        if (strcmp(ptr, ".log") == 0) {
+            ptr[0] = '\0';
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_thread_cleanup_xint (pthread_t thread)
+gf_thread_cleanup_xint(pthread_t thread)
 {
-        int ret = 0;
-        void *res = NULL;
+    int ret = 0;
+    void *res = NULL;
 
-        ret = pthread_cancel (thread);
-        if (ret != 0)
-                goto error_return;
+    ret = pthread_cancel(thread);
+    if (ret != 0)
+        goto error_return;
 
-        ret = pthread_join (thread, &res);
-        if (ret != 0)
-                goto error_return;
+    ret = pthread_join(thread, &res);
+    if (ret != 0)
+        goto error_return;
 
-        if (res != PTHREAD_CANCELED)
-                goto error_return;
+    if (res != PTHREAD_CANCELED)
+        goto error_return;
 
-        ret = 0;
+    ret = 0;
 
- error_return:
-        return ret;
+error_return:
+    return ret;
 }
 
-int
-gf_thread_create (pthread_t *thread, const pthread_attr_t *attr,
-                  void *(*start_routine)(void *), void *arg, const char *name)
-{
-        sigset_t set, old;
-        int ret;
-        char thread_name[GF_THREAD_NAMEMAX+GF_THREAD_NAME_PREFIX_LEN] = {0,};
-        /* Max name on Linux is 16 and on NetBSD is 32
-         * All Gluster threads have a set prefix of gluster and hence the limit
-         * of 9 on GF_THREAD_NAMEMAX including the null character.
-         */
+void
+gf_thread_set_vname(pthread_t thread, const char *name, va_list args)
+{
+    char thread_name[GF_THREAD_NAME_LIMIT];
+    int ret;
 
-        sigemptyset (&old);
-        sigfillset (&set);
-        sigdelset (&set, SIGSEGV);
-        sigdelset (&set, SIGBUS);
-        sigdelset (&set, SIGILL);
-        sigdelset (&set, SIGSYS);
-        sigdelset (&set, SIGFPE);
-        sigdelset (&set, SIGABRT);
-
-        pthread_sigmask (SIG_BLOCK, &set, &old);
-
-        ret = pthread_create (thread, attr, start_routine, arg);
-        snprintf (thread_name, sizeof(thread_name), "%s%s",
-                  GF_THREAD_NAME_PREFIX, name);
-
-        if (0 == ret && name) {
-                #ifdef GF_LINUX_HOST_OS
-                        pthread_setname_np(*thread, thread_name);
-                #elif defined(__NetBSD__)
-                        pthread_setname_np(*thread, thread_name, NULL);
-                #else
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_PTHREAD_NAMING_FAILED,
-                                "Thread names not implemented on this ",
-                                "platform");
-                #endif
-        }
+    /* Initialize the thread name with the prefix (not NULL terminated). */
+    memcpy(thread_name, GF_THREAD_NAME_PREFIX,
+           sizeof(GF_THREAD_NAME_PREFIX) - 1);
 
-        pthread_sigmask (SIG_SETMASK, &old, NULL);
+    ret = vsnprintf(thread_name + sizeof(GF_THREAD_NAME_PREFIX) - 1,
+                    sizeof(thread_name) - sizeof(GF_THREAD_NAME_PREFIX) + 1,
+                    name, args);
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED,
+                "name=%s", name, NULL);
+        return;
+    }
 
-        return ret;
+    if (ret >= sizeof(thread_name)) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_THREAD_NAME_TOO_LONG,
+                "name=%s", thread_name, NULL);
+    }
+
+#ifdef GF_LINUX_HOST_OS
+    ret = pthread_setname_np(thread, thread_name);
+#elif defined(__NetBSD__)
+    ret = pthread_setname_np(thread, thread_name, NULL);
+#elif defined(__FreeBSD__)
+    pthread_set_name_np(thread, thread_name);
+    ret = 0;
+#else
+    ret = ENOSYS;
+#endif
+    if (ret != 0) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, ret, LG_MSG_SET_THREAD_FAILED,
+                "name=%s", thread_name, NULL);
+    }
+}
+
+void
+gf_thread_set_name(pthread_t thread, const char *name, ...)
+{
+    va_list args;
+
+    va_start(args, name);
+    gf_thread_set_vname(thread, name, args);
+    va_end(args);
 }
 
 int
-gf_thread_create_detached (pthread_t *thread,
-                         void *(*start_routine)(void *), void *arg,
-                         const char *name)
+gf_thread_vcreate(pthread_t *thread, const pthread_attr_t *attr,
+                  void *(*start_routine)(void *), void *arg, const char *name,
+                  va_list args)
 {
-        pthread_attr_t attr;
-        int ret = -1;
+    sigset_t set, old;
+    int ret;
 
-        ret = pthread_attr_init (&attr);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ret,
-                        LG_MSG_PTHREAD_ATTR_INIT_FAILED,
-                        "Thread attribute initialization failed");
-                return -1;
-        }
+    sigemptyset(&old);
+    sigfillset(&set);
+    sigdelset(&set, SIGSEGV);
+    sigdelset(&set, SIGBUS);
+    sigdelset(&set, SIGILL);
+    sigdelset(&set, SIGSYS);
+    sigdelset(&set, SIGFPE);
+    sigdelset(&set, SIGABRT);
 
-        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+    pthread_sigmask(SIG_BLOCK, &set, &old);
 
-        ret = gf_thread_create (thread, &attr, start_routine, arg, name);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ret,
-                        LG_MSG_PTHREAD_FAILED,
-                        "Thread creation failed");
-                ret = -1;
-        }
+    ret = pthread_create(thread, attr, start_routine, arg);
+    if (ret != 0) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_THREAD_CREATE_FAILED,
+                NULL);
+        ret = -1;
+    } else if (name != NULL) {
+        gf_thread_set_vname(*thread, name, args);
+    }
 
-        pthread_attr_destroy (&attr);
+    pthread_sigmask(SIG_SETMASK, &old, NULL);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_skip_header_section (int fd, int header_len)
+gf_thread_create(pthread_t *thread, const pthread_attr_t *attr,
+                 void *(*start_routine)(void *), void *arg, const char *name,
+                 ...)
 {
-        int  ret           = -1;
+    va_list args;
+    int ret;
 
-        ret = sys_lseek (fd, header_len, SEEK_SET);
-        if (ret == (off_t) -1) {
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED,
-                        "Failed to skip header section");
-        } else {
-                ret = 0;
-        }
+    va_start(args, name);
+    ret = gf_thread_vcreate(thread, attr, start_routine, arg, name, args);
+    va_end(args);
 
-        return ret;
+    return ret;
 }
 
-/* Below function is use to check at runtime if pid is running */
-
-gf_boolean_t
-gf_is_pid_running (int pid)
+int
+gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *),
+                          void *arg, const char *name, ...)
 {
-        char fname[32] = {0,};
+    pthread_attr_t attr;
+    va_list args;
+    int ret = -1;
 
-        snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
+    ret = pthread_attr_init(&attr);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED,
+                NULL);
+        return -1;
+    }
 
-        if (sys_access (fname , R_OK) != 0) {
-                return _gf_false;
-        }
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
-        return _gf_true;
+    va_start(args, name);
+    ret = gf_thread_vcreate(thread, &attr, start_routine, arg, name, args);
+    va_end(args);
 
+    pthread_attr_destroy(&attr);
+
+    return ret;
 }
 
+int
+gf_skip_header_section(int fd, int header_len)
+{
+    int ret = -1;
+
+    ret = sys_lseek(fd, header_len, SEEK_SET);
+    if (ret == (off_t)-1) {
+        gf_smsg("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED, NULL);
+    } else {
+        ret = 0;
+    }
+
+    return ret;
+}
+
+/* Below function is use to check at runtime if pid is running */
 
 gf_boolean_t
-gf_is_service_running (char *pidfile, int *pid)
+gf_is_pid_running(int pid)
 {
-        FILE            *file = NULL;
-        gf_boolean_t    running = _gf_false;
-        int             ret = 0;
-        int             fno = 0;
+#ifdef __FreeBSD__
+    int ret = -1;
 
-        file = fopen (pidfile, "r+");
-        if (!file) {
-                goto out;
-        }
+    ret = sys_kill(pid, 0);
+    if (ret < 0) {
+        return _gf_false;
+    }
+#else
+    char fname[32] = {
+        0,
+    };
+    int fd = -1;
 
-        fno = fileno (file);
-        ret = lockf (fno, F_TEST, 0);
-        if (ret == -1)
-                running = _gf_true;
-        if (!pid) {
-                goto out;
-        }
+    snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
 
-        ret = fscanf (file, "%d", pid);
-        if (ret <= 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to read pidfile: %s", pidfile);
-                *pid = -1;
-        }
+    fd = sys_open(fname, O_RDONLY, 0);
+    if (fd < 0) {
+        return _gf_false;
+    }
 
-        running = gf_is_pid_running (*pid);
+    sys_close(fd);
+#endif
+    return _gf_true;
+}
+
+gf_boolean_t
+gf_is_service_running(char *pidfile, int *pid)
+{
+    FILE *file = NULL;
+    gf_boolean_t running = _gf_false;
+    int ret = 0;
+    int fno = 0;
+
+    file = fopen(pidfile, "r+");
+    if (!file) {
+        goto out;
+    }
+
+    fno = fileno(file);
+    ret = lockf(fno, F_TEST, 0);
+    if (ret == -1) {
+        running = _gf_true;
+    }
+
+    ret = fscanf(file, "%d", pid);
+    if (ret <= 0) {
+        gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "pidfile=%s",
+                pidfile, NULL);
+        *pid = -1;
+        running = _gf_false;
+        goto out;
+    }
+
+    running = gf_is_pid_running(*pid);
 out:
-        if (file)
-                fclose (file);
-        return running;
+    if (file)
+        fclose(file);
+    return running;
 }
 
 /* Check if the pid is > 0 */
 gf_boolean_t
-gf_valid_pid (const char *pid, int length)
+gf_valid_pid(const char *pid, int length)
 {
-        gf_boolean_t    ret = _gf_true;
-        pid_t           value = 0;
-        char           *end_ptr = NULL;
+    gf_boolean_t ret = _gf_true;
+    pid_t value = 0;
+    char *end_ptr = NULL;
 
-        if (length <= 0) {
-                ret = _gf_false;
-                goto out;
-        }
+    if (length <= 0) {
+        ret = _gf_false;
+        goto out;
+    }
 
-        value = strtol (pid, &end_ptr, 10);
-        if (value <= 0) {
-                ret = _gf_false;
-        }
+    value = strtol(pid, &end_ptr, 10);
+    if (value <= 0) {
+        ret = _gf_false;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-dht_is_linkfile_key (dict_t *this, char *key, data_t *value, void *data)
+dht_is_linkfile_key(dict_t *this, char *key, data_t *value, void *data)
 {
-        gf_boolean_t *linkfile_key_found = NULL;
+    gf_boolean_t *linkfile_key_found = NULL;
 
-        if (!data)
-                goto out;
+    if (!data)
+        goto out;
 
-        linkfile_key_found = data;
+    linkfile_key_found = data;
 
-        *linkfile_key_found = _gf_true;
+    *linkfile_key_found = _gf_true;
 out:
-        return 0;
+    return 0;
 }
 
-
 gf_boolean_t
-dht_is_linkfile (struct iatt *buf, dict_t *dict)
+dht_is_linkfile(struct iatt *buf, dict_t *dict)
 {
-        gf_boolean_t linkfile_key_found = _gf_false;
+    gf_boolean_t linkfile_key_found = _gf_false;
 
-        if (!IS_DHT_LINKFILE_MODE (buf))
-                return _gf_false;
+    if (!IS_DHT_LINKFILE_MODE(buf))
+        return _gf_false;
 
-        dict_foreach_fnmatch (dict, "*."DHT_LINKFILE_STR, dht_is_linkfile_key,
-                              &linkfile_key_found);
+    dict_foreach_fnmatch(dict, "*." DHT_LINKFILE_STR, dht_is_linkfile_key,
+                         &linkfile_key_found);
 
-        return linkfile_key_found;
+    return linkfile_key_found;
 }
 
 int
-gf_check_log_format (const char *value)
+gf_check_log_format(const char *value)
 {
-        int log_format = -1;
+    int log_format = -1;
 
-        if (!strcasecmp (value, GF_LOG_FORMAT_NO_MSG_ID))
-                log_format = gf_logformat_traditional;
-        else if (!strcasecmp (value, GF_LOG_FORMAT_WITH_MSG_ID))
-                log_format = gf_logformat_withmsgid;
+    if (!strcasecmp(value, GF_LOG_FORMAT_NO_MSG_ID))
+        log_format = gf_logformat_traditional;
+    else if (!strcasecmp(value, GF_LOG_FORMAT_WITH_MSG_ID))
+        log_format = gf_logformat_withmsgid;
 
-        if (log_format == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-                        "Invalid log-format. possible values are "
-                        GF_LOG_FORMAT_NO_MSG_ID "|" GF_LOG_FORMAT_WITH_MSG_ID);
+    if (log_format == -1)
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+                "possible_values=" GF_LOG_FORMAT_NO_MSG_ID
+                "|" GF_LOG_FORMAT_WITH_MSG_ID,
+                NULL);
 
-        return log_format;
+    return log_format;
 }
 
 int
-gf_check_logger (const char *value)
+gf_check_logger(const char *value)
 {
-        int logger = -1;
+    int logger = -1;
 
-        if (!strcasecmp (value, GF_LOGGER_GLUSTER_LOG))
-                logger = gf_logger_glusterlog;
-        else if (!strcasecmp (value, GF_LOGGER_SYSLOG))
-                logger = gf_logger_syslog;
+    if (!strcasecmp(value, GF_LOGGER_GLUSTER_LOG))
+        logger = gf_logger_glusterlog;
+    else if (!strcasecmp(value, GF_LOGGER_SYSLOG))
+        logger = gf_logger_syslog;
 
-        if (logger == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-                        "Invalid logger. possible values are "
-                        GF_LOGGER_GLUSTER_LOG "|" GF_LOGGER_SYSLOG);
+    if (logger == -1)
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+                "possible_values=" GF_LOGGER_GLUSTER_LOG "|" GF_LOGGER_SYSLOG,
+                NULL);
 
-        return logger;
+    return logger;
 }
 
 /* gf_compare_sockaddr compares the given addresses @addr1 and @addr2 for
@@ -3963,30 +4301,28 @@ gf_check_logger (const char *value)
  * https://www.opensource.apple.com/source/postfix/postfix-197/postfix/src/util/sock_addr.c
  */
 gf_boolean_t
-gf_compare_sockaddr (const struct sockaddr *addr1,
-                     const struct sockaddr *addr2)
+gf_compare_sockaddr(const struct sockaddr *addr1, const struct sockaddr *addr2)
 {
-        GF_ASSERT (addr1 != NULL);
-        GF_ASSERT (addr2 != NULL);
-
-        /* Obviously, the addresses don't match if their families are different
-         */
-        if (addr1->sa_family != addr2->sa_family)
-                return _gf_false;
+    GF_ASSERT(addr1 != NULL);
+    GF_ASSERT(addr2 != NULL);
 
+    /* Obviously, the addresses don't match if their families are different
+     */
+    if (addr1->sa_family != addr2->sa_family)
+        return _gf_false;
 
-        if (AF_INET == addr1->sa_family) {
-                if (((struct sockaddr_in *)addr1)->sin_addr.s_addr ==
-                       ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
-                        return _gf_true;
+    if (AF_INET == addr1->sa_family) {
+        if (((struct sockaddr_in *)addr1)->sin_addr.s_addr ==
+            ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
+            return _gf_true;
 
-        } else if (AF_INET6 == addr1->sa_family) {
-                if (memcmp ((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr,
-                            (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr,
-                            sizeof (struct in6_addr)) == 0)
-                        return _gf_true;
-        }
-        return _gf_false;
+    } else if (AF_INET6 == addr1->sa_family) {
+        if (memcmp((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr,
+                   (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr,
+                   sizeof(struct in6_addr)) == 0)
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 /*
@@ -3995,147 +4331,167 @@ gf_compare_sockaddr (const struct sockaddr *addr1,
  */
 
 int
-gf_set_timestamp  (const char *src, const char* dest)
+gf_set_timestamp(const char *src, const char *dest)
 {
-        struct stat    sb             = {0, };
+    struct stat sb = {
+        0,
+    };
 #if defined(HAVE_UTIMENSAT)
-        struct timespec new_time[2]   = { {0, }, {0, } };
+    struct timespec new_time[2] = {{
+                                       0,
+                                   },
+                                   {
+                                       0,
+                                   }};
 #else
-        struct timeval new_time[2]    = { {0, }, {0, } };
+    struct timeval new_time[2] = {{
+                                      0,
+                                  },
+                                  {
+                                      0,
+                                  }};
 #endif
-        int            ret            = 0;
-        xlator_t       *this          = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-        GF_ASSERT (src);
-        GF_ASSERT (dest);
-
-        ret = sys_stat (src, &sb);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FILE_STAT_FAILED, "stat on %s", src);
-                goto out;
-        }
-        /* The granularity is nano seconds if `utimensat()` is available,
-         * and micro seconds otherwise.
-         */
+    int ret = 0;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(src);
+    GF_ASSERT(dest);
+
+    ret = sys_stat(src, &sb);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+                "stat=%s", src, NULL);
+        goto out;
+    }
+    /* The granularity is nano seconds if `utimensat()` is available,
+     * and micro seconds otherwise.
+     */
 #if defined(HAVE_UTIMENSAT)
-        new_time[0].tv_sec = sb.st_atime;
-        new_time[0].tv_nsec = ST_ATIM_NSEC (&sb);
-
-        new_time[1].tv_sec = sb.st_mtime;
-        new_time[1].tv_nsec = ST_MTIM_NSEC (&sb);
-
-        /* dirfd = 0 is ignored because `dest` is an absolute path. */
-        ret = sys_utimensat (AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_UTIMENSAT_FAILED, "utimensat on %s", dest);
-        }
+    new_time[0].tv_sec = sb.st_atime;
+    new_time[0].tv_nsec = ST_ATIM_NSEC(&sb);
+
+    new_time[1].tv_sec = sb.st_mtime;
+    new_time[1].tv_nsec = ST_MTIM_NSEC(&sb);
+
+    /* dirfd = 0 is ignored because `dest` is an absolute path. */
+    ret = sys_utimensat(AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMENSAT_FAILED,
+                "dest=%s", dest, NULL);
+    }
 #else
-        new_time[0].tv_sec = sb.st_atime;
-        new_time[0].tv_usec = ST_ATIM_NSEC (&sb)/1000;
+    new_time[0].tv_sec = sb.st_atime;
+    new_time[0].tv_usec = ST_ATIM_NSEC(&sb) / 1000;
 
-        new_time[1].tv_sec = sb.st_mtime;
-        new_time[1].tv_usec = ST_MTIM_NSEC (&sb)/1000;
+    new_time[1].tv_sec = sb.st_mtime;
+    new_time[1].tv_usec = ST_MTIM_NSEC(&sb) / 1000;
 
-        ret = sys_utimes (dest, new_time);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
-                        "utimes on %s", dest);
-        }
+    ret = sys_utimes(dest, new_time);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
+                "dest=%s", dest, NULL);
+    }
 #endif
 out:
-        return ret;
+    return ret;
 }
 
 static void
-gf_backtrace_end (char *buf, size_t frames)
+gf_backtrace_end(char *buf, size_t frames)
 {
-        size_t pos = 0;
+    size_t pos = 0;
 
-        if (!buf)
-                return;
+    if (!buf)
+        return;
 
-        pos = strlen (buf);
+    pos = strlen(buf);
 
-        frames = min(frames, GF_BACKTRACE_LEN - pos -1);
+    frames = min(frames, GF_BACKTRACE_LEN - pos - 1);
 
-        if (frames <= 0)
-                return;
+    if (0 == frames)
+        return;
 
-        memset (buf+pos, ')', frames);
-        buf[pos+frames] = '\0';
+    memset(buf + pos, ')', frames);
+    buf[pos + frames] = '\0';
 }
 
 /*Returns bytes written*/
 static int
-gf_backtrace_append (char *buf, size_t pos, char *framestr)
+gf_backtrace_append(char *buf, size_t pos, char *framestr)
 {
-        if (pos >= GF_BACKTRACE_LEN)
-                return -1;
-        return snprintf (buf+pos, GF_BACKTRACE_LEN-pos, "(--> %s ", framestr);
+    if (pos >= GF_BACKTRACE_LEN)
+        return -1;
+    return snprintf(buf + pos, GF_BACKTRACE_LEN - pos, "(--> %s ", framestr);
 }
 
 static int
-gf_backtrace_fillframes (char *buf)
-{
-        void    *array[GF_BACKTRACE_FRAME_COUNT];
-        size_t  frames                  = 0;
-        FILE    *fp                     = NULL;
-        char    callingfn[GF_BACKTRACE_FRAME_COUNT-2][1024] = {{0},};
-        int     ret                     = -1;
-        int     fd                      = -1;
-        size_t  idx                     = 0;
-        size_t  pos                     = 0;
-        size_t  inc                     = 0;
-        char    tmpl[32]                = "/tmp/btXXXXXX";
-
-        frames = backtrace (array, GF_BACKTRACE_FRAME_COUNT);
-        if (!frames)
-                return -1;
-
-        fd = gf_mkostemp (tmpl, 0, O_RDWR);
-        if (fd == -1)
-                return -1;
-
-        /*The most recent two frames are the calling function and
-         * gf_backtrace_save, which we can infer.*/
-
-        backtrace_symbols_fd (&array[2], frames-2, fd);
-
-        fp = fdopen (fd, "r");
-        if (!fp) {
-                sys_close (fd);
-                ret = -1;
-                goto out;
-        }
+gf_backtrace_fillframes(char *buf)
+{
+    void *array[GF_BACKTRACE_FRAME_COUNT];
+    size_t frames = 0;
+    FILE *fp = NULL;
+    char callingfn[GF_BACKTRACE_FRAME_COUNT - 2][1024] = {
+        {0},
+    };
+    int ret = -1;
+    int fd = -1;
+    size_t idx = 0;
+    size_t pos = 0;
+    size_t inc = 0;
+    char tmpl[] = "/tmp/glfs-bt-XXXXXX";
+
+    frames = backtrace(array, GF_BACKTRACE_FRAME_COUNT);
+    if (!frames)
+        return -1;
 
-        ret = fseek (fp, 0L, SEEK_SET);
-        if (ret)
-                goto out;
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(tmpl);
+    if (fd == -1)
+        return -1;
 
-        pos = 0;
-        for (idx = 0; idx < frames - 2; idx++) {
-                ret = fscanf (fp, "%s", callingfn[idx]);
-                if (ret == EOF)
-                        break;
-                inc = gf_backtrace_append (buf, pos, callingfn[idx]);
-                if (inc == -1)
-                        break;
-                pos += inc;
-        }
-        gf_backtrace_end (buf, idx);
+    /* Calling unlink so that when the file is closed or program
+     * terminates the temporary file is deleted.
+     */
+    ret = sys_unlink(tmpl);
+    if (ret < 0) {
+        gf_smsg(THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_DELETE_FAILED,
+                "temporary_file=%s", tmpl, NULL);
+    }
+
+    /*The most recent two frames are the calling function and
+     * gf_backtrace_save, which we can infer.*/
+
+    backtrace_symbols_fd(&array[2], frames - 2, fd);
+
+    fp = fdopen(fd, "r");
+    if (!fp) {
+        sys_close(fd);
+        goto out;
+    }
+
+    ret = fseek(fp, 0L, SEEK_SET);
+    if (ret)
+        goto out;
+
+    pos = 0;
+    for (idx = 0; idx < frames - 2; idx++) {
+        ret = fscanf(fp, "%1023s", callingfn[idx]);
+        if (ret == EOF)
+            break;
+        inc = gf_backtrace_append(buf, pos, callingfn[idx]);
+        if (inc == -1)
+            break;
+        pos += inc;
+    }
+    gf_backtrace_end(buf, idx);
 
 out:
-        if (fp)
-                fclose (fp);
-
-        sys_unlink (tmpl);
-
-        return (idx > 0)? 0: -1;
+    if (fp)
+        fclose(fp);
 
+    return (idx > 0) ? 0 : -1;
 }
 
 /* Optionally takes @buf to save backtrace.  If @buf is NULL, uses the
@@ -4146,66 +4502,69 @@ out:
  * when there is a real-use for that.*/
 
 char *
-gf_backtrace_save (char *buf)
+gf_backtrace_save(char *buf)
 {
-        char *bt = NULL;
-
-        if (!buf) {
-                bt = THIS->ctx->btbuf;
-                GF_ASSERT (bt);
+    char *bt = NULL;
 
-        } else {
-                bt = buf;
+    if (!buf) {
+        bt = THIS->ctx->btbuf;
+        GF_ASSERT(bt);
 
-        }
+    } else {
+        bt = buf;
+    }
 
-        if ((0 == gf_backtrace_fillframes (bt)))
-                return bt;
+    if ((0 == gf_backtrace_fillframes(bt)))
+        return bt;
 
-        gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED,
-                "Failed to save the backtrace.");
-        return NULL;
+    gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED, NULL);
+    return NULL;
 }
 
 gf_loglevel_t
-fop_log_level (glusterfs_fop_t fop, int op_errno)
-{
-        /* if gfid doesn't exist ESTALE comes */
-        if (op_errno == ENOENT || op_errno == ESTALE)
-                return GF_LOG_DEBUG;
-
-        if ((fop == GF_FOP_ENTRYLK) ||
-            (fop == GF_FOP_FENTRYLK) ||
-            (fop == GF_FOP_FINODELK) ||
-            (fop == GF_FOP_INODELK) ||
-            (fop == GF_FOP_LK)) {
-                /*
-                 * if non-blocking lock fails EAGAIN comes
-                 * if locks xlator is not loaded ENOSYS comes
-                 */
-                if (op_errno == EAGAIN || op_errno == ENOSYS)
-                        return GF_LOG_DEBUG;
-        }
-
-        if ((fop == GF_FOP_GETXATTR) ||
-            (fop == GF_FOP_FGETXATTR)) {
-                if (op_errno == ENOTSUP || op_errno == ENODATA)
-                        return GF_LOG_DEBUG;
-        }
+fop_log_level(glusterfs_fop_t fop, int op_errno)
+{
+    /* if gfid doesn't exist ESTALE comes */
+    if (op_errno == ENOENT || op_errno == ESTALE)
+        return GF_LOG_DEBUG;
 
-        if ((fop == GF_FOP_SETXATTR) ||
-            (fop == GF_FOP_FSETXATTR) ||
-            (fop == GF_FOP_REMOVEXATTR) ||
-            (fop == GF_FOP_FREMOVEXATTR)) {
-                if (op_errno == ENOTSUP)
-                        return GF_LOG_DEBUG;
+    if ((fop == GF_FOP_ENTRYLK) || (fop == GF_FOP_FENTRYLK) ||
+        (fop == GF_FOP_FINODELK) || (fop == GF_FOP_INODELK) ||
+        (fop == GF_FOP_LK)) {
+        /*
+         * if non-blocking lock fails EAGAIN comes
+         * if locks xlator is not loaded ENOSYS comes
+         */
+        if (op_errno == EAGAIN || op_errno == ENOSYS)
+            return GF_LOG_DEBUG;
+    }
+
+    if ((fop == GF_FOP_GETXATTR) || (fop == GF_FOP_FGETXATTR)) {
+        if (op_errno == ENOTSUP || op_errno == ENODATA)
+            return GF_LOG_DEBUG;
+    }
+
+    if ((fop == GF_FOP_SETXATTR) || (fop == GF_FOP_FSETXATTR) ||
+        (fop == GF_FOP_REMOVEXATTR) || (fop == GF_FOP_FREMOVEXATTR)) {
+        if (op_errno == ENOTSUP)
+            return GF_LOG_DEBUG;
+    }
+
+    if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR)
+        if (op_errno == EEXIST)
+            return GF_LOG_DEBUG;
+
+    if (fop == GF_FOP_SEEK) {
+#ifdef HAVE_SEEK_HOLE
+        if (op_errno == ENXIO) {
+            return GF_LOG_DEBUG;
         }
+#else
+        return GF_LOG_DEBUG;
+#endif
+    }
 
-        if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR)
-                if (op_errno == EEXIST)
-                        return GF_LOG_DEBUG;
-
-        return GF_LOG_ERROR;
+    return GF_LOG_ERROR;
 }
 
 /* This function will build absolute path of file/directory from the
@@ -4223,116 +4582,115 @@ fop_log_level (glusterfs_fop_t fop, int op_errno)
  */
 
 int32_t
-gf_build_absolute_path (char *current_path, char *relative_path, char **path)
-{
-        char                    *absolute_path          = NULL;
-        char                    *token                  = NULL;
-        char                    *component              = NULL;
-        char                    *saveptr                = NULL;
-        char                    *end                    = NULL;
-        int                     ret                     = 0;
-        size_t                  relativepath_len        = 0;
-        size_t                  currentpath_len         = 0;
-        size_t                  max_absolutepath_len    = 0;
-
-        GF_ASSERT (current_path);
-        GF_ASSERT (relative_path);
-        GF_ASSERT (path);
-
-        if (!path || !current_path || !relative_path) {
-                ret = -EFAULT;
-                goto err;
-        }
-        /* Check for current and relative path
-         * current path should be absolute one and  start from '/'
-         * relative path should not start from '/'
-         */
-        currentpath_len = strlen (current_path);
-        if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Wrong value for current path %s", current_path);
-                ret = -EINVAL;
+gf_build_absolute_path(char *current_path, char *relative_path, char **path)
+{
+    char *absolute_path = NULL;
+    char *token = NULL;
+    char *component = NULL;
+    char *saveptr = NULL;
+    char *end = NULL;
+    int ret = 0;
+    size_t relativepath_len = 0;
+    size_t currentpath_len = 0;
+    size_t max_absolutepath_len = 0;
+
+    GF_ASSERT(current_path);
+    GF_ASSERT(relative_path);
+    GF_ASSERT(path);
+
+    if (!path || !current_path || !relative_path) {
+        ret = -EFAULT;
+        goto err;
+    }
+    /* Check for current and relative path
+     * current path should be absolute one and  start from '/'
+     * relative path should not start from '/'
+     */
+    currentpath_len = strlen(current_path);
+    if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_WRONG_VALUE,
+                "current-path=%s", current_path, NULL);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    relativepath_len = strlen(relative_path);
+    if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_WRONG_VALUE,
+                "relative-path=%s", relative_path, NULL);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    /* It is maximum possible value for absolute path */
+    max_absolutepath_len = currentpath_len + relativepath_len + 2;
+
+    absolute_path = GF_CALLOC(1, max_absolutepath_len, gf_common_mt_char);
+    if (!absolute_path) {
+        ret = -ENOMEM;
+        goto err;
+    }
+    absolute_path[0] = '\0';
+
+    /* If current path is root i.e contains only "/", we do not
+     * need to copy it
+     */
+    if (strcmp(current_path, "/") != 0) {
+        strcpy(absolute_path, current_path);
+
+        /* We trim '/' at the end for easier string manipulation */
+        gf_path_strip_trailing_slashes(absolute_path);
+    }
+
+    /* Used to spilt relative path based on '/' */
+    component = gf_strdup(relative_path);
+    if (!component) {
+        ret = -ENOMEM;
+        goto err;
+    }
+
+    /* In the relative path, we want to consider ".." and "."
+     * if token is ".." , we just need to reduce one level hierarchy
+     * if token is "." , we just ignore it
+     * if token is NULL , end of relative path
+     * if absolute path becomes '\0' and still "..", then it is a bad
+     * relative path,  it points to out of boundary area and stop
+     * building the absolute path
+     * All other cases we just concatenate token to the absolute path
+     */
+    for (token = strtok_r(component, "/", &saveptr),
+        end = strchr(absolute_path, '\0');
+         token; token = strtok_r(NULL, "/", &saveptr)) {
+        if (strcmp(token, ".") == 0)
+            continue;
+
+        else if (strcmp(token, "..") == 0) {
+            if (absolute_path[0] == '\0') {
+                ret = -EACCES;
                 goto err;
-        }
+            }
 
-        relativepath_len = strlen (relative_path);
-        if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Wrong value for relative path %s", relative_path);
-                ret = -EINVAL;
-                goto err;
-        }
-
-        /* It is maximum possible value for absolute path */
-        max_absolutepath_len = currentpath_len + relativepath_len + 2;
-
-        absolute_path = GF_CALLOC (1, max_absolutepath_len, gf_common_mt_char);
-        if (!absolute_path) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        absolute_path[0] = '\0';
-
-        /* If current path is root i.e contains only "/", we do not
-         * need to copy it
-         */
-        if (strcmp (current_path, "/") != 0) {
-                strcpy (absolute_path, current_path);
-
-                /* We trim '/' at the end for easier string manipulation */
-                gf_path_strip_trailing_slashes (absolute_path);
-        }
-
-        /* Used to spilt relative path based on '/' */
-        component = gf_strdup (relative_path);
-        if (!component) {
-                ret = -ENOMEM;
-                goto err;
-        }
-
-        /* In the relative path, we want to consider ".." and "."
-         * if token is ".." , we just need to reduce one level hierarchy
-         * if token is "." , we just ignore it
-         * if token is NULL , end of relative path
-         * if absolute path becomes '\0' and still "..", then it is a bad
-         * relative path,  it points to out of boundary area and stop
-         * building the absolute path
-         * All other cases we just concatenate token to the absolute path
-         */
-        for (token = strtok_r (component,  "/", &saveptr),
-             end = strchr (absolute_path, '\0'); token;
-             token = strtok_r (NULL, "/", &saveptr)) {
-                if (strcmp (token, ".") == 0)
-                        continue;
-
-                else if (strcmp (token, "..") == 0) {
-
-                        if (absolute_path[0] == '\0') {
-                                ret = -EACCES;
-                                goto err;
-                         }
-
-                         end = strrchr (absolute_path, '/');
-                         *end = '\0';
-                } else {
-                        ret = snprintf (end, max_absolutepath_len -
-                                        strlen (absolute_path), "/%s", token);
-                        end = strchr (absolute_path , '\0');
-                }
+            end = strrchr(absolute_path, '/');
+            *end = '\0';
+        } else {
+            ret = snprintf(end, max_absolutepath_len - strlen(absolute_path),
+                           "/%s", token);
+            end = strchr(absolute_path, '\0');
         }
+    }
 
-        if (strlen (absolute_path) > PATH_MAX) {
-                ret = -EINVAL;
-                goto err;
-        }
-        *path = gf_strdup (absolute_path);
+    if (strlen(absolute_path) > PATH_MAX) {
+        ret = -EINVAL;
+        goto err;
+    }
+    *path = gf_strdup(absolute_path);
 
 err:
-        if (component)
-                GF_FREE (component);
-        if (absolute_path)
-                GF_FREE (absolute_path);
-        return ret;
+    if (component)
+        GF_FREE(component);
+    if (absolute_path)
+        GF_FREE(absolute_path);
+    return ret;
 }
 
 /* This is an utility function which will recursively delete
@@ -4343,68 +4701,84 @@ err:
  * @return 0 on success and -1 on failure.
  */
 int
-recursive_rmdir (const char *delete_path)
-{
-        int             ret             = -1;
-        char            path[PATH_MAX]  = {0,};
-        struct stat     st              = {0,};
-        DIR            *dir             = NULL;
-        struct dirent  *entry           = NULL;
-        struct dirent   scratch[2]      = {{0,},};
-        xlator_t       *this            = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-        GF_VALIDATE_OR_GOTO (this->name, delete_path, out);
-
-        dir = sys_opendir (delete_path);
-        if (!dir) {
-                gf_msg_debug (this->name, 0, "Failed to open directory %s. "
-                              "Reason : %s", delete_path, strerror (errno));
-                ret = 0;
-                goto out;
-        }
-
-        GF_FOR_EACH_ENTRY_IN_DIR (entry, dir, scratch);
-        while (entry) {
-                snprintf (path, PATH_MAX, "%s/%s", delete_path, entry->d_name);
-                ret = sys_lstat (path, &st);
-                if (ret == -1) {
-                        gf_msg_debug (this->name, 0, "Failed to stat entry %s :"
-                                      " %s", path, strerror (errno));
-                        goto out;
-                }
-
-                if (S_ISDIR (st.st_mode))
-                        ret = recursive_rmdir (path);
-                else
-                        ret = sys_unlink (path);
-
-                if (ret) {
-                        gf_msg_debug (this->name, 0, " Failed to remove %s. "
-                                      "Reason : %s", path, strerror (errno));
-                }
-
-                gf_msg_debug (this->name, 0, "%s %s", ret ?
-                              "Failed to remove" : "Removed", entry->d_name);
-
-                GF_FOR_EACH_ENTRY_IN_DIR (entry, dir, scratch);
-        }
+recursive_rmdir(const char *delete_path)
+{
+    int ret = -1;
+    char path[PATH_MAX] = {
+        0,
+    };
+    struct stat st = {
+        0,
+    };
+    DIR *dir = NULL;
+    struct dirent *entry = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_VALIDATE_OR_GOTO(this->name, delete_path, out);
+
+    dir = sys_opendir(delete_path);
+    if (!dir) {
+        gf_msg_debug(this->name, 0,
+                     "Failed to open directory %s. "
+                     "Reason : %s",
+                     delete_path, strerror(errno));
+        ret = 0;
+        goto out;
+    }
+
+    while ((entry = sys_readdir(dir, scratch))) {
+        if (gf_irrelevant_entry(entry))
+            continue;
+        snprintf(path, PATH_MAX, "%s/%s", delete_path, entry->d_name);
+        ret = sys_lstat(path, &st);
+        if (ret == -1) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to stat entry %s :"
+                         " %s",
+                         path, strerror(errno));
+            (void)sys_closedir(dir);
+            goto out;
+        }
+
+        if (S_ISDIR(st.st_mode))
+            ret = recursive_rmdir(path);
+        else
+            ret = sys_unlink(path);
 
-        ret = sys_closedir (dir);
         if (ret) {
-                gf_msg_debug (this->name, 0, "Failed to close dir %s. Reason :"
-                              " %s", delete_path, strerror (errno));
-        }
-
-        ret = sys_rmdir (delete_path);
-        if (ret) {
-                gf_msg_debug (this->name, 0, "Failed to rmdir: %s,err: %s",
-                              delete_path, strerror (errno));
-        }
+            gf_msg_debug(this->name, 0,
+                         " Failed to remove %s. "
+                         "Reason : %s",
+                         path, strerror(errno));
+        }
+
+        gf_msg_debug(this->name, 0, "%s %s",
+                     ret ? "Failed to remove" : "Removed", entry->d_name);
+    }
+
+    ret = sys_closedir(dir);
+    if (ret) {
+        gf_msg_debug(this->name, 0,
+                     "Failed to close dir %s. Reason :"
+                     " %s",
+                     delete_path, strerror(errno));
+    }
+
+    ret = sys_rmdir(delete_path);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Failed to rmdir: %s,err: %s", delete_path,
+                     strerror(errno));
+    }
 
 out:
-        return ret;
+    return ret;
 }
 /*
  * Input: Array of strings 'array' terminating in NULL
@@ -4413,197 +4787,198 @@ out:
  * Output: Index of the element in the array if found, '-1' otherwise
  */
 int
-gf_get_index_by_elem (char **array, char *elem)
+gf_get_index_by_elem(char **array, char *elem)
 {
-        int     i = 0;
+    int i = 0;
 
-        for (i = 0; array[i]; i++) {
-                if (strcmp (elem, array[i]) == 0)
-                        return i;
-        }
+    for (i = 0; array[i]; i++) {
+        if (strcmp(elem, array[i]) == 0)
+            return i;
+    }
 
-        return -1;
+    return -1;
 }
 
 static int
-get_pathinfo_host (char *pathinfo, char *hostname, size_t size)
+get_pathinfo_host(char *pathinfo, char *hostname, size_t size)
 {
-        char    *start = NULL;
-        char    *end = NULL;
-        int     ret  = -1;
-        int     i    = 0;
+    char *start = NULL;
+    char *end = NULL;
+    int ret = -1;
+    int i = 0;
 
-        if (!pathinfo)
-                goto out;
+    if (!pathinfo)
+        goto out;
 
-        start = strchr (pathinfo, ':');
-        if (!start)
-                goto out;
+    start = strchr(pathinfo, ':');
+    if (!start)
+        goto out;
 
-        end = strrchr (pathinfo, ':');
-        if (start == end)
-                goto out;
+    end = strrchr(pathinfo, ':');
+    if (start == end)
+        goto out;
 
-        memset (hostname, 0, size);
-        i = 0;
-        while (++start != end)
-                hostname[i++] = *start;
-        ret = 0;
+    memset(hostname, 0, size);
+    i = 0;
+    while (++start != end)
+        hostname[i++] = *start;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /*Note: 'pathinfo' should be gathered only from one brick*/
 int
-glusterfs_is_local_pathinfo (char *pathinfo, gf_boolean_t *is_local)
+glusterfs_is_local_pathinfo(char *pathinfo, gf_boolean_t *is_local)
 {
-        int             ret   = 0;
-        char            pathinfohost[1024] = {0};
-        char            localhost[1024] = {0};
+    int ret = 0;
+    char pathinfohost[1024] = {0};
+    char localhost[1024] = {0};
 
-        *is_local = _gf_false;
-        ret = get_pathinfo_host (pathinfo, pathinfohost, sizeof (pathinfohost));
-        if (ret)
-                goto out;
+    *is_local = _gf_false;
+    ret = get_pathinfo_host(pathinfo, pathinfohost, sizeof(pathinfohost));
+    if (ret)
+        goto out;
 
-        ret = gethostname (localhost, sizeof (localhost));
-        if (ret)
-                goto out;
+    ret = gethostname(localhost, sizeof(localhost));
+    if (ret)
+        goto out;
 
-        if (!strcmp (localhost, pathinfohost))
-                *is_local = _gf_true;
+    if (!strcmp(localhost, pathinfohost))
+        *is_local = _gf_true;
 out:
-        return ret;
+    return ret;
 }
 
 ssize_t
-gf_nread (int fd, void *buf, size_t count)
-{
-        ssize_t  ret           = 0;
-        ssize_t  read_bytes    = 0;
-
-        for (read_bytes = 0; read_bytes < count; read_bytes += ret) {
-                ret = sys_read (fd, buf + read_bytes, count - read_bytes);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+gf_nread(int fd, void *buf, size_t count)
+{
+    ssize_t ret = 0;
+    ssize_t read_bytes = 0;
+
+    for (read_bytes = 0; read_bytes < count; read_bytes += ret) {
+        ret = sys_read(fd, buf + read_bytes, count - read_bytes);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = read_bytes;
+    ret = read_bytes;
 out:
-        return ret;
+    return ret;
 }
 
 ssize_t
-gf_nwrite (int fd, const void *buf, size_t count)
-{
-        ssize_t  ret        = 0;
-        ssize_t  written    = 0;
-
-        for (written = 0; written != count; written += ret) {
-                ret = sys_write (fd, buf + written, count - written);
-                if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+gf_nwrite(int fd, const void *buf, size_t count)
+{
+    ssize_t ret = 0;
+    ssize_t written = 0;
+
+    for (written = 0; written != count; written += ret) {
+        ret = sys_write(fd, buf + written, count - written);
+        if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = written;
+    ret = written;
 out:
-        return ret;
+    return ret;
 }
 
 void
-gf_free_mig_locks (lock_migration_info_t *locks)
+gf_free_mig_locks(lock_migration_info_t *locks)
 {
-        lock_migration_info_t    *current       = NULL;
-        lock_migration_info_t    *temp          = NULL;
+    lock_migration_info_t *current = NULL;
+    lock_migration_info_t *temp = NULL;
 
-        if (!locks)
-                return;
+    if (!locks)
+        return;
 
-        if (list_empty (&locks->list))
-                return;
+    if (list_empty(&locks->list))
+        return;
 
-        list_for_each_entry_safe (current, temp, &locks->list, list) {
-                list_del_init (&current->list);
-                GF_FREE (current->client_uid);
-                GF_FREE (current);
-        }
+    list_for_each_entry_safe(current, temp, &locks->list, list)
+    {
+        list_del_init(&current->list);
+        GF_FREE(current->client_uid);
+        GF_FREE(current);
+    }
 }
 
 void
-_mask_cancellation (void)
+_mask_cancellation(void)
 {
-        (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
+    (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 }
 
 void
-_unmask_cancellation (void)
+_unmask_cancellation(void)
 {
-        (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+    (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 }
 
 /* This is a wrapper function to add a pointer to a list,
  * which doesn't contain list member
  */
-struct list_node*
-_list_node_add (void *ptr, struct list_head *list,
+struct list_node *
+_list_node_add(void *ptr, struct list_head *list,
                int (*compare)(struct list_head *, struct list_head *))
 {
-        struct list_node  *node = NULL;
+    struct list_node *node = NULL;
 
-        if (ptr == NULL || list == NULL)
-                goto out;
+    if (ptr == NULL || list == NULL)
+        goto out;
 
-        node = GF_CALLOC (1, sizeof (struct list_node), gf_common_list_node);
+    node = GF_CALLOC(1, sizeof(struct list_node), gf_common_list_node);
 
-        if (node == NULL)
-                goto out;
+    if (node == NULL)
+        goto out;
 
-        node->ptr = ptr;
-        if (compare)
-                list_add_order (&node->list, list, compare);
-        else
-                list_add_tail (&node->list, list);
+    node->ptr = ptr;
+    if (compare)
+        list_add_order(&node->list, list, compare);
+    else
+        list_add_tail(&node->list, list);
 out:
-        return node;
+    return node;
 }
 
-struct list_node*
-list_node_add (void *ptr, struct list_head *list)
+struct list_node *
+list_node_add(void *ptr, struct list_head *list)
 {
-        return _list_node_add (ptr, list, NULL);
+    return _list_node_add(ptr, list, NULL);
 }
 
-struct list_node*
-list_node_add_order (void *ptr, struct list_head *list,
-                     int (*compare)(struct list_head *, struct list_head *))
+struct list_node *
+list_node_add_order(void *ptr, struct list_head *list,
+                    int (*compare)(struct list_head *, struct list_head *))
 {
-        return _list_node_add (ptr, list, compare);
+    return _list_node_add(ptr, list, compare);
 }
 
 void
-list_node_del (struct list_node *node)
+list_node_del(struct list_node *node)
 {
-        if (node == NULL)
-                return;
+    if (node == NULL)
+        return;
 
-        list_del_init (&node->list);
-        GF_FREE (node);
+    list_del_init(&node->list);
+    GF_FREE(node);
 }
 
 const char *
-fop_enum_to_pri_string (glusterfs_fop_t fop)
+fop_enum_to_pri_string(glusterfs_fop_t fop)
 {
-        switch (fop) {
+    switch (fop) {
         case GF_FOP_OPEN:
         case GF_FOP_STAT:
         case GF_FOP_FSTAT:
@@ -4616,7 +4991,9 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_READDIRP:
         case GF_FOP_GETACTIVELK:
         case GF_FOP_SETACTIVELK:
-                return "HIGH";
+        case GF_FOP_ICREATE:
+        case GF_FOP_NAMELINK:
+            return "HIGH";
 
         case GF_FOP_CREATE:
         case GF_FOP_FLUSH:
@@ -4642,7 +5019,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_FREMOVEXATTR:
         case GF_FOP_IPC:
         case GF_FOP_LEASE:
-                return "NORMAL";
+            return "NORMAL";
 
         case GF_FOP_READ:
         case GF_FOP_WRITE:
@@ -4656,7 +5033,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_ZEROFILL:
         case GF_FOP_FALLOCATE:
         case GF_FOP_SEEK:
-                return "LOW";
+            return "LOW";
 
         case GF_FOP_NULL:
         case GF_FOP_FORGET:
@@ -4665,187 +5042,184 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_GETSPEC:
         case GF_FOP_MAXVALUE:
         case GF_FOP_DISCARD:
-                return "LEAST";
+            return "LEAST";
         default:
-                return "UNKNOWN";
-        }
+            return "UNKNOWN";
+    }
 }
 
 const char *
-gf_inode_type_to_str (ia_type_t type)
+gf_inode_type_to_str(ia_type_t type)
 {
-        static const char *const str_ia_type[] = {
-                "UNKNOWN",
-                "REGULAR FILE",
-                "DIRECTORY",
-                "LINK",
-                "BLOCK DEVICE",
-                "CHARACTER DEVICE",
-                "PIPE",
-                "SOCKET"};
-        return str_ia_type[type];
+    static const char *const str_ia_type[] = {
+        "UNKNOWN",      "REGULAR FILE",     "DIRECTORY", "LINK",
+        "BLOCK DEVICE", "CHARACTER DEVICE", "PIPE",      "SOCKET"};
+    return str_ia_type[type];
 }
 
 gf_boolean_t
-gf_is_zero_filled_stat (struct iatt *buf)
+gf_is_zero_filled_stat(struct iatt *buf)
 {
-        if (!buf)
-                return 1;
+    if (!buf)
+        return 1;
 
-        /* Do not use st_dev because it is transformed to store the xlator id
-         * in place of the device number. Do not use st_ino because by this time
-         * we've already mapped the root ino to 1 so it is not guaranteed to be
-         * 0.
-         */
-        if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0))
-                return 1;
+    /* Do not use st_dev because it is transformed to store the xlator id
+     * in place of the device number. Do not use st_ino because by this time
+     * we've already mapped the root ino to 1 so it is not guaranteed to be
+     * 0.
+     */
+    if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0))
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 void
-gf_zero_fill_stat (struct iatt *buf)
+gf_zero_fill_stat(struct iatt *buf)
 {
-        buf->ia_nlink = 0;
-        buf->ia_ctime = 0;
+    buf->ia_nlink = 0;
+    buf->ia_ctime = 0;
 }
 
 gf_boolean_t
-gf_is_valid_xattr_namespace (char *key)
+gf_is_valid_xattr_namespace(char *key)
 {
-        static char *xattr_namespaces[] = {"trusted.", "security.", "system.",
-                                           "user.", NULL };
-        int i = 0;
+    static char *xattr_namespaces[] = {"trusted.", "system.", "user.",
+                                       "security.", NULL};
+    int i = 0;
 
-        for (i = 0; xattr_namespaces[i]; i++) {
-                if (strncmp (key, xattr_namespaces[i],
-                             strlen (xattr_namespaces[i])) == 0)
-                        return _gf_true;
-        }
+    for (i = 0; xattr_namespaces[i]; i++) {
+        if (strncmp(key, xattr_namespaces[i], strlen(xattr_namespaces[i])) == 0)
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 ino_t
-gfid_to_ino (uuid_t gfid)
+gfid_to_ino(uuid_t gfid)
 {
-        ino_t ino = 0;
-        int32_t i;
+    ino_t ino = 0;
+    int32_t i;
 
-        for (i = 8; i < 16; i++) {
-                ino <<= 8;
-                ino += (uint8_t)gfid[i];
-        }
+    for (i = 8; i < 16; i++) {
+        ino <<= 8;
+        ino += (uint8_t)gfid[i];
+    }
 
-        return ino;
+    return ino;
 }
 
 int
-gf_bits_count (uint64_t n)
+gf_bits_count(uint64_t n)
 {
-        int val = 0;
+    int val = 0;
 #if defined(__GNUC__) || defined(__clang__)
-        val = __builtin_popcountll (n);
+    val = __builtin_popcountll(n);
 #else
-        n -= (n >> 1) & 0x5555555555555555ULL;
-        n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL);
-        n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-        n += n >> 8;
-        n += n >> 16;
-        n += n >> 32;
-        val = n & 0xFF;
+    n -= (n >> 1) & 0x5555555555555555ULL;
+    n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL);
+    n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+    n += n >> 8;
+    n += n >> 16;
+    n += n >> 32;
+    val = n & 0xFF;
 #endif
-        return val;
+    return val;
 }
 
 int
-gf_bits_index (uint64_t n)
+gf_bits_index(uint64_t n)
 {
 #if defined(__GNUC__) || defined(__clang__)
-        return __builtin_ffsll (n) - 1;
+    return __builtin_ffsll(n) - 1;
 #else
-        return ffsll (n) - 1;
+    return ffsll(n) - 1;
 #endif
 }
 
-const char*
-gf_fop_string (glusterfs_fop_t fop)
+const char *
+gf_fop_string(glusterfs_fop_t fop)
 {
-        if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE))
-                return gf_fop_list[fop];
-        return "INVALID";
+    if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE))
+        return gf_fop_list[fop];
+    return "INVALID";
 }
 
 int
-gf_fop_int (char *fop)
+gf_fop_int(char *fop)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
-                if (strcasecmp (fop, gf_fop_list[i]) == 0)
-                        return i;
-        }
-        return -1;
+    for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
+        if (strcasecmp(fop, gf_fop_list[i]) == 0)
+            return i;
+    }
+    return -1;
 }
 
 int
-close_fds_except (int *fdv, size_t count)
+close_fds_except(int *fdv, size_t count)
 {
-        int          i            = 0;
-        size_t       j            = 0;
-        gf_boolean_t should_close = _gf_true;
+    int i = 0;
+    size_t j = 0;
+    gf_boolean_t should_close = _gf_true;
 #ifdef GF_LINUX_HOST_OS
-        DIR           *d          = NULL;
-        struct dirent *de         = NULL;
-        struct dirent  scratch[2] = {{0,},};
-        char          *e          = NULL;
-
-        d = sys_opendir ("/proc/self/fd");
-        if (!d)
-                return -1;
-
-        for (;;) {
-                should_close = _gf_true;
-
-                errno = 0;
-                de = sys_readdir (d, scratch);
-                if (!de || errno != 0)
-                        break;
-                i = strtoul (de->d_name, &e, 10);
-                if (*e != '\0' || i == dirfd (d))
-                        continue;
-
-                for (j = 0; j < count; j++) {
-                        if (i == fdv[j]) {
-                                should_close = _gf_false;
-                                break;
-                        }
-               }
-               if (should_close)
-                        sys_close (i);
-        }
-        sys_closedir (d);
-#else /* !GF_LINUX_HOST_OS */
-        struct rlimit rl;
-        int ret = -1;
+    DIR *d = NULL;
+    struct dirent *de = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    char *e = NULL;
+
+    d = sys_opendir("/proc/self/fd");
+    if (!d)
+        return -1;
+
+    for (;;) {
+        should_close = _gf_true;
 
-        ret = getrlimit (RLIMIT_NOFILE, &rl);
-        if (ret)
-                return ret;
-
-        for (i = 0; i < rl.rlim_cur; i++) {
-                should_close = _gf_true;
-                for (j = 0; j < count; j++) {
-                        if (i == fdv[j]) {
-                                should_close = _gf_false;
-                                break;
-                        }
-                }
-                if (should_close)
-                        sys_close (i);
+        errno = 0;
+        de = sys_readdir(d, scratch);
+        if (!de || errno != 0)
+            break;
+        i = strtoul(de->d_name, &e, 10);
+        if (*e != '\0' || i == dirfd(d))
+            continue;
+
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = _gf_false;
+                break;
+            }
+        }
+        if (should_close)
+            sys_close(i);
+    }
+    sys_closedir(d);
+#else  /* !GF_LINUX_HOST_OS */
+    struct rlimit rl;
+    int ret = -1;
+
+    ret = getrlimit(RLIMIT_NOFILE, &rl);
+    if (ret)
+        return ret;
+
+    for (i = 0; i < rl.rlim_cur; i++) {
+        should_close = _gf_true;
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = _gf_false;
+                break;
+            }
         }
+        if (should_close)
+            sys_close(i);
+    }
 #endif /* !GF_LINUX_HOST_OS */
-        return 0;
+    return 0;
 }
 
 /**
@@ -4859,110 +5233,233 @@ close_fds_except (int *fdv, size_t count)
  *
  * gf_getgrouplist allocates a gid_t buffer which is big enough to
  * hold the list of auxiliary group ids for user, up to the GF_MAX_AUX_GROUPS
- * threshold. Upon succesfull invocation groups will be pointed to that buffer.
+ * threshold. Upon successful invocation groups will be pointed to that buffer.
  *
  * @return success: the number of auxiliary group ids retrieved
  *         failure: -1
  */
 int
-gf_getgrouplist (const char *user, gid_t group, gid_t **groups)
+gf_getgrouplist(const char *user, gid_t group, gid_t **groups)
 {
-        int ret     = -1;
-        int ngroups = SMALL_GROUP_COUNT;
+    int ret = -1;
+    int ngroups = SMALL_GROUP_COUNT;
+
+    *groups = GF_CALLOC(sizeof(gid_t), ngroups, gf_common_mt_groups_t);
+    if (!*groups)
+        return -1;
 
-        *groups = GF_CALLOC (sizeof (gid_t), ngroups, gf_common_mt_groups_t);
+    /*
+     * We are running getgrouplist() in a loop until we succeed (or hit
+     * certain exit conditions, see the comments below). This is because
+     * the indicated number of auxiliary groups that we obtain in case of
+     * the failure of the first invocation is not guaranteed to keep its
+     * validity upon the next invocation with a gid buffer of that size.
+     */
+    for (;;) {
+        int ngroups_old = ngroups;
+        ret = getgrouplist(user, group, *groups, &ngroups);
+        if (ret != -1)
+            break;
+
+        if (ngroups >= GF_MAX_AUX_GROUPS) {
+            /*
+             * This should not happen as GF_MAX_AUX_GROUPS is set
+             * to the max value of number of supported auxiliary
+             * groups across all platforms supported by GlusterFS.
+             * However, if it still happened some way, we wouldn't
+             * care about the incompleteness of the result, we'd
+             * just go on with what we got.
+             */
+            return GF_MAX_AUX_GROUPS;
+        } else if (ngroups <= ngroups_old) {
+            /*
+             * There is an edge case that getgrouplist() fails but
+             * ngroups remains the same. This is actually not
+             * specified in getgrouplist(3), but implementations
+             * can do this upon internal failure[1]. To avoid
+             * falling into an infinite loop when this happens, we
+             * break the loop if the getgrouplist call failed
+             * without an increase in the indicated group number.
+             *
+             * [1]
+             * https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168
+             */
+            GF_FREE(*groups);
+            return -1;
+        }
+
+        *groups = GF_REALLOC(*groups, ngroups * sizeof(gid_t));
         if (!*groups)
-                return -1;
+            return -1;
+    }
+    return ret;
+}
 
-        /*
-         * We are running getgrouplist() in a loop until we succeed (or hit
-         * certain exit conditions, see the comments below). This is because
-         * the indicated number of auxiliary groups that we obtain in case of
-         * the failure of the first invocation is not guaranteed to keep its
-         * validity upon the next invocation with a gid buffer of that size.
-         */
-        for (;;) {
-                int ngroups_old = ngroups;
-                ret = getgrouplist (user, group, *groups, &ngroups);
-                if (ret != -1)
-                        break;
-
-                if (ngroups >= GF_MAX_AUX_GROUPS) {
-                        /*
-                         * This should not happen as GF_MAX_AUX_GROUPS is set
-                         * to the max value of number of supported auxiliary
-                         * groups across all platforms supported by GlusterFS.
-                         * However, if it still happened some way, we wouldn't
-                         * care about the incompleteness of the result, we'd
-                         * just go on with what we got.
-                         */
-                        return GF_MAX_AUX_GROUPS;
-                } else if (ngroups <= ngroups_old) {
-                        /*
-                         * There is an edge case that getgrouplist() fails but
-                         * ngroups remains the same. This is actually not
-                         * specified in getgrouplist(3), but implementations
-                         * can do this upon internal failure[1]. To avoid
-                         * falling into an infinite loop when this happens, we
-                         * break the loop if the getgrouplist call failed
-                         * without an increase in the indicated group number.
-                         *
-                         * [1] https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168
-                         */
-                        GF_FREE (*groups);
-                        return -1;
-                }
-
-                *groups = GF_REALLOC (*groups, ngroups * sizeof (gid_t));
-                if (!*groups)
-                        return -1;
-        }
-        return ret;
+int
+glusterfs_compute_sha256(const unsigned char *content, size_t size,
+                         char *sha256_hash)
+{
+    SHA256_CTX sha256;
+
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, (const unsigned char *)(content), size);
+    SHA256_Final((unsigned char *)sha256_hash, &sha256);
+
+    return 0;
+}
+
+/* * Safe wrapper function for strncpy.
+ * This wrapper makes sure that when there is no null byte among the first n in
+ * source srting for strncpy function call, the string placed in dest will be
+ * null-terminated.
+ */
+
+char *
+gf_strncpy(char *dest, const char *src, const size_t dest_size)
+{
+    strncpy(dest, src, dest_size - 1);
+    dest[dest_size - 1] = '\0';
+    return dest;
 }
 
 int
-glusterfs_compute_sha256 (const unsigned char *content, size_t size,
-                          char *sha256_hash) {
-        SHA256_CTX               sha256;
+gf_replace_old_iatt_in_dict(dict_t *xdata)
+{
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* current iatt */
 
-        SHA256_Init (&sha256);
-        SHA256_Update (&sha256, (const unsigned char *) (content), size);
-        SHA256_Final ((unsigned char *) sha256_hash, &sha256);
+    if (!xdata) {
+        return 0;
+    }
 
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt);
+    if (ret < 0) {
         return 0;
+    }
+
+    o_iatt = GF_CALLOC(1, sizeof(struct old_iatt), gf_common_mt_char);
+    if (!o_iatt) {
+        return -1;
+    }
+
+    oldiatt_from_iatt(o_iatt, c_iatt);
+
+    ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, o_iatt,
+                       sizeof(struct old_iatt));
+    if (ret) {
+        GF_FREE(o_iatt);
+    }
+
+    return ret;
 }
 
-char*
-get_struct_variable (int mem_num, gf_gsync_status_t *sts_val)
-{
-        switch (mem_num) {
-        case 0:  return (sts_val->node);
-        case 1:  return (sts_val->master);
-        case 2:  return (sts_val->brick);
-        case 3:  return (sts_val->slave_user);
-        case 4:  return (sts_val->slave);
-        case 5:  return (sts_val->slave_node);
-        case 6:  return (sts_val->worker_status);
-        case 7:  return (sts_val->crawl_status);
-        case 8:  return (sts_val->last_synced);
-        case 9:  return (sts_val->entry);
-        case 10:  return (sts_val->data);
-        case 11:  return (sts_val->meta);
-        case 12: return (sts_val->failures);
-        case 13:  return (sts_val->checkpoint_time);
-        case 14:  return (sts_val->checkpoint_completed);
-        case 15:  return (sts_val->checkpoint_completion_time);
-        case 16: return (sts_val->brick_host_uuid);
-        case 17: return (sts_val->last_synced_utc);
-        case 18: return (sts_val->checkpoint_time_utc);
-        case 19: return (sts_val->checkpoint_completion_time_utc);
-        case 20: return (sts_val->slavekey);
-        case 21: return (sts_val->session_slave);
+int
+gf_replace_new_iatt_in_dict(dict_t *xdata)
+{
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* new iatt */
+
+    if (!xdata) {
+        return 0;
+    }
+
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt);
+    if (ret < 0) {
+        return 0;
+    }
+
+    c_iatt = GF_CALLOC(1, sizeof(struct iatt), gf_common_mt_char);
+    if (!c_iatt) {
+        return -1;
+    }
+
+    iatt_from_oldiatt(c_iatt, o_iatt);
+
+    ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, c_iatt,
+                       sizeof(struct iatt));
+    if (ret) {
+        GF_FREE(c_iatt);
+    }
+
+    return ret;
+}
+
+xlator_cmdline_option_t *
+find_xlator_option_in_cmd_args_t(const char *option_name, cmd_args_t *args)
+{
+    xlator_cmdline_option_t *pos = NULL;
+    xlator_cmdline_option_t *tmp = NULL;
+
+    list_for_each_entry_safe(pos, tmp, &args->xlator_options, cmd_args)
+    {
+        if (strcmp(pos->key, option_name) == 0)
+            return pos;
+    }
+    return NULL;
+}
+
+int
+gf_d_type_from_ia_type(ia_type_t type)
+{
+    switch (type) {
+        case IA_IFDIR:
+            return DT_DIR;
+        case IA_IFCHR:
+            return DT_CHR;
+        case IA_IFBLK:
+            return DT_BLK;
+        case IA_IFIFO:
+            return DT_FIFO;
+        case IA_IFLNK:
+            return DT_LNK;
+        case IA_IFREG:
+            return DT_REG;
+        case IA_IFSOCK:
+            return DT_SOCK;
         default:
-                 goto out;
-        }
+            return DT_UNKNOWN;
+    }
+}
 
-out:
-        return NULL;
+int
+gf_nanosleep(uint64_t nsec)
+{
+    struct timespec req;
+    struct timespec rem;
+    int ret = -1;
+
+    req.tv_sec = nsec / GF_SEC_IN_NS;
+    req.tv_nsec = nsec % GF_SEC_IN_NS;
+
+    do {
+        ret = nanosleep(&req, &rem);
+        req = rem;
+    } while (ret == -1 && errno == EINTR);
+
+    return ret;
 }
 
+int
+gf_syncfs(int fd)
+{
+    int ret = 0;
+#if defined(HAVE_SYNCFS)
+    /* Linux with glibc recent enough. */
+    ret = syncfs(fd);
+#elif defined(HAVE_SYNCFS_SYS)
+    /* Linux with no library function. */
+    ret = syscall(SYS_syncfs, fd);
+#else
+    /* Fallback to generic UNIX stuff. */
+    sync();
+#endif
+    return ret;
+}
+
+char **
+get_xattrs_to_heal()
+{
+    return xattrs_to_heal;
+}
diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h
deleted file mode 100644
index 01310709cee..00000000000
--- a/libglusterfs/src/common-utils.h
+++ /dev/null
@@ -1,946 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _COMMON_UTILS_H
-#define _COMMON_UTILS_H
-
-#include <stdint.h>
-#include <sys/uio.h>
-#include <netdb.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <pthread.h>
-#include <openssl/md5.h>
-#ifndef GF_BSD_HOST_OS
-#include <alloca.h>
-#endif
-#include <limits.h>
-#include <fnmatch.h>
-
-#ifndef ffsll
-#define ffsll(x) __builtin_ffsll(x)
-#endif
-
-void trap (void);
-
-#define GF_UNIVERSAL_ANSWER 42    /* :O */
-
-/* To solve type punned error */
-#define VOID(ptr) ((void **) ((void *) ptr))
-
-#include "logging.h"
-#include "glusterfs.h"
-#include "locking.h"
-#include "mem-pool.h"
-#include "compat-uuid.h"
-#include "iatt.h"
-#include "uuid.h"
-#include "libglusterfs-messages.h"
-#include "protocol-common.h"
-
-#define STRINGIFY(val) #val
-#define TOSTRING(val) STRINGIFY(val)
-
-#define alloca0(size) ({void *__ptr; __ptr = alloca(size); memset(__ptr, 0, size); __ptr; })
-
-#define min(a,b) ((a)<(b)?(a):(b))
-#define max(a,b) ((a)>(b)?(a):(b))
-#define roof(a,b) ((((a)+(b)-1)/((b)?(b):1))*(b))
-#define floor(a,b) (((a)/((b)?(b):1))*(b))
-
-#define IPv4_ADDR_SIZE 32
-
-
-#define GF_UNIT_KB    1024ULL
-#define GF_UNIT_MB    1048576ULL
-#define GF_UNIT_GB    1073741824ULL
-#define GF_UNIT_TB    1099511627776ULL
-#define GF_UNIT_PB    1125899906842624ULL
-
-#define GF_UNIT_B_STRING     "B"
-#define GF_UNIT_KB_STRING    "KB"
-#define GF_UNIT_MB_STRING    "MB"
-#define GF_UNIT_GB_STRING    "GB"
-#define GF_UNIT_TB_STRING    "TB"
-#define GF_UNIT_PB_STRING    "PB"
-
-#define GF_UNIT_PERCENT_STRING      "%"
-
-#define GEOREP "geo-replication"
-#define GHADOOP "glusterfs-hadoop"
-#define GLUSTERD_NAME "glusterd"
-
-#define GF_SELINUX_XATTR_KEY "security.selinux"
-
-#define WIPE(statp) do { typeof(*statp) z = {0,}; if (statp) *statp = z; } while (0)
-
-#define IS_EXT_FS(fs_name)          \
-        (!strcmp (fs_name, "ext2") || \
-         !strcmp (fs_name, "ext3") || \
-         !strcmp (fs_name, "ext4"))
-
-/* process mode definitions */
-#define GF_SERVER_PROCESS   0
-#define GF_CLIENT_PROCESS   1
-#define GF_GLUSTERD_PROCESS 2
-
-/* Defining this here as it is needed by glusterd for setting
- * nfs port in volume status.
- */
-#define GF_NFS3_PORT    2049
-
-#define GF_CLIENT_PORT_CEILING 1024
-#define GF_IANA_PRIV_PORTS_START 49152 /* RFC 6335 */
-#define GF_CLNT_INSECURE_PORT_CEILING (GF_IANA_PRIV_PORTS_START - 1)
-#define GF_PORT_MAX 65535
-#define GF_PORT_ARRAY_SIZE ((GF_PORT_MAX + 7) / 8)
-#define GF_LOCK_TIMER 180
-#define GF_MINUTE_IN_SECONDS 60
-#define GF_HOUR_IN_SECONDS (60*60)
-#define GF_DAY_IN_SECONDS (24*60*60)
-#define GF_WEEK_IN_SECONDS (7*24*60*60)
-
-/* Default timeout for both barrier and changelog translator */
-#define BARRIER_TIMEOUT "120"
-
-/* Default value of signing waiting time to sign a file for bitrot */
-#define SIGNING_TIMEOUT "120"
-
-/* xxhash */
-#define GF_XXH64_DIGEST_LENGTH 8
-#define GF_XXHSUM64_DEFAULT_SEED 0
-
-/* Shard */
-#define GF_XATTR_SHARD_FILE_SIZE  "trusted.glusterfs.shard.file-size"
-#define SHARD_ROOT_GFID "be318638-e8a0-4c6d-977d-7a937aa84806"
-
-/* Lease: buffer length for stringified lease id
- * Format: 4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum
- * Eg:6c69-6431-2d63-6c6e-7431-0000-0000-0000
- */
-#define GF_LEASE_ID_BUF_SIZE  ((LEASE_ID_SIZE * 2) +     \
-                               (LEASE_ID_SIZE / 2))
-
-#define GF_PERCENTAGE(val, total) (((val)*100)/(total))
-
-/* pthread related */
-#define GF_THREAD_NAMEMAX 9
-#define GF_THREAD_NAME_PREFIX "gluster"
-#define GF_THREAD_NAME_PREFIX_LEN 7
-
-enum _gf_boolean
-{
-	_gf_false = 0,
-	_gf_true = 1
-};
-
-/*
- * we could have initialized these as +ve values and treated
- * them as negative while comparing etc.. (which would have
- * saved us with the pain of assigning values), but since we
- * only have a few clients that use this feature, it's okay.
- */
-enum _gf_special_pid
-{
-        GF_CLIENT_PID_MAX               =  0,
-        GF_CLIENT_PID_GSYNCD            = -1,
-        GF_CLIENT_PID_HADOOP            = -2,
-        GF_CLIENT_PID_DEFRAG            = -3,
-        GF_CLIENT_PID_NO_ROOT_SQUASH    = -4,
-        GF_CLIENT_PID_QUOTA_MOUNT       = -5,
-        GF_CLIENT_PID_SELF_HEALD        = -6,
-        GF_CLIENT_PID_GLFS_HEAL         = -7,
-        GF_CLIENT_PID_BITD              = -8,
-        GF_CLIENT_PID_SCRUB             = -9,
-        GF_CLIENT_PID_TIER_DEFRAG       = -10,
-        GF_SERVER_PID_TRASH             = -11
-};
-
-enum _gf_xlator_ipc_targets {
-        GF_IPC_TARGET_CHANGELOG = 0,
-        GF_IPC_TARGET_CTR = 1,
-        GF_IPC_TARGET_UPCALL = 2
-};
-
-typedef enum _gf_boolean gf_boolean_t;
-typedef enum _gf_special_pid gf_special_pid_t;
-typedef enum _gf_xlator_ipc_targets _gf_xlator_ipc_targets_t;
-
-/* The DHT file rename operation is not a straightforward rename.
- * It involves creating linkto and linkfiles, and can unlink or rename the
- * source file depending on the hashed and cached subvols for the source
- * and target files. this makes it difficult for geo-rep to figure out that
- * a rename operation has taken place.
- *
- * We now send a special key and the values of the source and target pargfids
- * and basenames to indicate to changelog that the operation in question
- * should be treated as a rename. We are explicitly filling and sending this
- * as a binary value in the dictionary as the unlink op will not have the
- * source file information. The lengths of the src and target basenames
- * are used to calculate where to start reading the names in the structure.
- * XFS allows a max of 255 chars for filenames but other file systems might
- * not have such restrictions
- */
-typedef struct dht_changelog_rename_info {
-         uuid_t  old_pargfid;
-         uuid_t  new_pargfid;
-         int32_t oldname_len;
-         int32_t newname_len;
-         char    buffer[1];
- } dht_changelog_rename_info_t;
-
-
-typedef int (*gf_cmp) (void *, void *);
-
-struct _dict;
-
-struct dnscache {
-        struct _dict *cache_dict;
-        time_t ttl;
-};
-
-struct dnscache_entry {
-        char *ip;
-        char *fqdn;
-        time_t timestamp;
-};
-
-struct dnscache6 {
-        struct addrinfo *first;
-        struct addrinfo *next;
-};
-
-struct list_node {
-        void *ptr;
-        struct list_head list;
-};
-
-extern char *vol_type_str[];
-
-struct list_node *list_node_add (void *ptr, struct list_head *list);
-struct list_node *list_node_add_order (void *ptr, struct list_head *list,
-                                       int (*compare)(struct list_head *,
-                                            struct list_head *));
-void list_node_del (struct list_node *node);
-
-struct dnscache *gf_dnscache_init (time_t ttl);
-struct dnscache_entry *gf_dnscache_entry_init (void);
-void gf_dnscache_entry_deinit (struct dnscache_entry *entry);
-char *gf_rev_dns_lookup_cached (const char *ip, struct dnscache *dnscache);
-
-char *gf_resolve_path_parent (const char *path);
-
-void gf_global_variable_init(void);
-
-int32_t gf_resolve_ip6 (const char *hostname, uint16_t port, int family,
-                        void **dnscache, struct addrinfo **addr_info);
-
-void gf_log_dump_graph (FILE *specfp, glusterfs_graph_t *graph);
-void gf_print_trace (int32_t signal, glusterfs_ctx_t *ctx);
-int  gf_set_log_file_path (cmd_args_t *cmd_args, glusterfs_ctx_t *ctx);
-int  gf_set_log_ident (cmd_args_t *cmd_args);
-
-static inline void
-BIT_SET (unsigned char *array, unsigned int index)
-{
-        unsigned int    offset  = index / 8;
-        unsigned int    shift   = index % 8;
-
-        array[offset] |= (1 << shift);
-}
-
-static inline void
-BIT_CLEAR (unsigned char *array, unsigned int index)
-{
-        unsigned int    offset  = index / 8;
-        unsigned int    shift   = index % 8;
-
-        array[offset] &= ~(1 << shift);
-}
-
-static inline unsigned int
-BIT_VALUE (unsigned char *array, unsigned int index)
-{
-        unsigned int    offset  = index / 8;
-        unsigned int    shift   = index % 8;
-
-        return (array[offset] >> shift) & 0x1;
-}
-
-#define VECTORSIZE(count) (count * (sizeof (struct iovec)))
-
-#define STRLEN_0(str) (strlen(str) + 1)
-
-#define VALIDATE_OR_GOTO(arg,label)   do {				\
-		if (!arg) {						\
-			errno = EINVAL;					\
-			gf_msg_callingfn ((this ? (this->name) :        \
-                                           "(Govinda! Govinda!)"),      \
-                                          GF_LOG_WARNING, EINVAL,       \
-                                          LG_MSG_INVALID_ARG,           \
-                                          "invalid argument: " #arg);   \
-			goto label;					\
-		}							\
-	} while (0)
-
-#define GF_VALIDATE_OR_GOTO(name,arg,label)   do {                      \
-		if (!arg) {                                             \
-			errno = EINVAL;                                 \
-			gf_msg_callingfn (name, GF_LOG_ERROR, errno,    \
-                                          LG_MSG_INVALID_ARG,           \
-                                          "invalid argument: " #arg);	\
-			goto label;                                     \
-		}                                                       \
-	} while (0)
-
-#define GF_VALIDATE_OR_GOTO_WITH_ERROR(name, arg, label, errno, error) do { \
-                if (!arg) {                                                 \
-                        errno = error;                                  \
-                        gf_msg_callingfn (name, GF_LOG_ERROR, EINVAL,   \
-                                          LG_MSG_INVALID_ARG,         \
-                                          "invalid argument: " #arg);   \
-                        goto label;                                     \
-                }                                                       \
-        }while (0)
-
-#define GF_CHECK_ALLOC(arg, retval, label)   do {                       \
-                if (!(arg)) {                                           \
-                        retval = -ENOMEM;                               \
-                        goto label;                                     \
-                }                                                       \
-        } while (0)                                                     \
-
-#define GF_CHECK_ALLOC_AND_LOG(name, item, retval, msg, errlabel) do {  \
-                if (!(item)) {                                          \
-                        (retval) = -ENOMEM;                             \
-                        gf_msg (name, GF_LOG_CRITICAL, ENOMEM,          \
-                                LG_MSG_NO_MEMORY, (msg));               \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)
-
-#define GF_ASSERT_AND_GOTO_WITH_ERROR(name, arg, label, errno, error) do { \
-                if (!arg) {                                             \
-                        GF_ASSERT (0);                                  \
-                        errno = error;                                  \
-                        goto label;                                     \
-                }                                                       \
-        }while (0)
-
-#define GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO(name,arg,label)               \
-        do {                                                            \
-                GF_VALIDATE_OR_GOTO (name, arg, label);                 \
-                if ((arg[0]) != '/') {                                  \
-                        errno = EINVAL;                                 \
-			gf_msg_callingfn (name, GF_LOG_ERROR, EINVAL,   \
-                                          LG_MSG_INVALID_ARG,           \
-                                          "invalid argument: " #arg);	\
-                        goto label;                                     \
-                }                                                       \
-	} while (0)
-
-#define GF_REMOVE_SLASH_FROM_PATH(path, string)                         \
-        do {                                                            \
-                int i = 0;                                              \
-                for (i = 1; i < strlen (path); i++) {                   \
-                        string[i-1] = path[i];                          \
-                        if (string[i-1] == '/')                         \
-                                string[i-1] = '-';                      \
-                }                                                       \
-        } while (0)
-
-#define GF_REMOVE_INTERNAL_XATTR(pattern, dict)                         \
-        do {                                                            \
-                if (!dict) {                                            \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,            \
-                                LG_MSG_DICT_NULL, "dict is null");      \
-                        break;                                          \
-                }                                                       \
-                dict_foreach_fnmatch (dict, pattern,                    \
-                                      dict_remove_foreach_fn,           \
-                                      NULL);                            \
-        } while (0)
-
-#define GF_IF_INTERNAL_XATTR_GOTO(pattern, dict, op_errno, label)       \
-        do {                                                            \
-                if (!dict) {                                            \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,            \
-                                LG_MSG_DICT_NULL,                        \
-                                "setxattr dict is null");               \
-                        goto label;                                     \
-                }                                                       \
-                if (dict_foreach_fnmatch (dict, pattern,                \
-                                          dict_null_foreach_fn,         \
-                                          NULL) > 0) {                  \
-                        op_errno = EPERM;                               \
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,     \
-                                LG_MSG_NO_PERM,                         \
-                                "attempt to set internal"               \
-                                " xattr: %s", pattern);                 \
-                        goto label;                                     \
-                }                                                       \
-        } while (0)
-
-#define GF_IF_NATIVE_XATTR_GOTO(pattern, key, op_errno, label)          \
-        do {                                                            \
-                if (!key) {                                             \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,            \
-                                LG_MSG_NO_KEY,                          \
-                                "no key for removexattr");              \
-                        goto label;                                     \
-                }                                                       \
-                if (!fnmatch (pattern, key, 0)) {                       \
-                        op_errno = EPERM;                               \
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,     \
-                                LG_MSG_NO_PERM,                         \
-                                "attempt to remove internal "           \
-                                "xattr: %s", key);                      \
-                        goto label;                                     \
-                }                                                       \
-        } while (0)
-
-
-#define GF_FILE_CONTENT_REQUESTED(_xattr_req,_content_limit) \
-	(dict_get_uint64 (_xattr_req, "glusterfs.content", _content_limit) == 0)
-
-#ifdef DEBUG
-#define GF_ASSERT(x) assert (x);
-#else
-#define GF_ASSERT(x)                                                    \
-        do {                                                            \
-                if (!(x)) {                                             \
-                        gf_msg_callingfn ("", GF_LOG_ERROR, 0,          \
-                                          LG_MSG_ASSERTION_FAILED,      \
-                                          "Assertion failed: " #x);     \
-                }                                                       \
-        } while (0)
-#endif
-
-#define GF_UUID_ASSERT(u) \
-        if (gf_uuid_is_null (u))\
-                GF_ASSERT (!"uuid null");
-
-#define GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)                 \
-        (((frame->root->pid == GF_CLIENT_PID_GSYNCD) &&                 \
-          (op_errno == EEXIST || op_errno == ENOENT))?0:1)              \
-
-union gf_sock_union {
-        struct sockaddr_storage storage;
-        struct sockaddr_in6 sin6;
-        struct sockaddr_in sin;
-        struct sockaddr sa;
-};
-
-#define GF_HIDDEN_PATH ".glusterfs"
-#define GF_UNLINK_PATH GF_HIDDEN_PATH"/unlink"
-#define GF_LANDFILL_PATH GF_HIDDEN_PATH"/landfill"
-
-#define IOV_MIN(n) min(IOV_MAX,n)
-
-#define GF_FOR_EACH_ENTRY_IN_DIR(entry, dir, scr) \
-        do {\
-                entry = NULL;\
-                if (dir) { \
-                        entry = sys_readdir (dir, scr); \
-                        while (entry && (!strcmp (entry->d_name, ".") || \
-                            !fnmatch ("*.tmp", entry->d_name, 0) || \
-                            !strcmp (entry->d_name, ".."))) { \
-                                entry = sys_readdir (dir, scr); \
-                        } \
-                } \
-        } while (0)
-
-static inline void
-iov_free (struct iovec *vector, int count)
-{
-	int i;
-
-	for (i = 0; i < count; i++)
-		FREE (vector[i].iov_base);
-
-	GF_FREE (vector);
-}
-
-
-static inline int
-iov_length (const struct iovec *vector, int count)
-{
-	int     i = 0;
-	size_t  size = 0;
-
-	for (i = 0; i < count; i++)
-		size += vector[i].iov_len;
-
-	return size;
-}
-
-
-static inline struct iovec *
-iov_dup (const struct iovec *vector, int count)
-{
-	int           bytecount = 0;
-	int           i;
-	struct iovec *newvec = NULL;
-
-	bytecount = (count * sizeof (struct iovec));
-	newvec = GF_MALLOC (bytecount, gf_common_mt_iovec);
-	if (!newvec)
-		return NULL;
-
-	for (i = 0; i < count; i++) {
-		newvec[i].iov_len  = vector[i].iov_len;
-		newvec[i].iov_base = vector[i].iov_base;
-	}
-
-	return newvec;
-}
-
-
-static inline int
-iov_subset (struct iovec *orig, int orig_count,
-	    off_t src_offset, off_t dst_offset,
-	    struct iovec *new)
-{
-	int    new_count = 0;
-	int    i;
-	off_t  offset = 0;
-	size_t start_offset = 0;
-	size_t end_offset = 0, origin_iov_len = 0;
-
-
-	for (i = 0; i < orig_count; i++) {
-                origin_iov_len = orig[i].iov_len;
-
-		if ((offset + orig[i].iov_len < src_offset)
-		    || (offset > dst_offset)) {
-			goto not_subset;
-		}
-
-		if (!new) {
-			goto count_only;
-		}
-
-		start_offset = 0;
-		end_offset = orig[i].iov_len;
-
-		if (src_offset >= offset) {
-			start_offset = (src_offset - offset);
-		}
-
-		if (dst_offset <= (offset + orig[i].iov_len)) {
-			end_offset = (dst_offset - offset);
-		}
-
-		new[new_count].iov_base = orig[i].iov_base + start_offset;
-		new[new_count].iov_len = end_offset - start_offset;
-
-	count_only:
-		new_count++;
-
-	not_subset:
-		offset += origin_iov_len;
-	}
-
-	return new_count;
-}
-
-
-static inline void
-iov_unload (char *buf, const struct iovec *vector, int count)
-{
-	int i;
-	int copied = 0;
-
-	for (i = 0; i < count; i++) {
-		memcpy (buf + copied, vector[i].iov_base, vector[i].iov_len);
-		copied += vector[i].iov_len;
-	}
-}
-
-
-static inline size_t
-iov_load (const struct iovec *vector, int count, char *buf, int size)
-{
-	size_t left = size;
-	size_t cp = 0;
-	int    ret = 0;
-	int    i = 0;
-
-	while (left && i < count) {
-		cp = min (vector[i].iov_len, left);
-		if (vector[i].iov_base != buf + (size - left))
-			memcpy (vector[i].iov_base, buf + (size - left), cp);
-		ret += cp;
-		left -= cp;
-		if (left)
-			i++;
-	}
-
-	return ret;
-}
-
-
-static inline size_t
-iov_copy (const struct iovec *dst, int dcnt,
-	  const struct iovec *src, int scnt)
-{
-	size_t  ret = 0;
-	size_t  left = 0;
-	size_t  min_i = 0;
-	int     s_i = 0, s_ii = 0;
-	int     d_i = 0, d_ii = 0;
-
-	ret = min (iov_length (dst, dcnt), iov_length (src, scnt));
-	left = ret;
-
-	while (left) {
-		min_i = min (dst[d_i].iov_len - d_ii, src[s_i].iov_len - s_ii);
-		memcpy (dst[d_i].iov_base + d_ii, src[s_i].iov_base + s_ii,
-			min_i);
-
-		d_ii += min_i;
-		if (d_ii == dst[d_i].iov_len) {
-			d_ii = 0;
-			d_i++;
-		}
-
-		s_ii += min_i;
-		if (s_ii == src[s_i].iov_len) {
-			s_ii = 0;
-			s_i++;
-		}
-
-		left -= min_i;
-	}
-
-	return ret;
-}
-
-
-static inline int
-mem_0filled (const char *buf, size_t size)
-{
-	int i = 0;
-	int ret = 0;
-
-	for (i = 0; i < size; i++) {
-		ret = buf[i];
-		if (ret)
-			break;
-	}
-
-	return ret;
-}
-
-
-static inline int
-iov_0filled (struct iovec *vector, int count)
-{
-	int i = 0;
-	int ret = 0;
-
-	for (i = 0; i < count; i++) {
-		ret = mem_0filled (vector[i].iov_base, vector[i].iov_len);
-		if (ret)
-			break;
-	}
-
-	return ret;
-}
-
-
-static inline void *
-memdup (const void *ptr, size_t size)
-{
-	void *newptr = NULL;
-
-	newptr = GF_MALLOC (size, gf_common_mt_memdup);
-	if (!newptr)
-		return NULL;
-
-	memcpy (newptr, ptr, size);
-	return newptr;
-}
-
-typedef enum {
-        gf_timefmt_default = 0,
-        gf_timefmt_FT = 0,  /* YYYY-MM-DD hh:mm:ss */
-        gf_timefmt_Ymd_T,   /* YYYY/MM-DD-hh:mm:ss */
-        gf_timefmt_bdT,     /* MMM DD hh:mm:ss */
-        gf_timefmt_F_HMS,   /* YYYY-MM-DD hhmmss */
-	gf_timefmt_dirent,
-        gf_timefmt_s,
-        gf_timefmt_last
-} gf_timefmts;
-
-static inline char *
-gf_time_fmt (char *dst, size_t sz_dst, time_t utime, unsigned int fmt)
-{
-        extern void _gf_timestuff (gf_timefmts *, const char ***, const char ***);
-        static gf_timefmts timefmt_last = (gf_timefmts) - 1;
-        static const char **fmts;
-        static const char **zeros;
-        struct tm tm, *res;
-        int localtime = 0;
-
-        if (timefmt_last == (gf_timefmts) - 1)
-                _gf_timestuff (&timefmt_last, &fmts, &zeros);
-        if (timefmt_last < fmt) fmt = gf_timefmt_default;
-        localtime = gf_log_get_localtime ();
-        res = localtime ? localtime_r (&utime, &tm) : gmtime_r (&utime, &tm);
-        if (utime && res != NULL) {
-                strftime (dst, sz_dst, fmts[fmt], &tm);
-        } else {
-                strncpy (dst, "N/A", sz_dst);
-        }
-        return dst;
-}
-
-/* This function helps us use gfid (unique identity) to generate inode's unique
- * number in glusterfs.
- */
-ino_t
-gfid_to_ino (uuid_t gfid);
-
-int
-mkdir_p (char *path, mode_t mode, gf_boolean_t allow_symlinks);
-/*
- * rounds up nr to power of two. If nr is already a power of two, just returns
- * nr
- */
-
-int
-gf_lstat_dir (const char *path, struct stat *stbuf_in);
-
-int32_t gf_roundup_power_of_two (int32_t nr);
-
-/*
- * rounds up nr to next power of two. If nr is already a power of two, next
- * power of two is returned.
- */
-
-int32_t gf_roundup_next_power_of_two (int32_t nr);
-
-char *gf_trim (char *string);
-int gf_strsplit (const char *str, const char *delim,
-		 char ***tokens, int *token_count);
-int gf_volume_name_validate (const char *volume_name);
-
-int gf_string2long (const char *str, long *n);
-int gf_string2ulong (const char *str, unsigned long *n);
-int gf_string2int (const char *str, int *n);
-int gf_string2uint (const char *str, unsigned int *n);
-int gf_string2double (const char *str, double *n);
-int gf_string2longlong (const char *str, long long *n);
-int gf_string2ulonglong (const char *str, unsigned long long *n);
-
-int gf_string2int8 (const char *str, int8_t *n);
-int gf_string2int16 (const char *str, int16_t *n);
-int gf_string2int32 (const char *str, int32_t *n);
-int gf_string2int64 (const char *str, int64_t *n);
-int gf_string2uint8 (const char *str, uint8_t *n);
-int gf_string2uint16 (const char *str, uint16_t *n);
-int gf_string2uint32 (const char *str, uint32_t *n);
-int gf_string2uint64 (const char *str, uint64_t *n);
-
-int gf_strstr (const char *str, const char *delim, const char *match);
-
-int gf_string2ulong_base10 (const char *str, unsigned long *n);
-int gf_string2uint_base10 (const char *str, unsigned int *n);
-int gf_string2uint8_base10 (const char *str, uint8_t *n);
-int gf_string2uint16_base10 (const char *str, uint16_t *n);
-int gf_string2uint32_base10 (const char *str, uint32_t *n);
-int gf_string2uint64_base10 (const char *str, uint64_t *n);
-int gf_string2bytesize (const char *str, uint64_t *n);
-int gf_string2bytesize_size (const char *str, size_t *n);
-int gf_string2bytesize_uint64 (const char *str, uint64_t *n);
-int gf_string2bytesize_int64 (const char *str, int64_t *n);
-int gf_string2percent_or_bytesize (const char *str, double *n,
-				   gf_boolean_t *is_percent);
-
-int gf_string2boolean (const char *str, gf_boolean_t *b);
-int gf_string2percent (const char *str, double *n);
-int gf_string2time (const char *str, uint32_t *n);
-
-int gf_lockfd (int fd);
-int gf_unlockfd (int fd);
-
-int get_checksum_for_file (int fd, uint32_t *checksum);
-int log_base2 (unsigned long x);
-
-int get_checksum_for_path (char *path, uint32_t *checksum);
-int get_file_mtime (const char *path, time_t *stamp);
-char *gf_resolve_path_parent (const char *path);
-
-char *strtail (char *str, const char *pattern);
-void skipwhite (char **s);
-char *nwstrtail (char *str, char *pattern);
-void skip_word (char **str);
-/* returns a new string with nth word of given string. n>=1 */
-char *get_nth_word (const char *str, int n);
-
-typedef struct token_iter {
-        char *end;
-        char sep;
-} token_iter_t;
-char *token_iter_init (char *str, char sep, token_iter_t *tit);
-gf_boolean_t next_token (char **tokenp, token_iter_t *tit);
-void drop_token (char *token, token_iter_t *tit);
-
-gf_boolean_t mask_match (const uint32_t a, const uint32_t b, const uint32_t m);
-gf_boolean_t gf_is_ip_in_net (const char *network, const char *ip_str);
-char valid_host_name (char *address, int length);
-char valid_ipv4_address (char *address, int length, gf_boolean_t wildcard_acc);
-char valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc);
-char valid_internet_address (char *address, gf_boolean_t wildcard_acc);
-gf_boolean_t valid_mount_auth_address (char *address);
-gf_boolean_t valid_ipv4_subnetwork (const char *address);
-gf_boolean_t gf_sock_union_equal_addr (union gf_sock_union *a,
-                                       union gf_sock_union *b);
-char *gf_rev_dns_lookup (const char *ip);
-
-char *uuid_utoa (uuid_t uuid);
-char *uuid_utoa_r (uuid_t uuid, char *dst);
-char *lkowner_utoa (gf_lkowner_t *lkowner);
-char *lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len);
-char *leaseid_utoa (const char *lease_id);
-gf_boolean_t is_valid_lease_id (const char *lease_id);
-
-void gf_array_insertionsort (void *a, int l, int r, size_t elem_size,
-                             gf_cmp cmp);
-int gf_is_str_int (const char *value);
-
-char *gf_uint64_2human_readable (uint64_t);
-int get_vol_type (int type, int dist_count, int brick_count);
-int validate_brick_name (char *brick);
-char *get_host_name (char *word, char **host);
-char *get_path_name (char *word, char **path);
-void gf_path_strip_trailing_slashes (char *path);
-uint64_t get_mem_size (void);
-int gf_strip_whitespace (char *str, int len);
-int gf_canonicalize_path (char *path);
-char *generate_glusterfs_ctx_id (void);
-char *gf_get_reserved_ports(void);
-int gf_process_reserved_ports (unsigned char *ports, uint32_t ceiling);
-gf_boolean_t
-gf_ports_reserved (char *blocked_port, unsigned char *ports, uint32_t ceiling);
-int gf_get_hostname_from_ip (char *client_ip, char **hostname);
-gf_boolean_t gf_is_local_addr (char *hostname);
-gf_boolean_t gf_is_same_address (char *host1, char *host2);
-void md5_wrapper(const unsigned char *data, size_t len, char *md5);
-void gf_xxh64_wrapper(const unsigned char *data, size_t len,
-                      unsigned long long seed, char *xxh64);
-int gf_set_timestamp  (const char *src, const char* dest);
-
-int gf_thread_create (pthread_t *thread, const pthread_attr_t *attr,
-                      void *(*start_routine)(void *), void *arg,
-                      const char *name);
-int gf_thread_create_detached (pthread_t *thread,
-                      void *(*start_routine)(void *), void *arg,
-                      const char *name);
-gf_boolean_t
-gf_is_pid_running (int pid);
-gf_boolean_t
-gf_is_service_running (char *pidfile, int *pid);
-gf_boolean_t
-gf_valid_pid (const char *pid, int length);
-int
-gf_skip_header_section (int fd, int header_len);
-
-struct iatt;
-struct _dict;
-
-gf_boolean_t
-dht_is_linkfile (struct iatt *buf, struct _dict *dict);
-
-int
-gf_check_log_format (const char *value);
-
-int
-gf_check_logger (const char *value);
-
-gf_boolean_t
-gf_compare_sockaddr (const struct sockaddr *addr1,
-                     const struct sockaddr *addr2);
-
-char *
-gf_backtrace_save (char *buf);
-
-void
-gf_backtrace_done (char *buf);
-
-gf_loglevel_t
-fop_log_level (glusterfs_fop_t fop, int op_errno);
-
-int32_t
-gf_build_absolute_path (char *current_path, char *relative_path, char **path);
-
-int
-recursive_rmdir (const char *delete_path);
-
-int
-gf_get_index_by_elem (char **array, char *elem);
-
-int
-glusterfs_is_local_pathinfo (char *pathinfo, gf_boolean_t *local);
-
-int
-gf_thread_cleanup_xint (pthread_t thread);
-
-ssize_t
-gf_nread (int fd, void *buf, size_t count);
-
-ssize_t
-gf_nwrite (int fd, const void *buf, size_t count);
-
-void _mask_cancellation (void);
-void _unmask_cancellation (void);
-
-gf_boolean_t
-gf_is_zero_filled_stat (struct iatt *buf);
-
-void
-gf_zero_fill_stat (struct iatt *buf);
-
-gf_boolean_t
-gf_is_valid_xattr_namespace (char *k);
-
-const char *
-gf_inode_type_to_str (ia_type_t type);
-
-int32_t
-gf_bits_count (uint64_t n);
-
-int32_t
-gf_bits_index (uint64_t n);
-
-const char*
-gf_fop_string (glusterfs_fop_t fop);
-
-int
-gf_fop_int (char *fop);
-
-char *
-get_ip_from_addrinfo (struct addrinfo *addr, char **ip);
-
-int
-close_fds_except (int *fdv, size_t count);
-
-int
-gf_getgrouplist (const char *user, gid_t group, gid_t **groups);
-
-int
-glusterfs_compute_sha256 (const unsigned char *content, size_t size,
-                          char *sha256_hash);
-char*
-get_struct_variable (int mem_num, gf_gsync_status_t *sts_val);
-
-#endif /* _COMMON_UTILS_H */
diff --git a/libglusterfs/src/compat-errno.c b/libglusterfs/src/compat-errno.c
index 3674596ad71..df57e243239 100644
--- a/libglusterfs/src/compat-errno.c
+++ b/libglusterfs/src/compat-errno.c
@@ -10,8 +10,7 @@
 
 #include <stdint.h>
 
-#include "compat-errno.h"
-
+#include "glusterfs/compat-errno.h"
 
 static int32_t gf_error_to_errno_array[1024];
 static int32_t gf_errno_to_error_array[1024];
@@ -20,912 +19,937 @@ static int32_t gf_compat_errno_init_done;
 
 #ifdef GF_SOLARIS_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-/*      ENOMSG  35      / * No message of desired type          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-/*      EIDRM   36      / * Identifier removed                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-
-/*      ECHRNG  37      / * Channel number out of range         */
-        gf_error_to_errno_array[GF_ERROR_CODE_CHRNG] = ECHRNG;
-        gf_errno_to_error_array[ECHRNG] = GF_ERROR_CODE_CHRNG;
-
-/*      EL2NSYNC 38     / * Level 2 not synchronized            */
-        gf_error_to_errno_array[GF_ERROR_CODE_L2NSYNC] = EL2NSYNC;
-        gf_errno_to_error_array[EL2NSYNC] = GF_ERROR_CODE_L2NSYNC;
-
-/*      EL3HLT  39      / * Level 3 halted                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_L3HLT] = EL3HLT;
-        gf_errno_to_error_array[EL3HLT] = GF_ERROR_CODE_L3HLT;
-
-/*      EL3RST  40      / * Level 3 reset                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_L3RST] = EL3RST;
-        gf_errno_to_error_array[EL3RST] = GF_ERROR_CODE_L3RST;
-
-/*      ELNRNG  41      / * Link number out of range            */
-        gf_error_to_errno_array[GF_ERROR_CODE_LNRNG] = ELNRNG;
-        gf_errno_to_error_array[ELNRNG] = GF_ERROR_CODE_LNRNG;
-
-/*      EUNATCH 42      / * Protocol driver not attached                */
-        gf_error_to_errno_array[GF_ERROR_CODE_UNATCH] = EUNATCH;
-        gf_errno_to_error_array[EUNATCH] = GF_ERROR_CODE_UNATCH;
-
-/*      ENOCSI  43      / * No CSI structure available          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOCSI] = ENOCSI;
-        gf_errno_to_error_array[ENOCSI] = GF_ERROR_CODE_NOCSI;
-
-/*      EL2HLT  44      / * Level 2 halted                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_L2HLT] = EL2HLT;
-        gf_errno_to_error_array[EL2HLT] = GF_ERROR_CODE_L2HLT;
-
-/*      EDEADLK 45      / * Deadlock condition.                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-/*      ENOLCK  46      / * No record locks available.          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-/*      ECANCELED 47    / * Operation canceled                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-/*      ENOTSUP 48      / * Operation not supported             */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSUPP] = ENOTSUP;
-        gf_errno_to_error_array[ENOTSUP] = GF_ERROR_CODE_NOTSUPP;
-
-/* Filesystem Quotas */
-/*      EDQUOT  49      / * Disc quota exceeded                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-/* Convergent Error Returns */
-/*      EBADE   50      / * invalid exchange                    */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADE] = EBADE;
-        gf_errno_to_error_array[EBADE] = GF_ERROR_CODE_BADE;
-/*      EBADR   51      / * invalid request descriptor          */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADR] = EBADR;
-        gf_errno_to_error_array[EBADR] = GF_ERROR_CODE_BADR;
-/*      EXFULL  52      / * exchange full                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_XFULL] = EXFULL;
-        gf_errno_to_error_array[EXFULL] = GF_ERROR_CODE_XFULL;
-/*      ENOANO  53      / * no anode                            */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOANO] = ENOANO;
-        gf_errno_to_error_array[ENOANO] = GF_ERROR_CODE_NOANO;
-/*      EBADRQC 54      / * invalid request code                        */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRQC] = EBADRQC;
-        gf_errno_to_error_array[EBADRQC] = GF_ERROR_CODE_BADRQC;
-/*      EBADSLT 55      / * invalid slot                                */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADSLT] = EBADSLT;
-        gf_errno_to_error_array[EBADSLT] = GF_ERROR_CODE_BADSLT;
-/*      EDEADLOCK 56    / * file locking deadlock error         */
-/* This is same as EDEADLK on linux */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLOCK;
-        gf_errno_to_error_array[EDEADLOCK] = GF_ERROR_CODE_DEADLK;
-
-/*      EBFONT  57      / * bad font file fmt                   */
-        gf_error_to_errno_array[GF_ERROR_CODE_BFONT] = EBFONT;
-        gf_errno_to_error_array[EBFONT] = GF_ERROR_CODE_BFONT;
-
-/* Interprocess Robust Locks */
-/*      EOWNERDEAD      58      / * process died with the lock */
-        gf_error_to_errno_array[GF_ERROR_CODE_OWNERDEAD] = EOWNERDEAD;
-        gf_errno_to_error_array[EOWNERDEAD] = GF_ERROR_CODE_OWNERDEAD;
-/*      ENOTRECOVERABLE 59      / * lock is not recoverable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTRECOVERABLE] = ENOTRECOVERABLE;
-        gf_errno_to_error_array[ENOTRECOVERABLE] = GF_ERROR_CODE_NOTRECOVERABLE;
-
-/* stream problems */
-/*      ENOSTR  60      / * Device not a stream                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
-        gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
-/*      ENODATA 61      / * no data (for no delay io)           */
-        gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
-        gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
-/*      ETIME   62      / * timer expired                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
-        gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
-/*      ENOSR   63      / * out of streams resources            */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
-        gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
-
-/*      ENONET  64      / * Machine is not on the network       */
-        gf_error_to_errno_array[GF_ERROR_CODE_NONET] = ENONET;
-        gf_errno_to_error_array[ENONET] = GF_ERROR_CODE_NONET;
-/*      ENOPKG  65      / * Package not installed               */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPKG] = ENOPKG;
-        gf_errno_to_error_array[ENOPKG] = GF_ERROR_CODE_NOPKG;
-/*      EREMOTE 66      / * The object is remote                        */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-/*      ENOLINK 67      / * the link has been severed           */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
-/*      EADV    68      / * advertise error                     */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADV] = EADV;
-        gf_errno_to_error_array[EADV] = GF_ERROR_CODE_ADV;
-/*      ESRMNT  69      / * srmount error                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_SRMNT] = ESRMNT;
-        gf_errno_to_error_array[ESRMNT] = GF_ERROR_CODE_SRMNT;
-
-/*      ECOMM   70      / * Communication error on send         */
-        gf_error_to_errno_array[GF_ERROR_CODE_COMM] = ECOMM;
-        gf_errno_to_error_array[ECOMM] = GF_ERROR_CODE_COMM;
-/*      EPROTO  71      / * Protocol error                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
-
-/* Interprocess Robust Locks */
-/*      ELOCKUNMAPPED   72      / * locked lock was unmapped */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOCKUNMAPPED] = ELOCKUNMAPPED;
-        gf_errno_to_error_array[ELOCKUNMAPPED] = GF_ERROR_CODE_LOCKUNMAPPED;
-
-/*      ENOTACTIVE 73   / * Facility is not active              */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTACTIVE] = ENOTACTIVE;
-        gf_errno_to_error_array[ENOTACTIVE] = GF_ERROR_CODE_NOTACTIVE;
-/*      EMULTIHOP 74    / * multihop attempted                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-/*      EBADMSG 77      / * trying to read unreadable message   */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
-/*      ENAMETOOLONG 78 / * path name is too long               */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-/*      EOVERFLOW 79    / * value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-/*      ENOTUNIQ 80     / * given log. name not unique          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTUNIQ] = ENOTUNIQ;
-        gf_errno_to_error_array[ENOTUNIQ] = GF_ERROR_CODE_NOTUNIQ;
-/*      EBADFD  81      / * f.d. invalid for this operation     */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADFD] = EBADFD;
-        gf_errno_to_error_array[EBADFD] = GF_ERROR_CODE_BADFD;
-/*      EREMCHG 82      / * Remote address changed              */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMCHG] = EREMCHG;
-        gf_errno_to_error_array[EREMCHG] = GF_ERROR_CODE_REMCHG;
-
-/* shared library problems */
-/*      ELIBACC 83      / * Can't access a needed shared lib.   */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBACC] = ELIBACC;
-        gf_errno_to_error_array[ELIBACC] = GF_ERROR_CODE_LIBACC;
-/*      ELIBBAD 84      / * Accessing a corrupted shared lib.   */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBBAD] = ELIBBAD;
-        gf_errno_to_error_array[ELIBBAD] = GF_ERROR_CODE_LIBBAD;
-/*      ELIBSCN 85      / * .lib section in a.out corrupted.    */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBSCN] = ELIBSCN;
-        gf_errno_to_error_array[ELIBSCN] = GF_ERROR_CODE_LIBSCN;
-/*      ELIBMAX 86      / * Attempting to link in too many libs.        */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBMAX] = ELIBMAX;
-        gf_errno_to_error_array[ELIBMAX] = GF_ERROR_CODE_LIBMAX;
-/*      ELIBEXEC 87     / * Attempting to exec a shared library.        */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBEXEC] = ELIBEXEC;
-        gf_errno_to_error_array[ELIBEXEC] = GF_ERROR_CODE_LIBEXEC;
-/*      EILSEQ  88      / * Illegal byte sequence.              */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-/*      ENOSYS  89      / * Unsupported file system operation   */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-/*      ELOOP   90      / * Symbolic link loop                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-/*      ERESTART 91     / * Restartable system call             */
-        gf_error_to_errno_array[GF_ERROR_CODE_RESTART] = ERESTART;
-        gf_errno_to_error_array[ERESTART] = GF_ERROR_CODE_RESTART;
-/*      ESTRPIPE 92     / * if pipe/FIFO, don't sleep in stream head */
-        gf_error_to_errno_array[GF_ERROR_CODE_STRPIPE] = ESTRPIPE;
-        gf_errno_to_error_array[ESTRPIPE] = GF_ERROR_CODE_STRPIPE;
-/*      ENOTEMPTY 93    / * directory not empty                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-/*      EUSERS  94      / * Too many users (for UFS)            */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-/* BSD Networking Software */
-        /* argument errors */
-/*      ENOTSOCK        95      / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-/*      EDESTADDRREQ    96      / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-/*      EMSGSIZE        97      / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-/*      EPROTOTYPE      98      / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-/*      ENOPROTOOPT     99      / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-/*      EPROTONOSUPPORT 120     / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-/*      ESOCKTNOSUPPORT 121     / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-/*      EOPNOTSUPP      122     / * Operation not supported on socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-/*      EPFNOSUPPORT    123     / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-/*      EAFNOSUPPORT    124     / * Address family not supported by */
-        /* protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
-/*      EADDRINUSE      125     / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
-/*      EADDRNOTAVAIL   126     / * Can't assign requested address */
-        /* operational errors */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
-/*      ENETDOWN        127     / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
-/*      ENETUNREACH     128     / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
-/*      ENETRESET       129     / * Network dropped connection because */
-        /* of reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
-/*      ECONNABORTED    130     / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
-/*      ECONNRESET      131     / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-/*      ENOBUFS         132     / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-/*      EISCONN         133     / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-/*      ENOTCONN        134     / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-/* XENIX has 135 - 142 */
-/*      ESHUTDOWN       143     / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-/*      ETOOMANYREFS    144     / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-/*      ETIMEDOUT       145     / * Connection timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-/*      ECONNREFUSED    146     / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-/*      EHOSTDOWN       147     / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-/*      EHOSTUNREACH    148     / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-/*      EALREADY        149     / * operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-/*      EINPROGRESS     150     / * operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-/* SUN Network File System */
-/*      ESTALE          151     / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        return ;
+    /*      ENOMSG  35      / * No message of desired type          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
+
+    /*      EIDRM   36      / * Identifier removed                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
+
+    /*      ECHRNG  37      / * Channel number out of range         */
+    gf_error_to_errno_array[GF_ERROR_CODE_CHRNG] = ECHRNG;
+    gf_errno_to_error_array[ECHRNG] = GF_ERROR_CODE_CHRNG;
+
+    /*      EL2NSYNC 38     / * Level 2 not synchronized            */
+    gf_error_to_errno_array[GF_ERROR_CODE_L2NSYNC] = EL2NSYNC;
+    gf_errno_to_error_array[EL2NSYNC] = GF_ERROR_CODE_L2NSYNC;
+
+    /*      EL3HLT  39      / * Level 3 halted                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_L3HLT] = EL3HLT;
+    gf_errno_to_error_array[EL3HLT] = GF_ERROR_CODE_L3HLT;
+
+    /*      EL3RST  40      / * Level 3 reset                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_L3RST] = EL3RST;
+    gf_errno_to_error_array[EL3RST] = GF_ERROR_CODE_L3RST;
+
+    /*      ELNRNG  41      / * Link number out of range            */
+    gf_error_to_errno_array[GF_ERROR_CODE_LNRNG] = ELNRNG;
+    gf_errno_to_error_array[ELNRNG] = GF_ERROR_CODE_LNRNG;
+
+    /*      EUNATCH 42      / * Protocol driver not attached                */
+    gf_error_to_errno_array[GF_ERROR_CODE_UNATCH] = EUNATCH;
+    gf_errno_to_error_array[EUNATCH] = GF_ERROR_CODE_UNATCH;
+
+    /*      ENOCSI  43      / * No CSI structure available          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOCSI] = ENOCSI;
+    gf_errno_to_error_array[ENOCSI] = GF_ERROR_CODE_NOCSI;
+
+    /*      EL2HLT  44      / * Level 2 halted                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_L2HLT] = EL2HLT;
+    gf_errno_to_error_array[EL2HLT] = GF_ERROR_CODE_L2HLT;
+
+    /*      EDEADLK 45      / * Deadlock condition.                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*      ENOLCK  46      / * No record locks available.          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
+
+    /*      ECANCELED 47    / * Operation canceled                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
+
+    /*      ENOTSUP 48      / * Operation not supported             */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSUPP] = ENOTSUP;
+    gf_errno_to_error_array[ENOTSUP] = GF_ERROR_CODE_NOTSUPP;
+
+    /* Filesystem Quotas */
+    /*      EDQUOT  49      / * Disc quota exceeded                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /* Convergent Error Returns */
+    /*      EBADE   50      / * invalid exchange                    */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADE] = EBADE;
+    gf_errno_to_error_array[EBADE] = GF_ERROR_CODE_BADE;
+    /*      EBADR   51      / * invalid request descriptor          */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADR] = EBADR;
+    gf_errno_to_error_array[EBADR] = GF_ERROR_CODE_BADR;
+    /*      EXFULL  52      / * exchange full                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_XFULL] = EXFULL;
+    gf_errno_to_error_array[EXFULL] = GF_ERROR_CODE_XFULL;
+    /*      ENOANO  53      / * no anode                            */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOANO] = ENOANO;
+    gf_errno_to_error_array[ENOANO] = GF_ERROR_CODE_NOANO;
+    /*      EBADRQC 54      / * invalid request code                        */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRQC] = EBADRQC;
+    gf_errno_to_error_array[EBADRQC] = GF_ERROR_CODE_BADRQC;
+    /*      EBADSLT 55      / * invalid slot                                */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADSLT] = EBADSLT;
+    gf_errno_to_error_array[EBADSLT] = GF_ERROR_CODE_BADSLT;
+    /*      EDEADLOCK 56    / * file locking deadlock error         */
+    /* This is same as EDEADLK on linux */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLOCK;
+    gf_errno_to_error_array[EDEADLOCK] = GF_ERROR_CODE_DEADLK;
+
+    /*      EBFONT  57      / * bad font file fmt                   */
+    gf_error_to_errno_array[GF_ERROR_CODE_BFONT] = EBFONT;
+    gf_errno_to_error_array[EBFONT] = GF_ERROR_CODE_BFONT;
+
+    /* Interprocess Robust Locks */
+    /*      EOWNERDEAD      58      / * process died with the lock */
+    gf_error_to_errno_array[GF_ERROR_CODE_OWNERDEAD] = EOWNERDEAD;
+    gf_errno_to_error_array[EOWNERDEAD] = GF_ERROR_CODE_OWNERDEAD;
+    /*      ENOTRECOVERABLE 59      / * lock is not recoverable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTRECOVERABLE] = ENOTRECOVERABLE;
+    gf_errno_to_error_array[ENOTRECOVERABLE] = GF_ERROR_CODE_NOTRECOVERABLE;
+
+    /* stream problems */
+    /*      ENOSTR  60      / * Device not a stream                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
+    gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
+    /*      ENODATA 61      / * no data (for no delay io)           */
+    gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
+    gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
+    /*      ETIME   62      / * timer expired                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
+    gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
+    /*      ENOSR   63      / * out of streams resources            */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
+    gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
+
+    /*      ENONET  64      / * Machine is not on the network       */
+    gf_error_to_errno_array[GF_ERROR_CODE_NONET] = ENONET;
+    gf_errno_to_error_array[ENONET] = GF_ERROR_CODE_NONET;
+    /*      ENOPKG  65      / * Package not installed               */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPKG] = ENOPKG;
+    gf_errno_to_error_array[ENOPKG] = GF_ERROR_CODE_NOPKG;
+    /*      EREMOTE 66      / * The object is remote                        */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+    /*      ENOLINK 67      / * the link has been severed           */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+    /*      EADV    68      / * advertise error                     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADV] = EADV;
+    gf_errno_to_error_array[EADV] = GF_ERROR_CODE_ADV;
+    /*      ESRMNT  69      / * srmount error                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_SRMNT] = ESRMNT;
+    gf_errno_to_error_array[ESRMNT] = GF_ERROR_CODE_SRMNT;
+
+    /*      ECOMM   70      / * Communication error on send         */
+    gf_error_to_errno_array[GF_ERROR_CODE_COMM] = ECOMM;
+    gf_errno_to_error_array[ECOMM] = GF_ERROR_CODE_COMM;
+    /*      EPROTO  71      / * Protocol error                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+
+    /* Interprocess Robust Locks */
+    /*      ELOCKUNMAPPED   72      / * locked lock was unmapped */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOCKUNMAPPED] = ELOCKUNMAPPED;
+    gf_errno_to_error_array[ELOCKUNMAPPED] = GF_ERROR_CODE_LOCKUNMAPPED;
+
+    /*      ENOTACTIVE 73   / * Facility is not active              */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTACTIVE] = ENOTACTIVE;
+    gf_errno_to_error_array[ENOTACTIVE] = GF_ERROR_CODE_NOTACTIVE;
+    /*      EMULTIHOP 74    / * multihop attempted                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
+    /*      EBADMSG 77      / * trying to read unreadable message   */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+    /*      ENAMETOOLONG 78 / * path name is too long               */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+    /*      EOVERFLOW 79    / * value too large to be stored in data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
+    /*      ENOTUNIQ 80     / * given log. name not unique          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTUNIQ] = ENOTUNIQ;
+    gf_errno_to_error_array[ENOTUNIQ] = GF_ERROR_CODE_NOTUNIQ;
+    /*      EBADFD  81      / * f.d. invalid for this operation     */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADFD] = EBADFD;
+    gf_errno_to_error_array[EBADFD] = GF_ERROR_CODE_BADFD;
+    /*      EREMCHG 82      / * Remote address changed              */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMCHG] = EREMCHG;
+    gf_errno_to_error_array[EREMCHG] = GF_ERROR_CODE_REMCHG;
+
+    /* shared library problems */
+    /*      ELIBACC 83      / * Can't access a needed shared lib.   */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBACC] = ELIBACC;
+    gf_errno_to_error_array[ELIBACC] = GF_ERROR_CODE_LIBACC;
+    /*      ELIBBAD 84      / * Accessing a corrupted shared lib.   */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBBAD] = ELIBBAD;
+    gf_errno_to_error_array[ELIBBAD] = GF_ERROR_CODE_LIBBAD;
+    /*      ELIBSCN 85      / * .lib section in a.out corrupted.    */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBSCN] = ELIBSCN;
+    gf_errno_to_error_array[ELIBSCN] = GF_ERROR_CODE_LIBSCN;
+    /*      ELIBMAX 86      / * Attempting to link in too many libs.        */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBMAX] = ELIBMAX;
+    gf_errno_to_error_array[ELIBMAX] = GF_ERROR_CODE_LIBMAX;
+    /*      ELIBEXEC 87     / * Attempting to exec a shared library.        */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBEXEC] = ELIBEXEC;
+    gf_errno_to_error_array[ELIBEXEC] = GF_ERROR_CODE_LIBEXEC;
+    /*      EILSEQ  88      / * Illegal byte sequence.              */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
+    /*      ENOSYS  89      / * Unsupported file system operation   */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
+    /*      ELOOP   90      / * Symbolic link loop                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+    /*      ERESTART 91     / * Restartable system call             */
+    gf_error_to_errno_array[GF_ERROR_CODE_RESTART] = ERESTART;
+    gf_errno_to_error_array[ERESTART] = GF_ERROR_CODE_RESTART;
+    /*      ESTRPIPE 92     / * if pipe/FIFO, don't sleep in stream head */
+    gf_error_to_errno_array[GF_ERROR_CODE_STRPIPE] = ESTRPIPE;
+    gf_errno_to_error_array[ESTRPIPE] = GF_ERROR_CODE_STRPIPE;
+    /*      ENOTEMPTY 93    / * directory not empty                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+    /*      EUSERS  94      / * Too many users (for UFS)            */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /* BSD Networking Software */
+    /* argument errors */
+    /*      ENOTSOCK        95      / * Socket operation on non-socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+    /*      EDESTADDRREQ    96      / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+    /*      EMSGSIZE        97      / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+    /*      EPROTOTYPE      98      / * Protocol wrong type for socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+    /*      ENOPROTOOPT     99      / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+    /*      EPROTONOSUPPORT 120     / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+    /*      ESOCKTNOSUPPORT 121     / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      122     / * Operation not supported on socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+    /*      EPFNOSUPPORT    123     / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+    /*      EAFNOSUPPORT    124     / * Address family not supported by */
+    /* protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+    /*      EADDRINUSE      125     / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+    /*      EADDRNOTAVAIL   126     / * Can't assign requested address */
+    /* operational errors */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+    /*      ENETDOWN        127     / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+    /*      ENETUNREACH     128     / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+    /*      ENETRESET       129     / * Network dropped connection because */
+    /* of reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+    /*      ECONNABORTED    130     / * Software caused connection abort */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+    /*      ECONNRESET      131     / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+    /*      ENOBUFS         132     / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+    /*      EISCONN         133     / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+    /*      ENOTCONN        134     / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+    /* XENIX has 135 - 142 */
+    /*      ESHUTDOWN       143     / * Can't send after socket shutdown */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+    /*      ETOOMANYREFS    144     / * Too many references: can't splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+    /*      ETIMEDOUT       145     / * Connection timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    146     / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+    /*      EHOSTDOWN       147     / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+    /*      EHOSTUNREACH    148     / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+    /*      EALREADY        149     / * operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+    /*      EINPROGRESS     150     / * operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /* SUN Network File System */
+    /*      ESTALE          151     / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    return;
 }
 #endif /* GF_SOLARIS_HOST_OS */
 
 #ifdef GF_DARWIN_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /*    EDEADLK         11              / * Resource deadlock would occur */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-        /*    EAGAIN          35              / * Try Again */
-        gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
-        gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
-
-        /*      EINPROGRESS     36              / * Operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-        /*      EALREADY        37              / * Operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-
-        /*      ENOTSOCK        38              / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-
-        /*      EDESTADDRREQ    39              / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-
-        /*      EMSGSIZE        40              / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-
-        /*      EPROTOTYPE      41              / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-
-        /*      ENOPROTOOPT     42              / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-
-        /*      EPROTONOSUPPORT 43              / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-
-        /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-        /*      EOPNOTSUPP      45              / * Operation not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-        /*      EPFNOSUPPORT    46              / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-
-        /*      EAFNOSUPPORT    47              / * Address family not supported by protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
-
-        /*      EADDRINUSE      48              / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
-
-        /*      EADDRNOTAVAIL   49              / * Can't assign requested address */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
-
-        /*      ENETDOWN        50              / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
-
-        /*      ENETUNREACH     51              / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
-
-        /*      ENETRESET       52              / * Network dropped connection on reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
-
-        /*      ECONNABORTED    53              / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
-
-        /*      ECONNRESET      54              / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-
-        /*      ENOBUFS         55              / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-
-        /*      EISCONN         56              / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-
-        /*      ENOTCONN        57              / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-
-        /*      ESHUTDOWN       58              / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-
-        /*      ETOOMANYREFS    59              / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-
-        /*      ETIMEDOUT       60              / * Operation timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-        /*      ECONNREFUSED    61              / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-
-        /*      ELOOP           62              / * Too many levels of symbolic links */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-
-        /*      ENAMETOOLONG    63              / * File name too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-
-        /*      EHOSTDOWN       64              / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-
-        /*      EHOSTUNREACH    65              / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-
-        /*      ENOTEMPTY       66              / * Directory not empty */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-
-        /*      EPROCLIM        67              / * Too many processes */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
-        gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
-
-        /*      EUSERS          68              / * Too many users */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-        /*      EDQUOT          69              / * Disc quota exceeded */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-        /*      ESTALE          70              / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        /*      EREMOTE         71              / * Too many levels of remote in path */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-
-        /*      EBADRPC         72              / * RPC struct is bad */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
-        gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
-
-        /*      ERPCMISMATCH    73              / * RPC version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
-        gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
-
-        /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
-        gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
-
-        /*      EPROGMISMATCH   75              / * Program version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
-        gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
-
-        /*      EPROCUNAVAIL    76              / * Bad procedure for program */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
-        gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
-
-        /*      ENOLCK          77              / * No locks available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-        /*      ENOSYS          78              / * Function not implemented */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-
-        /*      EFTYPE          79              / * Inappropriate file type or format */
-        gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
-        gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
-
-        /*      EAUTH           80              / * Authentication error */
-        gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
-        gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
-
-        /*      ENEEDAUTH       81              / * Need authenticator */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-/* Intelligent device errors */
-/*      EPWROFF         82      / * Device power is off */
-        gf_error_to_errno_array[GF_ERROR_CODE_PWROFF] = EPWROFF;
-        gf_errno_to_error_array[EPWROFF] = GF_ERROR_CODE_PWROFF;
-/*      EDEVERR         83      / * Device error, e.g. paper out */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEVERR] = EDEVERR;
-        gf_errno_to_error_array[EDEVERR] = GF_ERROR_CODE_DEVERR;
-
-        /*      EOVERFLOW       84              / * Value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-
-/* Program loading errors */
-/*   EBADEXEC   85      / * Bad executable */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADEXEC] = EBADEXEC;
-        gf_errno_to_error_array[EBADEXEC] = GF_ERROR_CODE_BADEXEC;
-
-/*   EBADARCH   86      / * Bad CPU type in executable */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADARCH] = EBADARCH;
-        gf_errno_to_error_array[EBADARCH] = GF_ERROR_CODE_BADARCH;
-
-/*   ESHLIBVERS 87      / * Shared library version mismatch */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHLIBVERS] = ESHLIBVERS;
-        gf_errno_to_error_array[ESHLIBVERS] = GF_ERROR_CODE_SHLIBVERS;
-
-/*   EBADMACHO  88      / * Malformed Macho file */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMACHO] = EBADMACHO;
-        gf_errno_to_error_array[EBADMACHO] = GF_ERROR_CODE_BADMACHO;
+    /*    EDEADLK         11              / * Resource deadlock would occur */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*    EAGAIN          35              / * Try Again */
+    gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
+    gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
+
+    /*      EINPROGRESS     36              / * Operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /*      EALREADY        37              / * Operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+
+    /*      ENOTSOCK        38              / * Socket operation on non-socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+
+    /*      EDESTADDRREQ    39              / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+
+    /*      EMSGSIZE        40              / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+
+    /*      EPROTOTYPE      41              / * Protocol wrong type for socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+
+    /*      ENOPROTOOPT     42              / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+
+    /*      EPROTONOSUPPORT 43              / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+
+    /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      45              / * Operation not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*      EPFNOSUPPORT    46              / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+
+    /*      EAFNOSUPPORT    47              / * Address family not supported by
+     * protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+
+    /*      EADDRINUSE      48              / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+
+    /*      EADDRNOTAVAIL   49              / * Can't assign requested address
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+
+    /*      ENETDOWN        50              / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+
+    /*      ENETUNREACH     51              / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+
+    /*      ENETRESET       52              / * Network dropped connection on
+     * reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+
+    /*      ECONNABORTED    53              / * Software caused connection abort
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+
+    /*      ECONNRESET      54              / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+
+    /*      ENOBUFS         55              / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+
+    /*      EISCONN         56              / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+
+    /*      ENOTCONN        57              / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+
+    /*      ESHUTDOWN       58              / * Can't send after socket shutdown
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+
+    /*      ETOOMANYREFS    59              / * Too many references: can't
+     * splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+
+    /*      ETIMEDOUT       60              / * Operation timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    61              / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+
+    /*      ELOOP           62              / * Too many levels of symbolic
+     * links */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+
+    /*      ENAMETOOLONG    63              / * File name too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+
+    /*      EHOSTDOWN       64              / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+
+    /*      EHOSTUNREACH    65              / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+
+    /*      ENOTEMPTY       66              / * Directory not empty */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+
+    /*      EPROCLIM        67              / * Too many processes */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
+    gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
+
+    /*      EUSERS          68              / * Too many users */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /*      EDQUOT          69              / * Disc quota exceeded */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /*      ESTALE          70              / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    /*      EREMOTE         71              / * Too many levels of remote in
+     * path */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+
+    /*      EBADRPC         72              / * RPC struct is bad */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
+    gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
+
+    /*      ERPCMISMATCH    73              / * RPC version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
+    gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
+
+    /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
+    gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
+
+    /*      EPROGMISMATCH   75              / * Program version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
+    gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
+
+    /*      EPROCUNAVAIL    76              / * Bad procedure for program */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
+    gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
+
+    /*      ENOLCK          77              / * No locks available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
+
+    /*      ENOSYS          78              / * Function not implemented */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
+
+    /*      EFTYPE          79              / * Inappropriate file type or
+     * format */
+    gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
+    gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
+
+    /*      EAUTH           80              / * Authentication error */
+    gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
+    gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
+
+    /*      ENEEDAUTH       81              / * Need authenticator */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+    /* Intelligent device errors */
+    /*      EPWROFF         82      / * Device power is off */
+    gf_error_to_errno_array[GF_ERROR_CODE_PWROFF] = EPWROFF;
+    gf_errno_to_error_array[EPWROFF] = GF_ERROR_CODE_PWROFF;
+    /*      EDEVERR         83      / * Device error, e.g. paper out */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEVERR] = EDEVERR;
+    gf_errno_to_error_array[EDEVERR] = GF_ERROR_CODE_DEVERR;
+
+    /*      EOVERFLOW       84              / * Value too large to be stored in
+     * data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
+
+    /* Program loading errors */
+    /*   EBADEXEC   85      / * Bad executable */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADEXEC] = EBADEXEC;
+    gf_errno_to_error_array[EBADEXEC] = GF_ERROR_CODE_BADEXEC;
+
+    /*   EBADARCH   86      / * Bad CPU type in executable */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADARCH] = EBADARCH;
+    gf_errno_to_error_array[EBADARCH] = GF_ERROR_CODE_BADARCH;
+
+    /*   ESHLIBVERS 87      / * Shared library version mismatch */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHLIBVERS] = ESHLIBVERS;
+    gf_errno_to_error_array[ESHLIBVERS] = GF_ERROR_CODE_SHLIBVERS;
+
+    /*   EBADMACHO  88      / * Malformed Macho file */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMACHO] = EBADMACHO;
+    gf_errno_to_error_array[EBADMACHO] = GF_ERROR_CODE_BADMACHO;
 
 #ifdef EDOOFUS
-        /*    EDOOFUS           88              / * Programming error */
-        gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
-        gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
+    /*    EDOOFUS           88              / * Programming error */
+    gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
+    gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
 #endif
 
-        /*      ECANCELED       89              / * Operation canceled */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-        /*   EIDRM              90              / * Identifier removed */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-        /*   ENOMSG             91              / * No message of desired type */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-        /*   EILSEQ             92              / * Illegal byte sequence */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-
-        /*   ENOATTR            93              / * Attribute not found */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
-        gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
-
-        /*   EBADMSG            94              / * Bad message */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
-
-        /*   EMULTIHOP  95              / * Reserved */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-
-        /*      ENODATA         96              / * No message available on STREAM */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-
-        /*   ENOLINK            97              / * Reserved */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
-
-        /*   ENOSR              98              / * No STREAM resources */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
-        gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
-
-        /*   ENOSTR             99              / * Not a STREAM */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
-        gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
-
-/*      EPROTO          100             / * Protocol error */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
-/*   ETIME              101             / * STREAM ioctl timeout */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
-        gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
-
-/* This value is only discrete when compiling __DARWIN_UNIX03, or KERNEL */
-/*      EOPNOTSUPP      102             / * Operation not supported on socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-/*   ENOPOLICY  103             / * No such policy registered */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPOLICY] = ENOPOLICY;
-        gf_errno_to_error_array[ENOPOLICY] = GF_ERROR_CODE_NOPOLICY;
-
-        return ;
+    /*      ECANCELED       89              / * Operation canceled */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
+
+    /*   EIDRM              90              / * Identifier removed */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
+    /*   ENOMSG             91              / * No message of desired type */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
+
+    /*   EILSEQ             92              / * Illegal byte sequence */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
+
+    /*   ENOATTR            93              / * Attribute not found */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
+    gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
+
+    /*   EBADMSG            94              / * Bad message */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+
+    /*   EMULTIHOP  95              / * Reserved */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
+
+    /*      ENODATA         96              / * No message available on STREAM
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+
+    /*   ENOLINK            97              / * Reserved */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+
+    /*   ENOSR              98              / * No STREAM resources */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
+    gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
+
+    /*   ENOSTR             99              / * Not a STREAM */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
+    gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
+
+    /*      EPROTO          100             / * Protocol error */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+    /*   ETIME              101             / * STREAM ioctl timeout */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
+    gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
+
+    /* This value is only discrete when compiling __DARWIN_UNIX03, or KERNEL */
+    /*      EOPNOTSUPP      102             / * Operation not supported on
+     * socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*   ENOPOLICY  103             / * No such policy registered */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPOLICY] = ENOPOLICY;
+    gf_errno_to_error_array[ENOPOLICY] = GF_ERROR_CODE_NOPOLICY;
+
+    return;
 }
 #endif /* GF_DARWIN_HOST_OS */
 
 #ifdef GF_BSD_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /* Quite a bit of things changed in FreeBSD - current */
-
-        /*    EAGAIN          35              / * Try Again */
-        gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
-        gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
-
-        /*    EDEADLK         11              / * Resource deadlock would occur */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-        /*      EINPROGRESS     36              / * Operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-        /*      EALREADY        37              / * Operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-
-        /*      ENOTSOCK        38              / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-
-        /*      EDESTADDRREQ    39              / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-
-        /*      EMSGSIZE        40              / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-
-        /*      EPROTOTYPE      41              / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-
-        /*      ENOPROTOOPT     42              / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-
-        /*      EPROTONOSUPPORT 43              / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-
-        /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-        /*      EOPNOTSUPP      45              / * Operation not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-        /*      EPFNOSUPPORT    46              / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-
-        /*      EAFNOSUPPORT    47              / * Address family not supported by protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+    /* Quite a bit of things changed in FreeBSD - current */
+
+    /*    EAGAIN          35              / * Try Again */
+    gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
+    gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
+
+    /*    EDEADLK         11              / * Resource deadlock would occur */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*      EINPROGRESS     36              / * Operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /*      EALREADY        37              / * Operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+
+    /*      ENOTSOCK        38              / * Socket operation on non-socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+
+    /*      EDESTADDRREQ    39              / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+
+    /*      EMSGSIZE        40              / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+
+    /*      EPROTOTYPE      41              / * Protocol wrong type for socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+
+    /*      ENOPROTOOPT     42              / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+
+    /*      EPROTONOSUPPORT 43              / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+
+    /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      45              / * Operation not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*      EPFNOSUPPORT    46              / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+
+    /*      EAFNOSUPPORT    47              / * Address family not supported by
+     * protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+
+    /*      EADDRINUSE      48              / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+
+    /*      EADDRNOTAVAIL   49              / * Can't assign requested address
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+
+    /*      ENETDOWN        50              / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+
+    /*      ENETUNREACH     51              / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+
+    /*      ENETRESET       52              / * Network dropped connection on
+     * reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+
+    /*      ECONNABORTED    53              / * Software caused connection abort
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+
+    /*      ECONNRESET      54              / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+
+    /*      ENOBUFS         55              / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+
+    /*      EISCONN         56              / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+
+    /*      ENOTCONN        57              / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+
+    /*      ESHUTDOWN       58              / * Can't send after socket shutdown
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+
+    /*      ETOOMANYREFS    59              / * Too many references: can't
+     * splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+
+    /*      ETIMEDOUT       60              / * Operation timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    61              / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+
+    /*      ELOOP           62              / * Too many levels of symbolic
+     * links */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+
+    /*      ENAMETOOLONG    63              / * File name too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+
+    /*      EHOSTDOWN       64              / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+
+    /*      EHOSTUNREACH    65              / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+
+    /*      ENOTEMPTY       66              / * Directory not empty */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+
+    /*      EPROCLIM        67              / * Too many processes */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
+    gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
+
+    /*      EUSERS          68              / * Too many users */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /*      EDQUOT          69              / * Disc quota exceeded */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /*      ESTALE          70              / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    /*      EREMOTE         71              / * Too many levels of remote in
+     * path */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+
+    /*      EBADRPC         72              / * RPC struct is bad */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
+    gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
+
+    /*      ERPCMISMATCH    73              / * RPC version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
+    gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
+
+    /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
+    gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
+
+    /*      EPROGMISMATCH   75              / * Program version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
+    gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
+
+    /*      EPROCUNAVAIL    76              / * Bad procedure for program */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
+    gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
+
+    /*      ENOLCK          77              / * No locks available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
 
-        /*      EADDRINUSE      48              / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+    /*      ENOSYS          78              / * Function not implemented */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
 
-        /*      EADDRNOTAVAIL   49              / * Can't assign requested address */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+    /*      EFTYPE          79              / * Inappropriate file type or
+     * format */
+    gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
+    gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
+
+    /*      EAUTH           80              / * Authentication error */
+    gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
+    gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
+
+    /*      ENEEDAUTH       81              / * Need authenticator */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+
+    /*      EIDRM           82              / * Identifier removed */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
 
-        /*      ENETDOWN        50              / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+    /*      ENOMSG          83              / * No message of desired type */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
 
-        /*      ENETUNREACH     51              / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+    /*      EOVERFLOW       84              / * Value too large to be stored in
+     * data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
 
-        /*      ENETRESET       52              / * Network dropped connection on reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+    /*      ECANCELED       85              / * Operation canceled */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
 
-        /*      ECONNABORTED    53              / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+    /*      EILSEQ          86              / * Illegal byte sequence */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
 
-        /*      ECONNRESET      54              / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-
-        /*      ENOBUFS         55              / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-
-        /*      EISCONN         56              / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-
-        /*      ENOTCONN        57              / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-
-        /*      ESHUTDOWN       58              / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-
-        /*      ETOOMANYREFS    59              / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-
-        /*      ETIMEDOUT       60              / * Operation timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-        /*      ECONNREFUSED    61              / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-
-        /*      ELOOP           62              / * Too many levels of symbolic links */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-
-        /*      ENAMETOOLONG    63              / * File name too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-
-        /*      EHOSTDOWN       64              / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-
-        /*      EHOSTUNREACH    65              / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-
-        /*      ENOTEMPTY       66              / * Directory not empty */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-
-        /*      EPROCLIM        67              / * Too many processes */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
-        gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
-
-        /*      EUSERS          68              / * Too many users */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-        /*      EDQUOT          69              / * Disc quota exceeded */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-        /*      ESTALE          70              / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        /*      EREMOTE         71              / * Too many levels of remote in path */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-
-        /*      EBADRPC         72              / * RPC struct is bad */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
-        gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
-
-        /*      ERPCMISMATCH    73              / * RPC version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
-        gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
-
-        /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
-        gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
-
-        /*      EPROGMISMATCH   75              / * Program version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
-        gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
-
-        /*      EPROCUNAVAIL    76              / * Bad procedure for program */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
-        gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
-
-        /*      ENOLCK          77              / * No locks available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-        /*      ENOSYS          78              / * Function not implemented */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-
-        /*      EFTYPE          79              / * Inappropriate file type or format */
-        gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
-        gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
-
-        /*      EAUTH           80              / * Authentication error */
-        gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
-        gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
-
-        /*      ENEEDAUTH       81              / * Need authenticator */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-
-        /*      EIDRM           82              / * Identifier removed */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-
-        /*      ENOMSG          83              / * No message of desired type */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-        /*      EOVERFLOW       84              / * Value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-
-        /*      ECANCELED       85              / * Operation canceled */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-        /*      EILSEQ          86              / * Illegal byte sequence */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-
-        /*      ENOATTR         87              / * Attribute not found */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
-        gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
+    /*      ENOATTR         87              / * Attribute not found */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
+    gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
 
 #ifdef EDOOFUS
-        /*    EDOOFUS           88              / * Programming error */
-        gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
-        gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
+    /*    EDOOFUS           88              / * Programming error */
+    gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
+    gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
 #endif
 
-        /*      EBADMSG         89              / * Bad message */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+    /*      EBADMSG         89              / * Bad message */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
 
 #ifdef __NetBSD__
-        /*      ENODATA         89              / * No message available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
-        gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
+    /*      ENODATA         89              / * No message available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
+    gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
 #endif
 
-        /*      EMULTIHOP       90              / * Multihop attempted */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-
-        /*      ENOLINK         91              / * Link has been severed */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+    /*      EMULTIHOP       90              / * Multihop attempted */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
 
-        /*      EPROTO          92              / * Protocol error */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+    /*      ENOLINK         91              / * Link has been severed */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
 
+    /*      EPROTO          92              / * Protocol error */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
 
-        return ;
+    return;
 }
 #endif /* GF_BSD_HOST_OS */
 
 #ifdef GF_LINUX_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /* Things are fine. Everything should work seemlessly on GNU/Linux machines */
-        return ;
+    /* Things are fine. Everything should work seemlessly on GNU/Linux machines
+     */
+    return;
 }
 #endif /* GF_LINUX_HOST_OS */
 
-
 static void
-init_errno_arrays ()
+init_errno_arrays()
 {
-        int i;
-        for (i=0; i < GF_ERROR_CODE_UNKNOWN; i++) {
-                gf_errno_to_error_array[i] = i;
-                gf_error_to_errno_array[i] = i;
-        }
-        /* Now change the order if it needs to be. */
-        init_compat_errno_arrays();
-
-        return;
+    int i;
+    for (i = 0; i < GF_ERROR_CODE_UNKNOWN; i++) {
+        gf_errno_to_error_array[i] = i;
+        gf_error_to_errno_array[i] = i;
+    }
+    /* Now change the order if it needs to be. */
+    init_compat_errno_arrays();
+
+    return;
 }
 
 int32_t
-gf_errno_to_error (int32_t op_errno)
+gf_errno_to_error(int32_t op_errno)
 {
-        if (!gf_compat_errno_init_done) {
-                init_errno_arrays ();
-                gf_compat_errno_init_done = 1;
-        }
+    if (!gf_compat_errno_init_done) {
+        init_errno_arrays();
+        gf_compat_errno_init_done = 1;
+    }
 
-        if ((op_errno > GF_ERROR_CODE_SUCCESS) && (op_errno < GF_ERROR_CODE_UNKNOWN))
-                return gf_errno_to_error_array[op_errno];
+    if ((op_errno > GF_ERROR_CODE_SUCCESS) &&
+        (op_errno < GF_ERROR_CODE_UNKNOWN))
+        return gf_errno_to_error_array[op_errno];
 
-        return op_errno;
+    return op_errno;
 }
 
-
 int32_t
-gf_error_to_errno (int32_t error)
+gf_error_to_errno(int32_t error)
 {
-        if (!gf_compat_errno_init_done) {
-                init_errno_arrays ();
-                gf_compat_errno_init_done = 1;
-        }
+    if (!gf_compat_errno_init_done) {
+        init_errno_arrays();
+        gf_compat_errno_init_done = 1;
+    }
 
-        if ((error > GF_ERROR_CODE_SUCCESS) && (error < GF_ERROR_CODE_UNKNOWN))
-                return gf_error_to_errno_array[error];
+    if ((error > GF_ERROR_CODE_SUCCESS) && (error < GF_ERROR_CODE_UNKNOWN))
+        return gf_error_to_errno_array[error];
 
-        return error;
+    return error;
 }
diff --git a/libglusterfs/src/compat-errno.h b/libglusterfs/src/compat-errno.h
deleted file mode 100644
index 5ee1d18f823..00000000000
--- a/libglusterfs/src/compat-errno.h
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __COMPAT_ERRNO_H__
-#define __COMPAT_ERRNO_H__
-
-#include <errno.h>
-
-#define GF_ERROR_CODE_SUCCESS         0
-#define GF_ERROR_CODE_UNKNOWN         1024
-#define GF_ERRNO_UNKNOWN              1024
-
-#define GF_ERROR_CODE_PERM            1      /* Operation not permitted */
-#define GF_ERROR_CODE_NOENT           2      /* No such file or directory */
-#define GF_ERROR_CODE_SRCH            3      /* No such process */
-#define GF_ERROR_CODE_INTR            4      /* Interrupted system call */
-#define GF_ERROR_CODE_IO              5      /* I/O error */
-#define GF_ERROR_CODE_NXIO            6      /* No such device or address */
-#define GF_ERROR_CODE_2BIG            7      /* Argument list too long */
-#define GF_ERROR_CODE_NOEXEC          8      /* Exec format error */
-#define GF_ERROR_CODE_BADF            9      /* Bad file number */
-#define GF_ERROR_CODE_CHILD          10      /* No child processes */
-#define GF_ERROR_CODE_AGAIN          11      /* Try again */
-#define GF_ERROR_CODE_NOMEM          12      /* Out of memory */
-#define GF_ERROR_CODE_ACCES          13      /* Permission denied */
-#define GF_ERROR_CODE_FAULT          14      /* Bad address */
-#define GF_ERROR_CODE_NOTBLK         15      /* Block device required */
-#define GF_ERROR_CODE_BUSY           16      /* Device or resource busy */
-#define GF_ERROR_CODE_EXIST          17      /* File exists */
-#define GF_ERROR_CODE_XDEV           18      /* Cross-device link */
-#define GF_ERROR_CODE_NODEV          19      /* No such device */
-#define GF_ERROR_CODE_NOTDIR         20      /* Not a directory */
-#define GF_ERROR_CODE_ISDIR          21      /* Is a directory */
-#define GF_ERROR_CODE_INVAL          22      /* Invalid argument */
-#define GF_ERROR_CODE_NFILE          23      /* File table overflow */
-#define GF_ERROR_CODE_MFILE          24      /* Too many open files */
-#define GF_ERROR_CODE_NOTTY          25      /* Not a typewriter */
-#define GF_ERROR_CODE_TXTBSY         26      /* Text file busy */
-#define GF_ERROR_CODE_FBIG           27      /* File too large */
-#define GF_ERROR_CODE_NOSPC          28      /* No space left on device */
-#define GF_ERROR_CODE_SPIPE          29      /* Illegal seek */
-#define GF_ERROR_CODE_ROFS           30      /* Read-only file system */
-#define GF_ERROR_CODE_MLINK          31      /* Too many links */
-#define GF_ERROR_CODE_PIPE           32      /* Broken pipe */
-#define GF_ERROR_CODE_DOM            33      /* Math argument out of domain of func */
-#define GF_ERROR_CODE_RANGE          34      /* Math result not representable */
-#define GF_ERROR_CODE_DEADLK         35      /* Resource deadlock would occur */
-#define GF_ERROR_CODE_NAMETOOLONG    36      /* File name too long */
-#define GF_ERROR_CODE_NOLCK          37      /* No record locks available */
-#define GF_ERROR_CODE_NOSYS          38      /* Function not implemented */
-#define GF_ERROR_CODE_NOTEMPTY       39      /* Directory not empty */
-#define GF_ERROR_CODE_LOOP           40      /* Too many symbolic links encountered */
-
-#define GF_ERROR_CODE_NOMSG          42      /* No message of desired type */
-#define GF_ERROR_CODE_IDRM           43      /* Identifier removed */
-#define GF_ERROR_CODE_CHRNG          44      /* Channel number out of range */
-#define GF_ERROR_CODE_L2NSYNC        45      /* Level 2 not synchronized */
-#define GF_ERROR_CODE_L3HLT          46      /* Level 3 halted */
-#define GF_ERROR_CODE_L3RST          47      /* Level 3 reset */
-#define GF_ERROR_CODE_LNRNG          48      /* Link number out of range */
-#define GF_ERROR_CODE_UNATCH         49      /* Protocol driver not attached */
-#define GF_ERROR_CODE_NOCSI          50      /* No CSI structure available */
-#define GF_ERROR_CODE_L2HLT          51      /* Level 2 halted */
-#define GF_ERROR_CODE_BADE           52      /* Invalid exchange */
-#define GF_ERROR_CODE_BADR           53      /* Invalid request descriptor */
-#define GF_ERROR_CODE_XFULL          54      /* Exchange full */
-#define GF_ERROR_CODE_NOANO          55      /* No anode */
-#define GF_ERROR_CODE_BADRQC         56      /* Invalid request code */
-#define GF_ERROR_CODE_BADSLT         57      /* Invalid slot */
-#define GF_ERROR_CODE_BFONT          59      /* Bad font file format */
-#define GF_ERROR_CODE_NOSTR          60      /* Device not a stream */
-#define GF_ERROR_CODE_NODATA         61      /* No data available */
-#define GF_ERROR_CODE_TIME           62      /* Timer expired */
-#define GF_ERROR_CODE_NOSR           63      /* Out of streams resources */
-#define GF_ERROR_CODE_NONET          64      /* Machine is not on the network */
-#define GF_ERROR_CODE_NOPKG          65      /* Package not installed */
-#define GF_ERROR_CODE_REMOTE         66      /* Object is remote */
-#define GF_ERROR_CODE_NOLINK         67      /* Link has been severed */
-#define GF_ERROR_CODE_ADV            68      /* Advertise error */
-#define GF_ERROR_CODE_SRMNT          69      /* Srmount error */
-#define GF_ERROR_CODE_COMM           70      /* Communication error on send */
-#define GF_ERROR_CODE_PROTO          71      /* Protocol error */
-#define GF_ERROR_CODE_MULTIHOP       72      /* Multihop attempted */
-#define GF_ERROR_CODE_DOTDOT         73      /* RFS specific error */
-#define GF_ERROR_CODE_BADMSG         74      /* Not a data message */
-#define GF_ERROR_CODE_OVERFLOW       75      /* Value too large for defined data type */
-#define GF_ERROR_CODE_NOTUNIQ        76      /* Name not unique on network */
-#define GF_ERROR_CODE_BADFD          77      /* File descriptor in bad state */
-#define GF_ERROR_CODE_REMCHG         78      /* Remote address changed */
-#define GF_ERROR_CODE_LIBACC         79      /* Can not access a needed shared library */
-#define GF_ERROR_CODE_LIBBAD         80      /* Accessing a corrupted shared library */
-#define GF_ERROR_CODE_LIBSCN         81      /* .lib section in a.out corrupted */
-#define GF_ERROR_CODE_LIBMAX         82      /* Attempting to link in too many shared libraries */
-#define GF_ERROR_CODE_LIBEXEC        83      /* Cannot exec a shared library directly */
-#define GF_ERROR_CODE_ILSEQ          84      /* Illegal byte sequence */
-#define GF_ERROR_CODE_RESTART        85      /* Interrupted system call should be restarted */
-#define GF_ERROR_CODE_STRPIPE        86      /* Streams pipe error */
-#define GF_ERROR_CODE_USERS          87      /* Too many users */
-#define GF_ERROR_CODE_NOTSOCK        88      /* Socket operation on non-socket */
-#define GF_ERROR_CODE_DESTADDRREQ    89      /* Destination address required */
-#define GF_ERROR_CODE_MSGSIZE        90      /* Message too long */
-#define GF_ERROR_CODE_PROTOTYPE      91      /* Protocol wrong type for socket */
-#define GF_ERROR_CODE_NOPROTOOPT     92      /* Protocol not available */
-#define GF_ERROR_CODE_PROTONOSUPPORT 93      /* Protocol not supported */
-#define GF_ERROR_CODE_SOCKTNOSUPPORT 94      /* Socket type not supported */
-#define GF_ERROR_CODE_OPNOTSUPP      95      /* Operation not supported on transport endpoint */
-#define GF_ERROR_CODE_PFNOSUPPORT    96      /* Protocol family not supported */
-#define GF_ERROR_CODE_AFNOSUPPORT    97      /* Address family not supported by protocol */
-#define GF_ERROR_CODE_ADDRINUSE      98      /* Address already in use */
-#define GF_ERROR_CODE_ADDRNOTAVAIL   99      /* Cannot assign requested address */
-#define GF_ERROR_CODE_NETDOWN        100     /* Network is down */
-#define GF_ERROR_CODE_NETUNREACH     101     /* Network is unreachable */
-#define GF_ERROR_CODE_NETRESET       102     /* Network dropped connection because of reset */
-#define GF_ERROR_CODE_CONNABORTED    103     /* Software caused connection abort */
-#define GF_ERROR_CODE_CONNRESET      104     /* Connection reset by peer */
-#define GF_ERROR_CODE_NOBUFS         105     /* No buffer space available */
-#define GF_ERROR_CODE_ISCONN         106     /* Transport endpoint is already connected */
-#define GF_ERROR_CODE_NOTCONN        107     /* Transport endpoint is not connected */
-#define GF_ERROR_CODE_SHUTDOWN       108     /* Cannot send after transport endpoint shutdown */
-#define GF_ERROR_CODE_TOOMANYREFS    109     /* Too many references: cannot splice */
-#define GF_ERROR_CODE_TIMEDOUT       110     /* Connection timed out */
-#define GF_ERROR_CODE_CONNREFUSED    111     /* Connection refused */
-#define GF_ERROR_CODE_HOSTDOWN       112     /* Host is down */
-#define GF_ERROR_CODE_HOSTUNREACH    113     /* No route to host */
-#define GF_ERROR_CODE_ALREADY        114     /* Operation already in progress */
-#define GF_ERROR_CODE_INPROGRESS     115     /* Operation now in progress */
-#define GF_ERROR_CODE_ALREADY        114     /* Operation already in progress */
-#define GF_ERROR_CODE_INPROGRESS     115     /* Operation now in progress */
-#define GF_ERROR_CODE_STALE          116     /* Stale NFS file handle */
-#define GF_ERROR_CODE_UCLEAN         117     /* Structure needs cleaning */
-#define GF_ERROR_CODE_NOTNAM         118     /* Not a XENIX named type file */
-#define GF_ERROR_CODE_NAVAIL         119     /* No XENIX semaphores available */
-#define GF_ERROR_CODE_ISNAM          120     /* Is a named type file */
-#define GF_ERROR_CODE_REMOTEIO       121     /* Remote I/O error */
-#define GF_ERROR_CODE_DQUOT          122     /* Quota exceeded */
-#define GF_ERROR_CODE_NOMEDIUM       123     /* No medium found */
-#define GF_ERROR_CODE_MEDIUMTYPE     124     /* Wrong medium type */
-#define GF_ERROR_CODE_CANCELED       125     /* Operation Canceled */
-#define GF_ERROR_CODE_NOKEY          126     /* Required key not available */
-#define GF_ERROR_CODE_KEYEXPIRED     127     /* Key has expired */
-#define GF_ERROR_CODE_KEYREVOKED     128     /* Key has been revoked */
-#define GF_ERROR_CODE_KEYREJECTED    129     /* Key was rejected by service */
-
-/* for robust mutexes */
-#define GF_ERROR_CODE_OWNERDEAD      130     /* Owner died */
-#define GF_ERROR_CODE_NOTRECOVERABLE 131     /* State not recoverable */
-
-
-
-/* Should never be seen by user programs */
-#define GF_ERROR_CODE_RESTARTSYS     512
-#define GF_ERROR_CODE_RESTARTNOINTR  513
-#define GF_ERROR_CODE_RESTARTNOHAND  514     /* restart if no handler.. */
-#define GF_ERROR_CODE_NOIOCTLCMD     515     /* No ioctl command */
-#define GF_ERROR_CODE_RESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
-
-/* Defined for the NFSv3 protocol */
-#define GF_ERROR_CODE_BADHANDLE      521     /* Illegal NFS file handle */
-#define GF_ERROR_CODE_NOTSYNC        522     /* Update synchronization mismatch */
-#define GF_ERROR_CODE_BADCOOKIE      523     /* Cookie is stale */
-#define GF_ERROR_CODE_NOTSUPP        524     /* Operation is not supported */
-#define GF_ERROR_CODE_TOOSMALL       525     /* Buffer or request is too small */
-#define GF_ERROR_CODE_SERVERFAULT    526     /* An untranslatable error occurred */
-#define GF_ERROR_CODE_BADTYPE        527     /* Type not supported by server */
-#define GF_ERROR_CODE_JUKEBOX        528     /* Request initiated, but will not complete before timeout */
-#define GF_ERROR_CODE_IOCBQUEUED     529     /* iocb queued, will get completion event */
-#define GF_ERROR_CODE_IOCBRETRY      530     /* iocb queued, will trigger a retry */
-
-/* Darwin OS X */
-#define GF_ERROR_CODE_NOPOLICY   701
-#define GF_ERROR_CODE_BADMACHO   702
-#define GF_ERROR_CODE_PWROFF     703
-#define GF_ERROR_CODE_DEVERR     704
-#define GF_ERROR_CODE_BADARCH    705
-#define GF_ERROR_CODE_BADEXEC    706
-#define GF_ERROR_CODE_SHLIBVERS  707
-
-
-
-/* Solaris */
-/*	ENOTACTIVE 73	/ * Facility is not active		*/
-#define GF_ERROR_CODE_NOTACTIVE   801
-/*	ELOCKUNMAPPED	72	/ * locked lock was unmapped */
-#define GF_ERROR_CODE_LOCKUNMAPPED 802
-
-/* BSD system */
-#define GF_ERROR_CODE_PROCLIM	        901		/* Too many processes */
-#define GF_ERROR_CODE_BADRPC		902		/* RPC struct is bad */
-#define GF_ERROR_CODE_RPCMISMATCH	903		/* RPC version wrong */
-#define GF_ERROR_CODE_PROGUNAVAIL	904		/* RPC prog. not avail */
-#define GF_ERROR_CODE_PROGMISMATCH	905		/* Program version wrong */
-#define GF_ERROR_CODE_PROCUNAVAIL	905		/* Bad procedure for program */
-#define GF_ERROR_CODE_FTYPE		906		/* Inappropriate file type or format */
-#define GF_ERROR_CODE_AUTH		907		/* Authentication error */
-#define GF_ERROR_CODE_NEEDAUTH	        908		/* Need authenticator */
-#define GF_ERROR_CODE_DOOFUS		909		/* Programming error */
-
-#define GF_ERROR_CODE_NOATTR		GF_ERROR_CODE_NODATA		/* Attribute not found */
-
-/* Either one of enodata or enoattr will be there in system */
-#ifndef ENOATTR
-#define ENOATTR ENODATA
-#endif /* ENOATTR */
-
-#ifndef ENODATA
-#define ENODATA ENOATTR
-#endif /* ENODATA */
-
-#ifndef EBADFD
-#define EBADFD EBADRPC
-#endif /* EBADFD */
-
-#if !defined(ENODATA)
-/* This happens on FreeBSD.  Value borrowed from Linux. */
-#define ENODATA 61
-#endif
-
-/* These functions are defined for all the OS flags, but content will
- * be different for each OS flag.
- */
-int32_t gf_errno_to_error (int32_t op_errno);
-int32_t gf_error_to_errno (int32_t error);
-
-#endif /* __COMPAT_ERRNO_H__ */
diff --git a/libglusterfs/src/compat.c b/libglusterfs/src/compat.c
index 621ff5f54c9..8a05a30a8fe 100644
--- a/libglusterfs/src/compat.c
+++ b/libglusterfs/src/compat.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdarg.h>
@@ -16,567 +15,604 @@
 #include <sys/types.h>
 #include <dirent.h>
 
-#ifdef GF_SOLARIS_HOST_OS
-#include "logging.h"
-#endif /* GF_SOLARIS_HOST_OS */
-
-#include "compat.h"
-#include "common-utils.h"
-#include "iatt.h"
-#include "inode.h"
-#include "syscall.h"
-#include "run.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/compat.h"
+#include "glusterfs/iatt.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/run.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 #ifdef GF_SOLARIS_HOST_OS
 int
-solaris_fsetxattr(int fd, const char* key, const char *value, size_t size,
+solaris_fsetxattr(int fd, const char *key, const char *value, size_t size,
                   int flags)
 {
-        int attrfd = -1;
-        int ret = 0;
-
-        attrfd = openat (fd, key, flags|O_CREAT|O_WRONLY|O_XATTR, 0777);
-        if (attrfd >= 0) {
-                ftruncate (attrfd, 0);
-                ret = write (attrfd, value, size);
-                close (attrfd);
-        } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_ERROR, errno,
-                                LG_MSG_SET_ATTRIBUTE_FAILED, "Couldn't set "
-                                "extended attribute for %d", fd);
-                return -1;
-        }
-
-        return 0;
+    int attrfd = -1;
+    int ret = 0;
+
+    attrfd = openat(fd, key, flags | O_CREAT | O_WRONLY | O_XATTR, 0777);
+    if (attrfd >= 0) {
+        ftruncate(attrfd, 0);
+        ret = write(attrfd, value, size);
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_ERROR, errno,
+                   LG_MSG_SET_ATTRIBUTE_FAILED,
+                   "Couldn't set "
+                   "extended attribute for %d",
+                   fd);
+        return -1;
+    }
+
+    return 0;
 }
 
-
 int
-solaris_fgetxattr(int fd, const char* key, char *value, size_t size)
+solaris_fgetxattr(int fd, const char *key, char *value, size_t size)
 {
-        int attrfd = -1;
-        int ret = 0;
-
-        attrfd = openat (fd, key, O_RDONLY|O_XATTR);
-        if (attrfd >= 0) {
-                if (size == 0) {
-                        struct stat buf;
-                        fstat (attrfd, &buf);
-                        ret = buf.st_size;
-                } else {
-                        ret = read (attrfd, value, size);
-                }
-                close (attrfd);
+    int attrfd = -1;
+    int ret = 0;
+
+    attrfd = openat(fd, key, O_RDONLY | O_XATTR);
+    if (attrfd >= 0) {
+        if (size == 0) {
+            struct stat buf;
+            fstat(attrfd, &buf);
+            ret = buf.st_size;
         } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_INFO, errno,
-                                LG_MSG_READ_ATTRIBUTE_FAILED, "Couldn't read "
-                                "extended attribute for the file %d", fd);
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                return -1;
+            ret = read(attrfd, value, size);
         }
-
-        return ret;
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_INFO, errno,
+                   LG_MSG_READ_ATTRIBUTE_FAILED,
+                   "Couldn't read "
+                   "extended attribute for the file %d",
+                   fd);
+        if (errno == ENOENT)
+            errno = ENODATA;
+        return -1;
+    }
+
+    return ret;
 }
 
 /* Solaris does not support xattr for symlinks and dev files. Since gfid and
    other trusted attributes are stored as xattrs, we need to provide support for
-   them. A mapped regular file is stored in the /.glusterfs_xattr_inode of the export dir.
-   All xattr ops related to the special files are redirected to this map file.
+   them. A mapped regular file is stored in the /.glusterfs_xattr_inode of the
+   export dir. All xattr ops related to the special files are redirected to this
+   map file.
 */
 
 int
-make_export_path (const char *real_path, char **path)
+make_export_path(const char *real_path, char **path)
 {
-        int     ret = -1;
-        char   *tmp = NULL;
-        char   *export_path = NULL;
-        char   *dup = NULL;
-        char   *ptr = NULL;
-        char   *freeptr = NULL;
-        uuid_t  gfid = {0, };
-
-        export_path = GF_CALLOC (1, sizeof (char) * PATH_MAX, 0);
-        if (!export_path)
-                goto out;
+    int ret = -1;
+    char *tmp = NULL;
+    char *export_path = NULL;
+    char *dup = NULL;
+    char *ptr = NULL;
+    char *freeptr = NULL;
+    uuid_t gfid = {
+        0,
+    };
+
+    export_path = GF_CALLOC(1, sizeof(char) * PATH_MAX, 0);
+    if (!export_path)
+        goto out;
 
-        dup = gf_strdup (real_path);
-        if (!dup)
-                goto out;
+    dup = gf_strdup(real_path);
+    if (!dup)
+        goto out;
 
-        freeptr = dup;
-        ret = solaris_getxattr ("/", GFID_XATTR_KEY, gfid, 16);
-        /* Return value of getxattr */
+    freeptr = dup;
+    ret = solaris_getxattr("/", GFID_XATTR_KEY, gfid, 16);
+    /* Return value of getxattr */
+    if (ret == 16) {
+        if (__is_root_gfid(gfid)) {
+            strcat(export_path, "/");
+            ret = 0;
+            goto done;
+        }
+    }
+
+    do {
+        ptr = strtok_r(dup, "/", &tmp);
+        if (!ptr)
+            break;
+        strcat(export_path, dup);
+        ret = solaris_getxattr(export_path, GFID_XATTR_KEY, gfid, 16);
         if (ret == 16) {
-                if (__is_root_gfid (gfid)){
-                        strcat (export_path, "/");
-                        ret = 0;
-                        goto done;
-                }
+            if (__is_root_gfid(gfid)) {
+                ret = 0;
+                goto done;
+            }
         }
+        strcat(export_path, "/");
+        dup = tmp;
+    } while (ptr);
 
-        do {
-                ptr = strtok_r (dup, "/", &tmp);
-                if (!ptr)
-                        break;
-                strcat (export_path, dup);
-                ret = solaris_getxattr (export_path, GFID_XATTR_KEY, gfid, 16);
-                if (ret == 16) {
-                        if (__is_root_gfid (gfid)) {
-                                ret = 0;
-                                goto done;
-                        }
-                }
-                strcat (export_path, "/");
-                dup = tmp;
-        } while (ptr);
-
-        goto out;
+    goto out;
 
 done:
-        if (!ret) {
-                *path = export_path;
-        }
+    if (!ret) {
+        *path = export_path;
+    }
 out:
-        GF_FREE (freeptr);
-        if (ret && export_path)
-                GF_FREE (export_path);
+    GF_FREE(freeptr);
+    if (ret && export_path)
+        GF_FREE(export_path);
 
-        return ret;
+    return ret;
 }
 int
-solaris_xattr_resolve_path (const char *real_path, char **path)
+solaris_xattr_resolve_path(const char *real_path, char **path)
 {
-        int                    ret  = -1;
-        char                   *export_path = NULL;
-        char                   xattr_path[PATH_MAX] = {0, };
-        struct stat            lstatbuf = {0, };
-        struct iatt            stbuf = {0, };
-        struct stat            statbuf = {0, };
-
-        ret = lstat (real_path, &lstatbuf);
-        if (ret != 0 )
-                return ret;
-        iatt_from_stat (&stbuf, &lstatbuf);
-        if (IA_ISREG(stbuf.ia_type) || IA_ISDIR(stbuf.ia_type))
-                return -1;
-
-        ret = make_export_path (real_path, &export_path);
-        if (!ret && export_path) {
-                strcat (export_path, "/"GF_SOLARIS_XATTR_DIR);
-                if (lstat (export_path, &statbuf)) {
-                        ret = mkdir (export_path, 0777);
-                        if (ret && (errno != EEXIST)) {
-                                gf_msg_debug (THIS->name, 0, "mkdir failed,"
-                                        " errno: %d", errno);
-                                goto out;
-                        }
-                }
+    int ret = -1;
+    char *export_path = NULL;
+    char xattr_path[PATH_MAX] = {
+        0,
+    };
+    struct stat lstatbuf = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    struct stat statbuf = {
+        0,
+    };
+
+    ret = lstat(real_path, &lstatbuf);
+    if (ret != 0)
+        return ret;
+    iatt_from_stat(&stbuf, &lstatbuf);
+    if (IA_ISREG(stbuf.ia_type) || IA_ISDIR(stbuf.ia_type))
+        return -1;
+
+    ret = make_export_path(real_path, &export_path);
+    if (!ret && export_path) {
+        strcat(export_path, "/" GF_SOLARIS_XATTR_DIR);
+        if (lstat(export_path, &statbuf)) {
+            ret = mkdir(export_path, 0755);
+            if (ret && (errno != EEXIST)) {
+                gf_msg_debug(THIS->name, 0,
+                             "mkdir failed,"
+                             " errno: %d",
+                             errno);
+                goto out;
+            }
+        }
 
-                snprintf(xattr_path, PATH_MAX, "%s%s%lu", export_path,
-                         "/", stbuf.ia_ino);
+        snprintf(xattr_path, PATH_MAX, "%s%s%lu", export_path, "/",
+                 stbuf.ia_ino);
 
-                ret = lstat (xattr_path, &statbuf);
+        ret = lstat(xattr_path, &statbuf);
 
-                if (ret) {
-                        ret = mknod (xattr_path, S_IFREG|O_WRONLY, 0);
-                        if (ret && (errno != EEXIST)) {
-                                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                        LG_MSG_FILE_OP_FAILED, "Failed to "
-                                        "create mapped file %s", xattr_path);
-                                goto out;
-                        }
-                }
-                *path = gf_strdup (xattr_path);
+        if (ret) {
+            ret = mknod(xattr_path, S_IFREG | O_WRONLY, 0);
+            if (ret && (errno != EEXIST)) {
+                gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                       "Failed to "
+                       "create mapped file %s",
+                       xattr_path);
+                goto out;
+            }
         }
+        *path = gf_strdup(xattr_path);
+    }
 out:
-        GF_FREE (export_path);
-        if (*path)
-                return 0;
-        else
-                return -1;
+    GF_FREE(export_path);
+    if (*path)
+        return 0;
+    else
+        return -1;
 }
 
 int
-solaris_setxattr(const char *path, const char* key, const char *value,
+solaris_setxattr(const char *path, const char *key, const char *value,
                  size_t size, int flags)
 {
-        int attrfd = -1;
-        int ret = 0;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path,  key, flags|O_CREAT|O_WRONLY,
-                                   0777);
-        } else {
-                attrfd = attropen (path, key, flags|O_CREAT|O_WRONLY, 0777);
-        }
-        if (attrfd >= 0) {
-                ftruncate (attrfd, 0);
-                ret = write (attrfd, value, size);
-                close (attrfd);
-                ret = 0;
-        } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_ERROR, errno,
-                                LG_MSG_SET_ATTRIBUTE_FAILED, "Couldn't set "
-                                "extended attribute for %s", path);
-                ret = -1;
-        }
-        GF_FREE (mapped_path);
-        return ret;
+    int attrfd = -1;
+    int ret = 0;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, key, flags | O_CREAT | O_WRONLY, 0777);
+    } else {
+        attrfd = attropen(path, key, flags | O_CREAT | O_WRONLY, 0777);
+    }
+    if (attrfd >= 0) {
+        ftruncate(attrfd, 0);
+        ret = write(attrfd, value, size);
+        close(attrfd);
+        ret = 0;
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_ERROR, errno,
+                   LG_MSG_SET_ATTRIBUTE_FAILED,
+                   "Couldn't set "
+                   "extended attribute for %s",
+                   path);
+        ret = -1;
+    }
+    GF_FREE(mapped_path);
+    return ret;
 }
 
-
 int
 solaris_listxattr(const char *path, char *list, size_t size)
 {
-        int attrdirfd = -1;
-        ssize_t len = 0;
-        DIR *dirptr = NULL;
-        struct dirent *dent = NULL;
-        int newfd = -1;
-        char *mapped_path = NULL;
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrdirfd = attropen (mapped_path, ".", O_RDONLY, 0);
-        } else {
-                attrdirfd = attropen (path, ".", O_RDONLY, 0);
-        }
-        if (attrdirfd >= 0) {
-                newfd = dup(attrdirfd);
-                dirptr = fdopendir(newfd);
-                if (dirptr) {
-                        while ((dent = readdir(dirptr))) {
-                                size_t listlen = strlen(dent->d_name);
-                                if (!strcmp(dent->d_name, ".") ||
-                                    !strcmp(dent->d_name, "..")) {
-                                        /* we don't want "." and ".." here */
-                                        continue;
-                                }
-                                if (size == 0) {
-                                        /* return the current size of the list
-                                           of extended attribute names*/
-                                        len += listlen + 1;
-                                } else {
-                                        /* check size and copy entry + null
-                                           into list. */
-                                        if ((len + listlen + 1) > size) {
-                                                errno = ERANGE;
-                                                len = -1;
-                                                break;
-                                        } else {
-                                                strncpy(list + len, dent->d_name, listlen);
-                                                len += listlen;
-                                                list[len] = '\0';
-                                                ++len;
-                                        }
-                                }
-                        }
-
-                        if (closedir(dirptr) == -1) {
-                                close (attrdirfd);
-                                len = -1;
-                                goto out;
-                        }
+    int attrdirfd = -1;
+    ssize_t len = 0;
+    DIR *dirptr = NULL;
+    struct dirent *dent = NULL;
+    int newfd = -1;
+    char *mapped_path = NULL;
+    int ret = -1;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrdirfd = attropen(mapped_path, ".", O_RDONLY, 0);
+    } else {
+        attrdirfd = attropen(path, ".", O_RDONLY, 0);
+    }
+    if (attrdirfd >= 0) {
+        newfd = dup(attrdirfd);
+        dirptr = fdopendir(newfd);
+        if (dirptr) {
+            while ((dent = readdir(dirptr))) {
+                size_t listlen = strlen(dent->d_name);
+                if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) {
+                    /* we don't want "." and ".." here */
+                    continue;
+                }
+                if (size == 0) {
+                    /* return the current size of the list
+                       of extended attribute names*/
+                    len += listlen + 1;
                 } else {
-                        close (attrdirfd);
+                    /* check size and copy entry + null
+                       into list. */
+                    if ((len + listlen + 1) > size) {
+                        errno = ERANGE;
                         len = -1;
-                        goto out;
+                        break;
+                    } else {
+                        strncpy(list + len, dent->d_name, listlen);
+                        len += listlen;
+                        list[len] = '\0';
+                        ++len;
+                    }
                 }
-                close (attrdirfd);
+            }
+
+            if (closedir(dirptr) == -1) {
+                close(attrdirfd);
+                len = -1;
+                goto out;
+            }
+        } else {
+            close(attrdirfd);
+            len = -1;
+            goto out;
         }
+        close(attrdirfd);
+    }
 out:
-        GF_FREE (mapped_path);
-        return len;
+    GF_FREE(mapped_path);
+    return len;
 }
 
-
 int
 solaris_flistxattr(int fd, char *list, size_t size)
 {
-        int attrdirfd = -1;
-        ssize_t len = 0;
-        DIR *dirptr = NULL;
-        struct dirent *dent = NULL;
-        int newfd = -1;
-
-        attrdirfd = openat (fd, ".", O_RDONLY, 0);
-        if (attrdirfd >= 0) {
-                newfd = dup(attrdirfd);
-                dirptr = fdopendir(newfd);
-                if (dirptr) {
-                        while ((dent = readdir(dirptr))) {
-                                size_t listlen = strlen(dent->d_name);
-                                if (!strcmp(dent->d_name, ".") ||
-                                    !strcmp(dent->d_name, "..")) {
-                                        /* we don't want "." and ".." here */
-                                        continue;
-                                }
-                                if (size == 0) {
-                                        /* return the current size of the list
-                                           of extended attribute names*/
-                                        len += listlen + 1;
-                                } else {
-                                        /* check size and copy entry + null
-                                           into list. */
-                                        if ((len + listlen + 1) > size) {
-                                                errno = ERANGE;
-                                                len = -1;
-                                                break;
-                                        } else {
-                                                strncpy(list + len, dent->d_name, listlen);
-                                                len += listlen;
-                                                list[len] = '\0';
-                                                ++len;
-                                        }
-                                }
-                        }
-
-                        if (closedir(dirptr) == -1) {
-                                close (attrdirfd);
-                                return -1;
-                        }
+    int attrdirfd = -1;
+    ssize_t len = 0;
+    DIR *dirptr = NULL;
+    struct dirent *dent = NULL;
+    int newfd = -1;
+
+    attrdirfd = openat(fd, ".", O_RDONLY, 0);
+    if (attrdirfd >= 0) {
+        newfd = dup(attrdirfd);
+        dirptr = fdopendir(newfd);
+        if (dirptr) {
+            while ((dent = readdir(dirptr))) {
+                size_t listlen = strlen(dent->d_name);
+                if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) {
+                    /* we don't want "." and ".." here */
+                    continue;
+                }
+                if (size == 0) {
+                    /* return the current size of the list
+                       of extended attribute names*/
+                    len += listlen + 1;
                 } else {
-                        close (attrdirfd);
-                        return -1;
+                    /* check size and copy entry + null
+                       into list. */
+                    if ((len + listlen + 1) > size) {
+                        errno = ERANGE;
+                        len = -1;
+                        break;
+                    } else {
+                        strncpy(list + len, dent->d_name, listlen);
+                        len += listlen;
+                        list[len] = '\0';
+                        ++len;
+                    }
                 }
-                close (attrdirfd);
+            }
+
+            if (closedir(dirptr) == -1) {
+                close(attrdirfd);
+                return -1;
+            }
+        } else {
+            close(attrdirfd);
+            return -1;
         }
-        return len;
+        close(attrdirfd);
+    }
+    return len;
 }
 
-
 int
-solaris_removexattr(const char *path, const char* key)
+solaris_removexattr(const char *path, const char *key)
 {
-        int ret = -1;
-        int attrfd = -1;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path, ".", O_RDONLY, 0);
-        } else {
-                attrfd = attropen (path, ".", O_RDONLY, 0);
-        }
-        if (attrfd >= 0) {
-                ret = unlinkat (attrfd, key, 0);
-                close (attrfd);
-        } else {
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                ret = -1;
-        }
-
-        GF_FREE (mapped_path);
-
-        return ret;
+    int ret = -1;
+    int attrfd = -1;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, ".", O_RDONLY, 0);
+    } else {
+        attrfd = attropen(path, ".", O_RDONLY, 0);
+    }
+    if (attrfd >= 0) {
+        ret = unlinkat(attrfd, key, 0);
+        close(attrfd);
+    } else {
+        if (errno == ENOENT)
+            errno = ENODATA;
+        ret = -1;
+    }
+
+    GF_FREE(mapped_path);
+
+    return ret;
 }
 
 int
-solaris_getxattr(const char *path,
-                 const char* key,
-                 char *value,
-                 size_t size)
+solaris_getxattr(const char *path, const char *key, char *value, size_t size)
 {
-        int attrfd = -1;
-        int ret = 0;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path, key, O_RDONLY, 0);
+    int attrfd = -1;
+    int ret = 0;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, key, O_RDONLY, 0);
+    } else {
+        attrfd = attropen(path, key, O_RDONLY, 0);
+    }
+
+    if (attrfd >= 0) {
+        if (size == 0) {
+            struct stat buf;
+            fstat(attrfd, &buf);
+            ret = buf.st_size;
         } else {
-                attrfd = attropen (path, key, O_RDONLY, 0);
+            ret = read(attrfd, value, size);
         }
-
-        if (attrfd >= 0) {
-                if (size == 0) {
-                        struct stat buf;
-                        fstat (attrfd, &buf);
-                        ret = buf.st_size;
-                } else {
-                        ret = read (attrfd, value, size);
-                }
-                close (attrfd);
-        } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_INFO, errno,
-                                LG_MSG_READ_ATTRIBUTE_FAILED, "Couldn't read "
-                                "extended attribute for the file %s", path);
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                ret = -1;
-        }
-        GF_FREE (mapped_path);
-        return ret;
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_INFO, errno,
+                   LG_MSG_READ_ATTRIBUTE_FAILED,
+                   "Couldn't read "
+                   "extended attribute for the file %s",
+                   path);
+        if (errno == ENOENT)
+            errno = ENODATA;
+        ret = -1;
+    }
+    GF_FREE(mapped_path);
+    return ret;
 }
 
-
-char* strsep(char** str, const char* delims)
+char *
+strsep(char **str, const char *delims)
 {
-        char* token;
-
-        if (*str==NULL) {
-                /* No more tokens */
-                return NULL;
+    char *token;
+
+    if (*str == NULL) {
+        /* No more tokens */
+        return NULL;
+    }
+
+    token = *str;
+    while (**str != '\0') {
+        if (strchr(delims, **str) != NULL) {
+            **str = '\0';
+            (*str)++;
+            return token;
         }
-
-        token=*str;
-        while (**str!='\0') {
-                if (strchr(delims,**str)!=NULL) {
-                        **str='\0';
-                        (*str)++;
-                        return token;
-                }
-                (*str)++;
-        }
-        /* There is no other token */
-        *str=NULL;
-        return token;
+        (*str)++;
+    }
+    /* There is no other token */
+    *str = NULL;
+    return token;
 }
 
 /* Code comes from libiberty */
 
 int
-vasprintf (char **result, const char *format, va_list args)
+vasprintf(char **result, const char *format, va_list args)
 {
-        return gf_vasprintf(result, format, args);
+    return gf_vasprintf(result, format, args);
 }
 
 int
-asprintf (char **buf, const char *fmt, ...)
+asprintf(char **buf, const char *fmt, ...)
 {
-        int status;
-        va_list ap;
+    int status;
+    va_list ap;
 
-        va_start (ap, fmt);
-        status = vasprintf (buf, fmt, ap);
-        va_end (ap);
-        return status;
+    va_start(ap, fmt);
+    status = vasprintf(buf, fmt, ap);
+    va_end(ap);
+    return status;
 }
 
-int solaris_unlink (const char *path)
+int
+solaris_unlink(const char *path)
 {
-        char *mapped_path = NULL;
-        struct stat     stbuf = {0, };
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-
-
-        if (!ret && mapped_path) {
-                if (lstat(path, &stbuf)) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                LG_MSG_FILE_OP_FAILED, "Stat failed on "
-                                "mapped file %s", mapped_path);
-                        goto out;
-                }
-                if (stbuf.st_nlink == 1) {
-                        if(remove (mapped_path))
-                                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                        LG_MSG_FILE_OP_FAILED, "Failed to "
-                                        "remove mapped file %s", mapped_path);
-                }
-
+    char *mapped_path = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    int ret = -1;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+
+    if (!ret && mapped_path) {
+        if (lstat(path, &stbuf)) {
+            gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                   "Stat failed on "
+                   "mapped file %s",
+                   mapped_path);
+            goto out;
         }
+        if (stbuf.st_nlink == 1) {
+            if (remove(mapped_path))
+                gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                       "Failed to "
+                       "remove mapped file %s",
+                       mapped_path);
+        }
+    }
 
 out:
-        GF_FREE (mapped_path);
+    GF_FREE(mapped_path);
 
-        return  unlink (path);
+    return unlink(path);
 }
 
 int
-solaris_rename (const char *old_path, const char *new_path)
+solaris_rename(const char *old_path, const char *new_path)
 {
-        char *mapped_path = NULL;
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (new_path, &mapped_path);
+    char *mapped_path = NULL;
+    int ret = -1;
 
+    ret = solaris_xattr_resolve_path(new_path, &mapped_path);
 
-        if (!ret && mapped_path) {
-                if (!remove (mapped_path))
-                        gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                LG_MSG_FILE_OP_FAILED, "Failed to remove "
-                                "mapped file %s.", mapped_path);
-                GF_FREE (mapped_path);
-        }
-
-        return rename(old_path, new_path);
+    if (!ret && mapped_path) {
+        if (!remove(mapped_path))
+            gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                   "Failed to remove "
+                   "mapped file %s.",
+                   mapped_path);
+        GF_FREE(mapped_path);
+    }
 
+    return rename(old_path, new_path);
 }
 
 char *
-mkdtemp (char *tempstring)
+mkdtemp(char *tempstring)
 {
-        char *new_string = NULL;
-        int   ret        = 0;
+    char *new_string = NULL;
+    int ret = 0;
 
-        new_string = mkstemp (tempstring);
-        if (!new_string)
-                goto out;
+    new_string = mkstemp(tempstring);
+    if (!new_string)
+        goto out;
 
-        ret = mkdir (new_string, 0700);
-        if (ret < 0)
-                new_string = NULL;
+    ret = mkdir(new_string, 0700);
+    if (ret < 0)
+        new_string = NULL;
 
 out:
-        return new_string;
+    return new_string;
 }
 
 #endif /* GF_SOLARIS_HOST_OS */
 
+#ifdef GF_BSD_HOST_OS
+void
+gf_extattr_list_reshape(char *bsd_list, ssize_t size)
+{
+    /*
+     * the format of bsd_list is
+     *     <attr_len>attr<attr_len>attr...
+     * we try to reformat it as Linux's
+     *     attr<\0>attr<\0>...
+     * */
+    if (NULL == bsd_list || size <= 0)
+        return;
+
+    size_t i = 0, j;
+
+    while (i < size) {
+        size_t attr_len = bsd_list[i];
+
+        for (j = i; j < i + attr_len; ++j)
+            bsd_list[j] = bsd_list[j + 1];
+        bsd_list[j] = '\0';
+
+        i += attr_len + 1;
+        gf_msg_debug("syscall", 0, "syscall debug: %lu", attr_len);
+    }
+}
+#endif /* GF_BSD_HOST_OS */
+
 #ifndef HAVE_STRNLEN
 size_t
 strnlen(const char *string, size_t maxlen)
 {
-        int len = 0;
-        while ((len < maxlen) && string[len])
-                len++;
-        return len;
+    int len = 0;
+    while ((len < maxlen) && string[len])
+        len++;
+    return len;
 }
 #endif /* STRNLEN */
 
 int
-gf_umount_lazy (char *xlname, char *path, int rmdir_flag)
+gf_umount_lazy(char *xlname, char *path, int rmdir_flag)
 {
-        int                   ret               = -1;
-        runner_t              runner            = {0,};
+    int ret = -1;
+    runner_t runner = {
+        0,
+    };
 
-        runinit (&runner);
+    runinit(&runner);
 #ifdef GF_LINUX_HOST_OS
-        runner_add_args (&runner, _PATH_UMOUNT, "-l", path, NULL);
+    runner_add_args(&runner, _PATH_UMOUNT, "-l", path, NULL);
 #else
-        if (rmdir_flag)
-                runner_add_args (&runner, SBIN_DIR "/umountd",
-                                 "-r", path, NULL);
-        else
-                runner_add_args (&runner, SBIN_DIR "/umountd",
-                                 path, NULL);
+    if (rmdir_flag)
+        runner_add_args(&runner, SBIN_DIR "/umountd", "-r", path, NULL);
+    else
+        runner_add_args(&runner, SBIN_DIR "/umountd", path, NULL);
 #endif
-        ret = runner_run (&runner);
-        if (ret) {
-                gf_msg (xlname, GF_LOG_ERROR, errno, LG_MSG_UNMOUNT_FAILED,
-                        "Lazy unmount of %s", path);
-        }
+    ret = runner_run(&runner);
+    if (ret) {
+        gf_msg(xlname, GF_LOG_ERROR, errno, LG_MSG_UNMOUNT_FAILED,
+               "Lazy unmount of %s", path);
+    }
 
 #ifdef GF_LINUX_HOST_OS
-        if (!ret && rmdir_flag) {
-                ret = sys_rmdir (path);
-                if (ret)
-                        gf_msg (xlname, GF_LOG_WARNING, errno,
-                                LG_MSG_DIR_OP_FAILED, "rmdir %s", path);
-        }
+    if (!ret && rmdir_flag) {
+        ret = sys_rmdir(path);
+        if (ret)
+            gf_msg(xlname, GF_LOG_WARNING, errno, LG_MSG_DIR_OP_FAILED,
+                   "rmdir %s", path);
+    }
 #endif
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/compound-fop-utils.c b/libglusterfs/src/compound-fop-utils.c
deleted file mode 100644
index 03d7b5ba459..00000000000
--- a/libglusterfs/src/compound-fop-utils.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#include "defaults.h"
-#include "default-args.h"
-#include "mem-types.h"
-#include "dict.h"
-
-void
-compound_args_cleanup (compound_args_t *args)
-{
-        int i;
-
-        if (!args)
-                return;
-
-        if (args->xdata)
-                dict_unref (args->xdata);
-
-        if (args->req_list) {
-                for (i = 0; i < args->fop_length; i++) {
-                        args_wipe (&args->req_list[i]);
-                }
-        }
-
-        GF_FREE (args->enum_list);
-        GF_FREE (args->req_list);
-        GF_FREE (args);
-}
-
-void
-compound_args_cbk_cleanup (compound_args_cbk_t *args_cbk)
-{
-        int i;
-
-        if (!args_cbk)
-                return;
-
-        if (args_cbk->xdata)
-                dict_unref (args_cbk->xdata);
-
-        if (args_cbk->rsp_list) {
-                for (i = 0; i < args_cbk->fop_length; i++) {
-                        args_cbk_wipe (&args_cbk->rsp_list[i]);
-                }
-        }
-
-        GF_FREE (args_cbk->rsp_list);
-        GF_FREE (args_cbk->enum_list);
-        GF_FREE (args_cbk);
-}
-
-compound_args_cbk_t*
-compound_args_cbk_alloc (int length, dict_t *xdata)
-{
-        int                 i             = 0;
-        compound_args_cbk_t *args_cbk     = NULL;
-
-        args_cbk = GF_CALLOC (1, sizeof (*args_cbk), gf_mt_compound_rsp_t);
-        if (!args_cbk)
-                return NULL;
-
-        args_cbk->fop_length = length;
-
-        args_cbk->rsp_list = GF_CALLOC (length, sizeof (*args_cbk->rsp_list),
-                                        gf_mt_default_args_cbk_t);
-        if (!args_cbk->rsp_list)
-                goto out;
-
-        for (i = 0; i < length; i++) {
-                args_cbk_init (&args_cbk->rsp_list[i]);
-        }
-
-        args_cbk->enum_list = GF_CALLOC (length, sizeof (*args_cbk->enum_list),
-                                        gf_common_mt_int);
-        if (!args_cbk->enum_list)
-                goto out;
-
-        if (xdata) {
-                args_cbk->xdata = dict_copy_with_ref (xdata, NULL);
-                if (!args_cbk->xdata)
-                        goto out;
-        }
-
-        return args_cbk;
-out:
-        compound_args_cbk_cleanup (args_cbk);
-        return NULL;
-}
-
-compound_args_t*
-compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata)
-{
-        compound_args_t *args     = NULL;
-
-        args = GF_CALLOC (1, sizeof (*args), gf_mt_compound_req_t);
-
-        if (!args)
-                return NULL;
-
-        /* fop_enum can be used by xlators to see which fops are
-         * included as part of compound fop. This will help in checking
-         * for compatibility or support without going through the entire
-         * fop list packed.
-         */
-        args->fop_enum = fop;
-        args->fop_length = length;
-
-        args->enum_list = GF_CALLOC (length, sizeof (*args->enum_list),
-                                     gf_common_mt_int);
-
-        if (!args->enum_list)
-                goto out;
-
-        args->req_list = GF_CALLOC (length, sizeof (*args->req_list),
-                                     gf_mt_default_args_t);
-
-        if (!args->req_list)
-                goto out;
-
-        if (xdata) {
-                args->xdata = dict_copy_with_ref (xdata, args->xdata);
-                if (!args->xdata)
-                        goto out;
-        }
-
-        return args;
-out:
-        compound_args_cleanup (args);
-        return NULL;
-}
diff --git a/libglusterfs/src/compound-fop-utils.h b/libglusterfs/src/compound-fop-utils.h
deleted file mode 100644
index bfd0649aef2..00000000000
--- a/libglusterfs/src/compound-fop-utils.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __COMPOUND_FOP_UTILS_H__
-#define __COMPOUND_FOP_UTILS_H__
-
-#include "defaults.h"
-#include "default-args.h"
-#include "mem-types.h"
-#include "dict.h"
-
-#define COMPOUND_PACK_ARGS(fop, fop_enum, args, counter, params ...) do {    \
-        args->enum_list[counter] = fop_enum;                                 \
-        args_##fop##_store (&args->req_list[counter], params);               \
-} while (0)
-
-compound_args_t*
-compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata);
-
-void
-compound_args_cleanup (compound_args_t *args);
-
-void
-compound_args_cbk_cleanup (compound_args_cbk_t *args_cbk);
-
-compound_args_cbk_t*
-compound_args_cbk_alloc (int length, dict_t *xdata);
-#endif /* __COMPOUND_FOP_UTILS_H__ */
diff --git a/libglusterfs/src/ctx.c b/libglusterfs/src/ctx.c
index 94c56acdea5..3d890b04ec9 100644
--- a/libglusterfs/src/ctx.c
+++ b/libglusterfs/src/ctx.c
@@ -10,88 +10,88 @@
 
 #include <pthread.h>
 
-#include "globals.h"
-#include "glusterfs.h"
+#include "glusterfs/globals.h"
+#include "glusterfs/glusterfs.h"
 #include "timer-wheel.h"
 
 glusterfs_ctx_t *
-glusterfs_ctx_new ()
+glusterfs_ctx_new()
 {
-        int               ret = 0;
-	glusterfs_ctx_t  *ctx = NULL;
-
-	/* no GF_CALLOC here, gf_acct_mem_set_enable is not
-	   yet decided at this point */
-        ctx = calloc (1, sizeof (*ctx));
-        if (!ctx) {
-                ret = -1;
-                goto out;
-        }
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx->mem_acct_enable = gf_global_mem_acct_enable_get();
+    /* no GF_CALLOC here, gf_acct_mem_set_enable is not
+       yet decided at this point */
+    ctx = CALLOC(1, sizeof(*ctx));
+    if (!ctx) {
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&ctx->graphs);
-#if defined(OLD_MEM_POOLS)
-        INIT_LIST_HEAD (&ctx->mempool_list);
-#endif
-        INIT_LIST_HEAD (&ctx->volfile_list);
+    ctx->mem_acct_enable = gf_global_mem_acct_enable_get();
+
+    INIT_LIST_HEAD(&ctx->graphs);
+    INIT_LIST_HEAD(&ctx->mempool_list);
+    INIT_LIST_HEAD(&ctx->volfile_list);
 
-	ctx->daemon_pipe[0] = -1;
-	ctx->daemon_pipe[1] = -1;
+    ctx->daemon_pipe[0] = -1;
+    ctx->daemon_pipe[1] = -1;
 
-        ctx->log.loglevel = DEFAULT_LOG_LEVEL;
+    ctx->log.loglevel = DEFAULT_LOG_LEVEL;
 
-#ifdef RUN_WITH_VALGRIND
-        ctx->cmd_args.valgrind = _gf_true;
+#if defined(RUN_WITH_MEMCHECK)
+    ctx->cmd_args.vgtool = _gf_memcheck;
+#elif defined(RUN_WITH_DRD)
+    ctx->cmd_args.vgtool = _gf_drd;
+#else
+    ctx->cmd_args.vgtool = _gf_none;
 #endif
 
-        /* lock is never destroyed! */
-	ret = LOCK_INIT (&ctx->lock);
-	if (ret) {
-		free (ctx);
-		ctx = NULL;
-	}
+    /* lock is never destroyed! */
+    if (LOCK_INIT(&ctx->lock)) {
+        free(ctx);
+        ctx = NULL;
+        goto out;
+    }
 
-        GF_ATOMIC_INIT (ctx->stats.max_dict_pairs, 0);
-        GF_ATOMIC_INIT (ctx->stats.total_pairs_used, 0);
-        GF_ATOMIC_INIT (ctx->stats.total_dicts_used, 0);
+    GF_ATOMIC_INIT(ctx->stats.max_dict_pairs, 0);
+    GF_ATOMIC_INIT(ctx->stats.total_pairs_used, 0);
+    GF_ATOMIC_INIT(ctx->stats.total_dicts_used, 0);
 out:
-	return ctx;
+    return ctx;
 }
 
 static void
-glusterfs_ctx_tw_destroy (struct gf_ctx_tw *ctx_tw)
+glusterfs_ctx_tw_destroy(struct gf_ctx_tw *ctx_tw)
 {
-        if (ctx_tw->timer_wheel)
-                gf_tw_cleanup_timers (ctx_tw->timer_wheel);
+    if (ctx_tw->timer_wheel)
+        gf_tw_cleanup_timers(ctx_tw->timer_wheel);
 
-        GF_FREE (ctx_tw);
+    GF_FREE(ctx_tw);
 }
 
-struct tvec_base*
-glusterfs_ctx_tw_get (glusterfs_ctx_t *ctx)
+struct tvec_base *
+glusterfs_ctx_tw_get(glusterfs_ctx_t *ctx)
 {
-        struct gf_ctx_tw *ctx_tw = NULL;
-
-        LOCK (&ctx->lock);
-        {
-                if (ctx->tw) {
-                        ctx_tw = GF_REF_GET (ctx->tw);
-                } else {
-                        ctx_tw = GF_CALLOC (1, sizeof (struct gf_ctx_tw),
-                                            gf_common_mt_tw_ctx);
-                        ctx_tw->timer_wheel = gf_tw_init_timers();
-                        GF_REF_INIT (ctx_tw, glusterfs_ctx_tw_destroy);
-                        ctx->tw = ctx_tw;
-                }
+    struct gf_ctx_tw *ctx_tw = NULL;
+
+    LOCK(&ctx->lock);
+    {
+        if (ctx->tw) {
+            ctx_tw = GF_REF_GET(ctx->tw);
+        } else {
+            ctx_tw = GF_CALLOC(1, sizeof(struct gf_ctx_tw),
+                               gf_common_mt_tw_ctx);
+            ctx_tw->timer_wheel = gf_tw_init_timers();
+            GF_REF_INIT(ctx_tw, glusterfs_ctx_tw_destroy);
+            ctx->tw = ctx_tw;
         }
-        UNLOCK (&ctx->lock);
+    }
+    UNLOCK(&ctx->lock);
 
-        return ctx_tw->timer_wheel;
+    return ctx_tw->timer_wheel;
 }
 
 void
-glusterfs_ctx_tw_put (glusterfs_ctx_t *ctx)
+glusterfs_ctx_tw_put(glusterfs_ctx_t *ctx)
 {
-        GF_REF_PUT (ctx->tw);
+    GF_REF_PUT(ctx->tw);
 }
diff --git a/libglusterfs/src/daemon.c b/libglusterfs/src/daemon.c
index 348e3ad4083..0a3e5438325 100644
--- a/libglusterfs/src/daemon.c
+++ b/libglusterfs/src/daemon.c
@@ -8,59 +8,58 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <fcntl.h>
 #include <unistd.h>
 #include <stdio.h>
-#include "daemon.h"
+#include "glusterfs/daemon.h"
 
 int
-os_daemon_return (int nochdir, int noclose)
+os_daemon_return(int nochdir, int noclose)
 {
-	pid_t   pid  = -1;
-	int     ret  = -1;
-        FILE    *ptr = NULL;
+    pid_t pid = -1;
+    int ret = -1;
+    FILE *ptr = NULL;
 
-	ret = fork();
-	if (ret)
-		return ret;
+    ret = fork();
+    if (ret)
+        return ret;
 
-	pid = setsid();
+    pid = setsid();
 
-	if (pid == -1) {
-                ret = -1;
-		goto out;
-        }
+    if (pid == -1) {
+        ret = -1;
+        goto out;
+    }
 
-	if (!nochdir)
-		ret = chdir("/");
+    if (!nochdir)
+        ret = chdir("/");
 
-        if (!noclose) {
-                ptr = freopen (DEVNULLPATH, "r", stdin);
-                if (!ptr)
-                        goto out;
+    if (!noclose) {
+        ptr = freopen(DEVNULLPATH, "r", stdin);
+        if (!ptr)
+            goto out;
 
-                ptr = freopen (DEVNULLPATH, "w", stdout);
-                if (!ptr)
-                        goto out;
+        ptr = freopen(DEVNULLPATH, "w", stdout);
+        if (!ptr)
+            goto out;
 
-                ptr = freopen (DEVNULLPATH, "w", stderr);
-                if (!ptr)
-                        goto out;
-	}
+        ptr = freopen(DEVNULLPATH, "w", stderr);
+        if (!ptr)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
 int
-os_daemon (int nochdir, int noclose)
+os_daemon(int nochdir, int noclose)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = os_daemon_return (nochdir, noclose);
-	if (ret <= 0)
-		return ret;
+    ret = os_daemon_return(nochdir, noclose);
+    if (ret <= 0)
+        return ret;
 
-	_exit (0);
+    _exit(0);
 }
diff --git a/libglusterfs/src/default-args.c b/libglusterfs/src/default-args.c
index f40de2dae68..a0ba1cfb299 100644
--- a/libglusterfs/src/default-args.c
+++ b/libglusterfs/src/default-args.c
@@ -13,1597 +13,1639 @@
 #include "config.h"
 #endif
 
-#include "xlator.h"
-#include "defaults.h"
+#include "glusterfs/defaults.h"
 
 int
-args_lookup_store (default_args_t *args, loc_t *loc,
-                   dict_t *xdata)
+args_lookup_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_lookup_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     inode_t *inode, struct iatt *buf,
-                     dict_t *xdata, struct iatt *postparent)
+args_lookup_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, inode_t *inode, struct iatt *buf,
+                      dict_t *xdata, struct iatt *postparent)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_stat_store (default_args_t *args, loc_t *loc, dict_t *xdata)
+args_stat_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_stat_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   struct iatt *buf, dict_t *xdata)
+args_stat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    struct iatt *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->stat = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fstat_store (default_args_t *args, fd_t *fd, dict_t *xdata)
+args_fstat_store(default_args_t *args, fd_t *fd, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fstat_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *buf, dict_t *xdata)
+args_fstat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (buf)
-                args->stat = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (buf)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_truncate_store (default_args_t *args, loc_t *loc, off_t off,
-                     dict_t *xdata)
+args_truncate_store(default_args_t *args, loc_t *loc, off_t off, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_truncate_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
+args_truncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ftruncate_store (default_args_t *args, fd_t *fd, off_t off,
-                      dict_t *xdata)
+args_ftruncate_store(default_args_t *args, fd_t *fd, off_t off, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ftruncate_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+args_ftruncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_access_store (default_args_t *args, loc_t *loc, int32_t mask,
-                   dict_t *xdata)
+args_access_store(default_args_t *args, loc_t *loc, int32_t mask, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mask = mask;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->mask = mask;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_access_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_access_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_readlink_store (default_args_t *args, loc_t *loc, size_t size,
-                     dict_t *xdata)
+args_readlink_store(default_args_t *args, loc_t *loc, size_t size,
+                    dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->size = size;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->size = size;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readlink_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       const char *path, struct iatt *stbuf, dict_t *xdata)
+args_readlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, const char *path, struct iatt *stbuf,
+                        dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (path)
-                args->buf = gf_strdup (path);
-        if (stbuf)
-                args->stat = *stbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (path)
+        args->buf = gf_strdup(path);
+    if (stbuf)
+        args->stat = *stbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mknod_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  dev_t rdev, mode_t umask, dict_t *xdata)
+args_mknod_store(default_args_t *args, loc_t *loc, mode_t mode, dev_t rdev,
+                 mode_t umask, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode = mode;
-        args->rdev = rdev;
-        args->umask = umask;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->rdev = rdev;
+    args->umask = umask;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mknod_cbk_store (default_args_cbk_t *args, int op_ret,
-                    int32_t op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata)
+args_mknod_cbk_store(default_args_cbk_t *args, int op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mkdir_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  mode_t umask, dict_t *xdata)
+args_mkdir_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+                 dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode  = mode;
-        args->umask = umask;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->umask = umask;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mkdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+args_mkdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_unlink_store (default_args_t *args, loc_t *loc, int xflag, dict_t *xdata)
+args_unlink_store(default_args_t *args, loc_t *loc, int xflag, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->xflag = xflag;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->xflag = xflag;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_unlink_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+args_unlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_rmdir_store (default_args_t *args, loc_t *loc, int flags, dict_t *xdata)
+args_rmdir_store(default_args_t *args, loc_t *loc, int flags, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_rmdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata)
+args_rmdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_symlink_store (default_args_t *args, const char *linkname, loc_t *loc,
+args_symlink_store(default_args_t *args, const char *linkname, loc_t *loc,
                    mode_t umask, dict_t *xdata)
 {
-        args->linkname = gf_strdup (linkname);
-        args->umask = umask;
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->linkname = gf_strdup(linkname);
+    args->umask = umask;
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_symlink_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+args_symlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, inode_t *inode, struct iatt *buf,
+                       struct iatt *preparent, struct iatt *postparent,
+                       dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_rename_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                   dict_t *xdata)
+args_rename_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                  dict_t *xdata)
 {
-        loc_copy (&args->loc, oldloc);
-        loc_copy (&args->loc2, newloc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, oldloc);
+    loc_copy(&args->loc2, newloc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_rename_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-                     dict_t *xdata)
+args_rename_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *buf,
+                      struct iatt *preoldparent, struct iatt *postoldparent,
+                      struct iatt *prenewparent, struct iatt *postnewparent,
+                      dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (buf)
-                args->stat = *buf;
-        if (preoldparent)
-                args->preparent = *preoldparent;
-        if (postoldparent)
-                args->postparent = *postoldparent;
-        if (prenewparent)
-                args->preparent2 = *prenewparent;
-        if (postnewparent)
-                args->postparent2 = *postnewparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (buf)
+        args->stat = *buf;
+    if (preoldparent)
+        args->preparent = *preoldparent;
+    if (postoldparent)
+        args->postparent = *postoldparent;
+    if (prenewparent)
+        args->preparent2 = *prenewparent;
+    if (postnewparent)
+        args->postparent2 = *postnewparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_link_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                 dict_t *xdata)
+args_link_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                dict_t *xdata)
 {
-        loc_copy (&args->loc, oldloc);
-        loc_copy (&args->loc2, newloc);
+    loc_copy(&args->loc, oldloc);
+    loc_copy(&args->loc2, newloc);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_link_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   inode_t *inode, struct iatt *buf,
-                   struct iatt *preparent, struct iatt *postparent,
-                   dict_t *xdata)
+args_link_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_create_store (default_args_t *args,
-                  loc_t *loc, int32_t flags, mode_t mode,
+args_create_store(default_args_t *args, loc_t *loc, int32_t flags, mode_t mode,
                   mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        args->mode = mode;
-        args->umask = umask;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    args->mode = mode;
+    args->umask = umask;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_create_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+args_create_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, fd_t *fd, inode_t *inode,
+                      struct iatt *buf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_open_store (default_args_t *args, loc_t *loc, int32_t flags,
-                 fd_t *fd, dict_t *xdata)
+args_open_store(default_args_t *args, loc_t *loc, int32_t flags, fd_t *fd,
+                dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_open_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   fd_t *fd, dict_t *xdata)
+args_open_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    fd_t *fd, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readv_store (default_args_t *args, fd_t *fd, size_t size, off_t off,
-                  uint32_t flags, dict_t *xdata)
+args_readv_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                 uint32_t flags, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->size  = size;
-        args->offset  = off;
-        args->flags = flags;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
+    args->flags = flags;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readv_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                    int32_t count, struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata)
+args_readv_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iovec *vector, int32_t count, struct iatt *stbuf,
+                     struct iobref *iobref, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0) {
-                args->vector = iov_dup (vector, count);
-                args->count = count;
-                args->stat = *stbuf;
-                args->iobref = iobref_ref (iobref);
-        }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0) {
+        args->vector = iov_dup(vector, count);
+        args->count = count;
+        args->stat = *stbuf;
+        args->iobref = iobref_ref(iobref);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_writev_store (default_args_t *args, fd_t *fd, struct iovec *vector,
-                   int32_t count, off_t off, uint32_t flags,
-                   struct iobref *iobref, dict_t *xdata)
+args_writev_store(default_args_t *args, fd_t *fd, struct iovec *vector,
+                  int32_t count, off_t off, uint32_t flags,
+                  struct iobref *iobref, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->vector = iov_dup (vector, count);
-        args->count  = count;
-        args->offset = off;
-        args->flags  = flags;
-        args->iobref = iobref_ref (iobref);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->vector = iov_dup(vector, count);
+    args->count = count;
+    args->offset = off;
+    args->flags = flags;
+    args->iobref = iobref_ref(iobref);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_writev_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+args_writev_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0)
-                args->poststat = *postbuf;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0)
+        args->poststat = *postbuf;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_flush_store (default_args_t *args, fd_t *fd, dict_t *xdata)
+args_put_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+               uint32_t flags, struct iovec *vector, int32_t count, off_t off,
+               struct iobref *iobref, dict_t *xattr, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->umask = umask;
+    args->flags = flags;
+    args->vector = iov_dup(vector, count);
+    args->count = count;
+    args->offset = off;
+    args->iobref = iobref_ref(iobref);
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_flush_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_put_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0)
+        args->stat = *buf;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
+}
+int
+args_flush_store(default_args_t *args, fd_t *fd, dict_t *xdata)
+{
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fsync_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                  dict_t *xdata)
+args_flush_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->datasync = datasync;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    return 0;
+}
+
+int
+args_fsync_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                 dict_t *xdata)
+{
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->datasync = datasync;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fsync_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+args_fsync_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_opendir_store (default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata)
+args_opendir_store(default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_opendir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      fd_t *fd, dict_t *xdata)
+args_opendir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fsyncdir_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                     dict_t *xdata)
+args_fsyncdir_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                    dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->datasync = datasync;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->datasync = datasync;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 int
-args_fsyncdir_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fsyncdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_statfs_store (default_args_t *args, loc_t *loc, dict_t *xdata)
+args_statfs_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_statfs_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct statvfs *buf, dict_t *xdata)
+args_statfs_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->statvfs = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->statvfs = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_setxattr_store (default_args_t *args,
-                     loc_t *loc, dict_t *dict,
-                     int32_t flags, dict_t *xdata)
+args_setxattr_store(default_args_t *args, loc_t *loc, dict_t *dict,
+                    int32_t flags, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        /* TODO */
-        if (dict)
-                args->xattr = dict_ref (dict);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    /* TODO */
+    if (dict)
+        args->xattr = dict_ref(dict);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_setxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret,
-                       int32_t op_errno, dict_t *xdata)
+args_setxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_getxattr_store (default_args_t *args,
-                     loc_t *loc, const char *name, dict_t *xdata)
+args_getxattr_store(default_args_t *args, loc_t *loc, const char *name,
+                    dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (name)
-                args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (name)
+        args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_getxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata)
+args_getxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (dict)
-                args->xattr = dict_ref (dict);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fsetxattr_store (default_args_t *args,
-                      fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+args_fsetxattr_store(default_args_t *args, fd_t *fd, dict_t *dict,
+                     int32_t flags, dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        if (dict)
-                args->xattr = dict_ref (dict);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fsetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fsetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fgetxattr_store (default_args_t *args,
-                      fd_t *fd, const char *name, dict_t *xdata)
+args_fgetxattr_store(default_args_t *args, fd_t *fd, const char *name,
+                     dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        if (name)
-                args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (name)
+        args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fgetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+args_fgetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (dict)
-                args->xattr = dict_ref (dict);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_removexattr_store (default_args_t *args,
-                        loc_t *loc, const char *name, dict_t *xdata)
+args_removexattr_store(default_args_t *args, loc_t *loc, const char *name,
+                       dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_removexattr_cbk_store (default_args_cbk_t *args,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_removexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fremovexattr_store (default_args_t *args,
-                         fd_t *fd, const char *name, dict_t *xdata)
+args_fremovexattr_store(default_args_t *args, fd_t *fd, const char *name,
+                        dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    args->fd = fd_ref(fd);
+    args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fremovexattr_cbk_store (default_args_cbk_t *args,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fremovexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                            int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_lk_store (default_args_t *args,
-               fd_t *fd, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata)
+args_lk_store(default_args_t *args, fd_t *fd, int32_t cmd,
+              struct gf_flock *lock, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->cmd = cmd;
-        args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->cmd = cmd;
+    args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_lk_cbk_store (default_args_cbk_t *args,
-                 int32_t op_ret, int32_t op_errno,
-                 struct gf_flock *lock, dict_t *xdata)
+args_lk_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                  struct gf_flock *lock, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_inodelk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, int32_t cmd,
-                    struct gf_flock *lock, dict_t *xdata)
+args_inodelk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        loc_copy (&args->loc, loc);
-        args->cmd  = cmd;
-        args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->cmd = cmd;
+    args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_inodelk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_inodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_finodelk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, int32_t cmd,
-                     struct gf_flock *lock, dict_t *xdata)
+args_finodelk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        if (fd)
-                args->fd   = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        args->cmd  = cmd;
-        args->lock = *lock;
+    args->cmd = cmd;
+    args->lock = *lock;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_finodelk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_finodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_entrylk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, const char *name,
-                    entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+args_entrylk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   const char *name, entrylk_cmd cmd, entrylk_type type,
+                   dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        args->entrylkcmd = cmd;
-        args->entrylktype = type;
+    args->entrylkcmd = cmd;
+    args->entrylktype = type;
 
-        if (name)
-                args->name = gf_strdup (name);
+    if (name)
+        args->name = gf_strdup(name);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_entrylk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_entrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fentrylk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, const char *name,
-                     entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+args_fentrylk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    const char *name, entrylk_cmd cmd, entrylk_type type,
+                    dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->entrylkcmd = cmd;
-        args->entrylktype = type;
-        if (name)
-                args->name = gf_strdup (name);
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->entrylkcmd = cmd;
+    args->entrylktype = type;
+    if (name)
+        args->name = gf_strdup(name);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fentrylk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fentrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_readdirp_store (default_args_t *args,
-                     fd_t *fd, size_t size, off_t off, dict_t *xdata)
-{
-        args->fd = fd_ref (fd);
-        args->size = size;
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
-}
-
-int
-args_readdirp_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata)
+args_readdirp_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                    dict_t *xdata)
 {
-        gf_dirent_t *stub_entry = NULL, *entry = NULL;
-
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        stub_entry = gf_dirent_for_name (entry->d_name);
-                        if (!stub_entry)
-                                goto out;
-                        stub_entry->d_off = entry->d_off;
-                        stub_entry->d_ino = entry->d_ino;
-                        stub_entry->d_stat = entry->d_stat;
-                        stub_entry->d_type = entry->d_type;
-                        if (entry->inode)
-                                stub_entry->inode = inode_ref (entry->inode);
-                        if (entry->dict)
-                                stub_entry->dict = dict_ref (entry->dict);
-                        list_add_tail (&stub_entry->list,
-                                       &args->entries.list);
-                }
+    args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
+}
+
+int
+args_readdirp_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
+{
+    gf_dirent_t *stub_entry = NULL, *entry = NULL;
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            stub_entry = gf_dirent_for_name(entry->d_name);
+            if (!stub_entry)
+                goto out;
+            stub_entry->d_off = entry->d_off;
+            stub_entry->d_ino = entry->d_ino;
+            stub_entry->d_stat = entry->d_stat;
+            stub_entry->d_type = entry->d_type;
+            if (entry->inode)
+                stub_entry->inode = inode_ref(entry->inode);
+            if (entry->dict)
+                stub_entry->dict = dict_ref(entry->dict);
+            list_add_tail(&stub_entry->list, &args->entries.list);
         }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-args_readdir_store (default_args_t *args,
-                    fd_t *fd, size_t size,
-                    off_t off, dict_t *xdata)
+args_readdir_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                   dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->size = size;
-        args->offset = off;
+    args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_readdir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      gf_dirent_t *entries, dict_t *xdata)
+args_readdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
-        gf_dirent_t *stub_entry = NULL, *entry = NULL;
+    gf_dirent_t *stub_entry = NULL, *entry = NULL;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        stub_entry = gf_dirent_for_name (entry->d_name);
-                        if (!stub_entry)
-                                goto out;
-                        stub_entry->d_off = entry->d_off;
-                        stub_entry->d_ino = entry->d_ino;
-                        stub_entry->d_type = entry->d_type;
-                        list_add_tail (&stub_entry->list,
-                                       &args->entries.list);
-                }
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            stub_entry = gf_dirent_for_name(entry->d_name);
+            if (!stub_entry)
+                goto out;
+            stub_entry->d_off = entry->d_off;
+            stub_entry->d_ino = entry->d_ino;
+            stub_entry->d_type = entry->d_type;
+            list_add_tail(&stub_entry->list, &args->entries.list);
         }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-args_rchecksum_store (default_args_t *args,
-                      fd_t *fd, off_t offset, int32_t len, dict_t *xdata)
+args_rchecksum_store(default_args_t *args, fd_t *fd, off_t offset, int32_t len,
+                     dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->offset = offset;
-        args->size    = len;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    args->fd = fd_ref(fd);
+    args->offset = offset;
+    args->size = len;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_rchecksum_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        uint32_t weak_checksum, uint8_t *strong_checksum,
-                        dict_t *xdata)
+args_rchecksum_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, uint32_t weak_checksum,
+                         uint8_t *strong_checksum, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0) {
-                args->weak_checksum =
-                        weak_checksum;
-                args->strong_checksum =
-                        memdup (strong_checksum, MD5_DIGEST_LENGTH);
-        }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0) {
+        args->weak_checksum = weak_checksum;
+        args->strong_checksum = gf_memdup(strong_checksum,
+                                          SHA256_DIGEST_LENGTH);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_xattrop_store (default_args_t *args,
-                    loc_t *loc, gf_xattrop_flags_t optype,
-                    dict_t *xattr, dict_t *xdata)
+args_xattrop_store(default_args_t *args, loc_t *loc, gf_xattrop_flags_t optype,
+                   dict_t *xattr, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        args->optype = optype;
-        args->xattr = dict_ref (xattr);
+    args->optype = optype;
+    args->xattr = dict_ref(xattr);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
-
 int
-args_xattrop_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                        int32_t op_errno, dict_t *xattr, dict_t *xdata)
+args_xattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xattr)
-                args->xattr = dict_ref (xattr);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_fxattrop_store (default_args_t *args,
-                     fd_t *fd, gf_xattrop_flags_t optype,
-                     dict_t *xattr, dict_t *xdata)
+args_fxattrop_store(default_args_t *args, fd_t *fd, gf_xattrop_flags_t optype,
+                    dict_t *xattr, dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        args->optype = optype;
-        args->xattr = dict_ref (xattr);
+    args->optype = optype;
+    args->xattr = dict_ref(xattr);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fxattrop_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+args_fxattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xattr)
-                args->xattr = dict_ref (xattr);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_setattr_store (default_args_t *args,
-                    loc_t *loc, struct iatt *stbuf,
-                    int32_t valid, dict_t *xdata)
+args_setattr_store(default_args_t *args, loc_t *loc, struct iatt *stbuf,
+                   int32_t valid, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (stbuf)
-                args->stat = *stbuf;
+    if (stbuf)
+        args->stat = *stbuf;
 
-        args->valid = valid;
+    args->valid = valid;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_setattr_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt *statpre, struct iatt *statpost,
-                      dict_t *xdata)
+args_setattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_fsetattr_store (default_args_t *args,
-                     fd_t *fd, struct iatt *stbuf,
-                     int32_t valid, dict_t *xdata)
+args_fsetattr_store(default_args_t *args, fd_t *fd, struct iatt *stbuf,
+                    int32_t valid, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        if (stbuf)
-                args->stat = *stbuf;
+    if (stbuf)
+        args->stat = *stbuf;
 
-        args->valid = valid;
+    args->valid = valid;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 int
-args_fsetattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata)
+args_fsetattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fallocate_store (default_args_t *args, fd_t *fd,
-                      int32_t mode, off_t offset, size_t len, dict_t *xdata)
+args_fallocate_store(default_args_t *args, fd_t *fd, int32_t mode, off_t offset,
+                     size_t len, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-	args->flags = mode;
-	args->offset = offset;
-	args->size = len;
+    args->flags = mode;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fallocate_cbk_store(default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata)
+args_fallocate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *statpre,
+                         struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_discard_store (default_args_t *args, fd_t *fd,
-		    off_t offset, size_t len, dict_t *xdata)
+args_discard_store(default_args_t *args, fd_t *fd, off_t offset, size_t len,
+                   dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-	args->offset = offset;
-	args->size = len;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_discard_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+args_discard_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_zerofill_store (default_args_t *args, fd_t *fd,
-                     off_t offset, off_t len, dict_t *xdata)
+args_zerofill_store(default_args_t *args, fd_t *fd, off_t offset, off_t len,
+                    dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = offset;
-        args->size = len;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_zerofill_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+args_zerofill_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ipc_store (default_args_t *args,
-                int32_t op, dict_t *xdata)
+args_ipc_store(default_args_t *args, int32_t op, dict_t *xdata)
 {
-        args->cmd = op;
+    args->cmd = op;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_ipc_cbk_store (default_args_cbk_t *args,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_ipc_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_seek_store (default_args_t *args, fd_t *fd,
-                 off_t offset, gf_seek_what_t what, dict_t *xdata)
+args_seek_store(default_args_t *args, fd_t *fd, off_t offset,
+                gf_seek_what_t what, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = offset;
-        args->what = what;
+    args->offset = offset;
+    args->what = what;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_seek_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                     int32_t op_errno, off_t offset, dict_t *xdata)
+args_seek_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    off_t offset, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        args->offset = offset;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    args->offset = offset;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_getactivelk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      lock_migration_info_t *locklist, dict_t *xdata)
+args_getactivelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, lock_migration_info_t *locklist,
+                           dict_t *xdata)
 {
-        lock_migration_info_t  *stub_entry = NULL, *entry = NULL;
-        int     ret = 0;
+    lock_migration_info_t *stub_entry = NULL, *entry = NULL;
+    int ret = 0;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        /*op_ret needs to carry the number of locks present in the list*/
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &locklist->list, list) {
-                        stub_entry = GF_CALLOC (1, sizeof (*stub_entry),
-                                                gf_common_mt_char);
-                        if (!stub_entry) {
-                               ret = -1;
-                               goto out;
-                        }
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    /*op_ret needs to carry the number of locks present in the list*/
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &locklist->list, list)
+        {
+            stub_entry = GF_CALLOC(1, sizeof(*stub_entry), gf_common_mt_char);
+            if (!stub_entry) {
+                ret = -1;
+                goto out;
+            }
 
-                        INIT_LIST_HEAD (&stub_entry->list);
-                        stub_entry->flock = entry->flock;
+            INIT_LIST_HEAD(&stub_entry->list);
+            stub_entry->flock = entry->flock;
 
-                        stub_entry->lk_flags = entry->lk_flags;
+            stub_entry->lk_flags = entry->lk_flags;
 
-                        stub_entry->client_uid = gf_strdup (entry->client_uid);
-                        if (!stub_entry->client_uid) {
-                                GF_FREE (stub_entry);
-                                ret = -1;
-                                goto out;
-                        }
+            stub_entry->client_uid = gf_strdup(entry->client_uid);
+            if (!stub_entry->client_uid) {
+                GF_FREE(stub_entry);
+                ret = -1;
+                goto out;
+            }
 
-                        list_add_tail (&stub_entry->list,
-                                       &args->locklist.list);
-                }
+            list_add_tail(&stub_entry->list, &args->locklist.list);
         }
+    }
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return ret;
+    return ret;
 }
 
 int
-args_setactivelk_store (default_args_t *args, loc_t *loc,
-                          lock_migration_info_t *locklist, dict_t *xdata)
+args_setactivelk_store(default_args_t *args, loc_t *loc,
+                       lock_migration_info_t *locklist, dict_t *xdata)
 {
-        lock_migration_info_t  *stub_entry = NULL, *entry = NULL;
-        int     ret = 0;
+    lock_migration_info_t *stub_entry = NULL, *entry = NULL;
+    int ret = 0;
 
-        list_for_each_entry (entry, &locklist->list, list) {
-                stub_entry = GF_CALLOC (1, sizeof (*stub_entry),
-                                        gf_common_mt_lock_mig);
-                if (!stub_entry) {
-                       ret = -1;
-                       goto out;
-                }
-
-                INIT_LIST_HEAD (&stub_entry->list);
-                stub_entry->flock = entry->flock;
+    list_for_each_entry(entry, &locklist->list, list)
+    {
+        stub_entry = GF_CALLOC(1, sizeof(*stub_entry), gf_common_mt_lock_mig);
+        if (!stub_entry) {
+            ret = -1;
+            goto out;
+        }
 
-                stub_entry->lk_flags = entry->lk_flags;
+        INIT_LIST_HEAD(&stub_entry->list);
+        stub_entry->flock = entry->flock;
 
-                stub_entry->client_uid = gf_strdup (entry->client_uid);
-                if (!stub_entry->client_uid) {
-                        GF_FREE (stub_entry);
-                        ret = -1;
-                        goto out;
-                }
+        stub_entry->lk_flags = entry->lk_flags;
 
-                list_add_tail (&stub_entry->list,
-                               &args->locklist.list);
+        stub_entry->client_uid = gf_strdup(entry->client_uid);
+        if (!stub_entry->client_uid) {
+            GF_FREE(stub_entry);
+            ret = -1;
+            goto out;
         }
 
-        loc_copy (&args->loc, loc);
+        list_add_tail(&stub_entry->list, &args->locklist.list);
+    }
+
+    loc_copy(&args->loc, loc);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-args_lease_store (default_args_t *args, loc_t *loc, struct gf_lease *lease,
-                  dict_t *xdata)
+args_lease_store(default_args_t *args, loc_t *loc, struct gf_lease *lease,
+                 dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->lease = *lease;
+    loc_copy(&args->loc, loc);
+    args->lease = *lease;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return;
+    return;
 }
 
 void
-args_lease_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
+args_lease_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
                      struct gf_lease *lease, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->lease = *lease;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->lease = *lease;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 }
 
-void
-args_cbk_wipe (default_args_cbk_t *args_cbk)
+int
+args_icreate_store(default_args_t *args, loc_t *loc, mode_t mode, dict_t *xdata)
 {
-        if (!args_cbk)
-                return;
-        if (args_cbk->inode)
-                inode_unref (args_cbk->inode);
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
 
-        GF_FREE ((char *)args_cbk->buf);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
+}
 
-        GF_FREE (args_cbk->vector);
+int
+args_namelink_store(default_args_t *args, loc_t *loc, dict_t *xdata)
+{
+    loc_copy(&args->loc, loc);
 
-        if (args_cbk->iobref)
-                iobref_unref (args_cbk->iobref);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
+}
 
-        if (args_cbk->fd)
-                fd_unref (args_cbk->fd);
+int
+args_copy_file_range_store(default_args_t *args, fd_t *fd_in, off64_t off_in,
+                           fd_t *fd_out, off64_t off_out, size_t len,
+                           uint32_t flags, dict_t *xdata)
+{
+    if (fd_in)
+        args->fd = fd_ref(fd_in);
+    if (fd_out)
+        args->fd_dst = fd_ref(fd_out);
+    args->size = len;
+    args->off_in = off_in;
+    args->off_out = off_out;
+    args->flags = flags;
 
-        if (args_cbk->xattr)
-                dict_unref (args_cbk->xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        GF_FREE (args_cbk->strong_checksum);
+    return 0;
+}
 
-        if (args_cbk->xdata)
-                dict_unref (args_cbk->xdata);
+int
+args_copy_file_range_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                               int32_t op_errno, struct iatt *stbuf,
+                               struct iatt *prebuf_dst,
+                               struct iatt *postbuf_dst, dict_t *xdata)
+{
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0) {
+        if (postbuf_dst)
+            args->poststat = *postbuf_dst;
+        if (prebuf_dst)
+            args->prestat = *prebuf_dst;
+        if (stbuf)
+            args->stat = *stbuf;
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (!list_empty (&args_cbk->entries.list))
-                gf_dirent_free (&args_cbk->entries);
+    return 0;
 }
 
 void
-args_wipe (default_args_t *args)
+args_cbk_wipe(default_args_cbk_t *args_cbk)
 {
-        if (!args)
-                return;
+    if (!args_cbk)
+        return;
+    if (args_cbk->inode)
+        inode_unref(args_cbk->inode);
+
+    GF_FREE((char *)args_cbk->buf);
+
+    GF_FREE(args_cbk->vector);
+
+    if (args_cbk->iobref)
+        iobref_unref(args_cbk->iobref);
+
+    if (args_cbk->fd)
+        fd_unref(args_cbk->fd);
 
-        loc_wipe (&args->loc);
+    if (args_cbk->xattr)
+        dict_unref(args_cbk->xattr);
+
+    GF_FREE(args_cbk->strong_checksum);
+
+    if (args_cbk->xdata)
+        dict_unref(args_cbk->xdata);
+
+    if (!list_empty(&args_cbk->entries.list))
+        gf_dirent_free(&args_cbk->entries);
+}
+
+void
+args_wipe(default_args_t *args)
+{
+    if (!args)
+        return;
 
-        loc_wipe (&args->loc2);
+    loc_wipe(&args->loc);
 
-        if (args->fd)
-                fd_unref (args->fd);
+    loc_wipe(&args->loc2);
 
-        GF_FREE ((char *)args->linkname);
+    if (args->fd)
+        fd_unref(args->fd);
 
-	GF_FREE (args->vector);
+    GF_FREE((char *)args->linkname);
 
-        if (args->iobref)
-                iobref_unref (args->iobref);
+    GF_FREE(args->vector);
 
-        if (args->xattr)
-                dict_unref (args->xattr);
+    if (args->iobref)
+        iobref_unref(args->iobref);
 
-        if (args->xdata)
-                dict_unref (args->xdata);
+    if (args->xattr)
+        dict_unref(args->xattr);
 
-	GF_FREE ((char *)args->name);
+    if (args->xdata)
+        dict_unref(args->xdata);
 
-	GF_FREE ((char *)args->volume);
+    GF_FREE((char *)args->name);
 
+    GF_FREE((char *)args->volume);
 }
 
 void
-args_cbk_init (default_args_cbk_t *args_cbk)
+args_cbk_init(default_args_cbk_t *args_cbk)
 {
-        INIT_LIST_HEAD (&args_cbk->entries);
+    INIT_LIST_HEAD(&args_cbk->entries);
 }
diff --git a/libglusterfs/src/default-args.h b/libglusterfs/src/default-args.h
deleted file mode 100644
index a2201dd4703..00000000000
--- a/libglusterfs/src/default-args.h
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
-  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-/* libglusterfs/src/defaults.h:
-       This file contains definition of default fops and mops functions.
-*/
-
-#ifndef _DEFAULT_ARGS_H
-#define _DEFAULT_ARGS_H
-
-#include "xlator.h"
-
-int
-args_lookup_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     inode_t *inode, struct iatt *buf,
-                     dict_t *xdata, struct iatt *postparent);
-
-
-int
-args_stat_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   struct iatt *buf, dict_t *xdata);
-
-int
-args_fstat_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *buf, dict_t *xdata);
-
-int
-args_truncate_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata);
-
-
-int
-args_ftruncate_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata);
-
-
-int
-args_access_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int
-args_readlink_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       const char *path, struct iatt *stbuf, dict_t *xdata);
-
-int
-args_mknod_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                    int32_t op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata);
-
-int
-args_mkdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-int
-args_unlink_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata);
-
-int
-args_rmdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata);
-
-int
-args_symlink_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata);
-
-
-int
-args_rename_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-                     dict_t *xdata);
-
-int
-args_link_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   inode_t *inode, struct iatt *buf,
-                   struct iatt *preparent, struct iatt *postparent,
-                   dict_t *xdata);
-
-int
-args_create_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata);
-
-int
-args_open_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   fd_t *fd, dict_t *xdata);
-
-int
-args_readv_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                    int32_t count, struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata);
-
-int
-args_writev_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata);
-
-
-int
-args_flush_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int
-args_fsync_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata);
-
-int
-args_opendir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      fd_t *fd, dict_t *xdata);
-
-int
-args_fsyncdir_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_statfs_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct statvfs *buf, dict_t *xdata);
-
-int
-args_setxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret,
-                       int32_t op_errno, dict_t *xdata);
-
-int
-args_getxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata);
-
-int
-args_fsetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_fgetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata);
-
-int
-args_removexattr_cbk_store (default_args_cbk_t *args,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_fremovexattr_cbk_store (default_args_cbk_t *args,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_lk_cbk_store (default_args_cbk_t *args,
-                 int32_t op_ret, int32_t op_errno,
-                 struct gf_flock *lock, dict_t *xdata);
-
-
-int
-args_inodelk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_finodelk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_entrylk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_fentrylk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int
-args_readdirp_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata);
-
-
-int
-args_readdir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      gf_dirent_t *entries, dict_t *xdata);
-
-
-int
-args_rchecksum_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        uint32_t weak_checksum, uint8_t *strong_checksum,
-                        dict_t *xdata);
-
-
-int
-args_xattrop_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                        int32_t op_errno, dict_t *xattr, dict_t *xdata);
-
-
-int
-args_fxattrop_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata);
-
-int
-args_setattr_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt *statpre, struct iatt *statpost,
-                      dict_t *xdata);
-
-
-int
-args_fsetattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata);
-
-int
-args_fallocate_cbk_store(default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata);
-
-int
-args_discard_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata);
-
-int
-args_zerofill_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata);
-
-int
-args_ipc_cbk_store (default_args_cbk_t *args,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-args_seek_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                     int32_t op_errno, off_t offset, dict_t *xdata);
-
-void
-args_lease_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct gf_lease *lease, dict_t *xdata);
-
-void
-args_cbk_wipe (default_args_cbk_t *args_cbk);
-
-void
-args_wipe (default_args_t *args);
-
-int
-args_lookup_store (default_args_t *args, loc_t *loc,
-                   dict_t *xdata);
-
-int
-args_stat_store (default_args_t *args, loc_t *loc, dict_t *xdata);
-
-int
-args_fstat_store (default_args_t *args, fd_t *fd, dict_t *xdata);
-
-int
-args_truncate_store (default_args_t *args, loc_t *loc, off_t off,
-                     dict_t *xdata);
-int
-args_ftruncate_store (default_args_t *args, fd_t *fd, off_t off,
-                      dict_t *xdata);
-
-int
-args_access_store (default_args_t *args, loc_t *loc, int32_t mask,
-                   dict_t *xdata);
-
-int
-args_readlink_store (default_args_t *args, loc_t *loc, size_t size,
-                     dict_t *xdata);
-
-int
-args_mknod_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  dev_t rdev, mode_t umask, dict_t *xdata);
-
-int
-args_mkdir_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  mode_t umask, dict_t *xdata);
-
-int
-args_unlink_store (default_args_t *args, loc_t *loc, int xflag, dict_t *xdata);
-
-int
-args_rmdir_store (default_args_t *args, loc_t *loc, int flags, dict_t *xdata);
-
-int
-args_symlink_store (default_args_t *args, const char *linkname, loc_t *loc,
-                   mode_t umask, dict_t *xdata);
-
-int
-args_rename_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                   dict_t *xdata);
-
-int
-args_link_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                 dict_t *xdata);
-
-int
-args_create_store (default_args_t *args,
-                  loc_t *loc, int32_t flags, mode_t mode,
-                  mode_t umask, fd_t *fd, dict_t *xdata);
-
-int
-args_open_store (default_args_t *args, loc_t *loc, int32_t flags,
-                 fd_t *fd, dict_t *xdata);
-
-int
-args_readv_store (default_args_t *args, fd_t *fd, size_t size, off_t off,
-                  uint32_t flags, dict_t *xdata);
-
-int
-args_writev_store (default_args_t *args, fd_t *fd, struct iovec *vector,
-                   int32_t count, off_t off, uint32_t flags,
-                   struct iobref *iobref, dict_t *xdata);
-
-int
-args_flush_store (default_args_t *args, fd_t *fd, dict_t *xdata);
-
-int
-args_fsync_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                  dict_t *xdata);
-
-int
-args_opendir_store (default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata);
-
-int
-args_fsyncdir_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                     dict_t *xdata);
-
-int
-args_statfs_store (default_args_t *args, loc_t *loc, dict_t *xdata);
-
-int
-args_setxattr_store (default_args_t *args,
-                     loc_t *loc, dict_t *dict,
-                     int32_t flags, dict_t *xdata);
-
-int
-args_getxattr_store (default_args_t *args,
-                     loc_t *loc, const char *name, dict_t *xdata);
-
-int
-args_fsetxattr_store (default_args_t *args,
-                      fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata);
-
-int
-args_fgetxattr_store (default_args_t *args,
-                      fd_t *fd, const char *name, dict_t *xdata);
-
-int
-args_removexattr_store (default_args_t *args,
-                        loc_t *loc, const char *name, dict_t *xdata);
-
-int
-args_fremovexattr_store (default_args_t *args,
-                         fd_t *fd, const char *name, dict_t *xdata);
-
-int
-args_lk_store (default_args_t *args,
-               fd_t *fd, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata);
-
-int
-args_inodelk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, int32_t cmd,
-                    struct gf_flock *lock, dict_t *xdata);
-
-int
-args_finodelk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, int32_t cmd,
-                     struct gf_flock *lock, dict_t *xdata);
-
-int
-args_entrylk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, const char *name,
-                    entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-int
-args_fentrylk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, const char *name,
-                     entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-int
-args_readdirp_store (default_args_t *args,
-                     fd_t *fd, size_t size, off_t off, dict_t *xdata);
-
-int
-args_readdir_store (default_args_t *args,
-                    fd_t *fd, size_t size,
-                    off_t off, dict_t *xdata);
-
-int
-args_rchecksum_store (default_args_t *args,
-                      fd_t *fd, off_t offset, int32_t len, dict_t *xdata);
-
-int
-args_xattrop_store (default_args_t *args,
-                    loc_t *loc, gf_xattrop_flags_t optype,
-                    dict_t *xattr, dict_t *xdata);
-
-int
-args_fxattrop_store (default_args_t *args,
-                     fd_t *fd, gf_xattrop_flags_t optype,
-                     dict_t *xattr, dict_t *xdata);
-
-int
-args_setattr_store (default_args_t *args,
-                    loc_t *loc, struct iatt *stbuf,
-                    int32_t valid, dict_t *xdata);
-
-int
-args_fsetattr_store (default_args_t *args,
-                     fd_t *fd, struct iatt *stbuf,
-                     int32_t valid, dict_t *xdata);
-
-int
-args_fallocate_store (default_args_t *args, fd_t *fd,
-                      int32_t mode, off_t offset, size_t len, dict_t *xdata);
-
-int
-args_discard_store (default_args_t *args, fd_t *fd,
-		    off_t offset, size_t len, dict_t *xdata);
-
-int
-args_zerofill_store (default_args_t *args, fd_t *fd,
-                     off_t offset, off_t len, dict_t *xdata);
-
-int
-args_ipc_store (default_args_t *args,
-                int32_t op, dict_t *xdata);
-
-int
-args_seek_store (default_args_t *args, fd_t *fd,
-                 off_t offset, gf_seek_what_t what, dict_t *xdata);
-
-void
-args_lease_store (default_args_t *args, loc_t *loc, struct gf_lease *lease,
-                  dict_t *xdata);
-
-int
-args_getactivelk_cbk_store (default_args_cbk_t *args,
-                             int32_t op_ret, int32_t op_errno,
-                             lock_migration_info_t *locklist, dict_t *xdata);
-
-int
-args_setactivelk_store (default_args_t *args, loc_t *loc,
-                          lock_migration_info_t *locklist, dict_t *xdata);
-void
-args_cbk_init (default_args_cbk_t *args_cbk);
-#endif /* _DEFAULT_ARGS_H */
diff --git a/libglusterfs/src/defaults-tmpl.c b/libglusterfs/src/defaults-tmpl.c
index 0ef14d5c68e..3cf707f42aa 100644
--- a/libglusterfs/src/defaults-tmpl.c
+++ b/libglusterfs/src/defaults-tmpl.c
@@ -11,7 +11,7 @@
 /* libglusterfs/src/defaults.c:
    This file contains functions, which are used to fill the 'fops', 'cbk'
    structures in the xlator structures, if they are not written. Here, all the
-   function calls are plainly forwared to the first child of the xlator, and
+   function calls are plainly forwarded to the first child of the xlator, and
    all the *_cbk function does plain STACK_UNWIND of the frame, and returns.
 
    This function also implements *_resume () functions, which does same
@@ -25,201 +25,223 @@
 #include "config.h"
 #endif
 
-#include "xlator.h"
-#include "defaults.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/defaults.h"
 
 #pragma generate
 
 struct xlator_fops _default_fops = {
-        .create = default_create,
-        .open = default_open,
-        .stat = default_stat,
-        .readlink = default_readlink,
-        .mknod = default_mknod,
-        .mkdir = default_mkdir,
-        .unlink = default_unlink,
-        .rmdir = default_rmdir,
-        .symlink = default_symlink,
-        .rename = default_rename,
-        .link = default_link,
-        .truncate = default_truncate,
-        .readv = default_readv,
-        .writev = default_writev,
-        .statfs = default_statfs,
-        .flush = default_flush,
-        .fsync = default_fsync,
-        .setxattr = default_setxattr,
-        .getxattr = default_getxattr,
-        .fsetxattr = default_fsetxattr,
-        .fgetxattr = default_fgetxattr,
-        .removexattr = default_removexattr,
-        .fremovexattr = default_fremovexattr,
-        .opendir = default_opendir,
-        .readdir = default_readdir,
-        .readdirp = default_readdirp,
-        .fsyncdir = default_fsyncdir,
-        .access = default_access,
-        .ftruncate = default_ftruncate,
-        .fstat = default_fstat,
-        .lk = default_lk,
-        .inodelk = default_inodelk,
-        .finodelk = default_finodelk,
-        .entrylk = default_entrylk,
-        .fentrylk = default_fentrylk,
-        .lookup = default_lookup,
-        .rchecksum = default_rchecksum,
-        .xattrop = default_xattrop,
-        .fxattrop = default_fxattrop,
-        .setattr = default_setattr,
-        .fsetattr = default_fsetattr,
-	.fallocate = default_fallocate,
-	.discard = default_discard,
-        .zerofill = default_zerofill,
-        .ipc = default_ipc,
-        .seek = default_seek,
-
-        .getspec = default_getspec,
-        .getactivelk = default_getactivelk,
-        .setactivelk = default_setactivelk,
+    .create = default_create,
+    .open = default_open,
+    .stat = default_stat,
+    .readlink = default_readlink,
+    .mknod = default_mknod,
+    .mkdir = default_mkdir,
+    .unlink = default_unlink,
+    .rmdir = default_rmdir,
+    .symlink = default_symlink,
+    .rename = default_rename,
+    .link = default_link,
+    .truncate = default_truncate,
+    .readv = default_readv,
+    .writev = default_writev,
+    .statfs = default_statfs,
+    .flush = default_flush,
+    .fsync = default_fsync,
+    .setxattr = default_setxattr,
+    .getxattr = default_getxattr,
+    .fsetxattr = default_fsetxattr,
+    .fgetxattr = default_fgetxattr,
+    .removexattr = default_removexattr,
+    .fremovexattr = default_fremovexattr,
+    .opendir = default_opendir,
+    .readdir = default_readdir,
+    .readdirp = default_readdirp,
+    .fsyncdir = default_fsyncdir,
+    .access = default_access,
+    .ftruncate = default_ftruncate,
+    .fstat = default_fstat,
+    .lk = default_lk,
+    .inodelk = default_inodelk,
+    .finodelk = default_finodelk,
+    .entrylk = default_entrylk,
+    .fentrylk = default_fentrylk,
+    .lookup = default_lookup,
+    .rchecksum = default_rchecksum,
+    .xattrop = default_xattrop,
+    .fxattrop = default_fxattrop,
+    .setattr = default_setattr,
+    .fsetattr = default_fsetattr,
+    .fallocate = default_fallocate,
+    .discard = default_discard,
+    .zerofill = default_zerofill,
+    .ipc = default_ipc,
+    .seek = default_seek,
+
+    .getspec = default_getspec,
+    .getactivelk = default_getactivelk,
+    .setactivelk = default_setactivelk,
+    .put = default_put,
+    .icreate = default_icreate,
+    .namelink = default_namelink,
+    .copy_file_range = default_copy_file_range,
 };
 struct xlator_fops *default_fops = &_default_fops;
 
-
 /*
  * Remaining functions don't follow the fop calling conventions, so they're
  * not generated.
  */
 
 int32_t
-default_forget (xlator_t *this, inode_t *inode)
+default_forget(xlator_t *this, inode_t *inode)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement forget_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement forget_cbk");
+    return 0;
 }
 
-
 int32_t
-default_releasedir (xlator_t *this, fd_t *fd)
+default_releasedir(xlator_t *this, fd_t *fd)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement releasedir_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement releasedir_cbk");
+    return 0;
 }
 
 int32_t
-default_release (xlator_t *this, fd_t *fd)
+default_release(xlator_t *this, fd_t *fd)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement release_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement release_cbk");
+    return 0;
 }
 
 /* notify */
 int
-default_notify (xlator_t *this, int32_t event, void *data, ...)
+default_notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        switch (event) {
-        case GF_EVENT_PARENT_UP:
-        case GF_EVENT_PARENT_DOWN:
-        {
-                xlator_list_t *list = this->children;
+    GF_UNUSED int ret = 0;
+    xlator_t *victim = data;
 
-                while (list) {
-                        xlator_notify (list->xlator, event, this);
-                        list = list->next;
-                }
-        }
-        break;
+    glusterfs_graph_t *graph = NULL;
+
+    GF_VALIDATE_OR_GOTO("notify", this, out);
+    graph = this->graph;
+    GF_VALIDATE_OR_GOTO(this->name, graph, out);
+
+    switch (event) {
+        case GF_EVENT_PARENT_UP:
+        case GF_EVENT_PARENT_DOWN: {
+            xlator_list_t *list = this->children;
+
+            while (list) {
+                if (victim && victim->cleanup_starting)
+                    xlator_notify(list->xlator, event, victim);
+                else
+                    xlator_notify(list->xlator, event, this);
+                list = list->next;
+            }
+        } break;
         case GF_EVENT_CHILD_CONNECTING:
         case GF_EVENT_CHILD_DOWN:
         case GF_EVENT_CHILD_UP:
-        case GF_EVENT_AUTH_FAILED:
-        {
-                xlator_list_t *parent = this->parents;
-
-                /*
-                 * Handle case of CHILD_* & AUTH_FAILED event specially, send
-                 * it to fuse.
-                 */
-                if (!parent && this->ctx && this->ctx->master) {
-                        xlator_notify (this->ctx->master, event, this->graph,
-                                       NULL);
-                }
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               this, NULL);
-                        parent = parent->next;
+        case GF_EVENT_AUTH_FAILED: {
+            xlator_list_t *parent = this->parents;
+
+            /*
+             * Handle case of CHILD_* & AUTH_FAILED event specially, send
+             * it to fuse.
+             */
+            if (!parent && this->ctx && this->ctx->master) {
+                xlator_notify(this->ctx->master, event, this->graph, NULL);
+            }
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, this, NULL);
+                parent = parent->next;
+            }
+
+            if (event == GF_EVENT_CHILD_DOWN &&
+                !(this->ctx && this->ctx->master) && (graph->top == this)) {
+                /* Make sure this is not a daemon with master xlator */
+                pthread_mutex_lock(&graph->mutex);
+                {
+                    if (graph->parent_down ==
+                        graph_total_client_xlator(graph)) {
+                        graph->used = 0;
+                        pthread_cond_broadcast(&graph->child_down_cond);
+                    }
                 }
+                pthread_mutex_unlock(&graph->mutex);
+            }
+        } break;
+        case GF_EVENT_UPCALL: {
+            xlator_list_t *parent = this->parents;
+
+            if (!parent && this->ctx && this->ctx->master)
+                xlator_notify(this->ctx->master, event, data, NULL);
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, data, NULL);
+                parent = parent->next;
+            }
+        } break;
+        case GF_EVENT_CHILD_PING: {
+            xlator_list_t *parent = this->parents;
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    XLATOR_NOTIFY(ret, parent->xlator, event, this, data);
+                parent = parent->next;
+            }
+        } break;
+        case GF_EVENT_CLEANUP: {
+            xlator_list_t *list = this->children;
+
+            while (list) {
+                xlator_notify(list->xlator, event, this);
+                list = list->next;
+            }
+        } break;
+
+        default: {
+            xlator_list_t *parent = this->parents;
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, this, NULL);
+                parent = parent->next;
+            }
         }
-        break;
-        case GF_EVENT_UPCALL:
-        {
-                xlator_list_t *parent = this->parents;
-
-                if (!parent && this->ctx && this->ctx->master)
-                        xlator_notify (this->ctx->master, event, data, NULL);
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               data, NULL);
-                        parent = parent->next;
-                }
-        }
-        break;
-        case GF_EVENT_CHILD_PING:
-        {
-                xlator_list_t *parent = this->parents;
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               this, data);
-                        parent = parent->next;
-                }
-        }
-        break;
-        case GF_EVENT_CLEANUP:
-        {
-                xlator_list_t *list = this->children;
-
-                while (list) {
-                        xlator_notify (list->xlator, event, this);
-                        list = list->next;
-                }
-        }
-        break;
-
-        default:
-        {
-                xlator_list_t *parent = this->parents;
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               this, NULL);
-                        parent = parent->next;
-                }
-        }
-        /*
-         * Apparently our picky-about-everything else coding standard allows
-         * adjacent same-indendation-level close braces.  Clearly it has
-         * nothing to do with readability.
-         */
-        }
-
-        return 0;
+            /*
+             * Apparently our picky-about-everything else coding standard allows
+             * adjacent same-indendation-level close braces.  Clearly it has
+             * nothing to do with readability.
+             */
+    }
+out:
+    return 0;
 }
 
 int32_t
-default_mem_acct_init (xlator_t *this)
+default_mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_common_mt_end);
+    ret = xlator_mem_acct_init(this, gf_common_mt_end);
 
-        return ret;
+    return ret;
+}
+
+void
+default_fini(xlator_t *this)
+{
+    if (this && this->private)
+        GF_FREE(this->private);
 }
diff --git a/libglusterfs/src/defaults.h b/libglusterfs/src/defaults.h
deleted file mode 100644
index 50f1909b90b..00000000000
--- a/libglusterfs/src/defaults.h
+++ /dev/null
@@ -1,1300 +0,0 @@
-/*
-  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-/* libglusterfs/src/defaults.h:
-       This file contains definition of default fops and mops functions.
-*/
-
-#ifndef _DEFAULTS_H
-#define _DEFAULTS_H
-
-#include "xlator.h"
-
-typedef struct {
-        int op_ret;
-        int op_errno;
-        inode_t *inode;
-        struct iatt stat;
-        struct iatt prestat;
-        struct iatt poststat;
-        struct iatt preparent;   /* @preoldparent in rename_cbk */
-        struct iatt postparent;  /* @postoldparent in rename_cbk */
-        struct iatt preparent2;  /* @prenewparent in rename_cbk */
-        struct iatt postparent2; /* @postnewparent in rename_cbk */
-        const char *buf;
-        struct iovec *vector;
-        int count;
-        struct iobref *iobref;
-        fd_t *fd;
-        struct statvfs statvfs;
-        dict_t *xattr;
-        struct gf_flock lock;
-        uint32_t weak_checksum;
-        uint8_t *strong_checksum;
-        dict_t *xdata;
-        gf_dirent_t entries;
-        off_t offset;            /* seek hole/data */
-        int valid; /* If the response is valid or not. For call-stub it is
-                      always valid irrespective of this */
-        struct gf_lease lease;
-        lock_migration_info_t locklist;
-} default_args_cbk_t;
-
-typedef struct {
-        loc_t loc; /* @old in rename(), link() */
-        loc_t loc2; /* @new in rename(), link() */
-        fd_t *fd;
-        off_t offset;
-        int mask;
-        size_t size;
-        mode_t mode;
-        dev_t rdev;
-        mode_t umask;
-        int xflag;
-        int flags;
-        const char *linkname;
-        struct iovec *vector;
-        int count;
-        struct iobref *iobref;
-        int datasync;
-        dict_t *xattr;
-        const char *name;
-        int cmd;
-        struct gf_flock lock;
-        const char *volume;
-        entrylk_cmd entrylkcmd;
-        entrylk_type entrylktype;
-        gf_xattrop_flags_t optype;
-        int valid;
-        struct iatt stat;
-        gf_seek_what_t what;
-        dict_t *xdata;
-        struct gf_lease lease;
-        lock_migration_info_t locklist;
-} default_args_t;
-
-typedef struct {
-        int             fop_enum;
-        unsigned int    fop_length;
-        int             *enum_list;
-        default_args_t  *req_list;
-        dict_t          *xdata;
-} compound_args_t;
-
-typedef struct {
-        int                fop_enum;
-        unsigned int       fop_length;
-        int                *enum_list;
-        default_args_cbk_t *rsp_list;
-        dict_t             *xdata;
-} compound_args_cbk_t;
-
-int32_t default_notify (xlator_t *this,
-                        int32_t event,
-                        void *data,
-                        ...);
-
-int32_t default_forget (xlator_t *this, inode_t *inode);
-
-int32_t default_release (xlator_t *this, fd_t *fd);
-
-int32_t default_releasedir (xlator_t *this, fd_t *fd);
-
-
-extern struct xlator_fops *default_fops;
-
-/* Management Operations */
-
-int32_t default_getspec (call_frame_t *frame,
-                         xlator_t *this,
-                         const char *key,
-                         int32_t flag);
-
-int32_t default_rchecksum (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd, off_t offset,
-                           int32_t len, dict_t *xdata);
-
-/* FileSystem operations */
-int32_t default_lookup (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc,
-                        dict_t *xdata);
-
-int32_t default_stat (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t *loc, dict_t *xdata);
-
-int32_t default_fstat (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd, dict_t *xdata);
-
-int32_t default_truncate (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          off_t offset, dict_t *xdata);
-
-int32_t default_ftruncate (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           off_t offset, dict_t *xdata);
-
-int32_t default_access (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc,
-                        int32_t mask, dict_t *xdata);
-
-int32_t default_readlink (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          size_t size, dict_t *xdata);
-
-int32_t default_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata);
-
-int32_t default_mkdir (call_frame_t *frame, xlator_t *this,
-                       loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata);
-
-int32_t default_unlink (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc, int xflag, dict_t *xdata);
-
-int32_t default_rmdir (call_frame_t *frame, xlator_t *this,
-                       loc_t *loc, int xflag, dict_t *xdata);
-
-int32_t default_symlink (call_frame_t *frame, xlator_t *this,
-                         const char *linkpath, loc_t *loc, mode_t umask,
-                         dict_t *xdata);
-
-int32_t default_rename (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *oldloc,
-                        loc_t *newloc, dict_t *xdata);
-
-int32_t default_link (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t *oldloc,
-                      loc_t *newloc, dict_t *xdata);
-
-int32_t default_create (call_frame_t *frame, xlator_t *this,
-                        loc_t *loc, int32_t flags, mode_t mode,
-                        mode_t umask, fd_t *fd, dict_t *xdata);
-
-int32_t default_open (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t *loc,
-                      int32_t flags, fd_t *fd,
-                      dict_t *xdata);
-
-int32_t default_readv (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd,
-                       size_t size,
-                       off_t offset,
-                       uint32_t flags, dict_t *xdata);
-
-int32_t default_writev (call_frame_t *frame,
-                        xlator_t *this,
-                        fd_t *fd,
-                        struct iovec *vector,
-                        int32_t count,
-                        off_t offset,
-                        uint32_t flags,
-                        struct iobref *iobref, dict_t *xdata);
-
-int32_t default_flush (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd, dict_t *xdata);
-
-int32_t default_fsync (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd,
-                       int32_t datasync, dict_t *xdata);
-
-int32_t default_opendir (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc, fd_t *fd, dict_t *xdata);
-
-int32_t default_fsyncdir (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          int32_t datasync, dict_t *xdata);
-
-int32_t default_statfs (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc, dict_t *xdata);
-
-int32_t default_setxattr (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          dict_t *dict,
-                          int32_t flags, dict_t *xdata);
-
-int32_t default_getxattr (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          const char *name, dict_t *xdata);
-
-int32_t default_fsetxattr (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           dict_t *dict,
-                           int32_t flags, dict_t *xdata);
-
-int32_t default_fgetxattr (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           const char *name, dict_t *xdata);
-
-int32_t default_removexattr (call_frame_t *frame,
-                             xlator_t *this,
-                             loc_t *loc,
-                             const char *name, dict_t *xdata);
-
-int32_t default_fremovexattr (call_frame_t *frame,
-                              xlator_t *this,
-                              fd_t *fd,
-                              const char *name, dict_t *xdata);
-
-int32_t default_lk (call_frame_t *frame,
-                    xlator_t *this,
-                    fd_t *fd,
-                    int32_t cmd,
-                    struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_inodelk (call_frame_t *frame, xlator_t *this,
-                         const char *volume, loc_t *loc, int32_t cmd,
-                         struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_finodelk (call_frame_t *frame, xlator_t *this,
-                          const char *volume, fd_t *fd, int32_t cmd,
-                          struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_entrylk (call_frame_t *frame, xlator_t *this,
-                         const char *volume, loc_t *loc, const char *basename,
-                         entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-int32_t default_fentrylk (call_frame_t *frame, xlator_t *this,
-                          const char *volume, fd_t *fd, const char *basename,
-                          entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-int32_t default_readdir (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          size_t size, off_t off, dict_t *xdata);
-
-int32_t default_readdirp (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          size_t size, off_t off, dict_t *xdata);
-
-int32_t default_xattrop (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc,
-                         gf_xattrop_flags_t flags,
-                         dict_t *dict, dict_t *xdata);
-
-int32_t default_fxattrop (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          gf_xattrop_flags_t flags,
-                          dict_t *dict, dict_t *xdata);
-
-int32_t default_setattr (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc,
-                         struct iatt *stbuf,
-                         int32_t valid, dict_t *xdata);
-
-int32_t default_fsetattr (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          struct iatt *stbuf,
-                          int32_t valid, dict_t *xdata);
-
-int32_t default_fallocate(call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          int32_t keep_size, off_t offset,
-                          size_t len, dict_t *xdata);
-
-int32_t default_discard(call_frame_t *frame,
-                        xlator_t *this,
-                        fd_t *fd,
-                        off_t offset,
-                        size_t len, dict_t *xdata);
-
-int32_t default_zerofill(call_frame_t *frame,
-                        xlator_t *this,
-                        fd_t *fd,
-                        off_t offset,
-                        off_t len, dict_t *xdata);
-
-int32_t default_ipc (call_frame_t *frame, xlator_t *this, int32_t op,
-                     dict_t *xdata);
-
-int32_t default_seek (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                      off_t offset, gf_seek_what_t what, dict_t *xdata);
-
-int32_t default_lease (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       struct gf_lease *lease, dict_t *xdata);
-
-int32_t
-default_getactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                      dict_t *xdata);
-
-int32_t
-default_setactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       lock_migration_info_t *locklist, dict_t *xdata);
-
-/* Resume */
-int32_t default_getspec_resume (call_frame_t *frame,
-                                xlator_t *this,
-                                const char *key,
-                                int32_t flag);
-
-int32_t default_rchecksum_resume (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd, off_t offset,
-                           int32_t len, dict_t *xdata);
-
-/* FileSystem operations */
-int32_t default_lookup_resume (call_frame_t *frame,
-                               xlator_t *this,
-                               loc_t *loc,
-                               dict_t *xdata);
-
-int32_t default_stat_resume (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t *loc, dict_t *xdata);
-
-int32_t default_fstat_resume (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd, dict_t *xdata);
-
-int32_t default_truncate_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          off_t offset, dict_t *xdata);
-
-int32_t default_ftruncate_resume (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           off_t offset, dict_t *xdata);
-
-int32_t default_access_resume (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc,
-                        int32_t mask, dict_t *xdata);
-
-int32_t default_readlink_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          size_t size, dict_t *xdata);
-
-int32_t default_mknod_resume (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                              mode_t mode, dev_t rdev, mode_t umask,
-                              dict_t *xdata);
-
-int32_t default_mkdir_resume (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                              mode_t mode, mode_t umask, dict_t *xdata);
-
-int32_t default_unlink_resume (call_frame_t *frame,
-                               xlator_t *this,
-                               loc_t *loc, int xflag, dict_t *xdata);
-
-int32_t default_rmdir_resume (call_frame_t *frame, xlator_t *this,
-                              loc_t *loc, int xflag, dict_t *xdata);
-
-int32_t default_symlink_resume (call_frame_t *frame, xlator_t *this,
-                                const char *linkpath, loc_t *loc, mode_t umask,
-                                dict_t *xdata);
-
-int32_t default_rename_resume (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *oldloc,
-                        loc_t *newloc, dict_t *xdata);
-
-int32_t default_link_resume (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t *oldloc,
-                      loc_t *newloc, dict_t *xdata);
-
-int32_t default_create_resume (call_frame_t *frame, xlator_t *this,
-                               loc_t *loc, int32_t flags, mode_t mode,
-                               mode_t umask, fd_t *fd, dict_t *xdata);
-
-int32_t default_open_resume (call_frame_t *frame,
-                             xlator_t *this,
-                             loc_t *loc,
-                             int32_t flags, fd_t *fd, dict_t *xdata);
-
-int32_t default_readv_resume (call_frame_t *frame,
-                              xlator_t *this,
-                              fd_t *fd,
-                              size_t size,
-                              off_t offset, uint32_t flags, dict_t *xdata);
-
-int32_t default_writev_resume (call_frame_t *frame,
-                               xlator_t *this,
-                               fd_t *fd,
-                               struct iovec *vector,
-                               int32_t count,
-                               off_t offset, uint32_t flags,
-                               struct iobref *iobref, dict_t *xdata);
-
-int32_t default_flush_resume (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd, dict_t *xdata);
-
-int32_t default_fsync_resume (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t *fd,
-                       int32_t datasync, dict_t *xdata);
-
-int32_t default_opendir_resume (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc, fd_t *fd, dict_t *xdata);
-
-int32_t default_fsyncdir_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          int32_t datasync, dict_t *xdata);
-
-int32_t default_statfs_resume (call_frame_t *frame,
-                        xlator_t *this,
-                        loc_t *loc, dict_t *xdata);
-
-int32_t default_setxattr_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          dict_t *dict,
-                          int32_t flags, dict_t *xdata);
-
-int32_t default_getxattr_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          loc_t *loc,
-                          const char *name, dict_t *xdata);
-
-int32_t default_fsetxattr_resume (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           dict_t *dict,
-                           int32_t flags, dict_t *xdata);
-
-int32_t default_fgetxattr_resume (call_frame_t *frame,
-                           xlator_t *this,
-                           fd_t *fd,
-                           const char *name, dict_t *xdata);
-
-int32_t default_removexattr_resume (call_frame_t *frame,
-                             xlator_t *this,
-                             loc_t *loc,
-                             const char *name, dict_t *xdata);
-
-int32_t default_fremovexattr_resume (call_frame_t *frame,
-                                     xlator_t *this,
-                                     fd_t *fd,
-                                     const char *name, dict_t *xdata);
-
-int32_t default_lk_resume (call_frame_t *frame,
-                    xlator_t *this,
-                    fd_t *fd,
-                    int32_t cmd,
-                    struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_inodelk_resume (call_frame_t *frame, xlator_t *this,
-                         const char *volume, loc_t *loc, int32_t cmd,
-                         struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_finodelk_resume (call_frame_t *frame, xlator_t *this,
-                          const char *volume, fd_t *fd, int32_t cmd,
-                          struct gf_flock *flock, dict_t *xdata);
-
-int32_t default_entrylk_resume (call_frame_t *frame, xlator_t *this,
-                         const char *volume, loc_t *loc, const char *basename,
-                         entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-int32_t default_fentrylk_resume (call_frame_t *frame, xlator_t *this,
-                          const char *volume, fd_t *fd, const char *basename,
-                          entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
-
-int32_t default_readdir_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          size_t size, off_t off, dict_t *xdata);
-
-int32_t default_readdirp_resume (call_frame_t *frame,
-                                 xlator_t *this,
-                                 fd_t *fd,
-                                 size_t size, off_t off, dict_t *xdata);
-
-int32_t default_xattrop_resume (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc,
-                         gf_xattrop_flags_t flags,
-                         dict_t *dict, dict_t *xdata);
-
-int32_t default_fxattrop_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          gf_xattrop_flags_t flags,
-                          dict_t *dict, dict_t *xdata);
-int32_t default_rchecksum_resume (call_frame_t *frame,
-                                  xlator_t *this,
-                                  fd_t *fd, off_t offset,
-                                  int32_t len, dict_t *xdata);
-
-int32_t default_setattr_resume (call_frame_t *frame,
-                         xlator_t *this,
-                         loc_t *loc,
-                         struct iatt *stbuf,
-                         int32_t valid, dict_t *xdata);
-
-int32_t default_fsetattr_resume (call_frame_t *frame,
-                          xlator_t *this,
-                          fd_t *fd,
-                          struct iatt *stbuf,
-                          int32_t valid, dict_t *xdata);
-
-int32_t default_fallocate_resume(call_frame_t *frame,
-                                 xlator_t *this,
-                                 fd_t *fd,
-                                 int32_t keep_size, off_t offset,
-                                 size_t len, dict_t *xdata);
-
-int32_t default_discard_resume(call_frame_t *frame,
-                               xlator_t *this,
-                               fd_t *fd,
-                               off_t offset,
-                               size_t len, dict_t *xdata);
-
-int32_t default_zerofill_resume(call_frame_t *frame,
-                               xlator_t *this,
-                               fd_t *fd,
-                               off_t offset,
-                               off_t len, dict_t *xdata);
-
-int32_t default_ipc_resume (call_frame_t *frame, xlator_t *this,
-                            int32_t op, dict_t *xdata);
-
-int32_t default_seek_resume (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             off_t offset, gf_seek_what_t what, dict_t *xdata);
-
-int32_t default_lease_resume (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                              struct gf_lease *lease, dict_t *xdata);
-
-int32_t
-default_getactivelk_resume (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                            dict_t *xdata);
-
-int32_t
-default_setactivelk_resume (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                            lock_migration_info_t *locklist, dict_t *xdata);
-
-/* _cbk_resume */
-
-int32_t
-default_lookup_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           inode_t * inode, struct iatt *buf, dict_t * xdata,
-                           struct iatt *postparent);
-
-int32_t
-default_stat_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                         dict_t * xdata);
-
-
-int32_t
-default_truncate_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, struct iatt *prebuf,
-                             struct iatt *postbuf, dict_t * xdata);
-
-int32_t
-default_ftruncate_cbk_resume (call_frame_t * frame, void *cookie,
-                              xlator_t * this, int32_t op_ret,
-                              int32_t op_errno, struct iatt *prebuf,
-                              struct iatt *postbuf, dict_t * xdata);
-
-int32_t
-default_access_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           dict_t * xdata);
-
-int32_t
-default_readlink_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, const char *path,
-                             struct iatt *buf, dict_t * xdata);
-
-
-int32_t
-default_mknod_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno, inode_t * inode,
-                          struct iatt *buf, struct iatt *preparent,
-                          struct iatt *postparent, dict_t * xdata);
-
-int32_t
-default_mkdir_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno, inode_t * inode,
-                          struct iatt *buf, struct iatt *preparent,
-                          struct iatt *postparent, dict_t * xdata);
-
-int32_t
-default_unlink_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           struct iatt *preparent, struct iatt *postparent,
-                           dict_t * xdata);
-
-int32_t
-default_rmdir_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iatt *preparent, struct iatt *postparent,
-                          dict_t * xdata);
-
-
-int32_t
-default_symlink_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            inode_t * inode, struct iatt *buf,
-                            struct iatt *preparent, struct iatt *postparent,
-                            dict_t * xdata);
-
-
-int32_t
-default_rename_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           struct iatt *buf, struct iatt *preoldparent,
-                           struct iatt *postoldparent,
-                           struct iatt *prenewparent,
-                           struct iatt *postnewparent, dict_t * xdata);
-
-
-int32_t
-default_link_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                         int32_t op_ret, int32_t op_errno, inode_t * inode,
-                         struct iatt *buf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t * xdata);
-
-
-int32_t
-default_create_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           fd_t * fd, inode_t * inode, struct iatt *buf,
-                           struct iatt *preparent, struct iatt *postparent,
-                           dict_t * xdata);
-
-int32_t
-default_open_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                         int32_t op_ret, int32_t op_errno, fd_t * fd,
-                         dict_t * xdata);
-
-int32_t
-default_readv_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iovec *vector, int32_t count,
-                          struct iatt *stbuf, struct iobref *iobref,
-                          dict_t * xdata);
-
-
-int32_t
-default_writev_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           struct iatt *prebuf, struct iatt *postbuf,
-                           dict_t * xdata);
-
-
-int32_t
-default_flush_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno, dict_t * xdata);
-
-
-
-int32_t
-default_fsync_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iatt *prebuf, struct iatt *postbuf,
-                          dict_t * xdata);
-
-int32_t
-default_fstat_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                          dict_t * xdata);
-
-int32_t
-default_opendir_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            fd_t * fd, dict_t * xdata);
-
-int32_t
-default_fsyncdir_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * xdata);
-
-int32_t
-default_statfs_cbk_resume (call_frame_t * frame, void *cookie,
-                           xlator_t * this, int32_t op_ret, int32_t op_errno,
-                           struct statvfs *buf, dict_t * xdata);
-
-
-int32_t
-default_setxattr_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * xdata);
-
-
-int32_t
-default_fsetxattr_cbk_resume (call_frame_t * frame, void *cookie,
-                              xlator_t * this, int32_t op_ret,
-                              int32_t op_errno, dict_t * xdata);
-
-
-
-int32_t
-default_fgetxattr_cbk_resume (call_frame_t * frame, void *cookie,
-                              xlator_t * this, int32_t op_ret,
-                              int32_t op_errno, dict_t * dict,
-                              dict_t * xdata);
-
-
-int32_t
-default_getxattr_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * dict, dict_t * xdata);
-
-int32_t
-default_xattrop_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            dict_t * dict, dict_t * xdata);
-
-int32_t
-default_fxattrop_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * dict, dict_t * xdata);
-
-
-int32_t
-default_removexattr_cbk_resume (call_frame_t * frame, void *cookie,
-                                xlator_t * this, int32_t op_ret,
-                                int32_t op_errno, dict_t * xdata);
-
-int32_t
-default_fremovexattr_cbk_resume (call_frame_t * frame, void *cookie,
-                                 xlator_t * this, int32_t op_ret,
-                                 int32_t op_errno, dict_t * xdata);
-
-int32_t
-default_lk_cbk_resume (call_frame_t * frame, void *cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno,
-                       struct gf_flock *lock, dict_t * xdata);
-
-int32_t
-default_inodelk_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            dict_t * xdata);
-
-
-int32_t
-default_finodelk_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * xdata);
-
-int32_t
-default_entrylk_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            dict_t * xdata);
-
-int32_t
-default_fentrylk_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, dict_t * xdata);
-
-
-int32_t
-default_rchecksum_cbk_resume (call_frame_t * frame, void *cookie,
-                              xlator_t * this, int32_t op_ret,
-                              int32_t op_errno, uint32_t weak_checksum,
-                              uint8_t * strong_checksum, dict_t * xdata);
-
-
-int32_t
-default_readdir_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            gf_dirent_t * entries, dict_t * xdata);
-
-
-int32_t
-default_readdirp_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, gf_dirent_t * entries,
-                             dict_t * xdata);
-
-int32_t
-default_setattr_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            struct iatt *statpre, struct iatt *statpost,
-                            dict_t * xdata);
-
-int32_t
-default_fsetattr_cbk_resume (call_frame_t * frame, void *cookie,
-                             xlator_t * this, int32_t op_ret,
-                             int32_t op_errno, struct iatt *statpre,
-                             struct iatt *statpost, dict_t * xdata);
-
-int32_t default_fallocate_cbk_resume (call_frame_t * frame, void *cookie,
-                                      xlator_t * this, int32_t op_ret,
-                                      int32_t op_errno, struct iatt *pre,
-                                      struct iatt *post, dict_t * xdata);
-
-int32_t default_discard_cbk_resume (call_frame_t * frame, void *cookie,
-                                    xlator_t * this, int32_t op_ret,
-                                    int32_t op_errno, struct iatt *pre,
-                                    struct iatt *post, dict_t * xdata);
-
-int32_t default_zerofill_cbk_resume (call_frame_t * frame, void *cookie,
-                                     xlator_t * this, int32_t op_ret,
-                                     int32_t op_errno, struct iatt *pre,
-                                     struct iatt *post, dict_t * xdata);
-int32_t
-default_ipc_cbk_resume (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_seek_cbk_resume (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, off_t offset,
-                         dict_t *xdata);
-
-int32_t
-default_getspec_cbk_resume (call_frame_t * frame, void *cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            char *spec_data);
-
-int32_t
-default_lease_cbk_resume (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct gf_lease *lease, dict_t *xdata);
-
-int32_t
-default_getactivelk_cbk_resume (call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno,
-                                lock_migration_info_t *locklist,
-                                dict_t *xdata);
-
-int32_t
-default_setactivelk_cbk_resume (call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno, dict_t *xdata);
-
-/* _CBK */
-int32_t
-default_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, dict_t *xdata, struct iatt *postparent);
-
-int32_t
-default_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata);
-
-
-int32_t
-default_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata);
-
-int32_t
-default_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata);
-
-int32_t
-default_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, const char *path,
-                      struct iatt *buf, dict_t *xdata);
-
-
-int32_t
-default_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata);
-
-int32_t
-default_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata);
-
-int32_t
-default_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-int32_t
-default_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata);
-
-
-int32_t
-default_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata);
-
-
-int32_t
-default_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent, dict_t *xdata);
-
-
-int32_t
-default_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata);
-
-
-int32_t
-default_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata);
-
-int32_t
-default_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata);
-
-int32_t
-default_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref, dict_t *xdata);
-
-
-int32_t
-default_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata);
-
-
-int32_t
-default_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-
-int32_t
-default_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata);
-
-int32_t
-default_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata);
-
-int32_t
-default_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata);
-
-int32_t
-default_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata);
-
-
-int32_t
-default_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int32_t
-default_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-
-int32_t
-default_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata);
-
-
-int32_t
-default_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata);
-
-int32_t
-default_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata);
-
-int32_t
-default_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata);
-
-
-int32_t
-default_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata);
-
-int32_t
-default_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int32_t
-default_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t
-default_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int32_t
-default_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
-                       uint8_t *strong_checksum, dict_t *xdata);
-
-
-int32_t
-default_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
-
-
-int32_t
-default_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
-
-int32_t
-default_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                     struct iatt *statpost, dict_t *xdata);
-
-int32_t
-default_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                      struct iatt *statpost, dict_t *xdata);
-
-int32_t default_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                              struct iatt *post, dict_t *xdata);
-
-int32_t default_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                            int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                            struct iatt *post, dict_t *xdata);
-
-int32_t default_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                            int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                            struct iatt *post, dict_t *xdata);
-
-int32_t default_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int32_t default_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, off_t offset,
-                          dict_t *xdata);
-
-int32_t
-default_getspec_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, char *spec_data);
-
-int32_t
-default_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno,
-                   struct gf_lease *lease, dict_t *xdata);
-
-int32_t
-default_getactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          lock_migration_info_t *locklist,
-                          dict_t *xdata);
-
-int32_t
-default_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-
-int32_t
-default_lookup_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_stat_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-
-int32_t
-default_truncate_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_ftruncate_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_access_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_readlink_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-
-int32_t
-default_mknod_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_mkdir_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_unlink_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_rmdir_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_symlink_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_rename_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_link_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_create_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_open_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_readv_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_writev_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_flush_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fsync_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fstat_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_opendir_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fsyncdir_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_statfs_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_setxattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fsetxattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fgetxattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_getxattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_xattrop_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fxattrop_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_removexattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fremovexattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_lk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_inodelk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_finodelk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_entrylk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fentrylk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_rchecksum_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_readdir_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_readdirp_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_setattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fsetattr_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_fallocate_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_discard_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_zerofill_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_getspec_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_ipc_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_seek_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_lease_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_getactivelk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_setactivelk_failure_cbk (call_frame_t *frame, int32_t op_errno);
-
-int32_t
-default_mem_acct_init (xlator_t *this);
-#endif /* _DEFAULTS_H */
diff --git a/libglusterfs/src/dict.c b/libglusterfs/src/dict.c
index 243c92985a8..1d9be9217a6 100644
--- a/libglusterfs/src/dict.c
+++ b/libglusterfs/src/dict.c
@@ -16,153 +16,227 @@
 #include <limits.h>
 #include <fnmatch.h>
 
-#include "glusterfs.h"
-#include "common-utils.h"
-#include "dict.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "compat.h"
-#include "compat-errno.h"
-#include "byte-order.h"
-#include "globals.h"
-#include "statedump.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/dict.h"
+#define XXH_INLINE_ALL
+#include "xxhash.h"
+#include "glusterfs/compat.h"
+#include "glusterfs/compat-errno.h"
+#include "glusterfs/byte-order.h"
+#include "glusterfs/statedump.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 struct dict_cmp {
-        dict_t *dict;
-        gf_boolean_t (*value_ignore) (char *k);
+    dict_t *dict;
+    gf_boolean_t (*value_ignore)(char *k);
 };
 
-data_t *
-get_new_data ()
+#define VALIDATE_DATA_AND_LOG(data, type, key, ret_val)                        \
+    do {                                                                       \
+        if (!data || !data->data) {                                            \
+            gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG, \
+                             "data is NULL");                                  \
+            return ret_val;                                                    \
+        }                                                                      \
+        /* Not of the asked type, or old version */                            \
+        if ((data->data_type != type) &&                                       \
+            (data->data_type != GF_DATA_TYPE_STR_OLD)) {                       \
+            gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG, \
+                             "key %s, %s type asked, has %s type", key,        \
+                             data_type_name[type],                             \
+                             data_type_name[data->data_type]);                 \
+        }                                                                      \
+    } while (0)
+
+static data_t *
+get_new_data()
 {
-        data_t *data = NULL;
+    data_t *data = mem_get(THIS->ctx->dict_data_pool);
 
-        data = mem_get0 (THIS->ctx->dict_data_pool);
-        if (!data) {
-                return NULL;
-        }
+    if (!data)
+        return NULL;
+
+    GF_ATOMIC_INIT(data->refcount, 0);
+    data->is_static = _gf_false;
 
-        LOCK_INIT (&data->lock);
-        return data;
+    return data;
 }
 
-dict_t *
-get_new_dict_full (int size_hint)
+static dict_t *
+get_new_dict_full(int size_hint)
 {
-        dict_t *dict = mem_get0 (THIS->ctx->dict_pool);
+    dict_t *dict = mem_get0(THIS->ctx->dict_pool);
 
-        if (!dict) {
-                return NULL;
-        }
-
-        dict->hash_size = size_hint;
-        if (size_hint == 1) {
-                /*
-                 * This is the only case we ever see currently.  If we ever
-                 * need to support resizing the hash table, the resize function
-                 * will have to take into account the possibility that
-                 * "members" is not separately allocated (i.e. don't just call
-                 * realloc() blindly.
-                 */
-                dict->members = &dict->members_internal;
-        }
-        else {
-                /*
-                 * We actually need to allocate space for size_hint *pointers*
-                 * but we actually allocate space for one *structure*.  Since
-                 * a data_pair_t consists of five pointers, we're wasting four
-                 * pointers' worth for N=1, and will overrun what we allocated
-                 * for N>5.  If anybody ever starts using size_hint, we'll need
-                 * to fix this.
-                 */
-                GF_ASSERT (size_hint <=
-                           (sizeof(data_pair_t) / sizeof(data_pair_t *)));
-                dict->members = mem_get0 (THIS->ctx->dict_pair_pool);
-                if (!dict->members) {
-                        mem_put (dict);
-                        return NULL;
-                }
+    if (!dict) {
+        return NULL;
+    }
+
+    dict->hash_size = size_hint;
+    if (size_hint == 1) {
+        /*
+         * This is the only case we ever see currently.  If we ever
+         * need to support resizing the hash table, the resize function
+         * will have to take into account the possibility that
+         * "members" is not separately allocated (i.e. don't just call
+         * realloc() blindly.
+         */
+        dict->members = &dict->members_internal;
+    } else {
+        /*
+         * We actually need to allocate space for size_hint *pointers*
+         * but we actually allocate space for one *structure*.  Since
+         * a data_pair_t consists of five pointers, we're wasting four
+         * pointers' worth for N=1, and will overrun what we allocated
+         * for N>5.  If anybody ever starts using size_hint, we'll need
+         * to fix this.
+         */
+        GF_ASSERT(size_hint <= (sizeof(data_pair_t) / sizeof(data_pair_t *)));
+        dict->members = mem_get0(THIS->ctx->dict_pair_pool);
+        if (!dict->members) {
+            mem_put(dict);
+            return NULL;
         }
+    }
 
-        LOCK_INIT (&dict->lock);
+    dict->free_pair.key = NULL;
+    dict->totkvlen = 0;
+    LOCK_INIT(&dict->lock);
 
-        return dict;
+    return dict;
 }
 
 dict_t *
-get_new_dict (void)
+dict_new(void)
 {
-        return get_new_dict_full (1);
+    dict_t *dict = get_new_dict_full(1);
+
+    if (dict)
+        dict_ref(dict);
+
+    return dict;
 }
 
-dict_t *
-dict_new (void)
+int32_t
+is_data_equal(data_t *one, data_t *two)
 {
-        dict_t *dict = NULL;
+    struct iatt *iatt1, *iatt2;
+    struct mdata_iatt *mdata_iatt1, *mdata_iatt2;
+
+    if (!one || !two || !one->data || !two->data) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "input arguments are provided "
+                         "with value data_t as NULL");
+        return -1;
+    }
 
-        dict = get_new_dict_full(1);
+    if (one == two)
+        return 1;
 
-        if (dict)
-                dict_ref (dict);
+    if (one->data == two->data)
+        return 1;
 
-        return dict;
-}
+    if (one->data_type != two->data_type) {
+        return 0;
+    }
 
-int32_t
-is_data_equal (data_t *one,
-               data_t *two)
-{
-        if (!one || !two || !one->data || !two->data) {
-		gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-				  "input arguments are provided "
-				  "with value data_t as NULL");
-                return -1;
-	}
+    if (one->data_type == GF_DATA_TYPE_IATT) {
+        if ((one->len < sizeof(struct iatt)) ||
+            (two->len < sizeof(struct iatt))) {
+            return 0;
+        }
 
-        if (one == two)
-                return 1;
+        iatt1 = (struct iatt *)one->data;
+        iatt2 = (struct iatt *)two->data;
 
-        if (one->len != two->len)
+        /* Two iatt structs are considered equal if main fields are
+         * equal, even if times differ.
+         * TODO: maybe when ctime if fully operational we could
+         *       enforce time matching. */
+        if (iatt1->ia_ino != iatt2->ia_ino) {
+            return 0;
+        }
+        if (iatt1->ia_type != iatt2->ia_type) {
+            return 0;
+        }
+        if ((iatt1->ia_type == IA_IFBLK) || (iatt1->ia_type == IA_IFCHR)) {
+            if (iatt1->ia_rdev != iatt2->ia_rdev) {
                 return 0;
+            }
+        }
+        if (gf_uuid_compare(iatt1->ia_gfid, iatt2->ia_gfid) != 0) {
+            return 0;
+        }
 
-        if (one->data == two->data)
-                return 1;
+        /* TODO: ia_uid, ia_gid, ia_prot and ia_size can be changed
+         *       with some commands. Here we don't have enough
+         *       information to decide if they should match or not. */
+        /*
+                        if ((iatt1->ia_uid != iatt2->ia_uid) ||
+                            (iatt1->ia_gid != iatt2->ia_gid) ||
+                            (st_mode_from_ia(iatt1->ia_prot, iatt1->ia_type) !=
+                                    st_mode_from_ia(iatt2->ia_prot,
+           iatt2->ia_type))) { return 0;
+                        }
+                        if (iatt1->ia_type == IA_IFREG) {
+                                if (iatt1->ia_size != iatt2->ia_size) {
+                                        return 0;
+                                }
+                        }
+        */
+        return 1;
+    }
+    if (one->data_type == GF_DATA_TYPE_MDATA) {
+        if ((one->len < sizeof(struct mdata_iatt)) ||
+            (two->len < sizeof(struct mdata_iatt))) {
+            return 0;
+        }
+        mdata_iatt1 = (struct mdata_iatt *)one->data;
+        mdata_iatt2 = (struct mdata_iatt *)two->data;
+
+        if (mdata_iatt1->ia_atime != mdata_iatt2->ia_atime ||
+            mdata_iatt1->ia_mtime != mdata_iatt2->ia_mtime ||
+            mdata_iatt1->ia_ctime != mdata_iatt2->ia_ctime ||
+            mdata_iatt1->ia_atime_nsec != mdata_iatt2->ia_atime_nsec ||
+            mdata_iatt1->ia_mtime_nsec != mdata_iatt2->ia_mtime_nsec ||
+            mdata_iatt1->ia_ctime_nsec != mdata_iatt2->ia_ctime_nsec) {
+            return 0;
+        }
+        return 1;
+    }
+
+    if (one->len != two->len)
+        return 0;
 
-        if (memcmp (one->data, two->data, one->len) == 0)
-                return 1;
+    if (memcmp(one->data, two->data, one->len) == 0)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 static int
-key_value_cmp (dict_t *one, char *key1, data_t *value1, void *data)
+key_value_cmp(dict_t *one, char *key1, data_t *value1, void *data)
 {
-        struct dict_cmp *cmp = data;
-        dict_t *two = NULL;
-        data_t *value2 = NULL;
-
-        two = cmp->dict;
-        value2 = dict_get (two, key1);
+    struct dict_cmp *cmp = data;
+    dict_t *two = cmp->dict;
+    data_t *value2 = dict_get(two, key1);
 
-        if (value2) {
-                if (cmp->value_ignore && cmp->value_ignore (key1))
-                        return 0;
+    if (value2) {
+        if (cmp->value_ignore && cmp->value_ignore(key1))
+            return 0;
 
-                if (is_data_equal (value1, value2) == 1)
-                        return 0;
-        }
+        if (is_data_equal(value1, value2) == 1)
+            return 0;
+    }
 
-        if (value2 == NULL) {
-                gf_msg_debug (THIS->name, 0, "'%s' found only on one dict",
-                              key1);
-        } else {
-                gf_msg_debug (THIS->name, 0, "'%s' is different in two dicts "
-                              "(%u, %u)", key1, value1->len, value2->len);
-        }
+    if (value2 == NULL) {
+        gf_msg_debug(THIS->name, 0, "'%s' found only on one dict", key1);
+    } else {
+        gf_msg_debug(THIS->name, 0,
+                     "'%s' is different in two dicts "
+                     "(%u, %u)",
+                     key1, value1->len, value2->len);
+    }
 
-        return -1;
+    return -1;
 }
 
 /* If both dicts are NULL then equal. If one of the dicts is NULL but the
@@ -173,1085 +247,1087 @@ key_value_cmp (dict_t *one, char *key1, data_t *value1, void *data)
  * different.
  */
 gf_boolean_t
-are_dicts_equal (dict_t *one, dict_t *two,
-                 gf_boolean_t (*match) (dict_t *d, char *k, data_t *v,
-                                        void *data),
-                 gf_boolean_t (*value_ignore) (char *k))
-{
-        int     num_matches1 = 0;
-        int     num_matches2 = 0;
-        struct  dict_cmp cmp = {0};
-
-        if (one == two)
-                return _gf_true;
-
-        if (!match)
-                match = dict_match_everything;
-
-        cmp.dict = two;
-        cmp.value_ignore = value_ignore;
-        if (!two) {
-                num_matches1 = dict_foreach_match (one, match, NULL,
-                                                   dict_null_foreach_fn, NULL);
-                goto done;
-        } else {
-                num_matches1 = dict_foreach_match (one, match, NULL,
-                                                   key_value_cmp, &cmp);
-        }
+are_dicts_equal(dict_t *one, dict_t *two,
+                gf_boolean_t (*match)(dict_t *d, char *k, data_t *v,
+                                      void *data),
+                gf_boolean_t (*value_ignore)(char *k))
+{
+    int num_matches1 = 0;
+    int num_matches2 = 0;
+    struct dict_cmp cmp = {0};
 
-        if (num_matches1 == -1)
-                return _gf_false;
+    if (one == two)
+        return _gf_true;
 
-        if ((num_matches1 == one->count) && (one->count == two->count))
-                return _gf_true;
+    if (!match)
+        match = dict_match_everything;
 
-        num_matches2 = dict_foreach_match (two, match, NULL,
-                                           dict_null_foreach_fn, NULL);
-done:
-        /* If the number of matches is same in 'two' then for all the
-         * valid-keys that exist in 'one' the value matched and no extra valid
-         * keys exist in 'two' alone. Otherwise there exists at least one extra
-         * valid-key in 'two' which doesn't exist in 'one' */
-        if (num_matches1 == num_matches2)
-                return _gf_true;
+    if ((one == NULL) || (two == NULL)) {
+        num_matches1 = dict_foreach_match(one ? one : two, match, NULL,
+                                          dict_null_foreach_fn, NULL);
+        goto done;
+    }
+
+    cmp.dict = two;
+    cmp.value_ignore = value_ignore;
+    num_matches1 = dict_foreach_match(one, match, NULL, key_value_cmp, &cmp);
+
+    if (num_matches1 == -1)
         return _gf_false;
+
+    if ((num_matches1 == one->count) && (one->count == two->count))
+        return _gf_true;
+
+    num_matches2 = dict_foreach_match(two, match, NULL, dict_null_foreach_fn,
+                                      NULL);
+done:
+    /* If the number of matches is same in 'two' then for all the
+     * valid-keys that exist in 'one' the value matched and no extra valid
+     * keys exist in 'two' alone. Otherwise there exists at least one extra
+     * valid-key in 'two' which doesn't exist in 'one' */
+    if (num_matches1 == num_matches2)
+        return _gf_true;
+    return _gf_false;
 }
 
 void
-data_destroy (data_t *data)
+data_destroy(data_t *data)
 {
-        if (data) {
-                LOCK_DESTROY (&data->lock);
+    if (data) {
+        if (!data->is_static)
+            GF_FREE(data->data);
 
-                if (!data->is_static)
-                        GF_FREE (data->data);
-
-                data->len = 0xbabababa;
-                if (!data->is_const)
-                        mem_put (data);
-        }
+        data->len = 0xbabababa;
+        mem_put(data);
+    }
 }
 
 data_t *
-data_copy (data_t *old)
+data_copy(data_t *old)
 {
-        if (!old) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, 0, LG_MSG_NULL_PTR,
-                                  "old is NULL");
-                return NULL;
-        }
+    if (!old) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, 0, LG_MSG_NULL_PTR,
+                         "old is NULL");
+        return NULL;
+    }
 
-        data_t *newdata = mem_get0 (THIS->ctx->dict_data_pool);
-        if (!newdata) {
-                return NULL;
-        }
+    data_t *newdata = mem_get0(THIS->ctx->dict_data_pool);
+    if (!newdata) {
+        return NULL;
+    }
 
-        if (old) {
-                newdata->len = old->len;
-                if (old->data) {
-                        newdata->data = memdup (old->data, old->len);
-                        if (!newdata->data)
-                                goto err_out;
-                }
-        }
+    newdata->len = old->len;
+    if (old->data) {
+        newdata->data = gf_memdup(old->data, old->len);
+        if (!newdata->data)
+            goto err_out;
+    }
+    newdata->data_type = old->data_type;
 
-        LOCK_INIT (&newdata->lock);
-        return newdata;
+    return newdata;
 
 err_out:
-        mem_put (newdata);
+    mem_put(newdata);
 
-        return NULL;
+    return NULL;
 }
 
+/* Always need to be called under lock
+ * Always this and key variables are not null -
+ * checked by callers.
+ */
 static data_pair_t *
-dict_lookup_common (dict_t *this, char *key, uint32_t hash)
+dict_lookup_common(const dict_t *this, const char *key, const uint32_t hash)
 {
-        int hashval = 0;
-        data_pair_t *pair;
+    int hashval = 0;
+    data_pair_t *pair;
 
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || !key (%s)", key);
-                return NULL;
-        }
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1)
+        hashval = hash % this->hash_size;
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        if (this->hash_size != 1)
-                hashval = hash % this->hash_size;
+    for (pair = this->members[hashval]; pair != NULL; pair = pair->hash_next) {
+        if (pair->key && (hash == pair->key_hash) && !strcmp(pair->key, key))
+            return pair;
+    }
 
-        for (pair = this->members[hashval]; pair != NULL; pair = pair->hash_next) {
-                if (pair->key && (hash == pair->key_hash) &&
-                    !strcmp (pair->key, key))
-                        return pair;
-        }
-
-        return NULL;
+    return NULL;
 }
 
 int32_t
-dict_lookup (dict_t *this, char *key, data_t **data)
+dict_lookup(dict_t *this, char *key, data_t **data)
 {
-        if (!this || !key || !data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || !key || "
-                                  "!data");
-                return -1;
-        }
+    if (!this || !key || !data) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !key || "
+                         "!data");
+        return -1;
+    }
 
-        data_pair_t *tmp = NULL;
-        uint32_t hash = 0;
+    data_pair_t *tmp = NULL;
 
-        hash = SuperFastHash (key, strlen (key));
+    uint32_t hash = (uint32_t)XXH64(key, strlen(key), 0);
 
-        LOCK (&this->lock);
-        {
-                tmp = dict_lookup_common (this, key, hash);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        tmp = dict_lookup_common(this, key, hash);
+    }
+    UNLOCK(&this->lock);
 
-        if (!tmp)
-                return -1;
+    if (!tmp)
+        return -1;
 
-        *data = tmp->value;
-        return 0;
+    *data = tmp->value;
+    return 0;
 }
 
 static int32_t
-dict_set_lk (dict_t *this, char *key, data_t *value, gf_boolean_t replace)
-{
-        int hashval = 0;
-        data_pair_t *pair;
-        char key_free = 0;
-        int ret = 0;
-        uint32_t hash = 0;
-
-        if (!key) {
-                ret = gf_asprintf (&key, "ref:%p", value);
-                if (-1 == ret) {
-                        return -1;
-                }
-                key_free = 1;
-        }
+dict_set_lk(dict_t *this, char *key, const int key_len, data_t *value,
+            const uint32_t hash, gf_boolean_t replace)
+{
+    int hashval = 0;
+    data_pair_t *pair;
+    int key_free = 0;
+    uint32_t key_hash;
+    int keylen;
+
+    if (!key) {
+        keylen = gf_asprintf(&key, "ref:%p", value);
+        if (-1 == keylen) {
+            return -1;
+        }
+        key_free = 1;
+        key_hash = (uint32_t)XXH64(key, keylen, 0);
+    } else {
+        keylen = key_len;
+        key_hash = hash;
+    }
+
+    /* Search for a existing key if 'replace' is asked for */
+    if (replace) {
+        pair = dict_lookup_common(this, key, key_hash);
+        if (pair) {
+            data_t *unref_data = pair->value;
+            pair->value = data_ref(value);
+            this->totkvlen += (value->len - unref_data->len);
+            data_unref(unref_data);
+            if (key_free)
+                GF_FREE(key);
+            /* Indicates duplicate key */
+            return 0;
+        }
+    }
+
+    if (this->free_pair.key) { /* the free_pair is used */
+        pair = mem_get(THIS->ctx->dict_pair_pool);
+        if (!pair) {
+            if (key_free)
+                GF_FREE(key);
+            return -1;
+        }
+    } else { /* assign the pair to the free pair */
+        pair = &this->free_pair;
+    }
+
+    if (key_free) {
+        /* It's ours.  Use it. */
+        pair->key = key;
+        key_free = 0;
+    } else {
+        pair->key = (char *)GF_MALLOC(keylen + 1, gf_common_mt_char);
+        if (!pair->key) {
+            if (pair != &this->free_pair) {
+                mem_put(pair);
+            }
+            return -1;
+        }
+        strcpy(pair->key, key);
+    }
+    pair->key_hash = key_hash;
+    pair->value = data_ref(value);
+    this->totkvlen += (keylen + 1 + value->len);
+
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1) {
+        hashval = (key_hash % this->hash_size);
+    }
+    pair->hash_next = this->members[hashval];
+    this->members[hashval] = pair;
+
+    pair->next = this->members_list;
+    pair->prev = NULL;
+    if (this->members_list)
+        this->members_list->prev = pair;
+    this->members_list = pair;
+    this->count++;
+
+    if (key_free)
+        GF_FREE(key);
+
+    if (this->max_count < this->count)
+        this->max_count = this->count;
+    return 0;
+}
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        hash = SuperFastHash (key, strlen (key));
-        if (this->hash_size != 1) {
-                hashval = (hash % this->hash_size);
-        }
+int32_t
+dict_set(dict_t *this, char *key, data_t *value)
+{
+    if (key)
+        return dict_setn(this, key, strlen(key), value);
+    else
+        return dict_setn(this, NULL, 0, value);
+}
 
-        /* Search for a existing key if 'replace' is asked for */
-        if (replace) {
-                pair = dict_lookup_common (this, key, hash);
-
-                if (pair) {
-                        data_t *unref_data = pair->value;
-                        pair->value = data_ref (value);
-                        data_unref (unref_data);
-                        if (key_free)
-                                GF_FREE (key);
-                        /* Indicates duplicate key */
-                        return 0;
-                }
-        }
+int32_t
+dict_setn(dict_t *this, char *key, const int keylen, data_t *value)
+{
+    int32_t ret;
+    uint32_t key_hash = 0;
 
-        if (this->free_pair_in_use) {
-                pair = mem_get0 (THIS->ctx->dict_pair_pool);
-                if (!pair) {
-                        if (key_free)
-                                GF_FREE (key);
-                        return -1;
-                }
-        }
-        else {
-                pair = &this->free_pair;
-                this->free_pair_in_use = _gf_true;
-        }
+    if (!this || !value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !value for "
+                         "key=%s",
+                         key);
+        return -1;
+    }
 
-        if (key_free) {
-                /* It's ours.  Use it. */
-                pair->key = key;
-                key_free = 0;
-        }
-        else {
-                pair->key = (char *) GF_CALLOC (1, strlen (key) + 1,
-                                                gf_common_mt_char);
-                if (!pair->key) {
-                        if (pair == &this->free_pair) {
-                                this->free_pair_in_use = _gf_false;
-                        }
-                        else {
-                                mem_put (pair);
-                        }
-                        return -1;
-                }
-                strcpy (pair->key, key);
-        }
-        pair->key_hash = hash;
-        pair->value = data_ref (value);
+    if (key) {
+        key_hash = (uint32_t)XXH64(key, keylen, 0);
+    }
 
-        pair->hash_next = this->members[hashval];
-        this->members[hashval] = pair;
+    LOCK(&this->lock);
 
-        pair->next = this->members_list;
-        pair->prev = NULL;
-        if (this->members_list)
-                this->members_list->prev = pair;
-        this->members_list = pair;
-        this->count++;
+    ret = dict_set_lk(this, key, keylen, value, key_hash, 1);
 
-        if (key_free)
-                GF_FREE (key);
+    UNLOCK(&this->lock);
 
-        if (this->max_count < this->count)
-                this->max_count = this->count;
-        return 0;
+    return ret;
 }
 
 int32_t
-dict_set (dict_t *this,
-          char *key,
-          data_t *value)
+dict_add(dict_t *this, char *key, data_t *value)
 {
-        int32_t ret;
-
-        if (!this || !value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || !value for "
-                                  "key=%s", key);
-                return -1;
-        }
-
-        LOCK (&this->lock);
-
-        ret = dict_set_lk (this, key, value, 1);
-
-        UNLOCK (&this->lock);
-
-        return ret;
+    if (key)
+        return dict_addn(this, key, strlen(key), value);
+    else
+        return dict_addn(this, NULL, 0, value);
 }
 
-
 int32_t
-dict_add (dict_t *this, char *key, data_t *value)
+dict_addn(dict_t *this, char *key, const int keylen, data_t *value)
 {
-        int32_t ret;
+    int32_t ret;
+    uint32_t key_hash = 0;
 
-        if (!this || !value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || !value for key=%s", key);
-                return -1;
-        }
+    if (!this || !value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !value for key=%s", key);
+        return -1;
+    }
 
-        LOCK (&this->lock);
+    if (key) {
+        key_hash = (uint32_t)XXH64(key, keylen, 0);
+    }
 
-        ret = dict_set_lk (this, key, value, 0);
+    LOCK(&this->lock);
 
-        UNLOCK (&this->lock);
+    ret = dict_set_lk(this, key, keylen, value, key_hash, 0);
 
-        return ret;
+    UNLOCK(&this->lock);
+
+    return ret;
 }
 
+data_t *
+dict_get(dict_t *this, char *key)
+{
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", (key) ? key : "()");
+        return NULL;
+    }
+
+    return dict_getn(this, key, strlen(key));
+}
 
 data_t *
-dict_get (dict_t *this, char *key)
+dict_getn(dict_t *this, char *key, const int keylen)
 {
-        data_pair_t *pair;
-        uint32_t hash = 0;
+    data_pair_t *pair;
+    uint32_t hash;
 
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_INFO, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || key=%s", (key) ? key : "()");
-                return NULL;
-        }
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", (key) ? key : "()");
+        return NULL;
+    }
 
-        hash = SuperFastHash (key, strlen (key));
+    hash = (uint32_t)XXH64(key, keylen, 0);
 
-        LOCK (&this->lock);
-        {
-                pair = dict_lookup_common (this, key, hash);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
+    }
+    UNLOCK(&this->lock);
 
-        if (pair)
-                return pair->value;
+    if (pair)
+        return pair->value;
 
-        return NULL;
+    return NULL;
 }
 
 int
-dict_key_count (dict_t *this)
+dict_key_count(dict_t *this)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict passed is NULL");
-                return ret;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict passed is NULL");
+        return ret;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = this->count;
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = this->count;
+    }
+    UNLOCK(&this->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-dict_del (dict_t *this, char *key)
+dict_del(dict_t *this, char *key)
 {
-        int hashval = 0;
-        uint32_t hash = 0;
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", key);
+        return;
+    }
 
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || key=%s", key);
-                return;
-        }
+    return dict_deln(this, key, strlen(key));
+}
 
-        LOCK (&this->lock);
+void
+dict_deln(dict_t *this, char *key, const int keylen)
+{
+    int hashval = 0;
+    uint32_t hash;
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        hash = SuperFastHash (key, strlen (key));
-        if (this->hash_size != 1)
-                hashval = hash % this->hash_size;
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", key);
+        return;
+    }
 
-        data_pair_t *pair = this->members[hashval];
-        data_pair_t *prev = NULL;
+    hash = (uint32_t)XXH64(key, keylen, 0);
 
-        while (pair) {
-                if ((hash == pair->key_hash) && strcmp (pair->key, key) == 0) {
-                        if (prev)
-                                prev->hash_next = pair->hash_next;
-                        else
-                                this->members[hashval] = pair->hash_next;
+    LOCK(&this->lock);
 
-                        data_unref (pair->value);
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1)
+        hashval = hash % this->hash_size;
 
-                        if (pair->prev)
-                                pair->prev->next = pair->next;
-                        else
-                                this->members_list = pair->next;
+    data_pair_t *pair = this->members[hashval];
+    data_pair_t *prev = NULL;
 
-                        if (pair->next)
-                                pair->next->prev = pair->prev;
+    while (pair) {
+        if ((hash == pair->key_hash) && strcmp(pair->key, key) == 0) {
+            if (prev)
+                prev->hash_next = pair->hash_next;
+            else
+                this->members[hashval] = pair->hash_next;
 
-                        GF_FREE (pair->key);
-                        if (pair == &this->free_pair) {
-                                this->free_pair_in_use = _gf_false;
-                        }
-                        else {
-                                mem_put (pair);
-                        }
-                        this->count--;
-                        break;
-                }
+            this->totkvlen -= pair->value->len;
+            data_unref(pair->value);
 
-                prev = pair;
-                pair = pair->hash_next;
+            if (pair->prev)
+                pair->prev->next = pair->next;
+            else
+                this->members_list = pair->next;
+
+            if (pair->next)
+                pair->next->prev = pair->prev;
+
+            this->totkvlen -= (strlen(pair->key) + 1);
+            GF_FREE(pair->key);
+            if (pair == &this->free_pair) {
+                this->free_pair.key = NULL;
+            } else {
+                mem_put(pair);
+            }
+            this->count--;
+            break;
         }
 
-        UNLOCK (&this->lock);
+        prev = pair;
+        pair = pair->hash_next;
+    }
 
-        return;
+    UNLOCK(&this->lock);
+
+    return;
 }
 
 void
-dict_destroy (dict_t *this)
+dict_destroy(dict_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
-
-        data_pair_t *pair = this->members_list;
-        data_pair_t *prev = this->members_list;
-        glusterfs_ctx_t *ctx = NULL;
-        uint32_t total_pairs = 0;
-        uint64_t current_max = 0;
-
-        LOCK_DESTROY (&this->lock);
-
-        while (prev) {
-                pair = pair->next;
-                data_unref (prev->value);
-                GF_FREE (prev->key);
-                if (prev != &this->free_pair) {
-                        mem_put (prev);
-                }
-                total_pairs++;
-                prev = pair;
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return;
+    }
+
+    data_pair_t *pair = this->members_list;
+    data_pair_t *prev = this->members_list;
+    glusterfs_ctx_t *ctx = NULL;
+    uint64_t current_max = 0;
+    uint32_t total_pairs = 0;
+
+    LOCK_DESTROY(&this->lock);
+
+    while (prev) {
+        pair = pair->next;
+        data_unref(prev->value);
+        GF_FREE(prev->key);
+        if (prev != &this->free_pair) {
+            mem_put(prev);
+        } else {
+            this->free_pair.key = NULL;
         }
+        total_pairs++;
+        prev = pair;
+    }
 
-        if (this->members != &this->members_internal) {
-                mem_put (this->members);
-        }
+    this->totkvlen = 0;
+    if (this->members != &this->members_internal) {
+        mem_put(this->members);
+    }
 
-        GF_FREE (this->extra_free);
-        free (this->extra_stdfree);
+    free(this->extra_stdfree);
 
-        /* update 'ctx->stats.dict.details' using max_count */
-        ctx = THIS->ctx;
+    /* update 'ctx->stats.dict.details' using max_count */
+    ctx = THIS->ctx;
 
-        /* NOTE: below logic is not totaly race proof */
-        /* thread0 and thread1 gets current_max as 10 */
-        /* thread0 has 'this->max_count as 11 */
-        /* thread1 has 'this->max_count as 20 */
-        /* thread1 goes ahead and sets the max_dict_pairs to 20 */
-        /* thread0 then goes and sets it to 11 */
-        /* As it is for information purpose only, no functionality will be
-           broken by this, but a point to consider about ATOMIC macros. */
-        current_max = GF_ATOMIC_GET (ctx->stats.max_dict_pairs);
-        if (current_max < this->max_count)
-                GF_ATOMIC_INIT (ctx->stats.max_dict_pairs, this->max_count);
+    /* NOTE: below logic is not totaly race proof */
+    /* thread0 and thread1 gets current_max as 10 */
+    /* thread0 has 'this->max_count as 11 */
+    /* thread1 has 'this->max_count as 20 */
+    /* thread1 goes ahead and sets the max_dict_pairs to 20 */
+    /* thread0 then goes and sets it to 11 */
+    /* As it is for information purpose only, no functionality will be
+       broken by this, but a point to consider about ATOMIC macros. */
+    current_max = GF_ATOMIC_GET(ctx->stats.max_dict_pairs);
+    if (current_max < this->max_count)
+        GF_ATOMIC_INIT(ctx->stats.max_dict_pairs, this->max_count);
 
-        GF_ATOMIC_ADD (ctx->stats.total_pairs_used, total_pairs);
-        GF_ATOMIC_INC (ctx->stats.total_dicts_used);
+    GF_ATOMIC_ADD(ctx->stats.total_pairs_used, total_pairs);
+    GF_ATOMIC_INC(ctx->stats.total_dicts_used);
 
-        if (!this->is_static)
-                mem_put (this);
+    mem_put(this);
 
-        return;
+    return;
 }
 
 void
-dict_unref (dict_t *this)
+dict_unref(dict_t *this)
 {
-        int32_t ref;
-
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+    uint64_t ref = 0;
 
-        LOCK (&this->lock);
-
-        this->refcount--;
-        ref = this->refcount;
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return;
+    }
 
-        UNLOCK (&this->lock);
+    ref = GF_ATOMIC_DEC(this->refcount);
 
-        if (!ref)
-                dict_destroy (this);
+    if (!ref)
+        dict_destroy(this);
 }
 
 dict_t *
-dict_ref (dict_t *this)
+dict_ref(dict_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return NULL;
-        }
-
-        LOCK (&this->lock);
-
-        this->refcount++;
-
-        UNLOCK (&this->lock);
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return NULL;
+    }
 
-        return this;
+    GF_ATOMIC_INC(this->refcount);
+    return this;
 }
 
 void
-data_unref (data_t *this)
+data_unref(data_t *this)
 {
+    uint64_t ref;
 
-        int32_t ref;
-
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
-
-        LOCK (&this->lock);
-
-        this->refcount--;
-        ref = this->refcount;
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return;
+    }
 
-        UNLOCK (&this->lock);
+    ref = GF_ATOMIC_DEC(this->refcount);
 
-        if (!ref)
-                data_destroy (this);
+    if (!ref)
+        data_destroy(this);
 }
 
 data_t *
-data_ref (data_t *this)
+data_ref(data_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return NULL;
-        }
-
-        LOCK (&this->lock);
-
-        this->refcount++;
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return NULL;
+    }
 
-        UNLOCK (&this->lock);
+    GF_ATOMIC_INC(this->refcount);
 
-        return this;
+    return this;
 }
 
 data_t *
-int_to_data (int64_t value)
+int_to_data(int64_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
 
-        ret = gf_asprintf (&data->data, "%"PRId64, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
-        data->len = strlen (data->data) + 1;
+    data->len = gf_asprintf(&data->data, "%" PRId64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int64 (int64_t value)
+data_from_int64(int64_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRId64, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
-        data->len = strlen (data->data) + 1;
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int32 (int32_t value)
+data_from_int32(int32_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRId32, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId32, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int16 (int16_t value)
+data_from_int16(int16_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRId16, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId16, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int8 (int8_t value)
+data_from_int8(int8_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%d", value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%d", value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_uint64 (uint64_t value)
+data_from_uint64(uint64_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRIu64, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
-static data_t *
-data_from_double (double value)
+data_t *
+data_from_double(double value)
 {
-        data_t *data = NULL;
-        int     ret  = 0;
-
-        data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
 
-        ret = gf_asprintf (&data->data, "%f", value);
-        if (ret == -1) {
-                return NULL;
-        }
-        data->len = strlen (data->data) + 1;
+    data->len = gf_asprintf(&data->data, "%f", value);
+    if (data->len == -1) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_DOUBLE;
 
-        return data;
+    return data;
 }
 
-
 data_t *
-data_from_uint32 (uint32_t value)
+data_from_uint32(uint32_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRIu32, value);
-        if (-1 == ret) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu32, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
-
 data_t *
-data_from_uint16 (uint16_t value)
+data_from_uint16(uint16_t value)
 {
-        int     ret = 0;
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        ret = gf_asprintf (&data->data, "%"PRIu16, value);
-        if (-1 == ret) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu16, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        data_destroy(data);
+        return NULL;
+    }
 
-        data->len = strlen (data->data) + 1;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
 static data_t *
-data_from_ptr_common (void *value, gf_boolean_t is_static)
+data_from_ptr_common(void *value, gf_boolean_t is_static)
 {
-        /* it is valid to set 0/NULL as a value, no need to check *value */
+    /* it is valid to set 0/NULL as a value, no need to check *value */
 
-        data_t *data = get_new_data ();
-        if (!data) {
-                return NULL;
-        }
+    data_t *data = get_new_data();
+    if (!data) {
+        return NULL;
+    }
 
-        data->data = value;
-        data->is_static = is_static;
+    data->data = value;
+    data->len = 0;
+    data->is_static = is_static;
 
-        return data;
+    data->data_type = GF_DATA_TYPE_PTR;
+    return data;
 }
 
 data_t *
-str_to_data (char *value)
+str_to_data(char *value)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
-        data_t *data = get_new_data ();
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = strlen (value) + 1;
+    return strn_to_data(value, strlen(value));
+}
 
-        data->data = value;
-        data->is_static = 1;
+data_t *
+strn_to_data(char *value, const int vallen)
+{
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
+    data_t *data = get_new_data();
+
+    if (!data) {
+        return NULL;
+    }
+    data->len = vallen + 1;
+    data->data_type = GF_DATA_TYPE_STR;
 
-        return data;
+    data->data = value;
+    data->is_static = _gf_true;
+
+    return data;
 }
 
-data_t *
-data_from_dynstr (char *value)
+static data_t *
+data_from_dynstr(char *value)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
-        data->len = strlen (value) + 1;
-        data->data = value;
+    if (!data)
+        return NULL;
+    data->len = strlen(value) + 1;
+    data->data = value;
+    data->data_type = GF_DATA_TYPE_STR;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_dynptr (void *value, int32_t len)
+data_from_dynptr(void *value, int32_t len)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
+    if (!data)
+        return NULL;
 
-        data->len = len;
-        data->data = value;
+    data->len = len;
+    data->data = value;
+    data->data_type = GF_DATA_TYPE_PTR;
 
-        return data;
+    return data;
 }
 
 data_t *
-bin_to_data (void *value, int32_t len)
+bin_to_data(void *value, int32_t len)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
+    if (!data)
+        return NULL;
 
-        data->is_static = 1;
-        data->len = len;
-        data->data = value;
+    data->is_static = _gf_true;
+    data->len = len;
+    data->data = value;
 
-        return data;
+    return data;
 }
 
+static char *data_type_name[GF_DATA_TYPE_MAX] = {
+    [GF_DATA_TYPE_UNKNOWN] = "unknown",
+    [GF_DATA_TYPE_STR_OLD] = "string-old-version",
+    [GF_DATA_TYPE_INT] = "integer",
+    [GF_DATA_TYPE_UINT] = "unsigned integer",
+    [GF_DATA_TYPE_DOUBLE] = "float",
+    [GF_DATA_TYPE_STR] = "string",
+    [GF_DATA_TYPE_PTR] = "pointer",
+    [GF_DATA_TYPE_GFUUID] = "gf-uuid",
+    [GF_DATA_TYPE_IATT] = "iatt",
+    [GF_DATA_TYPE_MDATA] = "mdata",
+};
+
 int64_t
-data_to_int64 (data_t *data)
+data_to_int64(data_t *data)
 {
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return -1;
-        }
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
 
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-        return (int64_t) strtoull (str, NULL, 0);
-}
+    errno = 0;
+    value = strtoll(data->data, &endptr, 0);
+
+    if (endptr && *endptr != '\0')
+        /* Unrecognized characters at the end of string. */
+        errno = EINVAL;
+    if (errno) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "Error in data conversion: '%s' can't "
+                         "be represented as int64_t",
+                         data->data);
+        return -1;
+    }
+    return value;
+}
+
+/* Like above but implies signed range check. */
+
+#define DATA_TO_RANGED_SIGNED(endptr, value, data, type, min, max)             \
+    do {                                                                       \
+        errno = 0;                                                             \
+        value = strtoll(data->data, &endptr, 0);                               \
+        if (endptr && *endptr != '\0')                                         \
+            errno = EINVAL;                                                    \
+        if (errno || value > max || value < min) {                             \
+            gf_msg_callingfn("dict", GF_LOG_WARNING, errno,                    \
+                             LG_MSG_DATA_CONVERSION_ERROR,                     \
+                             "Error in data conversion: '%s' can't "           \
+                             "be represented as " #type,                       \
+                             data->data);                                      \
+            return -1;                                                         \
+        }                                                                      \
+        return (type)value;                                                    \
+    } while (0)
 
 int32_t
-data_to_int32 (data_t *data)
+data_to_int32(data_t *data)
 {
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return -1;
-        }
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        return strtoul (str, NULL, 0);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    DATA_TO_RANGED_SIGNED(endptr, value, data, int32_t, INT_MIN, INT_MAX);
 }
 
 int16_t
-data_to_int16 (data_t *data)
+data_to_int16(data_t *data)
 {
-        int16_t value = 0;
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return -1;
-        }
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        errno = 0;
-        value = strtol (str, NULL, 0);
-
-        if ((value > SHRT_MAX) || (value < SHRT_MIN)) {
-                errno = ERANGE;
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "Error in data"
-                                  " conversion: detected overflow");
-                return -1;
-        }
-
-        return (int16_t)value;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    DATA_TO_RANGED_SIGNED(endptr, value, data, int16_t, SHRT_MIN, SHRT_MAX);
 }
 
-
 int8_t
-data_to_int8 (data_t *data)
+data_to_int8(data_t *data)
 {
-        int8_t value = 0;
-
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return -1;
-        }
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        errno = 0;
-        value = strtol (str, NULL, 0);
+    char *endptr = NULL;
+    int64_t value = 0;
 
-        if ((value > SCHAR_MAX) || (value < SCHAR_MIN)) {
-                errno = ERANGE;
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "Error in data"
-                                  " conversion: detected overflow");
-                return -1;
-        }
-
-        return (int8_t)value;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    DATA_TO_RANGED_SIGNED(endptr, value, data, int8_t, CHAR_MIN, CHAR_MAX);
 }
 
-
 uint64_t
-data_to_uint64 (data_t *data)
+data_to_uint64(data_t *data)
 {
-        if (!data)
-                return -1;
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
 
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    char *endptr = NULL;
+    uint64_t value = 0;
 
-        return strtoll (str, NULL, 0);
-}
+    errno = 0;
+    value = strtoull(data->data, &endptr, 0);
+
+    if (endptr && *endptr != '\0')
+        errno = EINVAL;
+    if (errno) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "Error in data conversion: '%s' can't "
+                         "be represented as uint64_t",
+                         data->data);
+        return -1;
+    }
+    return value;
+}
+
+/* Like above but implies unsigned range check. */
+
+#define DATA_TO_RANGED_UNSIGNED(endptr, value, data, type, max)                \
+    do {                                                                       \
+        errno = 0;                                                             \
+        value = strtoull(data->data, &endptr, 0);                              \
+        if (endptr && *endptr != '\0')                                         \
+            errno = EINVAL;                                                    \
+        if (errno || value > max) {                                            \
+            gf_msg_callingfn("dict", GF_LOG_WARNING, errno,                    \
+                             LG_MSG_DATA_CONVERSION_ERROR,                     \
+                             "Error in data conversion: '%s' can't "           \
+                             "be represented as " #type,                       \
+                             data->data);                                      \
+            return -1;                                                         \
+        }                                                                      \
+        return (type)value;                                                    \
+    } while (0)
 
 uint32_t
-data_to_uint32 (data_t *data)
+data_to_uint32(data_t *data)
 {
-        if (!data)
-                return -1;
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
+    char *endptr = NULL;
+    uint64_t value = 0;
 
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        return strtol (str, NULL, 0);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    DATA_TO_RANGED_UNSIGNED(endptr, value, data, uint32_t, UINT_MAX);
 }
 
 uint16_t
-data_to_uint16 (data_t *data)
+data_to_uint16(data_t *data)
 {
-	uint16_t value = 0;
-
-        if (!data)
-                return -1;
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-	errno = 0;
-	value = strtol (str, NULL, 0);
-
-	if ((USHRT_MAX - value) < 0) {
-		errno = ERANGE;
-		gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR,
-				  "Error in data conversion: "
-				  "overflow detected");
-		return -1;
-	}
+    char *endptr = NULL;
+    uint64_t value = 0;
 
-        return (uint16_t)value;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    DATA_TO_RANGED_UNSIGNED(endptr, value, data, uint16_t, USHRT_MAX);
 }
 
 uint8_t
-data_to_uint8 (data_t *data)
+data_to_uint8(data_t *data)
 {
-	uint32_t value = 0;
+    char *endptr = NULL;
+    uint64_t value = 0;
 
-        if (!data) {
-		gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return -1;
-	}
-
-        char *str = alloca (data->len + 1);
-        if (!str)
-                return -1;
-
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-	errno = 0;
-	value = strtol (str, NULL, 0);
-
-	if ((UCHAR_MAX - (uint8_t)value) < 0) {
-		errno = ERANGE;
-		gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "data "
-                                  "conversion overflow detected");
-		return -1;
-	}
-
-        return (uint8_t) value;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    DATA_TO_RANGED_UNSIGNED(endptr, value, data, uint8_t, UCHAR_MAX);
 }
 
 char *
-data_to_str (data_t *data)
+data_to_str(data_t *data)
 {
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return NULL;
-        }
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, "null", NULL);
+    return data->data;
 }
 
 void *
-data_to_ptr (data_t *data)
+data_to_ptr(data_t *data)
 {
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return NULL;
-        }
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
+    return data->data;
 }
 
 void *
-data_to_bin (data_t *data)
+data_to_bin(data_t *data)
 {
-        if (!data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return NULL;
-        }
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
+    return data->data;
+}
+
+struct iatt *
+data_to_iatt(data_t *data, char *key)
+{
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, NULL);
+
+    /* We only check for smaller size. If it's bigger we simply ignore
+     * the extra data. This way it's easy to do changes in the future that
+     * pass more data but are backward compatible (if the initial contents
+     * of the struct are maintained, of course). */
+    if (data->len < sizeof(struct iatt)) {
+        gf_smsg("glusterfs", GF_LOG_ERROR, ENOBUFS, LG_MSG_UNDERSIZED_BUF,
+                "key=%s", key, NULL);
+        return NULL;
+    }
+
+    return (struct iatt *)data->data;
 }
 
 int
-dict_null_foreach_fn (dict_t *d, char *k,
-                      data_t *v, void *tmp)
+dict_null_foreach_fn(dict_t *d, char *k, data_t *v, void *tmp)
 {
-        return 0;
+    return 0;
 }
 
 int
-dict_remove_foreach_fn (dict_t *d, char *k,
-                        data_t *v, void *_tmp)
-{
-        if (!d || !k) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, EINVAL,
-                        LG_MSG_INVALID_ENTRY, "%s is NULL",
-                        d?"key":"dictionary");
-                return -1;
-        }
+dict_remove_foreach_fn(dict_t *d, char *k, data_t *v, void *_tmp)
+{
+    if (!d || !k) {
+        gf_smsg("glusterfs", GF_LOG_WARNING, EINVAL, LG_MSG_KEY_OR_VALUE_NULL,
+                "d=%s", d ? "key" : "dictionary", NULL);
+        return -1;
+    }
 
-        dict_del (d, k);
-        return 0;
+    dict_del(d, k);
+    return 0;
 }
 
 gf_boolean_t
-dict_match_everything (dict_t *d, char *k, data_t *v, void *data)
+dict_match_everything(dict_t *d, char *k, data_t *v, void *data)
 {
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-dict_foreach (dict_t *dict,
-              int (*fn)(dict_t *this,
-                        char *key,
-                        data_t *value,
-                        void *data),
-              void *data)
+dict_foreach(dict_t *dict,
+             int (*fn)(dict_t *this, char *key, data_t *value, void *data),
+             void *data)
 {
-        int     ret = 0;
-
-        ret = dict_foreach_match (dict, dict_match_everything, NULL, fn, data);
+    int ret = dict_foreach_match(dict, dict_match_everything, NULL, fn, data);
 
-        if (ret > 0)
-                ret = 0;
+    if (ret > 0)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 /* return values:
@@ -1260,50 +1336,44 @@ dict_foreach (dict_t *dict,
    +n = n number of matches
 */
 int
-dict_foreach_match (dict_t *dict,
-             gf_boolean_t (*match)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *mdata),
-             void *match_data,
-             int (*action)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *adata),
-              void *action_data)
-{
-        if (!dict || !match || !action) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict|match|action is "
-                                  "NULL");
-                return -1;
-        }
-
-        int          ret   = -1;
-        int          count = 0;
-        data_pair_t *pairs = NULL;
-        data_pair_t *next  = NULL;
-
-        pairs = dict->members_list;
-        while (pairs) {
-                next = pairs->next;
-                if (match (dict, pairs->key, pairs->value, match_data)) {
-                        ret = action (dict, pairs->key, pairs->value,
-                                      action_data);
-                        if (ret < 0)
-                                return ret;
-                        count++;
-                }
-                pairs = next;
+dict_foreach_match(dict_t *dict,
+                   gf_boolean_t (*match)(dict_t *this, char *key, data_t *value,
+                                         void *mdata),
+                   void *match_data,
+                   int (*action)(dict_t *this, char *key, data_t *value,
+                                 void *adata),
+                   void *action_data)
+{
+    if (!dict || !match || !action) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict|match|action is "
+                         "NULL");
+        return -1;
+    }
+
+    int ret = -1;
+    int count = 0;
+    data_pair_t *pairs = dict->members_list;
+    data_pair_t *next = NULL;
+
+    while (pairs) {
+        next = pairs->next;
+        if (match(dict, pairs->key, pairs->value, match_data)) {
+            ret = action(dict, pairs->key, pairs->value, action_data);
+            if (ret < 0)
+                return ret;
+            count++;
         }
+        pairs = next;
+    }
 
-        return count;
+    return count;
 }
 
 static gf_boolean_t
-dict_fnmatch (dict_t *d, char *k, data_t *val, void *match_data)
+dict_fnmatch(dict_t *d, char *k, data_t *val, void *match_data)
 {
-        return (fnmatch (match_data, k, 0) == 0);
+    return (fnmatch(match_data, k, 0) == 0);
 }
 /* return values:
    -1 = failure,
@@ -1311,17 +1381,14 @@ dict_fnmatch (dict_t *d, char *k, data_t *val, void *match_data)
    +n = n number of matches
 */
 int
-dict_foreach_fnmatch (dict_t *dict, char *pattern,
-                      int (*fn)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *data),
-                      void *data)
+dict_foreach_fnmatch(dict_t *dict, char *pattern,
+                     int (*fn)(dict_t *this, char *key, data_t *value,
+                               void *data),
+                     void *data)
 {
-        return dict_foreach_match (dict, dict_fnmatch, pattern, fn, data);
+    return dict_foreach_match(dict, dict_fnmatch, pattern, fn, data);
 }
 
-
 /**
  * dict_keys_join - pack the keys of the dictionary in a buffer.
  *
@@ -1336,89 +1403,85 @@ dict_foreach_fnmatch (dict_t *dict, char *pattern,
  */
 
 int
-dict_keys_join (void *value, int size, dict_t *dict,
-                int (*filter_fn)(char *k))
+dict_keys_join(void *value, int size, dict_t *dict, int (*filter_fn)(char *k))
 {
-	int          len = 0;
-        data_pair_t *pairs = NULL;
-        data_pair_t *next  = NULL;
+    int len = 0;
+    data_pair_t *pairs = dict->members_list;
+    data_pair_t *next = NULL;
 
-        pairs = dict->members_list;
-        while (pairs) {
-                next = pairs->next;
+    while (pairs) {
+        next = pairs->next;
 
-                if (filter_fn && filter_fn (pairs->key)){
-		    pairs = next;
-		    continue;
-		}
+        if (filter_fn && filter_fn(pairs->key)) {
+            pairs = next;
+            continue;
+        }
 
-		if (value && (size > len))
-			strncpy (value + len, pairs->key, size - len);
+        if (value && (size > len))
+            strncpy(value + len, pairs->key, size - len);
 
-                len += (strlen (pairs->key) + 1);
+        len += (strlen(pairs->key) + 1);
 
-                pairs = next;
-        }
+        pairs = next;
+    }
 
-	return len;
+    return len;
 }
 
 static int
-dict_copy_one (dict_t *unused, char *key, data_t *value, void *newdict)
+dict_copy_one(dict_t *unused, char *key, data_t *value, void *newdict)
 {
-        return dict_set ((dict_t *)newdict, key, (value));
+    return dict_set((dict_t *)newdict, key, (value));
 }
 
 dict_t *
-dict_copy (dict_t *dict,
-           dict_t *new)
+dict_copy(dict_t *dict, dict_t *new)
 {
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return NULL;
-        }
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return NULL;
+    }
 
-        if (!new)
-                new = get_new_dict_full (dict->hash_size);
+    if (!new)
+        new = get_new_dict_full(dict->hash_size);
 
-        dict_foreach (dict, dict_copy_one, new);
+    dict_foreach(dict, dict_copy_one, new);
 
-        return new;
+    return new;
 }
 
 int
-dict_reset (dict_t *dict)
-{
-        int32_t         ret = -1;
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                goto out;
-        }
-        dict_foreach (dict, dict_remove_foreach_fn, NULL);
-        ret = 0;
+dict_reset(dict_t *dict)
+{
+    int32_t ret = -1;
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+    dict_foreach(dict, dict_remove_foreach_fn, NULL);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 dict_t *
-dict_copy_with_ref (dict_t *dict,
-                    dict_t *new)
+dict_copy_with_ref(dict_t *dict, dict_t *new)
 {
-        dict_t *local_new = NULL;
+    dict_t *local_new = NULL;
 
-        GF_VALIDATE_OR_GOTO("dict", dict, fail);
+    GF_VALIDATE_OR_GOTO("dict", dict, fail);
 
-        if (new == NULL) {
-                local_new = dict_new ();
-                GF_VALIDATE_OR_GOTO("dict", local_new, fail);
-                new = local_new;
-        }
+    if (new == NULL) {
+        local_new = dict_new();
+        GF_VALIDATE_OR_GOTO("dict", local_new, fail);
+        new = local_new;
+    }
 
-        dict_foreach (dict, dict_copy_one, new);
+    dict_foreach(dict, dict_copy_one, new);
 fail:
-        return new;
+    return new;
 }
 
 /*
@@ -1432,893 +1495,1118 @@ fail:
  *               -val error, val = errno
  */
 
-
-int
-dict_get_with_ref (dict_t *this, char *key, data_t **data)
+static int
+dict_get_with_refn(dict_t *this, char *key, const int keylen, data_t **data)
 {
-        data_pair_t * pair = NULL;
-        int           ret  = -ENOENT;
-        uint32_t      hash = 0;
+    data_pair_t *pair = NULL;
+    int ret = -ENOENT;
+    uint32_t hash;
 
-        if (!this || !key || !data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "dict OR key (%s) is NULL", key);
-                ret = -EINVAL;
-                goto err;
+    hash = (uint32_t)XXH64(key, keylen, 0);
+
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
+
+        if (pair) {
+            ret = 0;
+            *data = data_ref(pair->value);
         }
+    }
+    UNLOCK(&this->lock);
 
-        hash = SuperFastHash (key, strlen (key));
+    return ret;
+}
 
-        LOCK (&this->lock);
-        {
-                pair = dict_lookup_common (this, key, hash);
+int
+dict_get_with_ref(dict_t *this, char *key, data_t **data)
+{
+    if (!this || !key || !data) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict OR key (%s) is NULL", key);
+        return -EINVAL;
+    }
 
-                if (pair) {
-                        ret = 0;
-                        *data = data_ref (pair->value);
-                 }
-        }
-        UNLOCK (&this->lock);
-err:
-        return ret;
+    return dict_get_with_refn(this, key, strlen(key), data);
 }
 
 static int
-data_to_ptr_common (data_t *data, void **val)
+data_to_ptr_common(data_t *data, void **val)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        *val = data->data;
+    *val = data->data;
 err:
-        return ret;
+    return ret;
 }
 
-
 static int
-data_to_int8_ptr (data_t *data, int8_t *val)
+data_to_int8_ptr(data_t *data, int8_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
-
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    int ret = 0;
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int16_ptr (data_t *data, int16_t *val)
+data_to_int16_ptr(data_t *data, int16_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
-
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    int ret = 0;
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int32_ptr (data_t *data, int32_t *val)
+data_to_int32_ptr(data_t *data, int32_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
-
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int64_ptr (data_t *data, int64_t *val)
+data_to_int64_ptr(data_t *data, int64_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
-
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtoll (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoll(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint16_ptr (data_t *data, uint16_t *val)
+data_to_uint16_ptr(data_t *data, uint16_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        errno = 0;
-        *val = strtoul (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoul(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint32_ptr (data_t *data, uint32_t *val)
+data_to_uint32_ptr(data_t *data, uint32_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        errno = 0;
-        *val = strtoul (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoul(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint64_ptr (data_t *data, uint64_t *val)
+data_to_uint64_ptr(data_t *data, uint64_t *val)
 {
-        int    ret = 0;
-        char * str = NULL;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
-
-        errno = 0;
-        *val = strtoull (str, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoull(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_double_ptr (data_t *data, double *val)
+data_to_double_ptr(data_t *data, double *val)
 {
-        int    ret = 0;
-        char * str = NULL;
-
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    int ret = 0;
 
-        str = alloca (data->len + 1);
-        if (!str) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        memcpy (str, data->data, data->len);
-        str[data->len] = '\0';
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtod (str, NULL);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtod(data->data, NULL);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int8 (dict_t *this, char *key, int8_t *val)
+dict_get_int8(dict_t *this, char *key, int8_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int8_ptr (data, val);
+    ret = data_to_int8_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_int8 (dict_t *this, char *key, int8_t val)
+dict_set_int8(dict_t *this, char *key, int8_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int8 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int8(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int16 (dict_t *this, char *key, int16_t *val)
+dict_get_int16(dict_t *this, char *key, int16_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int16_ptr (data, val);
+    ret = data_to_int16_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
+int
+dict_set_int16(dict_t *this, char *key, int16_t val)
+{
+    data_t *data = NULL;
+    int ret = 0;
+
+    data = data_from_int16(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
+
+err:
+    return ret;
+}
 
 int
-dict_set_int16 (dict_t *this, char *key, int16_t val)
+dict_get_int32n(dict_t *this, char *key, const int keylen, int32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int16 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_get_with_refn(this, key, keylen, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+
+    ret = data_to_int32_ptr(data, val);
 
 err:
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_get_int32 (dict_t *this, char *key, int32_t *val)
+dict_get_int32(dict_t *this, char *key, int32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int32_ptr (data, val);
+    ret = data_to_int32_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
+int
+dict_set_int32n(dict_t *this, char *key, const int keylen, int32_t val)
+{
+    data_t *data = NULL;
+    int ret = 0;
+
+    data = data_from_int32(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
+
+err:
+    return ret;
+}
 
 int
-dict_set_int32 (dict_t *this, char *key, int32_t val)
+dict_set_int32(dict_t *this, char *key, int32_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_int32(val);
+    int ret = 0;
 
-        data = data_from_int32 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int64 (dict_t *this, char *key, int64_t *val)
+dict_get_int64(dict_t *this, char *key, int64_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        ret = data_to_int64_ptr (data, val);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+
+    ret = data_to_int64_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_int64 (dict_t *this, char *key, int64_t val)
+dict_set_int64(dict_t *this, char *key, int64_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_int64(val);
+    int ret = 0;
 
-        data = data_from_int64 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint16 (dict_t *this, char *key, uint16_t *val)
+dict_get_uint16(dict_t *this, char *key, uint16_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint16_ptr (data, val);
+    ret = data_to_uint16_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_uint16 (dict_t *this, char *key, uint16_t val)
+dict_set_uint16(dict_t *this, char *key, uint16_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_uint16(val);
+    int ret = 0;
 
-        data = data_from_uint16 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint32 (dict_t *this, char *key, uint32_t *val)
+dict_get_uint32(dict_t *this, char *key, uint32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        ret = data_to_uint32_ptr (data, val);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
+
+    ret = data_to_uint32_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
-
 int
-dict_set_uint32 (dict_t *this, char *key, uint32_t val)
+dict_set_uint32(dict_t *this, char *key, uint32_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_uint32(val);
+    int ret = 0;
 
-        data = data_from_uint32 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint64 (dict_t *this, char *key, uint64_t *val)
+dict_get_uint64(dict_t *this, char *key, uint64_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint64_ptr (data, val);
+    ret = data_to_uint64_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_uint64 (dict_t *this, char *key, uint64_t val)
+dict_set_uint64(dict_t *this, char *key, uint64_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_uint64(val);
+    int ret = 0;
 
-        data = data_from_uint64 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
+/*
+ * dict_check_flag can be used to check a one bit flag in an array of flags
+ * The flag argument indicates the bit position (within the array of bits).
+ * Currently limited to max of 256 flags for a key.
+ * return value,
+ * 1 : flag is set
+ * 0 : flag is not set
+ * <0: Error
+ */
 int
-dict_get_double (dict_t *this, char *key, double *val)
+dict_check_flag(dict_t *this, char *key, int flag)
 {
-        data_t *data = NULL;
-        int     ret  = 0;
+    data_t *data = NULL;
+    int ret = -ENOENT;
+
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (BIT_VALUE((unsigned char *)(data->data), flag))
+        ret = 1;
+    else
+        ret = 0;
+
+    data_unref(data);
+    return ret;
+}
+
+/*
+ * _dict_modify_flag can be used to set/clear a bit flag in an array of flags
+ * flag: indicates the bit position. limited to max of DICT_MAX_FLAGS.
+ * op: Indicates operation DICT_FLAG_SET / DICT_FLAG_CLEAR
+ */
+static int
+_dict_modify_flag(dict_t *this, char *key, int flag, int op)
+{
+    data_t *data = NULL;
+    int ret = 0;
+    data_pair_t *pair = NULL;
+    char *ptr = NULL;
+    int hashval = 0;
+    uint32_t hash;
+
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict OR key (%s) is NULL", key);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    /*
+     * Using a size of 32 bytes to support max of 256
+     * flags in a single key. This should be suffcient.
+     */
+    GF_ASSERT(flag >= 0 && flag < DICT_MAX_FLAGS);
+
+    hash = (uint32_t)XXH64(key, strlen(key), 0);
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
+
+        if (pair) {
+            data = pair->value;
+            if (op == DICT_FLAG_SET)
+                BIT_SET((unsigned char *)(data->data), flag);
+            else
+                BIT_CLEAR((unsigned char *)(data->data), flag);
+        } else {
+            ptr = GF_CALLOC(1, DICT_MAX_FLAGS / 8, gf_common_mt_char);
+            if (!ptr) {
+                gf_smsg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                        "flag bit array", NULL);
+                ret = -ENOMEM;
+                goto err;
+            }
+
+            data = data_from_dynptr(ptr, DICT_MAX_FLAGS / 8);
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
+            if (!data) {
+                gf_smsg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, "data",
+                        NULL);
+                GF_FREE(ptr);
+                ret = -ENOMEM;
                 goto err;
-        }
+            }
+
+            if (op == DICT_FLAG_SET)
+                BIT_SET((unsigned char *)(data->data), flag);
+            else
+                BIT_CLEAR((unsigned char *)(data->data), flag);
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
+            if (this->free_pair.key) { /* the free pair is in use */
+                pair = mem_get0(THIS->ctx->dict_pair_pool);
+                if (!pair) {
+                    gf_smsg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                            "dict pair", NULL);
+                    ret = -ENOMEM;
+                    goto err;
+                }
+            } else { /* use the free pair */
+                pair = &this->free_pair;
+            }
+
+            pair->key = (char *)GF_MALLOC(strlen(key) + 1, gf_common_mt_char);
+            if (!pair->key) {
+                gf_smsg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                        "dict pair", NULL);
+                ret = -ENOMEM;
                 goto err;
+            }
+            strcpy(pair->key, key);
+            pair->key_hash = hash;
+            pair->value = data_ref(data);
+            this->totkvlen += (strlen(key) + 1 + data->len);
+            hashval = hash % this->hash_size;
+            pair->hash_next = this->members[hashval];
+            this->members[hashval] = pair;
+
+            pair->next = this->members_list;
+            pair->prev = NULL;
+            if (this->members_list)
+                this->members_list->prev = pair;
+            this->members_list = pair;
+            this->count++;
+
+            if (this->max_count < this->count)
+                this->max_count = this->count;
         }
+    }
 
-        ret = data_to_double_ptr (data, val);
+    UNLOCK(&this->lock);
+    return 0;
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (key && this)
+        UNLOCK(&this->lock);
+
+    if (pair) {
+        if (pair->key) {
+            GF_FREE(pair->key);
+            pair->key = NULL;
+        }
+        if (pair != &this->free_pair) {
+            mem_put(pair);
+        }
+    }
+
+    if (data)
+        data_destroy(data);
+
+    gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_DICT_SET_FAILED, "key=%s", key,
+            NULL);
+
+    return ret;
 }
 
+/*
+ * Todo:
+ * Add below primitives as needed:
+ * dict_check_flags(this, key, flag...): variadic function to check
+ *                                       multiple flags at a time.
+ * dict_set_flags(this, key, flag...): set multiple flags
+ * dict_clear_flags(this, key, flag...): reset multiple flags
+ */
+
 int
-dict_set_double (dict_t *this, char *key, double val)
+dict_set_flag(dict_t *this, char *key, int flag)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_SET);
+}
 
-        data = data_from_double (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+int
+dict_clear_flag(dict_t *this, char *key, int flag)
+{
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_CLEAR);
+}
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+int
+dict_get_double(dict_t *this, char *key, double *val)
+{
+    data_t *data = NULL;
+    int ret = 0;
+
+    if (!val) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_DOUBLE, key, -EINVAL);
+
+    ret = data_to_double_ptr(data, val);
 
 err:
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_set_static_ptr (dict_t *this, char *key, void *ptr)
+dict_set_double(dict_t *this, char *key, double val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_double(val);
+    int ret = 0;
 
-        data = data_from_ptr_common (ptr, _gf_true);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_set_dynptr (dict_t *this, char *key, void *ptr, size_t len)
+dict_set_static_ptr(dict_t *this, char *key, void *ptr)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_ptr_common(ptr, _gf_true);
+    int ret = 0;
 
-        data = data_from_dynptr (ptr, len);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_ptr (dict_t *this, char *key, void **ptr)
+dict_set_dynptr(dict_t *this, char *key, void *ptr, size_t len)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = data_from_dynptr(ptr, len);
+    int ret = 0;
 
-        if (!this || !key || !ptr) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+err:
+    return ret;
+}
+
+int
+dict_get_ptr(dict_t *this, char *key, void **ptr)
+{
+    data_t *data = NULL;
+    int ret = 0;
+
+    if (!ptr) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
+
+    ret = data_to_ptr_common(data, ptr);
+    if (ret != 0) {
+        goto err;
+    }
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_get_ptr_and_len (dict_t *this, char *key, void **ptr, int *len)
+dict_get_ptr_and_len(dict_t *this, char *key, void **ptr, int *len)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !ptr) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!ptr) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-	*len = data->len;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+    *len = data->len;
+
+    ret = data_to_ptr_common(data, ptr);
+    if (ret != 0) {
+        goto err;
+    }
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
+/* Get string - with known key length */
 int
-dict_set_ptr (dict_t *this, char *key, void *ptr)
+dict_get_strn(dict_t *this, char *key, const int keylen, char **str)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        data = data_from_ptr_common (ptr, _gf_false);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !str) {
+        goto err;
+    }
+    ret = dict_get_with_refn(this, key, keylen, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
+
+    *str = data->data;
 
 err:
-        return ret;
-}
+    if (data)
+        data_unref(data);
 
+    return ret;
+}
 
 int
-dict_get_str (dict_t *this, char *key, char **str)
+dict_get_str(dict_t *this, char *key, char **str)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !str) {
-                goto err;
-        }
+    if (!str) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
 
-        if (!data || !data->data) {
-                goto err;
-        }
-        *str = data->data;
+    *str = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_set_str (dict_t *this, char *key, char *str)
+dict_set_str(dict_t *this, char *key, char *str)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = str_to_data(str);
+    int ret = 0;
 
-        data = str_to_data (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
+/* Set string - with known key length */
 int
-dict_set_dynstr_with_alloc (dict_t *this, char *key, const char *str)
+dict_set_strn(dict_t *this, char *key, const int keylen, char *str)
 {
-        char *alloc_str = NULL;
-        int   ret       = -1;
+    data_t *data = NULL;
+    int ret = 0;
 
-        alloc_str = gf_strdup (str);
-        if (!alloc_str)
-                return -1;
+    data = str_to_data(str);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set_dynstr (this, key, alloc_str);
-        if (ret == -EINVAL)
-                GF_FREE (alloc_str);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
-        return ret;
+err:
+    return ret;
 }
 
+/* Set string - with known key length and known value length */
 int
-dict_set_dynstr (dict_t *this, char *key, char *str)
+dict_set_nstrn(dict_t *this, char *key, const int keylen, char *str,
+               const int vallen)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = strn_to_data(str, vallen);
+    int ret = 0;
 
-        data = data_from_dynstr (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
+    return ret;
+}
+
+int
+dict_set_dynstr_with_alloc(dict_t *this, char *key, const char *str)
+{
+    char *alloc_str = gf_strdup(str);
+    int ret = -1;
+
+    if (!alloc_str)
         return ret;
+
+    ret = dict_set_dynstr(this, key, alloc_str);
+    if (ret == -EINVAL)
+        GF_FREE(alloc_str);
+
+    return ret;
 }
 
 int
-dict_add_dynstr_with_alloc (dict_t *this, char *key, char *str)
+dict_set_dynstr(dict_t *this, char *key, char *str)
 {
-        data_t  *data = NULL;
-        int      ret  = 0;
-        char    *alloc_str = NULL;
+    const int keylen = strlen(key);
+    return dict_set_dynstrn(this, key, keylen, str);
+}
 
-        alloc_str = gf_strdup (str);
-        if (!alloc_str)
-                goto out;
+int
+dict_set_dynstrn(dict_t *this, char *key, const int keylen, char *str)
+{
+    data_t *data = data_from_dynstr(str);
+    int ret = 0;
 
-        data = data_from_dynstr (alloc_str);
-        if (!data) {
-                GF_FREE (alloc_str);
-                ret = -EINVAL;
-                goto out;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_add (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
-out:
-        return ret;
+err:
+    return ret;
 }
 
+/* This function is called only by the volgen for now.
+   Check how else you can handle it */
+int
+dict_set_option(dict_t *this, char *key, char *str)
+{
+    data_t *data = data_from_dynstr(str);
+    int ret = 0;
+
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
+
+    data->data_type = GF_DATA_TYPE_STR_OLD;
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
+err:
+    return ret;
+}
 
 int
-dict_get_bin (dict_t *this, char *key, void **bin)
+dict_add_dynstr_with_alloc(dict_t *this, char *key, char *str)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = 0;
+    char *alloc_str = gf_strdup(str);
 
-        if (!this || !key || !bin) {
-                goto err;
-        }
+    if (!alloc_str)
+        goto out;
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    data = data_from_dynstr(alloc_str);
+    if (!data) {
+        GF_FREE(alloc_str);
+        ret = -EINVAL;
+        goto out;
+    }
 
-        if (!data || !data->data) {
-                goto err;
-        }
-        *bin = data->data;
+    ret = dict_add(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
+
+out:
+    return ret;
+}
+
+int
+dict_get_bin(dict_t *this, char *key, void **bin)
+{
+    data_t *data = NULL;
+    int ret = -EINVAL;
+
+    if (!bin) {
+        goto err;
+    }
+
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, ret);
+
+    *bin = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 /********************************************************************
@@ -2331,34 +2619,35 @@ err:
  *
  *******************************************************************/
 static int
-dict_set_bin_common (dict_t *this, char *key, void *ptr, size_t size,
-                     gf_boolean_t is_static)
+dict_set_bin_common(dict_t *this, char *key, void *ptr, size_t size,
+                    gf_boolean_t is_static, gf_dict_data_type_t type)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!ptr || (size > ULONG_MAX)) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!ptr || (size > DICT_KEY_VALUE_MAX_SIZE)) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        data = bin_to_data (ptr, size);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = bin_to_data(ptr, size);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        data->is_static = is_static;
+    data->is_static = is_static;
+    data->data_type = type;
 
-        ret = dict_set (this, key, data);
-        if (ret < 0) {
-                /* don't free data->data, let callers handle it */
-                data->data = NULL;
-                data_destroy (data);
-        }
+    ret = dict_set(this, key, data);
+    if (ret < 0) {
+        /* don't free data->data, let callers handle it */
+        data->data = NULL;
+        data_destroy(data);
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 /********************************************************************
@@ -2369,9 +2658,10 @@ err:
  *
  *******************************************************************/
 int
-dict_set_bin (dict_t *this, char *key, void *ptr, size_t size)
+dict_set_bin(dict_t *this, char *key, void *ptr, size_t size)
 {
-        return dict_set_bin_common (this, key, ptr, size, _gf_false);
+    return dict_set_bin_common(this, key, ptr, size, _gf_false,
+                               GF_DATA_TYPE_PTR);
 }
 
 /********************************************************************
@@ -2382,11 +2672,115 @@ dict_set_bin (dict_t *this, char *key, void *ptr, size_t size)
  *
  *******************************************************************/
 int
-dict_set_static_bin (dict_t *this, char *key, void *ptr, size_t size)
+dict_set_static_bin(dict_t *this, char *key, void *ptr, size_t size)
+{
+    return dict_set_bin_common(this, key, ptr, size, _gf_true,
+                               GF_DATA_TYPE_PTR);
+}
+
+/*  */
+int
+dict_set_gfuuid(dict_t *this, char *key, uuid_t gfid, bool is_static)
+{
+    return dict_set_bin_common(this, key, gfid, sizeof(uuid_t), is_static,
+                               GF_DATA_TYPE_GFUUID);
+}
+
+int
+dict_get_gfuuid(dict_t *this, char *key, uuid_t *gfid)
+{
+    data_t *data = NULL;
+    int ret = -EINVAL;
+
+    if (!gfid) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_GFUUID, key, -EINVAL);
+
+    memcpy(*gfid, data->data, min(data->len, sizeof(uuid_t)));
+
+err:
+    if (data)
+        data_unref(data);
+
+    return ret;
+}
+
+int
+dict_set_mdata(dict_t *this, char *key, struct mdata_iatt *mdata,
+               bool is_static)
+{
+    return dict_set_bin_common(this, key, mdata, sizeof(struct mdata_iatt),
+                               is_static, GF_DATA_TYPE_MDATA);
+}
+
+int
+dict_get_mdata(dict_t *this, char *key, struct mdata_iatt *mdata)
+{
+    data_t *data = NULL;
+    int ret = -EINVAL;
+
+    if (!mdata) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_MDATA, key, -EINVAL);
+    if (data->len < sizeof(struct mdata_iatt)) {
+        gf_smsg("glusterfs", GF_LOG_ERROR, ENOBUFS, LG_MSG_UNDERSIZED_BUF,
+                "key=%s", key, NULL);
+        ret = -ENOBUFS;
+        goto err;
+    }
+
+    memcpy(mdata, data->data, min(data->len, sizeof(struct mdata_iatt)));
+
+err:
+    if (data)
+        data_unref(data);
+
+    return ret;
+}
+
+int
+dict_set_iatt(dict_t *this, char *key, struct iatt *iatt, bool is_static)
 {
-        return dict_set_bin_common (this, key, ptr, size, _gf_true);
+    return dict_set_bin_common(this, key, iatt, sizeof(struct iatt), is_static,
+                               GF_DATA_TYPE_IATT);
 }
 
+int
+dict_get_iatt(dict_t *this, char *key, struct iatt *iatt)
+{
+    data_t *data = NULL;
+    int ret = -EINVAL;
+
+    if (!iatt) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
+
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, -EINVAL);
+
+    memcpy(iatt, data->data, min(data->len, sizeof(struct iatt)));
+
+err:
+    if (data)
+        data_unref(data);
+
+    return ret;
+}
 
 /**
  * dict_get_str_boolean - get a boolean value based on string representation.
@@ -2412,70 +2806,76 @@ dict_set_static_bin (dict_t *this, char *key, void *ptr, size_t size)
  */
 
 int
-dict_get_str_boolean (dict_t *this, char *key, int default_val)
+dict_get_str_boolean(dict_t *this, char *key, int default_val)
 {
-        data_t       *data = NULL;
-        gf_boolean_t  boo = _gf_false;
-        int           ret  = 0;
+    data_t *data = NULL;
+    gf_boolean_t boo = _gf_false;
+    int ret = 0;
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                if (ret == -ENOENT)
-                        ret = default_val;
-                else
-                        ret = -1;
-                goto err;
-        }
-
-        GF_ASSERT (data);
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        if (ret == -ENOENT)
+            ret = default_val;
+        else
+            ret = -1;
+        goto err;
+    }
 
-        if (!data->data) {
-                ret = -1;
-                goto err;
-        }
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = gf_string2boolean (data->data, &boo);
-        if (ret == -1)
-                goto err;
+    ret = gf_strn2boolean(data->data, data->len - 1, &boo);
+    if (ret == -1)
+        goto err;
 
-        ret = boo;
+    ret = boo;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_rename_key (dict_t *this, char *key, char *replace_key)
+dict_rename_key(dict_t *this, char *key, char *replace_key)
 {
-        data_pair_t *pair = NULL;
-        int          ret  = -EINVAL;
-        uint32_t     hash = 0;
-
-        /* replacing a key by itself is a NO-OP */
-        if (strcmp (key, replace_key) == 0)
-                return 0;
+    data_pair_t *pair = NULL;
+    int ret = -EINVAL;
+    uint32_t hash;
+    uint32_t replacekey_hash;
+    int replacekey_len;
 
-        hash = SuperFastHash (key, strlen (key));
+    /* replacing a key by itself is a NO-OP */
+    if (strcmp(key, replace_key) == 0)
+        return 0;
 
-        LOCK (&this->lock);
-        {
-                /* no need to data_ref(pair->value), dict_set_lk() does it */
-                pair = dict_lookup_common (this, key, hash);
-                if (!pair)
-                        ret = -ENODATA;
-                else
-                        ret = dict_set_lk (this, replace_key, pair->value, 1);
-        }
-        UNLOCK (&this->lock);
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return ret;
+    }
+
+    hash = (uint32_t)XXH64(key, strlen(key), 0);
+    replacekey_len = strlen(replace_key);
+    replacekey_hash = (uint32_t)XXH64(replace_key, replacekey_len, 0);
+
+    LOCK(&this->lock);
+    {
+        /* no need to data_ref(pair->value), dict_set_lk() does it */
+        pair = dict_lookup_common(this, key, hash);
+        if (!pair)
+            ret = -ENODATA;
+        else
+            ret = dict_set_lk(this, replace_key, replacekey_len, pair->value,
+                              replacekey_hash, 1);
+    }
+    UNLOCK(&this->lock);
 
-        if (!ret)
-                /* only delete the key on success */
-                dict_del (this, key);
+    if (!ret)
+        /* only delete the key on success */
+        dict_del(this, key);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -2486,10 +2886,6 @@ dict_rename_key (dict_t *this, char *key, char *replace_key)
  *     4        4         4       <key len>   <value len>
  */
 
-#define DICT_HDR_LEN               4
-#define DICT_DATA_HDR_KEY_LEN      4
-#define DICT_DATA_HDR_VAL_LEN      4
-
 /**
  * dict_serialized_length_lk - return the length of serialized dict. This
  *                             procedure has to be called with this->lock held.
@@ -2500,64 +2896,21 @@ dict_rename_key (dict_t *this, char *key, char *replace_key)
  */
 
 int
-dict_serialized_length_lk (dict_t *this)
+dict_serialized_length_lk(dict_t *this)
 {
-        int ret            = -EINVAL;
-        int count          = 0;
-        int len            = 0;
-        data_pair_t * pair = NULL;
-
-        len = DICT_HDR_LEN;
-        count = this->count;
-
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                        LG_MSG_COUNT_LESS_THAN_ZERO, "count (%d) < 0!", count);
-                goto out;
-        }
-
-        pair = this->members_list;
-
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_COUNT_LESS_THAN_DATA_PAIRS,
-                                "less than count data pairs found!");
-                        goto out;
-                }
-
-                len += DICT_DATA_HDR_KEY_LEN + DICT_DATA_HDR_VAL_LEN;
-
-                if (!pair->key) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_NULL_PTR, "pair->key is null!");
-                        goto out;
-                }
+    int ret = -EINVAL;
+    int count = this->count;
+    const int keyhdrlen = DICT_DATA_HDR_KEY_LEN + DICT_DATA_HDR_VAL_LEN;
 
-                len += strlen (pair->key) + 1  /* for '\0' */;
+    if (count < 0) {
+        gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_COUNT_LESS_THAN_ZERO,
+                "count=%d", count, NULL);
+        goto out;
+    }
 
-                if (!pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_NULL_PTR, "pair->value is null!");
-                        goto out;
-                }
-
-                if (pair->value->len < 0) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO,
-                                "value->len (%d) < 0", pair->value->len);
-                        goto out;
-                }
-
-                len += pair->value->len;
-
-                pair = pair->next;
-                count--;
-        }
-
-        ret = len;
+    ret = DICT_HDR_LEN + this->totkvlen + (count * keyhdrlen);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2566,92 +2919,80 @@ out:
  *
  * @this: dict to serialize
  * @buf:  buffer to serialize into. This must be
- *        atleast dict_serialized_length (this) large
+ *        at least dict_serialized_length (this) large
  *
  * @return: success: 0
  *          failure: -errno
  */
 
-int
-dict_serialize_lk (dict_t *this, char *buf)
+static int
+dict_serialize_lk(dict_t *this, char *buf)
 {
-        int           ret     = -1;
-        data_pair_t * pair    = NULL;
-        int32_t       count   = 0;
-        int32_t       keylen  = 0;
-        int32_t       vallen  = 0;
-        int32_t       netword = 0;
+    int ret = -1;
+    data_pair_t *pair = this->members_list;
+    int32_t count = this->count;
+    int32_t keylen = 0;
+    int32_t netword = 0;
 
+    if (!buf) {
+        gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, NULL);
+        goto out;
+    }
 
-        if (!buf) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
-                        "buf is null!");
-                goto out;
-        }
+    if (count < 0) {
+        gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
+                "count=%d", count, NULL);
+        goto out;
+    }
 
+    netword = hton32(count);
+    memcpy(buf, &netword, sizeof(netword));
+    buf += DICT_HDR_LEN;
 
-        count = this->count;
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
-                        "count (%d) < 0!", count);
-                goto out;
+    while (count) {
+        if (!pair) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_PAIRS_LESS_THAN_COUNT,
+                    NULL);
+            goto out;
         }
 
-        netword = hton32 (count);
-        memcpy (buf, &netword, sizeof(netword));
-        buf += DICT_HDR_LEN;
-        pair = this->members_list;
-
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_PAIRS_LESS_THAN_COUNT,
-                                "less than count data pairs found!");
-                        goto out;
-                }
-
-                if (!pair->key) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR,
-                                "pair->key is null!");
-                        goto out;
-                }
-
-                keylen  = strlen (pair->key);
-                netword = hton32 (keylen);
-                memcpy (buf, &netword, sizeof(netword));
-                buf += DICT_DATA_HDR_KEY_LEN;
+        if (!pair->key) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR, NULL);
+            goto out;
+        }
 
-                if (!pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_NULL_PTR,
-                                "pair->value is null!");
-                        goto out;
-                }
+        keylen = strlen(pair->key);
+        netword = hton32(keylen);
+        memcpy(buf, &netword, sizeof(netword));
+        buf += DICT_DATA_HDR_KEY_LEN;
 
-                vallen  = pair->value->len;
-                netword = hton32 (vallen);
-                memcpy (buf, &netword, sizeof(netword));
-                buf += DICT_DATA_HDR_VAL_LEN;
+        if (!pair->value) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR, NULL);
+            goto out;
+        }
 
-                memcpy (buf, pair->key, keylen);
-                buf += keylen;
-                *buf++ = '\0';
+        netword = hton32(pair->value->len);
+        memcpy(buf, &netword, sizeof(netword));
+        buf += DICT_DATA_HDR_VAL_LEN;
 
-                if (pair->value->data) {
-                        memcpy (buf, pair->value->data, vallen);
-                        buf += vallen;
-                }
+        memcpy(buf, pair->key, keylen);
+        buf += keylen;
+        *buf++ = '\0';
 
-                pair = pair->next;
-                count--;
+        if (pair->value->data) {
+            memcpy(buf, pair->value->data, pair->value->len);
+            buf += pair->value->len;
         }
 
-        ret = 0;
+        pair = pair->next;
+        count--;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_serialized_length - return the length of serialized dict
  *
@@ -2661,24 +3002,24 @@ out:
  */
 
 int
-dict_serialized_length (dict_t *this)
+dict_serialized_length(dict_t *this)
 {
-        int ret            = -EINVAL;
+    int ret = -EINVAL;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = dict_serialized_length_lk (this);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = dict_serialized_length_lk(this);
+    }
+    UNLOCK(&this->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2686,33 +3027,32 @@ out:
  *
  * @this: dict to serialize
  * @buf:  buffer to serialize into. This must be
- *        atleast dict_serialized_length (this) large
+ *        at least dict_serialized_length (this) large
  *
  * @return: success: 0
  *          failure: -errno
  */
 
 int
-dict_serialize (dict_t *this, char *buf)
+dict_serialize(dict_t *this, char *buf)
 {
-        int           ret    = -1;
+    int ret = -1;
 
-        if (!this || !buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
+    if (!this || !buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = dict_serialize_lk (this, buf);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = dict_serialize_lk(this, buf);
+    }
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_unserialize - unserialize a buffer into a dict
  *
@@ -2725,135 +3065,137 @@ out:
  */
 
 int32_t
-dict_unserialize (char *orig_buf, int32_t size, dict_t **fill)
-{
-        char   *buf = NULL;
-        int     ret   = -1;
-        int32_t count = 0;
-        int     i     = 0;
-
-        data_t * value   = NULL;
-        char   * key     = NULL;
-        int32_t  keylen  = 0;
-        int32_t  vallen  = 0;
-        int32_t  hostord = 0;
-
-        buf = orig_buf;
-
-        if (!buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "buf is null!");
-                goto out;
-        }
+dict_unserialize(char *orig_buf, int32_t size, dict_t **fill)
+{
+    char *buf = orig_buf;
+    int ret = -1;
+    int32_t count = 0;
+    int i = 0;
+
+    data_t *value = NULL;
+    char *key = NULL;
+    int32_t keylen = 0;
+    int32_t vallen = 0;
+    int32_t hostord = 0;
+
+    if (!buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "buf is null!");
+        goto out;
+    }
+
+    if (size == 0) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "size is 0!");
+        goto out;
+    }
+
+    if (!fill) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "fill is null!");
+        goto out;
+    }
+
+    if (!*fill) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "*fill is null!");
+        goto out;
+    }
+
+    if ((buf + DICT_HDR_LEN) > (orig_buf + size)) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                         "undersized buffer "
+                         "passed. available (%lu) < required (%lu)",
+                         (long)(orig_buf + size), (long)(buf + DICT_HDR_LEN));
+        goto out;
+    }
+
+    memcpy(&hostord, buf, sizeof(hostord));
+    count = ntoh32(hostord);
+    buf += DICT_HDR_LEN;
+
+    if (count < 0) {
+        gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
+                "count=%d", count, NULL);
+        goto out;
+    }
+
+    /* count will be set by the dict_set's below */
+    (*fill)->count = 0;
+
+    for (i = 0; i < count; i++) {
+        if ((buf + DICT_DATA_HDR_KEY_LEN) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized "
+                             "buffer passed. available (%lu) < "
+                             "required (%lu)",
+                             (long)(orig_buf + size),
+                             (long)(buf + DICT_DATA_HDR_KEY_LEN));
+            goto out;
+        }
+        memcpy(&hostord, buf, sizeof(hostord));
+        keylen = ntoh32(hostord);
+        buf += DICT_DATA_HDR_KEY_LEN;
+
+        if ((buf + DICT_DATA_HDR_VAL_LEN) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized "
+                             "buffer passed. available (%lu) < "
+                             "required (%lu)",
+                             (long)(orig_buf + size),
+                             (long)(buf + DICT_DATA_HDR_VAL_LEN));
+            goto out;
+        }
+        memcpy(&hostord, buf, sizeof(hostord));
+        vallen = ntoh32(hostord);
+        buf += DICT_DATA_HDR_VAL_LEN;
+
+        if ((keylen < 0) || (vallen < 0)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized length passed "
+                             "key:%d val:%d",
+                             keylen, vallen);
+            goto out;
+        }
+        if ((buf + keylen) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized buffer passed. "
+                             "available (%lu) < required (%lu)",
+                             (long)(orig_buf + size), (long)(buf + keylen));
+            goto out;
+        }
+        key = buf;
+        buf += keylen + 1; /* for '\0' */
+
+        if ((buf + vallen) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized buffer passed. "
+                             "available (%lu) < required (%lu)",
+                             (long)(orig_buf + size), (long)(buf + vallen));
+            goto out;
+        }
+        value = get_new_data();
 
-        if (size == 0) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "size is 0!");
-                goto out;
-        }
-
-        if (!fill) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "fill is null!");
-                goto out;
-        }
-
-        if (!*fill) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "*fill is null!");
-                goto out;
-        }
-
-        if ((buf + DICT_HDR_LEN) > (orig_buf + size)) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                  LG_MSG_UNDERSIZED_BUF, "undersized buffer "
-                                  "passed. available (%lu) < required (%lu)",
-                                  (long)(orig_buf + size),
-                                  (long)(buf + DICT_HDR_LEN));
-                goto out;
-        }
-
-        memcpy (&hostord, buf, sizeof(hostord));
-        count = ntoh32 (hostord);
-        buf += DICT_HDR_LEN;
-
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
-                        "count (%d) <= 0", count);
-                goto out;
+        if (!value) {
+            ret = -1;
+            goto out;
         }
+        value->len = vallen;
+        value->data = gf_memdup(buf, vallen);
+        value->data_type = GF_DATA_TYPE_STR_OLD;
+        value->is_static = _gf_false;
+        buf += vallen;
 
-        /* count will be set by the dict_set's below */
-        (*fill)->count = 0;
-
-        for (i = 0; i < count; i++) {
-                if ((buf + DICT_DATA_HDR_KEY_LEN) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF, "undersized "
-                                          "buffer passed. available (%lu) < "
-                                          "required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + DICT_DATA_HDR_KEY_LEN));
-                        goto out;
-                }
-                memcpy (&hostord, buf, sizeof(hostord));
-                keylen = ntoh32 (hostord);
-                buf += DICT_DATA_HDR_KEY_LEN;
-
-                if ((buf + DICT_DATA_HDR_VAL_LEN) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF, "undersized "
-                                          "buffer passed. available (%lu) < "
-                                          "required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + DICT_DATA_HDR_VAL_LEN));
-                        goto out;
-                }
-                memcpy (&hostord, buf, sizeof(hostord));
-                vallen = ntoh32 (hostord);
-                buf += DICT_DATA_HDR_VAL_LEN;
-
-                if ((buf + keylen) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF,
-                                          "undersized buffer passed. "
-                                          "available (%lu) < required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + keylen));
-                        goto out;
-                }
-                key = buf;
-                buf += keylen + 1;  /* for '\0' */
-
-                if ((buf + vallen) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF,
-                                          "undersized buffer passed. "
-                                          "available (%lu) < required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + vallen));
-                        goto out;
-                }
-                value = get_new_data ();
-
-                if (!value) {
-                        ret = -1;
-                        goto out;
-                }
-                value->len  = vallen;
-                value->data = memdup (buf, vallen);
-                value->is_static = 0;
-                buf += vallen;
-
-                dict_add (*fill, key, value);
-        }
+        ret = dict_addn(*fill, key, keylen, value);
+        if (ret < 0)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_allocate_and_serialize - serialize a dictionary into an allocated buffer
  *
@@ -2866,45 +3208,45 @@ out:
  */
 
 int32_t
-dict_allocate_and_serialize (dict_t *this, char **buf, u_int *length)
+dict_allocate_and_serialize(dict_t *this, char **buf, u_int *length)
 {
-        int           ret    = -EINVAL;
-        ssize_t       len = 0;
+    int ret = -EINVAL;
+    ssize_t len = 0;
 
-        if (!this || !buf) {
-                gf_msg_debug ("dict", 0, "dict OR buf is NULL");
-                goto out;
-        }
+    if (!this || !buf) {
+        gf_msg_debug("dict", 0, "dict OR buf is NULL");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                len = dict_serialized_length_lk (this);
-                if (len < 0) {
-                        ret = len;
-                        goto unlock;
-                }
+    LOCK(&this->lock);
+    {
+        len = dict_serialized_length_lk(this);
+        if (len < 0) {
+            ret = len;
+            goto unlock;
+        }
 
-                *buf = GF_CALLOC (1, len, gf_common_mt_char);
-                if (*buf == NULL) {
-                        ret = -ENOMEM;
-                        goto unlock;
-                }
+        *buf = GF_MALLOC(len, gf_common_mt_char);
+        if (*buf == NULL) {
+            ret = -ENOMEM;
+            goto unlock;
+        }
 
-                ret = dict_serialize_lk (this, *buf);
-                if (ret < 0) {
-                        GF_FREE (*buf);
-                        *buf = NULL;
-                        goto unlock;
-                }
+        ret = dict_serialize_lk(this, *buf);
+        if (ret < 0) {
+            GF_FREE(*buf);
+            *buf = NULL;
+            goto unlock;
+        }
 
-                if (length != NULL) {
-                        *length = len;
-                }
+        if (length != NULL) {
+            *length = len;
         }
+    }
 unlock:
-        UNLOCK (&this->lock);
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2917,217 +3259,231 @@ out:
  * @delimiter : the delimiter to separate the values
  *
  * @return    : 0 -> success
- *            : -errno -> faliure
+ *            : -errno -> failure
  */
 int
-dict_serialize_value_with_delim_lk (dict_t *this, char *buf, int32_t *serz_len,
-                                    char delimiter)
-{
-        int          ret       = -1;
-        int32_t      count     = 0;
-        int32_t      vallen    = 0;
-        int32_t      total_len = 0;
-        data_pair_t *pair      = NULL;
-
-        if (!buf) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                        LG_MSG_INVALID_ARG, "buf is null");
-                goto out;
-        }
+dict_serialize_value_with_delim_lk(dict_t *this, char *buf, int32_t *serz_len,
+                                   char delimiter)
+{
+    int ret = -1;
+    int32_t count = this->count;
+    int32_t vallen = 0;
+    int32_t total_len = 0;
+    data_pair_t *pair = this->members_list;
 
-        count = this->count;
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
-                        "count (%d) < 0", count);
-                goto out;
-        }
+    if (!buf) {
+        gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, NULL);
+        goto out;
+    }
 
-        pair = this->members_list;
+    if (count < 0) {
+        gf_smsg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "count=%d",
+                count, NULL);
+        goto out;
+    }
 
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_PAIRS_LESS_THAN_COUNT,
-                                "less than count data pairs found");
-                        goto out;
-                }
+    while (count) {
+        if (!pair) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_PAIRS_LESS_THAN_COUNT,
+                    NULL);
+            goto out;
+        }
 
-                if (!pair->key || !pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_KEY_OR_VALUE_NULL,
-                                "key or value is null");
-                        goto out;
-                }
+        if (!pair->key || !pair->value) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_KEY_OR_VALUE_NULL, NULL);
+            goto out;
+        }
 
-                if (!pair->value->data) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_NULL_VALUE_IN_DICT,
-                                "null value found in dict");
-                        goto out;
-                }
+        if (!pair->value->data) {
+            gf_smsg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_VALUE_IN_DICT, NULL);
+            goto out;
+        }
 
-                vallen = pair->value->len - 1; // length includes \0
-                memcpy (buf, pair->value->data, vallen);
-                buf += vallen;
-                *buf++ = delimiter;
+        vallen = pair->value->len - 1;  // length includes \0
+        memcpy(buf, pair->value->data, vallen);
+        buf += vallen;
+        *buf++ = delimiter;
 
-                total_len += (vallen + 1);
+        total_len += (vallen + 1);
 
-                pair = pair->next;
-                count--;
-        }
+        pair = pair->next;
+        count--;
+    }
 
-        *--buf = '\0'; // remove the last delimiter
-        total_len--;   // adjust the length
-        ret = 0;
+    *--buf = '\0';  // remove the last delimiter
+    total_len--;    // adjust the length
+    ret = 0;
 
-        if (serz_len)
-                *serz_len = total_len;
+    if (serz_len)
+        *serz_len = total_len;
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 int
-dict_serialize_value_with_delim (dict_t *this, char *buf, int32_t *serz_len,
-                                 char delimiter)
-{
-        int           ret    = -1;
-
-        if (!this || !buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
-
-        LOCK (&this->lock);
-        {
-                ret = dict_serialize_value_with_delim_lk (this, buf, serz_len,
-                                                          delimiter);
-        }
-        UNLOCK (&this->lock);
+dict_serialize_value_with_delim(dict_t *this, char *buf, int32_t *serz_len,
+                                char delimiter)
+{
+    int ret = -1;
+
+    if (!this || !buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
+
+    LOCK(&this->lock);
+    {
+        ret = dict_serialize_value_with_delim_lk(this, buf, serz_len,
+                                                 delimiter);
+    }
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dict_dump_to_str (dict_t *dict, char *dump, int dumpsize, char *format)
+dict_dump_to_str(dict_t *dict, char *dump, int dumpsize, char *format)
 {
-        int          ret                       = 0;
-        int          dumplen                   = 0;
-        data_pair_t *trav                      = NULL;
-
-        for (trav = dict->members_list; trav; trav = trav->next) {
-                ret = snprintf (&dump[dumplen], dumpsize - dumplen,
-                                format, trav->key, trav->value->data);
-                if ((ret == -1) || !ret)
-                        return ret;
+    int ret = 0;
+    int dumplen = 0;
+    data_pair_t *trav = NULL;
 
-                dumplen += ret;
-        }
+    if (!dict)
         return 0;
-}
 
-void
-dict_dump_to_log (dict_t *dict)
-{
-        int          ret                       = -1;
-        char         dump[64*1024]             = {0,};
-        char        *format                    = "(%s:%s)";
+    for (trav = dict->members_list; trav; trav = trav->next) {
+        ret = snprintf(&dump[dumplen], dumpsize - dumplen, format, trav->key,
+                       trav->value->data);
+        if ((ret == -1) || !ret)
+            return ret;
 
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+        dumplen += ret;
+    }
+    return 0;
+}
 
-        ret = dict_dump_to_str (dict, dump, sizeof(dump), format);
-        if (ret) {
-                gf_msg ("dict", GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary");
-                return;
-        }
-        gf_msg_callingfn ("dict", GF_LOG_INFO, 0, LG_MSG_DICT_ERROR,
-                          "dict=%p (%s)", dict, dump);
+void
+dict_dump_to_log(dict_t *dict)
+{
+    int ret = -1;
+    char *dump = NULL;
+    const int dump_size = 64 * 1024;
+    char *format = "(%s:%s)";
+
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+
+    dump = GF_MALLOC(dump_size, gf_common_mt_char);
+    if (!dump) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+                         "dump buffer is NULL");
+        goto out;
+    }
+
+    ret = dict_dump_to_str(dict, dump, dump_size, format);
+    if (ret) {
+        gf_smsg("dict", GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT, NULL);
+        goto out;
+    }
+    gf_smsg("dict", GF_LOG_INFO, 0, LG_MSG_DICT_ERROR, "dict=%p", dict,
+            "dump=%s", dump, NULL);
+out:
+    GF_FREE(dump);
 
-        return;
+    return;
 }
 
 void
-dict_dump_to_statedump (dict_t *dict, char *dict_name, char *domain)
-{
-        int          ret                       = -1;
-        char         dump[64*1024]             = {0,};
-        char         key[4096]                 = {0,};
-        char        *format                    = "\n\t%s:%s";
-
-        if (!dict) {
-                gf_msg_callingfn (domain, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+dict_dump_to_statedump(dict_t *dict, char *dict_name, char *domain)
+{
+    int ret = -1;
+    char *dump = NULL;
+    const int dump_size = 64 * 1024;
+    char key[4096] = {
+        0,
+    };
+    char *format = "\n\t%s:%s";
+
+    if (!dict) {
+        gf_msg_callingfn(domain, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+
+    dump = GF_MALLOC(dump_size, gf_common_mt_char);
+    if (!dump) {
+        gf_msg_callingfn(domain, GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+                         "dump buffer is NULL");
+        goto out;
+    }
+
+    ret = dict_dump_to_str(dict, dump, dump_size, format);
+    if (ret) {
+        gf_smsg(domain, GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT, "name=%s",
+                dict_name, NULL);
+        goto out;
+    }
+    gf_proc_dump_build_key(key, domain, "%s", dict_name);
+    gf_proc_dump_write(key, "%s", dump);
 
-        ret = dict_dump_to_str (dict, dump, sizeof(dump), format);
-        if (ret) {
-                gf_msg (domain, GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary %s", dict_name);
-                return;
-        }
-        gf_proc_dump_build_key (key, domain, "%s", dict_name);
-        gf_proc_dump_write (key, "%s", dump);
+out:
+    GF_FREE(dump);
 
-        return;
+    return;
 }
 
 dict_t *
-dict_for_key_value (const char *name, const char *value, size_t size,
-                    gf_boolean_t is_static)
+dict_for_key_value(const char *name, const char *value, size_t size,
+                   gf_boolean_t is_static)
 {
-	dict_t *xattr = NULL;
-	int     ret = 0;
+    dict_t *xattr = dict_new();
+    int ret = 0;
 
-	xattr = dict_new ();
-	if (!xattr)
-		return NULL;
+    if (!xattr)
+        return NULL;
 
-        if (is_static)
-                ret = dict_set_static_bin (xattr, (char *)name, (void *)value,
-                                           size);
-        else
-                ret = dict_set_bin (xattr, (char *)name, (void *)value, size);
+    if (is_static)
+        ret = dict_set_static_bin(xattr, (char *)name, (void *)value, size);
+    else
+        ret = dict_set_bin(xattr, (char *)name, (void *)value, size);
 
-	if (ret) {
-		dict_destroy (xattr);
-		xattr = NULL;
-	}
+    if (ret) {
+        dict_destroy(xattr);
+        xattr = NULL;
+    }
 
-	return xattr;
+    return xattr;
 }
 
 /*
  * "strings" should be NULL terminated strings array.
  */
 int
-dict_has_key_from_array (dict_t *dict, char **strings, gf_boolean_t *result)
+dict_has_key_from_array(dict_t *dict, char **strings, gf_boolean_t *result)
 {
-        int      i    = 0;
-        uint32_t hash = 0;
+    int i = 0;
+    uint32_t hash = 0;
 
-        if (!dict || !strings || !result)
-                return -EINVAL;
+    if (!dict || !strings || !result)
+        return -EINVAL;
 
-        LOCK (&dict->lock);
-        {
-                for (i = 0; strings[i]; i++) {
-                        hash = SuperFastHash (strings[i], strlen (strings[i]));
-                        if (dict_lookup_common (dict, strings[i], hash)) {
-                                *result = _gf_true;
-                                goto unlock;
-                        }
-                }
-                *result = _gf_false;
+    LOCK(&dict->lock);
+    {
+        for (i = 0; strings[i]; i++) {
+            hash = (uint32_t)XXH64(strings[i], strlen(strings[i]), 0);
+            if (dict_lookup_common(dict, strings[i], hash)) {
+                *result = _gf_true;
+                goto unlock;
+            }
         }
+        *result = _gf_false;
+    }
 unlock:
-        UNLOCK (&dict->lock);
-        return 0;
+    UNLOCK(&dict->lock);
+    return 0;
 }
diff --git a/libglusterfs/src/dict.h b/libglusterfs/src/dict.h
deleted file mode 100644
index b1313636092..00000000000
--- a/libglusterfs/src/dict.h
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _DICT_H
-#define _DICT_H
-
-#include <inttypes.h>
-#include <sys/uio.h>
-#include <pthread.h>
-
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
-
-typedef struct _data data_t;
-typedef struct _dict dict_t;
-typedef struct _data_pair data_pair_t;
-
-
-#define GF_PROTOCOL_DICT_SERIALIZE(this,from_dict,to,len,ope,labl) do { \
-                int    _ret     = 0;                                     \
-                                                                        \
-                if (!from_dict)                                         \
-                        break;                                          \
-                                                                        \
-                _ret = dict_allocate_and_serialize (from_dict, to, &len);\
-                if (_ret < 0) {                                          \
-                        gf_msg (this->name, GF_LOG_WARNING, 0,          \
-                                LG_MSG_DICT_SERIAL_FAILED,            \
-                                "failed to get serialized dict (%s)",   \
-                                (#from_dict));                          \
-                        ope = EINVAL;                                   \
-                        goto labl;                                      \
-                }                                                       \
-        } while (0)
-
-
-#define GF_PROTOCOL_DICT_UNSERIALIZE(xl,to,buff,len,ret,ope,labl) do {  \
-                if (!len)                                               \
-                        break;                                          \
-                to = dict_new();                                        \
-                GF_VALIDATE_OR_GOTO (xl->name, to, labl);               \
-                                                                        \
-                ret = dict_unserialize (buff, len, &to);                \
-                if (ret < 0) {                                          \
-                        gf_msg (xl->name, GF_LOG_WARNING, 0,            \
-                                LG_MSG_DICT_UNSERIAL_FAILED,            \
-                                "failed to unserialize dictionary (%s)", \
-                                (#to));                                 \
-                                                                        \
-                        ope = EINVAL;                                   \
-                        goto labl;                                      \
-                }                                                       \
-                                                                        \
-        } while (0)
-
-struct _data {
-        unsigned char  is_static:1;
-        unsigned char  is_const:1;
-        int32_t        len;
-        char          *data;
-        int32_t        refcount;
-        gf_lock_t      lock;
-};
-
-struct _data_pair {
-        struct _data_pair *hash_next;
-        struct _data_pair *prev;
-        struct _data_pair *next;
-        data_t            *value;
-        char              *key;
-        uint32_t           key_hash;
-};
-
-struct _dict {
-        unsigned char   is_static:1;
-        int32_t         hash_size;
-        int32_t         count;
-        int32_t         refcount;
-        data_pair_t   **members;
-        data_pair_t    *members_list;
-        char           *extra_free;
-        char           *extra_stdfree;
-        gf_lock_t       lock;
-        data_pair_t    *members_internal;
-        data_pair_t     free_pair;
-        gf_boolean_t    free_pair_in_use;
-        uint32_t        max_count;
-};
-
-typedef gf_boolean_t (*dict_match_t) (dict_t *d, char *k, data_t *v,
-                                      void *data);
-
-int32_t is_data_equal (data_t *one, data_t *two);
-void data_destroy (data_t *data);
-
-/* function to set a key/value pair (overwrite existing if matches the key */
-int32_t dict_set (dict_t *this, char *key, data_t *value);
-/* function to set a new key/value pair (without checking for duplicate) */
-int32_t dict_add (dict_t *this, char *key, data_t *value);
-
-int dict_get_with_ref (dict_t *this, char *key, data_t **data);
-data_t *dict_get (dict_t *this, char *key);
-void dict_del (dict_t *this, char *key);
-int dict_reset (dict_t *dict);
-
-int dict_key_count (dict_t *this);
-
-int32_t dict_serialized_length (dict_t *dict);
-int32_t dict_serialize (dict_t *dict, char *buf);
-int32_t dict_unserialize (char *buf, int32_t size, dict_t **fill);
-
-int32_t dict_allocate_and_serialize (dict_t *this, char **buf, u_int *length);
-
-void dict_unref (dict_t *dict);
-dict_t *dict_ref (dict_t *dict);
-data_t *data_ref (data_t *data);
-void data_unref (data_t *data);
-
-int32_t dict_lookup  (dict_t *this, char *key, data_t **data);
-/*
-   TODO: provide converts for different byte sizes, signedness, and void *
- */
-data_t *int_to_data (int64_t value);
-data_t *str_to_data (char *value);
-data_t *data_from_dynstr (char *value);
-data_t *data_from_dynptr (void *value, int32_t len);
-data_t *bin_to_data (void *value, int32_t len);
-data_t *static_str_to_data (char *value);
-data_t *static_bin_to_data (void *value);
-
-int64_t data_to_int64 (data_t *data);
-int32_t data_to_int32 (data_t *data);
-int16_t data_to_int16 (data_t *data);
-int8_t data_to_int8 (data_t *data);
-
-uint64_t data_to_uint64 (data_t *data);
-uint32_t data_to_uint32 (data_t *data);
-uint16_t data_to_uint16 (data_t *data);
-uint8_t data_to_uint8 (data_t *data);
-
-data_t *data_from_int64 (int64_t value);
-data_t *data_from_int32 (int32_t value);
-data_t *data_from_int16 (int16_t value);
-data_t *data_from_int8 (int8_t value);
-
-data_t *data_from_uint64 (uint64_t value);
-data_t *data_from_uint32 (uint32_t value);
-data_t *data_from_uint16 (uint16_t value);
-
-char *data_to_str (data_t *data);
-void *data_to_bin (data_t *data);
-void *data_to_ptr (data_t *data);
-
-data_t * data_copy (data_t *old);
-int dict_foreach (dict_t *this,
-                  int (*fn)(dict_t *this,
-                            char *key,
-                            data_t *value,
-                            void *data),
-                  void *data);
-
-int dict_foreach_fnmatch (dict_t *dict, char *pattern,
-                          int (*fn)(dict_t *this,
-                                    char *key,
-                                    data_t *value,
-                                    void *data),
-                          void *data);
-
-int
-dict_foreach_match (dict_t *dict,
-             gf_boolean_t (*match)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *mdata),
-             void *match_data,
-             int (*action)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *adata),
-              void *action_data);
-
-int dict_null_foreach_fn (dict_t *d, char *k,
-                          data_t *v, void *tmp);
-int dict_remove_foreach_fn (dict_t *d, char *k,
-                            data_t *v, void *tmp);
-dict_t *dict_copy (dict_t *this, dict_t *new);
-dict_t *get_new_dict (void);
-int dict_keys_join (void *value, int size, dict_t *dict,
-                    int (*filter_fn)(char *key));
-
-/* CLEANED UP FUNCTIONS DECLARATIONS */
-GF_MUST_CHECK dict_t *dict_new (void);
-dict_t *dict_copy_with_ref (dict_t *this, dict_t *new);
-
-GF_MUST_CHECK int dict_reset (dict_t *dict);
-
-GF_MUST_CHECK int dict_get_int8 (dict_t *this, char *key, int8_t *val);
-GF_MUST_CHECK int dict_set_int8 (dict_t *this, char *key, int8_t val);
-
-GF_MUST_CHECK int dict_get_int16 (dict_t *this, char *key, int16_t *val);
-GF_MUST_CHECK int dict_set_int16 (dict_t *this, char *key, int16_t val);
-
-GF_MUST_CHECK int dict_get_int32 (dict_t *this, char *key, int32_t *val);
-GF_MUST_CHECK int dict_set_int32 (dict_t *this, char *key, int32_t val);
-
-GF_MUST_CHECK int dict_get_int64 (dict_t *this, char *key, int64_t *val);
-GF_MUST_CHECK int dict_set_int64 (dict_t *this, char *key, int64_t val);
-
-GF_MUST_CHECK int dict_get_uint16 (dict_t *this, char *key, uint16_t *val);
-GF_MUST_CHECK int dict_set_uint16 (dict_t *this, char *key, uint16_t val);
-
-GF_MUST_CHECK int dict_get_uint32 (dict_t *this, char *key, uint32_t *val);
-GF_MUST_CHECK int dict_set_uint32 (dict_t *this, char *key, uint32_t val);
-
-GF_MUST_CHECK int dict_get_uint64 (dict_t *this, char *key, uint64_t *val);
-GF_MUST_CHECK int dict_set_uint64 (dict_t *this, char *key, uint64_t val);
-
-GF_MUST_CHECK int dict_get_double (dict_t *this, char *key, double *val);
-GF_MUST_CHECK int dict_set_double (dict_t *this, char *key, double val);
-
-GF_MUST_CHECK int dict_set_static_ptr (dict_t *this, char *key, void *ptr);
-GF_MUST_CHECK int dict_get_ptr (dict_t *this, char *key, void **ptr);
-GF_MUST_CHECK int dict_get_ptr_and_len (dict_t *this, char *key, void **ptr, int *len);
-GF_MUST_CHECK int dict_set_ptr (dict_t *this, char *key, void *ptr);
-GF_MUST_CHECK int dict_set_dynptr (dict_t *this, char *key, void *ptr, size_t size);
-
-GF_MUST_CHECK int dict_get_bin (dict_t *this, char *key, void **ptr);
-GF_MUST_CHECK int dict_set_bin (dict_t *this, char *key, void *ptr, size_t size);
-GF_MUST_CHECK int dict_set_static_bin (dict_t *this, char *key, void *ptr, size_t size);
-
-GF_MUST_CHECK int dict_set_str (dict_t *this, char *key, char *str);
-GF_MUST_CHECK int dict_set_dynstr (dict_t *this, char *key, char *str);
-GF_MUST_CHECK int dict_set_dynstr_with_alloc (dict_t *this, char *key, const char *str);
-GF_MUST_CHECK int dict_add_dynstr_with_alloc (dict_t *this, char *key, char *str);
-GF_MUST_CHECK int dict_get_str (dict_t *this, char *key, char **str);
-
-GF_MUST_CHECK int dict_get_str_boolean (dict_t *this, char *key, int default_val);
-GF_MUST_CHECK int dict_rename_key (dict_t *this, char *key, char *replace_key);
-GF_MUST_CHECK int dict_serialize_value_with_delim (dict_t *this, char *buf, int32_t *serz_len,
-                                                    char delimiter);
-void
-dict_dump_to_statedump (dict_t *dict, char *dict_name, char *domain);
-
-void
-dict_dump_to_log (dict_t *dict);
-
-int
-dict_dump_to_str (dict_t *dict, char *dump, int dumpsize, char *format);
-gf_boolean_t
-dict_match_everything (dict_t *d, char *k, data_t *v, void *data);
-
-dict_t *
-dict_for_key_value (const char *name, const char *value, size_t size,
-                    gf_boolean_t is_static);
-
-gf_boolean_t
-are_dicts_equal (dict_t *one, dict_t *two,
-                 gf_boolean_t (*match) (dict_t *d, char *k, data_t *v,
-                                        void *data),
-                 gf_boolean_t (*value_ignore) (char *k));
-int
-dict_has_key_from_array (dict_t *dict, char **strings, gf_boolean_t *result);
-#endif
diff --git a/libglusterfs/src/event-epoll.c b/libglusterfs/src/event-epoll.c
index 7fc53ffeaf6..fb4fb845b40 100644
--- a/libglusterfs/src/event-epoll.c
+++ b/libglusterfs/src/event-epoll.c
@@ -8,750 +8,839 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <sys/poll.h>
 #include <pthread.h>
-#include <unistd.h>
-#include <fcntl.h>
 #include <stdlib.h>
 #include <errno.h>
-#include <string.h>
-
-#include "logging.h"
-#include "event.h"
-#include "mem-pool.h"
-#include "common-utils.h"
-#include "syscall.h"
-#include "libglusterfs-messages.h"
 
+#include "glusterfs/gf-event.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 #ifdef HAVE_SYS_EPOLL_H
 #include <sys/epoll.h>
 
-
 struct event_slot_epoll {
-	int fd;
-	int events;
-	int gen;
-	int ref;
-	int do_close;
-	int in_handler;
-        int handled_error;
-	void *data;
-	event_handler_t handler;
-	gf_lock_t lock;
+    int fd;
+    int events;
+    int gen;
+    int idx;
+    gf_atomic_t ref;
+    int do_close;
+    int in_handler;
+    int handled_error;
+    void *data;
+    event_handler_t handler;
+    gf_lock_t lock;
+    struct list_head poller_death;
 };
 
 struct event_thread_data {
-        struct event_pool *event_pool;
-        int    event_index;
+    struct event_pool *event_pool;
+    int event_index;
 };
 
 static struct event_slot_epoll *
-__event_newtable (struct event_pool *event_pool, int table_idx)
+__event_newtable(struct event_pool *event_pool, int table_idx)
 {
-	struct event_slot_epoll *table = NULL;
-	int                      i = -1;
+    struct event_slot_epoll *table = NULL;
+    int i = -1;
 
-	table = GF_CALLOC (sizeof (*table), EVENT_EPOLL_SLOTS,
-			   gf_common_mt_ereg);
-	if (!table)
-		return NULL;
+    table = GF_CALLOC(sizeof(*table), EVENT_EPOLL_SLOTS, gf_common_mt_ereg);
+    if (!table)
+        return NULL;
 
-	for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
-		table[i].fd = -1;
-		LOCK_INIT (&table[i].lock);
-	}
+    for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
+        table[i].fd = -1;
+        LOCK_INIT(&table[i].lock);
+        INIT_LIST_HEAD(&table[i].poller_death);
+    }
 
-	event_pool->ereg[table_idx] = table;
-	event_pool->slots_used[table_idx] = 0;
+    event_pool->ereg[table_idx] = table;
+    event_pool->slots_used[table_idx] = 0;
 
-	return table;
+    return table;
 }
 
-
 static int
-__event_slot_alloc (struct event_pool *event_pool, int fd)
+event_slot_ref(struct event_slot_epoll *slot)
 {
-        int  i = 0;
-	int  table_idx = -1;
-	int  gen = -1;
-	struct event_slot_epoll *table = NULL;
-
-	for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
-		switch (event_pool->slots_used[i]) {
-		case EVENT_EPOLL_SLOTS:
-			continue;
-		case 0:
-			if (!event_pool->ereg[i]) {
-				table = __event_newtable (event_pool, i);
-				if (!table)
-					return -1;
-			} else {
-                                table = event_pool->ereg[i];
-                        }
-			break;
-		default:
-			table = event_pool->ereg[i];
-			break;
-		}
-
-		if (table)
-			/* break out of the loop */
-			break;
-	}
-
-	if (!table)
-		return -1;
-
-	table_idx = i;
-
-	for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
-		if (table[i].fd == -1) {
-			/* wipe everything except bump the generation */
-			gen = table[i].gen;
-			memset (&table[i], 0, sizeof (table[i]));
-			table[i].gen = gen + 1;
-
-			LOCK_INIT (&table[i].lock);
-
-			table[i].fd = fd;
-			event_pool->slots_used[table_idx]++;
-
-			break;
-		}
-	}
-
-	return table_idx * EVENT_EPOLL_SLOTS + i;
-}
+    if (!slot)
+        return -1;
 
+    return GF_ATOMIC_INC(slot->ref);
+}
 
 static int
-event_slot_alloc (struct event_pool *event_pool, int fd)
+__event_slot_alloc(struct event_pool *event_pool, int fd,
+                   char notify_poller_death, struct event_slot_epoll **slot)
 {
-	int  idx = -1;
+    int i = 0;
+    int j = 0;
+    int table_idx = -1;
+    int gen = -1;
+    struct event_slot_epoll *table = NULL;
+
+retry:
+
+    while (i < EVENT_EPOLL_TABLES) {
+        switch (event_pool->slots_used[i]) {
+            case EVENT_EPOLL_SLOTS:
+                break;
+            case 0:
+                if (!event_pool->ereg[i]) {
+                    table = __event_newtable(event_pool, i);
+                    if (!table)
+                        return -1;
+                } else {
+                    table = event_pool->ereg[i];
+                }
+                break;
+            default:
+                table = event_pool->ereg[i];
+                break;
+        }
 
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_slot_alloc (event_pool, fd);
-	}
-	pthread_mutex_unlock (&event_pool->mutex);
+        if (table)
+            /* break out of the loop */
+            break;
+        i++;
+    }
 
-	return idx;
-}
+    if (!table)
+        return -1;
 
+    table_idx = i;
 
+    for (j = 0; j < EVENT_EPOLL_SLOTS; j++) {
+        if (table[j].fd == -1) {
+            /* wipe everything except bump the generation */
+            gen = table[j].gen;
+            memset(&table[j], 0, sizeof(table[j]));
+            table[j].gen = gen + 1;
 
-static void
-__event_slot_dealloc (struct event_pool *event_pool, int idx)
-{
-	int                      table_idx = 0;
-	int                      offset = 0;
-	struct event_slot_epoll *table = NULL;
-	struct event_slot_epoll *slot = NULL;
+            LOCK_INIT(&table[j].lock);
+            INIT_LIST_HEAD(&table[j].poller_death);
 
-	table_idx = idx / EVENT_EPOLL_SLOTS;
-	offset = idx % EVENT_EPOLL_SLOTS;
+            table[j].fd = fd;
+            if (notify_poller_death) {
+                table[j].idx = table_idx * EVENT_EPOLL_SLOTS + j;
+                list_add_tail(&table[j].poller_death,
+                              &event_pool->poller_death);
+            }
 
-	table = event_pool->ereg[table_idx];
-	if (!table)
-		return;
+            event_pool->slots_used[table_idx]++;
 
-	slot = &table[offset];
-	slot->gen++;
+            break;
+        }
+    }
+
+    if (j == EVENT_EPOLL_SLOTS) {
+        table = NULL;
+        i++;
+        goto retry;
+    } else {
+        (*slot) = &table[j];
+        event_slot_ref(*slot);
+        return table_idx * EVENT_EPOLL_SLOTS + j;
+    }
+}
+
+static int
+event_slot_alloc(struct event_pool *event_pool, int fd,
+                 char notify_poller_death, struct event_slot_epoll **slot)
+{
+    int idx = -1;
 
-	slot->fd = -1;
-        slot->handled_error = 0;
-        slot->in_handler = 0;
-	event_pool->slots_used[table_idx]--;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_slot_alloc(event_pool, fd, notify_poller_death, slot);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-	return;
+    return idx;
 }
 
+static void
+__event_slot_dealloc(struct event_pool *event_pool, int idx)
+{
+    int table_idx = 0;
+    int offset = 0;
+    struct event_slot_epoll *table = NULL;
+    struct event_slot_epoll *slot = NULL;
+    int fd = -1;
+
+    table_idx = idx / EVENT_EPOLL_SLOTS;
+    offset = idx % EVENT_EPOLL_SLOTS;
+
+    table = event_pool->ereg[table_idx];
+    if (!table)
+        return;
+
+    slot = &table[offset];
+    slot->gen++;
+
+    fd = slot->fd;
+    slot->fd = -1;
+    slot->handled_error = 0;
+    slot->in_handler = 0;
+    list_del_init(&slot->poller_death);
+    if (fd != -1)
+        event_pool->slots_used[table_idx]--;
+
+    return;
+}
 
 static void
-event_slot_dealloc (struct event_pool *event_pool, int idx)
+event_slot_dealloc(struct event_pool *event_pool, int idx)
 {
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		__event_slot_dealloc (event_pool, idx);
-	}
-	pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        __event_slot_dealloc(event_pool, idx);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-	return;
+    return;
 }
 
-
 static struct event_slot_epoll *
-event_slot_get (struct event_pool *event_pool, int idx)
+event_slot_get(struct event_pool *event_pool, int idx)
 {
-	struct event_slot_epoll *slot = NULL;
-	struct event_slot_epoll *table = NULL;
-	int                      table_idx = 0;
-	int                      offset = 0;
+    struct event_slot_epoll *slot = NULL;
+    struct event_slot_epoll *table = NULL;
+    int table_idx = 0;
+    int offset = 0;
 
-	table_idx = idx / EVENT_EPOLL_SLOTS;
-	offset = idx % EVENT_EPOLL_SLOTS;
+    table_idx = idx / EVENT_EPOLL_SLOTS;
+    offset = idx % EVENT_EPOLL_SLOTS;
 
-	table = event_pool->ereg[table_idx];
-	if (!table)
-		return NULL;
-
-	slot = &table[offset];
+    table = event_pool->ereg[table_idx];
+    if (!table)
+        return NULL;
 
-	LOCK (&slot->lock);
-	{
-		slot->ref++;
-	}
-	UNLOCK (&slot->lock);
+    slot = &table[offset];
 
-	return slot;
+    event_slot_ref(slot);
+    return slot;
 }
 
-
 static void
-event_slot_unref (struct event_pool *event_pool, struct event_slot_epoll *slot,
-		  int idx)
+__event_slot_unref(struct event_pool *event_pool, struct event_slot_epoll *slot,
+                   int idx)
 {
-	int ref = -1;
-	int fd = -1;
-	int do_close = 0;
-
-	LOCK (&slot->lock);
-	{
-		ref = --slot->ref;
-		fd = slot->fd;
-		do_close = slot->do_close;
-	}
-	UNLOCK (&slot->lock);
-
-	if (ref)
-		/* slot still alive */
-		goto done;
-
-	event_slot_dealloc (event_pool, idx);
-
-	if (do_close)
-		sys_close (fd);
+    int ref = -1;
+    int fd = -1;
+    int do_close = 0;
+
+    ref = GF_ATOMIC_DEC(slot->ref);
+    if (ref)
+        /* slot still alive */
+        goto done;
+
+    LOCK(&slot->lock);
+    {
+        fd = slot->fd;
+        do_close = slot->do_close;
+        slot->do_close = 0;
+    }
+    UNLOCK(&slot->lock);
+
+    __event_slot_dealloc(event_pool, idx);
+
+    if (do_close)
+        sys_close(fd);
 done:
-	return;
+    return;
 }
 
+static void
+event_slot_unref(struct event_pool *event_pool, struct event_slot_epoll *slot,
+                 int idx)
+{
+    int ref = -1;
+    int fd = -1;
+    int do_close = 0;
+
+    ref = GF_ATOMIC_DEC(slot->ref);
+    if (ref)
+        /* slot still alive */
+        goto done;
+
+    LOCK(&slot->lock);
+    {
+        fd = slot->fd;
+        do_close = slot->do_close;
+        slot->do_close = 0;
+    }
+    UNLOCK(&slot->lock);
+
+    event_slot_dealloc(event_pool, idx);
+
+    if (do_close)
+        sys_close(fd);
+done:
+    return;
+}
 
 static struct event_pool *
-event_pool_new_epoll (int count, int eventthreadcount)
+event_pool_new_epoll(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-        int                epfd = -1;
-
-        event_pool = GF_CALLOC (1, sizeof (*event_pool),
-                                gf_common_mt_event_pool);
+    struct event_pool *event_pool = NULL;
+    int epfd = -1;
 
-        if (!event_pool)
-                goto out;
+    event_pool = GF_CALLOC(1, sizeof(*event_pool), gf_common_mt_event_pool);
 
-        epfd = epoll_create (count);
+    if (!event_pool)
+        goto out;
 
-        if (epfd == -1) {
-                gf_msg ("epoll", GF_LOG_ERROR, errno,
-                        LG_MSG_EPOLL_FD_CREATE_FAILED, "epoll fd creation "
-                        "failed");
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                event_pool = NULL;
-                goto out;
-        }
+    epfd = epoll_create(count);
 
-        event_pool->fd = epfd;
+    if (epfd == -1) {
+        gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_CREATE_FAILED,
+                NULL);
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        event_pool = NULL;
+        goto out;
+    }
 
-        event_pool->count = count;
+    event_pool->fd = epfd;
 
-        event_pool->eventthreadcount = eventthreadcount;
-        event_pool->auto_thread_count = 0;
+    event_pool->count = count;
+    INIT_LIST_HEAD(&event_pool->poller_death);
+    event_pool->eventthreadcount = eventthreadcount;
+    event_pool->auto_thread_count = 0;
 
-        pthread_mutex_init (&event_pool->mutex, NULL);
+    pthread_mutex_init(&event_pool->mutex, NULL);
 
 out:
-        return event_pool;
+    return event_pool;
 }
 
-
 static void
-__slot_update_events (struct event_slot_epoll *slot, int poll_in, int poll_out)
+__slot_update_events(struct event_slot_epoll *slot, int poll_in, int poll_out)
 {
-	switch (poll_in) {
-	case 1:
-		slot->events |= EPOLLIN;
-		break;
-	case 0:
-		slot->events &= ~EPOLLIN;
-		break;
-	case -1:
-		/* do nothing */
-		break;
-	default:
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
-			"invalid poll_in value %d", poll_in);
-		break;
-	}
-
-	switch (poll_out) {
-	case 1:
-		slot->events |= EPOLLOUT;
-		break;
-	case 0:
-		slot->events &= ~EPOLLOUT;
-		break;
-	case -1:
-		/* do nothing */
-		break;
-	default:
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
-			"invalid poll_out value %d", poll_out);
-		break;
-	}
+    switch (poll_in) {
+        case 1:
+            slot->events |= EPOLLIN;
+            break;
+        case 0:
+            slot->events &= ~EPOLLIN;
+            break;
+        case -1:
+            /* do nothing */
+            break;
+        default:
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                    "value=%d", poll_in, NULL);
+            break;
+    }
+
+    switch (poll_out) {
+        case 1:
+            slot->events |= EPOLLOUT;
+            break;
+        case 0:
+            slot->events &= ~EPOLLOUT;
+            break;
+        case -1:
+            /* do nothing */
+            break;
+        default:
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                    "value=%d", poll_out, NULL);
+            break;
+    }
 }
 
-
 int
-event_register_epoll (struct event_pool *event_pool, int fd,
-                      event_handler_t handler,
-                      void *data, int poll_in, int poll_out)
+event_register_epoll(struct event_pool *event_pool, int fd,
+                     event_handler_t handler, void *data, int poll_in,
+                     int poll_out, char notify_poller_death)
 {
-        int                 idx = -1;
-        int                 ret = -1;
-        int             destroy = 0;
-        struct epoll_event  epoll_event = {0, };
-        struct event_data  *ev_data = (void *)&epoll_event.data;
-	struct event_slot_epoll *slot = NULL;
-
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        /* TODO: Even with the below check, there is a possiblity of race,
-         * What if the destroy mode is set after the check is done.
-         * Not sure of the best way to prevent this race, ref counting
-         * is one possibility.
-         * There is no harm in registering and unregistering the fd
-         * even after destroy mode is set, just that such fds will remain
-         * open until unregister is called, also the events on that fd will be
-         * notified, until one of the poller thread is alive.
-         */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                destroy = event_pool->destroy;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        if (destroy == 1)
-               goto out;
-
-	idx = event_slot_alloc (event_pool, fd);
-	if (idx == -1) {
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-			"could not find slot for fd=%d", fd);
-		return -1;
-	}
-
-	slot = event_slot_get (event_pool, idx);
-
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		/* make epoll 'singleshot', which
-		   means we need to re-add the fd with
-		   epoll_ctl(EPOLL_CTL_MOD) after delivery of every
-		   single event. This assures us that while a poller
-		   thread has picked up and is processing an event,
-		   another poller will not try to pick this at the same
-		   time as well.
-		*/
-
-		slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT;
-		slot->handler = handler;
-		slot->data = data;
-
-		__slot_update_events (slot, poll_in, poll_out);
-
-		epoll_event.events = slot->events;
-		ev_data->idx = idx;
-		ev_data->gen = slot->gen;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd,
-				 &epoll_event);
-		/* check ret after UNLOCK() to avoid deadlock in
-		   event_slot_unref()
-		*/
-	}
-	UNLOCK (&slot->lock);
-
-	if (ret == -1) {
-		gf_msg ("epoll", GF_LOG_ERROR, errno,
-                        LG_MSG_EPOLL_FD_ADD_FAILED, "failed to add fd(=%d) to "
-                        "epoll fd(=%d)", fd, event_pool->fd);
-		event_slot_unref (event_pool, slot, idx);
-		idx = -1;
-	}
-
-	/* keep slot->ref (do not event_slot_unref) if successful */
+    int idx = -1;
+    int ret = -1;
+    int destroy = 0;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+    struct event_slot_epoll *slot = NULL;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    /* TODO: Even with the below check, there is a possibility of race,
+     * What if the destroy mode is set after the check is done.
+     * Not sure of the best way to prevent this race, ref counting
+     * is one possibility.
+     * There is no harm in registering and unregistering the fd
+     * even after destroy mode is set, just that such fds will remain
+     * open until unregister is called, also the events on that fd will be
+     * notified, until one of the poller thread is alive.
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        destroy = event_pool->destroy;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    if (destroy == 1)
+        goto out;
+
+    idx = event_slot_alloc(event_pool, fd, notify_poller_death, &slot);
+    if (idx == -1) {
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                NULL);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        /* make epoll 'singleshot', which
+           means we need to re-add the fd with
+           epoll_ctl(EPOLL_CTL_MOD) after delivery of every
+           single event. This assures us that while a poller
+           thread has picked up and is processing an event,
+           another poller will not try to pick this at the same
+           time as well.
+        */
+
+        slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT;
+        slot->handler = handler;
+        slot->data = data;
+
+        __slot_update_events(slot, poll_in, poll_out);
+
+        epoll_event.events = slot->events;
+        ev_data->idx = idx;
+        ev_data->gen = slot->gen;
+
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_ADD, fd, &epoll_event);
+        /* check ret after UNLOCK() to avoid deadlock in
+           event_slot_unref()
+        */
+    }
+    UNLOCK(&slot->lock);
+
+    if (ret == -1) {
+        gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_ADD_FAILED,
+                "fd=%d", fd, "epoll_fd=%d", event_pool->fd, NULL);
+        event_slot_unref(event_pool, slot, idx);
+        idx = -1;
+    }
+
+    /* keep slot->ref (do not event_slot_unref) if successful */
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_epoll_common (struct event_pool *event_pool, int fd,
-			       int idx, int do_close)
+event_unregister_epoll_common(struct event_pool *event_pool, int fd, int idx,
+                              int do_close)
 {
-        int  ret = -1;
-	struct event_slot_epoll *slot = NULL;
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-	slot = event_slot_get (event_pool, idx);
-
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
-
-                if (ret == -1) {
-                        gf_msg ("epoll", GF_LOG_ERROR, errno,
-                                LG_MSG_EPOLL_FD_DEL_FAILED, "fail to del "
-                                "fd(=%d) from epoll fd(=%d)", fd,
-                                event_pool->fd);
-                        goto unlock;
-                }
-
-		slot->do_close = do_close;
-		slot->gen++; /* detect unregister in dispatch_handler() */
+    int ret = -1;
+    struct event_slot_epoll *slot = NULL;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    /* During shutdown, it may happen that a socket registration with
+     * the event sub-system may fail and an rpc_transport_unref() may
+     * be called for such an unregistered socket with idx == -1. This
+     * may cause the following assert(slot->fd == fd) to fail.
+     */
+    if (idx < 0)
+        goto out;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
+
+        if (ret == -1) {
+            gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_DEL_FAILED,
+                    "fd=%d", fd, "epoll_fd=%d", event_pool->fd, NULL);
+            goto unlock;
         }
+
+        slot->do_close = do_close;
+        slot->gen++; /* detect unregister in dispatch_handler() */
+    }
 unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-	event_slot_unref (event_pool, slot, idx); /* one for event_register() */
-	event_slot_unref (event_pool, slot, idx); /* one for event_slot_get() */
+    event_slot_unref(event_pool, slot, idx); /* one for event_register() */
+    event_slot_unref(event_pool, slot, idx); /* one for event_slot_get() */
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-event_unregister_epoll (struct event_pool *event_pool, int fd, int idx_hint)
+event_unregister_epoll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 0);
+    ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 0);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-event_unregister_close_epoll (struct event_pool *event_pool, int fd,
-			      int idx_hint)
+event_unregister_close_epoll(struct event_pool *event_pool, int fd,
+                             int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 1);
+    ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 1);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-event_select_on_epoll (struct event_pool *event_pool, int fd, int idx,
-                       int poll_in, int poll_out)
+event_select_on_epoll(struct event_pool *event_pool, int fd, int idx,
+                      int poll_in, int poll_out)
 {
-        int ret = -1;
-	struct event_slot_epoll *slot = NULL;
-        struct epoll_event epoll_event = {0, };
-        struct event_data *ev_data = (void *)&epoll_event.data;
-
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-	slot = event_slot_get (event_pool, idx);
-
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		__slot_update_events (slot, poll_in, poll_out);
-
-		epoll_event.events = slot->events;
-		ev_data->idx = idx;
-		ev_data->gen = slot->gen;
-
-		if (slot->in_handler)
-			/*
-			 * in_handler indicates at least one thread
-			 * executing event_dispatch_epoll_handler()
-			 * which will perform epoll_ctl(EPOLL_CTL_MOD)
-			 * anyways (because of EPOLLET)
-			 *
-			 * This not only saves a system call, but also
-			 * avoids possibility of another epoll thread
-			 * picking up the next event while the ongoing
-			 * handler is still in progress (and resulting
-			 * in unnecessary contention on rpc_transport_t->mutex).
-			 */
-			goto unlock;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, fd,
-				 &epoll_event);
-		if (ret == -1) {
-			gf_msg ("epoll", GF_LOG_ERROR, errno,
-                                LG_MSG_EPOLL_FD_MODIFY_FAILED, "failed to "
-                                "modify fd(=%d) events to %d", fd,
-                                epoll_event.events);
-		}
-	}
+    int ret = -1;
+    struct event_slot_epoll *slot = NULL;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        __slot_update_events(slot, poll_in, poll_out);
+
+        epoll_event.events = slot->events;
+        ev_data->idx = idx;
+        ev_data->gen = slot->gen;
+
+        if (slot->in_handler)
+            /*
+             * in_handler indicates at least one thread
+             * executing event_dispatch_epoll_handler()
+             * which will perform epoll_ctl(EPOLL_CTL_MOD)
+             * anyways (because of EPOLLET)
+             *
+             * This not only saves a system call, but also
+             * avoids possibility of another epoll thread
+             * picking up the next event while the ongoing
+             * handler is still in progress (and resulting
+             * in unnecessary contention on rpc_transport_t->mutex).
+             */
+            goto unlock;
+
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event);
+        if (ret == -1) {
+            gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_MODIFY_FAILED,
+                    "fd=%d", fd, "events=%d", epoll_event.events, NULL);
+        }
+    }
 unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-	event_slot_unref (event_pool, slot, idx);
+    event_slot_unref(event_pool, slot, idx);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_dispatch_epoll_handler (struct event_pool *event_pool,
-                              struct epoll_event *event)
+event_dispatch_epoll_handler(struct event_pool *event_pool,
+                             struct epoll_event *event)
 {
-        struct event_data  *ev_data = NULL;
-	struct event_slot_epoll *slot = NULL;
-        event_handler_t     handler = NULL;
-        void               *data = NULL;
-        int                 idx = -1;
-	int                 gen = -1;
-        int                 ret = -1;
-	int                 fd = -1;
-        gf_boolean_t        handled_error_previously = _gf_false;
-
-	ev_data = (void *)&event->data;
-        handler = NULL;
-        data = NULL;
-
-	idx = ev_data->idx;
-	gen = ev_data->gen;
-
-	slot = event_slot_get (event_pool, idx);
-
-	LOCK (&slot->lock);
-	{
-		fd = slot->fd;
-		if (fd == -1) {
-			gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_STALE_FD_FOUND, "stale fd found on "
-                                "idx=%d, gen=%d, events=%d, slot->gen=%d",
-				idx, gen, event->events, slot->gen);
-			/* fd got unregistered in another thread */
-			goto pre_unlock;
-		}
-
-		if (gen != slot->gen) {
-			gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_GENERATION_MISMATCH, "generation "
-                                "mismatch on idx=%d, gen=%d, slot->gen=%d, "
-                                "slot->fd=%d", idx, gen, slot->gen, slot->fd);
-			/* slot was re-used and therefore is another fd! */
-			goto pre_unlock;
-		}
-
-		handler = slot->handler;
-		data = slot->data;
-
-                if (slot->handled_error) {
-                        handled_error_previously = _gf_true;
-                } else {
-                        slot->handled_error = (event->events
-                                               & (EPOLLERR|EPOLLHUP));
-                        slot->in_handler++;
-                }
-	}
-pre_unlock:
-	UNLOCK (&slot->lock);
+    struct event_data *ev_data = NULL;
+    struct event_slot_epoll *slot = NULL;
+    event_handler_t handler = NULL;
+    void *data = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+    gf_boolean_t handled_error_previously = _gf_false;
+
+    ev_data = (void *)&event->data;
+    handler = NULL;
+    data = NULL;
+
+    idx = ev_data->idx;
+    gen = ev_data->gen;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "idx=%d", idx,
+                NULL);
+        return -1;
+    }
+
+    LOCK(&slot->lock);
+    {
+        fd = slot->fd;
+        if (fd == -1) {
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_STALE_FD_FOUND, "idx=%d",
+                    idx, "gen=%d", gen, "events=%d", event->events,
+                    "slot->gen=%d", slot->gen, NULL);
+            /* fd got unregistered in another thread */
+            goto pre_unlock;
+        }
+
+        if (gen != slot->gen) {
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_GENERATION_MISMATCH,
+                    "idx=%d", idx, "gen=%d", gen, "slot->gen=%d", slot->gen,
+                    "slot->fd=%d", slot->fd, NULL);
+            /* slot was re-used and therefore is another fd! */
+            goto pre_unlock;
+        }
+
+        handler = slot->handler;
+        data = slot->data;
 
-        if (!handler)
-		goto out;
+        if (slot->in_handler > 0) {
+            /* Another handler is inprogress, skip this one. */
+            handler = NULL;
+            goto pre_unlock;
+        }
 
-        if (!handled_error_previously) {
-                ret = handler (fd, idx, gen, data,
-                               (event->events & (EPOLLIN|EPOLLPRI)),
-                               (event->events & (EPOLLOUT)),
-                               (event->events & (EPOLLERR|EPOLLHUP)));
+        if (slot->handled_error) {
+            handled_error_previously = _gf_true;
+        } else {
+            slot->handled_error = (event->events & (EPOLLERR | EPOLLHUP));
+            slot->in_handler++;
         }
+    }
+pre_unlock:
+    UNLOCK(&slot->lock);
+
+    ret = 0;
+
+    if (!handler)
+        goto out;
+
+    if (!handled_error_previously) {
+        handler(fd, idx, gen, data, (event->events & (EPOLLIN | EPOLLPRI)),
+                (event->events & (EPOLLOUT)),
+                (event->events & (EPOLLERR | EPOLLHUP)), 0);
+    }
 out:
-	event_slot_unref (event_pool, slot, idx);
+    event_slot_unref(event_pool, slot, idx);
 
-        return ret;
+    return ret;
 }
 
-
 static void *
-event_dispatch_epoll_worker (void *data)
+event_dispatch_epoll_worker(void *data)
 {
-        struct epoll_event  event;
-        int                 ret = -1;
-        struct event_thread_data *ev_data = data;
-	struct event_pool  *event_pool;
-        int                 myindex = -1;
-        int                 timetodie = 0;
-
-        GF_VALIDATE_OR_GOTO ("event", ev_data, out);
-
-        event_pool = ev_data->event_pool;
-        myindex = ev_data->event_index;
+    struct epoll_event event;
+    int ret = -1;
+    struct event_thread_data *ev_data = data;
+    struct event_pool *event_pool;
+    int myindex = -1;
+    int timetodie = 0, gen = 0;
+    struct list_head poller_death_notify;
+    struct event_slot_epoll *slot = NULL, *tmp = NULL;
+
+    GF_VALIDATE_OR_GOTO("event", ev_data, out);
+
+    event_pool = ev_data->event_pool;
+    myindex = ev_data->event_index;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    gf_smsg("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, "index=%d",
+            myindex - 1, NULL);
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount++;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    for (;;) {
+        if (event_pool->eventthreadcount < myindex) {
+            /* ...time to die, thread count was decreased below
+             * this threads index */
+            /* Start with extra safety at this point, reducing
+             * lock conention in normal case when threads are not
+             * reconfigured always */
+            pthread_mutex_lock(&event_pool->mutex);
+            {
+                if (event_pool->eventthreadcount < myindex) {
+                    while (event_pool->poller_death_sliced) {
+                        pthread_cond_wait(&event_pool->cond,
+                                          &event_pool->mutex);
+                    }
+
+                    INIT_LIST_HEAD(&poller_death_notify);
+                    /* if found true in critical section,
+                     * die */
+                    event_pool->pollers[myindex - 1] = 0;
+                    event_pool->activethreadcount--;
+                    timetodie = 1;
+                    gen = ++event_pool->poller_gen;
+                    list_for_each_entry(slot, &event_pool->poller_death,
+                                        poller_death)
+                    {
+                        event_slot_ref(slot);
+                    }
+
+                    list_splice_init(&event_pool->poller_death,
+                                     &poller_death_notify);
+                    event_pool->poller_death_sliced = 1;
+                    pthread_cond_broadcast(&event_pool->cond);
+                }
+            }
+            pthread_mutex_unlock(&event_pool->mutex);
+            if (timetodie) {
+                list_for_each_entry(slot, &poller_death_notify, poller_death)
+                {
+                    slot->handler(slot->fd, 0, gen, slot->data, 0, 0, 0, 1);
+                }
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+                pthread_mutex_lock(&event_pool->mutex);
+                {
+                    list_for_each_entry_safe(slot, tmp, &poller_death_notify,
+                                             poller_death)
+                    {
+                        __event_slot_unref(event_pool, slot, slot->idx);
+                    }
+
+                    list_splice(&poller_death_notify,
+                                &event_pool->poller_death);
+                    event_pool->poller_death_sliced = 0;
+                    pthread_cond_broadcast(&event_pool->cond);
+                }
+                pthread_mutex_unlock(&event_pool->mutex);
 
-        gf_msg ("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, "Started"
-                " thread with index %d", myindex);
+                gf_smsg("epoll", GF_LOG_INFO, 0, LG_MSG_EXITED_EPOLL_THREAD,
+                        "index=%d", myindex, NULL);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                event_pool->activethreadcount++;
+                goto out;
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-	for (;;) {
-                if (event_pool->eventthreadcount < myindex) {
-                        /* ...time to die, thread count was decreased below
-                         * this threads index */
-                        /* Start with extra safety at this point, reducing
-                         * lock conention in normal case when threads are not
-                         * reconfigured always */
-                        pthread_mutex_lock (&event_pool->mutex);
-                        {
-                                if (event_pool->eventthreadcount <
-                                    myindex) {
-                                        /* if found true in critical section,
-                                         * die */
-                                        event_pool->pollers[myindex - 1] = 0;
-                                        event_pool->activethreadcount--;
-                                        timetodie = 1;
-                                        pthread_cond_broadcast (&event_pool->cond);
-                                }
-                        }
-                        pthread_mutex_unlock (&event_pool->mutex);
-                        if (timetodie) {
-                                gf_msg ("epoll", GF_LOG_INFO, 0,
-                                        LG_MSG_EXITED_EPOLL_THREAD, "Exited "
-                                        "thread with index %d", myindex);
-                                goto out;
-                        }
-                }
 
-                ret = epoll_wait (event_pool->fd, &event, 1, -1);
+        ret = epoll_wait(event_pool->fd, &event, 1, -1);
 
-                if (ret == 0)
-                        /* timeout */
-                        continue;
+        if (ret == 0)
+            /* timeout */
+            continue;
 
-                if (ret == -1 && errno == EINTR)
-                        /* sys call */
-                        continue;
+        if (ret == -1 && errno == EINTR)
+            /* sys call */
+            continue;
 
-		ret = event_dispatch_epoll_handler (event_pool, &event);
+        ret = event_dispatch_epoll_handler(event_pool, &event);
+        if (ret) {
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_DISPATCH_HANDLER_FAILED,
+                    NULL);
         }
+    }
 out:
-        if (ev_data)
-                GF_FREE (ev_data);
-        return NULL;
+    if (ev_data)
+        GF_FREE(ev_data);
+    return NULL;
 }
 
 /* Attempts to start the # of configured pollers, ensuring at least the first
  * is started in a joinable state */
 static int
-event_dispatch_epoll (struct event_pool *event_pool)
+event_dispatch_epoll(struct event_pool *event_pool)
 {
-	int                       i = 0;
-        pthread_t                 t_id;
-        int                       pollercount = 0;
-	int                       ret = -1;
-        struct event_thread_data *ev_data = NULL;
-        char                      thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        /* Start the configured number of pollers */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                pollercount = event_pool->eventthreadcount;
-
-                /* Set to MAX if greater */
-                if (pollercount > EVENT_MAX_THREADS)
-                        pollercount = EVENT_MAX_THREADS;
-
-                /* Default pollers to 1 in case this is incorrectly set */
-                if (pollercount <= 0)
-                        pollercount = 1;
-
-                event_pool->activethreadcount++;
-
-                for (i = 0; i < pollercount; i++) {
-                        ev_data = GF_CALLOC (1, sizeof (*ev_data),
-                                     gf_common_mt_event_pool);
-                        if (!ev_data) {
-                                if (i == 0) {
-                                        /* Need to suceed creating 0'th
-                                         * thread, to joinable and wait */
-                                        break;
-                                } else {
-                                        /* Inability to create other threads
-                                         * are a lesser evil, and ignored */
-                                        continue;
-                                }
-                        }
-
-                        ev_data->event_pool = event_pool;
-                        ev_data->event_index = i + 1;
-
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "%s%d", "epoll", i);
-                        ret = gf_thread_create (&t_id, NULL,
-                                                event_dispatch_epoll_worker,
-                                                ev_data, thread_name);
-                        if (!ret) {
-                                event_pool->pollers[i] = t_id;
-
-                                /* mark all threads other than one in index 0
-                                 * as detachable. Errors can be ignored, they
-                                 * spend their time as zombies if not detched
-                                 * and the thread counts are decreased */
-                                if (i != 0)
-                                        pthread_detach (event_pool->pollers[i]);
-                        } else {
-                                gf_msg ("epoll", GF_LOG_WARNING, 0,
-                                        LG_MSG_START_EPOLL_THREAD_FAILED,
-                                        "Failed to start thread for index %d",
-                                        i);
-                                if (i == 0) {
-                                        GF_FREE (ev_data);
-                                        break;
-                                } else {
-                                        GF_FREE (ev_data);
-                                        continue;
-                                }
-                        }
+    int i = 0;
+    pthread_t t_id;
+    int pollercount = 0;
+    int ret = -1;
+    struct event_thread_data *ev_data = NULL;
+
+    /* Start the configured number of pollers */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        pollercount = event_pool->eventthreadcount;
+
+        /* Set to MAX if greater */
+        if (pollercount > EVENT_MAX_THREADS)
+            pollercount = EVENT_MAX_THREADS;
+
+        /* Default pollers to 1 in case this is incorrectly set */
+        if (pollercount <= 0)
+            pollercount = 1;
+
+        event_pool->activethreadcount++;
+
+        for (i = 0; i < pollercount; i++) {
+            ev_data = GF_CALLOC(1, sizeof(*ev_data), gf_common_mt_event_pool);
+            if (!ev_data) {
+                if (i == 0) {
+                    /* Need to succeed creating 0'th
+                     * thread, to joinable and wait */
+                    break;
+                } else {
+                    /* Inability to create other threads
+                     * are a lesser evil, and ignored */
+                    continue;
+                }
+            }
+
+            ev_data->event_pool = event_pool;
+            ev_data->event_index = i + 1;
+
+            ret = gf_thread_create(&t_id, NULL, event_dispatch_epoll_worker,
+                                   ev_data, "epoll%03hx", i & 0x3ff);
+            if (!ret) {
+                event_pool->pollers[i] = t_id;
+
+                /* mark all threads other than one in index 0
+                 * as detachable. Errors can be ignored, they
+                 * spend their time as zombies if not detched
+                 * and the thread counts are decreased */
+                if (i != 0)
+                    pthread_detach(event_pool->pollers[i]);
+            } else {
+                gf_smsg("epoll", GF_LOG_WARNING, 0,
+                        LG_MSG_START_EPOLL_THREAD_FAILED, "index=%d", i, NULL);
+                if (i == 0) {
+                    GF_FREE(ev_data);
+                    break;
+                } else {
+                    GF_FREE(ev_data);
+                    continue;
                 }
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        /* Just wait for the first thread, that is created in a joinable state
-         * and will never die, ensuring this function never returns */
-        if (event_pool->pollers[0] != 0)
-		pthread_join (event_pool->pollers[0], NULL);
+    /* Just wait for the first thread, that is created in a joinable state
+     * and will never die, ensuring this function never returns */
+    if (event_pool->pollers[0] != 0)
+        pthread_join(event_pool->pollers[0], NULL);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                event_pool->activethreadcount--;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount--;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-	return ret;
+    return ret;
 }
 
 /**
@@ -764,90 +853,80 @@ event_dispatch_epoll (struct event_pool *event_pool)
  */
 
 static int
-event_pool_dispatched_unlocked (struct event_pool *event_pool)
+event_pool_dispatched_unlocked(struct event_pool *event_pool)
 {
-        return (event_pool->pollers[0] != 0);
-
+    return (event_pool->pollers[0] != 0);
 }
 
-
 int
-event_reconfigure_threads_epoll (struct event_pool *event_pool, int value)
+event_reconfigure_threads_epoll(struct event_pool *event_pool, int value)
 {
-        int                              i;
-        int                              ret = 0;
-        pthread_t                        t_id;
-        int                              oldthreadcount;
-        struct event_thread_data        *ev_data = NULL;
-        char                             thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                /* Reconfigure to 0 threads is allowed only in destroy mode */
-                if (event_pool->destroy == 1) {
-                        value = 0;
-                } else {
-                        /* Set to MAX if greater */
-                        if (value > EVENT_MAX_THREADS)
-                                value = EVENT_MAX_THREADS;
-
-                        /* Default pollers to 1 in case this is set incorrectly */
-                        if (value <= 0)
-                                value = 1;
-                }
+    int i;
+    int ret = 0;
+    pthread_t t_id;
+    int oldthreadcount;
+    struct event_thread_data *ev_data = NULL;
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        /* Reconfigure to 0 threads is allowed only in destroy mode */
+        if (event_pool->destroy == 1) {
+            value = 0;
+        } else {
+            /* Set to MAX if greater */
+            if (value > EVENT_MAX_THREADS)
+                value = EVENT_MAX_THREADS;
+
+            /* Default pollers to 1 in case this is set incorrectly */
+            if (value <= 0)
+                value = 1;
+        }
 
-                oldthreadcount = event_pool->eventthreadcount;
-
-                /* Start 'worker' threads as necessary only if event_dispatch()
-                 * was called before. If event_dispatch() was not called, there
-                 * will be no epoll 'worker' threads running yet. */
-
-                if (event_pool_dispatched_unlocked(event_pool)
-                    && (oldthreadcount < value)) {
-                        /* create more poll threads */
-                        for (i = oldthreadcount; i < value; i++) {
-                                /* Start a thread if the index at this location
-                                 * is a 0, so that the older thread is confirmed
-                                 * as dead */
-                                if (event_pool->pollers[i] == 0) {
-                                        ev_data = GF_CALLOC (1,
-                                                      sizeof (*ev_data),
-                                                      gf_common_mt_event_pool);
-                                        if (!ev_data) {
-                                                continue;
-                                        }
-
-                                        ev_data->event_pool = event_pool;
-                                        ev_data->event_index = i + 1;
-
-                                        snprintf (thread_name,
-                                                  sizeof(thread_name),
-                                                  "%s%d",
-                                                  "epoll", i);
-                                        ret = gf_thread_create (&t_id, NULL,
-                                                event_dispatch_epoll_worker,
-                                                ev_data, thread_name);
-                                        if (ret) {
-                                                gf_msg ("epoll", GF_LOG_WARNING,
-                                                        0,
-                                                        LG_MSG_START_EPOLL_THREAD_FAILED,
-                                                        "Failed to start thread"
-                                                        " for index %d", i);
-                                                GF_FREE (ev_data);
-                                        } else {
-                                                pthread_detach (t_id);
-                                                event_pool->pollers[i] = t_id;
-                                        }
-                                }
-                        }
+        oldthreadcount = event_pool->eventthreadcount;
+
+        /* Start 'worker' threads as necessary only if event_dispatch()
+         * was called before. If event_dispatch() was not called, there
+         * will be no epoll 'worker' threads running yet. */
+
+        if (event_pool_dispatched_unlocked(event_pool) &&
+            (oldthreadcount < value)) {
+            /* create more poll threads */
+            for (i = oldthreadcount; i < value; i++) {
+                /* Start a thread if the index at this location
+                 * is a 0, so that the older thread is confirmed
+                 * as dead */
+                if (event_pool->pollers[i] == 0) {
+                    ev_data = GF_CALLOC(1, sizeof(*ev_data),
+                                        gf_common_mt_event_pool);
+                    if (!ev_data) {
+                        continue;
+                    }
+
+                    ev_data->event_pool = event_pool;
+                    ev_data->event_index = i + 1;
+
+                    ret = gf_thread_create(&t_id, NULL,
+                                           event_dispatch_epoll_worker, ev_data,
+                                           "epoll%03hx", i & 0x3ff);
+                    if (ret) {
+                        gf_smsg("epoll", GF_LOG_WARNING, 0,
+                                LG_MSG_START_EPOLL_THREAD_FAILED, "index=%d", i,
+                                NULL);
+                        GF_FREE(ev_data);
+                    } else {
+                        pthread_detach(t_id);
+                        event_pool->pollers[i] = t_id;
+                    }
                 }
-
-                /* if value decreases, threads will terminate, themselves */
-                event_pool->eventthreadcount = value;
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
 
-        return 0;
+        /* if value decreases, threads will terminate, themselves */
+        event_pool->eventthreadcount = value;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    return 0;
 }
 
 /* This function is the destructor for the event_pool data structure
@@ -855,93 +934,99 @@ event_reconfigure_threads_epoll (struct event_pool *event_pool, int value)
  * else will lead to crashes.
  */
 static int
-event_pool_destroy_epoll (struct event_pool *event_pool)
+event_pool_destroy_epoll(struct event_pool *event_pool)
 {
-        int ret = 0, i = 0, j = 0;
-        struct event_slot_epoll *table = NULL;
-
-        ret = sys_close (event_pool->fd);
-
-        for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
-                if (event_pool->ereg[i]) {
-                        table = event_pool->ereg[i];
-                        event_pool->ereg[i] = NULL;
-                                for (j = 0; j < EVENT_EPOLL_SLOTS; j++) {
-                                        LOCK_DESTROY (&table[j].lock);
-                                }
-                        GF_FREE (table);
-                }
+    int ret = 0, i = 0, j = 0;
+    struct event_slot_epoll *table = NULL;
+
+    ret = sys_close(event_pool->fd);
+
+    for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
+        if (event_pool->ereg[i]) {
+            table = event_pool->ereg[i];
+            event_pool->ereg[i] = NULL;
+            for (j = 0; j < EVENT_EPOLL_SLOTS; j++) {
+                LOCK_DESTROY(&table[j].lock);
+            }
+            GF_FREE(table);
         }
+    }
 
-        pthread_mutex_destroy (&event_pool->mutex);
-        pthread_cond_destroy (&event_pool->cond);
+    pthread_mutex_destroy(&event_pool->mutex);
+    pthread_cond_destroy(&event_pool->cond);
 
-        GF_FREE (event_pool->evcache);
-        GF_FREE (event_pool->reg);
-        GF_FREE (event_pool);
+    GF_FREE(event_pool->evcache);
+    GF_FREE(event_pool->reg);
+    GF_FREE(event_pool);
 
-        return ret;
+    return ret;
 }
 
 static int
-event_handled_epoll (struct event_pool *event_pool, int fd, int idx, int gen)
+event_handled_epoll(struct event_pool *event_pool, int fd, int idx, int gen)
 {
-        struct event_slot_epoll *slot  = NULL;
-        struct epoll_event epoll_event = {0, };
-        struct event_data *ev_data     = (void *)&epoll_event.data;
-        int                ret         = 0;
-
-	slot = event_slot_get (event_pool, idx);
-
-        assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		slot->in_handler--;
-
-		if (gen != slot->gen) {
-			/* event_unregister() happened while we were
-			   in handler()
-			*/
-			gf_msg_debug ("epoll", 0, "generation bumped on idx=%d"
-                                      " from gen=%d to slot->gen=%d, fd=%d, "
-				      "slot->fd=%d", idx, gen, slot->gen, fd,
-                                      slot->fd);
-			goto post_unlock;
-		}
-
-		/* This call also picks up the changes made by another
-		   thread calling event_select_on_epoll() while this
-		   thread was busy in handler()
-		*/
-                if (slot->in_handler == 0) {
-                        epoll_event.events = slot->events;
-                        ev_data->idx = idx;
-                        ev_data->gen = gen;
-
-                        ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD,
-                                         fd, &epoll_event);
-                }
-	}
-post_unlock:
-	UNLOCK (&slot->lock);
+    struct event_slot_epoll *slot = NULL;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+    int ret = 0;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        slot->in_handler--;
+
+        if (gen != slot->gen) {
+            /* event_unregister() happened while we were
+               in handler()
+            */
+            gf_msg_debug("epoll", 0,
+                         "generation bumped on idx=%d"
+                         " from gen=%d to slot->gen=%d, fd=%d, "
+                         "slot->fd=%d",
+                         idx, gen, slot->gen, fd, slot->fd);
+            goto unlock;
+        }
 
-        event_slot_unref (event_pool, slot, idx);
+        /* This call also picks up the changes made by another
+           thread calling event_select_on_epoll() while this
+           thread was busy in handler()
+        */
+        if (slot->in_handler == 0) {
+            epoll_event.events = slot->events;
+            ev_data->idx = idx;
+            ev_data->gen = gen;
 
-        return ret;
-}
+            ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event);
+        }
+    }
+unlock:
+    UNLOCK(&slot->lock);
+
+    event_slot_unref(event_pool, slot, idx);
 
+    return ret;
+}
 
 struct event_ops event_ops_epoll = {
-        .new                       = event_pool_new_epoll,
-        .event_register            = event_register_epoll,
-        .event_select_on           = event_select_on_epoll,
-        .event_unregister          = event_unregister_epoll,
-        .event_unregister_close    = event_unregister_close_epoll,
-        .event_dispatch            = event_dispatch_epoll,
-        .event_reconfigure_threads = event_reconfigure_threads_epoll,
-        .event_pool_destroy        = event_pool_destroy_epoll,
-        .event_handled             = event_handled_epoll,
+    .new = event_pool_new_epoll,
+    .event_register = event_register_epoll,
+    .event_select_on = event_select_on_epoll,
+    .event_unregister = event_unregister_epoll,
+    .event_unregister_close = event_unregister_close_epoll,
+    .event_dispatch = event_dispatch_epoll,
+    .event_reconfigure_threads = event_reconfigure_threads_epoll,
+    .event_pool_destroy = event_pool_destroy_epoll,
+    .event_handled = event_handled_epoll,
 };
 
 #endif
diff --git a/libglusterfs/src/event-history.c b/libglusterfs/src/event-history.c
index 95484a4322b..379fed866be 100644
--- a/libglusterfs/src/event-history.c
+++ b/libglusterfs/src/event-history.c
@@ -8,76 +8,75 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "event-history.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/event-history.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 eh_t *
-eh_new (size_t buffer_size, gf_boolean_t use_buffer_once,
-        void (*destroy_buffer_data) (void *data))
+eh_new(size_t buffer_size, gf_boolean_t use_buffer_once,
+       void (*destroy_buffer_data)(void *data))
 {
-        eh_t *history = NULL;
-        buffer_t *buffer = NULL;
+    eh_t *history = NULL;
+    buffer_t *buffer = NULL;
 
-        history = GF_CALLOC (1, sizeof (eh_t), gf_common_mt_eh_t);
-        if (!history) {
-                goto out;
-        }
+    history = GF_CALLOC(1, sizeof(eh_t), gf_common_mt_eh_t);
+    if (!history) {
+        goto out;
+    }
 
-        buffer = cb_buffer_new (buffer_size, use_buffer_once,
-                                destroy_buffer_data);
-        if (!buffer) {
-                GF_FREE (history);
-                history = NULL;
-                goto out;
-        }
+    buffer = cb_buffer_new(buffer_size, use_buffer_once, destroy_buffer_data);
+    if (!buffer) {
+        GF_FREE(history);
+        history = NULL;
+        goto out;
+    }
 
-        history->buffer = buffer;
+    history->buffer = buffer;
 
-        pthread_mutex_init (&history->lock, NULL);
+    pthread_mutex_init(&history->lock, NULL);
 out:
-        return history;
+    return history;
 }
 
 void
-eh_dump (eh_t *history, void *data,
-         int (dump_fn) (circular_buffer_t *buffer, void *data))
+eh_dump(eh_t *history, void *data,
+        int(dump_fn)(circular_buffer_t *buffer, void *data))
 {
-        if (!history) {
-                gf_msg_debug ("event-history", 0, "history is NULL");
-                goto out;
-        }
+    if (!history) {
+        gf_msg_debug("event-history", 0, "history is NULL");
+        goto out;
+    }
 
-        cb_buffer_dump (history->buffer, data, dump_fn);
+    cb_buffer_dump(history->buffer, data, dump_fn);
 
 out:
-        return;
+    return;
 }
 
 int
-eh_save_history (eh_t *history, void *data)
+eh_save_history(eh_t *history, void *data)
 {
-        int   ret = -1;
+    int ret = -1;
 
-        ret = cb_add_entry_buffer (history->buffer, data);
+    ret = cb_add_entry_buffer(history->buffer, data);
 
-        return ret;
+    return ret;
 }
 
 int
-eh_destroy (eh_t *history)
+eh_destroy(eh_t *history)
 {
-        if (!history) {
-                gf_msg ("event-history", GF_LOG_INFO, 0, LG_MSG_INVALID_ARG,
-                        "history for the xlator is NULL");
-                return -1;
-        }
+    if (!history) {
+        gf_msg("event-history", GF_LOG_INFO, 0, LG_MSG_INVALID_ARG,
+               "history for the xlator is NULL");
+        return -1;
+    }
 
-        cb_buffer_destroy (history->buffer);
-        history->buffer = NULL;
+    cb_buffer_destroy(history->buffer);
+    history->buffer = NULL;
 
-        pthread_mutex_destroy (&history->lock);
+    pthread_mutex_destroy(&history->lock);
 
-        GF_FREE (history);
+    GF_FREE(history);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/event-history.h b/libglusterfs/src/event-history.h
deleted file mode 100644
index de5d47cdfee..00000000000
--- a/libglusterfs/src/event-history.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _EH_H
-#define _EH_H
-
-#include "mem-types.h"
-#include "circ-buff.h"
-
-struct event_hist
-{
-        buffer_t *buffer;
-        pthread_mutex_t lock;
-};
-
-typedef struct event_hist eh_t;
-
-void
-eh_dump (eh_t *event , void *data,
-         int (fn) (circular_buffer_t *buffer, void *data));
-
-eh_t *
-eh_new (size_t buffer_size, gf_boolean_t use_buffer_once,
-        void (*destroy_data) (void *data));
-
-int
-eh_save_history (eh_t *history, void *string);
-
-int
-eh_destroy (eh_t *history);
-
-#endif /* _EH_H */
diff --git a/libglusterfs/src/event-poll.c b/libglusterfs/src/event-poll.c
index 3bffc4784d7..2cba963f096 100644
--- a/libglusterfs/src/event-poll.c
+++ b/libglusterfs/src/event-poll.c
@@ -16,486 +16,465 @@
 #include <errno.h>
 #include <string.h>
 
-#include "logging.h"
-#include "event.h"
-#include "mem-pool.h"
-#include "common-utils.h"
-#include "syscall.h"
-#include "libglusterfs-messages.h"
-
-
+#include "glusterfs/logging.h"
+#include "glusterfs/gf-event.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 struct event_slot_poll {
-	int fd;
-	int events;
-	void *data;
-	event_handler_t handler;
+    int fd;
+    int events;
+    void *data;
+    event_handler_t handler;
 };
 
-
 static int
-event_register_poll (struct event_pool *event_pool, int fd,
-                     event_handler_t handler,
-                     void *data, int poll_in, int poll_out);
+event_register_poll(struct event_pool *event_pool, int fd,
+                    event_handler_t handler, void *data, int poll_in,
+                    int poll_out, char notify_poller_death);
 
-
-static int
-__flush_fd (int fd, int idx, int gen, void *data,
-            int poll_in, int poll_out, int poll_err)
+static void
+__flush_fd(int fd, int idx, int gen, void *data, int poll_in, int poll_out,
+           int poll_err, char event_thread_died)
 {
-        char buf[64];
-        int ret = -1;
+    char buf[64];
+    int ret = -1;
 
-        if (!poll_in)
-                return ret;
+    if (!poll_in)
+        return;
 
-        do {
-                ret = sys_read (fd, buf, 64);
-                if (ret == -1 && errno != EAGAIN) {
-                        gf_msg ("poll", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED, "read on %d returned "
-                                "error", fd);
-                }
-        } while (ret == 64);
+    do {
+        ret = sys_read(fd, buf, 64);
+        if (ret == -1 && errno != EAGAIN) {
+            gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_READ_FILE_FAILED,
+                    "fd=%d", fd, NULL);
+        }
+    } while (ret == 64);
 
-        return ret;
+    return;
 }
 
-
 static int
-__event_getindex (struct event_pool *event_pool, int fd, int idx)
+__event_getindex(struct event_pool *event_pool, int fd, int idx)
 {
-        int  ret = -1;
-        int  i = 0;
+    int ret = -1;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        /* lookup in used space based on index provided */
-        if (idx > -1 && idx < event_pool->used) {
-                if (event_pool->reg[idx].fd == fd) {
-                        ret = idx;
-                        goto out;
-                }
+    /* lookup in used space based on index provided */
+    if (idx > -1 && idx < event_pool->used) {
+        if (event_pool->reg[idx].fd == fd) {
+            ret = idx;
+            goto out;
         }
+    }
 
-        /* search in used space, if lookup fails */
-        for (i = 0; i < event_pool->used; i++) {
-                if (event_pool->reg[i].fd == fd) {
-                        ret = i;
-                        break;
-                }
+    /* search in used space, if lookup fails */
+    for (i = 0; i < event_pool->used; i++) {
+        if (event_pool->reg[i].fd == fd) {
+            ret = i;
+            break;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static struct event_pool *
-event_pool_new_poll (int count, int eventthreadcount)
+event_pool_new_poll(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-        int                ret = -1;
+    struct event_pool *event_pool = NULL;
+    int ret = -1;
 
-        event_pool = GF_CALLOC (1, sizeof (*event_pool),
-                                gf_common_mt_event_pool);
+    event_pool = GF_CALLOC(1, sizeof(*event_pool), gf_common_mt_event_pool);
 
-        if (!event_pool)
-                return NULL;
+    if (!event_pool)
+        return NULL;
 
-        event_pool->count = count;
-        event_pool->reg = GF_CALLOC (event_pool->count,
-                                     sizeof (*event_pool->reg),
-                                     gf_common_mt_reg);
+    event_pool->count = count;
+    event_pool->reg = GF_CALLOC(event_pool->count, sizeof(*event_pool->reg),
+                                gf_common_mt_reg);
 
-        if (!event_pool->reg) {
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    if (!event_pool->reg) {
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        pthread_mutex_init (&event_pool->mutex, NULL);
+    pthread_mutex_init(&event_pool->mutex, NULL);
 
-        ret = pipe (event_pool->breaker);
+    ret = pipe(event_pool->breaker);
 
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED,
-                        "pipe creation failed");
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    if (ret == -1) {
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED, NULL);
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        ret = fcntl (event_pool->breaker[0], F_SETFL, O_NONBLOCK);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-                        "could not set pipe to non blocking mode");
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    ret = fcntl(event_pool->breaker[0], F_SETFL, O_NONBLOCK);
+    if (ret == -1) {
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED, NULL);
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        ret = fcntl (event_pool->breaker[1], F_SETFL, O_NONBLOCK);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-                        "could not set pipe to non blocking mode");
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
+    ret = fcntl(event_pool->breaker[1], F_SETFL, O_NONBLOCK);
+    if (ret == -1) {
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED, NULL);
 
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        ret = event_register_poll (event_pool, event_pool->breaker[0],
-                                   __flush_fd, NULL, 1, 0);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED,
-                        "could not register pipe fd with poll event loop");
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
+
+    ret = event_register_poll(event_pool, event_pool->breaker[0], __flush_fd,
+                              NULL, 1, 0, 0);
+    if (ret == -1) {
+        gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED, NULL);
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        if (eventthreadcount > 1) {
-                gf_msg ("poll", GF_LOG_INFO, 0,
-                        LG_MSG_POLL_IGNORE_MULTIPLE_THREADS, "Currently poll "
-                        "does not use multiple event processing threads, "
-                        "thread count (%d) ignored", eventthreadcount);
-        }
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        return event_pool;
-}
+    if (eventthreadcount > 1) {
+        gf_smsg("poll", GF_LOG_INFO, 0, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
+                "count=%d", eventthreadcount, NULL);
+    }
 
+    /* although, eventhreadcount for poll implementation is always
+     * going to be 1, eventthreadcount needs to be set to 1 so that
+     * rpcsvc_request_handler() thread scaling works flawlessly in
+     * both epoll and poll models
+     */
+    event_pool->eventthreadcount = 1;
+
+    return event_pool;
+}
 
 static int
-event_register_poll (struct event_pool *event_pool, int fd,
-                     event_handler_t handler,
-                     void *data, int poll_in, int poll_out)
+event_register_poll(struct event_pool *event_pool, int fd,
+                    event_handler_t handler, void *data, int poll_in,
+                    int poll_out, char notify_poller_death)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                if (event_pool->count == event_pool->used)
-                {
-                        event_pool->count += 256;
-
-                        event_pool->reg = GF_REALLOC (event_pool->reg,
-                                                      event_pool->count *
-                                                      sizeof (*event_pool->reg));
-                        if (!event_pool->reg)
-                                goto unlock;
-                }
-
-                idx = event_pool->used++;
-
-                event_pool->reg[idx].fd = fd;
-                event_pool->reg[idx].events = POLLPRI;
-                event_pool->reg[idx].handler = handler;
-                event_pool->reg[idx].data = data;
-
-                switch (poll_in) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLIN;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLIN;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_POLL_IN,
-                                "invalid poll_in value %d", poll_in);
-                        break;
-                }
-
-                switch (poll_out) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLOUT;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLOUT;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_POLL_OUT,
-                                "invalid poll_out value %d", poll_out);
-                        break;
-                }
-
-                event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        if (event_pool->count == event_pool->used) {
+            event_pool->count += 256;
+
+            event_pool->reg = GF_REALLOC(
+                event_pool->reg, event_pool->count * sizeof(*event_pool->reg));
+            if (!event_pool->reg)
+                goto unlock;
+        }
+
+        idx = event_pool->used++;
+
+        event_pool->reg[idx].fd = fd;
+        event_pool->reg[idx].events = POLLPRI;
+        event_pool->reg[idx].handler = handler;
+        event_pool->reg[idx].data = data;
+
+        switch (poll_in) {
+            case 1:
+                event_pool->reg[idx].events |= POLLIN;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLIN;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                        "value=%d", poll_in, NULL);
+                break;
+        }
 
+        switch (poll_out) {
+            case 1:
+                event_pool->reg[idx].events |= POLLOUT;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLOUT;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                        "value=%d", poll_out, NULL);
+                break;
         }
+
+        event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_poll (struct event_pool *event_pool, int fd, int idx_hint)
+event_unregister_poll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, fd, idx_hint);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                                "index not found for fd=%d (idx_hint=%d)",
-                                fd, idx_hint);
-                        errno = ENOENT;
-                        goto unlock;
-                }
-
-                event_pool->reg[idx] =  event_pool->reg[--event_pool->used];
-                event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, fd, idx_hint);
+
+        if (idx == -1) {
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    fd, "idx_hint=%d", idx_hint, NULL);
+            errno = ENOENT;
+            goto unlock;
         }
+
+        event_pool->reg[idx] = event_pool->reg[--event_pool->used];
+        event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_close_poll (struct event_pool *event_pool, int fd,
-			     int idx_hint)
+event_unregister_close_poll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_poll (event_pool, fd, idx_hint);
+    ret = event_unregister_poll(event_pool, fd, idx_hint);
 
-	sys_close (fd);
+    sys_close(fd);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-event_select_on_poll (struct event_pool *event_pool, int fd, int idx_hint,
-                      int poll_in, int poll_out)
+event_select_on_poll(struct event_pool *event_pool, int fd, int idx_hint,
+                     int poll_in, int poll_out)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, fd, idx_hint);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                                "index not found for fd=%d (idx_hint=%d)",
-                                fd, idx_hint);
-                        errno = ENOENT;
-                        goto unlock;
-                }
-
-                switch (poll_in) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLIN;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLIN;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        /* TODO: log error */
-                        break;
-                }
-
-                switch (poll_out) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLOUT;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLOUT;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        /* TODO: log error */
-                        break;
-                }
-
-                if (poll_in + poll_out > -2)
-                        event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, fd, idx_hint);
+
+        if (idx == -1) {
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    fd, "idx_hint=%d", idx_hint, NULL);
+            errno = ENOENT;
+            goto unlock;
         }
+
+        switch (poll_in) {
+            case 1:
+                event_pool->reg[idx].events |= POLLIN;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLIN;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                /* TODO: log error */
+                break;
+        }
+
+        switch (poll_out) {
+            case 1:
+                event_pool->reg[idx].events |= POLLOUT;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLOUT;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                /* TODO: log error */
+                break;
+        }
+
+        if (poll_in + poll_out > -2)
+            event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_dispatch_poll_handler (struct event_pool *event_pool,
-                             struct pollfd *ufds, int i)
+event_dispatch_poll_handler(struct event_pool *event_pool, struct pollfd *ufds,
+                            int i)
 {
-        event_handler_t  handler = NULL;
-        void            *data = NULL;
-        int              idx = -1;
-        int              ret = 0;
-
-        handler = NULL;
-        data    = NULL;
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, ufds[i].fd, i);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INDEX_NOT_FOUND, "index not found for "
-                                "fd=%d (idx_hint=%d)", ufds[i].fd, i);
-                        goto unlock;
-                }
-
-                handler = event_pool->reg[idx].handler;
-                data = event_pool->reg[idx].data;
+    event_handler_t handler = NULL;
+    void *data = NULL;
+    int idx = -1;
+    int ret = 0;
+
+    handler = NULL;
+    data = NULL;
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, ufds[i].fd, i);
+
+        if (idx == -1) {
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    ufds[i].fd, "idx_hint=%d", i, NULL);
+            goto unlock;
         }
+
+        handler = event_pool->reg[idx].handler;
+        data = event_pool->reg[idx].data;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        if (handler)
-                ret = handler (ufds[i].fd, idx, 0, data,
-                               (ufds[i].revents & (POLLIN|POLLPRI)),
-                               (ufds[i].revents & (POLLOUT)),
-                               (ufds[i].revents & (POLLERR|POLLHUP|POLLNVAL)));
+    if (handler)
+        handler(ufds[i].fd, idx, 0, data,
+                (ufds[i].revents & (POLLIN | POLLPRI)),
+                (ufds[i].revents & (POLLOUT)),
+                (ufds[i].revents & (POLLERR | POLLHUP | POLLNVAL)), 0);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-event_dispatch_poll_resize (struct event_pool *event_pool,
-                            struct pollfd *ufds, int size)
+event_dispatch_poll_resize(struct event_pool *event_pool, struct pollfd *ufds,
+                           int size)
 {
-        int              i = 0;
+    int i = 0;
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                if (event_pool->changed == 0) {
-                        goto unlock;
-                }
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        if (event_pool->changed == 0) {
+            goto unlock;
+        }
 
-                if (event_pool->used > event_pool->evcache_size) {
-                        GF_FREE (event_pool->evcache);
+        if (event_pool->used > event_pool->evcache_size) {
+            GF_FREE(event_pool->evcache);
 
-                        event_pool->evcache = ufds = NULL;
+            event_pool->evcache = ufds = NULL;
 
-                        event_pool->evcache_size = event_pool->used;
+            event_pool->evcache_size = event_pool->used;
 
-                        ufds = GF_CALLOC (sizeof (struct pollfd),
-                                          event_pool->evcache_size,
-                                          gf_common_mt_pollfd);
-                        if (!ufds)
-                                goto unlock;
-                        event_pool->evcache = ufds;
-                }
+            ufds = GF_CALLOC(sizeof(struct pollfd), event_pool->evcache_size,
+                             gf_common_mt_pollfd);
+            if (!ufds)
+                goto unlock;
+            event_pool->evcache = ufds;
+        }
 
-                for (i = 0; i < event_pool->used; i++) {
-                        ufds[i].fd = event_pool->reg[i].fd;
-                        ufds[i].events = event_pool->reg[i].events;
-                        ufds[i].revents = 0;
-                }
+        if (ufds == NULL) {
+            goto unlock;
+        }
 
-                size = i;
+        for (i = 0; i < event_pool->used; i++) {
+            ufds[i].fd = event_pool->reg[i].fd;
+            ufds[i].events = event_pool->reg[i].events;
+            ufds[i].revents = 0;
         }
+
+        size = i;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        return size;
+    return size;
 }
 
-
 static int
-event_dispatch_poll (struct event_pool *event_pool)
+event_dispatch_poll(struct event_pool *event_pool)
 {
-        struct pollfd   *ufds = NULL;
-        int              size = 0;
-        int              i = 0;
-        int              ret = -1;
+    struct pollfd *ufds = NULL;
+    int size = 0;
+    int i = 0;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount = 1;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    while (1) {
+        pthread_mutex_lock(&event_pool->mutex);
         {
-                event_pool->activethreadcount = 1;
+            if (event_pool->destroy == 1) {
+                event_pool->activethreadcount = 0;
+                pthread_cond_broadcast(&event_pool->cond);
+                pthread_mutex_unlock(&event_pool->mutex);
+                return 0;
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        while (1) {
-                pthread_mutex_lock (&event_pool->mutex);
-                {
-                        if (event_pool->destroy == 1) {
-                                event_pool->activethreadcount = 0;
-                                pthread_cond_broadcast (&event_pool->cond);
-                                pthread_mutex_unlock (&event_pool->mutex);
-                                return 0;
-                        }
-                }
-                pthread_mutex_unlock (&event_pool->mutex);
-
-                size = event_dispatch_poll_resize (event_pool, ufds, size);
-                ufds = event_pool->evcache;
-
-                ret = poll (ufds, size, 1);
-
-                if (ret == 0)
-                        /* timeout */
-                        continue;
-
-                if (ret == -1 && errno == EINTR)
-                        /* sys call */
-                        continue;
-
-                for (i = 0; i < size; i++) {
-                        if (!ufds[i].revents)
-                                continue;
-
-                        event_dispatch_poll_handler (event_pool, ufds, i);
-                }
+        pthread_mutex_unlock(&event_pool->mutex);
+
+        size = event_dispatch_poll_resize(event_pool, ufds, size);
+        ufds = event_pool->evcache;
+
+        ret = poll(ufds, size, 1);
+
+        if (ret == 0)
+            /* timeout */
+            continue;
+
+        if (ret == -1 && errno == EINTR)
+            /* sys call */
+            continue;
+
+        for (i = 0; i < size; i++) {
+            if (!ufds[i].revents)
+                continue;
+
+            event_dispatch_poll_handler(event_pool, ufds, i);
         }
+    }
 
 out:
-        return -1;
+    return -1;
 }
 
 int
-event_reconfigure_threads_poll (struct event_pool *event_pool, int value)
+event_reconfigure_threads_poll(struct event_pool *event_pool, int value)
 {
-        /* No-op for poll */
+    /* No-op for poll */
 
-        return 0;
+    return 0;
 }
 
 /* This function is the destructor for the event_pool data structure
@@ -503,33 +482,32 @@ event_reconfigure_threads_poll (struct event_pool *event_pool, int value)
  * else will lead to crashes.
  */
 static int
-event_pool_destroy_poll (struct event_pool *event_pool)
+event_pool_destroy_poll(struct event_pool *event_pool)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = sys_close (event_pool->breaker[0]);
-        if (ret)
-                return ret;
+    ret = sys_close(event_pool->breaker[0]);
+    if (ret)
+        return ret;
 
-        ret = sys_close (event_pool->breaker[1]);
-        if (ret)
-                return ret;
+    ret = sys_close(event_pool->breaker[1]);
+    if (ret)
+        return ret;
 
-        event_pool->breaker[0] = event_pool->breaker[1] = -1;
+    event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        GF_FREE (event_pool->reg);
-        GF_FREE (event_pool);
+    GF_FREE(event_pool->reg);
+    GF_FREE(event_pool);
 
-        return ret;
+    return ret;
 }
 
 struct event_ops event_ops_poll = {
-        .new                    = event_pool_new_poll,
-        .event_register         = event_register_poll,
-        .event_select_on        = event_select_on_poll,
-        .event_unregister       = event_unregister_poll,
-        .event_unregister_close = event_unregister_close_poll,
-        .event_dispatch         = event_dispatch_poll,
-        .event_reconfigure_threads = event_reconfigure_threads_poll,
-        .event_pool_destroy     = event_pool_destroy_poll
-};
+    .new = event_pool_new_poll,
+    .event_register = event_register_poll,
+    .event_select_on = event_select_on_poll,
+    .event_unregister = event_unregister_poll,
+    .event_unregister_close = event_unregister_close_poll,
+    .event_dispatch = event_dispatch_poll,
+    .event_reconfigure_threads = event_reconfigure_threads_poll,
+    .event_pool_destroy = event_pool_destroy_poll};
diff --git a/libglusterfs/src/event.c b/libglusterfs/src/event.c
index bba6f8429a1..402c253ca25 100644
--- a/libglusterfs/src/event.c
+++ b/libglusterfs/src/event.c
@@ -16,289 +16,290 @@
 #include <errno.h>
 #include <string.h>
 
-#include "logging.h"
-#include "event.h"
-#include "mem-pool.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
-#include "syscall.h"
-
-
+#include "glusterfs/gf-event.h"
+#include "glusterfs/timespec.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
+#include "glusterfs/syscall.h"
 
 struct event_pool *
-event_pool_new (int count, int eventthreadcount)
+gf_event_pool_new(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-	extern struct event_ops event_ops_poll;
+    struct event_pool *event_pool = NULL;
+    extern struct event_ops event_ops_poll;
 
 #ifdef HAVE_SYS_EPOLL_H
-	extern struct event_ops event_ops_epoll;
+    extern struct event_ops event_ops_epoll;
 
-        event_pool = event_ops_epoll.new (count, eventthreadcount);
+    event_pool = event_ops_epoll.new(count, eventthreadcount);
 
-        if (event_pool) {
-                event_pool->ops = &event_ops_epoll;
-        } else {
-                gf_msg ("event", GF_LOG_WARNING, 0, LG_MSG_FALLBACK_TO_POLL,
-                        "falling back to poll based event handling");
-        }
+    if (event_pool) {
+        event_pool->ops = &event_ops_epoll;
+    } else {
+        gf_msg("event", GF_LOG_WARNING, 0, LG_MSG_FALLBACK_TO_POLL,
+               "falling back to poll based event handling");
+    }
 #endif
 
-        if (!event_pool) {
-                event_pool = event_ops_poll.new (count, eventthreadcount);
+    if (!event_pool) {
+        event_pool = event_ops_poll.new(count, eventthreadcount);
 
-                if (event_pool)
-                        event_pool->ops = &event_ops_poll;
-        }
+        if (event_pool)
+            event_pool->ops = &event_ops_poll;
+    }
 
-        return event_pool;
+    return event_pool;
 }
 
-
 int
-event_register (struct event_pool *event_pool, int fd,
-                event_handler_t handler,
-                void *data, int poll_in, int poll_out)
+gf_event_register(struct event_pool *event_pool, int fd,
+                  event_handler_t handler, void *data, int poll_in,
+                  int poll_out, char notify_poller_death)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_register (event_pool, fd, handler, data,
-                                               poll_in, poll_out);
+    ret = event_pool->ops->event_register(
+        event_pool, fd, handler, data, poll_in, poll_out, notify_poller_death);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_unregister (struct event_pool *event_pool, int fd, int idx)
+gf_event_unregister(struct event_pool *event_pool, int fd, int idx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_unregister (event_pool, fd, idx);
+    ret = event_pool->ops->event_unregister(event_pool, fd, idx);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_unregister_close (struct event_pool *event_pool, int fd, int idx)
+gf_event_unregister_close(struct event_pool *event_pool, int fd, int idx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_unregister_close (event_pool, fd, idx);
+    ret = event_pool->ops->event_unregister_close(event_pool, fd, idx);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_select_on (struct event_pool *event_pool, int fd, int idx_hint,
-                 int poll_in, int poll_out)
+gf_event_select_on(struct event_pool *event_pool, int fd, int idx_hint,
+                   int poll_in, int poll_out)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_select_on (event_pool, fd, idx_hint,
-                                                poll_in, poll_out);
+    ret = event_pool->ops->event_select_on(event_pool, fd, idx_hint, poll_in,
+                                           poll_out);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_dispatch (struct event_pool *event_pool)
+gf_event_dispatch(struct event_pool *event_pool)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_dispatch (event_pool);
-        if (ret)
-                goto out;
+    ret = event_pool->ops->event_dispatch(event_pool);
+    if (ret)
+        goto out;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-event_reconfigure_threads (struct event_pool *event_pool, int value)
+gf_event_reconfigure_threads(struct event_pool *event_pool, int value)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        /* call event refresh function */
-        ret = event_pool->ops->event_reconfigure_threads (event_pool,
-                                                          value);
+    /* call event refresh function */
+    ret = event_pool->ops->event_reconfigure_threads(event_pool, value);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-event_pool_destroy (struct event_pool *event_pool)
+gf_event_pool_destroy(struct event_pool *event_pool)
 {
-        int ret = -1;
-        int destroy = 0, activethreadcount = 0;
+    int ret = -1;
+    int destroy = 0, activethreadcount = 0;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                destroy = event_pool->destroy;
-                activethreadcount = event_pool->activethreadcount;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        destroy = event_pool->destroy;
+        activethreadcount = event_pool->activethreadcount;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        if (!destroy || (activethreadcount > 0)) {
-                goto out;
-        }
+    if (!destroy || (activethreadcount > 0)) {
+        goto out;
+    }
 
-        ret = event_pool->ops->event_pool_destroy (event_pool);
+    ret = event_pool->ops->event_pool_destroy(event_pool);
 out:
-        return ret;
+    return ret;
 }
 
-int
-poller_destroy_handler (int fd, int idx, int gen, void *data,
-                       int poll_out, int poll_in, int poll_err)
+void
+poller_destroy_handler(int fd, int idx, int gen, void *data, int poll_out,
+                       int poll_in, int poll_err, char event_thread_exit)
 {
-        struct event_destroy_data *destroy = NULL;
-        int                        readfd  = -1, ret = -1;
-        char                       buf     = '\0';
-
-        destroy = data;
-        readfd = destroy->readfd;
-        if (readfd < 0) {
-                goto out;
-        }
+    struct event_destroy_data *destroy = NULL;
+    int readfd = -1;
+    char buf = '\0';
 
-        while (sys_read (readfd, &buf, 1) > 0) {
-        }
+    destroy = data;
+    readfd = destroy->readfd;
+    if (readfd < 0) {
+        goto out;
+    }
+
+    while (sys_read(readfd, &buf, 1) > 0) {
+    }
 
-        ret = 0;
 out:
-        event_handled (destroy->pool, fd, idx, gen);
+    gf_event_handled(destroy->pool, fd, idx, gen);
 
-        return ret;
+    return;
 }
 
 /* This function destroys all the poller threads.
- * Note: to be called before event_pool_destroy is called.
+ * Note: to be called before gf_event_pool_destroy is called.
  * The order in which cleaning is performed:
  * - Register a pipe fd(this is for waking threads in poll()/epoll_wait())
- * - Set the destroy mode, which this no new event registration will succede
- * - Reconfigure the thread count to 0(this will succede only in destroy mode)
+ * - Set the destroy mode, which this no new event registration will succeed
+ * - Reconfigure the thread count to 0(this will succeed only in destroy mode)
  * - Wake up all the threads in poll() or epoll_wait(), so that they can
  *   destroy themselves.
  * - Wait for the thread to join(which will happen only after all the other
  *   threads are destroyed)
  */
 int
-event_dispatch_destroy (struct event_pool *event_pool)
+gf_event_dispatch_destroy(struct event_pool *event_pool)
 {
-        int                       ret        = -1, threadcount = 0;
-        int  fd[2]                           = {-1};
-        int                       idx        = -1;
-        int                       flags      = 0;
-        struct timespec           sleep_till = {0, };
-        struct event_destroy_data data       = {0, };
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        ret = pipe (fd);
-        if (ret < 0)
-                goto out;
-
-        /* Make the read end of the pipe nonblocking */
-        flags = fcntl(fd[0], F_GETFL);
-        flags |= O_NONBLOCK;
-        ret = fcntl(fd[0], F_SETFL, flags);
-        if (ret < 0)
-                goto out;
-
-        /* Make the write end of the pipe nonblocking */
-        flags = fcntl(fd[1], F_GETFL);
-        flags |= O_NONBLOCK;
-        ret = fcntl(fd[1], F_SETFL, flags);
-        if (ret < 0)
-                goto out;
-
-        data.pool = event_pool;
-        data.readfd = fd[1];
-
-        /* From the main thread register an event on the pipe fd[0],
-         */
-        idx = event_register (event_pool, fd[0], poller_destroy_handler,
-                              &data, 1, 0);
-        if (idx < 0)
-                goto out;
-
-        /* Enter the destroy mode first, set this before reconfiguring to 0
-         * threads, to prevent further reconfigure to thread count > 0.
+    int ret = -1, threadcount = 0;
+    int fd[2] = {-1};
+    int idx = -1;
+    int flags = 0;
+    struct timespec sleep_till = {
+        0,
+    };
+    struct event_destroy_data data = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    ret = pipe(fd);
+    if (ret < 0)
+        goto out;
+
+    /* Make the read end of the pipe nonblocking */
+    flags = fcntl(fd[0], F_GETFL);
+    flags |= O_NONBLOCK;
+    ret = fcntl(fd[0], F_SETFL, flags);
+    if (ret < 0)
+        goto out;
+
+    /* Make the write end of the pipe nonblocking */
+    flags = fcntl(fd[1], F_GETFL);
+    flags |= O_NONBLOCK;
+    ret = fcntl(fd[1], F_SETFL, flags);
+    if (ret < 0)
+        goto out;
+
+    data.pool = event_pool;
+    data.readfd = fd[1];
+
+    /* From the main thread register an event on the pipe fd[0],
+     */
+    idx = gf_event_register(event_pool, fd[0], poller_destroy_handler, &data, 1,
+                            0, 0);
+    if (idx < 0)
+        goto out;
+
+    /* Enter the destroy mode first, set this before reconfiguring to 0
+     * threads, to prevent further reconfigure to thread count > 0.
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        threadcount = event_pool->eventthreadcount;
+        event_pool->destroy = 1;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    ret = gf_event_reconfigure_threads(event_pool, 0);
+    if (ret < 0)
+        goto out;
+
+    /* Write something onto the write end of the pipe(fd[1]) so that
+     * poll wakes up and calls the handler, poller_destroy_handler()
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        /* Write to pipe(fd[1]) and then wait for 1 second or until
+         * a poller thread that is dying, broadcasts. Make sure we
+         * do not loop forever by limiting to 10 retries
          */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                threadcount = event_pool->eventthreadcount;
-                event_pool->destroy = 1;
+        int retry = 0;
+
+        while (event_pool->activethreadcount > 0 &&
+               (retry++ < (threadcount + 10))) {
+            if (sys_write(fd[1], "dummy", 6) == -1) {
+                break;
+            }
+            timespec_now_realtime(&sleep_till);
+            sleep_till.tv_sec += 1;
+            ret = pthread_cond_timedwait(&event_pool->cond, &event_pool->mutex,
+                                         &sleep_till);
+            if (ret) {
+                gf_msg_debug("event", 0,
+                             "thread cond-timedwait failed "
+                             "active-thread-count: %d, "
+                             "retry: %d",
+                             event_pool->activethreadcount, retry);
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        ret = event_reconfigure_threads (event_pool, 0);
-        if (ret < 0)
-                goto out;
+    ret = gf_event_unregister(event_pool, fd[0], idx);
 
-        /* Write something onto the write end of the pipe(fd[1]) so that
-         * poll wakes up and calls the handler, poller_destroy_handler()
-         */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                /* Write to pipe(fd[1]) and then wait for 1 second or until
-                 * a poller thread that is dying, broadcasts. Make sure we
-                 * do not loop forever by limiting to 10 retries
-                 */
-                int retry = 0;
-
-                while (event_pool->activethreadcount > 0
-                       && (retry++ < (threadcount + 10))) {
-                        if (sys_write (fd[1], "dummy", 6) == -1) {
-                                break;
-                        }
-                        sleep_till.tv_sec = time (NULL) + 1;
-                        ret = pthread_cond_timedwait (&event_pool->cond,
-                                                      &event_pool->mutex,
-                                                      &sleep_till);
-                }
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        ret = event_unregister (event_pool, fd[0], idx);
-
- out:
-        if (fd[0] != -1)
-                sys_close (fd[0]);
-        if (fd[1] != -1)
-                sys_close (fd[1]);
+out:
+    if (fd[0] != -1)
+        sys_close(fd[0]);
+    if (fd[1] != -1)
+        sys_close(fd[1]);
 
-        return ret;
+    return ret;
 }
 
 int
-event_handled (struct event_pool *event_pool, int fd, int idx, int gen)
+gf_event_handled(struct event_pool *event_pool, int fd, int idx, int gen)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (event_pool->ops->event_handled)
-                ret = event_pool->ops->event_handled (event_pool, fd, idx, gen);
+    if (event_pool->ops->event_handled)
+        ret = event_pool->ops->event_handled(event_pool, fd, idx, gen);
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/event.h b/libglusterfs/src/event.h
deleted file mode 100644
index c60b14ad04b..00000000000
--- a/libglusterfs/src/event.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _EVENT_H_
-#define _EVENT_H_
-
-#include <pthread.h>
-
-struct event_pool;
-struct event_ops;
-struct event_slot_poll;
-struct event_slot_epoll;
-struct event_data {
-	int idx;
-	int gen;
-} __attribute__ ((__packed__, __may_alias__));
-
-
-typedef int (*event_handler_t) (int fd, int idx, int gen, void *data,
-				int poll_in, int poll_out, int poll_err);
-
-#define EVENT_EPOLL_TABLES 1024
-#define EVENT_EPOLL_SLOTS 1024
-#define EVENT_MAX_THREADS  1024
-
-struct event_pool {
-	struct event_ops *ops;
-
-	int fd;
-	int breaker[2];
-
-	int count;
-	struct event_slot_poll  *reg;
-	struct event_slot_epoll *ereg[EVENT_EPOLL_TABLES];
-	int slots_used[EVENT_EPOLL_TABLES];
-
-	int used;
-	int changed;
-
-	pthread_mutex_t mutex;
-	pthread_cond_t cond;
-
-	void *evcache;
-	int evcache_size;
-
-        /* NOTE: Currently used only when event processing is done using
-         * epoll. */
-        int eventthreadcount; /* number of event threads to execute. */
-        pthread_t pollers[EVENT_MAX_THREADS]; /* poller thread_id store,
-                                                     * and live status */
-        int destroy;
-        int activethreadcount;
-
-        /*
-         * Number of threads created by auto-scaling, *in addition to* the
-         * configured number of threads.  This is only applicable on the
-         * server, where we try to keep the number of threads around the number
-         * of bricks.  In that case, the configured number is just "extra"
-         * threads to handle requests in excess of one per brick (including
-         * requests on the GlusterD connection).  For clients or GlusterD, this
-         * number will always be zero, so the "extra" is all we have.
-         *
-         * TBD: consider auto-scaling for clients as well
-         */
-        int auto_thread_count;
-
-};
-
-struct event_destroy_data {
-        int                readfd;
-        struct event_pool *pool;
-};
-
-struct event_ops {
-        struct event_pool * (*new) (int count, int eventthreadcount);
-
-        int (*event_register) (struct event_pool *event_pool, int fd,
-                               event_handler_t handler,
-                               void *data, int poll_in, int poll_out);
-
-        int (*event_select_on) (struct event_pool *event_pool, int fd, int idx,
-                                int poll_in, int poll_out);
-
-        int (*event_unregister) (struct event_pool *event_pool, int fd, int idx);
-
-        int (*event_unregister_close) (struct event_pool *event_pool, int fd,
-				       int idx);
-
-        int (*event_dispatch) (struct event_pool *event_pool);
-
-        int (*event_reconfigure_threads) (struct event_pool *event_pool,
-                                          int newcount);
-        int (*event_pool_destroy) (struct event_pool *event_pool);
-        int (*event_handled) (struct event_pool *event_pool, int fd, int idx,
-                              int gen);
-};
-
-struct event_pool *event_pool_new (int count, int eventthreadcount);
-int event_select_on (struct event_pool *event_pool, int fd, int idx,
-		     int poll_in, int poll_out);
-int event_register (struct event_pool *event_pool, int fd,
-		    event_handler_t handler,
-		    void *data, int poll_in, int poll_out);
-int event_unregister (struct event_pool *event_pool, int fd, int idx);
-int event_unregister_close (struct event_pool *event_pool, int fd, int idx);
-int event_dispatch (struct event_pool *event_pool);
-int event_reconfigure_threads (struct event_pool *event_pool, int value);
-int event_pool_destroy (struct event_pool *event_pool);
-int event_dispatch_destroy (struct event_pool *event_pool);
-int event_handled (struct event_pool *event_pool, int fd, int idx, int gen);
-
-#endif /* _EVENT_H_ */
diff --git a/libglusterfs/src/events.c b/libglusterfs/src/events.c
index 7c20c32ad6e..33157549897 100644
--- a/libglusterfs/src/events.c
+++ b/libglusterfs/src/events.c
@@ -19,117 +19,118 @@
 #include <netinet/in.h>
 #include <netdb.h>
 
-#include "syscall.h"
-#include "mem-pool.h"
-#include "glusterfs.h"
-#include "globals.h"
-#include "events.h"
-
+#include "glusterfs/syscall.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/globals.h"
+#include "glusterfs/events.h"
 
 #define EVENT_HOST "127.0.0.1"
 #define EVENT_PORT 24009
 
-
 int
-_gf_event (eventtypes_t event, const char *fmt, ...)
+_gf_event(eventtypes_t event, const char *fmt, ...)
 {
-        int                ret                   = 0;
-        int                sock                  = -1;
-        char              *eventstr              = NULL;
-        struct             sockaddr_in server;
-        va_list            arguments;
-        char              *msg                   = NULL;
-        glusterfs_ctx_t   *ctx                   = NULL;
-        char              *host                  = NULL;
-        struct addrinfo    hints;
-        struct addrinfo   *result                = NULL;
-
-        /* Global context */
-        ctx = THIS->ctx;
-
-        if (event < 0 || event >= EVENT_LAST) {
-                ret = EVENT_ERROR_INVALID_INPUTS;
-                goto out;
-        }
-
-        /* Initialize UDP socket */
-        sock = socket (AF_INET, SOCK_DGRAM, 0);
-        if (sock < 0) {
-                ret = EVENT_ERROR_SOCKET;
-                goto out;
-        }
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = AF_UNSPEC;
-
-        /* Get Host name to send message */
-        if (ctx && ctx->cmd_args.volfile_server) {
-                /* If it is client code then volfile_server is set
-                   use that information to push the events. */
-                if ((getaddrinfo (ctx->cmd_args.volfile_server,
-                                  NULL, &hints, &result)) != 0) {
-                        ret = EVENT_ERROR_RESOLVE;
-                        goto out;
-                }
-
-                if (get_ip_from_addrinfo (result, &host) == NULL) {
-                        ret = EVENT_ERROR_RESOLVE;
-                        goto out;
-                }
-        } else {
-                /* Localhost, Use the defined IP for localhost */
-                host = gf_strdup (EVENT_HOST);
+    int ret = 0;
+    int sock = -1;
+    char *eventstr = NULL;
+    va_list arguments;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char *host = NULL;
+    struct addrinfo hints;
+    struct addrinfo *result = NULL;
+    struct addrinfo *iter_result_ptr = NULL;
+    xlator_t *this = THIS;
+    char *volfile_server_transport = NULL;
+
+    /* Global context */
+    ctx = this->ctx;
+
+    if (event < 0 || event >= EVENT_LAST) {
+        ret = EVENT_ERROR_INVALID_INPUTS;
+        goto out;
+    }
+
+    if (ctx) {
+        volfile_server_transport = ctx->cmd_args.volfile_server_transport;
+    }
+    if (!volfile_server_transport) {
+        volfile_server_transport = "tcp";
+    }
+
+    /* host = NULL returns localhost */
+    if (ctx && ctx->cmd_args.volfile_server &&
+        (strcmp(volfile_server_transport, "unix"))) {
+        /* If it is client code then volfile_server is set
+           use that information to push the events. */
+        host = ctx->cmd_args.volfile_server;
+    }
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_DGRAM;
+    hints.ai_flags = AI_ADDRCONFIG;
+
+    if ((getaddrinfo(host, TOSTRING(EVENT_PORT), &hints, &result)) != 0) {
+        ret = EVENT_ERROR_RESOLVE;
+        goto out;
+    }
+
+    // iterate over the result and break when socket creation is success.
+    for (iter_result_ptr = result; iter_result_ptr != NULL;
+         iter_result_ptr = iter_result_ptr->ai_next) {
+        sock = socket(iter_result_ptr->ai_family, iter_result_ptr->ai_socktype,
+                      iter_result_ptr->ai_protocol);
+        if (sock != -1) {
+            break;
         }
-
-        /* Socket Configurations */
-        server.sin_family = AF_INET;
-        server.sin_port = htons (EVENT_PORT);
-        server.sin_addr.s_addr = inet_addr (host);
-        memset (&server.sin_zero, '\0', sizeof (server.sin_zero));
-
-        va_start (arguments, fmt);
-        ret = gf_vasprintf (&msg, fmt, arguments);
-        va_end (arguments);
-
-        if (ret < 0) {
-                ret = EVENT_ERROR_INVALID_INPUTS;
-                goto out;
-        }
-
-        ret = gf_asprintf (&eventstr, "%u %d %s",
-                            (unsigned)time(NULL), event, msg);
-
-        if (ret <= 0) {
-                ret = EVENT_ERROR_MSG_FORMAT;
-                goto out;
-        }
-
-        /* Send Message */
-        if (sendto (sock, eventstr, strlen (eventstr),
-                    0, (struct sockaddr *)&server, sizeof (server)) <= 0) {
-                ret = EVENT_ERROR_SEND;
-        }
-
-        ret = EVENT_SEND_OK;
-
- out:
-        if (sock >= 0) {
-                sys_close (sock);
-        }
-
-        /* Allocated by gf_vasprintf */
-        if (msg)
-                GF_FREE (msg);
-
-        /* Allocated by gf_asprintf */
-        if (eventstr)
-                GF_FREE (eventstr);
-
-        if (host)
-                GF_FREE (host);
-
-        if (result)
-                freeaddrinfo (result);
-
-        return ret;
+    }
+    /*
+     * If none of the addrinfo structures lead to a successful socket
+     * creation, socket creation has failed.
+     */
+    if (sock < 0) {
+        ret = EVENT_ERROR_SOCKET;
+        goto out;
+    }
+
+    va_start(arguments, fmt);
+    ret = gf_vasprintf(&msg, fmt, arguments);
+    va_end(arguments);
+
+    if (ret < 0) {
+        ret = EVENT_ERROR_INVALID_INPUTS;
+        goto out;
+    }
+
+    ret = gf_asprintf(&eventstr, "%u %d %s", (unsigned)gf_time(), event, msg);
+    GF_FREE(msg);
+    if (ret <= 0) {
+        ret = EVENT_ERROR_MSG_FORMAT;
+        goto out;
+    }
+
+    /* Send Message */
+    if (sendto(sock, eventstr, strlen(eventstr), 0, result->ai_addr,
+               result->ai_addrlen) <= 0) {
+        ret = EVENT_ERROR_SEND;
+        goto out;
+    }
+
+    ret = EVENT_SEND_OK;
+
+out:
+    if (sock >= 0) {
+        sys_close(sock);
+    }
+
+    /* Allocated by gf_asprintf */
+    if (eventstr)
+        GF_FREE(eventstr);
+
+    if (result)
+        freeaddrinfo(result);
+
+    return ret;
 }
diff --git a/libglusterfs/src/events.h b/libglusterfs/src/events.h
deleted file mode 100644
index 19988b0e3d2..00000000000
--- a/libglusterfs/src/events.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __EVENTS_H__
-#define __EVENTS_H__
-
-#include "eventtypes.h"
-
-#ifdef USE_EVENTS
-int
-_gf_event (eventtypes_t event, const char *fmt, ...)
-           __attribute__ ((__format__ (__printf__, 2, 3)));
-#else
-__attribute__ ((__format__ (__printf__, 2, 3)))
-static inline int
-_gf_event (eventtypes_t event, const char *fmt, ...)
-{
-        return 0;
-}
-#endif /* USE_EVENTS */
-
-#define gf_event(event, fmt...)                         \
-        do {                                            \
-                FMT_WARN(fmt);                          \
-                _gf_event (event, ##fmt);               \
-        } while (0)
-
-#endif /* __EVENTS_H__ */
diff --git a/libglusterfs/src/fd-lk.c b/libglusterfs/src/fd-lk.c
index 358cf3b616a..c2d34f81c9c 100644
--- a/libglusterfs/src/fd-lk.c
+++ b/libglusterfs/src/fd-lk.c
@@ -8,480 +8,426 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "fd-lk.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/fd-lk.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 int32_t
-_fd_lk_delete_lock (fd_lk_ctx_node_t *lock)
+_fd_lk_delete_lock(fd_lk_ctx_node_t *lock)
 {
-        int32_t    ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lock, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lock, out);
 
-        list_del_init (&lock->next);
+    list_del_init(&lock->next);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-_fd_lk_destroy_lock (fd_lk_ctx_node_t *lock)
+_fd_lk_destroy_lock(fd_lk_ctx_node_t *lock)
 {
-        int32_t    ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lock, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lock, out);
 
-        GF_FREE (lock);
+    GF_FREE(lock);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-_fd_lk_destroy_lock_list (fd_lk_ctx_t *lk_ctx)
+_fd_lk_destroy_lock_list(fd_lk_ctx_t *lk_ctx)
 {
-        int               ret     = -1;
-        fd_lk_ctx_node_t *lk      = NULL;
-        fd_lk_ctx_node_t *tmp     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, out);
-
-        list_for_each_entry_safe (lk, tmp, &lk_ctx->lk_list, next) {
-                _fd_lk_delete_lock (lk);
-                _fd_lk_destroy_lock (lk);
-        }
-        ret = 0;
+    int ret = -1;
+    fd_lk_ctx_node_t *lk = NULL;
+    fd_lk_ctx_node_t *tmp = NULL;
+
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, out);
+
+    list_for_each_entry_safe(lk, tmp, &lk_ctx->lk_list, next)
+    {
+        _fd_lk_delete_lock(lk);
+        _fd_lk_destroy_lock(lk);
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_lk_ctx_unref (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_unref(fd_lk_ctx_t *lk_ctx)
 {
-        int ref = -1;
+    int ref = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, err);
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, err);
 
-        LOCK (&lk_ctx->lock);
-        {
-                ref = --lk_ctx->ref;
-                if (ref < 0)
-                        GF_ASSERT (!ref);
-                if (ref == 0)
-                        _fd_lk_destroy_lock_list (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
+    ref = GF_ATOMIC_DEC(lk_ctx->ref);
+    if (ref < 0)
+        GF_ASSERT(!ref);
+    if (ref == 0)
+        _fd_lk_destroy_lock_list(lk_ctx);
 
-        if (ref == 0) {
-                LOCK_DESTROY (&lk_ctx->lock);
-                GF_FREE (lk_ctx);
-        }
+    if (ref == 0) {
+        LOCK_DESTROY(&lk_ctx->lock);
+        GF_FREE(lk_ctx);
+    }
 
-        return 0;
+    return 0;
 err:
-        return -1;
-}
-
-fd_lk_ctx_t *
-_fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
-{
-        if (!lk_ctx) {
-                gf_msg_callingfn ("fd-lk", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        ++lk_ctx->ref;
-
-        return lk_ctx;
-}
-
-fd_lk_ctx_t *
-fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
-{
-        fd_lk_ctx_t *new_lk_ctx = NULL;
-
-        if (!lk_ctx) {
-                gf_msg_callingfn ("fd-lk", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        LOCK (&lk_ctx->lock);
-        {
-                new_lk_ctx = _fd_lk_ctx_ref (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
-
-        return new_lk_ctx;
+    return -1;
 }
 
 fd_lk_ctx_t *
-fd_lk_ctx_try_ref (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_ref(fd_lk_ctx_t *lk_ctx)
 {
-        int         ret         = -1;
-        fd_lk_ctx_t *new_lk_ctx = NULL;
-
-        if (!lk_ctx) {
-                goto out;
-        }
-
-        ret = TRY_LOCK (&lk_ctx->lock);
-        if (ret)
-                goto out;
+    if (!lk_ctx) {
+        gf_msg_callingfn("fd-lk", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        new_lk_ctx = _fd_lk_ctx_ref (lk_ctx);
-        UNLOCK (&lk_ctx->lock);
+    GF_ATOMIC_INC(lk_ctx->ref);
 
-out:
-        return new_lk_ctx;
+    return lk_ctx;
 }
 
 fd_lk_ctx_t *
-fd_lk_ctx_create ()
+fd_lk_ctx_create()
 {
-        fd_lk_ctx_t *fd_lk_ctx = NULL;
+    fd_lk_ctx_t *fd_lk_ctx = NULL;
 
-        fd_lk_ctx = GF_CALLOC (1, sizeof (fd_lk_ctx_t),
-                               gf_common_mt_fd_lk_ctx_t);
-        if (!fd_lk_ctx)
-                goto out;
+    fd_lk_ctx = GF_CALLOC(1, sizeof(fd_lk_ctx_t), gf_common_mt_fd_lk_ctx_t);
+    if (!fd_lk_ctx)
+        goto out;
 
-        INIT_LIST_HEAD (&fd_lk_ctx->lk_list);
+    INIT_LIST_HEAD(&fd_lk_ctx->lk_list);
 
-        LOCK_INIT (&fd_lk_ctx->lock);
+    LOCK_INIT(&fd_lk_ctx->lock);
 
-        fd_lk_ctx = fd_lk_ctx_ref (fd_lk_ctx);
+    fd_lk_ctx = fd_lk_ctx_ref(fd_lk_ctx);
 out:
-        return fd_lk_ctx;
+    return fd_lk_ctx;
 }
 
 int
-_fd_lk_insert_lock (fd_lk_ctx_t *lk_ctx,
-                    fd_lk_ctx_node_t *lock)
+_fd_lk_insert_lock(fd_lk_ctx_t *lk_ctx, fd_lk_ctx_node_t *lock)
 {
-        list_add_tail (&lock->next, &lk_ctx->lk_list);
-        return 0;
+    list_add_tail(&lock->next, &lk_ctx->lk_list);
+    return 0;
 }
 
 static off_t
-_fd_lk_get_lock_len (off_t start, off_t end)
+_fd_lk_get_lock_len(off_t start, off_t end)
 {
-        if (end == LLONG_MAX)
-                return 0;
-        else
-                return (end - start + 1);
+    if (end == LLONG_MAX)
+        return 0;
+    else
+        return (end - start + 1);
 }
 
 fd_lk_ctx_node_t *
-fd_lk_ctx_node_new (int32_t cmd, struct gf_flock *flock)
+fd_lk_ctx_node_new(int32_t cmd, struct gf_flock *flock)
 {
-        fd_lk_ctx_node_t  *new_lock  = NULL;
+    fd_lk_ctx_node_t *new_lock = NULL;
 
-        /* TODO: get from mem-pool */
-        new_lock = GF_CALLOC (1, sizeof (fd_lk_ctx_node_t),
-                              gf_common_mt_fd_lk_ctx_node_t);
-        if (!new_lock)
-                goto out;
+    /* TODO: get from mem-pool */
+    new_lock = GF_CALLOC(1, sizeof(fd_lk_ctx_node_t),
+                         gf_common_mt_fd_lk_ctx_node_t);
+    if (!new_lock)
+        goto out;
 
-        new_lock->cmd = cmd;
+    new_lock->cmd = cmd;
 
-        if (flock) {
-                new_lock->fl_type  = flock->l_type;
-                new_lock->fl_start = flock->l_start;
+    if (flock) {
+        new_lock->fl_type = flock->l_type;
+        new_lock->fl_start = flock->l_start;
 
-                if (flock->l_len == 0)
-                        new_lock->fl_end = LLONG_MAX;
-                else
-                        new_lock->fl_end = flock->l_start + flock->l_len - 1;
+        if (flock->l_len == 0)
+            new_lock->fl_end = LLONG_MAX;
+        else
+            new_lock->fl_end = flock->l_start + flock->l_len - 1;
 
-                memcpy (&new_lock->user_flock, flock,
-                        sizeof (struct gf_flock));
-        }
+        memcpy(&new_lock->user_flock, flock, sizeof(struct gf_flock));
+    }
 
-        INIT_LIST_HEAD (&new_lock->next);
+    INIT_LIST_HEAD(&new_lock->next);
 out:
-        return new_lock;
+    return new_lock;
 }
 
 int32_t
-_fd_lk_delete_unlck_locks (fd_lk_ctx_t *lk_ctx)
+_fd_lk_delete_unlck_locks(fd_lk_ctx_t *lk_ctx)
 {
-        int32_t            ret   = -1;
-        fd_lk_ctx_node_t  *tmp   = NULL;
-        fd_lk_ctx_node_t  *lk    = NULL;
+    int32_t ret = -1;
+    fd_lk_ctx_node_t *tmp = NULL;
+    fd_lk_ctx_node_t *lk = NULL;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, out);
 
-        list_for_each_entry_safe (lk, tmp, &lk_ctx->lk_list, next) {
-                if (lk->fl_type == F_UNLCK) {
-                        _fd_lk_delete_lock (lk);
-                        _fd_lk_destroy_lock (lk);
-                }
+    list_for_each_entry_safe(lk, tmp, &lk_ctx->lk_list, next)
+    {
+        if (lk->fl_type == F_UNLCK) {
+            _fd_lk_delete_lock(lk);
+            _fd_lk_destroy_lock(lk);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_lk_overlap (fd_lk_ctx_node_t *l1,
-               fd_lk_ctx_node_t *l2)
+fd_lk_overlap(fd_lk_ctx_node_t *l1, fd_lk_ctx_node_t *l2)
 {
-        if (l1->fl_end >= l2->fl_start &&
-            l2->fl_end >= l1->fl_start)
-                return 1;
+    if (l1->fl_end >= l2->fl_start && l2->fl_end >= l1->fl_start)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 fd_lk_ctx_node_t *
-_fd_lk_add_locks (fd_lk_ctx_node_t *l1,
-                  fd_lk_ctx_node_t *l2)
+_fd_lk_add_locks(fd_lk_ctx_node_t *l1, fd_lk_ctx_node_t *l2)
 {
-        fd_lk_ctx_node_t  *sum = NULL;
+    fd_lk_ctx_node_t *sum = NULL;
 
-        sum = fd_lk_ctx_node_new (0, NULL);
-        if (!sum)
-                goto out;
+    sum = fd_lk_ctx_node_new(0, NULL);
+    if (!sum)
+        goto out;
 
-        sum->fl_start = min (l1->fl_start, l2->fl_start);
-        sum->fl_end   = max (l1->fl_end, l2->fl_end);
+    sum->fl_start = min(l1->fl_start, l2->fl_start);
+    sum->fl_end = max(l1->fl_end, l2->fl_end);
 
-        sum->user_flock.l_start = sum->fl_start;
-        sum->user_flock.l_len   = _fd_lk_get_lock_len (sum->fl_start,
-                                                       sum->fl_end);
+    sum->user_flock.l_start = sum->fl_start;
+    sum->user_flock.l_len = _fd_lk_get_lock_len(sum->fl_start, sum->fl_end);
 out:
-        return sum;
+    return sum;
 }
 
 /* Subtract two locks */
 struct _values {
-        fd_lk_ctx_node_t *locks[3];
+    fd_lk_ctx_node_t *locks[3];
 };
 
 int32_t
-_fd_lk_sub_locks (struct _values *v,
-                  fd_lk_ctx_node_t *big,
-                  fd_lk_ctx_node_t *small)
+_fd_lk_sub_locks(struct _values *v, fd_lk_ctx_node_t *big,
+                 fd_lk_ctx_node_t *small)
 {
-        int32_t  ret  = -1;
-
-        if ((big->fl_start == small->fl_start) &&
-            (big->fl_end   == small->fl_end)) {
-                /* both edges coincide with big */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-
-                v->locks[0]->fl_type            = small->fl_type;
-                v->locks[0]->user_flock.l_type = small->fl_type;
-        } else if ((small->fl_start > big->fl_start) &&
-                   (small->fl_end   < big->fl_end)) {
-                /* small lock is completely inside big lock,
-                   break it down into 3 different locks. */
-                v->locks[0] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                v->locks[2] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[2])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[0]->fl_end = small->fl_start - 1;
-                v->locks[0]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[0]->fl_start,
-                                             v->locks[0]->fl_end);
-
-                memcpy (v->locks[1], small, sizeof (fd_lk_ctx_node_t));
-
-                memcpy (v->locks[2], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[2]->fl_start = small->fl_end + 1;
-                v->locks[2]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[2]->fl_start,
-                                             v->locks[2]->fl_end);
-        } else if (small->fl_start == big->fl_start) {
-                /* One of the ends co-incide, break the
-                   locks into two separate parts */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                memcpy (v->locks[0], small, sizeof (fd_lk_ctx_node_t));
-
-                memcpy (v->locks[1], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[1]->fl_start = small->fl_end + 1;
-                v->locks[1]->user_flock.l_start = small->fl_end + 1;
-        } else if (small->fl_end == big->fl_end) {
-                /* One of the ends co-incide, break the
-                   locks into two separate parts */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[0]->fl_end = small->fl_start - 1;
-                v->locks[0]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[0]->fl_start,
-                                             v->locks[0]->fl_end);
-
-                memcpy (v->locks[1], small, sizeof (fd_lk_ctx_node_t));
-        } else {
-                /* We should never come to this case */
-                GF_ASSERT (!"Invalid case");
-        }
-        ret = 0;
+    int32_t ret = -1;
+
+    if ((big->fl_start == small->fl_start) && (big->fl_end == small->fl_end)) {
+        /* both edges coincide with big */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+
+        v->locks[0]->fl_type = small->fl_type;
+        v->locks[0]->user_flock.l_type = small->fl_type;
+    } else if ((small->fl_start > big->fl_start) &&
+               (small->fl_end < big->fl_end)) {
+        /* small lock is completely inside big lock,
+           break it down into 3 different locks. */
+        v->locks[0] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        v->locks[2] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[2])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[0]->fl_end = small->fl_start - 1;
+        v->locks[0]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[0]->fl_start, v->locks[0]->fl_end);
+
+        memcpy(v->locks[1], small, sizeof(fd_lk_ctx_node_t));
+
+        memcpy(v->locks[2], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[2]->fl_start = small->fl_end + 1;
+        v->locks[2]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[2]->fl_start, v->locks[2]->fl_end);
+    } else if (small->fl_start == big->fl_start) {
+        /* One of the ends co-incide, break the
+           locks into two separate parts */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        memcpy(v->locks[0], small, sizeof(fd_lk_ctx_node_t));
+
+        memcpy(v->locks[1], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[1]->fl_start = small->fl_end + 1;
+        v->locks[1]->user_flock.l_start = small->fl_end + 1;
+    } else if (small->fl_end == big->fl_end) {
+        /* One of the ends co-incide, break the
+           locks into two separate parts */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[0]->fl_end = small->fl_start - 1;
+        v->locks[0]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[0]->fl_start, v->locks[0]->fl_end);
+
+        memcpy(v->locks[1], small, sizeof(fd_lk_ctx_node_t));
+    } else {
+        /* We should never come to this case */
+        GF_ASSERT(!"Invalid case");
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-_fd_lk_insert_and_merge (fd_lk_ctx_t *lk_ctx,
-                         fd_lk_ctx_node_t *lock)
+_fd_lk_insert_and_merge(fd_lk_ctx_t *lk_ctx, fd_lk_ctx_node_t *lock)
 {
-        int32_t               ret     = -1;
-        int32_t               i       = 0;
-        fd_lk_ctx_node_t     *entry   = NULL;
-        fd_lk_ctx_node_t     *t       = NULL;
-        fd_lk_ctx_node_t     *sum     = NULL;
-        struct _values        v       = {.locks = {0, 0, 0 }};
-
-        list_for_each_entry_safe (entry, t, &lk_ctx->lk_list, next) {
-                if (!fd_lk_overlap (entry, lock))
-                        continue;
-
-                if (entry->fl_type == lock->fl_type) {
-                        sum = _fd_lk_add_locks (entry, lock);
-                        if (!sum)
-                                return;
-                        sum->fl_type = entry->fl_type;
-                        sum->user_flock.l_type = entry->fl_type;
-                        _fd_lk_delete_lock (entry);
-                        _fd_lk_destroy_lock (entry);
-                        _fd_lk_destroy_lock (lock);
-                        _fd_lk_insert_and_merge (lk_ctx, sum);
-                        return;
-                } else {
-                        sum = _fd_lk_add_locks (entry, lock);
-                        sum->fl_type = lock->fl_type;
-                        sum->user_flock.l_type = lock->fl_type;
-                        ret = _fd_lk_sub_locks (&v, sum, lock);
-                        if (ret)
-                                return;
-                        _fd_lk_delete_lock (entry);
-                        _fd_lk_destroy_lock (entry);
-
-                        _fd_lk_delete_lock (lock);
-                        _fd_lk_destroy_lock (lock);
-
-                        _fd_lk_destroy_lock (sum);
-
-                        for (i = 0; i < 3; i++) {
-                                if (!v.locks[i])
-                                        continue;
-
-                                INIT_LIST_HEAD (&v.locks[i]->next);
-                                _fd_lk_insert_and_merge (lk_ctx, v.locks[i]);
-                        }
-                        _fd_lk_delete_unlck_locks (lk_ctx);
-                        return;
-                }
-        }
-
-        /* no conflicts, so just insert */
-        if (lock->fl_type != F_UNLCK) {
-                _fd_lk_insert_lock (lk_ctx, lock);
+    int32_t ret = -1;
+    int32_t i = 0;
+    fd_lk_ctx_node_t *entry = NULL;
+    fd_lk_ctx_node_t *t = NULL;
+    fd_lk_ctx_node_t *sum = NULL;
+    struct _values v = {.locks = {0, 0, 0}};
+
+    list_for_each_entry_safe(entry, t, &lk_ctx->lk_list, next)
+    {
+        if (!fd_lk_overlap(entry, lock))
+            continue;
+
+        if (entry->fl_type == lock->fl_type) {
+            sum = _fd_lk_add_locks(entry, lock);
+            if (!sum)
+                return;
+            sum->fl_type = entry->fl_type;
+            sum->user_flock.l_type = entry->fl_type;
+            _fd_lk_delete_lock(entry);
+            _fd_lk_destroy_lock(entry);
+            _fd_lk_destroy_lock(lock);
+            _fd_lk_insert_and_merge(lk_ctx, sum);
+            return;
         } else {
-                _fd_lk_destroy_lock (lock);
+            sum = _fd_lk_add_locks(entry, lock);
+            sum->fl_type = lock->fl_type;
+            sum->user_flock.l_type = lock->fl_type;
+            ret = _fd_lk_sub_locks(&v, sum, lock);
+            if (ret)
+                return;
+            _fd_lk_delete_lock(entry);
+            _fd_lk_destroy_lock(entry);
+
+            _fd_lk_delete_lock(lock);
+            _fd_lk_destroy_lock(lock);
+
+            _fd_lk_destroy_lock(sum);
+
+            for (i = 0; i < 3; i++) {
+                if (!v.locks[i])
+                    continue;
+
+                INIT_LIST_HEAD(&v.locks[i]->next);
+                _fd_lk_insert_and_merge(lk_ctx, v.locks[i]);
+            }
+            _fd_lk_delete_unlck_locks(lk_ctx);
+            return;
         }
+    }
+
+    /* no conflicts, so just insert */
+    if (lock->fl_type != F_UNLCK) {
+        _fd_lk_insert_lock(lk_ctx, lock);
+    } else {
+        _fd_lk_destroy_lock(lock);
+    }
 }
 
 static void
-print_lock_list (fd_lk_ctx_t *lk_ctx)
+print_lock_list(fd_lk_ctx_t *lk_ctx)
 {
-        fd_lk_ctx_node_t    *lk     = NULL;
-
-        gf_msg_debug ("fd-lk", 0, "lock list:");
-
-        list_for_each_entry (lk, &lk_ctx->lk_list, next)
-                gf_msg_debug ("fd-lk", 0, "owner = %s, cmd = %s fl_type = %s,"
-                              " fs_start = %"PRId64", fs_end = %"PRId64", "
-                              "user_flock: l_type = %s, l_start = %"PRId64", "
-                              "l_len = %"PRId64", ",
-                              lkowner_utoa (&lk->user_flock.l_owner),
-                              get_lk_cmd (lk->cmd), get_lk_type (lk->fl_type),
-                              lk->fl_start, lk->fl_end,
-                              get_lk_type (lk->user_flock.l_type),
-                              lk->user_flock.l_start, lk->user_flock.l_len);
+    fd_lk_ctx_node_t *lk = NULL;
+
+    gf_msg_debug("fd-lk", 0, "lock list:");
+
+    list_for_each_entry(lk, &lk_ctx->lk_list, next)
+        gf_msg_debug("fd-lk", 0,
+                     "owner = %s, cmd = %s fl_type = %s,"
+                     " fs_start = %" PRId64 ", fs_end = %" PRId64
+                     ", "
+                     "user_flock: l_type = %s, l_start = %" PRId64
+                     ", "
+                     "l_len = %" PRId64 ", ",
+                     lkowner_utoa(&lk->user_flock.l_owner), get_lk_cmd(lk->cmd),
+                     get_lk_type(lk->fl_type), lk->fl_start, lk->fl_end,
+                     get_lk_type(lk->user_flock.l_type), lk->user_flock.l_start,
+                     lk->user_flock.l_len);
 }
 
 int
-fd_lk_insert_and_merge (fd_t *fd, int32_t cmd,
-                        struct gf_flock *flock)
+fd_lk_insert_and_merge(fd_t *fd, int32_t cmd, struct gf_flock *flock)
 {
-        int32_t              ret      = -1;
-        fd_lk_ctx_t         *lk_ctx   = NULL;
-        fd_lk_ctx_node_t    *lk     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("fd-lk", fd, out);
-        GF_VALIDATE_OR_GOTO ("fd-lk", flock, out);
-
-        lk_ctx = fd_lk_ctx_ref (fd->lk_ctx);
-        lk     = fd_lk_ctx_node_new (cmd, flock);
-
-        gf_msg_debug ("fd-lk", 0, "new lock request: owner = %s, fl_type = %s"
-                      ", fs_start = %"PRId64", fs_end = %"PRId64", user_flock:"
-                      " l_type = %s, l_start = %"PRId64", l_len = %"PRId64,
-                      lkowner_utoa (&flock->l_owner),
-                      get_lk_type (lk->fl_type), lk->fl_start, lk->fl_end,
-                      get_lk_type (lk->user_flock.l_type),
-                      lk->user_flock.l_start, lk->user_flock.l_len);
-
-        LOCK (&lk_ctx->lock);
-        {
-                _fd_lk_insert_and_merge (lk_ctx, lk);
-                print_lock_list (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
-
-        fd_lk_ctx_unref (lk_ctx);
-
-        ret = 0;
+    int32_t ret = -1;
+    fd_lk_ctx_t *lk_ctx = NULL;
+    fd_lk_ctx_node_t *lk = NULL;
+
+    GF_VALIDATE_OR_GOTO("fd-lk", fd, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", flock, out);
+
+    lk_ctx = fd_lk_ctx_ref(fd->lk_ctx);
+    lk = fd_lk_ctx_node_new(cmd, flock);
+
+    gf_msg_debug("fd-lk", 0,
+                 "new lock request: owner = %s, fl_type = %s"
+                 ", fs_start = %" PRId64 ", fs_end = %" PRId64
+                 ", user_flock:"
+                 " l_type = %s, l_start = %" PRId64 ", l_len = %" PRId64,
+                 lkowner_utoa(&flock->l_owner), get_lk_type(lk->fl_type),
+                 lk->fl_start, lk->fl_end, get_lk_type(lk->user_flock.l_type),
+                 lk->user_flock.l_start, lk->user_flock.l_len);
+
+    LOCK(&lk_ctx->lock);
+    {
+        _fd_lk_insert_and_merge(lk_ctx, lk);
+        print_lock_list(lk_ctx);
+    }
+    UNLOCK(&lk_ctx->lock);
+
+    fd_lk_ctx_unref(lk_ctx);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-fd_lk_ctx_empty (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_empty(fd_lk_ctx_t *lk_ctx)
 {
-	gf_boolean_t verdict = _gf_true;
+    gf_boolean_t verdict = _gf_true;
 
-	if (!lk_ctx)
-		return _gf_true;
+    if (!lk_ctx)
+        return _gf_true;
 
-	LOCK (&lk_ctx->lock);
-	{
-		verdict = list_empty (&lk_ctx->lk_list);
-	}
-	UNLOCK (&lk_ctx->lock);
+    LOCK(&lk_ctx->lock);
+    {
+        verdict = list_empty(&lk_ctx->lk_list);
+    }
+    UNLOCK(&lk_ctx->lock);
 
-	return verdict;
+    return verdict;
 }
diff --git a/libglusterfs/src/fd-lk.h b/libglusterfs/src/fd-lk.h
deleted file mode 100644
index 51f62991681..00000000000
--- a/libglusterfs/src/fd-lk.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _FD_LK_H
-#define _FD_LK_H
-
-#include "fd.h"
-#include "locking.h"
-#include "list.h"
-#include "logging.h"
-#include "mem-pool.h"
-#include "mem-types.h"
-#include "glusterfs.h"
-#include "common-utils.h"
-
-#define get_lk_type(type)                                               \
-        type == F_UNLCK ? "F_UNLCK" : (type == F_RDLCK ? "F_RDLCK" : "F_WRLCK")
-
-#define get_lk_cmd(cmd)                                                 \
-        cmd == F_SETLKW ? "F_SETLKW" : (cmd == F_SETLK ? "F_SETLK" : "F_GETLK")
-
-struct _fd;
-
-struct fd_lk_ctx {
-        struct list_head lk_list;
-        int   ref;
-        gf_lock_t lock;
-};
-typedef struct fd_lk_ctx fd_lk_ctx_t;
-
-struct fd_lk_ctx_node {
-        int32_t            cmd;
-        struct gf_flock    user_flock;
-        off_t              fl_start;
-        off_t              fl_end;
-        short              fl_type;
-        struct list_head   next;
-};
-typedef struct fd_lk_ctx_node fd_lk_ctx_node_t;
-
-fd_lk_ctx_t *
-_fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx);
-
-fd_lk_ctx_t *
-fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx);
-
-fd_lk_ctx_t *
-fd_lk_ctx_try_ref (fd_lk_ctx_t *lk_ctx);
-
-fd_lk_ctx_t *
-fd_lk_ctx_create (void);
-
-int
-fd_lk_insert_and_merge (struct _fd *lk_ctx, int32_t cmd,
-                        struct gf_flock *flock);
-
-int
-fd_lk_ctx_unref (fd_lk_ctx_t *lk_ctx);
-
-gf_boolean_t
-fd_lk_ctx_empty (fd_lk_ctx_t *lk_ctx);
-
-#endif /* _FD_LK_H */
diff --git a/libglusterfs/src/fd.c b/libglusterfs/src/fd.c
index a824db7c7a5..62606e91164 100644
--- a/libglusterfs/src/fd.c
+++ b/libglusterfs/src/fd.c
@@ -8,1250 +8,1196 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "fd.h"
-#include "glusterfs.h"
-#include "inode.h"
-#include "dict.h"
-#include "statedump.h"
-#include "libglusterfs-messages.h"
-
+#include "glusterfs/fd.h"
+#include <errno.h>     // for EINVAL, errno, ENOMEM
+#include <inttypes.h>  // for PRIu64
+#include <stdint.h>    // for UINT32_MAX
+#include <string.h>    // for NULL, memcpy, memset, size_t
+#include "glusterfs/statedump.h"
 
 static int
-gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr);
-
+gf_fd_fdtable_expand(fdtable_t *fdtable, uint32_t nr);
 
 fd_t *
-__fd_ref (fd_t *fd);
+__fd_ref(fd_t *fd);
 
 static int
-gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
-                        uint32_t endcount)
+gf_fd_chain_fd_entries(fdentry_t *entries, uint32_t startidx, uint32_t endcount)
 {
-        uint32_t        i = 0;
+    uint32_t i = 0;
 
-        if (!entries) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!entries");
-                return -1;
-        }
+    if (!entries) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!entries");
+        return -1;
+    }
 
-        /* Chain only till the second to last entry because we want to
-         * ensure that the last entry has GF_FDTABLE_END.
-         */
-        for (i = startidx; i < (endcount - 1); i++)
-                entries[i].next_free = i + 1;
+    /* Chain only till the second to last entry because we want to
+     * ensure that the last entry has GF_FDTABLE_END.
+     */
+    for (i = startidx; i < (endcount - 1); i++)
+        entries[i].next_free = i + 1;
 
-        /* i has already been incremented up to the last entry. */
-        entries[i].next_free = GF_FDTABLE_END;
+    /* i has already been incremented up to the last entry. */
+    entries[i].next_free = GF_FDTABLE_END;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
+gf_fd_fdtable_expand(fdtable_t *fdtable, uint32_t nr)
 {
-        fdentry_t   *oldfds = NULL;
-        uint32_t     oldmax_fds = -1;
-        int          ret = -1;
-
-        if (fdtable == NULL || nr > UINT32_MAX) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                ret = EINVAL;
-                goto out;
-        }
-
-        nr /= (1024 / sizeof (fdentry_t));
-        nr = gf_roundup_next_power_of_two (nr + 1);
-        nr *= (1024 / sizeof (fdentry_t));
-
-        oldfds = fdtable->fdentries;
-        oldmax_fds = fdtable->max_fds;
-
-        fdtable->fdentries = GF_CALLOC (nr, sizeof (fdentry_t),
-                                        gf_common_mt_fdentry_t);
-        if (!fdtable->fdentries) {
-                ret = ENOMEM;
-                goto out;
-        }
-        fdtable->max_fds = nr;
-
-        if (oldfds) {
-                uint32_t cpy = oldmax_fds * sizeof (fdentry_t);
-                memcpy (fdtable->fdentries, oldfds, cpy);
-        }
-
-        gf_fd_chain_fd_entries (fdtable->fdentries, oldmax_fds,
-                                fdtable->max_fds);
-
-        /* Now that expansion is done, we must update the fd list
-         * head pointer so that the fd allocation functions can continue
-         * using the expanded table.
-         */
-        fdtable->first_free = oldmax_fds;
-        GF_FREE (oldfds);
-        ret = 0;
+    fdentry_t *oldfds = NULL;
+    uint32_t oldmax_fds = -1;
+    int ret = -1;
+
+    if (fdtable == NULL || nr > UINT32_MAX) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        ret = EINVAL;
+        goto out;
+    }
+
+    nr /= (1024 / sizeof(fdentry_t));
+    nr = gf_roundup_next_power_of_two(nr + 1);
+    nr *= (1024 / sizeof(fdentry_t));
+
+    oldfds = fdtable->fdentries;
+    oldmax_fds = fdtable->max_fds;
+
+    fdtable->fdentries = GF_CALLOC(nr, sizeof(fdentry_t),
+                                   gf_common_mt_fdentry_t);
+    if (!fdtable->fdentries) {
+        ret = ENOMEM;
+        goto out;
+    }
+    fdtable->max_fds = nr;
+
+    if (oldfds) {
+        uint32_t cpy = oldmax_fds * sizeof(fdentry_t);
+        memcpy(fdtable->fdentries, oldfds, cpy);
+    }
+
+    gf_fd_chain_fd_entries(fdtable->fdentries, oldmax_fds, fdtable->max_fds);
+
+    /* Now that expansion is done, we must update the fd list
+     * head pointer so that the fd allocation functions can continue
+     * using the expanded table.
+     */
+    fdtable->first_free = oldmax_fds;
+    GF_FREE(oldfds);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 fdtable_t *
-gf_fd_fdtable_alloc (void)
+gf_fd_fdtable_alloc(void)
 {
-        fdtable_t *fdtable = NULL;
+    fdtable_t *fdtable = NULL;
 
-        fdtable = GF_CALLOC (1, sizeof (*fdtable), gf_common_mt_fdtable_t);
-        if (!fdtable)
-                return NULL;
+    fdtable = GF_CALLOC(1, sizeof(*fdtable), gf_common_mt_fdtable_t);
+    if (!fdtable)
+        return NULL;
 
-        pthread_mutex_init (&fdtable->lock, NULL);
+    pthread_rwlock_init(&fdtable->lock, NULL);
 
-        pthread_mutex_lock (&fdtable->lock);
-        {
-                gf_fd_fdtable_expand (fdtable, 0);
-        }
-        pthread_mutex_unlock (&fdtable->lock);
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        gf_fd_fdtable_expand(fdtable, 0);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fdtable;
+    return fdtable;
 }
 
-
 static fdentry_t *
-__gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
+__gf_fd_fdtable_get_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t       *fdentries = NULL;
+    fdentry_t *fdentries = NULL;
 
-        if (count == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!count");
-                goto out;
-        }
+    if (count == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!count");
+        goto out;
+    }
 
-        fdentries = fdtable->fdentries;
-        fdtable->fdentries = GF_CALLOC (fdtable->max_fds, sizeof (fdentry_t),
-                                        gf_common_mt_fdentry_t);
-        gf_fd_chain_fd_entries (fdtable->fdentries, 0, fdtable->max_fds);
-        *count = fdtable->max_fds;
+    fdentries = fdtable->fdentries;
+    fdtable->fdentries = GF_CALLOC(fdtable->max_fds, sizeof(fdentry_t),
+                                   gf_common_mt_fdentry_t);
+    gf_fd_chain_fd_entries(fdtable->fdentries, 0, fdtable->max_fds);
+    *count = fdtable->max_fds;
 
 out:
-        return fdentries;
+    return fdentries;
 }
 
-
 fdentry_t *
-gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
+gf_fd_fdtable_get_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t       *entries = NULL;
+    fdentry_t *entries = NULL;
 
-        if (fdtable) {
-                pthread_mutex_lock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_get_all_fds (fdtable, count);
-                }
-                pthread_mutex_unlock (&fdtable->lock);
+    if (fdtable) {
+        pthread_rwlock_wrlock(&fdtable->lock);
+        {
+            entries = __gf_fd_fdtable_get_all_fds(fdtable, count);
         }
+        pthread_rwlock_unlock(&fdtable->lock);
+    }
 
-        return entries;
+    return entries;
 }
 
-
 static fdentry_t *
-__gf_fd_fdtable_copy_all_fds (fdtable_t *fdtable, uint32_t *count)
+__gf_fd_fdtable_copy_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t *fdentries = NULL;
-        int        i         = 0;
+    fdentry_t *fdentries = NULL;
+    int i = 0;
 
-        if (count == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!count");
-                goto out;
-        }
+    if (count == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!count");
+        goto out;
+    }
 
-        fdentries = GF_CALLOC (fdtable->max_fds, sizeof (fdentry_t),
-                               gf_common_mt_fdentry_t);
-        if (fdentries == NULL) {
-                goto out;
-        }
+    fdentries = GF_CALLOC(fdtable->max_fds, sizeof(fdentry_t),
+                          gf_common_mt_fdentry_t);
+    if (fdentries == NULL) {
+        goto out;
+    }
 
-        *count = fdtable->max_fds;
+    *count = fdtable->max_fds;
 
-        for (i = 0; i < fdtable->max_fds; i++) {
-                if (fdtable->fdentries[i].fd != NULL) {
-                        fdentries[i].fd = fd_ref (fdtable->fdentries[i].fd);
-                }
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (fdtable->fdentries[i].fd != NULL) {
+            fdentries[i].fd = fd_ref(fdtable->fdentries[i].fd);
         }
+    }
 
 out:
-        return fdentries;
+    return fdentries;
 }
 
-
 fdentry_t *
-gf_fd_fdtable_copy_all_fds (fdtable_t *fdtable, uint32_t *count)
+gf_fd_fdtable_copy_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t *entries = NULL;
+    fdentry_t *entries = NULL;
 
-        if (fdtable) {
-                pthread_mutex_lock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_copy_all_fds (fdtable, count);
-                }
-                pthread_mutex_unlock (&fdtable->lock);
+    if (fdtable) {
+        pthread_rwlock_rdlock(&fdtable->lock);
+        {
+            entries = __gf_fd_fdtable_copy_all_fds(fdtable, count);
         }
+        pthread_rwlock_unlock(&fdtable->lock);
+    }
 
-        return entries;
+    return entries;
 }
 
-
 void
-gf_fd_fdtable_destroy (fdtable_t *fdtable)
+gf_fd_fdtable_destroy(fdtable_t *fdtable)
 {
-        struct list_head  list = {0, };
-        fd_t             *fd = NULL;
-        fdentry_t        *fdentries = NULL;
-        uint32_t          fd_count = 0;
-        int32_t           i = 0;
-
-        INIT_LIST_HEAD (&list);
-
-        if (!fdtable) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!fdtable");
-                return;
-        }
-
-        pthread_mutex_lock (&fdtable->lock);
-        {
-                fdentries = __gf_fd_fdtable_get_all_fds (fdtable, &fd_count);
-                GF_FREE (fdtable->fdentries);
-        }
-        pthread_mutex_unlock (&fdtable->lock);
-
-        if (fdentries != NULL) {
-                for (i = 0; i < fd_count; i++) {
-                        fd = fdentries[i].fd;
-                        if (fd != NULL) {
-                                fd_unref (fd);
-                        }
-                }
-
-                GF_FREE (fdentries);
-                pthread_mutex_destroy (&fdtable->lock);
-                GF_FREE (fdtable);
-        }
+    struct list_head list = {
+        0,
+    };
+    fd_t *fd = NULL;
+    fdentry_t *fdentries = NULL;
+    uint32_t fd_count = 0;
+    int32_t i = 0;
+
+    INIT_LIST_HEAD(&list);
+
+    if (!fdtable) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!fdtable");
+        return;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        fdentries = __gf_fd_fdtable_get_all_fds(fdtable, &fd_count);
+        GF_FREE(fdtable->fdentries);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
+
+    if (fdentries != NULL) {
+        for (i = 0; i < fd_count; i++) {
+            fd = fdentries[i].fd;
+            if (fd != NULL) {
+                fd_unref(fd);
+            }
+        }
+
+        GF_FREE(fdentries);
+        pthread_rwlock_destroy(&fdtable->lock);
+        GF_FREE(fdtable);
+    }
 }
 
-
 int
-gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr)
+gf_fd_unused_get(fdtable_t *fdtable, fd_t *fdptr)
 {
-        int32_t         fd = -1;
-        fdentry_t       *fde = NULL;
-        int             error;
-        int             alloc_attempts = 0;
-
-        if (fdtable == NULL || fdptr == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return EINVAL;
-        }
-
-        pthread_mutex_lock (&fdtable->lock);
-        {
-        fd_alloc_try_again:
-                if (fdtable->first_free != GF_FDTABLE_END) {
-                        fde = &fdtable->fdentries[fdtable->first_free];
-                        fd = fdtable->first_free;
-                        fdtable->first_free = fde->next_free;
-                        fde->next_free = GF_FDENTRY_ALLOCATED;
-                        fde->fd = fdptr;
-                } else {
-                        /* If this is true, there is something
-                         * seriously wrong with our data structures.
-                         */
-                        if (alloc_attempts >= 2) {
-                                gf_msg ("fd", GF_LOG_ERROR, 0,
-                                        LG_MSG_EXPAND_FD_TABLE_FAILED,
-                                        "multiple attempts to expand fd table"
-                                        " have failed.");
-                                goto out;
-                        }
-                        error = gf_fd_fdtable_expand (fdtable,
-                                                      fdtable->max_fds + 1);
-                        if (error) {
-                                gf_msg ("fd", GF_LOG_ERROR, error,
-                                        LG_MSG_EXPAND_FD_TABLE_FAILED,
-                                        "Cannot expand fdtable");
-                                goto out;
-                        }
-                        ++alloc_attempts;
-                        /* At this point, the table stands expanded
-                         * with the first_free referring to the first
-                         * free entry in the new set of fdentries that
-                         * have just been allocated. That means, the
-                         * above logic should just work.
-                         */
-                        goto fd_alloc_try_again;
-                }
-        }
+    int32_t fd = -1;
+    fdentry_t *fde = NULL;
+    int error;
+    int alloc_attempts = 0;
+
+    if (fdtable == NULL || fdptr == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return EINVAL;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+    fd_alloc_try_again:
+        if (fdtable->first_free != GF_FDTABLE_END) {
+            fde = &fdtable->fdentries[fdtable->first_free];
+            fd = fdtable->first_free;
+            fdtable->first_free = fde->next_free;
+            fde->next_free = GF_FDENTRY_ALLOCATED;
+            fde->fd = fdptr;
+        } else {
+            /* If this is true, there is something
+             * seriously wrong with our data structures.
+             */
+            if (alloc_attempts >= 2) {
+                gf_msg("fd", GF_LOG_ERROR, 0, LG_MSG_EXPAND_FD_TABLE_FAILED,
+                       "multiple attempts to expand fd table"
+                       " have failed.");
+                goto out;
+            }
+            error = gf_fd_fdtable_expand(fdtable, fdtable->max_fds + 1);
+            if (error) {
+                gf_msg("fd", GF_LOG_ERROR, error, LG_MSG_EXPAND_FD_TABLE_FAILED,
+                       "Cannot expand fdtable");
+                goto out;
+            }
+            ++alloc_attempts;
+            /* At this point, the table stands expanded
+             * with the first_free referring to the first
+             * free entry in the new set of fdentries that
+             * have just been allocated. That means, the
+             * above logic should just work.
+             */
+            goto fd_alloc_try_again;
+        }
+    }
 out:
-        pthread_mutex_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fd;
+    return fd;
 }
 
-
 void
-gf_fd_put (fdtable_t *fdtable, int32_t fd)
+gf_fd_put(fdtable_t *fdtable, int32_t fd)
 {
-        fd_t *fdptr = NULL;
-        fdentry_t *fde = NULL;
-
-        if (fd == GF_ANON_FD_NO)
-                return;
+    fd_t *fdptr = NULL;
+    fdentry_t *fde = NULL;
 
-        if (fdtable == NULL || fd < 0) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
+    if (fd == GF_ANON_FD_NO)
+        return;
 
-        if (!(fd < fdtable->max_fds)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
+    if (fdtable == NULL || fd < 0) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
 
-        pthread_mutex_lock (&fdtable->lock);
-        {
-                fde = &fdtable->fdentries[fd];
-                /* If the entry is not allocated, put operation must return
-                 * without doing anything.
-                 * This has the potential of masking out any bugs in a user of
-                 * fd that ends up calling gf_fd_put twice for the same fd or
-                 * for an unallocated fd, but it is a price we have to pay for
-                 * ensuring sanity of our fd-table.
-                 */
-                if (fde->next_free != GF_FDENTRY_ALLOCATED)
-                        goto unlock_out;
-                fdptr = fde->fd;
-                fde->fd = NULL;
-                fde->next_free = fdtable->first_free;
-                fdtable->first_free = fd;
-        }
+    if (!(fd < fdtable->max_fds)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        fde = &fdtable->fdentries[fd];
+        /* If the entry is not allocated, put operation must return
+         * without doing anything.
+         * This has the potential of masking out any bugs in a user of
+         * fd that ends up calling gf_fd_put twice for the same fd or
+         * for an unallocated fd, but it is a price we have to pay for
+         * ensuring sanity of our fd-table.
+         */
+        if (fde->next_free != GF_FDENTRY_ALLOCATED)
+            goto unlock_out;
+        fdptr = fde->fd;
+        fde->fd = NULL;
+        fde->next_free = fdtable->first_free;
+        fdtable->first_free = fd;
+    }
 unlock_out:
-        pthread_mutex_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        if (fdptr) {
-                fd_unref (fdptr);
-        }
+    if (fdptr) {
+        fd_unref(fdptr);
+    }
 }
 
-
 void
-gf_fdptr_put (fdtable_t *fdtable, fd_t *fd)
+gf_fdptr_put(fdtable_t *fdtable, fd_t *fd)
 {
-        fdentry_t *fde   = NULL;
-        int32_t    i     = 0;
+    fdentry_t *fde = NULL;
+    int32_t i = 0;
 
-        if ((fdtable == NULL) || (fd == NULL)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
-
-        pthread_mutex_lock (&fdtable->lock);
-        {
-                for (i = 0; i < fdtable->max_fds; i++) {
-                        if (fdtable->fdentries[i].fd == fd) {
-                                fde = &fdtable->fdentries[i];
-                                break;
-                        }
-                }
+    if ((fdtable == NULL) || (fd == NULL)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
 
-                if (fde == NULL) {
-                        gf_msg_callingfn ("fd", GF_LOG_WARNING, 0,
-                                          LG_MSG_FD_NOT_FOUND_IN_FDTABLE,
-                                          "fd (%p) is not present in fdtable",
-                                          fd);
-                        goto unlock_out;
-                }
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        for (i = 0; i < fdtable->max_fds; i++) {
+            if (fdtable->fdentries[i].fd == fd) {
+                fde = &fdtable->fdentries[i];
+                break;
+            }
+        }
 
-                /* If the entry is not allocated, put operation must return
-                 * without doing anything.
-                 * This has the potential of masking out any bugs in a user of
-                 * fd that ends up calling gf_fd_put twice for the same fd or
-                 * for an unallocated fd, but it is a price we have to pay for
-                 * ensuring sanity of our fd-table.
-                 */
-                if (fde->next_free != GF_FDENTRY_ALLOCATED)
-                        goto unlock_out;
-                fde->fd = NULL;
-                fde->next_free = fdtable->first_free;
-                fdtable->first_free = i;
+        if (fde == NULL) {
+            gf_msg_callingfn("fd", GF_LOG_WARNING, 0,
+                             LG_MSG_FD_NOT_FOUND_IN_FDTABLE,
+                             "fd (%p) is not present in fdtable", fd);
+            goto unlock_out;
         }
+
+        /* If the entry is not allocated, put operation must return
+         * without doing anything.
+         * This has the potential of masking out any bugs in a user of
+         * fd that ends up calling gf_fd_put twice for the same fd or
+         * for an unallocated fd, but it is a price we have to pay for
+         * ensuring sanity of our fd-table.
+         */
+        if (fde->next_free != GF_FDENTRY_ALLOCATED)
+            goto unlock_out;
+        fde->fd = NULL;
+        fde->next_free = fdtable->first_free;
+        fdtable->first_free = i;
+    }
 unlock_out:
-        pthread_mutex_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        if ((fd != NULL) && (fde != NULL)) {
-                fd_unref (fd);
-        }
+    if ((fd != NULL) && (fde != NULL)) {
+        fd_unref(fd);
+    }
 }
 
-
 fd_t *
-gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
+gf_fd_fdptr_get(fdtable_t *fdtable, int64_t fd)
 {
-        fd_t *fdptr = NULL;
+    fd_t *fdptr = NULL;
 
-        if (fdtable == NULL || fd < 0) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
+    if (fdtable == NULL || fd < 0) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
 
-        if (!(fd < fdtable->max_fds)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
+    if (!(fd < fdtable->max_fds)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
 
-        pthread_mutex_lock (&fdtable->lock);
-        {
-                fdptr = fdtable->fdentries[fd].fd;
-                if (fdptr) {
-                        fd_ref (fdptr);
-                }
+    pthread_rwlock_rdlock(&fdtable->lock);
+    {
+        fdptr = fdtable->fdentries[fd].fd;
+        if (fdptr) {
+            fd_ref(fdptr);
         }
-        pthread_mutex_unlock (&fdtable->lock);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fdptr;
+    return fdptr;
 }
 
-
 fd_t *
-__fd_ref (fd_t *fd)
+__fd_ref(fd_t *fd)
 {
-        ++fd->refcount;
+    GF_ATOMIC_INC(fd->refcount);
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_ref (fd_t *fd)
+fd_ref(fd_t *fd)
 {
-        fd_t *refed_fd = NULL;
-
-        if (!fd) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "null fd");
-                return NULL;
-        }
+    if (!fd) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "null fd");
+        return NULL;
+    }
 
-        LOCK (&fd->inode->lock);
-        refed_fd = __fd_ref (fd);
-        UNLOCK (&fd->inode->lock);
+    GF_ATOMIC_INC(fd->refcount);
 
-        return refed_fd;
+    return fd;
 }
 
-
-fd_t *
-__fd_unref (fd_t *fd)
+static void
+fd_destroy(fd_t *fd, gf_boolean_t bound)
 {
-        GF_ASSERT (fd->refcount);
-
-        --fd->refcount;
-
-        return fd;
+    xlator_t *xl = NULL;
+    int i = 0;
+    xlator_t *old_THIS = NULL;
+
+    if (fd == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        goto out;
+    }
+
+    if (fd->inode == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, 0, LG_MSG_FD_INODE_NULL,
+                         "fd->inode is NULL");
+        goto out;
+    }
+    if (!fd->_ctx)
+        goto out;
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        for (i = 0; i < fd->xl_count; i++) {
+            if (fd->_ctx[i].key) {
+                xl = fd->_ctx[i].xl_key;
+                old_THIS = THIS;
+                THIS = xl;
+                if (!xl->call_cleanup && xl->cbks->releasedir)
+                    xl->cbks->releasedir(xl, fd);
+                THIS = old_THIS;
+            }
+        }
+    } else {
+        for (i = 0; i < fd->xl_count; i++) {
+            if (fd->_ctx[i].key) {
+                xl = fd->_ctx[i].xl_key;
+                old_THIS = THIS;
+                THIS = xl;
+                if (!xl->call_cleanup && xl->cbks->release)
+                    xl->cbks->release(xl, fd);
+                THIS = old_THIS;
+            }
+        }
+    }
+
+    LOCK_DESTROY(&fd->lock);
+
+    GF_FREE(fd->_ctx);
+    if (bound) {
+        /*Decrease the count only after close happens on file*/
+        LOCK(&fd->inode->lock);
+        {
+            fd->inode->fd_count--;
+        }
+        UNLOCK(&fd->inode->lock);
+    }
+    inode_unref(fd->inode);
+    fd->inode = NULL;
+    fd_lk_ctx_unref(fd->lk_ctx);
+    mem_put(fd);
+out:
+    return;
 }
 
-
-static void
-fd_destroy (fd_t *fd, gf_boolean_t bound)
+void
+fd_close(fd_t *fd)
 {
-        xlator_t    *xl = NULL;
-        int          i = 0;
-        xlator_t    *old_THIS = NULL;
+    xlator_t *xl, *old_THIS;
 
-        if (fd == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR,  EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                goto out;
-        }
+    old_THIS = THIS;
 
-        if (fd->inode == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR, 0,
-                                  LG_MSG_FD_INODE_NULL,
-                                  "fd->inode is NULL");
-                goto out;
-        }
-        if (!fd->_ctx)
-                goto out;
+    for (xl = fd->inode->table->xl->graph->first; xl != NULL; xl = xl->next) {
+        if (!xl->call_cleanup) {
+            THIS = xl;
 
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                for (i = 0; i <  fd->xl_count; i++) {
-                        if (fd->_ctx[i].key) {
-                                xl = fd->_ctx[i].xl_key;
-                                old_THIS = THIS;
-                                THIS = xl;
-                                if (xl->cbks->releasedir)
-                                        xl->cbks->releasedir (xl, fd);
-                                THIS = old_THIS;
-                        }
+            if (IA_ISDIR(fd->inode->ia_type)) {
+                if (xl->cbks->fdclosedir != NULL) {
+                    xl->cbks->fdclosedir(xl, fd);
                 }
-        } else {
-                for (i = 0; i < fd->xl_count; i++) {
-                        if (fd->_ctx[i].key) {
-                                xl = fd->_ctx[i].xl_key;
-                                old_THIS = THIS;
-                                THIS = xl;
-                                if (xl->cbks->release)
-                                        xl->cbks->release (xl, fd);
-                                THIS = old_THIS;
-                        }
+            } else {
+                if (xl->cbks->fdclose != NULL) {
+                    xl->cbks->fdclose(xl, fd);
                 }
+            }
         }
+    }
 
-        LOCK_DESTROY (&fd->lock);
-
-        GF_FREE (fd->_ctx);
-        if (bound) {
-                /*Decrease the count only after close happens on file*/
-                LOCK (&fd->inode->lock);
-                {
-                        fd->inode->fd_count--;
-                }
-                UNLOCK (&fd->inode->lock);
-        }
-        inode_unref (fd->inode);
-        fd->inode = NULL;
-        fd_lk_ctx_unref (fd->lk_ctx);
-        mem_put (fd);
-out:
-        return;
+    THIS = old_THIS;
 }
 
-
 void
-fd_unref (fd_t *fd)
+fd_unref(fd_t *fd)
 {
-        int32_t refcount = 0;
-        gf_boolean_t bound = _gf_false;
-
-        if (!fd) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "fd is NULL");
-                return;
-        }
+    int32_t refcount = 0;
+    gf_boolean_t bound = _gf_false;
 
-        LOCK (&fd->inode->lock);
-        {
-                __fd_unref (fd);
-                refcount = fd->refcount;
-                if (refcount == 0) {
-                        if (!list_empty (&fd->inode_list)) {
-                                list_del_init (&fd->inode_list);
-                                bound = _gf_true;
-                        }
-                }
-
-        }
-        UNLOCK (&fd->inode->lock);
+    if (!fd) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "fd is NULL");
+        return;
+    }
 
+    LOCK(&fd->inode->lock);
+    {
+        refcount = GF_ATOMIC_DEC(fd->refcount);
         if (refcount == 0) {
-                fd_destroy (fd, bound);
+            if (!list_empty(&fd->inode_list)) {
+                list_del_init(&fd->inode_list);
+                fd->inode->active_fd_count--;
+                bound = _gf_true;
+            }
         }
+    }
+    UNLOCK(&fd->inode->lock);
 
-        return ;
-}
+    if (refcount == 0) {
+        fd_destroy(fd, bound);
+    }
 
+    return;
+}
 
-fd_t *
-__fd_bind (fd_t *fd)
+static fd_t *
+__fd_bind(fd_t *fd)
 {
-        list_del_init (&fd->inode_list);
-        list_add (&fd->inode_list, &fd->inode->fd_list);
-        fd->inode->fd_count++;
+    list_del_init(&fd->inode_list);
+    list_add(&fd->inode_list, &fd->inode->fd_list);
+    fd->inode->fd_count++;
+    fd->inode->active_fd_count++;
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_bind (fd_t *fd)
+fd_bind(fd_t *fd)
 {
-        if (!fd || !fd->inode) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!fd || !fd->inode");
-                return NULL;
-        }
+    if (!fd || !fd->inode) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "!fd || !fd->inode");
+        return NULL;
+    }
 
-        LOCK (&fd->inode->lock);
-        {
-                fd = __fd_bind (fd);
-        }
-        UNLOCK (&fd->inode->lock);
+    LOCK(&fd->inode->lock);
+    {
+        fd = __fd_bind(fd);
+    }
+    UNLOCK(&fd->inode->lock);
 
-        return fd;
+    return fd;
 }
 
-
 static fd_t *
-__fd_create (inode_t *inode, uint64_t pid)
+fd_allocate(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd;
 
-        if (inode == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        fd = mem_get0 (inode->table->fd_mem_pool);
-        if (!fd)
-                goto out;
-
-        fd->xl_count = inode->table->xl->graph->xl_count + 1;
-
-        fd->_ctx = GF_CALLOC (1, (sizeof (struct _fd_ctx) * fd->xl_count),
-                              gf_common_mt_fd_ctx);
-        if (!fd->_ctx)
-                goto free_fd;
-
-        fd->lk_ctx = fd_lk_ctx_create ();
-        if (!fd->lk_ctx)
-                goto free_fd_ctx;
+    if (inode == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        fd->inode = inode_ref (inode);
+    fd = mem_get0(inode->table->fd_mem_pool);
+    if (fd == NULL) {
+        return NULL;
+    }
+
+    fd->xl_count = inode->table->xl->graph->xl_count + 1;
+
+    fd->_ctx = GF_CALLOC(1, (sizeof(struct _fd_ctx) * fd->xl_count),
+                         gf_common_mt_fd_ctx);
+    if (fd->_ctx == NULL) {
+        goto failed;
+    }
+
+    fd->lk_ctx = fd_lk_ctx_create();
+    if (fd->lk_ctx != NULL) {
+        /* We need to take a reference from the inode, but we cannot do it
+         * here because this function can be called with the inode lock taken
+         * and inode_ref() takes the inode's table lock. This is the reverse
+         * of the logical lock acquisition order and can cause a deadlock. So
+         * we simply assign the inode here and we delefate the inode reference
+         * responsibility to the caller (when this function succeeds and the
+         * inode lock is released). This is safe because the caller must hold
+         * a reference of the inode to use it, so it's guaranteed that the
+         * number of references won't reach 0 before the caller finishes.
+         *
+         * TODO: minimize use of locks in favor of atomic operations to avoid
+         *       these dependencies. */
+        fd->inode = inode;
         fd->pid = pid;
-        INIT_LIST_HEAD (&fd->inode_list);
-
-        LOCK_INIT (&fd->lock);
-out:
+        INIT_LIST_HEAD(&fd->inode_list);
+        LOCK_INIT(&fd->lock);
+        GF_ATOMIC_INIT(fd->refcount, 1);
         return fd;
+    }
 
-free_fd_ctx:
-        GF_FREE (fd->_ctx);
-free_fd:
-        mem_put (fd);
+    GF_FREE(fd->_ctx);
 
-        return NULL;
-}
+failed:
+    mem_put(fd);
 
+    return NULL;
+}
 
 fd_t *
-fd_create (inode_t *inode, pid_t pid)
+fd_create_uint64(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
-
-        fd = __fd_create (inode, (uint64_t)pid);
-        if (!fd)
-                goto out;
+    fd_t *fd;
 
-        fd = fd_ref (fd);
+    fd = fd_allocate(inode, pid);
+    if (fd != NULL) {
+        /* fd_allocate() doesn't get a reference from the inode. We need to
+         * take it here in case of success. */
+        inode_ref(inode);
+    }
 
-out:
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_create_uint64 (inode_t *inode, uint64_t pid)
+fd_create(inode_t *inode, pid_t pid)
 {
-        fd_t *fd = NULL;
-
-        fd = __fd_create (inode, pid);
-        if (!fd)
-                goto out;
-
-        fd = fd_ref (fd);
-
-out:
-        return fd;
+    return fd_create_uint64(inode, (uint64_t)pid);
 }
 
-
 static fd_t *
-__fd_lookup (inode_t *inode, uint64_t pid)
+__fd_lookup(inode_t *inode, uint64_t pid)
 {
-        fd_t *iter_fd = NULL;
-        fd_t *fd = NULL;
-
-        if (list_empty (&inode->fd_list))
-                return NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *fd = NULL;
 
+    if (list_empty(&inode->fd_list))
+        return NULL;
 
-        list_for_each_entry (iter_fd, &inode->fd_list, inode_list) {
-                if (iter_fd->anonymous)
-                        /* If someone was interested in getting an
-                           anonymous fd (or was OK getting an anonymous fd),
-                           they can as well call fd_anonymous() directly */
-                        continue;
+    list_for_each_entry(iter_fd, &inode->fd_list, inode_list)
+    {
+        if (iter_fd->anonymous)
+            /* If someone was interested in getting an
+               anonymous fd (or was OK getting an anonymous fd),
+               they can as well call fd_anonymous() directly */
+            continue;
 
-                if (!pid || iter_fd->pid == pid) {
-                        fd = __fd_ref (iter_fd);
-                        break;
-                }
+        if (!pid || iter_fd->pid == pid) {
+            fd = __fd_ref(iter_fd);
+            break;
         }
+    }
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_lookup (inode_t *inode, pid_t pid)
+fd_lookup(inode_t *inode, pid_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup (inode, (uint64_t)pid);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup(inode, (uint64_t)pid);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_lookup_uint64 (inode_t *inode, uint64_t pid)
+fd_lookup_uint64(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup (inode, pid);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup(inode, pid);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
 static fd_t *
-__fd_lookup_anonymous (inode_t *inode, int32_t flags)
+__fd_lookup_anonymous(inode_t *inode, int32_t flags)
 {
-        fd_t *iter_fd = NULL;
-        fd_t *fd = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *fd = NULL;
 
-        if (list_empty (&inode->fd_list))
-                return NULL;
+    if (list_empty(&inode->fd_list))
+        return NULL;
 
-        list_for_each_entry (iter_fd, &inode->fd_list, inode_list) {
-                if ((iter_fd->anonymous) && (flags == iter_fd->flags)) {
-                        fd = __fd_ref (iter_fd);
-                        break;
-                }
+    list_for_each_entry(iter_fd, &inode->fd_list, inode_list)
+    {
+        if ((iter_fd->anonymous) && (flags == iter_fd->flags)) {
+            fd = __fd_ref(iter_fd);
+            break;
         }
+    }
 
-        return fd;
+    return fd;
 }
 
-static fd_t *
-__fd_anonymous (inode_t *inode, int32_t flags)
+fd_t *
+fd_anonymous_with_flags(inode_t *inode, int32_t flags)
 {
-        fd_t *fd = NULL;
-
-        fd = __fd_lookup_anonymous (inode, flags);
+    fd_t *fd = NULL;
+    bool ref = false;
 
-        /* if (fd); then we already have increased the refcount in
-           __fd_lookup_anonymous(), so no need of one more fd_ref().
-           if (!fd); then both create and bind wont bump up the ref
-           count, so we have to call fd_ref() after bind. */
-        if (!fd) {
-                fd = __fd_create (inode, 0);
+    LOCK(&inode->lock);
 
-                if (!fd)
-                        return NULL;
+    fd = __fd_lookup_anonymous(inode, flags);
 
-                fd->anonymous = _gf_true;
-                fd->flags = GF_ANON_FD_FLAGS|flags;
+    /* if (fd); then we already have increased the refcount in
+       __fd_lookup_anonymous(), so no need of one more fd_ref().
+       if (!fd); then both create and bind won't bump up the ref
+       count, so we have to call fd_ref() after bind. */
+    if (fd == NULL) {
+        fd = fd_allocate(inode, 0);
+        if (fd != NULL) {
+            fd->anonymous = _gf_true;
+            fd->flags = GF_ANON_FD_FLAGS | (flags & O_DIRECT);
 
-                __fd_bind (fd);
+            __fd_bind(fd);
 
-                __fd_ref (fd);
+            ref = true;
         }
+    }
 
-        return fd;
-}
-
+    UNLOCK(&inode->lock);
 
-fd_t *
-fd_anonymous (inode_t *inode)
-{
-        fd_t *fd = NULL;
-
-        LOCK (&inode->lock);
-        {
-                fd = __fd_anonymous (inode, GF_ANON_FD_FLAGS);
-        }
-        UNLOCK (&inode->lock);
+    if (ref) {
+        /* fd_allocate() doesn't get a reference from the inode. We need to
+         * take it here in case of success. */
+        inode_ref(inode);
+    }
 
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_anonymous_with_flags (inode_t *inode, int32_t flags)
+fd_anonymous(inode_t *inode)
 {
-        fd_t *fd = NULL;
-
-        LOCK (&inode->lock);
-        {
-                if (flags & O_DIRECT)
-                        flags = GF_ANON_FD_FLAGS | O_DIRECT;
-                else
-                        flags = GF_ANON_FD_FLAGS;
-
-                fd = __fd_anonymous (inode, flags);
-        }
-        UNLOCK (&inode->lock);
-
-        return fd;
+    return fd_anonymous_with_flags(inode, 0);
 }
 
-fd_t*
-fd_lookup_anonymous (inode_t *inode, int32_t flags)
+fd_t *
+fd_lookup_anonymous(inode_t *inode, int32_t flags)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
-
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup_anonymous (inode, flags);
-        }
-        UNLOCK (&inode->lock);
-        return fd;
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
+
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup_anonymous(inode, flags);
+    }
+    UNLOCK(&inode->lock);
+    return fd;
 }
 
 gf_boolean_t
-fd_is_anonymous (fd_t *fd)
+fd_is_anonymous(fd_t *fd)
 {
-        return (fd && fd->anonymous);
+    return (fd && fd->anonymous);
 }
 
-
 uint8_t
-fd_list_empty (inode_t *inode)
+fd_list_empty(inode_t *inode)
 {
-        uint8_t empty = 0;
+    uint8_t empty = 0;
 
-        LOCK (&inode->lock);
-        {
-                empty = list_empty (&inode->fd_list);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        empty = list_empty(&inode->fd_list);
+    }
+    UNLOCK(&inode->lock);
 
-        return empty;
+    return empty;
 }
 
-
 int
-__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
+__fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value)
 {
-        int             index   = 0, new_xl_count = 0;
-        int             ret     = 0;
-        int             set_idx = -1;
-        void           *begin   = NULL;
-        size_t          diff    = 0;
-        struct _fd_ctx *tmp     = NULL;
-
-	if (!fd || !xlator)
-		return -1;
-
-        for (index = 0; index < fd->xl_count; index++) {
-                if (!fd->_ctx[index].key) {
-                        if (set_idx == -1)
-                                set_idx = index;
-                        /* dont break, to check if key already exists
-                           further on */
-                }
-                if (fd->_ctx[index].xl_key == xlator) {
-                        set_idx = index;
-                        break;
-                }
+    int index = 0, new_xl_count = 0;
+    int ret = 0;
+    int set_idx = -1;
+    void *begin = NULL;
+    size_t diff = 0;
+    struct _fd_ctx *tmp = NULL;
+
+    if (!fd || !xlator)
+        return -1;
+
+    for (index = 0; index < fd->xl_count; index++) {
+        if (!fd->_ctx[index].key) {
+            if (set_idx == -1)
+                set_idx = index;
+            /* don't break, to check if key already exists
+               further on */
         }
+        if (fd->_ctx[index].xl_key == xlator) {
+            set_idx = index;
+            break;
+        }
+    }
 
-        if (set_idx == -1) {
-                set_idx = fd->xl_count;
+    if (set_idx == -1) {
+        set_idx = fd->xl_count;
 
-                new_xl_count = fd->xl_count + xlator->graph->xl_count;
+        new_xl_count = fd->xl_count + xlator->graph->xl_count;
 
-                tmp = GF_REALLOC (fd->_ctx,
-                                  (sizeof (struct _fd_ctx)
-                                   * new_xl_count));
-                if (tmp == NULL) {
-                        ret = -1;
-                        goto out;
-                }
+        tmp = GF_REALLOC(fd->_ctx, (sizeof(struct _fd_ctx) * new_xl_count));
+        if (tmp == NULL) {
+            ret = -1;
+            goto out;
+        }
 
-                fd->_ctx = tmp;
+        fd->_ctx = tmp;
 
-                begin = fd->_ctx;
-                begin += (fd->xl_count * sizeof (struct _fd_ctx));
+        begin = fd->_ctx;
+        begin += (fd->xl_count * sizeof(struct _fd_ctx));
 
-                diff = (new_xl_count - fd->xl_count )
-                        * sizeof (struct _fd_ctx);
+        diff = (new_xl_count - fd->xl_count) * sizeof(struct _fd_ctx);
 
-                memset (begin, 0, diff);
+        memset(begin, 0, diff);
 
-                fd->xl_count = new_xl_count;
-        }
+        fd->xl_count = new_xl_count;
+    }
 
-        fd->_ctx[set_idx].xl_key = xlator;
-        fd->_ctx[set_idx].value1  = value;
+    fd->_ctx[set_idx].xl_key = xlator;
+    fd->_ctx[set_idx].value1 = value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
+fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value)
 {
-        int ret = 0;
+    int ret = 0;
 
-	if (!fd || !xlator) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "%p %p", fd, xlator);
-		return -1;
-        }
+    if (!fd || !xlator) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "%p %p", fd, xlator);
+        return -1;
+    }
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_set (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_set(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
+__fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        for (index = 0; index < fd->xl_count; index++) {
-                if (fd->_ctx[index].xl_key == xlator)
-                        break;
-        }
+    for (index = 0; index < fd->xl_count; index++) {
+        if (fd->_ctx[index].xl_key == xlator)
+            break;
+    }
 
-        if (index == fd->xl_count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == fd->xl_count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = fd->_ctx[index].value1;
+    if (value)
+        *value = fd->_ctx[index].value1;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
+fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
+__fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        for (index = 0; index < fd->xl_count; index++) {
-                if (fd->_ctx[index].xl_key == xlator)
-                        break;
-        }
+    for (index = 0; index < fd->xl_count; index++) {
+        if (fd->_ctx[index].xl_key == xlator)
+            break;
+    }
 
-        if (index == fd->xl_count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == fd->xl_count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = fd->_ctx[index].value1;
+    if (value)
+        *value = fd->_ctx[index].value1;
 
-        fd->_ctx[index].key   = 0;
-        fd->_ctx[index].value1 = 0;
+    fd->_ctx[index].key = 0;
+    fd->_ctx[index].value1 = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
+fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_del (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_del(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 void
-fd_dump (fd_t *fd, char *prefix)
+fd_dump(fd_t *fd, char *prefix)
 {
-        char        key[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
 
-        if (!fd)
-                return;
+    if (!fd)
+        return;
 
-        memset(key, 0, sizeof(key));
-        gf_proc_dump_write("pid", "%llu", fd->pid);
-        gf_proc_dump_write("refcount", "%d", fd->refcount);
-        gf_proc_dump_write("flags", "%d", fd->flags);
-
-        if (fd->inode) {
-                gf_proc_dump_build_key (key, "inode", NULL);
-                gf_proc_dump_add_section(key);
-                inode_dump (fd->inode, key);
-        }
+    gf_proc_dump_write("pid", "%" PRIu64, fd->pid);
+    gf_proc_dump_write("refcount", "%" GF_PRI_ATOMIC,
+                       GF_ATOMIC_GET(fd->refcount));
+    gf_proc_dump_write("flags", "%d", fd->flags);
 
+    if (fd->inode) {
+        gf_proc_dump_build_key(key, "inode", NULL);
+        gf_proc_dump_add_section("%s", key);
+        inode_dump(fd->inode, key);
+    }
 }
 
-
 void
-fdentry_dump (fdentry_t *fdentry, char *prefix)
+fdentry_dump(fdentry_t *fdentry, char *prefix)
 {
-        if (!fdentry)
-                return;
+    if (!fdentry)
+        return;
 
-        if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
-                return;
+    if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
+        return;
 
-        if (fdentry->fd)
-                fd_dump(fdentry->fd, prefix);
+    if (fdentry->fd)
+        fd_dump(fdentry->fd, prefix);
 }
 
-
 void
-fdtable_dump (fdtable_t *fdtable, char *prefix)
+fdtable_dump(fdtable_t *fdtable, char *prefix)
 {
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     i = 0;
-        int     ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+    int ret = -1;
 
-        if (!fdtable)
-                return;
+    if (!fdtable)
+        return;
 
-        ret = pthread_mutex_trylock (&fdtable->lock);
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        goto out;
 
-        if (ret)
-                goto out;
+    gf_proc_dump_build_key(key, prefix, "refcount");
+    gf_proc_dump_write(key, "%d", fdtable->refcount);
+    gf_proc_dump_build_key(key, prefix, "maxfds");
+    gf_proc_dump_write(key, "%d", fdtable->max_fds);
+    gf_proc_dump_build_key(key, prefix, "first_free");
+    gf_proc_dump_write(key, "%d", fdtable->first_free);
 
-        memset(key, 0, sizeof(key));
-        gf_proc_dump_build_key(key, prefix, "refcount");
-        gf_proc_dump_write(key, "%d", fdtable->refcount);
-        gf_proc_dump_build_key(key, prefix, "maxfds");
-        gf_proc_dump_write(key, "%d", fdtable->max_fds);
-        gf_proc_dump_build_key(key, prefix, "first_free");
-        gf_proc_dump_write(key, "%d", fdtable->first_free);
-
-        for ( i = 0 ; i < fdtable->max_fds; i++) {
-                if (GF_FDENTRY_ALLOCATED ==
-                    fdtable->fdentries[i].next_free) {
-                        gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
-                        gf_proc_dump_add_section(key);
-                        fdentry_dump(&fdtable->fdentries[i], key);
-                }
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (GF_FDENTRY_ALLOCATED == fdtable->fdentries[i].next_free) {
+            gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
+            gf_proc_dump_add_section("%s", key);
+            fdentry_dump(&fdtable->fdentries[i], key);
         }
+    }
 
-        pthread_mutex_unlock(&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
 out:
-        if (ret != 0)
-                gf_proc_dump_write ("Unable to dump the fdtable",
-                                    "(Lock acquistion failed) %p", fdtable);
-        return;
+    if (ret != 0)
+        gf_proc_dump_write("Unable to dump the fdtable",
+                           "(Lock acquistion failed) %p", fdtable);
+    return;
 }
 
-
 void
-fd_ctx_dump (fd_t *fd, char *prefix)
+fd_ctx_dump(fd_t *fd, char *prefix)
 {
-        struct _fd_ctx *fd_ctx = NULL;
-        xlator_t       *xl     = NULL;
-        int    i               = 0;
-
-
-        if ((fd == NULL) || (fd->_ctx == NULL)) {
-                goto out;
-        }
-
-        LOCK (&fd->lock);
-        {
-                if (fd->_ctx != NULL) {
-                        fd_ctx = GF_CALLOC (fd->xl_count, sizeof (*fd_ctx),
-                                            gf_common_mt_fd_ctx);
-                        if (fd_ctx == NULL) {
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < fd->xl_count; i++) {
-                                fd_ctx[i] = fd->_ctx[i];
-                        }
-                }
-        }
+    struct _fd_ctx *fd_ctx = NULL;
+    xlator_t *xl = NULL;
+    int i = 0;
+
+    if ((fd == NULL) || (fd->_ctx == NULL)) {
+        goto out;
+    }
+
+    LOCK(&fd->lock);
+    {
+        if (fd->_ctx != NULL) {
+            fd_ctx = GF_CALLOC(fd->xl_count, sizeof(*fd_ctx),
+                               gf_common_mt_fd_ctx);
+            if (fd_ctx == NULL) {
+                goto unlock;
+            }
+
+            for (i = 0; i < fd->xl_count; i++) {
+                fd_ctx[i] = fd->_ctx[i];
+            }
+        }
+    }
 unlock:
-        UNLOCK (&fd->lock);
+    UNLOCK(&fd->lock);
 
-        if (fd_ctx == NULL) {
-                goto out;
-        }
+    if (fd_ctx == NULL) {
+        goto out;
+    }
 
-        for (i = 0; i < fd->xl_count; i++) {
-                if (fd_ctx[i].xl_key) {
-                        xl = (xlator_t *)(long)fd_ctx[i].xl_key;
-                        if (xl->dumpops && xl->dumpops->fdctx)
-                                xl->dumpops->fdctx (xl, fd);
-                }
+    for (i = 0; i < fd->xl_count; i++) {
+        if (fd_ctx[i].xl_key) {
+            xl = (xlator_t *)(long)fd_ctx[i].xl_key;
+            if (xl->dumpops && xl->dumpops->fdctx)
+                xl->dumpops->fdctx(xl, fd);
         }
+    }
 
 out:
-        GF_FREE (fd_ctx);
+    GF_FREE(fd_ctx);
 
-        return;
+    return;
 }
 
 void
-fdentry_dump_to_dict (fdentry_t *fdentry, char *prefix, dict_t *dict,
-                      int *openfds)
+fdentry_dump_to_dict(fdentry_t *fdentry, char *prefix, dict_t *dict,
+                     int *openfds)
 {
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int     ret = -1;
-
-        if (!fdentry)
-                return;
-        if (!dict)
-                return;
-
-        if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
-                return;
-
-        if (fdentry->fd) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.pid", prefix);
-                ret = dict_set_uint64 (dict, key, fdentry->fd->pid);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.refcount", prefix);
-                ret = dict_set_int32 (dict, key, fdentry->fd->refcount);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.flags", prefix);
-                ret = dict_set_int32 (dict, key, fdentry->fd->flags);
-
-                (*openfds)++;
-        }
-        return;
-}
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int ret = -1;
 
-void
-fdtable_dump_to_dict (fdtable_t *fdtable, char *prefix, dict_t *dict)
-{
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int     i = 0;
-        int     openfds = 0;
-        int     ret = -1;
+    if (!fdentry)
+        return;
+    if (!dict)
+        return;
 
-        if (!fdtable)
-                return;
-        if (!dict)
-                return;
+    if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
+        return;
 
-        ret = pthread_mutex_trylock (&fdtable->lock);
+    if (fdentry->fd) {
+        snprintf(key, sizeof(key), "%s.pid", prefix);
+        ret = dict_set_uint64(dict, key, fdentry->fd->pid);
         if (ret)
-                goto out;
+            return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.fdtable.refcount", prefix);
-        ret = dict_set_int32 (dict, key, fdtable->refcount);
+        snprintf(key, sizeof(key), "%s.refcount", prefix);
+        ret = dict_set_int32(dict, key, GF_ATOMIC_GET(fdentry->fd->refcount));
         if (ret)
-                goto out;
+            return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.fdtable.maxfds", prefix);
-        ret = dict_set_uint32 (dict, key, fdtable->max_fds);
+        snprintf(key, sizeof(key), "%s.flags", prefix);
+        ret = dict_set_int32(dict, key, fdentry->fd->flags);
         if (ret)
-                goto out;
+            return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.fdtable.firstfree", prefix);
-        ret = dict_set_int32 (dict, key, fdtable->first_free);
-        if (ret)
-                goto out;
+        (*openfds)++;
+    }
+    return;
+}
 
-        for (i = 0; i < fdtable->max_fds; i++) {
-                if (GF_FDENTRY_ALLOCATED ==
-                    fdtable->fdentries[i].next_free) {
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.fdtable.fdentry%d",
-                                  prefix, i);
-                        fdentry_dump_to_dict (&fdtable->fdentries[i], key,
-                                              dict, &openfds);
-                }
+void
+fdtable_dump_to_dict(fdtable_t *fdtable, char *prefix, dict_t *dict)
+{
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int i = 0;
+    int openfds = 0;
+    int ret = -1;
+
+    if (!fdtable)
+        return;
+    if (!dict)
+        return;
+
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        return;
+
+    snprintf(key, sizeof(key), "%s.fdtable.refcount", prefix);
+    ret = dict_set_int32(dict, key, fdtable->refcount);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.fdtable.maxfds", prefix);
+    ret = dict_set_uint32(dict, key, fdtable->max_fds);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.fdtable.firstfree", prefix);
+    ret = dict_set_int32(dict, key, fdtable->first_free);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (GF_FDENTRY_ALLOCATED == fdtable->fdentries[i].next_free) {
+            snprintf(key, sizeof(key), "%s.fdtable.fdentry%d", prefix, i);
+            fdentry_dump_to_dict(&fdtable->fdentries[i], key, dict, &openfds);
         }
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.fdtable.openfds", prefix);
-        ret = dict_set_int32 (dict, key, openfds);
+    snprintf(key, sizeof(key), "%s.fdtable.openfds", prefix);
+    ret = dict_set_int32(dict, key, openfds);
+    if (ret)
+        goto out;
 
 out:
-        pthread_mutex_unlock (&fdtable->lock);
-        return;
+    pthread_rwlock_unlock(&fdtable->lock);
+    return;
 }
diff --git a/libglusterfs/src/fd.h b/libglusterfs/src/fd.h
deleted file mode 100644
index 31f494a7e8f..00000000000
--- a/libglusterfs/src/fd.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _FD_H
-#define _FD_H
-
-#include "list.h"
-#include <sys/types.h>
-#include <unistd.h>
-#include "glusterfs.h"
-#include "locking.h"
-#include "fd-lk.h"
-#include "common-utils.h"
-
-#define GF_ANON_FD_NO -2
-#define GF_ANON_FD_FLAGS (O_RDWR|O_LARGEFILE)
-
-struct _inode;
-struct _dict;
-struct fd_lk_ctx;
-
-struct _fd_ctx {
-        union {
-                uint64_t  key;
-                void     *xl_key;
-        };
-        union {
-                uint64_t  value1;
-                void     *ptr1;
-        };
-};
-
-struct _fd {
-        uint64_t          pid;
-	int32_t           flags;
-        int32_t           refcount;
-        struct list_head  inode_list;
-        struct _inode    *inode;
-        gf_lock_t         lock; /* used ONLY for manipulating
-                                   'struct _fd_ctx' array (_ctx).*/
-	struct _fd_ctx   *_ctx;
-        int               xl_count; /* Number of xl referred in this fd */
-        struct fd_lk_ctx *lk_ctx;
-        gf_boolean_t      anonymous; /* fd which does not have counterpart open
-                                        fd on backend (server for client, posix
-                                        for server). */
-};
-typedef struct _fd fd_t;
-
-
-struct fd_table_entry {
-        fd_t    *fd;
-        int     next_free;
-};
-typedef struct fd_table_entry fdentry_t;
-
-
-struct _fdtable {
-        int             refcount;
-        uint32_t        max_fds;
-        pthread_mutex_t lock;
-        fdentry_t       *fdentries;
-        int             first_free;
-};
-typedef struct _fdtable fdtable_t;
-
-
-/* Signifies no more entries in the fd table. */
-#define GF_FDTABLE_END  -1
-
-/* This is used to invalidated
- * the next_free value in an fdentry that has been allocated
- */
-#define GF_FDENTRY_ALLOCATED    -2
-
-#include "logging.h"
-#include "xlator.h"
-
-
-void
-gf_fd_put (fdtable_t *fdtable, int32_t fd);
-
-
-fd_t *
-gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd);
-
-
-fdtable_t *
-gf_fd_fdtable_alloc (void);
-
-
-int
-gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr);
-
-
-fdentry_t *
-gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count);
-
-
-void
-gf_fd_fdtable_destroy (fdtable_t *fdtable);
-
-
-fd_t *
-__fd_ref (fd_t *fd);
-
-
-fd_t *
-fd_ref (fd_t *fd);
-
-
-void
-fd_unref (fd_t *fd);
-
-
-fd_t *
-fd_create (struct _inode *inode, pid_t pid);
-
-fd_t *
-fd_create_uint64 (struct _inode *inode, uint64_t pid);
-
-fd_t *
-fd_lookup (struct _inode *inode, pid_t pid);
-
-fd_t *
-fd_lookup_uint64 (struct _inode *inode, uint64_t pid);
-
-fd_t*
-fd_lookup_anonymous (inode_t *inode, int32_t flags);
-
-fd_t *
-fd_anonymous (inode_t *inode);
-
-fd_t *
-fd_anonymous_with_flags (inode_t *inode, int32_t flags);
-
-gf_boolean_t
-fd_is_anonymous (fd_t *fd);
-
-
-uint8_t
-fd_list_empty (struct _inode *inode);
-
-
-fd_t *
-fd_bind (fd_t *fd);
-
-
-int
-fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-
-
-int
-fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-
-
-int
-fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
-
-int
-__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
-
-
-int
-__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-
-
-int
-__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-
-
-void
-fd_ctx_dump (fd_t *fd, char *prefix);
-
-fdentry_t *
-gf_fd_fdtable_copy_all_fds (fdtable_t *fdtable, uint32_t *count);
-
-
-void
-gf_fdptr_put (fdtable_t *fdtable, fd_t *fd);
-
-#endif /* _FD_H */
diff --git a/libglusterfs/src/gen-defaults.py b/libglusterfs/src/gen-defaults.py
index f8e76d02ef4..e31d3a9fe8a 100644..100755
--- a/libglusterfs/src/gen-defaults.py
+++ b/libglusterfs/src/gen-defaults.py
@@ -1,5 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
+from __future__ import print_function
 import sys
 from generator import ops, fop_subs, cbk_subs, generate
 
@@ -60,21 +61,21 @@ default_@NAME@ (
 """
 
 def gen_defaults ():
-	for name in ops.iterkeys():
-		print generate(FAILURE_CBK_TEMPLATE,name,cbk_subs)
-	for name in ops.iterkeys():
-		print generate(CBK_RESUME_TEMPLATE,name,cbk_subs)
-	for name in ops.iterkeys():
-		print generate(CBK_TEMPLATE,name,cbk_subs)
-	for name in ops.iterkeys():
-		print generate(RESUME_TEMPLATE,name,fop_subs)
-	for name in ops.iterkeys():
-		print generate(FOP_TEMPLATE,name,fop_subs)
+	for name in list(ops.keys()):
+		print(generate(FAILURE_CBK_TEMPLATE, name, cbk_subs))
+	for name in list(ops.keys()):
+		print(generate(CBK_RESUME_TEMPLATE, name, cbk_subs))
+	for name in list(ops.keys()):
+		print(generate(CBK_TEMPLATE, name, cbk_subs))
+	for name in list(ops.keys()):
+		print(generate(RESUME_TEMPLATE, name, fop_subs))
+	for name in list(ops.keys()):
+		print(generate(FOP_TEMPLATE, name, fop_subs))
 
-for l in open(sys.argv[1],'r').readlines():
+for l in open(sys.argv[1], 'r').readlines():
 	if l.find('#pragma generate') != -1:
-		print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
 		gen_defaults()
-		print "/* END GENERATED CODE */"
+		print("/* END GENERATED CODE */")
 	else:
-		print l[:-1]
+		print(l[:-1])
diff --git a/libglusterfs/src/generator.py b/libglusterfs/src/generator.py
index 7bd4c21cb3a..5b7aa4764a0 100755
--- a/libglusterfs/src/generator.py
+++ b/libglusterfs/src/generator.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import string
 
@@ -123,6 +123,8 @@ ops['fstat'] = (
 ops['fsync'] = (
 	('fop-arg',	'fd',			'fd_t *'),
 	('fop-arg',	'flags',		'int32_t'),
+	('extra',	'preop',		'struct iatt',		'&preop'),
+	('extra',	'postop',		'struct iatt',		'&postop'),
 	('fop-arg',	'xdata',		'dict_t *'),
 	('cbk-arg',	'prebuf',		'struct iatt *'),
 	('cbk-arg',	'postbuf',		'struct iatt *'),
@@ -142,6 +144,8 @@ ops['writev'] = (
 	('fop-arg',	'off',			'off_t',			'offset'),
 	('fop-arg',	'flags',		'uint32_t',			'flags'),
 	('fop-arg',	'iobref',		'struct iobref *'),
+	('extra',	'preop',		'struct iatt',		'&preop'),
+	('extra',	'postop',		'struct iatt',		'&postop'),
 	('fop-arg',	'xdata',		'dict_t *',			'xdata'),
 	('cbk-arg',	'prebuf',		'struct iatt *'),
 	('cbk-arg',	'postbuf',		'struct iatt *'),
@@ -154,6 +158,7 @@ ops['readv'] = (
 	('fop-arg',	'size',			'size_t'),
 	('fop-arg',	'offset',		'off_t'),
 	('fop-arg',	'flags',		'uint32_t'),
+	('extra',	'iatt',			'struct iatt',		'&iatt'),
 	('fop-arg',	'xdata',		'dict_t *'),
 	('cbk-arg',	'vector',		'struct iovec *'),
 	('cbk-arg',	'count',		'int32_t'),
@@ -208,9 +213,9 @@ ops['rename'] = (
 	('fop-arg',	'xdata',		'dict_t *',			'xdata'),
 	('cbk-arg',	'buf',			'struct iatt *'),
 	('cbk-arg',	'preoldparent',	'struct iatt *'),
-	('cbk-arg',	'postoldparent','struct iatt *'),
+	('cbk-arg',	'postoldparent', 'struct iatt *'),
 	('cbk-arg',	'prenewparent',	'struct iatt *'),
-	('cbk-arg',	'postnewparent','struct iatt *'),
+	('cbk-arg',	'postnewparent', 'struct iatt *'),
 	('cbk-arg',	'xdata',		'dict_t *'),
 	('journal',	'entry-op'),
 )
@@ -298,6 +303,8 @@ ops['access'] = (
 ops['ftruncate'] = (
 	('fop-arg',	'fd',			'fd_t *',				'fd'),
 	('fop-arg',	'offset',		'off_t',				'offset'),
+	('extra',	'preop',		'struct iatt',		'&preop'),
+	('extra',	'postop',		'struct iatt',		'&postop'),
 	('fop-arg',	'xdata',		'dict_t *',				'xdata'),
 	('cbk-arg',	'prebuf',		'struct iatt *'),
 	('cbk-arg',	'postbuf',		'struct iatt *'),
@@ -536,135 +543,183 @@ ops['getspec'] = (
 )
 
 ops['lease'] = (
-        ('fop-arg',     'loc',                  'loc_t *'),
-        ('fop-arg',     'lease',                'struct gf_lease *'),
-        ('fop-arg',     'xdata',                'dict_t *'),
-        ('cbk-arg',     'lease',                'struct gf_lease *'),
-        ('cbk-arg',     'xdata',                'dict_t *'),
+	('fop-arg',     'loc',                  'loc_t *'),
+	('fop-arg',     'lease',                'struct gf_lease *'),
+	('fop-arg',     'xdata',                'dict_t *'),
+	('cbk-arg',     'lease',                'struct gf_lease *'),
+	('cbk-arg',     'xdata',                'dict_t *'),
 )
 
 ops['getactivelk'] = (
-        ('fop-arg',     'loc',                  'loc_t *'),
-        ('fop-arg',     'xdata',                'dict_t *'),
-        ('cbk-arg',     'locklist',             'lock_migration_info_t *'),
-        ('cbk-arg',     'xdata',                'dict_t *'),
+	('fop-arg',     'loc',                  'loc_t *'),
+	('fop-arg',     'xdata',                'dict_t *'),
+	('cbk-arg',     'locklist',             'lock_migration_info_t *'),
+	('cbk-arg',     'xdata',                'dict_t *'),
 )
 
 ops['setactivelk'] = (
-        ('fop-arg',     'loc',                  'loc_t *'),
-        ('fop-arg',     'locklist',             'lock_migration_info_t *'),
-        ('fop-arg',     'xdata',                'dict_t *'),
-        ('cbk-arg',     'xdata',                'dict_t *'),
+	('fop-arg',     'loc',                  'loc_t *'),
+	('fop-arg',     'locklist',             'lock_migration_info_t *'),
+	('fop-arg',     'xdata',                'dict_t *'),
+	('cbk-arg',     'xdata',                'dict_t *'),
+)
+
+ops['put'] = (
+	('fop-arg',     'loc',                  'loc_t *',                      'loc'),
+	('fop-arg',     'mode',                 'mode_t',                       'mode'),
+	('fop-arg',     'umask',                'mode_t',                       'umask'),
+	('fop-arg',     'flags',                'uint32_t',                     'flags'),
+	('fop-arg',     'vector',               'struct iovec *',               'vector'),
+	('fop-arg',     'count',                'int32_t'),
+	('fop-arg',     'off',                  'off_t',                        'offset'),
+	('fop-arg',     'iobref',               'struct iobref *'),
+	('fop-arg',     'dict',                 'dict_t *',                     'xattr'),
+	('fop-arg',     'xdata',                'dict_t *',                     'xdata'),
+	('cbk-arg',     'inode',                'inode_t *'),
+	('cbk-arg',     'buf',                  'struct iatt *'),
+	('cbk-arg',     'preparent',            'struct iatt *'),
+	('cbk-arg',     'postparent',           'struct iatt *'),
+	('cbk-arg',     'xdata',                'dict_t *'),
+)
+
+ops['icreate'] = (
+	('fop-arg',     'loc',                   'loc_t *'),
+	('fop-arg',     'mode',                  'mode_t'),
+	('fop-arg',     'xdata',                 'dict_t *'),
+	('cbk-arg',     'inode',                 'inode_t *'),
+	('cbk-arg',     'buf',                   'struct iatt *'),
+	('cbk-arg',     'xdata',                 'dict_t *'),
+)
+
+ops['namelink'] = (
+	('fop-arg',     'loc',                   'loc_t *'),
+	('fop-arg',     'xdata',                 'dict_t *'),
+	('cbk-arg',     'prebuf',                'struct iatt *'),
+	('cbk-arg',     'postbuf',               'struct iatt *'),
+	('cbk-arg',     'xdata',                 'dict_t *'),
+)
+
+ops['copy_file_range'] = (
+        ('fop-arg',     'fd_in',                 'fd_t *'),
+        ('fop-arg',     'off_in',                'off64_t '),
+        ('fop-arg',     'fd_out',                'fd_t *'),
+        ('fop-arg',     'off_out',               'off64_t '),
+        ('fop-arg',     'len',                   'size_t'),
+        ('fop-arg',     'flags',                 'uint32_t'),
+        ('fop-arg',     'xdata',                 'dict_t *'),
+        ('cbk-arg',     'stbuf',                 'struct iatt *'),
+        ('cbk-arg',     'prebuf_dst',            'struct iatt *'),
+        ('cbk-arg',     'postbuf_dst',           'struct iatt *'),
+        ('cbk-arg',     'xdata',                 'dict_t *'),
 )
-
 #####################################################################
 xlator_cbks['forget'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'inode',       'inode_t *'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'inode',       'inode_t *'),
 	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['release'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'fd',          'fd_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'fd',          'fd_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['releasedir'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'fd',          'fd_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'fd',          'fd_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['invalidate'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'inode',       'inode_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'inode',       'inode_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['client_destroy'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'client',      'client_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'client',      'client_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['client_disconnect'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'client',      'client_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'client',      'client_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_cbks['ictxmerge'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'fd',          'fd_t *'),
-        ('fn-arg',      'inode',       'inode_t *'),
-        ('fn-arg',      'linked_inode', 'inode_t *'),
-        ('ret-val',     'void',        ''),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'fd',          'fd_t *'),
+	('fn-arg',      'inode',       'inode_t *'),
+	('fn-arg',      'linked_inode', 'inode_t *'),
+	('ret-val',     'void',        ''),
 )
 
 #####################################################################
 xlator_dumpops['priv'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['inode'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['fd'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['inodectx'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'ino',         'inode_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'ino',         'inode_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['fdctx'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'fd',          'fd_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'fd',          'fd_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['priv_to_dict'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'dict',        'dict_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'dict',        'dict_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['inode_to_dict'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'dict',        'dict_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'dict',        'dict_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['fd_to_dict'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'dict',        'dict_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'dict',        'dict_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['inodectx_to_dict'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'ino',         'inode_t *'),
-        ('fn-arg',      'dict',        'dict_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'ino',         'inode_t *'),
+	('fn-arg',      'dict',        'dict_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['fdctx_to_dict'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('fn-arg',      'fd',          'fd_t *'),
-        ('fn-arg',      'dict',        'dict_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('fn-arg',      'fd',          'fd_t *'),
+	('fn-arg',      'dict',        'dict_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 xlator_dumpops['history'] = (
-        ('fn-arg',      'this',        'xlator_t *'),
-        ('ret-val',     'int32_t',     '0'),
+	('fn-arg',      'this',        'xlator_t *'),
+	('ret-val',     'int32_t',     '0'),
 )
 
 def get_error_arg (type_str):
@@ -672,45 +727,50 @@ def get_error_arg (type_str):
 		return "NULL"
 	return "-1"
 
-def get_subs (names, types):
+def get_subs (names, types, cbktypes=None):
 	sdict = {}
-	sdict["@SHORT_ARGS@"] = string.join(names,", ")
+	sdict["@SHORT_ARGS@"] = ', '.join(names)
 	# Convert two separate tuples to one of (name, type) sub-tuples.
-	as_tuples = zip(types,names)
+	as_tuples = list(zip(types, names))
 	# Convert each sub-tuple into a "type name" string.
-	as_strings = map(string.join,as_tuples)
+	as_strings = [' '.join(item) for item in as_tuples]
 	# Join all of those into one big string.
-	sdict["@LONG_ARGS@"] = string.join(as_strings,",\n\t")
+	sdict["@LONG_ARGS@"] = ',\n\t'.join(as_strings)
 	# So much more readable than string.join(map(string.join,zip(...))))
-	sdict["@ERROR_ARGS@"] = string.join(map(get_error_arg,types),", ")
+	sdict["@ERROR_ARGS@"] = ', '.join(list(map(get_error_arg, types)))
+	if cbktypes is not None:
+		sdict["@CBK_ERROR_ARGS@"] = ', '.join(list(map(get_error_arg, cbktypes)))
 	return sdict
 
 def generate (tmpl, name, subs):
-	text = tmpl.replace("@NAME@",name)
+	text = tmpl.replace("@NAME@", name)
 	if name == "writev":
 		# More spurious inconsistency.
-		text = text.replace("@UPNAME@","WRITE")
+		text = text.replace("@UPNAME@", "WRITE")
+	elif name == "readv":
+		text = text.replace("@UPNAME@", "READ")
 	else:
-		text = text.replace("@UPNAME@",name.upper())
-	for old, new in subs[name].iteritems():
-		text = text.replace(old,new)
+		text = text.replace("@UPNAME@", name.upper())
+	for old, new in subs[name].items():
+		text = text.replace(old, new)
 	# TBD: reindent/reformat the result for maximum readability.
-	return  text
+	return text
 
 fop_subs = {}
 cbk_subs = {}
 
-for name, args in ops.iteritems():
+for name, args in ops.items():
 
 	# Create the necessary substitution strings for fops.
 	arg_names = [ a[1] for a in args if a[0] == 'fop-arg']
 	arg_types = [ a[2] for a in args if a[0] == 'fop-arg']
-	fop_subs[name] = get_subs(arg_names,arg_types)
+	cbk_types = [ a[2] for a in args if a[0] == 'cbk-arg']
+	fop_subs[name] = get_subs(arg_names, arg_types, cbk_types)
 
 	# Same thing for callbacks.
 	arg_names = [ a[1] for a in args if a[0] == 'cbk-arg']
 	arg_types = [ a[2] for a in args if a[0] == 'cbk-arg']
-	cbk_subs[name] = get_subs(arg_names,arg_types)
+	cbk_subs[name] = get_subs(arg_names, arg_types)
 
 	# Callers can add other subs to these tables, or even create their
 	# own tables, using these same techniques, and then pass the result
diff --git a/libglusterfs/src/gf-dirent.c b/libglusterfs/src/gf-dirent.c
index d0df80e2886..a809efc97ef 100644
--- a/libglusterfs/src/gf-dirent.c
+++ b/libglusterfs/src/gf-dirent.c
@@ -8,237 +8,232 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
-#include "compat.h"
-#include "xlator.h"
-#include "syncop.h"
+#include "glusterfs/compat.h"
+#include "glusterfs/syncop.h"
 
 #define ONE 1ULL
 #define PRESENT_D_OFF_BITS 63
 #define BACKEND_D_OFF_BITS 63
 #define TOP_BIT (ONE << (PRESENT_D_OFF_BITS - 1))
 #define MASK (~0ULL)
-#define SHIFT_BITS (max (0, (BACKEND_D_OFF_BITS - PRESENT_D_OFF_BITS + 1)))
+#define SHIFT_BITS (max(0, (BACKEND_D_OFF_BITS - PRESENT_D_OFF_BITS + 1)))
 #define PRESENT_MASK (MASK >> (64 - PRESENT_D_OFF_BITS))
 
 static uint64_t
-bits_for (uint64_t num)
+bits_for(uint64_t num)
 {
-	uint64_t bits = 0, ctrl = 1;
+    uint64_t bits = 0, ctrl = 1;
 
-	while (ctrl < num) {
-		ctrl *= 2;
-		bits++;
-	}
+    while (ctrl < num) {
+        ctrl *= 2;
+        bits++;
+    }
 
-	return bits;
+    return bits;
 }
 
 int
-gf_deitransform(xlator_t *this,
-                uint64_t offset)
+gf_deitransform(xlator_t *this, uint64_t offset)
 {
-        int         cnt = 0;
-        int         max = 0;
-        int         max_bits = 0;
-        uint64_t    off_mask = 0;
-        uint64_t    host_mask = 0;
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-		cnt = 0;
-		goto out;
-	}
-
-        if (offset & TOP_BIT) {
-                /* HUGE d_off */
-                max_bits = bits_for (max);
-                off_mask = (MASK << max_bits);
-                host_mask = ~(off_mask);
-
-                cnt = offset & host_mask;
-	} else {
-                /* small d_off */
-                cnt = offset % max;
-        }
+    int cnt = 0;
+    int max = 0;
+    int max_bits = 0;
+    uint64_t off_mask = 0;
+    uint64_t host_mask = 0;
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        cnt = 0;
+        goto out;
+    }
+
+    if (offset & TOP_BIT) {
+        /* HUGE d_off */
+        max_bits = bits_for(max);
+        off_mask = (MASK << max_bits);
+        host_mask = ~(off_mask);
+
+        cnt = offset & host_mask;
+    } else {
+        /* small d_off */
+        cnt = offset % max;
+    }
 out:
-        return cnt;
+    return cnt;
 }
 
 uint64_t
-gf_dirent_orig_offset(xlator_t *this,
-                      uint64_t offset)
+gf_dirent_orig_offset(xlator_t *this, uint64_t offset)
 {
-        int         max = 0;
-        int         max_bits = 0;
-        uint64_t    off_mask = 0;
-        uint64_t    orig_offset;
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-                orig_offset = offset;
-		goto out;
-	}
-
-        if (offset & TOP_BIT) {
-                /* HUGE d_off */
-                max_bits = bits_for (max);
-                off_mask = (MASK << max_bits);
-                orig_offset = ((offset & ~TOP_BIT) & off_mask) << SHIFT_BITS;
-	} else {
-                /* small d_off */
-                orig_offset = offset / max;
-        }
+    int max = 0;
+    int max_bits = 0;
+    uint64_t off_mask = 0;
+    uint64_t orig_offset;
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        orig_offset = offset;
+        goto out;
+    }
+
+    if (offset & TOP_BIT) {
+        /* HUGE d_off */
+        max_bits = bits_for(max);
+        off_mask = (MASK << max_bits);
+        orig_offset = ((offset & ~TOP_BIT) & off_mask) << SHIFT_BITS;
+    } else {
+        /* small d_off */
+        orig_offset = offset / max;
+    }
 out:
-        return orig_offset;
+    return orig_offset;
 }
 
 int
-gf_itransform (xlator_t *this, uint64_t x, uint64_t *y_p, int client_id)
+gf_itransform(xlator_t *this, uint64_t x, uint64_t *y_p, int client_id)
 {
-        int         max = 0;
-        uint64_t    y = 0;
-        uint64_t    hi_mask = 0;
-        uint64_t    off_mask = 0;
-        int         max_bits = 0;
-
-        if (x == ((uint64_t) -1)) {
-                y = (uint64_t) -1;
-                goto out;
-        }
-
-        if (!x) {
-                y = 0;
-                goto out;
-        }
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-		y = x;
-		goto out;
-	}
-
-        max_bits = bits_for (max);
-
-        hi_mask = ~(PRESENT_MASK >> (max_bits + 1));
-
-        if (x & hi_mask) {
-                /* HUGE d_off */
-                off_mask = MASK << max_bits;
-                y = TOP_BIT | ((x >> SHIFT_BITS) & off_mask) | client_id;
-        } else {
-                /* small d_off */
-                y = ((x * max) + client_id);
-        }
+    int max = 0;
+    uint64_t y = 0;
+    uint64_t hi_mask = 0;
+    uint64_t off_mask = 0;
+    int max_bits = 0;
+
+    if (x == ((uint64_t)-1)) {
+        y = (uint64_t)-1;
+        goto out;
+    }
+
+    if (!x) {
+        y = 0;
+        goto out;
+    }
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        y = x;
+        goto out;
+    }
+
+    max_bits = bits_for(max);
+
+    hi_mask = ~(PRESENT_MASK >> (max_bits + 1));
+
+    if (x & hi_mask) {
+        /* HUGE d_off */
+        off_mask = MASK << max_bits;
+        y = TOP_BIT | ((x >> SHIFT_BITS) & off_mask) | client_id;
+    } else {
+        /* small d_off */
+        y = ((x * max) + client_id);
+    }
 
 out:
-        if (y_p)
-                *y_p = y;
+    if (y_p)
+        *y_p = y;
 
-        return 0;
+    return 0;
 }
 
 gf_dirent_t *
-gf_dirent_for_name (const char *name)
+gf_dirent_for_name(const char *name)
 {
-        gf_dirent_t *gf_dirent = NULL;
+    gf_dirent_t *gf_dirent = NULL;
 
-        /* TODO: use mem-pool */
-        gf_dirent = GF_CALLOC (gf_dirent_size (name), 1,
-                               gf_common_mt_gf_dirent_t);
-        if (!gf_dirent)
-                return NULL;
+    /* TODO: use mem-pool */
+    gf_dirent = GF_CALLOC(gf_dirent_size(name), 1, gf_common_mt_gf_dirent_t);
+    if (!gf_dirent)
+        return NULL;
 
-        INIT_LIST_HEAD (&gf_dirent->list);
-        strcpy (gf_dirent->d_name, name);
+    INIT_LIST_HEAD(&gf_dirent->list);
+    strcpy(gf_dirent->d_name, name);
 
-        gf_dirent->d_off = 0;
-        gf_dirent->d_ino = -1;
-        gf_dirent->d_type = 0;
-        gf_dirent->d_len = strlen (name);
+    gf_dirent->d_off = 0;
+    gf_dirent->d_ino = -1;
+    gf_dirent->d_type = 0;
+    gf_dirent->d_len = strlen(name);
 
-        return gf_dirent;
+    return gf_dirent;
 }
 
 void
-gf_dirent_entry_free (gf_dirent_t *entry)
+gf_dirent_entry_free(gf_dirent_t *entry)
 {
-        if (!entry)
-                return;
+    if (!entry)
+        return;
 
-        if (entry->dict)
-                dict_unref (entry->dict);
-        if (entry->inode)
-                inode_unref (entry->inode);
+    if (entry->dict)
+        dict_unref(entry->dict);
+    if (entry->inode)
+        inode_unref(entry->inode);
 
-        list_del_init (&entry->list);
-        GF_FREE (entry);
+    list_del_init(&entry->list);
+    GF_FREE(entry);
 }
 
 void
-gf_dirent_free (gf_dirent_t *entries)
+gf_dirent_free(gf_dirent_t *entries)
 {
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        if (!entries)
-                return;
+    if (!entries)
+        return;
 
-        if (list_empty (&entries->list))
-                return;
+    if (list_empty(&entries->list))
+        return;
 
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                gf_dirent_entry_free (entry);
-        }
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        gf_dirent_entry_free(entry);
+    }
 }
 
 gf_dirent_t *
-entry_copy (gf_dirent_t *source)
+entry_copy(gf_dirent_t *source)
 {
-        gf_dirent_t *sink = NULL;
+    gf_dirent_t *sink = NULL;
 
-        sink = gf_dirent_for_name (source->d_name);
-        if (!sink)
-                return NULL;
+    sink = gf_dirent_for_name(source->d_name);
+    if (!sink)
+        return NULL;
 
-        sink->d_off = source->d_off;
-        sink->d_ino = source->d_ino;
-        sink->d_type = source->d_type;
-        sink->d_stat = source->d_stat;
-        sink->d_len  = source->d_len;
+    sink->d_off = source->d_off;
+    sink->d_ino = source->d_ino;
+    sink->d_type = source->d_type;
+    sink->d_stat = source->d_stat;
+    sink->d_len = source->d_len;
 
-	if (source->inode)
-		sink->inode = inode_ref (source->inode);
+    if (source->inode)
+        sink->inode = inode_ref(source->inode);
 
-	if (source->dict)
-		sink->dict = dict_ref (source->dict);
-        return sink;
+    if (source->dict)
+        sink->dict = dict_ref(source->dict);
+    return sink;
 }
 
 void
-gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry)
+gf_link_inode_from_dirent(xlator_t *this, inode_t *parent, gf_dirent_t *entry)
 {
-        inode_t     *link_inode = NULL;
-        inode_t     *tmp        = NULL;
-
-        if (!entry->inode)
-                return;
-        link_inode = inode_link (entry->inode, parent,
-                                 entry->d_name, &entry->d_stat);
-        if (!link_inode)
-                return;
-
-        inode_lookup (link_inode);
-        tmp = entry->inode;
-        entry->inode = link_inode;
-        inode_unref (tmp);
+    inode_t *link_inode = NULL;
+    inode_t *tmp = NULL;
+
+    if (!entry->inode)
+        return;
+    link_inode = inode_link(entry->inode, parent, entry->d_name,
+                            &entry->d_stat);
+    if (!link_inode)
+        return;
+
+    inode_lookup(link_inode);
+    tmp = entry->inode;
+    entry->inode = link_inode;
+    inode_unref(tmp);
 }
 
 /* TODO: Currently, with this function, we will be breaking the
@@ -247,55 +242,60 @@ gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry)
    Need more thoughts before finalizing this function
 */
 int
-gf_link_inodes_from_dirent (xlator_t *this, inode_t *parent,
-                            gf_dirent_t *entries)
+gf_link_inodes_from_dirent(xlator_t *this, inode_t *parent,
+                           gf_dirent_t *entries)
 {
-        gf_dirent_t *entry      = NULL;
+    gf_dirent_t *entry = NULL;
 
-        list_for_each_entry (entry, &entries->list, list) {
-                gf_link_inode_from_dirent (this, parent, entry);
-        }
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        gf_link_inode_from_dirent(this, parent, entry);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-gf_fill_iatt_for_dirent (gf_dirent_t *entry, inode_t *parent, xlator_t *subvol)
+gf_fill_iatt_for_dirent(gf_dirent_t *entry, inode_t *parent, xlator_t *subvol)
 {
-        loc_t                   loc             = {0, };
-        int                     ret             = -1;
-        char                   *path            = NULL;
-        struct iatt             iatt            = {0,};
-
-        loc.inode = inode_grep (parent->table, parent, entry->d_name);
-        if (!loc.inode) {
-                loc.inode = inode_new (parent->table);
-                gf_uuid_copy (loc.inode->gfid, entry->d_stat.ia_gfid);
-        }
-
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.name = entry->d_name;
-        loc.parent = inode_ref (parent);
-        ret = inode_path (loc.inode, entry->d_name, &path);
-        loc.path = path;
-        if (ret < 0)
-                goto out;
-
-        ret = syncop_lookup (subvol, &loc, &iatt, NULL, NULL, NULL);
-        if (ret)
-                goto out;
-
-        entry->d_stat = iatt;
-        entry->inode = inode_ref (loc.inode);
-        /* We don't need to link inode here, because as part of readdirp_cbk
-         * we will link all dirents.
-         *
-         * Since we did a proper lookup, we don't need to set need_lookup
-         * flag.
-         */
-
-        ret = 0;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    loc.inode = inode_grep(parent->table, parent, entry->d_name);
+    if (!loc.inode) {
+        loc.inode = inode_new(parent->table);
+        gf_uuid_copy(loc.inode->gfid, entry->d_stat.ia_gfid);
+    }
+
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = entry->d_name;
+    loc.parent = inode_ref(parent);
+    ret = inode_path(loc.parent, entry->d_name, &path);
+    loc.path = path;
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, NULL, NULL);
+    if (ret)
+        goto out;
+
+    entry->d_stat = iatt;
+    entry->inode = inode_ref(loc.inode);
+    /* We don't need to link inode here, because as part of readdirp_cbk
+     * we will link all dirents.
+     *
+     * Since we did a proper lookup, we don't need to set need_lookup
+     * flag.
+     */
+
+    ret = 0;
 out:
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
diff --git a/libglusterfs/src/gf-dirent.h b/libglusterfs/src/gf-dirent.h
deleted file mode 100644
index fa323396e92..00000000000
--- a/libglusterfs/src/gf-dirent.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-
-#ifndef _GF_DIRENT_H
-#define _GF_DIRENT_H
-
-#include "iatt.h"
-#include "inode.h"
-
-#define gf_dirent_size(name) (sizeof (gf_dirent_t) + strlen (name) + 1)
-
-int
-gf_deitransform(xlator_t *this, uint64_t y);
-
-int
-gf_itransform (xlator_t *this, uint64_t x, uint64_t *y_p, int client_id);
-
-uint64_t
-gf_dirent_orig_offset (xlator_t *this, uint64_t offset);
-
-
-struct _dir_entry {
-        struct _dir_entry   *next;
-	char                *name;
-	char                *link;
-	struct iatt          buf;
-};
-
-
-struct _gf_dirent {
-	union {
-		struct list_head             list;
-		struct {
-			struct _gf_dirent   *next;
-			struct _gf_dirent   *prev;
-		};
-	};
-	uint64_t                             d_ino;
-	uint64_t                             d_off;
-	uint32_t                             d_len;
-	uint32_t                             d_type;
-        struct iatt                          d_stat;
-        dict_t                              *dict;
-        inode_t                             *inode;
-	char                                 d_name[];
-};
-
-#define DT_ISDIR(mode) (mode == DT_DIR)
-
-gf_dirent_t *gf_dirent_for_name (const char *name);
-gf_dirent_t *entry_copy (gf_dirent_t *source);
-void gf_dirent_entry_free (gf_dirent_t *entry);
-void gf_dirent_free (gf_dirent_t *entries);
-int gf_link_inodes_from_dirent (xlator_t *this, inode_t *parent,
-                                gf_dirent_t *entries);
-int
-gf_fill_iatt_for_dirent (gf_dirent_t *entry, inode_t *parent,
-                         xlator_t *subvol);
-
-void
-gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry);
-#endif /* _GF_DIRENT_H */
diff --git a/libglusterfs/src/gfdb/Makefile.am b/libglusterfs/src/gfdb/Makefile.am
deleted file mode 100644
index 3931e694c24..00000000000
--- a/libglusterfs/src/gfdb/Makefile.am
+++ /dev/null
@@ -1,37 +0,0 @@
-libgfdb_la_CFLAGS = -Wall $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) \
-	$(SQLITE_CFLAGS) -DDATADIR=\"$(localstatedir)\"
-
-libgfdb_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 -fpic \
-	-I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src \
-	-I$(top_builddir)/rpc/xdr/src \
-	-DDATADIR=\"$(localstatedir)\"
-
-libgfdb_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	$(SQLITE_LIBS) $(UUID_LIBS)
-
-libgfdb_la_LDFLAGS = $(GF_LDFLAGS) -version-info $(LIBGLUSTERFS_LT_VERSION)
-
-libgfdbdir = $(includedir)/glusterfs/gfdb
-
-if BUILD_GFDB
- lib_LTLIBRARIES = libgfdb.la
-endif
-
-CONTRIB_BUILDDIR = $(top_builddir)/contrib
-
-libgfdb_la_SOURCES = gfdb_data_store.c gfdb_data_store_helper.c \
-	gfdb_sqlite3_helper.c gfdb_sqlite3.c
-
-noinst_HEADERS =  gfdb_data_store.h gfdb_data_store_types.h \
-	gfdb_sqlite3_helper.h gfdb_sqlite3.h gfdb_mem-types.h \
-	gfdb_data_store_helper.h
-
-libgfdb_HEADERS = gfdb_data_store.h gfdb_data_store_types.h \
-	gfdb_data_store_helper.h gfdb_sqlite3.h gfdb_mem-types.h \
-	gfdb_sqlite3_helper.h
-
-CLEANFILES =
-
-$(top_builddir)/libglusterfs/src/libglusterfs.la:
-	$(MAKE) -C $(top_builddir)/libglusterfs/src/ all
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.c b/libglusterfs/src/gfdb/gfdb_data_store.c
deleted file mode 100644
index 7074c4a51c2..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store.c
+++ /dev/null
@@ -1,883 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3.h"
-#include "gfdb_data_store.h"
-#include "list.h"
-#include "libglusterfs-messages.h"
-
-/******************************************************************************
- *
- *                     Database Connection utils/internals
- *
- * ****************************************************************************/
-
-/* GFDB Connection Node:
- * ~~~~~~~~~~~~~~~~~~~~
- * Represents the connection to the database while using libgfdb
- * The connection node is not thread safe as far as fini_db is concerned.
- * You can use a single connection node
- * to do multithreaded db operations like insert/delete/find of records.
- * But you need to wait for all the operating threads to complete i.e
- * pthread_join() and then do fini_db() to kill the connection node.
- * gfdb_conn_node_t is an opaque structure.
- * */
-struct gfdb_conn_node_t {
-        gfdb_connection_t       gfdb_connection;
-        struct list_head        conn_list;
-};
-
-
-/*
- * db_conn_list is the circular linked list which
- * will have all the database connections for the process
- *
- * */
-static gfdb_conn_node_t *db_conn_list;
-
-/*
- * db_conn_mutex is the mutex for db_conn_list
- *
- * */
-static pthread_mutex_t db_conn_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-
-/*Checks the sanity of the connection node*/
-#define CHECK_CONN_NODE(_conn_node)\
-do {\
-        GF_ASSERT (_conn_node);\
-        GF_ASSERT (_conn_node->gfdb_connection.gf_db_connection);\
-} while (0)
-
-/* Checks the sanity of the connection node and goto */
-#define CHECK_CONN_NODE_GOTO(_conn_node, label)\
-do {\
-        if (!_conn_node) {\
-                goto label;\
-        };\
-        if (!_conn_node->gfdb_connection.gf_db_connection) {\
-                goto label;\
-        };\
-} while (0)
-
-/*Check if the conn node is first in the list*/
-#define IS_FIRST_NODE(db_conn_list, _conn_node)\
-        ((_conn_node == db_conn_list) ? _gf_true : _gf_false)
-
-
-/*Check if the conn node is the only node in the list*/
-#define IS_THE_ONLY_NODE(_conn_node)\
-((_conn_node->conn_list.next == _conn_node->conn_list.prev)\
-        ? _gf_true : _gf_false)
-
-
-
-/*Internal Function: Adds connection node to the end of
- * the db connection list.*/
-static int
-add_connection_node (gfdb_conn_node_t *_conn_node) {
-        int ret = -1;
-
-        GF_ASSERT (_conn_node);
-
-        /*Lock the list*/
-        ret = pthread_mutex_lock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_LOCK_LIST_FAILED, "Failed lock db connection "
-                        "list %s", strerror(ret));
-                ret = -1;
-                goto out;
-        }
-
-        if (db_conn_list == NULL) {
-                db_conn_list = _conn_node;
-        } else {
-                list_add_tail (&_conn_node->conn_list,
-                                &db_conn_list->conn_list);
-        }
-
-        /*unlock the list*/
-        ret = pthread_mutex_unlock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock db "
-                        "connection list %s", strerror(ret));
-                ret = -1;
-                /*TODO What if the unlock fails.
-                * Will it lead to deadlock?
-                * Most of the gluster code
-                * no check for unlock or destory of mutex!*/
-        }
-        ret = 0;
-out:
-        return ret;
-}
-
-
-/*Internal Function:
- * Delete connection node from the list*/
-static int
-delete_conn_node (gfdb_conn_node_t *_conn_node)
-{
-        int ret = -1;
-
-        GF_ASSERT (_conn_node);
-
-        /*Lock of the list*/
-        ret = pthread_mutex_lock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_LOCK_LIST_FAILED, "Failed lock on db connection"
-                        " list %s", strerror(ret));
-                goto out;
-        }
-
-        /*Remove the connection object from list*/
-        if (IS_THE_ONLY_NODE(_conn_node)) {
-                db_conn_list = NULL;
-                GF_FREE (_conn_node);
-        } else {
-                if (IS_FIRST_NODE(db_conn_list, _conn_node)) {
-                        db_conn_list = list_entry (db_conn_list->conn_list.next,
-                                                gfdb_conn_node_t, conn_list);
-                }
-                list_del(&_conn_node->conn_list);
-                GF_FREE (_conn_node);
-        }
-
-        /*Release the list lock*/
-        ret =  pthread_mutex_unlock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_WARNING, ret,
-                        LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock on db "
-                        "connection list %s", strerror(ret));
-                /*TODO What if the unlock fails.
-                * Will it lead to deadlock?
-                * Most of the gluster code
-                * no check for unlock or destory of mutex!*/
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
-out:
-        return ret;
-}
-
-
-/*Internal function: Used initialize/map db operation of
- * specified type of db plugin*/
-static int
-init_db_operations (gfdb_db_type_t       gfdb_db_type,
-                    gfdb_db_operations_t *gfdb_db_operations)
-{
-
-        int ret = -1;
-
-        GF_ASSERT (gfdb_db_operations);
-
-        /*Clear the gfdb_db_operations*/
-        gfdb_db_operations = memset(gfdb_db_operations, 0,
-                                        sizeof(*gfdb_db_operations));
-        switch (gfdb_db_type) {
-        case GFDB_SQLITE3:
-                gf_sqlite3_fill_db_operations (gfdb_db_operations);
-                ret = 0;
-                break;
-        case GFDB_HYPERDEX:
-        case GFDB_HASH_FILE_STORE:
-        case GFDB_ROCKS_DB:
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_UNSUPPORTED_PLUGIN, "Plugin not supported");
-                break;
-        case GFDB_INVALID_DB:
-        case GFDB_DB_END:
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INVALID_DB_TYPE, "Invalid DB Type");
-                break;
-        }
-        return ret;
-}
-
-
-/******************************************************************************
- *
- *                      LIBGFDB API Functions
- *
- * ****************************************************************************/
-
-
-/*Libgfdb API Function: Used to initialize a db connection
- *                      (Constructor function for db connection object)
- * Arguments:
- *      args         :  Dictionary containing database specific parameters
- *                      eg: For sqlite3, pagesize, cachesize, db name, db path
-                        etc
- *      gfdb_db_type :  Type of data base used i.e sqlite or hyperdex etc
- * Returns : if successful return the GFDB Connection node to the caller or
- *          NULL in case of failure*/
-gfdb_conn_node_t *
-init_db (dict_t *args, gfdb_db_type_t gfdb_db_type)
-{
-        int ret                                 = -1;
-        gfdb_conn_node_t *_conn_node            = NULL;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-
-        /*Create data base connection object*/
-        _conn_node = GF_CALLOC (1, sizeof(gfdb_conn_node_t),
-                                        gf_mt_db_conn_node_t);
-        if (!_conn_node) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Failed mem alloc for "
-                        "gfdb_conn_node_t");
-                goto alloc_failed;
-        }
-
-        /*Init the list component of db conneciton object*/
-        INIT_LIST_HEAD (&_conn_node->conn_list);
-
-
-        /*Add created connection node to the list*/
-        ret = add_connection_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_ADD_TO_LIST_FAILED, "Failed to add connection "
-                        "node to list");
-                goto _conn_failed;
-        }
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-
-        /*init the db ops object of db connection object*/
-        ret = init_db_operations(gfdb_db_type, db_operations_t);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INIT_DB_FAILED, "Failed initializing database "
-                        "operation failed.");
-                ret = -1;
-                goto init_db_failed;
-        }
-
-        /*Calling the init_db_op of the respected db type*/
-        GF_ASSERT (db_operations_t->init_db_op);
-        ret = db_operations_t->init_db_op (args, &_conn_node->gfdb_connection.
-                                           gf_db_connection);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INIT_DB_FAILED, "Failed initializing database");
-                ret = -1;
-                goto init_db_failed;
-        }
-        _conn_node->gfdb_connection.gfdb_db_type = gfdb_db_type;
-        ret = 0;
-
-        return _conn_node;
-
-        /*****Error Handling********/
-        /* If init_db_operations or init_db of plugin failed delete
-        * conn node from the list.
-        * connection node will be free by delete_conn_node*/
-init_db_failed:
-        ret = delete_conn_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting "
-                        "connection node from list");
-        }
-        return NULL;
-        /*if adding to the list failed free connection node*/
-_conn_failed:
-        GF_FREE (_conn_node);
-        /*if allocation failed*/
-alloc_failed:
-        return NULL;
-        /*****Error Handling********/
-}
-
-
-
-
-
-/*Libgfdb API Function: Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      _conn_node  :  GFDB Connection node
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-fini_db (gfdb_conn_node_t *_conn_node)
-{
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-
-        CHECK_CONN_NODE_GOTO (_conn_node, empty);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-
-        GF_ASSERT (db_operations_t->fini_db_op);
-
-        ret = db_operations_t->fini_db_op(&_conn_node->gfdb_connection.
-                                          gf_db_connection);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_CLOSE_CONNECTION_FAILED, "Failed close the db "
-                        "connection");
-                goto out;
-        }
-
-        ret = delete_conn_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting "
-                        "connection node from list");
-        }
-empty:
-        ret = 0;
-out:
-        return ret;
-}
-
-
-
-
-
-
-/*Libgfdb API Function: Used to insert/update records in the database
- *                      NOTE: In current gfdb_sqlite plugin we use that
- *                      same function to delete the record. Set the
- *                      gfdb_fop_path to GFDB_FOP_UNDEL to delete the
- *                      link of inode from GF_FLINK_TB and
- *                      GFDB_FOP_UNDEL_ALL to delete all the records from
- *                      GF_FLINK_TB and GF_FILE_TB.
- *                      TODO: Should seperate this function into the
- *                      delete_record function
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be inserted/updated
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-insert_record (gfdb_conn_node_t *_conn_node,
-               gfdb_db_record_t *gfdb_db_record)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->insert_record_op) {
-
-                ret = db_operations_t->insert_record_op (gf_db_connection,
-                                                         gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED, "Insert/Update"
-                                " operation failed");
-                }
-        }
-
-        return ret;
-}
-
-
-
-
-/*Libgfdb API Function: Used to delete record from the database
- *                      NOTE: In the current gfdb_sqlite3 plugin
- *                      implementation this function is dummy.
- *                      Use the insert_record function.
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be deleted
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-delete_record (gfdb_conn_node_t *_conn_node,
-               gfdb_db_record_t *gfdb_db_record)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->delete_record_op) {
-
-                ret = db_operations_t->delete_record_op (gf_db_connection,
-                                                         gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DELETE_FAILED, "Delete operation "
-                                "failed");
-                }
-
-        }
-
-        return ret;
-}
-
-/*Libgfdb API Function: Compact the database.
- *
- * Arguments:
- *      _conn_node                      :  GFDB Connection node
- *      _compact_active                 :  Is compaction currently on?
- *      _compact_mode_switched          :  Was the compaction switch flipped?
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active,
-            gf_boolean_t _compact_mode_switched)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->compact_db_op) {
-
-                ret = db_operations_t->compact_db_op (gf_db_connection,
-                                                      _compact_active,
-                                                      _compact_mode_switched);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_COMPACT_FAILED, "Compaction operation "
-                                "failed");
-                }
-
-        }
-
-        return ret;
-}
-
-
-
-
-
-/*Libgfdb API Function: Query all the records from the database
- * Arguments:
- *      _conn_node      : GFDB Connection node
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : number to limit number of rows returned by the query
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_all (gfdb_conn_node_t      *_conn_node,
-          gf_query_callback_t   query_callback,
-          void                  *_query_cbk_args,
-          int                   query_limit)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_all_op) {
-                ret = db_operations_t->find_all_op (gf_db_connection,
-                                                    query_callback,
-                                                    _query_cbk_args,
-                                                    query_limit);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED, "Find all operation "
-                                "failed");
-                }
-
-        }
-
-        return ret;
-}
-
-
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_unchanged_for_time(gfdb_conn_node_t        *_conn_node,
-                        gf_query_callback_t     query_callback,
-                        void                    *_query_cbk_args,
-                        gfdb_time_t             *for_time)
-{
-
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_unchanged_for_time_op) {
-
-                ret = db_operations_t->find_unchanged_for_time_op
-                                (gf_db_connection, query_callback,
-                                _query_cbk_args, for_time);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED, "Find unchanged "
-                                "operation failed");
-                }
-
-        }
-
-        return ret;
-}
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_recently_changed_files(gfdb_conn_node_t    *_conn_node,
-                            gf_query_callback_t query_callback,
-                            void                *_query_cbk_args,
-                            gfdb_time_t         *from_time)
-{
-
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_recently_changed_files_op) {
-
-                ret =  db_operations_t->find_recently_changed_files_op (
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, from_time);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find changed operation failed");
-                }
-
-        }
-
-        return ret;
-
-}
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_unchanged_for_time_freq(gfdb_conn_node_t *_conn_node,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *for_time,
-                                        int write_freq_thresold,
-                                        int read_freq_thresold,
-                                        gf_boolean_t _clear_counters)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_unchanged_for_time_freq_op) {
-
-                ret = db_operations_t->find_unchanged_for_time_freq_op(
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, for_time,
-                                write_freq_thresold, read_freq_thresold,
-                                _clear_counters);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find unchanged with freq operation failed");
-                }
-
-        }
-
-        return ret;
-}
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_recently_changed_files_freq(gfdb_conn_node_t *_conn_node,
-                                gf_query_callback_t query_callback,
-                                void *_query_cbk_args,
-                                gfdb_time_t *from_time,
-                                int write_freq_thresold,
-                                int read_freq_thresold,
-                                gf_boolean_t _clear_counters)
-{
-
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_recently_changed_files_freq_op) {
-
-                ret =  db_operations_t->find_recently_changed_files_freq_op(
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, from_time,
-                                write_freq_thresold, read_freq_thresold,
-                                _clear_counters);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find changed with freq operation failed");
-                }
-
-        }
-
-        return ret;
-
-}
-
-
-
-/*Libgfdb API Function: Clear the heat for all the files
- *
- *  Arguments:
- *    conn_node              : GFDB Connection node
- *
- * Returns : if successful return 0 or
- *           -ve value in case of failure
- **/
-
-int
-clear_files_heat (gfdb_conn_node_t *conn_node)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->clear_files_heat_op) {
-                ret =  db_operations->clear_files_heat_op (gf_db_connection);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED,
-                                "Clear files heat operation failed");
-                }
-        }
-
-        return ret;
-}
-
-
-/* Libgfdb API Function: Function to extract version of the db
- * Input:
- * gfdb_conn_node_t *conn_node        : GFDB Connection node
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the lenght of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-get_db_version (gfdb_conn_node_t *conn_node, char **version)
-{
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->get_db_version) {
-                ret =  db_operations->get_db_version (gf_db_connection,
-                                                      version);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Get version failed");
-                }
-        }
-
-        return ret;
-}
-
-int
-get_db_params (gfdb_conn_node_t *conn_node, char *param_key,
-                char **param_value)
-{
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->get_db_params) {
-                ret =  db_operations->get_db_params (gf_db_connection,
-                                                     param_key,
-                                                     param_value);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Get setting failed");
-                }
-        }
-
-        return ret;
-}
-
-
-int
-set_db_params (gfdb_conn_node_t *conn_node, char *param_key,
-                char *param_value)
-{
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->set_db_params) {
-                ret =  db_operations->set_db_params (gf_db_connection,
-                                                     param_key,
-                                                     param_value);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED,
-                                "Failed to set database setting");
-                }
-        }
-
-        return ret;
-}
-
-
-
-
-static const
-char *get_db_path_key()
-{
-        return GFDB_SQL_PARAM_DBPATH;
-}
-
-void get_gfdb_methods (gfdb_methods_t *methods)
-{
-        methods->init_db = init_db;
-        methods->fini_db = fini_db;
-        methods->find_all = find_all;
-        methods->find_unchanged_for_time = find_unchanged_for_time;
-        methods->find_recently_changed_files = find_recently_changed_files;
-        methods->find_unchanged_for_time_freq = find_unchanged_for_time_freq;
-        methods->find_recently_changed_files_freq =
-                                               find_recently_changed_files_freq;
-        methods->clear_files_heat = clear_files_heat;
-        methods->get_db_version = get_db_version;
-        methods->get_db_params = get_db_params;
-        methods->set_db_params = set_db_params;
-        methods->get_db_path_key = get_db_path_key;
-
-        /* Query Record related functions */
-        methods->gfdb_query_record_new = gfdb_query_record_new;
-        methods->gfdb_query_record_free = gfdb_query_record_free;
-        methods->gfdb_add_link_to_query_record = gfdb_add_link_to_query_record;
-        methods->gfdb_write_query_record = gfdb_write_query_record;
-        methods->gfdb_read_query_record = gfdb_read_query_record;
-
-        /* Link info related functions */
-        methods->gfdb_link_info_new = gfdb_link_info_new;
-        methods->gfdb_link_info_free = gfdb_link_info_free;
-
-        /* Compaction related functions */
-        methods->compact_db = compact_db;
-}
-
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.h b/libglusterfs/src/gfdb/gfdb_data_store.h
deleted file mode 100644
index beb954c190a..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store.h
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_H
-#define __GFDB_DATA_STORE_H
-
-
-#include "glusterfs.h"
-#include "xlator.h"
-#include "logging.h"
-#include "common-utils.h"
-#include <time.h>
-#include <sys/time.h>
-
-#include "gfdb_data_store_types.h"
-
-/* GFDB Connection Node:
- * ~~~~~~~~~~~~~~~~~~~~
- * Represents the connection to the database while using libgfdb
- * The connection node is not thread safe as far as fini_db is concerned.
- * You can use a single connection node
- * to do multithreaded db operations like insert/delete/find of records.
- * But you need to wait for all the operating threads to complete i.e
- * pthread_join() and then do fini_db() to kill the connection node.
- * gfdb_conn_node_t is an opaque structure.
- * */
-typedef struct gfdb_conn_node_t gfdb_conn_node_t;
-
-
-
-
-/*Libgfdb API Function: Used to initialize db connection
- * Arguments:
- *      args         :  Dictionary containing database specific parameters
- *                      eg: For sqlite3, pagesize, cachesize, db name, db path
-                        etc
- *      gfdb_db_type :  Type of data base used i.e sqlite or hyperdex etc
- * Returns : if successful return the GFDB Connection Node to the caller or
- *          NULL value in case of failure*/
-gfdb_conn_node_t *
-init_db(dict_t *arg, gfdb_db_type_t db_type);
-
-typedef gfdb_conn_node_t * (*init_db_t) (dict_t *args,
-                                         gfdb_db_type_t gfdb_db_type);
-
-
-
-
-/*Libgfdb API Function: Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      _conn_node  :  DB Connection Index of the DB Connection
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-fini_db(gfdb_conn_node_t *);
-
-typedef int (*fini_db_t) (gfdb_conn_node_t *_conn_node);
-
-
-
-/*Libgfdb API Function: Used to insert/updated records in the database
- *                      NOTE: In current gfdb_sqlite plugin we use that
- *                      same function to delete the record. Set the
- *                      gfdb_fop_path to GFDB_FOP_UNDEL to delete the
- *                      link of inode from GF_FLINK_TB and
- *                      GFDB_FOP_UNDEL_ALL to delete all the records from
- *                      GF_FLINK_TB and GF_FILE_TB.
- *                      TODO: Should seperate this function into the
- *                      delete_record function
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be inserted/updated
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-insert_record(gfdb_conn_node_t *, gfdb_db_record_t *gfdb_db_record);
-
-
-
-
-/*Libgfdb API Function: Used to delete record from the database
- *                      NOTE: In the current gfdb_sqlite3 plugin
- *                      implementation this function is dummy.
- *                      Use the insert_record function.
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be deleted
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-delete_record(gfdb_conn_node_t *, gfdb_db_record_t *gfdb_db_record);
-
-
-
-
-
-/*Libgfdb API Function: Query all the records from the database
- * Arguments:
- *      _conn_node      : GFDB Connection node
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : 0 - umlimited,
- *                        any positive value - adds the LIMIT clause
- *                        to the SQL query
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int find_all(gfdb_conn_node_t *, gf_query_callback_t query_callback,
-                void *_query_cbk_args,
-                int query_limit);
-
-typedef int (*find_all_t) (gfdb_conn_node_t *,
-                           gf_query_callback_t query_callback,
-                           void *_query_cbk_args,
-                           int query_limit);
-
-
-
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int find_unchanged_for_time(gfdb_conn_node_t *,
-                        gf_query_callback_t query_callback,
-                        void *_query_cbk_args, gfdb_time_t *for_time);
-
-typedef int (*find_unchanged_for_time_t) (gfdb_conn_node_t *_conn_node,
-                                          gf_query_callback_t query_callback,
-                                          void *_query_cbk_args,
-                                          gfdb_time_t *for_time);
-
-
-
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int find_recently_changed_files(gfdb_conn_node_t *_conn,
-                gf_query_callback_t query_callback, void *_query_cbk_args,
-                gfdb_time_t *from_time);
-
-typedef int (*find_recently_changed_files_t) (gfdb_conn_node_t *_conn_node,
-                                              gf_query_callback_t query_callback,
-                                              void *_query_cbk_args,
-                                              gfdb_time_t *from_time);
-
-
-
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int find_unchanged_for_time_freq(gfdb_conn_node_t *_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *for_time,
-                                        int write_freq_thresold,
-                                        int read_freq_thresold,
-                                        gf_boolean_t _clear_counters);
-
-typedef int (*find_unchanged_for_time_freq_t) (gfdb_conn_node_t *_conn_node,
-                                               gf_query_callback_t query_callback,
-                                               void *_query_cbk_args,
-                                               gfdb_time_t *for_time,
-                                               int write_freq_thresold,
-                                               int read_freq_thresold,
-                                               gf_boolean_t _clear_counters);
-
-
-
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int find_recently_changed_files_freq(gfdb_conn_node_t *_conn,
-                                gf_query_callback_t query_callback,
-                                void *_query_cbk_args,
-                                gfdb_time_t *from_time,
-                                int write_freq_thresold,
-                                int read_freq_thresold,
-                                gf_boolean_t _clear_counters);
-
-typedef int (*find_recently_changed_files_freq_t) (gfdb_conn_node_t *_conn_node,
-                                                   gf_query_callback_t query_callback,
-                                                   void *_query_cbk_args,
-                                                   gfdb_time_t *from_time,
-                                                   int write_freq_thresold,
-                                                   int read_freq_thresold,
-                                                   gf_boolean_t _clear_counters);
-
-typedef const
-char *(*get_db_path_key_t)();
-
-/*Libgfdb API Function: Clear the heat for all the files
- *
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure
- **/
-int
-clear_files_heat (gfdb_conn_node_t *_conn_node);
-
-typedef int (*clear_files_heat_t) (gfdb_conn_node_t *_conn_node);
-
-
-
-/* Libgfdb API Function: Function to extract version of the db
- *  Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char **version  : the version is extracted as a string
- *                   and will be stored in this variable.
- *                   The freeing of the memory should be done by the caller.
- * Return:
- *      On success return the length of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-get_db_version (gfdb_conn_node_t *_conn_node, char **version);
-
-typedef int (*get_db_version_t)(gfdb_conn_node_t *_conn_node,
-                                        char **version);
-
-
-/* Libgfdb API Function: Function to extract param from the db
- *  Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char *param_key     : param to be extracted
- *      char **param_value  : the value of the param that is
- *                       extracted. This function will allocate memory
- *                       to pragma_value. The caller should free the memory.
- * Return:
- *      On success return the lenght of the param value that is
- *      extracted.
- *      On failure return -1
- * */
-int
-get_db_params (gfdb_conn_node_t *_conn_node,
-                char *param_key,
-                char **param_value);
-
-typedef int (*get_db_params_t)(gfdb_conn_node_t *db_conn,
-                                     char *param_key,
-                                     char **param_value);
-
-
-/* Libgfdb API Function: Function to set db params
- * Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char *param_key     : param to be set
- * char *param_value  : param value
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-set_db_params (gfdb_conn_node_t *_conn_node,
-                char *param_key,
-                char *param_value);
-
-typedef int (*set_db_params_t)(gfdb_conn_node_t *db_conn,
-                                     char *param_key,
-                                     char *param_value);
-
-/*Libgfdb API Function: Compact the database.
- *
- * Arguments:
- *      _conn_node                      :  GFDB Connection node
- *      _compact_active                 :  Is compaction currently on?
- *      _compact_mode_switched          :  Was the compaction switch flipped?
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active,
-            gf_boolean_t _compact_mode_switched);
-
-typedef int (*compact_db_t)(gfdb_conn_node_t *db_conn,
-                            gf_boolean_t compact_active,
-                            gf_boolean_t compact_mode_switched);
-
-
-typedef struct gfdb_methods_s {
-        init_db_t                       init_db;
-        fini_db_t                       fini_db;
-        find_all_t                      find_all;
-        find_unchanged_for_time_t       find_unchanged_for_time;
-        find_recently_changed_files_t   find_recently_changed_files;
-        find_unchanged_for_time_freq_t  find_unchanged_for_time_freq;
-        find_recently_changed_files_freq_t find_recently_changed_files_freq;
-        clear_files_heat_t              clear_files_heat;
-        get_db_version_t                get_db_version;
-        get_db_params_t                 get_db_params;
-        set_db_params_t                 set_db_params;
-        /* Do not expose dbpath directly. Expose it via an */
-        /* access function: get_db_path_key(). */
-        char                            *dbpath;
-        get_db_path_key_t               get_db_path_key;
-
-        /* Query Record related functions */
-        gfdb_query_record_new_t         gfdb_query_record_new;
-        gfdb_query_record_free_t        gfdb_query_record_free;
-        gfdb_add_link_to_query_record_t gfdb_add_link_to_query_record;
-        gfdb_write_query_record_t       gfdb_write_query_record;
-        gfdb_read_query_record_t        gfdb_read_query_record;
-
-        /* Link info related functions */
-        gfdb_link_info_new_t            gfdb_link_info_new;
-        gfdb_link_info_free_t           gfdb_link_info_free;
-
-        /* Compaction related functions */
-        compact_db_t                    compact_db;
-} gfdb_methods_t;
-
-void get_gfdb_methods (gfdb_methods_t *methods);
-
-typedef void (*get_gfdb_methods_t) (gfdb_methods_t *methods);
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.c b/libglusterfs/src/gfdb/gfdb_data_store_helper.c
deleted file mode 100644
index fba5ec5a252..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_helper.c
+++ /dev/null
@@ -1,612 +0,0 @@
-
-#include "gfdb_data_store_helper.h"
-#include "syscall.h"
-
-/******************************************************************************
- *
- *                       Query record related functions
- *
- * ****************************************************************************/
-
-/*Create a single link info structure*/
-gfdb_link_info_t*
-gfdb_link_info_new ()
-{
-        gfdb_link_info_t *link_info = NULL;
-
-        link_info = GF_CALLOC (1, sizeof(gfdb_link_info_t),
-                                        gf_mt_gfdb_link_info_t);
-        if (!link_info) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Memory allocation failed for "
-                        "link_info ");
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&link_info->list);
-
-out:
-
-        return link_info;
-}
-
-/*Destroy a link info structure*/
-void
-gfdb_link_info_free(gfdb_link_info_t *link_info)
-{
-        GF_FREE (link_info);
-}
-
-
-/*Function to create the query_record*/
-gfdb_query_record_t *
-gfdb_query_record_new()
-{
-        int ret = -1;
-        gfdb_query_record_t *query_record = NULL;
-
-        query_record = GF_CALLOC (1, sizeof(gfdb_query_record_t),
-                                        gf_mt_gfdb_query_record_t);
-        if (!query_record) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Memory allocation failed for "
-                        "query_record ");
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&query_record->link_list);
-
-        ret = 0;
-out:
-        if (ret == -1) {
-                GF_FREE (query_record);
-        }
-        return query_record;
-}
-
-
-/*Function to delete a single linkinfo from list*/
-static void
-gfdb_delete_linkinfo_from_list (gfdb_link_info_t **link_info)
-{
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, link_info, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, *link_info, out);
-
-        /*Remove hard link from list*/
-        list_del(&(*link_info)->list);
-        gfdb_link_info_free (*link_info);
-        link_info = NULL;
-out:
-        return;
-}
-
-
-/*Function to destroy link_info list*/
-void
-gfdb_free_link_info_list (gfdb_query_record_t *query_record)
-{
-        gfdb_link_info_t        *link_info = NULL;
-        gfdb_link_info_t        *temp = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-        list_for_each_entry_safe(link_info, temp,
-                        &query_record->link_list, list)
-        {
-                gfdb_delete_linkinfo_from_list (&link_info);
-                link_info = NULL;
-        }
-
-out:
-        return;
-}
-
-
-
-/* Function to add linkinfo to the query record */
-int
-gfdb_add_link_to_query_record (gfdb_query_record_t      *query_record,
-                           uuid_t                   pgfid,
-                           char               *base_name)
-{
-        int ret                                 = -1;
-        gfdb_link_info_t *link_info             = NULL;
-        int base_name_len                       = 0;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, pgfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, base_name, out);
-
-        link_info = gfdb_link_info_new ();
-        if (!link_info) {
-                goto out;
-        }
-
-        gf_uuid_copy (link_info->pargfid, pgfid);
-        base_name_len = strlen (base_name);
-        memcpy (link_info->file_name, base_name, base_name_len);
-        link_info->file_name[base_name_len] = '\0';
-
-        list_add_tail (&link_info->list,
-                        &query_record->link_list);
-
-        query_record->link_count++;
-
-        ret = 0;
-out:
-        if (ret) {
-                gfdb_link_info_free (link_info);
-                link_info = NULL;
-        }
-        return ret;
-}
-
-
-
-/*Function to destroy query record*/
-void
-gfdb_query_record_free(gfdb_query_record_t *query_record)
-{
-        if (query_record) {
-                gfdb_free_link_info_list (query_record);
-                GF_FREE (query_record);
-        }
-}
-
-
-/******************************************************************************
-                SERIALIZATION/DE-SERIALIZATION OF QUERY RECORD
-*******************************************************************************/
-/******************************************************************************
- The on disk format of query record is as follows,
-
-+---------------------------------------------------------------------------+
-| Length of serialized query record |       Serialized Query Record         |
-+---------------------------------------------------------------------------+
-             4 bytes                     Length of serialized query record
-                                                      |
-                                                      |
-     -------------------------------------------------|
-     |
-     |
-     V
-   Serialized Query Record Format:
-   +---------------------------------------------------------------------------+
-   | GFID |  Link count   |  <LINK INFO>  |.....                      | FOOTER |
-   +---------------------------------------------------------------------------+
-     16 B        4 B         Link Length                                  4 B
-                                |                                          |
-                                |                                          |
-   -----------------------------|                                          |
-   |                                                                       |
-   |                                                                       |
-   V                                                                       |
-   Each <Link Info> will be serialized as                                  |
-   +-----------------------------------------------+                       |
-   | PGID | BASE_NAME_LENGTH |      BASE_NAME      |                       |
-   +-----------------------------------------------+                       |
-     16 B       4 B             BASE_NAME_LENGTH                           |
-                                                                           |
-                                                                           |
-   ------------------------------------------------------------------------|
-   |
-   |
-   V
-   FOOTER is a magic number 0xBAADF00D indicating the end of the record.
-   This also serves as a serialized schema validator.
- * ****************************************************************************/
-
-#define GFDB_QUERY_RECORD_FOOTER 0xBAADF00D
-#define UUID_LEN                 16
-
-/*Function to get the potential length of the serialized buffer*/
-static int32_t
-gfdb_query_record_serialized_length (gfdb_query_record_t *query_record)
-{
-        int32_t len                         = -1;
-        gfdb_link_info_t *link_info     = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-        /* Length of GFID */
-        len = UUID_LEN;
-
-        /* length of number of links*/
-        len += sizeof (int32_t);
-
-        list_for_each_entry (link_info, &query_record->link_list, list) {
-
-                /* length of PFID */
-                len += UUID_LEN;
-
-                /* Add size of base name length*/
-                len += sizeof (int32_t);
-
-                /* Length of base_name */
-                len += strlen (link_info->file_name);
-
-        }
-
-        /* length of footer */
-        len += sizeof (int32_t);
-out:
-        return len;
-}
-
-/* Function for serializing query record.
- *
- * Query Record Serialization Format
- * +---------------------------------------------------------------------------+
- * | GFID |  Link count   |  <LINK INFO>  |.....                      | FOOTER |
- * +---------------------------------------------------------------------------+
- *   16 B        4 B         Link Length                                  4 B
- *
- *
- * Each <Link Info> will be serialized as
- * +-----------------------------------------------+
- * | PGID | BASE_NAME_LENGTH |      BASE_NAME      |
- * +-----------------------------------------------+
- *   16 B       4 B             BASE_NAME_LENGTH
- *
- *
- * FOOTER is a magic number 0xBAADF00D indicating the end of the record.
- * This also serves as a serialized schema validator.
- *
- * The function will allocate memory to the serialized buffer,
- * the caller needs to free it.
- * Returns the length of the serialized buffer on success
- * or -1 on failure.
- *
- * */
-static int
-gfdb_query_record_serialize (gfdb_query_record_t *query_record,
-                             char **in_buffer)
-{
-        gfdb_link_info_t *link_info     = NULL;
-        int              count          = -1;
-        int              base_name_len  = 0;
-        int              buffer_length  = 0;
-        int              footer         = GFDB_QUERY_RECORD_FOOTER;
-        char             *buffer        = NULL;
-        char             *ret_buffer    = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE,
-                             (query_record->link_count > 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out);
-
-
-        /* Calculate the total length of the serialized buffer */
-        buffer_length = gfdb_query_record_serialized_length (query_record);
-        if (buffer_length <= 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to calculate the length of "
-                        "serialized buffer");
-                goto out;
-        }
-
-        /* Allocate memory to the serialized buffer */
-        ret_buffer = GF_CALLOC (1, buffer_length,  gf_common_mt_char);
-        if (!ret_buffer) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Memory allocation failed for "
-                        "serialized buffer.");
-                goto out;
-        }
-
-        buffer = ret_buffer;
-
-        count = 0;
-
-        /* Copying the GFID */
-        memcpy (buffer, query_record->gfid, UUID_LEN);
-        buffer += UUID_LEN;
-        count += UUID_LEN;
-
-        /* Copying the number of links */
-        memcpy (buffer, &query_record->link_count, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
-
-        list_for_each_entry (link_info, &query_record->link_list, list) {
-
-                /* Copying the PFID */
-                memcpy(buffer, link_info->pargfid, UUID_LEN);
-                buffer += UUID_LEN;
-                count += UUID_LEN;
-
-                /* Copying base name length*/
-                base_name_len = strlen (link_info->file_name);
-                memcpy (buffer, &base_name_len, sizeof (int32_t));
-                buffer += sizeof (int32_t);
-                count += sizeof (int32_t);
-
-                /* Length of base_name */
-                memcpy(buffer, link_info->file_name, base_name_len);
-                buffer += base_name_len;
-                count += base_name_len;
-
-        }
-
-        /* Copying the Footer of the record */
-        memcpy (buffer, &footer, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
-
-out:
-        if (count < 0) {
-                GF_FREE (ret_buffer);
-                ret_buffer = NULL;
-        }
-        *in_buffer = ret_buffer;
-        return count;
-}
-
-static gf_boolean_t
-is_serialized_buffer_valid (char *in_buffer, int buffer_length) {
-        gf_boolean_t    ret        = _gf_false;
-        int             footer     = 0;
-
-        /* Read the footer */
-        in_buffer += (buffer_length - sizeof (int32_t));
-        memcpy (&footer, in_buffer, sizeof (int32_t));
-
-        /*
-         * if the footer is not GFDB_QUERY_RECORD_FOOTER
-         * then the serialized record is invalid
-         *
-         * */
-        if (footer != GFDB_QUERY_RECORD_FOOTER) {
-                goto out;
-        }
-
-        ret = _gf_true;
-out:
-        return ret;
-}
-
-
-static int
-gfdb_query_record_deserialize (char *in_buffer,
-                               int buffer_length,
-                               gfdb_query_record_t **query_record)
-{
-        int ret                                 = -1;
-        char *buffer                            = NULL;
-        int i                                   = 0;
-        gfdb_link_info_t *link_info             = NULL;
-        int count                               = 0;
-        int base_name_len                       = 0;
-        gfdb_query_record_t *ret_qrecord        = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (buffer_length > 0), out);
-
-        if (!is_serialized_buffer_valid (in_buffer, buffer_length)) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Invalid serialized query record");
-                goto out;
-        }
-
-        buffer = in_buffer;
-
-        ret_qrecord = gfdb_query_record_new ();
-        if (!ret_qrecord) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to allocate space to "
-                        "gfdb_query_record_t");
-                goto out;
-        }
-
-        /* READ GFID */
-        memcpy ((ret_qrecord)->gfid, buffer, UUID_LEN);
-        buffer += UUID_LEN;
-        count += UUID_LEN;
-
-        /* Read the number of link */
-        memcpy (&(ret_qrecord->link_count), buffer, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
-
-        /* Read all the links */
-        for (i = 0; i < ret_qrecord->link_count; i++) {
-                if (count >= buffer_length) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Invalid serialized "
-                                "query record");
-                        ret = -1;
-                        goto out;
-                }
-
-                link_info = gfdb_link_info_new ();
-                if (!link_info) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed to create link_info");
-                        goto out;
-                }
-
-                /* READ PGFID */
-                memcpy (link_info->pargfid, buffer, UUID_LEN);
-                buffer += UUID_LEN;
-                count += UUID_LEN;
-
-                /* Read base name length */
-                memcpy (&base_name_len, buffer, sizeof (int32_t));
-                buffer += sizeof (int32_t);
-                count += sizeof (int32_t);
-
-                /* READ basename */
-                memcpy (link_info->file_name, buffer, base_name_len);
-                buffer += base_name_len;
-                count += base_name_len;
-                link_info->file_name[base_name_len] = '\0';
-
-                /* Add link_info to the list */
-                list_add_tail (&link_info->list,
-                               &(ret_qrecord->link_list));
-
-                /* Reseting link_info */
-                link_info = NULL;
-        }
-
-        ret = 0;
-out:
-        if (ret) {
-                gfdb_query_record_free (ret_qrecord);
-                ret_qrecord = NULL;
-        }
-        *query_record = ret_qrecord;
-        return ret;
-}
-
-
-
-
-
-/* Function to write query record to file
- *
- * Disk format
- * +---------------------------------------------------------------------------+
- * | Length of serialized query record |       Serialized Query Record         |
- * +---------------------------------------------------------------------------+
- *            4 bytes                     Length of serialized query record
- *
- * Please refer gfdb_query_record_serialize () for format of
- * Serialized Query Record
- *
- * */
-int
-gfdb_write_query_record (int fd,
-                        gfdb_query_record_t *query_record)
-{
-        int ret                 = -1;
-        int buffer_len          = 0;
-        char *buffer            = NULL;
-        int write_len           = 0;
-        char *write_buffer      = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-        buffer_len = gfdb_query_record_serialize (query_record, &buffer);
-        if (buffer_len < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to serialize query record");
-                goto out;
-        }
-
-        /* Serialize the buffer length and write to file */
-        ret = write (fd, &buffer_len, sizeof (int32_t));
-        if (ret < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed to write buffer length"
-                                " to file");
-                goto out;
-        }
-
-        /* Write the serialized query record to file */
-        write_len = buffer_len;
-        write_buffer = buffer;
-        while ((ret = write (fd, write_buffer, write_len)) <  write_len) {
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno,
-                                LG_MSG_DB_ERROR, "Failed to write serialized "
-                                "query record to file");
-                        goto out;
-                }
-
-                write_buffer += ret;
-                write_len -= ret;
-        }
-
-        ret = 0;
-out:
-        GF_FREE (buffer);
-        return ret;
-}
-
-
-
-/* Function to read query record from file.
- * Allocates memory to query record and
- * returns length of serialized query record when successful
- * Return -1 when failed.
- * Return 0 when reached EOF.
- * */
-int
-gfdb_read_query_record (int fd,
-                        gfdb_query_record_t **query_record)
-{
-        int ret                 = -1;
-        int buffer_len          = 0;
-        int read_len            = 0;
-        char *buffer            = NULL;
-        char *read_buffer       = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-
-        /* Read serialized query record length from the file*/
-        ret = sys_read (fd, &buffer_len, sizeof (int32_t));
-        if (ret < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed reading buffer length"
-                                " from file");
-                goto out;
-        }
-        /* EOF */
-        else if (ret == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        /* Allocating memory to the serialization buffer */
-        buffer = GF_CALLOC (1, buffer_len,  gf_common_mt_char);
-        if (!buffer) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to allocate space to "
-                        "serialized buffer");
-                goto out;
-        }
-
-
-        /* Read the serialized query record from file */
-        read_len = buffer_len;
-        read_buffer = buffer;
-        while ((ret = sys_read (fd, read_buffer, read_len)) < read_len) {
-
-                /*Any error */
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno,
-                                LG_MSG_DB_ERROR, "Failed to read serialized "
-                                "query record from file");
-                        goto out;
-                }
-                /* EOF */
-                else if (ret == 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Invalid query record or "
-                                "corrupted query file");
-                        ret = -1;
-                        goto out;
-                }
-
-                read_buffer += ret;
-                read_len -= ret;
-        }
-
-        ret = gfdb_query_record_deserialize (buffer, buffer_len,
-                                             query_record);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to de-serialize query record");
-                goto out;
-        }
-
-        ret = buffer_len;
-out:
-        GF_FREE (buffer);
-        return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.h b/libglusterfs/src/gfdb/gfdb_data_store_helper.h
deleted file mode 100644
index ce1f1c52281..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_helper.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_HELPER_H
-#define __GFDB_DATA_STORE_HELPER_H
-
-#include <time.h>
-#include <sys/time.h>
-#include <string.h>
-#include <fcntl.h>
-
-#include "common-utils.h"
-#include "compat-uuid.h"
-#include "gfdb_mem-types.h"
-#include "dict.h"
-#include "byte-order.h"
-#include "libglusterfs-messages.h"
-
-
-#define GFDB_DATA_STORE               "gfdbdatastore"
-
-/*******************************************************************************
- *
- *                     Query related data structure and functions
- *
- * ****************************************************************************/
-
-#ifdef NAME_MAX
-#define GF_NAME_MAX NAME_MAX
-#else
-#define GF_NAME_MAX 255
-#endif
-
-/*Structure to hold the link information*/
-typedef struct gfdb_link_info {
-        uuid_t                          pargfid;
-        char                            file_name[GF_NAME_MAX];
-        struct list_head                list;
-} gfdb_link_info_t;
-
-
-/*Structure used for querying purpose*/
-typedef struct gfdb_query_record {
-        uuid_t                          gfid;
-        /*This is the hardlink list*/
-        struct list_head                link_list;
-        int                             link_count;
-} gfdb_query_record_t;
-
-/*Create a single link info structure*/
-gfdb_link_info_t *gfdb_link_info_new ();
-typedef gfdb_link_info_t *(*gfdb_link_info_new_t) ();
-
-/*Destroy a link info structure*/
-void
-gfdb_link_info_free (gfdb_link_info_t *gfdb_link_info);
-typedef void
-(*gfdb_link_info_free_t) (gfdb_link_info_t *gfdb_link_info);
-
-/* Function to create the query_record */
-gfdb_query_record_t *
-gfdb_query_record_new();
-typedef gfdb_query_record_t *
-(*gfdb_query_record_new_t)();
-
-
-
-
-/* Fuction to add linkinfo to query record */
-int
-gfdb_add_link_to_query_record (gfdb_query_record_t      *gfdb_query_record,
-                           uuid_t                   pgfid,
-                           char               *base_name);
-typedef int
-(*gfdb_add_link_to_query_record_t) (gfdb_query_record_t *, uuid_t, char *);
-
-
-
-
-/*Function to destroy query record*/
-void
-gfdb_query_record_free (gfdb_query_record_t *gfdb_query_record);
-typedef void
-(*gfdb_query_record_free_t) (gfdb_query_record_t *);
-
-
-
-
-
-
-/* Function to write query record to file */
-int
-gfdb_write_query_record (int fd,
-                        gfdb_query_record_t *gfdb_query_record);
-typedef int
-(*gfdb_write_query_record_t) (int, gfdb_query_record_t *);
-
-
-
-
-
-/* Function to read query record from file.
- * Allocates memory to query record and return 0 when successful
- * Return -1 when failed.
- * Return 0 when EOF.
- * */
-int
-gfdb_read_query_record (int fd,
-                        gfdb_query_record_t **gfdb_query_record);
-typedef int
-(*gfdb_read_query_record_t) (int, gfdb_query_record_t **);
-
-
-#endif
-\ No newline at end of file
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_types.h b/libglusterfs/src/gfdb/gfdb_data_store_types.h
deleted file mode 100644
index 3add890b047..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_types.h
+++ /dev/null
@@ -1,592 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_TYPE_H
-#define __GFDB_DATA_STORE_TYPE_H
-
-#include "gfdb_data_store_helper.h"
-
-/*
- * Helps in dynamically choosing log level
- * */
-static inline gf_loglevel_t
-_gfdb_log_level (gf_loglevel_t given_level,
-                 gf_boolean_t ignore_level)
-{
-        return (ignore_level) ? GF_LOG_DEBUG : given_level;
-}
-
-typedef enum gf_db_operation {
-        GFDB_INVALID_DB_OP = -1,
-        /* Query DB OPS : All the Query DB_OP should be added */
-        /* in between START and END */
-        GFDB_QUERY_DB_OP_START, /* Start of Query DB_OP  */
-        GFDB_QUERY_DB_OP,
-        GF_FTABLE_EXISTS_DB_OP,
-        GFDB_QUERY_DB_OP_END, /* End of Query DB_OP */
-        /* Non-Query DB OPS */
-        GFDB_DB_CREATE_DB_OP,
-        GFDB_GFID_EXIST_DB_OP,
-        GFDB_W_INSERT_DB_OP,
-        GFDB_WU_INSERT_DB_OP,
-        GFDB_W_UPDATE_DB_OP,
-        GFDB_WU_UPDATE_DB_OP,
-        GFDB_W_DELETE_DB_OP,
-        GFDB_UW_DELETE_DB_OP,
-        GFDB_WFC_UPDATE_DB_OP,
-        GFDB_RFC_UPDATE_DB_OP,
-        GFDB_DB_COMPACT_DB_OP /* Added for VACUUM/manual compaction support */
-} gf_db_operation_t;
-
-
-#define GF_COL_MAX_NUM                  2
-#define GF_COL_ALL                      " * "
-
-/* Column/fields names used in the DB.
- * If any new field is added should be updated here*/
-#define GF_COL_GF_ID                    "GF_ID"
-#define GF_COL_GF_PID                   "GF_PID"
-#define GF_COL_FILE_NAME                "FNAME"
-#define GF_COL_WSEC                     "W_SEC"
-#define GF_COL_WMSEC                    "W_MSEC"
-#define GF_COL_UWSEC                    "UW_SEC"
-#define GF_COL_UWMSEC                   "UW_MSEC"
-#define GF_COL_WSEC_READ                "W_READ_SEC"
-#define GF_COL_WMSEC_READ               "W_READ_MSEC"
-#define GF_COL_UWSEC_READ               "UW_READ_SEC"
-#define GF_COL_UWMSEC_READ              "UW_READ_MSEC"
-#define GF_COL_WDEL_FLAG                "W_DEL_FLAG"
-#define GF_COL_WRITE_FREQ_CNTR          "WRITE_FREQ_CNTR"
-#define GF_COL_READ_FREQ_CNTR           "READ_FREQ_CNTR"
-#define GF_COL_LINK_UPDATE              "LINK_UPDATE"
-
-
-/***********************Time related********************************/
-/*1 sec = 1000000 microsec*/
-#define GFDB_MICROSEC         1000000
-
-/*All the gfdb times are represented using this structure*/
-typedef  struct timeval gfdb_time_t;
-
-/*Convert time into  seconds*/
-static inline uint64_t
-gfdb_time_2_usec(gfdb_time_t *gfdb_time)
-{
-        GF_ASSERT(gfdb_time);
-        return ((uint64_t) gfdb_time->tv_sec * GFDB_MICROSEC) + gfdb_time->tv_usec;
-}
-
-/******************************************************************************
- *
- *              Insert/Update Record related data structures/functions
- *
- * ****************************************************************************/
-
-/*Indicated a generic synchronous write to the db
- * This may or may not be implemented*/
-typedef enum gfdb_sync_type {
-        GFDB_INVALID_SYNC = -1,
-        GFDB_DB_ASYNC,
-        GFDB_DB_SYNC
-} gfdb_sync_type_t;
-
-/*Strings related to the abvove sync type*/
-#define GFDB_STR_DB_ASYNC        "async"
-#define GFDB_STR_DB_SYNC         "sync"
-
-/*To convert sync type from string to gfdb_sync_type_t*/
-static inline int
-gf_string2gfdbdbsync (char *sync_option)
-{
-        int ret = -1;
-
-        if (!sync_option)
-                goto out;
-        if (strcmp(sync_option, GFDB_STR_DB_ASYNC) == 0) {
-                ret = GFDB_DB_ASYNC;
-        } else if (strcmp(sync_option, GFDB_STR_DB_SYNC) == 0) {
-                ret = GFDB_DB_SYNC;
-        }
-out:
-        return ret;
-}
-
-/*Indicated different types of db*/
-typedef enum gfdb_db_type {
-        GFDB_INVALID_DB = -1,
-        GFDB_HASH_FILE_STORE,
-        GFDB_ROCKS_DB,
-        GFDB_SQLITE3,
-        GFDB_HYPERDEX,
-        GFDB_DB_END /*Add DB type Entries above this only*/
-} gfdb_db_type_t;
-
-/*String related to the db types*/
-#define GFDB_STR_HASH_FILE_STORE      "hashfile"
-#define GFDB_STR_ROCKS_DB             "rocksdb"
-#define GFDB_STR_SQLITE3              "sqlite3"
-#define GFDB_STR_HYPERDEX             "hyperdex"
-
-/*Convert db type in string to gfdb_db_type_t*/
-static inline int
-gf_string2gfdbdbtype (char *db_option)
-{
-        int ret = -1;
-
-        if (!db_option)
-                goto out;
-        if (strcmp(db_option, GFDB_STR_HASH_FILE_STORE) == 0) {
-                ret = GFDB_HASH_FILE_STORE;
-        } else if (strcmp(db_option, GFDB_STR_ROCKS_DB) == 0) {
-                ret = GFDB_ROCKS_DB;
-        } else if (strcmp(db_option, GFDB_STR_SQLITE3) == 0) {
-                ret = GFDB_SQLITE3;
-        } else if (strcmp(db_option, GFDB_STR_HYPERDEX) == 0) {
-                ret = GFDB_HYPERDEX;
-        }
-out:
-        return ret;
-}
-
-/*Tells the path of the fop*/
-typedef enum gfdb_fop_path {
-        GFDB_FOP_INVALID = -1,
-        /*Filler value for zero*/
-        GFDB_FOP_PATH_ZERO = 0,
-        /*have wind path below this*/
-        GFDB_FOP_WIND = 1,
-        GFDB_FOP_WDEL = 2,
-        /*have unwind path below this*/
-        GFDB_FOP_UNWIND = 4,
-        /*Delete unwind path*/
-        GFDB_FOP_UNDEL = 8,
-        GFDB_FOP_UNDEL_ALL = 16
-} gfdb_fop_path_t;
-/*Strings related to the above fop path*/
-#define GFDB_STR_FOP_INVALID "INVALID"
-#define GFDB_STR_FOP_WIND "ENTRY"
-#define GFDB_STR_FOP_UNWIND "EXIT"
-#define GFDB_STR_FOP_WDEL "WDEL"
-#define GFDB_STR_FOP_UNDEL "UNDEL"
-
-static inline gf_boolean_t
-iswindpath(gfdb_fop_path_t gfdb_fop_path)
-{
-        return ((gfdb_fop_path == GFDB_FOP_WIND) ||
-                        (gfdb_fop_path == GFDB_FOP_WDEL)) ?
-                                                _gf_true : _gf_false;
-}
-
-static inline gf_boolean_t
-isunwindpath(gfdb_fop_path_t gfdb_fop_path)
-{
-        return (gfdb_fop_path >= GFDB_FOP_UNWIND) ? _gf_true : _gf_false;
-}
-
-/*Tell what type of fop it was
- * Like whether a dentry fop or a inode fop
- * Read fop or a write fop etc*/
-typedef enum gfdb_fop_type {
-        GFDB_FOP_INVALID_OP = -1,
-        /*Filler value for zero*/
-        GFDB_FOP_TYPE_ZERO = 0,
-        GFDB_FOP_DENTRY_OP = 1,
-        GFDB_FOP_DENTRY_CREATE_OP = 2,
-        GFDB_FOP_INODE_OP = 4,
-        GFDB_FOP_WRITE_OP = 8,
-        GFDB_FOP_READ_OP = 16
-} gfdb_fop_type_t;
-
-#define GFDB_FOP_INODE_WRITE\
-        (GFDB_FOP_INODE_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_DENTRY_WRITE\
-        (GFDB_FOP_DENTRY_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_CREATE_WRITE\
-        (GFDB_FOP_DENTRY_CREATE_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_INODE_READ\
-        (GFDB_FOP_INODE_OP | GFDB_FOP_READ_OP)
-
-static inline gf_boolean_t
-isreadfop(gfdb_fop_type_t fop_type)
-{
-        return (fop_type & GFDB_FOP_READ_OP) ? _gf_true : _gf_false;
-}
-
-static inline gf_boolean_t
-isdentryfop(gfdb_fop_type_t fop_type)
-{
-        return ((fop_type & GFDB_FOP_DENTRY_OP) ||
-                (fop_type & GFDB_FOP_DENTRY_CREATE_OP)) ? _gf_true : _gf_false;
-}
-
-static inline gf_boolean_t
-isdentrycreatefop(gfdb_fop_type_t fop_type)
-{
-        return (fop_type & GFDB_FOP_DENTRY_CREATE_OP) ?
-                        _gf_true : _gf_false;
-}
-
-/*The structure that is used to send insert/update the databases
- * using insert_db api*/
-typedef struct gfdb_db_record {
-        /* GFID */
-        uuid_t                          gfid;
-        /* Used during a rename refer ctr_rename() in changetimerecorder
-         * xlator*/
-        uuid_t                          old_gfid;
-        /* Parent GFID */
-        uuid_t                          pargfid;
-        uuid_t                          old_pargfid;
-        /* File names */
-        char                            file_name[GF_NAME_MAX + 1];
-        char                            old_file_name[GF_NAME_MAX + 1];
-        /* FOP type and FOP path*/
-        gfdb_fop_type_t                 gfdb_fop_type;
-        gfdb_fop_path_t                 gfdb_fop_path;
-        /*Time of change or access*/
-        gfdb_time_t                     gfdb_wind_change_time;
-        gfdb_time_t                     gfdb_unwind_change_time;
-        /* For crash consistancy while inserting/updating hard links */
-        gf_boolean_t                    islinkupdate;
-        /* For link consistency we do a double update i.e mark the link
-         * during the wind and during the unwind we update/delete the link.
-         * This has a performance hit. We give a choice here whether we need
-         * link consistency to be spoton or not using link_consistency flag.
-         * This will have only one link update */
-         gf_boolean_t                   link_consistency;
-        /* For dentry fops we can choose to ignore recording of unwind time */
-        /* For inode fops "record_exit" volume option does the trick,       */
-        /* but for dentry fops we update the LINK_UPDATE, so an extra       */
-        /* flag is provided to ignore the recording of the unwind time.     */
-        gf_boolean_t                    do_record_uwind_time;
-        /* Global flag to record or not record counters */
-        gf_boolean_t                    do_record_counters;
-        /* Global flag to Record/Not Record wind or wind time.
-         * This flag will overrule do_record_uwind_time*/
-        gf_boolean_t                    do_record_times;
-        /* Ignoring errors while inserting.
-         * */
-        gf_boolean_t                    ignore_errors;
-} gfdb_db_record_t;
-
-
-/*******************************************************************************
- *
- *                           Signatures for the plugin functions
- *                           i.e Any plugin should implementment
- *                           these functions to integrate with
- *                           libgfdb.
- *
- * ****************************************************************************/
-
-/*Call back function for querying the database*/
-typedef int
-(*gf_query_callback_t)(gfdb_query_record_t *, void *);
-
-/* Used to initialize db connection
- * Arguments:
- *      args         : Dictionary containing database specific parameters
- *      db_conn      : pointer to plugin specific data base connection
- *                     that will be created. If the call is successful
- *                     db_conn will contain the plugin specific connection
- *                     If call is unsuccessful will have NULL.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_init_db_t)(dict_t *args, void **db_conn);
-
-
-
-
-/* Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      db_conn        : plugin specific data base connection
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_fini_db_t)(void **db_conn);
-
-
-
-
-/*Used to insert/updated records in the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      gfdb_db_record :  Record to be inserted/updated
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_insert_record_t)(void *db_conn,
-                        gfdb_db_record_t *db_record);
-
-
-
-
-/*Used to delete record from the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      gfdb_db_record :  Record to be deleted
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_delete_record_t)(void *db_conn,
-                        gfdb_db_record_t *db_record);
-
-
-
-
-/*Used to compact the database
- * Arguments:
- *      db_conn                        :  GFDB Connection node
- *      compact_active                 :  Is compaction currently on?
- *      compact_mode_switched          :  Was the compaction switch flipped?
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_compact_db_t)(void *db_conn, gf_boolean_t compact_active,
-                     gf_boolean_t compact_mode_switched);
-
-
-
-
-/* Query all the records from the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : 0 - list all files
- *                        positive value - add the LIMIT clause to
- *                        the SQL query to limit the number of records
- *                        returned
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_find_all_t)(void *db_conn,
-                               gf_query_callback_t query_callback,
-                               void *_cbk_args,
-                               int query_limit);
-
-
-
-
-/* Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_find_unchanged_for_time_t)(void *db_conn,
-                                  gf_query_callback_t query_callback,
-                                  void *_cbk_args,
-                                  gfdb_time_t *_time);
-
-
-
-/* Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_find_recently_changed_files_t)(void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_cbk_args, gfdb_time_t *_time);
-
-/* Query records/files that have not changed/accessed
- * from a time in past to current time, with
- * a desired frequency
- *
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are not
- *                                changed/accessed
- *      _write_freq             : Desired Write Frequency lower limit
- *      _read_freq              : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_find_unchanged_for_time_freq_t)
-                                        (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_cbk_args, gfdb_time_t *_time,
-                                        int _write_freq, int _read_freq,
-                                        gf_boolean_t _clear_counters);
-
-
-
-
-/* Query records/files that have changed/accessed from a
- * time in past to current time, with a desired frequency
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are
- *                                changed/accessed
- *      _write_freq             : Desired Write Frequency lower limit
- *      _read_freq              : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int
-(*gfdb_find_recently_changed_files_freq_t)(void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_cbk_args, gfdb_time_t *_time,
-                                        int _write_freq, int _read_freq,
-                                        gf_boolean_t _clear_counters);
-
-
-typedef int (*gfdb_clear_files_heat_t)(void *db_conn);
-
-typedef int (*gfdb_get_db_version_t)(void *db_conn,
-                                        char **version);
-
-typedef int (*gfdb_get_db_params_t)(void *db_conn,
-                                char *param_key,
-                                char **param_value);
-
-typedef int (*gfdb_set_db_params_t)(void *db_conn,
-                                char *param_key,
-                                char *param_value);
-
-
-
-/*Data structure holding all the above plugin function pointers*/
-typedef struct gfdb_db_operations {
-        gfdb_init_db_t                        init_db_op;
-        gfdb_fini_db_t                        fini_db_op;
-        gfdb_insert_record_t                  insert_record_op;
-        gfdb_delete_record_t                  delete_record_op;
-        gfdb_compact_db_t                     compact_db_op;
-        gfdb_find_all_t                       find_all_op;
-        gfdb_find_unchanged_for_time_t        find_unchanged_for_time_op;
-        gfdb_find_recently_changed_files_t    find_recently_changed_files_op;
-        gfdb_find_unchanged_for_time_freq_t
-                                        find_unchanged_for_time_freq_op;
-        gfdb_find_recently_changed_files_freq_t
-                                        find_recently_changed_files_freq_op;
-        gfdb_clear_files_heat_t clear_files_heat_op;
-        gfdb_get_db_version_t           get_db_version;
-        gfdb_get_db_params_t           get_db_params;
-        gfdb_set_db_params_t           set_db_params;
-} gfdb_db_operations_t;
-
-/*******************************************************************************
- *
- * Database connection object: This objected is maitained by libgfdb for each
- * database connection created.
- * gf_db_connection     : DB connection specific to the plugin
- * gfdb_db_operations   : Contains all the libgfdb API implementation
- *                        from the plugin.
- * gfdb_db_type         : Type of database
- *
- * ****************************************************************************/
-
-
-typedef struct gfdb_connection {
-        void *gf_db_connection;
-        gfdb_db_operations_t gfdb_db_operations;
-        gfdb_db_type_t gfdb_db_type;
-} gfdb_connection_t;
-
-
-
-
-/*******************************************************************************
- *
- *                    Macros for get and set db options
- *
- * ****************************************************************************/
-
-
-/*Set param_key : str_value into param_dict*/
-#define SET_DB_PARAM_TO_DICT(comp_name, params_dict, param_key,\
-                                                        str_value, ret, error)\
-        do {\
-                data_t *data     = NULL;\
-                data            = str_to_data (str_value);\
-                if (!data)\
-                        goto error;\
-                ret = dict_add (params_dict, param_key, data);\
-                if (ret) {\
-                        gf_msg (comp_name, GF_LOG_ERROR, 0,\
-                                LG_MSG_SET_PARAM_FAILED, "Failed setting %s "\
-                                "to params dictionary", param_key);\
-                        data_destroy (data);\
-                        goto error;\
-                };\
-        } while (0)
-
-/*get str_value of param_key from param_dict*/
-#define GET_DB_PARAM_FROM_DICT(comp_name, params_dict, param_key, str_value,\
-                                error)\
-        do {\
-                data_t *data    = NULL;\
-                data = dict_get (params_dict, param_key);\
-                if (!data) {\
-                        gf_msg (comp_name, GF_LOG_ERROR, 0,\
-                                LG_MSG_GET_PARAM_FAILED, "Failed to retrieve "\
-                                "%s from params", param_key);\
-                        goto error;\
-                } else {\
-                        str_value = data->data;\
-                };\
-        } while (0)
-
-
-/*get str_value of param_key from param_dict. if param_key is not present
- * set _default_v to str_value */
-#define GET_DB_PARAM_FROM_DICT_DEFAULT(comp_name, params_dict, param_key,\
-                                str_value, _default_v)\
-        do {\
-                data_t *data    = NULL;\
-                data = dict_get (params_dict, param_key);\
-                if (!data) {\
-                        str_value = _default_v;\
-                        gf_msg (comp_name, GF_LOG_TRACE, 0,\
-                                LG_MSG_GET_PARAM_FAILED, "Failed to retrieve "\
-                                "%s from params.Assigning default value: %s",\
-                                param_key, _default_v);\
-                } else {\
-                        str_value = data->data;\
-                };\
-        } while (0)
-
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.c b/libglusterfs/src/gfdb/gfdb_sqlite3.c
deleted file mode 100644
index 16930504742..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3.c
+++ /dev/null
@@ -1,1587 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3.h"
-#include "gfdb_sqlite3_helper.h"
-#include "libglusterfs-messages.h"
-#include "syscall.h"
-
-/******************************************************************************
- *
- *                      Util functions
- *
- * ***************************************************************************/
-gf_sql_connection_t *
-gf_sql_connection_init ()
-{
-        gf_sql_connection_t *gf_sql_conn = NULL;
-
-        gf_sql_conn = GF_CALLOC (1, sizeof(gf_sql_connection_t),
-                        gf_mt_sql_connection_t);
-        if (gf_sql_conn == NULL) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Error allocating memory to "
-                        "gf_sql_connection_t ");
-        }
-
-        return gf_sql_conn;
-}
-
-void
-gf_sql_connection_fini (gf_sql_connection_t **sql_connection)
-{
-        if (!sql_connection)
-                return;
-        GF_FREE (*sql_connection);
-        *sql_connection = NULL;
-}
-
-const char *
-gf_sql_jm2str (gf_sql_journal_mode_t jm)
-{
-        switch (jm) {
-        case gf_sql_jm_delete:
-                return GF_SQL_JM_DELETE;
-        case gf_sql_jm_truncate:
-                return GF_SQL_JM_TRUNCATE;
-        case gf_sql_jm_persist:
-                return GF_SQL_JM_PERSIST;
-        case gf_sql_jm_memory:
-                return GF_SQL_JM_MEMORY;
-        case gf_sql_jm_wal:
-                return GF_SQL_JM_WAL;
-        case gf_sql_jm_off:
-                return GF_SQL_JM_OFF;
-        case gf_sql_jm_invalid:
-                break;
-        }
-        return NULL;
-}
-
-gf_sql_journal_mode_t
-gf_sql_str2jm (const char *jm_str)
-{
-        if (!jm_str) {
-                return gf_sql_jm_invalid;
-        } else if (strcmp (jm_str, GF_SQL_JM_DELETE) == 0) {
-                return gf_sql_jm_delete;
-        } else if (strcmp (jm_str, GF_SQL_JM_TRUNCATE) == 0) {
-                return gf_sql_jm_truncate;
-        } else if (strcmp (jm_str, GF_SQL_JM_PERSIST) == 0) {
-                return gf_sql_jm_persist;
-        } else if (strcmp (jm_str, GF_SQL_JM_MEMORY) == 0) {
-                return gf_sql_jm_memory;
-        } else if (strcmp (jm_str, GF_SQL_JM_WAL) == 0) {
-                return gf_sql_jm_wal;
-        } else if (strcmp (jm_str, GF_SQL_JM_OFF) == 0) {
-                return gf_sql_jm_off;
-        }
-        return gf_sql_jm_invalid;
-}
-
-const char *
-gf_sql_av_t2str (gf_sql_auto_vacuum_t sql_av)
-{
-        switch (sql_av) {
-        case gf_sql_av_none:
-                return GF_SQL_AV_NONE;
-        case gf_sql_av_full:
-                return GF_SQL_AV_FULL;
-        case gf_sql_av_incr:
-                return GF_SQL_AV_INCR;
-        case gf_sql_av_invalid:
-                break;
-        }
-        return NULL;
-}
-
-gf_sql_auto_vacuum_t
-gf_sql_str2av_t (const char *av_str)
-{
-        if (!av_str) {
-                return gf_sql_av_invalid;
-        } else if (strcmp (av_str, GF_SQL_AV_NONE) == 0) {
-                return gf_sql_av_none;
-        } else if (strcmp (av_str, GF_SQL_AV_FULL) == 0) {
-                return gf_sql_av_full;
-        } else if (strcmp (av_str, GF_SQL_AV_INCR) == 0) {
-                return gf_sql_av_incr;
-        }
-        return gf_sql_av_invalid;
-}
-
-const char *
-gf_sync_t2str (gf_sql_sync_t sql_sync)
-{
-        switch (sql_sync) {
-        case gf_sql_sync_off:
-                return GF_SQL_SYNC_OFF;
-        case gf_sql_sync_normal:
-                return GF_SQL_SYNC_NORMAL;
-        case gf_sql_sync_full:
-                return GF_SQL_SYNC_FULL;
-        case gf_sql_sync_invalid:
-                break;
-        }
-        return NULL;
-}
-
-gf_sql_sync_t
-gf_sql_str2sync_t (const char *sync_str)
-{
-        if (!sync_str) {
-                return gf_sql_sync_invalid;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_OFF) == 0) {
-                return gf_sql_sync_off;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_NORMAL) == 0) {
-                return gf_sql_sync_normal;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_FULL) == 0) {
-                return gf_sql_sync_full;
-        }
-        return gf_sql_sync_invalid;
-}
-
-
-/*TODO replace GF_CALLOC by mem_pool or iobuff if required for performace */
-static char *
-sql_stmt_init ()
-{
-        char *sql_stmt = NULL;
-
-        sql_stmt = GF_CALLOC (GF_STMT_SIZE_MAX, sizeof(char),
-                        gf_common_mt_char);
-
-        if (!sql_stmt) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Error allocating memory to SQL "
-                        "Statement ");
-                goto out;
-        }
-out:
-        return sql_stmt;
-}
-
-/*TODO replace GF_FREE by mem_pool or iobuff if required for performace */
-static void
-sql_stmt_fini (char **sql_stmt)
-{
-        GF_FREE (*sql_stmt);
-}
-
-/******************************************************************************
- *                      DB Essential functions used by
- *                      > gf_open_sqlite3_conn ()
- *                      > gf_close_sqlite3_conn ()
- * ***************************************************************************/
-static sqlite3 *
-gf_open_sqlite3_conn(char *sqlite3_db_path, int flags)
-{
-        sqlite3 *sqlite3_db_conn = NULL;
-        int ret = -1;
-
-        GF_ASSERT (sqlite3_db_path);
-
-        /*Creates DB if not created*/
-        ret = sqlite3_open_v2 (sqlite3_db_path, &sqlite3_db_conn, flags, NULL);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
-                        "FATAL: Could open %s : %s",
-                        sqlite3_db_path, sqlite3_errmsg (sqlite3_db_conn));
-        }
-        return sqlite3_db_conn;
-}
-
-static int
-gf_close_sqlite3_conn(sqlite3 *sqlite3_db_conn)
-{
-        int ret = 0;
-
-        GF_ASSERT (sqlite3_db_conn);
-
-        if (sqlite3_db_conn) {
-                ret = sqlite3_close (sqlite3_db_conn);
-                if (ret != SQLITE_OK) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CONNECTION_ERROR, "FATAL: sqlite3 close"
-                                " connection failed %s",
-                                sqlite3_errmsg (sqlite3_db_conn));
-                        ret = -1;
-                        goto out;
-                }
-        }
-        ret = 0;
-out:
-        return ret;
-}
-
-/******************************************************************************
-*
-*                      Database init / fini / create table
-*
-* ***************************************************************************/
-
-
-/*Function to fill db operations*/
-void
-gf_sqlite3_fill_db_operations(gfdb_db_operations_t  *gfdb_db_ops)
-{
-        GF_ASSERT (gfdb_db_ops);
-
-        gfdb_db_ops->init_db_op = gf_sqlite3_init;
-        gfdb_db_ops->fini_db_op = gf_sqlite3_fini;
-
-        gfdb_db_ops->insert_record_op = gf_sqlite3_insert;
-        gfdb_db_ops->delete_record_op = gf_sqlite3_delete;
-        gfdb_db_ops->compact_db_op = gf_sqlite3_vacuum;
-
-        gfdb_db_ops->find_all_op = gf_sqlite3_find_all;
-        gfdb_db_ops->find_unchanged_for_time_op =
-                        gf_sqlite3_find_unchanged_for_time;
-        gfdb_db_ops->find_recently_changed_files_op =
-                        gf_sqlite3_find_recently_changed_files;
-        gfdb_db_ops->find_unchanged_for_time_freq_op =
-                        gf_sqlite3_find_unchanged_for_time_freq;
-        gfdb_db_ops->find_recently_changed_files_freq_op =
-                        gf_sqlite3_find_recently_changed_files_freq;
-
-        gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat;
-
-        gfdb_db_ops->get_db_version = gf_sqlite3_version;
-
-        gfdb_db_ops->get_db_params = gf_sqlite3_pragma;
-
-        gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma;
-}
-
-
-static int
-create_filetable (sqlite3 *sqlite3_db_conn)
-{
-        int ret                         =       -1;
-        char *sql_stmt                  =       NULL;
-        char *sql_strerror              =       NULL;
-
-        GF_ASSERT(sqlite3_db_conn);
-
-        sql_stmt = sql_stmt_init ();
-        if (!sql_stmt) {
-                ret = ENOMEM;
-                goto out;
-        }
-
-        GF_CREATE_STMT(sql_stmt);
-
-        ret = sqlite3_exec (sqlite3_db_conn, sql_stmt, NULL, NULL,
-                                &sql_strerror);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
-                        "Failed executing: %s : %s", sql_stmt, sql_strerror);
-                sqlite3_free (sql_strerror);
-                        ret = -1;
-                        goto out;
-        }
-
-
-        ret = 0;
-out:
-        sql_stmt_fini (&sql_stmt);
-        return ret;
-}
-
-
-
-
-static int
-apply_sql_params_db(gf_sql_connection_t *sql_conn, dict_t *param_dict)
-{
-        int ret = -1;
-        char *temp_str = NULL;
-        char sqlite3_config_str[GF_NAME_MAX] = "";
-
-        GF_ASSERT(sql_conn);
-        GF_ASSERT(param_dict);
-
-        /*Extract sql page_size from param_dict,
-         * if not specified default value will be GF_SQL_DEFAULT_PAGE_SIZE*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_PAGE_SIZE, temp_str,
-                        GF_SQL_DEFAULT_PAGE_SIZE);
-        sql_conn->page_size = atoi (temp_str);
-        /*Apply page_size on the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "page_size", "%zd",
-                        sql_conn->page_size, ret, out);
-
-
-
-        /*Extract sql cache size from param_dict,
-         * if not specified default value will be
-         * GF_SQL_DEFAULT_CACHE_SIZE pages*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_CACHE_SIZE, temp_str,
-                        GF_SQL_DEFAULT_CACHE_SIZE);
-        sql_conn->cache_size = atoi (temp_str);
-        /*Apply cache size on the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "cache_size", "%zd",
-                        sql_conn->cache_size, ret, out);
-
-
-
-
-        /*Extract sql journal mode from param_dict,
-         * if not specified default value will be
-         * GF_SQL_DEFAULT_JOURNAL_MODE i.e "wal"*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_JOURNAL_MODE, temp_str,
-                        GF_SQL_DEFAULT_JOURNAL_MODE);
-        sql_conn->journal_mode = gf_sql_str2jm (temp_str);
-        /*Apply journal mode to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "journal_mode", "%s",
-                        temp_str, ret, out);
-
-
-
-        /*Only when the journal mode is WAL, wal_autocheckpoint makes sense*/
-        if (sql_conn->journal_mode == gf_sql_jm_wal) {
-                /*Extract sql wal auto check point from param_dict
-                * if not specified default value will be
-                * GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT pages*/
-                temp_str = NULL;
-                GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_WAL_AUTOCHECK, temp_str,
-                        GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT);
-                sql_conn->wal_autocheckpoint = atoi(temp_str);
-                /*Apply wal auto check point to the sqlite db*/
-                GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "wal_autocheckpoint",
-                        "%zd", sql_conn->wal_autocheckpoint, ret, out);
-        }
-
-
-
-        /*Extract sql synchronous from param_dict
-         * if not specified default value will be GF_SQL_DEFAULT_SYNC*/
-         temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_SYNC, temp_str, GF_SQL_DEFAULT_SYNC);
-        sql_conn->synchronous = gf_sql_str2sync_t (temp_str);
-        /*Apply synchronous to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "synchronous", "%d",
-                        sql_conn->synchronous, ret, out);
-
-
-
-        /*Extract sql auto_vacuum from param_dict
-         * if not specified default value will be GF_SQL_DEFAULT_AUTO_VACUUM*/
-         temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_AUTO_VACUUM, temp_str,
-                        GF_SQL_DEFAULT_AUTO_VACUUM);
-        sql_conn->auto_vacuum = gf_sql_str2av_t (temp_str);
-        /*Apply auto_vacuum to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "auto_vacuum", "%d",
-                        sql_conn->auto_vacuum, ret, out);
-
-        ret = 0;
-out:
-        return ret;
-}
-
-
-
-int
-gf_sqlite3_init (dict_t *args, void **db_conn) {
-        int ret                         = -1;
-        gf_sql_connection_t *sql_conn   = NULL;
-        struct stat stbuf               = {0,};
-        gf_boolean_t    is_dbfile_exist = _gf_false;
-        char *temp_str                  = NULL;
-
-        GF_ASSERT (args);
-        GF_ASSERT (db_conn);
-
-        if (*db_conn != NULL) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CONNECTION_ERROR, "DB Connection is not "
-                        "empty!");
-                return 0;
-        }
-
-        if (!sqlite3_threadsafe ()) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_NOT_MULTITHREAD_MODE,
-                        "sqlite3 is not in multithreaded mode");
-                goto out;
-        }
-
-        sql_conn = gf_sql_connection_init ();
-        if (!sql_conn) {
-                goto out;
-        }
-
-        /*Extract sql db path from args*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT(GFDB_STR_SQLITE3, args,
-                        GFDB_SQL_PARAM_DBPATH, temp_str, out);
-        strncpy(sql_conn->sqlite3_db_path, temp_str, PATH_MAX-1);
-        sql_conn->sqlite3_db_path[PATH_MAX-1] = 0;
-
-        is_dbfile_exist = (sys_stat (sql_conn->sqlite3_db_path, &stbuf) == 0) ?
-                                                _gf_true : _gf_false;
-
-        /*Creates DB if not created*/
-        sql_conn->sqlite3_db_conn = gf_open_sqlite3_conn (
-                                        sql_conn->sqlite3_db_path,
-                                        SQLITE_OPEN_READWRITE |
-                                        SQLITE_OPEN_CREATE);
-        if (!sql_conn->sqlite3_db_conn) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CONNECTION_ERROR,
-                        "Failed creating db connection");
-                goto out;
-        }
-
-        /* If the file exist we skip the config part
-         * and creation of the schema */
-        if (is_dbfile_exist)
-                goto db_exists;
-
-
-        /*Apply sqlite3 params to database*/
-        ret = apply_sql_params_db (sql_conn, args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_SET_PARAM_FAILED, "Failed applying sql params"
-                        " to %s", sql_conn->sqlite3_db_path);
-                goto out;
-        }
-
-        /*Create the schema if NOT present*/
-        ret = create_filetable (sql_conn->sqlite3_db_conn);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CREATE_FAILED, "Failed Creating %s Table",
-                        GF_FILE_TABLE);
-               goto out;
-        }
-
-db_exists:
-        ret = 0;
-out:
-        if (ret) {
-                gf_sqlite3_fini ((void **)&sql_conn);
-        }
-
-        *db_conn = sql_conn;
-
-        return ret;
-}
-
-
-int
-gf_sqlite3_fini (void **db_conn)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = NULL;
-
-        GF_ASSERT (db_conn);
-        sql_conn = *db_conn;
-
-        if (sql_conn) {
-                if (sql_conn->sqlite3_db_conn) {
-                        ret = gf_close_sqlite3_conn (sql_conn->sqlite3_db_conn);
-                        if (ret) {
-                                /*Logging of error done in
-                                 * gf_close_sqlite3_conn()*/
-                                goto out;
-                        }
-                        sql_conn->sqlite3_db_conn = NULL;
-                }
-                gf_sql_connection_fini (&sql_conn);
-        }
-        *db_conn = sql_conn;
-        ret = 0;
-out:
-        return ret;
-}
-
-/******************************************************************************
- *
- *                      INSERT/UPDATE/DELETE Operations
- *
- *
- * ***************************************************************************/
-
-int gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *gfdb_db_record)
-{
-        int ret                         =       -1;
-        gf_sql_connection_t *sql_conn   =       db_conn;
-
-        CHECK_SQL_CONN(sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-
-        switch (gfdb_db_record->gfdb_fop_path) {
-        case GFDB_FOP_WIND:
-                ret = gf_sql_insert_wind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_FAILED, "Failed wind insert");
-                        goto out;
-                }
-                break;
-        case GFDB_FOP_UNWIND:
-                ret = gf_sql_insert_unwind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_FAILED, "Failed unwind insert");
-                        goto out;
-                }
-                break;
-
-        case GFDB_FOP_WDEL:
-                ret = gf_sql_update_delete_wind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_UPDATE_FAILED, "Failed updating delete "
-                                "during wind");
-                        goto out;
-                }
-                break;
-        case GFDB_FOP_UNDEL:
-        case GFDB_FOP_UNDEL_ALL:
-                ret = gf_sql_delete_unwind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_DELETE_FAILED, "Failed deleting");
-                        goto out;
-                }
-                break;
-        case GFDB_FOP_INVALID:
-        default:
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_FOP,
-                        "Cannot record to DB: Invalid FOP");
-                goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-int
-gf_sqlite3_delete(void *db_conn, gfdb_db_record_t *gfdb_db_record)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
-
-        CHECK_SQL_CONN(sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        ret = 0;
-out:
-        return ret;
-}
-
-/******************************************************************************
- *
- *                      SELECT QUERY FUNCTIONS
- *
- *
- * ***************************************************************************/
-
-static int
-gf_get_basic_query_stmt (char **out_stmt)
-{
-        int ret = -1;
-        ret = gf_asprintf (out_stmt, "select GF_FILE_TB.GF_ID,"
-                                  "GF_FLINK_TB.GF_PID ,"
-                                  "GF_FLINK_TB.FNAME "
-                                  "from GF_FLINK_TB, GF_FILE_TB "
-                                  "where "
-                                  "GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID ");
-        if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create base query statement");
-                *out_stmt = NULL;
-        }
-        return ret;
-}
-
-
-
-
-
-/*
- * Find All files recorded in the DB
- * Input:
- *      query_callback  :       query callback fuction to handle
- *                              result records from the query
- * */
-int
-gf_sqlite3_find_all (void *db_conn, gf_query_callback_t query_callback,
-                        void *query_cbk_args,
-                        int query_limit)
-{
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        char *limit_query                       =       NULL;
-        char *query                             =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        query = query_str;
-
-        if (query_limit > 0) {
-                ret = gf_asprintf (&limit_query, "%s LIMIT %d",
-                                   query, query_limit);
-                if (ret < 0) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_FAILED,
-                                "Failed creating limit query statement");
-                        limit_query = NULL;
-                        goto out;
-                }
-
-                query = limit_query;
-        }
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED,
-                        "Failed to prepare statement %s: %s", query,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query);
-                goto out;
-        }
-
-        ret = 0;
-out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (query_str);
-
-        if (limit_query)
-                GF_FREE (limit_query);
-
-        return ret;
-}
-
-
-/*
- * Find recently changed files from the DB
- * Input:
- *      query_callback  :       query callback fuction to handle
- *                              result records from the query
- *      from_time       :       Time to define what is recent
- * */
-int
-gf_sqlite3_find_recently_changed_files(void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *from_time)
-{
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  from_time_usec                =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND"
-                /*First condition: For writes*/
-                "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? )"
-                " OR "
-                /*Second condition: For reads*/
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ?) )"
-                /* Order by write wind time in a descending order
-                 * i.e most hot files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC DESC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed creating query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        from_time_usec = gfdb_time_2_usec (from_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                               &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 2, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s ", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-        ret = 0;
-out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
-}
-
-
-/*
- * Find unchanged files from a specified time from the DB
- * Input:
- *      query_callback  :       query callback fuction to handle
- *                              result records from the query
- *      for_time        :        Time from where the file/s are not changed
- * */
-int
-gf_sqlite3_find_unchanged_for_time (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *for_time)
-{
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  for_time_usec                 =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND "
-                /*First condition: For writes*/
-                "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") <= ? )"
-                " AND "
-                /*Second condition: For reads*/
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") <= ?) )"
-                /* Order by write wind time in a ascending order
-                 * i.e most cold files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC ASC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        for_time_usec = gfdb_time_2_usec (for_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                               &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 2, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-        ret = 0;
-out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
-}
-
-
-
-
-
-/*
- * Find recently changed files with a specific frequency from the DB
- * Input:
- *      db_conn         :       db connection object
- *      query_callback  :       query callback fuction to handle
- *                              result records from the query
- *      from_time       :       Time to define what is recent
- *      freq_write_cnt  :       Frequency thresold for write
- *      freq_read_cnt   :       Frequency thresold for read
- *      clear_counters  :       Clear counters (r/w) for all inodes in DB
- * */
-int
-gf_sqlite3_find_recently_changed_files_freq (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *from_time,
-                                        int freq_write_cnt,
-                                        int freq_read_cnt,
-                                        gf_boolean_t clear_counters)
-{
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  from_time_usec                =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-        ret = gf_asprintf (&query_str, "%s AND "
-                /*First condition: For Writes*/
-                "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? )"
-                " AND "" (" GF_COL_TB_WFC " >= ? ) )"
-                " OR "
-                /*Second condition: For Reads */
-                "( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ?)"
-                " AND "" (" GF_COL_TB_RFC " >= ? ) ) )"
-                /* Order by write wind time and write freq in a descending order
-                 * i.e most hot files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC DESC, "
-                "GF_FILE_TB.WRITE_FREQ_CNTR DESC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        from_time_usec = gfdb_time_2_usec (from_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt "
-                        "%d : %s", freq_write_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 3, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 4, freq_read_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt "
-                        "%d : %s", freq_read_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-
-
-        /*Clear counters*/
-        if (clear_counters) {
-                ret = gf_sql_clear_counters (sql_conn);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear"
-                                " counters!");
-                        goto out;
-                }
-        }
-        ret = 0;
-out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
-}
-
-
-
-
-/*
- * Find unchanged files from a specified time, w.r.t to frequency, from the DB
- * Input:
- *      query_callback  :       query callback fuction to handle
- *                              result records from the query
- *      for_time       :        Time from where the file/s are not changed
- *      freq_write_cnt  :       Frequency thresold for write
- *      freq_read_cnt   :       Frequency thresold for read
- *      clear_counters  :       Clear counters (r/w) for all inodes in DB
- * */
-int
-gf_sqlite3_find_unchanged_for_time_freq (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *for_time,
-                                        int freq_write_cnt,
-                                        int freq_read_cnt,
-                                        gf_boolean_t clear_counters)
-{
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  for_time_usec                 =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND "
-                /*First condition: For Writes
-                 * Files that have write wind time smaller than for_time
-                 * OR
-                 * File that have write wind time greater than for_time,
-                 * but write_frequency less than freq_write_cnt*/
-                "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") < ? )"
-                " OR "
-                "( (" GF_COL_TB_WFC " < ? ) AND"
-                "((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? ) ) )"
-                " AND "
-                /*Second condition: For Reads
-                 * Files that have read wind time smaller than for_time
-                 * OR
-                 * File that have read wind time greater than for_time,
-                 * but read_frequency less than freq_read_cnt*/
-                "( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") < ? )"
-                " OR "
-                "( (" GF_COL_TB_RFC " < ? ) AND"
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ? ) ) ) )"
-                /* Order by write wind time and write freq in ascending order
-                 * i.e most cold files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC ASC, "
-                "GF_FILE_TB.WRITE_FREQ_CNTR ASC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        for_time_usec = gfdb_time_2_usec (for_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare delete "
-                        "statement %s : %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt"
-                        " %d : %s", freq_write_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 3, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 4, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 5, freq_read_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt "
-                        "%d : %s", freq_read_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 6, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg(sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-
-        /*Clear counters*/
-        if (clear_counters) {
-                ret = gf_sql_clear_counters (sql_conn);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear "
-                                "counters!");
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
-}
-
-
-int
-gf_sqlite3_clear_files_heat (void *db_conn)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        ret = gf_sql_clear_counters (sql_conn);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear "
-                        "files heat");
-                goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-
-/* Function to extract version of sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the lenght of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-gf_sqlite3_version (void *db_conn, char **version)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *pre_stmt = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
-                                "SELECT SQLITE_VERSION()",
-                                -1, &pre_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
-                        sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = sqlite3_step(pre_stmt);
-        if (ret != SQLITE_ROW) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to get records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = gf_asprintf (version, "%s", sqlite3_column_text (pre_stmt, 0));
-        if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed extracting version");
-        }
-
-out:
-        sqlite3_finalize (pre_stmt);
-
-        return ret;
-}
-
-
-
-/* Function to extract PRAGMA from sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA or setting to be extracted
- * char **pragma_value  : the value of the PRAGMA or setting that is
- *                        extracted. This function will allocate memory
- *                        to pragma_value. The caller should free the memory
- * Return:
- *      On success return the lenght of the pragma/setting value that is
- *      extracted.
- *      On failure return -1
- * */
-int
-gf_sqlite3_pragma (void *db_conn, char *pragma_key, char **pragma_value)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
-        sqlite3_stmt *pre_stmt = NULL;
-        char *sqlstring = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out);
-
-        ret = gf_asprintf (&sqlstring, "PRAGMA %s;", pragma_key);
-        if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed allocating memory");
-                goto out;
-        }
-
-        ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
-                                  sqlstring, -1, &pre_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
-                        sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = sqlite3_step (pre_stmt);
-        if (ret != SQLITE_ROW) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to get records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        if (pragma_value) {
-                ret = gf_asprintf (pragma_value, "%s",
-                                   sqlite3_column_text (pre_stmt, 0));
-                if (ret <= 0) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_FAILED, "Failed to get %s from db",
-                                pragma_key);
-                }
-        }
-
-        ret = 0;
-out:
-        GF_FREE (sqlstring);
-
-        sqlite3_finalize (pre_stmt);
-
-        return ret;
-}
-
-/* Function to set PRAGMA to sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA to be set
- * char *pragma_value   : the value of the PRAGMA
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_set_pragma (void *db_conn, char *pragma_key, char *pragma_value)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
-        char sqlstring[GF_NAME_MAX] = "";
-        char *db_pragma_value = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_value, out);
-
-        GF_SQLITE3_SET_PRAGMA(sqlstring, pragma_key, "%s",
-                              pragma_value, ret, out);
-
-        ret = gf_sqlite3_pragma (db_conn, pragma_key, &db_pragma_value);
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to get %s pragma", pragma_key);
-        } else {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, 0,
-                        "Value set on DB %s : %s", pragma_key, db_pragma_value);
-        }
-        GF_FREE (db_pragma_value);
-
-        ret = 0;
-
-out:
-
-        return ret;
-}
-
-/* Function to vacuum of sqlite db
- * Input:
- * void *db_conn                      : Sqlite connection
- * gf_boolean_t compact_active        : Is compaction on?
- * gf_boolean_t compact_mode_switched : Did we just flip the compaction swtich?
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_vacuum (void *db_conn, gf_boolean_t compact_active,
-                   gf_boolean_t compact_mode_switched)
-{
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        char *sqlstring = NULL;
-        char *sql_strerror = NULL;
-        gf_boolean_t changing_pragma = _gf_true;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_NONE) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                        LG_MSG_COMPACT_STATUS,
-                        "VACUUM type is off: no VACUUM to do");
-                goto out;
-        }
-
-        if (compact_mode_switched) {
-                if (compact_active) { /* Then it was OFF before.
-                                        So turn everything on */
-                        ret = 0;
-                        switch (GF_SQL_COMPACT_DEF) {
-                        case GF_SQL_COMPACT_FULL:
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_FULL);
-                                break;
-                        case GF_SQL_COMPACT_INCR:
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_INCR);
-                                break;
-                        case GF_SQL_COMPACT_MANUAL:
-                                changing_pragma = _gf_false;
-                                break;
-                        default:
-                                ret = -1;
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_COMPACT_FAILED,
-                                        "VACUUM type undefined");
-                                goto out;
-                                break;
-                        }
-
-                } else { /* Then it was ON before, so turn it all off */
-                        if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_FULL ||
-                           GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_INCR) {
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_NONE);
-                        } else {
-                                changing_pragma = _gf_false;
-                        }
-                }
-
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0,
-                                LG_MSG_PREPARE_FAILED,
-                                "Failed to set the pragma");
-                        goto out;
-                }
-
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                        LG_MSG_COMPACT_STATUS, "Turning compaction %i",
-                        GF_SQL_COMPACT_DEF);
-
-                /* If we move from an auto_vacuum scheme to off, */
-                /* or vice-versa, we must VACUUM to save the change. */
-                /* In the case of a manual VACUUM scheme, we might as well */
-                /* run a manual VACUUM now if we */
-                if (changing_pragma || compact_active) {
-                        ret = gf_asprintf (&sqlstring, "VACUUM;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS, "Sealed with a VACUUM");
-                }
-        } else { /* We are active, so it's time to VACUUM */
-                if (!compact_active) { /* Did we somehow enter an inconsistent
-                                          state? */
-                        ret = -1;
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_PREPARE_FAILED,
-                                "Tried to VACUUM when compaction inactive");
-                        goto out;
-                }
-
-                gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0,
-                       LG_MSG_COMPACT_STATUS,
-                       "Doing regular vacuum of type %i", GF_SQL_COMPACT_DEF);
-
-                switch (GF_SQL_COMPACT_DEF) {
-                case GF_SQL_COMPACT_INCR: /* INCR auto_vacuum */
-                        ret = gf_asprintf(&sqlstring,
-                                          "PRAGMA incremental_vacuum;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS,
-                               "Will commence an incremental VACUUM");
-                        break;
-                /* (MANUAL) Invoke the VACUUM command */
-                case GF_SQL_COMPACT_MANUAL:
-                        ret = gf_asprintf(&sqlstring, "VACUUM;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS,
-                               "Will commence a VACUUM");
-                        break;
-                /* (FULL) The database does the compaction itself. */
-                /* We cannot do anything else, so we can leave */
-                /* without sending anything to the database */
-                case GF_SQL_COMPACT_FULL:
-                        ret = 0;
-                        goto success;
-                /* Any other state must be an error. Note that OFF */
-                /* cannot hit this statement since we immediately leave */
-                /* in that case */
-                default:
-                        ret = -1;
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_COMPACT_FAILED,
-                                "VACUUM type undefined");
-                        goto out;
-                        break;
-                }
-        }
-
-        gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS,
-               "SQLString == %s", sqlstring);
-
-        ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlstring, NULL, NULL,
-                           &sql_strerror);
-
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to vacuum "
-                        "the db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-success:
-        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
-               compact_mode_switched ? "Successfully changed VACUUM on/off"
-               : "DB successfully VACUUM");
-out:
-        GF_FREE(sqlstring);
-
-        return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.h b/libglusterfs/src/gfdb/gfdb_sqlite3.h
deleted file mode 100644
index 5b55b0ace5e..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3.h
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_SQLITE3_H
-#define __GFDB_SQLITE3_H
-
-
-/*Sqlite3 header file*/
-#include <sqlite3.h>
-
-#include "logging.h"
-#include "gfdb_data_store_types.h"
-#include "gfdb_mem-types.h"
-#include "libglusterfs-messages.h"
-
-#define GF_STMT_SIZE_MAX        2048
-
-#define GF_DB_NAME              "gfdb.db"
-#define GF_FILE_TABLE           "GF_FILE_TB"
-#define GF_FILE_LINK_TABLE      "GF_FLINK_TB"
-#define GF_MASTER_TABLE         "sqlite_master"
-
-/*Since we have multiple tables to be created we put it in a transaction*/
-#define GF_CREATE_STMT(out_str)\
-do {\
-        sprintf (out_str , "BEGIN; CREATE TABLE IF NOT EXISTS "\
-                GF_FILE_TABLE\
-                "(GF_ID TEXT PRIMARY KEY NOT NULL, "\
-                "W_SEC INTEGER NOT NULL DEFAULT 0, "\
-                "W_MSEC INTEGER NOT NULL DEFAULT 0, "\
-                "UW_SEC INTEGER NOT NULL DEFAULT 0, "\
-                "UW_MSEC INTEGER NOT NULL DEFAULT 0, "\
-                "W_READ_SEC INTEGER NOT NULL DEFAULT 0, "\
-                "W_READ_MSEC INTEGER NOT NULL DEFAULT 0, "\
-                "UW_READ_SEC INTEGER NOT NULL DEFAULT 0, "\
-                "UW_READ_MSEC INTEGER NOT NULL DEFAULT 0, "\
-                "WRITE_FREQ_CNTR INTEGER NOT NULL DEFAULT 1, "\
-                "READ_FREQ_CNTR INTEGER NOT NULL DEFAULT 1); "\
-                "CREATE TABLE IF NOT EXISTS "\
-                GF_FILE_LINK_TABLE\
-                "(GF_ID TEXT NOT NULL, "\
-                "GF_PID TEXT NOT NULL, "\
-                "FNAME TEXT NOT NULL, "\
-                "W_DEL_FLAG INTEGER NOT NULL DEFAULT 0, "\
-                "LINK_UPDATE INTEGER NOT NULL DEFAULT 0, "\
-                "PRIMARY KEY ( GF_ID, GF_PID, FNAME) "\
-                ");"\
-                "COMMIT;"\
-                );;\
-} while (0)
-
-#define GF_COL_TB_WSEC          GF_FILE_TABLE "." GF_COL_WSEC
-#define GF_COL_TB_WMSEC         GF_FILE_TABLE "." GF_COL_WMSEC
-#define GF_COL_TB_UWSEC         GF_FILE_TABLE "." GF_COL_UWSEC
-#define GF_COL_TB_UWMSEC        GF_FILE_TABLE "." GF_COL_UWMSEC
-#define GF_COL_TB_RWSEC         GF_FILE_TABLE "." GF_COL_WSEC_READ
-#define GF_COL_TB_RWMSEC        GF_FILE_TABLE "." GF_COL_WMSEC_READ
-#define GF_COL_TB_RUWSEC        GF_FILE_TABLE "." GF_COL_UWSEC_READ
-#define GF_COL_TB_RUWMSEC       GF_FILE_TABLE "." GF_COL_UWMSEC_READ
-#define GF_COL_TB_WFC           GF_FILE_TABLE "." GF_COL_WRITE_FREQ_CNTR
-#define GF_COL_TB_RFC           GF_FILE_TABLE "." GF_COL_READ_FREQ_CNTR
-
-
-/*******************************************************************************
-*                      SQLITE3 Connection details and PRAGMA
-* ****************************************************************************/
-
-#define GF_SQL_AV_NONE  "none"
-#define GF_SQL_AV_FULL  "full"
-#define GF_SQL_AV_INCR  "incremental"
-
-#define GF_SQL_SYNC_OFF         "off"
-#define GF_SQL_SYNC_NORMAL      "normal"
-#define GF_SQL_SYNC_FULL        "full"
-
-#define GF_SQL_JM_DELETE        "delete"
-#define GF_SQL_JM_TRUNCATE      "truncate"
-#define GF_SQL_JM_PERSIST       "persist"
-#define GF_SQL_JM_MEMORY        "memory"
-#define GF_SQL_JM_WAL           "wal"
-#define GF_SQL_JM_OFF           "off"
-
-#define GF_SQL_COMPACT_NONE   0
-#define GF_SQL_COMPACT_FULL   1
-#define GF_SQL_COMPACT_INCR   2
-#define GF_SQL_COMPACT_MANUAL 3
-
-#define GF_SQL_COMPACT_DEF    GF_SQL_COMPACT_INCR
-typedef enum gf_sql_auto_vacuum {
-        gf_sql_av_none = 0,
-        gf_sql_av_full,
-        gf_sql_av_incr,
-        gf_sql_av_invalid
-} gf_sql_auto_vacuum_t;
-
-typedef enum gf_sql_sync {
-        gf_sql_sync_off = 0,
-        gf_sql_sync_normal,
-        gf_sql_sync_full,
-        gf_sql_sync_invalid
-} gf_sql_sync_t;
-
-
-typedef enum gf_sql_journal_mode {
-        gf_sql_jm_wal = 0,
-        gf_sql_jm_delete,
-        gf_sql_jm_truncate,
-        gf_sql_jm_persist,
-        gf_sql_jm_memory,
-        gf_sql_jm_off,
-        gf_sql_jm_invalid
-} gf_sql_journal_mode_t;
-
-
-typedef struct gf_sql_connection {
-        char                    sqlite3_db_path[PATH_MAX];
-        sqlite3                 *sqlite3_db_conn;
-        ssize_t                 cache_size;
-        ssize_t                 page_size;
-        ssize_t                 wal_autocheckpoint;
-        gf_sql_journal_mode_t   journal_mode;
-        gf_sql_sync_t           synchronous;
-        gf_sql_auto_vacuum_t    auto_vacuum;
-} gf_sql_connection_t;
-
-
-
-#define CHECK_SQL_CONN(sql_conn, out)\
-do {\
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, sql_conn, out);\
-        if (!sql_conn->sqlite3_db_conn) {\
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,\
-                        LG_MSG_CONNECTION_INIT_FAILED,\
-                        "sqlite3 connection not initialized");\
-                goto out;\
-        };\
-} while (0)
-
-#define GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, param_key, format, value,\
-                        ret, error)\
-do {\
-        sprintf (sqlite3_config_str, "PRAGMA %s = " format ,  param_key,\
-                value);\
-        ret = sqlite3_exec (sql_conn->sqlite3_db_conn, sqlite3_config_str,\
-                NULL, NULL, NULL);\
-        if (ret != SQLITE_OK) {\
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,\
-                        "Failed executing: %s : %s",\
-                        sqlite3_config_str, sqlite3_errmsg\
-                                               (sql_conn->sqlite3_db_conn));\
-                        ret = -1;\
-                        goto error;\
-        };\
-} while (0)
-
-/************************SQLITE3 PARAMS KEYS***********************************/
-#define GFDB_SQL_PARAM_DBPATH           "sql-db-path"
-#define GFDB_SQL_PARAM_CACHE_SIZE       "sql-db-cachesize"
-#define GFDB_SQL_PARAM_PAGE_SIZE        "sql-db-pagesize"
-#define GFDB_SQL_PARAM_JOURNAL_MODE     "sql-db-journalmode"
-#define GFDB_SQL_PARAM_WAL_AUTOCHECK    "sql-db-wal-autocheckpoint"
-#define GFDB_SQL_PARAM_SYNC             "sql-db-sync"
-#define GFDB_SQL_PARAM_AUTO_VACUUM      "sql-db-autovacuum"
-
-#define GF_SQL_DEFAULT_DBPATH                   ""
-#define GF_SQL_DEFAULT_PAGE_SIZE                "4096"
-#define GF_SQL_DEFAULT_CACHE_SIZE               "12500"
-#define GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT       "25000"
-#define GF_SQL_DEFAULT_JOURNAL_MODE             GF_SQL_JM_WAL
-#define GF_SQL_DEFAULT_SYNC                     GF_SQL_SYNC_OFF
-#define GF_SQL_DEFAULT_AUTO_VACUUM              GF_SQL_AV_NONE
-
-
-/* Defines the indexs for sqlite params
- * The order should be maintained*/
-typedef enum sqlite_param_index {
-        sql_dbpath_ix = 0,
-        sql_pagesize_ix,
-        sql_cachesize_ix,
-        sql_journalmode_ix,
-        sql_walautocheck_ix,
-        sql_dbsync_ix,
-        sql_autovacuum_ix,
-        /*This should be in the end*/
-        sql_index_max
-} sqlite_param_index_t;
-
-/* Array to hold the sqlite param keys
- * The order should be maintained as sqlite_param_index_t*/
-static char *sqlite_params_keys[] = {
-        GFDB_SQL_PARAM_DBPATH,
-        GFDB_SQL_PARAM_PAGE_SIZE,
-        GFDB_SQL_PARAM_CACHE_SIZE,
-        GFDB_SQL_PARAM_JOURNAL_MODE,
-        GFDB_SQL_PARAM_WAL_AUTOCHECK,
-        GFDB_SQL_PARAM_SYNC,
-        GFDB_SQL_PARAM_AUTO_VACUUM
-};
-
-
-/* Array of default values for sqlite params
- * The order should be maintained as sqlite_param_index_t*/
-static char *sqlite_params_default_value[] = {
-        GF_SQL_DEFAULT_DBPATH,
-        GF_SQL_DEFAULT_PAGE_SIZE,
-        GF_SQL_DEFAULT_CACHE_SIZE,
-        GF_SQL_DEFAULT_JOURNAL_MODE,
-        GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT,
-        GF_SQL_DEFAULT_SYNC,
-        GF_SQL_DEFAULT_AUTO_VACUUM
-};
-
-/*Extract sql params from page_size to auto_vacumm
- * The dbpath is extracted in a different way*/
-static inline int
-gfdb_set_sql_params(char *comp_name, dict_t *from_dict, dict_t *to_dict)
-{
-        sqlite_param_index_t sql_index  = sql_pagesize_ix;
-        char *_val_str                  = NULL;
-        int ret                      = -1;
-
-        GF_ASSERT (comp_name);
-        GF_ASSERT (from_dict);
-        GF_ASSERT (to_dict);
-
-        /*Extact and Set of the sql params from page_size*/
-        for (sql_index = sql_pagesize_ix; sql_index < sql_index_max;
-                sql_index++) {
-                _val_str = NULL;
-                GET_DB_PARAM_FROM_DICT_DEFAULT (comp_name, from_dict,
-                        sqlite_params_keys[sql_index], _val_str,
-                        sqlite_params_default_value[sql_index]);
-                SET_DB_PARAM_TO_DICT (comp_name, to_dict,
-                        sqlite_params_keys[sql_index], _val_str, ret, out);
-        }
-out:
-        return ret;
-}
-
-
-
-
-/*************************SQLITE3 GFDB PLUGINS*********************************/
-
-/*Db init and fini modules*/
-int gf_sqlite3_fini (void **db_conn);
-int gf_sqlite3_init (dict_t *args, void **db_conn);
-
-/*insert/update/delete modules*/
-int gf_sqlite3_insert (void *db_conn, gfdb_db_record_t *);
-int gf_sqlite3_delete (void *db_conn, gfdb_db_record_t *);
-
-/*querying modules*/
-int gf_sqlite3_find_all (void *db_conn, gf_query_callback_t,
-                        void *_query_cbk_args,
-                        int query_limit);
-int gf_sqlite3_find_unchanged_for_time (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *for_time);
-int gf_sqlite3_find_recently_changed_files (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *from_time);
-int gf_sqlite3_find_unchanged_for_time_freq (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *for_time,
-                                        int write_freq_cnt,
-                                        int read_freq_cnt,
-                                        gf_boolean_t clear_counters);
-int gf_sqlite3_find_recently_changed_files_freq (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *from_time,
-                                        int write_freq_cnt,
-                                        int read_freq_cnt,
-                                        gf_boolean_t clear_counters);
-
-int gf_sqlite3_clear_files_heat (void *db_conn);
-
-/* Function to extract version of sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the lenght of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int gf_sqlite3_version (void *db_conn, char **version);
-
-/* Function to extract PRAGMA or setting from sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA or setting to be extracted
- * char **pragma_value  : the value of the PRAGMA or setting that is
- *                        extracted. This function will allocate memory
- *                        to pragma_value. The caller should free the memory
- * Return:
- *      On success return the lenght of the pragma/setting value that is
- *      extracted.
- *      On failure return -1
- * */
-int gf_sqlite3_pragma (void *db_conn, char *pragma_key, char **pragma_value);
-
-/* Function to set PRAGMA to sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA to be set
- * char *pragma_value   : the value of the PRAGMA
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_set_pragma (void *db_conn, char *pragma_key, char *pragma_value);
-
-/* Function to vacuum of sqlite db
- * Input:
- * void *db_conn                      : Sqlite connection
- * gf_boolean_t compact_active        : Is compaction on?
- * gf_boolean_t compact_mode_switched : Did we just flip the compaction swtich?
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_vacuum (void *db_conn, gf_boolean_t compact_active,
-                   gf_boolean_t compact_mode_switched);
-
-void gf_sqlite3_fill_db_operations (gfdb_db_operations_t  *gfdb_db_ops);
-
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
deleted file mode 100644
index 8e1e27ff082..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
+++ /dev/null
@@ -1,1371 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3_helper.h"
-
-
-#define GFDB_SQL_STMT_SIZE 256
-
-/*****************************************************************************
- *
- *                 Helper function to execute actual sql queries
- *
- *
- * ****************************************************************************/
-
-static int
-gf_sql_delete_all (gf_sql_connection_t  *sql_conn,
-                  char                  *gfid,
-                  gf_boolean_t          ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *delete_file_stmt = NULL;
-        sqlite3_stmt *delete_link_stmt = NULL;
-        char *delete_link_str = "DELETE FROM "
-                           GF_FILE_LINK_TABLE
-                           " WHERE GF_ID = ? ;";
-        char *delete_file_str = "DELETE FROM "
-                           GF_FILE_TABLE
-                           " WHERE GF_ID = ? ;";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-
-        /*
-         * Delete all links associated with this GFID
-         *
-         * */
-        /*Prepare statement for delete all links*/
-        ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1,
-                                &delete_link_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_link_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_link_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (delete_link_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_link_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*
-         * Delete entry from file table associated with this GFID
-         *
-         * */
-        /*Prepare statement for delete all links*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_file_str, -1,
-                                &delete_file_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_file_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_file_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (delete_file_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_file_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (delete_file_stmt);
-        sqlite3_finalize (delete_link_stmt);
-        return ret;
-}
-
-static int
-gf_sql_delete_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   gf_boolean_t         ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *delete_stmt = NULL;
-        char *delete_str = "DELETE FROM "
-                           GF_FILE_LINK_TABLE
-                           " WHERE GF_ID = ? AND GF_PID = ?"
-                           " AND FNAME = ?;";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_str, -1,
-                                &delete_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED,
-                        "Failed binding gfid %s : %s", gfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (delete_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (delete_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step(delete_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (delete_stmt);
-        return ret;
-}
-
-
-
-static int
-gf_sql_update_link_flags (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   int                  update_flag,
-                   gf_boolean_t         is_update_or_delete,
-                   gf_boolean_t         ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *update_stmt = NULL;
-        char *update_column = NULL;
-        char update_str[1024] = "";
-
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG";
-
-        sprintf (update_str, "UPDATE "
-                            GF_FILE_LINK_TABLE
-                            " SET %s = ?"
-                            " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;",
-                            update_column);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
-                                &update_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing update "
-                        "statement %s : %s", update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Bind link_update*/
-        ret = sqlite3_bind_int (update_stmt, 1, update_flag);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding update_flag %d "
-                        ": %s", update_flag,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (update_stmt, 2, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (update_stmt, 3, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (update_stmt, 4, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step(update_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (update_stmt);
-        return ret;
-}
-
-
-static int
-gf_sql_insert_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   gf_boolean_t         link_consistency,
-                   gf_boolean_t         ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char insert_str[GFDB_SQL_STMT_SIZE] = "";
-
-        sprintf (insert_str, "INSERT INTO "
-                           GF_FILE_LINK_TABLE
-                           " (GF_ID, GF_PID, FNAME,"
-                           " W_DEL_FLAG, LINK_UPDATE) "
-                           " VALUES (?, ?, ?, 0, %d);",
-                           link_consistency);
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                                &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED,
-                        "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED,
-                        "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_BINDING_FAILED,
-                        "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_BINDING_FAILED,
-                        "Failed binding basename %s : %s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors),
-                        0, LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared "
-                        "stmt %s %s %s %s : %s",
-                        gfid, pargfid, basename, insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
-}
-
-
-static int
-gf_sql_update_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   char                 *old_pargfid,
-                   char                 *old_basename,
-                   gf_boolean_t         link_consistency,
-                   gf_boolean_t         ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char insert_str[GFDB_SQL_STMT_SIZE] = "";
-
-        sprintf (insert_str, "INSERT INTO "
-                            GF_FILE_LINK_TABLE
-                            " (GF_ID, GF_PID, FNAME,"
-                            " W_DEL_FLAG, LINK_UPDATE) "
-                            " VALUES (? , ?, ?, 0, %d);",
-                            link_consistency);
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_basename, out);
-
-        /*
-         *
-         * Delete the old link
-         *
-         * */
-         ret = gf_sql_delete_link (sql_conn, gfid, old_pargfid,
-                                old_basename, ignore_errors);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_DELETE_FAILED, "Failed deleting old link");
-                goto out;
-        }
-
-        /*
-         *
-         * insert new link
-         *
-         * */
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                                &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind new pargfid*/
-        ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind new basename*/
-        ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
-}
-
-static int
-gf_sql_insert_write_wind_time (gf_sql_connection_t      *sql_conn,
-                                char                    *gfid,
-                                gfdb_time_t             *wind_time,
-                                gf_boolean_t            ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char *insert_str = "INSERT INTO "
-                           GF_FILE_TABLE
-                           "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)"
-                           " VALUES (?, ?, ?, 0, 0);";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, wind_time, out);
-
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                        &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind wind secs*/
-        ret = sqlite3_bind_int (insert_stmt, 2, wind_time->tv_sec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "secs %ld : %s", wind_time->tv_sec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind wind msecs*/
-        ret = sqlite3_bind_int (insert_stmt, 3, wind_time->tv_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "msecs %ld : %s", wind_time->tv_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt GFID:%s %s : %s",
-                        gfid, insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
-}
-
-
-
-/*Update write/read times for both wind and unwind*/
-static int
-gf_update_time (gf_sql_connection_t    *sql_conn,
-                char                    *gfid,
-                gfdb_time_t             *update_time,
-                gf_boolean_t            record_counter,
-                gf_boolean_t            is_wind,
-                gf_boolean_t            is_read,
-                gf_boolean_t            ignore_errors)
-{
-        int ret = -1;
-        sqlite3_stmt *update_stmt = NULL;
-        char update_str[1024] = "";
-        char *freq_cntr_str = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, update_time, out);
-
-        /*
-         * Constructing the prepare statement string.
-         *
-         * */
-        /*For write time*/
-        if (!is_read) {
-                if (is_wind) {
-                        /*if record counter is on*/
-                        freq_cntr_str = (record_counter) ?
-                        ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" : "";
-
-                        /*Prefectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET W_SEC = ?, W_MSEC = ? "
-                                " %s"/*place for read freq counters*/
-                                " WHERE GF_ID = ? ;", freq_cntr_str);
-                } else {
-                        /*Prefectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET UW_SEC = ?, UW_MSEC = ? ;");
-                }
-        }
-        /*For Read Time update*/
-        else {
-                if (is_wind) {
-                        /*if record counter is on*/
-                        freq_cntr_str = (record_counter) ?
-                        ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" : "";
-
-                        /*Prefectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET W_READ_SEC = ?, W_READ_MSEC = ? "
-                                " %s"/*place for read freq counters*/
-                                " WHERE GF_ID = ? ;", freq_cntr_str);
-                } else {
-                        /*Prefectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET UW_READ_SEC = ?, UW_READ_MSEC = ? ;");
-                }
-        }
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
-                                &update_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind time secs*/
-        ret = sqlite3_bind_int (update_stmt, 1, update_time->tv_sec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "secs %ld : %s", update_time->tv_sec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind time msecs*/
-        ret = sqlite3_bind_int (update_stmt, 2, update_time->tv_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "msecs %ld : %s", update_time->tv_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (update_stmt, 3, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (update_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
-out:
-        /*Free prepared statement*/
-        sqlite3_finalize (update_stmt);
-        return ret;
-}
-
-/******************************************************************************
- *
- *                      Helper functions for gf_sqlite3_insert()
- *
- *
- * ****************************************************************************/
-
-int
-gf_sql_insert_wind (gf_sql_connection_t  *sql_conn,
-                   gfdb_db_record_t     *gfdb_db_record)
-{
-        int ret                 = -1;
-        gfdb_time_t *modtime    = NULL;
-        char *pargfid_str       = NULL;
-        char *gfid_str          = NULL;
-        char *old_pargfid_str   = NULL;
-        gf_boolean_t its_wind   = _gf_true;/*remains true for this function*/
-
-
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-
-        gfid_str = gf_strdup (uuid_utoa (gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
-                goto out;
-        }
-
-        modtime = &gfdb_db_record->gfdb_wind_change_time;
-
-        /* handle all dentry based operations */
-        if (isdentryfop (gfdb_db_record->gfdb_fop_type)) {
-                /*Parent GFID is always set*/
-                pargfid_str = gf_strdup (uuid_utoa (gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating gfid string "
-                                "failed.");
-                        goto out;
-                }
-
-                /* handle create, mknod */
-                if (isdentrycreatefop (gfdb_db_record->gfdb_fop_type)) {
-                        /*insert link*/
-                        ret = gf_sql_insert_link(sql_conn,
-                                        gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name,
-                                        gfdb_db_record->link_consistency,
-                                        _gf_true);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_WARNING,
-                                                gfdb_db_record->ignore_errors),
-                                        0,
-                                        LG_MSG_INSERT_FAILED, "Failed "
-                                        "inserting link in DB");
-                                /* Even if link creation is failed we
-                                 * continue with the creation of file record.
-                                 * This covers to cases
-                                 * 1) Lookup heal: If the file record from
-                                 * gf_file_tb is deleted but the link record
-                                 * still exist. Lookup heal will attempt a heal
-                                 * with create_wind set. The link heal will fail
-                                 * as there is already a record and if we dont
-                                 * ignore the error we will not heal the
-                                 * gf_file_tb.
-                                 * 2) Rename file in cold tier: During a rename
-                                 * of a file that is there in cold tier. We get
-                                 * an link record created in hot tier for the
-                                 * linkto file. When the file gets heated and
-                                 * moves to hot tier there will be attempt from
-                                 * ctr lookup heal to create link and file
-                                 * record and If we dont ignore the error we
-                                 * will not heal the gf_file_tb.
-                                 * */
-                        }
-                        gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-
-                        /*
-                         * Only for create/mknod insert wind time
-                         * for the first time
-                         * */
-                        ret = gf_sql_insert_write_wind_time (sql_conn, gfid_str,
-                                        modtime, gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_INSERT_FAILED,
-                                        "Failed inserting wind time in DB");
-                                goto out;
-                        }
-                        goto out;
-                }
-                /*handle rename, link */
-                else {
-                        /*rename*/
-                        if (strlen (gfdb_db_record->old_file_name) != 0) {
-                                old_pargfid_str = gf_strdup (uuid_utoa (
-                                                gfdb_db_record->old_pargfid));
-                                if (!old_pargfid_str) {
-                                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                                0, LG_MSG_CREATE_FAILED,
-                                                "Creating gfid string failed.");
-                                        goto out;
-                                }
-                                ret = gf_sql_update_link (sql_conn, gfid_str,
-                                                pargfid_str,
-                                                gfdb_db_record->file_name,
-                                                old_pargfid_str,
-                                                gfdb_db_record->old_file_name,
-                                                gfdb_db_record->
-                                                        link_consistency,
-                                                gfdb_db_record->ignore_errors);
-                                if (ret) {
-                                        gf_msg (GFDB_STR_SQLITE3,
-                                                _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                                0, LG_MSG_UPDATE_FAILED,
-                                                "Failed updating link");
-                                        goto out;
-                                }
-                                gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-                        }
-                        /*link*/
-                        else {
-                                ret = gf_sql_insert_link (sql_conn,
-                                                gfid_str, pargfid_str,
-                                                gfdb_db_record->file_name,
-                                                gfdb_db_record->
-                                                        link_consistency,
-                                                gfdb_db_record->ignore_errors);
-                                if (ret) {
-                                        gf_msg (GFDB_STR_SQLITE3,
-                                                _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                                0, LG_MSG_INSERT_FAILED,
-                                                "Failed inserting link in DB");
-                                        goto out;
-                                }
-                                gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-                        }
-                }
-        }
-
-        /* update times only when said!*/
-        if (gfdb_db_record->do_record_times) {
-                /*All fops update times read or write*/
-                ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                its_wind,
-                                isreadfop (gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_UPDATE_FAILED, "Failed update wind time"
-                                " in DB");
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        GF_FREE (old_pargfid_str);
-        return ret;
-}
-
-
-
-
-int
-gf_sql_insert_unwind (gf_sql_connection_t  *sql_conn,
-                     gfdb_db_record_t     *gfdb_db_record)
-{
-
-        int ret = -1;
-        gfdb_time_t *modtime    = NULL;
-        gf_boolean_t its_wind   = _gf_true;/*remains true for this function*/
-        char *gfid_str = NULL;
-        char *pargfid_str = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
-                goto out;
-        }
-
-        /*Only update if recording unwind is set*/
-        if (gfdb_db_record->do_record_times &&
-                gfdb_db_record->do_record_uwind_time) {
-                modtime = &gfdb_db_record->gfdb_unwind_change_time;
-                ret = gf_update_time (sql_conn, gfid_str, modtime,
-                        gfdb_db_record->do_record_counters,
-                        (!its_wind),
-                        isreadfop (gfdb_db_record->gfdb_fop_type),
-                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED, "Failed update unwind "
-                                "time in DB");
-                        goto out;
-                }
-        }
-
-        /*For link creation and changes we use link updated*/
-        if (gfdb_db_record->islinkupdate &&
-                isdentryfop(gfdb_db_record->gfdb_fop_type)) {
-
-                pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED,
-                                "Creating pargfid_str string failed.");
-                        goto out;
-                }
-
-                ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name, 0, _gf_true,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED,
-                                "Failed updating link flags in unwind");
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
-}
-
-
-int
-gf_sql_update_delete_wind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record)
-{
-        int ret = -1;
-        char *gfid_str          = NULL;
-        char *pargfid_str       = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
-                goto out;
-        }
-
-        pargfid_str = gf_strdup (uuid_utoa(gfdb_db_record->pargfid));
-        if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating pargfid_str "
-                                "string failed.");
-                        goto out;
-        }
-
-        if (gfdb_db_record->link_consistency) {
-                ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name, 1,
-                                        _gf_false,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED,
-                                "Failed updating link flags in wind");
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
-}
-
-int
-gf_sql_delete_unwind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record)
-{
-        int ret = -1;
-        char *gfid_str = NULL;
-        char *pargfid_str = NULL;
-        gfdb_time_t *modtime    = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
-                goto out;
-        }
-
-        /*Nuke all the entries for this GFID from DB*/
-        if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) {
-                gf_sql_delete_all (sql_conn, gfid_str,
-                                gfdb_db_record->ignore_errors);
-        }
-        /*Remove link entries only*/
-        else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) {
-
-                pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating pargfid_str "
-                                "string failed.");
-                        goto out;
-                }
-
-                /* Special performance case:
-                 * Updating wind time in unwind for delete. This is done here
-                 * as in the wind path we will not know whether its the last
-                 * link or not. For a last link there is not use to update any
-                 * wind or unwind time!*/
-                if (gfdb_db_record->do_record_times) {
-                        /*Update the wind write times*/
-                        modtime = &gfdb_db_record->gfdb_wind_change_time;
-                        ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                _gf_true,
-                                isreadfop (gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_UPDATE_FAILED,
-                                        "Failed update wind time in DB");
-                                goto out;
-                        }
-                }
-
-                modtime = &gfdb_db_record->gfdb_unwind_change_time;
-
-                ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_DELETE_FAILED, "Failed deleting link");
-                        goto out;
-                }
-
-                if (gfdb_db_record->do_record_times &&
-                        gfdb_db_record->do_record_uwind_time) {
-                        ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                _gf_false,
-                                isreadfop(gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_UPDATE_FAILED,
-                                        "Failed update unwind time in DB");
-                                goto out;
-                        }
-                }
-        } else {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_INVALID_UPLINK, "Invalid unlink option");
-                goto out;
-        }
-        ret = 0;
-out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
-}
-
-/******************************************************************************
- *
- *                      Find/Query helper functions
- *
- * ****************************************************************************/
-int
-gf_sql_query_function (sqlite3_stmt              *prep_stmt,
-                      gf_query_callback_t       query_callback,
-                      void                      *_query_cbk_args)
-{
-        int ret                                         = -1;
-        gfdb_query_record_t *query_record               = NULL;
-        char *text_column                               = NULL;
-        sqlite3 *db_conn                                = NULL;
-        uuid_t  prev_gfid                               = {0};
-        uuid_t  curr_gfid                               = {0};
-        uuid_t  pgfid                                   = {0};
-        char *base_name                                 = NULL;
-        gf_boolean_t is_first_record                    = _gf_true;
-        gf_boolean_t is_query_empty                     = _gf_true;
-
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, prep_stmt, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, query_callback, out);
-
-        db_conn = sqlite3_db_handle(prep_stmt);
-
-        /*
-         * Loop to access queried rows
-         * Each db record will have 3 columns
-         * GFID, PGFID, FILE_NAME
-         *
-         * For file with multiple hard links we will get multiple query rows
-         * with the same GFID, but different PGID and FILE_NAME Combination
-         * For Example if a file with
-         *         GFID = 00000000-0000-0000-0000-000000000006
-         * has 3 hardlinks file1, file2 and file3 in 3 different folder
-         * with GFID's
-         * 00000000-0000-0000-0000-0000EFC00001,
-         * 00000000-0000-0000-0000-00000ABC0001 and
-         * 00000000-0000-0000-0000-00000ABC00CD
-         * Then there will be 3 records
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-0000EFC00001
-         *         FILE_NAME    : file1
-         *
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-00000ABC0001
-         *         FILE_NAME    : file2
-         *
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-00000ABC00CD
-         *         FILE_NAME    : file3
-         *
-         * This is retrieved and added to a single query_record
-         *
-         * query_record->gfid = 00000000-0000-0000-0000-000000000006
-         *                  ->link_info = {00000000-0000-0000-0000-0000EFC00001,
-         *                                 "file1"}
-         *                                  |
-         *                                  V
-         *             link_info = {00000000-0000-0000-0000-00000ABC0001,
-         *                                 "file2"}
-         *                                  |
-         *                                  V
-         *             link_info = {00000000-0000-0000-0000-00000ABC0001,
-         *                                 "file3",
-         *                                 list}
-         *
-         * This query record is sent to the registered query_callback()
-         *
-         * */
-        while ((ret = sqlite3_step (prep_stmt)) == SQLITE_ROW) {
-
-                if (sqlite3_column_count(prep_stmt) > 0) {
-
-                        is_query_empty = _gf_false;
-
-                        /*Retrieving GFID - column index is 0*/
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 0);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        "retrieve GFID");
-                                goto out;
-                        }
-                        ret = gf_uuid_parse (text_column, curr_gfid);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PARSE_FAILED, "Failed to parse "
-                                        "GFID");
-                                goto out;
-                        }
-
-                        /*
-                         * if the previous record was not of the current gfid
-                         * call the call_back function and send the
-                         * query record, which will have all the link_info
-                         * objects associated with this gfid
-                         *
-                         * */
-                        if (gf_uuid_compare (curr_gfid, prev_gfid) != 0) {
-
-                                /* If this is not the first record */
-                                if (!is_first_record) {
-                                        /*Call the call_back function provided*/
-                                        ret = query_callback (query_record,
-                                                        _query_cbk_args);
-                                        if (ret) {
-                                                gf_msg (GFDB_STR_SQLITE3,
-                                                        GF_LOG_ERROR, 0,
-                                                LG_MSG_QUERY_CALL_BACK_FAILED,
-                                                        "Query call back "
-                                                        "failed");
-                                                goto out;
-                                        }
-
-                                }
-
-                                /*Clear the query record*/
-                                gfdb_query_record_free (query_record);
-                                query_record = NULL;
-                                query_record = gfdb_query_record_new ();
-                                if (!query_record) {
-                                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                                0, LG_MSG_CREATE_FAILED,
-                                                "Failed to create "
-                                                "query_record");
-                                        goto out;
-                                }
-
-                                gf_uuid_copy(query_record->gfid,
-                                                                curr_gfid);
-                                gf_uuid_copy(prev_gfid, curr_gfid);
-
-                        }
-
-                        /* Get PGFID */
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 1);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " retrieve GF_ID");
-                                goto out;
-                        }
-                        ret = gf_uuid_parse (text_column, pgfid);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PARSE_FAILED, "Failed to parse "
-                                        "GF_ID");
-                                goto out;
-                        }
-
-                        /* Get Base name */
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 2);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " retrieve GF_ID");
-                                goto out;
-                        }
-                        base_name = text_column;
-
-
-                        /* Add link info to the list */
-                        ret = gfdb_add_link_to_query_record (query_record,
-                                                         pgfid, base_name);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " add link info to query record");
-                                goto out;
-                        }
-
-                        is_first_record = _gf_false;
-
-                }
-
-        }
-
-        if (ret != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to retrieve records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        if (!is_query_empty) {
-                /*
-                 * Call the call_back function for the last record from the
-                 * Database
-                 * */
-                ret = query_callback (query_record, _query_cbk_args);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_CALL_BACK_FAILED,
-                                "Query call back failed");
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        gfdb_query_record_free (query_record);
-        query_record = NULL;
-        return ret;
-}
-
-
-
-int
-gf_sql_clear_counters (gf_sql_connection_t *sql_conn)
-{
-        int ret                 = -1;
-        char *sql_strerror      = NULL;
-        char *query_str         = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        query_str = "UPDATE "
-                    GF_FILE_TABLE
-                    " SET " GF_COL_READ_FREQ_CNTR " = 0 , "
-                    GF_COL_WRITE_FREQ_CNTR " = 0 ;";
-
-        ret = sqlite3_exec (sql_conn->sqlite3_db_conn, query_str, NULL, NULL,
-                                &sql_strerror);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
-                        "Failed to execute: %s : %s",
-                        query_str, sql_strerror);
-                sqlite3_free (sql_strerror);
-                        ret = -1;
-                        goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h
deleted file mode 100644
index 0d222305d01..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_SQLITE3_HELPER_H
-#define __GFDB_SQLITE3_HELPER_H
-
-
-#include "gfdb_sqlite3.h"
-
-/******************************************************************************
- *
- *                      Helper functions for gf_sqlite3_insert()
- *
- * ****************************************************************************/
-
-
-int
-gf_sql_insert_wind (gf_sql_connection_t  *sql_conn,
-                   gfdb_db_record_t     *gfdb_db_record);
-
-int
-gf_sql_insert_unwind (gf_sql_connection_t  *sql_conn,
-                     gfdb_db_record_t     *gfdb_db_record);
-
-
-int
-gf_sql_update_delete_wind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record);
-
-int
-gf_sql_delete_unwind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record);
-
-
-
-
-
-/******************************************************************************
- *
- *                      Find/Query helper functions
- *
- * ****************************************************************************/
-
-
-int
-gf_sql_query_function (sqlite3_stmt              *prep_stmt,
-                      gf_query_callback_t       query_callback,
-                      void                      *_query_cbk_args);
-
-int
-gf_sql_clear_counters (gf_sql_connection_t *sql_conn);
-
-#endif
diff --git a/libglusterfs/src/gidcache.c b/libglusterfs/src/gidcache.c
index f2d98abefc3..64a93802f76 100644
--- a/libglusterfs/src/gidcache.c
+++ b/libglusterfs/src/gidcache.c
@@ -8,45 +8,48 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "gidcache.h"
-#include "mem-pool.h"
+#include "glusterfs/gidcache.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/common-utils.h"
 
 /*
  * We treat this as a very simple set-associative LRU cache, with entries aged
  * out after a configurable interval.  Hardly rocket science, but lots of
  * details to worry about.
  */
-#define BUCKET_START(p,n)       ((p) + ((n) * AUX_GID_CACHE_ASSOC))
+#define BUCKET_START(p, n) ((p) + ((n)*AUX_GID_CACHE_ASSOC))
 
 /*
  * Initialize the cache.
  */
-int gid_cache_init(gid_cache_t *cache, uint32_t timeout)
+int
+gid_cache_init(gid_cache_t *cache, uint32_t timeout)
 {
-	if (!cache)
-		return -1;
+    if (!cache)
+        return -1;
 
-	LOCK_INIT(&cache->gc_lock);
-	cache->gc_max_age = timeout;
-	cache->gc_nbuckets = AUX_GID_CACHE_BUCKETS;
-	memset(cache->gc_cache, 0, sizeof(gid_list_t) * AUX_GID_CACHE_SIZE);
+    LOCK_INIT(&cache->gc_lock);
+    cache->gc_max_age = timeout;
+    cache->gc_nbuckets = AUX_GID_CACHE_BUCKETS;
+    memset(cache->gc_cache, 0, sizeof(gid_list_t) * AUX_GID_CACHE_SIZE);
 
-	return 0;
+    return 0;
 }
 
 /*
  * Reconfigure the cache timeout.
  */
-int gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
+int
+gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
 {
-        if (!cache)
-                return -1;
+    if (!cache)
+        return -1;
 
-        LOCK(&cache->gc_lock);
-        cache->gc_max_age = timeout;
-        UNLOCK(&cache->gc_lock);
+    LOCK(&cache->gc_lock);
+    cache->gc_max_age = timeout;
+    UNLOCK(&cache->gc_lock);
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -54,153 +57,155 @@ int gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
  * an additional allocation and memory copy. The caller should copy the data and
  * release (unlock) the cache as soon as possible.
  */
-const gid_list_t *gid_cache_lookup(gid_cache_t *cache, uint64_t id,
-				   uint64_t uid, uint64_t gid)
+const gid_list_t *
+gid_cache_lookup(gid_cache_t *cache, uint64_t id, uint64_t uid, uint64_t gid)
 {
-	int bucket;
-	int i;
-	time_t now;
-	const gid_list_t *agl;
-
-	LOCK(&cache->gc_lock);
-	now = time(NULL);
-	bucket = id % cache->gc_nbuckets;
-	agl = BUCKET_START(cache->gc_cache, bucket);
-	for (i = 0; i < AUX_GID_CACHE_ASSOC; i++, agl++) {
-		if (!agl->gl_list)
-			continue;
-		if (agl->gl_id != id)
-			continue;
-
-		/*
-		  @uid and @gid reflect the latest UID/GID of the
-		   process performing the syscall (taken from frame->root).
-
-		   If the UID and GID has changed for the PID since the
-		   time we cached it, we should treat the cache as having
-		   stale values and query them freshly.
-		*/
-		if (agl->gl_uid != uid || agl->gl_gid != gid)
-			break;
-
-		/*
-		 * We don't put new entries in the cache when expiration=0, but
-		 * there might be entries still in there if expiration was
-		 * changed very recently.  Writing the check this way ensures
-		 * that they're not used.
-		 */
-		if (now < agl->gl_deadline) {
-			return agl;
-		}
-
-		/*
-		 * We're not going to find any more UID matches, and reaping
-		 * is handled further down to maintain LRU order.
-		 */
-		break;
-	}
-	UNLOCK(&cache->gc_lock);
-	return NULL;
+    int bucket;
+    int i;
+    time_t now;
+    const gid_list_t *agl;
+
+    now = gf_time();
+    LOCK(&cache->gc_lock);
+    bucket = id % cache->gc_nbuckets;
+    agl = BUCKET_START(cache->gc_cache, bucket);
+    for (i = 0; i < AUX_GID_CACHE_ASSOC; i++, agl++) {
+        if (!agl->gl_list)
+            continue;
+        if (agl->gl_id != id)
+            continue;
+
+        /*
+          @uid and @gid reflect the latest UID/GID of the
+           process performing the syscall (taken from frame->root).
+
+           If the UID and GID has changed for the PID since the
+           time we cached it, we should treat the cache as having
+           stale values and query them freshly.
+        */
+        if (agl->gl_uid != uid || agl->gl_gid != gid)
+            break;
+
+        /*
+         * We don't put new entries in the cache when expiration=0, but
+         * there might be entries still in there if expiration was
+         * changed very recently.  Writing the check this way ensures
+         * that they're not used.
+         */
+        if (now < agl->gl_deadline) {
+            return agl;
+        }
+
+        /*
+         * We're not going to find any more UID matches, and reaping
+         * is handled further down to maintain LRU order.
+         */
+        break;
+    }
+    UNLOCK(&cache->gc_lock);
+    return NULL;
 }
 
 /*
  * Release an entry found via lookup.
  */
-void gid_cache_release(gid_cache_t *cache, const gid_list_t *agl)
+void
+gid_cache_release(gid_cache_t *cache, const gid_list_t *agl)
 {
-	UNLOCK(&cache->gc_lock);
+    UNLOCK(&cache->gc_lock);
 }
 
 /*
  * Add a new list entry to the cache. If an entry for this ID already exists,
  * update it.
  */
-int gid_cache_add(gid_cache_t *cache, gid_list_t *gl)
+int
+gid_cache_add(gid_cache_t *cache, gid_list_t *gl)
 {
-	gid_list_t *agl;
-	int bucket;
-	int i;
-	time_t now;
-
-	if (!gl || !gl->gl_list)
-		return -1;
-
-	if (!cache->gc_max_age)
-		return 0;
-
-	LOCK(&cache->gc_lock);
-	now = time(NULL);
-
-	/*
-	 * Scan for the first free entry or one that matches this id. The id
-	 * check is added to address a bug where the cache might contain an
-	 * expired entry for this id. Since lookup occurs in LRU order and
-	 * does not reclaim entries, it will always return failure on discovery
-	 * of an expired entry. This leads to duplicate entries being added,
-	 * which still do not satisfy lookups until the expired entry (and
-	 * everything before it) is reclaimed.
-	 *
-	 * We address this through reuse of an entry already allocated to this
-	 * id, whether expired or not, since we have obviously already received
-	 * more recent data. The entry is repopulated with the new data and a new
-	 * deadline and is pushed forward to reside as the last populated entry in
-	 * the bucket.
-	 */
-	bucket = gl->gl_id % cache->gc_nbuckets;
-	agl = BUCKET_START(cache->gc_cache, bucket);
-	for (i = 0; i < AUX_GID_CACHE_ASSOC; ++i, ++agl) {
-		if (agl->gl_id == gl->gl_id)
-			break;
-		if (!agl->gl_list)
-			break;
-	}
-
-	/*
-	 * The way we allocate free entries naturally places the newest
-	 * ones at the highest indices, so evicting the lowest makes
-	 * sense, but that also means we can't just replace it with the
-	 * one that caused the eviction.  That would cause us to thrash
-	 * the first entry while others remain idle.  Therefore, we
-	 * need to slide the other entries down and add the new one at
-	 * the end just as if the *last* slot had been free.
-	 *
-	 * Deadline expiration is also handled here, since the oldest
-	 * expired entry will be in the first position.  This does mean
-	 * the bucket can stay full of expired entries if we're idle
-	 * but, if the small amount of extra memory or scan time before
-	 * we decide to evict someone ever become issues, we could
-	 * easily add a reaper thread.
-	 */
-
-	if (i >= AUX_GID_CACHE_ASSOC) {
-		/* cache full, evict the first (LRU) entry */
-		i = 0;
-		agl = BUCKET_START(cache->gc_cache, bucket);
-		GF_FREE(agl->gl_list);
-	} else if (agl->gl_list) {
-		/* evict the old entry we plan to reuse */
-		GF_FREE(agl->gl_list);
-	}
-
-	/*
-	 * If we have evicted an entry, slide the subsequent populated entries
-	 * back and populate the last entry.
-	 */
-	for (; i < AUX_GID_CACHE_ASSOC - 1; i++) {
-		if (!agl[1].gl_list)
-			break;
-		agl[0] = agl[1];
-		agl++;
-	}
-
-	agl->gl_id = gl->gl_id;
-	agl->gl_uid = gl->gl_uid;
-	agl->gl_gid = gl->gl_gid;
-	agl->gl_count = gl->gl_count;
-	agl->gl_list = gl->gl_list;
-	agl->gl_deadline = now + cache->gc_max_age;
-
-	UNLOCK(&cache->gc_lock);
-
-	return 1;
+    gid_list_t *agl;
+    int bucket;
+    int i;
+    time_t now;
+
+    if (!gl || !gl->gl_list)
+        return -1;
+
+    if (!cache->gc_max_age)
+        return 0;
+
+    now = gf_time();
+    LOCK(&cache->gc_lock);
+
+    /*
+     * Scan for the first free entry or one that matches this id. The id
+     * check is added to address a bug where the cache might contain an
+     * expired entry for this id. Since lookup occurs in LRU order and
+     * does not reclaim entries, it will always return failure on discovery
+     * of an expired entry. This leads to duplicate entries being added,
+     * which still do not satisfy lookups until the expired entry (and
+     * everything before it) is reclaimed.
+     *
+     * We address this through reuse of an entry already allocated to this
+     * id, whether expired or not, since we have obviously already received
+     * more recent data. The entry is repopulated with the new data and a new
+     * deadline and is pushed forward to reside as the last populated entry in
+     * the bucket.
+     */
+    bucket = gl->gl_id % cache->gc_nbuckets;
+    agl = BUCKET_START(cache->gc_cache, bucket);
+    for (i = 0; i < AUX_GID_CACHE_ASSOC; ++i, ++agl) {
+        if (agl->gl_id == gl->gl_id)
+            break;
+        if (!agl->gl_list)
+            break;
+    }
+
+    /*
+     * The way we allocate free entries naturally places the newest
+     * ones at the highest indices, so evicting the lowest makes
+     * sense, but that also means we can't just replace it with the
+     * one that caused the eviction.  That would cause us to thrash
+     * the first entry while others remain idle.  Therefore, we
+     * need to slide the other entries down and add the new one at
+     * the end just as if the *last* slot had been free.
+     *
+     * Deadline expiration is also handled here, since the oldest
+     * expired entry will be in the first position.  This does mean
+     * the bucket can stay full of expired entries if we're idle
+     * but, if the small amount of extra memory or scan time before
+     * we decide to evict someone ever become issues, we could
+     * easily add a reaper thread.
+     */
+
+    if (i >= AUX_GID_CACHE_ASSOC) {
+        /* cache full, evict the first (LRU) entry */
+        i = 0;
+        agl = BUCKET_START(cache->gc_cache, bucket);
+        GF_FREE(agl->gl_list);
+    } else if (agl->gl_list) {
+        /* evict the old entry we plan to reuse */
+        GF_FREE(agl->gl_list);
+    }
+
+    /*
+     * If we have evicted an entry, slide the subsequent populated entries
+     * back and populate the last entry.
+     */
+    for (; i < AUX_GID_CACHE_ASSOC - 1; i++) {
+        if (!agl[1].gl_list)
+            break;
+        agl[0] = agl[1];
+        agl++;
+    }
+
+    agl->gl_id = gl->gl_id;
+    agl->gl_uid = gl->gl_uid;
+    agl->gl_gid = gl->gl_gid;
+    agl->gl_count = gl->gl_count;
+    agl->gl_list = gl->gl_list;
+    agl->gl_deadline = now + cache->gc_max_age;
+
+    UNLOCK(&cache->gc_lock);
+
+    return 1;
 }
diff --git a/libglusterfs/src/glfs-message-id.h b/libglusterfs/src/glfs-message-id.h
deleted file mode 100644
index f14b0fb0818..00000000000
--- a/libglusterfs/src/glfs-message-id.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-  Copyright (c) 2015-2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _GLFS_MESSAGE_ID_H_
-#define _GLFS_MESSAGE_ID_H_
-
-/* Base of all message IDs, all message IDs would be
- * greater than this */
-#define GLFS_MSGID_BASE         100000
-
-/* Segment size of allocated range. Any component needing more than this
- * segment size should take multiple segments (at times non contiguous,
- * if extensions are being made post the next segment already allocated) */
-#define GLFS_MSGID_SEGMENT      1000
-
-/* Per module message segments allocated */
-/* NOTE: For any new module add to the end the modules */
-#define GLFS_MSGID_COMP_GLUSTERFSD         GLFS_MSGID_BASE
-#define GLFS_MSGID_COMP_GLUSTERFSD_END     GLFS_MSGID_COMP_GLUSTERFSD + \
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_LIBGLUSTERFS       GLFS_MSGID_COMP_GLUSTERFSD_END
-#define GLFS_MSGID_COMP_LIBGLUSTERFS_END   GLFS_MSGID_COMP_LIBGLUSTERFS + \
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_RPC_LIB            GLFS_MSGID_COMP_LIBGLUSTERFS_END
-#define GLFS_MSGID_COMP_RPC_LIB_END        GLFS_MSGID_COMP_RPC_LIB + \
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_RPC_TRANS_RDMA     GLFS_MSGID_COMP_RPC_LIB_END
-#define GLFS_MSGID_COMP_RPC_TRANS_RDMA_END (GLFS_MSGID_COMP_RPC_TRANS_RDMA + \
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_API                GLFS_MSGID_COMP_RPC_TRANS_RDMA_END
-#define GLFS_MSGID_COMP_API_END            GLFS_MSGID_COMP_API + \
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_CLI                GLFS_MSGID_COMP_API_END
-#define GLFS_MSGID_COMP_CLI_END            GLFS_MSGID_COMP_CLI + \
-                                           GLFS_MSGID_SEGMENT
-
-/* glusterd has a lot of messages, taking 2 segments for the same */
-#define GLFS_MSGID_GLUSTERD                GLFS_MSGID_COMP_CLI_END
-#define GLFS_MSGID_GLUSTERD_END            GLFS_MSGID_GLUSTERD + \
-                                           GLFS_MSGID_SEGMENT + \
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_AFR                GLFS_MSGID_GLUSTERD_END
-#define GLFS_MSGID_COMP_AFR_END            GLFS_MSGID_COMP_AFR +\
-                                           GLFS_MSGID_SEGMENT
-
-#define GLFS_MSGID_COMP_DHT                GLFS_MSGID_COMP_AFR_END
-#define GLFS_MSGID_COMP_DHT_END            GLFS_MSGID_COMP_DHT +\
-                                           GLFS_MSGID_SEGMENT
-
-
-/* there is no component called 'common', however reserving this segment
- * for common actions/errors like dict_{get/set}, memory accounting*/
-
-#define GLFS_MSGID_COMP_COMMON             GLFS_MSGID_COMP_DHT_END
-#define GLFS_MSGID_COMP_COMMON_END         (GLFS_MSGID_COMP_COMMON +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_UPCALL             GLFS_MSGID_COMP_COMMON_END
-#define GLFS_MSGID_COMP_UPCALL_END         (GLFS_MSGID_COMP_UPCALL +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_NFS                GLFS_MSGID_COMP_UPCALL_END
-#define GLFS_MSGID_COMP_NFS_END            (GLFS_MSGID_COMP_NFS +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_POSIX              GLFS_MSGID_COMP_NFS_END
-#define GLFS_MSGID_COMP_POSIX_END          (GLFS_MSGID_COMP_POSIX +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_PC                 GLFS_MSGID_COMP_POSIX_END
-#define GLFS_MSGID_COMP_PC_END             (GLFS_MSGID_COMP_PC +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_PS                 GLFS_MSGID_COMP_PC_END
-#define GLFS_MSGID_COMP_PS_END             (GLFS_MSGID_COMP_PS +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_BITROT_STUB        GLFS_MSGID_COMP_PS_END
-#define GLFS_MSGID_COMP_BITROT_STUB_END    (GLFS_MSGID_COMP_BITROT_STUB +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_CHANGELOG          GLFS_MSGID_COMP_BITROT_STUB_END
-#define GLFS_MSGID_COMP_CHANGELOG_END      (GLFS_MSGID_COMP_CHANGELOG +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_BITROT_BITD        GLFS_MSGID_COMP_CHANGELOG_END
-#define GLFS_MSGID_COMP_BITROT_BITD_END    (GLFS_MSGID_COMP_BITROT_BITD +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_RPC_TRANS_SOCKET        GLFS_MSGID_COMP_BITROT_BITD_END
-#define GLFS_MSGID_COMP_RPC_TRANS_SOCKET_END    (GLFS_MSGID_COMP_RPC_TRANS_SOCKET + \
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_QUOTA              GLFS_MSGID_COMP_RPC_TRANS_SOCKET_END
-#define GLFS_MSGID_COMP_QUOTA_END          (GLFS_MSGID_COMP_QUOTA +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_CTR                GLFS_MSGID_COMP_QUOTA_END
-#define GLFS_MSGID_COMP_CTR_END            (GLFS_MSGID_COMP_CTR+\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_EC               GLFS_MSGID_COMP_CTR_END
-#define GLFS_MSGID_COMP_EC_END           (GLFS_MSGID_COMP_EC +\
-                                         GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_IO_CACHE                GLFS_MSGID_COMP_EC_END
-#define GLFS_MSGID_COMP_IO_CACHE_END            (GLFS_MSGID_COMP_IO_CACHE+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_IO_THREADS              GLFS_MSGID_COMP_IO_CACHE_END
-#define GLFS_MSGID_COMP_IO_THREADS_END          (GLFS_MSGID_COMP_IO_THREADS+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_MD_CACHE                GLFS_MSGID_COMP_IO_THREADS_END
-#define GLFS_MSGID_COMP_MD_CACHE_END            (GLFS_MSGID_COMP_MD_CACHE+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_OPEN_BEHIND             GLFS_MSGID_COMP_MD_CACHE_END
-#define GLFS_MSGID_COMP_OPEN_BEHIND_END         (GLFS_MSGID_COMP_OPEN_BEHIND+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_QUICK_READ              GLFS_MSGID_COMP_OPEN_BEHIND_END
-#define GLFS_MSGID_COMP_QUICK_READ_END          (GLFS_MSGID_COMP_QUICK_READ+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_READ_AHEAD              GLFS_MSGID_COMP_QUICK_READ_END
-#define GLFS_MSGID_COMP_READ_AHEAD_END          (GLFS_MSGID_COMP_READ_AHEAD+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_READDIR_AHEAD           GLFS_MSGID_COMP_READ_AHEAD_END
-#define GLFS_MSGID_COMP_READDIR_AHEAD_END       (GLFS_MSGID_COMP_READDIR_AHEAD+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_SYMLINK_CACHE           \
-        GLFS_MSGID_COMP_READDIR_AHEAD_END
-#define GLFS_MSGID_COMP_SYMLINK_CACHE_END \
-(GLFS_MSGID_COMP_SYMLINK_CACHE+ \
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_WRITE_BEHIND             \
-GLFS_MSGID_COMP_SYMLINK_CACHE_END
-#define GLFS_MSGID_COMP_WRITE_BEHIND_END        (GLFS_MSGID_COMP_WRITE_BEHIND+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_CHANGELOG_LIB           GLFS_MSGID_COMP_WRITE_BEHIND_END
-#define GLFS_MSGID_COMP_CHANGELOG_LIB_END       (GLFS_MSGID_COMP_CHANGELOG_LIB+\
-                                                GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_SHARD               GLFS_MSGID_COMP_CHANGELOG_LIB_END
-#define GLFS_MSGID_COMP_SHARD_END           (GLFS_MSGID_COMP_SHARD +\
-                                             GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_JBR                     GLFS_MSGID_COMP_SHARD_END
-#define GLFS_MSGID_COMP_JBR_END                 (GLFS_MSGID_COMP_JBR +\
-                                                 GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_PL               GLFS_MSGID_COMP_JBR_END
-#define GLFS_MSGID_COMP_PL_END           (GLFS_MSGID_COMP_PL +\
-                                         GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_DC                     GLFS_MSGID_COMP_PL_END
-#define GLFS_MSGID_COMP_DC_END                 (GLFS_MSGID_COMP_DC +\
-                                                 GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_LEASES             GLFS_MSGID_COMP_DC_END
-#define GLFS_MSGID_COMP_LEASES_END         (GLFS_MSGID_COMP_LEASES +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_INDEX              GLFS_MSGID_COMP_LEASES_END
-#define GLFS_MSGID_COMP_INDEX_END          (GLFS_MSGID_COMP_INDEX +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_POSIX_ACL          GLFS_MSGID_COMP_INDEX_END
-#define GLFS_MSGID_COMP_POSIX_ACL_END      (GLFS_MSGID_COMP_POSIX_ACL +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_NLC                GLFS_MSGID_COMP_POSIX_ACL_END
-#define GLFS_MSGID_COMP_NLC_END            (GLFS_MSGID_COMP_NLC +\
-                                           GLFS_MSGID_SEGMENT)
-
-#define GLFS_MSGID_COMP_SL                 GLFS_MSGID_COMP_NLC
-#define GLFS_MSGID_COMP_SL_END             (GLFS_MSGID_COMP_SL +\
-                                            GLFS_MSGID_SEGMENT)
-
-
-
-/* --- new segments for messages goes above this line --- */
-
-#endif /* !_GLFS_MESSAGE_ID_H_ */
diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c
index 0ac1ab9b65b..ae06f8be386 100644
--- a/libglusterfs/src/globals.c
+++ b/libglusterfs/src/globals.c
@@ -10,81 +10,80 @@
 
 #include <pthread.h>
 
-#include "glusterfs.h"
-#include "globals.h"
-#include "xlator.h"
-#include "mem-pool.h"
-#include "syncop.h"
-#include "libglusterfs-messages.h"
-#include "upcall-utils.h"
+#include "glusterfs/syncop.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 const char *gf_fop_list[GF_FOP_MAXVALUE] = {
-        [GF_FOP_NULL]        = "NULL",
-        [GF_FOP_STAT]        = "STAT",
-        [GF_FOP_READLINK]    = "READLINK",
-        [GF_FOP_MKNOD]       = "MKNOD",
-        [GF_FOP_MKDIR]       = "MKDIR",
-        [GF_FOP_UNLINK]      = "UNLINK",
-        [GF_FOP_RMDIR]       = "RMDIR",
-        [GF_FOP_SYMLINK]     = "SYMLINK",
-        [GF_FOP_RENAME]      = "RENAME",
-        [GF_FOP_LINK]        = "LINK",
-        [GF_FOP_TRUNCATE]    = "TRUNCATE",
-        [GF_FOP_OPEN]        = "OPEN",
-        [GF_FOP_READ]        = "READ",
-        [GF_FOP_WRITE]       = "WRITE",
-        [GF_FOP_STATFS]      = "STATFS",
-        [GF_FOP_FLUSH]       = "FLUSH",
-        [GF_FOP_FSYNC]       = "FSYNC",
-        [GF_FOP_SETXATTR]    = "SETXATTR",
-        [GF_FOP_GETXATTR]    = "GETXATTR",
-        [GF_FOP_REMOVEXATTR] = "REMOVEXATTR",
-        [GF_FOP_OPENDIR]     = "OPENDIR",
-        [GF_FOP_FSYNCDIR]    = "FSYNCDIR",
-        [GF_FOP_ACCESS]      = "ACCESS",
-        [GF_FOP_CREATE]      = "CREATE",
-        [GF_FOP_FTRUNCATE]   = "FTRUNCATE",
-        [GF_FOP_FSTAT]       = "FSTAT",
-        [GF_FOP_LK]          = "LK",
-        [GF_FOP_LOOKUP]      = "LOOKUP",
-        [GF_FOP_READDIR]     = "READDIR",
-        [GF_FOP_INODELK]     = "INODELK",
-        [GF_FOP_FINODELK]    = "FINODELK",
-        [GF_FOP_ENTRYLK]     = "ENTRYLK",
-        [GF_FOP_FENTRYLK]    = "FENTRYLK",
-        [GF_FOP_XATTROP]     = "XATTROP",
-        [GF_FOP_FXATTROP]    = "FXATTROP",
-        [GF_FOP_FSETXATTR]   = "FSETXATTR",
-        [GF_FOP_FGETXATTR]   = "FGETXATTR",
-        [GF_FOP_RCHECKSUM]   = "RCHECKSUM",
-        [GF_FOP_SETATTR]     = "SETATTR",
-        [GF_FOP_FSETATTR]    = "FSETATTR",
-        [GF_FOP_READDIRP]    = "READDIRP",
-        [GF_FOP_GETSPEC]     = "GETSPEC",
-        [GF_FOP_FORGET]      = "FORGET",
-        [GF_FOP_RELEASE]     = "RELEASE",
-        [GF_FOP_RELEASEDIR]  = "RELEASEDIR",
-        [GF_FOP_FREMOVEXATTR]= "FREMOVEXATTR",
-	[GF_FOP_FALLOCATE]   = "FALLOCATE",
-	[GF_FOP_DISCARD]     = "DISCARD",
-        [GF_FOP_ZEROFILL]    = "ZEROFILL",
-        [GF_FOP_IPC]         = "IPC",
-        [GF_FOP_SEEK]        = "SEEK",
-        [GF_FOP_LEASE]       = "LEASE",
-        [GF_FOP_COMPOUND]    = "COMPOUND",
-        [GF_FOP_GETACTIVELK] = "GETACTIVELK",
-        [GF_FOP_SETACTIVELK] = "SETACTIVELK",
+    [GF_FOP_NULL] = "NULL",
+    [GF_FOP_STAT] = "STAT",
+    [GF_FOP_READLINK] = "READLINK",
+    [GF_FOP_MKNOD] = "MKNOD",
+    [GF_FOP_MKDIR] = "MKDIR",
+    [GF_FOP_UNLINK] = "UNLINK",
+    [GF_FOP_RMDIR] = "RMDIR",
+    [GF_FOP_SYMLINK] = "SYMLINK",
+    [GF_FOP_RENAME] = "RENAME",
+    [GF_FOP_LINK] = "LINK",
+    [GF_FOP_TRUNCATE] = "TRUNCATE",
+    [GF_FOP_OPEN] = "OPEN",
+    [GF_FOP_READ] = "READ",
+    [GF_FOP_WRITE] = "WRITE",
+    [GF_FOP_STATFS] = "STATFS",
+    [GF_FOP_FLUSH] = "FLUSH",
+    [GF_FOP_FSYNC] = "FSYNC",
+    [GF_FOP_SETXATTR] = "SETXATTR",
+    [GF_FOP_GETXATTR] = "GETXATTR",
+    [GF_FOP_REMOVEXATTR] = "REMOVEXATTR",
+    [GF_FOP_OPENDIR] = "OPENDIR",
+    [GF_FOP_FSYNCDIR] = "FSYNCDIR",
+    [GF_FOP_ACCESS] = "ACCESS",
+    [GF_FOP_CREATE] = "CREATE",
+    [GF_FOP_FTRUNCATE] = "FTRUNCATE",
+    [GF_FOP_FSTAT] = "FSTAT",
+    [GF_FOP_LK] = "LK",
+    [GF_FOP_LOOKUP] = "LOOKUP",
+    [GF_FOP_READDIR] = "READDIR",
+    [GF_FOP_INODELK] = "INODELK",
+    [GF_FOP_FINODELK] = "FINODELK",
+    [GF_FOP_ENTRYLK] = "ENTRYLK",
+    [GF_FOP_FENTRYLK] = "FENTRYLK",
+    [GF_FOP_XATTROP] = "XATTROP",
+    [GF_FOP_FXATTROP] = "FXATTROP",
+    [GF_FOP_FSETXATTR] = "FSETXATTR",
+    [GF_FOP_FGETXATTR] = "FGETXATTR",
+    [GF_FOP_RCHECKSUM] = "RCHECKSUM",
+    [GF_FOP_SETATTR] = "SETATTR",
+    [GF_FOP_FSETATTR] = "FSETATTR",
+    [GF_FOP_READDIRP] = "READDIRP",
+    [GF_FOP_GETSPEC] = "GETSPEC",
+    [GF_FOP_FORGET] = "FORGET",
+    [GF_FOP_RELEASE] = "RELEASE",
+    [GF_FOP_RELEASEDIR] = "RELEASEDIR",
+    [GF_FOP_FREMOVEXATTR] = "FREMOVEXATTR",
+    [GF_FOP_FALLOCATE] = "FALLOCATE",
+    [GF_FOP_DISCARD] = "DISCARD",
+    [GF_FOP_ZEROFILL] = "ZEROFILL",
+    [GF_FOP_IPC] = "IPC",
+    [GF_FOP_SEEK] = "SEEK",
+    [GF_FOP_LEASE] = "LEASE",
+    [GF_FOP_COMPOUND] = "COMPOUND",
+    [GF_FOP_GETACTIVELK] = "GETACTIVELK",
+    [GF_FOP_SETACTIVELK] = "SETACTIVELK",
+    [GF_FOP_PUT] = "PUT",
+    [GF_FOP_ICREATE] = "ICREATE",
+    [GF_FOP_NAMELINK] = "NAMELINK",
+    [GF_FOP_COPY_FILE_RANGE] = "COPY_FILE_RANGE",
 };
 
 const char *gf_upcall_list[GF_UPCALL_FLAGS_MAXVALUE] = {
-        [GF_UPCALL_NULL] = "NULL",
-        [GF_UPCALL] = "UPCALL",
-        [GF_UPCALL_CI_STAT] = "CI_IATT",
-        [GF_UPCALL_CI_XATTR] = "CI_XATTR",
-        [GF_UPCALL_CI_RENAME] = "CI_RENAME",
-        [GF_UPCALL_CI_NLINK] = "CI_UNLINK",
-        [GF_UPCALL_CI_FORGET] = "CI_FORGET",
-        [GF_UPCALL_LEASE_RECALL] = "LEASE_RECALL",
+    [GF_UPCALL_NULL] = "NULL",
+    [GF_UPCALL] = "UPCALL",
+    [GF_UPCALL_CI_STAT] = "CI_IATT",
+    [GF_UPCALL_CI_XATTR] = "CI_XATTR",
+    [GF_UPCALL_CI_RENAME] = "CI_RENAME",
+    [GF_UPCALL_CI_NLINK] = "CI_UNLINK",
+    [GF_UPCALL_CI_FORGET] = "CI_FORGET",
+    [GF_UPCALL_LEASE_RECALL] = "LEASE_RECALL",
 };
 
 /* THIS */
@@ -95,378 +94,273 @@ const char *gf_upcall_list[GF_UPCALL_FLAGS_MAXVALUE] = {
 glusterfs_ctx_t *global_ctx = NULL;
 pthread_mutex_t global_ctx_mutex = PTHREAD_MUTEX_INITIALIZER;
 xlator_t global_xlator;
-static pthread_key_t this_xlator_key;
-static pthread_key_t synctask_key;
-static pthread_key_t uuid_buf_key;
-static char          global_uuid_buf[GF_UUID_BUF_SIZE];
-static pthread_key_t lkowner_buf_key;
-static char          global_lkowner_buf[GF_LKOWNER_BUF_SIZE];
-static pthread_key_t leaseid_buf_key;
 static int gf_global_mem_acct_enable = 1;
 static pthread_once_t globals_inited = PTHREAD_ONCE_INIT;
 
+static pthread_key_t free_key;
 
-int
-gf_global_mem_acct_enable_get (void)
-{
-	return gf_global_mem_acct_enable;
-}
+static __thread xlator_t *thread_xlator = NULL;
+static __thread void *thread_synctask = NULL;
+static __thread void *thread_leaseid = NULL;
+static __thread struct syncopctx thread_syncopctx = {};
+static __thread char thread_uuid_buf[GF_UUID_BUF_SIZE] = {};
+static __thread char thread_lkowner_buf[GF_LKOWNER_BUF_SIZE] = {};
+static __thread char thread_leaseid_buf[GF_LEASE_ID_BUF_SIZE] = {};
 
 int
-gf_global_mem_acct_enable_set (int val)
+gf_global_mem_acct_enable_get(void)
 {
-	gf_global_mem_acct_enable = val;
-	return 0;
+    return gf_global_mem_acct_enable;
 }
 
-void
-glusterfs_this_destroy (void *ptr)
+int
+gf_global_mem_acct_enable_set(int val)
 {
-        FREE (ptr);
+    gf_global_mem_acct_enable = val;
+    return 0;
 }
 
 static struct xlator_cbks global_cbks = {
-        .forget                 = NULL,
-        .release                = NULL,
-        .releasedir             = NULL,
-        .invalidate             = NULL,
-        .client_destroy         = NULL,
-        .client_disconnect      = NULL,
-        .ictxmerge              = NULL,
-        .ictxsize               = NULL,
-        .fdctxsize              = NULL,
+    .forget = NULL,
+    .release = NULL,
+    .releasedir = NULL,
+    .invalidate = NULL,
+    .client_destroy = NULL,
+    .client_disconnect = NULL,
+    .ictxmerge = NULL,
+    .ictxsize = NULL,
+    .fdctxsize = NULL,
 };
 
-int
-glusterfs_this_init ()
-{
-        int  ret = 0;
-
-        ret = pthread_key_create (&this_xlator_key, glusterfs_this_destroy);
-        if (ret != 0) {
-                gf_msg ("", GF_LOG_WARNING, ret,
-                        LG_MSG_PTHREAD_KEY_CREATE_FAILED, "failed to create "
-                        "the pthread key");
-                return ret;
-        }
+/* This is required to get through the check in graph.c */
+static struct xlator_fops global_fops = {};
 
-        global_xlator.name = "glusterfs";
-        global_xlator.type = "global";
-        global_xlator.cbks = &global_cbks;
+static int
+global_xl_reconfigure(xlator_t *this, dict_t *options)
+{
+    int ret = -1;
+    gf_boolean_t bool_opt = _gf_false;
 
-        INIT_LIST_HEAD (&global_xlator.volume_options);
+    /* This is not added in volume dump, hence adding the options in log
+       would be helpful for debugging later */
+    dict_dump_to_log(options);
 
-        return ret;
-}
+    GF_OPTION_RECONF("measure-latency", bool_opt, options, bool, out);
+    this->ctx->measure_latency = bool_opt;
 
+    GF_OPTION_RECONF("metrics-dump-path", this->ctx->config.metrics_dumppath,
+                     options, str, out);
 
-xlator_t **
-__glusterfs_this_location ()
-{
-        xlator_t **this_location = NULL;
-        int        ret = 0;
-
-        this_location = pthread_getspecific (this_xlator_key);
-
-        if (!this_location) {
-                this_location = CALLOC (1, sizeof (*this_location));
-                if (!this_location)
-                        goto out;
-
-                ret = pthread_setspecific (this_xlator_key, this_location);
-                if (ret != 0) {
-                        FREE (this_location);
-                        this_location = NULL;
-                        goto out;
-                }
-        }
+    /* TODO: add more things here */
+    ret = 0;
 out:
-        if (this_location) {
-                if (!*this_location)
-                        *this_location = &global_xlator;
-        }
-        return this_location;
+    return ret;
 }
 
-
-xlator_t *
-glusterfs_this_get ()
+static int
+global_xl_init(xlator_t *this)
 {
-        xlator_t **this_location = NULL;
-
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return &global_xlator;
-
-        return *this_location;
-}
-
+    int ret = -1;
+    gf_boolean_t bool_opt = false;
 
-int
-glusterfs_this_set (xlator_t *this)
-{
-        xlator_t **this_location = NULL;
+    GF_OPTION_INIT("measure-latency", bool_opt, bool, out);
+    this->ctx->measure_latency = bool_opt;
 
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return -ENOMEM;
+    GF_OPTION_INIT("metrics-dump-path", this->ctx->config.metrics_dumppath, str,
+                   out);
 
-        *this_location = this;
+    ret = 0;
 
-        return 0;
+out:
+    return ret;
 }
 
-/* SYNCOPCTX */
-static pthread_key_t syncopctx_key;
-
 static void
-syncopctx_key_destroy (void *ptr)
+global_xl_fini(xlator_t *this)
 {
-	struct syncopctx *opctx = ptr;
-
-	if (opctx) {
-		if (opctx->groups)
-			GF_FREE (opctx->groups);
-
-		GF_FREE (opctx);
-	}
-
-	return;
+    return;
 }
 
-void *
-syncopctx_getctx ()
-{
-	void *opctx = NULL;
+struct volume_options global_xl_options[] = {
+    {.key = {"measure-latency"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .tags = {"global", "context"},
+     .description = "Use this option to toggle measuring latency"},
+    {.key = {"metrics-dump-path"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "{{gluster_workdir}}/metrics",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .tags = {"global", "context"},
+     .description = "Use this option to set the metrics dump path"},
+
+    {
+        .key = {NULL},
+    },
+};
 
-	opctx = pthread_getspecific (syncopctx_key);
+static volume_opt_list_t global_xl_opt_list;
 
-	return opctx;
+void
+glusterfs_this_init()
+{
+    global_xlator.name = "glusterfs";
+    global_xlator.type = GF_GLOBAL_XLATOR_NAME;
+    global_xlator.cbks = &global_cbks;
+    global_xlator.fops = &global_fops;
+    global_xlator.reconfigure = global_xl_reconfigure;
+    global_xlator.init = global_xl_init;
+    global_xlator.fini = global_xl_fini;
+
+    INIT_LIST_HEAD(&global_xlator.volume_options);
+    INIT_LIST_HEAD(&global_xl_opt_list.list);
+    global_xl_opt_list.given_opt = global_xl_options;
+
+    list_add_tail(&global_xl_opt_list.list, &global_xlator.volume_options);
 }
 
-int
-syncopctx_setctx (void *ctx)
+xlator_t **
+__glusterfs_this_location()
 {
-	int ret = 0;
+    xlator_t **this_location;
 
-	ret = pthread_setspecific (syncopctx_key, ctx);
+    this_location = &thread_xlator;
+    if (*this_location == NULL) {
+        thread_xlator = &global_xlator;
+    }
 
-	return ret;
+    return this_location;
 }
 
-static int
-syncopctx_init (void)
+xlator_t *
+glusterfs_this_get()
 {
-	int ret;
-
-	ret = pthread_key_create (&syncopctx_key, syncopctx_key_destroy);
-
-	return ret;
+    return *__glusterfs_this_location();
 }
 
-/* SYNCTASK */
-
-int
-synctask_init ()
+void
+glusterfs_this_set(xlator_t *this)
 {
-        int  ret = 0;
-
-        ret = pthread_key_create (&synctask_key, NULL);
-
-        return ret;
+    thread_xlator = this;
 }
 
+/* SYNCOPCTX */
+
 void *
-synctask_get ()
+syncopctx_getctx()
 {
-        void   *synctask = NULL;
-
-        synctask = pthread_getspecific (synctask_key);
-
-        return synctask;
+    return &thread_syncopctx;
 }
 
+/* SYNCTASK */
 
-int
-synctask_set (void *synctask)
+void *
+synctask_get()
 {
-        int     ret = 0;
-
-        pthread_setspecific (synctask_key, synctask);
-
-        return ret;
+    return thread_synctask;
 }
 
-//UUID_BUFFER
-
 void
-glusterfs_uuid_buf_destroy (void *ptr)
+synctask_set(void *synctask)
 {
-        FREE (ptr);
+    thread_synctask = synctask;
 }
 
-int
-glusterfs_uuid_buf_init ()
-{
-        int ret = 0;
-
-        ret = pthread_key_create (&uuid_buf_key,
-                                  glusterfs_uuid_buf_destroy);
-        return ret;
-}
+// UUID_BUFFER
 
 char *
-glusterfs_uuid_buf_get ()
+glusterfs_uuid_buf_get()
 {
-        char *buf;
-        int ret = 0;
-
-        buf = pthread_getspecific (uuid_buf_key);
-        if(!buf) {
-                buf = MALLOC (GF_UUID_BUF_SIZE);
-                ret = pthread_setspecific (uuid_buf_key, (void *) buf);
-                if (ret)
-                        buf = global_uuid_buf;
-        }
-        return buf;
+    return thread_uuid_buf;
 }
 
 /* LKOWNER_BUFFER */
 
-void
-glusterfs_lkowner_buf_destroy (void *ptr)
+char *
+glusterfs_lkowner_buf_get()
 {
-        FREE (ptr);
+    return thread_lkowner_buf;
 }
 
-int
-glusterfs_lkowner_buf_init ()
-{
-        int ret = 0;
-
-        ret = pthread_key_create (&lkowner_buf_key,
-                                  glusterfs_lkowner_buf_destroy);
-        return ret;
-}
+/* Leaseid buffer */
 
 char *
-glusterfs_lkowner_buf_get ()
+glusterfs_leaseid_buf_get()
 {
-        char *buf;
-        int ret = 0;
-
-        buf = pthread_getspecific (lkowner_buf_key);
-        if(!buf) {
-                buf = MALLOC (GF_LKOWNER_BUF_SIZE);
-                ret = pthread_setspecific (lkowner_buf_key, (void *) buf);
-                if (ret)
-                        buf = global_lkowner_buf;
-        }
-        return buf;
+    char *buf = NULL;
+
+    buf = thread_leaseid;
+    if (buf == NULL) {
+        buf = thread_leaseid_buf;
+        thread_leaseid = buf;
+    }
+
+    return buf;
 }
 
-/* Leaseid buffer */
-void
-glusterfs_leaseid_buf_destroy (void *ptr)
+char *
+glusterfs_leaseid_exist()
 {
-        FREE (ptr);
+    return thread_leaseid;
 }
 
-int
-glusterfs_leaseid_buf_init ()
+static void
+glusterfs_cleanup(void *ptr)
 {
-        int ret = 0;
+    if (thread_syncopctx.groups != NULL) {
+        GF_FREE(thread_syncopctx.groups);
+    }
 
-        ret = pthread_key_create (&leaseid_buf_key,
-                                  glusterfs_leaseid_buf_destroy);
-        return ret;
+    mem_pool_thread_destructor(NULL);
 }
 
-char *
-glusterfs_leaseid_buf_get ()
+void
+gf_thread_needs_cleanup(void)
 {
-        char *buf = NULL;
-        int   ret = 0;
-
-        buf = pthread_getspecific (leaseid_buf_key);
-        if (!buf) {
-                buf = CALLOC (1, GF_LEASE_ID_BUF_SIZE);
-                ret = pthread_setspecific (leaseid_buf_key, (void *) buf);
-                if (ret) {
-                        FREE (buf);
-                        buf = NULL;
-                }
-        }
-        return buf;
+    /* The value stored in free_key TLS is not really used for anything, but
+     * pthread implementation doesn't call the TLS destruction function unless
+     * it's != NULL. This function must be called whenever something is
+     * allocated for this thread so that glusterfs_cleanup() will be called
+     * and resources can be released. */
+    (void)pthread_setspecific(free_key, (void *)1);
 }
 
 static void
-gf_globals_init_once ()
+gf_globals_init_once()
 {
-        int ret = 0;
-
-        ret = glusterfs_this_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_TRANSLATOR_INIT_FAILED,
-                        "ERROR: glusterfs-translator init failed");
-                goto out;
-        }
-
-        ret = glusterfs_uuid_buf_init ();
-        if(ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_UUID_BUF_INIT_FAILED,
-                        "ERROR: glusterfs uuid buffer init failed");
-                goto out;
-        }
-
-        ret = glusterfs_lkowner_buf_init ();
-        if(ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_LKOWNER_BUF_INIT_FAILED,
-                        "ERROR: glusterfs lkowner buffer init failed");
-                goto out;
-        }
-
-        ret = glusterfs_leaseid_buf_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_LEASEID_BUF_INIT_FAILED,
-                        "ERROR: glusterfs leaseid buffer init failed");
-                goto out;
-        }
-
-        ret = synctask_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCTASK_INIT_FAILED,
-                        "ERROR: glusterfs synctask init failed");
-                goto out;
-        }
-
-        ret = syncopctx_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCOPCTX_INIT_FAILED,
-                        "ERROR: glusterfs syncopctx init failed");
-                goto out;
-        }
-out:
+    int ret = 0;
+
+    glusterfs_this_init();
+
+    /* This is needed only to cleanup the potential allocation of
+     * thread_syncopctx.groups. */
+    ret = pthread_key_create(&free_key, glusterfs_cleanup);
+    if (ret != 0) {
+        gf_msg("", GF_LOG_ERROR, ret, LG_MSG_PTHREAD_KEY_CREATE_FAILED,
+               "failed to create the pthread key");
+
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_GLOBAL_INIT_FAILED,
+               "Exiting as global initialization failed");
 
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_GLOBAL_INIT_FAILED,
-                        "Exiting as global initialization failed");
-                exit (ret);
-        }
+        exit(ret);
+    }
 }
 
 int
-glusterfs_globals_init (glusterfs_ctx_t *ctx)
+glusterfs_globals_init(glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
+    int ret = 0;
 
-        gf_log_globals_init (ctx, GF_LOG_INFO);
+    gf_log_globals_init(ctx, GF_LOG_INFO);
 
-        ret =  pthread_once (&globals_inited, gf_globals_init_once);
+    ret = pthread_once(&globals_inited, gf_globals_init_once);
 
-        if (ret)
-                gf_msg ("", GF_LOG_CRITICAL, ret, LG_MSG_PTHREAD_FAILED,
-                        "pthread_once failed");
+    if (ret)
+        gf_msg("", GF_LOG_CRITICAL, ret, LG_MSG_PTHREAD_FAILED,
+               "pthread_once failed");
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h
deleted file mode 100644
index 365183d1562..00000000000
--- a/libglusterfs/src/globals.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _GLOBALS_H
-#define _GLOBALS_H
-
-#define GF_DEFAULT_BASE_PORT 24007
-#define GF_DEFAULT_VOLFILE_TRANSPORT "tcp"
-
-#define GD_OP_VERSION_KEY     "operating-version"
-#define GD_MIN_OP_VERSION_KEY "minimum-operating-version"
-#define GD_MAX_OP_VERSION_KEY "maximum-operating-version"
-
-/* Gluster versions - OP-VERSION mapping
- *
- * 3.3.x                - 1
- * 3.4.x                - 2
- * 3.5.0                - 3
- * 3.5.1                - 30501
- * 3.6.0                - 30600
- * 3.7.0                - 30700
- * 3.7.1                - 30701
- * 3.7.2                - 30702
- *
- * Starting with Gluster v3.6, the op-version will be multi-digit integer values
- * based on the Glusterfs version, instead of a simply incrementing integer
- * value. The op-version for a given X.Y.Z release will be an integer XYZ, with
- * Y and Z 2 digit always 2 digits wide and padded with 0 when needed. This
- * should allow for some gaps between two Y releases for backports of features
- * in Z releases.
- */
-#define GD_OP_VERSION_MIN  1 /* MIN is the fresh start op-version, mostly
-                                should not change */
-#define GD_OP_VERSION_MAX  GD_OP_VERSION_3_12_2 /* MAX VERSION is the maximum
-                                                  count in VME table, should
-                                                  keep changing with
-                                                  introduction of newer
-                                                  versions */
-
-#define GD_OP_VERSION_3_6_0    30600 /* Op-Version for GlusterFS 3.6.0 */
-
-#define GD_OP_VERSION_3_7_0    30700 /* Op-version for GlusterFS 3.7.0 */
-
-#define GD_OP_VERSION_3_7_1    30701 /* Op-version for GlusterFS 3.7.1 */
-
-#define GD_OP_VERSION_3_7_2    30702 /* Op-version for GlusterFS 3.7.2 */
-
-#define GD_OP_VERSION_3_7_3    30703 /* Op-version for GlusterFS 3.7.3 */
-
-#define GD_OP_VERSION_3_7_4    30704 /* Op-version for GlusterFS 3.7.4 */
-
-#define GD_OP_VERSION_3_7_5    30705 /* Op-version for GlusterFS 3.7.5 */
-
-#define GD_OP_VERSION_3_7_6    30706 /* Op-version for GlusterFS 3.7.6 */
-
-#define GD_OP_VERSION_3_7_7    30707 /* Op-version for GlusterFS 3.7.7 */
-
-#define GD_OP_VERSION_3_7_10   30710 /* Op-version for GlusterFS 3.7.10 */
-
-#define GD_OP_VERSION_3_7_12   30712 /* Op-version for GlusterFS 3.7.12 */
-
-#define GD_OP_VERSION_3_8_0    30800 /* Op-version for GlusterFS 3.8.0 */
-
-#define GD_OP_VERSION_3_8_3    30803 /* Op-version for GlusterFS 3.8.3 */
-
-#define GD_OP_VERSION_3_8_4    30804 /* Op-version for GlusterFS 3.8.4 */
-
-#define GD_OP_VERSION_3_9_0    30900 /* Op-version for GlusterFS 3.9.0 */
-
-#define GD_OP_VERSION_3_9_1    30901 /* Op-version for GlusterFS 3.9.1 */
-
-#define GD_OP_VERSION_3_10_0   31000 /* Op-version for GlusterFS 3.10.0 */
-
-#define GD_OP_VERSION_3_10_1   31001 /* Op-version for GlusterFS 3.10.1 */
-
-#define GD_OP_VERSION_3_10_2   31002 /* Op-version for GlusterFS 3.10.2 */
-
-#define GD_OP_VERSION_3_11_0   31100 /* Op-version for GlusterFS 3.11.0 */
-
-#define GD_OP_VERSION_3_11_1   31101 /* Op-version for GlusterFS 3.11.1 */
-
-#define GD_OP_VERSION_3_12_0   31200 /* Op-version for GlusterFS 3.12.0 */
-
-#define GD_OP_VERSION_3_12_2   31202 /* Op-version for GlusterFS 3.12.2 */
-
-#define GD_OP_VER_PERSISTENT_AFR_XATTRS GD_OP_VERSION_3_6_0
-
-#include "xlator.h"
-
-/* THIS */
-#define THIS (*__glusterfs_this_location())
-#define DECLARE_OLD_THIS        xlator_t *old_THIS = THIS
-
-xlator_t **__glusterfs_this_location (void);
-xlator_t *glusterfs_this_get (void);
-int glusterfs_this_set (xlator_t *);
-
-/* syncopctx */
-void *syncopctx_getctx (void);
-int syncopctx_setctx (void *ctx);
-
-/* task */
-void *synctask_get (void);
-int synctask_set (void *);
-
-/* uuid_buf */
-char *glusterfs_uuid_buf_get (void);
-/* lkowner_buf */
-char *glusterfs_lkowner_buf_get (void);
-/* leaseid buf */
-char *glusterfs_leaseid_buf_get (void);
-
-/* init */
-int glusterfs_globals_init (glusterfs_ctx_t *ctx);
-
-struct tvec_base* glusterfs_ctx_tw_get (glusterfs_ctx_t *ctx);
-void glusterfs_ctx_tw_put (glusterfs_ctx_t *ctx);
-
-extern const char *gf_fop_list[];
-extern const char *gf_upcall_list[];
-
-/* mem acct enable/disable */
-int gf_global_mem_acct_enable_get (void);
-int gf_global_mem_acct_enable_set (int val);
-#endif /* !_GLOBALS_H */
diff --git a/libglusterfs/src/glusterfs-acl.h b/libglusterfs/src/glusterfs-acl.h
deleted file mode 100644
index 2a1661686bc..00000000000
--- a/libglusterfs/src/glusterfs-acl.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _GLUSTERFS_ACL_H
-#define _GLUSTERFS_ACL_H
-
-
-/* WARNING: Much if this code is restricted to Linux usage.
- *
- * It would be much cleaner to replace the code with something that is based on
- * libacl (or its libc implementation on *BSD).
- *
- * Initial work for replacing this Linux specific implementation has been
- * started as part of the "Improve POSIX ACLs" feature. Functionality for this
- * feature has been added to the end of this file.
- */
-
-#include <stdint.h>
-#include <sys/types.h> /* For uid_t */
-
-#include "locking.h" /* For gf_lock_t in struct posix_acl_conf */
-
-#define ACL_PROGRAM    100227
-#define ACLV3_VERSION  3
-
-#define POSIX_ACL_MINIMAL_ACE_COUNT   3
-
-#define POSIX_ACL_READ                (0x04)
-#define POSIX_ACL_WRITE               (0x02)
-#define POSIX_ACL_EXECUTE             (0x01)
-
-#define POSIX_ACL_UNDEFINED_TAG       (0x00)
-#define POSIX_ACL_USER_OBJ            (0x01)
-#define POSIX_ACL_USER                (0x02)
-#define POSIX_ACL_GROUP_OBJ           (0x04)
-#define POSIX_ACL_GROUP               (0x08)
-#define POSIX_ACL_MASK                (0x10)
-#define POSIX_ACL_OTHER               (0x20)
-
-#define POSIX_ACL_UNDEFINED_ID        (-1)
-
-#define POSIX_ACL_XATTR_VERSION       (0x02)
-
-#define POSIX_ACL_ACCESS_XATTR        "system.posix_acl_access"
-#define POSIX_ACL_DEFAULT_XATTR       "system.posix_acl_default"
-
-struct posix_acl_xattr_entry {
-        uint16_t            tag;
-        uint16_t            perm;
-        uint32_t            id;
-};
-
-struct posix_acl_xattr_header {
-        uint32_t                        version;
-        struct posix_acl_xattr_entry    entries[];
-};
-
-typedef struct posix_acl_xattr_entry  posix_acl_xattr_entry;
-typedef struct posix_acl_xattr_header posix_acl_xattr_header;
-
-static inline size_t
-posix_acl_xattr_size (unsigned int count)
-{
-        return (sizeof(posix_acl_xattr_header) +
-                       (count * sizeof(posix_acl_xattr_entry)));
-}
-
-static inline ssize_t
-posix_acl_xattr_count (size_t size)
-{
-        if (size < sizeof(posix_acl_xattr_header))
-                return (-1);
-        size -= sizeof(posix_acl_xattr_header);
-        if (size % sizeof(posix_acl_xattr_entry))
-                return (-1);
-        return (size / sizeof(posix_acl_xattr_entry));
-}
-
-struct posix_ace {
-        uint16_t     tag;
-        uint16_t     perm;
-        uint32_t     id;
-};
-
-
-struct posix_acl {
-        int               refcnt;
-        int               count;
-        struct posix_ace  entries[];
-};
-
-struct posix_acl_ctx {
-        uid_t             uid;
-        gid_t             gid;
-        mode_t            perm;
-        glusterfs_fop_t   fop;
-        struct posix_acl *acl_access;
-        struct posix_acl *acl_default;
-};
-
-struct posix_acl_conf {
-        gf_lock_t         acl_lock;
-        uid_t             super_uid;
-        struct posix_acl *minimal_acl;
-};
-
-
-/* Above this comment, the legacy POSIX ACL support is kept until it is not
- * used anymore. Below you will find the more portable version to support POSIX
- * ACls based on the implementation of libacl (see sys/acl.h). */
-
-/* virtual xattrs passed over RPC, not stored on disk */
-#define GF_POSIX_ACL_ACCESS       "glusterfs.posix.acl"
-#define GF_POSIX_ACL_DEFAULT      "glusterfs.posix.default_acl"
-#define GF_POSIX_ACL_REQUEST(key) \
-        (!strncmp(key, GF_POSIX_ACL_ACCESS, strlen(GF_POSIX_ACL_ACCESS)) || \
-         !strncmp(key, GF_POSIX_ACL_DEFAULT, strlen(GF_POSIX_ACL_DEFAULT)))
-
-#ifdef HAVE_SYS_ACL_H /* only NetBSD does not support POSIX ACLs */
-
-#include <sys/acl.h>
-
-static inline const char*
-gf_posix_acl_get_key (const acl_type_t type)
-{
-        char *acl_key = NULL;
-
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                acl_key = GF_POSIX_ACL_ACCESS;
-                break;
-        case ACL_TYPE_DEFAULT:
-                acl_key = GF_POSIX_ACL_DEFAULT;
-                break;
-        default:
-                errno = EINVAL;
-        }
-
-        return acl_key;
-}
-
-static inline const acl_type_t
-gf_posix_acl_get_type (const char *key)
-{
-        acl_type_t type = 0;
-
-        if (!strncmp (key, GF_POSIX_ACL_ACCESS, strlen (GF_POSIX_ACL_ACCESS)))
-                type = ACL_TYPE_ACCESS;
-        else if (!strncmp (key, GF_POSIX_ACL_DEFAULT,
-                           strlen (GF_POSIX_ACL_DEFAULT)))
-                type = ACL_TYPE_DEFAULT;
-        else
-                errno = EINVAL;
-
-        return type;
-}
-
-#endif /* HAVE_SYS_ACL_H */
-#endif /* _GLUSTERFS_ACL_H */
diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h
deleted file mode 100644
index 18256aad8fc..00000000000
--- a/libglusterfs/src/glusterfs.h
+++ /dev/null
@@ -1,639 +0,0 @@
-/*
-  Copyright (c) 2008-2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _GLUSTERFS_H
-#define _GLUSTERFS_H
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <netdb.h>
-#include <errno.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <arpa/inet.h>
-#include <sys/poll.h>
-#include <pthread.h>
-#include <limits.h> /* For PATH_MAX */
-#include <openssl/sha.h>
-
-#include "glusterfs-fops.h" /* generated XDR values for FOPs */
-
-#include "list.h"
-#include "locking.h"
-#include "logging.h"
-#include "lkowner.h"
-#include "compat-uuid.h"
-#include "refcount.h"
-#include "atomic.h"
-
-#define GF_YES 1
-#define GF_NO  0
-
-#ifndef O_LARGEFILE
-/* savannah bug #20053, patch for compiling on darwin */
-#define O_LARGEFILE 0100000 /* from bits/fcntl.h */
-#endif
-
-#ifndef O_FMODE_EXEC
-/* redhat bug 843080, added from linux/fs.h */
-#define O_FMODE_EXEC 040 //0x20
-#endif
-
-#ifndef O_DIRECT
-/* savannah bug #20050, #20052 */
-#define O_DIRECT 0 /* From asm/fcntl.h */
-#endif
-
-#ifndef O_DIRECTORY
-/* FreeBSD does not need O_DIRECTORY */
-#define O_DIRECTORY 0
-#endif
-
-#ifndef EBADFD
-/* Mac OS X does not have EBADFD */
-#define EBADFD EBADF
-#endif
-
-#ifndef FNM_EXTMATCH
-#define FNM_EXTMATCH 0
-#endif
-
-#define GLUSTERD_MAX_SNAP_NAME  255
-#define GLUSTERFS_SOCKET_LISTEN_BACKLOG  10
-#define ZR_MOUNTPOINT_OPT       "mountpoint"
-#define ZR_ATTR_TIMEOUT_OPT     "attribute-timeout"
-#define ZR_ENTRY_TIMEOUT_OPT    "entry-timeout"
-#define ZR_NEGATIVE_TIMEOUT_OPT "negative-timeout"
-#define ZR_DIRECT_IO_OPT        "direct-io-mode"
-#define ZR_STRICT_VOLFILE_CHECK "strict-volfile-check"
-#define ZR_DUMP_FUSE            "dump-fuse"
-#define ZR_FUSE_MOUNTOPTS       "fuse-mountopts"
-
-#define GF_XATTR_CLRLK_CMD      "glusterfs.clrlk"
-#define GF_XATTR_PATHINFO_KEY   "trusted.glusterfs.pathinfo"
-#define GF_XATTR_NODE_UUID_KEY  "trusted.glusterfs.node-uuid"
-#define GF_XATTR_LIST_NODE_UUIDS_KEY "trusted.glusterfs.list-node-uuids"
-#define GF_REBAL_FIND_LOCAL_SUBVOL "glusterfs.find-local-subvol"
-#define GF_REBAL_OLD_FIND_LOCAL_SUBVOL "glusterfs.old-find-local-subvol"
-#define GF_XATTR_VOL_ID_KEY   "trusted.glusterfs.volume-id"
-#define GF_XATTR_LOCKINFO_KEY   "trusted.glusterfs.lockinfo"
-#define GF_META_LOCK_KEY        "glusterfs.lock-migration-meta-lock"
-#define GF_META_UNLOCK_KEY      "glusterfs.lock-migration-meta-unlock"
-#define GF_XATTR_GET_REAL_FILENAME_KEY "glusterfs.get_real_filename:"
-#define GF_XATTR_USER_PATHINFO_KEY   "glusterfs.pathinfo"
-#define GF_INTERNAL_IGNORE_DEEM_STATFS "ignore-deem-statfs"
-#define GF_XATTR_IOSTATS_DUMP_KEY "trusted.io-stats-dump"
-
-#define GF_READDIR_SKIP_DIRS       "readdir-filter-directories"
-#define GF_MDC_LOADED_KEY_NAMES     "glusterfs.mdc.loaded.key.names"
-
-#define BD_XATTR_KEY             "user.glusterfs"
-#define GF_PREOP_PARENT_KEY      "glusterfs.preop.parent.key"
-#define GF_PREOP_CHECK_FAILED    "glusterfs.preop.check.failed"
-
-#define XATTR_IS_PATHINFO(x)  ((strncmp (x, GF_XATTR_PATHINFO_KEY,       \
-                                        strlen (x)) == 0) ||             \
-                              (strncmp (x, GF_XATTR_USER_PATHINFO_KEY,   \
-                                         strlen (x)) == 0))
-#define XATTR_IS_NODE_UUID(x) (strncmp (x, GF_XATTR_NODE_UUID_KEY,      \
-                                        strlen (GF_XATTR_NODE_UUID_KEY)) == 0)
-#define XATTR_IS_NODE_UUID_LIST(x) (strncmp (x, GF_XATTR_LIST_NODE_UUIDS_KEY, \
-                                    strlen (GF_XATTR_LIST_NODE_UUIDS_KEY)) == 0)
-#define XATTR_IS_LOCKINFO(x) (strncmp (x, GF_XATTR_LOCKINFO_KEY,        \
-                                       strlen (GF_XATTR_LOCKINFO_KEY)) == 0)
-
-#define XATTR_IS_BD(x) (strncmp (x, BD_XATTR_KEY, strlen (BD_XATTR_KEY)) == 0)
-
-#define GF_XATTR_LINKINFO_KEY   "trusted.distribute.linkinfo"
-#define GFID_XATTR_KEY          "trusted.gfid"
-#define PGFID_XATTR_KEY_PREFIX  "trusted.pgfid."
-#define GFID2PATH_VIRT_XATTR_KEY  "glusterfs.gfidtopath"
-#define GFID2PATH_XATTR_KEY_PREFIX  "trusted.gfid2path."
-#define GFID2PATH_XATTR_KEY_PREFIX_LENGTH 18
-#define VIRTUAL_GFID_XATTR_KEY_STR  "glusterfs.gfid.string"
-#define VIRTUAL_GFID_XATTR_KEY      "glusterfs.gfid"
-#define UUID_CANONICAL_FORM_LEN 36
-
-#define GET_ANCESTRY_PATH_KEY "glusterfs.ancestry.path"
-#define GET_ANCESTRY_DENTRY_KEY "glusterfs.ancestry.dentry"
-
-#define BITROT_DEFAULT_CURRENT_VERSION  (unsigned long)1
-#define BITROT_DEFAULT_SIGNING_VERSION  (unsigned long)0
-
-/* on-disk object signature keys */
-#define BITROT_OBJECT_BAD_KEY       "trusted.bit-rot.bad-file"
-#define BITROT_CURRENT_VERSION_KEY  "trusted.bit-rot.version"
-#define BITROT_SIGNING_VERSION_KEY  "trusted.bit-rot.signature"
-
-/* globally usable bad file marker */
-#define GLUSTERFS_BAD_INODE         "glusterfs.bad-inode"
-
-/* on-disk size of signing xattr (not the signature itself) */
-#define BITROT_SIGNING_XATTR_SIZE_KEY  "trusted.glusterfs.bit-rot.size"
-
-/* GET/SET object signature */
-#define GLUSTERFS_GET_OBJECT_SIGNATURE "trusted.glusterfs.get-signature"
-#define GLUSTERFS_SET_OBJECT_SIGNATURE "trusted.glusterfs.set-signature"
-
-/* operation needs to be durable on-disk */
-#define GLUSTERFS_DURABLE_OP           "trusted.glusterfs.durable-op"
-
-/* key for version exchange b/w bitrot stub and changelog */
-#define GLUSTERFS_VERSION_XCHG_KEY     "glusterfs.version.xchg"
-
-#define GLUSTERFS_INTERNAL_FOP_KEY  "glusterfs-internal-fop"
-#define DHT_CHANGELOG_RENAME_OP_KEY   "changelog.rename-op"
-
-#define ZR_FILE_CONTENT_STR     "glusterfs.file."
-#define ZR_FILE_CONTENT_STRLEN 15
-
-#define GLUSTERFS_WRITE_IS_APPEND "glusterfs.write-is-append"
-#define GLUSTERFS_WRITE_UPDATE_ATOMIC "glusterfs.write-update-atomic"
-#define GLUSTERFS_OPEN_FD_COUNT "glusterfs.open-fd-count"
-#define GLUSTERFS_INODELK_COUNT "glusterfs.inodelk-count"
-#define GLUSTERFS_ENTRYLK_COUNT "glusterfs.entrylk-count"
-#define GLUSTERFS_POSIXLK_COUNT "glusterfs.posixlk-count"
-#define GLUSTERFS_PARENT_ENTRYLK "glusterfs.parent-entrylk"
-#define GLUSTERFS_INODELK_DOM_COUNT "glusterfs.inodelk-dom-count"
-#define GFID_TO_PATH_KEY "glusterfs.gfid2path"
-#define GF_XATTR_STIME_PATTERN "trusted.glusterfs.*.stime"
-#define GF_XATTR_XTIME_PATTERN "trusted.glusterfs.*.xtime"
-#define GF_XATTR_TRIGGER_SYNC "glusterfs.geo-rep.trigger-sync"
-
-/* quota xattrs */
-#define QUOTA_SIZE_KEY "trusted.glusterfs.quota.size"
-#define QUOTA_LIMIT_KEY "trusted.glusterfs.quota.limit-set"
-#define QUOTA_LIMIT_OBJECTS_KEY "trusted.glusterfs.quota.limit-objects"
-#define VIRTUAL_QUOTA_XATTR_CLEANUP_KEY "glusterfs.quota-xattr-cleanup"
-#define QUOTA_READ_ONLY_KEY "trusted.glusterfs.quota.read-only"
-
-/* afr related */
-#define AFR_XATTR_PREFIX "trusted.afr"
-
-/* Index xlator related */
-#define GF_XATTROP_INDEX_GFID "glusterfs.xattrop_index_gfid"
-#define GF_XATTROP_ENTRY_CHANGES_GFID "glusterfs.xattrop_entry_changes_gfid"
-#define GF_XATTROP_INDEX_COUNT "glusterfs.xattrop_index_count"
-#define GF_XATTROP_DIRTY_GFID "glusterfs.xattrop_dirty_gfid"
-#define GF_XATTROP_DIRTY_COUNT "glusterfs.xattrop_dirty_count"
-#define GF_XATTROP_ENTRY_IN_KEY "glusterfs.xattrop-entry-create"
-#define GF_XATTROP_ENTRY_OUT_KEY "glusterfs.xattrop-entry-delete"
-#define GF_INDEX_IA_TYPE_GET_REQ "glusterfs.index-ia-type-get-req"
-#define GF_INDEX_IA_TYPE_GET_RSP "glusterfs.index-ia-type-get-rsp"
-
-#define GF_HEAL_INFO "glusterfs.heal-info"
-#define GF_AFR_HEAL_SBRAIN "glusterfs.heal-sbrain"
-#define GF_AFR_SBRAIN_STATUS "replica.split-brain-status"
-#define GF_AFR_SBRAIN_CHOICE "replica.split-brain-choice"
-#define GF_AFR_SPB_CHOICE_TIMEOUT "replica.split-brain-choice-timeout"
-#define GF_AFR_SBRAIN_RESOLVE "replica.split-brain-heal-finalize"
-#define GF_AFR_ADD_BRICK "trusted.add-brick"
-#define GF_AFR_REPLACE_BRICK "trusted.replace-brick"
-#define GF_AFR_DIRTY "trusted.afr.dirty"
-#define GF_XATTROP_ENTRY_OUT "glusterfs.xattrop-entry-delete"
-#define GF_XATTROP_PURGE_INDEX "glusterfs.xattrop-purge-index"
-
-#define GF_GFIDLESS_LOOKUP "gfidless-lookup"
-/* replace-brick and pump related internal xattrs */
-#define RB_PUMP_CMD_START       "glusterfs.pump.start"
-#define RB_PUMP_CMD_PAUSE       "glusterfs.pump.pause"
-#define RB_PUMP_CMD_COMMIT      "glusterfs.pump.commit"
-#define RB_PUMP_CMD_ABORT       "glusterfs.pump.abort"
-#define RB_PUMP_CMD_STATUS      "glusterfs.pump.status"
-
-#define GLUSTERFS_MARKER_DONT_ACCOUNT_KEY "glusters.marker.dont-account"
-#define GLUSTERFS_RDMA_INLINE_THRESHOLD       (2048)
-#define GLUSTERFS_RDMA_MAX_HEADER_SIZE        (228) /* (sizeof (rdma_header_t)                 \
-                                                       + RDMA_MAX_SEGMENTS \
-                                                       * sizeof (rdma_read_chunk_t))
-                                                       */
-
-#define GLUSTERFS_RPC_REPLY_SIZE               24
-
-#define STARTING_EVENT_THREADS                 1
-
-#define ZR_FILE_CONTENT_REQUEST(key) (!strncmp(key, ZR_FILE_CONTENT_STR, \
-                                               ZR_FILE_CONTENT_STRLEN))
-
-#define DEFAULT_VAR_RUN_DIRECTORY        DATADIR "/run/gluster"
-#define DEFAULT_GLUSTERFSD_MISC_DIRETORY DATADIR "/lib/misc/glusterfsd"
-#ifdef GF_LINUX_HOST_OS
-#define GLUSTERD_DEFAULT_WORKDIR DATADIR "/lib/glusterd"
-#else
-#define GLUSTERD_DEFAULT_WORKDIR DATADIR "/db/glusterd"
-#endif
-#define GF_REPLICATE_TRASH_DIR           ".landfill"
-
-/* GlusterFS's maximum supported Auxiliary GIDs */
-#define GF_MAX_AUX_GROUPS   65535
-
-#define GF_UUID_BUF_SIZE 50
-#define GF_UUID_BNAME_BUF_SIZE (320) /* (64 + 256) */
-
-#define GF_REBALANCE_TID_KEY     "rebalance-id"
-#define GF_REMOVE_BRICK_TID_KEY  "remove-brick-id"
-#define GF_TIER_TID_KEY          "tier-id"
-#define GF_TIER_ENABLED          "tier-enabled"
-
-#define UUID_CANONICAL_FORM_LEN  36
-
-/* Adding this here instead of any glusterd*.h files as it is also required by
- * cli
- */
-#define DEFAULT_GLUSTERD_SOCKFILE             DATADIR "/run/glusterd.socket"
-
-/* features/marker-quota also needs to have knowledge of link-files so as to
- * exclude them from accounting.
- */
-#define DHT_LINKFILE_MODE        (S_ISVTX)
-
-#define IS_DHT_LINKFILE_MODE(iabuf) ((st_mode_from_ia ((iabuf)->ia_prot, \
-                                                       (iabuf)->ia_type) & ~S_IFMT)\
-                                     == DHT_LINKFILE_MODE)
-#define DHT_LINKFILE_STR "linkto"
-#define DHT_COMMITHASH_STR "commithash"
-
-#define DHT_SKIP_NON_LINKTO_UNLINK  "unlink-only-if-dht-linkto-file"
-#define TIER_SKIP_NON_LINKTO_UNLINK  "unlink-only-if-tier-linkto-file"
-#define TIER_LINKFILE_GFID           "tier-linkfile-gfid"
-#define DHT_SKIP_OPEN_FD_UNLINK     "dont-unlink-for-open-fd"
-#define DHT_IATT_IN_XDATA_KEY       "dht-get-iatt-in-xattr"
-#define GET_LINK_COUNT              "get-link-count"
-#define GF_GET_SIZE                 "get-size"
-
-/*CTR and Marker requires inode dentry link count from posix*/
-#define GF_RESPONSE_LINK_COUNT_XDATA "gf_response_link_count"
-#define GF_REQUEST_LINK_COUNT_XDATA  "gf_request_link_count"
-
-#define CTR_ATTACH_TIER_LOOKUP    "ctr_attach_tier_lookup"
-
-#define GF_LOG_LRU_BUFSIZE_DEFAULT 5
-#define GF_LOG_LRU_BUFSIZE_MIN 0
-#define GF_LOG_LRU_BUFSIZE_MAX 20
-#define GF_LOG_LRU_BUFSIZE_MIN_STR "0"
-#define GF_LOG_LRU_BUFSIZE_MAX_STR "20"
-
-#define GF_LOG_FLUSH_TIMEOUT_DEFAULT 120
-#define GF_LOG_FLUSH_TIMEOUT_MIN 30
-#define GF_LOG_FLUSH_TIMEOUT_MAX 300
-#define GF_LOG_FLUSH_TIMEOUT_MIN_STR "30"
-#define GF_LOG_FLUSH_TIMEOUT_MAX_STR "300"
-#define GF_LOG_LOCALTIME_DEFAULT 0
-
-#define GF_BACKTRACE_LEN        4096
-#define GF_BACKTRACE_FRAME_COUNT 7
-
-#define GF_LK_ADVISORY 0
-#define GF_LK_MANDATORY 1
-
-const char *fop_enum_to_pri_string (glusterfs_fop_t fop);
-
-#define GF_SET_IF_NOT_PRESENT 0x1 /* default behaviour */
-#define GF_SET_OVERWRITE      0x2 /* Overwrite with the buf given */
-#define GF_SET_DIR_ONLY       0x4
-#define GF_SET_EPOCH_TIME     0x8 /* used by afr dir lookup selfheal */
-
-/* key value which quick read uses to get small files in lookup cbk */
-#define GF_CONTENT_KEY "glusterfs.content"
-
-struct _xlator_cmdline_option {
-        struct list_head   cmd_args;
-        char              *volume;
-        char              *key;
-        char              *value;
-};
-typedef struct _xlator_cmdline_option xlator_cmdline_option_t;
-
-struct _server_cmdline {
-        struct list_head   list;
-        char              *volfile_server;
-        char              *transport;
-        int                port;
-};
-typedef struct _server_cmdline server_cmdline_t;
-
-#define GF_OPTION_ENABLE   _gf_true
-#define GF_OPTION_DISABLE  _gf_false
-#define GF_OPTION_DEFERRED 2
-
-struct _cmd_args {
-        /* basic options */
-        char              *volfile_server;
-        server_cmdline_t  *curr_server;
-        /* List of backup  volfile servers, including original */
-        struct list_head   volfile_servers;
-        char              *volfile;
-        char              *log_server;
-        gf_loglevel_t      log_level;
-        char              *log_file;
-        char              *log_ident;
-        gf_log_logger_t    logger;
-        gf_log_format_t    log_format;
-        uint32_t           log_buf_size;
-        uint32_t           log_flush_timeout;
-        int32_t            max_connect_attempts;
-        char              *print_exports;
-        char              *print_netgroups;
-        /* advanced options */
-        uint32_t           volfile_server_port;
-        char              *volfile_server_transport;
-        uint32_t           log_server_port;
-        char              *pid_file;
-        char              *sock_file;
-        int                no_daemon_mode;
-        char              *run_id;
-        int                debug_mode;
-        int                read_only;
-        int                acl;
-        int                selinux;
-        int                capability;
-        int                enable_ino32;
-        int                worm;
-        int                mac_compat;
-        int                fopen_keep_cache;
-        int                gid_timeout;
-        char               gid_timeout_set;
-        int                aux_gfid_mount;
-
-        /* need a process wide timer-wheel? */
-        int                global_timer_wheel;
-
-        /* list of xlator_option_t */
-        struct list_head   xlator_options;
-
-        /* fuse options */
-        int                fuse_direct_io_mode;
-        char              *use_readdirp;
-        int                no_root_squash;
-        int                volfile_check;
-        double             fuse_entry_timeout;
-        double             fuse_negative_timeout;
-        double             fuse_attribute_timeout;
-        char              *volume_name;
-        int                fuse_nodev;
-        int                fuse_nosuid;
-        char              *dump_fuse;
-        pid_t              client_pid;
-        int                client_pid_set;
-        unsigned           uid_map_root;
-        int                background_qlen;
-        int                congestion_threshold;
-        char              *fuse_mountopts;
-        int                mem_acct;
-        int                resolve_gids;
-
-        /* key args */
-        char              *mount_point;
-        char              *volfile_id;
-
-        /* required for portmap */
-        int                brick_port;
-        char              *brick_name;
-        int                brick_port2;
-
-        /* Should management connections use SSL? */
-        int                secure_mgmt;
-
-        /* Linux-only OOM killer adjustment */
-#ifdef GF_LINUX_HOST_OS
-        char              *oom_score_adj;
-#endif
-
-        /* Run this process with valgrind? Might want to prevent calling
-         * functions that prevent valgrind from working correctly, like
-         * dlclose(). */
-        int                valgrind;
-        int                localtime_logging;
-
-        /* For the subdir mount */
-        char           *subdir_mount;
-
-        char              *event_history;
-};
-typedef struct _cmd_args cmd_args_t;
-
-
-struct _glusterfs_graph {
-        struct list_head   list;
-        char               graph_uuid[128];
-        struct timeval     dob;
-        void              *first;
-        void              *top;   /* selected by -n */
-        uint32_t           leaf_count;
-        int                xl_count;
-        int                id;    /* Used in logging */
-        int                used;  /* Should be set when fuse gets
-                                            first CHILD_UP */
-        uint32_t           volfile_checksum;
-};
-typedef struct _glusterfs_graph glusterfs_graph_t;
-
-
-typedef int32_t (*glusterfsd_mgmt_event_notify_fn_t) (int32_t event, void *data,
-                                                      ...);
-
-typedef enum {
-        MGMT_SSL_NEVER = 0,
-        MGMT_SSL_COPY_IO,
-        MGMT_SSL_ALWAYS
-} mgmt_ssl_t;
-
-struct tvec_base;
-
-/* reference counting for the global (per ctx) timer-wheel */
-struct gf_ctx_tw {
-        GF_REF_DECL;
-        struct tvec_base *timer_wheel; /* global timer-wheel instance */
-};
-
-struct _glusterfs_ctx {
-        cmd_args_t         cmd_args;
-        char              *process_uuid;
-        FILE              *pidfp;
-        char               fin;
-        void              *timer;
-        void              *ib;
-        struct call_pool  *pool;
-        void              *event_pool;
-        void              *iobuf_pool;
-        void              *logbuf_pool;
-        gf_lock_t          lock;
-        size_t             page_size;
-
-        /* one per volfile parse */
-        struct list_head   graphs;
-
-        /* the latest graph in use */
-        glusterfs_graph_t *active;
-
-        /* fuse or nfs (but not protocol/server) */
-        void              *master;
-
-        /* xlator implementing MOPs for centralized logging, volfile server */
-        void              *mgmt;
-
-        /* listener of the commands from glusterd */
-        void              *listener;
-
-        /* toggle switch for latency measurement */
-        unsigned char      measure_latency;
-        pthread_t          sigwaiter;
-        char              *cmdlinestr;
-        struct mem_pool   *stub_mem_pool;
-        unsigned char      cleanup_started;
-        int                graph_id; /* Incremented per graph, value should
-                                        indicate how many times the graph has
-                                        got changed */
-        pid_t              mnt_pid; /* pid of the mount agent */
-        int                process_mode; /*mode in which process is runninng*/
-        struct syncenv    *env;          /* The env pointer to the synctasks */
-
-#if defined(OLD_MEM_POOLS)
-        struct list_head   mempool_list; /* used to keep a global list of
-                                            mempools, used to log details of
-                                            mempool in statedump */
-#endif
-        char              *statedump_path;
-
-        struct mem_pool   *dict_pool;
-        struct mem_pool   *dict_pair_pool;
-        struct mem_pool   *dict_data_pool;
-
-        glusterfsd_mgmt_event_notify_fn_t notify; /* Used for xlators to make
-                                                     call to fsd-mgmt */
-        gf_log_handle_t    log; /* all logging related variables */
-
-        int                mem_acct_enable;
-
-        int                daemon_pipe[2];
-
-        struct clienttable *clienttable;
-
-        /*
-         * Should management connections use SSL?  This is the only place we
-         * can put it where both daemon-startup and socket code will see it.
-         *
-         * Why is it an int?  Because we're included before common-utils.h,
-         * which defines gf_boolean_t (what we really want).  It doesn't make
-         * any sense, but it's not worth turning the codebase upside-down to
-         * fix it.  Thus, an int.
-         */
-        int                secure_mgmt;
-
-        /*
-         * Should *our* server/inbound connections use SSL?  This is only true
-         * if we're glusterd and secure_mgmt is set, or if we're glusterfsd
-         * and SSL is set on the I/O path.  It should never be set e.g. for
-         * NFS.
-         */
-        mgmt_ssl_t         secure_srvr;
-        /* Buffer to 'save' backtrace even under OOM-kill like situations*/
-        char               btbuf[GF_BACKTRACE_LEN];
-
-        pthread_mutex_t    notify_lock;
-        pthread_cond_t     notify_cond;
-        int                notifying;
-
-        struct gf_ctx_tw  *tw; /* refcounted timer_wheel */
-
-        gf_lock_t          volfile_lock;
-
-
-        struct {
-                gf_atomic_t max_dict_pairs;
-                gf_atomic_t total_pairs_used;
-                gf_atomic_t total_dicts_used;
-        } stats;
-
-        struct list_head   volfile_list;
-};
-typedef struct _glusterfs_ctx glusterfs_ctx_t;
-
-typedef struct {
-        char               volfile_checksum[SHA256_DIGEST_LENGTH];
-        char               vol_id[NAME_MAX+1];
-        struct list_head   volfile_list;
-
-} gf_volfile_t;
-
-
-glusterfs_ctx_t *glusterfs_ctx_new (void);
-
-struct gf_flock {
-        short              l_type;
-        short              l_whence;
-        off_t              l_start;
-        off_t              l_len;
-        pid_t              l_pid;
-        gf_lkowner_t       l_owner;
-};
-
-typedef struct lock_migration_info {
-        struct list_head   list;
-        struct gf_flock    flock;
-        char              *client_uid;
-        uint32_t           lk_flags;
-} lock_migration_info_t;
-
-#define GF_MUST_CHECK __attribute__((warn_unused_result))
-/*
- * Some macros (e.g. ALLOC_OR_GOTO) set variables in function scope, but the
- * calling function might not only declare the variable to keep the macro happy
- * and not use it otherwise.  In such cases, the following can be used to
- * suppress the "set but not used" warning that would otherwise occur.
- */
-#define GF_UNUSED __attribute__((unused))
-
-/*
- * If present, this has the following effects:
- *
- *      glusterd enables privileged commands over TCP
- *
- *      all code enables SSL for outbound connections to management port
- *
- *      glusterd enables SSL for inbound connections
- *
- * Servers and clients enable/disable SSL among themselves by other means.
- * Making secure management connections conditional on a file is a bit of a
- * hack, but we don't have any other place for such global settings across
- * all of the affected components.  Making it a compile-time option would
- * reduce functionality, both for users and for testing (which can now be
- * done using secure connections for all tests without change elsewhere).
- *
- */
-#define SECURE_ACCESS_FILE     GLUSTERD_DEFAULT_WORKDIR "/secure-access"
-
-int glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
-                             char *volume_name);
-int glusterfs_graph_destroy_residual (glusterfs_graph_t *graph);
-int glusterfs_graph_deactivate (glusterfs_graph_t *graph);
-int glusterfs_graph_destroy (glusterfs_graph_t *graph);
-int glusterfs_get_leaf_count (glusterfs_graph_t *graph);
-int glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx);
-glusterfs_graph_t *glusterfs_graph_construct (FILE *fp);
-int glusterfs_graph_init (glusterfs_graph_t *graph);
-glusterfs_graph_t *glusterfs_graph_new (void);
-int glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph,
-                                  glusterfs_graph_t *newgraph);
-int glusterfs_graph_attach (glusterfs_graph_t *orig_graph, char *path,
-                            glusterfs_graph_t **newgraph);
-int glusterfs_graph_parent_up (glusterfs_graph_t *graph);
-
-void
-gf_free_mig_locks (lock_migration_info_t *locks);
-
-#endif /* _GLUSTERFS_H */
diff --git a/libglusterfs/src/glusterfs/async.h b/libglusterfs/src/glusterfs/async.h
new file mode 100644
index 00000000000..d1d70ae0bc7
--- /dev/null
+++ b/libglusterfs/src/glusterfs/async.h
@@ -0,0 +1,209 @@
+/*
+  Copyright (c) 2019 Red Hat, Inc <https://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __GLUSTERFS_ASYNC_H__
+#define __GLUSTERFS_ASYNC_H__
+
+#define _LGPL_SOURCE
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#ifdef URCU_OLD
+
+/* TODO: Fix the include paths. Since this is a .h included from many places
+ *       it makes no sense to append a '-I$(CONTRIBDIR)/userspace-rcu/' to each
+ *       Makefile.am. I've also seen some problems with CI builders (they
+ *       failed to find the include files, but the same source on another setup
+ *       is working fine). */
+#include "wfcqueue.h"
+#include "wfstack.h"
+
+#else /* !URCU_OLD */
+
+#include <urcu/wfcqueue.h>
+#include <urcu/wfstack.h>
+
+#endif /* URCU_OLD */
+
+#include "glusterfs/xlator.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/list.h"
+#include "glusterfs/libglusterfs-messages.h"
+
+/* This is the name prefix that all worker threads will have. A number will
+ * be added to differentiate them. */
+#define GF_ASYNC_THREAD_NAME "tpw"
+
+/* This value determines the maximum number of threads that are allowed. */
+#define GF_ASYNC_MAX_THREADS 128
+
+/* This value determines how many additional threads will be started but will
+ * remain inactive until they are explicitly activated by the leader. This is
+ * useful to react faster to bursts of load, but at the same time we minimize
+ * contention if they are not really needed to handle current load.
+ *
+ * TODO: Instead of a fixed number, it would probably be better to use a
+ *       prcentage of the available cores. */
+#define GF_ASYNC_SPARE_THREADS 2
+
+/* This value determines the signal used to wake the leader when new work has
+ * been added to the queue. To do so we reuse SIGALRM, since the most logical
+ * candidates (SIGUSR1/SIGUSR2) are already used. This signal must not be used
+ * by anything else in the process. */
+#define GF_ASYNC_SIGQUEUE SIGALRM
+
+/* This value determines the signal that will be used to transfer leader role
+ * to other workers. */
+#define GF_ASYNC_SIGCTRL SIGVTALRM
+
+#define gf_async_warning(_err, _msg, _args...)                                 \
+    gf_msg("async", GF_LOG_WARNING, -(_err), LG_MSG_ASYNC_WARNING, _msg,       \
+           ##_args)
+
+#define gf_async_error(_err, _msg, _args...)                                   \
+    gf_msg("async", GF_LOG_ERROR, -(_err), LG_MSG_ASYNC_FAILURE, _msg, ##_args)
+
+#define gf_async_fatal(_err, _msg, _args...)                                   \
+    do {                                                                       \
+        GF_ABORT("Critical error in async module. Unable to continue. (" _msg  \
+                 "). Error %d.",                                               \
+                 ##_args, -(_err));                                            \
+    } while (0)
+
+struct _gf_async;
+typedef struct _gf_async gf_async_t;
+
+struct _gf_async_worker;
+typedef struct _gf_async_worker gf_async_worker_t;
+
+struct _gf_async_queue;
+typedef struct _gf_async_queue gf_async_queue_t;
+
+struct _gf_async_control;
+typedef struct _gf_async_control gf_async_control_t;
+
+typedef void (*gf_async_callback_f)(xlator_t *xl, gf_async_t *async);
+
+struct _gf_async {
+    /* TODO: remove dependency on xl/THIS. */
+    xlator_t *xl;
+    gf_async_callback_f cbk;
+    struct cds_wfcq_node queue;
+};
+
+struct _gf_async_worker {
+    /* Used to send asynchronous jobs related to the worker. */
+    gf_async_t async;
+
+    /* Member of the available workers stack. */
+    struct cds_wfs_node stack;
+
+    /* Thread object of the current worker. */
+    pthread_t thread;
+
+    /* Unique identifier of this worker. */
+    int32_t id;
+
+    /* Indicates if this worker is enabled. */
+    bool running;
+};
+
+struct _gf_async_queue {
+    /* Structures needed to manage a wait-free queue. For better performance
+     * they are placed in two different cache lines, as recommended by URCU
+     * documentation, even though in our case some threads will be producers
+     * and consumers at the same time. */
+    struct cds_wfcq_head head __attribute__((aligned(64)));
+    struct cds_wfcq_tail tail __attribute__((aligned(64)));
+};
+
+#define GF_ASYNC_COUNTS(_run, _stop) (((uint32_t)(_run) << 16) + (_stop))
+#define GF_ASYNC_COUNT_RUNNING(_count) ((_count) >> 16)
+#define GF_ASYNC_COUNT_STOPPING(_count) ((_count)&65535)
+
+struct _gf_async_control {
+    gf_async_queue_t queue;
+
+    /* Stack of unused workers. */
+    struct __cds_wfs_stack available;
+
+    /* Array of preallocated worker structures. */
+    gf_async_worker_t *table;
+
+    /* Used to synchronize main thread with workers on termination. */
+    pthread_barrier_t sync;
+
+    /* The id of the last thread that will be used for synchronization. */
+    pthread_t sync_thread;
+
+    /* Signal mask to wait for control signals from leader. */
+    sigset_t sigmask_ctrl;
+
+    /* Signal mask to wait for queued items. */
+    sigset_t sigmask_queue;
+
+    /* Saved signal handlers. */
+    struct sigaction handler_ctrl;
+    struct sigaction handler_queue;
+
+    /* PID of the current process. */
+    pid_t pid;
+
+    /* Maximum number of allowed threads. */
+    uint32_t max_threads;
+
+    /* Current number of running and stopping workers. This value is split
+     * into 2 16-bits fields to track both counters atomically at the same
+     * time. */
+    uint32_t counts;
+
+    /* It's used to control whether the asynchronous infrastructure is used
+     * or not. */
+    bool enabled;
+};
+
+extern gf_async_control_t gf_async_ctrl;
+
+int32_t
+gf_async_init(glusterfs_ctx_t *ctx);
+
+void
+gf_async_fini(void);
+
+void
+gf_async_adjust_threads(int32_t threads);
+
+static inline void
+gf_async(gf_async_t *async, xlator_t *xl, gf_async_callback_f cbk)
+{
+    if (!gf_async_ctrl.enabled) {
+        cbk(xl, async);
+        return;
+    }
+
+    async->xl = xl;
+    async->cbk = cbk;
+    cds_wfcq_node_init(&async->queue);
+    if (caa_unlikely(!cds_wfcq_enqueue(&gf_async_ctrl.queue.head,
+                                       &gf_async_ctrl.queue.tail,
+                                       &async->queue))) {
+        /* The queue was empty, so the leader could be sleeping. We need to
+         * wake it so that the new item can be processed. If the queue was not
+         * empty, we don't need to do anything special since the leader will
+         * take care of it. */
+        if (caa_unlikely(kill(gf_async_ctrl.pid, GF_ASYNC_SIGQUEUE) < 0)) {
+            gf_async_fatal(errno, "Unable to wake leader worker.");
+        };
+    }
+}
+
+#endif /* !__GLUSTERFS_ASYNC_H__ */
diff --git a/libglusterfs/src/glusterfs/atomic.h b/libglusterfs/src/glusterfs/atomic.h
new file mode 100644
index 00000000000..ced81748218
--- /dev/null
+++ b/libglusterfs/src/glusterfs/atomic.h
@@ -0,0 +1,459 @@
+/*
+  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _ATOMIC_H
+#define _ATOMIC_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+#include "glusterfs/locking.h"
+
+/* Macros used to join two arguments and generate a new macro name. */
+#define GF_ATOMIC_MACRO_1(_macro) _macro
+#define GF_ATOMIC_MACRO(_base, _name) GF_ATOMIC_MACRO_1(_base##_name)
+
+/* There's a problem on 32-bit architectures when we try to use atomic
+ * builtins with 64-bit types. Only way to solve the problem is to use
+ * a mutex to protect the access to the atomic, but we don't want to
+ * use mutexes for other smaller types that could work with the atomic
+ * builtins.
+ *
+ * So on each atomic type we add a field for the mutex if atomic operation
+ * is not supported and a dummy zero size field if it's supported. This way
+ * we can have different atomic types, some with a mutex and some without.
+ *
+ * To define these types, we use two macros:
+ *
+ *     GF_ATOMIC_MUTEX_FIELD_0 = char lk[0]
+ *     GF_ATOMIC_MUTEX_FILED_1 = gf_lock_t lk
+ *
+ * Both macros define the 'lk' field that will be used in the atomic
+ * structure. One when the atomic is supported by the architecture and
+ * another when not. We need to define the field even if it won't be
+ * used. Otherwise the compiler will return an error.
+ *
+ * Now we need to take the mutex or not depending on the existence of
+ * the mutex field in the structure. To do so we check the size of the
+ * structure, and if it's bigger than uint64_t (all structures with a
+ * mutex will be bigger), we use the mutex-based version. Otherwise we
+ * use the atomic builtin. This check is easily optimized out by the
+ * compiler, leaving a clean and efficient compiled code. */
+
+#define GF_ATOMIC_MUTEX_FIELD_0 char lk[0]
+#define GF_ATOMIC_MUTEX_FIELD_1 gf_lock_t lk
+
+/* We'll use SIZEOF_LONG to determine the architecture. 32-bit machines
+ * will have 4 here, while 64-bit machines will have 8. If additional
+ * needs or restrictions appear on other platforms, these tests can be
+ * extended to handle them. */
+
+/* GF_ATOMIC_SIZE_X macros map each type size to one of the
+ * GF_ATOMIC_MUTEX_FIELD_X macros, depending on detected conditions. */
+
+#if defined(HAVE_ATOMIC_BUILTINS) || defined(HAVE_SYNC_BUILTINS)
+
+#define GF_ATOMIC_SIZE_1 GF_ATOMIC_MUTEX_FIELD_0
+#define GF_ATOMIC_SIZE_2 GF_ATOMIC_MUTEX_FIELD_0
+#define GF_ATOMIC_SIZE_4 GF_ATOMIC_MUTEX_FIELD_0
+
+#if SIZEOF_LONG >= 8
+#define GF_ATOMIC_SIZE_8 GF_ATOMIC_MUTEX_FIELD_0
+#endif
+
+#endif /* HAVE_(ATOMIC|SYNC)_BUILTINS */
+
+/* Any GF_ATOMIC_SIZE_X macro not yet defined will use the mutex version */
+#ifndef GF_ATOMIC_SIZE_1
+#define GF_ATOMIC_SIZE_1 GF_ATOMIC_MUTEX_FIELD_1
+#endif
+
+#ifndef GF_ATOMIC_SIZE_2
+#define GF_ATOMIC_SIZE_2 GF_ATOMIC_MUTEX_FIELD_1
+#endif
+
+#ifndef GF_ATOMIC_SIZE_4
+#define GF_ATOMIC_SIZE_4 GF_ATOMIC_MUTEX_FIELD_1
+#endif
+
+#ifndef GF_ATOMIC_SIZE_8
+#define GF_ATOMIC_SIZE_8 GF_ATOMIC_MUTEX_FIELD_1
+#endif
+
+/* This macro is used to define all atomic types supported. First field
+ * represents the size of the type in bytes, and the second one the name. */
+#define GF_ATOMIC_TYPE(_size, _name)                                           \
+    typedef struct _gf_atomic_##_name##_t {                                    \
+        GF_ATOMIC_MACRO(GF_ATOMIC_SIZE_, _size);                               \
+        _name##_t value;                                                       \
+    } gf_atomic_##_name##_t
+
+/* The atomic types we support */
+GF_ATOMIC_TYPE(1, int8);              /* gf_atomic_int8_t */
+GF_ATOMIC_TYPE(2, int16);             /* gf_atomic_int16_t */
+GF_ATOMIC_TYPE(4, int32);             /* gf_atomic_int32_t */
+GF_ATOMIC_TYPE(8, int64);             /* gf_atomic_int64_t */
+GF_ATOMIC_TYPE(SIZEOF_LONG, intptr);  /* gf_atomic_intptr_t */
+GF_ATOMIC_TYPE(1, uint8);             /* gf_atomic_uint8_t */
+GF_ATOMIC_TYPE(2, uint16);            /* gf_atomic_uint16_t */
+GF_ATOMIC_TYPE(4, uint32);            /* gf_atomic_uint32_t */
+GF_ATOMIC_TYPE(8, uint64);            /* gf_atomic_uint64_t */
+GF_ATOMIC_TYPE(SIZEOF_LONG, uintptr); /* gf_atomic_uintptr_t */
+
+/* Define the default atomic type as int64_t */
+#define gf_atomic_t gf_atomic_int64_t
+
+/* This macro will choose between the mutex based version and the atomic
+ * builtin version depending on the size of the atomic structure. */
+#define GF_ATOMIC_CHOOSE(_atomic, _op, _args...)                               \
+    ((sizeof(_atomic) > sizeof(uint64_t))                                      \
+         ? ({                                                                  \
+               GF_ATOMIC_MACRO(GF_ATOMIC_LOCK_, _op)                           \
+               (_atomic, ##_args);                                             \
+           })                                                                  \
+         : ({                                                                  \
+               GF_ATOMIC_MACRO(GF_ATOMIC_BASE_, _op)                           \
+               (_atomic, ##_args);                                             \
+           }))
+
+/* Macros to implement the mutex-based atomics. */
+#define GF_ATOMIC_OP_PREPARE(_atomic, _name)                                   \
+    typeof(_atomic) *__atomic = &(_atomic);                                    \
+    gf_lock_t *__lock = (gf_lock_t *)&__atomic->lk;                            \
+    LOCK(__lock);                                                              \
+    typeof(__atomic->value) _name = __atomic->value
+
+#define GF_ATOMIC_OP_STORE(_value) (__atomic->value = (_value))
+
+#define GF_ATOMIC_OP_RETURN(_value)                                            \
+    ({                                                                         \
+        UNLOCK(__lock);                                                        \
+        _value;                                                                \
+    })
+
+#define GF_ATOMIC_LOCK_INIT(_atomic, _value)                                   \
+    do {                                                                       \
+        typeof(_atomic) *__atomic = &(_atomic);                                \
+        LOCK_INIT((gf_lock_t *)&__atomic->lk);                                 \
+        __atomic->value = (_value);                                            \
+    } while (0)
+
+#define GF_ATOMIC_LOCK_GET(_atomic)                                            \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_ADD(_atomic, _value)                                    \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value += (_value));                               \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_SUB(_atomic, _value)                                    \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value -= (_value));                               \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_AND(_atomic, _value)                                    \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value &= (_value));                               \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_OR(_atomic, _value)                                     \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value |= (_value));                               \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_XOR(_atomic, _value)                                    \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value ^= (_value));                               \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_NAND(_atomic, _value)                                   \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value = ~(__value & (_value)));                   \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_ADD(_atomic, _value)                              \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value + (_value));                                \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_SUB(_atomic, _value)                              \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value - (_value));                                \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_AND(_atomic, _value)                              \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value &(_value));                                 \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_OR(_atomic, _value)                               \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value | (_value));                                \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_XOR(_atomic, _value)                              \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(__value ^ (_value));                                \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_FETCH_NAND(_atomic, _value)                             \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(~(__value & (_value)));                             \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_SWAP(_atomic, _value)                                   \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        GF_ATOMIC_OP_STORE(_value);                                            \
+        GF_ATOMIC_OP_RETURN(__value);                                          \
+    })
+
+#define GF_ATOMIC_LOCK_CMP_SWAP(_atomic, _expected, _value)                    \
+    ({                                                                         \
+        GF_ATOMIC_OP_PREPARE(_atomic, __value);                                \
+        bool __ret = (__value == (_expected));                                 \
+        if (__ret) {                                                           \
+            GF_ATOMIC_OP_STORE(_value);                                        \
+        }                                                                      \
+        GF_ATOMIC_OP_RETURN(__ret);                                            \
+    })
+
+#if defined(HAVE_ATOMIC_BUILTINS)
+
+/* If compiler supports __atomic builtins, we use them. */
+
+#define GF_ATOMIC_BASE_INIT(_atomic, _value)                                   \
+    __atomic_store_n(&(_atomic).value, (_value), __ATOMIC_RELEASE)
+
+#define GF_ATOMIC_BASE_GET(_atomic)                                            \
+    __atomic_load_n(&(_atomic).value, __ATOMIC_ACQUIRE)
+
+#define GF_ATOMIC_BASE_ADD(_atomic, _value)                                    \
+    __atomic_add_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_SUB(_atomic, _value)                                    \
+    __atomic_sub_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_AND(_atomic, _value)                                    \
+    __atomic_and_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_OR(_atomic, _value)                                     \
+    __atomic_or_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_XOR(_atomic, _value)                                    \
+    __atomic_xor_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_NAND(_atomic, _value)                                   \
+    __atomic_nand_fetch(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_ADD(_atomic, _value)                              \
+    __atomic_fetch_add(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_SUB(_atomic, _value)                              \
+    __atomic_fetch_sub(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_AND(_atomic, _value)                              \
+    __atomic_fetch_and(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_OR(_atomic, _value)                               \
+    __atomic_fetch_or(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_XOR(_atomic, _value)                              \
+    __atomic_fetch_xor(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_FETCH_NAND(_atomic, _value)                             \
+    __atomic_fetch_nand(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_SWAP(_atomic, _value)                                   \
+    __atomic_exchange_n(&(_atomic).value, (_value), __ATOMIC_ACQ_REL)
+
+#define GF_ATOMIC_BASE_CMP_SWAP(_atomic, _expected, _value)                    \
+    ({                                                                         \
+        typeof((_atomic).value) __expected = (_expected);                      \
+        __atomic_compare_exchange_n(&(_atomic).value, &__expected, (_value),   \
+                                    0, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE);    \
+    })
+
+#elif defined(HAVE_SYNC_BUILTINS)
+
+/* If compiler doesn't support __atomic builtins but supports __sync builtins,
+ * we use them. */
+
+#define GF_ATOMIC_BASE_INIT(_atomic, _value)                                   \
+    do {                                                                       \
+        (_atomic).value = (_value);                                            \
+        __sync_synchronize();                                                  \
+    } while (0)
+
+#define GF_ATOMIC_BASE_ADD(_atomic, _value)                                    \
+    __sync_add_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_SUB(_atomic, _value)                                    \
+    __sync_sub_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_AND(_atomic, _value)                                    \
+    __sync_and_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_OR(_atomic, _value)                                     \
+    __sync_or_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_XOR(_atomic, _value)                                    \
+    __sync_xor_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_NAND(_atomic, _value)                                   \
+    __sync_nand_and_fetch(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_ADD(_atomic, _value)                              \
+    __sync_fetch_and_add(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_SUB(_atomic, _value)                              \
+    __sync_fetch_and_sub(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_AND(_atomic, _value)                              \
+    __sync_fetch_and_and(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_OR(_atomic, _value)                               \
+    __sync_fetch_and_or(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_XOR(_atomic, _value)                              \
+    __sync_fetch_and_xor(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_FETCH_NAND(_atomic, _value)                             \
+    __sync_fetch_and_nand(&(_atomic).value, (_value))
+
+#define GF_ATOMIC_BASE_SWAP(_atomic, _value)                                   \
+    ({                                                                         \
+        __sync_synchronize();                                                  \
+        __sync_lock_test_and_set(&(_atomic).value, (_value));                  \
+    })
+
+#define GF_ATOMIC_BASE_CMP_SWAP(_atomic, _expected, _value)                    \
+    __sync_bool_compare_and_swap(&(_atomic).value, (_expected), (_value))
+
+#define GF_ATOMIC_BASE_GET(_atomic) GF_ATOMIC_BASE_ADD(_atomic, 0)
+
+#else /* !HAVE_ATOMIC_BUILTINS && !HAVE_SYNC_BUILTINS */
+
+/* The compiler doesn't support any atomic builtin. We fallback to the
+ * mutex-based implementation. */
+
+#define GF_ATOMIC_BASE_INIT(_atomic, _value)                                   \
+    GF_ATOMIC_LOCK_INIT(_atomic, _value)
+
+#define GF_ATOMIC_BASE_GET(_atomic) GF_ATOMIC_LOCK_GET(_atomic)
+
+#define GF_ATOMIC_BASE_ADD(_atomic, _value) GF_ATOMIC_LOCK_ADD(_atomic, _value)
+
+#define GF_ATOMIC_BASE_SUB(_atomic, _value) GF_ATOMIC_LOCK_SUB(_atomic, _value)
+
+#define GF_ATOMIC_BASE_AND(_atomic, _value) GF_ATOMIC_LOCK_AND(_atomic, _value)
+
+#define GF_ATOMIC_BASE_OR(_atomic, _value) GF_ATOMIC_LOCK_OR(_atomic, _value)
+
+#define GF_ATOMIC_BASE_XOR(_atomic, _value) GF_ATOMIC_LOCK_XOR(_atomic, _value)
+
+#define GF_ATOMIC_BASE_NAND(_atomic, _value)                                   \
+    GF_ATOMIC_LOCK_NAND(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_ADD(_atomic, _value)                              \
+    GF_ATOMIC_LOCK_FETCH_ADD(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_SUB(_atomic, _value)                              \
+    GF_ATOMIC_LOCK_FETCH_SUB(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_AND(_atomic, _value)                              \
+    GF_ATOMIC_LOCK_FETCH_AND(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_OR(_atomic, _value)                               \
+    GF_ATOMIC_LOCK_FETCH_OR(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_XOR(_atomic, _value)                              \
+    GF_ATOMIC_LOCK_FETCH_XOR(_atomic, _value)
+
+#define GF_ATOMIC_BASE_FETCH_NAND(_atomic, _value)                             \
+    GF_ATOMIC_LOCK_FETCH_NAND(_atomic, _value)
+
+#define GF_ATOMIC_BASE_SWAP(_atomic, _value)                                   \
+    GF_ATOMIC_LOCK_SWAP(_atomic, _value)
+
+#define GF_ATOMIC_BASE_CMP_SWAP(_atomic, _expected, _value)                    \
+    GF_ATOMIC_LOCK_CMP_SWAP(_atomic, _expected, _value)
+
+#endif /* HAVE_(ATOMIC|SYNC)_BUILTINS */
+
+/* Here we declare the real atomic macros available to the user. */
+
+/* All macros have a 'gf_atomic_xxx' as 1st argument */
+
+#define GF_ATOMIC_INIT(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, INIT, _value)
+#define GF_ATOMIC_GET(_atomic) GF_ATOMIC_CHOOSE(_atomic, GET)
+#define GF_ATOMIC_ADD(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, ADD, _value)
+#define GF_ATOMIC_SUB(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, SUB, _value)
+#define GF_ATOMIC_AND(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, AND, _value)
+#define GF_ATOMIC_OR(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, OR, _value)
+#define GF_ATOMIC_XOR(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, XOR, _value)
+#define GF_ATOMIC_NAND(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, NAND, _value)
+
+#define GF_ATOMIC_FETCH_ADD(_atomic, _value)                                   \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_ADD, _value)
+
+#define GF_ATOMIC_FETCH_SUB(_atomic, _value)                                   \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_SUB, _value)
+
+#define GF_ATOMIC_FETCH_AND(_atomic, _value)                                   \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_AND, _value)
+
+#define GF_ATOMIC_FETCH_OR(_atomic, _value)                                    \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_OR, _value)
+
+#define GF_ATOMIC_FETCH_XOR(_atomic, _value)                                   \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_XOR, _value)
+
+#define GF_ATOMIC_FETCH_NAND(_atomic, _value)                                  \
+    GF_ATOMIC_CHOOSE(_atomic, FETCH_NAND, _value)
+
+#define GF_ATOMIC_SWAP(_atomic, _value) GF_ATOMIC_CHOOSE(_atomic, SWAP, _value)
+
+#define GF_ATOMIC_CMP_SWAP(_atomic, _expected, _value)                         \
+    GF_ATOMIC_CHOOSE(_atomic, CMP_SWAP, _expected, _value)
+
+#define GF_ATOMIC_INC(_atomic) GF_ATOMIC_ADD(_atomic, 1)
+#define GF_ATOMIC_DEC(_atomic) GF_ATOMIC_SUB(_atomic, 1)
+#define GF_ATOMIC_FETCH_INC(_atomic) GF_ATOMIC_FETCH_ADD(_atomic, 1)
+#define GF_ATOMIC_FETCH_DEC(_atomic) GF_ATOMIC_FETCH_SUB(_atomic, 1)
+
+#endif /* _ATOMIC_H */
diff --git a/libglusterfs/src/glusterfs/byte-order.h b/libglusterfs/src/glusterfs/byte-order.h
new file mode 100644
index 00000000000..fd8cef9e58d
--- /dev/null
+++ b/libglusterfs/src/glusterfs/byte-order.h
@@ -0,0 +1,279 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _BYTE_ORDER_H
+#define _BYTE_ORDER_H
+
+#include <inttypes.h>
+
+#define LS1 0x00ffU
+#define MS1 0xff00U
+#define LS2 0x0000ffffU
+#define MS2 0xffff0000U
+#define LS4 0x00000000ffffffffULL
+#define MS4 0xffffffff00000000ULL
+
+static uint16_t (*hton16)(uint16_t);
+static uint32_t (*hton32)(uint32_t);
+static uint64_t (*hton64)(uint64_t);
+
+#define ntoh16 hton16
+#define ntoh32 hton32
+#define ntoh64 hton64
+
+static uint16_t (*htole16)(uint16_t);
+static uint32_t (*htole32)(uint32_t);
+static uint64_t (*htole64)(uint64_t);
+
+#define letoh16 htole16
+#define letoh32 htole32
+#define letoh64 htole64
+
+static uint16_t (*htobe16)(uint16_t);
+static uint32_t (*htobe32)(uint32_t);
+static uint64_t (*htobe64)(uint64_t);
+
+#define betoh16 htobe16
+#define betoh32 htobe32
+#define betoh64 htobe64
+
+#define do_swap2(x) (((x & LS1) << 8) | (((x & MS1) >> 8)))
+#define do_swap4(x) ((do_swap2(x & LS2) << 16) | (do_swap2((x & MS2) >> 16)))
+#define do_swap8(x) ((do_swap4(x & LS4) << 32) | (do_swap4((x & MS4) >> 32)))
+
+static inline uint16_t
+__swap16(uint16_t x)
+{
+    return do_swap2(x);
+}
+
+static inline uint32_t
+__swap32(uint32_t x)
+{
+    return do_swap4(x);
+}
+
+static inline uint64_t
+__swap64(uint64_t x)
+{
+    return do_swap8(x);
+}
+
+static inline uint16_t
+__noswap16(uint16_t x)
+{
+    return x;
+}
+
+static inline uint32_t
+__noswap32(uint32_t x)
+{
+    return x;
+}
+
+static inline uint64_t
+__noswap64(uint64_t x)
+{
+    return x;
+}
+
+static inline uint16_t
+__byte_order_n16(uint16_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        hton16 = __swap16;
+        hton32 = __swap32;
+        hton64 = __swap64;
+    } else {
+        /* cpu is be */
+        hton16 = __noswap16;
+        hton32 = __noswap32;
+        hton64 = __noswap64;
+    }
+
+    return hton16(i);
+}
+
+static inline uint32_t
+__byte_order_n32(uint32_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        hton16 = __swap16;
+        hton32 = __swap32;
+        hton64 = __swap64;
+    } else {
+        /* cpu is be */
+        hton16 = __noswap16;
+        hton32 = __noswap32;
+        hton64 = __noswap64;
+    }
+
+    return hton32(i);
+}
+
+static inline uint64_t
+__byte_order_n64(uint64_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        hton16 = __swap16;
+        hton32 = __swap32;
+        hton64 = __swap64;
+    } else {
+        /* cpu is be */
+        hton16 = __noswap16;
+        hton32 = __noswap32;
+        hton64 = __noswap64;
+    }
+
+    return hton64(i);
+}
+
+static uint16_t (*hton16)(uint16_t) = __byte_order_n16;
+static uint32_t (*hton32)(uint32_t) = __byte_order_n32;
+static uint64_t (*hton64)(uint64_t) = __byte_order_n64;
+
+static inline uint16_t
+__byte_order_le16(uint16_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htole16 = __noswap16;
+        htole32 = __noswap32;
+        htole64 = __noswap64;
+    } else {
+        /* cpu is be */
+        htole16 = __swap16;
+        htole32 = __swap32;
+        htole64 = __swap64;
+    }
+
+    return htole16(i);
+}
+
+static inline uint32_t
+__byte_order_le32(uint32_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htole16 = __noswap16;
+        htole32 = __noswap32;
+        htole64 = __noswap64;
+    } else {
+        /* cpu is be */
+        htole16 = __swap16;
+        htole32 = __swap32;
+        htole64 = __swap64;
+    }
+
+    return htole32(i);
+}
+
+static inline uint64_t
+__byte_order_le64(uint64_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htole16 = __noswap16;
+        htole32 = __noswap32;
+        htole64 = __noswap64;
+    } else {
+        /* cpu is be */
+        htole16 = __swap16;
+        htole32 = __swap32;
+        htole64 = __swap64;
+    }
+
+    return htole64(i);
+}
+
+static uint16_t (*htole16)(uint16_t) = __byte_order_le16;
+static uint32_t (*htole32)(uint32_t) = __byte_order_le32;
+static uint64_t (*htole64)(uint64_t) = __byte_order_le64;
+
+static inline uint16_t
+__byte_order_be16(uint16_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htobe16 = __swap16;
+        htobe32 = __swap32;
+        htobe64 = __swap64;
+    } else {
+        /* cpu is be */
+        htobe16 = __noswap16;
+        htobe32 = __noswap32;
+        htobe64 = __noswap64;
+    }
+
+    return htobe16(i);
+}
+
+static inline uint32_t
+__byte_order_be32(uint32_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htobe16 = __swap16;
+        htobe32 = __swap32;
+        htobe64 = __swap64;
+    } else {
+        /* cpu is be */
+        htobe16 = __noswap16;
+        htobe32 = __noswap32;
+        htobe64 = __noswap64;
+    }
+
+    return htobe32(i);
+}
+
+static inline uint64_t
+__byte_order_be64(uint64_t i)
+{
+    uint32_t num = 1;
+
+    if (((char *)(&num))[0] == 1) {
+        /* cpu is le */
+        htobe16 = __swap16;
+        htobe32 = __swap32;
+        htobe64 = __swap64;
+    } else {
+        /* cpu is be */
+        htobe16 = __noswap16;
+        htobe32 = __noswap32;
+        htobe64 = __noswap64;
+    }
+
+    return htobe64(i);
+}
+
+static uint16_t (*htobe16)(uint16_t) = __byte_order_be16;
+static uint32_t (*htobe32)(uint32_t) = __byte_order_be32;
+static uint64_t (*htobe64)(uint64_t) = __byte_order_be64;
+
+#endif /* _BYTE_ORDER_H */
diff --git a/libglusterfs/src/glusterfs/call-stub.h b/libglusterfs/src/glusterfs/call-stub.h
new file mode 100644
index 00000000000..8237ea459bf
--- /dev/null
+++ b/libglusterfs/src/glusterfs/call-stub.h
@@ -0,0 +1,622 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CALL_STUB_H_
+#define _CALL_STUB_H_
+
+#include "glusterfs/xlator.h"
+#include "glusterfs/defaults.h"
+#include "glusterfs/default-args.h"
+#include "glusterfs/stack.h"
+#include "glusterfs/list.h"
+
+typedef struct _call_stub {
+    struct list_head list;
+    call_frame_t *frame;
+    struct mem_pool *stub_mem_pool; /* pointer to stub mempool in ctx_t */
+    uint32_t jnl_meta_len;
+    uint32_t jnl_data_len;
+    void (*serialize)(struct _call_stub *, char *, char *);
+    union {
+        fop_lookup_t lookup;
+        fop_stat_t stat;
+        fop_fstat_t fstat;
+        fop_truncate_t truncate;
+        fop_ftruncate_t ftruncate;
+        fop_access_t access;
+        fop_readlink_t readlink;
+        fop_mknod_t mknod;
+        fop_mkdir_t mkdir;
+        fop_unlink_t unlink;
+        fop_rmdir_t rmdir;
+        fop_symlink_t symlink;
+        fop_rename_t rename;
+        fop_link_t link;
+        fop_create_t create;
+        fop_open_t open;
+        fop_readv_t readv;
+        fop_writev_t writev;
+        fop_flush_t flush;
+        fop_fsync_t fsync;
+        fop_opendir_t opendir;
+        fop_fsyncdir_t fsyncdir;
+        fop_statfs_t statfs;
+        fop_setxattr_t setxattr;
+        fop_getxattr_t getxattr;
+        fop_fgetxattr_t fgetxattr;
+        fop_fsetxattr_t fsetxattr;
+        fop_removexattr_t removexattr;
+        fop_fremovexattr_t fremovexattr;
+        fop_lk_t lk;
+        fop_inodelk_t inodelk;
+        fop_finodelk_t finodelk;
+        fop_entrylk_t entrylk;
+        fop_fentrylk_t fentrylk;
+        fop_readdir_t readdir;
+        fop_readdirp_t readdirp;
+        fop_rchecksum_t rchecksum;
+        fop_xattrop_t xattrop;
+        fop_fxattrop_t fxattrop;
+        fop_setattr_t setattr;
+        fop_fsetattr_t fsetattr;
+        fop_fallocate_t fallocate;
+        fop_discard_t discard;
+        fop_zerofill_t zerofill;
+        fop_ipc_t ipc;
+        fop_seek_t seek;
+        fop_lease_t lease;
+        fop_getactivelk_t getactivelk;
+        fop_setactivelk_t setactivelk;
+        fop_put_t put;
+        fop_icreate_t icreate;
+        fop_namelink_t namelink;
+        fop_copy_file_range_t copy_file_range;
+    } fn;
+
+    union {
+        fop_lookup_cbk_t lookup;
+        fop_stat_cbk_t stat;
+        fop_fstat_cbk_t fstat;
+        fop_truncate_cbk_t truncate;
+        fop_ftruncate_cbk_t ftruncate;
+        fop_access_cbk_t access;
+        fop_readlink_cbk_t readlink;
+        fop_mknod_cbk_t mknod;
+        fop_mkdir_cbk_t mkdir;
+        fop_unlink_cbk_t unlink;
+        fop_rmdir_cbk_t rmdir;
+        fop_symlink_cbk_t symlink;
+        fop_rename_cbk_t rename;
+        fop_link_cbk_t link;
+        fop_create_cbk_t create;
+        fop_open_cbk_t open;
+        fop_readv_cbk_t readv;
+        fop_writev_cbk_t writev;
+        fop_flush_cbk_t flush;
+        fop_fsync_cbk_t fsync;
+        fop_opendir_cbk_t opendir;
+        fop_fsyncdir_cbk_t fsyncdir;
+        fop_statfs_cbk_t statfs;
+        fop_setxattr_cbk_t setxattr;
+        fop_getxattr_cbk_t getxattr;
+        fop_fgetxattr_cbk_t fgetxattr;
+        fop_fsetxattr_cbk_t fsetxattr;
+        fop_removexattr_cbk_t removexattr;
+        fop_fremovexattr_cbk_t fremovexattr;
+        fop_lk_cbk_t lk;
+        fop_inodelk_cbk_t inodelk;
+        fop_finodelk_cbk_t finodelk;
+        fop_entrylk_cbk_t entrylk;
+        fop_fentrylk_cbk_t fentrylk;
+        fop_readdir_cbk_t readdir;
+        fop_readdirp_cbk_t readdirp;
+        fop_rchecksum_cbk_t rchecksum;
+        fop_xattrop_cbk_t xattrop;
+        fop_fxattrop_cbk_t fxattrop;
+        fop_setattr_cbk_t setattr;
+        fop_fsetattr_cbk_t fsetattr;
+        fop_fallocate_cbk_t fallocate;
+        fop_discard_cbk_t discard;
+        fop_zerofill_cbk_t zerofill;
+        fop_ipc_cbk_t ipc;
+        fop_seek_cbk_t seek;
+        fop_lease_cbk_t lease;
+        fop_getactivelk_cbk_t getactivelk;
+        fop_setactivelk_cbk_t setactivelk;
+        fop_put_cbk_t put;
+        fop_icreate_cbk_t icreate;
+        fop_namelink_cbk_t namelink;
+        fop_copy_file_range_cbk_t copy_file_range;
+    } fn_cbk;
+    glusterfs_fop_t fop;
+    gf_boolean_t poison;
+    char wind;
+    default_args_t args;
+    default_args_cbk_t args_cbk;
+} call_stub_t;
+
+call_stub_t *
+fop_lookup_stub(call_frame_t *frame, fop_lookup_t fn, loc_t *loc,
+                dict_t *xdata);
+
+call_stub_t *
+fop_lookup_cbk_stub(call_frame_t *frame, fop_lookup_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, inode_t *inode, struct iatt *buf,
+                    dict_t *xdata, struct iatt *postparent);
+call_stub_t *
+fop_stat_stub(call_frame_t *frame, fop_stat_t fn, loc_t *loc, dict_t *xdata);
+call_stub_t *
+fop_stat_cbk_stub(call_frame_t *frame, fop_stat_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, struct iatt *buf, dict_t *xdata);
+call_stub_t *
+fop_fstat_stub(call_frame_t *frame, fop_fstat_t fn, fd_t *fd, dict_t *xdata);
+call_stub_t *
+fop_fstat_cbk_stub(call_frame_t *frame, fop_fstat_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *buf, dict_t *xdata);
+
+call_stub_t *
+fop_truncate_stub(call_frame_t *frame, fop_truncate_t fn, loc_t *loc, off_t off,
+                  dict_t *xdata);
+
+call_stub_t *
+fop_truncate_cbk_stub(call_frame_t *frame, fop_truncate_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata);
+
+call_stub_t *
+fop_ftruncate_stub(call_frame_t *frame, fop_ftruncate_t fn, fd_t *fd, off_t off,
+                   dict_t *xdata);
+
+call_stub_t *
+fop_ftruncate_cbk_stub(call_frame_t *frame, fop_ftruncate_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata);
+
+call_stub_t *
+fop_access_stub(call_frame_t *frame, fop_access_t fn, loc_t *loc, int32_t mask,
+                dict_t *xdata);
+
+call_stub_t *
+fop_access_cbk_stub(call_frame_t *frame, fop_access_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_readlink_stub(call_frame_t *frame, fop_readlink_t fn, loc_t *loc,
+                  size_t size, dict_t *xdata);
+
+call_stub_t *
+fop_readlink_cbk_stub(call_frame_t *frame, fop_readlink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, const char *path,
+                      struct iatt *buf, dict_t *xdata);
+
+call_stub_t *
+fop_mknod_stub(call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
+               dev_t rdev, mode_t umask, dict_t *xdata);
+
+call_stub_t *
+fop_mknod_cbk_stub(call_frame_t *frame, fop_mknod_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata);
+
+call_stub_t *
+fop_mkdir_stub(call_frame_t *frame, fop_mkdir_t fn, loc_t *loc, mode_t mode,
+               mode_t umask, dict_t *xdata);
+
+call_stub_t *
+fop_mkdir_cbk_stub(call_frame_t *frame, fop_mkdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata);
+
+call_stub_t *
+fop_unlink_stub(call_frame_t *frame, fop_unlink_t fn, loc_t *loc, int xflag,
+                dict_t *xdata);
+
+call_stub_t *
+fop_unlink_cbk_stub(call_frame_t *frame, fop_unlink_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata);
+
+call_stub_t *
+fop_rmdir_stub(call_frame_t *frame, fop_rmdir_t fn, loc_t *loc, int flags,
+               dict_t *xdata);
+
+call_stub_t *
+fop_rmdir_cbk_stub(call_frame_t *frame, fop_rmdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata);
+
+call_stub_t *
+fop_symlink_stub(call_frame_t *frame, fop_symlink_t fn, const char *linkname,
+                 loc_t *loc, mode_t umask, dict_t *xdata);
+
+call_stub_t *
+fop_symlink_cbk_stub(call_frame_t *frame, fop_symlink_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata);
+
+call_stub_t *
+fop_rename_stub(call_frame_t *frame, fop_rename_t fn, loc_t *oldloc,
+                loc_t *newloc, dict_t *xdata);
+
+call_stub_t *
+fop_rename_cbk_stub(call_frame_t *frame, fop_rename_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *buf,
+                    struct iatt *preoldparent, struct iatt *postoldparent,
+                    struct iatt *prenewparent, struct iatt *postnewparent,
+                    dict_t *xdata);
+
+call_stub_t *
+fop_link_stub(call_frame_t *frame, fop_link_t fn, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata);
+
+call_stub_t *
+fop_link_cbk_stub(call_frame_t *frame, fop_link_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, inode_t *inode, struct iatt *buf,
+                  struct iatt *preparent, struct iatt *postparent,
+                  dict_t *xdata);
+
+call_stub_t *
+fop_create_stub(call_frame_t *frame, fop_create_t fn, loc_t *loc, int32_t flags,
+                mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata);
+
+call_stub_t *
+fop_create_cbk_stub(call_frame_t *frame, fop_create_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, fd_t *fd, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata);
+
+call_stub_t *
+fop_open_stub(call_frame_t *frame, fop_open_t fn, loc_t *loc, int32_t flags,
+              fd_t *fd, dict_t *xdata);
+
+call_stub_t *
+fop_open_cbk_stub(call_frame_t *frame, fop_open_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+call_stub_t *
+fop_readv_stub(call_frame_t *frame, fop_readv_t fn, fd_t *fd, size_t size,
+               off_t off, uint32_t flags, dict_t *xdata);
+
+call_stub_t *
+fop_readv_cbk_stub(call_frame_t *frame, fop_readv_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iovec *vector, int32_t count,
+                   struct iatt *stbuf, struct iobref *iobref, dict_t *xdata);
+
+call_stub_t *
+fop_writev_stub(call_frame_t *frame, fop_writev_t fn, fd_t *fd,
+                struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+                struct iobref *iobref, dict_t *xdata);
+
+call_stub_t *
+fop_writev_cbk_stub(call_frame_t *frame, fop_writev_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                    dict_t *xdata);
+
+call_stub_t *
+fop_flush_stub(call_frame_t *frame, fop_flush_t fn, fd_t *fd, dict_t *xdata);
+
+call_stub_t *
+fop_flush_cbk_stub(call_frame_t *frame, fop_flush_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_fsync_stub(call_frame_t *frame, fop_fsync_t fn, fd_t *fd, int32_t datasync,
+               dict_t *xdata);
+
+call_stub_t *
+fop_fsync_cbk_stub(call_frame_t *frame, fop_fsync_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                   dict_t *xdata);
+
+call_stub_t *
+fop_opendir_stub(call_frame_t *frame, fop_opendir_t fn, loc_t *loc, fd_t *fd,
+                 dict_t *xdata);
+
+call_stub_t *
+fop_opendir_cbk_stub(call_frame_t *frame, fop_opendir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+call_stub_t *
+fop_fsyncdir_stub(call_frame_t *frame, fop_fsyncdir_t fn, fd_t *fd,
+                  int32_t datasync, dict_t *xdata);
+
+call_stub_t *
+fop_fsyncdir_cbk_stub(call_frame_t *frame, fop_fsyncdir_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_statfs_stub(call_frame_t *frame, fop_statfs_t fn, loc_t *loc,
+                dict_t *xdata);
+
+call_stub_t *
+fop_statfs_cbk_stub(call_frame_t *frame, fop_statfs_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct statvfs *buf, dict_t *xdata);
+
+call_stub_t *
+fop_setxattr_stub(call_frame_t *frame, fop_setxattr_t fn, loc_t *loc,
+                  dict_t *dict, int32_t flags, dict_t *xdata);
+
+call_stub_t *
+fop_setxattr_cbk_stub(call_frame_t *frame, fop_setxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_getxattr_stub(call_frame_t *frame, fop_getxattr_t fn, loc_t *loc,
+                  const char *name, dict_t *xdata);
+
+call_stub_t *
+fop_getxattr_cbk_stub(call_frame_t *frame, fop_getxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *value,
+                      dict_t *xdata);
+
+call_stub_t *
+fop_fsetxattr_stub(call_frame_t *frame, fop_fsetxattr_t fn, fd_t *fd,
+                   dict_t *dict, int32_t flags, dict_t *xdata);
+
+call_stub_t *
+fop_fsetxattr_cbk_stub(call_frame_t *frame, fop_fsetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_fgetxattr_stub(call_frame_t *frame, fop_fgetxattr_t fn, fd_t *fd,
+                   const char *name, dict_t *xdata);
+
+call_stub_t *
+fop_fgetxattr_cbk_stub(call_frame_t *frame, fop_fgetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *value,
+                       dict_t *xdata);
+
+call_stub_t *
+fop_removexattr_stub(call_frame_t *frame, fop_removexattr_t fn, loc_t *loc,
+                     const char *name, dict_t *xdata);
+
+call_stub_t *
+fop_removexattr_cbk_stub(call_frame_t *frame, fop_removexattr_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_fremovexattr_stub(call_frame_t *frame, fop_fremovexattr_t fn, fd_t *fd,
+                      const char *name, dict_t *xdata);
+
+call_stub_t *
+fop_fremovexattr_cbk_stub(call_frame_t *frame, fop_fremovexattr_cbk_t fn,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_lk_stub(call_frame_t *frame, fop_lk_t fn, fd_t *fd, int32_t cmd,
+            struct gf_flock *lock, dict_t *xdata);
+
+call_stub_t *
+fop_lk_cbk_stub(call_frame_t *frame, fop_lk_cbk_t fn, int32_t op_ret,
+                int32_t op_errno, struct gf_flock *lock, dict_t *xdata);
+
+call_stub_t *
+fop_inodelk_stub(call_frame_t *frame, fop_inodelk_t fn, const char *volume,
+                 loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata);
+
+call_stub_t *
+fop_finodelk_stub(call_frame_t *frame, fop_finodelk_t fn, const char *volume,
+                  fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata);
+
+call_stub_t *
+fop_entrylk_stub(call_frame_t *frame, fop_entrylk_t fn, const char *volume,
+                 loc_t *loc, const char *basename, entrylk_cmd cmd,
+                 entrylk_type type, dict_t *xdata);
+
+call_stub_t *
+fop_fentrylk_stub(call_frame_t *frame, fop_fentrylk_t fn, const char *volume,
+                  fd_t *fd, const char *basename, entrylk_cmd cmd,
+                  entrylk_type type, dict_t *xdata);
+
+call_stub_t *
+fop_inodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_finodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_entrylk_cbk_stub(call_frame_t *frame, fop_entrylk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_fentrylk_cbk_stub(call_frame_t *frame, fop_entrylk_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_readdir_stub(call_frame_t *frame, fop_readdir_t fn, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata);
+
+call_stub_t *
+fop_readdirp_stub(call_frame_t *frame, fop_readdirp_t fn, fd_t *fd, size_t size,
+                  off_t off, dict_t *xdata);
+
+call_stub_t *
+fop_readdirp_cbk_stub(call_frame_t *frame, fop_readdir_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
+
+call_stub_t *
+fop_readdir_cbk_stub(call_frame_t *frame, fop_readdir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
+
+call_stub_t *
+fop_rchecksum_stub(call_frame_t *frame, fop_rchecksum_t fn, fd_t *fd,
+                   off_t offset, int32_t len, dict_t *xdata);
+
+call_stub_t *
+fop_rchecksum_cbk_stub(call_frame_t *frame, fop_rchecksum_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                       uint8_t *strong_checksum, dict_t *xdata);
+
+call_stub_t *
+fop_xattrop_stub(call_frame_t *frame, fop_xattrop_t fn, loc_t *loc,
+                 gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
+
+call_stub_t *
+fop_xattrop_stub_cbk_stub(call_frame_t *frame, fop_xattrop_cbk_t fn,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_fxattrop_stub(call_frame_t *frame, fop_fxattrop_t fn, fd_t *fd,
+                  gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
+
+call_stub_t *
+fop_fxattrop_stub_cbk_stub(call_frame_t *frame, fop_xattrop_cbk_t fn,
+                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_setattr_stub(call_frame_t *frame, fop_setattr_t fn, loc_t *loc,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+call_stub_t *
+fop_setattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata);
+
+call_stub_t *
+fop_fsetattr_stub(call_frame_t *frame, fop_fsetattr_t fn, fd_t *fd,
+                  struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+call_stub_t *
+fop_fsetattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata);
+
+call_stub_t *
+fop_fallocate_stub(call_frame_t *frame, fop_fallocate_t fn, fd_t *fd,
+                   int32_t mode, off_t offset, size_t len, dict_t *xdata);
+
+call_stub_t *
+fop_fallocate_cbk_stub(call_frame_t *frame, fop_fallocate_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata);
+
+call_stub_t *
+fop_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd, off_t offset,
+                 size_t len, dict_t *xdata);
+
+call_stub_t *
+fop_discard_cbk_stub(call_frame_t *frame, fop_discard_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata);
+
+call_stub_t *
+fop_zerofill_stub(call_frame_t *frame, fop_zerofill_t fn, fd_t *fd,
+                  off_t offset, off_t len, dict_t *xdata);
+
+call_stub_t *
+fop_zerofill_cbk_stub(call_frame_t *frame, fop_zerofill_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata);
+
+call_stub_t *
+fop_ipc_stub(call_frame_t *frame, fop_ipc_t fn, int32_t op, dict_t *xdata);
+
+call_stub_t *
+fop_ipc_cbk_stub(call_frame_t *frame, fop_ipc_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_seek_stub(call_frame_t *frame, fop_seek_t fn, fd_t *fd, off_t offset,
+              gf_seek_what_t what, dict_t *xdata);
+
+call_stub_t *
+fop_seek_cbk_stub(call_frame_t *frame, fop_seek_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, off_t offset, dict_t *xdata);
+
+call_stub_t *
+fop_lease_stub(call_frame_t *frame, fop_lease_t fn, loc_t *loc,
+               struct gf_lease *lease, dict_t *xdata);
+
+call_stub_t *
+fop_lease_cbk_stub(call_frame_t *frame, fop_lease_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct gf_lease *lease, dict_t *xdata);
+
+call_stub_t *
+fop_getactivelk_stub(call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
+                     dict_t *xdata);
+
+call_stub_t *
+fop_getactivelk_cbk_stub(call_frame_t *frame, fop_getactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno,
+                         lock_migration_info_t *lmi, dict_t *xdata);
+
+call_stub_t *
+fop_setactivelk_stub(call_frame_t *frame, fop_setactivelk_t fn, loc_t *loc,
+                     lock_migration_info_t *locklist, dict_t *xdata);
+
+call_stub_t *
+fop_setactivelk_cbk_stub(call_frame_t *frame, fop_setactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+call_stub_t *
+fop_put_stub(call_frame_t *frame, fop_put_t fn, loc_t *loc, mode_t mode,
+             mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+             off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata);
+
+call_stub_t *
+fop_put_cbk_stub(call_frame_t *frame, fop_put_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, inode_t *inode, struct iatt *buf,
+                 struct iatt *preparent, struct iatt *postparent,
+                 dict_t *xdata);
+
+call_stub_t *
+fop_icreate_stub(call_frame_t *frame, fop_icreate_t fn, loc_t *loc, mode_t mode,
+                 dict_t *xdata);
+
+call_stub_t *
+fop_namelink_stub(call_frame_t *frame, fop_namelink_t fn, loc_t *loc,
+                  dict_t *xdata);
+
+call_stub_t *
+fop_icreate_cbk_stub(call_frame_t *frame, fop_icreate_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     dict_t *xdata);
+
+call_stub_t *
+fop_namelink_cbk_stub(call_frame_t *frame, fop_namelink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata);
+
+call_stub_t *
+fop_copy_file_range_stub(call_frame_t *frame, fop_copy_file_range_t fn,
+                         fd_t *fd_in, off64_t off_in, fd_t *fd_out,
+                         off64_t off_out, size_t len, uint32_t flags,
+                         dict_t *xdata);
+
+call_stub_t *
+fop_copy_file_range_cbk_stub(call_frame_t *frame, fop_copy_file_range_cbk_t fn,
+                             int32_t op_ret, int32_t op_errno,
+                             struct iatt *stbuf, struct iatt *prebuf_dst,
+                             struct iatt *postbuf_dst, dict_t *xdata);
+
+void
+call_resume(call_stub_t *stub);
+void
+call_resume_keep_stub(call_stub_t *stub);
+void
+call_stub_destroy(call_stub_t *stub);
+void
+call_unwind_error(call_stub_t *stub, int op_ret, int op_errno);
+void
+call_unwind_error_keep_stub(call_stub_t *stub, int op_ret, int op_errno);
+
+/*
+ * Sometimes we might want to call just this, perhaps repeatedly, without
+ * having (or being able) to destroy and recreate it.
+ */
+void
+call_resume_wind(call_stub_t *stub);
+
+#endif
diff --git a/libglusterfs/src/checksum.h b/libglusterfs/src/glusterfs/checksum.h
index bf7eeede8fc..019bb14df71 100644
--- a/libglusterfs/src/checksum.h
+++ b/libglusterfs/src/glusterfs/checksum.h
@@ -12,9 +12,11 @@
 #define __CHECKSUM_H__
 
 uint32_t
-gf_rsync_weak_checksum (unsigned char *buf, size_t len);
+gf_rsync_weak_checksum(unsigned char *buf, size_t len);
 
 void
-gf_rsync_strong_checksum (unsigned char *buf, size_t len, unsigned char *sum);
+gf_rsync_strong_checksum(unsigned char *buf, size_t len, unsigned char *sum);
 
+void
+gf_rsync_md5_checksum(unsigned char *data, size_t len, unsigned char *md5);
 #endif /* __CHECKSUM_H__ */
diff --git a/libglusterfs/src/glusterfs/circ-buff.h b/libglusterfs/src/glusterfs/circ-buff.h
new file mode 100644
index 00000000000..822345b641b
--- /dev/null
+++ b/libglusterfs/src/glusterfs/circ-buff.h
@@ -0,0 +1,61 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CB_H
+#define _CB_H
+
+#include "glusterfs/common-utils.h"
+
+#define BUFFER_SIZE 10
+#define TOTAL_SIZE BUFFER_SIZE + 1
+
+struct _circular_buffer {
+    struct timeval tv;
+    void *data;
+};
+
+typedef struct _circular_buffer circular_buffer_t;
+
+struct _buffer {
+    unsigned int w_index;
+    size_t size_buffer;
+    gf_boolean_t use_once;
+    /* This variable is assigned the proper value at the time of initing */
+    /* the buffer. It indicates, whether the buffer should be used once */
+    /*  it becomes full. */
+
+    int used_len;
+    /* indicates the amount of circular buffer used. */
+
+    circular_buffer_t **cb;
+    void (*destroy_buffer_data)(void *data);
+    pthread_mutex_t lock;
+};
+
+typedef struct _buffer buffer_t;
+
+int
+cb_add_entry_buffer(buffer_t *buffer, void *item);
+
+void
+cb_buffer_show(buffer_t *buffer);
+
+buffer_t *
+cb_buffer_new(size_t buffer_size, gf_boolean_t use_buffer_once,
+              void (*destroy_data)(void *data));
+
+void
+cb_buffer_destroy(buffer_t *buffer);
+
+void
+cb_buffer_dump(buffer_t *buffer, void *data,
+               int(fn)(circular_buffer_t *buffer, void *data));
+
+#endif /* _CB_H */
diff --git a/libglusterfs/src/glusterfs/client_t.h b/libglusterfs/src/glusterfs/client_t.h
new file mode 100644
index 00000000000..a2c508e1d5c
--- /dev/null
+++ b/libglusterfs/src/glusterfs/client_t.h
@@ -0,0 +1,147 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CLIENT_T_H
+#define _CLIENT_T_H
+
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/locking.h" /* for gf_lock_t, not included by glusterfs.h */
+#include "glusterfs/atomic.h"  /* for gf_atomic_t */
+
+/* auth_data structure is required by RPC layer. But as it is also used in
+ * client_t structure validation, comparision, it is critical that it is defined
+ * in the larger scope of libglusterfs, instead of libgfrpc. With this change,
+ * even RPC will use this structure */
+#define GF_CLIENTT_AUTH_BYTES 400
+typedef struct client_auth_data {
+    int flavour;
+    int datalen;
+    char authdata[GF_CLIENTT_AUTH_BYTES];
+} client_auth_data_t;
+
+struct client_ctx {
+    void *ctx_key;
+    void *ctx_value;
+};
+
+typedef struct _client {
+    struct {
+        /* e.g. protocol/server stashes its ctx here */
+        gf_lock_t lock;
+        unsigned short count;
+        struct client_ctx *ctx;
+    } scratch_ctx;
+    gf_atomic_t bind;
+    gf_atomic_t count;
+    xlator_t *bound_xl;
+    xlator_t *this;
+    int tbl_index;
+    char *client_uid;
+    char *client_name;
+    struct {
+        int flavour;
+        size_t len;
+        char *data;
+        char *username;
+        char *passwd;
+    } auth;
+
+    /* subdir_mount */
+    char *subdir_mount;
+    inode_t *subdir_inode;
+    uuid_t subdir_gfid;
+    int32_t opversion;
+    /* Variable to save fd_count for detach brick */
+    gf_atomic_t fd_cnt;
+} client_t;
+
+#define GF_CLIENTCTX_INITIAL_SIZE 8
+
+struct client_table_entry {
+    client_t *client;
+    int next_free;
+};
+typedef struct client_table_entry cliententry_t;
+
+struct clienttable {
+    unsigned int max_clients;
+    gf_lock_t lock;
+    cliententry_t *cliententries;
+    int first_free;
+    client_t *local;
+};
+typedef struct clienttable clienttable_t;
+
+#define GF_CLIENTTABLE_INITIAL_SIZE 128
+
+/* Signifies no more entries in the client table. */
+#define GF_CLIENTTABLE_END -1
+
+/* This is used to invalidate
+ * the next_free value in an cliententry that has been allocated
+ */
+#define GF_CLIENTENTRY_ALLOCATED -2
+
+void
+gf_client_put(client_t *client, gf_boolean_t *detached);
+
+clienttable_t *
+gf_clienttable_alloc(void);
+
+client_t *
+gf_client_ref(client_t *client);
+
+void
+gf_client_unref(client_t *client);
+
+int
+gf_client_dump_fdtable_to_dict(xlator_t *this, dict_t *dict);
+
+int
+gf_client_dump_fdtable(xlator_t *this);
+
+int
+gf_client_dump_inodes_to_dict(xlator_t *this, dict_t *dict);
+
+int
+gf_client_dump_inodes(xlator_t *this);
+
+void *
+client_ctx_set(client_t *client, void *key, void *value);
+
+int
+client_ctx_get(client_t *client, void *key, void **value);
+
+int
+client_ctx_del(client_t *client, void *key, void **value);
+
+void
+client_ctx_dump(client_t *client, char *prefix);
+
+int
+gf_client_dump_fdtables_to_dict(xlator_t *this, dict_t *dict);
+
+int
+gf_client_dump_fdtables(xlator_t *this);
+
+int
+gf_client_dump_inodes_to_dict(xlator_t *this, dict_t *dict);
+
+int
+gf_client_dump_inodes(xlator_t *this);
+
+int
+gf_client_disconnect(client_t *client);
+
+client_t *
+gf_client_get(xlator_t *this, client_auth_data_t *cred, char *client_uid,
+              char *subdir_mount);
+
+#endif /* _CLIENT_T_H */
diff --git a/libglusterfs/src/glusterfs/cluster-syncop.h b/libglusterfs/src/glusterfs/cluster-syncop.h
new file mode 100644
index 00000000000..d0ad5ed548c
--- /dev/null
+++ b/libglusterfs/src/glusterfs/cluster-syncop.h
@@ -0,0 +1,227 @@
+/*
+  Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CLUSTER_SYNCOP_H
+#define _CLUSTER_SYNCOP_H
+
+#include <sys/time.h>
+#include <pthread.h>
+#include <ucontext.h>
+
+#include "glusterfs/defaults.h"
+#include "glusterfs/default-args.h"
+#include "glusterfs/syncop.h"
+
+/*********************************************************************
+ *
+ * PARALLEL_FOP_ONLIST:
+ *          Performs file operations in parallel on bricks.
+ * This macro expects a helper function(func) to implement the
+ * functionality.
+ *
+ ********************************************************************/
+#define PARALLEL_FOP_ONLIST(subvols, on, numsubvols, replies, frame, func,     \
+                            args...)                                           \
+    do {                                                                       \
+        int __i = 0;                                                           \
+        int __count = 0;                                                       \
+        cluster_local_t __local = {                                            \
+            0,                                                                 \
+        };                                                                     \
+        void *__old_local = frame->local;                                      \
+                                                                               \
+        __local.replies = replies;                                             \
+        cluster_replies_wipe(replies, numsubvols);                             \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+        if (syncbarrier_init(&__local.barrier))                                \
+            break;                                                             \
+        frame->local = &__local;                                               \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (on[__i]) {                                                     \
+                __count++;                                                     \
+            }                                                                  \
+        }                                                                      \
+        __local.barrier.waitfor = __count;                                     \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (on[__i]) {                                                     \
+                func(frame, subvols[__i], __i, ##args);                        \
+            }                                                                  \
+        }                                                                      \
+        syncbarrier_wait(&__local.barrier, __count);                           \
+        syncbarrier_destroy(&__local.barrier);                                 \
+        frame->local = __old_local;                                            \
+        STACK_RESET(frame->root);                                              \
+    } while (0)
+
+typedef struct cluster_local_ {
+    default_args_cbk_t *replies;
+    syncbarrier_t barrier;
+} cluster_local_t;
+
+int32_t
+cluster_lookup(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+int32_t
+cluster_setattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                struct iatt *stbuf, int32_t valid, dict_t *xdata);
+int32_t
+cluster_getxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 const char *name, dict_t *xdata);
+int32_t
+cluster_setxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                 int32_t flags, dict_t *xdata);
+
+int
+cluster_inodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                off_t off, size_t size);
+
+int
+cluster_uninodelk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, off_t off, size_t size);
+
+int
+cluster_entrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                const char *name);
+
+int32_t
+cluster_rmdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+              dict_t *xdata);
+
+int32_t
+cluster_unlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+               dict_t *xdata);
+
+int
+cluster_mkdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              mode_t umask, dict_t *xdata);
+
+int32_t
+cluster_readlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                 dict_t *xdata);
+
+int
+cluster_symlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, const char *linkpath,
+                loc_t *loc, mode_t umask, dict_t *xdata);
+
+int32_t
+cluster_link(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata);
+
+int
+cluster_mknod(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              dev_t rdev, mode_t umask, dict_t *xdata);
+
+int
+cluster_unentrylk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, const char *name);
+
+int
+cluster_tryentrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
+                   call_frame_t *frame, xlator_t *this, char *dom,
+                   inode_t *inode, const char *name);
+
+int32_t
+cluster_fxattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+cluster_xattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+cluster_fstat(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
+
+int32_t
+cluster_ftruncate(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  dict_t *xdata);
+
+int32_t
+cluster_open(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             fd_t *fd, dict_t *xdata);
+
+int
+cluster_tryinodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
+                   call_frame_t *frame, xlator_t *this, char *dom,
+                   inode_t *inode, off_t off, size_t size);
+
+int32_t
+cluster_fsetattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+int32_t
+cluster_put(xlator_t **subvols, unsigned char *on, int numsubvols,
+            default_args_cbk_t *replies, unsigned char *output,
+            call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+            off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata);
+
+void
+cluster_replies_wipe(default_args_cbk_t *replies, int num_subvols);
+
+int32_t
+cluster_fop_success_fill(default_args_cbk_t *replies, int numsubvols,
+                         unsigned char *success);
+
+int32_t
+cluster_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata);
+
+int
+cluster_tiebreaker_inodelk(xlator_t **subvols, unsigned char *on,
+                           int numsubvols, default_args_cbk_t *replies,
+                           unsigned char *locked_on, call_frame_t *frame,
+                           xlator_t *this, char *dom, inode_t *inode, off_t off,
+                           size_t size);
+#endif /* !_CLUSTER_SYNCOP_H */
diff --git a/libglusterfs/src/glusterfs/common-utils.h b/libglusterfs/src/glusterfs/common-utils.h
new file mode 100644
index 00000000000..f297fdab5c9
--- /dev/null
+++ b/libglusterfs/src/glusterfs/common-utils.h
@@ -0,0 +1,1256 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _COMMON_UTILS_H
+#define _COMMON_UTILS_H
+
+#include <stdint.h>
+#include <sys/uio.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <openssl/md5.h>
+#ifndef GF_BSD_HOST_OS
+#include <alloca.h>
+#endif
+#include <limits.h>
+#include <fnmatch.h>
+#include <uuid/uuid.h>
+
+/* FreeBSD, etc. */
+#ifndef __BITS_PER_LONG
+#define __BITS_PER_LONG (CHAR_BIT * (sizeof(long)))
+#endif
+
+#ifndef ffsll
+#define ffsll(x) __builtin_ffsll(x)
+#endif
+
+void
+trap(void);
+
+#define GF_UNIVERSAL_ANSWER 42 /* :O */
+
+/* To solve type punned error */
+#define VOID(ptr) ((void **)((void *)ptr))
+
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/compat-uuid.h"
+#include "glusterfs/iatt.h"
+#include "glusterfs/libglusterfs-messages.h"
+
+#define STRINGIFY(val) #val
+#define TOSTRING(val) STRINGIFY(val)
+
+#define alloca0(size)                                                          \
+    ({                                                                         \
+        void *__ptr;                                                           \
+        __ptr = alloca(size);                                                  \
+        memset(__ptr, 0, size);                                                \
+        __ptr;                                                                 \
+    })
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define gf_roof(a, b) ((((a) + (b)-1) / ((b != 0) ? (b) : 1)) * (b))
+#define gf_floor(a, b) (((a) / ((b != 0) ? (b) : 1)) * (b))
+
+#define IPv4_ADDR_SIZE 32
+
+#define GF_UNIT_KB 1024ULL
+#define GF_UNIT_MB 1048576ULL
+#define GF_UNIT_GB 1073741824ULL
+#define GF_UNIT_TB 1099511627776ULL
+#define GF_UNIT_PB 1125899906842624ULL
+
+#define GF_UNIT_B_STRING "B"
+#define GF_UNIT_KB_STRING "KB"
+#define GF_UNIT_MB_STRING "MB"
+#define GF_UNIT_GB_STRING "GB"
+#define GF_UNIT_TB_STRING "TB"
+#define GF_UNIT_PB_STRING "PB"
+
+#define GF_UNIT_PERCENT_STRING "%"
+
+#define GEOREP "geo-replication"
+#define GLUSTERD_NAME "glusterd"
+
+#define GF_SELINUX_XATTR_KEY "security.selinux"
+
+#define WIPE(statp)                                                            \
+    do {                                                                       \
+        typeof(*statp) z = {                                                   \
+            0,                                                                 \
+        };                                                                     \
+        if (statp)                                                             \
+            *statp = z;                                                        \
+    } while (0)
+
+#define IS_EXT_FS(fs_name)                                                     \
+    (!strcmp(fs_name, "ext2") || !strcmp(fs_name, "ext3") ||                   \
+     !strcmp(fs_name, "ext4"))
+
+/* process mode definitions */
+#define GF_SERVER_PROCESS 0
+#define GF_CLIENT_PROCESS 1
+#define GF_GLUSTERD_PROCESS 2
+
+/* Defining this here as it is needed by glusterd for setting
+ * nfs port in volume status.
+ */
+#define GF_NFS3_PORT 2049
+
+#define GF_CLIENT_PORT_CEILING 1024
+#define GF_IANA_PRIV_PORTS_START 49152 /* RFC 6335 */
+#define GF_CLNT_INSECURE_PORT_CEILING (GF_IANA_PRIV_PORTS_START - 1)
+#define GF_PORT_MAX 65535
+#define GF_PORT_ARRAY_SIZE ((GF_PORT_MAX + 7) / 8)
+#define GF_LOCK_TIMER 180
+#define GF_MINUTE_IN_SECONDS 60
+#define GF_HOUR_IN_SECONDS (60 * 60)
+#define GF_DAY_IN_SECONDS (24 * 60 * 60)
+#define GF_WEEK_IN_SECONDS (7 * 24 * 60 * 60)
+#define GF_SEC_IN_NS 1000000000
+#define GF_MS_IN_NS 1000000
+#define GF_US_IN_NS 1000
+
+/* Default timeout for both barrier and changelog translator */
+#define BARRIER_TIMEOUT "120"
+
+/* Default value of signing waiting time to sign a file for bitrot */
+#define SIGNING_TIMEOUT "120"
+#define BR_WORKERS "4"
+
+/* xxhash */
+#define GF_XXH64_DIGEST_LENGTH 8
+#define GF_XXHSUM64_DEFAULT_SEED 0
+
+/* Shard */
+#define GF_XATTR_SHARD_FILE_SIZE "trusted.glusterfs.shard.file-size"
+#define SHARD_ROOT_GFID "be318638-e8a0-4c6d-977d-7a937aa84806"
+#define DOT_SHARD_REMOVE_ME_GFID "77dd5a45-dbf5-4592-b31b-b440382302e9"
+
+/* Lease: buffer length for stringified lease id
+ * Format: 4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum-4hexnum
+ * Eg:6c69-6431-2d63-6c6e-7431-0000-0000-0000
+ */
+#define GF_LEASE_ID_BUF_SIZE ((LEASE_ID_SIZE * 2) + (LEASE_ID_SIZE / 2))
+
+#define GF_PERCENTAGE(val, total) (((val)*100) / (total))
+
+/* pthread related */
+/* as per the man page, thread-name should be at max 16 bytes */
+/* with prefix of 'glfs_' (5), we are left with 11 more bytes */
+#define GF_THREAD_NAME_LIMIT 16
+#define GF_THREAD_NAME_PREFIX "glfs_"
+
+/* Advisory buffer size for formatted timestamps (see gf_time_fmt) */
+#define GF_TIMESTR_SIZE 256
+
+/*
+ * we could have initialized these as +ve values and treated
+ * them as negative while comparing etc.. (which would have
+ * saved us with the pain of assigning values), but since we
+ * only have a few clients that use this feature, it's okay.
+ */
+enum _gf_special_pid {
+    GF_CLIENT_PID_MAX = 0,
+    GF_CLIENT_PID_GSYNCD = -1,
+    GF_CLIENT_PID_HADOOP = -2,
+    GF_CLIENT_PID_DEFRAG = -3,
+    GF_CLIENT_PID_NO_ROOT_SQUASH = -4,
+    GF_CLIENT_PID_QUOTA_MOUNT = -5,
+    GF_CLIENT_PID_SELF_HEALD = -6,
+    GF_CLIENT_PID_GLFS_HEAL = -7,
+    GF_CLIENT_PID_BITD = -8,
+    GF_CLIENT_PID_SCRUB = -9,
+    GF_CLIENT_PID_TIER_DEFRAG = -10,
+    GF_SERVER_PID_TRASH = -11,
+    GF_CLIENT_PID_ADD_REPLICA_MOUNT = -12,
+    GF_CLIENT_PID_SET_UTIME = -13,
+};
+
+enum _gf_xlator_ipc_targets {
+    GF_IPC_TARGET_CHANGELOG = 0,
+    GF_IPC_TARGET_CTR = 1,
+    GF_IPC_TARGET_UPCALL = 2
+};
+
+typedef enum _gf_special_pid gf_special_pid_t;
+typedef enum _gf_xlator_ipc_targets _gf_xlator_ipc_targets_t;
+
+/* Array to hold custom xattr keys */
+extern char *xattrs_to_heal[];
+
+char **
+get_xattrs_to_heal();
+
+/* The DHT file rename operation is not a straightforward rename.
+ * It involves creating linkto and linkfiles, and can unlink or rename the
+ * source file depending on the hashed and cached subvols for the source
+ * and target files. this makes it difficult for geo-rep to figure out that
+ * a rename operation has taken place.
+ *
+ * We now send a special key and the values of the source and target pargfids
+ * and basenames to indicate to changelog that the operation in question
+ * should be treated as a rename. We are explicitly filling and sending this
+ * as a binary value in the dictionary as the unlink op will not have the
+ * source file information. The lengths of the src and target basenames
+ * are used to calculate where to start reading the names in the structure.
+ * XFS allows a max of 255 chars for filenames but other file systems might
+ * not have such restrictions
+ */
+typedef struct dht_changelog_rename_info {
+    uuid_t old_pargfid;
+    uuid_t new_pargfid;
+    int32_t oldname_len;
+    int32_t newname_len;
+    char buffer[1];
+} dht_changelog_rename_info_t;
+
+typedef int (*gf_cmp)(void *, void *);
+
+struct _dict;
+
+struct dnscache {
+    struct _dict *cache_dict;
+    time_t ttl;
+};
+
+struct dnscache_entry {
+    char *ip;
+    char *fqdn;
+    time_t timestamp;
+};
+
+struct dnscache6 {
+    struct addrinfo *first;
+    struct addrinfo *next;
+};
+
+struct list_node {
+    void *ptr;
+    struct list_head list;
+};
+
+extern char *vol_type_str[];
+
+struct list_node *
+list_node_add(void *ptr, struct list_head *list);
+struct list_node *
+list_node_add_order(void *ptr, struct list_head *list,
+                    int (*compare)(struct list_head *, struct list_head *));
+void
+list_node_del(struct list_node *node);
+
+struct dnscache *
+gf_dnscache_init(time_t ttl);
+void
+gf_dnscache_deinit(struct dnscache *cache);
+struct dnscache_entry *
+gf_dnscache_entry_init(void);
+void
+gf_dnscache_entry_deinit(struct dnscache_entry *entry);
+char *
+gf_rev_dns_lookup_cached(const char *ip, struct dnscache *dnscache);
+
+char *
+gf_resolve_path_parent(const char *path);
+
+void
+gf_global_variable_init(void);
+
+int32_t
+gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
+               struct addrinfo **addr_info);
+
+void
+gf_log_dump_graph(FILE *specfp, glusterfs_graph_t *graph);
+void
+gf_print_trace(int32_t signal, glusterfs_ctx_t *ctx);
+int
+gf_set_log_file_path(cmd_args_t *cmd_args, glusterfs_ctx_t *ctx);
+int
+gf_set_log_ident(cmd_args_t *cmd_args);
+
+int
+gf_process_getspec_servers_list(cmd_args_t *cmd_args, const char *servers_list);
+int
+gf_set_volfile_server_common(cmd_args_t *cmd_args, const char *host,
+                             const char *transport, int port);
+
+static inline void
+BIT_SET(unsigned char *array, unsigned int index)
+{
+    unsigned int offset = index / 8;
+    unsigned int shift = index % 8;
+
+    array[offset] |= (1 << shift);
+}
+
+static inline void
+BIT_CLEAR(unsigned char *array, unsigned int index)
+{
+    unsigned int offset = index / 8;
+    unsigned int shift = index % 8;
+
+    array[offset] &= ~(1 << shift);
+}
+
+static inline unsigned int
+BIT_VALUE(unsigned char *array, unsigned int index)
+{
+    unsigned int offset = index / 8;
+    unsigned int shift = index % 8;
+
+    return (array[offset] >> shift) & 0x1;
+}
+
+#define VECTORSIZE(count) (count * (sizeof(struct iovec)))
+
+#define STRLEN_0(str) (strlen(str) + 1)
+
+#define VALIDATE_OR_GOTO(arg, label)                                           \
+    do {                                                                       \
+        if (!arg) {                                                            \
+            errno = EINVAL;                                                    \
+            gf_msg_callingfn((this ? (this->name) : "(Govinda! Govinda!)"),    \
+                             GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,       \
+                             "invalid argument: " #arg);                       \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_VALIDATE_OR_GOTO(name, arg, label)                                  \
+    do {                                                                       \
+        if (!arg) {                                                            \
+            errno = EINVAL;                                                    \
+            gf_msg_callingfn(name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,    \
+                             "invalid argument: " #arg);                       \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_VALIDATE_OR_GOTO_WITH_ERROR(name, arg, label, errno, error)         \
+    do {                                                                       \
+        if (!arg) {                                                            \
+            errno = error;                                                     \
+            gf_msg_callingfn(name, GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,   \
+                             "invalid argument: " #arg);                       \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_CHECK_ALLOC(arg, retval, label)                                     \
+    do {                                                                       \
+        if (!(arg)) {                                                          \
+            retval = -ENOMEM;                                                  \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_CHECK_ALLOC_AND_LOG(name, item, retval, msg, errlabel)              \
+    do {                                                                       \
+        if (!(item)) {                                                         \
+            (retval) = -ENOMEM;                                                \
+            gf_msg(name, GF_LOG_CRITICAL, ENOMEM, LG_MSG_NO_MEMORY, (msg));    \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
+
+#define GF_ASSERT_AND_GOTO_WITH_ERROR(name, arg, label, errno, error)          \
+    do {                                                                       \
+        if (!arg) {                                                            \
+            GF_ASSERT(0);                                                      \
+            errno = error;                                                     \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO(name, arg, label)                    \
+    do {                                                                       \
+        GF_VALIDATE_OR_GOTO(name, arg, label);                                 \
+        if ((arg[0]) != '/') {                                                 \
+            errno = EINVAL;                                                    \
+            gf_msg_callingfn(name, GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,   \
+                             "invalid argument: " #arg);                       \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_REMOVE_SLASH_FROM_PATH(path, string)                                \
+    do {                                                                       \
+        int i = 0;                                                             \
+        for (i = 1; i < strlen(path); i++) {                                   \
+            string[i - 1] = path[i];                                           \
+            if (string[i - 1] == '/')                                          \
+                string[i - 1] = '-';                                           \
+        }                                                                      \
+    } while (0)
+
+#define GF_REMOVE_INTERNAL_XATTR(pattern, dict)                                \
+    do {                                                                       \
+        if (!dict) {                                                           \
+            gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_DICT_NULL,              \
+                   "dict is null");                                            \
+            break;                                                             \
+        }                                                                      \
+        dict_foreach_fnmatch(dict, pattern, dict_remove_foreach_fn, NULL);     \
+    } while (0)
+
+#define GF_IF_INTERNAL_XATTR_GOTO(pattern, dict, op_errno, label)              \
+    do {                                                                       \
+        if (!dict) {                                                           \
+            gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_DICT_NULL,              \
+                   "setxattr dict is null");                                   \
+            goto label;                                                        \
+        }                                                                      \
+        if (dict_foreach_fnmatch(dict, pattern, dict_null_foreach_fn, NULL) >  \
+            0) {                                                               \
+            op_errno = EPERM;                                                  \
+            gf_msg(this->name, GF_LOG_ERROR, op_errno, LG_MSG_NO_PERM,         \
+                   "attempt to set internal"                                   \
+                   " xattr: %s",                                               \
+                   pattern);                                                   \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GF_IF_NATIVE_XATTR_GOTO(pattern, key, op_errno, label)                 \
+    do {                                                                       \
+        if (!key) {                                                            \
+            gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_NO_KEY,                 \
+                   "no key for removexattr");                                  \
+            goto label;                                                        \
+        }                                                                      \
+        if (!fnmatch(pattern, key, 0)) {                                       \
+            op_errno = EPERM;                                                  \
+            gf_msg(this->name, GF_LOG_ERROR, op_errno, LG_MSG_NO_PERM,         \
+                   "attempt to remove internal "                               \
+                   "xattr: %s",                                                \
+                   key);                                                       \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#ifdef DEBUG
+#define GF_ASSERT(x) assert(x);
+#else
+#define GF_ASSERT(x)                                                           \
+    do {                                                                       \
+        if (!(x)) {                                                            \
+            gf_msg_callingfn("", GF_LOG_ERROR, 0, LG_MSG_ASSERTION_FAILED,     \
+                             "Assertion failed: " #x);                         \
+        }                                                                      \
+    } while (0)
+#endif
+
+/* Compile-time assert, borrowed from Linux kernel. */
+#ifdef HAVE_STATIC_ASSERT
+#define GF_STATIC_ASSERT(expr, ...)                                            \
+    __gf_static_assert(expr, ##__VA_ARGS__, #expr)
+#define __gf_static_assert(expr, msg, ...) _Static_assert(expr, msg)
+#else
+#define GF_STATIC_ASSERT(expr, ...)
+#endif
+
+#define GF_ABORT(msg...)                                                       \
+    do {                                                                       \
+        gf_msg_callingfn("", GF_LOG_CRITICAL, 0, LG_MSG_ASSERTION_FAILED,      \
+                         "Assertion failed: " msg);                            \
+        abort();                                                               \
+    } while (0)
+
+#define GF_UUID_ASSERT(u)                                                      \
+    if (gf_uuid_is_null(u))                                                    \
+        GF_ASSERT(!"uuid null");
+
+#define GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)                        \
+    (((frame->root->pid == GF_CLIENT_PID_GSYNCD) &&                            \
+      (op_errno == EEXIST || op_errno == ENOENT))                              \
+         ? 0                                                                   \
+         : 1)
+
+union gf_sock_union {
+    struct sockaddr_storage storage;
+    struct sockaddr_in6 sin6;
+    struct sockaddr_in sin;
+    struct sockaddr sa;
+};
+
+#define GF_HIDDEN_PATH ".glusterfs"
+#define GF_UNLINK_PATH GF_HIDDEN_PATH "/unlink"
+#define GF_LANDFILL_PATH GF_HIDDEN_PATH "/landfill"
+
+#define IOV_MIN(n) min(IOV_MAX, n)
+
+static inline gf_boolean_t
+gf_irrelevant_entry(struct dirent *entry)
+{
+    GF_ASSERT(entry);
+
+    return (!strcmp(entry->d_name, ".") ||
+            !fnmatch("*.tmp", entry->d_name, 0) ||
+            !strcmp(entry->d_name, ".."));
+}
+
+static inline void
+iov_free(struct iovec *vector, int count)
+{
+    int i;
+
+    for (i = 0; i < count; i++)
+        FREE(vector[i].iov_base);
+
+    GF_FREE(vector);
+}
+
+static inline int
+iov_length(const struct iovec *vector, int count)
+{
+    int i = 0;
+    size_t size = 0;
+
+    for (i = 0; i < count; i++)
+        size += vector[i].iov_len;
+
+    return size;
+}
+
+static inline struct iovec *
+iov_dup(const struct iovec *vector, int count)
+{
+    int bytecount = 0;
+    struct iovec *newvec = NULL;
+
+    bytecount = (count * sizeof(struct iovec));
+    newvec = GF_MALLOC(bytecount, gf_common_mt_iovec);
+    if (newvec != NULL) {
+        memcpy(newvec, vector, bytecount);
+    }
+
+    return newvec;
+}
+
+typedef struct _iov_iter {
+    const struct iovec *iovec;
+    void *ptr;
+    uint32_t len;
+    uint32_t count;
+} iov_iter_t;
+
+static inline bool
+iov_iter_init(iov_iter_t *iter, const struct iovec *iovec, uint32_t count,
+              uint32_t offset)
+{
+    uint32_t len;
+
+    while (count > 0) {
+        count--;
+        len = iovec->iov_len;
+        if (offset < len) {
+            iter->ptr = iovec->iov_base + offset;
+            iter->len = len - offset;
+            iter->iovec = iovec + 1;
+            iter->count = count;
+
+            return true;
+        }
+        offset -= len;
+    }
+
+    memset(iter, 0, sizeof(*iter));
+
+    return false;
+}
+
+static inline bool
+iov_iter_end(iov_iter_t *iter)
+{
+    return iter->count == 0;
+}
+
+static inline bool
+iov_iter_next(iov_iter_t *iter, uint32_t size)
+{
+    GF_ASSERT(size <= iter->len);
+
+    if (iter->len > size) {
+        iter->len -= size;
+        iter->ptr += size;
+
+        return true;
+    }
+    if (iter->count > 0) {
+        iter->count--;
+        iter->ptr = iter->iovec->iov_base;
+        iter->len = iter->iovec->iov_len;
+        iter->iovec++;
+
+        return true;
+    }
+
+    memset(iter, 0, sizeof(*iter));
+
+    return false;
+}
+
+static inline uint32_t
+iov_iter_copy(iov_iter_t *dst, iov_iter_t *src, uint32_t size)
+{
+    uint32_t len;
+
+    len = src->len;
+    if (len > dst->len) {
+        len = dst->len;
+    }
+    if (len > size) {
+        len = size;
+    }
+    memcpy(dst->ptr, src->ptr, len);
+
+    return len;
+}
+
+static inline uint32_t
+iov_iter_to_iovec(iov_iter_t *iter, struct iovec *iovec, int32_t idx,
+                  uint32_t size)
+{
+    uint32_t len;
+
+    len = iter->len;
+    if (len > size) {
+        len = size;
+    }
+    iovec[idx].iov_base = iter->ptr;
+    iovec[idx].iov_len = len;
+
+    return len;
+}
+
+static inline int
+iov_subset(struct iovec *src, int src_count, uint32_t start, uint32_t size,
+           struct iovec **dst, int32_t dst_count)
+{
+    struct iovec iovec[src_count];
+    iov_iter_t iter;
+    uint32_t len;
+    int32_t idx;
+
+    if ((size == 0) || !iov_iter_init(&iter, src, src_count, start)) {
+        return 0;
+    }
+
+    idx = 0;
+    do {
+        len = iov_iter_to_iovec(&iter, iovec, idx, size);
+        idx++;
+        size -= len;
+    } while ((size > 0) && iov_iter_next(&iter, len));
+
+    if (*dst == NULL) {
+        *dst = iov_dup(iovec, idx);
+        if (*dst == NULL) {
+            return -1;
+        }
+    } else if (idx > dst_count) {
+        return -1;
+    } else {
+        memcpy(*dst, iovec, idx * sizeof(struct iovec));
+    }
+
+    return idx;
+}
+
+static inline int
+iov_skip(struct iovec *iovec, uint32_t count, uint32_t size)
+{
+    uint32_t len, idx;
+
+    idx = 0;
+    while ((size > 0) && (idx < count)) {
+        len = iovec[idx].iov_len;
+        if (len > size) {
+            iovec[idx].iov_len -= size;
+            iovec[idx].iov_base += size;
+            break;
+        }
+        idx++;
+        size -= len;
+    }
+
+    if (idx > 0) {
+        memmove(iovec, iovec + idx, (count - idx) * sizeof(struct iovec));
+    }
+
+    return count - idx;
+}
+
+static inline size_t
+iov_range_copy(const struct iovec *dst, uint32_t dst_count, uint32_t dst_offset,
+               const struct iovec *src, uint32_t src_count, uint32_t src_offset,
+               uint32_t size)
+{
+    iov_iter_t src_iter, dst_iter;
+    uint32_t len, total;
+
+    if ((size == 0) || !iov_iter_init(&src_iter, src, src_count, src_offset) ||
+        !iov_iter_init(&dst_iter, dst, dst_count, dst_offset)) {
+        return 0;
+    }
+
+    total = 0;
+    do {
+        len = iov_iter_copy(&dst_iter, &src_iter, size);
+        total += len;
+        size -= len;
+    } while ((size > 0) && iov_iter_next(&src_iter, len) &&
+             iov_iter_next(&dst_iter, len));
+
+    return total;
+}
+
+static inline void
+iov_unload(char *buf, const struct iovec *vector, int count)
+{
+    int i;
+    int copied = 0;
+
+    for (i = 0; i < count; i++) {
+        memcpy(buf + copied, vector[i].iov_base, vector[i].iov_len);
+        copied += vector[i].iov_len;
+    }
+}
+
+static inline size_t
+iov_load(const struct iovec *vector, int count, char *buf, int size)
+{
+    size_t left = size;
+    size_t cp = 0;
+    int ret = 0;
+    int i = 0;
+
+    while (left && i < count) {
+        cp = min(vector[i].iov_len, left);
+        if (vector[i].iov_base != buf + (size - left))
+            memcpy(vector[i].iov_base, buf + (size - left), cp);
+        ret += cp;
+        left -= cp;
+        if (left)
+            i++;
+    }
+
+    return ret;
+}
+
+static inline size_t
+iov_copy(const struct iovec *dst, int dcnt, const struct iovec *src, int scnt)
+{
+    return iov_range_copy(dst, dcnt, 0, src, scnt, 0, UINT32_MAX);
+}
+
+/* based on the amusing discussion @ https://rusty.ozlabs.org/?p=560 */
+static bool
+memeqzero(const void *data, size_t length)
+{
+    const unsigned char *p = data;
+    size_t len;
+
+    /* Check first 16 bytes manually */
+    for (len = 0; len < 16; len++) {
+        if (!length)
+            return true;
+        if (*p)
+            return false;
+        p++;
+        length--;
+    }
+
+    /* Now we know that's zero, memcmp with self. */
+    return memcmp(data, p, length) == 0;
+}
+
+static inline int
+mem_0filled(const char *buf, size_t size)
+{
+    return !memeqzero(buf, size);
+}
+
+static inline int
+iov_0filled(const struct iovec *vector, int count)
+{
+    int i = 0;
+    int ret = 0;
+
+    for (i = 0; i < count; i++) {
+        ret = mem_0filled(vector[i].iov_base, vector[i].iov_len);
+        if (ret)
+            break;
+    }
+
+    return ret;
+}
+
+typedef enum {
+    gf_timefmt_default = 0,
+    gf_timefmt_FT = 0, /* YYYY-MM-DD hh:mm:ss */
+    gf_timefmt_Ymd_T,  /* YYYY/MM-DD-hh:mm:ss */
+    gf_timefmt_bdT,    /* MMM DD hh:mm:ss */
+    gf_timefmt_F_HMS,  /* YYYY-MM-DD hhmmss */
+    gf_timefmt_dirent,
+    gf_timefmt_s,
+    gf_timefmt_last
+} gf_timefmts;
+
+static inline char *
+gf_time_fmt_tv(char *dst, size_t sz_dst, struct timeval *tv, unsigned int fmt)
+{
+    extern void _gf_timestuff(const char ***, const char ***);
+    static gf_timefmts timefmt_last = (gf_timefmts)-1;
+    static const char **fmts;
+    static const char **zeros;
+    struct tm tm, *res;
+    int localtime = 0;
+    int len = 0;
+    int pos = 0;
+
+    if (timefmt_last == ((gf_timefmts)-1)) {
+        _gf_timestuff(&fmts, &zeros);
+        timefmt_last = gf_timefmt_last;
+    }
+    if (timefmt_last <= fmt) {
+        fmt = gf_timefmt_default;
+    }
+    localtime = gf_log_get_localtime();
+    res = localtime ? localtime_r(&tv->tv_sec, &tm)
+                    : gmtime_r(&tv->tv_sec, &tm);
+    if (tv->tv_sec && (res != NULL)) {
+        len = strftime(dst, sz_dst, fmts[fmt], &tm);
+        if (len == 0)
+            return dst;
+        pos += len;
+        if (tv->tv_usec >= 0) {
+            len = snprintf(dst + pos, sz_dst - pos, ".%" GF_PRI_SUSECONDS,
+                           tv->tv_usec);
+            if (len >= sz_dst - pos)
+                return dst;
+            pos += len;
+        }
+        strftime(dst + pos, sz_dst - pos, " %z", &tm);
+    } else {
+        strncpy(dst, "N/A", sz_dst);
+    }
+    return dst;
+}
+
+static inline char *
+gf_time_fmt(char *dst, size_t sz_dst, time_t utime, unsigned int fmt)
+{
+    struct timeval tv = {utime, -1};
+
+    return gf_time_fmt_tv(dst, sz_dst, &tv, fmt);
+}
+
+/* This function helps us use gfid (unique identity) to generate inode's unique
+ * number in glusterfs.
+ */
+ino_t
+gfid_to_ino(uuid_t gfid);
+
+int
+mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks);
+/*
+ * rounds up nr to power of two. If nr is already a power of two, just returns
+ * nr
+ */
+
+int
+gf_lstat_dir(const char *path, struct stat *stbuf_in);
+
+int32_t
+gf_roundup_power_of_two(int32_t nr);
+
+/*
+ * rounds up nr to next power of two. If nr is already a power of two, next
+ * power of two is returned.
+ */
+
+int32_t
+gf_roundup_next_power_of_two(int32_t nr);
+
+char *
+gf_trim(char *string);
+int
+gf_volume_name_validate(const char *volume_name);
+
+int
+gf_string2long(const char *str, long *n);
+int
+gf_string2ulong(const char *str, unsigned long *n);
+int
+gf_string2int(const char *str, int *n);
+int
+gf_string2uint(const char *str, unsigned int *n);
+int
+gf_string2double(const char *str, double *n);
+int
+gf_string2longlong(const char *str, long long *n);
+int
+gf_string2ulonglong(const char *str, unsigned long long *n);
+
+int
+gf_string2int8(const char *str, int8_t *n);
+int
+gf_string2int16(const char *str, int16_t *n);
+int
+gf_string2int32(const char *str, int32_t *n);
+int
+gf_string2int64(const char *str, int64_t *n);
+int
+gf_string2uint8(const char *str, uint8_t *n);
+int
+gf_string2uint16(const char *str, uint16_t *n);
+int
+gf_string2uint32(const char *str, uint32_t *n);
+int
+gf_string2uint64(const char *str, uint64_t *n);
+
+int
+gf_strstr(const char *str, const char *delim, const char *match);
+
+int
+gf_string2ulong_base10(const char *str, unsigned long *n);
+int
+gf_string2uint_base10(const char *str, unsigned int *n);
+int
+gf_string2uint8_base10(const char *str, uint8_t *n);
+int
+gf_string2uint16_base10(const char *str, uint16_t *n);
+int
+gf_string2uint32_base10(const char *str, uint32_t *n);
+int
+gf_string2uint64_base10(const char *str, uint64_t *n);
+int
+gf_string2bytesize_uint64(const char *str, uint64_t *n);
+int
+gf_string2bytesize_int64(const char *str, int64_t *n);
+int
+gf_string2percent_or_bytesize(const char *str, double *n,
+                              gf_boolean_t *is_percent);
+
+int
+gf_string2boolean(const char *str, gf_boolean_t *b);
+int
+gf_strn2boolean(const char *str, const int len, gf_boolean_t *b);
+int
+gf_string2percent(const char *str, double *n);
+int
+gf_string2time(const char *str, uint32_t *n);
+
+int
+gf_lockfd(int fd);
+int
+gf_unlockfd(int fd);
+
+int
+get_checksum_for_file(int fd, uint32_t *checksum, int op_version);
+int
+log_base2(unsigned long x);
+
+int
+get_checksum_for_path(char *path, uint32_t *checksum, int op_version);
+int
+get_file_mtime(const char *path, time_t *stamp);
+char *
+gf_resolve_path_parent(const char *path);
+
+char *
+strtail(char *str, const char *pattern);
+void
+skipwhite(char **s);
+char *
+nwstrtail(char *str, char *pattern);
+/* returns a new string with nth word of given string. n>=1 */
+
+typedef struct token_iter {
+    char *end;
+    char sep;
+} token_iter_t;
+char *
+token_iter_init(char *str, char sep, token_iter_t *tit);
+gf_boolean_t
+next_token(char **tokenp, token_iter_t *tit);
+void
+drop_token(char *token, token_iter_t *tit);
+
+gf_boolean_t
+mask_match(const uint32_t a, const uint32_t b, const uint32_t m);
+gf_boolean_t
+gf_is_ip_in_net(const char *network, const char *ip_str);
+char
+valid_host_name(char *address, int length);
+char
+valid_ipv4_address(char *address, int length, gf_boolean_t wildcard_acc);
+char
+valid_ipv6_address(char *address, int length, gf_boolean_t wildcard_acc);
+char
+valid_internet_address(char *address, gf_boolean_t wildcard_acc,
+                       gf_boolean_t cidr);
+gf_boolean_t
+valid_mount_auth_address(char *address);
+gf_boolean_t
+valid_ipv4_subnetwork(const char *address);
+gf_boolean_t
+gf_sock_union_equal_addr(union gf_sock_union *a, union gf_sock_union *b);
+char *
+gf_rev_dns_lookup(const char *ip);
+
+char *
+uuid_utoa(uuid_t uuid);
+char *
+uuid_utoa_r(uuid_t uuid, char *dst);
+char *
+lkowner_utoa(gf_lkowner_t *lkowner);
+char *
+lkowner_utoa_r(gf_lkowner_t *lkowner, char *dst, int len);
+char *
+leaseid_utoa(const char *lease_id);
+gf_boolean_t
+is_valid_lease_id(const char *lease_id);
+char *
+gf_leaseid_get(void);
+char *
+gf_existing_leaseid(void);
+
+void
+gf_array_insertionsort(void *a, int l, int r, size_t elem_size, gf_cmp cmp);
+int
+gf_is_str_int(const char *value);
+
+char *gf_uint64_2human_readable(uint64_t);
+int
+validate_brick_name(char *brick);
+char *
+get_host_name(char *word, char **host);
+char *
+get_path_name(char *word, char **path);
+void
+gf_path_strip_trailing_slashes(char *path);
+uint64_t
+get_mem_size(void);
+int
+gf_strip_whitespace(char *str, int len);
+int
+gf_canonicalize_path(char *path);
+char *
+generate_glusterfs_ctx_id(void);
+char *
+gf_get_reserved_ports(void);
+int
+gf_process_reserved_ports(unsigned char *ports, uint32_t ceiling);
+gf_boolean_t
+gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling);
+int
+gf_get_hostname_from_ip(char *client_ip, char **hostname);
+gf_boolean_t
+gf_is_local_addr(char *hostname);
+gf_boolean_t
+gf_is_same_address(char *host1, char *host2);
+void
+gf_xxh64_wrapper(const unsigned char *data, size_t const len,
+                 unsigned long long const seed, char *xxh64);
+int
+gf_gfid_generate_from_xxh64(uuid_t gfid, char *key);
+
+int
+gf_set_timestamp(const char *src, const char *dest);
+
+int
+gf_thread_create(pthread_t *thread, const pthread_attr_t *attr,
+                 void *(*start_routine)(void *), void *arg, const char *name,
+                 ...) __attribute__((__format__(__printf__, 5, 6)));
+
+int
+gf_thread_vcreate(pthread_t *thread, const pthread_attr_t *attr,
+                  void *(*start_routine)(void *), void *arg, const char *name,
+                  va_list args);
+int
+gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *),
+                          void *arg, const char *name, ...)
+    __attribute__((__format__(__printf__, 4, 5)));
+
+void
+gf_thread_set_name(pthread_t thread, const char *name, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+void
+gf_thread_set_vname(pthread_t thread, const char *name, va_list args);
+gf_boolean_t
+gf_is_pid_running(int pid);
+gf_boolean_t
+gf_is_service_running(char *pidfile, int *pid);
+gf_boolean_t
+gf_valid_pid(const char *pid, int length);
+int
+gf_skip_header_section(int fd, int header_len);
+
+struct iatt;
+struct _dict;
+
+gf_boolean_t
+dht_is_linkfile(struct iatt *buf, struct _dict *dict);
+
+int
+gf_check_log_format(const char *value);
+
+int
+gf_check_logger(const char *value);
+
+gf_boolean_t
+gf_compare_sockaddr(const struct sockaddr *addr1, const struct sockaddr *addr2);
+
+char *
+gf_backtrace_save(char *buf);
+
+void
+gf_backtrace_done(char *buf);
+
+gf_loglevel_t
+fop_log_level(glusterfs_fop_t fop, int op_errno);
+
+int32_t
+gf_build_absolute_path(char *current_path, char *relative_path, char **path);
+
+int
+recursive_rmdir(const char *delete_path);
+
+int
+gf_get_index_by_elem(char **array, char *elem);
+
+int
+glusterfs_is_local_pathinfo(char *pathinfo, gf_boolean_t *local);
+
+int
+gf_thread_cleanup_xint(pthread_t thread);
+
+ssize_t
+gf_nread(int fd, void *buf, size_t count);
+
+ssize_t
+gf_nwrite(int fd, const void *buf, size_t count);
+
+void
+_mask_cancellation(void);
+void
+_unmask_cancellation(void);
+
+gf_boolean_t
+gf_is_zero_filled_stat(struct iatt *buf);
+
+void
+gf_zero_fill_stat(struct iatt *buf);
+
+gf_boolean_t
+gf_is_valid_xattr_namespace(char *k);
+
+const char *
+gf_inode_type_to_str(ia_type_t type);
+
+int32_t
+gf_bits_count(uint64_t n);
+
+int32_t
+gf_bits_index(uint64_t n);
+
+const char *
+gf_fop_string(glusterfs_fop_t fop);
+
+int
+gf_fop_int(char *fop);
+
+char *
+get_ip_from_addrinfo(struct addrinfo *addr, char **ip);
+
+int
+close_fds_except(int *fdv, size_t count);
+
+int
+gf_getgrouplist(const char *user, gid_t group, gid_t **groups);
+
+int
+glusterfs_compute_sha256(const unsigned char *content, size_t size,
+                         char *sha256_hash);
+
+char *
+gf_strncpy(char *dest, const char *src, const size_t dest_size);
+
+void
+gf_strTrim(char **s);
+
+int
+gf_replace_old_iatt_in_dict(struct _dict *);
+
+int
+gf_replace_new_iatt_in_dict(struct _dict *);
+
+xlator_cmdline_option_t *
+find_xlator_option_in_cmd_args_t(const char *option_name, cmd_args_t *args);
+
+int
+gf_d_type_from_ia_type(ia_type_t type);
+
+int
+gf_syncfs(int fd);
+
+int
+gf_nanosleep(uint64_t nsec);
+
+static inline time_t
+gf_time(void)
+{
+    return time(NULL);
+}
+
+/* Return delta value in microseconds. */
+
+static inline double
+gf_tvdiff(struct timeval *start, struct timeval *end)
+{
+    struct timeval t;
+
+    if (start->tv_usec > end->tv_usec)
+        t.tv_sec = end->tv_sec - 1, t.tv_usec = end->tv_usec + 1000000;
+    else
+        t.tv_sec = end->tv_sec, t.tv_usec = end->tv_usec;
+
+    return (double)(t.tv_sec - start->tv_sec) * 1e6 +
+           (double)(t.tv_usec - start->tv_usec);
+}
+
+/* Return delta value in nanoseconds. */
+
+static inline double
+gf_tsdiff(struct timespec *start, struct timespec *end)
+{
+    struct timespec t;
+
+    if (start->tv_nsec > end->tv_nsec)
+        t.tv_sec = end->tv_sec - 1, t.tv_nsec = end->tv_nsec + 1000000000;
+    else
+        t.tv_sec = end->tv_sec, t.tv_nsec = end->tv_nsec;
+
+    return (double)(t.tv_sec - start->tv_sec) * 1e9 +
+           (double)(t.tv_nsec - start->tv_nsec);
+}
+
+#endif /* _COMMON_UTILS_H */
diff --git a/libglusterfs/src/glusterfs/compat-errno.h b/libglusterfs/src/glusterfs/compat-errno.h
new file mode 100644
index 00000000000..c4ab09ab0d5
--- /dev/null
+++ b/libglusterfs/src/glusterfs/compat-errno.h
@@ -0,0 +1,238 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __COMPAT_ERRNO_H__
+#define __COMPAT_ERRNO_H__
+
+#include <errno.h>
+
+#define GF_ERROR_CODE_SUCCESS 0
+#define GF_ERROR_CODE_UNKNOWN 1024
+#define GF_ERRNO_UNKNOWN 1024
+
+#define GF_ERROR_CODE_PERM 1         /* Operation not permitted */
+#define GF_ERROR_CODE_NOENT 2        /* No such file or directory */
+#define GF_ERROR_CODE_SRCH 3         /* No such process */
+#define GF_ERROR_CODE_INTR 4         /* Interrupted system call */
+#define GF_ERROR_CODE_IO 5           /* I/O error */
+#define GF_ERROR_CODE_NXIO 6         /* No such device or address */
+#define GF_ERROR_CODE_2BIG 7         /* Argument list too long */
+#define GF_ERROR_CODE_NOEXEC 8       /* Exec format error */
+#define GF_ERROR_CODE_BADF 9         /* Bad file number */
+#define GF_ERROR_CODE_CHILD 10       /* No child processes */
+#define GF_ERROR_CODE_AGAIN 11       /* Try again */
+#define GF_ERROR_CODE_NOMEM 12       /* Out of memory */
+#define GF_ERROR_CODE_ACCES 13       /* Permission denied */
+#define GF_ERROR_CODE_FAULT 14       /* Bad address */
+#define GF_ERROR_CODE_NOTBLK 15      /* Block device required */
+#define GF_ERROR_CODE_BUSY 16        /* Device or resource busy */
+#define GF_ERROR_CODE_EXIST 17       /* File exists */
+#define GF_ERROR_CODE_XDEV 18        /* Cross-device link */
+#define GF_ERROR_CODE_NODEV 19       /* No such device */
+#define GF_ERROR_CODE_NOTDIR 20      /* Not a directory */
+#define GF_ERROR_CODE_ISDIR 21       /* Is a directory */
+#define GF_ERROR_CODE_INVAL 22       /* Invalid argument */
+#define GF_ERROR_CODE_NFILE 23       /* File table overflow */
+#define GF_ERROR_CODE_MFILE 24       /* Too many open files */
+#define GF_ERROR_CODE_NOTTY 25       /* Not a typewriter */
+#define GF_ERROR_CODE_TXTBSY 26      /* Text file busy */
+#define GF_ERROR_CODE_FBIG 27        /* File too large */
+#define GF_ERROR_CODE_NOSPC 28       /* No space left on device */
+#define GF_ERROR_CODE_SPIPE 29       /* Illegal seek */
+#define GF_ERROR_CODE_ROFS 30        /* Read-only file system */
+#define GF_ERROR_CODE_MLINK 31       /* Too many links */
+#define GF_ERROR_CODE_PIPE 32        /* Broken pipe */
+#define GF_ERROR_CODE_DOM 33         /* Math argument out of domain of func */
+#define GF_ERROR_CODE_RANGE 34       /* Math result not representable */
+#define GF_ERROR_CODE_DEADLK 35      /* Resource deadlock would occur */
+#define GF_ERROR_CODE_NAMETOOLONG 36 /* File name too long */
+#define GF_ERROR_CODE_NOLCK 37       /* No record locks available */
+#define GF_ERROR_CODE_NOSYS 38       /* Function not implemented */
+#define GF_ERROR_CODE_NOTEMPTY 39    /* Directory not empty */
+#define GF_ERROR_CODE_LOOP 40        /* Too many symbolic links encountered */
+
+#define GF_ERROR_CODE_NOMSG 42    /* No message of desired type */
+#define GF_ERROR_CODE_IDRM 43     /* Identifier removed */
+#define GF_ERROR_CODE_CHRNG 44    /* Channel number out of range */
+#define GF_ERROR_CODE_L2NSYNC 45  /* Level 2 not synchronized */
+#define GF_ERROR_CODE_L3HLT 46    /* Level 3 halted */
+#define GF_ERROR_CODE_L3RST 47    /* Level 3 reset */
+#define GF_ERROR_CODE_LNRNG 48    /* Link number out of range */
+#define GF_ERROR_CODE_UNATCH 49   /* Protocol driver not attached */
+#define GF_ERROR_CODE_NOCSI 50    /* No CSI structure available */
+#define GF_ERROR_CODE_L2HLT 51    /* Level 2 halted */
+#define GF_ERROR_CODE_BADE 52     /* Invalid exchange */
+#define GF_ERROR_CODE_BADR 53     /* Invalid request descriptor */
+#define GF_ERROR_CODE_XFULL 54    /* Exchange full */
+#define GF_ERROR_CODE_NOANO 55    /* No anode */
+#define GF_ERROR_CODE_BADRQC 56   /* Invalid request code */
+#define GF_ERROR_CODE_BADSLT 57   /* Invalid slot */
+#define GF_ERROR_CODE_BFONT 59    /* Bad font file format */
+#define GF_ERROR_CODE_NOSTR 60    /* Device not a stream */
+#define GF_ERROR_CODE_NODATA 61   /* No data available */
+#define GF_ERROR_CODE_TIME 62     /* Timer expired */
+#define GF_ERROR_CODE_NOSR 63     /* Out of streams resources */
+#define GF_ERROR_CODE_NONET 64    /* Machine is not on the network */
+#define GF_ERROR_CODE_NOPKG 65    /* Package not installed */
+#define GF_ERROR_CODE_REMOTE 66   /* Object is remote */
+#define GF_ERROR_CODE_NOLINK 67   /* Link has been severed */
+#define GF_ERROR_CODE_ADV 68      /* Advertise error */
+#define GF_ERROR_CODE_SRMNT 69    /* Srmount error */
+#define GF_ERROR_CODE_COMM 70     /* Communication error on send */
+#define GF_ERROR_CODE_PROTO 71    /* Protocol error */
+#define GF_ERROR_CODE_MULTIHOP 72 /* Multihop attempted */
+#define GF_ERROR_CODE_DOTDOT 73   /* RFS specific error */
+#define GF_ERROR_CODE_BADMSG 74   /* Not a data message */
+#define GF_ERROR_CODE_OVERFLOW 75 /* Value too large for defined data type */
+#define GF_ERROR_CODE_NOTUNIQ 76  /* Name not unique on network */
+#define GF_ERROR_CODE_BADFD 77    /* File descriptor in bad state */
+#define GF_ERROR_CODE_REMCHG 78   /* Remote address changed */
+#define GF_ERROR_CODE_LIBACC 79   /* Can not access a needed shared library */
+#define GF_ERROR_CODE_LIBBAD 80   /* Accessing a corrupted shared library */
+#define GF_ERROR_CODE_LIBSCN 81   /* .lib section in a.out corrupted */
+#define GF_ERROR_CODE_LIBMAX                                                   \
+    82 /* Attempting to link in too many shared libraries */
+#define GF_ERROR_CODE_LIBEXEC 83 /* Cannot exec a shared library directly */
+#define GF_ERROR_CODE_ILSEQ 84   /* Illegal byte sequence */
+#define GF_ERROR_CODE_RESTART                                                  \
+    85 /* Interrupted system call should be restarted */
+#define GF_ERROR_CODE_STRPIPE 86        /* Streams pipe error */
+#define GF_ERROR_CODE_USERS 87          /* Too many users */
+#define GF_ERROR_CODE_NOTSOCK 88        /* Socket operation on non-socket */
+#define GF_ERROR_CODE_DESTADDRREQ 89    /* Destination address required */
+#define GF_ERROR_CODE_MSGSIZE 90        /* Message too long */
+#define GF_ERROR_CODE_PROTOTYPE 91      /* Protocol wrong type for socket */
+#define GF_ERROR_CODE_NOPROTOOPT 92     /* Protocol not available */
+#define GF_ERROR_CODE_PROTONOSUPPORT 93 /* Protocol not supported */
+#define GF_ERROR_CODE_SOCKTNOSUPPORT 94 /* Socket type not supported */
+#define GF_ERROR_CODE_OPNOTSUPP                                                \
+    95 /* Operation not supported on transport endpoint */
+#define GF_ERROR_CODE_PFNOSUPPORT 96 /* Protocol family not supported */
+#define GF_ERROR_CODE_AFNOSUPPORT                                              \
+    97 /* Address family not supported by protocol */
+#define GF_ERROR_CODE_ADDRINUSE 98    /* Address already in use */
+#define GF_ERROR_CODE_ADDRNOTAVAIL 99 /* Cannot assign requested address */
+#define GF_ERROR_CODE_NETDOWN 100     /* Network is down */
+#define GF_ERROR_CODE_NETUNREACH 101  /* Network is unreachable */
+#define GF_ERROR_CODE_NETRESET                                                 \
+    102 /* Network dropped connection because of reset */
+#define GF_ERROR_CODE_CONNABORTED 103 /* Software caused connection abort */
+#define GF_ERROR_CODE_CONNRESET 104   /* Connection reset by peer */
+#define GF_ERROR_CODE_NOBUFS 105      /* No buffer space available */
+#define GF_ERROR_CODE_ISCONN 106  /* Transport endpoint is already connected */
+#define GF_ERROR_CODE_NOTCONN 107 /* Transport endpoint is not connected */
+#define GF_ERROR_CODE_SHUTDOWN                                                 \
+    108 /* Cannot send after transport endpoint shutdown */
+#define GF_ERROR_CODE_TOOMANYREFS 109 /* Too many references: cannot splice */
+#define GF_ERROR_CODE_TIMEDOUT 110    /* Connection timed out */
+#define GF_ERROR_CODE_CONNREFUSED 111 /* Connection refused */
+#define GF_ERROR_CODE_HOSTDOWN 112    /* Host is down */
+#define GF_ERROR_CODE_HOSTUNREACH 113 /* No route to host */
+#define GF_ERROR_CODE_ALREADY 114     /* Operation already in progress */
+#define GF_ERROR_CODE_INPROGRESS 115  /* Operation now in progress */
+#define GF_ERROR_CODE_ALREADY 114     /* Operation already in progress */
+#define GF_ERROR_CODE_INPROGRESS 115  /* Operation now in progress */
+#define GF_ERROR_CODE_STALE 116       /* Stale NFS file handle */
+#define GF_ERROR_CODE_UCLEAN 117      /* Structure needs cleaning */
+#define GF_ERROR_CODE_NOTNAM 118      /* Not a XENIX named type file */
+#define GF_ERROR_CODE_NAVAIL 119      /* No XENIX semaphores available */
+#define GF_ERROR_CODE_ISNAM 120       /* Is a named type file */
+#define GF_ERROR_CODE_REMOTEIO 121    /* Remote I/O error */
+#define GF_ERROR_CODE_DQUOT 122       /* Quota exceeded */
+#define GF_ERROR_CODE_NOMEDIUM 123    /* No medium found */
+#define GF_ERROR_CODE_MEDIUMTYPE 124  /* Wrong medium type */
+#define GF_ERROR_CODE_CANCELED 125    /* Operation Canceled */
+#define GF_ERROR_CODE_NOKEY 126       /* Required key not available */
+#define GF_ERROR_CODE_KEYEXPIRED 127  /* Key has expired */
+#define GF_ERROR_CODE_KEYREVOKED 128  /* Key has been revoked */
+#define GF_ERROR_CODE_KEYREJECTED 129 /* Key was rejected by service */
+
+/* for robust mutexes */
+#define GF_ERROR_CODE_OWNERDEAD 130      /* Owner died */
+#define GF_ERROR_CODE_NOTRECOVERABLE 131 /* State not recoverable */
+
+/* Should never be seen by user programs */
+#define GF_ERROR_CODE_RESTARTSYS 512
+#define GF_ERROR_CODE_RESTARTNOINTR 513
+#define GF_ERROR_CODE_RESTARTNOHAND 514 /* restart if no handler.. */
+#define GF_ERROR_CODE_NOIOCTLCMD 515    /* No ioctl command */
+#define GF_ERROR_CODE_RESTART_RESTARTBLOCK                                     \
+    516 /* restart by calling sys_restart_syscall */
+
+/* Defined for the NFSv3 protocol */
+#define GF_ERROR_CODE_BADHANDLE 521   /* Illegal NFS file handle */
+#define GF_ERROR_CODE_NOTSYNC 522     /* Update synchronization mismatch */
+#define GF_ERROR_CODE_BADCOOKIE 523   /* Cookie is stale */
+#define GF_ERROR_CODE_NOTSUPP 524     /* Operation is not supported */
+#define GF_ERROR_CODE_TOOSMALL 525    /* Buffer or request is too small */
+#define GF_ERROR_CODE_SERVERFAULT 526 /* An untranslatable error occurred */
+#define GF_ERROR_CODE_BADTYPE 527     /* Type not supported by server */
+#define GF_ERROR_CODE_JUKEBOX                                                  \
+    528 /* Request initiated, but will not complete before timeout */
+#define GF_ERROR_CODE_IOCBQUEUED                                               \
+    529                             /* iocb queued, will get completion event */
+#define GF_ERROR_CODE_IOCBRETRY 530 /* iocb queued, will trigger a retry */
+
+/* Darwin OS X */
+#define GF_ERROR_CODE_NOPOLICY 701
+#define GF_ERROR_CODE_BADMACHO 702
+#define GF_ERROR_CODE_PWROFF 703
+#define GF_ERROR_CODE_DEVERR 704
+#define GF_ERROR_CODE_BADARCH 705
+#define GF_ERROR_CODE_BADEXEC 706
+#define GF_ERROR_CODE_SHLIBVERS 707
+
+/* Solaris */
+/*	ENOTACTIVE 73	/ * Facility is not active		*/
+#define GF_ERROR_CODE_NOTACTIVE 801
+/*	ELOCKUNMAPPED	72	/ * locked lock was unmapped */
+#define GF_ERROR_CODE_LOCKUNMAPPED 802
+
+/* BSD system */
+#define GF_ERROR_CODE_PROCLIM 901      /* Too many processes */
+#define GF_ERROR_CODE_BADRPC 902       /* RPC struct is bad */
+#define GF_ERROR_CODE_RPCMISMATCH 903  /* RPC version wrong */
+#define GF_ERROR_CODE_PROGUNAVAIL 904  /* RPC prog. not avail */
+#define GF_ERROR_CODE_PROGMISMATCH 905 /* Program version wrong */
+#define GF_ERROR_CODE_PROCUNAVAIL 905  /* Bad procedure for program */
+#define GF_ERROR_CODE_FTYPE 906        /* Inappropriate file type or format */
+#define GF_ERROR_CODE_AUTH 907         /* Authentication error */
+#define GF_ERROR_CODE_NEEDAUTH 908     /* Need authenticator */
+#define GF_ERROR_CODE_DOOFUS 909       /* Programming error */
+
+#define GF_ERROR_CODE_NOATTR GF_ERROR_CODE_NODATA /* Attribute not found */
+
+/* Either one of enodata or enoattr will be there in system */
+#ifndef ENOATTR
+#define ENOATTR ENODATA
+#endif /* ENOATTR */
+
+#ifndef ENODATA
+#define ENODATA ENOATTR
+#endif /* ENODATA */
+
+#ifndef EBADFD
+#define EBADFD EBADRPC
+#endif /* EBADFD */
+
+#if !defined(ENODATA)
+/* This happens on FreeBSD.  Value borrowed from Linux. */
+#define ENODATA 61
+#endif
+
+/* These functions are defined for all the OS flags, but content will
+ * be different for each OS flag.
+ */
+int32_t
+gf_errno_to_error(int32_t op_errno);
+int32_t
+gf_error_to_errno(int32_t error);
+
+#endif /* __COMPAT_ERRNO_H__ */
diff --git a/libglusterfs/src/compat-uuid.h b/libglusterfs/src/glusterfs/compat-uuid.h
index 8dac6990388..6e7fdefbfab 100644
--- a/libglusterfs/src/compat-uuid.h
+++ b/libglusterfs/src/glusterfs/compat-uuid.h
@@ -11,54 +11,52 @@
 #ifndef _GF_UUID_H
 #define _GF_UUID_H
 
-#if defined(HAVE_LIBUUID) /* Linux like libuuid.so */
-
-#include <uuid.h>
+#include <uuid/uuid.h>
 
 static inline void
-gf_uuid_clear (uuid_t uuid)
+gf_uuid_clear(uuid_t uuid)
 {
-        uuid_clear (uuid);
+    uuid_clear(uuid);
 }
 
 static inline int
-gf_uuid_compare (uuid_t u1, uuid_t u2)
+gf_uuid_compare(uuid_t u1, uuid_t u2)
 {
-        return uuid_compare (u1, u2);
+    return uuid_compare(u1, u2);
 }
 
 static inline void
-gf_uuid_copy (uuid_t dst, const uuid_t src)
+gf_uuid_copy(uuid_t dst, const uuid_t src)
 {
-        uuid_copy (dst, src);
+    uuid_copy(dst, src);
 }
 
 static inline void
-gf_uuid_generate (uuid_t uuid)
+gf_uuid_generate(uuid_t uuid)
 {
-        uuid_generate  (uuid);
+    uuid_generate(uuid);
 }
 
 static inline int
-gf_uuid_is_null (uuid_t uuid)
+gf_uuid_is_null(uuid_t uuid)
 {
-        return uuid_is_null (uuid);
+    return uuid_is_null(uuid);
 }
 
 static inline int
-gf_uuid_parse (const char *in, uuid_t uuid)
+gf_uuid_parse(const char *in, uuid_t uuid)
 {
-        return uuid_parse (in, uuid);
+    return uuid_parse(in, uuid);
 }
 
 static inline void
-gf_uuid_unparse (const uuid_t uuid, char *out)
+gf_uuid_unparse(const uuid_t uuid, char *out)
 {
-        uuid_unparse (uuid, out);
+    uuid_unparse(uuid, out);
 }
 
 /* TODO: add more uuid APIs, use constructs like this:
-#elif defined(__NetBSD__) * NetBSD libc *
+#if defined(__NetBSD__) * NetBSD libc *
 
 #include <string.h>
 
@@ -67,12 +65,7 @@ gf_uuid_clear (uuid_t uuid)
 {
         memset (uuid, 0, sizeof (uuid_t));
 }
-
+#endif
 */
 
-#else /* use bundled Linux like libuuid from contrib/uuid/ */
-
-#include "uuid.h"
-
-#endif /* HAVE_UUID */
 #endif /* _GF_UUID_H */
diff --git a/libglusterfs/src/compat.h b/libglusterfs/src/glusterfs/compat.h
index f4da4b2a0de..bf00d903152 100644
--- a/libglusterfs/src/compat.h
+++ b/libglusterfs/src/glusterfs/compat.h
@@ -15,8 +15,7 @@
 
 #ifndef LLONG_MAX
 #define LLONG_MAX __LONG_LONG_MAX__ /* compat with old gcc */
-#endif /* LLONG_MAX */
-
+#endif                              /* LLONG_MAX */
 
 #ifdef GF_LINUX_HOST_OS
 
@@ -38,48 +37,44 @@
 #ifndef _PATH_UMOUNT
 #define _PATH_UMOUNT "/bin/umount"
 #endif
-#define GF_XATTR_NAME_MAX       XATTR_NAME_MAX
+#define GF_XATTR_NAME_MAX XATTR_NAME_MAX
 #endif /* GF_LINUX_HOST_OS */
 
-#ifdef HAVE_XATTR_H
-#include <sys/xattr.h>
-#endif
-
 /*
  * Define the fallocate flags in case we do not have the header. This also
  * accounts for older systems that do not define FALLOC_FL_PUNCH_HOLE.
  */
 
 #ifndef FALLOC_FL_KEEP_SIZE
-#define FALLOC_FL_KEEP_SIZE     0x01 /* default is extend size */
+#define FALLOC_FL_KEEP_SIZE 0x01 /* default is extend size */
 #endif
 #ifndef FALLOC_FL_PUNCH_HOLE
-#define FALLOC_FL_PUNCH_HOLE    0x02 /* de-allocates range */
+#define FALLOC_FL_PUNCH_HOLE 0x02 /* de-allocates range */
 #endif
 #ifndef FALLOC_FL_ZERO_RANGE
-#define FALLOC_FL_ZERO_RANGE    0x10 /* zeroes out range */
+#define FALLOC_FL_ZERO_RANGE 0x10 /* zeroes out range */
 #endif
 #ifndef FALLOC_FL_COLLAPSE_RANGE
-#define FALLOC_FL_COLLAPSE_RANGE  0x08 /* reduces the size */
+#define FALLOC_FL_COLLAPSE_RANGE 0x08 /* reduces the size */
 #endif
 #ifndef FALLOC_FL_INSERT_RANGE
-#define FALLOC_FL_INSERT_RANGE  0x20 /* expands the size */
+#define FALLOC_FL_INSERT_RANGE 0x20 /* expands the size */
 #endif
 
 #ifndef HAVE_LLISTXATTR
 
-/* This part is valid only incase of old glibc which doesn't support
+/* This part is valid only in case of old glibc which doesn't support
  * 'llistxattr()' system calls.
  */
 
-#define lremovexattr(path,key) removexattr(path,key)
-#define llistxattr(path,key,size)  listxattr(path,key,size)
-#define lgetxattr(path, key, value, size) getxattr(path,key,value,size)
-#define lsetxattr(path,key,value,size,flags) setxattr(path,key,value,size,flags)
+#define lremovexattr(path, key) removexattr(path, key)
+#define llistxattr(path, key, size) listxattr(path, key, size)
+#define lgetxattr(path, key, value, size) getxattr(path, key, value, size)
+#define lsetxattr(path, key, value, size, flags)                               \
+    setxattr(path, key, value, size, flags)
 
 #endif /* HAVE_LLISTXATTR */
 
-
 #ifdef GF_DARWIN_HOST_OS
 #include <machine/endian.h>
 #include <libkern/OSByteOrder.h>
@@ -102,7 +97,6 @@
 
 #endif
 
-
 #ifdef GF_BSD_HOST_OS
 /* In case of FreeBSD and NetBSD */
 
@@ -118,17 +112,35 @@
 #include <limits.h>
 
 #include <libgen.h>
+/*
+ * This is where things like off64_t are defined.
+ * So include it before declaring _OFF64_T_DECLARED.
+ * If the freebsd version has support for off64_t
+ * including stdio.h should be sufficient.
+ */
+#include <stdio.h>
+
+#ifndef _OFF64_T_DECLARED
+/*
+ * Including <stdio.h> (done above) should actually define
+ * _OFF64_T_DECLARED with off64_t data type being available
+ * for consumption. But, off64_t data type is not recognizable
+ * for FreeBSD versions less than 11. Hence, int64_t is typedefed
+ * to off64_t.
+ */
+#define _OFF64_T_DECLARED
+typedef int64_t off64_t;
+#endif /* _OFF64_T_DECLARED */
 
 #ifndef XATTR_CREATE
 enum {
-        ATTR_CREATE = 1,
+    ATTR_CREATE = 1,
 #define XATTR_CREATE ATTR_CREATE
-        ATTR_REPLACE = 2
+    ATTR_REPLACE = 2
 #define XATTR_REPLACE ATTR_REPLACE
 };
 #endif /* XATTR_CREATE */
 
-
 #ifndef sighandler_t
 #define sighandler_t sig_t
 #endif
@@ -141,11 +153,11 @@ enum {
 /* Using NAME_MAX since EXTATTR_MAXNAMELEN is inside a preprocessor conditional
  * for the kernel
  */
-#define GF_XATTR_NAME_MAX       NAME_MAX
+#define GF_XATTR_NAME_MAX NAME_MAX
 #endif /* __FreeBSD__ */
 
 #ifdef __NetBSD__
-#define GF_XATTR_NAME_MAX       XATTR_NAME_MAX
+#define GF_XATTR_NAME_MAX XATTR_NAME_MAX
 #endif
 
 #ifndef ino64_t
@@ -169,26 +181,30 @@ enum {
 #endif
 
 /* Posix dictates NAME_MAX to be used */
-# ifndef NAME_MAX
-#  ifdef  MAXNAMLEN
-#   define NAME_MAX MAXNAMLEN
-#  else
-#   define NAME_MAX 255
-#  endif
-# endif
-
-#define F_GETLK64       F_GETLK
-#define F_SETLK64       F_SETLK
-#define F_SETLKW64      F_SETLKW
-#define FALLOC_FL_KEEP_SIZE     0x01 /* default is extend size */
-#define FALLOC_FL_PUNCH_HOLE    0x02 /* de-allocates range */
-#define FALLOC_FL_ZERO_RANGE    0x10 /* zeroes out range */
-#define FALLOC_FL_INSERT_RANGE  0x20 /* Expands the size */
+#ifndef NAME_MAX
+#ifdef MAXNAMLEN
+#define NAME_MAX MAXNAMLEN
+#else
+#define NAME_MAX 255
+#endif
+#endif
+
+#define F_GETLK64 F_GETLK
+#define F_SETLK64 F_SETLK
+#define F_SETLKW64 F_SETLKW
+#define FALLOC_FL_KEEP_SIZE 0x01      /* default is extend size */
+#define FALLOC_FL_PUNCH_HOLE 0x02     /* de-allocates range */
+#define FALLOC_FL_ZERO_RANGE 0x10     /* zeroes out range */
+#define FALLOC_FL_INSERT_RANGE 0x20   /* Expands the size */
 #define FALLOC_FL_COLLAPSE_RANGE 0x08 /* Reduces the size */
 
 #ifndef _PATH_UMOUNT
-  #define _PATH_UMOUNT "/sbin/umount"
+#define _PATH_UMOUNT "/sbin/umount"
 #endif
+
+void
+gf_extattr_list_reshape(char *list, ssize_t size);
+
 #endif /* GF_BSD_HOST_OS */
 
 #ifdef GF_DARWIN_HOST_OS
@@ -223,14 +239,12 @@ enum {
 
 #include <libgen.h>
 
-
 #if __DARWIN_64_BIT_INO_T == 0
-#    error '64 bit ino_t is must for GlusterFS to work, Compile with "CFLAGS=-D__DARWIN_64_BIT_INO_T"'
+#error '64 bit ino_t is must for GlusterFS to work, Compile with "CFLAGS=-D__DARWIN_64_BIT_INO_T"'
 #endif /* __DARWIN_64_BIT_INO_T */
 
-
 #if __DARWIN_64_BIT_INO_T == 0
-#    error '64 bit ino_t is must for GlusterFS to work, Compile with "CFLAGS=-D__DARWIN_64_BIT_INO_T"'
+#error '64 bit ino_t is must for GlusterFS to work, Compile with "CFLAGS=-D__DARWIN_64_BIT_INO_T"'
 #endif /* __DARWIN_64_BIT_INO_T */
 
 #ifndef sighandler_t
@@ -250,24 +264,24 @@ enum {
 #endif
 
 /* Posix dictates NAME_MAX to be used */
-# ifndef NAME_MAX
-#  ifdef  MAXNAMLEN
-#   define NAME_MAX MAXNAMLEN
-#  else
-#   define NAME_MAX 255
-#  endif
-# endif
-
-#define F_GETLK64       F_GETLK
-#define F_SETLK64       F_SETLK
-#define F_SETLKW64      F_SETLKW
+#ifndef NAME_MAX
+#ifdef MAXNAMLEN
+#define NAME_MAX MAXNAMLEN
+#else
+#define NAME_MAX 255
+#endif
+#endif
+
+#define F_GETLK64 F_GETLK
+#define F_SETLK64 F_SETLK
+#define F_SETLKW64 F_SETLKW
 
 #ifndef FTW_CONTINUE
-  #define FTW_CONTINUE 0
+#define FTW_CONTINUE 0
 #endif
 
 #ifndef _PATH_UMOUNT
-  #define _PATH_UMOUNT "/sbin/umount"
+#define _PATH_UMOUNT "/sbin/umount"
 #endif
 #endif /* GF_DARWIN_HOST_OS */
 
@@ -288,107 +302,120 @@ enum {
 #define lchmod chmod
 #endif
 
-#define lgetxattr(path, key, value, size) solaris_getxattr(path,key,value,size)
+#define lgetxattr(path, key, value, size)                                      \
+    solaris_getxattr(path, key, value, size)
 enum {
-        ATTR_CREATE = 1,
+    ATTR_CREATE = 1,
 #define XATTR_CREATE ATTR_CREATE
-        ATTR_REPLACE = 2
+    ATTR_REPLACE = 2
 #define XATTR_REPLACE ATTR_REPLACE
 };
 
 /* This patch is not present in Solaris 10 and before */
 #ifndef dirfd
-#define dirfd(dirp)   ((dirp)->dd_fd)
+#define dirfd(dirp) ((dirp)->dd_fd)
 #endif
 
 /* Posix dictates NAME_MAX to be used */
-# ifndef NAME_MAX
-#  ifdef  MAXNAMLEN
-#   define NAME_MAX MAXNAMLEN
-#  else
-#   define NAME_MAX 255
-#  endif
-# endif
+#ifndef NAME_MAX
+#ifdef MAXNAMLEN
+#define NAME_MAX MAXNAMLEN
+#else
+#define NAME_MAX 255
+#endif
+#endif
 
 #include <netinet/in.h>
 #ifndef s6_addr16
-#define S6_ADDR16(x)    ((uint16_t*) ((char*)&(x).s6_addr))
+#define S6_ADDR16(x) ((uint16_t *)((char *)&(x).s6_addr))
 #endif
 #ifndef s6_addr32
-#define s6_addr32       _S6_un._S6_u32
+#define s6_addr32 _S6_un._S6_u32
 #endif
 
-#define lutimes(filename,times)              utimes(filename,times)
+#define lutimes(filename, times) utimes(filename, times)
 
 #ifndef SEEK_SET
 #define SEEK_SET 0
 #endif
 
 enum {
-        DT_UNKNOWN = 0,
-# define DT_UNKNOWN	DT_UNKNOWN
-        DT_FIFO = 1,
-# define DT_FIFO	DT_FIFO
-        DT_CHR = 2,
-# define DT_CHR		DT_CHR
-        DT_DIR = 4,
-# define DT_DIR		DT_DIR
-        DT_BLK = 6,
-# define DT_BLK		DT_BLK
-        DT_REG = 8,
-# define DT_REG		DT_REG
-        DT_LNK = 10,
-# define DT_LNK		DT_LNK
-        DT_SOCK = 12,
-# define DT_SOCK	DT_SOCK
-        DT_WHT = 14
-# define DT_WHT		DT_WHT
+    DT_UNKNOWN = 0,
+#define DT_UNKNOWN DT_UNKNOWN
+    DT_FIFO = 1,
+#define DT_FIFO DT_FIFO
+    DT_CHR = 2,
+#define DT_CHR DT_CHR
+    DT_DIR = 4,
+#define DT_DIR DT_DIR
+    DT_BLK = 6,
+#define DT_BLK DT_BLK
+    DT_REG = 8,
+#define DT_REG DT_REG
+    DT_LNK = 10,
+#define DT_LNK DT_LNK
+    DT_SOCK = 12,
+#define DT_SOCK DT_SOCK
+    DT_WHT = 14
+#define DT_WHT DT_WHT
 };
 
 #ifndef _PATH_MOUNTED
- #define _PATH_MOUNTED "/etc/mtab"
+#define _PATH_MOUNTED "/etc/mtab"
 #endif
 #ifndef _PATH_UMOUNT
- #define _PATH_UMOUNT "/sbin/umount"
+#define _PATH_UMOUNT "/sbin/umount"
 #endif
 
 #ifndef O_ASYNC
-  #ifdef FASYNC
-    #define O_ASYNC FASYNC
-  #else
-    #define O_ASYNC 0
-  #endif
+#ifdef FASYNC
+#define O_ASYNC FASYNC
+#else
+#define O_ASYNC 0
 #endif
-
-#ifndef FTW_CONTINUE
-  #define FTW_CONTINUE 0
 #endif
 
-int asprintf(char **string_ptr, const char *format, ...);
-
-int vasprintf (char **result, const char *format, va_list args);
-char* strsep(char** str, const char* delims);
-int solaris_listxattr(const char *path, char *list, size_t size);
-int solaris_removexattr(const char *path, const char* key);
-int solaris_getxattr(const char *path, const char* key,
-                     char *value, size_t size);
-int solaris_setxattr(const char *path, const char* key, const char *value,
-                     size_t size, int flags);
-int solaris_fgetxattr(int fd, const char* key,
-                      char *value, size_t size);
-int solaris_fsetxattr(int fd, const char* key, const char *value,
-                      size_t size, int flags);
-int solaris_flistxattr(int fd, char *list, size_t size);
-
-int solaris_rename (const char *oldpath, const char *newpath);
-
-int solaris_unlink (const char *pathname);
-
-char *mkdtemp (char *temp);
+#ifndef FTW_CONTINUE
+#define FTW_CONTINUE 0
+#endif
+
+int
+asprintf(char **string_ptr, const char *format, ...);
+
+int
+vasprintf(char **result, const char *format, va_list args);
+char *
+strsep(char **str, const char *delims);
+int
+solaris_listxattr(const char *path, char *list, size_t size);
+int
+solaris_removexattr(const char *path, const char *key);
+int
+solaris_getxattr(const char *path, const char *key, char *value, size_t size);
+int
+solaris_setxattr(const char *path, const char *key, const char *value,
+                 size_t size, int flags);
+int
+solaris_fgetxattr(int fd, const char *key, char *value, size_t size);
+int
+solaris_fsetxattr(int fd, const char *key, const char *value, size_t size,
+                  int flags);
+int
+solaris_flistxattr(int fd, char *list, size_t size);
+
+int
+solaris_rename(const char *oldpath, const char *newpath);
+
+int
+solaris_unlink(const char *pathname);
+
+char *
+mkdtemp(char *temp);
 
 #define GF_SOLARIS_XATTR_DIR ".glusterfs_xattr_inode"
 
-int solaris_xattr_resolve_path (const char *real_path, char **path);
+int
+solaris_xattr_resolve_path(const char *real_path, char **path);
 
 #endif /* GF_SOLARIS_HOST_OS */
 
@@ -399,57 +426,57 @@ int solaris_xattr_resolve_path (const char *real_path, char **path);
 #endif /* HAVE_ARGP */
 
 #ifndef HAVE_STRNLEN
-size_t strnlen(const char *string, size_t maxlen);
+size_t
+strnlen(const char *string, size_t maxlen);
 #endif /* STRNLEN */
 
 #ifndef strdupa
-#define strdupa(s)                                                      \
-        (__extension__                                                  \
-         ({                                                             \
-                 __const char *__old = (s);                             \
-                 size_t __len = strlen (__old) + 1;                     \
-                 char *__new = (char *) __builtin_alloca (__len);       \
-                 (char *) memcpy (__new, __old, __len);                 \
-         }))
+#define strdupa(s)                                                             \
+    (__extension__({                                                           \
+        __const char *__old = (s);                                             \
+        size_t __len = strlen(__old) + 1;                                      \
+        char *__new = (char *)__builtin_alloca(__len);                         \
+        (char *)memcpy(__new, __old, __len);                                   \
+    }))
 #endif
 
-#define GF_DIR_ALIGN(x) (((x) + sizeof (uint64_t) - 1) & ~(sizeof (uint64_t) - 1))
+#define GF_DIR_ALIGN(x) (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
 
 #include <sys/types.h>
 #include <dirent.h>
 
 static inline int32_t
-dirent_size (struct dirent *entry)
+dirent_size(struct dirent *entry)
 {
-        int32_t size = -1;
+    int32_t size = -1;
 
 #ifdef GF_BSD_HOST_OS
-        size = GF_DIR_ALIGN (24 /* FIX MEEEE!!! */ + entry->d_namlen);
+    size = GF_DIR_ALIGN(24 /* FIX MEEEE!!! */ + entry->d_namlen);
 #endif
 #ifdef GF_DARWIN_HOST_OS
-        size = GF_DIR_ALIGN (24 /* FIX MEEEE!!! */ + entry->d_namlen);
+    size = GF_DIR_ALIGN(24 /* FIX MEEEE!!! */ + entry->d_namlen);
 #endif
 #ifdef GF_LINUX_HOST_OS
-        size = GF_DIR_ALIGN (24 /* FIX MEEEE!!! */ + entry->d_reclen);
+    size = GF_DIR_ALIGN(24 /* FIX MEEEE!!! */ + entry->d_reclen);
 #endif
 #ifdef GF_SOLARIS_HOST_OS
-        size = GF_DIR_ALIGN (24 /* FIX MEEEE!!! */ + entry->d_reclen);
+    size = GF_DIR_ALIGN(24 /* FIX MEEEE!!! */ + entry->d_reclen);
 #endif
-        return size;
+    return size;
 }
 
 #ifdef THREAD_UNSAFE_BASENAME
-char *basename_r(const char *);
+char *
+basename_r(const char *);
 #define basename(path) basename_r(path)
 #endif /* THREAD_UNSAFE_BASENAME */
 
 #ifdef THREAD_UNSAFE_DIRNAME
-char *dirname_r(char *path);
+char *
+dirname_r(char *path);
 #define dirname(path) dirname_r(path)
 #endif /* THREAD_UNSAFE_DIRNAME */
 
-int gf_mkostemp (char *tmpl, int suffixlen, int flags);
-
 #ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
 /* Linux, Solaris, Cygwin */
 #define ST_ATIM_SEC(stbuf) ((stbuf)->st_atim.tv_sec)
@@ -482,35 +509,33 @@ int gf_mkostemp (char *tmpl, int suffixlen, int flags);
 #define ST_ATIM_NSEC(stbuf) (0)
 #define ST_CTIM_NSEC(stbuf) (0)
 #define ST_MTIM_NSEC(stbuf) (0)
-#define ST_ATIM_NSEC_SET(stbuf, val) do { } while (0);
-#define ST_MTIM_NSEC_SET(stbuf, val) do { } while (0);
-#define ST_CTIM_NSEC_SET(stbuf, val) do { } while (0);
-#endif
-
-#ifndef IXDR_GET_LONG
-#define IXDR_GET_LONG(buf) ((long)IXDR_GET_U_INT32(buf))
-#endif
-
-#ifndef IXDR_PUT_LONG
-#define IXDR_PUT_LONG(buf, v) ((long)IXDR_PUT_INT32(buf, (long)(v)))
+#define ST_ATIM_NSEC_SET(stbuf, val)                                           \
+    do {                                                                       \
+    } while (0);
+#define ST_MTIM_NSEC_SET(stbuf, val)                                           \
+    do {                                                                       \
+    } while (0);
+#define ST_CTIM_NSEC_SET(stbuf, val)                                           \
+    do {                                                                       \
+    } while (0);
 #endif
 
-#ifndef IXDR_GET_U_LONG
-#define IXDR_GET_U_LONG(buf)          ((u_long)IXDR_GET_LONG(buf))
-#endif
-
-#ifndef IXDR_PUT_U_LONG
-#define IXDR_PUT_U_LONG(buf, v)       IXDR_PUT_LONG(buf, (long)(v))
+#ifdef GF_BSD_HOST_OS
+#define CLOCK_REALTIME_COARSE CLOCK_REALTIME
 #endif
 
 #if defined(__GNUC__) && !defined(RELAX_POISONING)
 /* Use run API, see run.h */
 #include <stdlib.h> /* system(), mkostemp() */
-#include <stdio.h> /* popen() */
+#include <stdio.h>  /* popen() */
+#ifdef GF_LINUX_HOST_OS
+#include <sys/sysmacros.h>
+#endif
 #pragma GCC poison system mkostemp popen
 #endif
 
-int gf_umount_lazy(char *xlname, char *path, int rmdir);
+int
+gf_umount_lazy(char *xlname, char *path, int rmdir);
 
 #ifndef GF_XATTR_NAME_MAX
 #error 'Please define GF_XATTR_NAME_MAX for your OS distribution.'
diff --git a/libglusterfs/src/daemon.h b/libglusterfs/src/glusterfs/daemon.h
index 95e134b78b0..48850800b5e 100644
--- a/libglusterfs/src/daemon.h
+++ b/libglusterfs/src/glusterfs/daemon.h
@@ -13,6 +13,8 @@
 
 #define DEVNULLPATH "/dev/null"
 
-int os_daemon_return(int nochdir, int noclose);
-int os_daemon(int nochdir, int noclose);
+int
+os_daemon_return(int nochdir, int noclose);
+int
+os_daemon(int nochdir, int noclose);
 #endif /*_DAEMON_H */
diff --git a/libglusterfs/src/glusterfs/default-args.h b/libglusterfs/src/glusterfs/default-args.h
new file mode 100644
index 00000000000..ca7526fcab6
--- /dev/null
+++ b/libglusterfs/src/glusterfs/default-args.h
@@ -0,0 +1,455 @@
+/*
+  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+/* libglusterfs/src/defaults.h:
+       This file contains definition of default fops and mops functions.
+*/
+
+#ifndef _DEFAULT_ARGS_H
+#define _DEFAULT_ARGS_H
+
+#include "glusterfs/xlator.h"
+
+int
+args_lookup_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, inode_t *inode, struct iatt *buf,
+                      dict_t *xdata, struct iatt *postparent);
+
+int
+args_stat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    struct iatt *buf, dict_t *xdata);
+
+int
+args_fstat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *buf, dict_t *xdata);
+
+int
+args_truncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata);
+
+int
+args_ftruncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata);
+
+int
+args_access_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata);
+
+int
+args_readlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, const char *path, struct iatt *stbuf,
+                        dict_t *xdata);
+
+int
+args_mknod_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata);
+
+int
+args_mkdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata);
+
+int
+args_unlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata);
+
+int
+args_rmdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata);
+
+int
+args_symlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, inode_t *inode, struct iatt *buf,
+                       struct iatt *preparent, struct iatt *postparent,
+                       dict_t *xdata);
+
+int
+args_rename_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *buf,
+                      struct iatt *preoldparent, struct iatt *postoldparent,
+                      struct iatt *prenewparent, struct iatt *postnewparent,
+                      dict_t *xdata);
+
+int
+args_link_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata);
+
+int
+args_create_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, fd_t *fd, inode_t *inode,
+                      struct iatt *buf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata);
+
+int
+args_open_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    fd_t *fd, dict_t *xdata);
+
+int
+args_readv_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iovec *vector, int32_t count, struct iatt *stbuf,
+                     struct iobref *iobref, dict_t *xdata);
+
+int
+args_writev_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata);
+
+int
+args_put_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata);
+
+int
+args_flush_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     dict_t *xdata);
+
+int
+args_fsync_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata);
+
+int
+args_opendir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+int
+args_fsyncdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata);
+
+int
+args_statfs_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct statvfs *buf, dict_t *xdata);
+
+int
+args_setxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata);
+
+int
+args_getxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *dict, dict_t *xdata);
+
+int
+args_fsetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *xdata);
+
+int
+args_fgetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *dict, dict_t *xdata);
+
+int
+args_removexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, dict_t *xdata);
+
+int
+args_fremovexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                            int32_t op_errno, dict_t *xdata);
+
+int
+args_lk_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                  struct gf_flock *lock, dict_t *xdata);
+
+int
+args_inodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata);
+
+int
+args_finodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata);
+
+int
+args_entrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata);
+
+int
+args_fentrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata);
+
+int
+args_readdirp_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
+
+int
+args_readdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, gf_dirent_t *entries, dict_t *xdata);
+
+int
+args_rchecksum_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, uint32_t weak_checksum,
+                         uint8_t *strong_checksum, dict_t *xdata);
+
+int
+args_xattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xattr, dict_t *xdata);
+
+int
+args_fxattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xattr, dict_t *xdata);
+
+int
+args_setattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata);
+
+int
+args_fsetattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata);
+
+int
+args_fallocate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *statpre,
+                         struct iatt *statpost, dict_t *xdata);
+
+int
+args_discard_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata);
+
+int
+args_zerofill_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata);
+
+int
+args_ipc_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   dict_t *xdata);
+
+int
+args_seek_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    off_t offset, dict_t *xdata);
+
+void
+args_lease_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct gf_lease *lease, dict_t *xdata);
+
+int
+args_copy_file_range_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                               int32_t op_errno, struct iatt *stbuf,
+                               struct iatt *prebuf_dst,
+                               struct iatt *postbuf_dst, dict_t *xdata);
+
+void
+args_cbk_wipe(default_args_cbk_t *args_cbk);
+
+void
+args_wipe(default_args_t *args);
+
+int
+args_lookup_store(default_args_t *args, loc_t *loc, dict_t *xdata);
+
+int
+args_stat_store(default_args_t *args, loc_t *loc, dict_t *xdata);
+
+int
+args_fstat_store(default_args_t *args, fd_t *fd, dict_t *xdata);
+
+int
+args_truncate_store(default_args_t *args, loc_t *loc, off_t off, dict_t *xdata);
+int
+args_ftruncate_store(default_args_t *args, fd_t *fd, off_t off, dict_t *xdata);
+
+int
+args_access_store(default_args_t *args, loc_t *loc, int32_t mask,
+                  dict_t *xdata);
+
+int
+args_readlink_store(default_args_t *args, loc_t *loc, size_t size,
+                    dict_t *xdata);
+
+int
+args_mknod_store(default_args_t *args, loc_t *loc, mode_t mode, dev_t rdev,
+                 mode_t umask, dict_t *xdata);
+
+int
+args_mkdir_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+                 dict_t *xdata);
+
+int
+args_unlink_store(default_args_t *args, loc_t *loc, int xflag, dict_t *xdata);
+
+int
+args_rmdir_store(default_args_t *args, loc_t *loc, int flags, dict_t *xdata);
+
+int
+args_symlink_store(default_args_t *args, const char *linkname, loc_t *loc,
+                   mode_t umask, dict_t *xdata);
+
+int
+args_rename_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                  dict_t *xdata);
+
+int
+args_link_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                dict_t *xdata);
+
+int
+args_create_store(default_args_t *args, loc_t *loc, int32_t flags, mode_t mode,
+                  mode_t umask, fd_t *fd, dict_t *xdata);
+
+int
+args_open_store(default_args_t *args, loc_t *loc, int32_t flags, fd_t *fd,
+                dict_t *xdata);
+
+int
+args_readv_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                 uint32_t flags, dict_t *xdata);
+
+int
+args_writev_store(default_args_t *args, fd_t *fd, struct iovec *vector,
+                  int32_t count, off_t off, uint32_t flags,
+                  struct iobref *iobref, dict_t *xdata);
+
+int
+args_put_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+               uint32_t flags, struct iovec *vector, int32_t count, off_t off,
+               struct iobref *iobref, dict_t *xattr, dict_t *xdata);
+
+int
+args_flush_store(default_args_t *args, fd_t *fd, dict_t *xdata);
+
+int
+args_fsync_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                 dict_t *xdata);
+
+int
+args_opendir_store(default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata);
+
+int
+args_fsyncdir_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                    dict_t *xdata);
+
+int
+args_statfs_store(default_args_t *args, loc_t *loc, dict_t *xdata);
+
+int
+args_setxattr_store(default_args_t *args, loc_t *loc, dict_t *dict,
+                    int32_t flags, dict_t *xdata);
+
+int
+args_getxattr_store(default_args_t *args, loc_t *loc, const char *name,
+                    dict_t *xdata);
+
+int
+args_fsetxattr_store(default_args_t *args, fd_t *fd, dict_t *dict,
+                     int32_t flags, dict_t *xdata);
+
+int
+args_fgetxattr_store(default_args_t *args, fd_t *fd, const char *name,
+                     dict_t *xdata);
+
+int
+args_removexattr_store(default_args_t *args, loc_t *loc, const char *name,
+                       dict_t *xdata);
+
+int
+args_fremovexattr_store(default_args_t *args, fd_t *fd, const char *name,
+                        dict_t *xdata);
+
+int
+args_lk_store(default_args_t *args, fd_t *fd, int32_t cmd,
+              struct gf_flock *lock, dict_t *xdata);
+
+int
+args_inodelk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   int32_t cmd, struct gf_flock *lock, dict_t *xdata);
+
+int
+args_finodelk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    int32_t cmd, struct gf_flock *lock, dict_t *xdata);
+
+int
+args_entrylk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   const char *name, entrylk_cmd cmd, entrylk_type type,
+                   dict_t *xdata);
+
+int
+args_fentrylk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    const char *name, entrylk_cmd cmd, entrylk_type type,
+                    dict_t *xdata);
+int
+args_readdirp_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                    dict_t *xdata);
+
+int
+args_readdir_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                   dict_t *xdata);
+
+int
+args_rchecksum_store(default_args_t *args, fd_t *fd, off_t offset, int32_t len,
+                     dict_t *xdata);
+
+int
+args_xattrop_store(default_args_t *args, loc_t *loc, gf_xattrop_flags_t optype,
+                   dict_t *xattr, dict_t *xdata);
+
+int
+args_fxattrop_store(default_args_t *args, fd_t *fd, gf_xattrop_flags_t optype,
+                    dict_t *xattr, dict_t *xdata);
+
+int
+args_setattr_store(default_args_t *args, loc_t *loc, struct iatt *stbuf,
+                   int32_t valid, dict_t *xdata);
+
+int
+args_fsetattr_store(default_args_t *args, fd_t *fd, struct iatt *stbuf,
+                    int32_t valid, dict_t *xdata);
+
+int
+args_fallocate_store(default_args_t *args, fd_t *fd, int32_t mode, off_t offset,
+                     size_t len, dict_t *xdata);
+
+int
+args_discard_store(default_args_t *args, fd_t *fd, off_t offset, size_t len,
+                   dict_t *xdata);
+
+int
+args_zerofill_store(default_args_t *args, fd_t *fd, off_t offset, off_t len,
+                    dict_t *xdata);
+
+int
+args_ipc_store(default_args_t *args, int32_t op, dict_t *xdata);
+
+int
+args_seek_store(default_args_t *args, fd_t *fd, off_t offset,
+                gf_seek_what_t what, dict_t *xdata);
+
+void
+args_lease_store(default_args_t *args, loc_t *loc, struct gf_lease *lease,
+                 dict_t *xdata);
+
+int
+args_getactivelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, lock_migration_info_t *locklist,
+                           dict_t *xdata);
+
+int
+args_setactivelk_store(default_args_t *args, loc_t *loc,
+                       lock_migration_info_t *locklist, dict_t *xdata);
+
+int
+args_icreate_store(default_args_t *args, loc_t *loc, mode_t mode,
+                   dict_t *xdata);
+
+int
+args_namelink_store(default_args_t *args, loc_t *loc, dict_t *xdata);
+
+int
+args_copy_file_range_store(default_args_t *args, fd_t *fd_in, off64_t off_in,
+                           fd_t *fd_out, off_t off64_out, size_t len,
+                           uint32_t flags, dict_t *xdata);
+
+void
+args_cbk_init(default_args_cbk_t *args_cbk);
+#endif /* _DEFAULT_ARGS_H */
diff --git a/libglusterfs/src/glusterfs/defaults.h b/libglusterfs/src/glusterfs/defaults.h
new file mode 100644
index 00000000000..5a818eeb91a
--- /dev/null
+++ b/libglusterfs/src/glusterfs/defaults.h
@@ -0,0 +1,1275 @@
+/*
+  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+/* libglusterfs/src/defaults.h:
+       This file contains definition of default fops and mops functions.
+*/
+
+#ifndef _DEFAULTS_H
+#define _DEFAULTS_H
+
+#include "glusterfs/xlator.h"
+
+typedef struct {
+    int op_ret;
+    int op_errno;
+    inode_t *inode;
+    struct iatt stat;
+    struct iatt prestat;
+    struct iatt poststat;
+    struct iatt preparent;   /* @preoldparent in rename_cbk */
+    struct iatt postparent;  /* @postoldparent in rename_cbk */
+    struct iatt preparent2;  /* @prenewparent in rename_cbk */
+    struct iatt postparent2; /* @postnewparent in rename_cbk */
+    const char *buf;
+    struct iovec *vector;
+    int count;
+    struct iobref *iobref;
+    fd_t *fd;
+    struct statvfs statvfs;
+    dict_t *xattr;
+    struct gf_flock lock;
+    uint32_t weak_checksum;
+    uint8_t *strong_checksum;
+    dict_t *xdata;
+    gf_dirent_t entries;
+    off_t offset; /* seek hole/data */
+    int valid;    /* If the response is valid or not. For call-stub it is
+                     always valid irrespective of this */
+    struct gf_lease lease;
+    lock_migration_info_t locklist;
+} default_args_cbk_t;
+
+typedef struct {
+    loc_t loc;    /* @old in rename(), link() */
+    loc_t loc2;   /* @new in rename(), link() */
+    fd_t *fd;     /* for all the fd based ops */
+    fd_t *fd_dst; /* Only for copy_file_range destination */
+    off_t offset;
+    /*
+     * According to the man page of copy_file_range,
+     * the offsets for source and destination file
+     * are of type loff_t. But the type loff_t is
+     * linux specific and is actual a typedef of
+     * off64_t.
+     */
+    off64_t off_in;  /* For copy_file_range source fd */
+    off64_t off_out; /* For copy_file_range destination fd only */
+    int mask;
+    size_t size;
+    mode_t mode;
+    dev_t rdev;
+    mode_t umask;
+    int xflag;
+    int flags;
+    const char *linkname;
+    struct iovec *vector;
+    int count;
+    struct iobref *iobref;
+    int datasync;
+    dict_t *xattr;
+    const char *name;
+    int cmd;
+    struct gf_flock lock;
+    const char *volume;
+    entrylk_cmd entrylkcmd;
+    entrylk_type entrylktype;
+    gf_xattrop_flags_t optype;
+    int valid;
+    struct iatt stat;
+    gf_seek_what_t what;
+    dict_t *xdata;
+    struct gf_lease lease;
+    lock_migration_info_t locklist;
+} default_args_t;
+
+typedef struct {
+    int fop_enum;
+    unsigned int fop_length;
+    int *enum_list;
+    default_args_t *req_list;
+    dict_t *xdata;
+} compound_args_t;
+
+typedef struct {
+    int fop_enum;
+    unsigned int fop_length;
+    int *enum_list;
+    default_args_cbk_t *rsp_list;
+    dict_t *xdata;
+} compound_args_cbk_t;
+
+int32_t
+default_notify(xlator_t *this, int32_t event, void *data, ...);
+
+int32_t
+default_forget(xlator_t *this, inode_t *inode);
+
+int32_t
+default_release(xlator_t *this, fd_t *fd);
+
+int32_t
+default_releasedir(xlator_t *this, fd_t *fd);
+
+extern struct xlator_fops *default_fops;
+
+/* Management Operations */
+
+int32_t
+default_getspec(call_frame_t *frame, xlator_t *this, const char *key,
+                int32_t flag);
+
+int32_t
+default_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  int32_t len, dict_t *xdata);
+
+/* FileSystem operations */
+int32_t
+default_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+
+int32_t
+default_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+
+int32_t
+default_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                 dict_t *xdata);
+
+int32_t
+default_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  dict_t *xdata);
+
+int32_t
+default_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+               dict_t *xdata);
+
+int32_t
+default_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                 dict_t *xdata);
+
+int32_t
+default_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              dev_t rdev, mode_t umask, dict_t *xdata);
+
+int32_t
+default_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              mode_t umask, dict_t *xdata);
+
+int32_t
+default_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+               dict_t *xdata);
+
+int32_t
+default_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+              dict_t *xdata);
+
+int32_t
+default_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+                loc_t *loc, mode_t umask, dict_t *xdata);
+
+int32_t
+default_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+               loc_t *newloc, dict_t *xdata);
+
+int32_t
+default_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata);
+
+int32_t
+default_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+               mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             fd_t *fd, dict_t *xdata);
+
+int32_t
+default_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+              off_t offset, uint32_t flags, dict_t *xdata);
+
+int32_t
+default_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
+               struct iovec *vector, int32_t count, off_t offset,
+               uint32_t flags, struct iobref *iobref, dict_t *xdata);
+
+int32_t
+default_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+              dict_t *xdata);
+
+int32_t
+default_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                dict_t *xdata);
+
+int32_t
+default_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 int32_t datasync, dict_t *xdata);
+
+int32_t
+default_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+
+int32_t
+default_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                 int32_t flags, dict_t *xdata);
+
+int32_t
+default_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 const char *name, dict_t *xdata);
+
+int32_t
+default_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+                  int32_t flags, dict_t *xdata);
+
+int32_t
+default_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                  const char *name, dict_t *xdata);
+
+int32_t
+default_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    const char *name, dict_t *xdata);
+
+int32_t
+default_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     const char *name, dict_t *xdata);
+
+int32_t
+default_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+           struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+default_inodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+                loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+default_finodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+                 fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+default_entrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+                loc_t *loc, const char *basename, entrylk_cmd cmd,
+                entrylk_type type, dict_t *xdata);
+
+int32_t
+default_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+                 fd_t *fd, const char *basename, entrylk_cmd cmd,
+                 entrylk_type type, dict_t *xdata);
+
+int32_t
+default_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t off, dict_t *xdata);
+
+int32_t
+default_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata);
+
+int32_t
+default_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+default_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+default_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+int32_t
+default_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+int32_t
+default_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                  int32_t keep_size, off_t offset, size_t len, dict_t *xdata);
+
+int32_t
+default_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                size_t len, dict_t *xdata);
+
+int32_t
+default_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                 off_t len, dict_t *xdata);
+
+int32_t
+default_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata);
+
+int32_t
+default_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             gf_seek_what_t what, dict_t *xdata);
+
+int32_t
+default_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+              struct gf_lease *lease, dict_t *xdata);
+
+int32_t
+default_getactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    dict_t *xdata);
+
+int32_t
+default_setactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    lock_migration_info_t *locklist, dict_t *xdata);
+
+int32_t
+default_put(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+            off_t off, struct iobref *iobref, dict_t *xattr, dict_t *xdata);
+
+int32_t
+default_icreate(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                dict_t *xdata);
+
+int32_t
+default_namelink(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 dict_t *xdata);
+
+int32_t
+default_copy_file_range(call_frame_t *frame, xlator_t *this, fd_t *fd_in,
+                        off64_t off_in, fd_t *fd_out, off64_t off_out,
+                        size_t len, uint32_t flags, dict_t *xdata);
+
+/* Resume */
+int32_t
+default_getspec_resume(call_frame_t *frame, xlator_t *this, const char *key,
+                       int32_t flag);
+
+int32_t
+default_rchecksum_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         off_t offset, int32_t len, dict_t *xdata);
+
+/* FileSystem operations */
+int32_t
+default_lookup_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      dict_t *xdata);
+
+int32_t
+default_stat_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    dict_t *xdata);
+
+int32_t
+default_fstat_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     dict_t *xdata);
+
+int32_t
+default_truncate_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        off_t offset, dict_t *xdata);
+
+int32_t
+default_ftruncate_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         off_t offset, dict_t *xdata);
+
+int32_t
+default_access_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      int32_t mask, dict_t *xdata);
+
+int32_t
+default_readlink_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        size_t size, dict_t *xdata);
+
+int32_t
+default_mknod_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                     mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata);
+
+int32_t
+default_mkdir_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                     mode_t mode, mode_t umask, dict_t *xdata);
+
+int32_t
+default_unlink_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      int xflag, dict_t *xdata);
+
+int32_t
+default_rmdir_resume(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+                     dict_t *xdata);
+
+int32_t
+default_symlink_resume(call_frame_t *frame, xlator_t *this,
+                       const char *linkpath, loc_t *loc, mode_t umask,
+                       dict_t *xdata);
+
+int32_t
+default_rename_resume(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+                      loc_t *newloc, dict_t *xdata);
+
+int32_t
+default_link_resume(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+                    loc_t *newloc, dict_t *xdata);
+
+int32_t
+default_create_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      int32_t flags, mode_t mode, mode_t umask, fd_t *fd,
+                      dict_t *xdata);
+
+int32_t
+default_open_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    int32_t flags, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_readv_resume(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                     off_t offset, uint32_t flags, dict_t *xdata);
+
+int32_t
+default_writev_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                      struct iovec *vector, int32_t count, off_t offset,
+                      uint32_t flags, struct iobref *iobref, dict_t *xdata);
+
+int32_t
+default_flush_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     dict_t *xdata);
+
+int32_t
+default_fsync_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     int32_t datasync, dict_t *xdata);
+
+int32_t
+default_opendir_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       fd_t *fd, dict_t *xdata);
+
+int32_t
+default_fsyncdir_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        int32_t datasync, dict_t *xdata);
+
+int32_t
+default_statfs_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      dict_t *xdata);
+
+int32_t
+default_setxattr_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        dict_t *dict, int32_t flags, dict_t *xdata);
+
+int32_t
+default_getxattr_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        const char *name, dict_t *xdata);
+
+int32_t
+default_fsetxattr_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         dict_t *dict, int32_t flags, dict_t *xdata);
+
+int32_t
+default_fgetxattr_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         const char *name, dict_t *xdata);
+
+int32_t
+default_removexattr_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                           const char *name, dict_t *xdata);
+
+int32_t
+default_fremovexattr_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            const char *name, dict_t *xdata);
+
+int32_t
+default_lk_resume(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+                  struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+default_inodelk_resume(call_frame_t *frame, xlator_t *this, const char *volume,
+                       loc_t *loc, int32_t cmd, struct gf_flock *flock,
+                       dict_t *xdata);
+
+int32_t
+default_finodelk_resume(call_frame_t *frame, xlator_t *this, const char *volume,
+                        fd_t *fd, int32_t cmd, struct gf_flock *flock,
+                        dict_t *xdata);
+
+int32_t
+default_entrylk_resume(call_frame_t *frame, xlator_t *this, const char *volume,
+                       loc_t *loc, const char *basename, entrylk_cmd cmd,
+                       entrylk_type type, dict_t *xdata);
+
+int32_t
+default_fentrylk_resume(call_frame_t *frame, xlator_t *this, const char *volume,
+                        fd_t *fd, const char *basename, entrylk_cmd cmd,
+                        entrylk_type type, dict_t *xdata);
+
+int32_t
+default_readdir_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                       size_t size, off_t off, dict_t *xdata);
+
+int32_t
+default_readdirp_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        size_t size, off_t off, dict_t *xdata);
+
+int32_t
+default_xattrop_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+default_fxattrop_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+int32_t
+default_rchecksum_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         off_t offset, int32_t len, dict_t *xdata);
+
+int32_t
+default_setattr_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+int32_t
+default_fsetattr_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        struct iatt *stbuf, int32_t valid, dict_t *xdata);
+
+int32_t
+default_fallocate_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                         int32_t keep_size, off_t offset, size_t len,
+                         dict_t *xdata);
+
+int32_t
+default_discard_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                       off_t offset, size_t len, dict_t *xdata);
+
+int32_t
+default_zerofill_resume(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        off_t offset, off_t len, dict_t *xdata);
+
+int32_t
+default_ipc_resume(call_frame_t *frame, xlator_t *this, int32_t op,
+                   dict_t *xdata);
+
+int32_t
+default_seek_resume(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                    gf_seek_what_t what, dict_t *xdata);
+
+int32_t
+default_lease_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                     struct gf_lease *lease, dict_t *xdata);
+
+int32_t
+default_getactivelk_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                           dict_t *xdata);
+
+int32_t
+default_setactivelk_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                           lock_migration_info_t *locklist, dict_t *xdata);
+
+int32_t
+default_put_resume(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                   mode_t umask, uint32_t flags, struct iovec *vector,
+                   int32_t count, off_t off, struct iobref *iobref,
+                   dict_t *xattr, dict_t *xdata);
+
+int32_t
+default_copy_file_range_resume(call_frame_t *frame, xlator_t *this, fd_t *fd_in,
+                               off_t off64_in, fd_t *fd_out, off64_t off_out,
+                               size_t len, uint32_t flags, dict_t *xdata);
+
+/* _cbk_resume */
+
+int32_t
+default_lookup_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xdata,
+                          struct iatt *postparent);
+
+int32_t
+default_stat_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                        dict_t *xdata);
+
+int32_t
+default_truncate_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            struct iatt *prebuf, struct iatt *postbuf,
+                            dict_t *xdata);
+
+int32_t
+default_ftruncate_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno,
+                             struct iatt *prebuf, struct iatt *postbuf,
+                             dict_t *xdata);
+
+int32_t
+default_access_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_readlink_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, const char *path,
+                            struct iatt *buf, dict_t *xdata);
+
+int32_t
+default_mknod_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, inode_t *inode,
+                         struct iatt *buf, struct iatt *preparent,
+                         struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_mkdir_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, inode_t *inode,
+                         struct iatt *buf, struct iatt *preparent,
+                         struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_unlink_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno,
+                          struct iatt *preparent, struct iatt *postparent,
+                          dict_t *xdata);
+
+int32_t
+default_rmdir_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno,
+                         struct iatt *preparent, struct iatt *postparent,
+                         dict_t *xdata);
+
+int32_t
+default_symlink_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, inode_t *inode,
+                           struct iatt *buf, struct iatt *preparent,
+                           struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_rename_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                          struct iatt *preoldparent, struct iatt *postoldparent,
+                          struct iatt *prenewparent, struct iatt *postnewparent,
+                          dict_t *xdata);
+
+int32_t
+default_link_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, inode_t *inode,
+                        struct iatt *buf, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_create_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, fd_t *fd,
+                          inode_t *inode, struct iatt *buf,
+                          struct iatt *preparent, struct iatt *postparent,
+                          dict_t *xdata);
+
+int32_t
+default_open_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, fd_t *fd,
+                        dict_t *xdata);
+
+int32_t
+default_readv_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                         int32_t count, struct iatt *stbuf,
+                         struct iobref *iobref, dict_t *xdata);
+
+int32_t
+default_writev_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                          struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_flush_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fsync_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_fstat_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                         dict_t *xdata);
+
+int32_t
+default_opendir_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, fd_t *fd,
+                           dict_t *xdata);
+
+int32_t
+default_fsyncdir_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_statfs_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                          dict_t *xdata);
+
+int32_t
+default_setxattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fsetxattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fgetxattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, dict_t *dict,
+                             dict_t *xdata);
+
+int32_t
+default_getxattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *dict,
+                            dict_t *xdata);
+
+int32_t
+default_xattrop_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata);
+
+int32_t
+default_fxattrop_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *dict,
+                            dict_t *xdata);
+
+int32_t
+default_removexattr_cbk_resume(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               dict_t *xdata);
+
+int32_t
+default_fremovexattr_cbk_resume(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_lk_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                      dict_t *xdata);
+
+int32_t
+default_inodelk_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_finodelk_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_entrylk_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fentrylk_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_rchecksum_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno,
+                             uint32_t weak_checksum, uint8_t *strong_checksum,
+                             dict_t *xdata);
+
+int32_t
+default_readdir_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno,
+                           gf_dirent_t *entries, dict_t *xdata);
+
+int32_t
+default_readdirp_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            gf_dirent_t *entries, dict_t *xdata);
+
+int32_t
+default_setattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno,
+                           struct iatt *statpre, struct iatt *statpost,
+                           dict_t *xdata);
+
+int32_t
+default_fsetattr_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            struct iatt *statpre, struct iatt *statpost,
+                            dict_t *xdata);
+
+int32_t
+default_fallocate_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                             struct iatt *post, dict_t *xdata);
+
+int32_t
+default_discard_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                           struct iatt *post, dict_t *xdata);
+
+int32_t
+default_zerofill_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                            struct iatt *post, dict_t *xdata);
+int32_t
+default_ipc_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_seek_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, off_t offset,
+                        dict_t *xdata);
+
+int32_t
+default_getspec_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, char *spec_data);
+
+int32_t
+default_lease_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno,
+                         struct gf_lease *lease, dict_t *xdata);
+
+int32_t
+default_getactivelk_cbk_resume(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               lock_migration_info_t *locklist, dict_t *xdata);
+
+int32_t
+default_setactivelk_cbk_resume(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               dict_t *xdata);
+
+int32_t
+default_put_cbk_resume(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, inode_t *inode,
+                       struct iatt *buf, struct iatt *preparent,
+                       struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_icreate_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       mode_t mode, dict_t *xdata);
+
+int32_t
+default_namelink_resume(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        dict_t *xdata);
+
+int32_t
+default_copy_file_range_cbk_resume(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iatt *stbuf,
+                                   struct iatt *prebuf_dst,
+                                   struct iatt *postbuf_dst, dict_t *xdata);
+
+/* _CBK */
+int32_t
+default_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, dict_t *xdata, struct iatt *postparent);
+
+int32_t
+default_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata);
+
+int32_t
+default_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, const char *path,
+                     struct iatt *buf, dict_t *xdata);
+
+int32_t
+default_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata);
+
+int32_t
+default_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                  dict_t *xdata);
+
+int32_t
+default_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  dict_t *xdata);
+
+int32_t
+default_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+int32_t
+default_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                   dict_t *xdata);
+
+int32_t
+default_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata);
+
+int32_t
+default_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata);
+
+int32_t
+default_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata);
+
+int32_t
+default_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata);
+
+int32_t
+default_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+               dict_t *xdata);
+
+int32_t
+default_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                      uint8_t *strong_checksum, dict_t *xdata);
+
+int32_t
+default_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata);
+
+int32_t
+default_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                     dict_t *xdata);
+
+int32_t
+default_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                    struct iatt *statpost, dict_t *xdata);
+
+int32_t
+default_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata);
+
+int32_t
+default_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                      struct iatt *post, dict_t *xdata);
+
+int32_t
+default_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                    struct iatt *post, dict_t *xdata);
+
+int32_t
+default_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                     struct iatt *post, dict_t *xdata);
+
+int32_t
+default_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata);
+
+int32_t
+default_getspec_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, char *spec_data);
+
+int32_t
+default_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
+                  dict_t *xdata);
+
+int32_t
+default_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        lock_migration_info_t *locklist, dict_t *xdata);
+
+int32_t
+default_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int32_t
+default_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata);
+
+int32_t
+default_icreate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, dict_t *xdata);
+
+int32_t
+default_namelink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata);
+
+int32_t
+default_copy_file_range_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            struct iatt *stbuf, struct iatt *prebuf_dst,
+                            struct iatt *postbuf_dst, dict_t *xdata);
+
+int32_t
+default_lookup_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_stat_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_truncate_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_ftruncate_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_access_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_readlink_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_mknod_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_mkdir_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_unlink_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_rmdir_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_symlink_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_rename_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_link_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_create_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_open_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_readv_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_writev_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_flush_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fsync_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fstat_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_opendir_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fsyncdir_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_statfs_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_setxattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fsetxattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fgetxattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_getxattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_xattrop_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fxattrop_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_removexattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fremovexattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_lk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_inodelk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_finodelk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_entrylk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fentrylk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_rchecksum_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_readdir_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_readdirp_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_setattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fsetattr_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_fallocate_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_discard_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_zerofill_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_getspec_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_ipc_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_seek_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_lease_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_getactivelk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_setactivelk_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_put_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_icreate_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_namelink_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_copy_file_range_failure_cbk(call_frame_t *frame, int32_t op_errno);
+
+int32_t
+default_mem_acct_init(xlator_t *this);
+
+void
+default_fini(xlator_t *this);
+
+#endif /* _DEFAULTS_H */
diff --git a/libglusterfs/src/glusterfs/dict.h b/libglusterfs/src/glusterfs/dict.h
new file mode 100644
index 00000000000..d0467c6dfb6
--- /dev/null
+++ b/libglusterfs/src/glusterfs/dict.h
@@ -0,0 +1,420 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _DICT_H
+#define _DICT_H
+
+#include <inttypes.h>
+#include <sys/uio.h>
+#include <pthread.h>
+
+#include "glusterfs/common-utils.h"
+
+typedef struct _data data_t;
+typedef struct _dict dict_t;
+typedef struct _data_pair data_pair_t;
+
+#define dict_set_sizen(this, key, value) dict_setn(this, key, SLEN(key), value)
+
+#define dict_add_sizen(this, key, value) dict_addn(this, key, SLEN(key), value)
+
+#define dict_get_sizen(this, key) dict_getn(this, key, SLEN(key))
+
+#define dict_del_sizen(this, key) dict_deln(this, key, SLEN(key))
+
+#define dict_set_str_sizen(this, key, str)                                     \
+    dict_set_strn(this, key, SLEN(key), str)
+
+#define dict_set_sizen_str_sizen(this, key, str)                               \
+    dict_set_nstrn(this, key, SLEN(key), str, SLEN(str))
+
+#define dict_set_dynstr_sizen(this, key, str)                                  \
+    dict_set_dynstrn(this, key, SLEN(key), str)
+
+#define dict_get_str_sizen(this, key, str)                                     \
+    dict_get_strn(this, key, SLEN(key), str)
+
+#define dict_get_int32_sizen(this, key, val)                                   \
+    dict_get_int32n(this, key, SLEN(key), val)
+
+#define dict_set_int32_sizen(this, key, val)                                   \
+    dict_set_int32n(this, key, SLEN(key), val)
+
+#define GF_PROTOCOL_DICT_SERIALIZE(this, from_dict, to, len, ope, labl)        \
+    do {                                                                       \
+        int _ret = 0;                                                          \
+                                                                               \
+        if (!from_dict)                                                        \
+            break;                                                             \
+                                                                               \
+        _ret = dict_allocate_and_serialize(from_dict, to, &len);               \
+        if (_ret < 0) {                                                        \
+            gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_DICT_SERIAL_FAILED,   \
+                   "failed to get serialized dict (%s)", (#from_dict));        \
+            ope = EINVAL;                                                      \
+            goto labl;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define GF_PROTOCOL_DICT_UNSERIALIZE(xl, to, buff, len, ret, ope, labl)        \
+    do {                                                                       \
+        if (!len)                                                              \
+            break;                                                             \
+        to = dict_new();                                                       \
+        GF_VALIDATE_OR_GOTO(xl->name, to, labl);                               \
+                                                                               \
+        ret = dict_unserialize(buff, len, &to);                                \
+        if (ret < 0) {                                                         \
+            gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_DICT_UNSERIAL_FAILED,   \
+                   "failed to unserialize dictionary (%s)", (#to));            \
+                                                                               \
+            ope = EINVAL;                                                      \
+            goto labl;                                                         \
+        }                                                                      \
+                                                                               \
+    } while (0)
+
+#define dict_foreach_inline(d, c) for (c = d->members_list; c; c = c->next)
+
+#define DICT_KEY_VALUE_MAX_SIZE 1048576
+#define DICT_MAX_FLAGS 256
+#define DICT_FLAG_SET 1
+#define DICT_FLAG_CLEAR 0
+#define DICT_HDR_LEN 4
+#define DICT_DATA_HDR_KEY_LEN 4
+#define DICT_DATA_HDR_VAL_LEN 4
+
+struct _data {
+    char *data;
+    gf_atomic_t refcount;
+    gf_dict_data_type_t data_type;
+    uint32_t len;
+    gf_boolean_t is_static;
+};
+
+struct _data_pair {
+    struct _data_pair *hash_next;
+    struct _data_pair *prev;
+    struct _data_pair *next;
+    data_t *value;
+    char *key;
+    uint32_t key_hash;
+};
+
+struct _dict {
+    uint64_t max_count;
+    int32_t hash_size;
+    int32_t count;
+    gf_atomic_t refcount;
+    data_pair_t **members;
+    data_pair_t *members_list;
+    char *extra_stdfree;
+    gf_lock_t lock;
+    data_pair_t *members_internal;
+    data_pair_t free_pair;
+    /* Variable to store total keylen + value->len */
+    uint32_t totkvlen;
+};
+
+typedef gf_boolean_t (*dict_match_t)(dict_t *d, char *k, data_t *v, void *data);
+
+int32_t
+is_data_equal(data_t *one, data_t *two);
+void
+data_destroy(data_t *data);
+
+/* function to set a key/value pair (overwrite existing if matches the key */
+int32_t
+dict_set(dict_t *this, char *key, data_t *value);
+int32_t
+dict_setn(dict_t *this, char *key, const int keylen, data_t *value);
+
+/* function to set a new key/value pair (without checking for duplicate) */
+int32_t
+dict_add(dict_t *this, char *key, data_t *value);
+int32_t
+dict_addn(dict_t *this, char *key, const int keylen, data_t *value);
+int
+dict_get_with_ref(dict_t *this, char *key, data_t **data);
+data_t *
+dict_get(dict_t *this, char *key);
+data_t *
+dict_getn(dict_t *this, char *key, const int keylen);
+void
+dict_del(dict_t *this, char *key);
+void
+dict_deln(dict_t *this, char *key, const int keylen);
+int
+dict_reset(dict_t *dict);
+
+int
+dict_key_count(dict_t *this);
+
+int32_t
+dict_serialized_length(dict_t *dict);
+int32_t
+dict_serialize(dict_t *dict, char *buf);
+int32_t
+dict_unserialize(char *buf, int32_t size, dict_t **fill);
+
+int32_t
+dict_allocate_and_serialize(dict_t *this, char **buf, u_int *length);
+
+void
+dict_unref(dict_t *dict);
+dict_t *
+dict_ref(dict_t *dict);
+data_t *
+data_ref(data_t *data);
+void
+data_unref(data_t *data);
+
+int32_t
+dict_lookup(dict_t *this, char *key, data_t **data);
+/*
+   TODO: provide converts for different byte sizes, signedness, and void *
+ */
+data_t *
+int_to_data(int64_t value);
+data_t *
+str_to_data(char *value);
+data_t *
+strn_to_data(char *value, const int vallen);
+data_t *
+data_from_dynptr(void *value, int32_t len);
+data_t *
+bin_to_data(void *value, int32_t len);
+data_t *
+static_str_to_data(char *value);
+data_t *
+static_bin_to_data(void *value);
+
+int64_t
+data_to_int64(data_t *data);
+int32_t
+data_to_int32(data_t *data);
+int16_t
+data_to_int16(data_t *data);
+int8_t
+data_to_int8(data_t *data);
+
+uint64_t
+data_to_uint64(data_t *data);
+uint32_t
+data_to_uint32(data_t *data);
+uint16_t
+data_to_uint16(data_t *data);
+uint8_t
+data_to_uint8(data_t *data);
+
+data_t *
+data_from_int64(int64_t value);
+data_t *
+data_from_int32(int32_t value);
+data_t *
+data_from_int16(int16_t value);
+data_t *
+data_from_int8(int8_t value);
+
+data_t *
+data_from_uint64(uint64_t value);
+data_t *
+data_from_uint32(uint32_t value);
+data_t *
+data_from_uint16(uint16_t value);
+
+char *
+data_to_str(data_t *data);
+void *
+data_to_bin(data_t *data);
+void *
+data_to_ptr(data_t *data);
+data_t *
+data_copy(data_t *old);
+struct iatt *
+data_to_iatt(data_t *data, char *key);
+
+int
+dict_foreach(dict_t *this,
+             int (*fn)(dict_t *this, char *key, data_t *value, void *data),
+             void *data);
+
+int
+dict_foreach_fnmatch(dict_t *dict, char *pattern,
+                     int (*fn)(dict_t *this, char *key, data_t *value,
+                               void *data),
+                     void *data);
+
+int
+dict_foreach_match(dict_t *dict,
+                   gf_boolean_t (*match)(dict_t *this, char *key, data_t *value,
+                                         void *mdata),
+                   void *match_data,
+                   int (*action)(dict_t *this, char *key, data_t *value,
+                                 void *adata),
+                   void *action_data);
+
+int
+dict_null_foreach_fn(dict_t *d, char *k, data_t *v, void *tmp);
+int
+dict_remove_foreach_fn(dict_t *d, char *k, data_t *v, void *tmp);
+dict_t *
+dict_copy(dict_t *this, dict_t *new);
+int
+dict_keys_join(void *value, int size, dict_t *dict,
+               int (*filter_fn)(char *key));
+
+/* CLEANED UP FUNCTIONS DECLARATIONS */
+GF_MUST_CHECK dict_t *
+dict_new(void);
+dict_t *
+dict_copy_with_ref(dict_t *this, dict_t *new);
+
+GF_MUST_CHECK int
+dict_reset(dict_t *dict);
+
+GF_MUST_CHECK int
+dict_get_int8(dict_t *this, char *key, int8_t *val);
+GF_MUST_CHECK int
+dict_set_int8(dict_t *this, char *key, int8_t val);
+
+GF_MUST_CHECK int
+dict_get_int16(dict_t *this, char *key, int16_t *val);
+GF_MUST_CHECK int
+dict_set_int16(dict_t *this, char *key, int16_t val);
+
+GF_MUST_CHECK int
+dict_get_int32(dict_t *this, char *key, int32_t *val);
+GF_MUST_CHECK int
+dict_get_int32n(dict_t *this, char *key, const int keylen, int32_t *val);
+GF_MUST_CHECK int
+dict_set_int32(dict_t *this, char *key, int32_t val);
+GF_MUST_CHECK int
+dict_set_int32n(dict_t *this, char *key, const int keylen, int32_t val);
+
+GF_MUST_CHECK int
+dict_get_int64(dict_t *this, char *key, int64_t *val);
+GF_MUST_CHECK int
+dict_set_int64(dict_t *this, char *key, int64_t val);
+
+GF_MUST_CHECK int
+dict_get_uint16(dict_t *this, char *key, uint16_t *val);
+GF_MUST_CHECK int
+dict_set_uint16(dict_t *this, char *key, uint16_t val);
+
+GF_MUST_CHECK int
+dict_get_uint32(dict_t *this, char *key, uint32_t *val);
+GF_MUST_CHECK int
+dict_set_uint32(dict_t *this, char *key, uint32_t val);
+
+GF_MUST_CHECK int
+dict_get_uint64(dict_t *this, char *key, uint64_t *val);
+GF_MUST_CHECK int
+dict_set_uint64(dict_t *this, char *key, uint64_t val);
+
+GF_MUST_CHECK int
+dict_check_flag(dict_t *this, char *key, int flag);
+GF_MUST_CHECK int
+dict_set_flag(dict_t *this, char *key, int flag);
+GF_MUST_CHECK int
+dict_clear_flag(dict_t *this, char *key, int flag);
+
+GF_MUST_CHECK int
+dict_get_double(dict_t *this, char *key, double *val);
+GF_MUST_CHECK int
+dict_set_double(dict_t *this, char *key, double val);
+
+GF_MUST_CHECK int
+dict_set_static_ptr(dict_t *this, char *key, void *ptr);
+GF_MUST_CHECK int
+dict_get_ptr(dict_t *this, char *key, void **ptr);
+GF_MUST_CHECK int
+dict_get_ptr_and_len(dict_t *this, char *key, void **ptr, int *len);
+GF_MUST_CHECK int
+dict_set_dynptr(dict_t *this, char *key, void *ptr, size_t size);
+
+GF_MUST_CHECK int
+dict_get_bin(dict_t *this, char *key, void **ptr);
+GF_MUST_CHECK int
+dict_set_bin(dict_t *this, char *key, void *ptr, size_t size);
+GF_MUST_CHECK int
+dict_set_static_bin(dict_t *this, char *key, void *ptr, size_t size);
+
+GF_MUST_CHECK int
+dict_set_option(dict_t *this, char *key, char *str);
+GF_MUST_CHECK int
+dict_set_str(dict_t *this, char *key, char *str);
+GF_MUST_CHECK int
+dict_set_strn(dict_t *this, char *key, const int keylen, char *str);
+GF_MUST_CHECK int
+dict_set_nstrn(dict_t *this, char *key, const int keylen, char *str,
+               const int vallen);
+GF_MUST_CHECK int
+dict_set_dynstr(dict_t *this, char *key, char *str);
+GF_MUST_CHECK int
+dict_set_dynstrn(dict_t *this, char *key, const int keylen, char *str);
+GF_MUST_CHECK int
+dict_set_dynstr_with_alloc(dict_t *this, char *key, const char *str);
+GF_MUST_CHECK int
+dict_add_dynstr_with_alloc(dict_t *this, char *key, char *str);
+GF_MUST_CHECK int
+dict_get_str(dict_t *this, char *key, char **str);
+GF_MUST_CHECK int
+dict_get_strn(dict_t *this, char *key, const int keylen, char **str);
+
+GF_MUST_CHECK int
+dict_get_str_boolean(dict_t *this, char *key, int default_val);
+GF_MUST_CHECK int
+dict_rename_key(dict_t *this, char *key, char *replace_key);
+GF_MUST_CHECK int
+dict_serialize_value_with_delim(dict_t *this, char *buf, int32_t *serz_len,
+                                char delimiter);
+
+GF_MUST_CHECK int
+dict_set_gfuuid(dict_t *this, char *key, uuid_t uuid, bool is_static);
+GF_MUST_CHECK int
+dict_get_gfuuid(dict_t *this, char *key, uuid_t *uuid);
+
+GF_MUST_CHECK int
+dict_set_iatt(dict_t *this, char *key, struct iatt *iatt, bool is_static);
+GF_MUST_CHECK int
+dict_get_iatt(dict_t *this, char *key, struct iatt *iatt);
+GF_MUST_CHECK int
+dict_set_mdata(dict_t *this, char *key, struct mdata_iatt *mdata,
+               bool is_static);
+GF_MUST_CHECK int
+dict_get_mdata(dict_t *this, char *key, struct mdata_iatt *mdata);
+
+void
+dict_dump_to_statedump(dict_t *dict, char *dict_name, char *domain);
+
+void
+dict_dump_to_log(dict_t *dict);
+
+int
+dict_dump_to_str(dict_t *dict, char *dump, int dumpsize, char *format);
+gf_boolean_t
+dict_match_everything(dict_t *d, char *k, data_t *v, void *data);
+
+dict_t *
+dict_for_key_value(const char *name, const char *value, size_t size,
+                   gf_boolean_t is_static);
+
+gf_boolean_t
+are_dicts_equal(dict_t *one, dict_t *two,
+                gf_boolean_t (*match)(dict_t *d, char *k, data_t *v,
+                                      void *data),
+                gf_boolean_t (*value_ignore)(char *k));
+int
+dict_has_key_from_array(dict_t *dict, char **strings, gf_boolean_t *result);
+
+int
+dict_serialized_length_lk(dict_t *this);
+#endif
diff --git a/libglusterfs/src/glusterfs/event-history.h b/libglusterfs/src/glusterfs/event-history.h
new file mode 100644
index 00000000000..f0e0422418e
--- /dev/null
+++ b/libglusterfs/src/glusterfs/event-history.h
@@ -0,0 +1,40 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _EH_H
+#define _EH_H
+
+#include <pthread.h>              // for pthread_mutex_t
+#include <stddef.h>               // for size_t
+#include "glusterfs/circ-buff.h"  // for buffer_t, circular_buffer_t
+#include "glusterfs/glusterfs.h"  // for gf_boolean_t
+
+struct event_hist {
+    buffer_t *buffer;
+    pthread_mutex_t lock;
+};
+
+typedef struct event_hist eh_t;
+
+void
+eh_dump(eh_t *event, void *data,
+        int(fn)(circular_buffer_t *buffer, void *data));
+
+eh_t *
+eh_new(size_t buffer_size, gf_boolean_t use_buffer_once,
+       void (*destroy_data)(void *data));
+
+int
+eh_save_history(eh_t *history, void *string);
+
+int
+eh_destroy(eh_t *history);
+
+#endif /* _EH_H */
diff --git a/libglusterfs/src/glusterfs/events.h b/libglusterfs/src/glusterfs/events.h
new file mode 100644
index 00000000000..74c5326427b
--- /dev/null
+++ b/libglusterfs/src/glusterfs/events.h
@@ -0,0 +1,34 @@
+/*
+  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __EVENTS_H__
+#define __EVENTS_H__
+
+#include "eventtypes.h"
+
+#ifdef USE_EVENTS
+int
+_gf_event(eventtypes_t event, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+#else
+__attribute__((__format__(__printf__, 2, 3))) static inline int
+_gf_event(eventtypes_t event, const char *fmt, ...)
+{
+    return 0;
+}
+#endif /* USE_EVENTS */
+
+#define gf_event(event, fmt...)                                                \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+        _gf_event(event, ##fmt);                                               \
+    } while (0)
+
+#endif /* __EVENTS_H__ */
diff --git a/libglusterfs/src/glusterfs/fd-lk.h b/libglusterfs/src/glusterfs/fd-lk.h
new file mode 100644
index 00000000000..76cc680306a
--- /dev/null
+++ b/libglusterfs/src/glusterfs/fd-lk.h
@@ -0,0 +1,59 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _FD_LK_H
+#define _FD_LK_H
+
+#include "glusterfs/fd.h"
+#include "glusterfs/locking.h"
+#include "glusterfs/list.h"
+#include "glusterfs/glusterfs.h"
+
+#define get_lk_type(type)                                                      \
+    type == F_UNLCK ? "F_UNLCK" : (type == F_RDLCK ? "F_RDLCK" : "F_WRLCK")
+
+#define get_lk_cmd(cmd)                                                        \
+    cmd == F_SETLKW ? "F_SETLKW" : (cmd == F_SETLK ? "F_SETLK" : "F_GETLK")
+
+struct _fd;
+
+struct fd_lk_ctx {
+    struct list_head lk_list;
+    gf_atomic_t ref;
+    gf_lock_t lock;
+};
+typedef struct fd_lk_ctx fd_lk_ctx_t;
+
+struct fd_lk_ctx_node {
+    int32_t cmd;
+    struct gf_flock user_flock;
+    off_t fl_start;
+    off_t fl_end;
+    short fl_type;
+    struct list_head next;
+};
+typedef struct fd_lk_ctx_node fd_lk_ctx_node_t;
+
+fd_lk_ctx_t *
+fd_lk_ctx_ref(fd_lk_ctx_t *lk_ctx);
+
+fd_lk_ctx_t *
+fd_lk_ctx_create(void);
+
+int
+fd_lk_insert_and_merge(struct _fd *lk_ctx, int32_t cmd, struct gf_flock *flock);
+
+int
+fd_lk_ctx_unref(fd_lk_ctx_t *lk_ctx);
+
+gf_boolean_t
+fd_lk_ctx_empty(fd_lk_ctx_t *lk_ctx);
+
+#endif /* _FD_LK_H */
diff --git a/libglusterfs/src/glusterfs/fd.h b/libglusterfs/src/glusterfs/fd.h
new file mode 100644
index 00000000000..3ffaaa60504
--- /dev/null
+++ b/libglusterfs/src/glusterfs/fd.h
@@ -0,0 +1,169 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _FD_H
+#define _FD_H
+
+#include "glusterfs/list.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/locking.h"
+#include "glusterfs/fd-lk.h"
+
+#define GF_ANON_FD_NO -2
+#define GF_ANON_FD_FLAGS (O_RDWR | O_LARGEFILE)
+
+struct _inode;
+struct _dict;
+struct fd_lk_ctx;
+
+struct _fd_ctx {
+    union {
+        uint64_t key;
+        void *xl_key;
+    };
+    union {
+        uint64_t value1;
+        void *ptr1;
+    };
+};
+
+struct _fd {
+    uint64_t pid;
+    int32_t flags;
+    gf_atomic_t refcount;
+    struct list_head inode_list;
+    struct _inode *inode;
+    gf_lock_t lock; /* used ONLY for manipulating
+                       'struct _fd_ctx' array (_ctx).*/
+    struct _fd_ctx *_ctx;
+    int xl_count; /* Number of xl referred in this fd */
+    struct fd_lk_ctx *lk_ctx;
+    gf_boolean_t anonymous; /* fd which does not have counterpart open
+                               fd on backend (server for client, posix
+                               for server). */
+};
+typedef struct _fd fd_t;
+
+struct fd_table_entry {
+    fd_t *fd;
+    int next_free;
+};
+typedef struct fd_table_entry fdentry_t;
+
+struct _fdtable {
+    int refcount;
+    uint32_t max_fds;
+    pthread_rwlock_t lock;
+    fdentry_t *fdentries;
+    int first_free;
+};
+typedef struct _fdtable fdtable_t;
+
+/* Signifies no more entries in the fd table. */
+#define GF_FDTABLE_END -1
+
+/* This is used to invalidated
+ * the next_free value in an fdentry that has been allocated
+ */
+#define GF_FDENTRY_ALLOCATED -2
+
+#include "glusterfs/logging.h"
+#include "glusterfs/xlator.h"
+
+void
+gf_fd_put(fdtable_t *fdtable, int32_t fd);
+
+fd_t *
+gf_fd_fdptr_get(fdtable_t *fdtable, int64_t fd);
+
+fdtable_t *
+gf_fd_fdtable_alloc(void);
+
+int
+gf_fd_unused_get(fdtable_t *fdtable, fd_t *fdptr);
+
+fdentry_t *
+gf_fd_fdtable_get_all_fds(fdtable_t *fdtable, uint32_t *count);
+
+void
+gf_fd_fdtable_destroy(fdtable_t *fdtable);
+
+fd_t *
+__fd_ref(fd_t *fd);
+
+fd_t *
+fd_ref(fd_t *fd);
+
+void
+fd_unref(fd_t *fd);
+
+void
+fd_close(fd_t *fd);
+
+fd_t *
+fd_create(struct _inode *inode, pid_t pid);
+
+fd_t *
+fd_create_uint64(struct _inode *inode, uint64_t pid);
+
+fd_t *
+fd_lookup(struct _inode *inode, pid_t pid);
+
+fd_t *
+fd_lookup_uint64(struct _inode *inode, uint64_t pid);
+
+fd_t *
+fd_lookup_anonymous(inode_t *inode, int32_t flags);
+
+fd_t *
+fd_anonymous(inode_t *inode);
+
+fd_t *
+fd_anonymous_with_flags(inode_t *inode, int32_t flags);
+
+gf_boolean_t
+fd_is_anonymous(fd_t *fd);
+
+uint8_t
+fd_list_empty(struct _inode *inode);
+
+fd_t *
+fd_bind(fd_t *fd);
+
+int
+fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value);
+
+int
+fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value);
+
+int
+fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value);
+
+int
+__fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value);
+
+int
+__fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value);
+
+int
+__fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value);
+
+void
+fd_ctx_dump(fd_t *fd, char *prefix);
+
+fdentry_t *
+gf_fd_fdtable_copy_all_fds(fdtable_t *fdtable, uint32_t *count);
+
+void
+gf_fdptr_put(fdtable_t *fdtable, fd_t *fd);
+
+#endif /* _FD_H */
diff --git a/libglusterfs/src/glusterfs/gf-dirent.h b/libglusterfs/src/glusterfs/gf-dirent.h
new file mode 100644
index 00000000000..e358da30f58
--- /dev/null
+++ b/libglusterfs/src/glusterfs/gf-dirent.h
@@ -0,0 +1,71 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GF_DIRENT_H
+#define _GF_DIRENT_H
+
+#include "glusterfs/iatt.h"
+#include "glusterfs/inode.h"
+
+#define gf_dirent_size(name) (sizeof(gf_dirent_t) + strlen(name) + 1)
+
+int
+gf_deitransform(xlator_t *this, uint64_t y);
+
+int
+gf_itransform(xlator_t *this, uint64_t x, uint64_t *y_p, int client_id);
+
+uint64_t
+gf_dirent_orig_offset(xlator_t *this, uint64_t offset);
+
+struct _dir_entry {
+    struct _dir_entry *next;
+    char *name;
+    char *link;
+    struct iatt buf;
+};
+
+struct _gf_dirent {
+    union {
+        struct list_head list;
+        struct {
+            struct _gf_dirent *next;
+            struct _gf_dirent *prev;
+        };
+    };
+    uint64_t d_ino;
+    uint64_t d_off;
+    uint32_t d_len;
+    uint32_t d_type;
+    struct iatt d_stat;
+    dict_t *dict;
+    inode_t *inode;
+    char d_name[];
+};
+
+#define DT_ISDIR(mode) (mode == DT_DIR)
+
+gf_dirent_t *
+gf_dirent_for_name(const char *name);
+gf_dirent_t *
+entry_copy(gf_dirent_t *source);
+void
+gf_dirent_entry_free(gf_dirent_t *entry);
+void
+gf_dirent_free(gf_dirent_t *entries);
+int
+gf_link_inodes_from_dirent(xlator_t *this, inode_t *parent,
+                           gf_dirent_t *entries);
+int
+gf_fill_iatt_for_dirent(gf_dirent_t *entry, inode_t *parent, xlator_t *subvol);
+
+void
+gf_link_inode_from_dirent(xlator_t *this, inode_t *parent, gf_dirent_t *entry);
+#endif /* _GF_DIRENT_H */
diff --git a/libglusterfs/src/glusterfs/gf-event.h b/libglusterfs/src/glusterfs/gf-event.h
new file mode 100644
index 00000000000..40f8fbdf10a
--- /dev/null
+++ b/libglusterfs/src/glusterfs/gf-event.h
@@ -0,0 +1,140 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GF_EVENT_H_
+#define _GF_EVENT_H_
+
+#include <pthread.h>
+#include "common-utils.h"
+#include "list.h"
+
+struct event_pool;
+struct event_ops;
+struct event_slot_poll;
+struct event_slot_epoll;
+struct event_data {
+    int idx;
+    int gen;
+} __attribute__((__packed__, __may_alias__));
+
+typedef void (*event_handler_t)(int fd, int idx, int gen, void *data,
+                                int poll_in, int poll_out, int poll_err,
+                                char event_thread_exit);
+
+#define EVENT_EPOLL_TABLES 1024
+#define EVENT_EPOLL_SLOTS 1024
+#define EVENT_MAX_THREADS 1024
+
+/* See rpcsvc.h to check why. */
+GF_STATIC_ASSERT(EVENT_MAX_THREADS % __BITS_PER_LONG == 0);
+
+struct event_pool {
+    struct event_ops *ops;
+
+    int fd;
+    int breaker[2];
+
+    int count;
+    struct event_slot_poll *reg;
+    struct event_slot_epoll *ereg[EVENT_EPOLL_TABLES];
+    int slots_used[EVENT_EPOLL_TABLES];
+
+    struct list_head poller_death;
+    int poller_death_sliced; /* track whether the list of fds interested
+                              * poller_death is sliced. If yes, new thread death
+                              * notification has to wait till the list is added
+                              * back
+                              */
+    int poller_gen;
+    int used;
+    int changed;
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+
+    void *evcache;
+    int evcache_size;
+
+    /* NOTE: Currently used only when event processing is done using
+     * epoll. */
+    int eventthreadcount; /* number of event threads to execute. */
+    pthread_t pollers[EVENT_MAX_THREADS]; /* poller thread_id store, and live
+                                             status */
+    int destroy;
+    int activethreadcount;
+
+    /*
+     * Number of threads created by auto-scaling, *in addition to* the
+     * configured number of threads.  This is only applicable on the
+     * server, where we try to keep the number of threads around the number
+     * of bricks.  In that case, the configured number is just "extra"
+     * threads to handle requests in excess of one per brick (including
+     * requests on the GlusterD connection).  For clients or GlusterD, this
+     * number will always be zero, so the "extra" is all we have.
+     *
+     * TBD: consider auto-scaling for clients as well
+     */
+    int auto_thread_count;
+};
+
+struct event_destroy_data {
+    int readfd;
+    struct event_pool *pool;
+};
+
+struct event_ops {
+    struct event_pool *(*new)(int count, int eventthreadcount);
+
+    int (*event_register)(struct event_pool *event_pool, int fd,
+                          event_handler_t handler, void *data, int poll_in,
+                          int poll_out, char notify_poller_death);
+
+    int (*event_select_on)(struct event_pool *event_pool, int fd, int idx,
+                           int poll_in, int poll_out);
+
+    int (*event_unregister)(struct event_pool *event_pool, int fd, int idx);
+
+    int (*event_unregister_close)(struct event_pool *event_pool, int fd,
+                                  int idx);
+
+    int (*event_dispatch)(struct event_pool *event_pool);
+
+    int (*event_reconfigure_threads)(struct event_pool *event_pool,
+                                     int newcount);
+    int (*event_pool_destroy)(struct event_pool *event_pool);
+    int (*event_handled)(struct event_pool *event_pool, int fd, int idx,
+                         int gen);
+};
+
+struct event_pool *
+gf_event_pool_new(int count, int eventthreadcount);
+int
+gf_event_select_on(struct event_pool *event_pool, int fd, int idx, int poll_in,
+                   int poll_out);
+int
+gf_event_register(struct event_pool *event_pool, int fd,
+                  event_handler_t handler, void *data, int poll_in,
+                  int poll_out, char notify_poller_death);
+int
+gf_event_unregister(struct event_pool *event_pool, int fd, int idx);
+int
+gf_event_unregister_close(struct event_pool *event_pool, int fd, int idx);
+int
+gf_event_dispatch(struct event_pool *event_pool);
+int
+gf_event_reconfigure_threads(struct event_pool *event_pool, int value);
+int
+gf_event_pool_destroy(struct event_pool *event_pool);
+int
+gf_event_dispatch_destroy(struct event_pool *event_pool);
+int
+gf_event_handled(struct event_pool *event_pool, int fd, int idx, int gen);
+
+#endif /* _GF_EVENT_H_ */
diff --git a/libglusterfs/src/gidcache.h b/libglusterfs/src/glusterfs/gidcache.h
index 886721e719f..ddaabd765b5 100644
--- a/libglusterfs/src/gidcache.h
+++ b/libglusterfs/src/glusterfs/gidcache.h
@@ -11,8 +11,8 @@
 #ifndef __GIDCACHE_H__
 #define __GIDCACHE_H__
 
-#include "glusterfs.h"
-#include "locking.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/locking.h"
 
 /*
  * TBD: make the cache size tunable
@@ -26,30 +26,35 @@
  * to scan more entries with every lookup/update.
  */
 
-#define AUX_GID_CACHE_ASSOC     4
-#define AUX_GID_CACHE_BUCKETS   256
-#define AUX_GID_CACHE_SIZE      (AUX_GID_CACHE_ASSOC * AUX_GID_CACHE_BUCKETS)
+#define AUX_GID_CACHE_ASSOC 4
+#define AUX_GID_CACHE_BUCKETS 256
+#define AUX_GID_CACHE_SIZE (AUX_GID_CACHE_ASSOC * AUX_GID_CACHE_BUCKETS)
 
 typedef struct {
-	uint64_t	gl_id;
-	uint64_t        gl_uid;
-	uint64_t        gl_gid;
-	int		gl_count;
-	gid_t		*gl_list;
-	time_t		gl_deadline;
+    uint64_t gl_id;
+    uint64_t gl_uid;
+    uint64_t gl_gid;
+    int gl_count;
+    gid_t *gl_list;
+    time_t gl_deadline;
 } gid_list_t;
 
 typedef struct {
-	gf_lock_t	gc_lock;
-	uint32_t	gc_max_age;
-	unsigned int	gc_nbuckets;
-	gid_list_t	gc_cache[AUX_GID_CACHE_SIZE];
+    gf_lock_t gc_lock;
+    uint32_t gc_max_age;
+    unsigned int gc_nbuckets;
+    gid_list_t gc_cache[AUX_GID_CACHE_SIZE];
 } gid_cache_t;
 
-int gid_cache_init(gid_cache_t *, uint32_t);
-int gid_cache_reconf(gid_cache_t *, uint32_t);
-const gid_list_t *gid_cache_lookup(gid_cache_t *, uint64_t, uint64_t, uint64_t);
-void gid_cache_release(gid_cache_t *, const gid_list_t *);
-int gid_cache_add(gid_cache_t *, gid_list_t *);
+int
+gid_cache_init(gid_cache_t *, uint32_t);
+int
+gid_cache_reconf(gid_cache_t *, uint32_t);
+const gid_list_t *
+gid_cache_lookup(gid_cache_t *, uint64_t, uint64_t, uint64_t);
+void
+gid_cache_release(gid_cache_t *, const gid_list_t *);
+int
+gid_cache_add(gid_cache_t *, gid_list_t *);
 
 #endif /* __GIDCACHE_H__ */
diff --git a/libglusterfs/src/glusterfs/glfs-message-id.h b/libglusterfs/src/glusterfs/glfs-message-id.h
new file mode 100644
index 00000000000..a1a16ca1efb
--- /dev/null
+++ b/libglusterfs/src/glusterfs/glfs-message-id.h
@@ -0,0 +1,102 @@
+/*
+  Copyright (c) 2015-2016 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GLFS_MESSAGE_ID_H_
+#define _GLFS_MESSAGE_ID_H_
+
+/* Base of all message IDs, all message IDs would be
+ * greater than this */
+#define GLFS_MSGID_BASE 100000
+
+/* Segment size of allocated range. Any component needing more than this
+ * segment size should take multiple segments (at times non contiguous,
+ * if extensions are being made post the next segment already allocated) */
+#define GLFS_MSGID_SEGMENT 1000
+
+/* Macro to define a range of messages for a component. The first argument is
+ * the name of the component. The second argument is the number of segments
+ * to allocate. The defined values will be GLFS_MSGID_COMP_<name> and
+ * GLFS_MSGID_COMP_<name>_END. */
+#define GLFS_MSGID_COMP(_name, _blocks)                                        \
+    GLFS_MSGID_COMP_##_name,                                                   \
+        GLFS_MSGID_COMP_##_name##_END = (GLFS_MSGID_COMP_##_name +             \
+                                         (GLFS_MSGID_SEGMENT * (_blocks)) - 1)
+
+#define GLFS_MSGID(_name, _msgs...)                                            \
+    enum _msgid_table_##_name                                                  \
+    {                                                                          \
+        GLFS_##_name##_COMP_BASE = GLFS_MSGID_COMP_##_name, ##_msgs,           \
+        GLGS_##_name##_COMP_END                                                \
+    }
+
+/* Per module message segments allocated */
+/* NOTE: For any new module add to the end the modules */
+enum _msgid_comp {
+    GLFS_MSGID_RESERVED = GLFS_MSGID_BASE - 1,
+
+    GLFS_MSGID_COMP(GLUSTERFSD, 1),
+    GLFS_MSGID_COMP(LIBGLUSTERFS, 1),
+    GLFS_MSGID_COMP(RPC_LIB, 1),
+    GLFS_MSGID_COMP(RPC_TRANS_RDMA, 1),
+    GLFS_MSGID_COMP(API, 1),
+    GLFS_MSGID_COMP(CLI, 1),
+    /* glusterd has a lot of messages, taking 2 segments for the same */
+    GLFS_MSGID_COMP(GLUSTERD, 2),
+    GLFS_MSGID_COMP(AFR, 1),
+    GLFS_MSGID_COMP(DHT, 1),
+    /* there is no component called 'common', however reserving this segment
+     * for common actions/errors like dict_{get/set}, memory accounting*/
+    GLFS_MSGID_COMP(COMMON, 1),
+    GLFS_MSGID_COMP(UPCALL, 1),
+    GLFS_MSGID_COMP(NFS, 1),
+    GLFS_MSGID_COMP(POSIX, 1),
+    GLFS_MSGID_COMP(PC, 1),
+    GLFS_MSGID_COMP(PS, 1),
+    GLFS_MSGID_COMP(BITROT_STUB, 1),
+    GLFS_MSGID_COMP(CHANGELOG, 1),
+    GLFS_MSGID_COMP(BITROT_BITD, 1),
+    GLFS_MSGID_COMP(RPC_TRANS_SOCKET, 1),
+    GLFS_MSGID_COMP(QUOTA, 1),
+    GLFS_MSGID_COMP(CTR, 1),
+    GLFS_MSGID_COMP(EC, 1),
+    GLFS_MSGID_COMP(IO_CACHE, 1),
+    GLFS_MSGID_COMP(IO_THREADS, 1),
+    GLFS_MSGID_COMP(MD_CACHE, 1),
+    GLFS_MSGID_COMP(OPEN_BEHIND, 1),
+    GLFS_MSGID_COMP(QUICK_READ, 1),
+    GLFS_MSGID_COMP(READ_AHEAD, 1),
+    GLFS_MSGID_COMP(READDIR_AHEAD, 1),
+    GLFS_MSGID_COMP(SYMLINK_CACHE, 1),
+    GLFS_MSGID_COMP(WRITE_BEHIND, 1),
+    GLFS_MSGID_COMP(CHANGELOG_LIB, 1),
+    GLFS_MSGID_COMP(SHARD, 1),
+    GLFS_MSGID_COMP(JBR, 1),
+    GLFS_MSGID_COMP(PL, 1),
+    GLFS_MSGID_COMP(DC, 1),
+    GLFS_MSGID_COMP(LEASES, 1),
+    GLFS_MSGID_COMP(INDEX, 1),
+    GLFS_MSGID_COMP(POSIX_ACL, 1),
+    GLFS_MSGID_COMP(NLC, 1),
+    GLFS_MSGID_COMP(SL, 1),
+    GLFS_MSGID_COMP(HAM, 1),
+    GLFS_MSGID_COMP(SDFS, 1),
+    GLFS_MSGID_COMP(QUIESCE, 1),
+    GLFS_MSGID_COMP(TA, 1),
+    GLFS_MSGID_COMP(SNAPVIEW_CLIENT, 1),
+    GLFS_MSGID_COMP(TEMPLATE, 1),
+    GLFS_MSGID_COMP(UTIME, 1),
+    GLFS_MSGID_COMP(SNAPVIEW_SERVER, 1),
+    GLFS_MSGID_COMP(CVLT, 1),
+    /* --- new segments for messages goes above this line --- */
+
+    GLFS_MSGID_END
+};
+
+#endif /* !_GLFS_MESSAGE_ID_H_ */
diff --git a/libglusterfs/src/glusterfs/globals.h b/libglusterfs/src/glusterfs/globals.h
new file mode 100644
index 00000000000..b22eaae6c2f
--- /dev/null
+++ b/libglusterfs/src/glusterfs/globals.h
@@ -0,0 +1,188 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GLOBALS_H
+#define _GLOBALS_H
+
+#define GF_DEFAULT_BASE_PORT 24007
+#define GF_DEFAULT_VOLFILE_TRANSPORT "tcp"
+
+#define GF_GLOBAL_XLATOR_NAME "global"
+#define GD_OP_VERSION_KEY "operating-version"
+#define GD_MIN_OP_VERSION_KEY "minimum-operating-version"
+#define GD_MAX_OP_VERSION_KEY "maximum-operating-version"
+
+#define GF_PROTECT_FROM_EXTERNAL_WRITES "trusted.glusterfs.protect.writes"
+#define GF_AVOID_OVERWRITE "glusterfs.avoid.overwrite"
+#define GF_CLEAN_WRITE_PROTECTION "glusterfs.clean.writexattr"
+
+/* Gluster versions - OP-VERSION mapping
+ *
+ * 3.3.x                - 1
+ * 3.4.x                - 2
+ * 3.5.0                - 3
+ * 3.5.1                - 30501
+ * 3.6.0                - 30600
+ * 3.7.0                - 30700
+ * 3.7.1                - 30701
+ * 3.7.2                - 30702
+ *
+ * Starting with Gluster v3.6, the op-version will be multi-digit integer values
+ * based on the Glusterfs version, instead of a simply incrementing integer
+ * value. The op-version for a given X.Y.Z release will be an integer XYZ, with
+ * Y and Z 2 digit always 2 digits wide and padded with 0 when needed. This
+ * should allow for some gaps between two Y releases for backports of features
+ * in Z releases.
+ */
+#define GD_OP_VERSION_MIN                                                      \
+    1 /* MIN is the fresh start op-version, mostly                             \
+         should not change */
+#define GD_OP_VERSION_MAX                                                      \
+    GD_OP_VERSION_9_0 /* MAX VERSION is the maximum                            \
+                         count in VME table, should                            \
+                         keep changing with                                    \
+                         introduction of newer                                 \
+                         versions */
+
+#define GD_OP_VERSION_3_6_0 30600 /* Op-Version for GlusterFS 3.6.0 */
+
+#define GD_OP_VERSION_3_7_0 30700 /* Op-version for GlusterFS 3.7.0 */
+
+#define GD_OP_VERSION_3_7_1 30701 /* Op-version for GlusterFS 3.7.1 */
+
+#define GD_OP_VERSION_3_7_2 30702 /* Op-version for GlusterFS 3.7.2 */
+
+#define GD_OP_VERSION_3_7_3 30703 /* Op-version for GlusterFS 3.7.3 */
+
+#define GD_OP_VERSION_3_7_4 30704 /* Op-version for GlusterFS 3.7.4 */
+
+#define GD_OP_VERSION_3_7_5 30705 /* Op-version for GlusterFS 3.7.5 */
+
+#define GD_OP_VERSION_3_7_6 30706 /* Op-version for GlusterFS 3.7.6 */
+
+#define GD_OP_VERSION_3_7_7 30707 /* Op-version for GlusterFS 3.7.7 */
+
+#define GD_OP_VERSION_3_7_10 30710 /* Op-version for GlusterFS 3.7.10 */
+
+#define GD_OP_VERSION_3_7_12 30712 /* Op-version for GlusterFS 3.7.12 */
+
+#define GD_OP_VERSION_3_8_0 30800 /* Op-version for GlusterFS 3.8.0 */
+
+#define GD_OP_VERSION_3_8_3 30803 /* Op-version for GlusterFS 3.8.3 */
+
+#define GD_OP_VERSION_3_8_4 30804 /* Op-version for GlusterFS 3.8.4 */
+
+#define GD_OP_VERSION_3_9_0 30900 /* Op-version for GlusterFS 3.9.0 */
+
+#define GD_OP_VERSION_3_9_1 30901 /* Op-version for GlusterFS 3.9.1 */
+
+#define GD_OP_VERSION_3_10_0 31000 /* Op-version for GlusterFS 3.10.0 */
+
+#define GD_OP_VERSION_3_10_1 31001 /* Op-version for GlusterFS 3.10.1 */
+
+#define GD_OP_VERSION_3_10_2 31002 /* Op-version for GlusterFS 3.10.2 */
+
+#define GD_OP_VERSION_3_11_0 31100 /* Op-version for GlusterFS 3.11.0 */
+
+#define GD_OP_VERSION_3_11_1 31101 /* Op-version for GlusterFS 3.11.1 */
+
+#define GD_OP_VERSION_3_12_0 31200 /* Op-version for GlusterFS 3.12.0 */
+
+#define GD_OP_VERSION_3_12_2 31202 /* Op-version for GlusterFS 3.12.2 */
+
+#define GD_OP_VERSION_3_12_3 31203 /* Op-version for GlusterFS 3.12.3 */
+
+#define GD_OP_VERSION_3_13_0 31300 /* Op-version for GlusterFS 3.13.0 */
+
+#define GD_OP_VERSION_3_13_1 31301 /* Op-version for GlusterFS 3.13.1 */
+
+#define GD_OP_VERSION_3_13_2 31302 /* Op-version for GlusterFS 3.13.2 */
+
+#define GD_OP_VERSION_4_0_0 40000 /* Op-version for GlusterFS 4.0.0 */
+
+#define GD_OP_VERSION_4_1_0 40100 /* Op-version for GlusterFS 4.1.0 */
+
+#define GD_OP_VERSION_5_0 50000 /* Op-version for GlusterFS 5.0 */
+
+#define GD_OP_VERSION_5_4 50400 /* Op-version for GlusterFS 5.4 */
+
+#define GD_OP_VERSION_6_0 60000 /* Op-version for GlusterFS 6.0 */
+
+#define GD_OP_VERSION_7_0 70000 /* Op-version for GlusterFS 7.0 */
+#define GD_OP_VERSION_7_1 70100 /* Op-version for GlusterFS 7.1 */
+#define GD_OP_VERSION_7_2 70200 /* Op-version for GlusterFS 7.2 */
+#define GD_OP_VERSION_7_3 70300 /* Op-version for GlusterFS 7.3 */
+
+#define GD_OP_VERSION_8_0 80000 /* Op-version for GlusterFS 8.0 */
+
+#define GD_OP_VERSION_9_0 90000 /* Op-version for GlusterFS 9.0 */
+
+#define GD_OP_VER_PERSISTENT_AFR_XATTRS GD_OP_VERSION_3_6_0
+
+#include "glusterfs/xlator.h"
+#include "glusterfs/options.h"
+
+/* THIS */
+#define THIS (*__glusterfs_this_location())
+#define DECLARE_OLD_THIS xlator_t *old_THIS = THIS
+
+xlator_t **
+__glusterfs_this_location(void);
+xlator_t *
+glusterfs_this_get(void);
+void
+glusterfs_this_set(xlator_t *);
+
+extern xlator_t global_xlator;
+extern struct volume_options global_xl_options[];
+
+/* syncopctx */
+void *
+syncopctx_getctx(void);
+
+/* task */
+void *
+synctask_get(void);
+void
+synctask_set(void *);
+
+/* uuid_buf */
+char *
+glusterfs_uuid_buf_get(void);
+/* lkowner_buf */
+char *
+glusterfs_lkowner_buf_get(void);
+/* leaseid buf */
+char *
+glusterfs_leaseid_buf_get(void);
+char *
+glusterfs_leaseid_exist(void);
+
+/* init */
+int
+glusterfs_globals_init(glusterfs_ctx_t *ctx);
+
+void
+gf_thread_needs_cleanup(void);
+
+struct tvec_base *
+glusterfs_ctx_tw_get(glusterfs_ctx_t *ctx);
+void
+glusterfs_ctx_tw_put(glusterfs_ctx_t *ctx);
+
+extern const char *gf_fop_list[];
+extern const char *gf_upcall_list[];
+
+/* mem acct enable/disable */
+int
+gf_global_mem_acct_enable_get(void);
+int
+gf_global_mem_acct_enable_set(int val);
+#endif /* !_GLOBALS_H */
diff --git a/libglusterfs/src/glusterfs/glusterfs-acl.h b/libglusterfs/src/glusterfs/glusterfs-acl.h
new file mode 100644
index 00000000000..987bf5fab0b
--- /dev/null
+++ b/libglusterfs/src/glusterfs/glusterfs-acl.h
@@ -0,0 +1,162 @@
+/*
+  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GLUSTERFS_ACL_H
+#define _GLUSTERFS_ACL_H
+
+/* WARNING: Much if this code is restricted to Linux usage.
+ *
+ * It would be much cleaner to replace the code with something that is based on
+ * libacl (or its libc implementation on *BSD).
+ *
+ * Initial work for replacing this Linux specific implementation has been
+ * started as part of the "Improve POSIX ACLs" feature. Functionality for this
+ * feature has been added to the end of this file.
+ */
+
+#include <stdint.h>
+#include <sys/types.h> /* For uid_t */
+
+#include "glusterfs/locking.h" /* For gf_lock_t in struct posix_acl_conf */
+
+#define ACL_PROGRAM 100227
+#define ACLV3_VERSION 3
+
+#define POSIX_ACL_MINIMAL_ACE_COUNT 3
+
+#define POSIX_ACL_READ (0x04)
+#define POSIX_ACL_WRITE (0x02)
+#define POSIX_ACL_EXECUTE (0x01)
+
+#define POSIX_ACL_UNDEFINED_TAG (0x00)
+#define POSIX_ACL_USER_OBJ (0x01)
+#define POSIX_ACL_USER (0x02)
+#define POSIX_ACL_GROUP_OBJ (0x04)
+#define POSIX_ACL_GROUP (0x08)
+#define POSIX_ACL_MASK (0x10)
+#define POSIX_ACL_OTHER (0x20)
+
+#define POSIX_ACL_UNDEFINED_ID (-1)
+
+#define POSIX_ACL_XATTR_VERSION (0x02)
+
+#define POSIX_ACL_ACCESS_XATTR "system.posix_acl_access"
+#define POSIX_ACL_DEFAULT_XATTR "system.posix_acl_default"
+
+struct posix_acl_xattr_entry {
+    uint16_t tag;
+    uint16_t perm;
+    uint32_t id;
+};
+
+struct posix_acl_xattr_header {
+    uint32_t version;
+    struct posix_acl_xattr_entry entries[];
+};
+
+typedef struct posix_acl_xattr_entry posix_acl_xattr_entry;
+typedef struct posix_acl_xattr_header posix_acl_xattr_header;
+
+static inline size_t
+posix_acl_xattr_size(unsigned int count)
+{
+    return (sizeof(posix_acl_xattr_header) +
+            (count * sizeof(posix_acl_xattr_entry)));
+}
+
+static inline ssize_t
+posix_acl_xattr_count(size_t size)
+{
+    if (size < sizeof(posix_acl_xattr_header))
+        return (-1);
+    size -= sizeof(posix_acl_xattr_header);
+    if (size % sizeof(posix_acl_xattr_entry))
+        return (-1);
+    return (size / sizeof(posix_acl_xattr_entry));
+}
+
+struct posix_ace {
+    uint16_t tag;
+    uint16_t perm;
+    uint32_t id;
+};
+
+struct posix_acl {
+    int refcnt;
+    int count;
+    struct posix_ace entries[];
+};
+
+struct posix_acl_ctx {
+    uid_t uid;
+    gid_t gid;
+    mode_t perm;
+    glusterfs_fop_t fop;
+    struct posix_acl *acl_access;
+    struct posix_acl *acl_default;
+};
+
+struct posix_acl_conf {
+    gf_lock_t acl_lock;
+    uid_t super_uid;
+    struct posix_acl *minimal_acl;
+};
+
+/* Above this comment, the legacy POSIX ACL support is kept until it is not
+ * used anymore. Below you will find the more portable version to support POSIX
+ * ACls based on the implementation of libacl (see sys/acl.h). */
+
+/* virtual xattrs passed over RPC, not stored on disk */
+#define GF_POSIX_ACL_ACCESS "glusterfs.posix.acl"
+#define GF_POSIX_ACL_DEFAULT "glusterfs.posix.default_acl"
+#define GF_POSIX_ACL_REQUEST(key)                                              \
+    (!strncmp(key, GF_POSIX_ACL_ACCESS, SLEN(GF_POSIX_ACL_ACCESS)) ||          \
+     !strncmp(key, GF_POSIX_ACL_DEFAULT, SLEN(GF_POSIX_ACL_DEFAULT)))
+
+#ifdef HAVE_SYS_ACL_H /* only NetBSD does not support POSIX ACLs */
+
+#include <sys/acl.h>
+
+static inline const char *
+gf_posix_acl_get_key(const acl_type_t type)
+{
+    char *acl_key = NULL;
+
+    switch (type) {
+        case ACL_TYPE_ACCESS:
+            acl_key = GF_POSIX_ACL_ACCESS;
+            break;
+        case ACL_TYPE_DEFAULT:
+            acl_key = GF_POSIX_ACL_DEFAULT;
+            break;
+        default:
+            errno = EINVAL;
+    }
+
+    return acl_key;
+}
+
+static inline acl_type_t
+gf_posix_acl_get_type(const char *key)
+{
+    acl_type_t type = 0;
+
+    if (!strncmp(key, GF_POSIX_ACL_ACCESS, SLEN(GF_POSIX_ACL_ACCESS)))
+        type = ACL_TYPE_ACCESS;
+    else if (!strncmp(key, GF_POSIX_ACL_DEFAULT, SLEN(GF_POSIX_ACL_DEFAULT)))
+        type = ACL_TYPE_DEFAULT;
+    else
+        errno = EINVAL;
+
+    return type;
+}
+
+#endif /* HAVE_SYS_ACL_H */
+#endif /* _GLUSTERFS_ACL_H */
diff --git a/libglusterfs/src/glusterfs/glusterfs-fops.h b/libglusterfs/src/glusterfs/glusterfs-fops.h
new file mode 100644
index 00000000000..030b2701608
--- /dev/null
+++ b/libglusterfs/src/glusterfs/glusterfs-fops.h
@@ -0,0 +1,241 @@
+/*
+  Copyright (c) 2008-2019 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GLUSTERFS_FOPS_H_
+#define _GLUSTERFS_FOPS_H_
+
+#include <glusterfs/compat.h>
+
+enum glusterfs_fop_t {
+    GF_FOP_NULL = 0,
+    GF_FOP_STAT = 0 + 1,
+    GF_FOP_READLINK = 0 + 2,
+    GF_FOP_MKNOD = 0 + 3,
+    GF_FOP_MKDIR = 0 + 4,
+    GF_FOP_UNLINK = 0 + 5,
+    GF_FOP_RMDIR = 0 + 6,
+    GF_FOP_SYMLINK = 0 + 7,
+    GF_FOP_RENAME = 0 + 8,
+    GF_FOP_LINK = 0 + 9,
+    GF_FOP_TRUNCATE = 0 + 10,
+    GF_FOP_OPEN = 0 + 11,
+    GF_FOP_READ = 0 + 12,
+    GF_FOP_WRITE = 0 + 13,
+    GF_FOP_STATFS = 0 + 14,
+    GF_FOP_FLUSH = 0 + 15,
+    GF_FOP_FSYNC = 0 + 16,
+    GF_FOP_SETXATTR = 0 + 17,
+    GF_FOP_GETXATTR = 0 + 18,
+    GF_FOP_REMOVEXATTR = 0 + 19,
+    GF_FOP_OPENDIR = 0 + 20,
+    GF_FOP_FSYNCDIR = 0 + 21,
+    GF_FOP_ACCESS = 0 + 22,
+    GF_FOP_CREATE = 0 + 23,
+    GF_FOP_FTRUNCATE = 0 + 24,
+    GF_FOP_FSTAT = 0 + 25,
+    GF_FOP_LK = 0 + 26,
+    GF_FOP_LOOKUP = 0 + 27,
+    GF_FOP_READDIR = 0 + 28,
+    GF_FOP_INODELK = 0 + 29,
+    GF_FOP_FINODELK = 0 + 30,
+    GF_FOP_ENTRYLK = 0 + 31,
+    GF_FOP_FENTRYLK = 0 + 32,
+    GF_FOP_XATTROP = 0 + 33,
+    GF_FOP_FXATTROP = 0 + 34,
+    GF_FOP_FGETXATTR = 0 + 35,
+    GF_FOP_FSETXATTR = 0 + 36,
+    GF_FOP_RCHECKSUM = 0 + 37,
+    GF_FOP_SETATTR = 0 + 38,
+    GF_FOP_FSETATTR = 0 + 39,
+    GF_FOP_READDIRP = 0 + 40,
+    GF_FOP_FORGET = 0 + 41,
+    GF_FOP_RELEASE = 0 + 42,
+    GF_FOP_RELEASEDIR = 0 + 43,
+    GF_FOP_GETSPEC = 0 + 44,
+    GF_FOP_FREMOVEXATTR = 0 + 45,
+    GF_FOP_FALLOCATE = 0 + 46,
+    GF_FOP_DISCARD = 0 + 47,
+    GF_FOP_ZEROFILL = 0 + 48,
+    GF_FOP_IPC = 0 + 49,
+    GF_FOP_SEEK = 0 + 50,
+    GF_FOP_LEASE = 0 + 51,
+    GF_FOP_COMPOUND = 0 + 52,
+    GF_FOP_GETACTIVELK = 0 + 53,
+    GF_FOP_SETACTIVELK = 0 + 54,
+    GF_FOP_PUT = 0 + 55,
+    GF_FOP_ICREATE = 0 + 56,
+    GF_FOP_NAMELINK = 0 + 57,
+    GF_FOP_COPY_FILE_RANGE = 0 + 58,
+    GF_FOP_MAXVALUE = 0 + 59,
+};
+typedef enum glusterfs_fop_t glusterfs_fop_t;
+
+enum glusterfs_event_t {
+    GF_EVENT_PARENT_UP = 1,
+    GF_EVENT_POLLIN = 1 + 1,
+    GF_EVENT_POLLOUT = 1 + 2,
+    GF_EVENT_POLLERR = 1 + 3,
+    GF_EVENT_CHILD_UP = 1 + 4,
+    GF_EVENT_CHILD_DOWN = 1 + 5,
+    GF_EVENT_CHILD_CONNECTING = 1 + 6,
+    GF_EVENT_CLEANUP = 9,
+    GF_EVENT_TRANSPORT_CONNECTED = 9 + 1,
+    GF_EVENT_VOLFILE_MODIFIED = 9 + 2,
+    GF_EVENT_GRAPH_NEW = 9 + 3,
+    GF_EVENT_TRANSLATOR_INFO = 9 + 4,
+    GF_EVENT_TRANSLATOR_OP = 9 + 5,
+    GF_EVENT_AUTH_FAILED = 9 + 6,
+    GF_EVENT_VOLUME_DEFRAG = 9 + 7,
+    GF_EVENT_PARENT_DOWN = 9 + 8,
+    GF_EVENT_VOLUME_BARRIER_OP = 9 + 9,
+    GF_EVENT_UPCALL = 9 + 10,
+    GF_EVENT_SCRUB_STATUS = 9 + 11,
+    GF_EVENT_SOME_DESCENDENT_DOWN = 9 + 12,
+    GF_EVENT_SCRUB_ONDEMAND = 9 + 13,
+    GF_EVENT_SOME_DESCENDENT_UP = 9 + 14,
+    GF_EVENT_CHILD_PING = 9 + 15,
+    GF_EVENT_MAXVAL = 9 + 16,
+};
+typedef enum glusterfs_event_t glusterfs_event_t;
+
+enum gf_op_type_t {
+    GF_OP_TYPE_NULL = 0,
+    GF_OP_TYPE_FOP = 0 + 1,
+    GF_OP_TYPE_MGMT = 0 + 2,
+    GF_OP_TYPE_MAX = 0 + 3,
+};
+typedef enum gf_op_type_t gf_op_type_t;
+
+enum glusterfs_lk_cmds_t {
+    GF_LK_GETLK = 0,
+    GF_LK_SETLK = 0 + 1,
+    GF_LK_SETLKW = 0 + 2,
+    GF_LK_RESLK_LCK = 0 + 3,
+    GF_LK_RESLK_LCKW = 0 + 4,
+    GF_LK_RESLK_UNLCK = 0 + 5,
+    GF_LK_GETLK_FD = 0 + 6,
+};
+typedef enum glusterfs_lk_cmds_t glusterfs_lk_cmds_t;
+
+enum glusterfs_lk_types_t {
+    GF_LK_F_RDLCK = 0,
+    GF_LK_F_WRLCK = 0 + 1,
+    GF_LK_F_UNLCK = 0 + 2,
+    GF_LK_EOL = 0 + 3,
+};
+typedef enum glusterfs_lk_types_t glusterfs_lk_types_t;
+
+enum gf_lease_types_t {
+    NONE = 0,
+    GF_RD_LEASE = 1,
+    GF_RW_LEASE = 2,
+    GF_LEASE_MAX_TYPE = 2 + 1,
+};
+typedef enum gf_lease_types_t gf_lease_types_t;
+
+enum gf_lease_cmds_t {
+    GF_GET_LEASE = 1,
+    GF_SET_LEASE = 2,
+    GF_UNLK_LEASE = 3,
+};
+typedef enum gf_lease_cmds_t gf_lease_cmds_t;
+
+#define LEASE_ID_SIZE 16 /* 128bits */
+
+struct gf_lease {
+    gf_lease_cmds_t cmd;
+    gf_lease_types_t lease_type;
+    char lease_id[LEASE_ID_SIZE];
+    u_int lease_flags;
+};
+typedef struct gf_lease gf_lease;
+
+enum glusterfs_lk_recovery_cmds_t {
+    F_RESLK_LCK = 200,
+    F_RESLK_LCKW = 200 + 1,
+    F_RESLK_UNLCK = 200 + 2,
+    F_GETLK_FD = 200 + 3,
+};
+typedef enum glusterfs_lk_recovery_cmds_t glusterfs_lk_recovery_cmds_t;
+
+enum gf_lk_domain_t {
+    GF_LOCK_POSIX = 0,
+    GF_LOCK_INTERNAL = 1,
+};
+typedef enum gf_lk_domain_t gf_lk_domain_t;
+
+enum entrylk_cmd {
+    ENTRYLK_LOCK = 0,
+    ENTRYLK_UNLOCK = 1,
+    ENTRYLK_LOCK_NB = 2,
+};
+typedef enum entrylk_cmd entrylk_cmd;
+
+enum entrylk_type {
+    ENTRYLK_RDLCK = 0,
+    ENTRYLK_WRLCK = 1,
+};
+typedef enum entrylk_type entrylk_type;
+#define GF_MAX_LOCK_OWNER_LEN 1024 /* 1kB as per NLM */
+#define GF_LKOWNER_BUF_SIZE                                                    \
+    ((GF_MAX_LOCK_OWNER_LEN * 2) + (GF_MAX_LOCK_OWNER_LEN / 8))
+
+struct gf_lkowner_t {
+    int len;
+    char data[GF_MAX_LOCK_OWNER_LEN];
+};
+typedef struct gf_lkowner_t gf_lkowner_t;
+
+enum gf_xattrop_flags_t {
+    GF_XATTROP_ADD_ARRAY = 0,
+    GF_XATTROP_ADD_ARRAY64 = 1,
+    GF_XATTROP_OR_ARRAY = 2,
+    GF_XATTROP_AND_ARRAY = 3,
+    GF_XATTROP_GET_AND_SET = 4,
+    GF_XATTROP_ADD_ARRAY_WITH_DEFAULT = 5,
+    GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT = 6,
+};
+typedef enum gf_xattrop_flags_t gf_xattrop_flags_t;
+
+enum gf_seek_what_t {
+    GF_SEEK_DATA = 0,
+    GF_SEEK_HOLE = 1,
+};
+typedef enum gf_seek_what_t gf_seek_what_t;
+
+enum gf_upcall_flags_t {
+    GF_UPCALL_NULL = 0,
+    GF_UPCALL = 1,
+    GF_UPCALL_CI_STAT = 2,
+    GF_UPCALL_CI_XATTR = 3,
+    GF_UPCALL_CI_RENAME = 4,
+    GF_UPCALL_CI_NLINK = 5,
+    GF_UPCALL_CI_FORGET = 6,
+    GF_UPCALL_LEASE_RECALL = 7,
+    GF_UPCALL_FLAGS_MAXVALUE = 8,
+};
+typedef enum gf_upcall_flags_t gf_upcall_flags_t;
+
+enum gf_dict_data_type_t {
+    GF_DATA_TYPE_UNKNOWN = 0,
+    GF_DATA_TYPE_STR_OLD = 1,
+    GF_DATA_TYPE_INT = 2,
+    GF_DATA_TYPE_UINT = 3,
+    GF_DATA_TYPE_DOUBLE = 4,
+    GF_DATA_TYPE_STR = 5,
+    GF_DATA_TYPE_PTR = 6,
+    GF_DATA_TYPE_GFUUID = 7,
+    GF_DATA_TYPE_IATT = 8,
+    GF_DATA_TYPE_MDATA = 9,
+    GF_DATA_TYPE_MAX = 10,
+};
+typedef enum gf_dict_data_type_t gf_dict_data_type_t;
+
+#endif /* !_GLUSTERFS_FOPS_H */
diff --git a/libglusterfs/src/glusterfs/glusterfs.h b/libglusterfs/src/glusterfs/glusterfs.h
new file mode 100644
index 00000000000..e6425618b7f
--- /dev/null
+++ b/libglusterfs/src/glusterfs/glusterfs.h
@@ -0,0 +1,838 @@
+/*
+  Copyright (c) 2008-2016 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GLUSTERFS_H
+#define _GLUSTERFS_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <netdb.h>
+#include <errno.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <arpa/inet.h>
+#include <sys/poll.h>
+#include <pthread.h>
+#include <limits.h> /* For PATH_MAX */
+#include <openssl/sha.h>
+
+#include "glusterfs/glusterfs-fops.h"
+#include "glusterfs/list.h"
+#include "glusterfs/locking.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/lkowner.h"
+#include "glusterfs/compat-uuid.h"
+#include "glusterfs/refcount.h"
+#include "glusterfs/atomic.h"
+
+#define GF_YES 1
+#define GF_NO 0
+
+#define IS_ERROR(ret) ((ret) < 0)
+#define IS_SUCCESS(ret) ((ret) >= 0)
+
+#ifndef O_LARGEFILE
+/* savannah bug #20053, patch for compiling on darwin */
+#define O_LARGEFILE 0100000 /* from bits/fcntl.h */
+#endif
+
+#ifndef O_FMODE_EXEC
+/* redhat bug 843080, added from linux/fs.h */
+#define O_FMODE_EXEC 040  // 0x20
+#endif
+
+#ifndef O_DIRECT
+/* savannah bug #20050, #20052 */
+#define O_DIRECT 0 /* From asm/fcntl.h */
+#endif
+
+#ifndef O_DIRECTORY
+/* FreeBSD does not need O_DIRECTORY */
+#define O_DIRECTORY 0
+#endif
+
+#ifndef EBADFD
+/* Mac OS X does not have EBADFD */
+#define EBADFD EBADF
+#endif
+
+#ifndef FNM_EXTMATCH
+#define FNM_EXTMATCH 0
+#endif
+
+/*gets max-offset on all architectures correctly*/
+#define GF_OFF_MAX ((1ULL << (sizeof(off_t) * 8 - 1)) - 1ULL)
+
+#define GLUSTERD_MAX_SNAP_NAME 255
+#define GLUSTERFS_SOCKET_LISTEN_BACKLOG 1024
+#define GLUSTERD_BRICK_SERVERS "cluster.brick-vol-servers"
+#define SLEN(str) (sizeof(str) - 1)
+
+#define ZR_MOUNTPOINT_OPT "mountpoint"
+#define ZR_ATTR_TIMEOUT_OPT "attribute-timeout"
+#define ZR_ENTRY_TIMEOUT_OPT "entry-timeout"
+#define ZR_NEGATIVE_TIMEOUT_OPT "negative-timeout"
+#define ZR_DIRECT_IO_OPT "direct-io-mode"
+#define ZR_STRICT_VOLFILE_CHECK "strict-volfile-check"
+#define ZR_DUMP_FUSE "dump-fuse"
+#define ZR_FUSE_MOUNTOPTS "fuse-mountopts"
+#define IO_THREADS_QUEUE_SIZE_KEY "io-thread-queue-size"
+
+#define GF_XATTR_CLRLK_CMD "glusterfs.clrlk"
+#define GF_XATTR_PATHINFO_KEY "trusted.glusterfs.pathinfo"
+#define GF_XATTR_NODE_UUID_KEY "trusted.glusterfs.node-uuid"
+#define GF_XATTR_LIST_NODE_UUIDS_KEY "trusted.glusterfs.list-node-uuids"
+#define GF_REBAL_FIND_LOCAL_SUBVOL "glusterfs.find-local-subvol"
+#define GF_REBAL_OLD_FIND_LOCAL_SUBVOL "glusterfs.old-find-local-subvol"
+#define GF_XATTR_VOL_ID_KEY "trusted.glusterfs.volume-id"
+#define GF_XATTR_LOCKINFO_KEY "trusted.glusterfs.lockinfo"
+#define GF_META_LOCK_KEY "glusterfs.lock-migration-meta-lock"
+#define GF_META_UNLOCK_KEY "glusterfs.lock-migration-meta-unlock"
+#define GF_XATTR_GET_REAL_FILENAME_KEY "glusterfs.get_real_filename:"
+#define GF_XATTR_USER_PATHINFO_KEY "glusterfs.pathinfo"
+#define GF_INTERNAL_IGNORE_DEEM_STATFS "ignore-deem-statfs"
+#define GF_XATTR_IOSTATS_DUMP_KEY "trusted.io-stats-dump"
+
+#define GF_READDIR_SKIP_DIRS "readdir-filter-directories"
+#define GF_MDC_LOADED_KEY_NAMES "glusterfs.mdc.loaded.key.names"
+
+#define BD_XATTR_KEY "user.glusterfs"
+#define GF_PREOP_PARENT_KEY "glusterfs.preop.parent.key"
+#define GF_PREOP_CHECK_FAILED "glusterfs.preop.check.failed"
+
+#define XATTR_IS_PATHINFO(x)                                                   \
+    ((strncmp(x, GF_XATTR_PATHINFO_KEY, strlen(x)) == 0) ||                    \
+     (strncmp(x, GF_XATTR_USER_PATHINFO_KEY, strlen(x)) == 0))
+#define XATTR_IS_NODE_UUID(x)                                                  \
+    (strncmp(x, GF_XATTR_NODE_UUID_KEY, SLEN(GF_XATTR_NODE_UUID_KEY)) == 0)
+#define XATTR_IS_NODE_UUID_LIST(x)                                             \
+    (strncmp(x, GF_XATTR_LIST_NODE_UUIDS_KEY,                                  \
+             SLEN(GF_XATTR_LIST_NODE_UUIDS_KEY)) == 0)
+#define XATTR_IS_LOCKINFO(x)                                                   \
+    (strncmp(x, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) == 0)
+
+#define XATTR_IS_BD(x) (strncmp(x, BD_XATTR_KEY, SLEN(BD_XATTR_KEY)) == 0)
+
+#define GF_XATTR_LINKINFO_KEY "trusted.distribute.linkinfo"
+#define GFID_XATTR_KEY "trusted.gfid"
+#define PGFID_XATTR_KEY_PREFIX "trusted.pgfid."
+#define GFID2PATH_VIRT_XATTR_KEY "glusterfs.gfidtopath"
+#define GFID2PATH_XATTR_KEY_PREFIX "trusted.gfid2path."
+#define GFID2PATH_XATTR_KEY_PREFIX_LENGTH 18
+#define VIRTUAL_GFID_XATTR_KEY_STR "glusterfs.gfid.string"
+#define VIRTUAL_GFID_XATTR_KEY "glusterfs.gfid"
+#define GF_XATTR_MDATA_KEY "trusted.glusterfs.mdata"
+#define UUID_CANONICAL_FORM_LEN 36
+
+#define GET_ANCESTRY_PATH_KEY "glusterfs.ancestry.path"
+#define GET_ANCESTRY_DENTRY_KEY "glusterfs.ancestry.dentry"
+
+#define BITROT_DEFAULT_CURRENT_VERSION (unsigned long)1
+#define BITROT_DEFAULT_SIGNING_VERSION (unsigned long)0
+
+/* on-disk object signature keys */
+#define BITROT_OBJECT_BAD_KEY "trusted.bit-rot.bad-file"
+#define BITROT_CURRENT_VERSION_KEY "trusted.bit-rot.version"
+#define BITROT_SIGNING_VERSION_KEY "trusted.bit-rot.signature"
+
+/* globally usable bad file marker */
+#define GLUSTERFS_BAD_INODE "glusterfs.bad-inode"
+
+/* on-disk size of signing xattr (not the signature itself) */
+#define BITROT_SIGNING_XATTR_SIZE_KEY "trusted.glusterfs.bit-rot.size"
+
+/* GET/SET object signature */
+#define GLUSTERFS_GET_OBJECT_SIGNATURE "trusted.glusterfs.get-signature"
+#define GLUSTERFS_SET_OBJECT_SIGNATURE "trusted.glusterfs.set-signature"
+
+/* operation needs to be durable on-disk */
+#define GLUSTERFS_DURABLE_OP "trusted.glusterfs.durable-op"
+
+/* key for version exchange b/w bitrot stub and changelog */
+#define GLUSTERFS_VERSION_XCHG_KEY "glusterfs.version.xchg"
+
+#define GLUSTERFS_INTERNAL_FOP_KEY "glusterfs-internal-fop"
+
+#define GF_ENFORCE_MANDATORY_LOCK "trusted.glusterfs.enforce-mandatory-lock"
+
+/* GlusterFS Internal FOP Indicator flags
+ * (To pass information on the context in which a paritcular
+ *  fop is performed between translators)
+ * The presence of a particular flag must be treated as an
+ * indicator of the context, however the flag is added only in
+ * a scenario where there is a need for such context across translators.
+ * So it cannot be an absolute information on context.
+ */
+#define GF_INTERNAL_CTX_KEY "glusterfs.internal-ctx"
+
+/*
+ * Always append entries to end of the enum, do not delete entries.
+ * Currently dict_set_flag allows to set up to 256 flag, if the enum
+ * needs to grow beyond this dict_set_flag has to be changed accordingly
+ */
+enum gf_internal_fop_indicator {
+    GF_DHT_HEAL_DIR /* Index 0 in bit array*/
+};
+
+/* Todo:
+ * Add GF_FOP_LINK_FILE         0x2ULL
+ * address GLUSTERFS_MARKER_DONT_ACCOUNT_KEY and
+ * GLUSTERFS_INTERNAL_FOP_KEY with this flag
+ */
+
+#define DHT_CHANGELOG_RENAME_OP_KEY "changelog.rename-op"
+
+#define GLUSTERFS_WRITE_IS_APPEND "glusterfs.write-is-append"
+#define GLUSTERFS_WRITE_UPDATE_ATOMIC "glusterfs.write-update-atomic"
+#define GLUSTERFS_OPEN_FD_COUNT "glusterfs.open-fd-count"
+#define GLUSTERFS_ACTIVE_FD_COUNT "glusterfs.open-active-fd-count"
+#define GLUSTERFS_INODELK_COUNT "glusterfs.inodelk-count"
+#define GLUSTERFS_ENTRYLK_COUNT "glusterfs.entrylk-count"
+#define GLUSTERFS_POSIXLK_COUNT "glusterfs.posixlk-count"
+#define GLUSTERFS_PARENT_ENTRYLK "glusterfs.parent-entrylk"
+#define GLUSTERFS_INODELK_DOM_COUNT "glusterfs.inodelk-dom-count"
+#define GLUSTERFS_INODELK_DOM_PREFIX "glusterfs.inodelk-dom-prefix"
+#define GLUSTERFS_MULTIPLE_DOM_LK_CNT_REQUESTS "glusterfs.multi-dom-lk-cnt-req"
+#define GFID_TO_PATH_KEY "glusterfs.gfid2path"
+#define GF_XATTR_STIME_PATTERN "trusted.glusterfs.*.stime"
+#define GF_XATTR_XTIME_PATTERN "trusted.glusterfs.*.xtime"
+#define GF_XATTR_TRIGGER_SYNC "glusterfs.geo-rep.trigger-sync"
+
+/* quota xattrs */
+#define QUOTA_SIZE_KEY "trusted.glusterfs.quota.size"
+#define QUOTA_LIMIT_KEY "trusted.glusterfs.quota.limit-set"
+#define QUOTA_LIMIT_OBJECTS_KEY "trusted.glusterfs.quota.limit-objects"
+#define VIRTUAL_QUOTA_XATTR_CLEANUP_KEY "glusterfs.quota-xattr-cleanup"
+#define QUOTA_READ_ONLY_KEY "trusted.glusterfs.quota.read-only"
+
+/* ctime related */
+#define CTIME_MDATA_XDATA_KEY "set-ctime-mdata"
+
+/* afr related */
+#define AFR_XATTR_PREFIX "trusted.afr"
+
+/* Index xlator related */
+#define GF_XATTROP_INDEX_GFID "glusterfs.xattrop_index_gfid"
+#define GF_XATTROP_ENTRY_CHANGES_GFID "glusterfs.xattrop_entry_changes_gfid"
+#define GF_XATTROP_INDEX_COUNT "glusterfs.xattrop_index_count"
+#define GF_XATTROP_DIRTY_GFID "glusterfs.xattrop_dirty_gfid"
+#define GF_XATTROP_DIRTY_COUNT "glusterfs.xattrop_dirty_count"
+#define GF_XATTROP_ENTRY_IN_KEY "glusterfs.xattrop-entry-create"
+#define GF_XATTROP_ENTRY_OUT_KEY "glusterfs.xattrop-entry-delete"
+#define GF_INDEX_IA_TYPE_GET_REQ "glusterfs.index-ia-type-get-req"
+#define GF_INDEX_IA_TYPE_GET_RSP "glusterfs.index-ia-type-get-rsp"
+
+#define GF_HEAL_INFO "glusterfs.heal-info"
+#define GF_AFR_HEAL_SBRAIN "glusterfs.heal-sbrain"
+#define GF_AFR_SBRAIN_STATUS "replica.split-brain-status"
+#define GF_AFR_SBRAIN_CHOICE "replica.split-brain-choice"
+#define GF_AFR_SPB_CHOICE_TIMEOUT "replica.split-brain-choice-timeout"
+#define GF_AFR_SBRAIN_RESOLVE "replica.split-brain-heal-finalize"
+#define GF_AFR_ADD_BRICK "trusted.add-brick"
+#define GF_AFR_REPLACE_BRICK "trusted.replace-brick"
+#define GF_AFR_DIRTY "trusted.afr.dirty"
+#define GF_XATTROP_ENTRY_OUT "glusterfs.xattrop-entry-delete"
+#define GF_XATTROP_PURGE_INDEX "glusterfs.xattrop-purge-index"
+
+#define GF_GFIDLESS_LOOKUP "gfidless-lookup"
+/* replace-brick and pump related internal xattrs */
+#define RB_PUMP_CMD_START "glusterfs.pump.start"
+#define RB_PUMP_CMD_PAUSE "glusterfs.pump.pause"
+#define RB_PUMP_CMD_COMMIT "glusterfs.pump.commit"
+#define RB_PUMP_CMD_ABORT "glusterfs.pump.abort"
+#define RB_PUMP_CMD_STATUS "glusterfs.pump.status"
+
+#define GLUSTERFS_MARKER_DONT_ACCOUNT_KEY "glusters.marker.dont-account"
+#define GLUSTERFS_RDMA_INLINE_THRESHOLD (2048)
+#define GLUSTERFS_RDMA_MAX_HEADER_SIZE                                         \
+    (228) /* (sizeof (rdma_header_t)                                           \
+             + RDMA_MAX_SEGMENTS                                               \
+             * sizeof (rdma_read_chunk_t))                                     \
+             */
+
+#define GLUSTERFS_RPC_REPLY_SIZE 24
+
+#define STARTING_EVENT_THREADS 2
+
+#define DEFAULT_VAR_RUN_DIRECTORY DATADIR "/run/gluster"
+#define DEFAULT_GLUSTERFSD_MISC_DIRETORY DATADIR "/lib/misc/glusterfsd"
+#ifdef GF_LINUX_HOST_OS
+#define GLUSTERD_DEFAULT_WORKDIR DATADIR "/lib/glusterd"
+#else
+#define GLUSTERD_DEFAULT_WORKDIR DATADIR "/db/glusterd"
+#endif
+#define GF_REPLICATE_TRASH_DIR ".landfill"
+
+/* GlusterFS's maximum supported Auxiliary GIDs */
+#define GF_MAX_AUX_GROUPS 65535
+
+#define GF_UUID_BUF_SIZE 37          /* UUID_CANONICAL_FORM_LEN + NULL */
+#define GF_UUID_BNAME_BUF_SIZE (320) /* (64 + 256) */
+
+#define GF_REBALANCE_TID_KEY "rebalance-id"
+#define GF_REMOVE_BRICK_TID_KEY "remove-brick-id"
+#define GF_TIER_TID_KEY "tier-id"
+#define GF_TIER_ENABLED "tier-enabled"
+
+#define UUID_CANONICAL_FORM_LEN 36
+
+/* Adding this here instead of any glusterd*.h files as it is also required by
+ * cli
+ */
+#define DEFAULT_GLUSTERD_SOCKFILE DATADIR "/run/glusterd.socket"
+
+/* features/marker-quota also needs to have knowledge of link-files so as to
+ * exclude them from accounting.
+ */
+#define DHT_LINKFILE_MODE (S_ISVTX)
+
+#define IS_DHT_LINKFILE_MODE(iabuf)                                            \
+    ((st_mode_from_ia((iabuf)->ia_prot, (iabuf)->ia_type) & ~S_IFMT) ==        \
+     DHT_LINKFILE_MODE)
+#define DHT_LINKFILE_STR "linkto"
+#define DHT_COMMITHASH_STR "commithash"
+
+#define DHT_SKIP_NON_LINKTO_UNLINK "unlink-only-if-dht-linkto-file"
+#define TIER_SKIP_NON_LINKTO_UNLINK "unlink-only-if-tier-linkto-file"
+#define DHT_SKIP_OPEN_FD_UNLINK "dont-unlink-for-open-fd"
+#define DHT_IATT_IN_XDATA_KEY "dht-get-iatt-in-xattr"
+#define DHT_MODE_IN_XDATA_KEY "dht-get-mode-in-xattr"
+#define GET_LINK_COUNT "get-link-count"
+#define GF_GET_SIZE "get-size"
+#define GF_PRESTAT "virt-gf-prestat"
+#define GF_POSTSTAT "virt-gf-poststat"
+
+/*CTR and Marker requires inode dentry link count from posix*/
+#define GF_RESPONSE_LINK_COUNT_XDATA "gf_response_link_count"
+#define GF_REQUEST_LINK_COUNT_XDATA "gf_request_link_count"
+
+#define GF_GET_FILE_BLOCK_COUNT "gf_get_file_block_count"
+
+#define CTR_ATTACH_TIER_LOOKUP "ctr_attach_tier_lookup"
+
+#define CLIENT_CMD_CONNECT "trusted.glusterfs.client-connect"
+#define CLIENT_CMD_DISCONNECT "trusted.glusterfs.client-disconnect"
+
+#define GF_LOG_LRU_BUFSIZE_DEFAULT 5
+#define GF_LOG_LRU_BUFSIZE_MIN 0
+#define GF_LOG_LRU_BUFSIZE_MAX 20
+#define GF_LOG_LRU_BUFSIZE_MIN_STR "0"
+#define GF_LOG_LRU_BUFSIZE_MAX_STR "20"
+
+#define GF_LOG_FLUSH_TIMEOUT_DEFAULT 120
+#define GF_LOG_FLUSH_TIMEOUT_MIN 30
+#define GF_LOG_FLUSH_TIMEOUT_MAX 300
+#define GF_LOG_FLUSH_TIMEOUT_MIN_STR "30"
+#define GF_LOG_FLUSH_TIMEOUT_MAX_STR "300"
+#define GF_LOG_LOCALTIME_DEFAULT 0
+
+#define GF_NETWORK_TIMEOUT 42
+
+#define GF_BACKTRACE_LEN 4096
+#define GF_BACKTRACE_FRAME_COUNT 7
+
+#define GF_LK_ADVISORY 0  /* maps to GLFS_LK_ADVISORY from libgfapi*/
+#define GF_LK_MANDATORY 1 /* maps to GLFS_LK_MANDATORY from libgfapi*/
+#define GF_LOCK_MODE "glusterfs.lk.lkmode"
+
+#define GF_CHECK_XATTR_KEY_AND_GOTO(key, cmpkey, errval, lbl)                  \
+    do {                                                                       \
+        if (key && strcmp(key, cmpkey) == 0) {                                 \
+            errval = -EINVAL;                                                  \
+            goto lbl;                                                          \
+        }                                                                      \
+    } while (0)
+
+#define GF_CS_OBJECT_SIZE "trusted.glusterfs.cs.object_size"
+#define GF_CS_BLOCK_SIZE "trusted.glusterfs.cs.block_size"
+#define GF_CS_NUM_BLOCKS "trusted.glusterfs.cs.num_blocks"
+
+#define GF_CS_XATTR_ARCHIVE_UUID "trusted.cloudsync.uuid"
+
+#define GF_CS_OBJECT_UPLOAD_COMPLETE "trusted.glusterfs.csou.complete"
+#define GF_CS_OBJECT_REMOTE "trusted.glusterfs.cs.remote"
+#define GF_CS_OBJECT_DOWNLOADING "trusted.glusterfs.cs.downloading"
+#define GF_CS_OBJECT_DOWNLOADED "trusted.glusterfs.cs.downloaded"
+#define GF_CS_OBJECT_STATUS "trusted.glusterfs.cs.status"
+#define GF_CS_OBJECT_REPAIR "trusted.glusterfs.cs.repair"
+
+#define gf_boolean_t bool
+#define _gf_false false
+#define _gf_true true
+
+typedef enum {
+    GF_CS_LOCAL = 1,
+    GF_CS_REMOTE = 2,
+    GF_CS_REPAIR = 4,
+    GF_CS_DOWNLOADING = 8,
+    GF_CS_ERROR = 16,
+} gf_cs_obj_state;
+
+typedef enum {
+    GF_FOP_PRI_UNSPEC = -1, /* Priority not specified */
+    GF_FOP_PRI_HI = 0,      /* low latency */
+    GF_FOP_PRI_NORMAL,      /* normal */
+    GF_FOP_PRI_LO,          /* bulk */
+    GF_FOP_PRI_LEAST,       /* least */
+    GF_FOP_PRI_MAX,         /* Highest */
+} gf_fop_pri_t;
+
+typedef enum {
+    /* The 'component' (xlator / option) is not yet setting the flag */
+    GF_UNCLASSIFIED = 0,
+    /* The 'component' is experimental, should not be recommened
+       in production mode */
+    GF_EXPERIMENTAL,
+    /* The 'component' is tech preview, ie, it is 'mostly' working as
+       expected, but can have some of the corner cases, which is not
+       handled. */
+    GF_TECH_PREVIEW,
+    /* The 'component' is good to run. Has good enough test and
+       documentation coverage. */
+    GF_MAINTAINED,
+    /* The component is:
+       - no more a focus
+       - no more solving a valid use case
+       - no more maintained, no volunteers to maintain
+       - there is 'maintained' or 'tech-preview' feature,
+       which does the same thing, better.
+    */
+    GF_DEPRECATED,
+    /* The 'component' is no more 'built'. */
+    GF_OBSOLETE,
+    /* The 'component' exist for Documentation purposes.
+       No real usecase */
+    GF_DOCUMENT_PURPOSE,
+} gf_category_t;
+
+static const char *const FOP_PRI_STRINGS[] = {"HIGH", "NORMAL", "LOW", "LEAST"};
+
+static inline const char *
+fop_pri_to_string(gf_fop_pri_t pri)
+{
+    if (IS_ERROR(pri))
+        return "UNSPEC";
+
+    if (pri >= GF_FOP_PRI_MAX)
+        return "INVALID";
+
+    return FOP_PRI_STRINGS[pri];
+}
+
+const char *
+fop_enum_to_pri_string(glusterfs_fop_t fop);
+
+#define GF_SET_IF_NOT_PRESENT 0x1 /* default behaviour */
+#define GF_SET_OVERWRITE 0x2      /* Overwrite with the buf given */
+#define GF_SET_DIR_ONLY 0x4
+#define GF_SET_EPOCH_TIME 0x8    /* used by afr dir lookup selfheal */
+#define GF_AUXILLARY_PARGFID 0xd /* RIO dummy parent gfid */
+
+/* key value which quick read uses to get small files in lookup cbk */
+#define GF_CONTENT_KEY "glusterfs.content"
+
+struct _xlator_cmdline_option {
+    struct list_head cmd_args;
+    char *volume;
+    char *key;
+    char *value;
+};
+typedef struct _xlator_cmdline_option xlator_cmdline_option_t;
+
+struct _server_cmdline {
+    struct list_head list;
+    char *volfile_server;
+    char *transport;
+    int port;
+};
+typedef struct _server_cmdline server_cmdline_t;
+
+#define GF_OPTION_ENABLE _gf_true
+#define GF_OPTION_DISABLE _gf_false
+#define GF_OPTION_DEFERRED 2
+
+typedef enum { _gf_none, _gf_memcheck, _gf_drd } gf_valgrind_tool;
+
+struct _cmd_args {
+    /* basic options */
+    char *volfile_server;
+    server_cmdline_t *curr_server;
+    /* List of backup  volfile servers, including original */
+    struct list_head volfile_servers;
+    char *volfile;
+    char *log_server;
+    gf_loglevel_t log_level;
+    char *log_file;
+    char *log_ident;
+    gf_log_logger_t logger;
+    gf_log_format_t log_format;
+    uint32_t log_buf_size;
+    uint32_t log_flush_timeout;
+    int32_t max_connect_attempts;
+    char *print_exports;
+    char *print_netgroups;
+    int print_xlatordir;
+    int print_statedumpdir;
+    int print_logdir;
+    int print_libexecdir;
+    /* advanced options */
+    uint32_t volfile_server_port;
+    char *volfile_server_transport;
+    uint32_t log_server_port;
+    char *pid_file;
+    char *sock_file;
+    int no_daemon_mode;
+    char *run_id;
+    int debug_mode;
+    int read_only;
+    int acl;
+    int selinux;
+    int capability;
+    int enable_ino32;
+    int worm;
+    int mac_compat;
+    int fopen_keep_cache;
+    int gid_timeout;
+    char gid_timeout_set;
+    int aux_gfid_mount;
+
+    /* need a process wide timer-wheel? */
+    int global_timer_wheel;
+
+    /* list of xlator_option_t */
+    struct list_head xlator_options;
+
+    /* fuse options */
+    int fuse_direct_io_mode;
+    char *use_readdirp;
+    int no_root_squash;
+    int volfile_check;
+    double fuse_entry_timeout;
+    double fuse_negative_timeout;
+    double fuse_attribute_timeout;
+    char *volume_name;
+    int fuse_nodev;
+    int fuse_nosuid;
+    char *dump_fuse;
+    pid_t client_pid;
+    int client_pid_set;
+    unsigned uid_map_root;
+    int32_t lru_limit;
+    int32_t invalidate_limit;
+    int background_qlen;
+    int congestion_threshold;
+    char *fuse_mountopts;
+    int mem_acct;
+    int resolve_gids;
+
+    /* key args */
+    char *mount_point;
+    char *volfile_id;
+
+    /* required for portmap */
+    int brick_port;
+    char *brick_name;
+    int brick_port2;
+
+    /* Should management connections use SSL? */
+    int secure_mgmt;
+
+    /* Linux-only OOM killer adjustment */
+#ifdef GF_LINUX_HOST_OS
+    char *oom_score_adj;
+#endif
+
+    /* Run this process with valgrind? Might want to prevent calling
+     * functions that prevent valgrind from working correctly, like
+     * dlclose(). */
+    gf_valgrind_tool vgtool;
+
+    int localtime_logging;
+
+    /* For the subdir mount */
+    char *subdir_mount;
+
+    char *process_name;
+    char *event_history;
+    int thin_client;
+    uint32_t reader_thread_count;
+
+    /* FUSE writeback cache support */
+    int kernel_writeback_cache;
+    uint32_t attr_times_granularity;
+
+    int fuse_flush_handle_interrupt;
+    int fuse_auto_inval;
+
+    bool global_threading;
+    bool brick_mux;
+
+    uint32_t fuse_dev_eperm_ratelimit_ns;
+};
+typedef struct _cmd_args cmd_args_t;
+
+struct _glusterfs_graph {
+    struct list_head list;
+    struct timeval dob;
+    void *first;
+    void *top; /* selected by -n */
+    int xl_count;
+    int id;   /* Used in logging */
+    int used; /* Should be set when fuse gets
+                        first CHILD_UP */
+    uint32_t volfile_checksum;
+    uint32_t leaf_count;
+    void *last_xl; /* Stores the last xl of the graph, as of now only populated
+                      in client multiplexed code path */
+    pthread_mutex_t mutex;
+    pthread_cond_t child_down_cond; /* for broadcasting CHILD_DOWN */
+    int parent_down;
+    char graph_uuid[128];
+    char volume_id[GF_UUID_BUF_SIZE];
+};
+typedef struct _glusterfs_graph glusterfs_graph_t;
+
+typedef int32_t (*glusterfsd_mgmt_event_notify_fn_t)(int32_t event, void *data,
+                                                     ...);
+
+typedef enum {
+    MGMT_SSL_NEVER = 0,
+    MGMT_SSL_COPY_IO,
+    MGMT_SSL_ALWAYS
+} mgmt_ssl_t;
+
+struct tvec_base;
+
+/* reference counting for the global (per ctx) timer-wheel */
+struct gf_ctx_tw {
+    GF_REF_DECL;
+    struct tvec_base *timer_wheel; /* global timer-wheel instance */
+};
+
+struct _glusterfs_ctx {
+    cmd_args_t cmd_args;
+    char *process_uuid;
+    FILE *pidfp;
+    char fin;
+    void *timer;
+    void *ib;
+    struct call_pool *pool;
+    void *event_pool;
+    void *iobuf_pool;
+    void *logbuf_pool;
+    gf_lock_t lock;
+    size_t page_size;
+
+    /* one per volfile parse */
+    struct list_head graphs;
+
+    /* the latest graph in use */
+    glusterfs_graph_t *active;
+
+    /* fuse or nfs (but not protocol/server) */
+    void *master;
+
+    /* xlator implementing MOPs for centralized logging, volfile server */
+    void *mgmt;
+
+    /* listener of the commands from glusterd */
+    void *listener;
+
+    /* toggle switch for latency measurement */
+    unsigned char measure_latency;
+    pthread_t sigwaiter;
+    char *cmdlinestr;
+    struct mem_pool *stub_mem_pool;
+    unsigned char cleanup_started;
+    int graph_id;        /* Incremented per graph, value should
+                            indicate how many times the graph has
+                            got changed */
+    pid_t mnt_pid;       /* pid of the mount agent */
+    int process_mode;    /*mode in which process is runninng*/
+    struct syncenv *env; /* The env pointer to the synctasks */
+
+    struct list_head mempool_list; /* used to keep a global list of
+                                      mempools, used to log details of
+                                      mempool in statedump */
+    char *statedump_path;
+
+    struct mem_pool *dict_pool;
+    struct mem_pool *dict_pair_pool;
+    struct mem_pool *dict_data_pool;
+
+    glusterfsd_mgmt_event_notify_fn_t notify; /* Used for xlators to make
+                                                 call to fsd-mgmt */
+    gf_log_handle_t log; /* all logging related variables */
+
+    int mem_acct_enable;
+
+    int daemon_pipe[2];
+
+    struct clienttable *clienttable;
+
+    /*
+     * Should management connections use SSL?  This is the only place we
+     * can put it where both daemon-startup and socket code will see it.
+     *
+     * Why is it an int?  Because we're included before common-utils.h,
+     * which defines gf_boolean_t (what we really want).  It doesn't make
+     * any sense, but it's not worth turning the codebase upside-down to
+     * fix it.  Thus, an int.
+     */
+    int secure_mgmt;
+
+    /* The option is use to set cert_depth while management connection
+       use SSL
+     */
+    int ssl_cert_depth;
+
+    /*
+     * Should *our* server/inbound connections use SSL?  This is only true
+     * if we're glusterd and secure_mgmt is set, or if we're glusterfsd
+     * and SSL is set on the I/O path.  It should never be set e.g. for
+     * NFS.
+     */
+    mgmt_ssl_t secure_srvr;
+    /* Buffer to 'save' backtrace even under OOM-kill like situations*/
+    char btbuf[GF_BACKTRACE_LEN];
+
+    pthread_mutex_t notify_lock;
+    pthread_mutex_t cleanup_lock;
+    pthread_cond_t notify_cond;
+    int notifying;
+
+    struct gf_ctx_tw *tw; /* refcounted timer_wheel */
+
+    gf_lock_t volfile_lock;
+
+    /* configuration related elements, which gets changed
+       from global xlator */
+    struct {
+        char *metrics_dumppath;
+    } config;
+
+    struct {
+        gf_atomic_t max_dict_pairs;
+        gf_atomic_t total_pairs_used;
+        gf_atomic_t total_dicts_used;
+    } stats;
+
+    struct list_head volfile_list;
+    /* Add members to manage janitor threads for cleanup fd */
+    struct list_head janitor_fds;
+    pthread_cond_t fd_cond;
+    pthread_mutex_t fd_lock;
+    pthread_t janitor;
+    /* The variable is use to save total posix xlator count */
+    uint32_t pxl_count;
+
+    char volume_id[GF_UUID_BUF_SIZE]; /* Used only in protocol/client */
+};
+typedef struct _glusterfs_ctx glusterfs_ctx_t;
+
+typedef struct {
+    char volfile_checksum[SHA256_DIGEST_LENGTH];
+    char vol_id[NAME_MAX + 1];
+    struct list_head volfile_list;
+    glusterfs_graph_t *graph;
+    FILE *pidfp;
+} gf_volfile_t;
+
+glusterfs_ctx_t *
+glusterfs_ctx_new(void);
+
+struct gf_flock {
+    short l_type;
+    short l_whence;
+    off_t l_start;
+    off_t l_len;
+    pid_t l_pid;
+    gf_lkowner_t l_owner;
+};
+
+typedef struct lock_migration_info {
+    struct list_head list;
+    struct gf_flock flock;
+    char *client_uid;
+    uint32_t lk_flags;
+} lock_migration_info_t;
+
+#define GF_MUST_CHECK __attribute__((warn_unused_result))
+/*
+ * Some macros (e.g. ALLOC_OR_GOTO) set variables in function scope, but the
+ * calling function might not only declare the variable to keep the macro happy
+ * and not use it otherwise.  In such cases, the following can be used to
+ * suppress the "set but not used" warning that would otherwise occur.
+ */
+#define GF_UNUSED __attribute__((unused))
+
+/*
+ * If present, this has the following effects:
+ *
+ *      glusterd enables privileged commands over TCP
+ *
+ *      all code enables SSL for outbound connections to management port
+ *
+ *      glusterd enables SSL for inbound connections
+ *
+ * Servers and clients enable/disable SSL among themselves by other means.
+ * Making secure management connections conditional on a file is a bit of a
+ * hack, but we don't have any other place for such global settings across
+ * all of the affected components.  Making it a compile-time option would
+ * reduce functionality, both for users and for testing (which can now be
+ * done using secure connections for all tests without change elsewhere).
+ *
+ */
+#define SECURE_ACCESS_FILE GLUSTERD_DEFAULT_WORKDIR "/secure-access"
+
+int
+glusterfs_graph_prepare(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+                        char *volume_name);
+int
+glusterfs_graph_destroy_residual(glusterfs_graph_t *graph);
+int
+glusterfs_graph_deactivate(glusterfs_graph_t *graph);
+int
+glusterfs_graph_destroy(glusterfs_graph_t *graph);
+int
+glusterfs_get_leaf_count(glusterfs_graph_t *graph);
+int
+glusterfs_graph_activate(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx);
+glusterfs_graph_t *
+glusterfs_graph_construct(FILE *fp);
+int
+glusterfs_graph_init(glusterfs_graph_t *graph);
+glusterfs_graph_t *
+glusterfs_graph_new(void);
+int
+glusterfs_graph_reconfigure(glusterfs_graph_t *oldgraph,
+                            glusterfs_graph_t *newgraph);
+int
+glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path,
+                       glusterfs_graph_t **newgraph);
+int
+glusterfs_graph_parent_up(glusterfs_graph_t *graph);
+
+void
+gf_free_mig_locks(lock_migration_info_t *locks);
+
+int
+glusterfs_read_secure_access_file(void);
+int
+glusterfs_graph_fini(glusterfs_graph_t *graph);
+#endif /* _GLUSTERFS_H */
diff --git a/libglusterfs/src/graph-utils.h b/libglusterfs/src/glusterfs/graph-utils.h
index 207664fdb1f..247f1a55d5a 100644
--- a/libglusterfs/src/graph-utils.h
+++ b/libglusterfs/src/glusterfs/graph-utils.h
@@ -11,10 +11,10 @@
 #ifndef _GRAPH_H_
 #define _GRAPH_H_
 
-int glusterfs_graph_print_file (FILE *file, glusterfs_graph_t *graph);
-
-char *glusterfs_graph_print_buf (glusterfs_graph_t *graph);
-
-int glusterfs_xlator_link (xlator_t *pxl, xlator_t *cxl);
-void glusterfs_graph_set_first (glusterfs_graph_t *graph, xlator_t *xl);
+int
+glusterfs_graph_print_file(FILE *file, glusterfs_graph_t *graph);
+int
+glusterfs_xlator_link(xlator_t *pxl, xlator_t *cxl);
+void
+glusterfs_graph_set_first(glusterfs_graph_t *graph, xlator_t *xl);
 #endif
diff --git a/libglusterfs/src/hashfn.h b/libglusterfs/src/glusterfs/hashfn.h
index fed464e11cd..6e92e706d8c 100644
--- a/libglusterfs/src/hashfn.h
+++ b/libglusterfs/src/glusterfs/hashfn.h
@@ -14,9 +14,10 @@
 #include <sys/types.h>
 #include <stdint.h>
 
-uint32_t SuperFastHash (const char * data, int32_t len);
+uint32_t
+SuperFastHash(const char *data, int32_t len);
 
-uint32_t gf_dm_hashfn (const char *msg, int len);
+uint32_t
+gf_dm_hashfn(const char *msg, int len);
 
-uint32_t ReallySimpleHash (char *path, int len);
 #endif /* __HASHFN_H__ */
diff --git a/libglusterfs/src/glusterfs/iatt.h b/libglusterfs/src/glusterfs/iatt.h
new file mode 100644
index 00000000000..f03d68b02f0
--- /dev/null
+++ b/libglusterfs/src/glusterfs/iatt.h
@@ -0,0 +1,489 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _IATT_H
+#define _IATT_H
+
+#if defined(GF_LINUX_HOST_OS)
+#include <sys/sysmacros.h> /* for makedev(3), major(3), minor(3) */
+#endif
+#include <sys/types.h>
+#include <sys/stat.h> /* for iatt <--> stat conversions */
+#include <unistd.h>
+
+#include "glusterfs/compat.h"
+#include "glusterfs/compat-uuid.h"
+
+typedef enum {
+    IA_INVAL = 0,
+    IA_IFREG,
+    IA_IFDIR,
+    IA_IFLNK,
+    IA_IFBLK,
+    IA_IFCHR,
+    IA_IFIFO,
+    IA_IFSOCK
+} ia_type_t;
+
+typedef struct {
+    uint8_t suid : 1;
+    uint8_t sgid : 1;
+    uint8_t sticky : 1;
+    struct {
+        uint8_t read : 1;
+        uint8_t write : 1;
+        uint8_t exec : 1;
+    } owner, group, other;
+} ia_prot_t;
+
+struct iatt {
+    uint64_t ia_flags;
+    uint64_t ia_ino;     /* inode number */
+    uint64_t ia_dev;     /* backing device ID */
+    uint64_t ia_rdev;    /* device ID (if special file) */
+    uint64_t ia_size;    /* file size in bytes */
+    uint32_t ia_nlink;   /* Link count */
+    uint32_t ia_uid;     /* user ID of owner */
+    uint32_t ia_gid;     /* group ID of owner */
+    uint32_t ia_blksize; /* blocksize for filesystem I/O */
+    uint64_t ia_blocks;  /* number of 512B blocks allocated */
+    int64_t ia_atime;    /* last access time */
+    int64_t ia_mtime;    /* last modification time */
+    int64_t ia_ctime;    /* last status change time */
+    int64_t ia_btime;    /* creation time. Fill using statx */
+    uint32_t ia_atime_nsec;
+    uint32_t ia_mtime_nsec;
+    uint32_t ia_ctime_nsec;
+    uint32_t ia_btime_nsec;
+    uint64_t ia_attributes;      /* chattr related:compressed, immutable,
+                                  * append only, encrypted etc.*/
+    uint64_t ia_attributes_mask; /* Mask for the attributes */
+
+    uuid_t ia_gfid;
+    ia_type_t ia_type; /* type of file */
+    ia_prot_t ia_prot; /* protection */
+};
+
+struct old_iatt {
+    uint64_t ia_ino; /* inode number */
+    uuid_t ia_gfid;
+    uint64_t ia_dev;     /* backing device ID */
+    ia_type_t ia_type;   /* type of file */
+    ia_prot_t ia_prot;   /* protection */
+    uint32_t ia_nlink;   /* Link count */
+    uint32_t ia_uid;     /* user ID of owner */
+    uint32_t ia_gid;     /* group ID of owner */
+    uint64_t ia_rdev;    /* device ID (if special file) */
+    uint64_t ia_size;    /* file size in bytes */
+    uint32_t ia_blksize; /* blocksize for filesystem I/O */
+    uint64_t ia_blocks;  /* number of 512B blocks allocated */
+    uint32_t ia_atime;   /* last access time */
+    uint32_t ia_atime_nsec;
+    uint32_t ia_mtime; /* last modification time */
+    uint32_t ia_mtime_nsec;
+    uint32_t ia_ctime; /* last status change time */
+    uint32_t ia_ctime_nsec;
+};
+
+struct mdata_iatt {
+    int64_t ia_atime; /* last access time */
+    int64_t ia_mtime; /* last modification time */
+    int64_t ia_ctime; /* last status change time */
+    uint32_t ia_atime_nsec;
+    uint32_t ia_mtime_nsec;
+    uint32_t ia_ctime_nsec;
+};
+
+/* 64-bit mask for valid members in struct iatt. */
+#define IATT_TYPE 0x0000000000000001U
+#define IATT_MODE 0x0000000000000002U
+#define IATT_NLINK 0x0000000000000004U
+#define IATT_UID 0x0000000000000008U
+#define IATT_GID 0x0000000000000010U
+#define IATT_ATIME 0x0000000000000020U
+#define IATT_MTIME 0x0000000000000040U
+#define IATT_CTIME 0x0000000000000080U
+#define IATT_INO 0x0000000000000100U
+#define IATT_SIZE 0x0000000000000200U
+#define IATT_BLOCKS 0x0000000000000400U
+#define IATT_BTIME 0x0000000000000800U
+#define IATT_GFID 0x0000000000001000U
+
+/* Macros for checking validity of struct iatt members.*/
+#define IATT_TYPE_VALID(iaflags) (iaflags & IATT_TYPE)
+#define IATT_MODE_VALID(iaflags) (iaflags & IATT_MODE)
+#define IATT_NLINK_VALID(iaflags) (iaflags & IATT_NLINK)
+#define IATT_UID_VALID(iaflags) (iaflags & IATT_UID)
+#define IATT_GID_VALID(iaflags) (iaflags & IATT_GID)
+#define IATT_ATIME_VALID(iaflags) (iaflags & IATT_ATIME)
+#define IATT_MTIME_VALID(iaflags) (iaflags & IATT_MTIME)
+#define IATT_CTIME_VALID(iaflags) (iaflags & IATT_CTIME)
+#define IATT_INO_VALID(iaflags) (iaflags & IATT_INO)
+#define IATT_SIZE_VALID(iaflags) (iaflags & IATT_SIZE)
+#define IATT_BLOCKS_VALID(iaflags) (iaflags & IATT_BLOCKS)
+#define IATT_BTIME_VALID(iaflags) (iaflags & IATT_BTIME)
+#define IATT_GFID_VALID(iaflags) (iaflags & IATT_GFID)
+
+#define IA_ISREG(t) (t == IA_IFREG)
+#define IA_ISDIR(t) (t == IA_IFDIR)
+#define IA_ISLNK(t) (t == IA_IFLNK)
+#define IA_ISBLK(t) (t == IA_IFBLK)
+#define IA_ISCHR(t) (t == IA_IFCHR)
+#define IA_ISFIFO(t) (t == IA_IFIFO)
+#define IA_ISSOCK(t) (t == IA_IFSOCK)
+#define IA_ISINVAL(t) (t == IA_INVAL)
+
+#define IA_PROT_RUSR(prot) ((prot).owner.read == 1)
+#define IA_PROT_WUSR(prot) ((prot).owner.write == 1)
+#define IA_PROT_XUSR(prot) ((prot).owner.exec == 1)
+
+#define IA_PROT_RGRP(prot) ((prot).group.read == 1)
+#define IA_PROT_WGRP(prot) ((prot).group.write == 1)
+#define IA_PROT_XGRP(prot) ((prot).group.exec == 1)
+
+#define IA_PROT_ROTH(prot) ((prot).other.read == 1)
+#define IA_PROT_WOTH(prot) ((prot).other.write == 1)
+#define IA_PROT_XOTH(prot) ((prot).other.exec == 1)
+
+#define IA_PROT_SUID(prot) ((prot).suid == 1)
+#define IA_PROT_SGID(prot) ((prot).sgid == 1)
+#define IA_PROT_STCKY(prot) ((prot).sticky == 1)
+
+#define IA_FILE_OR_DIR(t) (IA_ISREG(t) || IA_ISDIR(t))
+
+static inline uint32_t
+ia_major(uint64_t ia_dev)
+{
+    return (uint32_t)(ia_dev >> 32);
+}
+
+static inline uint32_t
+ia_minor(uint64_t ia_dev)
+{
+    return (uint32_t)(ia_dev & 0xffffffff);
+}
+
+static inline uint64_t
+ia_makedev(uint32_t ia_maj, uint32_t ia_min)
+{
+    return ((((uint64_t)ia_maj) << 32) | ia_min);
+}
+
+static inline ia_prot_t
+ia_prot_from_st_mode(mode_t mode)
+{
+    ia_prot_t ia_prot = {
+        0,
+    };
+
+    if (mode & S_ISUID)
+        ia_prot.suid = 1;
+    if (mode & S_ISGID)
+        ia_prot.sgid = 1;
+    if (mode & S_ISVTX)
+        ia_prot.sticky = 1;
+
+    if (mode & S_IRUSR)
+        ia_prot.owner.read = 1;
+    if (mode & S_IWUSR)
+        ia_prot.owner.write = 1;
+    if (mode & S_IXUSR)
+        ia_prot.owner.exec = 1;
+
+    if (mode & S_IRGRP)
+        ia_prot.group.read = 1;
+    if (mode & S_IWGRP)
+        ia_prot.group.write = 1;
+    if (mode & S_IXGRP)
+        ia_prot.group.exec = 1;
+
+    if (mode & S_IROTH)
+        ia_prot.other.read = 1;
+    if (mode & S_IWOTH)
+        ia_prot.other.write = 1;
+    if (mode & S_IXOTH)
+        ia_prot.other.exec = 1;
+
+    return ia_prot;
+}
+
+static inline ia_type_t
+ia_type_from_st_mode(mode_t mode)
+{
+    ia_type_t type = IA_INVAL;
+
+    if (S_ISREG(mode))
+        type = IA_IFREG;
+    if (S_ISDIR(mode))
+        type = IA_IFDIR;
+    if (S_ISLNK(mode))
+        type = IA_IFLNK;
+    if (S_ISBLK(mode))
+        type = IA_IFBLK;
+    if (S_ISCHR(mode))
+        type = IA_IFCHR;
+    if (S_ISFIFO(mode))
+        type = IA_IFIFO;
+    if (S_ISSOCK(mode))
+        type = IA_IFSOCK;
+
+    return type;
+}
+
+static inline uint32_t
+st_mode_prot_from_ia(ia_prot_t prot)
+{
+    uint32_t prot_bit = 0;
+
+    if (prot.suid)
+        prot_bit |= S_ISUID;
+    if (prot.sgid)
+        prot_bit |= S_ISGID;
+    if (prot.sticky)
+        prot_bit |= S_ISVTX;
+
+    if (prot.owner.read)
+        prot_bit |= S_IRUSR;
+    if (prot.owner.write)
+        prot_bit |= S_IWUSR;
+    if (prot.owner.exec)
+        prot_bit |= S_IXUSR;
+
+    if (prot.group.read)
+        prot_bit |= S_IRGRP;
+    if (prot.group.write)
+        prot_bit |= S_IWGRP;
+    if (prot.group.exec)
+        prot_bit |= S_IXGRP;
+
+    if (prot.other.read)
+        prot_bit |= S_IROTH;
+    if (prot.other.write)
+        prot_bit |= S_IWOTH;
+    if (prot.other.exec)
+        prot_bit |= S_IXOTH;
+
+    return prot_bit;
+}
+
+static inline uint32_t
+st_mode_type_from_ia(ia_type_t type)
+{
+    uint32_t type_bit = 0;
+
+    switch (type) {
+        case IA_IFREG:
+            type_bit = S_IFREG;
+            break;
+        case IA_IFDIR:
+            type_bit = S_IFDIR;
+            break;
+        case IA_IFLNK:
+            type_bit = S_IFLNK;
+            break;
+        case IA_IFBLK:
+            type_bit = S_IFBLK;
+            break;
+        case IA_IFCHR:
+            type_bit = S_IFCHR;
+            break;
+        case IA_IFIFO:
+            type_bit = S_IFIFO;
+            break;
+        case IA_IFSOCK:
+            type_bit = S_IFSOCK;
+            break;
+        case IA_INVAL:
+            break;
+    }
+
+    return type_bit;
+}
+
+static inline mode_t
+st_mode_from_ia(ia_prot_t prot, ia_type_t type)
+{
+    mode_t st_mode = 0;
+    uint32_t type_bit = 0;
+    uint32_t prot_bit = 0;
+
+    type_bit = st_mode_type_from_ia(type);
+    prot_bit = st_mode_prot_from_ia(prot);
+
+    st_mode = (type_bit | prot_bit);
+
+    return st_mode;
+}
+
+static inline void
+iatt_to_mdata(struct mdata_iatt *mdata, struct iatt *iatt)
+{
+    mdata->ia_atime = iatt->ia_atime;
+    mdata->ia_atime_nsec = iatt->ia_atime_nsec;
+    mdata->ia_mtime = iatt->ia_mtime;
+    mdata->ia_mtime_nsec = iatt->ia_mtime_nsec;
+    mdata->ia_ctime = iatt->ia_ctime;
+    mdata->ia_ctime_nsec = iatt->ia_ctime_nsec;
+}
+
+static inline int
+iatt_from_stat(struct iatt *iatt, struct stat *stat)
+{
+    iatt->ia_dev = stat->st_dev;
+    iatt->ia_ino = stat->st_ino;
+
+    iatt->ia_type = ia_type_from_st_mode(stat->st_mode);
+    iatt->ia_prot = ia_prot_from_st_mode(stat->st_mode);
+
+    iatt->ia_nlink = stat->st_nlink;
+    iatt->ia_uid = stat->st_uid;
+    iatt->ia_gid = stat->st_gid;
+
+    iatt->ia_rdev = ia_makedev(major(stat->st_rdev), minor(stat->st_rdev));
+
+    iatt->ia_size = stat->st_size;
+    iatt->ia_blksize = stat->st_blksize;
+    iatt->ia_blocks = stat->st_blocks;
+
+    /* There is a possibility that the backend FS (like XFS) can
+       allocate blocks beyond EOF for better performance reasons, which
+       results in 'st_blocks' with higher values than what is consumed by
+       the file descriptor. This would break few logic inside GlusterFS,
+       like quota behavior etc, thus we need the exact number of blocks
+       which are consumed by the file to the higher layers inside GlusterFS.
+       Currently, this logic won't work for sparse files (ie, file with
+       holes)
+    */
+    {
+        uint64_t maxblocks;
+
+        maxblocks = (iatt->ia_size + 511) / 512;
+
+        if (iatt->ia_blocks > maxblocks)
+            iatt->ia_blocks = maxblocks;
+    }
+
+    iatt->ia_atime = stat->st_atime;
+    iatt->ia_atime_nsec = ST_ATIM_NSEC(stat);
+
+    iatt->ia_mtime = stat->st_mtime;
+    iatt->ia_mtime_nsec = ST_MTIM_NSEC(stat);
+
+    iatt->ia_ctime = stat->st_ctime;
+    iatt->ia_ctime_nsec = ST_CTIM_NSEC(stat);
+
+    /* Setting IATT_INO in ia_flags is done in posix_fill_ino_from_gfid. */
+    iatt->ia_flags = iatt->ia_flags | IATT_TYPE | IATT_MODE | IATT_NLINK |
+                     IATT_UID | IATT_GID | IATT_SIZE | IATT_BLOCKS |
+                     IATT_ATIME | IATT_MTIME | IATT_CTIME;
+
+    return 0;
+}
+
+static inline int
+iatt_to_stat(struct iatt *iatt, struct stat *stat)
+{
+    stat->st_dev = iatt->ia_dev;
+    stat->st_ino = iatt->ia_ino;
+
+    stat->st_mode = st_mode_from_ia(iatt->ia_prot, iatt->ia_type);
+
+    stat->st_nlink = iatt->ia_nlink;
+    stat->st_uid = iatt->ia_uid;
+    stat->st_gid = iatt->ia_gid;
+
+    stat->st_rdev = makedev(ia_major(iatt->ia_rdev), ia_minor(iatt->ia_rdev));
+
+    stat->st_size = iatt->ia_size;
+    stat->st_blksize = iatt->ia_blksize;
+    stat->st_blocks = iatt->ia_blocks;
+
+    stat->st_atime = iatt->ia_atime;
+    ST_ATIM_NSEC_SET(stat, iatt->ia_atime_nsec);
+
+    stat->st_mtime = iatt->ia_mtime;
+    ST_MTIM_NSEC_SET(stat, iatt->ia_mtime_nsec);
+
+    stat->st_ctime = iatt->ia_ctime;
+    ST_CTIM_NSEC_SET(stat, iatt->ia_ctime_nsec);
+
+    return 0;
+}
+
+static inline void
+oldiatt_from_iatt(struct old_iatt *o_iatt, struct iatt *c_iatt)
+{
+    o_iatt->ia_dev = c_iatt->ia_dev;
+    o_iatt->ia_ino = c_iatt->ia_ino;
+    o_iatt->ia_type = c_iatt->ia_type;
+    o_iatt->ia_prot = c_iatt->ia_prot;
+    o_iatt->ia_nlink = c_iatt->ia_nlink;
+    o_iatt->ia_uid = c_iatt->ia_uid;
+    o_iatt->ia_gid = c_iatt->ia_gid;
+    o_iatt->ia_rdev = c_iatt->ia_rdev;
+    o_iatt->ia_size = c_iatt->ia_size;
+    o_iatt->ia_blksize = c_iatt->ia_blksize;
+    o_iatt->ia_blocks = c_iatt->ia_blocks;
+    o_iatt->ia_atime = c_iatt->ia_atime;
+    o_iatt->ia_atime_nsec = c_iatt->ia_atime_nsec;
+    o_iatt->ia_mtime = c_iatt->ia_mtime;
+    o_iatt->ia_mtime_nsec = c_iatt->ia_mtime_nsec;
+    o_iatt->ia_ctime = c_iatt->ia_ctime;
+    o_iatt->ia_ctime_nsec = c_iatt->ia_ctime_nsec;
+
+    gf_uuid_copy(o_iatt->ia_gfid, c_iatt->ia_gfid);
+
+    return;
+}
+
+static inline void
+iatt_from_oldiatt(struct iatt *c_iatt, struct old_iatt *o_iatt)
+{
+    c_iatt->ia_dev = o_iatt->ia_dev;
+    c_iatt->ia_ino = o_iatt->ia_ino;
+    c_iatt->ia_type = o_iatt->ia_type;
+    c_iatt->ia_prot = o_iatt->ia_prot;
+    c_iatt->ia_nlink = o_iatt->ia_nlink;
+    c_iatt->ia_uid = o_iatt->ia_uid;
+    c_iatt->ia_gid = o_iatt->ia_gid;
+    c_iatt->ia_rdev = o_iatt->ia_rdev;
+    c_iatt->ia_size = o_iatt->ia_size;
+    c_iatt->ia_blksize = o_iatt->ia_blksize;
+    c_iatt->ia_blocks = o_iatt->ia_blocks;
+    c_iatt->ia_atime = o_iatt->ia_atime;
+    c_iatt->ia_atime_nsec = o_iatt->ia_atime_nsec;
+    c_iatt->ia_mtime = o_iatt->ia_mtime;
+    c_iatt->ia_mtime_nsec = o_iatt->ia_mtime_nsec;
+    c_iatt->ia_ctime = o_iatt->ia_ctime;
+    c_iatt->ia_ctime_nsec = o_iatt->ia_ctime_nsec;
+
+    gf_uuid_copy(c_iatt->ia_gfid, o_iatt->ia_gfid);
+
+    c_iatt->ia_attributes = 0;
+
+    c_iatt->ia_flags = IATT_TYPE | IATT_MODE | IATT_NLINK | IATT_INO |
+                       IATT_UID | IATT_GID | IATT_SIZE | IATT_BLOCKS |
+                       IATT_ATIME | IATT_MTIME | IATT_CTIME | IATT_GFID;
+
+    return;
+}
+
+static inline int
+is_same_mode(ia_prot_t prot1, ia_prot_t prot2)
+{
+    int ret = 0;
+
+    if (st_mode_prot_from_ia(prot1) != st_mode_prot_from_ia(prot2))
+        ret = -1;
+
+    return ret;
+}
+
+#endif /* _IATT_H */
diff --git a/libglusterfs/src/glusterfs/inode.h b/libglusterfs/src/glusterfs/inode.h
new file mode 100644
index 00000000000..4b28da510c7
--- /dev/null
+++ b/libglusterfs/src/glusterfs/inode.h
@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _INODE_H
+#define _INODE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#define LOOKUP_NEEDED 1
+#define LOOKUP_NOT_NEEDED 2
+
+#define DEFAULT_INODE_MEMPOOL_ENTRIES 32 * 1024
+#define INODE_PATH_FMT "<gfid:%s>"
+struct _inode_table;
+typedef struct _inode_table inode_table_t;
+
+struct _inode;
+typedef struct _inode inode_t;
+
+struct _dentry;
+typedef struct _dentry dentry_t;
+
+#include "glusterfs/list.h"
+#include "glusterfs/iatt.h"
+#include "glusterfs/compat-uuid.h"
+#include "glusterfs/fd.h"
+
+struct _inode_table {
+    pthread_mutex_t lock;
+    size_t hashsize;    /* bucket size of inode hash and dentry hash */
+    char *name;         /* name of the inode table, just for gf_log() */
+    inode_t *root;      /* root directory inode, with number 1 */
+    xlator_t *xl;       /* xlator to be called to do purge */
+    uint32_t lru_limit; /* maximum LRU cache size */
+    struct list_head *inode_hash; /* buckets for inode hash table */
+    struct list_head *name_hash;  /* buckets for dentry hash table */
+    struct list_head active; /* list of inodes currently active (in an fop) */
+    uint32_t active_size;    /* count of inodes in active list */
+    struct list_head lru;    /* list of inodes recently used.
+                                lru.next most recent */
+    uint32_t lru_size;       /* count of inodes in lru list  */
+    struct list_head purge;  /* list of inodes to be purged soon */
+    uint32_t purge_size;     /* count of inodes in purge list */
+
+    struct mem_pool *inode_pool;  /* memory pool for inodes */
+    struct mem_pool *dentry_pool; /* memory pool for dentrys */
+    struct mem_pool *fd_mem_pool; /* memory pool for fd_t */
+    int ctxcount;                 /* number of slots in inode->ctx */
+
+    /* This is required for 'invalidation' when 'nlookup' would be used,
+       specially in case of fuse-bridge */
+    int32_t (*invalidator_fn)(xlator_t *, inode_t *);
+    xlator_t *invalidator_xl;
+    struct list_head invalidate; /* inodes which are in invalidation queue */
+    uint32_t invalidate_size;    /* count of inodes in invalidation list */
+
+    /* flag to indicate whether the cleanup of the inode
+       table started or not */
+    gf_boolean_t cleanup_started;
+};
+
+struct _dentry {
+    struct list_head inode_list; /* list of dentries of inode */
+    struct list_head hash;       /* hash table pointers */
+    inode_t *inode;              /* inode of this directory entry */
+    char *name;                  /* name of the directory entry */
+    inode_t *parent;             /* directory of the entry */
+};
+
+struct _inode_ctx {
+    union {
+        uint64_t key;
+        xlator_t *xl_key;
+    };
+    /* if value1 is 0, then field is not set.. */
+    union {
+        uint64_t value1;
+        void *ptr1;
+    };
+    /* if value2 is 0, then field is not set.. */
+    union {
+        uint64_t value2;
+        void *ptr2;
+    };
+    int ref; /* This is for debugging inode ref leaks,
+                basically helps in identifying the xlator
+                causing th ref leak, it is printed in
+                statedump */
+};
+
+struct _inode {
+    inode_table_t *table; /* the table this inode belongs to */
+    uuid_t gfid;
+    gf_lock_t lock;
+    gf_atomic_t nlookup;
+    uint32_t fd_count;            /* Open fd count */
+    uint32_t active_fd_count;     /* Active open fd count */
+    uint32_t ref;                 /* reference count on this inode */
+    ia_type_t ia_type;            /* what kind of file */
+    struct list_head fd_list;     /* list of open files on this inode */
+    struct list_head dentry_list; /* list of directory entries for this inode */
+    struct list_head hash;        /* hash table pointers */
+    struct list_head list;        /* active/lru/purge */
+
+    struct _inode_ctx *_ctx; /* replacement for dict_t *(inode->ctx) */
+    bool in_invalidate_list; /* Set if inode is in table invalidate list */
+    bool invalidate_sent;    /* Set it if invalidator_fn is called for inode */
+};
+
+#define UUID0_STR "00000000-0000-0000-0000-000000000000"
+#define GFID_STR_PFX "<gfid:" UUID0_STR ">"
+#define GFID_STR_PFX_LEN (sizeof(GFID_STR_PFX) - 1)
+
+inode_table_t *
+inode_table_new(uint32_t lru_limit, xlator_t *xl);
+
+inode_table_t *
+inode_table_with_invalidator(uint32_t lru_limit, xlator_t *xl,
+                             int32_t (*invalidator_fn)(xlator_t *, inode_t *),
+                             xlator_t *invalidator_xl);
+
+void
+inode_table_destroy_all(glusterfs_ctx_t *ctx);
+
+void
+inode_table_destroy(inode_table_t *inode_table);
+
+inode_t *
+inode_new(inode_table_t *table);
+
+inode_t *
+inode_link(inode_t *inode, inode_t *parent, const char *name,
+           struct iatt *stbuf);
+
+void
+inode_unlink(inode_t *inode, inode_t *parent, const char *name);
+
+inode_t *
+inode_parent(inode_t *inode, uuid_t pargfid, const char *name);
+
+inode_t *
+inode_ref(inode_t *inode);
+
+inode_t *
+inode_unref(inode_t *inode);
+
+int
+inode_lookup(inode_t *inode);
+
+int
+inode_forget(inode_t *inode, uint64_t nlookup);
+int
+inode_forget_with_unref(inode_t *inode, uint64_t nlookup);
+
+int
+inode_ref_reduce_by_n(inode_t *inode, uint64_t nref);
+
+int
+inode_invalidate(inode_t *inode);
+
+int
+inode_rename(inode_table_t *table, inode_t *olddir, const char *oldname,
+             inode_t *newdir, const char *newname, inode_t *inode,
+             struct iatt *stbuf);
+
+inode_t *
+inode_grep(inode_table_t *table, inode_t *parent, const char *name);
+
+int
+inode_grep_for_gfid(inode_table_t *table, inode_t *parent, const char *name,
+                    uuid_t gfid, ia_type_t *type);
+
+inode_t *
+inode_find(inode_table_t *table, uuid_t gfid);
+
+int
+inode_path(inode_t *inode, const char *name, char **bufp);
+
+int
+__inode_path(inode_t *inode, const char *name, char **bufp);
+
+inode_t *
+inode_from_path(inode_table_t *table, const char *path);
+
+inode_t *
+inode_resolve(inode_table_t *table, char *path);
+
+/* deal with inode ctx's both values */
+
+int
+inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2);
+int
+__inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                 uint64_t *value2);
+
+int
+inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2);
+int
+__inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                 uint64_t *value2);
+
+int
+inode_ctx_del2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2);
+
+int
+inode_ctx_reset2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                 uint64_t *value2);
+
+/* deal with inode ctx's 1st value */
+
+int
+inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+__inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1);
+int
+__inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+inode_ctx_reset0(inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+/* deal with inode ctx's 2st value */
+
+int
+inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+__inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2);
+int
+__inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+inode_ctx_reset1(inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+static inline int
+__inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
+{
+    return __inode_ctx_set0(inode, this, &v);
+}
+
+static inline int
+inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
+{
+    return inode_ctx_set0(inode, this, &v);
+}
+
+#define __inode_ctx_set(i, x, v_p) __inode_ctx_set0(i, x, v_p)
+
+#define inode_ctx_set(i, x, v_p) inode_ctx_set0(i, x, v_p)
+
+#define inode_ctx_reset(i, x, v) inode_ctx_reset0(i, x, v)
+
+#define __inode_ctx_get(i, x, v) __inode_ctx_get0(i, x, v)
+
+#define inode_ctx_get(i, x, v) inode_ctx_get0(i, x, v)
+
+#define inode_ctx_del(i, x, v) inode_ctx_del2(i, x, v, 0)
+#define inode_ctx_del1(i, x, v) inode_ctx_del2(i, x, 0, v)
+
+gf_boolean_t
+__is_root_gfid(uuid_t gfid);
+
+void
+__inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit);
+
+void
+inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit);
+
+void
+inode_ctx_merge(fd_t *fd, inode_t *inode, inode_t *linked_inode);
+
+int
+inode_is_linked(inode_t *inode);
+
+void
+inode_set_need_lookup(inode_t *inode, xlator_t *this);
+
+gf_boolean_t
+inode_needs_lookup(inode_t *inode, xlator_t *this);
+
+int
+inode_has_dentry(inode_t *inode);
+
+size_t
+inode_ctx_size(inode_t *inode);
+
+void
+inode_find_directory_name(inode_t *inode, const char **name);
+#endif /* _INODE_H */
diff --git a/libglusterfs/src/glusterfs/iobuf.h b/libglusterfs/src/glusterfs/iobuf.h
new file mode 100644
index 00000000000..4bd443efd5e
--- /dev/null
+++ b/libglusterfs/src/glusterfs/iobuf.h
@@ -0,0 +1,194 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _IOBUF_H_
+#define _IOBUF_H_
+
+#include <stddef.h>  // for size_t
+#include <sys/mman.h>
+#include "glusterfs/atomic.h"   // for gf_atomic_t
+#include <sys/uio.h>            // for struct iovec
+#include "glusterfs/locking.h"  // for gf_lock_t
+#include "glusterfs/list.h"
+
+#define GF_VARIABLE_IOBUF_COUNT 32
+
+#define GF_RDMA_DEVICE_COUNT 8
+
+/* Lets try to define the new anonymous mapping
+ * flag, in case the system is still using the
+ * now deprecated MAP_ANON flag.
+ *
+ * Also, this should ideally be in a centralized/common
+ * header which can be used by other source files also.
+ */
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+#define GF_ALIGN_BUF(ptr, bound)                                               \
+    ((void *)((unsigned long)(ptr + bound - 1) & (unsigned long)(~(bound - 1))))
+
+#define GF_IOBUF_ALIGN_SIZE 512
+
+/* one allocatable unit for the consumers of the IOBUF API */
+/* each unit hosts @page_size bytes of memory */
+struct iobuf;
+
+/* one region of memory mapped from the operating system */
+/* each region MMAPs @arena_size bytes of memory */
+/* each arena hosts @arena_size / @page_size IOBUFs */
+struct iobuf_arena;
+
+/* expandable and contractable pool of memory, internally broken into arenas */
+struct iobuf_pool;
+
+struct iobuf_init_config {
+    size_t pagesize;
+    int32_t num_pages;
+};
+
+struct iobuf {
+    union {
+        struct list_head list;
+        struct {
+            struct iobuf *next;
+            struct iobuf *prev;
+        };
+    };
+    struct iobuf_arena *iobuf_arena;
+
+    gf_lock_t lock;  /* for ->ptr and ->ref */
+    gf_atomic_t ref; /* 0 == passive, >0 == active */
+
+    void *ptr; /* usable memory region by the consumer */
+
+    void *free_ptr; /* in case of stdalloc, this is the
+                       one to be freed */
+};
+
+struct iobuf_arena {
+    union {
+        struct list_head list;
+        struct {
+            struct iobuf_arena *next;
+            struct iobuf_arena *prev;
+        };
+    };
+
+    struct list_head all_list;
+    size_t page_size; /* size of all iobufs in this arena */
+    size_t arena_size;
+    /* this is equal to rounded_size * num_iobufs.
+       (rounded_size comes with gf_iobuf_get_pagesize().) */
+    size_t page_count;
+
+    struct iobuf_pool *iobuf_pool;
+
+    void *mem_base;
+    struct iobuf *iobufs; /* allocated iobufs list */
+
+    struct iobuf active;  /* head node iobuf
+                             (unused by itself) */
+    struct iobuf passive; /* head node iobuf
+                             (unused by itself) */
+    uint64_t alloc_cnt;   /* total allocs in this pool */
+    int active_cnt;
+    int passive_cnt;
+    int max_active; /* max active buffers at a given time */
+};
+
+struct iobuf_pool {
+    pthread_mutex_t mutex;
+    size_t arena_size;        /* size of memory region in
+                                 arena */
+    size_t default_page_size; /* default size of iobuf */
+
+    struct list_head all_arenas;
+    struct list_head arenas[GF_VARIABLE_IOBUF_COUNT];
+    /* array of arenas. Each element of the array is a list of arenas
+       holding iobufs of particular page_size */
+
+    struct list_head filled[GF_VARIABLE_IOBUF_COUNT];
+    /* array of arenas without free iobufs */
+
+    struct list_head purge[GF_VARIABLE_IOBUF_COUNT];
+    /* array of of arenas which can be purged */
+
+    uint64_t request_misses; /* mostly the requests for higher
+                               value of iobufs */
+    int arena_cnt;
+    int rdma_device_count;
+    struct list_head *mr_list[GF_RDMA_DEVICE_COUNT];
+    void *device[GF_RDMA_DEVICE_COUNT];
+    int (*rdma_registration)(void **, void *);
+    int (*rdma_deregistration)(struct list_head **, struct iobuf_arena *);
+};
+
+struct iobuf_pool *
+iobuf_pool_new(void);
+void
+iobuf_pool_destroy(struct iobuf_pool *iobuf_pool);
+struct iobuf *
+iobuf_get(struct iobuf_pool *iobuf_pool);
+void
+iobuf_unref(struct iobuf *iobuf);
+struct iobuf *
+iobuf_ref(struct iobuf *iobuf);
+void
+iobuf_pool_destroy(struct iobuf_pool *iobuf_pool);
+void
+iobuf_to_iovec(struct iobuf *iob, struct iovec *iov);
+
+#define iobuf_ptr(iob) ((iob)->ptr)
+#define iobpool_default_pagesize(iobpool) ((iobpool)->default_page_size)
+#define iobuf_pagesize(iob) (iob->iobuf_arena->page_size)
+
+struct iobref {
+    gf_lock_t lock;
+    gf_atomic_t ref;
+    struct iobuf **iobrefs;
+    int allocated;
+    int used;
+};
+
+struct iobref *
+iobref_new(void);
+struct iobref *
+iobref_ref(struct iobref *iobref);
+void
+iobref_unref(struct iobref *iobref);
+int
+iobref_add(struct iobref *iobref, struct iobuf *iobuf);
+int
+iobref_merge(struct iobref *to, struct iobref *from);
+void
+iobref_clear(struct iobref *iobref);
+
+size_t
+iobuf_size(struct iobuf *iobuf);
+size_t
+iobref_size(struct iobref *iobref);
+void
+iobuf_stats_dump(struct iobuf_pool *iobuf_pool);
+
+struct iobuf *
+iobuf_get2(struct iobuf_pool *iobuf_pool, size_t page_size);
+
+struct iobuf *
+iobuf_get_page_aligned(struct iobuf_pool *iobuf_pool, size_t page_size,
+                       size_t align_size);
+
+int
+iobuf_copy(struct iobuf_pool *iobuf_pool, const struct iovec *iovec_src,
+           int iovcnt, struct iobref **iobref, struct iobuf **iobuf,
+           struct iovec *iov_dst);
+
+#endif /* !_IOBUF_H_ */
diff --git a/libglusterfs/src/glusterfs/latency.h b/libglusterfs/src/glusterfs/latency.h
new file mode 100644
index 00000000000..4d601bbcbd6
--- /dev/null
+++ b/libglusterfs/src/glusterfs/latency.h
@@ -0,0 +1,33 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __LATENCY_H__
+#define __LATENCY_H__
+
+#include <inttypes.h>
+#include <time.h>
+
+typedef struct _gf_latency {
+    uint64_t min;   /* min time for the call (nanoseconds) */
+    uint64_t max;   /* max time for the call (nanoseconds) */
+    uint64_t total; /* total time (nanoseconds) */
+    uint64_t count;
+} gf_latency_t;
+
+gf_latency_t *
+gf_latency_new(size_t n);
+
+void
+gf_latency_reset(gf_latency_t *lat);
+
+void
+gf_latency_update(gf_latency_t *lat, struct timespec *begin,
+                  struct timespec *end);
+#endif /* __LATENCY_H__ */
diff --git a/libglusterfs/src/glusterfs/libglusterfs-messages.h b/libglusterfs/src/glusterfs/libglusterfs-messages.h
new file mode 100644
index 00000000000..cb31dd7614b
--- /dev/null
+++ b/libglusterfs/src/glusterfs/libglusterfs-messages.h
@@ -0,0 +1,245 @@
+/*
+ Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+ This file is part of GlusterFS.
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+ */
+
+#ifndef _LG_MESSAGES_H_
+#define _LG_MESSAGES_H_
+
+#include "glusterfs/glfs-message-id.h"
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
+ */
+
+GLFS_MSGID(
+    LIBGLUSTERFS, LG_MSG_ASPRINTF_FAILED, LG_MSG_INVALID_ENTRY,
+    LG_MSG_COUNT_LESS_THAN_ZERO, LG_MSG_COUNT_LESS_THAN_DATA_PAIRS,
+    LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO, LG_MSG_PAIRS_LESS_THAN_COUNT,
+    LG_MSG_KEY_OR_VALUE_NULL, LG_MSG_FAILED_TO_LOG_DICT,
+    LG_MSG_NULL_VALUE_IN_DICT, LG_MSG_DIR_OP_FAILED,
+    LG_MSG_STORE_HANDLE_CREATE_FAILED, LG_MSG_FILE_OP_FAILED,
+    LG_MSG_FILE_STAT_FAILED, LG_MSG_LOCK_FAILED, LG_MSG_UNLOCK_FAILED,
+    LG_MSG_DICT_SERIAL_FAILED, LG_MSG_DICT_UNSERIAL_FAILED, LG_MSG_NO_MEMORY,
+    LG_MSG_VOLUME_ERROR, LG_MSG_SUB_VOLUME_ERROR, LG_MSG_SYNTAX_ERROR,
+    LG_MSG_BACKTICK_PARSE_FAILED, LG_MSG_BUFFER_ERROR, LG_MSG_STRDUP_ERROR,
+    LG_MSG_HASH_FUNC_ERROR, LG_MSG_GET_BUCKET_FAILED, LG_MSG_INSERT_FAILED,
+    LG_MSG_OUT_OF_RANGE, LG_MSG_VALIDATE_RETURNS, LG_MSG_VALIDATE_REC_FAILED,
+    LG_MSG_RB_TABLE_CREATE_FAILED, LG_MSG_PATH_NOT_FOUND,
+    LG_MSG_EXPAND_FD_TABLE_FAILED, LG_MSG_MAPPING_FAILED,
+    LG_MSG_INIT_IOBUF_FAILED, LG_MSG_PAGE_SIZE_EXCEEDED, LG_MSG_ARENA_NOT_FOUND,
+    LG_MSG_IOBUF_NOT_FOUND, LG_MSG_POOL_NOT_FOUND, LG_MSG_SET_ATTRIBUTE_FAILED,
+    LG_MSG_READ_ATTRIBUTE_FAILED, LG_MSG_UNMOUNT_FAILED,
+    LG_MSG_LATENCY_MEASUREMENT_STATE, LG_MSG_NO_PERM, LG_MSG_NO_KEY,
+    LG_MSG_DICT_NULL, LG_MSG_INIT_TIMER_FAILED, LG_MSG_FD_ANONYMOUS_FAILED,
+    LG_MSG_FD_CREATE_FAILED, LG_MSG_BUFFER_FULL, LG_MSG_FWRITE_FAILED,
+    LG_MSG_PRINT_FAILED, LG_MSG_MEM_POOL_DESTROY,
+    LG_MSG_EXPAND_CLIENT_TABLE_FAILED, LG_MSG_DISCONNECT_CLIENT,
+    LG_MSG_PIPE_CREATE_FAILED, LG_MSG_SET_PIPE_FAILED,
+    LG_MSG_REGISTER_PIPE_FAILED, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
+    LG_MSG_INDEX_NOT_FOUND, LG_MSG_EPOLL_FD_CREATE_FAILED,
+    LG_MSG_SLOT_NOT_FOUND, LG_MSG_STALE_FD_FOUND, LG_MSG_GENERATION_MISMATCH,
+    LG_MSG_PTHREAD_KEY_CREATE_FAILED, LG_MSG_TRANSLATOR_INIT_FAILED,
+    LG_MSG_UUID_BUF_INIT_FAILED, LG_MSG_LKOWNER_BUF_INIT_FAILED,
+    LG_MSG_SYNCTASK_INIT_FAILED, LG_MSG_SYNCOPCTX_INIT_FAILED,
+    LG_MSG_GLOBAL_INIT_FAILED, LG_MSG_PTHREAD_FAILED, LG_MSG_DIR_IS_SYMLINK,
+    LG_MSG_RESOLVE_HOSTNAME_FAILED, LG_MSG_GETADDRINFO_FAILED,
+    LG_MSG_GETNAMEINFO_FAILED, LG_MSG_PATH_ERROR, LG_MSG_INET_PTON_FAILED,
+    LG_MSG_NEGATIVE_NUM_PASSED, LG_MSG_GETHOSTNAME_FAILED,
+    LG_MSG_RESERVED_PORTS_ERROR, LG_MSG_INVALID_PORT, LG_MSG_INVALID_FAMILY,
+    LG_MSG_CONVERSION_FAILED, LG_MSG_SKIP_HEADER_FAILED, LG_MSG_INVALID_LOG,
+    LG_MSG_UTIMES_FAILED, LG_MSG_BACKTRACE_SAVE_FAILED, LG_MSG_INIT_FAILED,
+    LG_MSG_VALIDATION_FAILED, LG_MSG_GRAPH_ERROR, LG_MSG_UNKNOWN_OPTIONS_FAILED,
+    LG_MSG_CTX_NULL, LG_MSG_TMPFILE_CREATE_FAILED, LG_MSG_DLOPEN_FAILED,
+    LG_MSG_LOAD_FAILED, LG_MSG_DLSYM_ERROR, LG_MSG_TREE_NOT_FOUND,
+    LG_MSG_PER_DENTRY, LG_MSG_DENTRY, LG_MSG_GETIFADDRS_FAILED,
+    LG_MSG_REGEX_OP_FAILED, LG_MSG_FRAME_ERROR, LG_MSG_SET_PARAM_FAILED,
+    LG_MSG_GET_PARAM_FAILED, LG_MSG_PREPARE_FAILED, LG_MSG_EXEC_FAILED,
+    LG_MSG_BINDING_FAILED, LG_MSG_DELETE_FAILED, LG_MSG_GET_ID_FAILED,
+    LG_MSG_CREATE_FAILED, LG_MSG_PARSE_FAILED, LG_MSG_GETCONTEXT_FAILED,
+    LG_MSG_UPDATE_FAILED, LG_MSG_QUERY_CALL_BACK_FAILED,
+    LG_MSG_GET_RECORD_FAILED, LG_MSG_DB_ERROR, LG_MSG_CONNECTION_ERROR,
+    LG_MSG_NOT_MULTITHREAD_MODE, LG_MSG_SKIP_PATH, LG_MSG_INVALID_FOP,
+    LG_MSG_QUERY_FAILED, LG_MSG_CLEAR_COUNTER_FAILED, LG_MSG_LOCK_LIST_FAILED,
+    LG_MSG_UNLOCK_LIST_FAILED, LG_MSG_ADD_TO_LIST_FAILED, LG_MSG_INIT_DB_FAILED,
+    LG_MSG_DELETE_FROM_LIST_FAILED, LG_MSG_CLOSE_CONNECTION_FAILED,
+    LG_MSG_INSERT_OR_UPDATE_FAILED, LG_MSG_FIND_OP_FAILED,
+    LG_MSG_CONNECTION_INIT_FAILED, LG_MSG_COMPLETED_TASK, LG_MSG_WAKE_UP_ZOMBIE,
+    LG_MSG_REWAITING_TASK, LG_MSG_SLEEP_ZOMBIE, LG_MSG_SWAPCONTEXT_FAILED,
+    LG_MSG_UNSUPPORTED_PLUGIN, LG_MSG_INVALID_DB_TYPE, LG_MSG_UNDERSIZED_BUF,
+    LG_MSG_DATA_CONVERSION_ERROR, LG_MSG_DICT_ERROR, LG_MSG_IOBUFS_NOT_FOUND,
+    LG_MSG_ENTRIES_NULL, LG_MSG_FD_NOT_FOUND_IN_FDTABLE,
+    LG_MSG_REALLOC_FOR_FD_PTR_FAILED, LG_MSG_DICT_SET_FAILED, LG_MSG_NULL_PTR,
+    LG_MSG_RBTHASH_INIT_BUCKET_FAILED, LG_MSG_ASSERTION_FAILED,
+    LG_MSG_HOSTNAME_NULL, LG_MSG_INVALID_IPV4_FORMAT,
+    LG_MSG_CTX_CLEANUP_STARTED, LG_MSG_TIMER_REGISTER_ERROR,
+    LG_MSG_PTR_HEADER_CORRUPTED, LG_MSG_INVALID_UPLINK, LG_MSG_CLIENT_NULL,
+    LG_MSG_XLATOR_DOES_NOT_IMPLEMENT, LG_MSG_DENTRY_NOT_FOUND,
+    LG_MSG_INODE_NOT_FOUND, LG_MSG_INODE_TABLE_NOT_FOUND,
+    LG_MSG_DENTRY_CREATE_FAILED, LG_MSG_INODE_CONTEXT_FREED,
+    LG_MSG_UNKNOWN_LOCK_TYPE, LG_MSG_UNLOCK_BEFORE_LOCK,
+    LG_MSG_LOCK_OWNER_ERROR, LG_MSG_MEMPOOL_PTR_NULL,
+    LG_MSG_QUOTA_XATTRS_MISSING, LG_MSG_INVALID_STRING, LG_MSG_BIND_REF,
+    LG_MSG_REF_COUNT, LG_MSG_INVALID_ARG, LG_MSG_VOL_OPTION_ADD,
+    LG_MSG_XLATOR_OPTION_INVALID, LG_MSG_GETTIMEOFDAY_FAILED,
+    LG_MSG_GRAPH_INIT_FAILED, LG_MSG_EVENT_NOTIFY_FAILED,
+    LG_MSG_ACTIVE_GRAPH_NULL, LG_MSG_VOLFILE_PARSE_ERROR, LG_MSG_FD_INODE_NULL,
+    LG_MSG_INVALID_VOLFILE_ENTRY, LG_MSG_PER_DENTRY_FAILED,
+    LG_MSG_PARENT_DENTRY_NOT_FOUND, LG_MSG_DENTRY_CYCLIC_LOOP,
+    LG_MSG_INVALID_POLL_IN, LG_MSG_INVALID_POLL_OUT, LG_MSG_EPOLL_FD_ADD_FAILED,
+    LG_MSG_EPOLL_FD_DEL_FAILED, LG_MSG_EPOLL_FD_MODIFY_FAILED,
+    LG_MSG_STARTED_EPOLL_THREAD, LG_MSG_EXITED_EPOLL_THREAD,
+    LG_MSG_START_EPOLL_THREAD_FAILED, LG_MSG_FALLBACK_TO_POLL,
+    LG_MSG_QUOTA_CONF_ERROR, LG_MSG_RBTHASH_GET_ENTRY_FAILED,
+    LG_MSG_RBTHASH_GET_BUCKET_FAILED, LG_MSG_RBTHASH_INSERT_FAILED,
+    LG_MSG_RBTHASH_INIT_ENTRY_FAILED, LG_MSG_TMPFILE_DELETE_FAILED,
+    LG_MSG_MEMPOOL_INVALID_FREE, LG_MSG_LOCK_FAILURE, LG_MSG_SET_LOG_LEVEL,
+    LG_MSG_VERIFY_PLATFORM, LG_MSG_RUNNER_LOG, LG_MSG_LEASEID_BUF_INIT_FAILED,
+    LG_MSG_PTHREAD_ATTR_INIT_FAILED, LG_MSG_INVALID_INODE_LIST,
+    LG_MSG_COMPACT_FAILED, LG_MSG_COMPACT_STATUS, LG_MSG_UTIMENSAT_FAILED,
+    LG_MSG_PTHREAD_NAMING_FAILED, LG_MSG_SYSCALL_RETURNS_WRONG,
+    LG_MSG_XXH64_TO_GFID_FAILED, LG_MSG_ASYNC_WARNING, LG_MSG_ASYNC_FAILURE,
+    LG_MSG_GRAPH_CLEANUP_FAILED, LG_MSG_GRAPH_SETUP_FAILED,
+    LG_MSG_GRAPH_DETACH_STARTED, LG_MSG_GRAPH_ATTACH_FAILED,
+    LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED, LG_MSG_DUPLICATE_ENTRY,
+    LG_MSG_THREAD_NAME_TOO_LONG, LG_MSG_SET_THREAD_FAILED,
+    LG_MSG_THREAD_CREATE_FAILED, LG_MSG_FILE_DELETE_FAILED, LG_MSG_WRONG_VALUE,
+    LG_MSG_PATH_OPEN_FAILED, LG_MSG_DISPATCH_HANDLER_FAILED,
+    LG_MSG_READ_FILE_FAILED, LG_MSG_ENTRIES_NOT_PROVIDED,
+    LG_MSG_ENTRIES_PROVIDED, LG_MSG_UNKNOWN_OPTION_TYPE,
+    LG_MSG_OPTION_DEPRECATED, LG_MSG_INVALID_INIT, LG_MSG_OBJECT_NULL,
+    LG_MSG_GRAPH_NOT_SET, LG_MSG_FILENAME_NOT_SPECIFIED, LG_MSG_STRUCT_MISS,
+    LG_MSG_METHOD_MISS, LG_MSG_INPUT_DATA_NULL, LG_MSG_OPEN_LOGFILE_FAILED);
+
+#define LG_MSG_EPOLL_FD_CREATE_FAILED_STR "epoll fd creation failed"
+#define LG_MSG_INVALID_POLL_IN_STR "invalid poll_in value"
+#define LG_MSG_INVALID_POLL_OUT_STR "invalid poll_out value"
+#define LG_MSG_SLOT_NOT_FOUND_STR "could not find slot"
+#define LG_MSG_EPOLL_FD_ADD_FAILED_STR "failed to add fd to epoll"
+#define LG_MSG_EPOLL_FD_DEL_FAILED_STR "fail to delete fd to epoll"
+#define LG_MSG_EPOLL_FD_MODIFY_FAILED_STR "failed to modify fd events"
+#define LG_MSG_STALE_FD_FOUND_STR "stale fd found"
+#define LG_MSG_GENERATION_MISMATCH_STR "generation mismatch"
+#define LG_MSG_STARTED_EPOLL_THREAD_STR "Started thread with index"
+#define LG_MSG_EXITED_EPOLL_THREAD_STR "Exited thread"
+#define LG_MSG_DISPATCH_HANDLER_FAILED_STR "Failed to dispatch handler"
+#define LG_MSG_START_EPOLL_THREAD_FAILED_STR "Failed to start thread"
+#define LG_MSG_PIPE_CREATE_FAILED_STR "pipe creation failed"
+#define LG_MSG_SET_PIPE_FAILED_STR "could not set pipe to non blocking mode"
+#define LG_MSG_REGISTER_PIPE_FAILED_STR                                        \
+    "could not register pipe fd with poll event loop"
+#define LG_MSG_POLL_IGNORE_MULTIPLE_THREADS_STR                                \
+    "Currently poll does not use multiple event processing threads, count "    \
+    "ignored"
+#define LG_MSG_INDEX_NOT_FOUND_STR "index not found"
+#define LG_MSG_READ_FILE_FAILED_STR "read on file returned error"
+#define LG_MSG_RB_TABLE_CREATE_FAILED_STR "Failed to create rb table bucket"
+#define LG_MSG_HASH_FUNC_ERROR_STR "Hash function not given"
+#define LG_MSG_ENTRIES_NOT_PROVIDED_STR                                        \
+    "Both mem-pool and expected entries not provided"
+#define LG_MSG_ENTRIES_PROVIDED_STR                                            \
+    "Both mem-pool and expected entries are provided"
+#define LG_MSG_RBTHASH_INIT_BUCKET_FAILED_STR "failed to init buckets"
+#define LG_MSG_RBTHASH_GET_ENTRY_FAILED_STR "Failed to get entry from mem-pool"
+#define LG_MSG_RBTHASH_GET_BUCKET_FAILED_STR "Failed to get bucket"
+#define LG_MSG_RBTHASH_INSERT_FAILED_STR "Failed to insert entry"
+#define LG_MSG_RBTHASH_INIT_ENTRY_FAILED_STR "Failed to init entry"
+#define LG_MSG_FILE_STAT_FAILED_STR "failed to stat"
+#define LG_MSG_INET_PTON_FAILED_STR "inet_pton() failed"
+#define LG_MSG_INVALID_ENTRY_STR "Invalid arguments"
+#define LG_MSG_NEGATIVE_NUM_PASSED_STR "negative number passed"
+#define LG_MSG_PATH_ERROR_STR "Path manipulation failed"
+#define LG_MSG_FILE_OP_FAILED_STR "could not open/read file, getting ports info"
+#define LG_MSG_RESERVED_PORTS_ERROR_STR                                        \
+    "Not able to get reserved ports, hence there is a possibility that "       \
+    "glusterfs may consume reserved port"
+#define LG_MSG_INVALID_PORT_STR "invalid port"
+#define LG_MSG_GETNAMEINFO_FAILED_STR "Could not lookup hostname"
+#define LG_MSG_GETIFADDRS_FAILED_STR "getifaddrs() failed"
+#define LG_MSG_INVALID_FAMILY_STR "Invalid family"
+#define LG_MSG_CONVERSION_FAILED_STR "String conversion failed"
+#define LG_MSG_GETADDRINFO_FAILED_STR "error in getaddrinfo"
+#define LG_MSG_DUPLICATE_ENTRY_STR "duplicate entry for volfile-server"
+#define LG_MSG_PTHREAD_NAMING_FAILED_STR "Failed to compose thread name"
+#define LG_MSG_THREAD_NAME_TOO_LONG_STR                                        \
+    "Thread name is too long. It has been truncated"
+#define LG_MSG_SET_THREAD_FAILED_STR "Could not set thread name"
+#define LG_MSG_THREAD_CREATE_FAILED_STR "Thread creation failed"
+#define LG_MSG_PTHREAD_ATTR_INIT_FAILED_STR                                    \
+    "Thread attribute initialization failed"
+#define LG_MSG_SKIP_HEADER_FAILED_STR "Failed to skip header section"
+#define LG_MSG_INVALID_LOG_STR "Invalid log-format"
+#define LG_MSG_UTIMENSAT_FAILED_STR "utimenstat failed"
+#define LG_MSG_UTIMES_FAILED_STR "utimes failed"
+#define LG_MSG_FILE_DELETE_FAILED_STR "Unable to delete file"
+#define LG_MSG_BACKTRACE_SAVE_FAILED_STR "Failed to save the backtrace"
+#define LG_MSG_WRONG_VALUE_STR "wrong value"
+#define LG_MSG_DIR_OP_FAILED_STR "Failed to create directory"
+#define LG_MSG_DIR_IS_SYMLINK_STR "dir is symlink"
+#define LG_MSG_RESOLVE_HOSTNAME_FAILED_STR "couldnot resolve hostname"
+#define LG_MSG_PATH_OPEN_FAILED_STR "Unable to open path"
+#define LG_MSG_NO_MEMORY_STR "Error allocating memory"
+#define LG_MSG_EVENT_NOTIFY_FAILED_STR "notification failed"
+#define LG_MSG_PER_DENTRY_FAILED_STR "per dentry fn returned"
+#define LG_MSG_PARENT_DENTRY_NOT_FOUND_STR "parent not found"
+#define LG_MSG_DENTRY_CYCLIC_LOOP_STR                                          \
+    "detected cyclic loop formation during inode linkage"
+#define LG_MSG_CTX_NULL_STR "_ctx not found"
+#define LG_MSG_DENTRY_NOT_FOUND_STR "dentry not found"
+#define LG_MSG_OUT_OF_RANGE_STR "out of range"
+#define LG_MSG_UNKNOWN_OPTION_TYPE_STR "unknown option type"
+#define LG_MSG_VALIDATE_RETURNS_STR "validate of returned"
+#define LG_MSG_OPTION_DEPRECATED_STR                                           \
+    "option is deprecated, continuing with correction"
+#define LG_MSG_VALIDATE_REC_FAILED_STR "validate_rec failed"
+#define LG_MSG_MAPPING_FAILED_STR "mapping failed"
+#define LG_MSG_INIT_IOBUF_FAILED_STR "init failed"
+#define LG_MSG_ARENA_NOT_FOUND_STR "arena not found"
+#define LG_MSG_PAGE_SIZE_EXCEEDED_STR                                          \
+    "page_size of iobufs in arena being added is greater than max available"
+#define LG_MSG_POOL_NOT_FOUND_STR "pool not found"
+#define LG_MSG_IOBUF_NOT_FOUND_STR "iobuf not found"
+#define LG_MSG_DLOPEN_FAILED_STR "DL open failed"
+#define LG_MSG_DLSYM_ERROR_STR "dlsym missing"
+#define LG_MSG_LOAD_FAILED_STR "Failed to load xlator options table"
+#define LG_MSG_INPUT_DATA_NULL_STR                                             \
+    "input data is null. cannot update the lru limit of the inode table. "     \
+    "continuing with older value."
+#define LG_MSG_INIT_FAILED_STR "No init() found"
+#define LG_MSG_VOLUME_ERROR_STR                                                \
+    "Initialization of volume failed. review your volfile again."
+#define LG_MSG_TREE_NOT_FOUND_STR "Translator tree not found"
+#define LG_MSG_SET_LOG_LEVEL_STR "setting log level"
+#define LG_MSG_INVALID_INIT_STR                                                \
+    "Invalid log-level. possible values are DEBUG|WARNING|ERROR|NONE|TRACE"
+#define LG_MSG_OBJECT_NULL_STR "object is null, returning false."
+#define LG_MSG_GRAPH_NOT_SET_STR "Graph is not set for xlator"
+#define LG_MSG_OPEN_LOGFILE_FAILED_STR "failed to open logfile"
+#define LG_MSG_STRDUP_ERROR_STR "failed to create metrics dir"
+#define LG_MSG_FILENAME_NOT_SPECIFIED_STR "no filename specified"
+#define LG_MSG_UNDERSIZED_BUF_STR "data value is smaller than expected"
+#define LG_MSG_DICT_SET_FAILED_STR "unable to set dict"
+#define LG_MSG_COUNT_LESS_THAN_ZERO_STR "count < 0!"
+#define LG_MSG_PAIRS_LESS_THAN_COUNT_STR "less than count data pairs found"
+#define LG_MSG_NULL_PTR_STR "pair->key is null!"
+#define LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO_STR "value->len < 0"
+#define LG_MSG_INVALID_ARG_STR "buf is null"
+#define LG_MSG_KEY_OR_VALUE_NULL_STR "key or value is null"
+#define LG_MSG_NULL_VALUE_IN_DICT_STR "null value found in dict"
+#define LG_MSG_FAILED_TO_LOG_DICT_STR "Failed to log dictionary"
+#define LG_MSG_DICT_ERROR_STR "dict error"
+#define LG_MSG_STRUCT_MISS_STR "struct missing"
+#define LG_MSG_METHOD_MISS_STR "method missing(init)"
+
+#endif /* !_LG_MESSAGES_H_ */
diff --git a/libglusterfs/src/glusterfs/list.h b/libglusterfs/src/glusterfs/list.h
new file mode 100644
index 00000000000..221a710ca30
--- /dev/null
+++ b/libglusterfs/src/glusterfs/list.h
@@ -0,0 +1,273 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _LLIST_H
+#define _LLIST_H
+
+struct list_head {
+    struct list_head *next;
+    struct list_head *prev;
+};
+
+#define INIT_LIST_HEAD(head)                                                   \
+    do {                                                                       \
+        (head)->next = (head)->prev = head;                                    \
+    } while (0)
+
+static inline void
+list_add(struct list_head *new, struct list_head *head)
+{
+    new->prev = head;
+    new->next = head->next;
+
+    new->prev->next = new;
+    new->next->prev = new;
+}
+
+static inline void
+list_add_tail(struct list_head *new, struct list_head *head)
+{
+    new->next = head;
+    new->prev = head->prev;
+
+    new->prev->next = new;
+    new->next->prev = new;
+}
+
+/* This function will insert the element to the list in a order.
+   Order will be based on the compare function provided as a input.
+   If element to be inserted in ascending order compare should return:
+    0: if both the arguments are equal
+   >0: if first argument is greater than second argument
+   <0: if first argument is less than second argument */
+static inline void
+list_add_order(struct list_head *new, struct list_head *head,
+               int (*compare)(struct list_head *, struct list_head *))
+{
+    struct list_head *pos = head->prev;
+
+    while (pos != head) {
+        if (compare(new, pos) >= 0)
+            break;
+
+        /* Iterate the list in the reverse order. This will have
+           better efficiency if the elements are inserted in the
+           ascending order */
+        pos = pos->prev;
+    }
+
+    list_add(new, pos);
+}
+
+static inline void
+list_del(struct list_head *old)
+{
+    old->prev->next = old->next;
+    old->next->prev = old->prev;
+
+    old->next = (void *)0xbabebabe;
+    old->prev = (void *)0xcafecafe;
+}
+
+static inline void
+list_del_init(struct list_head *old)
+{
+    old->prev->next = old->next;
+    old->next->prev = old->prev;
+
+    old->next = old;
+    old->prev = old;
+}
+
+static inline void
+list_move(struct list_head *list, struct list_head *head)
+{
+    list_del(list);
+    list_add(list, head);
+}
+
+static inline void
+list_move_tail(struct list_head *list, struct list_head *head)
+{
+    list_del(list);
+    list_add_tail(list, head);
+}
+
+static inline int
+list_empty(struct list_head *head)
+{
+    return (head->next == head);
+}
+
+static inline void
+__list_splice(struct list_head *list, struct list_head *head)
+{
+    (list->prev)->next = (head->next);
+    (head->next)->prev = (list->prev);
+
+    (head)->next = (list->next);
+    (list->next)->prev = (head);
+}
+
+static inline void
+list_splice(struct list_head *list, struct list_head *head)
+{
+    if (list_empty(list))
+        return;
+
+    __list_splice(list, head);
+}
+
+/* Splice moves @list to the head of the list at @head. */
+static inline void
+list_splice_init(struct list_head *list, struct list_head *head)
+{
+    if (list_empty(list))
+        return;
+
+    __list_splice(list, head);
+    INIT_LIST_HEAD(list);
+}
+
+static inline void
+__list_append(struct list_head *list, struct list_head *head)
+{
+    (head->prev)->next = (list->next);
+    (list->next)->prev = (head->prev);
+    (head->prev) = (list->prev);
+    (list->prev)->next = head;
+}
+
+static inline void
+list_append(struct list_head *list, struct list_head *head)
+{
+    if (list_empty(list))
+        return;
+
+    __list_append(list, head);
+}
+
+/* Append moves @list to the end of @head */
+static inline void
+list_append_init(struct list_head *list, struct list_head *head)
+{
+    if (list_empty(list))
+        return;
+
+    __list_append(list, head);
+    INIT_LIST_HEAD(list);
+}
+
+static inline int
+list_is_last(struct list_head *list, struct list_head *head)
+{
+    return (list->next == head);
+}
+
+static inline int
+list_is_singular(struct list_head *head)
+{
+    return !list_empty(head) && (head->next == head->prev);
+}
+
+/**
+ * list_replace - replace old entry by new one
+ * @old : the element to be replaced
+ * @new : the new element to insert
+ *
+ * If @old was empty, it will be overwritten.
+ */
+static inline void
+list_replace(struct list_head *old, struct list_head *new)
+{
+    new->next = old->next;
+    new->next->prev = new;
+    new->prev = old->prev;
+    new->prev->next = new;
+}
+
+static inline void
+list_replace_init(struct list_head *old, struct list_head *new)
+{
+    list_replace(old, new);
+    INIT_LIST_HEAD(old);
+}
+
+/**
+ * list_rotate_left - rotate the list to the left
+ * @head: the head of the list
+ */
+static inline void
+list_rotate_left(struct list_head *head)
+{
+    struct list_head *first;
+
+    if (!list_empty(head)) {
+        first = head->next;
+        list_move_tail(first, head);
+    }
+}
+
+#define list_entry(ptr, type, member)                                          \
+    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))
+
+#define list_first_entry(ptr, type, member)                                    \
+    list_entry((ptr)->next, type, member)
+
+#define list_last_entry(ptr, type, member) list_entry((ptr)->prev, type, member)
+
+#define list_next_entry(pos, member)                                           \
+    list_entry((pos)->member.next, typeof(*(pos)), member)
+
+#define list_prev_entry(pos, member)                                           \
+    list_entry((pos)->member.prev, typeof(*(pos)), member)
+
+#define list_for_each(pos, head)                                               \
+    for (pos = (head)->next; pos != (head); pos = pos->next)
+
+#define list_for_each_entry(pos, head, member)                                 \
+    for (pos = list_entry((head)->next, typeof(*pos), member);                 \
+         &pos->member != (head);                                               \
+         pos = list_entry(pos->member.next, typeof(*pos), member))
+
+#define list_for_each_entry_safe(pos, n, head, member)                         \
+    for (pos = list_entry((head)->next, typeof(*pos), member),                 \
+        n = list_entry(pos->member.next, typeof(*pos), member);                \
+         &pos->member != (head);                                               \
+         pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+#define list_for_each_entry_reverse(pos, head, member)                         \
+    for (pos = list_entry((head)->prev, typeof(*pos), member);                 \
+         &pos->member != (head);                                               \
+         pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+#define list_for_each_entry_safe_reverse(pos, n, head, member)                 \
+    for (pos = list_entry((head)->prev, typeof(*pos), member),                 \
+        n = list_entry(pos->member.prev, typeof(*pos), member);                \
+         &pos->member != (head);                                               \
+         pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+
+/*
+ * This list implementation has some advantages, but one disadvantage: you
+ * can't use NULL to check whether you're at the head or tail.  Thus, the
+ * address of the head has to be an argument for these macros.
+ */
+
+#define list_next(ptr, head, type, member)                                     \
+    (((ptr)->member.next == head)                                              \
+         ? NULL                                                                \
+         : list_entry((ptr)->member.next, type, member))
+
+#define list_prev(ptr, head, type, member)                                     \
+    (((ptr)->member.prev == head)                                              \
+         ? NULL                                                                \
+         : list_entry((ptr)->member.prev, type, member))
+
+#endif /* _LLIST_H */
diff --git a/libglusterfs/src/glusterfs/lkowner.h b/libglusterfs/src/glusterfs/lkowner.h
new file mode 100644
index 00000000000..692de34bc7a
--- /dev/null
+++ b/libglusterfs/src/glusterfs/lkowner.h
@@ -0,0 +1,93 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _LK_OWNER_H
+#define _LK_OWNER_H
+
+#include "glusterfs/glusterfs-fops.h"
+
+/* LKOWNER to string functions */
+static inline void
+lkowner_unparse(gf_lkowner_t *lkowner, char *buf, int buf_len)
+{
+    int i = 0;
+    int j = 0;
+
+    for (i = 0; i < lkowner->len; i++) {
+        if (i && !(i % 8)) {
+            buf[j] = '-';
+            j++;
+        }
+        sprintf(&buf[j], "%02hhx", lkowner->data[i]);
+        j += 2;
+        if (j == buf_len)
+            break;
+    }
+    if (j < buf_len)
+        buf[j] = '\0';
+}
+
+static inline void
+set_lk_owner_from_ptr(gf_lkowner_t *lkowner, void *data)
+{
+    int i = 0;
+    int j = 0;
+
+    lkowner->len = sizeof(unsigned long);
+    for (i = 0, j = 0; i < lkowner->len; i++, j += 8) {
+        lkowner->data[i] = (char)((((unsigned long)data) >> j) & 0xff);
+    }
+}
+
+static inline void
+set_lk_owner_from_uint64(gf_lkowner_t *lkowner, uint64_t data)
+{
+    int i = 0;
+    int j = 0;
+
+    lkowner->len = 8;
+    for (i = 0, j = 0; i < lkowner->len; i++, j += 8) {
+        lkowner->data[i] = (char)((data >> j) & 0xff);
+    }
+}
+
+/* Return true if the locks have the same owner */
+static inline int
+is_same_lkowner(gf_lkowner_t *l1, gf_lkowner_t *l2)
+{
+    return ((l1->len == l2->len) && !memcmp(l1->data, l2->data, l1->len));
+}
+
+static inline int
+is_lk_owner_null(gf_lkowner_t *lkowner)
+{
+    int is_null = 1;
+    int i = 0;
+
+    if (lkowner == NULL || lkowner->len == 0)
+        goto out;
+
+    for (i = 0; i < lkowner->len; i++) {
+        if (lkowner->data[i] != 0) {
+            is_null = 0;
+            break;
+        }
+    }
+out:
+    return is_null;
+}
+
+static inline void
+lk_owner_copy(gf_lkowner_t *dst, gf_lkowner_t *src)
+{
+    dst->len = src->len;
+    memcpy(dst->data, src->data, src->len);
+}
+#endif /* _LK_OWNER_H */
diff --git a/libglusterfs/src/locking.h b/libglusterfs/src/glusterfs/locking.h
index 71b6a286e6c..43cc87735d1 100644
--- a/libglusterfs/src/locking.h
+++ b/libglusterfs/src/glusterfs/locking.h
@@ -13,7 +13,7 @@
 
 #include <pthread.h>
 
-#if defined (GF_DARWIN_HOST_OS)
+#if defined(GF_DARWIN_HOST_OS)
 #include <libkern/OSAtomic.h>
 #define pthread_spinlock_t OSSpinLock
 #define pthread_spin_lock(l) OSSpinLockLock(l)
@@ -22,11 +22,11 @@
 #define pthread_spin_init(l, v) (*l = v)
 #endif
 
-#if defined (HAVE_SPINLOCK)
+#if defined(HAVE_SPINLOCK)
 
 typedef union {
-        pthread_spinlock_t      spinlock;
-        pthread_mutex_t         mutex;
+    pthread_spinlock_t spinlock;
+    pthread_mutex_t mutex;
 } gf_lock_t;
 
 #if !defined(LOCKING_IMPL)
@@ -47,25 +47,25 @@ extern int use_spinlocks;
  * worth the extra complexity, but for now this way seems preferable.
  */
 
-#define LOCK_INIT(x)    (use_spinlocks \
-                                ? pthread_spin_init  (&((x)->spinlock), 0) \
-                                : pthread_mutex_init (&((x)->mutex), 0))
+#define LOCK_INIT(x)                                                           \
+    (use_spinlocks ? pthread_spin_init(&((x)->spinlock), 0)                    \
+                   : pthread_mutex_init(&((x)->mutex), 0))
 
-#define LOCK(x)         (use_spinlocks \
-                                ? pthread_spin_lock  (&((x)->spinlock)) \
-                                : pthread_mutex_lock (&((x)->mutex)))
+#define LOCK(x)                                                                \
+    (use_spinlocks ? pthread_spin_lock(&((x)->spinlock))                       \
+                   : pthread_mutex_lock(&((x)->mutex)))
 
-#define TRY_LOCK(x)     (use_spinlocks \
-                                ? pthread_spin_trylock  (&((x)->spinlock)) \
-                                : pthread_mutex_trylock (&((x)->mutex)))
+#define TRY_LOCK(x)                                                            \
+    (use_spinlocks ? pthread_spin_trylock(&((x)->spinlock))                    \
+                   : pthread_mutex_trylock(&((x)->mutex)))
 
-#define UNLOCK(x)       (use_spinlocks \
-                                ? pthread_spin_unlock  (&((x)->spinlock)) \
-                                : pthread_mutex_unlock (&((x)->mutex)))
+#define UNLOCK(x)                                                              \
+    (use_spinlocks ? pthread_spin_unlock(&((x)->spinlock))                     \
+                   : pthread_mutex_unlock(&((x)->mutex)))
 
-#define LOCK_DESTROY(x) (use_spinlocks \
-                                ? pthread_spin_destroy  (&((x)->spinlock)) \
-                                : pthread_mutex_destroy (&((x)->mutex)))
+#define LOCK_DESTROY(x)                                                        \
+    (use_spinlocks ? pthread_spin_destroy(&((x)->spinlock))                    \
+                   : pthread_mutex_destroy(&((x)->mutex)))
 
 #endif
 
@@ -73,13 +73,12 @@ extern int use_spinlocks;
 
 typedef pthread_mutex_t gf_lock_t;
 
-#define LOCK_INIT(x)    pthread_mutex_init (x, 0)
-#define LOCK(x)         pthread_mutex_lock (x)
-#define TRY_LOCK(x)     pthread_mutex_trylock (x)
-#define UNLOCK(x)       pthread_mutex_unlock (x)
-#define LOCK_DESTROY(x) pthread_mutex_destroy (x)
+#define LOCK_INIT(x) pthread_mutex_init(x, 0)
+#define LOCK(x) pthread_mutex_lock(x)
+#define TRY_LOCK(x) pthread_mutex_trylock(x)
+#define UNLOCK(x) pthread_mutex_unlock(x)
+#define LOCK_DESTROY(x) pthread_mutex_destroy(x)
 
 #endif /* HAVE_SPINLOCK */
 
-
 #endif /* _LOCKING_H */
diff --git a/libglusterfs/src/glusterfs/logging.h b/libglusterfs/src/glusterfs/logging.h
new file mode 100644
index 00000000000..b3a6ac191f0
--- /dev/null
+++ b/libglusterfs/src/glusterfs/logging.h
@@ -0,0 +1,383 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __LOGGING_H__
+#define __LOGGING_H__
+
+#include <sys/time.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <pthread.h>
+#include "glusterfs/list.h"
+
+#ifdef GF_DARWIN_HOST_OS
+#define GF_PRI_FSBLK "u"
+#define GF_PRI_DEV PRId32
+#define GF_PRI_INODE PRIu64
+#define GF_PRI_NLINK PRIu32
+#define GF_PRI_SECOND "ld"
+#define GF_PRI_SUSECONDS "06d"
+#define GF_PRI_SNSECONDS "09ld"
+#define GF_PRI_USEC "d"
+#else
+#define GF_PRI_FSBLK PRIu64
+#define GF_PRI_DEV PRIu64
+#define GF_PRI_INODE PRIu64
+#define GF_PRI_NLINK PRIu32
+#define GF_PRI_SECOND "lu"
+#define GF_PRI_SUSECONDS "06ld"
+#define GF_PRI_SNSECONDS "09ld"
+#define GF_PRI_USEC "ld"
+#endif
+#define GF_PRI_BLKSIZE PRId32
+#define GF_PRI_SIZET "zu"
+#define GF_PRI_ATOMIC PRIu64
+
+#ifdef GF_DARWIN_HOST_OS
+#define GF_PRI_TIME "ld"
+#else
+#define GF_PRI_TIME PRIu64
+#endif
+
+#if 0
+/* Syslog definitions :-) */
+#define LOG_EMERG 0   /* system is unusable */
+#define LOG_ALERT 1   /* action must be taken immediately */
+#define LOG_CRIT 2    /* critical conditions */
+#define LOG_ERR 3     /* error conditions */
+#define LOG_WARNING 4 /* warning conditions */
+#define LOG_NOTICE 5  /* normal but significant condition */
+#define LOG_INFO 6    /* informational */
+#define LOG_DEBUG 7   /* debug-level messages */
+#endif
+
+#define GF_LOG_FORMAT_NO_MSG_ID "no-msg-id"
+#define GF_LOG_FORMAT_WITH_MSG_ID "with-msg-id"
+
+#define GF_LOGGER_GLUSTER_LOG "gluster-log"
+#define GF_LOGGER_SYSLOG "syslog"
+
+typedef enum {
+    GF_LOG_NONE,
+    GF_LOG_EMERG,
+    GF_LOG_ALERT,
+    GF_LOG_CRITICAL, /* fatal errors */
+    GF_LOG_ERROR,    /* major failures (not necessarily fatal) */
+    GF_LOG_WARNING,  /* info about normal operation */
+    GF_LOG_NOTICE,
+    GF_LOG_INFO,  /* Normal information */
+    GF_LOG_DEBUG, /* internal errors */
+    GF_LOG_TRACE, /* full trace of operation */
+} gf_loglevel_t;
+
+/* format for the logs */
+typedef enum {
+    gf_logformat_traditional = 0, /* Format as in gluster 3.5 */
+    gf_logformat_withmsgid, /* Format enhanced with MsgID, ident, errstr */
+    gf_logformat_cee        /* log enhanced format in cee */
+} gf_log_format_t;
+
+/* log infrastructure to log to */
+typedef enum {
+    gf_logger_glusterlog = 0, /* locations and files as in gluster 3.5 */
+    gf_logger_syslog          /* log to (r)syslog, based on (r)syslog conf */
+    /* NOTE: In the future journald, lumberjack, next new thing here */
+} gf_log_logger_t;
+
+#define DEFAULT_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
+#define DEFAULT_QUOTA_CRAWL_LOG_DIRECTORY DATADIR "/log/glusterfs/quota_crawl"
+#define DEFAULT_LOG_LEVEL GF_LOG_INFO
+
+typedef struct gf_log_handle_ {
+    pthread_mutex_t logfile_mutex;
+    gf_loglevel_t loglevel;
+    gf_loglevel_t sys_log_level;
+    int gf_log_syslog;
+    char *filename;
+    FILE *logfile;
+    FILE *gf_log_logfile;
+    char *cmd_log_filename;
+    FILE *cmdlogfile;
+    gf_log_logger_t logger;
+    gf_log_format_t logformat;
+    char *ident;
+    int log_control_file_found;
+    struct list_head lru_queue;
+    pthread_mutex_t log_buf_lock;
+    struct _gf_timer *log_flush_timer;
+    int localtime;
+    uint32_t lru_size;
+    uint32_t lru_cur_size;
+    uint32_t timeout;
+    uint8_t logrotate;
+    uint8_t cmd_history_logrotate;
+} gf_log_handle_t;
+
+typedef struct log_buf_ {
+    char *msg;
+    uint64_t msg_id;
+    int errnum;
+    struct timeval oldest;
+    struct timeval latest;
+    char *domain;
+    char *file;
+    char *function;
+    int32_t line;
+    gf_loglevel_t level;
+    int refcount;
+    int graph_id;
+    struct list_head msg_list;
+} log_buf_t;
+
+void
+gf_log_globals_init(void *ctx, gf_loglevel_t level);
+int
+gf_log_init(void *data, const char *filename, const char *ident);
+
+void
+gf_log_logrotate(int signum);
+
+void
+gf_log_cleanup(void);
+
+/* Internal interfaces to log messages with message IDs */
+int
+_gf_msg(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, int errnum, int trace,
+        uint64_t msgid, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 9, 10)));
+
+void
+_gf_msg_backtrace_nomem(gf_loglevel_t level, int stacksize);
+
+int
+_gf_msg_plain(gf_loglevel_t level, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+int
+_gf_msg_plain_nomem(gf_loglevel_t level, const char *msg);
+
+int
+_gf_msg_vplain(gf_loglevel_t level, const char *fmt, va_list ap);
+
+int
+_gf_msg_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size);
+
+int
+_gf_log(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 6, 7)));
+
+int
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int32_t line, gf_loglevel_t level, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 6, 7)));
+
+int
+_gf_log_eh(const char *function, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+/* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
+ * other level as is */
+#define SET_LOG_PRIO(level, priority)                                          \
+    do {                                                                       \
+        if (GF_LOG_TRACE == (level) || GF_LOG_NONE == (level)) {               \
+            priority = LOG_DEBUG;                                              \
+        } else {                                                               \
+            priority = (level)-1;                                              \
+        }                                                                      \
+    } while (0)
+
+/* extract just the file name from the path */
+#define GET_FILE_NAME_TO_LOG(file, basename)                                   \
+    do {                                                                       \
+        basename = strrchr((file), '/');                                       \
+        if (basename)                                                          \
+            basename++;                                                        \
+        else                                                                   \
+            basename = (file);                                                 \
+    } while (0)
+
+#define PRINT_SIZE_CHECK(ret, label, strsize)                                  \
+    do {                                                                       \
+        if (ret < 0)                                                           \
+            goto label;                                                        \
+        if ((strsize - ret) > 0) {                                             \
+            strsize -= ret;                                                    \
+        } else {                                                               \
+            ret = 0;                                                           \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define FMT_WARN(fmt...)                                                       \
+    do {                                                                       \
+        if (0)                                                                 \
+            printf(fmt);                                                       \
+    } while (0)
+
+/* Interface to log messages with message IDs */
+#define gf_msg(dom, level, errnum, msgid, fmt...)                              \
+    do {                                                                       \
+        _gf_msg(dom, __FILE__, __FUNCTION__, __LINE__, level, errnum, 0,       \
+                msgid, ##fmt);                                                 \
+    } while (0)
+
+/* no frills, no thrills, just a vanilla message, used to print the graph */
+#define gf_msg_plain(level, fmt...)                                            \
+    do {                                                                       \
+        _gf_msg_plain(level, ##fmt);                                           \
+    } while (0)
+
+#define gf_msg_plain_nomem(level, msg)                                         \
+    do {                                                                       \
+        _gf_msg_plain_nomem(level, msg);                                       \
+    } while (0)
+
+#define gf_msg_vplain(level, fmt, va)                                          \
+    do {                                                                       \
+        _gf_msg_vplain(level, fmt, va);                                        \
+    } while (0)
+
+#define gf_msg_backtrace_nomem(level, stacksize)                               \
+    do {                                                                       \
+        _gf_msg_backtrace_nomem(level, stacksize);                             \
+    } while (0)
+
+#define gf_msg_callingfn(dom, level, errnum, msgid, fmt...)                    \
+    do {                                                                       \
+        _gf_msg(dom, __FILE__, __FUNCTION__, __LINE__, level, errnum, 1,       \
+                msgid, ##fmt);                                                 \
+    } while (0)
+
+/* No malloc or calloc should be called in this function */
+#define gf_msg_nomem(dom, level, size)                                         \
+    do {                                                                       \
+        _gf_msg_nomem(dom, __FILE__, __FUNCTION__, __LINE__, level, size);     \
+    } while (0)
+
+/* Debug or trace messages do not need message IDs as these are more developer
+ * related. Hence, the following abstractions are provided for the same */
+#define gf_msg_debug(dom, errnum, fmt...)                                      \
+    do {                                                                       \
+        _gf_msg(dom, __FILE__, __FUNCTION__, __LINE__, GF_LOG_DEBUG, errnum,   \
+                0, 0, ##fmt);                                                  \
+    } while (0)
+
+#define gf_msg_trace(dom, errnum, fmt...)                                      \
+    do {                                                                       \
+        _gf_msg(dom, __FILE__, __FUNCTION__, __LINE__, GF_LOG_TRACE, errnum,   \
+                0, 0, ##fmt);                                                  \
+    } while (0)
+
+#define gf_log(dom, level, fmt...)                                             \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+        _gf_log(dom, __FILE__, __FUNCTION__, __LINE__, level, ##fmt);          \
+    } while (0)
+
+#define gf_log_eh(fmt...)                                                      \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+        _gf_log_eh(__FUNCTION__, ##fmt);                                       \
+    } while (0)
+
+#define gf_log_callingfn(dom, level, fmt...)                                   \
+    do {                                                                       \
+        FMT_WARN(fmt);                                                         \
+        _gf_log_callingfn(dom, __FILE__, __FUNCTION__, __LINE__, level,        \
+                          ##fmt);                                              \
+    } while (0)
+
+/* Log once in GF_UNIVERSAL_ANSWER times */
+#define GF_LOG_OCCASIONALLY(var, args...)                                      \
+    if (var++ == 0 || !((var - 1) % GF_UNIVERSAL_ANSWER)) {                    \
+        gf_log(args);                                                          \
+    }
+
+struct _glusterfs_ctx;
+
+void
+gf_log_disable_syslog(void);
+void
+gf_log_enable_syslog(void);
+gf_loglevel_t
+gf_log_get_loglevel(void);
+void
+gf_log_set_loglevel(struct _glusterfs_ctx *ctx, gf_loglevel_t level);
+int
+gf_log_get_localtime(void);
+void
+gf_log_set_localtime(int);
+void
+gf_log_flush(void);
+gf_loglevel_t
+gf_log_get_xl_loglevel(void *xl);
+void
+gf_log_set_xl_loglevel(void *xl, gf_loglevel_t level);
+
+int
+gf_cmd_log(const char *domain, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+int
+gf_cmd_log_init(const char *filename);
+
+void
+set_sys_log_level(gf_loglevel_t level);
+
+int
+gf_log_fini(void *data);
+
+void
+gf_log_set_logger(gf_log_logger_t logger);
+
+void
+gf_log_set_logformat(gf_log_format_t format);
+
+void
+gf_log_set_log_buf_size(uint32_t buf_size);
+
+void
+gf_log_set_log_flush_timeout(uint32_t timeout);
+
+void
+gf_log_flush_msgs(struct _glusterfs_ctx *ctx);
+
+int
+gf_log_inject_timer_event(struct _glusterfs_ctx *ctx);
+
+void
+gf_log_disable_suppression_before_exit(struct _glusterfs_ctx *ctx);
+
+#define GF_DEBUG(xl, format, args...)                                          \
+    gf_log((xl)->name, GF_LOG_DEBUG, format, ##args)
+#define GF_INFO(xl, format, args...)                                           \
+    gf_log((xl)->name, GF_LOG_INFO, format, ##args)
+#define GF_WARNING(xl, format, args...)                                        \
+    gf_log((xl)->name, GF_LOG_WARNING, format, ##args)
+#define GF_ERROR(xl, format, args...)                                          \
+    gf_log((xl)->name, GF_LOG_ERROR, format, ##args)
+
+int
+_gf_smsg(const char *domain, const char *file, const char *function,
+         int32_t line, gf_loglevel_t level, int errnum, int trace,
+         uint64_t msgid, const char *event, ...);
+
+/* Interface to log messages with message IDs */
+#define gf_smsg(dom, level, errnum, msgid, event...)                           \
+    do {                                                                       \
+        _gf_smsg(dom, __FILE__, __FUNCTION__, __LINE__, level, errnum, 0,      \
+                 msgid, msgid##_STR, ##event);                                 \
+    } while (0)
+
+#endif /* __LOGGING_H__ */
diff --git a/libglusterfs/src/lvm-defaults.h b/libglusterfs/src/glusterfs/lvm-defaults.h
index 32feebf3f6e..32feebf3f6e 100644
--- a/libglusterfs/src/lvm-defaults.h
+++ b/libglusterfs/src/glusterfs/lvm-defaults.h
diff --git a/libglusterfs/src/glusterfs/mem-pool.h b/libglusterfs/src/glusterfs/mem-pool.h
new file mode 100644
index 00000000000..e5b3276d047
--- /dev/null
+++ b/libglusterfs/src/glusterfs/mem-pool.h
@@ -0,0 +1,336 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _MEM_POOL_H_
+#define _MEM_POOL_H_
+
+#include "glusterfs/list.h"
+#include "glusterfs/atomic.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/mem-types.h"
+#include "glusterfs/glusterfs.h" /* for glusterfs_ctx_t */
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stdarg.h>
+
+/*
+ * Need this for unit tests since inline functions
+ * access memory allocation and need to use the
+ * unit test versions
+ */
+#ifdef UNIT_TESTING
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#endif
+
+#define GF_MEM_TRAILER_SIZE 8
+#define GF_MEM_HEADER_MAGIC 0xCAFEBABE
+#define GF_MEM_TRAILER_MAGIC 0xBAADF00D
+#define GF_MEM_INVALID_MAGIC 0xDEADC0DE
+
+#define POOL_SMALLEST 7 /* i.e. 128 */
+#define POOL_LARGEST 20 /* i.e. 1048576 */
+#define NPOOLS (POOL_LARGEST - POOL_SMALLEST + 1)
+
+struct mem_acct_rec {
+    const char *typestr;
+    uint64_t size;
+    uint64_t max_size;
+    uint64_t total_allocs;
+    uint32_t num_allocs;
+    uint32_t max_num_allocs;
+    gf_lock_t lock;
+#ifdef DEBUG
+    struct list_head obj_list;
+#endif
+};
+
+struct mem_acct {
+    uint32_t num_types;
+    gf_atomic_t refcnt;
+    struct mem_acct_rec rec[0];
+};
+
+struct mem_header {
+    uint32_t type;
+    size_t size;
+    struct mem_acct *mem_acct;
+    uint32_t magic;
+#ifdef DEBUG
+    struct list_head acct_list;
+#endif
+    int padding[8];
+};
+
+#define GF_MEM_HEADER_SIZE (sizeof(struct mem_header))
+
+#ifdef DEBUG
+struct mem_invalid {
+    uint32_t magic;
+    void *mem_acct;
+    uint32_t type;
+    size_t size;
+    void *baseaddr;
+};
+#endif
+
+void *
+__gf_calloc(size_t cnt, size_t size, uint32_t type, const char *typestr);
+
+void *
+__gf_malloc(size_t size, uint32_t type, const char *typestr);
+
+void *
+__gf_realloc(void *ptr, size_t size);
+
+int
+gf_vasprintf(char **string_ptr, const char *format, va_list arg);
+
+int
+gf_asprintf(char **string_ptr, const char *format, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+void
+__gf_free(void *ptr);
+
+static inline void *
+__gf_default_malloc(size_t size)
+{
+    void *ptr = NULL;
+
+    ptr = malloc(size);
+    if (!ptr)
+        gf_msg_nomem("", GF_LOG_ALERT, size);
+
+    return ptr;
+}
+
+static inline void *
+__gf_default_calloc(int cnt, size_t size)
+{
+    void *ptr = NULL;
+
+    ptr = calloc(cnt, size);
+    if (!ptr)
+        gf_msg_nomem("", GF_LOG_ALERT, (cnt * size));
+
+    return ptr;
+}
+
+static inline void *
+__gf_default_realloc(void *oldptr, size_t size)
+{
+    void *ptr = NULL;
+
+    ptr = realloc(oldptr, size);
+    if (!ptr)
+        gf_msg_nomem("", GF_LOG_ALERT, size);
+
+    return ptr;
+}
+
+#define MALLOC(size) __gf_default_malloc(size)
+#define CALLOC(cnt, size) __gf_default_calloc(cnt, size)
+#define REALLOC(ptr, size) __gf_default_realloc(ptr, size)
+
+#define FREE(ptr)                                                              \
+    do {                                                                       \
+        if (ptr != NULL) {                                                     \
+            free((void *)ptr);                                                 \
+            ptr = (void *)0xeeeeeeee;                                          \
+        }                                                                      \
+    } while (0)
+
+#define GF_CALLOC(nmemb, size, type) __gf_calloc(nmemb, size, type, #type)
+
+#define GF_MALLOC(size, type) __gf_malloc(size, type, #type)
+
+#define GF_REALLOC(ptr, size) __gf_realloc(ptr, size)
+
+#define GF_FREE(free_ptr) __gf_free(free_ptr)
+
+static inline char *
+gf_strndup(const char *src, size_t len)
+{
+    char *dup_str = NULL;
+
+    if (!src) {
+        goto out;
+    }
+
+    dup_str = GF_MALLOC(len + 1, gf_common_mt_strdup);
+    if (!dup_str) {
+        goto out;
+    }
+
+    memcpy(dup_str, src, len);
+    dup_str[len] = '\0';
+out:
+    return dup_str;
+}
+
+static inline char *
+gf_strdup(const char *src)
+{
+    if (!src)
+        return NULL;
+
+    return gf_strndup(src, strlen(src));
+}
+
+static inline void *
+gf_memdup(const void *src, size_t size)
+{
+    void *dup_mem = NULL;
+
+    dup_mem = GF_MALLOC(size, gf_common_mt_memdup);
+    if (!dup_mem)
+        goto out;
+
+    memcpy(dup_mem, src, size);
+
+out:
+    return dup_mem;
+}
+
+#ifdef GF_DISABLE_MEMPOOL
+
+/* No-op memory pool enough to fit current API without massive redesign. */
+
+struct mem_pool {
+    unsigned long sizeof_type;
+};
+
+#define mem_pools_init()                                                       \
+    do {                                                                       \
+    } while (0)
+#define mem_pools_fini()                                                       \
+    do {                                                                       \
+    } while (0)
+#define mem_pool_thread_destructor(pool_list) (void)pool_list
+
+#else /* !GF_DISABLE_MEMPOOL */
+
+/* kind of 'header' for the actual mem_pool_shared structure, this might make
+ * it possible to dump some more details in a statedump */
+struct mem_pool {
+    /* object size, without pooled_obj_hdr_t */
+    unsigned long sizeof_type;
+    unsigned long count; /* requested pool size (unused) */
+    char *name;
+    char *xl_name;
+    gf_atomic_t active;     /* current allocations */
+#ifdef DEBUG
+    gf_atomic_t hit;        /* number of allocations served from pt_pool */
+    gf_atomic_t miss;       /* number of std allocs due to miss */
+#endif
+    struct list_head owner; /* glusterfs_ctx_t->mempool_list */
+    glusterfs_ctx_t *ctx;   /* take ctx->lock when updating owner */
+
+    struct mem_pool_shared *pool; /* the initial pool that was returned */
+};
+
+typedef struct pooled_obj_hdr {
+    unsigned long magic;
+    struct pooled_obj_hdr *next;
+    struct per_thread_pool_list *pool_list;
+    unsigned int power_of_two;
+
+    /* track the pool that was used to request this object */
+    struct mem_pool *pool;
+} pooled_obj_hdr_t;
+
+/* Each memory block inside a pool has a fixed size that is a power of two.
+ * However each object will have a header that will reduce the available
+ * space. */
+#define AVAILABLE_SIZE(p2) ((1UL << (p2)) - sizeof(pooled_obj_hdr_t))
+
+typedef struct per_thread_pool {
+    /* the pool that was used to request this allocation */
+    struct mem_pool_shared *parent;
+    /* Everything else is protected by our own lock. */
+    pooled_obj_hdr_t *hot_list;
+    pooled_obj_hdr_t *cold_list;
+} per_thread_pool_t;
+
+typedef struct per_thread_pool_list {
+    /* thr_list is used to place the TLS pool_list into the active global list
+     * (pool_threads) or the inactive global list (pool_free_threads). It's
+     * protected by the global pool_lock. */
+    struct list_head thr_list;
+
+    /* This lock is used to update poison and the hot/cold lists of members
+     * of 'pools' array. */
+    pthread_spinlock_t lock;
+
+    /* This field is used to mark a pool_list as not being owned by any thread.
+     * This means that the sweeper thread won't be cleaning objects stored in
+     * its pools. mem_put() uses it to decide if the object being released is
+     * placed into its original pool_list or directly destroyed. */
+    bool poison;
+
+    /*
+     * There's really more than one pool, but the actual number is hidden
+     * in the implementation code so we just make it a single-element array
+     * here.
+     */
+    per_thread_pool_t pools[1];
+} per_thread_pool_list_t;
+
+/* actual pool structure, shared between different mem_pools */
+struct mem_pool_shared {
+    unsigned int power_of_two;
+    /*
+     * Updates to these are *not* protected by a global lock, so races
+     * could occur and the numbers might be slightly off.  Don't expect
+     * them to line up exactly.  It's the general trends that matter, and
+     * it's not worth the locked-bus-cycle overhead to make these precise.
+     */
+    gf_atomic_t allocs_hot;
+    gf_atomic_t allocs_cold;
+    gf_atomic_t allocs_stdc;
+    gf_atomic_t frees_to_list;
+};
+
+void
+mem_pools_init(void); /* start the pool_sweeper thread */
+void
+mem_pools_fini(void); /* cleanup memory pools */
+void
+mem_pool_thread_destructor(per_thread_pool_list_t *pool_list);
+
+#endif /* GF_DISABLE_MEMPOOL */
+
+struct mem_pool *
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+                unsigned long count, char *name);
+
+#define mem_pool_new(type, count)                                              \
+    mem_pool_new_fn(THIS->ctx, sizeof(type), count, #type)
+
+#define mem_pool_new_ctx(ctx, type, count)                                     \
+    mem_pool_new_fn(ctx, sizeof(type), count, #type)
+
+void
+mem_put(void *ptr);
+void *
+mem_get(struct mem_pool *pool);
+void *
+mem_get0(struct mem_pool *pool);
+
+void
+mem_pool_destroy(struct mem_pool *pool);
+
+void
+gf_mem_acct_enable_set(void *ctx);
+
+#endif /* _MEM_POOL_H */
diff --git a/libglusterfs/src/glusterfs/mem-types.h b/libglusterfs/src/glusterfs/mem-types.h
new file mode 100644
index 00000000000..d45d5b68c91
--- /dev/null
+++ b/libglusterfs/src/glusterfs/mem-types.h
@@ -0,0 +1,139 @@
+/*
+  Copyright (c) 2008-2016 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __MEM_TYPES_H__
+#define __MEM_TYPES_H__
+
+enum gf_common_mem_types_ {
+    gf_common_mt_dnscache6, /* used only in one location */
+    gf_common_mt_event_pool,
+    gf_common_mt_reg,
+    gf_common_mt_pollfd,    /* used only in one location */
+    gf_common_mt_fdentry_t, /* used only in one location */
+    gf_common_mt_fdtable_t, /* used only in one location */
+    gf_common_mt_fd_ctx,    /* used only in one location */
+    gf_common_mt_gf_dirent_t,
+    gf_common_mt_inode_t,   /* used only in one location */
+    gf_common_mt_inode_ctx, /* used only in one location */
+    gf_common_mt_list_head,
+    gf_common_mt_inode_table_t, /* used only in one location */
+    gf_common_mt_xlator_t,
+    gf_common_mt_xlator_list_t, /* used only in one location */
+    gf_common_mt_volume_opt_list_t,
+    gf_common_mt_gf_timer_t,          /* used only in one location */
+    gf_common_mt_gf_timer_registry_t, /* used only in one location */
+    gf_common_mt_auth_handle_t,       /* used only in one location */
+    gf_common_mt_iobuf,               /* used only in one location */
+    gf_common_mt_iobuf_arena,         /* used only in one location */
+    gf_common_mt_iobref,              /* used only in one location */
+    gf_common_mt_iobuf_pool,          /* used only in one location */
+    gf_common_mt_iovec,
+    gf_common_mt_memdup,   /* used only in one location */
+    gf_common_mt_asprintf, /* used only in one location */
+    gf_common_mt_strdup,
+    gf_common_mt_socket_private_t, /* used only in one location */
+    gf_common_mt_ioq,              /* used only in one location */
+    gf_common_mt_char,
+    gf_common_mt_rbthash_table_t,      /* used only in one location */
+    gf_common_mt_rbthash_bucket,       /* used only in one location */
+    gf_common_mt_mem_pool,             /* used only in one location */
+    gf_common_mt_rpcsvc_auth_list,     /* used only in one location */
+    gf_common_mt_rpcsvc_t,             /* used only in one location */
+    gf_common_mt_rpcsvc_program_t,     /* used only in one location */
+    gf_common_mt_rpcsvc_listener_t,    /* used only in one location */
+    gf_common_mt_rpcsvc_wrapper_t,     /* used only in one location */
+    gf_common_mt_rpcclnt_t,            /* used only in one location */
+    gf_common_mt_rpcclnt_savedframe_t, /* used only in one location */
+    gf_common_mt_rpc_trans_t,
+    gf_common_mt_rpc_trans_pollin_t,  /* used only in one location */
+    gf_common_mt_rpc_trans_reqinfo_t, /* used only in one location */
+    gf_common_mt_glusterfs_graph_t,
+    gf_common_mt_rdma_private_t,       /* used only in one location */
+    gf_common_mt_rpc_transport_t,      /* used only in one location */
+    gf_common_mt_rdma_post_t,          /* used only in one location */
+    gf_common_mt_qpent,                /* used only in one location */
+    gf_common_mt_rdma_device_t,        /* used only in one location */
+    gf_common_mt_rdma_arena_mr,        /* used only in one location */
+    gf_common_mt_sge,                  /* used only in one location */
+    gf_common_mt_rpcclnt_cb_program_t, /* used only in one location */
+    gf_common_mt_libxl_marker_local,   /* used only in one location */
+    gf_common_mt_graph_buf,            /* used only in one location */
+    gf_common_mt_trie_trie,            /* used only in one location */
+    gf_common_mt_trie_data,            /* used only in one location */
+    gf_common_mt_trie_node,            /* used only in one location */
+    gf_common_mt_trie_buf,             /* used only in one location */
+    gf_common_mt_run_argv,             /* used only in one location */
+    gf_common_mt_run_logbuf,           /* used only in one location */
+    gf_common_mt_fd_lk_ctx_t,          /* used only in one location */
+    gf_common_mt_fd_lk_ctx_node_t,     /* used only in one location */
+    gf_common_mt_buffer_t,             /* used only in one location */
+    gf_common_mt_circular_buffer_t,    /* used only in one location */
+    gf_common_mt_eh_t,
+    gf_common_mt_store_handle_t, /* used only in one location */
+    gf_common_mt_store_iter_t,   /* used only in one location */
+    gf_common_mt_drc_client_t,   /* used only in one location */
+    gf_common_mt_drc_globals_t,  /* used only in one location */
+    gf_common_mt_groups_t,
+    gf_common_mt_cliententry_t, /* used only in one location */
+    gf_common_mt_clienttable_t, /* used only in one location */
+    gf_common_mt_client_t,      /* used only in one location */
+    gf_common_mt_client_ctx,    /* used only in one location */
+    gf_common_mt_auxgids,       /* used only in one location */
+    gf_common_mt_syncopctx,     /* used only in one location */
+    gf_common_mt_iobrefs,       /* used only in one location */
+    gf_common_mt_gsync_status_t,
+    gf_common_mt_uuid_t,
+    gf_common_mt_mgmt_v3_lock_obj_t, /* used only in one location */
+    gf_common_mt_txn_opinfo_obj_t,   /* used only in one location */
+    gf_common_mt_strfd_t,            /* used only in one location */
+    gf_common_mt_strfd_data_t,       /* used only in one location */
+    gf_common_mt_regex_t,            /* used only in one location */
+    gf_common_mt_ereg,               /* used only in one location */
+    gf_common_mt_wr,                 /* used only in one location */
+    gf_common_mt_dnscache,           /* used only in one location */
+    gf_common_mt_dnscache_entry,     /* used only in one location */
+    gf_common_mt_parser_t,           /* used only in one location */
+    gf_common_quota_meta_t,
+    gf_common_mt_rbuf_t,  /* used only in one location */
+    gf_common_mt_rlist_t, /* used only in one location */
+    gf_common_mt_rvec_t,  /* used only in one location */
+    /* glusterd can load the nfs-xlator dynamically and needs these two */
+    gf_common_mt_nfs_netgroups,   /* used only in one location */
+    gf_common_mt_nfs_exports,     /* used only in one location */
+    gf_common_mt_gf_brick_spec_t, /* used only in one location */
+    gf_common_mt_int,
+    gf_common_mt_pointer,
+    gf_common_mt_synctask,  /* used only in one location */
+    gf_common_mt_syncstack, /* used only in one location */
+    gf_common_mt_syncenv,   /* used only in one location */
+    gf_common_mt_scan_data, /* used only in one location */
+    gf_common_list_node,
+    gf_mt_default_args_t,     /* used only in one location */
+    gf_mt_default_args_cbk_t, /* used only in one location */
+    /*used for compound fops*/
+    gf_mt_compound_req_t, /* used only in one location */
+    gf_mt_compound_rsp_t, /* used only in one location */
+    gf_common_mt_tw_ctx,  /* used only in one location */
+    gf_common_mt_tw_timer_list,
+    /*lock migration*/
+    gf_common_mt_lock_mig,
+    /* throttle */
+    gf_common_mt_tbf_t,          /* used only in one location */
+    gf_common_mt_tbf_bucket_t,   /* used only in one location */
+    gf_common_mt_tbf_throttle_t, /* used only in one location */
+    gf_common_mt_pthread_t,      /* used only in one location */
+    gf_common_ping_local_t,      /* used only in one location */
+    gf_common_volfile_t,
+    gf_common_mt_mgmt_v3_lock_timer_t, /* used only in one location */
+    gf_common_mt_server_cmdline_t,     /* used only in one location */
+    gf_common_mt_latency_t,
+    gf_common_mt_end
+};
+#endif
diff --git a/libglusterfs/src/glusterfs/monitoring.h b/libglusterfs/src/glusterfs/monitoring.h
new file mode 100644
index 00000000000..09d9f54e734
--- /dev/null
+++ b/libglusterfs/src/glusterfs/monitoring.h
@@ -0,0 +1,21 @@
+/*
+  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __MONITORING_H__
+#define __MONITORING_H__
+
+#include "glusterfs/glusterfs.h"
+
+#define GLUSTER_METRICS_DIR "/var/run/gluster/metrics"
+
+char *
+gf_monitor_metrics(glusterfs_ctx_t *ctx);
+
+#endif /* __MONITORING_H__ */
diff --git a/libglusterfs/src/glusterfs/options.h b/libglusterfs/src/glusterfs/options.h
new file mode 100644
index 00000000000..747b13ba375
--- /dev/null
+++ b/libglusterfs/src/glusterfs/options.h
@@ -0,0 +1,327 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _OPTIONS_H
+#define _OPTIONS_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "glusterfs/xlator.h"
+#include "glusterfs/libglusterfs-messages.h"
+/* Add possible new type of option you may need */
+typedef enum {
+    GF_OPTION_TYPE_ANY = 0,
+    GF_OPTION_TYPE_STR,
+    GF_OPTION_TYPE_INT,
+    GF_OPTION_TYPE_SIZET,
+    GF_OPTION_TYPE_PERCENT,
+    GF_OPTION_TYPE_PERCENT_OR_SIZET,
+    GF_OPTION_TYPE_BOOL,
+    GF_OPTION_TYPE_XLATOR,
+    GF_OPTION_TYPE_PATH,
+    GF_OPTION_TYPE_TIME,
+    GF_OPTION_TYPE_DOUBLE,
+    GF_OPTION_TYPE_INTERNET_ADDRESS,
+    GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
+    GF_OPTION_TYPE_PRIORITY_LIST,
+    GF_OPTION_TYPE_SIZE_LIST,
+    GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
+    GF_OPTION_TYPE_MAX,
+} volume_option_type_t;
+
+typedef enum {
+    GF_OPT_VALIDATE_BOTH = 0,
+    GF_OPT_VALIDATE_MIN,
+    GF_OPT_VALIDATE_MAX,
+} opt_validate_type_t;
+
+typedef enum {
+    OPT_FLAG_NONE = 0,
+    OPT_FLAG_SETTABLE = 1 << 0,   /* can be set using volume set */
+    OPT_FLAG_CLIENT_OPT = 1 << 1, /* affects clients */
+    OPT_FLAG_GLOBAL = 1
+                      << 2, /* affects all instances of the particular xlator */
+    OPT_FLAG_FORCE = 1 << 3,       /* needs force to be reset */
+    OPT_FLAG_NEVER_RESET = 1 << 4, /* which should not be reset */
+    OPT_FLAG_DOC = 1 << 5,         /* can be shown in volume set help */
+} opt_flags_t;
+
+typedef enum {
+    OPT_STATUS_ADVANCED = 0,
+    OPT_STATUS_BASIC = 1,
+    OPT_STATUS_EXPERIMENTAL = 2,
+    OPT_STATUS_DEPRECATED = 3,
+} opt_level_t;
+
+#define ZR_VOLUME_MAX_NUM_KEY 4
+#define ZR_OPTION_MAX_ARRAY_SIZE 64
+/* The maximum number of releases that an option could be backported to
+ * based on the release schedule as in August 2017 (3), plus one more
+ * Refer comment on volume_options.op_version for more information.
+ */
+#define GF_MAX_RELEASES 4
+
+/* Custom validation functoins for options
+ * TODO: Need to check what sorts of validation is being done, and decide if
+ * passing the volinfo is actually required. If it is, then we should possibly
+ * try a solution in GD2 for this.
+ */
+/* typedef int (*option_validation_fn) (glusterd_volinfo_t *volinfo, dict_t
+ *dict, char *key, char *value, char **op_errstr);
+ */
+
+/* Each translator should define this structure */
+/* XXX: This structure is in use by GD2, and SHOULD NOT be modified.
+ * If there is a need to add new members, add them to the end of the structure.
+ * If the struct must be modified, GD2 MUST be updated as well
+ */
+typedef struct volume_options {
+    char *key[ZR_VOLUME_MAX_NUM_KEY];
+    /* different key, same meaning */
+    volume_option_type_t type;
+    double min; /* 0 means no range */
+    double max; /* 0 means no range */
+    char *value[ZR_OPTION_MAX_ARRAY_SIZE];
+    /* If specified, will check for one of
+       the value from this array */
+    char *default_value;
+    char *description; /* about the key */
+    /* Required for int options where only the min value
+     * is given and is 0. This will cause validation not to
+     * happen
+     */
+    opt_validate_type_t validate;
+
+    /* The op-version at which this option was introduced.
+     * This is an array to support options that get backported to supported
+     * releases.
+     * Normally, an option introduced for a major release just has a single
+     * entry in the array, with op-version of the major release
+     * For an option that is backported, the op-versions of the all the
+     * releases it was ported to should be added, starting from the newest,
+     * to the oldest.
+     */
+    uint32_t op_version[GF_MAX_RELEASES];
+    /* The op-version at which this option was deprecated.
+     * Follows the same rules as above.
+     */
+    uint32_t deprecated[GF_MAX_RELEASES];
+    /* Additional flags for an option
+     * Check the OPT_FLAG_* enums for available flags
+     */
+    uint32_t flags;
+    /* Tags applicable to this option, which can be used to group similar
+     * options
+     */
+    char *tags[ZR_OPTION_MAX_ARRAY_SIZE];
+    /* A custom validation function if required
+     * TODO: See todo above for option_validation_fn
+     */
+    /* option_validation_fn validate_fn; */
+    /* This is actual key that should be set in the options dict. Can
+     * contain varstrings
+     */
+    char *setkey;
+
+    /* A 'level' is about the technical depth / understanding one
+       needs to handle the option. 'category' is based on
+       quality (ie, tests, people behind it, documentation available) */
+
+    /* The level at which the option is classified */
+    opt_level_t level;
+
+    /* Flag to understand how this option is categorized */
+    gf_category_t category;
+} volume_option_t;
+
+typedef struct vol_opt_list {
+    struct list_head list;
+    volume_option_t *given_opt;
+} volume_opt_list_t;
+
+int
+xlator_tree_reconfigure(xlator_t *old_xl, xlator_t *new_xl);
+int
+xlator_validate_rec(xlator_t *xlator, char **op_errstr);
+int
+graph_reconf_validateopt(glusterfs_graph_t *graph, char **op_errstr);
+int
+xlator_option_info_list(volume_opt_list_t *list, char *key, char **def_val,
+                        char **descr);
+/*
+int validate_xlator_volume_options (xlator_t *xl, dict_t *options,
+                                    volume_option_t *opt, char **op_errstr);
+*/
+int
+xlator_options_validate_list(xlator_t *xl, dict_t *options,
+                             volume_opt_list_t *list, char **op_errstr);
+int
+xlator_option_validate(xlator_t *xl, char *key, char *value,
+                       volume_option_t *opt, char **op_errstr);
+int
+xlator_options_validate(xlator_t *xl, dict_t *options, char **errstr);
+
+int
+xlator_option_validate_addr_list(xlator_t *xl, const char *key,
+                                 const char *value, volume_option_t *opt,
+                                 char **op_errstr);
+
+volume_option_t *
+xlator_volume_option_get(xlator_t *xl, const char *key);
+
+volume_option_t *
+xlator_volume_option_get_list(volume_opt_list_t *vol_list, const char *key);
+
+#define DECLARE_INIT_OPT(type_t, type)                                         \
+    int xlator_option_init_##type(xlator_t *this, dict_t *options, char *key,  \
+                                  type_t *val_p);
+
+DECLARE_INIT_OPT(char *, str);
+DECLARE_INIT_OPT(uint64_t, uint64);
+DECLARE_INIT_OPT(int64_t, int64);
+DECLARE_INIT_OPT(uint32_t, uint32);
+DECLARE_INIT_OPT(int32_t, int32);
+DECLARE_INIT_OPT(uint64_t, size);
+DECLARE_INIT_OPT(uint64_t, size_uint64);
+DECLARE_INIT_OPT(double, percent);
+DECLARE_INIT_OPT(double, percent_or_size);
+DECLARE_INIT_OPT(gf_boolean_t, bool);
+DECLARE_INIT_OPT(xlator_t *, xlator);
+DECLARE_INIT_OPT(char *, path);
+DECLARE_INIT_OPT(double, double);
+DECLARE_INIT_OPT(uint32_t, time);
+
+#define DEFINE_INIT_OPT(type_t, type, conv)                                    \
+    int xlator_option_init_##type(xlator_t *this, dict_t *options, char *key,  \
+                                  type_t *val_p)                               \
+    {                                                                          \
+        int ret = 0;                                                           \
+        volume_option_t *opt = NULL;                                           \
+        char *def_value = NULL;                                                \
+        char *set_value = NULL;                                                \
+        char *value = NULL;                                                    \
+        xlator_t *old_THIS = NULL;                                             \
+                                                                               \
+        opt = xlator_volume_option_get(this, key);                             \
+        if (!opt) {                                                            \
+            gf_msg(this->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ENTRY,   \
+                   "unknown option: %s", key);                                 \
+            ret = -1;                                                          \
+            return ret;                                                        \
+        }                                                                      \
+        def_value = opt->default_value;                                        \
+        ret = dict_get_str(options, key, &set_value);                          \
+                                                                               \
+        if (def_value)                                                         \
+            value = def_value;                                                 \
+        if (set_value)                                                         \
+            value = set_value;                                                 \
+        if (!value) {                                                          \
+            gf_msg_trace(this->name, 0, "option %s not set", key);             \
+            *val_p = (type_t)0;                                                \
+            return 0;                                                          \
+        }                                                                      \
+        if (value == def_value) {                                              \
+            gf_msg_trace(this->name, 0,                                        \
+                         "option %s using default"                             \
+                         " value %s",                                          \
+                         key, value);                                          \
+        } else {                                                               \
+            gf_msg_debug(this->name, 0,                                        \
+                         "option %s using set"                                 \
+                         " value %s",                                          \
+                         key, value);                                          \
+        }                                                                      \
+        old_THIS = THIS;                                                       \
+        THIS = this;                                                           \
+        ret = conv(value, val_p);                                              \
+        THIS = old_THIS;                                                       \
+        if (ret) {                                                             \
+            gf_msg(this->name, GF_LOG_INFO, 0, LG_MSG_CONVERSION_FAILED,       \
+                   "option %s conversion failed value %s", key, value);        \
+            return ret;                                                        \
+        }                                                                      \
+        ret = xlator_option_validate(this, key, value, opt, NULL);             \
+        return ret;                                                            \
+    }
+
+#define GF_OPTION_INIT(key, val, type, err_label)                              \
+    do {                                                                       \
+        int val_ret = 0;                                                       \
+        val_ret = xlator_option_init_##type(THIS, THIS->options, key, &(val)); \
+        if (val_ret)                                                           \
+            goto err_label;                                                    \
+    } while (0)
+
+#define DECLARE_RECONF_OPT(type_t, type)                                       \
+    int xlator_option_reconf_##type(xlator_t *this, dict_t *options,           \
+                                    char *key, int keylen, type_t *val_p);
+
+DECLARE_RECONF_OPT(char *, str);
+DECLARE_RECONF_OPT(uint64_t, uint64);
+DECLARE_RECONF_OPT(int64_t, int64);
+DECLARE_RECONF_OPT(uint32_t, uint32);
+DECLARE_RECONF_OPT(int32_t, int32);
+DECLARE_RECONF_OPT(uint64_t, size);
+DECLARE_RECONF_OPT(uint64_t, size_uint64);
+DECLARE_RECONF_OPT(double, percent);
+DECLARE_RECONF_OPT(double, percent_or_size);
+DECLARE_RECONF_OPT(gf_boolean_t, bool);
+DECLARE_RECONF_OPT(xlator_t *, xlator);
+DECLARE_RECONF_OPT(char *, path);
+DECLARE_RECONF_OPT(double, double);
+DECLARE_RECONF_OPT(uint32_t, time);
+
+#define DEFINE_RECONF_OPT(type_t, type, conv)                                  \
+    int xlator_option_reconf_##type(xlator_t *this, dict_t *options,           \
+                                    char *key, int keylen, type_t *val_p)      \
+    {                                                                          \
+        int ret = 0;                                                           \
+        char *value = NULL;                                                    \
+        xlator_t *old_THIS = NULL;                                             \
+                                                                               \
+        volume_option_t *opt = xlator_volume_option_get(this, key);            \
+        if (!opt) {                                                            \
+            gf_msg(this->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ENTRY,   \
+                   "unknown option: %s", key);                                 \
+            return -1;                                                         \
+        }                                                                      \
+        ret = dict_get_strn(options, key, keylen, &value);                     \
+        if (ret == 0 && value) {                                               \
+            gf_msg(this->name, GF_LOG_INFO, 0, 0,                              \
+                   "option %s using set value %s", key, value);                \
+        } else if (opt->default_value) {                                       \
+            value = opt->default_value;                                        \
+            gf_msg_trace(this->name, 0, "option %s using default value %s",    \
+                         key, value);                                          \
+        } else {                                                               \
+            gf_msg_trace(this->name, 0, "option %s not set", key);             \
+            *val_p = (type_t)0;                                                \
+            return 0;                                                          \
+        }                                                                      \
+                                                                               \
+        old_THIS = THIS;                                                       \
+        THIS = this;                                                           \
+        ret = conv(value, val_p);                                              \
+        THIS = old_THIS;                                                       \
+        if (ret)                                                               \
+            return ret;                                                        \
+        return xlator_option_validate(this, key, value, opt, NULL);            \
+    }
+
+#define GF_OPTION_RECONF(key, val, opt, type, err_label)                       \
+    do {                                                                       \
+        if (xlator_option_reconf_##type(THIS, opt, key, SLEN(key), &(val)))    \
+            goto err_label;                                                    \
+    } while (0)
+
+#endif /* !_OPTIONS_H */
diff --git a/libglusterfs/src/parse-utils.h b/libglusterfs/src/glusterfs/parse-utils.h
index 275ccf3153b..8653b9dd180 100644
--- a/libglusterfs/src/parse-utils.h
+++ b/libglusterfs/src/glusterfs/parse-utils.h
@@ -20,31 +20,31 @@
 #define GF_PARSE "parse-utils"
 
 struct parser {
-        regex_t preg;           /* Compiled regex */
-        regmatch_t pmatch[1];   /* The match */
-        char *complete_str;     /* The string we are parsing */
-        char *regex;            /* Regex used to parse the string */
-        char *_rstr;            /* Temp string to hold offsets */
+    regex_t preg;         /* Compiled regex */
+    regmatch_t pmatch[1]; /* The match */
+    char *complete_str;   /* The string we are parsing */
+    char *regex;          /* Regex used to parse the string */
+    char *_rstr;          /* Temp string to hold offsets */
 };
 
 /* Initializes some of the parsers variables */
 struct parser *
-parser_init (const char *regex);
+parser_init(const char *regex);
 
 /* Sets the string to parse */
 int
-parser_set_string (struct parser *parser, const char *complete_str);
+parser_set_string(struct parser *parser, const char *complete_str);
 
 /* Frees memory used by the string after all matches are found */
 int
-parser_unset_string (struct parser *parser);
+parser_unset_string(struct parser *parser);
 
 /* Free memory used by the parser */
 void
-parser_deinit (struct parser *ptr);
+parser_deinit(struct parser *ptr);
 
 /* Get the next matching string */
 char *
-parser_get_next_match (struct parser *parser);
+parser_get_next_match(struct parser *parser);
 
 #endif /* _PARSE_UTILS_H */
diff --git a/libglusterfs/src/glusterfs/quota-common-utils.h b/libglusterfs/src/glusterfs/quota-common-utils.h
new file mode 100644
index 00000000000..0096e340756
--- /dev/null
+++ b/libglusterfs/src/glusterfs/quota-common-utils.h
@@ -0,0 +1,68 @@
+/*
+   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#ifndef _QUOTA_COMMON_UTILS_H
+#define _QUOTA_COMMON_UTILS_H
+
+#include "glusterfs/iatt.h"
+
+#define GF_QUOTA_CONF_VERSION 1.2
+#define QUOTA_CONF_HEADER "GlusterFS Quota conf | version: v1.2\n"
+#define QUOTA_CONF_HEADER_1_1 "GlusterFS Quota conf | version: v1.1\n"
+
+typedef enum {
+    GF_QUOTA_CONF_TYPE_USAGE = 1,
+    GF_QUOTA_CONF_TYPE_OBJECTS
+} gf_quota_conf_type_t;
+
+struct _quota_limits {
+    int64_t hl;
+    int64_t sl;
+} __attribute__((__packed__));
+typedef struct _quota_limits quota_limits_t;
+
+struct _quota_meta {
+    int64_t size;
+    int64_t file_count;
+    int64_t dir_count;
+} __attribute__((__packed__));
+typedef struct _quota_meta quota_meta_t;
+
+gf_boolean_t
+quota_meta_is_null(const quota_meta_t *meta);
+
+int32_t
+quota_data_to_meta(data_t *data, quota_meta_t *meta);
+
+int32_t
+quota_dict_get_inode_meta(dict_t *dict, char *key, const int keylen,
+                          quota_meta_t *meta);
+
+int32_t
+quota_dict_get_meta(dict_t *dict, char *key, const int keylen,
+                    quota_meta_t *meta);
+
+int32_t
+quota_dict_set_meta(dict_t *dict, char *key, const quota_meta_t *meta,
+                    ia_type_t ia_type);
+
+int32_t
+quota_conf_read_header(int fd, char *buf);
+
+int32_t
+quota_conf_read_version(int fd, float *version);
+
+int32_t
+quota_conf_read_gfid(int fd, void *buf, char *type, float version);
+
+int32_t
+quota_conf_skip_header(int fd);
+
+#endif /* _QUOTA_COMMON_UTILS_H */
diff --git a/libglusterfs/src/glusterfs/rbthash.h b/libglusterfs/src/glusterfs/rbthash.h
new file mode 100644
index 00000000000..4c731de69c2
--- /dev/null
+++ b/libglusterfs/src/glusterfs/rbthash.h
@@ -0,0 +1,75 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __RBTHASH_TABLE_H_
+#define __RBTHASH_TABLE_H_
+
+#include <stdint.h>               // for uint32_t
+#include "glusterfs/glusterfs.h"  // for gf_boolean_t, glusterfs_ctx_t
+#include "glusterfs/list.h"       // for list_head
+#include "glusterfs/locking.h"    // for gf_lock_t
+struct mem_pool;
+
+#define GF_RBTHASH_MEMPOOL 16384  // 1048576
+#define GF_RBTHASH "rbthash"
+
+struct rbthash_bucket {
+    struct rb_table *bucket;
+    gf_lock_t bucketlock;
+};
+
+typedef struct rbthash_entry {
+    void *data;
+    void *key;
+    int keylen;
+    uint32_t keyhash;
+    struct list_head list;
+} rbthash_entry_t;
+
+typedef uint32_t (*rbt_hasher_t)(void *data, int len);
+typedef void (*rbt_data_destroyer_t)(void *data);
+typedef void (*rbt_traverse_t)(void *data, void *mydata);
+
+typedef struct rbthash_table {
+    int size;
+    int numbuckets;
+    struct mem_pool *entrypool;
+    gf_lock_t tablelock;
+    struct rbthash_bucket *buckets;
+    rbt_hasher_t hashfunc;
+    rbt_data_destroyer_t dfunc;
+    gf_boolean_t pool_alloced;
+    struct list_head list;
+} rbthash_table_t;
+
+extern rbthash_table_t *
+rbthash_table_init(glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
+                   rbt_data_destroyer_t dfunc, unsigned long expected_entries,
+                   struct mem_pool *entrypool);
+
+extern int
+rbthash_insert(rbthash_table_t *tbl, void *data, void *key, int keylen);
+
+extern void *
+rbthash_get(rbthash_table_t *tbl, void *key, int keylen);
+
+extern void *
+rbthash_remove(rbthash_table_t *tbl, void *key, int keylen);
+
+extern void *
+rbthash_replace(rbthash_table_t *tbl, void *key, int keylen, void *newdata);
+
+extern void
+rbthash_table_destroy(rbthash_table_t *tbl);
+
+extern void
+rbthash_table_traverse(rbthash_table_t *tbl, rbt_traverse_t traverse,
+                       void *mydata);
+#endif
diff --git a/libglusterfs/src/refcount.h b/libglusterfs/src/glusterfs/refcount.h
index 25f44258e42..cf922dabb05 100644
--- a/libglusterfs/src/refcount.h
+++ b/libglusterfs/src/glusterfs/refcount.h
@@ -17,33 +17,33 @@
  * http://lists.iptel.org/pipermail/semsdev/2010-October/005075.html
  * this is sufficient for RHEL5 i386 builds
  */
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && !defined(__i386__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) &&                \
+    !defined(__i386__)
 #undef REFCOUNT_NEEDS_LOCK
 #else
 #define REFCOUNT_NEEDS_LOCK
-#include "locking.h"
+#include "glusterfs/locking.h"
 #endif /* compiler support for __sync_*_and_fetch() */
 
 typedef void (*gf_ref_release_t)(void *data);
 
 struct _gf_ref {
 #ifdef REFCOUNT_NEEDS_LOCK
-        gf_lock_t          lk;      /* lock for atomically adjust cnt */
+    gf_lock_t lk; /* lock for atomically adjust cnt */
 #endif
-        unsigned int       cnt;     /* number of users, free on 0 */
+    unsigned int cnt; /* number of users, free on 0 */
 
-        gf_ref_release_t   release; /* cleanup when cnt == 0 */
-        void              *data;    /* parameter passed to release() */
+    gf_ref_release_t release; /* cleanup when cnt == 0 */
+    void *data;               /* parameter passed to release() */
 };
 typedef struct _gf_ref gf_ref_t;
 
-
 /* _gf_ref_get -- increase the refcount
  *
  * @return: greater then 0 when a reference was taken, 0 when not
  */
 void *
-_gf_ref_get (gf_ref_t *ref);
+_gf_ref_get(gf_ref_t *ref);
 
 /* _gf_ref_put -- decrease the refcount
  *
@@ -51,16 +51,15 @@ _gf_ref_get (gf_ref_t *ref);
  *          should be done, gf_ref_release_t is called on cleanup
  */
 unsigned int
-_gf_ref_put (gf_ref_t *ref);
+_gf_ref_put(gf_ref_t *ref);
 
-/* _gf_ref_init -- initalize an embedded refcount object
+/* _gf_ref_init -- initialize an embedded refcount object
  *
  * @release: function to call when the refcount == 0
  * @data: parameter to be passed to @release
  */
 void
-_gf_ref_init (gf_ref_t *ref, gf_ref_release_t release, void *data);
-
+_gf_ref_init(gf_ref_t *ref, gf_ref_release_t release, void *data);
 
 /*
  * Strong suggestion to use the simplified GF_REF_* API.
@@ -75,7 +74,7 @@ _gf_ref_init (gf_ref_t *ref, gf_ref_release_t release, void *data);
  *       ... // additional members
  *   };
  */
-#define GF_REF_DECL         gf_ref_t _ref
+#define GF_REF_DECL gf_ref_t _ref
 
 /* GF_REF_INIT -- initialize a GF_REF_DECL structure
  *
@@ -84,20 +83,19 @@ _gf_ref_init (gf_ref_t *ref, gf_ref_release_t release, void *data);
  *
  * Sets the refcount to 1.
  */
-#define GF_REF_INIT(p, d)   _gf_ref_init (&(p)->_ref, (gf_ref_release_t) d, p)
+#define GF_REF_INIT(p, d) _gf_ref_init(&(p)->_ref, (gf_ref_release_t)d, p)
 
 /* GF_REF_GET -- increase the refcount of a GF_REF_DECL structure
  *
  * @return: greater then 0 when a reference was taken, 0 when not
  */
-#define GF_REF_GET(p)       _gf_ref_get (&(p)->_ref)
+#define GF_REF_GET(p) _gf_ref_get(&(p)->_ref)
 
 /* GF_REF_PUT -- decrease the refcount of a GF_REF_DECL structure
  *
  * @return: greater then 0 when there are still references, 0 when cleanup
  *          should be done, gf_ref_release_t is called on cleanup
  */
-#define GF_REF_PUT(p)       _gf_ref_put (&(p)->_ref)
-
+#define GF_REF_PUT(p) _gf_ref_put(&(p)->_ref)
 
 #endif /* _REFCOUNT_H */
diff --git a/libglusterfs/src/revision.h b/libglusterfs/src/glusterfs/revision.h
index 3c404d30e78..3c404d30e78 100644
--- a/libglusterfs/src/revision.h
+++ b/libglusterfs/src/glusterfs/revision.h
diff --git a/libglusterfs/src/glusterfs/rot-buffs.h b/libglusterfs/src/glusterfs/rot-buffs.h
new file mode 100644
index 00000000000..9dc227d58b8
--- /dev/null
+++ b/libglusterfs/src/glusterfs/rot-buffs.h
@@ -0,0 +1,125 @@
+/*
+  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __ROT_BUFFS_H
+#define __ROT_BUFFS_H
+
+#include "glusterfs/list.h"
+#include "glusterfs/locking.h"
+#include "glusterfs/common-utils.h"
+
+typedef struct rbuf_iovec {
+    struct iovec iov;
+
+    struct list_head list;
+} rbuf_iovec_t;
+
+#define RBUF_IOVEC_SIZE (sizeof(rbuf_iovec_t))
+
+typedef struct rbuf_list {
+    gf_lock_t c_lock;
+
+    pthread_mutex_t b_lock; /* protects this structure */
+    pthread_cond_t b_cond;  /* signal for writer completion */
+
+    gf_boolean_t awaiting;
+
+    unsigned long long pending;   /* pending writers */
+    unsigned long long completed; /* completed writers */
+
+    rbuf_iovec_t *rvec; /* currently used IO vector */
+
+    struct list_head veclist; /* list of attached rbuf_iov */
+
+    unsigned long long used;  /* consumable entries
+                                  attached in ->veclist */
+    unsigned long long total; /* total entries in ->veclist (used
+                                 during deallocation) */
+
+    unsigned long seq[2]; /* if interested, this whould store
+                             the start sequence number and the
+                             range */
+
+    struct list_head list; /* attachment to rbuf_t */
+} rbuf_list_t;
+
+struct rlist_iter {
+    struct list_head veclist;
+
+    unsigned long long iter;
+};
+
+#define RLIST_ENTRY_COUNT(rlist) rlist->used
+
+#define rlist_iter_init(riter, rlist)                                          \
+    do {                                                                       \
+        (riter)->iter = rlist->used;                                           \
+        (riter)->veclist = rlist->veclist;                                     \
+    } while (0)
+
+#define rvec_for_each_entry(pos, riter)                                        \
+    for (pos = list_entry((riter)->veclist.next, typeof(*pos), list);          \
+         (riter)->iter > 0;                                                    \
+         pos = list_entry(pos->list.next, typeof(*pos), list),                 \
+        --((riter)->iter))
+
+/**
+ * Sequence number assignment routine is called during buffer
+ * switch under rbuff ->lock.
+ */
+typedef void(sequence_fn)(rbuf_list_t *, void *);
+
+#define RLIST_STORE_SEQ(rlist, start, range)                                   \
+    do {                                                                       \
+        rlist->seq[0] = start;                                                 \
+        rlist->seq[1] = range;                                                 \
+    } while (0)
+
+#define RLIST_GET_SEQ(rlist, start, range)                                     \
+    do {                                                                       \
+        start = rlist->seq[0];                                                 \
+        range = rlist->seq[1];                                                 \
+    } while (0)
+
+typedef struct rbuf {
+    gf_lock_t lock; /* protects "current" rlist */
+
+    rbuf_list_t *current; /* cached pointer to first free rlist */
+
+    struct list_head freelist;
+} rbuf_t;
+
+typedef enum {
+    RBUF_CONSUMABLE = 1,
+    RBUF_BUSY,
+    RBUF_EMPTY,
+    RBUF_WOULD_STARVE,
+} rlist_retval_t;
+
+/* Initialization/Destruction */
+rbuf_t *
+rbuf_init(int);
+void
+rbuf_dtor(rbuf_t *);
+
+/* Producer API */
+char *
+rbuf_reserve_write_area(rbuf_t *, size_t, void **);
+int
+rbuf_write_complete(void *);
+
+/* Consumer API */
+int
+rbuf_get_buffer(rbuf_t *, void **, sequence_fn *, void *);
+int
+rbuf_wait_for_completion(rbuf_t *, void *, void (*)(rbuf_list_t *, void *),
+                         void *);
+
+#endif
diff --git a/libglusterfs/src/run.h b/libglusterfs/src/glusterfs/run.h
index 1dc4bf9f1b0..76af95fd27f 100644
--- a/libglusterfs/src/run.h
+++ b/libglusterfs/src/glusterfs/run.h
@@ -14,12 +14,12 @@
 #define RUN_PIPE -1
 
 struct runner {
-        char **argv;
-        unsigned argvlen;
-        int runerr;
-        pid_t chpid;
-        int chfd[3];
-        FILE *chio[3];
+    char **argv;
+    unsigned argvlen;
+    int runerr;
+    pid_t chpid;
+    int chfd[3];
+    FILE *chio[3];
 };
 
 typedef struct runner runner_t;
@@ -29,7 +29,8 @@ typedef struct runner runner_t;
  *
  * @param runner pointer to runner_t instance
  */
-void runinit (runner_t *runner);
+void
+runinit(runner_t *runner);
 
 /**
  * get FILE pointer to which child's stdio is redirected.
@@ -40,7 +41,8 @@ void runinit (runner_t *runner);
  *
  * @see runner_redir()
  */
-FILE *runner_chio (runner_t *runner, int fd);
+FILE *
+runner_chio(runner_t *runner, int fd);
 
 /**
  * add an argument.
@@ -52,7 +54,8 @@ FILE *runner_chio (runner_t *runner, int fd);
  * @param runner pointer to runner_t instance
  * @param arg    command line argument
  */
-void runner_add_arg (runner_t *runner, const char *arg);
+void
+runner_add_arg(runner_t *runner, const char *arg);
 
 /**
  * add a sequence of arguments.
@@ -66,7 +69,8 @@ void runner_add_arg (runner_t *runner, const char *arg);
  *
  * @see runner_add_arg()
  */
-void runner_add_args (runner_t *runner, ...);
+void
+runner_add_args(runner_t *runner, ...);
 
 /**
  * add an argument with printf style formatting.
@@ -76,8 +80,9 @@ void runner_add_args (runner_t *runner, ...);
  * @param runner pointer to runner_t instance
  * @param format printf style format specifier
  */
-void runner_argprintf (runner_t *runner, const char *format, ...);
-
+void
+runner_argprintf(runner_t *runner, const char *format, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
 /**
  * log a message about the command to be run.
  *
@@ -89,8 +94,9 @@ void runner_argprintf (runner_t *runner, const char *format, ...);
  *
  * @see gf_log()
  */
-void runner_log (runner_t *runner, const char *dom, gf_loglevel_t lvl,
-                 const char *msg);
+void
+runner_log(runner_t *runner, const char *dom, gf_loglevel_t lvl,
+           const char *msg);
 
 /**
  * set up redirection for child.
@@ -111,7 +117,7 @@ void runner_log (runner_t *runner, const char *dom, gf_loglevel_t lvl,
  * @see  runner_start(), dup(2), runner_chio(), runner_start()
  */
 void
-runner_redir (runner_t *runner, int fd, int tgt_fd);
+runner_redir(runner_t *runner, int fd, int tgt_fd);
 
 /**
  * spawn child with accumulated arg list.
@@ -123,7 +129,8 @@ runner_redir (runner_t *runner, int fd, int tgt_fd);
  *
  * @see runner_cout()
  */
-int runner_start (runner_t *runner);
+int
+runner_start(runner_t *runner);
 
 /**
  * complete operation and free resources.
@@ -140,7 +147,8 @@ int runner_start (runner_t *runner);
  *
  * @see waitpid(2)
  */
-int runner_end (runner_t *runner);
+int
+runner_end(runner_t *runner);
 
 /**
  * variant of runner_end() which does not free internal data
@@ -148,7 +156,8 @@ int runner_end (runner_t *runner);
  *
  * @see runner_end()
  */
-int runner_end_reuse (runner_t *runner);
+int
+runner_end_reuse(runner_t *runner);
 
 /**
  * spawn and child, take it to completion and free resources.
@@ -163,13 +172,15 @@ int runner_end_reuse (runner_t *runner);
  *
  * @see runner_start(), runner_end()
  */
-int runner_run (runner_t *runner);
+int
+runner_run(runner_t *runner);
 
 /**
  * variant for runner_run() which does not wait for acknowledgement
  * from child, and always assumes it succeeds.
  */
-int runner_run_nowait (runner_t *runner);
+int
+runner_run_nowait(runner_t *runner);
 
 /**
  * variant of runner_run() which does not free internal data
@@ -177,7 +188,8 @@ int runner_run_nowait (runner_t *runner);
  *
  * @see runner_run()
  */
-int runner_run_reuse (runner_t *runner);
+int
+runner_run_reuse(runner_t *runner);
 
 /**
  * run a command with args.
@@ -189,6 +201,7 @@ int runner_run_reuse (runner_t *runner);
  * @return 0 on success
  *         -1 on failure
  */
-int runcmd (const char *arg, ...);
+int
+runcmd(const char *arg, ...);
 
 #endif
diff --git a/libglusterfs/src/glusterfs/stack.h b/libglusterfs/src/glusterfs/stack.h
new file mode 100644
index 00000000000..536a330d38b
--- /dev/null
+++ b/libglusterfs/src/glusterfs/stack.h
@@ -0,0 +1,555 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+/*
+  This file defines MACROS and static inlines used to emulate a function
+  call over asynchronous communication with remote server
+*/
+
+#ifndef _STACK_H
+#define _STACK_H
+
+struct _call_stack;
+typedef struct _call_stack call_stack_t;
+struct _call_frame;
+typedef struct _call_frame call_frame_t;
+struct call_pool;
+typedef struct call_pool call_pool_t;
+
+#include <sys/time.h>
+
+#include "glusterfs/xlator.h"
+#include "glusterfs/dict.h"
+#include "glusterfs/list.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/lkowner.h"
+#include "glusterfs/client_t.h"
+#include "glusterfs/libglusterfs-messages.h"
+#include "glusterfs/timespec.h"
+
+#define NFS_PID 1
+#define LOW_PRIO_PROC_PID -1
+
+#define STACK_ERR_XL_NAME(stack) (stack->err_xl ? stack->err_xl->name : "-")
+#define STACK_CLIENT_NAME(stack)                                               \
+    (stack->client ? stack->client->client_uid : "-")
+
+typedef int32_t (*ret_fn_t)(call_frame_t *frame, call_frame_t *prev_frame,
+                            xlator_t *this, int32_t op_ret, int32_t op_errno,
+                            ...);
+
+void
+gf_frame_latency_update(call_frame_t *frame);
+
+struct call_pool {
+    union {
+        struct list_head all_frames;
+        struct {
+            call_stack_t *next_call;
+            call_stack_t *prev_call;
+        } all_stacks;
+    };
+    int64_t cnt;
+    gf_atomic_t total_count;
+    gf_lock_t lock;
+    struct mem_pool *frame_mem_pool;
+    struct mem_pool *stack_mem_pool;
+};
+
+struct _call_frame {
+    call_stack_t *root;   /* stack root */
+    call_frame_t *parent; /* previous BP */
+    struct list_head frames;
+    void *local;    /* local variables */
+    xlator_t *this; /* implicit object */
+    ret_fn_t ret;   /* op_return address */
+    int32_t ref_count;
+    gf_lock_t lock;
+    void *cookie; /* unique cookie */
+    gf_boolean_t complete;
+
+    glusterfs_fop_t op;
+    struct timespec begin; /* when this frame was created */
+    struct timespec end;   /* when this frame completed */
+    const char *wind_from;
+    const char *wind_to;
+    const char *unwind_from;
+    const char *unwind_to;
+};
+
+struct _ns_info {
+    uint32_t hash;      /* Hash of the namespace from SuperFastHash */
+    gf_boolean_t found; /* Set to true if we found a namespace */
+};
+
+typedef struct _ns_info ns_info_t;
+
+#define SMALL_GROUP_COUNT 128
+
+struct _call_stack {
+    union {
+        struct list_head all_frames;
+        struct {
+            call_stack_t *next_call;
+            call_stack_t *prev_call;
+        };
+    };
+    call_pool_t *pool;
+    gf_lock_t stack_lock;
+    client_t *client;
+    uint64_t unique;
+    void *state; /* pointer to request state */
+    uid_t uid;
+    gid_t gid;
+    pid_t pid;
+    char identifier[UNIX_PATH_MAX];
+    uint16_t ngrps;
+    uint32_t groups_small[SMALL_GROUP_COUNT];
+    uint32_t *groups_large;
+    uint32_t *groups;
+    gf_lkowner_t lk_owner;
+    glusterfs_ctx_t *ctx;
+
+    struct list_head myframes; /* List of call_frame_t that go
+                                  to make the call stack */
+
+    int32_t op;
+    int8_t type;
+    struct timespec tv;
+    xlator_t *err_xl;
+    int32_t error;
+
+    uint32_t flags;        /* use it wisely, think of it as a mechanism to
+                              send information over the wire too */
+    struct timespec ctime; /* timestamp, most probably set at
+                              creation of stack. */
+
+    ns_info_t ns_info;
+};
+
+/* call_stack flags field users */
+#define MDATA_CTIME (1 << 0)
+#define MDATA_MTIME (1 << 1)
+#define MDATA_ATIME (1 << 2)
+#define MDATA_PAR_CTIME (1 << 3)
+#define MDATA_PAR_MTIME (1 << 4)
+#define MDATA_PAR_ATIME (1 << 5)
+
+#define frame_set_uid_gid(frm, u, g)                                           \
+    do {                                                                       \
+        if (frm) {                                                             \
+            (frm)->root->uid = u;                                              \
+            (frm)->root->gid = g;                                              \
+            (frm)->root->ngrps = 0;                                            \
+        }                                                                      \
+    } while (0);
+
+struct xlator_fops;
+
+static inline void
+FRAME_DESTROY(call_frame_t *frame)
+{
+    void *local = NULL;
+
+    if (frame->root->ctx->measure_latency)
+        gf_frame_latency_update(frame);
+
+    list_del_init(&frame->frames);
+    if (frame->local) {
+        local = frame->local;
+        frame->local = NULL;
+    }
+
+    LOCK_DESTROY(&frame->lock);
+    mem_put(frame);
+
+    if (local)
+        mem_put(local);
+}
+
+static inline void
+STACK_DESTROY(call_stack_t *stack)
+{
+    call_frame_t *frame = NULL;
+    call_frame_t *tmp = NULL;
+
+    LOCK(&stack->pool->lock);
+    {
+        list_del_init(&stack->all_frames);
+        stack->pool->cnt--;
+    }
+    UNLOCK(&stack->pool->lock);
+
+    LOCK_DESTROY(&stack->stack_lock);
+
+    list_for_each_entry_safe(frame, tmp, &stack->myframes, frames)
+    {
+        FRAME_DESTROY(frame);
+    }
+
+    GF_FREE(stack->groups_large);
+
+    mem_put(stack);
+}
+
+static inline void
+STACK_RESET(call_stack_t *stack)
+{
+    call_frame_t *frame = NULL;
+    call_frame_t *tmp = NULL;
+    call_frame_t *last = NULL;
+    struct list_head toreset = {0};
+
+    INIT_LIST_HEAD(&toreset);
+
+    /* We acquire call_pool->lock only to remove the frames from this stack
+     * to preserve atomicity. This synchronizes across concurrent requests
+     * like statedump, STACK_DESTROY etc. */
+
+    LOCK(&stack->pool->lock);
+    {
+        last = list_last_entry(&stack->myframes, call_frame_t, frames);
+        list_del_init(&last->frames);
+        list_splice_init(&stack->myframes, &toreset);
+        list_add(&last->frames, &stack->myframes);
+    }
+    UNLOCK(&stack->pool->lock);
+
+    list_for_each_entry_safe(frame, tmp, &toreset, frames)
+    {
+        FRAME_DESTROY(frame);
+    }
+}
+
+#define FRAME_SU_DO(frm, local_type)                                           \
+    do {                                                                       \
+        local_type *__local = (frm)->local;                                    \
+        __local->uid = frm->root->uid;                                         \
+        __local->gid = frm->root->gid;                                         \
+        __local->pid = frm->root->pid;                                         \
+        frm->root->uid = 0;                                                    \
+        frm->root->gid = 0;                                                    \
+        frm->root->pid = GF_CLIENT_PID_NO_ROOT_SQUASH;                         \
+    } while (0);
+
+#define FRAME_SU_UNDO(frm, local_type)                                         \
+    do {                                                                       \
+        local_type *__local = (frm)->local;                                    \
+        frm->root->uid = __local->uid;                                         \
+        frm->root->gid = __local->gid;                                         \
+        frm->root->pid = __local->pid;                                         \
+    } while (0);
+
+/* NOTE: make sure to keep this as an macro, mainly because, we need 'fn'
+   field here to be the proper fn ptr, so its address is valid entry in
+   'xlator_fops' struct.
+   To understand this, check the `xlator.h:struct xlator_fops`, and then
+   see a STACK_WIND call, which generally calls `subvol->fops->fop`, so
+   the address offset should give the index */
+
+/* +1 is required as 0 means NULL fop, and we don't have a variable for it */
+#define get_fop_index_from_fn(xl, fn)                                          \
+    (1 + (((long)&(fn) - (long)&((xl)->fops->stat)) / sizeof(void *)))
+
+/* NOTE: the above reason holds good here too. But notice that we are getting
+ the base address of the 'stat' fop, which is the first entry in the fop
+ structure. All we need to do is move as much as 'idx' fields, and get the
+ actual pointer from that field. */
+
+static inline void *
+get_the_pt_fop(void *base_fop, int fop_idx)
+{
+    void *target_addr = (base_fop + ((fop_idx - 1) * sizeof(void *)));
+    /* all below type casting is for not getting warning. */
+    return (void *)*(unsigned long *)target_addr;
+}
+
+/* make a call without switching frames */
+#define STACK_WIND_TAIL(frame, obj, fn, params...)                             \
+    do {                                                                       \
+        xlator_t *old_THIS = NULL;                                             \
+        xlator_t *next_xl = obj;                                               \
+        typeof(fn) next_xl_fn = fn;                                            \
+        int opn = get_fop_index_from_fn((next_xl), (fn));                      \
+                                                                               \
+        frame->this = next_xl;                                                 \
+        frame->wind_to = #fn;                                                  \
+        old_THIS = THIS;                                                       \
+        THIS = next_xl;                                                        \
+        gf_msg_trace("stack-trace", 0,                                         \
+                     "stack-address: %p, "                                     \
+                     "winding from %s to %s",                                  \
+                     frame->root, old_THIS->name, THIS->name);                 \
+        /* Need to capture counts at leaf node */                              \
+        if (!next_xl->pass_through && !next_xl->children) {                    \
+            GF_ATOMIC_INC(next_xl->stats.total.metrics[opn].fop);              \
+            GF_ATOMIC_INC(next_xl->stats.interval.metrics[opn].fop);           \
+            GF_ATOMIC_INC(next_xl->stats.total.count);                         \
+            GF_ATOMIC_INC(next_xl->stats.interval.count);                      \
+        }                                                                      \
+                                                                               \
+        if (next_xl->pass_through) {                                           \
+            next_xl_fn = get_the_pt_fop(&next_xl->pass_through_fops->stat,     \
+                                        opn);                                  \
+        }                                                                      \
+        next_xl_fn(frame, next_xl, params);                                    \
+        THIS = old_THIS;                                                       \
+    } while (0)
+
+/* make a call */
+#define STACK_WIND(frame, rfn, obj, fn, params...)                             \
+    STACK_WIND_COMMON(frame, rfn, 0, NULL, obj, fn, params)
+
+/* make a call with a cookie */
+#define STACK_WIND_COOKIE(frame, rfn, cky, obj, fn, params...)                 \
+    STACK_WIND_COMMON(frame, rfn, 1, cky, obj, fn, params)
+
+/* Cookie passed as the argument can be NULL (ptr) or 0 (int). Hence we
+   have to have a mechanism to separate out the two STACK_WIND formats.
+   Needed a common macro, as other than for cookie, all the other code
+   is common across.
+ */
+#define STACK_WIND_COMMON(frame, rfn, has_cookie, cky, obj, fn, params...)     \
+    do {                                                                       \
+        call_frame_t *_new = NULL;                                             \
+        xlator_t *old_THIS = NULL;                                             \
+        typeof(fn) next_xl_fn = fn;                                            \
+                                                                               \
+        _new = mem_get0(frame->root->pool->frame_mem_pool);                    \
+        if (!_new) {                                                           \
+            break;                                                             \
+        }                                                                      \
+        typeof(fn##_cbk) tmp_cbk = rfn;                                        \
+        _new->root = frame->root;                                              \
+        _new->this = obj;                                                      \
+        _new->ret = (ret_fn_t)tmp_cbk;                                         \
+        _new->parent = frame;                                                  \
+        /* (void *) is required for avoiding gcc warning */                    \
+        _new->cookie = ((has_cookie == 1) ? (void *)(cky) : (void *)_new);     \
+        _new->wind_from = __FUNCTION__;                                        \
+        _new->wind_to = #fn;                                                   \
+        _new->unwind_to = #rfn;                                                \
+        LOCK_INIT(&_new->lock);                                                \
+        LOCK(&frame->root->stack_lock);                                        \
+        {                                                                      \
+            list_add(&_new->frames, &frame->root->myframes);                   \
+            frame->ref_count++;                                                \
+        }                                                                      \
+        UNLOCK(&frame->root->stack_lock);                                      \
+        fn##_cbk = rfn;                                                        \
+        old_THIS = THIS;                                                       \
+        THIS = obj;                                                            \
+        gf_msg_trace("stack-trace", 0,                                         \
+                     "stack-address: %p, "                                     \
+                     "winding from %s to %s",                                  \
+                     frame->root, old_THIS->name, THIS->name);                 \
+        if (obj->ctx->measure_latency)                                         \
+            timespec_now(&_new->begin);                                        \
+        _new->op = get_fop_index_from_fn((_new->this), (fn));                  \
+        if (!obj->pass_through) {                                              \
+            GF_ATOMIC_INC(obj->stats.total.metrics[_new->op].fop);             \
+            GF_ATOMIC_INC(obj->stats.interval.metrics[_new->op].fop);          \
+            GF_ATOMIC_INC(obj->stats.total.count);                             \
+            GF_ATOMIC_INC(obj->stats.interval.count);                          \
+        } else {                                                               \
+            /* we want to get to the actual fop to call */                     \
+            next_xl_fn = get_the_pt_fop(&obj->pass_through_fops->stat,         \
+                                        _new->op);                             \
+        }                                                                      \
+        next_xl_fn(_new, obj, params);                                         \
+        THIS = old_THIS;                                                       \
+    } while (0)
+
+#define STACK_UNWIND STACK_UNWIND_STRICT
+
+/* return from function in type-safe way */
+#define STACK_UNWIND_STRICT(fop, frame, op_ret, op_errno, params...)           \
+    do {                                                                       \
+        fop_##fop##_cbk_t fn = NULL;                                           \
+        call_frame_t *_parent = NULL;                                          \
+        xlator_t *old_THIS = NULL;                                             \
+                                                                               \
+        if (!frame) {                                                          \
+            gf_msg("stack", GF_LOG_CRITICAL, 0, LG_MSG_FRAME_ERROR, "!frame"); \
+            break;                                                             \
+        }                                                                      \
+        if ((op_ret) < 0) {                                                    \
+            gf_msg_debug("stack-trace", op_errno,                              \
+                         "stack-address: %p, "                                 \
+                         "%s returned %d error: %s",                           \
+                         frame->root, THIS->name, (int32_t)(op_ret),           \
+                         strerror(op_errno));                                  \
+        } else {                                                               \
+            gf_msg_trace("stack-trace", 0,                                     \
+                         "stack-address: %p, "                                 \
+                         "%s returned %d",                                     \
+                         frame->root, THIS->name, (int32_t)(op_ret));          \
+        }                                                                      \
+        fn = (fop_##fop##_cbk_t)frame->ret;                                    \
+        _parent = frame->parent;                                               \
+        LOCK(&frame->root->stack_lock);                                        \
+        {                                                                      \
+            _parent->ref_count--;                                              \
+            if ((op_ret) < 0 && (op_errno) != frame->root->error) {            \
+                frame->root->err_xl = frame->this;                             \
+                frame->root->error = (op_errno);                               \
+            } else if ((op_ret) == 0) {                                        \
+                frame->root->err_xl = NULL;                                    \
+                frame->root->error = 0;                                        \
+            }                                                                  \
+        }                                                                      \
+        UNLOCK(&frame->root->stack_lock);                                      \
+        old_THIS = THIS;                                                       \
+        THIS = _parent->this;                                                  \
+        frame->complete = _gf_true;                                            \
+        frame->unwind_from = __FUNCTION__;                                     \
+        if (frame->this->ctx->measure_latency) {                               \
+            timespec_now(&frame->end);                                         \
+            /* required for top most xlator */                                 \
+            if (_parent->ret == NULL)                                          \
+                timespec_now(&_parent->end);                                   \
+        }                                                                      \
+        if (op_ret < 0) {                                                      \
+            GF_ATOMIC_INC(THIS->stats.total.metrics[frame->op].cbk);           \
+            GF_ATOMIC_INC(THIS->stats.interval.metrics[frame->op].cbk);        \
+        }                                                                      \
+        fn(_parent, frame->cookie, _parent->this, op_ret, op_errno, params);   \
+        THIS = old_THIS;                                                       \
+    } while (0)
+
+static inline int
+call_stack_alloc_groups(call_stack_t *stack, int ngrps)
+{
+    if (ngrps <= SMALL_GROUP_COUNT) {
+        stack->groups = stack->groups_small;
+    } else {
+        GF_FREE(stack->groups_large);
+        stack->groups_large = GF_CALLOC(ngrps, sizeof(gid_t),
+                                        gf_common_mt_groups_t);
+        if (!stack->groups_large)
+            return -1;
+        stack->groups = stack->groups_large;
+    }
+
+    stack->ngrps = ngrps;
+
+    return 0;
+}
+
+static inline int
+call_stack_groups_capacity(call_stack_t *stack)
+{
+    return max(stack->ngrps, SMALL_GROUP_COUNT);
+}
+
+static inline int
+call_frames_count(call_stack_t *call_stack)
+{
+    call_frame_t *pos;
+    int32_t count = 0;
+
+    if (!call_stack)
+        return count;
+
+    list_for_each_entry(pos, &call_stack->myframes, frames) count++;
+
+    return count;
+}
+
+static inline call_frame_t *
+copy_frame(call_frame_t *frame)
+{
+    call_stack_t *newstack = NULL;
+    call_stack_t *oldstack = NULL;
+    call_frame_t *newframe = NULL;
+
+    if (!frame) {
+        return NULL;
+    }
+
+    newstack = mem_get0(frame->root->pool->stack_mem_pool);
+    if (newstack == NULL) {
+        return NULL;
+    }
+
+    INIT_LIST_HEAD(&newstack->myframes);
+
+    newframe = mem_get0(frame->root->pool->frame_mem_pool);
+    if (!newframe) {
+        mem_put(newstack);
+        return NULL;
+    }
+
+    newframe->this = frame->this;
+    newframe->root = newstack;
+    INIT_LIST_HEAD(&newframe->frames);
+    list_add(&newframe->frames, &newstack->myframes);
+
+    oldstack = frame->root;
+
+    newstack->uid = oldstack->uid;
+    newstack->gid = oldstack->gid;
+    newstack->pid = oldstack->pid;
+    newstack->op = oldstack->op;
+    newstack->type = oldstack->type;
+    newstack->ctime = oldstack->ctime;
+    newstack->flags = oldstack->flags;
+    if (call_stack_alloc_groups(newstack, oldstack->ngrps) != 0) {
+        mem_put(newstack);
+        return NULL;
+    }
+    if (!oldstack->groups) {
+        gf_msg_debug("stack", EINVAL, "groups is null (ngrps: %d)",
+                     oldstack->ngrps);
+        /* Considering 'groups' is NULL, set ngrps to 0 */
+        oldstack->ngrps = 0;
+
+        if (oldstack->groups_large)
+            oldstack->groups = oldstack->groups_large;
+        else
+            oldstack->groups = oldstack->groups_small;
+    }
+    newstack->ngrps = oldstack->ngrps;
+    memcpy(newstack->groups, oldstack->groups, sizeof(gid_t) * oldstack->ngrps);
+    newstack->unique = oldstack->unique;
+    newstack->pool = oldstack->pool;
+    newstack->lk_owner = oldstack->lk_owner;
+    newstack->ctx = oldstack->ctx;
+
+    if (newstack->ctx->measure_latency) {
+        timespec_now(&newstack->tv);
+        memcpy(&newframe->begin, &newstack->tv, sizeof(newstack->tv));
+    }
+
+    LOCK_INIT(&newframe->lock);
+    LOCK_INIT(&newstack->stack_lock);
+
+    LOCK(&oldstack->pool->lock);
+    {
+        list_add(&newstack->all_frames, &oldstack->all_frames);
+        newstack->pool->cnt++;
+    }
+    UNLOCK(&oldstack->pool->lock);
+    GF_ATOMIC_INC(newstack->pool->total_count);
+
+    return newframe;
+}
+
+void
+call_stack_set_groups(call_stack_t *stack, int ngrps, gid_t **groupbuf_p);
+void
+gf_proc_dump_pending_frames(call_pool_t *call_pool);
+void
+gf_proc_dump_pending_frames_to_dict(call_pool_t *call_pool, dict_t *dict);
+call_frame_t *
+create_frame(xlator_t *xl, call_pool_t *pool);
+gf_boolean_t
+__is_fuse_call(call_frame_t *frame);
+#endif /* _STACK_H */
diff --git a/libglusterfs/src/glusterfs/statedump.h b/libglusterfs/src/glusterfs/statedump.h
new file mode 100644
index 00000000000..ce082706bdf
--- /dev/null
+++ b/libglusterfs/src/glusterfs/statedump.h
@@ -0,0 +1,132 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef STATEDUMP_H
+#define STATEDUMP_H
+
+#include <stdarg.h>
+#include "glusterfs/inode.h"
+#include "glusterfs/strfd.h"
+
+#define GF_DUMP_MAX_BUF_LEN 4096
+
+typedef struct gf_dump_xl_options_ {
+    gf_boolean_t dump_priv;
+    gf_boolean_t dump_inode;
+    gf_boolean_t dump_fd;
+    gf_boolean_t dump_inodectx;
+    gf_boolean_t dump_fdctx;
+    gf_boolean_t dump_history;
+} gf_dump_xl_options_t;
+
+typedef struct gf_dump_options_ {
+    gf_boolean_t dump_mem;
+    gf_boolean_t dump_iobuf;
+    gf_boolean_t dump_callpool;
+    gf_dump_xl_options_t xl_options;  // options for all xlators
+    char *dump_path;
+} gf_dump_options_t;
+
+extern gf_dump_options_t dump_options;
+
+__attribute__((__format__(__printf__, 3, 4))) static inline void
+_gf_proc_dump_build_key(char *key, const char *prefix, const char *fmt, ...)
+{
+    va_list ap;
+    int32_t len;
+
+    len = snprintf(key, GF_DUMP_MAX_BUF_LEN, "%s.", prefix);
+    if (len >= 0) {
+        va_start(ap, fmt);
+        len = vsnprintf(key + len, GF_DUMP_MAX_BUF_LEN - len, fmt, ap);
+        va_end(ap);
+    }
+    if (len < 0) {
+        *key = 0;
+    }
+}
+
+#define gf_proc_dump_build_key(key, key_prefix, fmt...)                        \
+    {                                                                          \
+        _gf_proc_dump_build_key(key, key_prefix, ##fmt);                       \
+    }
+
+#define GF_PROC_DUMP_SET_OPTION(opt, val) opt = val
+
+#define GF_CHECK_DUMP_OPTION_ENABLED(option_dump, var, label)                  \
+    do {                                                                       \
+        if (option_dump == _gf_true) {                                         \
+            var = _gf_false;                                                   \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0);
+
+void
+gf_proc_dump_init();
+
+void
+gf_proc_dump_fini(void);
+
+void
+gf_proc_dump_cleanup(void);
+
+void
+gf_proc_dump_info(int signum, glusterfs_ctx_t *ctx);
+
+int
+gf_proc_dump_add_section(char *key, ...)
+    __attribute__((__format__(__printf__, 1, 2)));
+
+int
+gf_proc_dump_write(char *key, char *value, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+
+void
+inode_table_dump(inode_table_t *itable, char *prefix);
+
+void
+inode_table_dump_to_dict(inode_table_t *itable, char *prefix, dict_t *dict);
+
+void
+fdtable_dump(fdtable_t *fdtable, char *prefix);
+
+void
+fdtable_dump_to_dict(fdtable_t *fdtable, char *prefix, dict_t *dict);
+
+void
+inode_dump(inode_t *inode, char *prefix);
+
+void
+gf_proc_dump_mem_info_to_dict(dict_t *dict);
+
+void
+gf_proc_dump_mempool_info_to_dict(glusterfs_ctx_t *ctx, dict_t *dict);
+
+void
+glusterd_init(int sig);
+
+void
+gf_proc_dump_xlator_private(xlator_t *this, strfd_t *strfd);
+
+void
+gf_proc_dump_mallinfo(strfd_t *strfd);
+
+void
+gf_proc_dump_xlator_history(xlator_t *this, strfd_t *strfd);
+
+void
+gf_proc_dump_xlator_meminfo(xlator_t *this, strfd_t *strfd);
+
+void
+gf_proc_dump_xlator_profile(xlator_t *this, strfd_t *strfd);
+
+void
+gf_latency_statedump_and_reset(char *key, gf_latency_t *lat);
+#endif /* STATEDUMP_H */
diff --git a/libglusterfs/src/glusterfs/store.h b/libglusterfs/src/glusterfs/store.h
new file mode 100644
index 00000000000..a1f70c7b840
--- /dev/null
+++ b/libglusterfs/src/glusterfs/store.h
@@ -0,0 +1,112 @@
+/*
+   Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+#ifndef _GLUSTERD_STORE_H_
+#define _GLUSTERD_STORE_H_
+
+#include "glusterfs/compat.h"
+#include "glusterfs/glusterfs.h"
+
+struct gf_store_handle_ {
+    char *path;
+    int fd;
+    int tmp_fd;
+    FILE *read;
+    int locked; /* state of lockf() */
+};
+
+typedef struct gf_store_handle_ gf_store_handle_t;
+
+struct gf_store_iter_ {
+    FILE *file;
+    char filepath[PATH_MAX];
+};
+
+typedef struct gf_store_iter_ gf_store_iter_t;
+
+typedef enum {
+    GD_STORE_SUCCESS,
+    GD_STORE_KEY_NULL,
+    GD_STORE_VALUE_NULL,
+    GD_STORE_KEY_VALUE_NULL,
+    GD_STORE_EOF,
+    GD_STORE_ENOMEM,
+    GD_STORE_STAT_FAILED
+} gf_store_op_errno_t;
+
+int32_t
+gf_store_mkdir(char *path);
+
+int32_t
+gf_store_handle_create_on_absence(gf_store_handle_t **shandle, char *path);
+
+int32_t
+gf_store_mkstemp(gf_store_handle_t *shandle);
+
+int
+gf_store_sync_direntry(char *path);
+
+int32_t
+gf_store_rename_tmppath(gf_store_handle_t *shandle);
+
+int32_t
+gf_store_unlink_tmppath(gf_store_handle_t *shandle);
+
+int
+gf_store_read_and_tokenize(FILE *file, char **iter_key, char **iter_val,
+                           gf_store_op_errno_t *store_errno);
+
+int32_t
+gf_store_retrieve_value(gf_store_handle_t *handle, char *key, char **value);
+
+int32_t
+gf_store_save_value(int fd, char *key, char *value);
+
+int32_t
+gf_store_save_items(int fd, char *items);
+
+int32_t
+gf_store_handle_new(const char *path, gf_store_handle_t **handle);
+
+int
+gf_store_handle_retrieve(char *path, gf_store_handle_t **handle);
+
+int32_t
+gf_store_handle_destroy(gf_store_handle_t *handle);
+
+int32_t
+gf_store_iter_new(gf_store_handle_t *shandle, gf_store_iter_t **iter);
+
+int32_t
+gf_store_validate_key_value(char *storepath, char *key, char *val,
+                            gf_store_op_errno_t *op_errno);
+
+int32_t
+gf_store_iter_get_next(gf_store_iter_t *iter, char **key, char **value,
+                       gf_store_op_errno_t *op_errno);
+
+int32_t
+gf_store_iter_get_matching(gf_store_iter_t *iter, char *key, char **value);
+
+int32_t
+gf_store_iter_destroy(gf_store_iter_t **iter);
+
+char *
+gf_store_strerror(gf_store_op_errno_t op_errno);
+
+int
+gf_store_lock(gf_store_handle_t *sh);
+
+void
+gf_store_unlock(gf_store_handle_t *sh);
+
+int
+gf_store_locked_local(gf_store_handle_t *sh);
+
+#endif
diff --git a/libglusterfs/src/strfd.h b/libglusterfs/src/glusterfs/strfd.h
index 9084e235eef..861cd02e005 100644
--- a/libglusterfs/src/strfd.h
+++ b/libglusterfs/src/glusterfs/strfd.h
@@ -12,19 +12,23 @@
 #define _STRFD_H
 
 typedef struct {
-        void *data;
-        size_t alloc_size;
-        size_t size;
-        off_t pos;
+    void *data;
+    size_t alloc_size;
+    size_t size;
+    off_t pos;
 } strfd_t;
 
-strfd_t *strfd_open();
+strfd_t *
+strfd_open();
 
-int strprintf(strfd_t *strfd, const char *fmt, ...)
-        __attribute__ ((__format__ (__printf__, 2, 3)));
+int
+strprintf(strfd_t *strfd, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
 
-int strvprintf(strfd_t *strfd, const char *fmt, va_list ap);
+int
+strvprintf(strfd_t *strfd, const char *fmt, va_list ap);
 
-int strfd_close(strfd_t *strfd);
+int
+strfd_close(strfd_t *strfd);
 
 #endif
diff --git a/libglusterfs/src/glusterfs/syncop-utils.h b/libglusterfs/src/glusterfs/syncop-utils.h
new file mode 100644
index 00000000000..1f3ee403edc
--- /dev/null
+++ b/libglusterfs/src/glusterfs/syncop-utils.h
@@ -0,0 +1,54 @@
+/*
+  Copyright (c) 2015, Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _SYNCOP_UTILS_H
+#define _SYNCOP_UTILS_H
+
+typedef int (*syncop_dir_scan_fn_t)(xlator_t *subvol, gf_dirent_t *entry,
+                                    loc_t *parent, void *data);
+int
+syncop_ftw(xlator_t *subvol, loc_t *loc, int pid, void *data,
+           int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                     void *data));
+
+int
+syncop_mt_dir_scan(call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
+                   void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
+                   uint32_t max_jobs, uint32_t max_qlen);
+
+int
+syncop_dir_scan(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                          void *data));
+
+int
+syncop_dirfd(xlator_t *subvol, loc_t *loc, fd_t **fd, int pid);
+
+int
+syncop_is_subvol_local(xlator_t *this, loc_t *loc, gf_boolean_t *is_local);
+
+int
+syncop_gfid_to_path(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                    char **path_p);
+
+int
+syncop_ftw_throttle(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                    int (*fn)(xlator_t *subvol, gf_dirent_t *entry,
+                              loc_t *parent, void *data),
+                    int count, int sleep_time);
+int
+syncop_inode_find(xlator_t *this, xlator_t *subvol, uuid_t gfid,
+                  inode_t **inode, dict_t *xdata, dict_t **rsp_dict);
+
+int
+syncop_gfid_to_path_hard(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                         inode_t *inode, char **path_p,
+                         gf_boolean_t hard_resolve);
+#endif /* _SYNCOP_H */
diff --git a/libglusterfs/src/glusterfs/syncop.h b/libglusterfs/src/glusterfs/syncop.h
new file mode 100644
index 00000000000..4e9241a32fc
--- /dev/null
+++ b/libglusterfs/src/glusterfs/syncop.h
@@ -0,0 +1,718 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _SYNCOP_H
+#define _SYNCOP_H
+
+#include <sys/time.h>
+#include <pthread.h>
+#include <ucontext.h>
+#include "glusterfs/dict.h"   // for dict_t
+#include "glusterfs/stack.h"  // for call_frame_t, STACK_DESTROY, STACK_...
+#include "glusterfs/timer.h"
+
+#define SYNCENV_PROC_MAX 16
+#define SYNCENV_PROC_MIN 2
+#define SYNCPROC_IDLE_TIME 600
+
+/*
+ * Flags for syncopctx valid elements
+ */
+#define SYNCOPCTX_UID 0x00000001
+#define SYNCOPCTX_GID 0x00000002
+#define SYNCOPCTX_GROUPS 0x00000004
+#define SYNCOPCTX_PID 0x00000008
+#define SYNCOPCTX_LKOWNER 0x00000010
+
+#ifdef HAVE_TSAN_API
+/* Currently hardcoded within thread context maintained by the sanitizer. */
+#define TSAN_THREAD_NAMELEN 64
+#endif
+
+struct synctask;
+struct syncproc;
+struct syncenv;
+struct synccond;
+
+typedef int (*synctask_cbk_t)(int ret, call_frame_t *frame, void *opaque);
+
+typedef int (*synctask_fn_t)(void *opaque);
+
+typedef enum {
+    SYNCTASK_INIT = 0,
+    SYNCTASK_RUN,
+    SYNCTASK_SUSPEND,
+    SYNCTASK_WAIT,
+    SYNCTASK_DONE,
+    SYNCTASK_ZOMBIE,
+} synctask_state_t;
+
+/* for one sequential execution of @syncfn */
+struct synctask {
+    struct list_head all_tasks;
+    struct syncenv *env;
+    xlator_t *xl;
+    call_frame_t *frame;
+    call_frame_t *opframe;
+    synctask_cbk_t synccbk;
+    synctask_fn_t syncfn;
+    struct timespec *delta;
+    gf_timer_t *timer;
+    struct synccond *synccond;
+    void *opaque;
+    void *stack;
+    synctask_state_t state;
+    int woken;
+    int slept;
+    int ret;
+
+    uid_t uid;
+    gid_t gid;
+
+#ifdef HAVE_TSAN_API
+    struct {
+        void *fiber;
+        char name[TSAN_THREAD_NAMELEN];
+    } tsan;
+#endif
+
+    ucontext_t ctx;
+    struct syncproc *proc;
+
+    pthread_mutex_t mutex; /* for synchronous spawning of synctask */
+    pthread_cond_t cond;
+    int done;
+
+    struct list_head waitq; /* can wait only "once" at a time */
+};
+
+struct syncproc {
+    pthread_t processor;
+
+#ifdef HAVE_TSAN_API
+    struct {
+        void *fiber;
+        char name[TSAN_THREAD_NAMELEN];
+    } tsan;
+#endif
+
+    ucontext_t sched;
+    struct syncenv *env;
+    struct synctask *current;
+};
+
+/* hosts the scheduler thread and framework for executing synctasks */
+struct syncenv {
+    struct syncproc proc[SYNCENV_PROC_MAX];
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+
+    struct list_head runq;
+    struct list_head waitq;
+
+    int procs;
+    int procs_idle;
+
+    int runcount;
+
+    int procmin;
+    int procmax;
+
+    size_t stacksize;
+
+    int destroy; /* FLAG to mark syncenv is in destroy mode
+                    so that no more synctasks are accepted*/
+};
+
+typedef enum { LOCK_NULL = 0, LOCK_TASK, LOCK_THREAD } lock_type_t;
+
+typedef enum {
+    SYNC_LOCK_DEFAULT = 0,
+    SYNC_LOCK_RECURSIVE, /*it allows recursive locking*/
+} lock_attr_t;
+
+struct synclock {
+    pthread_mutex_t guard;  /* guard the remaining members, pair @cond */
+    pthread_cond_t cond;    /* waiting non-synctasks */
+    struct list_head waitq; /* waiting synctasks */
+    volatile int lock;      /* true(non zero) or false(zero), lock status */
+    lock_attr_t attr;
+    struct synctask *owner; /* NULL if current owner is not a synctask */
+    pthread_t owner_tid;
+    lock_type_t type;
+};
+typedef struct synclock synclock_t;
+
+struct synccond {
+    pthread_mutex_t pmutex;
+    pthread_cond_t pcond;
+    struct list_head waitq;
+};
+typedef struct synccond synccond_t;
+
+struct syncbarrier {
+    gf_boolean_t initialized; /*Set on successful initialization*/
+    pthread_mutex_t guard;    /* guard the remaining members, pair @cond */
+    pthread_cond_t cond;      /* waiting non-synctasks */
+    struct list_head waitq;   /* waiting synctasks */
+    int count;                /* count the number of wakes */
+    int waitfor;              /* no. of wakes until which task can be in
+                                 waitq before being woken up. */
+};
+typedef struct syncbarrier syncbarrier_t;
+
+struct syncargs {
+    int op_ret;
+    int op_errno;
+
+    /*
+     * The below 3 iatt structures are used in the fops
+     * whose callbacks get struct iatt as one of the
+     * a return arguments. Currently, the maximum number
+     * of iatt structures returned is 3 for some fops
+     * such as mknod, copy_file_range, mkdir etc. So
+     * all the following 3 iatt structures would be used
+     * for those fops.
+     */
+    struct iatt iatt1;
+    struct iatt iatt2;
+    struct iatt iatt3;
+    dict_t *xattr;
+    struct statvfs statvfs_buf;
+    struct iovec *vector;
+    int count;
+    struct iobref *iobref;
+    char *buffer;
+    dict_t *xdata;
+    struct gf_flock flock;
+    struct gf_lease lease;
+    dict_t *dict_out;
+
+    /* some more _cbk needs */
+    uuid_t uuid;
+    char *errstr;
+    dict_t *dict;
+    pthread_mutex_t lock_dict;
+
+    syncbarrier_t barrier;
+
+    /* do not touch */
+    struct synctask *task;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int done;
+
+    gf_dirent_t entries;
+    off_t offset;
+
+    lock_migration_info_t locklist;
+};
+
+struct syncopctx {
+    unsigned int valid; /* valid flags for elements that are set */
+    uid_t uid;
+    gid_t gid;
+    int grpsize;
+    int ngrps;
+    gid_t *groups;
+    pid_t pid;
+    gf_lkowner_t lk_owner;
+};
+
+#define __yawn(args)                                                           \
+    do {                                                                       \
+        args->task = synctask_get();                                           \
+        if (args->task)                                                        \
+            break;                                                             \
+        pthread_mutex_init(&args->mutex, NULL);                                \
+        pthread_cond_init(&args->cond, NULL);                                  \
+        args->done = 0;                                                        \
+    } while (0)
+
+#define __wake(args)                                                           \
+    do {                                                                       \
+        if (args->task) {                                                      \
+            synctask_wake(args->task);                                         \
+        } else {                                                               \
+            pthread_mutex_lock(&args->mutex);                                  \
+            {                                                                  \
+                args->done = 1;                                                \
+                pthread_cond_signal(&args->cond);                              \
+            }                                                                  \
+            pthread_mutex_unlock(&args->mutex);                                \
+        }                                                                      \
+    } while (0)
+
+#define __yield(args)                                                          \
+    do {                                                                       \
+        if (args->task) {                                                      \
+            synctask_yield(args->task, NULL);                                  \
+        } else {                                                               \
+            pthread_mutex_lock(&args->mutex);                                  \
+            {                                                                  \
+                while (!args->done)                                            \
+                    pthread_cond_wait(&args->cond, &args->mutex);              \
+            }                                                                  \
+            pthread_mutex_unlock(&args->mutex);                                \
+            pthread_mutex_destroy(&args->mutex);                               \
+            pthread_cond_destroy(&args->cond);                                 \
+        }                                                                      \
+    } while (0)
+
+#define SYNCOP(subvol, stb, cbk, fn_op, params...)                             \
+    do {                                                                       \
+        struct synctask *task = NULL;                                          \
+        call_frame_t *frame = NULL;                                            \
+                                                                               \
+        task = synctask_get();                                                 \
+        stb->task = task;                                                      \
+        if (task)                                                              \
+            frame = copy_frame(task->opframe);                                 \
+        else                                                                   \
+            frame = syncop_create_frame(THIS);                                 \
+                                                                               \
+        if (!frame) {                                                          \
+            stb->op_ret = -1;                                                  \
+            stb->op_errno = errno;                                             \
+            break;                                                             \
+        }                                                                      \
+                                                                               \
+        if (task) {                                                            \
+            frame->root->uid = task->uid;                                      \
+            frame->root->gid = task->gid;                                      \
+        }                                                                      \
+                                                                               \
+        __yawn(stb);                                                           \
+                                                                               \
+        frame->op = get_fop_index_from_fn(subvol, fn_op);                      \
+        STACK_WIND_COOKIE(frame, cbk, (void *)stb, subvol, fn_op, params);     \
+                                                                               \
+        __yield(stb);                                                          \
+        STACK_DESTROY(frame->root);                                            \
+    } while (0)
+
+/*
+ * syncop_xxx() calls are executed in two ways, one is inside a synctask where
+ * the executing function will do 'swapcontext' and the other is without
+ * synctask where the executing thread is made to wait using pthread_cond_wait.
+ * Executing thread may change when syncop_xxx() is executed inside a synctask.
+ * This leads to errno_location change i.e. errno may give errno of
+ * non-executing thread. So errno is not touched inside a synctask execution.
+ * All gfapi calls are executed using the second way of executing syncop_xxx()
+ * where the executing thread waits using pthread_cond_wait so it is ok to set
+ * errno in these cases. The following macro makes syncop_xxx() behave just
+ * like a system call, where -1 is returned and errno is set when a failure
+ * occurs.
+ */
+#define DECODE_SYNCOP_ERR(ret)                                                 \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            errno = -ret;                                                      \
+            ret = -1;                                                          \
+        } else {                                                               \
+            errno = 0;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define SYNCENV_DEFAULT_STACKSIZE (2 * 1024 * 1024)
+
+struct syncenv *
+syncenv_new(size_t stacksize, int procmin, int procmax);
+void
+syncenv_destroy(struct syncenv *);
+void
+syncenv_scale(struct syncenv *env);
+
+int
+synctask_new1(struct syncenv *, size_t stacksize, synctask_fn_t, synctask_cbk_t,
+              call_frame_t *frame, void *);
+int
+synctask_new(struct syncenv *, synctask_fn_t, synctask_cbk_t,
+             call_frame_t *frame, void *);
+struct synctask *
+synctask_create(struct syncenv *, size_t stacksize, synctask_fn_t,
+                synctask_cbk_t, call_frame_t *, void *);
+int
+synctask_join(struct synctask *task);
+void
+synctask_wake(struct synctask *task);
+void
+synctask_yield(struct synctask *task, struct timespec *delta);
+void
+synctask_sleep(int32_t secs);
+void
+synctask_waitfor(struct synctask *task, int count);
+
+#define synctask_barrier_init(args) syncbarrier_init(&args->barrier)
+#define synctask_barrier_wait(args, n) syncbarrier_wait(&args->barrier, n)
+#define synctask_barrier_wake(args) syncbarrier_wake(&args->barrier)
+
+int
+synctask_setid(struct synctask *task, uid_t uid, gid_t gid);
+#define SYNCTASK_SETID(uid, gid) synctask_setid(synctask_get(), uid, gid);
+
+int
+syncopctx_setfsuid(void *uid);
+int
+syncopctx_setfsgid(void *gid);
+int
+syncopctx_setfsgroups(int count, const void *groups);
+int
+syncopctx_setfspid(void *pid);
+int
+syncopctx_setfslkowner(gf_lkowner_t *lk_owner);
+
+static inline call_frame_t *
+syncop_create_frame(xlator_t *this)
+{
+    call_frame_t *frame = NULL;
+    int ngrps = -1;
+    struct syncopctx *opctx = NULL;
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        return NULL;
+
+    frame->root->type = GF_OP_TYPE_FOP;
+    opctx = syncopctx_getctx();
+
+    if (opctx && (opctx->valid & SYNCOPCTX_PID))
+        frame->root->pid = opctx->pid;
+    else
+        frame->root->pid = getpid();
+
+    if (opctx && (opctx->valid & SYNCOPCTX_UID))
+        frame->root->uid = opctx->uid;
+    else
+        frame->root->uid = geteuid();
+
+    if (opctx && (opctx->valid & SYNCOPCTX_GID))
+        frame->root->gid = opctx->gid;
+    else
+        frame->root->gid = getegid();
+
+    if (opctx && (opctx->valid & SYNCOPCTX_GROUPS)) {
+        ngrps = opctx->ngrps;
+
+        if (ngrps != 0 && opctx->groups != NULL) {
+            if (call_stack_alloc_groups(frame->root, ngrps) != 0) {
+                STACK_DESTROY(frame->root);
+                return NULL;
+            }
+
+            memcpy(frame->root->groups, opctx->groups, (sizeof(gid_t) * ngrps));
+        }
+    } else {
+        ngrps = getgroups(0, 0);
+        if (ngrps < 0) {
+            STACK_DESTROY(frame->root);
+            return NULL;
+        }
+
+        if (call_stack_alloc_groups(frame->root, ngrps) != 0) {
+            STACK_DESTROY(frame->root);
+            return NULL;
+        }
+
+        if (getgroups(ngrps, frame->root->groups) < 0) {
+            STACK_DESTROY(frame->root);
+            return NULL;
+        }
+    }
+
+    if (opctx && (opctx->valid & SYNCOPCTX_LKOWNER))
+        frame->root->lk_owner = opctx->lk_owner;
+
+    return frame;
+}
+
+int
+synclock_init(synclock_t *lock, lock_attr_t attr);
+int
+synclock_destroy(synclock_t *lock);
+int
+synclock_lock(synclock_t *lock);
+int
+synclock_trylock(synclock_t *lock);
+int
+synclock_unlock(synclock_t *lock);
+
+int32_t
+synccond_init(synccond_t *cond);
+
+void
+synccond_destroy(synccond_t *cond);
+
+int
+synccond_wait(synccond_t *cond, synclock_t *lock);
+
+int
+synccond_timedwait(synccond_t *cond, synclock_t *lock, struct timespec *delta);
+
+void
+synccond_signal(synccond_t *cond);
+
+void
+synccond_broadcast(synccond_t *cond);
+
+int
+syncbarrier_init(syncbarrier_t *barrier);
+int
+syncbarrier_wait(syncbarrier_t *barrier, int waitfor);
+int
+syncbarrier_wake(syncbarrier_t *barrier);
+int
+syncbarrier_destroy(syncbarrier_t *barrier);
+
+int
+syncop_lookup(xlator_t *subvol, loc_t *loc,
+              /* out */
+              struct iatt *iatt, struct iatt *parent,
+              /* xdata */
+              dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_readdirp(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+                /* out */
+                gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_readdir(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+               gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_opendir(xlator_t *subvol, loc_t *loc, fd_t *fd, dict_t *xdata_in,
+               dict_t **xdata_out);
+
+int
+syncop_setattr(xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
+               /* out */
+               struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+               dict_t **xdata_out);
+
+int
+syncop_fsetattr(xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
+                /* out */
+                struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+                dict_t **xdata_out);
+
+int
+syncop_statfs(xlator_t *subvol, loc_t *loc,
+              /* out */
+              struct statvfs *buf, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_setxattr(xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
+                dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_fsetxattr(xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
+                 dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_listxattr(xlator_t *subvol, loc_t *loc, dict_t **dict, dict_t *xdata_in,
+                 dict_t **xdata_out);
+
+int
+syncop_getxattr(xlator_t *xl, loc_t *loc, dict_t **dict, const char *key,
+                dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_fgetxattr(xlator_t *xl, fd_t *fd, dict_t **dict, const char *key,
+                 dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_removexattr(xlator_t *subvol, loc_t *loc, const char *name,
+                   dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_fremovexattr(xlator_t *subvol, fd_t *fd, const char *name,
+                    dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_create(xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
+              fd_t *fd, struct iatt *iatt, dict_t *xdata_in,
+              dict_t **xdata_out);
+
+int
+syncop_open(xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
+            dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_close(fd_t *fd);
+
+int
+syncop_write(xlator_t *subvol, fd_t *fd, const char *buf, int size,
+             off_t offset, struct iobref *iobref, uint32_t flags,
+             dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_writev(xlator_t *subvol, fd_t *fd, const struct iovec *vector,
+              int32_t count, off_t offset, struct iobref *iobref,
+              uint32_t flags, struct iatt *preiatt, struct iatt *postiatt,
+              dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_readv(xlator_t *subvol, fd_t *fd, size_t size, off_t off, uint32_t flags,
+             /* out */
+             struct iovec **vector, int *count, struct iobref **iobref,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_ftruncate(xlator_t *subvol, fd_t *fd, off_t offset, struct iatt *preiatt,
+                 struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_truncate(xlator_t *subvol, loc_t *loc, off_t offset, dict_t *xdata_in,
+                dict_t **xdata_out);
+
+int
+syncop_unlink(xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
+              dict_t **xdata_out);
+
+int
+syncop_rmdir(xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
+             dict_t **xdata_out);
+
+int
+syncop_fsync(xlator_t *subvol, fd_t *fd, int dataonly, struct iatt *preiatt,
+             struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_flush(xlator_t *subvol, fd_t *fd, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_fstat(xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
+             dict_t **xdata_out);
+
+int
+syncop_stat(xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
+            dict_t **xdata_out);
+
+int
+syncop_symlink(xlator_t *subvol, loc_t *loc, const char *newpath,
+               struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_readlink(xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
+                dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_mknod(xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_mkdir(xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
+             dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_link(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, struct iatt *iatt,
+            dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_fsyncdir(xlator_t *subvol, fd_t *fd, int datasync, dict_t *xdata_in,
+                dict_t **xdata_out);
+
+int
+syncop_access(xlator_t *subvol, loc_t *loc, int32_t mask, dict_t *xdata_in,
+              dict_t **xdata_out);
+
+int
+syncop_fallocate(xlator_t *subvol, fd_t *fd, int32_t keep_size, off_t offset,
+                 size_t len, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_discard(xlator_t *subvol, fd_t *fd, off_t offset, size_t len,
+               dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_zerofill(xlator_t *subvol, fd_t *fd, off_t offset, off_t len,
+                dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_rename(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, dict_t *xdata_in,
+              dict_t **xdata_out);
+
+int
+syncop_lk(xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
+          dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_inodelk(xlator_t *subvol, const char *volume, loc_t *loc, int32_t cmd,
+               struct gf_flock *lock, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_lease(xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
+             dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_ipc(xlator_t *subvol, int op, dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_xattrop(xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
+               dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+               dict_t **xdata_out);
+
+int
+syncop_fxattrop(xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
+                dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+                dict_t **xdata_out);
+
+int
+syncop_seek(xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
+            dict_t *xdata_in, off_t *off);
+
+int
+syncop_getactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out);
+
+int
+syncop_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int
+syncop_setactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out);
+
+int
+syncop_put(xlator_t *subvol, loc_t *loc, mode_t mode, mode_t umask,
+           uint32_t flags, struct iovec *vector, int32_t count, off_t offset,
+           struct iobref *iobref, dict_t *xattr, struct iatt *iatt,
+           dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata);
+
+int
+syncop_icreate(xlator_t *subvol, loc_t *loc, mode_t mode, dict_t *xdata_out);
+
+int
+syncop_entrylk(xlator_t *subvol, const char *volume, loc_t *loc,
+               const char *basename, entrylk_cmd cmd, entrylk_type type,
+               dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_copy_file_range(xlator_t *subvol, fd_t *fd_in, off64_t off_in,
+                       fd_t *fd_out, off64_t off_out, size_t len,
+                       uint32_t flags, struct iatt *stbuf,
+                       struct iatt *preiatt_dst, struct iatt *postiatt_dst,
+                       dict_t *xdata_in, dict_t **xdata_out);
+
+int
+syncop_copy_file_range_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, struct iatt *stbuf,
+                           struct iatt *prebuf_dst, struct iatt *postbuf_dst,
+                           dict_t *xdata);
+
+#endif /* _SYNCOP_H */
diff --git a/libglusterfs/src/glusterfs/syscall.h b/libglusterfs/src/glusterfs/syscall.h
new file mode 100644
index 00000000000..b6d3ab4f2ad
--- /dev/null
+++ b/libglusterfs/src/glusterfs/syscall.h
@@ -0,0 +1,278 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __SYSCALL_H__
+#define __SYSCALL_H__
+
+#include <dirent.h>
+#include <sys/uio.h>
+#include <sys/statvfs.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <stdio.h>
+
+/* GF follows the Linux XATTR definition, which differs in Darwin. */
+#define GF_XATTR_CREATE 0x1  /* set value, fail if attr already exists */
+#define GF_XATTR_REPLACE 0x2 /* set value, fail if attr does not exist */
+
+/* Linux kernel version 2.6.x don't have these defined
+   define if not defined */
+
+#ifndef XATTR_SECURITY_PREFIX
+#define XATTR_SECURITY_PREFIX "security."
+#define XATTR_SECURITY_PREFIX_LEN (sizeof(XATTR_SECURITY_PREFIX) - 1)
+#endif
+
+#ifndef XATTR_SYSTEM_PREFIX
+#define XATTR_SYSTEM_PREFIX "system."
+#define XATTR_SYSTEM_PREFIX_LEN (sizeof(XATTR_SYSTEM_PREFIX) - 1)
+#endif
+
+#ifndef XATTR_TRUSTED_PREFIX
+#define XATTR_TRUSTED_PREFIX "trusted."
+#define XATTR_TRUSTED_PREFIX_LEN (sizeof(XATTR_TRUSTED_PREFIX) - 1)
+#endif
+
+#ifndef XATTR_USER_PREFIX
+#define XATTR_USER_PREFIX "user."
+#define XATTR_USER_PREFIX_LEN (sizeof(XATTR_USER_PREFIX) - 1)
+#endif
+
+#if defined(GF_DARWIN_HOST_OS)
+#include <sys/xattr.h>
+#define XATTR_DARWIN_NOSECURITY XATTR_NOSECURITY
+#define XATTR_DARWIN_NODEFAULT XATTR_NODEFAULT
+#define XATTR_DARWIN_SHOWCOMPRESSION XATTR_SHOWCOMPRESSION
+#endif
+
+int
+sys_lstat(const char *path, struct stat *buf);
+
+int
+sys_stat(const char *path, struct stat *buf);
+
+int
+sys_fstat(int fd, struct stat *buf);
+
+int
+sys_fstatat(int dirfd, const char *pathname, struct stat *buf, int flags);
+
+int
+sys_open(const char *pathname, int flags, int mode);
+
+int
+sys_openat(int dirfd, const char *pathname, int flags, int mode);
+
+DIR *
+sys_opendir(const char *name);
+
+struct dirent *
+sys_readdir(DIR *dir, struct dirent *de);
+
+ssize_t
+sys_readlink(const char *path, char *buf, size_t bufsiz);
+
+int
+sys_closedir(DIR *dir);
+
+int
+sys_mknod(const char *pathname, mode_t mode, dev_t dev);
+
+int
+sys_mkdir(const char *pathname, mode_t mode);
+
+int
+sys_mkdirat(int dirfd, const char *pathname, mode_t mode);
+
+int
+sys_unlink(const char *pathname);
+
+int
+sys_unlinkat(int dfd, const char *pathname);
+
+int
+sys_rmdir(const char *pathname);
+
+int
+sys_symlink(const char *oldpath, const char *newpath);
+
+int
+sys_symlinkat(const char *oldpath, int dirfd, const char *newpath);
+
+int
+sys_rename(const char *oldpath, const char *newpath);
+
+int
+sys_link(const char *oldpath, const char *newpath);
+
+int
+sys_linkat(int oldfd, const char *oldpath, int newfd, const char *newpath);
+
+int
+sys_chmod(const char *path, mode_t mode);
+
+int
+sys_fchmod(int fd, mode_t mode);
+
+int
+sys_chown(const char *path, uid_t owner, gid_t group);
+
+int
+sys_fchown(int fd, uid_t owner, gid_t group);
+
+int
+sys_lchown(const char *path, uid_t owner, gid_t group);
+
+int
+sys_truncate(const char *path, off_t length);
+
+int
+sys_ftruncate(int fd, off_t length);
+
+int
+sys_utimes(const char *filename, const struct timeval times[2]);
+
+#if defined(HAVE_UTIMENSAT)
+int
+sys_utimensat(int dirfd, const char *filename, const struct timespec times[2],
+              int flags);
+#endif
+
+int
+sys_futimes(int fd, const struct timeval times[2]);
+
+int
+sys_creat(const char *pathname, mode_t mode);
+
+ssize_t
+sys_readv(int fd, const struct iovec *iov, int iovcnt);
+
+ssize_t
+sys_writev(int fd, const struct iovec *iov, int iovcnt);
+
+ssize_t
+sys_read(int fd, void *buf, size_t count);
+
+ssize_t
+sys_write(int fd, const void *buf, size_t count);
+
+off_t
+sys_lseek(int fd, off_t offset, int whence);
+
+int
+sys_statvfs(const char *path, struct statvfs *buf);
+
+int
+sys_fstatvfs(int fd, struct statvfs *buf);
+
+int
+sys_close(int fd);
+
+int
+sys_fsync(int fd);
+
+int
+sys_fdatasync(int fd);
+
+void
+gf_add_prefix(const char *ns, const char *key, char **newkey);
+
+void
+gf_remove_prefix(const char *ns, const char *key, char **newkey);
+
+int
+sys_lsetxattr(const char *path, const char *name, const void *value,
+              size_t size, int flags);
+
+ssize_t
+sys_llistxattr(const char *path, char *list, size_t size);
+
+ssize_t
+sys_lgetxattr(const char *path, const char *name, void *value, size_t size);
+
+ssize_t
+sys_fgetxattr(int filedes, const char *name, void *value, size_t size);
+
+int
+sys_fsetxattr(int filedes, const char *name, const void *value, size_t size,
+              int flags);
+
+ssize_t
+sys_flistxattr(int filedes, char *list, size_t size);
+
+int
+sys_lremovexattr(const char *path, const char *name);
+
+int
+sys_fremovexattr(int filedes, const char *name);
+
+int
+sys_access(const char *pathname, int mode);
+
+int
+sys_fallocate(int fd, int mode, off_t offset, off_t len);
+
+ssize_t
+sys_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
+
+ssize_t
+sys_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
+
+ssize_t
+sys_pread(int fd, void *buf, size_t count, off_t offset);
+
+ssize_t
+sys_pwrite(int fd, const void *buf, size_t count, off_t offset);
+
+int
+sys_socket(int domain, int type, int protocol);
+
+int
+sys_accept(int sock, struct sockaddr *sockaddr, socklen_t *socklen, int flags);
+
+#ifdef GF_BSD_HOST_OS
+#ifndef _OFF64_T_DECLARED
+/*
+ * Including <stdio.h> (done above) should actually define
+ * _OFF64_T_DECLARED with off64_t data type being available
+ * for consumption. But, off64_t data type is not recognizable
+ * for FreeBSD versions less than 11. Hence, int64_t is typedefed
+ * to off64_t.
+ */
+#define _OFF64_T_DECLARED
+typedef int64_t off64_t;
+#endif /* _OFF64_T_DECLARED */
+#endif /* GF_BSD_HOST_OS */
+
+/*
+ * According to the man page of copy_file_range, both off_in and off_out are
+ * pointers to the data type loff_t (i.e. loff_t *). But, freebsd does not
+ * have (and recognize) loff_t. Since loff_t is 64 bits, use off64_t
+ * instead.  Since it's a pointer type it should be okay. It just needs
+ * to be a pointer-to-64-bit pointer for both 32- and 64-bit platforms.
+ * off64_t is recognized by freebsd.
+ * TODO: In future, when freebsd can recognize loff_t, probably revisit this
+ *       and change the off_in and off_out to (loff_t *).
+ */
+ssize_t
+sys_copy_file_range(int fd_in, off64_t *off_in, int fd_out, off64_t *off_out,
+                    size_t len, unsigned int flags);
+
+int
+sys_kill(pid_t pid, int sig);
+
+#ifdef __FreeBSD__
+int
+sys_sysctl(const int *name, u_int namelen, void *oldp, size_t *oldlenp,
+           const void *newp, size_t newlen);
+#endif
+
+#endif /* __SYSCALL_H__ */
diff --git a/libglusterfs/src/glusterfs/template-component-messages.h b/libglusterfs/src/glusterfs/template-component-messages.h
new file mode 100644
index 00000000000..aa7ad3d1baa
--- /dev/null
+++ b/libglusterfs/src/glusterfs/template-component-messages.h
@@ -0,0 +1,28 @@
+/*
+ Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+ This file is part of GlusterFS.
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+ */
+
+#ifndef _component_MESSAGES_H_
+#define _component_MESSAGES_H_
+
+#include "glusterfs/glfs-message-id.h"
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
+ */
+
+GLFS_MSGID(component, message id, message id, ...);
+
+#endif /* !_component_MESSAGES_H_ */
diff --git a/libglusterfs/src/glusterfs/throttle-tbf.h b/libglusterfs/src/glusterfs/throttle-tbf.h
new file mode 100644
index 00000000000..cccb13c83d9
--- /dev/null
+++ b/libglusterfs/src/glusterfs/throttle-tbf.h
@@ -0,0 +1,74 @@
+/*
+   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#include "glusterfs/list.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/locking.h"
+
+#ifndef THROTTLE_TBF_H__
+#define THROTTLE_TBF_H__
+
+typedef enum tbf_ops {
+    TBF_OP_MIN = -1,
+    TBF_OP_HASH = 0,    /* checksum calculation  */
+    TBF_OP_READ = 1,    /* inode read(s)         */
+    TBF_OP_READDIR = 2, /* dentry read(s)        */
+    TBF_OP_MAX = 3,
+} tbf_ops_t;
+
+/**
+ * Operation rate specification
+ */
+typedef struct tbf_opspec {
+    tbf_ops_t op;
+
+    unsigned long rate;
+
+    unsigned long maxlimit;
+
+    unsigned long token_gen_interval; /* Token generation interval in usec */
+} tbf_opspec_t;
+
+/**
+ * Token bucket for each operation type
+ */
+typedef struct tbf_bucket {
+    gf_lock_t lock;
+
+    pthread_t tokener; /* token generator thread          */
+
+    unsigned long tokenrate; /* token generation rate           */
+
+    unsigned long tokens; /* number of current tokens        */
+
+    unsigned long maxtokens; /* maximum token in the bucket     */
+
+    struct list_head queued; /* list of non-conformant requests */
+
+    unsigned long token_gen_interval; /* Token generation interval in usec */
+} tbf_bucket_t;
+
+typedef struct tbf {
+    tbf_bucket_t **bucket;
+} tbf_t;
+
+tbf_t *
+tbf_init(tbf_opspec_t *, unsigned int);
+
+int
+tbf_mod(tbf_t *, tbf_opspec_t *);
+
+void
+tbf_throttle(tbf_t *, tbf_ops_t, unsigned long);
+
+#define TBF_THROTTLE_BEGIN(tbf, op, tokens) (tbf_throttle(tbf, op, tokens))
+#define TBF_THROTTLE_END(tbf, op, tokens)
+
+#endif /** THROTTLE_TBF_H__ */
diff --git a/libglusterfs/src/glusterfs/timer.h b/libglusterfs/src/glusterfs/timer.h
new file mode 100644
index 00000000000..ae5b2edf451
--- /dev/null
+++ b/libglusterfs/src/glusterfs/timer.h
@@ -0,0 +1,56 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _TIMER_H
+#define _TIMER_H
+
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/xlator.h"
+#include <sys/time.h>
+#include <pthread.h>
+
+typedef void (*gf_timer_cbk_t)(void *);
+
+struct _gf_timer {
+    union {
+        struct list_head list;
+        struct {
+            struct _gf_timer *next;
+            struct _gf_timer *prev;
+        };
+    };
+    struct timespec at;
+    gf_timer_cbk_t callbk;
+    void *data;
+    xlator_t *xl;
+    gf_boolean_t fired;
+};
+
+struct _gf_timer_registry {
+    struct list_head active;
+    pthread_mutex_t lock;
+    pthread_cond_t cond;
+    pthread_t th;
+    char fin;
+};
+
+typedef struct _gf_timer gf_timer_t;
+typedef struct _gf_timer_registry gf_timer_registry_t;
+
+gf_timer_t *
+gf_timer_call_after(glusterfs_ctx_t *ctx, struct timespec delta,
+                    gf_timer_cbk_t cbk, void *data);
+
+int32_t
+gf_timer_call_cancel(glusterfs_ctx_t *ctx, gf_timer_t *event);
+
+void
+gf_timer_registry_destroy(glusterfs_ctx_t *ctx);
+#endif /* _TIMER_H */
diff --git a/libglusterfs/src/timespec.h b/libglusterfs/src/glusterfs/timespec.h
index 9c393ee7166..bb9ab446a5f 100644
--- a/libglusterfs/src/timespec.h
+++ b/libglusterfs/src/glusterfs/timespec.h
@@ -14,14 +14,20 @@
 #include <stdint.h>
 #include <sys/time.h>
 
-#define TS(ts)  ((ts.tv_sec * 1000000000LL) + ts.tv_nsec)
+#define TS(ts) ((ts.tv_sec * 1000000000LL) + ts.tv_nsec)
 #define NANO (+1.0E-9)
 #define GIGA UINT64_C(1000000000)
 
-void timespec_now (struct timespec *ts);
-void timespec_adjust_delta (struct timespec *ts, struct timespec delta);
-void timespec_sub (const struct timespec *begin,
-                   const struct timespec *end,
-                   struct timespec *res);
+void
+timespec_now(struct timespec *ts);
+void
+timespec_now_realtime(struct timespec *ts);
+void
+timespec_adjust_delta(struct timespec *ts, struct timespec delta);
+void
+timespec_sub(const struct timespec *begin, const struct timespec *end,
+             struct timespec *res);
+int
+timespec_cmp(const struct timespec *lhs_ts, const struct timespec *rhs_ts);
 
 #endif /*  __INCLUDE_TIMESPEC_H__ */
diff --git a/libglusterfs/src/glusterfs/trie.h b/libglusterfs/src/glusterfs/trie.h
new file mode 100644
index 00000000000..6d2d8015964
--- /dev/null
+++ b/libglusterfs/src/glusterfs/trie.h
@@ -0,0 +1,52 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _TRIE_H_
+#define _TRIE_H_
+
+struct trienode;
+typedef struct trienode trienode_t;
+
+struct trie;
+typedef struct trie trie_t;
+
+struct trienodevec {
+    trienode_t **nodes;
+    unsigned cnt;
+};
+
+trie_t *
+trie_new();
+
+int
+trie_add(trie_t *trie, const char *word);
+
+void
+trie_destroy(trie_t *trie);
+
+void
+trie_destroy_bynode(trienode_t *node);
+
+int
+trie_measure(trie_t *trie, const char *word, trienode_t **nodes, int nodecnt);
+
+int
+trie_measure_vec(trie_t *trie, const char *word, struct trienodevec *nodevec);
+
+void
+trie_reset_search(trie_t *trie);
+
+int
+trienode_get_dist(trienode_t *node);
+
+int
+trienode_get_word(trienode_t *node, char **buf);
+
+#endif
diff --git a/libglusterfs/src/glusterfs/upcall-utils.h b/libglusterfs/src/glusterfs/upcall-utils.h
new file mode 100644
index 00000000000..0de8428c5fc
--- /dev/null
+++ b/libglusterfs/src/glusterfs/upcall-utils.h
@@ -0,0 +1,110 @@
+/*
+  Copyright (c) 2015, Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _UPCALL_UTILS_H
+#define _UPCALL_UTILS_H
+
+#include "glusterfs/iatt.h"
+#include "glusterfs/compat-uuid.h"
+#include "glusterfs/compat.h"
+
+/* Flags sent for cache_invalidation */
+#define UP_NLINK 0x00000001 /* update nlink */
+#define UP_MODE 0x00000002  /* update mode and ctime */
+#define UP_OWN 0x00000004   /* update mode,uid,gid and ctime */
+#define UP_SIZE 0x00000008  /* update fsize */
+#define UP_TIMES 0x00000010 /* update all times */
+#define UP_ATIME 0x00000020 /* update atime only */
+#define UP_PERM                                                                \
+    0x00000040 /* update fields needed for permission                          \
+                  checking */
+#define UP_RENAME                                                              \
+    0x00000080 /* this is a rename op - delete the cache                       \
+                  entry */
+#define UP_FORGET                                                              \
+    0x00000100                     /* inode_forget on server side -            \
+                                      invalidate the cache entry */
+#define UP_PARENT_TIMES 0x00000200 /* update parent dir times */
+
+#define UP_XATTR 0x00000400    /* update the xattrs and ctime */
+#define UP_XATTR_RM 0x00000800 /* Remove the xattrs and update ctime */
+
+#define UP_EXPLICIT_LOOKUP 0x00001000 /* Request an explicit lookup */
+
+#define UP_INVAL_ATTR 0x00002000 /* Request to invalidate iatt and xatt */
+
+/* for fops - open, read, lk, */
+#define UP_UPDATE_CLIENT (UP_ATIME)
+
+/* for fop - write, truncate */
+#define UP_WRITE_FLAGS (UP_SIZE | UP_TIMES)
+
+/* for fop - setattr */
+#define UP_ATTR_FLAGS (UP_SIZE | UP_TIMES | UP_OWN | UP_MODE | UP_PERM)
+/* for fop - rename */
+#define UP_RENAME_FLAGS (UP_RENAME)
+
+/* to invalidate parent directory entries for fops -rename, unlink, rmdir,
+ * mkdir, create */
+#define UP_PARENT_DENTRY_FLAGS (UP_PARENT_TIMES)
+
+/* for fop - unlink, link, rmdir, mkdir */
+#define UP_NLINK_FLAGS (UP_NLINK | UP_TIMES)
+
+#define IATT_UPDATE_FLAGS                                                      \
+    (UP_NLINK | UP_MODE | UP_OWN | UP_SIZE | UP_TIMES | UP_ATIME | UP_PERM)
+
+typedef enum {
+    GF_UPCALL_EVENT_NULL,
+    GF_UPCALL_CACHE_INVALIDATION,
+    GF_UPCALL_RECALL_LEASE,
+    GF_UPCALL_INODELK_CONTENTION,
+    GF_UPCALL_ENTRYLK_CONTENTION,
+} gf_upcall_event_t;
+
+struct gf_upcall {
+    char *client_uid;
+    uuid_t gfid;
+    uint32_t event_type;
+    void *data;
+};
+
+struct gf_upcall_cache_invalidation {
+    uint32_t flags;
+    uint32_t expire_time_attr;
+    struct iatt stat;
+    struct iatt p_stat;    /* parent dir stat */
+    struct iatt oldp_stat; /* oldparent dir stat */
+    dict_t *dict;          /* For xattrs */
+};
+
+struct gf_upcall_recall_lease {
+    uint32_t lease_type; /* Lease type to which client can downgrade to*/
+    uuid_t tid;          /* transaction id of the fop that caused
+                            the recall */
+    dict_t *dict;
+};
+
+struct gf_upcall_inodelk_contention {
+    struct gf_flock flock;
+    pid_t pid;
+    const char *domain;
+    dict_t *xdata;
+};
+
+struct gf_upcall_entrylk_contention {
+    uint32_t type;
+    pid_t pid;
+    const char *name;
+    const char *domain;
+    dict_t *xdata;
+};
+
+#endif /* _UPCALL_UTILS_H */
diff --git a/libglusterfs/src/glusterfs/xlator.h b/libglusterfs/src/glusterfs/xlator.h
new file mode 100644
index 00000000000..4fd3abdaeff
--- /dev/null
+++ b/libglusterfs/src/glusterfs/xlator.h
@@ -0,0 +1,1106 @@
+/*
+  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef _XLATOR_H
+#define _XLATOR_H
+
+#include <stdint.h>                    // for int32_t
+#include <sys/types.h>                 // for off_t, mode_t, off64_t, dev_t
+#include "glusterfs/glusterfs-fops.h"  // for GF_FOP_MAXVALUE, entrylk_cmd
+#include "glusterfs/atomic.h"          // for gf_atomic_t
+#include "glusterfs/glusterfs.h"       // for gf_boolean_t, glusterfs_ctx_t
+#include "glusterfs/compat-uuid.h"     // for uuid_t
+#include "glusterfs/compat.h"
+#include "glusterfs/event-history.h"
+#include "glusterfs/dict.h"
+#include "glusterfs/latency.h"
+
+#define FIRST_CHILD(xl) (xl->children->xlator)
+#define SECOND_CHILD(xl) (xl->children->next->xlator)
+
+#define GF_SET_ATTR_MODE 0x1
+#define GF_SET_ATTR_UID 0x2
+#define GF_SET_ATTR_GID 0x4
+#define GF_SET_ATTR_SIZE 0x8
+#define GF_SET_ATTR_ATIME 0x10
+#define GF_SET_ATTR_MTIME 0x20
+#define GF_SET_ATTR_CTIME 0x40
+#define GF_ATTR_ATIME_NOW 0x80
+#define GF_ATTR_MTIME_NOW 0x100
+
+#define gf_attr_mode_set(mode) ((mode)&GF_SET_ATTR_MODE)
+#define gf_attr_uid_set(mode) ((mode)&GF_SET_ATTR_UID)
+#define gf_attr_gid_set(mode) ((mode)&GF_SET_ATTR_GID)
+#define gf_attr_size_set(mode) ((mode)&GF_SET_ATTR_SIZE)
+#define gf_attr_atime_set(mode) ((mode)&GF_SET_ATTR_ATIME)
+#define gf_attr_mtime_set(mode) ((mode)&GF_SET_ATTR_MTIME)
+
+struct _xlator;
+typedef struct _xlator xlator_t;
+struct _dir_entry;
+typedef struct _dir_entry dir_entry_t;
+struct _gf_dirent;
+typedef struct _gf_dirent gf_dirent_t;
+struct _loc;
+typedef struct _loc loc_t;
+
+typedef int32_t (*event_notify_fn_t)(xlator_t *this, int32_t event, void *data,
+                                     ...);
+
+#include "glusterfs/list.h"
+#include "glusterfs/gf-dirent.h"
+#include "glusterfs/stack.h"
+#include "glusterfs/iobuf.h"
+#include "glusterfs/globals.h"
+#include "glusterfs/iatt.h"
+#include "glusterfs/options.h"
+#include "glusterfs/client_t.h"
+
+struct _loc {
+    const char *path;
+    const char *name;
+    inode_t *inode;
+    inode_t *parent;
+    /* Currently all location based operations are through 'gfid' of inode.
+     * But the 'inode->gfid' only gets set in higher most layer (as in,
+     * 'fuse', 'protocol/server', or 'nfs/server'). So if translators want
+     * to send fops on a inode before the 'inode->gfid' is set, they have to
+     * make use of below 'gfid' fields
+     */
+    uuid_t gfid;
+    uuid_t pargfid;
+};
+
+typedef int32_t (*fop_getspec_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, char *spec_data);
+
+typedef int32_t (*fop_rchecksum_cbk_t)(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, uint32_t weak_checksum,
+                                       uint8_t *strong_checksum, dict_t *xdata);
+
+typedef int32_t (*fop_getspec_t)(call_frame_t *frame, xlator_t *this,
+                                 const char *key, int32_t flag);
+
+typedef int32_t (*fop_rchecksum_t)(call_frame_t *frame, xlator_t *this,
+                                   fd_t *fd, off_t offset, int32_t len,
+                                   dict_t *xdata);
+
+typedef int32_t (*fop_lookup_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, inode_t *inode,
+                                    struct iatt *buf, dict_t *xdata,
+                                    struct iatt *postparent);
+
+typedef int32_t (*fop_stat_cbk_t)(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, struct iatt *buf,
+                                  dict_t *xdata);
+
+typedef int32_t (*fop_fstat_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iatt *buf,
+                                   dict_t *xdata);
+
+typedef int32_t (*fop_truncate_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, struct iatt *prebuf,
+                                      struct iatt *postbuf, dict_t *xdata);
+
+typedef int32_t (*fop_ftruncate_cbk_t)(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, struct iatt *prebuf,
+                                       struct iatt *postbuf, dict_t *xdata);
+
+typedef int32_t (*fop_access_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_readlink_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, const char *path,
+                                      struct iatt *buf, dict_t *xdata);
+
+typedef int32_t (*fop_mknod_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, inode_t *inode,
+                                   struct iatt *buf, struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_mkdir_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, inode_t *inode,
+                                   struct iatt *buf, struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_unlink_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, struct iatt *preparent,
+                                    struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_rmdir_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_symlink_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, inode_t *inode,
+                                     struct iatt *buf, struct iatt *preparent,
+                                     struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_rename_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, struct iatt *buf,
+                                    struct iatt *preoldparent,
+                                    struct iatt *postoldparent,
+                                    struct iatt *prenewparent,
+                                    struct iatt *postnewparent, dict_t *xdata);
+
+typedef int32_t (*fop_link_cbk_t)(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, inode_t *inode,
+                                  struct iatt *buf, struct iatt *preparent,
+                                  struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_create_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, fd_t *fd, inode_t *inode,
+                                    struct iatt *buf, struct iatt *preparent,
+                                    struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_open_cbk_t)(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+typedef int32_t (*fop_readv_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iovec *vector,
+                                   int32_t count, struct iatt *stbuf,
+                                   struct iobref *iobref, dict_t *xdata);
+
+typedef int32_t (*fop_writev_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, struct iatt *prebuf,
+                                    struct iatt *postbuf, dict_t *xdata);
+
+typedef int32_t (*fop_flush_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_fsync_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iatt *prebuf,
+                                   struct iatt *postbuf, dict_t *xdata);
+
+typedef int32_t (*fop_opendir_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, fd_t *fd, dict_t *xdata);
+
+typedef int32_t (*fop_fsyncdir_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_statfs_cbk_t)(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int32_t op_ret,
+                                    int32_t op_errno, struct statvfs *buf,
+                                    dict_t *xdata);
+
+typedef int32_t (*fop_setxattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_getxattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *dict,
+                                      dict_t *xdata);
+
+typedef int32_t (*fop_fsetxattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_fgetxattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, dict_t *dict,
+                                       dict_t *xdata);
+
+typedef int32_t (*fop_removexattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int32_t op_ret,
+                                         int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_fremovexattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                          xlator_t *this, int32_t op_ret,
+                                          int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_lk_cbk_t)(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, struct gf_flock *flock,
+                                dict_t *xdata);
+
+typedef int32_t (*fop_inodelk_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_finodelk_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_entrylk_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_fentrylk_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_readdir_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, gf_dirent_t *entries,
+                                     dict_t *xdata);
+
+typedef int32_t (*fop_readdirp_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, gf_dirent_t *entries,
+                                      dict_t *xdata);
+
+typedef int32_t (*fop_xattrop_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, dict_t *xattr,
+                                     dict_t *xdata);
+
+typedef int32_t (*fop_fxattrop_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xattr,
+                                      dict_t *xdata);
+
+typedef int32_t (*fop_setattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, struct iatt *preop_stbuf,
+                                     struct iatt *postop_stbuf, dict_t *xdata);
+
+typedef int32_t (*fop_fsetattr_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno,
+                                      struct iatt *preop_stbuf,
+                                      struct iatt *postop_stbuf, dict_t *xdata);
+
+typedef int32_t (*fop_fallocate_cbk_t)(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno,
+                                       struct iatt *preop_stbuf,
+                                       struct iatt *postop_stbuf,
+                                       dict_t *xdata);
+
+typedef int32_t (*fop_discard_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, struct iatt *preop_stbuf,
+                                     struct iatt *postop_stbuf, dict_t *xdata);
+
+typedef int32_t (*fop_zerofill_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno,
+                                      struct iatt *preop_stbuf,
+                                      struct iatt *postop_stbuf, dict_t *xdata);
+
+typedef int32_t (*fop_ipc_cbk_t)(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int32_t op_ret,
+                                 int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_seek_cbk_t)(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, off_t offset,
+                                  dict_t *xdata);
+
+typedef int32_t (*fop_lease_cbk_t)(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct gf_lease *lease,
+                                   dict_t *xdata);
+typedef int32_t (*fop_compound_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, void *data,
+                                      dict_t *xdata);
+
+typedef int32_t (*fop_getactivelk_cbk_t)(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int32_t op_ret,
+                                         int32_t op_errno,
+                                         lock_migration_info_t *locklist,
+                                         dict_t *xdata);
+
+typedef int32_t (*fop_setactivelk_cbk_t)(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int32_t op_ret,
+                                         int32_t op_errno, dict_t *xdata);
+
+typedef int32_t (*fop_put_cbk_t)(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int32_t op_ret,
+                                 int32_t op_errno, inode_t *inode,
+                                 struct iatt *buf, struct iatt *preparent,
+                                 struct iatt *postparent, dict_t *xdata);
+
+typedef int32_t (*fop_icreate_cbk_t)(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int32_t op_ret,
+                                     int32_t op_errno, inode_t *inode,
+                                     struct iatt *buf, dict_t *xdata);
+
+typedef int32_t (*fop_namelink_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, struct iatt *prebuf,
+                                      struct iatt *postbuf, dict_t *xdata);
+
+typedef int32_t (*fop_copy_file_range_cbk_t)(
+    call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+    int32_t op_errno, struct iatt *stbuf, struct iatt *prebuf_dst,
+    struct iatt *postbuf_dst, dict_t *xdata);
+
+typedef int32_t (*fop_lookup_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                dict_t *xdata);
+
+typedef int32_t (*fop_stat_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                              dict_t *xdata);
+
+typedef int32_t (*fop_fstat_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               dict_t *xdata);
+
+typedef int32_t (*fop_truncate_t)(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, off_t offset, dict_t *xdata);
+
+typedef int32_t (*fop_ftruncate_t)(call_frame_t *frame, xlator_t *this,
+                                   fd_t *fd, off_t offset, dict_t *xdata);
+
+typedef int32_t (*fop_access_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                int32_t mask, dict_t *xdata);
+
+typedef int32_t (*fop_readlink_t)(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, size_t size, dict_t *xdata);
+
+typedef int32_t (*fop_mknod_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               mode_t mode, dev_t rdev, mode_t umask,
+                               dict_t *xdata);
+
+typedef int32_t (*fop_mkdir_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               mode_t mode, mode_t umask, dict_t *xdata);
+
+typedef int32_t (*fop_unlink_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                int xflags, dict_t *xdata);
+
+typedef int32_t (*fop_rmdir_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               int xflags, dict_t *xdata);
+
+typedef int32_t (*fop_symlink_t)(call_frame_t *frame, xlator_t *this,
+                                 const char *linkname, loc_t *loc, mode_t umask,
+                                 dict_t *xdata);
+
+typedef int32_t (*fop_rename_t)(call_frame_t *frame, xlator_t *this,
+                                loc_t *oldloc, loc_t *newloc, dict_t *xdata);
+
+typedef int32_t (*fop_link_t)(call_frame_t *frame, xlator_t *this,
+                              loc_t *oldloc, loc_t *newloc, dict_t *xdata);
+
+typedef int32_t (*fop_create_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                int32_t flags, mode_t mode, mode_t umask,
+                                fd_t *fd, dict_t *xdata);
+
+/* Tell subsequent writes on the fd_t to fsync after every writev fop without
+ * requiring a fsync fop.
+ */
+#define GF_OPEN_FSYNC 0x01
+
+/* Tell write-behind to disable writing behind despite O_SYNC not being set.
+ */
+#define GF_OPEN_NOWB 0x02
+
+typedef int32_t (*fop_open_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                              int32_t flags, fd_t *fd, dict_t *xdata);
+
+typedef int32_t (*fop_readv_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               size_t size, off_t offset, uint32_t flags,
+                               dict_t *xdata);
+
+typedef int32_t (*fop_writev_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                struct iovec *vector, int32_t count,
+                                off_t offset, uint32_t flags,
+                                struct iobref *iobref, dict_t *xdata);
+
+typedef int32_t (*fop_flush_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               dict_t *xdata);
+
+typedef int32_t (*fop_fsync_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               int32_t datasync, dict_t *xdata);
+
+typedef int32_t (*fop_opendir_t)(call_frame_t *frame, xlator_t *this,
+                                 loc_t *loc, fd_t *fd, dict_t *xdata);
+
+typedef int32_t (*fop_fsyncdir_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                  int32_t datasync, dict_t *xdata);
+
+typedef int32_t (*fop_statfs_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                dict_t *xdata);
+
+typedef int32_t (*fop_setxattr_t)(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, dict_t *dict, int32_t flags,
+                                  dict_t *xdata);
+
+typedef int32_t (*fop_getxattr_t)(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, const char *name, dict_t *xdata);
+
+typedef int32_t (*fop_fsetxattr_t)(call_frame_t *frame, xlator_t *this,
+                                   fd_t *fd, dict_t *dict, int32_t flags,
+                                   dict_t *xdata);
+
+typedef int32_t (*fop_fgetxattr_t)(call_frame_t *frame, xlator_t *this,
+                                   fd_t *fd, const char *name, dict_t *xdata);
+
+typedef int32_t (*fop_removexattr_t)(call_frame_t *frame, xlator_t *this,
+                                     loc_t *loc, const char *name,
+                                     dict_t *xdata);
+
+typedef int32_t (*fop_fremovexattr_t)(call_frame_t *frame, xlator_t *this,
+                                      fd_t *fd, const char *name,
+                                      dict_t *xdata);
+
+typedef int32_t (*fop_lk_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            int32_t cmd, struct gf_flock *flock, dict_t *xdata);
+
+typedef int32_t (*fop_inodelk_t)(call_frame_t *frame, xlator_t *this,
+                                 const char *volume, loc_t *loc, int32_t cmd,
+                                 struct gf_flock *flock, dict_t *xdata);
+
+typedef int32_t (*fop_finodelk_t)(call_frame_t *frame, xlator_t *this,
+                                  const char *volume, fd_t *fd, int32_t cmd,
+                                  struct gf_flock *flock, dict_t *xdata);
+
+typedef int32_t (*fop_entrylk_t)(call_frame_t *frame, xlator_t *this,
+                                 const char *volume, loc_t *loc,
+                                 const char *basename, entrylk_cmd cmd,
+                                 entrylk_type type, dict_t *xdata);
+
+typedef int32_t (*fop_fentrylk_t)(call_frame_t *frame, xlator_t *this,
+                                  const char *volume, fd_t *fd,
+                                  const char *basename, entrylk_cmd cmd,
+                                  entrylk_type type, dict_t *xdata);
+
+typedef int32_t (*fop_readdir_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                 size_t size, off_t offset, dict_t *xdata);
+
+typedef int32_t (*fop_readdirp_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                  size_t size, off_t offset, dict_t *xdata);
+
+typedef int32_t (*fop_xattrop_t)(call_frame_t *frame, xlator_t *this,
+                                 loc_t *loc, gf_xattrop_flags_t optype,
+                                 dict_t *xattr, dict_t *xdata);
+
+typedef int32_t (*fop_fxattrop_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                  gf_xattrop_flags_t optype, dict_t *xattr,
+                                  dict_t *xdata);
+
+typedef int32_t (*fop_setattr_t)(call_frame_t *frame, xlator_t *this,
+                                 loc_t *loc, struct iatt *stbuf, int32_t valid,
+                                 dict_t *xdata);
+
+typedef int32_t (*fop_fsetattr_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                  struct iatt *stbuf, int32_t valid,
+                                  dict_t *xdata);
+
+typedef int32_t (*fop_fallocate_t)(call_frame_t *frame, xlator_t *this,
+                                   fd_t *fd, int32_t keep_size, off_t offset,
+                                   size_t len, dict_t *xdata);
+
+typedef int32_t (*fop_discard_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                 off_t offset, size_t len, dict_t *xdata);
+
+typedef int32_t (*fop_zerofill_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                  off_t offset, off_t len, dict_t *xdata);
+
+typedef int32_t (*fop_ipc_t)(call_frame_t *frame, xlator_t *this, int32_t op,
+                             dict_t *xdata);
+
+typedef int32_t (*fop_seek_t)(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                              off_t offset, gf_seek_what_t what, dict_t *xdata);
+
+typedef int32_t (*fop_lease_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               struct gf_lease *lease, dict_t *xdata);
+
+typedef int32_t (*fop_compound_t)(call_frame_t *frame, xlator_t *this,
+                                  void *args, dict_t *xdata);
+
+typedef int32_t (*fop_getactivelk_t)(call_frame_t *frame, xlator_t *this,
+                                     loc_t *loc, dict_t *xdata);
+
+typedef int32_t (*fop_setactivelk_t)(call_frame_t *frame, xlator_t *this,
+                                     loc_t *loc,
+                                     lock_migration_info_t *locklist,
+                                     dict_t *xdata);
+
+typedef int32_t (*fop_put_t)(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                             mode_t mode, mode_t umask, uint32_t flags,
+                             struct iovec *vector, int32_t count, off_t offset,
+                             struct iobref *iobref, dict_t *xattr,
+                             dict_t *xdata);
+
+typedef int32_t (*fop_icreate_t)(call_frame_t *frame, xlator_t *this,
+                                 loc_t *loc, mode_t mode, dict_t *xdata);
+
+typedef int32_t (*fop_namelink_t)(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, dict_t *xdata);
+typedef int32_t (*fop_copy_file_range_t)(call_frame_t *frame, xlator_t *this,
+                                         fd_t *fd_in, off64_t off_in,
+                                         fd_t *fd_out, off64_t off_out,
+                                         size_t len, uint32_t flags,
+                                         dict_t *xdata);
+
+/* WARNING: make sure the list is in order with FOP definition in
+   `rpc/xdr/src/glusterfs-fops.x`.
+   If it is not in order, mainly the metrics related feature would be broken */
+struct xlator_fops {
+    fop_stat_t stat;
+    fop_readlink_t readlink;
+    fop_mknod_t mknod;
+    fop_mkdir_t mkdir;
+    fop_unlink_t unlink;
+    fop_rmdir_t rmdir;
+    fop_symlink_t symlink;
+    fop_rename_t rename;
+    fop_link_t link;
+    fop_truncate_t truncate;
+    fop_open_t open;
+    fop_readv_t readv;
+    fop_writev_t writev;
+    fop_statfs_t statfs;
+    fop_flush_t flush;
+    fop_fsync_t fsync;
+    fop_setxattr_t setxattr;
+    fop_getxattr_t getxattr;
+    fop_removexattr_t removexattr;
+    fop_opendir_t opendir;
+    fop_fsyncdir_t fsyncdir;
+    fop_access_t access;
+    fop_create_t create;
+    fop_ftruncate_t ftruncate;
+    fop_fstat_t fstat;
+    fop_lk_t lk;
+    fop_lookup_t lookup;
+    fop_readdir_t readdir;
+    fop_inodelk_t inodelk;
+    fop_finodelk_t finodelk;
+    fop_entrylk_t entrylk;
+    fop_fentrylk_t fentrylk;
+    fop_xattrop_t xattrop;
+    fop_fxattrop_t fxattrop;
+    fop_fgetxattr_t fgetxattr;
+    fop_fsetxattr_t fsetxattr;
+    fop_rchecksum_t rchecksum;
+    fop_setattr_t setattr;
+    fop_fsetattr_t fsetattr;
+    fop_readdirp_t readdirp;
+
+    /* These 3 are required to keep the index same as GF_FOP_##FOP */
+    void *forget_placeholder;
+    void *release_placeholder;
+    void *releasedir_placeholder;
+
+    fop_getspec_t getspec;
+    fop_fremovexattr_t fremovexattr;
+    fop_fallocate_t fallocate;
+    fop_discard_t discard;
+    fop_zerofill_t zerofill;
+    fop_ipc_t ipc;
+    fop_seek_t seek;
+    fop_lease_t lease;
+    fop_compound_t compound;
+    fop_getactivelk_t getactivelk;
+    fop_setactivelk_t setactivelk;
+    fop_put_t put;
+    fop_icreate_t icreate;
+    fop_namelink_t namelink;
+    fop_copy_file_range_t copy_file_range;
+
+    /* these entries are used for a typechecking hack in STACK_WIND _only_ */
+    /* make sure to add _cbk variables only after defining regular fops as
+       its relative position is used to get the index */
+    fop_stat_cbk_t stat_cbk;
+    fop_readlink_cbk_t readlink_cbk;
+    fop_mknod_cbk_t mknod_cbk;
+    fop_mkdir_cbk_t mkdir_cbk;
+    fop_unlink_cbk_t unlink_cbk;
+    fop_rmdir_cbk_t rmdir_cbk;
+    fop_symlink_cbk_t symlink_cbk;
+    fop_rename_cbk_t rename_cbk;
+    fop_link_cbk_t link_cbk;
+    fop_truncate_cbk_t truncate_cbk;
+    fop_open_cbk_t open_cbk;
+    fop_readv_cbk_t readv_cbk;
+    fop_writev_cbk_t writev_cbk;
+    fop_statfs_cbk_t statfs_cbk;
+    fop_flush_cbk_t flush_cbk;
+    fop_fsync_cbk_t fsync_cbk;
+    fop_setxattr_cbk_t setxattr_cbk;
+    fop_getxattr_cbk_t getxattr_cbk;
+    fop_removexattr_cbk_t removexattr_cbk;
+    fop_opendir_cbk_t opendir_cbk;
+    fop_fsyncdir_cbk_t fsyncdir_cbk;
+    fop_access_cbk_t access_cbk;
+    fop_create_cbk_t create_cbk;
+    fop_ftruncate_cbk_t ftruncate_cbk;
+    fop_fstat_cbk_t fstat_cbk;
+    fop_lk_cbk_t lk_cbk;
+    fop_lookup_cbk_t lookup_cbk;
+    fop_readdir_cbk_t readdir_cbk;
+    fop_inodelk_cbk_t inodelk_cbk;
+    fop_finodelk_cbk_t finodelk_cbk;
+    fop_entrylk_cbk_t entrylk_cbk;
+    fop_fentrylk_cbk_t fentrylk_cbk;
+    fop_xattrop_cbk_t xattrop_cbk;
+    fop_fxattrop_cbk_t fxattrop_cbk;
+    fop_fgetxattr_cbk_t fgetxattr_cbk;
+    fop_fsetxattr_cbk_t fsetxattr_cbk;
+    fop_rchecksum_cbk_t rchecksum_cbk;
+    fop_setattr_cbk_t setattr_cbk;
+    fop_fsetattr_cbk_t fsetattr_cbk;
+    fop_readdirp_cbk_t readdirp_cbk;
+
+    /* These 3 are required to keep the index same as GF_FOP_##FOP */
+    void *forget_placeholder_cbk;
+    void *release_placeholder_cbk;
+    void *releasedir_placeholder_cbk;
+
+    fop_getspec_cbk_t getspec_cbk;
+    fop_fremovexattr_cbk_t fremovexattr_cbk;
+    fop_fallocate_cbk_t fallocate_cbk;
+    fop_discard_cbk_t discard_cbk;
+    fop_zerofill_cbk_t zerofill_cbk;
+    fop_ipc_cbk_t ipc_cbk;
+    fop_seek_cbk_t seek_cbk;
+    fop_lease_cbk_t lease_cbk;
+    fop_compound_cbk_t compound_cbk;
+    fop_getactivelk_cbk_t getactivelk_cbk;
+    fop_setactivelk_cbk_t setactivelk_cbk;
+    fop_put_cbk_t put_cbk;
+    fop_icreate_cbk_t icreate_cbk;
+    fop_namelink_cbk_t namelink_cbk;
+    fop_copy_file_range_cbk_t copy_file_range_cbk;
+};
+
+typedef int32_t (*cbk_forget_t)(xlator_t *this, inode_t *inode);
+
+typedef int32_t (*cbk_release_t)(xlator_t *this, fd_t *fd);
+
+typedef int32_t (*cbk_invalidate_t)(xlator_t *this, inode_t *inode);
+
+typedef int32_t (*cbk_client_t)(xlator_t *this, client_t *client);
+
+typedef void (*cbk_ictxmerge_t)(xlator_t *this, fd_t *fd, inode_t *inode,
+                                inode_t *linked_inode);
+
+typedef size_t (*cbk_inodectx_size_t)(xlator_t *this, inode_t *inode);
+
+typedef size_t (*cbk_fdctx_size_t)(xlator_t *this, fd_t *fd);
+
+typedef void (*cbk_fdclose_t)(xlator_t *this, fd_t *fd);
+
+struct xlator_cbks {
+    cbk_forget_t forget;
+    cbk_release_t release;
+    cbk_release_t releasedir;
+    cbk_invalidate_t invalidate;
+    cbk_client_t client_destroy;
+    cbk_client_t client_disconnect;
+    cbk_ictxmerge_t ictxmerge;
+    cbk_inodectx_size_t ictxsize;
+    cbk_fdctx_size_t fdctxsize;
+    cbk_fdclose_t fdclose;
+    cbk_fdclose_t fdclosedir;
+};
+
+typedef int32_t (*dumpop_priv_t)(xlator_t *this);
+
+typedef int32_t (*dumpop_inode_t)(xlator_t *this);
+
+typedef int32_t (*dumpop_fd_t)(xlator_t *this);
+
+typedef int32_t (*dumpop_inodectx_t)(xlator_t *this, inode_t *ino);
+
+typedef int32_t (*dumpop_fdctx_t)(xlator_t *this, fd_t *fd);
+
+typedef int32_t (*dumpop_priv_to_dict_t)(xlator_t *this, dict_t *dict,
+                                         char *brickname);
+
+typedef int32_t (*dumpop_inode_to_dict_t)(xlator_t *this, dict_t *dict);
+
+typedef int32_t (*dumpop_fd_to_dict_t)(xlator_t *this, dict_t *dict);
+
+typedef int32_t (*dumpop_inodectx_to_dict_t)(xlator_t *this, inode_t *ino,
+                                             dict_t *dict);
+
+typedef int32_t (*dumpop_fdctx_to_dict_t)(xlator_t *this, fd_t *fd,
+                                          dict_t *dict);
+
+typedef int32_t (*dumpop_eh_t)(xlator_t *this);
+
+struct xlator_dumpops {
+    dumpop_priv_t priv;
+    dumpop_inode_t inode;
+    dumpop_fd_t fd;
+    dumpop_inodectx_t inodectx;
+    dumpop_fdctx_t fdctx;
+    dumpop_priv_to_dict_t priv_to_dict;
+    dumpop_inode_to_dict_t inode_to_dict;
+    dumpop_fd_to_dict_t fd_to_dict;
+    dumpop_inodectx_to_dict_t inodectx_to_dict;
+    dumpop_fdctx_to_dict_t fdctx_to_dict;
+    dumpop_eh_t history;
+};
+
+typedef struct xlator_list {
+    xlator_t *xlator;
+    struct xlator_list *next;
+} xlator_list_t;
+
+typedef struct fop_metrics {
+    gf_atomic_t fop;
+    gf_atomic_t cbk; /* only updaed when there is failure */
+} fop_metrics_t;
+
+struct _xlator {
+    /* Built during parsing */
+    char *name;
+    char *type;
+    char *instance_name; /* Used for multi NFSd */
+    xlator_t *next;
+    xlator_t *prev;
+    xlator_list_t *parents;
+    xlator_list_t *children;
+    dict_t *options;
+
+    /* Set after doing dlopen() */
+    void *dlhandle;
+    struct xlator_fops *fops;
+    struct xlator_cbks *cbks;
+    struct xlator_dumpops *dumpops;
+    struct list_head volume_options; /* list of volume_option_t */
+
+    void (*fini)(xlator_t *this);
+    int32_t (*init)(xlator_t *this);
+    int32_t (*reconfigure)(xlator_t *this, dict_t *options);
+    int32_t (*mem_acct_init)(xlator_t *this);
+    int32_t (*dump_metrics)(xlator_t *this, int fd);
+
+    event_notify_fn_t notify;
+
+    gf_loglevel_t loglevel; /* Log level for translator */
+
+    struct {
+        struct {
+            /* for latency measurement */
+            fop_metrics_t metrics[GF_FOP_MAXVALUE];
+
+            gf_atomic_t count;
+        } total;
+
+        struct {
+            /* for latency measurement */
+            gf_latency_t latencies[GF_FOP_MAXVALUE];
+            /* for latency measurement */
+            fop_metrics_t metrics[GF_FOP_MAXVALUE];
+
+            gf_atomic_t count;
+        } interval;
+    } stats;
+
+    /* Misc */
+    eh_t *history; /* event history context */
+    glusterfs_ctx_t *ctx;
+    glusterfs_graph_t *graph; /* not set for fuse */
+    inode_table_t *itable;
+    char init_succeeded;
+    void *private;
+    struct mem_acct *mem_acct;
+    uint64_t winds;
+    char switched;
+
+    /* for the memory pool of 'frame->local' */
+    struct mem_pool *local_pool;
+    gf_boolean_t is_autoloaded;
+
+    /* Saved volfile ID (used for multiplexing) */
+    char *volfile_id;
+
+    /* Its used as an index to inode_ctx*/
+    uint32_t xl_id;
+
+    /* op_version: initialized in xlator code itself */
+    uint32_t op_version[GF_MAX_RELEASES];
+
+    /* flags: initialized in xlator code itself */
+    uint32_t flags;
+
+    /* id: unique, initialized in xlator code itself */
+    uint32_t id;
+
+    /* identifier: a full string which can unique identify the xlator */
+    char *identifier;
+
+    /* Is this pass_through? */
+    gf_boolean_t pass_through;
+    struct xlator_fops *pass_through_fops;
+
+    /* cleanup flag to avoid races during xlator cleanup */
+    uint32_t cleanup_starting;
+
+    /* flag to avoid recall of xlator_mem_cleanup for xame xlator */
+    uint32_t call_cleanup;
+
+    /* Flag to understand how this xlator is categorized */
+    gf_category_t category;
+
+    /* Variable to save xprt associated for detach brick */
+    gf_atomic_t xprtrefcnt;
+
+    /* Flag to notify got CHILD_DOWN event for detach brick */
+    uint32_t notify_down;
+
+    /* Flag to avoid throw duplicate PARENT_DOWN event */
+    uint32_t parent_down;
+};
+
+/* This would be the only structure which needs to be exported by
+   the translators. For the backward compatibility, in 4.x series
+   even the old exported fields will be supported */
+/* XXX: This struct is in use by GD2, and hence SHOULD NOT be modified.
+ * If the struct must be modified, see instructions at the comment with
+ * GD2MARKER below.
+ */
+typedef struct {
+    /* op_version: will be used by volume generation logic to figure
+       out whether to insert it in graph or no, based on cluster's
+       operating version.
+       default value: 0, which means good to insert always */
+    uint32_t op_version[GF_MAX_RELEASES];
+
+    /* flags: will be used by volume generation logic to optimize the
+       placements etc.
+       default value: 0, which means don't treat it specially */
+    uint32_t flags;
+
+    /* xlator_id: unique per xlator. make sure to have no collission
+       in this ID */
+    uint32_t xlator_id;
+
+    /* identifier: a string constant */
+    char *identifier;
+
+    /* struct options: if the translator takes any 'options' from the
+       volume file, then that should be defined here. optional. */
+    volume_option_t *options;
+
+    /* Flag to understand how this xlator is categorized */
+    gf_category_t category;
+
+    /* XXX: GD2MARKER
+     * If a new member that needs to be visible to GD2 is introduced,
+     * add it above this comment.
+     * Any other new members need to be added below this comment, or at the
+     * end of the struct
+     */
+
+    /* init(): mandatory method, will be called during the
+       graph initialization */
+    int32_t (*init)(xlator_t *this);
+
+    /* fini(): optional method, will be initialized to default
+       method which would just free the 'xlator->private' variable.
+       This method is called when the graph is no more in use, and
+       is being destroyed. Also when SIGTERM is received */
+    void (*fini)(xlator_t *this);
+
+    /* reconfigure(): optional method, will be initialized to default
+       method in case not provided by xlator. This method is called
+       when there are only option changes in xlator, and no graph change.
+       eg., a 'gluster volume set' command */
+    int32_t (*reconfigure)(xlator_t *this, dict_t *options);
+
+    /* mem_acct_init(): used for memory accounting inside of the xlator.
+       optional. called during translator initialization */
+    int32_t (*mem_acct_init)(xlator_t *this);
+
+    /* dump_metrics(): used for providing internal metrics. optional */
+    int32_t (*dump_metrics)(xlator_t *this, int fd);
+
+    /* notify(): used for handling the notification of events from either
+       the parent or child in the graph. optional. */
+    event_notify_fn_t notify;
+
+    /* struct fops: mandatory. provides all the filesystem operations
+       methods of the xlator */
+    struct xlator_fops *fops;
+    /* struct cbks: optional. provides methods to handle
+       inode forgets, and fd releases */
+    struct xlator_cbks *cbks;
+
+    /* dumpops: a structure again, with methods to dump the details.
+       optional. */
+    struct xlator_dumpops *dumpops;
+
+    /* struct pass_through_fops: optional. provides all the filesystem
+       operations which should be used if the xlator is marked as pass_through
+     */
+    /* by default, the default_fops would be used */
+    struct xlator_fops *pass_through_fops;
+} xlator_api_t;
+
+#define xlator_has_parent(xl) (xl->parents != NULL)
+
+#define XLATOR_NOTIFY(ret, _xl, params...)                                     \
+    do {                                                                       \
+        xlator_t *_old_THIS = NULL;                                            \
+                                                                               \
+        _old_THIS = THIS;                                                      \
+        THIS = _xl;                                                            \
+                                                                               \
+        ret = _xl->notify(_xl, params);                                        \
+                                                                               \
+        THIS = _old_THIS;                                                      \
+    } while (0);
+
+int32_t
+xlator_set_type_virtual(xlator_t *xl, const char *type);
+
+int32_t
+xlator_set_type(xlator_t *xl, const char *type);
+
+int32_t
+xlator_dynload(xlator_t *xl);
+
+xlator_t *
+file_to_xlator_tree(glusterfs_ctx_t *ctx, FILE *fp);
+
+int
+xlator_notify(xlator_t *this, int32_t event, void *data, ...);
+int
+xlator_init(xlator_t *this);
+int
+xlator_destroy(xlator_t *xl);
+
+int32_t
+xlator_tree_init(xlator_t *xl);
+int32_t
+xlator_tree_free_members(xlator_t *xl);
+int32_t
+xlator_tree_free_memacct(xlator_t *xl);
+
+void
+xlator_tree_fini(xlator_t *xl);
+
+void
+xlator_foreach(xlator_t *this, void (*fn)(xlator_t *each, void *data),
+               void *data);
+
+void
+xlator_foreach_depth_first(xlator_t *this,
+                           void (*fn)(xlator_t *each, void *data), void *data);
+
+xlator_t *
+xlator_search_by_name(xlator_t *any, const char *name);
+xlator_t *
+get_xlator_by_name(xlator_t *this, char *target);
+xlator_t *
+get_xlator_by_type(xlator_t *this, char *target);
+
+void
+xlator_set_inode_lru_limit(xlator_t *this, void *data);
+
+void
+inode_destroy_notify(inode_t *inode, const char *xlname);
+
+int
+loc_copy(loc_t *dst, loc_t *src);
+int
+loc_copy_overload_parent(loc_t *dst, loc_t *src, inode_t *parent);
+#define loc_dup(src, dst) loc_copy(dst, src)
+void
+loc_wipe(loc_t *loc);
+int
+loc_path(loc_t *loc, const char *bname);
+void
+loc_gfid(loc_t *loc, uuid_t gfid);
+void
+loc_pargfid(loc_t *loc, uuid_t pargfid);
+char *
+loc_gfid_utoa(loc_t *loc);
+gf_boolean_t
+loc_is_root(loc_t *loc);
+int32_t
+loc_build_child(loc_t *child, loc_t *parent, char *name);
+gf_boolean_t
+loc_is_nameless(loc_t *loc);
+int
+xlator_mem_acct_init(xlator_t *xl, int num_types);
+void
+xlator_mem_acct_unref(struct mem_acct *mem_acct);
+int
+is_gf_log_command(xlator_t *trans, const char *name, char *value, size_t size);
+int
+glusterd_check_log_level(const char *value);
+int
+xlator_volopt_dynload(char *xlator_type, void **dl_handle,
+                      volume_opt_list_t *vol_opt_handle);
+enum gf_hdsk_event_notify_op {
+    GF_EN_DEFRAG_STATUS,
+    GF_EN_MAX,
+};
+gf_boolean_t
+is_graph_topology_equal(glusterfs_graph_t *graph1, glusterfs_graph_t *graph2);
+int
+glusterfs_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx);
+
+int
+gf_volfile_reconfigure(int oldvollen, FILE *newvolfile_fp, glusterfs_ctx_t *ctx,
+                       const char *oldvolfile);
+
+int
+loc_touchup(loc_t *loc, const char *name);
+
+int
+glusterfs_leaf_position(xlator_t *tgt);
+
+int
+glusterfs_reachable_leaves(xlator_t *base, dict_t *leaves);
+
+int
+xlator_subvolume_count(xlator_t *this);
+
+void
+xlator_init_lock(void);
+void
+xlator_init_unlock(void);
+int
+copy_opts_to_child(xlator_t *src, xlator_t *dst, char *glob);
+
+int
+glusterfs_delete_volfile_checksum(glusterfs_ctx_t *ctx, const char *volfile_id);
+int
+xlator_memrec_free(xlator_t *xl);
+
+void
+xlator_mem_cleanup(xlator_t *this);
+
+void
+handle_default_options(xlator_t *xl, dict_t *options);
+
+void
+gluster_graph_take_reference(xlator_t *tree);
+
+gf_boolean_t
+mgmt_is_multiplexed_daemon(char *name);
+
+gf_boolean_t
+xlator_is_cleanup_starting(xlator_t *this);
+int
+graph_total_client_xlator(glusterfs_graph_t *graph);
+#endif /* _XLATOR_H */
diff --git a/libglusterfs/src/graph-print.c b/libglusterfs/src/graph-print.c
index 676167b17d2..595d74330a1 100644
--- a/libglusterfs/src/graph-print.c
+++ b/libglusterfs/src/graph-print.c
@@ -10,188 +10,126 @@
 
 #include <sys/uio.h>
 
-#include "common-utils.h"
-#include "xlator.h"
-#include "graph-utils.h"
-#include "libglusterfs-messages.h"
-
+#include "glusterfs/common-utils.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/graph-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 struct gf_printer {
-        ssize_t (*write) (struct gf_printer *gp, char *buf, size_t len);
-        void *priv;
-        int  len;
+    ssize_t (*write)(struct gf_printer *gp, char *buf, size_t len);
+    void *priv;
+    int len;
 };
 
 static ssize_t
-gp_write_file (struct gf_printer *gp, char *buf, size_t len)
+gp_write_file(struct gf_printer *gp, char *buf, size_t len)
 {
-        FILE *f = gp->priv;
-
-        if (fwrite (buf, len, 1, f) != 1) {
-                gf_msg ("graph-print", GF_LOG_ERROR, errno,
-                        LG_MSG_FWRITE_FAILED, "fwrite failed");
-
-                return -1;
-        }
+    FILE *f = gp->priv;
 
-        return len;
-}
-
-static ssize_t
-gp_write_buf (struct gf_printer *gp, char *buf, size_t len)
-{
-        struct iovec *iov = gp->priv;
+    if (fwrite(buf, len, 1, f) != 1) {
+        gf_msg("graph-print", GF_LOG_ERROR, errno, LG_MSG_FWRITE_FAILED,
+               "fwrite failed");
 
-        if (iov->iov_len < len) {
-                gf_msg ("graph-print", GF_LOG_ERROR, 0, LG_MSG_BUFFER_FULL,
-                        "buffer full");
-
-                return -1;
-        }
-
-        memcpy (iov->iov_base, buf, len);
-        iov->iov_base += len;
-        iov->iov_len  -= len;
+        return -1;
+    }
 
-        return len;
+    return len;
 }
 
 static int
-gpprintf (struct gf_printer *gp, const char *format, ...)
+gpprintf(struct gf_printer *gp, const char *format, ...)
 {
-        va_list arg;
-        char *str = NULL;
-        int ret = 0;
+    va_list arg;
+    char *str = NULL;
+    int ret = 0;
 
-        va_start (arg, format);
-        ret = gf_vasprintf (&str, format, arg);
-        va_end (arg);
+    va_start(arg, format);
+    ret = gf_vasprintf(&str, format, arg);
+    va_end(arg);
 
-        if (ret < 0)
-                return ret;
+    if (ret < 0)
+        return ret;
 
-        ret = gp->write (gp, str, ret);
+    ret = gp->write(gp, str, ret);
 
-        GF_FREE (str);
+    GF_FREE(str);
 
-        return ret;
+    return ret;
 }
 
-#define GPPRINTF(gp, fmt, ...) do {                             \
-                ret = gpprintf (gp, fmt, ## __VA_ARGS__);       \
-                if (ret == -1)                                  \
-                        goto out;                               \
-                else                                            \
-                        gp->len += ret;                             \
-        } while (0)
+#define GPPRINTF(gp, fmt, ...)                                                 \
+    do {                                                                       \
+        ret = gpprintf(gp, fmt, ##__VA_ARGS__);                                \
+        if (ret == -1)                                                         \
+            goto out;                                                          \
+        else                                                                   \
+            gp->len += ret;                                                    \
+    } while (0)
 
 static int
-_print_volume_options (dict_t *d, char *k, data_t *v,
-                           void *tmp)
+_print_volume_options(dict_t *d, char *k, data_t *v, void *tmp)
 {
-        struct gf_printer *gp  = tmp;
-        int                ret = 0;
-        GPPRINTF (gp, "    option %s %s\n", k, v->data);
-        return 0;
+    struct gf_printer *gp = tmp;
+    int ret = 0;
+    GPPRINTF(gp, "    option %s %s\n", k, v->data);
+    return 0;
 out:
-        /* means, it is a failure */
-        return -1;
+    /* means, it is a failure */
+    return -1;
 }
 
 static int
-glusterfs_graph_print (struct gf_printer *gp, glusterfs_graph_t *graph)
+glusterfs_graph_print(struct gf_printer *gp, glusterfs_graph_t *graph)
 {
-        xlator_t      *trav = NULL;
-        xlator_list_t *xch = NULL;
-        int            ret = 0;
-        ssize_t        len = 0;
-
-        if (!graph->first)
-                return 0;
+    xlator_t *trav = NULL;
+    xlator_list_t *xch = NULL;
+    int ret = 0;
+    ssize_t len = 0;
 
-        for (trav = graph->first; trav->next; trav = trav->next);
-        for (; trav; trav = trav->prev) {
-                GPPRINTF (gp, "volume %s\n    type %s\n", trav->name,
-                          trav->type);
+    if (!graph->first)
+        return 0;
 
-                ret = dict_foreach (trav->options, _print_volume_options, gp);
-                if (ret)
-                        goto out;
+    for (trav = graph->first; trav->next; trav = trav->next)
+        ;
+    for (; trav; trav = trav->prev) {
+        GPPRINTF(gp, "volume %s\n    type %s\n", trav->name, trav->type);
 
-                if (trav->children) {
-                        GPPRINTF (gp, "    subvolumes");
+        ret = dict_foreach(trav->options, _print_volume_options, gp);
+        if (ret)
+            goto out;
 
-                        for (xch = trav->children; xch; xch = xch->next)
-                                GPPRINTF (gp, " %s", xch->xlator->name);
+        if (trav->children) {
+            GPPRINTF(gp, "    subvolumes");
 
-                        GPPRINTF (gp, "\n");
-                }
+            for (xch = trav->children; xch; xch = xch->next)
+                GPPRINTF(gp, " %s", xch->xlator->name);
 
-                GPPRINTF (gp, "end-volume\n");
-                if (trav != graph->first)
-                        GPPRINTF (gp, "\n");
+            GPPRINTF(gp, "\n");
         }
 
+        GPPRINTF(gp, "end-volume\n");
+        if (trav != graph->first)
+            GPPRINTF(gp, "\n");
+    }
+
 out:
-        len = gp->len;
-        if (ret == -1) {
-                gf_msg ("graph-print", GF_LOG_ERROR, 0, LG_MSG_PRINT_FAILED,
-                        "printing failed");
+    len = gp->len;
+    if (ret == -1) {
+        gf_msg("graph-print", GF_LOG_ERROR, 0, LG_MSG_PRINT_FAILED,
+               "printing failed");
 
-                return -1;
-        }
+        return -1;
+    }
 
-        return len;
+    return len;
 
 #undef GPPRINTF
 }
 
 int
-glusterfs_graph_print_file (FILE *file, glusterfs_graph_t *graph)
+glusterfs_graph_print_file(FILE *file, glusterfs_graph_t *graph)
 {
-        struct gf_printer gp = { .write = gp_write_file,
-                                 .priv  = file
-        };
-
-        return glusterfs_graph_print (&gp, graph);
-}
-
-char *
-glusterfs_graph_print_buf (glusterfs_graph_t *graph)
-{
-        FILE *f = NULL;
-        struct iovec iov = {0,};
-        int len = 0;
-        char *buf = NULL;
-        struct gf_printer gp = { .write = gp_write_buf,
-                                 .priv  = &iov
-        };
-
-        f = fopen ("/dev/null", "a");
-        if (!f) {
-                gf_msg ("graph-print", GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "cannot open /dev/null");
-
-                return NULL;
-        }
-        len = glusterfs_graph_print_file (f, graph);
-        fclose (f);
-        if (len == -1)
-                return NULL;
-
-        buf = GF_CALLOC (1, len + 1, gf_common_mt_graph_buf);
-        if (!buf) {
-                return NULL;
-        }
-        iov.iov_base = buf;
-        iov.iov_len  = len;
-
-        len = glusterfs_graph_print (&gp, graph);
-        if (len == -1) {
-                GF_FREE (buf);
-
-                return NULL;
-        }
+    struct gf_printer gp = {.write = gp_write_file, .priv = file};
 
-        return buf;
+    return glusterfs_graph_print(&gp, graph);
 }
diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c
index 738cd9688db..13f298eb3bd 100644
--- a/libglusterfs/src/graph.c
+++ b/libglusterfs/src/graph.c
@@ -8,16 +8,32 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "xlator.h"
-#include <dlfcn.h>
-#include <netdb.h>
-#include <fnmatch.h>
-#include <stdlib.h>
-#include "defaults.h"
-#include <unistd.h>
-#include "syscall.h"
-
-#include "libglusterfs-messages.h"
+#include <stdint.h>                  // for uint32_t
+#include <sys/time.h>                // for timeval
+#include <errno.h>                   // for EIO, errno, EINVAL, ENOMEM
+#include <fnmatch.h>                 // for fnmatch, FNM_NOESCAPE
+#include <openssl/sha.h>             // for SHA256_DIGEST_LENGTH
+#include <regex.h>                   // for regmatch_t, regcomp
+#include <stdio.h>                   // for fclose, fopen, snprintf
+#include <stdlib.h>                  // for NULL, atoi, mkstemp
+#include <string.h>                  // for strcmp, strerror, memcpy
+#include <strings.h>                 // for rindex
+#include <sys/stat.h>                // for stat
+#include <sys/time.h>                // for gettimeofday
+#include <unistd.h>                  // for gethostname, getpid
+#include "glusterfs/common-utils.h"  // for gf_strncpy, gf_time_fmt
+#include "glusterfs/defaults.h"
+#include "glusterfs/dict.h"                   // for dict_foreach, dict_set_...
+#include "glusterfs/globals.h"                // for xlator_t, xlator_list_t
+#include "glusterfs/glusterfs.h"              // for glusterfs_graph_t, glus...
+#include "glusterfs/glusterfs-fops.h"         // for GF_EVENT_GRAPH_NEW, GF_...
+#include "glusterfs/libglusterfs-messages.h"  // for LG_MSG_GRAPH_ERROR, LG_...
+#include "glusterfs/list.h"                   // for list_add, list_del_init
+#include "glusterfs/logging.h"                // for gf_msg, GF_LOG_ERROR
+#include "glusterfs/mem-pool.h"               // for GF_FREE, gf_strdup, GF_...
+#include "glusterfs/mem-types.h"              // for gf_common_mt_xlator_list_t
+#include "glusterfs/options.h"                // for xlator_tree_reconfigure
+#include "glusterfs/syscall.h"                // for sys_close, sys_stat
 
 #if 0
 static void
@@ -25,7 +41,7 @@ _gf_dump_details (int argc, char **argv)
 {
         extern FILE *gf_log_logfile;
         int          i = 0;
-        char         timestr[64];
+        char         timestr[GF_TIMESTR_SIZE];
         time_t       utime = 0;
         pid_t        mypid = 0;
         struct utsname uname_buf = {{0, }, };
@@ -68,584 +84,648 @@ _gf_dump_details (int argc, char **argv)
 }
 #endif
 
+int
+glusterfs_read_secure_access_file(void)
+{
+    FILE *fp = NULL;
+    char line[100] = {
+        0,
+    };
+    int cert_depth = 1; /* Default SSL CERT DEPTH */
+    regex_t regcmpl;
+    char *key = {"^option transport.socket.ssl-cert-depth"};
+    char keyval[50] = {
+        0,
+    };
+    int start = 0, end = 0, copy_len = 0;
+    regmatch_t result[1] = {{0}};
+
+    fp = fopen(SECURE_ACCESS_FILE, "r");
+    if (!fp)
+        goto out;
+
+    /* Check if any line matches with key */
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (regcomp(&regcmpl, key, REG_EXTENDED)) {
+            goto out;
+        }
+        if (!regexec(&regcmpl, line, 1, result, 0)) {
+            start = result[0].rm_so;
+            end = result[0].rm_eo;
+            copy_len = end - start;
+            gf_strncpy(keyval, line + copy_len, sizeof(keyval));
+            if (keyval[0]) {
+                cert_depth = atoi(keyval);
+                if (cert_depth == 0)
+                    cert_depth = 1; /* Default SSL CERT DEPTH */
+                break;
+            }
+        }
+        regfree(&regcmpl);
+    }
 
+out:
+    if (fp)
+        fclose(fp);
+    return cert_depth;
+}
 
-int
-glusterfs_xlator_link (xlator_t *pxl, xlator_t *cxl)
+xlator_t *
+glusterfs_get_last_xlator(glusterfs_graph_t *graph)
 {
-        xlator_list_t   *xlchild = NULL;
-        xlator_list_t   *xlparent = NULL;
-        xlator_list_t  **tmp = NULL;
+    xlator_t *trav = graph->first;
+    if (!trav)
+        return NULL;
 
-        xlparent = (void *) GF_CALLOC (1, sizeof (*xlparent),
-                                       gf_common_mt_xlator_list_t);
-        if (!xlparent)
-                return -1;
+    while (trav->next)
+        trav = trav->next;
 
-        xlchild = (void *) GF_CALLOC (1, sizeof (*xlchild),
-                                      gf_common_mt_xlator_list_t);
-        if (!xlchild) {
-                GF_FREE (xlparent);
+    return trav;
+}
 
-                return -1;
+xlator_t *
+glusterfs_mux_xlator_unlink(xlator_t *pxl, xlator_t *cxl)
+{
+    xlator_list_t *unlink = NULL;
+    xlator_list_t *prev = NULL;
+    xlator_list_t **tmp = NULL;
+    xlator_t *next_child = NULL;
+    xlator_t *xl = NULL;
+
+    for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next) {
+        if ((*tmp)->xlator == cxl) {
+            unlink = *tmp;
+            *tmp = (*tmp)->next;
+            if (*tmp)
+                next_child = (*tmp)->xlator;
+            break;
         }
+        prev = *tmp;
+    }
 
-        xlparent->xlator = pxl;
-        for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next);
-        *tmp = xlparent;
+    if (!prev)
+        xl = pxl;
+    else if (prev->xlator)
+        xl = prev->xlator->graph->last_xl;
 
-        xlchild->xlator = cxl;
-        for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next);
-        *tmp = xlchild;
+    if (xl)
+        xl->next = next_child;
+    if (next_child)
+        next_child->prev = xl;
 
-        return 0;
+    GF_FREE(unlink);
+    return next_child;
 }
 
+int
+glusterfs_xlator_link(xlator_t *pxl, xlator_t *cxl)
+{
+    xlator_list_t *xlchild = NULL;
+    xlator_list_t *xlparent = NULL;
+    xlator_list_t **tmp = NULL;
+
+    xlparent = (void *)GF_CALLOC(1, sizeof(*xlparent),
+                                 gf_common_mt_xlator_list_t);
+    if (!xlparent)
+        return -1;
+
+    xlchild = (void *)GF_CALLOC(1, sizeof(*xlchild),
+                                gf_common_mt_xlator_list_t);
+    if (!xlchild) {
+        GF_FREE(xlparent);
+
+        return -1;
+    }
+
+    xlparent->xlator = pxl;
+    for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next)
+        ;
+    *tmp = xlparent;
+
+    xlchild->xlator = cxl;
+    for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next)
+        ;
+    *tmp = xlchild;
+
+    return 0;
+}
 
 void
-glusterfs_graph_set_first (glusterfs_graph_t *graph, xlator_t *xl)
+glusterfs_graph_set_first(glusterfs_graph_t *graph, xlator_t *xl)
 {
-        xl->next = graph->first;
-        if (graph->first)
-                ((xlator_t *)graph->first)->prev = xl;
-        graph->first = xl;
+    xl->next = graph->first;
+    if (graph->first)
+        ((xlator_t *)graph->first)->prev = xl;
+    graph->first = xl;
 
-        graph->xl_count++;
-        xl->xl_id = graph->xl_count;
+    graph->xl_count++;
+    xl->xl_id = graph->xl_count;
 }
 
-
 int
-glusterfs_graph_insert (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
-                        const char *type, const char *name,
-                        gf_boolean_t autoload)
+glusterfs_graph_insert(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+                       const char *type, const char *name,
+                       gf_boolean_t autoload)
 {
-        xlator_t        *ixl = NULL;
+    xlator_t *ixl = NULL;
 
-        if (!ctx->master) {
-                gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
-                        "volume \"%s\" can be added from command line only "
-                        "on client side", type);
+    if (!ctx->master) {
+        gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
+               "volume \"%s\" can be added from command line only "
+               "on client side",
+               type);
 
-                return -1;
-        }
+        return -1;
+    }
 
-        ixl = GF_CALLOC (1, sizeof (*ixl), gf_common_mt_xlator_t);
-        if (!ixl)
-                return -1;
+    ixl = GF_CALLOC(1, sizeof(*ixl), gf_common_mt_xlator_t);
+    if (!ixl)
+        return -1;
 
-        ixl->ctx      = ctx;
-        ixl->graph    = graph;
-        ixl->options  = get_new_dict ();
-        if (!ixl->options)
-                goto err;
+    ixl->ctx = ctx;
+    ixl->graph = graph;
+    ixl->options = dict_new();
+    if (!ixl->options)
+        goto err;
 
-        ixl->name  = gf_strdup (name);
-        if (!ixl->name)
-                goto err;
+    ixl->name = gf_strdup(name);
+    if (!ixl->name)
+        goto err;
 
-        ixl->is_autoloaded = autoload;
+    ixl->is_autoloaded = autoload;
 
-        if (xlator_set_type (ixl, type) == -1) {
-                gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
-                        "%s (%s) initialization failed",
-                        name, type);
-                return -1;
-        }
+    if (xlator_set_type(ixl, type) == -1) {
+        gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
+               "%s (%s) initialization failed", name, type);
+        return -1;
+    }
 
-        if (glusterfs_xlator_link (ixl, graph->top) == -1)
-                goto err;
-        glusterfs_graph_set_first (graph, ixl);
-        graph->top = ixl;
+    if (glusterfs_xlator_link(ixl, graph->top) == -1)
+        goto err;
+    glusterfs_graph_set_first(graph, ixl);
+    graph->top = ixl;
 
-        return 0;
+    return 0;
 err:
-        xlator_destroy (ixl);
-        return -1;
+    xlator_destroy(ixl);
+    return -1;
 }
 
 int
-glusterfs_graph_acl (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_acl(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->acl)
-                return 0;
+    if (!cmd_args->acl)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "system/posix-acl",
-                                      "posix-acl-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "system/posix-acl",
+                                 "posix-acl-autoload", 1);
+    return ret;
 }
 
 int
-glusterfs_graph_worm (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_worm(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->worm)
-                return 0;
+    if (!cmd_args->worm)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/worm",
-                                      "worm-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "features/worm", "worm-autoload",
+                                 1);
+    return ret;
 }
 
-
 int
-glusterfs_graph_meta (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_meta(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
+    int ret = 0;
 
-	if (!ctx->master)
-		return 0;
+    if (!ctx->master)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "meta",
-                                      "meta-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "meta", "meta-autoload", 1);
+    return ret;
 }
 
-
 int
-glusterfs_graph_mac_compat (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_mac_compat(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->mac_compat == GF_OPTION_DISABLE)
-                return 0;
+    if (cmd_args->mac_compat == GF_OPTION_DISABLE)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/mac-compat",
-                                      "mac-compat-autoload", 1);
+    ret = glusterfs_graph_insert(graph, ctx, "features/mac-compat",
+                                 "mac-compat-autoload", 1);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_graph_gfid_access (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_gfid_access(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->aux_gfid_mount)
-                return 0;
+    if (!cmd_args->aux_gfid_mount)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/gfid-access",
-                                      "gfid-access-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "features/gfid-access",
+                                 "gfid-access-autoload", 1);
+    return ret;
 }
 
 static void
-gf_add_cmdline_options (glusterfs_graph_t *graph, cmd_args_t *cmd_args)
+gf_add_cmdline_options(glusterfs_graph_t *graph, cmd_args_t *cmd_args)
 {
-        int                      ret = 0;
-        xlator_t                *trav = NULL;
-        xlator_cmdline_option_t *cmd_option = NULL;
-
-        trav = graph->first;
-
-        while (trav) {
-                list_for_each_entry (cmd_option,
-                                     &cmd_args->xlator_options, cmd_args) {
-                        if (!fnmatch (cmd_option->volume,
-                                      trav->name, FNM_NOESCAPE)) {
-                                ret = dict_set_str (trav->options,
-                                                    cmd_option->key,
-                                                    cmd_option->value);
-                                if (ret == 0) {
-                                        gf_msg (trav->name, GF_LOG_TRACE, 0,
-                                                LG_MSG_VOL_OPTION_ADD,
-                                                "adding option '%s' for "
-                                                "volume '%s' with value '%s'",
-                                                cmd_option->key, trav->name,
-                                                cmd_option->value);
-                                } else {
-                                        gf_msg (trav->name, GF_LOG_WARNING,
-                                                -ret, LG_MSG_VOL_OPTION_ADD,
-                                                "adding option '%s' for "
-                                                "volume '%s' failed",
-                                                cmd_option->key, trav->name);
-                                }
-                        }
+    int ret = 0;
+    xlator_t *trav = NULL;
+    xlator_cmdline_option_t *cmd_option = NULL;
+
+    trav = graph->first;
+
+    while (trav) {
+        list_for_each_entry(cmd_option, &cmd_args->xlator_options, cmd_args)
+        {
+            if (!fnmatch(cmd_option->volume, trav->name, FNM_NOESCAPE)) {
+                ret = dict_set_str(trav->options, cmd_option->key,
+                                   cmd_option->value);
+                if (ret == 0) {
+                    gf_msg(trav->name, GF_LOG_TRACE, 0, LG_MSG_VOL_OPTION_ADD,
+                           "adding option '%s' for "
+                           "volume '%s' with value '%s'",
+                           cmd_option->key, trav->name, cmd_option->value);
+                } else {
+                    gf_msg(trav->name, GF_LOG_WARNING, -ret,
+                           LG_MSG_VOL_OPTION_ADD,
+                           "adding option '%s' for "
+                           "volume '%s' failed",
+                           cmd_option->key, trav->name);
                 }
-                trav = trav->next;
+            }
         }
+        trav = trav->next;
+    }
 }
 
-
 int
-glusterfs_graph_validate_options (glusterfs_graph_t *graph)
+glusterfs_graph_validate_options(glusterfs_graph_t *graph)
 {
-        xlator_t           *trav = NULL;
-        int                 ret = -1;
-        char               *errstr = NULL;
+    xlator_t *trav = NULL;
+    int ret = -1;
+    char *errstr = NULL;
 
-        trav = graph->first;
+    trav = graph->first;
 
-        while (trav) {
-                if (list_empty (&trav->volume_options)) {
-                        trav = trav->next;
-                        continue;
-                }
+    while (trav) {
+        if (list_empty(&trav->volume_options)) {
+            trav = trav->next;
+            continue;
+        }
 
-                ret = xlator_options_validate (trav, trav->options, &errstr);
-                if (ret) {
-                        gf_msg (trav->name, GF_LOG_ERROR, 0,
-                                LG_MSG_VALIDATION_FAILED, "validation failed: "
-                                "%s", errstr);
-                        return ret;
-                }
-                trav = trav->next;
+        ret = xlator_options_validate(trav, trav->options, &errstr);
+        if (ret) {
+            gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
+                   "validation failed: "
+                   "%s",
+                   errstr);
+            return ret;
         }
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-glusterfs_graph_init (glusterfs_graph_t *graph)
+glusterfs_graph_init(glusterfs_graph_t *graph)
 {
-        xlator_t           *trav = NULL;
-        int                 ret = -1;
-
-        trav = graph->first;
-
-        while (trav) {
-                ret = xlator_init (trav);
-                if (ret) {
-                        gf_msg (trav->name, GF_LOG_ERROR, 0,
-                                LG_MSG_TRANSLATOR_INIT_FAILED,
-                                "initializing translator failed");
-                        return ret;
-                }
-                trav = trav->next;
+    xlator_t *trav = NULL;
+    int ret = -1;
+
+    trav = graph->first;
+
+    while (trav) {
+        ret = xlator_init(trav);
+        if (ret) {
+            gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_TRANSLATOR_INIT_FAILED,
+                   "initializing translator failed");
+            return ret;
         }
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_graph_deactivate (glusterfs_graph_t *graph)
+glusterfs_graph_deactivate(glusterfs_graph_t *graph)
 {
-        xlator_t           *top = NULL;
+    xlator_t *top = NULL;
 
-        if (graph == NULL)
-                goto out;
+    if (graph == NULL)
+        goto out;
 
-        top = graph->top;
-        xlator_tree_fini (top);
- out:
-        return 0;
+    top = graph->top;
+    xlator_tree_fini(top);
+out:
+    return 0;
 }
 
 static int
-_log_if_unknown_option (dict_t *dict, char *key, data_t *value, void *data)
+_log_if_unknown_option(dict_t *dict, char *key, data_t *value, void *data)
 {
-        volume_option_t   *found = NULL;
-        xlator_t          *xl = NULL;
+    volume_option_t *found = NULL;
+    xlator_t *xl = NULL;
 
-        xl = data;
+    xl = data;
 
-        found = xlator_volume_option_get (xl, key);
+    found = xlator_volume_option_get(xl, key);
 
-        if (!found) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_XLATOR_OPTION_INVALID,
-                        "option '%s' is not recognized", key);
-        }
+    if (!found) {
+        gf_msg(xl->name, GF_LOG_DEBUG, 0, LG_MSG_XLATOR_OPTION_INVALID,
+               "option '%s' is not recognized", key);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static void
-_xlator_check_unknown_options (xlator_t *xl, void *data)
+_xlator_check_unknown_options(xlator_t *xl, void *data)
 {
-        dict_foreach (xl->options, _log_if_unknown_option, xl);
+    dict_foreach(xl->options, _log_if_unknown_option, xl);
 }
 
-
-int
-glusterfs_graph_unknown_options (glusterfs_graph_t *graph)
+static int
+glusterfs_graph_unknown_options(glusterfs_graph_t *graph)
 {
-        xlator_foreach (graph->first, _xlator_check_unknown_options, NULL);
-        return 0;
+    xlator_foreach(graph->first, _xlator_check_unknown_options, NULL);
+    return 0;
 }
 
-
-void
-fill_uuid (char *uuid, int size)
+static void
+fill_uuid(char *uuid, int size, struct timeval tv)
 {
-        char           hostname[256] = {0,};
-        struct timeval tv = {0,};
-        char           now_str[64];
-
-        if (gettimeofday (&tv, NULL) == -1) {
-                gf_msg ("graph", GF_LOG_ERROR, errno,
-                        LG_MSG_GETTIMEOFDAY_FAILED, "gettimeofday: "
-                        "failed");
-        }
+    char hostname[50] = {
+        0,
+    };
+    char now_str[GF_TIMESTR_SIZE];
 
-        if (gethostname (hostname, 256) == -1) {
-                gf_msg ("graph", GF_LOG_ERROR, errno,
-                        LG_MSG_GETHOSTNAME_FAILED, "gethostname: "
-                        "failed");
-        }
+    if (gethostname(hostname, sizeof(hostname) - 1) != 0) {
+        gf_msg("graph", GF_LOG_ERROR, errno, LG_MSG_GETHOSTNAME_FAILED,
+               "gethostname failed");
+        hostname[sizeof(hostname) - 1] = '\0';
+    }
 
-        gf_time_fmt (now_str, sizeof now_str, tv.tv_sec, gf_timefmt_dirent);
-        snprintf (uuid, size, "%s-%d-%s:%"GF_PRI_SUSECONDS,
-                  hostname, getpid(), now_str, tv.tv_usec);
+    gf_time_fmt_tv(now_str, sizeof now_str, &tv, gf_timefmt_dirent);
+    snprintf(uuid, size, "%s-%d-%s", hostname, getpid(), now_str);
 
-        return;
+    return;
 }
 
-
 static int
-glusterfs_graph_settop (glusterfs_graph_t *graph, char *volume_name,
-                        gf_boolean_t exact_match)
+glusterfs_graph_settop(glusterfs_graph_t *graph, char *volume_name,
+                       gf_boolean_t exact_match)
 {
-        int         ret  = -1;
-        xlator_t   *trav = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
 
-        if (!volume_name || !exact_match) {
-                graph->top = graph->first;
+    if (!volume_name || !exact_match) {
+        graph->top = graph->first;
+        ret = 0;
+    } else {
+        for (trav = graph->first; trav; trav = trav->next) {
+            if (strcmp(trav->name, volume_name) == 0) {
+                graph->top = trav;
                 ret = 0;
-        } else {
-                for (trav = graph->first; trav; trav = trav->next) {
-                        if (strcmp (trav->name, volume_name) == 0) {
-                                graph->top = trav;
-                                ret = 0;
-                                break;
-                        }
-                }
+                break;
+            }
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_parent_up (glusterfs_graph_t *graph)
+glusterfs_graph_parent_up(glusterfs_graph_t *graph)
 {
-        xlator_t *trav = NULL;
-        int       ret = -1;
+    xlator_t *trav = NULL;
+    int ret = -1;
 
-        trav = graph->first;
+    trav = graph->first;
 
-        while (trav) {
-                if (!xlator_has_parent (trav)) {
-                        ret = xlator_notify (trav, GF_EVENT_PARENT_UP, trav);
-                }
+    while (trav) {
+        if (!xlator_has_parent(trav)) {
+            ret = xlator_notify(trav, GF_EVENT_PARENT_UP, trav);
+        }
 
-                if (ret)
-                        break;
+        if (ret)
+            break;
 
-                trav = trav->next;
-        }
+        trav = trav->next;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
-                         char *volume_name)
+glusterfs_graph_prepare(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+                        char *volume_name)
 {
-        xlator_t    *trav = NULL;
-        int          ret = 0;
-
-        /* XXX: CHECKSUM */
-
-        /* XXX: attach to -n volname */
-        /* A '/' in the volume name suggests brick multiplexing is used, find
-         * the top of the (sub)graph. The volname MUST match the subvol in this
-         * case. In other cases (like for gfapi) the default top for the
-         * (sub)graph is ok. */
-        if (!volume_name) {
-                /* GlusterD does not pass a volume_name */
-                ret = glusterfs_graph_settop (graph, volume_name, _gf_false);
-        } else if (strncmp (volume_name, "/snaps/", 7) == 0) {
-                /* snap shots have their top xlator named like "/snaps/..."  */
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_false);
-        } else if (volume_name[0] == '/') {
-                /* brick multiplexing passes the brick path */
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_true);
-        } else {
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_false);
-        }
-        if (!ret) {
-                goto ok;
-        }
-
-        gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                "glusterfs graph settop failed");
+    xlator_t *trav = NULL;
+    int ret = 0;
+
+    /* XXX: CHECKSUM */
+
+    /* XXX: attach to -n volname */
+    /* A '/' in the volume name suggests brick multiplexing is used, find
+     * the top of the (sub)graph. The volname MUST match the subvol in this
+     * case. In other cases (like for gfapi) the default top for the
+     * (sub)graph is ok. */
+    if (!volume_name) {
+        /* GlusterD does not pass a volume_name */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    } else if (strncmp(volume_name, "/snaps/", 7) == 0) {
+        /* snap shots have their top xlator named like "/snaps/..."  */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    } else if (volume_name[0] == '/') {
+        /* brick multiplexing passes the brick path */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_true);
+    } else {
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    }
+
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph settop failed");
+        errno = EINVAL;
         return -1;
-ok:
+    }
 
-        /* XXX: WORM VOLUME */
-        ret = glusterfs_graph_worm (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph worm failed");
-                return -1;
-        }
-        ret = glusterfs_graph_acl (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph ACL failed");
-                return -1;
-        }
+    /* XXX: WORM VOLUME */
+    ret = glusterfs_graph_worm(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph worm failed");
+        return -1;
+    }
+    ret = glusterfs_graph_acl(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph ACL failed");
+        return -1;
+    }
 
-        /* XXX: MAC COMPAT */
-        ret = glusterfs_graph_mac_compat (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph mac compat failed");
-                return -1;
-        }
+    /* XXX: MAC COMPAT */
+    ret = glusterfs_graph_mac_compat(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph mac compat failed");
+        return -1;
+    }
 
-        /* XXX: gfid-access */
-        ret = glusterfs_graph_gfid_access (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph 'gfid-access' failed");
-                return -1;
-        }
+    /* XXX: gfid-access */
+    ret = glusterfs_graph_gfid_access(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph 'gfid-access' failed");
+        return -1;
+    }
 
-	/* XXX: topmost xlator */
-	ret = glusterfs_graph_meta (graph, ctx);
-	if (ret) {
-		gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-			"glusterfs graph meta failed");
-		return -1;
-	}
+    /* XXX: topmost xlator */
+    ret = glusterfs_graph_meta(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph meta failed");
+        return -1;
+    }
 
-        /* XXX: this->ctx setting */
-        for (trav = graph->first; trav; trav = trav->next) {
-                trav->ctx = ctx;
-        }
+    /* XXX: this->ctx setting */
+    for (trav = graph->first; trav; trav = trav->next) {
+        trav->ctx = ctx;
+    }
 
-        /* XXX: DOB setting */
-        gettimeofday (&graph->dob, NULL);
+    /* XXX: DOB setting */
+    gettimeofday(&graph->dob, NULL);
 
-        fill_uuid (graph->graph_uuid, 128);
+    fill_uuid(graph->graph_uuid, sizeof(graph->graph_uuid), graph->dob);
 
-        graph->id = ctx->graph_id++;
+    graph->id = ctx->graph_id++;
 
-        /* XXX: --xlator-option additions */
-        gf_add_cmdline_options (graph, &ctx->cmd_args);
+    /* XXX: --xlator-option additions */
+    gf_add_cmdline_options(graph, &ctx->cmd_args);
 
-        return 0;
+    return 0;
 }
 
-static
-xlator_t *glusterfs_root(glusterfs_graph_t *graph)
+static xlator_t *
+glusterfs_root(glusterfs_graph_t *graph)
 {
-        return graph->first;
+    return graph->first;
 }
 
-static
-int glusterfs_is_leaf(xlator_t *xl)
+static int
+glusterfs_is_leaf(xlator_t *xl)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!xl->children)
-                ret = 1;
+    if (!xl->children)
+        ret = 1;
 
-        return ret;
+    return ret;
 }
 
-static
-uint32_t glusterfs_count_leaves(xlator_t *xl)
+static uint32_t
+glusterfs_count_leaves(xlator_t *xl)
 {
-        int n = 0;
-        xlator_list_t *list = NULL;
+    int n = 0;
+    xlator_list_t *list = NULL;
 
-        if (glusterfs_is_leaf(xl))
-                n = 1;
-        else
-                for (list = xl->children; list; list = list->next)
-                        n += glusterfs_count_leaves(list->xlator);
+    if (glusterfs_is_leaf(xl))
+        n = 1;
+    else
+        for (list = xl->children; list; list = list->next)
+            n += glusterfs_count_leaves(list->xlator);
 
-        return n;
+    return n;
 }
 
-int glusterfs_get_leaf_count(glusterfs_graph_t *graph)
+int
+glusterfs_get_leaf_count(glusterfs_graph_t *graph)
 {
-        return graph->leaf_count;
+    return graph->leaf_count;
 }
 
-static
-int _glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl)
+static int
+_glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl)
 {
-        xlator_list_t *list = NULL;
-        int found = 0;
-
-        if (xl == tgt)
-                found = 1;
-        else if (glusterfs_is_leaf(xl))
-                *id += 1;
-        else
-                for (list = xl->children; !found && list; list = list->next)
-                        found = _glusterfs_leaf_position(tgt, id, list->xlator);
-
-        return found;
+    xlator_list_t *list = NULL;
+    int found = 0;
+
+    if (xl == tgt)
+        found = 1;
+    else if (glusterfs_is_leaf(xl))
+        *id += 1;
+    else
+        for (list = xl->children; !found && list; list = list->next)
+            found = _glusterfs_leaf_position(tgt, id, list->xlator);
+
+    return found;
 }
 
-int glusterfs_leaf_position(xlator_t *tgt)
+int
+glusterfs_leaf_position(xlator_t *tgt)
 {
-        xlator_t *root = NULL;
-        int pos = 0;
+    xlator_t *root = NULL;
+    int pos = 0;
 
-        root = glusterfs_root(tgt->graph);
+    root = glusterfs_root(tgt->graph);
 
-        if (!_glusterfs_leaf_position(tgt, &pos, root))
-                pos = -1;
+    if (!_glusterfs_leaf_position(tgt, &pos, root))
+        pos = -1;
 
-        return pos;
+    return pos;
 }
 
 static int
 _glusterfs_reachable_leaves(xlator_t *base, xlator_t *xl, dict_t *leaves)
 {
-        xlator_list_t *list = NULL;
-        int err = 1;
-        int pos = 0;
-        char *strpos = NULL;
+    xlator_list_t *list = NULL;
+    int err = 1;
+    int pos = 0;
+    char *strpos = NULL;
 
-        if (glusterfs_is_leaf(xl)) {
-                pos = glusterfs_leaf_position(xl);
-                if (pos < 0)
-                        goto out;
+    if (glusterfs_is_leaf(xl)) {
+        pos = glusterfs_leaf_position(xl);
+        if (pos < 0)
+            goto out;
 
-                err = gf_asprintf(&strpos, "%d", pos);
+        err = gf_asprintf(&strpos, "%d", pos);
 
-                if (err >= 0) {
-                        err = dict_set_static_ptr(leaves, strpos, base);
-                        GF_FREE (strpos);
-                }
-        } else {
-                for (err = 0, list = xl->children;
-                     !err && list;
-                     list = list->next)
-                        err = _glusterfs_reachable_leaves(base, list->xlator,
-                                                          leaves);
+        if (err >= 0) {
+            err = dict_set_static_ptr(leaves, strpos, base);
+            GF_FREE(strpos);
         }
+    } else {
+        for (err = 0, list = xl->children; !err && list; list = list->next)
+            err = _glusterfs_reachable_leaves(base, list->xlator, leaves);
+    }
 
 out:
-        return err;
+    return err;
 }
 
 /*
@@ -663,230 +743,226 @@ out:
 int
 glusterfs_reachable_leaves(xlator_t *base, dict_t *leaves)
 {
-        xlator_list_t *list = NULL;
-        int err = 0;
+    xlator_list_t *list = NULL;
+    int err = 0;
 
-        for (list = base->children; !err && list; list = list->next)
-                err = _glusterfs_reachable_leaves(list->xlator,
-                                                  list->xlator, leaves);
+    for (list = base->children; !err && list; list = list->next)
+        err = _glusterfs_reachable_leaves(list->xlator, list->xlator, leaves);
 
-        return err;
+    return err;
 }
 
 int
-glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_activate(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        xlator_t *root = NULL;
+    int ret = 0;
+    xlator_t *root = NULL;
 
-        root = glusterfs_root(graph);
+    root = glusterfs_root(graph);
 
-        graph->leaf_count = glusterfs_count_leaves(root);
+    graph->leaf_count = glusterfs_count_leaves(root);
 
-        /* XXX: all xlator options validation */
-        ret = glusterfs_graph_validate_options (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
-                        "validate options failed");
-                return ret;
-        }
-
-        /* XXX: perform init () */
-        ret = glusterfs_graph_init (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED,
-                        "init failed");
-                return ret;
-        }
+    /* XXX: all xlator options validation */
+    ret = glusterfs_graph_validate_options(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
+               "validate options failed");
+        return ret;
+    }
 
-        ret = glusterfs_graph_unknown_options (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0,
-                        LG_MSG_UNKNOWN_OPTIONS_FAILED, "unknown options "
-                        "failed");
-                return ret;
-        }
+    /* XXX: perform init () */
+    ret = glusterfs_graph_init(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED,
+               "init failed");
+        return ret;
+    }
 
-        /* XXX: log full graph (_gf_dump_details) */
+    ret = glusterfs_graph_unknown_options(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_UNKNOWN_OPTIONS_FAILED,
+               "unknown options "
+               "failed");
+        return ret;
+    }
 
-        list_add (&graph->list, &ctx->graphs);
-        ctx->active = graph;
+    /* XXX: log full graph (_gf_dump_details) */
 
-        /* XXX: attach to master and set active pointer */
-        if (ctx->master) {
-                ret = xlator_notify (ctx->master, GF_EVENT_GRAPH_NEW, graph);
-                if (ret) {
-                        gf_msg ("graph", GF_LOG_ERROR, 0,
-                                LG_MSG_EVENT_NOTIFY_FAILED,
-                                "graph new notification failed");
-                        return ret;
-                }
-                ((xlator_t *)ctx->master)->next = graph->top;
-        }
+    list_add(&graph->list, &ctx->graphs);
+    ctx->active = graph;
 
-        /* XXX: perform parent up */
-        ret = glusterfs_graph_parent_up (graph);
+    /* XXX: attach to master and set active pointer */
+    if (ctx->master) {
+        ret = xlator_notify(ctx->master, GF_EVENT_GRAPH_NEW, graph);
         if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
-                        "parent up notification failed");
-                return ret;
+            gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+                   "graph new notification failed");
+            return ret;
         }
+        ((xlator_t *)ctx->master)->next = graph->top;
+    }
+
+    /* XXX: perform parent up */
+    ret = glusterfs_graph_parent_up(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+               "parent up notification failed");
+        return ret;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-xlator_equal_rec (xlator_t *xl1, xlator_t *xl2)
+xlator_equal_rec(xlator_t *xl1, xlator_t *xl2)
 {
-        xlator_list_t *trav1 = NULL;
-        xlator_list_t *trav2 = NULL;
-        int            ret   = 0;
-
-        if (xl1 == NULL || xl2 == NULL) {
-                gf_msg_debug ("xlator", 0, "invalid argument");
-                return -1;
-        }
+    xlator_list_t *trav1 = NULL;
+    xlator_list_t *trav2 = NULL;
+    int ret = 0;
 
-        trav1 = xl1->children;
-        trav2 = xl2->children;
-
-        while (trav1 && trav2) {
-                ret = xlator_equal_rec (trav1->xlator, trav2->xlator);
-                if (ret) {
-                        gf_msg_debug ("glusterfsd-mgmt", 0, "xlators children "
-                                      "not equal");
-                        goto out;
-                }
-
-                trav1 = trav1->next;
-                trav2 = trav2->next;
-        }
+    if (xl1 == NULL || xl2 == NULL) {
+        gf_msg_debug("xlator", 0, "invalid argument");
+        return -1;
+    }
 
-        if (trav1 || trav2) {
-                ret = -1;
-                goto out;
-        }
+    trav1 = xl1->children;
+    trav2 = xl2->children;
 
-        if (strcmp (xl1->name, xl2->name)) {
-                ret = -1;
-                goto out;
+    while (trav1 && trav2) {
+        ret = xlator_equal_rec(trav1->xlator, trav2->xlator);
+        if (ret) {
+            gf_msg_debug("glusterfsd-mgmt", 0,
+                         "xlators children "
+                         "not equal");
+            goto out;
         }
 
-	/* type could have changed even if xlator names match,
-	   e.g cluster/distribute and cluster/nufa share the same
-	   xlator name
-	*/
-        if (strcmp (xl1->type, xl2->type)) {
-                ret = -1;
-                goto out;
-        }
-out :
-        return ret;
+        trav1 = trav1->next;
+        trav2 = trav2->next;
+    }
+
+    if (trav1 || trav2) {
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(xl1->name, xl2->name)) {
+        ret = -1;
+        goto out;
+    }
+
+    /* type could have changed even if xlator names match,
+       e.g cluster/distribute and cluster/nufa share the same
+       xlator name
+    */
+    if (strcmp(xl1->type, xl2->type)) {
+        ret = -1;
+        goto out;
+    }
+out:
+    return ret;
 }
 
-
 gf_boolean_t
-is_graph_topology_equal (glusterfs_graph_t *graph1, glusterfs_graph_t *graph2)
+is_graph_topology_equal(glusterfs_graph_t *graph1, glusterfs_graph_t *graph2)
 {
-        xlator_t      *trav1    = NULL;
-        xlator_t      *trav2    = NULL;
-        gf_boolean_t   ret      = _gf_true;
-        xlator_list_t *ltrav;
-
-        trav1 = graph1->first;
-        trav2 = graph2->first;
-
-        if (strcmp (trav2->type, "protocol/server") == 0) {
-                trav2 = trav2->children->xlator;
-                for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) {
-                        trav1 = ltrav->xlator;
-                        if (strcmp (trav1->name, trav2->name) == 0) {
-                                break;
-                        }
-                }
-                if (!ltrav) {
-                        return _gf_false;
-                }
+    xlator_t *trav1 = NULL;
+    xlator_t *trav2 = NULL;
+    gf_boolean_t ret = _gf_true;
+    xlator_list_t *ltrav;
+
+    trav1 = graph1->first;
+    trav2 = graph2->first;
+
+    if (strcmp(trav2->type, "protocol/server") == 0) {
+        trav2 = trav2->children->xlator;
+        for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) {
+            trav1 = ltrav->xlator;
+            if (!trav1->cleanup_starting && !strcmp(trav1->name, trav2->name)) {
+                break;
+            }
+        }
+        if (!ltrav) {
+            return _gf_false;
         }
+    }
 
-        ret = xlator_equal_rec (trav1, trav2);
+    ret = xlator_equal_rec(trav1, trav2);
 
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are not equal");
-                ret = _gf_false;
-                goto out;
-        }
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0, "graphs are not equal");
+        ret = _gf_false;
+        goto out;
+    }
 
-        ret = _gf_true;
-        gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are equal");
+    ret = _gf_true;
+    gf_msg_debug("glusterfsd-mgmt", 0, "graphs are equal");
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Function has 3types of return value 0, -ve , 1
  *   return 0          =======> reconfiguration of options has succeeded
- *   return 1          =======> the graph has to be reconstructed and all the xlators should be inited
- *   return -1(or -ve) =======> Some Internal Error occurred during the operation
+ *   return 1          =======> the graph has to be reconstructed and all the
+ * xlators should be inited return -1(or -ve) =======> Some Internal Error
+ * occurred during the operation
  */
 int
-glusterfs_volfile_reconfigure (FILE *newvolfile_fp, glusterfs_ctx_t *ctx)
+glusterfs_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx)
 {
-        glusterfs_graph_t *oldvolfile_graph = NULL;
-        glusterfs_graph_t *newvolfile_graph = NULL;
-
-        int ret = -1;
-
-        if (!ctx) {
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
-                        "ctx is NULL");
-                goto out;
-        }
-
-        oldvolfile_graph = ctx->active;
-        if (!oldvolfile_graph) {
-                ret = 1;
-                goto out;
-        }
-
-        newvolfile_graph = glusterfs_graph_construct (newvolfile_fp);
-
-        if (!newvolfile_graph) {
-                goto out;
-        }
-
-        glusterfs_graph_prepare (newvolfile_graph, ctx,
-                                 ctx->cmd_args.volume_name);
-
-        if (!is_graph_topology_equal (oldvolfile_graph,
-                                      newvolfile_graph)) {
-
-                ret = 1;
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not "
-                              "equal(should call INIT)");
-                goto out;
-        }
-
-        gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the"
-                      " new graph");
-
-        ret = glusterfs_graph_reconfigure (oldvolfile_graph,
-                                           newvolfile_graph);
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure "
-                              "new options in old graph");
-                goto out;
-        }
-
-        ret = 0;
+    glusterfs_graph_t *oldvolfile_graph = NULL;
+    glusterfs_graph_t *newvolfile_graph = NULL;
+
+    int ret = -1;
+
+    if (!ctx) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "ctx is NULL");
+        goto out;
+    }
+
+    oldvolfile_graph = ctx->active;
+    if (!oldvolfile_graph) {
+        ret = 1;
+        goto out;
+    }
+
+    newvolfile_graph = glusterfs_graph_construct(newvolfile_fp);
+
+    if (!newvolfile_graph) {
+        goto out;
+    }
+
+    glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name);
+
+    if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) {
+        ret = 1;
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Graph topology not "
+                     "equal(should call INIT)");
+        goto out;
+    }
+
+    gf_msg_debug("glusterfsd-mgmt", 0,
+                 "Only options have changed in the"
+                 " new graph");
+
+    ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph);
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Could not reconfigure "
+                     "new options in old graph");
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        if (newvolfile_graph)
-                glusterfs_graph_destroy (newvolfile_graph);
+    if (newvolfile_graph)
+        glusterfs_graph_destroy(newvolfile_graph);
 
-        return ret;
+    return ret;
 }
 
 /* This function need to remove. This added to support gfapi volfile
@@ -894,182 +970,185 @@ out:
  */
 
 int
-gf_volfile_reconfigure (int oldvollen, FILE *newvolfile_fp,
-                        glusterfs_ctx_t *ctx, const char *oldvolfile)
+gf_volfile_reconfigure(int oldvollen, FILE *newvolfile_fp, glusterfs_ctx_t *ctx,
+                       const char *oldvolfile)
 {
-        glusterfs_graph_t *oldvolfile_graph = NULL;
-        glusterfs_graph_t *newvolfile_graph = NULL;
-        FILE              *oldvolfile_fp    = NULL;
-        /*Since the function mkstemp() replaces XXXXXX,
-         * assigning it to a variable
-         */
-        char temp_file[]                    = "/tmp/temp_vol_file_XXXXXX";
-        gf_boolean_t      active_graph_found = _gf_true;
-
-        int ret = -1;
-        int u_ret = -1;
-        int file_desc = -1;
-
-        if (!oldvollen) {
-                ret = 1; // Has to call INIT for the whole graph
-                goto out;
+    glusterfs_graph_t *oldvolfile_graph = NULL;
+    glusterfs_graph_t *newvolfile_graph = NULL;
+    FILE *oldvolfile_fp = NULL;
+    /*Since the function mkstemp() replaces XXXXXX,
+     * assigning it to a variable
+     */
+    char temp_file[] = "/tmp/temp_vol_file_XXXXXX";
+    gf_boolean_t active_graph_found = _gf_true;
+
+    int ret = -1;
+    int u_ret = -1;
+    int file_desc = -1;
+
+    if (!oldvollen) {
+        ret = 1;  // Has to call INIT for the whole graph
+        goto out;
+    }
+
+    if (!ctx) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "ctx is NULL");
+        goto out;
+    }
+
+    oldvolfile_graph = ctx->active;
+    if (!oldvolfile_graph) {
+        active_graph_found = _gf_false;
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_ACTIVE_GRAPH_NULL,
+               "glusterfs_ctx->active is NULL");
+
+        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+        file_desc = mkstemp(temp_file);
+        if (file_desc < 0) {
+            gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno,
+                   LG_MSG_TMPFILE_CREATE_FAILED,
+                   "Unable to "
+                   "create temporary volfile");
+            goto out;
         }
 
-        if (!ctx) {
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
-                        "ctx is NULL");
-                goto out;
-        }
-
-        oldvolfile_graph = ctx->active;
-        if (!oldvolfile_graph) {
-                active_graph_found = _gf_false;
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0,
-                        LG_MSG_ACTIVE_GRAPH_NULL,
-                        "glusterfs_ctx->active is NULL");
-
-                file_desc = mkstemp(temp_file);
-                if (file_desc < 0) {
-                        gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno,
-                                LG_MSG_TMPFILE_CREATE_FAILED, "Unable to "
-                                "create temporary volfile");
-                        goto out;
-                }
-
-                /*Calling unlink so that when the file is closed or program
-                 *terminates the tempfile is deleted.
-                 */
-                u_ret = sys_unlink(temp_file);
-
-                if (u_ret < 0) {
-                        gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno,
-                                LG_MSG_TMPFILE_DELETE_FAILED, "Temporary file"
-                                " delete failed.");
-                        sys_close (file_desc);
-                        goto out;
-                }
-
-
-                oldvolfile_fp = fdopen (file_desc, "w+b");
-                if (!oldvolfile_fp)
-                        goto out;
-
-                fwrite (oldvolfile, oldvollen, 1, oldvolfile_fp);
-                fflush (oldvolfile_fp);
-                if (ferror (oldvolfile_fp)) {
-                        goto out;
-                }
-
-                oldvolfile_graph = glusterfs_graph_construct (oldvolfile_fp);
-                if (!oldvolfile_graph)
-                        goto out;
-        }
-
-        newvolfile_graph = glusterfs_graph_construct (newvolfile_fp);
-        if (!newvolfile_graph) {
-                goto out;
-        }
-
-        glusterfs_graph_prepare (newvolfile_graph, ctx,
-                                 ctx->cmd_args.volume_name);
-
-        if (!is_graph_topology_equal (oldvolfile_graph,
-                                      newvolfile_graph)) {
-
-                ret = 1;
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not "
-                              "equal(should call INIT)");
-                goto out;
+        /*Calling unlink so that when the file is closed or program
+         *terminates the tempfile is deleted.
+         */
+        u_ret = sys_unlink(temp_file);
+
+        if (u_ret < 0) {
+            gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno,
+                   LG_MSG_TMPFILE_DELETE_FAILED,
+                   "Temporary file"
+                   " delete failed.");
+            sys_close(file_desc);
+            goto out;
         }
 
-        gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the"
-                      " new graph");
+        oldvolfile_fp = fdopen(file_desc, "w+b");
+        if (!oldvolfile_fp)
+            goto out;
 
-        /* */
-        ret = glusterfs_graph_reconfigure (oldvolfile_graph,
-                                           newvolfile_graph);
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure "
-                              "new options in old graph");
-                goto out;
+        fwrite(oldvolfile, oldvollen, 1, oldvolfile_fp);
+        fflush(oldvolfile_fp);
+        if (ferror(oldvolfile_fp)) {
+            goto out;
         }
 
-        ret = 0;
+        oldvolfile_graph = glusterfs_graph_construct(oldvolfile_fp);
+        if (!oldvolfile_graph)
+            goto out;
+    }
+
+    newvolfile_graph = glusterfs_graph_construct(newvolfile_fp);
+    if (!newvolfile_graph) {
+        goto out;
+    }
+
+    glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name);
+
+    if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) {
+        ret = 1;
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Graph topology not "
+                     "equal(should call INIT)");
+        goto out;
+    }
+
+    gf_msg_debug("glusterfsd-mgmt", 0,
+                 "Only options have changed in the"
+                 " new graph");
+
+    /* */
+    ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph);
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Could not reconfigure "
+                     "new options in old graph");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (oldvolfile_fp)
-                fclose (oldvolfile_fp);
-
-        /*  Do not simply destroy the old graph here. If the oldgraph
-            is constructed here in this function itself instead of getting
-            it from ctx->active (which happens only of ctx->active is NULL),
-            then destroy the old graph. If some i/o is still happening in
-            the old graph and the old graph is obtained from ctx->active,
-            then destroying the graph will cause problems.
-        */
-        if (!active_graph_found && oldvolfile_graph)
-                glusterfs_graph_destroy (oldvolfile_graph);
-        if (newvolfile_graph)
-                glusterfs_graph_destroy (newvolfile_graph);
-
-        return ret;
+    if (oldvolfile_fp)
+        fclose(oldvolfile_fp);
+
+    /*  Do not simply destroy the old graph here. If the oldgraph
+        is constructed here in this function itself instead of getting
+        it from ctx->active (which happens only of ctx->active is NULL),
+        then destroy the old graph. If some i/o is still happening in
+        the old graph and the old graph is obtained from ctx->active,
+        then destroying the graph will cause problems.
+    */
+    if (!active_graph_found && oldvolfile_graph)
+        glusterfs_graph_destroy(oldvolfile_graph);
+    if (newvolfile_graph)
+        glusterfs_graph_destroy(newvolfile_graph);
+
+    return ret;
 }
 
 int
-glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph,
-                             glusterfs_graph_t *newgraph)
+glusterfs_graph_reconfigure(glusterfs_graph_t *oldgraph,
+                            glusterfs_graph_t *newgraph)
 {
-        xlator_t        *old_xl   = NULL;
-        xlator_t        *new_xl   = NULL;
-        xlator_list_t   *trav;
-
-        GF_ASSERT (oldgraph);
-        GF_ASSERT (newgraph);
-
-        old_xl   = oldgraph->first;
-        while (old_xl->is_autoloaded) {
-                old_xl = old_xl->children->xlator;
-        }
-
-        new_xl   = newgraph->first;
-        while (new_xl->is_autoloaded) {
-                new_xl = new_xl->children->xlator;
-        }
-
-        if (strcmp (old_xl->type, "protocol/server") != 0) {
-                return xlator_tree_reconfigure (old_xl, new_xl);
-        }
-
-        /* Some options still need to be handled by the server translator. */
-        if (old_xl->reconfigure) {
-                old_xl->reconfigure (old_xl, new_xl->options);
+    xlator_t *old_xl = NULL;
+    xlator_t *new_xl = NULL;
+    xlator_list_t *trav;
+
+    GF_ASSERT(oldgraph);
+    GF_ASSERT(newgraph);
+
+    old_xl = oldgraph->first;
+    while (old_xl->is_autoloaded) {
+        old_xl = old_xl->children->xlator;
+    }
+
+    new_xl = newgraph->first;
+    while (new_xl->is_autoloaded) {
+        new_xl = new_xl->children->xlator;
+    }
+
+    if (strcmp(old_xl->type, "protocol/server") != 0) {
+        return xlator_tree_reconfigure(old_xl, new_xl);
+    }
+
+    /* Some options still need to be handled by the server translator. */
+    if (old_xl->reconfigure) {
+        old_xl->reconfigure(old_xl, new_xl->options);
+    }
+
+    (void)copy_opts_to_child(new_xl, FIRST_CHILD(new_xl), "*auth*");
+    new_xl = FIRST_CHILD(new_xl);
+
+    for (trav = old_xl->children; trav; trav = trav->next) {
+        if (!trav->xlator->cleanup_starting &&
+            !strcmp(trav->xlator->name, new_xl->name)) {
+            return xlator_tree_reconfigure(trav->xlator, new_xl);
         }
+    }
 
-        (void) copy_opts_to_child (new_xl, FIRST_CHILD (new_xl), "*auth*");
-        new_xl = FIRST_CHILD (new_xl);
-
-        for (trav = old_xl->children; trav; trav = trav->next) {
-                if (strcmp (trav->xlator->name, new_xl->name) == 0) {
-                        return xlator_tree_reconfigure (trav->xlator, new_xl);
-                }
-        }
-
-        return -1;
+    return -1;
 }
 
 int
-glusterfs_graph_destroy_residual (glusterfs_graph_t *graph)
+glusterfs_graph_destroy_residual(glusterfs_graph_t *graph)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (graph == NULL)
-                return ret;
+    if (graph == NULL)
+        return ret;
 
-        ret = xlator_tree_free_memacct (graph->first);
+    ret = xlator_tree_free_memacct(graph->first);
 
-        list_del_init (&graph->list);
-        GF_FREE (graph);
+    list_del_init(&graph->list);
+    pthread_mutex_destroy(&graph->mutex);
+    pthread_cond_destroy(&graph->child_down_cond);
+    GF_FREE(graph);
 
-        return ret;
+    return ret;
 }
 
 /* This function destroys all the xlator members except for the
@@ -1095,140 +1174,707 @@ glusterfs_graph_destroy_residual (glusterfs_graph_t *graph)
  *   object itself.
  */
 int
-glusterfs_graph_destroy (glusterfs_graph_t *graph)
+glusterfs_graph_destroy(glusterfs_graph_t *graph)
 {
-        int ret = 0;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("graph", graph, out);
+    GF_VALIDATE_OR_GOTO("graph", graph, out);
 
-        ret = xlator_tree_free_members (graph->first);
+    ret = xlator_tree_free_members(graph->first);
 
-        ret = glusterfs_graph_destroy_residual (graph);
+    ret = glusterfs_graph_destroy_residual(graph);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_attach (glusterfs_graph_t *orig_graph, char *path,
-                        glusterfs_graph_t **newgraph)
+glusterfs_graph_fini(glusterfs_graph_t *graph)
 {
-        xlator_t                *this   = THIS;
-        FILE                    *fp;
-        glusterfs_graph_t       *graph;
-        xlator_t                *xl;
-        char                    *volfile_id                        = NULL;
-        char                    *volfile_content                   = NULL;
-        struct stat              stbuf                             = {0,};
-        size_t                   file_len                          = -1;
-        gf_volfile_t            *volfile_obj                       = NULL;
-        int                      ret                               = -1;
-        char                     sha256_hash[SHA256_DIGEST_LENGTH] = {0, };
-
-        if (!orig_graph) {
-                return -EINVAL;
+    xlator_t *trav = NULL;
+
+    trav = graph->first;
+
+    while (trav) {
+        if (trav->init_succeeded) {
+            trav->cleanup_starting = 1;
+            trav->fini(trav);
+            if (trav->local_pool) {
+                mem_pool_destroy(trav->local_pool);
+                trav->local_pool = NULL;
+            }
+            if (trav->itable) {
+                inode_table_destroy(trav->itable);
+                trav->itable = NULL;
+            }
+            trav->init_succeeded = 0;
         }
+        trav = trav->next;
+    }
 
-        ret = sys_stat (path, &stbuf);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)",
-                        path, strerror (errno));
-                return -EINVAL;
-        }
+    return 0;
+}
 
-        file_len = stbuf.st_size;
-        if (file_len) {
-                volfile_content = GF_CALLOC (file_len+1, sizeof (char),
-                                             gf_common_mt_char);
-                if (!volfile_content) {
-                        return -ENOMEM;
-                }
+int
+glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path,
+                       glusterfs_graph_t **newgraph)
+{
+    xlator_t *this = THIS;
+    FILE *fp;
+    glusterfs_graph_t *graph;
+    xlator_t *xl;
+    char *volfile_id = NULL;
+    char *volfile_content = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    size_t file_len = -1;
+    gf_volfile_t *volfile_obj = NULL;
+    int ret = -1;
+    char sha256_hash[SHA256_DIGEST_LENGTH] = {
+        0,
+    };
+
+    if (!orig_graph) {
+        return -EINVAL;
+    }
+
+    ret = sys_stat(path, &stbuf);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)", path,
+               strerror(errno));
+        return -EINVAL;
+    }
+
+    file_len = stbuf.st_size;
+    volfile_content = GF_MALLOC(file_len + 1, gf_common_mt_char);
+    if (!volfile_content)
+        return -ENOMEM;
+
+    fp = fopen(path, "r");
+    if (!fp) {
+        gf_log(THIS->name, GF_LOG_WARNING, "oops, %s disappeared on us", path);
+        GF_FREE(volfile_content);
+        return -EIO;
+    }
+
+    ret = fread(volfile_content, sizeof(char), file_len, fp);
+    if (ret == file_len) {
+        glusterfs_compute_sha256((const unsigned char *)volfile_content,
+                                 file_len, sha256_hash);
+    } else {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "read failed on path %s. File size=%" GF_PRI_SIZET
+               "read size=%d",
+               path, file_len, ret);
+        GF_FREE(volfile_content);
+        fclose(fp);
+        return -EIO;
+    }
+
+    GF_FREE(volfile_content);
+
+    graph = glusterfs_graph_construct(fp);
+    fclose(fp);
+    if (!graph) {
+        gf_log(this->name, GF_LOG_WARNING, "could not create graph from %s",
+               path);
+        return -EIO;
+    }
+
+    /*
+     * If there's a server translator on top, we want whatever's below
+     * that.
+     */
+    xl = graph->first;
+    if (strcmp(xl->type, "protocol/server") == 0) {
+        (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*");
+        xl = FIRST_CHILD(xl);
+    }
+    graph->first = xl;
+    *newgraph = graph;
+
+    volfile_id = strstr(path, "/snaps/");
+    if (!volfile_id) {
+        volfile_id = rindex(path, '/');
+        if (volfile_id) {
+            ++volfile_id;
         }
-
-        fp = fopen (path, "r");
-        if (!fp) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "oops, %s disappeared on us", path);
-                GF_FREE (volfile_content);
-                return -EIO;
+    }
+    if (volfile_id) {
+        xl->volfile_id = gf_strdup(volfile_id);
+        /* There's a stray ".vol" at the end. */
+        xl->volfile_id[strlen(xl->volfile_id) - 4] = '\0';
+    }
+
+    /* TODO memory leaks everywhere need to free graph in case of error */
+    if (glusterfs_graph_prepare(graph, this->ctx, xl->name)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to prepare graph for xlator %s", xl->name);
+        return -EIO;
+    } else if (glusterfs_graph_init(graph)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to initialize graph for xlator %s", xl->name);
+        return -EIO;
+    } else if (glusterfs_xlator_link(orig_graph->top, graph->top)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to link the graphs for xlator %s ", xl->name);
+        return -EIO;
+    }
+
+    if (!volfile_obj) {
+        volfile_obj = GF_CALLOC(1, sizeof(gf_volfile_t), gf_common_volfile_t);
+        if (!volfile_obj) {
+            return -EIO;
         }
+    }
+
+    INIT_LIST_HEAD(&volfile_obj->volfile_list);
+    snprintf(volfile_obj->vol_id, sizeof(volfile_obj->vol_id), "%s",
+             xl->volfile_id);
+    memcpy(volfile_obj->volfile_checksum, sha256_hash,
+           sizeof(volfile_obj->volfile_checksum));
+    list_add(&volfile_obj->volfile_list, &this->ctx->volfile_list);
 
-        ret = fread (volfile_content, sizeof (char), file_len, fp);
-        if (ret == file_len) {
-              glusterfs_compute_sha256 ((const unsigned char *) volfile_content,
-                                         file_len, sha256_hash);
-        } else {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "read failed on path %s. File size=%"GF_PRI_SIZET
-                        "read size=%d", path, file_len, ret);
-                GF_FREE (volfile_content);
-                return -EIO;
+    return 0;
+}
+int
+glusterfs_muxsvc_cleanup_parent(glusterfs_ctx_t *ctx,
+                                glusterfs_graph_t *parent_graph)
+{
+    if (parent_graph) {
+        if (parent_graph->first) {
+            xlator_destroy(parent_graph->first);
         }
+        ctx->active = NULL;
+        GF_FREE(parent_graph);
+        parent_graph = NULL;
+    }
+    return 0;
+}
 
-        GF_FREE (volfile_content);
+void *
+glusterfs_graph_cleanup(void *arg)
+{
+    glusterfs_graph_t *graph = NULL;
+    glusterfs_ctx_t *ctx = THIS->ctx;
+    int ret = -1;
+    graph = arg;
+
+    if (!graph)
+        return NULL;
+
+    /* To destroy the graph, fitst sent a GF_EVENT_PARENT_DOWN
+     * Then wait for GF_EVENT_CHILD_DOWN to get on the top
+     * xl. Once we have GF_EVENT_CHILD_DOWN event, then proceed
+     * to fini.
+     *
+     * During fini call, this will take a last unref on rpc and
+     * rpc_transport_object.
+     */
+    if (graph->first)
+        default_notify(graph->first, GF_EVENT_PARENT_DOWN, graph->first);
+
+    ret = pthread_mutex_lock(&graph->mutex);
+    if (ret != 0) {
+        gf_msg("glusterfs", GF_LOG_ERROR, EAGAIN, LG_MSG_GRAPH_CLEANUP_FAILED,
+               "Failed to acquire a lock");
+        goto out;
+    }
+    /* check and wait for CHILD_DOWN for top xlator*/
+    while (graph->used) {
+        ret = pthread_cond_wait(&graph->child_down_cond, &graph->mutex);
+        if (ret != 0)
+            gf_msg("glusterfs", GF_LOG_INFO, 0, LG_MSG_GRAPH_CLEANUP_FAILED,
+                   "cond wait failed ");
+    }
+
+    ret = pthread_mutex_unlock(&graph->mutex);
+    if (ret != 0) {
+        gf_msg("glusterfs", GF_LOG_ERROR, EAGAIN, LG_MSG_GRAPH_CLEANUP_FAILED,
+               "Failed to release a lock");
+    }
+
+    /* Though we got a child down on top xlator, we have to wait until
+     * all the notifier to exit. Because there should not be any threads
+     * that access xl variables.
+     */
+    pthread_mutex_lock(&ctx->notify_lock);
+    {
+        while (ctx->notifying)
+            pthread_cond_wait(&ctx->notify_cond, &ctx->notify_lock);
+    }
+    pthread_mutex_unlock(&ctx->notify_lock);
+
+    pthread_mutex_lock(&ctx->cleanup_lock);
+    {
+        glusterfs_graph_fini(graph);
+        glusterfs_graph_destroy(graph);
+    }
+    pthread_mutex_unlock(&ctx->cleanup_lock);
+out:
+    return NULL;
+}
 
-        graph = glusterfs_graph_construct (fp);
-        fclose(fp);
-        if (!graph) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "could not create graph from %s", path);
-                return -EIO;
-        }
+glusterfs_graph_t *
+glusterfs_muxsvc_setup_parent_graph(glusterfs_ctx_t *ctx, char *name,
+                                    char *type)
+{
+    glusterfs_graph_t *parent_graph = NULL;
+    xlator_t *ixl = NULL;
+    int ret = -1;
+    parent_graph = GF_CALLOC(1, sizeof(*parent_graph),
+                             gf_common_mt_glusterfs_graph_t);
+    if (!parent_graph)
+        goto out;
+
+    INIT_LIST_HEAD(&parent_graph->list);
+
+    ctx->active = parent_graph;
+    ixl = GF_CALLOC(1, sizeof(*ixl), gf_common_mt_xlator_t);
+    if (!ixl)
+        goto out;
+
+    ixl->ctx = ctx;
+    ixl->graph = parent_graph;
+    ixl->options = dict_new();
+    if (!ixl->options)
+        goto out;
+
+    ixl->name = gf_strdup(name);
+    if (!ixl->name)
+        goto out;
+
+    ixl->is_autoloaded = 1;
+
+    if (xlator_set_type(ixl, type) == -1) {
+        gf_msg("glusterfs", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_SETUP_FAILED,
+               "%s (%s) set type failed", name, type);
+        goto out;
+    }
+
+    glusterfs_graph_set_first(parent_graph, ixl);
+    parent_graph->top = ixl;
+    ixl = NULL;
+
+    gettimeofday(&parent_graph->dob, NULL);
+    fill_uuid(parent_graph->graph_uuid, 128, parent_graph->dob);
+    parent_graph->id = ctx->graph_id++;
+    ret = 0;
+out:
+    if (ixl)
+        xlator_destroy(ixl);
+
+    if (ret) {
+        glusterfs_muxsvc_cleanup_parent(ctx, parent_graph);
+        parent_graph = NULL;
+    }
+    return parent_graph;
+}
 
-        /*
-         * If there's a server translator on top, we want whatever's below
-         * that.
-         */
-        xl = graph->first;
-        if (strcmp(xl->type, "protocol/server") == 0) {
-                (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*");
-                xl = FIRST_CHILD(xl);
+int
+glusterfs_svc_mux_pidfile_cleanup(gf_volfile_t *volfile_obj)
+{
+    if (!volfile_obj || !volfile_obj->pidfp)
+        return 0;
+
+    gf_msg_trace("glusterfsd", 0, "pidfile %s cleanup", volfile_obj->vol_id);
+
+    lockf(fileno(volfile_obj->pidfp), F_ULOCK, 0);
+    fclose(volfile_obj->pidfp);
+    volfile_obj->pidfp = NULL;
+
+    return 0;
+}
+
+int
+glusterfs_process_svc_detach(glusterfs_ctx_t *ctx, gf_volfile_t *volfile_obj)
+{
+    xlator_t *last_xl = NULL;
+    glusterfs_graph_t *graph = NULL;
+    glusterfs_graph_t *parent_graph = NULL;
+    pthread_t clean_graph = {
+        0,
+    };
+    int ret = -1;
+    xlator_t *xl = NULL;
+
+    if (!ctx || !ctx->active || !volfile_obj)
+        goto out;
+
+    pthread_mutex_lock(&ctx->cleanup_lock);
+    {
+        parent_graph = ctx->active;
+        graph = volfile_obj->graph;
+        if (!graph)
+            goto unlock;
+        if (graph->first)
+            xl = graph->first;
+
+        last_xl = graph->last_xl;
+        if (last_xl)
+            last_xl->next = NULL;
+        if (!xl || xl->cleanup_starting)
+            goto unlock;
+
+        xl->cleanup_starting = 1;
+        gf_msg("mgmt", GF_LOG_INFO, 0, LG_MSG_GRAPH_DETACH_STARTED,
+               "detaching child %s", volfile_obj->vol_id);
+
+        list_del_init(&volfile_obj->volfile_list);
+        glusterfs_mux_xlator_unlink(parent_graph->top, xl);
+        glusterfs_svc_mux_pidfile_cleanup(volfile_obj);
+        parent_graph->last_xl = glusterfs_get_last_xlator(parent_graph);
+        parent_graph->xl_count -= graph->xl_count;
+        parent_graph->leaf_count -= graph->leaf_count;
+        parent_graph->id++;
+        ret = 0;
+    }
+unlock:
+    pthread_mutex_unlock(&ctx->cleanup_lock);
+out:
+    if (!ret) {
+        list_del_init(&volfile_obj->volfile_list);
+        if (graph) {
+            ret = gf_thread_create_detached(
+                &clean_graph, glusterfs_graph_cleanup, graph, "graph_clean");
+            if (ret) {
+                gf_msg("glusterfs", GF_LOG_ERROR, EINVAL,
+                       LG_MSG_GRAPH_CLEANUP_FAILED,
+                       "%s failed to create clean "
+                       "up thread",
+                       volfile_obj->vol_id);
+                ret = 0;
+            }
         }
-        graph->first = xl;
-        *newgraph = graph;
-
-        volfile_id = strstr (path, "/snaps/");
-        if (!volfile_id) {
-                volfile_id = rindex (path, '/');
-                if (volfile_id) {
-                        ++volfile_id;
-                }
+        GF_FREE(volfile_obj);
+    }
+    return ret;
+}
+
+int
+glusterfs_svc_mux_pidfile_setup(gf_volfile_t *volfile_obj, const char *pid_file)
+{
+    int ret = -1;
+    FILE *pidfp = NULL;
+
+    if (!pid_file || !volfile_obj)
+        goto out;
+
+    if (volfile_obj->pidfp) {
+        ret = 0;
+        goto out;
+    }
+    pidfp = fopen(pid_file, "a+");
+    if (!pidfp) {
+        goto out;
+    }
+    volfile_obj->pidfp = pidfp;
+
+    ret = lockf(fileno(pidfp), F_TLOCK, 0);
+    if (ret) {
+        ret = 0;
+        goto out;
+    }
+out:
+    return ret;
+}
+
+int
+glusterfs_svc_mux_pidfile_update(gf_volfile_t *volfile_obj,
+                                 const char *pid_file, pid_t pid)
+{
+    int ret = 0;
+    FILE *pidfp = NULL;
+    int old_pid;
+
+    if (!volfile_obj->pidfp) {
+        ret = glusterfs_svc_mux_pidfile_setup(volfile_obj, pid_file);
+        if (ret == -1)
+            goto out;
+    }
+    pidfp = volfile_obj->pidfp;
+    ret = fscanf(pidfp, "%d", &old_pid);
+    if (ret <= 0) {
+        goto update;
+    }
+    if (old_pid == pid) {
+        ret = 0;
+        goto out;
+    } else {
+        gf_msg("mgmt", GF_LOG_INFO, 0, LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED,
+               "Old pid=%d found in pidfile %s. Cleaning the old pid and "
+               "Updating new pid=%d",
+               old_pid, pid_file, pid);
+    }
+update:
+    ret = sys_ftruncate(fileno(pidfp), 0);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno,
+               LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED,
+               "pidfile %s truncation failed", pid_file);
+        goto out;
+    }
+
+    ret = fprintf(pidfp, "%d\n", pid);
+    if (ret <= 0) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno,
+               LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED, "pidfile %s write failed",
+               pid_file);
+        goto out;
+    }
+
+    ret = fflush(pidfp);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno,
+               LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED, "pidfile %s write failed",
+               pid_file);
+        goto out;
+    }
+out:
+    return ret;
+}
+
+int
+glusterfs_update_mux_pid(dict_t *dict, gf_volfile_t *volfile_obj)
+{
+    char *file = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("graph", dict, out);
+    GF_VALIDATE_OR_GOTO("graph", volfile_obj, out);
+
+    ret = dict_get_str(dict, "pidfile", &file);
+    if (ret < 0) {
+        gf_msg("mgmt", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_SETUP_FAILED,
+               "Failed to get pidfile from dict for  volfile_id=%s",
+               volfile_obj->vol_id);
+    }
+
+    ret = glusterfs_svc_mux_pidfile_update(volfile_obj, file, getpid());
+    if (ret < 0) {
+        ret = -1;
+        gf_msg("mgmt", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_SETUP_FAILED,
+               "Failed to update "
+               "the pidfile for volfile_id=%s",
+               volfile_obj->vol_id);
+
+        goto out;
+    }
+
+    if (ret == 1)
+        gf_msg("mgmt", GF_LOG_INFO, 0, LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED,
+               "PID %d updated in pidfile=%s", getpid(), file);
+    ret = 0;
+out:
+    return ret;
+}
+int
+glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp,
+                                   char *volfile_id, char *checksum,
+                                   dict_t *dict)
+{
+    glusterfs_graph_t *graph = NULL;
+    glusterfs_graph_t *parent_graph = NULL;
+    glusterfs_graph_t *clean_graph = NULL;
+    int ret = -1;
+    xlator_t *xl = NULL;
+    xlator_t *last_xl = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+    pthread_t thread_id = {
+        0,
+    };
+
+    if (!ctx)
+        goto out;
+    parent_graph = ctx->active;
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED,
+               "failed to construct the graph");
+        goto out;
+    }
+    graph->parent_down = 0;
+    graph->last_xl = glusterfs_get_last_xlator(graph);
+
+    for (xl = graph->first; xl; xl = xl->next) {
+        if (strcmp(xl->type, "mount/fuse") == 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, EINVAL,
+                   LG_MSG_GRAPH_ATTACH_FAILED,
+                   "fuse xlator cannot be specified in volume file");
+            goto out;
         }
-        if (volfile_id) {
-                xl->volfile_id = gf_strdup (volfile_id);
-                /* There's a stray ".vol" at the end. */
-                xl->volfile_id[strlen(xl->volfile_id)-4] = '\0';
+    }
+
+    graph->leaf_count = glusterfs_count_leaves(glusterfs_root(graph));
+    xl = graph->first;
+    /* TODO memory leaks everywhere need to free graph in case of error */
+    if (glusterfs_graph_prepare(graph, ctx, xl->name)) {
+        gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED,
+               "failed to prepare graph for xlator %s", xl->name);
+        ret = -1;
+        goto out;
+    } else if (glusterfs_graph_init(graph)) {
+        gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED,
+               "failed to initialize graph for xlator %s", xl->name);
+        ret = -1;
+        goto out;
+    } else if (glusterfs_graph_parent_up(graph)) {
+        gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED,
+               "failed to link the graphs for xlator %s ", xl->name);
+        ret = -1;
+        goto out;
+    }
+
+    if (!parent_graph) {
+        parent_graph = glusterfs_muxsvc_setup_parent_graph(ctx, "glustershd",
+                                                           "debug/io-stats");
+        if (!parent_graph)
+            goto out;
+        ((xlator_t *)parent_graph->top)->next = xl;
+        clean_graph = parent_graph;
+    } else {
+        last_xl = parent_graph->last_xl;
+        if (last_xl)
+            last_xl->next = xl;
+        xl->prev = last_xl;
+    }
+    parent_graph->last_xl = graph->last_xl;
+
+    ret = glusterfs_xlator_link(parent_graph->top, xl);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+               "parent up notification failed");
+        goto out;
+    }
+    parent_graph->xl_count += graph->xl_count;
+    parent_graph->leaf_count += graph->leaf_count;
+    parent_graph->id++;
+
+    volfile_obj = GF_CALLOC(1, sizeof(gf_volfile_t), gf_common_volfile_t);
+    if (!volfile_obj) {
+        ret = -1;
+        goto out;
+    }
+    volfile_obj->pidfp = NULL;
+    snprintf(volfile_obj->vol_id, sizeof(volfile_obj->vol_id), "%s",
+             volfile_id);
+
+    if (strcmp(ctx->cmd_args.process_name, "glustershd") == 0) {
+        ret = glusterfs_update_mux_pid(dict, volfile_obj);
+        if (ret == -1) {
+            GF_FREE(volfile_obj);
+            goto out;
         }
-
-        /* TBD: memory leaks everywhere */
-        if (glusterfs_graph_prepare (graph, this->ctx, xl->name)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to prepare graph for xlator %s", xl->name);
-                return -EIO;
-        } else if (glusterfs_graph_init (graph)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to initialize graph for xlator %s", xl->name);
-                return -EIO;
-        } else if (glusterfs_xlator_link (orig_graph->top, graph->top)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to link the graphs for xlator %s ", xl->name);
-                return -EIO;
+    }
+
+    graph->used = 1;
+    parent_graph->id++;
+    list_add(&graph->list, &ctx->graphs);
+    INIT_LIST_HEAD(&volfile_obj->volfile_list);
+    volfile_obj->graph = graph;
+    memcpy(volfile_obj->volfile_checksum, checksum,
+           sizeof(volfile_obj->volfile_checksum));
+    list_add_tail(&volfile_obj->volfile_list, &ctx->volfile_list);
+    gf_log_dump_graph(fp, graph);
+    graph = NULL;
+
+    ret = 0;
+out:
+    if (ret) {
+        if (graph) {
+            gluster_graph_take_reference(graph->first);
+            ret = gf_thread_create_detached(&thread_id, glusterfs_graph_cleanup,
+                                            graph, "graph_clean");
+            if (ret) {
+                gf_msg("glusterfs", GF_LOG_ERROR, EINVAL,
+                       LG_MSG_GRAPH_CLEANUP_FAILED,
+                       "%s failed to create clean "
+                       "up thread",
+                       volfile_id);
+                ret = 0;
+            }
         }
+        if (clean_graph)
+            glusterfs_muxsvc_cleanup_parent(ctx, clean_graph);
+    }
+    return ret;
+}
 
-        if (!volfile_obj) {
-                volfile_obj = GF_CALLOC (1, sizeof (gf_volfile_t),
-                                         gf_common_volfile_t);
-                if (!volfile_obj) {
-                        return -EIO;
-                }
+int
+glusterfs_mux_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx,
+                                  gf_volfile_t *volfile_obj, char *checksum,
+                                  dict_t *dict)
+{
+    glusterfs_graph_t *oldvolfile_graph = NULL;
+    glusterfs_graph_t *newvolfile_graph = NULL;
+    char vol_id[NAME_MAX + 1];
+
+    int ret = -1;
+
+    if (!ctx) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "ctx is NULL");
+        goto out;
+    }
+
+    /* Change the message id */
+    if (!volfile_obj) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "failed to get volfile object");
+        goto out;
+    }
+
+    oldvolfile_graph = volfile_obj->graph;
+    if (!oldvolfile_graph) {
+        goto out;
+    }
+
+    newvolfile_graph = glusterfs_graph_construct(newvolfile_fp);
+
+    if (!newvolfile_graph) {
+        goto out;
+    }
+    newvolfile_graph->last_xl = glusterfs_get_last_xlator(newvolfile_graph);
+
+    glusterfs_graph_prepare(newvolfile_graph, ctx, newvolfile_graph->first);
+
+    if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) {
+        ret = snprintf(vol_id, sizeof(vol_id), "%s", volfile_obj->vol_id);
+        if (ret < 0)
+            goto out;
+        ret = glusterfs_process_svc_detach(ctx, volfile_obj);
+        if (ret) {
+            gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, EINVAL,
+                   LG_MSG_GRAPH_CLEANUP_FAILED,
+                   "Could not detach "
+                   "old graph. Aborting the reconfiguration operation");
+            goto out;
         }
+        volfile_obj = NULL;
+        ret = glusterfs_process_svc_attach_volfp(ctx, newvolfile_fp, vol_id,
+                                                 checksum, dict);
+        goto out;
+    }
+
+    gf_msg_debug("glusterfsd-mgmt", 0,
+                 "Only options have changed in the"
+                 " new graph");
+
+    ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph);
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Could not reconfigure "
+                     "new options in old graph");
+        goto out;
+    }
+    memcpy(volfile_obj->volfile_checksum, checksum,
+           sizeof(volfile_obj->volfile_checksum));
+
+    ret = 0;
+out:
 
-        INIT_LIST_HEAD (&volfile_obj->volfile_list);
-        snprintf (volfile_obj->vol_id, sizeof (volfile_obj->vol_id),
-                  "%s", xl->volfile_id);
-        strncpy (volfile_obj->volfile_checksum, sha256_hash,
-                 sizeof (volfile_obj->volfile_checksum));
-        list_add (&volfile_obj->volfile_list, &this->ctx->volfile_list);
+    if (newvolfile_graph)
+        glusterfs_graph_destroy(newvolfile_graph);
 
-        return 0;
+    return ret;
 }
diff --git a/libglusterfs/src/graph.l b/libglusterfs/src/graph.l
index 8af28a43539..b9d4b2b6828 100644
--- a/libglusterfs/src/graph.l
+++ b/libglusterfs/src/graph.l
@@ -14,35 +14,27 @@
 %{
 
 #define YYSTYPE char *
-#include "xlator.h"
+#include "glusterfs/xlator.h"
 #include "y.tab.h"
 #include <string.h>
-#define START_STRSIZE	32
 
 static char *text;
-static int text_asize;
 static int text_size;
 
 void append_string(const char *str, int size)
 {
-	int new_size = text_size + size + 1;
-	if (new_size > text_asize) {
-		new_size += START_STRSIZE - 1;
-		new_size &= -START_STRSIZE;
-                if (!text) {
-                        text = GF_CALLOC (1, new_size,
-                                          gf_common_mt_char);
-                } else {
-                        text = GF_REALLOC (text, new_size);
-                }
-                if (!text) {
-                        return;
-                }
-		text_asize = new_size;
-	}
-        memcpy(text + text_size, str, size);
-	text_size += size;
-	text[text_size] = 0;
+    int new_size = text_size + size + 1;
+    if (!text) {
+        text = GF_CALLOC (1, new_size, gf_common_mt_char);
+    } else {
+        text = GF_REALLOC (text, new_size);
+    }
+    if (!text) {
+        return;
+    }
+    memcpy(text + text_size, str, size);
+    text_size += size;
+    text[text_size] = 0;
 }
 
 %}
@@ -65,12 +57,14 @@ TYPE   [t][y][p][e]
        \\.        {    append_string (yytext + 1, yyleng - 1); }
        \"         {
                        if (0) {
-                              yyunput (0, NULL);
+                           yyunput (0, NULL);
                        }
                        BEGIN (INITIAL);
                        graphyylval = text;
+                       text = NULL;
+                       text_size = 0;
                        return STRING_TOK;
-       }
+                  }
 }
 [^ \t\r\n\"\\]+ {    graphyylval = gf_strdup (yytext) ; return ID; }
 [ \t\r\n]+             ;
diff --git a/libglusterfs/src/graph.y b/libglusterfs/src/graph.y
index 7df3479d701..e63febdc08b 100644
--- a/libglusterfs/src/graph.y
+++ b/libglusterfs/src/graph.y
@@ -22,11 +22,11 @@
 
 #define RELAX_POISONING
 
-#include "xlator.h"
-#include "graph-utils.h"
-#include "logging.h"
-#include "syscall.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/graph-utils.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 static int new_volume (char *name);
 static int volume_type (char *type);
@@ -123,7 +123,7 @@ new_volume (char *name)
         int          ret = 0;
 
         if (!name) {
-                gf_msg_debug ("parser", 0,"Invalid argument name: '%s'", name);
+                gf_msg_debug ("parser", 0,"Invalid argument name");
                 ret = -1;
                 goto out;
         }
@@ -164,7 +164,8 @@ new_volume (char *name)
                 goto out;
         }
 
-        curr->options = get_new_dict ();
+        INIT_LIST_HEAD(&curr->volume_options);
+        curr->options = dict_new ();
 
         if (!curr->options) {
                 GF_FREE (curr->name);
@@ -239,7 +240,7 @@ volume_option (char *key, char *value)
         }
 
         set_value = gf_strdup (value);
-	ret = dict_set_dynstr (curr->options, key, set_value);
+	ret = dict_set_option (curr->options, key, set_value);
 
         if (ret == 1) {
                 gf_msg ("parser", GF_LOG_ERROR, 0,
@@ -542,6 +543,9 @@ glusterfs_graph_new ()
 
         INIT_LIST_HEAD (&graph->list);
 
+        pthread_mutex_init(&graph->mutex, NULL);
+        pthread_cond_init(&graph->child_down_cond, NULL);
+
         gettimeofday (&graph->dob, NULL);
 
         return graph;
@@ -555,14 +559,14 @@ glusterfs_graph_construct (FILE *fp)
         int                tmp_fd = -1;
         glusterfs_graph_t *graph = NULL;
         FILE              *tmp_file = NULL;
-        char               template[PATH_MAX] = {0};
+        char               template[] = "/tmp/tmp.XXXXXX";
 	static pthread_mutex_t graph_mutex = PTHREAD_MUTEX_INITIALIZER;
 
         graph = glusterfs_graph_new ();
         if (!graph)
                 goto err;
 
-        strcpy (template, "/tmp/tmp.XXXXXX");
+        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
         tmp_fd = mkstemp (template);
         if (-1 == tmp_fd)
                 goto err;
diff --git a/libglusterfs/src/hashfn.c b/libglusterfs/src/hashfn.c
index 62f7ab87800..d2237e99f83 100644
--- a/libglusterfs/src/hashfn.c
+++ b/libglusterfs/src/hashfn.c
@@ -11,24 +11,11 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "hashfn.h"
-
-#define get16bits(d) (*((const uint16_t *) (d)))
+#define get16bits(d) (*((const uint16_t *)(d)))
 
 #define DM_DELTA 0x9E3779B9
-#define DM_FULLROUNDS 10        /* 32 is overkill, 16 is strong crypto */
-#define DM_PARTROUNDS 6         /* 6 gets complete mixing */
-
-
-uint32_t
-ReallySimpleHash (char *path, int len)
-{
-        uint32_t        hash = 0;
-        for (;len > 0; len--)
-                hash ^= (char)path[len];
-
-        return hash;
-}
+#define DM_FULLROUNDS 10 /* 32 is overkill, 16 is strong crypto */
+#define DM_PARTROUNDS 6  /* 6 gets complete mixing */
 
 /*
   This is apparently the "fastest hash function for strings".
@@ -37,146 +24,145 @@ ReallySimpleHash (char *path, int len)
 
 /* In any case make sure, you return 1 */
 
-uint32_t SuperFastHash (const char * data, int32_t len) {
-        uint32_t hash = len, tmp;
-        int32_t rem;
-
-        if (len <= 1 || data == NULL) return 1;
-
-        rem = len & 3;
-        len >>= 2;
-
-        /* Main loop */
-        for (;len > 0; len--) {
-                hash  += get16bits (data);
-                tmp    = (get16bits (data+2) << 11) ^ hash;
-                hash   = (hash << 16) ^ tmp;
-                data  += 2*sizeof (uint16_t);
-                hash  += hash >> 11;
-        }
-
-        /* Handle end cases */
-        switch (rem) {
-        case 3: hash += get16bits (data);
-                hash ^= hash << 16;
-                hash ^= data[sizeof (uint16_t)] << 18;
-                hash += hash >> 11;
-                break;
-        case 2: hash += get16bits (data);
-                hash ^= hash << 11;
-                hash += hash >> 17;
-                break;
-        case 1: hash += *data;
-                hash ^= hash << 10;
-                hash += hash >> 1;
-        }
-
-        /* Force "avalanching" of final 127 bits */
-        hash ^= hash << 3;
-        hash += hash >> 5;
-        hash ^= hash << 4;
-        hash += hash >> 17;
-        hash ^= hash << 25;
-        hash += hash >> 6;
-
-        return hash;
+uint32_t
+SuperFastHash(const char *data, int32_t len)
+{
+    uint32_t hash = len, tmp;
+    int32_t rem;
+
+    if (len <= 1 || data == NULL)
+        return 1;
+
+    rem = len & 3;
+    len >>= 2;
+
+    /* Main loop */
+    for (; len > 0; len--) {
+        hash += get16bits(data);
+        tmp = (get16bits(data + 2) << 11) ^ hash;
+        hash = (hash << 16) ^ tmp;
+        data += 2 * sizeof(uint16_t);
+        hash += hash >> 11;
+    }
+
+    /* Handle end cases */
+    switch (rem) {
+        case 3:
+            hash += get16bits(data);
+            hash ^= hash << 16;
+            hash ^= data[sizeof(uint16_t)] << 18;
+            hash += hash >> 11;
+            break;
+        case 2:
+            hash += get16bits(data);
+            hash ^= hash << 11;
+            hash += hash >> 17;
+            break;
+        case 1:
+            hash += *data;
+            hash ^= hash << 10;
+            hash += hash >> 1;
+    }
+
+    /* Force "avalanching" of final 127 bits */
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+
+    return hash;
 }
 
-
 /* Davies-Meyer hashing function implementation
  */
 static int
-dm_round (int rounds, uint32_t *array, uint32_t *h0, uint32_t *h1)
+dm_round(int rounds, uint32_t *array, uint32_t *h0, uint32_t *h1)
 {
-        uint32_t sum = 0;
-        int      n = 0;
-        uint32_t b0  = 0;
-        uint32_t b1  = 0;
-
-        b0 = *h0;
-        b1 = *h1;
-
-        n = rounds;
-
-        do {
-                sum += DM_DELTA;
-                b0  += ((b1 << 4) + array[0])
-                        ^ (b1 + sum)
-                        ^ ((b1 >> 5) + array[1]);
-                b1  += ((b0 << 4) + array[2])
-                        ^ (b0 + sum)
-                        ^ ((b0 >> 5) + array[3]);
-        } while (--n);
-
-        *h0 += b0;
-        *h1 += b1;
-
-        return 0;
-}
+    uint32_t sum = 0;
+    int n = 0;
+    uint32_t b0 = 0;
+    uint32_t b1 = 0;
+
+    b0 = *h0;
+    b1 = *h1;
+
+    n = rounds;
 
+    do {
+        sum += DM_DELTA;
+        b0 += ((b1 << 4) + array[0]) ^ (b1 + sum) ^ ((b1 >> 5) + array[1]);
+        b1 += ((b0 << 4) + array[2]) ^ (b0 + sum) ^ ((b0 >> 5) + array[3]);
+    } while (--n);
+
+    *h0 += b0;
+    *h1 += b1;
+
+    return 0;
+}
 
 uint32_t
-__pad (int len)
+__pad(int len)
 {
-        uint32_t pad = 0;
+    uint32_t pad = 0;
 
-        pad = (uint32_t) len | ((uint32_t) len << 8);
-        pad |= pad << 16;
+    pad = (uint32_t)len | ((uint32_t)len << 8);
+    pad |= pad << 16;
 
-        return pad;
+    return pad;
 }
 
 uint32_t
-gf_dm_hashfn (const char *msg, int len)
+gf_dm_hashfn(const char *msg, int len)
 {
-        uint32_t  h0 = 0x9464a485;
-        uint32_t  h1 = 0x542e1a94;
-        uint32_t  array[4];
-        uint32_t  pad = 0;
-        int       i = 0;
-        int       j = 0;
-        int       full_quads = 0;
-        int       full_words = 0;
-        int       full_bytes = 0;
-        uint32_t *intmsg = NULL;
-        int       word = 0;
-
-
-        intmsg = (uint32_t *) msg;
-        pad = __pad (len);
-
-        full_bytes   = len;
-        full_words   = len / 4;
-        full_quads   = len / 16;
-
-        for (i = 0; i < full_quads; i++) {
-                for (j = 0; j < 4; j++) {
-                        word     = *intmsg;
-                        array[j] = word;
-                        intmsg++;
-                        full_words--;
-                        full_bytes -= 4;
-                }
-                dm_round (DM_PARTROUNDS, &array[0], &h0, &h1);
-        }
-
+    uint32_t h0 = 0x9464a485;
+    uint32_t h1 = 0x542e1a94;
+    uint32_t array[4];
+    uint32_t pad = 0;
+    int i = 0;
+    int j = 0;
+    int full_quads = 0;
+    int full_words = 0;
+    int full_bytes = 0;
+    uint32_t *intmsg = NULL;
+    int word = 0;
+
+    intmsg = (uint32_t *)msg;
+    pad = __pad(len);
+
+    full_bytes = len;
+    full_words = len / 4;
+    full_quads = len / 16;
+
+    for (i = 0; i < full_quads; i++) {
         for (j = 0; j < 4; j++) {
-                if (full_words) {
-                        word     = *intmsg;
-                        array[j] = word;
-                        intmsg++;
-                        full_words--;
-                        full_bytes -= 4;
-                } else {
-                        array[j] = pad;
-                        while (full_bytes) {
-                                array[j] <<= 8;
-                                array[j] |= msg[len - full_bytes];
-                                full_bytes--;
-                        }
-                }
+            word = *intmsg;
+            array[j] = word;
+            intmsg++;
+            full_words--;
+            full_bytes -= 4;
+        }
+        dm_round(DM_PARTROUNDS, &array[0], &h0, &h1);
+    }
+
+    for (j = 0; j < 4; j++) {
+        if (full_words) {
+            word = *intmsg;
+            array[j] = word;
+            intmsg++;
+            full_words--;
+            full_bytes -= 4;
+        } else {
+            array[j] = pad;
+            while (full_bytes) {
+                array[j] <<= 8;
+                array[j] |= msg[len - full_bytes];
+                full_bytes--;
+            }
         }
-        dm_round (DM_FULLROUNDS, &array[0], &h0, &h1);
+    }
+    dm_round(DM_FULLROUNDS, &array[0], &h0, &h1);
 
-        return h0 ^ h1;
+    return h0 ^ h1;
 }
diff --git a/libglusterfs/src/iatt.h b/libglusterfs/src/iatt.h
deleted file mode 100644
index b8907598b18..00000000000
--- a/libglusterfs/src/iatt.h
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-
-#ifndef _IATT_H
-#define _IATT_H
-
-#if defined(GF_LINUX_HOST_OS)
-#include <sys/sysmacros.h> /* for makedev(3), major(3), minor(3) */
-#endif
-#include <sys/types.h>
-#include <sys/stat.h> /* for iatt <--> stat conversions */
-#include <unistd.h>
-
-#include "compat.h"
-#include "compat-uuid.h"
-
-typedef enum {
-        IA_INVAL = 0,
-        IA_IFREG,
-        IA_IFDIR,
-        IA_IFLNK,
-        IA_IFBLK,
-        IA_IFCHR,
-        IA_IFIFO,
-        IA_IFSOCK
-} ia_type_t;
-
-
-typedef struct {
-        uint8_t    suid:1;
-        uint8_t    sgid:1;
-        uint8_t    sticky:1;
-        struct {
-                uint8_t    read:1;
-                uint8_t    write:1;
-                uint8_t    exec:1;
-        } owner, group, other;
-} ia_prot_t;
-
-
-struct iatt {
-        uint64_t     ia_ino;        /* inode number */
-        uuid_t       ia_gfid;
-        uint64_t     ia_dev;        /* backing device ID */
-        ia_type_t    ia_type;       /* type of file */
-        ia_prot_t    ia_prot;       /* protection */
-        uint32_t     ia_nlink;      /* Link count */
-        uint32_t     ia_uid;        /* user ID of owner */
-        uint32_t     ia_gid;        /* group ID of owner */
-        uint64_t     ia_rdev;       /* device ID (if special file) */
-        uint64_t     ia_size;       /* file size in bytes */
-        uint32_t     ia_blksize;    /* blocksize for filesystem I/O */
-        uint64_t     ia_blocks;     /* number of 512B blocks allocated */
-        uint32_t     ia_atime;      /* last access time */
-        uint32_t     ia_atime_nsec;
-        uint32_t     ia_mtime;      /* last modification time */
-        uint32_t     ia_mtime_nsec;
-        uint32_t     ia_ctime;      /* last status change time */
-        uint32_t     ia_ctime_nsec;
-};
-
-
-#define IA_ISREG(t) (t == IA_IFREG)
-#define IA_ISDIR(t) (t == IA_IFDIR)
-#define IA_ISLNK(t) (t == IA_IFLNK)
-#define IA_ISBLK(t) (t == IA_IFBLK)
-#define IA_ISCHR(t) (t == IA_IFCHR)
-#define IA_ISFIFO(t) (t == IA_IFIFO)
-#define IA_ISSOCK(t) (t == IA_IFSOCK)
-#define IA_ISINVAL(t) (t == IA_INVAL)
-
-#define IA_PROT_RUSR(prot)      ((prot).owner.read == 1)
-#define IA_PROT_WUSR(prot)      ((prot).owner.write == 1)
-#define IA_PROT_XUSR(prot)      ((prot).owner.exec == 1)
-
-#define IA_PROT_RGRP(prot)      ((prot).group.read == 1)
-#define IA_PROT_WGRP(prot)      ((prot).group.write == 1)
-#define IA_PROT_XGRP(prot)      ((prot).group.exec == 1)
-
-#define IA_PROT_ROTH(prot)      ((prot).other.read == 1)
-#define IA_PROT_WOTH(prot)      ((prot).other.write == 1)
-#define IA_PROT_XOTH(prot)      ((prot).other.exec == 1)
-
-#define IA_PROT_SUID(prot)      ((prot).suid == 1)
-#define IA_PROT_SGID(prot)      ((prot).sgid == 1)
-#define IA_PROT_STCKY(prot)     ((prot).sticky == 1)
-
-#define IA_FILE_OR_DIR(t)       (IA_ISREG(t) || IA_ISDIR(t))
-
-static inline uint32_t
-ia_major (uint64_t ia_dev)
-{
-        return (uint32_t) (ia_dev >> 32);
-}
-
-
-static inline uint32_t
-ia_minor (uint64_t ia_dev)
-{
-        return (uint32_t) (ia_dev & 0xffffffff);
-}
-
-
-static inline uint64_t
-ia_makedev (uint32_t ia_maj, uint32_t ia_min)
-{
-        return ((((uint64_t) ia_maj) << 32) | ia_min);
-}
-
-
-static inline ia_prot_t
-ia_prot_from_st_mode (mode_t mode)
-{
-        ia_prot_t ia_prot = {0, };
-
-        if (mode & S_ISUID)
-                ia_prot.suid = 1;
-        if (mode & S_ISGID)
-                ia_prot.sgid = 1;
-        if (mode & S_ISVTX)
-                ia_prot.sticky = 1;
-
-        if (mode & S_IRUSR)
-                ia_prot.owner.read = 1;
-        if (mode & S_IWUSR)
-                ia_prot.owner.write = 1;
-        if (mode & S_IXUSR)
-                ia_prot.owner.exec = 1;
-
-        if (mode & S_IRGRP)
-                ia_prot.group.read = 1;
-        if (mode & S_IWGRP)
-                ia_prot.group.write = 1;
-        if (mode & S_IXGRP)
-                ia_prot.group.exec = 1;
-
-        if (mode & S_IROTH)
-                ia_prot.other.read = 1;
-        if (mode & S_IWOTH)
-                ia_prot.other.write = 1;
-        if (mode & S_IXOTH)
-                ia_prot.other.exec = 1;
-
-        return ia_prot;
-}
-
-
-static inline ia_type_t
-ia_type_from_st_mode (mode_t mode)
-{
-        ia_type_t type = IA_INVAL;
-
-        if (S_ISREG (mode))
-                type = IA_IFREG;
-        if (S_ISDIR (mode))
-                type = IA_IFDIR;
-        if (S_ISLNK (mode))
-                type = IA_IFLNK;
-        if (S_ISBLK (mode))
-                type = IA_IFBLK;
-        if (S_ISCHR (mode))
-                type = IA_IFCHR;
-        if (S_ISFIFO (mode))
-                type = IA_IFIFO;
-        if (S_ISSOCK (mode))
-                type = IA_IFSOCK;
-
-        return type;
-}
-
-
-static inline uint32_t
-st_mode_prot_from_ia (ia_prot_t prot)
-{
-        uint32_t  prot_bit = 0;
-
-        if (prot.suid)
-                prot_bit |= S_ISUID;
-        if (prot.sgid)
-                prot_bit |= S_ISGID;
-        if (prot.sticky)
-                prot_bit |= S_ISVTX;
-
-        if (prot.owner.read)
-                prot_bit |= S_IRUSR;
-        if (prot.owner.write)
-                prot_bit |= S_IWUSR;
-        if (prot.owner.exec)
-                prot_bit |= S_IXUSR;
-
-        if (prot.group.read)
-                prot_bit |= S_IRGRP;
-        if (prot.group.write)
-                prot_bit |= S_IWGRP;
-        if (prot.group.exec)
-                prot_bit |= S_IXGRP;
-
-        if (prot.other.read)
-                prot_bit |= S_IROTH;
-        if (prot.other.write)
-                prot_bit |= S_IWOTH;
-        if (prot.other.exec)
-                prot_bit |= S_IXOTH;
-
-        return prot_bit;
-}
-
-
-static inline mode_t
-st_mode_from_ia (ia_prot_t prot, ia_type_t type)
-{
-        mode_t    st_mode = 0;
-        uint32_t  type_bit = 0;
-        uint32_t  prot_bit = 0;
-
-        switch (type) {
-        case IA_IFREG:
-                type_bit = S_IFREG;
-                break;
-        case IA_IFDIR:
-                type_bit = S_IFDIR;
-                break;
-        case IA_IFLNK:
-                type_bit = S_IFLNK;
-                break;
-        case IA_IFBLK:
-                type_bit = S_IFBLK;
-                break;
-        case IA_IFCHR:
-                type_bit = S_IFCHR;
-                break;
-        case IA_IFIFO:
-                type_bit = S_IFIFO;
-                break;
-        case IA_IFSOCK:
-                type_bit = S_IFSOCK;
-                break;
-        case IA_INVAL:
-                break;
-        }
-
-        prot_bit = st_mode_prot_from_ia (prot);
-
-        st_mode = (type_bit | prot_bit);
-
-        return st_mode;
-}
-
-
-static inline int
-iatt_from_stat (struct iatt *iatt, struct stat *stat)
-{
-        iatt->ia_dev        = stat->st_dev;
-        iatt->ia_ino        = stat->st_ino;
-
-        iatt->ia_type       = ia_type_from_st_mode (stat->st_mode);
-        iatt->ia_prot       = ia_prot_from_st_mode (stat->st_mode);
-
-        iatt->ia_nlink      = stat->st_nlink;
-        iatt->ia_uid        = stat->st_uid;
-        iatt->ia_gid        = stat->st_gid;
-
-        iatt->ia_rdev       = ia_makedev (major (stat->st_rdev),
-                                          minor (stat->st_rdev));
-
-        iatt->ia_size       = stat->st_size;
-        iatt->ia_blksize    = stat->st_blksize;
-        iatt->ia_blocks     = stat->st_blocks;
-
-        /* There is a possibility that the backend FS (like XFS) can
-           allocate blocks beyond EOF for better performance reasons, which
-           results in 'st_blocks' with higher values than what is consumed by
-           the file descriptor. This would break few logic inside GlusterFS,
-           like quota behavior etc, thus we need the exact number of blocks
-           which are consumed by the file to the higher layers inside GlusterFS.
-           Currently, this logic won't work for sparse files (ie, file with
-           holes)
-        */
-        {
-                uint64_t maxblocks;
-
-                maxblocks = (iatt->ia_size + 511) / 512;
-
-                if (iatt->ia_blocks > maxblocks)
-                        iatt->ia_blocks = maxblocks;
-        }
-
-        iatt->ia_atime      = stat->st_atime;
-        iatt->ia_atime_nsec = ST_ATIM_NSEC (stat);
-
-        iatt->ia_mtime      = stat->st_mtime;
-        iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat);
-
-        iatt->ia_ctime      = stat->st_ctime;
-        iatt->ia_ctime_nsec = ST_CTIM_NSEC (stat);
-
-        return 0;
-}
-
-
-static inline int
-iatt_to_stat (struct iatt *iatt, struct stat *stat)
-{
-        stat->st_dev        = iatt->ia_dev;
-        stat->st_ino        = iatt->ia_ino;
-
-        stat->st_mode       = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
-
-        stat->st_nlink      = iatt->ia_nlink;
-        stat->st_uid        = iatt->ia_uid;
-        stat->st_gid        = iatt->ia_gid;
-
-        stat->st_rdev       = makedev (ia_major (iatt->ia_rdev),
-                                       ia_minor (iatt->ia_rdev));
-
-        stat->st_size       = iatt->ia_size;
-        stat->st_blksize    = iatt->ia_blksize;
-        stat->st_blocks     = iatt->ia_blocks;
-
-        stat->st_atime      = iatt->ia_atime;
-        ST_ATIM_NSEC_SET (stat, iatt->ia_atime_nsec);
-
-        stat->st_mtime      = iatt->ia_mtime;
-        ST_MTIM_NSEC_SET (stat, iatt->ia_mtime_nsec);
-
-        stat->st_ctime      = iatt->ia_ctime;
-        ST_CTIM_NSEC_SET (stat, iatt->ia_ctime_nsec);
-
-        return 0;
-}
-
-static inline int
-is_same_mode (ia_prot_t prot1, ia_prot_t prot2)
-{
-        int ret = 0;
-
-        if (st_mode_prot_from_ia(prot1) != st_mode_prot_from_ia(prot2))
-                ret = -1;
-
-        return ret;
-}
-
-
-#endif /* _IATT_H */
diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index b7b5ac6a7dd..dbadf77442d 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -8,692 +8,707 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "inode.h"
-#include "fd.h"
-#include "common-utils.h"
-#include "statedump.h"
+#include "glusterfs/inode.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/statedump.h"
 #include <pthread.h>
 #include <sys/types.h>
 #include <stdint.h>
-#include "list.h"
-#include <time.h>
+#include "glusterfs/list.h"
 #include <assert.h>
-#include "libglusterfs-messages.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 /* TODO:
    move latest accessed dentry to list_head of inode
 */
 
-#define INODE_DUMP_LIST(head, key_buf, key_prefix, list_type)           \
-        {                                                               \
-                int i = 1;                                              \
-                inode_t *inode = NULL;                                  \
-                list_for_each_entry (inode, head, list) {               \
-                        gf_proc_dump_build_key(key_buf, key_prefix,     \
-                                               "%s.%d",list_type, i++); \
-                        gf_proc_dump_add_section(key_buf);              \
-                        inode_dump(inode, key);                         \
-                }                                                       \
-        }
+// clang-format off
+/*
+
+Details as per Xavi:
+
+ I think we should have 3 lists: active, lru and invalidate.
+
+We'll need 3 things: refs, nlookups and invalidate_sent flag. Any change of
+refs, invalidate_sent flag and moving from one list to another must be done
+atomically.
+
+With this information, these are the states that cause a transition:
+
+    refs nlookups inv_sent    op
+      1      0        0      unref  -> refs = 0, active--->destroy
+      1      1        0      unref  -> refs = 0, active--->lru
+      1      1        0     forget  -> nlookups = 0, active--->active
+     *0      1        0     forget  -> nlookups = 0, lru--->destroy
+     *0      1        1     forget  -> nlookups = 0, invalidate--->destroy
+      0      1        0       ref   -> refs = 1, lru--->active
+      0      1        1       ref   -> refs = 1, inv_sent = 0, invalidate--->active
+      0      1        0    overflow -> refs = 1, inv_sent = 1, lru--->invalidate
+      1      1        1      unref  -> refs = 0, invalidate--->invalidate
+      1      1        1     forget  -> nlookups = 0, inv_sent = 0, invalidate--->active
+
+(*) technically these combinations cannot happen because a forget sent by the
+kernel first calls ref() and then unref(). However it's equivalent.
+
+overflow means that lru list has grown beyond the limit and the inode needs to
+be invalidated. All other combinations do not cause a change in state or are not
+possible.
+
+Based on this, the code could be similar to this:
+
+    ref(inode, inv)
+    {
+        if (refs == 0) {
+            if (inv_sent) {
+                invalidate_count--;
+                inv_sent = 0;
+            } else {
+                lru_count--;
+            }
+            if (inv) {
+                inv_sent = 1;
+                invalidate_count++;
+                list_move(inode, invalidate);
+            } else {
+                active_count++;
+                list_move(inode, active);
+            }
+        }
+        refs++;
+    }
+
+    unref(inode, clear)
+    {
+        if (clear && inv_sent) {
+            // there is a case of fuse itself sending forget, without
+            // invalidate, after entry delete, like unlink(), rmdir().
+            inv_sent = 0;
+            invalidate_count--;
+            active_count++;
+            list_move(inode, active);
+        }
+        refs--;
+        if ((refs == 0) && !inv_sent) {
+            active_count--;
+            if (nlookups == 0) {
+                destroy(inode);
+            } else {
+                lru_count++;
+                list_move(inode, lru);
+            }
+        }
+    }
+
+    forget(inode)
+    {
+        ref(inode, false);
+        nlookups--;
+        unref(inode, true);
+    }
+
+    overflow(inode)
+    {
+        ref(inode, true);
+        invalidator(inode);
+        unref(inode, false);
+    }
+
+*/
+// clang-format on
+
+#define INODE_DUMP_LIST(head, key_buf, key_prefix, list_type)                  \
+    {                                                                          \
+        int i = 1;                                                             \
+        inode_t *inode = NULL;                                                 \
+        list_for_each_entry(inode, head, list)                                 \
+        {                                                                      \
+            gf_proc_dump_build_key(key_buf, key_prefix, "%s.%d", list_type,    \
+                                   i++);                                       \
+            gf_proc_dump_add_section("%s", key_buf);                           \
+            inode_dump(inode, key);                                            \
+        }                                                                      \
+    }
 
 static inode_t *
-__inode_unref (inode_t *inode);
+__inode_unref(inode_t *inode, bool clear);
 
 static int
-inode_table_prune (inode_table_t *table);
+inode_table_prune(inode_table_t *table);
 
 void
-fd_dump (struct list_head *head, char *prefix);
+fd_dump(struct list_head *head, char *prefix);
 
 static int
-hash_dentry (inode_t *parent, const char *name, int mod)
+hash_dentry(inode_t *parent, const char *name, int mod)
 {
-        int hash = 0;
-        int ret = 0;
+    int hash = 0;
+    int ret = 0;
 
-        hash = *name;
-        if (hash) {
-                for (name += 1; *name != '\0'; name++) {
-                        hash = (hash << 5) - hash + *name;
-                }
+    hash = *name;
+    if (hash) {
+        for (name += 1; *name != '\0'; name++) {
+            hash = (hash << 5) - hash + *name;
         }
-        ret = (hash + (unsigned long)parent) % mod;
+    }
+    ret = (hash + (unsigned long)parent) % mod;
 
-        return ret;
+    return ret;
 }
 
-
 static int
-hash_gfid (uuid_t uuid, int mod)
+hash_gfid(uuid_t uuid, int mod)
 {
-        int ret = 0;
-
-        ret = uuid[15] + (uuid[14] << 8);
-
-        return ret;
+    return ((uuid[15] + (uuid[14] << 8)) % mod);
 }
 
-
 static void
-__dentry_hash (dentry_t *dentry)
+__dentry_hash(dentry_t *dentry, const int hash)
 {
-        inode_table_t   *table = NULL;
-        int              hash = 0;
-
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
+    inode_table_t *table = NULL;
 
-        table = dentry->inode->table;
-        hash = hash_dentry (dentry->parent, dentry->name,
-                            table->hashsize);
+    table = dentry->inode->table;
 
-        list_del_init (&dentry->hash);
-        list_add (&dentry->hash, &table->name_hash[hash]);
+    list_del_init(&dentry->hash);
+    list_add(&dentry->hash, &table->name_hash[hash]);
 }
 
-
 static int
-__is_dentry_hashed (dentry_t *dentry)
+__is_dentry_hashed(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return 0;
-        }
-
-        return !list_empty (&dentry->hash);
+    return !list_empty(&dentry->hash);
 }
 
-
 static void
-__dentry_unhash (dentry_t *dentry)
+__dentry_unhash(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
-
-        list_del_init (&dentry->hash);
+    list_del_init(&dentry->hash);
 }
 
-
 static void
-__dentry_unset (dentry_t *dentry)
+dentry_destroy(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
-
-        __dentry_unhash (dentry);
+    if (!dentry)
+        return;
 
-        list_del_init (&dentry->inode_list);
+    GF_FREE(dentry->name);
+    dentry->name = NULL;
+    mem_put(dentry);
 
-        GF_FREE (dentry->name);
-        dentry->name = NULL;
+    return;
+}
 
-        if (dentry->parent) {
-                __inode_unref (dentry->parent);
-                dentry->parent = NULL;
-        }
+static dentry_t *
+__dentry_unset(dentry_t *dentry)
+{
+    if (!dentry)
+        return NULL;
 
-        mem_put (dentry);
-}
+    __dentry_unhash(dentry);
 
+    list_del_init(&dentry->inode_list);
 
-static int
-__foreach_ancestor_dentry (dentry_t *dentry,
-                           int (per_dentry_fn) (dentry_t *dentry,
-                                                void *data),
-                           void *data)
-{
-        inode_t  *parent = NULL;
-        dentry_t *each = NULL;
-        int       ret = 0;
-
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return 0;
-        }
+    if (dentry->parent) {
+        __inode_unref(dentry->parent, false);
+        dentry->parent = NULL;
+    }
 
-        ret = per_dentry_fn (dentry, data);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_PER_DENTRY_FAILED, "per dentry fn returned %d",
-                        ret);
-                goto out;
-        }
+    return dentry;
+}
 
-        parent = dentry->parent;
-        if (!parent) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_PARENT_DENTRY_NOT_FOUND,
-                        "parent not found");
-                goto out;
-        }
+static int
+__foreach_ancestor_dentry(dentry_t *dentry,
+                          int(per_dentry_fn)(dentry_t *dentry, void *data),
+                          void *data)
+{
+    inode_t *parent = NULL;
+    dentry_t *each = NULL;
+    int ret = 0;
 
-        list_for_each_entry (each, &parent->dentry_list, inode_list) {
-                ret = __foreach_ancestor_dentry (each, per_dentry_fn, data);
-                if (ret)
-                        goto out;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return 0;
+    }
+
+    ret = per_dentry_fn(dentry, data);
+    if (ret) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PER_DENTRY_FAILED,
+                "ret=%d", ret, NULL);
+        goto out;
+    }
+
+    parent = dentry->parent;
+    if (!parent) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PARENT_DENTRY_NOT_FOUND,
+                NULL);
+        goto out;
+    }
+
+    list_for_each_entry(each, &parent->dentry_list, inode_list)
+    {
+        ret = __foreach_ancestor_dentry(each, per_dentry_fn, data);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__check_cycle (dentry_t *a_dentry, void *data)
+__check_cycle(dentry_t *a_dentry, void *data)
 {
-        inode_t *link_inode = NULL;
+    inode_t *link_inode = NULL;
 
-        link_inode = data;
+    link_inode = data;
 
-        if (a_dentry->parent == link_inode)
-                return 1;
+    if (a_dentry->parent == link_inode)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-__is_dentry_cyclic (dentry_t *dentry)
+__is_dentry_cyclic(dentry_t *dentry)
 {
-        int       ret = 0;
-        inode_t  *inode = NULL;
-        char     *name = "<nul>";
-
-        ret = __foreach_ancestor_dentry (dentry, __check_cycle,
-                                         dentry->inode);
-        if (ret) {
-                inode = dentry->inode;
-
-                if (dentry->name)
-                        name = dentry->name;
+    int ret = 0;
 
-                gf_msg (dentry->inode->table->name, GF_LOG_CRITICAL, 0,
-                        LG_MSG_DENTRY_CYCLIC_LOOP, "detected cyclic loop "
-                        "formation during inode linkage. inode (%s) linking "
-                        "under itself as %s", uuid_utoa (inode->gfid), name);
-        }
+    ret = __foreach_ancestor_dentry(dentry, __check_cycle, dentry->inode);
+    if (ret) {
+        gf_smsg(dentry->inode->table->name, GF_LOG_CRITICAL, 0,
+                LG_MSG_DENTRY_CYCLIC_LOOP, "gfid=%s name=-%s",
+                uuid_utoa(dentry->inode->gfid), dentry->name, NULL);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__inode_unhash (inode_t *inode)
+__inode_unhash(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
-
-        list_del_init (&inode->hash);
+    list_del_init(&inode->hash);
 }
 
-
 static int
-__is_inode_hashed (inode_t *inode)
+__is_inode_hashed(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
-
-        return !list_empty (&inode->hash);
+    return !list_empty(&inode->hash);
 }
 
-
 static void
-__inode_hash (inode_t *inode)
+__inode_hash(inode_t *inode, const int hash)
 {
-        inode_table_t *table = NULL;
-        int            hash = 0;
-
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
-
-        table = inode->table;
-        hash = hash_gfid (inode->gfid, 65536);
+    inode_table_t *table = inode->table;
 
-        list_del_init (&inode->hash);
-        list_add (&inode->hash, &table->inode_hash[hash]);
+    list_del_init(&inode->hash);
+    list_add(&inode->hash, &table->inode_hash[hash]);
 }
 
-
 static dentry_t *
-__dentry_search_for_inode (inode_t *inode, uuid_t pargfid, const char *name)
+__dentry_search_for_inode(inode_t *inode, uuid_t pargfid, const char *name)
 {
-        dentry_t *dentry = NULL;
-        dentry_t *tmp = NULL;
-
-        if (!inode || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "inode || name not found");
-                return NULL;
-        }
+    dentry_t *dentry = NULL;
+    dentry_t *tmp = NULL;
 
-        /* earlier, just the ino was sent, which could have been 0, now
-           we deal with gfid, and if sent gfid is null or 0, no need to
-           continue with the check */
-        if (!pargfid || gf_uuid_is_null (pargfid))
-                return NULL;
+    /* earlier, just the ino was sent, which could have been 0, now
+       we deal with gfid, and if sent gfid is null or 0, no need to
+       continue with the check */
+    if (!pargfid || gf_uuid_is_null(pargfid))
+        return NULL;
 
-        list_for_each_entry (tmp, &inode->dentry_list, inode_list) {
-                if ((gf_uuid_compare (tmp->parent->gfid, pargfid) == 0) &&
-                    !strcmp (tmp->name, name)) {
-                        dentry = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &inode->dentry_list, inode_list)
+    {
+        if ((gf_uuid_compare(tmp->parent->gfid, pargfid) == 0) &&
+            !strcmp(tmp->name, name)) {
+            dentry = tmp;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 static void
-__inode_ctx_free (inode_t *inode)
+__inode_ctx_free(inode_t *inode)
 {
-        int          index = 0;
-        xlator_t    *xl = NULL;
-        xlator_t    *old_THIS = NULL;
-
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    int index = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
 
-        if (!inode->_ctx) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_CTX_NULL,
-                        "_ctx not found");
-                goto noctx;
-        }
+    if (!inode->_ctx) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_CTX_NULL, NULL);
+        goto noctx;
+    }
 
-        for (index = 0; index < inode->table->xl->graph->xl_count; index++) {
-                if (inode->_ctx[index].value1 || inode->_ctx[index].value2) {
-                        xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
-                        old_THIS = THIS;
-                        THIS = xl;
-                        if (xl->cbks->forget)
-                                xl->cbks->forget (xl, inode);
-                        THIS = old_THIS;
-                }
+    for (index = 0; index < inode->table->ctxcount; index++) {
+        if (inode->_ctx[index].value1 || inode->_ctx[index].value2) {
+            xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
+            if (xl && !xl->call_cleanup && xl->cbks->forget) {
+                old_THIS = THIS;
+                THIS = xl;
+                xl->cbks->forget(xl, inode);
+                THIS = old_THIS;
+            }
         }
+    }
 
-        GF_FREE (inode->_ctx);
-        inode->_ctx = NULL;
+    GF_FREE(inode->_ctx);
+    inode->_ctx = NULL;
 
 noctx:
-        return;
+    return;
 }
 
 static void
-__inode_destroy (inode_t *inode)
+__inode_destroy(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    __inode_ctx_free(inode);
 
-        __inode_ctx_free (inode);
-
-        LOCK_DESTROY (&inode->lock);
-        //  memset (inode, 0xb, sizeof (*inode));
-        mem_put (inode);
+    LOCK_DESTROY(&inode->lock);
+    //  memset (inode, 0xb, sizeof (*inode));
+    mem_put(inode);
 }
 
 void
-inode_ctx_merge (fd_t *fd, inode_t *inode, inode_t *linked_inode)
+inode_ctx_merge(fd_t *fd, inode_t *inode, inode_t *linked_inode)
 {
-        int       index    = 0;
-        xlator_t *xl       = NULL;
-        xlator_t *old_THIS = NULL;
+    int index = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
 
-        if (!fd || !inode || !linked_inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid inode");
-                return;
-        }
+    if (!fd || !inode || !linked_inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode");
+        return;
+    }
 
-        if (!inode->_ctx || !linked_inode->_ctx) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "invalid inode context");
-                return;
-        }
+    if (!inode->_ctx || !linked_inode->_ctx) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode context");
+        return;
+    }
 
-        for (; index < inode->table->ctxcount; index++) {
-                if (inode->_ctx[index].xl_key) {
-                        xl = (xlator_t *)(long) inode->_ctx[index].xl_key;
+    for (; index < inode->table->ctxcount; index++) {
+        if (inode->_ctx[index].xl_key) {
+            xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
 
-                        old_THIS = THIS;
-                        THIS = xl;
-                        if (xl->cbks->ictxmerge)
-                                xl->cbks->ictxmerge (xl, fd,
-                                                     inode, linked_inode);
-                        THIS = old_THIS;
-                }
+            old_THIS = THIS;
+            THIS = xl;
+            if (xl->cbks->ictxmerge)
+                xl->cbks->ictxmerge(xl, fd, inode, linked_inode);
+            THIS = old_THIS;
         }
+    }
 }
 
 static void
-__inode_activate (inode_t *inode)
+__inode_activate(inode_t *inode)
 {
-        if (!inode)
-                return;
-
-        list_move (&inode->list, &inode->table->active);
-        inode->table->active_size++;
+    list_move(&inode->list, &inode->table->active);
+    inode->table->active_size++;
 }
 
-
 static void
-__inode_passivate (inode_t *inode)
+__inode_passivate(inode_t *inode)
 {
-        dentry_t      *dentry = NULL;
-        dentry_t      *t = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *t = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
-
-        list_move_tail (&inode->list, &inode->table->lru);
-        inode->table->lru_size++;
+    list_move_tail(&inode->list, &inode->table->lru);
+    inode->table->lru_size++;
 
-        list_for_each_entry_safe (dentry, t, &inode->dentry_list, inode_list) {
-                if (!__is_dentry_hashed (dentry))
-                        __dentry_unset (dentry);
-        }
+    list_for_each_entry_safe(dentry, t, &inode->dentry_list, inode_list)
+    {
+        if (!__is_dentry_hashed(dentry))
+            dentry_destroy(__dentry_unset(dentry));
+    }
 }
 
-
 static void
-__inode_retire (inode_t *inode)
+__inode_retire(inode_t *inode)
 {
-        dentry_t      *dentry = NULL;
-        dentry_t      *t = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *t = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
-
-        list_move_tail (&inode->list, &inode->table->purge);
-        inode->table->purge_size++;
+    list_move_tail(&inode->list, &inode->table->purge);
+    inode->table->purge_size++;
 
-        __inode_unhash (inode);
+    __inode_unhash(inode);
 
-        list_for_each_entry_safe (dentry, t, &inode->dentry_list, inode_list) {
-                __dentry_unset (dentry);
-        }
+    list_for_each_entry_safe(dentry, t, &inode->dentry_list, inode_list)
+    {
+        dentry_destroy(__dentry_unset(dentry));
+    }
 }
 
-
 static int
-__inode_get_xl_index (inode_t *inode, xlator_t *xlator)
+__inode_get_xl_index(inode_t *inode, xlator_t *xlator)
 {
-        int set_idx = -1;
+    int set_idx = -1;
 
-        if ((inode->_ctx[xlator->xl_id].xl_key != NULL) &&
-            (inode->_ctx[xlator->xl_id].xl_key != xlator))
-                goto out;
+    if ((inode->_ctx[xlator->xl_id].xl_key != NULL) &&
+        (inode->_ctx[xlator->xl_id].xl_key != xlator))
+        goto out;
 
-        set_idx = xlator->xl_id;
-        inode->_ctx[set_idx].xl_key = xlator;
+    set_idx = xlator->xl_id;
+    inode->_ctx[set_idx].xl_key = xlator;
 
 out:
-        return set_idx;
+    return set_idx;
 }
 
-
 static inode_t *
-__inode_unref (inode_t *inode)
+__inode_unref(inode_t *inode, bool clear)
 {
-        int       index = 0;
-        xlator_t *this  = NULL;
-
-        if (!inode)
-                return NULL;
+    int index = 0;
+    xlator_t *this = NULL;
+    uint64_t nlookup = 0;
 
-        this = THIS;
+    /*
+     * Root inode should always be in active list of inode table. So unrefs
+     * on root inode are no-ops.
+     */
+    if (__is_root_gfid(inode->gfid))
+        return inode;
 
+    /*
+     * No need to acquire inode table's lock
+     * as __inode_unref is called after acquiding
+     * the inode table's lock.
+     */
+    if (inode->table->cleanup_started && !inode->ref)
         /*
-         * Root inode should always be in active list of inode table. So unrefs
-         * on root inode are no-ops.
+         * There is a good chance that, the inode
+         * on which unref came has already been
+         * zero refed and added to the purge list.
+         * This can happen when inode table is
+         * being destroyed (glfs_fini is something
+         * which destroys the inode table).
+         *
+         * Consider a directory 'a' which has a file
+         * 'b'. Now as part of inode table destruction
+         * zero refing of inodes does not happen from
+         * leaf to the root. It happens in the order
+         * inodes are present in the list. So, in this
+         * example, the dentry of 'b' would have its
+         * parent set to the inode of 'a'. So if
+         * 'a' gets zero refed first (as part of
+         * inode table cleanup) and then 'b' has to
+         * zero refed, then dentry_unset is called on
+         * the dentry of 'b' and it further goes on to
+         * call inode_unref on b's parent which is 'a'.
+         * In this situation, GF_ASSERT would be called
+         * below as the refcount of 'a' has been already set
+         * to zero.
+         *
+         * So return the inode if the inode table cleanup
+         * has already started and inode refcount is 0.
          */
-        if (__is_root_gfid(inode->gfid))
-                return inode;
+        return inode;
 
-        GF_ASSERT (inode->ref);
+    this = THIS;
 
-        --inode->ref;
+    if (clear && inode->in_invalidate_list) {
+        inode->in_invalidate_list = false;
+        inode->table->invalidate_size--;
+        __inode_activate(inode);
+    }
+    GF_ASSERT(inode->ref);
 
-        index = __inode_get_xl_index (inode, this);
-        if (index >= 0) {
-                inode->_ctx[index].xl_key = this;
-                inode->_ctx[index].ref--;
-        }
+    --inode->ref;
 
-        if (!inode->ref) {
-                inode->table->active_size--;
+    index = __inode_get_xl_index(inode, this);
+    if (index >= 0) {
+        inode->_ctx[index].xl_key = this;
+        inode->_ctx[index].ref--;
+    }
 
-                if (inode->nlookup)
-                        __inode_passivate (inode);
-                else
-                        __inode_retire (inode);
-        }
+    if (!inode->ref && !inode->in_invalidate_list) {
+        inode->table->active_size--;
 
-        return inode;
-}
+        nlookup = GF_ATOMIC_GET(inode->nlookup);
+        if (nlookup)
+            __inode_passivate(inode);
+        else
+            __inode_retire(inode);
+    }
 
+    return inode;
+}
 
 static inode_t *
-__inode_ref (inode_t *inode)
+__inode_ref(inode_t *inode, bool is_invalidate)
 {
-        int       index = 0;
-        xlator_t *this  = NULL;
+    int index = 0;
+    xlator_t *this = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        this = THIS;
+    this = THIS;
 
-        if (!inode->ref) {
-                inode->table->lru_size--;
-                __inode_activate (inode);
-        }
+    /*
+     * Root inode should always be in active list of inode table. So unrefs
+     * on root inode are no-ops. If we do not allow unrefs but allow refs,
+     * it leads to refcount overflows and deleting and adding the inode
+     * to active-list, which is ugly. active_size (check __inode_activate)
+     * in inode table increases which is wrong. So just keep the ref
+     * count as 1 always
+     */
+    if (__is_root_gfid(inode->gfid) && inode->ref)
+        return inode;
 
-        /*
-         * Root inode should always be in active list of inode table. So unrefs
-         * on root inode are no-ops. If we do not allow unrefs but allow refs,
-         * it leads to refcount overflows and deleting and adding the inode
-         * to active-list, which is ugly. active_size (check __inode_activate)
-         * in inode table increases which is wrong. So just keep the ref
-         * count as 1 always
-         */
-        if (__is_root_gfid(inode->gfid) && inode->ref)
-                return inode;
+    if (!inode->ref) {
+        if (inode->in_invalidate_list) {
+            inode->in_invalidate_list = false;
+            inode->table->invalidate_size--;
+        } else {
+            inode->table->lru_size--;
+        }
+        if (is_invalidate) {
+            inode->in_invalidate_list = true;
+            inode->table->invalidate_size++;
+            list_move_tail(&inode->list, &inode->table->invalidate);
+        } else {
+            __inode_activate(inode);
+        }
+    }
 
-        inode->ref++;
+    inode->ref++;
 
-        index = __inode_get_xl_index (inode, this);
-        if (index >= 0) {
-                inode->_ctx[index].xl_key = this;
-                inode->_ctx[index].ref++;
-        }
+    index = __inode_get_xl_index(inode, this);
+    if (index >= 0) {
+        inode->_ctx[index].xl_key = this;
+        inode->_ctx[index].ref++;
+    }
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_unref (inode_t *inode)
+inode_unref(inode_t *inode)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_unref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_unref(inode, false);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_ref (inode_t *inode)
+inode_ref(inode_t *inode)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_ref(inode, false);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 static dentry_t *
-__dentry_create (inode_t *inode, inode_t *parent, const char *name)
+dentry_create(inode_t *inode, inode_t *parent, const char *name)
 {
-        dentry_t      *newd = NULL;
-
-        if (!inode || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "inode || parent || name not found");
-                return NULL;
-        }
-
-        newd = mem_get0 (parent->table->dentry_pool);
-        if (newd == NULL) {
-                goto out;
-        }
+    dentry_t *newd = NULL;
 
-        INIT_LIST_HEAD (&newd->inode_list);
-        INIT_LIST_HEAD (&newd->hash);
+    newd = mem_get0(parent->table->dentry_pool);
+    if (newd == NULL) {
+        goto out;
+    }
 
-        newd->name = gf_strdup (name);
-        if (newd->name == NULL) {
-                mem_put (newd);
-                newd = NULL;
-                goto out;
-        }
+    INIT_LIST_HEAD(&newd->inode_list);
+    INIT_LIST_HEAD(&newd->hash);
 
-        if (parent)
-                newd->parent = __inode_ref (parent);
+    newd->name = gf_strdup(name);
+    if (newd->name == NULL) {
+        mem_put(newd);
+        newd = NULL;
+        goto out;
+    }
 
-        list_add (&newd->inode_list, &inode->dentry_list);
-        newd->inode = inode;
+    newd->inode = inode;
 
 out:
-        return newd;
+    return newd;
 }
 
-
 static inode_t *
-__inode_create (inode_table_t *table)
+inode_create(inode_table_t *table)
 {
-        inode_t  *newi = NULL;
-
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                return NULL;
-        }
+    inode_t *newi = NULL;
 
-        newi = mem_get0 (table->inode_pool);
-        if (!newi) {
-                goto out;
-        }
+    newi = mem_get0(table->inode_pool);
+    if (!newi) {
+        goto out;
+    }
 
-        newi->table = table;
+    newi->table = table;
 
-        LOCK_INIT (&newi->lock);
+    LOCK_INIT(&newi->lock);
 
-        INIT_LIST_HEAD (&newi->fd_list);
-        INIT_LIST_HEAD (&newi->list);
-        INIT_LIST_HEAD (&newi->hash);
-        INIT_LIST_HEAD (&newi->dentry_list);
+    INIT_LIST_HEAD(&newi->fd_list);
+    INIT_LIST_HEAD(&newi->list);
+    INIT_LIST_HEAD(&newi->hash);
+    INIT_LIST_HEAD(&newi->dentry_list);
 
-        newi->_ctx = GF_CALLOC (1,
-                                (sizeof (struct _inode_ctx) * table->ctxcount),
-                                gf_common_mt_inode_ctx);
-        if (newi->_ctx == NULL) {
-                LOCK_DESTROY (&newi->lock);
-                mem_put (newi);
-                newi = NULL;
-                goto out;
-        }
-
-        list_add (&newi->list, &table->lru);
-        table->lru_size++;
+    newi->_ctx = GF_CALLOC(1, (sizeof(struct _inode_ctx) * table->ctxcount),
+                           gf_common_mt_inode_ctx);
+    if (newi->_ctx == NULL) {
+        LOCK_DESTROY(&newi->lock);
+        mem_put(newi);
+        newi = NULL;
+        goto out;
+    }
 
 out:
-
-        return newi;
+    return newi;
 }
 
-
 inode_t *
-inode_new (inode_table_t *table)
+inode_new(inode_table_t *table)
 {
-        inode_t *inode = NULL;
+    inode_t *inode = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "inode not "
-                                  "found");
-                return NULL;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "inode not "
+                         "found");
+        return NULL;
+    }
 
-        pthread_mutex_lock (&table->lock);
+    inode = inode_create(table);
+    if (inode) {
+        pthread_mutex_lock(&table->lock);
         {
-                inode = __inode_create (table);
-                if (inode != NULL) {
-                        __inode_ref (inode);
-                }
+            list_add(&inode->list, &table->lru);
+            table->lru_size++;
+            __inode_ref(inode, false);
         }
-        pthread_mutex_unlock (&table->lock);
+        pthread_mutex_unlock(&table->lock);
+    }
 
-        return inode;
+    return inode;
 }
 
-
 /* Reduce the ref count by value 'nref'
  * Args:
  * inode - address of the inode to operate on
@@ -704,1240 +719,1297 @@ inode_new (inode_table_t *table)
  * hence to be used only in destructor functions and not otherwise.
  */
 static inode_t *
-__inode_ref_reduce_by_n (inode_t *inode, uint64_t nref)
+__inode_ref_reduce_by_n(inode_t *inode, uint64_t nref)
 {
-        if (!inode)
-                return NULL;
+    uint64_t nlookup = 0;
 
-        GF_ASSERT (inode->ref >= nref);
+    GF_ASSERT(inode->ref >= nref);
 
-        inode->ref -= nref;
+    inode->ref -= nref;
 
-        if (!nref)
-                inode->ref = 0;
+    if (!nref)
+        inode->ref = 0;
 
-        if (!inode->ref) {
-                inode->table->active_size--;
+    if (!inode->ref) {
+        inode->table->active_size--;
 
-                if (inode->nlookup)
-                        __inode_passivate (inode);
-                else
-                        __inode_retire (inode);
-        }
+        nlookup = GF_ATOMIC_GET(inode->nlookup);
+        if (nlookup)
+            __inode_passivate(inode);
+        else
+            __inode_retire(inode);
+    }
 
-        return inode;
+    return inode;
 }
 
-
 static inode_t *
-__inode_lookup (inode_t *inode)
+inode_forget_atomic(inode_t *inode, uint64_t nlookup)
 {
-        if (!inode)
-                return NULL;
+    uint64_t inode_lookup = 0;
 
-        inode->nlookup++;
+    if (!inode)
+        return NULL;
 
-        return inode;
-}
-
-
-static inode_t *
-__inode_forget (inode_t *inode, uint64_t nlookup)
-{
-        if (!inode)
-                return NULL;
-
-        GF_ASSERT (inode->nlookup >= nlookup);
-
-        inode->nlookup -= nlookup;
+    if (nlookup == 0) {
+        GF_ATOMIC_INIT(inode->nlookup, 0);
+    } else {
+        inode_lookup = GF_ATOMIC_FETCH_SUB(inode->nlookup, nlookup);
+        GF_ASSERT(inode_lookup >= nlookup);
+    }
 
-        if (!nlookup)
-                inode->nlookup = 0;
-
-        return inode;
+    return inode;
 }
 
-
 dentry_t *
-__dentry_grep (inode_table_t *table, inode_t *parent, const char *name)
+__dentry_grep(inode_table_t *table, inode_t *parent, const char *name,
+              const int hash)
 {
-        int       hash = 0;
-        dentry_t *dentry = NULL;
-        dentry_t *tmp = NULL;
-
-        if (!table || !name || !parent)
-                return NULL;
-
-        hash = hash_dentry (parent, name, table->hashsize);
+    dentry_t *dentry = NULL;
+    dentry_t *tmp = NULL;
 
-        list_for_each_entry (tmp, &table->name_hash[hash], hash) {
-                if (tmp->parent == parent && !strcmp (tmp->name, name)) {
-                        dentry = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &table->name_hash[hash], hash)
+    {
+        if (tmp->parent == parent && !strcmp(tmp->name, name)) {
+            dentry = tmp;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 inode_t *
-inode_grep (inode_table_t *table, inode_t *parent, const char *name)
+inode_grep(inode_table_t *table, inode_t *parent, const char *name)
 {
-        inode_t   *inode = NULL;
-        dentry_t  *dentry = NULL;
+    inode_t *inode = NULL;
+    dentry_t *dentry = NULL;
 
-        if (!table || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "table || parent || name"
-                                  " not found");
-                return NULL;
-        }
-
-        pthread_mutex_lock (&table->lock);
-        {
-                dentry = __dentry_grep (table, parent, name);
+    if (!table || !parent || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "table || parent || name"
+                         " not found");
+        return NULL;
+    }
 
-                if (dentry)
-                        inode = dentry->inode;
+    int hash = hash_dentry(parent, name, table->hashsize);
 
-                if (inode)
-                        __inode_ref (inode);
+    pthread_mutex_lock(&table->lock);
+    {
+        dentry = __dentry_grep(table, parent, name, hash);
+        if (dentry) {
+            inode = dentry->inode;
+            if (inode)
+                __inode_ref(inode, false);
         }
-        pthread_mutex_unlock (&table->lock);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_resolve (inode_table_t *table, char *path)
+inode_resolve(inode_table_t *table, char *path)
 {
-        char    *tmp   = NULL, *bname = NULL, *str = NULL, *saveptr = NULL;
-        inode_t *inode = NULL, *parent = NULL;
-
-        if ((path == NULL) || (table == NULL)) {
-                goto out;
-        }
+    char *tmp = NULL, *bname = NULL, *str = NULL, *saveptr = NULL;
+    inode_t *inode = NULL, *parent = NULL;
 
-        parent = inode_ref (table->root);
-        str = tmp = gf_strdup (path);
+    if ((path == NULL) || (table == NULL)) {
+        goto out;
+    }
 
-        while (1) {
-                bname = strtok_r (str, "/", &saveptr);
-                if (bname == NULL) {
-                        break;
-                }
+    parent = inode_ref(table->root);
+    str = tmp = gf_strdup(path);
+    if (str == NULL) {
+        goto out;
+    }
 
-                if (inode != NULL) {
-                        inode_unref (inode);
-                }
+    while (1) {
+        bname = strtok_r(str, "/", &saveptr);
+        if (bname == NULL) {
+            break;
+        }
 
-                inode = inode_grep (table, parent, bname);
-                if (inode == NULL) {
-                        break;
-                }
+        if (inode != NULL) {
+            inode_unref(inode);
+        }
 
-                if (parent != NULL) {
-                        inode_unref (parent);
-                }
+        inode = inode_grep(table, parent, bname);
+        if (inode == NULL) {
+            break;
+        }
 
-                parent = inode_ref (inode);
-                str = NULL;
+        if (parent != NULL) {
+            inode_unref(parent);
         }
 
-        inode_unref (parent);
-        GF_FREE (tmp);
+        parent = inode_ref(inode);
+        str = NULL;
+    }
+
+    inode_unref(parent);
+    GF_FREE(tmp);
 out:
-        return inode;
+    return inode;
 }
 
-
 int
-inode_grep_for_gfid (inode_table_t *table, inode_t *parent, const char *name,
-                     uuid_t gfid, ia_type_t *type)
-{
-        inode_t   *inode = NULL;
-        dentry_t  *dentry = NULL;
-        int        ret = -1;
-
-        if (!table || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "table || parent || name"
-                                  " not found");
-                return ret;
-        }
+inode_grep_for_gfid(inode_table_t *table, inode_t *parent, const char *name,
+                    uuid_t gfid, ia_type_t *type)
+{
+    inode_t *inode = NULL;
+    dentry_t *dentry = NULL;
+    int ret = -1;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                dentry = __dentry_grep (table, parent, name);
+    if (!table || !parent || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "table || parent || name"
+                         " not found");
+        return ret;
+    }
 
-                if (dentry)
-                        inode = dentry->inode;
+    int hash = hash_dentry(parent, name, table->hashsize);
 
-                if (inode) {
-                        gf_uuid_copy (gfid, inode->gfid);
-                        *type = inode->ia_type;
-                        ret = 0;
-                }
+    pthread_mutex_lock(&table->lock);
+    {
+        dentry = __dentry_grep(table, parent, name, hash);
+        if (dentry) {
+            inode = dentry->inode;
+            if (inode) {
+                gf_uuid_copy(gfid, inode->gfid);
+                *type = inode->ia_type;
+                ret = 0;
+            }
         }
-        pthread_mutex_unlock (&table->lock);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
-
 /* return 1 if gfid is of root, 0 if not */
 gf_boolean_t
-__is_root_gfid (uuid_t gfid)
+__is_root_gfid(uuid_t gfid)
 {
-        static uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+    static uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
-        if (gf_uuid_compare (gfid, root) == 0)
-                return _gf_true;
+    if (gf_uuid_compare(gfid, root) == 0)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
-
 inode_t *
-__inode_find (inode_table_t *table, uuid_t gfid)
+__inode_find(inode_table_t *table, uuid_t gfid, const int hash)
 {
-        inode_t   *inode = NULL;
-        inode_t   *tmp = NULL;
-        int        hash = 0;
+    inode_t *inode = NULL;
+    inode_t *tmp = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                goto out;
-        }
-
-        if (__is_root_gfid (gfid))
-                return table->root;
+    if (__is_root_gfid(gfid))
+        return table->root;
 
-        hash = hash_gfid (gfid, 65536);
-
-        list_for_each_entry (tmp, &table->inode_hash[hash], hash) {
-                if (gf_uuid_compare (tmp->gfid, gfid) == 0) {
-                        inode = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &table->inode_hash[hash], hash)
+    {
+        if (gf_uuid_compare(tmp->gfid, gfid) == 0) {
+            inode = tmp;
+            break;
         }
+    }
 
-out:
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_find (inode_table_t *table, uuid_t gfid)
+inode_find(inode_table_t *table, uuid_t gfid)
 {
-        inode_t   *inode = NULL;
+    inode_t *inode = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                return NULL;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "table not "
+                         "found");
+        return NULL;
+    }
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_find (table, gfid);
-                if (inode)
-                        __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    int hash = hash_gfid(gfid, 65536);
 
-        return inode;
-}
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_find(table, gfid, hash);
+        if (inode)
+            __inode_ref(inode, false);
+    }
+    pthread_mutex_unlock(&table->lock);
 
+    return inode;
+}
 
 static inode_t *
-__inode_link (inode_t *inode, inode_t *parent, const char *name,
-              struct iatt *iatt)
+__inode_link(inode_t *inode, inode_t *parent, const char *name,
+             struct iatt *iatt, const int dhash)
 {
-        dentry_t      *dentry = NULL;
-        dentry_t      *old_dentry = NULL;
-        inode_t       *old_inode = NULL;
-        inode_table_t *table = NULL;
-        inode_t       *link_inode = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *old_dentry = NULL;
+    inode_t *old_inode = NULL;
+    inode_table_t *table = NULL;
+    inode_t *link_inode = NULL;
+    char link_uuid_str[64] = {0}, parent_uuid_str[64] = {0};
 
-        if (!inode) {
-                errno = EINVAL;
-                return NULL;
-        }
+    table = inode->table;
 
-        table = inode->table;
-        if (!table) {
-                errno = EINVAL;
-                return NULL;
+    if (parent) {
+        /* We should prevent inode linking between different
+           inode tables. This can cause errors which is very
+           hard to catch/debug. */
+        if (inode->table != parent->table) {
+            errno = EINVAL;
+            GF_ASSERT(!"link attempted b/w inodes of diff table");
         }
 
-        if (parent) {
-                /* We should prevent inode linking between different
-                   inode tables. This can cause errors which is very
-                   hard to catch/debug. */
-                if (inode->table != parent->table) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted b/w inodes of diff table");
-                }
-
-                if (parent->ia_type != IA_IFDIR) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted on non-directory parent");
-                        return NULL;
-                }
+        if (parent->ia_type != IA_IFDIR) {
+            errno = EINVAL;
+            GF_ASSERT(!"link attempted on non-directory parent");
+            return NULL;
+        }
 
-                if (!name || strlen (name) == 0) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted with no basename on "
+        if (!name || strlen(name) == 0) {
+            errno = EINVAL;
+            GF_ASSERT (!"link attempted with no basename on "
                                     "parent");
-                        return NULL;
-                }
+            return NULL;
         }
+    }
 
-        link_inode = inode;
+    link_inode = inode;
 
-        if (!__is_inode_hashed (inode)) {
-                if (!iatt) {
-                        errno = EINVAL;
-                        return NULL;
-                }
+    if (!__is_inode_hashed(inode)) {
+        if (!iatt) {
+            errno = EINVAL;
+            return NULL;
+        }
 
-                if (gf_uuid_is_null (iatt->ia_gfid)) {
-                        errno = EINVAL;
-                        return NULL;
-                }
+        if (gf_uuid_is_null(iatt->ia_gfid)) {
+            errno = EINVAL;
+            return NULL;
+        }
 
-                old_inode = __inode_find (table, iatt->ia_gfid);
+        int ihash = hash_gfid(iatt->ia_gfid, 65536);
 
-                if (old_inode) {
-                        link_inode = old_inode;
-                } else {
-                        gf_uuid_copy (inode->gfid, iatt->ia_gfid);
-                        inode->ia_type    = iatt->ia_type;
-                        __inode_hash (inode);
-                }
+        old_inode = __inode_find(table, iatt->ia_gfid, ihash);
+
+        if (old_inode) {
+            link_inode = old_inode;
         } else {
-		/* @old_inode serves another important purpose - it indicates
-		   to the code further below whether a dentry cycle check is
-		   required or not (a new inode linkage can never result in
-		   creation of a loop.)
-
-		   if the given @inode is already hashed, it actually means
-		   it is an "old" inode and deserves to undergo the cyclic
-		   check.
-		*/
-		old_inode = inode;
-	}
+            gf_uuid_copy(inode->gfid, iatt->ia_gfid);
+            inode->ia_type = iatt->ia_type;
+            __inode_hash(inode, ihash);
+        }
+    } else {
+        /* @old_inode serves another important purpose - it indicates
+           to the code further below whether a dentry cycle check is
+           required or not (a new inode linkage can never result in
+           creation of a loop.)
+
+           if the given @inode is already hashed, it actually means
+           it is an "old" inode and deserves to undergo the cyclic
+           check.
+        */
+        old_inode = inode;
+    }
+
+    if (name && (!strcmp(name, ".") || !strcmp(name, ".."))) {
+        return link_inode;
+    }
+
+    /* use only link_inode beyond this point */
+    if (parent) {
+        old_dentry = __dentry_grep(table, parent, name, dhash);
+
+        if (!old_dentry || old_dentry->inode != link_inode) {
+            dentry = dentry_create(link_inode, parent, name);
+            if (!dentry) {
+                gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0,
+                                 LG_MSG_DENTRY_CREATE_FAILED,
+                                 "dentry create failed on "
+                                 "inode %s with parent %s",
+                                 uuid_utoa_r(link_inode->gfid, link_uuid_str),
+                                 uuid_utoa_r(parent->gfid, parent_uuid_str));
+                errno = ENOMEM;
+                return NULL;
+            }
 
-        if (name) {
-                if (!strcmp(name, ".") || !strcmp(name, ".."))
-                        return link_inode;
+            /* dentry linking needs to happen inside lock */
+            dentry->parent = __inode_ref(parent, false);
+            list_add(&dentry->inode_list, &link_inode->dentry_list);
 
-                if (strchr (name, '/')) {
-                        GF_ASSERT (!"inode link attempted with '/' in name");
-                        return NULL;
-                }
-        }
+            if (old_inode && __is_dentry_cyclic(dentry)) {
+                errno = ELOOP;
+                dentry_destroy(__dentry_unset(dentry));
+                return NULL;
+            }
+            __dentry_hash(dentry, dhash);
 
-        /* use only link_inode beyond this point */
-        if (parent) {
-                old_dentry = __dentry_grep (table, parent, name);
-
-                if (!old_dentry || old_dentry->inode != link_inode) {
-                        dentry = __dentry_create (link_inode, parent, name);
-                        if (!dentry) {
-                                gf_msg_callingfn (THIS->name, GF_LOG_ERROR, 0,
-                                                  LG_MSG_DENTRY_CREATE_FAILED,
-                                                  "dentry create failed on "
-                                                  "inode %s with parent %s",
-                                                  uuid_utoa (link_inode->gfid),
-                                                  uuid_utoa (parent->gfid));
-                                errno = ENOMEM;
-                                return NULL;
-                        }
-                        if (old_inode && __is_dentry_cyclic (dentry)) {
-                                errno = ELOOP;
-                                __dentry_unset (dentry);
-                                return NULL;
-                        }
-                        __dentry_hash (dentry);
-
-                        if (old_dentry)
-                                __dentry_unset (old_dentry);
-                }
+            if (old_dentry)
+                dentry_destroy(__dentry_unset(old_dentry));
         }
+    }
 
-        return link_inode;
+    return link_inode;
 }
 
-
 inode_t *
-inode_link (inode_t *inode, inode_t *parent, const char *name,
-            struct iatt *iatt)
+inode_link(inode_t *inode, inode_t *parent, const char *name, struct iatt *iatt)
 {
-        inode_table_t *table = NULL;
-        inode_t       *linked_inode = NULL;
+    int hash = 0;
+    inode_table_t *table = NULL;
+    inode_t *linked_inode = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return NULL;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                linked_inode = __inode_link (inode, parent, name, iatt);
+    if (parent && name) {
+        hash = hash_dentry(parent, name, table->hashsize);
+    }
 
-                if (linked_inode)
-                        __inode_ref (linked_inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    if (name && strchr(name, '/')) {
+        GF_ASSERT(!"inode link attempted with '/' in name");
+        return NULL;
+    }
 
-        inode_table_prune (table);
+    pthread_mutex_lock(&table->lock);
+    {
+        linked_inode = __inode_link(inode, parent, name, iatt, hash);
+        if (linked_inode)
+            __inode_ref(linked_inode, false);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return linked_inode;
+    inode_table_prune(table);
+
+    return linked_inode;
 }
 
+int
+inode_lookup(inode_t *inode)
+{
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
+
+    GF_ATOMIC_INC(inode->nlookup);
+
+    return 0;
+}
 
 int
-inode_lookup (inode_t *inode)
+inode_ref_reduce_by_n(inode_t *inode, uint64_t nref)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_lookup (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_ref_reduce_by_n(inode, nref);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return 0;
-}
+    inode_table_prune(table);
 
+    return 0;
+}
 
 int
-inode_ref_reduce_by_n (inode_t *inode, uint64_t nref)
+inode_forget(inode_t *inode, uint64_t nlookup)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_ref_reduce_by_n (inode, nref);
-        }
-        pthread_mutex_unlock (&table->lock);
+    inode_forget_atomic(inode, nlookup);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return 0;
+    return 0;
 }
 
-
 int
-inode_forget (inode_t *inode, uint64_t nlookup)
+inode_forget_with_unref(inode_t *inode, uint64_t nlookup)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_forget (inode, nlookup);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode_forget_atomic(inode, nlookup);
+        __inode_unref(inode, true);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return 0;
+    return 0;
 }
 
 /*
- * Invalidate an inode. This is invoked when a translator decides that an inode's
- * cache is no longer valid. Any translator interested in taking action in this
- * situation can define the invalidate callback.
+ * Invalidate an inode. This is invoked when a translator decides that an
+ * inode's cache is no longer valid. Any translator interested in taking action
+ * in this situation can define the invalidate callback.
  */
 int
 inode_invalidate(inode_t *inode)
 {
-	int ret = 0;
-	xlator_t *xl = NULL;
-	xlator_t *old_THIS = NULL;
-
-	if (!inode) {
-		gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
-                                 LG_MSG_INODE_NOT_FOUND, "inode not found");
-		return -1;
-	}
-
-	/*
-	 * The master xlator is not in the graph but it can define an invalidate
-	 * handler.
-	 */
-	xl = inode->table->xl->ctx->master;
-	if (xl && xl->cbks->invalidate) {
-		old_THIS = THIS;
-		THIS = xl;
-		ret = xl->cbks->invalidate(xl, inode);
-		THIS = old_THIS;
-		if (ret)
-			return ret;
-	}
+    int ret = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
+
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
+
+    /*
+     * The master xlator is not in the graph but it can define an invalidate
+     * handler.
+     */
+    xl = inode->table->xl->ctx->master;
+    if (xl && xl->cbks->invalidate) {
+        old_THIS = THIS;
+        THIS = xl;
+        ret = xl->cbks->invalidate(xl, inode);
+        THIS = old_THIS;
+        if (ret)
+            return ret;
+    }
 
-	xl = inode->table->xl->graph->first;
-	while (xl) {
-		old_THIS = THIS;
-		THIS = xl;
-		if (xl->cbks->invalidate)
-			ret = xl->cbks->invalidate(xl, inode);
-		THIS = old_THIS;
+    xl = inode->table->xl->graph->first;
+    while (xl) {
+        old_THIS = THIS;
+        THIS = xl;
+        if (xl->cbks->invalidate)
+            ret = xl->cbks->invalidate(xl, inode);
+        THIS = old_THIS;
 
-		if (ret)
-			break;
+        if (ret)
+            break;
 
-		xl = xl->next;
-	}
+        xl = xl->next;
+    }
 
-	return ret;
+    return ret;
 }
 
-
-static void
-__inode_unlink (inode_t *inode, inode_t *parent, const char *name)
+static dentry_t *
+__inode_unlink(inode_t *inode, inode_t *parent, const char *name)
 {
-        dentry_t *dentry = NULL;
-        char pgfid[64] = {0};
-        char gfid[64] = {0};
+    dentry_t *dentry = NULL;
+    char pgfid[64] = {0};
+    char gfid[64] = {0};
 
-        if (!inode || !parent || !name)
-                return;
+    dentry = __dentry_search_for_inode(inode, parent->gfid, name);
 
-        dentry = __dentry_search_for_inode (inode, parent->gfid, name);
-
-        /* dentry NULL for corrupted backend */
-        if (dentry) {
-                __dentry_unset (dentry);
-        } else {
-                gf_msg ("inode", GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
-                        "%s/%s: dentry not found in %s",
-                        uuid_utoa_r (parent->gfid, pgfid), name,
-                        uuid_utoa_r (inode->gfid, gfid));
-        }
+    /* dentry NULL for corrupted backend */
+    if (dentry) {
+        dentry = __dentry_unset(dentry);
+    } else {
+        gf_smsg("inode", GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                "parent-gfid=%s name=%s gfid%s",
+                uuid_utoa_r(parent->gfid, pgfid), name,
+                uuid_utoa_r(inode->gfid, gfid), NULL);
+    }
 
+    return dentry;
 }
 
-
 void
-inode_unlink (inode_t *inode, inode_t *parent, const char *name)
+inode_unlink(inode_t *inode, inode_t *parent, const char *name)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table;
+    dentry_t *dentry;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode || !parent || !name)
+        return;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_unlink (inode, parent, name);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        dentry = __inode_unlink(inode, parent, name);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
-}
+    dentry_destroy(dentry);
 
+    inode_table_prune(table);
+}
 
 int
-inode_rename (inode_table_t *table, inode_t *srcdir, const char *srcname,
-              inode_t *dstdir, const char *dstname, inode_t *inode,
-              struct iatt *iatt)
-{
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+inode_rename(inode_table_t *table, inode_t *srcdir, const char *srcname,
+             inode_t *dstdir, const char *dstname, inode_t *inode,
+             struct iatt *iatt)
+{
+    int hash = 0;
+    dentry_t *dentry = NULL;
 
-        table = inode->table;
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_link (inode, dstdir, dstname, iatt);
-                __inode_unlink (inode, srcdir, srcname);
-        }
-        pthread_mutex_unlock (&table->lock);
+    table = inode->table;
 
-        inode_table_prune (table);
+    if (dstname && strchr(dstname, '/')) {
+        GF_ASSERT(!"inode link attempted with '/' in name");
+        return -1;
+    }
 
-        return 0;
-}
+    if (dstdir && dstname) {
+        hash = hash_dentry(dstdir, dstname, table->hashsize);
+    }
 
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_link(inode, dstdir, dstname, iatt, hash);
+        /* pick the old dentry */
+        dentry = __inode_unlink(inode, srcdir, srcname);
+    }
+    pthread_mutex_unlock(&table->lock);
+
+    /* free the old dentry */
+    dentry_destroy(dentry);
+
+    inode_table_prune(table);
+
+    return 0;
+}
 
 static dentry_t *
-__dentry_search_arbit (inode_t *inode)
+__dentry_search_arbit(inode_t *inode)
 {
-        dentry_t *dentry = NULL;
-        dentry_t *trav = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *trav = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        list_for_each_entry (trav, &inode->dentry_list, inode_list) {
-                if (__is_dentry_hashed (trav)) {
-                        dentry = trav;
-                        break;
-                }
+    list_for_each_entry(trav, &inode->dentry_list, inode_list)
+    {
+        if (__is_dentry_hashed(trav)) {
+            dentry = trav;
+            break;
         }
+    }
 
-        if (!dentry) {
-                list_for_each_entry (trav, &inode->dentry_list, inode_list) {
-                        dentry = trav;
-                        break;
-                }
+    if (!dentry) {
+        list_for_each_entry(trav, &inode->dentry_list, inode_list)
+        {
+            dentry = trav;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 inode_t *
-inode_parent (inode_t *inode, uuid_t pargfid, const char *name)
+inode_parent(inode_t *inode, uuid_t pargfid, const char *name)
 {
-        inode_t       *parent = NULL;
-        inode_table_t *table = NULL;
-        dentry_t      *dentry = NULL;
+    inode_t *parent = NULL;
+    inode_table_t *table = NULL;
+    dentry_t *dentry = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return NULL;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                if (pargfid && !gf_uuid_is_null (pargfid) && name) {
-                        dentry = __dentry_search_for_inode (inode, pargfid, name);
-                } else {
-                        dentry = __dentry_search_arbit (inode);
-                }
+    pthread_mutex_lock(&table->lock);
+    {
+        if (pargfid && !gf_uuid_is_null(pargfid) && name) {
+            dentry = __dentry_search_for_inode(inode, pargfid, name);
+        } else {
+            dentry = __dentry_search_arbit(inode);
+        }
 
-                if (dentry)
-                        parent = dentry->parent;
+        if (dentry)
+            parent = dentry->parent;
 
-                if (parent)
-                        __inode_ref (parent);
-        }
-        pthread_mutex_unlock (&table->lock);
+        if (parent)
+            __inode_ref(parent, false);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return parent;
+    return parent;
 }
 
 static int
-__inode_has_dentry (inode_t *inode)
+__inode_has_dentry(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
-
-        return !list_empty (&inode->dentry_list);
+    return !list_empty(&inode->dentry_list);
 }
 
 int
-inode_has_dentry (inode_t *inode)
+inode_has_dentry(inode_t *inode)
 {
+    int dentry_present = 0;
 
-        int dentry_present = 0;
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return 0;
+    }
 
-        LOCK (&inode->lock);
-        {
-                dentry_present = __inode_has_dentry (inode);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        dentry_present = __inode_has_dentry(inode);
+    }
+    UNLOCK(&inode->lock);
 
-        return dentry_present;
+    return dentry_present;
 }
 
 int
-__inode_path (inode_t *inode, const char *name, char **bufp)
-{
-        inode_table_t *table = NULL;
-        inode_t       *itrav = NULL;
-        dentry_t      *trav  = NULL;
-        size_t         i     = 0, size = 0;
-        int64_t        ret   = 0;
-        int            len   = 0;
-        char          *buf   = NULL;
-
-        if (!inode || gf_uuid_is_null (inode->gfid)) {
-                GF_ASSERT (0);
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid inode");
-                return -EINVAL;
-        }
+__inode_path(inode_t *inode, const char *name, char **bufp)
+{
+    inode_table_t *table = NULL;
+    inode_t *itrav = NULL;
+    dentry_t *trav = NULL;
+    size_t i = 0, size = 0;
+    int64_t ret = 0;
+    int len = 0;
+    char *buf = NULL;
+
+    if (!inode || gf_uuid_is_null(inode->gfid)) {
+        GF_ASSERT(0);
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode");
+        return -EINVAL;
+    }
+
+    table = inode->table;
+
+    itrav = inode;
+    for (trav = __dentry_search_arbit(itrav); trav;
+         trav = __dentry_search_arbit(itrav)) {
+        itrav = trav->parent;
+        i++; /* "/" */
+        i += strlen(trav->name);
+        if (i > PATH_MAX) {
+            gf_smsg(table->name, GF_LOG_CRITICAL, 0, LG_MSG_DENTRY_CYCLIC_LOOP,
+                    "name=%s", name, NULL);
+            ret = -ENOENT;
+            goto out;
+        }
+    }
+
+    if (!__is_root_gfid(itrav->gfid)) {
+        /* "<gfid:00000000-0000-0000-0000-000000000000>"/path */
+        i += GFID_STR_PFX_LEN;
+    }
+
+    if (name) {
+        i++;
+        i += strlen(name);
+    }
+
+    ret = i;
+    size = i + 1;
+    buf = GF_CALLOC(size, sizeof(char), gf_common_mt_char);
+    if (buf) {
+        buf[size - 1] = 0;
 
-        table = inode->table;
+        if (name) {
+            len = strlen(name);
+            memcpy(buf + (i - len), name, len);
+            buf[i - len - 1] = '/';
+            i -= (len + 1);
+        }
 
         itrav = inode;
-        for (trav = __dentry_search_arbit (itrav); trav;
-             trav = __dentry_search_arbit (itrav)) {
-                itrav = trav->parent;
-                i ++; /* "/" */
-                i += strlen (trav->name);
-                if (i > PATH_MAX) {
-                        gf_msg (table->name, GF_LOG_CRITICAL, 0,
-                                LG_MSG_DENTRY_CYCLIC_LOOP, "possible infinite "
-                                "loop detected, forcing break. name=(%s)",
-                                name);
-                        ret = -ENOENT;
-                        goto out;
-                }
+        for (trav = __dentry_search_arbit(itrav); trav;
+             trav = __dentry_search_arbit(itrav)) {
+            itrav = trav->parent;
+            len = strlen(trav->name);
+            memcpy(buf + (i - len), trav->name, len);
+            buf[i - len - 1] = '/';
+            i -= (len + 1);
         }
 
-        if (!__is_root_gfid (itrav->gfid)) {
-                /* "<gfid:00000000-0000-0000-0000-000000000000>"/path */
-                i += GFID_STR_PFX_LEN;
+        if (!__is_root_gfid(itrav->gfid)) {
+            snprintf(&buf[i - GFID_STR_PFX_LEN], GFID_STR_PFX_LEN,
+                     INODE_PATH_FMT, uuid_utoa(itrav->gfid));
+            buf[i - 1] = '>';
         }
 
-        if (name) {
-                i++;
-                i += strlen (name);
-        }
+        *bufp = buf;
+    } else {
+        ret = -ENOMEM;
+    }
 
-        ret = i;
-        size = i + 1;
-        buf = GF_CALLOC (size, sizeof (char), gf_common_mt_char);
+out:
+    if (__is_root_gfid(inode->gfid) && !name) {
+        ret = 1;
+        GF_FREE(buf);
+        buf = GF_CALLOC(ret + 1, sizeof(char), gf_common_mt_char);
         if (buf) {
-
-                buf[size - 1] = 0;
-
-                if (name) {
-                        len = strlen (name);
-                        strncpy (buf + (i - len), name, len);
-                        buf[i-len-1] = '/';
-                        i -= (len + 1);
-                }
-
-                itrav = inode;
-                for (trav = __dentry_search_arbit (itrav); trav;
-                     trav = __dentry_search_arbit (itrav)) {
-                        itrav = trav->parent;
-                        len = strlen (trav->name);
-                        strncpy (buf + (i - len), trav->name, len);
-                        buf[i-len-1] = '/';
-                        i -= (len + 1);
-                }
-
-                if (!__is_root_gfid (itrav->gfid)) {
-                        snprintf (&buf[i-GFID_STR_PFX_LEN], GFID_STR_PFX_LEN,
-                                  INODE_PATH_FMT, uuid_utoa (itrav->gfid));
-                        buf[i-1] = '>';
-                }
-
-                *bufp = buf;
+            strcpy(buf, "/");
+            *bufp = buf;
         } else {
-                ret = -ENOMEM;
-        }
-
-out:
-        if (__is_root_gfid (inode->gfid) && !name) {
-                ret = 1;
-                GF_FREE (buf);
-                buf = GF_CALLOC (ret + 1, sizeof (char), gf_common_mt_char);
-                if (buf) {
-                        strcpy (buf, "/");
-                        *bufp = buf;
-                } else {
-                        ret = -ENOMEM;
-                }
+            ret = -ENOMEM;
         }
+    }
 
-        if (ret < 0)
-                *bufp = NULL;
-        return ret;
+    if (ret < 0)
+        *bufp = NULL;
+    return ret;
 }
 
-
 int
-inode_path (inode_t *inode, const char *name, char **bufp)
+inode_path(inode_t *inode, const char *name, char **bufp)
 {
-        inode_table_t *table = NULL;
-        int            ret   = -1;
+    inode_table_t *table = NULL;
+    int ret = -1;
 
-        if (!inode)
-                return -EINVAL;
+    if (!inode)
+        return -EINVAL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                ret = __inode_path (inode, name, bufp);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        ret = __inode_path(inode, name, bufp);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-__inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit)
+__inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit)
 {
-        table->lru_limit = lru_limit;
-        return;
+    table->lru_limit = lru_limit;
+    return;
 }
 
-
 void
-inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit)
+inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit)
 {
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_table_set_lru_limit (table, lru_limit);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_table_set_lru_limit(table, lru_limit);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return;
+    return;
 }
 
 static int
-inode_table_prune (inode_table_t *table)
-{
-        int               ret = 0;
-        struct list_head  purge = {0, };
-        inode_t          *del = NULL;
-        inode_t          *tmp = NULL;
-        inode_t          *entry = NULL;
-
-        if (!table)
-                return -1;
-
-        INIT_LIST_HEAD (&purge);
-
-        pthread_mutex_lock (&table->lock);
-        {
-                while (table->lru_limit
-                       && table->lru_size > (table->lru_limit)) {
-                        if (list_empty (&table->lru)) {
-                                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                                  LG_MSG_INVALID_INODE_LIST,
-                                                  "Empty inode lru list found"
-                                                  " but with (%d) lru_size",
-                                                  table->lru_size);
-                                break;
-                        }
-
-                        entry = list_entry (table->lru.next, inode_t, list);
-
-                        table->lru_size--;
-                        __inode_retire (entry);
-
-                        ret++;
+inode_table_prune(inode_table_t *table)
+{
+    int ret = 0;
+    int ret1 = 0;
+    struct list_head purge = {
+        0,
+    };
+    inode_t *del = NULL;
+    inode_t *tmp = NULL;
+    inode_t *entry = NULL;
+    uint64_t nlookup = 0;
+    int64_t lru_size = 0;
+
+    if (!table)
+        return -1;
+
+    INIT_LIST_HEAD(&purge);
+
+    pthread_mutex_lock(&table->lock);
+    {
+        if (!table->lru_limit)
+            goto purge_list;
+
+        lru_size = table->lru_size;
+        while (lru_size > (table->lru_limit)) {
+            if (list_empty(&table->lru)) {
+                gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                                 LG_MSG_INVALID_INODE_LIST,
+                                 "Empty inode lru list found"
+                                 " but with (%d) lru_size",
+                                 table->lru_size);
+                break;
+            }
+
+            lru_size--;
+            entry = list_entry(table->lru.next, inode_t, list);
+            /* The logic of invalidation is required only if invalidator_fn
+               is present */
+            if (table->invalidator_fn) {
+                /* check for valid inode with 'nlookup' */
+                nlookup = GF_ATOMIC_GET(entry->nlookup);
+                if (nlookup) {
+                    if (entry->invalidate_sent) {
+                        list_move_tail(&entry->list, &table->lru);
+                        continue;
+                    }
+                    __inode_ref(entry, true);
+                    tmp = entry;
+                    break;
                 }
-
-                list_splice_init (&table->purge, &purge);
-                table->purge_size = 0;
-        }
-        pthread_mutex_unlock (&table->lock);
-
+            }
+
+            table->lru_size--;
+            __inode_retire(entry);
+            ret++;
+        }
+
+    purge_list:
+        list_splice_init(&table->purge, &purge);
+        table->purge_size = 0;
+    }
+    pthread_mutex_unlock(&table->lock);
+
+    /* Pick 1 inode for invalidation */
+    if (tmp) {
+        xlator_t *old_THIS = THIS;
+        THIS = table->invalidator_xl;
+        ret1 = table->invalidator_fn(table->invalidator_xl, tmp);
+        THIS = old_THIS;
+        pthread_mutex_lock(&table->lock);
         {
-                list_for_each_entry_safe (del, tmp, &purge, list) {
-                        list_del_init (&del->list);
-                        __inode_forget (del, 0);
-                        __inode_destroy (del);
-                }
+            if (!ret1) {
+                tmp->invalidate_sent = true;
+                __inode_unref(tmp, false);
+            } else {
+                /* Move this back to the lru list*/
+                __inode_unref(tmp, true);
+            }
         }
+        pthread_mutex_unlock(&table->lock);
+    }
 
-        return ret;
-}
+    /* Just so that if purge list is handled too, then clear it off */
+    list_for_each_entry_safe(del, tmp, &purge, list)
+    {
+        list_del_init(&del->list);
+        inode_forget_atomic(del, 0);
+        __inode_destroy(del);
+    }
 
+    return ret;
+}
 
 static void
-__inode_table_init_root (inode_table_t *table)
+__inode_table_init_root(inode_table_t *table)
 {
-        inode_t     *root = NULL;
-        struct iatt  iatt = {0, };
+    inode_t *root = NULL;
+    struct iatt iatt = {
+        0,
+    };
 
-        if (!table)
-                return;
+    if (!table)
+        return;
 
-        root = __inode_create (table);
+    root = inode_create(table);
 
-        iatt.ia_gfid[15] = 1;
-        iatt.ia_ino = 1;
-        iatt.ia_type = IA_IFDIR;
+    list_add(&root->list, &table->lru);
+    table->lru_size++;
 
-        __inode_link (root, NULL, NULL, &iatt);
-        table->root = root;
-}
+    iatt.ia_gfid[15] = 1;
+    iatt.ia_ino = 1;
+    iatt.ia_type = IA_IFDIR;
 
+    __inode_link(root, NULL, NULL, &iatt, 0);
+    table->root = root;
+}
 
 inode_table_t *
-inode_table_new (size_t lru_limit, xlator_t *xl)
+inode_table_with_invalidator(uint32_t lru_limit, xlator_t *xl,
+                             int32_t (*invalidator_fn)(xlator_t *, inode_t *),
+                             xlator_t *invalidator_xl)
 {
-        inode_table_t *new = NULL;
-        int            ret = -1;
-        int            i = 0;
-
-        new = (void *)GF_CALLOC(1, sizeof (*new), gf_common_mt_inode_table_t);
-        if (!new)
-                return NULL;
-
-        new->xl = xl;
-        new->ctxcount = xl->graph->xl_count + 1;
+    inode_table_t *new = NULL;
+    uint32_t mem_pool_size = lru_limit;
+    int ret = -1;
+    int i = 0;
 
-        new->lru_limit = lru_limit;
+    new = (void *)GF_CALLOC(1, sizeof(*new), gf_common_mt_inode_table_t);
+    if (!new)
+        return NULL;
 
-        new->hashsize = 14057; /* TODO: Random Number?? */
+    new->xl = xl;
+    new->ctxcount = xl->graph->xl_count + 1;
 
-        /* In case FUSE is initing the inode table. */
-        if (lru_limit == 0)
-                lru_limit = DEFAULT_INODE_MEMPOOL_ENTRIES;
+    new->lru_limit = lru_limit;
+    new->invalidator_fn = invalidator_fn;
+    new->invalidator_xl = invalidator_xl;
 
-        new->inode_pool = mem_pool_new (inode_t, lru_limit);
+    new->hashsize = 14057; /* TODO: Random Number?? */
 
-        if (!new->inode_pool)
-                goto out;
+    /* In case FUSE is initing the inode table. */
+    if (!mem_pool_size || (mem_pool_size > DEFAULT_INODE_MEMPOOL_ENTRIES))
+        mem_pool_size = DEFAULT_INODE_MEMPOOL_ENTRIES;
 
-        new->dentry_pool = mem_pool_new (dentry_t, lru_limit);
+    new->inode_pool = mem_pool_new(inode_t, mem_pool_size);
+    if (!new->inode_pool)
+        goto out;
 
-        if (!new->dentry_pool)
-                goto out;
+    new->dentry_pool = mem_pool_new(dentry_t, mem_pool_size);
+    if (!new->dentry_pool)
+        goto out;
 
-        new->inode_hash = (void *)GF_CALLOC (65536,
-                                             sizeof (struct list_head),
-                                             gf_common_mt_list_head);
-        if (!new->inode_hash)
-                goto out;
+    new->inode_hash = (void *)GF_CALLOC(65536, sizeof(struct list_head),
+                                        gf_common_mt_list_head);
+    if (!new->inode_hash)
+        goto out;
 
-        new->name_hash = (void *)GF_CALLOC (new->hashsize,
-                                            sizeof (struct list_head),
-                                            gf_common_mt_list_head);
-        if (!new->name_hash)
-                goto out;
+    new->name_hash = (void *)GF_CALLOC(new->hashsize, sizeof(struct list_head),
+                                       gf_common_mt_list_head);
+    if (!new->name_hash)
+        goto out;
 
-        /* if number of fd open in one process is more than this,
-           we may hit perf issues */
-        new->fd_mem_pool = mem_pool_new (fd_t, 1024);
+    /* if number of fd open in one process is more than this,
+       we may hit perf issues */
+    new->fd_mem_pool = mem_pool_new(fd_t, 1024);
 
-        if (!new->fd_mem_pool)
-                goto out;
+    if (!new->fd_mem_pool)
+        goto out;
 
-        for (i = 0; i < 65536; i++) {
-                INIT_LIST_HEAD (&new->inode_hash[i]);
-        }
+    for (i = 0; i < 65536; i++) {
+        INIT_LIST_HEAD(&new->inode_hash[i]);
+    }
 
+    for (i = 0; i < new->hashsize; i++) {
+        INIT_LIST_HEAD(&new->name_hash[i]);
+    }
 
-        for (i = 0; i < new->hashsize; i++) {
-                INIT_LIST_HEAD (&new->name_hash[i]);
-        }
+    INIT_LIST_HEAD(&new->active);
+    INIT_LIST_HEAD(&new->lru);
+    INIT_LIST_HEAD(&new->purge);
+    INIT_LIST_HEAD(&new->invalidate);
 
-        INIT_LIST_HEAD (&new->active);
-        INIT_LIST_HEAD (&new->lru);
-        INIT_LIST_HEAD (&new->purge);
+    ret = gf_asprintf(&new->name, "%s/inode", xl->name);
+    if (-1 == ret) {
+        /* TODO: This should be ok to continue, check with avati */
+        ;
+    }
 
-        ret = gf_asprintf (&new->name, "%s/inode", xl->name);
-        if (-1 == ret) {
-                /* TODO: This should be ok to continue, check with avati */
-                ;
-        }
+    new->cleanup_started = _gf_false;
 
-        __inode_table_init_root (new);
+    __inode_table_init_root(new);
 
-        pthread_mutex_init (&new->lock, NULL);
+    pthread_mutex_init(&new->lock, NULL);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                if (new) {
-                        GF_FREE (new->inode_hash);
-                        GF_FREE (new->name_hash);
-                        if (new->dentry_pool)
-                                mem_pool_destroy (new->dentry_pool);
-                        if (new->inode_pool)
-                                mem_pool_destroy (new->inode_pool);
-                        GF_FREE (new);
-                        new = NULL;
-                }
+    if (ret) {
+        if (new) {
+            GF_FREE(new->inode_hash);
+            GF_FREE(new->name_hash);
+            if (new->dentry_pool)
+                mem_pool_destroy(new->dentry_pool);
+            if (new->inode_pool)
+                mem_pool_destroy(new->inode_pool);
+            GF_FREE(new);
+            new = NULL;
         }
+    }
 
-        return new;
+    return new;
+}
+
+inode_table_t *
+inode_table_new(uint32_t lru_limit, xlator_t *xl)
+{
+    /* Only fuse for now requires the inode table with invalidator */
+    return inode_table_with_invalidator(lru_limit, xl, NULL, NULL);
 }
 
 int
-inode_table_ctx_free (inode_table_t *table)
+inode_table_ctx_free(inode_table_t *table)
 {
-        int ret = 0;
-        inode_t *del = NULL;
-        inode_t *tmp = NULL;
-        int purge_count = 0;
-        int lru_count = 0;
-        int active_count = 0;
-        xlator_t *this = NULL;
-        int itable_size = 0;
+    int ret = 0;
+    inode_t *del = NULL;
+    inode_t *tmp = NULL;
+    int purge_count = 0;
+    int lru_count = 0;
+    int active_count = 0;
+    xlator_t *this = NULL;
+    int itable_size = 0;
 
-        if (!table)
-                return -1;
+    if (!table)
+        return -1;
 
-        this = THIS;
+    this = THIS;
 
-        pthread_mutex_lock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        list_for_each_entry_safe(del, tmp, &table->purge, list)
         {
-                list_for_each_entry_safe (del, tmp, &table->purge, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                purge_count++;
-                        }
-                }
-
-                list_for_each_entry_safe (del, tmp, &table->lru, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                lru_count++;
-                        }
-                }
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                purge_count++;
+            }
+        }
 
-                /* should the contexts of active inodes be freed?
-                 * Since before this function being called fds would have
-                 * been migrated and would have held the ref on the new
-                 * inode from the new inode table, the older inode would not
-                 * be used.
-                 */
-                list_for_each_entry_safe (del, tmp, &table->active, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                active_count++;
-                        }
-                }
+        list_for_each_entry_safe(del, tmp, &table->lru, list)
+        {
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                lru_count++;
+            }
         }
-        pthread_mutex_unlock (&table->lock);
-
-        ret = purge_count + lru_count + active_count;
-        itable_size = table->active_size + table->lru_size + table->purge_size;
-        gf_msg_callingfn (this->name, GF_LOG_INFO, 0,
-                          LG_MSG_INODE_CONTEXT_FREED, "total %d (itable size: "
-                          "%d) inode contexts have been freed (active: %d, ("
-                          "active size: %d), lru: %d, (lru size: %d),  purge: "
-                          "%d, (purge size: %d))", ret, itable_size,
-                          active_count, table->active_size, lru_count,
-                          table->lru_size, purge_count, table->purge_size);
-        return ret;
+
+        /* should the contexts of active inodes be freed?
+         * Since before this function being called fds would have
+         * been migrated and would have held the ref on the new
+         * inode from the new inode table, the older inode would not
+         * be used.
+         */
+        list_for_each_entry_safe(del, tmp, &table->active, list)
+        {
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                active_count++;
+            }
+        }
+    }
+    pthread_mutex_unlock(&table->lock);
+
+    ret = purge_count + lru_count + active_count;
+    itable_size = table->active_size + table->lru_size + table->purge_size;
+    gf_msg_callingfn(this->name, GF_LOG_INFO, 0, LG_MSG_INODE_CONTEXT_FREED,
+                     "total %d (itable size: "
+                     "%d) inode contexts have been freed (active: %d, ("
+                     "active size: %d), lru: %d, (lru size: %d),  purge: "
+                     "%d, (purge size: %d))",
+                     ret, itable_size, active_count, table->active_size,
+                     lru_count, table->lru_size, purge_count,
+                     table->purge_size);
+    return ret;
 }
 
 void
-inode_table_destroy_all (glusterfs_ctx_t *ctx) {
-
-        glusterfs_graph_t *trav_graph  = NULL, *tmp = NULL;
-        xlator_t          *tree        = NULL;
-        inode_table_t     *inode_table = NULL;
+inode_table_destroy_all(glusterfs_ctx_t *ctx)
+{
+    glusterfs_graph_t *trav_graph = NULL, *tmp = NULL;
+    xlator_t *tree = NULL;
+    inode_table_t *inode_table = NULL;
+
+    if (ctx == NULL)
+        goto out;
+
+    /* TODO: Traverse ctx->graphs with in ctx->lock and also the other
+     * graph additions and traversals in ctx->lock.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        tree = trav_graph->first;
+        inode_table = tree->itable;
+        tree->itable = NULL;
+        if (inode_table)
+            inode_table_destroy(inode_table);
+    }
+out:
+    return;
+}
 
-        if (ctx == NULL)
-                goto out;
+void
+inode_table_destroy(inode_table_t *inode_table)
+{
+    inode_t *trav = NULL;
 
-        /* TODO: Traverse ctx->graphs with in ctx->lock and also the other
-         * graph additions and traversals in ctx->lock.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                tree = trav_graph->first;
-                inode_table = tree->itable;
-                tree->itable = NULL;
-                if (inode_table)
-                        inode_table_destroy (inode_table);
-        }
- out:
+    if (inode_table == NULL)
         return;
-}
 
-void
-inode_table_destroy (inode_table_t *inode_table) {
-
-        inode_t  *trav = NULL;
-
-        if (inode_table == NULL)
-                return;
-
-        /* Ideally at this point in time, there should be no inodes with
-         * refs remaining. But there are quite a few chances where the inodes
-         * leak. So we can take three approaches for cleaning up the inode table:
-         * 1. Assume there are no leaks and then send a forget on all the inodes
-         *    in lru list.(If no leaks there should be no inodes in active list)
-         * 2. Knowing there could be leaks and not freeing those inodes will
-         *    also not free its inode context and this could leak a lot of
-         *    memory, force free the inodes by changing the ref to 0.
-         *    The problem with this is that any reference to inode after this
-         *    calling this funtion will lead to a crash.
-         * 3. Knowing there could be leakes, just free the inode contexts of
-         *    all the inodes. and let the inodes be alive. This way the major
-         *    memory consumed by the inode contexts are freed, but there can
-         *    be errors when any inode contexts are accessed after destroying
-         *    this table.
+    /* Ideally at this point in time, there should be no inodes with
+     * refs remaining. But there are quite a few chances where the inodes
+     * leak. So we can take three approaches for cleaning up the inode table:
+     * 1. Assume there are no leaks and then send a forget on all the inodes
+     *    in lru list.(If no leaks there should be no inodes in active list)
+     * 2. Knowing there could be leaks and not freeing those inodes will
+     *    also not free its inode context and this could leak a lot of
+     *    memory, force free the inodes by changing the ref to 0.
+     *    The problem with this is that any reference to inode after this
+     *    calling this function will lead to a crash.
+     * 3. Knowing there could be leakes, just free the inode contexts of
+     *    all the inodes. and let the inodes be alive. This way the major
+     *    memory consumed by the inode contexts are freed, but there can
+     *    be errors when any inode contexts are accessed after destroying
+     *    this table.
+     *
+     * Not sure which is the approach to be taken, going by approach 2.
+     */
+
+    /* Approach 3:
+     * ret = inode_table_ctx_free (inode_table);
+     */
+    pthread_mutex_lock(&inode_table->lock);
+    {
+        inode_table->cleanup_started = _gf_true;
+        /* Process lru list first as we need to unset their dentry
+         * entries (the ones which may not be unset during
+         * '__inode_passivate' as they were hashed) which in turn
+         * shall unref their parent
          *
-         * Not sure which is the approach to be taken, going by approach 2.
-         */
-
-        /* Approach 3:
-         * ret = inode_table_ctx_free (inode_table);
+         * These parent inodes when unref'ed may well again fall
+         * into lru list and if we are at the end of traversing
+         * the list, we may miss to delete/retire that entry. Hence
+         * traverse the lru list till it gets empty.
          */
-        pthread_mutex_lock (&inode_table->lock);
-        {
-                /* Process lru list first as we need to unset their dentry
-                 * entries (the ones which may not be unset during
-                 * '__inode_passivate' as they were hashed) which in turn
-                 * shall unref their parent
-                 *
-                 * These parent inodes when unref'ed may well again fall
-                 * into lru list and if we are at the end of traversing
-                 * the list, we may miss to delete/retire that entry. Hence
-                 * traverse the lru list till it gets empty.
-                 */
-                while (!list_empty (&inode_table->lru)) {
-                        trav = list_first_entry (&inode_table->lru,
-                                                 inode_t, list);
-                        __inode_forget (trav, 0);
-                        __inode_retire (trav);
-                        inode_table->lru_size--;
-                }
-
-                while (!list_empty (&inode_table->active)) {
-                        trav = list_first_entry (&inode_table->active,
-                                                 inode_t, list);
-                        /* forget and unref the inode to retire and add it to
-                         * purge list. By this time there should not be any
-                         * inodes present in the active list except for root
-                         * inode. Its a ref_leak otherwise. */
-                        if (trav != inode_table->root)
-                                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                                  LG_MSG_REF_COUNT,
-                                                  "Active inode(%p) with refcount"
-                                                  "(%d) found during cleanup",
-                                                  trav, trav->ref);
-                        __inode_forget (trav, 0);
-                        __inode_ref_reduce_by_n (trav, 0);
-                }
-
-        }
-        pthread_mutex_unlock (&inode_table->lock);
-
-        inode_table_prune (inode_table);
-
-        GF_FREE (inode_table->inode_hash);
-        GF_FREE (inode_table->name_hash);
-        if (inode_table->dentry_pool)
-                mem_pool_destroy (inode_table->dentry_pool);
-        if (inode_table->inode_pool)
-                mem_pool_destroy (inode_table->inode_pool);
-        if (inode_table->fd_mem_pool)
-                mem_pool_destroy (inode_table->fd_mem_pool);
-
-        pthread_mutex_destroy (&inode_table->lock);
-
-        GF_FREE (inode_table->name);
-        GF_FREE (inode_table);
-
-        return;
+        while (!list_empty(&inode_table->lru)) {
+            trav = list_first_entry(&inode_table->lru, inode_t, list);
+            inode_forget_atomic(trav, 0);
+            __inode_retire(trav);
+            inode_table->lru_size--;
+        }
+
+        /* Same logic for invalidate list */
+        while (!list_empty(&inode_table->invalidate)) {
+            trav = list_first_entry(&inode_table->invalidate, inode_t, list);
+            inode_forget_atomic(trav, 0);
+            __inode_retire(trav);
+            inode_table->invalidate_size--;
+        }
+
+        while (!list_empty(&inode_table->active)) {
+            trav = list_first_entry(&inode_table->active, inode_t, list);
+            /* forget and unref the inode to retire and add it to
+             * purge list. By this time there should not be any
+             * inodes present in the active list except for root
+             * inode. Its a ref_leak otherwise. */
+            if (trav && (trav != inode_table->root))
+                gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                                 LG_MSG_REF_COUNT,
+                                 "Active inode(%p) with refcount"
+                                 "(%d) found during cleanup",
+                                 trav, trav->ref);
+            inode_forget_atomic(trav, 0);
+            __inode_ref_reduce_by_n(trav, 0);
+        }
+    }
+    pthread_mutex_unlock(&inode_table->lock);
+
+    inode_table_prune(inode_table);
+
+    GF_FREE(inode_table->inode_hash);
+    GF_FREE(inode_table->name_hash);
+    if (inode_table->dentry_pool)
+        mem_pool_destroy(inode_table->dentry_pool);
+    if (inode_table->inode_pool)
+        mem_pool_destroy(inode_table->inode_pool);
+    if (inode_table->fd_mem_pool)
+        mem_pool_destroy(inode_table->fd_mem_pool);
+
+    pthread_mutex_destroy(&inode_table->lock);
+
+    GF_FREE(inode_table->name);
+    GF_FREE(inode_table);
+
+    return;
 }
 
 inode_t *
-inode_from_path (inode_table_t *itable, const char *path)
+inode_from_path(inode_table_t *itable, const char *path)
 {
-        inode_t  *inode = NULL;
-        inode_t  *parent = NULL;
-        inode_t  *root = NULL;
-        inode_t  *curr = NULL;
-        char     *pathname = NULL;
-        char     *component = NULL, *next_component = NULL;
-        char     *strtokptr = NULL;
+    inode_t *inode = NULL;
+    inode_t *parent = NULL;
+    inode_t *root = NULL;
+    inode_t *curr = NULL;
+    char *pathname = NULL;
+    char *component = NULL, *next_component = NULL;
+    char *strtokptr = NULL;
 
-        if (!itable || !path)
-                return NULL;
+    if (!itable || !path)
+        return NULL;
 
-        /* top-down approach */
-        pathname = gf_strdup (path);
-        if (pathname == NULL) {
-                goto out;
-        }
+    /* top-down approach */
+    pathname = gf_strdup(path);
+    if (pathname == NULL) {
+        goto out;
+    }
 
-        root = itable->root;
-        parent = inode_ref (root);
-        component = strtok_r (pathname, "/", &strtokptr);
+    root = itable->root;
+    parent = inode_ref(root);
+    component = strtok_r(pathname, "/", &strtokptr);
 
-        if (component == NULL)
-                /* root inode */
-                inode = inode_ref (parent);
+    if (component == NULL)
+        /* root inode */
+        inode = inode_ref(parent);
 
-        while (component) {
-                curr = inode_grep (itable, parent, component);
+    while (component) {
+        curr = inode_grep(itable, parent, component);
 
-                if (curr == NULL) {
-                        strtok_r (NULL, "/", &strtokptr);
-                        break;
-                }
-
-                next_component = strtok_r (NULL, "/", &strtokptr);
+        if (curr == NULL) {
+            strtok_r(NULL, "/", &strtokptr);
+            break;
+        }
 
-                if (next_component) {
-                        inode_unref (parent);
-                        parent = curr;
-                        curr = NULL;
-                } else {
-                        inode = curr;
-                }
+        next_component = strtok_r(NULL, "/", &strtokptr);
 
-                component = next_component;
+        if (next_component) {
+            inode_unref(parent);
+            parent = curr;
+            curr = NULL;
+        } else {
+            inode = curr;
         }
 
-        if (parent)
-                inode_unref (parent);
+        component = next_component;
+    }
 
-        GF_FREE (pathname);
+    if (parent)
+        inode_unref(parent);
+
+    GF_FREE(pathname);
 
 out:
-        return inode;
+    return inode;
 }
 
 void
-inode_set_need_lookup (inode_t *inode, xlator_t *this)
+inode_set_need_lookup(inode_t *inode, xlator_t *this)
 {
-        uint64_t  need_lookup = LOOKUP_NEEDED;
+    uint64_t need_lookup = LOOKUP_NEEDED;
 
-        if (!inode || !this)
-                return;
+    if (!inode || !this)
+        return;
 
-        inode_ctx_set (inode, this, &need_lookup);
+    inode_ctx_set(inode, this, &need_lookup);
 
-        return;
+    return;
 }
 
 /* Function behaviour:
@@ -1948,264 +2020,259 @@ inode_set_need_lookup (inode_t *inode, xlator_t *this)
  * needed.
  */
 gf_boolean_t
-inode_needs_lookup (inode_t *inode, xlator_t *this)
-{
-        uint64_t     need_lookup = 0;
-        gf_boolean_t ret         = _gf_false;
-        int          op_ret      = -1;
-
-        if (!inode || !this)
-                return ret;
-
-        op_ret = inode_ctx_get (inode, this, &need_lookup);
-        if (op_ret == -1) {
-                ret = _gf_true;
-        } else if (need_lookup == LOOKUP_NEEDED) {
-                ret = _gf_true;
-                need_lookup = LOOKUP_NOT_NEEDED;
-                inode_ctx_set (inode, this, &need_lookup);
-        }
+inode_needs_lookup(inode_t *inode, xlator_t *this)
+{
+    uint64_t need_lookup = 0;
+    gf_boolean_t ret = _gf_false;
+    int op_ret = -1;
 
+    if (!inode || !this)
         return ret;
-}
-
-int
-__inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                  uint64_t *value2_p)
-{
-        int ret = 0;
-        int set_idx = -1;
 
-        if (!inode || !xlator || !inode->_ctx)
-                return -1;
+    op_ret = inode_ctx_get(inode, this, &need_lookup);
+    if (op_ret == -1) {
+        ret = _gf_true;
+    } else if (need_lookup == LOOKUP_NEEDED) {
+        ret = _gf_true;
+        need_lookup = LOOKUP_NOT_NEEDED;
+        inode_ctx_set(inode, this, &need_lookup);
+    }
 
-        set_idx = __inode_get_xl_index (inode, xlator);
-        if (set_idx == -1) {
-                ret = -1;
-                goto out;;
-        }
+    return ret;
+}
 
-        inode->_ctx[set_idx].xl_key = xlator;
-        if (value1_p)
-                inode->_ctx[set_idx].value1 = *value1_p;
-        if (value2_p)
-                inode->_ctx[set_idx].value2 = *value2_p;
+int
+__inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+                 uint64_t *value2_p)
+{
+    int ret = 0;
+    int set_idx = -1;
+
+    if (!inode || !xlator || !inode->_ctx)
+        return -1;
+
+    set_idx = __inode_get_xl_index(inode, xlator);
+    if (set_idx == -1) {
+        ret = -1;
+        goto out;
+        ;
+    }
+
+    inode->_ctx[set_idx].xl_key = xlator;
+    if (value1_p)
+        inode->_ctx[set_idx].value1 = *value1_p;
+    if (value2_p)
+        inode->_ctx[set_idx].value2 = *value2_p;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+__inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        return __inode_ctx_set2 (inode, xlator, value1_p, NULL);
+    return __inode_ctx_set2(inode, xlator, value1_p, NULL);
 }
 
 int
-__inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+__inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        return __inode_ctx_set2 (inode, xlator, NULL, value2_p);
+    return __inode_ctx_set2(inode, xlator, NULL, value2_p);
 }
 
-
 int
-inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                uint64_t *value2_p)
+inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+               uint64_t *value2_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set2 (inode, xlator, value1_p, value2_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set2(inode, xlator, value1_p, value2_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set1 (inode, xlator, value2_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set1(inode, xlator, value2_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 int
-inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set0 (inode, xlator, value1_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set0(inode, xlator, value1_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                  uint64_t *value2)
+__inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                 uint64_t *value2)
 {
-        int index = 0;
-        int ret = -1;
+    int index = 0;
+    int ret = -1;
 
-        if (!inode || !xlator || !inode->_ctx)
-                goto out;
+    if (!inode || !xlator || !inode->_ctx)
+        goto out;
 
-        index = xlator->xl_id;
-        if (inode->_ctx[index].xl_key != xlator)
-                goto out;
+    index = xlator->xl_id;
+    if (inode->_ctx[index].xl_key != xlator)
+        goto out;
 
-        if (inode->_ctx[index].value1) {
-                if (value1) {
-                        *value1 = inode->_ctx[index].value1;
-                        ret = 0;
-                }
+    if (inode->_ctx[index].value1) {
+        if (value1) {
+            *value1 = inode->_ctx[index].value1;
+            ret = 0;
         }
-        if (inode->_ctx[index].value2) {
-                if (value2) {
-                        *value2 = inode->_ctx[index].value2;
-                        ret = 0;
-                }
+    }
+    if (inode->_ctx[index].value2) {
+        if (value2) {
+            *value2 = inode->_ctx[index].value2;
+            ret = 0;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-__inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+__inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1)
 {
-        uint64_t tmp_value = 0;
-        int ret = 0;
+    uint64_t tmp_value = 0;
+    int ret = 0;
 
-        ret =  __inode_ctx_get2 (inode, xlator, &tmp_value, NULL);
-        if (!ret && value1)
-                *value1 = tmp_value;
+    ret = __inode_ctx_get2(inode, xlator, &tmp_value, NULL);
+    if (!ret && value1)
+        *value1 = tmp_value;
 
-        return ret;
+    return ret;
 }
 
 int
-__inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+__inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2)
 {
-        uint64_t tmp_value = 0;
-        int ret = 0;
+    uint64_t tmp_value = 0;
+    int ret = 0;
 
-        ret =  __inode_ctx_get2 (inode, xlator, NULL, &tmp_value);
-        if (!ret && value2)
-                *value2 = tmp_value;
+    ret = __inode_ctx_get2(inode, xlator, NULL, &tmp_value);
+    if (!ret && value2)
+        *value2 = tmp_value;
 
-        return ret;
+    return ret;
 }
 
-
 int
-inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2)
+inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get2 (inode, xlator, value1, value2);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get2(inode, xlator, value1, value2);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get1 (inode, xlator, value2);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get1(inode, xlator, value2);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get0 (inode, xlator, value1);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get0(inode, xlator, value1);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2)
+inode_ctx_del2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                if (!inode->_ctx)
-                        goto unlock;
+    LOCK(&inode->lock);
+    {
+        if (!inode->_ctx)
+            goto unlock;
 
-                index = xlator->xl_id;
-                if (inode->_ctx[index].xl_key != xlator) {
-                        ret = -1;
-                        goto unlock;
-                }
+        index = xlator->xl_id;
+        if (inode->_ctx[index].xl_key != xlator) {
+            ret = -1;
+            goto unlock;
+        }
 
-                if (inode->_ctx[index].value1 && value1)
-                        *value1 = inode->_ctx[index].value1;
-                if (inode->_ctx[index].value2 && value2)
-                        *value2 = inode->_ctx[index].value2;
+        if (inode->_ctx[index].value1 && value1)
+            *value1 = inode->_ctx[index].value1;
+        if (inode->_ctx[index].value2 && value2)
+            *value2 = inode->_ctx[index].value2;
 
-                inode->_ctx[index].key    = 0;
-                inode->_ctx[index].xl_key = NULL;
-                inode->_ctx[index].value1 = 0;
-                inode->_ctx[index].value2 = 0;
-        }
+        inode->_ctx[index].key = 0;
+        inode->_ctx[index].xl_key = NULL;
+        inode->_ctx[index].value1 = 0;
+        inode->_ctx[index].value2 = 0;
+    }
 unlock:
-        UNLOCK (&inode->lock);
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 /* function behavior:
@@ -2216,358 +2283,368 @@ unlock:
  - if both are set, both fields are reset.
 */
 static int
-__inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                    uint64_t *value2)
+__inode_ctx_reset2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                   uint64_t *value2)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                index = xlator->xl_id;
-                if (inode->_ctx[index].xl_key != xlator) {
-                        ret = -1;
-                        goto unlock;
-                }
+    LOCK(&inode->lock);
+    {
+        index = xlator->xl_id;
+        if (inode->_ctx[index].xl_key != xlator) {
+            ret = -1;
+            goto unlock;
+        }
 
-                if (inode->_ctx[index].value1 && value1) {
-                        *value1 = inode->_ctx[index].value1;
-                        inode->_ctx[index].value1 = 0;
-                }
-                if (inode->_ctx[index].value2 && value2) {
-                        *value2 = inode->_ctx[index].value2;
-                        inode->_ctx[index].value2 = 0;
-                }
+        if (inode->_ctx[index].value1 && value1) {
+            *value1 = inode->_ctx[index].value1;
+            inode->_ctx[index].value1 = 0;
         }
+        if (inode->_ctx[index].value2 && value2) {
+            *value2 = inode->_ctx[index].value2;
+            inode->_ctx[index].value2 = 0;
+        }
+    }
 unlock:
-        UNLOCK (&inode->lock);
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                  uint64_t *value2_p)
-{
-        uint64_t tmp_value1 = 0;
-        uint64_t tmp_value2 = 0;
-        int ret = 0;
-
-        ret =  __inode_ctx_reset2 (inode, xlator, &tmp_value1, &tmp_value2);
-        if (!ret) {
-                if (value1_p)
-                        *value1_p = tmp_value1;
-                if (value2_p)
-                        *value2_p = tmp_value2;
-        }
-        return ret;
+inode_ctx_reset2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+                 uint64_t *value2_p)
+{
+    uint64_t tmp_value1 = 0;
+    uint64_t tmp_value2 = 0;
+    int ret = 0;
+
+    ret = __inode_ctx_reset2(inode, xlator, &tmp_value1, &tmp_value2);
+    if (!ret) {
+        if (value1_p)
+            *value1_p = tmp_value1;
+        if (value2_p)
+            *value2_p = tmp_value2;
+    }
+    return ret;
 }
 
 int
-inode_ctx_reset1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+inode_ctx_reset1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        uint64_t tmp_value2 = 0;
-        int ret = 0;
+    uint64_t tmp_value2 = 0;
+    int ret = 0;
 
-        ret = __inode_ctx_reset2 (inode, xlator, NULL, &tmp_value2);
+    ret = __inode_ctx_reset2(inode, xlator, NULL, &tmp_value2);
 
-        if (!ret && value2_p)
-                *value2_p = tmp_value2;
-
-        return ret;
+    if (!ret && value2_p)
+        *value2_p = tmp_value2;
 
+    return ret;
 }
 int
-inode_ctx_reset0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+inode_ctx_reset0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        uint64_t tmp_value1 = 0;
-        int ret = 0;
+    uint64_t tmp_value1 = 0;
+    int ret = 0;
 
-        ret = __inode_ctx_reset2 (inode, xlator, &tmp_value1, NULL);
+    ret = __inode_ctx_reset2(inode, xlator, &tmp_value1, NULL);
 
-        if (!ret && value1_p)
-                *value1_p = tmp_value1;
+    if (!ret && value1_p)
+        *value1_p = tmp_value1;
 
-        return ret;
+    return ret;
 }
 
 int
-inode_is_linked (inode_t *inode)
+inode_is_linked(inode_t *inode)
 {
-        int            ret   = 0;
-        inode_table_t *table = NULL;
+    int ret = 0;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return 0;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                ret = __is_inode_hashed (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        ret = __is_inode_hashed(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-inode_dump (inode_t *inode, char *prefix)
-{
-        int                ret       = -1;
-        xlator_t          *xl        = NULL;
-        int                i         = 0;
-        fd_t              *fd        = NULL;
-        struct _inode_ctx *inode_ctx = NULL;
-        struct list_head   fd_list;
-        int                ref       = 0;
-        char               key[GF_DUMP_MAX_BUF_LEN];
-
-        if (!inode)
-                return;
-
-        memset(key, 0, sizeof(key));
-        INIT_LIST_HEAD (&fd_list);
-
-        ret = TRY_LOCK(&inode->lock);
-        if (ret != 0) {
-                return;
-        }
+inode_dump(inode_t *inode, char *prefix)
+{
+    int ret = -1;
+    xlator_t *xl = NULL;
+    int i = 0;
+    fd_t *fd = NULL;
+    struct _inode_ctx *inode_ctx = NULL;
+    struct list_head fd_list;
+    int ref = 0;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    uint64_t nlookup = 0;
+
+    if (!inode)
+        return;
 
-        {
-                gf_proc_dump_write("gfid", "%s", uuid_utoa (inode->gfid));
-                gf_proc_dump_write("nlookup", "%ld", inode->nlookup);
-                gf_proc_dump_write("fd-count", "%u", inode->fd_count);
-                gf_proc_dump_write("ref", "%u", inode->ref);
-                gf_proc_dump_write("ia_type", "%d", inode->ia_type);
-                if (inode->_ctx) {
-                        inode_ctx = GF_CALLOC (inode->table->ctxcount,
-                                               sizeof (*inode_ctx),
-                                               gf_common_mt_inode_ctx);
-                        if (inode_ctx == NULL) {
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < inode->table->ctxcount;
-                             i++) {
-                                inode_ctx[i] = inode->_ctx[i];
-                                xl = inode_ctx[i].xl_key;
-                                ref = inode_ctx[i].ref;
-                                if (ref != 0 && xl) {
-                                        gf_proc_dump_build_key (key,
-                                                                "ref_by_xl:",
-                                                                "%s",
-                                                                xl->name);
-                                        gf_proc_dump_write (key, "%d", ref);
-                                }
-                        }
-                }
+    INIT_LIST_HEAD(&fd_list);
 
-		if (dump_options.xl_options.dump_fdctx != _gf_true)
-			goto unlock;
+    ret = TRY_LOCK(&inode->lock);
+    if (ret != 0) {
+        return;
+    }
+
+    {
+        nlookup = GF_ATOMIC_GET(inode->nlookup);
+        gf_proc_dump_write("gfid", "%s", uuid_utoa(inode->gfid));
+        gf_proc_dump_write("nlookup", "%" PRIu64, nlookup);
+        gf_proc_dump_write("fd-count", "%u", inode->fd_count);
+        gf_proc_dump_write("active-fd-count", "%u", inode->active_fd_count);
+        gf_proc_dump_write("ref", "%u", inode->ref);
+        gf_proc_dump_write("invalidate-sent", "%d", inode->invalidate_sent);
+        gf_proc_dump_write("ia_type", "%d", inode->ia_type);
+        if (inode->_ctx) {
+            inode_ctx = GF_CALLOC(inode->table->ctxcount, sizeof(*inode_ctx),
+                                  gf_common_mt_inode_ctx);
+            if (inode_ctx == NULL) {
+                goto unlock;
+            }
+
+            for (i = 0; i < inode->table->ctxcount; i++) {
+                inode_ctx[i] = inode->_ctx[i];
+                xl = inode_ctx[i].xl_key;
+                ref = inode_ctx[i].ref;
+                if (ref != 0 && xl) {
+                    gf_proc_dump_build_key(key, "ref_by_xl:", "%s", xl->name);
+                    gf_proc_dump_write(key, "%d", ref);
+                }
+            }
+        }
 
+        if (dump_options.xl_options.dump_fdctx != _gf_true)
+            goto unlock;
 
-                list_for_each_entry (fd, &inode->fd_list, inode_list) {
-                        fd_ctx_dump (fd, prefix);
-                }
+        list_for_each_entry(fd, &inode->fd_list, inode_list)
+        {
+            fd_ctx_dump(fd, prefix);
         }
+    }
 unlock:
-        UNLOCK(&inode->lock);
-
-        if (inode_ctx && (dump_options.xl_options.dump_inodectx == _gf_true)) {
-                for (i = 0; i < inode->table->ctxcount; i++) {
-                        if (inode_ctx[i].xl_key) {
-                                xl = (xlator_t *)(long)inode_ctx[i].xl_key;
-                                if (xl->dumpops && xl->dumpops->inodectx)
-                                        xl->dumpops->inodectx (xl, inode);
-                        }
-                }
+    UNLOCK(&inode->lock);
+
+    if (inode_ctx && (dump_options.xl_options.dump_inodectx == _gf_true)) {
+        for (i = 0; i < inode->table->ctxcount; i++) {
+            if (inode_ctx[i].xl_key) {
+                xl = (xlator_t *)(long)inode_ctx[i].xl_key;
+                if (xl->dumpops && xl->dumpops->inodectx)
+                    xl->dumpops->inodectx(xl, inode);
+            }
         }
+    }
 
-        GF_FREE (inode_ctx);
+    GF_FREE(inode_ctx);
 
-        return;
+    return;
 }
 
 void
-inode_table_dump (inode_table_t *itable, char *prefix)
+inode_table_dump(inode_table_t *itable, char *prefix)
 {
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int ret = 0;
 
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     ret = 0;
-
-        if (!itable)
-                return;
+    if (!itable)
+        return;
 
-        memset(key, 0, sizeof(key));
-        ret = pthread_mutex_trylock(&itable->lock);
+    ret = pthread_mutex_trylock(&itable->lock);
 
-        if (ret != 0) {
-                return;
-        }
+    if (ret != 0) {
+        return;
+    }
 
-        gf_proc_dump_build_key(key, prefix, "hashsize");
-        gf_proc_dump_write(key, "%d", itable->hashsize);
-        gf_proc_dump_build_key(key, prefix, "name");
-        gf_proc_dump_write(key, "%s", itable->name);
+    gf_proc_dump_build_key(key, prefix, "hashsize");
+    gf_proc_dump_write(key, "%" GF_PRI_SIZET, itable->hashsize);
+    gf_proc_dump_build_key(key, prefix, "name");
+    gf_proc_dump_write(key, "%s", itable->name);
 
-        gf_proc_dump_build_key(key, prefix, "lru_limit");
-        gf_proc_dump_write(key, "%d", itable->lru_limit);
-        gf_proc_dump_build_key(key, prefix, "active_size");
-        gf_proc_dump_write(key, "%d", itable->active_size);
-        gf_proc_dump_build_key(key, prefix, "lru_size");
-        gf_proc_dump_write(key, "%d", itable->lru_size);
-        gf_proc_dump_build_key(key, prefix, "purge_size");
-        gf_proc_dump_write(key, "%d", itable->purge_size);
+    gf_proc_dump_build_key(key, prefix, "lru_limit");
+    gf_proc_dump_write(key, "%d", itable->lru_limit);
+    gf_proc_dump_build_key(key, prefix, "active_size");
+    gf_proc_dump_write(key, "%d", itable->active_size);
+    gf_proc_dump_build_key(key, prefix, "lru_size");
+    gf_proc_dump_write(key, "%d", itable->lru_size);
+    gf_proc_dump_build_key(key, prefix, "purge_size");
+    gf_proc_dump_write(key, "%d", itable->purge_size);
+    gf_proc_dump_build_key(key, prefix, "invalidate_size");
+    gf_proc_dump_write(key, "%d", itable->invalidate_size);
 
-        INODE_DUMP_LIST(&itable->active, key, prefix, "active");
-        INODE_DUMP_LIST(&itable->lru, key, prefix, "lru");
-        INODE_DUMP_LIST(&itable->purge, key, prefix, "purge");
+    INODE_DUMP_LIST(&itable->active, key, prefix, "active");
+    INODE_DUMP_LIST(&itable->lru, key, prefix, "lru");
+    INODE_DUMP_LIST(&itable->purge, key, prefix, "purge");
+    INODE_DUMP_LIST(&itable->invalidate, key, prefix, "invalidate");
 
-        pthread_mutex_unlock(&itable->lock);
+    pthread_mutex_unlock(&itable->lock);
 }
 
 void
-inode_dump_to_dict (inode_t *inode, char *prefix, dict_t *dict)
+inode_dump_to_dict(inode_t *inode, char *prefix, dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    uint64_t nlookup = 0;
 
-        ret = TRY_LOCK (&inode->lock);
-        if (ret)
-                return;
+    ret = TRY_LOCK(&inode->lock);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_set_dynstr (dict, key, gf_strdup (uuid_utoa (inode->gfid)));
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_set_dynstr(dict, key, gf_strdup(uuid_utoa(inode->gfid)));
+    if (ret)
+        goto out;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_set_uint64 (dict, key, inode->nlookup);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    nlookup = GF_ATOMIC_GET(inode->nlookup);
+    ret = dict_set_uint64(dict, key, nlookup);
+    if (ret)
+        goto out;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_set_uint32 (dict, key, inode->ref);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_set_uint32(dict, key, inode->ref);
+    if (ret)
+        goto out;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_set_int32 (dict, key, inode->ia_type);
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_set_int32(dict, key, inode->ia_type);
+    if (ret)
+        goto out;
 
 out:
-        UNLOCK (&inode->lock);
-        return;
+    UNLOCK(&inode->lock);
+    return;
 }
 
 void
-inode_table_dump_to_dict (inode_table_t *itable, char *prefix, dict_t *dict)
-{
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             ret = 0;
-        inode_t         *inode = NULL;
-        int             count = 0;
-
-        ret = pthread_mutex_trylock (&itable->lock);
-        if (ret)
-                return;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.itable.active_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->active_size);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.itable.lru_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->lru_size);
-        if (ret)
-                goto out;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.itable.purge_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->purge_size);
-        if (ret)
-                goto out;
-
-        list_for_each_entry (inode, &itable->active, list) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.itable.active%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
-        count = 0;
-
-        list_for_each_entry (inode, &itable->lru, list) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.itable.lru%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
-        count = 0;
+inode_table_dump_to_dict(inode_table_t *itable, char *prefix, dict_t *dict)
+{
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int ret = 0;
+#ifdef DEBUG
+    inode_t *inode = NULL;
+    int count = 0;
+#endif
+    ret = pthread_mutex_trylock(&itable->lock);
+    if (ret)
+        return;
 
-        list_for_each_entry (inode, &itable->purge, list) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.itable.purge%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
+    snprintf(key, sizeof(key), "%s.itable.lru_limit", prefix);
+    ret = dict_set_uint32(dict, key, itable->lru_limit);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.itable.active_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->active_size);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.itable.lru_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->lru_size);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.itable.purge_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->purge_size);
+    if (ret)
+        goto out;
+
+#ifdef DEBUG
+    /* Dumping inode details in dictionary and sending it to CLI is not
+       required as when a developer (or support team) asks for this command
+       output, they just want to get top level detail of inode table.
+       If one wants to debug, let them take statedump and debug, this
+       wouldn't be available in CLI during production setup.
+    */
+    list_for_each_entry(inode, &itable->active, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.active%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
+    count = 0;
+
+    list_for_each_entry(inode, &itable->lru, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.lru%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
+    count = 0;
+
+    list_for_each_entry(inode, &itable->purge, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.purge%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
+#endif
 
 out:
-        pthread_mutex_unlock (&itable->lock);
+    pthread_mutex_unlock(&itable->lock);
 
-        return;
+    return;
 }
 
 size_t
-inode_ctx_size (inode_t *inode)
+inode_ctx_size(inode_t *inode)
 {
-        int       i    = 0;
-        size_t    size = 0;
-        xlator_t *xl   = NULL, *old_THIS = NULL;
+    int i = 0;
+    size_t size = 0;
+    xlator_t *xl = NULL, *old_THIS = NULL;
 
-        if (!inode)
-                goto out;
+    if (!inode)
+        goto out;
 
-        LOCK (&inode->lock);
-        {
-                for (i = 0; i < inode->table->ctxcount; i++) {
-                        if (!inode->_ctx[i].xl_key)
-                                continue;
-
-                        xl = (xlator_t *)(long)inode->_ctx[i].xl_key;
-                        old_THIS = THIS;
-                        THIS = xl;
-
-                        /* If inode ref is taken when THIS is global xlator,
-                         * the ctx xl_key is set, but the value is NULL.
-                         * For global xlator the cbks can be NULL, hence check
-                         * for the same */
-                        if (!xl->cbks) {
-                                THIS = old_THIS;
-                                continue;
-                        }
-
-                        if (xl->cbks->ictxsize)
-                                size += xl->cbks->ictxsize (xl, inode);
-
-                        THIS = old_THIS;
-                }
+    LOCK(&inode->lock);
+    {
+        for (i = 0; i < inode->table->ctxcount; i++) {
+            if (!inode->_ctx[i].xl_key)
+                continue;
+
+            xl = (xlator_t *)(long)inode->_ctx[i].xl_key;
+            old_THIS = THIS;
+            THIS = xl;
+
+            /* If inode ref is taken when THIS is global xlator,
+             * the ctx xl_key is set, but the value is NULL.
+             * For global xlator the cbks can be NULL, hence check
+             * for the same */
+            if (!xl->cbks) {
+                THIS = old_THIS;
+                continue;
+            }
+
+            if (xl->cbks->ictxsize)
+                size += xl->cbks->ictxsize(xl, inode);
+
+            THIS = old_THIS;
         }
-        UNLOCK (&inode->lock);
+    }
+    UNLOCK(&inode->lock);
 
 out:
-        return size;
+    return size;
 }
 
 /* *
@@ -2577,23 +2654,24 @@ out:
  * not possible(no hardlinks)
  * */
 void
-inode_find_directory_name (inode_t *inode, const char **name) {
-        dentry_t *dentry = NULL;
+inode_find_directory_name(inode_t *inode, const char **name)
+{
+    dentry_t *dentry = NULL;
 
-        GF_VALIDATE_OR_GOTO ("inode", inode, out);
-        GF_VALIDATE_OR_GOTO ("inode", name, out);
+    GF_VALIDATE_OR_GOTO("inode", inode, out);
+    GF_VALIDATE_OR_GOTO("inode", name, out);
 
-        if (!IA_ISDIR (inode->ia_type))
-                return;
+    if (!IA_ISDIR(inode->ia_type))
+        return;
 
-        pthread_mutex_lock (&inode->table->lock);
-        {
-                dentry = __dentry_search_arbit (inode);
-                if (dentry) {
-                        *name = dentry->name;
-                }
+    pthread_mutex_lock(&inode->table->lock);
+    {
+        dentry = __dentry_search_arbit(inode);
+        if (dentry) {
+            *name = dentry->name;
         }
-        pthread_mutex_unlock (&inode->table->lock);
+    }
+    pthread_mutex_unlock(&inode->table->lock);
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/inode.h b/libglusterfs/src/inode.h
deleted file mode 100644
index b82b6bac2c7..00000000000
--- a/libglusterfs/src/inode.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _INODE_H
-#define _INODE_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#define LOOKUP_NEEDED 1
-#define LOOKUP_NOT_NEEDED 2
-
-#define DEFAULT_INODE_MEMPOOL_ENTRIES   32 * 1024
-#define INODE_PATH_FMT "<gfid:%s>"
-struct _inode_table;
-typedef struct _inode_table inode_table_t;
-
-struct _inode;
-typedef struct _inode inode_t;
-
-struct _dentry;
-typedef struct _dentry dentry_t;
-
-#include "list.h"
-#include "xlator.h"
-#include "iatt.h"
-#include "compat-uuid.h"
-#include "fd.h"
-
-struct _inode_table {
-        pthread_mutex_t    lock;
-        size_t             hashsize;    /* bucket size of inode hash and dentry hash */
-        char              *name;        /* name of the inode table, just for gf_log() */
-        inode_t           *root;        /* root directory inode, with number 1 */
-        xlator_t          *xl;          /* xlator to be called to do purge */
-        uint32_t           lru_limit;   /* maximum LRU cache size */
-        struct list_head  *inode_hash;  /* buckets for inode hash table */
-        struct list_head  *name_hash;   /* buckets for dentry hash table */
-        struct list_head   active;      /* list of inodes currently active (in an fop) */
-        uint32_t           active_size; /* count of inodes in active list */
-        struct list_head   lru;         /* list of inodes recently used.
-                                           lru.next most recent */
-        uint32_t           lru_size;    /* count of inodes in lru list  */
-        struct list_head   purge;       /* list of inodes to be purged soon */
-        uint32_t           purge_size;  /* count of inodes in purge list */
-
-        struct mem_pool   *inode_pool;  /* memory pool for inodes */
-        struct mem_pool   *dentry_pool; /* memory pool for dentrys */
-        struct mem_pool   *fd_mem_pool; /* memory pool for fd_t */
-        int                ctxcount;    /* number of slots in inode->ctx */
-};
-
-
-struct _dentry {
-        struct list_head   inode_list;   /* list of dentries of inode */
-        struct list_head   hash;         /* hash table pointers */
-        inode_t           *inode;        /* inode of this directory entry */
-        char              *name;         /* name of the directory entry */
-        inode_t           *parent;       /* directory of the entry */
-};
-
-struct _inode_ctx {
-        union {
-                uint64_t    key;
-                xlator_t   *xl_key;
-        };
-        /* if value1 is 0, then field is not set.. */
-        union {
-                uint64_t    value1;
-                void       *ptr1;
-        };
-        /* if value2 is 0, then field is not set.. */
-        union {
-                uint64_t    value2;
-                void       *ptr2;
-        };
-        int                 ref; /* This is for debugging inode ref leaks,
-                                    basically helps in identifying the xlator
-                                    causing th ref leak, it is printed in
-                                    statedump */
-};
-
-struct _inode {
-        inode_table_t       *table;         /* the table this inode belongs to */
-        uuid_t               gfid;
-        gf_lock_t            lock;
-        uint64_t             nlookup;
-        uint32_t             fd_count;      /* Open fd count */
-        uint32_t             ref;           /* reference count on this inode */
-        ia_type_t            ia_type;       /* what kind of file */
-        struct list_head     fd_list;       /* list of open files on this inode */
-        struct list_head     dentry_list;   /* list of directory entries for this inode */
-        struct list_head     hash;          /* hash table pointers */
-        struct list_head     list;          /* active/lru/purge */
-
-        struct _inode_ctx   *_ctx;    /* replacement for dict_t *(inode->ctx) */
-};
-
-
-#define UUID0_STR "00000000-0000-0000-0000-000000000000"
-#define GFID_STR_PFX "<gfid:" UUID0_STR ">"
-#define GFID_STR_PFX_LEN (sizeof (GFID_STR_PFX) - 1)
-
-inode_table_t *
-inode_table_new (size_t lru_limit, xlator_t *xl);
-
-void
-inode_table_destroy_all (glusterfs_ctx_t *ctx);
-
-void
-inode_table_destroy (inode_table_t *inode_table);
-
-inode_t *
-inode_new (inode_table_t *table);
-
-inode_t *
-inode_link (inode_t *inode, inode_t *parent,
-            const char *name, struct iatt *stbuf);
-
-void
-inode_unlink (inode_t *inode, inode_t *parent, const char *name);
-
-inode_t *
-inode_parent (inode_t *inode, uuid_t pargfid, const char *name);
-
-inode_t *
-inode_ref (inode_t *inode);
-
-inode_t *
-inode_unref (inode_t *inode);
-
-int
-inode_lookup (inode_t *inode);
-
-int
-inode_forget (inode_t *inode, uint64_t nlookup);
-
-int
-inode_ref_reduce_by_n (inode_t *inode, uint64_t nref);
-
-int
-inode_invalidate(inode_t *inode);
-
-int
-inode_rename (inode_table_t *table, inode_t *olddir, const char *oldname,
-	      inode_t *newdir, const char *newname,
-	      inode_t *inode, struct iatt *stbuf);
-
-dentry_t *
-__dentry_grep (inode_table_t *table, inode_t *parent, const char *name);
-
-inode_t *
-inode_grep (inode_table_t *table, inode_t *parent, const char *name);
-
-int
-inode_grep_for_gfid (inode_table_t *table, inode_t *parent, const char *name,
-                     uuid_t gfid, ia_type_t *type);
-
-inode_t *
-inode_find (inode_table_t *table, uuid_t gfid);
-
-int
-inode_path (inode_t *inode, const char *name, char **bufp);
-
-int
-__inode_path (inode_t *inode, const char *name, char **bufp);
-
-inode_t *
-inode_from_path (inode_table_t *table, const char *path);
-
-inode_t *
-inode_resolve (inode_table_t *table, char *path);
-
-/* deal with inode ctx's both values */
-
-int
-inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2);
-int
-__inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                  uint64_t *value2);
-
-int
-inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2);
-int
-__inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                  uint64_t *value2);
-
-int
-inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2);
-
-int
-inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                  uint64_t *value2);
-
-/* deal with inode ctx's 1st value */
-
-int
-inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
-
-int
-__inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
-
-int
-inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
-int
-__inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
-
-int
-inode_ctx_reset0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
-
-/* deal with inode ctx's 2st value */
-
-int
-inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
-
-int
-__inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
-
-int
-inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
-int
-__inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
-
-int
-inode_ctx_reset1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
-
-
-static inline int
-__inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
-{
-        return __inode_ctx_set0 (inode, this, &v);
-}
-
-static inline int
-inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
-{
-        return inode_ctx_set0 (inode, this, &v);
-}
-
-#define __inode_ctx_set(i,x,v_p) __inode_ctx_set0(i,x,v_p)
-
-#define inode_ctx_set(i,x,v_p) inode_ctx_set0(i,x,v_p)
-
-#define inode_ctx_reset(i,x,v) inode_ctx_reset0(i,x,v)
-
-#define __inode_ctx_get(i,x,v) __inode_ctx_get0(i,x,v)
-
-#define inode_ctx_get(i,x,v) inode_ctx_get0(i,x,v)
-
-#define inode_ctx_del(i,x,v) inode_ctx_del2(i,x,v,0)
-
-gf_boolean_t
-__is_root_gfid (uuid_t gfid);
-
-void
-__inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit);
-
-void
-inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit);
-
-void
-inode_ctx_merge (fd_t *fd, inode_t *inode, inode_t *linked_inode);
-
-int
-inode_is_linked (inode_t *inode);
-
-void
-inode_set_need_lookup (inode_t *inode, xlator_t *this);
-
-gf_boolean_t
-inode_needs_lookup (inode_t *inode, xlator_t *this);
-
-int
-inode_has_dentry (inode_t *inode);
-
-size_t
-inode_ctx_size (inode_t *inode);
-
-void
-inode_find_directory_name (inode_t *inode, const char **name);
-#endif /* _INODE_H */
diff --git a/libglusterfs/src/iobuf.c b/libglusterfs/src/iobuf.c
index 76584fc9cde..4e7d2958764 100644
--- a/libglusterfs/src/iobuf.c
+++ b/libglusterfs/src/iobuf.c
@@ -8,1250 +8,1139 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "iobuf.h"
-#include "statedump.h"
+#include "glusterfs/iobuf.h"
+#include "glusterfs/statedump.h"
 #include <stdio.h>
-#include "libglusterfs-messages.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 /*
   TODO: implement destroy margins and prefetching of arenas
 */
 
-#define IOBUF_ARENA_MAX_INDEX  (sizeof (gf_iobuf_init_config) /         \
-                                (sizeof (struct iobuf_init_config)))
+#define IOBUF_ARENA_MAX_INDEX                                                  \
+    (sizeof(gf_iobuf_init_config) / (sizeof(struct iobuf_init_config)))
 
 /* Make sure this array is sorted based on pagesize */
-struct iobuf_init_config gf_iobuf_init_config[] = {
-        /* { pagesize, num_pages }, */
-        {128, 1024},
-        {512, 512},
-        {2 * 1024, 512},
-        {8 * 1024, 128},
-        {32 * 1024, 64},
-        {128 * 1024, 32},
-        {256 * 1024, 8},
-        {1 * 1024 * 1024, 2},
+static const struct iobuf_init_config gf_iobuf_init_config[] = {
+    /* { pagesize, num_pages }, */
+    {128, 1024},     {512, 512},       {2 * 1024, 512}, {8 * 1024, 128},
+    {32 * 1024, 64}, {128 * 1024, 32}, {256 * 1024, 8}, {1 * 1024 * 1024, 2},
 };
 
-int
-gf_iobuf_get_arena_index (size_t page_size)
+static int
+gf_iobuf_get_arena_index(const size_t page_size)
 {
-        int i = -1;
-
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                if (page_size <= gf_iobuf_init_config[i].pagesize)
-                        break;
-        }
+    int i;
 
-        if (i >= IOBUF_ARENA_MAX_INDEX)
-                i = -1;
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        if (page_size <= gf_iobuf_init_config[i].pagesize)
+            return i;
+    }
 
-        return i;
+    return -1;
 }
 
-
-size_t
-gf_iobuf_get_pagesize (size_t page_size)
+static size_t
+gf_iobuf_get_pagesize(const size_t page_size, int *index)
 {
-        int    i    = 0;
-        size_t size = 0;
-
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                size = gf_iobuf_init_config[i].pagesize;
-                if (page_size <= size)
-                        break;
+    int i;
+    size_t size = 0;
+
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        size = gf_iobuf_init_config[i].pagesize;
+        if (page_size <= size) {
+            if (index != NULL)
+                *index = i;
+            return size;
         }
+    }
 
-        if (i >= IOBUF_ARENA_MAX_INDEX)
-                size = -1;
-
-        return size;
+    return -1;
 }
 
-void
-__iobuf_arena_init_iobufs (struct iobuf_arena *iobuf_arena)
+static void
+__iobuf_arena_init_iobufs(struct iobuf_arena *iobuf_arena)
 {
-        int                 iobuf_cnt = 0;
-        struct iobuf       *iobuf = NULL;
-        int                 offset = 0;
-        int                 i = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        iobuf_cnt  = iobuf_arena->page_count;
-
-        iobuf_arena->iobufs = GF_CALLOC (sizeof (*iobuf), iobuf_cnt,
-                                         gf_common_mt_iobuf);
-        if (!iobuf_arena->iobufs)
-                return;
+    const int iobuf_cnt = iobuf_arena->page_count;
+    struct iobuf *iobuf = NULL;
+    int offset = 0;
+    int i = 0;
+
+    iobuf_arena->iobufs = GF_CALLOC(sizeof(*iobuf), iobuf_cnt,
+                                    gf_common_mt_iobuf);
+    if (!iobuf_arena->iobufs)
+        return;
 
-        iobuf = iobuf_arena->iobufs;
-        for (i = 0; i < iobuf_cnt; i++) {
-                INIT_LIST_HEAD (&iobuf->list);
-                LOCK_INIT (&iobuf->lock);
+    iobuf = iobuf_arena->iobufs;
+    for (i = 0; i < iobuf_cnt; i++) {
+        INIT_LIST_HEAD(&iobuf->list);
+        LOCK_INIT(&iobuf->lock);
 
-                iobuf->iobuf_arena = iobuf_arena;
+        iobuf->iobuf_arena = iobuf_arena;
 
-                iobuf->ptr = iobuf_arena->mem_base + offset;
+        iobuf->ptr = iobuf_arena->mem_base + offset;
 
-                list_add (&iobuf->list, &iobuf_arena->passive.list);
-                iobuf_arena->passive_cnt++;
+        list_add(&iobuf->list, &iobuf_arena->passive.list);
+        iobuf_arena->passive_cnt++;
 
-                offset += iobuf_arena->page_size;
-                iobuf++;
-        }
+        offset += iobuf_arena->page_size;
+        iobuf++;
+    }
 
-out:
-        return;
+    return;
 }
 
-
-void
-__iobuf_arena_destroy_iobufs (struct iobuf_arena *iobuf_arena)
+static void
+__iobuf_arena_destroy_iobufs(struct iobuf_arena *iobuf_arena)
 {
-        int                 iobuf_cnt = 0;
-        struct iobuf       *iobuf = NULL;
-        int                 i = 0;
+    int iobuf_cnt = 0;
+    struct iobuf *iobuf = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        iobuf_cnt  = iobuf_arena->page_count;
+    if (!iobuf_arena->iobufs) {
+        gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0, LG_MSG_IOBUFS_NOT_FOUND,
+                         "iobufs not found");
+        return;
+    }
 
-        if (!iobuf_arena->iobufs) {
-                gf_msg_callingfn (THIS->name, GF_LOG_ERROR, 0,
-                                  LG_MSG_IOBUFS_NOT_FOUND, "iobufs not found");
-                return;
-        }
+    iobuf_cnt = iobuf_arena->page_count;
+    iobuf = iobuf_arena->iobufs;
+    for (i = 0; i < iobuf_cnt; i++) {
+        GF_ASSERT(GF_ATOMIC_GET(iobuf->ref) == 0);
 
-        iobuf = iobuf_arena->iobufs;
-        for (i = 0; i < iobuf_cnt; i++) {
-                GF_ASSERT (iobuf->ref == 0);
+        LOCK_DESTROY(&iobuf->lock);
+        list_del_init(&iobuf->list);
+        iobuf++;
+    }
 
-                LOCK_DESTROY (&iobuf->lock);
-                list_del_init (&iobuf->list);
-                iobuf++;
-        }
+    GF_FREE(iobuf_arena->iobufs);
 
-        GF_FREE (iobuf_arena->iobufs);
-
-out:
-        return;
+    return;
 }
 
-
-void
-__iobuf_arena_destroy (struct iobuf_pool *iobuf_pool,
-                       struct iobuf_arena *iobuf_arena)
+static void
+__iobuf_arena_destroy(struct iobuf_pool *iobuf_pool,
+                      struct iobuf_arena *iobuf_arena)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
 
-        if (iobuf_pool->rdma_deregistration)
-                iobuf_pool->rdma_deregistration (iobuf_pool->mr_list,
-                                                 iobuf_arena);
+    if (iobuf_pool->rdma_deregistration)
+        iobuf_pool->rdma_deregistration(iobuf_pool->mr_list, iobuf_arena);
 
-        __iobuf_arena_destroy_iobufs (iobuf_arena);
+    __iobuf_arena_destroy_iobufs(iobuf_arena);
 
-        if (iobuf_arena->mem_base
-            && iobuf_arena->mem_base != MAP_FAILED)
-                munmap (iobuf_arena->mem_base, iobuf_arena->arena_size);
+    if (iobuf_arena->mem_base && iobuf_arena->mem_base != MAP_FAILED)
+        munmap(iobuf_arena->mem_base, iobuf_arena->arena_size);
 
-        GF_FREE (iobuf_arena);
+    GF_FREE(iobuf_arena);
 out:
-        return;
+    return;
 }
 
-
-struct iobuf_arena *
-__iobuf_arena_alloc (struct iobuf_pool *iobuf_pool, size_t page_size,
-                     int32_t num_iobufs)
+static struct iobuf_arena *
+__iobuf_arena_alloc(struct iobuf_pool *iobuf_pool, size_t page_size,
+                    int32_t num_iobufs)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        size_t              rounded_size = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    size_t rounded_size = 0;
+    int index = 0; /* unused */
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        iobuf_arena = GF_CALLOC (sizeof (*iobuf_arena), 1,
-                                 gf_common_mt_iobuf_arena);
-        if (!iobuf_arena)
-                goto err;
+    iobuf_arena = GF_CALLOC(sizeof(*iobuf_arena), 1, gf_common_mt_iobuf_arena);
+    if (!iobuf_arena)
+        goto err;
 
-        INIT_LIST_HEAD (&iobuf_arena->list);
-        INIT_LIST_HEAD (&iobuf_arena->all_list);
-        INIT_LIST_HEAD (&iobuf_arena->active.list);
-        INIT_LIST_HEAD (&iobuf_arena->passive.list);
-        iobuf_arena->iobuf_pool = iobuf_pool;
+    INIT_LIST_HEAD(&iobuf_arena->list);
+    INIT_LIST_HEAD(&iobuf_arena->all_list);
+    INIT_LIST_HEAD(&iobuf_arena->active.list);
+    INIT_LIST_HEAD(&iobuf_arena->passive.list);
+    iobuf_arena->iobuf_pool = iobuf_pool;
 
-        rounded_size = gf_iobuf_get_pagesize (page_size);
+    rounded_size = gf_iobuf_get_pagesize(page_size, &index);
 
-        iobuf_arena->page_size  = rounded_size;
-        iobuf_arena->page_count = num_iobufs;
+    iobuf_arena->page_size = rounded_size;
+    iobuf_arena->page_count = num_iobufs;
 
-        iobuf_arena->arena_size = rounded_size * num_iobufs;
+    iobuf_arena->arena_size = rounded_size * num_iobufs;
 
-        iobuf_arena->mem_base = mmap (NULL, iobuf_arena->arena_size,
-                                      PROT_READ|PROT_WRITE,
-                                      MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
-        if (iobuf_arena->mem_base == MAP_FAILED) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_MAPPING_FAILED,
-                        "mapping failed");
-                goto err;
-        }
+    iobuf_arena->mem_base = mmap(NULL, iobuf_arena->arena_size,
+                                 PROT_READ | PROT_WRITE,
+                                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (iobuf_arena->mem_base == MAP_FAILED) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_MAPPING_FAILED, NULL);
+        goto err;
+    }
 
-        if (iobuf_pool->rdma_registration) {
-                iobuf_pool->rdma_registration (iobuf_pool->device,
-                                               iobuf_arena);
-        }
+    if (iobuf_pool->rdma_registration) {
+        iobuf_pool->rdma_registration(iobuf_pool->device, iobuf_arena);
+    }
 
-        list_add_tail (&iobuf_arena->all_list, &iobuf_pool->all_arenas);
+    list_add_tail(&iobuf_arena->all_list, &iobuf_pool->all_arenas);
 
-        __iobuf_arena_init_iobufs (iobuf_arena);
-        if (!iobuf_arena->iobufs) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_IOBUF_FAILED,
-                        "init failed");
-                goto err;
-        }
+    __iobuf_arena_init_iobufs(iobuf_arena);
+    if (!iobuf_arena->iobufs) {
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_IOBUF_FAILED, NULL);
+        goto err;
+    }
 
-        iobuf_pool->arena_cnt++;
+    iobuf_pool->arena_cnt++;
 
-        return iobuf_arena;
+    return iobuf_arena;
 
 err:
-        __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
+    __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
 
 out:
-        return NULL;
+    return NULL;
 }
 
-
-struct iobuf_arena *
-__iobuf_arena_unprune (struct iobuf_pool *iobuf_pool, size_t page_size)
+static struct iobuf_arena *
+__iobuf_arena_unprune(struct iobuf_pool *iobuf_pool, const size_t page_size,
+                      const int index)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        struct iobuf_arena *tmp          = NULL;
-        int                 index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
 
-        list_for_each_entry (tmp, &iobuf_pool->purge[index], list) {
-                list_del_init (&tmp->list);
-                iobuf_arena = tmp;
-                break;
-        }
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
+
+    list_for_each_entry(tmp, &iobuf_pool->purge[index], list)
+    {
+        list_del_init(&tmp->list);
+        iobuf_arena = tmp;
+        break;
+    }
 out:
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
-struct iobuf_arena *
-__iobuf_pool_add_arena (struct iobuf_pool *iobuf_pool, size_t page_size,
-                        int32_t num_pages)
+static struct iobuf_arena *
+__iobuf_pool_add_arena(struct iobuf_pool *iobuf_pool, const size_t page_size,
+                       const int32_t num_pages, const int index)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        int                 index        = 0;
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
-
-        iobuf_arena = __iobuf_arena_unprune (iobuf_pool, page_size);
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        if (!iobuf_arena)
-                iobuf_arena = __iobuf_arena_alloc (iobuf_pool, page_size,
-                                                   num_pages);
+    iobuf_arena = __iobuf_arena_unprune(iobuf_pool, page_size, index);
 
+    if (!iobuf_arena) {
+        iobuf_arena = __iobuf_arena_alloc(iobuf_pool, page_size, num_pages);
         if (!iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                return NULL;
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
+                    NULL);
+            return NULL;
         }
-        list_add (&iobuf_arena->list, &iobuf_pool->arenas[index]);
+    }
+    list_add(&iobuf_arena->list, &iobuf_pool->arenas[index]);
 
-
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
-struct iobuf_arena *
-iobuf_pool_add_arena (struct iobuf_pool *iobuf_pool, size_t page_size,
-                      int32_t num_pages)
-{
-        struct iobuf_arena *iobuf_arena = NULL;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                iobuf_arena = __iobuf_pool_add_arena (iobuf_pool, page_size,
-                                                      num_pages);
-        }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
-
-out:
-        return iobuf_arena;
-}
-
-
 /* This function destroys all the iobufs and the iobuf_pool */
 void
-iobuf_pool_destroy (struct iobuf_pool *iobuf_pool)
+iobuf_pool_destroy(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *tmp         = NULL;
-        int                 i           = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->arenas[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->purge[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        /* If there are no iobuf leaks, there should be no
-                         * arenas in the filled list. If at all there are any
-                         * arenas in the filled list, the below function will
-                         * assert.
-                         */
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->filled[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        /* If there are no iobuf leaks, there shoould be
-                         * no standard alloced arenas, iobuf_put will free such
-                         * arenas.
-                         * TODO: Free the stdalloc arenas forcefully if present?
-                         */
-                }
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->arenas[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->purge[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            /* If there are no iobuf leaks, there should be no
+             * arenas in the filled list. If at all there are any
+             * arenas in the filled list, the below function will
+             * assert.
+             */
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->filled[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            /* If there are no iobuf leaks, there shoould be
+             * no standard allocated arenas, iobuf_put will free
+             * such arenas.
+             * TODO: Free the stdalloc arenas forcefully if present?
+             */
         }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
-        pthread_mutex_destroy (&iobuf_pool->mutex);
+    pthread_mutex_destroy(&iobuf_pool->mutex);
 
-        GF_FREE (iobuf_pool);
+    GF_FREE(iobuf_pool);
 
 out:
-        return;
+    return;
 }
 
 static void
-iobuf_create_stdalloc_arena (struct iobuf_pool *iobuf_pool)
+iobuf_create_stdalloc_arena(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        /* No locking required here as its called only once during init */
-        iobuf_arena = GF_CALLOC (sizeof (*iobuf_arena), 1,
-                                 gf_common_mt_iobuf_arena);
-        if (!iobuf_arena)
-                goto err;
+    /* No locking required here as its called only once during init */
+    iobuf_arena = GF_CALLOC(sizeof(*iobuf_arena), 1, gf_common_mt_iobuf_arena);
+    if (!iobuf_arena)
+        goto err;
 
-        INIT_LIST_HEAD (&iobuf_arena->list);
-        INIT_LIST_HEAD (&iobuf_arena->active.list);
-        INIT_LIST_HEAD (&iobuf_arena->passive.list);
+    INIT_LIST_HEAD(&iobuf_arena->list);
+    INIT_LIST_HEAD(&iobuf_arena->active.list);
+    INIT_LIST_HEAD(&iobuf_arena->passive.list);
 
-        iobuf_arena->iobuf_pool = iobuf_pool;
+    iobuf_arena->iobuf_pool = iobuf_pool;
 
-        iobuf_arena->page_size = 0x7fffffff;
+    iobuf_arena->page_size = 0x7fffffff;
 
-        list_add_tail (&iobuf_arena->list,
-                       &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX]);
+    list_add_tail(&iobuf_arena->list,
+                  &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX]);
 
 err:
-        return;
+    return;
 }
 
 struct iobuf_pool *
-iobuf_pool_new (void)
+iobuf_pool_new(void)
 {
-        struct iobuf_pool  *iobuf_pool = NULL;
-        int                 i          = 0;
-        size_t              page_size  = 0;
-        size_t              arena_size = 0;
-        int32_t             num_pages  = 0;
-
-        iobuf_pool = GF_CALLOC (sizeof (*iobuf_pool), 1,
-                                gf_common_mt_iobuf_pool);
-        if (!iobuf_pool)
-                goto out;
-        INIT_LIST_HEAD (&iobuf_pool->all_arenas);
-        pthread_mutex_init (&iobuf_pool->mutex, NULL);
-        for (i = 0; i <= IOBUF_ARENA_MAX_INDEX; i++) {
-                INIT_LIST_HEAD (&iobuf_pool->arenas[i]);
-                INIT_LIST_HEAD (&iobuf_pool->filled[i]);
-                INIT_LIST_HEAD (&iobuf_pool->purge[i]);
-        }
-
-        iobuf_pool->default_page_size  = 128 * GF_UNIT_KB;
-
-        iobuf_pool->rdma_registration = NULL;
-        iobuf_pool->rdma_deregistration = NULL;
-
-        for (i = 0; i < GF_RDMA_DEVICE_COUNT; i++) {
-
-                iobuf_pool->device[i] = NULL;
-                iobuf_pool->mr_list[i] = NULL;
-
-        }
-
-        arena_size = 0;
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                page_size = gf_iobuf_init_config[i].pagesize;
-                num_pages = gf_iobuf_init_config[i].num_pages;
-
-                iobuf_pool_add_arena (iobuf_pool, page_size, num_pages);
-
-                arena_size += page_size * num_pages;
-        }
-
-        /* Need an arena to handle all the bigger iobuf requests */
-        iobuf_create_stdalloc_arena (iobuf_pool);
-
-        iobuf_pool->arena_size = arena_size;
+    struct iobuf_pool *iobuf_pool = NULL;
+    int i = 0;
+    size_t page_size = 0;
+    size_t arena_size = 0;
+    int32_t num_pages = 0;
+
+    iobuf_pool = GF_CALLOC(sizeof(*iobuf_pool), 1, gf_common_mt_iobuf_pool);
+    if (!iobuf_pool)
+        goto out;
+    INIT_LIST_HEAD(&iobuf_pool->all_arenas);
+    pthread_mutex_init(&iobuf_pool->mutex, NULL);
+    for (i = 0; i <= IOBUF_ARENA_MAX_INDEX; i++) {
+        INIT_LIST_HEAD(&iobuf_pool->arenas[i]);
+        INIT_LIST_HEAD(&iobuf_pool->filled[i]);
+        INIT_LIST_HEAD(&iobuf_pool->purge[i]);
+    }
+
+    iobuf_pool->default_page_size = 128 * GF_UNIT_KB;
+
+    iobuf_pool->rdma_registration = NULL;
+    iobuf_pool->rdma_deregistration = NULL;
+
+    for (i = 0; i < GF_RDMA_DEVICE_COUNT; i++) {
+        iobuf_pool->device[i] = NULL;
+        iobuf_pool->mr_list[i] = NULL;
+    }
+
+    /* No locking required here
+     * as no one else can use this pool yet
+     */
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        page_size = gf_iobuf_init_config[i].pagesize;
+        num_pages = gf_iobuf_init_config[i].num_pages;
+
+        if (__iobuf_pool_add_arena(iobuf_pool, page_size, num_pages, i) != NULL)
+            arena_size += page_size * num_pages;
+    }
+
+    /* Need an arena to handle all the bigger iobuf requests */
+    iobuf_create_stdalloc_arena(iobuf_pool);
+
+    iobuf_pool->arena_size = arena_size;
 out:
 
-        return iobuf_pool;
+    return iobuf_pool;
 }
 
-
-void
-__iobuf_arena_prune (struct iobuf_pool *iobuf_pool,
-                     struct iobuf_arena *iobuf_arena, int index)
+static void
+__iobuf_arena_prune(struct iobuf_pool *iobuf_pool,
+                    struct iobuf_arena *iobuf_arena, const int index)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        /* code flow comes here only if the arena is in purge list and we can
-         * free the arena only if we have atleast one arena in 'arenas' list
-         * (ie, at least few iobufs free in arena), that way, there won't
-         * be spurious mmap/unmap of buffers
-         */
-        if (list_empty (&iobuf_pool->arenas[index]))
-                goto out;
+    /* code flow comes here only if the arena is in purge list and we can
+     * free the arena only if we have at least one arena in 'arenas' list
+     * (ie, at least few iobufs free in arena), that way, there won't
+     * be spurious mmap/unmap of buffers
+     */
+    if (list_empty(&iobuf_pool->arenas[index]))
+        goto out;
 
-        /* All cases matched, destroy */
-        list_del_init (&iobuf_arena->list);
-        list_del_init (&iobuf_arena->all_list);
-        iobuf_pool->arena_cnt--;
+    /* All cases matched, destroy */
+    list_del_init(&iobuf_arena->list);
+    list_del_init(&iobuf_arena->all_list);
+    iobuf_pool->arena_cnt--;
 
-        __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
+    __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobuf_pool_prune (struct iobuf_pool *iobuf_pool)
+iobuf_pool_prune(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *tmp         = NULL;
-        int                 i           = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                        if (list_empty (&iobuf_pool->arenas[i])) {
-                                continue;
-                        }
-
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                                  &iobuf_pool->purge[i], list) {
-                                __iobuf_arena_prune (iobuf_pool, iobuf_arena, i);
-                        }
-                }
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+            if (list_empty(&iobuf_pool->arenas[i])) {
+                continue;
+            }
+
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->purge[i],
+                                     list)
+            {
+                __iobuf_arena_prune(iobuf_pool, iobuf_arena, i);
+            }
         }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
-struct iobuf_arena *
-__iobuf_select_arena (struct iobuf_pool *iobuf_pool, size_t page_size)
+/* Always called under the iobuf_pool mutex lock */
+static struct iobuf_arena *
+__iobuf_select_arena(struct iobuf_pool *iobuf_pool, const size_t page_size,
+                     const int index)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        struct iobuf_arena *trav         = NULL;
-        int                 index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
-
-        /* look for unused iobuf from the head-most arena */
-        list_for_each_entry (trav, &iobuf_pool->arenas[index], list) {
-                if (trav->passive_cnt) {
-                        iobuf_arena = trav;
-                        break;
-                }
-        }
-
-        if (!iobuf_arena) {
-                /* all arenas were full, find the right count to add */
-                iobuf_arena = __iobuf_pool_add_arena (iobuf_pool, page_size,
-                                                      gf_iobuf_init_config[index].num_pages);
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *trav = NULL;
+
+    /* look for unused iobuf from the head-most arena */
+    list_for_each_entry(trav, &iobuf_pool->arenas[index], list)
+    {
+        if (trav->passive_cnt) {
+            iobuf_arena = trav;
+            break;
         }
+    }
 
-out:
-        return iobuf_arena;
-}
-
-
-struct iobuf *
-__iobuf_ref (struct iobuf *iobuf)
-{
-        iobuf->ref++;
-
-        return iobuf;
-}
-
-
-struct iobuf *
-__iobuf_unref (struct iobuf *iobuf)
-{
-        iobuf->ref--;
+    if (!iobuf_arena) {
+        /* all arenas were full, find the right count to add */
+        iobuf_arena = __iobuf_pool_add_arena(
+            iobuf_pool, page_size, gf_iobuf_init_config[index].num_pages,
+            index);
+    }
 
-        return iobuf;
+    return iobuf_arena;
 }
 
-struct iobuf *
-__iobuf_get (struct iobuf_arena *iobuf_arena, size_t page_size)
+/* Always called under the iobuf_pool mutex lock */
+static struct iobuf *
+__iobuf_get(struct iobuf_pool *iobuf_pool, const size_t page_size,
+            const int index)
 {
-        struct iobuf      *iobuf        = NULL;
-        struct iobuf_pool *iobuf_pool   = NULL;
-        int                index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        iobuf_pool = iobuf_arena->iobuf_pool;
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        list_for_each_entry (iobuf, &iobuf_arena->passive.list, list)
-                break;
+    /* most eligible arena for picking an iobuf */
+    iobuf_arena = __iobuf_select_arena(iobuf_pool, page_size, index);
+    if (!iobuf_arena)
+        return NULL;
 
-        list_del (&iobuf->list);
-        iobuf_arena->passive_cnt--;
+    list_for_each_entry(iobuf, &iobuf_arena->passive.list, list) break;
 
-        list_add (&iobuf->list, &iobuf_arena->active.list);
-        iobuf_arena->active_cnt++;
+    list_del(&iobuf->list);
+    iobuf_arena->passive_cnt--;
 
-        /* no resetting requied for this element */
-        iobuf_arena->alloc_cnt++;
+    list_add(&iobuf->list, &iobuf_arena->active.list);
+    iobuf_arena->active_cnt++;
 
-        if (iobuf_arena->max_active < iobuf_arena->active_cnt)
-                iobuf_arena->max_active = iobuf_arena->active_cnt;
+    /* no resetting requied for this element */
+    iobuf_arena->alloc_cnt++;
 
-        if (iobuf_arena->passive_cnt == 0) {
-                index = gf_iobuf_get_arena_index (page_size);
-                if (index == -1) {
-                        gf_msg ("iobuf", GF_LOG_ERROR, 0,
-                                LG_MSG_PAGE_SIZE_EXCEEDED, "page_size (%zu) of"
-                                " iobufs in arena being added is greater "
-                                "than max available", page_size);
-                        goto out;
-                }
+    if (iobuf_arena->max_active < iobuf_arena->active_cnt)
+        iobuf_arena->max_active = iobuf_arena->active_cnt;
 
-                list_del (&iobuf_arena->list);
-                list_add (&iobuf_arena->list, &iobuf_pool->filled[index]);
-        }
+    if (iobuf_arena->passive_cnt == 0) {
+        list_del(&iobuf_arena->list);
+        list_add(&iobuf_arena->list, &iobuf_pool->filled[index]);
+    }
 
-out:
-        return iobuf;
+    return iobuf;
 }
 
-struct iobuf *
-iobuf_get_from_stdalloc (struct iobuf_pool *iobuf_pool, size_t page_size)
+static struct iobuf *
+iobuf_get_from_stdalloc(struct iobuf_pool *iobuf_pool, const size_t page_size)
 {
-        struct iobuf       *iobuf       = NULL;
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *trav        = NULL;
-        int                 ret         = -1;
-
-        /* The first arena in the 'MAX-INDEX' will always be used for misc */
-        list_for_each_entry (trav, &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX],
-                             list) {
-                iobuf_arena = trav;
-                break;
-        }
-
-        iobuf = GF_CALLOC (1, sizeof (*iobuf), gf_common_mt_iobuf);
-        if (!iobuf)
-                goto out;
-
-        /* 4096 is the alignment */
-        iobuf->free_ptr = GF_CALLOC (1, ((page_size + GF_IOBUF_ALIGN_SIZE) - 1),
-                                     gf_common_mt_char);
-        if (!iobuf->free_ptr)
-                goto out;
-
-        iobuf->ptr = GF_ALIGN_BUF (iobuf->free_ptr, GF_IOBUF_ALIGN_SIZE);
-        iobuf->iobuf_arena = iobuf_arena;
-        LOCK_INIT (&iobuf->lock);
-
-        /* Hold a ref because you are allocating and using it */
-        iobuf->ref = 1;
-
-        ret = 0;
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *trav = NULL;
+    int ret = -1;
+
+    /* The first arena in the 'MAX-INDEX' will always be used for misc */
+    list_for_each_entry(trav, &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX], list)
+    {
+        iobuf_arena = trav;
+        break;
+    }
+
+    iobuf = GF_CALLOC(1, sizeof(*iobuf), gf_common_mt_iobuf);
+    if (!iobuf)
+        goto out;
+
+    /* 4096 is the alignment */
+    iobuf->free_ptr = GF_CALLOC(1, ((page_size + GF_IOBUF_ALIGN_SIZE) - 1),
+                                gf_common_mt_char);
+    if (!iobuf->free_ptr)
+        goto out;
+
+    iobuf->ptr = GF_ALIGN_BUF(iobuf->free_ptr, GF_IOBUF_ALIGN_SIZE);
+    iobuf->iobuf_arena = iobuf_arena;
+    LOCK_INIT(&iobuf->lock);
+
+    /* Hold a ref because you are allocating and using it */
+    GF_ATOMIC_INIT(iobuf->ref, 1);
+
+    ret = 0;
 out:
-        if (ret && iobuf) {
-                GF_FREE (iobuf->free_ptr);
-                GF_FREE (iobuf);
-                iobuf = NULL;
-        }
+    if (ret && iobuf) {
+        GF_FREE(iobuf->free_ptr);
+        GF_FREE(iobuf);
+        iobuf = NULL;
+    }
 
-        return iobuf;
+    return iobuf;
 }
 
-
 struct iobuf *
-iobuf_get2 (struct iobuf_pool *iobuf_pool, size_t page_size)
+iobuf_get2(struct iobuf_pool *iobuf_pool, size_t page_size)
 {
-        struct iobuf       *iobuf        = NULL;
-        struct iobuf_arena *iobuf_arena  = NULL;
-        size_t              rounded_size = 0;
-
-        if (page_size == 0) {
-                page_size = iobuf_pool->default_page_size;
-        }
-
-        rounded_size = gf_iobuf_get_pagesize (page_size);
-        if (rounded_size == -1) {
-                /* make sure to provide the requested buffer with standard
-                   memory allocations */
-                iobuf = iobuf_get_from_stdalloc (iobuf_pool, page_size);
-
-                gf_msg_debug ("iobuf", 0, "request for iobuf of size %zu "
-                        "is serviced using standard calloc() (%p) as it "
-                        "exceeds the maximum available buffer size",
-                        page_size, iobuf);
-
-                iobuf_pool->request_misses++;
-                return iobuf;
+    struct iobuf *iobuf = NULL;
+    size_t rounded_size = 0;
+    int index = 0;
+
+    if (page_size == 0) {
+        page_size = iobuf_pool->default_page_size;
+    }
+
+    rounded_size = gf_iobuf_get_pagesize(page_size, &index);
+    if (rounded_size == -1) {
+        /* make sure to provide the requested buffer with standard
+           memory allocations */
+        iobuf = iobuf_get_from_stdalloc(iobuf_pool, page_size);
+
+        gf_msg_debug("iobuf", 0,
+                     "request for iobuf of size %zu "
+                     "is serviced using standard calloc() (%p) as it "
+                     "exceeds the maximum available buffer size",
+                     page_size, iobuf);
+
+        iobuf_pool->request_misses++;
+        return iobuf;
+    } else if (index == -1) {
+        gf_smsg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+                "page_size=%zu", page_size, NULL);
+        return NULL;
+    }
+
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        iobuf = __iobuf_get(iobuf_pool, rounded_size, index);
+        if (!iobuf) {
+            pthread_mutex_unlock(&iobuf_pool->mutex);
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_IOBUF_NOT_FOUND,
+                    NULL);
+            goto post_unlock;
         }
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                /* most eligible arena for picking an iobuf */
-                iobuf_arena = __iobuf_select_arena (iobuf_pool, rounded_size);
-                if (!iobuf_arena)
-                        goto unlock;
-
-                iobuf = __iobuf_get (iobuf_arena, rounded_size);
-                if (!iobuf)
-                        goto unlock;
-
-                iobuf_ref (iobuf);
-         }
-unlock:
-        pthread_mutex_unlock (&iobuf_pool->mutex);
-
-        return iobuf;
+        iobuf_ref(iobuf);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
+post_unlock:
+    return iobuf;
 }
 
 struct iobuf *
-iobuf_get_page_aligned (struct iobuf_pool *iobuf_pool, size_t page_size,
-                        size_t align_size)
+iobuf_get_page_aligned(struct iobuf_pool *iobuf_pool, size_t page_size,
+                       size_t align_size)
 {
-        size_t              req_size     = 0;
-        struct iobuf       *iobuf        = NULL;
+    size_t req_size = 0;
+    struct iobuf *iobuf = NULL;
 
-        req_size = page_size;
-
-        if (req_size == 0) {
-                req_size = iobuf_pool->default_page_size;
-        }
+    req_size = page_size;
 
-        iobuf = iobuf_get2 (iobuf_pool, req_size + align_size);
-        if (!iobuf)
-                return NULL;
-        /* If std allocation was used, then free_ptr will be non-NULL. In this
-         * case, we do not want to modify the original free_ptr.
-         * On the other hand, if the buf was gotten through the available
-         * arenas, then we use iobuf->free_ptr to store the original
-         * pointer to the offset into the mmap'd block of memory and in turn
-         * reuse iobuf->ptr to hold the page-aligned address. And finally, in
-         * iobuf_put(), we copy iobuf->free_ptr into iobuf->ptr - back to where
-         * it was originally when __iobuf_get() returned this iobuf.
-         */
-        if (!iobuf->free_ptr)
-                iobuf->free_ptr = iobuf->ptr;
-        iobuf->ptr = GF_ALIGN_BUF (iobuf->ptr, align_size);
+    if (req_size == 0) {
+        req_size = iobuf_pool->default_page_size;
+    }
 
-        return iobuf;
+    iobuf = iobuf_get2(iobuf_pool, req_size + align_size);
+    if (!iobuf)
+        return NULL;
+    /* If std allocation was used, then free_ptr will be non-NULL. In this
+     * case, we do not want to modify the original free_ptr.
+     * On the other hand, if the buf was gotten through the available
+     * arenas, then we use iobuf->free_ptr to store the original
+     * pointer to the offset into the mmap'd block of memory and in turn
+     * reuse iobuf->ptr to hold the page-aligned address. And finally, in
+     * iobuf_put(), we copy iobuf->free_ptr into iobuf->ptr - back to where
+     * it was originally when __iobuf_get() returned this iobuf.
+     */
+    if (!iobuf->free_ptr)
+        iobuf->free_ptr = iobuf->ptr;
+    iobuf->ptr = GF_ALIGN_BUF(iobuf->ptr, align_size);
+
+    return iobuf;
 }
 
 struct iobuf *
-iobuf_get (struct iobuf_pool *iobuf_pool)
+iobuf_get(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf       *iobuf        = NULL;
-        struct iobuf_arena *iobuf_arena  = NULL;
+    struct iobuf *iobuf = NULL;
+    int index = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                /* most eligible arena for picking an iobuf */
-                iobuf_arena = __iobuf_select_arena (iobuf_pool,
-                                                    iobuf_pool->default_page_size);
-                if (!iobuf_arena) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_ARENA_NOT_FOUND, "arena not found");
-                        goto unlock;
-                }
-
-                iobuf = __iobuf_get (iobuf_arena,
-                                     iobuf_pool->default_page_size);
-                if (!iobuf) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_IOBUF_NOT_FOUND, "iobuf not found");
-                        goto unlock;
-                }
-
-                iobuf_ref (iobuf);
+    index = gf_iobuf_get_arena_index(iobuf_pool->default_page_size);
+    if (index == -1) {
+        gf_smsg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+                "page_size=%zu", iobuf_pool->default_page_size, NULL);
+        return NULL;
+    }
+
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        iobuf = __iobuf_get(iobuf_pool, iobuf_pool->default_page_size, index);
+        if (!iobuf) {
+            pthread_mutex_unlock(&iobuf_pool->mutex);
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_IOBUF_NOT_FOUND,
+                    NULL);
+            goto out;
         }
-unlock:
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+
+        iobuf_ref(iobuf);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return iobuf;
+    return iobuf;
 }
 
-void
-__iobuf_put (struct iobuf *iobuf, struct iobuf_arena *iobuf_arena)
+static void
+__iobuf_put(struct iobuf *iobuf, struct iobuf_arena *iobuf_arena)
 {
-        struct iobuf_pool *iobuf_pool = NULL;
-        int                index      = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
-
-        iobuf_pool = iobuf_arena->iobuf_pool;
-
-        index = gf_iobuf_get_arena_index (iobuf_arena->page_size);
-        if (index == -1) {
-                gf_msg_debug ("iobuf", 0, "freeing the iobuf (%p) "
-                        "allocated with standard calloc()", iobuf);
-
-                /* free up properly without bothering about lists and all */
-                LOCK_DESTROY (&iobuf->lock);
-                GF_FREE (iobuf->free_ptr);
-                GF_FREE (iobuf);
-                return;
-        }
-
-        if (iobuf_arena->passive_cnt == 0) {
-                list_del (&iobuf_arena->list);
-                list_add_tail (&iobuf_arena->list, &iobuf_pool->arenas[index]);
-        }
-
-        list_del_init (&iobuf->list);
-        iobuf_arena->active_cnt--;
-
-        if (iobuf->free_ptr) {
-                iobuf->ptr = iobuf->free_ptr;
-                iobuf->free_ptr = NULL;
-        }
-
-        list_add (&iobuf->list, &iobuf_arena->passive.list);
-        iobuf_arena->passive_cnt++;
-
-        if (iobuf_arena->active_cnt == 0) {
-                list_del (&iobuf_arena->list);
-                list_add_tail (&iobuf_arena->list, &iobuf_pool->purge[index]);
-                __iobuf_arena_prune (iobuf_pool, iobuf_arena, index);
-        }
-out:
+    struct iobuf_pool *iobuf_pool = NULL;
+    int index = 0;
+
+    iobuf_pool = iobuf_arena->iobuf_pool;
+
+    index = gf_iobuf_get_arena_index(iobuf_arena->page_size);
+    if (index == -1) {
+        gf_msg_debug("iobuf", 0,
+                     "freeing the iobuf (%p) "
+                     "allocated with standard calloc()",
+                     iobuf);
+
+        /* free up properly without bothering about lists and all */
+        LOCK_DESTROY(&iobuf->lock);
+        GF_FREE(iobuf->free_ptr);
+        GF_FREE(iobuf);
         return;
+    }
+
+    if (iobuf_arena->passive_cnt == 0) {
+        list_del(&iobuf_arena->list);
+        list_add_tail(&iobuf_arena->list, &iobuf_pool->arenas[index]);
+    }
+
+    list_del_init(&iobuf->list);
+    iobuf_arena->active_cnt--;
+
+    if (iobuf->free_ptr) {
+        iobuf->ptr = iobuf->free_ptr;
+        iobuf->free_ptr = NULL;
+    }
+
+    list_add(&iobuf->list, &iobuf_arena->passive.list);
+    iobuf_arena->passive_cnt++;
+
+    if (iobuf_arena->active_cnt == 0) {
+        list_del(&iobuf_arena->list);
+        list_add_tail(&iobuf_arena->list, &iobuf_pool->purge[index]);
+        GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
+        __iobuf_arena_prune(iobuf_pool, iobuf_arena, index);
+    }
+out:
+    return;
 }
 
-
 void
-iobuf_put (struct iobuf *iobuf)
+iobuf_put(struct iobuf *iobuf)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_pool  *iobuf_pool = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        iobuf_arena = iobuf->iobuf_arena;
-        if (!iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                return;
-        }
+    iobuf_arena = iobuf->iobuf_arena;
+    if (!iobuf_arena) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND, NULL);
+        return;
+    }
 
-        iobuf_pool = iobuf_arena->iobuf_pool;
-        if (!iobuf_pool) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_POOL_NOT_FOUND, "iobuf pool not found");
-                return;
-        }
+    iobuf_pool = iobuf_arena->iobuf_pool;
+    if (!iobuf_pool) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND, "iobuf",
+                NULL);
+        return;
+    }
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                __iobuf_put (iobuf, iobuf_arena);
-        }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        __iobuf_put(iobuf, iobuf_arena);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobuf_unref (struct iobuf *iobuf)
+iobuf_unref(struct iobuf *iobuf)
 {
-        int  ref = 0;
+    int ref = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        LOCK (&iobuf->lock);
-        {
-                __iobuf_unref (iobuf);
-                ref = iobuf->ref;
-        }
-        UNLOCK (&iobuf->lock);
+    ref = GF_ATOMIC_DEC(iobuf->ref);
 
-        if (!ref)
-                iobuf_put (iobuf);
+    if (!ref)
+        iobuf_put(iobuf);
 
 out:
-        return;
+    return;
 }
 
-
 struct iobuf *
-iobuf_ref (struct iobuf *iobuf)
+iobuf_ref(struct iobuf *iobuf)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
-
-        LOCK (&iobuf->lock);
-        {
-                __iobuf_ref (iobuf);
-        }
-        UNLOCK (&iobuf->lock);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
+    GF_ATOMIC_INC(iobuf->ref);
 
 out:
-        return iobuf;
+    return iobuf;
 }
 
-
 struct iobref *
-iobref_new ()
+iobref_new()
 {
-        struct iobref *iobref = NULL;
+    struct iobref *iobref = NULL;
 
-        iobref = GF_CALLOC (sizeof (*iobref), 1,
-                            gf_common_mt_iobref);
-        if (!iobref)
-                return NULL;
-
-	iobref->iobrefs = GF_CALLOC (sizeof (*iobref->iobrefs),
-				     16, gf_common_mt_iobrefs);
-	if (!iobref->iobrefs) {
-		GF_FREE (iobref);
-		return NULL;
-	}
+    iobref = GF_MALLOC(sizeof(*iobref), gf_common_mt_iobref);
+    if (!iobref)
+        return NULL;
 
-	iobref->alloced = 16;
-	iobref->used = 0;
+    iobref->iobrefs = GF_CALLOC(sizeof(*iobref->iobrefs), 16,
+                                gf_common_mt_iobrefs);
+    if (!iobref->iobrefs) {
+        GF_FREE(iobref);
+        return NULL;
+    }
 
-        LOCK_INIT (&iobref->lock);
+    iobref->allocated = 16;
+    iobref->used = 0;
 
-        iobref->ref++;
+    LOCK_INIT(&iobref->lock);
 
-        return iobref;
+    GF_ATOMIC_INIT(iobref->ref, 1);
+    return iobref;
 }
 
-
 struct iobref *
-iobref_ref (struct iobref *iobref)
+iobref_ref(struct iobref *iobref)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-
-        LOCK (&iobref->lock);
-        {
-                iobref->ref++;
-        }
-        UNLOCK (&iobref->lock);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_ATOMIC_INC(iobref->ref);
 
 out:
-        return iobref;
+    return iobref;
 }
 
-
 void
-iobref_destroy (struct iobref *iobref)
+iobref_destroy(struct iobref *iobref)
 {
-        int            i = 0;
-        struct iobuf  *iobuf = NULL;
+    int i = 0;
+    struct iobuf *iobuf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        for (i = 0; i < iobref->alloced; i++) {
-                iobuf = iobref->iobrefs[i];
+    for (i = 0; i < iobref->allocated; i++) {
+        iobuf = iobref->iobrefs[i];
 
-                iobref->iobrefs[i] = NULL;
-                if (iobuf)
-                        iobuf_unref (iobuf);
-        }
+        iobref->iobrefs[i] = NULL;
+        if (iobuf)
+            iobuf_unref(iobuf);
+    }
 
-	GF_FREE (iobref->iobrefs);
-        GF_FREE (iobref);
+    GF_FREE(iobref->iobrefs);
+    GF_FREE(iobref);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobref_unref (struct iobref *iobref)
+iobref_unref(struct iobref *iobref)
 {
-        int ref = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    int ref = 0;
 
-        LOCK (&iobref->lock);
-        {
-                ref = (--iobref->ref);
-        }
-        UNLOCK (&iobref->lock);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    ref = GF_ATOMIC_DEC(iobref->ref);
 
-        if (!ref)
-                iobref_destroy (iobref);
+    if (!ref)
+        iobref_destroy(iobref);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobref_clear (struct iobref *iobref)
+iobref_clear(struct iobref *iobref)
 {
-        int i = 0;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        for (; i < iobref->alloced; i++) {
-                if (iobref->iobrefs[i] != NULL) {
-                        iobuf_unref (iobref->iobrefs[i]);
-                } else {
-                        /** iobuf's are attched serially */
-                        break;
-                }
+    for (; i < iobref->allocated; i++) {
+        if (iobref->iobrefs[i] != NULL) {
+            iobuf_unref(iobref->iobrefs[i]);
+        } else {
+            /** iobuf's are attached serially */
+            break;
         }
+    }
 
-        iobref_unref (iobref);
+    iobref_unref(iobref);
 
- out:
-        return;
+out:
+    return;
 }
 
-
 static void
-__iobref_grow (struct iobref *iobref)
+__iobref_grow(struct iobref *iobref)
 {
-	void *newptr = NULL;
-	int i = 0;
-
-	newptr = GF_REALLOC (iobref->iobrefs,
-			     iobref->alloced * 2 * (sizeof (*iobref->iobrefs)));
-	if (newptr) {
-		iobref->iobrefs = newptr;
-		iobref->alloced *= 2;
-
-		for (i = iobref->used; i < iobref->alloced; i++)
-			iobref->iobrefs[i] = NULL;
-	}
+    void *newptr = NULL;
+    int i = 0;
+
+    newptr = GF_REALLOC(iobref->iobrefs,
+                        iobref->allocated * 2 * (sizeof(*iobref->iobrefs)));
+    if (newptr) {
+        iobref->iobrefs = newptr;
+        iobref->allocated *= 2;
+
+        for (i = iobref->used; i < iobref->allocated; i++)
+            iobref->iobrefs[i] = NULL;
+    }
 }
 
-
 int
-__iobref_add (struct iobref *iobref, struct iobuf *iobuf)
+__iobref_add(struct iobref *iobref, struct iobuf *iobuf)
 {
-        int  i = 0;
-        int  ret = -ENOMEM;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
-
-	if (iobref->used == iobref->alloced) {
-		__iobref_grow (iobref);
-
-		if (iobref->used == iobref->alloced) {
-			ret = -ENOMEM;
-			goto out;
-		}
-	}
-
-        for (i = 0; i < iobref->alloced; i++) {
-                if (iobref->iobrefs[i] == NULL) {
-                        iobref->iobrefs[i] = iobuf_ref (iobuf);
-			iobref->used++;
-                        ret = 0;
-                        break;
-                }
+    int i = 0;
+    int ret = -ENOMEM;
+
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
+
+    if (iobref->used == iobref->allocated) {
+        __iobref_grow(iobref);
+
+        if (iobref->used == iobref->allocated) {
+            ret = -ENOMEM;
+            goto out;
         }
+    }
+
+    for (i = 0; i < iobref->allocated; i++) {
+        if (iobref->iobrefs[i] == NULL) {
+            iobref->iobrefs[i] = iobuf_ref(iobuf);
+            iobref->used++;
+            ret = 0;
+            break;
+        }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-iobref_add (struct iobref *iobref, struct iobuf *iobuf)
+iobref_add(struct iobref *iobref, struct iobuf *iobuf)
 {
-        int  ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        LOCK (&iobref->lock);
-        {
-                ret = __iobref_add (iobref, iobuf);
-        }
-        UNLOCK (&iobref->lock);
+    LOCK(&iobref->lock);
+    {
+        ret = __iobref_add(iobref, iobuf);
+    }
+    UNLOCK(&iobref->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-iobref_merge (struct iobref *to, struct iobref *from)
+iobref_merge(struct iobref *to, struct iobref *from)
 {
-        int           i = 0;
-        int           ret = 0;
-        struct iobuf *iobuf = NULL;
+    int i = 0;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", to, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", from, out);
+    GF_VALIDATE_OR_GOTO("iobuf", to, out);
+    GF_VALIDATE_OR_GOTO("iobuf", from, out);
 
-        LOCK (&from->lock);
-        {
-                for (i = 0; i < from->alloced; i++) {
-                        iobuf = from->iobrefs[i];
+    LOCK(&from->lock);
+    {
+        for (i = 0; i < from->allocated; i++) {
+            iobuf = from->iobrefs[i];
 
-                        if (!iobuf)
-                                break;
+            if (!iobuf)
+                break;
 
-                        ret = iobref_add (to, iobuf);
+            ret = iobref_add(to, iobuf);
 
-                        if (ret < 0)
-                                break;
-                }
+            if (ret < 0)
+                break;
         }
-        UNLOCK (&from->lock);
+    }
+    UNLOCK(&from->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 size_t
-iobuf_size (struct iobuf *iobuf)
+iobuf_size(struct iobuf *iobuf)
 {
-        size_t size = 0;
+    size_t size = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        if (!iobuf->iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                goto out;
-        }
+    if (!iobuf->iobuf_arena) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND, NULL);
+        goto out;
+    }
 
-        if (!iobuf->iobuf_arena->iobuf_pool) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND,
-                        "pool not found");
-                goto out;
-        }
+    if (!iobuf->iobuf_arena->iobuf_pool) {
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND, NULL);
+        goto out;
+    }
 
-        size = iobuf->iobuf_arena->page_size;
+    size = iobuf->iobuf_arena->page_size;
 out:
-        return size;
+    return size;
 }
 
-
 size_t
-iobref_size (struct iobref *iobref)
+iobref_size(struct iobref *iobref)
 {
-        size_t size = 0;
-        int    i = 0;
+    size_t size = 0;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        LOCK (&iobref->lock);
-        {
-                for (i = 0; i < iobref->alloced; i++) {
-                        if (iobref->iobrefs[i])
-                                size += iobuf_size (iobref->iobrefs[i]);
-                }
+    LOCK(&iobref->lock);
+    {
+        for (i = 0; i < iobref->allocated; i++) {
+            if (iobref->iobrefs[i])
+                size += iobuf_size(iobref->iobrefs[i]);
         }
-        UNLOCK (&iobref->lock);
+    }
+    UNLOCK(&iobref->lock);
 
 out:
-        return size;
+    return size;
 }
 
 void
-iobuf_info_dump (struct iobuf *iobuf, const char *key_prefix)
+iobuf_info_dump(struct iobuf *iobuf, const char *key_prefix)
 {
-        char   key[GF_DUMP_MAX_BUF_LEN];
-        struct iobuf my_iobuf;
-        int    ret = 0;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    struct iobuf my_iobuf;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        memset(&my_iobuf, 0, sizeof(my_iobuf));
-
-        ret = TRY_LOCK(&iobuf->lock);
-        if (ret) {
-                return;
-        }
-        memcpy(&my_iobuf, iobuf, sizeof(my_iobuf));
-        UNLOCK(&iobuf->lock);
+    ret = TRY_LOCK(&iobuf->lock);
+    if (ret) {
+        return;
+    }
+    memcpy(&my_iobuf, iobuf, sizeof(my_iobuf));
+    UNLOCK(&iobuf->lock);
 
-        gf_proc_dump_build_key(key, key_prefix,"ref");
-        gf_proc_dump_write(key, "%d", my_iobuf.ref);
-        gf_proc_dump_build_key(key, key_prefix,"ptr");
-        gf_proc_dump_write(key, "%p", my_iobuf.ptr);
+    gf_proc_dump_build_key(key, key_prefix, "ref");
+    gf_proc_dump_write(key, "%" GF_PRI_ATOMIC, GF_ATOMIC_GET(my_iobuf.ref));
+    gf_proc_dump_build_key(key, key_prefix, "ptr");
+    gf_proc_dump_write(key, "%p", my_iobuf.ptr);
 
 out:
-        return;
+    return;
 }
 
 void
-iobuf_arena_info_dump (struct iobuf_arena *iobuf_arena, const char *key_prefix)
+iobuf_arena_info_dump(struct iobuf_arena *iobuf_arena, const char *key_prefix)
 {
-        char key[GF_DUMP_MAX_BUF_LEN];
-        int  i = 1;
-        struct iobuf *trav;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        gf_proc_dump_build_key(key, key_prefix,"mem_base");
-        gf_proc_dump_write(key, "%p", iobuf_arena->mem_base);
-        gf_proc_dump_build_key(key, key_prefix, "active_cnt");
-        gf_proc_dump_write(key, "%d", iobuf_arena->active_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "passive_cnt");
-        gf_proc_dump_write(key, "%d", iobuf_arena->passive_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "alloc_cnt");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->alloc_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "max_active");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->max_active);
-        gf_proc_dump_build_key(key, key_prefix, "page_size");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->page_size);
-        list_for_each_entry (trav, &iobuf_arena->active.list, list) {
-                gf_proc_dump_build_key(key, key_prefix,"active_iobuf.%d", i++);
-                gf_proc_dump_add_section(key);
-                iobuf_info_dump(trav, key);
-        }
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 1;
+    struct iobuf *trav;
+
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
+
+    gf_proc_dump_build_key(key, key_prefix, "mem_base");
+    gf_proc_dump_write(key, "%p", iobuf_arena->mem_base);
+    gf_proc_dump_build_key(key, key_prefix, "active_cnt");
+    gf_proc_dump_write(key, "%d", iobuf_arena->active_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "passive_cnt");
+    gf_proc_dump_write(key, "%d", iobuf_arena->passive_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "alloc_cnt");
+    gf_proc_dump_write(key, "%" PRIu64, iobuf_arena->alloc_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "max_active");
+    gf_proc_dump_write(key, "%d", iobuf_arena->max_active);
+    gf_proc_dump_build_key(key, key_prefix, "page_size");
+    gf_proc_dump_write(key, "%" GF_PRI_SIZET, iobuf_arena->page_size);
+    list_for_each_entry(trav, &iobuf_arena->active.list, list)
+    {
+        gf_proc_dump_build_key(key, key_prefix, "active_iobuf.%d", i++);
+        gf_proc_dump_add_section("%s", key);
+        iobuf_info_dump(trav, key);
+    }
 
 out:
-        return;
+    return;
 }
 
 void
-iobuf_stats_dump (struct iobuf_pool *iobuf_pool)
+iobuf_stats_dump(struct iobuf_pool *iobuf_pool)
 {
-        char               msg[1024];
-        struct iobuf_arena *trav = NULL;
-        int                i = 1;
-        int                j = 0;
-        int                ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    char msg[1024];
+    struct iobuf_arena *trav = NULL;
+    int i = 1;
+    int j = 0;
+    int ret = -1;
 
-        memset(msg, 0, sizeof(msg));
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        ret = pthread_mutex_trylock(&iobuf_pool->mutex);
+    ret = pthread_mutex_trylock(&iobuf_pool->mutex);
 
-        if (ret) {
-                return;
+    if (ret) {
+        return;
+    }
+    gf_proc_dump_add_section("iobuf.global");
+    gf_proc_dump_write("iobuf_pool", "%p", iobuf_pool);
+    gf_proc_dump_write("iobuf_pool.default_page_size", "%" GF_PRI_SIZET,
+                       iobuf_pool->default_page_size);
+    gf_proc_dump_write("iobuf_pool.arena_size", "%" GF_PRI_SIZET,
+                       iobuf_pool->arena_size);
+    gf_proc_dump_write("iobuf_pool.arena_cnt", "%d", iobuf_pool->arena_cnt);
+    gf_proc_dump_write("iobuf_pool.request_misses", "%" PRId64,
+                       iobuf_pool->request_misses);
+
+    for (j = 0; j < IOBUF_ARENA_MAX_INDEX; j++) {
+        list_for_each_entry(trav, &iobuf_pool->arenas[j], list)
+        {
+            snprintf(msg, sizeof(msg), "arena.%d", i);
+            gf_proc_dump_add_section("%s", msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
         }
-        gf_proc_dump_add_section("iobuf.global");
-        gf_proc_dump_write("iobuf_pool","%p", iobuf_pool);
-        gf_proc_dump_write("iobuf_pool.default_page_size", "%d",
-                                                iobuf_pool->default_page_size);
-        gf_proc_dump_write("iobuf_pool.arena_size", "%d",
-                           iobuf_pool->arena_size);
-        gf_proc_dump_write("iobuf_pool.arena_cnt", "%d",
-                           iobuf_pool->arena_cnt);
-        gf_proc_dump_write("iobuf_pool.request_misses", "%"PRId64,
-                           iobuf_pool->request_misses);
-
-        for (j = 0; j < IOBUF_ARENA_MAX_INDEX; j++) {
-                list_for_each_entry (trav, &iobuf_pool->arenas[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "arena.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-                list_for_each_entry (trav, &iobuf_pool->purge[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "purge.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-                list_for_each_entry (trav, &iobuf_pool->filled[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "filled.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-
+        list_for_each_entry(trav, &iobuf_pool->purge[j], list)
+        {
+            snprintf(msg, sizeof(msg), "purge.%d", i);
+            gf_proc_dump_add_section("%s", msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
         }
+        list_for_each_entry(trav, &iobuf_pool->filled[j], list)
+        {
+            snprintf(msg, sizeof(msg), "filled.%d", i);
+            gf_proc_dump_add_section("%s", msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
+        }
+    }
 
-        pthread_mutex_unlock(&iobuf_pool->mutex);
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
 void
 iobuf_to_iovec(struct iobuf *iob, struct iovec *iov)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iob, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iov, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iob, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iov, out);
 
-        iov->iov_base = iobuf_ptr (iob);
-        iov->iov_len =  iobuf_pagesize (iob);
+    iov->iov_base = iobuf_ptr(iob);
+    iov->iov_len = iobuf_pagesize(iob);
 
 out:
-        return;
+    return;
+}
+
+int
+iobuf_copy(struct iobuf_pool *iobuf_pool, const struct iovec *iovec_src,
+           int iovcnt, struct iobref **iobref, struct iobuf **iobuf,
+           struct iovec *iov_dst)
+{
+    size_t size = -1;
+    int ret = 0;
+
+    size = iov_length(iovec_src, iovcnt);
+
+    *iobuf = iobuf_get2(iobuf_pool, size);
+    if (!(*iobuf)) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    *iobref = iobref_new();
+    if (!(*iobref)) {
+        iobuf_unref(*iobuf);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = iobref_add(*iobref, *iobuf);
+    if (ret) {
+        iobuf_unref(*iobuf);
+        iobref_unref(*iobref);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    iov_unload(iobuf_ptr(*iobuf), iovec_src, iovcnt);
+
+    iov_dst->iov_base = iobuf_ptr(*iobuf);
+    iov_dst->iov_len = size;
+
+out:
+    return ret;
 }
diff --git a/libglusterfs/src/iobuf.h b/libglusterfs/src/iobuf.h
deleted file mode 100644
index 03aa954bbdd..00000000000
--- a/libglusterfs/src/iobuf.h
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _IOBUF_H_
-#define _IOBUF_H_
-
-#include "list.h"
-#include "common-utils.h"
-#include <pthread.h>
-#include <sys/mman.h>
-#include <sys/uio.h>
-
-#define GF_VARIABLE_IOBUF_COUNT 32
-
-#define GF_RDMA_DEVICE_COUNT 8
-
-/* Lets try to define the new anonymous mapping
- * flag, in case the system is still using the
- * now deprecated MAP_ANON flag.
- *
- * Also, this should ideally be in a centralized/common
- * header which can be used by other source files also.
- */
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#define GF_ALIGN_BUF(ptr,bound) ((void *)((unsigned long)(ptr + bound - 1) & \
-                                          (unsigned long)(~(bound - 1))))
-
-#define GF_IOBUF_ALIGN_SIZE 512
-
-/* one allocatable unit for the consumers of the IOBUF API */
-/* each unit hosts @page_size bytes of memory */
-struct iobuf;
-
-/* one region of memory MMAPed from the operating system */
-/* each region MMAPs @arena_size bytes of memory */
-/* each arena hosts @arena_size / @page_size IOBUFs */
-struct iobuf_arena;
-
-/* expandable and contractable pool of memory, internally broken into arenas */
-struct iobuf_pool;
-
-struct iobuf_init_config {
-        size_t   pagesize;
-        int32_t  num_pages;
-};
-
-struct iobuf {
-        union {
-                struct list_head      list;
-                struct {
-                        struct iobuf *next;
-                        struct iobuf *prev;
-                };
-        };
-        struct iobuf_arena  *iobuf_arena;
-
-        gf_lock_t            lock; /* for ->ptr and ->ref */
-        int                  ref;  /* 0 == passive, >0 == active */
-
-        void                *ptr;  /* usable memory region by the consumer */
-
-        void                *free_ptr; /* in case of stdalloc, this is the
-                                          one to be freed */
-};
-
-
-struct iobuf_arena {
-        union {
-                struct list_head            list;
-                struct {
-                        struct iobuf_arena *next;
-                        struct iobuf_arena *prev;
-                };
-        };
-
-        struct list_head    all_list;
-        size_t              page_size;  /* size of all iobufs in this arena */
-        size_t              arena_size;
-        /* this is equal to rounded_size * num_iobufs.
-           (rounded_size comes with gf_iobuf_get_pagesize().) */
-        size_t              page_count;
-
-        struct iobuf_pool  *iobuf_pool;
-
-        void               *mem_base;
-        struct iobuf       *iobufs;     /* allocated iobufs list */
-
-        int                 active_cnt;
-        struct iobuf        active;     /* head node iobuf
-                                           (unused by itself) */
-        int                 passive_cnt;
-        struct iobuf        passive;    /* head node iobuf
-                                           (unused by itself) */
-        uint64_t            alloc_cnt;  /* total allocs in this pool */
-        int                 max_active; /* max active buffers at a given time */
-};
-
-
-struct iobuf_pool {
-        pthread_mutex_t     mutex;
-        size_t              arena_size; /* size of memory region in
-                                           arena */
-        size_t              default_page_size; /* default size of iobuf */
-
-        int                 arena_cnt;
-        struct list_head    all_arenas;
-        struct list_head    arenas[GF_VARIABLE_IOBUF_COUNT];
-        /* array of arenas. Each element of the array is a list of arenas
-           holding iobufs of particular page_size */
-
-        struct list_head    filled[GF_VARIABLE_IOBUF_COUNT];
-        /* array of arenas without free iobufs */
-
-        struct list_head    purge[GF_VARIABLE_IOBUF_COUNT];
-        /* array of of arenas which can be purged */
-
-        uint64_t            request_misses; /* mostly the requests for higher
-                                              value of iobufs */
-        int                 rdma_device_count;
-        struct list_head    *mr_list[GF_RDMA_DEVICE_COUNT];
-        void                *device[GF_RDMA_DEVICE_COUNT];
-        int (*rdma_registration)(void **, void*);
-        int (*rdma_deregistration)(struct list_head**, struct iobuf_arena *);
-
-};
-
-
-struct iobuf_pool *iobuf_pool_new (void);
-void iobuf_pool_destroy (struct iobuf_pool *iobuf_pool);
-struct iobuf *iobuf_get (struct iobuf_pool *iobuf_pool);
-void iobuf_unref (struct iobuf *iobuf);
-struct iobuf *iobuf_ref (struct iobuf *iobuf);
-void iobuf_pool_destroy (struct iobuf_pool *iobuf_pool);
-void iobuf_to_iovec(struct iobuf *iob, struct iovec *iov);
-
-#define iobuf_ptr(iob) ((iob)->ptr)
-#define iobpool_default_pagesize(iobpool) ((iobpool)->default_page_size)
-#define iobuf_pagesize(iob) (iob->iobuf_arena->page_size)
-
-
-struct iobref {
-        gf_lock_t          lock;
-        int                ref;
-        struct iobuf     **iobrefs;
-	int                alloced;
-	int                used;
-};
-
-struct iobref *iobref_new (void);
-struct iobref *iobref_ref (struct iobref *iobref);
-void iobref_unref (struct iobref *iobref);
-int iobref_add (struct iobref *iobref, struct iobuf *iobuf);
-int iobref_merge (struct iobref *to, struct iobref *from);
-void iobref_clear (struct iobref *iobref);
-
-size_t iobuf_size (struct iobuf *iobuf);
-size_t iobref_size (struct iobref *iobref);
-void   iobuf_stats_dump (struct iobuf_pool *iobuf_pool);
-
-struct iobuf *
-iobuf_get2 (struct iobuf_pool *iobuf_pool, size_t page_size);
-
-struct iobuf *
-iobuf_get_page_aligned (struct iobuf_pool *iobuf_pool, size_t page_size,
-                        size_t align_size);
-#endif /* !_IOBUF_H_ */
diff --git a/libglusterfs/src/latency.c b/libglusterfs/src/latency.c
index 1d75f5b98ce..ce4b0e8255d 100644
--- a/libglusterfs/src/latency.c
+++ b/libglusterfs/src/latency.c
@@ -8,191 +8,77 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /*
  * This file contains functions to support dumping of
  * latencies of FOPs broken down by subvolumes.
  */
 
-#include "glusterfs.h"
-#include "stack.h"
-#include "xlator.h"
-#include "common-utils.h"
-#include "statedump.h"
-#include "libglusterfs-messages.h"
-
-static int gf_set_fop_from_fn_pointer_warning;
-void
-gf_set_fop_from_fn_pointer (call_frame_t *frame, struct xlator_fops *fops, void *fn)
-{
-        glusterfs_fop_t fop = -1;
-
-        if (fops->stat == *(fop_stat_t *)&fn)
-                fop = GF_FOP_STAT;
-        else if (fops->readlink == *(fop_readlink_t *)&fn)
-                fop = GF_FOP_READLINK;
-        else if (fops->mknod == *(fop_mknod_t *)&fn)
-                fop = GF_FOP_MKNOD;
-        else if (fops->mkdir == *(fop_mkdir_t *)&fn)
-                fop = GF_FOP_MKDIR;
-        else if (fops->unlink == *(fop_unlink_t *)&fn)
-                fop = GF_FOP_UNLINK;
-        else if (fops->rmdir == *(fop_rmdir_t *)&fn)
-                fop = GF_FOP_RMDIR;
-        else if (fops->symlink == *(fop_symlink_t *)&fn)
-                fop = GF_FOP_SYMLINK;
-        else if (fops->rename == *(fop_rename_t *)&fn)
-                fop = GF_FOP_RENAME;
-        else if (fops->link == *(fop_link_t *)&fn)
-                fop = GF_FOP_LINK;
-        else if (fops->truncate == *(fop_truncate_t *)&fn)
-                fop = GF_FOP_TRUNCATE;
-        else if (fops->open == *(fop_open_t *)&fn)
-                fop = GF_FOP_OPEN;
-        else if (fops->readv == *(fop_readv_t *)&fn)
-                fop = GF_FOP_READ;
-        else if (fops->writev == *(fop_writev_t *)&fn)
-                fop = GF_FOP_WRITE;
-        else if (fops->statfs == *(fop_statfs_t *)&fn)
-                fop = GF_FOP_STATFS;
-        else if (fops->flush == *(fop_flush_t *)&fn)
-                fop = GF_FOP_FLUSH;
-        else if (fops->fsync == *(fop_fsync_t *)&fn)
-                fop = GF_FOP_FSYNC;
-        else if (fops->setxattr == *(fop_setxattr_t *)&fn)
-                fop = GF_FOP_SETXATTR;
-        else if (fops->getxattr == *(fop_getxattr_t *)&fn)
-                fop = GF_FOP_GETXATTR;
-        else if (fops->removexattr == *(fop_removexattr_t *)&fn)
-                fop = GF_FOP_REMOVEXATTR;
-        else if (fops->opendir == *(fop_opendir_t *)&fn)
-                fop = GF_FOP_OPENDIR;
-        else if (fops->fsyncdir == *(fop_fsyncdir_t *)&fn)
-                fop = GF_FOP_FSYNCDIR;
-        else if (fops->access == *(fop_access_t *)&fn)
-                fop = GF_FOP_ACCESS;
-        else if (fops->create == *(fop_create_t *)&fn)
-                fop = GF_FOP_CREATE;
-        else if (fops->ftruncate == *(fop_ftruncate_t *)&fn)
-                fop = GF_FOP_FTRUNCATE;
-        else if (fops->fstat == *(fop_fstat_t *)&fn)
-                fop = GF_FOP_FSTAT;
-        else if (fops->lk == *(fop_lk_t *)&fn)
-                fop = GF_FOP_LK;
-        else if (fops->lookup == *(fop_lookup_t *)&fn)
-                fop = GF_FOP_LOOKUP;
-        else if (fops->readdir == *(fop_readdir_t *)&fn)
-                fop = GF_FOP_READDIR;
-        else if (fops->inodelk == *(fop_inodelk_t *)&fn)
-                fop = GF_FOP_INODELK;
-        else if (fops->finodelk == *(fop_finodelk_t *)&fn)
-                fop = GF_FOP_FINODELK;
-        else if (fops->entrylk == *(fop_entrylk_t *)&fn)
-                fop = GF_FOP_ENTRYLK;
-        else if (fops->fentrylk == *(fop_fentrylk_t *)&fn)
-                fop = GF_FOP_FENTRYLK;
-        else if (fops->xattrop == *(fop_xattrop_t *)&fn)
-                fop = GF_FOP_XATTROP;
-        else if (fops->fxattrop == *(fop_fxattrop_t *)&fn)
-                fop = GF_FOP_FXATTROP;
-        else if (fops->fgetxattr == *(fop_fgetxattr_t *)&fn)
-                fop = GF_FOP_FGETXATTR;
-        else if (fops->fsetxattr == *(fop_fsetxattr_t *)&fn)
-                fop = GF_FOP_FSETXATTR;
-        else if (fops->rchecksum == *(fop_rchecksum_t *)&fn)
-                fop = GF_FOP_RCHECKSUM;
-        else if (fops->setattr == *(fop_setattr_t *)&fn)
-                fop = GF_FOP_SETATTR;
-        else if (fops->fsetattr == *(fop_fsetattr_t *)&fn)
-                fop = GF_FOP_FSETATTR;
-        else if (fops->readdirp == *(fop_readdirp_t *)&fn)
-                fop = GF_FOP_READDIRP;
-        else if (fops->getspec == *(fop_getspec_t *)&fn)
-                fop = GF_FOP_GETSPEC;
-        else if (fops->ipc == *(fop_ipc_t *)&fn)
-                fop = GF_FOP_IPC;
-        else {
-                fop = GF_FOP_NULL;
-                GF_LOG_OCCASIONALLY(gf_set_fop_from_fn_pointer_warning,
-                                    "latency",
-                                    GF_LOG_WARNING,
-                                    "Unknown FOP type");
-        }
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/statedump.h"
 
-        frame->op   = fop;
-}
-
-
-void
-gf_update_latency (call_frame_t *frame)
+gf_latency_t *
+gf_latency_new(size_t n)
 {
-        double elapsed;
-        struct timeval *begin, *end;
-
-        fop_latency_t *lat;
+    int i = 0;
+    gf_latency_t *lat = NULL;
 
-        begin = &frame->begin;
-        end   = &frame->end;
+    lat = GF_MALLOC(n * sizeof(*lat), gf_common_mt_latency_t);
+    if (!lat)
+        return NULL;
 
-        elapsed = (end->tv_sec - begin->tv_sec) * 1e6
-                + (end->tv_usec - begin->tv_usec);
-
-        lat = &frame->this->latencies[frame->op];
-
-        lat->total += elapsed;
-        lat->count++;
-        lat->mean = lat->mean + (elapsed - lat->mean) / lat->count;
+    for (i = 0; i < n; i++) {
+        gf_latency_reset(lat + i);
+    }
+    return lat;
 }
 
 void
-gf_latency_begin (call_frame_t *frame, void *fn)
+gf_latency_update(gf_latency_t *lat, struct timespec *begin,
+                  struct timespec *end)
 {
-        gf_set_fop_from_fn_pointer (frame, frame->this->fops, fn);
+    if (!(begin->tv_sec && end->tv_sec)) {
+        /*Measure latency might have been enabled/disabled during the op*/
+        return;
+    }
 
-        gettimeofday (&frame->begin, NULL);
-}
+    double elapsed = gf_tsdiff(begin, end);
 
+    if (lat->max < elapsed)
+        lat->max = elapsed;
 
-void
-gf_latency_end (call_frame_t *frame)
-{
-        gettimeofday (&frame->end, NULL);
+    if (lat->min > elapsed)
+        lat->min = elapsed;
 
-        gf_update_latency (frame);
+    lat->total += elapsed;
+    lat->count++;
 }
 
 void
-gf_proc_dump_latency_info (xlator_t *xl)
+gf_latency_reset(gf_latency_t *lat)
 {
-        char key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char key[GF_DUMP_MAX_BUF_LEN];
-        int i;
-
-        snprintf (key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.latency", xl->name);
-        gf_proc_dump_add_section (key_prefix);
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                gf_proc_dump_build_key (key, key_prefix, "%s",
-                                        (char *)gf_fop_list[i]);
-
-                gf_proc_dump_write (key, "%.03f,%"PRId64",%.03f",
-                                    xl->latencies[i].mean,
-                                    xl->latencies[i].count,
-                                    xl->latencies[i].total);
-        }
-
-        memset (xl->latencies, 0, sizeof (xl->latencies));
+    if (!lat)
+        return;
+    memset(lat, 0, sizeof(*lat));
+    lat->min = ULLONG_MAX;
+    /* make sure 'min' is set to high value, so it would be
+       properly set later */
 }
 
-
 void
-gf_latency_toggle (int signum, glusterfs_ctx_t *ctx)
+gf_frame_latency_update(call_frame_t *frame)
 {
-        if (ctx) {
-                ctx->measure_latency = !ctx->measure_latency;
-                gf_msg ("[core]", GF_LOG_INFO, 0,
-                        LG_MSG_LATENCY_MEASUREMENT_STATE,
-                        "Latency measurement turned %s",
-                        ctx->measure_latency ? "on" : "off");
-        }
+    gf_latency_t *lat;
+    /* Can happen mostly at initiator xlator, as STACK_WIND/UNWIND macros
+       set it right anyways for those frames */
+    if (!frame->op)
+        frame->op = frame->root->op;
+
+    if (frame->op < 0 || frame->op >= GF_FOP_MAXVALUE) {
+        gf_log("[core]", GF_LOG_WARNING, "Invalid frame op value: %d",
+               frame->op);
+        return;
+    }
+
+    lat = &frame->this->stats.interval.latencies[frame->op];
+    gf_latency_update(lat, &frame->begin, &frame->end);
 }
diff --git a/libglusterfs/src/latency.h b/libglusterfs/src/latency.h
deleted file mode 100644
index 81acbf48478..00000000000
--- a/libglusterfs/src/latency.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __LATENCY_H__
-#define __LATENCY_H__
-
-#include "glusterfs.h"
-
-typedef struct fop_latency {
-        uint64_t min;           /* min time for the call (microseconds) */
-        uint64_t max;           /* max time for the call (microseconds) */
-	double total;           /* total time (microseconds) */
-        double std;             /* standard deviation */
-        double mean;            /* mean (microseconds) */
-        uint64_t count;
-} fop_latency_t;
-
-void
-gf_latency_toggle (int signum, glusterfs_ctx_t *ctx);
-
-#endif /* __LATENCY_H__ */
diff --git a/libglusterfs/src/libglusterfs-messages.h b/libglusterfs/src/libglusterfs-messages.h
deleted file mode 100644
index dd657013257..00000000000
--- a/libglusterfs/src/libglusterfs-messages.h
+++ /dev/null
@@ -1,1819 +0,0 @@
-/*
- Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
- This file is part of GlusterFS.
-
- This file is licensed to you under your choice of the GNU Lesser
- General Public License, version 3 or any later version (LGPLv3 or
- later), or the GNU General Public License, version 2 (GPLv2), in all
- cases as published by the Free Software Foundation.
- */
-
-#ifndef _LG_MESSAGES_H_
-#define _LG_MESSAGES_H_
-
-#include "glfs-message-id.h"
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
- */
-
-#define GLFS_LG_BASE            GLFS_MSGID_COMP_LIBGLUSTERFS
-
-#define GLFS_LG_NUM_MESSAGES    211
-
-#define GLFS_LG_MSGID_END       (GLFS_LG_BASE + GLFS_LG_NUM_MESSAGES + 1)
-/* Messaged with message IDs */
-#define glfs_msg_start_lg GLFS_LG_BASE, "Invalid: Start of messages"
-/*------------*/
-
-#define LG_MSG_ASPRINTF_FAILED                            (GLFS_LG_BASE + 1)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_ENTRY                              (GLFS_LG_BASE + 2)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_COUNT_LESS_THAN_ZERO                       (GLFS_LG_BASE + 3)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_COUNT_LESS_THAN_DATA_PAIRS                 (GLFS_LG_BASE + 4)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO                (GLFS_LG_BASE + 5)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PAIRS_LESS_THAN_COUNT                      (GLFS_LG_BASE + 6)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_KEY_OR_VALUE_NULL                          (GLFS_LG_BASE + 7)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FAILED_TO_LOG_DICT                         (GLFS_LG_BASE + 8)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_NULL_VALUE_IN_DICT                         (GLFS_LG_BASE + 9)
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DIR_OP_FAILED                              (GLFS_LG_BASE + 10)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_STORE_HANDLE_CREATE_FAILED                 (GLFS_LG_BASE + 11)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FILE_OP_FAILED                            (GLFS_LG_BASE + 12)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FILE_STAT_FAILED                           (GLFS_LG_BASE + 13)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LOCK_FAILED                               (GLFS_LG_BASE + 14)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UNLOCK_FAILED                             (GLFS_LG_BASE + 15)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DICT_SERIAL_FAILED                         (GLFS_LG_BASE + 16)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DICT_UNSERIAL_FAILED                       (GLFS_LG_BASE + 17)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_NO_MEMORY                                  (GLFS_LG_BASE + 18)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VOLUME_ERROR                               (GLFS_LG_BASE + 19)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SUB_VOLUME_ERROR                           (GLFS_LG_BASE + 20)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SYNTAX_ERROR                               (GLFS_LG_BASE + 21)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_BACKTICK_PARSE_FAILED                      (GLFS_LG_BASE + 22)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_BUFFER_ERROR                               (GLFS_LG_BASE + 23)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_STRDUP_ERROR                               (GLFS_LG_BASE + 24)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_HASH_FUNC_ERROR                            (GLFS_LG_BASE + 25)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_GET_BUCKET_FAILED                         (GLFS_LG_BASE + 26)
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INSERT_FAILED                             (GLFS_LG_BASE + 27)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_OUT_OF_RANGE                              (GLFS_LG_BASE + 28)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VALIDATE_RETURNS                          (GLFS_LG_BASE + 29)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VALIDATE_REC_FAILED                       (GLFS_LG_BASE + 30)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_RB_TABLE_CREATE_FAILED                    (GLFS_LG_BASE + 31)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-
-#define LG_MSG_PATH_NOT_FOUND                            (GLFS_LG_BASE + 32)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_EXPAND_FD_TABLE_FAILED                    (GLFS_LG_BASE + 33)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_MAPPING_FAILED                            (GLFS_LG_BASE + 34)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INIT_IOBUF_FAILED                         (GLFS_LG_BASE + 35)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PAGE_SIZE_EXCEEDED                        (GLFS_LG_BASE + 36)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_ARENA_NOT_FOUND                           (GLFS_LG_BASE + 37)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_IOBUF_NOT_FOUND                           (GLFS_LG_BASE + 38)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_POOL_NOT_FOUND                            (GLFS_LG_BASE + 39)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SET_ATTRIBUTE_FAILED                      (GLFS_LG_BASE + 40)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_READ_ATTRIBUTE_FAILED                     (GLFS_LG_BASE + 41)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UNMOUNT_FAILED                            (GLFS_LG_BASE + 42)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LATENCY_MEASUREMENT_STATE                 (GLFS_LG_BASE + 43)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_NO_PERM                                   (GLFS_LG_BASE + 44)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_NO_KEY                                    (GLFS_LG_BASE + 45)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DICT_NULL                                 (GLFS_LG_BASE + 46)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INIT_TIMER_FAILED                         (GLFS_LG_BASE + 47)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FD_ANONYMOUS_FAILED                       (GLFS_LG_BASE + 48)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FD_CREATE_FAILED                          (GLFS_LG_BASE + 49)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_BUFFER_FULL                               (GLFS_LG_BASE + 50)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FWRITE_FAILED                             (GLFS_LG_BASE + 51)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PRINT_FAILED                              (GLFS_LG_BASE + 52)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_MEM_POOL_DESTROY                          (GLFS_LG_BASE + 53)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EXPAND_CLIENT_TABLE_FAILED                (GLFS_LG_BASE + 54)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DISCONNECT_CLIENT                         (GLFS_LG_BASE + 55)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PIPE_CREATE_FAILED                        (GLFS_LG_BASE + 56)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SET_PIPE_FAILED                           (GLFS_LG_BASE + 57)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_REGISTER_PIPE_FAILED                      (GLFS_LG_BASE + 58)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_POLL_IGNORE_MULTIPLE_THREADS              (GLFS_LG_BASE + 59)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INDEX_NOT_FOUND                           (GLFS_LG_BASE + 60)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EPOLL_FD_CREATE_FAILED                    (GLFS_LG_BASE + 61)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SLOT_NOT_FOUND                            (GLFS_LG_BASE + 62)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
- #define LG_MSG_STALE_FD_FOUND                            (GLFS_LG_BASE + 63)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_GENERATION_MISMATCH                       (GLFS_LG_BASE + 64)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PTHREAD_KEY_CREATE_FAILED                 (GLFS_LG_BASE + 65)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_TRANSLATOR_INIT_FAILED                    (GLFS_LG_BASE + 66)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UUID_BUF_INIT_FAILED                      (GLFS_LG_BASE + 67)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LKOWNER_BUF_INIT_FAILED                   (GLFS_LG_BASE + 68)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SYNCTASK_INIT_FAILED                      (GLFS_LG_BASE + 69)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SYNCOPCTX_INIT_FAILED                     (GLFS_LG_BASE + 70)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_GLOBAL_INIT_FAILED                        (GLFS_LG_BASE + 71)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PTHREAD_FAILED                            (GLFS_LG_BASE + 72)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DIR_IS_SYMLINK                            (GLFS_LG_BASE + 73)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_RESOLVE_HOSTNAME_FAILED                   (GLFS_LG_BASE + 74)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GETADDRINFO_FAILED                        (GLFS_LG_BASE + 75)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GETNAMEINFO_FAILED                        (GLFS_LG_BASE + 76)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PATH_ERROR                                (GLFS_LG_BASE + 77)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INET_PTON_FAILED                          (GLFS_LG_BASE + 78)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_NEGATIVE_NUM_PASSED                       (GLFS_LG_BASE + 79)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GETHOSTNAME_FAILED                        (GLFS_LG_BASE + 80)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_RESERVED_PORTS_ERROR                      (GLFS_LG_BASE + 81)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_PORT                              (GLFS_LG_BASE + 82)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_FAMILY                            (GLFS_LG_BASE + 83)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CONVERSION_FAILED                         (GLFS_LG_BASE + 84)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_SKIP_HEADER_FAILED                        (GLFS_LG_BASE + 85)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_LOG                               (GLFS_LG_BASE + 86)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UTIMES_FAILED                             (GLFS_LG_BASE + 87)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_BACKTRACE_SAVE_FAILED                     (GLFS_LG_BASE + 88)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INIT_FAILED                               (GLFS_LG_BASE + 89)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_VALIDATION_FAILED                         (GLFS_LG_BASE + 90)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GRAPH_ERROR                               (GLFS_LG_BASE + 91)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UNKNOWN_OPTIONS_FAILED                    (GLFS_LG_BASE + 92)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CTX_NULL                                  (GLFS_LG_BASE + 93)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_TMPFILE_CREATE_FAILED                     (GLFS_LG_BASE + 94)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DLOPEN_FAILED                             (GLFS_LG_BASE + 95)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_LOAD_FAILED                               (GLFS_LG_BASE + 96)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DLSYM_ERROR                               (GLFS_LG_BASE + 97)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_TREE_NOT_FOUND                            (GLFS_LG_BASE + 98)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PER_DENTRY                                (GLFS_LG_BASE + 99)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DENTRY                                    (GLFS_LG_BASE + 100)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GETIFADDRS_FAILED                         (GLFS_LG_BASE + 101)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_REGEX_OP_FAILED                           (GLFS_LG_BASE + 102)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_FRAME_ERROR                               (GLFS_LG_BASE + 103)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_SET_PARAM_FAILED                          (GLFS_LG_BASE + 104)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GET_PARAM_FAILED                          (GLFS_LG_BASE + 105)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PREPARE_FAILED                            (GLFS_LG_BASE + 106)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_EXEC_FAILED                               (GLFS_LG_BASE + 107)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_BINDING_FAILED                            (GLFS_LG_BASE + 108)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DELETE_FAILED                             (GLFS_LG_BASE + 109)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GET_ID_FAILED                             (GLFS_LG_BASE + 110)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CREATE_FAILED                             (GLFS_LG_BASE + 111)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PARSE_FAILED                              (GLFS_LG_BASE + 112)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-
-#define LG_MSG_GETCONTEXT_FAILED                         (GLFS_LG_BASE + 113)
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UPDATE_FAILED                             (GLFS_LG_BASE + 114)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_QUERY_CALL_BACK_FAILED                    (GLFS_LG_BASE + 115)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_GET_RECORD_FAILED                         (GLFS_LG_BASE + 116)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DB_ERROR                                  (GLFS_LG_BASE + 117)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CONNECTION_ERROR                          (GLFS_LG_BASE + 118)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_NOT_MULTITHREAD_MODE                      (GLFS_LG_BASE + 119)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_SKIP_PATH                                 (GLFS_LG_BASE + 120)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_FOP                               (GLFS_LG_BASE + 121)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_QUERY_FAILED                              (GLFS_LG_BASE + 122)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CLEAR_COUNTER_FAILED                      (GLFS_LG_BASE + 123)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_LOCK_LIST_FAILED                          (GLFS_LG_BASE + 124)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UNLOCK_LIST_FAILED                        (GLFS_LG_BASE + 125)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_ADD_TO_LIST_FAILED                        (GLFS_LG_BASE + 126)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INIT_DB_FAILED                            (GLFS_LG_BASE + 127)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_DELETE_FROM_LIST_FAILED                   (GLFS_LG_BASE + 128)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CLOSE_CONNECTION_FAILED                   (GLFS_LG_BASE + 129)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INSERT_OR_UPDATE_FAILED                   (GLFS_LG_BASE + 130)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_FIND_OP_FAILED                            (GLFS_LG_BASE + 131)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CONNECTION_INIT_FAILED                    (GLFS_LG_BASE + 132)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_COMPLETED_TASK                            (GLFS_LG_BASE + 133)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_WAKE_UP_ZOMBIE                            (GLFS_LG_BASE + 134)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_REWAITING_TASK                            (GLFS_LG_BASE + 135)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_SLEEP_ZOMBIE                              (GLFS_LG_BASE + 136)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_SWAPCONTEXT_FAILED                        (GLFS_LG_BASE + 137)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UNSUPPORTED_PLUGIN                        (GLFS_LG_BASE + 138)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_DB_TYPE                           (GLFS_LG_BASE + 139)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UNDERSIZED_BUF                            (GLFS_LG_BASE + 140)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DATA_CONVERSION_ERROR                     (GLFS_LG_BASE + 141)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DICT_ERROR                                (GLFS_LG_BASE + 142)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_IOBUFS_NOT_FOUND                          (GLFS_LG_BASE + 143)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_ENTRIES_NULL                              (GLFS_LG_BASE + 144)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FD_NOT_FOUND_IN_FDTABLE                   (GLFS_LG_BASE + 145)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_REALLOC_FOR_FD_PTR_FAILED                 (GLFS_LG_BASE + 146)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DICT_SET_FAILED                           (GLFS_LG_BASE + 147)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_NULL_PTR                                  (GLFS_LG_BASE + 148)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RBTHASH_INIT_BUCKET_FAILED                (GLFS_LG_BASE + 149)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_ASSERTION_FAILED                          (GLFS_LG_BASE + 150)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_HOSTNAME_NULL                             (GLFS_LG_BASE + 151)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_IPV4_FORMAT                       (GLFS_LG_BASE + 152)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_CTX_CLEANUP_STARTED                       (GLFS_LG_BASE + 153)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_TIMER_REGISTER_ERROR                      (GLFS_LG_BASE + 154)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PTR_HEADER_CORRUPTED                      (GLFS_LG_BASE + 155)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_UPLINK                            (GLFS_LG_BASE + 156)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_CLIENT_NULL                               (GLFS_LG_BASE + 157)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_XLATOR_DOES_NOT_IMPLEMENT                 (GLFS_LG_BASE + 158)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DENTRY_NOT_FOUND                          (GLFS_LG_BASE + 159)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INODE_NOT_FOUND                           (GLFS_LG_BASE + 160)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INODE_TABLE_NOT_FOUND                     (GLFS_LG_BASE + 161)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DENTRY_CREATE_FAILED                      (GLFS_LG_BASE + 162)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INODE_CONTEXT_FREED                       (GLFS_LG_BASE + 163)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UNKNOWN_LOCK_TYPE                         (GLFS_LG_BASE + 164)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_UNLOCK_BEFORE_LOCK                        (GLFS_LG_BASE + 165)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LOCK_OWNER_ERROR                          (GLFS_LG_BASE + 166)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_MEMPOOL_PTR_NULL                          (GLFS_LG_BASE + 167)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_QUOTA_XATTRS_MISSING                      (GLFS_LG_BASE + 168)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_STRING                            (GLFS_LG_BASE + 169)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_BIND_REF                                  (GLFS_LG_BASE + 170)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_REF_COUNT                                 (GLFS_LG_BASE + 171)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_ARG                               (GLFS_LG_BASE + 172)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VOL_OPTION_ADD                            (GLFS_LG_BASE + 173)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_XLATOR_OPTION_INVALID                     (GLFS_LG_BASE + 174)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_GETTIMEOFDAY_FAILED                       (GLFS_LG_BASE + 175)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_GRAPH_INIT_FAILED                         (GLFS_LG_BASE + 176)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EVENT_NOTIFY_FAILED                       (GLFS_LG_BASE + 177)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_ACTIVE_GRAPH_NULL                         (GLFS_LG_BASE + 178)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VOLFILE_PARSE_ERROR                       (GLFS_LG_BASE + 179)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FD_INODE_NULL                             (GLFS_LG_BASE + 180)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_VOLFILE_ENTRY                     (GLFS_LG_BASE + 181)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PER_DENTRY_FAILED                         (GLFS_LG_BASE + 182)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PARENT_DENTRY_NOT_FOUND                   (GLFS_LG_BASE + 183)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_DENTRY_CYCLIC_LOOP                        (GLFS_LG_BASE + 184)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_POLL_IN                           (GLFS_LG_BASE + 185)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_INVALID_POLL_OUT                         (GLFS_LG_BASE + 186)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EPOLL_FD_ADD_FAILED                       (GLFS_LG_BASE + 187)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EPOLL_FD_DEL_FAILED                        (GLFS_LG_BASE + 188)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EPOLL_FD_MODIFY_FAILED                     (GLFS_LG_BASE + 189)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_STARTED_EPOLL_THREAD                       (GLFS_LG_BASE + 190)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_EXITED_EPOLL_THREAD                        (GLFS_LG_BASE + 191)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_START_EPOLL_THREAD_FAILED                  (GLFS_LG_BASE + 192)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_FALLBACK_TO_POLL                           (GLFS_LG_BASE + 193)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_QUOTA_CONF_ERROR                           (GLFS_LG_BASE + 194)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RBTHASH_GET_ENTRY_FAILED                  (GLFS_LG_BASE + 195)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RBTHASH_GET_BUCKET_FAILED                 (GLFS_LG_BASE + 196)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RBTHASH_INSERT_FAILED                     (GLFS_LG_BASE + 197)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RBTHASH_INIT_ENTRY_FAILED                 (GLFS_LG_BASE + 198)
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_TMPFILE_DELETE_FAILED                     (GLFS_LG_BASE + 199)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_MEMPOOL_INVALID_FREE                      (GLFS_LG_BASE + 200)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LOCK_FAILURE                              (GLFS_LG_BASE + 201)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_SET_LOG_LEVEL                             (GLFS_LG_BASE + 202)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_VERIFY_PLATFORM                           (GLFS_LG_BASE + 203)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_RUNNER_LOG                                (GLFS_LG_BASE + 204)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_LEASEID_BUF_INIT_FAILED                   (GLFS_LG_BASE + 205)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-#define LG_MSG_PTHREAD_ATTR_INIT_FAILED                  (GLFS_LG_BASE + 206)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_INVALID_INODE_LIST                         (GLFS_LG_BASE + 207)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_COMPACT_FAILED                            (GLFS_LG_BASE + 208)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_COMPACT_STATUS                            (GLFS_LG_BASE + 209)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_UTIMENSAT_FAILED                          (GLFS_LG_BASE + 210)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-
-#define LG_MSG_PTHREAD_NAMING_FAILED                     (GLFS_LG_BASE + 211)
-
-/*!
- * @messageid
- * @diagnosis
- * @recommendedaction
- *
- */
-/*------------*/
-
-#define glfs_msg_end_lg GLFS_LG_MSGID_END, "Invalid: End of messages"
-
-#endif /* !_LG_MESSAGES_H_ */
-
-
-
diff --git a/libglusterfs/src/libglusterfs.sym b/libglusterfs/src/libglusterfs.sym
new file mode 100644
index 00000000000..5f18cd56cbe
--- /dev/null
+++ b/libglusterfs/src/libglusterfs.sym
@@ -0,0 +1,1193 @@
+are_dicts_equal
+args_access_cbk_store
+args_access_store
+args_create_cbk_store
+args_create_store
+args_discard_cbk_store
+args_discard_store
+args_entrylk_cbk_store
+args_entrylk_store
+args_fallocate_cbk_store
+args_fallocate_store
+args_fentrylk_cbk_store
+args_fentrylk_store
+args_fgetxattr_cbk_store
+args_fgetxattr_store
+args_finodelk_cbk_store
+args_finodelk_store
+args_flush_cbk_store
+args_flush_store
+args_fremovexattr_cbk_store
+args_fremovexattr_store
+args_fsetattr_cbk_store
+args_fsetattr_store
+args_fsetxattr_cbk_store
+args_fsetxattr_store
+args_fstat_cbk_store
+args_fstat_store
+args_fsync_cbk_store
+args_fsyncdir_cbk_store
+args_fsyncdir_store
+args_fsync_store
+args_ftruncate_cbk_store
+args_ftruncate_store
+args_fxattrop_cbk_store
+args_fxattrop_store
+args_getxattr_cbk_store
+args_getxattr_store
+args_inodelk_cbk_store
+args_inodelk_store
+args_ipc_cbk_store
+args_lease_cbk_store
+args_lease_store
+args_link_cbk_store
+args_link_store
+args_lk_cbk_store
+args_lk_store
+args_lookup_cbk_store
+args_lookup_store
+args_mkdir_cbk_store
+args_mkdir_store
+args_mknod_cbk_store
+args_mknod_store
+args_open_cbk_store
+args_opendir_cbk_store
+args_opendir_store
+args_open_store
+args_rchecksum_cbk_store
+args_rchecksum_store
+args_readdir_cbk_store
+args_readdirp_cbk_store
+args_readdirp_store
+args_readdir_store
+args_readlink_cbk_store
+args_readlink_store
+args_readv_cbk_store
+args_readv_store
+args_removexattr_cbk_store
+args_removexattr_store
+args_rename_cbk_store
+args_rename_store
+args_rmdir_cbk_store
+args_rmdir_store
+args_seek_cbk_store
+args_seek_store
+args_setattr_cbk_store
+args_setattr_store
+args_setxattr_cbk_store
+args_setxattr_store
+args_stat_cbk_store
+args_statfs_cbk_store
+args_statfs_store
+args_stat_store
+args_symlink_cbk_store
+args_symlink_store
+args_truncate_cbk_store
+args_truncate_store
+args_unlink_cbk_store
+args_unlink_store
+args_writev_cbk_store
+args_writev_store
+args_xattrop_cbk_store
+args_xattrop_store
+args_zerofill_cbk_store
+args_zerofill_store
+args_copy_file_range_cbk_store
+args_copy_file_range_store
+bin_to_data
+call_resume
+call_resume_keep_stub
+call_resume_wind
+call_stack_set_groups
+call_stub_destroy
+call_unwind_error
+call_unwind_error_keep_stub
+client_ctx_del
+client_ctx_get
+client_ctx_set
+client_dump
+close_fds_except
+cluster_fop_success_fill
+cluster_fstat
+cluster_ftruncate
+cluster_fxattrop
+cluster_getxattr
+cluster_inodelk
+cluster_link
+cluster_lookup
+cluster_mkdir
+cluster_mknod
+cluster_open
+cluster_readlink
+cluster_replies_wipe
+cluster_rmdir
+cluster_setattr
+cluster_setxattr
+cluster_symlink
+cluster_tiebreaker_inodelk
+cluster_uninodelk
+cluster_unlink
+cluster_xattrop
+cluster_xattrop_cbk
+copy_opts_to_child
+create_frame
+data_copy
+data_destroy
+data_from_dynptr
+data_from_uint64
+data_ref
+data_to_bin
+data_to_int32
+data_to_int64
+data_to_ptr
+data_to_str
+data_to_uint16
+data_to_uint32
+data_to_uint64
+data_to_uint8
+data_to_iatt
+data_unref
+default_access
+default_access_cbk
+default_access_failure_cbk
+default_access_resume
+default_create
+default_create_cbk
+default_create_failure_cbk
+default_create_resume
+default_discard
+default_discard_cbk
+default_discard_failure_cbk
+default_discard_resume
+default_entrylk
+default_entrylk_cbk
+default_entrylk_failure_cbk
+default_entrylk_resume
+default_fallocate
+default_fallocate_cbk
+default_fallocate_failure_cbk
+default_fallocate_resume
+default_fentrylk
+default_fentrylk_cbk
+default_fentrylk_failure_cbk
+default_fentrylk_resume
+default_fgetxattr
+default_fgetxattr_cbk
+default_fgetxattr_failure_cbk
+default_fgetxattr_resume
+default_finodelk
+default_finodelk_cbk
+default_finodelk_failure_cbk
+default_finodelk_resume
+default_flush
+default_flush_cbk
+default_flush_failure_cbk
+default_flush_resume
+default_forget
+default_fremovexattr
+default_fremovexattr_cbk
+default_fremovexattr_failure_cbk
+default_fremovexattr_resume
+default_fsetattr
+default_fsetattr_cbk
+default_fsetattr_failure_cbk
+default_fsetattr_resume
+default_fsetxattr
+default_fsetxattr_cbk
+default_fsetxattr_failure_cbk
+default_fsetxattr_resume
+default_fstat
+default_fstat_cbk
+default_fstat_failure_cbk
+default_fstat_resume
+default_fsync
+default_fsync_cbk
+default_fsyncdir
+default_fsyncdir_cbk
+default_fsyncdir_failure_cbk
+default_fsyncdir_resume
+default_fsync_failure_cbk
+default_fsync_resume
+default_ftruncate
+default_ftruncate_cbk
+default_ftruncate_failure_cbk
+default_ftruncate_resume
+default_fxattrop
+default_fxattrop_cbk
+default_fxattrop_failure_cbk
+default_fxattrop_resume
+default_getactivelk
+default_getactivelk_failure_cbk
+default_getactivelk_resume
+default_getspec
+default_getspec_cbk
+default_getxattr
+default_getxattr_cbk
+default_getxattr_failure_cbk
+default_getxattr_resume
+default_inodelk
+default_inodelk_cbk
+default_inodelk_failure_cbk
+default_inodelk_resume
+default_ipc
+default_ipc_cbk
+default_lease
+default_lease_failure_cbk
+default_lease_resume
+default_link
+default_link_cbk
+default_link_failure_cbk
+default_link_resume
+default_lk
+default_lk_cbk
+default_lk_failure_cbk
+default_lk_resume
+default_lookup
+default_lookup_cbk
+default_lookup_failure_cbk
+default_lookup_resume
+default_mem_acct_init
+default_mkdir
+default_mkdir_cbk
+default_mkdir_failure_cbk
+default_mkdir_resume
+default_mknod
+default_mknod_cbk
+default_mknod_failure_cbk
+default_mknod_resume
+default_notify
+default_open
+default_open_cbk
+default_opendir
+default_opendir_cbk
+default_opendir_failure_cbk
+default_opendir_resume
+default_open_failure_cbk
+default_open_resume
+default_rchecksum
+default_rchecksum_cbk
+default_rchecksum_failure_cbk
+default_rchecksum_resume
+default_readdir
+default_readdir_cbk
+default_readdir_failure_cbk
+default_readdirp
+default_readdirp_cbk
+default_readdirp_failure_cbk
+default_readdirp_resume
+default_readdir_resume
+default_readlink
+default_readlink_cbk
+default_readlink_failure_cbk
+default_readlink_resume
+default_readv
+default_readv_cbk
+default_readv_failure_cbk
+default_readv_resume
+default_release
+default_releasedir
+default_removexattr
+default_removexattr_cbk
+default_removexattr_failure_cbk
+default_removexattr_resume
+default_rename
+default_rename_cbk
+default_rename_failure_cbk
+default_rename_resume
+default_rmdir
+default_rmdir_cbk
+default_rmdir_failure_cbk
+default_rmdir_resume
+default_seek
+default_seek_cbk
+default_seek_failure_cbk
+default_seek_resume
+default_setactivelk
+default_setactivelk_failure_cbk
+default_setactivelk_resume
+default_setattr
+default_setattr_cbk
+default_setattr_failure_cbk
+default_setattr_resume
+default_setxattr
+default_setxattr_cbk
+default_setxattr_failure_cbk
+default_setxattr_resume
+default_stat
+default_stat_cbk
+default_stat_failure_cbk
+default_statfs
+default_statfs_cbk
+default_statfs_failure_cbk
+default_statfs_resume
+default_stat_resume
+default_symlink
+default_symlink_cbk
+default_symlink_failure_cbk
+default_symlink_resume
+default_truncate
+default_truncate_cbk
+default_truncate_failure_cbk
+default_truncate_resume
+default_unlink
+default_unlink_cbk
+default_unlink_failure_cbk
+default_unlink_resume
+default_writev
+default_writev_cbk
+default_writev_failure_cbk
+default_writev_resume
+default_xattrop
+default_xattrop_cbk
+default_xattrop_failure_cbk
+default_xattrop_resume
+default_zerofill
+default_zerofill_cbk
+default_zerofill_failure_cbk
+default_zerofill_resume
+default_put
+default_put_cbk
+default_put_failure_cbk
+default_put_resume
+default_copy_file_range
+default_copy_file_range_cbk
+default_copy_file_range_failure_cbk
+default_copy_file_range_resume
+dht_is_linkfile
+dict_add
+dict_addn
+dict_add_dynstr_with_alloc
+dict_allocate_and_serialize
+dict_copy
+dict_copy_with_ref
+dict_del
+dict_deln
+dict_dump_to_statedump
+dict_dump_to_str
+dict_dump_to_log
+dict_foreach
+dict_foreach_fnmatch
+dict_foreach_match
+dict_for_key_value
+dict_get
+dict_getn
+dict_get_bin
+dict_get_double
+dict_get_gfuuid
+dict_get_iatt
+dict_get_mdata
+dict_get_int16
+dict_get_int32
+dict_get_int32n
+dict_get_int64
+dict_get_int8
+dict_get_ptr
+dict_get_ptr_and_len
+dict_get_str
+dict_get_strn
+dict_get_str_boolean
+dict_get_uint32
+dict_get_uint64
+dict_get_with_ref
+dict_has_key_from_array
+dict_key_count
+dict_keys_join
+dict_lookup
+dict_new
+dict_null_foreach_fn
+dict_ref
+dict_remove_foreach_fn
+dict_rename_key
+dict_reset
+dict_serialize
+dict_serialized_length
+dict_serialized_length_lk
+dict_serialize_value_with_delim
+dict_set
+dict_setn
+dict_set_bin
+dict_set_double
+dict_set_dynptr
+dict_set_dynstr
+dict_set_dynstrn
+dict_set_dynstr_with_alloc
+dict_set_gfuuid
+dict_set_iatt
+dict_set_mdata
+dict_set_int16
+dict_set_int32
+dict_set_int32n
+dict_set_int64
+dict_set_int8
+dict_set_static_bin
+dict_set_static_ptr
+dict_set_str
+dict_set_strn
+dict_setn_nstrn
+dict_set_nstrn
+dict_set_uint32
+dict_set_uint64
+dict_set_flag
+dict_clear_flag
+dict_check_flag
+dict_unref
+dict_unserialize
+drop_token
+eh_destroy
+eh_dump
+eh_new
+eh_save_history
+entry_copy
+gf_event_dispatch
+gf_event_dispatch_destroy
+gf_event_handled
+gf_event_pool_destroy
+gf_event_pool_new
+gf_event_reconfigure_threads
+gf_event_register
+gf_event_select_on
+gf_event_unregister
+gf_event_unregister_close
+fd_anonymous
+fd_anonymous_with_flags
+fd_bind
+fd_close
+fd_create
+fd_create_uint64
+__fd_ctx_del
+fd_ctx_del
+fd_ctx_dump
+__fd_ctx_get
+fd_ctx_get
+__fd_ctx_set
+fd_ctx_set
+fd_is_anonymous
+fd_list_empty
+fd_lk_ctx_empty
+fd_lk_ctx_ref
+fd_lk_ctx_unref
+fd_lk_insert_and_merge
+fd_lookup
+fd_lookup_anonymous
+fd_lookup_uint64
+__fd_ref
+fd_ref
+fd_unref
+_fini
+fop_access_stub
+fop_create_stub
+fop_copy_file_range_stub
+fop_copy_file_range_cbk_stub
+fop_discard_stub
+fop_entrylk_stub
+fop_enum_to_pri_string
+fop_fallocate_stub
+fop_fentrylk_stub
+fop_fgetxattr_stub
+fop_finodelk_stub
+fop_flush_stub
+fop_fremovexattr_cbk_stub
+fop_fremovexattr_stub
+fop_fsetattr_stub
+fop_fsetxattr_cbk_stub
+fop_fsetxattr_stub
+fop_fstat_stub
+fop_fsync_cbk_stub
+fop_fsyncdir_stub
+fop_fsync_stub
+fop_ftruncate_cbk_stub
+fop_ftruncate_stub
+fop_fxattrop_stub
+fop_getactivelk_stub
+fop_getxattr_stub
+fop_icreate_stub
+fop_inodelk_stub
+fop_ipc_stub
+fop_lease_stub
+fop_link_stub
+fop_lk_stub
+fop_log_level
+fop_lookup_cbk_stub
+fop_lookup_stub
+fop_mkdir_stub
+fop_mknod_stub
+fop_namelink_stub
+fop_opendir_stub
+fop_open_stub
+fop_put_stub
+fop_rchecksum_stub
+fop_readdirp_stub
+fop_readdir_stub
+fop_readlink_stub
+fop_readv_stub
+fop_removexattr_cbk_stub
+fop_removexattr_stub
+fop_rename_cbk_stub
+fop_rename_stub
+fop_rmdir_cbk_stub
+fop_rmdir_stub
+fop_seek_stub
+fop_setactivelk_stub
+fop_setattr_stub
+fop_setxattr_stub
+fop_statfs_stub
+fop_stat_stub
+fop_symlink_stub
+fop_truncate_cbk_stub
+fop_truncate_stub
+fop_unlink_cbk_stub
+fop_unlink_stub
+fop_writev_cbk_stub
+fop_writev_stub
+fop_xattrop_stub
+fop_zerofill_stub
+generate_glusterfs_ctx_id
+get_checksum_for_file
+get_checksum_for_path
+get_file_mtime
+get_host_name
+get_mem_size
+get_path_name
+get_xlator_by_name
+get_xlator_by_type
+gf_array_insertionsort
+gf_asprintf
+gf_async
+gf_async_adjust_threads
+gf_async_ctrl
+gf_async_init
+gf_async_fini
+gf_backtrace_save
+gf_bits_count
+gf_bits_index
+gf_build_absolute_path
+__gf_calloc
+gf_canonicalize_path
+gf_check_log_format
+gf_check_logger
+gf_client_disconnect
+gf_client_dump_fdtables
+gf_client_dump_fdtables_to_dict
+gf_client_dump_inodes
+gf_client_dump_inodes_to_dict
+gf_client_get
+gf_client_put
+gf_client_ref
+gf_clienttable_alloc
+gf_client_unref
+gf_cmd_log
+gf_cmd_log_init
+gf_compare_sockaddr
+gf_deitransform
+gf_dirent_entry_free
+gf_dirent_for_name
+gf_dirent_free
+gf_dirent_orig_offset
+gf_dm_hashfn
+gf_dnscache_init
+gf_dnscache_deinit
+gf_errno_to_error
+gf_error_to_errno
+_gf_event
+gf_fd_fdptr_get
+gf_fd_fdtable_alloc
+gf_fd_fdtable_copy_all_fds
+gf_fd_fdtable_destroy
+gf_fd_fdtable_get_all_fds
+gf_fdptr_put
+gf_fd_put
+gf_fd_unused_get
+gf_fill_iatt_for_dirent
+gf_fop_int
+gf_fop_string
+__gf_free
+gf_free_mig_locks
+gf_getgrouplist
+gf_get_hostname_from_ip
+gf_get_index_by_elem
+gf_global_mem_acct_enable_set
+gfid_to_ino
+gf_inode_type_to_str
+gf_is_ip_in_net
+gf_is_local_addr
+gf_is_same_address
+gf_is_service_running
+gf_is_str_int
+gf_is_valid_xattr_namespace
+gf_is_zero_filled_stat
+gf_itransform
+gf_link_inodes_from_dirent
+_gf_log
+_gf_log_callingfn
+gf_log_disable_suppression_before_exit
+gf_log_dump_graph
+_gf_log_eh
+gf_log_fini
+gf_log_get_localtime
+gf_log_get_loglevel
+gf_log_globals_init
+gf_log_init
+gf_log_inject_timer_event
+gf_log_logrotate
+gf_log_set_localtime
+gf_log_set_log_buf_size
+gf_log_set_log_flush_timeout
+gf_log_set_logformat
+gf_log_set_logger
+gf_log_set_loglevel
+gf_lstat_dir
+__gf_malloc
+gf_mem_acct_enable_set
+gf_monitor_metrics
+_gf_msg
+_gf_msg_nomem
+gf_nwrite
+gf_path_strip_trailing_slashes
+gf_print_trace
+gf_proc_dump_add_section
+gf_proc_dump_info
+gf_proc_dump_init
+gf_proc_dump_mallinfo
+gf_proc_dump_mem_info
+gf_proc_dump_mem_info_to_dict
+gf_proc_dump_mempool_info
+gf_proc_dump_mempool_info_to_dict
+gf_proc_dump_pending_frames
+gf_proc_dump_pending_frames_to_dict
+gf_proc_dump_write
+gf_proc_dump_xlator_history
+gf_proc_dump_xlator_meminfo
+gf_proc_dump_xlator_private
+gf_proc_dump_xlator_profile
+gf_process_getspec_servers_list
+gf_process_reserved_ports
+__gf_realloc
+_gf_ref_get
+_gf_ref_init
+_gf_ref_put
+gf_resolve_ip6
+gf_resolve_path_parent
+gf_rev_dns_lookup
+gf_rev_dns_lookup_cached
+gf_rsync_strong_checksum
+gf_rsync_md5_checksum
+gf_rsync_weak_checksum
+gf_set_log_file_path
+gf_set_log_ident
+gf_set_timestamp
+gf_set_volfile_server_common
+_gf_smsg
+gf_sock_union_equal_addr
+gf_store_handle_create_on_absence
+gf_store_handle_destroy
+gf_store_handle_new
+gf_store_handle_retrieve
+gf_store_iter_destroy
+gf_store_iter_get_matching
+gf_store_iter_get_next
+gf_store_iter_new
+gf_store_lock
+gf_store_locked_local
+gf_store_mkdir
+gf_store_mkstemp
+gf_store_read_and_tokenize
+gf_store_rename_tmppath
+gf_store_retrieve_value
+gf_store_save_value
+gf_store_save_items
+gf_store_unlink_tmppath
+gf_store_unlock
+gf_string2boolean
+gf_string2bytesize_int64
+gf_string2bytesize_uint64
+gf_string2double
+gf_string2int
+gf_string2int32
+gf_string2percent
+gf_string2time
+gf_string2uint
+gf_string2uint32
+gf_string2uint64
+gf_string2uint_base10
+gf_strip_whitespace
+gf_strncpy
+gf_strTrim
+gf_strstr
+gf_thread_cleanup_xint
+gf_thread_create
+gf_thread_vcreate
+gf_thread_create_detached
+gf_thread_set_name
+gf_thread_set_vname
+gf_timer_call_after
+gf_timer_call_cancel
+gf_timer_registry_destroy
+_gf_timestuff
+gf_trim
+gf_tw_add_timer
+gf_tw_del_timer
+gf_tw_mod_timer
+gf_tw_mod_timer_pending
+gf_uint64_2human_readable
+gf_umount_lazy
+gf_update_latency
+gf_uuid_clear
+gf_uuid_compare
+gf_uuid_copy
+gf_uuid_is_null
+gf_uuid_generate
+gf_uuid_parse
+gf_uuid_unparse
+gf_valid_pid
+gf_vasprintf
+gf_volfile_reconfigure
+gf_xxh64_wrapper
+gf_zero_fill_stat
+gid_cache_add
+gid_cache_init
+gid_cache_lookup
+gid_cache_reconf
+gid_cache_release
+glusterd_check_log_level
+glusterfs_compute_sha256
+glusterfs_ctx_new
+glusterfs_ctx_tw_get
+glusterfs_ctx_tw_put
+glusterfs_delete_volfile_checksum
+glusterfs_globals_init
+glusterfs_graph_activate
+glusterfs_graph_attach
+glusterfs_graph_construct
+glusterfs_graph_deactivate
+glusterfs_graph_destroy
+glusterfs_graph_destroy_residual
+glusterfs_graph_prepare
+glusterfs_read_secure_access_file
+glusterfs_graph_print_file
+glusterfs_graph_set_first
+glusterfs_is_local_pathinfo
+glusterfs_leaf_position
+glusterfs_reachable_leaves
+__glusterfs_this_location
+glusterfs_this_set
+glusterfs_volfile_reconfigure
+glusterfs_xlator_link
+graph_reconf_validateopt
+_init
+inode_ctx_del2
+__inode_ctx_get0
+inode_ctx_get0
+__inode_ctx_get1
+inode_ctx_get1
+__inode_ctx_get2
+inode_ctx_get2
+inode_ctx_merge
+inode_ctx_reset0
+inode_ctx_reset1
+inode_ctx_reset2
+__inode_ctx_set0
+inode_ctx_set0
+__inode_ctx_set1
+inode_ctx_set1
+__inode_ctx_set2
+inode_ctx_set2
+inode_ctx_size
+inode_dump
+inode_dump_to_dict
+__inode_find
+inode_find
+inode_find_directory_name
+inode_forget
+inode_forget_with_unref
+inode_from_path
+inode_grep
+inode_grep_for_gfid
+inode_has_dentry
+inode_invalidate
+inode_is_linked
+inode_link
+inode_lookup
+inode_needs_lookup
+inode_new
+inode_parent
+__inode_path
+inode_path
+inode_ref
+inode_ref_reduce_by_n
+inode_rename
+inode_resolve
+inode_set_need_lookup
+inode_table_ctx_free
+inode_table_destroy
+inode_table_destroy_all
+inode_table_dump
+inode_table_dump_to_dict
+inode_table_new
+inode_table_with_invalidator
+__inode_table_set_lru_limit
+inode_table_set_lru_limit
+inode_unlink
+inode_unref
+int_to_data
+iobref_add
+iobref_clear
+iobref_merge
+iobref_new
+iobref_ref
+iobref_size
+iobref_unref
+iobuf_get
+iobuf_get2
+iobuf_get_page_aligned
+iobuf_pool_destroy
+iobuf_pool_new
+iobuf_size
+iobuf_to_iovec
+iobuf_unref
+iobuf_copy
+is_data_equal
+__is_fuse_call
+is_gf_log_command
+is_graph_topology_equal
+__is_root_gfid
+is_valid_lease_id
+leaseid_utoa
+gf_existing_leaseid
+gf_leaseid_get
+list_node_add
+list_node_add_order
+list_node_del
+lkowner_utoa
+loc_copy
+loc_copy_overload_parent
+loc_gfid
+loc_gfid_utoa
+loc_is_nameless
+loc_is_root
+loc_pargfid
+loc_path
+loc_touchup
+loc_wipe
+log_base2
+_mask_cancellation
+mask_match
+mem_get
+mem_get0
+mem_pool_destroy
+mem_pool_new_fn
+mem_pools_fini
+mem_pools_init
+mem_put
+mkdir_p
+next_token
+nwstrtail
+os_daemon
+os_daemon_return
+parser_deinit
+parser_get_next_match
+parser_init
+parser_set_string
+parser_unset_string
+quota_conf_read_gfid
+quota_conf_read_version
+quota_conf_skip_header
+quota_data_to_meta
+quota_dict_get_inode_meta
+quota_dict_get_meta
+quota_dict_set_meta
+quota_meta_is_null
+rb_create
+rb_delete
+rb_destroy
+rb_find
+rb_probe
+rbthash_get
+rbthash_insert
+rbthash_remove
+rbthash_table_destroy
+rbthash_table_init
+rbuf_dtor
+rbuf_get_buffer
+rbuf_init
+rbuf_reserve_write_area
+rbuf_wait_for_completion
+rbuf_write_complete
+recursive_rmdir
+runcmd
+runinit
+runner
+runner_add_arg
+runner_add_args
+runner_argprintf
+runner_chio
+runner_end
+runner_log
+runner_redir
+runner_run
+runner_run_nowait
+runner_run_reuse
+runner_start
+set_sys_log_level
+skipwhite
+strfd_close
+strfd_open
+strprintf
+strtail
+str_to_data
+SuperFastHash
+syncbarrier_destroy
+syncbarrier_init
+syncbarrier_wait
+syncbarrier_wake
+synccond_init
+synccond_destroy
+synccond_wait
+synccond_timedwait
+synccond_signal
+synccond_broadcast
+syncenv_destroy
+syncenv_new
+synclock_destroy
+synclock_init
+synclock_lock
+synclock_trylock
+synclock_unlock
+syncop_access
+syncop_close
+syncop_create
+syncop_copy_file_range
+syncopctx_getctx
+syncopctx_setfsgid
+syncopctx_setfsgroups
+syncopctx_setfslkowner
+syncopctx_setfspid
+syncopctx_setfsuid
+syncop_dirfd
+syncop_dir_scan
+syncop_discard
+syncop_fallocate
+syncop_flush
+syncop_fgetxattr
+syncop_fremovexattr
+syncop_fsetattr
+syncop_fsetxattr
+syncop_fstat
+syncop_fsync
+syncop_fsyncdir
+syncop_ftruncate
+syncop_ftw
+syncop_ftw_throttle
+syncop_fxattrop
+syncop_getactivelk
+syncop_getxattr
+syncop_gfid_to_path
+syncop_gfid_to_path_hard
+syncop_inode_find
+syncop_inodelk
+syncop_entrylk
+syncop_ipc
+syncop_is_subvol_local
+syncop_link
+syncop_listxattr
+syncop_lk
+syncop_lookup
+syncop_mkdir
+syncop_mknod
+syncop_mt_dir_scan
+syncop_open
+syncop_opendir
+syncop_readdir
+syncop_readdirp
+syncop_readlink
+syncop_readv
+syncop_removexattr
+syncop_rename
+syncop_rmdir
+syncop_seek
+syncop_setactivelk
+syncop_setattr
+syncop_setxattr
+syncop_stat
+syncop_statfs
+syncop_symlink
+syncop_truncate
+syncop_unlink
+syncop_write
+syncop_writev
+syncop_xattrop
+syncop_zerofill
+syncop_lease
+synctask_get
+synctask_new
+synctask_new1
+synctask_set
+synctask_setid
+synctask_sleep
+synctask_wake
+synctask_yield
+sys_access
+sys_chmod
+sys_chown
+sys_close
+sys_closedir
+sys_copy_file_range
+sys_creat
+sys_fallocate
+sys_fchmod
+sys_fchown
+sys_fdatasync
+sys_fgetxattr
+sys_flistxattr
+sys_fremovexattr
+sys_fsetxattr
+sys_fstat
+sys_fstatat
+sys_fsync
+sys_ftruncate
+sys_futimes
+sys_lchown
+sys_lgetxattr
+sys_link
+sys_linkat
+sys_llistxattr
+sys_lremovexattr
+sys_lseek
+sys_lsetxattr
+sys_lstat
+sys_mkdir
+sys_mkdirat
+sys_mknod
+sys_open
+sys_openat
+sys_opendir
+sys_pread
+sys_pwrite
+sys_pwritev
+sys_read
+sys_readdir
+sys_readlink
+sys_readv
+sys_rename
+sys_rmdir
+sys_stat
+sys_statvfs
+sys_symlink
+sys_symlinkat
+sys_truncate
+sys_unlink
+sys_unlinkat
+sys_utimensat
+sys_write
+sys_writev
+sys_socket
+sys_accept
+sys_kill
+sys_sysctl
+tbf_init
+tbf_throttle
+timespec_now
+timespec_now_realtime
+timespec_sub
+timespec_adjust_delta
+timespec_cmp
+token_iter_init
+trap
+trie_add
+trie_destroy
+trie_measure
+trie_measure_vec
+trie_new
+trienode_get_word
+_unmask_cancellation
+uuid_utoa
+uuid_utoa_r
+validate_brick_name
+valid_host_name
+valid_ipv4_address
+valid_internet_address
+xlator_destroy
+xlator_foreach
+xlator_foreach_depth_first
+xlator_init
+xlator_mem_acct_init
+xlator_mem_acct_unref
+xlator_notify
+xlator_option_info_list
+xlator_option_init_bool
+xlator_option_init_double
+xlator_option_init_int32
+xlator_option_init_path
+xlator_option_init_percent
+xlator_option_init_percent_or_size
+xlator_option_init_size
+xlator_option_init_size_uint64
+xlator_option_init_size_int64
+xlator_option_init_str
+xlator_option_init_time
+xlator_option_init_uint32
+xlator_option_init_uint64
+xlator_option_init_int64
+xlator_option_init_xlator
+xlator_option_reconf_bool
+xlator_option_reconf_int32
+xlator_option_reconf_path
+xlator_option_reconf_percent
+xlator_option_reconf_percent_or_size
+xlator_option_reconf_size
+xlator_option_reconf_size_uint64
+xlator_option_reconf_size_int64
+xlator_option_reconf_str
+xlator_option_reconf_time
+xlator_option_reconf_uint32
+xlator_option_reconf_uint64
+xlator_option_reconf_int64
+xlator_option_reconf_xlator
+xlator_options_validate
+xlator_options_validate_list
+xlator_option_validate
+xlator_option_validate_addr_list
+xlator_search_by_name
+xlator_set_inode_lru_limit
+xlator_set_type
+xlator_set_type_virtual
+xlator_subvolume_count
+xlator_tree_free_members
+xlator_volopt_dynload
+xlator_volume_option_get
+xlator_volume_option_get_list
+xlator_memrec_free
+xlator_mem_cleanup
+gluster_graph_take_reference
+default_fops
+gf_fop_list
+gf_upcall_list
+vol_type_str
+global_ctx
+global_ctx_mutex
+global_xlator
+use_spinlocks
+dump_options
+glusterfs_leaseid_buf_get
+glusterfs_leaseid_exist
+gf_replace_old_iatt_in_dict
+gf_replace_new_iatt_in_dict
+gf_changelog_init
+gf_changelog_register_generic
+gf_gfid_generate_from_xxh64
+find_xlator_option_in_cmd_args_t
+gf_d_type_from_ia_type
+glusterfs_graph_fini
+glusterfs_process_svc_attach_volfp
+glusterfs_mux_volfile_reconfigure
+glusterfs_process_svc_detach
+mgmt_is_multiplexed_daemon
+xlator_is_cleanup_starting
+gf_nanosleep
+gf_syncfs
+graph_total_client_xlator
+get_xattrs_to_heal
+gf_latency_statedump_and_reset
+gf_latency_new
+gf_latency_reset
+gf_latency_update
+gf_frame_latency_update
diff --git a/libglusterfs/src/list.h b/libglusterfs/src/list.h
deleted file mode 100644
index b8f9a6eebd8..00000000000
--- a/libglusterfs/src/list.h
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _LLIST_H
-#define _LLIST_H
-
-
-struct list_head {
-	struct list_head *next;
-	struct list_head *prev;
-};
-
-
-#define INIT_LIST_HEAD(head) do {			\
-		(head)->next = (head)->prev = head;	\
-	} while (0)
-
-
-static inline void
-list_add (struct list_head *new, struct list_head *head)
-{
-	new->prev = head;
-	new->next = head->next;
-
-	new->prev->next = new;
-	new->next->prev = new;
-}
-
-
-static inline void
-list_add_tail (struct list_head *new, struct list_head *head)
-{
-	new->next = head;
-	new->prev = head->prev;
-
-	new->prev->next = new;
-	new->next->prev = new;
-}
-
-
-/* This function will insert the element to the list in a order.
-   Order will be based on the compare function provided as a input.
-   If element to be inserted in ascending order compare should return:
-    0: if both the arguments are equal
-   >0: if first argument is greater than second argument
-   <0: if first argument is less than second argument */
-static inline void
-list_add_order (struct list_head *new, struct list_head *head,
-                int (*compare)(struct list_head *, struct list_head *))
-{
-        struct list_head *pos = head->prev;
-
-        while ( pos != head ) {
-                if (compare(new, pos) >= 0)
-                        break;
-
-                /* Iterate the list in the reverse order. This will have
-                   better efficiency if the elements are inserted in the
-                   ascending order */
-                pos = pos->prev;
-        }
-
-        list_add (new, pos);
-}
-
-static inline void
-list_del (struct list_head *old)
-{
-	old->prev->next = old->next;
-	old->next->prev = old->prev;
-
-	old->next = (void *)0xbabebabe;
-	old->prev = (void *)0xcafecafe;
-}
-
-
-static inline void
-list_del_init (struct list_head *old)
-{
-	old->prev->next = old->next;
-	old->next->prev = old->prev;
-
-	old->next = old;
-	old->prev = old;
-}
-
-
-static inline void
-list_move (struct list_head *list, struct list_head *head)
-{
-	list_del (list);
-	list_add (list, head);
-}
-
-
-static inline void
-list_move_tail (struct list_head *list, struct list_head *head)
-{
-	list_del (list);
-	list_add_tail (list, head);
-}
-
-
-static inline int
-list_empty (struct list_head *head)
-{
-	return (head->next == head);
-}
-
-
-static inline void
-__list_splice (struct list_head *list, struct list_head *head)
-{
-	(list->prev)->next = (head->next);
-	(head->next)->prev = (list->prev);
-
-	(head)->next = (list->next);
-	(list->next)->prev = (head);
-}
-
-
-static inline void
-list_splice (struct list_head *list, struct list_head *head)
-{
-	if (list_empty (list))
-		return;
-
-	__list_splice (list, head);
-}
-
-
-/* Splice moves @list to the head of the list at @head. */
-static inline void
-list_splice_init (struct list_head *list, struct list_head *head)
-{
-	if (list_empty (list))
-		return;
-
-	__list_splice (list, head);
-	INIT_LIST_HEAD (list);
-}
-
-
-static inline void
-__list_append (struct list_head *list, struct list_head *head)
-{
-	(head->prev)->next = (list->next);
-        (list->next)->prev = (head->prev);
-        (head->prev) = (list->prev);
-        (list->prev)->next = head;
-}
-
-
-static inline void
-list_append (struct list_head *list, struct list_head *head)
-{
-	if (list_empty (list))
-		return;
-
-	__list_append (list, head);
-}
-
-
-/* Append moves @list to the end of @head */
-static inline void
-list_append_init (struct list_head *list, struct list_head *head)
-{
-	if (list_empty (list))
-		return;
-
-	__list_append (list, head);
-	INIT_LIST_HEAD (list);
-}
-
-static inline int
-list_is_last (struct list_head *list, struct list_head *head)
-{
-        return (list->next == head);
-}
-
-static inline int
-list_is_singular(struct list_head *head)
-{
-        return !list_empty(head) && (head->next == head->prev);
-}
-
-/**
- * list_replace - replace old entry by new one
- * @old : the element to be replaced
- * @new : the new element to insert
- *
- * If @old was empty, it will be overwritten.
- */
-static inline void list_replace(struct list_head *old,
-				struct list_head *new)
-{
-	new->next = old->next;
-	new->next->prev = new;
-	new->prev = old->prev;
-	new->prev->next = new;
-}
-
-static inline void list_replace_init(struct list_head *old,
-                                     struct list_head *new)
-{
-	list_replace(old, new);
-	INIT_LIST_HEAD(old);
-}
-
-/**
- * list_rotate_left - rotate the list to the left
- * @head: the head of the list
- */
-static inline void list_rotate_left (struct list_head *head)
-{
-	struct list_head *first;
-
-	if (!list_empty (head)) {
-		first = head->next;
-		list_move_tail (first, head);
-	}
-}
-
-#define list_entry(ptr, type, member)					\
-	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
-
-#define list_first_entry(ptr, type, member)     \
-        list_entry((ptr)->next, type, member)
-
-#define list_last_entry(ptr, type, member)     \
-        list_entry((ptr)->prev, type, member)
-
-#define list_next_entry(pos, member) \
-        list_entry((pos)->member.next, typeof(*(pos)), member)
-
-#define list_prev_entry(pos, member) \
-        list_entry((pos)->member.prev, typeof(*(pos)), member)
-
-#define list_for_each(pos, head)                                        \
-	for (pos = (head)->next; pos != (head); pos = pos->next)
-
-#define list_for_each_entry(pos, head, member)				\
-	for (pos = list_entry((head)->next, typeof(*pos), member);	\
-	     &pos->member != (head); 					\
-	     pos = list_entry(pos->member.next, typeof(*pos), member))
-
-
-#define list_for_each_entry_safe(pos, n, head, member)			\
-	for (pos = list_entry((head)->next, typeof(*pos), member),	\
-		n = list_entry(pos->member.next, typeof(*pos), member);	\
-	     &pos->member != (head); 					\
-	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
-
-#define list_for_each_entry_reverse(pos, head, member)                  \
-	for (pos = list_entry((head)->prev, typeof(*pos), member);      \
-	     &pos->member != (head);                                    \
-	     pos = list_entry(pos->member.prev, typeof(*pos), member))
-
-
-#define list_for_each_entry_safe_reverse(pos, n, head, member)          \
-	for (pos = list_entry((head)->prev, typeof(*pos), member),      \
-	        n = list_entry(pos->member.prev, typeof(*pos), member); \
-	     &pos->member != (head);                                    \
-	     pos = n, n = list_entry(n->member.prev, typeof(*n), member))
-
-/*
- * This list implementation has some advantages, but one disadvantage: you
- * can't use NULL to check whether you're at the head or tail.  Thus, the
- * address of the head has to be an argument for these macros.
- */
-
-#define list_next(ptr, head, type, member)      \
-        (((ptr)->member.next == head) ? NULL    \
-                                 : list_entry((ptr)->member.next, type, member))
-
-#define list_prev(ptr, head, type, member)      \
-        (((ptr)->member.prev == head) ? NULL    \
-                                 : list_entry((ptr)->member.prev, type, member))
-
-#endif /* _LLIST_H */
diff --git a/libglusterfs/src/lkowner.h b/libglusterfs/src/lkowner.h
deleted file mode 100644
index 9712f176f30..00000000000
--- a/libglusterfs/src/lkowner.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _LK_OWNER_H
-#define _LK_OWNER_H
-
-#include "glusterfs-fops.h"
-
-/* LKOWNER to string functions */
-static inline void
-lkowner_unparse (gf_lkowner_t *lkowner, char *buf, int buf_len)
-{
-        int i = 0;
-        int j = 0;
-
-        for (i = 0; i < lkowner->len; i++) {
-                if (i && !(i % 8)) {
-                        buf[j] = '-';
-                        j++;
-                }
-                sprintf (&buf[j], "%02hhx", lkowner->data[i]);
-                j += 2;
-                if (j == buf_len)
-                        break;
-        }
-        if (j < buf_len)
-                buf[j] = '\0';
-}
-
-static inline void
-set_lk_owner_from_ptr (gf_lkowner_t *lkowner, void *data)
-{
-        int i = 0;
-        int j = 0;
-
-        lkowner->len = sizeof (unsigned long);
-        for (i = 0, j = 0; i < lkowner->len; i++, j += 8) {
-                lkowner->data[i] =  (char)((((unsigned long)data) >> j) & 0xff);
-        }
-}
-
-static inline void
-set_lk_owner_from_uint64 (gf_lkowner_t *lkowner, uint64_t data)
-{
-        int i = 0;
-        int j = 0;
-
-        lkowner->len = 8;
-        for (i = 0, j = 0; i < lkowner->len; i++, j += 8) {
-                lkowner->data[i] =  (char)((data >> j) & 0xff);
-        }
-}
-
-/* Return true if the locks have the same owner */
-static inline int
-is_same_lkowner (gf_lkowner_t *l1, gf_lkowner_t *l2)
-{
-        return ((l1->len == l2->len) && !memcmp(l1->data, l2->data, l1->len));
-}
-
-static inline int
-is_lk_owner_null (gf_lkowner_t *lkowner)
-{
-        int is_null = 1;
-        int i       = 0;
-
-        if (lkowner == NULL || lkowner->len == 0)
-                goto out;
-
-        for (i = 0; i < lkowner->len; i++) {
-                if (lkowner->data[i] != 0) {
-                        is_null = 0;
-                        break;
-                }
-        }
-out:
-        return is_null;
-}
-
-static inline void
-lk_owner_copy (gf_lkowner_t *dst, gf_lkowner_t *src)
-{
-        dst->len = src->len;
-        memcpy(dst->data, src->data, src->len);
-}
-#endif /* _LK_OWNER_H */
diff --git a/libglusterfs/src/locking.c b/libglusterfs/src/locking.c
index f27b0d05b35..7577054e33a 100644
--- a/libglusterfs/src/locking.c
+++ b/libglusterfs/src/locking.c
@@ -15,14 +15,13 @@
 #include <unistd.h>
 
 #define LOCKING_IMPL
-#include "locking.h"
+#include "glusterfs/locking.h"
 
 int use_spinlocks = 0;
 
-static void __attribute__((constructor))
-gf_lock_setup (void)
+static void __attribute__((constructor)) gf_lock_setup(void)
 {
-        //use_spinlocks = (sysconf(_SC_NPROCESSORS_ONLN) > 1);
+    // use_spinlocks = (sysconf(_SC_NPROCESSORS_ONLN) > 1);
 }
 
 #endif
diff --git a/libglusterfs/src/logging.c b/libglusterfs/src/logging.c
index 0f238d00738..a930d3e3b63 100644
--- a/libglusterfs/src/logging.c
+++ b/libglusterfs/src/logging.c
@@ -17,6 +17,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <syslog.h>
+#include <sys/resource.h>
 
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
@@ -26,171 +27,134 @@
 
 #include <sys/stat.h>
 
-#include "syscall.h"
+#include "glusterfs/syscall.h"
 
-#define GF_JSON_MSG_LENGTH      8192
-#define GF_SYSLOG_CEE_FORMAT    \
-        "@cee: {\"msg\": \"%s\", \"gf_code\": \"%u\", \"gf_message\": \"%s\"}"
-#define GF_LOG_CONTROL_FILE     "/etc/glusterfs/logger.conf"
-#define GF_LOG_BACKTRACE_DEPTH  5
-#define GF_LOG_BACKTRACE_SIZE   4096
-#define GF_LOG_TIMESTR_SIZE     256
-#define GF_MAX_SLOG_PAIR_COUNT  100
+#define GF_JSON_MSG_LENGTH 8192
+#define GF_SYSLOG_CEE_FORMAT                                                   \
+    "@cee: {\"msg\": \"%s\", \"gf_code\": \"%u\", \"gf_message\": \"%s\"}"
+#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf"
+#define GF_LOG_BACKTRACE_DEPTH 5
+#define GF_LOG_BACKTRACE_SIZE 4096
+#define GF_MAX_SLOG_PAIR_COUNT 100
 
-#include "xlator.h"
-#include "logging.h"
-#include "defaults.h"
-#include "glusterfs.h"
-#include "timer.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/timer.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 /* Do not replace gf_log in TEST_LOG with gf_msg, as there is a slight chance
  * that it could lead to an infinite recursion.*/
-#define TEST_LOG(__msg, __args ...)                             \
-                gf_log ("logging-infra", GF_LOG_DEBUG, __msg, ##__args);
+#define TEST_LOG(__msg, __args...)                                             \
+    gf_log("logging-infra", GF_LOG_DEBUG, __msg, ##__args);
 
-void
-gf_log_flush_timeout_cbk (void *data);
+static void
+gf_log_flush_timeout_cbk(void *data);
 
 int
-gf_log_inject_timer_event (glusterfs_ctx_t *ctx);
+gf_log_inject_timer_event(glusterfs_ctx_t *ctx);
 
 static void
-gf_log_flush_extra_msgs (glusterfs_ctx_t *ctx, uint32_t new);
-
-static char *gf_level_strings[] = {"",  /* NONE */
-                "M", /* EMERGENCY */
-                "A", /* ALERT */
-                "C", /* CRITICAL */
-                "E", /* ERROR */
-                "W", /* WARNING */
-                "N", /* NOTICE */
-                "I", /* INFO */
-                "D", /* DEBUG */
-                "T", /* TRACE */
-                ""
-};
-
-/* Ideally this should get moved to logging.h */
-struct _msg_queue {
-        struct list_head msgs;
-};
+gf_log_flush_extra_msgs(glusterfs_ctx_t *ctx, uint32_t new);
 
-struct _log_msg {
-        const char *msg;
-        struct list_head queue;
+static int
+log_buf_init(log_buf_t *buf, const char *domain, const char *file,
+             const char *function, int32_t line, gf_loglevel_t level,
+             int errnum, uint64_t msgid, char **appmsgstr, int graph_id);
+static void
+gf_log_rotate(glusterfs_ctx_t *ctx);
+
+static char gf_level_strings[] = {
+    ' ', /* NONE */
+    'M', /* EMERGENCY */
+    'A', /* ALERT */
+    'C', /* CRITICAL */
+    'E', /* ERROR */
+    'W', /* WARNING */
+    'N', /* NOTICE */
+    'I', /* INFO */
+    'D', /* DEBUG */
+    'T', /* TRACE */
 };
 
 void
-gf_log_logrotate (int signum)
+gf_log_logrotate(int signum)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx) {
-                ctx->log.logrotate = 1;
-                ctx->log.cmd_history_logrotate = 1;
-        }
+    if (THIS->ctx) {
+        THIS->ctx->log.logrotate = 1;
+        THIS->ctx->log.cmd_history_logrotate = 1;
+    }
 }
 
 void
-gf_log_enable_syslog (void)
+gf_log_enable_syslog(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.gf_log_syslog = 1;
+    if (THIS->ctx)
+        THIS->ctx->log.gf_log_syslog = 1;
 }
 
 void
-gf_log_disable_syslog (void)
+gf_log_disable_syslog(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.gf_log_syslog = 0;
+    if (THIS->ctx)
+        THIS->ctx->log.gf_log_syslog = 0;
 }
 
 gf_loglevel_t
-gf_log_get_loglevel (void)
+gf_log_get_loglevel(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                return ctx->log.loglevel;
-        else
-                /* return global defaults (see gf_log_globals_init) */
-                return GF_LOG_INFO;
+    if (THIS->ctx)
+        return THIS->ctx->log.loglevel;
+    else
+        /* return global defaults (see gf_log_globals_init) */
+        return GF_LOG_INFO;
 }
 
 void
-gf_log_set_loglevel (gf_loglevel_t level)
+gf_log_set_loglevel(glusterfs_ctx_t *ctx, gf_loglevel_t level)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.loglevel = level;
+    if (ctx)
+        ctx->log.loglevel = level;
 }
 
 int
-gf_log_get_localtime (void)
+gf_log_get_localtime(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                return ctx->log.localtime;
-        else
-                /* return global defaults (see gf_log_globals_init) */
-                return 0;
+    if (THIS->ctx)
+        return THIS->ctx->log.localtime;
+    else
+        /* return global defaults (see gf_log_globals_init) */
+        return 0;
 }
 
 void
-gf_log_set_localtime (int on_off)
+gf_log_set_localtime(int on_off)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.localtime = on_off;
+    if (THIS->ctx)
+        THIS->ctx->log.localtime = on_off;
 }
 
 void
-gf_log_flush (void)
+gf_log_flush(void)
 {
-        xlator_t        *this           = NULL;
-        glusterfs_ctx_t *ctx            = NULL;
-
-        this = THIS;
-        ctx = this->ctx;
+    xlator_t *this = THIS;
+    glusterfs_ctx_t *ctx = this->ctx;
 
-        if (ctx && ctx->log.logger == gf_logger_glusterlog) {
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                fflush (ctx->log.gf_log_logfile);
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        }
+    if (ctx && ctx->log.logger == gf_logger_glusterlog) {
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        fflush(ctx->log.gf_log_logfile);
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    }
 
-        return;
+    return;
 }
 
 void
-gf_log_set_xl_loglevel (void *this, gf_loglevel_t level)
+gf_log_set_xl_loglevel(void *this, gf_loglevel_t level)
 {
-        xlator_t *xl = this;
-        if (!xl)
-                return;
-        xl->loglevel = level;
+    xlator_t *xl = this;
+    if (!xl)
+        return;
+    xl->loglevel = level;
 }
 
 /* TODO: The following get/set functions are yet not invoked from anywhere
@@ -210,253 +174,204 @@ gf_log_set_xl_loglevel (void *this, gf_loglevel_t level)
  *
  * care needs to be taken to configure and start daemons based on the versions
  * that supports these features */
-gf_log_format_t
-gf_log_get_logformat (void)
-{
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                return ctx->log.logformat;
-        else
-                /* return global defaluts (see gf_log_globals_init) */
-                return gf_logformat_withmsgid;
-}
 
 void
-gf_log_set_logformat (gf_log_format_t format)
+gf_log_set_logformat(gf_log_format_t format)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.logformat = format;
-}
-
-gf_log_logger_t
-gf_log_get_logger (void)
-{
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                return ctx->log.logger;
-        else
-                /* return global defaluts (see gf_log_globals_init) */
-                return gf_logger_glusterlog;
+    if (THIS->ctx)
+        THIS->ctx->log.logformat = format;
 }
 
 void
-gf_log_set_logger (gf_log_logger_t logger)
+gf_log_set_logger(gf_log_logger_t logger)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.logger = logger;
+    if (THIS->ctx)
+        THIS->ctx->log.logger = logger;
 }
 
 gf_loglevel_t
-gf_log_get_xl_loglevel (void *this)
+gf_log_get_xl_loglevel(void *this)
 {
-        xlator_t *xl = this;
-        if (!xl)
-                return 0;
-        return xl->loglevel;
+    xlator_t *xl = this;
+    if (!xl)
+        return 0;
+    return xl->loglevel;
 }
 
 void
-gf_log_set_log_buf_size (uint32_t buf_size)
+gf_log_set_log_buf_size(uint32_t buf_size)
 {
-        uint32_t          old = 0;
-        glusterfs_ctx_t  *ctx = THIS->ctx;
-
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                old = ctx->log.lru_size;
-                ctx->log.lru_size = buf_size;
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-
-        /* If the old size is less than/equal to the new size, then do nothing.
-         *
-         * But if the new size is less than the old size, then
-         *   a. If the cur size of the buf is less than or equal the new size,
-         *      then do nothing.
-         *   b. But if the current size of the buf is greater than the new size,
-         *      then flush the least recently used (cur size - new_size) msgs
-         *      to disk.
-         */
-        if (buf_size < old)
-                gf_log_flush_extra_msgs (ctx, buf_size);
+    uint32_t old = 0;
+    glusterfs_ctx_t *ctx = THIS->ctx;
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        old = ctx->log.lru_size;
+        ctx->log.lru_size = buf_size;
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+
+    /* If the old size is less than/equal to the new size, then do nothing.
+     *
+     * But if the new size is less than the old size, then
+     *   a. If the cur size of the buf is less than or equal the new size,
+     *      then do nothing.
+     *   b. But if the current size of the buf is greater than the new size,
+     *      then flush the least recently used (cur size - new_size) msgs
+     *      to disk.
+     */
+    if (buf_size < old)
+        gf_log_flush_extra_msgs(ctx, buf_size);
 }
 
 void
-gf_log_set_log_flush_timeout (uint32_t timeout)
+gf_log_set_log_flush_timeout(uint32_t timeout)
 {
-        THIS->ctx->log.timeout = timeout;
-}
-
-log_buf_t *
-log_buf_new ()
-{
-        log_buf_t  *buf  = NULL;
-
-        buf = mem_get0 (THIS->ctx->logbuf_pool);
-
-        return buf;
+    THIS->ctx->log.timeout = timeout;
 }
 
 /* If log_buf_init() fails (indicated by a return value of -1),
  * call log_buf_destroy() to clean up memory allocated in heap and to return
  * the log_buf_t object back to its memory pool.
  */
-int
-log_buf_init (log_buf_t *buf, const char *domain, const char *file,
-              const char *function, int32_t line, gf_loglevel_t level,
-              int errnum, uint64_t msgid, char **appmsgstr, int graph_id)
+static int
+log_buf_init(log_buf_t *buf, const char *domain, const char *file,
+             const char *function, int32_t line, gf_loglevel_t level,
+             int errnum, uint64_t msgid, char **appmsgstr, int graph_id)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!buf || !domain || !file || !function || !appmsgstr || !*appmsgstr)
-                goto out;
+    if (!buf || !domain || !file || !function || !appmsgstr || !*appmsgstr)
+        goto out;
 
-        buf->msg = gf_strdup (*appmsgstr);
-        if (!buf->msg)
-                goto out;
+    buf->msg = gf_strdup(*appmsgstr);
+    if (!buf->msg)
+        goto out;
 
-        buf->msg_id = msgid;
-        buf->errnum = errnum;
-        buf->domain = gf_strdup (domain);
-        if (!buf->domain)
-                goto out;
+    buf->msg_id = msgid;
+    buf->errnum = errnum;
+    buf->domain = gf_strdup(domain);
+    if (!buf->domain)
+        goto out;
 
-        buf->file = gf_strdup (file);
-        if (!buf->file)
-                goto out;
+    buf->file = gf_strdup(file);
+    if (!buf->file)
+        goto out;
 
-        buf->function = gf_strdup (function);
-        if (!buf->function)
-                goto out;
+    buf->function = gf_strdup(function);
+    if (!buf->function)
+        goto out;
 
-        buf->line = line;
-        buf->level = level;
-        buf->refcount = 0;
-        buf->graph_id = graph_id;
-        INIT_LIST_HEAD (&buf->msg_list);
+    buf->line = line;
+    buf->level = level;
+    buf->refcount = 0;
+    buf->graph_id = graph_id;
+    INIT_LIST_HEAD(&buf->msg_list);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-int
-log_buf_destroy (log_buf_t *buf)
+static int
+log_buf_destroy(log_buf_t *buf)
 {
+    if (!buf)
+        return -1;
 
-        if (!buf)
-                return -1;
-
-        GF_FREE (buf->msg);
-        GF_FREE (buf->domain);
-        GF_FREE (buf->file);
-        GF_FREE (buf->function);
+    GF_FREE(buf->msg);
+    GF_FREE(buf->domain);
+    GF_FREE(buf->file);
+    GF_FREE(buf->function);
 
-        mem_put (buf);
-        return 0;
+    mem_put(buf);
+    return 0;
 }
 
 static void
 gf_log_rotate(glusterfs_ctx_t *ctx)
 {
-        int            fd   = -1;
-        FILE          *new_logfile = NULL;
-        FILE          *old_logfile = NULL;
-
-        /* not involving locks on initial check to speed it up */
-        if (ctx->log.logrotate) {
-                /* let only one winner through on races */
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-
-                if (!ctx->log.logrotate) {
-                        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                        return;
-                } else {
-                        ctx->log.logrotate = 0;
-                        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                }
+    int fd = -1;
+    FILE *new_logfile = NULL;
+    FILE *old_logfile = NULL;
+
+    /* not involving locks on initial check to speed it up */
+    if (ctx->log.logrotate) {
+        /* let only one winner through on races */
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+
+        if (!ctx->log.logrotate) {
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
+            return;
+        } else {
+            ctx->log.logrotate = 0;
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
+        }
 
-                fd = open (ctx->log.filename,
-                           O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg ("logrotate", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open "
-                                "logfile");
-                        return;
-                }
-                sys_close (fd);
-
-                new_logfile = fopen (ctx->log.filename, "a");
-                if (!new_logfile) {
-                        gf_msg ("logrotate", GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open logfile"
-                                " %s", ctx->log.filename);
-                        return;
-                }
+        fd = sys_open(ctx->log.filename, O_CREAT | O_WRONLY | O_APPEND,
+                      S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            gf_smsg("logrotate", GF_LOG_ERROR, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, NULL);
+            return;
+        }
 
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile)
-                                old_logfile = ctx->log.logfile;
+        new_logfile = fdopen(fd, "a");
+        if (!new_logfile) {
+            gf_smsg("logrotate", GF_LOG_CRITICAL, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, "filename=%s",
+                    ctx->log.filename, NULL);
+            sys_close(fd);
+            return;
+        }
 
-                        ctx->log.gf_log_logfile = ctx->log.logfile =
-                                                                new_logfile;
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        {
+            if (ctx->log.logfile)
+                old_logfile = ctx->log.logfile;
 
-                if (old_logfile != NULL)
-                        fclose (old_logfile);
+            ctx->log.gf_log_logfile = ctx->log.logfile = new_logfile;
         }
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-        return;
+        if (old_logfile != NULL)
+            fclose(old_logfile);
+    }
+
+    return;
 }
 
 void
-gf_log_globals_fini (void)
+gf_log_globals_fini(void)
 {
-        /* TODO: Nobody is invoking the fini, but cleanup needs to happen here,
-         * needs cleanup for, log.ident, log.filename, closelog, log file close
-         * rotate state, possibly under a lock */
-        pthread_mutex_destroy (&THIS->ctx->log.logfile_mutex);
-        pthread_mutex_destroy (&THIS->ctx->log.log_buf_lock);
+    /* TODO: Nobody is invoking the fini, but cleanup needs to happen here,
+     * needs cleanup for, log.ident, log.filename, closelog, log file close
+     * rotate state, possibly under a lock */
+    pthread_mutex_destroy(&THIS->ctx->log.logfile_mutex);
+    pthread_mutex_destroy(&THIS->ctx->log.log_buf_lock);
 }
 
 void
-gf_log_disable_suppression_before_exit (glusterfs_ctx_t *ctx)
+gf_log_disable_suppression_before_exit(glusterfs_ctx_t *ctx)
 {
-        /*
-         * First set log buf size to 0. This would ensure two things:
-         * i. that all outstanding log messages are flushed to disk, and
-         * ii. all subsequent calls to gf_msg will result in the logs getting
-         *     directly flushed to disk without being buffered.
-         *
-         * Then, cancel the current log timer event.
-         */
-
-        gf_log_set_log_buf_size (0);
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                if (ctx->log.log_flush_timer) {
-                        gf_timer_call_cancel (ctx, ctx->log.log_flush_timer);
-                        ctx->log.log_flush_timer = NULL;
-                }
+    /*
+     * First set log buf size to 0. This would ensure two things:
+     * i. that all outstanding log messages are flushed to disk, and
+     * ii. all subsequent calls to gf_msg will result in the logs getting
+     *     directly flushed to disk without being buffered.
+     *
+     * Then, cancel the current log timer event.
+     */
+
+    gf_log_set_log_buf_size(0);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        if (ctx->log.log_flush_timer) {
+            gf_timer_call_cancel(ctx, ctx->log.log_flush_timer);
+            ctx->log.log_flush_timer = NULL;
         }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 }
 
 /** gf_log_fini - function to perform the cleanup of the log information
@@ -465,41 +380,43 @@ gf_log_disable_suppression_before_exit (glusterfs_ctx_t *ctx)
  *          failure: -1
  */
 int
-gf_log_fini (void *data)
+gf_log_fini(void *data)
 {
-        glusterfs_ctx_t *ctx = data;
-        int              ret = 0;
-        FILE            *old_logfile = NULL;
+    glusterfs_ctx_t *ctx = data;
+    int ret = 0;
+    FILE *old_logfile = NULL;
 
-        if (ctx == NULL) {
-	        ret = -1;
-                goto out;
-        }
+    if (ctx == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        gf_log_disable_suppression_before_exit (ctx);
+    gf_log_disable_suppression_before_exit(ctx);
 
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        old_logfile = ctx->log.logfile;
-
-                        /* Logfile needs to be set to NULL, so that any
-                           call to gf_log after calling gf_log_fini, will
-                           log the message to stderr.
-                        */
-                        ctx->log.loglevel = GF_LOG_NONE;
-                        ctx->log.logfile = NULL;
-                }
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            old_logfile = ctx->log.logfile;
+
+            /* Logfile needs to be set to NULL, so that any
+               call to gf_log after calling gf_log_fini, will
+               log the message to stderr.
+            */
+            ctx->log.loglevel = GF_LOG_NONE;
+            ctx->log.logfile = NULL;
         }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    }
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-        if (old_logfile && (fclose (old_logfile) != 0))
-                ret = -1;
+    if (old_logfile && (fclose(old_logfile) != 0))
+        ret = -1;
 
- out:
-        return ret;
-}
+    GF_FREE(ctx->log.ident);
+    GF_FREE(ctx->log.filename);
 
+out:
+    return ret;
+}
 
 /**
  * gf_openlog -function to open syslog specific to gluster based on
@@ -512,28 +429,27 @@ gf_log_fini (void *data)
  *
  * @return: void
  */
-void
-gf_openlog (const char *ident, int option, int facility)
+static void
+gf_openlog(const char *ident, int option, int facility)
 {
-        int _option = option;
-        int _facility = facility;
-
-        if (-1 == _option) {
-                _option = LOG_PID | LOG_NDELAY;
-        }
-        if (-1 == _facility) {
-                _facility = LOG_LOCAL1;
-        }
-
-        /* TODO: Should check for errors here and return appropriately */
-        setlocale(LC_ALL, "");
-        setlocale(LC_NUMERIC, "C"); /* C-locale for strtod, ... */
-        /* close the previous syslog if open as we are changing settings */
-        closelog ();
-        openlog(ident, _option, _facility);
+    int _option = option;
+    int _facility = facility;
+
+    if (-1 == _option) {
+        _option = LOG_PID | LOG_NDELAY;
+    }
+    if (-1 == _facility) {
+        _facility = LOG_LOCAL1;
+    }
+
+    /* TODO: Should check for errors here and return appropriately */
+    setlocale(LC_ALL, "");
+    setlocale(LC_NUMERIC, "C"); /* C-locale for strtod, ... */
+    /* close the previous syslog if open as we are changing settings */
+    closelog();
+    openlog(ident, _option, _facility);
 }
 
-
 /**
  * _json_escape -function to convert string to json encoded string
  * @str: input string
@@ -557,88 +473,78 @@ gf_openlog (const char *ident, int option, int facility)
  *     buf = "I/O error\u001bon /tmp/bar file"
  *
  */
-char *
+static char *
 _json_escape(const char *str, char *buf, size_t len)
 {
-        static const unsigned char json_exceptions[UCHAR_MAX + 1] =
-                {
-                        [0x01] = 1, [0x02] = 1, [0x03] = 1, [0x04] = 1,
-                        [0x05] = 1, [0x06] = 1, [0x07] = 1, [0x08] = 1,
-                        [0x09] = 1, [0x0a] = 1, [0x0b] = 1, [0x0c] = 1,
-                        [0x0d] = 1, [0x0e] = 1, [0x0f] = 1, [0x10] = 1,
-                        [0x11] = 1, [0x12] = 1, [0x13] = 1, [0x14] = 1,
-                        [0x15] = 1, [0x16] = 1, [0x17] = 1, [0x18] = 1,
-                        [0x19] = 1, [0x1a] = 1, [0x1b] = 1, [0x1c] = 1,
-                        [0x1d] = 1, [0x1e] = 1, [0x1f] = 1,
-                        ['\\'] = 1, ['"'] = 1
-                };
-        static const char  json_hex_chars[16] = "0123456789abcdef";
-        unsigned char     *p = NULL;
-        size_t             pos = 0;
-
-        if (!str || !buf || len <= 0) {
-                return NULL;
-        }
-
-        for (p = (unsigned char *)str;
-             *p && (pos + 1) < len;
-             p++)
-        {
-                if (json_exceptions[*p] == 0) {
-                        buf[pos++] = *p;
-                        continue;
-                }
-
-                if ((pos + 2) >= len) {
-                        break;
-                }
-
-                switch (*p)
-                {
-                case '\b':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'b';
-                        break;
-                case '\n':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'n';
-                        break;
-                case '\r':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'r';
-                        break;
-                case '\t':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 't';
-                        break;
-                case '\\':
-                        buf[pos++] = '\\';
-                        buf[pos++] = '\\';
-                        break;
-                case '"':
-                        buf[pos++] = '\\';
-                        buf[pos++] = '"';
-                        break;
-                default:
-                        if ((pos + 6) >= len) {
-                                buf[pos] = '\0';
-                                return (char *)p;
-                        }
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'u';
-                        buf[pos++] = '0';
-                        buf[pos++] = '0';
-                        buf[pos++] = json_hex_chars[(*p) >> 4];
-                        buf[pos++] = json_hex_chars[(*p) & 0xf];
-                        break;
+    static const unsigned char json_exceptions[UCHAR_MAX + 1] = {
+        [0x01] = 1, [0x02] = 1, [0x03] = 1, [0x04] = 1, [0x05] = 1, [0x06] = 1,
+        [0x07] = 1, [0x08] = 1, [0x09] = 1, [0x0a] = 1, [0x0b] = 1, [0x0c] = 1,
+        [0x0d] = 1, [0x0e] = 1, [0x0f] = 1, [0x10] = 1, [0x11] = 1, [0x12] = 1,
+        [0x13] = 1, [0x14] = 1, [0x15] = 1, [0x16] = 1, [0x17] = 1, [0x18] = 1,
+        [0x19] = 1, [0x1a] = 1, [0x1b] = 1, [0x1c] = 1, [0x1d] = 1, [0x1e] = 1,
+        [0x1f] = 1, ['\\'] = 1, ['"'] = 1};
+    static const char json_hex_chars[16] = "0123456789abcdef";
+    unsigned char *p = NULL;
+    size_t pos = 0;
+
+    if (!str || !buf || len <= 0) {
+        return NULL;
+    }
+
+    for (p = (unsigned char *)str; *p && (pos + 1) < len; p++) {
+        if (json_exceptions[*p] == 0) {
+            buf[pos++] = *p;
+            continue;
+        }
+
+        if ((pos + 2) >= len) {
+            break;
+        }
+
+        switch (*p) {
+            case '\b':
+                buf[pos++] = '\\';
+                buf[pos++] = 'b';
+                break;
+            case '\n':
+                buf[pos++] = '\\';
+                buf[pos++] = 'n';
+                break;
+            case '\r':
+                buf[pos++] = '\\';
+                buf[pos++] = 'r';
+                break;
+            case '\t':
+                buf[pos++] = '\\';
+                buf[pos++] = 't';
+                break;
+            case '\\':
+                buf[pos++] = '\\';
+                buf[pos++] = '\\';
+                break;
+            case '"':
+                buf[pos++] = '\\';
+                buf[pos++] = '"';
+                break;
+            default:
+                if ((pos + 6) >= len) {
+                    buf[pos] = '\0';
+                    return (char *)p;
                 }
+                buf[pos++] = '\\';
+                buf[pos++] = 'u';
+                buf[pos++] = '0';
+                buf[pos++] = '0';
+                buf[pos++] = json_hex_chars[(*p) >> 4];
+                buf[pos++] = json_hex_chars[(*p) & 0xf];
+                break;
         }
+    }
 
-        buf[pos] = '\0';
-        return (char *)p;
+    buf[pos] = '\0';
+    return (char *)p;
 }
 
-
 /**
  * gf_syslog -function to submit message to syslog specific to gluster
  * @facility_priority: facility_priority of syslog()
@@ -646,154 +552,183 @@ _json_escape(const char *str, char *buf, size_t len)
  *
  * @return: void
  */
-void
-gf_syslog (int facility_priority, char *format, ...)
+static void
+gf_syslog(int facility_priority, char *format, ...)
 {
-        char       *msg = NULL;
-        char        json_msg[GF_JSON_MSG_LENGTH];
-        GF_UNUSED char       *p = NULL;
-        va_list     ap;
-
-        GF_ASSERT (format);
-
-        va_start (ap, format);
-        if (vasprintf (&msg, format, ap) != -1) {
-                p = _json_escape (msg, json_msg, GF_JSON_MSG_LENGTH);
-                syslog (facility_priority, "%s", msg);
-                free (msg);
-        } else
-                syslog (GF_LOG_CRITICAL, "vasprintf() failed, out of memory?");
-        va_end (ap);
+    char *msg = NULL;
+    char json_msg[GF_JSON_MSG_LENGTH];
+    GF_UNUSED char *p = NULL;
+    va_list ap;
+
+    GF_ASSERT(format);
+
+    va_start(ap, format);
+    if (vasprintf(&msg, format, ap) != -1) {
+        p = _json_escape(msg, json_msg, GF_JSON_MSG_LENGTH);
+        syslog(facility_priority, "%s", msg);
+        free(msg);
+    } else
+        syslog(GF_LOG_CRITICAL, "vasprintf() failed, out of memory?");
+    va_end(ap);
 }
 
 void
-gf_log_globals_init (void *data, gf_loglevel_t level)
+gf_log_globals_init(void *data, gf_loglevel_t level)
 {
-        glusterfs_ctx_t *ctx = data;
+    glusterfs_ctx_t *ctx = data;
 
-        pthread_mutex_init (&ctx->log.logfile_mutex, NULL);
+    pthread_mutex_init(&ctx->log.logfile_mutex, NULL);
 
-        ctx->log.loglevel         = level;
-        ctx->log.gf_log_syslog    = 1;
-        ctx->log.sys_log_level    = GF_LOG_CRITICAL;
-        ctx->log.logger           = gf_logger_glusterlog;
-        ctx->log.logformat        = gf_logformat_withmsgid;
-        ctx->log.lru_size         = GF_LOG_LRU_BUFSIZE_DEFAULT;
-        ctx->log.timeout          = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
-        ctx->log.localtime        = GF_LOG_LOCALTIME_DEFAULT;
+    ctx->log.loglevel = level;
+    ctx->log.gf_log_syslog = 1;
+    ctx->log.sys_log_level = GF_LOG_CRITICAL;
+    ctx->log.logger = gf_logger_glusterlog;
+    ctx->log.logformat = gf_logformat_withmsgid;
+    ctx->log.lru_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
+    ctx->log.timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+    ctx->log.localtime = GF_LOG_LOCALTIME_DEFAULT;
 
-        pthread_mutex_init (&ctx->log.log_buf_lock, NULL);
+    pthread_mutex_init(&ctx->log.log_buf_lock, NULL);
 
-        INIT_LIST_HEAD (&ctx->log.lru_queue);
+    INIT_LIST_HEAD(&ctx->log.lru_queue);
 
 #ifdef GF_LINUX_HOST_OS
-        /* For the 'syslog' output. one can grep 'GlusterFS' in syslog
-           for serious logs */
-        openlog ("GlusterFS", LOG_PID, LOG_DAEMON);
+    /* For the 'syslog' output. one can grep 'GlusterFS' in syslog
+       for serious logs */
+    openlog("GlusterFS", LOG_PID, LOG_DAEMON);
 #endif
-
 }
 
 int
-gf_log_init (void *data, const char *file, const char *ident)
+gf_log_init(void *data, const char *file, const char *ident)
 {
-        glusterfs_ctx_t *ctx = NULL;
-        int              fd = -1;
-        struct stat      buf;
-
-        ctx = data;
-
-        if (ctx == NULL) {
-                fprintf (stderr, "ERROR: ctx is NULL\n");
-                return -1;
-        }
-        if (ident) {
-                ctx->log.ident = gf_strdup (ident);
-        }
-
-        /* we keep the files and the syslog open, so that on logger change, we
-         * are ready to log anywhere, that the new value specifies */
-        if (ctx->log.ident) {
-                gf_openlog (ctx->log.ident, -1, LOG_DAEMON);
-        } else {
-                gf_openlog (NULL, -1, LOG_DAEMON);
-        }
-        /* TODO: make FACILITY configurable than LOG_DAEMON */
-        if (sys_stat (GF_LOG_CONTROL_FILE, &buf) == 0) {
-                /* use syslog logging */
-                ctx->log.log_control_file_found = 1;
-        } else {
-                /* use old style logging */
-                ctx->log.log_control_file_found = 0;
-        }
-
-        if (!file) {
-                fprintf (stderr, "ERROR: no filename specified\n");
-                return -1;
+    glusterfs_ctx_t *ctx = data;
+    int fd = -1;
+    struct stat buf;
+
+    if (ctx == NULL) {
+        fprintf(stderr, "ERROR: ctx is NULL\n");
+        return -1;
+    }
+    if (ident) {
+        GF_FREE(ctx->log.ident);
+        ctx->log.ident = gf_strdup(ident);
+    }
+
+    /* we keep the files and the syslog open, so that on logger change, we
+     * are ready to log anywhere, that the new value specifies */
+    if (ctx->log.ident) {
+        gf_openlog(ctx->log.ident, -1, LOG_DAEMON);
+    } else {
+        gf_openlog(NULL, -1, LOG_DAEMON);
+    }
+    /* TODO: make FACILITY configurable than LOG_DAEMON */
+    if (sys_stat(GF_LOG_CONTROL_FILE, &buf) == 0) {
+        /* use syslog logging */
+        ctx->log.log_control_file_found = 1;
+    } else {
+        /* use old style logging */
+        ctx->log.log_control_file_found = 0;
+    }
+
+    if (!file) {
+        fprintf(stderr, "ERROR: no filename specified\n");
+        return -1;
+    }
+
+    /* free the (possible) previous filename */
+    GF_FREE(ctx->log.filename);
+    ctx->log.filename = NULL;
+
+    /* close and reopen logfile for log rotate */
+    if (ctx->log.logfile) {
+        fclose(ctx->log.logfile);
+        ctx->log.logfile = NULL;
+        ctx->log.gf_log_logfile = NULL;
+    }
+
+    if (strcmp(file, "-") == 0) {
+        int dupfd = -1;
+
+        ctx->log.filename = gf_strdup("/dev/stderr");
+        if (!ctx->log.filename) {
+            fprintf(stderr, "ERROR: strdup failed\n");
+            return -1;
         }
 
-        if (strcmp (file, "-") == 0) {
-		int dupfd = -1;
-
-		ctx->log.filename = gf_strdup ("/dev/stderr");
-		if (!ctx->log.filename) {
-			fprintf (stderr, "ERROR: strdup failed\n");
-			return -1;
-		}
-
-		dupfd = dup (fileno (stderr));
-		if (dupfd == -1) {
-			fprintf (stderr, "ERROR: could not dup %d (%s)\n",
-				 fileno (stderr), strerror (errno));
-			return -1;
-		}
-
-		ctx->log.logfile = fdopen (dupfd, "a");
-		if (!ctx->log.logfile) {
-			fprintf (stderr, "ERROR: could not fdopen on %d (%s)\n",
-				 dupfd, strerror (errno));
-			return -1;
-		}
-
-		goto out;
+        dupfd = dup(fileno(stderr));
+        if (dupfd == -1) {
+            fprintf(stderr, "ERROR: could not dup %d (%s)\n", fileno(stderr),
+                    strerror(errno));
+            return -1;
         }
 
-        ctx->log.filename = gf_strdup (file);
+        ctx->log.logfile = fdopen(dupfd, "a");
+        if (!ctx->log.logfile) {
+            fprintf(stderr, "ERROR: could not fdopen on %d (%s)\n", dupfd,
+                    strerror(errno));
+            sys_close(dupfd);
+            return -1;
+        }
+    } else {
+        /* Also create parent dir */
+        char *logdir = gf_strdup(file);
+        if (!logdir) {
+            return -1;
+        }
+        char *tmp_index = rindex(logdir, '/');
+        if (tmp_index) {
+            tmp_index[0] = '\0';
+        }
+        if (mkdir_p(logdir, 0755, true)) {
+            /* EEXIST is handled in mkdir_p() itself */
+            gf_smsg("logging", GF_LOG_ERROR, 0, LG_MSG_STRDUP_ERROR,
+                    "logdir=%s", logdir, "errno=%s", strerror(errno), NULL);
+            GF_FREE(logdir);
+            return -1;
+        }
+        /* no need of this variable */
+        GF_FREE(logdir);
+
+        ctx->log.filename = gf_strdup(file);
         if (!ctx->log.filename) {
-                fprintf (stderr, "ERROR: updating log-filename failed: %s\n",
-                         strerror (errno));
-                return -1;
+            fprintf(stderr,
+                    "ERROR: updating log-filename failed: "
+                    "%s\n",
+                    strerror(errno));
+            return -1;
         }
 
-        fd = open (file, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
+        fd = sys_open(file, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
         if (fd < 0) {
-                fprintf (stderr, "ERROR: failed to create logfile"
-                         " \"%s\" (%s)\n", file, strerror (errno));
-                return -1;
+            fprintf(stderr,
+                    "ERROR: failed to create logfile"
+                    " \"%s\" (%s)\n",
+                    file, strerror(errno));
+            return -1;
         }
-        sys_close (fd);
 
-        ctx->log.logfile = fopen (file, "a");
+        ctx->log.logfile = fdopen(fd, "a");
         if (!ctx->log.logfile) {
-                fprintf (stderr, "ERROR: failed to open logfile \"%s\" (%s)\n",
-                         file, strerror (errno));
-                return -1;
+            fprintf(stderr,
+                    "ERROR: failed to open logfile \"%s\" "
+                    "(%s)\n",
+                    file, strerror(errno));
+            sys_close(fd);
+            return -1;
         }
-out:
-        ctx->log.gf_log_logfile = ctx->log.logfile;
+    }
 
-        return 0;
+    ctx->log.gf_log_logfile = ctx->log.logfile;
+
+    return 0;
 }
 
 void
-set_sys_log_level (gf_loglevel_t level)
+set_sys_log_level(gf_loglevel_t level)
 {
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (ctx)
-                ctx->log.sys_log_level = level;
+    if (THIS->ctx)
+        THIS->ctx->log.sys_log_level = level;
 }
 
 /* Check if we should be logging
@@ -801,1842 +736,1711 @@ set_sys_log_level (gf_loglevel_t level)
  *               _gf_true : Do not Print the log
  */
 static gf_boolean_t
-skip_logging (xlator_t *this, gf_loglevel_t level)
+skip_logging(xlator_t *this, gf_loglevel_t level)
 {
-        gf_boolean_t ret = _gf_false;
-        gf_loglevel_t existing_level = GF_LOG_NONE;
+    gf_loglevel_t existing_level = this->loglevel ? this->loglevel
+                                                  : this->ctx->log.loglevel;
+    if (level > existing_level) {
+        return _gf_true;
+    }
 
-        if (level == GF_LOG_NONE) {
-                ret = _gf_true;
-                goto out;
-        }
+    if (level == GF_LOG_NONE) {
+        return _gf_true;
+    }
 
-        existing_level = this->loglevel ? this->loglevel : this->ctx->log.loglevel;
-        if (level > existing_level) {
-                ret = _gf_true;
-                goto out;
-        }
-out:
-        return ret;
+    return _gf_false;
 }
 
 int
-_gf_log_callingfn (const char *domain, const char *file, const char *function,
-                   int line, gf_loglevel_t level, const char *fmt, ...)
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int line, gf_loglevel_t level, const char *fmt, ...)
 {
-        const char     *basename        = NULL;
-        xlator_t       *this            = NULL;
-        char           *str1            = NULL;
-        char           *str2            = NULL;
-        char           *msg             = NULL;
-        char            timestr[256]    = {0,};
-        char           *callstr         = NULL;
-        struct timeval  tv              = {0,};
-        size_t          len             = 0;
-        int             ret             = 0;
-        va_list         ap;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        static char *level_strings[] = {"",  /* NONE */
-                                        "M", /* EMERGENCY */
-                                        "A", /* ALERT */
-                                        "C", /* CRITICAL */
-                                        "E", /* ERROR */
-                                        "W", /* WARNING */
-                                        "N", /* NOTICE */
-                                        "I", /* INFO */
-                                        "D", /* DEBUG */
-                                        "T", /* TRACE */
-                                        ""};
-
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
+    const char *basename = NULL;
+    xlator_t *this = THIS;
+    char *logline = NULL;
+    char *msg = NULL;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char *callstr = NULL;
+    struct timeval tv = {
+        0,
+    };
+    int ret = 0;
+    va_list ap;
+    glusterfs_ctx_t *ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    basename = strrchr(file, '/');
+    if (basename)
+        basename++;
+    else
+        basename = file;
+
+    /*Saving the backtrace to pre-allocated ctx->btbuf
+     * to avoid allocating memory from the heap*/
+    callstr = gf_backtrace_save(NULL);
+
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret) {
+        goto out;
+    }
+
+    if (ctx->log.log_control_file_found) {
+        int priority;
+        /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
+           other level as is */
+        if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
+            priority = LOG_DEBUG;
+        } else {
+            priority = level - 1;
         }
 
-        basename = strrchr (file, '/');
-        if (basename)
-                basename++;
-        else
-                basename = file;
+        gf_syslog(priority, "[%s:%d:%s] %s %d-%s: %s", basename, line, function,
+                  callstr, ((this->graph) ? this->graph->id : 0), domain, msg);
 
-        /*Saving the backtrace to pre-allocated ctx->btbuf
-         * to avoid allocating memory from the heap*/
-        callstr = gf_backtrace_save (NULL);
+        goto out;
+    }
 
-        if (ctx->log.log_control_file_found)
-        {
-                int priority;
-                /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
-                   other level as is */
-                if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
-                        priority = LOG_DEBUG;
-                } else {
-                        priority = level - 1;
-                }
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
 
-                va_start (ap, fmt);
-                vasprintf (&str2, fmt, ap);
-                va_end (ap);
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
 
-                gf_syslog (priority, "[%s:%d:%s] %s %d-%s: %s",
-                           basename, line, function,
-                           callstr,
-                           ((this->graph) ? this->graph->id:0), domain,
-                           str2);
+    ret = gf_asprintf(&logline, "[%s] %c [%s:%d:%s] %s %d-%s: %s\n", timestr,
+                      gf_level_strings[level], basename, line, function,
+                      callstr, ((this->graph) ? this->graph->id : 0), domain,
+                      msg);
+    if (-1 == ret) {
+        goto out;
+    }
 
-                goto out;
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fputs(logline, ctx->log.logfile);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fputs(logline, stderr);
+            fflush(stderr);
         }
 
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %s %d-%s: ",
-                           timestr, level_strings[level],
-                           basename, line, function, callstr,
-                           ((this->graph) ? this->graph->id:0), domain);
-        if (-1 == ret) {
-                goto out;
-        }
-
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
-
-        va_end (ap);
-
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto out;
-        }
-
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious log in 'syslog', not our debug
-                   and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                    (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious log in 'syslog', not our debug
+           and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s", logline);
 #endif
-        }
+    }
 
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 out:
-        GF_FREE (msg);
-
-        GF_FREE (str1);
 
-        FREE (str2);
+    GF_FREE(logline);
 
-        va_end (ap);
+    FREE(msg);
 
-        return ret;
+    return ret;
 }
 
-int
-_gf_msg_plain_internal (gf_loglevel_t level, const char *msg)
+static int
+_gf_msg_plain_internal(gf_loglevel_t level, const char *msg)
 {
-        xlator_t        *this           = NULL;
-        glusterfs_ctx_t *ctx            = NULL;
-        int              priority;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int priority;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        /* log to the configured logging service */
-        switch (ctx->log.logger) {
+    /* log to the configured logging service */
+    switch (ctx->log.logger) {
         case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        SET_LOG_PRIO (level, priority);
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                SET_LOG_PRIO(level, priority);
 
-                        syslog (priority, "%s", msg);
-                        break;
-                }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
+                syslog(priority, "%s", msg);
+                break;
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
         case gf_logger_glusterlog:
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile) {
-                                fprintf (ctx->log.logfile, "%s\n", msg);
-                                fflush (ctx->log.logfile);
-                        } else {
-                                fprintf (stderr, "%s\n", msg);
-                                fflush (stderr);
-                        }
+            pthread_mutex_lock(&ctx->log.logfile_mutex);
+            {
+                if (ctx->log.logfile) {
+                    fprintf(ctx->log.logfile, "%s\n", msg);
+                    fflush(ctx->log.logfile);
+                } else {
+                    fprintf(stderr, "%s\n", msg);
+                    fflush(stderr);
+                }
 
 #ifdef GF_LINUX_HOST_OS
-                        /* We want only serious logs in 'syslog', not our debug
-                                * and trace logs */
-                        if (ctx->log.gf_log_syslog && level &&
-                                (level <= ctx->log.sys_log_level))
-                                syslog ((level-1), "%s\n", msg);
+                /* We want only serious logs in 'syslog', not our debug
+                 * and trace logs */
+                if (ctx->log.gf_log_syslog && level &&
+                    (level <= ctx->log.sys_log_level))
+                    syslog((level - 1), "%s\n", msg);
 #endif
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+            }
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-                break;
-        }
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-_gf_msg_plain (gf_loglevel_t level, const char *fmt, ...)
+_gf_msg_plain(gf_loglevel_t level, const char *fmt, ...)
 {
-        xlator_t        *this            = NULL;
-        int              ret             = 0;
-        va_list          ap;
-        char            *msg             = NULL;
-        glusterfs_ctx_t *ctx = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    va_list ap;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        va_start (ap, fmt);
-        ret = vasprintf (&msg, fmt, ap);
-        va_end (ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
-        FREE (msg);
+    FREE(msg);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg_vplain (gf_loglevel_t level, const char *fmt, va_list ap)
+_gf_msg_vplain(gf_loglevel_t level, const char *fmt, va_list ap)
 {
-        xlator_t        *this            = NULL;
-        int              ret             = 0;
-        char            *msg             = NULL;
-        glusterfs_ctx_t *ctx             = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        ret = vasprintf (&msg, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    ret = vasprintf(&msg, fmt, ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
-        FREE (msg);
+    FREE(msg);
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg_plain_nomem (gf_loglevel_t level, const char *msg)
+_gf_msg_plain_nomem(gf_loglevel_t level, const char *msg)
 {
-        xlator_t        *this           = NULL;
-        int              ret            = 0;
-        glusterfs_ctx_t *ctx            = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-_gf_msg_backtrace_nomem (gf_loglevel_t level, int stacksize)
+_gf_msg_backtrace_nomem(gf_loglevel_t level, int stacksize)
 {
-        xlator_t        *this            = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-        void            *array[200];
-        size_t           bt_size = 0;
-        int              fd = -1;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        /* syslog does not have fd support, hence no no-mem variant */
-        if (ctx->log.logger != gf_logger_glusterlog)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        bt_size = backtrace (array, ((stacksize <= 200)? stacksize : 200));
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                fd = ctx->log.logfile?
-                        fileno (ctx->log.logfile) :
-                        fileno (stderr);
-                if (bt_size && (fd != -1)) {
-                        /* print to the file fd, to prevent any
-                           allocations from backtrace_symbols
-                         */
-                        backtrace_symbols_fd (&array[0], bt_size, fd);
-                }
-        }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    void *array[200];
+    size_t bt_size = 0;
+    int fd = -1;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    /* syslog does not have fd support, hence no no-mem variant */
+    if (ctx->log.logger != gf_logger_glusterlog)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    bt_size = backtrace(array, ((stacksize <= 200) ? stacksize : 200));
+    if (!bt_size)
+        goto out;
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        fd = ctx->log.logfile ? fileno(ctx->log.logfile) : fileno(stderr);
+        if (fd != -1) {
+            /* print to the file fd, to prevent any
+               allocations from backtrace_symbols
+             */
+            backtrace_symbols_fd(&array[0], bt_size, fd);
+        }
+    }
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 out:
-        return;
+    return;
 }
 
 int
-_gf_msg_backtrace (int stacksize, char *callstr, size_t strsize)
+_gf_msg_backtrace(int stacksize, char *callstr, size_t strsize)
 {
-        int       ret = -1;
-        int       i = 0;
-        int       size = 0;
-        int       savstrsize = strsize;
-        void     *array[200];
-        char    **callingfn = NULL;
-
-        /* We chop off last 2 anyway, so if request is less than tolerance
-         * nothing to do */
-        if (stacksize < 3)
-                goto out;
-
-        size = backtrace (array, ((stacksize <= 200)? stacksize : 200));
-        if ((size - 3) < 0)
-                goto out;
-        if (size)
-                callingfn = backtrace_symbols (&array[2], size - 2);
-        if (!callingfn)
-                goto out;
-
-        ret = snprintf (callstr, strsize, "(");
-        PRINT_SIZE_CHECK (ret, out, strsize);
-
-        for ((i = size - 3); i >= 0; i--) {
-                ret = snprintf (callstr + savstrsize - strsize, strsize,
-                                "-->%s ", callingfn[i]);
-                PRINT_SIZE_CHECK (ret, out, strsize);
-        }
-
-        ret = snprintf (callstr + savstrsize - strsize, strsize, ")");
-        PRINT_SIZE_CHECK (ret, out, strsize);
+    int ret = -1;
+    int i = 0;
+    int size = 0;
+    int savstrsize = strsize;
+    void *array[200];
+    char **callingfn = NULL;
+
+    /* We chop off last 2 anyway, so if request is less than tolerance
+     * nothing to do */
+    if (stacksize < 3)
+        goto out;
+
+    size = backtrace(array, ((stacksize <= 200) ? stacksize : 200));
+    if ((size - 3) < 0)
+        goto out;
+    if (size)
+        callingfn = backtrace_symbols(&array[2], size - 2);
+    if (!callingfn)
+        goto out;
+
+    ret = snprintf(callstr, strsize, "(");
+    PRINT_SIZE_CHECK(ret, out, strsize);
+
+    for ((i = size - 3); i >= 0; i--) {
+        ret = snprintf(callstr + savstrsize - strsize, strsize, "-->%s ",
+                       callingfn[i]);
+        PRINT_SIZE_CHECK(ret, out, strsize);
+    }
+
+    ret = snprintf(callstr + savstrsize - strsize, strsize, ")");
+    PRINT_SIZE_CHECK(ret, out, strsize);
 out:
-        FREE (callingfn);
-        return ret;
+    FREE(callingfn);
+    return ret;
 }
 
 int
-_gf_msg_nomem (const char *domain, const char *file,
-               const char *function, int line, gf_loglevel_t level,
-               size_t size)
+_gf_msg_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
-        const char      *basename        = NULL;
-        xlator_t        *this            = NULL;
-        struct timeval   tv              = {0,};
-        int              ret             = 0;
-        int              fd              = -1;
-        char             msg[2048]       = {0,};
-        char             timestr[GF_LOG_TIMESTR_SIZE]    = {0,};
-        glusterfs_ctx_t *ctx = NULL;
-        int              wlen = 0;
-        int              priority;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        if (!domain || !file || !function) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
-        }
-
-        GET_FILE_NAME_TO_LOG (file, basename);
-
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        ret = snprintf (timestr + strlen (timestr),
-                        sizeof timestr - strlen (timestr),
-                        ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        if (-1 == ret) {
-                goto out;
-        }
+    const char *basename = NULL;
+    xlator_t *this = NULL;
+    struct timeval tv = {
+        0,
+    };
+    int ret = 0;
+    int fd = -1;
+    char msg[2048] = {
+        0,
+    };
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    int wlen = 0;
+    int priority;
+    struct rusage r_usage;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    if (!domain || !file || !function) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    GET_FILE_NAME_TO_LOG(file, basename);
+
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+
+    /* TODO: Currently we print in the enhanced format, with a message ID
+     * of 0. Need to enhance this to support format as configured */
+    wlen = snprintf(
+        msg, sizeof msg,
+        "[%s] %c [MSGID: %" PRIu64
+        "]"
+        " [%s:%d:%s] %s: no memory "
+        "available for size (%" GF_PRI_SIZET
+        ") current memory usage in kilobytes %ld"
+        " [call stack follows]\n",
+        timestr, gf_level_strings[level], (uint64_t)0, basename, line, function,
+        domain, size,
+        (!getrusage(RUSAGE_SELF, &r_usage) ? r_usage.ru_maxrss : 0));
+    if (-1 == wlen) {
+        ret = -1;
+        goto out;
+    }
+
+    /* log to the configured logging service */
+    switch (ctx->log.logger) {
+        case gf_logger_syslog:
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                SET_LOG_PRIO(level, priority);
 
-        /* TODO: Currently we print in the enhanced format, with a message ID
-         * of 0. Need to enhance this to support format as configured */
-        ret = snprintf (msg, sizeof msg, "[%s] %s [MSGID: %"PRIu64"]"
-                        " [%s:%d:%s] %s: no memory "
-                        "available for size (%"GF_PRI_SIZET")"
-                        " [call stack follows]\n",
-                        timestr, gf_level_strings[level], (uint64_t) 0,
-                        basename, line, function, domain, size);
-        if (-1 == ret) {
-                goto out;
-        }
+                /* if syslog allocates, then this may fail, but we
+                 * cannot do much about it at the moment */
+                /* There is no fd for syslog, hence no stack printed */
+                syslog(priority, "%s", msg);
+                break;
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
+        case gf_logger_glusterlog:
+            pthread_mutex_lock(&ctx->log.logfile_mutex);
+            {
+                fd = ctx->log.logfile ? fileno(ctx->log.logfile)
+                                      : fileno(stderr);
+                if (fd == -1) {
+                    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+                    goto out;
+                }
 
-        /* log to the configured logging service */
-        switch (ctx->log.logger) {
-        case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        SET_LOG_PRIO (level, priority);
-
-                        /* if syslog allocates, then this may fail, but we
-                         * cannot do much about it at the moment */
-                        /* There is no fd for syslog, hence no stack printed */
-                        syslog (priority, "%s", msg);
-                        break;
+                /* write directly to the fd to prevent out of order
+                 * message and stack */
+                ret = sys_write(fd, msg, wlen);
+                if (ret == -1) {
+                    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+                    goto out;
                 }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
-        case gf_logger_glusterlog:
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        fd = ctx->log.logfile? fileno (ctx->log.logfile) :
-                                fileno (stderr);
-                        if (fd == -1) {
-                                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                                goto out;
-                        }
-
-                        wlen = strlen (msg);
-
-                        /* write directly to the fd to prevent out of order
-                         * message and stack */
-                        ret = sys_write (fd, msg, wlen);
-                        if (ret == -1) {
-                                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                                goto out;
-                        }
 #ifdef GF_LINUX_HOST_OS
-                        /* We want only serious log in 'syslog', not our debug
-                         * and trace logs */
-                        if (ctx->log.gf_log_syslog && level &&
-                                (level <= ctx->log.sys_log_level))
-                                syslog ((level-1), "%s\n", msg);
+                /* We want only serious log in 'syslog', not our debug
+                 * and trace logs */
+                if (ctx->log.gf_log_syslog && level &&
+                    (level <= ctx->log.sys_log_level))
+                    syslog((level - 1), "%s\n", msg);
 #endif
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+            }
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-                _gf_msg_backtrace_nomem (level, GF_LOG_BACKTRACE_DEPTH);
+            _gf_msg_backtrace_nomem(level, GF_LOG_BACKTRACE_DEPTH);
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_log_syslog (glusterfs_ctx_t *ctx, const char *domain, const char *file,
-               const char *function, int32_t line, gf_loglevel_t level,
-               int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
-               int graph_id, gf_log_format_t fmt)
+gf_log_syslog(glusterfs_ctx_t *ctx, const char *domain, const char *file,
+              const char *function, int32_t line, gf_loglevel_t level,
+              int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
+              int graph_id, gf_log_format_t fmt)
 {
-        int              priority;
-
-        SET_LOG_PRIO (level, priority);
-
-        /* log with appropriate format */
-        switch (fmt) {
-                case gf_logformat_traditional:
-                if (!callstr) {
-                        if (errnum)
-                                syslog (priority, "[%s:%d:%s] %d-%s: %s [%s]",
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr);
-                } else {
-                        if (errnum)
-                                syslog (priority, "[%s:%d:%s] %s %d-%s:"
-                                        " %s [%s]",
-                                        file, line, function, callstr, graph_id,
-                                        domain, *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[%s:%d:%s] %s %d-%s: %s",
-                                        file, line, function, callstr, graph_id,
-                                        domain, *appmsgstr);
-                }
-                break;
-                case gf_logformat_withmsgid:
-                if (!callstr) {
-                        if (errnum)
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %d-%s: %s [%s]", msgid,
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %d-%s: %s",
-                                        msgid, file, line, function, graph_id,
-                                        domain, *appmsgstr);
-                } else {
-                        if (errnum)
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %s %d-%s: %s [%s]",
-                                        msgid, file, line, function, callstr,
-                                        graph_id, domain, *appmsgstr,
-                                        strerror(errnum));
-                        else
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %s %d-%s: %s",
-                                        msgid, file, line, function, callstr,
-                                        graph_id, domain, *appmsgstr);
-                }
-                break;
-                case gf_logformat_cee:
-                /* TODO: Enhance CEE with additional parameters */
-                gf_syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                           file, line, function, graph_id, domain, *appmsgstr);
-                break;
-
-                default:
-                /* NOTE: should not get here without logging */
-                break;
-        }
-
-        /* TODO: There can be no errors from gf_syslog? */
-        return 0;
+    int priority;
+
+    SET_LOG_PRIO(level, priority);
+
+    /* log with appropriate format */
+    switch (fmt) {
+        case gf_logformat_traditional:
+            if (!callstr) {
+                if (errnum)
+                    syslog(priority, "[%s:%d:%s] %d-%s: %s [%s]", file, line,
+                           function, graph_id, domain, *appmsgstr,
+                           strerror(errnum));
+                else
+                    syslog(priority, "[%s:%d:%s] %d-%s: %s", file, line,
+                           function, graph_id, domain, *appmsgstr);
+            } else {
+                if (errnum)
+                    syslog(priority,
+                           "[%s:%d:%s] %s %d-%s:"
+                           " %s [%s]",
+                           file, line, function, callstr, graph_id, domain,
+                           *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority, "[%s:%d:%s] %s %d-%s: %s", file, line,
+                           function, callstr, graph_id, domain, *appmsgstr);
+            }
+            break;
+        case gf_logformat_withmsgid:
+            if (!callstr) {
+                if (errnum)
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %d-%s: %s [%s]",
+                           msgid, file, line, function, graph_id, domain,
+                           *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %d-%s: %s",
+                           msgid, file, line, function, graph_id, domain,
+                           *appmsgstr);
+            } else {
+                if (errnum)
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %s %d-%s: %s [%s]",
+                           msgid, file, line, function, callstr, graph_id,
+                           domain, *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %s %d-%s: %s",
+                           msgid, file, line, function, callstr, graph_id,
+                           domain, *appmsgstr);
+            }
+            break;
+        case gf_logformat_cee:
+            /* TODO: Enhance CEE with additional parameters */
+            gf_syslog(priority, "[%s:%d:%s] %d-%s: %s", file, line, function,
+                      graph_id, domain, *appmsgstr);
+            break;
+
+        default:
+            /* NOTE: should not get here without logging */
+            break;
+    }
+
+    /* TODO: There can be no errors from gf_syslog? */
+    return 0;
 }
 
 static int
-gf_log_glusterlog (glusterfs_ctx_t *ctx, const char *domain, const char *file,
-                   const char *function, int32_t line, gf_loglevel_t level,
-                   int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
-                   struct timeval tv, int graph_id, gf_log_format_t fmt)
+gf_log_glusterlog(glusterfs_ctx_t *ctx, const char *domain, const char *file,
+                  const char *function, int32_t line, gf_loglevel_t level,
+                  int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
+                  struct timeval tv, int graph_id, gf_log_format_t fmt)
 {
-        char             timestr[GF_LOG_TIMESTR_SIZE] = {0,};
-        char            *header = NULL;
-        char            *footer = NULL;
-        char            *msg  = NULL;
-        size_t           hlen  = 0, flen = 0, mlen = 0;
-        int              ret  = 0;
-
-        /* rotate if required */
-        gf_log_rotate(ctx);
-
-        /* format the time stamp */
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        /* generate header and footer */
-        if (fmt == gf_logformat_traditional) {
-                if (!callstr) {
-                        ret = gf_asprintf (&header, "[%s] %s [%s:%d:%s]"
-                                                    " %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           file, line, function, graph_id,
-                                           domain);
-                } else {
-                        ret = gf_asprintf (&header, "[%s] %s [%s:%d:%s] %s"
-                                                    " %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           file, line, function, callstr,
-                                           graph_id, domain);
-                }
-                if (-1 == ret) {
-                        goto err;
-                }
-        } else { /* gf_logformat_withmsgid */
-                /* CEE log format unsupported in logger_glusterlog, so just
-                 * print enhanced log format */
-                if (!callstr) {
-                        ret = gf_asprintf (&header, "[%s] %s [MSGID: %"PRIu64"]"
-                                                    " [%s:%d:%s] %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           msgid, file, line, function,
-                                           graph_id, domain);
-                } else {
-                        ret = gf_asprintf (&header, "[%s] %s [MSGID: %"PRIu64"]"
-                                                    " [%s:%d:%s] %s %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           msgid, file, line, function, callstr,
-                                           graph_id, domain);
-                }
-                if (-1 == ret) {
-                        goto err;
-                }
-        }
-
-        if (errnum) {
-                ret = gf_asprintf (&footer, " [%s]",strerror(errnum));
-                if (-1 == ret) {
-                        goto err;
-                }
-        }
-
-        /* generate the full message to log */
-        hlen = strlen (header);
-        flen = footer? strlen (footer) : 0;
-        mlen = strlen (*appmsgstr);
-        msg = GF_MALLOC (hlen + flen + mlen + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto err;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char *header = NULL;
+    char *footer = NULL;
+    int ret = 0;
+
+    /* rotate if required */
+    gf_log_rotate(ctx);
+
+    /* format the time stamp */
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+
+    /* generate footer */
+    if (errnum) {
+        ret = gf_asprintf(&footer, " [%s]\n", strerror(errnum));
+    } else {
+        ret = gf_asprintf(&footer, " \n");
+    }
+    if (-1 == ret) {
+        goto err;
+    }
+
+    /* generate message, inc. the header */
+    if (fmt == gf_logformat_traditional) {
+        if (!callstr) {
+            ret = gf_asprintf(&header,
+                              "[%s] %c [%s:%d:%s]"
+                              " %d-%s: %s",
+                              timestr, gf_level_strings[level], file, line,
+                              function, graph_id, domain, *appmsgstr);
+        } else {
+            ret = gf_asprintf(&header,
+                              "[%s] %c [%s:%d:%s] %s"
+                              " %d-%s: %s",
+                              timestr, gf_level_strings[level], file, line,
+                              function, callstr, graph_id, domain, *appmsgstr);
+        }
+    } else { /* gf_logformat_withmsgid */
+        /* CEE log format unsupported in logger_glusterlog, so just
+         * print enhanced log format */
+        if (!callstr) {
+            ret = gf_asprintf(&header,
+                              "[%s] %c [MSGID: %" PRIu64
+                              "]"
+                              " [%s:%d:%s] %d-%s: %s",
+                              timestr, gf_level_strings[level], msgid, file,
+                              line, function, graph_id, domain, *appmsgstr);
+        } else {
+            ret = gf_asprintf(&header,
+                              "[%s] %c [MSGID: %" PRIu64
+                              "]"
+                              " [%s:%d:%s] %s %d-%s: %s",
+                              timestr, gf_level_strings[level], msgid, file,
+                              line, function, callstr, graph_id, domain,
+                              *appmsgstr);
+        }
+    }
+    if (-1 == ret) {
+        goto err;
+    }
+
+    /* send the full message to log */
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s%s", header, footer);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s%s", header, footer);
+            fflush(stderr);
         }
 
-        strcpy (msg, header);
-        strcpy (msg + hlen, *appmsgstr);
-        if (footer)
-                strcpy (msg + hlen + mlen, footer);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious logs in 'syslog', not our debug
-                 * and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                        (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
-#endif
+        /* We want only serious logs in 'syslog', not our debug
+         * and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level)) {
+            syslog((level - 1), "%s%s", header, footer);
         }
+#endif
+    }
 
-        /* TODO: Plugin in memory log buffer retention here. For logs not
-         * flushed during cores, it would be useful to retain some of the last
-         * few messages in memory */
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        ret = 0;
+    /* TODO: Plugin in memory log buffer retention here. For logs not
+     * flushed during cores, it would be useful to retain some of the last
+     * few messages in memory */
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    ret = 0;
 
 err:
-        GF_FREE (msg);
-        GF_FREE (header);
-        GF_FREE (footer);
+    GF_FREE(header);
+    GF_FREE(footer);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_syslog_log_repetitions (const char *domain, const char *file,
-                           const char *function, int32_t line,
-                           gf_loglevel_t level, int errnum, uint64_t msgid,
-                           char **appmsgstr, char *callstr, int refcount,
-                           struct timeval oldest, struct timeval latest,
-                           int graph_id)
+gf_syslog_log_repetitions(const char *domain, const char *file,
+                          const char *function, int32_t line,
+                          gf_loglevel_t level, int errnum, uint64_t msgid,
+                          char **appmsgstr, char *callstr, int refcount,
+                          struct timeval oldest, struct timeval latest,
+                          int graph_id)
 {
-        int              priority;
-        char             timestr_latest[256] = {0,};
-        char             timestr_oldest[256] = {0,};
-
-        SET_LOG_PRIO (level, priority);
-
-        gf_time_fmt (timestr_latest, sizeof timestr_latest, latest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_latest + strlen (timestr_latest),
-                  sizeof (timestr_latest) - strlen (timestr_latest),
-                  ".%"GF_PRI_SUSECONDS, latest.tv_usec);
-
-        gf_time_fmt (timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_oldest + strlen (timestr_oldest),
-                  sizeof (timestr_oldest) - strlen (timestr_oldest),
-                  ".%"GF_PRI_SUSECONDS, oldest.tv_usec);
-
-        if (errnum) {
-                syslog (priority, "The message \"[MSGID: %"PRIu64"] [%s:%d:%s] "
-                        "%d-%s: %s [%s] \" repeated %d times between %s and %s",
-                        msgid, file, line, function, graph_id, domain,
-                        *appmsgstr, strerror(errnum), refcount, timestr_oldest,
-                        timestr_latest);
-        } else {
-                syslog (priority, "The message \"[MSGID: %"PRIu64"] [%s:%d:%s] "
-                        "%d-%s: %s \" repeated %d times between %s and %s",
-                        msgid, file, line, function, graph_id, domain,
-                        *appmsgstr, refcount, timestr_oldest, timestr_latest);
-        }
-        return 0;
+    int priority;
+    char timestr_latest[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char timestr_oldest[GF_TIMESTR_SIZE] = {
+        0,
+    };
+
+    SET_LOG_PRIO(level, priority);
+
+    gf_time_fmt_tv(timestr_latest, sizeof timestr_latest, &latest,
+                   gf_timefmt_FT);
+    gf_time_fmt_tv(timestr_oldest, sizeof timestr_oldest, &oldest,
+                   gf_timefmt_FT);
+
+    if (errnum) {
+        syslog(priority,
+               "The message \"[MSGID: %" PRIu64
+               "] [%s:%d:%s] "
+               "%d-%s: %s [%s] \" repeated %d times between %s"
+               " and %s",
+               msgid, file, line, function, graph_id, domain, *appmsgstr,
+               strerror(errnum), refcount, timestr_oldest, timestr_latest);
+    } else {
+        syslog(priority,
+               "The message \"[MSGID: %" PRIu64
+               "] [%s:%d:%s] "
+               "%d-%s: %s \" repeated %d times between %s"
+               " and %s",
+               msgid, file, line, function, graph_id, domain, *appmsgstr,
+               refcount, timestr_oldest, timestr_latest);
+    }
+    return 0;
 }
 
 static int
-gf_glusterlog_log_repetitions (glusterfs_ctx_t *ctx, const char *domain,
-                               const char *file, const char *function,
-                               int32_t line, gf_loglevel_t level, int errnum,
-                               uint64_t msgid, char **appmsgstr, char *callstr,
-                               int refcount, struct timeval oldest,
-                               struct timeval latest, int graph_id)
+gf_glusterlog_log_repetitions(glusterfs_ctx_t *ctx, const char *domain,
+                              const char *file, const char *function,
+                              int32_t line, gf_loglevel_t level, int errnum,
+                              uint64_t msgid, char **appmsgstr, char *callstr,
+                              int refcount, struct timeval oldest,
+                              struct timeval latest, int graph_id)
 {
-        int              ret                 = 0;
-        size_t           hlen                = 0;
-        size_t           flen                = 0;
-        size_t           mlen                = 0;
-        char             timestr_latest[256] = {0,};
-        char             timestr_oldest[256] = {0,};
-        char             errstr[256]         = {0,};
-        char            *header              = NULL;
-        char            *footer              = NULL;
-        char            *msg                 = NULL;
-
-        if (!ctx)
-                goto err;
-
-        gf_log_rotate (ctx);
-
-        gf_time_fmt (timestr_latest, sizeof timestr_latest, latest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_latest + strlen (timestr_latest),
-                  sizeof (timestr_latest) - strlen (timestr_latest),
-                  ".%"GF_PRI_SUSECONDS, latest.tv_usec);
-
-        gf_time_fmt (timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_oldest + strlen (timestr_oldest),
-                  sizeof (timestr_oldest) - strlen (timestr_oldest),
-                  ".%"GF_PRI_SUSECONDS, oldest.tv_usec);
-
-        ret = gf_asprintf (&header, "The message \"%s [MSGID: %"PRIu64"]"
-                           " [%s:%d:%s] %d-%s: ", gf_level_strings[level],
-                           msgid, file, line, function, graph_id, domain);
-        if (-1 == ret)
-                goto err;
-
-        if (errnum)
-                snprintf (errstr, sizeof (errstr) - 1, " [%s]",
-                          strerror (errnum));
-
-        ret = gf_asprintf (&footer, "%s\" repeated %d times between"
-                           " [%s] and [%s]", errstr, refcount, timestr_oldest,
-                           timestr_latest);
-        if (-1 == ret)
-                goto err;
-
-        /* generate the full message to log */
-        hlen = strlen (header);
-        flen = strlen (footer);
-        mlen = strlen (*appmsgstr);
-        msg = GF_MALLOC (hlen + flen + mlen + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto err;
+    int ret = 0;
+    char timestr_latest[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char timestr_oldest[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char errstr[256] = {
+        0,
+    };
+    char *header = NULL;
+    char *footer = NULL;
+
+    if (!ctx)
+        goto err;
+
+    gf_log_rotate(ctx);
+
+    ret = gf_asprintf(&header,
+                      "The message \"%c [MSGID: %" PRIu64
+                      "]"
+                      " [%s:%d:%s] %d-%s: %s",
+                      gf_level_strings[level], msgid, file, line, function,
+                      graph_id, domain, *appmsgstr);
+    if (-1 == ret) {
+        goto err;
+    }
+
+    gf_time_fmt_tv(timestr_latest, sizeof timestr_latest, &latest,
+                   gf_timefmt_FT);
+
+    gf_time_fmt_tv(timestr_oldest, sizeof timestr_oldest, &oldest,
+                   gf_timefmt_FT);
+
+    if (errnum)
+        snprintf(errstr, sizeof(errstr) - 1, " [%s]", strerror(errnum));
+
+    ret = gf_asprintf(&footer, "%s\" repeated %d times between [%s] and [%s]",
+                      errstr, refcount, timestr_oldest, timestr_latest);
+    if (-1 == ret) {
+        ret = -1;
+        goto err;
+    }
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s%s\n", header, footer);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s%s\n", header, footer);
+            fflush(stderr);
         }
 
-        strcpy (msg, header);
-        strcpy (msg + hlen, *appmsgstr);
-        strcpy (msg + hlen + mlen, footer);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious logs in 'syslog', not our debug
-                 * and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                        (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious logs in 'syslog', not our debug
+         * and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s%s\n", header, footer);
 #endif
-        }
+    }
 
-        /* TODO: Plugin in memory log buffer retention here. For logs not
-         * flushed during cores, it would be useful to retain some of the last
-         * few messages in memory */
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        ret = 0;
+    /* TODO: Plugin in memory log buffer retention here. For logs not
+     * flushed during cores, it would be useful to retain some of the last
+     * few messages in memory */
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    ret = 0;
 
 err:
-        GF_FREE (msg);
-        GF_FREE (header);
-        GF_FREE (footer);
+    GF_FREE(header);
+    GF_FREE(footer);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_log_print_with_repetitions (glusterfs_ctx_t *ctx, const char *domain,
-                               const char *file, const char *function,
-                               int32_t line, gf_loglevel_t level, int errnum,
-                               uint64_t msgid, char **appmsgstr, char *callstr,
-                               int refcount, struct timeval oldest,
-                               struct timeval latest, int graph_id)
+gf_log_print_with_repetitions(glusterfs_ctx_t *ctx, const char *domain,
+                              const char *file, const char *function,
+                              int32_t line, gf_loglevel_t level, int errnum,
+                              uint64_t msgid, char **appmsgstr, char *callstr,
+                              int refcount, struct timeval oldest,
+                              struct timeval latest, int graph_id)
 {
-        int               ret    = -1;
-        gf_log_logger_t   logger = 0;
-
-        logger = ctx->log.logger;
-
-
-        switch (logger) {
-                case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        ret = gf_syslog_log_repetitions (domain, file, function,
-                                                         line, level, errnum,
-                                                         msgid, appmsgstr,
-                                                         callstr, refcount,
-                                                         oldest, latest,
-                                                         graph_id);
-                        break;
-                }
-                case gf_logger_glusterlog:
-                ret = gf_glusterlog_log_repetitions (ctx, domain, file,
-                                                     function, line, level,
-                                                     errnum, msgid, appmsgstr,
-                                                     callstr, refcount, oldest,
-                                                     latest, graph_id);
+    int ret = -1;
+    gf_log_logger_t logger = ctx->log.logger;
+
+    switch (logger) {
+        case gf_logger_syslog:
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                ret = gf_syslog_log_repetitions(
+                    domain, file, function, line, level, errnum, msgid,
+                    appmsgstr, callstr, refcount, oldest, latest, graph_id);
                 break;
-        }
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
 
-        return ret;
+        case gf_logger_glusterlog:
+            ret = gf_glusterlog_log_repetitions(
+                ctx, domain, file, function, line, level, errnum, msgid,
+                appmsgstr, callstr, refcount, oldest, latest, graph_id);
+            break;
+    }
+
+    return ret;
 }
 
 static int
-gf_log_print_plain_fmt (glusterfs_ctx_t *ctx, const char *domain,
-                        const char *file, const char *function, int32_t line,
-                        gf_loglevel_t level, int errnum, uint64_t msgid,
-                        char **appmsgstr, char *callstr, struct timeval tv,
-                        int graph_id, gf_log_format_t fmt)
+gf_log_print_plain_fmt(glusterfs_ctx_t *ctx, const char *domain,
+                       const char *file, const char *function, int32_t line,
+                       gf_loglevel_t level, int errnum, uint64_t msgid,
+                       char **appmsgstr, char *callstr, struct timeval tv,
+                       int graph_id, gf_log_format_t fmt)
 {
-        int               ret    = -1;
-        gf_log_logger_t   logger = 0;
+    int ret = -1;
+    gf_log_logger_t logger = 0;
 
-        logger = ctx->log.logger;
+    logger = ctx->log.logger;
 
-        /* log to the configured logging service */
-        switch (logger) {
+    /* log to the configured logging service */
+    switch (logger) {
         case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        ret = gf_log_syslog (ctx, domain, file, function, line,
-                                             level, errnum, msgid, appmsgstr,
-                                             callstr, graph_id, fmt);
-                        break;
-                }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
-        case gf_logger_glusterlog:
-                ret = gf_log_glusterlog (ctx, domain, file, function, line,
-                                         level, errnum, msgid, appmsgstr,
-                                         callstr, tv, graph_id, fmt);
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                ret = gf_log_syslog(ctx, domain, file, function, line, level,
+                                    errnum, msgid, appmsgstr, callstr, graph_id,
+                                    fmt);
                 break;
-        }
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
+        case gf_logger_glusterlog:
+            ret = gf_log_glusterlog(ctx, domain, file, function, line, level,
+                                    errnum, msgid, appmsgstr, callstr, tv,
+                                    graph_id, fmt);
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-gf_log_flush_message (log_buf_t *buf, glusterfs_ctx_t *ctx)
+gf_log_flush_message(log_buf_t *buf, glusterfs_ctx_t *ctx)
 {
-        if (buf->refcount == 1) {
-                (void) gf_log_print_plain_fmt (ctx, buf->domain, buf->file,
-                                               buf->function, buf->line,
-                                               buf->level, buf->errnum,
-                                               buf->msg_id, &buf->msg, NULL,
-                                               buf->latest, buf->graph_id,
-                                               gf_logformat_withmsgid);
-        }
-
-        if (buf->refcount > 1) {
-                gf_log_print_with_repetitions (ctx, buf->domain, buf->file,
-                                               buf->function, buf->line,
-                                               buf->level, buf->errnum,
-                                               buf->msg_id, &buf->msg, NULL,
-                                               buf->refcount, buf->oldest,
-                                               buf->latest, buf->graph_id);
-        }
-        return;
+    if (buf->refcount == 1) {
+        (void)gf_log_print_plain_fmt(ctx, buf->domain, buf->file, buf->function,
+                                     buf->line, buf->level, buf->errnum,
+                                     buf->msg_id, &buf->msg, NULL, buf->latest,
+                                     buf->graph_id, gf_logformat_withmsgid);
+    }
+
+    if (buf->refcount > 1) {
+        gf_log_print_with_repetitions(
+            ctx, buf->domain, buf->file, buf->function, buf->line, buf->level,
+            buf->errnum, buf->msg_id, &buf->msg, NULL, buf->refcount,
+            buf->oldest, buf->latest, buf->graph_id);
+    }
+    return;
 }
 
 static void
-gf_log_flush_list (struct list_head *copy, glusterfs_ctx_t *ctx)
+gf_log_flush_list(struct list_head *copy, glusterfs_ctx_t *ctx)
 {
-        log_buf_t        *iter = NULL;
-        log_buf_t        *tmp  = NULL;
-
-        list_for_each_entry_safe (iter, tmp, copy, msg_list) {
-                gf_log_flush_message (iter, ctx);
-                list_del_init (&iter->msg_list);
-                log_buf_destroy (iter);
-        }
+    log_buf_t *iter = NULL;
+    log_buf_t *tmp = NULL;
+
+    list_for_each_entry_safe(iter, tmp, copy, msg_list)
+    {
+        gf_log_flush_message(iter, ctx);
+        list_del_init(&iter->msg_list);
+        log_buf_destroy(iter);
+    }
 }
 
 void
-gf_log_flush_msgs (glusterfs_ctx_t *ctx)
+gf_log_flush_msgs(glusterfs_ctx_t *ctx)
 {
-        struct list_head copy;
+    struct list_head copy;
 
-        INIT_LIST_HEAD (&copy);
+    INIT_LIST_HEAD(&copy);
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                list_splice_init (&ctx->log.lru_queue, &copy);
-                ctx->log.lru_cur_size = 0;
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        list_splice_init(&ctx->log.lru_queue, &copy);
+        ctx->log.lru_cur_size = 0;
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 
-        gf_log_flush_list (&copy, ctx);
+    gf_log_flush_list(&copy, ctx);
 
-        return;
+    return;
 }
 
 static void
-gf_log_flush_extra_msgs (glusterfs_ctx_t *ctx, uint32_t new)
+gf_log_flush_extra_msgs(glusterfs_ctx_t *ctx, uint32_t new)
 {
-        int               count = 0;
-        int                   i = 0;
-        log_buf_t        *iter  = NULL;
-        log_buf_t        *tmp   = NULL;
-        struct list_head copy;
-
-        INIT_LIST_HEAD (&copy);
-
-        /* If the number of outstanding log messages does not cause list
-         * overflow even after reducing the size of the list, then do nothing.
-         * Otherwise (that is if there are more items in the list than there
-         * need to be after reducing its size), move the least recently used
-         * 'diff' elements to be flushed into a separate list...
-         */
-
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
+    int count = 0;
+    int i = 0;
+    log_buf_t *iter = NULL;
+    log_buf_t *tmp = NULL;
+    struct list_head copy;
+
+    INIT_LIST_HEAD(&copy);
+
+    /* If the number of outstanding log messages does not cause list
+     * overflow even after reducing the size of the list, then do nothing.
+     * Otherwise (that is if there are more items in the list than there
+     * need to be after reducing its size), move the least recently used
+     * 'diff' elements to be flushed into a separate list...
+     */
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        if (ctx->log.lru_cur_size <= new)
+            goto unlock;
+        count = ctx->log.lru_cur_size - new;
+        list_for_each_entry_safe(iter, tmp, &ctx->log.lru_queue, msg_list)
         {
-                if (ctx->log.lru_cur_size <= new)
-                        goto unlock;
-                count = ctx->log.lru_cur_size - new;
-                list_for_each_entry_safe (iter, tmp, &ctx->log.lru_queue,
-                                          msg_list) {
-                        if (i == count)
-                                break;
-
-                        list_del_init (&iter->msg_list);
-                        list_add_tail (&iter->msg_list, &copy);
-                        i++;
-                }
-                ctx->log.lru_cur_size = ctx->log.lru_cur_size - count;
+            if (i == count)
+                break;
+
+            list_del_init(&iter->msg_list);
+            list_add_tail(&iter->msg_list, &copy);
+            i++;
         }
-        // ... quickly unlock ...
+        ctx->log.lru_cur_size = ctx->log.lru_cur_size - count;
+    }
+    // ... quickly unlock ...
 unlock:
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-        if (list_empty (&copy))
-                return;
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+    if (list_empty(&copy))
+        return;
 
-        TEST_LOG("Log buffer size reduced. About to flush %d extra log "
-                 "messages", count);
-        // ... and then flush them outside the lock.
-        gf_log_flush_list (&copy, ctx);
-        TEST_LOG("Just flushed %d extra log messages", count);
+    TEST_LOG(
+        "Log buffer size reduced. About to flush %d extra log "
+        "messages",
+        count);
+    // ... and then flush them outside the lock.
+    gf_log_flush_list(&copy, ctx);
+    TEST_LOG("Just flushed %d extra log messages", count);
 
-        return;
+    return;
 }
 
 static int
-__gf_log_inject_timer_event (glusterfs_ctx_t *ctx)
+__gf_log_inject_timer_event(glusterfs_ctx_t *ctx)
 {
-        int              ret      = -1;
-        struct timespec  timeout  = {0,};
+    int ret = -1;
+    struct timespec timeout = {
+        0,
+    };
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (ctx->log.log_flush_timer) {
-                gf_timer_call_cancel (ctx, ctx->log.log_flush_timer);
-                ctx->log.log_flush_timer = NULL;
-        }
+    if (ctx->log.log_flush_timer) {
+        gf_timer_call_cancel(ctx, ctx->log.log_flush_timer);
+        ctx->log.log_flush_timer = NULL;
+    }
 
-        timeout.tv_sec  = ctx->log.timeout;
-        timeout.tv_nsec = 0;
+    timeout.tv_sec = ctx->log.timeout;
+    timeout.tv_nsec = 0;
 
-        TEST_LOG("Starting timer now. Timeout = %u, current buf size = %d",
-                 ctx->log.timeout, ctx->log.lru_size);
-        ctx->log.log_flush_timer = gf_timer_call_after (ctx, timeout,
-                                                      gf_log_flush_timeout_cbk,
-                                                        (void *)ctx);
-        if (!ctx->log.log_flush_timer)
-                goto out;
+    TEST_LOG("Starting timer now. Timeout = %u, current buf size = %d",
+             ctx->log.timeout, ctx->log.lru_size);
+    ctx->log.log_flush_timer = gf_timer_call_after(
+        ctx, timeout, gf_log_flush_timeout_cbk, (void *)ctx);
+    if (!ctx->log.log_flush_timer)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_log_inject_timer_event (glusterfs_ctx_t *ctx)
+gf_log_inject_timer_event(glusterfs_ctx_t *ctx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!ctx)
-                return -1;
+    if (!ctx)
+        return -1;
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                ret = __gf_log_inject_timer_event (ctx);
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        ret = __gf_log_inject_timer_event(ctx);
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 
-        return ret;
+    return ret;
 }
 
 void
-gf_log_flush_timeout_cbk (void *data)
+gf_log_flush_timeout_cbk(void *data)
 {
-        glusterfs_ctx_t  *ctx  = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = (glusterfs_ctx_t *) data;
+    ctx = (glusterfs_ctx_t *)data;
 
-        TEST_LOG("Log timer timed out. About to flush outstanding messages if "
-                 "present");
-        gf_log_flush_msgs (ctx);
+    TEST_LOG(
+        "Log timer timed out. About to flush outstanding messages if "
+        "present");
+    gf_log_flush_msgs(ctx);
 
-        (void) gf_log_inject_timer_event (ctx);
+    (void)gf_log_inject_timer_event(ctx);
 
-        return;
+    return;
 }
 
 static int
-_gf_msg_internal (const char *domain, const char *file, const char *function,
-                  int32_t line, gf_loglevel_t level, int errnum, uint64_t msgid,
-                  char **appmsgstr, char *callstr, int graph_id)
+_gf_msg_internal(const char *domain, const char *file, const char *function,
+                 int32_t line, gf_loglevel_t level, int errnum, uint64_t msgid,
+                 char **appmsgstr, char *callstr, int graph_id)
 {
-        int              ret              = -1;
-        uint32_t         size             = 0;
-        const char      *basename         = NULL;
-        xlator_t        *this             = NULL;
-        glusterfs_ctx_t *ctx              = NULL;
-        log_buf_t       *iter             = NULL;
-        log_buf_t       *buf_tmp          = NULL;
-        log_buf_t       *buf_new          = NULL;
-        log_buf_t       *first            = NULL;
-        struct timeval   tv               = {0,};
-        gf_boolean_t     found            = _gf_false;
-        gf_boolean_t     flush_lru        = _gf_false;
-        gf_boolean_t     flush_logged_msg = _gf_false;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
+    int ret = -1;
+    uint32_t size = 0;
+    const char *basename = NULL;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    log_buf_t *iter = NULL;
+    log_buf_t *buf_tmp = NULL;
+    log_buf_t *buf_new = NULL;
+    log_buf_t *first = NULL;
+    struct timeval tv = {
+        0,
+    };
+    gf_boolean_t found = _gf_false;
+    gf_boolean_t flush_lru = _gf_false;
+    gf_boolean_t flush_logged_msg = _gf_false;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    GET_FILE_NAME_TO_LOG(file, basename);
+
+    ret = gettimeofday(&tv, NULL);
+    if (ret)
+        goto out;
+
+    /* If this function is called via _gf_msg_callingfn () (indicated by a
+     * non-NULL callstr), or if the logformat is traditional, flush the
+     * message directly to disk.
+     */
+
+    if ((callstr) || (ctx->log.logformat == gf_logformat_traditional)) {
+        ret = gf_log_print_plain_fmt(ctx, domain, basename, function, line,
+                                     level, errnum, msgid, appmsgstr, callstr,
+                                     tv, graph_id, gf_logformat_traditional);
+        goto out;
+    }
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        /* Check if the msg being logged is already part of the list */
+        list_for_each_entry_safe_reverse(iter, buf_tmp, &ctx->log.lru_queue,
+                                         msg_list)
+        {
+            if (first == NULL)
+                // Remember the first (lru) element in first ptr
+                first = iter;
 
-        GET_FILE_NAME_TO_LOG (file, basename);
+            /* Try to fail the search early on by doing the less
+             * expensive integer comparisons and continue to string
+             * parameter comparisons only after all int parameters
+             * are found to be matching.
+             */
+            if (line != iter->line)
+                continue;
 
-        ret = gettimeofday (&tv, NULL);
-        if (ret)
-                goto out;
+            if (errnum != iter->errnum)
+                continue;
 
-        /* If this function is called via _gf_msg_callingfn () (indicated by a
-         * non-NULL callstr), or if the logformat is traditional, flush the
-         * message directly to disk.
-         */
+            if (msgid != iter->msg_id)
+                continue;
 
-        if ((callstr) || (ctx->log.logformat == gf_logformat_traditional)) {
-                ret = gf_log_print_plain_fmt (ctx, domain, basename, function,
-                                              line, level, errnum, msgid,
-                                              appmsgstr, callstr, tv, graph_id,
-                                              gf_logformat_traditional);
-                goto out;
-        }
+            if (level != iter->level)
+                continue;
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                /* Check if the msg being logged is already part of the list */
-                list_for_each_entry_safe_reverse (iter, buf_tmp,
-                                                  &ctx->log.lru_queue,
-                                                  msg_list) {
-                        if (first == NULL)
-                                // Remember the first (lru) element in first ptr
-                                first = iter;
-
-                        /* Try to fail the search early on by doing the less
-                         * expensive integer comparisons and continue to string
-                         * parameter comparisons only after all int parameters
-                         * are found to be matching.
-                         */
-                        if (line != iter->line)
-                                continue;
-
-                        if (errnum != iter->errnum)
-                                continue;
-
-                        if (msgid != iter->msg_id)
-                                continue;
-
-                        if (level != iter->level)
-                                continue;
-
-                        if (graph_id != iter->graph_id)
-                                continue;
-
-                        if (strcmp (domain, iter->domain))
-                                continue;
-
-                        if (strcmp (basename, iter->file))
-                                continue;
-
-                        if (strcmp (function, iter->function))
-                                continue;
-
-                        if (strcmp (*appmsgstr, iter->msg))
-                                continue;
-
-                        //Ah! Found a match!
-                        list_move_tail (&iter->msg_list, &ctx->log.lru_queue);
-                        iter->refcount++;
-                        found = _gf_true;
-                        //Update the 'latest' timestamp.
-                        memcpy ((void *)&(iter->latest), (void *)&tv,
-                                sizeof (struct timeval));
-                        break;
-                }
-                if (found) {
-                        ret = 0;
-                        goto unlock;
-                }
-                // else ...
-
-                size = ctx->log.lru_size;
-                /* If the upper limit on the log buf size is 0, flush the msg to
-                 * disk directly after unlock. There's no need to buffer the
-                 * msg here.
-                 */
-                if (size == 0) {
-                        flush_logged_msg = _gf_true;
-                        goto unlock;
-                } else if ((ctx->log.lru_cur_size + 1) > size) {
-                /* If the list is full, flush the lru msg to disk and also
-                 * release it after unlock, and ...
-                 * */
-                if (first->refcount >= 1)
-                        TEST_LOG("Buffer overflow of a buffer whose size limit "
-                                 "is %d. About to flush least recently used log"
-                                 " message to disk", size);
-                        list_del_init (&first->msg_list);
-                        ctx->log.lru_cur_size--;
-                        flush_lru = _gf_true;
-                }
-                /* create a new list element, initialise and enqueue it.
-                 * Additionally, this being the first occurrence of the msg,
-                 * log it directly to disk after unlock. */
-                buf_new = log_buf_new ();
-                if (!buf_new) {
-                        ret = -1;
-                        goto unlock;
-                }
-                ret = log_buf_init (buf_new, domain, basename, function, line,
-                                    level, errnum, msgid, appmsgstr, graph_id);
-                if (ret) {
-                        log_buf_destroy (buf_new);
-                        goto unlock;
-                }
+            if (graph_id != iter->graph_id)
+                continue;
 
-                memcpy ((void *)&(buf_new->latest), (void *)&tv,
-                        sizeof (struct timeval));
-                memcpy ((void *)&(buf_new->oldest), (void *)&tv,
-                        sizeof (struct timeval));
+            if (strcmp(domain, iter->domain))
+                continue;
 
-                list_add_tail (&buf_new->msg_list, &ctx->log.lru_queue);
-                ctx->log.lru_cur_size++;
-                flush_logged_msg = _gf_true;
-                ret = 0;
-        }
-unlock:
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+            if (strcmp(basename, iter->file))
+                continue;
 
-        /* Value of @ret is a don't-care below since irrespective of success or
-         * failure post setting of @flush_lru, @first must be flushed and freed.
-         */
-        if (flush_lru) {
-                gf_log_flush_message (first, ctx);
-                log_buf_destroy (first);
+            if (strcmp(function, iter->function))
+                continue;
+
+            if (strcmp(*appmsgstr, iter->msg))
+                continue;
+
+            // Ah! Found a match!
+            list_move_tail(&iter->msg_list, &ctx->log.lru_queue);
+            iter->refcount++;
+            found = _gf_true;
+            // Update the 'latest' timestamp.
+            memcpy((void *)&(iter->latest), (void *)&tv,
+                   sizeof(struct timeval));
+            break;
         }
-        /* Similarly, irrespective of whether all operations since setting of
-         * @flush_logged_msg were successful or not, flush the message being
-         * logged to disk in the plain format.
-         */
-        if (flush_logged_msg) {
-                ret = gf_log_print_plain_fmt (ctx, domain, basename,
-                                              function, line, level,
-                                              errnum, msgid, appmsgstr,
-                                              callstr, tv, graph_id,
-                                              gf_logformat_withmsgid);
+        if (found) {
+            ret = 0;
+            goto unlock;
         }
+        // else ...
+
+        size = ctx->log.lru_size;
+        /* If the upper limit on the log buf size is 0, flush the msg to
+         * disk directly after unlock. There's no need to buffer the
+         * msg here.
+         */
+        if (size == 0) {
+            flush_logged_msg = _gf_true;
+            goto unlock;
+        } else if (((ctx->log.lru_cur_size + 1) > size) && (first)) {
+            /* If the list is full, flush the lru msg to disk and also
+             * release it after unlock, and ...
+             * */
+            if (first->refcount >= 1)
+                TEST_LOG(
+                    "Buffer overflow of a buffer whose size limit "
+                    "is %d. About to flush least recently used log"
+                    " message to disk",
+                    size);
+            list_del_init(&first->msg_list);
+            ctx->log.lru_cur_size--;
+            flush_lru = _gf_true;
+        }
+        /* create a new list element, initialise and enqueue it.
+         * Additionally, this being the first occurrence of the msg,
+         * log it directly to disk after unlock. */
+        buf_new = mem_get0(THIS->ctx->logbuf_pool);
+        if (!buf_new) {
+            ret = -1;
+            goto unlock;
+        }
+        ret = log_buf_init(buf_new, domain, basename, function, line, level,
+                           errnum, msgid, appmsgstr, graph_id);
+        if (ret) {
+            log_buf_destroy(buf_new);
+            goto unlock;
+        }
+
+        memcpy((void *)&(buf_new->latest), (void *)&tv, sizeof(struct timeval));
+        memcpy((void *)&(buf_new->oldest), (void *)&tv, sizeof(struct timeval));
+
+        list_add_tail(&buf_new->msg_list, &ctx->log.lru_queue);
+        ctx->log.lru_cur_size++;
+        flush_logged_msg = _gf_true;
+        ret = 0;
+    }
+unlock:
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+
+    /* Value of @ret is a don't-care below since irrespective of success or
+     * failure post setting of @flush_lru, @first must be flushed and freed.
+     */
+    if (flush_lru) {
+        gf_log_flush_message(first, ctx);
+        log_buf_destroy(first);
+    }
+    /* Similarly, irrespective of whether all operations since setting of
+     * @flush_logged_msg were successful or not, flush the message being
+     * logged to disk in the plain format.
+     */
+    if (flush_logged_msg) {
+        ret = gf_log_print_plain_fmt(ctx, domain, basename, function, line,
+                                     level, errnum, msgid, appmsgstr, callstr,
+                                     tv, graph_id, gf_logformat_withmsgid);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg (const char *domain, const char *file, const char *function,
-         int32_t line, gf_loglevel_t level, int errnum, int trace,
-         uint64_t msgid, const char *fmt, ...)
+_gf_msg(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, int errnum, int trace,
+        uint64_t msgid, const char *fmt, ...)
 {
-        int              ret = 0;
-        char            *msgstr = NULL;
-        va_list          ap;
-        xlator_t        *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-        char             callstr[GF_LOG_BACKTRACE_SIZE] = {0,};
-        int              passcallstr = 0;
-        int              log_inited = 0;
-
-        /* in args check */
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
-        }
-
-        this = THIS;
-
-        if (this == NULL)
-                return -1;
-
-        ctx = this->ctx;
-        if (ctx == NULL) {
-                /* messages before context initialization are ignored */
+    int ret = 0;
+    char *msgstr = NULL;
+    va_list ap;
+    xlator_t *this = THIS;
+    glusterfs_ctx_t *ctx = NULL;
+    char *callstr = NULL;
+    int log_inited = 0;
+
+    if (this == NULL)
+        return -1;
+
+    ctx = this->ctx;
+    if (ctx == NULL) {
+        /* messages before context initialization are ignored */
+        return -1;
+    }
+
+    /* check if we should be logging */
+    if (skip_logging(this, level))
+        goto out;
+
+    /* in args check */
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    /* form the message */
+    va_start(ap, fmt);
+    ret = vasprintf(&msgstr, fmt, ap);
+    va_end(ap);
+
+    /* log */
+    if (ret != -1) {
+        if (trace) {
+            callstr = GF_MALLOC(GF_LOG_BACKTRACE_SIZE, gf_common_mt_char);
+            if (callstr == NULL)
                 return -1;
-        }
 
-        /* check if we should be logging */
-        if (skip_logging (this, level))
-                goto out;
-
-        if (trace) {
-                ret = _gf_msg_backtrace (GF_LOG_BACKTRACE_DEPTH, callstr,
-                                         GF_LOG_BACKTRACE_SIZE);
-                if (ret >= 0)
-                        passcallstr = 1;
-                else
-                        ret = 0;
+            ret = _gf_msg_backtrace(GF_LOG_BACKTRACE_DEPTH, callstr,
+                                    GF_LOG_BACKTRACE_SIZE);
+            if (ret < 0) {
+                GF_FREE(callstr);
+                callstr = NULL;
+            }
         }
 
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
         {
-                if (ctx->log.logfile) {
-                        log_inited = 1;
-                }
-        }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-
-        /* form the message */
-        va_start (ap, fmt);
-        ret = vasprintf (&msgstr, fmt, ap);
-        va_end (ap);
-
-        /* log */
-        if (ret != -1) {
-                if (!log_inited && ctx->log.gf_log_syslog) {
-                        ret = gf_log_syslog (ctx, domain, file, function, line,
-                                            level, errnum, msgid, &msgstr,
-                                            (passcallstr? callstr : NULL),
-                                            (this->graph)? this->graph->id : 0,
-                                            gf_logformat_traditional);
-                } else {
-                        ret = _gf_msg_internal (domain, file, function, line,
-                                            level, errnum, msgid, &msgstr,
-                                            (passcallstr? callstr : NULL),
-                                            (this->graph)? this->graph->id : 0);
-                }
-        } else {
-                /* man (3) vasprintf states on error strp contents
-                 * are undefined, be safe */
-                msgstr = NULL;
+            if (ctx->log.logfile) {
+                log_inited = 1;
+            }
         }
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-        FREE (msgstr);
+        if (!log_inited && ctx->log.gf_log_syslog) {
+            ret = gf_log_syslog(
+                ctx, domain, file, function, line, level, errnum, msgid,
+                &msgstr, (callstr ? callstr : NULL),
+                (this->graph) ? this->graph->id : 0, gf_logformat_traditional);
+        } else {
+            ret = _gf_msg_internal(domain, file, function, line, level, errnum,
+                                   msgid, &msgstr, (callstr ? callstr : NULL),
+                                   (this->graph) ? this->graph->id : 0);
+        }
+    } else {
+        /* man (3) vasprintf states on error strp contents
+         * are undefined, be safe */
+        msgstr = NULL;
+    }
+    if (callstr)
+        GF_FREE(callstr);
+    FREE(msgstr);
 
 out:
-        return ret;
+    return ret;
 }
 
 /* TODO: Deprecate (delete) _gf_log, _gf_log_callingfn,
  * once messages are changed to use _gf_msgXXX APIs for logging */
 int
-_gf_log (const char *domain, const char *file, const char *function, int line,
-         gf_loglevel_t level, const char *fmt, ...)
+_gf_log(const char *domain, const char *file, const char *function, int line,
+        gf_loglevel_t level, const char *fmt, ...)
 {
-        const char    *basename = NULL;
-        FILE          *new_logfile = NULL;
-        va_list        ap;
-        char           timestr[GF_LOG_TIMESTR_SIZE] = {0,};
-        struct timeval tv = {0,};
-        char          *str1 = NULL;
-        char          *str2 = NULL;
-        char          *msg  = NULL;
-        size_t         len  = 0;
-        int            ret  = 0;
-        int            fd   = -1;
-        xlator_t      *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        static char *level_strings[] = {"",  /* NONE */
-                                        "M", /* EMERGENCY */
-                                        "A", /* ALERT */
-                                        "C", /* CRITICAL */
-                                        "E", /* ERROR */
-                                        "W", /* WARNING */
-                                        "N", /* NOTICE */
-                                        "I", /* INFO */
-                                        "D", /* DEBUG */
-                                        "T", /* TRACE */
-                                        ""};
-
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
+    const char *basename = NULL;
+    FILE *new_logfile = NULL;
+    va_list ap;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    struct timeval tv = {
+        0,
+    };
+    char *logline = NULL;
+    char *msg = NULL;
+    int ret = 0;
+    int fd = -1;
+    xlator_t *this = THIS;
+    glusterfs_ctx_t *ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    basename = strrchr(file, '/');
+    if (basename)
+        basename++;
+    else
+        basename = file;
+
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret) {
+        goto err;
+    }
+
+    if (ctx->log.log_control_file_found) {
+        int priority;
+        /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
+           other level as is */
+        if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
+            priority = LOG_DEBUG;
+        } else {
+            priority = level - 1;
         }
 
-        basename = strrchr (file, '/');
-        if (basename)
-                basename++;
-        else
-                basename = file;
-
-        if (ctx->log.log_control_file_found)
-        {
-                int priority;
-                /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
-                   other level as is */
-                if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
-                        priority = LOG_DEBUG;
-                } else {
-                        priority = level - 1;
-                }
+        gf_syslog(priority, "[%s:%d:%s] %d-%s: %s", basename, line, function,
+                  ((this->graph) ? this->graph->id : 0), domain, msg);
+        goto err;
+    }
 
-                va_start (ap, fmt);
-                vasprintf (&str2, fmt, ap);
-                va_end (ap);
+    if (ctx->log.logrotate) {
+        ctx->log.logrotate = 0;
 
-                gf_syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                           basename, line, function,
-                           ((this->graph) ? this->graph->id:0), domain, str2);
-                goto err;
+        fd = sys_open(ctx->log.filename, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            gf_smsg("logrotate", GF_LOG_ERROR, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, NULL);
+            return -1;
         }
+        sys_close(fd);
 
-        if (ctx->log.logrotate) {
-                ctx->log.logrotate = 0;
-
-                fd = open (ctx->log.filename,
-                           O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg ("logrotate", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile");
-                        return -1;
-                }
-                sys_close (fd);
-
-                new_logfile = fopen (ctx->log.filename, "a");
-                if (!new_logfile) {
-                        gf_msg ("logrotate", GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile %s",
-                                ctx->log.filename);
-                        goto log;
-                }
-
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile)
-                                fclose (ctx->log.logfile);
+        new_logfile = fopen(ctx->log.filename, "a");
+        if (!new_logfile) {
+            gf_smsg("logrotate", GF_LOG_CRITICAL, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, "filename=%s",
+                    ctx->log.filename, NULL);
+            goto log;
+        }
 
-                        ctx->log.gf_log_logfile =
-                                ctx->log.logfile = new_logfile;
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        {
+            if (ctx->log.logfile)
+                fclose(ctx->log.logfile);
 
+            ctx->log.gf_log_logfile = ctx->log.logfile = new_logfile;
         }
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    }
 
 log:
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %d-%s: ",
-                           timestr, level_strings[level],
-                           basename, line, function,
-                           ((this->graph)?this->graph->id:0), domain);
-        if (-1 == ret) {
-                goto err;
-        }
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
 
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto err;
-        }
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
 
-        va_end (ap);
+    ret = gf_asprintf(&logline, "[%s] %c [%s:%d:%s] %d-%s: %s\n", timestr,
+                      gf_level_strings[level], basename, line, function,
+                      ((this->graph) ? this->graph->id : 0), domain, msg);
+    if (-1 == ret) {
+        goto err;
+    }
 
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                goto err;
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fputs(logline, ctx->log.logfile);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fputs(logline, stderr);
+            fflush(stderr);
         }
 
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious log in 'syslog', not our debug
-                   and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                    (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious log in 'syslog', not our debug
+           and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s", logline);
 #endif
-        }
+    }
 
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 err:
-        GF_FREE (msg);
-
-        GF_FREE (str1);
+    GF_FREE(logline);
 
-        FREE (str2);
+    FREE(msg);
 
 out:
-        va_end (ap);
-        return (0);
+    return (0);
 }
 
 int
-_gf_log_eh (const char *function, const char *fmt, ...)
+_gf_log_eh(const char *function, const char *fmt, ...)
 {
-        int          ret   = -1;
-        va_list      ap;
-        char         *str1 = NULL;
-        char         *str2 = NULL;
-        char         *msg  = NULL;
-        xlator_t     *this = NULL;
-
-        this = THIS;
-
-        ret = gf_asprintf (&str1, "[%d] %s: ",
-                           ((this->graph)?this->graph->id:0),
-                           function);
-        if (-1 == ret) {
-                goto out;
-        }
+    int ret = -1;
+    va_list ap;
+    char *logline = NULL;
+    char *msg = NULL;
+    xlator_t *this = NULL;
 
-        va_start (ap, fmt);
-
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    this = THIS;
 
-        msg = GF_MALLOC (strlen (str1) + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto out;
-        }
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        strcpy (msg, str1);
-        strcat (msg, str2);
+    ret = gf_asprintf(&logline, "[%d] %s: %s",
+                      ((this->graph) ? this->graph->id : 0), function, msg);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = eh_save_history (this->history, msg);
-        if (ret < 0)
-                GF_FREE (msg);
+    ret = eh_save_history(this->history, logline);
 
 out:
-        GF_FREE (str1);
-
-        /* Use FREE instead of GF_FREE since str2 was allocated by vasprintf */
-        if (str2)
-                FREE (str2);
+    GF_FREE(logline);
 
-        va_end (ap);
+    FREE(msg);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cmd_log_init (const char *filename)
+gf_cmd_log_init(const char *filename)
 {
-        int         fd   = -1;
-        xlator_t   *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx  = this->ctx;
-
-        if (!ctx)
-                return -1;
+    int fd = -1;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        return -1;
+
+    if (!filename) {
+        gf_smsg(this->name, GF_LOG_CRITICAL, 0, LG_MSG_FILENAME_NOT_SPECIFIED,
+                "gf_cmd_log_init", NULL);
+        return -1;
+    }
+
+    ctx->log.cmd_log_filename = gf_strdup(filename);
+    if (!ctx->log.cmd_log_filename) {
+        return -1;
+    }
+    /* close and reopen cmdlogfile for log rotate*/
+    if (ctx->log.cmdlogfile) {
+        fclose(ctx->log.cmdlogfile);
+        ctx->log.cmdlogfile = NULL;
+    }
+
+    fd = sys_open(ctx->log.cmd_log_filename, O_CREAT | O_WRONLY | O_APPEND,
+                  S_IRUSR | S_IWUSR);
+    if (fd < 0) {
+        gf_smsg(this->name, GF_LOG_CRITICAL, errno, LG_MSG_OPEN_LOGFILE_FAILED,
+                "cmd_log_file", NULL);
+        return -1;
+    }
+
+    ctx->log.cmdlogfile = fdopen(fd, "a");
+    if (!ctx->log.cmdlogfile) {
+        gf_smsg(this->name, GF_LOG_CRITICAL, errno, LG_MSG_OPEN_LOGFILE_FAILED,
+                "gf_cmd_log_init: %s", ctx->log.cmd_log_filename, NULL);
+        sys_close(fd);
+        return -1;
+    }
+    return 0;
+}
 
-        if (!filename){
-                gf_msg (this->name, GF_LOG_CRITICAL, 0, LG_MSG_INVALID_ENTRY,
-                        "gf_cmd_log_init: no filename specified\n");
-                return -1;
-        }
+int
+gf_cmd_log(const char *domain, const char *fmt, ...)
+{
+    va_list ap;
+    char timestr[GF_TIMESTR_SIZE];
+    struct timeval tv = {
+        0,
+    };
+    char *logline = NULL;
+    char *msg = NULL;
+    int ret = 0;
+    int fd = -1;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = THIS->ctx;
+
+    if (!ctx)
+        return -1;
+
+    if (!ctx->log.cmdlogfile)
+        return -1;
+
+    if (!domain || !fmt) {
+        gf_msg_trace("glusterd", 0, "logging: invalid argument\n");
+        return -1;
+    }
+
+    ret = gettimeofday(&tv, NULL);
+    if (ret == -1)
+        goto out;
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (ret == -1) {
+        goto out;
+    }
+
+    gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+
+    ret = gf_asprintf(&logline, "[%s] %s : %s\n", timestr, domain, msg);
+    if (ret == -1) {
+        goto out;
+    }
+
+    /* close and reopen cmdlogfile fd for in case of log rotate*/
+    if (ctx->log.cmd_history_logrotate) {
+        ctx->log.cmd_history_logrotate = 0;
 
-        ctx->log.cmd_log_filename = gf_strdup (filename);
-        if (!ctx->log.cmd_log_filename) {
-                return -1;
-        }
-        /* close and reopen cmdlogfile for log rotate*/
         if (ctx->log.cmdlogfile) {
-                fclose (ctx->log.cmdlogfile);
-                ctx->log.cmdlogfile = NULL;
+            fclose(ctx->log.cmdlogfile);
+            ctx->log.cmdlogfile = NULL;
         }
 
-        fd = open (ctx->log.cmd_log_filename,
-                   O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
+        fd = sys_open(ctx->log.cmd_log_filename, O_CREAT | O_WRONLY | O_APPEND,
+                      S_IRUSR | S_IWUSR);
         if (fd < 0) {
-                gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                        LG_MSG_FILE_OP_FAILED, "failed to open cmd_log_file");
-                return -1;
+            gf_smsg(THIS->name, GF_LOG_CRITICAL, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, "name=%s",
+                    ctx->log.cmd_log_filename, NULL);
+            ret = -1;
+            goto out;
         }
-        sys_close (fd);
-
-        ctx->log.cmdlogfile = fopen (ctx->log.cmd_log_filename, "a");
-        if (!ctx->log.cmdlogfile){
-                gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                        LG_MSG_FILE_OP_FAILED,
-                        "gf_cmd_log_init: failed to open logfile \"%s\" "
-                        "\n", ctx->log.cmd_log_filename);
-                return -1;
+
+        ctx->log.cmdlogfile = fdopen(fd, "a");
+        if (!ctx->log.cmdlogfile) {
+            gf_smsg(THIS->name, GF_LOG_CRITICAL, errno,
+                    LG_MSG_OPEN_LOGFILE_FAILED, "name=%s",
+                    ctx->log.cmd_log_filename, NULL);
+            ret = -1;
+            sys_close(fd);
+            goto out;
         }
-        return 0;
-}
+    }
 
-int
-gf_cmd_log (const char *domain, const char *fmt, ...)
-{
-        va_list        ap;
-        char           timestr[64];
-        struct timeval tv = {0,};
-        char          *str1 = NULL;
-        char          *str2 = NULL;
-        char          *msg  = NULL;
-        size_t         len  = 0;
-        int            ret  = 0;
-        int            fd   = -1;
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (!ctx)
-                return -1;
+    fputs(logline, ctx->log.cmdlogfile);
+    fflush(ctx->log.cmdlogfile);
 
-        if (!ctx->log.cmdlogfile)
-                return -1;
+out:
+    GF_FREE(logline);
 
+    FREE(msg);
 
-        if (!domain || !fmt) {
-                gf_msg_trace ("glusterd", 0,
-                        "logging: invalid argument\n");
-                return -1;
-        }
+    return ret;
+}
 
-        ret = gettimeofday (&tv, NULL);
-        if (ret == -1)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr),
-                  GF_LOG_TIMESTR_SIZE - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s : ",
-                           timestr, domain);
-        if (ret == -1) {
+static int
+_do_slog_format(int errnum, const char *event, va_list inp, char **msg)
+{
+    va_list valist_tmp;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    int ret = 0;
+    char *fmt = NULL;
+    char *buffer = NULL;
+    int num_format_chars = 0;
+    char format_char = '%';
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    char temp_sep[3] = "";
+
+    tmp2 = gf_strdup("");
+    if (!tmp2) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Hardcoded value for max key value pairs, exits early */
+    /* from loop if found NULL */
+    for (i = 0; i < GF_MAX_SLOG_PAIR_COUNT; i++) {
+        fmt = va_arg(inp, char *);
+        if (fmt == NULL) {
+            break;
+        }
+
+        /* Get number of times % is used in input for formatting, */
+        /* this count will be used to skip those many args from the */
+        /* main list and will be used to format inner format */
+        num_format_chars = 0;
+        for (k = 0; fmt[k] != '\0'; k++) {
+            /* If %% is used then that is escaped */
+            if (fmt[k] == format_char && fmt[k + 1] == format_char) {
+                k++;
+            } else if (fmt[k] == format_char) {
+                num_format_chars++;
+            }
+        }
+
+        tmp1 = gf_strdup(tmp2);
+        if (!tmp1) {
+            ret = -1;
+            goto out;
+        }
+
+        GF_FREE(tmp2);
+        tmp2 = NULL;
+
+        if (num_format_chars > 0) {
+            /* Make separate valist and format the string */
+            va_copy(valist_tmp, inp);
+            ret = gf_vasprintf(&buffer, fmt, valist_tmp);
+            if (ret < 0) {
+                va_end(valist_tmp);
                 goto out;
-        }
+            }
+            va_end(valist_tmp);
 
-        ret = vasprintf (&str2, fmt, ap);
-        if (ret == -1) {
-                goto out;
-        }
+            for (j = 0; j < num_format_chars; j++) {
+                /* Skip the va_arg value since these values
+                   are already used for internal formatting */
+                (void)va_arg(inp, void *);
+            }
 
-        va_end (ap);
+            ret = gf_asprintf(&tmp2, "%s%s{%s}", tmp1, temp_sep, buffer);
+            if (ret < 0)
+                goto out;
 
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
+            GF_FREE(buffer);
+            buffer = NULL;
+        } else {
+            ret = gf_asprintf(&tmp2, "%s%s{%s}", tmp1, temp_sep, fmt);
+            if (ret < 0)
                 goto out;
         }
 
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
+        /* Set seperator for next iteration */
+        temp_sep[0] = ',';
+        temp_sep[1] = ' ';
+        temp_sep[2] = 0;
 
-        /* close and reopen cmdlogfile fd for in case of log rotate*/
-        if (ctx->log.cmd_history_logrotate) {
-                ctx->log.cmd_history_logrotate = 0;
+        GF_FREE(tmp1);
+        tmp1 = NULL;
+    }
 
-                if (ctx->log.cmdlogfile) {
-                        fclose (ctx->log.cmdlogfile);
-                        ctx->log.cmdlogfile = NULL;
-                }
+    tmp1 = gf_strdup(tmp2);
+    if (!tmp1) {
+        ret = -1;
+        goto out;
+    }
+    GF_FREE(tmp2);
+    tmp2 = NULL;
 
-                fd = open (ctx->log.cmd_log_filename,
-                           O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg (THIS->name, GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open "
-                                "logfile \"%s\" \n", ctx->log.cmd_log_filename);
-                        ret = -1;
-                        goto out;
-                }
+    if (errnum) {
+        ret = gf_asprintf(&tmp2, "%s [%s%s{errno=%d}, {error=%s}]", event, tmp1,
+                          temp_sep, errnum, strerror(errnum));
+    } else {
+        ret = gf_asprintf(&tmp2, "%s [%s]", event, tmp1);
+    }
 
-                ctx->log.cmdlogfile = fdopen (fd, "a");
-                if (!ctx->log.cmdlogfile) {
-                        gf_msg (THIS->name, GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile \"%s\""
-                                " \n", ctx->log.cmd_log_filename);
-                        ret = -1;
-                        goto out;
-                }
-        }
+    if (ret == -1)
+        goto out;
 
-        fprintf (ctx->log.cmdlogfile, "%s\n", msg);
-        fflush (ctx->log.cmdlogfile);
+    *msg = gf_strdup(tmp2);
+    if (!*msg)
+        ret = -1;
 
 out:
-        GF_FREE (msg);
-
-        GF_FREE (str1);
+    if (buffer)
+        GF_FREE(buffer);
 
-        FREE (str2);
+    if (tmp1)
+        GF_FREE(tmp1);
 
-        va_end (ap);
+    if (tmp2)
+        GF_FREE(tmp2);
 
-        return ret;
+    return ret;
 }
 
 int
-_do_slog_format (const char *event, va_list inp, char **msg) {
-        va_list                    valist_tmp;
-        int                        i = 0;
-        int                        j = 0;
-        int                        k = 0;
-        int                        ret = 0;
-        char                      *fmt = NULL;
-        char                      *buffer = NULL;
-        int                        num_format_chars = 0;
-        char                       format_char = '%';
-        char                      *tmp1 = NULL;
-        char                      *tmp2 = NULL;
-
-        ret = gf_asprintf (&tmp2, "%s", event);
-        if (ret == -1)
-                goto out;
-
-        /* Hardcoded value for max key value pairs, exits early */
-        /* from loop if found NULL */
-        for (i = 0; i < GF_MAX_SLOG_PAIR_COUNT; i++) {
-                fmt = va_arg (inp, char*);
-                if (fmt == NULL) {
-                        break;
-                }
-
-                /* Get number of times % is used in input for formating, */
-                /* this count will be used to skip those many args from the */
-                /* main list and will be used to format inner format */
-                num_format_chars = 0;
-                for (k = 0; fmt[k] != '\0'; k++) {
-                        /* If %% is used then that is escaped */
-                        if (fmt[k] == format_char && fmt[k+1] == format_char) {
-                                k++;
-                        } else if (fmt[k] == format_char) {
-                                num_format_chars++;
-                        }
-                }
-
-                tmp1 = gf_strdup (tmp2);
-                if (!tmp1) {
-                        ret = -1;
-                        goto out;
-                }
-
-                GF_FREE (tmp2);
-                tmp2 = NULL;
-
-                if (num_format_chars > 0) {
-                        /* Make separate valist and format the string */
-                        va_copy (valist_tmp, inp);
-                        ret = gf_vasprintf (&buffer, fmt, valist_tmp);
-                        if (ret < 0) {
-                                va_end (valist_tmp);
-                                goto out;
-                        }
-                        va_end (valist_tmp);
-
-                        for (j = 0; j < num_format_chars; j++) {
-                                /* Skip the va_arg value since these values
-                                   are already used for internal formatting */
-                                (void) va_arg (inp, void*);
-                        }
-
-                        ret = gf_asprintf (&tmp2, "%s\t%s", tmp1, buffer);
-                        if (ret < 0)
-                                goto out;
-
-                        GF_FREE (buffer);
-                        buffer = NULL;
-                } else {
-                        ret = gf_asprintf (&tmp2, "%s\t%s", tmp1, fmt);
-                        if (ret < 0)
-                                goto out;
-                }
-
-                GF_FREE (tmp1);
-                tmp1 = NULL;
-        }
-
-        *msg = gf_strdup (tmp2);
-        if (!msg)
-                ret = -1;
-
- out:
-        if (buffer)
-                GF_FREE (buffer);
-
-        if (tmp1)
-                GF_FREE (tmp1);
-
-        if (tmp2)
-                GF_FREE (tmp2);
-
-        return ret;
-}
-
-int
-_gf_smsg (const char *domain, const char *file, const char *function,
-          int32_t line, gf_loglevel_t level, int errnum, int trace,
-          uint64_t msgid, const char *event, ...)
+_gf_smsg(const char *domain, const char *file, const char *function,
+         int32_t line, gf_loglevel_t level, int errnum, int trace,
+         uint64_t msgid, const char *event, ...)
 {
-        va_list     valist;
-        char       *msg = NULL;
-        int         ret = 0;
-
-        va_start (valist, event);
-        ret = _do_slog_format (event, valist, &msg);
-        if (ret == -1)
-                goto out;
-
-        ret = _gf_msg (domain, file, function, line, level, errnum, trace,
-                       msgid, "%s", msg);
+    va_list valist;
+    char *msg = NULL;
+    int ret = 0;
+    xlator_t *this = THIS;
 
- out:
-        va_end (valist);
-        if (msg)
-                GF_FREE (msg);
+    if (skip_logging(this, level))
         return ret;
-}
 
-int
-_gf_slog (const char *domain, const char *file, const char *function, int line,
-          gf_loglevel_t level, const char *event, ...)
-{
-        va_list      valist;
-        char        *msg = NULL;
-        int          ret = 0;
+    va_start(valist, event);
+    ret = _do_slog_format(errnum, event, valist, &msg);
+    if (ret == -1)
+        goto out;
 
-        va_start (valist, event);
-        ret = _do_slog_format (event, valist, &msg);
-        if (ret == -1)
-                goto out;
+    /* Pass errnum as zero since it is already formated as required */
+    ret = _gf_msg(domain, file, function, line, level, 0, trace, msgid, "%s",
+                  msg);
 
-        ret = _gf_log (domain, file, function, line, level, "%s", msg);
-
- out:
-        va_end (valist);
-        if (msg)
-                GF_FREE (msg);
-        return ret;
+out:
+    va_end(valist);
+    if (msg)
+        GF_FREE(msg);
+    return ret;
 }
diff --git a/libglusterfs/src/logging.h b/libglusterfs/src/logging.h
deleted file mode 100644
index fd9a36d15c2..00000000000
--- a/libglusterfs/src/logging.h
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __LOGGING_H__
-#define __LOGGING_H__
-
-#include <sys/time.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <pthread.h>
-#include "list.h"
-
-#ifdef GF_DARWIN_HOST_OS
-#define GF_PRI_FSBLK       "u"
-#define GF_PRI_DEV         PRId32
-#define GF_PRI_INODE       PRIu64
-#define GF_PRI_NLINK       PRIu32
-#define GF_PRI_SECOND      "ld"
-#define GF_PRI_SUSECONDS   "06d"
-#define GF_PRI_USEC        "d"
-#else
-#define GF_PRI_FSBLK       PRIu64
-#define GF_PRI_DEV         PRIu64
-#define GF_PRI_INODE       PRIu64
-#define GF_PRI_NLINK       PRIu32
-#define GF_PRI_SECOND      "lu"
-#define GF_PRI_SUSECONDS   "06ld"
-#define GF_PRI_USEC        "ld"
-#endif
-#define GF_PRI_BLKSIZE     PRId32
-#define GF_PRI_SIZET       "zu"
-#define GF_PRI_ATOMIC      PRIu64
-
-#ifdef GF_DARWIN_HOST_OS
-#define GF_PRI_TIME "ld"
-#else
-#define GF_PRI_TIME PRIu64
-#endif
-
-#if 0
-/* Syslog definitions :-) */
-#define LOG_EMERG   0           /* system is unusable */
-#define LOG_ALERT   1           /* action must be taken immediately */
-#define LOG_CRIT    2           /* critical conditions */
-#define LOG_ERR     3           /* error conditions */
-#define LOG_WARNING 4           /* warning conditions */
-#define LOG_NOTICE  5           /* normal but significant condition */
-#define LOG_INFO    6           /* informational */
-#define LOG_DEBUG   7           /* debug-level messages */
-#endif
-
-#define GF_LOG_FORMAT_NO_MSG_ID       "no-msg-id"
-#define GF_LOG_FORMAT_WITH_MSG_ID     "with-msg-id"
-
-#define GF_LOGGER_GLUSTER_LOG         "gluster-log"
-#define GF_LOGGER_SYSLOG              "syslog"
-
-typedef enum {
-        GF_LOG_NONE,
-        GF_LOG_EMERG,
-        GF_LOG_ALERT,
-        GF_LOG_CRITICAL,   /* fatal errors */
-        GF_LOG_ERROR,      /* major failures (not necessarily fatal) */
-        GF_LOG_WARNING,    /* info about normal operation */
-        GF_LOG_NOTICE,
-        GF_LOG_INFO,       /* Normal information */
-        GF_LOG_DEBUG,      /* internal errors */
-        GF_LOG_TRACE,      /* full trace of operation */
-} gf_loglevel_t;
-
-/* format for the logs */
-typedef enum {
-        gf_logformat_traditional = 0, /* Format as in gluster 3.5 */
-        gf_logformat_withmsgid, /* Format enhanced with MsgID, ident, errstr */
-        gf_logformat_cee /* log enhanced format in cee */
-} gf_log_format_t;
-
-/* log infrastructure to log to */
-typedef enum {
-        gf_logger_glusterlog = 0, /* locations and files as in gluster 3.5 */
-        gf_logger_syslog /* log to (r)syslog, based on (r)syslog conf */
-        /* NOTE: In the future journald, lumberjack, next new thing here */
-} gf_log_logger_t;
-
-#define DEFAULT_LOG_FILE_DIRECTORY          DATADIR "/log/glusterfs"
-#define DEFAULT_QUOTA_CRAWL_LOG_DIRECTORY   DATADIR "/log/glusterfs/quota_crawl"
-#define DEFAULT_LOG_LEVEL                   GF_LOG_INFO
-
-typedef struct gf_log_handle_ {
-        pthread_mutex_t   logfile_mutex;
-        uint8_t           logrotate;
-        uint8_t           cmd_history_logrotate;
-        gf_loglevel_t     loglevel;
-        int               gf_log_syslog;
-        gf_loglevel_t     sys_log_level;
-        char             *filename;
-        FILE             *logfile;
-        FILE             *gf_log_logfile;
-        char             *cmd_log_filename;
-        FILE             *cmdlogfile;
-        gf_log_logger_t   logger;
-        gf_log_format_t   logformat;
-        char             *ident;
-        int               log_control_file_found;
-        struct list_head  lru_queue;
-        uint32_t          lru_size;
-        uint32_t          lru_cur_size;
-        uint32_t          timeout;
-        pthread_mutex_t   log_buf_lock;
-        struct _gf_timer *log_flush_timer;
-        int               localtime;
-} gf_log_handle_t;
-
-
-typedef struct log_buf_ {
-        char             *msg;
-        uint64_t          msg_id;
-        int               errnum;
-        struct timeval    oldest;
-        struct timeval    latest;
-        char             *domain;
-        char             *file;
-        char             *function;
-        int32_t           line;
-        gf_loglevel_t     level;
-        int              refcount;
-        int              graph_id;
-        struct list_head msg_list;
-} log_buf_t;
-
-void gf_log_globals_init (void *ctx, gf_loglevel_t level);
-int gf_log_init (void *data, const char *filename, const char *ident);
-
-void gf_log_logrotate (int signum);
-
-void gf_log_cleanup (void);
-
-/* Internal interfaces to log messages with message IDs */
-int _gf_msg (const char *domain, const char *file,
-             const char *function, int32_t line, gf_loglevel_t level,
-             int errnum, int trace, uint64_t msgid, const char *fmt, ...)
-             __attribute__ ((__format__ (__printf__, 9, 10)));
-
-void _gf_msg_backtrace_nomem (gf_loglevel_t level, int stacksize);
-
-int _gf_msg_plain (gf_loglevel_t level, const char *fmt, ...)
-                   __attribute__ ((__format__ (__printf__, 2, 3)));
-
-int _gf_msg_plain_nomem (gf_loglevel_t level, const char *msg);
-
-int _gf_msg_vplain (gf_loglevel_t level, const char *fmt, va_list ap);
-
-int _gf_msg_nomem (const char *domain, const char *file,
-                   const char *function, int line, gf_loglevel_t level,
-                   size_t size);
-
-int _gf_log (const char *domain, const char *file,
-             const char *function, int32_t line, gf_loglevel_t level,
-             const char *fmt, ...)
-             __attribute__ ((__format__ (__printf__, 6, 7)));
-
-int _gf_log_callingfn (const char *domain, const char *file,
-                       const char *function, int32_t line, gf_loglevel_t level,
-                       const char *fmt, ...)
-                       __attribute__ ((__format__ (__printf__, 6, 7)));
-
-int _gf_log_eh (const char *function, const char *fmt, ...);
-
-
-
-/* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
- * other level as is */
-#define SET_LOG_PRIO(level, priority) do {                              \
-        if (GF_LOG_TRACE == (level) || GF_LOG_NONE == (level)) {        \
-                priority = LOG_DEBUG;                                   \
-        } else {                                                        \
-                priority = (level) - 1;                                 \
-        }                                                               \
-        } while (0)
-
-/* extract just the file name from the path */
-#define GET_FILE_NAME_TO_LOG(file, basename) do {       \
-        basename = strrchr ((file), '/');               \
-        if (basename)                                   \
-                basename++;                             \
-        else                                            \
-                basename = (file);                      \
-        } while (0)
-
-#define PRINT_SIZE_CHECK(ret, label, strsize) do {      \
-        if (ret < 0)                            \
-                goto label;                     \
-        if ((strsize - ret) > 0) {              \
-                strsize -= ret;                 \
-        } else {                                \
-                ret = 0;                        \
-                goto label;                     \
-        }                                       \
-        } while (0)
-
-#define FMT_WARN(fmt...) do { if (0) printf (fmt); } while (0)
-
-/* Interface to log messages with message IDs */
-#define gf_msg(dom, levl, errnum, msgid, fmt...) do {           \
-                _gf_msg (dom, __FILE__, __FUNCTION__, __LINE__, \
-                        levl, errnum, 0, msgid, ##fmt);         \
-        } while (0)
-
-/* no frills, no thrills, just a vanilla message, used to print the graph */
-#define gf_msg_plain(levl, fmt...) do {         \
-                _gf_msg_plain (levl, ##fmt);    \
-        } while (0)
-
-#define gf_msg_plain_nomem(levl, msg) do {              \
-                _gf_msg_plain_nomem (levl, msg);        \
-        } while (0)
-
-#define gf_msg_vplain(levl, fmt, va) do {         \
-                _gf_msg_vplain (levl, fmt, va);    \
-        } while (0)
-
-#define gf_msg_backtrace_nomem(level, stacksize) do {           \
-                _gf_msg_backtrace_nomem (level, stacksize);     \
-        } while (0)
-
-#define gf_msg_callingfn(dom, levl, errnum, msgid, fmt...) do { \
-                _gf_msg (dom, __FILE__, __FUNCTION__, __LINE__, \
-                        levl, errnum, 1, msgid, ##fmt);         \
-        } while (0)
-
-/* No malloc or calloc should be called in this function */
-#define gf_msg_nomem(dom, levl, size) do {                              \
-                _gf_msg_nomem (dom, __FILE__, __FUNCTION__, __LINE__,   \
-                                levl, size);                            \
-        } while (0)
-
-/* Debug or trace messages do not need message IDs as these are more developer
- * related. Hence, the following abstractions are provided for the same */
-#define gf_msg_debug(dom, errnum, fmt...) do {                          \
-                _gf_msg (dom, __FILE__, __FUNCTION__, __LINE__,         \
-                        GF_LOG_DEBUG, errnum, 0, 0, ##fmt);             \
-        } while (0)
-
-#define gf_msg_trace(dom, errnum, fmt...) do {                          \
-                _gf_msg (dom, __FILE__, __FUNCTION__, __LINE__,         \
-                        GF_LOG_TRACE, errnum, 0, 0, ##fmt);             \
-        } while (0)
-
-#define gf_log(dom, levl, fmt...) do {                                  \
-                FMT_WARN (fmt);                                         \
-                _gf_log (dom, __FILE__, __FUNCTION__, __LINE__,         \
-                         levl, ##fmt);                                  \
-        } while (0)
-
-#define gf_log_eh(fmt...) do {                                          \
-                FMT_WARN (fmt);                                         \
-                _gf_log_eh (__FUNCTION__, ##fmt);                        \
-        } while (0)
-
-#define gf_log_callingfn(dom, levl, fmt...) do {                        \
-                FMT_WARN (fmt);                                         \
-                _gf_log_callingfn (dom, __FILE__, __FUNCTION__, __LINE__, \
-                                   levl, ##fmt);                        \
-        } while (0)
-
-
-/* Log once in GF_UNIVERSAL_ANSWER times */
-#define GF_LOG_OCCASIONALLY(var, args...) if (!(var++%GF_UNIVERSAL_ANSWER)) { \
-                gf_log (args);                                          \
-        }
-
-void gf_log_disable_syslog (void);
-void gf_log_enable_syslog (void);
-gf_loglevel_t gf_log_get_loglevel (void);
-void gf_log_set_loglevel (gf_loglevel_t level);
-int gf_log_get_localtime (void);
-void gf_log_set_localtime (int);
-void gf_log_flush (void);
-gf_loglevel_t gf_log_get_xl_loglevel (void *xl);
-void gf_log_set_xl_loglevel (void *xl, gf_loglevel_t level);
-
-int gf_cmd_log (const char *domain, const char *fmt, ...)
-                __attribute__ ((__format__ (__printf__, 2, 3)));
-
-int gf_cmd_log_init (const char *filename);
-
-void set_sys_log_level (gf_loglevel_t level);
-
-int gf_log_fini(void *data);
-
-void
-gf_log_set_logger (gf_log_logger_t logger);
-
-void
-gf_log_set_logformat (gf_log_format_t format);
-
-void
-gf_log_set_log_buf_size (uint32_t buf_size);
-
-void
-gf_log_set_log_flush_timeout (uint32_t timeout);
-
-struct _glusterfs_ctx;
-
-void
-gf_log_flush_msgs (struct _glusterfs_ctx *ctx);
-
-int
-gf_log_inject_timer_event (struct _glusterfs_ctx *ctx);
-
-void
-gf_log_disable_suppression_before_exit (struct _glusterfs_ctx *ctx);
-
-#define GF_DEBUG(xl, format, args...)                           \
-        gf_log ((xl)->name, GF_LOG_DEBUG, format, ##args)
-#define GF_INFO(xl, format, args...)                            \
-        gf_log ((xl)->name, GF_LOG_INFO, format, ##args)
-#define GF_WARNING(xl, format, args...)                         \
-        gf_log ((xl)->name, GF_LOG_WARNING, format, ##args)
-#define GF_ERROR(xl, format, args...)                           \
-        gf_log ((xl)->name, GF_LOG_ERROR, format, ##args)
-
-int
-_gf_slog (const char *domain, const char *file, const char *function, int line,
-          gf_loglevel_t level, const char *event, ...);
-
-int
-_gf_smsg (const char *domain, const char *file, const char *function,
-          int32_t line, gf_loglevel_t level, int errnum, int trace,
-          uint64_t msgid, const char *event, ...);
-
-/* Interface to log messages with message IDs */
-#define gf_smsg(dom, levl, errnum, msgid, event...) do {              \
-                _gf_smsg (dom, __FILE__, __FUNCTION__, __LINE__,      \
-                          levl, errnum, 0, msgid, ##event);           \
-        } while (0)
-
-#define gf_slog(dom, levl, event...) do {                             \
-                _gf_slog (dom, __FILE__, __FUNCTION__, __LINE__,      \
-                          levl, ##event);                             \
-        } while (0)
-
-#endif /* __LOGGING_H__ */
diff --git a/libglusterfs/src/mem-pool.c b/libglusterfs/src/mem-pool.c
index ba29137b176..2d5a12b0a00 100644
--- a/libglusterfs/src/mem-pool.c
+++ b/libglusterfs/src/mem-pool.c
@@ -8,867 +8,925 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "mem-pool.h"
-#include "logging.h"
-#include "xlator.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/common-utils.h"  // for GF_ASSERT, gf_thread_cr...
+#include "glusterfs/globals.h"       // for xlator_t, THIS
 #include <stdlib.h>
 #include <stdarg.h>
 
-#define GF_MEM_POOL_LIST_BOUNDARY        (sizeof(struct list_head))
-#define GF_MEM_POOL_PTR                  (sizeof(struct mem_pool*))
-#define GF_MEM_POOL_PAD_BOUNDARY         (GF_MEM_POOL_LIST_BOUNDARY  + GF_MEM_POOL_PTR + sizeof(int))
-#define mem_pool_chunkhead2ptr(head)     ((head) + GF_MEM_POOL_PAD_BOUNDARY)
-#define mem_pool_ptr2chunkhead(ptr)      ((ptr) - GF_MEM_POOL_PAD_BOUNDARY)
-#define is_mem_chunk_in_use(ptr)         (*ptr == 1)
-#define mem_pool_from_ptr(ptr)           ((ptr) + GF_MEM_POOL_LIST_BOUNDARY)
-
-#define GLUSTERFS_ENV_MEM_ACCT_STR  "GLUSTERFS_DISABLE_MEM_ACCT"
-
 #include "unittest/unittest.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 void
-gf_mem_acct_enable_set (void *data)
+gf_mem_acct_enable_set(void *data)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        REQUIRE(data != NULL);
+    REQUIRE(data != NULL);
 
-        ctx = data;
+    ctx = data;
 
-        GF_ASSERT (ctx != NULL);
+    GF_ASSERT(ctx != NULL);
 
-        ctx->mem_acct_enable = 1;
+    ctx->mem_acct_enable = 1;
 
-        ENSURE(1 == ctx->mem_acct_enable);
+    ENSURE(1 == ctx->mem_acct_enable);
 
-        return;
+    return;
 }
 
-int
-gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
-		      uint32_t type, const char *typestr)
+static void *
+gf_mem_header_prepare(struct mem_header *header, size_t size)
 {
+    void *ptr;
 
-        void              *ptr    = NULL;
-        struct mem_header *header = NULL;
+    header->size = size;
 
-        if (!alloc_ptr)
-                return -1;
+    ptr = header + 1;
 
-        ptr = *alloc_ptr;
+    /* data follows in this gap of 'size' bytes */
+    *(uint32_t *)(ptr + size) = GF_MEM_TRAILER_MAGIC;
 
-        GF_ASSERT (xl != NULL);
+    return ptr;
+}
 
-        GF_ASSERT (xl->mem_acct != NULL);
+static void *
+gf_mem_set_acct_info(struct mem_acct *mem_acct, struct mem_header *header,
+                     size_t size, uint32_t type, const char *typestr)
+{
+    struct mem_acct_rec *rec = NULL;
+    bool new_ref = false;
 
-        GF_ASSERT (type <= xl->mem_acct->num_types);
+    if (mem_acct != NULL) {
+        GF_ASSERT(type <= mem_acct->num_types);
 
-        LOCK(&xl->mem_acct->rec[type].lock);
+        rec = &mem_acct->rec[type];
+        LOCK(&rec->lock);
         {
-		if (!xl->mem_acct->rec[type].typestr)
-			xl->mem_acct->rec[type].typestr = typestr;
-                xl->mem_acct->rec[type].size += size;
-                xl->mem_acct->rec[type].num_allocs++;
-                xl->mem_acct->rec[type].total_allocs++;
-                xl->mem_acct->rec[type].max_size =
-                        max (xl->mem_acct->rec[type].max_size,
-                             xl->mem_acct->rec[type].size);
-                xl->mem_acct->rec[type].max_num_allocs =
-                        max (xl->mem_acct->rec[type].max_num_allocs,
-                             xl->mem_acct->rec[type].num_allocs);
+            if (!rec->typestr) {
+                rec->typestr = typestr;
+            }
+            rec->size += size;
+            new_ref = (rec->num_allocs == 0);
+            rec->num_allocs++;
+            rec->total_allocs++;
+            rec->max_size = max(rec->max_size, rec->size);
+            rec->max_num_allocs = max(rec->max_num_allocs, rec->num_allocs);
+
+#ifdef DEBUG
+            list_add(&header->acct_list, &rec->obj_list);
+#endif
+        }
+        UNLOCK(&rec->lock);
+
+        /* We only take a reference for each memory type used, not for each
+         * allocation. This minimizes the use of atomic operations. */
+        if (new_ref) {
+            GF_ATOMIC_INC(mem_acct->refcnt);
         }
-        UNLOCK(&xl->mem_acct->rec[type].lock);
+    }
 
-        GF_ATOMIC_INC (xl->mem_acct->refcnt);
+    header->type = type;
+    header->mem_acct = mem_acct;
+    header->magic = GF_MEM_HEADER_MAGIC;
 
-        header = (struct mem_header *) ptr;
-        header->type = type;
-        header->size = size;
-        header->mem_acct = xl->mem_acct;
-        header->magic = GF_MEM_HEADER_MAGIC;
+    return gf_mem_header_prepare(header, size);
+}
 
-        ptr += sizeof (struct mem_header);
+static void *
+gf_mem_update_acct_info(struct mem_acct *mem_acct, struct mem_header *header,
+                        size_t size)
+{
+    struct mem_acct_rec *rec = NULL;
+
+    if (mem_acct != NULL) {
+        rec = &mem_acct->rec[header->type];
+        LOCK(&rec->lock);
+        {
+            rec->size += size - header->size;
+            rec->total_allocs++;
+            rec->max_size = max(rec->max_size, rec->size);
 
-        /* data follows in this gap of 'size' bytes */
-        *(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
+#ifdef DEBUG
+            /* The old 'header' already was present in 'obj_list', but
+             * realloc() could have changed its address. We need to remove
+             * the old item from the list and add the new one. This can be
+             * done this way because list_move() doesn't use the pointers
+             * to the old location (which are not valid anymore) already
+             * present in the list, it simply overwrites them. */
+            list_move(&header->acct_list, &rec->obj_list);
+#endif
+        }
+        UNLOCK(&rec->lock);
+    }
 
-        *alloc_ptr = ptr;
-        return 0;
+    return gf_mem_header_prepare(header, size);
 }
 
+static bool
+gf_mem_acct_enabled(void)
+{
+    xlator_t *x = THIS;
+    /* Low-level __gf_xxx() may be called
+       before ctx is initialized. */
+    return x->ctx && x->ctx->mem_acct_enable;
+}
 
 void *
-__gf_calloc (size_t nmemb, size_t size, uint32_t type, const char *typestr)
+__gf_calloc(size_t nmemb, size_t size, uint32_t type, const char *typestr)
 {
-        size_t          tot_size = 0;
-        size_t          req_size = 0;
-        char            *ptr = NULL;
-        xlator_t        *xl = NULL;
+    size_t tot_size = 0;
+    size_t req_size = 0;
+    void *ptr = NULL;
+    xlator_t *xl = NULL;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return CALLOC (nmemb, size);
+    if (!gf_mem_acct_enabled())
+        return CALLOC(nmemb, size);
 
-        xl = THIS;
+    xl = THIS;
 
-        req_size = nmemb * size;
-        tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    req_size = nmemb * size;
+    tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
 
-        ptr = calloc (1, tot_size);
+    ptr = calloc(1, tot_size);
 
-        if (!ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
-        gf_mem_set_acct_info (xl, &ptr, req_size, type, typestr);
+    if (!ptr) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
 
-        return (void *)ptr;
+    return gf_mem_set_acct_info(xl->mem_acct, ptr, req_size, type, typestr);
 }
 
 void *
-__gf_malloc (size_t size, uint32_t type, const char *typestr)
+__gf_malloc(size_t size, uint32_t type, const char *typestr)
 {
-        size_t          tot_size = 0;
-        char            *ptr = NULL;
-        xlator_t        *xl = NULL;
+    size_t tot_size = 0;
+    void *ptr = NULL;
+    xlator_t *xl = NULL;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return MALLOC (size);
+    if (!gf_mem_acct_enabled())
+        return MALLOC(size);
 
-        xl = THIS;
+    xl = THIS;
 
-        tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
 
-        ptr = malloc (tot_size);
-        if (!ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
-        gf_mem_set_acct_info (xl, &ptr, size, type, typestr);
+    ptr = malloc(tot_size);
+    if (!ptr) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
 
-        return (void *)ptr;
+    return gf_mem_set_acct_info(xl->mem_acct, ptr, size, type, typestr);
 }
 
 void *
-__gf_realloc (void *ptr, size_t size)
+__gf_realloc(void *ptr, size_t size)
 {
-        size_t             tot_size = 0;
-        char              *new_ptr;
-        struct mem_header *old_header = NULL;
-        struct mem_header *new_header = NULL;
-        struct mem_header  tmp_header;
-
-        if (!THIS->ctx->mem_acct_enable)
-                return REALLOC (ptr, size);
-
-        REQUIRE(NULL != ptr);
-
-        old_header = (struct mem_header *) (ptr - GF_MEM_HEADER_SIZE);
-        GF_ASSERT (old_header->magic == GF_MEM_HEADER_MAGIC);
-        tmp_header = *old_header;
-
-        tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
-        new_ptr = realloc (old_header, tot_size);
-        if (!new_ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
+    size_t tot_size = 0;
+    struct mem_header *header = NULL;
+
+    if (!gf_mem_acct_enabled())
+        return REALLOC(ptr, size);
+
+    REQUIRE(NULL != ptr);
+
+    header = (struct mem_header *)(ptr - GF_MEM_HEADER_SIZE);
+    GF_ASSERT(header->magic == GF_MEM_HEADER_MAGIC);
+
+    tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    header = realloc(header, tot_size);
+    if (!header) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
 
-        /*
-         * We used to pass (char **)&ptr as the second
-         * argument after the value of realloc was saved
-         * in ptr, but the compiler warnings complained
-         * about the casting to and forth from void ** to
-         * char **.
-         * TBD: it would be nice to adjust the memory accounting info here,
-         * but calling gf_mem_set_acct_info here is wrong because it bumps
-         * up counts as though this is a new allocation - which it's not.
-         * The consequence of doing nothing here is only that the sizes will be
-         * wrong, but at least the counts won't be.
-        uint32_t           type = 0;
-        xlator_t          *xl = NULL;
-        type = header->type;
-        xl = (xlator_t *) header->xlator;
-        gf_mem_set_acct_info (xl, &new_ptr, size, type, NULL);
-         */
-
-        new_header = (struct mem_header *) new_ptr;
-        *new_header = tmp_header;
-        new_header->size = size;
-
-        new_ptr += sizeof (struct mem_header);
-        /* data follows in this gap of 'size' bytes */
-        *(uint32_t *) (new_ptr + size) = GF_MEM_TRAILER_MAGIC;
-
-        return (void *)new_ptr;
+    return gf_mem_update_acct_info(header->mem_acct, header, size);
 }
 
 int
-gf_vasprintf (char **string_ptr, const char *format, va_list arg)
+gf_vasprintf(char **string_ptr, const char *format, va_list arg)
 {
-        va_list arg_save;
-        char    *str = NULL;
-        int     size = 0;
-        int     rv = 0;
-
-        if (!string_ptr || !format)
-                return -1;
-
-        va_copy (arg_save, arg);
-
-        size = vsnprintf (NULL, 0, format, arg);
-        size++;
-        str = GF_MALLOC (size, gf_common_mt_asprintf);
-        if (str == NULL) {
-                /* log is done in GF_MALLOC itself */
-                va_end (arg_save);
-                return -1;
-        }
-        rv = vsnprintf (str, size, format, arg_save);
-
-        *string_ptr = str;
-        va_end (arg_save);
-        return (rv);
+    va_list arg_save;
+    char *str = NULL;
+    int size = 0;
+    int rv = 0;
+
+    if (!string_ptr || !format)
+        return -1;
+
+    va_copy(arg_save, arg);
+
+    size = vsnprintf(NULL, 0, format, arg);
+    size++;
+    str = GF_MALLOC(size, gf_common_mt_asprintf);
+    if (str == NULL) {
+        /* log is done in GF_MALLOC itself */
+        va_end(arg_save);
+        return -1;
+    }
+    rv = vsnprintf(str, size, format, arg_save);
+
+    *string_ptr = str;
+    va_end(arg_save);
+    return (rv);
 }
 
 int
-gf_asprintf (char **string_ptr, const char *format, ...)
+gf_asprintf(char **string_ptr, const char *format, ...)
 {
-        va_list arg;
-        int     rv = 0;
+    va_list arg;
+    int rv = 0;
 
-        va_start (arg, format);
-        rv = gf_vasprintf (string_ptr, format, arg);
-        va_end (arg);
+    va_start(arg, format);
+    rv = gf_vasprintf(string_ptr, format, arg);
+    va_end(arg);
 
-        return rv;
+    return rv;
 }
 
 #ifdef DEBUG
 void
-__gf_mem_invalidate (void *ptr)
+__gf_mem_invalidate(void *ptr)
 {
-        struct mem_header *header = ptr;
-        void              *end    = NULL;
-
-        struct mem_invalid inval = {
-                .magic = GF_MEM_INVALID_MAGIC,
-                .mem_acct = header->mem_acct,
-                .type = header->type,
-                .size = header->size,
-                .baseaddr = ptr + GF_MEM_HEADER_SIZE,
-        };
-
-        /* calculate the last byte of the allocated area */
-        end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
-
-        /* overwrite the old mem_header */
-        memcpy (ptr, &inval, sizeof (inval));
-        ptr += sizeof (inval);
-
-        /* zero out remaining (old) mem_header bytes) */
-        memset (ptr, 0x00, sizeof (*header) - sizeof (inval));
-        ptr += sizeof (*header) - sizeof (inval);
-
-        /* zero out the first byte of data */
-        *(uint32_t *)(ptr) = 0x00;
-        ptr += 1;
-
-        /* repeated writes of invalid structurein data area */
-        while ((ptr + (sizeof (inval))) < (end - 1)) {
-                memcpy (ptr, &inval, sizeof (inval));
-                ptr += sizeof (inval);
-        }
-
-        /* fill out remaining data area with 0xff */
-        memset (ptr, 0xff, end - ptr);
+    struct mem_header *header = ptr;
+    void *end = NULL;
+
+    struct mem_invalid inval = {
+        .magic = GF_MEM_INVALID_MAGIC,
+        .mem_acct = header->mem_acct,
+        .type = header->type,
+        .size = header->size,
+        .baseaddr = ptr + GF_MEM_HEADER_SIZE,
+    };
+
+    /* calculate the last byte of the allocated area */
+    end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
+
+    /* overwrite the old mem_header */
+    memcpy(ptr, &inval, sizeof(inval));
+    ptr += sizeof(inval);
+
+    /* zero out remaining (old) mem_header bytes) */
+    memset(ptr, 0x00, sizeof(*header) - sizeof(inval));
+    ptr += sizeof(*header) - sizeof(inval);
+
+    /* zero out the first byte of data */
+    *(uint32_t *)(ptr) = 0x00;
+    ptr += 1;
+
+    /* repeated writes of invalid structurein data area */
+    while ((ptr + (sizeof(inval))) < (end - 1)) {
+        memcpy(ptr, &inval, sizeof(inval));
+        ptr += sizeof(inval);
+    }
+
+    /* fill out remaining data area with 0xff */
+    memset(ptr, 0xff, end - ptr);
 }
 #endif /* DEBUG */
 
+/* Coverity taint NOTE: pointers passed to free, would operate on
+pointer-GF_MEM_HEADER_SIZE content and if the pointer was used for any IO
+related purpose, the pointer stands tainted, and hence coverity would consider
+access to the said region as tainted. The following directive to coverity hence
+sanitizes the pointer, thus removing any taint to the same within this function.
+If the pointer is accessed outside the scope of this function without any
+checks on content read from an IO operation, taints will still be reported, and
+needs appropriate addressing. */
+
+/* coverity[ +tainted_data_sanitize : arg-0 ] */
+static void
+gf_free_sanitize(void *s)
+{
+}
+
 void
-__gf_free (void *free_ptr)
+__gf_free(void *free_ptr)
 {
-        void              *ptr = NULL;
-        struct mem_acct   *mem_acct;
-        struct mem_header *header = NULL;
+    void *ptr = NULL;
+    struct mem_acct *mem_acct;
+    struct mem_header *header = NULL;
+    bool last_ref = false;
 
-        if (!THIS->ctx->mem_acct_enable) {
-                FREE (free_ptr);
-                return;
-        }
+    if (!gf_mem_acct_enabled()) {
+        FREE(free_ptr);
+        return;
+    }
 
-        if (!free_ptr)
-                return;
+    if (!free_ptr)
+        return;
 
-        ptr = free_ptr - GF_MEM_HEADER_SIZE;
-        header = (struct mem_header *) ptr;
+    gf_free_sanitize(free_ptr);
+    ptr = free_ptr - GF_MEM_HEADER_SIZE;
+    header = (struct mem_header *)ptr;
 
-        //Possible corruption, assert here
-        GF_ASSERT (GF_MEM_HEADER_MAGIC == header->magic);
+    // Possible corruption, assert here
+    GF_ASSERT(GF_MEM_HEADER_MAGIC == header->magic);
 
-        mem_acct = header->mem_acct;
-        if (!mem_acct) {
-                goto free;
-        }
+    mem_acct = header->mem_acct;
+    if (!mem_acct) {
+        goto free;
+    }
 
-        // This points to a memory overrun
-        GF_ASSERT (GF_MEM_TRAILER_MAGIC ==
-                *(uint32_t *)((char *)free_ptr + header->size));
+    // This points to a memory overrun
+    GF_ASSERT(GF_MEM_TRAILER_MAGIC ==
+              *(uint32_t *)((char *)free_ptr + header->size));
 
-        LOCK (&mem_acct->rec[header->type].lock);
-        {
-                mem_acct->rec[header->type].size -= header->size;
-                mem_acct->rec[header->type].num_allocs--;
-                /* If all the instances are freed up then ensure typestr is set
-                 * to NULL */
-                if (!mem_acct->rec[header->type].num_allocs)
-                        mem_acct->rec[header->type].typestr = NULL;
+    LOCK(&mem_acct->rec[header->type].lock);
+    {
+        mem_acct->rec[header->type].size -= header->size;
+        mem_acct->rec[header->type].num_allocs--;
+        /* If all the instances are freed up then ensure typestr is set
+         * to NULL */
+        if (!mem_acct->rec[header->type].num_allocs) {
+            last_ref = true;
+            mem_acct->rec[header->type].typestr = NULL;
         }
-        UNLOCK (&mem_acct->rec[header->type].lock);
+#ifdef DEBUG
+        list_del(&header->acct_list);
+#endif
+    }
+    UNLOCK(&mem_acct->rec[header->type].lock);
 
-        if (GF_ATOMIC_DEC (mem_acct->refcnt) == 0) {
-                FREE (mem_acct);
-        }
+    if (last_ref) {
+        xlator_mem_acct_unref(mem_acct);
+    }
 
 free:
 #ifdef DEBUG
-        __gf_mem_invalidate (ptr);
+    __gf_mem_invalidate(ptr);
 #endif
 
-        FREE (ptr);
+    FREE(ptr);
 }
 
+#if defined(GF_DISABLE_MEMPOOL)
 
-/*
- * Based on the mem-type that is used for the allocation, GF_FREE can be
- * called, or something more intelligent for the structure can be done.
- *
- * NOTE: this will not work for allocations from a memory pool.  It never did,
- * because those allocations never set the type in the first place.  Any caller
- * that relies on knowing whether a particular type was allocated via a pool or
- * not is *BROKEN*, or will be any time either this module or the module
- * "owning" the type changes.  The proper way to handle this, assuming the
- * caller is not smart enough to call a type-specific free function themselves,
- * would be to create a callback interface where destructors for specific types
- * can be registered so that code *here* (GF_FREE, mem_put, etc.) can do the
- * right thing.  That allows type-specific behavior without creating the kind
- * of fragile coupling that we have now.
- */
-int
-gf_get_mem_type (void *ptr)
+struct mem_pool *
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+                unsigned long count, char *name)
 {
-        struct mem_header *header = NULL;
+    struct mem_pool *new;
 
-        if (!ptr || !THIS->ctx->mem_acct_enable)
-                return 0;
-
-        header = (struct mem_header *) (ptr - GF_MEM_HEADER_SIZE);
+    new = GF_MALLOC(sizeof(struct mem_pool), gf_common_mt_mem_pool);
+    if (!new)
+        return NULL;
 
-        /* Possible corruption, assert here */
-        GF_ASSERT (GF_MEM_HEADER_MAGIC == header->magic);
+    new->sizeof_type = sizeof_type;
+    return new;
+}
 
-        return header->type;
+void
+mem_pool_destroy(struct mem_pool *pool)
+{
+    GF_FREE(pool);
 }
 
+#else /* !GF_DISABLE_MEMPOOL */
 
-#define POOL_SMALLEST   7       /* i.e. 128 */
-#define POOL_LARGEST    20      /* i.e. 1048576 */
-#define NPOOLS          (POOL_LARGEST - POOL_SMALLEST + 1)
+static pthread_mutex_t pool_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_threads;
+static pthread_mutex_t pool_free_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_free_threads;
+static struct mem_pool_shared pools[NPOOLS];
+static size_t pool_list_size;
 
-static pthread_key_t            pool_key;
-static pthread_mutex_t          pool_lock       = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head         pool_threads;
-static pthread_mutex_t          pool_free_lock  = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head         pool_free_threads;
-static struct mem_pool          pools[NPOOLS];
-static size_t                   pool_list_size;
+static __thread per_thread_pool_list_t *thread_pool_list = NULL;
 
-#if !defined(GF_DISABLE_MEMPOOL)
-#define N_COLD_LISTS    1024
+#define N_COLD_LISTS 1024
 #define POOL_SWEEP_SECS 30
 
-static unsigned long            sweep_times;
-static unsigned long            sweep_usecs;
-static unsigned long            frees_to_system;
-
 typedef struct {
-        struct list_head        death_row;
-        pooled_obj_hdr_t        *cold_lists[N_COLD_LISTS];
-        unsigned int            n_cold_lists;
+    pooled_obj_hdr_t *cold_lists[N_COLD_LISTS];
+    unsigned int n_cold_lists;
 } sweep_state_t;
 
 enum init_state {
-        GF_MEMPOOL_INIT_NONE = 0,
-        GF_MEMPOOL_INIT_PREINIT,
-        GF_MEMPOOL_INIT_EARLY,
-        GF_MEMPOOL_INIT_LATE,
-        GF_MEMPOOL_INIT_DESTROY
+    GF_MEMPOOL_INIT_NONE = 0,
+    GF_MEMPOOL_INIT_EARLY,
+    GF_MEMPOOL_INIT_LATE,
+    GF_MEMPOOL_INIT_DESTROY
 };
 
-static enum init_state  init_done       = GF_MEMPOOL_INIT_NONE;
-static pthread_mutex_t  init_mutex      = PTHREAD_MUTEX_INITIALIZER;
-static unsigned int     init_count      = 0;
-static pthread_t        sweeper_tid;
-
+static enum init_state init_done = GF_MEMPOOL_INIT_NONE;
+static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static unsigned int init_count = 0;
+static pthread_t sweeper_tid;
 
-void
-collect_garbage (sweep_state_t *state, per_thread_pool_list_t *pool_list)
+static bool
+collect_garbage(sweep_state_t *state, per_thread_pool_list_t *pool_list)
 {
-        unsigned int            i;
-        per_thread_pool_t       *pt_pool;
+    unsigned int i;
+    per_thread_pool_t *pt_pool;
 
-        if (pool_list->poison) {
-                list_del (&pool_list->thr_list);
-                list_add (&pool_list->thr_list, &state->death_row);
-                return;
-        }
+    (void)pthread_spin_lock(&pool_list->lock);
 
-        if (state->n_cold_lists >= N_COLD_LISTS) {
-                return;
+    for (i = 0; i < NPOOLS; ++i) {
+        pt_pool = &pool_list->pools[i];
+        if (pt_pool->cold_list) {
+            if (state->n_cold_lists >= N_COLD_LISTS) {
+                (void)pthread_spin_unlock(&pool_list->lock);
+                return true;
+            }
+            state->cold_lists[state->n_cold_lists++] = pt_pool->cold_list;
         }
+        pt_pool->cold_list = pt_pool->hot_list;
+        pt_pool->hot_list = NULL;
+    }
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        for (i = 0; i < NPOOLS; ++i) {
-                pt_pool = &pool_list->pools[i];
-                if (pt_pool->cold_list) {
-                        state->cold_lists[state->n_cold_lists++]
-                                = pt_pool->cold_list;
-                }
-                pt_pool->cold_list = pt_pool->hot_list;
-                pt_pool->hot_list = NULL;
-                if (state->n_cold_lists >= N_COLD_LISTS) {
-                        /* We'll just catch up on a future pass. */
-                        break;
-                }
-        }
-        (void) pthread_spin_unlock (&pool_list->lock);
-}
+    (void)pthread_spin_unlock(&pool_list->lock);
 
+    return false;
+}
 
-void
-free_obj_list (pooled_obj_hdr_t *victim)
+static void
+free_obj_list(pooled_obj_hdr_t *victim)
 {
-        pooled_obj_hdr_t        *next;
+    pooled_obj_hdr_t *next;
 
-        while (victim) {
-                next = victim->next;
-                free (victim);
-                victim = next;
-                ++frees_to_system;
-        }
+    while (victim) {
+        next = victim->next;
+        free(victim);
+        victim = next;
+    }
 }
 
-void *
-pool_sweeper (void *arg)
+static void *
+pool_sweeper(void *arg)
 {
-        sweep_state_t           state;
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_list_t  *next_pl;
-        per_thread_pool_t       *pt_pool;
-        unsigned int            i;
-        struct timeval          begin_time;
-        struct timeval          end_time;
-        struct timeval          elapsed;
-
-        /*
-         * This is all a bit inelegant, but the point is to avoid doing
-         * expensive things (like freeing thousands of objects) while holding a
-         * global lock.  Thus, we split each iteration into three passes, with
-         * only the first and fastest holding the lock.
-         */
-
-        for (;;) {
-                sleep (POOL_SWEEP_SECS);
-                (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
-                INIT_LIST_HEAD (&state.death_row);
-                state.n_cold_lists = 0;
-
-                /* First pass: collect stuff that needs our attention. */
-                (void) gettimeofday (&begin_time, NULL);
-                (void) pthread_mutex_lock (&pool_lock);
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_threads, thr_list) {
-                        collect_garbage (&state, pool_list);
-                }
-                (void) pthread_mutex_unlock (&pool_lock);
-                (void) gettimeofday (&end_time, NULL);
-                timersub (&end_time, &begin_time, &elapsed);
-                sweep_usecs += elapsed.tv_sec * 1000000 + elapsed.tv_usec;
-                sweep_times += 1;
-
-                /* Second pass: free dead pools. */
-                (void) pthread_mutex_lock (&pool_free_lock);
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &state.death_row, thr_list) {
-                        for (i = 0; i < NPOOLS; ++i) {
-                                pt_pool = &pool_list->pools[i];
-                                free_obj_list (pt_pool->cold_list);
-                                free_obj_list (pt_pool->hot_list);
-                                pt_pool->hot_list = pt_pool->cold_list = NULL;
-                        }
-                        list_del (&pool_list->thr_list);
-                        list_add (&pool_list->thr_list, &pool_free_threads);
-                }
-                (void) pthread_mutex_unlock (&pool_free_lock);
-
-                /* Third pass: free cold objects from live pools. */
-                for (i = 0; i < state.n_cold_lists; ++i) {
-                        free_obj_list (state.cold_lists[i]);
-                }
-                (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+    sweep_state_t state;
+    per_thread_pool_list_t *pool_list;
+    uint32_t i;
+    bool pending;
+
+    /*
+     * This is all a bit inelegant, but the point is to avoid doing
+     * expensive things (like freeing thousands of objects) while holding a
+     * global lock.  Thus, we split each iteration into two passes, with
+     * only the first and fastest holding the lock.
+     */
+
+    pending = true;
+
+    for (;;) {
+        /* If we know there's pending work to do (or it's the first run), we
+         * do collect garbage more often. */
+        sleep(pending ? POOL_SWEEP_SECS / 5 : POOL_SWEEP_SECS);
+
+        (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+        state.n_cold_lists = 0;
+        pending = false;
+
+        /* First pass: collect stuff that needs our attention. */
+        (void)pthread_mutex_lock(&pool_lock);
+        list_for_each_entry(pool_list, &pool_threads, thr_list)
+        {
+            if (collect_garbage(&state, pool_list)) {
+                pending = true;
+            }
         }
-}
+        (void)pthread_mutex_unlock(&pool_lock);
 
+        /* Second pass: free cold objects from live pools. */
+        for (i = 0; i < state.n_cold_lists; ++i) {
+            free_obj_list(state.cold_lists[i]);
+        }
+        (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    }
+
+    return NULL;
+}
 
 void
-pool_destructor (void *arg)
+mem_pool_thread_destructor(per_thread_pool_list_t *pool_list)
 {
-        per_thread_pool_list_t  *pool_list      = arg;
-
-        /* The pool-sweeper thread will take it from here. */
-        pool_list->poison = 1;
+    per_thread_pool_t *pt_pool;
+    uint32_t i;
+
+    if (pool_list == NULL) {
+        pool_list = thread_pool_list;
+    }
+
+    /* The current thread is terminating. None of the allocated objects will
+     * be used again. We can directly destroy them here instead of delaying
+     * it until the next sweeper loop. */
+    if (pool_list != NULL) {
+        /* Remove pool_list from the global list to avoid that sweeper
+         * could touch it. */
+        pthread_mutex_lock(&pool_lock);
+        list_del(&pool_list->thr_list);
+        pthread_mutex_unlock(&pool_lock);
+
+        /* We need to protect hot/cold changes from potential mem_put() calls
+         * that reference this pool_list. Once poison is set to true, we are
+         * sure that no one else will touch hot/cold lists. The only possible
+         * race is when at the same moment a mem_put() is adding a new item
+         * to the hot list. We protect from that by taking pool_list->lock.
+         * After that we don't need the lock to destroy the hot/cold lists. */
+        pthread_spin_lock(&pool_list->lock);
+        pool_list->poison = true;
+        pthread_spin_unlock(&pool_list->lock);
+
+        for (i = 0; i < NPOOLS; i++) {
+            pt_pool = &pool_list->pools[i];
+
+            free_obj_list(pt_pool->hot_list);
+            pt_pool->hot_list = NULL;
+
+            free_obj_list(pt_pool->cold_list);
+            pt_pool->cold_list = NULL;
+        }
+
+        pthread_mutex_lock(&pool_free_lock);
+        list_add(&pool_list->thr_list, &pool_free_threads);
+        pthread_mutex_unlock(&pool_free_lock);
+
+        thread_pool_list = NULL;
+    }
 }
 
-
 static __attribute__((constructor)) void
-mem_pools_preinit (void)
+mem_pools_preinit(void)
 {
-        unsigned int    i;
+    unsigned int i;
 
-        INIT_LIST_HEAD (&pool_threads);
-        INIT_LIST_HEAD (&pool_free_threads);
+    INIT_LIST_HEAD(&pool_threads);
+    INIT_LIST_HEAD(&pool_free_threads);
 
-        for (i = 0; i < NPOOLS; ++i) {
-                pools[i].power_of_two = POOL_SMALLEST + i;
+    for (i = 0; i < NPOOLS; ++i) {
+        pools[i].power_of_two = POOL_SMALLEST + i;
 
-                GF_ATOMIC_INIT (pools[i].allocs_hot, 0);
-                GF_ATOMIC_INIT (pools[i].allocs_cold, 0);
-                GF_ATOMIC_INIT (pools[i].allocs_stdc, 0);
-                GF_ATOMIC_INIT (pools[i].frees_to_list, 0);
-        }
+        GF_ATOMIC_INIT(pools[i].allocs_hot, 0);
+        GF_ATOMIC_INIT(pools[i].allocs_cold, 0);
+        GF_ATOMIC_INIT(pools[i].allocs_stdc, 0);
+        GF_ATOMIC_INIT(pools[i].frees_to_list, 0);
+    }
 
-        pool_list_size = sizeof (per_thread_pool_list_t)
-                       + sizeof (per_thread_pool_t) * (NPOOLS - 1);
+    pool_list_size = sizeof(per_thread_pool_list_t) +
+                     sizeof(per_thread_pool_t) * (NPOOLS - 1);
 
-        init_done = GF_MEMPOOL_INIT_PREINIT;
+    init_done = GF_MEMPOOL_INIT_EARLY;
 }
 
-/* Use mem_pools_init_early() function for basic initialization. There will be
- * no cleanup done by the pool_sweeper thread until mem_pools_init_late() has
- * been called. Calling mem_get() will be possible after this function has
- * setup the basic structures. */
-void
-mem_pools_init_early (void)
+static __attribute__((destructor)) void
+mem_pools_postfini(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        /* Use a pthread_key destructor to clean up when a thread exits.
-         *
-         * We won't increase init_count here, that is only done when the
-         * pool_sweeper thread is started too.
-         */
-        if (init_done == GF_MEMPOOL_INIT_PREINIT ||
-            init_done == GF_MEMPOOL_INIT_DESTROY) {
-                /* key has not been created yet */
-                if (pthread_key_create (&pool_key, pool_destructor) != 0) {
-                        gf_log ("mem-pool", GF_LOG_CRITICAL,
-                                "failed to initialize mem-pool key");
-                }
-
-                init_done = GF_MEMPOOL_INIT_EARLY;
-        } else {
-                gf_log ("mem-pool", GF_LOG_CRITICAL,
-                        "incorrect order of mem-pool initialization "
-                        "(init_done=%d)", init_done);
-        }
-
-        pthread_mutex_unlock (&init_mutex);
+    /* TODO: This function should destroy all per thread memory pools that
+     *       are still alive, but this is not possible right now because glibc
+     *       starts calling destructors as soon as exit() is called, and
+     *       gluster doesn't ensure that all threads have been stopped before
+     *       calling exit(). Existing threads would crash when they try to use
+     *       memory or they terminate if we destroy things here.
+     *
+     *       When we propertly terminate all threads, we can add the needed
+     *       code here. Till then we need to leave the memory allocated. Most
+     *       probably this function will be executed on process termination,
+     *       so the memory will be released anyway by the system. */
 }
 
-/* Call mem_pools_init_late() once threading has been configured completely.
- * This prevent the pool_sweeper thread from getting killed once the main()
- * thread exits during deamonizing. */
+/* Call mem_pools_init() once threading has been configured completely. This
+ * prevent the pool_sweeper thread from getting killed once the main() thread
+ * exits during deamonizing. */
 void
-mem_pools_init_late (void)
+mem_pools_init(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        if ((init_count++) == 0) {
-                (void) gf_thread_create (&sweeper_tid, NULL, pool_sweeper,
-                                         NULL, "memsweep");
-
-                init_done = GF_MEMPOOL_INIT_LATE;
-        }
-        pthread_mutex_unlock (&init_mutex);
+    pthread_mutex_lock(&init_mutex);
+    if ((init_count++) == 0) {
+        (void)gf_thread_create(&sweeper_tid, NULL, pool_sweeper, NULL,
+                               "memsweep");
+
+        init_done = GF_MEMPOOL_INIT_LATE;
+    }
+    pthread_mutex_unlock(&init_mutex);
 }
 
 void
-mem_pools_fini (void)
+mem_pools_fini(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        switch (init_count) {
+    pthread_mutex_lock(&init_mutex);
+    switch (init_count) {
         case 0:
-                /*
-                 * If init_count is already zero (as e.g. if somebody called
-                 * this before mem_pools_init_late) then the sweeper was
-                 * probably never even started so we don't need to stop it.
-                 * Even if there's some crazy circumstance where there is a
-                 * sweeper but init_count is still zero, that just means we'll
-                 * leave it running.  Not perfect, but far better than any
-                 * known alternative.
-                 */
-                break;
-        case 1:
-        {
-                per_thread_pool_list_t *pool_list;
-                per_thread_pool_list_t *next_pl;
-                unsigned int            i;
-
-                /* if only mem_pools_init_early() was called, sweeper_tid will
-                 * be invalid and the functions will error out. That is not
-                 * critical. In all other cases, the sweeper_tid will be valid
-                 * and the thread gets stopped. */
-                (void) pthread_cancel (sweeper_tid);
-                (void) pthread_join (sweeper_tid, NULL);
-
-                /* Need to clean the pool_key to prevent further usage of the
-                 * per_thread_pool_list_t structure that is stored for each
-                 * thread.
-                 * This also prevents calling pool_destructor() when a thread
-                 * exits, so there is no chance on a use-after-free of the
-                 * per_thread_pool_list_t structure. */
-                (void) pthread_key_delete (pool_key);
-
-                /* free all objects from all pools */
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_threads, thr_list) {
-                        for (i = 0; i < NPOOLS; ++i) {
-                                free_obj_list (pool_list->pools[i].hot_list);
-                                free_obj_list (pool_list->pools[i].cold_list);
-                                pool_list->pools[i].hot_list = NULL;
-                                pool_list->pools[i].cold_list = NULL;
-                        }
-
-                        list_del (&pool_list->thr_list);
-                        FREE (pool_list);
-                }
-
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_free_threads, thr_list) {
-                        list_del (&pool_list->thr_list);
-                        FREE (pool_list);
-                }
-
-                init_done = GF_MEMPOOL_INIT_DESTROY;
-                /* Fall through. */
+            /*
+             * If init_count is already zero (as e.g. if somebody called this
+             * before mem_pools_init) then the sweeper was probably never even
+             * started so we don't need to stop it. Even if there's some crazy
+             * circumstance where there is a sweeper but init_count is still
+             * zero, that just means we'll leave it running. Not perfect, but
+             * far better than any known alternative.
+             */
+            break;
+        case 1: {
+            /* if mem_pools_init() was not called, sweeper_tid will be invalid
+             * and the functions will error out. That is not critical. In all
+             * other cases, the sweeper_tid will be valid and the thread gets
+             * stopped. */
+            (void)pthread_cancel(sweeper_tid);
+            (void)pthread_join(sweeper_tid, NULL);
+
+            /* There could be threads still running in some cases, so we can't
+             * destroy pool_lists in use. We can also not destroy unused
+             * pool_lists because some allocated objects may still be pointing
+             * to them. */
+            mem_pool_thread_destructor(NULL);
+
+            init_done = GF_MEMPOOL_INIT_DESTROY;
+            /* Fall through. */
         }
         default:
-                --init_count;
-        }
-        pthread_mutex_unlock (&init_mutex);
+            --init_count;
+    }
+    pthread_mutex_unlock(&init_mutex);
 }
 
-#else
-void mem_pools_init_early (void) {}
-void mem_pools_init_late (void) {}
-void mem_pools_fini (void) {}
-#endif
-
-struct mem_pool *
-mem_pool_new_fn (unsigned long sizeof_type,
-                 unsigned long count, char *name)
+void
+mem_pool_destroy(struct mem_pool *pool)
 {
-        unsigned int            i;
-
-        if (!sizeof_type) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        for (i = 0; i < NPOOLS; ++i) {
-                if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
-                        return &pools[i];
-                }
-        }
+    if (!pool)
+        return;
 
-        gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                          LG_MSG_INVALID_ARG, "invalid argument");
-        return NULL;
+    /* remove this pool from the owner (glusterfs_ctx_t) */
+    LOCK(&pool->ctx->lock);
+    {
+        list_del(&pool->owner);
+    }
+    UNLOCK(&pool->ctx->lock);
+
+    /* free this pool, but keep the mem_pool_shared */
+    GF_FREE(pool);
+
+    /*
+     * Pools are now permanent, so the mem_pool->pool is kept around. All
+     * of the objects *in* the pool will eventually be freed via the
+     * pool-sweeper thread, and this way we don't have to add a lot of
+     * reference-counting complexity.
+     */
 }
 
-void*
-mem_get0 (struct mem_pool *mem_pool)
+struct mem_pool *
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+                unsigned long count, char *name)
 {
-        void             *ptr = NULL;
+    unsigned long extra_size, size;
+    unsigned int power;
+    struct mem_pool *new = NULL;
+    struct mem_pool_shared *pool = NULL;
+
+    if (!sizeof_type) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
+
+    /* This is the overhead we'll have because of memory accounting for each
+     * memory block. */
+    extra_size = sizeof(pooled_obj_hdr_t);
+
+    /* We need to compute the total space needed to hold the data type and
+     * the header. Given that the smallest block size we have in the pools
+     * is 2^POOL_SMALLEST, we need to take the MAX(size, 2^POOL_SMALLEST).
+     * However, since this value is only needed to compute its rounded
+     * logarithm in base 2, and this only depends on the highest bit set,
+     * we can simply do a bitwise or with the minimum size. We need to
+     * subtract 1 for correct handling of sizes that are exactly a power
+     * of 2. */
+    size = (sizeof_type + extra_size - 1UL) | ((1UL << POOL_SMALLEST) - 1UL);
+
+    /* We compute the logarithm in base 2 rounded up of the resulting size.
+     * This value will identify which pool we need to use from the pools of
+     * powers of 2. This is equivalent to finding the position of the highest
+     * bit set. */
+    power = sizeof(size) * 8 - __builtin_clzl(size);
+    if (power > POOL_LARGEST) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
+    pool = &pools[power - POOL_SMALLEST];
 
-        if (!mem_pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+    new = GF_MALLOC(sizeof(struct mem_pool), gf_common_mt_mem_pool);
+    if (!new)
+        return NULL;
 
-        ptr = mem_get(mem_pool);
+    new->ctx = ctx;
+    new->sizeof_type = sizeof_type;
+    new->count = count;
+    new->name = name;
+    new->xl_name = THIS->name;
+    new->pool = pool;
+    GF_ATOMIC_INIT(new->active, 0);
+#ifdef DEBUG
+    GF_ATOMIC_INIT(new->hit, 0);
+    GF_ATOMIC_INIT(new->miss, 0);
+#endif
+    INIT_LIST_HEAD(&new->owner);
 
-        if (ptr) {
-                memset (ptr, 0, AVAILABLE_SIZE(mem_pool->power_of_two));
-        }
+    LOCK(&ctx->lock);
+    {
+        list_add(&new->owner, &ctx->mempool_list);
+    }
+    UNLOCK(&ctx->lock);
 
-        return ptr;
+    return new;
 }
 
-
 per_thread_pool_list_t *
-mem_get_pool_list (void)
+mem_get_pool_list(void)
 {
-        per_thread_pool_list_t  *pool_list;
-        unsigned int            i;
+    per_thread_pool_list_t *pool_list;
+    unsigned int i;
 
-        pool_list = pthread_getspecific (pool_key);
-        if (pool_list) {
-                return pool_list;
+    pool_list = thread_pool_list;
+    if (pool_list) {
+        return pool_list;
+    }
+
+    (void)pthread_mutex_lock(&pool_free_lock);
+    if (!list_empty(&pool_free_threads)) {
+        pool_list = list_entry(pool_free_threads.next, per_thread_pool_list_t,
+                               thr_list);
+        list_del(&pool_list->thr_list);
+    }
+    (void)pthread_mutex_unlock(&pool_free_lock);
+
+    if (!pool_list) {
+        pool_list = MALLOC(pool_list_size);
+        if (!pool_list) {
+            return NULL;
         }
 
-        (void) pthread_mutex_lock (&pool_free_lock);
-        if (!list_empty (&pool_free_threads)) {
-                pool_list = list_entry (pool_free_threads.next,
-                                        per_thread_pool_list_t, thr_list);
-                list_del (&pool_list->thr_list);
+        INIT_LIST_HEAD(&pool_list->thr_list);
+        (void)pthread_spin_init(&pool_list->lock, PTHREAD_PROCESS_PRIVATE);
+        for (i = 0; i < NPOOLS; ++i) {
+            pool_list->pools[i].parent = &pools[i];
+            pool_list->pools[i].hot_list = NULL;
+            pool_list->pools[i].cold_list = NULL;
         }
-        (void) pthread_mutex_unlock (&pool_free_lock);
+    }
 
-        if (!pool_list) {
-                pool_list = CALLOC (pool_list_size, 1);
-                if (!pool_list) {
-                        return NULL;
-                }
-
-                INIT_LIST_HEAD (&pool_list->thr_list);
-                (void) pthread_spin_init (&pool_list->lock,
-                                          PTHREAD_PROCESS_PRIVATE);
-                for (i = 0; i < NPOOLS; ++i) {
-                        pool_list->pools[i].parent = &pools[i];
-                        pool_list->pools[i].hot_list = NULL;
-                        pool_list->pools[i].cold_list = NULL;
-                }
-        }
+    /* There's no need to take pool_list->lock, because this is already an
+     * atomic operation and we don't need to synchronize it with any change
+     * in hot/cold lists. */
+    pool_list->poison = false;
 
-        (void) pthread_mutex_lock (&pool_lock);
-        pool_list->poison = 0;
-        list_add (&pool_list->thr_list, &pool_threads);
-        (void) pthread_mutex_unlock (&pool_lock);
+    (void)pthread_mutex_lock(&pool_lock);
+    list_add(&pool_list->thr_list, &pool_threads);
+    (void)pthread_mutex_unlock(&pool_lock);
 
-        (void) pthread_setspecific (pool_key, pool_list);
-        return pool_list;
+    thread_pool_list = pool_list;
+
+    /* Ensure that all memory objects associated to the new pool_list are
+     * destroyed when the thread terminates. */
+    gf_thread_needs_cleanup();
+
+    return pool_list;
 }
 
-pooled_obj_hdr_t *
-mem_get_from_pool (per_thread_pool_t *pt_pool)
+static pooled_obj_hdr_t *
+mem_get_from_pool(struct mem_pool *mem_pool)
 {
-        pooled_obj_hdr_t        *retval;
+    per_thread_pool_list_t *pool_list;
+    per_thread_pool_t *pt_pool;
+    pooled_obj_hdr_t *retval;
+#ifdef DEBUG
+    gf_boolean_t hit = _gf_true;
+#endif
 
-        retval = pt_pool->hot_list;
-        if (retval) {
-                GF_ATOMIC_INC (pt_pool->parent->allocs_hot);
-                pt_pool->hot_list = retval->next;
-                return retval;
-        }
+    pool_list = mem_get_pool_list();
+    if (!pool_list || pool_list->poison) {
+        return NULL;
+    }
+
+    pt_pool = &pool_list->pools[mem_pool->pool->power_of_two - POOL_SMALLEST];
+
+    (void)pthread_spin_lock(&pool_list->lock);
 
+    retval = pt_pool->hot_list;
+    if (retval) {
+        pt_pool->hot_list = retval->next;
+        (void)pthread_spin_unlock(&pool_list->lock);
+        GF_ATOMIC_INC(pt_pool->parent->allocs_hot);
+    } else {
         retval = pt_pool->cold_list;
         if (retval) {
-                GF_ATOMIC_INC (pt_pool->parent->allocs_cold);
-                pt_pool->cold_list = retval->next;
-                return retval;
+            pt_pool->cold_list = retval->next;
+            (void)pthread_spin_unlock(&pool_list->lock);
+            GF_ATOMIC_INC(pt_pool->parent->allocs_cold);
+        } else {
+            (void)pthread_spin_unlock(&pool_list->lock);
+            GF_ATOMIC_INC(pt_pool->parent->allocs_stdc);
+            retval = malloc(1 << pt_pool->parent->power_of_two);
+#ifdef DEBUG
+            hit = _gf_false;
+#endif
         }
+    }
+
+    if (retval != NULL) {
+        retval->pool = mem_pool;
+        retval->power_of_two = mem_pool->pool->power_of_two;
+#ifdef DEBUG
+        if (hit == _gf_true)
+            GF_ATOMIC_INC(mem_pool->hit);
+        else
+            GF_ATOMIC_INC(mem_pool->miss);
+#endif
+        retval->magic = GF_MEM_HEADER_MAGIC;
+        retval->pool_list = pool_list;
+    }
 
-        GF_ATOMIC_INC (pt_pool->parent->allocs_stdc);
-        return malloc (1 << pt_pool->parent->power_of_two);
+    return retval;
 }
 
+#endif /* GF_DISABLE_MEMPOOL */
 
 void *
-mem_get (struct mem_pool *mem_pool)
+mem_get0(struct mem_pool *mem_pool)
 {
+    void *ptr = mem_get(mem_pool);
+    if (ptr) {
 #if defined(GF_DISABLE_MEMPOOL)
-        return GF_CALLOC (1, AVAILABLE_SIZE (mem_pool->power_of_two),
-                          gf_common_mt_mem_pool);
+        memset(ptr, 0, mem_pool->sizeof_type);
 #else
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_t       *pt_pool;
-        pooled_obj_hdr_t        *retval;
-
-        if (!mem_pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+        memset(ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
+#endif
+    }
 
-        pool_list = mem_get_pool_list ();
-        if (!pool_list || pool_list->poison) {
-                return NULL;
-        }
+    return ptr;
+}
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        pt_pool = &pool_list->pools[mem_pool->power_of_two-POOL_SMALLEST];
-        retval = mem_get_from_pool (pt_pool);
-        (void) pthread_spin_unlock (&pool_list->lock);
+void *
+mem_get(struct mem_pool *mem_pool)
+{
+    if (!mem_pool) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        if (!retval) {
-                return NULL;
-        }
+#if defined(GF_DISABLE_MEMPOOL)
+    return GF_MALLOC(mem_pool->sizeof_type, gf_common_mt_mem_pool);
+#else
+    pooled_obj_hdr_t *retval = mem_get_from_pool(mem_pool);
+    if (!retval) {
+        return NULL;
+    }
 
-        retval->magic = GF_MEM_HEADER_MAGIC;
-        retval->next = NULL;
-        retval->pool_list = pool_list;;
-        retval->power_of_two = mem_pool->power_of_two;
+    GF_ATOMIC_INC(mem_pool->active);
 
-        return retval + 1;
+    return retval + 1;
 #endif /* GF_DISABLE_MEMPOOL */
 }
 
-
 void
-mem_put (void *ptr)
+mem_put(void *ptr)
 {
 #if defined(GF_DISABLE_MEMPOOL)
-        GF_FREE (ptr);
+    GF_FREE(ptr);
 #else
-        pooled_obj_hdr_t        *hdr;
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_t       *pt_pool;
-
-        if (!ptr) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
+    pooled_obj_hdr_t *hdr;
+    per_thread_pool_list_t *pool_list;
+    per_thread_pool_t *pt_pool;
 
-        hdr = ((pooled_obj_hdr_t *)ptr) - 1;
-        if (hdr->magic != GF_MEM_HEADER_MAGIC) {
-                /* Not one of ours; don't touch it. */
-                return;
-        }
-        pool_list = hdr->pool_list;
-        pt_pool = &pool_list->pools[hdr->power_of_two-POOL_SMALLEST];
+    if (!ptr) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
+
+    hdr = ((pooled_obj_hdr_t *)ptr) - 1;
+    if (hdr->magic != GF_MEM_HEADER_MAGIC) {
+        /* Not one of ours; don't touch it. */
+        return;
+    }
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        hdr->magic = GF_MEM_INVALID_MAGIC;
+    if (!hdr->pool_list) {
+        gf_msg_callingfn("mem-pool", GF_LOG_CRITICAL, EINVAL,
+                         LG_MSG_INVALID_ARG,
+                         "invalid argument hdr->pool_list NULL");
+        return;
+    }
+
+    pool_list = hdr->pool_list;
+    pt_pool = &pool_list->pools[hdr->power_of_two - POOL_SMALLEST];
+
+    if (hdr->pool)
+        GF_ATOMIC_DEC(hdr->pool->active);
+
+    hdr->magic = GF_MEM_INVALID_MAGIC;
+
+    (void)pthread_spin_lock(&pool_list->lock);
+    if (!pool_list->poison) {
         hdr->next = pt_pool->hot_list;
         pt_pool->hot_list = hdr;
-        GF_ATOMIC_INC (pt_pool->parent->frees_to_list);
-        (void) pthread_spin_unlock (&pool_list->lock);
+        (void)pthread_spin_unlock(&pool_list->lock);
+        GF_ATOMIC_INC(pt_pool->parent->frees_to_list);
+    } else {
+        /* If the owner thread of this element has terminated, we simply
+         * release its memory. */
+        (void)pthread_spin_unlock(&pool_list->lock);
+        free(hdr);
+    }
 #endif /* GF_DISABLE_MEMPOOL */
 }
-
-void
-mem_pool_destroy (struct mem_pool *pool)
-{
-        if (!pool)
-                return;
-
-        /*
-         * Pools are now permanent, so this does nothing.  Yes, this means we
-         * can keep allocating from a pool after calling mem_destroy on it, but
-         * that's kind of OK.  All of the objects *in* the pool will eventually
-         * be freed via the pool-sweeper thread, and this way we don't have to
-         * add a lot of reference-counting complexity.
-         */
-}
diff --git a/libglusterfs/src/mem-pool.h b/libglusterfs/src/mem-pool.h
deleted file mode 100644
index 1272ad4d5fc..00000000000
--- a/libglusterfs/src/mem-pool.h
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _MEM_POOL_H_
-#define _MEM_POOL_H_
-
-#include "list.h"
-#include "locking.h"
-#include "atomic.h"
-#include "logging.h"
-#include "mem-types.h"
-#include <stdlib.h>
-#include <inttypes.h>
-#include <string.h>
-#include <stdarg.h>
-
-/*
- * Need this for unit tests since inline functions
- * access memory allocation and need to use the
- * unit test versions
- */
-#ifdef UNIT_TESTING
-#include <stddef.h>
-#include <setjmp.h>
-#include <cmocka.h>
-#endif
-
-#define GF_MEM_TRAILER_SIZE 8
-#define GF_MEM_HEADER_MAGIC  0xCAFEBABE
-#define GF_MEM_TRAILER_MAGIC 0xBAADF00D
-#define GF_MEM_INVALID_MAGIC 0xDEADC0DE
-
-struct mem_acct_rec {
-	const char     *typestr;
-        size_t          size;
-        size_t          max_size;
-        uint32_t        num_allocs;
-        uint32_t        total_allocs;
-        uint32_t        max_num_allocs;
-        gf_lock_t       lock;
-};
-
-struct mem_acct {
-        uint32_t            num_types;
-        gf_atomic_t         refcnt;
-        struct mem_acct_rec rec[0];
-};
-
-struct mem_header {
-        uint32_t        type;
-        size_t          size;
-        struct mem_acct *mem_acct;
-        uint32_t        magic;
-        int             padding[8];
-};
-
-#define GF_MEM_HEADER_SIZE  (sizeof (struct mem_header))
-
-#ifdef DEBUG
-struct mem_invalid {
-        uint32_t  magic;
-        void     *mem_acct;
-        uint32_t  type;
-        size_t    size;
-        void     *baseaddr;
-};
-#endif
-
-void *
-__gf_calloc (size_t cnt, size_t size, uint32_t type, const char *typestr);
-
-void *
-__gf_malloc (size_t size, uint32_t type, const char *typestr);
-
-void *
-__gf_realloc (void *ptr, size_t size);
-
-int
-gf_vasprintf (char **string_ptr, const char *format, va_list arg);
-
-int
-gf_asprintf (char **string_ptr, const char *format, ...);
-
-void
-__gf_free (void *ptr);
-
-int
-gf_get_mem_type (void *ptr);
-
-static inline
-void* __gf_default_malloc (size_t size)
-{
-        void *ptr = NULL;
-
-        ptr = malloc (size);
-        if (!ptr)
-                gf_msg_nomem ("", GF_LOG_ALERT, size);
-
-        return ptr;
-}
-
-static inline
-void* __gf_default_calloc (int cnt, size_t size)
-{
-        void *ptr = NULL;
-
-        ptr = calloc (cnt, size);
-        if (!ptr)
-                gf_msg_nomem ("", GF_LOG_ALERT, (cnt * size));
-
-        return ptr;
-}
-
-static inline
-void* __gf_default_realloc (void *oldptr, size_t size)
-{
-        void *ptr = NULL;
-
-        ptr = realloc (oldptr, size);
-        if (!ptr)
-                gf_msg_nomem ("", GF_LOG_ALERT, size);
-
-        return ptr;
-}
-
-#define MALLOC(size)       __gf_default_malloc(size)
-#define CALLOC(cnt,size)   __gf_default_calloc(cnt,size)
-#define REALLOC(ptr,size)  __gf_default_realloc(ptr,size)
-
-#define FREE(ptr)                                       \
-        do {                                            \
-                if (ptr != NULL) {                      \
-                        free ((void *)ptr);             \
-                        ptr = (void *)0xeeeeeeee;       \
-                }                                       \
-        } while (0)
-
-#define GF_CALLOC(nmemb, size, type) __gf_calloc (nmemb, size, type, #type)
-
-#define GF_MALLOC(size, type)  __gf_malloc (size, type, #type)
-
-#define GF_REALLOC(ptr, size)  __gf_realloc (ptr, size)
-
-#define GF_FREE(free_ptr) __gf_free (free_ptr)
-
-static inline
-char *gf_strndup (const char *src, size_t len)
-{
-        char *dup_str = NULL;
-
-        if (!src) {
-                goto out;
-        }
-
-        dup_str = GF_CALLOC (1, len + 1, gf_common_mt_strdup);
-        if (!dup_str) {
-                goto out;
-        }
-
-        memcpy (dup_str, src, len);
-out:
-        return dup_str;
-}
-
-static inline
-char * gf_strdup (const char *src)
-{
-
-        char    *dup_str = NULL;
-        size_t  len = 0;
-
-        len = strlen (src) + 1;
-
-        dup_str = GF_CALLOC(1, len, gf_common_mt_strdup);
-
-        if (!dup_str)
-                return NULL;
-
-        memcpy (dup_str, src, len);
-
-        return dup_str;
-}
-
-static inline void *
-gf_memdup (const void *src, size_t size)
-{
-        void *dup_mem = NULL;
-
-        dup_mem = GF_CALLOC(1, size, gf_common_mt_strdup);
-        if (!dup_mem)
-                goto out;
-
-        memcpy (dup_mem, src, size);
-
-out:
-        return dup_mem;
-}
-
-typedef struct pooled_obj_hdr {
-        unsigned long                   magic;
-        struct pooled_obj_hdr           *next;
-        struct per_thread_pool_list     *pool_list;
-        unsigned int                    power_of_two;
-} pooled_obj_hdr_t;
-
-#define AVAILABLE_SIZE(p2)      ((1 << (p2)) - sizeof(pooled_obj_hdr_t))
-
-typedef struct per_thread_pool {
-        /* This never changes, so doesn't need a lock. */
-        struct mem_pool         *parent;
-        /* Everything else is protected by our own lock. */
-        pooled_obj_hdr_t        *hot_list;
-        pooled_obj_hdr_t        *cold_list;
-} per_thread_pool_t;
-
-typedef struct per_thread_pool_list {
-        /*
-         * These first two members are protected by the global pool lock.  When
-         * a thread first tries to use any pool, we create one of these.  We
-         * link it into the global list using thr_list so the pool-sweeper
-         * thread can find it, and use pthread_setspecific so this thread can
-         * find it.  When the per-thread destructor runs, we "poison" the pool
-         * list to prevent further allocations.  This also signals to the
-         * pool-sweeper thread that the list should be detached and freed after
-         * the next time it's swept.
-         */
-        struct list_head        thr_list;
-        unsigned int            poison;
-        /*
-         * There's really more than one pool, but the actual number is hidden
-         * in the implementation code so we just make it a single-element array
-         * here.
-         */
-        pthread_spinlock_t      lock;
-        per_thread_pool_t       pools[1];
-} per_thread_pool_list_t;
-
-struct mem_pool {
-        unsigned int            power_of_two;
-        /*
-         * Updates to these are *not* protected by a global lock, so races
-         * could occur and the numbers might be slightly off.  Don't expect
-         * them to line up exactly.  It's the general trends that matter, and
-         * it's not worth the locked-bus-cycle overhead to make these precise.
-         */
-        gf_atomic_t             allocs_hot;
-        gf_atomic_t             allocs_cold;
-        gf_atomic_t             allocs_stdc;
-        gf_atomic_t             frees_to_list;
-};
-
-void mem_pools_init_early (void);  /* basic initialization of memory pools */
-void mem_pools_init_late (void);   /* start the pool_sweeper thread */
-void mem_pools_fini (void);        /* cleanup memory pools */
-
-struct mem_pool *
-mem_pool_new_fn (unsigned long sizeof_type, unsigned long count, char *name);
-
-#define mem_pool_new(type,count) mem_pool_new_fn (sizeof(type), count, #type)
-
-void mem_put (void *ptr);
-void *mem_get (struct mem_pool *pool);
-void *mem_get0 (struct mem_pool *pool);
-
-void mem_pool_destroy (struct mem_pool *pool);
-
-void gf_mem_acct_enable_set (void *ctx);
-
-#endif /* _MEM_POOL_H */
diff --git a/libglusterfs/src/mem-types.h b/libglusterfs/src/mem-types.h
deleted file mode 100644
index 85cb5d2b975..00000000000
--- a/libglusterfs/src/mem-types.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-  Copyright (c) 2008-2016 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __MEM_TYPES_H__
-#define __MEM_TYPES_H__
-
-
-enum gf_common_mem_types_ {
-        gf_common_mt_call_stub_t,
-        gf_common_mt_dnscache6,
-        gf_common_mt_data_pair_t,
-        gf_common_mt_data_t,
-        gf_common_mt_dict_t,
-        gf_common_mt_event_pool,
-        gf_common_mt_reg,
-        gf_common_mt_pollfd,
-        gf_common_mt_epoll_event,
-        gf_common_mt_fdentry_t,
-        gf_common_mt_fdtable_t,
-        gf_common_mt_fd_t,
-        gf_common_mt_fd_ctx,
-        gf_common_mt_gf_dirent_t,
-        gf_common_mt_glusterfs_ctx_t,
-        gf_common_mt_dentry_t,
-        gf_common_mt_inode_t,
-        gf_common_mt_inode_ctx,
-        gf_common_mt_list_head,
-        gf_common_mt_inode_table_t,
-        gf_common_mt_xlator_t,
-        gf_common_mt_xlator_list_t,
-        gf_common_mt_log_msg,
-        gf_common_mt_client_log,
-        gf_common_mt_volume_opt_list_t,
-        gf_common_mt_gf_hdr_common_t,
-        gf_common_mt_call_frame_t,
-        gf_common_mt_call_stack_t,
-        gf_common_mt_gf_timer_t,
-        gf_common_mt_gf_timer_registry_t,
-        gf_common_mt_transport,
-        gf_common_mt_transport_msg,
-        gf_common_mt_auth_handle_t,
-        gf_common_mt_iobuf,
-        gf_common_mt_iobuf_arena,
-        gf_common_mt_iobref,
-        gf_common_mt_iobuf_pool,
-        gf_common_mt_iovec,
-        gf_common_mt_memdup,
-        gf_common_mt_asprintf,
-        gf_common_mt_strdup,
-        gf_common_mt_socket_private_t,
-        gf_common_mt_ioq,
-        gf_common_mt_transport_t,
-        gf_common_mt_socket_local_t,
-        gf_common_mt_char,
-        gf_common_mt_rbthash_table_t,
-        gf_common_mt_rbthash_bucket,
-#if defined(GF_DISABLE_MEMPOOL)
-        gf_common_mt_mem_pool,
-#endif
-        gf_common_mt_long,
-        gf_common_mt_rpcsvc_auth_list,
-        gf_common_mt_rpcsvc_t,
-        gf_common_mt_rpcsvc_conn_t,
-        gf_common_mt_rpcsvc_program_t,
-        gf_common_mt_rpcsvc_listener_t,
-        gf_common_mt_rpcsvc_wrapper_t,
-        gf_common_mt_rpcsvc_stage_t,
-        gf_common_mt_rpcclnt_t,
-        gf_common_mt_rpcclnt_savedframe_t,
-        gf_common_mt_rpc_trans_t,
-        gf_common_mt_rpc_trans_pollin_t,
-        gf_common_mt_rpc_trans_handover_t,
-        gf_common_mt_rpc_trans_reqinfo_t,
-        gf_common_mt_rpc_trans_rsp_t,
-        gf_common_mt_glusterfs_graph_t,
-        gf_common_mt_rdma_private_t,
-        gf_common_mt_rdma_ioq_t,
-        gf_common_mt_rpc_transport_t,
-        gf_common_mt_rdma_local_t,
-        gf_common_mt_rdma_post_t,
-        gf_common_mt_qpent,
-        gf_common_mt_rdma_device_t,
-        gf_common_mt_rdma_context_t,
-        gf_common_mt_sge,
-        gf_common_mt_rpcclnt_cb_program_t,
-        gf_common_mt_libxl_marker_local,
-        gf_common_mt_graph_buf,
-        gf_common_mt_trie_trie,
-        gf_common_mt_trie_data,
-        gf_common_mt_trie_node,
-        gf_common_mt_trie_buf,
-        gf_common_mt_trie_end,
-        gf_common_mt_run_argv,
-        gf_common_mt_run_logbuf,
-        gf_common_mt_fd_lk_ctx_t,
-        gf_common_mt_fd_lk_ctx_node_t,
-        gf_common_mt_buffer_t,
-        gf_common_mt_circular_buffer_t,
-        gf_common_mt_eh_t,
-        gf_common_mt_store_handle_t,
-        gf_common_mt_store_iter_t,
-        gf_common_mt_drc_client_t,
-        gf_common_mt_drc_globals_t,
-        gf_common_mt_drc_rbtree_node_t,
-        gf_common_mt_iov_base_t,
-        gf_common_mt_groups_t,
-        gf_common_mt_cliententry_t,
-        gf_common_mt_clienttable_t,
-        gf_common_mt_client_t,
-        gf_common_mt_client_ctx,
-        gf_common_mt_lock_table,
-        gf_common_mt_locker,
-        gf_common_mt_auxgids,
-        gf_common_mt_syncopctx,
-        gf_common_mt_iobrefs,
-        gf_common_mt_gsync_status_t,
-        gf_common_mt_uuid_t,
-        gf_common_mt_mgmt_v3_lock_obj_t,
-        gf_common_mt_txn_opinfo_obj_t,
-	gf_common_mt_strfd_t,
-	gf_common_mt_strfd_data_t,
-        gf_common_mt_regex_t,
-        gf_common_mt_ereg,
-        gf_common_mt_wr,
-        gf_common_mt_rdma_arena_mr,
-        gf_common_mt_dnscache             = 115,
-        gf_common_mt_dnscache_entry       = 116,
-        gf_common_mt_parser_t,
-        gf_common_quota_meta_t,
-        /*related to gfdb library*/
-        gfdb_mt_time_t,
-        gf_mt_sql_cbk_args_t,
-        gf_mt_gfdb_query_record_t,
-        gf_mt_gfdb_link_info_t,
-        gf_mt_gfdb_db_operations_t,
-        gf_mt_sql_connection_t,
-        gf_mt_sql_conn_node_t,
-        gf_mt_db_conn_node_t,
-        gf_mt_db_connection_t,
-        gfdb_mt_db_record_t,
-        /*related to gfdb library*/
-        gf_common_mt_rbuf_t,
-        gf_common_mt_rlist_t,
-        gf_common_mt_rvec_t,
-        /* glusterd can load the nfs-xlator dynamically and needs these two */
-        gf_common_mt_nfs_netgroups,
-        gf_common_mt_nfs_exports,
-        gf_common_mt_gf_brick_spec_t,
-        gf_common_mt_gf_timer_entry_t,
-        gf_common_mt_int,
-        gf_common_mt_pointer,
-        gf_common_mt_synctask,
-        gf_common_mt_syncstack,
-        gf_common_mt_syncenv,
-        gf_common_mt_scan_data,
-        gf_common_list_node,
-        gf_mt_default_args_t,
-        gf_mt_default_args_cbk_t,
-        /*used for compound fops*/
-        gf_mt_compound_req_t,
-        gf_mt_compound_rsp_t,
-        gf_common_mt_tw_ctx,
-        gf_common_mt_tw_timer_list,
-        /*lock migration*/
-        gf_common_mt_lock_mig,
-        /* throttle */
-        gf_common_mt_tbf_t,
-        gf_common_mt_tbf_bucket_t,
-        gf_common_mt_tbf_throttle_t,
-        gf_common_mt_pthread_t,
-        gf_common_ping_local_t,
-        gf_common_volfile_t,
-        gf_common_mt_mgmt_v3_lock_timer_t,
-        gf_common_mt_end
-};
-#endif
diff --git a/libglusterfs/src/monitoring.c b/libglusterfs/src/monitoring.c
new file mode 100644
index 00000000000..fbb68dc8622
--- /dev/null
+++ b/libglusterfs/src/monitoring.c
@@ -0,0 +1,282 @@
+/*
+  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#include "glusterfs/monitoring.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/syscall.h"
+
+#include <stdlib.h>
+
+static void
+dump_mem_acct_details(xlator_t *xl, int fd)
+{
+    struct mem_acct_rec *mem_rec;
+    int i = 0;
+
+    if (!xl || !xl->mem_acct || (xl->ctx->active != xl->graph))
+        return;
+
+    dprintf(fd, "# %s.%s.total.num_types %d\n", xl->type, xl->name,
+            xl->mem_acct->num_types);
+
+    dprintf(fd,
+            "# type, in-use-size, in-use-units, max-size, "
+            "max-units, total-allocs\n");
+
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        mem_rec = &xl->mem_acct->rec[i];
+        if (mem_rec->num_allocs == 0)
+            continue;
+        dprintf(fd, "# %s, %" PRIu64 ", %u, %" PRIu64 ", %u, %" PRIu64 "\n",
+                mem_rec->typestr, mem_rec->size, mem_rec->num_allocs,
+                mem_rec->max_size, mem_rec->max_num_allocs,
+                mem_rec->total_allocs);
+    }
+}
+
+static void
+dump_global_memory_accounting(int fd)
+{
+#if MEMORY_ACCOUNTING_STATS
+    int i = 0;
+    uint64_t count = 0;
+
+    uint64_t tcalloc = GF_ATOMIC_GET(gf_memory_stat_counts.total_calloc);
+    uint64_t tmalloc = GF_ATOMIC_GET(gf_memory_stat_counts.total_malloc);
+    uint64_t tfree = GF_ATOMIC_GET(gf_memory_stat_counts.total_free);
+
+    dprintf(fd, "memory.total.calloc %lu\n", tcalloc);
+    dprintf(fd, "memory.total.malloc %lu\n", tmalloc);
+    dprintf(fd, "memory.total.realloc %lu\n",
+            GF_ATOMIC_GET(gf_memory_stat_counts.total_realloc));
+    dprintf(fd, "memory.total.free %lu\n", tfree);
+    dprintf(fd, "memory.total.in-use %lu\n", ((tcalloc + tmalloc) - tfree));
+
+    for (i = 0; i < GF_BLK_MAX_VALUE; i++) {
+        count = GF_ATOMIC_GET(gf_memory_stat_counts.blk_size[i]);
+        dprintf(fd, "memory.total.blk_size.%s %lu\n",
+                gf_mem_stats_blk[i].blk_size_str, count);
+    }
+
+    dprintf(fd, "#----\n");
+#endif
+
+    /* This is not a metric to be watched in admin guide,
+       but keeping it here till we resolve all leak-issues
+       would be great */
+}
+
+static void
+dump_latency_and_count(xlator_t *xl, int fd)
+{
+    int32_t index = 0;
+    uint64_t fop;
+    uint64_t cbk;
+    uint64_t count;
+
+    if (xl->winds) {
+        dprintf(fd, "%s.total.pending-winds.count %" PRIu64 "\n", xl->name,
+                xl->winds);
+    }
+
+    /* Need 'fuse' data, and don't need all the old graph info */
+    if ((xl != xl->ctx->master) && (xl->ctx->active != xl->graph))
+        return;
+
+    count = GF_ATOMIC_GET(xl->stats.total.count);
+    dprintf(fd, "%s.total.fop-count %" PRIu64 "\n", xl->name, count);
+
+    count = GF_ATOMIC_GET(xl->stats.interval.count);
+    dprintf(fd, "%s.interval.fop-count %" PRIu64 "\n", xl->name, count);
+    GF_ATOMIC_INIT(xl->stats.interval.count, 0);
+
+    for (index = 0; index < GF_FOP_MAXVALUE; index++) {
+        fop = GF_ATOMIC_GET(xl->stats.total.metrics[index].fop);
+        if (fop) {
+            dprintf(fd, "%s.total.%s.count %" PRIu64 "\n", xl->name,
+                    gf_fop_list[index], fop);
+        }
+        fop = GF_ATOMIC_GET(xl->stats.interval.metrics[index].fop);
+        if (fop) {
+            dprintf(fd, "%s.interval.%s.count %" PRIu64 "\n", xl->name,
+                    gf_fop_list[index], fop);
+        }
+        cbk = GF_ATOMIC_GET(xl->stats.interval.metrics[index].cbk);
+        if (cbk) {
+            dprintf(fd, "%s.interval.%s.fail_count %" PRIu64 "\n", xl->name,
+                    gf_fop_list[index], cbk);
+        }
+        if (xl->stats.interval.latencies[index].count != 0) {
+            dprintf(fd, "%s.interval.%s.latency %lf\n", xl->name,
+                    gf_fop_list[index],
+                    (((double)xl->stats.interval.latencies[index].total) /
+                     xl->stats.interval.latencies[index].count));
+            dprintf(fd, "%s.interval.%s.max %" PRIu64 "\n", xl->name,
+                    gf_fop_list[index],
+                    xl->stats.interval.latencies[index].max);
+            dprintf(fd, "%s.interval.%s.min %" PRIu64 "\n", xl->name,
+                    gf_fop_list[index],
+                    xl->stats.interval.latencies[index].min);
+        }
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[index].cbk, 0);
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[index].fop, 0);
+    }
+    memset(xl->stats.interval.latencies, 0,
+           sizeof(xl->stats.interval.latencies));
+}
+
+static inline void
+dump_call_stack_details(glusterfs_ctx_t *ctx, int fd)
+{
+    dprintf(fd, "total.stack.count %" PRIu64 "\n",
+            GF_ATOMIC_GET(ctx->pool->total_count));
+    dprintf(fd, "total.stack.in-flight %" PRIu64 "\n", ctx->pool->cnt);
+}
+
+static inline void
+dump_dict_details(glusterfs_ctx_t *ctx, int fd)
+{
+    uint64_t total_dicts = 0;
+    uint64_t total_pairs = 0;
+
+    total_dicts = GF_ATOMIC_GET(ctx->stats.total_dicts_used);
+    total_pairs = GF_ATOMIC_GET(ctx->stats.total_pairs_used);
+
+    dprintf(fd, "total.dict.max-pairs-per %" PRIu64 "\n",
+            GF_ATOMIC_GET(ctx->stats.max_dict_pairs));
+    dprintf(fd, "total.dict.pairs-used %" PRIu64 "\n", total_pairs);
+    dprintf(fd, "total.dict.used %" PRIu64 "\n", total_dicts);
+    dprintf(fd, "total.dict.average-pairs %" PRIu64 "\n",
+            (total_pairs / total_dicts));
+}
+
+static void
+dump_inode_stats(glusterfs_ctx_t *ctx, int fd)
+{
+}
+
+static void
+dump_global_metrics(glusterfs_ctx_t *ctx, int fd)
+{
+    struct timeval tv;
+    time_t nowtime;
+    struct tm *nowtm;
+    char tmbuf[64] = {
+        0,
+    };
+
+    gettimeofday(&tv, NULL);
+    nowtime = tv.tv_sec;
+    nowtm = localtime(&nowtime);
+    strftime(tmbuf, sizeof tmbuf, "%Y-%m-%d %H:%M:%S", nowtm);
+
+    /* Let every file have information on which process dumped info */
+    dprintf(fd, "## %s\n", ctx->cmdlinestr);
+    dprintf(fd, "### %s\n", tmbuf);
+    dprintf(fd, "### BrickName: %s\n", ctx->cmd_args.brick_name);
+    dprintf(fd, "### MountName: %s\n", ctx->cmd_args.mount_point);
+    dprintf(fd, "### VolumeName: %s\n", ctx->cmd_args.volume_name);
+
+    /* Dump memory accounting */
+    dump_global_memory_accounting(fd);
+    dprintf(fd, "# -----\n");
+
+    dump_call_stack_details(ctx, fd);
+    dump_dict_details(ctx, fd);
+    dprintf(fd, "# -----\n");
+
+    dump_inode_stats(ctx, fd);
+    dprintf(fd, "# -----\n");
+}
+
+static void
+dump_xl_metrics(glusterfs_ctx_t *ctx, int fd)
+{
+    xlator_t *xl;
+
+    xl = ctx->active->top;
+
+    while (xl) {
+        dump_latency_and_count(xl, fd);
+        dump_mem_acct_details(xl, fd);
+        if (xl->dump_metrics)
+            xl->dump_metrics(xl, fd);
+        xl = xl->next;
+    }
+
+    if (ctx->master) {
+        xl = ctx->master;
+
+        dump_latency_and_count(xl, fd);
+        dump_mem_acct_details(xl, fd);
+        if (xl->dump_metrics)
+            xl->dump_metrics(xl, fd);
+    }
+
+    return;
+}
+
+char *
+gf_monitor_metrics(glusterfs_ctx_t *ctx)
+{
+    int ret = -1;
+    int fd = 0;
+    char *filepath = NULL, *dumppath = NULL;
+
+    gf_msg_trace("monitoring", 0, "received monitoring request (sig:USR2)");
+
+    dumppath = ctx->config.metrics_dumppath;
+    if (dumppath == NULL) {
+        dumppath = GLUSTER_METRICS_DIR;
+    }
+    ret = mkdir_p(dumppath, 0755, true);
+    if (ret) {
+        /* EEXIST is handled in mkdir_p() itself */
+        gf_msg("monitoring", GF_LOG_ERROR, 0, LG_MSG_STRDUP_ERROR,
+               "failed to create metrics dir %s (%s)", dumppath,
+               strerror(errno));
+        return NULL;
+    }
+
+    ret = gf_asprintf(&filepath, "%s/gmetrics.XXXXXX", dumppath);
+    if (ret < 0) {
+        return NULL;
+    }
+
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(filepath);
+    if (fd < 0) {
+        gf_msg("monitoring", GF_LOG_ERROR, 0, LG_MSG_STRDUP_ERROR,
+               "failed to open tmp file %s (%s)", filepath, strerror(errno));
+        GF_FREE(filepath);
+        return NULL;
+    }
+
+    dump_global_metrics(ctx, fd);
+
+    dump_xl_metrics(ctx, fd);
+
+    /* This below line is used just to capture any errors with dprintf() */
+    ret = dprintf(fd, "\n# End of metrics\n");
+    if (ret < 0) {
+        gf_msg("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
+               "dprintf() failed: %s", strerror(errno));
+    }
+
+    ret = sys_fsync(fd);
+    if (ret < 0) {
+        gf_msg("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
+               "fsync() failed: %s", strerror(errno));
+    }
+    sys_close(fd);
+
+    /* Figure this out, not happy with returning this string */
+    return filepath;
+}
diff --git a/libglusterfs/src/options.c b/libglusterfs/src/options.c
index a0f04c772e8..f6b5aa0ea23 100644
--- a/libglusterfs/src/options.c
+++ b/libglusterfs/src/options.c
@@ -10,1244 +10,1212 @@
 
 #include <fnmatch.h>
 
-#include "xlator.h"
-#include "defaults.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/defaults.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 #define GF_OPTION_LIST_EMPTY(_opt) (_opt->value[0] == NULL)
 
-
 static int
-xlator_option_validate_path (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_path(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        int   ret = -1;
-        char  errstr[256];
-
-        if (strstr (value, "../")) {
-                snprintf (errstr, 256,
-                          "invalid path given '%s'",
-                          value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-                /* Make sure the given path is valid */
-        if (value[0] != '/') {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not an "
-                          "absolute path name",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char errstr[256];
+
+    if (strstr(value, "../")) {
+        snprintf(errstr, 256, "invalid path given '%s'", value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    /* Make sure the given path is valid */
+    if (value[0] != '/') {
+        snprintf(errstr, 256,
+                 "option %s %s: '%s' is not an "
+                 "absolute path name",
+                 key, value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
 static int
-xlator_option_validate_int (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_int(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        long long inputll = 0;
-        unsigned long long uinputll = 0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2longlong (value, &inputll) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        /* Handle '-0' */
-        if ((inputll == 0) && (gf_string2ulonglong (value, &uinputll) != 0)) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        if ((opt->min == 0) && (opt->max == 0) &&
-            (opt->validate == GF_OPT_VALIDATE_BOTH)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
+    long long inputll = 0;
+    unsigned long long uinputll = 0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2longlong(value, &inputll) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    /* Handle '-0' */
+    if ((inputll == 0) && (gf_string2ulonglong(value, &uinputll) != 0)) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0) &&
+        (opt->validate == GF_OPT_VALIDATE_BOTH)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        ret = 0;
+        goto out;
+    }
+
+    if (opt->validate == GF_OPT_VALIDATE_MIN) {
+        if (inputll < opt->min) {
+            snprintf(errstr, 256,
+                     "'%lld' in 'option %s %s' is smaller than "
+                     "minimum value '%.0f'",
+                     inputll, key, value, opt->min);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
-
-        if (opt->validate == GF_OPT_VALIDATE_MIN) {
-                if (inputll < opt->min) {
-                        snprintf (errstr, 256,
-                                  "'%lld' in 'option %s %s' is smaller than "
-                                  "minimum value '%.0f'", inputll, key,
-                                  value, opt->min);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
-                if (inputll > opt->max) {
-                        snprintf (errstr, 256,
-                                  "'%lld' in 'option %s %s' is greater than "
-                                  "maximum value '%.0f'", inputll, key,
-                                  value, opt->max);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if ((inputll < opt->min) || (inputll > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%lld' in 'option %s %s' is out of range "
-                          "[%.0f - %.0f]",
-                          inputll, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+    } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
+        if (inputll > opt->max) {
+            snprintf(errstr, 256,
+                     "'%lld' in 'option %s %s' is greater than "
+                     "maximum value '%.0f'",
+                     inputll, key, value, opt->max);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
-
-        ret = 0;
+    } else if ((inputll < opt->min) || (inputll > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%lld' in 'option %s %s' is out of range "
+                 "[%.0f - %.0f]",
+                 inputll, key, value, opt->min, opt->max);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_sizet (xlator_t *xl, const char *key, const char *value,
-                              volume_option_t *opt, char **op_errstr)
+xlator_option_validate_sizet(xlator_t *xl, const char *key, const char *value,
+                             volume_option_t *opt, char **op_errstr)
 {
-        size_t  size = 0;
-        int       ret = 0;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2bytesize_size (value, &size) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                ret = -1;
-                goto out;
-        }
-
-        if ((opt->min == 0) && (opt->max == 0)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                goto out;
-        }
-
-        if ((size < opt->min) || (size > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%" GF_PRI_SIZET "' in 'option %s %s' "
-                          "is out of range [%.0f - %.0f]",
-                          size, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0,
-                        LG_MSG_OUT_OF_RANGE, "%s", errstr);
-                ret = -1;
-        }
+    uint64_t size = 0;
+    int ret = 0;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2bytesize_uint64(value, &size) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        ret = -1;
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        goto out;
+    }
+
+    if ((size < opt->min) || (size > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%" PRIu64
+                 "' in 'option %s %s' is out of range [%.0f - %.0f]",
+                 size, key, value, opt->min, opt->max);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                errstr, NULL);
+        ret = -1;
+    }
 
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_bool (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_bool(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        gf_boolean_t is_valid;
-
-
-        /* Check if the value is one of
-           '0|1|on|off|no|yes|true|false|enable|disable' */
-
-        if (gf_string2boolean (value, &is_valid) != 0) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not a valid boolean value",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char errstr[256];
+    gf_boolean_t is_valid;
+
+    /* Check if the value is one of
+       '0|1|on|off|no|yes|true|false|enable|disable' */
+
+    if (gf_string2boolean(value, &is_valid) != 0) {
+        snprintf(errstr, 256, "option %s %s: '%s' is not a valid boolean value",
+                 key, value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_xlator (xlator_t *xl, const char *key, const char *value,
-                               volume_option_t *opt, char **op_errstr)
+xlator_option_validate_xlator(xlator_t *xl, const char *key, const char *value,
+                              volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        xlator_t    *xlopt = NULL;
-
-
-        /* Check if the value is one of the xlators */
-        xlopt = xl;
-        while (xlopt->prev)
-                xlopt = xlopt->prev;
-
-        while (xlopt) {
-                if (strcmp (value, xlopt->name) == 0) {
-                        ret = 0;
-                        break;
-                }
-                xlopt = xlopt->next;
+    int ret = -1;
+    char errstr[256];
+    xlator_t *xlopt = NULL;
+
+    /* Check if the value is one of the xlators */
+    xlopt = xl;
+    while (xlopt->prev)
+        xlopt = xlopt->prev;
+
+    while (xlopt) {
+        if (strcmp(value, xlopt->name) == 0) {
+            ret = 0;
+            break;
         }
-
-        if (!xlopt) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not a valid volume name",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        ret = 0;
+        xlopt = xlopt->next;
+    }
+
+    if (!xlopt) {
+        snprintf(errstr, 256, "option %s %s: '%s' is not a valid volume name",
+                 key, value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-void
-set_error_str (char *errstr, size_t len, volume_option_t *opt, const char *key,
-               const char *value)
+static void
+set_error_str(char *errstr, size_t len, volume_option_t *opt, const char *key,
+              const char *value)
 {
-        int i   = 0;
-        int ret = 0;
-
-        ret = snprintf (errstr, len, "option %s %s: '%s' is not valid "
-                        "(possible options are ", key, value, value);
-
-        for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i];) {
-                ret += snprintf (errstr + ret, len - ret, "%s", opt->value[i]);
-                if (((++i) < ZR_OPTION_MAX_ARRAY_SIZE) &&
-                    (opt->value[i]))
-                        ret += snprintf (errstr + ret, len - ret, ", ");
-                else
-                        ret += snprintf (errstr + ret, len - ret, ".)");
-        }
-        return;
+    int i = 0;
+    int ret = 0;
+
+    ret = snprintf(errstr, len,
+                   "option %s %s: '%s' is not valid "
+                   "(possible options are ",
+                   key, value, value);
+
+    for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i];) {
+        ret += snprintf(errstr + ret, len - ret, "%s", opt->value[i]);
+        if (((++i) < ZR_OPTION_MAX_ARRAY_SIZE) && (opt->value[i]))
+            ret += snprintf(errstr + ret, len - ret, ", ");
+        else
+            ret += snprintf(errstr + ret, len - ret, ".)");
+    }
+    return;
 }
 
-int
-is_all_whitespaces (const char *value)
+static int
+is_all_whitespaces(const char *value)
 {
-        int i = 0;
-        size_t len = 0;
+    int i = 0;
 
-        if (value == NULL)
-                return -1;
-
-        len = strlen (value);
+    if (value == NULL)
+        return -1;
 
-        for (i = 0; i < len; i++) {
-                if (value[i] == ' ')
-                        continue;
-                else
-                        return 0;
-        }
+    for (i = 0; value[i] != '\0'; i++) {
+        if (value[i] == ' ')
+            continue;
+        else
+            return 0;
+    }
 
-        return 1;
+    return 1;
 }
 
 static int
-xlator_option_validate_str (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_str(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        int          i = 0;
-        char         errstr[4096] = {0,};
-
-        /* Check if the '*str' is valid */
-        if (GF_OPTION_LIST_EMPTY(opt)) {
-                ret = 0;
-                goto out;
-        }
-
-        if (is_all_whitespaces (value) == 1)
-                goto out;
-
-        for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i]; i++) {
- #ifdef  GF_DARWIN_HOST_OS
-                if (fnmatch (opt->value[i], value, 0) == 0) {
-                        ret = 0;
-                        break;
-                }
- #else
-                if (fnmatch (opt->value[i], value, FNM_EXTMATCH) == 0) {
-                        ret = 0;
-                        break;
-                }
- #endif
-        }
-
-        if ((i == ZR_OPTION_MAX_ARRAY_SIZE) || (!opt->value[i]))
-                goto out;
-                /* enter here only if
-                 * 1. reached end of opt->value array and haven't
-                 *    validated input
-                 *                      OR
-                 * 2. valid input list is less than
-                 *    ZR_OPTION_MAX_ARRAY_SIZE and input has not
-                 *    matched all possible input values.
-                 */
+    int ret = -1;
+    int i = 0;
 
+    /* Check if the '*str' is valid */
+    if (GF_OPTION_LIST_EMPTY(opt)) {
         ret = 0;
+        goto out;
+    }
 
-out:
-        if (ret) {
-                set_error_str (errstr, sizeof (errstr), opt, key, value);
-
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-        return ret;
-}
-
+    if (is_all_whitespaces(value) == 1)
+        goto out;
 
-static int
-xlator_option_validate_percent (xlator_t *xl, const char *key, const char *value,
-                                volume_option_t *opt, char **op_errstr)
-{
-        double    percent = 0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check if the value is valid percentage */
-        if (gf_string2percent (value, &percent) != 0) {
-                snprintf (errstr, 256,
-                          "invalid percent format \"%s\" in \"option %s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
+    for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i]; i++) {
+#ifdef GF_DARWIN_HOST_OS
+        if (fnmatch(opt->value[i], value, 0) == 0) {
+            ret = 0;
+            break;
         }
-
-        if ((percent < 0.0) || (percent > 100.0)) {
-                snprintf (errstr, 256,
-                          "'%lf' in 'option %s %s' is out of range [0 - 100]",
-                          percent, key, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+#else
+        if (fnmatch(opt->value[i], value, FNM_EXTMATCH) == 0) {
+            ret = 0;
+            break;
         }
+#endif
+    }
+
+    if ((i == ZR_OPTION_MAX_ARRAY_SIZE) || (!opt->value[i]))
+        goto out;
+    /* enter here only if
+     * 1. reached end of opt->value array and haven't
+     *    validated input
+     *                      OR
+     * 2. valid input list is less than
+     *    ZR_OPTION_MAX_ARRAY_SIZE and input has not
+     *    matched all possible input values.
+     */
+
+    ret = 0;
 
-        ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret) {
+        char errstr[4096];
+        set_error_str(errstr, sizeof(errstr), opt, key, value);
+
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    return ret;
 }
 
 static int
-xlator_option_validate_fractional_value (const char *value)
+xlator_option_validate_percent(xlator_t *xl, const char *key, const char *value,
+                               volume_option_t *opt, char **op_errstr)
 {
-        const char *s   = NULL;
-        int        ret  = 0;
-
-        s = strchr (value, '.');
-        if (s) {
-                for (s = s+1; *s != '\0'; s++) {
-                        if (*s != '0') {
-                                return -1;
-                        }
-                }
-        }
-
-        return ret;
+    double percent = 0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check if the value is valid percentage */
+    if (gf_string2percent(value, &percent) != 0) {
+        snprintf(errstr, 256, "invalid percent format \"%s\" in \"option %s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    if ((percent < 0.0) || (percent > 100.0)) {
+        snprintf(errstr, 256,
+                 "'%lf' in 'option %s %s' is out of range [0 - 100]", percent,
+                 key, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
 static int
-xlator_option_validate_percent_or_sizet (xlator_t *xl, const char *key,
-                                         const char *value,
-                                         volume_option_t *opt, char **op_errstr)
+xlator_option_validate_fractional_value(const char *value)
 {
-        int               ret = -1;
-        char              errstr[256];
-        double            size = 0;
-	gf_boolean_t is_percent = _gf_false;
-
-	if (gf_string2percent_or_bytesize (value, &size, &is_percent) == 0) {
-		if (is_percent) {
-                        if ((size < 0.0) || (size > 100.0)) {
-                                snprintf (errstr, sizeof (errstr),
-                                          "'%lf' in 'option %s %s' is out"
-                                          " of range [0 - 100]", size, key,
-                                          value);
-                                gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                        LG_MSG_OUT_OF_RANGE, "%s", errstr);
-                                goto out;
-                        }
-			ret = 0;
-			goto out;
-		}
-
-                /*Input value of size(in byte) should not be fractional*/
-                ret = xlator_option_validate_fractional_value (value);
-                if (ret) {
-                        snprintf (errstr, sizeof (errstr), "'%lf' in 'option %s"
-                                  " %s' should not be fractional value. Use "
-                                  "valid unsigned integer value.", size, key,
-                                  value);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-
-		/* Check the range */
-		if ((opt->min == 0) && (opt->max == 0)) {
-			gf_msg_trace (xl->name, 0, "no range check required "
-                                      "for 'option %s %s'", key, value);
-			ret = 0;
-			goto out;
-		}
-		if ((size < opt->min) || (size > opt->max)) {
-			snprintf (errstr, 256,
-				  "'%lf' in 'option %s %s'"
-				  " is out of range [%.0f - %.0f]",
-				  size, key, value, opt->min, opt->max);
-			gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE,
-                                "%s", errstr);
-			goto out;
-		}
-		ret = 0;
-		goto out;
-	}
-
-	/* If control reaches here, invalid argument */
-
-	snprintf (errstr, 256,
-		  "invalid number format \"%s\" in \"option %s\"",
-		  value, key);
-	gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+    const char *s = NULL;
+    int ret = 0;
 
+    s = strchr(value, '.');
+    if (s) {
+        for (s = s + 1; *s != '\0'; s++) {
+            if (*s != '0') {
+                return -1;
+            }
+        }
+    }
 
-out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    return ret;
 }
 
-
 static int
-xlator_option_validate_time (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_percent_or_sizet(xlator_t *xl, const char *key,
+                                        const char *value, volume_option_t *opt,
+                                        char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        uint32_t     input_time = 0;
-
-	/* Check if the value is valid time */
-        if (gf_string2time (value, &input_time) != 0) {
-                snprintf (errstr, 256,
-                          "invalid time format \"%s\" in "
-                          "\"option %s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
+    int ret = -1;
+    char errstr[256];
+    double size = 0;
+    gf_boolean_t is_percent = _gf_false;
+
+    if (gf_string2percent_or_bytesize(value, &size, &is_percent) == 0) {
+        if (is_percent) {
+            if ((size < 0.0) || (size > 100.0)) {
+                snprintf(errstr, sizeof(errstr),
+                         "'%lf' in 'option %s %s' is out"
+                         " of range [0 - 100]",
+                         size, key, value);
+                gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE,
+                        "error=%s", errstr, NULL);
                 goto out;
+            }
+            ret = 0;
+            goto out;
         }
 
-        if ((opt->min == 0) && (opt->max == 0)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
+        /*Input value of size(in byte) should not be fractional*/
+        ret = xlator_option_validate_fractional_value(value);
+        if (ret) {
+            snprintf(errstr, sizeof(errstr),
+                     "'%lf' in 'option %s"
+                     " %s' should not be fractional value. Use "
+                     "valid unsigned integer value.",
+                     size, key, value);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
 
-        if ((input_time < opt->min) || (input_time > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%"PRIu32"' in 'option %s %s' is "
-                          "out of range [%.0f - %.0f]",
-                          input_time, key, value,
-                          opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+        /* Check the range */
+        if ((opt->min == 0) && (opt->max == 0)) {
+            gf_msg_trace(xl->name, 0,
+                         "no range check required "
+                         "for 'option %s %s'",
+                         key, value);
+            ret = 0;
+            goto out;
+        }
+        if ((size < opt->min) || (size > opt->max)) {
+            snprintf(errstr, 256,
+                     "'%lf' in 'option %s %s'"
+                     " is out of range [%.0f - %.0f]",
+                     size, key, value, opt->min, opt->max);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
-
         ret = 0;
+        goto out;
+    }
+
+    /* If control reaches here, invalid argument */
+
+    snprintf(errstr, 256, "invalid number format \"%s\" in \"option %s\"",
+             value, key);
+    gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s", errstr,
+            NULL);
+
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_double (xlator_t *xl, const char *key, const char *value,
-                               volume_option_t *opt, char **op_errstr)
+xlator_option_validate_time(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        double    input = 0.0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2double (value, &input) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
+    int ret = -1;
+    char errstr[256];
+    uint32_t input_time = 0;
+
+    /* Check if the value is valid time */
+    if (gf_string2time(value, &input_time) != 0) {
+        snprintf(errstr, 256,
+                 "invalid time format \"%s\" in "
+                 "\"option %s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        ret = 0;
+        goto out;
+    }
+
+    if ((input_time < opt->min) || (input_time > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%" PRIu32
+                 "' in 'option %s %s' is "
+                 "out of range [%.0f - %.0f]",
+                 input_time, key, value, opt->min, opt->max);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
+}
 
-        if ((opt->min == 0) && (opt->max == 0) &&
-            (opt->validate == GF_OPT_VALIDATE_BOTH)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
+static int
+xlator_option_validate_double(xlator_t *xl, const char *key, const char *value,
+                              volume_option_t *opt, char **op_errstr)
+{
+    double input = 0.0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2double(value, &input) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0) &&
+        (opt->validate == GF_OPT_VALIDATE_BOTH)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        ret = 0;
+        goto out;
+    }
+
+    if (opt->validate == GF_OPT_VALIDATE_MIN) {
+        if (input < opt->min) {
+            snprintf(errstr, 256,
+                     "'%f' in 'option %s %s' is smaller than "
+                     "minimum value '%f'",
+                     input, key, value, opt->min);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
-
-        if (opt->validate == GF_OPT_VALIDATE_MIN) {
-                if (input < opt->min) {
-                        snprintf (errstr, 256,
-                                  "'%f' in 'option %s %s' is smaller than "
-                                  "minimum value '%f'", input, key,
-                                  value, opt->min);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
-                if (input > opt->max) {
-                        snprintf (errstr, 256,
-                                  "'%f' in 'option %s %s' is greater than "
-                                  "maximum value '%f'", input, key,
-                                  value, opt->max);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if ((input < opt->min) || (input > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%f' in 'option %s %s' is out of range "
-                          "[%f - %f]",
-                          input, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+    } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
+        if (input > opt->max) {
+            snprintf(errstr, 256,
+                     "'%f' in 'option %s %s' is greater than "
+                     "maximum value '%f'",
+                     input, key, value, opt->max);
+            gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                    errstr, NULL);
+            goto out;
         }
-
-        ret = 0;
+    } else if ((input < opt->min) || (input > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%f' in 'option %s %s' is out of range "
+                 "[%f - %f]",
+                 input, key, value, opt->min, opt->max);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "error=%s",
+                errstr, NULL);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_addr (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_addr(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-
-        if (!valid_internet_address ((char *)value, _gf_false)) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s'  is not a valid internet-address,"
-                          " it does not conform to standards.",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
+    int ret = -1;
+    char errstr[256];
 
-        ret = 0;
+    if (!valid_internet_address((char *)value, _gf_false, _gf_false)) {
+        snprintf(errstr, 256, "option %s %s: Can not parse %s address", key,
+                 value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
 
-        return ret;
+    ret = 0;
+
+    return ret;
 }
 
 int
-xlator_option_validate_addr_list (xlator_t *xl, const char *key,
-                                  const char *value, volume_option_t *opt,
-                                  char **op_errstr)
+xlator_option_validate_addr_list(xlator_t *xl, const char *key,
+                                 const char *value, volume_option_t *opt,
+                                 char **op_errstr)
 {
-        int          ret = -1;
-        char         *dup_val = NULL;
-        char         *addr_tok = NULL;
-        char         *save_ptr = NULL;
-        char         *entry = NULL;
-        char         *entry_ptr = NULL;
-        char         *dir_and_addr = NULL;
-        char         *addr_ptr = NULL;
-        char         *addr_list = NULL;
-        char         *addr = NULL;
-        char         *dir = NULL;
-        char         errstr[4096] = {0,};
-
-        dup_val = gf_strdup (value);
-        if (!dup_val)
+    int ret = -1;
+    char *dup_val = NULL;
+    char *addr_tok = NULL;
+    char *save_ptr = NULL;
+    char *entry = NULL;
+    char *entry_ptr = NULL;
+    char *dir_and_addr = NULL;
+    char *addr_ptr = NULL;
+    char *addr_list = NULL;
+    char *addr = NULL;
+    char *dir = NULL;
+
+    dup_val = gf_strdup(value);
+    if (!dup_val)
+        goto out;
+
+    if (dup_val[0] != '/' && !strchr(dup_val, '(')) {
+        /* Possible old format, handle it for back-ward compatibility */
+        addr_tok = strtok_r(dup_val, ",", &save_ptr);
+        while (addr_tok) {
+            if (!valid_internet_address(addr_tok, _gf_true, _gf_true))
                 goto out;
 
-        if (dup_val[0] != '/' && !strchr (dup_val, '(')) {
-                /* Possible old format, handle it for back-ward compatibility */
-                addr_tok = strtok_r (dup_val, ",", &save_ptr);
-                while (addr_tok) {
-                        if (!valid_internet_address (addr_tok, _gf_true))
-                                goto out;
+            addr_tok = strtok_r(NULL, ",", &save_ptr);
+        }
+        ret = 0;
+        goto out;
+    }
+
+    /* Lets handle the value with new format */
+    entry = strtok_r(dup_val, ",", &entry_ptr);
+    while (entry) {
+        dir_and_addr = gf_strdup(entry);
+        if (!dir_and_addr)
+            goto out;
+
+        dir = strtok_r(dir_and_addr, "(", &addr_ptr);
+        if (dir[0] != '/') {
+            /* Valid format should be starting from '/' */
+            goto out;
+        }
+        /* dir = strtok_r (NULL, " =", &addr_tmp); */
+        addr = strtok_r(NULL, ")", &addr_ptr);
+        if (!addr)
+            goto out;
+
+        addr_list = gf_strdup(addr);
+        if (!addr_list)
+            goto out;
 
-                        addr_tok = strtok_r (NULL, ",", &save_ptr);
-                }
-                ret = 0;
+        /* This format be separated by '|' */
+        addr_tok = strtok_r(addr_list, "|", &save_ptr);
+        if (addr_tok == NULL)
+            goto out;
+        while (addr_tok) {
+            if (!valid_internet_address(addr_tok, _gf_true, _gf_true))
                 goto out;
-        }
 
-        /* Lets handle the value with new format */
-        entry = strtok_r (dup_val, ",", &entry_ptr);
-        while (entry) {
-                dir_and_addr = gf_strdup (entry);
-                if (!dir_and_addr)
-                        goto out;
-
-                dir = strtok_r (dir_and_addr, "(", &addr_ptr);
-                if (dir[0] != '/') {
-                        /* Valid format should be starting from '/' */
-                        goto out;
-                }
-                /* dir = strtok_r (NULL, " =", &addr_tmp); */
-                addr = strtok_r (NULL, ")", &addr_ptr);
-                if (!addr)
-                        goto out;
-
-                addr_list = gf_strdup (addr);
-                if (!addr_list)
-                        goto out;
-
-                /* This format be separated by '|' */
-                addr_tok = strtok_r (addr_list, "|", &save_ptr);
-                if (addr_tok == NULL)
-                        goto out;
-                while (addr_tok) {
-                        if (!valid_internet_address (addr_tok, _gf_true))
-                                goto out;
-
-                        addr_tok = strtok_r (NULL, "|", &save_ptr);
-                }
-                entry = strtok_r (NULL, ",", &entry_ptr);
-                GF_FREE (dir_and_addr);
-                GF_FREE (addr_list);
-                addr_list = NULL;
-                dir_and_addr = NULL;
+            addr_tok = strtok_r(NULL, "|", &save_ptr);
         }
+        entry = strtok_r(NULL, ",", &entry_ptr);
+        GF_FREE(dir_and_addr);
+        GF_FREE(addr_list);
+        addr_list = NULL;
+        dir_and_addr = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret) {
-                snprintf (errstr, sizeof (errstr), "option %s %s: '%s' is not "
-                          "a valid internet-address-list", key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-        GF_FREE (dup_val);
-        GF_FREE (dir_and_addr);
-        GF_FREE (addr_list);
-        return ret;
+    if (ret) {
+        char errstr[4096];
+        snprintf(errstr, sizeof(errstr),
+                 "option %s %s: '%s' is not "
+                 "a valid internet-address-list",
+                 key, value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    GF_FREE(dup_val);
+    GF_FREE(dir_and_addr);
+    GF_FREE(addr_list);
+    return ret;
 }
 
 static int
-xlator_option_validate_mntauth (xlator_t *xl, const char *key,
-                                const char *value, volume_option_t *opt,
-                                char **op_errstr)
+xlator_option_validate_mntauth(xlator_t *xl, const char *key, const char *value,
+                               volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         *dup_val = NULL;
-        char         *addr_tok = NULL;
-        char         *save_ptr = NULL;
-        char         errstr[4096] = {0,};
-
-        dup_val = gf_strdup (value);
-        if (!dup_val)
-                goto out;
-
-        addr_tok = strtok_r (dup_val, ",", &save_ptr);
-        if (addr_tok == NULL)
-                goto out;
-        while (addr_tok) {
-                if (!valid_mount_auth_address (addr_tok))
-                        goto out;
-
-                addr_tok = strtok_r (NULL, ",", &save_ptr);
-        }
-        ret = 0;
+    int ret = -1;
+    char *dup_val = NULL;
+    char *addr_tok = NULL;
+    char *save_ptr = NULL;
+
+    dup_val = gf_strdup(value);
+    if (!dup_val)
+        goto out;
+
+    addr_tok = strtok_r(dup_val, ",", &save_ptr);
+    if (addr_tok == NULL)
+        goto out;
+    while (addr_tok) {
+        if (!valid_mount_auth_address(addr_tok))
+            goto out;
+
+        addr_tok = strtok_r(NULL, ",", &save_ptr);
+    }
+    ret = 0;
 
 out:
-        if (ret) {
-                snprintf (errstr, sizeof (errstr), "option %s %s: '%s' is not "
-                "a valid mount-auth-address", key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-        GF_FREE (dup_val);
-
-        return ret;
+    if (ret) {
+        char errstr[4096];
+        snprintf(errstr, sizeof(errstr),
+                 "option %s %s: '%s' is not "
+                 "a valid mount-auth-address",
+                 key, value, value);
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "error=%s",
+                errstr, NULL);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    GF_FREE(dup_val);
+
+    return ret;
 }
 
 /*XXX: the rules to validate are as per block-size required for stripe xlator */
 static int
-gf_validate_size (const char *sizestr, volume_option_t *opt)
+gf_validate_size(const char *sizestr, volume_option_t *opt)
 {
-        size_t                value = 0;
-        int                     ret = 0;
+    uint64_t value = 0;
+    int ret = 0;
 
-        GF_ASSERT (opt);
+    GF_ASSERT(opt);
 
-        if (gf_string2bytesize_size (sizestr, &value) != 0 ||
-            value < opt->min ||
-            value % 512) {
-                ret = -1;
-                goto out;
-        }
+    if (gf_string2bytesize_uint64(sizestr, &value) != 0 || value < opt->min ||
+        value % 512) {
+        ret = -1;
+        goto out;
+    }
 
- out:
-        gf_msg_debug (THIS->name, 0, "Returning %d", ret);
-        return ret;
+out:
+    gf_msg_debug(THIS->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 static int
-gf_validate_number (const char *numstr, volume_option_t *opt)
+gf_validate_number(const char *numstr, volume_option_t *opt)
 {
-        int32_t value;
-        return gf_string2int32 (numstr, &value);
+    int32_t value;
+    return gf_string2int32(numstr, &value);
 }
 
 /*  Parses the string to be of the form <key1>:<value1>,<key2>:<value2>...  *
  *  takes two optional validaters key_validator and value_validator         */
 static int
-validate_list_elements (const char *string, volume_option_t *opt,
-                        int (key_validator)( const char *),
-                        int (value_validator)( const char *, volume_option_t *))
+validate_list_elements(const char *string, volume_option_t *opt,
+                       int(key_validator)(const char *),
+                       int(value_validator)(const char *, volume_option_t *))
 {
-
-        char                    *dup_string = NULL;
-        char                    *str_sav = NULL;
-        char                    *substr_sav = NULL;
-        char                    *str_ptr = NULL;
-        char                    *key = NULL;
-        char                    *value = NULL;
-        int                     ret = 0;
-
-        GF_ASSERT (string);
-
-        dup_string = gf_strdup (string);
-        if (NULL == dup_string)
-                goto out;
-
-        str_ptr = strtok_r (dup_string, ",", &str_sav);
-        if (str_ptr == NULL) {
-                ret = -1;
-                goto out;
+    char *dup_string = NULL;
+    char *str_sav = NULL;
+    char *substr_sav = NULL;
+    char *str_ptr = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    int ret = 0;
+
+    GF_ASSERT(string);
+
+    dup_string = gf_strdup(string);
+    if (NULL == dup_string)
+        goto out;
+
+    str_ptr = strtok_r(dup_string, ",", &str_sav);
+    if (str_ptr == NULL) {
+        ret = -1;
+        goto out;
+    }
+    while (str_ptr) {
+        key = strtok_r(str_ptr, ":", &substr_sav);
+        if (!key || (key_validator && key_validator(key))) {
+            ret = -1;
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+                    "list=%s", string, "key=%s", key ? key : "", NULL);
+            goto out;
         }
-        while (str_ptr) {
-
-                key = strtok_r (str_ptr, ":", &substr_sav);
-                if (!key ||
-                    (key_validator && key_validator(key))) {
-                        ret = -1;
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "invalid list '%s', key "
-                                "'%s' not valid.", string, key);
-                        goto out;
-                }
-
-                value = strtok_r (NULL, ":", &substr_sav);
-                if (!value ||
-                    (value_validator && value_validator(value, opt))) {
-                        ret = -1;
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "invalid list '%s', "
-                                "value '%s' not valid.", string, key);
-                        goto out;
-                }
-
-                str_ptr = strtok_r (NULL, ",", &str_sav);
-                substr_sav = NULL;
+
+        value = strtok_r(NULL, ":", &substr_sav);
+        if (!value || (value_validator && value_validator(value, opt))) {
+            ret = -1;
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+                    "list=%s", string, "value=%s", key, NULL);
+            goto out;
         }
 
- out:
-        GF_FREE (dup_string);
-        gf_msg_debug (THIS->name, 0, "Returning %d", ret);
-        return ret;
+        str_ptr = strtok_r(NULL, ",", &str_sav);
+        substr_sav = NULL;
+    }
+
+out:
+    GF_FREE(dup_string);
+    gf_msg_debug(THIS->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 static int
-xlator_option_validate_priority_list (xlator_t *xl, const char *key,
-                                      const char *value, volume_option_t *opt,
-                                      char **op_errstr)
+xlator_option_validate_priority_list(xlator_t *xl, const char *key,
+                                     const char *value, volume_option_t *opt,
+                                     char **op_errstr)
 {
-        int                     ret =0;
-        char                    errstr[1024] = {0, };
-
-        GF_ASSERT (value);
-
-        ret = validate_list_elements (value, opt, NULL, &gf_validate_number);
-        if (ret) {
-                snprintf (errstr, 1024,
-                          "option %s %s: '%s' is not a valid "
-                          "priority-list", key, value, value);
-                *op_errstr = gf_strdup (errstr);
-        }
-
-        return ret;
+    int ret = 0;
+    char errstr[1024] = {
+        0,
+    };
+
+    GF_ASSERT(value);
+
+    ret = validate_list_elements(value, opt, NULL, &gf_validate_number);
+    if (ret) {
+        snprintf(errstr, 1024,
+                 "option %s %s: '%s' is not a valid "
+                 "priority-list",
+                 key, value, value);
+        *op_errstr = gf_strdup(errstr);
+    }
+
+    return ret;
 }
 
 static int
-xlator_option_validate_size_list (xlator_t *xl, const char *key,
-                                  const char *value, volume_option_t *opt,
-                                  char **op_errstr)
+xlator_option_validate_size_list(xlator_t *xl, const char *key,
+                                 const char *value, volume_option_t *opt,
+                                 char **op_errstr)
 {
-
-        int                    ret = 0;
-        char                   errstr[1024] = {0, };
-
-        GF_ASSERT (value);
-
-        ret = gf_validate_size (value, opt);
-        if (ret)
-                ret = validate_list_elements (value, opt, NULL, &gf_validate_size);
-
-        if (ret) {
-                snprintf (errstr, 1024,
-                          "option %s %s: '%s' is not a valid "
-                          "size-list", key, value, value);
-                *op_errstr = gf_strdup (errstr);
-        }
-
-        return ret;
-
+    int ret = 0;
+    char errstr[1024] = {
+        0,
+    };
+
+    GF_ASSERT(value);
+
+    ret = gf_validate_size(value, opt);
+    if (ret)
+        ret = validate_list_elements(value, opt, NULL, &gf_validate_size);
+
+    if (ret) {
+        snprintf(errstr, 1024,
+                 "option %s %s: '%s' is not a valid "
+                 "size-list",
+                 key, value, value);
+        *op_errstr = gf_strdup(errstr);
+    }
+
+    return ret;
 }
 
 static int
-xlator_option_validate_any (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_any(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        return 0;
+    return 0;
 }
 
-typedef int (xlator_option_validator_t) (xlator_t *xl, const char *key,
-                                         const char *value,
-                                         volume_option_t *opt, char **operrstr);
+typedef int(xlator_option_validator_t)(xlator_t *xl, const char *key,
+                                       const char *value, volume_option_t *opt,
+                                       char **operrstr);
 
 int
-xlator_option_validate (xlator_t *xl, char *key, char *value,
-                        volume_option_t *opt, char **op_errstr)
+xlator_option_validate(xlator_t *xl, char *key, char *value,
+                       volume_option_t *opt, char **op_errstr)
 {
-        int       ret = -1;
-        xlator_option_validator_t *validate;
-        xlator_option_validator_t *validators[] = {
-                [GF_OPTION_TYPE_PATH]        = xlator_option_validate_path,
-                [GF_OPTION_TYPE_INT]         = xlator_option_validate_int,
-                [GF_OPTION_TYPE_SIZET]       = xlator_option_validate_sizet,
-                [GF_OPTION_TYPE_BOOL]        = xlator_option_validate_bool,
-                [GF_OPTION_TYPE_XLATOR]      = xlator_option_validate_xlator,
-                [GF_OPTION_TYPE_STR]         = xlator_option_validate_str,
-                [GF_OPTION_TYPE_PERCENT]     = xlator_option_validate_percent,
-                [GF_OPTION_TYPE_PERCENT_OR_SIZET] =
-                xlator_option_validate_percent_or_sizet,
-                [GF_OPTION_TYPE_TIME]        = xlator_option_validate_time,
-                [GF_OPTION_TYPE_DOUBLE]      = xlator_option_validate_double,
-                [GF_OPTION_TYPE_INTERNET_ADDRESS] = xlator_option_validate_addr,
-                [GF_OPTION_TYPE_INTERNET_ADDRESS_LIST] =
-                xlator_option_validate_addr_list,
-                [GF_OPTION_TYPE_PRIORITY_LIST] =
-                xlator_option_validate_priority_list,
-                [GF_OPTION_TYPE_SIZE_LIST]   = xlator_option_validate_size_list,
-                [GF_OPTION_TYPE_ANY]         = xlator_option_validate_any,
-                [GF_OPTION_TYPE_CLIENT_AUTH_ADDR] = xlator_option_validate_mntauth,
-                [GF_OPTION_TYPE_MAX]         = NULL,
-        };
-
-        if (opt->type > GF_OPTION_TYPE_MAX) {
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "unknown option type '%d'", opt->type);
-                goto out;
-        }
-
-        validate = validators[opt->type];
-
-        ret = validate (xl, key, value, opt, op_errstr);
+    int ret = -1;
+    xlator_option_validator_t *validate;
+    xlator_option_validator_t *validators[] = {
+        [GF_OPTION_TYPE_PATH] = xlator_option_validate_path,
+        [GF_OPTION_TYPE_INT] = xlator_option_validate_int,
+        [GF_OPTION_TYPE_SIZET] = xlator_option_validate_sizet,
+        [GF_OPTION_TYPE_BOOL] = xlator_option_validate_bool,
+        [GF_OPTION_TYPE_XLATOR] = xlator_option_validate_xlator,
+        [GF_OPTION_TYPE_STR] = xlator_option_validate_str,
+        [GF_OPTION_TYPE_PERCENT] = xlator_option_validate_percent,
+        [GF_OPTION_TYPE_PERCENT_OR_SIZET] =
+            xlator_option_validate_percent_or_sizet,
+        [GF_OPTION_TYPE_TIME] = xlator_option_validate_time,
+        [GF_OPTION_TYPE_DOUBLE] = xlator_option_validate_double,
+        [GF_OPTION_TYPE_INTERNET_ADDRESS] = xlator_option_validate_addr,
+        [GF_OPTION_TYPE_INTERNET_ADDRESS_LIST] =
+            xlator_option_validate_addr_list,
+        [GF_OPTION_TYPE_PRIORITY_LIST] = xlator_option_validate_priority_list,
+        [GF_OPTION_TYPE_SIZE_LIST] = xlator_option_validate_size_list,
+        [GF_OPTION_TYPE_ANY] = xlator_option_validate_any,
+        [GF_OPTION_TYPE_CLIENT_AUTH_ADDR] = xlator_option_validate_mntauth,
+        [GF_OPTION_TYPE_MAX] = NULL,
+    };
+
+    if (opt->type > GF_OPTION_TYPE_MAX) {
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_UNKNOWN_OPTION_TYPE,
+                "type=%d", opt->type, NULL);
+        goto out;
+    }
+
+    validate = validators[opt->type];
+
+    ret = validate(xl, key, value, opt, op_errstr);
 out:
-        return ret;
+    return ret;
 }
 
-
 volume_option_t *
-xlator_volume_option_get_list (volume_opt_list_t *vol_list, const char *key)
+xlator_volume_option_get_list(volume_opt_list_t *vol_list, const char *key)
 {
-        volume_option_t         *opt = NULL;
-        volume_opt_list_t       *opt_list = NULL;
-        volume_option_t         *found = NULL;
-        int                      index = 0;
-        int                      i = 0;
-        char                    *cmp_key = NULL;
-
-        if (!vol_list->given_opt) {
-                opt_list = list_entry (vol_list->list.next, volume_opt_list_t,
-                                       list);
-                opt = opt_list->given_opt;
-        } else
-                opt = vol_list->given_opt;
-
-        for (index = 0; opt[index].key[0]; index++) {
-                for (i = 0; i < ZR_VOLUME_MAX_NUM_KEY; i++) {
-                        cmp_key = opt[index].key[i];
-                        if (!cmp_key)
-                                break;
-                        if (fnmatch (cmp_key, key, FNM_NOESCAPE) == 0) {
-                                found = &opt[index];
-                                goto out;
-                        }
-                }
+    volume_option_t *opt = NULL;
+    volume_opt_list_t *opt_list = NULL;
+    int index = 0;
+    int i = 0;
+    char *cmp_key = NULL;
+
+    if (!vol_list->given_opt) {
+        opt_list = list_entry(vol_list->list.next, volume_opt_list_t, list);
+        opt = opt_list->given_opt;
+    } else
+        opt = vol_list->given_opt;
+
+    for (index = 0; opt[index].key[0]; index++) {
+        for (i = 0; i < ZR_VOLUME_MAX_NUM_KEY; i++) {
+            cmp_key = opt[index].key[i];
+            if (!cmp_key)
+                break;
+            if (fnmatch(cmp_key, key, FNM_NOESCAPE) == 0) {
+                return &opt[index];
+            }
         }
-out:
-        return found;
-}
+    }
 
+    return NULL;
+}
 
 volume_option_t *
-xlator_volume_option_get (xlator_t *xl, const char *key)
+xlator_volume_option_get(xlator_t *xl, const char *key)
 {
-        volume_opt_list_t       *vol_list = NULL;
-        volume_option_t         *found = NULL;
+    volume_opt_list_t *vol_list = NULL;
+    volume_option_t *found = NULL;
 
-        list_for_each_entry (vol_list, &xl->volume_options, list) {
-                found = xlator_volume_option_get_list (vol_list, key);
-                if (found)
-                        break;
-        }
+    list_for_each_entry(vol_list, &xl->volume_options, list)
+    {
+        found = xlator_volume_option_get_list(vol_list, key);
+        if (found)
+            break;
+    }
 
-        return found;
+    return found;
 }
 
-
 static int
-xl_opt_validate (dict_t *dict, char *key, data_t *value, void *data)
+xl_opt_validate(dict_t *dict, char *key, data_t *value, void *data)
 {
-        xlator_t          *xl = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        volume_option_t   *opt = NULL;
-        int                ret = 0;
-        char              *errstr = NULL;
-
-        struct {
-                xlator_t           *this;
-                volume_opt_list_t  *vol_opt;
-                char               *errstr;
-        } *stub;
-
-        stub = data;
-        xl = stub->this;
-        vol_opt = stub->vol_opt;
-
-        opt = xlator_volume_option_get_list (vol_opt, key);
-        if (!opt)
-                return 0;
-
-        ret = xlator_option_validate (xl, key, value->data, opt, &errstr);
-        if (ret)
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_VALIDATE_RETURNS,
-                        "validate of %s returned %d", key, ret);
-
-        if (errstr)
-                /* possible small leak of previously set stub->errstr */
-                stub->errstr = errstr;
-
-        if (fnmatch (opt->key[0], key, FNM_NOESCAPE) != 0) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
-                        "option '%s' is deprecated, preferred is '%s', "
-                        "continuing with correction", key, opt->key[0]);
-                dict_set (dict, opt->key[0], value);
-                dict_del (dict, key);
-        }
+    xlator_t *xl = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    volume_option_t *opt = NULL;
+    int ret = 0;
+    char *errstr = NULL;
+
+    struct {
+        xlator_t *this;
+        volume_opt_list_t *vol_opt;
+        char *errstr;
+    } * stub;
+
+    stub = data;
+    xl = stub->this;
+    vol_opt = stub->vol_opt;
+
+    opt = xlator_volume_option_get_list(vol_opt, key);
+    if (!opt)
         return 0;
-}
 
+    ret = xlator_option_validate(xl, key, value->data, opt, &errstr);
+    if (ret)
+        gf_smsg(xl->name, GF_LOG_WARNING, 0, LG_MSG_VALIDATE_RETURNS, "key=%s",
+                key, "ret=%d", ret, NULL);
+
+    if (errstr)
+        /* possible small leak of previously set stub->errstr */
+        stub->errstr = errstr;
+
+    if (fnmatch(opt->key[0], key, FNM_NOESCAPE) != 0) {
+        gf_smsg(xl->name, GF_LOG_DEBUG, 0, LG_MSG_OPTION_DEPRECATED, "key=%s",
+                key, "preferred=%s", opt->key[0], NULL);
+        dict_set(dict, opt->key[0], value);
+        dict_del(dict, key);
+    }
+    return 0;
+}
 
 int
-xlator_options_validate_list (xlator_t *xl, dict_t *options,
-                              volume_opt_list_t *vol_opt, char **op_errstr)
+xlator_options_validate_list(xlator_t *xl, dict_t *options,
+                             volume_opt_list_t *vol_opt, char **op_errstr)
 {
-        int ret = 0;
-        struct {
-                xlator_t           *this;
-                volume_opt_list_t  *vol_opt;
-                char               *errstr;
-        } stub;
-
-        stub.this = xl;
-        stub.vol_opt = vol_opt;
-        stub.errstr = NULL;
-
-        dict_foreach (options, xl_opt_validate, &stub);
-        if (stub.errstr) {
-                ret = -1;
-                if (op_errstr)
-                        *op_errstr = stub.errstr;
-        }
-
-        return ret;
+    int ret = 0;
+    struct {
+        xlator_t *this;
+        volume_opt_list_t *vol_opt;
+        char *errstr;
+    } stub;
+
+    stub.this = xl;
+    stub.vol_opt = vol_opt;
+    stub.errstr = NULL;
+
+    dict_foreach(options, xl_opt_validate, &stub);
+    if (stub.errstr) {
+        ret = -1;
+        if (op_errstr)
+            *op_errstr = stub.errstr;
+    }
+
+    return ret;
 }
 
-
 int
-xlator_options_validate (xlator_t *xl, dict_t *options, char **op_errstr)
+xlator_options_validate(xlator_t *xl, dict_t *options, char **op_errstr)
 {
-        int                ret     = 0;
-        volume_opt_list_t *vol_opt = NULL;
-
-
-        if (!xl) {
-                gf_msg_debug (THIS->name, 0, "'this' not a valid ptr");
-                ret = -1;
-                goto out;
-        }
-
-        if (list_empty (&xl->volume_options))
-                goto out;
-
-        list_for_each_entry (vol_opt, &xl->volume_options, list) {
-                ret = xlator_options_validate_list (xl, options, vol_opt,
-                                                    op_errstr);
-        }
+    int ret = 0;
+    volume_opt_list_t *vol_opt = NULL;
+
+    if (!xl) {
+        gf_msg_debug(THIS->name, 0, "'this' not a valid ptr");
+        ret = -1;
+        goto out;
+    }
+
+    if (list_empty(&xl->volume_options))
+        goto out;
+
+    list_for_each_entry(vol_opt, &xl->volume_options, list)
+    {
+        ret = xlator_options_validate_list(xl, options, vol_opt, op_errstr);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_validate_rec (xlator_t *xlator, char **op_errstr)
+xlator_validate_rec(xlator_t *xlator, char **op_errstr)
 {
-        int            ret  = -1;
-        xlator_list_t *trav = NULL;
-        xlator_t      *old_THIS = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xlator, out);
+    int ret = -1;
+    xlator_list_t *trav = NULL;
+    xlator_t *old_THIS = NULL;
 
-        trav = xlator->children;
+    GF_VALIDATE_OR_GOTO("xlator", xlator, out);
 
-        while (trav) {
-                if (xlator_validate_rec (trav->xlator, op_errstr)) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_VALIDATE_REC_FAILED, "validate_rec "
-                                "failed");
-                        goto out;
-                }
+    trav = xlator->children;
 
-                trav = trav->next;
+    while (trav) {
+        if (xlator_validate_rec(trav->xlator, op_errstr)) {
+            gf_smsg("xlator", GF_LOG_WARNING, 0, LG_MSG_VALIDATE_REC_FAILED,
+                    NULL);
+            goto out;
         }
 
-        if (xlator_dynload (xlator))
-                gf_msg_debug (xlator->name, 0, "Did not load the symbols");
+        trav = trav->next;
+    }
 
-        old_THIS = THIS;
-        THIS = xlator;
+    if (xlator_dynload(xlator))
+        gf_msg_debug(xlator->name, 0, "Did not load the symbols");
 
-        /* Need this here, as this graph has not yet called init() */
-        if (!xlator->mem_acct) {
-                if (!xlator->mem_acct_init)
-                        xlator->mem_acct_init = default_mem_acct_init;
-                xlator->mem_acct_init (xlator);
-        }
+    old_THIS = THIS;
+    THIS = xlator;
 
-        ret = xlator_options_validate (xlator, xlator->options, op_errstr);
-        THIS = old_THIS;
+    /* Need this here, as this graph has not yet called init() */
+    if (!xlator->mem_acct) {
+        if (!xlator->mem_acct_init)
+            xlator->mem_acct_init = default_mem_acct_init;
+        xlator->mem_acct_init(xlator);
+    }
 
-        if (ret) {
-                gf_msg (xlator->name, GF_LOG_INFO, 0, LG_MSG_INVALID_ENTRY,
-                        "%s", *op_errstr);
-                goto out;
-        }
+    ret = xlator_options_validate(xlator, xlator->options, op_errstr);
+    THIS = old_THIS;
 
-        gf_msg_debug (xlator->name, 0, "Validated options");
+    if (ret) {
+        gf_smsg(xlator->name, GF_LOG_INFO, 0, LG_MSG_INVALID_ENTRY, "%s",
+                *op_errstr, NULL);
+        goto out;
+    }
 
-        ret = 0;
+    gf_msg_debug(xlator->name, 0, "Validated options");
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-graph_reconf_validateopt (glusterfs_graph_t *graph, char **op_errstr)
+graph_reconf_validateopt(glusterfs_graph_t *graph, char **op_errstr)
 {
-        xlator_t *xlator = NULL;
-        int       ret = -1;
+    xlator_t *xlator = NULL;
+    int ret = -1;
 
-        GF_ASSERT (graph);
+    GF_ASSERT(graph);
 
-        xlator = graph->first;
+    xlator = graph->first;
 
-        ret = xlator_validate_rec (xlator, op_errstr);
+    ret = xlator_validate_rec(xlator, op_errstr);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-xlator_reconfigure_rec (xlator_t *old_xl, xlator_t *new_xl)
+xlator_reconfigure_rec(xlator_t *old_xl, xlator_t *new_xl)
 {
-        xlator_list_t *trav1    = NULL;
-        xlator_list_t *trav2    = NULL;
-        int32_t        ret      = -1;
-        xlator_t      *old_THIS = NULL;
+    xlator_list_t *trav1 = NULL;
+    xlator_list_t *trav2 = NULL;
+    int32_t ret = -1;
+    xlator_t *old_THIS = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", old_xl, out);
-        GF_VALIDATE_OR_GOTO ("xlator", new_xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", old_xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", new_xl, out);
 
-        trav1 = old_xl->children;
-        trav2 = new_xl->children;
+    trav1 = old_xl->children;
+    trav2 = new_xl->children;
 
-        while (trav1 && trav2) {
-                ret = xlator_reconfigure_rec (trav1->xlator, trav2->xlator);
-                if (ret)
-                        goto out;
+    while (trav1 && trav2) {
+        ret = xlator_reconfigure_rec(trav1->xlator, trav2->xlator);
+        if (ret)
+            goto out;
 
-                gf_msg_debug (trav1->xlator->name, 0, "reconfigured");
+        gf_msg_debug(trav1->xlator->name, 0, "reconfigured");
 
-                trav1 = trav1->next;
-                trav2 = trav2->next;
-        }
+        trav1 = trav1->next;
+        trav2 = trav2->next;
+    }
 
-        if (old_xl->reconfigure) {
-                old_THIS = THIS;
-                THIS = old_xl;
+    if (old_xl->reconfigure) {
+        old_THIS = THIS;
+        THIS = old_xl;
 
-                xlator_init_lock ();
-                ret = old_xl->reconfigure (old_xl, new_xl->options);
-                xlator_init_unlock ();
+        xlator_init_lock();
+        handle_default_options(old_xl, new_xl->options);
+        ret = old_xl->reconfigure(old_xl, new_xl->options);
+        xlator_init_unlock();
 
-                THIS = old_THIS;
+        THIS = old_THIS;
 
-                if (ret)
-                        goto out;
-        } else {
-                gf_msg_debug (old_xl->name, 0, "No reconfigure() found");
-        }
+        if (ret)
+            goto out;
+    } else {
+        gf_msg_debug(old_xl->name, 0, "No reconfigure() found");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_tree_reconfigure (xlator_t *old_xl, xlator_t *new_xl)
+xlator_tree_reconfigure(xlator_t *old_xl, xlator_t *new_xl)
 {
-        xlator_t *new_top = NULL;
-        xlator_t *old_top = NULL;
+    xlator_t *new_top = NULL;
+    xlator_t *old_top = NULL;
 
-        GF_ASSERT (old_xl);
-        GF_ASSERT (new_xl);
+    GF_ASSERT(old_xl);
+    GF_ASSERT(new_xl);
 
-        old_top = old_xl;
-        new_top = new_xl;
+    old_top = old_xl;
+    new_top = new_xl;
 
-        return xlator_reconfigure_rec (old_top, new_top);
+    return xlator_reconfigure_rec(old_top, new_top);
 }
 
-
 int
-xlator_option_info_list (volume_opt_list_t *list, char *key,
-                         char **def_val, char **descr)
+xlator_option_info_list(volume_opt_list_t *list, char *key, char **def_val,
+                        char **descr)
 {
-        int                     ret = -1;
-        volume_option_t         *opt = NULL;
+    int ret = -1;
+    volume_option_t *opt = NULL;
 
+    opt = xlator_volume_option_get_list(list, key);
+    if (!opt)
+        goto out;
 
-        opt = xlator_volume_option_get_list (list, key);
-        if (!opt)
-                goto out;
-
-        if (def_val)
-                *def_val = opt->default_value;
-        if (descr)
-                *descr = opt->description;
+    if (def_val)
+        *def_val = opt->default_value;
+    if (descr)
+        *descr = opt->description;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-pass (char *in, char **out)
+pass(char *in, char **out)
 {
-        *out = in;
-        return 0;
+    *out = in;
+    return 0;
 }
 
-
 static int
-xl_by_name (char *in, xlator_t **out)
+xl_by_name(char *in, xlator_t **out)
 {
-        xlator_t  *xl = NULL;
+    xlator_t *xl = NULL;
 
-        xl = xlator_search_by_name (THIS, in);
+    xl = xlator_search_by_name(THIS, in);
 
-        if (!xl)
-                return -1;
-        *out = xl;
-        return 0;
+    if (!xl)
+        return -1;
+    *out = xl;
+    return 0;
 }
 
-
 static int
-pc_or_size (char *in, double *out)
+pc_or_size(char *in, double *out)
 {
-        double  pc = 0;
-        int       ret = 0;
-        size_t  size = 0;
-
-        if (gf_string2percent (in, &pc) == 0) {
-                if (pc > 100.0) {
-                        ret = gf_string2bytesize_size (in, &size);
-                        if (!ret)
-                                *out = size;
-                } else {
-                        *out = pc;
-                }
+    double pc = 0;
+    int ret = 0;
+    uint64_t size = 0;
+
+    if (gf_string2percent(in, &pc) == 0) {
+        if (pc > 100.0) {
+            ret = gf_string2bytesize_uint64(in, &size);
+            if (!ret)
+                *out = size;
         } else {
-                ret = gf_string2bytesize_size (in, &size);
-                if (!ret)
-                        *out = size;
+            *out = pc;
         }
-        return ret;
+    } else {
+        ret = gf_string2bytesize_uint64(in, &size);
+        if (!ret)
+            *out = size;
+    }
+    return ret;
 }
 
 DEFINE_INIT_OPT(char *, str, pass);
@@ -1255,7 +1223,7 @@ DEFINE_INIT_OPT(uint64_t, uint64, gf_string2uint64);
 DEFINE_INIT_OPT(int64_t, int64, gf_string2int64);
 DEFINE_INIT_OPT(uint32_t, uint32, gf_string2uint32);
 DEFINE_INIT_OPT(int32_t, int32, gf_string2int32);
-DEFINE_INIT_OPT(size_t, size, gf_string2bytesize_size);
+DEFINE_INIT_OPT(uint64_t, size, gf_string2bytesize_uint64);
 DEFINE_INIT_OPT(uint64_t, size_uint64, gf_string2bytesize_uint64);
 DEFINE_INIT_OPT(double, percent, gf_string2percent);
 DEFINE_INIT_OPT(double, percent_or_size, pc_or_size);
@@ -1265,13 +1233,12 @@ DEFINE_INIT_OPT(char *, path, pass);
 DEFINE_INIT_OPT(double, double, gf_string2double);
 DEFINE_INIT_OPT(uint32_t, time, gf_string2time);
 
-
 DEFINE_RECONF_OPT(char *, str, pass);
 DEFINE_RECONF_OPT(uint64_t, uint64, gf_string2uint64);
 DEFINE_RECONF_OPT(int64_t, int64, gf_string2int64);
 DEFINE_RECONF_OPT(uint32_t, uint32, gf_string2uint32);
 DEFINE_RECONF_OPT(int32_t, int32, gf_string2int32);
-DEFINE_RECONF_OPT(size_t, size, gf_string2bytesize_size);
+DEFINE_RECONF_OPT(uint64_t, size, gf_string2bytesize_uint64);
 DEFINE_RECONF_OPT(uint64_t, size_uint64, gf_string2bytesize_uint64);
 DEFINE_RECONF_OPT(double, percent, gf_string2percent);
 DEFINE_RECONF_OPT(double, percent_or_size, pc_or_size);
diff --git a/libglusterfs/src/options.h b/libglusterfs/src/options.h
deleted file mode 100644
index d259d44a263..00000000000
--- a/libglusterfs/src/options.h
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _OPTIONS_H
-#define _OPTIONS_H
-
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-#include "xlator.h"
-#include "libglusterfs-messages.h"
-/* Add possible new type of option you may need */
-typedef enum {
-        GF_OPTION_TYPE_ANY = 0,
-        GF_OPTION_TYPE_STR,
-        GF_OPTION_TYPE_INT,
-        GF_OPTION_TYPE_SIZET,
-        GF_OPTION_TYPE_PERCENT,
-        GF_OPTION_TYPE_PERCENT_OR_SIZET,
-        GF_OPTION_TYPE_BOOL,
-        GF_OPTION_TYPE_XLATOR,
-        GF_OPTION_TYPE_PATH,
-        GF_OPTION_TYPE_TIME,
-        GF_OPTION_TYPE_DOUBLE,
-        GF_OPTION_TYPE_INTERNET_ADDRESS,
-        GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
-        GF_OPTION_TYPE_PRIORITY_LIST,
-        GF_OPTION_TYPE_SIZE_LIST,
-        GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
-        GF_OPTION_TYPE_MAX,
-} volume_option_type_t;
-
-typedef enum {
-        GF_OPT_VALIDATE_BOTH = 0,
-        GF_OPT_VALIDATE_MIN,
-        GF_OPT_VALIDATE_MAX,
-} opt_validate_type_t;
-
-#define ZR_VOLUME_MAX_NUM_KEY    4
-#define ZR_OPTION_MAX_ARRAY_SIZE 64
-
-/* Each translator should define this structure */
-typedef struct volume_options {
-        char                    *key[ZR_VOLUME_MAX_NUM_KEY];
-        /* different key, same meaning */
-        volume_option_type_t    type;
-        double                  min;  /* 0 means no range */
-        double                  max;  /* 0 means no range */
-        char                    *value[ZR_OPTION_MAX_ARRAY_SIZE];
-        /* If specified, will check for one of
-           the value from this array */
-        char                    *default_value;
-        char                    *description; /* about the key */
-        /* Required for int options where only the min value
-         * is given and is 0. This will cause validation not to
-         * happen
-         */
-        opt_validate_type_t     validate;
-} volume_option_t;
-
-
-typedef struct vol_opt_list {
-        struct list_head  list;
-        volume_option_t  *given_opt;
-} volume_opt_list_t;
-
-
-int xlator_tree_reconfigure (xlator_t *old_xl, xlator_t *new_xl);
-int xlator_validate_rec (xlator_t *xlator, char **op_errstr);
-int graph_reconf_validateopt (glusterfs_graph_t *graph, char **op_errstr);
-int xlator_option_info_list (volume_opt_list_t *list, char *key,
-                             char **def_val, char **descr);
-/*
-int validate_xlator_volume_options (xlator_t *xl, dict_t *options,
-                                    volume_option_t *opt, char **op_errstr);
-*/
-int xlator_options_validate_list (xlator_t *xl, dict_t *options,
-                                  volume_opt_list_t *list, char **op_errstr);
-int xlator_option_validate (xlator_t *xl, char *key, char *value,
-                            volume_option_t *opt, char **op_errstr);
-int xlator_options_validate (xlator_t *xl, dict_t *options, char **errstr);
-
-int xlator_option_validate_addr_list (xlator_t *xl, const char *key,
-                                      const char *value, volume_option_t *opt,
-                                      char **op_errstr);
-
-volume_option_t *
-xlator_volume_option_get (xlator_t *xl, const char *key);
-
-volume_option_t *
-xlator_volume_option_get_list (volume_opt_list_t *vol_list, const char *key);
-
-
-#define DECLARE_INIT_OPT(type_t, type)                                  \
-int                                                                     \
-xlator_option_init_##type (xlator_t *this, dict_t *options, char *key,  \
-                           type_t *val_p);
-
-DECLARE_INIT_OPT(char *, str);
-DECLARE_INIT_OPT(uint64_t, uint64);
-DECLARE_INIT_OPT(int64_t, int64);
-DECLARE_INIT_OPT(uint32_t, uint32);
-DECLARE_INIT_OPT(int32_t, int32);
-DECLARE_INIT_OPT(size_t, size);
-DECLARE_INIT_OPT(uint64_t, size_uint64);
-DECLARE_INIT_OPT(double, percent);
-DECLARE_INIT_OPT(double, percent_or_size);
-DECLARE_INIT_OPT(gf_boolean_t, bool);
-DECLARE_INIT_OPT(xlator_t *, xlator);
-DECLARE_INIT_OPT(char *, path);
-DECLARE_INIT_OPT(double, double);
-DECLARE_INIT_OPT(uint32_t, time);
-
-
-#define DEFINE_INIT_OPT(type_t, type, conv)                             \
-int                                                                     \
-xlator_option_init_##type (xlator_t *this, dict_t *options, char *key,  \
-                           type_t *val_p)                               \
-{                                                                       \
-        int              ret = 0;                                       \
-        volume_option_t *opt = NULL;                                    \
-        char            *def_value = NULL;                              \
-        char            *set_value = NULL;                              \
-        char            *value = NULL;                                  \
-        xlator_t        *old_THIS = NULL;                               \
-                                                                        \
-        opt = xlator_volume_option_get (this, key);                     \
-        if (!opt) {                                                     \
-                gf_msg (this->name, GF_LOG_WARNING, EINVAL,             \
-                        LG_MSG_INVALID_ENTRY,                           \
-                        "unknown option: %s", key);                     \
-                ret = -1;                                               \
-                return ret;                                             \
-        }                                                               \
-        def_value = opt->default_value;                                 \
-        ret = dict_get_str (options, key, &set_value);                  \
-                                                                        \
-        if (def_value)                                                  \
-                value = def_value;                                      \
-        if (set_value)                                                  \
-                value = set_value;                                      \
-        if (!value) {                                                   \
-                gf_msg_trace (this->name, 0, "option %s not set",       \
-                        key);                                           \
-                *val_p = (type_t)0;                                     \
-                return 0;                                               \
-        }                                                               \
-        if (value == def_value) {                                       \
-                gf_msg_trace (this->name, 0, "option %s using default"  \
-                              " value %s", key, value);                 \
-        } else {                                                        \
-                gf_msg_debug (this->name, 0, "option %s using set"      \
-                              " value %s", key, value);                 \
-        }                                                               \
-        old_THIS = THIS;                                                \
-        THIS = this;                                                    \
-        ret = conv (value, val_p);                                      \
-        THIS = old_THIS;                                                \
-        if (ret) {							\
-                gf_msg (this->name, GF_LOG_INFO, 0,                     \
-                        LG_MSG_CONVERSION_FAILED,                       \
-                        "option %s conversion failed value %s",         \
-                        key, value);                                    \
-                return ret;                                             \
-	}                                                               \
-        ret = xlator_option_validate (this, key, value, opt, NULL);     \
-        return ret;                                                     \
-}
-
-#define GF_OPTION_INIT(key, val, type, err_label) do {            \
-        int val_ret = 0;                                          \
-        val_ret = xlator_option_init_##type (THIS, THIS->options, \
-                                             key, &(val));        \
-        if (val_ret)                                              \
-                goto err_label;                                   \
-        } while (0)
-
-
-
-#define DECLARE_RECONF_OPT(type_t, type)                                \
-int                                                                     \
-xlator_option_reconf_##type (xlator_t *this, dict_t *options, char *key,\
-                             type_t *val_p);
-
-DECLARE_RECONF_OPT(char *, str);
-DECLARE_RECONF_OPT(uint64_t, uint64);
-DECLARE_RECONF_OPT(int64_t, int64);
-DECLARE_RECONF_OPT(uint32_t, uint32);
-DECLARE_RECONF_OPT(int32_t, int32);
-DECLARE_RECONF_OPT(size_t, size);
-DECLARE_RECONF_OPT(uint64_t, size_uint64);
-DECLARE_RECONF_OPT(double, percent);
-DECLARE_RECONF_OPT(double, percent_or_size);
-DECLARE_RECONF_OPT(gf_boolean_t, bool);
-DECLARE_RECONF_OPT(xlator_t *, xlator);
-DECLARE_RECONF_OPT(char *, path);
-DECLARE_RECONF_OPT(double, double);
-DECLARE_RECONF_OPT(uint32_t, time);
-
-
-#define DEFINE_RECONF_OPT(type_t, type, conv)                            \
-int                                                                      \
-xlator_option_reconf_##type (xlator_t *this, dict_t *options, char *key, \
-                             type_t *val_p)                             \
-{                                                                       \
-        int              ret = 0;                                       \
-        volume_option_t *opt = NULL;                                    \
-        char            *def_value = NULL;                              \
-        char            *set_value = NULL;                              \
-        char            *value = NULL;                                  \
-        xlator_t        *old_THIS = NULL;                               \
-                                                                        \
-        opt = xlator_volume_option_get (this, key);                     \
-        if (!opt) {                                                     \
-                gf_msg (this->name, GF_LOG_WARNING, EINVAL,             \
-                        LG_MSG_INVALID_ENTRY,                           \
-                        "unknown option: %s", key);                     \
-                ret = -1;                                               \
-                return ret;                                             \
-        }                                                               \
-        def_value = opt->default_value;                                 \
-        ret = dict_get_str (options, key, &set_value);                  \
-                                                                        \
-        if (def_value)                                                  \
-                value = def_value;                                      \
-        if (set_value)                                                  \
-                value = set_value;                                      \
-        if (!value) {                                                   \
-                gf_msg_trace (this->name, 0, "option %s not set", key); \
-                *val_p = (type_t)0;                                     \
-                return 0;                                               \
-        }                                                               \
-        if (value == def_value) {                                       \
-                gf_msg_trace (this->name, 0,                            \
-                        "option %s using default value %s",             \
-                        key, value);                                    \
-        } else {                                                        \
-                gf_msg_debug (this->name, 0,                            \
-                        "option %s using set value %s",                 \
-                        key, value);                                    \
-        }                                                               \
-        old_THIS = THIS;                                                \
-        THIS = this;                                                    \
-        ret = conv (value, val_p);                                      \
-        THIS = old_THIS;                                                \
-        if (ret)                                                        \
-                return ret;                                             \
-        ret = xlator_option_validate (this, key, value, opt, NULL);     \
-        return ret;                                                     \
-}
-
-#define GF_OPTION_RECONF(key, val, opt, type, err_label) do {       \
-        int val_ret = 0;                                            \
-        val_ret = xlator_option_reconf_##type (THIS, opt, key,      \
-                                               &(val));             \
-        if (val_ret)                                                \
-                goto err_label;                                     \
-        } while (0)
-
-
-#endif /* !_OPTIONS_H */
diff --git a/libglusterfs/src/parse-utils.c b/libglusterfs/src/parse-utils.c
index 304232f6b56..4531d5f0170 100644
--- a/libglusterfs/src/parse-utils.c
+++ b/libglusterfs/src/parse-utils.c
@@ -14,13 +14,11 @@
 
 #include <regex.h>
 #include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
 
-#include "parse-utils.h"
-#include "mem-pool.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/parse-utils.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 /**
  * parser_init: Initialize a parser with the a string to parse and
@@ -36,33 +34,33 @@
  *              : failure: NULL (on failure to compile regex or allocate memory)
  */
 struct parser *
-parser_init (const char *regex)
+parser_init(const char *regex)
 {
-        int           rc      = 0;
-        struct parser *parser = NULL;
-
-        parser = GF_MALLOC (sizeof(*parser), gf_common_mt_parser_t);
-        if (!parser)
-                goto out;
-
-        parser->regex = gf_strdup (regex);
-        if (!parser->regex) {
-                GF_FREE (parser);
-                parser = NULL;
-                goto out;
-        }
-
-        rc = regcomp (&parser->preg, parser->regex, REG_EXTENDED);
-        if (rc != 0) {
-                gf_msg (GF_PARSE, GF_LOG_INFO, 0, LG_MSG_REGEX_OP_FAILED,
-                        "Failed to compile regex pattern.");
-                parser_deinit (parser);
-                parser = NULL;
-                goto out;
-        }
-        parser->complete_str = NULL;
+    int rc = 0;
+    struct parser *parser = NULL;
+
+    parser = GF_MALLOC(sizeof(*parser), gf_common_mt_parser_t);
+    if (!parser)
+        goto out;
+
+    parser->regex = gf_strdup(regex);
+    if (!parser->regex) {
+        GF_FREE(parser);
+        parser = NULL;
+        goto out;
+    }
+
+    rc = regcomp(&parser->preg, parser->regex, REG_EXTENDED);
+    if (rc != 0) {
+        gf_msg(GF_PARSE, GF_LOG_INFO, 0, LG_MSG_REGEX_OP_FAILED,
+               "Failed to compile regex pattern.");
+        parser_deinit(parser);
+        parser = NULL;
+        goto out;
+    }
+    parser->complete_str = NULL;
 out:
-        return parser;
+    return parser;
 }
 
 /**
@@ -78,22 +76,22 @@ out:
  *          failure: -EINVAL for NULL args, -ENOMEM for allocation errors
  */
 int
-parser_set_string (struct parser *parser, const char *complete_str)
+parser_set_string(struct parser *parser, const char *complete_str)
 {
-        int ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
-        GF_VALIDATE_OR_GOTO (GF_PARSE, complete_str, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, complete_str, out);
 
-        parser->complete_str = gf_strdup (complete_str);
-        GF_CHECK_ALLOC_AND_LOG (GF_PARSE, parser, ret,
-                                "Failed to duplicate string!", out);
+    parser->complete_str = gf_strdup(complete_str);
+    GF_CHECK_ALLOC_AND_LOG(GF_PARSE, parser, ret, "Failed to duplicate string!",
+                           out);
 
-        /* Point the temp internal string to what we just dup'ed */
-        parser->_rstr = (char *)parser->complete_str;
-        ret = 0;
+    /* Point the temp internal string to what we just dup'ed */
+    parser->_rstr = (char *)parser->complete_str;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -107,17 +105,17 @@ out:
  *              : failure: -EINVAL on NULL args
  */
 int
-parser_unset_string (struct parser *parser)
+parser_unset_string(struct parser *parser)
 {
-        int ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
 
-        GF_FREE (parser->complete_str);
-        parser->complete_str = NULL; /* Avoid double frees in parser_deinit */
-        ret = 0;
+    GF_FREE(parser->complete_str);
+    parser->complete_str = NULL; /* Avoid double frees in parser_deinit */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -128,15 +126,15 @@ out:
  * @return    : nothing
  */
 void
-parser_deinit (struct parser *ptr)
+parser_deinit(struct parser *ptr)
 {
-        if (!ptr)
-                return;
+    if (!ptr)
+        return;
 
-        regfree (&ptr->preg);
-        GF_FREE (ptr->complete_str);
-        GF_FREE (ptr->regex);
-        GF_FREE (ptr);
+    regfree(&ptr->preg);
+    GF_FREE(ptr->complete_str);
+    GF_FREE(ptr->regex);
+    GF_FREE(ptr);
 }
 
 /**
@@ -149,29 +147,28 @@ parser_deinit (struct parser *ptr)
  *            : failure: NULL
  */
 char *
-parser_get_next_match (struct parser *parser)
+parser_get_next_match(struct parser *parser)
 {
-        int             rc       = -EINVAL;
-        size_t          copy_len = 0;
-        char            *match   = NULL;
+    int rc = -EINVAL;
+    size_t copy_len = 0;
+    char *match = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
 
-        rc = regexec (&parser->preg, parser->_rstr, 1, parser->pmatch, 0);
-        if (rc != 0) {
-                gf_msg_debug (GF_PARSE, 0,
-                        "Could not match %s with regex %s",
-                        parser->_rstr, parser->regex);
-                goto out;
-        }
+    rc = regexec(&parser->preg, parser->_rstr, 1, parser->pmatch, 0);
+    if (rc != 0) {
+        gf_msg_debug(GF_PARSE, 0, "Could not match %s with regex %s",
+                     parser->_rstr, parser->regex);
+        goto out;
+    }
 
-        copy_len = parser->pmatch[0].rm_eo - parser->pmatch[0].rm_so;
+    copy_len = parser->pmatch[0].rm_eo - parser->pmatch[0].rm_so;
 
-        match = gf_strndup (parser->_rstr + parser->pmatch[0].rm_so, copy_len);
-        GF_CHECK_ALLOC_AND_LOG (GF_PARSE, match, rc,
-                                "Duplicating match failed!", out);
+    match = gf_strndup(parser->_rstr + parser->pmatch[0].rm_so, copy_len);
+    GF_CHECK_ALLOC_AND_LOG(GF_PARSE, match, rc, "Duplicating match failed!",
+                           out);
 
-        parser->_rstr = &parser->_rstr[parser->pmatch[0].rm_eo];
+    parser->_rstr = &parser->_rstr[parser->pmatch[0].rm_eo];
 out:
-        return match;
+    return match;
 }
diff --git a/libglusterfs/src/quota-common-utils.c b/libglusterfs/src/quota-common-utils.c
index ad7e4dcba1c..804e2f0ad4b 100644
--- a/libglusterfs/src/quota-common-utils.c
+++ b/libglusterfs/src/quota-common-utils.c
@@ -8,238 +8,234 @@
    cases as published by the Free Software Foundation.
 */
 
-
-#include "dict.h"
-#include "logging.h"
-#include "byte-order.h"
-#include "quota-common-utils.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/dict.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/byte-order.h"
+#include "glusterfs/quota-common-utils.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 gf_boolean_t
-quota_meta_is_null (const quota_meta_t *meta)
+quota_meta_is_null(const quota_meta_t *meta)
 {
-        if (meta->size == 0 &&
-            meta->file_count == 0 &&
-            meta->dir_count == 0)
-                return _gf_true;
+    if (meta->size == 0 && meta->file_count == 0 && meta->dir_count == 0)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int32_t
-quota_data_to_meta (data_t *data, char *key, quota_meta_t *meta)
+quota_data_to_meta(data_t *data, quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
-        quota_meta_t  *value    = NULL;
-        int64_t       *size     = NULL;
-
-        if (!data || !key || !meta)
-                goto out;
-
-        if (data->len > sizeof (int64_t)) {
-                value = (quota_meta_t *) data->data;
-                meta->size = ntoh64 (value->size);
-                meta->file_count = ntoh64 (value->file_count);
-                if (data->len > (sizeof (int64_t)) * 2)
-                        meta->dir_count  = ntoh64 (value->dir_count);
-                else
-                        meta->dir_count = 0;
-        } else {
-                size = (int64_t *) data->data;
-                meta->size = ntoh64 (*size);
-                meta->file_count = 0;
-                meta->dir_count = 0;
-                /* This can happen during software upgrade.
-                 * Older version of glusterfs will not have inode count.
-                 * Return failure, this will be healed as part of lookup
-                 */
-                gf_msg_callingfn ("quota", GF_LOG_DEBUG, 0,
-                                  LG_MSG_QUOTA_XATTRS_MISSING, "Object quota "
-                                  "xattrs missing: len = %d", data->len);
-                ret = -2;
-                goto out;
-        }
-
-        ret = 0;
+    int32_t ret = -1;
+    quota_meta_t *value = NULL;
+    int64_t *size = NULL;
+
+    if (!data || !meta)
+        goto out;
+
+    if (data->len > sizeof(int64_t)) {
+        value = (quota_meta_t *)data->data;
+        meta->size = ntoh64(value->size);
+        meta->file_count = ntoh64(value->file_count);
+        if (data->len > (sizeof(int64_t)) * 2)
+            meta->dir_count = ntoh64(value->dir_count);
+        else
+            meta->dir_count = 0;
+    } else {
+        size = (int64_t *)data->data;
+        meta->size = ntoh64(*size);
+        meta->file_count = 0;
+        meta->dir_count = 0;
+        /* This can happen during software upgrade.
+         * Older version of glusterfs will not have inode count.
+         * Return failure, this will be healed as part of lookup
+         */
+        gf_msg_callingfn("quota", GF_LOG_DEBUG, 0, LG_MSG_QUOTA_XATTRS_MISSING,
+                         "Object quota "
+                         "xattrs missing: len = %d",
+                         data->len);
+        ret = -2;
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_get_inode_meta (dict_t *dict, char *key, quota_meta_t *meta)
+quota_dict_get_inode_meta(dict_t *dict, char *key, const int keylen,
+                          quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
-        data_t        *data     = NULL;
+    int32_t ret = -1;
+    data_t *data = NULL;
 
-        if (!dict || !key || !meta)
-                goto out;
+    if (!dict || !key || !meta)
+        goto out;
 
-        data = dict_get (dict, key);
-        if (!data || !data->data)
-                goto out;
+    data = dict_getn(dict, key, keylen);
+    if (!data || !data->data)
+        goto out;
 
-        ret = quota_data_to_meta (data, key, meta);
+    ret = quota_data_to_meta(data, meta);
 
 out:
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_get_meta (dict_t *dict, char *key, quota_meta_t *meta)
+quota_dict_get_meta(dict_t *dict, char *key, const int keylen,
+                    quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
+    int32_t ret = -1;
 
-        ret = quota_dict_get_inode_meta (dict, key, meta);
-        if (ret == -2)
-                ret = 0;
+    ret = quota_dict_get_inode_meta(dict, key, keylen, meta);
+    if (ret == -2)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_set_meta (dict_t *dict, char *key, const quota_meta_t *meta,
-                     ia_type_t ia_type)
+quota_dict_set_meta(dict_t *dict, char *key, const quota_meta_t *meta,
+                    ia_type_t ia_type)
 {
-        int32_t         ret      = -ENOMEM;
-        quota_meta_t   *value    = NULL;
-
-        value = GF_CALLOC (1, sizeof (quota_meta_t), gf_common_quota_meta_t);
-        if (value == NULL) {
-                goto out;
-        }
-
-        value->size = hton64 (meta->size);
-        value->file_count = hton64 (meta->file_count);
-        value->dir_count = hton64 (meta->dir_count);
-
-        if (ia_type == IA_IFDIR) {
-                ret = dict_set_bin (dict, key, value, sizeof (*value));
-        } else {
-                /* For a file we don't need to store dir_count in the
-                 * quota size xattr, so we set the len of the data in the dict
-                 * as 128bits, so when the posix xattrop reads the dict, it only
-                 * performs operations on size and file_count
-                 */
-                ret = dict_set_bin (dict, key, value,
-                                    sizeof (*value) - sizeof (int64_t));
-        }
-
-        if (ret < 0) {
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_DICT_SET_FAILED, "dict set failed");
-                GF_FREE (value);
-        }
+    int32_t ret = -ENOMEM;
+    quota_meta_t *value = NULL;
+
+    value = GF_MALLOC(sizeof(quota_meta_t), gf_common_quota_meta_t);
+    if (value == NULL) {
+        goto out;
+    }
+
+    value->size = hton64(meta->size);
+    value->file_count = hton64(meta->file_count);
+    value->dir_count = hton64(meta->dir_count);
+
+    if (ia_type == IA_IFDIR) {
+        ret = dict_set_bin(dict, key, value, sizeof(*value));
+    } else {
+        /* For a file we don't need to store dir_count in the
+         * quota size xattr, so we set the len of the data in the dict
+         * as 128bits, so when the posix xattrop reads the dict, it only
+         * performs operations on size and file_count
+         */
+        ret = dict_set_bin(dict, key, value, sizeof(*value) - sizeof(int64_t));
+    }
+
+    if (ret < 0) {
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_DICT_SET_FAILED,
+                         "dict set failed");
+        GF_FREE(value);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_read_header (int fd, char *buf)
+quota_conf_read_header(int fd, char *buf)
 {
-        int    header_len      = 0;
-        int    ret             = 0;
-
-        header_len = strlen (QUOTA_CONF_HEADER);
+    int ret = 0;
+    const int header_len = SLEN(QUOTA_CONF_HEADER);
 
-        ret = gf_nread (fd, buf, header_len);
-        if (ret <= 0) {
-                goto out;
-        } else if (ret > 0 && ret != header_len) {
-                ret = -1;
-                goto out;
-        }
+    ret = gf_nread(fd, buf, header_len);
+    if (ret <= 0) {
+        goto out;
+    } else if (ret > 0 && ret != header_len) {
+        ret = -1;
+        goto out;
+    }
 
-        buf[header_len-1] = 0;
+    buf[header_len - 1] = 0;
 
 out:
-        if (ret < 0)
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to read "
-                                  "header from a quota conf");
+    if (ret < 0)
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to read "
+                         "header from a quota conf");
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_read_version (int fd, float *version)
+quota_conf_read_version(int fd, float *version)
 {
-        int    ret             = 0;
-        char   buf[PATH_MAX]   = "";
-        char  *tail            = NULL;
-        float  value           = 0.0f;
-
-        ret = quota_conf_read_header (fd, buf);
-        if (ret == 0) {
-                /* quota.conf is empty */
-                value = GF_QUOTA_CONF_VERSION;
-                goto out;
-        } else if (ret < 0) {
-                goto out;
-        }
-
-        value = strtof ((buf + strlen(buf) - 3), &tail);
-        if (tail[0] != '\0') {
-                ret = -1;
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "invalid quota conf"
-                                  " version");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    char buf[PATH_MAX] = "";
+    char *tail = NULL;
+    float value = 0.0f;
+
+    ret = quota_conf_read_header(fd, buf);
+    if (ret == 0) {
+        /* quota.conf is empty */
+        value = GF_QUOTA_CONF_VERSION;
+        goto out;
+    } else if (ret < 0) {
+        goto out;
+    }
+
+    value = strtof((buf + strlen(buf) - 3), &tail);
+    if (tail[0] != '\0') {
+        ret = -1;
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "invalid quota conf"
+                         " version");
+        goto out;
+    }
+
+    ret = 0;
 
 out:
-        if (ret >= 0)
-                *version = value;
-        else
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to "
-                                  "read version from a quota conf header");
-
-        return ret;
+    if (ret >= 0)
+        *version = value;
+    else
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to "
+                         "read version from a quota conf header");
+
+    return ret;
 }
 
 int32_t
-quota_conf_read_gfid (int fd, void *buf, char *type, float version)
+quota_conf_read_gfid(int fd, void *buf, char *type, float version)
 {
-        int           ret         = 0;
-
-        ret = gf_nread (fd, buf, 16);
-        if (ret <= 0)
-                goto out;
-
-        if (ret != 16) {
-                ret = -1;
-                goto out;
-        }
-
-        if (version >= 1.2f) {
-                ret = gf_nread (fd, type, 1);
-                if (ret != 1) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = 17;
-        } else {
-                *type = GF_QUOTA_CONF_TYPE_USAGE;
+    int ret = 0;
+
+    ret = gf_nread(fd, buf, 16);
+    if (ret <= 0)
+        goto out;
+
+    if (ret != 16) {
+        ret = -1;
+        goto out;
+    }
+
+    if (version >= 1.2f) {
+        ret = gf_nread(fd, type, 1);
+        if (ret != 1) {
+            ret = -1;
+            goto out;
         }
+        ret = 17;
+    } else {
+        *type = GF_QUOTA_CONF_TYPE_USAGE;
+    }
 
 out:
-        if (ret < 0)
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to "
-                                  "read gfid from a quota conf");
+    if (ret < 0)
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to "
+                         "read gfid from a quota conf");
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_skip_header (int fd)
+quota_conf_skip_header(int fd)
 {
-        return gf_skip_header_section (fd, strlen (QUOTA_CONF_HEADER));
+    return gf_skip_header_section(fd, strlen(QUOTA_CONF_HEADER));
 }
-
diff --git a/libglusterfs/src/quota-common-utils.h b/libglusterfs/src/quota-common-utils.h
deleted file mode 100644
index e479398c398..00000000000
--- a/libglusterfs/src/quota-common-utils.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#ifndef _QUOTA_COMMON_UTILS_H
-#define _QUOTA_COMMON_UTILS_H
-
-#include "iatt.h"
-
-#define GF_QUOTA_CONF_VERSION 1.2
-#define QUOTA_CONF_HEADER                           \
-        "GlusterFS Quota conf | version: v1.2\n"
-#define QUOTA_CONF_HEADER_1_1                       \
-        "GlusterFS Quota conf | version: v1.1\n"
-
-typedef enum {
-        GF_QUOTA_CONF_TYPE_USAGE = 1,
-        GF_QUOTA_CONF_TYPE_OBJECTS
-} gf_quota_conf_type_t;
-
-struct _quota_limits {
-        int64_t hl;
-        int64_t sl;
-} __attribute__ ((__packed__));
-typedef struct _quota_limits quota_limits_t;
-
-struct _quota_meta {
-        int64_t size;
-        int64_t file_count;
-        int64_t dir_count;
-} __attribute__ ((__packed__));
-typedef struct _quota_meta quota_meta_t;
-
-gf_boolean_t
-quota_meta_is_null (const quota_meta_t *meta);
-
-int32_t
-quota_data_to_meta (data_t *data, char *key, quota_meta_t *meta);
-
-int32_t
-quota_dict_get_inode_meta (dict_t *dict, char *key, quota_meta_t *meta);
-
-int32_t
-quota_dict_get_meta (dict_t *dict, char *key, quota_meta_t *meta);
-
-int32_t
-quota_dict_set_meta (dict_t *dict, char *key, const quota_meta_t *meta,
-                     ia_type_t ia_type);
-
-int32_t
-quota_conf_read_header (int fd, char *buf);
-
-int32_t
-quota_conf_read_version (int fd, float *version);
-
-int32_t
-quota_conf_read_gfid (int fd, void *buf, char *type, float version);
-
-int32_t
-quota_conf_skip_header (int fd);
-
-#endif /* _QUOTA_COMMON_UTILS_H */
diff --git a/libglusterfs/src/rbthash.c b/libglusterfs/src/rbthash.c
index 52d8a15fd2c..c90b5a21f44 100644
--- a/libglusterfs/src/rbthash.c
+++ b/libglusterfs/src/rbthash.c
@@ -8,70 +8,66 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "rbthash.h"
+#include "glusterfs/rbthash.h"
 #include "rb.h"
-#include "locking.h"
-#include "mem-pool.h"
-#include "logging.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/locking.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 #include <pthread.h>
 #include <string.h>
 
-
 int
-rbthash_comparator (void *entry1, void *entry2, void *param)
+rbthash_comparator(void *entry1, void *entry2, void *param)
 {
-        int             ret = 0;
-        rbthash_entry_t *e1 = NULL;
-        rbthash_entry_t *e2 = NULL;
+    int ret = 0;
+    rbthash_entry_t *e1 = NULL;
+    rbthash_entry_t *e2 = NULL;
 
-        if ((!entry1) || (!entry2) || (!param))
-                return -1;
+    if ((!entry1) || (!entry2) || (!param))
+        return -1;
 
-        e1 = (rbthash_entry_t *)entry1;
-        e2 = (rbthash_entry_t *)entry2;
+    e1 = (rbthash_entry_t *)entry1;
+    e2 = (rbthash_entry_t *)entry2;
 
-        if (e1->keylen != e2->keylen) {
-                if (e1->keylen < e2->keylen)
-                        ret = -1;
-                else if (e1->keylen > e2->keylen)
-                        ret = 1;
-        } else
-                ret = memcmp (e1->key, e2->key, e1->keylen);
+    if (e1->keylen != e2->keylen) {
+        if (e1->keylen < e2->keylen)
+            ret = -1;
+        else if (e1->keylen > e2->keylen)
+            ret = 1;
+    } else
+        ret = memcmp(e1->key, e2->key, e1->keylen);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__rbthash_init_buckets (rbthash_table_t *tbl, int buckets)
+__rbthash_init_buckets(rbthash_table_t *tbl, int buckets)
 {
-        int     i = 0;
-        int     ret = -1;
-
-        if (!tbl)
-                return -1;
-
-        for (; i < buckets; i++) {
-                LOCK_INIT (&tbl->buckets[i].bucketlock);
-                tbl->buckets[i].bucket = rb_create ((rb_comparison_func *)rbthash_comparator, tbl, NULL);
-                if (!tbl->buckets[i].bucket) {
-                        gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                                LG_MSG_RB_TABLE_CREATE_FAILED, "Failed to "
-                                "create rb table bucket");
-                        ret = -1;
-                        goto err;
-                }
+    int i = 0;
+    int ret = -1;
+
+    if (!tbl)
+        return -1;
+
+    for (; i < buckets; i++) {
+        LOCK_INIT(&tbl->buckets[i].bucketlock);
+        tbl->buckets[i].bucket = rb_create(
+            (rb_comparison_func *)rbthash_comparator, tbl, NULL);
+        if (!tbl->buckets[i].bucket) {
+            gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RB_TABLE_CREATE_FAILED,
+                    NULL);
+            ret = -1;
+            goto err;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 /*
  * rbthash_table_init - Initialize a RBT based hash table
  * @buckets - Number of buckets in the hash table
@@ -83,390 +79,376 @@ err:
  */
 
 rbthash_table_t *
-rbthash_table_init (int buckets, rbt_hasher_t hfunc,
-                    rbt_data_destroyer_t dfunc,
-                    unsigned long expected_entries,
-                    struct mem_pool *entrypool)
+rbthash_table_init(glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
+                   rbt_data_destroyer_t dfunc, unsigned long expected_entries,
+                   struct mem_pool *entrypool)
 {
-        rbthash_table_t         *newtab = NULL;
-        int                     ret = -1;
-
-        if (!hfunc) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR,
-                        "Hash function not given");
-                return NULL;
+    rbthash_table_t *newtab = NULL;
+    int ret = -1;
+
+    if (!hfunc) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR, NULL);
+        return NULL;
+    }
+
+    if (!entrypool && !expected_entries) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_ENTRIES_NOT_PROVIDED, NULL);
+        return NULL;
+    }
+
+    if (entrypool && expected_entries) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_ENTRIES_PROVIDED, NULL);
+        return NULL;
+    }
+
+    newtab = GF_CALLOC(1, sizeof(*newtab), gf_common_mt_rbthash_table_t);
+    if (!newtab)
+        return NULL;
+
+    newtab->buckets = GF_CALLOC(buckets, sizeof(struct rbthash_bucket),
+                                gf_common_mt_rbthash_bucket);
+    if (!newtab->buckets) {
+        goto free_newtab;
+    }
+
+    if (expected_entries) {
+        newtab->entrypool = mem_pool_new_ctx(ctx, rbthash_entry_t,
+                                             expected_entries);
+        if (!newtab->entrypool) {
+            goto free_buckets;
         }
-
-        if (!entrypool && !expected_entries) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Both mem-pool and expected entries not provided");
-                return NULL;
-        }
-
-        if (entrypool && expected_entries) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Both mem-pool and expected entries are provided");
-                return NULL;
-        }
-
-
-        newtab = GF_CALLOC (1, sizeof (*newtab),
-                            gf_common_mt_rbthash_table_t);
-        if (!newtab)
-                return NULL;
-
-        newtab->buckets = GF_CALLOC (buckets, sizeof (struct rbthash_bucket),
-                                     gf_common_mt_rbthash_bucket);
-        if (!newtab->buckets) {
-                goto free_newtab;
-        }
-
-        if (expected_entries) {
-                newtab->entrypool =
-                        mem_pool_new (rbthash_entry_t, expected_entries);
-                if (!newtab->entrypool) {
-                        goto free_buckets;
-                }
-                newtab->pool_alloced = _gf_true;
-        } else {
-                newtab->entrypool = entrypool;
-        }
-
-        LOCK_INIT (&newtab->tablelock);
-        INIT_LIST_HEAD (&newtab->list);
-        newtab->numbuckets = buckets;
-        ret = __rbthash_init_buckets (newtab, buckets);
-
-        if (ret == -1) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
-                        "Failed to init buckets");
-                if (newtab->pool_alloced)
-                        mem_pool_destroy (newtab->entrypool);
-        } else {
-                gf_msg_trace (GF_RBTHASH, 0, "Inited hash table: buckets:"
-                        " %d", buckets);
-        }
-
-        newtab->hashfunc = hfunc;
-        newtab->dfunc = dfunc;
+        newtab->pool_alloced = _gf_true;
+    } else {
+        newtab->entrypool = entrypool;
+    }
+
+    LOCK_INIT(&newtab->tablelock);
+    INIT_LIST_HEAD(&newtab->list);
+    newtab->numbuckets = buckets;
+    ret = __rbthash_init_buckets(newtab, buckets);
+
+    if (ret == -1) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
+                NULL);
+        if (newtab->pool_alloced)
+            mem_pool_destroy(newtab->entrypool);
+    } else {
+        gf_msg_trace(GF_RBTHASH, 0,
+                     "Inited hash table: buckets:"
+                     " %d",
+                     buckets);
+    }
+
+    newtab->hashfunc = hfunc;
+    newtab->dfunc = dfunc;
 
 free_buckets:
-        if (ret == -1)
-                GF_FREE (newtab->buckets);
+    if (ret == -1)
+        GF_FREE(newtab->buckets);
 
 free_newtab:
-        if (ret == -1) {
-                GF_FREE (newtab);
-                newtab = NULL;
-        }
+    if (ret == -1) {
+        GF_FREE(newtab);
+        newtab = NULL;
+    }
 
-        return newtab;
+    return newtab;
 }
 
 rbthash_entry_t *
-rbthash_init_entry (rbthash_table_t *tbl, void *data, void *key, int keylen)
+rbthash_init_entry(rbthash_table_t *tbl, void *data, void *key, int keylen)
 {
-        int             ret = -1;
-        rbthash_entry_t *entry = NULL;
-
-        if ((!tbl) || (!data) || (!key))
-                return NULL;
-
-        entry = mem_get (tbl->entrypool);
-        if (!entry) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_ENTRY_FAILED,
-                        "Failed to get entry from mem-pool");
-                goto ret;
-        }
-
-        entry->data = data;
-        entry->key = GF_CALLOC (keylen, sizeof (char), gf_common_mt_char);
-        if (!entry->key) {
-                goto free_entry;
-        }
-
-        INIT_LIST_HEAD (&entry->list);
-        memcpy (entry->key, key, keylen);
-        entry->keylen = keylen;
-        entry->keyhash = tbl->hashfunc (entry->key, entry->keylen);
-        gf_msg_trace (GF_RBTHASH, 0, "HASH: %u", entry->keyhash);
-
-        ret = 0;
+    int ret = -1;
+    rbthash_entry_t *entry = NULL;
+
+    if ((!tbl) || (!data) || (!key))
+        return NULL;
+
+    entry = mem_get(tbl->entrypool);
+    if (!entry) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_ENTRY_FAILED,
+                NULL);
+        goto ret;
+    }
+
+    entry->data = data;
+    entry->key = GF_MALLOC(keylen, gf_common_mt_char);
+    if (!entry->key) {
+        goto free_entry;
+    }
+
+    INIT_LIST_HEAD(&entry->list);
+    memcpy(entry->key, key, keylen);
+    entry->keylen = keylen;
+    entry->keyhash = tbl->hashfunc(entry->key, entry->keylen);
+    gf_msg_trace(GF_RBTHASH, 0, "HASH: %u", entry->keyhash);
+
+    ret = 0;
 free_entry:
-        if (ret == -1) {
-                mem_put (entry);
-                entry = NULL;
-        }
+    if (ret == -1) {
+        mem_put(entry);
+        entry = NULL;
+    }
 
 ret:
-        return entry;
+    return entry;
 }
 
-
 void
-rbthash_deinit_entry (rbthash_table_t *tbl, rbthash_entry_t *entry)
+rbthash_deinit_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
+    if (!entry)
+        return;
 
-        if (!entry)
-                return;
-
-        GF_FREE (entry->key);
-
-        if (tbl) {
-                if ((entry->data) && (tbl->dfunc))
-                        tbl->dfunc (entry->data);
+    GF_FREE(entry->key);
 
-                LOCK (&tbl->tablelock);
-                {
-                        list_del_init (&entry->list);
-                }
-                UNLOCK (&tbl->tablelock);
+    if (tbl) {
+        if ((entry->data) && (tbl->dfunc))
+            tbl->dfunc(entry->data);
 
-                mem_put (entry);
+        LOCK(&tbl->tablelock);
+        {
+            list_del_init(&entry->list);
         }
+        UNLOCK(&tbl->tablelock);
 
-        return;
-}
+        mem_put(entry);
+    }
 
+    return;
+}
 
 static struct rbthash_bucket *
-rbthash_entry_bucket (rbthash_table_t *tbl, rbthash_entry_t * entry)
+rbthash_entry_bucket(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
-        int     nbucket = 0;
+    int nbucket = 0;
 
-        nbucket = (entry->keyhash % tbl->numbuckets);
-        gf_msg_trace (GF_RBTHASH, 0, "BUCKET: %d", nbucket);
-        return &tbl->buckets[nbucket];
+    nbucket = (entry->keyhash % tbl->numbuckets);
+    gf_msg_trace(GF_RBTHASH, 0, "BUCKET: %d", nbucket);
+    return &tbl->buckets[nbucket];
 }
 
-
 int
-rbthash_insert_entry (rbthash_table_t *tbl, rbthash_entry_t *entry)
+rbthash_insert_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
-        struct rbthash_bucket   *bucket = NULL;
-        int                     ret = -1;
-
-        if ((!tbl) || (!entry))
-                return -1;
-
-        bucket = rbthash_entry_bucket (tbl, entry);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                goto err;
+    struct rbthash_bucket *bucket = NULL;
+    int ret = -1;
+
+    if ((!tbl) || (!entry))
+        return -1;
+
+    bucket = rbthash_entry_bucket(tbl, entry);
+    if (!bucket) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
+        goto err;
+    }
+
+    ret = 0;
+    LOCK(&bucket->bucketlock);
+    {
+        if (!rb_probe(bucket->bucket, (void *)entry)) {
+            UNLOCK(&bucket->bucketlock);
+            gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+                    NULL);
+            ret = -1;
+            goto err;
         }
-
-        ret = 0;
-        LOCK (&bucket->bucketlock);
-        {
-                if (!rb_probe (bucket->bucket, (void *)entry)) {
-                        gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                                LG_MSG_RBTHASH_INSERT_FAILED, "Failed to insert"
-                                " entry");
-                        ret = -1;
-                }
-        }
-        UNLOCK (&bucket->bucketlock);
+    }
+    UNLOCK(&bucket->bucketlock);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rbthash_insert (rbthash_table_t *tbl, void *data, void *key, int keylen)
+rbthash_insert(rbthash_table_t *tbl, void *data, void *key, int keylen)
 {
-        rbthash_entry_t         *entry = NULL;
-        int                     ret = -1;
-
-        if ((!tbl) || (!data) || (!key))
-                return -1;
-
-        entry = rbthash_init_entry (tbl, data, key, keylen);
-        if (!entry) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
-                        "Failed to init entry");
-                goto err;
-        }
-
-        ret = rbthash_insert_entry (tbl, entry);
-
-        if (ret == -1) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INSERT_FAILED,
-                        "Failed to insert entry");
-                rbthash_deinit_entry (tbl, entry);
-        }
-
-        LOCK (&tbl->tablelock);
-        {
-                list_add_tail (&entry->list, &tbl->list);
-        }
-        UNLOCK (&tbl->tablelock);
+    rbthash_entry_t *entry = NULL;
+    int ret = -1;
+
+    if ((!tbl) || (!data) || (!key))
+        return -1;
+
+    entry = rbthash_init_entry(tbl, data, key, keylen);
+    if (!entry) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
+                NULL);
+        goto err;
+    }
+
+    ret = rbthash_insert_entry(tbl, entry);
+
+    if (ret == -1) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+                NULL);
+        rbthash_deinit_entry(tbl, entry);
+        goto err;
+    }
+
+    LOCK(&tbl->tablelock);
+    {
+        list_add_tail(&entry->list, &tbl->list);
+    }
+    UNLOCK(&tbl->tablelock);
 
 err:
-        return ret;
+    return ret;
 }
 
 static struct rbthash_bucket *
-rbthash_key_bucket (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_key_bucket(rbthash_table_t *tbl, void *key, int keylen)
 {
-        uint32_t        keyhash = 0;
-        int             nbucket = 0;
+    uint32_t keyhash = 0;
+    int nbucket = 0;
 
-        if ((!tbl) || (!key))
-                return NULL;
+    if ((!tbl) || (!key))
+        return NULL;
 
-        keyhash =  tbl->hashfunc (key, keylen);
-        gf_msg_trace (GF_RBTHASH, 0, "HASH: %u", keyhash);
-        nbucket = (keyhash % tbl->numbuckets);
-        gf_msg_trace (GF_RBTHASH, 0, "BUCKET: %u", nbucket);
+    keyhash = tbl->hashfunc(key, keylen);
+    gf_msg_trace(GF_RBTHASH, 0, "HASH: %u", keyhash);
+    nbucket = (keyhash % tbl->numbuckets);
+    gf_msg_trace(GF_RBTHASH, 0, "BUCKET: %u", nbucket);
 
-        return &tbl->buckets[nbucket];
+    return &tbl->buckets[nbucket];
 }
 
-
 void *
-rbthash_get (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_get(rbthash_table_t *tbl, void *key, int keylen)
 {
-        struct rbthash_bucket           *bucket = NULL;
-        rbthash_entry_t                 *entry = NULL;
-        rbthash_entry_t                 searchentry = {0, };
-
-        if ((!tbl) || (!key))
-                return NULL;
-
-        bucket = rbthash_key_bucket (tbl, key, keylen);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                return NULL;
-        }
-
-        searchentry.key = key;
-        searchentry.keylen = keylen;
-        LOCK (&bucket->bucketlock);
-        {
-                entry = rb_find (bucket->bucket, &searchentry);
-        }
-        UNLOCK (&bucket->bucketlock);
-
-        if (!entry)
-                return NULL;
-
-        return entry->data;
+    struct rbthash_bucket *bucket = NULL;
+    rbthash_entry_t *entry = NULL;
+    rbthash_entry_t searchentry = {
+        0,
+    };
+
+    if ((!tbl) || (!key))
+        return NULL;
+
+    bucket = rbthash_key_bucket(tbl, key, keylen);
+    if (!bucket) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
+        return NULL;
+    }
+
+    searchentry.key = key;
+    searchentry.keylen = keylen;
+    LOCK(&bucket->bucketlock);
+    {
+        entry = rb_find(bucket->bucket, &searchentry);
+    }
+    UNLOCK(&bucket->bucketlock);
+
+    if (!entry)
+        return NULL;
+
+    return entry->data;
 }
 
-
 void *
-rbthash_remove (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_remove(rbthash_table_t *tbl, void *key, int keylen)
 {
-        struct rbthash_bucket   *bucket = NULL;
-        rbthash_entry_t         *entry = NULL;
-        rbthash_entry_t         searchentry = {0, };
-        void                    *dataref = NULL;
-
-        if ((!tbl) || (!key))
-                return NULL;
-
-        bucket = rbthash_key_bucket (tbl, key, keylen);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                return NULL;
-        }
-
-        searchentry.key = key;
-        searchentry.keylen = keylen;
-
-        LOCK (&bucket->bucketlock);
-        {
-                entry = rb_delete (bucket->bucket, &searchentry);
-        }
-        UNLOCK (&bucket->bucketlock);
-
-        if (!entry)
-                return NULL;
-
-        GF_FREE (entry->key);
-        dataref = entry->data;
-
-        LOCK (&tbl->tablelock);
-        {
-                list_del_init (&entry->list);
-        }
-        UNLOCK (&tbl->tablelock);
-
-        mem_put (entry);
-
-        return dataref;
+    struct rbthash_bucket *bucket = NULL;
+    rbthash_entry_t *entry = NULL;
+    rbthash_entry_t searchentry = {
+        0,
+    };
+    void *dataref = NULL;
+
+    if ((!tbl) || (!key))
+        return NULL;
+
+    bucket = rbthash_key_bucket(tbl, key, keylen);
+    if (!bucket) {
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
+        return NULL;
+    }
+
+    searchentry.key = key;
+    searchentry.keylen = keylen;
+
+    LOCK(&bucket->bucketlock);
+    {
+        entry = rb_delete(bucket->bucket, &searchentry);
+    }
+    UNLOCK(&bucket->bucketlock);
+
+    if (!entry)
+        return NULL;
+
+    GF_FREE(entry->key);
+    dataref = entry->data;
+
+    LOCK(&tbl->tablelock);
+    {
+        list_del_init(&entry->list);
+    }
+    UNLOCK(&tbl->tablelock);
+
+    mem_put(entry);
+
+    return dataref;
 }
 
-
 void
-rbthash_entry_deiniter (void *entry, void *rbparam)
+rbthash_entry_deiniter(void *entry, void *rbparam)
 {
-        if (!entry)
-                return;
+    if (!entry)
+        return;
 
-        rbthash_deinit_entry (rbparam, entry);
+    rbthash_deinit_entry(rbparam, entry);
 }
 
-
 void
-rbthash_table_destroy_buckets (rbthash_table_t *tbl)
+rbthash_table_destroy_buckets(rbthash_table_t *tbl)
 {
-        int x = 0;
-        if (!tbl)
-                return;
+    int x = 0;
+    if (!tbl)
+        return;
 
-        for (;x < tbl->numbuckets; x++) {
-                LOCK_DESTROY (&tbl->buckets[x].bucketlock);
-                rb_destroy (tbl->buckets[x].bucket, rbthash_entry_deiniter);
-        }
+    for (; x < tbl->numbuckets; x++) {
+        LOCK_DESTROY(&tbl->buckets[x].bucketlock);
+        rb_destroy(tbl->buckets[x].bucket, rbthash_entry_deiniter);
+    }
 
-        return;
+    return;
 }
 
-
 void
-rbthash_table_destroy (rbthash_table_t *tbl)
+rbthash_table_destroy(rbthash_table_t *tbl)
 {
-        if (!tbl)
-                return;
+    if (!tbl)
+        return;
 
-        rbthash_table_destroy_buckets (tbl);
-        if (tbl->pool_alloced)
-                mem_pool_destroy (tbl->entrypool);
+    rbthash_table_destroy_buckets(tbl);
+    if (tbl->pool_alloced)
+        mem_pool_destroy(tbl->entrypool);
 
-        GF_FREE (tbl->buckets);
-        GF_FREE (tbl);
+    GF_FREE(tbl->buckets);
+    GF_FREE(tbl);
 }
 
-
 void
-rbthash_table_traverse (rbthash_table_t *tbl, rbt_traverse_t traverse,
-                        void *mydata)
+rbthash_table_traverse(rbthash_table_t *tbl, rbt_traverse_t traverse,
+                       void *mydata)
 {
-        rbthash_entry_t *entry = NULL;
+    rbthash_entry_t *entry = NULL;
 
-        if ((tbl == NULL) || (traverse == NULL)) {
-                goto out;
-        }
+    if ((tbl == NULL) || (traverse == NULL)) {
+        goto out;
+    }
 
-        LOCK (&tbl->tablelock);
+    LOCK(&tbl->tablelock);
+    {
+        list_for_each_entry(entry, &tbl->list, list)
         {
-                list_for_each_entry (entry, &tbl->list, list) {
-                        traverse (entry->data, mydata);
-                }
+            traverse(entry->data, mydata);
         }
-        UNLOCK (&tbl->tablelock);
+    }
+    UNLOCK(&tbl->tablelock);
 
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/rbthash.h b/libglusterfs/src/rbthash.h
deleted file mode 100644
index b093ce9982d..00000000000
--- a/libglusterfs/src/rbthash.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __RBTHASH_TABLE_H_
-#define __RBTHASH_TABLE_H_
-#include "rb.h"
-#include "locking.h"
-#include "mem-pool.h"
-#include "logging.h"
-#include "common-utils.h"
-#include "list.h"
-
-#include <pthread.h>
-
-#define GF_RBTHASH_MEMPOOL      16384 //1048576
-#define GF_RBTHASH              "rbthash"
-
-struct rbthash_bucket {
-        struct rb_table *bucket;
-        gf_lock_t       bucketlock;
-};
-
-typedef struct rbthash_entry {
-        void            *data;
-        void            *key;
-        int              keylen;
-        uint32_t         keyhash;
-        struct list_head list;
-} rbthash_entry_t;
-
-typedef uint32_t (*rbt_hasher_t) (void *data, int len);
-typedef void (*rbt_data_destroyer_t) (void *data);
-typedef void (*rbt_traverse_t) (void *data, void *mydata);
-
-typedef struct rbthash_table {
-        int                     size;
-        int                     numbuckets;
-        struct mem_pool         *entrypool;
-        gf_lock_t               tablelock;
-        struct rbthash_bucket   *buckets;
-        rbt_hasher_t            hashfunc;
-        rbt_data_destroyer_t    dfunc;
-        gf_boolean_t            pool_alloced;
-        struct list_head        list;
-} rbthash_table_t;
-
-extern rbthash_table_t *
-rbthash_table_init (int buckets, rbt_hasher_t hfunc,
-                    rbt_data_destroyer_t dfunc, unsigned long expected_entries,
-                    struct mem_pool *entrypool);
-
-extern int
-rbthash_insert (rbthash_table_t *tbl, void *data, void *key, int keylen);
-
-extern void *
-rbthash_get (rbthash_table_t *tbl, void *key, int keylen);
-
-extern void *
-rbthash_remove (rbthash_table_t *tbl, void *key, int keylen);
-
-extern void *
-rbthash_replace (rbthash_table_t *tbl, void *key, int keylen, void *newdata);
-
-extern void
-rbthash_table_destroy (rbthash_table_t *tbl);
-
-extern void
-rbthash_table_traverse (rbthash_table_t *tbl, rbt_traverse_t traverse,
-                        void *mydata);
-#endif
diff --git a/libglusterfs/src/refcount.c b/libglusterfs/src/refcount.c
index 5787da290bb..d5a5a82fa0f 100644
--- a/libglusterfs/src/refcount.c
+++ b/libglusterfs/src/refcount.c
@@ -8,102 +8,101 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "common-utils.h"
-#include "refcount.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/refcount.h"
 
 #ifndef REFCOUNT_NEEDS_LOCK
 
 void *
-_gf_ref_get (gf_ref_t *ref)
+_gf_ref_get(gf_ref_t *ref)
 {
-        unsigned int cnt = __sync_fetch_and_add (&ref->cnt, 1);
-
-        /* if cnt == 0, we're in a fatal position, the object will be free'd
-         *
-         * There is a race when two threads do a _gf_ref_get(). Only one of
-         * them may get a 0 returned. That is acceptible, because one
-         * _gf_ref_get() returning 0 should be handled as a fatal problem and
-         * when correct usage/locking is used, it should never happen.
-         */
-        GF_ASSERT (cnt != 0);
-
-        return cnt ? ref->data : NULL;
+    unsigned int cnt = __sync_fetch_and_add(&ref->cnt, 1);
+
+    /* if cnt == 0, we're in a fatal position, the object will be free'd
+     *
+     * There is a race when two threads do a _gf_ref_get(). Only one of
+     * them may get a 0 returned. That is acceptable, because one
+     * _gf_ref_get() returning 0 should be handled as a fatal problem and
+     * when correct usage/locking is used, it should never happen.
+     */
+    GF_ASSERT(cnt != 0);
+
+    return cnt ? ref->data : NULL;
 }
 
 unsigned int
-_gf_ref_put (gf_ref_t *ref)
+_gf_ref_put(gf_ref_t *ref)
 {
-        unsigned int cnt = __sync_fetch_and_sub (&ref->cnt, 1);
+    unsigned int cnt = __sync_fetch_and_sub(&ref->cnt, 1);
 
-        /* if cnt == 1, the last user just did a _gf_ref_put()
-         *
-         * When cnt == 0, one _gf_ref_put() was done too much and there has
-         * been a thread using the refcounted structure when it was not
-         * supposed to.
-         */
-        GF_ASSERT (cnt != 0);
+    /* if cnt == 1, the last user just did a _gf_ref_put()
+     *
+     * When cnt == 0, one _gf_ref_put() was done too much and there has
+     * been a thread using the refcounted structure when it was not
+     * supposed to.
+     */
+    GF_ASSERT(cnt != 0);
 
-        if (cnt == 1 && ref->release)
-                ref->release (ref->data);
+    if (cnt == 1 && ref->release)
+        ref->release(ref->data);
 
-        return (cnt != 1);
+    return (cnt != 1);
 }
 
 #else
 
 void *
-_gf_ref_get (gf_ref_t *ref)
+_gf_ref_get(gf_ref_t *ref)
 {
-        unsigned int cnt = 0;
-
-        LOCK (&ref->lk);
-        {
-                /* never can be 0, should have been free'd */
-                if (ref->cnt > 0)
-                        cnt = ++ref->cnt;
-                else
-                        GF_ASSERT (ref->cnt > 0);
-        }
-        UNLOCK (&ref->lk);
-
-        return cnt ? ref->data : NULL;
+    unsigned int cnt = 0;
+
+    LOCK(&ref->lk);
+    {
+        /* never can be 0, should have been free'd */
+        if (ref->cnt > 0)
+            cnt = ++ref->cnt;
+        else
+            GF_ASSERT(ref->cnt > 0);
+    }
+    UNLOCK(&ref->lk);
+
+    return cnt ? ref->data : NULL;
 }
 
 unsigned int
-_gf_ref_put (gf_ref_t *ref)
+_gf_ref_put(gf_ref_t *ref)
 {
-        unsigned int cnt = 0;
-        int release = 0;
-
-        LOCK (&ref->lk);
-        {
-                if (ref->cnt != 0) {
-                        cnt = --ref->cnt;
-                        /* call release() only when cnt == 0 */
-                        release = (cnt == 0);
-                } else
-                        GF_ASSERT (ref->cnt != 0);
-        }
-        UNLOCK (&ref->lk);
-
-        if (release && ref->release)
-                ref->release (ref->data);
-
-        return !release;
+    unsigned int cnt = 0;
+    int release = 0;
+
+    LOCK(&ref->lk);
+    {
+        if (ref->cnt != 0) {
+            cnt = --ref->cnt;
+            /* call release() only when cnt == 0 */
+            release = (cnt == 0);
+        } else
+            GF_ASSERT(ref->cnt != 0);
+    }
+    UNLOCK(&ref->lk);
+
+    if (release && ref->release)
+        ref->release(ref->data);
+
+    return !release;
 }
 
 #endif /* REFCOUNT_NEEDS_LOCK */
 
-
 void
-_gf_ref_init (gf_ref_t *ref, gf_ref_release_t release, void *data)
+_gf_ref_init(gf_ref_t *ref, gf_ref_release_t release, void *data)
 {
-        GF_ASSERT (ref);
+    GF_ASSERT(ref);
 
 #ifdef REFCOUNT_NEEDS_LOCK
-        LOCK_INIT (&ref->lk);
+    LOCK_INIT(&ref->lk);
 #endif
-        ref->cnt = 1;
-        ref->release = release;
-        ref->data = data;
+    ref->cnt = 1;
+    ref->release = release;
+    ref->data = data;
 }
diff --git a/libglusterfs/src/rot-buffs.c b/libglusterfs/src/rot-buffs.c
index 4f3eb35fa96..260bf16ecea 100644
--- a/libglusterfs/src/rot-buffs.c
+++ b/libglusterfs/src/rot-buffs.c
@@ -10,10 +10,10 @@
 
 #include <math.h>
 
-#include "mem-types.h"
-#include "mem-pool.h"
+#include "glusterfs/mem-types.h"
+#include "glusterfs/mem-pool.h"
 
-#include "rot-buffs.h"
+#include "glusterfs/rot-buffs.h"
 
 /**
  * Producer-Consumer based on top of rotational buffers.
@@ -26,384 +26,383 @@
  * TODO: do away with opaques (use arrays with indexing).
  */
 
-#define ROT_BUFF_DEFAULT_COUNT  2
-#define ROT_BUFF_ALLOC_SIZE  (1 * 1024 * 1024)  /* 1MB per iovec */
+#define ROT_BUFF_DEFAULT_COUNT 2
+#define ROT_BUFF_ALLOC_SIZE (1 * 1024 * 1024) /* 1MB per iovec */
 
-#define RLIST_IOV_MELDED_ALLOC_SIZE  (RBUF_IOVEC_SIZE + ROT_BUFF_ALLOC_SIZE)
+#define RLIST_IOV_MELDED_ALLOC_SIZE (RBUF_IOVEC_SIZE + ROT_BUFF_ALLOC_SIZE)
 
 /**
- * iovec list is not shrinked (deallocated) if usage/total count
+ * iovec list is not shrunk (deallocated) if usage/total count
  * falls in this range. this is the fast path and should satisfy
  * most of the workloads. for the rest shrinking iovec list is
  * generous.
  */
-#define RVEC_LOW_WATERMARK_COUNT  1
+#define RVEC_LOW_WATERMARK_COUNT 1
 #define RVEC_HIGH_WATERMARK_COUNT (1 << 4)
 
-static inline
-rbuf_list_t *rbuf_current_buffer (rbuf_t *rbuf)
+static inline rbuf_list_t *
+rbuf_current_buffer(rbuf_t *rbuf)
 {
-        return rbuf->current;
+    return rbuf->current;
 }
 
 static void
-rlist_mark_waiting (rbuf_list_t *rlist)
+rlist_mark_waiting(rbuf_list_t *rlist)
 {
-        LOCK (&rlist->c_lock);
-        {
-                rlist->awaiting = _gf_true;
-        }
-        UNLOCK (&rlist->c_lock);
+    LOCK(&rlist->c_lock);
+    {
+        rlist->awaiting = _gf_true;
+    }
+    UNLOCK(&rlist->c_lock);
 }
 
 static int
-__rlist_has_waiter (rbuf_list_t *rlist)
+__rlist_has_waiter(rbuf_list_t *rlist)
 {
-        return (rlist->awaiting == _gf_true);
+    return (rlist->awaiting == _gf_true);
 }
 
 static void *
-rbuf_alloc_rvec ()
+rbuf_alloc_rvec()
 {
-        return GF_CALLOC (1, RLIST_IOV_MELDED_ALLOC_SIZE, gf_common_mt_rvec_t);
+    return GF_CALLOC(1, RLIST_IOV_MELDED_ALLOC_SIZE, gf_common_mt_rvec_t);
 }
 
 static void
-rlist_reset_vector_usage (rbuf_list_t *rlist)
+rlist_reset_vector_usage(rbuf_list_t *rlist)
 {
-        rlist->used = 1;
+    rlist->used = 1;
 }
 
 static void
-rlist_increment_vector_usage (rbuf_list_t *rlist)
+rlist_increment_vector_usage(rbuf_list_t *rlist)
 {
-        rlist->used++;
+    rlist->used++;
 }
 
 static void
-rlist_increment_total_usage (rbuf_list_t *rlist)
+rlist_increment_total_usage(rbuf_list_t *rlist)
 {
-        rlist->total++;
+    rlist->total++;
 }
 
 static int
-rvec_in_watermark_range (rbuf_list_t *rlist)
+rvec_in_watermark_range(rbuf_list_t *rlist)
 {
-        return ((rlist->total >= RVEC_LOW_WATERMARK_COUNT)
-                    && (rlist->total <= RVEC_HIGH_WATERMARK_COUNT));
+    return ((rlist->total >= RVEC_LOW_WATERMARK_COUNT) &&
+            (rlist->total <= RVEC_HIGH_WATERMARK_COUNT));
 }
 
 static void
-rbuf_reset_rvec (rbuf_iovec_t *rvec)
+rbuf_reset_rvec(rbuf_iovec_t *rvec)
 {
-        /* iov_base is _never_ modified */
-        rvec->iov.iov_len = 0;
+    GF_VALIDATE_OR_GOTO("libglusterfs", rvec, err);
+    /* iov_base is _never_ modified */
+    rvec->iov.iov_len = 0;
+err:
+    return;
 }
 
 /* TODO: alloc multiple rbuf_iovec_t */
 static int
-rlist_add_new_vec (rbuf_list_t *rlist)
+rlist_add_new_vec(rbuf_list_t *rlist)
 {
-        rbuf_iovec_t *rvec = NULL;
+    rbuf_iovec_t *rvec = NULL;
 
-        rvec = (rbuf_iovec_t *) rbuf_alloc_rvec ();
-        if (!rvec)
-                return -1;
-        INIT_LIST_HEAD (&rvec->list);
-        rvec->iov.iov_base = ((char *)rvec) + RBUF_IOVEC_SIZE;
-        rvec->iov.iov_len = 0;
+    rvec = (rbuf_iovec_t *)rbuf_alloc_rvec();
+    if (!rvec)
+        return -1;
+    INIT_LIST_HEAD(&rvec->list);
+    rvec->iov.iov_base = ((char *)rvec) + RBUF_IOVEC_SIZE;
+    rvec->iov.iov_len = 0;
 
-        list_add_tail (&rvec->list, &rlist->veclist);
+    list_add_tail(&rvec->list, &rlist->veclist);
 
-        rlist->rvec = rvec; /* cache the latest */
+    rlist->rvec = rvec; /* cache the latest */
 
-        rlist_increment_vector_usage (rlist);
-        rlist_increment_total_usage (rlist);
+    rlist_increment_vector_usage(rlist);
+    rlist_increment_total_usage(rlist);
 
-        return 0;
+    return 0;
 }
 
 static void
-rlist_free_rvec (rbuf_iovec_t *rvec)
+rlist_free_rvec(rbuf_iovec_t *rvec)
 {
-        if (!rvec)
-                return;
-        list_del (&rvec->list);
-        GF_FREE (rvec);
+    if (!rvec)
+        return;
+    list_del(&rvec->list);
+    GF_FREE(rvec);
 }
 
 static void
-rlist_purge_all_rvec (rbuf_list_t *rlist)
+rlist_purge_all_rvec(rbuf_list_t *rlist)
 {
-        rbuf_iovec_t *rvec = NULL;
-
-        if (!rlist)
-                return;
-        while (!list_empty (&rlist->veclist)) {
-                rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-                rlist_free_rvec (rvec);
-        }
+    rbuf_iovec_t *rvec = NULL;
+
+    if (!rlist)
+        return;
+    while (!list_empty(&rlist->veclist)) {
+        rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+        rlist_free_rvec(rvec);
+    }
 }
 
 static void
-rlist_shrink_rvec (rbuf_list_t *rlist, unsigned long long shrink)
+rlist_shrink_rvec(rbuf_list_t *rlist, unsigned long long shrink)
 {
-        rbuf_iovec_t *rvec = NULL;
+    rbuf_iovec_t *rvec = NULL;
 
-        while (!list_empty (&rlist->veclist) && (shrink-- > 0)) {
-                rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-                rlist_free_rvec (rvec);
-        }
+    while (!list_empty(&rlist->veclist) && (shrink-- > 0)) {
+        rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+        rlist_free_rvec(rvec);
+    }
 }
 
 static void
-rbuf_purge_rlist (rbuf_t *rbuf)
+rbuf_purge_rlist(rbuf_t *rbuf)
 {
-        rbuf_list_t *rlist = NULL;
+    rbuf_list_t *rlist = NULL;
 
-        while (!list_empty (&rbuf->freelist)) {
-                rlist = list_first_entry (&rbuf->freelist, rbuf_list_t, list);
-                list_del (&rlist->list);
+    while (!list_empty(&rbuf->freelist)) {
+        rlist = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+        list_del(&rlist->list);
 
-                rlist_purge_all_rvec (rlist);
+        rlist_purge_all_rvec(rlist);
 
-                LOCK_DESTROY (&rlist->c_lock);
+        LOCK_DESTROY(&rlist->c_lock);
 
-                (void) pthread_mutex_destroy (&rlist->b_lock);
-                (void) pthread_cond_destroy (&rlist->b_cond);
+        (void)pthread_mutex_destroy(&rlist->b_lock);
+        (void)pthread_cond_destroy(&rlist->b_cond);
 
-                GF_FREE (rlist);
-        }
+        GF_FREE(rlist);
+    }
 }
 
 rbuf_t *
-rbuf_init (int bufcount)
+rbuf_init(int bufcount)
 {
-        int          j     = 0;
-        int          ret   = 0;
-        rbuf_t      *rbuf  = NULL;
-        rbuf_list_t *rlist = NULL;
-
-        if (bufcount <= 0)
-                bufcount = ROT_BUFF_DEFAULT_COUNT;
-
-        rbuf = GF_CALLOC (1, sizeof (rbuf_t), gf_common_mt_rbuf_t);
-        if (!rbuf)
-                goto error_return;
-
-        LOCK_INIT (&rbuf->lock);
-        INIT_LIST_HEAD (&rbuf->freelist);
-
-        /* it could have been one big calloc() but this is just once.. */
-        for (j = 0; j < bufcount; j++) {
-                rlist = GF_CALLOC (1,
-                                   sizeof (rbuf_list_t), gf_common_mt_rlist_t);
-                if (!rlist) {
-                        ret = -1;
-                        break;
-                }
-
-                INIT_LIST_HEAD (&rlist->list);
-                INIT_LIST_HEAD (&rlist->veclist);
-
-                rlist->pending = rlist->completed = 0;
-
-                ret = rlist_add_new_vec (rlist);
-                if (ret)
-                        break;
-
-                LOCK_INIT (&rlist->c_lock);
-
-                rlist->awaiting = _gf_false;
-                ret = pthread_mutex_init (&rlist->b_lock, 0);
-                if (ret != 0) {
-                        GF_FREE (rlist);
-                        break;
-                }
-
-                ret = pthread_cond_init (&rlist->b_cond, 0);
-                if (ret != 0) {
-                        GF_FREE (rlist);
-                        break;
-                }
-
-                list_add_tail (&rlist->list, &rbuf->freelist);
+    int j = 0;
+    int ret = 0;
+    rbuf_t *rbuf = NULL;
+    rbuf_list_t *rlist = NULL;
+
+    if (bufcount <= 0)
+        bufcount = ROT_BUFF_DEFAULT_COUNT;
+
+    rbuf = GF_CALLOC(1, sizeof(rbuf_t), gf_common_mt_rbuf_t);
+    if (!rbuf)
+        goto error_return;
+
+    LOCK_INIT(&rbuf->lock);
+    INIT_LIST_HEAD(&rbuf->freelist);
+
+    /* it could have been one big calloc() but this is just once.. */
+    for (j = 0; j < bufcount; j++) {
+        rlist = GF_CALLOC(1, sizeof(rbuf_list_t), gf_common_mt_rlist_t);
+        if (!rlist) {
+            ret = -1;
+            break;
         }
 
-        if (ret != 0)
-                goto dealloc_rlist;
+        INIT_LIST_HEAD(&rlist->list);
+        INIT_LIST_HEAD(&rlist->veclist);
 
-        /* cache currently used buffer: first in the list */
-        rbuf->current = list_first_entry (&rbuf->freelist, rbuf_list_t, list);
-        return rbuf;
+        rlist->pending = rlist->completed = 0;
 
- dealloc_rlist:
-        rbuf_purge_rlist (rbuf);
-        LOCK_DESTROY (&rbuf->lock);
-        GF_FREE (rbuf);
- error_return:
-        return NULL;
+        ret = rlist_add_new_vec(rlist);
+        if (ret)
+            break;
+
+        LOCK_INIT(&rlist->c_lock);
+
+        rlist->awaiting = _gf_false;
+        ret = pthread_mutex_init(&rlist->b_lock, 0);
+        if (ret != 0) {
+            GF_FREE(rlist);
+            break;
+        }
+
+        ret = pthread_cond_init(&rlist->b_cond, 0);
+        if (ret != 0) {
+            GF_FREE(rlist);
+            break;
+        }
+
+        list_add_tail(&rlist->list, &rbuf->freelist);
+    }
+
+    if (ret != 0)
+        goto dealloc_rlist;
+
+    /* cache currently used buffer: first in the list */
+    rbuf->current = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+    return rbuf;
+
+dealloc_rlist:
+    rbuf_purge_rlist(rbuf);
+    LOCK_DESTROY(&rbuf->lock);
+    GF_FREE(rbuf);
+error_return:
+    return NULL;
 }
 
 void
-rbuf_dtor (rbuf_t *rbuf)
+rbuf_dtor(rbuf_t *rbuf)
 {
-        if (!rbuf)
-                return;
-        rbuf->current = NULL;
-        rbuf_purge_rlist (rbuf);
-        LOCK_DESTROY (&rbuf->lock);
+    if (!rbuf)
+        return;
+    rbuf->current = NULL;
+    rbuf_purge_rlist(rbuf);
+    LOCK_DESTROY(&rbuf->lock);
 
-        GF_FREE (rbuf);
+    GF_FREE(rbuf);
 }
 
 static char *
-rbuf_adjust_write_area (struct iovec *iov, size_t bytes)
+rbuf_adjust_write_area(struct iovec *iov, size_t bytes)
 {
-        char *wbuf = NULL;
+    char *wbuf = NULL;
 
-        wbuf = iov->iov_base + iov->iov_len;
-        iov->iov_len += bytes;
-        return wbuf;
+    wbuf = iov->iov_base + iov->iov_len;
+    iov->iov_len += bytes;
+    return wbuf;
 }
 
 static char *
-rbuf_alloc_write_area (rbuf_list_t *rlist, size_t bytes)
+rbuf_alloc_write_area(rbuf_list_t *rlist, size_t bytes)
 {
-        int           ret = 0;
-        struct iovec *iov = NULL;
-
-        /* check for available space in _current_ IO buffer */
-        iov = &rlist->rvec->iov;
-        if (iov->iov_len + bytes <= ROT_BUFF_ALLOC_SIZE)
-                return rbuf_adjust_write_area (iov, bytes); /* fast path */
-
-        /* not enough bytes, try next available buffers */
-        if (list_is_last (&rlist->rvec->list, &rlist->veclist)) {
-                /* OH! consumed all vector buffers */
-                GF_ASSERT (rlist->used == rlist->total);
-                ret = rlist_add_new_vec (rlist);
-                if (ret)
-                        goto error_return;
-        } else {
-                /* not the end, have available rbuf_iovec's */
-                rlist->rvec = list_next_entry (rlist->rvec, list);
-                rlist->used++;
-                rbuf_reset_rvec (rlist->rvec);
-        }
+    int ret = 0;
+    struct iovec *iov = NULL;
+
+    /* check for available space in _current_ IO buffer */
+    iov = &rlist->rvec->iov;
+    if (iov->iov_len + bytes <= ROT_BUFF_ALLOC_SIZE)
+        return rbuf_adjust_write_area(iov, bytes); /* fast path */
+
+    /* not enough bytes, try next available buffers */
+    if (list_is_last(&rlist->rvec->list, &rlist->veclist)) {
+        /* OH! consumed all vector buffers */
+        GF_ASSERT(rlist->used == rlist->total);
+        ret = rlist_add_new_vec(rlist);
+        if (ret)
+            goto error_return;
+    } else {
+        /* not the end, have available rbuf_iovec's */
+        rlist->rvec = list_next_entry(rlist->rvec, list);
+        rlist->used++;
+        rbuf_reset_rvec(rlist->rvec);
+    }
 
-        iov = &rlist->rvec->iov;
-        return rbuf_adjust_write_area (iov, bytes);
+    iov = &rlist->rvec->iov;
+    return rbuf_adjust_write_area(iov, bytes);
 
- error_return:
-        return NULL;
+error_return:
+    return NULL;
 }
 
 char *
-rbuf_reserve_write_area (rbuf_t *rbuf, size_t bytes, void **opaque)
+rbuf_reserve_write_area(rbuf_t *rbuf, size_t bytes, void **opaque)
 {
-        char        *wbuf  = NULL;
-        rbuf_list_t *rlist = NULL;
-
-        if (!rbuf || (bytes <= 0) || (bytes > ROT_BUFF_ALLOC_SIZE) || !opaque)
-                return NULL;
-
-        LOCK (&rbuf->lock);
-        {
-                rlist = rbuf_current_buffer (rbuf);
-                wbuf = rbuf_alloc_write_area (rlist, bytes);
-                if (!wbuf)
-                        goto unblock;
-                rlist->pending++;
-        }
- unblock:
-        UNLOCK (&rbuf->lock);
+    char *wbuf = NULL;
+    rbuf_list_t *rlist = NULL;
+
+    if (!rbuf || (bytes <= 0) || (bytes > ROT_BUFF_ALLOC_SIZE) || !opaque)
+        return NULL;
 
-        if (wbuf)
-                *opaque = rlist;
-        return wbuf;
+    LOCK(&rbuf->lock);
+    {
+        rlist = rbuf_current_buffer(rbuf);
+        wbuf = rbuf_alloc_write_area(rlist, bytes);
+        if (!wbuf)
+            goto unblock;
+        rlist->pending++;
+    }
+unblock:
+    UNLOCK(&rbuf->lock);
+
+    if (wbuf)
+        *opaque = rlist;
+    return wbuf;
 }
 
 static void
-rbuf_notify_waiter (rbuf_list_t *rlist)
+rbuf_notify_waiter(rbuf_list_t *rlist)
 {
-        pthread_mutex_lock (&rlist->b_lock);
-        {
-                pthread_cond_signal (&rlist->b_cond);
-        }
-        pthread_mutex_unlock (&rlist->b_lock);
+    pthread_mutex_lock(&rlist->b_lock);
+    {
+        pthread_cond_signal(&rlist->b_cond);
+    }
+    pthread_mutex_unlock(&rlist->b_lock);
 }
 
 int
-rbuf_write_complete (void *opaque)
+rbuf_write_complete(void *opaque)
 {
-        rbuf_list_t *rlist = NULL;
-        gf_boolean_t notify = _gf_false;
-
-        if (!opaque)
-                return -1;
-
-        rlist = opaque;
-
-        LOCK (&rlist->c_lock);
-        {
-                rlist->completed++;
-                /**
-                 * it's safe to test ->pending without rbuf->lock *only* if
-                 * there's a waiter as there can be no new incoming writes.
-                 */
-                if (__rlist_has_waiter (rlist)
-                                  && (rlist->completed == rlist->pending))
-                        notify = _gf_true;
-        }
-        UNLOCK (&rlist->c_lock);
+    rbuf_list_t *rlist = NULL;
+    gf_boolean_t notify = _gf_false;
+
+    if (!opaque)
+        return -1;
+
+    rlist = opaque;
+
+    LOCK(&rlist->c_lock);
+    {
+        rlist->completed++;
+        /**
+         * it's safe to test ->pending without rbuf->lock *only* if
+         * there's a waiter as there can be no new incoming writes.
+         */
+        if (__rlist_has_waiter(rlist) && (rlist->completed == rlist->pending))
+            notify = _gf_true;
+    }
+    UNLOCK(&rlist->c_lock);
 
-        if (notify)
-                rbuf_notify_waiter (rlist);
+    if (notify)
+        rbuf_notify_waiter(rlist);
 
-        return 0;
+    return 0;
 }
 
 int
-rbuf_get_buffer (rbuf_t *rbuf,
-                 void **opaque, sequence_fn *seqfn, void *mydata)
+rbuf_get_buffer(rbuf_t *rbuf, void **opaque, sequence_fn *seqfn, void *mydata)
 {
-        int retval = RBUF_CONSUMABLE;
-        rbuf_list_t *rlist = NULL;
-
-        if (!rbuf || !opaque)
-                return -1;
-
-        LOCK (&rbuf->lock);
-        {
-                rlist = rbuf_current_buffer (rbuf);
-                if (!rlist->pending) {
-                        retval = RBUF_EMPTY;
-                        goto unblock;
-                }
-
-                if (list_is_singular (&rbuf->freelist)) {
-                        /**
-                         * removal would lead to writer starvation, disallow
-                         * switching.
-                         */
-                        retval = RBUF_WOULD_STARVE;
-                        goto unblock;
-                }
-
-                list_del_init (&rlist->list);
-                if (seqfn)
-                        seqfn (rlist, mydata);
-                rbuf->current =
-                        list_first_entry (&rbuf->freelist, rbuf_list_t, list);
+    int retval = RBUF_CONSUMABLE;
+    rbuf_list_t *rlist = NULL;
+
+    if (!rbuf || !opaque)
+        return -1;
+
+    LOCK(&rbuf->lock);
+    {
+        rlist = rbuf_current_buffer(rbuf);
+        if (!rlist->pending) {
+            retval = RBUF_EMPTY;
+            goto unblock;
+        }
+
+        if (list_is_singular(&rbuf->freelist)) {
+            /**
+             * removal would lead to writer starvation, disallow
+             * switching.
+             */
+            retval = RBUF_WOULD_STARVE;
+            goto unblock;
         }
- unblock:
-        UNLOCK (&rbuf->lock);
 
-        if (retval == RBUF_CONSUMABLE)
-                *opaque = rlist; /* caller _owns_ the buffer */
+        list_del_init(&rlist->list);
+        if (seqfn)
+            seqfn(rlist, mydata);
+        rbuf->current = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+    }
+unblock:
+    UNLOCK(&rbuf->lock);
 
-        return retval;
+    if (retval == RBUF_CONSUMABLE)
+        *opaque = rlist; /* caller _owns_ the buffer */
+
+    return retval;
 }
 
 /**
@@ -412,10 +411,10 @@ rbuf_get_buffer (rbuf_t *rbuf,
  */
 
 static void
-__rbuf_wait_for_writers (rbuf_list_t *rlist)
+__rbuf_wait_for_writers(rbuf_list_t *rlist)
 {
-        while (rlist->completed != rlist->pending)
-                pthread_cond_wait (&rlist->b_cond, &rlist->b_lock);
+    while (rlist->completed != rlist->pending)
+        pthread_cond_wait(&rlist->b_cond, &rlist->b_lock);
 }
 
 #ifndef M_E
@@ -423,69 +422,69 @@ __rbuf_wait_for_writers (rbuf_list_t *rlist)
 #endif
 
 static void
-rlist_shrink_vector (rbuf_list_t *rlist)
+rlist_shrink_vector(rbuf_list_t *rlist)
 {
-        unsigned long long shrink = 0;
-
-        /**
-         * fast path: don't bother to deallocate if vectors are hardly
-         * used.
-         */
-        if (rvec_in_watermark_range (rlist))
-                return;
-
-        /**
-         * Calculate the shrink count based on total allocated vectors.
-         * Note that the calculation sticks to rlist->total irrespective
-         * of the actual usage count (rlist->used). Later, ->used could
-         * be used to apply slack to the calculation based on how much
-         * it lags from ->total. For now, let's stick to slow decay.
-         */
-        shrink = rlist->total - (rlist->total * pow (M_E, -0.2));
-
-        rlist_shrink_rvec (rlist, shrink);
-        rlist->total -= shrink;
+    unsigned long long shrink = 0;
+
+    /**
+     * fast path: don't bother to deallocate if vectors are hardly
+     * used.
+     */
+    if (rvec_in_watermark_range(rlist))
+        return;
+
+    /**
+     * Calculate the shrink count based on total allocated vectors.
+     * Note that the calculation sticks to rlist->total irrespective
+     * of the actual usage count (rlist->used). Later, ->used could
+     * be used to apply slack to the calculation based on how much
+     * it lags from ->total. For now, let's stick to slow decay.
+     */
+    shrink = rlist->total - (rlist->total * pow(M_E, -0.2));
+
+    rlist_shrink_rvec(rlist, shrink);
+    rlist->total -= shrink;
 }
 
 int
-rbuf_wait_for_completion (rbuf_t *rbuf, void *opaque,
-                          void (*fn)(rbuf_list_t *, void *), void *arg)
+rbuf_wait_for_completion(rbuf_t *rbuf, void *opaque,
+                         void (*fn)(rbuf_list_t *, void *), void *arg)
 {
-        rbuf_list_t *rlist = NULL;
+    rbuf_list_t *rlist = NULL;
 
-        if (!rbuf || !opaque)
-                return -1;
+    if (!rbuf || !opaque)
+        return -1;
 
-        rlist = opaque;
+    rlist = opaque;
 
-        pthread_mutex_lock (&rlist->b_lock);
-        {
-                rlist_mark_waiting (rlist);
-                __rbuf_wait_for_writers (rlist);
-        }
-        pthread_mutex_unlock (&rlist->b_lock);
+    pthread_mutex_lock(&rlist->b_lock);
+    {
+        rlist_mark_waiting(rlist);
+        __rbuf_wait_for_writers(rlist);
+    }
+    pthread_mutex_unlock(&rlist->b_lock);
 
-        /**
-         * from here on, no need of locking until the rlist is put
-         * back into rotation.
-         */
+    /**
+     * from here on, no need of locking until the rlist is put
+     * back into rotation.
+     */
 
-        fn (rlist, arg); /* invoke dispatcher */
+    fn(rlist, arg); /* invoke dispatcher */
 
-        rlist->awaiting = _gf_false;
-        rlist->pending = rlist->completed = 0;
+    rlist->awaiting = _gf_false;
+    rlist->pending = rlist->completed = 0;
 
-        rlist_shrink_vector (rlist);
-        rlist_reset_vector_usage (rlist);
+    rlist_shrink_vector(rlist);
+    rlist_reset_vector_usage(rlist);
 
-        rlist->rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-        rbuf_reset_rvec (rlist->rvec);
+    rlist->rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+    rbuf_reset_rvec(rlist->rvec);
 
-        LOCK (&rbuf->lock);
-        {
-                list_add_tail (&rlist->list, &rbuf->freelist);
-        }
-        UNLOCK (&rbuf->lock);
+    LOCK(&rbuf->lock);
+    {
+        list_add_tail(&rlist->list, &rbuf->freelist);
+    }
+    UNLOCK(&rbuf->lock);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/rot-buffs.h b/libglusterfs/src/rot-buffs.h
deleted file mode 100644
index aac24a4f571..00000000000
--- a/libglusterfs/src/rot-buffs.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __ROT_BUFFS_H
-#define __ROT_BUFFS_H
-
-#include "list.h"
-#include "locking.h"
-#include "common-utils.h"
-
-typedef struct rbuf_iovec {
-        struct iovec iov;
-
-        struct list_head list;
-} rbuf_iovec_t;
-
-#define RBUF_IOVEC_SIZE  (sizeof (rbuf_iovec_t))
-
-typedef struct rbuf_list {
-        gf_lock_t c_lock;
-
-        pthread_mutex_t b_lock;          /* protects this structure */
-        pthread_cond_t b_cond;           /* signal for writer completion */
-
-        gf_boolean_t awaiting;
-
-        unsigned long long pending;      /* pending writers */
-        unsigned long long completed;    /* completed writers */
-
-        rbuf_iovec_t *rvec;              /* currently used IO vector */
-
-        struct list_head veclist;        /* list of attached rbuf_iov */
-
-        unsigned long long used;         /* consumable entries
-                                             attached in ->veclist */
-        unsigned long long total;        /* total entries in ->veclist (used
-                                            during deallocation) */
-
-        unsigned long seq[2];            /* if interested, this whould store
-                                            the start sequence number and the
-                                            range */
-
-        struct list_head list;           /* attachment to rbuf_t */
-} rbuf_list_t;
-
-struct rlist_iter {
-        struct list_head veclist;
-
-        unsigned long long iter;
-};
-
-#define RLIST_ENTRY_COUNT(rlist)  rlist->used
-
-#define rlist_iter_init(riter, rlist)              \
-        do {                                       \
-                (riter)->iter = rlist->used;       \
-                (riter)->veclist = rlist->veclist; \
-        } while (0)
-
-#define rvec_for_each_entry(pos, riter)                                 \
-        for (pos = list_entry                                           \
-                     ((riter)->veclist.next, typeof(*pos), list);       \
-             (riter)->iter > 0;                                         \
-             pos = list_entry                                           \
-                     (pos->list.next, typeof(*pos), list),              \
-                     --((riter)->iter))
-
-/**
- * Sequence number assigment routine is called during buffer
- * switch under rbuff ->lock.
- */
-typedef void (sequence_fn) (rbuf_list_t *, void *);
-
-#define RLIST_STORE_SEQ(rlist, start, range)    \
-        do {                                    \
-                rlist->seq[0] = start;          \
-                rlist->seq[1] = range;          \
-        } while (0)
-
-#define RLIST_GET_SEQ(rlist, start, range)      \
-        do {                                    \
-                start = rlist->seq[0];          \
-                range = rlist->seq[1];          \
-        } while (0)
-
-typedef struct rbuf {
-        gf_lock_t lock;        /* protects "current" rlist */
-
-        rbuf_list_t *current;  /* cached pointer to first free rlist */
-
-        struct list_head freelist;
-} rbuf_t;
-
-typedef enum {
-        RBUF_CONSUMABLE = 1,
-        RBUF_BUSY,
-        RBUF_EMPTY,
-        RBUF_WOULD_STARVE,
-} rlist_retval_t;
-
-/* Initialization/Destruction */
-rbuf_t *rbuf_init (int);
-void rbuf_dtor (rbuf_t *);
-
-/* Producer API */
-char *rbuf_reserve_write_area (rbuf_t *, size_t, void **);
-int rbuf_write_complete (void *);
-
-/* Consumer API */
-int rbuf_get_buffer (rbuf_t *, void **, sequence_fn *, void *);
-int rbuf_wait_for_completion (rbuf_t *, void *,
-                              void (*)(rbuf_list_t *, void *), void *);
-
-#endif
diff --git a/libglusterfs/src/run.c b/libglusterfs/src/run.c
index a7d98af502f..58f95a7e610 100644
--- a/libglusterfs/src/run.c
+++ b/libglusterfs/src/run.c
@@ -23,9 +23,31 @@
 #include <assert.h>
 #include <signal.h>
 #include <sys/wait.h>
-#include "syscall.h"
+#include "glusterfs/syscall.h"
 
-#ifdef RUN_STANDALONE
+/*
+ * Following defines are available for helping development:
+ * RUN_STANDALONE and RUN_DO_DEMO.
+ *
+ * Compiling a standalone object file with no dependencies
+ * on glusterfs:
+ * $ cc -DRUN_STANDALONE -c run.c
+ *
+ * Compiling a demo program that exercises bits of run.c
+ * functionality (linking to glusterfs):
+ * $ cc -DRUN_DO_DEMO -orun run.c  `pkg-config --libs --cflags glusterfs-api`
+ *
+ * Compiling a demo program that exercises bits of run.c
+ * functionality (with no dependence on glusterfs):
+ *
+ * $ cc -DRUN_DO_DEMO -DRUN_STANDALONE -orun run.c
+ */
+#if defined(RUN_STANDALONE) || defined(RUN_DO_DEMO)
+int
+close_fds_except(int *fdv, size_t count);
+#define sys_read(f, b, c) read(f, b, c)
+#define sys_write(f, b, c) write(f, b, c)
+#define sys_close(f) close(f)
 #define GF_CALLOC(n, s, t) calloc(n, s)
 #define GF_ASSERT(cond) assert(cond)
 #define GF_REALLOC(p, s) realloc(p, s)
@@ -33,467 +55,516 @@
 #define gf_strdup(s) strdup(s)
 #define gf_vasprintf(p, f, va) vasprintf(p, f, va)
 #define gf_loglevel_t int
-#define gf_log(dom, levl, fmt, args...) printf("LOG: " fmt "\n", ##args)
+#define gf_msg_callingfn(dom, level, errnum, msgid, fmt, args...)              \
+    printf("LOG: " fmt "\n", ##args)
 #define LOG_DEBUG 0
+#ifdef RUN_STANDALONE
+#include <stdbool.h>
+#include <sys/resource.h>
+int
+close_fds_except(int *fdv, size_t count)
+{
+    int i = 0;
+    size_t j = 0;
+    bool should_close = true;
+    struct rlimit rl;
+    int ret = -1;
+
+    ret = getrlimit(RLIMIT_NOFILE, &rl);
+    if (ret)
+        return ret;
+
+    for (i = 0; i < rl.rlim_cur; i++) {
+        should_close = true;
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = false;
+                break;
+            }
+        }
+        if (should_close)
+            sys_close(i);
+    }
+    return 0;
+}
+#endif
 #ifdef __linux__
 #define GF_LINUX_HOST_OS
 #endif
-#else /* ! RUN_STANDALONE */
-#include "glusterfs.h"
-#include "common-utils.h"
+#else /* ! RUN_STANDALONE || RUN_DO_DEMO */
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 #endif
 
-#include "libglusterfs-messages.h"
-#include "run.h"
+#include "glusterfs/run.h"
 void
-runinit (runner_t *runner)
+runinit(runner_t *runner)
 {
-        int i = 0;
-
-        runner->argvlen = 64;
-        runner->argv = GF_CALLOC (runner->argvlen,
-                                  sizeof (*runner->argv),
-                                  gf_common_mt_run_argv);
-        runner->runerr = runner->argv ? 0 : errno;
-        runner->chpid = -1;
-        for (i = 0; i < 3; i++) {
-                runner->chfd[i] = -1;
-                runner->chio[i] = NULL;
-        }
+    int i = 0;
+
+    runner->argvlen = 64;
+    runner->argv = GF_CALLOC(runner->argvlen, sizeof(*runner->argv),
+                             gf_common_mt_run_argv);
+    runner->runerr = runner->argv ? 0 : errno;
+    runner->chpid = -1;
+    for (i = 0; i < 3; i++) {
+        runner->chfd[i] = -1;
+        runner->chio[i] = NULL;
+    }
 }
 
 FILE *
-runner_chio (runner_t *runner, int fd)
+runner_chio(runner_t *runner, int fd)
 {
-        GF_ASSERT (fd > 0 && fd < 3);
+    GF_ASSERT(fd > 0 && fd < 3);
 
-        if ((fd > 0) && (fd < 3))
-                return runner->chio[fd];
+    if ((fd > 0) && (fd < 3))
+        return runner->chio[fd];
 
-        return NULL;
+    return NULL;
 }
 
 static void
-runner_insert_arg (runner_t *runner, char *arg)
+runner_insert_arg(runner_t *runner, char *arg)
 {
-        int i = 0;
+    int i = 0;
 
-        GF_ASSERT (arg);
+    GF_ASSERT(arg);
 
-        if (runner->runerr)
-                return;
+    if (runner->runerr || !runner->argv)
+        return;
 
-        for (i = 0; i < runner->argvlen; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-        }
-        GF_ASSERT (i < runner->argvlen);
-
-        if (i == runner->argvlen - 1) {
-                runner->argv = GF_REALLOC (runner->argv,
-                                           runner->argvlen * 2 * sizeof (*runner->argv));
-                if (!runner->argv) {
-                        runner->runerr = errno;
-                        return;
-                }
-                memset (/* "+" is aware of the type of its left side,
-                         * no need to multiply with type-size */
-                        runner->argv + runner->argvlen,
-                        0, runner->argvlen * sizeof (*runner->argv));
-                runner->argvlen *= 2;
-        }
+    for (i = 0; i < runner->argvlen; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+    }
+    GF_ASSERT(i < runner->argvlen);
 
-        runner->argv[i] = arg;
+    if (i == runner->argvlen - 1) {
+        runner->argv = GF_REALLOC(runner->argv,
+                                  runner->argvlen * 2 * sizeof(*runner->argv));
+        if (!runner->argv) {
+            runner->runerr = errno;
+            return;
+        }
+        memset(/* "+" is aware of the type of its left side,
+                * no need to multiply with type-size */
+               runner->argv + runner->argvlen, 0,
+               runner->argvlen * sizeof(*runner->argv));
+        runner->argvlen *= 2;
+    }
+
+    runner->argv[i] = arg;
 }
 
 void
-runner_add_arg (runner_t *runner, const char *arg)
+runner_add_arg(runner_t *runner, const char *arg)
 {
-        arg = gf_strdup (arg);
-        if (!arg) {
-                runner->runerr = errno;
-                return;
-        }
+    arg = gf_strdup(arg);
+    if (!arg) {
+        runner->runerr = errno;
+        return;
+    }
 
-        runner_insert_arg (runner, (char *)arg);
+    runner_insert_arg(runner, (char *)arg);
 }
 
 static void
-runner_va_add_args (runner_t *runner, va_list argp)
+runner_va_add_args(runner_t *runner, va_list argp)
 {
-        const char *arg;
+    const char *arg;
 
-        while ((arg = va_arg (argp, const char *)))
-                runner_add_arg (runner, arg);
+    while ((arg = va_arg(argp, const char *)))
+        runner_add_arg(runner, arg);
 }
 
 void
-runner_add_args (runner_t *runner, ...)
+runner_add_args(runner_t *runner, ...)
 {
-        va_list argp;
+    va_list argp;
 
-        va_start (argp, runner);
-        runner_va_add_args (runner, argp);
-        va_end (argp);
+    va_start(argp, runner);
+    runner_va_add_args(runner, argp);
+    va_end(argp);
 }
 
 void
-runner_argprintf (runner_t *runner, const char *format, ...)
+runner_argprintf(runner_t *runner, const char *format, ...)
 {
-        va_list argva;
-        char *arg = NULL;
-        int ret = 0;
+    va_list argva;
+    char *arg = NULL;
+    int ret = 0;
 
-        va_start (argva, format);
-        ret = gf_vasprintf (&arg, format, argva);
-        va_end (argva);
+    va_start(argva, format);
+    ret = gf_vasprintf(&arg, format, argva);
+    va_end(argva);
 
-        if (ret < 0) {
-                runner->runerr = errno;
-                return;
-        }
+    if (ret < 0) {
+        runner->runerr = errno;
+        return;
+    }
 
-        runner_insert_arg (runner, arg);
+    runner_insert_arg(runner, arg);
 }
 
 void
-runner_log (runner_t *runner, const char *dom, gf_loglevel_t lvl,
-            const char *msg)
+runner_log(runner_t *runner, const char *dom, gf_loglevel_t lvl,
+           const char *msg)
 {
-        char *buf = NULL;
-        size_t len = 0;
-        int i = 0;
-
-        if (runner->runerr)
-                return;
-
-        for (i = 0;; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-                len += (strlen (runner->argv[i]) + 1);
-        }
-
-        buf = GF_CALLOC (1, len + 1, gf_common_mt_run_logbuf);
-        if (!buf) {
-                runner->runerr = errno;
-                return;
-        }
-        for (i = 0;; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-                strcat (buf, runner->argv[i]);
-                strcat (buf, " ");
-        }
-        if (len > 0)
-                buf[len - 1] = '\0';
-
-        gf_msg_callingfn (dom, lvl, 0, LG_MSG_RUNNER_LOG, "%s: %s", msg, buf);
-
-        GF_FREE (buf);
+    char *buf = NULL;
+    size_t len = 0;
+    int i = 0;
+
+    if (runner->runerr)
+        return;
+
+    for (i = 0;; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+        len += (strlen(runner->argv[i]) + 1);
+    }
+
+    buf = GF_CALLOC(1, len + 1, gf_common_mt_run_logbuf);
+    if (!buf) {
+        runner->runerr = errno;
+        return;
+    }
+    for (i = 0;; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+        strcat(buf, runner->argv[i]);
+        strcat(buf, " ");
+    }
+    if (len > 0)
+        buf[len - 1] = '\0';
+
+    gf_msg_callingfn(dom, lvl, 0, LG_MSG_RUNNER_LOG, "%s: %s", msg, buf);
+
+    GF_FREE(buf);
 }
 
 void
-runner_redir (runner_t *runner, int fd, int tgt_fd)
+runner_redir(runner_t *runner, int fd, int tgt_fd)
 {
-        GF_ASSERT (fd > 0 && fd < 3);
+    GF_ASSERT(fd > 0 && fd < 3);
 
-        if ((fd > 0) && (fd < 3))
-                runner->chfd[fd] = (tgt_fd >= 0) ? tgt_fd : -2;
+    if ((fd > 0) && (fd < 3))
+        runner->chfd[fd] = (tgt_fd >= 0) ? tgt_fd : -2;
 }
 
 int
-runner_start (runner_t *runner)
+runner_start(runner_t *runner)
 {
-        int pi[3][2] = {{-1, -1}, {-1, -1}, {-1, -1}};
-        int xpi[2];
-        int ret = 0;
-        int errno_priv = 0;
-        int i = 0;
-        sigset_t set;
-
-        if (runner->runerr) {
-                errno = runner->runerr;
-                return -1;
-        }
-
-        GF_ASSERT (runner->argv[0]);
-
-        /* set up a channel to child to communicate back
-         * possible execve(2) failures
-         */
-        ret = pipe(xpi);
-        if (ret != -1)
-                ret = fcntl (xpi[1], F_SETFD, FD_CLOEXEC);
-
-        for (i = 0; i < 3; i++) {
-                if (runner->chfd[i] != -2)
-                        continue;
-                ret = pipe (pi[i]);
-                if (ret != -1) {
-                        runner->chio[i] = fdopen (pi[i][i ? 0 : 1], i ? "r" : "w");
-                        if (!runner->chio[i])
-                                ret = -1;
-                }
+    int pi[3][2] = {{-1, -1}, {-1, -1}, {-1, -1}};
+    int xpi[2];
+    int ret = 0;
+    int errno_priv = 0;
+    int i = 0;
+    sigset_t set;
+
+    if (runner->runerr || !runner->argv) {
+        errno = (runner->runerr) ? runner->runerr : EINVAL;
+        return -1;
+    }
+
+    GF_ASSERT(runner->argv[0]);
+
+    /* set up a channel to child to communicate back
+     * possible execve(2) failures
+     */
+    ret = pipe(xpi);
+    if (ret != -1)
+        ret = fcntl(xpi[1], F_SETFD, FD_CLOEXEC);
+
+    for (i = 0; i < 3; i++) {
+        if (runner->chfd[i] != -2)
+            continue;
+        ret = pipe(pi[i]);
+        if (ret != -1) {
+            runner->chio[i] = fdopen(pi[i][i ? 0 : 1], i ? "r" : "w");
+            if (!runner->chio[i])
+                ret = -1;
         }
+    }
 
-        if (ret != -1)
-                runner->chpid = fork ();
-        switch (runner->chpid) {
+    if (ret != -1)
+        runner->chpid = fork();
+    switch (runner->chpid) {
         case -1:
-                errno_priv = errno;
-                sys_close (xpi[0]);
-                sys_close (xpi[1]);
-                for (i = 0; i < 3; i++) {
-                        sys_close (pi[i][0]);
-                        sys_close (pi[i][1]);
-                }
-                errno = errno_priv;
-                return -1;
+            errno_priv = errno;
+            sys_close(xpi[0]);
+            sys_close(xpi[1]);
+            for (i = 0; i < 3; i++) {
+                sys_close(pi[i][0]);
+                sys_close(pi[i][1]);
+            }
+            errno = errno_priv;
+            return -1;
         case 0:
-                for (i = 0; i < 3; i++)
-                        sys_close (pi[i][i ? 0 : 1]);
-                sys_close (xpi[0]);
-                ret = 0;
-
-                for (i = 0; i < 3; i++) {
-                        if (ret == -1)
-                                break;
-                        switch (runner->chfd[i]) {
-                        case -1:
-                                /* no redir */
-                                break;
-                        case -2:
-                                /* redir to pipe */
-                                ret = dup2 (pi[i][i ? 1 : 0], i);
-                                break;
-                        default:
-                                /* redir to file */
-                                ret = dup2 (runner->chfd[i], i);
-                        }
-                }
-
-                if (ret != -1 ) {
-                        int fdv[4] = {0, 1, 2, xpi[1]};
-
-                        ret = close_fds_except(fdv, sizeof (fdv) / sizeof (*fdv));
-                }
-
-                if (ret != -1) {
-                        /* save child from inheriting our singal handling */
-                        sigemptyset (&set);
-                        sigprocmask (SIG_SETMASK, &set, NULL);
-
-                        execvp (runner->argv[0], runner->argv);
-                }
-                ret = sys_write (xpi[1], &errno, sizeof (errno));
-                _exit (1);
-        }
-
-        errno_priv = errno;
-        for (i = 0; i < 3; i++)
-                sys_close (pi[i][i ? 1 : 0]);
-        sys_close (xpi[1]);
-        if (ret == -1) {
-                for (i = 0; i < 3; i++) {
-                        if (runner->chio[i]) {
-                                fclose (runner->chio[i]);
-                                runner->chio[i] = NULL;
-                        }
+            for (i = 0; i < 3; i++)
+                sys_close(pi[i][i ? 0 : 1]);
+            sys_close(xpi[0]);
+            ret = 0;
+
+            for (i = 0; i < 3; i++) {
+                if (ret == -1)
+                    break;
+                switch (runner->chfd[i]) {
+                    case -1:
+                        /* no redir */
+                        break;
+                    case -2:
+                        /* redir to pipe */
+                        ret = dup2(pi[i][i ? 1 : 0], i);
+                        break;
+                    default:
+                        /* redir to file */
+                        ret = dup2(runner->chfd[i], i);
                 }
-        } else {
-                ret = sys_read (xpi[0], (char *)&errno_priv, sizeof (errno_priv));
-                sys_close (xpi[0]);
-                if (ret <= 0)
-                        return 0;
-                GF_ASSERT (ret == sizeof (errno_priv));
+            }
+
+            if (ret != -1) {
+                int fdv[4] = {0, 1, 2, xpi[1]};
+
+                ret = close_fds_except(fdv, sizeof(fdv) / sizeof(*fdv));
+            }
+
+            if (ret != -1) {
+                /* save child from inheriting our signal handling */
+                sigemptyset(&set);
+                sigprocmask(SIG_SETMASK, &set, NULL);
+
+                execvp(runner->argv[0], runner->argv);
+            }
+            ret = sys_write(xpi[1], &errno, sizeof(errno));
+            _exit(1);
+    }
+
+    errno_priv = errno;
+    for (i = 0; i < 3; i++)
+        sys_close(pi[i][i ? 1 : 0]);
+    sys_close(xpi[1]);
+    if (ret == -1) {
+        for (i = 0; i < 3; i++) {
+            if (runner->chio[i]) {
+                fclose(runner->chio[i]);
+                runner->chio[i] = NULL;
+            }
         }
-        errno = errno_priv;
-        return -1;
+    } else {
+        ret = sys_read(xpi[0], (char *)&errno_priv, sizeof(errno_priv));
+        sys_close(xpi[0]);
+        if (ret <= 0)
+            return 0;
+        GF_ASSERT(ret == sizeof(errno_priv));
+    }
+    errno = errno_priv;
+    return -1;
 }
 
 int
-runner_end_reuse (runner_t *runner)
+runner_end_reuse(runner_t *runner)
 {
-        int i = 0;
-        int ret = 1;
-        int chstat = 0;
-
-        if (runner->chpid > 0) {
-                if (waitpid (runner->chpid, &chstat, 0) == runner->chpid) {
-                        if (WIFEXITED(chstat)) {
-                                ret = WEXITSTATUS(chstat);
-                        } else {
-                                ret = chstat;
-                        }
-                }
+    int i = 0;
+    int ret = 1;
+    int chstat = 0;
+
+    if (runner->chpid > 0) {
+        if (waitpid(runner->chpid, &chstat, 0) == runner->chpid) {
+            if (WIFEXITED(chstat)) {
+                ret = WEXITSTATUS(chstat);
+            } else {
+                ret = chstat;
+            }
         }
+    }
 
-        for (i = 0; i < 3; i++) {
-                if (runner->chio[i]) {
-                        fclose (runner->chio[i]);
-                        runner->chio[i] = NULL;
-                }
+    for (i = 0; i < 3; i++) {
+        if (runner->chio[i]) {
+            fclose(runner->chio[i]);
+            runner->chio[i] = NULL;
         }
+    }
 
-        return -ret;
+    return -ret;
 }
 
 int
-runner_end (runner_t *runner)
+runner_end(runner_t *runner)
 {
-        int i = 0;
-        int ret = -1;
-        char **p = NULL;
+    int i = 0;
+    int ret = -1;
+    char **p = NULL;
 
-        ret = runner_end_reuse (runner);
+    ret = runner_end_reuse(runner);
 
-        if (runner->argv) {
-                for (p = runner->argv; *p; p++)
-                        GF_FREE (*p);
-                GF_FREE (runner->argv);
-        }
-        for (i = 0; i < 3; i++)
-                sys_close (runner->chfd[i]);
+    if (runner->argv) {
+        for (p = runner->argv; *p; p++)
+            GF_FREE(*p);
+        GF_FREE(runner->argv);
+    }
+    for (i = 0; i < 3; i++)
+        sys_close(runner->chfd[i]);
 
-        return ret;
+    return ret;
 }
 
 static int
-runner_run_generic (runner_t *runner, int (*rfin)(runner_t *runner))
+runner_run_generic(runner_t *runner, int (*rfin)(runner_t *runner))
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = runner_start (runner);
-        if (ret)
-                goto out;
-        ret = rfin (runner);
+    ret = runner_start(runner);
+    if (ret)
+        goto out;
+    ret = rfin(runner);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-runner_run (runner_t *runner)
+runner_run(runner_t *runner)
 {
-        return runner_run_generic (runner, runner_end);
+    return runner_run_generic(runner, runner_end);
 }
 
-
 int
-runner_run_nowait (runner_t *runner)
+runner_run_nowait(runner_t *runner)
 {
-	int pid;
+    int pid;
 
-	pid = fork ();
+    pid = fork();
 
-	if (!pid) {
-		setsid ();
-		_exit (runner_start (runner));
-	}
+    if (!pid) {
+        setsid();
+        _exit(runner_start(runner));
+    }
 
-	if (pid > 0)
-		runner->chpid = pid;
-	return runner_end (runner);
+    if (pid > 0)
+        runner->chpid = pid;
+    return runner_end(runner);
 }
 
-
 int
-runner_run_reuse (runner_t *runner)
+runner_run_reuse(runner_t *runner)
 {
-        return runner_run_generic (runner, runner_end_reuse);
+    return runner_run_generic(runner, runner_end_reuse);
 }
 
 int
-runcmd (const char *arg, ...)
+runcmd(const char *arg, ...)
 {
-        runner_t runner;
-        va_list argp;
+    runner_t runner;
+    va_list argp;
 
-        runinit (&runner);
-        /* ISO C requires a named argument before '...' */
-        runner_add_arg (&runner, arg);
+    runinit(&runner);
+    /* ISO C requires a named argument before '...' */
+    runner_add_arg(&runner, arg);
 
-        va_start (argp, arg);
-        runner_va_add_args (&runner, argp);
-        va_end (argp);
+    va_start(argp, arg);
+    runner_va_add_args(&runner, argp);
+    va_end(argp);
 
-        return runner_run (&runner);
+    return runner_run(&runner);
 }
 
-#ifdef RUN_DO_TESTS
+#ifdef RUN_DO_DEMO
 static void
-TBANNER (const char *txt)
+TBANNER(const char *txt)
 {
-        printf("######\n### testing %s\n", txt);
+    printf("######\n### demoing %s\n", txt);
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        runner_t runner;
-        char buf[80];
-        char *wdbuf;;
-        int ret;
-        int fd;
-        long pathmax = pathconf ("/", _PC_PATH_MAX);
-        struct timeval tv = {0,};
-        struct timeval *tvp = NULL;
-
-        wdbuf = malloc (pathmax);
-        assert (wdbuf);
-        getcwd (wdbuf, pathmax);
-
-        TBANNER ("basic functionality");
-        runcmd ("echo", "a", "b", NULL);
-
-        TBANNER ("argv extension");
-        runcmd ("echo", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
-                "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
-                "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
-                "31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
-                "41", "42", "43", "44", "45", "46", "47", "48", "49", "50",
-                "51", "52", "53", "54", "55", "56", "57", "58", "59", "60",
-                "61", "62", "63", "64", "65", "66", "67", "68", "69", "70",
-                "71", "72", "73", "74", "75", "76", "77", "78", "79", "80",
-                "81", "82", "83", "84", "85", "86", "87", "88", "89", "90",
-                "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", NULL);
-
-        TBANNER ("add_args, argprintf, log, and popen-style functionality");
-        runinit (&runner);
-        runner_add_args (&runner, "echo", "pid:", NULL);
-        runner_argprintf (&runner, "%d\n", getpid());
-        runner_add_arg (&runner, "wd:");
-        runner_add_arg (&runner, wdbuf);
-        runner_redir (&runner, 1, RUN_PIPE);
-        runner_start (&runner);
-        runner_log (&runner, "(x)", LOG_DEBUG, "starting program");
-        while (fgets (buf, sizeof(buf), runner_chio (&runner, 1)))
-                printf ("got: %s", buf);
-        runner_end (&runner);
-
-        TBANNER ("execve error reporting");
-        ret = runcmd ("bafflavvitty", NULL);
-        printf ("%d %d [%s]\n", ret, errno, strerror (errno));
-
-        TBANNER ("output redirection");
-        fd = mkstemp ("/tmp/foof");
-        assert (fd != -1);
-        runinit (&runner);
-        runner_add_args (&runner, "echo", "foo", NULL);
-        runner_redir (&runner, 1, fd);
-        ret = runner_run (&runner);
-        printf ("%d", ret);
-        if (ret != 0)
-                printf (" %d [%s]", errno, strerror (errno));
-        putchar ('\n');
-
-        if (argc > 1) {
-                tv.tv_sec = strtoul (argv[1], NULL, 10);
-                if (tv.tv_sec > 0)
-                        tvp = &tv;
-                select (0, 0, 0, 0, tvp);
-        }
-
-        return 0;
+    runner_t runner;
+    char buf[80];
+    char *wdbuf;
+    ;
+    int ret;
+    int fd;
+    long pathmax = pathconf("/", _PC_PATH_MAX);
+    struct timeval tv = {
+        0,
+    };
+    struct timeval *tvp = NULL;
+    char *tfile;
+
+    wdbuf = malloc(pathmax);
+    assert(wdbuf);
+    getcwd(wdbuf, pathmax);
+
+    TBANNER("basic functionality: running \"echo a b\"");
+    runcmd("echo", "a", "b", NULL);
+
+    TBANNER("argv extension: running \"echo 1 2 ... 100\"");
+    runcmd("echo", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
+           "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
+           "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33",
+           "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44",
+           "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55",
+           "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66",
+           "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77",
+           "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88",
+           "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
+           "100", NULL);
+
+    TBANNER(
+        "add_args, argprintf, log, and popen-style functionality:\n"
+        "    running a multiline echo command, emit a log about it,\n"
+        "    redirect it to a pipe, read output lines\n"
+        "    and print them prefixed with \"got: \"");
+    runinit(&runner);
+    runner_add_args(&runner, "echo", "pid:", NULL);
+    runner_argprintf(&runner, "%d\n", getpid());
+    runner_add_arg(&runner, "wd:");
+    runner_add_arg(&runner, wdbuf);
+    runner_redir(&runner, 1, RUN_PIPE);
+    runner_start(&runner);
+    runner_log(&runner, "(x)", LOG_DEBUG, "starting program");
+    while (fgets(buf, sizeof(buf), runner_chio(&runner, 1)))
+        printf("got: %s", buf);
+    runner_end(&runner);
+
+    TBANNER("execve error reporting: running a non-existent command");
+    ret = runcmd("bafflavvitty", NULL);
+    printf("%d %d [%s]\n", ret, errno, strerror(errno));
+
+    TBANNER(
+        "output redirection: running \"echo foo\" redirected "
+        "to a temp file");
+    tfile = strdup("/tmp/foofXXXXXX");
+    assert(tfile);
+    fd = mkstemp(tfile);
+    assert(fd != -1);
+    printf("redirecting to %s\n", tfile);
+    runinit(&runner);
+    runner_add_args(&runner, "echo", "foo", NULL);
+    runner_redir(&runner, 1, fd);
+    ret = runner_run(&runner);
+    printf("runner_run returned: %d", ret);
+    if (ret != 0)
+        printf(", with errno %d [%s]", errno, strerror(errno));
+    putchar('\n');
+
+    /* sleep for seconds given as argument (0 means forever)
+     * to allow investigation of post-execution state to
+     * cbeck for resource leaks (eg. zombies).
+     */
+    if (argc > 1) {
+        tv.tv_sec = strtoul(argv[1], NULL, 10);
+        printf("### %s", "sleeping for");
+        if (tv.tv_sec > 0) {
+            printf(" %d seconds\n", tv.tv_sec);
+            tvp = &tv;
+        } else
+            printf("%s\n", "ever");
+        select(0, 0, 0, 0, tvp);
+    }
+
+    return 0;
 }
 #endif
diff --git a/libglusterfs/src/stack.c b/libglusterfs/src/stack.c
index 6977814ec69..1531f0da43f 100644
--- a/libglusterfs/src/stack.c
+++ b/libglusterfs/src/stack.c
@@ -8,419 +8,445 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "statedump.h"
-#include "stack.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/statedump.h"
+#include "glusterfs/stack.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 call_frame_t *
-create_frame (xlator_t *xl, call_pool_t *pool)
+create_frame(xlator_t *xl, call_pool_t *pool)
 {
-        call_stack_t    *stack = NULL;
-        call_frame_t    *frame = NULL;
-
-        if (!xl || !pool) {
-                return NULL;
-        }
-
-        stack = mem_get0 (pool->stack_mem_pool);
-        if (!stack)
-                return NULL;
-
-        INIT_LIST_HEAD (&stack->myframes);
-
-        frame = mem_get0 (pool->frame_mem_pool);
-        if (!frame) {
-                mem_put (stack);
-                return NULL;
-        }
-
-        frame->root = stack;
-        frame->this = xl;
-        LOCK_INIT (&frame->lock);
-        INIT_LIST_HEAD (&frame->frames);
-        list_add (&frame->frames, &stack->myframes);
-
-        stack->pool = pool;
-        stack->ctx = xl->ctx;
-
-        if (stack->ctx->measure_latency) {
-                if (gettimeofday (&stack->tv, NULL) == -1)
-                        gf_msg ("stack", GF_LOG_ERROR, errno,
-                                LG_MSG_GETTIMEOFDAY_FAILED,
-                                "gettimeofday () failed");
-                memcpy (&frame->begin, &stack->tv, sizeof (stack->tv));
-        }
-
-
-        LOCK (&pool->lock);
-        {
-                list_add (&stack->all_frames, &pool->all_frames);
-                pool->cnt++;
-        }
-        UNLOCK (&pool->lock);
-
-        LOCK_INIT (&stack->stack_lock);
-
-        return frame;
+    call_stack_t *stack = NULL;
+    call_frame_t *frame = NULL;
+    static uint64_t unique = 0;
+
+    if (!xl || !pool) {
+        return NULL;
+    }
+
+    stack = mem_get0(pool->stack_mem_pool);
+    if (!stack)
+        return NULL;
+
+    INIT_LIST_HEAD(&stack->myframes);
+
+    frame = mem_get0(pool->frame_mem_pool);
+    if (!frame) {
+        mem_put(stack);
+        return NULL;
+    }
+
+    frame->root = stack;
+    frame->this = xl;
+    LOCK_INIT(&frame->lock);
+    INIT_LIST_HEAD(&frame->frames);
+    list_add(&frame->frames, &stack->myframes);
+
+    stack->pool = pool;
+    stack->ctx = xl->ctx;
+
+    if (frame->root->ctx->measure_latency) {
+        timespec_now(&stack->tv);
+        memcpy(&frame->begin, &stack->tv, sizeof(stack->tv));
+    }
+
+    LOCK(&pool->lock);
+    {
+        list_add(&stack->all_frames, &pool->all_frames);
+        pool->cnt++;
+        stack->unique = unique++;
+    }
+    UNLOCK(&pool->lock);
+    GF_ATOMIC_INC(pool->total_count);
+
+    LOCK_INIT(&stack->stack_lock);
+
+    return frame;
 }
 
 void
-gf_proc_dump_call_frame (call_frame_t *call_frame, const char *key_buf,...)
+call_stack_set_groups(call_stack_t *stack, int ngrps, gid_t **groupbuf_p)
 {
+    /* We take the ownership of the passed group buffer. */
+
+    if (ngrps <= SMALL_GROUP_COUNT) {
+        memcpy(stack->groups_small, *groupbuf_p, sizeof(gid_t) * ngrps);
+        stack->groups = stack->groups_small;
+        GF_FREE(*groupbuf_p);
+    } else {
+        stack->groups_large = *groupbuf_p;
+        stack->groups = stack->groups_large;
+    }
+
+    stack->ngrps = ngrps;
+    /* Set a canary. */
+    *groupbuf_p = (void *)0xdeadf00d;
+}
 
-        char prefix[GF_DUMP_MAX_BUF_LEN];
-        va_list ap;
-        call_frame_t my_frame;
-        int  ret = -1;
-        char timestr[256] = {0,};
+void
+gf_proc_dump_call_frame(call_frame_t *call_frame, const char *key_buf, ...)
+{
+    char prefix[GF_DUMP_MAX_BUF_LEN];
+    va_list ap;
+    call_frame_t my_frame = {
+        0,
+    };
+
+    int ret = -1;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    int len;
+
+    if (!call_frame)
+        return;
 
-        if (!call_frame)
-                return;
+    GF_ASSERT(key_buf);
 
-        GF_ASSERT (key_buf);
+    va_start(ap, key_buf);
+    vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
+    va_end(ap);
 
-        memset(prefix, 0, sizeof(prefix));
-        memset(&my_frame, 0, sizeof(my_frame));
-        va_start(ap, key_buf);
-        vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
-        va_end(ap);
+    ret = TRY_LOCK(&call_frame->lock);
+    if (ret)
+        goto out;
 
-        ret = TRY_LOCK(&call_frame->lock);
-        if (ret)
-                goto out;
+    memcpy(&my_frame, call_frame, sizeof(my_frame));
+    UNLOCK(&call_frame->lock);
 
-        memcpy(&my_frame, call_frame, sizeof(my_frame));
-        UNLOCK(&call_frame->lock);
+    if (my_frame.root->ctx->measure_latency) {
+        gf_time_fmt(timestr, sizeof(timestr), my_frame.begin.tv_sec,
+                    gf_timefmt_FT);
+        len = strlen(timestr);
+        snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SNSECONDS,
+                 my_frame.begin.tv_nsec);
+        gf_proc_dump_write("frame-creation-time", "%s", timestr);
+        gf_proc_dump_write(
+            "timings", "%ld.%" GF_PRI_SNSECONDS " -> %ld.%" GF_PRI_SNSECONDS,
+            my_frame.begin.tv_sec, my_frame.begin.tv_nsec, my_frame.end.tv_sec,
+            my_frame.end.tv_nsec);
+    }
 
-        if (my_frame.this->ctx->measure_latency) {
-                gf_time_fmt (timestr, sizeof timestr, my_frame.begin.tv_sec,
-                             gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, my_frame.begin.tv_usec);
-                gf_proc_dump_write("frame-creation-time", "%s", timestr);
-        }
+    gf_proc_dump_write("frame", "%p", call_frame);
+    gf_proc_dump_write("ref_count", "%d", my_frame.ref_count);
+    gf_proc_dump_write("translator", "%s", my_frame.this->name);
+    gf_proc_dump_write("complete", "%d", my_frame.complete);
 
-        gf_proc_dump_write("frame", "%p", call_frame);
-        gf_proc_dump_write("ref_count", "%d", my_frame.ref_count);
-        gf_proc_dump_write("translator", "%s", my_frame.this->name);
-        gf_proc_dump_write("complete", "%d", my_frame.complete);
-        if (my_frame.parent)
-                gf_proc_dump_write("parent", "%s", my_frame.parent->this->name);
+    if (my_frame.parent)
+        gf_proc_dump_write("parent", "%s", my_frame.parent->this->name);
 
-        if (my_frame.wind_from)
-                gf_proc_dump_write("wind_from", "%s", my_frame.wind_from);
+    if (my_frame.wind_from)
+        gf_proc_dump_write("wind_from", "%s", my_frame.wind_from);
 
-        if (my_frame.wind_to)
-                gf_proc_dump_write("wind_to", "%s", my_frame.wind_to);
+    if (my_frame.wind_to)
+        gf_proc_dump_write("wind_to", "%s", my_frame.wind_to);
 
-        if (my_frame.unwind_from)
-                gf_proc_dump_write("unwind_from", "%s", my_frame.unwind_from);
+    if (my_frame.unwind_from)
+        gf_proc_dump_write("unwind_from", "%s", my_frame.unwind_from);
 
-        if (my_frame.unwind_to)
-                gf_proc_dump_write("unwind_to", "%s", my_frame.unwind_to);
+    if (my_frame.unwind_to)
+        gf_proc_dump_write("unwind_to", "%s", my_frame.unwind_to);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                gf_proc_dump_write("Unable to dump the frame information",
-                                   "(Lock acquisition failed) %p", my_frame);
-                return;
-        }
+    if (ret) {
+        gf_proc_dump_write("Unable to dump the frame information",
+                           "(Lock acquisition failed)");
+        return;
+    }
 }
 
-
 void
-gf_proc_dump_call_stack (call_stack_t *call_stack, const char *key_buf,...)
+gf_proc_dump_call_stack(call_stack_t *call_stack, const char *key_buf, ...)
 {
-        char prefix[GF_DUMP_MAX_BUF_LEN];
-        va_list ap;
-        call_frame_t *trav;
-        int32_t i = 1, cnt = 0;
-        char timestr[256] = {0,};
-
-        if (!call_stack)
-                return;
-
-        GF_ASSERT (key_buf);
-
-        memset(prefix, 0, sizeof(prefix));
-        va_start(ap, key_buf);
-        vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
-        va_end(ap);
-
-        cnt = call_frames_count (call_stack);
-        if (call_stack->ctx->measure_latency) {
-                gf_time_fmt (timestr, sizeof timestr, call_stack->tv.tv_sec,
-                             gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, call_stack->tv.tv_usec);
-        gf_proc_dump_write("callstack-creation-time", "%s", timestr);
-        }
-
-        gf_proc_dump_write("stack", "%p", call_stack);
-        gf_proc_dump_write("uid", "%d", call_stack->uid);
-        gf_proc_dump_write("gid", "%d", call_stack->gid);
-        gf_proc_dump_write("pid", "%d", call_stack->pid);
-        gf_proc_dump_write("unique", "%Ld", call_stack->unique);
-        gf_proc_dump_write("lk-owner", "%s", lkowner_utoa (&call_stack->lk_owner));
-
-        if (call_stack->type == GF_OP_TYPE_FOP)
-                gf_proc_dump_write("op", "%s",
-                                   (char *)gf_fop_list[call_stack->op]);
-        else
-                gf_proc_dump_write("op", "stack");
-
-        gf_proc_dump_write("type", "%d", call_stack->type);
-        gf_proc_dump_write("cnt", "%d", cnt);
-
-        list_for_each_entry (trav, &call_stack->myframes, frames) {
-                gf_proc_dump_add_section("%s.frame.%d", prefix, i);
-                gf_proc_dump_call_frame(trav, "%s.frame.%d", prefix, i);
-                i++;
-        }
+    char prefix[GF_DUMP_MAX_BUF_LEN];
+    va_list ap;
+    call_frame_t *trav;
+    int32_t i = 1, cnt = 0;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    int len;
+
+    if (!call_stack)
+        return;
+
+    GF_ASSERT(key_buf);
+
+    va_start(ap, key_buf);
+    vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
+    va_end(ap);
+
+    cnt = call_frames_count(call_stack);
+    gf_time_fmt(timestr, sizeof(timestr), call_stack->tv.tv_sec, gf_timefmt_FT);
+    len = strlen(timestr);
+    snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SNSECONDS,
+             call_stack->tv.tv_nsec);
+    gf_proc_dump_write("callstack-creation-time", "%s", timestr);
+
+    gf_proc_dump_write("stack", "%p", call_stack);
+    gf_proc_dump_write("uid", "%d", call_stack->uid);
+    gf_proc_dump_write("gid", "%d", call_stack->gid);
+    gf_proc_dump_write("pid", "%d", call_stack->pid);
+    gf_proc_dump_write("unique", "%" PRIu64, call_stack->unique);
+    gf_proc_dump_write("lk-owner", "%s", lkowner_utoa(&call_stack->lk_owner));
+    gf_proc_dump_write("ctime", "%" GF_PRI_SECOND ".%" GF_PRI_SNSECONDS,
+                       call_stack->tv.tv_sec, call_stack->tv.tv_nsec);
+
+    if (call_stack->type == GF_OP_TYPE_FOP)
+        gf_proc_dump_write("op", "%s", (char *)gf_fop_list[call_stack->op]);
+    else
+        gf_proc_dump_write("op", "stack");
+
+    gf_proc_dump_write("type", "%d", call_stack->type);
+    gf_proc_dump_write("cnt", "%d", cnt);
+
+    list_for_each_entry(trav, &call_stack->myframes, frames)
+    {
+        gf_proc_dump_add_section("%s.frame.%d", prefix, i);
+        gf_proc_dump_call_frame(trav, "%s.frame.%d", prefix, i);
+        i++;
+    }
 }
 
 void
-gf_proc_dump_pending_frames (call_pool_t *call_pool)
+gf_proc_dump_pending_frames(call_pool_t *call_pool)
 {
+    call_stack_t *trav = NULL;
+    int i = 1;
+    int ret = -1;
+    gf_boolean_t section_added = _gf_false;
 
-        call_stack_t     *trav = NULL;
-        int              i = 1;
-        int              ret = -1;
-        gf_boolean_t     section_added = _gf_true;
-
-        if (!call_pool)
-                return;
-
-        ret = TRY_LOCK (&(call_pool->lock));
-        if (ret)
-                goto out;
-
+    if (!call_pool)
+        return;
 
-        gf_proc_dump_add_section("global.callpool");
-        section_added = _gf_true;
-        gf_proc_dump_write("callpool_address","%p", call_pool);
-        gf_proc_dump_write("callpool.cnt","%d", call_pool->cnt);
+    ret = TRY_LOCK(&(call_pool->lock));
+    if (ret)
+        goto out;
 
+    gf_proc_dump_add_section("global.callpool");
+    section_added = _gf_true;
+    gf_proc_dump_write("callpool_address", "%p", call_pool);
+    gf_proc_dump_write("callpool.cnt", "%" PRId64, call_pool->cnt);
 
-        list_for_each_entry (trav, &call_pool->all_frames, all_frames) {
-                gf_proc_dump_add_section("global.callpool.stack.%d",i);
-                gf_proc_dump_call_stack(trav, "global.callpool.stack.%d", i);
-                i++;
-        }
-        UNLOCK (&(call_pool->lock));
+    list_for_each_entry(trav, &call_pool->all_frames, all_frames)
+    {
+        gf_proc_dump_add_section("global.callpool.stack.%d", i);
+        gf_proc_dump_call_stack(trav, "global.callpool.stack.%d", i);
+        i++;
+    }
+    UNLOCK(&(call_pool->lock));
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                if (_gf_false == section_added)
-                        gf_proc_dump_add_section("global.callpool");
-                gf_proc_dump_write("Unable to dump the callpool",
-                                   "(Lock acquisition failed) %p",
-                                   call_pool);
-        }
-        return;
+    if (ret) {
+        if (_gf_false == section_added)
+            gf_proc_dump_add_section("global.callpool");
+        gf_proc_dump_write("Unable to dump the callpool",
+                           "(Lock acquisition failed) %p", call_pool);
+    }
+    return;
 }
 
 void
-gf_proc_dump_call_frame_to_dict (call_frame_t *call_frame,
-                                 char *prefix, dict_t *dict)
+gf_proc_dump_call_frame_to_dict(call_frame_t *call_frame, char *prefix,
+                                dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        call_frame_t    tmp_frame = {0,};
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    char msg[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    call_frame_t tmp_frame = {
+        0,
+    };
+
+    if (!call_frame || !dict)
+        return;
+
+    ret = TRY_LOCK(&call_frame->lock);
+    if (ret)
+        return;
+    memcpy(&tmp_frame, call_frame, sizeof(tmp_frame));
+    UNLOCK(&call_frame->lock);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_set_int32(dict, key, tmp_frame.ref_count);
+    if (ret)
+        return;
 
-        if (!call_frame || !dict)
-                return;
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.this->name));
+    if (ret)
+        return;
+
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_set_int32(dict, key, tmp_frame.complete);
+    if (ret)
+        return;
 
-        ret = TRY_LOCK (&call_frame->lock);
+    if (tmp_frame.root->ctx->measure_latency) {
+        snprintf(key, sizeof(key), "%s.timings", prefix);
+        snprintf(msg, sizeof(msg),
+                 "%ld.%" GF_PRI_SNSECONDS " -> %ld.%" GF_PRI_SNSECONDS,
+                 tmp_frame.begin.tv_sec, tmp_frame.begin.tv_nsec,
+                 tmp_frame.end.tv_sec, tmp_frame.end.tv_nsec);
+        ret = dict_set_str(dict, key, msg);
         if (ret)
-                return;
-        memcpy (&tmp_frame, call_frame, sizeof (tmp_frame));
-        UNLOCK (&call_frame->lock);
+            return;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_set_int32 (dict, key, tmp_frame.ref_count);
+    if (tmp_frame.parent) {
+        snprintf(key, sizeof(key), "%s.parent", prefix);
+        ret = dict_set_dynstr(dict, key,
+                              gf_strdup(tmp_frame.parent->this->name));
         if (ret)
-                return;
+            return;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_set_dynstr (dict, key, gf_strdup (tmp_frame.this->name));
+    if (tmp_frame.wind_from) {
+        snprintf(key, sizeof(key), "%s.windfrom", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.wind_from));
         if (ret)
-                return;
+            return;
+    }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_set_int32 (dict, key, tmp_frame.complete);
+    if (tmp_frame.wind_to) {
+        snprintf(key, sizeof(key), "%s.windto", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.wind_to));
         if (ret)
-                return;
-
-        if (tmp_frame.parent) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.parent", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                    gf_strdup (tmp_frame.parent->this->name));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.wind_from) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.windfrom", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.wind_from));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.wind_to) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.windto", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.wind_to));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.unwind_from) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.unwind_from));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.unwind_to) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.unwind_to", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.unwind_to));
-        }
+            return;
+    }
 
-        return;
+    if (tmp_frame.unwind_from) {
+        snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.unwind_from));
+        if (ret)
+            return;
+    }
+
+    if (tmp_frame.unwind_to) {
+        snprintf(key, sizeof(key), "%s.unwind_to", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.unwind_to));
+        if (ret)
+            return;
+    }
+
+    return;
 }
 
 void
-gf_proc_dump_call_stack_to_dict (call_stack_t *call_stack,
-                                 char *prefix, dict_t *dict)
+gf_proc_dump_call_stack_to_dict(call_stack_t *call_stack, char *prefix,
+                                dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        call_frame_t    *trav = NULL;
-        int             i = 0;
-        int             count = 0;
-
-        if (!call_stack || !dict)
-                return;
-
-        count = call_frames_count (call_stack);
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->uid);
-        if (ret)
-                return;
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->gid);
-        if (ret)
-                return;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    call_frame_t *trav = NULL;
+    int i = 0;
+    int count = 0;
+
+    if (!call_stack || !dict)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->pid);
-        if (ret)
-                return;
+    count = call_frames_count(call_stack);
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->uid);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_set_uint64 (dict, key, call_stack->unique);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->gid);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.op", prefix);
-        if (call_stack->type == GF_OP_TYPE_FOP)
-                ret = dict_set_str (dict, key,
-                                    (char *)gf_fop_list[call_stack->op]);
-        else
-                ret = dict_set_str (dict, key, "other");
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->pid);
+    if (ret)
+        return;
 
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_set_uint64(dict, key, call_stack->unique);
+    if (ret)
+        return;
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.type", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->type);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.op", prefix);
+    if (call_stack->type == GF_OP_TYPE_FOP)
+        ret = dict_set_str(dict, key, (char *)gf_fop_list[call_stack->op]);
+    else
+        ret = dict_set_str(dict, key, "other");
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_set_int32 (dict, key, count);
-        if (ret)
-                return;
+    if (ret)
+        return;
 
-        list_for_each_entry (trav, &call_stack->myframes, frames) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s.frame%d",
-                          prefix, i);
-                gf_proc_dump_call_frame_to_dict (trav, key, dict);
-                i++;
-        }
+    snprintf(key, sizeof(key), "%s.type", prefix);
+    ret = dict_set_int32(dict, key, call_stack->type);
+    if (ret)
+        return;
 
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_set_int32(dict, key, count);
+    if (ret)
         return;
+
+    list_for_each_entry(trav, &call_stack->myframes, frames)
+    {
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        gf_proc_dump_call_frame_to_dict(trav, key, dict);
+        i++;
+    }
+
+    return;
 }
 
 void
-gf_proc_dump_pending_frames_to_dict (call_pool_t *call_pool, dict_t *dict)
+gf_proc_dump_pending_frames_to_dict(call_pool_t *call_pool, dict_t *dict)
 {
-        int             ret = -1;
-        call_stack_t    *trav = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             i = 0;
-
-        if (!call_pool || !dict)
-                return;
-
-        ret = TRY_LOCK (&call_pool->lock);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        LG_MSG_LOCK_FAILURE, "Unable to dump call "
-                        "pool to dict.");
-                return;
-        }
-
-        ret = dict_set_int32 (dict, "callpool.count", call_pool->cnt);
-        if (ret)
-                goto out;
+    int ret = -1;
+    call_stack_t *trav = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int i = 0;
+
+    if (!call_pool || !dict)
+        return;
 
-        list_for_each_entry (trav, &call_pool->all_frames, all_frames) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "callpool.stack%d", i);
-                gf_proc_dump_call_stack_to_dict (trav, key, dict);
-                i++;
-        }
+    ret = TRY_LOCK(&call_pool->lock);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_LOCK_FAILURE,
+               "Unable to dump call "
+               "pool to dict.");
+        return;
+    }
+
+    ret = dict_set_int32(dict, "callpool.count", call_pool->cnt);
+    if (ret)
+        goto out;
+
+    list_for_each_entry(trav, &call_pool->all_frames, all_frames)
+    {
+        snprintf(key, sizeof(key), "callpool.stack%d", i);
+        gf_proc_dump_call_stack_to_dict(trav, key, dict);
+        i++;
+    }
 
 out:
-        UNLOCK (&call_pool->lock);
+    UNLOCK(&call_pool->lock);
 
-        return;
+    return;
 }
 
 gf_boolean_t
-__is_fuse_call (call_frame_t *frame)
+__is_fuse_call(call_frame_t *frame)
 {
-        gf_boolean_t    is_fuse_call = _gf_false;
-        GF_ASSERT (frame);
-        GF_ASSERT (frame->root);
+    gf_boolean_t is_fuse_call = _gf_false;
+    GF_ASSERT(frame);
+    GF_ASSERT(frame->root);
 
-        if (NFS_PID != frame->root->pid)
-                is_fuse_call = _gf_true;
-        return is_fuse_call;
+    if (NFS_PID != frame->root->pid)
+        is_fuse_call = _gf_true;
+    return is_fuse_call;
 }
diff --git a/libglusterfs/src/stack.h b/libglusterfs/src/stack.h
deleted file mode 100644
index eb5848e92aa..00000000000
--- a/libglusterfs/src/stack.h
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-/*
-  This file defines MACROS and static inlines used to emulate a function
-  call over asynchronous communication with remote server
-*/
-
-#ifndef _STACK_H
-#define _STACK_H
-
-struct _call_stack;
-typedef struct _call_stack call_stack_t;
-struct _call_frame;
-typedef struct _call_frame call_frame_t;
-struct call_pool;
-typedef struct call_pool call_pool_t;
-
-#include <sys/time.h>
-
-#include "xlator.h"
-#include "dict.h"
-#include "list.h"
-#include "common-utils.h"
-#include "globals.h"
-#include "lkowner.h"
-#include "client_t.h"
-#include "libglusterfs-messages.h"
-
-#define NFS_PID 1
-#define LOW_PRIO_PROC_PID -1
-
-#define STACK_ERR_XL_NAME(stack) (stack->err_xl?stack->err_xl->name:"-")
-#define STACK_CLIENT_NAME(stack) (stack->client?stack->client->client_uid:"-")
-
-typedef int32_t (*ret_fn_t) (call_frame_t *frame,
-                             call_frame_t *prev_frame,
-                             xlator_t *this,
-                             int32_t op_ret,
-                             int32_t op_errno,
-                             ...);
-
-struct call_pool {
-        union {
-                struct list_head   all_frames;
-                struct {
-                        call_stack_t *next_call;
-                        call_stack_t *prev_call;
-                } all_stacks;
-        };
-        int64_t                     cnt;
-        gf_lock_t                   lock;
-        struct mem_pool             *frame_mem_pool;
-        struct mem_pool             *stack_mem_pool;
-};
-
-struct _call_frame {
-        call_stack_t *root;        /* stack root */
-        call_frame_t *parent;      /* previous BP */
-        struct list_head frames;
-        void         *local;       /* local variables */
-        xlator_t     *this;        /* implicit object */
-        ret_fn_t      ret;         /* op_return address */
-        int32_t       ref_count;
-        gf_lock_t     lock;
-        void         *cookie;      /* unique cookie */
-        gf_boolean_t  complete;
-
-        glusterfs_fop_t op;
-        struct timeval begin;      /* when this frame was created */
-        struct timeval end;        /* when this frame completed */
-        const char      *wind_from;
-        const char      *wind_to;
-        const char      *unwind_from;
-        const char      *unwind_to;
-};
-
-#define SMALL_GROUP_COUNT 128
-
-struct _call_stack {
-        union {
-                struct list_head      all_frames;
-                struct {
-                        call_stack_t *next_call;
-                        call_stack_t *prev_call;
-                };
-        };
-        call_pool_t                  *pool;
-        gf_lock_t                     stack_lock;
-        client_t                     *client;
-        uint64_t                      unique;
-        void                         *state;  /* pointer to request state */
-        uid_t                         uid;
-        gid_t                         gid;
-        pid_t                         pid;
-        char                          identifier[UNIX_PATH_MAX];
-        uint16_t                      ngrps;
-        uint32_t                      groups_small[SMALL_GROUP_COUNT];
-	uint32_t                     *groups_large;
-	uint32_t                     *groups;
-        gf_lkowner_t                  lk_owner;
-        glusterfs_ctx_t              *ctx;
-
-        struct list_head              myframes; /* List of call_frame_t that go
-                                                   to make the call stack */
-
-        int32_t                       op;
-        int8_t                        type;
-        struct timeval                tv;
-        xlator_t                     *err_xl;
-        int32_t                       error;
-};
-
-
-#define frame_set_uid_gid(frm, u, g)            \
-        do {                                    \
-                if (frm) {                      \
-                        (frm)->root->uid = u;   \
-                        (frm)->root->gid = g;   \
-                        (frm)->root->ngrps = 0; \
-                }                               \
-        } while (0);                            \
-
-
-struct xlator_fops;
-
-void
-gf_latency_begin (call_frame_t *frame, void *fn);
-
-void
-gf_latency_end (call_frame_t *frame);
-
-static inline void
-FRAME_DESTROY (call_frame_t *frame)
-{
-        void *local = NULL;
-
-        list_del_init (&frame->frames);
-        if (frame->local) {
-                local = frame->local;
-                frame->local = NULL;
-
-        }
-
-        LOCK_DESTROY (&frame->lock);
-        mem_put (frame);
-
-        if (local)
-                mem_put (local);
-}
-
-
-static inline void
-STACK_DESTROY (call_stack_t *stack)
-{
-        call_frame_t *frame = NULL;
-        call_frame_t *tmp = NULL;
-
-        LOCK (&stack->pool->lock);
-        {
-                list_del_init (&stack->all_frames);
-                stack->pool->cnt--;
-        }
-        UNLOCK (&stack->pool->lock);
-
-        LOCK_DESTROY (&stack->stack_lock);
-
-        list_for_each_entry_safe (frame, tmp, &stack->myframes, frames) {
-                FRAME_DESTROY (frame);
-        }
-
-	GF_FREE (stack->groups_large);
-
-        mem_put (stack);
-}
-
-static inline void
-STACK_RESET (call_stack_t *stack)
-{
-        call_frame_t *frame = NULL;
-        call_frame_t *tmp = NULL;
-        call_frame_t *last = NULL;
-        struct list_head toreset = {0};
-
-        INIT_LIST_HEAD (&toreset);
-
-        /* We acquire call_pool->lock only to remove the frames from this stack
-         * to preserve atomicity. This synchronizes across concurrent requests
-         * like statedump, STACK_DESTROY etc. */
-
-        LOCK (&stack->pool->lock);
-        {
-                last = list_last_entry (&stack->myframes, call_frame_t, frames);
-                list_del_init (&last->frames);
-                list_splice_init (&stack->myframes, &toreset);
-                list_add (&last->frames, &stack->myframes);
-        }
-        UNLOCK (&stack->pool->lock);
-
-        list_for_each_entry_safe (frame, tmp, &toreset, frames) {
-                FRAME_DESTROY (frame);
-        }
-}
-
-#define FRAME_SU_DO(frm, local_type)                                   \
-        do {                                                           \
-                local_type *__local = (frm)->local;                    \
-                __local->uid = frm->root->uid;                         \
-                __local->gid = frm->root->gid;                         \
-                frm->root->uid = 0;                                    \
-                frm->root->gid = 0;                                    \
-        } while (0);                                                   \
-
-#define FRAME_SU_UNDO(frm, local_type)                                 \
-        do {                                                           \
-                local_type *__local = (frm)->local;                    \
-                frm->root->uid = __local->uid;                         \
-                frm->root->gid = __local->gid;                         \
-        } while (0);                                                   \
-
-
-/* make a call without switching frames */
-#define STACK_WIND_TAIL(frame, obj, fn, params ...)                     \
-        do {                                                            \
-                xlator_t     *old_THIS = NULL;                          \
-                xlator_t     *next_xl = obj;                            \
-                typeof(fn)    next_xl_fn = fn;                          \
-                                                                        \
-                frame->this = next_xl;                                  \
-                frame->wind_to = #fn;                                   \
-                old_THIS = THIS;                                        \
-                THIS = next_xl;                                         \
-                gf_msg_trace ("stack-trace", 0,                         \
-                              "stack-address: %p, "                     \
-                              "winding from %s to %s",                  \
-                              frame->root, old_THIS->name,              \
-                              THIS->name);                              \
-                next_xl_fn (frame, next_xl, params);                    \
-                THIS = old_THIS;                                        \
-        } while (0)
-
-
-/* make a call */
-#define STACK_WIND(frame, rfn, obj, fn, params ...)             \
-        STACK_WIND_COMMON(frame, rfn, 0, NULL, obj, fn, params)
-
-/* make a call with a cookie */
-#define STACK_WIND_COOKIE(frame, rfn, cky, obj, fn, params ...) \
-        STACK_WIND_COMMON(frame, rfn, 1, cky, obj, fn, params)
-
-/* Cookie passed as the argument can be NULL (ptr) or 0 (int). Hence we
-   have to have a mechanism to separate out the two STACK_WIND formats.
-   Needed a common macro, as other than for cookie, all the other code
-   is common across.
- */
-#define STACK_WIND_COMMON(frame, rfn, has_cookie, cky, obj, fn, params ...) \
-        do {                                                            \
-                call_frame_t *_new = NULL;                              \
-                xlator_t     *old_THIS = NULL;                          \
-                                                                        \
-                _new = mem_get0 (frame->root->pool->frame_mem_pool);    \
-                if (!_new) {                                            \
-                        break;                                          \
-                }                                                       \
-                typeof(fn##_cbk) tmp_cbk = rfn;                         \
-                _new->root = frame->root;                               \
-                _new->this = obj;                                       \
-                _new->ret = (ret_fn_t) tmp_cbk;                         \
-                _new->parent = frame;                                   \
-                /* (void *) is required for avoiding gcc warning */     \
-                _new->cookie = ((has_cookie == 1) ?                     \
-                                (void *)(cky) : (void *)_new);          \
-                _new->wind_from = __FUNCTION__;                         \
-                _new->wind_to = #fn;                                    \
-                _new->unwind_to = #rfn;                                 \
-                LOCK_INIT (&_new->lock);                                \
-                LOCK(&frame->root->stack_lock);                         \
-                {                                                       \
-                        list_add (&_new->frames, &frame->root->myframes);\
-                        frame->ref_count++;                             \
-                }                                                       \
-                UNLOCK(&frame->root->stack_lock);                       \
-                fn##_cbk = rfn;                                         \
-                old_THIS = THIS;                                        \
-                THIS = obj;                                             \
-                gf_msg_trace ("stack-trace", 0,                         \
-                              "stack-address: %p, "                     \
-                              "winding from %s to %s",                  \
-                              frame->root, old_THIS->name,              \
-                              THIS->name);                              \
-                if (obj->ctx->measure_latency)                          \
-                        gf_latency_begin (_new, fn);                    \
-                fn (_new, obj, params);                                 \
-                THIS = old_THIS;                                        \
-        } while (0)
-
-
-#define STACK_UNWIND STACK_UNWIND_STRICT
-
-/* return from function in type-safe way */
-#define STACK_UNWIND_STRICT(op, frame, op_ret, op_errno, params ...)    \
-        do {                                                            \
-                fop_##op##_cbk_t      fn = NULL;                        \
-                call_frame_t *_parent = NULL;                           \
-                xlator_t     *old_THIS = NULL;                          \
-                                                                        \
-                if (!frame) {                                           \
-                        gf_msg ("stack", GF_LOG_CRITICAL, 0,            \
-                                LG_MSG_FRAME_ERROR, "!frame");          \
-                        break;                                          \
-                }                                                       \
-                if (op_ret < 0) {                                       \
-                        gf_msg_debug ("stack-trace", op_errno,          \
-                                      "stack-address: %p, "             \
-                                      "%s returned %d error: %s",       \
-                                      frame->root, THIS->name,          \
-                                      (int32_t)op_ret,                  \
-                                      strerror(op_errno));              \
-                } else {                                                \
-                        gf_msg_trace ("stack-trace", 0,                 \
-                                      "stack-address: %p, "             \
-                                      "%s returned %d",                 \
-                                      frame->root, THIS->name,          \
-                                      (int32_t)op_ret);                 \
-                }                                                       \
-                fn = (fop_##op##_cbk_t )frame->ret;                     \
-                _parent = frame->parent;                                \
-                LOCK(&frame->root->stack_lock);                         \
-                {                                                       \
-                        _parent->ref_count--;                           \
-                        if (op_ret < 0 &&                               \
-                            op_errno != frame->root->error) {           \
-                                frame->root->err_xl = frame->this;      \
-                                frame->root->error = op_errno;          \
-                        } else if (op_ret == 0) {                       \
-                                frame->root->err_xl = NULL;             \
-                                frame->root->error = 0;                 \
-                        }                                               \
-                }                                                       \
-                UNLOCK(&frame->root->stack_lock);                       \
-                old_THIS = THIS;                                        \
-                THIS = _parent->this;                                   \
-                frame->complete = _gf_true;                             \
-                frame->unwind_from = __FUNCTION__;                      \
-                if (frame->this->ctx->measure_latency)                  \
-                        gf_latency_end (frame);                         \
-                fn (_parent, frame->cookie, _parent->this, op_ret,      \
-                    op_errno, params);                                  \
-                THIS = old_THIS;                                        \
-        } while (0)
-
-
-static void
-call_stack_set_groups (call_stack_t *stack, int ngrps, gid_t *groupbuf)
-{
-        stack->groups = groupbuf;
-        stack->ngrps = ngrps;
-}
-
-static inline int
-call_stack_alloc_groups (call_stack_t *stack, int ngrps)
-{
-	if (ngrps <= SMALL_GROUP_COUNT) {
-		call_stack_set_groups (stack, ngrps, stack->groups_small);
-	} else {
-		stack->groups_large = GF_CALLOC (ngrps, sizeof (gid_t),
-						 gf_common_mt_groups_t);
-		if (!stack->groups_large)
-			return -1;
-		call_stack_set_groups (stack, ngrps, stack->groups_large);
-	}
-
-	return 0;
-}
-
-static inline
-int call_frames_count (call_stack_t *call_stack)
-{
-        call_frame_t *pos;
-        int32_t count = 0;
-
-        if (!call_stack)
-                return count;
-
-        list_for_each_entry (pos, &call_stack->myframes, frames)
-                count++;
-
-        return count;
-}
-
-static inline call_frame_t *
-copy_frame (call_frame_t *frame)
-{
-        call_stack_t *newstack = NULL;
-        call_stack_t *oldstack = NULL;
-        call_frame_t *newframe = NULL;
-
-        if (!frame) {
-                return NULL;
-        }
-
-        newstack = mem_get0 (frame->root->pool->stack_mem_pool);
-        if (newstack == NULL) {
-                return NULL;
-        }
-
-        INIT_LIST_HEAD (&newstack->myframes);
-
-        newframe = mem_get0 (frame->root->pool->frame_mem_pool);
-        if (!newframe) {
-                mem_put (newstack);
-                return NULL;
-        }
-
-        newframe->this = frame->this;
-        newframe->root = newstack;
-        INIT_LIST_HEAD (&newframe->frames);
-        list_add (&newframe->frames, &newstack->myframes);
-
-        oldstack = frame->root;
-
-        newstack->uid = oldstack->uid;
-        newstack->gid = oldstack->gid;
-        newstack->pid = oldstack->pid;
-        newstack->ngrps = oldstack->ngrps;
-        newstack->op  = oldstack->op;
-        newstack->type = oldstack->type;
-	if (call_stack_alloc_groups (newstack, oldstack->ngrps) != 0) {
-		mem_put (newstack);
-		return NULL;
-	}
-        memcpy (newstack->groups, oldstack->groups,
-                sizeof (gid_t) * oldstack->ngrps);
-        newstack->unique = oldstack->unique;
-        newstack->pool = oldstack->pool;
-        newstack->lk_owner = oldstack->lk_owner;
-        newstack->ctx = oldstack->ctx;
-
-        if (newstack->ctx->measure_latency) {
-                if (gettimeofday (&newstack->tv, NULL) == -1)
-                        gf_msg ("stack", GF_LOG_ERROR, errno,
-                                LG_MSG_GETTIMEOFDAY_FAILED,
-                                "gettimeofday () failed.");
-                memcpy (&newframe->begin, &newstack->tv,
-                        sizeof (newstack->tv));
-        }
-
-        LOCK_INIT (&newframe->lock);
-        LOCK_INIT (&newstack->stack_lock);
-
-        LOCK (&oldstack->pool->lock);
-        {
-                list_add (&newstack->all_frames, &oldstack->all_frames);
-                newstack->pool->cnt++;
-        }
-        UNLOCK (&oldstack->pool->lock);
-
-        return newframe;
-}
-
-void gf_proc_dump_pending_frames(call_pool_t *call_pool);
-void gf_proc_dump_pending_frames_to_dict (call_pool_t *call_pool,
-                                          dict_t *dict);
-call_frame_t *create_frame (xlator_t *xl, call_pool_t *pool);
-gf_boolean_t __is_fuse_call (call_frame_t *frame);
-#endif /* _STACK_H */
diff --git a/libglusterfs/src/statedump.c b/libglusterfs/src/statedump.c
index 697ddc3b7ba..65f0eb5c7f3 100644
--- a/libglusterfs/src/statedump.c
+++ b/libglusterfs/src/statedump.c
@@ -9,14 +9,11 @@
 */
 
 #include <stdarg.h>
-#include "glusterfs.h"
-#include "logging.h"
-#include "iobuf.h"
-#include "statedump.h"
-#include "stack.h"
-#include "common-utils.h"
-#include "syscall.h"
-
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/statedump.h"
+#include "glusterfs/stack.h"
+#include "glusterfs/syscall.h"
 
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
@@ -26,982 +23,1031 @@
    'deadlock' with statedump. This is because statedump happens
    inside a signal handler and cannot afford to block on a lock.*/
 #ifdef gf_log
-# undef gf_log
+#undef gf_log
 #endif
 
-#define GF_PROC_DUMP_IS_OPTION_ENABLED(opt)     \
-        (dump_options.dump_##opt == _gf_true)
+#define GF_PROC_DUMP_IS_OPTION_ENABLED(opt)                                    \
+    (dump_options.dump_##opt == _gf_true)
 
-#define GF_PROC_DUMP_IS_XL_OPTION_ENABLED(opt)                  \
-        (dump_options.xl_options.dump_##opt == _gf_true)
+#define GF_PROC_DUMP_IS_XL_OPTION_ENABLED(opt)                                 \
+    (dump_options.xl_options.dump_##opt == _gf_true)
 
 extern xlator_t global_xlator;
 
-static pthread_mutex_t  gf_proc_dump_mutex;
+static pthread_mutex_t gf_proc_dump_mutex;
 static int gf_dump_fd = -1;
 gf_dump_options_t dump_options;
 
 static strfd_t *gf_dump_strfd = NULL;
 
 static void
-gf_proc_dump_lock (void)
+gf_proc_dump_lock(void)
 {
-        pthread_mutex_lock (&gf_proc_dump_mutex);
+    pthread_mutex_lock(&gf_proc_dump_mutex);
 }
 
-
 static void
-gf_proc_dump_unlock (void)
+gf_proc_dump_unlock(void)
 {
-        pthread_mutex_unlock (&gf_proc_dump_mutex);
+    pthread_mutex_unlock(&gf_proc_dump_mutex);
 }
 
 static int
-gf_proc_dump_open (char *tmpname)
+gf_proc_dump_open(char *tmpname)
 {
-        int  dump_fd = -1;
+    int dump_fd = -1;
 
-        mode_t mask = umask(S_IRWXG | S_IRWXO);
-        dump_fd = mkstemp (tmpname);
-        umask(mask);
-        if (dump_fd < 0)
-                return -1;
+    mode_t mask = umask(S_IRWXG | S_IRWXO);
+    dump_fd = mkstemp(tmpname);
+    umask(mask);
+    if (dump_fd < 0)
+        return -1;
 
-        gf_dump_fd = dump_fd;
-        return 0;
+    gf_dump_fd = dump_fd;
+    return 0;
 }
 
 static void
-gf_proc_dump_close (void)
+gf_proc_dump_close(void)
 {
-        sys_close (gf_dump_fd);
-        gf_dump_fd = -1;
+    sys_close(gf_dump_fd);
+    gf_dump_fd = -1;
 }
 
 static int
-gf_proc_dump_set_path (char *dump_options_file)
+gf_proc_dump_set_path(char *dump_options_file)
 {
-        int     ret = -1;
-        FILE    *fp = NULL;
-        char    buf[256];
-        char    *key = NULL, *value = NULL;
-        char    *saveptr = NULL;
+    int ret = -1;
+    FILE *fp = NULL;
+    char buf[256];
+    char *key = NULL, *value = NULL;
+    char *saveptr = NULL;
+
+    fp = fopen(dump_options_file, "r");
+    if (!fp)
+        goto out;
+
+    ret = fscanf(fp, "%255s", buf);
+
+    while (ret != EOF) {
+        key = strtok_r(buf, "=", &saveptr);
+        if (!key) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
+        }
 
-        fp = fopen (dump_options_file, "r");
-        if (!fp)
-                goto out;
+        value = strtok_r(NULL, "=", &saveptr);
 
-        ret = fscanf (fp, "%s", buf);
-
-        while (ret != EOF) {
-                key = strtok_r (buf, "=", &saveptr);
-                if (!key) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-
-                value = strtok_r (NULL, "=", &saveptr);
-
-                if (!value) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-                if (!strcmp (key, "path")) {
-                        dump_options.dump_path = gf_strdup (value);
-                        break;
-                }
+        if (!value) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
         }
+        if (!strcmp(key, "path")) {
+            dump_options.dump_path = gf_strdup(value);
+            break;
+        }
+    }
 
 out:
-        if (fp)
-                fclose (fp);
-        return ret;
+    if (fp)
+        fclose(fp);
+    return ret;
 }
 
-int
-gf_proc_dump_add_section_fd (char *key, va_list ap)
+static int
+gf_proc_dump_add_section_fd(char *key, va_list ap)
 {
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int len;
 
-        char buf[GF_DUMP_MAX_BUF_LEN];
+    GF_ASSERT(key);
 
-        GF_ASSERT(key);
-
-        memset (buf, 0, sizeof(buf));
-        snprintf (buf, GF_DUMP_MAX_BUF_LEN, "\n[");
-        vsnprintf (buf + strlen(buf),
-                   GF_DUMP_MAX_BUF_LEN - strlen (buf), key, ap);
-        snprintf (buf + strlen(buf),
-                  GF_DUMP_MAX_BUF_LEN - strlen (buf),  "]\n");
-        return sys_write (gf_dump_fd, buf, strlen (buf));
+    len = snprintf(buf, GF_DUMP_MAX_BUF_LEN, "\n[");
+    len += vsnprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, key, ap);
+    len += snprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, "]\n");
+    return sys_write(gf_dump_fd, buf, len);
 }
 
-
-int
-gf_proc_dump_add_section_strfd (char *key, va_list ap)
+static int
+gf_proc_dump_add_section_strfd(char *key, va_list ap)
 {
-	int ret = 0;
+    int ret = 0;
 
-        ret += strprintf (gf_dump_strfd, "[");
-	ret += strvprintf (gf_dump_strfd, key, ap);
-	ret += strprintf (gf_dump_strfd,  "]\n");
+    ret += strprintf(gf_dump_strfd, "[");
+    ret += strvprintf(gf_dump_strfd, key, ap);
+    ret += strprintf(gf_dump_strfd, "]\n");
 
-	return ret;
+    return ret;
 }
 
-
 int
-gf_proc_dump_add_section (char *key, ...)
+gf_proc_dump_add_section(char *key, ...)
 {
-	va_list ap;
-	int ret = 0;
+    va_list ap;
+    int ret = 0;
 
-	va_start (ap, key);
-	if (gf_dump_strfd)
-		ret = gf_proc_dump_add_section_strfd (key, ap);
-	else
-		ret = gf_proc_dump_add_section_fd (key, ap);
-	va_end (ap);
+    va_start(ap, key);
+    if (gf_dump_strfd)
+        ret = gf_proc_dump_add_section_strfd(key, ap);
+    else
+        ret = gf_proc_dump_add_section_fd(key, ap);
+    va_end(ap);
 
-	return ret;
+    return ret;
 }
 
-
-int
-gf_proc_dump_write_fd (char *key, char *value, va_list ap)
+static int
+gf_proc_dump_write_fd(char *key, char *value, va_list ap)
 {
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int len = 0;
 
-        char         buf[GF_DUMP_MAX_BUF_LEN];
-        int          offset = 0;
+    GF_ASSERT(key);
 
-        GF_ASSERT (key);
+    len = snprintf(buf, GF_DUMP_MAX_BUF_LEN, "%s=", key);
+    len += vsnprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, value, ap);
 
-        offset = strlen (key);
+    len += snprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, "\n");
+    return sys_write(gf_dump_fd, buf, len);
+}
 
-        memset (buf, 0, GF_DUMP_MAX_BUF_LEN);
-        snprintf (buf, GF_DUMP_MAX_BUF_LEN, "%s", key);
-        snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "=");
-        offset += 1;
-        vsnprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, value, ap);
+static int
+gf_proc_dump_write_strfd(char *key, char *value, va_list ap)
+{
+    int ret = 0;
 
-        offset = strlen (buf);
-        snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
-        return sys_write (gf_dump_fd, buf, strlen (buf));
-}
+    ret += strprintf(gf_dump_strfd, "%s = ", key);
+    ret += strvprintf(gf_dump_strfd, value, ap);
+    ret += strprintf(gf_dump_strfd, "\n");
 
+    return ret;
+}
 
 int
-gf_proc_dump_write_strfd (char *key, char *value, va_list ap)
+gf_proc_dump_write(char *key, char *value, ...)
 {
-	int ret = 0;
+    int ret = 0;
+    va_list ap;
 
-	ret += strprintf (gf_dump_strfd, "%s = ", key);
-	ret += strvprintf (gf_dump_strfd, value, ap);
-	ret += strprintf (gf_dump_strfd, "\n");
+    va_start(ap, value);
+    if (gf_dump_strfd)
+        ret = gf_proc_dump_write_strfd(key, value, ap);
+    else
+        ret = gf_proc_dump_write_fd(key, value, ap);
+    va_end(ap);
 
-	return ret;
+    return ret;
 }
 
+void
+gf_latency_statedump_and_reset(char *key, gf_latency_t *lat)
+{
+    /* Doesn't make sense to continue if there are no fops
+       came in the given interval */
+    if (!lat || !lat->count)
+        return;
+    gf_proc_dump_write(key,
+                       "AVG:%lf CNT:%" PRIu64 " TOTAL:%" PRIu64 " MIN:%" PRIu64
+                       " MAX:%" PRIu64,
+                       (((double)lat->total) / lat->count), lat->count,
+                       lat->total, lat->min, lat->max);
+    gf_latency_reset(lat);
+}
 
-int
-gf_proc_dump_write (char *key, char *value, ...)
+void
+gf_proc_dump_xl_latency_info(xlator_t *xl)
 {
-	int ret = 0;
-	va_list ap;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i;
 
-	va_start (ap, value);
-	if (gf_dump_strfd)
-		ret = gf_proc_dump_write_strfd (key, value, ap);
-	else
-		ret = gf_proc_dump_write_fd (key, value, ap);
-	va_end (ap);
+    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.latency", xl->name);
+    gf_proc_dump_add_section("%s", key_prefix);
 
-	return ret;
-}
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        gf_proc_dump_build_key(key, key_prefix, "%s", (char *)gf_fop_list[i]);
 
+        gf_latency_t *lat = &xl->stats.interval.latencies[i];
+
+        gf_latency_statedump_and_reset(key, lat);
+    }
+}
 
 static void
-gf_proc_dump_xlator_mem_info (xlator_t *xl)
-{
-        int     i = 0;
-
-        if (!xl)
-                return;
-
-        if (!xl->mem_acct)
-                return;
-
-        gf_proc_dump_add_section ("%s.%s - Memory usage", xl->type, xl->name);
-        gf_proc_dump_write ("num_types", "%d", xl->mem_acct->num_types);
-
-        for (i = 0; i < xl->mem_acct->num_types; i++) {
-                if (xl->mem_acct->rec[i].num_allocs == 0)
-                        continue;
-
-                gf_proc_dump_add_section ("%s.%s - usage-type %s memusage",
-                                          xl->type, xl->name,
-                                          xl->mem_acct->rec[i].typestr);
-                gf_proc_dump_write ("size", "%u", xl->mem_acct->rec[i].size);
-                gf_proc_dump_write ("num_allocs", "%u",
-                                    xl->mem_acct->rec[i].num_allocs);
-                gf_proc_dump_write ("max_size", "%u",
-                                    xl->mem_acct->rec[i].max_size);
-                gf_proc_dump_write ("max_num_allocs", "%u",
-                                    xl->mem_acct->rec[i].max_num_allocs);
-                gf_proc_dump_write ("total_allocs", "%u",
-                                    xl->mem_acct->rec[i].total_allocs);
-        }
+gf_proc_dump_xlator_mem_info(xlator_t *xl)
+{
+    int i = 0;
 
+    if (!xl)
         return;
+
+    if (!xl->mem_acct)
+        return;
+
+    gf_proc_dump_add_section("%s.%s - Memory usage", xl->type, xl->name);
+    gf_proc_dump_write("num_types", "%d", xl->mem_acct->num_types);
+
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        if (xl->mem_acct->rec[i].num_allocs == 0)
+            continue;
+
+        gf_proc_dump_add_section("%s.%s - usage-type %s memusage", xl->type,
+                                 xl->name, xl->mem_acct->rec[i].typestr);
+        gf_proc_dump_write("size", "%" PRIu64, xl->mem_acct->rec[i].size);
+        gf_proc_dump_write("num_allocs", "%u", xl->mem_acct->rec[i].num_allocs);
+        gf_proc_dump_write("max_size", "%" PRIu64,
+                           xl->mem_acct->rec[i].max_size);
+        gf_proc_dump_write("max_num_allocs", "%u",
+                           xl->mem_acct->rec[i].max_num_allocs);
+        gf_proc_dump_write("total_allocs", "%" PRIu64,
+                           xl->mem_acct->rec[i].total_allocs);
+    }
+
+    return;
 }
 
 static void
-gf_proc_dump_xlator_mem_info_only_in_use (xlator_t *xl)
+gf_proc_dump_xlator_mem_info_only_in_use(xlator_t *xl)
 {
-        int     i = 0;
+    int i = 0;
 
-        if (!xl)
-                return;
+    if (!xl)
+        return;
 
-        if (!xl->mem_acct->rec)
-                return;
+    if (!xl->mem_acct)
+        return;
 
-        gf_proc_dump_add_section ("%s.%s - Memory usage", xl->type, xl->name);
-        gf_proc_dump_write ("num_types", "%d", xl->mem_acct->num_types);
+    gf_proc_dump_add_section("%s.%s - Memory usage", xl->type, xl->name);
+    gf_proc_dump_write("num_types", "%d", xl->mem_acct->num_types);
 
-        for (i = 0; i < xl->mem_acct->num_types; i++) {
-                if (!xl->mem_acct->rec[i].size)
-                        continue;
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        if (!xl->mem_acct->rec[i].size)
+            continue;
 
-                gf_proc_dump_add_section ("%s.%s - usage-type %d", xl->type,
-                                          xl->name,i);
+        gf_proc_dump_add_section("%s.%s - usage-type %d", xl->type, xl->name,
+                                 i);
 
-                gf_proc_dump_write ("size", "%u",
-                                    xl->mem_acct->rec[i].size);
-                gf_proc_dump_write ("max_size", "%u",
-                                    xl->mem_acct->rec[i].max_size);
-                gf_proc_dump_write ("num_allocs", "%u",
-                                    xl->mem_acct->rec[i].num_allocs);
-                gf_proc_dump_write ("max_num_allocs", "%u",
-                                    xl->mem_acct->rec[i].max_num_allocs);
-                gf_proc_dump_write ("total_allocs", "%u",
-                                    xl->mem_acct->rec[i].total_allocs);
-        }
+        gf_proc_dump_write("size", "%" PRIu64, xl->mem_acct->rec[i].size);
+        gf_proc_dump_write("max_size", "%" PRIu64,
+                           xl->mem_acct->rec[i].max_size);
+        gf_proc_dump_write("num_allocs", "%u", xl->mem_acct->rec[i].num_allocs);
+        gf_proc_dump_write("max_num_allocs", "%u",
+                           xl->mem_acct->rec[i].max_num_allocs);
+        gf_proc_dump_write("total_allocs", "%" PRIu64,
+                           xl->mem_acct->rec[i].total_allocs);
+    }
 
-        return;
+    return;
 }
 
-
-
 /* Currently this dumps only mallinfo. More can be built on here */
 void
-gf_proc_dump_mem_info ()
-{
-#ifdef HAVE_MALLOC_STATS
-        struct mallinfo info;
-
-        memset (&info, 0, sizeof (struct mallinfo));
-        info = mallinfo ();
-
-        gf_proc_dump_add_section ("mallinfo");
-        gf_proc_dump_write ("mallinfo_arena", "%d", info.arena);
-        gf_proc_dump_write ("mallinfo_ordblks", "%d", info.ordblks);
-        gf_proc_dump_write ("mallinfo_smblks", "%d", info.smblks);
-        gf_proc_dump_write ("mallinfo_hblks", "%d", info.hblks);
-        gf_proc_dump_write ("mallinfo_hblkhd", "%d", info.hblkhd);
-        gf_proc_dump_write ("mallinfo_usmblks", "%d", info.usmblks);
-        gf_proc_dump_write ("mallinfo_fsmblks", "%d", info.fsmblks);
-        gf_proc_dump_write ("mallinfo_uordblks", "%d", info.uordblks);
-        gf_proc_dump_write ("mallinfo_fordblks", "%d", info.fordblks);
-        gf_proc_dump_write ("mallinfo_keepcost", "%d", info.keepcost);
+gf_proc_dump_mem_info()
+{
+#ifdef HAVE_MALLINFO
+    struct mallinfo info;
+
+    memset(&info, 0, sizeof(struct mallinfo));
+    info = mallinfo();
+
+    gf_proc_dump_add_section("mallinfo");
+    gf_proc_dump_write("mallinfo_arena", "%d", info.arena);
+    gf_proc_dump_write("mallinfo_ordblks", "%d", info.ordblks);
+    gf_proc_dump_write("mallinfo_smblks", "%d", info.smblks);
+    gf_proc_dump_write("mallinfo_hblks", "%d", info.hblks);
+    gf_proc_dump_write("mallinfo_hblkhd", "%d", info.hblkhd);
+    gf_proc_dump_write("mallinfo_usmblks", "%d", info.usmblks);
+    gf_proc_dump_write("mallinfo_fsmblks", "%d", info.fsmblks);
+    gf_proc_dump_write("mallinfo_uordblks", "%d", info.uordblks);
+    gf_proc_dump_write("mallinfo_fordblks", "%d", info.fordblks);
+    gf_proc_dump_write("mallinfo_keepcost", "%d", info.keepcost);
 #endif
-        gf_proc_dump_xlator_mem_info(&global_xlator);
-
+    gf_proc_dump_xlator_mem_info(&global_xlator);
 }
 
 void
-gf_proc_dump_mem_info_to_dict (dict_t *dict)
+gf_proc_dump_mem_info_to_dict(dict_t *dict)
 {
-        if (!dict)
-                return;
-#ifdef HAVE_MALLOC_STATS
-        struct  mallinfo info;
-        int     ret = -1;
+    if (!dict)
+        return;
+#ifdef HAVE_MALLINFO
+    struct mallinfo info;
+    int ret = -1;
 
-        memset (&info, 0, sizeof(struct mallinfo));
-        info = mallinfo ();
+    memset(&info, 0, sizeof(struct mallinfo));
+    info = mallinfo();
 
-        ret = dict_set_int32 (dict, "mallinfo.arena", info.arena);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.arena", info.arena);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.ordblks", info.ordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.ordblks", info.ordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.smblks", info.smblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.smblks", info.smblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.hblks", info.hblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.hblks", info.hblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.hblkhd", info.hblkhd);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.hblkhd", info.hblkhd);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.usmblks", info.usmblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.usmblks", info.usmblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.fsmblks", info.fsmblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.fsmblks", info.fsmblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.uordblks", info.uordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.uordblks", info.uordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.fordblks", info.fordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.fordblks", info.fordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.keepcost", info.keepcost);
-        if (ret)
-                return;
-#endif
+    ret = dict_set_int32(dict, "mallinfo.keepcost", info.keepcost);
+    if (ret)
         return;
+#endif
+    return;
 }
 
 void
-gf_proc_dump_mempool_info (glusterfs_ctx_t *ctx)
-{
-#if defined(OLD_MEM_POOLS)
-        struct mem_pool *pool = NULL;
-
-        gf_proc_dump_add_section ("mempool");
-
-        list_for_each_entry (pool, &ctx->mempool_list, global_list) {
-                gf_proc_dump_write ("-----", "-----");
-                gf_proc_dump_write ("pool-name", "%s", pool->name);
-                gf_proc_dump_write ("hot-count", "%d", pool->hot_count);
-                gf_proc_dump_write ("cold-count", "%d", pool->cold_count);
-                gf_proc_dump_write ("padded_sizeof", "%lu",
-                                    pool->padded_sizeof_type);
-                gf_proc_dump_write ("alloc-count", "%"PRIu64, pool->alloc_count);
-                gf_proc_dump_write ("max-alloc", "%d", pool->max_alloc);
-
-                gf_proc_dump_write ("pool-misses", "%"PRIu64, pool->pool_misses);
-                gf_proc_dump_write ("cur-stdalloc", "%d", pool->curr_stdalloc);
-                gf_proc_dump_write ("max-stdalloc", "%d", pool->max_stdalloc);
+gf_proc_dump_mempool_info(glusterfs_ctx_t *ctx)
+{
+#ifdef GF_DISABLE_MEMPOOL
+    gf_proc_dump_write("built with --disable-mempool", " so no memory pools");
+#else
+    struct mem_pool *pool = NULL;
+
+    gf_proc_dump_add_section("mempool");
+
+    LOCK(&ctx->lock);
+    {
+        list_for_each_entry(pool, &ctx->mempool_list, owner)
+        {
+            int64_t active = GF_ATOMIC_GET(pool->active);
+
+            gf_proc_dump_write("-----", "-----");
+            gf_proc_dump_write("pool-name", "%s", pool->name);
+            gf_proc_dump_write("xlator-name", "%s", pool->xl_name);
+            gf_proc_dump_write("active-count", "%" GF_PRI_ATOMIC, active);
+            gf_proc_dump_write("sizeof-type", "%lu", pool->sizeof_type);
+            gf_proc_dump_write("padded-sizeof", "%d",
+                               1 << pool->pool->power_of_two);
+            gf_proc_dump_write("size", "%" PRId64,
+                               (1 << pool->pool->power_of_two) * active);
+            gf_proc_dump_write("shared-pool", "%p", pool->pool);
         }
-#endif
+    }
+    UNLOCK(&ctx->lock);
+#endif /* GF_DISABLE_MEMPOOL */
 }
 
 void
-gf_proc_dump_mempool_info_to_dict (glusterfs_ctx_t *ctx, dict_t *dict)
-{
-#if defined(OLD_MEM_POOLS)
-        struct mem_pool *pool = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             count = 0;
-        int             ret = -1;
-
-        if (!ctx || !dict)
-                return;
-
-        list_for_each_entry (pool, &ctx->mempool_list, global_list) {
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.name", count);
-                ret = dict_set_str (dict, key, pool->name);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.hotcount", count);
-                ret = dict_set_int32 (dict, key, pool->hot_count);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.coldcount", count);
-                ret = dict_set_int32 (dict, key, pool->cold_count);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.paddedsizeof", count);
-                ret = dict_set_uint64 (dict, key, pool->padded_sizeof_type);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.alloccount", count);
-                ret = dict_set_uint64 (dict, key, pool->alloc_count);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.max_alloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_alloc);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.max-stdalloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_stdalloc);
-                if (ret)
-                        return;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "pool%d.pool-misses", count);
-                ret = dict_set_uint64 (dict, key, pool->pool_misses);
-                if (ret)
-                        return;
-                count++;
+gf_proc_dump_mempool_info_to_dict(glusterfs_ctx_t *ctx, dict_t *dict)
+{
+#ifndef GF_DISABLE_MEMPOOL
+    struct mem_pool *pool = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int count = 0;
+    int ret = -1;
+
+    if (!ctx || !dict)
+        return;
+
+    LOCK(&ctx->lock);
+    {
+        list_for_each_entry(pool, &ctx->mempool_list, owner)
+        {
+            int64_t active = GF_ATOMIC_GET(pool->active);
+
+            snprintf(key, sizeof(key), "pool%d.name", count);
+            ret = dict_set_str(dict, key, pool->name);
+            if (ret)
+                goto out;
+
+            snprintf(key, sizeof(key), "pool%d.active-count", count);
+            ret = dict_set_uint64(dict, key, active);
+            if (ret)
+                goto out;
+
+            snprintf(key, sizeof(key), "pool%d.sizeof-type", count);
+            ret = dict_set_uint64(dict, key, pool->sizeof_type);
+            if (ret)
+                goto out;
+
+            snprintf(key, sizeof(key), "pool%d.padded-sizeof", count);
+            ret = dict_set_uint64(dict, key, 1 << pool->pool->power_of_two);
+            if (ret)
+                goto out;
+
+            snprintf(key, sizeof(key), "pool%d.size", count);
+            ret = dict_set_uint64(dict, key,
+                                  (1 << pool->pool->power_of_two) * active);
+            if (ret)
+                goto out;
+
+            snprintf(key, sizeof(key), "pool%d.shared-pool", count);
+            ret = dict_set_static_ptr(dict, key, pool->pool);
+            if (ret)
+                goto out;
         }
-        ret = dict_set_int32 (dict, "mempool-count", count);
-#endif
+    }
+out:
+    UNLOCK(&ctx->lock);
+#endif /* !GF_DISABLE_MEMPOOL */
 }
 
-void gf_proc_dump_latency_info (xlator_t *xl);
+void
+gf_proc_dump_latency_info(xlator_t *xl);
 
 void
-gf_proc_dump_dict_info (glusterfs_ctx_t *ctx)
+gf_proc_dump_dict_info(glusterfs_ctx_t *ctx)
 {
-        uint64_t total_dicts = 0;
-        uint64_t total_pairs = 0;
-
-        total_dicts = GF_ATOMIC_GET (ctx->stats.total_dicts_used);
-        total_pairs = GF_ATOMIC_GET (ctx->stats.total_pairs_used);
-
-        gf_proc_dump_write ("max-pairs-per-dict", "%u",
-                            GF_ATOMIC_GET (ctx->stats.max_dict_pairs));
-        gf_proc_dump_write ("total-pairs-used", "%lu", total_pairs);
-        gf_proc_dump_write ("total-dicts-used", "%lu", total_dicts);
-        gf_proc_dump_write ("average-pairs-per-dict", "%lu",
-                            (total_pairs / total_dicts));
+    int64_t total_dicts = 0;
+    int64_t total_pairs = 0;
+
+    total_dicts = GF_ATOMIC_GET(ctx->stats.total_dicts_used);
+    total_pairs = GF_ATOMIC_GET(ctx->stats.total_pairs_used);
+
+    gf_proc_dump_write("max-pairs-per-dict", "%" GF_PRI_ATOMIC,
+                       GF_ATOMIC_GET(ctx->stats.max_dict_pairs));
+    gf_proc_dump_write("total-pairs-used", "%" PRId64, total_pairs);
+    gf_proc_dump_write("total-dicts-used", "%" PRId64, total_dicts);
+    gf_proc_dump_write("average-pairs-per-dict", "%" PRId64,
+                       (total_pairs / total_dicts));
 }
 
-void
-gf_proc_dump_xlator_info (xlator_t *top)
+static void
+gf_proc_dump_single_xlator_info(xlator_t *trav)
 {
-        xlator_t        *trav = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-        char             itable_key[1024] = {0,};
+    glusterfs_ctx_t *ctx = trav->ctx;
+    char itable_key[1024] = {
+        0,
+    };
+
+    if (trav->cleanup_starting)
+        return;
 
-        if (!top)
-                return;
+    if (ctx->measure_latency)
+        gf_proc_dump_xl_latency_info(trav);
 
-        ctx = top->ctx;
+    gf_proc_dump_xlator_mem_info(trav);
 
-        trav = top;
-        while (trav) {
+    if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->itable)) {
+        snprintf(itable_key, sizeof(itable_key), "%d.%s.itable", ctx->graph_id,
+                 trav->name);
+    }
 
-                if (ctx->measure_latency)
-                        gf_proc_dump_latency_info (trav);
+    if (!trav->dumpops) {
+        return;
+    }
 
-                gf_proc_dump_xlator_mem_info(trav);
+    if (trav->dumpops->priv && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(priv))
+        trav->dumpops->priv(trav);
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->itable)) {
-                        snprintf (itable_key, 1024, "%d.%s.itable",
-                                  ctx->graph_id, trav->name);
-                }
+    if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->dumpops->inode))
+        trav->dumpops->inode(trav);
+    if (trav->dumpops->fd && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(fd))
+        trav->dumpops->fd(trav);
 
-                if (!trav->dumpops) {
-                        trav = trav->next;
-                        continue;
-                }
+    if (trav->dumpops->history && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(history))
+        trav->dumpops->history(trav);
+}
+
+static void
+gf_proc_dump_per_xlator_info(xlator_t *top)
+{
+    xlator_t *trav = top;
 
-                if (trav->dumpops->priv &&
-                    GF_PROC_DUMP_IS_XL_OPTION_ENABLED (priv))
-                        trav->dumpops->priv (trav);
+    while (trav && !trav->cleanup_starting) {
+        gf_proc_dump_single_xlator_info(trav);
+        trav = trav->next;
+    }
+}
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->dumpops->inode))
-                        trav->dumpops->inode (trav);
+void
+gf_proc_dump_xlator_info(xlator_t *top, gf_boolean_t brick_mux)
+{
+    xlator_t *trav = NULL;
+    xlator_list_t **trav_p = NULL;
 
-                if (trav->dumpops->fd &&
-                    GF_PROC_DUMP_IS_XL_OPTION_ENABLED (fd))
-                        trav->dumpops->fd (trav);
+    if (!top)
+        return;
 
-                if (trav->dumpops->history &&
-                    GF_PROC_DUMP_IS_XL_OPTION_ENABLED (history))
-                        trav->dumpops->history (trav);
+    trav = top;
+    gf_proc_dump_per_xlator_info(trav);
 
-                trav = trav->next;
+    if (brick_mux) {
+        trav_p = &top->children;
+        while (*trav_p) {
+            trav = (*trav_p)->xlator;
+            gf_proc_dump_per_xlator_info(trav);
+            trav_p = &(*trav_p)->next;
         }
+    }
 
-        return;
+    return;
 }
 
 static void
-gf_proc_dump_oldgraph_xlator_info (xlator_t *top)
+gf_proc_dump_oldgraph_xlator_info(xlator_t *top)
 {
-        xlator_t        *trav = NULL;
+    xlator_t *trav = NULL;
 
-        if (!top)
-                return;
+    if (!top)
+        return;
 
-        trav = top;
-        while (trav) {
-                gf_proc_dump_xlator_mem_info_only_in_use (trav);
+    trav = top;
+    while (trav) {
+        gf_proc_dump_xlator_mem_info_only_in_use(trav);
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->itable)) {
-                        /*TODO: dump inode table info if necessary by
-                          printing the graph id (taken by glusterfs_cbtx_t)
-                          in the key
-                        */
-                }
+        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->itable)) {
+            /*TODO: dump inode table info if necessary by
+              printing the graph id (taken by glusterfs_cbtx_t)
+              in the key
+            */
+        }
 
-                if (!trav->dumpops) {
-                        trav = trav->next;
-                        continue;
-                }
+        if (!trav->dumpops) {
+            trav = trav->next;
+            continue;
+        }
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->dumpops->inode))
-                        trav->dumpops->inode (trav);
+        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->dumpops->inode))
+            trav->dumpops->inode(trav);
 
-                if (trav->dumpops->fd &&
-                    GF_PROC_DUMP_IS_XL_OPTION_ENABLED (fd))
-                        trav->dumpops->fd (trav);
+        if (trav->dumpops->fd && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(fd))
+            trav->dumpops->fd(trav);
 
-                trav = trav->next;
-        }
+        trav = trav->next;
+    }
 
-        return;
+    return;
 }
 
 static int
-gf_proc_dump_enable_all_options ()
+gf_proc_dump_enable_all_options()
 {
-
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_iobuf, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_priv, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inode, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fd, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inodectx,
-                                 _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fdctx, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_history,
-                                 _gf_true);
-
-        return 0;
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_iobuf, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_priv, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inode, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fd, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inodectx, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fdctx, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_history, _gf_true);
+
+    return 0;
 }
 
 gf_boolean_t
-is_gf_proc_dump_all_disabled ()
-{
-        gf_boolean_t all_disabled = _gf_true;
-
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_mem, all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_iobuf, all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_callpool, all_disabled,
-                                   out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_priv,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_inode,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_fd,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_inodectx,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_fdctx,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_history,
-                                   all_disabled, out);
+is_gf_proc_dump_all_disabled()
+{
+    gf_boolean_t all_disabled = _gf_true;
+
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_mem, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_iobuf, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_callpool, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_priv,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_inode,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_fd, all_disabled,
+                                 out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_inodectx,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_fdctx,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_history,
+                                 all_disabled, out);
 
 out:
-        return all_disabled;
+    return all_disabled;
 }
 
 /* These options are dumped by default if glusterdump.options
    file exists and it is emtpty
 */
 static int
-gf_proc_dump_enable_default_options ()
+gf_proc_dump_enable_default_options()
 {
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_true);
 
-        return 0;
+    return 0;
 }
 
 static int
-gf_proc_dump_disable_all_options ()
-{
-
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_iobuf, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_priv, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inode,
-                                 _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fd, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inodectx,
-                                 _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fdctx, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_history,
-                                 _gf_false);
-        return 0;
+gf_proc_dump_disable_all_options()
+{
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_iobuf, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_priv, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inode, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fd, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inodectx, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fdctx, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_history, _gf_false);
+    return 0;
 }
 
 static int
-gf_proc_dump_parse_set_option (char *key, char *value)
-{
-        gf_boolean_t    *opt_key = NULL;
-        gf_boolean_t    opt_value = _gf_false;
-        char buf[GF_DUMP_MAX_BUF_LEN];
-        int ret = -1;
-
-        if (!strcasecmp (key, "all")) {
-                (void)gf_proc_dump_enable_all_options ();
-                return 0;
-        } else if (!strcasecmp (key, "mem")) {
-                opt_key = &dump_options.dump_mem;
-        } else if (!strcasecmp (key, "iobuf")) {
-                opt_key = &dump_options.dump_iobuf;
-        } else if (!strcasecmp (key, "callpool")) {
-                opt_key = &dump_options.dump_callpool;
-        } else if (!strcasecmp (key, "priv")) {
-                opt_key = &dump_options.xl_options.dump_priv;
-        } else if (!strcasecmp (key, "fd")) {
-                opt_key = &dump_options.xl_options.dump_fd;
-        } else if (!strcasecmp (key, "inode")) {
-                opt_key = &dump_options.xl_options.dump_inode;
-        } else if (!strcasecmp (key, "inodectx")) {
-                opt_key = &dump_options.xl_options.dump_inodectx;
-        } else if (!strcasecmp (key, "fdctx")) {
-                opt_key = &dump_options.xl_options.dump_fdctx;
-        } else if (!strcasecmp (key, "history")) {
-                opt_key = &dump_options.xl_options.dump_history;
-        }
-
-        if (!opt_key) {
-                //None of dump options match the key, return back
-                snprintf (buf, sizeof (buf), "[Warning]:None of the options "
-                          "matched key : %s\n", key);
-                ret = sys_write (gf_dump_fd, buf, strlen (buf));
-
-                if (ret >= 0)
-                        ret = -1;
-                goto out;
-
+gf_proc_dump_parse_set_option(char *key, char *value)
+{
+    gf_boolean_t *opt_key = NULL;
+    gf_boolean_t opt_value = _gf_false;
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int ret = -1;
+    int len;
+
+    if (!strcasecmp(key, "all")) {
+        (void)gf_proc_dump_enable_all_options();
+        return 0;
+    } else if (!strcasecmp(key, "mem")) {
+        opt_key = &dump_options.dump_mem;
+    } else if (!strcasecmp(key, "iobuf")) {
+        opt_key = &dump_options.dump_iobuf;
+    } else if (!strcasecmp(key, "callpool")) {
+        opt_key = &dump_options.dump_callpool;
+    } else if (!strcasecmp(key, "priv")) {
+        opt_key = &dump_options.xl_options.dump_priv;
+    } else if (!strcasecmp(key, "fd")) {
+        opt_key = &dump_options.xl_options.dump_fd;
+    } else if (!strcasecmp(key, "inode")) {
+        opt_key = &dump_options.xl_options.dump_inode;
+    } else if (!strcasecmp(key, "inodectx")) {
+        opt_key = &dump_options.xl_options.dump_inodectx;
+    } else if (!strcasecmp(key, "fdctx")) {
+        opt_key = &dump_options.xl_options.dump_fdctx;
+    } else if (!strcasecmp(key, "history")) {
+        opt_key = &dump_options.xl_options.dump_history;
+    }
+
+    if (!opt_key) {
+        // None of dump options match the key, return back
+        len = snprintf(buf, sizeof(buf),
+                       "[Warning]:None of the options "
+                       "matched key : %s\n",
+                       key);
+        if (len < 0)
+            ret = -1;
+        else {
+            ret = sys_write(gf_dump_fd, buf, len);
+            if (ret >= 0)
+                ret = -1;
         }
+        goto out;
+    }
 
-        opt_value = (strncasecmp (value, "yes", 3) ?
-                     _gf_false: _gf_true);
+    opt_value = (strncasecmp(value, "yes", 3) ? _gf_false : _gf_true);
 
-        GF_PROC_DUMP_SET_OPTION (*opt_key, opt_value);
+    GF_PROC_DUMP_SET_OPTION(*opt_key, opt_value);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_proc_dump_options_init ()
-{
-        int     ret = -1;
-        FILE    *fp = NULL;
-        char    buf[256];
-        char    *key = NULL, *value = NULL;
-        char    *saveptr = NULL;
-        char    dump_option_file[PATH_MAX];
-
-        /* glusterd will create a file glusterdump.<pid>.options and
-           sets the statedump options for the process and the file is removed
-           after the statedump is taken. Direct issue of SIGUSR1 does not have
-           mechanism for considering the statedump options. So to have a way
-           of configuring the statedump of all the glusterfs processes through
-           both cli command and SIGUSR1, glusterdump.options file is searched
-           and the options mentioned in it are given the higher priority.
-        */
-        snprintf (dump_option_file, sizeof (dump_option_file),
-                  DEFAULT_VAR_RUN_DIRECTORY
-                  "/glusterdump.options");
-        fp = fopen (dump_option_file, "r");
-        if (!fp) {
-                snprintf (dump_option_file, sizeof (dump_option_file),
-                          DEFAULT_VAR_RUN_DIRECTORY
-                          "/glusterdump.%d.options", getpid ());
-
-                fp = fopen (dump_option_file, "r");
-
-                if (!fp) {
-                        //ENOENT, return success
-                        (void) gf_proc_dump_enable_all_options ();
-                        return 0;
-                }
-        }
-
-        (void) gf_proc_dump_disable_all_options ();
-
-        // swallow the errors if setting statedump file path is failed.
-        ret = gf_proc_dump_set_path (dump_option_file);
-
-        ret = fscanf (fp, "%s", buf);
-
-        while (ret != EOF) {
-                key = strtok_r (buf, "=", &saveptr);
-                if (!key) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-
-                value = strtok_r (NULL, "=", &saveptr);
-
-                if (!value) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-
-                gf_proc_dump_parse_set_option (key, value);
-        }
-
-        if (is_gf_proc_dump_all_disabled ())
-                (void) gf_proc_dump_enable_default_options ();
-
-        if (fp)
-                fclose (fp);
-
-        return 0;
-}
-
-void
-gf_proc_dump_info (int signum, glusterfs_ctx_t *ctx)
+gf_proc_dump_options_init()
 {
-        int                i                       = 0;
-        int                ret                     = -1;
-        glusterfs_graph_t *trav                    = NULL;
-        char               brick_name[PATH_MAX]    = {0,};
-        char               timestr[256]            = {0,};
-        char               sign_string[512]        = {0,};
-        char               tmp_dump_name[PATH_MAX] = {0,};
-        char               path[PATH_MAX]          = {0,};
-        struct timeval     tv                      = {0,};
-
-        gf_proc_dump_lock ();
+    int ret = -1;
+    FILE *fp = NULL;
+    char buf[256];
+    char *key = NULL, *value = NULL;
+    char *saveptr = NULL;
+    char dump_option_file[PATH_MAX];
+
+    /* glusterd will create a file glusterdump.<pid>.options and
+       sets the statedump options for the process and the file is removed
+       after the statedump is taken. Direct issue of SIGUSR1 does not have
+       mechanism for considering the statedump options. So to have a way
+       of configuring the statedump of all the glusterfs processes through
+       both cli command and SIGUSR1, glusterdump.options file is searched
+       and the options mentioned in it are given the higher priority.
+    */
+    snprintf(dump_option_file, sizeof(dump_option_file),
+             DEFAULT_VAR_RUN_DIRECTORY "/glusterdump.options");
+    fp = fopen(dump_option_file, "r");
+    if (!fp) {
+        snprintf(dump_option_file, sizeof(dump_option_file),
+                 DEFAULT_VAR_RUN_DIRECTORY "/glusterdump.%d.options", getpid());
+
+        fp = fopen(dump_option_file, "r");
 
-        if (!ctx)
-                goto out;
-
-        if (ctx->cmd_args.brick_name) {
-                GF_REMOVE_SLASH_FROM_PATH (ctx->cmd_args.brick_name, brick_name);
-        } else
-                strncpy (brick_name, "glusterdump", sizeof (brick_name));
-
-        ret = gf_proc_dump_options_init ();
-        if (ret < 0)
-                goto out;
-
-        snprintf (path, sizeof (path), "%s/%s.%d.dump.%"PRIu64,
-                  ((dump_options.dump_path != NULL)?dump_options.dump_path:
-                   ((ctx->statedump_path != NULL)?ctx->statedump_path:
-                    DEFAULT_VAR_RUN_DIRECTORY)), brick_name, getpid(),
-                  (uint64_t) time (NULL));
-
-        snprintf (tmp_dump_name, PATH_MAX, "%s/dumpXXXXXX",
-                  ((dump_options.dump_path != NULL)?dump_options.dump_path:
-                   ((ctx->statedump_path != NULL)?ctx->statedump_path:
-                    DEFAULT_VAR_RUN_DIRECTORY)));
-
-        ret = gf_proc_dump_open (tmp_dump_name);
-        if (ret < 0)
-                goto out;
-
-        //continue even though gettimeofday() has failed
-        ret = gettimeofday (&tv, NULL);
-        if (0 == ret) {
-                gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
+        if (!fp) {
+            // ENOENT, return success
+            (void)gf_proc_dump_enable_all_options();
+            return 0;
         }
+    }
 
-        snprintf (sign_string, sizeof (sign_string), "DUMP-START-TIME: %s\n",
-                  timestr);
+    (void)gf_proc_dump_disable_all_options();
 
-        //swallow the errors of write for start and end marker
-        ret = sys_write (gf_dump_fd, sign_string, strlen (sign_string));
+    // swallow the errors if setting statedump file path is failed.
+    (void)gf_proc_dump_set_path(dump_option_file);
 
-        memset (sign_string, 0, sizeof (sign_string));
-        memset (timestr, 0, sizeof (timestr));
-        memset (&tv, 0, sizeof (tv));
+    ret = fscanf(fp, "%255s", buf);
 
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (mem)) {
-                gf_proc_dump_mem_info ();
-                gf_proc_dump_mempool_info (ctx);
+    while (ret != EOF) {
+        key = strtok_r(buf, "=", &saveptr);
+        if (!key) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
         }
 
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (iobuf))
-                iobuf_stats_dump (ctx->iobuf_pool);
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (callpool))
-                gf_proc_dump_pending_frames (ctx->pool);
+        value = strtok_r(NULL, "=", &saveptr);
 
-        /* dictionary stats */
-        gf_proc_dump_add_section ("dict");
-        gf_proc_dump_dict_info (ctx);
-
-        if (ctx->master) {
-                gf_proc_dump_add_section ("fuse");
-                gf_proc_dump_xlator_info (ctx->master);
+        if (!value) {
+            ret = fscanf(fp, "%255s", buf);
+            continue;
         }
 
-        if (ctx->active) {
-                gf_proc_dump_add_section ("active graph - %d", ctx->graph_id);
-                gf_proc_dump_xlator_info (ctx->active->top);
-        }
+        gf_proc_dump_parse_set_option(key, value);
+    }
 
-        i = 0;
-        list_for_each_entry (trav, &ctx->graphs, list) {
-                if (trav == ctx->active)
-                        continue;
+    if (is_gf_proc_dump_all_disabled())
+        (void)gf_proc_dump_enable_default_options();
 
-                gf_proc_dump_add_section ("oldgraph[%d]", i);
+    if (fp)
+        fclose(fp);
 
-                gf_proc_dump_oldgraph_xlator_info (trav->top);
-                i++;
-        }
+    return 0;
+}
 
-        ret = gettimeofday (&tv, NULL);
-        if (0 == ret) {
-                gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
+void
+gf_proc_dump_info(int signum, glusterfs_ctx_t *ctx)
+{
+    int i = 0;
+    int ret = -1;
+    glusterfs_graph_t *trav = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    char sign_string[512] = {
+        0,
+    };
+    char tmp_dump_name[PATH_MAX] = {
+        0,
+    };
+    char path[PATH_MAX] = {
+        0,
+    };
+    struct timeval tv = {
+        0,
+    };
+    gf_boolean_t is_brick_mux = _gf_false;
+    xlator_t *top = NULL;
+    xlator_list_t **trav_p = NULL;
+    int brick_count = 0;
+    int len = 0;
+
+    gf_msg_trace("dump", 0, "received statedump request (sig:USR1)");
+
+    if (!ctx)
+        goto out;
+
+    /*
+     * Multiplexed daemons can change the active graph when attach/detach
+     * is called. So this has to be protected with the cleanup lock.
+     */
+    if (mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name))
+        pthread_mutex_lock(&ctx->cleanup_lock);
+    gf_proc_dump_lock();
+
+    if (!mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name) &&
+        (ctx && ctx->active)) {
+        top = ctx->active->first;
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            brick_count++;
         }
 
-        snprintf (sign_string, sizeof (sign_string), "\nDUMP-END-TIME: %s",
-                  timestr);
-        ret = sys_write (gf_dump_fd, sign_string, strlen (sign_string));
-
+        if (brick_count > 1)
+            is_brick_mux = _gf_true;
+    }
+
+    if (ctx->cmd_args.brick_name) {
+        GF_REMOVE_SLASH_FROM_PATH(ctx->cmd_args.brick_name, brick_name);
+    } else
+        snprintf(brick_name, sizeof(brick_name), "glusterdump");
+
+    ret = gf_proc_dump_options_init();
+    if (ret < 0)
+        goto out;
+
+    ret = snprintf(
+        path, sizeof(path), "%s/%s.%d.dump.%" PRIu64,
+        ((dump_options.dump_path != NULL)
+             ? dump_options.dump_path
+             : ((ctx->statedump_path != NULL) ? ctx->statedump_path
+                                              : DEFAULT_VAR_RUN_DIRECTORY)),
+        brick_name, getpid(), (uint64_t)gf_time());
+    if ((ret < 0) || (ret >= sizeof(path))) {
+        goto out;
+    }
+
+    snprintf(
+        tmp_dump_name, PATH_MAX, "%s/dumpXXXXXX",
+        ((dump_options.dump_path != NULL)
+             ? dump_options.dump_path
+             : ((ctx->statedump_path != NULL) ? ctx->statedump_path
+                                              : DEFAULT_VAR_RUN_DIRECTORY)));
+
+    ret = gf_proc_dump_open(tmp_dump_name);
+    if (ret < 0)
+        goto out;
+
+    // continue even though gettimeofday() has failed
+    ret = gettimeofday(&tv, NULL);
+    if (0 == ret) {
+        gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+    }
+
+    len = snprintf(sign_string, sizeof(sign_string), "DUMP-START-TIME: %s\n",
+                   timestr);
+
+    // swallow the errors of write for start and end marker
+    (void)sys_write(gf_dump_fd, sign_string, len);
+
+    memset(timestr, 0, sizeof(timestr));
+
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(mem)) {
+        gf_proc_dump_mem_info();
+        gf_proc_dump_mempool_info(ctx);
+    }
+
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(iobuf))
+        iobuf_stats_dump(ctx->iobuf_pool);
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(callpool))
+        gf_proc_dump_pending_frames(ctx->pool);
+
+    /* dictionary stats */
+    gf_proc_dump_add_section("dict");
+    gf_proc_dump_dict_info(ctx);
+
+    if (ctx->master) {
+        gf_proc_dump_add_section("fuse");
+        gf_proc_dump_single_xlator_info(ctx->master);
+    }
+
+    if (ctx->active) {
+        gf_proc_dump_add_section("active graph - %d", ctx->graph_id);
+        gf_proc_dump_xlator_info(ctx->active->top, is_brick_mux);
+    }
+
+    i = 0;
+    list_for_each_entry(trav, &ctx->graphs, list)
+    {
+        if (trav == ctx->active)
+            continue;
+
+        gf_proc_dump_add_section("oldgraph[%d]", i);
+
+        gf_proc_dump_oldgraph_xlator_info(trav->top);
+        i++;
+    }
+
+    ret = gettimeofday(&tv, NULL);
+    if (0 == ret) {
+        gf_time_fmt_tv(timestr, sizeof timestr, &tv, gf_timefmt_FT);
+    }
+
+    len = snprintf(sign_string, sizeof(sign_string), "\nDUMP-END-TIME: %s",
+                   timestr);
+    (void)sys_write(gf_dump_fd, sign_string, len);
+
+    if (gf_dump_fd != -1)
+        gf_proc_dump_close();
+    sys_rename(tmp_dump_name, path);
 out:
-        if (gf_dump_fd != -1)
-                gf_proc_dump_close ();
-        sys_rename (tmp_dump_name, path);
-        GF_FREE (dump_options.dump_path);
-        dump_options.dump_path = NULL;
-        gf_proc_dump_unlock ();
-
-        return;
+    GF_FREE(dump_options.dump_path);
+    dump_options.dump_path = NULL;
+    if (ctx) {
+        gf_proc_dump_unlock();
+        if (mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name))
+            pthread_mutex_unlock(&ctx->cleanup_lock);
+    }
+
+    return;
 }
 
-
 void
-gf_proc_dump_fini (void)
+gf_proc_dump_fini(void)
 {
-        pthread_mutex_destroy (&gf_proc_dump_mutex);
+    pthread_mutex_destroy(&gf_proc_dump_mutex);
 }
 
-
 void
-gf_proc_dump_init ()
+gf_proc_dump_init()
 {
-        pthread_mutex_init (&gf_proc_dump_mutex, NULL);
+    pthread_mutex_init(&gf_proc_dump_mutex, NULL);
 
-        return;
+    return;
 }
 
-
 void
-gf_proc_dump_cleanup (void)
+gf_proc_dump_cleanup(void)
 {
-        pthread_mutex_destroy (&gf_proc_dump_mutex);
+    pthread_mutex_destroy(&gf_proc_dump_mutex);
 }
 
-
 void
-gf_proc_dump_xlator_private (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_private(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		if (this->dumpops && this->dumpops->priv)
-			this->dumpops->priv (this);
+        if (this->dumpops && this->dumpops->priv)
+            this->dumpops->priv(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_mallinfo (strfd_t *strfd)
+gf_proc_dump_mallinfo(strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_mem_info ();
+        gf_proc_dump_mem_info();
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_history (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_history(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		if (this->dumpops && this->dumpops->history)
-			this->dumpops->history (this);
+        if (this->dumpops && this->dumpops->history)
+            this->dumpops->history(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_itable (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_itable(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
-
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_meminfo (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_meminfo(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_xlator_mem_info (this);
+        gf_proc_dump_xlator_mem_info(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_profile (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_profile(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_latency_info (this);
+        gf_proc_dump_xl_latency_info(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
diff --git a/libglusterfs/src/statedump.h b/libglusterfs/src/statedump.h
deleted file mode 100644
index 0a7a97e10d4..00000000000
--- a/libglusterfs/src/statedump.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-
-#ifndef STATEDUMP_H
-#define STATEDUMP_H
-
-#include <stdarg.h>
-#include "inode.h"
-#include "strfd.h"
-
-#define GF_DUMP_MAX_BUF_LEN 4096
-
-typedef struct gf_dump_xl_options_ {
-        gf_boolean_t    dump_priv;
-        gf_boolean_t    dump_inode;
-        gf_boolean_t    dump_fd;
-        gf_boolean_t    dump_inodectx;
-        gf_boolean_t    dump_fdctx;
-        gf_boolean_t    dump_history;
-} gf_dump_xl_options_t;
-
-typedef struct gf_dump_options_ {
-        gf_boolean_t            dump_mem;
-        gf_boolean_t            dump_iobuf;
-        gf_boolean_t            dump_callpool;
-        gf_dump_xl_options_t    xl_options; //options for all xlators
-        char                    *dump_path;
-} gf_dump_options_t;
-
-extern gf_dump_options_t dump_options;
-
-__attribute__ ((__format__ (__printf__, 3, 4)))
-static inline void
-_gf_proc_dump_build_key (char *key, const char *prefix, const char *fmt, ...)
-{
-        char buf[GF_DUMP_MAX_BUF_LEN] = { 0, };
-        va_list ap;
-
-        va_start(ap, fmt);
-        vsnprintf(buf, GF_DUMP_MAX_BUF_LEN, fmt, ap);
-        va_end(ap);
-        snprintf(key, GF_DUMP_MAX_BUF_LEN, "%s.%s", prefix, buf);
-}
-
-#define gf_proc_dump_build_key(key, key_prefix, fmt...)                 \
-        {                                                               \
-                _gf_proc_dump_build_key(key, key_prefix, ##fmt);        \
-        }
-
-#define GF_PROC_DUMP_SET_OPTION(opt,val) opt = val
-
-#define GF_CHECK_DUMP_OPTION_ENABLED(option_dump, var, label)      \
-        do {                                                    \
-                if (option_dump == _gf_true) {                  \
-                        var = _gf_false;                        \
-                        goto label;                             \
-                }                                               \
-        } while (0);
-
-void gf_proc_dump_init();
-
-void gf_proc_dump_fini(void);
-
-void gf_proc_dump_cleanup(void);
-
-void gf_proc_dump_info(int signum, glusterfs_ctx_t *ctx);
-
-int gf_proc_dump_add_section(char *key,...);
-
-int gf_proc_dump_write(char *key, char *value,...);
-
-void inode_table_dump(inode_table_t *itable, char *prefix);
-
-void inode_table_dump_to_dict (inode_table_t *itable, char *prefix, dict_t *dict);
-
-void fdtable_dump(fdtable_t *fdtable, char *prefix);
-
-void fdtable_dump_to_dict (fdtable_t *fdtable, char *prefix, dict_t *dict);
-
-void inode_dump(inode_t *inode, char *prefix);
-
-void gf_proc_dump_mem_info_to_dict (dict_t *dict);
-
-void gf_proc_dump_mempool_info_to_dict (glusterfs_ctx_t *ctx, dict_t *dict);
-
-void glusterd_init (int sig);
-
-void gf_proc_dump_xlator_private (xlator_t *this, strfd_t *strfd);
-
-void gf_proc_dump_mallinfo (strfd_t *strfd);
-
-void gf_proc_dump_xlator_history (xlator_t *this, strfd_t *strfd);
-
-void gf_proc_dump_xlator_meminfo (xlator_t *this, strfd_t *strfd);
-
-void gf_proc_dump_xlator_profile (xlator_t *this, strfd_t *strfd);
-
-#endif /* STATEDUMP_H */
diff --git a/libglusterfs/src/store.c b/libglusterfs/src/store.c
index e805f20bb4c..5c316b9291a 100644
--- a/libglusterfs/src/store.c
+++ b/libglusterfs/src/store.c
@@ -11,726 +11,734 @@
 #include <inttypes.h>
 #include <libgen.h>
 
-#include "glusterfs.h"
-#include "store.h"
-#include "dict.h"
-#include "xlator.h"
-#include "syscall.h"
-#include "libglusterfs-messages.h"
-
+#include "glusterfs/glusterfs.h"
+#include "glusterfs/store.h"
+#include "glusterfs/xlator.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 int32_t
-gf_store_mkdir (char *path)
+gf_store_mkdir(char *path)
 {
-        int32_t     ret = -1;
+    int32_t ret = -1;
 
-        ret = mkdir_p (path, 0777, _gf_true);
+    ret = mkdir_p(path, 0755, _gf_true);
 
-        if ((-1 == ret) && (EEXIST != errno)) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "mkdir()"
-                        " failed on path %s.", path);
-        } else {
-                ret = 0;
-        }
+    if ((-1 == ret) && (EEXIST != errno)) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "mkdir()"
+               " failed on path %s.",
+               path);
+    } else {
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_handle_create_on_absence (gf_store_handle_t **shandle,
-                                   char *path)
+gf_store_handle_create_on_absence(gf_store_handle_t **shandle, char *path)
 {
-        GF_ASSERT (shandle);
-        int32_t     ret = 0;
+    GF_ASSERT(shandle);
+    int32_t ret = 0;
 
-        if (*shandle == NULL) {
-                ret = gf_store_handle_new (path, shandle);
+    if (*shandle == NULL) {
+        ret = gf_store_handle_new(path, shandle);
 
-                if (ret) {
-                        gf_msg ("", GF_LOG_ERROR, 0,
-                                LG_MSG_STORE_HANDLE_CREATE_FAILED, "Unable to"
-                                " create store handle for path: %s", path);
-                }
+        if (ret) {
+            gf_msg("", GF_LOG_ERROR, 0, LG_MSG_STORE_HANDLE_CREATE_FAILED,
+                   "Unable to"
+                   " create store handle for path: %s",
+                   path);
         }
-        return ret;
+    }
+    return ret;
 }
 
 int32_t
-gf_store_mkstemp (gf_store_handle_t *shandle)
+gf_store_mkstemp(gf_store_handle_t *shandle)
 {
-        char    tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        shandle->tmp_fd = open (tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600);
-        if (shandle->tmp_fd < 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open %s.", tmppath);
-        }
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    shandle->tmp_fd = open(tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    if (shandle->tmp_fd < 0) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open %s.", tmppath);
+    }
 out:
-        return shandle->tmp_fd;
+    return shandle->tmp_fd;
 }
 
 int
-gf_store_sync_direntry (char *path)
+gf_store_sync_direntry(char *path)
 {
-        int             ret     = -1;
-        int             dirfd   = -1;
-        char            *dir    = NULL;
-        char            *pdir   = NULL;
-        xlator_t        *this = NULL;
-
-        this = THIS;
-
-        dir = gf_strdup (path);
-        if (!dir)
-                goto out;
-
-        pdir = dirname (dir);
-        dirfd = open (pdir, O_RDONLY);
-        if (dirfd == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-                        "Failed to open directory %s.", pdir);
-                goto out;
-        }
-
-        ret = sys_fsync (dirfd);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "Failed to fsync %s.", pdir);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    int dirfd = -1;
+    char *dir = NULL;
+    char *pdir = NULL;
+    xlator_t *this = NULL;
+
+    this = THIS;
+
+    dir = gf_strdup(path);
+    if (!dir)
+        goto out;
+
+    pdir = dirname(dir);
+    dirfd = open(pdir, O_RDONLY);
+    if (dirfd == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "Failed to open directory %s.", pdir);
+        goto out;
+    }
+
+    ret = sys_fsync(dirfd);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "Failed to fsync %s.", pdir);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (dirfd >= 0) {
-                ret = sys_close (dirfd);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                LG_MSG_DIR_OP_FAILED, "Failed to close %s", pdir);
-                }
+    if (dirfd >= 0) {
+        ret = sys_close(dirfd);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                   "Failed to close %s", pdir);
         }
+    }
 
-        if (dir)
-                GF_FREE (dir);
+    if (dir)
+        GF_FREE(dir);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_rename_tmppath (gf_store_handle_t *shandle)
+gf_store_rename_tmppath(gf_store_handle_t *shandle)
 {
-        int32_t         ret = -1;
-        char            tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        ret = sys_fsync (shandle->tmp_fd);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to fsync %s", shandle->path);
-                goto out;
-        }
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        ret = sys_rename (tmppath, shandle->path);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to rename %s to %s", tmppath,
-                        shandle->path);
-                goto out;
-        }
-
-        ret = gf_store_sync_direntry (tmppath);
+    int32_t ret = -1;
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    ret = sys_fsync(shandle->tmp_fd);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to fsync %s", shandle->path);
+        goto out;
+    }
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    ret = sys_rename(tmppath, shandle->path);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to rename %s to %s", tmppath, shandle->path);
+        goto out;
+    }
+
+    ret = gf_store_sync_direntry(tmppath);
 out:
-        if (shandle && shandle->tmp_fd >= 0) {
-                sys_close (shandle->tmp_fd);
-                shandle->tmp_fd = -1;
-        }
-        return ret;
+    if (shandle && shandle->tmp_fd >= 0) {
+        sys_close(shandle->tmp_fd);
+        shandle->tmp_fd = -1;
+    }
+    return ret;
 }
 
 int32_t
-gf_store_unlink_tmppath (gf_store_handle_t *shandle)
+gf_store_unlink_tmppath(gf_store_handle_t *shandle)
 {
-        int32_t         ret = -1;
-        char            tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        ret = sys_unlink (tmppath);
-        if (ret && (errno != ENOENT)) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to mv %s to %s", tmppath,
-                        shandle->path);
-        } else {
-                ret = 0;
-        }
+    int32_t ret = -1;
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    ret = sys_unlink(tmppath);
+    if (ret && (errno != ENOENT)) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to mv %s to %s", tmppath, shandle->path);
+    } else {
+        ret = 0;
+    }
 out:
-        if (shandle && shandle->tmp_fd >= 0) {
-                sys_close (shandle->tmp_fd);
-                shandle->tmp_fd = -1;
-        }
-        return ret;
+    if (shandle && shandle->tmp_fd >= 0) {
+        sys_close(shandle->tmp_fd);
+        shandle->tmp_fd = -1;
+    }
+    return ret;
 }
 
 int
-gf_store_read_and_tokenize (FILE *file, char *str, int size, char **iter_key,
-                            char **iter_val, gf_store_op_errno_t *store_errno)
+gf_store_read_and_tokenize(FILE *file, char **iter_key, char **iter_val,
+                           gf_store_op_errno_t *store_errno)
 {
-        int32_t     ret         =   -1;
-        char        *savetok    = NULL;
-        char        *key        = NULL;
-        char        *value      = NULL;
-        char        *temp       = NULL;
-        size_t       str_len    =    0;
-
-        GF_ASSERT (file);
-        GF_ASSERT (str);
-        GF_ASSERT (iter_key);
-        GF_ASSERT (iter_val);
-        GF_ASSERT (store_errno);
+    int32_t ret = -1;
+    char *savetok = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char *temp = NULL;
+    size_t str_len = 0;
+    char str[8192];
+
+    GF_ASSERT(file);
+    GF_ASSERT(iter_key);
+    GF_ASSERT(iter_val);
+    GF_ASSERT(store_errno);
 
 retry:
-        temp = fgets (str, size, file);
-        if (temp == NULL || feof (file)) {
-                ret = -1;
-                *store_errno = GD_STORE_EOF;
-                goto out;
-        }
-
-        if (strcmp (str, "\n") == 0)
-                goto retry;
-
-        str_len = strlen(str);
-        str[str_len - 1] = '\0';
-        /* Truncate the "\n", as fgets stores "\n" in str */
-
-        key = strtok_r (str, "=", &savetok);
-        if (!key) {
-                ret = -1;
-                *store_errno = GD_STORE_KEY_NULL;
-                goto out;
-        }
-
-        value = strtok_r (NULL, "", &savetok);
-        if (!value) {
-                ret = -1;
-                *store_errno = GD_STORE_VALUE_NULL;
-                goto out;
-        }
-
-        *iter_key = key;
-        *iter_val = value;
-        *store_errno = GD_STORE_SUCCESS;
-        ret = 0;
+    temp = fgets(str, 8192, file);
+    if (temp == NULL || feof(file)) {
+        ret = -1;
+        *store_errno = GD_STORE_EOF;
+        goto out;
+    }
+
+    if (strcmp(str, "\n") == 0)
+        goto retry;
+
+    str_len = strlen(str);
+    str[str_len - 1] = '\0';
+    /* Truncate the "\n", as fgets stores "\n" in str */
+
+    key = strtok_r(str, "=", &savetok);
+    if (!key) {
+        ret = -1;
+        *store_errno = GD_STORE_KEY_NULL;
+        goto out;
+    }
+
+    value = strtok_r(NULL, "", &savetok);
+    if (!value) {
+        ret = -1;
+        *store_errno = GD_STORE_VALUE_NULL;
+        goto out;
+    }
+
+    *iter_key = key;
+    *iter_val = value;
+    *store_errno = GD_STORE_SUCCESS;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
+gf_store_retrieve_value(gf_store_handle_t *handle, char *key, char **value)
 {
-        int32_t         ret = -1;
-        char            *scan_str = NULL;
-        char            *iter_key = NULL;
-        char            *iter_val = NULL;
-        char            *free_str = NULL;
-        struct stat     st        = {0,};
-        gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
-
-        GF_ASSERT (handle);
-
-        if (handle->locked == F_ULOCK)
-                /* no locking is used handle->fd gets closed() after usage */
-                handle->fd = open (handle->path, O_RDWR);
-        else
-                /* handle->fd is valid already, kept open for lockf() */
-                sys_lseek (handle->fd, 0, SEEK_SET);
-
-        if (handle->fd == -1) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to open file %s", handle->path);
-                goto out;
-        }
-        if (!handle->read)
-                handle->read = fdopen (dup(handle->fd), "r");
-        else
-                fseek (handle->read, 0, SEEK_SET);
-
+    int32_t ret = -1;
+    char *iter_key = NULL;
+    char *iter_val = NULL;
+    gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
+
+    GF_ASSERT(handle);
+
+    if (handle->locked == F_ULOCK)
+        /* no locking is used handle->fd gets closed() after usage */
+        handle->fd = open(handle->path, O_RDWR);
+    else
+        /* handle->fd is valid already, kept open for lockf() */
+        sys_lseek(handle->fd, 0, SEEK_SET);
+
+    if (handle->fd == -1) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to open file %s", handle->path);
+        goto out;
+    }
+    if (!handle->read) {
+        int duped_fd = dup(handle->fd);
+
+        if (duped_fd >= 0)
+            handle->read = fdopen(duped_fd, "r");
         if (!handle->read) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to open file %s", handle->path);
-                goto out;
-        }
-
-        ret = sys_fstat (handle->fd, &st);
+            if (duped_fd != -1)
+                sys_close(duped_fd);
+            gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                   "Unable to open file %s", handle->path);
+            goto out;
+        }
+    } else {
+        fseek(handle->read, 0, SEEK_SET);
+    }
+    do {
+        ret = gf_store_read_and_tokenize(handle->read, &iter_key, &iter_val,
+                                         &store_errno);
         if (ret < 0) {
-                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "stat on file %s failed", handle->path);
-                ret = -1;
-                store_errno = GD_STORE_STAT_FAILED;
-                goto out;
-        }
-
-        /* "st.st_size + 1" is used as we are fetching each
-         * line of a file using fgets, fgets will append "\0"
-         * to the end of the string
-         */
-        scan_str = GF_CALLOC (1, st.st_size + 1,
-                              gf_common_mt_char);
-
-        if (scan_str == NULL) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
+            gf_msg_trace("", 0,
+                         "error while reading key '%s': "
+                         "%s",
+                         key, gf_store_strerror(store_errno));
+            goto out;
         }
 
-        free_str = scan_str;
-
-        do {
-                ret = gf_store_read_and_tokenize (handle->read, scan_str,
-                                                  st.st_size + 1,
-                                                  &iter_key, &iter_val,
-                                                  &store_errno);
-                if (ret < 0) {
-                        gf_msg_trace ("", 0, "error while reading key '%s': "
-                                      "%s", key,
-                                      gf_store_strerror (store_errno));
-                        goto out;
-                }
-
-                gf_msg_trace ("", 0, "key %s read", iter_key);
-
-                if (!strcmp (key, iter_key)) {
-                        gf_msg_debug ("", 0, "key %s found", key);
-                        ret = 0;
-                        if (iter_val)
-                                *value = gf_strdup (iter_val);
-                        goto out;
-                }
-        } while (1);
-out:
-        if (handle->read) {
-                fclose (handle->read);
-                handle->read = NULL;
-        }
+        gf_msg_trace("", 0, "key %s read", iter_key);
 
-        if (handle->fd > 0 && handle->locked == F_ULOCK) {
-                /* only invalidate handle->fd if not locked */
-                sys_close (handle->fd);
+        if (!strcmp(key, iter_key)) {
+            gf_msg_debug("", 0, "key %s found", key);
+            ret = 0;
+            if (iter_val)
+                *value = gf_strdup(iter_val);
+            goto out;
         }
+    } while (1);
+out:
+    if (handle->read) {
+        fclose(handle->read);
+        handle->read = NULL;
+    }
 
-        GF_FREE (free_str);
+    if (handle->fd > 0 && handle->locked == F_ULOCK) {
+        /* only invalidate handle->fd if not locked */
+        sys_close(handle->fd);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_save_value (int fd, char *key, char *value)
+gf_store_save_value(int fd, char *key, char *value)
 {
-        int32_t         ret = -1;
-        int             dup_fd = -1;
-        FILE           *fp  = NULL;
-
-        GF_ASSERT (fd > 0);
-        GF_ASSERT (key);
-        GF_ASSERT (value);
-
-        dup_fd = dup (fd);
-        if (dup_fd == -1)
-                goto out;
-
-        fp = fdopen (dup_fd, "a+");
-        if (fp == NULL) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "fdopen failed.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = fprintf (fp, "%s=%s\n", key, value);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to store key: %s, value: %s.",
-                        key, value);
-                ret = -1;
-                goto out;
-        }
-
-        ret = fflush (fp);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "fflush failed.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int32_t ret = -1;
+    int dup_fd = -1;
+    FILE *fp = NULL;
+
+    GF_ASSERT(fd > 0);
+    GF_ASSERT(key);
+    GF_ASSERT(value);
+
+    dup_fd = dup(fd);
+    if (dup_fd == -1)
+        goto out;
+
+    fp = fdopen(dup_fd, "a+");
+    if (fp == NULL) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fdopen failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = fprintf(fp, "%s=%s\n", key, value);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to store key: %s, value: %s.", key, value);
+        ret = -1;
+        goto out;
+    }
+
+    ret = fflush(fp);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fflush failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (fp)
-                fclose (fp);
+    if (fp)
+        fclose(fp);
 
-        gf_msg_debug (THIS->name, 0, "returning: %d", ret);
-        return ret;
+    gf_msg_debug(THIS->name, 0, "returning: %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_handle_new (const char *path, gf_store_handle_t **handle)
+gf_store_save_items(int fd, char *items)
 {
-        int32_t                 ret = -1;
-        gf_store_handle_t *shandle = NULL;
-        int                     fd = -1;
-        char                    *spath = NULL;
-
-        shandle = GF_CALLOC (1, sizeof (*shandle), gf_common_mt_store_handle_t);
-        if (!shandle)
-                goto out;
-
-        spath = gf_strdup (path);
-        if (!spath)
-                goto out;
-
-        fd = open (path, O_RDWR | O_CREAT | O_APPEND, 0600);
-        if (fd < 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open file: %s.", path);
-                goto out;
-        }
-
-        ret = gf_store_sync_direntry (spath);
-        if (ret)
-                goto out;
+    int32_t ret = -1;
+    int dup_fd = -1;
+    FILE *fp = NULL;
+
+    GF_ASSERT(fd > 0);
+    GF_ASSERT(items);
+
+    dup_fd = dup(fd);
+    if (dup_fd == -1)
+        goto out;
+
+    fp = fdopen(dup_fd, "a+");
+    if (fp == NULL) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fdopen failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = fputs(items, fp);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to store items: %s", items);
+        ret = -1;
+        goto out;
+    }
+
+    ret = fflush(fp);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fflush failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (fp)
+        fclose(fp);
 
-        shandle->path = spath;
-        shandle->locked = F_ULOCK;
-        *handle = shandle;
-        shandle->tmp_fd = -1;
+    gf_msg_debug(THIS->name, 0, "returning: %d", ret);
+    return ret;
+}
 
-        ret = 0;
+int32_t
+gf_store_handle_new(const char *path, gf_store_handle_t **handle)
+{
+    int32_t ret = -1;
+    gf_store_handle_t *shandle = NULL;
+    int fd = -1;
+    char *spath = NULL;
+
+    shandle = GF_CALLOC(1, sizeof(*shandle), gf_common_mt_store_handle_t);
+    if (!shandle)
+        goto out;
+
+    spath = gf_strdup(path);
+    if (!spath)
+        goto out;
+
+    fd = open(path, O_RDWR | O_CREAT | O_APPEND, 0600);
+    if (fd < 0) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open file: %s.", path);
+        goto out;
+    }
+
+    ret = gf_store_sync_direntry(spath);
+    if (ret)
+        goto out;
+
+    shandle->path = spath;
+    shandle->locked = F_ULOCK;
+    *handle = shandle;
+    shandle->tmp_fd = -1;
+
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        if (ret == -1) {
-                GF_FREE (spath);
-                GF_FREE (shandle);
-        }
+    if (ret) {
+        GF_FREE(spath);
+        GF_FREE(shandle);
+    }
 
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
 
 int
-gf_store_handle_retrieve (char *path, gf_store_handle_t **handle)
+gf_store_handle_retrieve(char *path, gf_store_handle_t **handle)
 {
-        int32_t                 ret = -1;
-        struct stat statbuf = {0};
-
-        ret = sys_stat (path, &statbuf);
-        if (ret) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND, "Path "
-                        "corresponding to %s.", path);
-                goto out;
-        }
-        ret =  gf_store_handle_new (path, handle);
+    int32_t ret = -1;
+    struct stat statbuf = {0};
+
+    ret = sys_stat(path, &statbuf);
+    if (ret) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND,
+               "Path "
+               "corresponding to %s.",
+               path);
+        goto out;
+    }
+    ret = gf_store_handle_new(path, handle);
 out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_handle_destroy (gf_store_handle_t *handle)
+gf_store_handle_destroy(gf_store_handle_t *handle)
 {
-        int32_t                 ret = -1;
+    int32_t ret = -1;
 
-        if (!handle) {
-                ret = 0;
-                goto out;
-        }
+    if (!handle) {
+        ret = 0;
+        goto out;
+    }
 
-        GF_FREE (handle->path);
+    GF_FREE(handle->path);
 
-        GF_FREE (handle);
+    GF_FREE(handle);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
+    gf_msg_debug("", 0, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_new (gf_store_handle_t  *shandle, gf_store_iter_t  **iter)
+gf_store_iter_new(gf_store_handle_t *shandle, gf_store_iter_t **iter)
 {
-        int32_t                 ret = -1;
-        FILE                    *fp = NULL;
-        gf_store_iter_t         *tmp_iter = NULL;
-
-        GF_ASSERT (shandle);
-        GF_ASSERT (iter);
-
-        fp = fopen (shandle->path, "r");
-        if (!fp) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to open file %s", shandle->path);
-                goto out;
-        }
+    int32_t ret = -1;
+    FILE *fp = NULL;
+    gf_store_iter_t *tmp_iter = NULL;
 
-        tmp_iter = GF_CALLOC (1, sizeof (*tmp_iter),
-                              gf_common_mt_store_iter_t);
-        if (!tmp_iter)
-                goto out;
+    GF_ASSERT(shandle);
+    GF_ASSERT(iter);
 
-        strncpy (tmp_iter->filepath, shandle->path, sizeof (tmp_iter->filepath));
-        tmp_iter->filepath[sizeof (tmp_iter->filepath) - 1] = 0;
-        tmp_iter->file = fp;
+    fp = fopen(shandle->path, "r");
+    if (!fp) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to open file %s", shandle->path);
+        goto out;
+    }
 
-        *iter = tmp_iter;
-        tmp_iter = NULL;
-        ret = 0;
+    tmp_iter = GF_CALLOC(1, sizeof(*tmp_iter), gf_common_mt_store_iter_t);
+    if (!tmp_iter)
+        goto out;
+
+    if (snprintf(tmp_iter->filepath, sizeof(tmp_iter->filepath), "%s",
+                 shandle->path) >= sizeof(tmp_iter->filepath))
+        goto out;
+
+    tmp_iter->file = fp;
+
+    *iter = tmp_iter;
+    tmp_iter = NULL;
+    ret = 0;
 
 out:
-        if (ret && fp)
-                fclose (fp);
+    if (ret && fp)
+        fclose(fp);
 
-        GF_FREE (tmp_iter);
+    GF_FREE(tmp_iter);
 
-        gf_msg_debug ("", 0, "Returning with %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning with %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_validate_key_value (char *storepath, char *key, char *val,
-                             gf_store_op_errno_t *op_errno)
+gf_store_validate_key_value(char *storepath, char *key, char *val,
+                            gf_store_op_errno_t *op_errno)
 {
-        int ret = 0;
-
-        GF_ASSERT (op_errno);
-        GF_ASSERT (storepath);
-
-        if ((key == NULL) && (val == NULL)) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid key and value (null)"
-                        " in %s", storepath);
-                *op_errno = GD_STORE_KEY_VALUE_NULL;
-        } else if (key == NULL) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid key (null) in %s",
-                        storepath);
-                *op_errno = GD_STORE_KEY_NULL;
-        } else if (val == NULL) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid value (null) for key"
-                        " %s in %s", key, storepath);
-                *op_errno = GD_STORE_VALUE_NULL;
-        } else {
-                ret = 0;
-                *op_errno = GD_STORE_SUCCESS;
-        }
+    int ret = 0;
+
+    GF_ASSERT(op_errno);
+    GF_ASSERT(storepath);
+
+    if ((key == NULL) && (val == NULL)) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid key and value (null)"
+               " in %s",
+               storepath);
+        *op_errno = GD_STORE_KEY_VALUE_NULL;
+    } else if (key == NULL) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid key (null) in %s",
+               storepath);
+        *op_errno = GD_STORE_KEY_NULL;
+    } else if (val == NULL) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid value (null) for key"
+               " %s in %s",
+               key, storepath);
+        *op_errno = GD_STORE_VALUE_NULL;
+    } else {
+        ret = 0;
+        *op_errno = GD_STORE_SUCCESS;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_get_next (gf_store_iter_t *iter, char  **key, char **value,
-                        gf_store_op_errno_t *op_errno)
+gf_store_iter_get_next(gf_store_iter_t *iter, char **key, char **value,
+                       gf_store_op_errno_t *op_errno)
 {
-        int32_t         ret       = -1;
-        char            *scan_str = NULL;
-        char            *iter_key = NULL;
-        char            *iter_val = NULL;
-        struct stat     st        = {0,};
-        gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
-
-        GF_ASSERT (iter);
-        GF_ASSERT (key);
-        GF_ASSERT (value);
-
-        ret = sys_stat (iter->filepath, &st);
-        if (ret < 0) {
-                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "stat on file failed");
-                ret = -1;
-                store_errno = GD_STORE_STAT_FAILED;
-                goto out;
-        }
-
-        /* "st.st_size + 1" is used as we are fetching each
-         * line of a file using fgets, fgets will append "\0"
-         * to the end of the string
-         */
-        scan_str = GF_CALLOC (1, st.st_size + 1,
-                              gf_common_mt_char);
-        if (!scan_str) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-
-        ret = gf_store_read_and_tokenize (iter->file, scan_str,
-                                          st.st_size + 1,
-                                          &iter_key, &iter_val,
-                                          &store_errno);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = gf_store_validate_key_value (iter->filepath, iter_key,
-                                           iter_val, &store_errno);
-        if (ret)
-                goto out;
-
-        *key = gf_strdup (iter_key);
-        if (!*key) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-        *value = gf_strdup (iter_val);
-        if (!*value) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-        ret = 0;
+    int32_t ret = -1;
+    char *iter_key = NULL;
+    char *iter_val = NULL;
+    gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
+
+    GF_ASSERT(iter);
+    GF_ASSERT(key);
+    GF_ASSERT(value);
+
+    ret = gf_store_read_and_tokenize(iter->file, &iter_key, &iter_val,
+                                     &store_errno);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = gf_store_validate_key_value(iter->filepath, iter_key, iter_val,
+                                      &store_errno);
+    if (ret)
+        goto out;
+
+    *key = gf_strdup(iter_key);
+    if (!*key) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+    *value = gf_strdup(iter_val);
+    if (!*value) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        GF_FREE (scan_str);
-        if (ret) {
-                GF_FREE (*key);
-                GF_FREE (*value);
-                *key = NULL;
-                *value = NULL;
-        }
-        if (op_errno)
-                *op_errno = store_errno;
-
-        gf_msg_debug ("", 0, "Returning with %d", ret);
-        return ret;
+    if (ret) {
+        GF_FREE(*key);
+        GF_FREE(*value);
+        *key = NULL;
+        *value = NULL;
+    }
+    if (op_errno)
+        *op_errno = store_errno;
+
+    gf_msg_debug("", 0, "Returning with %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_iter_get_matching (gf_store_iter_t *iter, char *key, char **value)
+gf_store_iter_get_matching(gf_store_iter_t *iter, char *key, char **value)
 {
-        int32_t ret = -1;
-        char    *tmp_key = NULL;
-        char    *tmp_value = NULL;
-
-        ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value, NULL);
-        while (!ret) {
-                if (!strncmp (key, tmp_key, strlen (key))){
-                        *value = tmp_value;
-                        GF_FREE (tmp_key);
-                        goto out;
-                }
-                GF_FREE (tmp_key);
-                tmp_key = NULL;
-                GF_FREE (tmp_value);
-                tmp_value = NULL;
-                ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value,
-                                              NULL);
-        }
+    int32_t ret = -1;
+    char *tmp_key = NULL;
+    char *tmp_value = NULL;
+
+    ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL);
+    while (!ret) {
+        if (!strncmp(key, tmp_key, strlen(key))) {
+            *value = tmp_value;
+            GF_FREE(tmp_key);
+            goto out;
+        }
+        GF_FREE(tmp_key);
+        tmp_key = NULL;
+        GF_FREE(tmp_value);
+        tmp_value = NULL;
+        ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_destroy (gf_store_iter_t *iter)
+gf_store_iter_destroy(gf_store_iter_t **iter)
 {
-        int32_t         ret = -1;
+    int32_t ret = -1;
+
+    if (!(*iter))
+        return 0;
 
-        if (!iter)
-                return 0;
+    /* gf_store_iter_new will not return a valid iter object with iter->file
+     * being NULL*/
+    ret = fclose((*iter)->file);
+    if (ret)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable"
+               " to close file: %s, ret: %d",
+               (*iter)->filepath, ret);
 
-        /* gf_store_iter_new will not return a valid iter object with iter->file
-         * being NULL*/
-        ret = fclose (iter->file);
-        if (ret)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "Unable"
-                        " to close file: %s, ret: %d" ,
-                        iter->filepath, ret);
+    GF_FREE(*iter);
+    *iter = NULL;
 
-        GF_FREE (iter);
-        return ret;
+    return ret;
 }
 
-char*
-gf_store_strerror (gf_store_op_errno_t op_errno)
+char *
+gf_store_strerror(gf_store_op_errno_t op_errno)
 {
-        switch (op_errno) {
+    switch (op_errno) {
         case GD_STORE_SUCCESS:
-                return "Success";
+            return "Success";
         case GD_STORE_KEY_NULL:
-                return "Invalid Key";
+            return "Invalid Key";
         case GD_STORE_VALUE_NULL:
-                return "Invalid Value";
+            return "Invalid Value";
         case GD_STORE_KEY_VALUE_NULL:
-                return "Invalid Key and Value";
+            return "Invalid Key and Value";
         case GD_STORE_EOF:
-                return "No data";
+            return "No data";
         case GD_STORE_ENOMEM:
-                return "No memory";
+            return "No memory";
         default:
-                return "Invalid errno";
-        }
+            return "Invalid errno";
+    }
 }
 
 int
-gf_store_lock (gf_store_handle_t *sh)
+gf_store_lock(gf_store_handle_t *sh)
 {
-        int                     ret;
-
-        GF_ASSERT (sh);
-        GF_ASSERT (sh->path);
-        GF_ASSERT (sh->locked == F_ULOCK);
-
-        sh->fd = open (sh->path, O_RDWR);
-        if (sh->fd == -1) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open '%s'", sh->path);
-                return -1;
-        }
-
-        ret = lockf (sh->fd, F_LOCK, 0);
-        if (ret)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED,
-                        "Failed to gain lock on '%s'", sh->path);
-        else
-                /* sh->locked is protected by the lockf(sh->fd) above */
-                sh->locked = F_LOCK;
-
-        return ret;
+    int ret;
+
+    GF_ASSERT(sh);
+    GF_ASSERT(sh->path);
+    GF_ASSERT(sh->locked == F_ULOCK);
+
+    sh->fd = open(sh->path, O_RDWR);
+    if (sh->fd == -1) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open '%s'", sh->path);
+        return -1;
+    }
+
+    ret = lockf(sh->fd, F_LOCK, 0);
+    if (ret)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED,
+               "Failed to gain lock on '%s'", sh->path);
+    else
+        /* sh->locked is protected by the lockf(sh->fd) above */
+        sh->locked = F_LOCK;
+
+    return ret;
 }
 
 void
-gf_store_unlock (gf_store_handle_t *sh)
+gf_store_unlock(gf_store_handle_t *sh)
 {
-        GF_ASSERT (sh);
-        GF_ASSERT (sh->locked == F_LOCK);
+    GF_ASSERT(sh);
+    GF_ASSERT(sh->locked == F_LOCK);
 
-        sh->locked = F_ULOCK;
+    sh->locked = F_ULOCK;
 
-        /* does not matter if this fails, locks are released on close anyway */
-        if (lockf (sh->fd, F_ULOCK, 0) == -1)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED,
-                        "Failed to release lock on '%s'", sh->path);
+    /* does not matter if this fails, locks are released on close anyway */
+    if (lockf(sh->fd, F_ULOCK, 0) == -1)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED,
+               "Failed to release lock on '%s'", sh->path);
 
-        sys_close (sh->fd);
+    sys_close(sh->fd);
 }
 
 int
-gf_store_locked_local (gf_store_handle_t *sh)
+gf_store_locked_local(gf_store_handle_t *sh)
 {
-        GF_ASSERT (sh);
+    GF_ASSERT(sh);
 
-        return (sh->locked == F_LOCK);
+    return (sh->locked == F_LOCK);
 }
diff --git a/libglusterfs/src/store.h b/libglusterfs/src/store.h
deleted file mode 100644
index 7ac307bf5ae..00000000000
--- a/libglusterfs/src/store.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-   Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef _GLUSTERD_STORE_H_
-#define _GLUSTERD_STORE_H_
-
-#include "compat.h"
-#include "glusterfs.h"
-
-struct gf_store_handle_ {
-        char    *path;
-        int     fd;
-        int     tmp_fd;
-        FILE    *read;
-        int     locked;   /* state of lockf() */
-};
-
-typedef struct gf_store_handle_ gf_store_handle_t;
-
-struct gf_store_iter_ {
-        FILE    *file;
-        char    filepath[PATH_MAX];
-};
-
-typedef struct gf_store_iter_ gf_store_iter_t;
-
-typedef enum {
-        GD_STORE_SUCCESS,
-        GD_STORE_KEY_NULL,
-        GD_STORE_VALUE_NULL,
-        GD_STORE_KEY_VALUE_NULL,
-        GD_STORE_EOF,
-        GD_STORE_ENOMEM,
-        GD_STORE_STAT_FAILED
-} gf_store_op_errno_t;
-
-int32_t
-gf_store_mkdir (char *path);
-
-int32_t
-gf_store_handle_create_on_absence (gf_store_handle_t **shandle, char *path);
-
-int32_t
-gf_store_mkstemp (gf_store_handle_t *shandle);
-
-int
-gf_store_sync_direntry (char *path);
-
-int32_t
-gf_store_rename_tmppath (gf_store_handle_t *shandle);
-
-int32_t
-gf_store_unlink_tmppath (gf_store_handle_t *shandle);
-
-int
-gf_store_read_and_tokenize (FILE *file, char *str, int size, char **iter_key,
-                            char **iter_val, gf_store_op_errno_t *store_errno);
-
-int32_t
-gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value);
-
-int32_t
-gf_store_save_value (int fd, char *key, char *value);
-
-int32_t
-gf_store_handle_new (const char *path, gf_store_handle_t **handle);
-
-int
-gf_store_handle_retrieve (char *path, gf_store_handle_t **handle);
-
-int32_t
-gf_store_handle_destroy (gf_store_handle_t *handle);
-
-int32_t
-gf_store_iter_new (gf_store_handle_t  *shandle, gf_store_iter_t  **iter);
-
-int32_t
-gf_store_validate_key_value (char *storepath, char *key, char *val,
-                             gf_store_op_errno_t *op_errno);
-
-int32_t
-gf_store_iter_get_next (gf_store_iter_t *iter, char **key, char **value,
-                        gf_store_op_errno_t *op_errno);
-
-int32_t
-gf_store_iter_get_matching (gf_store_iter_t *iter, char *key, char **value);
-
-int32_t
-gf_store_iter_destroy (gf_store_iter_t *iter);
-
-char*
-gf_store_strerror (gf_store_op_errno_t op_errno);
-
-int
-gf_store_lock (gf_store_handle_t *sh);
-
-void
-gf_store_unlock (gf_store_handle_t *sh);
-
-int
-gf_store_locked_local (gf_store_handle_t *sh);
-
-#endif
diff --git a/libglusterfs/src/strfd.c b/libglusterfs/src/strfd.c
index 002d48629bc..8a2580edc85 100644
--- a/libglusterfs/src/strfd.c
+++ b/libglusterfs/src/strfd.c
@@ -10,83 +10,84 @@
 
 #include <stdarg.h>
 
-#include "mem-types.h"
-#include "mem-pool.h"
-#include "strfd.h"
-#include "common-utils.h"
+#include "glusterfs/mem-types.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/strfd.h"
+#include "glusterfs/common-utils.h"
 
 strfd_t *
-strfd_open ()
+strfd_open()
 {
-        strfd_t *strfd = NULL;
+    strfd_t *strfd = NULL;
 
-        strfd = GF_CALLOC(1, sizeof(*strfd), gf_common_mt_strfd_t);
+    strfd = GF_CALLOC(1, sizeof(*strfd), gf_common_mt_strfd_t);
 
-        return strfd;
+    return strfd;
 }
 
 int
-strvprintf (strfd_t *strfd, const char *fmt, va_list ap)
+strvprintf(strfd_t *strfd, const char *fmt, va_list ap)
 {
-        char *str = NULL;
-        int size = 0;
-
-        size = vasprintf (&str, fmt, ap);
-
-        if (size < 0)
-                return size;
-
-        if (!strfd->alloc_size) {
-                strfd->data = GF_CALLOC (max(size + 1, 4096), 1,
-                                         gf_common_mt_strfd_data_t);
-                if (!strfd->data) {
-                        free (str); /* NOT GF_FREE */
-                        return -1;
-                }
-                strfd->alloc_size = max(size + 1, 4096);
-        }
+    char *str = NULL;
+    int size = 0;
+
+    size = vasprintf(&str, fmt, ap);
+
+    if (size < 0)
+        return size;
 
-        if (strfd->alloc_size <= (strfd->size + size)) {
-                char *tmp_ptr = NULL;
-                int new_size = max ((strfd->alloc_size * 2),
-                                    gf_roundup_next_power_of_two (strfd->size + size + 1));
-                tmp_ptr = GF_REALLOC (strfd->data, new_size);
-                if (!tmp_ptr) {
-                        free (str); /* NOT GF_FREE */
-                        return -1;
-                }
-                strfd->alloc_size = new_size;
-                strfd->data = tmp_ptr;
+    if (!strfd->alloc_size) {
+        strfd->data = GF_CALLOC(max(size + 1, 4096), 1,
+                                gf_common_mt_strfd_data_t);
+        if (!strfd->data) {
+            free(str); /* NOT GF_FREE */
+            return -1;
+        }
+        strfd->alloc_size = max(size + 1, 4096);
+    }
+
+    if (strfd->alloc_size <= (strfd->size + size)) {
+        char *tmp_ptr = NULL;
+        int new_size = max(
+            (strfd->alloc_size * 2),
+            gf_roundup_next_power_of_two(strfd->size + size + 1));
+        tmp_ptr = GF_REALLOC(strfd->data, new_size);
+        if (!tmp_ptr) {
+            free(str); /* NOT GF_FREE */
+            return -1;
         }
+        strfd->alloc_size = new_size;
+        strfd->data = tmp_ptr;
+    }
 
-        /* Copy the trailing '\0', but do not account for it in ->size.
-           This allows safe use of strfd->data as a string. */
-        memcpy (strfd->data + strfd->size, str, size + 1);
-        strfd->size += size;
+    /* Copy the trailing '\0', but do not account for it in ->size.
+       This allows safe use of strfd->data as a string. */
+    memcpy(strfd->data + strfd->size, str, size + 1);
+    strfd->size += size;
 
-        free (str); /* NOT GF_FREE */
+    free(str); /* NOT GF_FREE */
 
-        return size;
+    return size;
 }
 
 int
-strprintf (strfd_t *strfd, const char *fmt, ...)
+strprintf(strfd_t *strfd, const char *fmt, ...)
 {
-        int ret = 0;
-        va_list ap;
+    int ret = 0;
+    va_list ap;
 
-        va_start (ap, fmt);
-        ret = strvprintf (strfd, fmt, ap);
-        va_end (ap);
+    va_start(ap, fmt);
+    ret = strvprintf(strfd, fmt, ap);
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 int
-strfd_close (strfd_t *strfd)
+strfd_close(strfd_t *strfd)
 {
-        GF_FREE (strfd->data);
-        GF_FREE (strfd);
+    GF_FREE(strfd->data);
+    GF_FREE(strfd);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/syncop-utils.c b/libglusterfs/src/syncop-utils.c
index b743bdfae88..d9f1723856d 100644
--- a/libglusterfs/src/syncop-utils.c
+++ b/libglusterfs/src/syncop-utils.c
@@ -8,45 +8,44 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "syncop.h"
-#include "syncop-utils.h"
-#include "common-utils.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/syncop.h"
+#include "glusterfs/syncop-utils.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 struct syncop_dir_scan_data {
-        xlator_t *subvol;
-        loc_t *parent;
-        void *data;
-        gf_dirent_t *q;
-        gf_dirent_t *entry;
-        pthread_cond_t *cond;
-        pthread_mutex_t *mut;
-        syncop_dir_scan_fn_t fn;
-        uint32_t *jobs_running;
-        uint32_t *qlen;
-        int32_t  *retval;
+    xlator_t *subvol;
+    loc_t *parent;
+    void *data;
+    gf_dirent_t *q;
+    gf_dirent_t *entry;
+    pthread_cond_t *cond;
+    pthread_mutex_t *mut;
+    syncop_dir_scan_fn_t fn;
+    uint32_t *jobs_running;
+    uint32_t *qlen;
+    int32_t *retval;
 };
 
 int
-syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
+syncop_dirfd(xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
 {
-        int  ret    = 0;
-        fd_t *dirfd = NULL;
-
-        if (!fd)
-                return -EINVAL;
-
-        dirfd = fd_create (loc->inode, pid);
-        if (!dirfd) {
-                gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FD_CREATE_FAILED, "fd_create of %s",
-                        uuid_utoa (loc->gfid));
-                ret = -errno;
-                goto out;
-        }
-
-        ret = syncop_opendir (subvol, loc, dirfd, NULL, NULL);
-        if (ret) {
+    int ret = 0;
+    fd_t *dirfd = NULL;
+
+    if (!fd)
+        return -EINVAL;
+
+    dirfd = fd_create(loc->inode, pid);
+    if (!dirfd) {
+        gf_msg(subvol->name, GF_LOG_ERROR, errno, LG_MSG_FD_CREATE_FAILED,
+               "fd_create of %s", uuid_utoa(loc->gfid));
+        ret = -errno;
+        goto out;
+    }
+
+    ret = syncop_opendir(subvol, loc, dirfd, NULL, NULL);
+    if (ret) {
         /*
          * On Linux, if the brick was not updated, opendir will
          * fail. We therefore use backward compatible code
@@ -57,93 +56,95 @@ syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
          * to provide backward-compatibility.
          */
 #ifdef GF_LINUX_HOST_OS
-                fd_unref (dirfd);
-                dirfd = fd_anonymous (loc->inode);
-                if (!dirfd) {
-                        gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                                LG_MSG_FD_ANONYMOUS_FAILED, "fd_anonymous of "
-                                "%s", uuid_utoa (loc->gfid));
-                        ret = -errno;
-                        goto out;
-                }
-                ret = 0;
-#else /* GF_LINUX_HOST_OS */
-                fd_unref (dirfd);
-                gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "opendir of %s",
-                        uuid_utoa (loc->gfid));
-                goto out;
-#endif /* GF_LINUX_HOST_OS */
-        } else {
-                fd_bind (dirfd);
+        fd_unref(dirfd);
+        dirfd = fd_anonymous(loc->inode);
+        if (!dirfd) {
+            gf_msg(subvol->name, GF_LOG_ERROR, errno,
+                   LG_MSG_FD_ANONYMOUS_FAILED,
+                   "fd_anonymous of "
+                   "%s",
+                   uuid_utoa(loc->gfid));
+            ret = -errno;
+            goto out;
         }
+        ret = 0;
+#else  /* GF_LINUX_HOST_OS */
+        fd_unref(dirfd);
+        gf_msg(subvol->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "opendir of %s", uuid_utoa(loc->gfid));
+        goto out;
+#endif /* GF_LINUX_HOST_OS */
+    } else {
+        fd_bind(dirfd);
+    }
 out:
-        if (ret == 0)
-                *fd = dirfd;
-        return ret;
+    if (ret == 0)
+        *fd = dirfd;
+    return ret;
 }
 
 int
-syncop_ftw (xlator_t *subvol, loc_t *loc, int pid, void *data,
-            int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                       void *data))
+syncop_ftw(xlator_t *subvol, loc_t *loc, int pid, void *data,
+           int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                     void *data))
 {
-        loc_t       child_loc = {0, };
-        fd_t        *fd       = NULL;
-        uint64_t    offset    = 0;
-        gf_dirent_t *entry    = NULL;
-        int         ret       = 0;
-        gf_dirent_t entries;
-
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    loc_t child_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    while ((ret = syncop_readdirp(subvol, fd, 131072, offset, &entries, NULL,
+                                  NULL))) {
+        if (ret < 0)
+            break;
+
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-        INIT_LIST_HEAD (&entries.list);
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
-        while ((ret = syncop_readdirp (subvol, fd, 131072, offset, &entries,
-                                       NULL, NULL))) {
-                if (ret < 0)
-                        break;
+            gf_link_inode_from_dirent(NULL, fd->inode, entry);
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-
-                        gf_link_inode_from_dirent (NULL, fd->inode, entry);
-
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                break;
-
-                        if (entry->d_stat.ia_type == IA_IFDIR) {
-                                child_loc.inode = inode_ref (entry->inode);
-                                gf_uuid_copy (child_loc.gfid, entry->inode->gfid);
-                                ret = syncop_ftw (subvol, &child_loc,
-                                                  pid, data, fn);
-                                loc_wipe (&child_loc);
-                                if (ret)
-                                        break;
-                        }
-                }
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                break;
 
-                gf_dirent_free (&entries);
+            if (entry->d_stat.ia_type == IA_IFDIR) {
+                child_loc.inode = inode_ref(entry->inode);
+                gf_uuid_copy(child_loc.gfid, entry->inode->gfid);
+                ret = syncop_ftw(subvol, &child_loc, pid, data, fn);
+                loc_wipe(&child_loc);
                 if (ret)
-                        break;
+                    break;
+            }
         }
 
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
+
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 /**
@@ -156,476 +157,513 @@ out:
  * syncop_ftw.
  */
 int
-syncop_ftw_throttle (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                     int (*fn) (xlator_t *subvol, gf_dirent_t *entry,
-                                loc_t *parent, void *data),
-                     int count, int sleep_time)
+syncop_ftw_throttle(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                    int (*fn)(xlator_t *subvol, gf_dirent_t *entry,
+                              loc_t *parent, void *data),
+                    int count, int sleep_time)
 {
-        loc_t       child_loc = {0, };
-        fd_t        *fd       = NULL;
-        uint64_t    offset    = 0;
-        gf_dirent_t *entry    = NULL;
-        int         ret       = 0;
-        gf_dirent_t entries;
-        int         tmp       = 0;
-
-        if (sleep_time <= 0) {
-                ret = syncop_ftw (subvol, loc, pid, data, fn);
-                goto out;
-        }
+    loc_t child_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
+    int tmp = 0;
+
+    if (sleep_time <= 0) {
+        ret = syncop_ftw(subvol, loc, pid, data, fn);
+        goto out;
+    }
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    while ((ret = syncop_readdirp(subvol, fd, 131072, offset, &entries, NULL,
+                                  NULL))) {
+        if (ret < 0)
+            break;
 
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-        INIT_LIST_HEAD (&entries.list);
+        tmp = 0;
 
-        while ((ret = syncop_readdirp (subvol, fd, 131072, offset, &entries,
-                                       NULL, NULL))) {
-                if (ret < 0)
-                        break;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
+            if (++tmp >= count) {
                 tmp = 0;
+                sleep(sleep_time);
+            }
 
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-
-                        if (++tmp >= count) {
-                                tmp = 0;
-                                sleep (sleep_time);
-                        }
-
-                        gf_link_inode_from_dirent (NULL, fd->inode, entry);
-
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                continue;
-
-                        if (entry->d_stat.ia_type == IA_IFDIR) {
-                                child_loc.inode = inode_ref (entry->inode);
-                                gf_uuid_copy (child_loc.gfid, entry->inode->gfid);
-                                ret = syncop_ftw_throttle (subvol, &child_loc,
-                                                           pid, data, fn, count,
-                                                           sleep_time);
-                                loc_wipe (&child_loc);
-                                if (ret)
-                                        continue;
-                        }
-                }
+            gf_link_inode_from_dirent(NULL, fd->inode, entry);
+
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                continue;
 
-                gf_dirent_free (&entries);
+            if (entry->d_stat.ia_type == IA_IFDIR) {
+                child_loc.inode = inode_ref(entry->inode);
+                gf_uuid_copy(child_loc.gfid, entry->inode->gfid);
+                ret = syncop_ftw_throttle(subvol, &child_loc, pid, data, fn,
+                                          count, sleep_time);
+                loc_wipe(&child_loc);
                 if (ret)
-                        break;
+                    continue;
+            }
         }
 
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
+
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 static void
-_scan_data_destroy (struct syncop_dir_scan_data *data)
+_scan_data_destroy(struct syncop_dir_scan_data *data)
 {
-        GF_FREE (data);
+    GF_FREE(data);
 }
 
 static int
-_dir_scan_job_fn_cbk (int ret, call_frame_t *frame, void *opaque)
+_dir_scan_job_fn_cbk(int ret, call_frame_t *frame, void *opaque)
 {
-        struct syncop_dir_scan_data *scan_data = opaque;
+    struct syncop_dir_scan_data *scan_data = opaque;
 
-        _scan_data_destroy (scan_data);
-        return 0;
+    _scan_data_destroy(scan_data);
+    return 0;
 }
 
 static int
-_dir_scan_job_fn (void *data)
+_dir_scan_job_fn(void *data)
 {
-        struct syncop_dir_scan_data *scan_data = data;
-        gf_dirent_t                 *entry     = NULL;
-        int                         ret        = 0;
-
-        entry = scan_data->entry;
-        scan_data->entry = NULL;
-        do {
-                ret = scan_data->fn (scan_data->subvol, entry,
-                                     scan_data->parent,
-                                     scan_data->data);
-                gf_dirent_entry_free (entry);
-                entry = NULL;
-                pthread_mutex_lock (scan_data->mut);
-                {
-                        if (ret)
-                                *scan_data->retval |= ret;
-                        if (list_empty (&scan_data->q->list)) {
-                                (*scan_data->jobs_running)--;
-                                pthread_cond_broadcast (scan_data->cond);
-                        } else {
-                                entry = list_first_entry (&scan_data->q->list,
-                                                  typeof (*scan_data->q), list);
-                                list_del_init (&entry->list);
-                                (*scan_data->qlen)--;
-                        }
-                }
-                pthread_mutex_unlock (scan_data->mut);
-        } while (entry);
+    struct syncop_dir_scan_data *scan_data = data;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+
+    entry = scan_data->entry;
+    scan_data->entry = NULL;
+    do {
+        ret = scan_data->fn(scan_data->subvol, entry, scan_data->parent,
+                            scan_data->data);
+        gf_dirent_entry_free(entry);
+        entry = NULL;
+        pthread_mutex_lock(scan_data->mut);
+        {
+            if (ret)
+                *scan_data->retval |= ret;
+            if (list_empty(&scan_data->q->list)) {
+                (*scan_data->jobs_running)--;
+                pthread_cond_broadcast(scan_data->cond);
+            } else {
+                entry = list_first_entry(&scan_data->q->list,
+                                         typeof(*scan_data->q), list);
+                list_del_init(&entry->list);
+                (*scan_data->qlen)--;
+            }
+        }
+        pthread_mutex_unlock(scan_data->mut);
+    } while (entry);
 
-        return ret;
+    return ret;
 }
 
 static int
-_run_dir_scan_task (call_frame_t *frame, xlator_t *subvol, loc_t *parent,
-                    gf_dirent_t *q, gf_dirent_t *entry, int *retval,
-                    pthread_mutex_t *mut, pthread_cond_t *cond,
-                    uint32_t *jobs_running, uint32_t *qlen,
-                    syncop_dir_scan_fn_t fn, void *data)
+_run_dir_scan_task(call_frame_t *frame, xlator_t *subvol, loc_t *parent,
+                   gf_dirent_t *q, gf_dirent_t *entry, int *retval,
+                   pthread_mutex_t *mut, pthread_cond_t *cond,
+                   uint32_t *jobs_running, uint32_t *qlen,
+                   syncop_dir_scan_fn_t fn, void *data)
 {
-        int     ret = 0;
-        struct syncop_dir_scan_data *scan_data = NULL;
-
-
-        scan_data = GF_CALLOC (1, sizeof (struct syncop_dir_scan_data),
-                               gf_common_mt_scan_data);
-        if (!scan_data) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        scan_data->subvol       = subvol;
-        scan_data->parent       = parent;
-        scan_data->data         = data;
-        scan_data->mut          = mut;
-        scan_data->cond         = cond;
-        scan_data->fn           = fn;
-        scan_data->jobs_running = jobs_running;
-        scan_data->entry        = entry;
-        scan_data->q            = q;
-        scan_data->qlen         = qlen;
-        scan_data->retval       = retval;
-
-        ret = synctask_new (subvol->ctx->env, _dir_scan_job_fn,
-                            _dir_scan_job_fn_cbk, frame, scan_data);
+    int ret = 0;
+    struct syncop_dir_scan_data *scan_data = NULL;
+
+    scan_data = GF_CALLOC(1, sizeof(struct syncop_dir_scan_data),
+                          gf_common_mt_scan_data);
+    if (!scan_data) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    scan_data->subvol = subvol;
+    scan_data->parent = parent;
+    scan_data->data = data;
+    scan_data->mut = mut;
+    scan_data->cond = cond;
+    scan_data->fn = fn;
+    scan_data->jobs_running = jobs_running;
+    scan_data->entry = entry;
+    scan_data->q = q;
+    scan_data->qlen = qlen;
+    scan_data->retval = retval;
+
+    ret = synctask_new(subvol->ctx->env, _dir_scan_job_fn, _dir_scan_job_fn_cbk,
+                       frame, scan_data);
 out:
-        if (ret < 0) {
-                gf_dirent_entry_free (entry);
-                _scan_data_destroy (scan_data);
-                pthread_mutex_lock (mut);
-                {
-                        *jobs_running = *jobs_running - 1;
-                }
-                pthread_mutex_unlock (mut);
-                /*No need to cond-broadcast*/
+    if (ret < 0) {
+        gf_dirent_entry_free(entry);
+        _scan_data_destroy(scan_data);
+        pthread_mutex_lock(mut);
+        {
+            *jobs_running = *jobs_running - 1;
         }
-        return ret;
+        pthread_mutex_unlock(mut);
+        /*No need to cond-broadcast*/
+    }
+    return ret;
 }
 
 int
-syncop_mt_dir_scan (call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
-                    void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
-                    uint32_t max_jobs, uint32_t max_qlen)
+syncop_mt_dir_scan(call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
+                   void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
+                   uint32_t max_jobs, uint32_t max_qlen)
 {
-        fd_t        *fd    = NULL;
-        uint64_t    offset = 0;
-        gf_dirent_t *last = NULL;
-        int         ret    = 0;
-        int         retval = 0;
-        gf_dirent_t q;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t *tmp = NULL;
-        uint32_t    jobs_running = 0;
-        uint32_t    qlen = 0;
-        pthread_cond_t cond;
-        pthread_mutex_t mut;
-        gf_boolean_t cond_init = _gf_false;
-        gf_boolean_t mut_init = _gf_false;
-        gf_dirent_t entries;
-
-        /*For this functionality to be implemented in general, we need
-         * synccond_t infra which doesn't block the executing thread. Until then
-         * return failures inside synctask if they use this.*/
-        if (synctask_get())
-                return -ENOTSUP;
-
-        if (max_jobs == 0)
-                return -EINVAL;
-
-        /*Code becomes simpler this way. cond_wait just on qlength.
-         * Little bit of cheating*/
-        if (max_qlen == 0)
-                max_qlen = 1;
-
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *last = NULL;
+    int ret = 0;
+    int retval = 0;
+    gf_dirent_t q;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    uint32_t jobs_running = 0;
+    uint32_t qlen = 0;
+    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+    pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+    gf_dirent_t entries;
+    xlator_t *this = NULL;
+
+    if (frame) {
+        this = frame->this;
+    } else {
+        this = THIS;
+    }
+
+    /*For this functionality to be implemented in general, we need
+     * synccond_t infra which doesn't block the executing thread. Until then
+     * return failures inside synctask if they use this.*/
+    if (synctask_get())
+        return -ENOTSUP;
+
+    if (max_jobs == 0)
+        return -EINVAL;
+
+    /*Code becomes simpler this way. cond_wait just on qlength.
+     * Little bit of cheating*/
+    if (max_qlen == 0)
+        max_qlen = 1;
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+    INIT_LIST_HEAD(&q.list);
+
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, xdata,
+                                 NULL))) {
+        if (ret < 0)
+            break;
 
-        INIT_LIST_HEAD (&entries.list);
-        INIT_LIST_HEAD (&q.list);
-        ret = pthread_mutex_init (&mut, NULL);
-        if (ret)
-                goto out;
-        mut_init = _gf_true;
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-        ret = pthread_cond_init (&cond, NULL);
-        if (ret)
+        last = list_last_entry(&entries.list, typeof(*last), list);
+        offset = last->d_off;
+
+        list_for_each_entry_safe(entry, tmp, &entries.list, list)
+        {
+            if (this && this->cleanup_starting)
                 goto out;
-        cond_init = _gf_true;
 
-        while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      xdata, NULL))) {
-                if (ret < 0)
-                        break;
+            list_del_init(&entry->list);
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
+                gf_dirent_entry_free(entry);
+                continue;
+            }
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+            if (entry->d_stat.ia_type == IA_IFDIR) {
+                ret = fn(subvol, entry, loc, data);
+                gf_dirent_entry_free(entry);
+                if (ret)
+                    goto out;
+                continue;
+            }
+
+            if (retval) /*Any jobs failed?*/
+                goto out;
 
-                last = list_last_entry (&entries.list, typeof (*last), list);
-                offset = last->d_off;
-
-                list_for_each_entry_safe (entry, tmp, &entries.list, list) {
-                        list_del_init (&entry->list);
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, "..")) {
-                                gf_dirent_entry_free (entry);
-                                continue;
-                        }
-
-                        if (entry->d_type == IA_IFDIR) {
-                                ret = fn (subvol, entry, loc, data);
-                                gf_dirent_entry_free (entry);
-                                if (ret)
-                                        goto out;
-                                continue;
-                        }
-
-                        if (retval) /*Any jobs failed?*/
-                                goto out;
-
-                        pthread_mutex_lock (&mut);
-                        {
-                                while (qlen == max_qlen)
-                                        pthread_cond_wait (&cond, &mut);
-                                if (max_jobs == jobs_running) {
-                                        list_add_tail (&entry->list, &q.list);
-                                        qlen++;
-                                        entry = NULL;
-                                } else {
-                                        jobs_running++;
-                                }
-                        }
-                        pthread_mutex_unlock (&mut);
-
-
-                        if (!entry)
-                                continue;
-
-                        ret = _run_dir_scan_task (frame, subvol, loc, &q, entry,
-                                                  &retval, &mut, &cond,
-                                                &jobs_running, &qlen, fn, data);
-                        if (ret)
-                                goto out;
+            pthread_mutex_lock(&mut);
+            {
+                while (qlen == max_qlen)
+                    pthread_cond_wait(&cond, &mut);
+                if (max_jobs == jobs_running) {
+                    list_add_tail(&entry->list, &q.list);
+                    qlen++;
+                    entry = NULL;
+                } else {
+                    jobs_running++;
                 }
+            }
+            pthread_mutex_unlock(&mut);
+
+            if (!entry)
+                continue;
+
+            ret = _run_dir_scan_task(frame, subvol, loc, &q, entry, &retval,
+                                     &mut, &cond, &jobs_running, &qlen, fn,
+                                     data);
+            if (ret)
+                goto out;
         }
+    }
 
 out:
-        if (fd)
-                fd_unref (fd);
-        if (mut_init && cond_init) {
-                pthread_mutex_lock (&mut);
-                {
-                        while (jobs_running)
-                                pthread_cond_wait (&cond, &mut);
-                }
-                pthread_mutex_unlock (&mut);
-                gf_dirent_free (&q);
-                gf_dirent_free (&entries);
-        }
+    if (fd)
+        fd_unref(fd);
+
+    pthread_mutex_lock(&mut);
+    {
+        while (jobs_running)
+            pthread_cond_wait(&cond, &mut);
+    }
+    pthread_mutex_unlock(&mut);
+
+    gf_dirent_free(&q);
+    gf_dirent_free(&entries);
 
-        if (mut_init)
-                pthread_mutex_destroy (&mut);
-        if (cond_init)
-                pthread_cond_destroy (&cond);
-        return ret|retval;
+    return ret | retval;
 }
 
 int
-syncop_dir_scan (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                 int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                            void *data))
+syncop_dir_scan(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                          void *data))
 {
-        fd_t        *fd    = NULL;
-        uint64_t    offset = 0;
-        gf_dirent_t *entry = NULL;
-        int         ret    = 0;
-        gf_dirent_t entries;
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
 
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
 
-        INIT_LIST_HEAD (&entries.list);
+    INIT_LIST_HEAD(&entries.list);
 
-        while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      NULL, NULL))) {
-                if (ret < 0)
-                        break;
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, NULL,
+                                 NULL))) {
+        if (ret < 0)
+            break;
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                break;
-                }
-                gf_dirent_free (&entries);
-                if (ret)
-                        break;
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                break;
         }
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
 
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 int
-syncop_is_subvol_local (xlator_t *this, loc_t *loc, gf_boolean_t *is_local)
+syncop_is_subvol_local(xlator_t *this, loc_t *loc, gf_boolean_t *is_local)
 {
-        char *pathinfo = NULL;
-        dict_t *xattr = NULL;
-        int ret = 0;
+    char *pathinfo = NULL;
+    dict_t *xattr = NULL;
+    int ret = 0;
 
-        if (!this || !this->type || !is_local)
-                return -EINVAL;
+    if (!this || !this->type || !is_local)
+        return -EINVAL;
 
-        if (strcmp (this->type, "protocol/client") != 0)
-                return -EINVAL;
+    if (strcmp(this->type, "protocol/client") != 0)
+        return -EINVAL;
 
-        *is_local = _gf_false;
+    *is_local = _gf_false;
 
-        ret = syncop_getxattr (this, loc, &xattr, GF_XATTR_PATHINFO_KEY, NULL,
-                               NULL);
-        if (ret < 0) {
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_getxattr(this, loc, &xattr, GF_XATTR_PATHINFO_KEY, NULL, NULL);
+    if (ret < 0) {
+        ret = -1;
+        goto out;
+    }
 
-        if (!xattr) {
-                ret = -EINVAL;
-                goto out;
-        }
+    if (!xattr) {
+        ret = -EINVAL;
+        goto out;
+    }
 
-        ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &pathinfo);
-        if (ret)
-                goto out;
+    ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &pathinfo);
+    if (ret)
+        goto out;
 
-        ret = glusterfs_is_local_pathinfo (pathinfo, is_local);
+    ret = glusterfs_is_local_pathinfo(pathinfo, is_local);
 
-        gf_msg_debug (this->name, 0, "subvol %s is %slocal",
-                this->name, *is_local ? "" : "not ");
+    gf_msg_debug(this->name, 0, "subvol %s is %slocal", this->name,
+                 *is_local ? "" : "not ");
 
 out:
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return ret;
 }
 
+/**
+ * For hard resove, it it telling posix to make use of the
+ * gfid2path extended attribute stored on disk. Otherwise
+ * posix xlator (with GFID_TO_PATH_KEY as the key) will just
+ * do a in memory inode_path to get the path. Depending upon
+ * the consumer of this function, they can choose how they want
+ * to proceed. If doing a xattr operation sounds costly, then
+ * use GFID_TO_PATH_KEY as the key for getxattr.
+ **/
+
 int
-syncop_gfid_to_path (inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
-                     char **path_p)
+syncop_gfid_to_path_hard(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                         inode_t *inode, char **path_p,
+                         gf_boolean_t hard_resolve)
 {
-        int      ret   = 0;
-        char    *path  = NULL;
-        loc_t    loc   = {0,};
-        dict_t  *xattr = NULL;
-
-        gf_uuid_copy (loc.gfid, gfid);
-        loc.inode = inode_new (itable);
-
-        ret = syncop_getxattr (subvol, &loc, &xattr, GFID_TO_PATH_KEY, NULL,
-                               NULL);
-        if (ret < 0)
-                goto out;
-
-        ret = dict_get_str (xattr, GFID_TO_PATH_KEY, &path);
-        if (ret || !path) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        if (path_p) {
-                *path_p = gf_strdup (path);
-                if (!*path_p) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+    int ret = 0;
+    char *path = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    gf_uuid_copy(loc.gfid, gfid);
+
+    if (!inode)
+        loc.inode = inode_new(itable);
+    else
+        loc.inode = inode_ref(inode);
+
+    if (!hard_resolve)
+        ret = syncop_getxattr(subvol, &loc, &xattr, GFID_TO_PATH_KEY, NULL,
+                              NULL);
+    else
+        ret = syncop_getxattr(subvol, &loc, &xattr, GFID2PATH_VIRT_XATTR_KEY,
+                              NULL, NULL);
+
+    if (ret < 0)
+        goto out;
+
+    /*
+     * posix will do dict_set_dynstr for GFID_TO_PATH_KEY i.e.
+     * for in memory search for the path. And for on disk xattr
+     * fetching of the path for the key GFID2PATH_VIRT_XATTR_KEY
+     * it uses dict_set_dynptr. So, for GFID2PATH_VIRT_XATTR_KEY
+     * use dict_get_ptr to avoid dict complaining about type
+     * mismatch (i.e. str vs ptr)
+     */
+    if (!hard_resolve)
+        ret = dict_get_str(xattr, GFID_TO_PATH_KEY, &path);
+    else
+        ret = dict_get_ptr(xattr, GFID2PATH_VIRT_XATTR_KEY, (void **)&path);
+
+    if (ret || !path) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (path_p) {
+        *path_p = gf_strdup(path);
+        if (!*path_p) {
+            ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        loc_wipe (&loc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 int
-syncop_inode_find (xlator_t *this, xlator_t *subvol,
-                   uuid_t gfid, inode_t **inode,
-                   dict_t *xdata, dict_t **rsp_dict)
+syncop_gfid_to_path(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                    char **path_p)
 {
-        int         ret    = 0;
-        loc_t       loc    = {0, };
-        struct iatt iatt   = {0, };
-	*inode =  NULL;
-
-        *inode = inode_find (this->itable, gfid);
-        if (*inode)
-                goto out;
-
-        loc.inode = inode_new (this->itable);
-        if (!loc.inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        gf_uuid_copy (loc.gfid, gfid);
-
-	ret = syncop_lookup (subvol, &loc, &iatt, NULL, xdata, rsp_dict);
-        if (ret < 0)
-                goto out;
+    return syncop_gfid_to_path_hard(itable, subvol, gfid, NULL, path_p,
+                                    _gf_false);
+}
 
-        *inode = inode_link (loc.inode, NULL, NULL, &iatt);
-        if (!*inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+int
+syncop_inode_find(xlator_t *this, xlator_t *subvol, uuid_t gfid,
+                  inode_t **inode, dict_t *xdata, dict_t **rsp_dict)
+{
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    *inode = NULL;
+
+    *inode = inode_find(this->itable, gfid);
+    if (*inode)
+        goto out;
+
+    loc.inode = inode_new(this->itable);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    gf_uuid_copy(loc.gfid, gfid);
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, xdata, rsp_dict);
+    if (ret < 0)
+        goto out;
+
+    *inode = inode_link(loc.inode, NULL, NULL, &iatt);
+    if (!*inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
 out:
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
diff --git a/libglusterfs/src/syncop-utils.h b/libglusterfs/src/syncop-utils.h
deleted file mode 100644
index 4761371c120..00000000000
--- a/libglusterfs/src/syncop-utils.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Copyright (c) 2015, Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _SYNCOP_UTILS_H
-#define _SYNCOP_UTILS_H
-
-typedef int (*syncop_dir_scan_fn_t) (xlator_t *subvol, gf_dirent_t *entry,
-                                     loc_t *parent, void *data);
-int
-syncop_ftw (xlator_t *subvol, loc_t *loc, int pid, void *data,
-            int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                       void *data));
-
-int
-syncop_mt_dir_scan (call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
-                    void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
-                    uint32_t max_jobs, uint32_t max_qlen);
-
-int
-syncop_dir_scan (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                 int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                            void *data));
-
-int
-syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid);
-
-int
-syncop_is_subvol_local (xlator_t *this, loc_t *loc, gf_boolean_t *is_local);
-
-int
-syncop_gfid_to_path (inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
-                     char **path_p);
-
-int
-syncop_ftw_throttle (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                     int (*fn) (xlator_t *subvol, gf_dirent_t *entry,
-                                loc_t *parent, void *data),
-                     int count, int sleep_time);
-int
-syncop_inode_find (xlator_t *this, xlator_t *subvol,
-                   uuid_t gfid, inode_t **inode,
-                   dict_t *xdata, dict_t **rsp_dict);
-#endif /* _SYNCOP_H */
diff --git a/libglusterfs/src/syncop.c b/libglusterfs/src/syncop.c
index b36c88dc829..df20cec559f 100644
--- a/libglusterfs/src/syncop.c
+++ b/libglusterfs/src/syncop.c
@@ -8,2653 +8,2855 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "syncop.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/syncop.h"
+#include "glusterfs/libglusterfs-messages.h"
+
+#ifdef HAVE_TSAN_API
+#include <sanitizer/tsan_interface.h>
+#endif
 
 int
-syncopctx_setfsuid (void *uid)
+syncopctx_setfsuid(void *uid)
 {
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
-
-	/* In args check */
-	if (!uid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-	opctx = syncopctx_getctx ();
+    /* In args check */
+    if (!uid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
+    opctx = syncopctx_getctx();
 
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+    opctx->uid = *(uid_t *)uid;
+    opctx->valid |= SYNCOPCTX_UID;
 
 out:
-	if (opctx && uid) {
-		opctx->uid = *(uid_t *)uid;
-		opctx->valid |= SYNCOPCTX_UID;
-	}
+    return ret;
+}
+
+int
+syncopctx_setfsgid(void *gid)
+{
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
+
+    /* In args check */
+    if (!gid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    opctx = syncopctx_getctx();
 
-	return ret;
+    opctx->gid = *(gid_t *)gid;
+    opctx->valid |= SYNCOPCTX_GID;
+
+out:
+    return ret;
 }
 
 int
-syncopctx_setfsgid (void *gid)
+syncopctx_setfsgroups(int count, const void *groups)
 {
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    gid_t *tmpgroups = NULL;
+    int ret = 0;
 
-	/* In args check */
-	if (!gid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    /* In args check */
+    if (count != 0 && !groups) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	opctx = syncopctx_getctx ();
+    opctx = syncopctx_getctx();
 
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
+    /* resize internal groups as required */
+    if (count && opctx->grpsize < count) {
+        if (opctx->groups) {
+            /* Group list will be updated later, so no need to keep current
+             * data and waste time copying it. It's better to free the current
+             * allocation and then allocate a fresh new memory block. */
+            GF_FREE(opctx->groups);
+            opctx->groups = NULL;
+            opctx->grpsize = 0;
+        }
+        tmpgroups = GF_MALLOC(count * sizeof(gid_t), gf_common_mt_syncopctx);
+        if (tmpgroups == NULL) {
+            ret = -1;
+            goto out;
+        }
 
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+        opctx->groups = tmpgroups;
+        opctx->grpsize = count;
+    }
 
-out:
-	if (opctx && gid) {
-		opctx->gid = *(gid_t *)gid;
-		opctx->valid |= SYNCOPCTX_GID;
-	}
-
-	return ret;
-}
-
-int
-syncopctx_setfsgroups (int count, const void *groups)
-{
-	struct syncopctx *opctx = NULL;
-	gid_t            *tmpgroups = NULL;
-	int               ret = 0;
-
-	/* In args check */
-	if (count != 0 && !groups) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	opctx = syncopctx_getctx ();
-
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
-
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
-
-	/* resize internal groups as required */
-	if (count && opctx->grpsize < count) {
-		if (opctx->groups) {
-			tmpgroups = GF_REALLOC (opctx->groups,
-						(sizeof (gid_t) * count));
-			/* NOTE: Not really required to zero the reallocation,
-			 * as ngrps controls the validity of data,
-			 * making a note irrespective */
-			if (tmpgroups == NULL) {
-				opctx->grpsize = 0;
-				GF_FREE (opctx->groups);
-				opctx->groups = NULL;
-				ret = -1;
-				goto out;
-			}
-		}
-		else {
-			tmpgroups = GF_CALLOC (count, sizeof (gid_t),
-					       gf_common_mt_syncopctx);
-			if (tmpgroups == NULL) {
-				opctx->grpsize = 0;
-				ret = -1;
-				goto out;
-			}
-		}
-
-		opctx->groups = tmpgroups;
-		opctx->grpsize = count;
-	}
-
-	/* copy out the groups passed */
-	if (count)
-		memcpy (opctx->groups, groups, (sizeof (gid_t) * count));
-
-	/* set/reset the ngrps, this is where reset of groups is handled */
-	opctx->ngrps = count;
-	opctx->valid |= SYNCOPCTX_GROUPS;
+    /* copy out the groups passed */
+    if (count)
+        memcpy(opctx->groups, groups, (sizeof(gid_t) * count));
+
+    /* set/reset the ngrps, this is where reset of groups is handled */
+    opctx->ngrps = count;
+
+    if ((opctx->valid & SYNCOPCTX_GROUPS) == 0) {
+        /* This is the first time we are storing groups into the TLS structure
+         * so we mark the current thread so that it will be properly cleaned
+         * up when the thread terminates. */
+        gf_thread_needs_cleanup();
+    }
+    opctx->valid |= SYNCOPCTX_GROUPS;
 
 out:
-	return ret;
+    return ret;
 }
 
 int
-syncopctx_setfspid (void *pid)
+syncopctx_setfspid(void *pid)
 {
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-	/* In args check */
-	if (!pid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    /* In args check */
+    if (!pid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	opctx = syncopctx_getctx ();
+    opctx = syncopctx_getctx();
 
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
-
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+    opctx->pid = *(pid_t *)pid;
+    opctx->valid |= SYNCOPCTX_PID;
 
 out:
-	if (opctx && pid) {
-		opctx->pid = *(pid_t *)pid;
-		opctx->valid |= SYNCOPCTX_PID;
-	}
-
-	return ret;
+    return ret;
 }
 
 int
-syncopctx_setfslkowner (gf_lkowner_t *lk_owner)
+syncopctx_setfslkowner(gf_lkowner_t *lk_owner)
 {
-        struct syncopctx *opctx = NULL;
-        int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-        /* In args check */
-        if (!lk_owner) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        opctx = syncopctx_getctx ();
+    /* In args check */
+    if (!lk_owner) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-        /* alloc for this thread the first time */
-        if (!opctx) {
-                opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-                if (!opctx) {
-                        ret = -1;
-                        goto out;
-                }
+    opctx = syncopctx_getctx();
 
-                ret = syncopctx_setctx (opctx);
-                if (ret != 0) {
-                        GF_FREE (opctx);
-                        opctx = NULL;
-                        goto out;
-                }
-        }
+    opctx->lk_owner = *lk_owner;
+    opctx->valid |= SYNCOPCTX_LKOWNER;
 
 out:
-        if (opctx && lk_owner) {
-                opctx->lk_owner = *lk_owner;
-                opctx->valid |= SYNCOPCTX_LKOWNER;
-        }
-
-        return ret;
+    return ret;
 }
 
+void *
+syncenv_processor(void *thdata);
+
 static void
-__run (struct synctask *task)
+__run(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
+    int32_t total, ret, i;
 
-        env = task->env;
+    env = task->env;
 
-        list_del_init (&task->all_tasks);
-        switch (task->state) {
+    list_del_init(&task->all_tasks);
+    switch (task->state) {
         case SYNCTASK_INIT:
         case SYNCTASK_SUSPEND:
-                break;
+            break;
         case SYNCTASK_RUN:
-                gf_msg_debug (task->xl->name, 0, "re-running already running"
-                              " task");
-                env->runcount--;
-                break;
+            gf_msg_debug(task->xl->name, 0,
+                         "re-running already running"
+                         " task");
+            env->runcount--;
+            break;
         case SYNCTASK_WAIT:
-                env->waitcount--;
-                break;
+            break;
         case SYNCTASK_DONE:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_COMPLETED_TASK, "running completed task");
-		return;
-	case SYNCTASK_ZOMBIE:
-		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_WAKE_UP_ZOMBIE, "attempted to wake up "
-                        "zombie!!");
-		return;
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_COMPLETED_TASK,
+                   "running completed task");
+            return;
+        case SYNCTASK_ZOMBIE:
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_WAKE_UP_ZOMBIE,
+                   "attempted to wake up "
+                   "zombie!!");
+            return;
+    }
+
+    list_add_tail(&task->all_tasks, &env->runq);
+    task->state = SYNCTASK_RUN;
+
+    env->runcount++;
+
+    total = env->procs + env->runcount - env->procs_idle;
+    if (total > env->procmax) {
+        total = env->procmax;
+    }
+    if (total > env->procs) {
+        for (i = 0; i < env->procmax; i++) {
+            if (env->proc[i].env == NULL) {
+                env->proc[i].env = env;
+                ret = gf_thread_create(&env->proc[i].processor, NULL,
+                                       syncenv_processor, &env->proc[i],
+                                       "sproc%d", i);
+                if ((ret < 0) || (++env->procs >= total)) {
+                    break;
+                }
+            }
         }
-
-        list_add_tail (&task->all_tasks, &env->runq);
-        env->runcount++;
-        task->state = SYNCTASK_RUN;
+    }
 }
 
-
 static void
-__wait (struct synctask *task)
+__wait(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        list_del_init (&task->all_tasks);
-        switch (task->state) {
+    list_del_init(&task->all_tasks);
+    switch (task->state) {
         case SYNCTASK_INIT:
         case SYNCTASK_SUSPEND:
-                break;
+            break;
         case SYNCTASK_RUN:
-                env->runcount--;
-                break;
+            env->runcount--;
+            break;
         case SYNCTASK_WAIT:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_REWAITING_TASK, "re-waiting already waiting "
-                        "task");
-                env->waitcount--;
-                break;
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_REWAITING_TASK,
+                   "re-waiting already waiting "
+                   "task");
+            break;
         case SYNCTASK_DONE:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_COMPLETED_TASK,
-                        "running completed task");
-                return;
-	case SYNCTASK_ZOMBIE:
-		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_SLEEP_ZOMBIE,
-			"attempted to sleep a zombie!!");
-		return;
-        }
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_COMPLETED_TASK,
+                   "running completed task");
+            return;
+        case SYNCTASK_ZOMBIE:
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_SLEEP_ZOMBIE,
+                   "attempted to sleep a zombie!!");
+            return;
+    }
 
-        list_add_tail (&task->all_tasks, &env->waitq);
-        env->waitcount++;
-        task->state = SYNCTASK_WAIT;
+    list_add_tail(&task->all_tasks, &env->waitq);
+    task->state = SYNCTASK_WAIT;
 }
 
-
 void
-synctask_yield (struct synctask *task)
+synctask_yield(struct synctask *task, struct timespec *delta)
 {
-        xlator_t *oldTHIS = THIS;
+    xlator_t *oldTHIS = THIS;
 
 #if defined(__NetBSD__) && defined(_UC_TLSBASE)
-        /* Preserve pthread private pointer through swapcontex() */
-        task->proc->sched.uc_flags &= ~_UC_TLSBASE;
+    /* Preserve pthread private pointer through swapcontex() */
+    task->proc->sched.uc_flags &= ~_UC_TLSBASE;
 #endif
 
-        if (task->state != SYNCTASK_DONE) {
-                task->state = SYNCTASK_SUSPEND;
-                (void) gf_backtrace_save (task->btbuf);
-        }
-        if (swapcontext (&task->ctx, &task->proc->sched) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_SWAPCONTEXT_FAILED, "swapcontext failed");
-        }
+    task->delta = delta;
 
-        THIS = oldTHIS;
-}
+    if (task->state != SYNCTASK_DONE) {
+        task->state = SYNCTASK_SUSPEND;
+    }
 
+#ifdef HAVE_TSAN_API
+    __tsan_switch_to_fiber(task->proc->tsan.fiber, 0);
+#endif
+
+    if (swapcontext(&task->ctx, &task->proc->sched) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_SWAPCONTEXT_FAILED,
+               "swapcontext failed");
+    }
+
+    THIS = oldTHIS;
+}
 
 void
-synctask_wake (struct synctask *task)
+synctask_sleep(int32_t secs)
 {
-        struct syncenv *env = NULL;
+    struct timespec delta;
+    struct synctask *task;
 
-        env = task->env;
+    task = synctask_get();
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                task->woken = 1;
+    if (task == NULL) {
+        sleep(secs);
+    } else {
+        delta.tv_sec = secs;
+        delta.tv_nsec = 0;
 
-                if (task->slept)
-                        __run (task);
+        synctask_yield(task, &delta);
+    }
+}
 
-		pthread_cond_broadcast (&env->cond);
-        }
-        pthread_mutex_unlock (&env->mutex);
+static void
+__synctask_wake(struct synctask *task)
+{
+    task->woken = 1;
+
+    if (task->slept)
+        __run(task);
+
+    pthread_cond_broadcast(&task->env->cond);
 }
 
 void
-synctask_wrap (void)
+synctask_wake(struct synctask *task)
 {
-        struct synctask *task = NULL;
+    struct syncenv *env = NULL;
 
-        /* Do not trust the pointer received. It may be
-           wrong and can lead to crashes. */
+    env = task->env;
 
-        task = synctask_get ();
-        task->ret = task->syncfn (task->opaque);
-        if (task->synccbk)
-                task->synccbk (task->ret, task->frame, task->opaque);
+    pthread_mutex_lock(&env->mutex);
+    {
+        if (task->timer != NULL) {
+            if (gf_timer_call_cancel(task->xl->ctx, task->timer) != 0) {
+                goto unlock;
+            }
 
-        task->state = SYNCTASK_DONE;
+            task->timer = NULL;
+            task->synccond = NULL;
+        }
 
-        synctask_yield (task);
+        __synctask_wake(task);
+    }
+unlock:
+    pthread_mutex_unlock(&env->mutex);
 }
 
-
 void
-synctask_destroy (struct synctask *task)
+synctask_wrap(void)
 {
-        if (!task)
-                return;
+    struct synctask *task = NULL;
 
-        GF_FREE (task->stack);
+    /* Do not trust the pointer received. It may be
+       wrong and can lead to crashes. */
 
-        if (task->opframe)
-                STACK_DESTROY (task->opframe->root);
+    task = synctask_get();
+    task->ret = task->syncfn(task->opaque);
+    if (task->synccbk)
+        task->synccbk(task->ret, task->frame, task->opaque);
 
-        if (task->synccbk == NULL) {
-               pthread_mutex_destroy (&task->mutex);
-               pthread_cond_destroy (&task->cond);
-        }
+    task->state = SYNCTASK_DONE;
 
-        GF_FREE (task);
+    synctask_yield(task, NULL);
 }
 
-
 void
-synctask_done (struct synctask *task)
+synctask_destroy(struct synctask *task)
 {
-        if (task->synccbk) {
-                synctask_destroy (task);
-                return;
-        }
+    if (!task)
+        return;
 
-        pthread_mutex_lock (&task->mutex);
-        {
-		task->state = SYNCTASK_ZOMBIE;
-                task->done = 1;
-                pthread_cond_broadcast (&task->cond);
-        }
-        pthread_mutex_unlock (&task->mutex);
+    GF_FREE(task->stack);
+
+    if (task->opframe)
+        STACK_DESTROY(task->opframe->root);
+
+    if (task->synccbk == NULL) {
+        pthread_mutex_destroy(&task->mutex);
+        pthread_cond_destroy(&task->cond);
+    }
+
+#ifdef HAVE_TSAN_API
+    __tsan_destroy_fiber(task->tsan.fiber);
+#endif
+
+    GF_FREE(task);
 }
 
+void
+synctask_done(struct synctask *task)
+{
+    if (task->synccbk) {
+        synctask_destroy(task);
+        return;
+    }
+
+    pthread_mutex_lock(&task->mutex);
+    {
+        task->state = SYNCTASK_ZOMBIE;
+        task->done = 1;
+        pthread_cond_broadcast(&task->cond);
+    }
+    pthread_mutex_unlock(&task->mutex);
+}
 
 int
-synctask_setid (struct synctask *task, uid_t uid, gid_t gid)
+synctask_setid(struct synctask *task, uid_t uid, gid_t gid)
 {
-        if (!task)
-                return -1;
+    if (!task)
+        return -1;
 
-        if (uid != -1)
-                task->uid = uid;
+    if (uid != -1)
+        task->uid = uid;
 
-        if (gid != -1)
-                task->gid = gid;
+    if (gid != -1)
+        task->gid = gid;
 
-        return 0;
+    return 0;
 }
 
-
 struct synctask *
-synctask_create (struct syncenv *env, size_t stacksize, synctask_fn_t fn,
-                 synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
+synctask_create(struct syncenv *env, size_t stacksize, synctask_fn_t fn,
+                synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
 {
-        struct synctask *newtask = NULL;
-        xlator_t        *this    = THIS;
-        int             destroymode = 0;
+    struct synctask *newtask = NULL;
+    xlator_t *this = THIS;
+    int destroymode = 0;
 
-        VALIDATE_OR_GOTO (env, err);
-        VALIDATE_OR_GOTO (fn, err);
+    VALIDATE_OR_GOTO(env, err);
+    VALIDATE_OR_GOTO(fn, err);
 
-        /* Check if the syncenv is in destroymode i.e. destroy is SET.
-         * If YES, then don't allow any new synctasks on it. Return NULL.
-         */
-        pthread_mutex_lock (&env->mutex);
-        {
-                destroymode = env->destroy;
-        }
-        pthread_mutex_unlock (&env->mutex);
+    /* Check if the syncenv is in destroymode i.e. destroy is SET.
+     * If YES, then don't allow any new synctasks on it. Return NULL.
+     */
+    pthread_mutex_lock(&env->mutex);
+    {
+        destroymode = env->destroy;
+    }
+    pthread_mutex_unlock(&env->mutex);
 
-        /* syncenv is in DESTROY mode, return from here */
-        if (destroymode)
-                return NULL;
+    /* syncenv is in DESTROY mode, return from here */
+    if (destroymode)
+        return NULL;
 
-        newtask = GF_CALLOC (1, sizeof (*newtask), gf_common_mt_synctask);
-        if (!newtask)
-                return NULL;
+    newtask = GF_CALLOC(1, sizeof(*newtask), gf_common_mt_synctask);
+    if (!newtask)
+        return NULL;
 
-        newtask->frame      = frame;
-        if (!frame) {
-                newtask->opframe = create_frame (this, this->ctx->pool);
-                set_lk_owner_from_ptr (&newtask->opframe->root->lk_owner,
-                                       newtask->opframe->root);
-        } else {
-                newtask->opframe = copy_frame (frame);
-        }
+    newtask->frame = frame;
+    if (!frame) {
+        newtask->opframe = create_frame(this, this->ctx->pool);
         if (!newtask->opframe)
-                goto err;
-        newtask->env        = env;
-        newtask->xl         = this;
-        newtask->syncfn     = fn;
-        newtask->synccbk    = cbk;
-        newtask->opaque     = opaque;
-
-        /* default to the uid/gid of the passed frame */
-        newtask->uid = newtask->opframe->root->uid;
-        newtask->gid = newtask->opframe->root->gid;
-
-        INIT_LIST_HEAD (&newtask->all_tasks);
-        INIT_LIST_HEAD (&newtask->waitq);
-
-        if (getcontext (&newtask->ctx) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_GETCONTEXT_FAILED, "getcontext failed");
-                goto err;
-        }
-
-        if (stacksize <= 0) {
-                newtask->stack = GF_CALLOC (1, env->stacksize,
-                                            gf_common_mt_syncstack);
-                newtask->ctx.uc_stack.ss_size = env->stacksize;
-        } else {
-                newtask->stack = GF_CALLOC (1, stacksize,
-                                            gf_common_mt_syncstack);
-                newtask->ctx.uc_stack.ss_size = stacksize;
-        }
-
-        if (!newtask->stack) {
-                goto err;
-        }
-
-        newtask->ctx.uc_stack.ss_sp   = newtask->stack;
-
-        makecontext (&newtask->ctx, (void (*)(void)) synctask_wrap, 0);
+            goto err;
+        set_lk_owner_from_ptr(&newtask->opframe->root->lk_owner,
+                              newtask->opframe->root);
+    } else {
+        newtask->opframe = copy_frame(frame);
+    }
+    if (!newtask->opframe)
+        goto err;
+    newtask->env = env;
+    newtask->xl = this;
+    newtask->syncfn = fn;
+    newtask->synccbk = cbk;
+    newtask->opaque = opaque;
+
+    /* default to the uid/gid of the passed frame */
+    newtask->uid = newtask->opframe->root->uid;
+    newtask->gid = newtask->opframe->root->gid;
+
+    INIT_LIST_HEAD(&newtask->all_tasks);
+    INIT_LIST_HEAD(&newtask->waitq);
+
+    if (getcontext(&newtask->ctx) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_GETCONTEXT_FAILED,
+               "getcontext failed");
+        goto err;
+    }
+
+    if (stacksize <= 0) {
+        newtask->stack = GF_CALLOC(1, env->stacksize, gf_common_mt_syncstack);
+        newtask->ctx.uc_stack.ss_size = env->stacksize;
+    } else {
+        newtask->stack = GF_CALLOC(1, stacksize, gf_common_mt_syncstack);
+        newtask->ctx.uc_stack.ss_size = stacksize;
+    }
+
+    if (!newtask->stack) {
+        goto err;
+    }
+
+    newtask->ctx.uc_stack.ss_sp = newtask->stack;
+
+    makecontext(&newtask->ctx, (void (*)(void))synctask_wrap, 0);
+
+#ifdef HAVE_TSAN_API
+    newtask->tsan.fiber = __tsan_create_fiber(0);
+    snprintf(newtask->tsan.name, TSAN_THREAD_NAMELEN, "<synctask of %s>",
+             this->name);
+    __tsan_set_fiber_name(newtask->tsan.fiber, newtask->tsan.name);
+#endif
 
-        newtask->state = SYNCTASK_INIT;
+    newtask->state = SYNCTASK_INIT;
 
-        newtask->slept = 1;
+    newtask->slept = 1;
 
-        if (!cbk) {
-                pthread_mutex_init (&newtask->mutex, NULL);
-                pthread_cond_init (&newtask->cond, NULL);
-                newtask->done = 0;
-        }
+    if (!cbk) {
+        pthread_mutex_init(&newtask->mutex, NULL);
+        pthread_cond_init(&newtask->cond, NULL);
+        newtask->done = 0;
+    }
 
-        synctask_wake (newtask);
-        /*
-         * Make sure someone's there to execute anything we just put on the
-         * run queue.
-         */
-        syncenv_scale(env);
+    synctask_wake(newtask);
 
-	return newtask;
+    return newtask;
 err:
-        if (newtask) {
-                GF_FREE (newtask->stack);
-                if (newtask->opframe)
-                        STACK_DESTROY (newtask->opframe->root);
-                GF_FREE (newtask);
-        }
+    if (newtask) {
+        GF_FREE(newtask->stack);
+        if (newtask->opframe)
+            STACK_DESTROY(newtask->opframe->root);
+        GF_FREE(newtask);
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 int
-synctask_join (struct synctask *task)
+synctask_join(struct synctask *task)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&task->mutex);
-	{
-		while (!task->done)
-			pthread_cond_wait (&task->cond, &task->mutex);
-	}
-	pthread_mutex_unlock (&task->mutex);
+    pthread_mutex_lock(&task->mutex);
+    {
+        while (!task->done)
+            pthread_cond_wait(&task->cond, &task->mutex);
+    }
+    pthread_mutex_unlock(&task->mutex);
 
-	ret = task->ret;
+    ret = task->ret;
 
-	synctask_destroy (task);
+    synctask_destroy(task);
 
-	return ret;
+    return ret;
 }
 
-
 int
-synctask_new1 (struct syncenv *env, size_t stacksize, synctask_fn_t fn,
-                synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
+synctask_new1(struct syncenv *env, size_t stacksize, synctask_fn_t fn,
+              synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
 {
-	struct synctask *newtask = NULL;
-	int              ret = 0;
+    struct synctask *newtask = NULL;
+    int ret = 0;
 
-	newtask = synctask_create (env, stacksize, fn, cbk, frame, opaque);
-	if (!newtask)
-		return -1;
+    newtask = synctask_create(env, stacksize, fn, cbk, frame, opaque);
+    if (!newtask)
+        return -1;
 
-        if (!cbk)
-		ret = synctask_join (newtask);
+    if (!cbk)
+        ret = synctask_join(newtask);
 
-        return ret;
+    return ret;
 }
 
-
 int
-synctask_new (struct syncenv *env, synctask_fn_t fn, synctask_cbk_t cbk,
-              call_frame_t *frame, void *opaque)
+synctask_new(struct syncenv *env, synctask_fn_t fn, synctask_cbk_t cbk,
+             call_frame_t *frame, void *opaque)
 {
-        return synctask_new1 (env, 0, fn, cbk, frame, opaque);
+    return synctask_new1(env, 0, fn, cbk, frame, opaque);
 }
 
 struct synctask *
-syncenv_task (struct syncproc *proc)
+syncenv_task(struct syncproc *proc)
+{
+    struct syncenv *env = NULL;
+    struct synctask *task = NULL;
+    struct timespec sleep_till = {
+        0,
+    };
+    int ret = 0;
+
+    env = proc->env;
+
+    pthread_mutex_lock(&env->mutex);
+    {
+        while (list_empty(&env->runq)) {
+            /* If either of the conditions are met then exit
+             * the current thread:
+             * 1. syncenv has to scale down(procs > procmin)
+             * 2. syncenv is in destroy mode and no tasks in
+             *    either waitq or runq.
+             *
+             * At any point in time, a task can be either in runq,
+             * or in executing state or in the waitq. Once the
+             * destroy mode is set, no new synctask creates will
+             * be allowed, but whatever in waitq or runq should be
+             * allowed to finish before exiting any of the syncenv
+             * processor threads.
+             */
+            if (((ret == ETIMEDOUT) && (env->procs > env->procmin)) ||
+                (env->destroy && list_empty(&env->waitq))) {
+                task = NULL;
+                env->procs--;
+                memset(proc, 0, sizeof(*proc));
+                pthread_cond_broadcast(&env->cond);
+                goto unlock;
+            }
+
+            env->procs_idle++;
+
+            sleep_till.tv_sec = gf_time() + SYNCPROC_IDLE_TIME;
+            ret = pthread_cond_timedwait(&env->cond, &env->mutex, &sleep_till);
+
+            env->procs_idle--;
+        }
+
+        task = list_entry(env->runq.next, struct synctask, all_tasks);
+
+        list_del_init(&task->all_tasks);
+        env->runcount--;
+
+        task->woken = 0;
+        task->slept = 0;
+
+        task->proc = proc;
+    }
+unlock:
+    pthread_mutex_unlock(&env->mutex);
+
+    return task;
+}
+
+static void
+synctask_timer(void *data)
 {
-        struct syncenv   *env = NULL;
-        struct synctask  *task = NULL;
-        struct timespec   sleep_till = {0, };
-        int               ret = 0;
+    struct synctask *task = data;
+    struct synccond *cond;
 
-        env = proc->env;
+    cond = task->synccond;
+    if (cond != NULL) {
+        pthread_mutex_lock(&cond->pmutex);
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                while (list_empty (&env->runq)) {
-                        sleep_till.tv_sec = time (NULL) + SYNCPROC_IDLE_TIME;
-                        ret = pthread_cond_timedwait (&env->cond, &env->mutex,
-                                                      &sleep_till);
-                        if (!list_empty (&env->runq))
-                                break;
-                        /* If either of the conditions are met then exit
-                         * the current thread:
-                         * 1. syncenv has to scale down(procs > procmin)
-                         * 2. syncenv is in destroy mode and no tasks in
-                         *    either waitq or runq.
-                         *
-                         * At any point in time, a task can be either in runq,
-                         * or in executing state or in the waitq. Once the
-                         * destroy mode is set, no new synctask creates will
-                         * be allowed, but whatever in waitq or runq should be
-                         * allowed to finish before exiting any of the syncenv
-                         * processor threads.
-                         */
-                        if (((ret == ETIMEDOUT) && (env->procs > env->procmin))
-                            || (env->destroy && list_empty (&env->waitq))) {
-                                task = NULL;
-                                env->procs--;
-                                memset (proc, 0, sizeof (*proc));
-                                pthread_cond_broadcast (&env->cond);
-                                goto unlock;
-                        }
-                }
+        list_del_init(&task->waitq);
+        task->synccond = NULL;
 
-                task = list_entry (env->runq.next, struct synctask, all_tasks);
+        pthread_mutex_unlock(&cond->pmutex);
 
-                list_del_init (&task->all_tasks);
-                env->runcount--;
+        task->ret = -ETIMEDOUT;
+    }
 
-                task->woken = 0;
-                task->slept = 0;
+    pthread_mutex_lock(&task->env->mutex);
 
-                task->proc = proc;
-        }
-unlock:
-        pthread_mutex_unlock (&env->mutex);
+    gf_timer_call_cancel(task->xl->ctx, task->timer);
+    task->timer = NULL;
 
-        return task;
-}
+    __synctask_wake(task);
 
+    pthread_mutex_unlock(&task->env->mutex);
+}
 
 void
-synctask_switchto (struct synctask *task)
+synctask_switchto(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        synctask_set (task);
-        THIS = task->xl;
+    synctask_set(task);
+    THIS = task->xl;
 
 #if defined(__NetBSD__) && defined(_UC_TLSBASE)
-        /* Preserve pthread private pointer through swapcontex() */
-        task->ctx.uc_flags &= ~_UC_TLSBASE;
+    /* Preserve pthread private pointer through swapcontex() */
+    task->ctx.uc_flags &= ~_UC_TLSBASE;
 #endif
 
-        if (swapcontext (&task->proc->sched, &task->ctx) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_SWAPCONTEXT_FAILED, "swapcontext failed");
-        }
+#ifdef HAVE_TSAN_API
+    __tsan_switch_to_fiber(task->tsan.fiber, 0);
+#endif
 
-        if (task->state == SYNCTASK_DONE) {
-                synctask_done (task);
-                return;
-        }
+    if (swapcontext(&task->proc->sched, &task->ctx) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_SWAPCONTEXT_FAILED,
+               "swapcontext failed");
+    }
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                if (task->woken) {
-                        __run (task);
-                } else {
-                        task->slept = 1;
-                        __wait (task);
-                }
+    if (task->state == SYNCTASK_DONE) {
+        synctask_done(task);
+        return;
+    }
+
+    pthread_mutex_lock(&env->mutex);
+    {
+        if (task->woken) {
+            __run(task);
+        } else {
+            task->slept = 1;
+            __wait(task);
+
+            if (task->delta != NULL) {
+                task->timer = gf_timer_call_after(task->xl->ctx, *task->delta,
+                                                  synctask_timer, task);
+            }
         }
-        pthread_mutex_unlock (&env->mutex);
+
+        task->delta = NULL;
+    }
+    pthread_mutex_unlock(&env->mutex);
 }
 
 void *
-syncenv_processor (void *thdata)
+syncenv_processor(void *thdata)
 {
-        struct syncenv  *env = NULL;
-        struct syncproc *proc = NULL;
-        struct synctask *task = NULL;
+    struct syncproc *proc = NULL;
+    struct synctask *task = NULL;
 
-        proc = thdata;
-        env = proc->env;
+    proc = thdata;
 
-        for (;;) {
-                task = syncenv_task (proc);
-                if (!task)
-                        break;
+#ifdef HAVE_TSAN_API
+    proc->tsan.fiber = __tsan_create_fiber(0);
+    snprintf(proc->tsan.name, TSAN_THREAD_NAMELEN, "<sched of syncenv@%p>",
+             proc);
+    __tsan_set_fiber_name(proc->tsan.fiber, proc->tsan.name);
+#endif
 
-                synctask_switchto (task);
+    while ((task = syncenv_task(proc)) != NULL) {
+        synctask_switchto(task);
+    }
 
-                syncenv_scale (env);
-        }
+#ifdef HAVE_TSAN_API
+    __tsan_destroy_fiber(proc->tsan.fiber);
+#endif
 
-        return NULL;
+    return NULL;
 }
 
-
+/* The syncenv threads are cleaned up in this routine.
+ */
 void
-syncenv_scale (struct syncenv *env)
+syncenv_destroy(struct syncenv *env)
 {
-        int  diff = 0;
-        int  scale = 0;
-        int  i = 0;
-        int  ret = 0;
-        char thread_name[GF_THREAD_NAMEMAX] = {0,};
+    if (env == NULL)
+        return;
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                if (env->procs > env->runcount)
-                        goto unlock;
-
-                scale = env->runcount;
-                if (scale > env->procmax)
-                        scale = env->procmax;
-                if (scale > env->procs)
-                        diff = scale - env->procs;
-                while (diff) {
-                        diff--;
-                        for (; (i < env->procmax); i++) {
-                                if (env->proc[i].processor == 0)
-                                        break;
-                        }
-
-                        env->proc[i].env = env;
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "%s%d", "sproc", env->procs);
-                        ret = gf_thread_create (&env->proc[i].processor, NULL,
-                                                syncenv_processor,
-                                                &env->proc[i], thread_name);
-                        if (ret)
-                                break;
-                        env->procs++;
-                        i++;
-                }
-        }
-unlock:
-        pthread_mutex_unlock (&env->mutex);
-}
+    /* SET the 'destroy' in syncenv structure to prohibit any
+     * further synctask(s) on this syncenv which is in destroy mode.
+     *
+     * If syncenv threads are in pthread cond wait with no tasks in
+     * their run or wait queue, then the threads are woken up by
+     * broadcasting the cond variable and if destroy field is set,
+     * the infinite loop in syncenv_processor is broken and the
+     * threads return.
+     *
+     * If syncenv threads have tasks in runq or waitq, the tasks are
+     * completed and only then the thread returns.
+     */
+    pthread_mutex_lock(&env->mutex);
+    {
+        env->destroy = 1;
+        /* This broadcast will wake threads in pthread_cond_wait
+         * in syncenv_task
+         */
+        pthread_cond_broadcast(&env->cond);
 
-/* The syncenv threads are cleaned up in this routine.
- */
-void
-syncenv_destroy (struct syncenv *env)
-{
-
-        if (env == NULL)
-                return;
-
-        /* SET the 'destroy' in syncenv structure to prohibit any
-         * further synctask(s) on this syncenv which is in destroy mode.
-         *
-         * If syncenv threads are in pthread cond wait with no tasks in
-         * their run or wait queue, then the threads are woken up by
-         * broadcasting the cond variable and if destroy field is set,
-         * the infinite loop in syncenv_processor is broken and the
-         * threads return.
-         *
-         * If syncenv threads have tasks in runq or waitq, the tasks are
-         * completed and only then the thread returns.
+        /* when the syncenv_task() thread is exiting, it broadcasts to
+         * wake the below wait.
          */
-        pthread_mutex_lock (&env->mutex);
-        {
-                env->destroy = 1;
-                /* This broadcast will wake threads in pthread_cond_wait
-                 * in syncenv_task
-                 */
-                pthread_cond_broadcast (&env->cond);
-
-                /* when the syncenv_task() thread is exiting, it broadcasts to
-                 * wake the below wait.
-                 */
-                while (env->procs != 0) {
-                        pthread_cond_wait (&env->cond, &env->mutex);
-                }
+        while (env->procs != 0) {
+            pthread_cond_wait(&env->cond, &env->mutex);
         }
-        pthread_mutex_unlock (&env->mutex);
+    }
+    pthread_mutex_unlock(&env->mutex);
 
-        pthread_mutex_destroy (&env->mutex);
-        pthread_cond_destroy (&env->cond);
+    pthread_mutex_destroy(&env->mutex);
+    pthread_cond_destroy(&env->cond);
 
-        GF_FREE (env);
+    GF_FREE(env);
 
-        return;
+    return;
 }
 
-
 struct syncenv *
-syncenv_new (size_t stacksize, int procmin, int procmax)
-{
-        struct syncenv *newenv = NULL;
-        int             ret = 0;
-        int             i = 0;
-        char            thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-	if (!procmin || procmin < 0)
-		procmin = SYNCENV_PROC_MIN;
-	if (!procmax || procmax > SYNCENV_PROC_MAX)
-		procmax = SYNCENV_PROC_MAX;
-
-	if (procmin > procmax)
-		return NULL;
-
-        newenv = GF_CALLOC (1, sizeof (*newenv), gf_common_mt_syncenv);
-
-        if (!newenv)
-                return NULL;
-
-        pthread_mutex_init (&newenv->mutex, NULL);
-        pthread_cond_init (&newenv->cond, NULL);
-
-        INIT_LIST_HEAD (&newenv->runq);
-        INIT_LIST_HEAD (&newenv->waitq);
-
-        newenv->stacksize    = SYNCENV_DEFAULT_STACKSIZE;
-        if (stacksize)
-                newenv->stacksize = stacksize;
-	newenv->procmin = procmin;
-	newenv->procmax = procmax;
-
-        for (i = 0; i < newenv->procmin; i++) {
-                newenv->proc[i].env = newenv;
-                snprintf (thread_name, sizeof(thread_name),
-                          "%s%d", "sproc", (newenv->procs));
-                ret = gf_thread_create (&newenv->proc[i].processor, NULL,
-                                        syncenv_processor, &newenv->proc[i],
-                                        thread_name);
-                if (ret)
-                        break;
-                newenv->procs++;
-        }
+syncenv_new(size_t stacksize, int procmin, int procmax)
+{
+    struct syncenv *newenv = NULL;
+    int ret = 0;
+    int i = 0;
 
-        if (ret != 0) {
-                syncenv_destroy (newenv);
-                newenv = NULL;
-        }
+    if (!procmin || procmin < 0)
+        procmin = SYNCENV_PROC_MIN;
+    if (!procmax || procmax > SYNCENV_PROC_MAX)
+        procmax = SYNCENV_PROC_MAX;
 
-        return newenv;
-}
+    if (procmin > procmax)
+        return NULL;
+
+    newenv = GF_CALLOC(1, sizeof(*newenv), gf_common_mt_syncenv);
+
+    if (!newenv)
+        return NULL;
+
+    pthread_mutex_init(&newenv->mutex, NULL);
+    pthread_cond_init(&newenv->cond, NULL);
+
+    INIT_LIST_HEAD(&newenv->runq);
+    INIT_LIST_HEAD(&newenv->waitq);
+
+    newenv->stacksize = SYNCENV_DEFAULT_STACKSIZE;
+    if (stacksize)
+        newenv->stacksize = stacksize;
+    newenv->procmin = procmin;
+    newenv->procmax = procmax;
+    newenv->procs_idle = 0;
+
+    for (i = 0; i < newenv->procmin; i++) {
+        newenv->proc[i].env = newenv;
+        ret = gf_thread_create(&newenv->proc[i].processor, NULL,
+                               syncenv_processor, &newenv->proc[i], "sproc%d",
+                               i);
+        if (ret)
+            break;
+        newenv->procs++;
+    }
 
+    if (ret != 0) {
+        syncenv_destroy(newenv);
+        newenv = NULL;
+    }
+
+    return newenv;
+}
 
 int
-synclock_init (synclock_t *lock, lock_attr_t attr)
+synclock_init(synclock_t *lock, lock_attr_t attr)
 {
-        if (!lock)
-               return -1;
+    if (!lock)
+        return -1;
 
-        pthread_cond_init (&lock->cond, 0);
-        lock->type = LOCK_NULL;
-        lock->owner = NULL;
-        lock->owner_tid = 0;
-        lock->lock = 0;
-        lock->attr = attr;
-        INIT_LIST_HEAD (&lock->waitq);
+    pthread_cond_init(&lock->cond, 0);
+    lock->type = LOCK_NULL;
+    lock->owner = NULL;
+    lock->owner_tid = 0;
+    lock->lock = 0;
+    lock->attr = attr;
+    INIT_LIST_HEAD(&lock->waitq);
 
-        return pthread_mutex_init (&lock->guard, 0);
+    return pthread_mutex_init(&lock->guard, 0);
 }
 
-
 int
-synclock_destroy (synclock_t *lock)
+synclock_destroy(synclock_t *lock)
 {
-	if (!lock)
-		return -1;
+    if (!lock)
+        return -1;
 
-	pthread_cond_destroy (&lock->cond);
-	return pthread_mutex_destroy (&lock->guard);
+    pthread_cond_destroy(&lock->cond);
+    return pthread_mutex_destroy(&lock->guard);
 }
 
-
 static int
-__synclock_lock (struct synclock *lock)
-{
-        struct synctask *task = NULL;
-
-        if (!lock)
-                return -1;
-
-        task = synctask_get ();
-
-        if (lock->lock && (lock->attr == SYNC_LOCK_RECURSIVE)) {
-                /*Recursive lock (if same owner requested for lock again then
-                 *increment lock count and return success).
-                 *Note:same number of unlocks required.
-                 */
-                switch (lock->type) {
-                case LOCK_TASK:
-                        if (task == lock->owner) {
-                                lock->lock++;
-                                gf_msg_trace ("", 0, "Recursive lock called by"
-                                              " sync task.owner= %p,lock=%d",
-                                              lock->owner, lock->lock);
-                                return 0;
-                        }
-                        break;
-                case LOCK_THREAD:
-                        if (pthread_equal(pthread_self (), lock->owner_tid)) {
-                                lock->lock++;
-                                gf_msg_trace ("", 0, "Recursive lock called by"
-                                              " thread ,owner=%u lock=%d",
-                                              (unsigned int) lock->owner_tid,
-                                              lock->lock);
-                                return 0;
-                        }
-                        break;
-                default:
-                        gf_msg ("", GF_LOG_CRITICAL, 0,
-                                LG_MSG_UNKNOWN_LOCK_TYPE, "unknown lock type");
-                        break;
-                }
-        }
+__synclock_lock(struct synclock *lock)
+{
+    struct synctask *task = NULL;
 
+    if (!lock)
+        return -1;
 
-        while (lock->lock) {
-                if (task) {
-                        /* called within a synctask */
-                        task->woken = 0;
-                        list_add_tail (&task->waitq, &lock->waitq);
-                        pthread_mutex_unlock (&lock->guard);
-                        synctask_yield (task);
-                        /* task is removed from waitq in unlock,
-                         * under lock->guard.*/
-                        pthread_mutex_lock (&lock->guard);
-                } else {
-                        /* called by a non-synctask */
-                        pthread_cond_wait (&lock->cond, &lock->guard);
+    task = synctask_get();
+
+    if (lock->lock && (lock->attr == SYNC_LOCK_RECURSIVE)) {
+        /*Recursive lock (if same owner requested for lock again then
+         *increment lock count and return success).
+         *Note:same number of unlocks required.
+         */
+        switch (lock->type) {
+            case LOCK_TASK:
+                if (task == lock->owner) {
+                    lock->lock++;
+                    gf_msg_trace("", 0,
+                                 "Recursive lock called by"
+                                 " sync task.owner= %p,lock=%d",
+                                 lock->owner, lock->lock);
+                    return 0;
+                }
+                break;
+            case LOCK_THREAD:
+                if (pthread_equal(pthread_self(), lock->owner_tid)) {
+                    lock->lock++;
+                    gf_msg_trace("", 0,
+                                 "Recursive lock called by"
+                                 " thread ,owner=%u lock=%d",
+                                 (unsigned int)lock->owner_tid, lock->lock);
+                    return 0;
                 }
+                break;
+            default:
+                gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_UNKNOWN_LOCK_TYPE,
+                       "unknown lock type");
+                break;
         }
+    }
 
+    while (lock->lock) {
         if (task) {
-                lock->type = LOCK_TASK;
-                lock->owner = task;    /* for synctask*/
-
+            /* called within a synctask */
+            task->woken = 0;
+            list_add_tail(&task->waitq, &lock->waitq);
+            pthread_mutex_unlock(&lock->guard);
+            synctask_yield(task, NULL);
+            /* task is removed from waitq in unlock,
+             * under lock->guard.*/
+            pthread_mutex_lock(&lock->guard);
         } else {
-                lock->type = LOCK_THREAD;
-                lock->owner_tid = pthread_self (); /* for non-synctask */
-
+            /* called by a non-synctask */
+            pthread_cond_wait(&lock->cond, &lock->guard);
         }
-        lock->lock = 1;
+    }
 
-        return 0;
+    if (task) {
+        lock->type = LOCK_TASK;
+        lock->owner = task; /* for synctask*/
+
+    } else {
+        lock->type = LOCK_THREAD;
+        lock->owner_tid = pthread_self(); /* for non-synctask */
+    }
+    lock->lock = 1;
+
+    return 0;
 }
 
+int
+synclock_lock(synclock_t *lock)
+{
+    int ret = 0;
+
+    pthread_mutex_lock(&lock->guard);
+    {
+        ret = __synclock_lock(lock);
+    }
+    pthread_mutex_unlock(&lock->guard);
+
+    return ret;
+}
 
 int
-synclock_lock (synclock_t *lock)
+synclock_trylock(synclock_t *lock)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_lock (lock);
-	}
-	pthread_mutex_unlock (&lock->guard);
+    errno = 0;
 
-	return ret;
+    pthread_mutex_lock(&lock->guard);
+    {
+        if (lock->lock) {
+            errno = EBUSY;
+            ret = -1;
+            goto unlock;
+        }
+
+        ret = __synclock_lock(lock);
+    }
+unlock:
+    pthread_mutex_unlock(&lock->guard);
+
+    return ret;
 }
 
+static int
+__synclock_unlock(synclock_t *lock)
+{
+    struct synctask *task = NULL;
+    struct synctask *curr = NULL;
+
+    if (!lock)
+        return -1;
+
+    if (lock->lock == 0) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_UNLOCK_BEFORE_LOCK,
+               "Unlock called  before lock ");
+        return -1;
+    }
+    curr = synctask_get();
+    /*unlock should be called by lock owner
+     *i.e this will not allow the lock in nonsync task and unlock
+     * in sync task and vice-versa
+     */
+    switch (lock->type) {
+        case LOCK_TASK:
+            if (curr == lock->owner) {
+                lock->lock--;
+                gf_msg_trace("", 0,
+                             "Unlock success %p, remaining"
+                             " locks=%d",
+                             lock->owner, lock->lock);
+            } else {
+                gf_msg("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                       "Unlock called by %p, but lock held by %p", curr,
+                       lock->owner);
+            }
+
+            break;
+        case LOCK_THREAD:
+            if (pthread_equal(pthread_self(), lock->owner_tid)) {
+                lock->lock--;
+                gf_msg_trace("", 0,
+                             "Unlock success %u, remaining "
+                             "locks=%d",
+                             (unsigned int)lock->owner_tid, lock->lock);
+            } else {
+                gf_msg("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                       "Unlock called by %u, but lock held by %u",
+                       (unsigned int)pthread_self(),
+                       (unsigned int)lock->owner_tid);
+            }
+
+            break;
+        default:
+            break;
+    }
+
+    if (lock->lock > 0) {
+        return 0;
+    }
+    lock->type = LOCK_NULL;
+    lock->owner = NULL;
+    lock->owner_tid = 0;
+    lock->lock = 0;
+    /* There could be both synctasks and non synctasks
+       waiting (or none, or either). As a mid-approach
+       between maintaining too many waiting counters
+       at one extreme and a thundering herd on unlock
+       at the other, call a cond_signal (which wakes
+       one waiter) and first synctask waiter. So at
+       most we have two threads waking up to grab the
+       just released lock.
+    */
+    pthread_cond_signal(&lock->cond);
+    if (!list_empty(&lock->waitq)) {
+        task = list_entry(lock->waitq.next, struct synctask, waitq);
+        list_del_init(&task->waitq);
+        synctask_wake(task);
+    }
+
+    return 0;
+}
 
 int
-synclock_trylock (synclock_t *lock)
+synclock_unlock(synclock_t *lock)
 {
-	int ret = 0;
+    int ret = 0;
 
-	errno = 0;
+    pthread_mutex_lock(&lock->guard);
+    {
+        ret = __synclock_unlock(lock);
+    }
+    pthread_mutex_unlock(&lock->guard);
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		if (lock->lock) {
-			errno = EBUSY;
-			ret = -1;
-			goto unlock;
-		}
+    return ret;
+}
 
-		ret = __synclock_lock (lock);
-	}
-unlock:
-	pthread_mutex_unlock (&lock->guard);
+/* Condition variables */
+
+int32_t
+synccond_init(synccond_t *cond)
+{
+    int32_t ret;
+
+    INIT_LIST_HEAD(&cond->waitq);
+
+    ret = pthread_mutex_init(&cond->pmutex, NULL);
+    if (ret != 0) {
+        return -ret;
+    }
 
-	return ret;
+    ret = pthread_cond_init(&cond->pcond, NULL);
+    if (ret != 0) {
+        pthread_mutex_destroy(&cond->pmutex);
+    }
+
+    return -ret;
 }
 
+void
+synccond_destroy(synccond_t *cond)
+{
+    pthread_cond_destroy(&cond->pcond);
+    pthread_mutex_destroy(&cond->pmutex);
+}
 
-static int
-__synclock_unlock (synclock_t *lock)
+int
+synccond_timedwait(synccond_t *cond, synclock_t *lock, struct timespec *delta)
 {
-        struct synctask *task = NULL;
-        struct synctask *curr = NULL;
+    struct timespec now;
+    struct synctask *task = NULL;
+    int ret;
 
-        if (!lock)
-               return -1;
+    task = synctask_get();
 
-        if (lock->lock == 0) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_UNLOCK_BEFORE_LOCK,
-                        "Unlock called  before lock ");
-                return -1;
+    if (task == NULL) {
+        if (delta != NULL) {
+            timespec_now_realtime(&now);
+            timespec_adjust_delta(&now, *delta);
         }
-        curr = synctask_get ();
-        /*unlock should be called by lock owner
-         *i.e this will not allow the lock in nonsync task and unlock
-         * in sync task and vice-versa
-         */
-        switch (lock->type) {
-        case LOCK_TASK:
-                if (curr == lock->owner) {
-                        lock->lock--;
-                        gf_msg_trace ("", 0, "Unlock success %p, remaining"
-                                      " locks=%d", lock->owner, lock->lock);
-                } else {
-                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
-                                "Unlock called by %p, but lock held by %p",
-                                curr, lock->owner);
-                }
 
-                break;
-        case LOCK_THREAD:
-                if (pthread_equal(pthread_self (), lock->owner_tid)) {
-                        lock->lock--;
-                        gf_msg_trace ("", 0, "Unlock success %u, remaining "
-                                      "locks=%d",
-                                      (unsigned int)lock->owner_tid,
-                                      lock->lock);
-                } else {
-                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
-                                "Unlock called by %u, but lock held by %u",
-                                (unsigned int) pthread_self(),
-                                (unsigned int) lock->owner_tid);
-                }
+        pthread_mutex_lock(&cond->pmutex);
 
-                break;
-        default:
-                break;
+        if (delta == NULL) {
+            ret = -pthread_cond_wait(&cond->pcond, &cond->pmutex);
+        } else {
+            ret = -pthread_cond_timedwait(&cond->pcond, &cond->pmutex, &now);
         }
+    } else {
+        pthread_mutex_lock(&cond->pmutex);
 
-        if (lock->lock > 0) {
-                 return 0;
-        }
-        lock->type = LOCK_NULL;
-        lock->owner = NULL;
-        lock->owner_tid = 0;
-        lock->lock = 0;
-        /* There could be both synctasks and non synctasks
-           waiting (or none, or either). As a mid-approach
-           between maintaining too many waiting counters
-           at one extreme and a thundering herd on unlock
-           at the other, call a cond_signal (which wakes
-           one waiter) and first synctask waiter. So at
-           most we have two threads waking up to grab the
-           just released lock.
-        */
-        pthread_cond_signal (&lock->cond);
-        if (!list_empty (&lock->waitq)) {
-                task = list_entry (lock->waitq.next, struct synctask, waitq);
-                list_del_init (&task->waitq);
-                synctask_wake (task);
+        list_add_tail(&task->waitq, &cond->waitq);
+        task->synccond = cond;
+
+        ret = synclock_unlock(lock);
+        if (ret == 0) {
+            pthread_mutex_unlock(&cond->pmutex);
+
+            synctask_yield(task, delta);
+
+            ret = synclock_lock(lock);
+            if (ret == 0) {
+                ret = task->ret;
+            }
+            task->ret = 0;
+
+            return ret;
         }
 
-        return 0;
-}
+        list_del_init(&task->waitq);
+    }
 
+    pthread_mutex_unlock(&cond->pmutex);
+
+    return ret;
+}
 
 int
-synclock_unlock (synclock_t *lock)
+synccond_wait(synccond_t *cond, synclock_t *lock)
+{
+    return synccond_timedwait(cond, lock, NULL);
+}
+
+void
+synccond_signal(synccond_t *cond)
+{
+    struct synctask *task;
+
+    pthread_mutex_lock(&cond->pmutex);
+
+    if (!list_empty(&cond->waitq)) {
+        task = list_first_entry(&cond->waitq, struct synctask, waitq);
+        list_del_init(&task->waitq);
+
+        pthread_mutex_unlock(&cond->pmutex);
+
+        synctask_wake(task);
+    } else {
+        pthread_cond_signal(&cond->pcond);
+
+        pthread_mutex_unlock(&cond->pmutex);
+    }
+}
+
+void
+synccond_broadcast(synccond_t *cond)
 {
-	int ret = 0;
+    struct list_head list;
+    struct synctask *task;
+
+    INIT_LIST_HEAD(&list);
+
+    pthread_mutex_lock(&cond->pmutex);
+
+    list_splice_init(&cond->waitq, &list);
+    pthread_cond_broadcast(&cond->pcond);
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_unlock (lock);
-	}
-	pthread_mutex_unlock (&lock->guard);
+    pthread_mutex_unlock(&cond->pmutex);
 
-	return ret;
+    while (!list_empty(&list)) {
+        task = list_first_entry(&list, struct synctask, waitq);
+        list_del_init(&task->waitq);
+
+        synctask_wake(task);
+    }
 }
 
 /* Barriers */
 
 int
-syncbarrier_init (struct syncbarrier *barrier)
+syncbarrier_init(struct syncbarrier *barrier)
 {
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	pthread_cond_init (&barrier->cond, 0);
-	barrier->count = 0;
-        barrier->waitfor = 0;
-	INIT_LIST_HEAD (&barrier->waitq);
+    ret = pthread_cond_init(&barrier->cond, 0);
+    if (ret) {
+        errno = ret;
+        return -1;
+    }
+    barrier->count = 0;
+    barrier->waitfor = 0;
+    INIT_LIST_HEAD(&barrier->waitq);
 
-	return pthread_mutex_init (&barrier->guard, 0);
+    ret = pthread_mutex_init(&barrier->guard, 0);
+    if (ret) {
+        (void)pthread_cond_destroy(&barrier->cond);
+        errno = ret;
+        return -1;
+    }
+    barrier->initialized = _gf_true;
+    return 0;
 }
 
-
 int
-syncbarrier_destroy (struct syncbarrier *barrier)
+syncbarrier_destroy(struct syncbarrier *barrier)
 {
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    int ret1 = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	pthread_cond_destroy (&barrier->cond);
-	return pthread_mutex_destroy (&barrier->guard);
+    if (barrier->initialized) {
+        ret = pthread_cond_destroy(&barrier->cond);
+        ret1 = pthread_mutex_destroy(&barrier->guard);
+        barrier->initialized = _gf_false;
+    }
+    if (ret || ret1) {
+        errno = ret ? ret : ret1;
+        return -1;
+    }
+    return 0;
 }
 
-
 static int
-__syncbarrier_wait (struct syncbarrier *barrier, int waitfor)
+__syncbarrier_wait(struct syncbarrier *barrier, int waitfor)
 {
-	struct synctask *task = NULL;
+    struct synctask *task = NULL;
 
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	task = synctask_get ();
+    task = synctask_get();
 
-	while (barrier->count < waitfor) {
-		if (task) {
-			/* called within a synctask */
-			list_add_tail (&task->waitq, &barrier->waitq);
-                        pthread_mutex_unlock (&barrier->guard);
-                        synctask_yield (task);
-                        pthread_mutex_lock (&barrier->guard);
-		} else {
-			/* called by a non-synctask */
-			pthread_cond_wait (&barrier->cond, &barrier->guard);
-		}
-	}
+    while (barrier->count < waitfor) {
+        if (task) {
+            /* called within a synctask */
+            list_add_tail(&task->waitq, &barrier->waitq);
+            pthread_mutex_unlock(&barrier->guard);
+            synctask_yield(task, NULL);
+            pthread_mutex_lock(&barrier->guard);
+        } else {
+            /* called by a non-synctask */
+            pthread_cond_wait(&barrier->cond, &barrier->guard);
+        }
+    }
 
-	barrier->count = 0;
+    barrier->count = 0;
 
-	return 0;
+    return 0;
 }
 
-
 int
-syncbarrier_wait (struct syncbarrier *barrier, int waitfor)
+syncbarrier_wait(struct syncbarrier *barrier, int waitfor)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&barrier->guard);
-	{
-		ret = __syncbarrier_wait (barrier, waitfor);
-	}
-	pthread_mutex_unlock (&barrier->guard);
+    pthread_mutex_lock(&barrier->guard);
+    {
+        ret = __syncbarrier_wait(barrier, waitfor);
+    }
+    pthread_mutex_unlock(&barrier->guard);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__syncbarrier_wake (struct syncbarrier *barrier)
+__syncbarrier_wake(struct syncbarrier *barrier)
 {
-	struct synctask *task = NULL;
+    struct synctask *task = NULL;
 
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	barrier->count++;
-        if (barrier->waitfor && (barrier->count < barrier->waitfor))
-                return 0;
+    barrier->count++;
+    if (barrier->waitfor && (barrier->count < barrier->waitfor))
+        return 0;
 
-	pthread_cond_signal (&barrier->cond);
-	if (!list_empty (&barrier->waitq)) {
-		task = list_entry (barrier->waitq.next, struct synctask, waitq);
-                list_del_init (&task->waitq);
-		synctask_wake (task);
-	}
-        barrier->waitfor = 0;
+    pthread_cond_signal(&barrier->cond);
+    if (!list_empty(&barrier->waitq)) {
+        task = list_entry(barrier->waitq.next, struct synctask, waitq);
+        list_del_init(&task->waitq);
+        synctask_wake(task);
+    }
+    barrier->waitfor = 0;
 
-	return 0;
+    return 0;
 }
 
-
 int
-syncbarrier_wake (struct syncbarrier *barrier)
+syncbarrier_wake(struct syncbarrier *barrier)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&barrier->guard);
-	{
-		ret = __syncbarrier_wake (barrier);
-	}
-	pthread_mutex_unlock (&barrier->guard);
+    pthread_mutex_lock(&barrier->guard);
+    {
+        ret = __syncbarrier_wake(barrier);
+    }
+    pthread_mutex_unlock(&barrier->guard);
 
-	return ret;
+    return ret;
 }
 
-
 /* FOPS */
 
-
 int
-syncop_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, inode_t *inode,
-                   struct iatt *iatt, dict_t *xdata, struct iatt *parent)
+syncop_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, inode_t *inode, struct iatt *iatt,
+                  dict_t *xdata, struct iatt *parent)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->iatt1  = *iatt;
-                args->iatt2  = *parent;
-        }
+    if (op_ret == 0) {
+        args->iatt1 = *iatt;
+        args->iatt2 = *parent;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_lookup (xlator_t *subvol, loc_t *loc, struct iatt *iatt,
-               struct iatt *parent, dict_t *xdata_in, dict_t **xdata_out)
+syncop_lookup(xlator_t *subvol, loc_t *loc, struct iatt *iatt,
+              struct iatt *parent, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lookup_cbk, subvol->fops->lookup,
-                loc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lookup_cbk, subvol->fops->lookup, loc,
+           xdata_in);
 
-        if (iatt)
-                *iatt = args.iatt1;
-        if (parent)
-                *parent = args.iatt2;
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
+    if (parent)
+        *parent = args.iatt2;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_readdirp_cbk (call_frame_t *frame,
-                     void *cookie,
-                     xlator_t *this,
-                     int32_t op_ret,
-                     int32_t op_errno,
-                     gf_dirent_t *entries, dict_t *xdata)
-{
-        struct syncargs *args = NULL;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t  *tmp = NULL;
-
-        int count = 0;
-
-        args = cookie;
-
-        INIT_LIST_HEAD (&args->entries.list);
-
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-
-
-        if (op_ret >= 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        tmp = entry_copy (entry);
-                        if (!tmp) {
-                                args->op_ret = -1;
-                                args->op_errno = ENOMEM;
-                                gf_dirent_free (&(args->entries));
-                                break;
-                        }
-                        gf_msg_trace (this->name, 0, "adding entry=%s, "
-                                      "count=%d", tmp->d_name, count);
-                        list_add_tail (&tmp->list, &(args->entries.list));
-                        count++;
-                }
-        }
+syncop_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        __wake (args);
+    int count = 0;
 
-        return 0;
+    args = cookie;
+
+    INIT_LIST_HEAD(&args->entries.list);
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            tmp = entry_copy(entry);
+            if (!tmp) {
+                args->op_ret = -1;
+                args->op_errno = ENOMEM;
+                gf_dirent_free(&(args->entries));
+                break;
+            }
+            gf_msg_trace(this->name, 0,
+                         "adding entry=%s, "
+                         "count=%d",
+                         tmp->d_name, count);
+            list_add_tail(&tmp->list, &(args->entries.list));
+            count++;
+        }
+    }
 
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_readdirp (xlator_t *subvol,
-                 fd_t *fd,
-                 size_t size,
-                 off_t off,
-                 gf_dirent_t *entries,
-                 dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_readdirp(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+                gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readdirp_cbk, subvol->fops->readdirp,
-                fd, size, off, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readdirp_cbk, subvol->fops->readdirp, fd,
+           size, off, xdata_in);
 
-        if (entries)
-                list_splice_init (&args.entries.list, &entries->list);
-        else
-                gf_dirent_free (&args.entries);
+    if (entries)
+        list_splice_init(&args.entries.list, &entries->list);
+    else
+        gf_dirent_free(&args.entries);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_readdir_cbk (call_frame_t *frame,
-                    void *cookie,
-                    xlator_t *this,
-                    int32_t op_ret,
-                    int32_t op_errno,
-                    gf_dirent_t *entries, dict_t *xdata)
-{
-        struct syncargs *args = NULL;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t  *tmp = NULL;
-
-        int count = 0;
-
-        args = cookie;
-
-        INIT_LIST_HEAD (&args->entries.list);
-
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-
-        if (op_ret >= 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        tmp = entry_copy (entry);
-                        if (!tmp) {
-                                args->op_ret = -1;
-                                args->op_errno = ENOMEM;
-                                gf_dirent_free (&(args->entries));
-                                break;
-                        }
-                        gf_msg_trace (this->name, 0, "adding "
-                                      "entry=%s, count=%d", tmp->d_name,
-                                      count);
-                        list_add_tail (&tmp->list, &(args->entries.list));
-                        count++;
-                }
-        }
+syncop_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                   dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        __wake (args);
+    int count = 0;
 
-        return 0;
+    args = cookie;
 
+    INIT_LIST_HEAD(&args->entries.list);
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            tmp = entry_copy(entry);
+            if (!tmp) {
+                args->op_ret = -1;
+                args->op_errno = ENOMEM;
+                gf_dirent_free(&(args->entries));
+                break;
+            }
+            gf_msg_trace(this->name, 0,
+                         "adding "
+                         "entry=%s, count=%d",
+                         tmp->d_name, count);
+            list_add_tail(&tmp->list, &(args->entries.list));
+            count++;
+        }
+    }
+
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_readdir (xlator_t *subvol,
-                fd_t *fd,
-                size_t size,
-                off_t off,
-                gf_dirent_t *entries,
-		dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_readdir(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+               gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir,
-                fd, size, off, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir, fd, size,
+           off, xdata_in);
 
-        if (entries)
-                list_splice_init (&args.entries.list, &entries->list);
-        else
-                gf_dirent_free (&args.entries);
+    if (entries)
+        list_splice_init(&args.entries.list, &entries->list);
+    else
+        gf_dirent_free(&args.entries);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_opendir_cbk (call_frame_t *frame,
-                    void *cookie,
-                    xlator_t *this,
-                    int32_t op_ret,
-                    int32_t op_errno,
-                    fd_t *fd, dict_t *xdata)
+syncop_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_opendir (xlator_t *subvol,
-                loc_t *loc,
-                fd_t *fd,
-		dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_opendir(xlator_t *subvol, loc_t *loc, fd_t *fd, dict_t *xdata_in,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_opendir_cbk, subvol->fops->opendir,
-                loc, fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_opendir_cbk, subvol->fops->opendir, loc, fd,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsyncdir_cbk (call_frame_t *frame, void* cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+syncop_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_fsyncdir (xlator_t *subvol, fd_t *fd, int datasync, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_fsyncdir(xlator_t *subvol, fd_t *fd, int datasync, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fsyncdir_cbk, subvol->fops->fsyncdir,
-                fd, datasync, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fsyncdir_cbk, subvol->fops->fsyncdir, fd,
+           datasync, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+syncop_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_removexattr (xlator_t *subvol, loc_t *loc, const char *name,
-                    dict_t *xdata_in, dict_t **xdata_out)
+syncop_removexattr(xlator_t *subvol, loc_t *loc, const char *name,
+                   dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_removexattr_cbk,
-                subvol->fops->removexattr, loc, name, xdata_in);
+    SYNCOP(subvol, (&args), syncop_removexattr_cbk, subvol->fops->removexattr,
+           loc, name, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+syncop_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_fremovexattr (xlator_t *subvol, fd_t *fd, const char *name,
-                     dict_t *xdata_in, dict_t **xdata_out)
+syncop_fremovexattr(xlator_t *subvol, fd_t *fd, const char *name,
+                    dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fremovexattr_cbk,
-                subvol->fops->fremovexattr, fd, name, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fremovexattr_cbk, subvol->fops->fremovexattr,
+           fd, name, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+syncop_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_setxattr (xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
-                 dict_t *xdata_in, dict_t **xdata_out)
+syncop_setxattr(xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setxattr_cbk, subvol->fops->setxattr,
-                loc, dict, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setxattr_cbk, subvol->fops->setxattr, loc,
+           dict, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, dict_t *xdata)
+syncop_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_fsetxattr (xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
-		  dict_t *xdata_in, dict_t **xdata_out)
+syncop_fsetxattr(xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
+                 dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fsetxattr_cbk, subvol->fops->fsetxattr,
-                fd, dict, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fsetxattr_cbk, subvol->fops->fsetxattr, fd,
+           dict, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+syncop_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret >= 0)
-                args->xattr = dict_ref (dict);
+    if (op_ret >= 0)
+        args->xattr = dict_ref(dict);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_listxattr (xlator_t *subvol, loc_t *loc, dict_t **dict, dict_t *xdata_in,
-                  dict_t **xdata_out)
+syncop_listxattr(xlator_t *subvol, loc_t *loc, dict_t **dict, dict_t *xdata_in,
+                 dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr,
-                loc, NULL, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr, loc,
+           NULL, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_getxattr (xlator_t *subvol, loc_t *loc, dict_t **dict, const char *key,
-                 dict_t *xdata_in, dict_t **xdata_out)
+syncop_getxattr(xlator_t *subvol, loc_t *loc, dict_t **dict, const char *key,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr,
-                loc, key, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr, loc,
+           key, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fgetxattr (xlator_t *subvol, fd_t *fd, dict_t **dict, const char *key,
-                  dict_t *xdata_in, dict_t **xdata_out)
+syncop_fgetxattr(xlator_t *subvol, fd_t *fd, dict_t **dict, const char *key,
+                 dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->fgetxattr,
-                fd, key, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->fgetxattr, fd,
+           key, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno,
-                   struct statvfs *buf, dict_t *xdata)
+syncop_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                  dict_t *xdata)
 
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->statvfs_buf  = *buf;
-        }
+    if (op_ret == 0) {
+        args->statvfs_buf = *buf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_statfs (xlator_t *subvol, loc_t *loc, struct statvfs *buf,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_statfs(xlator_t *subvol, loc_t *loc, struct statvfs *buf,
+              dict_t *xdata_in, dict_t **xdata_out)
 
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_statfs_cbk, subvol->fops->statfs,
-                loc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_statfs_cbk, subvol->fops->statfs, loc,
+           xdata_in);
 
-        if (buf)
-                *buf = args.statvfs_buf;
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (buf)
+        *buf = args.statvfs_buf;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    struct iatt *preop, struct iatt *postop, dict_t *xdata)
+syncop_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, struct iatt *preop,
+                   struct iatt *postop, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->iatt1  = *preop;
-                args->iatt2  = *postop;
-        }
+    if (op_ret == 0) {
+        args->iatt1 = *preop;
+        args->iatt2 = *postop;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_setattr (xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
-                struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_setattr(xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
+               struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setattr_cbk, subvol->fops->setattr,
-                loc, iatt, valid, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setattr_cbk, subvol->fops->setattr, loc,
+           iatt, valid, xdata_in);
 
-        if (preop)
-                *preop = args.iatt1;
-        if (postop)
-                *postop = args.iatt2;
+    if (preop)
+        *preop = args.iatt1;
+    if (postop)
+        *postop = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_fsetattr (xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
-                 struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_fsetattr(xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
+                struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setattr_cbk, subvol->fops->fsetattr,
-                fd, iatt, valid, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setattr_cbk, subvol->fops->fsetattr, fd,
+           iatt, valid, xdata_in);
 
-        if (preop)
-                *preop = args.iatt1;
-        if (postop)
-                *postop = args.iatt2;
+    if (preop)
+        *preop = args.iatt1;
+    if (postop)
+        *postop = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int32_t
-syncop_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+syncop_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_open (xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
-	     dict_t *xdata_in, dict_t **xdata_out)
+syncop_open(xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
+            dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_open_cbk, subvol->fops->open,
-                loc, flags, fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_open_cbk, subvol->fops->open, loc, flags, fd,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int32_t
-syncop_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                  dict_t *xdata)
+syncop_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                 int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                 dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-
-        args = cookie;
+    struct syncargs *args = NULL;
 
-        INIT_LIST_HEAD (&args->entries.list);
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    INIT_LIST_HEAD(&args->entries.list);
 
-        if (args->op_ret >= 0) {
-                if (iobref)
-                        args->iobref = iobref_ref (iobref);
-                args->vector = iov_dup (vector, count);
-                args->count  = count;
-        }
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    if (args->op_ret >= 0) {
+        if (iobref)
+            args->iobref = iobref_ref(iobref);
+        args->vector = iov_dup(vector, count);
+        args->count = count;
+        args->iatt1 = *stbuf;
+    }
 
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_readv (xlator_t *subvol, fd_t *fd, size_t size, off_t off,
-              uint32_t flags, struct iovec **vector, int *count,
-              struct iobref **iobref, dict_t *xdata_in, dict_t **xdata_out)
+syncop_readv(xlator_t *subvol, fd_t *fd, size_t size, off_t off, uint32_t flags,
+             struct iovec **vector, int *count, struct iobref **iobref,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readv_cbk, subvol->fops->readv,
-                fd, size, off, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readv_cbk, subvol->fops->readv, fd, size,
+           off, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                goto out;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (vector)
-                *vector = args.vector;
-        else
-                GF_FREE (args.vector);
+    if (args.op_ret < 0)
+        goto out;
 
-        if (count)
-                *count = args.count;
+    if (vector)
+        *vector = args.vector;
+    else
+        GF_FREE(args.vector);
 
-        /* Do we need a 'ref' here? */
-        if (iobref)
-                *iobref = args.iobref;
-        else if (args.iobref)
-                iobref_unref (args.iobref);
+    if (count)
+        *count = args.count;
 
-out:
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    /* Do we need a 'ref' here? */
+    if (iobref)
+        *iobref = args.iobref;
+    else if (args.iobref)
+        iobref_unref(args.iobref);
 
+out:
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+syncop_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        return 0;
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_writev (xlator_t *subvol, fd_t *fd, const struct iovec *vector,
-               int32_t count, off_t offset, struct iobref *iobref,
-               uint32_t flags, dict_t *xdata_in, dict_t **xdata_out)
+syncop_writev(xlator_t *subvol, fd_t *fd, const struct iovec *vector,
+              int32_t count, off_t offset, struct iobref *iobref,
+              uint32_t flags, struct iatt *preiatt, struct iatt *postiatt,
+              dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_writev_cbk, subvol->fops->writev,
-                fd, (struct iovec *) vector, count, offset, flags, iobref,
-                xdata_in);
+    SYNCOP(subvol, (&args), syncop_writev_cbk, subvol->fops->writev, fd,
+           (struct iovec *)vector, count, offset, flags, iobref, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-int syncop_write (xlator_t *subvol, fd_t *fd, const char *buf, int size,
-                  off_t offset, struct iobref *iobref, uint32_t flags,
-                  dict_t *xdata_in, dict_t **xdata_out)
+int
+syncop_write(xlator_t *subvol, fd_t *fd, const char *buf, int size,
+             off_t offset, struct iobref *iobref, uint32_t flags,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0,};
-        struct iovec    vec  = {0,};
+    struct syncargs args = {
+        0,
+    };
+    struct iovec vec = {
+        0,
+    };
 
-        vec.iov_len = size;
-        vec.iov_base = (void *)buf;
+    vec.iov_len = size;
+    vec.iov_base = (void *)buf;
 
-        SYNCOP (subvol, (&args), syncop_writev_cbk, subvol->fops->writev,
-                fd, &vec, 1, offset, flags, iobref, xdata_in);
+    SYNCOP(subvol, (&args), syncop_writev_cbk, subvol->fops->writev, fd, &vec,
+           1, offset, flags, iobref, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_close (fd_t *fd)
+syncop_close(fd_t *fd)
 {
-        if (fd)
-                fd_unref (fd);
-        return 0;
+    if (fd)
+        fd_unref(fd);
+    return 0;
 }
 
 int32_t
-syncop_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+syncop_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_create (xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
-               fd_t *fd, struct iatt *iatt,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_create(xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
+              fd_t *fd, struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_create_cbk, subvol->fops->create,
-                loc, flags, mode, 0, fd, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-	if (iatt)
-		*iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_create_cbk, subvol->fops->create, loc, flags,
+           mode, 0, fd, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-int
-syncop_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+int32_t
+syncop_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, inode_t *inode,
+               struct iatt *buf, struct iatt *preparent,
+               struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    if (buf)
+        args->iatt1 = *buf;
 
-        return 0;
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_unlink (xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
-               dict_t **xdata_out)
+syncop_put(xlator_t *subvol, loc_t *loc, mode_t mode, mode_t umask,
+           uint32_t flags, struct iovec *vector, int32_t count, off_t offset,
+           struct iobref *iobref, dict_t *xattr, struct iatt *iatt,
+           dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_unlink_cbk, subvol->fops->unlink, loc,
-                0, xdata_in);
+    SYNCOP(subvol, (&args), syncop_put_cbk, subvol->fops->put, loc, mode, umask,
+           flags, (struct iovec *)vector, count, offset, iobref, xattr,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+syncop_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *preparent, struct iatt *postparent,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_rmdir (xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
+syncop_unlink(xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_rmdir_cbk, subvol->fops->rmdir, loc,
-                flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_unlink_cbk, subvol->fops->unlink, loc, 0,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+syncop_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *preparent, struct iatt *postparent,
+                 dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-
-        args = cookie;
+    struct syncargs *args = NULL;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args = cookie;
 
-        if (buf)
-                args->iatt1 = *buf;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_link (xlator_t *subvol, loc_t *oldloc, loc_t *newloc, struct iatt *iatt,
-             dict_t *xdata_in, dict_t **xdata_out)
+syncop_rmdir(xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
+             dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_link_cbk, subvol->fops->link,
-                oldloc, newloc, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (iatt)
-                *iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_rmdir_cbk, subvol->fops->rmdir, loc, flags,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                   struct iatt *preoldparent, struct iatt *postoldparent,
-                   struct iatt *prenewparent, struct iatt *postnewparent,
-                   dict_t *xdata)
+syncop_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    if (buf)
+        args->iatt1 = *buf;
 
-        return 0;
-}
+    __wake(args);
 
+    return 0;
+}
 
 int
-syncop_rename (xlator_t *subvol, loc_t *oldloc, loc_t *newloc,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_link(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, struct iatt *iatt,
+            dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_rename_cbk, subvol->fops->rename,
-                oldloc, newloc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_link_cbk, subvol->fops->link, oldloc, newloc,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        return args.op_ret;
-}
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
+    return args.op_ret;
+}
 
 int
-syncop_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+syncop_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  struct iatt *preoldparent, struct iatt *postoldparent,
+                  struct iatt *prenewparent, struct iatt *postnewparent,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_ftruncate (xlator_t *subvol, fd_t *fd, off_t offset, dict_t *xdata_in,
-                  dict_t **xdata_out)
+syncop_rename(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, dict_t *xdata_in,
+              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate,
-                fd, offset, xdata_in);
+    SYNCOP(subvol, (&args), syncop_rename_cbk, subvol->fops->rename, oldloc,
+           newloc, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+
+    return args.op_ret;
 }
 
 int
-syncop_truncate (xlator_t *subvol, loc_t *loc, off_t offset, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs args = {0, };
+    struct syncargs *args = NULL;
 
-        SYNCOP (subvol, (&args), syncop_ftruncate_cbk, subvol->fops->truncate,
-                loc, offset, xdata_in);
+    args = cookie;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
+
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno,
-                  struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+syncop_ftruncate(xlator_t *subvol, fd_t *fd, off_t offset, struct iatt *preiatt,
+                 struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs *args = NULL;
+    struct syncargs args = {
+        0,
+    };
 
-        args = cookie;
+    SYNCOP(subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate, fd,
+           offset, xdata_in);
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        __wake (args);
-
-        return 0;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsync (xlator_t *subvol, fd_t *fd, int dataonly, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_truncate(xlator_t *subvol, loc_t *loc, off_t offset, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fsync_cbk, subvol->fops->fsync,
-                fd, dataonly, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ftruncate_cbk, subvol->fops->truncate, loc,
+           offset, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                 struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_flush (xlator_t *subvol, fd_t *fd, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_fsync(xlator_t *subvol, fd_t *fd, int dataonly, struct iatt *preiatt,
+             struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0};
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_flush_cbk, subvol->fops->flush,
-                fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fsync_cbk, subvol->fops->fsync, fd, dataonly,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                  dict_t *xdata)
+syncop_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0)
-                args->iatt1 = *stbuf;
+    __wake(args);
 
-        __wake (args);
+    return 0;
+}
 
-        return 0;
+int
+syncop_flush(xlator_t *subvol, fd_t *fd, dict_t *xdata_in, dict_t **xdata_out)
+{
+    struct syncargs args = {0};
+
+    SYNCOP(subvol, (&args), syncop_flush_cbk, subvol->fops->flush, fd,
+           xdata_in);
 
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fstat (xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                 dict_t *xdata)
 {
-        struct syncargs args = {0, };
+    struct syncargs *args = NULL;
 
-        SYNCOP (subvol, (&args), syncop_fstat_cbk, subvol->fops->fstat,
-                fd, xdata_in);
+    args = cookie;
 
-        if (stbuf)
-                *stbuf = args.iatt1;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (op_ret == 0)
+        args->iatt1 = *stbuf;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_stat (xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
+syncop_fstat(xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fstat_cbk, subvol->fops->stat,
-                loc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fstat_cbk, subvol->fops->fstat, fd,
+           xdata_in);
 
-        if (stbuf)
-                *stbuf = args.iatt1;
+    if (stbuf)
+        *stbuf = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
+}
+
+int
+syncop_stat(xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
+            dict_t **xdata_out)
+{
+    struct syncargs args = {
+        0,
+    };
+
+    SYNCOP(subvol, (&args), syncop_fstat_cbk, subvol->fops->stat, loc,
+           xdata_in);
+
+    if (stbuf)
+        *stbuf = args.iatt1;
+
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+syncop_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_symlink (xlator_t *subvol, loc_t *loc, const char *newpath,
-                struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_symlink(xlator_t *subvol, loc_t *loc, const char *newpath,
+               struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_symlink_cbk, subvol->fops->symlink,
-                newpath, loc, 0, xdata_in);
+    SYNCOP(subvol, (&args), syncop_symlink_cbk, subvol->fops->symlink, newpath,
+           loc, 0, xdata_in);
 
-	if (iatt)
-		*iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, const char *path,
-                     struct iatt *stbuf, dict_t *xdata)
+syncop_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, const char *path,
+                    struct iatt *stbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if ((op_ret != -1) && path)
-                args->buffer = gf_strdup (path);
+    if ((op_ret != -1) && path)
+        args->buffer = gf_strdup(path);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_readlink (xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
-		 dict_t *xdata_in, dict_t **xdata_out)
+syncop_readlink(xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readlink_cbk, subvol->fops->readlink,
-                loc, size, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readlink_cbk, subvol->fops->readlink, loc,
+           size, xdata_in);
 
-        if (buffer)
-                *buffer = args.buffer;
-        else GF_FREE (args.buffer);
+    if (buffer)
+        *buffer = args.buffer;
+    else
+        GF_FREE(args.buffer);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+syncop_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_mknod (xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
-              struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_mknod(xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod,
-                loc, mode, rdev, 0, xdata_in);
+    SYNCOP(subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod, loc, mode,
+           rdev, 0, xdata_in);
 
-	if (iatt)
-		*iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+syncop_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_mkdir (xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
-              dict_t *xdata_in, dict_t **xdata_out)
+syncop_mkdir(xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_mkdir_cbk, subvol->fops->mkdir,
-                loc, mode, 0, xdata_in);
+    SYNCOP(subvol, (&args), syncop_mkdir_cbk, subvol->fops->mkdir, loc, mode, 0,
+           xdata_in);
 
-	if (iatt)
-		*iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 /* posix_acl xlator will respond in different ways for access calls from
@@ -2673,532 +2875,698 @@ syncop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
    got is the mode of the access.
 */
 int
-syncop_access (xlator_t *subvol, loc_t *loc, int32_t mask, dict_t *xdata_in,
-               dict_t **xdata_out)
+syncop_access(xlator_t *subvol, loc_t *loc, int32_t mask, dict_t *xdata_in,
+              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_access_cbk, subvol->fops->access,
-                loc, mask, xdata_in);
+    SYNCOP(subvol, (&args), syncop_access_cbk, subvol->fops->access, loc, mask,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_errno;
 }
 
-
 int
-syncop_fallocate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+syncop_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-	struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-	return 0;
+    return 0;
 }
 
 int
 syncop_fallocate(xlator_t *subvol, fd_t *fd, int32_t keep_size, off_t offset,
-		 size_t len, dict_t *xdata_in, dict_t **xdata_out)
+                 size_t len, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fallocate_cbk, subvol->fops->fallocate,
-                fd, keep_size, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fallocate_cbk, subvol->fops->fallocate, fd,
+           keep_size, offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_discard_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
+syncop_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-	struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-	return 0;
+    return 0;
 }
 
 int
 syncop_discard(xlator_t *subvol, fd_t *fd, off_t offset, size_t len,
-	       dict_t *xdata_in, dict_t **xdata_out)
+               dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_discard_cbk, subvol->fops->discard,
-                fd, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_discard_cbk, subvol->fops->discard, fd,
+           offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_zerofill_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+syncop_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                     int op_ret, int op_errno, struct iatt *prebuf,
                     struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
 syncop_zerofill(xlator_t *subvol, fd_t *fd, off_t offset, off_t len,
-		dict_t *xdata_in, dict_t **xdata_out)
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_zerofill_cbk, subvol->fops->zerofill,
-                fd, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_zerofill_cbk, subvol->fops->zerofill, fd,
+           offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, dict_t *xdata)
+syncop_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_ipc (xlator_t *subvol, int32_t op, dict_t *xdata_in, dict_t **xdata_out)
+syncop_ipc(xlator_t *subvol, int32_t op, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ipc_cbk, subvol->fops->ipc,
-                op, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ipc_cbk, subvol->fops->ipc, op, xdata_in);
 
-        if (args.xdata) {
-                if (xdata_out) {
-                        /*
-                         * We're passing this reference to the caller, along
-                         * with the pointer itself.  That means they're
-                         * responsible for calling dict_unref at some point.
-                         */
-                        *xdata_out = args.xdata;
-                } else {
-                        dict_unref(args.xdata);
-                }
+    if (args.xdata) {
+        if (xdata_out) {
+            /*
+             * We're passing this reference to the caller, along
+             * with the pointer itself.  That means they're
+             * responsible for calling dict_unref at some point.
+             */
+            *xdata_out = args.xdata;
+        } else {
+            dict_unref(args.xdata);
         }
+    }
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, off_t offset, dict_t *xdata)
+syncop_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, off_t offset, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        args->offset   = offset;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    args->offset = offset;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_seek (xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
-             dict_t *xdata_in, off_t *off)
+syncop_seek(xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
+            dict_t *xdata_in, off_t *off)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_seek_cbk, subvol->fops->seek, fd,
-                offset, what, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (*off)
-                *off = args.offset;
+    SYNCOP(subvol, (&args), syncop_seek_cbk, subvol->fops->seek, fd, offset,
+           what, xdata_in);
 
-        if (args.op_ret == -1)
-                return -args.op_errno;
+    if (args.op_ret < 0) {
+        return -args.op_errno;
+    } else {
+        if (off)
+            *off = args.offset;
         return args.op_ret;
+    }
 }
 
 int
-syncop_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, struct gf_lease *lease, dict_t *xdata)
+syncop_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-        if (lease)
-                args->lease = *lease;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    if (lease)
+        args->lease = *lease;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_lease (xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
-              dict_t *xdata_in, dict_t **xdata_out)
+syncop_lease(xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lease_cbk, subvol->fops->lease,
-                loc, lease, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lease_cbk, subvol->fops->lease, loc, lease,
+           xdata_in);
 
-        *lease = args.lease;
+    *lease = args.lease;
 
-        if (args.xdata) {
-                if (xdata_out) {
-                        /*
-                         * We're passing this reference to the caller, along
-                         * with the pointer itself.  That means they're
-                         * responsible for calling dict_unref at some point.
-                         */
-                        *xdata_out = args.xdata;
-                } else {
-                        dict_unref(args.xdata);
-                }
+    if (args.xdata) {
+        if (xdata_out) {
+            /*
+             * We're passing this reference to the caller, along
+             * with the pointer itself.  That means they're
+             * responsible for calling dict_unref at some point.
+             */
+            *xdata_out = args.xdata;
+        } else {
+            dict_unref(args.xdata);
         }
+    }
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-	       int op_ret, int op_errno, struct gf_flock *flock,
-	       dict_t *xdata)
+syncop_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct gf_flock *flock, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (flock)
-		args->flock = *flock;
-        __wake (args);
+    if (flock)
+        args->flock = *flock;
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_lk (xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
-	   dict_t *xdata_in, dict_t **xdata_out)
+syncop_lk(xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
+          dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lk_cbk, subvol->fops->lk,
-                fd, cmd, flock, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lk_cbk, subvol->fops->lk, fd, cmd, flock,
+           xdata_in);
 
-	*flock = args.flock;
+    *flock = args.flock;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_inodelk (xlator_t *subvol, const char *volume, loc_t *loc, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata_in, dict_t **xdata_out)
+syncop_inodelk(xlator_t *subvol, const char *volume, loc_t *loc, int32_t cmd,
+               struct gf_flock *lock, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_inodelk_cbk, subvol->fops->inodelk,
-                volume, loc, cmd, lock, xdata_in);
+    SYNCOP(subvol, (&args), syncop_inodelk_cbk, subvol->fops->inodelk, volume,
+           loc, cmd, lock, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
 int32_t
-syncop_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *dict,
-                    dict_t *xdata)
+syncop_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    __wake(args);
+    return 0;
+}
 
-        __wake (args);
+int
+syncop_entrylk(xlator_t *subvol, const char *volume, loc_t *loc,
+               const char *basename, entrylk_cmd cmd, entrylk_type type,
+               dict_t *xdata_in, dict_t **xdata_out)
+{
+    struct syncargs args = {
+        0,
+    };
 
-        return 0;
+    SYNCOP(subvol, (&args), syncop_entrylk_cbk, subvol->fops->entrylk, volume,
+           loc, basename, cmd, type, xdata_in);
+
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
+
+    return args.op_ret;
+}
+
+int32_t
+syncop_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *dict,
+                   dict_t *xdata)
+{
+    struct syncargs *args = NULL;
 
+    args = cookie;
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    if (dict)
+        args->dict_out = dict_ref(dict);
+
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_xattrop (xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
-                dict_t *dict, dict_t *xdata_in, dict_t **xdata_out)
+syncop_xattrop(xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
+               dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_xattrop_cbk, subvol->fops->xattrop,
-                loc, flags, dict, xdata_in);
+    SYNCOP(subvol, (&args), syncop_xattrop_cbk, subvol->fops->xattrop, loc,
+           flags, dict, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+
+    return args.op_ret;
 }
 
 int
-syncop_fxattrop (xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
-                 dict_t *dict, dict_t *xdata_in, dict_t **xdata_out)
+syncop_fxattrop(xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
+                dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_xattrop_cbk, subvol->fops->fxattrop,
-                fd, flags, dict, xdata_in);
+    SYNCOP(subvol, (&args), syncop_xattrop_cbk, subvol->fops->fxattrop, fd,
+           flags, dict, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+
+    return args.op_ret;
 }
 
 int32_t
-syncop_getactivelk_cbk (call_frame_t *frame,
-                         void *cookie,
-                         xlator_t *this,
-                         int32_t op_ret,
-                         int32_t op_errno,
-                         lock_migration_info_t *locklist, dict_t *xdata)
+syncop_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno,
+                       lock_migration_info_t *locklist, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-        lock_migration_info_t   *tmp = NULL;
-        lock_migration_info_t   *entry = NULL;
+    struct syncargs *args = NULL;
+    lock_migration_info_t *tmp = NULL;
+    lock_migration_info_t *entry = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        INIT_LIST_HEAD (&args->locklist.list);
+    INIT_LIST_HEAD(&args->locklist.list);
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret > 0) {
-                list_for_each_entry (tmp, &locklist->list, list) {
-                        entry = GF_CALLOC (1, sizeof (lock_migration_info_t),
-                                          gf_common_mt_char);
-
-                        if (!entry) {
-                                gf_msg (THIS->name, GF_LOG_ERROR, 0, 0,
-                                        "lock mem allocation  failed");
-                                gf_free_mig_locks (&args->locklist);
+    if (op_ret > 0) {
+        list_for_each_entry(tmp, &locklist->list, list)
+        {
+            entry = GF_CALLOC(1, sizeof(lock_migration_info_t),
+                              gf_common_mt_char);
 
-                                break;
-                        }
+            if (!entry) {
+                gf_msg(THIS->name, GF_LOG_ERROR, 0, 0,
+                       "lock mem allocation  failed");
+                gf_free_mig_locks(&args->locklist);
 
-                        INIT_LIST_HEAD (&entry->list);
+                break;
+            }
 
-                        entry->flock = tmp->flock;
+            INIT_LIST_HEAD(&entry->list);
 
-                        entry->lk_flags = tmp->lk_flags;
+            entry->flock = tmp->flock;
 
-                        entry->client_uid = gf_strdup (tmp->client_uid);
+            entry->lk_flags = tmp->lk_flags;
 
-                        list_add_tail (&entry->list, &args->locklist.list);
+            entry->client_uid = gf_strdup(tmp->client_uid);
 
-                }
+            list_add_tail(&entry->list, &args->locklist.list);
         }
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
+}
+
+int
+syncop_getactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out)
+{
+    struct syncargs args = {
+        0,
+    };
+
+    SYNCOP(subvol, (&args), syncop_getactivelk_cbk, subvol->fops->getactivelk,
+           loc, xdata_in);
+
+    if (locklist)
+        list_splice_init(&args.locklist.list, &locklist->list);
+    else
+        gf_free_mig_locks(&args.locklist);
+
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
+    return args.op_ret;
 }
 
 int
-syncop_getactivelk (xlator_t *subvol, loc_t *loc,
-                    lock_migration_info_t *locklist,  dict_t *xdata_in,
-                    dict_t **xdata_out)
+syncop_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs args = {0, };
+    struct syncargs *args = NULL;
 
-        SYNCOP (subvol, (&args), syncop_getactivelk_cbk,
-                subvol->fops->getactivelk,
-                loc, xdata_in);
+    args = cookie;
 
-        if (locklist)
-                list_splice_init (&args.locklist.list, &locklist->list);
-        else
-                gf_free_mig_locks (&args.locklist) ;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    __wake(args);
 
-        return args.op_ret;
+    return 0;
+}
+
+int
+syncop_setactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out)
+{
+    struct syncargs args = {
+        0,
+    };
 
+    SYNCOP(subvol, (&args), syncop_setactivelk_cbk, subvol->fops->setactivelk,
+           loc, locklist, xdata_in);
+
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
+
+    if (args.op_ret < 0)
+        return -args.op_errno;
+
+    return args.op_ret;
 }
 
 int
-syncop_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_icreate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    if (buf)
+        args->iatt1 = *buf;
 
+    __wake(args);
 
-        __wake (args);
+    return 0;
+}
 
-        return 0;
+int
+syncop_namelink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+
+    args = cookie;
 
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_setactivelk (xlator_t *subvol, loc_t *loc,
-                     lock_migration_info_t *locklist,  dict_t *xdata_in,
-                     dict_t **xdata_out)
+syncop_copy_file_range(xlator_t *subvol, fd_t *fd_in, off64_t off_in,
+                       fd_t *fd_out, off64_t off_out, size_t len,
+                       uint32_t flags, struct iatt *stbuf,
+                       struct iatt *preiatt_dst, struct iatt *postiatt_dst,
+                       dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setactivelk_cbk,
-                subvol->fops->setactivelk,
-                loc, locklist, xdata_in);
+    SYNCOP(subvol, (&args), syncop_copy_file_range_cbk,
+           subvol->fops->copy_file_range, fd_in, off_in, fd_out, off_out, len,
+           flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (stbuf) {
+        *stbuf = args.iatt1;
+    }
+    if (preiatt_dst) {
+        *preiatt_dst = args.iatt2;
+    }
+    if (postiatt_dst) {
+        *postiatt_dst = args.iatt3;
+    }
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (xdata_out) {
+        *xdata_out = args.xdata;
+    } else if (args.xdata) {
+        dict_unref(args.xdata);
+    }
 
-        return args.op_ret;
+    errno = args.op_errno;
+    return args.op_ret;
+}
+
+int
+syncop_copy_file_range_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, struct iatt *stbuf,
+                           struct iatt *prebuf_dst, struct iatt *postbuf_dst,
+                           dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+
+    args = cookie;
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        args->iatt1 = *stbuf;
+        args->iatt2 = *prebuf_dst;
+        args->iatt3 = *postbuf_dst;
+    }
+
+    __wake(args);
 
+    return 0;
 }
diff --git a/libglusterfs/src/syncop.h b/libglusterfs/src/syncop.h
deleted file mode 100644
index a9cdee1fa00..00000000000
--- a/libglusterfs/src/syncop.h
+++ /dev/null
@@ -1,565 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _SYNCOP_H
-#define _SYNCOP_H
-
-#include "xlator.h"
-#include <sys/time.h>
-#include <pthread.h>
-#include <ucontext.h>
-
-#define SYNCENV_PROC_MAX 16
-#define SYNCENV_PROC_MIN 2
-#define SYNCPROC_IDLE_TIME 600
-
-/*
- * Flags for syncopctx valid elements
- */
-#define SYNCOPCTX_UID    0x00000001
-#define SYNCOPCTX_GID    0x00000002
-#define SYNCOPCTX_GROUPS 0x00000004
-#define SYNCOPCTX_PID    0x00000008
-#define SYNCOPCTX_LKOWNER 0x00000010
-
-struct synctask;
-struct syncproc;
-struct syncenv;
-
-
-typedef int (*synctask_cbk_t) (int ret, call_frame_t *frame, void *opaque);
-
-typedef int (*synctask_fn_t) (void *opaque);
-
-
-typedef enum {
-        SYNCTASK_INIT = 0,
-        SYNCTASK_RUN,
-        SYNCTASK_SUSPEND,
-        SYNCTASK_WAIT,
-        SYNCTASK_DONE,
-	SYNCTASK_ZOMBIE,
-} synctask_state_t;
-
-/* for one sequential execution of @syncfn */
-struct synctask {
-        struct list_head    all_tasks;
-        struct syncenv     *env;
-        xlator_t           *xl;
-        call_frame_t       *frame;
-        call_frame_t       *opframe;
-        synctask_cbk_t      synccbk;
-        synctask_fn_t       syncfn;
-        synctask_state_t    state;
-        void               *opaque;
-        void               *stack;
-        int                 woken;
-        int                 slept;
-        int                 ret;
-
-        uid_t               uid;
-        gid_t               gid;
-
-        ucontext_t          ctx;
-        struct syncproc    *proc;
-
-        pthread_mutex_t     mutex; /* for synchronous spawning of synctask */
-        pthread_cond_t      cond;
-        int                 done;
-
-	struct list_head    waitq; /* can wait only "once" at a time */
-        char                btbuf[GF_BACKTRACE_LEN];
-};
-
-
-struct syncproc {
-        pthread_t           processor;
-        ucontext_t          sched;
-        struct syncenv     *env;
-        struct synctask    *current;
-};
-
-/* hosts the scheduler thread and framework for executing synctasks */
-struct syncenv {
-        struct syncproc     proc[SYNCENV_PROC_MAX];
-        int                 procs;
-
-        struct list_head    runq;
-        int                 runcount;
-        struct list_head    waitq;
-        int                 waitcount;
-
-	int                 procmin;
-	int                 procmax;
-
-        pthread_mutex_t     mutex;
-        pthread_cond_t      cond;
-
-        size_t              stacksize;
-
-        int                 destroy; /* FLAG to mark syncenv is in destroy mode
-                                        so that no more synctasks are accepted*/
-};
-
-
-typedef enum {
-        LOCK_NULL = 0,
-        LOCK_TASK,
-        LOCK_THREAD
-} lock_type_t;
-
-typedef enum {
-        SYNC_LOCK_DEFAULT = 0,
-        SYNC_LOCK_RECURSIVE,   /*it allows recursive locking*/
-} lock_attr_t;
-
-struct synclock {
-        pthread_mutex_t     guard; /* guard the remaining members, pair @cond */
-        pthread_cond_t      cond;  /* waiting non-synctasks */
-        struct list_head    waitq; /* waiting synctasks */
-        volatile int        lock;  /* true(non zero) or false(zero), lock status */
-        lock_attr_t         attr;
-        struct synctask    *owner; /* NULL if current owner is not a synctask */
-        pthread_t           owner_tid;
-        lock_type_t         type;
-};
-typedef struct synclock synclock_t;
-
-
-struct syncbarrier {
-	pthread_mutex_t     guard; /* guard the remaining members, pair @cond */
-	pthread_cond_t      cond;  /* waiting non-synctasks */
-	struct list_head    waitq; /* waiting synctasks */
-	int                 count; /* count the number of wakes */
-        int                 waitfor; /* no. of wakes until which task can be in
-                                        waitq before being woken up. */
-};
-typedef struct syncbarrier syncbarrier_t;
-
-
-struct syncargs {
-        int                 op_ret;
-        int                 op_errno;
-        struct iatt         iatt1;
-        struct iatt         iatt2;
-        dict_t             *xattr;
-        struct statvfs     statvfs_buf;
-        struct iovec       *vector;
-        int                 count;
-        struct iobref      *iobref;
-        char               *buffer;
-        dict_t             *xdata;
-	struct gf_flock     flock;
-        struct gf_lease     lease;
-
-        /* some more _cbk needs */
-        uuid_t              uuid;
-        char               *errstr;
-        dict_t             *dict;
-        pthread_mutex_t     lock_dict;
-
-	syncbarrier_t       barrier;
-
-        /* do not touch */
-        struct synctask    *task;
-        pthread_mutex_t     mutex;
-        pthread_cond_t      cond;
-	int                 done;
-
-        gf_dirent_t        entries;
-        off_t              offset;
-
-        lock_migration_info_t locklist;
-};
-
-struct syncopctx {
-        unsigned int valid;  /* valid flags for elements that are set */
-        uid_t        uid;
-        gid_t        gid;
-        int          grpsize;
-        int          ngrps;
-        gid_t       *groups;
-	pid_t        pid;
-        gf_lkowner_t lk_owner;
-};
-
-#define __yawn(args) do {                                       \
-        args->task = synctask_get ();                           \
-        if (args->task)                                         \
-            break;                                              \
-        pthread_mutex_init (&args->mutex, NULL);                \
-        pthread_cond_init (&args->cond, NULL);                  \
-        args->done = 0;                                         \
-        } while (0)
-
-
-#define __wake(args) do {                                       \
-        if (args->task) {                                       \
-                synctask_wake (args->task);                     \
-        } else {                                                \
-                pthread_mutex_lock (&args->mutex);              \
-                {                                               \
-                        args->done = 1;				\
-                        pthread_cond_signal (&args->cond);      \
-                }                                               \
-                pthread_mutex_unlock (&args->mutex);            \
-        }                                                       \
-        } while (0)
-
-
-#define __yield(args) do {						\
-	if (args->task) {				                \
-		synctask_yield (args->task);				\
-	} else {							\
-		pthread_mutex_lock (&args->mutex);			\
-		{							\
-			while (!args->done)				\
-				pthread_cond_wait (&args->cond,		\
-						   &args->mutex);	\
-		}							\
-		pthread_mutex_unlock (&args->mutex);			\
-		pthread_mutex_destroy (&args->mutex);			\
-		pthread_cond_destroy (&args->cond);			\
-	}								\
-	} while (0)
-
-
-#define SYNCOP(subvol, stb, cbk, op, params ...) do {                   \
-                struct  synctask        *task = NULL;                   \
-                call_frame_t            *frame = NULL;                  \
-                                                                        \
-                task = synctask_get ();                                 \
-                stb->task = task;                                       \
-                if (task)                                               \
-                        frame = task->opframe;                          \
-                else                                                    \
-                        frame = syncop_create_frame (THIS);		\
-                                                                        \
-                if (task) {                                             \
-                        frame->root->uid = task->uid;                   \
-                        frame->root->gid = task->gid;                   \
-                }                                                       \
-                                                                        \
-                __yawn (stb);                                           \
-                                                                        \
-                STACK_WIND_COOKIE (frame, cbk, (void *)stb, subvol,     \
-                                   op, params);                         \
-                                                                        \
-                __yield (stb);                                          \
-                if (task)                                               \
-                        STACK_RESET (frame->root);                      \
-                else                                                    \
-                        STACK_DESTROY (frame->root);                    \
-        } while (0)
-
-
-/*
- * syncop_xxx() calls are executed in two ways, one is inside a synctask where
- * the executing function will do 'swapcontext' and the other is without
- * synctask where the executing thread is made to wait using pthread_cond_wait.
- * Executing thread may change when syncop_xxx() is executed inside a synctask.
- * This leads to errno_location change i.e. errno may give errno of
- * non-executing thread. So errno is not touched inside a synctask execution.
- * All gfapi calls are executed using the second way of executing syncop_xxx()
- * where the executing thread waits using pthread_cond_wait so it is ok to set
- * errno in these cases. The following macro makes syncop_xxx() behave just
- * like a system call, where -1 is returned and errno is set when a failure
- * occurs.
- */
-#define DECODE_SYNCOP_ERR(ret) do {  \
-        if (ret < 0) {          \
-                errno = -ret;   \
-                ret = -1;       \
-        } else {                \
-                errno = 0;      \
-        }                       \
-        } while (0)
-
-
-#define SYNCENV_DEFAULT_STACKSIZE (2 * 1024 * 1024)
-
-struct syncenv * syncenv_new (size_t stacksize, int procmin, int procmax);
-void syncenv_destroy (struct syncenv *);
-void syncenv_scale (struct syncenv *env);
-
-int synctask_new1 (struct syncenv *, size_t stacksize, synctask_fn_t,
-                    synctask_cbk_t, call_frame_t *frame, void *);
-int synctask_new (struct syncenv *, synctask_fn_t, synctask_cbk_t,
-                  call_frame_t *frame, void *);
-struct synctask *synctask_create (struct syncenv *, size_t stacksize,
-                                  synctask_fn_t, synctask_cbk_t, call_frame_t *,
-                                  void *);
-int synctask_join (struct synctask *task);
-void synctask_wake (struct synctask *task);
-void synctask_yield (struct synctask *task);
-void synctask_waitfor (struct synctask *task, int count);
-
-#define synctask_barrier_init(args) syncbarrier_init (&args->barrier)
-#define synctask_barrier_wait(args, n) syncbarrier_wait (&args->barrier, n)
-#define synctask_barrier_wake(args) syncbarrier_wake (&args->barrier)
-
-int synctask_setid (struct synctask *task, uid_t uid, gid_t gid);
-#define SYNCTASK_SETID(uid, gid) synctask_setid (synctask_get(), uid, gid);
-
-int syncopctx_setfsuid (void *uid);
-int syncopctx_setfsgid (void *gid);
-int syncopctx_setfsgroups (int count, const void *groups);
-int syncopctx_setfspid (void *pid);
-int syncopctx_setfslkowner (gf_lkowner_t *lk_owner);
-
-static inline call_frame_t *
-syncop_create_frame (xlator_t *this)
-{
-	call_frame_t     *frame = NULL;
-	int               ngrps = -1;
-	struct syncopctx *opctx = NULL;
-
-	frame = create_frame (this, this->ctx->pool);
-	if (!frame)
-		return NULL;
-
-	opctx = syncopctx_getctx ();
-
-	if (opctx && (opctx->valid & SYNCOPCTX_PID))
-		frame->root->pid = opctx->pid;
-	else
-		frame->root->pid = getpid ();
-
-	if (opctx && (opctx->valid & SYNCOPCTX_UID))
-		frame->root->uid = opctx->uid;
-	else
-		frame->root->uid = geteuid ();
-
-	if (opctx && (opctx->valid & SYNCOPCTX_GID))
-		frame->root->gid = opctx->gid;
-	else
-		frame->root->gid = getegid ();
-
-	if (opctx && (opctx->valid & SYNCOPCTX_GROUPS)) {
-		ngrps = opctx->ngrps;
-
-		if (ngrps != 0 && opctx->groups != NULL) {
-			if (call_stack_alloc_groups (frame->root, ngrps) != 0) {
-				STACK_DESTROY (frame->root);
-				return NULL;
-			}
-
-			memcpy (frame->root->groups, opctx->groups,
-				(sizeof (gid_t) * ngrps));
-		}
-	}
-	else {
-		ngrps = getgroups (0, 0);
-		if (ngrps < 0) {
-			STACK_DESTROY (frame->root);
-			return NULL;
-		}
-
-		if (call_stack_alloc_groups (frame->root, ngrps) != 0) {
-			STACK_DESTROY (frame->root);
-			return NULL;
-		}
-
-		if (getgroups (ngrps, frame->root->groups) < 0) {
-			STACK_DESTROY (frame->root);
-			return NULL;
-		}
-	}
-
-        if (opctx && (opctx->valid & SYNCOPCTX_LKOWNER))
-                frame->root->lk_owner = opctx->lk_owner;
-
-	return frame;
-}
-
-int synclock_init (synclock_t *lock, lock_attr_t attr);
-int synclock_destroy (synclock_t *lock);
-int synclock_lock (synclock_t *lock);
-int synclock_trylock (synclock_t *lock);
-int synclock_unlock (synclock_t *lock);
-
-
-int syncbarrier_init (syncbarrier_t *barrier);
-int syncbarrier_wait (syncbarrier_t *barrier, int waitfor);
-int syncbarrier_wake (syncbarrier_t *barrier);
-int syncbarrier_destroy (syncbarrier_t *barrier);
-
-int syncop_lookup (xlator_t *subvol, loc_t *loc,
-                   /* out */
-                   struct iatt *iatt, struct iatt *parent,
-                   /* xdata */
-                   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_readdirp (xlator_t *subvol, fd_t *fd, size_t size, off_t off,
-                     /* out */
-                     gf_dirent_t *entries,
-                     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_readdir (xlator_t *subvol, fd_t *fd, size_t size, off_t off,
-                    gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_opendir (xlator_t *subvol, loc_t *loc, fd_t *fd, dict_t *xdata_in,
-                    dict_t **xdata_out);
-
-int syncop_setattr (xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
-                    /* out */
-                    struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                    dict_t **xdata_out);
-
-int syncop_fsetattr (xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
-                    /* out */
-                    struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                    dict_t **xdata_out);
-
-int syncop_statfs (xlator_t *subvol, loc_t *loc,
-                   /* out */
-                   struct statvfs *buf,
-                   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_setxattr (xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
-		     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_fsetxattr (xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
-		      dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_listxattr (xlator_t *subvol, loc_t *loc, dict_t **dict,
-		      dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_getxattr (xlator_t *xl, loc_t *loc, dict_t **dict, const char *key,
-                     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_fgetxattr (xlator_t *xl, fd_t *fd, dict_t **dict, const char *key,
-                      dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_removexattr (xlator_t *subvol, loc_t *loc, const char *name,
-			dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_fremovexattr (xlator_t *subvol, fd_t *fd, const char *name,
-			 dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_create (xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
-                   fd_t *fd, struct iatt *iatt,
-                   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_open (xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
-		 dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_close (fd_t *fd);
-
-int syncop_write (xlator_t *subvol, fd_t *fd, const char *buf, int size,
-                  off_t offset, struct iobref *iobref, uint32_t flags,
-		  dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_writev (xlator_t *subvol, fd_t *fd, const struct iovec *vector,
-                   int32_t count, off_t offset, struct iobref *iobref,
-                   uint32_t flags, dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_readv (xlator_t *subvol, fd_t *fd, size_t size, off_t off,
-                  uint32_t flags,
-                  /* out */
-                  struct iovec **vector, int *count, struct iobref **iobref,
-		  dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_ftruncate (xlator_t *subvol, fd_t *fd, off_t offset,
-                      dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_truncate (xlator_t *subvol, loc_t *loc, off_t offset,
-                     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_unlink (xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
-                   dict_t **xdata_out);
-
-int syncop_rmdir (xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
-                  dict_t **xdata_out);
-
-int syncop_fsync (xlator_t *subvol, fd_t *fd, int dataonly, dict_t *xdata_in,
-                  dict_t **xdata_out);
-
-int syncop_flush (xlator_t *subvol, fd_t *fd, dict_t *xdata_in,
-                  dict_t **xdata_out);
-
-int syncop_fstat (xlator_t *subvol, fd_t *fd, struct iatt *stbuf,
-		  dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_stat (xlator_t *subvol, loc_t *loc, struct iatt *stbuf,
-		 dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_symlink (xlator_t *subvol, loc_t *loc, const char *newpath,
-                    struct iatt *iatt,
-                    dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_readlink (xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
-		     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_mknod (xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
-                  struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_mkdir (xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
-                  dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_link (xlator_t *subvol, loc_t *oldloc, loc_t *newloc,
-                 struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_fsyncdir (xlator_t *subvol, fd_t *fd, int datasync,
-                     dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_access (xlator_t *subvol, loc_t *loc, int32_t mask,
-                   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_fallocate(xlator_t *subvol, fd_t *fd, int32_t keep_size,
-		     off_t offset, size_t len, dict_t *xdata_in,
-                     dict_t **xdata_out);
-
-int syncop_discard(xlator_t *subvol, fd_t *fd, off_t offset, size_t len,
-		   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_zerofill(xlator_t *subvol, fd_t *fd, off_t offset, off_t len,
-		    dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_rename (xlator_t *subvol, loc_t *oldloc, loc_t *newloc,
-		   dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_lk (xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
-	       dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_inodelk (xlator_t *subvol, const char *volume, loc_t *loc,
-                    int32_t cmd, struct gf_flock *lock, dict_t *xdata_in,
-                    dict_t **xdata_out);
-
-int syncop_lease (xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
-                  dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_ipc (xlator_t *subvol, int op, dict_t *xdata_in, dict_t **xdata_out);
-
-int syncop_xattrop (xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
-                    dict_t *dict, dict_t *xdata_in, dict_t **xdata_out);
-
-int
-syncop_fxattrop (xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
-                 dict_t *dict, dict_t *xdata_in, dict_t **xdata_out);
-
-int
-syncop_seek (xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
-             dict_t *xdata_in, off_t *off);
-
-int
-syncop_getactivelk (xlator_t *subvol, loc_t *loc,                                                                                                    lock_migration_info_t *locklist,
-                     dict_t *xdata_in, dict_t **xdata_out);
-
-int
-syncop_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-int
-syncop_setactivelk (xlator_t *subvol, loc_t *loc,
-                     lock_migration_info_t *locklist,  dict_t *xdata_in,
-                     dict_t **xdata_out);
-
-#endif /* _SYNCOP_H */
diff --git a/libglusterfs/src/syscall.c b/libglusterfs/src/syscall.c
index a7d4402808d..04400f98b6c 100644
--- a/libglusterfs/src/syscall.c
+++ b/libglusterfs/src/syscall.c
@@ -8,707 +8,869 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "syscall.h"
-#include "compat.h"
-#include "mem-pool.h"
+#include "glusterfs/compat.h"
+#include "glusterfs/syscall.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/libglusterfs-messages.h"
 
+#ifdef __FreeBSD__
+#include <sys/sysctl.h>
+#include <signal.h>
+#endif
 #include <sys/types.h>
 #include <utime.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdarg.h>
+#ifdef HAVE_COPY_FILE_RANGE_SYS
+#include <sys/syscall.h>
+#endif
+
+#define FS_ERROR_LOG(result)                                                   \
+    do {                                                                       \
+        gf_msg_callingfn("FS", GF_LOG_CRITICAL, EIO,                           \
+                         LG_MSG_SYSCALL_RETURNS_WRONG,                         \
+                         "returned %zd for the syscall", (ssize_t)result);     \
+    } while (0)
+
+/*
+ * Input to these macros is generally a function call, so capture the result
+ * i.e. (_ret) in another variable and use that instead of using _ret again
+ */
+#define FS_RET_CHECK(_ret, err)                                                \
+    ({                                                                         \
+        typeof(_ret) _result = (_ret);                                         \
+        if (_result < -1) {                                                    \
+            FS_ERROR_LOG(_result);                                             \
+            _result = -1;                                                      \
+            err = EIO;                                                         \
+        }                                                                      \
+        _result;                                                               \
+    })
+
+#define FS_RET_CHECK0(_ret, err)                                               \
+    ({                                                                         \
+        typeof(_ret) _result0 = (_ret);                                        \
+        if (_result0 < -1 || _result0 > 0) {                                   \
+            FS_ERROR_LOG(_result0);                                            \
+            _result0 = -1;                                                     \
+            err = EIO;                                                         \
+        }                                                                      \
+        _result0;                                                              \
+    })
+
+#define FS_RET_CHECK_ERRNO(_ret, err)                                          \
+    ({                                                                         \
+        typeof(_ret) _result1 = (_ret);                                        \
+        if (_result1 < 0) {                                                    \
+            FS_ERROR_LOG(_result1);                                            \
+            _result1 = -1;                                                     \
+            err = EIO;                                                         \
+        } else if (_result1 > 0) {                                             \
+            err = _result1;                                                    \
+            _result1 = -1;                                                     \
+        }                                                                      \
+        _result1;                                                              \
+    })
 
 int
-sys_lstat (const char *path, struct stat *buf)
+sys_lstat(const char *path, struct stat *buf)
 {
-        return lstat (path, buf);
+    return FS_RET_CHECK0(lstat(path, buf), errno);
 }
 
-
 int
-sys_stat (const char *path, struct stat *buf)
+sys_stat(const char *path, struct stat *buf)
 {
-        return stat (path, buf);
+    return FS_RET_CHECK0(stat(path, buf), errno);
 }
 
-
 int
-sys_fstat (int fd, struct stat *buf)
+sys_fstat(int fd, struct stat *buf)
 {
-        return fstat (fd, buf);
+    return FS_RET_CHECK0(fstat(fd, buf), errno);
 }
 
-
 int
 sys_fstatat(int dirfd, const char *pathname, struct stat *buf, int flags)
 {
 #ifdef GF_DARWIN_HOST_OS
-        if (fchdir(dirfd) < 0)
-                return -1;
-        if(flags & AT_SYMLINK_NOFOLLOW)
-                return lstat(pathname, buf);
-        else
-                return stat(pathname, buf);
+    if (fchdir(dirfd) < 0)
+        return -1;
+    if (flags & AT_SYMLINK_NOFOLLOW)
+        return FS_RET_CHECK0(lstat(pathname, buf), errno);
+    else
+        return FS_RET_CHECK0(stat(pathname, buf), errno);
 #else
-        return fstatat (dirfd, pathname, buf, flags);
+    return FS_RET_CHECK0(fstatat(dirfd, pathname, buf, flags), errno);
 #endif
 }
 
-
 int
 sys_openat(int dirfd, const char *pathname, int flags, int mode)
 {
-        int fd;
+    int fd;
 
 #ifdef GF_DARWIN_HOST_OS
-        if (fchdir(dirfd) < 0)
-                return -1;
-        fd = open (pathname, flags, mode);
-        /* TODO: Shouldn't we restore the old current directory */
+    if (fchdir(dirfd) < 0)
+        return -1;
+    fd = open(pathname, flags, mode);
+    /* TODO: Shouldn't we restore the old current directory */
 #else /* GF_DARWIN_HOST_OS */
-        fd = openat (dirfd, pathname, flags, mode);
+    fd = openat(dirfd, pathname, flags, mode);
 #ifdef __FreeBSD__
-        /* On FreeBSD S_ISVTX flag is ignored for an open() with O_CREAT set.
-         * We need to force the flag using fchmod(). */
-        if ((fd >= 0) &&
-            ((flags & O_CREAT) != 0) && ((mode & S_ISVTX) != 0)) {
-                sys_fchmod(fd, mode);
-                /* TODO: It's unlikely that fchmod could fail here. However,
-                         if it fails we cannot always restore the old state
-                         (if the file existed, we cannot recover it). We would
-                         need many more system calls to correctly handle all
-                         possible cases and it doesn't worth it. For now we
-                         simply ignore the error. */
-        }
+    /* On FreeBSD S_ISVTX flag is ignored for an open() with O_CREAT set.
+     * We need to force the flag using fchmod(). */
+    if ((fd >= 0) && ((flags & O_CREAT) != 0) && ((mode & S_ISVTX) != 0)) {
+        sys_fchmod(fd, mode);
+        /* TODO: It's unlikely that fchmod could fail here. However,
+                 if it fails we cannot always restore the old state
+                 (if the file existed, we cannot recover it). We would
+                 need many more system calls to correctly handle all
+                 possible cases and it doesn't worth it. For now we
+                 simply ignore the error. */
+    }
 #endif /* __FreeBSD__ */
 #endif /* !GF_DARWIN_HOST_OS */
 
-        return fd;
+    return FS_RET_CHECK(fd, errno);
 }
 
-
 int
 sys_open(const char *pathname, int flags, int mode)
 {
-        return sys_openat(AT_FDCWD, pathname, flags, mode);
+    return FS_RET_CHECK(sys_openat(AT_FDCWD, pathname, flags, mode), errno);
 }
 
-
 DIR *
-sys_opendir (const char *name)
+sys_opendir(const char *name)
 {
-        return opendir (name);
+    return opendir(name);
 }
 
-int sys_mkdirat(int dirfd, const char *pathname, mode_t mode)
+int
+sys_mkdirat(int dirfd, const char *pathname, mode_t mode)
 {
 #ifdef GF_DARWIN_HOST_OS
-        if(fchdir(dirfd) < 0)
-                return -1;
-        return mkdir(pathname, mode);
+    if (fchdir(dirfd) < 0)
+        return -1;
+    return FS_RET_CHECK0(mkdir(pathname, mode), errno);
 #else
-        return mkdirat (dirfd, pathname, mode);
+    return FS_RET_CHECK0(mkdirat(dirfd, pathname, mode), errno);
 #endif
 }
 
 struct dirent *
-sys_readdir (DIR *dir, struct dirent *de)
+sys_readdir(DIR *dir, struct dirent *de)
 {
 #if !defined(__GLIBC__)
-        /*
-         * World+Dog says glibc's readdir(3) is MT-SAFE as long as
-         * two threads are not accessing the same DIR; there's a
-         * potential buffer overflow in glibc's readdir_r(3); and
-         * glibc's readdir_r(3) is deprecated after version 2.22
-         * with presumed eventual removal.
-         * Given all that, World+Dog says everyone should just use
-         * readdir(3). But it's unknown, unclear whether the same
-         * is also true for *BSD, MacOS, and, etc.
-        */
-        struct dirent *entry = NULL;
-
-        (void) readdir_r (dir, de, &entry);
-        return entry;
+    /*
+     * World+Dog says glibc's readdir(3) is MT-SAFE as long as
+     * two threads are not accessing the same DIR; there's a
+     * potential buffer overflow in glibc's readdir_r(3); and
+     * glibc's readdir_r(3) is deprecated after version 2.22
+     * with presumed eventual removal.
+     * Given all that, World+Dog says everyone should just use
+     * readdir(3). But it's unknown, unclear whether the same
+     * is also true for *BSD, MacOS, and, etc.
+     */
+    struct dirent *entry = NULL;
+
+    (void)readdir_r(dir, de, &entry);
+    return entry;
 #else
-        return readdir (dir);
+    return readdir(dir);
 #endif
 }
 
-
 ssize_t
-sys_readlink (const char *path, char *buf, size_t bufsiz)
+sys_readlink(const char *path, char *buf, size_t bufsiz)
 {
-        return readlink (path, buf, bufsiz);
+    return FS_RET_CHECK(readlink(path, buf, bufsiz), errno);
 }
 
-
 int
-sys_closedir (DIR *dir)
+sys_closedir(DIR *dir)
 {
-        return closedir (dir);
+    return FS_RET_CHECK0(closedir(dir), errno);
 }
 
-
 int
-sys_mknod (const char *pathname, mode_t mode, dev_t dev)
+sys_mknod(const char *pathname, mode_t mode, dev_t dev)
 {
-        return mknod (pathname, mode, dev);
+    return FS_RET_CHECK0(mknod(pathname, mode, dev), errno);
 }
 
-
 int
-sys_mkdir (const char *pathname, mode_t mode)
+sys_mkdir(const char *pathname, mode_t mode)
 {
-        return mkdir (pathname, mode);
+    return FS_RET_CHECK0(mkdir(pathname, mode), errno);
 }
 
-
 int
-sys_unlink (const char *pathname)
+sys_unlink(const char *pathname)
 {
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_unlink (pathname);
+    return FS_RET_CHECK0(solaris_unlink(pathname), errno);
 #endif
-        return unlink (pathname);
+    return FS_RET_CHECK0(unlink(pathname), errno);
 }
 
-
 int
-sys_rmdir (const char *pathname)
+sys_unlinkat(int dfd, const char *pathname)
 {
-        return rmdir (pathname);
+#ifdef GF_SOLARIS_HOST_OS
+    return FS_RET_CHECK0(solaris_unlinkat(dfd, pathname, 0), errno);
+#endif
+    return FS_RET_CHECK0(unlinkat(dfd, pathname, 0), errno);
 }
 
+int
+sys_rmdir(const char *pathname)
+{
+    return FS_RET_CHECK0(rmdir(pathname), errno);
+}
 
 int
-sys_symlink (const char *oldpath, const char *newpath)
+sys_symlink(const char *oldpath, const char *newpath)
 {
-        return symlink (oldpath, newpath);
+    return FS_RET_CHECK0(symlink(oldpath, newpath), errno);
 }
 
+int
+sys_symlinkat(const char *oldpath, int dirfd, const char *newpath)
+{
+    return FS_RET_CHECK0(symlinkat(oldpath, dirfd, newpath), errno);
+}
 
 int
-sys_rename (const char *oldpath, const char *newpath)
+sys_rename(const char *oldpath, const char *newpath)
 {
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_rename (oldpath, newpath);
+    return FS_RET_CHECK0(solaris_rename(oldpath, newpath), errno);
 #endif
-        return rename (oldpath, newpath);
+    return FS_RET_CHECK0(rename(oldpath, newpath), errno);
 }
 
-
 int
-sys_link (const char *oldpath, const char *newpath)
+sys_link(const char *oldpath, const char *newpath)
 {
 #ifdef HAVE_LINKAT
-	/*
-	 * On most systems (Linux being the notable exception), link(2)
-	 * first resolves symlinks. If the target is a directory or
-	 * is nonexistent, it will fail. linkat(2) operates on the
-	 * symlink instead of its target when the AT_SYMLINK_FOLLOW
-	 * flag is not supplied.
-	 */
-        return linkat (AT_FDCWD, oldpath, AT_FDCWD, newpath, 0);
+    /*
+     * On most systems (Linux being the notable exception), link(2)
+     * first resolves symlinks. If the target is a directory or
+     * is nonexistent, it will fail. linkat(2) operates on the
+     * symlink instead of its target when the AT_SYMLINK_FOLLOW
+     * flag is not supplied.
+     */
+    return FS_RET_CHECK0(linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0),
+                         errno);
 #else
-        return link (oldpath, newpath);
+    return FS_RET_CHECK0(link(oldpath, newpath), errno);
 #endif
 }
 
-
 int
-sys_chmod (const char *path, mode_t mode)
+sys_linkat(int oldfd, const char *oldpath, int newfd, const char *newpath)
 {
-        return chmod (path, mode);
+    return FS_RET_CHECK0(linkat(oldfd, oldpath, newfd, newpath, 0), errno);
 }
 
-
 int
-sys_fchmod (int fd, mode_t mode)
+sys_chmod(const char *path, mode_t mode)
 {
-        return fchmod (fd, mode);
+    return FS_RET_CHECK0(chmod(path, mode), errno);
 }
 
-
 int
-sys_chown (const char *path, uid_t owner, gid_t group)
+sys_fchmod(int fd, mode_t mode)
 {
-        return chown (path, owner, group);
+    return FS_RET_CHECK0(fchmod(fd, mode), errno);
 }
 
-
 int
-sys_fchown (int fd, uid_t owner, gid_t group)
+sys_chown(const char *path, uid_t owner, gid_t group)
 {
-        return fchown (fd, owner, group);
+    return FS_RET_CHECK0(chown(path, owner, group), errno);
 }
 
-
 int
-sys_lchown (const char *path, uid_t owner, gid_t group)
+sys_fchown(int fd, uid_t owner, gid_t group)
 {
-        return lchown (path, owner, group);
+    return FS_RET_CHECK0(fchown(fd, owner, group), errno);
 }
 
-
 int
-sys_truncate (const char *path, off_t length)
+sys_lchown(const char *path, uid_t owner, gid_t group)
 {
-        return truncate (path, length);
+    return FS_RET_CHECK0(lchown(path, owner, group), errno);
 }
 
-
 int
-sys_ftruncate (int fd, off_t length)
+sys_truncate(const char *path, off_t length)
 {
-        return ftruncate (fd, length);
+    return FS_RET_CHECK0(truncate(path, length), errno);
 }
 
-
 int
-sys_utimes (const char *filename, const struct timeval times[2])
+sys_ftruncate(int fd, off_t length)
 {
-        return utimes (filename, times);
+    return FS_RET_CHECK0(ftruncate(fd, length), errno);
 }
 
+int
+sys_utimes(const char *filename, const struct timeval times[2])
+{
+    return FS_RET_CHECK0(utimes(filename, times), errno);
+}
 
 #if defined(HAVE_UTIMENSAT)
 int
-sys_utimensat (int dirfd, const char *filename, const struct timespec times[2],
-               int flags)
+sys_utimensat(int dirfd, const char *filename, const struct timespec times[2],
+              int flags)
 {
-        return utimensat (dirfd, filename, times, flags);
+    return FS_RET_CHECK0(utimensat(dirfd, filename, times, flags), errno);
 }
 #endif
 
-
 int
-sys_creat (const char *pathname, mode_t mode)
+sys_futimes(int fd, const struct timeval times[2])
 {
-        return sys_open(pathname, O_CREAT | O_TRUNC | O_WRONLY, mode);
+    return futimes(fd, times);
 }
 
+int
+sys_creat(const char *pathname, mode_t mode)
+{
+    return FS_RET_CHECK(sys_open(pathname, O_CREAT | O_TRUNC | O_WRONLY, mode),
+                        errno);
+}
 
 ssize_t
-sys_readv (int fd, const struct iovec *iov, int iovcnt)
+sys_readv(int fd, const struct iovec *iov, int iovcnt)
 {
-        return readv (fd, iov, iovcnt);
+    return FS_RET_CHECK(readv(fd, iov, iovcnt), errno);
 }
 
-
 ssize_t
-sys_writev (int fd, const struct iovec *iov, int iovcnt)
+sys_writev(int fd, const struct iovec *iov, int iovcnt)
 {
-        return writev (fd, iov, iovcnt);
+    return FS_RET_CHECK(writev(fd, iov, iovcnt), errno);
 }
 
-
 ssize_t
-sys_read (int fd, void *buf, size_t count)
+sys_read(int fd, void *buf, size_t count)
 {
-        return read (fd, buf, count);
+    return FS_RET_CHECK(read(fd, buf, count), errno);
 }
 
-
 ssize_t
-sys_write (int fd, const void *buf, size_t count)
+sys_write(int fd, const void *buf, size_t count)
 {
-        return write (fd, buf, count);
+    return FS_RET_CHECK(write(fd, buf, count), errno);
 }
 
-
 ssize_t
-sys_preadv (int fd, const struct iovec *iov, int iovcnt, off_t offset)
+sys_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset)
 {
-        return preadv (fd, iov, iovcnt, offset);
+    return FS_RET_CHECK(preadv(fd, iov, iovcnt, offset), errno);
 }
 
-
 ssize_t
-sys_pwritev (int fd, const struct iovec *iov, int iovcnt, off_t offset)
+sys_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset)
 {
-        return pwritev (fd, iov, iovcnt, offset);
+    return FS_RET_CHECK(pwritev(fd, iov, iovcnt, offset), errno);
 }
 
-
 ssize_t
-sys_pread (int fd, void *buf, size_t count, off_t offset)
+sys_pread(int fd, void *buf, size_t count, off_t offset)
 {
-        return pread (fd, buf, count, offset);
+    return FS_RET_CHECK(pread(fd, buf, count, offset), errno);
 }
 
-
 ssize_t
-sys_pwrite (int fd, const void *buf, size_t count, off_t offset)
+sys_pwrite(int fd, const void *buf, size_t count, off_t offset)
 {
-        return pwrite (fd, buf, count, offset);
+    return FS_RET_CHECK(pwrite(fd, buf, count, offset), errno);
 }
 
-
 off_t
-sys_lseek (int fd, off_t offset, int whence)
+sys_lseek(int fd, off_t offset, int whence)
 {
-        return lseek (fd, offset, whence);
+    return FS_RET_CHECK(lseek(fd, offset, whence), errno);
 }
 
-
 int
-sys_statvfs (const char *path, struct statvfs *buf)
+sys_statvfs(const char *path, struct statvfs *buf)
 {
-        int ret;
+    int ret;
 
-        ret = statvfs (path, buf);
+    ret = statvfs(path, buf);
 #ifdef __FreeBSD__
-        /* FreeBSD doesn't return the expected vaule in buf->f_bsize. It
-         * contains the optimal I/O size instead of the file system block
-         * size. Gluster expects that this field contains the block size.
-         */
-        if (ret == 0) {
-                buf->f_bsize = buf->f_frsize;
-        }
+    /* FreeBSD doesn't return the expected value in buf->f_bsize. It
+     * contains the optimal I/O size instead of the file system block
+     * size. Gluster expects that this field contains the block size.
+     */
+    if (ret == 0) {
+        buf->f_bsize = buf->f_frsize;
+    }
 #endif /* __FreeBSD__ */
 
-        return ret;
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_fstatvfs (int fd, struct statvfs *buf)
+sys_fstatvfs(int fd, struct statvfs *buf)
 {
-        int ret;
+    int ret;
 
-        ret = fstatvfs (fd, buf);
+    ret = fstatvfs(fd, buf);
 #ifdef __FreeBSD__
-        /* FreeBSD doesn't return the expected vaule in buf->f_bsize. It
-         * contains the optimal I/O size instead of the file system block
-         * size. Gluster expects this field to contain the block size.
-         */
-        if (ret == 0) {
-                buf->f_bsize = buf->f_frsize;
-        }
+    /* FreeBSD doesn't return the expected value in buf->f_bsize. It
+     * contains the optimal I/O size instead of the file system block
+     * size. Gluster expects this field to contain the block size.
+     */
+    if (ret == 0) {
+        buf->f_bsize = buf->f_frsize;
+    }
 #endif /* __FreeBSD__ */
 
-        return ret;
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_close (int fd)
+sys_close(int fd)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (fd >= 0)
-                ret = close (fd);
+    if (fd >= 0)
+        ret = close(fd);
 
-        return ret;
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_fsync (int fd)
+sys_fsync(int fd)
 {
-        return fsync (fd);
+    return FS_RET_CHECK0(fsync(fd), errno);
 }
 
-
 int
-sys_fdatasync (int fd)
+sys_fdatasync(int fd)
 {
 #ifdef GF_DARWIN_HOST_OS
-        return fcntl (fd, F_FULLFSYNC);
+    return FS_RET_CHECK0(fcntl(fd, F_FULLFSYNC), errno);
 #elif __FreeBSD__
-	return fsync (fd);
+    return FS_RET_CHECK0(fsync(fd), errno);
 #else
-        return fdatasync (fd);
+    return FS_RET_CHECK0(fdatasync(fd), errno);
 #endif
 }
 
 void
 gf_add_prefix(const char *ns, const char *key, char **newkey)
 {
-        /* if we dont have any namespace, append USER NS */
-        if (strncmp(key, XATTR_USER_PREFIX,     XATTR_USER_PREFIX_LEN) &&
-            strncmp(key, XATTR_TRUSTED_PREFIX,  XATTR_TRUSTED_PREFIX_LEN) &&
-            strncmp(key, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
-            strncmp(key, XATTR_SYSTEM_PREFIX,   XATTR_SYSTEM_PREFIX_LEN)) {
-                int ns_length =  strlen(ns);
-                *newkey = GF_MALLOC(ns_length + strlen(key) + 10,
-                                    gf_common_mt_char);
-                strcpy(*newkey, ns);
-                strcat(*newkey, key);
-        } else {
-                *newkey = gf_strdup(key);
-        }
+    /* if we don't have any namespace, append USER NS */
+    if (strncmp(key, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
+        strncmp(key, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) &&
+        strncmp(key, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
+        strncmp(key, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) {
+        int ns_length = strlen(ns);
+        *newkey = GF_MALLOC(ns_length + strlen(key) + 10, gf_common_mt_char);
+        if (!*newkey)
+            return;
+        strcpy(*newkey, ns);
+        strcat(*newkey, key);
+    } else {
+        *newkey = gf_strdup(key);
+    }
 }
 
 void
 gf_remove_prefix(const char *ns, const char *key, char **newkey)
 {
-        int ns_length =  strlen(ns);
-        if (strncmp(key, ns, ns_length) == 0) {
-                *newkey = GF_MALLOC(-ns_length + strlen(key) + 10,
-                                    gf_common_mt_char);
-                strcpy(*newkey, key + ns_length);
-        } else {
-                *newkey = gf_strdup(key);
-        }
+    int ns_length = strlen(ns);
+    if (strncmp(key, ns, ns_length) == 0) {
+        *newkey = GF_MALLOC(-ns_length + strlen(key) + 10, gf_common_mt_char);
+        if (!*newkey)
+            return;
+        strcpy(*newkey, key + ns_length);
+    } else {
+        *newkey = gf_strdup(key);
+    }
 }
 
 int
-sys_lsetxattr (const char *path, const char *name, const void *value,
-               size_t size, int flags)
+sys_lsetxattr(const char *path, const char *name, const void *value,
+              size_t size, int flags)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return lsetxattr (path, name, value, size, flags);
+    return FS_RET_CHECK0(lsetxattr(path, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_set_link (path, EXTATTR_NAMESPACE_USER,
-                                 name, value, size);
+    return FS_RET_CHECK(
+        extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_setxattr (path, name, value, size, flags);
+    return FS_RET_CHECK0(solaris_setxattr(path, name, value, size, flags),
+                         errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        /* OS X clients will carry other flags, which will be used on a
-           OS X host, but masked out on others. GF assume NOFOLLOW on Linux,
-           enforcing  */
-        return setxattr (path, name, value, size, 0,
-                         (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW);
+    /* OS X clients will carry other flags, which will be used on a
+       OS X host, but masked out on others. GF assume NOFOLLOW on Linux,
+       enforcing  */
+    return FS_RET_CHECK0(setxattr(path, name, value, size, 0,
+                                  (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW),
+                         errno);
 #endif
-
 }
 
-
 ssize_t
-sys_llistxattr (const char *path, char *list, size_t size)
+sys_llistxattr(const char *path, char *list, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return llistxattr (path, list, size);
+    return FS_RET_CHECK(llistxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_list_link (path, EXTATTR_NAMESPACE_USER, list, size);
+    ssize_t ret = FS_RET_CHECK(
+        extattr_list_link(path, EXTATTR_NAMESPACE_USER, list, size), errno);
+    gf_extattr_list_reshape(list, ret);
+    return ret;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_listxattr (path, list, size);
+    return FS_RET_CHECK(solaris_listxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return listxattr (path, list, size, XATTR_NOFOLLOW);
+    return FS_RET_CHECK(listxattr(path, list, size, XATTR_NOFOLLOW), errno);
 #endif
 }
 
 ssize_t
-sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
+sys_lgetxattr(const char *path, const char *name, void *value, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return lgetxattr (path, name, value, size);
+    return FS_RET_CHECK(lgetxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_get_link (path, EXTATTR_NAMESPACE_USER, name, value,
-                                 size);
+    return FS_RET_CHECK(
+        extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_getxattr (path, name, value, size);
+    return FS_RET_CHECK(solaris_getxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-         return getxattr (path, name, value, size, 0, XATTR_NOFOLLOW);
+    return FS_RET_CHECK(getxattr(path, name, value, size, 0, XATTR_NOFOLLOW),
+                        errno);
 #endif
-
 }
 
-
 ssize_t
-sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
+sys_fgetxattr(int filedes, const char *name, void *value, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return fgetxattr (filedes, name, value, size);
+    return FS_RET_CHECK(fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_get_fd (filedes, EXTATTR_NAMESPACE_USER, name,
-                               value, size);
+    return FS_RET_CHECK(
+        extattr_get_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_fgetxattr (filedes, name, value, size);
+    return FS_RET_CHECK(solaris_fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return fgetxattr (filedes, name, value, size, 0, 0);
+    return FS_RET_CHECK(fgetxattr(filedes, name, value, size, 0, 0), errno);
 #endif
-
 }
 
 int
-sys_fremovexattr (int filedes, const char *name)
+sys_fremovexattr(int filedes, const char *name)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return fremovexattr (filedes, name);
+    return FS_RET_CHECK0(fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_delete_fd (filedes, EXTATTR_NAMESPACE_USER, name);
+    return FS_RET_CHECK0(
+        extattr_delete_fd(filedes, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_fremovexattr (filedes, name);
+    return FS_RET_CHECK0(solaris_fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return fremovexattr (filedes, name, 0);
+    return FS_RET_CHECK0(fremovexattr(filedes, name, 0), errno);
 #endif
 }
 
-
 int
-sys_fsetxattr (int filedes, const char *name, const void *value,
-               size_t size, int flags)
+sys_fsetxattr(int filedes, const char *name, const void *value, size_t size,
+              int flags)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return fsetxattr (filedes, name, value, size, flags);
+    return FS_RET_CHECK0(fsetxattr(filedes, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_set_fd (filedes, EXTATTR_NAMESPACE_USER, name,
-                               value, size);
+    return FS_RET_CHECK(
+        extattr_set_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_fsetxattr (filedes, name, value, size, flags);
+    return FS_RET_CHECK0(solaris_fsetxattr(filedes, name, value, size, flags),
+                         errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return fsetxattr (filedes, name, value, size, 0,
-                          flags & ~XATTR_NOSECURITY);
+    return FS_RET_CHECK0(
+        fsetxattr(filedes, name, value, size, 0, flags & ~XATTR_NOSECURITY),
+        errno);
 #endif
-
 }
 
-
 ssize_t
-sys_flistxattr (int filedes, char *list, size_t size)
+sys_flistxattr(int filedes, char *list, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return flistxattr (filedes, list, size);
+    return FS_RET_CHECK(flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_list_fd (filedes, EXTATTR_NAMESPACE_USER, list, size);
+    ssize_t ret = FS_RET_CHECK(
+        extattr_list_fd(filedes, EXTATTR_NAMESPACE_USER, list, size), errno);
+    gf_extattr_list_reshape(list, ret);
+    return ret;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_flistxattr (filedes, list, size);
+    return FS_RET_CHECK(solaris_flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return flistxattr (filedes, list, size, XATTR_NOFOLLOW);
+    return FS_RET_CHECK(flistxattr(filedes, list, size, XATTR_NOFOLLOW), errno);
 #endif
-
 }
 
-
 int
-sys_lremovexattr (const char *path, const char *name)
+sys_lremovexattr(const char *path, const char *name)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return lremovexattr (path, name);
+    return FS_RET_CHECK0(lremovexattr(path, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return extattr_delete_link (path, EXTATTR_NAMESPACE_USER, name);
+    return FS_RET_CHECK0(
+        extattr_delete_link(path, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return solaris_removexattr (path, name);
+    return FS_RET_CHECK0(solaris_removexattr(path, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return removexattr (path, name, XATTR_NOFOLLOW);
+    return FS_RET_CHECK0(removexattr(path, name, XATTR_NOFOLLOW), errno);
 #endif
-
 }
 
-
 int
-sys_access (const char *pathname, int mode)
+sys_access(const char *pathname, int mode)
 {
-        return access (pathname, mode);
+    return FS_RET_CHECK0(access(pathname, mode), errno);
 }
 
-
 int
 sys_fallocate(int fd, int mode, off_t offset, off_t len)
 {
 #ifdef HAVE_FALLOCATE
-        return fallocate(fd, mode, offset, len);
+    return FS_RET_CHECK0(fallocate(fd, mode, offset, len), errno);
 #endif
 
 #ifdef HAVE_POSIX_FALLOCATE
-        if (mode) {
-                /* keep size not supported */
-                errno = EOPNOTSUPP;
-                return -1;
-        }
+    if (mode) {
+        /* keep size not supported */
+        errno = EOPNOTSUPP;
+        return -1;
+    }
 
-        return posix_fallocate(fd, offset, len);
+    return FS_RET_CHECK_ERRNO(posix_fallocate(fd, offset, len), errno);
 #endif
 
 #if defined(F_ALLOCATECONTIG) && defined(GF_DARWIN_HOST_OS)
-        /* C conversion from C++ implementation for OSX by Mozilla Foundation */
-        if (mode) {
-                /* keep size not supported */
-                errno = EOPNOTSUPP;
-                return -1;
+    /* C conversion from C++ implementation for OSX by Mozilla Foundation */
+    if (mode) {
+        /* keep size not supported */
+        errno = EOPNOTSUPP;
+        return -1;
+    }
+    /*
+     *   The F_PREALLOCATE command operates on the following structure:
+     *
+     *    typedef struct fstore {
+     *    u_int32_t fst_flags;      // IN: flags word
+     *    int       fst_posmode;    // IN: indicates offset field
+     *    off_t     fst_offset;     // IN: start of the region
+     *    off_t     fst_length;     // IN: size of the region
+     *    off_t     fst_bytesalloc; // OUT: number of bytes allocated
+     *    } fstore_t;
+     *
+     * The flags (fst_flags) for the F_PREALLOCATE command are as follows:
+     *    F_ALLOCATECONTIG   Allocate contiguous space.
+     *    F_ALLOCATEALL      Allocate all requested space or no space at all.
+     *
+     * The position modes (fst_posmode) for the F_PREALLOCATE command
+     * indicate how to use the offset field.  The modes are as follows:
+     *    F_PEOFPOSMODE   Allocate from the physical end of file.
+     *    F_VOLPOSMODE    Allocate from the volume offset.
+     *
+     */
+
+    int ret;
+    fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, offset, len, 0};
+    ret = fcntl(fd, F_PREALLOCATE, &store);
+    if (ret == -1) {
+        store.fst_flags = F_ALLOCATEALL;
+        ret = fcntl(fd, F_PREALLOCATE, &store);
+    }
+    if (ret == -1)
+        return ret;
+    return FS_RET_CHECK0(ftruncate(fd, offset + len), errno);
+#endif
+    errno = ENOSYS;
+    return -1;
+}
+
+int
+sys_socket(int domain, int type, int protocol)
+{
+#ifdef SOCK_CLOEXEC
+    return socket(domain, type | SOCK_CLOEXEC, protocol);
+#else
+    int fd = -1;
+
+    fd = socket(domain, type, protocol);
+    if (fd >= 0)
+        fcntl(fd, F_SETFD, FD_CLOEXEC);
+    return fd;
+#endif
+}
+
+#if (defined(HAVE_ACCEPT4) || defined(HAVE_PACCEPT))
+static inline int
+prep_accept_flags(int flags)
+{
+    if (flags & O_NONBLOCK) {
+        flags &= ~O_NONBLOCK;
+        flags |= SOCK_NONBLOCK;
+    }
+
+    flags |= SOCK_CLOEXEC;
+
+    return flags;
+}
+#endif
+
+int
+sys_accept(int sock, struct sockaddr *sockaddr, socklen_t *socklen, int flags)
+{
+    int newsock = -1;
+
+#ifdef HAVE_ACCEPT4
+
+    flags = prep_accept_flags(flags);
+    newsock = accept4(sock, sockaddr, socklen, flags);
+
+#elif HAVE_PACCEPT
+    flags = prep_accept_flags(flags);
+    newsock = paccept(sock, sockaddr, socklen, NULL, flags);
+
+#else
+    int op_errno = 0;
+    int curflag = 0;
+    int ret = 0;
+
+    newsock = accept(sock, sockaddr, socklen);
+    if (newsock != -1) {
+        curflag = fcntl(newsock, F_GETFL);
+        if (fcntl(newsock, F_SETFL, curflag | flags) == -1) {
+            op_errno = errno;
+            goto err;
         }
-        /*
-         *   The F_PREALLOCATE command operates on the following structure:
-         *
-         *    typedef struct fstore {
-         *    u_int32_t fst_flags;      // IN: flags word
-         *    int       fst_posmode;    // IN: indicates offset field
-         *    off_t     fst_offset;     // IN: start of the region
-         *    off_t     fst_length;     // IN: size of the region
-         *    off_t     fst_bytesalloc; // OUT: number of bytes allocated
-         *    } fstore_t;
-         *
-         * The flags (fst_flags) for the F_PREALLOCATE command are as follows:
-         *    F_ALLOCATECONTIG   Allocate contiguous space.
-         *    F_ALLOCATEALL      Allocate all requested space or no space at all.
-         *
-         * The position modes (fst_posmode) for the F_PREALLOCATE command
-         * indicate how to use the offset field.  The modes are as follows:
-         *    F_PEOFPOSMODE   Allocate from the physical end of file.
-         *    F_VOLPOSMODE    Allocate from the volume offset.
-         *
-         */
-
-        int ret;
-        fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, offset, len, 0};
-        ret = fcntl (fd, F_PREALLOCATE, &store);
-        if (ret == -1) {
-                store.fst_flags = F_ALLOCATEALL;
-                ret = fcntl (fd, F_PREALLOCATE, &store);
+
+        curflag = fcntl(newsock, F_GETFD);
+        if (fcntl(newsock, F_SETFD, curflag | FD_CLOEXEC) == -1) {
+            op_errno = errno;
+            goto err;
         }
-        if (ret == -1)
-                return ret;
-        return ftruncate (fd, offset + len);
-#endif
-        errno = ENOSYS;
+    }
+
+err:
+    if (op_errno) {
+        close(newsock);
+        errno = op_errno;
         return -1;
+    }
+
+#endif
+    return newsock;
 }
+
+ssize_t
+sys_copy_file_range(int fd_in, off64_t *off_in, int fd_out, off64_t *off_out,
+                    size_t len, unsigned int flags)
+{
+    /*
+     * TODO: Add check for other platofrms like freebsd etc if this syscall is
+     *       not generic.
+     * This is what the function does.
+     *       1) Check whether copy_file_range API is present. If so call it.
+     *       2) If copy_file_range API is not present, then check whether
+     *          the system call is there. If so, then use syscall to invoke
+     *          SYS_copy_file_range system call.
+     *       3) If neither of the above is present, then return ENOSYS.
+     */
+#ifdef HAVE_COPY_FILE_RANGE
+    return FS_RET_CHECK(
+        copy_file_range(fd_in, off_in, fd_out, off_out, len, flags), errno);
+#else
+#ifdef HAVE_COPY_FILE_RANGE_SYS
+    return syscall(SYS_copy_file_range, fd_in, off_in, fd_out, off_out, len,
+                   flags);
+#else
+    errno = ENOSYS;
+    return -1;
+#endif /* HAVE_COPY_FILE_RANGE_SYS */
+#endif /* HAVE_COPY_FILE_RANGE */
+}
+
+#ifdef __FreeBSD__
+int
+sys_kill(pid_t pid, int sig)
+{
+    return FS_RET_CHECK0(kill(pid, sig), errno);
+}
+
+int
+sys_sysctl(const int *name, u_int namelen, void *oldp, size_t *oldlenp,
+           const void *newp, size_t newlen)
+{
+    return FS_RET_CHECK0(sysctl(name, namelen, oldp, oldlenp, newp, newlen),
+                         errno);
+}
+#endif
diff --git a/libglusterfs/src/syscall.h b/libglusterfs/src/syscall.h
deleted file mode 100644
index 0cb61b66d36..00000000000
--- a/libglusterfs/src/syscall.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __SYSCALL_H__
-#define __SYSCALL_H__
-
-#include <dirent.h>
-#include <sys/uio.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-
-/* GF follows the Linux XATTR definition, which differs in Darwin. */
-#define GF_XATTR_CREATE  0x1 /* set value, fail if attr already exists */
-#define GF_XATTR_REPLACE 0x2 /* set value, fail if attr does not exist */
-
-/* Linux kernel version 2.6.x don't have these defined
-   define if not defined */
-
-#ifndef XATTR_SECURITY_PREFIX
-#define XATTR_SECURITY_PREFIX "security."
-#define XATTR_SECURITY_PREFIX_LEN (sizeof (XATTR_SECURITY_PREFIX) - 1)
-#endif
-
-#ifndef XATTR_SYSTEM_PREFIX
-#define XATTR_SYSTEM_PREFIX "system."
-#define XATTR_SYSTEM_PREFIX_LEN (sizeof (XATTR_SYSTEM_PREFIX) - 1)
-#endif
-
-#ifndef XATTR_TRUSTED_PREFIX
-#define XATTR_TRUSTED_PREFIX "trusted."
-#define XATTR_TRUSTED_PREFIX_LEN (sizeof (XATTR_TRUSTED_PREFIX) - 1)
-#endif
-
-#ifndef XATTR_USER_PREFIX
-#define XATTR_USER_PREFIX "user."
-#define XATTR_USER_PREFIX_LEN (sizeof (XATTR_USER_PREFIX) - 1)
-#endif
-
-#if defined(GF_DARWIN_HOST_OS)
-#include <sys/xattr.h>
-#define XATTR_DARWIN_NOSECURITY XATTR_NOSECURITY
-#define XATTR_DARWIN_NODEFAULT  XATTR_NODEFAULT
-#define XATTR_DARWIN_SHOWCOMPRESSION XATTR_SHOWCOMPRESSION
-#endif
-
-
-int
-sys_lstat (const char *path, struct stat *buf);
-
-int
-sys_stat (const char *path, struct stat *buf);
-
-int
-sys_fstat (int fd, struct stat *buf);
-
-int
-sys_fstatat (int dirfd, const char *pathname, struct stat *buf,
-             int flags);
-
-int
-sys_open (const char *pathname, int flags, int mode);
-
-int
-sys_openat (int dirfd, const char *pathname, int flags, int mode);
-
-DIR *sys_opendir (const char *name);
-
-struct dirent *
-sys_readdir (DIR *dir, struct dirent *de);
-
-ssize_t
-sys_readlink (const char *path, char *buf, size_t bufsiz);
-
-int
-sys_closedir (DIR *dir);
-
-int
-sys_mknod (const char *pathname, mode_t mode, dev_t dev);
-
-int
-sys_mkdir (const char *pathname, mode_t mode);
-
-int
-sys_mkdirat (int dirfd, const char *pathname, mode_t mode);
-
-int
-sys_unlink (const char *pathname);
-
-int
-sys_rmdir (const char *pathname);
-
-int
-sys_symlink (const char *oldpath, const char *newpath);
-
-int
-sys_rename (const char *oldpath, const char *newpath);
-
-int
-sys_link (const char *oldpath, const char *newpath);
-
-int
-sys_chmod (const char *path, mode_t mode);
-
-int
-sys_fchmod (int fd, mode_t mode);
-
-int
-sys_chown (const char *path, uid_t owner, gid_t group);
-
-int
-sys_fchown (int fd, uid_t owner, gid_t group);
-
-int
-sys_lchown (const char *path, uid_t owner, gid_t group);
-
-int
-sys_truncate (const char *path, off_t length);
-
-int
-sys_ftruncate (int fd, off_t length);
-
-int
-sys_utimes (const char *filename, const struct timeval times[2]);
-
-#if defined(HAVE_UTIMENSAT)
-int
-sys_utimensat (int dirfd, const char *filename, const struct timespec times[2],
-               int flags);
-#endif
-
-int
-sys_creat (const char *pathname, mode_t mode);
-
-ssize_t
-sys_readv (int fd, const struct iovec *iov, int iovcnt);
-
-ssize_t
-sys_writev (int fd, const struct iovec *iov, int iovcnt);
-
-ssize_t
-sys_read (int fd, void *buf, size_t count);
-
-ssize_t
-sys_write (int fd, const void *buf, size_t count);
-
-off_t
-sys_lseek (int fd, off_t offset, int whence);
-
-int
-sys_statvfs (const char *path, struct statvfs *buf);
-
-int
-sys_fstatvfs (int fd, struct statvfs *buf);
-
-int
-sys_close (int fd);
-
-int
-sys_fsync (int fd);
-
-int
-sys_fdatasync (int fd);
-
-void
-gf_add_prefix(const char *ns, const char *key, char **newkey);
-
-void
-gf_remove_prefix(const char *ns, const char *key, char **newkey);
-
-int
-sys_lsetxattr (const char *path, const char *name, const void *value,
-               size_t size, int flags);
-
-ssize_t
-sys_llistxattr (const char *path, char *list, size_t size);
-
-ssize_t
-sys_lgetxattr (const char *path, const char *name, void *value, size_t size);
-
-ssize_t
-sys_fgetxattr (int filedes, const char *name, void *value, size_t size);
-
-int
-sys_fsetxattr (int filedes, const char *name, const void *value,
-               size_t size, int flags);
-
-ssize_t
-sys_flistxattr (int filedes, char *list, size_t size);
-
-int
-sys_lremovexattr (const char *path, const char *name);
-
-int
-sys_fremovexattr (int filedes, const char *name);
-
-int
-sys_access (const char *pathname, int mode);
-
-int
-sys_fallocate(int fd, int mode, off_t offset, off_t len);
-
-ssize_t
-sys_preadv (int fd, const struct iovec *iov, int iovcnt, off_t offset);
-
-ssize_t
-sys_pwritev (int fd, const struct iovec *iov, int iovcnt, off_t offset);
-
-ssize_t
-sys_pread(int fd, void *buf, size_t count, off_t offset);
-
-ssize_t
-sys_pwrite(int fd, const void *buf, size_t count, off_t offset);
-
-#endif /* __SYSCALL_H__ */
diff --git a/libglusterfs/src/throttle-tbf.c b/libglusterfs/src/throttle-tbf.c
index a425166b681..e11ca4f9d35 100644
--- a/libglusterfs/src/throttle-tbf.c
+++ b/libglusterfs/src/throttle-tbf.c
@@ -23,97 +23,97 @@
  *
  */
 
-#include "mem-pool.h"
-#include "throttle-tbf.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/throttle-tbf.h"
 
 typedef struct tbf_throttle {
-        char done;
+    char done;
 
-        pthread_mutex_t mutex;
-        pthread_cond_t  cond;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
 
-        unsigned long tokens;
+    unsigned long tokens;
 
-        struct list_head list;
+    struct list_head list;
 } tbf_throttle_t;
 
 static tbf_throttle_t *
-tbf_init_throttle (unsigned long tokens_required)
+tbf_init_throttle(unsigned long tokens_required)
 {
-        tbf_throttle_t *throttle = NULL;
+    tbf_throttle_t *throttle = NULL;
 
-        throttle = GF_CALLOC (1, sizeof (*throttle),
-                              gf_common_mt_tbf_throttle_t);
-        if (!throttle)
-                return NULL;
+    throttle = GF_CALLOC(1, sizeof(*throttle), gf_common_mt_tbf_throttle_t);
+    if (!throttle)
+        return NULL;
 
-        throttle->done = 0;
-        throttle->tokens = tokens_required;
-        INIT_LIST_HEAD (&throttle->list);
+    throttle->done = 0;
+    throttle->tokens = tokens_required;
+    INIT_LIST_HEAD(&throttle->list);
 
-        (void) pthread_mutex_init (&throttle->mutex, NULL);
-        (void) pthread_cond_init (&throttle->cond, NULL);
+    (void)pthread_mutex_init(&throttle->mutex, NULL);
+    (void)pthread_cond_init(&throttle->cond, NULL);
 
-        return throttle;
+    return throttle;
 }
 
 void
-_tbf_dispatch_queued (tbf_bucket_t *bucket)
+_tbf_dispatch_queued(tbf_bucket_t *bucket)
 {
-        gf_boolean_t xcont = _gf_false;
-        tbf_throttle_t *tmp = NULL;
-        tbf_throttle_t *throttle = NULL;
-
-        list_for_each_entry_safe (throttle, tmp, &bucket->queued, list) {
-
-                pthread_mutex_lock (&throttle->mutex);
-                {
-                        if (bucket->tokens < throttle->tokens) {
-                                xcont = _gf_true;
-                                goto unblock;
-                        }
-
-                        /* this request can now be serviced */
-                        throttle->done = 1;
-                        list_del_init (&throttle->list);
-
-                        bucket->tokens -= throttle->tokens;
-                        pthread_cond_signal (&throttle->cond);
-                }
-        unblock:
-                pthread_mutex_unlock (&throttle->mutex);
-                if (xcont)
-                        break;
+    gf_boolean_t xcont = _gf_false;
+    tbf_throttle_t *tmp = NULL;
+    tbf_throttle_t *throttle = NULL;
+
+    list_for_each_entry_safe(throttle, tmp, &bucket->queued, list)
+    {
+        pthread_mutex_lock(&throttle->mutex);
+        {
+            if (bucket->tokens < throttle->tokens) {
+                xcont = _gf_true;
+                goto unblock;
+            }
+
+            /* this request can now be serviced */
+            throttle->done = 1;
+            list_del_init(&throttle->list);
+
+            bucket->tokens -= throttle->tokens;
+            pthread_cond_signal(&throttle->cond);
         }
+    unblock:
+        pthread_mutex_unlock(&throttle->mutex);
+        if (xcont)
+            break;
+    }
 }
 
-void *tbf_tokengenerator (void *arg)
+void *
+tbf_tokengenerator(void *arg)
 {
-        unsigned long tokenrate = 0;
-        unsigned long maxtokens = 0;
-        unsigned long token_gen_interval = 0;
-        tbf_bucket_t *bucket = arg;
-
-        tokenrate = bucket->tokenrate;
-        maxtokens = bucket->maxtokens;
-        token_gen_interval = bucket->token_gen_interval;
-
-        while (1) {
-                usleep (token_gen_interval);
-
-                LOCK (&bucket->lock);
-                {
-                        bucket->tokens += tokenrate;
-                        if (bucket->tokens > maxtokens)
-                                bucket->tokens = maxtokens;
-
-                        if (!list_empty (&bucket->queued))
-                                _tbf_dispatch_queued (bucket);
-                }
-                UNLOCK (&bucket->lock);
+    unsigned long tokenrate = 0;
+    unsigned long maxtokens = 0;
+    unsigned long token_gen_interval = 0;
+    tbf_bucket_t *bucket = arg;
+
+    tokenrate = bucket->tokenrate;
+    maxtokens = bucket->maxtokens;
+    token_gen_interval = bucket->token_gen_interval;
+
+    while (1) {
+        gf_nanosleep(token_gen_interval * GF_US_IN_NS);
+
+        LOCK(&bucket->lock);
+        {
+            bucket->tokens += tokenrate;
+            if (bucket->tokens > maxtokens)
+                bucket->tokens = maxtokens;
+
+            if (!list_empty(&bucket->queued))
+                _tbf_dispatch_queued(bucket);
         }
+        UNLOCK(&bucket->lock);
+    }
 
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -122,170 +122,169 @@ void *tbf_tokengenerator (void *arg)
  * updated _after_ all the required variables are initialized.
  */
 static int32_t
-tbf_init_bucket (tbf_t *tbf, tbf_opspec_t *spec)
+tbf_init_bucket(tbf_t *tbf, tbf_opspec_t *spec)
 {
-        int ret = 0;
-        tbf_bucket_t *curr = NULL;
-        tbf_bucket_t **bucket = NULL;
+    int ret = 0;
+    tbf_bucket_t *curr = NULL;
+    tbf_bucket_t **bucket = NULL;
 
-        GF_ASSERT (spec->op >= TBF_OP_MIN);
-        GF_ASSERT (spec->op <= TBF_OP_MAX);
+    GF_ASSERT(spec->op >= TBF_OP_MIN);
+    GF_ASSERT(spec->op <= TBF_OP_MAX);
 
-        /* no rate? no throttling. */
-        if (!spec->rate)
-                return 0;
+    /* no rate? no throttling. */
+    if (!spec->rate)
+        return 0;
 
-        bucket = tbf->bucket + spec->op;
+    bucket = tbf->bucket + spec->op;
 
-        curr = GF_CALLOC (1, sizeof (*curr), gf_common_mt_tbf_bucket_t);
-        if (!curr)
-                goto error_return;
+    curr = GF_CALLOC(1, sizeof(*curr), gf_common_mt_tbf_bucket_t);
+    if (!curr)
+        goto error_return;
 
-        LOCK_INIT (&curr->lock);
-        INIT_LIST_HEAD (&curr->queued);
+    LOCK_INIT(&curr->lock);
+    INIT_LIST_HEAD(&curr->queued);
 
-        curr->tokens = 0;
-        curr->tokenrate = spec->rate;
-        curr->maxtokens = spec->maxlimit;
-        curr->token_gen_interval = spec->token_gen_interval;
+    curr->tokens = 0;
+    curr->tokenrate = spec->rate;
+    curr->maxtokens = spec->maxlimit;
+    curr->token_gen_interval = spec->token_gen_interval;
 
-        ret = gf_thread_create (&curr->tokener,
-                                NULL, tbf_tokengenerator, curr, "tbfclock");
-        if (ret != 0)
-                goto freemem;
+    ret = gf_thread_create(&curr->tokener, NULL, tbf_tokengenerator, curr,
+                           "tbfclock");
+    if (ret != 0)
+        goto freemem;
 
-        *bucket = curr;
-        return 0;
+    *bucket = curr;
+    return 0;
 
- freemem:
-        LOCK_DESTROY (&curr->lock);
-        GF_FREE (curr);
- error_return:
-        return -1;
+freemem:
+    LOCK_DESTROY(&curr->lock);
+    GF_FREE(curr);
+error_return:
+    return -1;
 }
 
-#define TBF_ALLOC_SIZE                                               \
-        (sizeof (tbf_t) + (TBF_OP_MAX * sizeof (tbf_bucket_t)))
+#define TBF_ALLOC_SIZE (sizeof(tbf_t) + (TBF_OP_MAX * sizeof(tbf_bucket_t)))
 
 tbf_t *
-tbf_init (tbf_opspec_t *tbfspec, unsigned int count)
+tbf_init(tbf_opspec_t *tbfspec, unsigned int count)
 {
-        int32_t i = 0;
-        int32_t ret = 0;
-        tbf_t *tbf = NULL;
-        tbf_opspec_t *opspec = NULL;
-
-        tbf = GF_CALLOC (1, TBF_ALLOC_SIZE, gf_common_mt_tbf_t);
-        if (!tbf)
-                goto error_return;
-
-        tbf->bucket = (tbf_bucket_t **) ((char *)tbf + sizeof (*tbf));
-        for (i = 0; i < TBF_OP_MAX; i++) {
-                *(tbf->bucket + i) = NULL;
-        }
+    int32_t i = 0;
+    int32_t ret = 0;
+    tbf_t *tbf = NULL;
+    tbf_opspec_t *opspec = NULL;
 
-        for (i = 0; i < count; i++) {
-                opspec = tbfspec + i;
+    tbf = GF_CALLOC(1, TBF_ALLOC_SIZE, gf_common_mt_tbf_t);
+    if (!tbf)
+        goto error_return;
 
-                ret = tbf_init_bucket (tbf, opspec);
-                if (ret)
-                        break;
-        }
+    tbf->bucket = (tbf_bucket_t **)((char *)tbf + sizeof(*tbf));
+    for (i = 0; i < TBF_OP_MAX; i++) {
+        *(tbf->bucket + i) = NULL;
+    }
 
+    for (i = 0; i < count; i++) {
+        opspec = tbfspec + i;
+
+        ret = tbf_init_bucket(tbf, opspec);
         if (ret)
-                goto error_return;
+            break;
+    }
 
-        return tbf;
+    if (ret)
+        goto error_return;
 
- error_return:
-        return NULL;
+    return tbf;
+
+error_return:
+    return NULL;
 }
 
 static void
-tbf_mod_bucket (tbf_bucket_t *bucket, tbf_opspec_t *spec)
+tbf_mod_bucket(tbf_bucket_t *bucket, tbf_opspec_t *spec)
 {
-        LOCK (&bucket->lock);
-        {
-                bucket->tokens = 0;
-                bucket->tokenrate = spec->rate;
-                bucket->maxtokens = spec->maxlimit;
-        }
-        UNLOCK (&bucket->lock);
-
-        /* next token tick would unqueue pending operations */
+    LOCK(&bucket->lock);
+    {
+        bucket->tokens = 0;
+        bucket->tokenrate = spec->rate;
+        bucket->maxtokens = spec->maxlimit;
+    }
+    UNLOCK(&bucket->lock);
+
+    /* next token tick would unqueue pending operations */
 }
 
 int
-tbf_mod (tbf_t *tbf, tbf_opspec_t *tbfspec)
+tbf_mod(tbf_t *tbf, tbf_opspec_t *tbfspec)
 {
-        int              ret    = 0;
-        tbf_bucket_t *bucket = NULL;
-        tbf_ops_t     op     = TBF_OP_MIN;
+    int ret = 0;
+    tbf_bucket_t *bucket = NULL;
+    tbf_ops_t op = TBF_OP_MIN;
 
-        if (!tbf || !tbfspec)
-                return -1;
+    if (!tbf || !tbfspec)
+        return -1;
 
-        op = tbfspec->op;
+    op = tbfspec->op;
 
-        GF_ASSERT (op >= TBF_OP_MIN);
-        GF_ASSERT (op <= TBF_OP_MAX);
+    GF_ASSERT(op >= TBF_OP_MIN);
+    GF_ASSERT(op <= TBF_OP_MAX);
 
-        bucket = *(tbf->bucket + op);
-        if (bucket) {
-                tbf_mod_bucket (bucket, tbfspec);
-        } else {
-                ret = tbf_init_bucket (tbf, tbfspec);
-        }
+    bucket = *(tbf->bucket + op);
+    if (bucket) {
+        tbf_mod_bucket(bucket, tbfspec);
+    } else {
+        ret = tbf_init_bucket(tbf, tbfspec);
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-tbf_throttle (tbf_t *tbf, tbf_ops_t op, unsigned long tokens_requested)
+tbf_throttle(tbf_t *tbf, tbf_ops_t op, unsigned long tokens_requested)
 {
-        char waitq = 0;
-        tbf_bucket_t *bucket = NULL;
-        tbf_throttle_t *throttle = NULL;
-
-        GF_ASSERT (op >= TBF_OP_MIN);
-        GF_ASSERT (op <= TBF_OP_MAX);
-
-        bucket = *(tbf->bucket + op);
-        if (!bucket)
-                return;
+    char waitq = 0;
+    tbf_bucket_t *bucket = NULL;
+    tbf_throttle_t *throttle = NULL;
+
+    GF_ASSERT(op >= TBF_OP_MIN);
+    GF_ASSERT(op <= TBF_OP_MAX);
+
+    bucket = *(tbf->bucket + op);
+    if (!bucket)
+        return;
+
+    LOCK(&bucket->lock);
+    {
+        /**
+         * if there are enough tokens in the bucket there is no need
+         * to throttle the request: therefore, consume the required
+         * number of tokens and continue.
+         */
+        if (tokens_requested <= bucket->tokens) {
+            bucket->tokens -= tokens_requested;
+        } else {
+            throttle = tbf_init_throttle(tokens_requested);
+            if (!throttle) /* let it slip through for now.. */
+                goto unblock;
 
-        LOCK (&bucket->lock);
-        {
-                /**
-                 * if there are enough tokens in the bucket there is no need
-                 * to throttle the request: therefore, consume the required
-                 * number of tokens and continue.
-                 */
-                if (tokens_requested <= bucket->tokens) {
-                        bucket->tokens -= tokens_requested;
-                } else {
-                        throttle = tbf_init_throttle (tokens_requested);
-                        if (!throttle) /* let it slip through for now.. */
-                                goto unblock;
-
-                        waitq = 1;
-                        pthread_mutex_lock (&throttle->mutex);
-                        list_add_tail (&throttle->list, &bucket->queued);
-                }
+            waitq = 1;
+            pthread_mutex_lock(&throttle->mutex);
+            list_add_tail(&throttle->list, &bucket->queued);
         }
- unblock:
-        UNLOCK (&bucket->lock);
+    }
+unblock:
+    UNLOCK(&bucket->lock);
 
-        if (waitq) {
-                while (!throttle->done) {
-                        pthread_cond_wait (&throttle->cond, &throttle->mutex);
-                }
+    if (waitq) {
+        while (!throttle->done) {
+            pthread_cond_wait(&throttle->cond, &throttle->mutex);
+        }
 
-                pthread_mutex_unlock (&throttle->mutex);
+        pthread_mutex_unlock(&throttle->mutex);
 
-                pthread_mutex_destroy (&throttle->mutex);
-                pthread_cond_destroy (&throttle->cond);
+        pthread_mutex_destroy(&throttle->mutex);
+        pthread_cond_destroy(&throttle->cond);
 
-                GF_FREE (throttle);
-        }
+        GF_FREE(throttle);
+    }
 }
diff --git a/libglusterfs/src/throttle-tbf.h b/libglusterfs/src/throttle-tbf.h
deleted file mode 100644
index b6e04962ca4..00000000000
--- a/libglusterfs/src/throttle-tbf.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "list.h"
-#include "xlator.h"
-#include "locking.h"
-
-#ifndef THROTTLE_TBF_H__
-#define THROTTLE_TBF_H__
-
-typedef enum tbf_ops {
-        TBF_OP_MIN     = -1,
-        TBF_OP_HASH    = 0,    /* checksum calculation  */
-        TBF_OP_READ    = 1,    /* inode read(s)         */
-        TBF_OP_READDIR = 2,    /* dentry read(s)        */
-        TBF_OP_MAX     = 3,
-} tbf_ops_t;
-
-/**
- * Operation rate specification
- */
-typedef struct tbf_opspec {
-        tbf_ops_t op;
-
-        unsigned long rate;
-
-        unsigned long maxlimit;
-
-        unsigned long token_gen_interval;/* Token generation interval in usec */
-} tbf_opspec_t;
-
-/**
- * Token bucket for each operation type
- */
-typedef struct tbf_bucket {
-        gf_lock_t lock;
-
-        pthread_t tokener;         /* token generator thread          */
-
-        unsigned long tokenrate;   /* token generation rate           */
-
-        unsigned long tokens;      /* number of current tokens        */
-
-        unsigned long maxtokens;   /* maximum token in the bucket     */
-
-        struct list_head queued;   /* list of non-conformant requests */
-
-        unsigned long token_gen_interval;/* Token generation interval in usec */
-} tbf_bucket_t;
-
-typedef struct tbf {
-        tbf_bucket_t **bucket;
-} tbf_t;
-
-tbf_t *
-tbf_init (tbf_opspec_t *, unsigned int);
-
-int
-tbf_mod (tbf_t *, tbf_opspec_t *);
-
-void
-tbf_throttle (tbf_t *, tbf_ops_t, unsigned long);
-
-#define TBF_THROTTLE_BEGIN(tbf, op, tokens) (tbf_throttle (tbf, op, tokens))
-#define TBF_THROTTLE_END(tbf, op, tokens)
-
-#endif /** THROTTLE_TBF_H__ */
diff --git a/libglusterfs/src/tier-ctr-interface.h b/libglusterfs/src/tier-ctr-interface.h
deleted file mode 100644
index cfd3f8a5e5d..00000000000
--- a/libglusterfs/src/tier-ctr-interface.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef _TIER_CTR_INTERFACE_H_
-#define _TIER_CTR_INTERFACE_H_
-
-#include "common-utils.h"
-#include "gfdb_data_store_types.h"
-
-#define GFDB_IPC_CTR_KEY "gfdb.ipc-ctr-op"
-
-/*
- * CTR IPC OPERATIONS
- *
- *
- */
-#define GFDB_IPC_CTR_QUERY_OPS "gfdb.ipc-ctr-query-op"
-#define GFDB_IPC_CTR_CLEAR_OPS "gfdb.ipc-ctr-clear-op"
-#define GFDB_IPC_CTR_GET_DB_PARAM_OPS "gfdb.ipc-ctr-get-db-parm"
-#define GFDB_IPC_CTR_GET_DB_VERSION_OPS "gfdb.ipc-ctr-get-db-version"
-#define GFDB_IPC_CTR_SET_COMPACT_PRAGMA "gfdb.ipc-ctr-set-compact-pragma"
-/*
- * CTR IPC INPUT/OUTPUT
- *
- *
- */
-#define GFDB_IPC_CTR_GET_QFILE_PATH "gfdb.ipc-ctr-get-qfile-path"
-#define GFDB_IPC_CTR_GET_QUERY_PARAMS "gfdb.ipc-ctr-get-query-parms"
-#define GFDB_IPC_CTR_RET_QUERY_COUNT "gfdb.ipc-ctr-ret-rec-count"
-#define GFDB_IPC_CTR_GET_DB_KEY "gfdb.ipc-ctr-get-params-key"
-#define GFDB_IPC_CTR_RET_DB_VERSION "gfdb.ipc-ctr-ret-db-version"
-
-/*
- * gfdb ipc ctr params for query
- *
- *
- */
-typedef struct gfdb_ipc_ctr_params {
-        gf_boolean_t is_promote;
-        int write_freq_threshold;
-        int read_freq_threshold;
-        gfdb_time_t time_stamp;
-        int query_limit;
-        gf_boolean_t emergency_demote;
-} gfdb_ipc_ctr_params_t;
-
-#endif
diff --git a/libglusterfs/src/timer.c b/libglusterfs/src/timer.c
index 3d69a9f7160..66c861b04cd 100644
--- a/libglusterfs/src/timer.c
+++ b/libglusterfs/src/timer.c
@@ -8,242 +8,249 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "timer.h"
-#include "logging.h"
-#include "common-utils.h"
-#include "globals.h"
-#include "timespec.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/timer.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/globals.h"
+#include "glusterfs/timespec.h"
+#include "glusterfs/libglusterfs-messages.h"
 
 /* fwd decl */
 static gf_timer_registry_t *
-gf_timer_registry_init (glusterfs_ctx_t *);
+gf_timer_registry_init(glusterfs_ctx_t *);
 
 gf_timer_t *
-gf_timer_call_after (glusterfs_ctx_t *ctx,
-                     struct timespec delta,
-                     gf_timer_cbk_t callbk,
-                     void *data)
+gf_timer_call_after(glusterfs_ctx_t *ctx, struct timespec delta,
+                    gf_timer_cbk_t callbk, void *data)
 {
-        gf_timer_registry_t *reg = NULL;
-        gf_timer_t *event = NULL;
-        gf_timer_t *trav = NULL;
-        uint64_t at = 0;
-
-        if (ctx == NULL)
-        {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+    gf_timer_registry_t *reg = NULL;
+    gf_timer_t *event = NULL;
+    gf_timer_t *trav = NULL;
+    uint64_t at = 0;
+
+    if ((ctx == NULL) || (ctx->cleanup_started)) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "Either ctx is NULL or"
+                         " ctx cleanup started");
+        return NULL;
+    }
 
-        reg = gf_timer_registry_init (ctx);
+    reg = gf_timer_registry_init(ctx);
 
-        if (!reg) {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
-                                  LG_MSG_TIMER_REGISTER_ERROR, "!reg");
-                return NULL;
-        }
+    if (!reg) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, 0, LG_MSG_TIMER_REGISTER_ERROR,
+                         "!reg");
+        return NULL;
+    }
 
-        event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
-        if (!event) {
-                return NULL;
-        }
-        timespec_now (&event->at);
-        timespec_adjust_delta (&event->at, delta);
-        at = TS (event->at);
-        event->callbk = callbk;
-        event->data = data;
-        event->xl = THIS;
-        LOCK (&reg->lock);
+    event = GF_CALLOC(1, sizeof(*event), gf_common_mt_gf_timer_t);
+    if (!event) {
+        return NULL;
+    }
+    timespec_now(&event->at);
+    timespec_adjust_delta(&event->at, delta);
+    at = TS(event->at);
+    event->callbk = callbk;
+    event->data = data;
+    event->xl = THIS;
+    pthread_mutex_lock(&reg->lock);
+    {
+        list_for_each_entry_reverse(trav, &reg->active, list)
         {
-                list_for_each_entry_reverse (trav, &reg->active, list) {
-                        if (TS (trav->at) < at)
-                                break;
-                }
-                list_add (&event->list, &trav->list);
+            if (TS(trav->at) < at)
+                break;
         }
-        UNLOCK (&reg->lock);
-        return event;
+        list_add(&event->list, &trav->list);
+        if (&trav->list == &reg->active) {
+            pthread_cond_signal(&reg->cond);
+        }
+    }
+    pthread_mutex_unlock(&reg->lock);
+    return event;
 }
 
-
 int32_t
-gf_timer_call_cancel (glusterfs_ctx_t *ctx,
-                      gf_timer_t *event)
+gf_timer_call_cancel(glusterfs_ctx_t *ctx, gf_timer_t *event)
 {
-        gf_timer_registry_t *reg = NULL;
-        gf_boolean_t fired = _gf_false;
-
-        if (ctx == NULL || event == NULL)
-        {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return 0;
-        }
+    gf_timer_registry_t *reg = NULL;
+    gf_boolean_t fired = _gf_false;
 
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-        }
-        UNLOCK (&ctx->lock);
-
-        if (!reg) {
-                gf_msg ("timer", GF_LOG_ERROR, 0, LG_MSG_INIT_TIMER_FAILED,
-                        "!reg");
-                GF_FREE (event);
-                return 0;
-        }
+    if (ctx == NULL || event == NULL) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return -1;
+    }
 
-        LOCK (&reg->lock);
-        {
-                fired = event->fired;
-                if (fired)
-                        goto unlock;
-                list_del (&event->list);
-        }
+    if (ctx->cleanup_started) {
+        gf_msg_callingfn("timer", GF_LOG_INFO, 0, LG_MSG_CTX_CLEANUP_STARTED,
+                         "ctx cleanup started");
+        return -1;
+    }
+
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+    }
+    UNLOCK(&ctx->lock);
+
+    if (!reg) {
+        /* This can happen when cleanup may have just started and
+         * gf_timer_registry_destroy() sets ctx->timer to NULL.
+         * gf_timer_proc() takes care of cleaning up the events.
+         */
+        return -1;
+    }
+
+    pthread_mutex_lock(&reg->lock);
+    {
+        fired = event->fired;
+        if (fired)
+            goto unlock;
+        list_del(&event->list);
+    }
 unlock:
-        UNLOCK (&reg->lock);
+    pthread_mutex_unlock(&reg->lock);
 
-        if (!fired) {
-                GF_FREE (event);
-                return 0;
-        }
-        return -1;
+    if (!fired) {
+        GF_FREE(event);
+        return 0;
+    }
+    return -1;
 }
 
-
 static void *
-gf_timer_proc (void *data)
+gf_timer_proc(void *data)
 {
-        gf_timer_registry_t *reg = data;
-        const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, };
-        gf_timer_t *event = NULL;
-        gf_timer_t *tmp = NULL;
-        xlator_t   *old_THIS = NULL;
-
-        while (!reg->fin) {
-                uint64_t now;
-                struct timespec now_ts;
-
-                timespec_now (&now_ts);
-                now = TS (now_ts);
-                while (1) {
-                        uint64_t at;
-                        char need_cbk = 0;
-
-                        LOCK (&reg->lock);
-                        {
-                                list_for_each_entry_safe (event,
-                                             tmp, &reg->active, list) {
-                                        at = TS (event->at);
-                                        if (now >= at) {
-                                                need_cbk = 1;
-                                                event->fired = _gf_true;
-                                                list_del (&event->list);
-                                                break;
-                                        }
-                                }
-                        }
-                        UNLOCK (&reg->lock);
-                        if (need_cbk) {
-                                old_THIS = NULL;
-                                if (event->xl) {
-                                        old_THIS = THIS;
-                                        THIS = event->xl;
-                                }
-                                event->callbk (event->data);
-                                GF_FREE (event);
-                                if (old_THIS) {
-                                        THIS = old_THIS;
-                                }
-                        } else {
-                                break;
-                        }
+    gf_timer_registry_t *reg = data;
+    gf_timer_t *event = NULL;
+    gf_timer_t *tmp = NULL;
+    xlator_t *old_THIS = NULL;
+
+    pthread_mutex_lock(&reg->lock);
+
+    while (!reg->fin) {
+        if (list_empty(&reg->active)) {
+            pthread_cond_wait(&reg->cond, &reg->lock);
+        } else {
+            struct timespec now;
+
+            timespec_now(&now);
+            event = list_first_entry(&reg->active, gf_timer_t, list);
+            if (TS(now) < TS(event->at)) {
+                now = event->at;
+                pthread_cond_timedwait(&reg->cond, &reg->lock, &now);
+            } else {
+                event->fired = _gf_true;
+                list_del_init(&event->list);
+
+                pthread_mutex_unlock(&reg->lock);
+
+                old_THIS = NULL;
+                if (event->xl) {
+                    old_THIS = THIS;
+                    THIS = event->xl;
                 }
-                nanosleep (&sleepts, NULL);
-        }
-
-        LOCK (&reg->lock);
-        {
-                /* Do not call gf_timer_call_cancel(),
-                 * it will lead to deadlock
-                 */
-                list_for_each_entry_safe (event, tmp, &reg->active, list) {
-                        list_del (&event->list);
-                        GF_FREE (event);
+                event->callbk(event->data);
+                GF_FREE(event);
+                if (old_THIS) {
+                    THIS = old_THIS;
                 }
-        }
-        UNLOCK (&reg->lock);
-        LOCK_DESTROY (&reg->lock);
 
-        return NULL;
+                pthread_mutex_lock(&reg->lock);
+            }
+        }
+    }
+
+    /* Do not call gf_timer_call_cancel(),
+     * it will lead to deadlock
+     */
+    list_for_each_entry_safe(event, tmp, &reg->active, list)
+    {
+        list_del(&event->list);
+        /* TODO Possible resource leak
+         * Before freeing the event, we need to call the respective
+         * event functions and free any resources.
+         * For example, In case of rpc_clnt_reconnect, we need to
+         * unref rpc object which was taken when added to timer
+         * wheel.
+         */
+        GF_FREE(event);
+    }
+
+    pthread_mutex_unlock(&reg->lock);
+
+    return NULL;
 }
 
-
 static gf_timer_registry_t *
-gf_timer_registry_init (glusterfs_ctx_t *ctx)
+gf_timer_registry_init(glusterfs_ctx_t *ctx)
 {
-        gf_timer_registry_t *reg = NULL;
-
-        if (ctx == NULL) {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
+    gf_timer_registry_t *reg = NULL;
+    int ret = -1;
+    pthread_condattr_t attr;
+
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+        if (reg) {
+            UNLOCK(&ctx->lock);
+            goto out;
         }
-
-        if (ctx->cleanup_started) {
-                gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
-                                  LG_MSG_CTX_CLEANUP_STARTED,
-                                  "ctx cleanup started");
-                return NULL;
+        reg = GF_CALLOC(1, sizeof(*reg), gf_common_mt_gf_timer_registry_t);
+        if (!reg) {
+            UNLOCK(&ctx->lock);
+            goto out;
         }
+        ctx->timer = reg;
+        pthread_mutex_init(&reg->lock, NULL);
+        pthread_condattr_init(&attr);
+        pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
+        pthread_cond_init(&reg->cond, &attr);
+        INIT_LIST_HEAD(&reg->active);
+    }
+    UNLOCK(&ctx->lock);
+    ret = gf_thread_create(&reg->th, NULL, gf_timer_proc, reg, "timer");
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_FAILED,
+               "Thread creation failed");
+    }
 
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-                if (reg) {
-                        UNLOCK (&ctx->lock);
-                        goto out;
-                }
-                reg = GF_CALLOC (1, sizeof (*reg),
-                              gf_common_mt_gf_timer_registry_t);
-                if (!reg) {
-                        UNLOCK (&ctx->lock);
-                        goto out;
-                }
-                ctx->timer = reg;
-                LOCK_INIT (&reg->lock);
-                INIT_LIST_HEAD (&reg->active);
-        }
-        UNLOCK (&ctx->lock);
-        gf_thread_create (&reg->th, NULL, gf_timer_proc, reg, "timer");
 out:
-        return reg;
+    return reg;
 }
 
-
 void
-gf_timer_registry_destroy (glusterfs_ctx_t *ctx)
+gf_timer_registry_destroy(glusterfs_ctx_t *ctx)
 {
-        pthread_t thr_id;
-        gf_timer_registry_t *reg = NULL;
+    pthread_t thr_id;
+    gf_timer_registry_t *reg = NULL;
 
-        if (ctx == NULL)
-                return;
+    if (ctx == NULL)
+        return;
 
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-                ctx->timer = NULL;
-        }
-        UNLOCK (&ctx->lock);
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+        ctx->timer = NULL;
+    }
+    UNLOCK(&ctx->lock);
+
+    if (!reg)
+        return;
+
+    thr_id = reg->th;
+
+    pthread_mutex_lock(&reg->lock);
+
+    reg->fin = 1;
+    pthread_cond_signal(&reg->cond);
+
+    pthread_mutex_unlock(&reg->lock);
+
+    pthread_join(thr_id, NULL);
 
-        if (!reg)
-                return;
+    pthread_cond_destroy(&reg->cond);
+    pthread_mutex_destroy(&reg->lock);
 
-        thr_id = reg->th;
-        reg->fin = 1;
-        pthread_join (thr_id, NULL);
-        GF_FREE (reg);
+    GF_FREE(reg);
 }
diff --git a/libglusterfs/src/timer.h b/libglusterfs/src/timer.h
deleted file mode 100644
index 32b246cf00d..00000000000
--- a/libglusterfs/src/timer.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _TIMER_H
-#define _TIMER_H
-
-#include "glusterfs.h"
-#include "xlator.h"
-#include <sys/time.h>
-#include <pthread.h>
-
-typedef void (*gf_timer_cbk_t) (void *);
-
-struct _gf_timer {
-        union {
-                struct list_head list;
-                struct {
-                        struct _gf_timer *next;
-                        struct _gf_timer *prev;
-                };
-        };
-        struct timespec   at;
-        gf_timer_cbk_t    callbk;
-        void             *data;
-        xlator_t         *xl;
-	gf_boolean_t      fired;
-};
-
-struct _gf_timer_registry {
-        pthread_t        th;
-        char             fin;
-        struct list_head active;
-        gf_lock_t        lock;
-};
-
-typedef struct _gf_timer gf_timer_t;
-typedef struct _gf_timer_registry gf_timer_registry_t;
-
-gf_timer_t *
-gf_timer_call_after (glusterfs_ctx_t *ctx,
-                     struct timespec delta,
-                     gf_timer_cbk_t cbk,
-                     void *data);
-
-int32_t
-gf_timer_call_cancel (glusterfs_ctx_t *ctx,
-                      gf_timer_t *event);
-
-void
-gf_timer_registry_destroy (glusterfs_ctx_t *ctx);
-#endif /* _TIMER_H */
diff --git a/libglusterfs/src/timespec.c b/libglusterfs/src/timespec.c
index 903303d1380..96cef5c6f07 100644
--- a/libglusterfs/src/timespec.c
+++ b/libglusterfs/src/timespec.c
@@ -12,63 +12,118 @@
 #include <inttypes.h>
 #include <time.h>
 #include <sys/time.h>
+#include <string.h>
 
 #if defined GF_DARWIN_HOST_OS
 #include <mach/mach_time.h>
 static mach_timebase_info_data_t gf_timebase;
 #endif
 
-#include "logging.h"
-#include "timespec.h"
-#include "libglusterfs-messages.h"
+#include "glusterfs/timespec.h"
+#include "glusterfs/libglusterfs-messages.h"
+#include "glusterfs/common-utils.h"
 
-void timespec_now (struct timespec *ts)
+void
+timespec_now(struct timespec *ts)
 {
-#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS || defined GF_BSD_HOST_OS
-        if (0 == clock_gettime(CLOCK_MONOTONIC, ts))
-                return;
-        else {
-                struct timeval tv;
-                if (0 == gettimeofday(&tv, NULL))
-                        TIMEVAL_TO_TIMESPEC(&tv, ts);
-        }
+#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS ||                  \
+    defined GF_BSD_HOST_OS
+    if (0 == clock_gettime(CLOCK_MONOTONIC, ts)) {
+        /* All good */
+        return;
+    }
+
+    /* Fall back, but there is hope in gettimeofday() syscall */
+    struct timeval tv;
+    if (0 == gettimeofday(&tv, NULL)) {
+        /* Again, all good */
+        TIMEVAL_TO_TIMESPEC(&tv, ts);
+        return;
+    }
+
+    /* If control hits here, there is surely a problem,
+       mainly because, as per man page too, these syscalls
+       shouldn't fail. Best way is to ABORT, because it is
+       not right */
+    GF_ABORT("gettimeofday() failed!!");
+
 #elif defined GF_DARWIN_HOST_OS
-        uint64_t time = mach_absolute_time();
-        static double scaling = 0.0;
+    uint64_t time = mach_absolute_time();
+    static double scaling = 0.0;
 
-        if (mach_timebase_info(&gf_timebase) != KERN_SUCCESS) {
-                gf_timebase.numer = 1;
-                gf_timebase.denom = 1;
-        }
-        if (gf_timebase.denom == 0) {
-                gf_timebase.numer = 1;
-                gf_timebase.denom = 1;
-        }
+    if (mach_timebase_info(&gf_timebase) != KERN_SUCCESS) {
+        gf_timebase.numer = 1;
+        gf_timebase.denom = 1;
+    }
+    if (gf_timebase.denom == 0) {
+        gf_timebase.numer = 1;
+        gf_timebase.denom = 1;
+    }
 
-        scaling = (double) gf_timebase.numer / (double) gf_timebase.denom;
-        time *= scaling;
+    scaling = (double)gf_timebase.numer / (double)gf_timebase.denom;
+    time *= scaling;
 
-        ts->tv_sec = (time * NANO);
-        ts->tv_nsec = (time - (ts->tv_sec * GIGA));
+    ts->tv_sec = (time * NANO);
+    ts->tv_nsec = (time - (ts->tv_sec * GIGA));
 
 #endif /* Platform verification */
 }
 
-void timespec_adjust_delta (struct timespec *ts, struct timespec delta)
+void
+timespec_now_realtime(struct timespec *ts)
 {
-        ts->tv_nsec = ((ts->tv_nsec + delta.tv_nsec) % 1000000000);
-        ts->tv_sec += ((ts->tv_nsec + delta.tv_nsec) / 1000000000);
-        ts->tv_sec += delta.tv_sec;
+#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS ||                  \
+    defined GF_BSD_HOST_OS
+    if (0 == clock_gettime(CLOCK_REALTIME, ts)) {
+        return;
+    }
+#endif
+
+    /* Fall back to gettimeofday()*/
+    struct timeval tv = {
+        0,
+    };
+    if (0 == gettimeofday(&tv, NULL)) {
+        TIMEVAL_TO_TIMESPEC(&tv, ts);
+        return;
+    }
+
+    return;
 }
 
-void timespec_sub (const struct timespec *begin, const struct timespec *end,
-                   struct timespec *res)
+void
+timespec_adjust_delta(struct timespec *ts, struct timespec delta)
 {
-        if (end->tv_nsec < begin->tv_nsec) {
-                res->tv_sec = end->tv_sec - begin->tv_sec - 1;
-                res->tv_nsec = end->tv_nsec + 1000000000 - begin->tv_nsec;
-        } else {
-                res->tv_sec = end->tv_sec - begin->tv_sec;
-                res->tv_nsec = end->tv_nsec - begin->tv_nsec;
-        }
+    ts->tv_nsec = ((ts->tv_nsec + delta.tv_nsec) % 1000000000);
+    ts->tv_sec += ((ts->tv_nsec + delta.tv_nsec) / 1000000000);
+    ts->tv_sec += delta.tv_sec;
+}
+
+void
+timespec_sub(const struct timespec *begin, const struct timespec *end,
+             struct timespec *res)
+{
+    if (end->tv_nsec < begin->tv_nsec) {
+        res->tv_sec = end->tv_sec - begin->tv_sec - 1;
+        res->tv_nsec = end->tv_nsec + 1000000000 - begin->tv_nsec;
+    } else {
+        res->tv_sec = end->tv_sec - begin->tv_sec;
+        res->tv_nsec = end->tv_nsec - begin->tv_nsec;
+    }
+}
+
+int
+timespec_cmp(const struct timespec *lhs_ts, const struct timespec *rhs_ts)
+{
+    if (lhs_ts->tv_sec < rhs_ts->tv_sec) {
+        return -1;
+    } else if (lhs_ts->tv_sec > rhs_ts->tv_sec) {
+        return 1;
+    } else if (lhs_ts->tv_nsec < rhs_ts->tv_nsec) {
+        return -1;
+    } else if (lhs_ts->tv_nsec > rhs_ts->tv_nsec) {
+        return 1;
+    }
+
+    return 0;
 }
diff --git a/libglusterfs/src/trie.c b/libglusterfs/src/trie.c
index f96bbebf6d3..809550b864c 100644
--- a/libglusterfs/src/trie.c
+++ b/libglusterfs/src/trie.c
@@ -10,378 +10,357 @@
 
 #include <stdio.h>
 #include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
 
-#include "common-utils.h"
-#include "trie.h"
+#include "glusterfs/common-utils.h"
+#include "glusterfs/trie.h"
 
 #define DISTANCE_EDIT 1
-#define DISTANCE_INS  1
-#define DISTANCE_DEL  1
-
+#define DISTANCE_INS 1
+#define DISTANCE_DEL 1
 
 struct trienode {
-        char             id;
-        char             eow;
-        int              depth;
-        void            *data;
-        struct trie     *trie;
-        struct trienode *parent;
-        struct trienode *subnodes[255];
+    char id;
+    char eow;
+    int depth;
+    void *data;
+    struct trie *trie;
+    struct trienode *parent;
+    struct trienode *subnodes[255];
 };
 
 struct trie {
-        struct trienode   root;
-        int               nodecnt;
-        size_t            len;
+    struct trienode root;
+    int nodecnt;
+    size_t len;
 };
 
-
 trie_t *
-trie_new ()
+trie_new()
 {
-        trie_t *trie = NULL;
+    trie_t *trie = NULL;
 
-        trie = GF_CALLOC (1, sizeof (*trie),  gf_common_mt_trie_trie);
-        if (!trie)
-                return NULL;
+    trie = GF_CALLOC(1, sizeof(*trie), gf_common_mt_trie_trie);
+    if (!trie)
+        return NULL;
 
-        trie->root.trie = trie;
+    trie->root.trie = trie;
 
-        return trie;
+    return trie;
 }
 
-
 static trienode_t *
-trie_subnode (trienode_t *node, int id)
+trie_subnode(trienode_t *node, int id)
 {
-        trienode_t *subnode = NULL;
-
-        subnode = node->subnodes[id];
-        if (!subnode) {
-                subnode = GF_CALLOC (1, sizeof (*subnode),
-                                     gf_common_mt_trie_node);
-                if (!subnode)
-                        return NULL;
-
-                subnode->id        = id;
-                subnode->depth     = node->depth + 1;
-                node->subnodes[id] = subnode;
-                subnode->parent    = node;
-                subnode->trie      = node->trie;
-                node->trie->nodecnt++;
-        }
-
-        return subnode;
+    trienode_t *subnode = NULL;
+
+    subnode = node->subnodes[id];
+    if (!subnode) {
+        subnode = GF_CALLOC(1, sizeof(*subnode), gf_common_mt_trie_node);
+        if (!subnode)
+            return NULL;
+
+        subnode->id = id;
+        subnode->depth = node->depth + 1;
+        node->subnodes[id] = subnode;
+        subnode->parent = node;
+        subnode->trie = node->trie;
+        node->trie->nodecnt++;
+    }
+
+    return subnode;
 }
 
-
 int
-trie_add (trie_t *trie, const char *dword)
+trie_add(trie_t *trie, const char *dword)
 {
-        trienode_t *node = NULL;
-        int              i = 0;
-        char             id = 0;
-        trienode_t *subnode = NULL;
+    trienode_t *node = NULL;
+    int i = 0;
+    char id = 0;
+    trienode_t *subnode = NULL;
 
-        node = &trie->root;
+    node = &trie->root;
 
-        for (i = 0; i < strlen (dword); i++) {
-                id = dword[i];
+    for (i = 0; i < strlen(dword); i++) {
+        id = dword[i];
 
-                subnode = trie_subnode (node, id);
-                if (!subnode)
-                        return -1;
-                node = subnode;
-        }
+        subnode = trie_subnode(node, id);
+        if (!subnode)
+            return -1;
+        node = subnode;
+    }
 
-        node->eow = 1;
+    node->eow = 1;
 
-        return 0;
+    return 0;
 }
 
 static void
-trienode_free (trienode_t *node)
+trienode_free(trienode_t *node)
 {
-        trienode_t *trav = NULL;
-        int              i = 0;
+    trienode_t *trav = NULL;
+    int i = 0;
 
-        for (i = 0; i < 255; i++) {
-                trav = node->subnodes[i];
+    for (i = 0; i < 255; i++) {
+        trav = node->subnodes[i];
 
-                if (trav)
-                        trienode_free (trav);
-        }
+        if (trav)
+            trienode_free(trav);
+    }
 
-        GF_FREE (node->data);
-        GF_FREE (node);
+    GF_FREE(node->data);
+    GF_FREE(node);
 }
 
-
 void
-trie_destroy (trie_t *trie)
+trie_destroy(trie_t *trie)
 {
-        trienode_free ((trienode_t *)trie);
+    trienode_free((trienode_t *)trie);
 }
 
-
 void
-trie_destroy_bynode (trienode_t *node)
+trie_destroy_bynode(trienode_t *node)
 {
-        trie_destroy (node->trie);
+    trie_destroy(node->trie);
 }
 
-
 static int
-trienode_walk (trienode_t *node, int (*fn)(trienode_t *node, void *data),
-               void *data, int eowonly)
+trienode_walk(trienode_t *node, int (*fn)(trienode_t *node, void *data),
+              void *data, int eowonly)
 {
-        trienode_t *trav = NULL;
-        int              i = 0;
-        int              cret = 0;
-        int              ret = 0;
-
-        if (!eowonly || node->eow)
-                ret = fn (node, data);
-
-        if (ret)
-                goto out;
-
-        for (i = 0; i < 255; i++) {
-                trav = node->subnodes[i];
-                if (!trav)
-                        continue;
-
-                cret = trienode_walk (trav, fn, data, eowonly);
-                if (cret < 0) {
-                        ret = cret;
-                        goto out;
-                }
-                ret += cret;
+    trienode_t *trav = NULL;
+    int i = 0;
+    int cret = 0;
+    int ret = 0;
+
+    if (!eowonly || node->eow)
+        ret = fn(node, data);
+
+    if (ret)
+        goto out;
+
+    for (i = 0; i < 255; i++) {
+        trav = node->subnodes[i];
+        if (!trav)
+            continue;
+
+        cret = trienode_walk(trav, fn, data, eowonly);
+        if (cret < 0) {
+            ret = cret;
+            goto out;
         }
+        ret += cret;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-trie_walk (trie_t *trie, int (*fn)(trienode_t *node, void *data),
-           void *data, int eowonly)
+trie_walk(trie_t *trie, int (*fn)(trienode_t *node, void *data), void *data,
+          int eowonly)
 {
-        return trienode_walk (&trie->root, fn, data, eowonly);
+    return trienode_walk(&trie->root, fn, data, eowonly);
 }
 
-
 static void
-print_node (trienode_t *node, char **buf)
+print_node(trienode_t *node, char **buf)
 {
-        if (!node->parent)
-                return;
+    if (!node->parent)
+        return;
 
-        if (node->parent) {
-                print_node (node->parent, buf);
-                *(*buf)++ = node->id;
-        }
+    if (node->parent) {
+        print_node(node->parent, buf);
+        *(*buf)++ = node->id;
+    }
 }
 
-
 int
-trienode_get_word (trienode_t *node, char **bufp)
+trienode_get_word(trienode_t *node, char **bufp)
 {
-        char *buf = NULL;
+    char *buf = NULL;
 
-        buf = GF_CALLOC (1, node->depth + 1, gf_common_mt_trie_buf);
-        if (!buf)
-                return -1;
-        *bufp = buf;
+    buf = GF_CALLOC(1, node->depth + 1, gf_common_mt_trie_buf);
+    if (!buf)
+        return -1;
+    *bufp = buf;
 
-        print_node (node, &buf);
+    print_node(node, &buf);
 
-        return 0;
+    return 0;
 }
 
-
 static int
-calc_dist (trienode_t *node, void *data)
+calc_dist(trienode_t *node, void *data)
 {
-        const char *word = NULL;
-        int         i = 0;
-        int        *row = NULL;
-        int        *uprow = NULL;
-        int         distu = 0;
-        int         distl = 0;
-        int         distul = 0;
-
-        word = data;
-
-        node->data = GF_CALLOC (node->trie->len, sizeof (int),
-                                gf_common_mt_trie_data);
-        if (!node->data)
-                return -1;
-        row = node->data;
-
-        if (!node->parent) {
-                for (i = 0; i < node->trie->len; i++)
-                        row[i] = i+1;
-
-                return 0;
-        }
+    const char *word = NULL;
+    int i = 0;
+    int *row = NULL;
+    int *uprow = NULL;
+    int distu = 0;
+    int distl = 0;
+    int distul = 0;
+
+    word = data;
+
+    node->data = GF_CALLOC(node->trie->len, sizeof(int),
+                           gf_common_mt_trie_data);
+    if (!node->data)
+        return -1;
+    row = node->data;
+
+    if (!node->parent) {
+        for (i = 0; i < node->trie->len; i++)
+            row[i] = i + 1;
 
-        uprow = node->parent->data;
+        return 0;
+    }
 
-        distu = node->depth;          /* up node */
-        distul = node->parent->depth; /* up-left node */
+    uprow = node->parent->data;
 
-        for (i = 0; i < node->trie->len; i++) {
-                distl = uprow[i];     /* left node */
+    distu = node->depth;          /* up node */
+    distul = node->parent->depth; /* up-left node */
 
-                if (word[i] == node->id)
-                        row[i] = distul;
-                else
-                        row[i] = min ((distul + DISTANCE_EDIT),
-                                      min ((distu + DISTANCE_DEL),
-                                           (distl + DISTANCE_INS)));
+    for (i = 0; i < node->trie->len; i++) {
+        distl = uprow[i]; /* left node */
 
-                distu  = row[i];
-                distul = distl;
-        }
+        if (word[i] == node->id)
+            row[i] = distul;
+        else
+            row[i] = min((distul + DISTANCE_EDIT),
+                         min((distu + DISTANCE_DEL), (distl + DISTANCE_INS)));
 
-        return 0;
-}
+        distu = row[i];
+        distul = distl;
+    }
 
+    return 0;
+}
 
 int
-trienode_get_dist (trienode_t *node)
+trienode_get_dist(trienode_t *node)
 {
-        int *row = NULL;
+    int *row = NULL;
 
-        row = node->data;
+    row = node->data;
 
-        return row[node->trie->len - 1];
+    return row[node->trie->len - 1];
 }
 
-
 struct trienodevec_w {
-        struct trienodevec *vec;
-        const char *word;
+    struct trienodevec *vec;
+    const char *word;
 };
 
-
 static void
-trienodevec_clear (struct trienodevec *nodevec)
+trienodevec_clear(struct trienodevec *nodevec)
 {
-        memset(nodevec->nodes, 0, sizeof (*nodevec->nodes) * nodevec->cnt);
+    memset(nodevec->nodes, 0, sizeof(*nodevec->nodes) * nodevec->cnt);
 }
 
-
 static int
-collect_closest (trienode_t *node, void *data)
+collect_closest(trienode_t *node, void *data)
 {
-        struct trienodevec_w *nodevec_w = NULL;
-        struct trienodevec *nodevec = NULL;
-        int dist = 0;
-        int i = 0;
-
-        nodevec_w = data;
-        nodevec = nodevec_w->vec;
-
-        if (calc_dist (node, (void *)nodevec_w->word))
-                return -1;
-
-        if (!node->eow || !nodevec->cnt)
-                return 0;
-
-        dist = trienode_get_dist (node);
-
-        /*
-         * I thought that when descending further after some dictionary word dw,
-         * if we see that child's distance is bigger than it was for dw, then we
-         * can prune this branch, as it can contain only worse nodes.
-         *
-         * This conjecture fails, see eg:
-         *
-         * d("AB", "B") = 1;
-         * d("AB", "BA") = 2;
-         * d("AB", "BAB") = 1;
-         *
-         * -- if both "B" and "BAB" are in dict., then pruning at "BA" * would
-         * miss "BAB".
-         *
-         * (example courtesy of Richard Bann <richardbann at gmail.com>)
-
-        if (node->parent->eow && dist > trienode_get_dist (node->parent))
-                return 1;
-
-         */
-
-        if (nodevec->nodes[0] &&
-            dist < trienode_get_dist (nodevec->nodes[0])) {
-                /* improving over the findings so far */
-                trienodevec_clear (nodevec);
-                nodevec->nodes[0] = node;
-        } else if (!nodevec->nodes[0] ||
-                   dist == trienode_get_dist (nodevec->nodes[0])) {
-                /* as good as the best so far, add if there is free space */
-                for (i = 0; i < nodevec->cnt; i++) {
-                        if (!nodevec->nodes[i]) {
-                                nodevec->nodes[i] = node;
-                                break;
-                        }
-                }
-        }
+    struct trienodevec_w *nodevec_w = NULL;
+    struct trienodevec *nodevec = NULL;
+    int dist = 0;
+    int i = 0;
+
+    nodevec_w = data;
+    nodevec = nodevec_w->vec;
 
+    if (calc_dist(node, (void *)nodevec_w->word))
+        return -1;
+
+    if (!node->eow || !nodevec->cnt)
         return 0;
-}
 
+    dist = trienode_get_dist(node);
+
+    /*
+     * I thought that when descending further after some dictionary word dw,
+     * if we see that child's distance is bigger than it was for dw, then we
+     * can prune this branch, as it can contain only worse nodes.
+     *
+     * This conjecture fails, see eg:
+     *
+     * d("AB", "B") = 1;
+     * d("AB", "BA") = 2;
+     * d("AB", "BAB") = 1;
+     *
+     * -- if both "B" and "BAB" are in dict., then pruning at "BA" * would
+     * miss "BAB".
+     *
+     * (example courtesy of Richard Bann <richardbann at gmail.com>)
+
+    if (node->parent->eow && dist > trienode_get_dist (node->parent))
+            return 1;
+
+     */
+
+    if (nodevec->nodes[0] && dist < trienode_get_dist(nodevec->nodes[0])) {
+        /* improving over the findings so far */
+        trienodevec_clear(nodevec);
+        nodevec->nodes[0] = node;
+    } else if (!nodevec->nodes[0] ||
+               dist == trienode_get_dist(nodevec->nodes[0])) {
+        /* as good as the best so far, add if there is free space */
+        for (i = 0; i < nodevec->cnt; i++) {
+            if (!nodevec->nodes[i]) {
+                nodevec->nodes[i] = node;
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
 
 int
-trie_measure (trie_t *trie, const char *word, trienode_t **nodes,
-              int nodecnt)
+trie_measure(trie_t *trie, const char *word, trienode_t **nodes, int nodecnt)
 {
-        struct trienodevec nodevec = {0,};
+    struct trienodevec nodevec = {
+        0,
+    };
 
-        nodevec.nodes = nodes;
-        nodevec.cnt = nodecnt;
+    nodevec.nodes = nodes;
+    nodevec.cnt = nodecnt;
 
-        return trie_measure_vec (trie, word, &nodevec);
+    return trie_measure_vec(trie, word, &nodevec);
 }
 
-
 int
-trie_measure_vec (trie_t *trie, const char *word, struct trienodevec *nodevec)
+trie_measure_vec(trie_t *trie, const char *word, struct trienodevec *nodevec)
 {
-        struct trienodevec_w nodevec_w = {0,};
-        int ret = 0;
+    struct trienodevec_w nodevec_w = {
+        0,
+    };
+    int ret = 0;
 
-        trie->len = strlen (word);
+    trie->len = strlen(word);
 
-        trienodevec_clear (nodevec);
-        nodevec_w.vec = nodevec;
-        nodevec_w.word = word;
+    trienodevec_clear(nodevec);
+    nodevec_w.vec = nodevec;
+    nodevec_w.word = word;
 
-        ret = trie_walk (trie, collect_closest, &nodevec_w, 0);
-        if (ret > 0)
-                ret = 0;
+    ret = trie_walk(trie, collect_closest, &nodevec_w, 0);
+    if (ret > 0)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
-
 static int
-trienode_reset (trienode_t *node, void *data)
+trienode_reset(trienode_t *node, void *data)
 {
-        GF_FREE (node->data);
+    GF_FREE(node->data);
 
-        return 0;
+    return 0;
 }
 
-
 void
-trie_reset_search (trie_t *trie)
+trie_reset_search(trie_t *trie)
 {
-        trie->len = 0;
+    trie->len = 0;
 
-        trie_walk (trie, trienode_reset, NULL, 0);
+    trie_walk(trie, trienode_reset, NULL, 0);
 }
diff --git a/libglusterfs/src/trie.h b/libglusterfs/src/trie.h
deleted file mode 100644
index f7a4deee02f..00000000000
--- a/libglusterfs/src/trie.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _TRIE_H_
-#define _TRIE_H_
-
-struct trienode;
-typedef struct trienode trienode_t;
-
-struct trie;
-typedef struct trie trie_t;
-
-struct trienodevec {
-        trienode_t **nodes;
-        unsigned cnt;
-};
-
-
-trie_t *trie_new ();
-
-int trie_add (trie_t *trie, const char *word);
-
-void trie_destroy (trie_t *trie);
-
-void trie_destroy_bynode (trienode_t *node);
-
-int trie_measure (trie_t *trie, const char *word, trienode_t **nodes,
-                  int nodecnt);
-
-int trie_measure_vec (trie_t *trie, const char *word,
-                      struct trienodevec *nodevec);
-
-void trie_reset_search (trie_t *trie);
-
-int trienode_get_dist (trienode_t *node);
-
-int trienode_get_word (trienode_t *node, char **buf);
-
-#endif
diff --git a/libglusterfs/src/unittest/global_mock.c b/libglusterfs/src/unittest/global_mock.c
index afdadc4e868..2fcf96dbad8 100644
--- a/libglusterfs/src/unittest/global_mock.c
+++ b/libglusterfs/src/unittest/global_mock.c
@@ -8,8 +8,8 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "logging.h"
-#include "xlator.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/xlator.h"
 
 #include <stdarg.h>
 #include <stddef.h>
@@ -18,7 +18,8 @@
 
 #include <cmocka.h>
 
-xlator_t **__glusterfs_this_location ()
+xlator_t **
+__glusterfs_this_location()
 {
     return ((xlator_t **)(uintptr_t)mock());
 }
diff --git a/libglusterfs/src/unittest/log_mock.c b/libglusterfs/src/unittest/log_mock.c
index c03ff524612..60f6530726b 100644
--- a/libglusterfs/src/unittest/log_mock.c
+++ b/libglusterfs/src/unittest/log_mock.c
@@ -8,8 +8,8 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "logging.h"
-#include "xlator.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/xlator.h"
 
 #include <stdarg.h>
 #include <stddef.h>
@@ -18,33 +18,35 @@
 
 #include <cmocka.h>
 
-int _gf_log (const char *domain, const char *file,
-             const char *function, int32_t line, gf_loglevel_t level,
-             const char *fmt, ...)
+int
+_gf_log(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-int _gf_log_callingfn (const char *domain, const char *file,
-                       const char *function, int32_t line, gf_loglevel_t level,
-                       const char *fmt, ...)
+int
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-int _gf_log_nomem (const char *domain, const char *file,
-                   const char *function, int line, gf_loglevel_t level,
-                   size_t size)
+int
+_gf_log_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
     return 0;
 }
 
-int _gf_msg_nomem (const char *domain, const char *file,
-                   const char *function, int line, gf_loglevel_t level,
-                   size_t size)
+int
+_gf_msg_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
-	return 0;
+    return 0;
 }
 
 void
-gf_log_globals_init (void *data, gf_loglevel_t level) {}
+gf_log_globals_init(void *data, gf_loglevel_t level)
+{
+}
diff --git a/libglusterfs/src/unittest/mem_pool_unittest.c b/libglusterfs/src/unittest/mem_pool_unittest.c
index 00c7688637f..9ca324329ba 100644
--- a/libglusterfs/src/unittest/mem_pool_unittest.c
+++ b/libglusterfs/src/unittest/mem_pool_unittest.c
@@ -8,9 +8,9 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "mem-pool.h"
-#include "logging.h"
-#include "xlator.h"
+#include "glusterfs/mem-pool.h"
+#include "glusterfs/logging.h"
+#include "glusterfs/xlator.h"
 
 #include <stdarg.h>
 #include <stddef.h>
@@ -21,10 +21,10 @@
 #include <cmocka.h>
 
 #ifndef assert_ptr_equal
-#define assert_ptr_equal(a, b) \
-    _assert_int_equal(cast_ptr_to_largest_integral_type(a), \
-                      cast_ptr_to_largest_integral_type(b), \
-                      __FILE__, __LINE__)
+#define assert_ptr_equal(a, b)                                                 \
+    _assert_int_equal(cast_ptr_to_largest_integral_type(a),                    \
+                      cast_ptr_to_largest_integral_type(b), __FILE__,          \
+                      __LINE__)
 #endif
 
 /*
@@ -42,8 +42,8 @@ typedef struct __attribute__((packed)) {
  * Prototypes to private functions
  */
 int
-gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
-                      uint32_t type, const char *typestr);
+gf_mem_set_acct_info(xlator_t *xl, char **alloc_ptr, size_t size, uint32_t type,
+                     const char *typestr);
 
 /*
  * Helper functions
@@ -59,16 +59,16 @@ helper_xlator_init(uint32_t num_types)
     xl = test_calloc(1, sizeof(xlator_t));
     assert_non_null(xl);
     xl->mem_acct->num_types = num_types;
-    xl->mem_acct = test_calloc (sizeof(struct mem_acct)
-                                + sizeof(struct mem_acct_rec) * num_types);
+    xl->mem_acct = test_calloc(sizeof(struct mem_acct) +
+                               sizeof(struct mem_acct_rec) * num_types);
     assert_non_null(xl->mem_acct);
 
     xl->ctx = test_calloc(1, sizeof(glusterfs_ctx_t));
     assert_non_null(xl->ctx);
 
     for (i = 0; i < num_types; i++) {
-            ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
-            assert_int_equal(ret, 0);
+        ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
+        assert_int_equal(ret, 0);
     }
 
     ENSURE(num_types == xl->mem_acct->num_types);
@@ -83,8 +83,8 @@ helper_xlator_destroy(xlator_t *xl)
     int i, ret;
 
     for (i = 0; i < xl->mem_acct->num_types; i++) {
-            ret = LOCK_DESTROY(&(xl->mem_acct->rec[i].lock));
-            assert_int_equal(ret, 0);
+        ret = LOCK_DESTROY(&(xl->mem_acct->rec[i].lock));
+        assert_int_equal(ret, 0);
     }
 
     free(xl->mem_acct->rec);
@@ -94,20 +94,16 @@ helper_xlator_destroy(xlator_t *xl)
 }
 
 static void
-helper_check_memory_headers( char *mem,
-        xlator_t *xl,
-        size_t size,
-        uint32_t type)
+helper_check_memory_headers(char *mem, xlator_t *xl, size_t size, uint32_t type)
 {
     mem_header_t *p;
 
-    p = (mem_header_t *)mem,
-    assert_int_equal(p->type, type);
+    p = (mem_header_t *)mem, assert_int_equal(p->type, type);
     assert_int_equal(p->size, size);
     assert_true(p->xl == xl);
     assert_int_equal(p->header_magic, GF_MEM_HEADER_MAGIC);
-    assert_true(*(uint32_t *)(mem+sizeof(mem_header_t)+size) == GF_MEM_TRAILER_MAGIC);
-
+    assert_true(*(uint32_t *)(mem + sizeof(mem_header_t) + size) ==
+                GF_MEM_TRAILER_MAGIC);
 }
 
 /*
@@ -116,7 +112,7 @@ helper_check_memory_headers( char *mem,
 static void
 test_gf_mem_acct_enable_set(void **state)
 {
-    (void) state;
+    (void)state;
     glusterfs_ctx_t test_ctx;
 
     expect_assert_failure(gf_mem_acct_enable_set(NULL));
@@ -143,14 +139,16 @@ test_gf_mem_set_acct_info_asserts(void **state)
     size = 8196;
     type = 0;
 
-
     // Check xl is NULL
-    expect_assert_failure(gf_mem_set_acct_info(NULL, &alloc_ptr, size, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(NULL, &alloc_ptr, size, type, ""));
     // Check xl->mem_acct = NULL
-    expect_assert_failure(gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
     // Check type <= xl->mem_acct->num_types
     type = 100;
-    expect_assert_failure(gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
     // Check alloc is NULL
     assert_int_equal(-1, gf_mem_set_acct_info(&xltest, NULL, size, type, ""));
 
@@ -189,7 +187,7 @@ test_gf_mem_set_acct_info_memory(void **state)
     alloc_ptr = temp_ptr;
     gf_mem_set_acct_info(xl, &alloc_ptr, size, type, typestr);
 
-    //Check values
+    // Check values
     assert_ptr_equal(typestr, xl->mem_acct->rec[type].typestr);
     assert_int_equal(xl->mem_acct->rec[type].size, size);
     assert_int_equal(xl->mem_acct->rec[type].num_allocs, 1);
@@ -420,10 +418,10 @@ test_gf_realloc_mem_acct_enabled(void **state)
     // not to the realloc + the malloc.
     // Is this a bug?
     //
-    assert_int_equal(xl->mem_acct->rec[type].size, size+1024);
+    assert_int_equal(xl->mem_acct->rec[type].size, size + 1024);
     assert_int_equal(xl->mem_acct->rec[type].num_allocs, 2);
     assert_int_equal(xl->mem_acct->rec[type].total_allocs, 2);
-    assert_int_equal(xl->mem_acct->rec[type].max_size, size+1024);
+    assert_int_equal(xl->mem_acct->rec[type].max_size, size + 1024);
     assert_int_equal(xl->mem_acct->rec[type].max_num_allocs, 2);
 
     // Check memory
@@ -465,7 +463,9 @@ test_gf_realloc_ptr(void **state)
     helper_xlator_destroy(xl);
 }
 
-int main(void) {
+int
+main(void)
+{
     const struct CMUnitTest libglusterfs_mem_pool_tests[] = {
         cmocka_unit_test(test_gf_mem_acct_enable_set),
         cmocka_unit_test(test_gf_mem_set_acct_info_asserts),
diff --git a/libglusterfs/src/unittest/unittest.h b/libglusterfs/src/unittest/unittest.h
index 6320217db0d..58b3e28bb6e 100644
--- a/libglusterfs/src/unittest/unittest.h
+++ b/libglusterfs/src/unittest/unittest.h
@@ -18,8 +18,9 @@
 #include <cmocka_pbc.h>
 #include <cmocka.h>
 
-extern void mock_assert(const int result, const char* const expression,
-                        const char * const file, const int line);
+extern void
+mock_assert(const int result, const char *const expression,
+            const char *const file, const int line);
 
 // Change GF_CALLOC and GF_FREE to use
 // cmocka memory allocation versions
@@ -30,16 +31,17 @@ extern void mock_assert(const int result, const char* const expression,
 #define GF_FREE test_free
 
 /* Catch intended assert()'s while unit-testing */
-extern void mock_assert(const int result, const char* const expression,
-                        const char * const file, const int line);
+extern void
+mock_assert(const int result, const char *const expression,
+            const char *const file, const int line);
 
 #undef assert
-#define assert(expression) \
-            mock_assert((int)(expression), #expression, __FILE__, __LINE__);
+#define assert(expression)                                                     \
+    mock_assert((int)(expression), #expression, __FILE__, __LINE__);
 #endif
 #else
 #define REQUIRE(p) /**/
-#define ENSURE(p) /**/
+#define ENSURE(p)  /**/
 #endif
 
 #endif /* _GF_UNITTEST */
diff --git a/libglusterfs/src/upcall-utils.h b/libglusterfs/src/upcall-utils.h
deleted file mode 100644
index 3b5dce33e45..00000000000
--- a/libglusterfs/src/upcall-utils.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (c) 2015, Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _UPCALL_UTILS_H
-#define _UPCALL_UTILS_H
-
-#include "iatt.h"
-#include "compat-uuid.h"
-#include "compat.h"
-
-/* Flags sent for cache_invalidation */
-#define UP_NLINK         0x00000001   /* update nlink */
-#define UP_MODE          0x00000002   /* update mode and ctime */
-#define UP_OWN           0x00000004   /* update mode,uid,gid and ctime */
-#define UP_SIZE          0x00000008   /* update fsize */
-#define UP_TIMES         0x00000010   /* update all times */
-#define UP_ATIME         0x00000020   /* update atime only */
-#define UP_PERM          0x00000040   /* update fields needed for permission
-                                         checking */
-#define UP_RENAME        0x00000080   /* this is a rename op - delete the cache
-                                         entry */
-#define UP_FORGET        0x00000100   /* inode_forget on server side -
-                                         invalidate the cache entry */
-#define UP_PARENT_TIMES  0x00000200   /* update parent dir times */
-
-#define UP_XATTR         0x00000400   /* update the xattrs and ctime */
-#define UP_XATTR_RM      0x00000800   /* Remove the xattrs and update ctime */
-
-#define UP_EXPLICIT_LOOKUP 0x00001000 /* Request an explicit lookup */
-
-#define UP_INVAL_ATTR      0x00002000 /* Request to invalidate iatt and xatt */
-
-/* for fops - open, read, lk, */
-#define UP_UPDATE_CLIENT        (UP_ATIME)
-
-/* for fop - write, truncate */
-#define UP_WRITE_FLAGS          (UP_SIZE | UP_TIMES)
-
-/* for fop - setattr */
-#define UP_ATTR_FLAGS           (UP_SIZE | UP_TIMES | UP_OWN | UP_MODE | \
-                                 UP_PERM)
-/* for fop - rename */
-#define UP_RENAME_FLAGS         (UP_RENAME)
-
-/* to invalidate parent directory entries for fops -rename, unlink, rmdir,
- * mkdir, create */
-#define UP_PARENT_DENTRY_FLAGS  (UP_PARENT_TIMES)
-
-/* for fop - unlink, link, rmdir, mkdir */
-#define UP_NLINK_FLAGS          (UP_NLINK | UP_TIMES)
-
-#define IATT_UPDATE_FLAGS       (UP_NLINK | UP_MODE | UP_OWN | UP_SIZE | \
-                                 UP_TIMES | UP_ATIME | UP_PERM)
-
-typedef enum {
-        GF_UPCALL_EVENT_NULL,
-        GF_UPCALL_CACHE_INVALIDATION,
-        GF_UPCALL_RECALL_LEASE,
-} gf_upcall_event_t;
-
-struct gf_upcall {
-        char      *client_uid;
-        uuid_t    gfid;
-        uint32_t  event_type;
-        void      *data;
-};
-
-struct gf_upcall_cache_invalidation {
-        uint32_t flags;
-        uint32_t expire_time_attr;
-        struct iatt stat;
-        struct iatt p_stat; /* parent dir stat */
-        struct iatt oldp_stat; /* oldparent dir stat */
-        dict_t *dict; /* For xattrs */
-};
-
-struct gf_upcall_recall_lease {
-        uint32_t  lease_type; /* Lease type to which client can downgrade to*/
-        uuid_t    tid;        /* transaction id of the fop that caused
-                                 the recall */
-        dict_t   *dict;
-};
-
-#endif /* _UPCALL_UTILS_H */
diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c
index de97dff6dfe..9a2582d45d5 100644
--- a/libglusterfs/src/xlator.c
+++ b/libglusterfs/src/xlator.c
@@ -8,405 +8,535 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "xlator.h"
+#include "glusterfs/xlator.h"
 #include <dlfcn.h>
 #include <netdb.h>
 #include <fnmatch.h>
-#include "defaults.h"
-#include "libglusterfs-messages.h"
-
-#define SET_DEFAULT_FOP(fn) do {			\
-                if (!xl->fops->fn)			\
-                        xl->fops->fn = default_##fn;	\
-        } while (0)
-
-#define SET_DEFAULT_CBK(fn) do {			\
-                if (!xl->cbks->fn)			\
-                        xl->cbks->fn = default_##fn;	\
-        } while (0)
+#include "glusterfs/defaults.h"
+#include "glusterfs/libglusterfs-messages.h"
+
+#define SET_DEFAULT_FOP(fn)                                                    \
+    do {                                                                       \
+        if (!xl->fops->fn)                                                     \
+            xl->fops->fn = default_##fn;                                       \
+        if (!xl->pass_through_fops->fn)                                        \
+            xl->pass_through_fops->fn = default_##fn;                          \
+    } while (0)
+
+#define SET_DEFAULT_CBK(fn)                                                    \
+    do {                                                                       \
+        if (!xl->cbks->fn)                                                     \
+            xl->cbks->fn = default_##fn;                                       \
+    } while (0)
 
 pthread_mutex_t xlator_init_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void
-xlator_init_lock (void)
+xlator_init_lock(void)
 {
-        (void) pthread_mutex_lock (&xlator_init_mutex);
+    (void)pthread_mutex_lock(&xlator_init_mutex);
 }
 
-
 void
-xlator_init_unlock (void)
+xlator_init_unlock(void)
 {
-        (void) pthread_mutex_unlock (&xlator_init_mutex);
+    (void)pthread_mutex_unlock(&xlator_init_mutex);
 }
 
-
-static void
-fill_defaults (xlator_t *xl)
+static struct xlator_cbks default_cbks = {};
+struct volume_options default_options[] = {
+    {
+        .key = {"log-level"},
+        .type = GF_OPTION_TYPE_STR,
+        .op_version = {GD_OP_VERSION_6_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"generic"},
+        .value = {"DEBUG", "WARNING", "ERROR", "INFO", "CRITICAL", "NONE",
+                  "TRACE"},
+        .description = "Option to set log-level of given translator",
+    },
+    {
+        .key = {NULL},
+    },
+};
+
+/* Handle the common options in each translator */
+void
+handle_default_options(xlator_t *xl, dict_t *options)
 {
-        if (xl == NULL)	{
-                gf_msg_callingfn ("xlator", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
+    int ret;
+    char *value;
+
+    /* log-level */
+    ret = dict_get_str(options, "log-level", &value);
+    if (!ret) {
+        int log_level = glusterd_check_log_level(value);
+        if (log_level != -1) {
+            xl->loglevel = log_level;
         }
+    }
+}
 
-        SET_DEFAULT_FOP (create);
-        SET_DEFAULT_FOP (open);
-        SET_DEFAULT_FOP (stat);
-        SET_DEFAULT_FOP (readlink);
-        SET_DEFAULT_FOP (mknod);
-        SET_DEFAULT_FOP (mkdir);
-        SET_DEFAULT_FOP (unlink);
-        SET_DEFAULT_FOP (rmdir);
-        SET_DEFAULT_FOP (symlink);
-        SET_DEFAULT_FOP (rename);
-        SET_DEFAULT_FOP (link);
-        SET_DEFAULT_FOP (truncate);
-        SET_DEFAULT_FOP (readv);
-        SET_DEFAULT_FOP (writev);
-        SET_DEFAULT_FOP (statfs);
-        SET_DEFAULT_FOP (flush);
-        SET_DEFAULT_FOP (fsync);
-        SET_DEFAULT_FOP (setxattr);
-        SET_DEFAULT_FOP (getxattr);
-        SET_DEFAULT_FOP (fsetxattr);
-        SET_DEFAULT_FOP (fgetxattr);
-        SET_DEFAULT_FOP (removexattr);
-        SET_DEFAULT_FOP (fremovexattr);
-        SET_DEFAULT_FOP (opendir);
-        SET_DEFAULT_FOP (readdir);
-        SET_DEFAULT_FOP (readdirp);
-        SET_DEFAULT_FOP (fsyncdir);
-        SET_DEFAULT_FOP (access);
-        SET_DEFAULT_FOP (ftruncate);
-        SET_DEFAULT_FOP (fstat);
-        SET_DEFAULT_FOP (lk);
-        SET_DEFAULT_FOP (inodelk);
-        SET_DEFAULT_FOP (finodelk);
-        SET_DEFAULT_FOP (entrylk);
-        SET_DEFAULT_FOP (fentrylk);
-        SET_DEFAULT_FOP (lookup);
-        SET_DEFAULT_FOP (rchecksum);
-        SET_DEFAULT_FOP (xattrop);
-        SET_DEFAULT_FOP (fxattrop);
-        SET_DEFAULT_FOP (setattr);
-        SET_DEFAULT_FOP (fsetattr);
-	SET_DEFAULT_FOP (fallocate);
-	SET_DEFAULT_FOP (discard);
-        SET_DEFAULT_FOP (zerofill);
-        SET_DEFAULT_FOP (ipc);
-        SET_DEFAULT_FOP (seek);
-        SET_DEFAULT_FOP (lease);
-        SET_DEFAULT_FOP (getactivelk);
-        SET_DEFAULT_FOP (setactivelk);
-
-        SET_DEFAULT_FOP (getspec);
-
-        SET_DEFAULT_CBK (release);
-        SET_DEFAULT_CBK (releasedir);
-        SET_DEFAULT_CBK (forget);
-
-        if (!xl->notify)
-                xl->notify = default_notify;
-
-        if (!xl->mem_acct_init)
-                xl->mem_acct_init = default_mem_acct_init;
-
+static void
+fill_defaults(xlator_t *xl)
+{
+    if (xl == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
         return;
+    }
+
+    if (!xl->pass_through_fops)
+        xl->pass_through_fops = default_fops;
+
+    SET_DEFAULT_FOP(create);
+    SET_DEFAULT_FOP(open);
+    SET_DEFAULT_FOP(stat);
+    SET_DEFAULT_FOP(readlink);
+    SET_DEFAULT_FOP(mknod);
+    SET_DEFAULT_FOP(mkdir);
+    SET_DEFAULT_FOP(unlink);
+    SET_DEFAULT_FOP(rmdir);
+    SET_DEFAULT_FOP(symlink);
+    SET_DEFAULT_FOP(rename);
+    SET_DEFAULT_FOP(link);
+    SET_DEFAULT_FOP(truncate);
+    SET_DEFAULT_FOP(readv);
+    SET_DEFAULT_FOP(writev);
+    SET_DEFAULT_FOP(statfs);
+    SET_DEFAULT_FOP(flush);
+    SET_DEFAULT_FOP(fsync);
+    SET_DEFAULT_FOP(setxattr);
+    SET_DEFAULT_FOP(getxattr);
+    SET_DEFAULT_FOP(fsetxattr);
+    SET_DEFAULT_FOP(fgetxattr);
+    SET_DEFAULT_FOP(removexattr);
+    SET_DEFAULT_FOP(fremovexattr);
+    SET_DEFAULT_FOP(opendir);
+    SET_DEFAULT_FOP(readdir);
+    SET_DEFAULT_FOP(readdirp);
+    SET_DEFAULT_FOP(fsyncdir);
+    SET_DEFAULT_FOP(access);
+    SET_DEFAULT_FOP(ftruncate);
+    SET_DEFAULT_FOP(fstat);
+    SET_DEFAULT_FOP(lk);
+    SET_DEFAULT_FOP(inodelk);
+    SET_DEFAULT_FOP(finodelk);
+    SET_DEFAULT_FOP(entrylk);
+    SET_DEFAULT_FOP(fentrylk);
+    SET_DEFAULT_FOP(lookup);
+    SET_DEFAULT_FOP(rchecksum);
+    SET_DEFAULT_FOP(xattrop);
+    SET_DEFAULT_FOP(fxattrop);
+    SET_DEFAULT_FOP(setattr);
+    SET_DEFAULT_FOP(fsetattr);
+    SET_DEFAULT_FOP(fallocate);
+    SET_DEFAULT_FOP(discard);
+    SET_DEFAULT_FOP(zerofill);
+    SET_DEFAULT_FOP(ipc);
+    SET_DEFAULT_FOP(seek);
+    SET_DEFAULT_FOP(lease);
+    SET_DEFAULT_FOP(getactivelk);
+    SET_DEFAULT_FOP(setactivelk);
+    SET_DEFAULT_FOP(put);
+
+    SET_DEFAULT_FOP(getspec);
+    SET_DEFAULT_FOP(icreate);
+    SET_DEFAULT_FOP(namelink);
+    SET_DEFAULT_FOP(copy_file_range);
+
+    if (!xl->cbks)
+        xl->cbks = &default_cbks;
+
+    SET_DEFAULT_CBK(release);
+    SET_DEFAULT_CBK(releasedir);
+    SET_DEFAULT_CBK(forget);
+
+    if (!xl->fini)
+        xl->fini = default_fini;
+
+    if (!xl->notify)
+        xl->notify = default_notify;
+
+    if (!xl->mem_acct_init)
+        xl->mem_acct_init = default_mem_acct_init;
+
+    return;
 }
 
-
 int
-xlator_set_type_virtual (xlator_t *xl, const char *type)
+xlator_set_type_virtual(xlator_t *xl, const char *type)
 {
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
-        GF_VALIDATE_OR_GOTO ("xlator", type, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", type, out);
 
-        xl->type = gf_strdup (type);
+    xl->type = gf_strdup(type);
 
-        if (xl->type)
-                return 0;
+    if (xl->type)
+        return 0;
 
 out:
-        return -1;
+    return -1;
 }
 
-
 int
-xlator_volopt_dynload (char *xlator_type, void **dl_handle,
-                       volume_opt_list_t *opt_list)
+xlator_volopt_dynload(char *xlator_type, void **dl_handle,
+                      volume_opt_list_t *opt_list)
 {
-        int                     ret = -1;
-        char                    *name = NULL;
-        void                    *handle = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
+    int ret = -1;
+    int flag = 0;
+    char *name = NULL;
+    void *handle = NULL;
+    xlator_api_t *xlapi = NULL;
+    volume_option_t *opt = NULL;
+
+    GF_VALIDATE_OR_GOTO("xlator", xlator_type, out);
+
+    /* socket.so doesn't fall under the default xlator directory, hence we
+     * need this check */
+    if (!strstr(xlator_type, "rpc-transport"))
+        ret = gf_asprintf(&name, "%s/%s.so", XLATORDIR, xlator_type);
+    else {
+        flag = 1;
+        ret = gf_asprintf(&name, "%s/%s.so", XLATORPARENTDIR, xlator_type);
+    }
+    if (-1 == ret) {
+        goto out;
+    }
+
+    ret = -1;
+
+    gf_msg_trace("xlator", 0, "attempt to load file %s", name);
+
+    handle = dlopen(name, RTLD_NOW);
+    if (!handle) {
+        gf_smsg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, "error=%s",
+                dlerror(), NULL);
+        goto out;
+    }
+
+    if (flag == 0) {
+        /* check new struct first, and then check this */
+        xlapi = dlsym(handle, "xlator_api");
+        if (!xlapi) {
+            gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_DLSYM_ERROR, "error=%s",
+                    dlerror(), NULL);
+            goto out;
+        }
 
-        /* socket.so doesn't fall under the default xlator directory, hence we
-         * need this check */
-        if (!strstr(xlator_type, "rpc-transport"))
-                ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
-        else
-                ret = gf_asprintf (&name, "%s/%s.so", XLATORPARENTDIR, xlator_type);
-        if (-1 == ret) {
-                goto out;
+        opt_list->given_opt = xlapi->options;
+        if (!opt_list->given_opt) {
+            gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED, NULL);
+            goto out;
+        }
+    } else {
+        opt = dlsym(handle, "options");
+        if (!opt) {
+            gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_DLSYM_ERROR, "error=%s",
+                    dlerror(), NULL);
+            goto out;
         }
 
-        ret = -1;
+        opt_list->given_opt = opt;
+    }
 
-        gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
+    *dl_handle = handle;
+    handle = NULL;
 
-        handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
-        if (!handle) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto out;
-        }
+    ret = 0;
+out:
+    GF_FREE(name);
+    if (handle)
+        dlclose(handle);
 
-        if (!(opt_list->given_opt = dlsym (handle, "options"))) {
-                dlerror ();
-                gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
-                        "Failed to load xlator opt table");
-                goto out;
+    gf_msg_debug("xlator", 0, "Returning %d", ret);
+    return ret;
+}
+
+static int
+xlator_dynload_apis(xlator_t *xl)
+{
+    int ret = -1;
+    void *handle = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    xlator_api_t *xlapi = NULL;
+    int i = 0;
+
+    handle = xl->dlhandle;
+
+    xlapi = dlsym(handle, "xlator_api");
+    if (!xlapi) {
+        gf_smsg("xlator", GF_LOG_ERROR, 0, LG_MSG_DLSYM_ERROR, "dlsym=%s",
+                dlerror(), NULL);
+        ret = -1;
+        goto out;
+    }
+
+    xl->fops = xlapi->fops;
+    if (!xl->fops) {
+        gf_smsg("xlator", GF_LOG_WARNING, 0, LG_MSG_STRUCT_MISS, "name=%s",
+                xl->name, NULL);
+        goto out;
+    }
+
+    xl->cbks = xlapi->cbks;
+    if (!xl->cbks) {
+        gf_msg_trace("xlator", 0, "%s: struct missing (cbks)", xl->name);
+    }
+
+    xl->init = xlapi->init;
+    if (!xl->init) {
+        gf_smsg("xlator", GF_LOG_WARNING, 0, LG_MSG_METHOD_MISS, "name=%s",
+                xl->name, NULL);
+        goto out;
+    }
+
+    xl->fini = xlapi->fini;
+    if (!xl->fini) {
+        gf_msg_trace("xlator", 0, "%s: method missing (fini)", xl->name);
+    }
+
+    xl->reconfigure = xlapi->reconfigure;
+    if (!xl->reconfigure) {
+        gf_msg_trace("xlator", 0, "%s: method missing (reconfigure)", xl->name);
+    }
+    xl->notify = xlapi->notify;
+    if (!xl->notify) {
+        gf_msg_trace("xlator", 0, "%s: method missing (notify)", xl->name);
+    }
+    xl->dumpops = xlapi->dumpops;
+    if (!xl->dumpops) {
+        gf_msg_trace("xlator", 0, "%s: method missing (dumpops)", xl->name);
+    }
+    xl->mem_acct_init = xlapi->mem_acct_init;
+    if (!xl->mem_acct_init) {
+        gf_msg_trace("xlator", 0, "%s: method missing (mem_acct_init)",
+                     xl->name);
+    }
+
+    xl->dump_metrics = xlapi->dump_metrics;
+    if (!xl->dump_metrics) {
+        gf_msg_trace("xlator", 0, "%s: method missing (dump_metrics)",
+                     xl->name);
+    }
+
+    xl->pass_through_fops = xlapi->pass_through_fops;
+    if (!xl->pass_through_fops) {
+        gf_msg_trace("xlator", 0,
+                     "%s: method missing (pass_through_fops), "
+                     "falling back to default",
+                     xl->name);
+    }
+
+    vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                        gf_common_mt_volume_opt_list_t);
+    if (!vol_opt) {
+        goto out;
+    }
+    INIT_LIST_HEAD(&vol_opt->list);
+
+    vol_opt->given_opt = default_options;
+    list_add_tail(&vol_opt->list, &xl->volume_options);
+
+    if (xlapi->options) {
+        vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                            gf_common_mt_volume_opt_list_t);
+        if (!vol_opt) {
+            goto out;
         }
+        INIT_LIST_HEAD(&vol_opt->list);
 
-        *dl_handle = handle;
-        handle = NULL;
+        vol_opt->given_opt = xlapi->options;
+        list_add_tail(&vol_opt->list, &xl->volume_options);
+    }
 
-        ret = 0;
- out:
-        GF_FREE (name);
-        if (handle)
-                dlclose (handle);
+    xl->id = xlapi->xlator_id;
+    xl->flags = xlapi->flags;
+    xl->identifier = xlapi->identifier;
+    xl->category = xlapi->category;
 
-        gf_msg_debug ("xlator", 0, "Returning %d", ret);
-        return ret;
+    memcpy(xl->op_version, xlapi->op_version,
+           sizeof(uint32_t) * GF_MAX_RELEASES);
 
-}
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        gf_latency_reset(&xl->stats.interval.latencies[i]);
+    }
 
+    ret = 0;
+out:
+    return ret;
+}
 
 int
-xlator_dynload (xlator_t *xl)
+xlator_dynload(xlator_t *xl)
 {
-        int                ret = -1;
-        char              *name = NULL;
-        void              *handle = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        class_methods_t   *vtbl = NULL;
+    int ret = -1;
+    char *name = NULL;
+    void *handle = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        INIT_LIST_HEAD (&xl->volume_options);
+    INIT_LIST_HEAD(&xl->volume_options);
 
-        ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xl->type);
-        if (-1 == ret) {
-                goto out;
-        }
+    ret = gf_asprintf(&name, "%s/%s.so", XLATORDIR, xl->type);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = -1;
+    ret = -1;
 
-        gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
+    gf_msg_trace("xlator", 0, "attempt to load file %s", name);
 
-        handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
-        if (!handle) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto out;
-        }
-        xl->dlhandle = handle;
+    handle = dlopen(name, RTLD_NOW);
+    if (!handle) {
+        gf_smsg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, "error=%s",
+                dlerror(), NULL);
+        goto out;
+    }
+    xl->dlhandle = handle;
 
-        if (!(xl->fops = dlsym (handle, "fops"))) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(fops) on %s", dlerror ());
-                goto out;
-        }
+    ret = xlator_dynload_apis(xl);
+    if (-1 == ret)
+        goto out;
 
-        if (!(xl->cbks = dlsym (handle, "cbks"))) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(cbks) on %s", dlerror ());
-                goto out;
-        }
+    fill_defaults(xl);
 
-        /*
-         * If class_methods exists, its contents override any definitions of
-         * init or fini for that translator.  Otherwise, we fall back to the
-         * older method of looking for init and fini directly.
-         */
-        vtbl = dlsym(handle,"class_methods");
-        if (vtbl) {
-                xl->init        = vtbl->init;
-                xl->fini        = vtbl->fini;
-                xl->reconfigure = vtbl->reconfigure;
-                xl->notify      = vtbl->notify;
-        }
-        else {
-                if (!(*VOID(&xl->init) = dlsym (handle, "init"))) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_DLSYM_ERROR, "dlsym(init) on %s",
-                                dlerror ());
-                        goto out;
-                }
-
-                if (!(*VOID(&(xl->fini)) = dlsym (handle, "fini"))) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_DLSYM_ERROR, "dlsym(fini) on %s",
-                                dlerror ());
-                        goto out;
-                }
-                if (!(*VOID(&(xl->reconfigure)) = dlsym (handle,
-                                                         "reconfigure"))) {
-                        gf_msg_trace ("xlator", 0, "dlsym(reconfigure) on %s "
-                                      "-- neglecting", dlerror());
-                }
-                if (!(*VOID(&(xl->notify)) = dlsym (handle, "notify"))) {
-                        gf_msg_trace ("xlator", 0, "dlsym(notify) on %s -- "
-                                      "neglecting", dlerror ());
-                }
+    ret = 0;
 
-        }
+out:
+    GF_FREE(name);
+    return ret;
+}
 
-        if (!(xl->dumpops = dlsym (handle, "dumpops"))) {
-                gf_msg_trace ("xlator", 0, "dlsym(dumpops) on %s -- "
-                              "neglecting", dlerror ());
-        }
+int
+xlator_set_type(xlator_t *xl, const char *type)
+{
+    int ret = 0;
 
-        if (!(*VOID(&(xl->mem_acct_init)) = dlsym (handle, "mem_acct_init"))) {
-                gf_msg_trace (xl->name, 0, "dlsym(mem_acct_init) on %s -- "
-                              "neglecting", dlerror ());
-        }
+    /* Handle 'global' translator differently */
+    if (!strncmp(GF_GLOBAL_XLATOR_NAME, type, SLEN(GF_GLOBAL_XLATOR_NAME))) {
+        volume_opt_list_t *vol_opt = NULL;
 
-        vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                         gf_common_mt_volume_opt_list_t);
+        /* set the required values from Global xlator */
+        xl->type = gf_strdup(GF_GLOBAL_XLATOR_NAME);
+        xl->cbks = global_xlator.cbks;
+        xl->fops = global_xlator.fops;
+        xl->init = global_xlator.init;
+        xl->fini = global_xlator.fini;
+        xl->reconfigure = global_xlator.reconfigure;
 
+        vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                            gf_common_mt_volume_opt_list_t);
         if (!vol_opt) {
-                goto out;
+            ret = -1;
+            goto out;
         }
 
-        if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
-                dlerror ();
-                gf_msg_trace (xl->name, 0, "Strict option validation not "
-                              "enforced -- neglecting");
-        }
-        INIT_LIST_HEAD (&vol_opt->list);
-        list_add_tail (&vol_opt->list, &xl->volume_options);
+        vol_opt->given_opt = global_xl_options;
 
-        fill_defaults (xl);
+        INIT_LIST_HEAD(&xl->volume_options);
+        INIT_LIST_HEAD(&vol_opt->list);
+        list_add_tail(&vol_opt->list, &xl->volume_options);
 
+        fill_defaults(xl);
         ret = 0;
+        goto out;
+    }
 
+    ret = xlator_set_type_virtual(xl, type);
+    if (!ret)
+        ret = xlator_dynload(xl);
 out:
-        GF_FREE (name);
-        return ret;
-}
-
-
-int
-xlator_set_type (xlator_t *xl, const char *type)
-{
-        int ret = 0;
-
-        ret = xlator_set_type_virtual (xl, type);
-        if (!ret)
-                ret = xlator_dynload (xl);
-
-        return ret;
+    return ret;
 }
 
 void
-xlator_set_inode_lru_limit (xlator_t *this, void *data)
+xlator_set_inode_lru_limit(xlator_t *this, void *data)
 {
-        int inode_lru_limit = 0;
-
-        if (this->itable) {
-                if (!data) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "input data is NULL. "
-                                "Cannot update the lru limit of the inode"
-                                " table. Continuing with older value");
-                        goto out;
-                }
-                inode_lru_limit = *(int *)data;
-                inode_table_set_lru_limit (this->itable, inode_lru_limit);
+    int inode_lru_limit = 0;
+
+    if (this->itable) {
+        if (!data) {
+            gf_smsg(this->name, GF_LOG_WARNING, 0, LG_MSG_INPUT_DATA_NULL,
+                    NULL);
+            goto out;
         }
+        inode_lru_limit = *(int *)data;
+        inode_table_set_lru_limit(this->itable, inode_lru_limit);
+    }
 
 out:
-        return;
+    return;
 }
 
 void
-xlator_foreach (xlator_t *this,
-                void (*fn)(xlator_t *each,
-                           void *data),
-                void *data)
+xlator_foreach(xlator_t *this, void (*fn)(xlator_t *each, void *data),
+               void *data)
 {
-        xlator_t *first    = NULL;
-        xlator_t *old_THIS = NULL;
+    xlator_t *first = NULL;
+    xlator_t *old_THIS = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", this, out);
-        GF_VALIDATE_OR_GOTO ("xlator", fn, out);
+    GF_VALIDATE_OR_GOTO("xlator", this, out);
+    GF_VALIDATE_OR_GOTO("xlator", fn, out);
 
-        first = this;
+    first = this;
 
-        while (first->prev)
-                first = first->prev;
+    while (first->prev)
+        first = first->prev;
 
-        while (first) {
-                old_THIS = THIS;
-                THIS = first;
+    while (first) {
+        old_THIS = THIS;
+        THIS = first;
 
-                fn (first, data);
+        fn(first, data);
 
-                THIS = old_THIS;
-                first = first->next;
-        }
+        THIS = old_THIS;
+        first = first->next;
+    }
 
 out:
-        return;
+    return;
 }
 
-
 void
-xlator_foreach_depth_first (xlator_t *this,
-			    void (*fn)(xlator_t *each, void *data),
-			    void *data)
+xlator_foreach_depth_first(xlator_t *this,
+                           void (*fn)(xlator_t *each, void *data), void *data)
 {
-	xlator_list_t *subv = NULL;
+    xlator_list_t *subv = NULL;
 
-	subv = this->children;
+    subv = this->children;
 
-	while (subv) {
-		xlator_foreach_depth_first (subv->xlator, fn, data);
-		subv = subv->next;
-	}
+    while (subv) {
+        xlator_foreach_depth_first(subv->xlator, fn, data);
+        subv = subv->next;
+    }
 
-	fn (this, data);
+    fn(this, data);
 }
 
-
 xlator_t *
-xlator_search_by_name (xlator_t *any, const char *name)
+xlator_search_by_name(xlator_t *any, const char *name)
 {
-        xlator_t *search = NULL;
+    xlator_t *search = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", any, out);
-        GF_VALIDATE_OR_GOTO ("xlator", name, out);
+    GF_VALIDATE_OR_GOTO("xlator", any, out);
+    GF_VALIDATE_OR_GOTO("xlator", name, out);
 
-        search = any;
+    search = any;
 
-        while (search->prev)
-                search = search->prev;
+    while (search->prev)
+        search = search->prev;
 
-        while (search) {
-                if (!strcmp (search->name, name))
-                        break;
-                search = search->next;
-        }
+    while (search) {
+        if (!strcmp(search->name, name))
+            break;
+        search = search->next;
+    }
 
 out:
-        return search;
+    return search;
 }
 
-
 /*
  * With brick multiplexing, we sort of have multiple graphs, so
  * xlator_search_by_name might not find what we want.  Also, the translator
@@ -416,278 +546,302 @@ out:
  * search instead of a linear search works around both problems.
  */
 static xlator_t *
-get_xlator_by_name_or_type (xlator_t *this, char *target, int is_name)
+get_xlator_by_name_or_type(xlator_t *this, char *target, int is_name)
 {
-        xlator_list_t   *trav;
-        xlator_t        *child_xl;
-        char            *value;
-
-        for (trav = this->children; trav; trav = trav->next) {
-                value = is_name ? trav->xlator->name : trav->xlator->type;
-                if (strcmp(value, target) == 0) {
-                        return trav->xlator;
-                }
-                child_xl = get_xlator_by_name_or_type (trav->xlator, target,
-                                                       is_name);
-                if (child_xl) {
-                        /*
-                         * If the xlator we're looking for is somewhere down
-                         * the stack, get_xlator_by_name expects to get a
-                         * pointer to the top of its subtree (child of "this")
-                         * while get_xlator_by_type expects a pointer to what
-                         * we actually found.  Handle both cases here.
-                         *
-                         * TBD: rename the functions and fix callers to better
-                         * reflect the difference in semantics.
-                         */
-                        return is_name ? trav->xlator : child_xl;
-                }
+    xlator_list_t *trav;
+    xlator_t *child_xl;
+    char *value;
+
+    for (trav = this->children; trav; trav = trav->next) {
+        value = is_name ? trav->xlator->name : trav->xlator->type;
+        if (!strcmp(value, target) && !trav->xlator->cleanup_starting) {
+            return trav->xlator;
+        }
+        child_xl = get_xlator_by_name_or_type(trav->xlator, target, is_name);
+        if (child_xl) {
+            /*
+             * If the xlator we're looking for is somewhere down
+             * the stack, get_xlator_by_name expects to get a
+             * pointer to the top of its subtree (child of "this")
+             * while get_xlator_by_type expects a pointer to what
+             * we actually found.  Handle both cases here.
+             *
+             * TBD: rename the functions and fix callers to better
+             * reflect the difference in semantics.
+             */
+            return is_name ? trav->xlator : child_xl;
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 
 xlator_t *
-get_xlator_by_name (xlator_t *this, char *target)
+get_xlator_by_name(xlator_t *this, char *target)
 {
-        return get_xlator_by_name_or_type (this, target, 1);
+    return get_xlator_by_name_or_type(this, target, 1);
 }
 
 xlator_t *
-get_xlator_by_type (xlator_t *this, char *target)
+get_xlator_by_type(xlator_t *this, char *target)
 {
-        return get_xlator_by_name_or_type (this, target, 0);
+    return get_xlator_by_name_or_type(this, target, 0);
 }
 
 static int
 __xlator_init(xlator_t *xl)
 {
-        xlator_t *old_THIS = NULL;
-        int       ret = 0;
+    xlator_t *old_THIS = NULL;
+    int ret = 0;
+    int fop_idx = 0;
 
-        old_THIS = THIS;
-        THIS = xl;
+    old_THIS = THIS;
+    THIS = xl;
 
-        xlator_init_lock ();
-        ret = xl->init (xl);
-        xlator_init_unlock ();
+    /* initialize the metrics related locks */
+    for (fop_idx = 0; fop_idx < GF_FOP_MAXVALUE; fop_idx++) {
+        GF_ATOMIC_INIT(xl->stats.total.metrics[fop_idx].fop, 0);
+        GF_ATOMIC_INIT(xl->stats.total.metrics[fop_idx].cbk, 0);
 
-        THIS = old_THIS;
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[fop_idx].fop, 0);
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[fop_idx].cbk, 0);
+    }
+    GF_ATOMIC_INIT(xl->stats.total.count, 0);
+    GF_ATOMIC_INIT(xl->stats.interval.count, 0);
 
-        return ret;
-}
+    xlator_init_lock();
+    handle_default_options(xl, xl->options);
+    ret = xl->init(xl);
+    xlator_init_unlock();
 
+    THIS = old_THIS;
+
+    return ret;
+}
 
 int
-xlator_init (xlator_t *xl)
+xlator_init(xlator_t *xl)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        if (xl->mem_acct_init)
-                xl->mem_acct_init (xl);
+    if (xl->mem_acct_init)
+        xl->mem_acct_init(xl);
 
-        xl->instance_name = NULL;
-        if (!xl->init) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_INIT_FAILED,
-                        "No init() found");
-                goto out;
-        }
+    xl->instance_name = NULL;
+    GF_ATOMIC_INIT(xl->xprtrefcnt, 0);
+    if (!xl->init) {
+        gf_smsg(xl->name, GF_LOG_WARNING, 0, LG_MSG_INIT_FAILED, NULL);
+        goto out;
+    }
 
-        ret = __xlator_init (xl);
+    ret = __xlator_init(xl);
 
-        if (ret) {
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
-                        "Initialization of volume '%s' failed,"
-                        " review your volfile again", xl->name);
-                goto out;
-        }
-
-        xl->init_succeeded = 1;
+    if (ret) {
+        gf_smsg(xl->name, GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR, "name=%s",
+                xl->name, NULL);
+        goto out;
+    }
 
-        ret = 0;
+    xl->init_succeeded = 1;
+    /*xl->cleanup_starting = 0;
+      xl->call_cleanup = 0;
+    */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static void
-xlator_fini_rec (xlator_t *xl)
+xlator_fini_rec(xlator_t *xl)
 {
-        xlator_list_t *trav     = NULL;
-        xlator_t      *old_THIS = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    xlator_list_t *trav = NULL;
+    xlator_t *old_THIS = NULL;
 
-        trav = xl->children;
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        while (trav) {
-                if (!trav->xlator->init_succeeded) {
-                        break;
-                }
+    trav = xl->children;
 
-                xlator_fini_rec (trav->xlator);
-                gf_msg_debug (trav->xlator->name, 0, "fini done");
-                trav = trav->next;
+    while (trav) {
+        if (!trav->xlator->init_succeeded) {
+            break;
         }
 
-        if (xl->init_succeeded) {
-                if (xl->fini) {
-                        old_THIS = THIS;
-                        THIS = xl;
-
-                        xl->fini (xl);
-
-                        if (xl->local_pool)
-                                mem_pool_destroy (xl->local_pool);
-
-                        THIS = old_THIS;
-                } else {
-                        gf_msg_debug (xl->name, 0, "No fini() found");
-                }
-                xl->init_succeeded = 0;
+        xlator_fini_rec(trav->xlator);
+        gf_msg_debug(trav->xlator->name, 0, "fini done");
+        trav = trav->next;
+    }
+
+    xl->cleanup_starting = 1;
+    if (xl->init_succeeded) {
+        if (xl->fini) {
+            old_THIS = THIS;
+            THIS = xl;
+
+            xl->fini(xl);
+
+            if (xl->local_pool) {
+                mem_pool_destroy(xl->local_pool);
+                xl->local_pool = NULL;
+            }
+            if (xl->itable) {
+                inode_table_destroy(xl->itable);
+                xl->itable = NULL;
+            }
+
+            THIS = old_THIS;
+        } else {
+            gf_msg_debug(xl->name, 0, "No fini() found");
         }
+        xl->init_succeeded = 0;
+    }
 
 out:
-        return;
+    return;
 }
 
-
 int
-xlator_notify (xlator_t *xl, int event, void *data, ...)
+xlator_notify(xlator_t *xl, int event, void *data, ...)
 {
-        xlator_t *old_THIS = NULL;
-        int       ret = 0;
+    xlator_t *old_THIS = NULL;
+    int ret = 0;
 
-        old_THIS = THIS;
-        THIS = xl;
+    old_THIS = THIS;
+    THIS = xl;
 
-        ret = xl->notify (xl, event, data);
+    ret = xl->notify(xl, event, data);
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_mem_acct_init (xlator_t *xl, int num_types)
+xlator_mem_acct_init(xlator_t *xl, int num_types)
 {
-        int             i = 0;
-        int             ret = 0;
-
-        if (!xl)
-                return -1;
+    int i = 0;
+    int ret = 0;
 
-        if (!xl->ctx)
-                return -1;
+    if (!xl)
+        return -1;
 
-        if (!xl->ctx->mem_acct_enable)
-                return 0;
+    if (!xl->ctx)
+        return -1;
 
+    if (!xl->ctx->mem_acct_enable)
+        return 0;
 
-        xl->mem_acct = MALLOC (sizeof(struct mem_acct)
-                               + sizeof(struct mem_acct_rec) * num_types);
+    xl->mem_acct = MALLOC(sizeof(struct mem_acct) +
+                          sizeof(struct mem_acct_rec) * num_types);
 
-        if (!xl->mem_acct) {
-                return -1;
-        }
-        memset (xl->mem_acct, 0, sizeof(struct mem_acct));
+    if (!xl->mem_acct) {
+        return -1;
+    }
 
-        xl->mem_acct->num_types = num_types;
-        GF_ATOMIC_INIT (xl->mem_acct->refcnt, 1);
+    xl->mem_acct->num_types = num_types;
+    GF_ATOMIC_INIT(xl->mem_acct->refcnt, 1);
 
-        for (i = 0; i < num_types; i++) {
-                memset (&xl->mem_acct->rec[i], 0, sizeof(struct mem_acct_rec));
-                ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
-                if (ret) {
-                        fprintf(stderr, "Unable to lock..errno : %d",errno);
-                }
+    for (i = 0; i < num_types; i++) {
+        memset(&xl->mem_acct->rec[i], 0, sizeof(struct mem_acct_rec));
+        ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
+        if (ret) {
+            fprintf(stderr, "Unable to lock..errno : %d", errno);
         }
+#ifdef DEBUG
+        INIT_LIST_HEAD(&(xl->mem_acct->rec[i].obj_list));
+#endif
+    }
 
-        return 0;
+    return 0;
 }
 
+void
+xlator_mem_acct_unref(struct mem_acct *mem_acct)
+{
+    uint32_t i;
+
+    if (GF_ATOMIC_DEC(mem_acct->refcnt) == 0) {
+        for (i = 0; i < mem_acct->num_types; i++) {
+            LOCK_DESTROY(&(mem_acct->rec[i].lock));
+        }
+        FREE(mem_acct);
+    }
+}
 
 void
-xlator_tree_fini (xlator_t *xl)
+xlator_tree_fini(xlator_t *xl)
 {
-        xlator_t *top = NULL;
+    xlator_t *top = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        top = xl;
-        xlator_fini_rec (top);
+    top = xl;
+    xlator_fini_rec(top);
 
 out:
-        return;
+    return;
 }
 
 int
-xlator_list_destroy (xlator_list_t *list)
+xlator_list_destroy(xlator_list_t *list)
 {
-        xlator_list_t *next = NULL;
+    xlator_list_t *next = NULL;
 
-        while (list) {
-                next = list->next;
-                GF_FREE (list);
-                list = next;
-        }
+    while (list) {
+        next = list->next;
+        GF_FREE(list);
+        list = next;
+    }
 
-        return 0;
+    return 0;
 }
 
-static int
-xlator_memrec_free (xlator_t *xl)
+int
+xlator_memrec_free(xlator_t *xl)
 {
-        uint32_t        i               = 0;
-        struct mem_acct *mem_acct       = NULL;
-
-        if (!xl) {
-                return 0;
-        }
-        mem_acct = xl->mem_acct;
-
-        if (mem_acct) {
-                for (i = 0; i < mem_acct->num_types; i++) {
-                        LOCK_DESTROY (&(mem_acct->rec[i].lock));
-                }
-                if (GF_ATOMIC_DEC (mem_acct->refcnt) == 0) {
-                        FREE (mem_acct);
-                        xl->mem_acct = NULL;
-                }
-        }
+    struct mem_acct *mem_acct = NULL;
 
+    if (!xl) {
         return 0;
+    }
+    mem_acct = xl->mem_acct;
+
+    if (mem_acct) {
+        xlator_mem_acct_unref(mem_acct);
+        xl->mem_acct = NULL;
+    }
+
+    return 0;
 }
 
 static int
-xlator_members_free (xlator_t *xl)
+xlator_members_free(xlator_t *xl)
 {
-        volume_opt_list_t *vol_opt = NULL;
-        volume_opt_list_t *tmp     = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    volume_opt_list_t *tmp = NULL;
 
-        if (!xl)
-                return 0;
+    if (!xl)
+        return 0;
 
-        GF_FREE (xl->name);
-        GF_FREE (xl->type);
-        if (!(xl->ctx && xl->ctx->cmd_args.valgrind) && xl->dlhandle)
-                dlclose (xl->dlhandle);
-        if (xl->options)
-                dict_unref (xl->options);
+    GF_FREE(xl->name);
+    GF_FREE(xl->type);
+    if (!(xl->ctx && xl->ctx->cmd_args.vgtool != _gf_none) && xl->dlhandle)
+        dlclose(xl->dlhandle);
+    if (xl->options)
+        dict_unref(xl->options);
 
-        xlator_list_destroy (xl->children);
+    xlator_list_destroy(xl->children);
 
-        xlator_list_destroy (xl->parents);
+    xlator_list_destroy(xl->parents);
 
-        list_for_each_entry_safe (vol_opt, tmp, &xl->volume_options, list) {
-                list_del_init (&vol_opt->list);
-                GF_FREE (vol_opt);
-        }
+    list_for_each_entry_safe(vol_opt, tmp, &xl->volume_options, list)
+    {
+        list_del_init(&vol_opt->list);
+        GF_FREE(vol_opt);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* This function destroys all the xlator members except for the
@@ -716,508 +870,724 @@ xlator_members_free (xlator_t *xl)
  */
 
 int
-xlator_tree_free_members (xlator_t *tree)
+xlator_tree_free_members(xlator_t *tree)
 {
-        xlator_t *trav = tree;
-        xlator_t *prev = tree;
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
 
-        if (!tree) {
-                gf_msg ("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
-                        "Translator tree not found");
-                return -1;
-        }
+    if (!tree) {
+        gf_smsg("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND, NULL);
+        return -1;
+    }
 
-        while (prev) {
-                trav = prev->next;
-                xlator_members_free (prev);
-                prev = trav;
-        }
+    while (prev) {
+        trav = prev->next;
+        xlator_members_free(prev);
+        prev = trav;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-xlator_tree_free_memacct (xlator_t *tree)
+xlator_tree_free_memacct(xlator_t *tree)
 {
-        xlator_t *trav = tree;
-        xlator_t *prev = tree;
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
 
-        if (!tree) {
-                gf_msg ("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
-                        "Translator tree not found");
-                return -1;
-        }
+    if (!tree) {
+        gf_smsg("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND, NULL);
+        return -1;
+    }
 
-        while (prev) {
-                trav = prev->next;
-                xlator_memrec_free (prev);
-                GF_FREE (prev);
-                prev = trav;
-        }
+    while (prev) {
+        trav = prev->next;
+        xlator_memrec_free(prev);
+        GF_FREE(prev);
+        prev = trav;
+    }
 
+    return 0;
+}
+
+static int
+xlator_mem_free(xlator_t *xl)
+{
+    volume_opt_list_t *vol_opt = NULL;
+    volume_opt_list_t *tmp = NULL;
+
+    if (!xl)
         return 0;
+
+    if (xl->options) {
+        dict_unref(xl->options);
+        xl->options = NULL;
+    }
+
+    list_for_each_entry_safe(vol_opt, tmp, &xl->volume_options, list)
+    {
+        list_del_init(&vol_opt->list);
+        GF_FREE(vol_opt);
+    }
+
+    xlator_memrec_free(xl);
+
+    return 0;
+}
+
+static void
+xlator_call_fini(xlator_t *this)
+{
+    if (!this || this->call_cleanup)
+        return;
+    this->cleanup_starting = 1;
+    this->call_cleanup = 1;
+    xlator_call_fini(this->next);
+    this->fini(this);
 }
 
 void
-loc_wipe (loc_t *loc)
+xlator_mem_cleanup(xlator_t *this)
 {
-        if (loc->inode) {
-                inode_unref (loc->inode);
-                loc->inode = NULL;
-        }
-        if (loc->path) {
-                GF_FREE ((char *)loc->path);
-                loc->path = NULL;
+    xlator_list_t *list = this->children;
+    xlator_t *trav = list->xlator;
+    inode_table_t *inode_table = NULL;
+    xlator_t *prev = trav;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_list_t **trav_p = NULL;
+    xlator_t *top = NULL;
+    xlator_t *victim = NULL;
+    glusterfs_graph_t *graph = NULL;
+    gf_boolean_t graph_cleanup = _gf_false;
+
+    if (this->call_cleanup || !this->ctx)
+        return;
+
+    this->call_cleanup = 1;
+    ctx = this->ctx;
+
+    inode_table = this->itable;
+    if (inode_table) {
+        inode_table_destroy(inode_table);
+        this->itable = NULL;
+    }
+
+    xlator_call_fini(trav);
+
+    while (prev) {
+        trav = prev->next;
+        xlator_mem_free(prev);
+        prev = trav;
+    }
+
+    if (this->fini) {
+        this->fini(this);
+    }
+
+    xlator_mem_free(this);
+
+    if (ctx->active) {
+        top = ctx->active->first;
+        LOCK(&ctx->volfile_lock);
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            victim = (*trav_p)->xlator;
+            if (victim->call_cleanup && !strcmp(victim->name, this->name)) {
+                graph_cleanup = _gf_true;
+                (*trav_p) = (*trav_p)->next;
+                break;
+            }
         }
+        UNLOCK(&ctx->volfile_lock);
+    }
 
-        if (loc->parent) {
-                inode_unref (loc->parent);
-                loc->parent = NULL;
+    if (graph_cleanup) {
+        prev = this;
+        graph = ctx->active;
+        pthread_mutex_lock(&graph->mutex);
+        while (prev) {
+            trav = prev->next;
+            GF_FREE(prev);
+            prev = trav;
         }
+        pthread_mutex_unlock(&graph->mutex);
+    }
+}
 
-        memset (loc, 0, sizeof (*loc));
+void
+loc_wipe(loc_t *loc)
+{
+    if (loc->inode) {
+        inode_unref(loc->inode);
+        loc->inode = NULL;
+    }
+    if (loc->path) {
+        GF_FREE((char *)loc->path);
+        loc->path = NULL;
+    }
+
+    if (loc->parent) {
+        inode_unref(loc->parent);
+        loc->parent = NULL;
+    }
+
+    memset(loc, 0, sizeof(*loc));
 }
 
 int
-loc_path (loc_t *loc, const char *bname)
+loc_path(loc_t *loc, const char *bname)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        if (loc->path)
-                goto out;
+    if (loc->path)
+        goto out;
 
-        ret = -1;
+    ret = -1;
 
-        if (bname && !strlen (bname))
-                bname = NULL;
+    if (bname && !strlen(bname))
+        bname = NULL;
 
-        if (!bname)
-                goto inode_path;
+    if (!bname)
+        goto inode_path;
 
-        if (loc->parent && !gf_uuid_is_null (loc->parent->gfid)) {
-                ret = inode_path (loc->parent, bname, (char**)&loc->path);
-        } else if (!gf_uuid_is_null (loc->pargfid)) {
-                ret = gf_asprintf ((char**)&loc->path, INODE_PATH_FMT"/%s",
-                                   uuid_utoa (loc->pargfid), bname);
-        }
+    if (loc->parent && !gf_uuid_is_null(loc->parent->gfid)) {
+        ret = inode_path(loc->parent, bname, (char **)&loc->path);
+    } else if (!gf_uuid_is_null(loc->pargfid)) {
+        ret = gf_asprintf((char **)&loc->path, INODE_PATH_FMT "/%s",
+                          uuid_utoa(loc->pargfid), bname);
+    }
 
-        if (loc->path)
-                goto out;
+    if (loc->path)
+        goto out;
 
 inode_path:
-        if (loc->inode && !gf_uuid_is_null (loc->inode->gfid)) {
-                ret = inode_path (loc->inode, NULL, (char **)&loc->path);
-        } else if (!gf_uuid_is_null (loc->gfid)) {
-                ret = gf_asprintf ((char**)&loc->path, INODE_PATH_FMT,
-                                   uuid_utoa (loc->gfid));
-        }
+    if (loc->inode && !gf_uuid_is_null(loc->inode->gfid)) {
+        ret = inode_path(loc->inode, NULL, (char **)&loc->path);
+    } else if (!gf_uuid_is_null(loc->gfid)) {
+        ret = gf_asprintf((char **)&loc->path, INODE_PATH_FMT,
+                          uuid_utoa(loc->gfid));
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void
-loc_gfid (loc_t *loc, uuid_t gfid)
+loc_gfid(loc_t *loc, uuid_t gfid)
 {
-        if (!gfid)
-                goto out;
-        gf_uuid_clear (gfid);
-
-        if (!loc)
-                goto out;
-        else if (!gf_uuid_is_null (loc->gfid))
-                gf_uuid_copy (gfid, loc->gfid);
-        else if (loc->inode && (!gf_uuid_is_null (loc->inode->gfid)))
-                gf_uuid_copy (gfid, loc->inode->gfid);
+    if (!gfid)
+        goto out;
+    gf_uuid_clear(gfid);
+
+    if (!loc)
+        goto out;
+    else if (!gf_uuid_is_null(loc->gfid))
+        gf_uuid_copy(gfid, loc->gfid);
+    else if (loc->inode && (!gf_uuid_is_null(loc->inode->gfid)))
+        gf_uuid_copy(gfid, loc->inode->gfid);
 out:
-        return;
+    return;
 }
 
 void
-loc_pargfid (loc_t *loc, uuid_t gfid)
+loc_pargfid(loc_t *loc, uuid_t gfid)
 {
-        if (!gfid)
-                goto out;
-        gf_uuid_clear (gfid);
-
-        if (!loc)
-                goto out;
-        else if (!gf_uuid_is_null (loc->pargfid))
-                gf_uuid_copy (gfid, loc->pargfid);
-        else if (loc->parent && (!gf_uuid_is_null (loc->parent->gfid)))
-                gf_uuid_copy (gfid, loc->parent->gfid);
+    if (!gfid)
+        goto out;
+    gf_uuid_clear(gfid);
+
+    if (!loc)
+        goto out;
+    else if (!gf_uuid_is_null(loc->pargfid))
+        gf_uuid_copy(gfid, loc->pargfid);
+    else if (loc->parent && (!gf_uuid_is_null(loc->parent->gfid)))
+        gf_uuid_copy(gfid, loc->parent->gfid);
 out:
-        return;
+    return;
 }
 
-char*
-loc_gfid_utoa (loc_t *loc)
+char *
+loc_gfid_utoa(loc_t *loc)
 {
-        uuid_t gfid = {0, };
-        loc_gfid (loc, gfid);
-        return uuid_utoa (gfid);
+    uuid_t gfid = {
+        0,
+    };
+    loc_gfid(loc, gfid);
+    return uuid_utoa(gfid);
 }
 
 int
-loc_touchup (loc_t *loc, const char *name)
+loc_touchup(loc_t *loc, const char *name)
 {
-        char   *path   = NULL;
-        int    ret     = 0;
-
-        if (loc->path)
-                goto out;
-
-        if (loc->parent && name && strlen (name)) {
-                ret = inode_path (loc->parent, name, &path);
-                if (path) /*Guaranteed to have trailing '/' */
-                        loc->name = strrchr (path, '/') + 1;
-
-                if (gf_uuid_is_null (loc->pargfid))
-                        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
-        } else if (loc->inode) {
-                ret = inode_path (loc->inode, 0, &path);
-                if (gf_uuid_is_null (loc->gfid))
-                        gf_uuid_copy (loc->gfid, loc->inode->gfid);
-        }
-
-        if (ret < 0 || !path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        loc->path = path;
-        ret = 0;
+    char *path = NULL;
+    int ret = 0;
+
+    if (loc->path)
+        goto out;
+
+    if (loc->parent && name && strlen(name)) {
+        ret = inode_path(loc->parent, name, &path);
+        if (path) /*Guaranteed to have trailing '/' */
+            loc->name = strrchr(path, '/') + 1;
+
+        if (gf_uuid_is_null(loc->pargfid))
+            gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    } else if (loc->inode) {
+        ret = inode_path(loc->inode, 0, &path);
+        if (gf_uuid_is_null(loc->gfid))
+            gf_uuid_copy(loc->gfid, loc->inode->gfid);
+    }
+
+    if (ret < 0 || !path) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    loc->path = path;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-loc_copy_overload_parent (loc_t *dst, loc_t *src, inode_t *parent)
+loc_copy_overload_parent(loc_t *dst, loc_t *src, inode_t *parent)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", dst, err);
-        GF_VALIDATE_OR_GOTO ("xlator", src, err);
-        GF_VALIDATE_OR_GOTO ("xlator", parent, err);
+    GF_VALIDATE_OR_GOTO("xlator", dst, err);
+    GF_VALIDATE_OR_GOTO("xlator", src, err);
+    GF_VALIDATE_OR_GOTO("xlator", parent, err);
 
-        gf_uuid_copy (dst->gfid, src->gfid);
-        gf_uuid_copy (dst->pargfid, parent->gfid);
+    gf_uuid_copy(dst->gfid, src->gfid);
+    gf_uuid_copy(dst->pargfid, parent->gfid);
 
-        if (src->inode)
-                dst->inode = inode_ref (src->inode);
+    if (src->inode)
+        dst->inode = inode_ref(src->inode);
 
-        if (parent)
-                dst->parent = inode_ref (parent);
+    if (parent)
+        dst->parent = inode_ref(parent);
 
-        if (src->path) {
-                dst->path = gf_strdup (src->path);
+    if (src->path) {
+        dst->path = gf_strdup(src->path);
 
-                if (!dst->path)
-                        goto out;
+        if (!dst->path)
+            goto out;
 
-                if (src->name)
-                        dst->name = strrchr (dst->path, '/');
-                if (dst->name)
-                        dst->name++;
-        } else if (src->name) {
-		dst->name = src->name;
-	}
+        if (src->name)
+            dst->name = strrchr(dst->path, '/');
+        if (dst->name)
+            dst->name++;
+    } else if (src->name) {
+        dst->name = src->name;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1)
-                loc_wipe (dst);
+    if (ret == -1)
+        loc_wipe(dst);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-loc_copy (loc_t *dst, loc_t *src)
+loc_copy(loc_t *dst, loc_t *src)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", dst, err);
-        GF_VALIDATE_OR_GOTO ("xlator", src, err);
+    GF_VALIDATE_OR_GOTO("xlator", dst, err);
+    GF_VALIDATE_OR_GOTO("xlator", src, err);
 
-        if (!gf_uuid_is_null (src->gfid))
-                gf_uuid_copy (dst->gfid, src->gfid);
-        else if (src->inode && !gf_uuid_is_null (src->inode->gfid))
-                gf_uuid_copy (dst->gfid, src->inode->gfid);
+    if (!gf_uuid_is_null(src->gfid))
+        gf_uuid_copy(dst->gfid, src->gfid);
+    else if (src->inode && !gf_uuid_is_null(src->inode->gfid))
+        gf_uuid_copy(dst->gfid, src->inode->gfid);
 
-        gf_uuid_copy (dst->pargfid, src->pargfid);
+    gf_uuid_copy(dst->pargfid, src->pargfid);
 
-        if (src->inode)
-                dst->inode = inode_ref (src->inode);
+    if (src->inode)
+        dst->inode = inode_ref(src->inode);
 
-        if (src->parent)
-                dst->parent = inode_ref (src->parent);
+    if (src->parent)
+        dst->parent = inode_ref(src->parent);
 
-        if (src->path) {
-                dst->path = gf_strdup (src->path);
+    if (src->path) {
+        dst->path = gf_strdup(src->path);
 
-                if (!dst->path)
-                        goto out;
+        if (!dst->path)
+            goto out;
 
-                if (src->name)
-                        dst->name = strrchr (dst->path, '/');
-                if (dst->name)
-                        dst->name++;
-        } else if (src->name) {
-		dst->name = src->name;
-	}
+        if (src->name)
+            dst->name = strrchr(dst->path, '/');
+        if (dst->name)
+            dst->name++;
+    } else if (src->name) {
+        dst->name = src->name;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1)
-                loc_wipe (dst);
+    if (ret == -1)
+        loc_wipe(dst);
 
 err:
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-loc_is_root (loc_t *loc)
+loc_is_root(loc_t *loc)
 {
-        if (loc && __is_root_gfid (loc->gfid)) {
-                return _gf_true;
-        } else if (loc && loc->inode && __is_root_gfid (loc->inode->gfid)) {
-                return _gf_true;
-        }
+    if (loc && __is_root_gfid(loc->gfid)) {
+        return _gf_true;
+    } else if (loc && loc->inode && __is_root_gfid(loc->inode->gfid)) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int32_t
-loc_build_child (loc_t *child, loc_t *parent, char *name)
+loc_build_child(loc_t *child, loc_t *parent, char *name)
 {
-        int32_t  ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", child, out);
-        GF_VALIDATE_OR_GOTO ("xlator", parent, out);
-        GF_VALIDATE_OR_GOTO ("xlator", name, out);
+    GF_VALIDATE_OR_GOTO("xlator", child, out);
+    GF_VALIDATE_OR_GOTO("xlator", parent, out);
+    GF_VALIDATE_OR_GOTO("xlator", name, out);
 
-        loc_gfid (parent, child->pargfid);
+    loc_gfid(parent, child->pargfid);
 
-        if (strcmp (parent->path, "/") == 0)
-                ret = gf_asprintf ((char **)&child->path, "/%s", name);
-        else
-                ret = gf_asprintf ((char **)&child->path, "%s/%s", parent->path,
-                                   name);
+    if (strcmp(parent->path, "/") == 0)
+        ret = gf_asprintf((char **)&child->path, "/%s", name);
+    else
+        ret = gf_asprintf((char **)&child->path, "%s/%s", parent->path, name);
 
-        if (ret < 0 || !child->path) {
-                ret = -1;
-                goto out;
-        }
+    if (ret < 0 || !child->path) {
+        ret = -1;
+        goto out;
+    }
 
-        child->name = strrchr (child->path, '/') + 1;
+    child->name = strrchr(child->path, '/') + 1;
 
-        child->parent = inode_ref (parent->inode);
-        child->inode = inode_new (parent->inode->table);
+    child->parent = inode_ref(parent->inode);
+    child->inode = inode_new(parent->inode->table);
 
-        if (!child->inode) {
-                ret = -1;
-                goto out;
-        }
+    if (!child->inode) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if ((ret < 0) && child)
-                loc_wipe (child);
+    if ((ret < 0) && child)
+        loc_wipe(child);
 
-        return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-loc_is_nameless (loc_t *loc)
+loc_is_nameless(loc_t *loc)
 {
-        gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("xlator", loc, out);
+    GF_VALIDATE_OR_GOTO("xlator", loc, out);
 
-        if ((!loc->parent && gf_uuid_is_null (loc->pargfid)) || !loc->name)
-                ret = _gf_true;
+    if ((!loc->parent && gf_uuid_is_null(loc->pargfid)) || !loc->name)
+        ret = _gf_true;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_destroy (xlator_t *xl)
+xlator_destroy(xlator_t *xl)
 {
-        if (!xl)
-                return 0;
+    if (!xl)
+        return 0;
 
-        xlator_members_free (xl);
-        xlator_memrec_free (xl);
-        GF_FREE (xl);
+    xlator_members_free(xl);
+    xlator_memrec_free(xl);
+    GF_FREE(xl);
 
-        return 0;
+    return 0;
 }
 
-
-int
-is_gf_log_command (xlator_t *this, const char *name, char *value)
+static int32_t
+gf_bin_to_string(char *dst, size_t size, void *src, size_t len)
 {
-        xlator_t       *trav        = NULL;
-        char            key[1024]   = {0,};
-        int             ret         = -1;
-        int             log_level   = -1;
-        gf_boolean_t    syslog_flag = 0;
-        glusterfs_ctx_t *ctx        = NULL;
-
-        if (!strcmp ("trusted.glusterfs.syslog", name)) {
-                ret = gf_string2boolean (value, &syslog_flag);
-                if (ret) {
-                        ret = EOPNOTSUPP;
-                        goto out;
-                }
-                if (syslog_flag)
-                        gf_log_enable_syslog ();
-                else
-                        gf_log_disable_syslog ();
-
-                goto out;
-        }
+    if (len >= size) {
+        return EINVAL;
+    }
 
-        if (fnmatch ("trusted.glusterfs*set-log-level", name, FNM_NOESCAPE))
-                goto out;
+    memcpy(dst, src, len);
+    dst[len] = 0;
 
-        log_level = glusterd_check_log_level (value);
-        if (log_level == -1) {
-                ret = EOPNOTSUPP;
-                goto out;
-        }
+    return 0;
+}
 
-        /* Some crude way to change the log-level of process */
-        if (!strcmp (name, "trusted.glusterfs.set-log-level")) {
-                gf_msg ("glusterfs", gf_log_get_loglevel(), 0,
-                        LG_MSG_SET_LOG_LEVEL,
-                        "setting log level to %d (old-value=%d)",
-                        log_level, gf_log_get_loglevel());
-                gf_log_set_loglevel (log_level);
-                ret = 0;
-                goto out;
+int
+is_gf_log_command(xlator_t *this, const char *name, char *value, size_t size)
+{
+    xlator_t *trav = NULL;
+    char key[1024] = {
+        0,
+    };
+    int ret = -1;
+    int log_level = -1;
+    gf_boolean_t syslog_flag = 0;
+    glusterfs_ctx_t *ctx = NULL;
+
+    if (!strcmp("trusted.glusterfs.syslog", name)) {
+        ret = gf_bin_to_string(key, sizeof(key), value, size);
+        if (ret != 0) {
+            goto out;
         }
-
-        if (!strcmp (name, "trusted.glusterfs.fuse.set-log-level")) {
-                /* */
-                gf_msg (this->name, gf_log_get_xl_loglevel (this), 0,
-                        LG_MSG_SET_LOG_LEVEL,
-                        "setting log level to %d (old-value=%d)",
-                        log_level, gf_log_get_xl_loglevel (this));
-                gf_log_set_xl_loglevel (this, log_level);
-                ret = 0;
-                goto out;
+        ret = gf_string2boolean(key, &syslog_flag);
+        if (ret) {
+            ret = EOPNOTSUPP;
+            goto out;
         }
-
-        ctx = this->ctx;
-        if (!ctx)
-                goto out;
-        if (!ctx->active)
-                goto out;
-        trav = ctx->active->top;
-
-        while (trav) {
-                snprintf (key, 1024, "trusted.glusterfs.%s.set-log-level",
-                          trav->name);
-                if (fnmatch (name, key, FNM_NOESCAPE) == 0) {
-                        gf_msg (trav->name, gf_log_get_xl_loglevel (trav), 0,
-                                LG_MSG_SET_LOG_LEVEL,
-                                "setting log level to %d (old-value=%d)",
-                                log_level, gf_log_get_xl_loglevel (trav));
-                        gf_log_set_xl_loglevel (trav, log_level);
-                        ret = 0;
-                }
-                trav = trav->next;
+        if (syslog_flag)
+            gf_log_enable_syslog();
+        else
+            gf_log_disable_syslog();
+
+        goto out;
+    }
+
+    if (fnmatch("trusted.glusterfs*set-log-level", name, FNM_NOESCAPE))
+        goto out;
+
+    ret = gf_bin_to_string(key, sizeof(key), value, size);
+    if (ret != 0) {
+        goto out;
+    }
+
+    log_level = glusterd_check_log_level(key);
+    if (log_level == -1) {
+        ret = EOPNOTSUPP;
+        goto out;
+    }
+
+    /* Some crude way to change the log-level of process */
+    if (!strcmp(name, "trusted.glusterfs.set-log-level")) {
+        gf_smsg("glusterfs", gf_log_get_loglevel(), 0, LG_MSG_SET_LOG_LEVEL,
+                "new-value=%d", log_level, "old-value=%d",
+                gf_log_get_loglevel(), NULL);
+        gf_log_set_loglevel(this->ctx, log_level);
+        ret = 0;
+        goto out;
+    }
+
+    if (!strcmp(name, "trusted.glusterfs.fuse.set-log-level")) {
+        /* */
+        gf_smsg(this->name, gf_log_get_xl_loglevel(this), 0,
+                LG_MSG_SET_LOG_LEVEL, "new-value=%d", log_level, "old-value=%d",
+                gf_log_get_xl_loglevel(this), NULL);
+        gf_log_set_xl_loglevel(this, log_level);
+        ret = 0;
+        goto out;
+    }
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto out;
+    if (!ctx->active)
+        goto out;
+    trav = ctx->active->top;
+
+    while (trav) {
+        snprintf(key, 1024, "trusted.glusterfs.%s.set-log-level", trav->name);
+        if (fnmatch(name, key, FNM_NOESCAPE) == 0) {
+            gf_smsg(trav->name, gf_log_get_xl_loglevel(trav), 0,
+                    LG_MSG_SET_LOG_LEVEL, "new-value%d", log_level,
+                    "old-value=%d", gf_log_get_xl_loglevel(trav), NULL);
+            gf_log_set_xl_loglevel(trav, log_level);
+            ret = 0;
         }
+        trav = trav->next;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterd_check_log_level (const char *value)
+glusterd_check_log_level(const char *value)
 {
-        int log_level = -1;
-
-        if (!strcasecmp (value, "CRITICAL")) {
-                log_level = GF_LOG_CRITICAL;
-        } else if (!strcasecmp (value, "ERROR")) {
-                log_level = GF_LOG_ERROR;
-        } else if (!strcasecmp (value, "WARNING")) {
-                log_level = GF_LOG_WARNING;
-        } else if (!strcasecmp (value, "INFO")) {
-                log_level = GF_LOG_INFO;
-        } else if (!strcasecmp (value, "DEBUG")) {
-                log_level = GF_LOG_DEBUG;
-        } else if (!strcasecmp (value, "TRACE")) {
-                log_level = GF_LOG_TRACE;
-        } else if (!strcasecmp (value, "NONE")) {
-                log_level = GF_LOG_NONE;
-        }
-
-        if (log_level == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
-                        "Invalid log-level. possible values are "
-                        "DEBUG|WARNING|ERROR|CRITICAL|NONE|TRACE");
-
-        return log_level;
+    int log_level = -1;
+
+    if (!strcasecmp(value, "CRITICAL")) {
+        log_level = GF_LOG_CRITICAL;
+    } else if (!strcasecmp(value, "ERROR")) {
+        log_level = GF_LOG_ERROR;
+    } else if (!strcasecmp(value, "WARNING")) {
+        log_level = GF_LOG_WARNING;
+    } else if (!strcasecmp(value, "INFO")) {
+        log_level = GF_LOG_INFO;
+    } else if (!strcasecmp(value, "DEBUG")) {
+        log_level = GF_LOG_DEBUG;
+    } else if (!strcasecmp(value, "TRACE")) {
+        log_level = GF_LOG_TRACE;
+    } else if (!strcasecmp(value, "NONE")) {
+        log_level = GF_LOG_NONE;
+    }
+
+    if (log_level == -1)
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_INIT, NULL);
+
+    return log_level;
 }
 
 int
-xlator_subvolume_count (xlator_t *this)
+xlator_subvolume_count(xlator_t *this)
 {
-        int i = 0;
-        xlator_list_t *list = NULL;
+    int i = 0;
+    xlator_list_t *list = NULL;
 
-        for (list = this->children; list; list = list->next)
-                i++;
-        return i;
+    for (list = this->children; list; list = list->next)
+        i++;
+    return i;
 }
 
 static int
-_copy_opt_to_child (dict_t *options, char *key, data_t *value, void *data)
+_copy_opt_to_child(dict_t *options, char *key, data_t *value, void *data)
 {
-        xlator_t        *child = data;
+    xlator_t *child = data;
 
-        gf_log (__func__, GF_LOG_DEBUG,
-                "copying %s to child %s", key, child->name);
-        dict_set (child->options, key, value);
+    gf_log(__func__, GF_LOG_DEBUG, "copying %s to child %s", key, child->name);
+    dict_set(child->options, key, value);
 
-        return 0;
+    return 0;
 }
 
 int
-copy_opts_to_child (xlator_t *src, xlator_t *dst, char *glob)
+copy_opts_to_child(xlator_t *src, xlator_t *dst, char *glob)
 {
-        return dict_foreach_fnmatch (src->options, glob,
-                                     _copy_opt_to_child, dst);
+    return dict_foreach_fnmatch(src->options, glob, _copy_opt_to_child, dst);
 }
 
 int
-glusterfs_delete_volfile_checksum (glusterfs_ctx_t *ctx,
-                                   const char *volfile_id) {
-
-        gf_volfile_t            *volfile_tmp      = NULL;
-        gf_volfile_t            *volfile_obj      = NULL;
-
-        list_for_each_entry (volfile_tmp,  &ctx->volfile_list,
-                             volfile_list) {
-                if (!strcmp (volfile_id, volfile_tmp->vol_id)) {
-                        list_del_init (&volfile_tmp->volfile_list);
-                        volfile_obj = volfile_tmp;
-                        break;
-                }
+glusterfs_delete_volfile_checksum(glusterfs_ctx_t *ctx, const char *volfile_id)
+{
+    gf_volfile_t *volfile_tmp = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+
+    list_for_each_entry(volfile_tmp, &ctx->volfile_list, volfile_list)
+    {
+        if (!strcmp(volfile_id, volfile_tmp->vol_id)) {
+            list_del_init(&volfile_tmp->volfile_list);
+            volfile_obj = volfile_tmp;
+            break;
         }
+    }
+
+    if (volfile_obj) {
+        GF_FREE(volfile_obj);
+    } else {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to get volfile "
+               "checksum for volfile id %s.",
+               volfile_id);
+    }
+
+    return 0;
+}
 
-        if (volfile_obj) {
-                GF_FREE (volfile_obj);
-        } else {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to get volfile "
-                        "checksum for volfile id %s.", volfile_id);
-        }
+/*
+   The function is required to take dict ref for every xlator at graph.
+   At the time of compare graph topology create a graph and populate
+   key values in the dictionary, after finished graph comparison we do destroy
+   the new graph.At the time of construct graph we don't take any reference
+   so to avoid dict leak at the of destroying graph due to ref counter underflow
+   we need to call dict_ref here.
+
+*/
+
+void
+gluster_graph_take_reference(xlator_t *tree)
+{
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
+
+    if (!tree) {
+        gf_smsg("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND, NULL);
+        return;
+    }
+
+    while (prev) {
+        trav = prev->next;
+        if (prev->options)
+            dict_ref(prev->options);
+        prev = trav;
+    }
+    return;
+}
+
+gf_boolean_t
+mgmt_is_multiplexed_daemon(char *name)
+{
+    const char *mux_daemons[] = {"glustershd", NULL};
+    int i;
+
+    if (!name)
+        return _gf_false;
+
+    for (i = 0; mux_daemons[i]; i++) {
+        if (!strcmp(name, mux_daemons[i]))
+            return _gf_true;
+    }
+    return _gf_false;
+}
 
+gf_boolean_t
+xlator_is_cleanup_starting(xlator_t *this)
+{
+    gf_boolean_t cleanup = _gf_false;
+    glusterfs_graph_t *graph = NULL;
+    xlator_t *xl = NULL;
+
+    if (!this) {
+        gf_smsg("xlator", GF_LOG_WARNING, EINVAL, LG_MSG_OBJECT_NULL, "xlator",
+                NULL);
+        goto out;
+    }
+
+    graph = this->graph;
+    if (!graph) {
+        gf_smsg("xlator", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_NOT_SET,
+                "name=%s", this->name, NULL);
+        goto out;
+    }
+
+    xl = graph->first;
+    if (xl && xl->cleanup_starting)
+        cleanup = _gf_true;
+out:
+    return cleanup;
+}
+
+int
+graph_total_client_xlator(glusterfs_graph_t *graph)
+{
+    xlator_t *xl = NULL;
+    int count = 0;
+
+    if (!graph) {
+        gf_smsg("xlator", GF_LOG_WARNING, EINVAL, LG_MSG_OBJECT_NULL, "graph",
+                NULL);
+        goto out;
+    }
+
+    xl = graph->first;
+    if (!strcmp(xl->type, "protocol/server")) {
+        gf_msg_debug(xl->name, 0, "Return because it is a server graph");
         return 0;
+    }
+
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0) {
+            count++;
+        }
+        xl = xl->next;
+    }
+out:
+    return count;
 }
diff --git a/libglusterfs/src/xlator.h b/libglusterfs/src/xlator.h
deleted file mode 100644
index 26d2cc5b595..00000000000
--- a/libglusterfs/src/xlator.h
+++ /dev/null
@@ -1,1073 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _XLATOR_H
-#define _XLATOR_H
-
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-#include "event-history.h"
-#include "logging.h"
-#include "common-utils.h"
-#include "dict.h"
-#include "compat.h"
-#include "list.h"
-#include "latency.h"
-#include "compat-uuid.h"
-
-#define FIRST_CHILD(xl) (xl->children->xlator)
-#define SECOND_CHILD(xl) (xl->children->next->xlator)
-
-#define GF_SET_ATTR_MODE  0x1
-#define GF_SET_ATTR_UID   0x2
-#define GF_SET_ATTR_GID   0x4
-#define GF_SET_ATTR_SIZE  0x8
-#define GF_SET_ATTR_ATIME 0x10
-#define GF_SET_ATTR_MTIME 0x20
-
-#define gf_attr_mode_set(mode)  ((mode) & GF_SET_ATTR_MODE)
-#define gf_attr_uid_set(mode)   ((mode) & GF_SET_ATTR_UID)
-#define gf_attr_gid_set(mode)   ((mode) & GF_SET_ATTR_GID)
-#define gf_attr_size_set(mode)  ((mode) & GF_SET_ATTR_SIZE)
-#define gf_attr_atime_set(mode) ((mode) & GF_SET_ATTR_ATIME)
-#define gf_attr_mtime_set(mode) ((mode) & GF_SET_ATTR_MTIME)
-
-struct _xlator;
-typedef struct _xlator xlator_t;
-struct _dir_entry;
-typedef struct _dir_entry dir_entry_t;
-struct _gf_dirent;
-typedef struct _gf_dirent gf_dirent_t;
-struct _loc;
-typedef struct _loc loc_t;
-
-
-typedef int32_t (*event_notify_fn_t) (xlator_t *this, int32_t event, void *data,
-                                      ...);
-
-#include "list.h"
-#include "gf-dirent.h"
-#include "stack.h"
-#include "iobuf.h"
-#include "inode.h"
-#include "fd.h"
-#include "globals.h"
-#include "iatt.h"
-#include "options.h"
-#include "client_t.h"
-
-
-struct _loc {
-        const char *path;
-        const char *name;
-        inode_t    *inode;
-        inode_t    *parent;
-        /* Currently all location based operations are through 'gfid' of inode.
-         * But the 'inode->gfid' only gets set in higher most layer (as in,
-         * 'fuse', 'protocol/server', or 'nfs/server'). So if translators want
-         * to send fops on a inode before the 'inode->gfid' is set, they have to
-         * make use of below 'gfid' fields
-         */
-        uuid_t      gfid;
-        uuid_t      pargfid;
-};
-
-
-typedef int32_t (*fop_getspec_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      char *spec_data);
-
-typedef int32_t (*fop_rchecksum_cbk_t) (call_frame_t *frame,
-                                        void *cookie,
-                                        xlator_t *this,
-                                        int32_t op_ret,
-                                        int32_t op_errno,
-                                        uint32_t weak_checksum,
-                                        uint8_t *strong_checksum,
-                                        dict_t *xdata);
-
-
-typedef int32_t (*fop_getspec_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  const char *key,
-                                  int32_t flag);
-
-typedef int32_t (*fop_rchecksum_t) (call_frame_t *frame,
-                                    xlator_t *this,
-                                    fd_t *fd, off_t offset,
-                                    int32_t len, dict_t *xdata);
-
-
-typedef int32_t (*fop_lookup_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     inode_t *inode,
-                                     struct iatt *buf,
-                                     dict_t *xdata,
-                                     struct iatt *postparent);
-
-typedef int32_t (*fop_stat_cbk_t) (call_frame_t *frame,
-                                   void *cookie,
-                                   xlator_t *this,
-                                   int32_t op_ret,
-                                   int32_t op_errno,
-                                   struct iatt *buf, dict_t *xdata);
-
-typedef int32_t (*fop_fstat_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    struct iatt *buf, dict_t *xdata);
-
-typedef int32_t (*fop_truncate_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       struct iatt *prebuf,
-                                       struct iatt *postbuf, dict_t *xdata);
-
-typedef int32_t (*fop_ftruncate_cbk_t) (call_frame_t *frame,
-                                        void *cookie,
-                                        xlator_t *this,
-                                        int32_t op_ret,
-                                        int32_t op_errno,
-                                        struct iatt *prebuf,
-                                        struct iatt *postbuf, dict_t *xdata);
-
-typedef int32_t (*fop_access_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_readlink_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       const char *path,
-                                       struct iatt *buf, dict_t *xdata);
-
-typedef int32_t (*fop_mknod_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    inode_t *inode,
-                                    struct iatt *buf,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_mkdir_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    inode_t *inode,
-                                    struct iatt *buf,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_unlink_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     struct iatt *preparent,
-                                     struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_rmdir_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_symlink_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      inode_t *inode,
-                                      struct iatt *buf,
-                                      struct iatt *preparent,
-                                      struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_rename_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     struct iatt *buf,
-                                     struct iatt *preoldparent,
-                                     struct iatt *postoldparent,
-                                     struct iatt *prenewparent,
-                                     struct iatt *postnewparent, dict_t *xdata);
-
-typedef int32_t (*fop_link_cbk_t) (call_frame_t *frame,
-                                   void *cookie,
-                                   xlator_t *this,
-                                   int32_t op_ret,
-                                   int32_t op_errno,
-                                   inode_t *inode,
-                                   struct iatt *buf,
-                                   struct iatt *preparent,
-                                   struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_create_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     fd_t *fd,
-                                     inode_t *inode,
-                                     struct iatt *buf,
-                                     struct iatt *preparent,
-                                     struct iatt *postparent, dict_t *xdata);
-
-typedef int32_t (*fop_open_cbk_t) (call_frame_t *frame,
-                                   void *cookie,
-                                   xlator_t *this,
-                                   int32_t op_ret,
-                                   int32_t op_errno,
-                                   fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_readv_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    struct iovec *vector,
-                                    int32_t count,
-                                    struct iatt *stbuf,
-                                    struct iobref *iobref, dict_t *xdata);
-
-typedef int32_t (*fop_writev_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     struct iatt *prebuf,
-                                     struct iatt *postbuf, dict_t *xdata);
-
-typedef int32_t (*fop_flush_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_fsync_cbk_t) (call_frame_t *frame,
-                                    void *cookie,
-                                    xlator_t *this,
-                                    int32_t op_ret,
-                                    int32_t op_errno,
-                                    struct iatt *prebuf,
-                                    struct iatt *postbuf, dict_t *xdata);
-
-typedef int32_t (*fop_opendir_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_fsyncdir_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_statfs_cbk_t) (call_frame_t *frame,
-                                     void *cookie,
-                                     xlator_t *this,
-                                     int32_t op_ret,
-                                     int32_t op_errno,
-                                     struct statvfs *buf, dict_t *xdata);
-
-typedef int32_t (*fop_setxattr_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_getxattr_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       dict_t *dict, dict_t *xdata);
-
-typedef int32_t (*fop_fsetxattr_cbk_t) (call_frame_t *frame,
-                                        void *cookie,
-                                        xlator_t *this,
-                                        int32_t op_ret,
-                                        int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_fgetxattr_cbk_t) (call_frame_t *frame,
-                                        void *cookie,
-                                        xlator_t *this,
-                                        int32_t op_ret,
-                                        int32_t op_errno,
-                                        dict_t *dict, dict_t *xdata);
-
-typedef int32_t (*fop_removexattr_cbk_t) (call_frame_t *frame,
-                                          void *cookie,
-                                          xlator_t *this,
-                                          int32_t op_ret,
-                                          int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_fremovexattr_cbk_t) (call_frame_t *frame,
-                                           void *cookie,
-                                           xlator_t *this,
-                                           int32_t op_ret,
-                                           int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_lk_cbk_t) (call_frame_t *frame,
-                                 void *cookie,
-                                 xlator_t *this,
-                                 int32_t op_ret,
-                                 int32_t op_errno,
-                                 struct gf_flock *flock, dict_t *xdata);
-
-typedef int32_t (*fop_inodelk_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_finodelk_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_entrylk_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_fentrylk_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_readdir_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      gf_dirent_t *entries, dict_t *xdata);
-
-typedef int32_t (*fop_readdirp_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       gf_dirent_t *entries, dict_t *xdata);
-
-typedef int32_t (*fop_xattrop_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      dict_t *xattr, dict_t *xdata);
-
-typedef int32_t (*fop_fxattrop_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       dict_t *xattr, dict_t *xdata);
-
-
-typedef int32_t (*fop_setattr_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      struct iatt *preop_stbuf,
-                                      struct iatt *postop_stbuf, dict_t *xdata);
-
-typedef int32_t (*fop_fsetattr_cbk_t) (call_frame_t *frame,
-                                       void *cookie,
-                                       xlator_t *this,
-                                       int32_t op_ret,
-                                       int32_t op_errno,
-                                       struct iatt *preop_stbuf,
-                                       struct iatt *postop_stbuf, dict_t *xdata);
-
-typedef int32_t (*fop_fallocate_cbk_t) (call_frame_t *frame,
-                                        void *cookie,
-                                        xlator_t *this,
-                                        int32_t op_ret,
-                                        int32_t op_errno,
-                                        struct iatt *preop_stbuf,
-                                        struct iatt *postop_stbuf, dict_t *xdata);
-
-typedef int32_t (*fop_discard_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      struct iatt *preop_stbuf,
-                                      struct iatt *postop_stbuf, dict_t *xdata);
-
-typedef int32_t (*fop_zerofill_cbk_t) (call_frame_t *frame,
-                                      void *cookie,
-                                      xlator_t *this,
-                                      int32_t op_ret,
-                                      int32_t op_errno,
-                                      struct iatt *preop_stbuf,
-                                      struct iatt *postop_stbuf, dict_t *xdata);
-
-typedef int32_t (*fop_ipc_cbk_t) (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_seek_cbk_t) (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int32_t op_ret,
-                                   int32_t op_errno, off_t offset,
-                                   dict_t *xdata);
-
-typedef int32_t (*fop_lease_cbk_t) (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int32_t op_ret,
-                                    int32_t op_errno, struct gf_lease *lease,
-                                    dict_t *xdata);
-typedef int32_t (*fop_compound_cbk_t) (call_frame_t *frame,
-                                       void *cookie, xlator_t *this,
-                                       int32_t op_ret, int32_t op_errno,
-                                       void *data, dict_t *xdata);
-
-typedef int32_t (*fop_getactivelk_cbk_t) (call_frame_t *frame, void *cookie,
-                                           xlator_t *this, int32_t op_ret,
-                                           int32_t op_errno,
-                                           lock_migration_info_t *locklist,
-                                           dict_t *xdata);
-
-typedef int32_t (*fop_setactivelk_cbk_t) (call_frame_t *frame, void *cookie,
-                                            xlator_t *this, int32_t op_ret,
-                                            int32_t op_errno, dict_t *xdata);
-
-typedef int32_t (*fop_lookup_t) (call_frame_t *frame,
-                                 xlator_t *this,
-                                 loc_t *loc,
-                                 dict_t *xdata);
-
-typedef int32_t (*fop_stat_t) (call_frame_t *frame,
-                               xlator_t *this,
-                               loc_t *loc, dict_t *xdata);
-
-typedef int32_t (*fop_fstat_t) (call_frame_t *frame,
-                                xlator_t *this,
-                                fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_truncate_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   loc_t *loc,
-                                   off_t offset, dict_t *xdata);
-
-typedef int32_t (*fop_ftruncate_t) (call_frame_t *frame,
-                                    xlator_t *this,
-                                    fd_t *fd,
-                                    off_t offset, dict_t *xdata);
-
-typedef int32_t (*fop_access_t) (call_frame_t *frame,
-                                 xlator_t *this,
-                                 loc_t *loc,
-                                 int32_t mask, dict_t *xdata);
-
-typedef int32_t (*fop_readlink_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   loc_t *loc,
-                                   size_t size, dict_t *xdata);
-
-typedef int32_t (*fop_mknod_t) (call_frame_t *frame, xlator_t *this,
-                                loc_t *loc, mode_t mode, dev_t rdev,
-                                mode_t umask, dict_t *xdata);
-
-typedef int32_t (*fop_mkdir_t) (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                                mode_t mode, mode_t umask, dict_t *xdata);
-
-typedef int32_t (*fop_unlink_t) (call_frame_t *frame, xlator_t *this,
-                                 loc_t *loc, int xflags, dict_t *xdata);
-
-typedef int32_t (*fop_rmdir_t) (call_frame_t *frame, xlator_t *this,
-                                loc_t *loc, int xflags, dict_t *xdata);
-
-typedef int32_t (*fop_symlink_t) (call_frame_t *frame, xlator_t *this,
-                                  const char *linkname, loc_t *loc,
-                                  mode_t umask, dict_t *xdata);
-
-typedef int32_t (*fop_rename_t) (call_frame_t *frame,
-                                 xlator_t *this,
-                                 loc_t *oldloc,
-                                 loc_t *newloc, dict_t *xdata);
-
-typedef int32_t (*fop_link_t) (call_frame_t *frame,
-                               xlator_t *this,
-                               loc_t *oldloc,
-                               loc_t *newloc, dict_t *xdata);
-
-typedef int32_t (*fop_create_t) (call_frame_t *frame, xlator_t *this,
-                                 loc_t *loc, int32_t flags, mode_t mode,
-                                 mode_t umask, fd_t *fd, dict_t *xdata);
-
-/* Tell subsequent writes on the fd_t to fsync after every writev fop without
- * requiring a fsync fop.
- */
-#define GF_OPEN_FSYNC   0x01
-
-/* Tell write-behind to disable writing behind despite O_SYNC not being set.
- */
-#define GF_OPEN_NOWB    0x02
-
-typedef int32_t (*fop_open_t) (call_frame_t *frame, xlator_t *this,
-                               loc_t *loc, int32_t flags,
-                               fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_readv_t) (call_frame_t *frame,
-                                xlator_t *this,
-                                fd_t *fd,
-                                size_t size,
-                                off_t offset,
-                                uint32_t flags, dict_t *xdata);
-
-typedef int32_t (*fop_writev_t) (call_frame_t *frame,
-                                 xlator_t *this,
-                                 fd_t *fd,
-                                 struct iovec *vector,
-                                 int32_t count,
-                                 off_t offset,
-                                 uint32_t flags,
-                                 struct iobref *iobref, dict_t *xdata);
-
-typedef int32_t (*fop_flush_t) (call_frame_t *frame,
-                                xlator_t *this,
-                                fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_fsync_t) (call_frame_t *frame,
-                                xlator_t *this,
-                                fd_t *fd,
-                                int32_t datasync, dict_t *xdata);
-
-typedef int32_t (*fop_opendir_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  loc_t *loc,
-                                  fd_t *fd, dict_t *xdata);
-
-typedef int32_t (*fop_fsyncdir_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   fd_t *fd,
-                                   int32_t datasync, dict_t *xdata);
-
-typedef int32_t (*fop_statfs_t) (call_frame_t *frame,
-                                 xlator_t *this,
-                                 loc_t *loc, dict_t *xdata);
-
-typedef int32_t (*fop_setxattr_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   loc_t *loc,
-                                   dict_t *dict,
-                                   int32_t flags, dict_t *xdata);
-
-typedef int32_t (*fop_getxattr_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   loc_t *loc,
-                                   const char *name, dict_t *xdata);
-
-typedef int32_t (*fop_fsetxattr_t) (call_frame_t *frame,
-                                    xlator_t *this,
-                                    fd_t *fd,
-                                    dict_t *dict,
-                                    int32_t flags, dict_t *xdata);
-
-typedef int32_t (*fop_fgetxattr_t) (call_frame_t *frame,
-                                    xlator_t *this,
-                                    fd_t *fd,
-                                    const char *name, dict_t *xdata);
-
-typedef int32_t (*fop_removexattr_t) (call_frame_t *frame,
-                                      xlator_t *this,
-                                      loc_t *loc,
-                                      const char *name, dict_t *xdata);
-
-typedef int32_t (*fop_fremovexattr_t) (call_frame_t *frame,
-                                       xlator_t *this,
-                                       fd_t *fd,
-                                       const char *name, dict_t *xdata);
-
-typedef int32_t (*fop_lk_t) (call_frame_t *frame,
-                             xlator_t *this,
-                             fd_t *fd,
-                             int32_t cmd,
-                             struct gf_flock *flock, dict_t *xdata);
-
-typedef int32_t (*fop_inodelk_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  const char *volume,
-                                  loc_t *loc,
-                                  int32_t cmd,
-                                  struct gf_flock *flock, dict_t *xdata);
-
-typedef int32_t (*fop_finodelk_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   const char *volume,
-                                   fd_t *fd,
-                                   int32_t cmd,
-                                   struct gf_flock *flock, dict_t *xdata);
-
-typedef int32_t (*fop_entrylk_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  const char *volume, loc_t *loc,
-                                  const char *basename, entrylk_cmd cmd,
-                                  entrylk_type type, dict_t *xdata);
-
-typedef int32_t (*fop_fentrylk_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   const char *volume, fd_t *fd,
-                                   const char *basename, entrylk_cmd cmd,
-                                   entrylk_type type, dict_t *xdata);
-
-typedef int32_t (*fop_readdir_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  fd_t *fd,
-                                  size_t size,
-                                  off_t offset, dict_t *xdata);
-
-typedef int32_t (*fop_readdirp_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   fd_t *fd,
-                                   size_t size,
-                                   off_t offset,
-                                   dict_t *xdata);
-
-typedef int32_t (*fop_xattrop_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  loc_t *loc,
-                                  gf_xattrop_flags_t optype,
-                                  dict_t *xattr, dict_t *xdata);
-
-typedef int32_t (*fop_fxattrop_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   fd_t *fd,
-                                   gf_xattrop_flags_t optype,
-                                   dict_t *xattr, dict_t *xdata);
-
-typedef int32_t (*fop_setattr_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  loc_t *loc,
-                                  struct iatt *stbuf,
-                                  int32_t valid, dict_t *xdata);
-
-typedef int32_t (*fop_fsetattr_t) (call_frame_t *frame,
-                                   xlator_t *this,
-                                   fd_t *fd,
-                                   struct iatt *stbuf,
-                                   int32_t valid, dict_t *xdata);
-
-typedef int32_t (*fop_fallocate_t) (call_frame_t *frame,
-                                    xlator_t *this,
-                                    fd_t *fd,
-				    int32_t keep_size,
-				    off_t offset,
-				    size_t len,
-                                    dict_t *xdata);
-
-typedef int32_t (*fop_discard_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  fd_t *fd,
-				  off_t offset,
-				  size_t len,
-                                  dict_t *xdata);
-
-typedef int32_t (*fop_zerofill_t) (call_frame_t *frame,
-                                  xlator_t *this,
-                                  fd_t *fd,
-                                  off_t offset,
-                                  off_t len,
-                                  dict_t *xdata);
-
-typedef int32_t (*fop_ipc_t) (call_frame_t *frame, xlator_t *this, int32_t op,
-                              dict_t *xdata);
-
-typedef int32_t (*fop_seek_t) (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                               off_t offset, gf_seek_what_t what,
-                               dict_t *xdata);
-
-typedef int32_t (*fop_lease_t) (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                                struct gf_lease *lease, dict_t *xdata);
-
-typedef int32_t (*fop_compound_t) (call_frame_t *frame, xlator_t *this,
-                                   void *args, dict_t *xdata);
-
-typedef int32_t (*fop_getactivelk_t) (call_frame_t *frame, xlator_t *this,
-                                       loc_t *loc, dict_t *xdata);
-
-typedef int32_t (*fop_setactivelk_t) (call_frame_t *frame, xlator_t *this,
-                                      loc_t *loc,
-                                      lock_migration_info_t *locklist,
-                                      dict_t *xdata);
-
-struct xlator_fops {
-        fop_lookup_t         lookup;
-        fop_stat_t           stat;
-        fop_fstat_t          fstat;
-        fop_truncate_t       truncate;
-        fop_ftruncate_t      ftruncate;
-        fop_access_t         access;
-        fop_readlink_t       readlink;
-        fop_mknod_t          mknod;
-        fop_mkdir_t          mkdir;
-        fop_unlink_t         unlink;
-        fop_rmdir_t          rmdir;
-        fop_symlink_t        symlink;
-        fop_rename_t         rename;
-        fop_link_t           link;
-        fop_create_t         create;
-        fop_open_t           open;
-        fop_readv_t          readv;
-        fop_writev_t         writev;
-        fop_flush_t          flush;
-        fop_fsync_t          fsync;
-        fop_opendir_t        opendir;
-        fop_readdir_t        readdir;
-        fop_readdirp_t       readdirp;
-        fop_fsyncdir_t       fsyncdir;
-        fop_statfs_t         statfs;
-        fop_setxattr_t       setxattr;
-        fop_getxattr_t       getxattr;
-        fop_fsetxattr_t      fsetxattr;
-        fop_fgetxattr_t      fgetxattr;
-        fop_removexattr_t    removexattr;
-        fop_fremovexattr_t   fremovexattr;
-        fop_lk_t             lk;
-        fop_inodelk_t        inodelk;
-        fop_finodelk_t       finodelk;
-        fop_entrylk_t        entrylk;
-        fop_fentrylk_t       fentrylk;
-        fop_rchecksum_t      rchecksum;
-        fop_xattrop_t        xattrop;
-        fop_fxattrop_t       fxattrop;
-        fop_setattr_t        setattr;
-        fop_fsetattr_t       fsetattr;
-        fop_getspec_t        getspec;
-	fop_fallocate_t	     fallocate;
-	fop_discard_t	     discard;
-        fop_zerofill_t       zerofill;
-        fop_ipc_t            ipc;
-        fop_seek_t           seek;
-        fop_lease_t          lease;
-        fop_compound_t       compound;
-        fop_getactivelk_t   getactivelk;
-        fop_setactivelk_t  setactivelk;
-
-        /* these entries are used for a typechecking hack in STACK_WIND _only_ */
-        fop_lookup_cbk_t         lookup_cbk;
-        fop_stat_cbk_t           stat_cbk;
-        fop_fstat_cbk_t          fstat_cbk;
-        fop_truncate_cbk_t       truncate_cbk;
-        fop_ftruncate_cbk_t      ftruncate_cbk;
-        fop_access_cbk_t         access_cbk;
-        fop_readlink_cbk_t       readlink_cbk;
-        fop_mknod_cbk_t          mknod_cbk;
-        fop_mkdir_cbk_t          mkdir_cbk;
-        fop_unlink_cbk_t         unlink_cbk;
-        fop_rmdir_cbk_t          rmdir_cbk;
-        fop_symlink_cbk_t        symlink_cbk;
-        fop_rename_cbk_t         rename_cbk;
-        fop_link_cbk_t           link_cbk;
-        fop_create_cbk_t         create_cbk;
-        fop_open_cbk_t           open_cbk;
-        fop_readv_cbk_t          readv_cbk;
-        fop_writev_cbk_t         writev_cbk;
-        fop_flush_cbk_t          flush_cbk;
-        fop_fsync_cbk_t          fsync_cbk;
-        fop_opendir_cbk_t        opendir_cbk;
-        fop_readdir_cbk_t        readdir_cbk;
-        fop_readdirp_cbk_t       readdirp_cbk;
-        fop_fsyncdir_cbk_t       fsyncdir_cbk;
-        fop_statfs_cbk_t         statfs_cbk;
-        fop_setxattr_cbk_t       setxattr_cbk;
-        fop_getxattr_cbk_t       getxattr_cbk;
-        fop_fsetxattr_cbk_t      fsetxattr_cbk;
-        fop_fgetxattr_cbk_t      fgetxattr_cbk;
-        fop_removexattr_cbk_t    removexattr_cbk;
-        fop_fremovexattr_cbk_t   fremovexattr_cbk;
-        fop_lk_cbk_t             lk_cbk;
-        fop_inodelk_cbk_t        inodelk_cbk;
-        fop_finodelk_cbk_t       finodelk_cbk;
-        fop_entrylk_cbk_t        entrylk_cbk;
-        fop_fentrylk_cbk_t       fentrylk_cbk;
-        fop_rchecksum_cbk_t      rchecksum_cbk;
-        fop_xattrop_cbk_t        xattrop_cbk;
-        fop_fxattrop_cbk_t       fxattrop_cbk;
-        fop_setattr_cbk_t        setattr_cbk;
-        fop_fsetattr_cbk_t       fsetattr_cbk;
-        fop_getspec_cbk_t        getspec_cbk;
-	fop_fallocate_cbk_t	 fallocate_cbk;
-	fop_discard_cbk_t	 discard_cbk;
-        fop_zerofill_cbk_t       zerofill_cbk;
-        fop_ipc_cbk_t            ipc_cbk;
-        fop_seek_cbk_t           seek_cbk;
-        fop_lease_cbk_t          lease_cbk;
-        fop_compound_cbk_t       compound_cbk;
-        fop_getactivelk_cbk_t   getactivelk_cbk;
-        fop_setactivelk_cbk_t  setactivelk_cbk;
-};
-
-typedef int32_t (*cbk_forget_t) (xlator_t *this,
-                                 inode_t *inode);
-
-typedef int32_t (*cbk_release_t) (xlator_t *this,
-                                  fd_t *fd);
-
-typedef int32_t (*cbk_invalidate_t)(xlator_t *this, inode_t *inode);
-
-typedef int32_t (*cbk_client_t)(xlator_t *this, client_t *client);
-
-typedef void (*cbk_ictxmerge_t) (xlator_t *this, fd_t *fd,
-                                 inode_t *inode, inode_t *linked_inode);
-
-typedef size_t (*cbk_inodectx_size_t)(xlator_t *this, inode_t *inode);
-
-typedef size_t (*cbk_fdctx_size_t)(xlator_t *this, fd_t *fd);
-
-struct xlator_cbks {
-        cbk_forget_t             forget;
-        cbk_release_t            release;
-        cbk_release_t            releasedir;
-	cbk_invalidate_t         invalidate;
-        cbk_client_t             client_destroy;
-        cbk_client_t             client_disconnect;
-        cbk_ictxmerge_t          ictxmerge;
-        cbk_inodectx_size_t      ictxsize;
-        cbk_fdctx_size_t         fdctxsize;
-};
-
-typedef int32_t (*dumpop_priv_t) (xlator_t *this);
-
-typedef int32_t (*dumpop_inode_t) (xlator_t *this);
-
-typedef int32_t (*dumpop_fd_t)  (xlator_t   *this);
-
-typedef int32_t (*dumpop_inodectx_t) (xlator_t *this, inode_t *ino);
-
-typedef int32_t (*dumpop_fdctx_t) (xlator_t *this, fd_t *fd);
-
-typedef int32_t (*dumpop_priv_to_dict_t) (xlator_t *this, dict_t *dict);
-
-typedef int32_t (*dumpop_inode_to_dict_t) (xlator_t *this, dict_t *dict);
-
-typedef int32_t (*dumpop_fd_to_dict_t) (xlator_t *this, dict_t *dict);
-
-typedef int32_t (*dumpop_inodectx_to_dict_t) (xlator_t *this, inode_t *ino,
-                                              dict_t *dict);
-
-typedef int32_t (*dumpop_fdctx_to_dict_t) (xlator_t *this, fd_t *fd,
-                                           dict_t *dict);
-
-typedef int32_t (*dumpop_eh_t) (xlator_t *this);
-
-struct xlator_dumpops {
-        dumpop_priv_t                   priv;
-        dumpop_inode_t                  inode;
-        dumpop_fd_t                     fd;
-        dumpop_inodectx_t               inodectx;
-        dumpop_fdctx_t                  fdctx;
-        dumpop_priv_to_dict_t           priv_to_dict;
-        dumpop_inode_to_dict_t          inode_to_dict;
-        dumpop_fd_to_dict_t             fd_to_dict;
-        dumpop_inodectx_to_dict_t       inodectx_to_dict;
-        dumpop_fdctx_to_dict_t          fdctx_to_dict;
-        dumpop_eh_t                     history;
-};
-
-typedef struct xlator_list {
-        xlator_t           *xlator;
-        struct xlator_list *next;
-} xlator_list_t;
-
-
-struct _xlator {
-        /* Built during parsing */
-        char          *name;
-        char          *type;
-        char          *instance_name;  /* Used for multi NFSd */
-        xlator_t      *next;
-        xlator_t      *prev;
-        xlator_list_t *parents;
-        xlator_list_t *children;
-        dict_t        *options;
-
-        /* Set after doing dlopen() */
-        void                  *dlhandle;
-        struct xlator_fops    *fops;
-        struct xlator_cbks    *cbks;
-        struct xlator_dumpops *dumpops;
-        struct list_head       volume_options;  /* list of volume_option_t */
-
-        void              (*fini) (xlator_t *this);
-        int32_t           (*init) (xlator_t *this);
-        int32_t           (*reconfigure) (xlator_t *this, dict_t *options);
-	int32_t           (*mem_acct_init) (xlator_t *this);
-	event_notify_fn_t notify;
-
-        gf_loglevel_t    loglevel;   /* Log level for translator */
-
-        int64_t             client_latency;
-        /* for latency measurement */
-        fop_latency_t latencies[GF_FOP_MAXVALUE];
-
-        /* Misc */
-        eh_t               *history; /* event history context */
-        glusterfs_ctx_t    *ctx;
-        glusterfs_graph_t  *graph; /* not set for fuse */
-        inode_table_t      *itable;
-        char                init_succeeded;
-        void               *private;
-        struct mem_acct    *mem_acct;
-        uint64_t            winds;
-        char                switched;
-
-        /* for the memory pool of 'frame->local' */
-        struct mem_pool    *local_pool;
-        gf_boolean_t        is_autoloaded;
-
-        /* Saved volfile ID (used for multiplexing) */
-        char               *volfile_id;
-
-        /* Its used as an index to inode_ctx*/
-        uint32_t            xl_id;
-};
-
-typedef struct {
-        int32_t                 (*init) (xlator_t *this);
-        void                    (*fini) (xlator_t *this);
-        int32_t                 (*reconfigure) (xlator_t *this,
-                                                dict_t *options);
-        event_notify_fn_t       notify;
-} class_methods_t;
-
-#define xlator_has_parent(xl) (xl->parents != NULL)
-
-#define XLATOR_NOTIFY(_xl, params ...)          \
-        do {                                    \
-                xlator_t *_old_THIS = NULL;     \
-                                                \
-                _old_THIS = THIS;               \
-                THIS = _xl;                     \
-                                                \
-                ret = _xl->notify (_xl, params);\
-                                                \
-                THIS = _old_THIS;               \
-        } while (0);
-
-int32_t xlator_set_type_virtual (xlator_t *xl, const char *type);
-
-int32_t xlator_set_type (xlator_t *xl, const char *type);
-
-int32_t xlator_dynload (xlator_t *xl);
-
-xlator_t *file_to_xlator_tree (glusterfs_ctx_t *ctx,
-                               FILE *fp);
-
-int xlator_notify (xlator_t *this, int32_t event, void *data, ...);
-int xlator_init (xlator_t *this);
-int xlator_destroy (xlator_t *xl);
-
-int32_t xlator_tree_init (xlator_t *xl);
-int32_t xlator_tree_free_members (xlator_t *xl);
-int32_t xlator_tree_free_memacct (xlator_t *xl);
-
-void xlator_tree_fini (xlator_t *xl);
-
-void xlator_foreach (xlator_t *this,
-                     void (*fn) (xlator_t *each,
-                                 void *data),
-                     void *data);
-
-void xlator_foreach_depth_first (xlator_t *this,
-				 void (*fn) (xlator_t *each,
-					     void *data),
-				 void *data);
-
-xlator_t *xlator_search_by_name (xlator_t *any, const char *name);
-xlator_t *get_xlator_by_name (xlator_t *this, char *target);
-xlator_t *get_xlator_by_type (xlator_t *this, char *target);
-
-void
-xlator_set_inode_lru_limit (xlator_t *this, void *data);
-
-void inode_destroy_notify (inode_t *inode, const char *xlname);
-
-int loc_copy (loc_t *dst, loc_t *src);
-int loc_copy_overload_parent (loc_t *dst,
-                              loc_t *src, inode_t *parent);
-#define loc_dup(src, dst) loc_copy(dst, src)
-void loc_wipe (loc_t *loc);
-int loc_path (loc_t *loc, const char *bname);
-void loc_gfid (loc_t *loc, uuid_t gfid);
-void loc_pargfid (loc_t *loc, uuid_t pargfid);
-char* loc_gfid_utoa (loc_t *loc);
-gf_boolean_t loc_is_root (loc_t *loc);
-int32_t loc_build_child (loc_t *child, loc_t *parent, char *name);
-gf_boolean_t loc_is_nameless (loc_t *loc);
-int xlator_mem_acct_init (xlator_t *xl, int num_types);
-int is_gf_log_command (xlator_t *trans, const char *name, char *value);
-int glusterd_check_log_level (const char *value);
-int xlator_volopt_dynload (char *xlator_type, void **dl_handle,
-                           volume_opt_list_t *vol_opt_handle);
-enum gf_hdsk_event_notify_op {
-        GF_EN_DEFRAG_STATUS,
-        GF_EN_MAX,
-};
-gf_boolean_t
-is_graph_topology_equal (glusterfs_graph_t *graph1, glusterfs_graph_t *graph2);
-int
-glusterfs_volfile_reconfigure (FILE *newvolfile_fp, glusterfs_ctx_t *ctx);
-
-int
-gf_volfile_reconfigure (int oldvollen, FILE *newvolfile_fp,
-                        glusterfs_ctx_t *ctx, const char *oldvolfile);
-
-int
-loc_touchup (loc_t *loc, const char *name);
-
-int
-glusterfs_leaf_position(xlator_t *tgt);
-
-int
-glusterfs_reachable_leaves(xlator_t *base, dict_t *leaves);
-
-int
-xlator_subvolume_count (xlator_t *this);
-
-void xlator_init_lock (void);
-void xlator_init_unlock (void);
-int
-copy_opts_to_child (xlator_t *src, xlator_t *dst, char *glob);
-
-int
-glusterfs_delete_volfile_checksum (glusterfs_ctx_t *ctx,
-                                   const char *volfile_id);
-
-#endif /* _XLATOR_H */
diff --git a/rfc.sh b/rfc.sh
index 1354715bb7d..e7faec9ea0f 100755
--- a/rfc.sh
+++ b/rfc.sh
@@ -4,6 +4,29 @@
 # i.e. where we are interested in the result of a command,
 # we have to run the command in an if-statement.
 
+UPSTREAM=${GLUSTER_UPSTREAM}
+if [ "x$UPSTREAM" -eq "x" ]; then
+    for rmt in $(git remote); do
+	rmt_repo=$(git remote show $rmt -n | grep Fetch | awk '{ print $3 }');
+	if [ $rmt_repo -eq "git@github:gluster/glusterfs" ]; then
+	    UPSTREAM=$rmt
+	    echo "Picked $rmt as upstream remote"
+	    break
+	fi
+    done
+fi
+
+USER_REPO=${GLUSTER_USER_REPO:-origin}
+if [ "x${USER_REPO}" -eq "x${UPSTREAM}" ] ; then
+    echo "When you submit patches, it should get submitted to your fork, not to upstream directly"
+    echo "If you are not sure, check `for rmt in $(git remote); do git remote show $rmt -n; done`"
+    echo "And pick the correct remote you would like to push to and do `export GLUSTER_USER_REPO=$rmt`"
+    echo ""
+    echo "Exiting..."
+    exit 1
+fi
+
+
 
 while getopts "v" opt; do
     case $opt in
@@ -17,7 +40,7 @@ done
 shift $((OPTIND-1))
 
 
-branch="release-3.12";
+branch="devel";
 
 set_hooks_commit_msg()
 {
@@ -49,21 +72,21 @@ is_num()
 backport_id_message()
 {
     echo ""
-    echo "This commit is to a non-master branch, and hence is treated as a backport."
+    echo "This commit is to a non-devel branch, and hence is treated as a backport."
     echo ""
     echo "For backports we would like to retain the same gerrit Change-Id across"
     echo "branches. On auto inspection it is found that a gerrit Change-Id is"
-    echo "missing, or the Change-Id is not found on your local master"
+    echo "missing, or the Change-Id is not found on your local devel branch"
     echo ""
     echo "This could mean a few things:"
     echo "    1. This is not a backport, hence choose Y on the prompt to proceed"
-    echo "    2. Your origin master is not up to date, hence the script is unable"
-    echo "       to find the corresponding Change-Id on master. Either choose N,"
+    echo "    2. Your $USER_REPO/devel is not up to date, hence the script is unable"
+    echo "       to find the corresponding Change-Id on devel. Either choose N,"
     echo "       'git fetch', and try again, OR if you are sure you used the"
     echo "       same Change-Id, choose Y at the prompt to proceed"
     echo "    3. You commented or removed the Change-Id in your commit message after"
     echo "       cherry picking the commit. Choose N, fix the commit message to"
-    echo "       use the same Change-Id as master (git commit --amend), resubmit"
+    echo "       use the same Change-Id as 'devel' (git commit --amend), resubmit"
     echo ""
 }
 
@@ -71,13 +94,13 @@ check_backport()
 {
     moveon='N'
 
-    # Backports are never made to master
-    if [ $branch = "master" ]; then
+    # Backports are never made to 'devel'
+    if [ $branch = "devel" ]; then
         return;
     fi
 
     # Extract the change ID from the commit message
-    changeid=$(git show --format='%b' | grep -i '^Change-Id: ' | awk '{print $2}')
+    changeid=$(git log -n1 --format='%b' | grep -i '^Change-Id: ' | awk '{print $2}')
 
     # If there is no change ID ask if we should continue
     if [ -z "$changeid" ]; then
@@ -85,22 +108,22 @@ check_backport()
         echo -n "Did not find a Change-Id for a possible backport. Continue (y/N): "
         read moveon
     else
-        # Search master for the same change ID (rebase_changes has run, so we
+        # Search 'devel' for the same change ID (rebase_changes has run, so we
         # should never not find a Change-Id)
-        mchangeid=$(git log origin/master --format='%b' --grep="^Change-Id: ${changeid}" | grep ${changeid} | awk '{print $2}')
+        mchangeid=$(git log $UPSTREAM/devel --format='%b' --grep="^Change-Id: ${changeid}" | grep ${changeid} | awk '{print $2}')
 
-        # Check if we found the change ID on master, else throw a message to
+        # Check if we found the change ID on 'devel', else throw a message to
         # decide if we should continue.
-        # NOTE: If master was not rebased, we will not find the Change-ID and
+        # NOTE: If 'devel' was not rebased, we will not find the Change-ID and
         # could hit a false positive case here (or if someone checks out some
-        # other branch as master).
+        # other branch as 'devel').
         if [ "${mchangeid}" = "${changeid}" ]; then
             moveon="Y"
         else
             backport_id_message;
             echo "Change-Id of commit: $changeid"
-            echo "Change-Id on master: $mchangeid"
-            echo -n "Did not find mentioned Change-Id on master for a possible backport. Continue (y/N): "
+            echo "Change-Id on devel: $mchangeid"
+            echo -n "Did not find mentioned Change-Id on 'devel' for a possible backport. Continue (y/N): "
             read moveon
         fi
     fi
@@ -115,10 +138,51 @@ check_backport()
 
 rebase_changes()
 {
-    GIT_EDITOR=$0 git rebase -i origin/$branch;
+    GIT_EDITOR=$0 git rebase -i $UPSTREAM/$branch;
 }
 
 
+# Regex elaborated:
+#   grep options:
+#     -w -> --word-regexp (from the man page)
+#        Select only those lines containing matches that form whole words.
+#        The test is that the matching substring must either be at the
+#        beginning of the line, or preceded by a  non-word  constituent
+#        character.  Similarly, it must be either at the end of the line or
+#        followed by a non-word constituent character.  Word-constituent
+#        characters are letters, digits, and the underscore.
+#
+#        IOW, the above helps us find the pattern with leading or training
+#        spaces or non word consituents like , or ;
+#
+#     -i -> --ignore-case (case insensitive search)
+#
+#     -o -> --only-matching (only print matching portion of the line)
+#
+#     -E -> --extended-regexp (use extended regular expression)
+#
+#   ^
+#      The search begins at the start of each line
+#
+#   [[:space:]]*
+#      Any number of spaces is accepted
+#
+#   (Fixes|Updates)
+#      Finds 'Fixes' OR 'Updates' in any case combination
+#
+#   (:)?
+#      Followed by an optional : (colon)
+#
+#   [[:space:]]+
+#      Followed by 1 or more spaces
+#
+#   #
+#      Followed by #
+#
+#   [[:digit:]]+
+#      Followed by 1 or more digits
+REFRE="^[[:space:]]*(Fixes|Updates)(:)?[[:space:]]+#[[:digit:]]+"
+
 editor_mode()
 {
     if [ $(basename "$1") = "git-rebase-todo" ]; then
@@ -127,22 +191,34 @@ editor_mode()
     fi
 
     if [ $(basename "$1") = "COMMIT_EDITMSG" ]; then
-        if grep -qi '^BUG: ' $1; then
+        # see note above function warn_reference_missing for regex elaboration
+        # Lets first check for github issues
+        ref=$(git log -n1 --format='%b' | grep -iow -E "${REFRE}" | awk -F '#' '{print $2}');
+        if [ "x${ref}" != "x" ]; then
             return;
         fi
+
         while true; do
             echo Commit: "\"$(head -n 1 $1)\""
-            echo -n "Enter Bug ID: "
-            read bug
-            if [ -z "$bug" ]; then
+            echo -n "Github Issue ID: "
+            read issue
+            if [ -z "$issue" ]; then
                 return;
             fi
-            if ! is_num "$bug"; then
-                echo "Invalid Bug ID ($bug)!!!";
+            if ! is_num "$issue"; then
+                echo "Invalid Github Issue ID!!!";
                 continue;
             fi
 
-            sed "/^Change-Id:/{p; s/^.*$/BUG: $bug/;}" $1 > $1.new && \
+            echo "Select yes '(y)' if this patch fixes the issue/feature completely,"
+            echo -n "or is the last of the patchset which brings feature (Y/n): "
+            read fixes
+            fixes_string="Fixes"
+            if [ "${fixes}" = 'N' ] || [ "${fixes}" = 'n' ]; then
+                fixes_string="Updates"
+            fi
+
+            sed "/^Change-Id:/{p; s/^.*$/${fixes_string}: #${issue}/;}" $1 > $1.new && \
                 mv $1.new $1;
             return;
         done
@@ -158,120 +234,38 @@ EOF
 
 assert_diverge()
 {
-    git diff origin/$branch..HEAD | grep -q .;
+    git diff $UPSTREAM/$branch..HEAD | grep -q .;
 }
 
 
-check_patches_for_coding_style()
-{
-    git fetch origin;
-
-    check_patch_script=./build-aux/checkpatch.pl
-    if [ ! -e ${check_patch_script} ] ; then
-        echo "${check_patch_script} is not executable .. abort"
-        exit 1
-    fi
-
-    # The URL of our Gerrit server
-    export GERRIT_URL="review.gluster.org"
-
-    echo "Running coding guidelines check ..."
-    head=$(git rev-parse --abbrev-ref HEAD)
-    # Kludge: "1>&2 && echo $? || echo $?" is to get around
-    #         "-e" from script invocation
-    RES=$(git format-patch --stdout origin/${branch}..${head} \
-          | ${check_patch_script} --strict --terse - 1>&2 && echo $? || echo $?)
-    if [ "$RES" -eq 1 ] ; then
-        echo "Errors caught, get details by:"
-        echo "  git format-patch --stdout  origin/${branch}..${head} \\"
-        echo "  | ${check_patch_script} --strict --gerrit-url ${GERRIT_URL} -"
-        echo "and correct errors"
-        exit 1
-    elif [ "$RES" -eq 2 ] ; then
-        echo "Warnings or checks caught, get details by:"
-        echo "  git format-patch --stdout  origin/${branch}..${head} \\"
-        echo "  | ${check_patch_script} --strict --gerrit-url ${GERRIT_URL} -"
-        echo -n "Do you want to continue anyway [no/yes]: "
-        read yesno
-        if [ "${yesno}" != "yes" ] ; then
-            echo "Aborting..."
-            exit 1
-        fi
-    fi
-}
-
-github_issue_message()
+warn_reference_missing()
 {
     echo ""
-    echo "=== Missing a github issue reference in a potential enhancement! ==="
+    echo "=== Missing a reference in commit! ==="
+    echo ""
+    echo "Gluster commits are made with a reference to a github issue"
     echo ""
-    echo "Gluster code submissions that are enhancements (IOW, not functional"
-    echo "bug fixes, but improvements of any nature to the code) are tracked"
-    echo "using github issues. A check on the commit message, reveals that"
-    echo "there is no bug associated with this change, hence it could be a"
-    echo "potential code improvement or feature enhancement"
+    echo "A check on the commit message, reveals that there is no "
+    echo "github issue referenced in the commit message."
     echo ""
-    echo "If this is an enhancement, request a github issue be filed at [1]"
-    echo "and referenced in the commit message as,"
-    echo "\"Fixes gluster/glusterfs#n\" OR \"Updates gluster/glusterfs#n\","
-    echo "where n is the issue number"
+    echo "https://github.com/gluster/glusterfs/issues/new"
     echo ""
-    echo "You can reference multiple issues that this commit addresses as,"
-    echo "\"fixes gluster/glusterfs#n, updates gluster/glusterfs#m\", and so on"
+    echo "Please open an issue and reference the same in the commit message "
+    echo "using the following tags:"
     echo ""
-    echo "[1] https://github.com/gluster/glusterfs/issues/new"
+    echo "\"Fixes: #NNNN\" OR \"Updates: #NNNN\","
+    echo "where NNNN is the issue id"
     echo ""
     echo "You may abort the submission choosing 'N' below and use"
     echo "'git commit --amend' to add the issue reference before posting"
-    echo "to gerrit. If this is a bug fix, choose 'Y' to continue."
+    echo "to gerrit."
     echo ""
-}
-
-check_for_github_issue()
-{
-    # NOTE: Since we run '#!/bin/sh -e', the check is in an if,
-    # as grep count maybe 0
-    #
-    # Regex elaborated:
-    #   grep -w -> --word-regexp (from the man page)
-    #      Select only those lines containing matches that form whole words.
-    #      The test is that the matching substring must either be at the
-    #      beginning of the line, or preceded by a  non-word  constituent
-    #      character.  Similarly, it must be either at the end of the line or
-    #      followed by a non-word constituent character.  Word-constituent
-    #      characters are letters, digits, and the underscore.
-    #   IOW, the above helps us find the pattern with leading or training spaces
-    #   or non word consituents like , or ;
-    #
-    #   grep -c -> gives us a count of matches, which is all we need here
-    #
-    #   [fF][iI][xX][eE][sS]|[uU][pP][dD][aA][tT][eE][sS])
-    #      Finds 'fixes' OR 'updates' in any case combination
-    #
-    #   (:)?
-    #      Followed by an optional : (colon)
-    #
-    #   [[:space:]]+
-    #      followed by 1 or more spaces
-    #
-    #   (gluster\/glusterfs)?
-    #      Followed by 0 or more gluster/glusterfs
-    #
-    #   #
-    #      Followed by #
-    #
-    #   [[:digit:]]+
-    #      Followed by 1 or more digits
-    if [ 0 = "$(git log --format=%B -n 1 | grep -cow -E "([fF][iI][xX][eE][sS]|[uU][pP][dD][aA][tT][eE][sS])(:)?[[:space:]]+(gluster\/glusterfs)?#[[:digit:]]+")" ]; then
-        moveon='N'
-        github_issue_message;
-        echo -n "Missing github issue reference in a potential RFE. Continue (y/N): "
-        read moveon
-        if [ "${moveon}" = 'Y' ] || [ "${moveon}" = 'y' ]; then
-            return;
-        else
-            exit 1
-        fi
+    echo -n "Missing reference to a github issue. Continue (y/N): "
+    read moveon
+    if [ "${moveon}" = 'Y' ] || [ "${moveon}" = 'y' ]; then
+        return;
+    else
+        exit 1
     fi
 }
 
@@ -286,7 +280,7 @@ main()
         return;
     fi
 
-    check_patches_for_coding_style;
+    git fetch $UPSTREAM;
 
     rebase_changes;
 
@@ -294,15 +288,31 @@ main()
 
     assert_diverge;
 
-    bug=$(git show --format='%b' | grep -i '^BUG: ' | awk '{print $2}');
+    # see note above variable REFRE for regex elaboration
+    reference=$(git log -n1 --format='%b' | grep -iow -E "${REFRE}" | awk -F '#' '{print $2}');
 
-    # If this is a commit against master and does not have a bug ID
-    # it could be a feature or an RFE, check if there is a github
-    # issue reference, and if not suggest commit message amendment
-    if [ -z "$bug" ] && [ $branch = "master" ]; then
-        check_for_github_issue;
+    # If this is a commit against 'devel' and does not have a github
+    # issue reference. Warn the contributor that one of the 2 is required
+    if [ -z "${reference}" ] && [ $branch = "devel" ]; then
+        warn_reference_missing;
     fi
 
+    # TODO: add clang-format command here. It will after the changes are done everywhere else
+    clang_format=$(clang-format --version)
+    if [ ! -z "${clang_format}" ]; then
+        # Considering git show may not give any files as output matching the
+        # criteria, good to tell script not to fail on error
+        set +e
+        list_of_files=$(git show --pretty="format:" --name-only |
+                            grep -v "contrib/" | egrep --color=never "*\.[ch]$");
+        if [ ! -z "${list_of_files}" ]; then
+            echo "${list_of_files}" | xargs clang-format -i
+        fi
+        set -e
+    else
+        echo "High probability of your patch not passing smoke due to coding standard check"
+        echo "Please install 'clang-format' to format the patch before submitting"
+    fi
 
     if [ "$DRY_RUN" = 1 ]; then
         drier='echo -e Please use the following command to send your commits to review:\n\n'
@@ -310,10 +320,10 @@ main()
         drier=
     fi
 
-    if [ -z "$bug" ]; then
-        $drier git push origin HEAD:refs/for/$branch/rfc;
+    if [ -z "${reference}" ]; then
+        $drier git push $USER_REPO HEAD:temp_${branch}/$(date +%Y-%m-%d_%s);
     else
-        $drier git push origin HEAD:refs/for/$branch/bug-$bug;
+        $drier git push $USER_REPO HEAD:issue${reference}_${branch};
     fi
 }
 
diff --git a/rpc/rpc-lib/src/Makefile.am b/rpc/rpc-lib/src/Makefile.am
index c07d001b057..35c9db07e7f 100644
--- a/rpc/rpc-lib/src/Makefile.am
+++ b/rpc/rpc-lib/src/Makefile.am
@@ -2,11 +2,15 @@ lib_LTLIBRARIES = libgfrpc.la
 
 libgfrpc_la_SOURCES = auth-unix.c rpcsvc-auth.c rpcsvc.c auth-null.c \
 	rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c \
-	rpc-drc.c $(CONTRIBDIR)/sunrpc/xdr_sizeof.c  rpc-clnt-ping.c
+	rpc-drc.c rpc-clnt-ping.c \
+        autoscale-threads.c mgmt-pmap.c
+
+EXTRA_DIST = libgfrpc.sym
 
 libgfrpc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
                      $(top_builddir)/rpc/xdr/src/libgfxdr.la
-libgfrpc_la_LDFLAGS = -version-info $(LIBGFRPC_LT_VERSION) $(GF_LDFLAGS)
+libgfrpc_la_LDFLAGS = -version-info $(LIBGFRPC_LT_VERSION) $(GF_LDFLAGS) \
+		      -export-symbols $(top_srcdir)/rpc/rpc-lib/src/libgfrpc.sym
 
 libgfrpc_la_HEADERS = rpcsvc.h rpc-transport.h xdr-common.h xdr-rpc.h xdr-rpcclnt.h \
 	rpc-clnt.h rpcsvc-common.h protocol-common.h rpc-drc.h rpc-clnt-ping.h \
diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c
index 5670b8e840b..69a96f7512f 100644
--- a/rpc/rpc-lib/src/auth-glusterfs.c
+++ b/rpc/rpc-lib/src/auth-glusterfs.c
@@ -8,258 +8,379 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include "rpcsvc.h"
-#include "list.h"
-#include "dict.h"
+#include <glusterfs/dict.h>
 #include "xdr-rpc.h"
 #include "xdr-common.h"
 #include "rpc-common-xdr.h"
+#include "glusterfs4-xdr.h"
 
 /* V1 */
 
 ssize_t
-xdr_to_glusterfs_auth (char *buf, struct auth_glusterfs_parms *req)
+xdr_to_glusterfs_auth(char *buf, struct auth_glusterfs_parms *req)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
-
-        if ((!buf) || (!req))
-                return -1;
-
-        xdrmem_create (&xdr, buf, sizeof (struct auth_glusterfs_parms),
-                       XDR_DECODE);
-        if (!xdr_auth_glusterfs_parms (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs parameters");
-                ret  = -1;
-                goto ret;
-        }
-
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
-ret:
-        return ret;
+    XDR xdr;
+    ssize_t ret = -1;
+
+    if ((!buf) || (!req))
+        return -1;
+
+    xdrmem_create(&xdr, buf, sizeof(struct auth_glusterfs_parms), XDR_DECODE);
+    if (!xdr_auth_glusterfs_parms(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs parameters");
+        ret = -1;
+        goto ret;
+    }
 
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+ret:
+    return ret;
 }
 int
-auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_glusterfs_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        struct auth_glusterfs_parms  au = {0,};
-
-        int ret      = RPCSVC_AUTH_REJECT;
-        int j        = 0;
-        int i        = 0;
-        int gidcount = 0;
-
-        if (!req)
-                return ret;
-
-        ret = xdr_to_glusterfs_auth (req->cred.authdata, &au);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        req->pid = au.pid;
-        req->uid = au.uid;
-        req->gid = au.gid;
-        req->lk_owner.len = 8;
-        {
-                for (i = 0; i < req->lk_owner.len; i++, j += 8)
-                        req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff);
-        }
-        req->auxgidcount = au.ngrps;
-
-        if (req->auxgidcount > 16) {
-                gf_log ("", GF_LOG_WARNING,
-                        "more than 16 aux gids found, failing authentication");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-	if (req->auxgidcount > SMALL_GROUP_COUNT) {
-		req->auxgidlarge = GF_CALLOC(req->auxgidcount,
-					     sizeof(req->auxgids[0]),
-					     gf_common_mt_auxgids);
-		req->auxgids = req->auxgidlarge;
-	} else {
-		req->auxgids = req->auxgidsmall;
-	}
-
-	if (!req->auxgids) {
-		gf_log ("auth-glusterfs", GF_LOG_WARNING,
-			"cannot allocate gid list");
-		ret = RPCSVC_AUTH_REJECT;
-		goto err;
-	}
-
-        for (gidcount = 0; gidcount < au.ngrps; ++gidcount)
-                req->auxgids[gidcount] = au.groups[gidcount];
-
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s",
-                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
-        ret = RPCSVC_AUTH_ACCEPT;
-err:
+    struct auth_glusterfs_parms au = {
+        0,
+    };
+
+    int ret = RPCSVC_AUTH_REJECT;
+    int j = 0;
+    int i = 0;
+    int gidcount = 0;
+
+    if (!req)
         return ret;
+
+    ret = xdr_to_glusterfs_auth(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = 8;
+    {
+        for (i = 0; i < req->lk_owner.len; i++, j += 8)
+            req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff);
+    }
+    req->auxgidcount = au.ngrps;
+
+    if (req->auxgidcount > 16) {
+        gf_log("", GF_LOG_WARNING,
+               "more than 16 aux gids found, failing authentication");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (gidcount = 0; gidcount < au.ngrps; ++gidcount)
+        req->auxgids[gidcount] = au.groups[gidcount];
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner));
+    ret = RPCSVC_AUTH_ACCEPT;
+err:
+    return ret;
 }
 
 rpcsvc_auth_ops_t auth_glusterfs_ops = {
-        .transport_init         = NULL,
-        .request_init           = auth_glusterfs_request_init,
-        .authenticate           = auth_glusterfs_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_glusterfs = {
-        .authname       = "AUTH_GLUSTERFS",
-        .authnum        = AUTH_GLUSTERFS,
-        .authops        = &auth_glusterfs_ops,
-        .authprivate    = NULL
-};
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_request_init,
+    .authenticate = auth_glusterfs_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_glusterfs = {.authname = "AUTH_GLUSTERFS",
+                                       .authnum = AUTH_GLUSTERFS,
+                                       .authops = &auth_glusterfs_ops,
+                                       .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs;
+    return &rpcsvc_auth_glusterfs;
 }
 
 /* V2 */
 
 ssize_t
-xdr_to_glusterfs_auth_v2 (char *buf, struct auth_glusterfs_parms_v2 *req)
+xdr_to_glusterfs_auth_v2(char *buf, struct auth_glusterfs_parms_v2 *req)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!buf) || (!req))
-                return -1;
+    if ((!buf) || (!req))
+        return -1;
 
-        xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
-        if (!xdr_auth_glusterfs_parms_v2 (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs v2 parameters");
-                ret  = -1;
-                goto ret;
-        }
+    xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
+    if (!xdr_auth_glusterfs_parms_v2(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v2 parameters");
+        ret = -1;
+        goto ret;
+    }
 
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 ret:
-        return ret;
-
+    return ret;
 }
 int
-auth_glusterfs_v2_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_v2_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_v2_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_glusterfs_v2_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        struct auth_glusterfs_parms_v2  au = {0,};
-        int ret                            = RPCSVC_AUTH_REJECT;
-        int i                              = 0;
-        int max_groups                     = 0;
-        int max_lk_owner_len               = 0;
-
-        if (!req)
-                return ret;
-
-        ret = xdr_to_glusterfs_auth_v2 (req->cred.authdata, &au);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        req->pid = au.pid;
-        req->uid = au.uid;
-        req->gid = au.gid;
-        req->lk_owner.len = au.lk_owner.lk_owner_len;
-        req->auxgidcount = au.groups.groups_len;
-
-        /* the number of groups and size of lk_owner depend on each other */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (req->lk_owner.len);
-        max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (req->auxgidcount);
-
-        if (req->auxgidcount > max_groups) {
-                gf_log ("", GF_LOG_WARNING,
-                        "more than max aux gids found (%d) , truncating it "
-                        "to %d and continuing", au.groups.groups_len,
-                        max_groups);
-                req->auxgidcount = max_groups;
-        }
-
-        if (req->lk_owner.len > max_lk_owner_len) {
-                gf_log ("", GF_LOG_WARNING,
-                        "lkowner field to big (%d), depends on the number of "
-                        "groups (%d), failing authentication",
-                        req->lk_owner.len, req->auxgidcount);
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-	if (req->auxgidcount > SMALL_GROUP_COUNT) {
-		req->auxgidlarge = GF_CALLOC(req->auxgidcount,
-					     sizeof(req->auxgids[0]),
-					     gf_common_mt_auxgids);
-		req->auxgids = req->auxgidlarge;
-	} else {
-		req->auxgids = req->auxgidsmall;
-	}
-
-	if (!req->auxgids) {
-		gf_log ("auth-glusterfs-v2", GF_LOG_WARNING,
-			"cannot allocate gid list");
-		ret = RPCSVC_AUTH_REJECT;
-		goto err;
-	}
-
-        for (i = 0; i < req->auxgidcount; ++i)
-                req->auxgids[i] = au.groups.groups_val[i];
-
-        for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
-                req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
-
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s",
-                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
-        ret = RPCSVC_AUTH_ACCEPT;
+    struct auth_glusterfs_parms_v2 au = {
+        0,
+    };
+    int ret = RPCSVC_AUTH_REJECT;
+    int i = 0;
+    int max_groups = 0;
+    int max_lk_owner_len = 0;
+
+    if (!req)
+        return ret;
+
+    ret = xdr_to_glusterfs_auth_v2(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = au.lk_owner.lk_owner_len;
+    req->auxgidcount = au.groups.groups_len;
+
+    /* the number of groups and size of lk_owner depend on each other */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len,
+                                              AUTH_GLUSTERFS_v2);
+    max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount,
+                                                     AUTH_GLUSTERFS_v2);
+
+    if (req->auxgidcount > max_groups) {
+        gf_log("", GF_LOG_WARNING,
+               "more than max aux gids found (%d) , truncating it "
+               "to %d and continuing",
+               au.groups.groups_len, max_groups);
+        req->auxgidcount = max_groups;
+    }
+
+    if (req->lk_owner.len > max_lk_owner_len) {
+        gf_log("", GF_LOG_WARNING,
+               "lkowner field to big (%d), depends on the number of "
+               "groups (%d), failing authentication",
+               req->lk_owner.len, req->auxgidcount);
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (i = 0; i < req->auxgidcount; ++i)
+        req->auxgids[i] = au.groups.groups_val[i];
+
+    for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
+        req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner));
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        /* TODO: instead use alloca() for these variables */
-        free (au.groups.groups_val);
-        free (au.lk_owner.lk_owner_val);
+    /* TODO: instead use alloca() for these variables */
+    free(au.groups.groups_val);
+    free(au.lk_owner.lk_owner_val);
 
-        return ret;
+    return ret;
 }
 
 rpcsvc_auth_ops_t auth_glusterfs_ops_v2 = {
-        .transport_init         = NULL,
-        .request_init           = auth_glusterfs_v2_request_init,
-        .authenticate           = auth_glusterfs_v2_authenticate
-};
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_v2_request_init,
+    .authenticate = auth_glusterfs_v2_authenticate};
+
+rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {.authname = "AUTH_GLUSTERFS-v2",
+                                          .authnum = AUTH_GLUSTERFS_v2,
+                                          .authops = &auth_glusterfs_ops_v2,
+                                          .authprivate = NULL};
+
+rpcsvc_auth_t *
+rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options)
+{
+    return &rpcsvc_auth_glusterfs_v2;
+}
+
+/* V3 */
+
+ssize_t
+xdr_to_glusterfs_auth_v3(char *buf, struct auth_glusterfs_params_v3 *req)
+{
+    XDR xdr;
+    ssize_t ret = -1;
+
+    if ((!buf) || (!req))
+        return -1;
+
+    xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
+    if (!xdr_auth_glusterfs_params_v3(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v3 parameters");
+        ret = -1;
+        goto ret;
+    }
+
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+ret:
+    return ret;
+}
+
+int
+auth_glusterfs_v3_request_init(rpcsvc_request_t *req, void *priv)
+{
+    return 0;
+}
+
+int
+auth_glusterfs_v3_authenticate(rpcsvc_request_t *req, void *priv)
+{
+    struct auth_glusterfs_params_v3 au = {
+        0,
+    };
+    int ret = RPCSVC_AUTH_REJECT;
+    int i = 0;
+    int max_groups = 0;
+    int max_lk_owner_len = 0;
+
+    if (!req)
+        return ret;
+
+    ret = xdr_to_glusterfs_auth_v3(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = au.lk_owner.lk_owner_len;
+    req->auxgidcount = au.groups.groups_len;
+
+    /* the number of groups and size of lk_owner depend on each other */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len,
+                                              AUTH_GLUSTERFS_v3);
+    max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount,
+                                                     AUTH_GLUSTERFS_v3);
+
+    if (req->auxgidcount > max_groups) {
+        gf_log("", GF_LOG_WARNING,
+               "more than max aux gids found (%d) , truncating it "
+               "to %d and continuing",
+               au.groups.groups_len, max_groups);
+        req->auxgidcount = max_groups;
+    }
+
+    if (req->lk_owner.len > max_lk_owner_len) {
+        gf_log("", GF_LOG_WARNING,
+               "lkowner field to big (%d), depends on the number of "
+               "groups (%d), failing authentication",
+               req->lk_owner.len, req->auxgidcount);
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (i = 0; i < req->auxgidcount; ++i)
+        req->auxgids[i] = au.groups.groups_val[i];
+
+    for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
+        req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
+
+    /* All new things, starting glusterfs-4.0.0 */
+    req->flags = au.flags;
+    req->ctime.tv_sec = au.ctime_sec;
+    req->ctime.tv_nsec = au.ctime_nsec;
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s, flags: %d",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner),
+           req->flags);
+    ret = RPCSVC_AUTH_ACCEPT;
+err:
+    /* TODO: instead use alloca() for these variables */
+    free(au.groups.groups_val);
+    free(au.lk_owner.lk_owner_val);
+
+    return ret;
+}
 
-rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {
-        .authname       = "AUTH_GLUSTERFS-v2",
-        .authnum        = AUTH_GLUSTERFS_v2,
-        .authops        = &auth_glusterfs_ops_v2,
-        .authprivate    = NULL
-};
+rpcsvc_auth_ops_t auth_glusterfs_ops_v3 = {
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_v3_request_init,
+    .authenticate = auth_glusterfs_v3_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_glusterfs_v3 = {.authname = "AUTH_GLUSTERFS-v3",
+                                          .authnum = AUTH_GLUSTERFS_v3,
+                                          .authops = &auth_glusterfs_ops_v3,
+                                          .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs_v2;
+    return &rpcsvc_auth_glusterfs_v3;
 }
diff --git a/rpc/rpc-lib/src/auth-null.c b/rpc/rpc-lib/src/auth-null.c
index 774fdc8da3a..6d059b9da50 100644
--- a/rpc/rpc-lib/src/auth-null.c
+++ b/rpc/rpc-lib/src/auth-null.c
@@ -8,40 +8,33 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "rpcsvc.h"
-#include "list.h"
-#include "dict.h"
-
+#include <glusterfs/dict.h>
 
 int
-auth_null_request_init (rpcsvc_request_t *req, void *priv)
+auth_null_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_null_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_null_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        /* Always succeed. */
-        return RPCSVC_AUTH_ACCEPT;
+    /* Always succeed. */
+    return RPCSVC_AUTH_ACCEPT;
 }
 
-rpcsvc_auth_ops_t auth_null_ops = {
-        .transport_init              = NULL,
-        .request_init           = auth_null_request_init,
-        .authenticate           = auth_null_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_null = {
-        .authname       = "AUTH_NULL",
-        .authnum        = AUTH_NULL,
-        .authops        = &auth_null_ops,
-        .authprivate    = NULL
-};
+rpcsvc_auth_ops_t auth_null_ops = {.transport_init = NULL,
+                                   .request_init = auth_null_request_init,
+                                   .authenticate = auth_null_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_null = {.authname = "AUTH_NULL",
+                                  .authnum = AUTH_NULL,
+                                  .authops = &auth_null_ops,
+                                  .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_null;
+    return &rpcsvc_auth_null;
 }
diff --git a/rpc/rpc-lib/src/auth-unix.c b/rpc/rpc-lib/src/auth-unix.c
index 74ebfe0d1ff..61d475a5e84 100644
--- a/rpc/rpc-lib/src/auth-unix.c
+++ b/rpc/rpc-lib/src/auth-unix.c
@@ -8,65 +8,59 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include "rpcsvc.h"
-#include "list.h"
-#include "dict.h"
+#include <glusterfs/dict.h>
 #include "xdr-rpc.h"
 
-
 int
-auth_unix_request_init (rpcsvc_request_t *req, void *priv)
+auth_unix_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_unix_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_unix_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        struct authunix_parms   aup;
-        char                    machname[MAX_MACHINE_NAME];
+    int ret = RPCSVC_AUTH_REJECT;
+    struct authunix_parms aup;
+    char machname[MAX_MACHINE_NAME];
 
-        if (!req)
-                return ret;
+    if (!req)
+        return ret;
 
-	req->auxgids = req->auxgidsmall;
-        ret = xdr_to_auth_unix_cred (req->cred.authdata, req->cred.datalen,
-                                     &aup, machname, req->auxgids);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING, "failed to decode unix credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
+    req->auxgids = req->auxgidsmall;
+    ret = xdr_to_auth_unix_cred(req->cred.authdata, req->cred.datalen, &aup,
+                                machname, req->auxgids);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode unix credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
 
-        req->uid = aup.aup_uid;
-        req->gid = aup.aup_gid;
-        req->auxgidcount = aup.aup_len;
+    req->uid = aup.aup_uid;
+    req->gid = aup.aup_gid;
+    req->auxgidcount = aup.aup_len;
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: machine name: %s, uid: %d"
-                ", gid: %d", machname, req->uid, req->gid);
-        ret = RPCSVC_AUTH_ACCEPT;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: machine name: %s, uid: %d"
+           ", gid: %d",
+           machname, req->uid, req->gid);
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        return ret;
+    return ret;
 }
 
-rpcsvc_auth_ops_t auth_unix_ops = {
-        .transport_init              = NULL,
-        .request_init           = auth_unix_request_init,
-        .authenticate           = auth_unix_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_unix = {
-        .authname       = "AUTH_UNIX",
-        .authnum        = AUTH_UNIX,
-        .authops        = &auth_unix_ops,
-        .authprivate    = NULL
-};
+rpcsvc_auth_ops_t auth_unix_ops = {.transport_init = NULL,
+                                   .request_init = auth_unix_request_init,
+                                   .authenticate = auth_unix_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_unix = {.authname = "AUTH_UNIX",
+                                  .authnum = AUTH_UNIX,
+                                  .authops = &auth_unix_ops,
+                                  .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_unix;
+    return &rpcsvc_auth_unix;
 }
diff --git a/rpc/rpc-lib/src/autoscale-threads.c b/rpc/rpc-lib/src/autoscale-threads.c
new file mode 100644
index 00000000000..a954ae7a27a
--- /dev/null
+++ b/rpc/rpc-lib/src/autoscale-threads.c
@@ -0,0 +1,22 @@
+/*
+   Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#include <glusterfs/gf-event.h>
+#include "rpcsvc.h"
+
+void
+rpcsvc_autoscale_threads(glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr)
+{
+    struct event_pool *pool = ctx->event_pool;
+    int thread_count = pool->eventthreadcount;
+
+    pool->auto_thread_count += incr;
+    (void)gf_event_reconfigure_threads(pool, thread_count + incr);
+}
diff --git a/rpc/rpc-lib/src/libgfrpc.sym b/rpc/rpc-lib/src/libgfrpc.sym
new file mode 100644
index 00000000000..e026d80259b
--- /dev/null
+++ b/rpc/rpc-lib/src/libgfrpc.sym
@@ -0,0 +1,68 @@
+is_rpc_clnt_disconnected
+rpcclnt_cbk_program_register
+rpc_clnt_cleanup_and_start
+rpc_clnt_connection_cleanup
+rpc_clnt_disable
+rpc_clnt_new
+rpc_clnt_reconfig
+rpc_clnt_reconnect
+rpc_clnt_reconnect_cleanup
+rpc_clnt_ref
+rpc_clnt_register_notify
+rpc_clnt_start
+rpc_clnt_submit
+rpc_clnt_unref
+rpc_reply_to_xdr
+rpcsvc_auth_array
+rpcsvc_auth_check
+rpcsvc_auth_reconf
+rpcsvc_auth_unix_auxgids
+rpcsvc_callback_submit
+rpcsvc_create_listener
+rpcsvc_create_listeners
+rpcsvc_drc_init
+rpcsvc_drc_priv
+rpcsvc_drc_reconfigure
+rpcsvc_get_program_vector_sizer
+rpcsvc_init
+rpcsvc_destroy
+rpcsvc_init_options
+rpcsvc_listener_destroy
+rpcsvc_program_register
+rpcsvc_program_register_portmap
+rpcsvc_program_register_rpcbind6
+rpcsvc_program_unregister
+rpcsvc_program_unregister_portmap
+rpcsvc_program_unregister_rpcbind6
+rpcsvc_reconfigure_options
+rpcsvc_register_notify
+rpcsvc_register_portmap_enabled
+rpcsvc_request_submit
+rpcsvc_set_outstanding_rpc_limit
+rpcsvc_set_throttle_on
+rpcsvc_submit_generic
+rpcsvc_submit_message
+rpcsvc_transport_peeraddr
+rpcsvc_transport_peername
+rpcsvc_transport_privport_check
+rpcsvc_transport_unix_options_build
+rpcsvc_transport_volume_allowed
+rpcsvc_transport_connect
+rpcsvc_transport_getpeeraddr
+rpcsvc_unregister_notify
+rpcsvc_volume_allowed
+rpc_transport_count
+rpc_transport_connect
+rpc_transport_disconnect
+rpc_transport_get_peeraddr
+rpc_transport_inet_options_build
+rpc_transport_keepalive_options_set
+rpc_transport_notify
+rpc_transport_pollin_alloc
+rpc_transport_pollin_destroy
+rpc_transport_ref
+rpc_transport_unix_options_build
+rpc_transport_unref
+rpc_clnt_mgmt_pmap_signout
+rpcsvc_autoscale_threads
+rpcsvc_statedump
diff --git a/rpc/rpc-lib/src/mgmt-pmap.c b/rpc/rpc-lib/src/mgmt-pmap.c
new file mode 100644
index 00000000000..25a7148e5a3
--- /dev/null
+++ b/rpc/rpc-lib/src/mgmt-pmap.c
@@ -0,0 +1,147 @@
+/*
+   Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#include "portmap-xdr.h"
+#include "protocol-common.h"
+#include "rpc-clnt.h"
+#include "xdr-generic.h"
+
+/* Defining a minimal RPC client program for portmap signout
+ */
+char *clnt_pmap_signout_procs[GF_PMAP_MAXVALUE] = {
+    [GF_PMAP_SIGNOUT] = "SIGNOUT",
+};
+
+rpc_clnt_prog_t clnt_pmap_signout_prog = {
+    .progname = "Gluster Portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
+    .procnames = clnt_pmap_signout_procs,
+};
+
+static int
+mgmt_pmap_signout_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    pmap_signout_rsp rsp = {
+        0,
+    };
+    int ret = 0;
+    call_frame_t *frame = NULL;
+
+    frame = myframe;
+    if (-1 == req->rpc_status) {
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "XDR decoding failed");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        goto out;
+    }
+out:
+    if (frame) {
+        STACK_DESTROY(frame->root);
+    }
+
+    return 0;
+}
+
+int
+rpc_clnt_mgmt_pmap_signout(glusterfs_ctx_t *ctx, char *brickname)
+{
+    int ret = 0;
+    pmap_signout_req req = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    cmd_args_t *cmd_args = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    frame = create_frame(THIS, ctx->pool);
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) {
+        gf_log("fsd-mgmt", GF_LOG_DEBUG,
+               "portmapper signout arguments not given");
+        goto out;
+    }
+
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "rdma")) {
+        snprintf(brick_name, sizeof(brick_name), "%s.rdma",
+                 cmd_args->brick_name);
+        req.brick = brick_name;
+    } else {
+        if (brickname)
+            req.brick = brickname;
+        else
+            req.brick = cmd_args->brick_name;
+    }
+
+    req.port = cmd_args->brick_port;
+    req.rdma_port = cmd_args->brick_port2;
+
+    /* mgmt_submit_request is not available in libglusterfs.
+     * Need to serialize and submit manually.
+     */
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_pmap_signout_req, &req);
+    iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+    if (!iobuf) {
+        goto out;
+    };
+
+    iobref_add(iobref, iobuf);
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    /* Create the xdr payload */
+    ret = xdr_serialize_generic(iov, &req, (xdrproc_t)xdr_pmap_signout_req);
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+        goto out;
+    }
+    iov.iov_len = ret;
+
+    ret = rpc_clnt_submit(ctx->mgmt, &clnt_pmap_signout_prog, GF_PMAP_SIGNOUT,
+                          mgmt_pmap_signout_cbk, &iov, 1, NULL, 0, iobref,
+                          frame, NULL, 0, NULL, 0, NULL);
+out:
+    if (iobref)
+        iobref_unref(iobref);
+
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
+}
diff --git a/rpc/rpc-lib/src/protocol-common.h b/rpc/rpc-lib/src/protocol-common.h
index 510817c05f9..0cb5862e9a9 100644
--- a/rpc/rpc-lib/src/protocol-common.h
+++ b/rpc/rpc-lib/src/protocol-common.h
@@ -12,349 +12,371 @@
 #define _PROTOCOL_COMMON_H
 
 enum gf_fop_procnum {
-        GFS3_OP_NULL,    /* 0 */
-        GFS3_OP_STAT,
-        GFS3_OP_READLINK,
-        GFS3_OP_MKNOD,
-        GFS3_OP_MKDIR,
-        GFS3_OP_UNLINK,
-        GFS3_OP_RMDIR,
-        GFS3_OP_SYMLINK,
-        GFS3_OP_RENAME,
-        GFS3_OP_LINK,
-        GFS3_OP_TRUNCATE,
-        GFS3_OP_OPEN,
-        GFS3_OP_READ,
-        GFS3_OP_WRITE,
-        GFS3_OP_STATFS,
-        GFS3_OP_FLUSH,
-        GFS3_OP_FSYNC,
-        GFS3_OP_SETXATTR,
-        GFS3_OP_GETXATTR,
-        GFS3_OP_REMOVEXATTR,
-        GFS3_OP_OPENDIR,
-        GFS3_OP_FSYNCDIR,
-        GFS3_OP_ACCESS,
-        GFS3_OP_CREATE,
-        GFS3_OP_FTRUNCATE,
-        GFS3_OP_FSTAT,
-        GFS3_OP_LK,
-        GFS3_OP_LOOKUP,
-        GFS3_OP_READDIR,
-        GFS3_OP_INODELK,
-        GFS3_OP_FINODELK,
-	GFS3_OP_ENTRYLK,
-	GFS3_OP_FENTRYLK,
-        GFS3_OP_XATTROP,
-        GFS3_OP_FXATTROP,
-        GFS3_OP_FGETXATTR,
-        GFS3_OP_FSETXATTR,
-        GFS3_OP_RCHECKSUM,
-        GFS3_OP_SETATTR,
-        GFS3_OP_FSETATTR,
-        GFS3_OP_READDIRP,
-        GFS3_OP_RELEASE,
-        GFS3_OP_RELEASEDIR,
-        GFS3_OP_FREMOVEXATTR,
-	GFS3_OP_FALLOCATE,
-	GFS3_OP_DISCARD,
-        GFS3_OP_ZEROFILL,
-        GFS3_OP_IPC,
-        GFS3_OP_SEEK,
-        GFS3_OP_COMPOUND,
-        GFS3_OP_LEASE,
-        GFS3_OP_GETACTIVELK,
-        GFS3_OP_SETACTIVELK,
-        GFS3_OP_MAXVALUE,
+    GFS3_OP_NULL, /* 0 */
+    GFS3_OP_STAT,
+    GFS3_OP_READLINK,
+    GFS3_OP_MKNOD,
+    GFS3_OP_MKDIR,
+    GFS3_OP_UNLINK,
+    GFS3_OP_RMDIR,
+    GFS3_OP_SYMLINK,
+    GFS3_OP_RENAME,
+    GFS3_OP_LINK,
+    GFS3_OP_TRUNCATE,
+    GFS3_OP_OPEN,
+    GFS3_OP_READ,
+    GFS3_OP_WRITE,
+    GFS3_OP_STATFS,
+    GFS3_OP_FLUSH,
+    GFS3_OP_FSYNC,
+    GFS3_OP_SETXATTR,
+    GFS3_OP_GETXATTR,
+    GFS3_OP_REMOVEXATTR,
+    GFS3_OP_OPENDIR,
+    GFS3_OP_FSYNCDIR,
+    GFS3_OP_ACCESS,
+    GFS3_OP_CREATE,
+    GFS3_OP_FTRUNCATE,
+    GFS3_OP_FSTAT,
+    GFS3_OP_LK,
+    GFS3_OP_LOOKUP,
+    GFS3_OP_READDIR,
+    GFS3_OP_INODELK,
+    GFS3_OP_FINODELK,
+    GFS3_OP_ENTRYLK,
+    GFS3_OP_FENTRYLK,
+    GFS3_OP_XATTROP,
+    GFS3_OP_FXATTROP,
+    GFS3_OP_FGETXATTR,
+    GFS3_OP_FSETXATTR,
+    GFS3_OP_RCHECKSUM,
+    GFS3_OP_SETATTR,
+    GFS3_OP_FSETATTR,
+    GFS3_OP_READDIRP,
+    GFS3_OP_RELEASE,
+    GFS3_OP_RELEASEDIR,
+    GFS3_OP_FREMOVEXATTR,
+    GFS3_OP_FALLOCATE,
+    GFS3_OP_DISCARD,
+    GFS3_OP_ZEROFILL,
+    GFS3_OP_IPC,
+    GFS3_OP_SEEK,
+    GFS3_OP_COMPOUND,
+    GFS3_OP_LEASE,
+    GFS3_OP_GETACTIVELK,
+    GFS3_OP_SETACTIVELK,
+    GFS3_OP_ICREATE,
+    GFS3_OP_NAMELINK,
+    GFS3_OP_PUT,
+    GFS3_OP_COPY_FILE_RANGE,
+    GFS3_OP_MAXVALUE,
 };
 
 enum gf_handshake_procnum {
-        GF_HNDSK_NULL,
-        GF_HNDSK_SETVOLUME,
-        GF_HNDSK_GETSPEC,
-        GF_HNDSK_PING,
-        GF_HNDSK_SET_LK_VER,
-        GF_HNDSK_EVENT_NOTIFY,
-        GF_HNDSK_GET_VOLUME_INFO,
-        GF_HNDSK_GET_SNAPSHOT_INFO,
-        GF_HNDSK_MAXVALUE,
+    GF_HNDSK_NULL,
+    GF_HNDSK_SETVOLUME,
+    GF_HNDSK_GETSPEC,
+    GF_HNDSK_PING,
+    GF_HNDSK_SET_LK_VER,
+    GF_HNDSK_EVENT_NOTIFY,
+    GF_HNDSK_GET_VOLUME_INFO,
+    GF_HNDSK_GET_SNAPSHOT_INFO,
+    GF_HNDSK_MAXVALUE,
 };
 
 enum gf_pmap_procnum {
-        GF_PMAP_NULL = 0,
-        GF_PMAP_PORTBYBRICK,
-        GF_PMAP_BRICKBYPORT,
-        /*
-         * SIGNUP is not used, and shouldn't be used.  It was kept here only
-         * to avoid changing the numbers for things that come after it in this
-         * list.
-         */
-        GF_PMAP_SIGNUP,
-        GF_PMAP_SIGNIN,
-        GF_PMAP_SIGNOUT,
-        GF_PMAP_MAXVALUE,
+    GF_PMAP_NULL = 0,
+    GF_PMAP_PORTBYBRICK,
+    GF_PMAP_BRICKBYPORT,
+    /*
+     * SIGNUP is not used, and shouldn't be used.  It was kept here only
+     * to avoid changing the numbers for things that come after it in this
+     * list.
+     */
+    GF_PMAP_SIGNUP,
+    GF_PMAP_SIGNIN,
+    GF_PMAP_SIGNOUT,
+    GF_PMAP_MAXVALUE,
 };
 
 enum gf_aggregator_procnum {
-        GF_AGGREGATOR_NULL = 0,
-        GF_AGGREGATOR_LOOKUP,
-        GF_AGGREGATOR_GETLIMIT,
-        GF_AGGREGATOR_MAXVALUE,
+    GF_AGGREGATOR_NULL = 0,
+    GF_AGGREGATOR_LOOKUP,
+    GF_AGGREGATOR_GETLIMIT,
+    GF_AGGREGATOR_MAXVALUE,
 };
 
 enum gf_pmap_port_type {
-        GF_PMAP_PORT_FREE = 0,
-        GF_PMAP_PORT_FOREIGN,     /* it actually means, not sure who is using it, but it is in-use */
-        GF_PMAP_PORT_LEASED,
-        GF_PMAP_PORT_ANY,
-        GF_PMAP_PORT_BRICKSERVER, /* port used by brick process */
+    GF_PMAP_PORT_FREE = 0,
+    GF_PMAP_PORT_FOREIGN, /* it actually means, not sure who is using it, but it
+                             is in-use */
+    GF_PMAP_PORT_LEASED,
+    GF_PMAP_PORT_ANY,
+    GF_PMAP_PORT_BRICKSERVER, /* port used by brick process */
 };
 typedef enum gf_pmap_port_type gf_pmap_port_type_t;
 
 enum gf_probe_resp {
-	GF_PROBE_SUCCESS,
-	GF_PROBE_LOCALHOST,
-	GF_PROBE_FRIEND,
-        GF_PROBE_ANOTHER_CLUSTER,
-        GF_PROBE_VOLUME_CONFLICT,
-        GF_PROBE_SAME_UUID,
-        GF_PROBE_UNKNOWN_PEER,
-        GF_PROBE_ADD_FAILED,
-        GF_PROBE_QUORUM_NOT_MET,
-        GF_PROBE_MISSED_SNAP_CONFLICT,
-        GF_PROBE_SNAP_CONFLICT,
-        GF_PROBE_FRIEND_DETACHING,
+    GF_PROBE_SUCCESS,
+    GF_PROBE_LOCALHOST,
+    GF_PROBE_FRIEND,
+    GF_PROBE_ANOTHER_CLUSTER,
+    GF_PROBE_VOLUME_CONFLICT,
+    GF_PROBE_SAME_UUID,
+    GF_PROBE_UNKNOWN_PEER,
+    GF_PROBE_ADD_FAILED,
+    GF_PROBE_QUORUM_NOT_MET,
+    GF_PROBE_MISSED_SNAP_CONFLICT,
+    GF_PROBE_SNAP_CONFLICT,
+    GF_PROBE_FRIEND_DETACHING,
 };
 
 enum gf_deprobe_resp {
-        GF_DEPROBE_SUCCESS,
-        GF_DEPROBE_LOCALHOST,
-        GF_DEPROBE_NOT_FRIEND,
-        GF_DEPROBE_BRICK_EXIST,
-        GF_DEPROBE_FRIEND_DOWN,
-        GF_DEPROBE_QUORUM_NOT_MET,
-        GF_DEPROBE_FRIEND_DETACHING,
-        GF_DEPROBE_SNAP_BRICK_EXIST,
+    GF_DEPROBE_SUCCESS,
+    GF_DEPROBE_LOCALHOST,
+    GF_DEPROBE_NOT_FRIEND,
+    GF_DEPROBE_BRICK_EXIST,
+    GF_DEPROBE_FRIEND_DOWN,
+    GF_DEPROBE_QUORUM_NOT_MET,
+    GF_DEPROBE_FRIEND_DETACHING,
+    GF_DEPROBE_SNAP_BRICK_EXIST,
 };
 
 enum gf_cbk_procnum {
-        GF_CBK_NULL = 0,
-        GF_CBK_FETCHSPEC,
-        GF_CBK_INO_FLUSH,
-        GF_CBK_EVENT_NOTIFY,
-        GF_CBK_GET_SNAPS,
-        GF_CBK_CACHE_INVALIDATION,
-        GF_CBK_CHILD_UP,
-        GF_CBK_CHILD_DOWN,
-        GF_CBK_RECALL_LEASE,
-        GF_CBK_STATEDUMP,
-        GF_CBK_MAXVALUE,
+    GF_CBK_NULL = 0,
+    GF_CBK_FETCHSPEC,
+    GF_CBK_INO_FLUSH,
+    GF_CBK_EVENT_NOTIFY,
+    GF_CBK_GET_SNAPS,
+    GF_CBK_CACHE_INVALIDATION,
+    GF_CBK_CHILD_UP,
+    GF_CBK_CHILD_DOWN,
+    GF_CBK_RECALL_LEASE,
+    GF_CBK_STATEDUMP,
+    GF_CBK_INODELK_CONTENTION,
+    GF_CBK_ENTRYLK_CONTENTION,
+    GF_CBK_MAXVALUE,
 };
 
 enum gluster_cli_procnum {
-        GLUSTER_CLI_NULL,    /* 0 */
-        GLUSTER_CLI_PROBE,
-        GLUSTER_CLI_DEPROBE,
-        GLUSTER_CLI_LIST_FRIENDS,
-        GLUSTER_CLI_CREATE_VOLUME,
-        GLUSTER_CLI_GET_VOLUME,
-        GLUSTER_CLI_GET_NEXT_VOLUME,
-        GLUSTER_CLI_DELETE_VOLUME,
-        GLUSTER_CLI_START_VOLUME,
-        GLUSTER_CLI_STOP_VOLUME,
-        GLUSTER_CLI_RENAME_VOLUME,
-        GLUSTER_CLI_DEFRAG_VOLUME,
-        GLUSTER_CLI_SET_VOLUME,
-        GLUSTER_CLI_ADD_BRICK,
-        GLUSTER_CLI_REMOVE_BRICK,
-        GLUSTER_CLI_REPLACE_BRICK,
-        GLUSTER_CLI_LOG_ROTATE,
-        GLUSTER_CLI_GETSPEC,
-        GLUSTER_CLI_PMAP_PORTBYBRICK,
-        GLUSTER_CLI_SYNC_VOLUME,
-        GLUSTER_CLI_RESET_VOLUME,
-        GLUSTER_CLI_FSM_LOG,
-        GLUSTER_CLI_GSYNC_SET,
-        GLUSTER_CLI_PROFILE_VOLUME,
-        GLUSTER_CLI_QUOTA,
-        GLUSTER_CLI_TOP_VOLUME,
-        GLUSTER_CLI_GETWD,
-        GLUSTER_CLI_STATUS_VOLUME,
-        GLUSTER_CLI_STATUS_ALL,
-        GLUSTER_CLI_MOUNT,
-        GLUSTER_CLI_UMOUNT,
-        GLUSTER_CLI_HEAL_VOLUME,
-        GLUSTER_CLI_STATEDUMP_VOLUME,
-        GLUSTER_CLI_LIST_VOLUME,
-        GLUSTER_CLI_CLRLOCKS_VOLUME,
-        GLUSTER_CLI_UUID_RESET,
-        GLUSTER_CLI_UUID_GET,
-        GLUSTER_CLI_COPY_FILE,
-        GLUSTER_CLI_SYS_EXEC,
-        GLUSTER_CLI_SNAP,
-        GLUSTER_CLI_BARRIER_VOLUME,
-        GLUSTER_CLI_GET_VOL_OPT,
-        GLUSTER_CLI_GANESHA,
-        GLUSTER_CLI_BITROT,
-        GLUSTER_CLI_ATTACH_TIER,
-        GLUSTER_CLI_TIER,
-        GLUSTER_CLI_GET_STATE,
-        GLUSTER_CLI_RESET_BRICK,
-        GLUSTER_CLI_REMOVE_TIER_BRICK,
-        GLUSTER_CLI_ADD_TIER_BRICK,
-        GLUSTER_CLI_MAXVALUE,
+    GLUSTER_CLI_NULL, /* 0 */
+    GLUSTER_CLI_PROBE,
+    GLUSTER_CLI_DEPROBE,
+    GLUSTER_CLI_LIST_FRIENDS,
+    GLUSTER_CLI_CREATE_VOLUME,
+    GLUSTER_CLI_GET_VOLUME,
+    GLUSTER_CLI_GET_NEXT_VOLUME,
+    GLUSTER_CLI_DELETE_VOLUME,
+    GLUSTER_CLI_START_VOLUME,
+    GLUSTER_CLI_STOP_VOLUME,
+    GLUSTER_CLI_RENAME_VOLUME,
+    GLUSTER_CLI_DEFRAG_VOLUME,
+    GLUSTER_CLI_SET_VOLUME,
+    GLUSTER_CLI_ADD_BRICK,
+    GLUSTER_CLI_REMOVE_BRICK,
+    GLUSTER_CLI_REPLACE_BRICK,
+    GLUSTER_CLI_LOG_ROTATE,
+    GLUSTER_CLI_GETSPEC,
+    GLUSTER_CLI_PMAP_PORTBYBRICK,
+    GLUSTER_CLI_SYNC_VOLUME,
+    GLUSTER_CLI_RESET_VOLUME,
+    GLUSTER_CLI_FSM_LOG,
+    GLUSTER_CLI_GSYNC_SET,
+    GLUSTER_CLI_PROFILE_VOLUME,
+    GLUSTER_CLI_QUOTA,
+    GLUSTER_CLI_TOP_VOLUME,
+    GLUSTER_CLI_GETWD,
+    GLUSTER_CLI_STATUS_VOLUME,
+    GLUSTER_CLI_STATUS_ALL,
+    GLUSTER_CLI_MOUNT,
+    GLUSTER_CLI_UMOUNT,
+    GLUSTER_CLI_HEAL_VOLUME,
+    GLUSTER_CLI_STATEDUMP_VOLUME,
+    GLUSTER_CLI_LIST_VOLUME,
+    GLUSTER_CLI_CLRLOCKS_VOLUME,
+    GLUSTER_CLI_UUID_RESET,
+    GLUSTER_CLI_UUID_GET,
+    GLUSTER_CLI_COPY_FILE,
+    GLUSTER_CLI_SYS_EXEC,
+    GLUSTER_CLI_SNAP,
+    GLUSTER_CLI_BARRIER_VOLUME,
+    GLUSTER_CLI_GET_VOL_OPT,
+    GLUSTER_CLI_GANESHA,
+    GLUSTER_CLI_BITROT,
+    GLUSTER_CLI_ATTACH_TIER,
+    GLUSTER_CLI_TIER,
+    GLUSTER_CLI_GET_STATE,
+    GLUSTER_CLI_RESET_BRICK,
+    GLUSTER_CLI_REMOVE_TIER_BRICK,
+    GLUSTER_CLI_ADD_TIER_BRICK,
+    GLUSTER_CLI_MAXVALUE,
 };
 
 enum glusterd_mgmt_procnum {
-        GLUSTERD_MGMT_NULL,    /* 0 */
-        GLUSTERD_MGMT_CLUSTER_LOCK,
-        GLUSTERD_MGMT_CLUSTER_UNLOCK,
-        GLUSTERD_MGMT_STAGE_OP,
-        GLUSTERD_MGMT_COMMIT_OP,
-        GLUSTERD_MGMT_MAXVALUE,
+    GLUSTERD_MGMT_NULL, /* 0 */
+    GLUSTERD_MGMT_CLUSTER_LOCK,
+    GLUSTERD_MGMT_CLUSTER_UNLOCK,
+    GLUSTERD_MGMT_STAGE_OP,
+    GLUSTERD_MGMT_COMMIT_OP,
+    GLUSTERD_MGMT_MAXVALUE,
 };
 
 enum glusterd_friend_procnum {
-        GLUSTERD_FRIEND_NULL,    /* 0 */
-        GLUSTERD_PROBE_QUERY,
-        GLUSTERD_FRIEND_ADD,
-        GLUSTERD_FRIEND_REMOVE,
-        GLUSTERD_FRIEND_UPDATE,
-        GLUSTERD_FRIEND_MAXVALUE,
+    GLUSTERD_FRIEND_NULL, /* 0 */
+    GLUSTERD_PROBE_QUERY,
+    GLUSTERD_FRIEND_ADD,
+    GLUSTERD_FRIEND_REMOVE,
+    GLUSTERD_FRIEND_UPDATE,
+    GLUSTERD_FRIEND_MAXVALUE,
 };
 
 enum glusterd_brick_procnum {
-        GLUSTERD_BRICK_NULL,    /* 0 */
-        GLUSTERD_BRICK_TERMINATE,
-        GLUSTERD_BRICK_XLATOR_INFO,
-        GLUSTERD_BRICK_XLATOR_OP,
-        GLUSTERD_BRICK_STATUS,
-        GLUSTERD_BRICK_OP,
-        GLUSTERD_BRICK_XLATOR_DEFRAG,
-        GLUSTERD_NODE_PROFILE,
-        GLUSTERD_NODE_STATUS,
-        GLUSTERD_VOLUME_BARRIER_OP,
-        GLUSTERD_BRICK_BARRIER,
-        GLUSTERD_NODE_BITROT,
-        GLUSTERD_BRICK_ATTACH,
-        GLUSTERD_BRICK_MAXVALUE,
+    GLUSTERD_BRICK_NULL, /* 0 */
+    GLUSTERD_BRICK_TERMINATE,
+    GLUSTERD_BRICK_XLATOR_INFO,
+    GLUSTERD_BRICK_XLATOR_OP,
+    GLUSTERD_BRICK_STATUS,
+    GLUSTERD_BRICK_OP,
+    GLUSTERD_BRICK_XLATOR_DEFRAG,
+    GLUSTERD_NODE_PROFILE,
+    GLUSTERD_NODE_STATUS,
+    GLUSTERD_VOLUME_BARRIER_OP,
+    GLUSTERD_BRICK_BARRIER,
+    GLUSTERD_NODE_BITROT,
+    GLUSTERD_BRICK_ATTACH,
+    GLUSTERD_DUMP_METRICS,
+    GLUSTERD_SVC_ATTACH,
+    GLUSTERD_SVC_DETACH,
+    GLUSTERD_BRICK_MAXVALUE,
 };
 
 enum glusterd_mgmt_hndsk_procnum {
-        GD_MGMT_HNDSK_NULL,
-        GD_MGMT_HNDSK_VERSIONS,
-        GD_MGMT_HNDSK_VERSIONS_ACK,
-        GD_MGMT_HNDSK_MAXVALUE,
+    GD_MGMT_HNDSK_NULL,
+    GD_MGMT_HNDSK_VERSIONS,
+    GD_MGMT_HNDSK_VERSIONS_ACK,
+    GD_MGMT_HNDSK_MAXVALUE,
 };
 
 typedef enum {
-        GF_SHD_OP_INVALID,
-        GF_SHD_OP_HEAL_INDEX,
-        GF_SHD_OP_HEAL_FULL,
-        GF_SHD_OP_INDEX_SUMMARY,
-        GF_SHD_OP_HEALED_FILES,
-        GF_SHD_OP_HEAL_FAILED_FILES,
-        GF_SHD_OP_SPLIT_BRAIN_FILES,
-        GF_SHD_OP_STATISTICS,
-        GF_SHD_OP_STATISTICS_HEAL_COUNT,
-        GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA,
-        GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE,
-        GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK,
-        GF_SHD_OP_HEAL_ENABLE,
-        GF_SHD_OP_HEAL_DISABLE,
-        GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME,
-        GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE,
-        GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE,
-} gf_xl_afr_op_t ;
+    GF_SHD_OP_INVALID,
+    GF_SHD_OP_HEAL_INDEX,
+    GF_SHD_OP_HEAL_FULL,
+    GF_SHD_OP_INDEX_SUMMARY,
+    GF_SHD_OP_HEALED_FILES,
+    GF_SHD_OP_HEAL_FAILED_FILES,
+    GF_SHD_OP_SPLIT_BRAIN_FILES,
+    GF_SHD_OP_STATISTICS,
+    GF_SHD_OP_STATISTICS_HEAL_COUNT,
+    GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA,
+    GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE,
+    GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK,
+    GF_SHD_OP_HEAL_ENABLE,
+    GF_SHD_OP_HEAL_DISABLE,
+    GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME,
+    GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE,
+    GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE,
+    GF_SHD_OP_HEAL_SUMMARY,
+} gf_xl_afr_op_t;
 
 struct gf_gsync_detailed_status_ {
-        char node[NAME_MAX];
-        char master[NAME_MAX];
-        char brick[NAME_MAX];
-        char slave_user[NAME_MAX];
-        char slave[NAME_MAX];
-        char slave_node[NAME_MAX];
-        char worker_status[NAME_MAX];
-        char crawl_status[NAME_MAX];
-        char last_synced[NAME_MAX];
-        char last_synced_utc[NAME_MAX];
-        char entry[NAME_MAX];
-        char data[NAME_MAX];
-        char meta[NAME_MAX];
-        char failures[NAME_MAX];
-        char checkpoint_time[NAME_MAX];
-        char checkpoint_time_utc[NAME_MAX];
-        char checkpoint_completed[NAME_MAX];
-        char checkpoint_completion_time[NAME_MAX];
-        char checkpoint_completion_time_utc[NAME_MAX];
-        char brick_host_uuid[NAME_MAX];
-        char slavekey[NAME_MAX];
-        char session_slave[NAME_MAX];
+    char node[NAME_MAX];
+    char master[NAME_MAX];
+    char brick[PATH_MAX];
+    char slave_user[NAME_MAX];
+    char slave[NAME_MAX];
+    char slave_node[NAME_MAX];
+    char worker_status[NAME_MAX];
+    char crawl_status[NAME_MAX];
+    char last_synced[NAME_MAX];
+    char last_synced_utc[NAME_MAX];
+    char entry[NAME_MAX];
+    char data[NAME_MAX];
+    char meta[NAME_MAX];
+    char failures[NAME_MAX];
+    char checkpoint_time[NAME_MAX];
+    char checkpoint_time_utc[NAME_MAX];
+    char checkpoint_completed[NAME_MAX];
+    char checkpoint_completion_time[NAME_MAX];
+    char checkpoint_completion_time_utc[NAME_MAX];
+    char brick_host_uuid[NAME_MAX];
+    char slavekey[NAME_MAX];
+    char session_slave[NAME_MAX];
 };
 
 enum glusterd_mgmt_v3_procnum {
-        GLUSTERD_MGMT_V3_NULL,    /* 0 */
-        GLUSTERD_MGMT_V3_LOCK,
-        GLUSTERD_MGMT_V3_PRE_VALIDATE,
-        GLUSTERD_MGMT_V3_BRICK_OP,
-        GLUSTERD_MGMT_V3_COMMIT,
-        GLUSTERD_MGMT_V3_POST_VALIDATE,
-        GLUSTERD_MGMT_V3_UNLOCK,
-        GLUSTERD_MGMT_V3_MAXVALUE,
+    GLUSTERD_MGMT_V3_NULL, /* 0 */
+    GLUSTERD_MGMT_V3_LOCK,
+    GLUSTERD_MGMT_V3_PRE_VALIDATE,
+    GLUSTERD_MGMT_V3_BRICK_OP,
+    GLUSTERD_MGMT_V3_COMMIT,
+    GLUSTERD_MGMT_V3_POST_COMMIT,
+    GLUSTERD_MGMT_V3_POST_VALIDATE,
+    GLUSTERD_MGMT_V3_UNLOCK,
+    GLUSTERD_MGMT_V3_MAXVALUE,
 };
 
 typedef struct gf_gsync_detailed_status_ gf_gsync_status_t;
 
 enum gf_get_volume_info_type {
-        GF_GET_VOLUME_NONE,    /* 0 */
-        GF_GET_VOLUME_UUID
+    GF_GET_VOLUME_NONE, /* 0 */
+    GF_GET_VOLUME_UUID
 };
 
 typedef enum gf_get_volume_info_type gf_get_volume_info_type;
 
-
 enum gf_get_snapshot_info_type {
-        GF_GET_SNAPSHOT_LIST,
+    GF_GET_SNAPSHOT_LIST,
 };
 typedef enum gf_get_snapshot_info_type gf_get_snapshot_info_type;
 
-#define GLUSTER_HNDSK_PROGRAM    14398633 /* Completely random */
-#define GLUSTER_HNDSK_VERSION    2   /* 0.0.2 */
+enum gf_getspec_flags_type { GF_GETSPEC_FLAG_SERVERS_LIST = 1 };
+typedef enum gf_getspec_flags_type gf_getspec_flags_type;
+
+#define GLUSTER_HNDSK_PROGRAM 14398633 /* Completely random */
+#define GLUSTER_HNDSK_VERSION 2        /* 0.0.2 */
+
+#define GLUSTER_PMAP_PROGRAM 34123456
+#define GLUSTER_PMAP_VERSION 1
 
-#define GLUSTER_PMAP_PROGRAM     34123456
-#define GLUSTER_PMAP_VERSION     1
+#define GLUSTER_CBK_PROGRAM 52743234 /* Completely random */
+#define GLUSTER_CBK_VERSION 1        /* 0.0.1 */
 
-#define GLUSTER_CBK_PROGRAM      52743234 /* Completely random */
-#define GLUSTER_CBK_VERSION      1   /* 0.0.1 */
+#define GLUSTER_FOP_PROGRAM 1298437 /* Completely random */
+#define GLUSTER_FOP_VERSION 330     /* 3.3.0 */
+#define GLUSTER_FOP_PROCCNT GFS3_OP_MAXVALUE
 
-#define GLUSTER_FOP_PROGRAM   1298437 /* Completely random */
-#define GLUSTER_FOP_VERSION   330 /* 3.3.0 */
-#define GLUSTER_FOP_PROCCNT   GFS3_OP_MAXVALUE
+#define GLUSTER_FOP_VERSION_v2 400 /* 4.0.0 */
 
 /* Aggregator */
 #define GLUSTER_AGGREGATOR_PROGRAM 29852134 /* Completely random */
 #define GLUSTER_AGGREGATOR_VERSION 1
 
 /* Second version */
-#define GD_MGMT_PROGRAM          1238433 /* Completely random */
-#define GD_MGMT_VERSION          2   /* 0.0.2 */
+#define GD_MGMT_PROGRAM 1238433 /* Completely random */
+#define GD_MGMT_VERSION 2       /* 0.0.2 */
 
-#define GD_FRIEND_PROGRAM        1238437 /* Completely random */
-#define GD_FRIEND_VERSION        2  /* 0.0.2 */
+#define GD_FRIEND_PROGRAM 1238437 /* Completely random */
+#define GD_FRIEND_VERSION 2       /* 0.0.2 */
 
-#define GLUSTER_CLI_PROGRAM      1238463 /* Completely random */
-#define GLUSTER_CLI_VERSION      2   /* 0.0.2 */
+#define GLUSTER_CLI_PROGRAM 1238463 /* Completely random */
+#define GLUSTER_CLI_VERSION 2       /* 0.0.2 */
 
-#define GD_BRICK_PROGRAM         4867634 /*Completely random*/
-#define GD_BRICK_VERSION         2
+#define GD_BRICK_PROGRAM 4867634 /*Completely random*/
+#define GD_BRICK_VERSION 2
 
 /* Third version */
-#define GD_MGMT_V3_VERSION       3
+#define GD_MGMT_V3_VERSION 3
 
 /* OP-VERSION handshake */
-#define GD_MGMT_HNDSK_PROGRAM    1239873 /* Completely random */
-#define GD_MGMT_HNDSK_VERSION    1
+#define GD_MGMT_HNDSK_PROGRAM 1239873 /* Completely random */
+#define GD_MGMT_HNDSK_VERSION 1
 
-#define GD_VOLUME_NAME_MAX 256 /* Maximum size of volume name */
+#define GD_VOLUME_NAME_MAX                                                     \
+    ((NAME_MAX + 1) - 5) /* Maximum size of volume name */
+#define GD_VOLUME_NAME_MAX_TIER                                                \
+    (GD_VOLUME_NAME_MAX + 5) /* +5 needed for '-hot'                           \
+                                and '-cold' suffixes*/
 
+#define GLUSTER_PROCESS_UUID_FMT                                               \
+    "CTX_ID:%s-GRAPH_ID:%d-PID:%d-HOST:%s-PC_NAME:%s-RECON_NO:%s"
 #endif /* !_PROTOCOL_COMMON_H */
diff --git a/rpc/rpc-lib/src/rpc-clnt-ping.c b/rpc/rpc-lib/src/rpc-clnt-ping.c
index 5a97f4bb9cf..31f17841bea 100644
--- a/rpc/rpc-lib/src/rpc-clnt-ping.c
+++ b/rpc/rpc-lib/src/rpc-clnt-ping.c
@@ -8,27 +8,25 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "rpc-clnt.h"
 #include "rpc-clnt-ping.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "xdr-rpcclnt.h"
 #include "rpc-transport.h"
 #include "protocol-common.h"
-#include "mem-pool.h"
+#include <glusterfs/mem-pool.h>
 #include "xdr-rpc.h"
 #include "rpc-common-xdr.h"
-#include "timespec.h"
-
+#include <glusterfs/timespec.h>
 
 char *clnt_ping_procs[GF_DUMP_MAXVALUE] = {
-        [GF_DUMP_PING] = "NULL",
+    [GF_DUMP_PING] = "NULL",
 };
 struct rpc_clnt_program clnt_ping_prog = {
-        .progname  = "GF-DUMP",
-        .prognum   = GLUSTER_DUMP_PROGRAM,
-        .progver   = GLUSTER_DUMP_VERSION,
-        .procnames = clnt_ping_procs,
+    .progname = "GF-DUMP",
+    .prognum = GLUSTER_DUMP_PROGRAM,
+    .progver = GLUSTER_DUMP_VERSION,
+    .procnames = clnt_ping_procs,
 };
 
 struct ping_local {
@@ -38,342 +36,322 @@ struct ping_local {
 
 /* Must be called under conn->lock */
 static int
-__rpc_clnt_rearm_ping_timer (struct rpc_clnt *rpc, gf_timer_cbk_t cbk)
+__rpc_clnt_rearm_ping_timer(struct rpc_clnt *rpc, gf_timer_cbk_t cbk)
 {
-        rpc_clnt_connection_t *conn    = &rpc->conn;
-        rpc_transport_t       *trans   = conn->trans;
-        struct timespec        timeout = {0, };
-        gf_timer_t            *timer   = NULL;
-
-        if (conn->ping_timer) {
-                gf_log_callingfn ("", GF_LOG_CRITICAL,
-                                  "%s: ping timer event already scheduled",
-                                  conn->trans->peerinfo.identifier);
-                return -1;
-        }
-
-        timeout.tv_sec = conn->ping_timeout;
-        timeout.tv_nsec = 0;
-
-        rpc_clnt_ref (rpc);
-        timer = gf_timer_call_after (rpc->ctx, timeout,
-                                     cbk,
-                                     (void *) rpc);
-        if (timer == NULL) {
-                gf_log (trans->name, GF_LOG_WARNING,
-                        "unable to setup ping timer");
-
-                /* This unref can't be the last. We just took a ref few lines
-                 * above. So this can be performed under conn->lock. */
-                rpc_clnt_unref (rpc);
-                conn->ping_started = 0;
-                return -1;
-        }
-
-        conn->ping_timer = timer;
-        conn->ping_started = 1;
-        return 0;
+    rpc_clnt_connection_t *conn = &rpc->conn;
+    rpc_transport_t *trans = conn->trans;
+    struct timespec timeout = {
+        0,
+    };
+    gf_timer_t *timer = NULL;
+
+    if (conn->ping_timer) {
+        gf_log_callingfn("", GF_LOG_CRITICAL,
+                         "%s: ping timer event already scheduled",
+                         conn->trans->peerinfo.identifier);
+        return -1;
+    }
+
+    timeout.tv_sec = conn->ping_timeout;
+    timeout.tv_nsec = 0;
+
+    rpc_clnt_ref(rpc);
+    timer = gf_timer_call_after(rpc->ctx, timeout, cbk, (void *)rpc);
+    if (timer == NULL) {
+        gf_log(trans->name, GF_LOG_WARNING, "unable to setup ping timer");
+
+        /* This unref can't be the last. We just took a ref few lines
+         * above. So this can be performed under conn->lock. */
+        rpc_clnt_unref(rpc);
+        conn->ping_started = 0;
+        return -1;
+    }
+
+    conn->ping_timer = timer;
+    conn->ping_started = 1;
+    return 0;
 }
 
 /* Must be called under conn->lock */
 int
-rpc_clnt_remove_ping_timer_locked (struct rpc_clnt *rpc)
+rpc_clnt_remove_ping_timer_locked(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t *conn  = &rpc->conn;
-        gf_timer_t            *timer = NULL;
-
-        if (conn->ping_timer) {
-                timer = conn->ping_timer;
-                conn->ping_timer = NULL;
-                gf_timer_call_cancel (rpc->ctx, timer);
-                conn->ping_started = 0;
-                return 1;
-
-        }
-
-        /* This is to account for rpc_clnt_disable that might have set
-         *  conn->trans to NULL. */
-        if (conn->trans)
-                gf_log_callingfn ("", GF_LOG_DEBUG, "%s: ping timer event "
-                                  "already removed",
-                                   conn->trans->peerinfo.identifier);
-
-        return 0;
+    rpc_clnt_connection_t *conn = &rpc->conn;
+    gf_timer_t *timer = NULL;
+
+    if (conn->ping_timer) {
+        timer = conn->ping_timer;
+        conn->ping_timer = NULL;
+        gf_timer_call_cancel(rpc->ctx, timer);
+        conn->ping_started = 0;
+        return 1;
+    }
+
+    /* This is to account for rpc_clnt_disable that might have set
+     *  conn->trans to NULL. */
+    if (conn->trans)
+        gf_log_callingfn("", GF_LOG_DEBUG,
+                         "%s: ping timer event "
+                         "already removed",
+                         conn->trans->peerinfo.identifier);
+
+    return 0;
 }
 
 static void
-rpc_clnt_start_ping (void *rpc_ptr);
+rpc_clnt_start_ping(void *rpc_ptr);
 
 void
-rpc_clnt_ping_timer_expired (void *rpc_ptr)
+rpc_clnt_ping_timer_expired(void *rpc_ptr)
 {
-        struct rpc_clnt         *rpc                = NULL;
-        rpc_transport_t         *trans              = NULL;
-        rpc_clnt_connection_t   *conn               = NULL;
-        int                      disconnect         = 0;
-        int                      transport_activity = 0;
-        struct timeval           current            = {0, };
-        int                      unref              = 0;
-
-        rpc = (struct rpc_clnt*) rpc_ptr;
-        conn = &rpc->conn;
-        trans = conn->trans;
-
-        if (!trans) {
-                gf_log ("ping-timer", GF_LOG_WARNING,
-                        "transport not initialized");
-                goto out;
+    struct rpc_clnt *rpc = NULL;
+    rpc_transport_t *trans = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    int disconnect = 0;
+    struct timespec current = {
+        0,
+    };
+    int unref = 0;
+
+    rpc = (struct rpc_clnt *)rpc_ptr;
+    conn = &rpc->conn;
+    trans = conn->trans;
+
+    if (!trans) {
+        gf_log("ping-timer", GF_LOG_WARNING, "transport not initialized");
+        goto out;
+    }
+
+    timespec_now_realtime(&current);
+    pthread_mutex_lock(&conn->lock);
+    {
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+
+        if (((current.tv_sec - conn->last_received.tv_sec) <
+             conn->ping_timeout) ||
+            ((current.tv_sec - conn->last_sent.tv_sec) < conn->ping_timeout)) {
+            gf_log(trans->name, GF_LOG_TRACE,
+                   "ping timer expired but transport activity "
+                   "detected - not bailing transport");
+            if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) ==
+                -1) {
+                gf_log(trans->name, GF_LOG_WARNING,
+                       "unable to setup ping timer");
+            }
+        } else {
+            conn->ping_started = 0;
+            disconnect = 1;
         }
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-
-                gettimeofday (&current, NULL);
-                if (((current.tv_sec - conn->last_received.tv_sec) <
-                     conn->ping_timeout)
-                    || ((current.tv_sec - conn->last_sent.tv_sec) <
-                        conn->ping_timeout)) {
-                        transport_activity = 1;
-                }
-
-                if (transport_activity) {
-                        gf_log (trans->name, GF_LOG_TRACE,
-                                "ping timer expired but transport activity "
-                                "detected - not bailing transport");
-
-                        if (__rpc_clnt_rearm_ping_timer (rpc,
-                                         rpc_clnt_ping_timer_expired) == -1) {
-                                gf_log (trans->name, GF_LOG_WARNING,
-                                        "unable to setup ping timer");
-                        }
-
-                } else {
-                        conn->ping_started = 0;
-                        disconnect = 1;
-                }
-        }
-        pthread_mutex_unlock (&conn->lock);
+    if (unref)
+        rpc_clnt_unref(rpc);
 
-        if (unref)
-                rpc_clnt_unref (rpc);
+    if (disconnect) {
+        gf_log(trans->name, GF_LOG_CRITICAL,
+               "server %s has not responded in the last %d "
+               "seconds, disconnecting.",
+               trans->peerinfo.identifier, conn->ping_timeout);
 
-        if (disconnect) {
-                gf_log (trans->name, GF_LOG_CRITICAL,
-                        "server %s has not responded in the last %d "
-                        "seconds, disconnecting.",
-                        trans->peerinfo.identifier,
-                        conn->ping_timeout);
-
-                rpc_transport_disconnect (conn->trans, _gf_false);
-        }
+        rpc_transport_disconnect(conn->trans, _gf_false);
+    }
 
 out:
-        return;
+    return;
 }
 
 int
-rpc_clnt_ping_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                   void *myframe)
+rpc_clnt_ping_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
 {
-        struct ping_local     *local   = NULL;
-        xlator_t              *this    = NULL;
-        rpc_clnt_connection_t *conn    = NULL;
-        call_frame_t          *frame   = NULL;
-        int                   unref    = 0;
-        gf_boolean_t          call_notify = _gf_false;
-
-        struct timespec       now;
-        struct timespec       delta;
-        int64_t               latency_msec = 0;
-        int                   ret = 0;
-
-        if (!myframe) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "frame with the request is NULL");
-                goto out;
+    struct ping_local *local = NULL;
+    xlator_t *this = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    call_frame_t *frame = NULL;
+    int unref = 0;
+    gf_boolean_t call_notify = _gf_false;
+
+    struct timespec now;
+    struct timespec delta;
+    int64_t latency_msec = 0;
+    int ret = 0;
+
+    if (!myframe) {
+        gf_log(THIS->name, GF_LOG_WARNING, "frame with the request is NULL");
+        goto out;
+    }
+
+    frame = myframe;
+    this = frame->this;
+    local = frame->local;
+    conn = &local->rpc->conn;
+
+    timespec_now(&now);
+    timespec_sub(&local->submit_time, &now, &delta);
+    latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000;
+
+    gf_log(THIS->name, GF_LOG_DEBUG, "Ping latency is %" PRIu64 "ms",
+           latency_msec);
+    call_notify = _gf_true;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        unref = rpc_clnt_remove_ping_timer_locked(local->rpc);
+        if (req->rpc_status == -1) {
+            conn->ping_started = 0;
+            pthread_mutex_unlock(&conn->lock);
+            if (unref) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "socket or ib related error");
+
+            } else {
+                /* timer expired and transport bailed out */
+                gf_log(this->name, GF_LOG_WARNING, "socket disconnected");
+            }
+            goto after_unlock;
         }
 
-        frame = myframe;
-        this = frame->this;
-        local = frame->local;
-        conn = &local->rpc->conn;
-
-        timespec_now (&now);
-        timespec_sub (&local->submit_time, &now, &delta);
-        latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                this->client_latency = latency_msec;
-                gf_log (THIS->name, GF_LOG_DEBUG,
-                        "Ping latency is %" PRIu64 "ms",
-                        latency_msec);
-
-                call_notify = _gf_true;
-                if (req->rpc_status == -1) {
-                        unref = rpc_clnt_remove_ping_timer_locked (local->rpc);
-                        if (unref) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "socket or ib related error");
-
-                        } else {
-                                /* timer expired and transport bailed out */
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "socket disconnected");
-
-                        }
-                        conn->ping_started = 0;
-                        goto unlock;
-                }
-
-                unref = rpc_clnt_remove_ping_timer_locked (local->rpc);
-                if (__rpc_clnt_rearm_ping_timer (local->rpc,
-                                                 rpc_clnt_start_ping) == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "failed to set the ping timer");
-                }
-
+        if (__rpc_clnt_rearm_ping_timer(local->rpc, rpc_clnt_start_ping) ==
+            -1) {
+            /* unlock before logging error */
+            pthread_mutex_unlock(&conn->lock);
+            gf_log(this->name, GF_LOG_WARNING, "failed to set the ping timer");
+        } else {
+            /* just unlock the mutex */
+            pthread_mutex_unlock(&conn->lock);
         }
-unlock:
-        pthread_mutex_unlock (&conn->lock);
-
-        if (call_notify) {
-                ret = local->rpc->notifyfn (local->rpc, this, RPC_CLNT_PING,
-                                            (void *)(uintptr_t)latency_msec);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "RPC_CLNT_PING notify failed");
-                }
+    }
+after_unlock:
+    if (call_notify) {
+        ret = local->rpc->notifyfn(local->rpc, this, RPC_CLNT_PING,
+                                   (void *)(uintptr_t)latency_msec);
+        if (ret) {
+            gf_log(this->name, GF_LOG_WARNING, "RPC_CLNT_PING notify failed");
         }
+    }
 out:
-        if (unref)
-                rpc_clnt_unref (local->rpc);
-
-        if (frame) {
-                GF_FREE (frame->local);
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
-        }
-        return 0;
+    if (unref)
+        rpc_clnt_unref(local->rpc);
+
+    if (frame) {
+        GF_FREE(frame->local);
+        frame->local = NULL;
+        STACK_DESTROY(frame->root);
+    }
+    return 0;
 }
 
 int
-rpc_clnt_ping (struct rpc_clnt *rpc)
+rpc_clnt_ping(struct rpc_clnt *rpc)
 {
-        call_frame_t *frame = NULL;
-        int32_t       ret   = -1;
-        rpc_clnt_connection_t *conn = NULL;
-        struct ping_local *local = NULL;
-
-        conn = &rpc->conn;
-        local = GF_CALLOC (1, sizeof(struct ping_local),
-                           gf_common_ping_local_t);
-        if (!local)
-                return ret;
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                GF_FREE (local);
-                return ret;
-        }
-
-        local->rpc = rpc;
-        timespec_now (&local->submit_time);
-        frame->local = local;
-
-        ret = rpc_clnt_submit (rpc, &clnt_ping_prog,
-                               GF_DUMP_PING, rpc_clnt_ping_cbk, NULL, 0,
-                               NULL, 0, NULL, frame, NULL, 0, NULL, 0, NULL);
-        if (ret) {
-                /* FIXME: should we free the frame here? Methinks so! */
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "failed to start ping timer");
-        }
-        else {
-                /* ping successfully queued in list of saved frames
-                 * for the connection*/
-                pthread_mutex_lock (&conn->lock);
-                conn->pingcnt++;
-                pthread_mutex_unlock (&conn->lock);
-        }
-
+    call_frame_t *frame = NULL;
+    int32_t ret = -1;
+    rpc_clnt_connection_t *conn = NULL;
+    struct ping_local *local = NULL;
+
+    conn = &rpc->conn;
+    local = GF_MALLOC(sizeof(struct ping_local), gf_common_ping_local_t);
+    if (!local)
         return ret;
-
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        GF_FREE(local);
+        return ret;
+    }
+
+    local->rpc = rpc;
+    timespec_now(&local->submit_time);
+    frame->local = local;
+
+    ret = rpc_clnt_submit(rpc, &clnt_ping_prog, GF_DUMP_PING, rpc_clnt_ping_cbk,
+                          NULL, 0, NULL, 0, NULL, frame, NULL, 0, NULL, 0,
+                          NULL);
+    if (ret) {
+        /* FIXME: should we free the frame here? Methinks so! */
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to start ping timer");
+    } else {
+        /* ping successfully queued in list of saved frames
+         * for the connection*/
+        pthread_mutex_lock(&conn->lock);
+        conn->pingcnt++;
+        pthread_mutex_unlock(&conn->lock);
+    }
+
+    return ret;
 }
 
 static void
-rpc_clnt_start_ping (void *rpc_ptr)
+rpc_clnt_start_ping(void *rpc_ptr)
 {
-        struct rpc_clnt         *rpc         = NULL;
-        rpc_clnt_connection_t   *conn        = NULL;
-        int                      frame_count = 0;
-        int                      unref       = 0;
-
-        rpc = (struct rpc_clnt*) rpc_ptr;
-        conn = &rpc->conn;
-
-        if (conn->ping_timeout == 0) {
-                gf_log (THIS->name, GF_LOG_DEBUG, "ping timeout is 0,"
-                        " returning");
-                return;
+    struct rpc_clnt *rpc = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    int frame_count = 0;
+    int unref = 0;
+
+    rpc = (struct rpc_clnt *)rpc_ptr;
+    conn = &rpc->conn;
+
+    if (conn->ping_timeout == 0) {
+        gf_log(THIS->name, GF_LOG_DEBUG,
+               "ping timeout is 0,"
+               " returning");
+        return;
+    }
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+
+        if (conn->saved_frames) {
+            GF_ASSERT(conn->saved_frames->count >= 0);
+            /* treat the case where conn->saved_frames is NULL
+               as no pending frames */
+            frame_count = conn->saved_frames->count;
         }
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-
-                if (conn->saved_frames) {
-                        GF_ASSERT (conn->saved_frames->count >= 0);
-                        /* treat the case where conn->saved_frames is NULL
-                           as no pending frames */
-                        frame_count = conn->saved_frames->count;
-                }
-
-                if ((frame_count == 0) || !conn->connected) {
-                        gf_log (THIS->name, GF_LOG_DEBUG,
-                                "returning as transport is already disconnected"
-                                " OR there are no frames (%d || %d)",
-                                !conn->connected, frame_count);
-
-                        pthread_mutex_unlock (&conn->lock);
-                        if (unref)
-                                rpc_clnt_unref (rpc);
-                        return;
-                }
-
-                if (__rpc_clnt_rearm_ping_timer (rpc,
-                                         rpc_clnt_ping_timer_expired) == -1) {
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "unable to setup ping timer");
-                        pthread_mutex_unlock (&conn->lock);
-                        if (unref)
-                                rpc_clnt_unref (rpc);
-                        return;
-
-                }
+        if ((frame_count == 0) || !conn->connected) {
+            gf_log(THIS->name, GF_LOG_DEBUG,
+                   "returning as transport is already disconnected"
+                   " OR there are no frames (%d || %d)",
+                   !conn->connected, frame_count);
 
+            pthread_mutex_unlock(&conn->lock);
+            if (unref)
+                rpc_clnt_unref(rpc);
+            return;
         }
-        pthread_mutex_unlock (&conn->lock);
-        if (unref)
-                rpc_clnt_unref (rpc);
 
-        rpc_clnt_ping(rpc);
+        if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) ==
+            -1) {
+            gf_log(THIS->name, GF_LOG_WARNING, "unable to setup ping timer");
+            pthread_mutex_unlock(&conn->lock);
+            if (unref)
+                rpc_clnt_unref(rpc);
+            return;
+        }
+    }
+    pthread_mutex_unlock(&conn->lock);
+    if (unref)
+        rpc_clnt_unref(rpc);
+
+    rpc_clnt_ping(rpc);
 }
 
 void
-rpc_clnt_check_and_start_ping (struct rpc_clnt *rpc)
+rpc_clnt_check_and_start_ping(struct rpc_clnt *rpc)
 {
-        char start_ping = 0;
+    char start_ping = 0;
 
-        pthread_mutex_lock (&rpc->conn.lock);
-        {
-                if (!rpc->conn.ping_started)
-                        start_ping = 1;
-        }
-        pthread_mutex_unlock (&rpc->conn.lock);
+    pthread_mutex_lock(&rpc->conn.lock);
+    {
+        if (!rpc->conn.ping_started)
+            start_ping = 1;
+    }
+    pthread_mutex_unlock(&rpc->conn.lock);
 
-        if (start_ping)
-                rpc_clnt_start_ping ((void *)rpc);
+    if (start_ping)
+        rpc_clnt_start_ping((void *)rpc);
 
-        return;
+    return;
 }
diff --git a/rpc/rpc-lib/src/rpc-clnt-ping.h b/rpc/rpc-lib/src/rpc-clnt-ping.h
index d92e5054190..e5466a828c2 100644
--- a/rpc/rpc-lib/src/rpc-clnt-ping.h
+++ b/rpc/rpc-lib/src/rpc-clnt-ping.h
@@ -8,9 +8,9 @@
   cases as published by the Free Software Foundation.
 */
 
-
+struct rpc_clnt;
 #define RPC_DEFAULT_PING_TIMEOUT 30
 void
-rpc_clnt_check_and_start_ping (struct rpc_clnt *rpc_ptr);
+rpc_clnt_check_and_start_ping(struct rpc_clnt *rpc_ptr);
 int
-rpc_clnt_remove_ping_timer_locked (struct rpc_clnt *rpc);
+rpc_clnt_remove_ping_timer_locked(struct rpc_clnt *rpc);
diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c
index e34d2ca47ac..517037c4a5d 100644
--- a/rpc/rpc-lib/src/rpc-clnt.c
+++ b/rpc/rpc-lib/src/rpc-clnt.c
@@ -8,492 +8,473 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #define RPC_CLNT_DEFAULT_REQUEST_COUNT 512
 
 #include "rpc-clnt.h"
 #include "rpc-clnt-ping.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "xdr-rpcclnt.h"
 #include "rpc-transport.h"
 #include "protocol-common.h"
-#include "mem-pool.h"
+#include <glusterfs/mem-pool.h>
 #include "xdr-rpc.h"
 #include "rpc-common-xdr.h"
 
 void
-rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool);
+rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool);
 
 struct saved_frame *
-__saved_frames_get_timedout (struct saved_frames *frames, uint32_t timeout,
-                             struct timeval *current)
+__saved_frames_get_timedout(struct saved_frames *frames, uint32_t timeout,
+                            struct timeval *current)
 {
-	struct saved_frame *bailout_frame = NULL, *tmp = NULL;
-
-	if (!list_empty(&frames->sf.list)) {
-		tmp = list_entry (frames->sf.list.next, typeof (*tmp), list);
-		if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) {
-			bailout_frame = tmp;
-			list_del_init (&bailout_frame->list);
-			frames->count--;
-		}
-	}
-
-	return bailout_frame;
+    struct saved_frame *bailout_frame = NULL, *tmp = NULL;
+
+    if (!list_empty(&frames->sf.list)) {
+        tmp = list_entry(frames->sf.list.next, typeof(*tmp), list);
+        if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) {
+            bailout_frame = tmp;
+            list_del_init(&bailout_frame->list);
+            frames->count--;
+        }
+    }
+
+    return bailout_frame;
 }
 
 static int
-_is_lock_fop (struct saved_frame *sframe)
+_is_lock_fop(struct saved_frame *sframe)
 {
-        int     fop     = 0;
+    int fop = 0;
 
-        if (SFRAME_GET_PROGNUM (sframe) == GLUSTER_FOP_PROGRAM &&
-            SFRAME_GET_PROGVER (sframe) == GLUSTER_FOP_VERSION)
-                fop = SFRAME_GET_PROCNUM (sframe);
+    if (SFRAME_GET_PROGNUM(sframe) == GLUSTER_FOP_PROGRAM &&
+        SFRAME_GET_PROGVER(sframe) == GLUSTER_FOP_VERSION)
+        fop = SFRAME_GET_PROCNUM(sframe);
 
-        return ((fop == GFS3_OP_LK) ||
-                (fop == GFS3_OP_INODELK) ||
-                (fop == GFS3_OP_FINODELK) ||
-                (fop == GFS3_OP_ENTRYLK) ||
-                (fop == GFS3_OP_FENTRYLK));
+    return ((fop == GFS3_OP_LK) || (fop == GFS3_OP_INODELK) ||
+            (fop == GFS3_OP_FINODELK) || (fop == GFS3_OP_ENTRYLK) ||
+            (fop == GFS3_OP_FENTRYLK));
 }
 
-struct saved_frame *
-__saved_frames_put (struct saved_frames *frames, void *frame,
-                    struct rpc_req *rpcreq)
+static struct saved_frame *
+__saved_frames_put(struct saved_frames *frames, void *frame,
+                   struct rpc_req *rpcreq)
 {
-	struct saved_frame *saved_frame = NULL;
+    struct saved_frame *saved_frame = mem_get(
+        rpcreq->conn->rpc_clnt->saved_frames_pool);
 
-        saved_frame = mem_get (rpcreq->conn->rpc_clnt->saved_frames_pool);
-	if (!saved_frame) {
-                goto out;
-	}
-        /* THIS should be saved and set back */
+    if (!saved_frame) {
+        goto out;
+    }
+    /* THIS should be saved and set back */
 
-        memset (saved_frame, 0, sizeof (*saved_frame));
-	INIT_LIST_HEAD (&saved_frame->list);
+    INIT_LIST_HEAD(&saved_frame->list);
 
-	saved_frame->capital_this = THIS;
-	saved_frame->frame        = frame;
-        saved_frame->rpcreq       = rpcreq;
-	gettimeofday (&saved_frame->saved_at, NULL);
+    saved_frame->capital_this = THIS;
+    saved_frame->frame = frame;
+    saved_frame->rpcreq = rpcreq;
+    gettimeofday(&saved_frame->saved_at, NULL);
+    memset(&saved_frame->rsp, 0, sizeof(rpc_transport_rsp_t));
 
-        if (_is_lock_fop (saved_frame))
-                list_add_tail (&saved_frame->list, &frames->lk_sf.list);
-        else
-                list_add_tail (&saved_frame->list, &frames->sf.list);
+    if (_is_lock_fop(saved_frame))
+        list_add_tail(&saved_frame->list, &frames->lk_sf.list);
+    else
+        list_add_tail(&saved_frame->list, &frames->sf.list);
 
-	frames->count++;
+    frames->count++;
 
 out:
-	return saved_frame;
+    return saved_frame;
 }
 
-
-
 static void
-call_bail (void *data)
+call_bail(void *data)
 {
-        rpc_transport_t       *trans = NULL;
-        struct rpc_clnt       *clnt = NULL;
-        rpc_clnt_connection_t *conn = NULL;
-        struct timeval         current;
-        struct list_head       list;
-        struct saved_frame    *saved_frame = NULL;
-        struct saved_frame    *trav = NULL;
-        struct saved_frame    *tmp = NULL;
-        char                   frame_sent[256] = {0,};
-        struct timespec        timeout = {0,};
-        struct iovec           iov = {0,};
-        char                   peerid[UNIX_PATH_MAX] = {0};
-        gf_boolean_t           need_unref = _gf_false;
-
-        GF_VALIDATE_OR_GOTO ("client", data, out);
-
-        clnt = data;
-
-        conn = &clnt->conn;
-        pthread_mutex_lock (&conn->lock);
-        {
-            trans = conn->trans;
-            if (trans) {
-                    strncpy (peerid, conn->trans->peerinfo.identifier,
-                             sizeof (peerid)-1);
-
+    rpc_transport_t *trans = NULL;
+    struct rpc_clnt *clnt = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    struct timeval current;
+    struct list_head list;
+    struct saved_frame *saved_frame = NULL;
+    struct saved_frame *trav = NULL;
+    struct saved_frame *tmp = NULL;
+    char frame_sent[GF_TIMESTR_SIZE] = {
+        0,
+    };
+    struct timespec timeout = {
+        0,
+    };
+    char peerid[UNIX_PATH_MAX] = {0};
+    gf_boolean_t need_unref = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("client", data, out);
+
+    clnt = data;
+
+    conn = &clnt->conn;
+    pthread_mutex_lock(&conn->lock);
+    {
+        trans = conn->trans;
+        if (trans) {
+            (void)snprintf(peerid, sizeof(peerid), "%s",
+                           conn->trans->peerinfo.identifier);
+        }
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /*rpc_clnt_connection_cleanup will be unwinding all saved frames,
+     * bailed or otherwise*/
+    if (!trans)
+        goto out;
+
+    gettimeofday(&current, NULL);
+    INIT_LIST_HEAD(&list);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        /* Chaining to get call-always functionality from
+           call-once timer */
+        if (conn->timer) {
+            timeout.tv_sec = 10;
+            timeout.tv_nsec = 0;
+
+            /* Ref rpc as it's added to timer event queue */
+            rpc_clnt_ref(clnt);
+            gf_timer_call_cancel(clnt->ctx, conn->timer);
+            conn->timer = gf_timer_call_after(clnt->ctx, timeout, call_bail,
+                                              (void *)clnt);
+
+            if (conn->timer == NULL) {
+                gf_log(conn->name, GF_LOG_WARNING,
+                       "Cannot create bailout timer for %s", peerid);
+                need_unref = _gf_true;
             }
         }
-        pthread_mutex_unlock (&conn->lock);
-        /*rpc_clnt_connection_cleanup will be unwinding all saved frames,
-         * bailed or otherwise*/
-        if (!trans)
-                goto out;
 
-        gettimeofday (&current, NULL);
-        INIT_LIST_HEAD (&list);
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                /* Chaining to get call-always functionality from
-                   call-once timer */
-                if (conn->timer) {
-                        timeout.tv_sec = 10;
-                        timeout.tv_nsec = 0;
-
-                        /* Ref rpc as it's added to timer event queue */
-                        rpc_clnt_ref (clnt);
-                        gf_timer_call_cancel (clnt->ctx, conn->timer);
-                        conn->timer = gf_timer_call_after (clnt->ctx,
-                                                           timeout,
-                                                           call_bail,
-                                                           (void *) clnt);
-
-                        if (conn->timer == NULL) {
-                                gf_log (conn->name, GF_LOG_WARNING,
-                                        "Cannot create bailout timer for %s",
-                                        peerid);
-                                need_unref = _gf_true;
-                        }
-                }
-
-                do {
-                        saved_frame =
-                                __saved_frames_get_timedout (conn->saved_frames,
-                                                             conn->frame_timeout,
-                                                             &current);
-                        if (saved_frame)
-                                list_add (&saved_frame->list, &list);
-
-                } while (saved_frame);
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        list_for_each_entry_safe (trav, tmp, &list, list) {
-                gf_time_fmt (frame_sent, sizeof frame_sent,
-                             trav->saved_at.tv_sec, gf_timefmt_FT);
-                snprintf (frame_sent + strlen (frame_sent),
-                          256 - strlen (frame_sent),
-                          ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec);
-
-		gf_log (conn->name, GF_LOG_ERROR,
-			"bailing out frame type(%s) op(%s(%d)) xid = 0x%x "
-                        "sent = %s. timeout = %d for %s",
-			trav->rpcreq->prog->progname,
-                        (trav->rpcreq->prog->procnames) ?
-                        trav->rpcreq->prog->procnames[trav->rpcreq->procnum] :
-                        "--",
-                        trav->rpcreq->procnum, trav->rpcreq->xid, frame_sent,
-                        conn->frame_timeout, peerid);
-
-                clnt = rpc_clnt_ref (clnt);
-                trav->rpcreq->rpc_status = -1;
-		trav->rpcreq->cbkfn (trav->rpcreq, &iov, 1, trav->frame);
-
-                rpc_clnt_reply_deinit (trav->rpcreq, clnt->reqpool);
-                clnt = rpc_clnt_unref (clnt);
-                list_del_init (&trav->list);
-                mem_put (trav);
-        }
+        do {
+            saved_frame = __saved_frames_get_timedout(
+                conn->saved_frames, conn->frame_timeout, &current);
+            if (saved_frame)
+                list_add(&saved_frame->list, &list);
+
+        } while (saved_frame);
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (list_empty(&list))
+        goto out;
+
+    list_for_each_entry_safe(trav, tmp, &list, list)
+    {
+        gf_time_fmt_tv(frame_sent, sizeof frame_sent, &trav->saved_at,
+                       gf_timefmt_FT);
+
+        gf_log(conn->name, GF_LOG_ERROR,
+               "bailing out frame type(%s), op(%s(%d)), xid = 0x%x, "
+               "unique = %" PRIu64 ", sent = %s, timeout = %d for %s",
+               trav->rpcreq->prog->progname,
+               (trav->rpcreq->prog->procnames)
+                   ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
+                   : "--",
+               trav->rpcreq->procnum, trav->rpcreq->xid,
+               ((call_frame_t *)(trav->frame))->root->unique, frame_sent,
+               conn->frame_timeout, peerid);
+
+        clnt = rpc_clnt_ref(clnt);
+        trav->rpcreq->rpc_status = -1;
+        trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame);
+
+        rpc_clnt_reply_deinit(trav->rpcreq, clnt->reqpool);
+        clnt = rpc_clnt_unref(clnt);
+        list_del_init(&trav->list);
+        mem_put(trav);
+    }
 out:
-        rpc_clnt_unref (clnt);
-        if (need_unref)
-                rpc_clnt_unref (clnt);
-        return;
+    rpc_clnt_unref(clnt);
+    if (need_unref)
+        rpc_clnt_unref(clnt);
+    return;
 }
 
-
 /* to be called with conn->lock held */
-struct saved_frame *
-__save_frame (struct rpc_clnt *rpc_clnt, call_frame_t *frame,
-              struct rpc_req *rpcreq)
+static struct saved_frame *
+__save_frame(struct rpc_clnt *rpc_clnt, call_frame_t *frame,
+             struct rpc_req *rpcreq)
 {
-        rpc_clnt_connection_t *conn        = NULL;
-        struct timespec        timeout     = {0, };
-        struct saved_frame    *saved_frame = NULL;
-
-        conn = &rpc_clnt->conn;
-
-        saved_frame = __saved_frames_put (conn->saved_frames, frame, rpcreq);
-
-        if (saved_frame == NULL) {
-                goto out;
-        }
-
-        /* TODO: make timeout configurable */
-        if (conn->timer == NULL) {
-                timeout.tv_sec  = 10;
-                timeout.tv_nsec = 0;
-                rpc_clnt_ref (rpc_clnt);
-                conn->timer = gf_timer_call_after (rpc_clnt->ctx,
-                                                   timeout,
-                                                   call_bail,
-                                                   (void *) rpc_clnt);
-        }
+    rpc_clnt_connection_t *conn = &rpc_clnt->conn;
+    struct timespec timeout = {
+        0,
+    };
+    struct saved_frame *saved_frame = __saved_frames_put(conn->saved_frames,
+                                                         frame, rpcreq);
+
+    if (saved_frame == NULL) {
+        goto out;
+    }
+
+    /* TODO: make timeout configurable */
+    if (conn->timer == NULL) {
+        timeout.tv_sec = 10;
+        timeout.tv_nsec = 0;
+        rpc_clnt_ref(rpc_clnt);
+        conn->timer = gf_timer_call_after(rpc_clnt->ctx, timeout, call_bail,
+                                          (void *)rpc_clnt);
+    }
 
 out:
-        return saved_frame;
+    return saved_frame;
 }
 
-
 struct saved_frames *
-saved_frames_new (void)
+saved_frames_new(void)
 {
-	struct saved_frames *saved_frames = NULL;
+    struct saved_frames *saved_frames = NULL;
 
-	saved_frames = GF_CALLOC (1, sizeof (*saved_frames),
-                                  gf_common_mt_rpcclnt_savedframe_t);
-	if (!saved_frames) {
-		return NULL;
-	}
+    saved_frames = GF_CALLOC(1, sizeof(*saved_frames),
+                             gf_common_mt_rpcclnt_savedframe_t);
+    if (!saved_frames) {
+        return NULL;
+    }
 
-	INIT_LIST_HEAD (&saved_frames->sf.list);
-	INIT_LIST_HEAD (&saved_frames->lk_sf.list);
+    INIT_LIST_HEAD(&saved_frames->sf.list);
+    INIT_LIST_HEAD(&saved_frames->lk_sf.list);
 
-	return saved_frames;
+    return saved_frames;
 }
 
-
 int
-__saved_frame_copy (struct saved_frames *frames, int64_t callid,
-                    struct saved_frame *saved_frame)
+__saved_frame_copy(struct saved_frames *frames, int64_t callid,
+                   struct saved_frame *saved_frame)
 {
-	struct saved_frame *tmp   = NULL;
-        int                 ret   = -1;
+    struct saved_frame *tmp = NULL;
+    int ret = -1;
+
+    if (!saved_frame) {
+        ret = 0;
+        goto out;
+    }
 
-        if (!saved_frame) {
-                ret = 0;
-                goto out;
+    list_for_each_entry(tmp, &frames->sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            *saved_frame = *tmp;
+            ret = 0;
+            goto out;
         }
+    }
 
-	list_for_each_entry (tmp, &frames->sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			*saved_frame = *tmp;
-                        ret = 0;
-			goto out;
-		}
-	}
-
-	list_for_each_entry (tmp, &frames->lk_sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			*saved_frame = *tmp;
-                        ret = 0;
-			goto out;
-		}
-	}
+    list_for_each_entry(tmp, &frames->lk_sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            *saved_frame = *tmp;
+            ret = 0;
+            goto out;
+        }
+    }
 
 out:
-	return ret;
+    return ret;
 }
 
-
 struct saved_frame *
-__saved_frame_get (struct saved_frames *frames, int64_t callid)
+__saved_frame_get(struct saved_frames *frames, int64_t callid)
 {
-	struct saved_frame *saved_frame = NULL;
-	struct saved_frame *tmp = NULL;
-
-	list_for_each_entry (tmp, &frames->sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			list_del_init (&tmp->list);
-			frames->count--;
-			saved_frame = tmp;
-			goto out;
-		}
-	}
-
-	list_for_each_entry (tmp, &frames->lk_sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			list_del_init (&tmp->list);
-			frames->count--;
-			saved_frame = tmp;
-			goto out;
-		}
-	}
+    struct saved_frame *saved_frame = NULL;
+    struct saved_frame *tmp = NULL;
 
-out:
-	if (saved_frame) {
-                THIS  = saved_frame->capital_this;
+    list_for_each_entry(tmp, &frames->sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            list_del_init(&tmp->list);
+            frames->count--;
+            saved_frame = tmp;
+            goto out;
         }
+    }
 
-	return saved_frame;
-}
+    list_for_each_entry(tmp, &frames->lk_sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            list_del_init(&tmp->list);
+            frames->count--;
+            saved_frame = tmp;
+            goto out;
+        }
+    }
+
+out:
+    if (saved_frame) {
+        THIS = saved_frame->capital_this;
+    }
 
+    return saved_frame;
+}
 
 void
-saved_frames_unwind (struct saved_frames *saved_frames)
+saved_frames_unwind(struct saved_frames *saved_frames)
 {
-	struct saved_frame   *trav = NULL;
-	struct saved_frame   *tmp = NULL;
-        char                  timestr[1024] = {0,};
-        struct iovec          iov = {0,};
-
-        list_splice_init (&saved_frames->lk_sf.list, &saved_frames->sf.list);
-
-	list_for_each_entry_safe (trav, tmp, &saved_frames->sf.list, list) {
-                gf_time_fmt (timestr, sizeof timestr,
-                             trav->saved_at.tv_sec, gf_timefmt_FT);
-                snprintf (timestr + strlen (timestr),
-                          sizeof(timestr) - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec);
-
-                if (!trav->rpcreq || !trav->rpcreq->prog)
-                        continue;
-
-                gf_log_callingfn (trav->rpcreq->conn->name,
-                                  GF_LOG_ERROR,
-                                  "forced unwinding frame type(%s) op(%s(%d)) "
-                                  "called at %s (xid=0x%x)",
-                                  trav->rpcreq->prog->progname,
-                                  ((trav->rpcreq->prog->procnames) ?
-                                   trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
-                                   : "--"),
-                                  trav->rpcreq->procnum, timestr,
-                                  trav->rpcreq->xid);
-		saved_frames->count--;
-
-                trav->rpcreq->rpc_status = -1;
-                trav->rpcreq->cbkfn (trav->rpcreq, &iov, 1, trav->frame);
-
-                rpc_clnt_reply_deinit (trav->rpcreq,
-                                       trav->rpcreq->conn->rpc_clnt->reqpool);
-
-		list_del_init (&trav->list);
-                mem_put (trav);
-	}
+    struct saved_frame *trav = NULL;
+    struct saved_frame *tmp = NULL;
+    char timestr[GF_TIMESTR_SIZE] = {
+        0,
+    };
+
+    list_splice_init(&saved_frames->lk_sf.list, &saved_frames->sf.list);
+
+    list_for_each_entry_safe(trav, tmp, &saved_frames->sf.list, list)
+    {
+        gf_time_fmt_tv(timestr, sizeof timestr, &trav->saved_at, gf_timefmt_FT);
+
+        if (!trav->rpcreq || !trav->rpcreq->prog)
+            continue;
+
+        gf_log_callingfn(
+            trav->rpcreq->conn->name, GF_LOG_ERROR,
+            "forced unwinding frame type(%s) op(%s(%d)) "
+            "called at %s (xid=0x%x)",
+            trav->rpcreq->prog->progname,
+            ((trav->rpcreq->prog->procnames)
+                 ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
+                 : "--"),
+            trav->rpcreq->procnum, timestr, trav->rpcreq->xid);
+        saved_frames->count--;
+
+        trav->rpcreq->rpc_status = -1;
+        trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame);
+
+        rpc_clnt_reply_deinit(trav->rpcreq,
+                              trav->rpcreq->conn->rpc_clnt->reqpool);
+
+        list_del_init(&trav->list);
+        mem_put(trav);
+    }
 }
 
-
 void
-saved_frames_destroy (struct saved_frames *frames)
+saved_frames_destroy(struct saved_frames *frames)
 {
-        if (!frames)
-                return;
+    if (!frames)
+        return;
 
-	saved_frames_unwind (frames);
+    saved_frames_unwind(frames);
 
-	GF_FREE (frames);
+    GF_FREE(frames);
 }
 
-
 void
-rpc_clnt_reconnect (void *conn_ptr)
+rpc_clnt_reconnect(void *conn_ptr)
 {
-        rpc_transport_t         *trans = NULL;
-        rpc_clnt_connection_t   *conn  = NULL;
-        struct timespec          ts    = {0, 0};
-        struct rpc_clnt         *clnt  = NULL;
-        gf_boolean_t             need_unref = _gf_false;
-
-        conn  = conn_ptr;
-        clnt = conn->rpc_clnt;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                trans = conn->trans;
-                if (!trans) {
-                        pthread_mutex_unlock (&conn->lock);
-                        return;
-                }
-                if (conn->reconnect)
-                        gf_timer_call_cancel (clnt->ctx,
-                                              conn->reconnect);
-                conn->reconnect = 0;
-
-                if ((conn->connected == 0) && !clnt->disabled) {
-                        ts.tv_sec = 3;
-                        ts.tv_nsec = 0;
-
-                        gf_log (conn->name, GF_LOG_TRACE,
-                                "attempting reconnect");
-                        (void) rpc_transport_connect (trans,
-                                                      conn->config.remote_port);
-                        rpc_clnt_ref (clnt);
-                        conn->reconnect =
-                                gf_timer_call_after (clnt->ctx, ts,
-                                                     rpc_clnt_reconnect,
-                                                     conn);
-                        if (!conn->reconnect) {
-                                need_unref = _gf_true;
-                                gf_log (conn->name, GF_LOG_ERROR,
-                                        "Error adding to timer event queue");
-                        }
-                } else {
-                        gf_log (conn->name, GF_LOG_TRACE,
-                                "breaking reconnect chain");
-                }
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        rpc_clnt_unref (clnt);
-        if (need_unref)
-                rpc_clnt_unref (clnt);
-        return;
+    rpc_transport_t *trans = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    struct timespec ts = {0, 0};
+    struct rpc_clnt *clnt = NULL;
+    gf_boolean_t need_unref = _gf_false;
+    gf_boolean_t canceled_unref = _gf_false;
+
+    conn = conn_ptr;
+    clnt = conn->rpc_clnt;
+    pthread_mutex_lock(&conn->lock);
+    {
+        trans = conn->trans;
+        if (!trans)
+            goto out_unlock;
+
+        if (conn->reconnect) {
+            if (!gf_timer_call_cancel(clnt->ctx, conn->reconnect))
+                canceled_unref = _gf_true;
+        }
+        conn->reconnect = 0;
+
+        if ((conn->connected == 0) && !clnt->disabled) {
+            ts.tv_sec = 3;
+            ts.tv_nsec = 0;
+
+            gf_log(conn->name, GF_LOG_TRACE, "attempting reconnect");
+            (void)rpc_transport_connect(trans, conn->config.remote_port);
+            rpc_clnt_ref(clnt);
+            conn->reconnect = gf_timer_call_after(clnt->ctx, ts,
+                                                  rpc_clnt_reconnect, conn);
+            if (!conn->reconnect) {
+                need_unref = _gf_true;
+                gf_log(conn->name, GF_LOG_ERROR,
+                       "Error adding to timer event queue");
+            }
+        } else {
+            gf_log(conn->name, GF_LOG_TRACE, "breaking reconnect chain");
+        }
+    }
+out_unlock:
+    pthread_mutex_unlock(&conn->lock);
+
+    rpc_clnt_unref(clnt);
+    if (need_unref)
+        rpc_clnt_unref(clnt);
+    if (canceled_unref)
+        rpc_clnt_unref(clnt);
+    return;
 }
 
-
 int
-rpc_clnt_fill_request_info (struct rpc_clnt *clnt, rpc_request_info_t *info)
+rpc_clnt_fill_request_info(struct rpc_clnt *clnt, rpc_request_info_t *info)
 {
-        struct saved_frame  saved_frame;
-        int                 ret         = -1;
-
-        pthread_mutex_lock (&clnt->conn.lock);
-        {
-                ret = __saved_frame_copy (clnt->conn.saved_frames, info->xid,
-                                          &saved_frame);
-        }
-        pthread_mutex_unlock (&clnt->conn.lock);
-
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_CRITICAL,
-                        "cannot lookup the saved "
-                        "frame corresponding to xid (%d)", info->xid);
-                goto out;
-        }
-
-        info->prognum = saved_frame.rpcreq->prog->prognum;
-        info->procnum = saved_frame.rpcreq->procnum;
-        info->progver = saved_frame.rpcreq->prog->progver;
-        info->rpc_req = saved_frame.rpcreq;
-        info->rsp     = saved_frame.rsp;
-
-        ret = 0;
+    struct saved_frame saved_frame;
+    int ret = -1;
+
+    pthread_mutex_lock(&clnt->conn.lock);
+    {
+        ret = __saved_frame_copy(clnt->conn.saved_frames, info->xid,
+                                 &saved_frame);
+    }
+    pthread_mutex_unlock(&clnt->conn.lock);
+
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_CRITICAL,
+               "cannot lookup the saved "
+               "frame corresponding to xid (%d)",
+               info->xid);
+        goto out;
+    }
+
+    info->prognum = saved_frame.rpcreq->prog->prognum;
+    info->procnum = saved_frame.rpcreq->procnum;
+    info->progver = saved_frame.rpcreq->prog->progver;
+    info->rpc_req = saved_frame.rpcreq;
+    info->rsp = saved_frame.rsp;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_clnt_reconnect_cleanup (rpc_clnt_connection_t *conn)
+rpc_clnt_reconnect_cleanup(rpc_clnt_connection_t *conn)
 {
-        struct rpc_clnt         *clnt  = NULL;
-        int                      ret   = 0;
-        gf_boolean_t             reconnect_unref = _gf_false;
-
-        if (!conn) {
-                goto out;
-        }
-
-        clnt = conn->rpc_clnt;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (clnt->ctx, conn->reconnect);
-                        if (!ret) {
-                                reconnect_unref = _gf_true;
-                                conn->cleanup_gen++;
-                        }
-                        conn->reconnect = NULL;
-                }
-
+    struct rpc_clnt *clnt = NULL;
+    int ret = 0;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!conn) {
+        goto out;
+    }
+
+    clnt = conn->rpc_clnt;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(clnt->ctx, conn->reconnect);
+            if (!ret) {
+                reconnect_unref = _gf_true;
+                conn->cleanup_gen++;
+            }
+            conn->reconnect = NULL;
         }
-        pthread_mutex_unlock (&conn->lock);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (reconnect_unref)
-                rpc_clnt_unref (clnt);
+    if (reconnect_unref)
+        rpc_clnt_unref(clnt);
 
 out:
-        return 0;
+    return 0;
 }
 
 /*
@@ -502,53 +483,62 @@ out:
  *
  */
 int
-rpc_clnt_connection_cleanup (rpc_clnt_connection_t *conn)
+rpc_clnt_connection_cleanup(rpc_clnt_connection_t *conn)
 {
-        struct saved_frames    *saved_frames = NULL;
-        struct rpc_clnt         *clnt  = NULL;
-        int                     unref = 0;
-        int                     ret   = 0;
-        gf_boolean_t            timer_unref = _gf_false;
-
-        if (!conn) {
-                goto out;
-        }
-
-        clnt = conn->rpc_clnt;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-
-                saved_frames = conn->saved_frames;
-                conn->saved_frames = saved_frames_new ();
-
-                /* bailout logic cleanup */
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (clnt->ctx, conn->timer);
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
-
-                conn->connected = 0;
-
-                unref = rpc_clnt_remove_ping_timer_locked (clnt);
-                /*reset rpc msgs stats*/
-                conn->pingcnt = 0;
-                conn->msgcnt = 0;
-                conn->cleanup_gen++;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        saved_frames_destroy (saved_frames);
-        if (unref)
-                rpc_clnt_unref (clnt);
-
-        if (timer_unref)
-                rpc_clnt_unref (clnt);
-
+    struct saved_frames *saved_frames = NULL;
+    struct rpc_clnt *clnt = NULL;
+    int unref = 0;
+    int ret = 0;
+    gf_boolean_t timer_unref = _gf_false;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!conn) {
+        goto out;
+    }
+
+    clnt = conn->rpc_clnt;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        saved_frames = conn->saved_frames;
+        conn->saved_frames = saved_frames_new();
+
+        /* bailout logic cleanup */
+        if (conn->timer) {
+            ret = gf_timer_call_cancel(clnt->ctx, conn->timer);
+            if (!ret)
+                timer_unref = _gf_true;
+            conn->timer = NULL;
+        }
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(clnt->ctx, conn->reconnect);
+            if (!ret)
+                reconnect_unref = _gf_true;
+            conn->reconnect = NULL;
+        }
+
+        conn->connected = 0;
+        conn->disconnected = 1;
+
+        unref = rpc_clnt_remove_ping_timer_locked(clnt);
+        /*reset rpc msgs stats*/
+        conn->pingcnt = 0;
+        conn->msgcnt = 0;
+        conn->cleanup_gen++;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    saved_frames_destroy(saved_frames);
+    if (unref)
+        rpc_clnt_unref(clnt);
+
+    if (timer_unref)
+        rpc_clnt_unref(clnt);
+
+    if (reconnect_unref)
+        rpc_clnt_unref(clnt);
 out:
-        return 0;
+    return 0;
 }
 
 /*
@@ -560,438 +550,397 @@ out:
  */
 
 static struct saved_frame *
-lookup_frame (rpc_clnt_connection_t *conn, int64_t callid)
+lookup_frame(rpc_clnt_connection_t *conn, int64_t callid)
 {
-        struct saved_frame *frame = NULL;
+    struct saved_frame *frame = NULL;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                frame = __saved_frame_get (conn->saved_frames, callid);
-        }
-        pthread_mutex_unlock (&conn->lock);
+    pthread_mutex_lock(&conn->lock);
+    {
+        frame = __saved_frame_get(conn->saved_frames, callid);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        return frame;
+    return frame;
 }
 
-
 int
-rpc_clnt_reply_fill (rpc_transport_pollin_t *msg,
-                     rpc_clnt_connection_t *conn,
-                     struct rpc_msg *replymsg, struct iovec progmsg,
-                     struct rpc_req *req,
-                     struct saved_frame *saved_frame)
+rpc_clnt_reply_fill(rpc_transport_pollin_t *msg, rpc_clnt_connection_t *conn,
+                    struct rpc_msg *replymsg, struct iovec progmsg,
+                    struct rpc_req *req, struct saved_frame *saved_frame)
 {
-        int             ret   = -1;
-
-        if ((!conn) || (!replymsg)|| (!req) || (!saved_frame) || (!msg)) {
-                goto out;
-        }
-
-        req->rpc_status = 0;
-        if ((rpc_reply_status (replymsg) == MSG_DENIED)
-            || (rpc_accepted_reply_status (replymsg) != SUCCESS)) {
-                req->rpc_status = -1;
-        }
-
-        req->rsp[0] = progmsg;
-        req->rsp_iobref = iobref_ref (msg->iobref);
-
-        if (msg->vectored) {
-                req->rsp[1] = msg->vector[1];
-                req->rspcnt = 2;
-        } else {
-                req->rspcnt = 1;
-        }
-
-        /* By this time, the data bytes for the auth scheme would have already
-         * been copied into the required sections of the req structure,
-         * we just need to fill in the meta-data about it now.
+    int ret = -1;
+
+    if ((!conn) || (!replymsg) || (!req) || (!saved_frame) || (!msg)) {
+        goto out;
+    }
+
+    req->rpc_status = 0;
+    if ((rpc_reply_status(replymsg) == MSG_DENIED) ||
+        (rpc_accepted_reply_status(replymsg) != SUCCESS)) {
+        req->rpc_status = -1;
+    }
+
+    req->rsp[0] = progmsg;
+    req->rsp_iobref = iobref_ref(msg->iobref);
+
+    if (msg->vectored) {
+        req->rsp[1] = msg->vector[1];
+        req->rspcnt = 2;
+    } else {
+        req->rspcnt = 1;
+    }
+
+    /* By this time, the data bytes for the auth scheme would have already
+     * been copied into the required sections of the req structure,
+     * we just need to fill in the meta-data about it now.
+     */
+    if (req->rpc_status == 0) {
+        /*
+         * req->verf.flavour = rpc_reply_verf_flavour (replymsg);
+         * req->verf.datalen = rpc_reply_verf_len (replymsg);
          */
-        if (req->rpc_status == 0) {
-                /*
-                 * req->verf.flavour = rpc_reply_verf_flavour (replymsg);
-                 * req->verf.datalen = rpc_reply_verf_len (replymsg);
-                 */
-        }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool)
+rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool)
 {
-        if (!req) {
-                goto out;
-        }
+    if (!req) {
+        goto out;
+    }
 
-        if (req->rsp_iobref) {
-                iobref_unref (req->rsp_iobref);
-        }
+    if (req->rsp_iobref) {
+        iobref_unref(req->rsp_iobref);
+    }
 
-        mem_put (req);
+    mem_put(req);
 out:
-        return;
+    return;
 }
 
-
 /* TODO: use mem-pool for allocating requests */
 int
-rpc_clnt_reply_init (rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg,
-                     struct rpc_req *req, struct saved_frame *saved_frame)
+rpc_clnt_reply_init(rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg,
+                    struct rpc_req *req, struct saved_frame *saved_frame)
 {
-        char                    *msgbuf = NULL;
-        struct rpc_msg          rpcmsg;
-        struct iovec            progmsg;        /* RPC Program payload */
-        size_t                  msglen  = 0;
-        int                     ret     = -1;
-
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
-
-        ret = xdr_to_rpc_reply (msgbuf, msglen, &rpcmsg, &progmsg,
-                                req->verf.authdata);
-        if (ret != 0) {
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "RPC reply decoding failed");
-                goto out;
-        }
-
-        ret = rpc_clnt_reply_fill (msg, conn, &rpcmsg, progmsg, req,
-                                   saved_frame);
-        if (ret != 0) {
-                goto out;
-        }
-
-        gf_log (conn->name, GF_LOG_TRACE,
-                "received rpc message (RPC XID: 0x%x"
-                " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)",
-                saved_frame->rpcreq->xid,
-                saved_frame->rpcreq->prog->progname,
-                saved_frame->rpcreq->prog->progver,
-                saved_frame->rpcreq->procnum, conn->name);
+    char *msgbuf = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    size_t msglen = 0;
+    int ret = -1;
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    ret = xdr_to_rpc_reply(msgbuf, msglen, &rpcmsg, &progmsg,
+                           req->verf.authdata);
+    if (ret != 0) {
+        gf_log(conn->name, GF_LOG_WARNING, "RPC reply decoding failed");
+        goto out;
+    }
+
+    ret = rpc_clnt_reply_fill(msg, conn, &rpcmsg, progmsg, req, saved_frame);
+    if (ret != 0) {
+        goto out;
+    }
+
+    gf_log(conn->name, GF_LOG_TRACE,
+           "received rpc message (RPC XID: 0x%x"
+           " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)",
+           saved_frame->rpcreq->xid, saved_frame->rpcreq->prog->progname,
+           saved_frame->rpcreq->prog->progver, saved_frame->rpcreq->procnum,
+           conn->name);
 
 out:
-        if (ret != 0) {
-                req->rpc_status = -1;
-        }
+    if (ret != 0) {
+        req->rpc_status = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-rpc_clnt_handle_cbk (struct rpc_clnt *clnt, rpc_transport_pollin_t *msg)
+rpc_clnt_handle_cbk(struct rpc_clnt *clnt, rpc_transport_pollin_t *msg)
 {
-        char                 *msgbuf = NULL;
-        rpcclnt_cb_program_t *program = NULL;
-        struct rpc_msg        rpcmsg;
-        struct iovec          progmsg; /* RPC Program payload */
-        size_t                msglen = 0;
-        int                   found  = 0;
-        int                   ret    = -1;
-        int                   procnum = 0;
-
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
-
-        clnt = rpc_clnt_ref (clnt);
-        ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg, NULL,NULL);
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_WARNING,
-                        "RPC call decoding failed");
-                goto out;
-        }
-
-        gf_log (clnt->conn.name, GF_LOG_TRACE,
-		"receivd rpc message (XID: 0x%" GF_PRI_RPC_XID ", "
-		"Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-		"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                "from rpc-transport (%s)", rpc_call_xid (&rpcmsg),
-                rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                clnt->conn.name);
-
-        procnum = rpc_call_progproc (&rpcmsg);
-
-        pthread_mutex_lock (&clnt->lock);
+    char *msgbuf = NULL;
+    rpcclnt_cb_program_t *program = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    size_t msglen = 0;
+    int found = 0;
+    int ret = -1;
+    int procnum = 0;
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    clnt = rpc_clnt_ref(clnt);
+    ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, NULL, NULL);
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_WARNING, "RPC call decoding failed");
+        goto out;
+    }
+
+    gf_log(clnt->conn.name, GF_LOG_TRACE,
+           "receivd rpc message (XID: 0x%" GF_PRI_RPC_XID
+           ", "
+           "Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID
+           ", "
+           "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+           ") "
+           "from rpc-transport (%s)",
+           rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+           rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+           rpc_call_progproc(&rpcmsg), clnt->conn.name);
+
+    procnum = rpc_call_progproc(&rpcmsg);
+
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_for_each_entry(program, &clnt->programs, program)
         {
-                list_for_each_entry (program, &clnt->programs, program) {
-                        if ((program->prognum == rpc_call_program (&rpcmsg))
-                            && (program->progver
-                                == rpc_call_progver (&rpcmsg))) {
-                                found = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == rpc_call_program(&rpcmsg)) &&
+                (program->progver == rpc_call_progver(&rpcmsg))) {
+                found = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&clnt->lock);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        if (found && (procnum < program->numactors) &&
-            (program->actors[procnum].actor)) {
-                program->actors[procnum].actor (clnt, program->mydata,
-                                                &progmsg);
-        }
+    if (found && (procnum < program->numactors) &&
+        (program->actors[procnum].actor)) {
+        program->actors[procnum].actor(clnt, program->mydata, &progmsg);
+    }
 
 out:
-        rpc_clnt_unref (clnt);
-        return ret;
+    rpc_clnt_unref(clnt);
+    return ret;
 }
 
 int
-rpc_clnt_handle_reply (struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin)
+rpc_clnt_handle_reply(struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin)
 {
-        rpc_clnt_connection_t *conn         = NULL;
-        struct saved_frame    *saved_frame  = NULL;
-        int                    ret          = -1;
-        struct rpc_req        *req          = NULL;
-        uint32_t               xid          = 0;
-
-        clnt = rpc_clnt_ref (clnt);
-        conn = &clnt->conn;
-
-        xid = ntoh32 (*((uint32_t *)pollin->vector[0].iov_base));
-        saved_frame = lookup_frame (conn, xid);
-        if (saved_frame == NULL) {
-                gf_log (conn->name, GF_LOG_ERROR,
-                        "cannot lookup the saved frame for reply with xid (%u)",
-                        xid);
-                goto out;
-        }
-
-        req = saved_frame->rpcreq;
-        if (req == NULL) {
-                gf_log (conn->name, GF_LOG_ERROR,
-                        "no request with frame for xid (%u)", xid);
-                goto out;
-        }
-
-        ret = rpc_clnt_reply_init (conn, pollin, req, saved_frame);
-        if (ret != 0) {
-                req->rpc_status = -1;
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "initialising rpc reply failed");
-        }
-
-        req->cbkfn (req, req->rsp, req->rspcnt, saved_frame->frame);
-
-        if (req) {
-                rpc_clnt_reply_deinit (req, conn->rpc_clnt->reqpool);
-        }
+    rpc_clnt_connection_t *conn = NULL;
+    struct saved_frame *saved_frame = NULL;
+    int ret = -1;
+    struct rpc_req *req = NULL;
+    uint32_t xid = 0;
+
+    clnt = rpc_clnt_ref(clnt);
+    conn = &clnt->conn;
+
+    xid = ntoh32(*((uint32_t *)pollin->vector[0].iov_base));
+    saved_frame = lookup_frame(conn, xid);
+    if (saved_frame == NULL) {
+        gf_log(conn->name, GF_LOG_ERROR,
+               "cannot lookup the saved frame for reply with xid (%u)", xid);
+        goto out;
+    }
+
+    req = saved_frame->rpcreq;
+    if (req == NULL) {
+        gf_log(conn->name, GF_LOG_ERROR, "no request with frame for xid (%u)",
+               xid);
+        goto out;
+    }
+
+    ret = rpc_clnt_reply_init(conn, pollin, req, saved_frame);
+    if (ret != 0) {
+        req->rpc_status = -1;
+        gf_log(conn->name, GF_LOG_WARNING, "initialising rpc reply failed");
+    }
+
+    req->cbkfn(req, req->rsp, req->rspcnt, saved_frame->frame);
+
+    if (req) {
+        rpc_clnt_reply_deinit(req, conn->rpc_clnt->reqpool);
+    }
 out:
 
-        if (saved_frame) {
-                mem_put (saved_frame);
-        }
+    if (saved_frame) {
+        mem_put(saved_frame);
+    }
 
-        rpc_clnt_unref (clnt);
-        return ret;
-}
-
-
-void
-rpc_clnt_set_connected (rpc_clnt_connection_t *conn)
-{
-        if (!conn) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                conn->connected = 1;
-                conn->disconnected = _gf_false;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-out:
-        return;
-}
-
-
-void
-rpc_clnt_unset_connected (rpc_clnt_connection_t *conn)
-{
-        if (!conn) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                conn->connected = 0;
-                conn->disconnected = _gf_true;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-out:
-        return;
+    rpc_clnt_unref(clnt);
+    return ret;
 }
 
 gf_boolean_t
-is_rpc_clnt_disconnected (rpc_clnt_connection_t *conn)
+is_rpc_clnt_disconnected(rpc_clnt_connection_t *conn)
 {
-        gf_boolean_t disconnected = _gf_true;
+    gf_boolean_t disconnected = _gf_true;
 
-        if (!conn)
-                return disconnected;
+    if (!conn)
+        return disconnected;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (conn->disconnected == _gf_false)
-                        disconnected = _gf_false;
-        }
-        pthread_mutex_unlock (&conn->lock);
+    pthread_mutex_lock(&conn->lock);
+    {
+        disconnected = conn->disconnected;
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        return disconnected;
+    return disconnected;
 }
 
 static void
-rpc_clnt_destroy (struct rpc_clnt *rpc);
+rpc_clnt_destroy(struct rpc_clnt *rpc);
 
-#define RPC_THIS_SAVE(xl) do {                                  \
-        old_THIS = THIS ;                                       \
-        if (!old_THIS)                                          \
-                gf_log_callingfn ("rpc", GF_LOG_CRITICAL,       \
-                                  "THIS is not initialised.");  \
-        THIS = xl;                                              \
-} while (0)
+#define RPC_THIS_SAVE(xl)                                                      \
+    do {                                                                       \
+        old_THIS = THIS;                                                       \
+        if (!old_THIS)                                                         \
+            gf_log_callingfn("rpc", GF_LOG_CRITICAL,                           \
+                             "THIS is not initialised.");                      \
+        THIS = xl;                                                             \
+    } while (0)
 
-#define RPC_THIS_RESTORE        (THIS = old_THIS)
+#define RPC_THIS_RESTORE (THIS = old_THIS)
 
 static int
-rpc_clnt_handle_disconnect (struct rpc_clnt *clnt, rpc_clnt_connection_t *conn)
+rpc_clnt_handle_disconnect(struct rpc_clnt *clnt, rpc_clnt_connection_t *conn)
 {
-        struct timespec ts             = {0, };
-        gf_boolean_t    unref_clnt     = _gf_false;
-        uint64_t        pre_notify_gen = 0, post_notify_gen = 0;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                pre_notify_gen = conn->cleanup_gen;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (clnt->notifyfn)
-                clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL);
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                post_notify_gen = conn->cleanup_gen;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (pre_notify_gen == post_notify_gen) {
-                /* program didn't invoke cleanup, so rpc has to do it */
-                rpc_clnt_connection_cleanup (conn);
-        }
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) {
-                        ts.tv_sec = 10;
-                        ts.tv_nsec = 0;
-
-                        rpc_clnt_ref (clnt);
-                        conn->reconnect = gf_timer_call_after (clnt->ctx, ts,
-                                                rpc_clnt_reconnect, conn);
-                        if (conn->reconnect == NULL) {
-                                gf_log (conn->name, GF_LOG_WARNING,
-                                                "Cannot create rpc_clnt_reconnect timer");
-                                unref_clnt = _gf_true;
-                        }
-                }
+    struct timespec ts = {
+        0,
+    };
+    gf_boolean_t unref_clnt = _gf_false;
+    uint64_t pre_notify_gen = 0, post_notify_gen = 0;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        pre_notify_gen = conn->cleanup_gen;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (clnt->notifyfn)
+        clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        post_notify_gen = conn->cleanup_gen;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (pre_notify_gen == post_notify_gen) {
+        /* program didn't invoke cleanup, so rpc has to do it */
+        rpc_clnt_connection_cleanup(conn);
+    }
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) {
+            ts.tv_sec = 3;
+            ts.tv_nsec = 0;
+
+            rpc_clnt_ref(clnt);
+            conn->reconnect = gf_timer_call_after(clnt->ctx, ts,
+                                                  rpc_clnt_reconnect, conn);
+            if (conn->reconnect == NULL) {
+                gf_log(conn->name, GF_LOG_WARNING,
+                       "Cannot create rpc_clnt_reconnect timer");
+                unref_clnt = _gf_true;
+            }
         }
-        pthread_mutex_unlock (&conn->lock);
-
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (unref_clnt)
-                rpc_clnt_unref (clnt);
+    if (unref_clnt)
+        rpc_clnt_unref(clnt);
 
-        return 0;
+    return 0;
 }
 
 int
-rpc_clnt_notify (rpc_transport_t *trans, void *mydata,
-                 rpc_transport_event_t event, void *data, ...)
+rpc_clnt_notify(rpc_transport_t *trans, void *mydata,
+                rpc_transport_event_t event, void *data, ...)
 {
-        rpc_clnt_connection_t  *conn        = NULL;
-        struct rpc_clnt        *clnt        = NULL;
-        int                     ret         = -1;
-        rpc_request_info_t     *req_info    = NULL;
-        rpc_transport_pollin_t *pollin      = NULL;
-        void                   *clnt_mydata = NULL;
-        DECLARE_OLD_THIS;
-
-        conn = mydata;
-        if (conn == NULL) {
-                goto out;
-        }
-        clnt = conn->rpc_clnt;
-        if (!clnt)
-                goto out;
-
-        RPC_THIS_SAVE (clnt->owner);
-
-        switch (event) {
-        case RPC_TRANSPORT_DISCONNECT:
-        {
-                rpc_clnt_handle_disconnect (clnt, conn);
-                break;
+    rpc_clnt_connection_t *conn = NULL;
+    struct rpc_clnt *clnt = NULL;
+    int ret = -1;
+    rpc_request_info_t *req_info = NULL;
+    rpc_transport_pollin_t *pollin = NULL;
+    void *clnt_mydata = NULL;
+    DECLARE_OLD_THIS;
+
+    conn = mydata;
+    if (conn == NULL) {
+        goto out;
+    }
+    clnt = conn->rpc_clnt;
+    if (!clnt)
+        goto out;
+
+    RPC_THIS_SAVE(clnt->owner);
+
+    switch (event) {
+        case RPC_TRANSPORT_DISCONNECT: {
+            rpc_clnt_handle_disconnect(clnt, conn);
+            /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
+             *    if (clnt->auth_value)
+             *           clnt->auth_value = AUTH_GLUSTERFS_v2;
+             * It should not be reset here. The disconnect during
+             * portmap request can race with handshake. If handshake
+             * happens first and disconnect later, auth_value would set
+             * to default value and it never sets back to actual auth_value
+             * supported by server. But it's important to set to lower
+             * version supported in the case where the server downgrades.
+             * So moving this code to RPC_TRANSPORT_CONNECT. Note that
+             * CONNECT cannot race with handshake as by nature it is
+             * serialized with handhake. An handshake can happen only
+             * on a connected transport and hence its strictly serialized.
+             */
+            break;
         }
 
         case RPC_TRANSPORT_CLEANUP:
-                if (clnt->notifyfn) {
-                        clnt_mydata = clnt->mydata;
-                        clnt->mydata = NULL;
-                        ret = clnt->notifyfn (clnt, clnt_mydata,
-                                              RPC_CLNT_DESTROY, NULL);
+            if (clnt->notifyfn) {
+                clnt_mydata = clnt->mydata;
+                clnt->mydata = NULL;
+                ret = clnt->notifyfn(clnt, clnt_mydata, RPC_CLNT_DESTROY, NULL);
+                if (ret < 0) {
+                    gf_log(trans->name, GF_LOG_WARNING,
+                           "client notify handler returned error "
+                           "while handling RPC_CLNT_DESTROY");
                 }
-                rpc_clnt_destroy (clnt);
-                ret = 0;
-                break;
-
-        case RPC_TRANSPORT_MAP_XID_REQUEST:
-        {
-                req_info = data;
-                ret = rpc_clnt_fill_request_info (clnt, req_info);
-                break;
-        }
+            }
+            rpc_clnt_destroy(clnt);
+            ret = 0;
+            break;
 
-        case RPC_TRANSPORT_MSG_RECEIVED:
-        {
-                pthread_mutex_lock (&conn->lock);
-                {
-                        gettimeofday (&conn->last_received, NULL);
-                }
-                pthread_mutex_unlock (&conn->lock);
-
-                pollin = data;
-                if (pollin->is_reply)
-                        ret = rpc_clnt_handle_reply (clnt, pollin);
-                else
-                        ret = rpc_clnt_handle_cbk (clnt, pollin);
-                /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG,
-                 * data);
-                 */
-                break;
+        case RPC_TRANSPORT_MAP_XID_REQUEST: {
+            req_info = data;
+            ret = rpc_clnt_fill_request_info(clnt, req_info);
+            break;
         }
 
-        case RPC_TRANSPORT_MSG_SENT:
-        {
-                pthread_mutex_lock (&conn->lock);
-                {
-                        gettimeofday (&conn->last_sent, NULL);
-                }
-                pthread_mutex_unlock (&conn->lock);
+        case RPC_TRANSPORT_MSG_RECEIVED: {
+            timespec_now_realtime(&conn->last_received);
 
-                ret = 0;
-                break;
+            pollin = data;
+            if (pollin->is_reply)
+                ret = rpc_clnt_handle_reply(clnt, pollin);
+            else
+                ret = rpc_clnt_handle_cbk(clnt, pollin);
+            /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG,
+             * data);
+             */
+            break;
         }
 
-        case RPC_TRANSPORT_CONNECT:
-        {
+        case RPC_TRANSPORT_MSG_SENT: {
+            timespec_now_realtime(&conn->last_sent);
+            ret = 0;
+            break;
+        }
 
+        case RPC_TRANSPORT_CONNECT: {
+            pthread_mutex_lock(&conn->lock);
+            {
                 /* Every time there is a disconnection, processes
                  * should try to connect to 'glusterd' (ie, default
                  * port) or whichever port given as 'option remote-port'
@@ -999,1010 +948,1032 @@ rpc_clnt_notify (rpc_transport_t *trans, void *mydata,
                 /* Below code makes sure the (re-)configured port lasts
                  * for just one successful attempt */
                 conn->config.remote_port = 0;
+                conn->connected = 1;
+                conn->disconnected = 0;
+                pthread_cond_broadcast(&conn->cond);
+            }
+            pthread_mutex_unlock(&conn->lock);
 
-                if (clnt->notifyfn)
-                        ret = clnt->notifyfn (clnt, clnt->mydata,
-                                              RPC_CLNT_CONNECT, NULL);
+            /* auth value should be set to lower version available
+             * and will be set to appropriate version supported by
+             * server after the handshake.
+             */
+            if (clnt->auth_value)
+                clnt->auth_value = AUTH_GLUSTERFS_v2;
+            if (clnt->notifyfn)
+                ret = clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_CONNECT,
+                                     NULL);
 
-                break;
+            break;
         }
 
         case RPC_TRANSPORT_ACCEPT:
-                /* only meaningful on a server, no need of handling this event
-                 * in a client.
-                 */
-                ret = 0;
-                break;
-        }
+            /* only meaningful on a server, no need of handling this event
+             * in a client.
+             */
+            ret = 0;
+            break;
+
+        case RPC_TRANSPORT_EVENT_THREAD_DIED:
+            /* only meaningful on a server, no need of handling this event on a
+             * client */
+            ret = 0;
+            break;
+    }
 
 out:
-        RPC_THIS_RESTORE;
-        return ret;
+    RPC_THIS_RESTORE;
+    return ret;
 }
 
 static int
-rpc_clnt_connection_init (struct rpc_clnt *clnt, glusterfs_ctx_t *ctx,
-                          dict_t *options, char *name)
+rpc_clnt_connection_init(struct rpc_clnt *clnt, glusterfs_ctx_t *ctx,
+                         dict_t *options, char *name)
 {
-        int                    ret  = -1;
-        rpc_clnt_connection_t *conn = NULL;
-        rpc_transport_t       *trans = NULL;
+    int ret = -1;
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
 
-        conn = &clnt->conn;
-        pthread_mutex_init (&clnt->conn.lock, NULL);
+    conn = &clnt->conn;
+    pthread_mutex_init(&clnt->conn.lock, NULL);
+    pthread_cond_init(&clnt->conn.cond, NULL);
 
-        conn->name = gf_strdup (name);
-        if (!conn->name) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_get_int32 (options, "frame-timeout",
-                              &conn->frame_timeout);
-        if (ret >= 0) {
-                gf_log (name, GF_LOG_INFO,
-                        "setting frame-timeout to %d", conn->frame_timeout);
-        } else {
-                gf_log (name, GF_LOG_DEBUG,
-                        "defaulting frame-timeout to 30mins");
-                conn->frame_timeout = 1800;
-        }
-        conn->rpc_clnt = clnt;
-
-        ret = dict_get_int32 (options, "ping-timeout",
-                              &conn->ping_timeout);
-        if (ret >= 0) {
-                gf_log (name, GF_LOG_DEBUG,
-                        "setting ping-timeout to %d", conn->ping_timeout);
-        } else {
-                /*TODO: Once the epoll thread model is fixed,
-                  change the default ping-timeout to 30sec */
-                gf_log (name, GF_LOG_DEBUG,
-                        "disable ping-timeout");
-                conn->ping_timeout = 0;
-        }
-
-        trans = rpc_transport_load (ctx, options, name);
-        if (!trans) {
-                gf_log (name, GF_LOG_WARNING, "loading of new rpc-transport"
-                        " failed");
-                ret = -1;
-                goto out;
-        }
-        rpc_transport_ref (trans);
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                conn->trans = trans;
-                trans = NULL;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        ret = rpc_transport_register_notify (conn->trans, rpc_clnt_notify,
-                                             conn);
-        if (ret == -1) {
-                gf_log (name, GF_LOG_WARNING, "registering notify failed");
-                goto out;
-        }
-
-        conn->saved_frames = saved_frames_new ();
-        if (!conn->saved_frames) {
-                gf_log (name, GF_LOG_WARNING, "creation of saved_frames "
-                        "failed");
-                ret = -1;
-                goto out;
-        }
+    conn->name = gf_strdup(name);
+    if (!conn->name) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_int32(options, "frame-timeout", &conn->frame_timeout);
+    if (ret >= 0) {
+        gf_log(name, GF_LOG_INFO, "setting frame-timeout to %d",
+               conn->frame_timeout);
+    } else {
+        gf_log(name, GF_LOG_DEBUG, "defaulting frame-timeout to 30mins");
+        conn->frame_timeout = 1800;
+    }
+    conn->rpc_clnt = clnt;
+
+    ret = dict_get_int32(options, "ping-timeout", &conn->ping_timeout);
+    if (ret >= 0) {
+        gf_log(name, GF_LOG_DEBUG, "setting ping-timeout to %d",
+               conn->ping_timeout);
+    } else {
+        /*TODO: Once the epoll thread model is fixed,
+          change the default ping-timeout to 30sec */
+        gf_log(name, GF_LOG_DEBUG, "disable ping-timeout");
+        conn->ping_timeout = 0;
+    }
+
+    trans = rpc_transport_load(ctx, options, name);
+    if (!trans) {
+        gf_log(name, GF_LOG_WARNING,
+               "loading of new rpc-transport"
+               " failed");
+        ret = -1;
+        goto out;
+    }
+    rpc_transport_ref(trans);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        conn->trans = trans;
+        trans = NULL;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    ret = rpc_transport_register_notify(conn->trans, rpc_clnt_notify, conn);
+    if (ret == -1) {
+        gf_log(name, GF_LOG_WARNING, "registering notify failed");
+        goto out;
+    }
+
+    conn->saved_frames = saved_frames_new();
+    if (!conn->saved_frames) {
+        gf_log(name, GF_LOG_WARNING,
+               "creation of saved_frames "
+               "failed");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret) {
-                pthread_mutex_lock (&conn->lock);
-                {
-                        trans = conn->trans;
-                        conn->trans = NULL;
-                }
-                pthread_mutex_unlock (&conn->lock);
-                if (trans)
-                        rpc_transport_unref (trans);
-                //conn cleanup needs to be done since we might have failed to
-                // register notification.
-                rpc_clnt_connection_cleanup (conn);
-        }
-        return ret;
+    if (ret) {
+        pthread_mutex_lock(&conn->lock);
+        {
+            trans = conn->trans;
+            conn->trans = NULL;
+        }
+        pthread_mutex_unlock(&conn->lock);
+        if (trans)
+            rpc_transport_unref(trans);
+        // conn cleanup needs to be done since we might have failed to
+        // register notification.
+        rpc_clnt_connection_cleanup(conn);
+    }
+    return ret;
 }
 
 struct rpc_clnt *
-rpc_clnt_new (dict_t *options, xlator_t *owner, char *name,
-              uint32_t reqpool_size)
+rpc_clnt_new(dict_t *options, xlator_t *owner, char *name,
+             uint32_t reqpool_size)
 {
-        int                    ret  = -1;
-        struct rpc_clnt       *rpc  = NULL;
-        glusterfs_ctx_t       *ctx  = owner->ctx;
-
-
-        rpc = GF_CALLOC (1, sizeof (*rpc), gf_common_mt_rpcclnt_t);
-        if (!rpc) {
-                goto out;
-        }
-
-        pthread_mutex_init (&rpc->lock, NULL);
-        rpc->ctx = ctx;
-        rpc->owner = owner;
-        GF_ATOMIC_INIT (rpc->xid, 1);
-
-        if (!reqpool_size)
-                reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT;
-
-        rpc->reqpool = mem_pool_new (struct rpc_req, reqpool_size);
-        if (rpc->reqpool == NULL) {
-                pthread_mutex_destroy (&rpc->lock);
-                GF_FREE (rpc);
-                rpc = NULL;
-                goto out;
-        }
-
-        rpc->saved_frames_pool = mem_pool_new (struct saved_frame,
-                                               reqpool_size);
-        if (rpc->saved_frames_pool == NULL) {
-                pthread_mutex_destroy (&rpc->lock);
-                mem_pool_destroy (rpc->reqpool);
-                GF_FREE (rpc);
-                rpc = NULL;
-                goto out;
-        }
-
-        ret = rpc_clnt_connection_init (rpc, ctx, options, name);
-        if (ret == -1) {
-                pthread_mutex_destroy (&rpc->lock);
-                mem_pool_destroy (rpc->reqpool);
-                mem_pool_destroy (rpc->saved_frames_pool);
-                GF_FREE (rpc);
-                rpc = NULL;
-                if (options)
-                        dict_unref (options);
-                goto out;
-        }
-
-        rpc->auth_null = dict_get_str_boolean (options, "auth-null", 0);
-
-        rpc = rpc_clnt_ref (rpc);
-        INIT_LIST_HEAD (&rpc->programs);
+    int ret = -1;
+    struct rpc_clnt *rpc = NULL;
+    glusterfs_ctx_t *ctx = owner->ctx;
+
+    rpc = GF_CALLOC(1, sizeof(*rpc), gf_common_mt_rpcclnt_t);
+    if (!rpc) {
+        goto out;
+    }
+
+    pthread_mutex_init(&rpc->lock, NULL);
+    rpc->ctx = ctx;
+    rpc->owner = owner;
+    GF_ATOMIC_INIT(rpc->xid, 1);
+
+    if (!reqpool_size)
+        reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT;
+
+    rpc->reqpool = mem_pool_new(struct rpc_req, reqpool_size);
+    if (rpc->reqpool == NULL) {
+        pthread_mutex_destroy(&rpc->lock);
+        GF_FREE(rpc);
+        rpc = NULL;
+        goto out;
+    }
+
+    rpc->saved_frames_pool = mem_pool_new(struct saved_frame, reqpool_size);
+    if (rpc->saved_frames_pool == NULL) {
+        pthread_mutex_destroy(&rpc->lock);
+        mem_pool_destroy(rpc->reqpool);
+        GF_FREE(rpc);
+        rpc = NULL;
+        goto out;
+    }
+
+    ret = rpc_clnt_connection_init(rpc, ctx, options, name);
+    if (ret == -1) {
+        pthread_mutex_destroy(&rpc->lock);
+        mem_pool_destroy(rpc->reqpool);
+        mem_pool_destroy(rpc->saved_frames_pool);
+        GF_FREE(rpc);
+        rpc = NULL;
+        goto out;
+    }
+
+    /* This is handled to make sure we have modularity in getting the
+       auth data changed */
+    gf_boolean_t auth_null = dict_get_str_boolean(options, "auth-null", 0);
+
+    rpc->auth_value = (auth_null) ? 0 : AUTH_GLUSTERFS_v2;
+
+    rpc = rpc_clnt_ref(rpc);
+    INIT_LIST_HEAD(&rpc->programs);
 
 out:
-        return rpc;
+    return rpc;
 }
 
-
 int
-rpc_clnt_start (struct rpc_clnt *rpc)
+rpc_clnt_start(struct rpc_clnt *rpc)
 {
-        struct rpc_clnt_connection *conn = NULL;
+    struct rpc_clnt_connection *conn = NULL;
 
-        if (!rpc)
-                return -1;
+    if (!rpc)
+        return -1;
 
-        conn = &rpc->conn;
+    conn = &rpc->conn;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 0;
-        }
-        pthread_mutex_unlock (&conn->lock);
-        /* Corresponding unref will be either on successful timer cancel or last
-         * rpc_clnt_reconnect fire event.
-         */
-        rpc_clnt_ref (rpc);
-        rpc_clnt_reconnect (conn);
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 0;
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /* Corresponding unref will be either on successful timer cancel or last
+     * rpc_clnt_reconnect fire event.
+     */
+    rpc_clnt_ref(rpc);
+    rpc_clnt_reconnect(conn);
 
-        return 0;
+    return 0;
 }
 
-
 int
-rpc_clnt_cleanup_and_start (struct rpc_clnt *rpc)
+rpc_clnt_cleanup_and_start(struct rpc_clnt *rpc)
 {
-        struct rpc_clnt_connection *conn = NULL;
+    struct rpc_clnt_connection *conn = NULL;
 
-        if (!rpc)
-                return -1;
+    if (!rpc)
+        return -1;
 
-        conn = &rpc->conn;
+    conn = &rpc->conn;
 
-        rpc_clnt_connection_cleanup (conn);
+    rpc_clnt_connection_cleanup(conn);
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 0;
-        }
-        pthread_mutex_unlock (&conn->lock);
-        /* Corresponding unref will be either on successful timer cancel or last
-         * rpc_clnt_reconnect fire event.
-         */
-        rpc_clnt_ref (rpc);
-        rpc_clnt_reconnect (conn);
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 0;
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /* Corresponding unref will be either on successful timer cancel or last
+     * rpc_clnt_reconnect fire event.
+     */
+    rpc_clnt_ref(rpc);
+    rpc_clnt_reconnect(conn);
 
-        return 0;
+    return 0;
 }
 
-
 int
-rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
-                          void *mydata)
+rpc_clnt_register_notify(struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
+                         void *mydata)
 {
-        rpc->mydata = mydata;
-        rpc->notifyfn = fn;
+    rpc->mydata = mydata;
+    rpc->notifyfn = fn;
 
-        return 0;
+    return 0;
 }
 
 /* used for GF_LOG_OCCASIONALLY() */
 static int gf_auth_max_groups_log = 0;
 
-ssize_t
-xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms_v2 *au)
+static inline int
+setup_glusterfs_auth_param_v3(call_frame_t *frame, auth_glusterfs_params_v3 *au,
+                              int lk_owner_len, char *owner_data)
 {
-        ssize_t ret = -1;
-        XDR     xdr;
-        u_long  ngroups = 0;
-        int     max_groups = 0;
-
-        if ((!dest) || (!au))
-                return -1;
-
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (au->lk_owner.lk_owner_len);
-
-        xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE);
-
-        if (au->groups.groups_len > max_groups) {
-                ngroups = au->groups.groups_len;
-                au->groups.groups_len = max_groups;
-
-                GF_LOG_OCCASIONALLY (gf_auth_max_groups_log,
-                                     THIS->name, GF_LOG_WARNING,
-                                     "too many groups, reducing %ld -> %d",
-                                     ngroups, max_groups);
-        }
+    int ret = -1;
+    unsigned int max_groups = 0;
+    int max_lkowner_len = 0;
+
+    au->pid = frame->root->pid;
+    au->uid = frame->root->uid;
+    au->gid = frame->root->gid;
+
+    au->flags = frame->root->flags;
+    au->ctime_sec = frame->root->ctime.tv_sec;
+    au->ctime_nsec = frame->root->ctime.tv_nsec;
+
+    au->lk_owner.lk_owner_val = owner_data;
+    au->lk_owner.lk_owner_len = lk_owner_len;
+    au->groups.groups_val = frame->root->groups;
+    au->groups.groups_len = frame->root->ngrps;
+
+    /* The number of groups and the size of lk_owner depend on oneother.
+     * We can truncate the groups, but should not touch the lk_owner. */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v3);
+    if (au->groups.groups_len > max_groups) {
+        GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING,
+                            "truncating grouplist "
+                            "from %d to %d",
+                            au->groups.groups_len, max_groups);
+
+        au->groups.groups_len = max_groups;
+    }
+
+    max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len,
+                                                    AUTH_GLUSTERFS_v3);
+    if (lk_owner_len > max_lkowner_len) {
+        gf_log("rpc-clnt", GF_LOG_ERROR,
+               "lkowner field is too "
+               "big (%d), it does not fit in the rpc-header",
+               au->lk_owner.lk_owner_len);
+        errno = E2BIG;
+        goto out;
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
 
-        if (!xdr_auth_glusterfs_parms_v2 (&xdr, au)) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to encode auth glusterfs elements");
-                ret = -1;
-                goto ret;
-        }
+static inline int
+setup_glusterfs_auth_param_v2(call_frame_t *frame, auth_glusterfs_parms_v2 *au,
+                              int lk_owner_len, char *owner_data)
+{
+    unsigned int max_groups = 0;
+    int max_lkowner_len = 0;
+    int ret = -1;
+
+    au->pid = frame->root->pid;
+    au->uid = frame->root->uid;
+    au->gid = frame->root->gid;
+
+    au->lk_owner.lk_owner_val = owner_data;
+    au->lk_owner.lk_owner_len = lk_owner_len;
+    au->groups.groups_val = frame->root->groups;
+    au->groups.groups_len = frame->root->ngrps;
+
+    /* The number of groups and the size of lk_owner depend on oneother.
+     * We can truncate the groups, but should not touch the lk_owner. */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v2);
+    if (au->groups.groups_len > max_groups) {
+        GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING,
+                            "truncating grouplist "
+                            "from %d to %d",
+                            au->groups.groups_len, max_groups);
+
+        au->groups.groups_len = max_groups;
+    }
+
+    max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len,
+                                                    AUTH_GLUSTERFS_v2);
+    if (lk_owner_len > max_lkowner_len) {
+        gf_log("rpc-auth", GF_LOG_ERROR,
+               "lkowner field is too "
+               "big (%d), it does not fit in the rpc-header",
+               au->lk_owner.lk_owner_len);
+        errno = E2BIG;
+        goto out;
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
 
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+static ssize_t
+xdr_serialize_glusterfs_auth(struct rpc_clnt *clnt, call_frame_t *frame,
+                             char *dest)
+{
+    ssize_t ret = -1;
+    XDR xdr;
+    char owner[4] = {
+        0,
+    };
+    int32_t pid = 0;
+    char *lk_owner_data = NULL;
+    int lk_owner_len = 0;
+
+    if ((!dest))
+        return -1;
+
+    xdrmem_create(&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE);
+
+    if (frame->root->lk_owner.len) {
+        lk_owner_data = frame->root->lk_owner.data;
+        lk_owner_len = frame->root->lk_owner.len;
+    } else {
+        pid = frame->root->pid;
+        owner[0] = (char)(pid & 0xff);
+        owner[1] = (char)((pid >> 8) & 0xff);
+        owner[2] = (char)((pid >> 16) & 0xff);
+        owner[3] = (char)((pid >> 24) & 0xff);
+
+        lk_owner_data = owner;
+        lk_owner_len = 4;
+    }
+
+    if (clnt->auth_value == AUTH_GLUSTERFS_v2) {
+        auth_glusterfs_parms_v2 au_v2 = {
+            0,
+        };
+
+        ret = setup_glusterfs_auth_param_v2(frame, &au_v2, lk_owner_len,
+                                            lk_owner_data);
+        if (ret)
+            goto out;
+        if (!xdr_auth_glusterfs_parms_v2(&xdr, &au_v2)) {
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "failed to encode auth glusterfs elements");
+            ret = -1;
+            goto out;
+        }
+    } else if (clnt->auth_value == AUTH_GLUSTERFS_v3) {
+        auth_glusterfs_params_v3 au_v3 = {
+            0,
+        };
+
+        ret = setup_glusterfs_auth_param_v3(frame, &au_v3, lk_owner_len,
+                                            lk_owner_data);
+        if (ret)
+            goto out;
+
+        if (!xdr_auth_glusterfs_params_v3(&xdr, &au_v3)) {
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "failed to encode auth glusterfs elements");
+            ret = -1;
+            goto out;
+        }
+    } else {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to encode auth glusterfs elements");
+        ret = -1;
+        goto out;
+    }
 
-ret:
-        if (ngroups)
-                au->groups.groups_len = ngroups;
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 
-        return ret;
+out:
+    return ret;
 }
 
-
 int
-rpc_clnt_fill_request (int prognum, int progver, int procnum,
-                       uint64_t xid, struct auth_glusterfs_parms_v2 *au,
-                       struct rpc_msg *request, char *auth_data)
+rpc_clnt_fill_request(struct rpc_clnt *clnt, int prognum, int progver,
+                      int procnum, uint64_t xid, call_frame_t *fr,
+                      struct rpc_msg *request, char *auth_data)
 {
-        int   ret          = -1;
+    int ret = -1;
 
-        if (!request) {
-                goto out;
-        }
+    if (!request) {
+        goto out;
+    }
 
-        memset (request, 0, sizeof (*request));
+    memset(request, 0, sizeof(*request));
 
-        request->rm_xid = xid;
-        request->rm_direction = CALL;
+    request->rm_xid = xid;
+    request->rm_direction = CALL;
 
-        request->rm_call.cb_rpcvers = 2;
-        request->rm_call.cb_prog = prognum;
-        request->rm_call.cb_vers = progver;
-        request->rm_call.cb_proc = procnum;
+    request->rm_call.cb_rpcvers = 2;
+    request->rm_call.cb_prog = prognum;
+    request->rm_call.cb_vers = progver;
+    request->rm_call.cb_proc = procnum;
 
-        /* TODO: Using AUTH_(GLUSTERFS/NULL) in a kludgy way for time-being.
-         * Make it modular in future so it is easy to plug-in new
-         * authentication schemes.
-         */
-        if (auth_data) {
-                ret = xdr_serialize_glusterfs_auth (auth_data, au);
-                if (ret == -1) {
-                        gf_log ("rpc-clnt", GF_LOG_DEBUG,
-                                "cannot encode credentials");
-                        goto out;
-                }
-
-                request->rm_call.cb_cred.oa_flavor = AUTH_GLUSTERFS_v2;
-                request->rm_call.cb_cred.oa_base   = auth_data;
-                request->rm_call.cb_cred.oa_length = ret;
-        } else {
-                request->rm_call.cb_cred.oa_flavor = AUTH_NULL;
-                request->rm_call.cb_cred.oa_base   = NULL;
-                request->rm_call.cb_cred.oa_length = 0;
+    if (!clnt->auth_value) {
+        request->rm_call.cb_cred.oa_flavor = AUTH_NULL;
+        request->rm_call.cb_cred.oa_base = NULL;
+        request->rm_call.cb_cred.oa_length = 0;
+    } else {
+        ret = xdr_serialize_glusterfs_auth(clnt, fr, auth_data);
+        if (ret == -1) {
+            gf_log("rpc-clnt", GF_LOG_WARNING,
+                   "cannot encode auth credentials");
+            goto out;
         }
-        request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_verf.oa_base = NULL;
-        request->rm_call.cb_verf.oa_length = 0;
 
-        ret = 0;
+        request->rm_call.cb_cred.oa_flavor = clnt->auth_value;
+        request->rm_call.cb_cred.oa_base = auth_data;
+        request->rm_call.cb_cred.oa_length = ret;
+    }
+    request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_verf.oa_base = NULL;
+    request->rm_call.cb_verf.oa_length = 0;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 struct iovec
-rpc_clnt_record_build_header (char *recordstart, size_t rlen,
-                              struct rpc_msg *request, size_t payload)
+rpc_clnt_record_build_header(char *recordstart, size_t rlen,
+                             struct rpc_msg *request, size_t payload)
 {
-        struct iovec    requesthdr = {0, };
-        struct iovec    txrecord   = {0, 0};
-        int             ret        = -1;
-        size_t          fraglen    = 0;
-
-        ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr);
-        if (ret == -1) {
-                gf_log ("rpc-clnt", GF_LOG_DEBUG,
-                        "Failed to create RPC request");
-                goto out;
-        }
-
-        fraglen = payload + requesthdr.iov_len;
-        gf_log ("rpc-clnt", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len);
-
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = requesthdr.iov_len;
+    struct iovec requesthdr = {
+        0,
+    };
+    struct iovec txrecord = {0, 0};
+    int ret = -1;
+    size_t fraglen = 0;
+
+    ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr);
+    if (ret == -1) {
+        gf_log("rpc-clnt", GF_LOG_DEBUG, "Failed to create RPC request");
+        goto out;
+    }
+
+    fraglen = payload + requesthdr.iov_len;
+    gf_log("rpc-clnt", GF_LOG_TRACE,
+           "Request fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, requesthdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = requesthdr.iov_len;
 
 out:
-        return txrecord;
+    return txrecord;
 }
 
-
 struct iobuf *
-rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver,
-                              int procnum, size_t hdrsize, uint64_t xid,
-                              struct auth_glusterfs_parms_v2 *au,
-                              struct iovec *recbuf)
+rpc_clnt_record_build_record(struct rpc_clnt *clnt, call_frame_t *fr,
+                             int prognum, int progver, int procnum,
+                             size_t hdrsize, uint64_t xid, struct iovec *recbuf)
 {
-        struct rpc_msg  request                      = {0, };
-        struct iobuf   *request_iob                  = NULL;
-        char           *record                       = NULL;
-        struct iovec    recordhdr                    = {0, };
-        size_t          pagesize                     = 0;
-        int             ret                          = -1;
-        size_t          xdr_size                     = 0;
-        char            auth_data[GF_MAX_AUTH_BYTES] = {0, };
-
-        if ((!clnt) || (!recbuf) || (!au)) {
-                goto out;
-        }
-
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        if (clnt->auth_null)
-                ret = rpc_clnt_fill_request (prognum, progver, procnum,
-                                             xid, NULL, &request, NULL);
-        else
-                ret = rpc_clnt_fill_request (prognum, progver, procnum,
-                                             xid, au, &request, auth_data);
-
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_WARNING,
-                        "cannot build a rpc-request xid (%"PRIu64")", xid);
-                goto out;
-        }
-
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request);
-
-        /* First, try to get a pointer into the buffer which the RPC
-         * layer can use.
-         */
-        request_iob = iobuf_get2 (clnt->ctx->iobuf_pool, (xdr_size + hdrsize));
-        if (!request_iob) {
-                goto out;
-        }
-
-        pagesize = iobuf_pagesize (request_iob);
-
-        record = iobuf_ptr (request_iob);  /* Now we have it. */
-
-        recordhdr = rpc_clnt_record_build_header (record, pagesize, &request,
-                                                  hdrsize);
-
-        if (!recordhdr.iov_base) {
-                gf_log (clnt->conn.name, GF_LOG_ERROR,
-                        "Failed to build record header");
-                iobuf_unref (request_iob);
-                request_iob = NULL;
-                recbuf->iov_base = NULL;
-                goto out;
-        }
-
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+    struct rpc_msg request = {
+        0,
+    };
+    struct iobuf *request_iob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    int ret = -1;
+    size_t xdr_size = 0;
+    char auth_data[GF_MAX_AUTH_BYTES] = {
+        0,
+    };
+
+    if ((!clnt) || (!recbuf)) {
+        goto out;
+    }
+
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpc_clnt_fill_request(clnt, prognum, progver, procnum, xid, fr,
+                                &request, auth_data);
+
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_WARNING,
+               "cannot build a rpc-request xid (%" PRIu64 ")", xid);
+        goto out;
+    }
+
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request);
+
+    /* First, try to get a pointer into the buffer which the RPC
+     * layer can use.
+     */
+    request_iob = iobuf_get2(clnt->ctx->iobuf_pool, (xdr_size + hdrsize));
+    if (!request_iob) {
+        goto out;
+    }
+
+    pagesize = iobuf_pagesize(request_iob);
+
+    record = iobuf_ptr(request_iob); /* Now we have it. */
+
+    recordhdr = rpc_clnt_record_build_header(record, pagesize, &request,
+                                             hdrsize);
+
+    if (!recordhdr.iov_base) {
+        gf_log(clnt->conn.name, GF_LOG_ERROR, "Failed to build record header");
+        iobuf_unref(request_iob);
+        request_iob = NULL;
+        recbuf->iov_base = NULL;
+        goto out;
+    }
+
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 
 out:
-        return request_iob;
+    return request_iob;
 }
 
-
-struct iobuf *
-rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame,
-                 rpc_clnt_prog_t *prog, int procnum, size_t hdrlen,
-                 struct iovec *rpchdr, uint64_t callid)
+static inline struct iobuf *
+rpc_clnt_record(struct rpc_clnt *clnt, call_frame_t *call_frame,
+                rpc_clnt_prog_t *prog, int procnum, size_t hdrlen,
+                struct iovec *rpchdr, uint64_t callid)
 {
-        struct auth_glusterfs_parms_v2  au          = {0, };
-        struct iobuf                   *request_iob = NULL;
-        char                            owner[4] = {0,};
-        int                             max_groups = 0;
-        int                             max_lkowner_len = 0;
-
-        if (!prog || !rpchdr || !call_frame) {
-                goto out;
-        }
+    if (!prog || !rpchdr || !call_frame) {
+        return NULL;
+    }
 
-        au.pid                   = call_frame->root->pid;
-        au.uid                   = call_frame->root->uid;
-        au.gid                   = call_frame->root->gid;
-        au.groups.groups_len     = call_frame->root->ngrps;
-        au.lk_owner.lk_owner_len = call_frame->root->lk_owner.len;
-
-        if (au.groups.groups_len)
-                au.groups.groups_val = call_frame->root->groups;
-
-        if (call_frame->root->lk_owner.len)
-                au.lk_owner.lk_owner_val = call_frame->root->lk_owner.data;
-        else {
-                owner[0] = (char)(au.pid & 0xff);
-                owner[1] = (char)((au.pid >> 8) & 0xff);
-                owner[2] = (char)((au.pid >> 16) & 0xff);
-                owner[3] = (char)((au.pid >> 24) & 0xff);
-
-                au.lk_owner.lk_owner_val = owner;
-                au.lk_owner.lk_owner_len = 4;
-        }
-
-        /* The number of groups and the size of lk_owner depend on oneother.
-         * We can truncate the groups, but should not touch the lk_owner. */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (au.lk_owner.lk_owner_len);
-        if (au.groups.groups_len > max_groups) {
-                GF_LOG_OCCASIONALLY (gf_auth_max_groups_log, clnt->conn.name,
-                                     GF_LOG_WARNING, "truncating grouplist "
-                                     "from %d to %d", au.groups.groups_len,
-                                     max_groups);
-
-                au.groups.groups_len = max_groups;
-        }
-
-        max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (au.groups.groups_len);
-        if (au.lk_owner.lk_owner_len > max_lkowner_len) {
-                gf_log (clnt->conn.name, GF_LOG_ERROR, "lkowner field is too "
-                        "big (%d), it does not fit in the rpc-header",
-                        au.lk_owner.lk_owner_len);
-                errno = E2BIG;
-                goto out;
-        }
-
-        gf_log (clnt->conn.name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s", au.pid, au.uid, au.gid,
-                lkowner_utoa (&call_frame->root->lk_owner));
-
-        request_iob = rpc_clnt_record_build_record (clnt, prog->prognum,
-                                                    prog->progver,
-                                                    procnum, hdrlen,
-                                                    callid, &au,
-                                                    rpchdr);
-        if (!request_iob) {
-                gf_log (clnt->conn.name, GF_LOG_WARNING,
-                        "cannot build rpc-record");
-                goto out;
-        }
-
-out:
-        return request_iob;
+    return rpc_clnt_record_build_record(clnt, call_frame, prog->prognum,
+                                        prog->progver, procnum, hdrlen, callid,
+                                        rpchdr);
 }
 
 int
-rpcclnt_cbk_program_register (struct rpc_clnt *clnt,
-                              rpcclnt_cb_program_t *program, void *mydata)
+rpcclnt_cbk_program_register(struct rpc_clnt *clnt,
+                             rpcclnt_cb_program_t *program, void *mydata)
 {
-        int                   ret                = -1;
-        char                  already_registered = 0;
-        rpcclnt_cb_program_t *tmp                = NULL;
+    int ret = -1;
+    char already_registered = 0;
+    rpcclnt_cb_program_t *tmp = NULL;
 
-        if (!clnt)
-                goto out;
+    if (!clnt)
+        goto out;
 
-        if (program->actors == NULL)
-                goto out;
+    if (program->actors == NULL)
+        goto out;
 
-        pthread_mutex_lock (&clnt->lock);
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_for_each_entry(tmp, &clnt->programs, program)
         {
-                list_for_each_entry (tmp, &clnt->programs, program) {
-                        if ((program->prognum == tmp->prognum)
-                            && (program->progver == tmp->progver)) {
-                                already_registered = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == tmp->prognum) &&
+                (program->progver == tmp->progver)) {
+                already_registered = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&clnt->lock);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        if (already_registered) {
-                gf_log_callingfn (clnt->conn.name, GF_LOG_DEBUG,
-                                  "already registered");
-                ret = 0;
-                goto out;
-        }
+    if (already_registered) {
+        gf_log_callingfn(clnt->conn.name, GF_LOG_DEBUG, "already registered");
+        ret = 0;
+        goto out;
+    }
 
-        tmp = GF_CALLOC (1, sizeof (*tmp),
-                         gf_common_mt_rpcclnt_cb_program_t);
-        if (tmp == NULL) {
-                goto out;
-        }
+    tmp = GF_MALLOC(sizeof(*tmp), gf_common_mt_rpcclnt_cb_program_t);
+    if (tmp == NULL) {
+        goto out;
+    }
 
-        memcpy (tmp, program, sizeof (*tmp));
-        INIT_LIST_HEAD (&tmp->program);
+    memcpy(tmp, program, sizeof(*tmp));
+    INIT_LIST_HEAD(&tmp->program);
 
-        tmp->mydata = mydata;
+    tmp->mydata = mydata;
 
-        pthread_mutex_lock (&clnt->lock);
-        {
-                list_add_tail (&tmp->program, &clnt->programs);
-        }
-        pthread_mutex_unlock (&clnt->lock);
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_add_tail(&tmp->program, &clnt->programs);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        ret = 0;
-        gf_log (clnt->conn.name, GF_LOG_DEBUG,
-                "New program registered: %s, Num: %d, Ver: %d",
-                program->progname, program->prognum,
-                program->progver);
+    ret = 0;
+    gf_log(clnt->conn.name, GF_LOG_DEBUG,
+           "New program registered: %s, Num: %d, Ver: %d", program->progname,
+           program->prognum, program->progver);
 
 out:
-        if (ret == -1 && clnt) {
-                        gf_log (clnt->conn.name, GF_LOG_ERROR,
-                                        "Program registration failed:"
-                                        " %s, Num: %d, Ver: %d",
-                                        program->progname,
-                                        program->prognum, program->progver);
-        }
-
-        return ret;
+    if (ret == -1 && clnt) {
+        gf_log(clnt->conn.name, GF_LOG_ERROR,
+               "Program registration failed:"
+               " %s, Num: %d, Ver: %d",
+               program->progname, program->prognum, program->progver);
+    }
+
+    return ret;
 }
 
-
 int
-rpc_clnt_submit (struct rpc_clnt *rpc, rpc_clnt_prog_t *prog,
-                 int procnum, fop_cbk_fn_t cbkfn,
-                 struct iovec *proghdr, int proghdrcount,
-                 struct iovec *progpayload, int progpayloadcount,
-                 struct iobref *iobref, void *frame, struct iovec *rsphdr,
-                 int rsphdr_count, struct iovec *rsp_payload,
-                 int rsp_payload_count, struct iobref *rsp_iobref)
+rpc_clnt_submit(struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, int procnum,
+                fop_cbk_fn_t cbkfn, struct iovec *proghdr, int proghdrcount,
+                struct iovec *progpayload, int progpayloadcount,
+                struct iobref *iobref, void *frame, struct iovec *rsphdr,
+                int rsphdr_count, struct iovec *rsp_payload,
+                int rsp_payload_count, struct iobref *rsp_iobref)
 {
-        rpc_clnt_connection_t *conn        = NULL;
-        struct iobuf          *request_iob = NULL;
-        struct iovec           rpchdr      = {0,};
-        struct rpc_req        *rpcreq      = NULL;
-        rpc_transport_req_t    req;
-        int                    ret         = -1;
-        int                    proglen     = 0;
-        char                   new_iobref  = 0;
-        uint64_t               callid      = 0;
-        gf_boolean_t           need_unref  = _gf_false;
-
-        if (!rpc || !prog || !frame) {
-                goto out;
-        }
-
-        conn = &rpc->conn;
-
-        rpcreq = mem_get (rpc->reqpool);
-        if (rpcreq == NULL) {
-                goto out;
-        }
-
-        memset (rpcreq, 0, sizeof (*rpcreq));
-        memset (&req, 0, sizeof (req));
-
+    rpc_clnt_connection_t *conn = NULL;
+    struct iobuf *request_iob = NULL;
+    struct iovec rpchdr = {
+        0,
+    };
+    struct rpc_req *rpcreq = NULL;
+    rpc_transport_req_t req;
+    int ret = -1;
+    int proglen = 0;
+    char new_iobref = 0;
+    uint64_t callid = 0;
+    gf_boolean_t need_unref = _gf_false;
+    call_frame_t *cframe = frame;
+
+    if (!rpc || !prog || !frame) {
+        goto out;
+    }
+
+    conn = &rpc->conn;
+
+    rpcreq = mem_get(rpc->reqpool);
+    if (rpcreq == NULL) {
+        goto out;
+    }
+
+    memset(rpcreq, 0, sizeof(*rpcreq));
+    memset(&req, 0, sizeof(req));
+
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        goto out;
-                }
-
-                new_iobref = 1;
-        }
-
-        callid = GF_ATOMIC_INC (rpc->xid);
-
-        rpcreq->prog = prog;
-        rpcreq->procnum = procnum;
-        rpcreq->conn = conn;
-        rpcreq->xid = callid;
-        rpcreq->cbkfn = cbkfn;
-
-        ret = -1;
-
-        if (proghdr) {
-                proglen += iov_length (proghdr, proghdrcount);
-        }
-
-        request_iob = rpc_clnt_record (rpc, frame, prog,
-                                       procnum, proglen,
-                                       &rpchdr, callid);
-        if (!request_iob) {
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "cannot build rpc-record");
-                goto out;
-        }
-
-        iobref_add (iobref, request_iob);
-
-        req.msg.rpchdr = &rpchdr;
-        req.msg.rpchdrcount = 1;
-        req.msg.proghdr = proghdr;
-        req.msg.proghdrcount = proghdrcount;
-        req.msg.progpayload = progpayload;
-        req.msg.progpayloadcount = progpayloadcount;
-        req.msg.iobref = iobref;
-
-        req.rsp.rsphdr = rsphdr;
-        req.rsp.rsphdr_count = rsphdr_count;
-        req.rsp.rsp_payload = rsp_payload;
-        req.rsp.rsp_payload_count = rsp_payload_count;
-        req.rsp.rsp_iobref = rsp_iobref;
-        req.rpc_req = rpcreq;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (conn->connected == 0 && !rpc->disabled) {
-                        ret = rpc_transport_connect (conn->trans,
-                                                     conn->config.remote_port);
-                }
-
-                ret = rpc_transport_submit_request (conn->trans, &req);
-                if (ret == -1) {
-                        gf_log (conn->name, GF_LOG_WARNING,
-                                "failed to submit rpc-request "
-                                "(XID: 0x%x Program: %s, ProgVers: %d, "
-                                "Proc: %d) to rpc-transport (%s)", rpcreq->xid,
-                                rpcreq->prog->progname, rpcreq->prog->progver,
-                                rpcreq->procnum, conn->name);
-                }
-
-                if ((ret >= 0) && frame) {
-                        /* Save the frame in queue */
-                        __save_frame (rpc, frame, rpcreq);
-
-                        /* A ref on rpc-clnt object is taken while registering
-                         * call_bail to timer in __save_frame. If it fails to
-                         * register, it needs an unref and should happen outside
-                         * conn->lock which otherwise leads to deadlocks */
-                        if (conn->timer == NULL)
-                                need_unref = _gf_true;
-
-                        conn->msgcnt++;
-
-                        gf_log ("rpc-clnt", GF_LOG_TRACE, "submitted request "
-                                "(XID: 0x%x Program: %s, ProgVers: %d, "
-                                "Proc: %d) to rpc-transport (%s)", rpcreq->xid,
-                                rpcreq->prog->progname, rpcreq->prog->progver,
-                                rpcreq->procnum, conn->name);
-                }
+            goto out;
+        }
+
+        new_iobref = 1;
+    }
+
+    callid = GF_ATOMIC_INC(rpc->xid);
+
+    rpcreq->prog = prog;
+    rpcreq->procnum = procnum;
+    rpcreq->conn = conn;
+    rpcreq->xid = callid;
+    rpcreq->cbkfn = cbkfn;
+
+    ret = -1;
+
+    if (proghdr) {
+        proglen += iov_length(proghdr, proghdrcount);
+    }
+
+    request_iob = rpc_clnt_record(rpc, frame, prog, procnum, proglen, &rpchdr,
+                                  callid);
+    if (!request_iob) {
+        gf_log(conn->name, GF_LOG_WARNING, "cannot build rpc-record");
+        goto out;
+    }
+
+    iobref_add(iobref, request_iob);
+
+    req.msg.rpchdr = &rpchdr;
+    req.msg.rpchdrcount = 1;
+    req.msg.proghdr = proghdr;
+    req.msg.proghdrcount = proghdrcount;
+    req.msg.progpayload = progpayload;
+    req.msg.progpayloadcount = progpayloadcount;
+    req.msg.iobref = iobref;
+
+    req.rsp.rsphdr = rsphdr;
+    req.rsp.rsphdr_count = rsphdr_count;
+    req.rsp.rsp_payload = rsp_payload;
+    req.rsp.rsp_payload_count = rsp_payload_count;
+    req.rsp.rsp_iobref = rsp_iobref;
+    req.rpc_req = rpcreq;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (conn->connected == 0) {
+            if (rpc->disabled)
+                goto unlock;
+            ret = rpc_transport_connect(conn->trans, conn->config.remote_port);
+            if (ret < 0) {
+                gf_log(conn->name,
+                       (errno == EINPROGRESS) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+                       "error returned while attempting to "
+                       "connect to host:%s, port:%d",
+                       conn->config.remote_host, conn->config.remote_port);
+                goto unlock;
+            }
         }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (need_unref)
-                rpc_clnt_unref (rpc);
 
+        ret = rpc_transport_submit_request(conn->trans, &req);
         if (ret == -1) {
-                goto out;
-        }
-
-        rpc_clnt_check_and_start_ping (rpc);
-        ret = 0;
+            gf_log(conn->name, GF_LOG_WARNING,
+                   "failed to submit rpc-request "
+                   "(unique: %" PRIu64
+                   ", XID: 0x%x Program: %s, "
+                   "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
+                   cframe->root->unique, rpcreq->xid, rpcreq->prog->progname,
+                   rpcreq->prog->progver, rpcreq->procnum, conn->name);
+        } else if ((ret >= 0) && frame) {
+            /* Save the frame in queue */
+            __save_frame(rpc, frame, rpcreq);
+
+            /* A ref on rpc-clnt object is taken while registering
+             * call_bail to timer in __save_frame. If it fails to
+             * register, it needs an unref and should happen outside
+             * conn->lock which otherwise leads to deadlocks */
+            if (conn->timer == NULL)
+                need_unref = _gf_true;
+
+            conn->msgcnt++;
+
+            gf_log("rpc-clnt", GF_LOG_TRACE,
+                   "submitted request "
+                   "(unique: %" PRIu64
+                   ", XID: 0x%x, Program: %s, "
+                   "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
+                   cframe->root->unique, rpcreq->xid, rpcreq->prog->progname,
+                   rpcreq->prog->progver, rpcreq->procnum, conn->name);
+        }
+    }
+unlock:
+    pthread_mutex_unlock(&conn->lock);
+
+    if (need_unref)
+        rpc_clnt_unref(rpc);
+
+    if (ret == -1) {
+        goto out;
+    }
+
+    rpc_clnt_check_and_start_ping(rpc);
+    ret = 0;
 
 out:
-        if (request_iob) {
-                iobuf_unref (request_iob);
-        }
-
-        if (new_iobref && iobref) {
-                iobref_unref (iobref);
-        }
-
-        if (frame && (ret == -1)) {
-                if (rpcreq) {
-                        rpcreq->rpc_status = -1;
-                        cbkfn (rpcreq, NULL, 0, frame);
-                        mem_put (rpcreq);
-                }
-        }
-        return ret;
+    if (request_iob) {
+        iobuf_unref(request_iob);
+    }
+
+    if (new_iobref && iobref) {
+        iobref_unref(iobref);
+    }
+
+    if (frame && (ret == -1)) {
+        if (rpcreq) {
+            rpcreq->rpc_status = -1;
+            cbkfn(rpcreq, NULL, 0, frame);
+            mem_put(rpcreq);
+        }
+    }
+    return ret;
 }
 
-
 struct rpc_clnt *
-rpc_clnt_ref (struct rpc_clnt *rpc)
+rpc_clnt_ref(struct rpc_clnt *rpc)
 {
-        if (!rpc)
-                return NULL;
-        pthread_mutex_lock (&rpc->lock);
-        {
-                rpc->refcount++;
-        }
-        pthread_mutex_unlock (&rpc->lock);
-        return rpc;
-}
+    if (!rpc)
+        return NULL;
 
+    GF_ATOMIC_INC(rpc->refcount);
+    return rpc;
+}
 
 static void
-rpc_clnt_trigger_destroy (struct rpc_clnt *rpc)
+rpc_clnt_trigger_destroy(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t  *conn  = NULL;
-        rpc_transport_t        *trans = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
 
-        if (!rpc)
-                return;
-
-        /* reading conn->trans outside conn->lock is OK, since this is the last
-         * ref*/
-        conn = &rpc->conn;
-        trans = conn->trans;
-        rpc_clnt_disconnect (rpc);
+    if (!rpc)
+        return;
 
-        /* This is to account for rpc_clnt_disable that might have been called
-         * before rpc_clnt_unref */
-        if (trans) {
-                rpc_transport_unref (trans);
-                conn->trans = NULL;
-        }
+    /* reading conn->trans outside conn->lock is OK, since this is the last
+     * ref*/
+    conn = &rpc->conn;
+    trans = conn->trans;
+    rpc_clnt_disable(rpc);
+
+    /* This is to account for rpc_clnt_disable that might have been called
+     * before rpc_clnt_unref */
+    if (trans) {
+        /* set conn->trans to NULL before rpc_transport_unref
+         * as rpc_transport_unref can potentially free conn
+         */
+        conn->trans = NULL;
+        rpc_transport_unref(trans);
+    }
 }
 
 static void
-rpc_clnt_destroy (struct rpc_clnt *rpc)
+rpc_clnt_destroy(struct rpc_clnt *rpc)
 {
-        if (!rpc)
-                return;
-
-        saved_frames_destroy (rpc->conn.saved_frames);
-        pthread_mutex_destroy (&rpc->lock);
-        pthread_mutex_destroy (&rpc->conn.lock);
+    rpcclnt_cb_program_t *program = NULL;
+    rpcclnt_cb_program_t *tmp = NULL;
+    struct saved_frames *saved_frames = NULL;
+    rpc_clnt_connection_t *conn = NULL;
 
-        /* mem-pool should be destroyed, otherwise,
-           it will cause huge memory leaks */
-        mem_pool_destroy (rpc->reqpool);
-        mem_pool_destroy (rpc->saved_frames_pool);
-
-        GF_FREE (rpc);
+    if (!rpc)
         return;
-}
-
-struct rpc_clnt *
-rpc_clnt_unref (struct rpc_clnt *rpc)
-{
-        int     count = 0;
 
-        if (!rpc)
-                return NULL;
-        pthread_mutex_lock (&rpc->lock);
-        {
-                count = --rpc->refcount;
-        }
-        pthread_mutex_unlock (&rpc->lock);
-        if (!count) {
-                rpc_clnt_trigger_destroy (rpc);
-                return NULL;
-        }
-        return rpc;
+    conn = &rpc->conn;
+    GF_FREE(rpc->conn.name);
+    /* Access saved_frames in critical-section to avoid
+       crash in rpc_clnt_connection_cleanup at the time
+       of destroying saved frames
+    */
+    pthread_mutex_lock(&conn->lock);
+    {
+        saved_frames = conn->saved_frames;
+        conn->saved_frames = NULL;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    saved_frames_destroy(saved_frames);
+    pthread_mutex_destroy(&rpc->lock);
+    pthread_mutex_destroy(&rpc->conn.lock);
+    pthread_cond_destroy(&rpc->conn.cond);
+
+    /* mem-pool should be destroyed, otherwise,
+       it will cause huge memory leaks */
+    mem_pool_destroy(rpc->reqpool);
+    mem_pool_destroy(rpc->saved_frames_pool);
+
+    list_for_each_entry_safe(program, tmp, &rpc->programs, program)
+    {
+        GF_FREE(program);
+    }
+
+    GF_FREE(rpc);
+    return;
 }
 
-
-char
-rpc_clnt_is_disabled (struct rpc_clnt *rpc)
+struct rpc_clnt *
+rpc_clnt_unref(struct rpc_clnt *rpc)
 {
+    int count = 0;
 
-        rpc_clnt_connection_t *conn = NULL;
-        char                   disabled = 0;
-
-        if (!rpc) {
-                goto out;
-        }
-
-        conn = &rpc->conn;
+    if (!rpc)
+        return NULL;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                disabled = rpc->disabled;
-        }
-        pthread_mutex_unlock (&conn->lock);
+    count = GF_ATOMIC_DEC(rpc->refcount);
 
-out:
-        return disabled;
+    if (!count) {
+        rpc_clnt_trigger_destroy(rpc);
+        return NULL;
+    }
+    return rpc;
 }
 
-void
-rpc_clnt_disable (struct rpc_clnt *rpc)
+int
+rpc_clnt_disable(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t *conn = NULL;
-        rpc_transport_t       *trans = NULL;
-        int                    unref = 0;
-        int                    ret   = 0;
-        gf_boolean_t           timer_unref = _gf_false;
-        gf_boolean_t           reconnect_unref = _gf_false;
-
-        if (!rpc) {
-                goto out;
-        }
-
-        conn = &rpc->conn;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 1;
-
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->timer);
-                        /* If the event is not fired and it actually cancelled
-                         * the timer, do the unref else registered call back
-                         * function will take care of it.
-                         */
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect);
-                        if (!ret)
-                                reconnect_unref = _gf_true;
-                        conn->reconnect = NULL;
-                }
-                conn->connected = 0;
-
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-                trans = conn->trans;
-
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-        }
-
-        if (unref)
-                rpc_clnt_unref (rpc);
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
+    int unref = 0;
+    int ret = 0;
+    gf_boolean_t timer_unref = _gf_false;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!rpc) {
+        goto out;
+    }
+
+    conn = &rpc->conn;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 1;
+
+        if (conn->timer) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->timer);
+            /* If the event is not fired and it actually cancelled
+             * the timer, do the unref else registered call back
+             * function will take care of it.
+             */
+            if (!ret)
+                timer_unref = _gf_true;
+            conn->timer = NULL;
+        }
+
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->reconnect);
+            if (!ret)
+                reconnect_unref = _gf_true;
+            conn->reconnect = NULL;
+        }
+        conn->connected = 0;
+
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+        trans = conn->trans;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    ret = -1;
+    if (trans) {
+        ret = rpc_transport_disconnect(trans, _gf_true);
+        /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
+         *    if (clnt->auth_value)
+         *           clnt->auth_value = AUTH_GLUSTERFS_v2;
+         * It should not be reset here. The disconnect during
+         * portmap request can race with handshake. If handshake
+         * happens first and disconnect later, auth_value would set
+         * to default value and it never sets back to actual auth_value
+         * supported by server. But it's important to set to lower
+         * version supported in the case where the server downgrades.
+         * So moving this code to RPC_TRANSPORT_CONNECT. Note that
+         * CONNECT cannot race with handshake as by nature it is
+         * serialized with handhake. An handshake can happen only
+         * on a connected transport and hence its strictly serialized.
+         */
+    }
+    if (unref)
+        rpc_clnt_unref(rpc);
 
-        if (timer_unref)
-                rpc_clnt_unref (rpc);
+    if (timer_unref)
+        rpc_clnt_unref(rpc);
 
-        if (reconnect_unref)
-                rpc_clnt_unref (rpc);
+    if (reconnect_unref)
+        rpc_clnt_unref(rpc);
 
 out:
-        return;
+    return ret;
 }
 
 void
-rpc_clnt_disconnect (struct rpc_clnt *rpc)
+rpc_clnt_reconfig(struct rpc_clnt *rpc, struct rpc_clnt_config *config)
 {
-        rpc_clnt_connection_t *conn  = NULL;
-        rpc_transport_t       *trans = NULL;
-        int                    unref = 0;
-        int                    ret   = 0;
-        gf_boolean_t           timer_unref = _gf_false;
-        gf_boolean_t           reconnect_unref = _gf_false;
-
-        if (!rpc)
-                goto out;
+    if (config->ping_timeout) {
+        if (config->ping_timeout != rpc->conn.ping_timeout)
+            gf_log(rpc->conn.name, GF_LOG_INFO,
+                   "changing ping timeout to %d (from %d)",
+                   config->ping_timeout, rpc->conn.ping_timeout);
 
-        conn = &rpc->conn;
-
-        pthread_mutex_lock (&conn->lock);
+        pthread_mutex_lock(&rpc->conn.lock);
         {
-                rpc->disabled = 1;
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->timer);
-                        /* If the event is not fired and it actually cancelled
-                         * the timer, do the unref else registered call back
-                         * function will take care of unref.
-                         */
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect);
-                        if (!ret)
-                                reconnect_unref = _gf_true;
-                        conn->reconnect = NULL;
-                }
-                conn->connected = 0;
-
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-                trans = conn->trans;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-        }
-        if (unref)
-                rpc_clnt_unref (rpc);
-
-        if (timer_unref)
-                rpc_clnt_unref (rpc);
-
-        if (reconnect_unref)
-                rpc_clnt_unref (rpc);
-
-out:
-        return;
-}
-
-
-void
-rpc_clnt_reconfig (struct rpc_clnt *rpc, struct rpc_clnt_config *config)
-{
-        if (config->ping_timeout) {
-                if (config->ping_timeout != rpc->conn.ping_timeout)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing ping timeout to %d (from %d)",
-                                config->ping_timeout,
-                                rpc->conn.ping_timeout);
-
-                pthread_mutex_lock (&rpc->conn.lock);
-                {
-                rpc->conn.ping_timeout = config->ping_timeout;
-                }
-                pthread_mutex_unlock (&rpc->conn.lock);
-
-        }
-
-        if (config->rpc_timeout) {
-                if (config->rpc_timeout != rpc->conn.config.rpc_timeout)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing timeout to %d (from %d)",
-                                config->rpc_timeout,
-                                rpc->conn.config.rpc_timeout);
-                rpc->conn.config.rpc_timeout = config->rpc_timeout;
-        }
-
-        if (config->remote_port) {
-                if (config->remote_port != rpc->conn.config.remote_port)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing port to %d (from %d)",
-                                config->remote_port,
-                                rpc->conn.config.remote_port);
-
-                rpc->conn.config.remote_port = config->remote_port;
+            rpc->conn.ping_timeout = config->ping_timeout;
+        }
+        pthread_mutex_unlock(&rpc->conn.lock);
+    }
+
+    if (config->rpc_timeout) {
+        if (config->rpc_timeout != rpc->conn.config.rpc_timeout)
+            gf_log(rpc->conn.name, GF_LOG_INFO,
+                   "changing timeout to %d (from %d)", config->rpc_timeout,
+                   rpc->conn.config.rpc_timeout);
+        rpc->conn.config.rpc_timeout = config->rpc_timeout;
+    }
+
+    if (config->remote_port) {
+        if (config->remote_port != rpc->conn.config.remote_port)
+            gf_log(rpc->conn.name, GF_LOG_INFO, "changing port to %d (from %d)",
+                   config->remote_port, rpc->conn.config.remote_port);
+
+        rpc->conn.config.remote_port = config->remote_port;
+    }
+
+    if (config->remote_host) {
+        if (rpc->conn.config.remote_host) {
+            if (strcmp(rpc->conn.config.remote_host, config->remote_host))
+                gf_log(rpc->conn.name, GF_LOG_INFO,
+                       "changing hostname to %s (from %s)", config->remote_host,
+                       rpc->conn.config.remote_host);
+            GF_FREE(rpc->conn.config.remote_host);
+        } else {
+            gf_log(rpc->conn.name, GF_LOG_INFO, "setting hostname to %s",
+                   config->remote_host);
         }
 
-        if (config->remote_host) {
-                if (rpc->conn.config.remote_host) {
-                        if (strcmp (rpc->conn.config.remote_host,
-                                    config->remote_host))
-                                gf_log (rpc->conn.name, GF_LOG_INFO,
-                                        "changing hostname to %s (from %s)",
-                                        config->remote_host,
-                                        rpc->conn.config.remote_host);
-                        GF_FREE (rpc->conn.config.remote_host);
-                } else {
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "setting hostname to %s",
-                                config->remote_host);
-                }
-
-                rpc->conn.config.remote_host = gf_strdup (config->remote_host);
-        }
+        rpc->conn.config.remote_host = gf_strdup(config->remote_host);
+    }
 }
diff --git a/rpc/rpc-lib/src/rpc-clnt.h b/rpc/rpc-lib/src/rpc-clnt.h
index 952ecbce1a1..2945265200b 100644
--- a/rpc/rpc-lib/src/rpc-clnt.h
+++ b/rpc/rpc-lib/src/rpc-clnt.h
@@ -11,20 +11,20 @@
 #ifndef __RPC_CLNT_H
 #define __RPC_CLNT_H
 
-#include "stack.h"
+#include <glusterfs/stack.h>
 #include "rpc-transport.h"
-#include "timer.h"
+#include <glusterfs/timer.h>
 #include "xdr-common.h"
+#include "glusterfs3.h"
 
 typedef enum {
-        RPC_CLNT_CONNECT,
-        RPC_CLNT_DISCONNECT,
-        RPC_CLNT_PING,
-        RPC_CLNT_MSG,
-        RPC_CLNT_DESTROY
+    RPC_CLNT_CONNECT,
+    RPC_CLNT_DISCONNECT,
+    RPC_CLNT_PING,
+    RPC_CLNT_MSG,
+    RPC_CLNT_DESTROY
 } rpc_clnt_event_t;
 
-
 #define SFRAME_GET_PROGNUM(sframe) (sframe->rpcreq->prog->prognum)
 #define SFRAME_GET_PROGVER(sframe) (sframe->rpcreq->prog->progver)
 #define SFRAME_GET_PROCNUM(sframe) (sframe->rpcreq->procnum)
@@ -34,60 +34,59 @@ struct rpc_clnt;
 struct rpc_clnt_config;
 struct rpc_clnt_program;
 
-typedef int (*rpc_clnt_notify_t) (struct rpc_clnt *rpc, void *mydata,
-                                  rpc_clnt_event_t fn, void *data);
+typedef int (*rpc_clnt_notify_t)(struct rpc_clnt *rpc, void *mydata,
+                                 rpc_clnt_event_t fn, void *data);
 
-typedef int (*fop_cbk_fn_t) (struct rpc_req *req, struct iovec *iov, int count,
-                             void *myframe);
+typedef int (*fop_cbk_fn_t)(struct rpc_req *req, struct iovec *iov, int count,
+                            void *myframe);
 
-typedef int (*clnt_fn_t) (call_frame_t *fr, xlator_t *xl, void *args);
+typedef int (*clnt_fn_t)(call_frame_t *fr, xlator_t *xl, void *args);
 
 struct saved_frame {
-	union {
-		struct list_head list;
-		struct {
-			struct saved_frame *frame_next;
-			struct saved_frame *frame_prev;
-		};
-	};
-        void                    *capital_this;
-	void                    *frame;
-	struct timeval           saved_at;
-        struct rpc_req          *rpcreq;
-        rpc_transport_rsp_t      rsp;
+    union {
+        struct list_head list;
+        struct {
+            struct saved_frame *frame_next;
+            struct saved_frame *frame_prev;
+        };
+    };
+    void *capital_this;
+    void *frame;
+    struct rpc_req *rpcreq;
+    struct timeval saved_at;
+    rpc_transport_rsp_t rsp;
 };
 
 struct saved_frames {
-	int64_t            count;
-	struct saved_frame sf;
-	struct saved_frame lk_sf;
+    int64_t count;
+    struct saved_frame sf;
+    struct saved_frame lk_sf;
 };
 
-
 /* Initialized by procnum */
 typedef struct rpc_clnt_procedure {
-        char         *procname;
-        clnt_fn_t     fn;
+    char *procname;
+    clnt_fn_t fn;
 } rpc_clnt_procedure_t;
 
 typedef struct rpc_clnt_program {
-        char                 *progname;
-        int                   prognum;
-        int                   progver;
-        rpc_clnt_procedure_t *proctable;
-        char                **procnames;
-        int                   numproc;
+    char *progname;
+    int prognum;
+    int progver;
+    rpc_clnt_procedure_t *proctable;
+    char **procnames;
+    int numproc;
 } rpc_clnt_prog_t;
 
-typedef int (*rpcclnt_cb_fn) (struct rpc_clnt *rpc, void *mydata, void *data);
+typedef int (*rpcclnt_cb_fn)(struct rpc_clnt *rpc, void *mydata, void *data);
 
 /* The descriptor for each procedure/actor that runs
  * over the RPC service.
  */
 typedef struct rpcclnt_actor_desc {
-        char                 procname[32];
-        int                  procnum;
-        rpcclnt_cb_fn        actor;
+    char procname[32];
+    rpcclnt_cb_fn actor;
+    int procnum;
 } rpcclnt_cb_actor_t;
 
 /* Describes a program and its version along with the function pointers
@@ -95,114 +94,113 @@ typedef struct rpcclnt_actor_desc {
  * Never changed ever by any thread so no need for a lock.
  */
 typedef struct rpcclnt_cb_program {
-        char                      progname[32];
-        int                       prognum;
-        int                       progver;
-        rpcclnt_cb_actor_t       *actors;        /* All procedure handlers */
-        int                       numactors;     /* Num actors in actor array */
-
-        /* Program specific state handed to actors */
-        void                    *private;
+    char progname[32];
+    int prognum;
+    int progver;
+    rpcclnt_cb_actor_t *actors; /* All procedure handlers */
+    /* Program specific state handed to actors */
+    void *private;
 
+    /* list member to link to list of registered services with rpc_clnt */
+    struct list_head program;
 
-        /* list member to link to list of registered services with rpc_clnt */
-        struct list_head        program;
+    /* Needed for passing back in cb_actor */
+    void *mydata;
+    int numactors; /* Num actors in actor array */
 
-        /* Needed for passing back in cb_actor */
-        void                   *mydata;
 } rpcclnt_cb_program_t;
 
-
-
 typedef struct rpc_auth_data {
-        int  flavour;
-        int  datalen;
-        char authdata[GF_MAX_AUTH_BYTES];
+    int flavour;
+    int datalen;
+    char authdata[GF_MAX_AUTH_BYTES];
 } rpc_auth_data_t;
 
-
 struct rpc_clnt_config {
-        int    rpc_timeout;
-        int    remote_port;
-        char * remote_host;
-        int    ping_timeout;
+    int rpc_timeout;
+    int remote_port;
+    char *remote_host;
+    int ping_timeout;
 };
 
-
-#define rpc_auth_flavour(au)    ((au).flavour)
+#define rpc_auth_flavour(au) ((au).flavour)
 
 struct rpc_clnt_connection {
-        pthread_mutex_t          lock;
-        rpc_transport_t         *trans;
-        struct rpc_clnt_config   config;
-        gf_timer_t              *reconnect;
-        gf_timer_t              *timer;
-        gf_timer_t              *ping_timer;
-        struct rpc_clnt         *rpc_clnt;
-        char                     connected;
-        gf_boolean_t             disconnected;
-        struct saved_frames     *saved_frames;
-        int32_t                  frame_timeout;
-	struct timeval           last_sent;
-	struct timeval           last_received;
-	int32_t                  ping_started;
-        char                    *name;
-	int32_t                  ping_timeout;
-        uint64_t                 pingcnt;
-        uint64_t                 msgcnt;
-        uint64_t                 cleanup_gen;
+    pthread_mutex_t lock;
+    pthread_cond_t cond;
+    rpc_transport_t *trans;
+    struct rpc_clnt_config config;
+    gf_timer_t *reconnect;
+    gf_timer_t *timer;
+    gf_timer_t *ping_timer;
+    struct rpc_clnt *rpc_clnt;
+    struct saved_frames *saved_frames;
+    struct timespec last_sent;
+    struct timespec last_received;
+    uint64_t pingcnt;
+    uint64_t msgcnt;
+    uint64_t cleanup_gen;
+    char *name;
+    int32_t ping_started;
+    int32_t frame_timeout;
+    int32_t ping_timeout;
+    gf_boolean_t disconnected;
+    char connected;
 };
 typedef struct rpc_clnt_connection rpc_clnt_connection_t;
 
 struct rpc_req {
-        rpc_clnt_connection_t *conn;
-        uint32_t               xid;
-        struct iovec           req[2];
-        int                    reqcnt;
-        struct iobref         *req_iobref;
-        struct iovec           rsp[2];
-        int                    rspcnt;
-        struct iobref         *rsp_iobref;
-        int                    rpc_status;
-        rpc_auth_data_t        verf;
-        rpc_clnt_prog_t       *prog;
-        int                    procnum;
-        fop_cbk_fn_t           cbkfn;
-        void                  *conn_private;
+    rpc_clnt_connection_t *conn;
+    struct iovec req[2];
+    struct iobref *req_iobref;
+    struct iovec rsp[2];
+    int rspcnt;
+    int reqcnt;
+    struct iobref *rsp_iobref;
+    rpc_clnt_prog_t *prog;
+    rpc_auth_data_t verf;
+    fop_cbk_fn_t cbkfn;
+    void *conn_private;
+    int procnum;
+    int rpc_status;
+    uint32_t xid;
 };
 
 typedef struct rpc_clnt {
-        pthread_mutex_t        lock;
-        rpc_clnt_notify_t      notifyfn;
-        rpc_clnt_connection_t  conn;
-        void                  *mydata;
-        gf_atomic_t            xid;
+    pthread_mutex_t lock;
+    rpc_clnt_notify_t notifyfn;
+    rpc_clnt_connection_t conn;
+    void *mydata;
+    gf_atomic_t xid;
 
-        /* list of cb programs registered with rpc-clnt */
-        struct list_head       programs;
+    /* list of cb programs registered with rpc-clnt */
+    struct list_head programs;
 
-        /* Memory pool for rpc_req_t */
-        struct mem_pool       *reqpool;
+    /* Memory pool for rpc_req_t */
+    struct mem_pool *reqpool;
 
-        struct mem_pool       *saved_frames_pool;
+    struct mem_pool *saved_frames_pool;
 
-        glusterfs_ctx_t       *ctx;
-        int                   refcount;
-        int                   auth_null;
-        char                  disabled;
-        xlator_t             *owner;
+    glusterfs_ctx_t *ctx;
+    gf_atomic_t refcount;
+    xlator_t *owner;
+    int auth_value;
+    char disabled;
 } rpc_clnt_t;
 
+struct rpc_clnt *
+rpc_clnt_new(dict_t *options, xlator_t *owner, char *name,
+             uint32_t reqpool_size);
 
-struct rpc_clnt *rpc_clnt_new (dict_t *options, xlator_t *owner,
-                               char *name, uint32_t reqpool_size);
-
-int rpc_clnt_start (struct rpc_clnt *rpc);
+int
+rpc_clnt_start(struct rpc_clnt *rpc);
 
-int rpc_clnt_cleanup_and_start (struct rpc_clnt *rpc);
+int
+rpc_clnt_cleanup_and_start(struct rpc_clnt *rpc);
 
-int rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
-                              void *mydata);
+int
+rpc_clnt_register_notify(struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
+                         void *mydata);
 
 /* Some preconditions related to vectors holding responses.
  * @rsphdr: should contain pointer to buffer which can hold response header
@@ -219,46 +217,44 @@ int rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
  *    of the header.
  */
 
-int rpc_clnt_submit (struct rpc_clnt *rpc, rpc_clnt_prog_t *prog,
-                     int procnum, fop_cbk_fn_t cbkfn,
-                     struct iovec *proghdr, int proghdrcount,
-                     struct iovec *progpayload, int progpayloadcount,
-                     struct iobref *iobref, void *frame, struct iovec *rsphdr,
-                     int rsphdr_count, struct iovec *rsp_payload,
-                     int rsp_payload_count, struct iobref *rsp_iobref);
+int
+rpc_clnt_submit(struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, int procnum,
+                fop_cbk_fn_t cbkfn, struct iovec *proghdr, int proghdrcount,
+                struct iovec *progpayload, int progpayloadcount,
+                struct iobref *iobref, void *frame, struct iovec *rsphdr,
+                int rsphdr_count, struct iovec *rsp_payload,
+                int rsp_payload_count, struct iobref *rsp_iobref);
 
 struct rpc_clnt *
-rpc_clnt_ref (struct rpc_clnt *rpc);
+rpc_clnt_ref(struct rpc_clnt *rpc);
 
 struct rpc_clnt *
-rpc_clnt_unref (struct rpc_clnt *rpc);
+rpc_clnt_unref(struct rpc_clnt *rpc);
 
-int rpc_clnt_connection_cleanup (rpc_clnt_connection_t *conn);
-int rpc_clnt_reconnect_cleanup (rpc_clnt_connection_t *conn);
+int
+rpc_clnt_connection_cleanup(rpc_clnt_connection_t *conn);
+int
+rpc_clnt_reconnect_cleanup(rpc_clnt_connection_t *conn);
+gf_boolean_t
+is_rpc_clnt_disconnected(rpc_clnt_connection_t *conn);
 
-void rpc_clnt_set_connected (rpc_clnt_connection_t *conn);
-
-void rpc_clnt_unset_connected (rpc_clnt_connection_t *conn);
-
-gf_boolean_t is_rpc_clnt_disconnected (rpc_clnt_connection_t *conn);
-
-void rpc_clnt_reconnect (void *trans_ptr);
+void
+rpc_clnt_reconnect(void *trans_ptr);
 
-void rpc_clnt_reconfig (struct rpc_clnt *rpc, struct rpc_clnt_config *config);
+void
+rpc_clnt_reconfig(struct rpc_clnt *rpc, struct rpc_clnt_config *config);
 
 /* All users of RPC services should use this API to register their
  * procedure handlers.
  */
-int rpcclnt_cbk_program_register (struct rpc_clnt *svc,
-                                  rpcclnt_cb_program_t *program, void *mydata);
-
-void
-rpc_clnt_disable (struct rpc_clnt *rpc);
+int
+rpcclnt_cbk_program_register(struct rpc_clnt *svc,
+                             rpcclnt_cb_program_t *program, void *mydata);
 
-void
-rpc_clnt_disconnect (struct rpc_clnt *rpc);
+int
+rpc_clnt_disable(struct rpc_clnt *rpc);
 
-char
-rpc_clnt_is_disabled (struct rpc_clnt *rpc);
+int
+rpc_clnt_mgmt_pmap_signout(glusterfs_ctx_t *ctx, char *brick_name);
 
 #endif /* !_RPC_CLNT_H */
diff --git a/rpc/rpc-lib/src/rpc-drc.c b/rpc/rpc-lib/src/rpc-drc.c
index fb7d2f13605..de8dc630626 100644
--- a/rpc/rpc-lib/src/rpc-drc.c
+++ b/rpc/rpc-lib/src/rpc-drc.c
@@ -12,11 +12,9 @@
 #ifndef RPC_DRC_H
 #include "rpc-drc.h"
 #endif
-#include "locking.h"
-#include "hashfn.h"
-#include "common-utils.h"
-#include "statedump.h"
-#include "mem-pool.h"
+#include <glusterfs/locking.h>
+#include <glusterfs/statedump.h>
+#include <glusterfs/mem-pool.h>
 
 #include <netinet/in.h>
 #include <unistd.h>
@@ -29,29 +27,29 @@
  * @return NULL if reply is destroyed, reply otherwise
  */
 static drc_cached_op_t *
-rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
+rpcsvc_drc_op_destroy(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (reply);
-
-        if (reply->state == DRC_OP_IN_TRANSIT)
-                return reply;
-
-        iobref_unref (reply->msg.iobref);
-        if (reply->msg.rpchdr)
-                GF_FREE (reply->msg.rpchdr);
-        if (reply->msg.proghdr)
-                GF_FREE (reply->msg.proghdr);
-        if (reply->msg.progpayload)
-                GF_FREE (reply->msg.progpayload);
-
-        list_del (&reply->global_list);
-        reply->client->op_count--;
-        drc->op_count--;
-        mem_put (reply);
-        reply = NULL;
+    GF_ASSERT(drc);
+    GF_ASSERT(reply);
 
+    if (reply->state == DRC_OP_IN_TRANSIT)
         return reply;
+
+    iobref_unref(reply->msg.iobref);
+    if (reply->msg.rpchdr)
+        GF_FREE(reply->msg.rpchdr);
+    if (reply->msg.proghdr)
+        GF_FREE(reply->msg.proghdr);
+    if (reply->msg.progpayload)
+        GF_FREE(reply->msg.progpayload);
+
+    list_del(&reply->global_list);
+    reply->client->op_count--;
+    drc->op_count--;
+    mem_put(reply);
+    reply = NULL;
+
+    return reply;
 }
 
 /**
@@ -62,9 +60,9 @@ rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
  * @return void
  */
 static void
-rpcsvc_drc_rb_op_destroy (void *reply, void *drc)
+rpcsvc_drc_rb_op_destroy(void *reply, void *drc)
 {
-        rpcsvc_drc_op_destroy (drc, (drc_cached_op_t *)reply);
+    rpcsvc_drc_op_destroy(drc, (drc_cached_op_t *)reply);
 }
 
 /**
@@ -74,11 +72,11 @@ rpcsvc_drc_rb_op_destroy (void *reply, void *drc)
  * @return void
  */
 static void
-rpcsvc_remove_drc_client (drc_client_t *client)
+rpcsvc_remove_drc_client(drc_client_t *client)
 {
-        rb_destroy (client->rbtree, rpcsvc_drc_rb_op_destroy);
-        list_del (&client->client_list);
-        GF_FREE (client);
+    rb_destroy(client->rbtree, rpcsvc_drc_rb_op_destroy);
+    list_del(&client->client_list);
+    GF_FREE(client);
 }
 
 /**
@@ -89,24 +87,25 @@ rpcsvc_remove_drc_client (drc_client_t *client)
  * @return drc client if it exists, NULL otherwise
  */
 static drc_client_t *
-rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc,
-                      struct sockaddr_storage *sockaddr)
+rpcsvc_client_lookup(rpcsvc_drc_globals_t *drc,
+                     struct sockaddr_storage *sockaddr)
 {
-        drc_client_t    *client = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (sockaddr);
+    GF_ASSERT(drc);
+    GF_ASSERT(sockaddr);
 
-        if (list_empty (&drc->clients_head))
-            return NULL;
+    if (list_empty(&drc->clients_head))
+        return NULL;
 
-        list_for_each_entry (client, &drc->clients_head, client_list) {
-                if (gf_sock_union_equal_addr (&client->sock_union,
-                                              (union gf_sock_union *)sockaddr))
-                        return client;
-        }
+    list_for_each_entry(client, &drc->clients_head, client_list)
+    {
+        if (gf_sock_union_equal_addr(&client->sock_union,
+                                     (union gf_sock_union *)sockaddr))
+            return client;
+    }
 
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -119,29 +118,28 @@ rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc,
  * @return 0 if req matches reply, else (req->xid - reply->xid)
  */
 int
-drc_compare_reqs (const void *item, const void *rb_node_data, void *param)
+drc_compare_reqs(const void *item, const void *rb_node_data, void *param)
 {
-        int               ret      = -1;
-        drc_cached_op_t  *req      = NULL;
-        drc_cached_op_t  *reply    = NULL;
+    int ret = -1;
+    drc_cached_op_t *req = NULL;
+    drc_cached_op_t *reply = NULL;
 
-        GF_ASSERT (item);
-        GF_ASSERT (rb_node_data);
-        GF_ASSERT (param);
+    GF_ASSERT(item);
+    GF_ASSERT(rb_node_data);
+    GF_ASSERT(param);
 
-        req = (drc_cached_op_t *)item;
-        reply = (drc_cached_op_t *)rb_node_data;
+    req = (drc_cached_op_t *)item;
+    reply = (drc_cached_op_t *)rb_node_data;
 
-        ret = req->xid - reply->xid;
-        if (ret != 0)
-                return ret;
+    ret = req->xid - reply->xid;
+    if (ret != 0)
+        return ret;
 
-        if (req->prognum == reply->prognum &&
-            req->procnum == reply->procnum &&
-            req->progversion == reply->progversion)
-                return 0;
+    if (req->prognum == reply->prognum && req->procnum == reply->procnum &&
+        req->progversion == reply->progversion)
+        return 0;
 
-        return 1;
+    return 1;
 }
 
 /**
@@ -152,18 +150,18 @@ drc_compare_reqs (const void *item, const void *rb_node_data, void *param)
  * @return 0 on success, -1 on failure
  */
 static int
-drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client)
+drc_init_client_cache(rpcsvc_drc_globals_t *drc, drc_client_t *client)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (client);
+    GF_ASSERT(drc);
+    GF_ASSERT(client);
 
-        client->rbtree = rb_create (drc_compare_reqs, drc, NULL);
-        if (!client->rbtree) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed");
-                return -1;
-        }
+    client->rbtree = rb_create(drc_compare_reqs, drc, NULL);
+    if (!client->rbtree) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed");
+        return -1;
+    }
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -175,42 +173,40 @@ drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client)
  * @return drc client on success, NULL on failure
  */
 static drc_client_t *
-rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc,
-                       struct sockaddr_storage *sockaddr)
+rpcsvc_get_drc_client(rpcsvc_drc_globals_t *drc,
+                      struct sockaddr_storage *sockaddr)
 {
-        drc_client_t      *client      = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (sockaddr);
+    GF_ASSERT(drc);
+    GF_ASSERT(sockaddr);
 
-        client = rpcsvc_client_lookup (drc, sockaddr);
-        if (client)
-                goto out;
+    client = rpcsvc_client_lookup(drc, sockaddr);
+    if (client)
+        goto out;
 
-        /* if lookup fails, allocate cache for the new client */
-        client = GF_CALLOC (1, sizeof (drc_client_t),
-                            gf_common_mt_drc_client_t);
-        if (!client)
-                goto out;
-
-        client->ref = 0;
-        client->sock_union = (union gf_sock_union)*sockaddr;
-        client->op_count = 0;
-        INIT_LIST_HEAD (&client->client_list);
-
-        if (drc_init_client_cache (drc, client)) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG,
-                        "initialization of drc client failed");
-                GF_FREE (client);
-                client = NULL;
-                goto out;
-        }
-        drc->client_count++;
+    /* if lookup fails, allocate cache for the new client */
+    client = GF_CALLOC(1, sizeof(drc_client_t), gf_common_mt_drc_client_t);
+    if (!client)
+        goto out;
 
-        list_add (&client->client_list, &drc->clients_head);
+    GF_ATOMIC_INIT(client->ref, 0);
+    client->sock_union = (union gf_sock_union) * sockaddr;
+    client->op_count = 0;
+    INIT_LIST_HEAD(&client->client_list);
 
- out:
-        return client;
+    if (drc_init_client_cache(drc, client)) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "initialization of drc client failed");
+        GF_FREE(client);
+        client = NULL;
+        goto out;
+    }
+    drc->client_count++;
+
+    list_add(&client->client_list, &drc->clients_head);
+
+out:
+    return client;
 }
 
 /**
@@ -220,25 +216,24 @@ rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc,
  * @return 1 if DRC is needed for req, 0 otherwise
  */
 int
-rpcsvc_need_drc (rpcsvc_request_t *req)
+rpcsvc_need_drc(rpcsvc_request_t *req)
 {
-        rpcsvc_actor_t           *actor = NULL;
-        rpcsvc_drc_globals_t     *drc   = NULL;
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
 
-        GF_ASSERT (req);
-        GF_ASSERT (req->svc);
+    GF_ASSERT(req);
+    GF_ASSERT(req->svc);
 
-        drc = req->svc->drc;
+    drc = req->svc->drc;
 
-        if (!drc || drc->status == DRC_UNINITIATED)
-                return 0;
+    if (!drc || drc->status == DRC_UNINITIATED)
+        return 0;
 
-        actor = rpcsvc_program_actor (req);
-        if (!actor)
-                return 0;
+    actor = rpcsvc_program_actor(req);
+    if (!actor)
+        return 0;
 
-        return (actor->op_type == DRC_NON_IDEMPOTENT
-                && drc->type != DRC_TYPE_NONE);
+    return (actor->op_type == DRC_NON_IDEMPOTENT && drc->type != DRC_TYPE_NONE);
 }
 
 /**
@@ -248,11 +243,11 @@ rpcsvc_need_drc (rpcsvc_request_t *req)
  * @return client
  */
 static drc_client_t *
-rpcsvc_drc_client_ref (drc_client_t *client)
+rpcsvc_drc_client_ref(drc_client_t *client)
 {
-        GF_ASSERT (client);
-        client->ref++;
-        return client;
+    GF_ASSERT(client);
+    GF_ATOMIC_INC(client->ref);
+    return client;
 }
 
 /**
@@ -264,19 +259,20 @@ rpcsvc_drc_client_ref (drc_client_t *client)
  * @return NULL if it is the last unref, client otherwise
  */
 static drc_client_t *
-rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client)
+rpcsvc_drc_client_unref(rpcsvc_drc_globals_t *drc, drc_client_t *client)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (client->ref);
-
-        client->ref--;
-        if (!client->ref) {
-                drc->client_count--;
-                rpcsvc_remove_drc_client (client);
-                client = NULL;
-        }
+    uint32_t refcount;
+
+    GF_ASSERT(drc);
 
-        return client;
+    refcount = GF_ATOMIC_DEC(client->ref);
+    if (!refcount) {
+        drc->client_count--;
+        rpcsvc_remove_drc_client(client);
+        client = NULL;
+    }
+
+    return client;
 }
 
 /**
@@ -286,38 +282,37 @@ rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client)
  * @return cached reply of req if found, NULL otherwise
  */
 drc_cached_op_t *
-rpcsvc_drc_lookup (rpcsvc_request_t *req)
+rpcsvc_drc_lookup(rpcsvc_request_t *req)
 {
-        drc_client_t           *client = NULL;
-        drc_cached_op_t        *reply  = NULL;
-        drc_cached_op_t        new = {
-                .xid            = req->xid,
-                .prognum        = req->prognum,
-                .progversion    = req->progver,
-                .procnum        = req->procnum,
-        };
-
-        GF_ASSERT (req);
-
-        if (!req->trans->drc_client) {
-                client = rpcsvc_get_drc_client (req->svc->drc,
-                                                &req->trans->peerinfo.sockaddr);
-                if (!client)
-                        goto out;
-
-                req->trans->drc_client
-                        = rpcsvc_drc_client_ref (client);
-        }
+    drc_client_t *client = NULL;
+    drc_cached_op_t *reply = NULL;
+    drc_cached_op_t new = {
+        .xid = req->xid,
+        .prognum = req->prognum,
+        .progversion = req->progver,
+        .procnum = req->procnum,
+    };
+
+    GF_ASSERT(req);
+
+    if (!req->trans->drc_client) {
+        client = rpcsvc_get_drc_client(req->svc->drc,
+                                       &req->trans->peerinfo.sockaddr);
+        if (!client)
+            goto out;
 
-        client = req->trans->drc_client;
+        req->trans->drc_client = rpcsvc_drc_client_ref(client);
+    }
 
-        if (client->op_count == 0)
-                goto out;
+    client = req->trans->drc_client;
 
-        reply = rb_find (client->rbtree, &new);
+    if (client->op_count == 0)
+        goto out;
 
- out:
-        return reply;
+    reply = rb_find(client->rbtree, &new);
+
+out:
+    return reply;
 }
 
 /**
@@ -325,28 +320,30 @@ rpcsvc_drc_lookup (rpcsvc_request_t *req)
  *
  * @param req - incoming request (which is a duplicate in this case)
  * @param reply - the cached reply for req
- * @return 0 on successful reply submission, -1 or other non-zero value otherwise
+ * @return 0 on successful reply submission, -1 or other non-zero value
+ * otherwise
  */
 int
-rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply)
+rpcsvc_send_cached_reply(rpcsvc_request_t *req, drc_cached_op_t *reply)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        GF_ASSERT (req);
-        GF_ASSERT (reply);
+    GF_ASSERT(req);
+    GF_ASSERT(reply);
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "sending cached reply: xid: %d, "
-                "client: %s", req->xid, req->trans->peerinfo.identifier);
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "sending cached reply: xid: %d, "
+           "client: %s",
+           req->xid, req->trans->peerinfo.identifier);
 
-        rpcsvc_drc_client_ref (reply->client);
-        ret = rpcsvc_transport_submit (req->trans,
-                     reply->msg.rpchdr, reply->msg.rpchdrcount,
-                     reply->msg.proghdr, reply->msg.proghdrcount,
-                     reply->msg.progpayload, reply->msg.progpayloadcount,
-                     reply->msg.iobref, req->trans_private);
-        rpcsvc_drc_client_unref (req->svc->drc, reply->client);
+    rpcsvc_drc_client_ref(reply->client);
+    ret = rpcsvc_transport_submit(
+        req->trans, reply->msg.rpchdr, reply->msg.rpchdrcount,
+        reply->msg.proghdr, reply->msg.proghdrcount, reply->msg.progpayload,
+        reply->msg.progpayloadcount, reply->msg.iobref, req->trans_private);
+    rpcsvc_drc_client_unref(req->svc->drc, reply->client);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -363,38 +360,37 @@ rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref,
-                    struct iovec *rpchdr, int rpchdrcount,
-                    struct iovec *proghdr, int proghdrcount,
-                    struct iovec *payload, int payloadcount)
+rpcsvc_cache_reply(rpcsvc_request_t *req, struct iobref *iobref,
+                   struct iovec *rpchdr, int rpchdrcount, struct iovec *proghdr,
+                   int proghdrcount, struct iovec *payload, int payloadcount)
 {
-        int                       ret              = -1;
-        drc_cached_op_t          *reply            = NULL;
+    int ret = -1;
+    drc_cached_op_t *reply = NULL;
 
-        GF_ASSERT (req);
-        GF_ASSERT (req->reply);
+    GF_ASSERT(req);
+    GF_ASSERT(req->reply);
 
-        reply = req->reply;
+    reply = req->reply;
 
-        reply->state = DRC_OP_CACHED;
+    reply->state = DRC_OP_CACHED;
 
-        reply->msg.iobref = iobref_ref (iobref);
+    reply->msg.iobref = iobref_ref(iobref);
 
-        reply->msg.rpchdrcount = rpchdrcount;
-        reply->msg.rpchdr = iov_dup (rpchdr, rpchdrcount);
+    reply->msg.rpchdrcount = rpchdrcount;
+    reply->msg.rpchdr = iov_dup(rpchdr, rpchdrcount);
 
-        reply->msg.proghdrcount = proghdrcount;
-        reply->msg.proghdr = iov_dup (proghdr, proghdrcount);
+    reply->msg.proghdrcount = proghdrcount;
+    reply->msg.proghdr = iov_dup(proghdr, proghdrcount);
 
-        reply->msg.progpayloadcount = payloadcount;
-        if (payloadcount)
-                reply->msg.progpayload = iov_dup (payload, payloadcount);
+    reply->msg.progpayloadcount = payloadcount;
+    if (payloadcount)
+        reply->msg.progpayload = iov_dup(payload, payloadcount);
 
-        //        rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client);
-        //        rpcsvc_drc_op_unref (req->svc->drc, reply);
-        ret = 0;
+    //        rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client);
+    //        rpcsvc_drc_op_unref (req->svc->drc, reply);
+    ret = 0;
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -405,73 +401,74 @@ rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref,
  * @return void
  */
 static void
-rpcsvc_vacate_drc_entries (rpcsvc_drc_globals_t *drc)
+rpcsvc_vacate_drc_entries(rpcsvc_drc_globals_t *drc)
 {
-        uint32_t            i           = 0;
-        uint32_t            n           = 0;
-        drc_cached_op_t    *reply       = NULL;
-        drc_cached_op_t    *tmp         = NULL;
-        drc_client_t       *client      = NULL;
+    uint32_t i = 0;
+    uint32_t n = 0;
+    drc_cached_op_t *reply = NULL;
+    drc_cached_op_t *tmp = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
+    GF_ASSERT(drc);
 
-        n = drc->global_cache_size / drc->lru_factor;
+    n = drc->global_cache_size / drc->lru_factor;
 
-        list_for_each_entry_safe_reverse (reply, tmp, &drc->cache_head, global_list) {
-                /* Don't delete ops that are in transit */
-                if (reply->state == DRC_OP_IN_TRANSIT)
-                        continue;
+    list_for_each_entry_safe_reverse(reply, tmp, &drc->cache_head, global_list)
+    {
+        /* Don't delete ops that are in transit */
+        if (reply->state == DRC_OP_IN_TRANSIT)
+            continue;
 
-                client = reply->client;
+        client = reply->client;
 
-                rb_delete (client->rbtree, reply);
+        rb_delete(client->rbtree, reply);
 
-                rpcsvc_drc_op_destroy (drc, reply);
-                rpcsvc_drc_client_unref (drc, client);
-                i++;
-                if (i >= n)
-                        break;
-        }
+        rpcsvc_drc_op_destroy(drc, reply);
+        rpcsvc_drc_client_unref(drc, client);
+        i++;
+        if (i >= n)
+            break;
+    }
 }
 
 /**
- * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc list
+ * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc
+ * list
  *
  * @param drc - the main drc structure
  * @param reply - the op to be inserted
  * @return 0 on success, -1 on failure
  */
 static int
-rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
+rpcsvc_add_op_to_cache(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
 {
-        drc_client_t        *client         = NULL;
-        drc_cached_op_t    **tmp_reply      = NULL;
+    drc_client_t *client = NULL;
+    drc_cached_op_t **tmp_reply = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (reply);
+    GF_ASSERT(drc);
+    GF_ASSERT(reply);
 
-        client = reply->client;
+    client = reply->client;
 
-        /* cache is full, free up some space */
-        if (drc->op_count >= drc->global_cache_size)
-                rpcsvc_vacate_drc_entries (drc);
-
-        tmp_reply = (drc_cached_op_t **)rb_probe (client->rbtree, reply);
-        if (!tmp_reply) {
-                /* mem alloc failed */
-                return -1;
-        } else if (*tmp_reply != reply) {
-                /* should never happen */
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "DRC failed to detect duplicates");
-                return -1;
-        }
+    /* cache is full, free up some space */
+    if (drc->op_count >= drc->global_cache_size)
+        rpcsvc_vacate_drc_entries(drc);
 
-        client->op_count++;
-        list_add (&reply->global_list, &drc->cache_head);
-        drc->op_count++;
+    tmp_reply = (drc_cached_op_t **)rb_probe(client->rbtree, reply);
+    if (!tmp_reply) {
+        /* mem alloc failed */
+        return -1;
+    } else if (*tmp_reply != reply) {
+        /* should never happen */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "DRC failed to detect duplicates");
+        return -1;
+    }
 
-        return 0;
+    client->op_count++;
+    list_add(&reply->global_list, &drc->cache_head);
+    drc->op_count++;
+
+    return 0;
 }
 
 /**
@@ -481,46 +478,46 @@ rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_cache_request (rpcsvc_request_t *req)
+rpcsvc_cache_request(rpcsvc_request_t *req)
 {
-        int                        ret            = -1;
-        drc_client_t              *client         = NULL;
-        drc_cached_op_t           *reply          = NULL;
-        rpcsvc_drc_globals_t      *drc            = NULL;
-
-        GF_ASSERT (req);
-
-        drc = req->svc->drc;
-
-        client = req->trans->drc_client;
-        if (!client) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL");
-                goto out;
-        }
-
-        reply = mem_get0 (drc->mempool);
-        if (!reply)
-                goto out;
-
-        reply->client = rpcsvc_drc_client_ref (client);
-        reply->xid = req->xid;
-        reply->prognum = req->prognum;
-        reply->progversion = req->progver;
-        reply->procnum = req->procnum;
-        reply->state = DRC_OP_IN_TRANSIT;
-        req->reply = reply;
-        INIT_LIST_HEAD (&reply->global_list);
-
-        ret = rpcsvc_add_op_to_cache (drc, reply);
-        if (ret) {
-                req->reply = NULL;
-                rpcsvc_drc_op_destroy (drc, reply);
-                rpcsvc_drc_client_unref (drc, client);
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache");
-        }
-
- out:
-        return ret;
+    int ret = -1;
+    drc_client_t *client = NULL;
+    drc_cached_op_t *reply = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(req);
+
+    drc = req->svc->drc;
+
+    client = req->trans->drc_client;
+    if (!client) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL");
+        goto out;
+    }
+
+    reply = mem_get0(drc->mempool);
+    if (!reply)
+        goto out;
+
+    reply->client = rpcsvc_drc_client_ref(client);
+    reply->xid = req->xid;
+    reply->prognum = req->prognum;
+    reply->progversion = req->progver;
+    reply->procnum = req->procnum;
+    reply->state = DRC_OP_IN_TRANSIT;
+    req->reply = reply;
+    INIT_LIST_HEAD(&reply->global_list);
+
+    ret = rpcsvc_add_op_to_cache(drc, reply);
+    if (ret) {
+        req->reply = NULL;
+        rpcsvc_drc_op_destroy(drc, reply);
+        rpcsvc_drc_client_unref(drc, client);
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache");
+    }
+
+out:
+    return ret;
 }
 
 /**
@@ -531,72 +528,76 @@ rpcsvc_cache_request (rpcsvc_request_t *req)
  * @return 0 on success, -1 on failure
  */
 int32_t
-rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc)
+rpcsvc_drc_priv(rpcsvc_drc_globals_t *drc)
 {
-        int                      i                         = 0;
-        char                     key[GF_DUMP_MAX_BUF_LEN]  = {0};
-        drc_client_t            *client                    = NULL;
-        char                     ip[INET6_ADDRSTRLEN]      = {0};
-
-        if (!drc || drc->status == DRC_UNINITIATED) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "DRC is "
-                        "uninitialized, not dumping its state");
-                return 0;
+    int i = 0;
+    char key[GF_DUMP_MAX_BUF_LEN] = {0};
+    drc_client_t *client = NULL;
+    char ip[INET6_ADDRSTRLEN] = {0};
+
+    if (!drc || drc->status == DRC_UNINITIATED) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "DRC is "
+               "uninitialized, not dumping its state");
+        return 0;
+    }
+
+    gf_proc_dump_add_section("rpc.drc");
+
+    if (TRY_LOCK(&drc->lock))
+        return -1;
+
+    gf_proc_dump_build_key(key, "drc", "type");
+    gf_proc_dump_write(key, "%d", drc->type);
+
+    gf_proc_dump_build_key(key, "drc", "client_count");
+    gf_proc_dump_write(key, "%d", drc->client_count);
+
+    gf_proc_dump_build_key(key, "drc", "current_cache_size");
+    gf_proc_dump_write(key, "%d", drc->op_count);
+
+    gf_proc_dump_build_key(key, "drc", "max_cache_size");
+    gf_proc_dump_write(key, "%d", drc->global_cache_size);
+
+    gf_proc_dump_build_key(key, "drc", "lru_factor");
+    gf_proc_dump_write(key, "%d", drc->lru_factor);
+
+    gf_proc_dump_build_key(key, "drc", "duplicate_request_count");
+    gf_proc_dump_write(key, "%" PRIu64, drc->cache_hits);
+
+    gf_proc_dump_build_key(key, "drc", "in_transit_duplicate_requests");
+    gf_proc_dump_write(key, "%" PRIu64, drc->intransit_hits);
+
+    list_for_each_entry(client, &drc->clients_head, client_list)
+    {
+        gf_proc_dump_build_key(key, "client", "%d.ip-address", i);
+        memset(ip, 0, INET6_ADDRSTRLEN);
+        switch (client->sock_union.storage.ss_family) {
+            case AF_INET:
+                gf_proc_dump_write(
+                    key, "%s",
+                    inet_ntop(AF_INET, &client->sock_union.sin.sin_addr.s_addr,
+                              ip, INET_ADDRSTRLEN));
+                break;
+            case AF_INET6:
+                gf_proc_dump_write(
+                    key, "%s",
+                    inet_ntop(AF_INET6, &client->sock_union.sin6.sin6_addr, ip,
+                              INET6_ADDRSTRLEN));
+                break;
+            default:
+                gf_proc_dump_write(key, "%s", "N/A");
         }
 
-        gf_proc_dump_add_section("rpc.drc");
-
-        if (TRY_LOCK (&drc->lock))
-                return -1;
-
-        gf_proc_dump_build_key (key, "drc", "type");
-        gf_proc_dump_write (key, "%d", drc->type);
-
-        gf_proc_dump_build_key (key, "drc", "client_count");
-        gf_proc_dump_write (key, "%d", drc->client_count);
-
-        gf_proc_dump_build_key (key, "drc", "current_cache_size");
-        gf_proc_dump_write (key, "%d", drc->op_count);
-
-        gf_proc_dump_build_key (key, "drc", "max_cache_size");
-        gf_proc_dump_write (key, "%d", drc->global_cache_size);
-
-        gf_proc_dump_build_key (key, "drc", "lru_factor");
-        gf_proc_dump_write (key, "%d", drc->lru_factor);
-
-        gf_proc_dump_build_key (key, "drc", "duplicate_request_count");
-        gf_proc_dump_write (key, "%d", drc->cache_hits);
-
-        gf_proc_dump_build_key (key, "drc", "in_transit_duplicate_requests");
-        gf_proc_dump_write (key, "%d", drc->intransit_hits);
-
-        list_for_each_entry (client, &drc->clients_head, client_list) {
-                gf_proc_dump_build_key (key, "client", "%d.ip-address", i);
-                memset (ip, 0, INET6_ADDRSTRLEN);
-                switch (client->sock_union.storage.ss_family) {
-                case AF_INET:
-                        gf_proc_dump_write (key, "%s", inet_ntop (AF_INET,
-                                &client->sock_union.sin.sin_addr.s_addr,
-                                ip, INET_ADDRSTRLEN));
-                        break;
-                case AF_INET6:
-                        gf_proc_dump_write (key, "%s", inet_ntop (AF_INET6,
-                                &client->sock_union.sin6.sin6_addr,
-                                ip, INET6_ADDRSTRLEN));
-                        break;
-                default:
-                        gf_proc_dump_write (key, "%s", "N/A");
-                }
-
-                gf_proc_dump_build_key (key, "client", "%d.ref_count", i);
-                gf_proc_dump_write (key, "%d", client->ref);
-                gf_proc_dump_build_key (key, "client", "%d.op_count", i);
-                gf_proc_dump_write (key, "%d", client->op_count);
-                i++;
-        }
+        gf_proc_dump_build_key(key, "client", "%d.ref_count", i);
+        gf_proc_dump_write(key, "%" PRIu32, GF_ATOMIC_GET(client->ref));
+        gf_proc_dump_build_key(key, "client", "%d.op_count", i);
+        gf_proc_dump_write(key, "%d", client->op_count);
+        i++;
+    }
 
-        UNLOCK (&drc->lock);
-        return 0;
+    UNLOCK(&drc->lock);
+    return 0;
 }
 
 /**
@@ -609,53 +610,51 @@ rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_drc_notify (rpcsvc_t *svc, void *xl,
-                   rpcsvc_event_t event, void *data)
+rpcsvc_drc_notify(rpcsvc_t *svc, void *xl, rpcsvc_event_t event, void *data)
 {
-        int                       ret          = -1;
-        rpc_transport_t          *trans        = NULL;
-        drc_client_t             *client       = NULL;
-        rpcsvc_drc_globals_t     *drc          = NULL;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (svc->drc);
-        GF_ASSERT (data);
-
-        drc = svc->drc;
-
-        if (drc->status == DRC_UNINITIATED ||
-            drc->type == DRC_TYPE_NONE)
-                return 0;
-
-        LOCK (&drc->lock);
-        {
-                trans = (rpc_transport_t *)data;
-                client = rpcsvc_get_drc_client (drc, &trans->peerinfo.sockaddr);
-                if (!client)
-                        goto unlock;
-
-                switch (event) {
-                case RPCSVC_EVENT_ACCEPT:
-                        trans->drc_client = rpcsvc_drc_client_ref (client);
-                        ret = 0;
-                        break;
-
-                case RPCSVC_EVENT_DISCONNECT:
-                        ret = 0;
-                        if (list_empty (&drc->clients_head))
-                                break;
-                        /* should be the last unref */
-                        trans->drc_client = NULL;
-                        rpcsvc_drc_client_unref (drc, client);
-                        break;
-
-                default:
-                        break;
-                }
+    int ret = -1;
+    rpc_transport_t *trans = NULL;
+    drc_client_t *client = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(svc->drc);
+    GF_ASSERT(data);
+
+    drc = svc->drc;
+
+    if (drc->status == DRC_UNINITIATED || drc->type == DRC_TYPE_NONE)
+        return 0;
+
+    LOCK(&drc->lock);
+    {
+        trans = (rpc_transport_t *)data;
+        client = rpcsvc_get_drc_client(drc, &trans->peerinfo.sockaddr);
+        if (!client)
+            goto unlock;
+
+        switch (event) {
+            case RPCSVC_EVENT_ACCEPT:
+                trans->drc_client = rpcsvc_drc_client_ref(client);
+                ret = 0;
+                break;
+
+            case RPCSVC_EVENT_DISCONNECT:
+                ret = 0;
+                if (list_empty(&drc->clients_head))
+                    break;
+                /* should be the last unref */
+                trans->drc_client = NULL;
+                rpcsvc_drc_client_unref(drc, client);
+                break;
+
+            default:
+                break;
         }
+    }
 unlock:
-        UNLOCK (&drc->lock);
-        return ret;
+    UNLOCK(&drc->lock);
+    return ret;
 }
 
 /**
@@ -666,191 +665,191 @@ unlock:
  * @return 0 on success, non-zero integer on failure
  */
 int
-rpcsvc_drc_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_drc_init(rpcsvc_t *svc, dict_t *options)
 {
-        int                         ret            = 0;
-        uint32_t                    drc_type       = 0;
-        uint32_t                    drc_size       = 0;
-        uint32_t                    drc_factor     = 0;
-        rpcsvc_drc_globals_t       *drc            = NULL;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
-
-        /* Toggle DRC on/off, when more drc types(persistent/cluster)
-         * are added, we shouldn't treat this as boolean. */
-        ret = dict_get_str_boolean (options, "nfs.drc", _gf_false);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                        "drc user options need second look");
-                ret = _gf_false;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF"));
-
-        /*DRC off, nothing to do */
-        if (ret == _gf_false)
-                return (0);
-
-        drc = GF_CALLOC (1, sizeof (rpcsvc_drc_globals_t),
-                         gf_common_mt_drc_globals_t);
-        if (!drc)
-                return (-1);
-
-        LOCK_INIT (&drc->lock);
-        svc->drc = drc;
-
-        LOCK (&drc->lock);
-
-        /* Specify type of DRC to be used */
-        ret = dict_get_uint32 (options, "nfs.drc-type", &drc_type);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc type not set."
-                        " Continuing with default");
-                drc_type = DRC_DEFAULT_TYPE;
-        }
-
-        drc->type = drc_type;
-
-        /* Set the global cache size (no. of ops to cache) */
-        ret = dict_get_uint32 (options, "nfs.drc-size", &drc_size);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc size not set."
-                        " Continuing with default size");
-                drc_size = DRC_DEFAULT_CACHE_SIZE;
-        }
-
-        drc->global_cache_size = drc_size;
-
-        /* Mempool for cached ops */
-        drc->mempool = mem_pool_new (drc_cached_op_t, drc->global_cache_size);
-        if (!drc->mempool) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to get mempool for"
-                        " DRC, drc-size: %d", drc->global_cache_size);
-                ret = -1;
-                goto out;
-        }
-
-        /* What percent of cache to be evicted whenever it fills up */
-        ret = dict_get_uint32 (options, "nfs.drc-lru-factor", &drc_factor);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc lru factor not set."
-                        " Continuing with policy default");
-                drc_factor = DRC_DEFAULT_LRU_FACTOR;
-        }
-
-        drc->lru_factor = (drc_lru_factor_t) drc_factor;
-
-        INIT_LIST_HEAD (&drc->clients_head);
-        INIT_LIST_HEAD (&drc->cache_head);
-
-        ret = rpcsvc_register_notify (svc, rpcsvc_drc_notify, THIS);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "registration of drc_notify function failed");
-                goto out;
-        }
+    int ret = 0;
+    uint32_t drc_type = 0;
+    uint32_t drc_size = 0;
+    uint32_t drc_factor = 0;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
+
+    /* Toggle DRC on/off, when more drc types(persistent/cluster)
+     * are added, we shouldn't treat this as boolean. */
+    ret = dict_get_str_boolean(options, "nfs.drc", _gf_false);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_INFO, "drc user options need second look");
+        ret = _gf_false;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF"));
+
+    /*DRC off, nothing to do */
+    if (ret == _gf_false)
+        return (0);
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc init successful");
-        drc->status = DRC_INITIATED;
- out:
-        UNLOCK (&drc->lock);
-        if (ret == -1) {
-                if (drc->mempool) {
-                        mem_pool_destroy (drc->mempool);
-                        drc->mempool = NULL;
-                }
-                GF_FREE (drc);
-                svc->drc = NULL;
+    drc = GF_CALLOC(1, sizeof(rpcsvc_drc_globals_t),
+                    gf_common_mt_drc_globals_t);
+    if (!drc)
+        return (-1);
+
+    LOCK_INIT(&drc->lock);
+    svc->drc = drc;
+
+    /* Specify type of DRC to be used */
+    ret = dict_get_uint32(options, "nfs.drc-type", &drc_type);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc type not set. Continuing with default");
+        drc_type = DRC_DEFAULT_TYPE;
+    }
+
+    /* Set the global cache size (no. of ops to cache) */
+    ret = dict_get_uint32(options, "nfs.drc-size", &drc_size);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc size not set. Continuing with default size");
+        drc_size = DRC_DEFAULT_CACHE_SIZE;
+    }
+
+    LOCK(&drc->lock);
+
+    drc->type = drc_type;
+    drc->global_cache_size = drc_size;
+
+    /* Mempool for cached ops */
+    drc->mempool = mem_pool_new(drc_cached_op_t, drc->global_cache_size);
+    if (!drc->mempool) {
+        UNLOCK(&drc->lock);
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to get mempool for DRC, drc-size: %d", drc_size);
+        ret = -1;
+        goto post_unlock;
+    }
+
+    /* What percent of cache to be evicted whenever it fills up */
+    ret = dict_get_uint32(options, "nfs.drc-lru-factor", &drc_factor);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc lru factor not set. Continuing with policy default");
+        drc_factor = DRC_DEFAULT_LRU_FACTOR;
+    }
+
+    drc->lru_factor = (drc_lru_factor_t)drc_factor;
+
+    INIT_LIST_HEAD(&drc->clients_head);
+    INIT_LIST_HEAD(&drc->cache_head);
+
+    ret = rpcsvc_register_notify(svc, rpcsvc_drc_notify, THIS);
+    if (ret) {
+        UNLOCK(&drc->lock);
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "registration of drc_notify function failed");
+        goto post_unlock;
+    }
+
+    drc->status = DRC_INITIATED;
+    UNLOCK(&drc->lock);
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc init successful");
+post_unlock:
+    if (ret == -1) {
+        if (drc->mempool) {
+            mem_pool_destroy(drc->mempool);
+            drc->mempool = NULL;
         }
-        return ret;
+        GF_FREE(drc);
+        svc->drc = NULL;
+    }
+    return ret;
 }
 
 int
-rpcsvc_drc_deinit (rpcsvc_t *svc)
+rpcsvc_drc_deinit(rpcsvc_t *svc)
 {
-        rpcsvc_drc_globals_t *drc  = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
 
-        if (!svc)
-                return (-1);
+    if (!svc)
+        return (-1);
 
-        drc = svc->drc;
-        if (!drc)
-                return (0);
+    drc = svc->drc;
+    if (!drc)
+        return (0);
 
-        LOCK (&drc->lock);
-        (void) rpcsvc_unregister_notify (svc, rpcsvc_drc_notify, THIS);
-        if (drc->mempool) {
-                mem_pool_destroy (drc->mempool);
-                drc->mempool = NULL;
-        }
-        UNLOCK (&drc->lock);
+    LOCK(&drc->lock);
+    (void)rpcsvc_unregister_notify(svc, rpcsvc_drc_notify, THIS);
+    if (drc->mempool) {
+        mem_pool_destroy(drc->mempool);
+        drc->mempool = NULL;
+    }
+    UNLOCK(&drc->lock);
 
-        GF_FREE (drc);
-        svc->drc = NULL;
+    GF_FREE(drc);
+    svc->drc = NULL;
 
-        return (0);
+    return (0);
 }
 
 int
-rpcsvc_drc_reconfigure (rpcsvc_t *svc, dict_t *options)
+rpcsvc_drc_reconfigure(rpcsvc_t *svc, dict_t *options)
 {
-        int                     ret        = -1;
-        gf_boolean_t            enable_drc = _gf_false;
-        rpcsvc_drc_globals_t    *drc       = NULL;
-        uint32_t                drc_size   = 0;
-
-        /* Input sanitization */
-        if ((!svc) || (!options))
-                return (-1);
-
-        /* If DRC was not enabled before, Let rpcsvc_drc_init() to
-         * take care of DRC initialization part.
-         */
-        drc = svc->drc;
-        if (!drc) {
-                return rpcsvc_drc_init(svc, options);
-        }
-
-        /* DRC was already enabled before. Going to be reconfigured. Check
-         * if reconfigured options contain "nfs.drc" and "nfs.drc-size".
-         *
-         * NB: If DRC is "OFF", "drc-size" has no role to play.
-         *     So, "drc-size" gets evaluated IFF DRC is "ON".
-         *
-         * If DRC is reconfigured,
-         *     case 1: DRC is "ON"
-         *         sub-case 1: drc-size remains same
-         *              ACTION: Nothing to do.
-         *         sub-case 2: drc-size just changed
-         *              ACTION: rpcsvc_drc_deinit() followed by
-         *                      rpcsvc_drc_init().
-         *
-         *     case 2: DRC is "OFF"
-         *         ACTION: rpcsvc_drc_deinit()
-         */
-        ret = dict_get_str_boolean (options, "nfs.drc", _gf_false);
-        if (ret < 0)
-                ret = _gf_false;
-
-        enable_drc = ret;
-        gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF"));
-
-        /* case 1: DRC is "ON"*/
-        if (enable_drc) {
-                /* Fetch drc-size if reconfigured */
-                if (dict_get_uint32 (options, "nfs.drc-size", &drc_size))
-                        drc_size = DRC_DEFAULT_CACHE_SIZE;
-
-                /* case 1: sub-case 1*/
-                if (drc->global_cache_size == drc_size)
-                        return (0);
-
-                /* case 1: sub-case 2*/
-                (void) rpcsvc_drc_deinit (svc);
-                return rpcsvc_drc_init (svc, options);
-        }
-
-        /* case 2: DRC is "OFF" */
-        return rpcsvc_drc_deinit (svc);
+    int ret = -1;
+    gf_boolean_t enable_drc = _gf_false;
+    rpcsvc_drc_globals_t *drc = NULL;
+    uint32_t drc_size = 0;
+
+    /* Input sanitization */
+    if ((!svc) || (!options))
+        return (-1);
+
+    /* If DRC was not enabled before, Let rpcsvc_drc_init() to
+     * take care of DRC initialization part.
+     */
+    drc = svc->drc;
+    if (!drc) {
+        return rpcsvc_drc_init(svc, options);
+    }
+
+    /* DRC was already enabled before. Going to be reconfigured. Check
+     * if reconfigured options contain "nfs.drc" and "nfs.drc-size".
+     *
+     * NB: If DRC is "OFF", "drc-size" has no role to play.
+     *     So, "drc-size" gets evaluated IFF DRC is "ON".
+     *
+     * If DRC is reconfigured,
+     *     case 1: DRC is "ON"
+     *         sub-case 1: drc-size remains same
+     *              ACTION: Nothing to do.
+     *         sub-case 2: drc-size just changed
+     *              ACTION: rpcsvc_drc_deinit() followed by
+     *                      rpcsvc_drc_init().
+     *
+     *     case 2: DRC is "OFF"
+     *         ACTION: rpcsvc_drc_deinit()
+     */
+    ret = dict_get_str_boolean(options, "nfs.drc", _gf_false);
+    if (ret < 0)
+        ret = _gf_false;
+
+    enable_drc = ret;
+    gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF"));
+
+    /* case 1: DRC is "ON"*/
+    if (enable_drc) {
+        /* Fetch drc-size if reconfigured */
+        if (dict_get_uint32(options, "nfs.drc-size", &drc_size))
+            drc_size = DRC_DEFAULT_CACHE_SIZE;
+
+        /* case 1: sub-case 1*/
+        if (drc->global_cache_size == drc_size)
+            return (0);
+
+        /* case 1: sub-case 2*/
+        (void)rpcsvc_drc_deinit(svc);
+        return rpcsvc_drc_init(svc, options);
+    }
+
+    /* case 2: DRC is "OFF" */
+    return rpcsvc_drc_deinit(svc);
 }
diff --git a/rpc/rpc-lib/src/rpc-drc.h b/rpc/rpc-lib/src/rpc-drc.h
index cd9e2c73d32..ce66430809b 100644
--- a/rpc/rpc-lib/src/rpc-drc.h
+++ b/rpc/rpc-lib/src/rpc-drc.h
@@ -13,89 +13,85 @@
 
 #include "rpcsvc-common.h"
 #include "rpcsvc.h"
-#include "locking.h"
-#include "dict.h"
+#include <glusterfs/locking.h>
+#include <glusterfs/dict.h>
 #include "rb.h"
 
 /* per-client cache structure */
 struct drc_client {
-        uint32_t                   ref;
-        union gf_sock_union        sock_union;
-        /* pointers to the cache */
-        struct rb_table           *rbtree;
-        /* no. of ops currently cached */
-        uint32_t                   op_count;
-        struct list_head           client_list;
+    union gf_sock_union sock_union;
+    /* pointers to the cache */
+    struct rb_table *rbtree;
+    /* no. of ops currently cached */
+    uint32_t op_count;
+    gf_atomic_uint32_t ref;
+    struct list_head client_list;
 };
 
 struct drc_cached_op {
-        drc_op_state_t                 state;
-        uint32_t                       xid;
-        int                            prognum;
-        int                            progversion;
-        int                            procnum;
-        rpc_transport_msg_t            msg;
-        drc_client_t                  *client;
-        struct list_head               client_list;
-        struct list_head               global_list;
-        int32_t                        ref;
+    drc_op_state_t state;
+    int prognum;
+    int progversion;
+    int procnum;
+    rpc_transport_msg_t msg;
+    drc_client_t *client;
+    struct list_head client_list;
+    struct list_head global_list;
+    int32_t ref;
+    uint32_t xid;
 };
 
 /* global drc definitions */
-enum drc_status {
-        DRC_UNINITIATED,
-        DRC_INITIATED
-};
+enum drc_status { DRC_UNINITIATED, DRC_INITIATED };
 typedef enum drc_status drc_status_t;
 
 struct drc_globals {
-        /* allocator must be the first member since
-         * it is used so in gf_libavl_allocator
-         */
-        struct libavl_allocator   allocator;
-        drc_type_t                type;
-        /* configurable size parameter */
-        uint32_t                  global_cache_size;
-        drc_lru_factor_t          lru_factor;
-        gf_lock_t                 lock;
-        drc_status_t              status;
-        uint32_t                  op_count;
-        uint64_t                  cache_hits;
-        uint64_t                  intransit_hits;
-        struct mem_pool          *mempool;
-        struct list_head          cache_head;
-        uint32_t                  client_count;
-        struct list_head          clients_head;
+    /* allocator must be the first member since
+     * it is used so in gf_libavl_allocator
+     */
+    struct libavl_allocator allocator;
+    /* configurable size parameter */
+    gf_lock_t lock;
+    uint64_t cache_hits;
+    uint64_t intransit_hits;
+    struct mem_pool *mempool;
+    struct list_head cache_head;
+    struct list_head clients_head;
+    uint32_t op_count;
+    uint32_t client_count;
+    uint32_t global_cache_size;
+    drc_type_t type;
+    drc_lru_factor_t lru_factor;
+    drc_status_t status;
 };
 
 int
-rpcsvc_need_drc (rpcsvc_request_t *req);
+rpcsvc_need_drc(rpcsvc_request_t *req);
 
 drc_cached_op_t *
-rpcsvc_drc_lookup (rpcsvc_request_t *req);
+rpcsvc_drc_lookup(rpcsvc_request_t *req);
 
 int
-rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply);
+rpcsvc_send_cached_reply(rpcsvc_request_t *req, drc_cached_op_t *reply);
 
 int
-rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref,
-                    struct iovec *rpchdr, int rpchdrcount,
-                    struct iovec *proghdr, int proghdrcount,
-                    struct iovec *payload, int payloadcount);
+rpcsvc_cache_reply(rpcsvc_request_t *req, struct iobref *iobref,
+                   struct iovec *rpchdr, int rpchdrcount, struct iovec *proghdr,
+                   int proghdrcount, struct iovec *payload, int payloadcount);
 
 int
-rpcsvc_cache_request (rpcsvc_request_t *req);
+rpcsvc_cache_request(rpcsvc_request_t *req);
 
 int32_t
-rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc);
+rpcsvc_drc_priv(rpcsvc_drc_globals_t *drc);
 
 int
-rpcsvc_drc_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_drc_init(rpcsvc_t *svc, dict_t *options);
 
 int
-rpcsvc_drc_deinit (rpcsvc_t *svc);
+rpcsvc_drc_deinit(rpcsvc_t *svc);
 
 int
-rpcsvc_drc_reconfigure (rpcsvc_t *svc, dict_t *options);
+rpcsvc_drc_reconfigure(rpcsvc_t *svc, dict_t *options);
 
 #endif /* RPC_DRC_H */
diff --git a/rpc/rpc-lib/src/rpc-lib-messages.h b/rpc/rpc-lib/src/rpc-lib-messages.h
index 39258a161e3..2c0b820dbf9 100644
--- a/rpc/rpc-lib/src/rpc-lib-messages.h
+++ b/rpc/rpc-lib/src/rpc-lib-messages.h
@@ -11,70 +11,24 @@
 #ifndef _RPC_LIB_MESSAGES_H_
 #define _RPC_LIB_MESSAGES_H_
 
-#include "glfs-message-id.h"
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
+#include <glusterfs/glfs-message-id.h>
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
  */
 
-#define GLFS_RPC_LIB_BASE        GLFS_MSGID_COMP_RPC_LIB
-#define GLFS_NUM_MESSAGES        13
-#define GLFS_RPC_LIB_MSGID_END   (GLFS_RPC_LIB_BASE + GLFS_NUM_MESSAGES + 1)
-
-/* Messages with message IDs */
-
-#define glfs_msg_start_x GLFS_RPC_LIB_BASE, "Invalid: Start of messages"
-
-/*------------*/
-/* First slot is allocated for common transport msg ids */
-
-#define TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED          (GLFS_RPC_LIB_BASE + 1)
-
-#define TRANS_MSG_UNKNOWN_ADDR_FAMILY                (GLFS_RPC_LIB_BASE + 2)
-
-#define TRANS_MSG_REMOTE_HOST_ERROR                  (GLFS_RPC_LIB_BASE + 3)
-
-#define TRANS_MSG_DNS_RESOL_FAILED                   (GLFS_RPC_LIB_BASE + 4)
-
-#define TRANS_MSG_LISTEN_PATH_ERROR                  (GLFS_RPC_LIB_BASE + 5)
-
-#define TRANS_MSG_CONNECT_PATH_ERROR                 (GLFS_RPC_LIB_BASE + 6)
-
-#define TRANS_MSG_GET_ADDR_INFO_FAILED               (GLFS_RPC_LIB_BASE + 7)
-
-#define TRANS_MSG_PORT_BIND_FAILED                   (GLFS_RPC_LIB_BASE + 8)
-
-#define TRANS_MSG_INET_ERROR                         (GLFS_RPC_LIB_BASE + 9)
-
-#define TRANS_MSG_GET_NAME_INFO_FAILED               (GLFS_RPC_LIB_BASE + 10)
-
-#define TRANS_MSG_TRANSPORT_ERROR                    (GLFS_RPC_LIB_BASE + 11)
-
-#define TRANS_MSG_TIMEOUT_EXCEEDED                   (GLFS_RPC_LIB_BASE + 12)
-
-#define TRANS_MSG_SOCKET_BIND_ERROR                  (GLFS_RPC_LIB_BASE + 13)
-
-/*------------*/
-
-#define glfs_msg_end_x GLFS_RPC_LIB_MSGID_END, "Invalid: End of messages"
+GLFS_MSGID(RPC_LIB, TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED,
+           TRANS_MSG_UNKNOWN_ADDR_FAMILY, TRANS_MSG_REMOTE_HOST_ERROR,
+           TRANS_MSG_DNS_RESOL_FAILED, TRANS_MSG_LISTEN_PATH_ERROR,
+           TRANS_MSG_CONNECT_PATH_ERROR, TRANS_MSG_GET_ADDR_INFO_FAILED,
+           TRANS_MSG_PORT_BIND_FAILED, TRANS_MSG_INET_ERROR,
+           TRANS_MSG_GET_NAME_INFO_FAILED, TRANS_MSG_TRANSPORT_ERROR,
+           TRANS_MSG_TIMEOUT_EXCEEDED, TRANS_MSG_SOCKET_BIND_ERROR);
 
 #endif /* !_RPC_LIB_MESSAGES_H_ */
-
diff --git a/rpc/rpc-lib/src/rpc-transport.c b/rpc/rpc-lib/src/rpc-transport.c
index fc26f462c31..a6e201a9b36 100644
--- a/rpc/rpc-lib/src/rpc-transport.c
+++ b/rpc/rpc-lib/src/rpc-transport.c
@@ -12,700 +12,661 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/poll.h>
-#include <fnmatch.h>
 #include <stdint.h>
 
-#include "logging.h"
 #include "rpc-transport.h"
-#include "glusterfs.h"
-/* FIXME: xlator.h is needed for volume_option_t, need to define the datatype
- * in some other header
- */
-#include "xlator.h"
-#include "list.h"
 
 #ifndef GF_OPTION_LIST_EMPTY
 #define GF_OPTION_LIST_EMPTY(_opt) (_opt->value[0] == NULL)
 #endif
 
 int32_t
-rpc_transport_count (const char *transport_type)
+rpc_transport_count(const char *transport_type)
 {
-        char     *transport_dup   = NULL;
-        char     *saveptr         = NULL;
-        char     *ptr             = NULL;
-        int       count           = 0;
-
-        if (transport_type == NULL)
-                return -1;
-
-        transport_dup = gf_strdup (transport_type);
-        if (transport_dup == NULL) {
-                return -1;
-        }
-
-        ptr = strtok_r (transport_dup, ",", &saveptr);
-        while (ptr != NULL) {
-                count++;
-                ptr = strtok_r (NULL, ",", &saveptr);
-        }
-
-        GF_FREE (transport_dup);
-        return count;
+    char *transport_dup = NULL;
+    char *saveptr = NULL;
+    char *ptr = NULL;
+    int count = 0;
+
+    if (transport_type == NULL)
+        return -1;
+
+    transport_dup = gf_strdup(transport_type);
+    if (transport_dup == NULL) {
+        return -1;
+    }
+
+    ptr = strtok_r(transport_dup, ",", &saveptr);
+    while (ptr != NULL) {
+        count++;
+        ptr = strtok_r(NULL, ",", &saveptr);
+    }
+
+    GF_FREE(transport_dup);
+    return count;
 }
 
 int
-rpc_transport_get_myaddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                          struct sockaddr_storage *sa, size_t salen)
+rpc_transport_get_myaddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                         struct sockaddr_storage *sa, size_t salen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_myaddr (this, peeraddr, addrlen, sa, salen);
-
-out:
-        return ret;
-}
-
-int32_t
-rpc_transport_get_myname (rpc_transport_t *this, char *hostname, int hostlen)
-{
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    ret = this->ops->get_myaddr(this, peeraddr, addrlen, sa, salen);
 
-        ret = this->ops->get_myname (this, hostname, hostlen);
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-rpc_transport_get_peername (rpc_transport_t *this, char *hostname, int hostlen)
+rpc_transport_get_peername(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_peername (this, hostname, hostlen);
+    ret = this->ops->get_peername(this, hostname, hostlen);
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_transport_throttle (rpc_transport_t *this, gf_boolean_t onoff)
+rpc_transport_throttle(rpc_transport_t *this, gf_boolean_t onoff)
 {
-        int ret = 0;
+    if (!this->ops->throttle)
+        return -ENOSYS;
 
-        if (!this->ops->throttle)
-                return -ENOSYS;
-
-        ret = this->ops->throttle (this, onoff);
-
-        return ret;
+    return this->ops->throttle(this, onoff);
 }
 
 int32_t
-rpc_transport_get_peeraddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                            struct sockaddr_storage *sa, size_t salen)
+rpc_transport_get_peeraddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                           struct sockaddr_storage *sa, size_t salen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_peeraddr (this, peeraddr, addrlen, sa, salen);
+    ret = this->ops->get_peeraddr(this, peeraddr, addrlen, sa, salen);
 out:
-        return ret;
+    return ret;
 }
 
 void
-rpc_transport_pollin_destroy (rpc_transport_pollin_t *pollin)
+rpc_transport_pollin_destroy(rpc_transport_pollin_t *pollin)
 {
-        GF_VALIDATE_OR_GOTO ("rpc", pollin, out);
+    GF_VALIDATE_OR_GOTO("rpc", pollin, out);
 
-        if (pollin->iobref) {
-                iobref_unref (pollin->iobref);
-        }
+    if (pollin->iobref) {
+        iobref_unref(pollin->iobref);
+    }
 
-        if (pollin->private) {
-                /* */
-                GF_FREE (pollin->private);
-        }
+    if (pollin->private) {
+        /* */
+        GF_FREE(pollin->private);
+    }
 
-        GF_FREE (pollin);
+    GF_FREE(pollin);
 out:
-        return;
+    return;
 }
 
-
 rpc_transport_pollin_t *
-rpc_transport_pollin_alloc (rpc_transport_t *this, struct iovec *vector,
-                            int count, struct iobuf *hdr_iobuf,
-                            struct iobref *iobref, void *private)
+rpc_transport_pollin_alloc(rpc_transport_t *this, struct iovec *vector,
+                           int count, struct iobuf *hdr_iobuf,
+                           struct iobref *iobref, void *private)
 {
-        rpc_transport_pollin_t *msg = NULL;
-        msg = GF_CALLOC (1, sizeof (*msg), gf_common_mt_rpc_trans_pollin_t);
-        if (!msg) {
-                goto out;
-        }
+    rpc_transport_pollin_t *msg = NULL;
+    msg = GF_CALLOC(1, sizeof(*msg), gf_common_mt_rpc_trans_pollin_t);
+    if (!msg) {
+        goto out;
+    }
 
-        if (count > 1) {
-                msg->vectored = 1;
-        }
+    msg->trans = this;
+
+    if (count > 1) {
+        msg->vectored = 1;
+    }
 
-        memcpy (msg->vector, vector, count * sizeof (*vector));
-        msg->count = count;
-        msg->iobref = iobref_ref (iobref);
-        msg->private = private;
-        if (hdr_iobuf)
-                iobref_add (iobref, hdr_iobuf);
+    memcpy(msg->vector, vector, count * sizeof(*vector));
+    msg->count = count;
+    msg->iobref = iobref_ref(iobref);
+    msg->private = private;
+    if (hdr_iobuf)
+        iobref_add(iobref, hdr_iobuf);
 
 out:
-        return msg;
+    return msg;
 }
 
+void
+rpc_transport_cleanup(rpc_transport_t *trans)
+{
+    if (!trans)
+        return;
+
+    if (trans->fini)
+        trans->fini(trans);
+
+    if (trans->options) {
+        dict_unref(trans->options);
+        trans->options = NULL;
+    }
+
+    GF_FREE(trans->name);
+
+    if (trans->xl)
+        pthread_mutex_destroy(&trans->lock);
+
+    if (trans->dl_handle)
+        dlclose(trans->dl_handle);
 
+    GF_FREE(trans);
+}
 
 rpc_transport_t *
-rpc_transport_load (glusterfs_ctx_t *ctx, dict_t *options, char *trans_name)
+rpc_transport_load(glusterfs_ctx_t *ctx, dict_t *options, char *trans_name)
 {
-	struct rpc_transport *trans = NULL, *return_trans = NULL;
-	char *name = NULL;
-	void *handle = NULL;
-	char *type = NULL;
-	char str[] = "ERROR";
-	int32_t ret = -1;
-	int is_tcp = 0, is_unix = 0, is_ibsdp = 0;
-	volume_opt_list_t *vol_opt = NULL;
-        gf_boolean_t bind_insecure = _gf_false;
-        xlator_t   *this = NULL;
-
-	GF_VALIDATE_OR_GOTO("rpc-transport", options, fail);
-	GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail);
-	GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail);
-
-	trans = GF_CALLOC (1, sizeof (struct rpc_transport), gf_common_mt_rpc_trans_t);
-        if (!trans)
-                goto fail;
-
-        trans->name = gf_strdup (trans_name);
-        if (!trans->name)
-                goto fail;
-
-	trans->ctx = ctx;
-	type = str;
-
-	/* Backward compatibility */
-        ret = dict_get_str (options, "transport-type", &type);
-	if (ret < 0) {
-		ret = dict_set_str (options, "transport-type", "socket");
-		if (ret < 0)
-			gf_log ("dict", GF_LOG_DEBUG,
-				"setting transport-type failed");
-                else
-                        gf_log ("rpc-transport", GF_LOG_DEBUG,
-                                "missing 'option transport-type'. defaulting to "
-                                "\"socket\"");
-	} else {
-		{
-			/* Backword compatibility to handle * /client,
-			 * * /server.
-			 */
-			char *tmp = strchr (type, '/');
-			if (tmp)
-				*tmp = '\0';
-		}
-
-		is_tcp = strcmp (type, "tcp");
-		is_unix = strcmp (type, "unix");
-		is_ibsdp = strcmp (type, "ib-sdp");
-		if ((is_tcp == 0) ||
-		    (is_unix == 0) ||
-		    (is_ibsdp == 0)) {
-			if (is_unix == 0)
-				ret = dict_set_str (options,
-						    "transport.address-family",
-						    "unix");
-			if (is_ibsdp == 0)
-				ret = dict_set_str (options,
-						    "transport.address-family",
-						    "inet-sdp");
-
-			if (ret < 0)
-				gf_log ("dict", GF_LOG_DEBUG,
-					"setting address-family failed");
-
-			ret = dict_set_str (options,
-					    "transport-type", "socket");
-			if (ret < 0)
-				gf_log ("dict", GF_LOG_DEBUG,
-					"setting transport-type failed");
-		}
-	}
-
-        /* client-bind-insecure is for clients protocol, and
-         * bind-insecure for glusterd. Both mutually exclusive
-        */
-        ret = dict_get_str (options, "client-bind-insecure", &type);
-        if (ret)
-                ret = dict_get_str (options, "bind-insecure", &type);
-        if (ret == 0) {
-                ret = gf_string2boolean (type, &bind_insecure);
-                if (ret < 0) {
-                        gf_log ("rcp-transport", GF_LOG_WARNING,
-                                "bind-insecure option %s is not a"
-                                " valid bool option", type);
-                        goto fail;
-                }
-                if (_gf_true == bind_insecure)
-                        trans->bind_insecure = 1;
-                else
-                        trans->bind_insecure = 0;
-        } else {
-                /* By default allow bind insecure */
-                trans->bind_insecure = 1;
+    struct rpc_transport *trans = NULL, *return_trans = NULL;
+    char *name = NULL;
+    void *handle = NULL;
+    char *type = NULL;
+    static char str[] = "ERROR";
+    int32_t ret = -1;
+    int is_tcp = 0, is_unix = 0, is_ibsdp = 0;
+    volume_opt_list_t *vol_opt = NULL;
+    gf_boolean_t bind_insecure = _gf_false;
+    xlator_t *this = NULL;
+    gf_boolean_t success = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("rpc-transport", options, fail);
+    GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail);
+    GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail);
+
+    trans = GF_CALLOC(1, sizeof(struct rpc_transport),
+                      gf_common_mt_rpc_trans_t);
+    if (!trans)
+        goto fail;
+
+    trans->name = gf_strdup(trans_name);
+    if (!trans->name)
+        goto fail;
+
+    trans->ctx = ctx;
+    type = str;
+
+    /* Backward compatibility */
+    ret = dict_get_str_sizen(options, "transport-type", &type);
+    if (ret < 0) {
+        ret = dict_set_str_sizen(options, "transport-type", "socket");
+        if (ret < 0)
+            gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed");
+        else
+            gf_log("rpc-transport", GF_LOG_DEBUG,
+                   "missing 'option transport-type'. defaulting to "
+                   "\"socket\"");
+    } else {
+        {
+            /* Backward compatibility to handle * /client,
+             * * /server.
+             */
+            char *tmp = strchr(type, '/');
+            if (tmp)
+                *tmp = '\0';
         }
 
-	ret = dict_get_str (options, "transport-type", &type);
-	if (ret < 0) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"'option transport-type <xx>' missing in volume '%s'",
-			trans_name);
-		goto fail;
-	}
-
-	ret = gf_asprintf (&name, "%s/%s.so", RPC_TRANSPORTDIR, type);
-        if (-1 == ret) {
-                goto fail;
+        is_tcp = strcmp(type, "tcp");
+        is_unix = strcmp(type, "unix");
+        is_ibsdp = strcmp(type, "ib-sdp");
+        if ((is_tcp == 0) || (is_unix == 0) || (is_ibsdp == 0)) {
+            if (is_unix == 0)
+                ret = dict_set_str_sizen(options, "transport.address-family",
+                                         "unix");
+            if (is_ibsdp == 0)
+                ret = dict_set_str_sizen(options, "transport.address-family",
+                                         "inet-sdp");
+
+            if (ret < 0)
+                gf_log("dict", GF_LOG_DEBUG, "setting address-family failed");
+
+            ret = dict_set_str_sizen(options, "transport-type", "socket");
+            if (ret < 0)
+                gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed");
         }
-
-	gf_log ("rpc-transport", GF_LOG_DEBUG,
-		"attempt to load file %s", name);
-
-	handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
-	if (handle == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR, "%s", dlerror ());
-		gf_log ("rpc-transport", GF_LOG_WARNING,
-			"volume '%s': transport-type '%s' is not valid or "
-			"not found on this machine",
-			trans_name, type);
-		goto fail;
-	}
-
-        trans->dl_handle = handle;
-
-	trans->ops = dlsym (handle, "tops");
-	if (trans->ops == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (rpc_transport_ops) on %s", dlerror ());
-		goto fail;
-	}
-
-	*VOID(&(trans->init)) = dlsym (handle, "init");
-	if (trans->init == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (gf_rpc_transport_init) on %s", dlerror ());
-		goto fail;
-	}
-
-	*VOID(&(trans->fini)) = dlsym (handle, "fini");
-	if (trans->fini == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (gf_rpc_transport_fini) on %s", dlerror ());
-		goto fail;
-	}
-
-        *VOID(&(trans->reconfigure)) = dlsym (handle, "reconfigure");
-        if (trans->reconfigure == NULL) {
-                gf_log ("rpc-transport", GF_LOG_DEBUG,
-                        "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror());
+    }
+
+    /* client-bind-insecure is for clients protocol, and
+     * bind-insecure for glusterd. Both mutually exclusive
+     */
+    ret = dict_get_str_sizen(options, "client-bind-insecure", &type);
+    if (ret)
+        ret = dict_get_str_sizen(options, "bind-insecure", &type);
+    if (ret == 0) {
+        ret = gf_string2boolean(type, &bind_insecure);
+        if (ret < 0) {
+            gf_log("rcp-transport", GF_LOG_WARNING,
+                   "bind-insecure option %s is not a"
+                   " valid bool option",
+                   type);
+            goto fail;
         }
-
-	vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                             gf_common_mt_volume_opt_list_t);
-        if (!vol_opt) {
-                goto fail;
+        if (_gf_true == bind_insecure)
+            trans->bind_insecure = 1;
+        else
+            trans->bind_insecure = 0;
+    } else {
+        /* By default allow bind insecure */
+        trans->bind_insecure = 1;
+    }
+
+    ret = dict_get_str_sizen(options, "transport-type", &type);
+    if (ret < 0) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "'option transport-type <xx>' missing in volume '%s'",
+               trans_name);
+        goto fail;
+    }
+
+    ret = gf_asprintf(&name, "%s/%s.so", RPC_TRANSPORTDIR, type);
+    if (-1 == ret) {
+        goto fail;
+    }
+
+    if (dict_get_sizen(options, "notify-poller-death")) {
+        trans->notify_poller_death = 1;
+    }
+
+    gf_log("rpc-transport", GF_LOG_DEBUG, "attempt to load file %s", name);
+
+    handle = dlopen(name, RTLD_NOW);
+    if (handle == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR, "%s", dlerror());
+        gf_log("rpc-transport", GF_LOG_WARNING,
+               "volume '%s': transport-type '%s' is not valid or "
+               "not found on this machine",
+               trans_name, type);
+        goto fail;
+    }
+
+    trans->dl_handle = handle;
+
+    trans->ops = dlsym(handle, "tops");
+    if (trans->ops == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR, "dlsym (rpc_transport_ops) on %s",
+               dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->init)) = dlsym(handle, "init");
+    if (trans->init == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "dlsym (gf_rpc_transport_init) on %s", dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->fini)) = dlsym(handle, "fini");
+    if (trans->fini == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "dlsym (gf_rpc_transport_fini) on %s", dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->reconfigure)) = dlsym(handle, "reconfigure");
+    if (trans->reconfigure == NULL) {
+        gf_log("rpc-transport", GF_LOG_DEBUG,
+               "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror());
+    }
+
+    vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                        gf_common_mt_volume_opt_list_t);
+    if (!vol_opt) {
+        goto fail;
+    }
+
+    this = THIS;
+    vol_opt->given_opt = dlsym(handle, "options");
+    if (vol_opt->given_opt == NULL) {
+        gf_log("rpc-transport", GF_LOG_DEBUG,
+               "volume option validation not specified");
+    } else {
+        INIT_LIST_HEAD(&vol_opt->list);
+        list_add_tail(&vol_opt->list, &(this->volume_options));
+        if (xlator_options_validate_list(this, options, vol_opt, NULL)) {
+            gf_log("rpc-transport", GF_LOG_ERROR,
+                   "volume option validation failed");
+            goto fail;
         }
+    }
 
-        this = THIS;
-	vol_opt->given_opt = dlsym (handle, "options");
-	if (vol_opt->given_opt == NULL) {
-		gf_log ("rpc-transport", GF_LOG_DEBUG,
-			"volume option validation not specified");
-	} else {
-                INIT_LIST_HEAD (&vol_opt->list);
-		list_add_tail (&vol_opt->list, &(this->volume_options));
-                if (xlator_options_validate_list (this, options, vol_opt,
-                                                  NULL)) {
-			gf_log ("rpc-transport", GF_LOG_ERROR,
-				"volume option validation failed");
-			goto fail;
-		}
-	}
-
-        trans->options = options;
+    trans->options = dict_ref(options);
 
-        pthread_mutex_init (&trans->lock, NULL);
-        trans->xl = this;
+    pthread_mutex_init(&trans->lock, NULL);
+    trans->xl = this;
 
-	ret = trans->init (trans);
-	if (ret != 0) {
-		gf_log ("rpc-transport", GF_LOG_WARNING,
-			"'%s' initialization failed", type);
-		goto fail;
-	}
+    ret = trans->init(trans);
+    if (ret != 0) {
+        gf_log("rpc-transport", GF_LOG_WARNING, "'%s' initialization failed",
+               type);
+        goto fail;
+    }
 
-        INIT_LIST_HEAD (&trans->list);
+    INIT_LIST_HEAD(&trans->list);
+    GF_ATOMIC_INIT(trans->disconnect_progress, 0);
 
-        return_trans = trans;
+    return_trans = trans;
 
-        GF_FREE (name);
+    GF_FREE(name);
 
-	return return_trans;
+    success = _gf_true;
 
 fail:
-        if (trans) {
-                GF_FREE (trans->name);
+    if (!success) {
+        rpc_transport_cleanup(trans);
+        GF_FREE(name);
 
-                if (trans->dl_handle)
-                        dlclose (trans->dl_handle);
+        return_trans = NULL;
+    }
 
-                GF_FREE (trans);
+    if (vol_opt) {
+        if (!list_empty(&vol_opt->list)) {
+            list_del_init(&vol_opt->list);
         }
+        GF_FREE(vol_opt);
+    }
 
-        GF_FREE (name);
-
-        if (vol_opt && !list_empty (&vol_opt->list)) {
-                list_del_init (&vol_opt->list);
-                GF_FREE (vol_opt);
-        }
-
-        return NULL;
+    return return_trans;
 }
 
-
 int32_t
-rpc_transport_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
+rpc_transport_submit_request(rpc_transport_t *this, rpc_transport_req_t *req)
 {
-	int32_t                       ret          = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
-	GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
 
-	ret = this->ops->submit_request (this, req);
+    ret = this->ops->submit_request(this, req);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
+rpc_transport_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply)
 {
-	int32_t                   ret          = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
-	GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
 
-	ret = this->ops->submit_reply (this, reply);
+    ret = this->ops->submit_reply(this, reply);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_connect (rpc_transport_t *this, int port)
+rpc_transport_connect(rpc_transport_t *this, int port)
 {
-	int ret = -1;
+    int ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-	ret = this->ops->connect (this, port);
+    ret = this->ops->connect(this, port);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_listen (rpc_transport_t *this)
+rpc_transport_listen(rpc_transport_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-	ret = this->ops->listen (this);
+    ret = this->ops->listen(this);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_disconnect (rpc_transport_t *this, gf_boolean_t wait)
+rpc_transport_disconnect(rpc_transport_t *this, gf_boolean_t wait)
 {
-	int32_t ret = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-        ret = this->ops->disconnect (this, wait);
+    ret = this->ops->disconnect(this, wait);
 
 fail:
-	return ret;
+    return ret;
 }
 
-
-int32_t
-rpc_transport_destroy (rpc_transport_t *this)
+static void
+rpc_transport_destroy(rpc_transport_t *this)
 {
-	int32_t ret = -1;
+    struct dnscache6 *cache = NULL;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    if (this->clnt_options)
+        dict_unref(this->clnt_options);
+    if (this->options)
+        dict_unref(this->options);
+    if (this->fini)
+        this->fini(this);
 
-        if (this->clnt_options)
-                dict_unref (this->clnt_options);
-        if (this->options)
-                dict_unref (this->options);
-	if (this->fini)
-		this->fini (this);
+    pthread_mutex_destroy(&this->lock);
 
-	pthread_mutex_destroy (&this->lock);
+    GF_FREE(this->name);
 
-        GF_FREE (this->name);
+    if (this->dl_handle)
+        dlclose(this->dl_handle);
 
-        if (this->dl_handle)
-                dlclose (this->dl_handle);
+    if (this->ssl_name) {
+        GF_FREE(this->ssl_name);
+    }
 
-        if (this->ssl_name) {
-                GF_FREE(this->ssl_name);
-        }
+    if (this->dnscache) {
+        cache = this->dnscache;
+        if (cache->first)
+            freeaddrinfo(cache->first);
+        GF_FREE(this->dnscache);
+    }
 
-	GF_FREE (this);
-fail:
-	return ret;
+    GF_FREE(this);
 }
 
-
 rpc_transport_t *
-rpc_transport_ref (rpc_transport_t *this)
+rpc_transport_ref(rpc_transport_t *this)
 {
-	rpc_transport_t *return_this = NULL;
+    rpc_transport_t *return_this = NULL;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-	pthread_mutex_lock (&this->lock);
-	{
-		this->refcount ++;
-	}
-	pthread_mutex_unlock (&this->lock);
+    GF_ATOMIC_INC(this->refcount);
 
-	return_this = this;
+    return_this = this;
 fail:
-	return return_this;
+    return return_this;
 }
 
-
 int32_t
-rpc_transport_unref (rpc_transport_t *this)
+rpc_transport_unref(rpc_transport_t *this)
 {
-	int32_t refcount = 0;
-	int32_t ret = -1;
-
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
-
-	pthread_mutex_lock (&this->lock);
-	{
-                refcount = --this->refcount;
-	}
-	pthread_mutex_unlock (&this->lock);
-
-	if (refcount == 0) {
-                if (this->mydata)
-                        this->notify (this, this->mydata, RPC_TRANSPORT_CLEANUP,
-                                      NULL);
-                this->mydata = NULL;
-                this->notify = NULL;
-                rpc_transport_destroy (this);
-	}
-
-	ret = 0;
+    int32_t refcount = 0;
+    int32_t ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+
+    refcount = GF_ATOMIC_DEC(this->refcount);
+
+    if (refcount == 0) {
+        if (this->mydata)
+            this->notify(this, this->mydata, RPC_TRANSPORT_CLEANUP, NULL);
+        this->mydata = NULL;
+        this->notify = NULL;
+        rpc_transport_destroy(this);
+    }
+
+    ret = 0;
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_notify (rpc_transport_t *this, rpc_transport_event_t event,
-                      void *data, ...)
+rpc_transport_notify(rpc_transport_t *this, rpc_transport_event_t event,
+                     void *data, ...)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        if (this->notify != NULL) {
-                ret = this->notify (this, this->mydata, event, data);
-        } else {
-                ret = 0;
-        }
+    if (this->notify != NULL) {
+        ret = this->notify(this, this->mydata, event, data);
+    } else {
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-rpc_transport_register_notify (rpc_transport_t *trans,
-                               rpc_transport_notify_t notify, void *mydata)
+rpc_transport_register_notify(rpc_transport_t *trans,
+                              rpc_transport_notify_t notify, void *mydata)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", trans, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", trans, out);
 
-        trans->notify = notify;
-        trans->mydata = mydata;
+    trans->notify = notify;
+    trans->mydata = mydata;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
-//give negative values to skip setting that value
-//this function asserts if both the values are negative.
-//why call it if you dont set it.
+// give negative values to skip setting that value
+// this function asserts if both the values are negative.
+// why call it if you don't set it.
 int
-rpc_transport_keepalive_options_set (dict_t *options, int32_t interval,
-                                     int32_t time, int32_t timeout)
+rpc_transport_keepalive_options_set(dict_t *options, int32_t interval,
+                                    int32_t time, int32_t timeout)
 {
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (options);
-        GF_ASSERT ((interval > 0) || (time > 0));
+    GF_ASSERT(options);
+    GF_ASSERT((interval > 0) || (time > 0));
 
-        ret = dict_set_int32 (options,
-                "transport.socket.keepalive-interval", interval);
-        if (ret)
-                goto out;
+    ret = dict_set_int32_sizen(options, "transport.socket.keepalive-interval",
+                               interval);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options,
-                "transport.socket.keepalive-time", time);
-        if (ret)
-                goto out;
+    ret = dict_set_int32_sizen(options, "transport.socket.keepalive-time",
+                               time);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options,
-                "transport.tcp-user-timeout", timeout);
-        if (ret)
-                goto out;
+    ret = dict_set_int32_sizen(options, "transport.tcp-user-timeout", timeout);
+    if (ret)
+        goto out;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_transport_unix_options_build (dict_t **options, char *filepath,
-                                  int frame_timeout)
+rpc_transport_unix_options_build(dict_t *dict, char *filepath,
+                                 int frame_timeout)
 {
-        dict_t                  *dict = NULL;
-        char                    *fpath = NULL;
-        int                     ret = -1;
-
-        GF_ASSERT (filepath);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        fpath = gf_strdup (filepath);
-        if (!fpath) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (dict, "transport.socket.connect-path", fpath);
-        if (ret) {
-                GF_FREE (fpath);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "transport.address-family", "unix");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (dict, "transport.socket.nodelay", "off");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (dict, "transport.socket.keepalive", "off");
+    char *fpath = NULL;
+    int ret = -1;
+
+    GF_ASSERT(filepath);
+    GF_VALIDATE_OR_GOTO("rpc-transport", dict, out);
+
+    fpath = gf_strdup(filepath);
+    if (!fpath) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_dynstr_sizen(dict, "transport.socket.connect-path", fpath);
+    if (ret) {
+        GF_FREE(fpath);
+        goto out;
+    }
+
+    ret = dict_set_str_sizen(dict, "transport.address-family", "unix");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str_sizen(dict, "transport.socket.nodelay", "off");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str_sizen(dict, "transport-type", "socket");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str_sizen(dict, "transport.socket.keepalive", "off");
+    if (ret)
+        goto out;
+
+    if (frame_timeout > 0) {
+        ret = dict_set_int32_sizen(dict, "frame-timeout", frame_timeout);
         if (ret)
-                goto out;
-
-        if (frame_timeout > 0) {
-                ret = dict_set_int32 (dict, "frame-timeout", frame_timeout);
-                if (ret)
-                        goto out;
-        }
-
-        *options = dict;
+            goto out;
+    }
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
-        return ret;
+    return ret;
 }
 
 int
-rpc_transport_inet_options_build (dict_t **options, const char *hostname,
-                                  int port)
+rpc_transport_inet_options_build(dict_t *dict, const char *hostname, int port,
+                                 char *af)
 {
-        dict_t          *dict = NULL;
-        char            *host = NULL;
-        int             ret = -1;
-        char            *addr_family = "inet";
-
-        GF_ASSERT (options);
-        GF_ASSERT (hostname);
-        GF_ASSERT (port >= 1024);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        host = gf_strdup ((char*)hostname);
-        if (!host) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (dict, "remote-host", host);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set remote-host with %s", host);
-                GF_FREE (host);
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, "remote-port", port);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set remote-port with %d", port);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "address-family", addr_family);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set address-family to %s", addr_family);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set trans-type with socket");
-                goto out;
-        }
+    char *host = NULL;
+    int ret = -1;
+#ifdef IPV6_DEFAULT
+    static char *addr_family = "inet6";
+#else
+    static char *addr_family = "inet";
+#endif
 
-        *options = dict;
+    GF_ASSERT(hostname);
+    GF_ASSERT(port >= 1024);
+    GF_VALIDATE_OR_GOTO("rpc-transport", dict, out);
+
+    host = gf_strdup((char *)hostname);
+    if (!host) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_dynstr_sizen(dict, "remote-host", host);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-host with %s",
+               host);
+        GF_FREE(host);
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(dict, "remote-port", port);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-port with %d",
+               port);
+        goto out;
+    }
+
+    ret = dict_set_str_sizen(dict, "address-family",
+                             (af != NULL ? af : addr_family));
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set address-family to %s",
+               addr_family);
+        goto out;
+    }
+
+    ret = dict_set_str_sizen(dict, "transport-type", "socket");
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to set trans-type with socket");
+        goto out;
+    }
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
-
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/rpc-transport.h b/rpc/rpc-lib/src/rpc-transport.h
index 33f474e42c6..c499f0bb955 100644
--- a/rpc/rpc-lib/src/rpc-transport.h
+++ b/rpc/rpc-lib/src/rpc-transport.h
@@ -11,7 +11,6 @@
 #ifndef __RPC_TRANSPORT_H__
 #define __RPC_TRANSPORT_H__
 
-
 #include <inttypes.h>
 #ifdef GF_SOLARIS_HOST_OS
 #include <rpc/auth.h>
@@ -21,7 +20,6 @@
 
 #include <rpc/rpc_msg.h>
 
-
 #ifndef MAX_IOVEC
 #define MAX_IOVEC 16
 #endif
@@ -43,44 +41,45 @@
  */
 #define RPC_FRAGSIZE(fraghdr) ((uint32_t)(fraghdr & 0x7fffffffU))
 
-#define RPC_FRAGHDR_SIZE               4
-#define RPC_MSGTYPE_SIZE               8
+#define RPC_FRAGHDR_SIZE 4
+#define RPC_MSGTYPE_SIZE 8
 
 /* size of the msg from the start of call-body till and including credlen */
-#define RPC_CALL_BODY_SIZE             24
+#define RPC_CALL_BODY_SIZE 24
 
-#define RPC_REPLY_STATUS_SIZE          4
+#define RPC_REPLY_STATUS_SIZE 4
 
 #define RPC_AUTH_FLAVOUR_N_LENGTH_SIZE 8
 
-#define RPC_ACCEPT_STATUS_LEN          4
+#define RPC_ACCEPT_STATUS_LEN 4
 
 struct rpc_transport_ops;
 typedef struct rpc_transport rpc_transport_t;
 
-#include "dict.h"
-#include "compat.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/async.h>
 #include "rpcsvc-common.h"
 
 struct peer_info {
-        struct sockaddr_storage sockaddr;
-        socklen_t sockaddr_len;
-        char identifier[UNIX_PATH_MAX];
-        // OP-VERSION of clients
-        uint32_t max_op_version;
-        uint32_t min_op_version;
-        //Volume mounted by client
-        char volname[NAME_MAX];
+    // OP-VERSION of clients
+    uint32_t max_op_version;
+    uint32_t min_op_version;
+    struct sockaddr_storage sockaddr;
+    socklen_t sockaddr_len;
+    char identifier[UNIX_PATH_MAX];
+    // Volume mounted by client
+    char volname[NAME_MAX];
 };
 typedef struct peer_info peer_info_t;
 
 typedef enum msg_type msg_type_t;
 
 typedef enum {
-        RPC_TRANSPORT_ACCEPT,      /* New client has been accepted */
-        RPC_TRANSPORT_DISCONNECT,  /* Connection is disconnected */
-        RPC_TRANSPORT_CLEANUP,     /* connection is about to be freed */
-        /*RPC_TRANSPORT_READ,*/    /* An event used to enable rpcsvc to instruct
+    RPC_TRANSPORT_ACCEPT,          /* New client has been accepted */
+    RPC_TRANSPORT_DISCONNECT,      /* Connection is disconnected */
+    RPC_TRANSPORT_CLEANUP,         /* connection is about to be freed */
+    /*RPC_TRANSPORT_READ,*/        /* An event used to enable rpcsvc to instruct
                                     * transport the number of bytes to read.
                                     * This helps in reading large msgs, wherein
                                     * the rpc actors might decide to place the
@@ -92,54 +91,55 @@ typedef enum {
                                     * reading a single msg, this event may be
                                     * delivered more than once.
                                     */
-        RPC_TRANSPORT_MAP_XID_REQUEST, /* receiver of this event should send
-                                        * the prognum and procnum corresponding
-                                        * to xid.
-                                        */
-        RPC_TRANSPORT_MSG_RECEIVED,         /* Complete rpc msg has been read */
-        RPC_TRANSPORT_CONNECT,              /* client is connected to server */
-        RPC_TRANSPORT_MSG_SENT,
+    RPC_TRANSPORT_MAP_XID_REQUEST, /* receiver of this event should send
+                                    * the prognum and procnum corresponding
+                                    * to xid.
+                                    */
+    RPC_TRANSPORT_MSG_RECEIVED,    /* Complete rpc msg has been read */
+    RPC_TRANSPORT_CONNECT,         /* client is connected to server */
+    RPC_TRANSPORT_MSG_SENT,
+    RPC_TRANSPORT_EVENT_THREAD_DIED /* event-thread has died */
 } rpc_transport_event_t;
 
 struct rpc_transport_msg {
-        struct iovec     *rpchdr;
-        int               rpchdrcount;
-        struct iovec     *proghdr;
-        int               proghdrcount;
-        struct iovec     *progpayload;
-        int               progpayloadcount;
-        struct iobref    *iobref;
+    struct iovec *rpchdr;
+    struct iovec *proghdr;
+    int rpchdrcount;
+    int proghdrcount;
+    struct iovec *progpayload;
+    struct iobref *iobref;
+    int progpayloadcount;
 };
 typedef struct rpc_transport_msg rpc_transport_msg_t;
 
 struct rpc_transport_rsp {
-        struct iovec   *rsphdr;
-        int             rsphdr_count;
-        struct iovec   *rsp_payload;
-        int             rsp_payload_count;
-        struct iobref  *rsp_iobref;
+    struct iovec *rsphdr;
+    struct iovec *rsp_payload;
+    int rsphdr_count;
+    int rsp_payload_count;
+    struct iobref *rsp_iobref;
 };
 typedef struct rpc_transport_rsp rpc_transport_rsp_t;
 
 struct rpc_transport_req {
-        rpc_transport_msg_t  msg;
-        rpc_transport_rsp_t  rsp;
-        struct rpc_req      *rpc_req;
+    struct rpc_req *rpc_req;
+    rpc_transport_msg_t msg;
+    rpc_transport_rsp_t rsp;
 };
 typedef struct rpc_transport_req rpc_transport_req_t;
 
 struct rpc_transport_reply {
-        rpc_transport_msg_t  msg;
-        void                *private;
+    void *private;
+    rpc_transport_msg_t msg;
 };
 typedef struct rpc_transport_reply rpc_transport_reply_t;
 
 struct rpc_transport_data {
-        char is_request;
-        union {
-                rpc_transport_req_t   req;
-                rpc_transport_reply_t reply;
-        } data;
+    union {
+        rpc_transport_req_t req;
+        rpc_transport_reply_t reply;
+    } data;
+    char is_request;
 };
 typedef struct rpc_transport_data rpc_transport_data_t;
 
@@ -147,173 +147,166 @@ typedef struct rpc_transport_data rpc_transport_data_t;
  * rpc_request, hence these should be removed from request_info
  */
 struct rpc_request_info {
-        uint32_t            xid;
-        int                 prognum;
-        int                 progver;
-        int                 procnum;
-        void               *rpc_req; /* struct rpc_req */
-        rpc_transport_rsp_t rsp;
+    int prognum;
+    int progver;
+    void *rpc_req; /* struct rpc_req */
+    rpc_transport_rsp_t rsp;
+    int procnum;
+    uint32_t xid;
 };
 typedef struct rpc_request_info rpc_request_info_t;
 
+typedef int (*rpc_transport_notify_t)(rpc_transport_t *, void *mydata,
+                                      rpc_transport_event_t, void *data, ...);
 
-struct rpc_transport_pollin {
-        struct iovec vector[MAX_IOVEC];
-        int count;
-        char vectored;
-        void *private;
-        struct iobref *iobref;
-        char is_reply;
+struct rpc_transport {
+    struct rpc_transport_ops *ops;
+    rpc_transport_t *listener; /* listener transport to which
+                                * request for creation of this
+                                * transport came from. valid only
+                                * on server process.
+                                */
+
+    void *private;
+    struct _client *xl_private;
+    void *xl; /* Used for THIS */
+    void *mydata;
+    pthread_mutex_t lock;
+    gf_atomic_t refcount;
+    glusterfs_ctx_t *ctx;
+    dict_t *options;
+    char *name;
+    void *dnscache;
+    void *drc_client;
+    data_t *buf;
+    int32_t (*init)(rpc_transport_t *this);
+    void (*fini)(rpc_transport_t *this);
+    int (*reconfigure)(rpc_transport_t *this, dict_t *options);
+    rpc_transport_notify_t notify;
+    void *notify_data;
+    peer_info_t peerinfo;
+    peer_info_t myinfo;
+
+    uint64_t total_bytes_read;
+    uint64_t total_bytes_write;
+    uint32_t xid; /* RPC/XID used for callbacks */
+    int32_t outstanding_rpc_count;
+
+    struct list_head list;
+    void *dl_handle; /* handle of dlopen() */
+    char *ssl_name;
+    dict_t *clnt_options; /* store options received from
+                           * client */
+    gf_atomic_t disconnect_progress;
+    int bind_insecure;
+    /* connect_failed: saves the connect() syscall status as socket_t
+     * member holding connect() status can't be accessed by higher gfapi
+     * layer or in client management notification handler functions
+     */
+    gf_boolean_t connect_failed;
+    char notify_poller_death;
+    char poller_death_accept;
 };
-typedef struct rpc_transport_pollin rpc_transport_pollin_t;
-
-typedef int (*rpc_transport_notify_t) (rpc_transport_t *, void *mydata,
-                                       rpc_transport_event_t, void *data, ...);
-
 
-struct rpc_transport {
-        struct rpc_transport_ops  *ops;
-        rpc_transport_t           *listener; /* listener transport to which
-                                              * request for creation of this
-                                              * transport came from. valid only
-                                              * on server process.
-                                              */
-
-        void                      *private;
-        struct _client            *xl_private;
-        void                      *xl;       /* Used for THIS */
-        void                      *mydata;
-        pthread_mutex_t            lock;
-        int32_t                    refcount;
-
-        int32_t                    outstanding_rpc_count;
-
-        glusterfs_ctx_t           *ctx;
-        dict_t                    *options;
-        char                      *name;
-        void                      *dnscache;
-        void                      *drc_client;
-        data_t                    *buf;
-        int32_t                  (*init)   (rpc_transport_t *this);
-        void                     (*fini)   (rpc_transport_t *this);
-        int                      (*reconfigure) (rpc_transport_t *this, dict_t *options);
-        rpc_transport_notify_t     notify;
-        void                      *notify_data;
-        peer_info_t                peerinfo;
-        peer_info_t                myinfo;
-
-        uint64_t                   total_bytes_read;
-        uint64_t                   total_bytes_write;
-        uint32_t                   xid; /* RPC/XID used for callbacks */
-
-        struct list_head           list;
-        int                        bind_insecure;
-        void                      *dl_handle; /* handle of dlopen() */
-        char                      *ssl_name;
-        dict_t                    *clnt_options; /* store options received from
-                                                  * client */
-        /* connect_failed: saves the connect() syscall status as socket_t
-         * member holding connect() status can't be accessed by higher gfapi
-         * layer or in client management notification handler functions
-         */
-        gf_boolean_t               connect_failed;
+struct rpc_transport_pollin {
+    struct rpc_transport *trans;
+    void *private;
+    struct iobref *iobref;
+    struct iovec vector[MAX_IOVEC];
+    gf_async_t async;
+    int count;
+    char is_reply;
+    char vectored;
 };
+typedef struct rpc_transport_pollin rpc_transport_pollin_t;
 
 struct rpc_transport_ops {
-        /* no need of receive op, msg will be delivered through an event
-         * notification
-         */
-        int32_t (*submit_request) (rpc_transport_t *this,
-                                   rpc_transport_req_t *req);
-        int32_t (*submit_reply)   (rpc_transport_t *this,
-                                   rpc_transport_reply_t *reply);
-        int32_t (*connect)        (rpc_transport_t *this, int port);
-        int32_t (*listen)         (rpc_transport_t *this);
-        int32_t (*disconnect)     (rpc_transport_t *this, gf_boolean_t wait);
-        int32_t (*get_peername)   (rpc_transport_t *this, char *hostname,
-                                   int hostlen);
-        int32_t (*get_peeraddr)   (rpc_transport_t *this, char *peeraddr,
-                                   int addrlen, struct sockaddr_storage *sa,
-                                   socklen_t sasize);
-        int32_t (*get_myname)     (rpc_transport_t *this, char *hostname,
-                                   int hostlen);
-        int32_t (*get_myaddr)     (rpc_transport_t *this, char *peeraddr,
-                                   int addrlen, struct sockaddr_storage *sa,
-                                   socklen_t sasize);
-        int32_t (*throttle)       (rpc_transport_t *this, gf_boolean_t onoff);
+    /* no need of receive op, msg will be delivered through an event
+     * notification
+     */
+    int32_t (*submit_request)(rpc_transport_t *this, rpc_transport_req_t *req);
+    int32_t (*submit_reply)(rpc_transport_t *this,
+                            rpc_transport_reply_t *reply);
+    int32_t (*connect)(rpc_transport_t *this, int port);
+    int32_t (*listen)(rpc_transport_t *this);
+    int32_t (*disconnect)(rpc_transport_t *this, gf_boolean_t wait);
+    int32_t (*get_peername)(rpc_transport_t *this, char *hostname, int hostlen);
+    int32_t (*get_peeraddr)(rpc_transport_t *this, char *peeraddr, int addrlen,
+                            struct sockaddr_storage *sa, socklen_t sasize);
+    int32_t (*get_myname)(rpc_transport_t *this, char *hostname, int hostlen);
+    int32_t (*get_myaddr)(rpc_transport_t *this, char *peeraddr, int addrlen,
+                          struct sockaddr_storage *sa, socklen_t sasize);
+    int32_t (*throttle)(rpc_transport_t *this, gf_boolean_t onoff);
 };
 
 int32_t
-rpc_transport_count (const char *transport_type);
+rpc_transport_count(const char *transport_type);
 
 int32_t
-rpc_transport_listen (rpc_transport_t *this);
+rpc_transport_listen(rpc_transport_t *this);
 
 int32_t
-rpc_transport_connect (rpc_transport_t *this, int port);
+rpc_transport_connect(rpc_transport_t *this, int port);
 
 int32_t
-rpc_transport_disconnect (rpc_transport_t *this, gf_boolean_t wait);
+rpc_transport_disconnect(rpc_transport_t *this, gf_boolean_t wait);
 
 int32_t
-rpc_transport_destroy (rpc_transport_t *this);
+rpc_transport_notify(rpc_transport_t *this, rpc_transport_event_t event,
+                     void *data, ...);
 
 int32_t
-rpc_transport_notify (rpc_transport_t *this, rpc_transport_event_t event,
-                      void *data, ...);
+rpc_transport_submit_request(rpc_transport_t *this, rpc_transport_req_t *req);
 
 int32_t
-rpc_transport_submit_request (rpc_transport_t *this, rpc_transport_req_t *req);
-
-int32_t
-rpc_transport_submit_reply (rpc_transport_t *this,
-                            rpc_transport_reply_t *reply);
+rpc_transport_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply);
 
 rpc_transport_t *
-rpc_transport_load (glusterfs_ctx_t *ctx, dict_t *options, char *name);
+rpc_transport_load(glusterfs_ctx_t *ctx, dict_t *options, char *name);
 
 rpc_transport_t *
-rpc_transport_ref   (rpc_transport_t *trans);
+rpc_transport_ref(rpc_transport_t *trans);
 
 int32_t
-rpc_transport_unref (rpc_transport_t *trans);
+rpc_transport_unref(rpc_transport_t *trans);
 
 int
-rpc_transport_register_notify (rpc_transport_t *trans, rpc_transport_notify_t,
-                               void *mydata);
+rpc_transport_register_notify(rpc_transport_t *trans, rpc_transport_notify_t,
+                              void *mydata);
 
 int32_t
-rpc_transport_get_peername (rpc_transport_t *this, char *hostname, int hostlen);
+rpc_transport_get_peername(rpc_transport_t *this, char *hostname, int hostlen);
 
 int32_t
-rpc_transport_get_peeraddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                            struct sockaddr_storage *sa, size_t salen);
+rpc_transport_get_peeraddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                           struct sockaddr_storage *sa, size_t salen);
 
 int32_t
-rpc_transport_get_myname (rpc_transport_t *this, char *hostname, int hostlen);
-
-int32_t
-rpc_transport_get_myaddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                          struct sockaddr_storage *sa, size_t salen);
+rpc_transport_get_myaddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                         struct sockaddr_storage *sa, size_t salen);
 
 int
-rpc_transport_throttle (rpc_transport_t *this, gf_boolean_t onoff);
+rpc_transport_throttle(rpc_transport_t *this, gf_boolean_t onoff);
 
 rpc_transport_pollin_t *
-rpc_transport_pollin_alloc (rpc_transport_t *this, struct iovec *vector,
-                            int count, struct iobuf *hdr_iobuf,
-                            struct iobref *iobref, void *private);
+rpc_transport_pollin_alloc(rpc_transport_t *this, struct iovec *vector,
+                           int count, struct iobuf *hdr_iobuf,
+                           struct iobref *iobref, void *private);
 void
-rpc_transport_pollin_destroy (rpc_transport_pollin_t *pollin);
+rpc_transport_pollin_destroy(rpc_transport_pollin_t *pollin);
 
 int
-rpc_transport_keepalive_options_set (dict_t *options, int32_t interval,
-                                     int32_t time, int32_t timeout);
+rpc_transport_keepalive_options_set(dict_t *options, int32_t interval,
+                                    int32_t time, int32_t timeout);
 
 int
-rpc_transport_unix_options_build (dict_t **options, char *filepath,
-                                  int frame_timeout);
+rpc_transport_unix_options_build(dict_t *options, char *filepath,
+                                 int frame_timeout);
 
 int
-rpc_transport_inet_options_build (dict_t **options, const char *hostname, int port);
+rpc_transport_inet_options_build(dict_t *options, const char *hostname,
+                                 int port, char *af);
+
+void
+rpc_transport_cleanup(rpc_transport_t *);
 #endif /* __RPC_TRANSPORT_H__ */
diff --git a/rpc/rpc-lib/src/rpcsvc-auth.c b/rpc/rpc-lib/src/rpcsvc-auth.c
index b7d6c2216ef..8e76b4188bb 100644
--- a/rpc/rpc-lib/src/rpcsvc-auth.c
+++ b/rpc/rpc-lib/src/rpcsvc-auth.c
@@ -9,515 +9,553 @@
 */
 
 #include "rpcsvc.h"
-#include "logging.h"
-#include "dict.h"
+#include <glusterfs/dict.h>
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options);
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options);
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options);
 extern rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options);
+extern rpcsvc_auth_t *
+rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options);
 
 int
-rpcsvc_auth_add_initer (struct list_head *list, char *idfier,
-                        rpcsvc_auth_initer_t init)
+rpcsvc_auth_add_initer(struct list_head *list, char *idfier,
+                       rpcsvc_auth_initer_t init)
 {
-        struct rpcsvc_auth_list         *new = NULL;
+    struct rpcsvc_auth_list *new = NULL;
 
-        if ((!list) || (!init) || (!idfier))
-                return -1;
+    if ((!list) || (!init) || (!idfier))
+        return -1;
 
-        new = GF_CALLOC (1, sizeof (*new), gf_common_mt_rpcsvc_auth_list);
-        if (!new) {
-                return -1;
-        }
+    new = GF_CALLOC(1, sizeof(*new), gf_common_mt_rpcsvc_auth_list);
+    if (!new) {
+        return -1;
+    }
 
-        new->init = init;
-        strncpy (new->name, idfier, sizeof (new->name) - 1);
-        INIT_LIST_HEAD (&new->authlist);
-        list_add_tail (&new->authlist, list);
-        return 0;
+    new->init = init;
+    strncpy(new->name, idfier, sizeof(new->name) - 1);
+    INIT_LIST_HEAD(&new->authlist);
+    list_add_tail(&new->authlist, list);
+    return 0;
 }
 
-
-
 int
-rpcsvc_auth_add_initers (rpcsvc_t *svc)
+rpcsvc_auth_add_initers(rpcsvc_t *svc)
 {
-        int     ret = -1;
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_glusterfs_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS");
-                goto err;
-        }
-
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v2",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_glusterfs_v2_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "Failed to add AUTH_GLUSTERFS-v2");
-                goto err;
-        }
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-unix",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_unix_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX");
-                goto err;
-        }
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-null",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_null_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL");
-                goto err;
-        }
-
-        ret = 0;
+    int ret = -1;
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs-v2",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v2_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v2");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs-v3",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v3_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v3");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-unix",
+                                 (rpcsvc_auth_initer_t)rpcsvc_auth_unix_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-null",
+                                 (rpcsvc_auth_initer_t)rpcsvc_auth_null_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL");
+        goto err;
+    }
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_auth_init_auth (rpcsvc_t *svc, dict_t *options,
-                       struct rpcsvc_auth_list *authitem)
+rpcsvc_auth_init_auth(rpcsvc_t *svc, dict_t *options,
+                      struct rpcsvc_auth_list *authitem)
 {
-        int             ret = -1;
-
-        if ((!svc) || (!options) || (!authitem))
-                return -1;
-
-        if (!authitem->init) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "No init function defined");
-                ret = -1;
-                goto err;
-        }
-
-        authitem->auth = authitem->init (svc, options);
-        if (!authitem->auth) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Registration of auth failed:"
-                        " %s", authitem->name);
-                ret = -1;
-                goto err;
-        }
-
-        authitem->enable = 1;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s",
-                authitem->auth->authname);
-
-        ret = 0;
+    int ret = -1;
+
+    if ((!svc) || (!options) || (!authitem))
+        return -1;
+
+    if (!authitem->init) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "No init function defined");
+        ret = -1;
+        goto err;
+    }
+
+    authitem->auth = authitem->init(svc, options);
+    if (!authitem->auth) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Registration of auth failed:"
+               " %s",
+               authitem->name);
+        ret = -1;
+        goto err;
+    }
+
+    authitem->enable = 1;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s",
+           authitem->auth->authname);
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_auth_init_auths (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_init_auths(rpcsvc_t *svc, dict_t *options)
 {
-        int                     ret = -1;
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
+    int ret = -1;
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
 
-        if (!svc)
-                return -1;
+    if (!svc)
+        return -1;
 
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
-                ret = 0;
-                goto err;
-        }
-
-        /* If auth null and sys are not disabled by the user, we must enable
-         * it by default. This is a globally default rule, the user is still
-         * allowed to disable the two for particular subvolumes.
-         */
-        if (!dict_get (options, "rpc-auth.auth-null")) {
-                ret = dict_set_str (options, "rpc-auth.auth-null", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-nill'");
-        }
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
+        ret = 0;
+        goto err;
+    }
+
+    /* If auth null and sys are not disabled by the user, we must enable
+     * it by default. This is a globally default rule, the user is still
+     * allowed to disable the two for particular subvolumes.
+     */
+    if (!dict_get(options, "rpc-auth.auth-null")) {
+        ret = dict_set_str(options, "rpc-auth.auth-null", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-nill'");
+    }
 
-        if (!dict_get (options, "rpc-auth.auth-unix")) {
-                ret = dict_set_str (options, "rpc-auth.auth-unix", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-unix'");
-        }
+    if (!dict_get(options, "rpc-auth.auth-unix")) {
+        ret = dict_set_str(options, "rpc-auth.auth-unix", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'");
+    }
 
-        if (!dict_get (options, "rpc-auth.auth-glusterfs")) {
-                ret = dict_set_str (options, "rpc-auth.auth-glusterfs", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-unix'");
-        }
+    if (!dict_get(options, "rpc-auth.auth-glusterfs")) {
+        ret = dict_set_str(options, "rpc-auth.auth-glusterfs", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'");
+    }
 
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                ret = rpcsvc_auth_init_auth (svc, options, auth);
-                if (ret == -1)
-                        goto err;
-        }
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        ret = rpcsvc_auth_init_auth(svc, options, auth);
+        if (ret == -1)
+            goto err;
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
-
+    return ret;
 }
 
 int
-rpcsvc_set_addr_namelookup (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_addr_namelookup(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret;
-        static char     *addrlookup_key = "rpc-auth.addr.namelookup";
-
-        if (!svc || !options)
-                return (-1);
-
-        /* By default it's disabled */
-        ret = dict_get_str_boolean (options, addrlookup_key, _gf_false);
-        if (ret < 0) {
-                svc->addr_namelookup = _gf_false;
-        } else {
-                svc->addr_namelookup = ret;
-        }
+    int ret;
+    static char *addrlookup_key = "rpc-auth.addr.namelookup";
 
-        if (svc->addr_namelookup)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled");
+    if (!svc || !options)
+        return (-1);
 
-        return (0);
+    /* By default it's disabled */
+    ret = dict_get_str_boolean(options, addrlookup_key, _gf_false);
+    if (ret < 0) {
+        svc->addr_namelookup = _gf_false;
+    } else {
+        svc->addr_namelookup = ret;
+    }
+
+    if (svc->addr_namelookup)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled");
+
+    return (0);
 }
 
 int
-rpcsvc_set_allow_insecure (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_allow_insecure(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret = -1;
-        char            *allow_insecure_str = NULL;
-        gf_boolean_t    is_allow_insecure = _gf_false;
+    int ret = -1;
+    char *allow_insecure_str = NULL;
+    gf_boolean_t is_allow_insecure = _gf_false;
 
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
 
-        ret = dict_get_str (options, "rpc-auth-allow-insecure",
-                            &allow_insecure_str);
+    ret = dict_get_str(options, "rpc-auth-allow-insecure", &allow_insecure_str);
+    if (0 == ret) {
+        ret = gf_string2boolean(allow_insecure_str, &is_allow_insecure);
         if (0 == ret) {
-                ret = gf_string2boolean (allow_insecure_str,
-                                         &is_allow_insecure);
-                if (0 == ret) {
-                        if (_gf_true == is_allow_insecure)
-                                svc->allow_insecure = 1;
-                        else
-                                svc->allow_insecure = 0;
-                }
-        } else {
-                /* By default set allow-insecure to true */
+            if (_gf_true == is_allow_insecure)
                 svc->allow_insecure = 1;
-
-                /* setting in options for the sake of functions that look
-                 * configuration params for allow insecure,  eg: gf_auth
-                 */
-                ret = dict_set_str (options, "rpc-auth-allow-insecure", "on");
-                if (ret < 0)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                        "dict_set failed for 'allow-insecure'");
+            else
+                svc->allow_insecure = 0;
         }
+    } else {
+        /* By default set allow-insecure to true */
+        svc->allow_insecure = 1;
 
-        return ret;
+        /* setting in options for the sake of functions that look
+         * configuration params for allow insecure,  eg: gf_auth
+         */
+        ret = dict_set_str(options, "rpc-auth-allow-insecure", "on");
+        if (ret < 0)
+            gf_log("rpc-auth", GF_LOG_DEBUG,
+                   "dict_set failed for 'allow-insecure'");
+    }
+
+    return ret;
 }
 
 int
-rpcsvc_set_root_squash (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_root_squash(rpcsvc_t *svc, dict_t *options)
 {
-        int  ret = -1;
-        uid_t anonuid = -1;
-        gid_t anongid = -1;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
-
-        ret = dict_get_str_boolean (options, "root-squash", 0);
-        if (ret != -1)
-                svc->root_squash = ret;
-        else
-                svc->root_squash = _gf_false;
-
-        ret = dict_get_uint32 (options, "anonuid", &anonuid);
-        if (!ret)
-                svc->anonuid = anonuid;
-        else
-                svc->anonuid = RPC_NOBODY_UID;
-
-        ret = dict_get_uint32 (options, "anongid", &anongid);
-        if (!ret)
-                svc->anongid = anongid;
-        else
-                svc->anongid = RPC_NOBODY_GID;
-
-        if (svc->root_squash)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "root squashing enabled "
-                        "(uid=%d, gid=%d)", svc->anonuid, svc->anongid);
-
-        return 0;
+    int ret = -1;
+    uid_t anonuid = -1;
+    gid_t anongid = -1;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
+
+    ret = dict_get_str_boolean(options, "root-squash", 0);
+    if (ret != -1)
+        svc->root_squash = ret;
+    else
+        svc->root_squash = _gf_false;
+
+    ret = dict_get_uint32(options, "anonuid", &anonuid);
+    if (!ret)
+        svc->anonuid = anonuid;
+    else
+        svc->anonuid = RPC_NOBODY_UID;
+
+    ret = dict_get_uint32(options, "anongid", &anongid);
+    if (!ret)
+        svc->anongid = anongid;
+    else
+        svc->anongid = RPC_NOBODY_GID;
+
+    if (svc->root_squash)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "root squashing enabled "
+               "(uid=%d, gid=%d)",
+               svc->anonuid, svc->anongid);
+
+    return 0;
 }
 
 int
-rpcsvc_auth_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_all_squash(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret = -1;
-
-        if ((!svc) || (!options))
-                return -1;
-
-        (void) rpcsvc_set_allow_insecure (svc, options);
-        (void) rpcsvc_set_root_squash (svc, options);
-        (void) rpcsvc_set_addr_namelookup (svc, options);
-        ret = rpcsvc_auth_add_initers (svc);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers");
-                goto out;
-        }
+    int ret = -1;
+
+    uid_t anonuid = -1;
+    gid_t anongid = -1;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
+
+    ret = dict_get_str_boolean(options, "all-squash", 0);
+    if (ret != -1)
+        svc->all_squash = ret;
+    else
+        svc->all_squash = _gf_false;
+
+    ret = dict_get_uint32(options, "anonuid", &anonuid);
+    if (!ret)
+        svc->anonuid = anonuid;
+    else
+        svc->anonuid = RPC_NOBODY_UID;
+
+    ret = dict_get_uint32(options, "anongid", &anongid);
+    if (!ret)
+        svc->anongid = anongid;
+    else
+        svc->anongid = RPC_NOBODY_GID;
+
+    if (svc->all_squash)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "all squashing enabled "
+               "(uid=%d, gid=%d)",
+               svc->anonuid, svc->anongid);
+
+    return 0;
+}
 
-        ret = rpcsvc_auth_init_auths (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes");
-                goto out;
-        }
+int
+rpcsvc_auth_init(rpcsvc_t *svc, dict_t *options)
+{
+    int ret = -1;
+
+    if ((!svc) || (!options))
+        return -1;
+
+    (void)rpcsvc_set_allow_insecure(svc, options);
+    (void)rpcsvc_set_root_squash(svc, options);
+    (void)rpcsvc_set_all_squash(svc, options);
+    (void)rpcsvc_set_addr_namelookup(svc, options);
+    ret = rpcsvc_auth_add_initers(svc);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers");
+        goto out;
+    }
+
+    ret = rpcsvc_auth_init_auths(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_auth_reconf (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_reconf(rpcsvc_t *svc, dict_t *options)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if ((!svc) || (!options))
-                return (-1);
+    if ((!svc) || (!options))
+        return (-1);
 
-        ret = rpcsvc_set_allow_insecure (svc, options);
-        if (ret)
-                return (-1);
+    ret = rpcsvc_set_allow_insecure(svc, options);
+    if (ret)
+        return (-1);
 
-        ret = rpcsvc_set_root_squash (svc, options);
-        if (ret)
-                return (-1);
+    ret = rpcsvc_set_root_squash(svc, options);
+    if (ret)
+        return (-1);
 
-        return rpcsvc_set_addr_namelookup (svc, options);
-}
+    ret = rpcsvc_set_all_squash(svc, options);
+    if (ret)
+        return (-1);
 
+    return rpcsvc_set_addr_namelookup(svc, options);
+}
 
 rpcsvc_auth_t *
-__rpcsvc_auth_get_handler (rpcsvc_request_t *req)
+__rpcsvc_auth_get_handler(rpcsvc_request_t *req)
 {
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
-        rpcsvc_t                *svc = NULL;
-
-        if (!req)
-                return NULL;
-
-        svc = req->svc;
-        if (!svc) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "!svc");
-                goto err;
-        }
-
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
-                goto err;
-        }
-
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                if (!auth->enable)
-                        continue;
-                if (auth->auth->authnum == req->cred.flavour)
-                        goto err;
-
-        }
-
-        auth = NULL;
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
+    rpcsvc_t *svc = NULL;
+
+    if (!req)
+        return NULL;
+
+    svc = req->svc;
+    if (!svc) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "!svc");
+        goto err;
+    }
+
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
+        goto err;
+    }
+
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        if (!auth->enable)
+            continue;
+        if (auth->auth->authnum == req->cred.flavour)
+            goto err;
+    }
+
+    auth = NULL;
 err:
-        if (auth)
-                return auth->auth;
-        else
-                return NULL;
+    if (auth)
+        return auth->auth;
+    else
+        return NULL;
 }
 
 rpcsvc_auth_t *
-rpcsvc_auth_get_handler (rpcsvc_request_t *req)
+rpcsvc_auth_get_handler(rpcsvc_request_t *req)
 {
-        rpcsvc_auth_t           *auth = NULL;
+    rpcsvc_auth_t *auth = NULL;
 
-        auth = __rpcsvc_auth_get_handler (req);
-        if (auth)
-                goto ret;
+    auth = __rpcsvc_auth_get_handler(req);
+    if (auth)
+        goto ret;
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d",
-                req->cred.flavour);
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d", req->cred.flavour);
 
-        /* The requested scheme was not available so fall back the to one
-         * scheme that will always be present.
-         */
-        req->cred.flavour = AUTH_NULL;
-        req->verf.flavour = AUTH_NULL;
-        auth = __rpcsvc_auth_get_handler (req);
+    /* The requested scheme was not available so fall back the to one
+     * scheme that will always be present.
+     */
+    req->cred.flavour = AUTH_NULL;
+    req->verf.flavour = AUTH_NULL;
+    auth = __rpcsvc_auth_get_handler(req);
 ret:
-        return auth;
+    return auth;
 }
 
-
 int
-rpcsvc_auth_request_init (rpcsvc_request_t *req, struct rpc_msg *callmsg)
+rpcsvc_auth_request_init(rpcsvc_request_t *req, struct rpc_msg *callmsg)
 {
-        int32_t                 ret = 0;
-        rpcsvc_auth_t           *auth = NULL;
-
-        if (!req || !callmsg) {
-                ret = -1;
-                goto err;
-        }
-
-        req->cred.flavour = rpc_call_cred_flavour (callmsg);
-        req->cred.datalen = rpc_call_cred_len (callmsg);
-        req->verf.flavour = rpc_call_verf_flavour (callmsg);
-        req->verf.datalen = rpc_call_verf_len (callmsg);
-
-        auth = rpcsvc_auth_get_handler (req);
-        if (!auth) {
-                ret = -1;
-                goto err;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname);
-
-        if (auth->authops->request_init)
-              ret = auth->authops->request_init (req, auth->authprivate);
-
-        /* reset to auxgidlarge during
-           unsersialize if necessary */
-        req->auxgids = req->auxgidsmall;
-        req->auxgidlarge = NULL;
+    int32_t ret = 0;
+    rpcsvc_auth_t *auth = NULL;
+
+    if (!req || !callmsg) {
+        ret = -1;
+        goto err;
+    }
+
+    req->cred.flavour = rpc_call_cred_flavour(callmsg);
+    req->cred.datalen = rpc_call_cred_len(callmsg);
+    req->verf.flavour = rpc_call_verf_flavour(callmsg);
+    req->verf.datalen = rpc_call_verf_len(callmsg);
+
+    auth = rpcsvc_auth_get_handler(req);
+    if (!auth) {
+        ret = -1;
+        goto err;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname);
+
+    if (auth->authops->request_init)
+        ret = auth->authops->request_init(req, auth->authprivate);
+
+    /* reset to auxgidlarge during
+       unsersialize if necessary */
+    req->auxgids = req->auxgidsmall;
+    req->auxgidlarge = NULL;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_authenticate (rpcsvc_request_t *req)
+rpcsvc_authenticate(rpcsvc_request_t *req)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        rpcsvc_auth_t           *auth = NULL;
-        int                     minauth = 0;
-
-        if (!req)
-                return ret;
-
-        /* FIXME use rpcsvc_request_prog_minauth() */
-        minauth = 0;
-        if (minauth > rpcsvc_request_cred_flavour (req)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "Auth too weak");
-                rpcsvc_request_set_autherr (req, AUTH_TOOWEAK);
-                goto err;
-        }
+    int ret = RPCSVC_AUTH_REJECT;
+    rpcsvc_auth_t *auth = NULL;
+    int minauth = 0;
 
-        auth = rpcsvc_auth_get_handler (req);
-        if (!auth) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No auth handler found");
-                goto err;
-        }
+    if (!req)
+        return ret;
+
+    /* FIXME use rpcsvc_request_prog_minauth() */
+    minauth = 0;
+    if (minauth > rpcsvc_request_cred_flavour(req)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "Auth too weak");
+        rpcsvc_request_set_autherr(req, AUTH_TOOWEAK);
+        goto err;
+    }
+
+    auth = rpcsvc_auth_get_handler(req);
+    if (!auth) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No auth handler found");
+        goto err;
+    }
 
-        if (auth->authops->authenticate)
-                ret = auth->authops->authenticate (req, auth->authprivate);
+    if (auth->authops->authenticate)
+        ret = auth->authops->authenticate(req, auth->authprivate);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen)
+rpcsvc_auth_array(rpcsvc_t *svc, char *volname, int *autharr, int arrlen)
 {
-        int             count      = 0;
-        int             result     = RPCSVC_AUTH_REJECT;
-        char           *srchstr    = NULL;
-        int             ret        = 0;
-
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
+    int count = 0;
+    int result = RPCSVC_AUTH_REJECT;
+    char *srchstr = NULL;
+    int ret = 0;
+
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
+
+    if ((!svc) || (!autharr) || (!volname))
+        return -1;
+
+    memset(autharr, 0, arrlen * sizeof(int));
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "No authentication!");
+        goto err;
+    }
+
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        if (count >= arrlen)
+            break;
+
+        result = gf_asprintf(&srchstr, "rpc-auth.%s.%s", auth->name, volname);
+        if (result == -1) {
+            count = -1;
+            goto err;
+        }
 
-        if ((!svc) || (!autharr) || (!volname))
-                return -1;
+        ret = dict_get_str_boolean(svc->options, srchstr, 0xC00FFEE);
+        GF_FREE(srchstr);
 
-        memset (autharr, 0, arrlen * sizeof(int));
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "No authentication!");
-                goto err;
-        }
+        switch (ret) {
+            case _gf_true:
+                autharr[count] = auth->auth->authnum;
+                ++count;
+                break;
 
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                if (count >= arrlen)
-                        break;
-
-                result = gf_asprintf (&srchstr, "rpc-auth.%s.%s",
-                                      auth->name, volname);
-                if (result == -1) {
-                        count = -1;
-                        goto err;
-                }
-
-                ret = dict_get_str_boolean (svc->options, srchstr, 0xC00FFEE);
-                GF_FREE (srchstr);
-
-                switch (ret) {
-                case _gf_true:
-                        result = RPCSVC_AUTH_ACCEPT;
-                        autharr[count] = auth->auth->authnum;
-                        ++count;
-                        break;
-                case _gf_false:
-                        result = RPCSVC_AUTH_REJECT;
-                        break;
-                default:
-                        result = RPCSVC_AUTH_DONTCARE;
-                }
+            default:
+                /* nothing to do */
+                break;
         }
+    }
 
 err:
-        return count;
+    return count;
 }
 
 gid_t *
-rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen)
+rpcsvc_auth_unix_auxgids(rpcsvc_request_t *req, int *arrlen)
 {
-        if ((!req) || (!arrlen))
-                return NULL;
+    if ((!req) || (!arrlen))
+        return NULL;
 
-        /* In case of AUTH_NULL auxgids are not used */
-        switch (req->cred.flavour) {
+    /* In case of AUTH_NULL auxgids are not used */
+    switch (req->cred.flavour) {
         case AUTH_UNIX:
         case AUTH_GLUSTERFS:
         case AUTH_GLUSTERFS_v2:
-                break;
+        case AUTH_GLUSTERFS_v3:
+            break;
         default:
-                gf_log ("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs");
-                return NULL;
-        }
+            gf_log("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs");
+            return NULL;
+    }
 
-        *arrlen = req->auxgidcount;
-        if (*arrlen == 0)
-                return NULL;
+    *arrlen = req->auxgidcount;
+    if (*arrlen == 0)
+        return NULL;
 
-        return &req->auxgids[0];
+    return &req->auxgids[0];
 }
diff --git a/rpc/rpc-lib/src/rpcsvc-common.h b/rpc/rpc-lib/src/rpcsvc-common.h
index dd958032336..6c4ec49a6ef 100644
--- a/rpc/rpc-lib/src/rpcsvc-common.h
+++ b/rpc/rpc-lib/src/rpcsvc-common.h
@@ -12,24 +12,20 @@
 #define _RPCSVC_COMMON_H
 
 #include <pthread.h>
-#include "list.h"
-#include "compat.h"
-#include "glusterfs.h"
-#include "dict.h"
-#include "xlator.h"
+#include <glusterfs/compat.h>
+#include <glusterfs/dict.h>
 
 typedef enum {
-        RPCSVC_EVENT_ACCEPT,
-        RPCSVC_EVENT_DISCONNECT,
-        RPCSVC_EVENT_TRANSPORT_DESTROY,
-        RPCSVC_EVENT_LISTENER_DEAD,
+    RPCSVC_EVENT_ACCEPT,
+    RPCSVC_EVENT_DISCONNECT,
+    RPCSVC_EVENT_TRANSPORT_DESTROY,
+    RPCSVC_EVENT_LISTENER_DEAD,
 } rpcsvc_event_t;
 
-
 struct rpcsvc_state;
 
-typedef int (*rpcsvc_notify_t) (struct rpcsvc_state *, void *mydata,
-                                rpcsvc_event_t, void *data);
+typedef int (*rpcsvc_notify_t)(struct rpcsvc_state *, void *mydata,
+                               rpcsvc_event_t, void *data);
 
 struct drc_globals;
 typedef struct drc_globals rpcsvc_drc_globals_t;
@@ -37,95 +33,80 @@ typedef struct drc_globals rpcsvc_drc_globals_t;
 /* Contains global state required for all the RPC services.
  */
 typedef struct rpcsvc_state {
-
-        /* Contains list of (program, version) handlers.
-         * other options.
-         */
-
-        pthread_mutex_t         rpclock;
-
-        unsigned int            memfactor;
-
-        /* List of the authentication schemes available. */
-        struct list_head        authschemes;
-
-        /* Reference to the options */
-        dict_t                  *options;
-
-        /* Allow insecure ports. */
-        gf_boolean_t            allow_insecure;
-        gf_boolean_t            register_portmap;
-        gf_boolean_t            root_squash;
-        uid_t                   anonuid;
-        gid_t                   anongid;
-        glusterfs_ctx_t         *ctx;
-
-        /* list of connections which will listen for incoming connections */
-        struct list_head        listeners;
-
-        /* list of programs registered with rpcsvc */
-        struct list_head        programs;
-
-        /* list of notification callbacks */
-        struct list_head        notify;
-        int                     notify_count;
-
-        xlator_t                *xl;      /* xlator */
-        void                    *mydata;
-        rpcsvc_notify_t         notifyfn;
-        struct mem_pool         *rxpool;
-        rpcsvc_drc_globals_t    *drc;
-
-	/* per-client limit of outstanding rpc requests */
-        int                     outstanding_rpc_limit;
-        gf_boolean_t            addr_namelookup;
-        /* determine whether throttling is needed, by default OFF */
-        gf_boolean_t            throttle;
+    /* Contains list of (program, version) handlers.
+     * other options.
+     */
+
+    pthread_rwlock_t rpclock;
+
+    /* List of the authentication schemes available. */
+    struct list_head authschemes;
+
+    /* Reference to the options */
+    dict_t *options;
+
+    uid_t anonuid;
+    gid_t anongid;
+    glusterfs_ctx_t *ctx;
+
+    /* list of connections which will listen for incoming connections */
+    struct list_head listeners;
+
+    /* list of programs registered with rpcsvc */
+    struct list_head programs;
+
+    /* list of notification callbacks */
+    struct list_head notify;
+    int notify_count;
+
+    unsigned int memfactor;
+
+    xlator_t *xl; /* xlator */
+    void *mydata;
+    rpcsvc_notify_t notifyfn;
+    struct mem_pool *rxpool;
+    rpcsvc_drc_globals_t *drc;
+
+    /* per-client limit of outstanding rpc requests */
+    int outstanding_rpc_limit;
+    gf_boolean_t addr_namelookup;
+    /* determine whether throttling is needed, by default OFF */
+    gf_boolean_t throttle;
+    /* Allow insecure ports. */
+    gf_boolean_t allow_insecure;
+    gf_boolean_t register_portmap;
+    gf_boolean_t root_squash;
+    gf_boolean_t all_squash;
 } rpcsvc_t;
 
 /* DRC START */
-enum drc_op_type {
-        DRC_NA              = 0,
-        DRC_IDEMPOTENT      = 1,
-        DRC_NON_IDEMPOTENT  = 2
-};
+enum drc_op_type { DRC_NA = 0, DRC_IDEMPOTENT = 1, DRC_NON_IDEMPOTENT = 2 };
 typedef enum drc_op_type drc_op_type_t;
 
-enum drc_type {
-        DRC_TYPE_NONE        = 0,
-        DRC_TYPE_IN_MEMORY   = 1
-};
+enum drc_type { DRC_TYPE_NONE = 0, DRC_TYPE_IN_MEMORY = 1 };
 typedef enum drc_type drc_type_t;
 
 enum drc_lru_factor {
-        DRC_LRU_5_PC       = 20,
-        DRC_LRU_10_PC      = 10,
-        DRC_LRU_25_PC      = 4,
-        DRC_LRU_50_PC      = 2
+    DRC_LRU_5_PC = 20,
+    DRC_LRU_10_PC = 10,
+    DRC_LRU_25_PC = 4,
+    DRC_LRU_50_PC = 2
 };
 typedef enum drc_lru_factor drc_lru_factor_t;
 
-enum drc_xid_state {
-        DRC_XID_MONOTONOUS  = 0,
-        DRC_XID_WRAPPED     = 1
-};
+enum drc_xid_state { DRC_XID_MONOTONOUS = 0, DRC_XID_WRAPPED = 1 };
 typedef enum drc_xid_state drc_xid_state_t;
 
-enum drc_op_state {
-        DRC_OP_IN_TRANSIT    = 0,
-        DRC_OP_CACHED        = 1
-};
+enum drc_op_state { DRC_OP_IN_TRANSIT = 0, DRC_OP_CACHED = 1 };
 typedef enum drc_op_state drc_op_state_t;
 
-enum drc_policy {
-        DRC_LRU              = 0
-};
+enum drc_policy { DRC_LRU = 0 };
 typedef enum drc_policy drc_policy_t;
 
 /* Default policies for DRC */
-#define DRC_DEFAULT_TYPE               DRC_TYPE_IN_MEMORY
-#define DRC_DEFAULT_CACHE_SIZE         0x20000
-#define DRC_DEFAULT_LRU_FACTOR         DRC_LRU_25_PC
+#define DRC_DEFAULT_TYPE DRC_TYPE_IN_MEMORY
+#define DRC_DEFAULT_CACHE_SIZE 0x20000
+#define DRC_DEFAULT_LRU_FACTOR DRC_LRU_25_PC
 
 /* DRC END */
 
diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c
index 68e27ab9e3f..39910d481bf 100644
--- a/rpc/rpc-lib/src/rpcsvc.c
+++ b/rpc/rpc-lib/src/rpcsvc.c
@@ -10,19 +10,16 @@
 
 #include "rpcsvc.h"
 #include "rpc-transport.h"
-#include "dict.h"
-#include "logging.h"
-#include "byte-order.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "list.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/statedump.h>
 #include "xdr-rpc.h"
-#include "iobuf.h"
-#include "globals.h"
+#include <glusterfs/iobuf.h>
 #include "xdr-common.h"
 #include "xdr-generic.h"
 #include "rpc-common-xdr.h"
-#include "syncop.h"
+#include <glusterfs/syncop.h>
 #include "rpc-drc.h"
 #include "protocol-common.h"
 
@@ -36,1175 +33,1364 @@
 #include <fnmatch.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <dlfcn.h>
+
+#ifdef IPV6_DEFAULT
+#include <netconfig.h>
+#endif
 
 #include "xdr-rpcclnt.h"
-#include "glusterfs-acl.h"
+#include <glusterfs/glusterfs-acl.h>
+
+#ifndef PTHREAD_MUTEX_ADAPTIVE_NP
+#define PTHREAD_MUTEX_ADAPTIVE_NP PTHREAD_MUTEX_DEFAULT
+#endif
 
-struct rpcsvc_program gluster_dump_prog;
+static struct rpcsvc_program gluster_dump_prog;
 
-#define rpcsvc_alloc_request(svc, request)                              \
-        do {                                                            \
-                request = (rpcsvc_request_t *) mem_get ((svc)->rxpool); \
-                memset (request, 0, sizeof (rpcsvc_request_t));         \
-        } while (0)
+#define rpcsvc_alloc_request(svc, request)                                     \
+    do {                                                                       \
+        request = (rpcsvc_request_t *)mem_get((svc)->rxpool);                  \
+        if (request) {                                                         \
+            memset(request, 0, sizeof(rpcsvc_request_t));                      \
+        } else {                                                               \
+            gf_log("rpcsvc", GF_LOG_ERROR,                                     \
+                   "error getting memory for rpc request");                    \
+        }                                                                      \
+    } while (0)
 
 rpcsvc_listener_t *
-rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans);
+rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans);
 
 int
-rpcsvc_notify (rpc_transport_t *trans, void *mydata,
-               rpc_transport_event_t event, void *data, ...);
+rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event,
+              void *data, ...);
+void *
+rpcsvc_request_handler(void *arg);
 
 static int
-rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr);
+rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr);
 
-rpcsvc_notify_wrapper_t *
-rpcsvc_notify_wrapper_alloc (void)
+static void
+rpcsvc_toggle_queue_status(rpcsvc_program_t *prog,
+                           rpcsvc_request_queue_t *queue,
+                           unsigned long status[])
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
+    unsigned queue_index = queue - prog->request_queue;
 
-        wrapper = GF_CALLOC (1, sizeof (*wrapper), gf_common_mt_rpcsvc_wrapper_t);
-        if (!wrapper) {
-                goto out;
+    status[queue_index / __BITS_PER_LONG] ^= (1UL << (queue_index %
+                                                      __BITS_PER_LONG));
+}
+
+int
+rpcsvc_get_free_queue_index(rpcsvc_program_t *prog)
+{
+    unsigned i, j = 0;
+
+    for (i = 0; i < EVENT_MAX_THREADS / __BITS_PER_LONG; i++)
+        if (prog->request_queue_status[i] != ULONG_MAX) {
+            j = __builtin_ctzl(~prog->request_queue_status[i]);
+            break;
         }
 
-        INIT_LIST_HEAD (&wrapper->list);
-out:
-        return wrapper;
+    if (i == EVENT_MAX_THREADS / __BITS_PER_LONG)
+        return -1;
+
+    prog->request_queue_status[i] |= (1UL << j);
+    return i * __BITS_PER_LONG + j;
 }
 
+rpcsvc_notify_wrapper_t *
+rpcsvc_notify_wrapper_alloc(void)
+{
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
+
+    wrapper = GF_CALLOC(1, sizeof(*wrapper), gf_common_mt_rpcsvc_wrapper_t);
+    if (!wrapper) {
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&wrapper->list);
+out:
+    return wrapper;
+}
 
 void
-rpcsvc_listener_destroy (rpcsvc_listener_t *listener)
+rpcsvc_listener_destroy(rpcsvc_listener_t *listener)
 {
-        rpcsvc_t *svc = NULL;
+    rpcsvc_t *svc = NULL;
 
-        if (!listener) {
-                goto out;
-        }
+    if (!listener) {
+        goto out;
+    }
 
-        svc = listener->svc;
-        if (!svc) {
-                goto listener_free;
-        }
+    svc = listener->svc;
+    if (!svc) {
+        goto listener_free;
+    }
 
-        pthread_mutex_lock (&svc->rpclock);
-        {
-                list_del_init (&listener->list);
-        }
-        pthread_mutex_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_del_init(&listener->list);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
 listener_free:
-        GF_FREE (listener);
+    GF_FREE(listener);
 out:
-        return;
+    return;
 }
 
 rpcsvc_vector_sizer
-rpcsvc_get_program_vector_sizer (rpcsvc_t *svc, uint32_t prognum,
-                                 uint32_t progver, int procnum)
+rpcsvc_get_program_vector_sizer(rpcsvc_t *svc, uint32_t prognum,
+                                uint32_t progver, int procnum)
 {
-        rpcsvc_program_t        *program = NULL;
-        char                    found    = 0;
+    rpcsvc_program_t *program = NULL;
+    char found = 0;
 
-        if (!svc)
-                return NULL;
+    if (!svc)
+        return NULL;
 
-        pthread_mutex_lock (&svc->rpclock);
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        /* Find the matching RPC program from registered list */
+        list_for_each_entry(program, &svc->programs, program)
         {
-                /* Find the matching RPC program from registered list */
-                list_for_each_entry (program, &svc->programs, program) {
-                        if ((program->prognum == prognum)
-                            && (program->progver == progver)) {
-                                found = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == prognum) &&
+                (program->progver == progver)) {
+                found = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&svc->rpclock);
-
-        if (found) {
-                /* Make sure the requested procnum is supported by RPC prog */
-                if ((procnum < 0) || (procnum >= program->numactors)) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "RPC procedure %d not available for Program %s",
-                                procnum, program->progname);
-                        return NULL;
-                }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-                /* SUCCESS: Supported procedure */
-                return program->actors[procnum].vector_sizer;
+    if (found) {
+        /* Make sure the requested procnum is supported by RPC prog */
+        if ((procnum < 0) || (procnum >= program->numactors)) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "RPC procedure %d not available for Program %s", procnum,
+                   program->progname);
+            return NULL;
         }
 
-        return NULL; /* FAIL */
+        /* SUCCESS: Supported procedure */
+        return program->actors[procnum].vector_sizer;
+    }
+
+    return NULL; /* FAIL */
 }
 
 gf_boolean_t
-rpcsvc_can_outstanding_req_be_ignored (rpcsvc_request_t *req)
+rpcsvc_can_outstanding_req_be_ignored(rpcsvc_request_t *req)
 {
-        /*
-         * If outstanding_rpc_limit is reached because of blocked locks and
-         * throttling is attempted then no unlock requests will be received. So
-         * the outstanding request count will never change i.e. it will always
-         * be equal to the limit. This also leads to ping timer expiry on
-         * client.
-         */
-
-        /*
-         * This is a hack and a necessity until grantedlock == fop completion.
-         * Ideally if we get a blocking lock request which cannot be granted
-         * right now, we should unwind the fop saying “request registered, will
-         * notify you when granted”, which is very hard to implement at the
-         * moment. Until we bring in such mechanism, we will need to live with
-         * not rate-limiting INODELK/ENTRYLK/LK fops
-         */
-
-        if ((req->prognum == GLUSTER_FOP_PROGRAM) &&
-            (req->progver == GLUSTER_FOP_VERSION)) {
-                if ((req->procnum == GFS3_OP_INODELK) ||
-                    (req->procnum == GFS3_OP_FINODELK) ||
-                    (req->procnum == GFS3_OP_ENTRYLK) ||
-                    (req->procnum == GFS3_OP_FENTRYLK) ||
-                    (req->procnum == GFS3_OP_LK))
-                        return _gf_true;
-        }
-        return _gf_false;
+    /*
+     * If outstanding_rpc_limit is reached because of blocked locks and
+     * throttling is attempted then no unlock requests will be received. So
+     * the outstanding request count will never change i.e. it will always
+     * be equal to the limit. This also leads to ping timer expiry on
+     * client.
+     */
+
+    /*
+     * This is a hack and a necessity until grantedlock == fop completion.
+     * Ideally if we get a blocking lock request which cannot be granted
+     * right now, we should unwind the fop saying “request registered, will
+     * notify you when granted”, which is very hard to implement at the
+     * moment. Until we bring in such mechanism, we will need to live with
+     * not rate-limiting INODELK/ENTRYLK/LK fops
+     */
+
+    if ((req->prognum == GLUSTER_FOP_PROGRAM) &&
+        (req->progver == GLUSTER_FOP_VERSION)) {
+        if ((req->procnum == GFS3_OP_INODELK) ||
+            (req->procnum == GFS3_OP_FINODELK) ||
+            (req->procnum == GFS3_OP_ENTRYLK) ||
+            (req->procnum == GFS3_OP_FENTRYLK) || (req->procnum == GFS3_OP_LK))
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 int
-rpcsvc_request_outstanding (rpcsvc_request_t *req, int delta)
+rpcsvc_request_outstanding(rpcsvc_request_t *req, int delta)
 {
-        int             ret = -1;
-        int             old_count = 0;
-        int             new_count = 0;
-        int             limit = 0;
-        gf_boolean_t    throttle = _gf_false;
+    int ret = -1;
+    int old_count = 0;
+    int new_count = 0;
+    int limit = 0;
+    gf_boolean_t throttle = _gf_false;
 
-        if (!req)
-                goto out;
+    if (!req)
+        goto out;
 
-        throttle = rpcsvc_get_throttle (req->svc);
-        if (!throttle) {
-                ret = 0;
-                goto out;
-        }
+    throttle = rpcsvc_get_throttle(req->svc);
+    if (!throttle) {
+        ret = 0;
+        goto out;
+    }
 
-        if (rpcsvc_can_outstanding_req_be_ignored (req)) {
-                ret = 0;
-                goto out;
-        }
+    if (rpcsvc_can_outstanding_req_be_ignored(req)) {
+        ret = 0;
+        goto out;
+    }
 
-        pthread_mutex_lock (&req->trans->lock);
-        {
-                limit = req->svc->outstanding_rpc_limit;
-                if (!limit)
-                        goto unlock;
+    pthread_mutex_lock(&req->trans->lock);
+    {
+        limit = req->svc->outstanding_rpc_limit;
+        if (!limit)
+            goto unlock;
 
-                old_count = req->trans->outstanding_rpc_count;
-                req->trans->outstanding_rpc_count += delta;
-                new_count = req->trans->outstanding_rpc_count;
+        old_count = req->trans->outstanding_rpc_count;
+        req->trans->outstanding_rpc_count += delta;
+        new_count = req->trans->outstanding_rpc_count;
 
-                if (old_count <= limit && new_count > limit)
-                        ret = rpc_transport_throttle (req->trans, _gf_true);
+        if (old_count <= limit && new_count > limit)
+            ret = rpc_transport_throttle(req->trans, _gf_true);
 
-                if (old_count > limit && new_count <= limit)
-                        ret = rpc_transport_throttle (req->trans, _gf_false);
-        }
+        if (old_count > limit && new_count <= limit)
+            ret = rpc_transport_throttle(req->trans, _gf_false);
+    }
 unlock:
-        pthread_mutex_unlock (&req->trans->lock);
+    pthread_mutex_unlock(&req->trans->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* This needs to change to returning errors, since
  * we need to return RPC specific error messages when some
  * of the pointers below are NULL.
  */
 rpcsvc_actor_t *
-rpcsvc_program_actor (rpcsvc_request_t *req)
+rpcsvc_program_actor(rpcsvc_request_t *req)
 {
-        rpcsvc_program_t        *program = NULL;
-        int                     err      = SYSTEM_ERR;
-        rpcsvc_actor_t          *actor   = NULL;
-        rpcsvc_t                *svc     = NULL;
-        char                    found    = 0;
-        char                    *peername = NULL;
-
-        if (!req)
-                goto err;
-
-        svc = req->svc;
-        peername = req->trans->peerinfo.identifier;
-        pthread_mutex_lock (&svc->rpclock);
+    rpcsvc_program_t *program = NULL;
+    int err = SYSTEM_ERR;
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_t *svc = NULL;
+    char found = 0;
+    char *peername = NULL;
+
+    if (!req)
+        goto err;
+
+    svc = req->svc;
+    peername = req->trans->peerinfo.identifier;
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(program, &svc->programs, program)
         {
-                list_for_each_entry (program, &svc->programs, program) {
-                        if (program->prognum == req->prognum) {
-                                err = PROG_MISMATCH;
-                        }
-
-                        if ((program->prognum == req->prognum)
-                            && (program->progver == req->progver)) {
-                                found = 1;
-                                break;
-                        }
-                }
-        }
-        pthread_mutex_unlock (&svc->rpclock);
-
-        if (!found) {
-                if (err != PROG_MISMATCH) {
-                        /* log in DEBUG when nfs clients try to see if
-                         * ACL requests are accepted by nfs server
-                         */
-                        gf_log (GF_RPCSVC, (req->prognum == ACL_PROGRAM) ?
-                                GF_LOG_DEBUG : GF_LOG_WARNING,
-                                "RPC program not available (req %u %u) for %s",
-                                req->prognum, req->progver,
-                                peername);
-                        err = PROG_UNAVAIL;
-                        goto err;
-                }
-
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "RPC program version not available (req %u %u) for %s",
-                        req->prognum, req->progver,
-                        peername);
-                goto err;
-        }
-        req->prog = program;
-        if (!program->actors) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "RPC Actor not found for program %s %d for %s",
-                        program->progname, program->prognum,
-                        peername);
-                err = SYSTEM_ERR;
-                goto err;
-        }
-
-        if ((req->procnum < 0) || (req->procnum >= program->numactors)) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not"
-                        " available for procedure %d in %s for  %s",
-                        req->procnum, program->progname,
-                        peername);
-                err = PROC_UNAVAIL;
-                goto err;
-        }
-
-        actor = &program->actors[req->procnum];
-        if (!actor->actor) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not"
-                        " available for procedure %d in %s for %s",
-                        req->procnum, program->progname,
-                        peername);
-                err = PROC_UNAVAIL;
-                actor = NULL;
-                goto err;
-        }
-
-        req->ownthread = program->ownthread;
-        req->synctask = program->synctask;
+            if (program->prognum == req->prognum) {
+                err = PROG_MISMATCH;
+            }
 
-        err = SUCCESS;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s",
-                program->progname, actor->procname,
-                peername);
+            if ((program->prognum == req->prognum) &&
+                (program->progver == req->progver)) {
+                found = 1;
+                break;
+            }
+        }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    if (!found) {
+        if (err != PROG_MISMATCH) {
+            /* log in DEBUG when nfs clients try to see if
+             * ACL requests are accepted by nfs server
+             */
+            gf_log(
+                GF_RPCSVC,
+                (req->prognum == ACL_PROGRAM) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+                "RPC program not available (req %u %u) for %s", req->prognum,
+                req->progver, peername);
+            err = PROG_UNAVAIL;
+            goto err;
+        }
+
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "RPC program version not available (req %u %u) for %s",
+               req->prognum, req->progver, peername);
+        goto err;
+    }
+    req->prog = program;
+    if (!program->actors) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "RPC Actor not found for program %s %d for %s",
+               program->progname, program->prognum, peername);
+        err = SYSTEM_ERR;
+        goto err;
+    }
+
+    if ((req->procnum < 0) || (req->procnum >= program->numactors)) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC Program procedure not"
+               " available for procedure %d in %s for  %s",
+               req->procnum, program->progname, peername);
+        err = PROC_UNAVAIL;
+        goto err;
+    }
+
+    actor = &program->actors[req->procnum];
+    if (!actor->actor) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC Program procedure not"
+               " available for procedure %d in %s for %s",
+               req->procnum, program->progname, peername);
+        err = PROC_UNAVAIL;
+        actor = NULL;
+        goto err;
+    }
+
+    if (svc->xl->ctx->measure_latency) {
+        timespec_now(&req->begin);
+    }
+
+    req->ownthread = program->ownthread;
+    req->synctask = program->synctask;
+
+    err = SUCCESS;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s",
+           program->progname, actor->procname, peername);
 err:
-        if (req)
-                req->rpc_err = err;
+    if (req)
+        req->rpc_err = err;
 
-        return actor;
+    return actor;
 }
 
-
 /* this procedure can only pass 4 arguments to registered notifyfn. To send more
  * arguments call wrapper->notify directly.
  */
 static void
-rpcsvc_program_notify (rpcsvc_listener_t *listener, rpcsvc_event_t event,
-                       void *data)
+rpcsvc_program_notify(rpcsvc_listener_t *listener, rpcsvc_event_t event,
+                      void *data)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
 
-        if (!listener) {
-                goto out;
-        }
+    if (!listener) {
+        goto out;
+    }
 
-        list_for_each_entry (wrapper, &listener->svc->notify, list) {
-                if (wrapper->notify) {
-                        wrapper->notify (listener->svc,
-                                         wrapper->data,
-                                         event, data);
-                }
+    list_for_each_entry(wrapper, &listener->svc->notify, list)
+    {
+        if (wrapper->notify) {
+            wrapper->notify(listener->svc, wrapper->data, event, data);
         }
+    }
 
 out:
-        return;
+    return;
 }
 
-
 static int
-rpcsvc_accept (rpcsvc_t *svc, rpc_transport_t *listen_trans,
-               rpc_transport_t *new_trans)
+rpcsvc_accept(rpcsvc_t *svc, rpc_transport_t *listen_trans,
+              rpc_transport_t *new_trans)
 {
-        rpcsvc_listener_t *listener = NULL;
-        int32_t            ret      = -1;
+    rpcsvc_listener_t *listener = NULL;
+    int32_t ret = -1;
 
-        listener = rpcsvc_get_listener (svc, -1, listen_trans);
-        if (listener == NULL) {
-                goto out;
-        }
+    listener = rpcsvc_get_listener(svc, -1, listen_trans);
+    if (listener == NULL) {
+        goto out;
+    }
 
-        rpcsvc_program_notify (listener, RPCSVC_EVENT_ACCEPT, new_trans);
-        ret = 0;
+    rpcsvc_program_notify(listener, RPCSVC_EVENT_ACCEPT, new_trans);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-rpcsvc_request_destroy (rpcsvc_request_t *req)
+rpcsvc_request_destroy(rpcsvc_request_t *req)
 {
-        if (!req) {
-                goto out;
-        }
+    if (!req) {
+        goto out;
+    }
 
-        if (req->iobref) {
-                iobref_unref (req->iobref);
-        }
+    if (req->iobref) {
+        iobref_unref(req->iobref);
+    }
 
-        /* This marks the "end" of an RPC request. Reply is
-           completely written to the socket and is on the way
-           to the client. It is time to decrement the
-           outstanding request counter by 1.
-        */
-        if (req->prognum) //Only for initialized requests
-                rpcsvc_request_outstanding (req, -1);
+    /* This marks the "end" of an RPC request. Reply is
+       completely written to the socket and is on the way
+       to the client. It is time to decrement the
+       outstanding request counter by 1.
+    */
+    if (req->prognum)  // Only for initialized requests
+        rpcsvc_request_outstanding(req, -1);
 
-        rpc_transport_unref (req->trans);
+    rpc_transport_unref(req->trans);
 
-	GF_FREE (req->auxgidlarge);
+    GF_FREE(req->auxgidlarge);
 
-        mem_put (req);
+    mem_put(req);
 
 out:
-        return;
+    return;
 }
 
-
 rpcsvc_request_t *
-rpcsvc_request_init (rpcsvc_t *svc, rpc_transport_t *trans,
-                     struct rpc_msg *callmsg,
-                     struct iovec progmsg, rpc_transport_pollin_t *msg,
-                     rpcsvc_request_t *req)
+rpcsvc_request_init(rpcsvc_t *svc, rpc_transport_t *trans,
+                    struct rpc_msg *callmsg, struct iovec progmsg,
+                    rpc_transport_pollin_t *msg, rpcsvc_request_t *req)
 {
-        int i = 0;
+    int i = 0;
 
-        if ((!trans) || (!callmsg)|| (!req) || (!msg))
-                return NULL;
-
-        /* We start a RPC request as always denied. */
-        req->rpc_status = MSG_DENIED;
-        req->xid = rpc_call_xid (callmsg);
-        req->prognum = rpc_call_program (callmsg);
-        req->progver = rpc_call_progver (callmsg);
-        req->procnum = rpc_call_progproc (callmsg);
-        req->trans = rpc_transport_ref (trans);
-        req->count = msg->count;
-        req->msg[0] = progmsg;
-        req->iobref = iobref_ref (msg->iobref);
-        if (msg->vectored) {
-                /* msg->vector[MAX_IOVEC] is defined in structure. prevent a
-                   out of bound access */
-                for (i = 1; i < min (msg->count, MAX_IOVEC); i++) {
-                        req->msg[i] = msg->vector[i];
-                }
-        }
+    if ((!trans) || (!callmsg) || (!req) || (!msg))
+        return NULL;
 
-        req->svc = svc;
-        req->trans_private = msg->private;
+    /* We start a RPC request as always denied. */
+    req->rpc_status = MSG_DENIED;
+    req->xid = rpc_call_xid(callmsg);
+    req->prognum = rpc_call_program(callmsg);
+    req->progver = rpc_call_progver(callmsg);
+    req->procnum = rpc_call_progproc(callmsg);
+    req->trans = rpc_transport_ref(trans);
+    req->count = msg->count;
+    req->msg[0] = progmsg;
+    req->iobref = iobref_ref(msg->iobref);
+    if (msg->vectored) {
+        /* msg->vector[MAX_IOVEC] is defined in structure. prevent a
+           out of bound access */
+        for (i = 1; i < min(msg->count, MAX_IOVEC); i++) {
+            req->msg[i] = msg->vector[i];
+        }
+    }
+
+    req->svc = svc;
+    req->trans_private = msg->private;
+
+    INIT_LIST_HEAD(&req->txlist);
+    INIT_LIST_HEAD(&req->request_list);
+    req->payloadsize = 0;
+
+    /* By this time, the data bytes for the auth scheme would have already
+     * been copied into the required sections of the req structure,
+     * we just need to fill in the meta-data about it now.
+     */
+    rpcsvc_auth_request_init(req, callmsg);
+    return req;
+}
 
-        INIT_LIST_HEAD (&req->txlist);
-        INIT_LIST_HEAD (&req->request_list);
-        req->payloadsize = 0;
+rpcsvc_request_t *
+rpcsvc_request_create(rpcsvc_t *svc, rpc_transport_t *trans,
+                      rpc_transport_pollin_t *msg)
+{
+    char *msgbuf = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    rpcsvc_request_t *req = NULL;
+    size_t msglen = 0;
+    int ret = -1;
+
+    if (!svc || !trans || !svc->rxpool)
+        return NULL;
 
-        /* By this time, the data bytes for the auth scheme would have already
-         * been copied into the required sections of the req structure,
-         * we just need to fill in the meta-data about it now.
+    /* We need to allocate the request before actually calling
+     * rpcsvc_request_init on the request so that we, can fill the auth
+     * data directly into the request structure from the message iobuf.
+     * This avoids a need to keep a temp buffer into which the auth data
+     * would've been copied otherwise.
+     */
+    rpcsvc_alloc_request(svc, req);
+    if (!req) {
+        goto err;
+    }
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, req->cred.authdata,
+                          req->verf.authdata);
+
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        req->trans = rpc_transport_ref(trans);
+        req->svc = svc;
+        goto err;
+    }
+
+    ret = -1;
+    rpcsvc_request_init(svc, trans, &rpcmsg, progmsg, msg, req);
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "received rpc-message "
+           "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+           ", Program: %" GF_PRI_RPC_PROG_ID
+           ", "
+           "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+           ") "
+           "from rpc-transport (%s)",
+           rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+           rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+           rpc_call_progproc(&rpcmsg), trans->name);
+
+    /* We just received a new request from the wire. Account for
+       it in the outsanding request counter to make sure we don't
+       ingest too many concurrent requests from the same client.
+    */
+    if (req->prognum)  // Only for initialized requests
+        ret = rpcsvc_request_outstanding(req, +1);
+
+    if (rpc_call_rpcvers(&rpcmsg) != 2) {
+        /* LOG- TODO: print rpc version, also print the peerinfo
+           from transport */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC version not supported "
+               "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+               ", Program: %" GF_PRI_RPC_PROG_ID
+               ", "
+               "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+               ") "
+               "from trans (%s)",
+               rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+               rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+               rpc_call_progproc(&rpcmsg), trans->name);
+        rpcsvc_request_seterr(req, RPC_MISMATCH);
+        goto err;
+    }
+
+    ret = rpcsvc_authenticate(req);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        /* No need to set auth_err, that is the responsibility of
+         * the authentication handler since only that know what exact
+         * error happened.
          */
-        rpcsvc_auth_request_init (req, callmsg);
-        return req;
+        rpcsvc_request_seterr(req, AUTH_ERROR);
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "auth failed on request. "
+               "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+               ", Program: %" GF_PRI_RPC_PROG_ID
+               ", "
+               "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+               ") "
+               "from trans (%s)",
+               rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+               rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+               rpc_call_progproc(&rpcmsg), trans->name);
+        ret = -1;
+        goto err;
+    }
+
+    /* If the error is not RPC_MISMATCH, we consider the call as accepted
+     * since we are not handling authentication failures for now.
+     */
+    req->rpc_status = MSG_ACCEPTED;
+    req->reply = NULL;
+    ret = 0;
+err:
+    if (ret == -1) {
+        ret = rpcsvc_error_reply(req);
+        if (ret)
+            gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply");
+        req = NULL;
+    }
+
+    return req;
 }
 
+int
+rpcsvc_check_and_reply_error(int ret, call_frame_t *frame, void *opaque)
+{
+    rpcsvc_request_t *req = NULL;
 
-rpcsvc_request_t *
-rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans,
-                       rpc_transport_pollin_t *msg)
+    req = opaque;
+
+    if (ret)
+        gf_log("rpcsvc", GF_LOG_ERROR,
+               "rpc actor (%d:%d:%d) failed to complete successfully",
+               req->prognum, req->progver, req->procnum);
+
+    if (ret == RPCSVC_ACTOR_ERROR) {
+        ret = rpcsvc_error_reply(req);
+        if (ret)
+            gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply");
+    }
+
+    return 0;
+}
+
+void
+rpcsvc_queue_event_thread_death(rpcsvc_t *svc, rpcsvc_program_t *prog, int gen)
 {
-        char                    *msgbuf = NULL;
-        struct rpc_msg          rpcmsg;
-        struct iovec            progmsg;        /* RPC Program payload */
-        rpcsvc_request_t        *req    = NULL;
-        size_t                  msglen  = 0;
-        int                     ret     = -1;
-
-        if (!svc || !trans)
-                return NULL;
-
-        /* We need to allocate the request before actually calling
-         * rpcsvc_request_init on the request so that we, can fill the auth
-         * data directly into the request structure from the message iobuf.
-         * This avoids a need to keep a temp buffer into which the auth data
-         * would've been copied otherwise.
-         */
-        rpcsvc_alloc_request (svc, req);
-        if (!req) {
-                goto err;
-        }
+    rpcsvc_request_queue_t *queue = NULL;
+    int num = 0;
+    void *value = NULL;
+    rpcsvc_request_t *req = NULL;
+    char empty = 0;
+
+    value = pthread_getspecific(prog->req_queue_key);
+    if (value == NULL) {
+        return;
+    }
 
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
+    num = ((unsigned long)value) - 1;
 
-        ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg,
-                               req->cred.authdata,req->verf.authdata);
+    queue = &prog->request_queue[num];
 
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                req->trans = rpc_transport_ref (trans);
-                req->svc = svc;
-                goto err;
-        }
+    if (queue->gen == gen) {
+        /* duplicate event */
+        gf_log(GF_RPCSVC, GF_LOG_INFO,
+               "not queuing duplicate event thread death. "
+               "queue %d program %s",
+               num, prog->progname);
+        return;
+    }
 
-        ret = -1;
-        rpcsvc_request_init (svc, trans, &rpcmsg, progmsg, msg, req);
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "received rpc-message "
-		"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-		"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                "from rpc-transport (%s)", rpc_call_xid (&rpcmsg),
-                rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                trans->name);
-
-        /* We just received a new request from the wire. Account for
-           it in the outsanding request counter to make sure we don't
-           ingest too many concurrent requests from the same client.
-        */
-        if (req->prognum) //Only for initialized requests
-                ret = rpcsvc_request_outstanding (req, +1);
-
-        if (rpc_call_rpcvers (&rpcmsg) != 2) {
-                /* LOG- TODO: print rpc version, also print the peerinfo
-                   from transport */
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC version not supported "
-			"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-			"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-			"from trans (%s)", rpc_call_xid (&rpcmsg),
-                        rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                        rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                        trans->name);
-                rpcsvc_request_seterr (req, RPC_MISMATCH);
-                goto err;
-        }
+    rpcsvc_alloc_request(svc, req);
+    req->prognum = RPCSVC_INFRA_PROGRAM;
+    req->procnum = RPCSVC_PROC_EVENT_THREAD_DEATH;
+    gf_log(GF_RPCSVC, GF_LOG_INFO,
+           "queuing event thread death request to queue %d of program %s", num,
+           prog->progname);
 
-        ret = rpcsvc_authenticate (req);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                /* No need to set auth_err, that is the responsibility of
-                 * the authentication handler since only that know what exact
-                 * error happened.
-                 */
-                rpcsvc_request_seterr (req, AUTH_ERROR);
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "auth failed on request. "
-			"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-			"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                        "from trans (%s)", rpc_call_xid (&rpcmsg),
-                        rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                        rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                        trans->name);
-                ret = -1;
-                goto err;
-        }
+    pthread_mutex_lock(&queue->queue_lock);
+    {
+        empty = list_empty(&queue->request_queue);
 
+        list_add_tail(&req->request_list, &queue->request_queue);
+        queue->gen = gen;
 
-        /* If the error is not RPC_MISMATCH, we consider the call as accepted
-         * since we are not handling authentication failures for now.
-         */
-        req->rpc_status = MSG_ACCEPTED;
-        req->reply = NULL;
-        ret = 0;
-err:
-        if (ret == -1) {
-                ret = rpcsvc_error_reply (req);
-                if (ret)
-                        gf_log ("rpcsvc", GF_LOG_WARNING,
-                                "failed to queue error reply");
-                req = NULL;
-        }
+        if (empty && queue->waiting)
+            pthread_cond_signal(&queue->queue_cond);
+    }
+    pthread_mutex_unlock(&queue->queue_lock);
 
-        return req;
+    return;
 }
 
-
 int
-rpcsvc_check_and_reply_error (int ret, call_frame_t *frame, void *opaque)
+rpcsvc_handle_event_thread_death(rpcsvc_t *svc, rpc_transport_t *trans, int gen)
 {
-        rpcsvc_request_t  *req = NULL;
-
-        req = opaque;
+    rpcsvc_program_t *prog = NULL;
 
-        if (ret)
-                gf_log ("rpcsvc", GF_LOG_ERROR,
-                        "rpc actor failed to complete successfully");
-
-        if (ret == RPCSVC_ACTOR_ERROR) {
-                ret = rpcsvc_error_reply (req);
-                if (ret)
-                        gf_log ("rpcsvc", GF_LOG_WARNING,
-                                "failed to queue error reply");
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(prog, &svc->programs, program)
+        {
+            if (prog->ownthread)
+                rpcsvc_queue_event_thread_death(svc, prog, gen);
         }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        return 0;
+    return 0;
 }
 
 int
-rpcsvc_handle_rpc_call (rpcsvc_t *svc, rpc_transport_t *trans,
-                        rpc_transport_pollin_t *msg)
-{
-        rpcsvc_actor_t         *actor          = NULL;
-        rpcsvc_actor            actor_fn       = NULL;
-        rpcsvc_request_t       *req            = NULL;
-        int                     ret            = -1;
-        uint16_t                port           = 0;
-        gf_boolean_t            is_unix        = _gf_false, empty = _gf_false;
-        gf_boolean_t            unprivileged   = _gf_false;
-        drc_cached_op_t        *reply          = NULL;
-        rpcsvc_drc_globals_t   *drc            = NULL;
-
-        if (!trans || !svc)
-                return -1;
-
-        switch (trans->peerinfo.sockaddr.ss_family) {
+rpcsvc_handle_rpc_call(rpcsvc_t *svc, rpc_transport_t *trans,
+                       rpc_transport_pollin_t *msg)
+{
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_actor actor_fn = NULL;
+    rpcsvc_request_t *req = NULL;
+    int ret = -1;
+    uint16_t port = 0;
+    gf_boolean_t is_unix = _gf_false, empty = _gf_false;
+    gf_boolean_t unprivileged = _gf_false, spawn_request_handler = 0;
+    drc_cached_op_t *reply = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+    rpcsvc_request_queue_t *queue = NULL;
+    long num = 0;
+    void *value = NULL;
+
+    if (!trans || !svc)
+        return -1;
+
+    switch (trans->peerinfo.sockaddr.ss_family) {
         case AF_INET:
-                port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port;
-                break;
+            port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port;
+            break;
 
         case AF_INET6:
-                port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr)->sin6_port;
-                break;
+            port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr)
+                       ->sin6_port;
+            break;
         case AF_UNIX:
-                is_unix = _gf_true;
-                break;
+            is_unix = _gf_true;
+            break;
         default:
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "invalid address family (%d)",
-                        trans->peerinfo.sockaddr.ss_family);
-                return -1;
-        }
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid address family (%d)",
+                   trans->peerinfo.sockaddr.ss_family);
+            return -1;
+    }
 
+    if (is_unix == _gf_false) {
+        port = ntohs(port);
 
+        gf_log("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port);
 
-        if (is_unix == _gf_false) {
-                port = ntohs (port);
+        if (port >= 1024)
+            unprivileged = _gf_true;
+    }
 
-                gf_log ("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port);
+    req = rpcsvc_request_create(svc, trans, msg);
+    if (!req)
+        goto out;
 
-                if (port >= 1024)
-                        unprivileged = _gf_true;
-        }
+    if (!rpcsvc_request_accepted(req))
+        goto err_reply;
+
+    actor = rpcsvc_program_actor(req);
+    if (!actor)
+        goto err_reply;
+
+    if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) {
+        /* Non-privileged user, fail request */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Request received from non-"
+               "privileged port. Failing request for %s.",
+               req->trans->peerinfo.identifier);
+        req->rpc_status = MSG_DENIED;
+        req->rpc_err = AUTH_ERROR;
+        req->auth_err = RPCSVC_AUTH_REJECT;
+        goto err_reply;
+    }
 
-        req = rpcsvc_request_create (svc, trans, msg);
-        if (!req)
+    /* DRC */
+    if (rpcsvc_need_drc(req)) {
+        drc = req->svc->drc;
+
+        LOCK(&drc->lock);
+        {
+            reply = rpcsvc_drc_lookup(req);
+
+            /* retransmission of completed request, send cached reply */
+            if (reply && reply->state == DRC_OP_CACHED) {
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "duplicate request:"
+                       " XID: 0x%x",
+                       req->xid);
+                ret = rpcsvc_send_cached_reply(req, reply);
+                drc->cache_hits++;
+                UNLOCK(&drc->lock);
+                goto out;
+
+            } /* retransmitted request, original op in transit, drop it */
+            else if (reply && reply->state == DRC_OP_IN_TRANSIT) {
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "op in transit,"
+                       " discarding. XID: 0x%x",
+                       req->xid);
+                ret = 0;
+                drc->intransit_hits++;
+                rpcsvc_request_destroy(req);
+                UNLOCK(&drc->lock);
                 goto out;
 
-        if (!rpcsvc_request_accepted (req))
-                goto err_reply;
-
-        actor = rpcsvc_program_actor (req);
-        if (!actor)
-                goto err_reply;
-
-        if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) {
-                        /* Non-privileged user, fail request */
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "Request received from non-"
-                                "privileged port. Failing request for %s.",
-                                req->trans->peerinfo.identifier);
-                        req->rpc_status = MSG_DENIED;
-                        req->rpc_err = AUTH_ERROR;
-                        req->auth_err = RPCSVC_AUTH_REJECT;
-                        goto err_reply;
+            } /* fresh request, cache it as in-transit and proceed */
+            else {
+                ret = rpcsvc_cache_request(req);
+            }
         }
+        UNLOCK(&drc->lock);
+    }
 
-        /* DRC */
-        if (rpcsvc_need_drc (req)) {
-                drc = req->svc->drc;
+    if (req->rpc_err == SUCCESS) {
+        /* Before going to xlator code, set the THIS properly */
+        THIS = svc->xl;
+
+        actor_fn = actor->actor;
+
+        if (!actor_fn) {
+            rpcsvc_request_seterr(req, PROC_UNAVAIL);
+            /* LOG TODO: print more info about procnum,
+               prognum etc, also print transport info */
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "No vectored handler present");
+            ret = RPCSVC_ACTOR_ERROR;
+            goto err_reply;
+        }
 
-                LOCK (&drc->lock);
+        if (req->synctask) {
+            ret = synctask_new(THIS->ctx->env, (synctask_fn_t)actor_fn,
+                               rpcsvc_check_and_reply_error, NULL, req);
+        } else if (req->ownthread) {
+            value = pthread_getspecific(req->prog->req_queue_key);
+            if (value == NULL) {
+                pthread_mutex_lock(&req->prog->thr_lock);
                 {
-                        reply = rpcsvc_drc_lookup (req);
-
-                        /* retransmission of completed request, send cached reply */
-                        if (reply && reply->state == DRC_OP_CACHED) {
-                                gf_log (GF_RPCSVC, GF_LOG_INFO, "duplicate request:"
-                                        " XID: 0x%x", req->xid);
-                                ret = rpcsvc_send_cached_reply (req, reply);
-                                drc->cache_hits++;
-                                UNLOCK (&drc->lock);
-                                goto out;
-
-                        } /* retransmitted request, original op in transit, drop it */
-                        else if (reply && reply->state == DRC_OP_IN_TRANSIT) {
-                                gf_log (GF_RPCSVC, GF_LOG_INFO, "op in transit,"
-                                        " discarding. XID: 0x%x", req->xid);
-                                ret = 0;
-                                drc->intransit_hits++;
-                                rpcsvc_request_destroy (req);
-                                UNLOCK (&drc->lock);
-                                goto out;
-
-                        } /* fresh request, cache it as in-transit and proceed */
-                        else {
-                                ret = rpcsvc_cache_request (req);
+                    num = rpcsvc_get_free_queue_index(req->prog);
+                    if (num != -1) {
+                        num++;
+                        value = (void *)num;
+                        ret = pthread_setspecific(req->prog->req_queue_key,
+                                                  value);
+                        if (ret < 0) {
+                            gf_log(GF_RPCSVC, GF_LOG_WARNING,
+                                   "setting request queue in TLS failed");
+                            rpcsvc_toggle_queue_status(
+                                req->prog, &req->prog->request_queue[num - 1],
+                                req->prog->request_queue_status);
+                            num = -1;
+                        } else {
+                            spawn_request_handler = 1;
                         }
+                    }
                 }
-                UNLOCK (&drc->lock);
-        }
+                pthread_mutex_unlock(&req->prog->thr_lock);
+            }
 
-        if (req->rpc_err == SUCCESS) {
-                /* Before going to xlator code, set the THIS properly */
-                THIS = svc->xl;
+            if (num == -1)
+                goto noqueue;
 
-                actor_fn = actor->actor;
+            num = ((unsigned long)value) - 1;
 
-                if (!actor_fn) {
-                        rpcsvc_request_seterr (req, PROC_UNAVAIL);
-                        /* LOG TODO: print more info about procnum,
-                           prognum etc, also print transport info */
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "No vectored handler present");
-                        ret = RPCSVC_ACTOR_ERROR;
-                        goto err_reply;
-                }
+            queue = &req->prog->request_queue[num];
 
-                if (req->synctask) {
-                        ret = synctask_new (THIS->ctx->env,
-                                            (synctask_fn_t) actor_fn,
-                                            rpcsvc_check_and_reply_error, NULL,
-                                            req);
-                } else if (req->ownthread) {
-                        pthread_mutex_lock (&req->prog->queue_lock);
-                        {
-                                empty = list_empty (&req->prog->request_queue);
-
-                                list_add_tail (&req->request_list,
-                                               &req->prog->request_queue);
-
-                                if (empty)
-                                        pthread_cond_signal (&req->prog->queue_cond);
-                        }
-                        pthread_mutex_unlock (&req->prog->queue_lock);
+            if (spawn_request_handler) {
+                ret = gf_thread_create(&queue->thread, NULL,
+                                       rpcsvc_request_handler, queue,
+                                       "rpcrqhnd");
+                if (!ret) {
+                    gf_log(GF_RPCSVC, GF_LOG_INFO,
+                           "spawned a request handler thread for queue %d",
+                           (int)num);
 
-                        ret = 0;
+                    req->prog->threadcount++;
                 } else {
-                        ret = actor_fn (req);
+                    gf_log(
+                        GF_RPCSVC, GF_LOG_INFO,
+                        "spawning a request handler thread for queue %d failed",
+                        (int)num);
+                    ret = pthread_setspecific(req->prog->req_queue_key, 0);
+                    if (ret < 0) {
+                        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+                               "resetting request queue in TLS failed");
+                    }
+
+                    rpcsvc_toggle_queue_status(
+                        req->prog, &req->prog->request_queue[num - 1],
+                        req->prog->request_queue_status);
+
+                    goto noqueue;
                 }
+            }
+
+            pthread_mutex_lock(&queue->queue_lock);
+            {
+                empty = list_empty(&queue->request_queue);
+
+                list_add_tail(&req->request_list, &queue->request_queue);
+
+                if (empty && queue->waiting)
+                    pthread_cond_signal(&queue->queue_cond);
+            }
+            pthread_mutex_unlock(&queue->queue_lock);
+
+            ret = 0;
+        } else {
+        noqueue:
+            ret = actor_fn(req);
         }
+    }
 
 err_reply:
 
-        ret = rpcsvc_check_and_reply_error (ret, NULL, req);
-        /* No need to propagate error beyond this function since the reply
-         * has now been queued. */
-        ret = 0;
+    ret = rpcsvc_check_and_reply_error(ret, NULL, req);
+    /* No need to propagate error beyond this function since the reply
+     * has now been queued. */
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_handle_disconnect (rpcsvc_t *svc, rpc_transport_t *trans)
+rpcsvc_handle_disconnect(rpcsvc_t *svc, rpc_transport_t *trans)
 {
-        rpcsvc_event_t           event;
-        rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper;
-        int32_t                  ret      = -1, i = 0, wrapper_count = 0;
-        rpcsvc_listener_t       *listener = NULL;
-
-        event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD
-                : RPCSVC_EVENT_DISCONNECT;
+    rpcsvc_event_t event;
+    rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper;
+    int32_t ret = -1, i = 0, wrapper_count = 0;
+    rpcsvc_listener_t *listener = NULL;
 
-        pthread_mutex_lock (&svc->rpclock);
-        {
-                if (!svc->notify_count)
-                        goto unlock;
+    event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD
+                                      : RPCSVC_EVENT_DISCONNECT;
 
-                wrappers = GF_CALLOC (svc->notify_count, sizeof (*wrapper),
-                                      gf_common_mt_rpcsvc_wrapper_t);
-                if (!wrappers) {
-                        goto unlock;
-                }
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        if (!svc->notify_count)
+            goto unlock;
 
-                list_for_each_entry (wrapper, &svc->notify, list) {
-                        if (wrapper->notify) {
-                                wrappers[i++] = *wrapper;
-                        }
-                }
+        wrappers = GF_CALLOC(svc->notify_count, sizeof(*wrapper),
+                             gf_common_mt_rpcsvc_wrapper_t);
+        if (!wrappers) {
+            goto unlock;
+        }
 
-                wrapper_count = i;
+        list_for_each_entry(wrapper, &svc->notify, list)
+        {
+            if (wrapper->notify) {
+                wrappers[i++] = *wrapper;
+            }
         }
-unlock:
-        pthread_mutex_unlock (&svc->rpclock);
 
-        if (wrappers) {
-                for (i = 0; i < wrapper_count; i++) {
-                        wrappers[i].notify (svc, wrappers[i].data,
-                                            event, trans);
-                }
+        wrapper_count = i;
+    }
+unlock:
+    pthread_rwlock_unlock(&svc->rpclock);
 
-                GF_FREE (wrappers);
+    if (wrappers) {
+        for (i = 0; i < wrapper_count; i++) {
+            wrappers[i].notify(svc, wrappers[i].data, event, trans);
         }
 
-        if (event == RPCSVC_EVENT_LISTENER_DEAD) {
-                listener = rpcsvc_get_listener (svc, -1, trans->listener);
-                rpcsvc_listener_destroy (listener);
-        }
+        GF_FREE(wrappers);
+    }
 
-        return ret;
-}
+    if (event == RPCSVC_EVENT_LISTENER_DEAD) {
+        listener = rpcsvc_get_listener(svc, -1, trans->listener);
+        rpcsvc_listener_destroy(listener);
+    }
 
+    return ret;
+}
 
 int
-rpcsvc_notify (rpc_transport_t *trans, void *mydata,
-               rpc_transport_event_t event, void *data, ...)
+rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event,
+              void *data, ...)
 {
-        int                     ret       = -1;
-        rpc_transport_pollin_t *msg       = NULL;
-        rpc_transport_t        *new_trans = NULL;
-        rpcsvc_t               *svc       = NULL;
-        rpcsvc_listener_t      *listener  = NULL;
-
-        svc = mydata;
-        if (svc == NULL) {
-                goto out;
-        }
-
-        switch (event) {
+    int ret = -1;
+    rpc_transport_pollin_t *msg = NULL;
+    rpc_transport_t *new_trans = NULL;
+    rpcsvc_t *svc = NULL;
+    rpcsvc_listener_t *listener = NULL;
+
+    svc = mydata;
+    if (svc == NULL) {
+        goto out;
+    }
+
+    switch (event) {
         case RPC_TRANSPORT_ACCEPT:
-                new_trans = data;
-                ret = rpcsvc_accept (svc, trans, new_trans);
-                break;
+            new_trans = data;
+            ret = rpcsvc_accept(svc, trans, new_trans);
+            break;
 
         case RPC_TRANSPORT_DISCONNECT:
-                ret = rpcsvc_handle_disconnect (svc, trans);
-                break;
+            ret = rpcsvc_handle_disconnect(svc, trans);
+            break;
 
         case RPC_TRANSPORT_MSG_RECEIVED:
-                msg = data;
-                ret = rpcsvc_handle_rpc_call (svc, trans, msg);
-                break;
+            msg = data;
+            ret = rpcsvc_handle_rpc_call(svc, trans, msg);
+            break;
 
         case RPC_TRANSPORT_MSG_SENT:
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_CONNECT:
-                /* do nothing, no need for rpcsvc to handle this, client should
-                 * handle this event
-                 */
-                /* print info about transport too : LOG TODO */
-                gf_log ("rpcsvc", GF_LOG_CRITICAL,
-                        "got CONNECT event, which should have not come");
-                ret = 0;
-                break;
+            /* do nothing, no need for rpcsvc to handle this, client should
+             * handle this event
+             */
+            /* print info about transport too : LOG TODO */
+            gf_log("rpcsvc", GF_LOG_CRITICAL,
+                   "got CONNECT event, which should have not come");
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_CLEANUP:
-                listener = rpcsvc_get_listener (svc, -1, trans->listener);
-                if (listener == NULL) {
-                        goto out;
-                }
+            listener = rpcsvc_get_listener(svc, -1, trans->listener);
+            if (listener == NULL) {
+                goto out;
+            }
 
-                rpcsvc_program_notify (listener, RPCSVC_EVENT_TRANSPORT_DESTROY,
-                                       trans);
-                ret = 0;
-                break;
+            rpcsvc_program_notify(listener, RPCSVC_EVENT_TRANSPORT_DESTROY,
+                                  trans);
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_MAP_XID_REQUEST:
-                /* FIXME: think about this later */
-                gf_log ("rpcsvc", GF_LOG_CRITICAL,
-                        "got MAP_XID event, which should have not come");
-                ret = 0;
-                break;
-        }
+            /* FIXME: think about this later */
+            gf_log("rpcsvc", GF_LOG_CRITICAL,
+                   "got MAP_XID event, which should have not come");
+            ret = 0;
+            break;
+
+        case RPC_TRANSPORT_EVENT_THREAD_DIED:
+            rpcsvc_handle_event_thread_death(svc, trans,
+                                             (int)(unsigned long)data);
+            ret = 0;
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Given the RPC reply structure and the payload handed by the RPC program,
  * encode the RPC record header into the buffer pointed by recordstart.
  */
 struct iovec
-rpcsvc_record_build_header (char *recordstart, size_t rlen,
-                            struct rpc_msg reply, size_t payload)
+rpcsvc_record_build_header(char *recordstart, size_t rlen, struct rpc_msg reply,
+                           size_t payload)
 {
-        struct iovec    replyhdr;
-        struct iovec    txrecord = {0, 0};
-        size_t          fraglen = 0;
-        int             ret = -1;
-
-        /* After leaving aside the 4 bytes for the fragment header, lets
-         * encode the RPC reply structure into the buffer given to us.
-         */
-        ret = rpc_reply_to_xdr (&reply, recordstart, rlen, &replyhdr);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply");
-                goto err;
-        }
-
-        fraglen = payload + replyhdr.iov_len;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Reply fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, replyhdr.iov_len);
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = replyhdr.iov_len;
+    struct iovec replyhdr;
+    struct iovec txrecord = {0, 0};
+    size_t fraglen = 0;
+    int ret = -1;
+
+    /* After leaving aside the 4 bytes for the fragment header, lets
+     * encode the RPC reply structure into the buffer given to us.
+     */
+    ret = rpc_reply_to_xdr(&reply, recordstart, rlen, &replyhdr);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply");
+        goto err;
+    }
+
+    fraglen = payload + replyhdr.iov_len;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Reply fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, replyhdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = replyhdr.iov_len;
 err:
-        return txrecord;
+    return txrecord;
 }
 
 static uint32_t
-rpc_callback_new_callid (struct rpc_transport *trans)
+rpc_callback_new_callid(struct rpc_transport *trans)
 {
-        uint32_t callid = 0;
+    uint32_t callid = 0;
 
-        pthread_mutex_lock (&trans->lock);
-        {
-                callid = ++trans->xid;
-        }
-        pthread_mutex_unlock (&trans->lock);
+    pthread_mutex_lock(&trans->lock);
+    {
+        callid = ++trans->xid;
+    }
+    pthread_mutex_unlock(&trans->lock);
 
-        return callid;
+    return callid;
 }
 
 int
-rpcsvc_fill_callback (int prognum, int progver, int procnum, int payload,
-                      uint32_t xid, struct rpc_msg *request)
+rpcsvc_fill_callback(int prognum, int progver, int procnum, int payload,
+                     uint32_t xid, struct rpc_msg *request)
 {
-        int   ret          = -1;
+    int ret = -1;
 
-        if (!request) {
-                goto out;
-        }
+    if (!request) {
+        goto out;
+    }
 
-        memset (request, 0, sizeof (*request));
+    memset(request, 0, sizeof(*request));
 
-        request->rm_xid = xid;
-        request->rm_direction = CALL;
+    request->rm_xid = xid;
+    request->rm_direction = CALL;
 
-        request->rm_call.cb_rpcvers = 2;
-        request->rm_call.cb_prog = prognum;
-        request->rm_call.cb_vers = progver;
-        request->rm_call.cb_proc = procnum;
+    request->rm_call.cb_rpcvers = 2;
+    request->rm_call.cb_prog = prognum;
+    request->rm_call.cb_vers = progver;
+    request->rm_call.cb_proc = procnum;
 
-        request->rm_call.cb_cred.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_cred.oa_base   = NULL;
-        request->rm_call.cb_cred.oa_length = 0;
+    request->rm_call.cb_cred.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_cred.oa_base = NULL;
+    request->rm_call.cb_cred.oa_length = 0;
 
-        request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_verf.oa_base = NULL;
-        request->rm_call.cb_verf.oa_length = 0;
+    request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_verf.oa_base = NULL;
+    request->rm_call.cb_verf.oa_length = 0;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 struct iovec
-rpcsvc_callback_build_header (char *recordstart, size_t rlen,
+rpcsvc_callback_build_header(char *recordstart, size_t rlen,
                              struct rpc_msg *request, size_t payload)
 {
-        struct iovec    requesthdr = {0, };
-        struct iovec    txrecord   = {0, 0};
-        int             ret        = -1;
-        size_t          fraglen    = 0;
-
-        ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "Failed to create RPC request");
-                goto out;
-        }
-
-        fraglen = payload + requesthdr.iov_len;
-        gf_log ("rpcsvc", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len);
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = requesthdr.iov_len;
+    struct iovec requesthdr = {
+        0,
+    };
+    struct iovec txrecord = {0, 0};
+    int ret = -1;
+    size_t fraglen = 0;
+
+    ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create RPC request");
+        goto out;
+    }
+
+    fraglen = payload + requesthdr.iov_len;
+    gf_log("rpcsvc", GF_LOG_TRACE,
+           "Request fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, requesthdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = requesthdr.iov_len;
 
 out:
-        return txrecord;
+    return txrecord;
 }
 
 static struct iobuf *
-rpcsvc_callback_build_record (rpcsvc_t *rpc, int prognum, int progver,
-                              int procnum, size_t payload, u_long xid,
-                              struct iovec *recbuf)
-{
-        struct rpc_msg           request     = {0, };
-        struct iobuf            *request_iob = NULL;
-        char                    *record      = NULL;
-        struct iovec             recordhdr   = {0, };
-        size_t                   pagesize    = 0;
-        size_t                   xdr_size    = 0;
-        int                      ret         = -1;
-
-        if ((!rpc) || (!recbuf)) {
-                goto out;
-        }
-
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        ret = rpcsvc_fill_callback (prognum, progver, procnum, payload, xid,
-                                    &request);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING, "cannot build a rpc-request "
-                        "xid (%" GF_PRI_RPC_XID ")", xid);
-                goto out;
-        }
-
-        /* First, try to get a pointer into the buffer which the RPC
-         * layer can use.
-         */
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request);
-
-        request_iob = iobuf_get2 (rpc->ctx->iobuf_pool, (xdr_size + payload));
-        if (!request_iob) {
-                goto out;
-        }
-
-        pagesize = iobuf_pagesize (request_iob);
-
-        record = iobuf_ptr (request_iob);  /* Now we have it. */
-
-        recordhdr = rpcsvc_callback_build_header (record, pagesize, &request,
-                                                  payload);
-
-        if (!recordhdr.iov_base) {
-                gf_log ("rpc-clnt", GF_LOG_ERROR, "Failed to build record "
-                        " header");
-                iobuf_unref (request_iob);
-                request_iob = NULL;
-                recbuf->iov_base = NULL;
-                goto out;
-        }
-
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+rpcsvc_callback_build_record(rpcsvc_t *rpc, int prognum, int progver,
+                             int procnum, size_t payload, u_long xid,
+                             struct iovec *recbuf)
+{
+    struct rpc_msg request = {
+        0,
+    };
+    struct iobuf *request_iob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    size_t xdr_size = 0;
+    int ret = -1;
+
+    if ((!rpc) || (!recbuf)) {
+        goto out;
+    }
+
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpcsvc_fill_callback(prognum, progver, procnum, payload, xid,
+                               &request);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING,
+               "cannot build a rpc-request "
+               "xid (%lu)",
+               xid);
+        goto out;
+    }
+
+    /* First, try to get a pointer into the buffer which the RPC
+     * layer can use.
+     */
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request);
+
+    request_iob = iobuf_get2(rpc->ctx->iobuf_pool, (xdr_size + payload));
+    if (!request_iob) {
+        goto out;
+    }
+
+    pagesize = iobuf_pagesize(request_iob);
+
+    record = iobuf_ptr(request_iob); /* Now we have it. */
+
+    recordhdr = rpcsvc_callback_build_header(record, pagesize, &request,
+                                             payload);
+
+    if (!recordhdr.iov_base) {
+        gf_log("rpc-clnt", GF_LOG_ERROR,
+               "Failed to build record "
+               " header");
+        iobuf_unref(request_iob);
+        request_iob = NULL;
+        recbuf->iov_base = NULL;
+        goto out;
+    }
+
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 
 out:
-        return request_iob;
+    return request_iob;
 }
 
-int rpcsvc_request_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                           rpcsvc_cbk_program_t *prog, int procnum,
-                           void *req, glusterfs_ctx_t *ctx,
-                           xdrproc_t xdrproc)
+int
+rpcsvc_request_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                      rpcsvc_cbk_program_t *prog, int procnum, void *req,
+                      glusterfs_ctx_t *ctx, xdrproc_t xdrproc)
 {
-        int                     ret         = -1;
-        int                     count       = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf      = NULL;
-        ssize_t                 xdr_size    = 0;
-        struct iobref           *iobref     = NULL;
-
-        if (!req)
-                goto out;
-
-        xdr_size = xdr_sizeof (xdrproc, req);
-
-        iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-        if (!iobuf)
-                goto out;
-
-        iov.iov_base = iobuf->ptr;
-        iov.iov_len  = iobuf_pagesize (iobuf);
-
-        ret = xdr_serialize_generic (iov, req, xdrproc);
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to create XDR payload");
-                goto out;
-        }
-        iov.iov_len = ret;
-        count = 1;
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                ret = -1;
-                gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
-                goto out;
-        }
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    ssize_t xdr_size = 0;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        goto out;
+
+    xdr_size = xdr_sizeof(xdrproc, req);
+
+    iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+    if (!iobuf)
+        goto out;
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    ret = xdr_serialize_generic(iov, req, xdrproc);
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+        goto out;
+    }
+    iov.iov_len = ret;
+    count = 1;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        ret = -1;
+        gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
+        goto out;
+    }
 
-        iobref_add (iobref, iobuf);
+    iobref_add(iobref, iobuf);
 
-        ret = rpcsvc_callback_submit (rpc, trans, prog, procnum,
-                                      &iov, count, iobref);
+    ret = rpcsvc_callback_submit(rpc, trans, prog, procnum, &iov, count,
+                                 iobref);
 
 out:
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                        rpcsvc_cbk_program_t *prog, int procnum,
-                        struct iovec *proghdr, int proghdrcount,
-                        struct iobref *iobref)
-{
-        struct iobuf          *request_iob = NULL;
-        struct iovec           rpchdr      = {0,};
-        rpc_transport_req_t    req;
-        int                    ret         = -1;
-        int                    proglen     = 0;
-        uint32_t               xid         = 0;
-        gf_boolean_t           new_iobref  = _gf_false;
-
-        if (!rpc) {
-                goto out;
-        }
-
-        memset (&req, 0, sizeof (req));
-
-        if (proghdr) {
-                proglen += iov_length (proghdr, proghdrcount);
-        }
-
-        xid = rpc_callback_new_callid (trans);
-
-        request_iob = rpcsvc_callback_build_record (rpc, prog->prognum,
-                                                    prog->progver, procnum,
-                                                    proglen, xid, &rpchdr);
-        if (!request_iob) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "cannot build rpc-record");
-                goto out;
-        }
+rpcsvc_callback_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                       rpcsvc_cbk_program_t *prog, int procnum,
+                       struct iovec *proghdr, int proghdrcount,
+                       struct iobref *iobref)
+{
+    struct iobuf *request_iob = NULL;
+    struct iovec rpchdr = {
+        0,
+    };
+    rpc_transport_req_t req;
+    int ret = -1;
+    int proglen = 0;
+    uint32_t xid = 0;
+    gf_boolean_t new_iobref = _gf_false;
+
+    if (!rpc) {
+        goto out;
+    }
+
+    memset(&req, 0, sizeof(req));
+
+    if (proghdr) {
+        proglen += iov_length(proghdr, proghdrcount);
+    }
+
+    xid = rpc_callback_new_callid(trans);
+
+    request_iob = rpcsvc_callback_build_record(
+        rpc, prog->prognum, prog->progver, procnum, proglen, xid, &rpchdr);
+    if (!request_iob) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "cannot build rpc-record");
+        goto out;
+    }
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
-                        goto out;
-                }
-                new_iobref = 1;
+            gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
+            goto out;
         }
+        new_iobref = 1;
+    }
 
-        iobref_add (iobref, request_iob);
+    iobref_add(iobref, request_iob);
 
-        req.msg.rpchdr = &rpchdr;
-        req.msg.rpchdrcount = 1;
-        req.msg.proghdr = proghdr;
-        req.msg.proghdrcount = proghdrcount;
-        req.msg.iobref = iobref;
+    req.msg.rpchdr = &rpchdr;
+    req.msg.rpchdrcount = 1;
+    req.msg.proghdr = proghdr;
+    req.msg.proghdrcount = proghdrcount;
+    req.msg.iobref = iobref;
 
-        ret = rpc_transport_submit_request (trans, &req);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "transmission of rpc-request failed");
-                goto out;
-        }
+    ret = rpc_transport_submit_request(trans, &req);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "transmission of rpc-request failed");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        iobuf_unref (request_iob);
+    iobuf_unref(request_iob);
 
-        if (new_iobref)
-               iobref_unref (iobref);
+    if (new_iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_transport_submit (rpc_transport_t *trans, struct iovec *rpchdr,
-                         int rpchdrcount, struct iovec *proghdr,
-                         int proghdrcount, struct iovec *progpayload,
-                         int progpayloadcount, struct iobref *iobref,
-                         void *priv)
+rpcsvc_transport_submit(rpc_transport_t *trans, struct iovec *rpchdr,
+                        int rpchdrcount, struct iovec *proghdr,
+                        int proghdrcount, struct iovec *progpayload,
+                        int progpayloadcount, struct iobref *iobref, void *priv)
 {
-        int                   ret   = -1;
-        rpc_transport_reply_t reply = {{0, }};
-
-        if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) {
-                goto out;
-        }
-
-        reply.msg.rpchdr = rpchdr;
-        reply.msg.rpchdrcount = rpchdrcount;
-        reply.msg.proghdr = proghdr;
-        reply.msg.proghdrcount = proghdrcount;
-        reply.msg.progpayload = progpayload;
-        reply.msg.progpayloadcount = progpayloadcount;
-        reply.msg.iobref = iobref;
-        reply.private = priv;
-
-        ret = rpc_transport_submit_reply (trans, &reply);
+    int ret = -1;
+    rpc_transport_reply_t reply = {
+        0,
+    };
+
+    if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) {
+        goto out;
+    }
+
+    reply.msg.rpchdr = rpchdr;
+    reply.msg.rpchdrcount = rpchdrcount;
+    reply.msg.proghdr = proghdr;
+    reply.msg.proghdrcount = proghdrcount;
+    reply.msg.progpayload = progpayload;
+    reply.msg.progpayloadcount = progpayloadcount;
+    reply.msg.iobref = iobref;
+    reply.private = priv;
+
+    ret = rpc_transport_submit_reply(trans, &reply);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_fill_reply (rpcsvc_request_t *req, struct rpc_msg *reply)
+rpcsvc_fill_reply(rpcsvc_request_t *req, struct rpc_msg *reply)
 {
-        int                      ret  = -1;
-        rpcsvc_program_t        *prog = NULL;
-        if ((!req) || (!reply))
-                goto out;
-
-        ret = 0;
-        rpc_fill_empty_reply (reply, req->xid);
-        if (req->rpc_status == MSG_DENIED) {
-                rpc_fill_denied_reply (reply, req->rpc_err, req->auth_err);
-                goto out;
-        }
-
-        prog = rpcsvc_request_program (req);
-
-        if (req->rpc_status == MSG_ACCEPTED)
-                rpc_fill_accepted_reply (reply, req->rpc_err,
-                                         (prog) ? prog->proglowvers : 0,
-                                         (prog) ? prog->proghighvers: 0,
-                                         req->verf.flavour, req->verf.datalen,
-                                         req->verf.authdata);
-        else
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value");
+    int ret = -1;
+    rpcsvc_program_t *prog = NULL;
+    if ((!req) || (!reply))
+        goto out;
+
+    ret = 0;
+    rpc_fill_empty_reply(reply, req->xid);
+    if (req->rpc_status == MSG_DENIED) {
+        rpc_fill_denied_reply(reply, req->rpc_err, req->auth_err);
+        goto out;
+    }
+
+    prog = rpcsvc_request_program(req);
+
+    if (req->rpc_status == MSG_ACCEPTED)
+        rpc_fill_accepted_reply(
+            reply, req->rpc_err, (prog) ? prog->proglowvers : 0,
+            (prog) ? prog->proghighvers : 0, req->verf.flavour,
+            req->verf.datalen, req->verf.authdata);
+    else
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value");
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Given a request and the reply payload, build a reply and encodes the reply
  * into a record header. This record header is encoded into the vector pointed
  * to be recbuf.
@@ -1214,59 +1400,60 @@ out:
  * we should account for the length of that buffer in the RPC fragment header.
  */
 struct iobuf *
-rpcsvc_record_build_record (rpcsvc_request_t *req, size_t payload,
-                            size_t hdrlen, struct iovec *recbuf)
+rpcsvc_record_build_record(rpcsvc_request_t *req, size_t payload, size_t hdrlen,
+                           struct iovec *recbuf)
 {
-        struct rpc_msg          reply;
-        struct iobuf            *replyiob = NULL;
-        char                    *record = NULL;
-        struct iovec            recordhdr = {0, };
-        size_t                  pagesize = 0;
-        size_t                  xdr_size = 0;
-        rpcsvc_t                *svc = NULL;
-        int                     ret = -1;
-
-        if ((!req) || (!req->trans) || (!req->svc) || (!recbuf))
-                return NULL;
+    struct rpc_msg reply;
+    struct iobuf *replyiob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    size_t xdr_size = 0;
+    rpcsvc_t *svc = NULL;
+    int ret = -1;
+
+    if ((!req) || (!req->trans) || (!req->svc) || (!recbuf))
+        return NULL;
 
-        svc = req->svc;
+    svc = req->svc;
 
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        ret = rpcsvc_fill_reply (req, &reply);
-        if (ret)
-                goto err_exit;
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpcsvc_fill_reply(req, &reply);
+    if (ret)
+        goto err_exit;
 
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_replymsg, &reply);
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_replymsg, &reply);
 
-        /* Payload would include 'readv' size etc too, where as
-           that comes as another payload iobuf */
-        replyiob = iobuf_get2 (svc->ctx->iobuf_pool, (xdr_size + hdrlen));
-        if (!replyiob) {
-                goto err_exit;
-        }
+    /* Payload would include 'readv' size etc too, where as
+       that comes as another payload iobuf */
+    replyiob = iobuf_get2(svc->ctx->iobuf_pool, (xdr_size + hdrlen));
+    if (!replyiob) {
+        goto err_exit;
+    }
 
-        pagesize = iobuf_pagesize (replyiob);
+    pagesize = iobuf_pagesize(replyiob);
 
-        record = iobuf_ptr (replyiob);  /* Now we have it. */
+    record = iobuf_ptr(replyiob); /* Now we have it. */
 
-        recordhdr = rpcsvc_record_build_header (record, pagesize, reply,
-                                                payload);
-        if (!recordhdr.iov_base) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to build record "
-                        " header");
-                iobuf_unref (replyiob);
-                replyiob = NULL;
-                recbuf->iov_base = NULL;
-                goto err_exit;
-        }
+    recordhdr = rpcsvc_record_build_header(record, pagesize, reply, payload);
+    if (!recordhdr.iov_base) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to build record "
+               " header");
+        iobuf_unref(replyiob);
+        replyiob = NULL;
+        recbuf->iov_base = NULL;
+        goto err_exit;
+    }
 
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 err_exit:
-        return replyiob;
+    return replyiob;
 }
 
-
 /*
  * The function to submit a program message to the RPC service.
  * This message is added to the transmission queue of the
@@ -1294,244 +1481,344 @@ err_exit:
  */
 
 int
-rpcsvc_submit_generic (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref)
+rpcsvc_submit_generic(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref)
 {
-        int                     ret        = -1, i = 0;
-        struct iobuf           *replyiob   = NULL;
-        struct iovec            recordhdr  = {0, };
-        rpc_transport_t        *trans      = NULL;
-        size_t                  msglen     = 0;
-        size_t                  hdrlen     = 0;
-        char                    new_iobref = 0;
-        rpcsvc_drc_globals_t   *drc        = NULL;
-
-        if ((!req) || (!req->trans))
-                return -1;
-
-        trans = req->trans;
-
-        for (i = 0; i < hdrcount; i++) {
-                msglen += proghdr[i].iov_len;
-        }
-
-        for (i = 0; i < payloadcount; i++) {
-                msglen += payload[i].iov_len;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen);
-
-        /* Build the buffer containing the encoded RPC reply. */
-        replyiob = rpcsvc_record_build_record (req, msglen, hdrlen, &recordhdr);
-        if (!replyiob) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,"Reply record creation failed");
-                goto disconnect_exit;
-        }
-
+    int ret = -1, i = 0;
+    struct iobuf *replyiob = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    rpc_transport_t *trans = NULL;
+    size_t msglen = 0;
+    size_t hdrlen = 0;
+    char new_iobref = 0;
+    rpcsvc_drc_globals_t *drc = NULL;
+    gf_latency_t *lat = NULL;
+
+    if ((!req) || (!req->trans))
+        return -1;
+
+    if (req->prog && req->begin.tv_sec) {
+        if ((req->procnum >= 0) && (req->procnum < req->prog->numactors)) {
+            timespec_now(&req->end);
+            lat = &req->prog->latencies[req->procnum];
+            gf_latency_update(lat, &req->begin, &req->end);
+        }
+    }
+    trans = req->trans;
+
+    for (i = 0; i < hdrcount; i++) {
+        msglen += proghdr[i].iov_len;
+    }
+
+    for (i = 0; i < payloadcount; i++) {
+        msglen += payload[i].iov_len;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen);
+
+    /* Build the buffer containing the encoded RPC reply. */
+    replyiob = rpcsvc_record_build_record(req, msglen, hdrlen, &recordhdr);
+    if (!replyiob) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Reply record creation failed");
+        goto disconnect_exit;
+    }
+
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        goto disconnect_exit;
-                }
-
-                new_iobref = 1;
+            goto disconnect_exit;
         }
 
-        iobref_add (iobref, replyiob);
-
-        /* cache the request in the duplicate request cache for appropriate ops */
-        if ((req->reply) && (rpcsvc_need_drc (req))) {
-                drc = req->svc->drc;
+        new_iobref = 1;
+    }
 
-                LOCK (&drc->lock);
-                ret = rpcsvc_cache_reply (req, iobref, &recordhdr, 1,
-                                          proghdr, hdrcount,
-                                          payload, payloadcount);
-                UNLOCK (&drc->lock);
-        }
+    iobref_add(iobref, replyiob);
 
-        ret = rpcsvc_transport_submit (trans, &recordhdr, 1, proghdr, hdrcount,
-                                       payload, payloadcount, iobref,
-                                       req->trans_private);
+    /* cache the request in the duplicate request cache for appropriate ops */
+    if ((req->reply) && (rpcsvc_need_drc(req))) {
+        drc = req->svc->drc;
 
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "failed to submit message "
-                        "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to "
-                        "rpc-transport (%s)", req->xid,
-                        req->prog ? req->prog->progname : "(not matched)",
-                        req->prog ? req->prog->progver : 0,
-                        req->procnum, trans ? trans->name : "");
-        } else {
-                gf_log (GF_RPCSVC, GF_LOG_TRACE,
-                        "submitted reply for rpc-message (XID: 0x%x, "
-                        "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport "
-                        "(%s)", req->xid, req->prog ? req->prog->progname: "-",
-                        req->prog ? req->prog->progver : 0,
-                        req->procnum, trans ? trans->name : "");
-        }
+        LOCK(&drc->lock);
+        ret = rpcsvc_cache_reply(req, iobref, &recordhdr, 1, proghdr, hdrcount,
+                                 payload, payloadcount);
+        UNLOCK(&drc->lock);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to cache reply");
+        }
+    }
+
+    ret = rpcsvc_transport_submit(trans, &recordhdr, 1, proghdr, hdrcount,
+                                  payload, payloadcount, iobref,
+                                  req->trans_private);
+
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "failed to submit message "
+               "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to "
+               "rpc-transport (%s)",
+               req->xid, req->prog ? req->prog->progname : "(not matched)",
+               req->prog ? req->prog->progver : 0, req->procnum,
+               trans ? trans->name : "");
+    } else {
+        gf_log(GF_RPCSVC, GF_LOG_TRACE,
+               "submitted reply for rpc-message (XID: 0x%x, "
+               "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport "
+               "(%s)",
+               req->xid, req->prog ? req->prog->progname : "-",
+               req->prog ? req->prog->progver : 0, req->procnum,
+               trans ? trans->name : "");
+    }
 
 disconnect_exit:
-        if (replyiob) {
-                iobuf_unref (replyiob);
-        }
+    if (replyiob) {
+        iobuf_unref(replyiob);
+    }
 
-        if (new_iobref) {
-                iobref_unref (iobref);
-        }
+    if (new_iobref) {
+        iobref_unref(iobref);
+    }
 
-        rpcsvc_request_destroy (req);
+    rpcsvc_request_destroy(req);
 
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_error_reply (rpcsvc_request_t *req)
+rpcsvc_error_reply(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
+    struct iovec dummyvec = {
+        0,
+    };
 
-        if (!req)
-                return -1;
+    if (!req)
+        return -1;
 
-        gf_log_callingfn ("", GF_LOG_DEBUG, "sending a RPC error reply");
+    gf_log_callingfn("", GF_LOG_DEBUG, "sending a RPC error reply");
 
-        /* At this point the req should already have been filled with the
-         * appropriate RPC error numbers.
-         */
-        return rpcsvc_submit_generic (req, &dummyvec, 0, NULL, 0, NULL);
+    /* At this point the req should already have been filled with the
+     * appropriate RPC error numbers.
+     */
+    return rpcsvc_submit_generic(req, &dummyvec, 0, NULL, 0, NULL);
 }
 
-
-/* Register the program with the local portmapper service. */
+#ifdef IPV6_DEFAULT
 int
-rpcsvc_program_register_portmap (rpcsvc_program_t *newprog, uint32_t port)
+rpcsvc_program_register_rpcbind6(rpcsvc_program_t *newprog, uint32_t port)
 {
-        int                ret   = -1; /* FAIL */
+    const int IP_BUF_LEN = 64;
+    char addr_buf[IP_BUF_LEN];
+
+    int err = 0;
+    bool_t success = 0;
+    struct netconfig *nc;
+    struct netbuf *nb;
+
+    if (!newprog) {
+        goto out;
+    }
+
+    nc = getnetconfigent("tcp6");
+    if (!nc) {
+        err = -1;
+        goto out;
+    }
+
+    err = sprintf(addr_buf, "::.%d.%d", port >> 8 & 0xff, port & 0xff);
+    if (err < 0) {
+        err = -1;
+        goto out;
+    }
+
+    nb = uaddr2taddr(nc, addr_buf);
+    if (!nb) {
+        err = -1;
+        goto out;
+    }
+
+    /* Force the unregistration of the program first.
+     * This call may fail if nothing has been registered,
+     * which is fine.
+     */
+    rpcsvc_program_unregister_rpcbind6(newprog);
+
+    success = rpcb_set(newprog->prognum, newprog->progver, nc, nb);
+    if (!success) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not register the IPv6"
+               " service with rpcbind");
+    }
+
+    err = 0;
 
-        if (!newprog) {
-                goto out;
-        }
-
-        /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */
-        if (!(pmap_set (newprog->prognum, newprog->progver, IPPROTO_TCP,
-                        port))) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register with"
-                        " portmap %d %d %u", newprog->prognum, newprog->progver, port);
-                goto out;
-        }
+out:
+    return err;
+}
 
-        ret = 0; /* SUCCESS */
+int
+rpcsvc_program_unregister_rpcbind6(rpcsvc_program_t *newprog)
+{
+    int err = 0;
+    bool_t success = 0;
+    struct netconfig *nc;
+
+    if (!newprog) {
+        goto out;
+    }
+
+    nc = getnetconfigent("tcp6");
+    if (!nc) {
+        err = -1;
+        goto out;
+    }
+
+    success = rpcb_unset(newprog->prognum, newprog->progver, nc);
+    if (!success) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not unregister the IPv6"
+               " service with rpcbind");
+    }
+
+    err = 0;
 out:
-        return ret;
+    return err;
 }
+#endif
 
+/* Register the program with the local portmapper service. */
+int
+rpcsvc_program_register_portmap(rpcsvc_program_t *newprog, uint32_t port)
+{
+    int ret = -1; /* FAIL */
+
+    if (!newprog) {
+        goto out;
+    }
+
+    /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */
+    if (!(pmap_set(newprog->prognum, newprog->progver, IPPROTO_TCP, port))) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not register with"
+               " portmap %d %d %u",
+               newprog->prognum, newprog->progver, port);
+        goto out;
+    }
+
+    ret = 0; /* SUCCESS */
+out:
+    return ret;
+}
 
 int
-rpcsvc_program_unregister_portmap (rpcsvc_program_t *prog)
+rpcsvc_program_unregister_portmap(rpcsvc_program_t *prog)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!prog)
-                goto out;
+    if (!prog)
+        goto out;
 
-        if (!(pmap_unset(prog->prognum, prog->progver))) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not unregister with"
-                        " portmap");
-                goto out;
-        }
+    if (!(pmap_unset(prog->prognum, prog->progver))) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not unregister with"
+               " portmap");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_register_portmap_enabled (rpcsvc_t *svc)
+rpcsvc_register_portmap_enabled(rpcsvc_t *svc)
 {
-        return svc->register_portmap;
+    return svc->register_portmap;
 }
 
 int32_t
-rpcsvc_get_listener_port (rpcsvc_listener_t *listener)
+rpcsvc_get_listener_port(rpcsvc_listener_t *listener)
 {
-        int32_t listener_port = -1;
+    int32_t listener_port = -1;
 
-        if ((listener == NULL) || (listener->trans == NULL)) {
-                goto out;
-        }
+    if ((listener == NULL) || (listener->trans == NULL)) {
+        goto out;
+    }
 
-        switch (listener->trans->myinfo.sockaddr.ss_family) {
+    switch (listener->trans->myinfo.sockaddr.ss_family) {
         case AF_INET:
-                listener_port = ((struct sockaddr_in *)&listener->trans->myinfo.sockaddr)->sin_port;
-                break;
+            listener_port = ((struct sockaddr_in *)&listener->trans->myinfo
+                                 .sockaddr)
+                                ->sin_port;
+            break;
 
         case AF_INET6:
-                listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo.sockaddr)->sin6_port;
-                break;
+            listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo
+                                 .sockaddr)
+                                ->sin6_port;
+            break;
 
         default:
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG,
-                        "invalid address family (%d)",
-                        listener->trans->myinfo.sockaddr.ss_family);
-                goto out;
-        }
+            gf_log(GF_RPCSVC, GF_LOG_DEBUG, "invalid address family (%d)",
+                   listener->trans->myinfo.sockaddr.ss_family);
+            goto out;
+    }
 
-        listener_port = ntohs (listener_port);
+    listener_port = ntohs(listener_port);
 
 out:
-        return listener_port;
+    return listener_port;
 }
 
-
 rpcsvc_listener_t *
-rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans)
+rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans)
 {
-        rpcsvc_listener_t  *listener      = NULL;
-        char                found         = 0;
-        uint32_t            listener_port = 0;
-
-        if (!svc) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&svc->rpclock);
+    rpcsvc_listener_t *listener = NULL;
+    char found = 0;
+    rpcsvc_listener_t *next = NULL;
+    uint32_t listener_port = 0;
+
+    if (!svc) {
+        goto out;
+    }
+
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry_safe(listener, next, &svc->listeners, list)
         {
-                list_for_each_entry (listener, &svc->listeners, list) {
-                        if (trans != NULL) {
-                                if (listener->trans == trans) {
-                                        found = 1;
-                                        break;
-                                }
-
-                                continue;
-                        }
+            if (trans != NULL) {
+                if (listener->trans == trans) {
+                    found = 1;
+                    break;
+                }
 
-                        listener_port = rpcsvc_get_listener_port (listener);
-                        if (listener_port == -1) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "invalid port for listener %s",
-                                        listener->trans->name);
-                                continue;
-                        }
+                continue;
+            }
 
-                        if (listener_port == port) {
-                                found = 1;
-                                break;
-                        }
-                }
-        }
-        pthread_mutex_unlock (&svc->rpclock);
+            listener_port = rpcsvc_get_listener_port(listener);
+            if (listener_port == -1) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid port for listener %s",
+                       listener->trans->name);
+                continue;
+            }
 
-        if (!found) {
-                listener = NULL;
+            if (listener_port == port) {
+                found = 1;
+                break;
+            }
         }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    if (!found) {
+        listener = NULL;
+    }
 
 out:
-        return listener;
+    return listener;
 }
 
-
 /* The only difference between the generic submit and this one is that the
  * generic submit is also used for submitting RPC error replies in where there
  * are no payloads so the msgvec and msgbuf can be NULL.
@@ -1539,743 +1826,832 @@ out:
  * we must perform NULL checks before calling the generic submit.
  */
 int
-rpcsvc_submit_message (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref)
+rpcsvc_submit_message(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref)
 {
-        if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base))
-                return -1;
+    if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base))
+        return -1;
 
-        return rpcsvc_submit_generic (req, proghdr, hdrcount, payload,
-                                      payloadcount, iobref);
+    return rpcsvc_submit_generic(req, proghdr, hdrcount, payload, payloadcount,
+                                 iobref);
 }
 
+void
+rpcsvc_program_destroy(rpcsvc_program_t *program)
+{
+    if (program) {
+        GF_FREE(program->latencies);
+        GF_FREE(program);
+    }
+}
 
 int
-rpcsvc_program_unregister (rpcsvc_t *svc, rpcsvc_program_t *program)
+rpcsvc_program_unregister(rpcsvc_t *svc, rpcsvc_program_t *program)
 {
-        int                     ret = -1;
-        rpcsvc_program_t        *prog = NULL;
-        if (!svc || !program) {
-                goto out;
-        }
-
-        ret = rpcsvc_program_unregister_portmap (program);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "portmap unregistration of"
-                        " program failed");
-                goto out;
-        }
-        pthread_mutex_lock (&svc->rpclock);
+    int ret = -1;
+    rpcsvc_program_t *prog = NULL;
+    if (!svc || !program) {
+        goto out;
+    }
+
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(prog, &svc->programs, program)
         {
-                list_for_each_entry (prog, &svc->programs, program) {
-                        if ((prog->prognum == program->prognum)
-                            && (prog->progver == program->progver)) {
-                                break;
-                        }
-                }
-        }
-        pthread_mutex_unlock (&svc->rpclock);
-
-        if (prog == NULL) {
-                ret = -1;
-                goto out;
-        }
+            if ((prog->prognum == program->prognum) &&
+                (prog->progver == program->progver)) {
+                break;
+            }
+        }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    ret = rpcsvc_program_unregister_portmap(program);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "portmap unregistration of"
+               " program failed");
+        goto out;
+    }
+#ifdef IPV6_DEFAULT
+    ret = rpcsvc_program_unregister_rpcbind6(program);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "rpcbind (ipv6)"
+               " unregistration of program failed");
+        goto out;
+    }
+#endif
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Program unregistered: %s, Num: %d,"
-                " Ver: %d, Port: %d", prog->progname, prog->prognum,
-                prog->progver, prog->progport);
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "Program unregistered: %s, Num: %d,"
+           " Ver: %d, Port: %d",
+           prog->progname, prog->prognum, prog->progver, prog->progport);
 
-        if (prog->ownthread) {
-                prog->alive = _gf_false;
-                ret = 0;
-                goto out;
-        }
+    if (prog->ownthread) {
+        prog->alive = _gf_false;
+        ret = 0;
+        goto out;
+    }
 
-        pthread_mutex_lock (&svc->rpclock);
-        {
-                list_del_init (&prog->program);
-        }
-        pthread_mutex_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_del_init(&prog->program);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1) {
-                if (program) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program "
-                                "unregistration failed"
-                                ": %s, Num: %d, Ver: %d, Port: %d",
-                                program->progname, program->prognum,
-                                program->progver, program->progport);
-                } else {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program not found");
-                }
+    rpcsvc_program_destroy(prog);
+
+    if (ret == -1) {
+        if (program) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Program "
+                   "unregistration failed"
+                   ": %s, Num: %d, Ver: %d, Port: %d",
+                   program->progname, program->prognum, program->progver,
+                   program->progport);
+        } else {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "Program not found");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_transport_peername (rpc_transport_t *trans, char *hostname, int hostlen)
+rpcsvc_transport_peername(rpc_transport_t *trans, char *hostname, int hostlen)
 {
-        if (!trans) {
-                return -1;
-        }
+    if (!trans) {
+        return -1;
+    }
 
-        return rpc_transport_get_peername (trans, hostname, hostlen);
+    return rpc_transport_get_peername(trans, hostname, hostlen);
 }
 
-
 int
-rpcsvc_transport_peeraddr (rpc_transport_t *trans, char *addrstr, int addrlen,
-                           struct sockaddr_storage *sa, socklen_t sasize)
+rpcsvc_transport_peeraddr(rpc_transport_t *trans, char *addrstr, int addrlen,
+                          struct sockaddr_storage *sa, socklen_t sasize)
 {
-        if (!trans) {
-                return -1;
-        }
+    if (!trans) {
+        return -1;
+    }
 
-        return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa,
-                                          sasize);
+    return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa, sasize);
 }
 
 rpcsvc_listener_t *
-rpcsvc_listener_alloc (rpcsvc_t *svc, rpc_transport_t *trans)
+rpcsvc_listener_alloc(rpcsvc_t *svc, rpc_transport_t *trans)
 {
-        rpcsvc_listener_t *listener = NULL;
+    rpcsvc_listener_t *listener = NULL;
 
-        listener = GF_CALLOC (1, sizeof (*listener),
-                              gf_common_mt_rpcsvc_listener_t);
-        if (!listener) {
-                goto out;
-        }
+    listener = GF_CALLOC(1, sizeof(*listener), gf_common_mt_rpcsvc_listener_t);
+    if (!listener) {
+        goto out;
+    }
 
-        listener->trans = trans;
-        listener->svc = svc;
+    listener->trans = trans;
+    listener->svc = svc;
 
-        INIT_LIST_HEAD (&listener->list);
+    INIT_LIST_HEAD(&listener->list);
 
-        pthread_mutex_lock (&svc->rpclock);
-        {
-                list_add_tail (&listener->list, &svc->listeners);
-        }
-        pthread_mutex_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_add_tail(&listener->list, &svc->listeners);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 out:
-        return listener;
+    return listener;
 }
 
-
 int32_t
-rpcsvc_create_listener (rpcsvc_t *svc, dict_t *options, char *name)
+rpcsvc_create_listener(rpcsvc_t *svc, dict_t *options, char *name)
 {
-        rpc_transport_t   *trans    = NULL;
-        rpcsvc_listener_t *listener = NULL;
-        int32_t            ret      = -1;
-
-        if (!svc || !options) {
-                goto out;
-        }
-
-        trans = rpc_transport_load (svc->ctx, options, name);
-        if (!trans) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "cannot create listener, "
-                        "initing the transport failed");
-                goto out;
-        }
-
-        ret = rpc_transport_listen (trans);
-        if (ret == -EADDRINUSE || ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "listening on transport failed");
-                goto out;
-        }
-
-        ret = rpc_transport_register_notify (trans, rpcsvc_notify, svc);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "registering notify failed");
-                goto out;
-        }
-
-        listener = rpcsvc_listener_alloc (svc, trans);
-        if (listener == NULL) {
-                goto out;
-        }
+    rpc_transport_t *trans = NULL;
+    rpcsvc_listener_t *listener = NULL;
+    int32_t ret = -1;
+
+    if (!svc || !options) {
+        goto out;
+    }
+
+    trans = rpc_transport_load(svc->ctx, options, name);
+    if (!trans) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "cannot create listener, "
+               "initing the transport failed");
+        goto out;
+    }
+
+    ret = rpc_transport_listen(trans);
+    if (ret == -EADDRINUSE || ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "listening on transport failed");
+        goto out;
+    }
+
+    ret = rpc_transport_register_notify(trans, rpcsvc_notify, svc);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "registering notify failed");
+        goto out;
+    }
+
+    listener = rpcsvc_listener_alloc(svc, trans);
+    if (listener == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (!listener && trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-        }
+    if (!listener && trans) {
+        rpc_transport_disconnect(trans, _gf_true);
+        rpc_transport_cleanup(trans);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-rpcsvc_create_listeners (rpcsvc_t *svc, dict_t *options, char *name)
+rpcsvc_create_listeners(rpcsvc_t *svc, dict_t *options, char *name)
 {
-        int32_t  ret            = -1, count = 0;
-        data_t  *data           = NULL;
-        char    *str            = NULL, *ptr = NULL, *transport_name = NULL;
-        char    *transport_type = NULL, *saveptr = NULL, *tmp = NULL;
-
-        if ((svc == NULL) || (options == NULL) || (name == NULL)) {
-                goto out;
-        }
-
-        data = dict_get (options, "transport-type");
-        if (data == NULL) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "option transport-type not set");
-                goto out;
+    int32_t ret = -1, count = 0;
+    data_t *data = NULL;
+    char *str = NULL, *ptr = NULL, *transport_name = NULL;
+    char *transport_type = NULL, *saveptr = NULL, *tmp = NULL;
+
+    if ((svc == NULL) || (options == NULL) || (name == NULL)) {
+        goto out;
+    }
+
+    data = dict_get(options, "transport-type");
+    if (data == NULL) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set");
+        goto out;
+    }
+
+    transport_type = data_to_str(data);
+    if (transport_type == NULL) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set");
+        goto out;
+    }
+
+    /* duplicate transport_type, since following dict_set will free it */
+    transport_type = gf_strdup(transport_type);
+    if (transport_type == NULL) {
+        goto out;
+    }
+
+    str = gf_strdup(transport_type);
+    if (str == NULL) {
+        goto out;
+    }
+
+    ptr = strtok_r(str, ",", &saveptr);
+
+    while (ptr != NULL) {
+        tmp = gf_strdup(ptr);
+        if (tmp == NULL) {
+            goto out;
+        }
+
+        ret = gf_asprintf(&transport_name, "%s.%s", tmp, name);
+        if (ret == -1) {
+            goto out;
         }
 
-        transport_type = data_to_str (data);
-        if (transport_type == NULL) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "option transport-type not set");
-                goto out;
+        ret = dict_set_dynstr(options, "transport-type", tmp);
+        if (ret == -1) {
+            goto out;
         }
 
-        /* duplicate transport_type, since following dict_set will free it */
-        transport_type = gf_strdup (transport_type);
-        if (transport_type == NULL) {
-                goto out;
-        }
+        tmp = NULL;
+        ptr = strtok_r(NULL, ",", &saveptr);
 
-        str = gf_strdup (transport_type);
-        if (str == NULL) {
-                goto out;
+        ret = rpcsvc_create_listener(svc, options, transport_name);
+        if (ret != 0) {
+            goto out;
         }
 
-        ptr = strtok_r (str, ",", &saveptr);
-
-        while (ptr != NULL) {
-                tmp = gf_strdup (ptr);
-                if (tmp == NULL) {
-                        goto out;
-                }
-
-                ret = gf_asprintf (&transport_name, "%s.%s", tmp, name);
-                if (ret == -1) {
-                        goto out;
-                }
+        dict_del(options, "notify-poller-death");
+        GF_FREE(transport_name);
+        transport_name = NULL;
+        count++;
+    }
 
-                ret = dict_set_dynstr (options, "transport-type", tmp);
-                if (ret == -1) {
-                        goto out;
-                }
-
-                tmp = NULL;
-                ptr = strtok_r (NULL, ",", &saveptr);
+    ret = dict_set_dynstr(options, "transport-type", transport_type);
+    if (ret == -1) {
+        goto out;
+    }
 
-                ret = rpcsvc_create_listener (svc, options, transport_name);
-                if (ret != 0) {
-                        goto out;
-                }
-
-                GF_FREE (transport_name);
-                transport_name = NULL;
-                count++;
-        }
-
-        ret = dict_set_dynstr (options, "transport-type", transport_type);
-        if (ret == -1) {
-                goto out;
-        }
-
-        transport_type = NULL;
+    transport_type = NULL;
 
 out:
-        GF_FREE (str);
+    GF_FREE(str);
 
-        GF_FREE (transport_type);
+    GF_FREE(transport_type);
 
-        GF_FREE (tmp);
+    GF_FREE(tmp);
 
-        GF_FREE (transport_name);
+    GF_FREE(transport_name);
 
-        if (count > 0) {
-                return count;
-        } else {
-                return ret;
-        }
+    if (count > 0) {
+        return count;
+    } else {
+        return ret;
+    }
 }
 
-
 int
-rpcsvc_unregister_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
+rpcsvc_unregister_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL;
-        int                      ret     = 0;
+    rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL;
+    int ret = 0;
 
-        if (!svc || !notify) {
-                goto out;
-        }
+    if (!svc || !notify) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_for_each_entry_safe(wrapper, tmp, &svc->notify, list)
         {
-                list_for_each_entry_safe (wrapper, tmp, &svc->notify, list) {
-                        if ((wrapper->notify == notify)
-                            && (mydata == wrapper->data)) {
-                                list_del_init (&wrapper->list);
-                                GF_FREE (wrapper);
-                                ret++;
-                        }
-                }
+            if ((wrapper->notify == notify) && (mydata == wrapper->data)) {
+                list_del_init(&wrapper->list);
+                GF_FREE(wrapper);
+                ret++;
+            }
         }
-        pthread_mutex_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_register_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
+rpcsvc_register_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
-        int                      ret     = -1;
-
-        wrapper = rpcsvc_notify_wrapper_alloc ();
-        if (!wrapper) {
-                goto out;
-        }
-        svc->mydata   = mydata;
-        wrapper->data = mydata;
-        wrapper->notify = notify;
-
-        pthread_mutex_lock (&svc->rpclock);
-        {
-                list_add_tail (&wrapper->list, &svc->notify);
-                svc->notify_count++;
-        }
-        pthread_mutex_unlock (&svc->rpclock);
-
-        ret = 0;
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
+    int ret = -1;
+
+    wrapper = rpcsvc_notify_wrapper_alloc();
+    if (!wrapper) {
+        goto out;
+    }
+    svc->mydata = mydata;
+    wrapper->data = mydata;
+    wrapper->notify = notify;
+
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_add_tail(&wrapper->list, &svc->notify);
+        svc->notify_count++;
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 void *
-rpcsvc_request_handler (void *arg)
+rpcsvc_request_handler(void *arg)
 {
-        rpcsvc_program_t *program = arg;
-        rpcsvc_request_t *req     = NULL;
-        rpcsvc_actor_t   *actor   = NULL;
-        gf_boolean_t      done    = _gf_false;
-        int               ret     = 0;
-
-        if (!program)
-                return NULL;
-
-        while (1) {
-                pthread_mutex_lock (&program->queue_lock);
-                {
-                        if (!program->alive
-                            && list_empty (&program->request_queue)) {
-                                done = 1;
-                                goto unlock;
-                        }
-
-                        while (list_empty (&program->request_queue))
-                                pthread_cond_wait (&program->queue_cond,
-                                                   &program->queue_lock);
-
-                        req = list_entry (program->request_queue.next,
-                                          typeof (*req), request_list);
-
-                        list_del_init (&req->request_list);
-                }
-        unlock:
-                pthread_mutex_unlock (&program->queue_lock);
-
-                if (done)
-                        break;
+    rpcsvc_request_queue_t *queue = NULL;
+    rpcsvc_program_t *program = NULL;
+    rpcsvc_request_t *req = NULL, *tmp_req = NULL;
+    rpcsvc_actor_t *actor = NULL;
+    gf_boolean_t done = _gf_false;
+    int ret = 0;
+    struct list_head tmp_list;
 
-                THIS = req->svc->xl;
+    queue = arg;
+    program = queue->program;
 
-                actor = rpcsvc_program_actor (req);
-
-                ret = actor->actor (req);
-
-                if (ret != 0) {
-                        rpcsvc_check_and_reply_error (ret, NULL, req);
-                }
-        }
+    INIT_LIST_HEAD(&tmp_list);
 
+    if (!program)
         return NULL;
-}
 
-int
-rpcsvc_program_register (rpcsvc_t *svc, rpcsvc_program_t *program)
-{
-        int               ret                = -1;
-        rpcsvc_program_t *newprog            = NULL;
-        char              already_registered = 0;
+    while (1) {
+        pthread_mutex_lock(&queue->queue_lock);
+        {
+            if (!program->alive && list_empty(&queue->request_queue)) {
+                done = 1;
+                goto unlock;
+            }
 
-        if (!svc) {
-                goto out;
-        }
+            while (list_empty(&queue->request_queue)) {
+                queue->waiting = _gf_true;
+                pthread_cond_wait(&queue->queue_cond, &queue->queue_lock);
+            }
 
-        if (program->actors == NULL) {
-                goto out;
+            queue->waiting = _gf_false;
+
+            if (!list_empty(&queue->request_queue)) {
+                INIT_LIST_HEAD(&tmp_list);
+                list_splice_init(&queue->request_queue, &tmp_list);
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&queue->queue_lock);
 
-        pthread_mutex_lock (&svc->rpclock);
+        list_for_each_entry_safe(req, tmp_req, &tmp_list, request_list)
         {
-                list_for_each_entry (newprog, &svc->programs, program) {
-                        if ((newprog->prognum == program->prognum)
-                            && (newprog->progver == program->progver)) {
-                                already_registered = 1;
-                                break;
-                        }
+            if (req) {
+                list_del_init(&req->request_list);
+
+                if (req->prognum == RPCSVC_INFRA_PROGRAM) {
+                    switch (req->procnum) {
+                        case RPCSVC_PROC_EVENT_THREAD_DEATH:
+                            gf_log(GF_RPCSVC, GF_LOG_INFO,
+                                   "event thread died, exiting request handler "
+                                   "thread for queue %d of program %s",
+                                   (int)(queue - &program->request_queue[0]),
+                                   program->progname);
+                            done = 1;
+                            pthread_mutex_lock(&program->thr_lock);
+                            {
+                                rpcsvc_toggle_queue_status(
+                                    program, queue,
+                                    program->request_queue_status);
+                                program->threadcount--;
+                            }
+                            pthread_mutex_unlock(&program->thr_lock);
+                            rpcsvc_request_destroy(req);
+                            break;
+
+                        default:
+                            break;
+                    }
+                } else {
+                    THIS = req->svc->xl;
+                    actor = rpcsvc_program_actor(req);
+                    ret = actor->actor(req);
+
+                    if (ret != 0) {
+                        rpcsvc_check_and_reply_error(ret, NULL, req);
+                    }
+                    req = NULL;
                 }
+            }
         }
-        pthread_mutex_unlock (&svc->rpclock);
-
-        if (already_registered) {
-                ret = 0;
-                goto out;
-        }
-
-        newprog = GF_CALLOC (1, sizeof(*newprog),gf_common_mt_rpcsvc_program_t);
-        if (newprog == NULL) {
-                goto out;
-        }
-
-        memcpy (newprog, program, sizeof (*program));
-
-        INIT_LIST_HEAD (&newprog->program);
-        INIT_LIST_HEAD (&newprog->request_queue);
-        pthread_mutex_init (&newprog->queue_lock, NULL);
-        pthread_cond_init (&newprog->queue_cond, NULL);
 
-        newprog->alive = _gf_true;
+        if (done)
+            break;
+    }
 
-        /* make sure synctask gets priority over ownthread */
-        if (newprog->synctask)
-                newprog->ownthread = _gf_false;
-
-        if (newprog->ownthread) {
-                gf_thread_create (&newprog->thread, NULL,
-                                  rpcsvc_request_handler,
-                                  newprog, "rpcsvcrh");
-        }
+    return NULL;
+}
 
-        pthread_mutex_lock (&svc->rpclock);
+int
+rpcsvc_program_register(rpcsvc_t *svc, rpcsvc_program_t *program,
+                        gf_boolean_t add_to_head)
+{
+    int ret = -1, i = 0;
+    rpcsvc_program_t *newprog = NULL;
+    char already_registered = 0;
+    pthread_mutexattr_t attr[EVENT_MAX_THREADS];
+    pthread_mutexattr_t thr_attr;
+
+    if (!svc) {
+        goto out;
+    }
+
+    if (program->actors == NULL) {
+        goto out;
+    }
+
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(newprog, &svc->programs, program)
         {
-                list_add_tail (&newprog->program, &svc->programs);
+            if ((newprog->prognum == program->prognum) &&
+                (newprog->progver == program->progver)) {
+                already_registered = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
+    if (already_registered) {
         ret = 0;
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "New program registered: %s, Num: %d,"
-                " Ver: %d, Port: %d", newprog->progname, newprog->prognum,
-                newprog->progver, newprog->progport);
+        goto out;
+    }
+
+    newprog = GF_CALLOC(1, sizeof(*newprog), gf_common_mt_rpcsvc_program_t);
+    if (newprog == NULL) {
+        goto out;
+    }
+
+    memcpy(newprog, program, sizeof(*program));
+    newprog->latencies = gf_latency_new(program->numactors);
+    if (!newprog->latencies) {
+        rpcsvc_program_destroy(newprog);
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&newprog->program);
+    pthread_mutexattr_init(&thr_attr);
+    pthread_mutexattr_settype(&thr_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
+
+    for (i = 0; i < EVENT_MAX_THREADS; i++) {
+        pthread_mutexattr_init(&attr[i]);
+        pthread_mutexattr_settype(&attr[i], PTHREAD_MUTEX_ADAPTIVE_NP);
+        INIT_LIST_HEAD(&newprog->request_queue[i].request_queue);
+        pthread_mutex_init(&newprog->request_queue[i].queue_lock, &attr[i]);
+        pthread_cond_init(&newprog->request_queue[i].queue_cond, NULL);
+        newprog->request_queue[i].program = newprog;
+    }
+
+    pthread_mutex_init(&newprog->thr_lock, &thr_attr);
+    pthread_cond_init(&newprog->thr_cond, NULL);
+
+    newprog->alive = _gf_true;
+
+    if (gf_async_ctrl.enabled) {
+        newprog->ownthread = _gf_false;
+        newprog->synctask = _gf_false;
+    }
+
+    /* make sure synctask gets priority over ownthread */
+    if (newprog->synctask)
+        newprog->ownthread = _gf_false;
+
+    if (newprog->ownthread) {
+        struct event_pool *ep = svc->ctx->event_pool;
+        newprog->eventthreadcount = ep->eventthreadcount;
+
+        pthread_key_create(&newprog->req_queue_key, NULL);
+        newprog->thr_queue = 1;
+    }
+
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        if (add_to_head)
+            list_add(&newprog->program, &svc->programs);
+        else
+            list_add_tail(&newprog->program, &svc->programs);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-out:
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program registration failed:"
-                        " %s, Num: %d, Ver: %d, Port: %d", program->progname,
-                        program->prognum, program->progver, program->progport);
-        }
+    ret = 0;
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "New program registered: %s, Num: %d,"
+           " Ver: %d, Port: %d",
+           newprog->progname, newprog->prognum, newprog->progver,
+           newprog->progport);
 
-        return ret;
+out:
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Program registration failed:"
+               " %s, Num: %d, Ver: %d, Port: %d",
+               program->progname, program->prognum, program->progver,
+               program->progport);
+    }
+
+    return ret;
 }
 
 static void
-free_prog_details (gf_dump_rsp *rsp)
+free_prog_details(gf_dump_rsp *rsp)
 {
-        gf_prog_detail *prev = NULL;
-        gf_prog_detail *trav = NULL;
-
-        trav = rsp->prog;
-        while (trav) {
-                prev = trav;
-                trav = trav->next;
-                GF_FREE (prev);
-        }
+    gf_prog_detail *prev = NULL;
+    gf_prog_detail *trav = NULL;
+
+    trav = rsp->prog;
+    while (trav) {
+        prev = trav;
+        trav = trav->next;
+        GF_FREE(prev);
+    }
 }
 
 static int
-build_prog_details (rpcsvc_request_t *req, gf_dump_rsp *rsp)
+build_prog_details(rpcsvc_request_t *req, gf_dump_rsp *rsp)
 {
-        int               ret     = -1;
-        rpcsvc_program_t *program = NULL;
-        gf_prog_detail   *prog    = NULL;
-        gf_prog_detail   *prev    = NULL;
+    int ret = -1;
+    rpcsvc_program_t *program = NULL;
+    gf_prog_detail *prog = NULL;
+    gf_prog_detail *prev = NULL;
 
-        if (!req || !req->trans || !req->svc)
-                goto out;
+    if (!req || !req->trans || !req->svc)
+        goto out;
 
-        pthread_mutex_lock (&req->svc->rpclock);
+    pthread_rwlock_rdlock(&req->svc->rpclock);
+    {
+        list_for_each_entry(program, &req->svc->programs, program)
         {
-                list_for_each_entry (program, &req->svc->programs, program) {
-                        prog = GF_CALLOC (1, sizeof (*prog), 0);
-                        if (!prog)
-                                goto unlock;
-
-                        prog->progname = program->progname;
-                        prog->prognum  = program->prognum;
-                        prog->progver  = program->progver;
-
-                        if (!rsp->prog)
-                                rsp->prog = prog;
-                        if (prev)
-                                prev->next = prog;
-                        prev = prog;
-                }
-                if (prev)
-                        ret = 0;
-        }
+            prog = GF_CALLOC(1, sizeof(*prog), 0);
+            if (!prog)
+                goto unlock;
+
+            prog->progname = program->progname;
+            prog->prognum = program->prognum;
+            prog->progver = program->progver;
+
+            if (!rsp->prog)
+                rsp->prog = prog;
+            if (prev)
+                prev->next = prog;
+            prev = prog;
+        }
+        if (prev)
+            ret = 0;
+    }
 unlock:
-        pthread_mutex_unlock (&req->svc->rpclock);
+    pthread_rwlock_unlock(&req->svc->rpclock);
 out:
-        return ret;
+    return ret;
 }
 
 static int
-rpcsvc_ping (rpcsvc_request_t *req)
+rpcsvc_ping(rpcsvc_request_t *req)
 {
-        char          rsp_buf[8 * 1024] = {0,};
-        gf_common_rsp rsp               = {0,};
-        struct iovec  iov               = {0,};
-        int           ret               = -1;
-        uint32_t      ping_rsp_len      = 0;
-
-        ping_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_common_rsp,
-                                   &rsp);
-
-        iov.iov_base = rsp_buf;
-        iov.iov_len  = ping_rsp_len;
-
-        ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_common_rsp);
-        if (ret < 0) {
-                ret = RPCSVC_ACTOR_ERROR;
-        } else {
-                rsp.op_ret = 0;
-                rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL);
-        }
-
-        return 0;
+    char rsp_buf[8 * 1024] = {
+        0,
+    };
+    gf_common_rsp rsp = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    int ret = -1;
+    uint32_t ping_rsp_len = 0;
+
+    ping_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_common_rsp, &rsp);
+
+    iov.iov_base = rsp_buf;
+    iov.iov_len = ping_rsp_len;
+
+    ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_common_rsp);
+    if (ret < 0) {
+        ret = RPCSVC_ACTOR_ERROR;
+    } else {
+        rsp.op_ret = 0;
+        rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL);
+    }
+
+    return 0;
 }
 
 static int
-rpcsvc_dump (rpcsvc_request_t *req)
+rpcsvc_dump(rpcsvc_request_t *req)
 {
-        char         rsp_buf[8 * 1024] = {0,};
-        gf_dump_rsp  rsp               = {0,};
-        struct iovec iov               = {0,};
-        int          op_errno          = EINVAL;
-        int          ret               = -1;
-        uint32_t     dump_rsp_len      = 0;
-
-        if (!req)
-                goto sendrsp;
-
-        ret = build_prog_details (req, &rsp);
-        if (ret < 0) {
-                op_errno = -ret;
-                goto sendrsp;
-        }
-
-        op_errno = 0;
+    char rsp_buf[8 * 1024] = {
+        0,
+    };
+    gf_dump_rsp rsp = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    int op_errno = EINVAL;
+    int ret = -1;
+    uint32_t dump_rsp_len = 0;
+
+    if (!req)
+        goto sendrsp;
+
+    ret = build_prog_details(req, &rsp);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto sendrsp;
+    }
+
+    op_errno = 0;
 
 sendrsp:
-        rsp.op_errno = gf_errno_to_error (op_errno);
-        rsp.op_ret   = ret;
+    rsp.op_errno = gf_errno_to_error(op_errno);
+    rsp.op_ret = ret;
 
-        dump_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_dump_rsp,
-                                   &rsp);
+    dump_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_dump_rsp, &rsp);
 
-        iov.iov_base = rsp_buf;
-        iov.iov_len  = dump_rsp_len;
+    iov.iov_base = rsp_buf;
+    iov.iov_len = dump_rsp_len;
 
-        ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp);
-        if (ret < 0) {
-                ret = RPCSVC_ACTOR_ERROR;
-        } else {
-                rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL);
-                ret = 0;
-        }
+    ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp);
+    if (ret < 0) {
+        ret = RPCSVC_ACTOR_ERROR;
+    } else {
+        rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL);
+        ret = 0;
+    }
 
-        free_prog_details (&rsp);
+    free_prog_details(&rsp);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_init_options (rpcsvc_t *svc, dict_t *options)
+rpcsvc_init_options(rpcsvc_t *svc, dict_t *options)
 {
-        char            *optstr = NULL;
-        int             ret = -1;
-
-        if ((!svc) || (!options))
-                return -1;
+    char *optstr = NULL;
+    int ret = -1;
 
-        svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR;
+    if ((!svc) || (!options))
+        return -1;
 
-        svc->register_portmap = _gf_true;
-        if (dict_get (options, "rpc.register-with-portmap")) {
-                ret = dict_get_str (options, "rpc.register-with-portmap",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse "
-                                "dict");
-                        goto out;
-                }
+    svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR;
 
-                ret = gf_string2boolean (optstr, &svc->register_portmap);
-                if (ret < 0) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse bool "
-                                "string");
-                        goto out;
-                }
+    svc->register_portmap = _gf_true;
+    if (dict_get(options, "rpc.register-with-portmap")) {
+        ret = dict_get_str(options, "rpc.register-with-portmap", &optstr);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Failed to parse "
+                   "dict");
+            goto out;
         }
 
-        if (!svc->register_portmap)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Portmap registration "
-                        "disabled");
-        ret = 0;
+        ret = gf_string2boolean(optstr, &svc->register_portmap);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Failed to parse bool "
+                   "string");
+            goto out;
+        }
+    }
+
+    if (!svc->register_portmap)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "Portmap registration "
+               "disabled");
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_reconfigure_options (rpcsvc_t *svc, dict_t *options)
+rpcsvc_reconfigure_options(rpcsvc_t *svc, dict_t *options)
 {
-        xlator_t         *xlator    = NULL;
-        xlator_list_t    *volentry  = NULL;
-        char             *srchkey   = NULL;
-        char             *keyval    = NULL;
-        int              ret        = -1;
-
-        if ((!svc) || (!svc->options) || (!options))
-                return (-1);
-
-        /* Fetch the xlator from svc */
-        xlator = svc->xl;
-        if (!xlator)
+    xlator_t *xlator = NULL;
+    xlator_list_t *volentry = NULL;
+    char *srchkey = NULL;
+    char *keyval = NULL;
+    int ret = -1;
+
+    if ((!svc) || (!svc->options) || (!options))
+        return (-1);
+
+    /* Fetch the xlator from svc */
+    xlator = svc->xl;
+    if (!xlator)
+        return (-1);
+
+    /* Reconfigure the volume specific rpc-auth.addr allow part */
+    volentry = xlator->children;
+    while (volentry) {
+        ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.allow",
+                          volentry->xlator->name);
+        if (ret == -1) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+            return (-1);
+        }
+
+        /* key-string: rpc-auth.addr.<volname>.allow
+         *
+         * IMP: Delete the OLD key/value pair from dict.
+         * And set the NEW key/value pair IFF the option is SET
+         * in reconfigured volfile.
+         *
+         * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly,
+         *     build_nfs_graph() sets it as "*" i.e. anonymous.
+         */
+        dict_del(svc->options, srchkey);
+        if (!dict_get_str(options, srchkey, &keyval)) {
+            ret = dict_set_dynstr_with_alloc(svc->options, srchkey, keyval);
+            if (ret < 0) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error");
+                GF_FREE(srchkey);
                 return (-1);
-
-        /* Reconfigure the volume specific rpc-auth.addr allow part */
-        volentry = xlator->children;
-        while (volentry) {
-                ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.allow",
-                                             volentry->xlator->name);
-                if (ret == -1) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                        return (-1);
-                }
-
-                /* key-string: rpc-auth.addr.<volname>.allow
-                 *
-                 * IMP: Delete the OLD key/value pair from dict.
-                 * And set the NEW key/value pair IFF the option is SET
-                 * in reconfigured volfile.
-                 *
-                 * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly,
-                 *     build_nfs_graph() sets it as "*" i.e. anonymous.
-                 */
-                dict_del (svc->options, srchkey);
-                if (!dict_get_str (options, srchkey, &keyval)) {
-                        ret = dict_set_str (svc->options, srchkey, keyval);
-                        if (ret < 0) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "dict_set_str error");
-                                GF_FREE (srchkey);
-                                return (-1);
-                        }
-                }
-
-                GF_FREE (srchkey);
-                volentry = volentry->next;
+            }
         }
 
-        /* Reconfigure the volume specific rpc-auth.addr reject part */
-        volentry = xlator->children;
-        while (volentry) {
-                ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.reject",
-                                             volentry->xlator->name);
-                if (ret == -1) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                        return (-1);
-                }
+        GF_FREE(srchkey);
+        volentry = volentry->next;
+    }
 
-                /* key-string: rpc-auth.addr.<volname>.reject
-                 *
-                 * IMP: Delete the OLD key/value pair from dict.
-                 * And set the NEW key/value pair IFF the option is SET
-                 * in reconfigured volfile.
-                 *
-                 * NB: No default value for reject key.
-                 */
-                dict_del (svc->options, srchkey);
-                if (!dict_get_str (options, srchkey, &keyval)) {
-                        ret = dict_set_str (svc->options, srchkey, keyval);
-                        if (ret < 0) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "dict_set_str error");
-                                GF_FREE (srchkey);
-                                return (-1);
-                        }
-                }
-
-                GF_FREE (srchkey);
-                volentry = volentry->next;
+    /* Reconfigure the volume specific rpc-auth.addr reject part */
+    volentry = xlator->children;
+    while (volentry) {
+        ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.reject",
+                          volentry->xlator->name);
+        if (ret == -1) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+            return (-1);
         }
 
-        ret = rpcsvc_init_options (svc, options);
-        if (ret)
+        /* key-string: rpc-auth.addr.<volname>.reject
+         *
+         * IMP: Delete the OLD key/value pair from dict.
+         * And set the NEW key/value pair IFF the option is SET
+         * in reconfigured volfile.
+         *
+         * NB: No default value for reject key.
+         */
+        dict_del(svc->options, srchkey);
+        if (!dict_get_str(options, srchkey, &keyval)) {
+            ret = dict_set_dynstr_with_alloc(svc->options, srchkey, keyval);
+            if (ret < 0) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error");
+                GF_FREE(srchkey);
                 return (-1);
+            }
+        }
 
-        return rpcsvc_auth_reconf (svc, options);
+        GF_FREE(srchkey);
+        volentry = volentry->next;
+    }
+
+    ret = rpcsvc_init_options(svc, options);
+    if (ret)
+        return (-1);
+
+    return rpcsvc_auth_reconf(svc, options);
 }
 
 int
-rpcsvc_transport_unix_options_build (dict_t **options, char *filepath)
+rpcsvc_transport_unix_options_build(dict_t *dict, char *filepath)
 {
-        dict_t                  *dict = NULL;
-        char                    *fpath = NULL;
-        int                     ret = -1;
-
-        GF_ASSERT (filepath);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    char *fpath = NULL;
+    int ret = -1;
 
-        fpath = gf_strdup (filepath);
-        if (!fpath) {
-                ret = -1;
-                goto out;
-        }
+    GF_ASSERT(filepath);
+    GF_VALIDATE_OR_GOTO("rpcsvc", dict, out);
 
-        ret = dict_set_dynstr (dict, "transport.socket.listen-path", fpath);
-        if (ret)
-                goto out;
+    fpath = gf_strdup(filepath);
+    if (!fpath) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "transport.address-family", "unix");
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(dict, "transport.socket.listen-path", fpath);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "transport.socket.nodelay", "off");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "transport.address-family", "unix");
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "transport.socket.nodelay", "off");
+    if (ret)
+        goto out;
 
-        *options = dict;
+    ret = dict_set_str(dict, "transport-type", "socket");
+    if (ret)
+        goto out;
 out:
-        if (ret) {
-                GF_FREE (fpath);
-                if (dict)
-                        dict_unref (dict);
-        }
-        return ret;
+    if (ret) {
+        GF_FREE(fpath);
+    }
+    return ret;
 }
 
 /*
@@ -2287,42 +2663,42 @@ out:
  * NB: defval or set-value "0" is special which means unlimited/65536.
  */
 int
-rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue)
+rpcsvc_set_outstanding_rpc_limit(rpcsvc_t *svc, dict_t *options, int defvalue)
 {
-        int            ret        = -1; /* FAILURE */
-        int            rpclim     = 0;
-        static char    *rpclimkey = "rpc.outstanding-rpc-limit";
-
-        if ((!svc) || (!options))
-                return (-1);
-
-        if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) ||
-            (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) {
-                return (-1);
-        }
-
-        /* Fetch the rpc.outstanding-rpc-limit from dict. */
-        ret = dict_get_int32 (options, rpclimkey, &rpclim);
-        if (ret < 0) {
-                /* Fall back to default for FAILURE */
-                rpclim = defvalue;
-        }
-
-        /* Round up to multiple-of-8. It must not exceed
-         * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT.
-         */
-        rpclim = ((rpclim + 8 - 1) >> 3) * 8;
-        if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) {
-                rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT;
-        }
-
-        if (svc->outstanding_rpc_limit != rpclim) {
-                svc->outstanding_rpc_limit = rpclim;
-                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                        "Configured %s with value %d", rpclimkey, rpclim);
-        }
-
-        return (0);
+    int ret = -1; /* FAILURE */
+    int rpclim = 0;
+    static char *rpclimkey = "rpc.outstanding-rpc-limit";
+
+    if ((!svc) || (!options))
+        return (-1);
+
+    if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) ||
+        (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) {
+        return (-1);
+    }
+
+    /* Fetch the rpc.outstanding-rpc-limit from dict. */
+    ret = dict_get_int32(options, rpclimkey, &rpclim);
+    if (ret < 0) {
+        /* Fall back to default for FAILURE */
+        rpclim = defvalue;
+    }
+
+    /* Round up to multiple-of-8. It must not exceed
+     * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT.
+     */
+    rpclim = ((rpclim + 8 - 1) >> 3) * 8;
+    if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) {
+        rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT;
+    }
+
+    if (svc->outstanding_rpc_limit != rpclim) {
+        svc->outstanding_rpc_limit = rpclim;
+        gf_log(GF_RPCSVC, GF_LOG_INFO, "Configured %s with value %d", rpclimkey,
+               rpclim);
+    }
+
+    return (0);
 }
 
 /*
@@ -2330,15 +2706,14 @@ rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue)
  * Returns 0 on success, -1 otherwise.
  */
 int
-rpcsvc_set_throttle_on (rpcsvc_t *svc)
+rpcsvc_set_throttle_on(rpcsvc_t *svc)
 {
+    if (!svc)
+        return -1;
 
-        if (!svc)
-                return -1;
-
-        svc->throttle = _gf_true;
+    svc->throttle = _gf_true;
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -2346,15 +2721,14 @@ rpcsvc_set_throttle_on (rpcsvc_t *svc)
  * Returns 0 on success, -1 otherwise.
  */
 int
-rpcsvc_set_throttle_off (rpcsvc_t *svc)
+rpcsvc_set_throttle_off(rpcsvc_t *svc)
 {
+    if (!svc)
+        return -1;
 
-        if (!svc)
-                return -1;
+    svc->throttle = _gf_false;
 
-        svc->throttle = _gf_false;
-
-        return 0;
+    return 0;
 }
 
 /*
@@ -2362,213 +2736,246 @@ rpcsvc_set_throttle_off (rpcsvc_t *svc)
  * Returns value of attribute throttle on success, _gf_false otherwise.
  */
 gf_boolean_t
-rpcsvc_get_throttle (rpcsvc_t *svc)
+rpcsvc_get_throttle(rpcsvc_t *svc)
 {
+    if (!svc)
+        return _gf_false;
 
-        if (!svc)
-                return _gf_false;
-
-        return svc->throttle;
+    return svc->throttle;
 }
 
-/* The global RPC service initializer.
+/* Function call to cleanup resources for svc
  */
-rpcsvc_t *
-rpcsvc_init (xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
-             uint32_t poolcount)
+int
+rpcsvc_destroy(rpcsvc_t *svc)
 {
-        rpcsvc_t          *svc              = NULL;
-        int                ret              = -1;
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
+    rpcsvc_listener_t *listener = NULL;
+    rpcsvc_listener_t *next = NULL;
+    int ret = 0;
 
-        if ((!xl) || (!ctx) || (!options))
-                return NULL;
-
-        svc = GF_CALLOC (1, sizeof (*svc), gf_common_mt_rpcsvc_t);
-        if (!svc)
-                return NULL;
+    if (!svc)
+        return ret;
 
-        pthread_mutex_init (&svc->rpclock, NULL);
-        INIT_LIST_HEAD (&svc->authschemes);
-        INIT_LIST_HEAD (&svc->notify);
-        INIT_LIST_HEAD (&svc->listeners);
-        INIT_LIST_HEAD (&svc->programs);
+    list_for_each_entry_safe(listener, next, &svc->listeners, list)
+    {
+        rpcsvc_listener_destroy(listener);
+    }
 
-        ret = rpcsvc_init_options (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init options");
-                goto free_svc;
-        }
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        list_del_init(&auth->authlist);
+        GF_FREE(auth);
+    }
 
-        if (!poolcount)
-                poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor;
+    rpcsvc_program_unregister(svc, &gluster_dump_prog);
+    if (svc->rxpool) {
+        mem_pool_destroy(svc->rxpool);
+        svc->rxpool = NULL;
+    }
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount);
-        svc->rxpool = mem_pool_new (rpcsvc_request_t, poolcount);
-        /* TODO: leak */
-        if (!svc->rxpool) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed");
-                goto free_svc;
-        }
+    pthread_rwlock_destroy(&svc->rpclock);
+    GF_FREE(svc);
 
-        ret = rpcsvc_auth_init (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init "
-                        "authentication");
-                goto free_svc;
-        }
+    return ret;
+}
 
-        ret = -1;
-        svc->options = options;
-        svc->ctx = ctx;
-        svc->xl = xl;
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited.");
+/* The global RPC service initializer.
+ */
+rpcsvc_t *
+rpcsvc_init(xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
+            uint32_t poolcount)
+{
+    rpcsvc_t *svc = NULL;
+    int ret = -1;
 
-        gluster_dump_prog.options = options;
+    if ((!xl) || (!ctx) || (!options))
+        return NULL;
 
-        ret = rpcsvc_program_register (svc, &gluster_dump_prog);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "failed to register DUMP program");
-                goto free_svc;
-        }
+    svc = GF_CALLOC(1, sizeof(*svc), gf_common_mt_rpcsvc_t);
+    if (!svc)
+        return NULL;
 
-        ret = 0;
+    pthread_rwlock_init(&svc->rpclock, NULL);
+    INIT_LIST_HEAD(&svc->authschemes);
+    INIT_LIST_HEAD(&svc->notify);
+    INIT_LIST_HEAD(&svc->listeners);
+    INIT_LIST_HEAD(&svc->programs);
+
+    ret = rpcsvc_init_options(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init options");
+        goto free_svc;
+    }
+
+    if (!poolcount)
+        poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor;
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount);
+    svc->rxpool = mem_pool_new(rpcsvc_request_t, poolcount);
+    /* TODO: leak */
+    if (!svc->rxpool) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed");
+        goto free_svc;
+    }
+
+    ret = rpcsvc_auth_init(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to init "
+               "authentication");
+        goto free_svc;
+    }
+
+    ret = -1;
+    svc->options = options;
+    svc->ctx = ctx;
+    svc->xl = xl;
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited.");
+
+    gluster_dump_prog.options = options;
+
+    ret = rpcsvc_program_register(svc, &gluster_dump_prog, _gf_false);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to register DUMP program");
+        goto free_svc;
+    }
+
+    ret = 0;
 free_svc:
-        if (ret == -1) {
-                GF_FREE (svc);
-                svc = NULL;
-        }
+    if (ret == -1) {
+        GF_FREE(svc);
+        svc = NULL;
+    }
 
-        return svc;
+    return svc;
 }
 
-
 int
-rpcsvc_transport_peer_check_search (dict_t *options, char *pattern,
-                                    char *ip, char *hostname)
+rpcsvc_transport_peer_check_search(dict_t *options, char *pattern, char *ip,
+                                   char *hostname)
 {
-        int                      ret           = -1;
-        char                    *addrtok       = NULL;
-        char                    *addrstr       = NULL;
-        char                    *dup_addrstr   = NULL;
-        char                    *svptr         = NULL;
+    int ret = -1;
+    char *addrtok = NULL;
+    char *addrstr = NULL;
+    char *dup_addrstr = NULL;
+    char *svptr = NULL;
 
-        if ((!options) || (!ip))
-                return -1;
+    if ((!options) || (!ip))
+        return -1;
 
-        ret = dict_get_str (options, pattern, &addrstr);
-        if (ret < 0) {
-                ret = -1;
-                goto err;
-        }
-
-        if (!addrstr) {
-                ret = -1;
-                goto err;
-        }
+    ret = dict_get_str(options, pattern, &addrstr);
+    if (ret < 0) {
+        ret = -1;
+        goto err;
+    }
 
-        dup_addrstr = gf_strdup (addrstr);
-        addrtok = strtok_r (dup_addrstr, ",", &svptr);
-        while (addrtok) {
+    if (!addrstr) {
+        ret = -1;
+        goto err;
+    }
 
-                /* CASEFOLD not present on Solaris */
+    dup_addrstr = gf_strdup(addrstr);
+    if (dup_addrstr == NULL) {
+        ret = -1;
+        goto err;
+    }
+    addrtok = strtok_r(dup_addrstr, ",", &svptr);
+    while (addrtok) {
+        /* CASEFOLD not present on Solaris */
 #ifdef FNM_CASEFOLD
-                ret = fnmatch (addrtok, ip, FNM_CASEFOLD);
+        ret = fnmatch(addrtok, ip, FNM_CASEFOLD);
 #else
-                ret = fnmatch (addrtok, ip, 0);
+        ret = fnmatch(addrtok, ip, 0);
 #endif
-                if (ret == 0)
-                        goto err;
+        if (ret == 0)
+            goto err;
 
-                /* compare hostnames if applicable */
-                if (hostname) {
+        /* compare hostnames if applicable */
+        if (hostname) {
 #ifdef FNM_CASEFOLD
-                        ret = fnmatch (addrtok, hostname, FNM_CASEFOLD);
+            ret = fnmatch(addrtok, hostname, FNM_CASEFOLD);
 #else
-                        ret = fnmatch (addrtok, hostname, 0);
+            ret = fnmatch(addrtok, hostname, 0);
 #endif
-                        if (ret == 0)
-                                goto err;
-                }
-
-                /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */
-                if (strchr (addrtok, '/')) {
-                        ret = rpcsvc_match_subnet_v4 (addrtok, ip);
-                        if (ret == 0)
-                                goto err;
-                }
+            if (ret == 0)
+                goto err;
+        }
 
-                addrtok = strtok_r (NULL, ",", &svptr);
+        /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */
+        if (strchr(addrtok, '/')) {
+            ret = rpcsvc_match_subnet_v4(addrtok, ip);
+            if (ret == 0)
+                goto err;
         }
 
-        ret = -1;
+        addrtok = strtok_r(NULL, ",", &svptr);
+    }
+
+    ret = -1;
 err:
-        GF_FREE (dup_addrstr);
+    GF_FREE(dup_addrstr);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-rpcsvc_transport_peer_check_allow (dict_t *options, char *volname,
-                                   char *ip, char *hostname)
+rpcsvc_transport_peer_check_allow(dict_t *options, char *volname, char *ip,
+                                  char *hostname)
 {
-        int      ret     = RPCSVC_AUTH_DONTCARE;
-        char    *srchstr = NULL;
+    int ret = RPCSVC_AUTH_DONTCARE;
+    char *srchstr = NULL;
 
-        if ((!options) || (!ip) || (!volname))
-                return ret;
+    if ((!options) || (!ip) || (!volname))
+        return ret;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_DONTCARE;
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_DONTCARE;
+        goto out;
+    }
 
-        ret = rpcsvc_transport_peer_check_search (options, srchstr,
-                                                  ip, hostname);
-        GF_FREE (srchstr);
+    ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname);
+    GF_FREE(srchstr);
 
-        if (ret == 0)
-                ret = RPCSVC_AUTH_ACCEPT;
-        else
-                ret = RPCSVC_AUTH_REJECT;
+    if (ret == 0)
+        ret = RPCSVC_AUTH_ACCEPT;
+    else
+        ret = RPCSVC_AUTH_REJECT;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-rpcsvc_transport_peer_check_reject (dict_t *options, char *volname,
-                                    char *ip, char *hostname)
+rpcsvc_transport_peer_check_reject(dict_t *options, char *volname, char *ip,
+                                   char *hostname)
 {
-        int      ret     = RPCSVC_AUTH_DONTCARE;
-        char    *srchstr = NULL;
+    int ret = RPCSVC_AUTH_DONTCARE;
+    char *srchstr = NULL;
 
-        if ((!options) || (!ip) || (!volname))
-                return ret;
+    if ((!options) || (!ip) || (!volname))
+        return ret;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject",
-                           volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_REJECT;
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_REJECT;
+        goto out;
+    }
 
-        ret = rpcsvc_transport_peer_check_search (options, srchstr,
-                                                  ip, hostname);
-        GF_FREE (srchstr);
+    ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname);
+    GF_FREE(srchstr);
 
-        if (ret == 0)
-                ret = RPCSVC_AUTH_REJECT;
-        else
-                ret = RPCSVC_AUTH_DONTCARE;
+    if (ret == 0)
+        ret = RPCSVC_AUTH_REJECT;
+    else
+        ret = RPCSVC_AUTH_DONTCARE;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Combines rpc auth's allow and reject options.
  * Order of checks is important.
  * First,              REJECT if either rejects.
@@ -2576,188 +2983,188 @@ out:
  * If neither accepts, DONTCARE
  */
 int
-rpcsvc_combine_allow_reject_volume_check (int allow, int reject)
+rpcsvc_combine_allow_reject_volume_check(int allow, int reject)
 {
-        if (allow == RPCSVC_AUTH_REJECT ||
-            reject == RPCSVC_AUTH_REJECT)
-                return RPCSVC_AUTH_REJECT;
+    if (allow == RPCSVC_AUTH_REJECT || reject == RPCSVC_AUTH_REJECT)
+        return RPCSVC_AUTH_REJECT;
 
-        if (allow == RPCSVC_AUTH_ACCEPT ||
-            reject == RPCSVC_AUTH_ACCEPT)
-                return RPCSVC_AUTH_ACCEPT;
+    if (allow == RPCSVC_AUTH_ACCEPT || reject == RPCSVC_AUTH_ACCEPT)
+        return RPCSVC_AUTH_ACCEPT;
 
-        return RPCSVC_AUTH_DONTCARE;
+    return RPCSVC_AUTH_DONTCARE;
 }
 
 int
-rpcsvc_auth_check (rpcsvc_t *svc, char *volname, char *ipaddr)
-{
-        int     ret                            = RPCSVC_AUTH_REJECT;
-        int     accept                         = RPCSVC_AUTH_REJECT;
-        int     reject                         = RPCSVC_AUTH_REJECT;
-        char   *hostname                       = NULL;
-        char   *allow_str                      = NULL;
-        char   *reject_str                     = NULL;
-        char   *srchstr                        = NULL;
-        dict_t *options                        = NULL;
-
-        if (!svc || !volname || !ipaddr)
-                return ret;
-
-        /* Fetch the options from svc struct and validate */
-        options = svc->options;
-        if (!options)
-                return ret;
-
-        /* Accept if its the default case: Allow all, Reject none
-         * The default volfile always contains a 'allow *' rule
-         * for each volume. If allow rule is missing (which implies
-         * there is some bad volfile generating code doing this), we
-         * assume no one is allowed mounts, and thus, we reject mounts.
-         */
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                return RPCSVC_AUTH_REJECT;
-        }
-
-        ret = dict_get_str (options, srchstr, &allow_str);
-        GF_FREE (srchstr);
-        if (ret < 0)
-                return RPCSVC_AUTH_REJECT;
-
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                return RPCSVC_AUTH_REJECT;
-        }
-
-        ret = dict_get_str (options, srchstr, &reject_str);
-        GF_FREE (srchstr);
+rpcsvc_auth_check(rpcsvc_t *svc, char *volname, char *ipaddr)
+{
+    int ret = RPCSVC_AUTH_REJECT;
+    int accept = RPCSVC_AUTH_REJECT;
+    int reject = RPCSVC_AUTH_REJECT;
+    char *hostname = NULL;
+    char *allow_str = NULL;
+    char *reject_str = NULL;
+    char *srchstr = NULL;
+    dict_t *options = NULL;
+
+    if (!svc || !volname || !ipaddr)
+        return ret;
 
-        /*
-         * If "reject_str" is being set as '*' (anonymous), then NFS-server
-         * would reject everything. If the "reject_str" is not set and
-         * "allow_str" is set as '*' (anonymous), then NFS-server would
-         * accept mount requests from all clients.
-         */
-        if (reject_str != NULL) {
-                if (!strcmp ("*", reject_str))
-                        return RPCSVC_AUTH_REJECT;
-        } else {
-                if (!strcmp ("*", allow_str))
-                        return RPCSVC_AUTH_ACCEPT;
-        }
+    /* Fetch the options from svc struct and validate */
+    options = svc->options;
+    if (!options)
+        return ret;
 
-        /* addr-namelookup check */
-        if (svc->addr_namelookup == _gf_true) {
-                ret = gf_get_hostname_from_ip (ipaddr, &hostname);
-                if (ret) {
-                        if (hostname)
-                                GF_FREE (hostname);
-                        /* failed to get hostname, but hostname auth
-                         * is enabled, so authentication will not be
-                         * 100% correct. reject mounts
-                         */
-                        return RPCSVC_AUTH_REJECT;
-                }
+    /* Accept if its the default case: Allow all, Reject none
+     * The default volfile always contains a 'allow *' rule
+     * for each volume. If allow rule is missing (which implies
+     * there is some bad volfile generating code doing this), we
+     * assume no one is allowed mounts, and thus, we reject mounts.
+     */
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        return RPCSVC_AUTH_REJECT;
+    }
+
+    ret = dict_get_str(options, srchstr, &allow_str);
+    GF_FREE(srchstr);
+    if (ret < 0)
+        return RPCSVC_AUTH_REJECT;
+
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        return RPCSVC_AUTH_REJECT;
+    }
+
+    ret = dict_get_str(options, srchstr, &reject_str);
+    GF_FREE(srchstr);
+
+    /*
+     * If "reject_str" is being set as '*' (anonymous), then NFS-server
+     * would reject everything. If the "reject_str" is not set and
+     * "allow_str" is set as '*' (anonymous), then NFS-server would
+     * accept mount requests from all clients.
+     */
+    if (reject_str != NULL) {
+        if (!strcmp("*", reject_str))
+            return RPCSVC_AUTH_REJECT;
+    } else {
+        if (!strcmp("*", allow_str))
+            return RPCSVC_AUTH_ACCEPT;
+    }
+
+    /* addr-namelookup check */
+    if (svc->addr_namelookup == _gf_true) {
+        ret = gf_get_hostname_from_ip(ipaddr, &hostname);
+        if (ret) {
+            if (hostname)
+                GF_FREE(hostname);
+            /* failed to get hostname, but hostname auth
+             * is enabled, so authentication will not be
+             * 100% correct. reject mounts
+             */
+            return RPCSVC_AUTH_REJECT;
         }
+    }
 
-        accept = rpcsvc_transport_peer_check_allow (options, volname,
-                                                    ipaddr, hostname);
+    accept = rpcsvc_transport_peer_check_allow(options, volname, ipaddr,
+                                               hostname);
 
-        reject = rpcsvc_transport_peer_check_reject (options, volname,
-                                                     ipaddr, hostname);
+    reject = rpcsvc_transport_peer_check_reject(options, volname, ipaddr,
+                                                hostname);
 
-        if (hostname)
-                GF_FREE (hostname);
-        return rpcsvc_combine_allow_reject_volume_check (accept, reject);
+    if (hostname)
+        GF_FREE(hostname);
+    return rpcsvc_combine_allow_reject_volume_check(accept, reject);
 }
 
 int
-rpcsvc_transport_privport_check (rpcsvc_t *svc, char *volname, uint16_t port)
+rpcsvc_transport_privport_check(rpcsvc_t *svc, char *volname, uint16_t port)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        char                    *srchstr = NULL;
-        char                    *valstr = NULL;
-        gf_boolean_t            insecure = _gf_false;
-
-        if ((!svc) || (!volname))
-                return ret;
+    int ret = RPCSVC_AUTH_REJECT;
+    char *srchstr = NULL;
+    char *valstr = NULL;
+    gf_boolean_t insecure = _gf_false;
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port);
-        /* If the port is already a privileged one, dont bother with checking
-         * options.
-         */
-        if (port <= 1024) {
-                ret = RPCSVC_AUTH_ACCEPT;
-                goto err;
-        }
-
-        /* Disabled by default */
-        ret = gf_asprintf (&srchstr, "rpc-auth.ports.%s.insecure", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        ret = dict_get_str (svc->options, srchstr, &valstr);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to"
-                        " read rpc-auth.ports.insecure value");
-                goto err;
-        }
-
-        ret = gf_string2boolean (valstr, &insecure);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to"
-                        " convert rpc-auth.ports.insecure value");
-                goto err;
-        }
-
-        ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT;
+    if ((!svc) || (!volname))
+        return ret;
 
-        if (ret == RPCSVC_AUTH_ACCEPT)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed");
-        else
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port not"
-                        " allowed");
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port);
+    /* If the port is already a privileged one, don't bother with checking
+     * options.
+     */
+    if (port <= 1024) {
+        ret = RPCSVC_AUTH_ACCEPT;
+        goto err;
+    }
+
+    /* Disabled by default */
+    ret = gf_asprintf(&srchstr, "rpc-auth.ports.%s.insecure", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    ret = dict_get_str(svc->options, srchstr, &valstr);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to"
+               " read rpc-auth.ports.insecure value");
+        goto err;
+    }
+
+    ret = gf_string2boolean(valstr, &insecure);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to"
+               " convert rpc-auth.ports.insecure value");
+        goto err;
+    }
+
+    ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT;
+
+    if (ret == RPCSVC_AUTH_ACCEPT)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed");
+    else
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "Unprivileged port not"
+               " allowed");
 
 err:
-        if (srchstr)
-                GF_FREE (srchstr);
+    if (srchstr)
+        GF_FREE(srchstr);
 
-        return ret;
+    return ret;
 }
 
-
 char *
-rpcsvc_volume_allowed (dict_t *options, char *volname)
+rpcsvc_volume_allowed(dict_t *options, char *volname)
 {
-        char    globalrule[] = "rpc-auth.addr.allow";
-        char    *srchstr = NULL;
-        char    *addrstr = NULL;
-        int     ret = -1;
+    char globalrule[] = "rpc-auth.addr.allow";
+    char *srchstr = NULL;
+    char *addrstr = NULL;
+    int ret = -1;
 
-        if ((!options) || (!volname))
-                return NULL;
+    if ((!options) || (!volname))
+        return NULL;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        goto out;
+    }
 
-        if (!dict_get (options, srchstr))
-                ret = dict_get_str (options, globalrule, &addrstr);
-        else
-                ret = dict_get_str (options, srchstr, &addrstr);
+    if (!dict_get(options, srchstr))
+        ret = dict_get_str(options, globalrule, &addrstr);
+    else
+        ret = dict_get_str(options, srchstr, &addrstr);
 
 out:
-        GF_FREE (srchstr);
+    GF_FREE(srchstr);
 
-        return addrstr;
+    return addrstr;
 }
 
 /*
@@ -2771,63 +3178,118 @@ out:
  *     as it's already being done at the time of CLI SET.
  */
 static int
-rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr)
-{
-        char                 *slash     = NULL;
-        char                 *netaddr   = NULL;
-        int                   ret       = -1;
-        uint32_t              prefixlen = 0;
-        uint32_t              shift     = 0;
-        struct sockaddr_in    sin1      = {0, };
-        struct sockaddr_in    sin2      = {0, };
-        struct sockaddr_in    mask      = {0, };
-
-        /* Copy the input */
-        netaddr = gf_strdup (addrtok);
-        if (netaddr == NULL) /* ENOMEM */
-                goto out;
-
-        /* Find the network socket addr of target */
-        if (inet_pton (AF_INET, ipaddr, &sin1.sin_addr) == 0)
-                goto out;
-
-        /* Find the network socket addr of subnet pattern */
-        slash = strchr (netaddr, '/');
+rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr)
+{
+    char *slash = NULL;
+    char *netaddr = NULL;
+    int ret = -1;
+    uint32_t prefixlen = 0;
+    uint32_t shift = 0;
+    struct sockaddr_in sin1 = {
+        0,
+    };
+    struct sockaddr_in sin2 = {
+        0,
+    };
+    struct sockaddr_in mask = {
+        0,
+    };
+
+    /* Copy the input */
+    netaddr = gf_strdup(addrtok);
+    if (netaddr == NULL) /* ENOMEM */
+        goto out;
+
+    /* Find the network socket addr of target */
+    if (inet_pton(AF_INET, ipaddr, &sin1.sin_addr) == 0)
+        goto out;
+
+    slash = strchr(netaddr, '/');
+    if (slash) {
         *slash = '\0';
-        if (inet_pton (AF_INET, netaddr, &sin2.sin_addr) == 0)
-                goto out;
-
         /*
          * Find the IPv4 network mask in network byte order.
-         * IMP: String slash+1 is already validated, it cant have value
+         * IMP: String slash+1 is already validated, it can't have value
          * more than IPv4_ADDR_SIZE (32).
          */
-        prefixlen = (uint32_t) atoi (slash + 1);
-        shift = IPv4_ADDR_SIZE - prefixlen;
-        mask.sin_addr.s_addr = htonl ((uint32_t)~0 << shift);
-
-        if (mask_match (sin1.sin_addr.s_addr,
-                        sin2.sin_addr.s_addr,
-                        mask.sin_addr.s_addr)) {
-                ret = 0; /* SUCCESS */
-        }
+        prefixlen = (uint32_t)atoi(slash + 1);
+        if (prefixlen > 31)
+            goto out;
+    } else {
+        /* if there is no '/', then this function wouldn't be called */
+        goto out;
+    }
+
+    /* Need to do this after removing '/', as inet_pton() take IP address as
+     * second argument. Once we get sin2, then comparison is oranges to orange
+     */
+    if (inet_pton(AF_INET, netaddr, &sin2.sin_addr) == 0)
+        goto out;
+
+    shift = IPv4_ADDR_SIZE - prefixlen;
+    mask.sin_addr.s_addr = htonl((uint32_t)~0 << shift);
+
+    if (mask_match(sin1.sin_addr.s_addr, sin2.sin_addr.s_addr,
+                   mask.sin_addr.s_addr)) {
+        ret = 0; /* SUCCESS */
+    }
 out:
-        GF_FREE (netaddr);
-        return ret;
+    GF_FREE(netaddr);
+    return ret;
 }
 
+void
+rpcsvc_program_dump(rpcsvc_program_t *prog)
+{
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i;
 
-rpcsvc_actor_t gluster_dump_actors[GF_DUMP_MAXVALUE] = {
-        [GF_DUMP_NULL]      = {"NULL",     GF_DUMP_NULL,     NULL,        NULL, 0, DRC_NA},
-        [GF_DUMP_DUMP]      = {"DUMP",     GF_DUMP_DUMP,     rpcsvc_dump, NULL, 0, DRC_NA},
-        [GF_DUMP_PING]      = {"PING",     GF_DUMP_PING,     rpcsvc_ping, NULL, 0, DRC_NA},
-};
+    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s", prog->progname);
+    gf_proc_dump_add_section("%s", key_prefix);
+
+    gf_proc_dump_build_key(key, key_prefix, "program-number");
+    gf_proc_dump_write(key, "%d", prog->prognum);
+
+    gf_proc_dump_build_key(key, key_prefix, "program-version");
+    gf_proc_dump_write(key, "%d", prog->progver);
 
+    strncat(key_prefix, ".latency",
+            sizeof(key_prefix) - strlen(key_prefix) - 1);
+
+    for (i = 0; i < prog->numactors; i++) {
+        gf_proc_dump_build_key(key, key_prefix, "%s", prog->actors[i].procname);
+        gf_latency_statedump_and_reset(key, &prog->latencies[i]);
+    }
+}
+
+void
+rpcsvc_statedump(rpcsvc_t *svc)
+{
+    rpcsvc_program_t *prog = NULL;
+    int ret = 0;
+    ret = pthread_rwlock_tryrdlock(&svc->rpclock);
+    if (ret)
+        return;
+    {
+        list_for_each_entry(prog, &svc->programs, program)
+        {
+            rpcsvc_program_dump(prog);
+        }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+}
+
+static rpcsvc_actor_t gluster_dump_actors[GF_DUMP_MAXVALUE] = {
+    [GF_DUMP_NULL] = {"NULL", NULL, NULL, GF_DUMP_NULL, DRC_NA, 0},
+    [GF_DUMP_DUMP] = {"DUMP", rpcsvc_dump, NULL, GF_DUMP_DUMP, DRC_NA, 0},
+    [GF_DUMP_PING] = {"PING", rpcsvc_ping, NULL, GF_DUMP_PING, DRC_NA, 0},
+};
 
-struct rpcsvc_program gluster_dump_prog = {
-        .progname  = "GF-DUMP",
-        .prognum   = GLUSTER_DUMP_PROGRAM,
-        .progver   = GLUSTER_DUMP_VERSION,
-        .actors    = gluster_dump_actors,
-        .numactors = GF_DUMP_MAXVALUE,
+static struct rpcsvc_program gluster_dump_prog = {
+    .progname = "GF-DUMP",
+    .prognum = GLUSTER_DUMP_PROGRAM,
+    .progver = GLUSTER_DUMP_VERSION,
+    .actors = gluster_dump_actors,
+    .numactors = GF_DUMP_MAXVALUE,
 };
diff --git a/rpc/rpc-lib/src/rpcsvc.h b/rpc/rpc-lib/src/rpcsvc.h
index 73507b6538b..7b3030926c8 100644
--- a/rpc/rpc-lib/src/rpcsvc.h
+++ b/rpc/rpc-lib/src/rpcsvc.h
@@ -11,51 +11,57 @@
 #ifndef _RPCSVC_H
 #define _RPCSVC_H
 
-#include "event.h"
+#include <glusterfs/gf-event.h>
 #include "rpc-transport.h"
-#include "logging.h"
-#include "dict.h"
-#include "mem-pool.h"
-#include "list.h"
-#include "iobuf.h"
+#include <glusterfs/dict.h>
 #include "xdr-rpc.h"
-#include "glusterfs.h"
-#include "xlator.h"
 #include "rpcsvc-common.h"
 
 #include <pthread.h>
 #include <sys/uio.h>
 #include <inttypes.h>
 #include <rpc/rpc_msg.h>
-#include "compat.h"
+#include <glusterfs/compat.h>
+#include <glusterfs/client_t.h>
 
 #ifndef MAX_IOVEC
 #define MAX_IOVEC 16
 #endif
 
-#define RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT 64 /* Default for protocol/server */
+/* TODO: we should store prognums at a centralized location to avoid conflict
+         or use a robust random number generator to avoid conflicts
+*/
+
+#define RPCSVC_INFRA_PROGRAM 7712846 /* random number */
+
+typedef enum {
+    RPCSVC_PROC_EVENT_THREAD_DEATH = 0,
+} rpcsvc_infra_procnum_t;
+
+#define RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT                                   \
+    64 /* Default for protocol/server */
 #define RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT 16 /* Default for nfs/server */
 #define RPCSVC_MAX_OUTSTANDING_RPC_LIMIT 65536
 #define RPCSVC_MIN_OUTSTANDING_RPC_LIMIT 0 /* No limit i.e. Unlimited */
 
-#define GF_RPCSVC       "rpc-service"
+#define GF_RPCSVC "rpc-service"
 #define RPCSVC_THREAD_STACK_SIZE ((size_t)(1024 * GF_UNIT_KB))
 
-#define RPCSVC_FRAGHDR_SIZE  4       /* 4-byte RPC fragment header size */
-#define RPCSVC_DEFAULT_LISTEN_PORT      GF_DEFAULT_BASE_PORT
-#define RPCSVC_DEFAULT_MEMFACTOR        8
-#define RPCSVC_EVENTPOOL_SIZE_MULT      1024
-#define RPCSVC_POOLCOUNT_MULT           64
-#define RPCSVC_CONN_READ        (128 * GF_UNIT_KB)
-#define RPCSVC_PAGE_SIZE        (128 * GF_UNIT_KB)
-#define RPC_ROOT_UID             0
-#define RPC_ROOT_GID             0
-#define RPC_NOBODY_UID           65534
-#define RPC_NOBODY_GID           65534
+#define RPCSVC_FRAGHDR_SIZE 4 /* 4-byte RPC fragment header size */
+#define RPCSVC_DEFAULT_LISTEN_PORT GF_DEFAULT_BASE_PORT
+#define RPCSVC_DEFAULT_MEMFACTOR 8
+#define RPCSVC_EVENTPOOL_SIZE_MULT 1024
+#define RPCSVC_POOLCOUNT_MULT 64
+#define RPCSVC_CONN_READ (128 * GF_UNIT_KB)
+#define RPCSVC_PAGE_SIZE (128 * GF_UNIT_KB)
+#define RPC_ROOT_UID 0
+#define RPC_ROOT_GID 0
+#define RPC_NOBODY_UID 65534
+#define RPC_NOBODY_GID 65534
 
 /* RPC Record States */
-#define RPCSVC_READ_FRAGHDR     1
-#define RPCSVC_READ_FRAG        2
+#define RPCSVC_READ_FRAGHDR 1
+#define RPCSVC_READ_FRAG 2
 /* The size in bytes, if crossed by a fragment will be handed over to the
  * vectored actor so that it can allocate its buffers the way it wants.
  * In our RPC layer, we assume that vectored RPC requests/records are never
@@ -63,21 +69,28 @@
  * whether the record should be handled in RPC layer completely or handed to
  * the vectored handler.
  */
-#define RPCSVC_VECTORED_FRAGSZ  4096
-#define RPCSVC_VECTOR_READCRED          1003
-#define RPCSVC_VECTOR_READVERFSZ        1004
-#define RPCSVC_VECTOR_READVERF          1005
-#define RPCSVC_VECTOR_IGNORE            1006
-#define RPCSVC_VECTOR_READVEC           1007
-#define RPCSVC_VECTOR_READPROCHDR       1008
-
-#define rpcsvc_record_vectored_baremsg(rs) (((rs)->state == RPCSVC_READ_FRAG) && (rs)->vecstate == 0)
-#define rpcsvc_record_vectored_cred(rs) ((rs)->vecstate == RPCSVC_VECTOR_READCRED)
-#define rpcsvc_record_vectored_verfsz(rs) ((rs)->vecstate == RPCSVC_VECTOR_READVERFSZ)
-#define rpcsvc_record_vectored_verfread(rs) ((rs)->vecstate == RPCSVC_VECTOR_READVERF)
-#define rpcsvc_record_vectored_ignore(rs) ((rs)->vecstate == RPCSVC_VECTOR_IGNORE)
-#define rpcsvc_record_vectored_readvec(rs) ((rs)->vecstate == RPCSVC_VECTOR_READVEC)
-#define rpcsvc_record_vectored_readprochdr(rs) ((rs)->vecstate == RPCSVC_VECTOR_READPROCHDR)
+#define RPCSVC_VECTORED_FRAGSZ 4096
+#define RPCSVC_VECTOR_READCRED 1003
+#define RPCSVC_VECTOR_READVERFSZ 1004
+#define RPCSVC_VECTOR_READVERF 1005
+#define RPCSVC_VECTOR_IGNORE 1006
+#define RPCSVC_VECTOR_READVEC 1007
+#define RPCSVC_VECTOR_READPROCHDR 1008
+
+#define rpcsvc_record_vectored_baremsg(rs)                                     \
+    (((rs)->state == RPCSVC_READ_FRAG) && (rs)->vecstate == 0)
+#define rpcsvc_record_vectored_cred(rs)                                        \
+    ((rs)->vecstate == RPCSVC_VECTOR_READCRED)
+#define rpcsvc_record_vectored_verfsz(rs)                                      \
+    ((rs)->vecstate == RPCSVC_VECTOR_READVERFSZ)
+#define rpcsvc_record_vectored_verfread(rs)                                    \
+    ((rs)->vecstate == RPCSVC_VECTOR_READVERF)
+#define rpcsvc_record_vectored_ignore(rs)                                      \
+    ((rs)->vecstate == RPCSVC_VECTOR_IGNORE)
+#define rpcsvc_record_vectored_readvec(rs)                                     \
+    ((rs)->vecstate == RPCSVC_VECTOR_READVEC)
+#define rpcsvc_record_vectored_readprochdr(rs)                                 \
+    ((rs)->vecstate == RPCSVC_VECTOR_READPROCHDR)
 #define rpcsvc_record_vectored(rs) ((rs)->fragsize > RPCSVC_VECTORED_FRAGSZ)
 /* Includes bytes up to and including the credential length field. The credlen
  * will be followed by @credlen bytes of credential data which will have to be
@@ -85,60 +98,52 @@
  * verifier which will also have to be read separately including the 8 bytes of
  * verf flavour and verflen.
  */
-#define RPCSVC_BARERPC_MSGSZ    32
-#define rpcsvc_record_readfraghdr(rs)   ((rs)->state == RPCSVC_READ_FRAGHDR)
-#define rpcsvc_record_readfrag(rs)      ((rs)->state == RPCSVC_READ_FRAG)
+#define RPCSVC_BARERPC_MSGSZ 32
+#define rpcsvc_record_readfraghdr(rs) ((rs)->state == RPCSVC_READ_FRAGHDR)
+#define rpcsvc_record_readfrag(rs) ((rs)->state == RPCSVC_READ_FRAG)
 
-#define RPCSVC_LOWVERS  2
+#define RPCSVC_LOWVERS 2
 #define RPCSVC_HIGHVERS 2
 
-
 #if 0
 #error "defined in /usr/include/rpc/auth.h"
 
-#define AUTH_NONE	0		/* no authentication */
-#define	AUTH_NULL	0		/* backward compatibility */
-#define	AUTH_SYS	1		/* unix style (uid, gids) */
-#define	AUTH_UNIX	AUTH_SYS
-#define	AUTH_SHORT	2		/* short hand unix style */
-#define AUTH_DES	3		/* des style (encrypted timestamps) */
-#define AUTH_DH		AUTH_DES	/* Diffie-Hellman (this is DES) */
-#define AUTH_KERB       4               /* kerberos style */
-#endif /* */
+#define AUTH_NONE 0 /* no authentication */
+#define AUTH_NULL 0 /* backward compatibility */
+#define AUTH_SYS 1  /* unix style (uid, gids) */
+#define AUTH_UNIX AUTH_SYS
+#define AUTH_SHORT 2     /* short hand unix style */
+#define AUTH_DES 3       /* des style (encrypted timestamps) */
+#define AUTH_DH AUTH_DES /* Diffie-Hellman (this is DES) */
+#define AUTH_KERB 4      /* kerberos style */
+#endif                   /* */
 
 typedef struct rpcsvc_program rpcsvc_program_t;
 
 struct rpcsvc_notify_wrapper {
-        struct list_head  list;
-        void             *data;
-        rpcsvc_notify_t   notify;
+    struct list_head list;
+    void *data;
+    rpcsvc_notify_t notify;
 };
 typedef struct rpcsvc_notify_wrapper rpcsvc_notify_wrapper_t;
 
-
 typedef struct rpcsvc_request rpcsvc_request_t;
 
 typedef struct {
-        rpc_transport_t         *trans;
-        rpcsvc_t                *svc;
-        /* FIXME: remove address from this structure. Instead use get_myaddr
-         * interface implemented by individual transports.
-         */
-        struct sockaddr_storage  sa;
-        struct list_head         list;
+    rpc_transport_t *trans;
+    rpcsvc_t *svc;
+    /* FIXME: remove address from this structure. Instead use get_myaddr
+     * interface implemented by individual transports.
+     */
+    struct sockaddr_storage sa;
+    struct list_head list;
 } rpcsvc_listener_t;
 
 struct rpcsvc_config {
-        int    max_block_size;
+    int max_block_size;
 };
 
-typedef struct rpcsvc_auth_data {
-        int             flavour;
-        int             datalen;
-        char            authdata[GF_MAX_AUTH_BYTES];
-} rpcsvc_auth_data_t;
-
-#define rpcsvc_auth_flavour(au)    ((au).flavour)
+#define rpcsvc_auth_flavour(au) ((au).flavour)
 
 typedef struct drc_client drc_client_t;
 typedef struct drc_cached_op drc_cached_op_t;
@@ -148,153 +153,177 @@ typedef struct drc_cached_op drc_cached_op_t;
  * transmitted.
  * */
 struct rpcsvc_request {
-        /* connection over which this request came. */
-        rpc_transport_t       *trans;
-
-        rpcsvc_t              *svc;
-
-        rpcsvc_program_t      *prog;
-
-        /* The identifier for the call from client.
-         * Needed to pair the reply with the call.
-         */
-        uint32_t                xid;
-
-        int                     prognum;
-
-        int                     progver;
-
-        int                     procnum;
-
-        int                     type;
-
-        /* Uid and gid filled by the rpc-auth module during the authentication
-         * phase.
-         */
-        uid_t                   uid;
-        gid_t                   gid;
-        pid_t                   pid;
-
-        gf_lkowner_t            lk_owner;
-        uint64_t                gfs_id;
-
-        /* Might want to move this to AUTH_UNIX specific state since this array
-         * is not available for every authentication scheme.
-         */
-        gid_t                   *auxgids;
-        gid_t                   auxgidsmall[SMALL_GROUP_COUNT];
-        gid_t                   *auxgidlarge;
-        int                     auxgidcount;
-
-
-        /* The RPC message payload, contains the data required
-         * by the program actors. This is the buffer that will need to
-         * be de-xdred by the actor.
-         */
-        struct iovec            msg[MAX_IOVEC];
-        int                     count;
-
-        struct iobref          *iobref;
-
-        /* Status of the RPC call, whether it was accepted or denied. */
-        int                     rpc_status;
-
-        /* In case, the call was denied, the RPC error is stored here
-         * till the reply is sent.
-         */
-        int                     rpc_err;
-
-        /* In case the failure happened because of an authentication problem
-         * , this value needs to be assigned the correct auth error number.
-         */
-        int                     auth_err;
-
-        /* There can be cases of RPC requests where the reply needs to
-         * be built from multiple sources. E.g. where even the NFS reply
-         * can contain a payload, as in the NFSv3 read reply. Here the RPC header
-         * ,NFS header and the read data are brought together separately from
-         * different buffers, so we need to stage the buffers temporarily here
-         * before all of them get added to the connection's transmission list.
-         */
-        struct list_head        txlist;
+    /* connection over which this request came. */
+    rpc_transport_t *trans;
 
-        /* While the reply record is being built, this variable keeps track
-         * of how many bytes have been added to the record.
-         */
-        size_t                  payloadsize;
+    rpcsvc_t *svc;
+
+    rpcsvc_program_t *prog;
 
-        /* The credentials extracted from the rpc request */
-        rpcsvc_auth_data_t      cred;
+    int prognum;
+
+    int progver;
 
-        /* The verified extracted from the rpc request. In request side
-         * processing this contains the verifier sent by the client, on reply
-         * side processing, it is filled with the verified that will be
-         * sent to the client.
-         */
-        rpcsvc_auth_data_t      verf;
-
-	/* Execute this request's actor function in ownthread of program?*/
-	gf_boolean_t            ownthread;
-
-        gf_boolean_t            synctask;
-        /* Container for a RPC program wanting to store a temp
-         * request-specific item.
-         */
-        void                    *private;
-
-        /* Container for transport to store request-specific item */
-        void                    *trans_private;
-
-        /* pointer to cached reply for use in DRC */
-        drc_cached_op_t         *reply;
-
-        /* request queue in rpcsvc */
-        struct list_head         request_list;
+    int procnum;
+
+    int type;
+
+    /* Uid and gid filled by the rpc-auth module during the authentication
+     * phase.
+     */
+    uid_t uid;
+    gid_t gid;
+    pid_t pid;
+
+    gf_lkowner_t lk_owner;
+    uint64_t gfs_id;
+
+    /* Might want to move this to AUTH_UNIX specific state since this array
+     * is not available for every authentication scheme.
+     */
+    gid_t *auxgids;
+    gid_t auxgidsmall[SMALL_GROUP_COUNT];
+    gid_t *auxgidlarge;
+    int auxgidcount;
+
+    /* The RPC message payload, contains the data required
+     * by the program actors. This is the buffer that will need to
+     * be de-xdred by the actor.
+     */
+    int count;
+    struct iovec msg[MAX_IOVEC];
+
+    struct iobref *iobref;
+
+    /* There can be cases of RPC requests where the reply needs to
+     * be built from multiple sources. E.g. where even the NFS reply
+     * can contain a payload, as in the NFSv3 read reply. Here the RPC header
+     * ,NFS header and the read data are brought together separately from
+     * different buffers, so we need to stage the buffers temporarily here
+     * before all of them get added to the connection's transmission list.
+     */
+    struct list_head txlist;
+
+    /* While the reply record is being built, this variable keeps track
+     * of how many bytes have been added to the record.
+     */
+    size_t payloadsize;
+
+    /* The credentials extracted from the rpc request */
+    client_auth_data_t cred;
+
+    /* The verified extracted from the rpc request. In request side
+     * processing this contains the verifier sent by the client, on reply
+     * side processing, it is filled with the verified that will be
+     * sent to the client.
+     */
+    client_auth_data_t verf;
+    /* Container for a RPC program wanting to store a temp
+     * request-specific item.
+     */
+    void *private;
+
+    /* Container for transport to store request-specific item */
+    void *trans_private;
+
+    /* pointer to cached reply for use in DRC */
+    drc_cached_op_t *reply;
+
+    /* request queue in rpcsvc */
+    struct list_head request_list;
+
+    /* Status of the RPC call, whether it was accepted or denied. */
+    int rpc_status;
+
+    /* In case, the call was denied, the RPC error is stored here
+     * till the reply is sent.
+     */
+    int rpc_err;
+
+    /* In case the failure happened because of an authentication problem
+     * , this value needs to be assigned the correct auth error number.
+     */
+    int auth_err;
+
+    /* Things passed to rpc layer from client */
+
+    /* @flags: Can be used for binary data passed in xdata to be
+       passed here instead */
+    unsigned int flags;
+
+    /* ctime: origin of time on the client side, ideally this is
+       the one we should consider for time */
+    struct timespec ctime;
+
+    /* The identifier for the call from client.
+     * Needed to pair the reply with the call.
+     */
+    uint32_t xid;
+
+    /* Execute this request's actor function in ownthread of program?*/
+    gf_boolean_t ownthread;
+
+    gf_boolean_t synctask;
+    struct timespec begin; /*req handling start time*/
+    struct timespec end;   /*req handling end time*/
 };
 
 #define rpcsvc_request_program(req) ((rpcsvc_program_t *)((req)->prog))
 #define rpcsvc_request_procnum(req) (((req)->procnum))
-#define rpcsvc_request_program_private(req) (((rpcsvc_program_t *)((req)->prog))->private)
-#define rpcsvc_request_accepted(req)    ((req)->rpc_status == MSG_ACCEPTED)
+#define rpcsvc_request_program_private(req)                                    \
+    (((rpcsvc_program_t *)((req)->prog))->private)
+#define rpcsvc_request_accepted(req) ((req)->rpc_status == MSG_ACCEPTED)
 #define rpcsvc_request_accepted_success(req) ((req)->rpc_err == SUCCESS)
 #define rpcsvc_request_prog_minauth(req) (rpcsvc_request_program(req)->min_auth)
 #define rpcsvc_request_cred_flavour(req) (rpcsvc_auth_flavour(req->cred))
 #define rpcsvc_request_verf_flavour(req) (rpcsvc_auth_flavour(req->verf))
-#define rpcsvc_request_service(req)      ((req)->svc)
-#define rpcsvc_request_uid(req)         ((req)->uid)
-#define rpcsvc_request_gid(req)         ((req)->gid)
-#define rpcsvc_request_private(req)     ((req)->private)
-#define rpcsvc_request_xid(req)         ((req)->xid)
-#define rpcsvc_request_set_private(req,prv)  (req)->private = (void *)(prv)
-#define rpcsvc_request_iobref_ref(req)  (iobref_ref ((req)->iobref))
-#define rpcsvc_request_record_ref(req)  (iobuf_ref ((req)->recordiob))
-#define rpcsvc_request_record_unref(req) (iobuf_unref ((req)->recordiob))
-#define rpcsvc_request_record_iob(req)   ((req)->recordiob)
-#define rpcsvc_request_set_vecstate(req, state)  ((req)->vecstate = state)
+#define rpcsvc_request_service(req) ((req)->svc)
+#define rpcsvc_request_uid(req) ((req)->uid)
+#define rpcsvc_request_gid(req) ((req)->gid)
+#define rpcsvc_request_private(req) ((req)->private)
+#define rpcsvc_request_xid(req) ((req)->xid)
+#define rpcsvc_request_set_private(req, prv) (req)->private = (void *)(prv)
+#define rpcsvc_request_iobref_ref(req) (iobref_ref((req)->iobref))
+#define rpcsvc_request_record_ref(req) (iobuf_ref((req)->recordiob))
+#define rpcsvc_request_record_unref(req) (iobuf_unref((req)->recordiob))
+#define rpcsvc_request_record_iob(req) ((req)->recordiob)
+#define rpcsvc_request_set_vecstate(req, state) ((req)->vecstate = state)
 #define rpcsvc_request_vecstate(req) ((req)->vecstate)
 #define rpcsvc_request_transport(req) ((req)->trans)
 #define rpcsvc_request_transport_ref(req) (rpc_transport_ref((req)->trans))
-#define RPC_AUTH_ROOT_SQUASH(req)                                       \
-        do {                                                            \
-                int gidcount = 0;                                       \
-                if (req->svc->root_squash) {                            \
-                        if (req->uid == RPC_ROOT_UID)                   \
-                                req->uid = req->svc->anonuid;           \
-                        if (req->gid == RPC_ROOT_GID)                   \
-                                req->gid = req->svc->anongid;           \
-                                                                        \
-                        for (gidcount = 0; gidcount < req->auxgidcount; \
-                             ++gidcount) {                              \
-                                if (!req->auxgids[gidcount])            \
-                                        req->auxgids[gidcount] =        \
-                                                req->svc->anongid;      \
-                        }                                               \
-                }                                                       \
-        } while (0);
-
-#define RPCSVC_ACTOR_SUCCESS    0
-#define RPCSVC_ACTOR_ERROR      (-1)
-#define RPCSVC_ACTOR_IGNORE     (-2)
+#define RPC_AUTH_ROOT_SQUASH(req)                                              \
+    do {                                                                       \
+        int gidcount = 0;                                                      \
+        if (req->svc->root_squash) {                                           \
+            if (req->uid == RPC_ROOT_UID)                                      \
+                req->uid = req->svc->anonuid;                                  \
+            if (req->gid == RPC_ROOT_GID)                                      \
+                req->gid = req->svc->anongid;                                  \
+                                                                               \
+            for (gidcount = 0; gidcount < req->auxgidcount; ++gidcount) {      \
+                if (!req->auxgids[gidcount])                                   \
+                    req->auxgids[gidcount] = req->svc->anongid;                \
+            }                                                                  \
+        }                                                                      \
+    } while (0);
+
+#define RPC_AUTH_ALL_SQUASH(req)                                               \
+    do {                                                                       \
+        int gidcount = 0;                                                      \
+        if (req->svc->all_squash) {                                            \
+            req->uid = req->svc->anonuid;                                      \
+            req->gid = req->svc->anongid;                                      \
+                                                                               \
+            for (gidcount = 0; gidcount < req->auxgidcount; ++gidcount) {      \
+                if (!req->auxgids[gidcount])                                   \
+                    req->auxgids[gidcount] = req->svc->anongid;                \
+            }                                                                  \
+        }                                                                      \
+    } while (0);
+
+#define RPCSVC_ACTOR_SUCCESS 0
+#define RPCSVC_ACTOR_ERROR (-1)
+#define RPCSVC_ACTOR_IGNORE (-2)
 
 /* Functor for every type of protocol actor
  * must be defined like this.
@@ -308,125 +337,146 @@ struct rpcsvc_request {
  * should return RPCSVC_ACTOR_ERROR.
  *
  */
-typedef int (*rpcsvc_actor) (rpcsvc_request_t *req);
-typedef int (*rpcsvc_vector_sizer) (int state, ssize_t *readsize,
-                                    char *base_addr, char *curr_addr);
+typedef int (*rpcsvc_actor)(rpcsvc_request_t *req);
+typedef int (*rpcsvc_vector_sizer)(int state, ssize_t *readsize,
+                                   char *base_addr, char *curr_addr);
 
 /* Every protocol actor will also need to specify the function the RPC layer
  * will use to serialize or encode the message into XDR format just before
  * transmitting on the connection.
  */
-typedef void *(*rpcsvc_encode_reply) (void *msg);
+typedef void *(*rpcsvc_encode_reply)(void *msg);
 
 /* Once the reply has been transmitted, the message will have to be de-allocated
  * , so every actor will need to provide a function that deallocates the message
  * it had allocated as a response.
  */
-typedef void (*rpcsvc_deallocate_reply) (void *msg);
+typedef void (*rpcsvc_deallocate_reply)(void *msg);
 
-#define RPCSVC_NAME_MAX            32
+#define RPCSVC_NAME_MAX 32
 /* The descriptor for each procedure/actor that runs
  * over the RPC service.
  */
 typedef struct rpcsvc_actor_desc {
-        char                    procname[RPCSVC_NAME_MAX];
-        int                     procnum;
-        rpcsvc_actor            actor;
-
-        /* Handler for cases where the RPC requests fragments are large enough
-         * to benefit from being decoded into aligned memory addresses. While
-         * decoding the request in a non-vectored manner, due to the nature of
-         * the XDR scheme, RPC cannot guarantee memory aligned addresses for
-         * the resulting message-specific structures. Allowing a specialized
-         * handler for letting the RPC program read the data from the network
-         * directly into its aligned buffers.
-         */
-        rpcsvc_vector_sizer     vector_sizer;
-
-        /* Can actor be ran on behalf an unprivileged requestor? */
-        gf_boolean_t            unprivileged;
-        drc_op_type_t           op_type;
+    char procname[RPCSVC_NAME_MAX];
+    rpcsvc_actor actor;
+
+    /* Handler for cases where the RPC requests fragments are large enough
+     * to benefit from being decoded into aligned memory addresses. While
+     * decoding the request in a non-vectored manner, due to the nature of
+     * the XDR scheme, RPC cannot guarantee memory aligned addresses for
+     * the resulting message-specific structures. Allowing a specialized
+     * handler for letting the RPC program read the data from the network
+     * directly into its aligned buffers.
+     */
+    rpcsvc_vector_sizer vector_sizer;
+
+    int procnum;
+
+    /* Can actor be ran on behalf an unprivileged requestor? */
+    drc_op_type_t op_type;
+    gf_boolean_t unprivileged;
 } rpcsvc_actor_t;
 
+typedef struct rpcsvc_request_queue {
+    struct list_head request_queue;
+    pthread_mutex_t queue_lock;
+    pthread_cond_t queue_cond;
+    pthread_t thread;
+    struct rpcsvc_program *program;
+    int gen;
+    gf_boolean_t waiting;
+} rpcsvc_request_queue_t;
+
 /* Describes a program and its version along with the function pointers
  * required to handle the procedures/actors of each program/version.
  * Never changed ever by any thread so no need for a lock.
  */
 struct rpcsvc_program {
-        char                    progname[RPCSVC_NAME_MAX];
-        int                     prognum;
-        int                     progver;
-        /* FIXME */
-        dict_t                 *options;        /* An opaque dictionary
-                                                 * populated by the program
-                                                 * (probably from xl->options)
-                                                 * which contain enough
-                                                 * information for transport to
-                                                 * initialize. As a part of
-                                                 * cleanup, the members of
-                                                 * options which are of interest
-                                                 * to transport should be put
-                                                 * into a structure for better
-                                                 * readability and structure
-                                                 * should replace options member
-                                                 * here.
-                                                 */
-        uint16_t                progport;       /* Registered with portmap */
+    char progname[RPCSVC_NAME_MAX];
+    int prognum;
+    int progver;
+    /* FIXME */
+    dict_t *options; /* An opaque dictionary
+                      * populated by the program
+                      * (probably from xl->options)
+                      * which contain enough
+                      * information for transport to
+                      * initialize. As a part of
+                      * cleanup, the members of
+                      * options which are of interest
+                      * to transport should be put
+                      * into a structure for better
+                      * readability and structure
+                      * should replace options member
+                      * here.
+                      */
 #if 0
         int                     progaddrfamily; /* AF_INET or AF_INET6 */
         char                    *proghost;      /* Bind host, can be NULL */
 #endif
-        rpcsvc_actor_t          *actors;        /* All procedure handlers */
-        int                     numactors;      /* Num actors in actor array */
-        int                     proghighvers;   /* Highest ver for program
-                                                   supported by the system. */
-        int                     proglowvers;    /* Lowest ver */
-
-        /* Program specific state handed to actors */
-        void                    *private;
-
-
-        /* This upcall is provided by the program during registration.
-         * It is used to notify the program about events like connection being
-         * destroyed etc. The rpc program may take appropriate actions, for eg.,
-         * in the case of connection being destroyed, it should cleanup its
-         * state stored in the connection.
-         */
-        rpcsvc_notify_t         notify;
-
-        /* An integer that identifies the min auth strength that is required
-         * by this protocol, for eg. MOUNT3 needs AUTH_UNIX at least.
-         * See RFC 1813, Section 5.2.1.
-         */
-        int                     min_auth;
-
-	/* Execute actor function in program's own thread? This will reduce */
-        /* the workload on poller threads */
-	gf_boolean_t            ownthread;
-        gf_boolean_t            alive;
-
-        gf_boolean_t            synctask;
-        /* list member to link to list of registered services with rpcsvc */
-        struct list_head        program;
-        struct list_head        request_queue;
-        pthread_mutex_t         queue_lock;
-        pthread_cond_t          queue_cond;
-        pthread_t               thread;
+    rpcsvc_actor_t *actors; /* All procedure handlers */
+    int numactors;          /* Num actors in actor array */
+    int proghighvers;       /* Highest ver for program
+                               supported by the system. */
+    /* Program specific state handed to actors */
+    void *private;
+    gf_latency_t *latencies; /*Tracks latency statistics for the rpc call*/
+
+    /* This upcall is provided by the program during registration.
+     * It is used to notify the program about events like connection being
+     * destroyed etc. The rpc program may take appropriate actions, for eg.,
+     * in the case of connection being destroyed, it should cleanup its
+     * state stored in the connection.
+     */
+    rpcsvc_notify_t notify;
+
+    int proglowvers; /* Lowest ver */
+
+    /* An integer that identifies the min auth strength that is required
+     * by this protocol, for eg. MOUNT3 needs AUTH_UNIX at least.
+     * See RFC 1813, Section 5.2.1.
+     */
+    int min_auth;
+
+    /* list member to link to list of registered services with rpcsvc */
+    struct list_head program;
+    rpcsvc_request_queue_t request_queue[EVENT_MAX_THREADS];
+    pthread_mutex_t thr_lock;
+    pthread_cond_t thr_cond;
+    int threadcount;
+    int thr_queue;
+    pthread_key_t req_queue_key;
+
+    /* eventthreadcount is just a readonly copy of the actual value
+     * owned by the event sub-system
+     * It is used to control the scaling of rpcsvc_request_handler threads
+     */
+    int eventthreadcount;
+    uint16_t progport; /* Registered with portmap */
+    /* Execute actor function in program's own thread? This will reduce */
+    /* the workload on poller threads */
+    gf_boolean_t ownthread;
+    gf_boolean_t alive;
+
+    gf_boolean_t synctask;
+    unsigned long request_queue_status[EVENT_MAX_THREADS / __BITS_PER_LONG];
 };
 
 typedef struct rpcsvc_cbk_program {
-        char                 *progname;
-        int                   prognum;
-        int                   progver;
+    char *progname;
+    int prognum;
+    int progver;
 } rpcsvc_cbk_program_t;
 /* All users of RPC services should use this API to register their
  * procedure handlers.
  */
 extern int
-rpcsvc_program_register (rpcsvc_t *svc, rpcsvc_program_t *program);
+rpcsvc_program_register(rpcsvc_t *svc, rpcsvc_program_t *program,
+                        gf_boolean_t add_to_head);
 
 extern int
-rpcsvc_program_unregister (rpcsvc_t *svc, rpcsvc_program_t *program);
+rpcsvc_program_unregister(rpcsvc_t *svc, rpcsvc_program_t *program);
 
 /* This will create and add a listener to listener pool. Programs can
  * use any of the listener in this pool. A single listener can be used by
@@ -437,142 +487,150 @@ rpcsvc_program_unregister (rpcsvc_t *svc, rpcsvc_program_t *program);
  */
 /* FIXME: can multiple programs registered on same port? */
 extern int32_t
-rpcsvc_create_listeners (rpcsvc_t *svc, dict_t *options, char *name);
+rpcsvc_create_listeners(rpcsvc_t *svc, dict_t *options, char *name);
 
 void
-rpcsvc_listener_destroy (rpcsvc_listener_t *listener);
+rpcsvc_listener_destroy(rpcsvc_listener_t *listener);
 
 extern int
-rpcsvc_program_register_portmap (rpcsvc_program_t *newprog, uint32_t port);
+rpcsvc_program_register_portmap(rpcsvc_program_t *newprog, uint32_t port);
 
+#ifdef IPV6_DEFAULT
 extern int
-rpcsvc_program_unregister_portmap (rpcsvc_program_t *newprog);
+rpcsvc_program_register_rpcbind6(rpcsvc_program_t *newprog, uint32_t port);
+extern int
+rpcsvc_program_unregister_rpcbind6(rpcsvc_program_t *newprog);
+#endif
+
+extern int
+rpcsvc_program_unregister_portmap(rpcsvc_program_t *newprog);
 
 extern int
-rpcsvc_register_portmap_enabled (rpcsvc_t *svc);
+rpcsvc_register_portmap_enabled(rpcsvc_t *svc);
 
 /* Inits the global RPC service data structures.
  * Called in main.
  */
 extern rpcsvc_t *
-rpcsvc_init (xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
-             uint32_t poolcount);
+rpcsvc_init(xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
+            uint32_t poolcount);
 
 extern int
-rpcsvc_reconfigure_options (rpcsvc_t *svc, dict_t *options);
+rpcsvc_reconfigure_options(rpcsvc_t *svc, dict_t *options);
 
 int
-rpcsvc_register_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata);
+rpcsvc_register_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata);
 
 /* unregister a notification callback @notify with data @mydata from svc.
  * returns the number of notification callbacks unregistered.
  */
 int
-rpcsvc_unregister_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata);
+rpcsvc_unregister_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata);
 
 int
-rpcsvc_transport_submit (rpc_transport_t *trans, struct iovec *rpchdr,
-                         int rpchdrcount, struct iovec *proghdr,
-                         int proghdrcount, struct iovec *progpayload,
-                         int progpayloadcount, struct iobref *iobref,
-                         void *priv);
+rpcsvc_transport_submit(rpc_transport_t *trans, struct iovec *rpchdr,
+                        int rpchdrcount, struct iovec *proghdr,
+                        int proghdrcount, struct iovec *progpayload,
+                        int progpayloadcount, struct iobref *iobref,
+                        void *priv);
 
 int
-rpcsvc_submit_message (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref);
+rpcsvc_submit_message(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref);
 
 int
-rpcsvc_submit_generic (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref);
+rpcsvc_submit_generic(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref);
 
 extern int
-rpcsvc_error_reply (rpcsvc_request_t *req);
+rpcsvc_error_reply(rpcsvc_request_t *req);
 
-#define RPCSVC_PEER_STRLEN      1024
-#define RPCSVC_AUTH_ACCEPT      1
-#define RPCSVC_AUTH_REJECT      2
-#define RPCSVC_AUTH_DONTCARE    3
+#define RPCSVC_PEER_STRLEN 1024
+#define RPCSVC_AUTH_ACCEPT 1
+#define RPCSVC_AUTH_REJECT 2
+#define RPCSVC_AUTH_DONTCARE 3
 
 extern int
-rpcsvc_transport_peername (rpc_transport_t *trans, char *hostname, int hostlen);
+rpcsvc_transport_peername(rpc_transport_t *trans, char *hostname, int hostlen);
 
 extern int
-rpcsvc_transport_peeraddr (rpc_transport_t *trans, char *addrstr, int addrlen,
-                           struct sockaddr_storage *returnsa, socklen_t sasize);
+rpcsvc_transport_peeraddr(rpc_transport_t *trans, char *addrstr, int addrlen,
+                          struct sockaddr_storage *returnsa, socklen_t sasize);
 
 extern int
-rpcsvc_auth_check (rpcsvc_t *svc, char *volname, char *ipaddr);
+rpcsvc_auth_check(rpcsvc_t *svc, char *volname, char *ipaddr);
 
 extern int
-rpcsvc_transport_privport_check (rpcsvc_t *svc, char *volname, uint16_t port);
+rpcsvc_transport_privport_check(rpcsvc_t *svc, char *volname, uint16_t port);
 
-#define rpcsvc_request_seterr(req, err)                 (req)->rpc_err = err
-#define rpcsvc_request_set_autherr(req, err)            (req)->auth_err = err
+#define rpcsvc_request_seterr(req, err) ((req)->rpc_err = (int)(err))
+#define rpcsvc_request_set_autherr(req, err) ((req)->auth_err = (int)(err))
 
-extern int rpcsvc_submit_vectors (rpcsvc_request_t *req);
-
-extern int rpcsvc_request_attach_vector (rpcsvc_request_t *req,
-                                         struct iovec msgvec, struct iobuf *iob,
-                                         struct iobref *ioref, int finalvector);
+extern int
+rpcsvc_submit_vectors(rpcsvc_request_t *req);
 
+extern int
+rpcsvc_request_attach_vector(rpcsvc_request_t *req, struct iovec msgvec,
+                             struct iobuf *iob, struct iobref *ioref,
+                             int finalvector);
 
-typedef int (*auth_init_trans) (rpc_transport_t *trans, void *priv);
-typedef int (*auth_init_request) (rpcsvc_request_t *req, void *priv);
-typedef int (*auth_request_authenticate) (rpcsvc_request_t *req, void *priv);
+typedef int (*auth_init_trans)(rpc_transport_t *trans, void *priv);
+typedef int (*auth_init_request)(rpcsvc_request_t *req, void *priv);
+typedef int (*auth_request_authenticate)(rpcsvc_request_t *req, void *priv);
 
 /* This structure needs to be registered by every authentication scheme.
  * Our authentication schemes are stored per connection because
  * each connection will end up using a different authentication scheme.
  */
 typedef struct rpcsvc_auth_ops {
-        auth_init_trans               transport_init;
-        auth_init_request             request_init;
-        auth_request_authenticate     authenticate;
+    auth_init_trans transport_init;
+    auth_init_request request_init;
+    auth_request_authenticate authenticate;
 } rpcsvc_auth_ops_t;
 
 typedef struct rpcsvc_auth_flavour_desc {
-        char                    authname[RPCSVC_NAME_MAX];
-        int                     authnum;
-        rpcsvc_auth_ops_t       *authops;
-        void                    *authprivate;
+    char authname[RPCSVC_NAME_MAX];
+    rpcsvc_auth_ops_t *authops;
+    void *authprivate;
+    int authnum;
 } rpcsvc_auth_t;
 
-typedef void * (*rpcsvc_auth_initer_t) (rpcsvc_t *svc, dict_t *options);
+typedef void *(*rpcsvc_auth_initer_t)(rpcsvc_t *svc, dict_t *options);
 
 struct rpcsvc_auth_list {
-        struct list_head        authlist;
-        rpcsvc_auth_initer_t    init;
-        /* Should be the name with which we identify the auth scheme given
-         * in the volfile options.
-         * This should be different from the authname in rpc_auth_t
-         * in way that makes it easier to specify this scheme in the volfile.
-         * This is because the technical names of the schemes can be a bit
-         * arcane.
-         */
-        char                    name[RPCSVC_NAME_MAX];
-        rpcsvc_auth_t           *auth;
-        int                     enable;
+    struct list_head authlist;
+    rpcsvc_auth_initer_t init;
+    /* Should be the name with which we identify the auth scheme given
+     * in the volfile options.
+     * This should be different from the authname in rpc_auth_t
+     * in way that makes it easier to specify this scheme in the volfile.
+     * This is because the technical names of the schemes can be a bit
+     * arcane.
+     */
+    char name[RPCSVC_NAME_MAX];
+    rpcsvc_auth_t *auth;
+    int enable;
 };
 
 extern int
-rpcsvc_auth_request_init (rpcsvc_request_t *req, struct rpc_msg *callmsg);
+rpcsvc_auth_request_init(rpcsvc_request_t *req, struct rpc_msg *callmsg);
 
 extern int
-rpcsvc_auth_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_init(rpcsvc_t *svc, dict_t *options);
 
 extern int
-rpcsvc_auth_reconf (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_reconf(rpcsvc_t *svc, dict_t *options);
 
 extern int
-rpcsvc_auth_transport_init (rpc_transport_t *xprt);
+rpcsvc_auth_transport_init(rpc_transport_t *xprt);
 
 extern int
-rpcsvc_authenticate (rpcsvc_request_t *req);
+rpcsvc_authenticate(rpcsvc_request_t *req);
 
 extern int
-rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen);
+rpcsvc_auth_array(rpcsvc_t *svc, char *volname, int *autharr, int arrlen);
 
 /* If the request has been sent using AUTH_UNIX, this function returns the
  * auxiliary gids as an array, otherwise, it returns NULL.
@@ -580,47 +638,57 @@ rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen);
  * authentication code even further to support mode auth schemes.
  */
 extern gid_t *
-rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen);
+rpcsvc_auth_unix_auxgids(rpcsvc_request_t *req, int *arrlen);
 
 extern char *
-rpcsvc_volume_allowed (dict_t *options, char *volname);
+rpcsvc_volume_allowed(dict_t *options, char *volname);
 
-int rpcsvc_request_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                           rpcsvc_cbk_program_t *prog, int procnum,
-                           void *req, glusterfs_ctx_t *ctx,
-                           xdrproc_t xdrproc);
+int
+rpcsvc_request_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                      rpcsvc_cbk_program_t *prog, int procnum, void *req,
+                      glusterfs_ctx_t *ctx, xdrproc_t xdrproc);
 
-int rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                            rpcsvc_cbk_program_t *prog, int procnum,
-                            struct iovec *proghdr, int proghdrcount,
-                            struct iobref *iobref);
+int
+rpcsvc_callback_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                       rpcsvc_cbk_program_t *prog, int procnum,
+                       struct iovec *proghdr, int proghdrcount,
+                       struct iobref *iobref);
 
 rpcsvc_actor_t *
-rpcsvc_program_actor (rpcsvc_request_t *req);
+rpcsvc_program_actor(rpcsvc_request_t *req);
 
 int
-rpcsvc_transport_unix_options_build (dict_t **options, char *filepath);
+rpcsvc_transport_unix_options_build(dict_t *options, char *filepath);
 int
-rpcsvc_set_allow_insecure (rpcsvc_t *svc, dict_t *options);
+rpcsvc_set_allow_insecure(rpcsvc_t *svc, dict_t *options);
 int
-rpcsvc_set_addr_namelookup (rpcsvc_t *svc, dict_t *options);
+rpcsvc_set_addr_namelookup(rpcsvc_t *svc, dict_t *options);
 int
-rpcsvc_set_root_squash (rpcsvc_t *svc, dict_t *options);
+rpcsvc_set_root_squash(rpcsvc_t *svc, dict_t *options);
 int
-rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue);
+rpcsvc_set_all_squash(rpcsvc_t *svc, dict_t *options);
+int
+rpcsvc_set_outstanding_rpc_limit(rpcsvc_t *svc, dict_t *options, int defvalue);
 
 int
-rpcsvc_set_throttle_on (rpcsvc_t *svc);
+rpcsvc_set_throttle_on(rpcsvc_t *svc);
 
 int
-rpcsvc_set_throttle_off (rpcsvc_t *svc);
+rpcsvc_set_throttle_off(rpcsvc_t *svc);
 
 gf_boolean_t
-rpcsvc_get_throttle (rpcsvc_t *svc);
+rpcsvc_get_throttle(rpcsvc_t *svc);
 
 int
-rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen);
+rpcsvc_auth_array(rpcsvc_t *svc, char *volname, int *autharr, int arrlen);
 rpcsvc_vector_sizer
-rpcsvc_get_program_vector_sizer (rpcsvc_t *svc, uint32_t prognum,
-                                 uint32_t progver, int procnum);
+rpcsvc_get_program_vector_sizer(rpcsvc_t *svc, uint32_t prognum,
+                                uint32_t progver, int procnum);
+void
+rpcsvc_autoscale_threads(glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr);
+
+extern int
+rpcsvc_destroy(rpcsvc_t *svc);
+void
+rpcsvc_statedump(rpcsvc_t *svc);
 #endif
diff --git a/rpc/rpc-lib/src/xdr-common.h b/rpc/rpc-lib/src/xdr-common.h
index 596ac99640f..752736b3d4d 100644
--- a/rpc/rpc-lib/src/xdr-common.h
+++ b/rpc/rpc-lib/src/xdr-common.h
@@ -22,10 +22,10 @@
 #endif /* __NetBSD__ */
 
 enum gf_dump_procnum {
-        GF_DUMP_NULL,
-        GF_DUMP_DUMP,
-        GF_DUMP_PING,
-        GF_DUMP_MAXVALUE,
+    GF_DUMP_NULL,
+    GF_DUMP_DUMP,
+    GF_DUMP_PING,
+    GF_DUMP_MAXVALUE,
 };
 
 #define GLUSTER_DUMP_PROGRAM 123451501 /* Completely random */
@@ -33,7 +33,7 @@ enum gf_dump_procnum {
 
 /* MAX_AUTH_BYTES is restricted to 400 bytes, see
  * http://tools.ietf.org/html/rfc5531#section-8.2 */
-#define GF_MAX_AUTH_BYTES   MAX_AUTH_BYTES
+#define GF_MAX_AUTH_BYTES MAX_AUTH_BYTES
 
 /* The size of an AUTH_GLUSTERFS_V2 structure:
  *
@@ -54,29 +54,35 @@ enum gf_dump_procnum {
  * Note that the on-wire protocol has tighter requirements than the internal
  * structures. It is possible for xlators to use more groups and a bigger
  * lk_owner than that can be sent by a GlusterFS-client.
+ *
+ * -------
+ * On v3, there are 4 more units, and hence it will be 9 xdr-units
  */
-#define GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len) \
-           (95 - lk_owner_len)
-#define GF_AUTH_GLUSTERFS_MAX_LKOWNER(groups_len)  \
-           (95 - groups_len)
+#define GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_len, type)                             \
+    ((type == AUTH_GLUSTERFS_v2) ? (95 - lk_len) : (91 - lk_len))
+#define GF_AUTH_GLUSTERFS_MAX_LKOWNER(groups_len, type)                        \
+    ((type == AUTH_GLUSTERFS_v2) ? (95 - groups_len) : (91 - groups_len))
 
 #ifdef GF_LINUX_HOST_OS
 #define xdr_u_int32_t xdr_uint32_t
 #define xdr_u_int64_t xdr_uint64_t
+unsigned long
+xdr_sizeof(xdrproc_t func, void *data);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
 #define xdr_u_quad_t xdr_u_int64_t
-#define xdr_quad_t   xdr_int64_t
+#define xdr_quad_t xdr_int64_t
 #define xdr_uint32_t xdr_u_int32_t
 #define xdr_uint64_t xdr_u_int64_t
 #define uint64_t u_int64_t
-unsigned long xdr_sizeof (xdrproc_t func, void *data);
+unsigned long
+xdr_sizeof(xdrproc_t func, void *data);
 #endif
 
 #if defined(__NetBSD__)
 #define xdr_u_quad_t xdr_u_int64_t
-#define xdr_quad_t   xdr_int64_t
+#define xdr_quad_t xdr_int64_t
 #define xdr_uint32_t xdr_u_int32_t
 #define xdr_uint64_t xdr_u_int64_t
 #endif
@@ -85,7 +91,7 @@ unsigned long xdr_sizeof (xdrproc_t func, void *data);
 #define u_quad_t uint64_t
 #define quad_t int64_t
 #define xdr_u_quad_t xdr_uint64_t
-#define xdr_quad_t   xdr_int64_t
+#define xdr_quad_t xdr_int64_t
 #endif
 
 /* Returns the address of the byte that follows the
@@ -93,16 +99,18 @@ unsigned long xdr_sizeof (xdrproc_t func, void *data);
  * E.g. once the RPC call for NFS has been decoded, the macro will return
  * the address from which the NFS header starts.
  */
-#define xdr_decoded_remaining_addr(xdr)        ((&xdr)->x_private)
+#define xdr_decoded_remaining_addr(xdr) ((&xdr)->x_private)
 
 /* Returns the length of the remaining record after the previous decode
  * operation completed.
  */
-#define xdr_decoded_remaining_len(xdr)         ((&xdr)->x_handy)
+#define xdr_decoded_remaining_len(xdr) ((&xdr)->x_handy)
 
 /* Returns the number of bytes used by the last encode operation. */
-#define xdr_encoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+#define xdr_encoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
 
-#define xdr_decoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+#define xdr_decoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
 
 #endif
diff --git a/rpc/rpc-lib/src/xdr-rpc.c b/rpc/rpc-lib/src/xdr-rpc.c
index 88a7637b887..4992dc5a7ce 100644
--- a/rpc/rpc-lib/src/xdr-rpc.c
+++ b/rpc/rpc-lib/src/xdr-rpc.c
@@ -9,199 +9,190 @@
 */
 
 #include <rpc/rpc.h>
-#include <rpc/pmap_clnt.h>
-#include <arpa/inet.h>
 #include <rpc/xdr.h>
 #include <sys/uio.h>
 #include <rpc/auth_unix.h>
 
-#include "mem-pool.h"
 #include "xdr-rpc.h"
 #include "xdr-common.h"
-#include "logging.h"
-#include "common-utils.h"
+#include <glusterfs/common-utils.h>
 
 /* Decodes the XDR format in msgbuf into rpc_msg.
  * The remaining payload is returned into payload.
  */
 int
-xdr_to_rpc_call (char *msgbuf, size_t len, struct rpc_msg *call,
-                 struct iovec *payload, char *credbytes, char *verfbytes)
+xdr_to_rpc_call(char *msgbuf, size_t len, struct rpc_msg *call,
+                struct iovec *payload, char *credbytes, char *verfbytes)
 {
-        XDR                     xdr;
-        char                    opaquebytes[GF_MAX_AUTH_BYTES];
-        struct opaque_auth      *oa = NULL;
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", call, out);
-
-        memset (call, 0, sizeof (*call));
-
-        oa = &call->rm_call.cb_cred;
-        if (!credbytes)
-                oa->oa_base = opaquebytes;
-        else
-                oa->oa_base = credbytes;
-
-        oa = &call->rm_call.cb_verf;
-        if (!verfbytes)
-                oa->oa_base = opaquebytes;
-        else
-                oa->oa_base = verfbytes;
-
-        xdrmem_create (&xdr, msgbuf, len, XDR_DECODE);
-        if (!xdr_callmsg (&xdr, call)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode call msg");
-                goto out;
-        }
-
-        if (payload) {
-                payload->iov_base = xdr_decoded_remaining_addr (xdr);
-                payload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
-
-        ret = 0;
+    XDR xdr;
+    char opaquebytes[GF_MAX_AUTH_BYTES];
+    struct opaque_auth *oa = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", call, out);
+
+    memset(call, 0, sizeof(*call));
+
+    oa = &call->rm_call.cb_cred;
+    if (!credbytes)
+        oa->oa_base = opaquebytes;
+    else
+        oa->oa_base = credbytes;
+
+    oa = &call->rm_call.cb_verf;
+    if (!verfbytes)
+        oa->oa_base = opaquebytes;
+    else
+        oa->oa_base = verfbytes;
+
+    xdrmem_create(&xdr, msgbuf, len, XDR_DECODE);
+    if (!xdr_callmsg(&xdr, call)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode call msg");
+        goto out;
+    }
+
+    if (payload) {
+        payload->iov_base = xdr_decoded_remaining_addr(xdr);
+        payload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 bool_t
-true_func (XDR *s, caddr_t *a)
+true_func(XDR *s, caddr_t *a)
 {
-        return TRUE;
+    return TRUE;
 }
 
-
 int
-rpc_fill_empty_reply (struct rpc_msg *reply, uint32_t xid)
+rpc_fill_empty_reply(struct rpc_msg *reply, uint32_t xid)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
 
-        /* Setting to 0 also results in reply verifier flavor to be
-         * set to AUTH_NULL which is what we want right now.
-         */
-        memset (reply, 0, sizeof (*reply));
-        reply->rm_xid = xid;
-        reply->rm_direction = REPLY;
+    /* Setting to 0 also results in reply verifier flavor to be
+     * set to AUTH_NULL which is what we want right now.
+     */
+    memset(reply, 0, sizeof(*reply));
+    reply->rm_xid = xid;
+    reply->rm_direction = REPLY;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_fill_denied_reply (struct rpc_msg *reply, int rjstat, int auth_err)
+rpc_fill_denied_reply(struct rpc_msg *reply, int rjstat, int auth_err)
 {
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-
-        reply->rm_reply.rp_stat = MSG_DENIED;
-        reply->rjcted_rply.rj_stat = rjstat;
-        if (rjstat == RPC_MISMATCH) {
-                /* No problem with hardcoding
-                 * RPC version numbers. We only support
-                 * v2 anyway.
-                 */
-                reply->rjcted_rply.rj_vers.low = 2;
-                reply->rjcted_rply.rj_vers.high = 2;
-        } else if (rjstat == AUTH_ERROR)
-                reply->rjcted_rply.rj_why = auth_err;
-
-        ret = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+
+    reply->rm_reply.rp_stat = MSG_DENIED;
+    reply->rjcted_rply.rj_stat = rjstat;
+    if (rjstat == RPC_MISMATCH) {
+        /* No problem with hardcoding
+         * RPC version numbers. We only support
+         * v2 anyway.
+         */
+        reply->rjcted_rply.rj_vers.low = 2;
+        reply->rjcted_rply.rj_vers.high = 2;
+    } else if (rjstat == AUTH_ERROR)
+        reply->rjcted_rply.rj_why = auth_err;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpc_fill_accepted_reply (struct rpc_msg *reply, int arstat, int proglow,
-                         int proghigh, int verf, int len, char *vdata)
+rpc_fill_accepted_reply(struct rpc_msg *reply, int arstat, int proglow,
+                        int proghigh, int verf, int len, char *vdata)
 {
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-
-        reply->rm_reply.rp_stat = MSG_ACCEPTED;
-        reply->acpted_rply.ar_stat = arstat;
-
-        reply->acpted_rply.ar_verf.oa_flavor = verf;
-        reply->acpted_rply.ar_verf.oa_length = len;
-        reply->acpted_rply.ar_verf.oa_base = vdata;
-        if (arstat == PROG_MISMATCH) {
-                reply->acpted_rply.ar_vers.low = proglow;
-                reply->acpted_rply.ar_vers.high = proghigh;
-        } else if (arstat == SUCCESS) {
-
-                /* This is a hack. I'd really like to build a custom
-                 * XDR library because Sun RPC interface is not very flexible.
-                 */
-                reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func;
-                reply->acpted_rply.ar_results.where = NULL;
-        }
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+
+    reply->rm_reply.rp_stat = MSG_ACCEPTED;
+    reply->acpted_rply.ar_stat = arstat;
+
+    reply->acpted_rply.ar_verf.oa_flavor = verf;
+    reply->acpted_rply.ar_verf.oa_length = len;
+    reply->acpted_rply.ar_verf.oa_base = vdata;
+    if (arstat == PROG_MISMATCH) {
+        reply->acpted_rply.ar_vers.low = proglow;
+        reply->acpted_rply.ar_vers.high = proghigh;
+    } else if (arstat == SUCCESS) {
+        /* This is a hack. I'd really like to build a custom
+         * XDR library because Sun RPC interface is not very flexible.
+         */
+        reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func;
+        reply->acpted_rply.ar_results.where = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_reply_to_xdr (struct rpc_msg *reply, char *dest, size_t len,
-                  struct iovec *dst)
+rpc_reply_to_xdr(struct rpc_msg *reply, char *dest, size_t len,
+                 struct iovec *dst)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dst, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", dst, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_ENCODE);
-        if (!xdr_replymsg(&xdr, reply)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to encode reply msg");
-                goto out;
-        }
+    xdrmem_create(&xdr, dest, len, XDR_ENCODE);
+    if (!xdr_replymsg(&xdr, reply)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to encode reply msg");
+        goto out;
+    }
 
-        dst->iov_base = dest;
-        dst->iov_len = xdr_encoded_length (xdr);
+    dst->iov_base = dest;
+    dst->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xdr_to_auth_unix_cred (char *msgbuf, int msglen, struct authunix_parms *au,
-                       char *machname, gid_t *gids)
+xdr_to_auth_unix_cred(char *msgbuf, int msglen, struct authunix_parms *au,
+                      char *machname, gid_t *gids)
 {
-        XDR             xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", machname, out);
-        GF_VALIDATE_OR_GOTO ("rpc", gids, out);
-        GF_VALIDATE_OR_GOTO ("rpc", au, out);
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", machname, out);
+    GF_VALIDATE_OR_GOTO("rpc", gids, out);
+    GF_VALIDATE_OR_GOTO("rpc", au, out);
 
-        au->aup_machname = machname;
+    au->aup_machname = machname;
 #if defined(GF_DARWIN_HOST_OS) || defined(__FreeBSD__)
-        au->aup_gids = (int *)gids;
+    au->aup_gids = (int *)gids;
 #else
-        au->aup_gids = gids;
+    au->aup_gids = gids;
 #endif
 
-        xdrmem_create (&xdr, msgbuf, msglen, XDR_DECODE);
+    xdrmem_create(&xdr, msgbuf, msglen, XDR_DECODE);
 
-        if (!xdr_authunix_parms (&xdr, au)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode auth unix parms");
-                goto out;
-        }
+    if (!xdr_authunix_parms(&xdr, au)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode auth unix parms");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/xdr-rpc.h b/rpc/rpc-lib/src/xdr-rpc.h
index 82e3f5baac4..7baed273846 100644
--- a/rpc/rpc-lib/src/xdr-rpc.h
+++ b/rpc/rpc-lib/src/xdr-rpc.h
@@ -20,7 +20,6 @@
 #include <rpc/auth_sys.h>
 #endif
 
-//#include <rpc/pmap_clnt.h>
 #include <arpa/inet.h>
 #include <rpc/xdr.h>
 #include <sys/uio.h>
@@ -28,65 +27,68 @@
 #include "xdr-common.h"
 
 typedef enum {
-        AUTH_GLUSTERFS = 5,
-        AUTH_GLUSTERFS_v2 = 390039, /* using a number from  'unused' range,
-                                       from the list available in RFC5531 */
+    AUTH_GLUSTERFS = 5,
+    AUTH_GLUSTERFS_v2 = 390039, /* using a number from  'unused' range,
+                                   from the list available in RFC5531 */
+    AUTH_GLUSTERFS_v3 = 390040, /* this too is unused */
 } gf_rpc_authtype_t;
 
 /* Converts a given network buffer from its XDR format to a structure
  * that contains everything an RPC call needs to work.
  */
 extern int
-xdr_to_rpc_call (char *msgbuf, size_t len, struct rpc_msg *call,
-                 struct iovec *payload, char *credbytes, char *verfbytes);
+xdr_to_rpc_call(char *msgbuf, size_t len, struct rpc_msg *call,
+                struct iovec *payload, char *credbytes, char *verfbytes);
 
 extern int
-rpc_fill_empty_reply (struct rpc_msg *reply, uint32_t xid);
+rpc_fill_empty_reply(struct rpc_msg *reply, uint32_t xid);
 
 extern int
-rpc_fill_denied_reply (struct rpc_msg *reply, int rjstat, int auth_err);
+rpc_fill_denied_reply(struct rpc_msg *reply, int rjstat, int auth_err);
 
 extern int
-rpc_fill_accepted_reply (struct rpc_msg *reply, int arstat, int proglow,
-                         int proghigh, int verf, int len, char *vdata);
+rpc_fill_accepted_reply(struct rpc_msg *reply, int arstat, int proglow,
+                        int proghigh, int verf, int len, char *vdata);
 extern int
-rpc_reply_to_xdr (struct rpc_msg *reply, char *dest, size_t len,
-                  struct iovec *dst);
+rpc_reply_to_xdr(struct rpc_msg *reply, char *dest, size_t len,
+                 struct iovec *dst);
 
 extern int
-xdr_to_auth_unix_cred (char *msgbuf, int msglen, struct authunix_parms *au,
-                       char *machname, gid_t *gids);
+xdr_to_auth_unix_cred(char *msgbuf, int msglen, struct authunix_parms *au,
+                      char *machname, gid_t *gids);
 /* Macros that simplify accessing the members of an RPC call structure. */
-#define rpc_call_xid(call)              ((call)->rm_xid)
-#define rpc_call_direction(call)        ((call)->rm_direction)
-#define rpc_call_rpcvers(call)          ((call)->ru.RM_cmb.cb_rpcvers)
-#define rpc_call_program(call)          ((call)->ru.RM_cmb.cb_prog)
-#define rpc_call_progver(call)          ((call)->ru.RM_cmb.cb_vers)
-#define rpc_call_progproc(call)         ((call)->ru.RM_cmb.cb_proc)
-#define rpc_opaque_auth_flavour(oa)     ((oa)->oa_flavor)
-#define rpc_opaque_auth_len(oa)         ((oa)->oa_length)
-
-#define rpc_call_cred_flavour(call)     (rpc_opaque_auth_flavour ((&(call)->ru.RM_cmb.cb_cred)))
-#define rpc_call_cred_len(call)         (rpc_opaque_auth_len ((&(call)->ru.RM_cmb.cb_cred)))
-
-
-#define rpc_call_verf_flavour(call)     (rpc_opaque_auth_flavour ((&(call)->ru.RM_cmb.cb_verf)))
-#define rpc_call_verf_len(call)         (rpc_opaque_auth_len ((&(call)->ru.RM_cmb.cb_verf)))
-
-
-#ifdef GF_DARWIN_HOST_OS
-#define GF_PRI_RPC_XID          PRIu32
-#define GF_PRI_RPC_VERSION      PRIu32
-#define GF_PRI_RPC_PROG_ID      PRIu32
-#define GF_PRI_RPC_PROG_VERS    PRIu32
-#define GF_PRI_RPC_PROC         PRIu32
+#define rpc_call_xid(call) ((call)->rm_xid)
+#define rpc_call_direction(call) ((call)->rm_direction)
+#define rpc_call_rpcvers(call) ((call)->ru.RM_cmb.cb_rpcvers)
+#define rpc_call_program(call) ((call)->ru.RM_cmb.cb_prog)
+#define rpc_call_progver(call) ((call)->ru.RM_cmb.cb_vers)
+#define rpc_call_progproc(call) ((call)->ru.RM_cmb.cb_proc)
+#define rpc_opaque_auth_flavour(oa) ((oa)->oa_flavor)
+#define rpc_opaque_auth_len(oa) ((oa)->oa_length)
+
+#define rpc_call_cred_flavour(call)                                            \
+    (rpc_opaque_auth_flavour((&(call)->ru.RM_cmb.cb_cred)))
+#define rpc_call_cred_len(call)                                                \
+    (rpc_opaque_auth_len((&(call)->ru.RM_cmb.cb_cred)))
+
+#define rpc_call_verf_flavour(call)                                            \
+    (rpc_opaque_auth_flavour((&(call)->ru.RM_cmb.cb_verf)))
+#define rpc_call_verf_len(call)                                                \
+    (rpc_opaque_auth_len((&(call)->ru.RM_cmb.cb_verf)))
+
+#if defined(GF_DARWIN_HOST_OS) || !defined(HAVE_RPC_RPC_H)
+#define GF_PRI_RPC_XID PRIu32
+#define GF_PRI_RPC_VERSION PRIu32
+#define GF_PRI_RPC_PROG_ID PRIu32
+#define GF_PRI_RPC_PROG_VERS PRIu32
+#define GF_PRI_RPC_PROC PRIu32
 #define GF_PRI_RPC_PROC_VERSION PRIu32
 #else
-#define GF_PRI_RPC_XID          PRIu64
-#define GF_PRI_RPC_VERSION      PRIu64
-#define GF_PRI_RPC_PROG_ID      PRIu64
-#define GF_PRI_RPC_PROG_VERS    PRIu64
-#define GF_PRI_RPC_PROC         PRIu64
+#define GF_PRI_RPC_XID PRIu64
+#define GF_PRI_RPC_VERSION PRIu64
+#define GF_PRI_RPC_PROG_ID PRIu64
+#define GF_PRI_RPC_PROG_VERS PRIu64
+#define GF_PRI_RPC_PROC PRIu64
 #define GF_PRI_RPC_PROC_VERSION PRIu64
 #endif
 
diff --git a/rpc/rpc-lib/src/xdr-rpcclnt.c b/rpc/rpc-lib/src/xdr-rpcclnt.c
index 4a6d2ea9131..8dcdcfeda83 100644
--- a/rpc/rpc-lib/src/xdr-rpcclnt.c
+++ b/rpc/rpc-lib/src/xdr-rpcclnt.c
@@ -9,104 +9,97 @@
 */
 
 #include <rpc/rpc.h>
-#include <rpc/pmap_clnt.h>
-#include <arpa/inet.h>
 #include <rpc/xdr.h>
 #include <sys/uio.h>
 #include <rpc/auth_unix.h>
 #include <errno.h>
 
-#include "mem-pool.h"
 #include "xdr-rpc.h"
 #include "xdr-common.h"
-#include "logging.h"
-#include "common-utils.h"
+#include <glusterfs/common-utils.h>
 
 /* Decodes the XDR format in msgbuf into rpc_msg.
  * The remaining payload is returned into payload.
  */
 int
-xdr_to_rpc_reply (char *msgbuf, size_t len, struct rpc_msg *reply,
-                  struct iovec *payload, char *verfbytes)
+xdr_to_rpc_reply(char *msgbuf, size_t len, struct rpc_msg *reply,
+                 struct iovec *payload, char *verfbytes)
 {
-        XDR                     xdr;
-        int                     ret = -EINVAL;
-
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-
-        memset (reply, 0, sizeof (struct rpc_msg));
-
-        reply->acpted_rply.ar_verf = _null_auth;
-        reply->acpted_rply.ar_results.where = NULL;
-        reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void);
-
-        xdrmem_create (&xdr, msgbuf, len, XDR_DECODE);
-        if (!xdr_replymsg (&xdr, reply)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode reply msg");
-                ret = -errno;
-                goto out;
-        }
-        if (payload) {
-                payload->iov_base = xdr_decoded_remaining_addr (xdr);
-                payload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
-
-        ret = 0;
+    XDR xdr;
+    int ret = -EINVAL;
+
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+
+    memset(reply, 0, sizeof(struct rpc_msg));
+
+    reply->acpted_rply.ar_verf = _null_auth;
+    reply->acpted_rply.ar_results.where = NULL;
+    reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void);
+
+    xdrmem_create(&xdr, msgbuf, len, XDR_DECODE);
+    if (!xdr_replymsg(&xdr, reply)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode reply msg");
+        goto out;
+    }
+    if (payload) {
+        payload->iov_base = xdr_decoded_remaining_addr(xdr);
+        payload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpc_request_to_xdr (struct rpc_msg *request, char *dest, size_t len,
-                    struct iovec *dst)
+rpc_request_to_xdr(struct rpc_msg *request, char *dest, size_t len,
+                   struct iovec *dst)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", request, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dst, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", request, out);
+    GF_VALIDATE_OR_GOTO("rpc", dst, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_ENCODE);
-        if (!xdr_callmsg (&xdr, request)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to encode call msg");
-                goto out;
-        }
+    xdrmem_create(&xdr, dest, len, XDR_ENCODE);
+    if (!xdr_callmsg(&xdr, request)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to encode call msg");
+        goto out;
+    }
 
-        dst->iov_base = dest;
-        dst->iov_len = xdr_encoded_length (xdr);
+    dst->iov_base = dest;
+    dst->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-auth_unix_cred_to_xdr (struct authunix_parms *au, char *dest, size_t len,
-                       struct iovec *iov)
+auth_unix_cred_to_xdr(struct authunix_parms *au, char *dest, size_t len,
+                      struct iovec *iov)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", au, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", iov, out);
+    GF_VALIDATE_OR_GOTO("rpc", au, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", iov, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_DECODE);
+    xdrmem_create(&xdr, dest, len, XDR_DECODE);
 
-        if (!xdr_authunix_parms (&xdr, au)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode authunix parms");
-                goto out;
-        }
+    if (!xdr_authunix_parms(&xdr, au)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode authunix parms");
+        goto out;
+    }
 
-        iov->iov_base = dest;
-        iov->iov_len = xdr_encoded_length (xdr);
+    iov->iov_base = dest;
+    iov->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/xdr-rpcclnt.h b/rpc/rpc-lib/src/xdr-rpcclnt.h
index e8d615a872e..58eda4892a9 100644
--- a/rpc/rpc-lib/src/xdr-rpcclnt.h
+++ b/rpc/rpc-lib/src/xdr-rpcclnt.h
@@ -11,8 +11,6 @@
 #ifndef _XDR_RPCCLNT_H
 #define _XDR_RPCCLNT_H
 
-//#include <rpc/rpc.h>
-//#include <rpc/pmap_clnt.h>
 #include <arpa/inet.h>
 #include <rpc/xdr.h>
 #include <sys/uio.h>
@@ -20,18 +18,19 @@
 #include <rpc/auth_unix.h>
 
 /* Macros that simplify accessing the members of an RPC call structure. */
-#define rpc_reply_xid(reply)              ((reply)->rm_xid)
-#define rpc_reply_status(reply)           ((reply)->ru.RM_rmb.rp_stat)
-#define rpc_accepted_reply_status(reply)  ((reply)->acpted_rply.ar_stat)
-#define rpc_reply_verf_flavour(reply)     ((reply)->acpted_rply.ar_verf.oa_flavor)
+#define rpc_reply_xid(reply) ((reply)->rm_xid)
+#define rpc_reply_status(reply) ((reply)->ru.RM_rmb.rp_stat)
+#define rpc_accepted_reply_status(reply) ((reply)->acpted_rply.ar_stat)
+#define rpc_reply_verf_flavour(reply) ((reply)->acpted_rply.ar_verf.oa_flavor)
 
-int xdr_to_rpc_reply (char *msgbuf, size_t len, struct rpc_msg *reply,
-                      struct iovec *payload, char *verfbytes);
 int
-rpc_request_to_xdr (struct rpc_msg *request, char *dest, size_t len,
-                    struct iovec *dst);
+xdr_to_rpc_reply(char *msgbuf, size_t len, struct rpc_msg *reply,
+                 struct iovec *payload, char *verfbytes);
 int
-auth_unix_cred_to_xdr (struct authunix_parms *au, char *dest, size_t len,
-                       struct iovec *iov);
+rpc_request_to_xdr(struct rpc_msg *request, char *dest, size_t len,
+                   struct iovec *dst);
+int
+auth_unix_cred_to_xdr(struct authunix_parms *au, char *dest, size_t len,
+                      struct iovec *iov);
 
 #endif
diff --git a/rpc/rpc-transport/Makefile.am b/rpc/rpc-transport/Makefile.am
index 221fd640514..7dd9f026cfc 100644
--- a/rpc/rpc-transport/Makefile.am
+++ b/rpc/rpc-transport/Makefile.am
@@ -1 +1 @@
-SUBDIRS = socket $(RDMA_SUBDIR)
+SUBDIRS = socket
diff --git a/rpc/rpc-transport/rdma/Makefile.am b/rpc/rpc-transport/rdma/Makefile.am
deleted file mode 100644
index f963effea22..00000000000
--- a/rpc/rpc-transport/rdma/Makefile.am
+++ /dev/null
@@ -1 +0,0 @@
-SUBDIRS = src
-\ No newline at end of file
diff --git a/rpc/rpc-transport/rdma/src/Makefile.am b/rpc/rpc-transport/rdma/src/Makefile.am
deleted file mode 100644
index fedf304c5fe..00000000000
--- a/rpc/rpc-transport/rdma/src/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-# TODO : need to change transportdir
-
-transport_LTLIBRARIES = rdma.la
-transportdir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/rpc-transport
-
-rdma_la_LDFLAGS = -module -avoid-version -nostartfiles
-
-rdma_la_SOURCES = rdma.c name.c
-rdma_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la     \
-	-libverbs -lrdmacm
-
-noinst_HEADERS = rdma.h name.h rpc-trans-rdma-messages.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) \
-	-I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/rpc-lib/src/ \
-	-I$(top_srcdir)/rpc/xdr/src \
-	-I$(top_builddir)/rpc/xdr/src
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-CLEANFILES = *~
diff --git a/rpc/rpc-transport/rdma/src/name.c b/rpc/rpc-transport/rdma/src/name.c
deleted file mode 100644
index be7490abac1..00000000000
--- a/rpc/rpc-transport/rdma/src/name.c
+++ /dev/null
@@ -1,742 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <errno.h>
-#include <netdb.h>
-#include <string.h>
-#include <rdma/rdma_cma.h>
-
-#ifndef AF_INET_SDP
-#define AF_INET_SDP 27
-#endif
-
-#include "rpc-transport.h"
-#include "rdma.h"
-#include "common-utils.h"
-#include "rpc-lib-messages.h"
-#include "rpc-trans-rdma-messages.h"
-
-
-int32_t
-gf_resolve_ip6 (const char *hostname,
-                uint16_t port,
-                int family,
-                void **dnscache,
-                struct addrinfo **addr_info);
-
-
-static void
-_assign_port (struct sockaddr *sockaddr, uint16_t port)
-{
-        switch (sockaddr->sa_family) {
-        case AF_INET6:
-                ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port);
-                break;
-
-        case AF_INET_SDP:
-        case AF_INET:
-                ((struct sockaddr_in *)sockaddr)->sin_port = htons (port);
-                break;
-        }
-}
-
-static int32_t
-af_inet_bind_to_port_lt_ceiling (struct rdma_cm_id *cm_id,
-                                 struct sockaddr *sockaddr,
-                                 socklen_t sockaddr_len, uint32_t ceiling)
-{
-#if GF_DISABLE_PRIVPORT_TRACKING
-        _assign_port (sockaddr, 0);
-        return rdma_bind_addr (cm_id, sockaddr);
-#else
-        int32_t         ret                             = -1;
-        uint16_t        port                            = ceiling - 1;
-        unsigned char   ports[GF_PORT_ARRAY_SIZE]       = {0,};
-        int             i                               = 0;
-
-loop:
-        ret = gf_process_reserved_ports (ports, ceiling);
-
-        while (port) {
-                if (port == GF_CLIENT_PORT_CEILING) {
-                        ret = -1;
-                        break;
-                }
-
-                /* ignore the reserved ports */
-                if (BIT_VALUE (ports, port)) {
-                        port--;
-                        continue;
-                }
-
-                _assign_port (sockaddr, port);
-
-                ret = rdma_bind_addr (cm_id, sockaddr);
-
-                if (ret == 0)
-                        break;
-
-                if (ret == -1 && errno == EACCES)
-                        break;
-
-                port--;
-        }
-
-        /* Incase if all the secure ports are exhausted, we are no more
-         * binding to secure ports, hence instead of getting a random
-         * port, lets define the range to restrict it from getting from
-         * ports reserved for bricks i.e from range of 49152 - 65535
-         * which further may lead to port clash */
-        if (!port) {
-                ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
-                for (i = 0; i <= ceiling; i++)
-                        BIT_CLEAR (ports, i);
-                goto loop;
-        }
-
-        return ret;
-#endif /* GF_DISABLE_PRIVPORT_TRACKING */
-}
-
-#if 0
-static int32_t
-af_unix_client_bind (rpc_transport_t *this, struct sockaddr *sockaddr,
-                     socklen_t sockaddr_len, struct rdma_cm_id *cm_id)
-{
-        data_t *path_data = NULL;
-        struct sockaddr_un *addr = NULL;
-        int32_t ret = -1;
-
-        path_data = dict_get (this->options,
-                              "transport.rdma.bind-path");
-        if (path_data) {
-                char *path = data_to_str (path_data);
-                if (!path || strlen (path) > UNIX_PATH_MAX) {
-                        gf_msg_debug (this->name, 0,
-                                      "transport.rdma.bind-path not specified "
-                                      "for unix socket, letting connect to "
-                                      "assign default value");
-                        goto err;
-                }
-
-                addr = (struct sockaddr_un *) sockaddr;
-                strcpy (addr->sun_path, path);
-                ret = bind (sock, (struct sockaddr *)addr, sockaddr_len);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                TRANS_MSG_SOCKET_BIND_ERROR,
-                                "cannot bind to unix-domain socket %d ",
-                                sock);
-                        goto err;
-                }
-        }
-
-err:
-        return ret;
-}
-#endif
-
-static int32_t
-client_fill_address_family (rpc_transport_t *this, struct sockaddr *sockaddr)
-{
-        data_t *address_family_data = NULL;
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (!address_family_data) {
-                data_t *remote_host_data = NULL, *connect_path_data = NULL;
-                remote_host_data = dict_get (this->options, "remote-host");
-                connect_path_data = dict_get (this->options,
-                                              "transport.rdma.connect-path");
-
-                if (!(remote_host_data || connect_path_data) ||
-                    (remote_host_data && connect_path_data)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED,
-                                "address-family not specified and not able to "
-                                "determine the same from other options "
-                                "(remote-host:%s and connect-path:%s)",
-                                data_to_str (remote_host_data),
-                                data_to_str (connect_path_data));
-                        return -1;
-                }
-
-                if (remote_host_data) {
-                        gf_msg_debug (this->name, 0, "address-family not "
-                                      "specified, guessing it to be "
-                                      "inet/inet6");
-                        sockaddr->sa_family = AF_UNSPEC;
-                } else {
-                        gf_msg_debug (this->name, 0, "address-family not "
-                                      "specified, guessing it to be unix");
-                        sockaddr->sa_family = AF_UNIX;
-                }
-
-        } else {
-                char *address_family = data_to_str (address_family_data);
-                if (!strcasecmp (address_family, "unix")) {
-                        sockaddr->sa_family = AF_UNIX;
-                } else if (!strcasecmp (address_family, "inet")) {
-                        sockaddr->sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        sockaddr->sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        sockaddr->sa_family = AF_INET_SDP;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                                "unknown address-family (%s) specified",
-                                address_family);
-                        sockaddr->sa_family = AF_UNSPEC;
-                        return -1;
-                }
-        }
-
-        return 0;
-}
-
-static int32_t
-af_inet_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len,
-                                    int16_t remote_port)
-{
-        dict_t *options = this->options;
-        data_t *remote_host_data = NULL;
-        data_t *remote_port_data = NULL;
-        char *remote_host = NULL;
-        struct addrinfo *addr_info = NULL;
-        int32_t ret = 0;
-
-        remote_host_data = dict_get (options, "remote-host");
-        if (remote_host_data == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host "
-                        "missing in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_host = data_to_str (remote_host_data);
-        if (remote_host == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host "
-                        "has data NULL in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        if (remote_port == 0) {
-                remote_port_data = dict_get (options, "remote-port");
-                if (remote_port_data == NULL) {
-                        gf_msg_debug (this->name, 0, "option remote-port "
-                                      "missing in volume %s. Defaulting to %d",
-                                      this->name, GF_DEFAULT_RDMA_LISTEN_PORT);
-
-                        remote_port = GF_DEFAULT_RDMA_LISTEN_PORT;
-                } else {
-                        remote_port = data_to_uint16 (remote_port_data);
-                }
-        }
-
-        if (remote_port == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        RDMA_MSG_INVALID_ENTRY, "option remote-port has "
-                        "invalid port in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        /* TODO: gf_resolve is a blocking call. kick in some
-           non blocking dns techniques */
-        ret = gf_resolve_ip6 (remote_host, remote_port,
-                              sockaddr->sa_family,
-                              &this->dnscache, &addr_info);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, TRANS_MSG_DNS_RESOL_FAILED,
-                        "DNS resolution failed on host %s", remote_host);
-                goto err;
-        }
-
-        memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
-        *sockaddr_len = addr_info->ai_addrlen;
-
-err:
-        return ret;
-}
-
-static int32_t
-af_unix_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
-{
-        struct sockaddr_un *sockaddr_un = NULL;
-        char *connect_path = NULL;
-        data_t *connect_path_data = NULL;
-        int32_t ret = 0;
-
-        connect_path_data = dict_get (this->options,
-                                      "transport.rdma.connect-path");
-        if (!connect_path_data) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_CONNECT_PATH_ERROR, "option "
-                        "transport.rdma.connect-path not specified for "
-                        "address-family unix");
-                ret = -1;
-                goto err;
-        }
-
-        connect_path = data_to_str (connect_path_data);
-        if (!connect_path) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        RDMA_MSG_INVALID_ENTRY, "connect-path is null-string");
-                ret = -1;
-                goto err;
-        }
-
-        if (strlen (connect_path) > UNIX_PATH_MAX) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_CONNECT_PATH_ERROR,
-                        "connect-path value length %"GF_PRI_SIZET" > "
-                        "%d octets", strlen (connect_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
-
-        gf_msg_debug (this->name, 0, "using connect-path %s", connect_path);
-        sockaddr_un = (struct sockaddr_un *)sockaddr;
-        strcpy (sockaddr_un->sun_path, connect_path);
-        *sockaddr_len = sizeof (struct sockaddr_un);
-
-err:
-        return ret;
-}
-
-static int32_t
-af_unix_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
-{
-        data_t *listen_path_data = NULL;
-        char *listen_path = NULL;
-        int32_t ret = 0;
-        struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
-
-
-        listen_path_data = dict_get (this->options,
-                                     "transport.rdma.listen-path");
-        if (!listen_path_data) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_LISTEN_PATH_ERROR,
-                        "missing option listen-path");
-                ret = -1;
-                goto err;
-        }
-
-        listen_path = data_to_str (listen_path_data);
-
-#ifndef UNIX_PATH_MAX
-#define UNIX_PATH_MAX 108
-#endif
-
-        if (strlen (listen_path) > UNIX_PATH_MAX) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_LISTEN_PATH_ERROR, "option listen-path has "
-                        "value length %"GF_PRI_SIZET" > %d",
-                        strlen (listen_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
-
-        sunaddr->sun_family = AF_UNIX;
-        strcpy (sunaddr->sun_path, listen_path);
-        *addr_len = sizeof (struct sockaddr_un);
-
-err:
-        return ret;
-}
-
-static int32_t
-af_inet_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
-{
-        struct addrinfo hints, *res = 0;
-        data_t *listen_port_data = NULL, *listen_host_data = NULL;
-        uint16_t listen_port = -1;
-        char service[NI_MAXSERV], *listen_host = NULL;
-        dict_t *options = NULL;
-        int32_t ret = 0;
-
-        options = this->options;
-
-        listen_port_data = dict_get (options, "transport.rdma.listen-port");
-        listen_host_data = dict_get (options,
-                                     "transport.rdma.bind-address");
-
-        if (listen_port_data) {
-                listen_port = data_to_uint16 (listen_port_data);
-        } else {
-                listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
-
-                if (addr->sa_family == AF_INET6) {
-                        struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr;
-                        in->sin6_addr = in6addr_any;
-                        in->sin6_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in6);
-                        goto out;
-                } else if (addr->sa_family == AF_INET) {
-                        struct sockaddr_in *in = (struct sockaddr_in *) addr;
-                        in->sin_addr.s_addr = htonl(INADDR_ANY);
-                        in->sin_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in);
-                        goto out;
-                }
-        }
-
-        if (listen_port == (uint16_t) -1)
-                listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
-
-
-        if (listen_host_data) {
-                listen_host = data_to_str (listen_host_data);
-        }
-
-        memset (service, 0, sizeof (service));
-        sprintf (service, "%d", listen_port);
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = addr->sa_family;
-        hints.ai_socktype = SOCK_STREAM;
-        hints.ai_flags    = AI_ADDRCONFIG | AI_PASSIVE;
-
-        ret = getaddrinfo(listen_host, service, &hints, &res);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_ADDR_INFO_FAILED,
-                        "getaddrinfo failed for host %s, service %s",
-                        listen_host, service);
-                ret = -1;
-                goto out;
-        }
-
-        memcpy (addr, res->ai_addr, res->ai_addrlen);
-        *addr_len = res->ai_addrlen;
-
-        freeaddrinfo (res);
-
-out:
-        return ret;
-}
-
-int32_t
-gf_rdma_client_bind (rpc_transport_t *this, struct sockaddr *sockaddr,
-                     socklen_t *sockaddr_len, struct rdma_cm_id *cm_id)
-{
-        int ret = 0;
-
-        *sockaddr_len = sizeof (struct sockaddr_in6);
-        switch (sockaddr->sa_family) {
-        case AF_INET_SDP:
-        case AF_INET:
-                *sockaddr_len = sizeof (struct sockaddr_in);
-
-        case AF_INET6:
-                if (!this->bind_insecure) {
-                        ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_CLIENT_PORT_CEILING);
-                        if (ret == -1) {
-                                gf_msg (this->name, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_PORT_BIND_FAILED,
-                                        "cannot bind rdma_cm_id to port "
-                                        "less than %d", GF_CLIENT_PORT_CEILING);
-                        }
-                } else {
-                        ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_IANA_PRIV_PORTS_START);
-                        if (ret == -1) {
-                                gf_msg (this->name, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_PORT_BIND_FAILED,
-                                        "cannot bind rdma_cm_id to port "
-                                        "less than %d",
-                                        GF_IANA_PRIV_PORTS_START);
-                        }
-                }
-                break;
-
-        case AF_UNIX:
-                *sockaddr_len = sizeof (struct sockaddr_un);
-#if 0
-                ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr,
-                                           *sockaddr_len, sock);
-#endif
-                break;
-
-        default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address family %d", sockaddr->sa_family);
-                ret = -1;
-                break;
-        }
-
-        return ret;
-}
-
-int32_t
-gf_rdma_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len,
-                                    int16_t remote_port)
-{
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
-
-        ret = client_fill_address_family (this, sockaddr);
-        if (ret) {
-                ret = -1;
-                goto err;
-        }
-
-        switch (sockaddr->sa_family) {
-        case AF_INET_SDP:
-                sockaddr->sa_family = AF_INET;
-                is_inet_sdp = 1;
-
-        case AF_INET:
-        case AF_INET6:
-        case AF_UNSPEC:
-                ret = af_inet_client_get_remote_sockaddr (this,
-                                                          sockaddr,
-                                                          sockaddr_len,
-                                                          remote_port);
-
-                if (is_inet_sdp) {
-                        sockaddr->sa_family = AF_INET_SDP;
-                }
-
-                break;
-
-        case AF_UNIX:
-                ret = af_unix_client_get_remote_sockaddr (this,
-                                                          sockaddr,
-                                                          sockaddr_len);
-                break;
-
-        default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address-family %d", sockaddr->sa_family);
-                ret = -1;
-        }
-
-err:
-        return ret;
-}
-
-int32_t
-gf_rdma_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
-{
-        data_t *address_family_data = NULL;
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (address_family_data) {
-                char *address_family = NULL;
-                address_family = data_to_str (address_family_data);
-
-                if (!strcasecmp (address_family, "inet")) {
-                        addr->sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        addr->sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        addr->sa_family = AF_INET_SDP;
-                } else if (!strcasecmp (address_family, "unix")) {
-                        addr->sa_family = AF_UNIX;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_UNKNOWN_ADDR_FAMILY, "unknown address"
-                                " family (%s) specified", address_family);
-                        addr->sa_family = AF_UNSPEC;
-                        ret = -1;
-                        goto err;
-                }
-        } else {
-                gf_msg_debug (this->name, 0, "option address-family not "
-                              "specified, defaulting to inet");
-                addr->sa_family = AF_INET;
-        }
-
-        switch (addr->sa_family) {
-        case AF_INET_SDP:
-                is_inet_sdp = 1;
-                addr->sa_family = AF_INET;
-
-        case AF_INET:
-        case AF_INET6:
-        case AF_UNSPEC:
-                ret = af_inet_server_get_local_sockaddr (this, addr, addr_len);
-                if (is_inet_sdp && !ret) {
-                        addr->sa_family = AF_INET_SDP;
-                }
-                break;
-
-        case AF_UNIX:
-                ret = af_unix_server_get_local_sockaddr (this, addr, addr_len);
-                break;
-        }
-
-err:
-        return ret;
-}
-
-int32_t
-fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr,
-                             int32_t addr_len, char *identifier)
-{
-        int32_t ret = 0, tmpaddr_len = 0;
-        char service[NI_MAXSERV], host[NI_MAXHOST];
-        union gf_sock_union sock_union;
-
-        memset (&sock_union, 0, sizeof (sock_union));
-        sock_union.storage = *addr;
-        tmpaddr_len = addr_len;
-
-        if (sock_union.sa.sa_family == AF_INET6) {
-                int32_t one_to_four, four_to_eight, twelve_to_sixteen;
-                int16_t eight_to_ten, ten_to_twelve;
-
-                one_to_four = four_to_eight = twelve_to_sixteen = 0;
-                eight_to_ten = ten_to_twelve = 0;
-
-                one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
-                four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
-#ifdef GF_SOLARIS_HOST_OS
-                eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
-#else
-                eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
-#endif
-
-#ifdef GF_SOLARIS_HOST_OS
-                ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
-#else
-                ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
-#endif
-                twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
-
-                /* ipv4 mapped ipv6 address has
-                   bits 0-80: 0
-                   bits 80-96: 0xffff
-                   bits 96-128: ipv4 address
-                */
-
-                if (one_to_four == 0 &&
-                    four_to_eight == 0 &&
-                    eight_to_ten == 0 &&
-                    ten_to_twelve == -1) {
-                        struct sockaddr_in *in_ptr = &sock_union.sin;
-                        memset (&sock_union, 0, sizeof (sock_union));
-
-                        in_ptr->sin_family = AF_INET;
-                        in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
-                        in_ptr->sin_addr.s_addr = twelve_to_sixteen;
-                        tmpaddr_len = sizeof (*in_ptr);
-                }
-        }
-
-        ret = getnameinfo (&sock_union.sa,
-                           tmpaddr_len,
-                           host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST | NI_NUMERICSERV);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_NAME_INFO_FAILED,
-                        "getnameinfo failed");
-        }
-
-        sprintf (identifier, "%s:%s", host, service);
-
-        return ret;
-}
-
-int32_t
-gf_rdma_get_transport_identifiers (rpc_transport_t *this)
-{
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
-
-        switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family) {
-        case AF_INET_SDP:
-                is_inet_sdp = 1;
-                ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET;
-
-        case AF_INET:
-        case AF_INET6: {
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->myinfo.sockaddr,
-                                                   this->myinfo.sockaddr_len,
-                                                   this->myinfo.identifier);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_INET_ERROR,
-                                "can't fill inet/inet6 identifier for server");
-                        goto err;
-                }
-
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->peerinfo.sockaddr,
-                                                   this->peerinfo.sockaddr_len,
-                                                   this->peerinfo.identifier);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_INET_ERROR,
-                                "can't fill inet/inet6 identifier for client");
-                        goto err;
-                }
-
-                if (is_inet_sdp) {
-                        ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP;
-                }
-        }
-        break;
-
-        case AF_UNIX:
-        {
-                struct sockaddr_un *sunaddr = NULL;
-
-                sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr;
-                strcpy (this->myinfo.identifier, sunaddr->sun_path);
-
-                sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr;
-                strcpy (this->peerinfo.identifier, sunaddr->sun_path);
-        }
-        break;
-
-        default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address family (%d)",
-                        ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family);
-                ret = -1;
-                break;
-        }
-
-err:
-        return ret;
-}
diff --git a/rpc/rpc-transport/rdma/src/name.h b/rpc/rpc-transport/rdma/src/name.h
deleted file mode 100644
index 742fc5fc3f2..00000000000
--- a/rpc/rpc-transport/rdma/src/name.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _IB_VERBS_NAME_H
-#define _IB_VERBS_NAME_H
-
-#include <rdma/rdma_cma.h>
-
-#include "compat.h"
-
-int32_t
-gf_rdma_client_bind (rpc_transport_t *this, struct sockaddr *sockaddr,
-                     socklen_t *sockaddr_len, struct rdma_cm_id *cm_id);
-
-int32_t
-gf_rdma_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len,
-                                    int16_t remote_port);
-
-int32_t
-gf_rdma_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len);
-
-int32_t
-gf_rdma_get_transport_identifiers (rpc_transport_t *this);
-
-#endif /* _IB_VERBS_NAME_H */
diff --git a/rpc/rpc-transport/rdma/src/rdma.c b/rpc/rpc-transport/rdma/src/rdma.c
deleted file mode 100644
index 26bcce4fd99..00000000000
--- a/rpc/rpc-transport/rdma/src/rdma.c
+++ /dev/null
@@ -1,5056 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#include "dict.h"
-#include "glusterfs.h"
-#include "iobuf.h"
-#include "logging.h"
-#include "rdma.h"
-#include "name.h"
-#include "byte-order.h"
-#include "xlator.h"
-#include "xdr-rpc.h"
-#include "rpc-lib-messages.h"
-#include "rpc-trans-rdma-messages.h"
-#include <signal.h>
-
-#define GF_RDMA_LOG_NAME "rpc-transport/rdma"
-
-static int32_t
-__gf_rdma_ioq_churn (gf_rdma_peer_t *peer);
-
-gf_rdma_post_t *
-gf_rdma_post_ref (gf_rdma_post_t *post);
-
-int
-gf_rdma_post_unref (gf_rdma_post_t *post);
-
-static void *
-gf_rdma_send_completion_proc (void *data);
-
-static void *
-gf_rdma_recv_completion_proc (void *data);
-
-void *
-gf_rdma_async_event_thread (void *context);
-
-static int32_t
-gf_rdma_create_qp (rpc_transport_t *this);
-
-static int32_t
-__gf_rdma_teardown (rpc_transport_t *this);
-
-static int32_t
-gf_rdma_teardown (rpc_transport_t *this);
-
-static int32_t
-gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait);
-
-static void
-gf_rdma_cm_handle_disconnect (rpc_transport_t *this);
-
-static int
-gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event);
-
-static void
-gf_rdma_put_post (gf_rdma_queue_t *queue, gf_rdma_post_t *post)
-{
-        post->ctx.is_request = 0;
-
-        pthread_mutex_lock (&queue->lock);
-        {
-                if (post->prev) {
-                        queue->active_count--;
-                        post->prev->next = post->next;
-                }
-
-                if (post->next) {
-                        post->next->prev = post->prev;
-                }
-
-                post->prev = &queue->passive_posts;
-                post->next = post->prev->next;
-                post->prev->next = post;
-                post->next->prev = post;
-                queue->passive_count++;
-        }
-        pthread_mutex_unlock (&queue->lock);
-}
-
-
-static gf_rdma_post_t *
-gf_rdma_new_post (rpc_transport_t *this, gf_rdma_device_t *device, int32_t len,
-                  gf_rdma_post_type_t type)
-{
-        gf_rdma_post_t *post = NULL;
-        int             ret  = -1;
-
-        post = (gf_rdma_post_t *) GF_CALLOC (1, sizeof (*post),
-                                             gf_common_mt_rdma_post_t);
-        if (post == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_init (&post->lock, NULL);
-
-        post->buf_size = len;
-
-        post->buf = valloc (len);
-        if (!post->buf) {
-                gf_msg_nomem (GF_RDMA_LOG_NAME, GF_LOG_ERROR, len);
-                goto out;
-        }
-
-        post->mr = ibv_reg_mr (device->pd,
-                               post->buf,
-                               post->buf_size,
-                               IBV_ACCESS_LOCAL_WRITE);
-        if (!post->mr) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_MR_ALOC_FAILED,
-                        "memory registration failed");
-                goto out;
-        }
-
-        post->device = device;
-        post->type = type;
-
-        ret = 0;
-out:
-        if (ret != 0) {
-                free (post->buf);
-
-                GF_FREE (post);
-                post = NULL;
-        }
-
-        return post;
-}
-
-
-static gf_rdma_post_t *
-gf_rdma_get_post (gf_rdma_queue_t *queue)
-{
-        gf_rdma_post_t *post = NULL;
-
-        pthread_mutex_lock (&queue->lock);
-        {
-                post = queue->passive_posts.next;
-                if (post == &queue->passive_posts)
-                        post = NULL;
-
-                if (post) {
-                        if (post->prev)
-                                post->prev->next = post->next;
-                        if (post->next)
-                                post->next->prev = post->prev;
-                        post->prev = &queue->active_posts;
-                        post->next = post->prev->next;
-                        post->prev->next = post;
-                        post->next->prev = post;
-                        post->reused++;
-                        queue->active_count++;
-                }
-        }
-        pthread_mutex_unlock (&queue->lock);
-
-        return post;
-}
-
-void
-gf_rdma_destroy_post (gf_rdma_post_t *post)
-{
-        ibv_dereg_mr (post->mr);
-        free (post->buf);
-        GF_FREE (post);
-}
-
-
-static int32_t
-__gf_rdma_quota_get (gf_rdma_peer_t *peer)
-{
-        int32_t            ret  = -1;
-        gf_rdma_private_t *priv = NULL;
-
-        priv = peer->trans->private;
-
-        if (priv->connected && peer->quota > 0) {
-                ret = peer->quota--;
-        }
-
-        return ret;
-}
-
-
-static void
-__gf_rdma_ioq_entry_free (gf_rdma_ioq_t *entry)
-{
-        list_del_init (&entry->list);
-
-        if (entry->iobref) {
-                iobref_unref (entry->iobref);
-                entry->iobref = NULL;
-        }
-
-        if (entry->msg.request.rsp_iobref) {
-                iobref_unref (entry->msg.request.rsp_iobref);
-                entry->msg.request.rsp_iobref = NULL;
-        }
-
-        mem_put (entry);
-}
-
-
-static void
-__gf_rdma_ioq_flush (gf_rdma_peer_t *peer)
-{
-        gf_rdma_ioq_t *entry = NULL, *dummy = NULL;
-
-        list_for_each_entry_safe (entry, dummy, &peer->ioq, list) {
-                __gf_rdma_ioq_entry_free (entry);
-        }
-}
-
-
-static int32_t
-__gf_rdma_disconnect (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv = NULL;
-
-        priv = this->private;
-
-        if (priv->connected) {
-                rdma_disconnect (priv->peer.cm_id);
-        }
-
-        return 0;
-}
-
-
-static void
-gf_rdma_queue_init (gf_rdma_queue_t *queue)
-{
-        pthread_mutex_init (&queue->lock, NULL);
-
-        queue->active_posts.next = &queue->active_posts;
-        queue->active_posts.prev = &queue->active_posts;
-        queue->passive_posts.next = &queue->passive_posts;
-        queue->passive_posts.prev = &queue->passive_posts;
-}
-
-
-static void
-__gf_rdma_destroy_queue (gf_rdma_post_t *post)
-{
-        gf_rdma_post_t *tmp = NULL;
-
-        while (post->next != post) {
-                tmp = post->next;
-
-                post->next = post->next->next;
-                post->next->prev = post;
-
-                gf_rdma_destroy_post (tmp);
-        }
-}
-
-
-static void
-gf_rdma_destroy_queue (gf_rdma_queue_t *queue)
-{
-        if (queue == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&queue->lock);
-        {
-                if (queue->passive_count > 0) {
-                        __gf_rdma_destroy_queue (&queue->passive_posts);
-                        queue->passive_count = 0;
-                }
-
-                if (queue->active_count > 0) {
-                        __gf_rdma_destroy_queue (&queue->active_posts);
-                        queue->active_count = 0;
-                }
-        }
-        pthread_mutex_unlock (&queue->lock);
-
-out:
-        return;
-}
-
-
-static void
-gf_rdma_destroy_posts (rpc_transport_t *this)
-{
-        gf_rdma_device_t  *device = NULL;
-        gf_rdma_private_t *priv   = NULL;
-
-        if (this == NULL) {
-                goto out;
-        }
-
-        priv = this->private;
-        device = priv->device;
-
-        gf_rdma_destroy_queue (&device->sendq);
-        gf_rdma_destroy_queue (&device->recvq);
-
-out:
-        return;
-}
-
-
-static int32_t
-__gf_rdma_create_posts (rpc_transport_t *this, int32_t count, int32_t size,
-                        gf_rdma_queue_t *q, gf_rdma_post_type_t type)
-{
-        int32_t            i      = 0;
-        int32_t            ret    = 0;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-
-        priv = this->private;
-        device = priv->device;
-
-        for (i = 0 ; i < count ; i++) {
-                gf_rdma_post_t *post = NULL;
-
-                post = gf_rdma_new_post (this, device, size + 2048, type);
-                if (!post) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_POST_CREATION_FAILED,
-                                "post creation failed");
-                        ret = -1;
-                        break;
-                }
-
-                gf_rdma_put_post (q, post);
-        }
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_post_recv (struct ibv_srq *srq,
-                   gf_rdma_post_t *post)
-{
-        struct ibv_sge list = {
-                .addr   = (unsigned long) post->buf,
-                .length = post->buf_size,
-                .lkey   = post->mr->lkey
-        };
-
-        struct ibv_recv_wr wr = {
-                .wr_id  = (unsigned long) post,
-                .sg_list = &list,
-                .num_sge = 1,
-        }, *bad_wr;
-
-        gf_rdma_post_ref (post);
-
-        return ibv_post_srq_recv (srq, &wr, &bad_wr);
-}
-
-static void
-gf_rdma_deregister_iobuf_pool (gf_rdma_device_t *device)
-{
-
-        gf_rdma_arena_mr   *arena_mr  = NULL;
-        gf_rdma_arena_mr   *tmp       = NULL;
-
-        while (device) {
-                if (!list_empty(&device->all_mr)) {
-                        list_for_each_entry_safe (arena_mr, tmp,
-                                                  &device->all_mr, list) {
-                                if (ibv_dereg_mr(arena_mr->mr)) {
-                                        gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                                RDMA_MSG_DEREGISTER_ARENA_FAILED,
-                                                "deallocation of memory region "
-                                                "failed");
-                                        return;
-                                }
-                                list_del(&arena_mr->list);
-                                GF_FREE(arena_mr);
-                        }
-                }
-                device = device->next;
-        }
-}
-int
-gf_rdma_deregister_arena (struct list_head **mr_list,
-                          struct iobuf_arena *iobuf_arena)
-{
-        gf_rdma_arena_mr *tmp     = NULL;
-        gf_rdma_arena_mr *dummy   = NULL;
-        int               count   = 0, i = 0;
-
-        count = iobuf_arena->iobuf_pool->rdma_device_count;
-        for (i = 0; i < count; i++) {
-                list_for_each_entry_safe (tmp, dummy, mr_list[i], list) {
-                        if (tmp->iobuf_arena == iobuf_arena) {
-                                if (ibv_dereg_mr(tmp->mr)) {
-                                        gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                               RDMA_MSG_DEREGISTER_ARENA_FAILED,
-                                                "deallocation of memory region "
-                                                "failed");
-                                        return -1;
-                                }
-                                list_del(&tmp->list);
-                                GF_FREE(tmp);
-                                break;
-                        }
-                }
-        }
-
-        return 0;
-}
-
-
-int
-gf_rdma_register_arena (void **arg1, void *arg2)
-{
-        struct ibv_mr       *mr          = NULL;
-        gf_rdma_arena_mr    *new         = NULL;
-        struct iobuf_pool   *iobuf_pool  = NULL;
-        gf_rdma_device_t    **device     = (gf_rdma_device_t **)arg1;
-        struct iobuf_arena  *iobuf_arena = arg2;
-        int                  count       = 0, i = 0;
-
-        iobuf_pool = iobuf_arena->iobuf_pool;
-        count = iobuf_pool->rdma_device_count;
-        for (i = 0; i < count; i++) {
-                new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
-                                gf_common_mt_rdma_arena_mr);
-                if (new == NULL) {
-                        gf_msg ("rdma", GF_LOG_INFO, ENOMEM,
-                                RDMA_MSG_MR_ALOC_FAILED, "Out of "
-                                "memory: registering pre allocated buffer "
-                                "with rdma device failed.");
-                      return -1;
-                }
-                INIT_LIST_HEAD (&new->list);
-                new->iobuf_arena = iobuf_arena;
-
-                mr = ibv_reg_mr(device[i]->pd, iobuf_arena->mem_base,
-                                         iobuf_arena->arena_size,
-                                         IBV_ACCESS_REMOTE_READ |
-                                         IBV_ACCESS_LOCAL_WRITE |
-                                         IBV_ACCESS_REMOTE_WRITE
-                                         );
-                if (!mr)
-                        gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                RDMA_MSG_MR_ALOC_FAILED, "allocation of mr "
-                                "failed");
-
-                new->mr = mr;
-                list_add (&new->list, &device[i]->all_mr);
-                new = NULL;
-        }
-
-        return 0;
-
-}
-
-static void
-gf_rdma_register_iobuf_pool (gf_rdma_device_t *device,
-                        struct iobuf_pool *iobuf_pool)
-{
-        struct iobuf_arena  *tmp        = NULL;
-        struct iobuf_arena  *dummy      = NULL;
-        struct ibv_mr       *mr         = NULL;
-        gf_rdma_arena_mr    *new        = NULL;
-
-        if (!list_empty(&iobuf_pool->all_arenas)) {
-
-                list_for_each_entry_safe (tmp, dummy, &iobuf_pool->all_arenas,
-                                          all_list) {
-                        new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
-                                        gf_common_mt_rdma_arena_mr);
-                        if (new == NULL) {
-                                gf_msg ("rdma", GF_LOG_INFO, ENOMEM,
-                                        RDMA_MSG_MR_ALOC_FAILED, "Out of "
-                                        "memory: registering pre allocated "
-                                        "buffer with rdma device failed.");
-                              return;
-                        }
-                        INIT_LIST_HEAD (&new->list);
-                        new->iobuf_arena = tmp;
-
-                        mr = ibv_reg_mr(device->pd, tmp->mem_base,
-                                        tmp->arena_size,
-                                        IBV_ACCESS_REMOTE_READ |
-                                        IBV_ACCESS_LOCAL_WRITE |
-                                        IBV_ACCESS_REMOTE_WRITE);
-                        if (!mr) {
-                                gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                        RDMA_MSG_MR_ALOC_FAILED, "failed"
-                                        " to pre register buffers with rdma "
-                                        "devices.");
-
-                        }
-                        new->mr = mr;
-                        list_add (&new->list, &device->all_mr);
-
-                        new = NULL;
-                }
-        }
-
-       return;
-}
-
-static void
-gf_rdma_register_iobuf_pool_with_device (gf_rdma_device_t *device,
-                                         struct iobuf_pool *iobuf_pool)
-{
-        while (device) {
-                gf_rdma_register_iobuf_pool (device, iobuf_pool);
-                device = device->next;
-        }
-}
-
-static struct ibv_mr*
-gf_rdma_get_pre_registred_mr(rpc_transport_t *this, void *ptr, int size)
-{
-        gf_rdma_arena_mr   *tmp        = NULL;
-        gf_rdma_arena_mr   *dummy      = NULL;
-        gf_rdma_private_t  *priv       = NULL;
-        gf_rdma_device_t   *device     = NULL;
-
-        priv = this->private;
-        device = priv->device;
-
-        if (!list_empty(&device->all_mr)) {
-                list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) {
-                        if (tmp->iobuf_arena->mem_base <= ptr &&
-                            ptr < tmp->iobuf_arena->mem_base +
-                            tmp->iobuf_arena->arena_size)
-                                return tmp->mr;
-                        }
-        }
-
-        return NULL;
-}
-
-static int32_t
-gf_rdma_create_posts (rpc_transport_t *this)
-{
-        int32_t            i       = 0, ret = 0;
-        gf_rdma_post_t    *post    = NULL;
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_options_t *options = NULL;
-        gf_rdma_device_t  *device  = NULL;
-
-        priv = this->private;
-        options = &priv->options;
-        device = priv->device;
-
-        ret =  __gf_rdma_create_posts (this, options->send_count,
-                                       options->send_size,
-                                       &device->sendq, GF_RDMA_SEND_POST);
-        if (!ret)
-                ret =  __gf_rdma_create_posts (this, options->recv_count,
-                                               options->recv_size,
-                                               &device->recvq,
-                                               GF_RDMA_RECV_POST);
-
-        if (!ret) {
-                for (i = 0 ; i < options->recv_count ; i++) {
-                        post = gf_rdma_get_post (&device->recvq);
-                        if (gf_rdma_post_recv (device->srq, post) != 0) {
-                                ret = -1;
-                                break;
-                        }
-                }
-        }
-
-        if (ret)
-                gf_rdma_destroy_posts (this);
-
-        return ret;
-}
-
-
-static void
-gf_rdma_destroy_cq (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-
-        priv = this->private;
-        device = priv->device;
-
-        if (device->recv_cq)
-                ibv_destroy_cq (device->recv_cq);
-        device->recv_cq = NULL;
-
-        if (device->send_cq)
-                ibv_destroy_cq (device->send_cq);
-        device->send_cq = NULL;
-
-        return;
-}
-
-
-static int32_t
-gf_rdma_create_cq (rpc_transport_t *this)
-{
-        gf_rdma_private_t      *priv        = NULL;
-        gf_rdma_options_t      *options     = NULL;
-        gf_rdma_device_t       *device      = NULL;
-        uint64_t                send_cqe    = 0;
-        int32_t                 ret         = 0;
-        struct ibv_device_attr  device_attr = {{0}, };
-
-        priv = this->private;
-        options = &priv->options;
-        device = priv->device;
-
-        device->recv_cq = ibv_create_cq (priv->device->context,
-                                         options->recv_count * 2,
-                                         device,
-                                         device->recv_chan,
-                                         0);
-        if (!device->recv_cq) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        RDMA_MSG_CQ_CREATION_FAILED, "creation of CQ for "
-                        "device %s failed", device->device_name);
-                ret = -1;
-                goto out;
-        } else if (ibv_req_notify_cq (device->recv_cq, 0)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED, "ibv_req_notify_"
-                        "cq on recv CQ of device %s failed",
-                        device->device_name);
-                ret = -1;
-                goto out;
-        }
-
-        do {
-                ret = ibv_query_device (priv->device->context, &device_attr);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_QUERY_DEVICE_FAILED, "ibv_query_"
-                                "device on %s returned %d (%s)",
-                                priv->device->device_name, ret,
-                                (ret > 0) ? strerror (ret) : "");
-                        ret = -1;
-                        goto out;
-                }
-
-                send_cqe = options->send_count * 128;
-                send_cqe = (send_cqe > device_attr.max_cqe)
-                        ? device_attr.max_cqe : send_cqe;
-
-                /* TODO: make send_cq size dynamically adaptive */
-                device->send_cq = ibv_create_cq (priv->device->context,
-                                                 send_cqe, device,
-                                                 device->send_chan, 0);
-                if (!device->send_cq) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CQ_CREATION_FAILED,
-                                "creation of send_cq "
-                                "for device %s failed", device->device_name);
-                        ret = -1;
-                        goto out;
-                }
-
-                if (ibv_req_notify_cq (device->send_cq, 0)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED,
-                                "ibv_req_notify_cq on send_cq for device %s"
-                                " failed",  device->device_name);
-                        ret = -1;
-                        goto out;
-                }
-        } while (0);
-
-out:
-        if (ret != 0)
-                gf_rdma_destroy_cq (this);
-
-        return ret;
-}
-
-
-static gf_rdma_device_t *
-gf_rdma_get_device (rpc_transport_t *this, struct ibv_context *ibctx,
-                    char *device_name)
-{
-        glusterfs_ctx_t   *ctx      = NULL;
-        gf_rdma_private_t *priv     = NULL;
-        gf_rdma_options_t *options  = NULL;
-        int32_t            ret      = 0;
-        int32_t            i        = 0;
-        gf_rdma_device_t  *trav     = NULL, *device = NULL;
-        gf_rdma_ctx_t     *rdma_ctx = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-
-        priv        = this->private;
-        options     = &priv->options;
-        ctx         = this->ctx;
-        rdma_ctx    = ctx->ib;
-        iobuf_pool = ctx->iobuf_pool;
-
-        trav = rdma_ctx->device;
-
-        while (trav) {
-                if (!strcmp (trav->device_name, device_name))
-                        break;
-                trav = trav->next;
-        }
-
-        if (!trav) {
-                trav = GF_CALLOC (1, sizeof (*trav),
-                                  gf_common_mt_rdma_device_t);
-                if (trav == NULL) {
-                        goto out;
-                }
-                priv->device = trav;
-                trav->context = ibctx;
-
-                trav->next = rdma_ctx->device;
-                rdma_ctx->device = trav;
-
-                iobuf_pool->device[iobuf_pool->rdma_device_count] = trav;
-                iobuf_pool->mr_list[iobuf_pool->rdma_device_count++] = &trav->all_mr;
-                trav->request_ctx_pool
-                        = mem_pool_new (gf_rdma_request_context_t,
-                                        GF_RDMA_POOL_SIZE);
-                if (trav->request_ctx_pool == NULL) {
-                        goto out;
-                }
-
-                trav->ioq_pool
-                        = mem_pool_new (gf_rdma_ioq_t, GF_RDMA_POOL_SIZE);
-                if (trav->ioq_pool == NULL) {
-                        goto out;
-                }
-
-                trav->reply_info_pool = mem_pool_new (gf_rdma_reply_info_t,
-                                                      GF_RDMA_POOL_SIZE);
-                if (trav->reply_info_pool == NULL) {
-                        goto out;
-                }
-
-                trav->device_name = gf_strdup (device_name);
-
-                trav->send_chan = ibv_create_comp_channel (trav->context);
-                if (!trav->send_chan) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_SEND_COMP_CHAN_FAILED, "could not "
-                                "create send completion channel for "
-                                "device (%s)", device_name);
-                        goto out;
-                }
-
-                trav->recv_chan = ibv_create_comp_channel (trav->context);
-                if (!trav->recv_chan) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_RECV_COMP_CHAN_FAILED, "could not "
-                                "create recv completion channel for "
-                                "device (%s)", device_name);
-
-                        /* TODO: cleanup current mess */
-                        goto out;
-                }
-
-                if (gf_rdma_create_cq (this) < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CQ_CREATION_FAILED,
-                                "could not create CQ for device (%s)",
-                                device_name);
-                        goto out;
-                }
-
-                /* protection domain */
-                trav->pd = ibv_alloc_pd (trav->context);
-
-                if (!trav->pd) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ALOC_PROT_DOM_FAILED, "could not "
-                                "allocate protection domain for device (%s)",
-                                device_name);
-                        goto out;
-                }
-
-                struct ibv_srq_init_attr attr = {
-                        .attr = {
-                                .max_wr = options->recv_count,
-                                .max_sge = 1,
-                                .srq_limit = 10
-                        }
-                };
-                trav->srq = ibv_create_srq (trav->pd, &attr);
-
-                if (!trav->srq) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CRE_SRQ_FAILED, "could not create SRQ"
-                                " for device (%s)",
-                                device_name);
-                        goto out;
-                }
-
-                /* queue init */
-                gf_rdma_queue_init (&trav->sendq);
-                gf_rdma_queue_init (&trav->recvq);
-
-                INIT_LIST_HEAD (&trav->all_mr);
-                gf_rdma_register_iobuf_pool(trav, iobuf_pool);
-
-                if (gf_rdma_create_posts (this) < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ALOC_POST_FAILED, "could not allocate"
-                                "posts for device (%s)", device_name);
-                        goto out;
-                }
-
-                /* completion threads */
-                ret = gf_thread_create (&trav->send_thread, NULL,
-                                        gf_rdma_send_completion_proc,
-                                        trav->send_chan, "rdmascom");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_SEND_COMP_THREAD_FAILED,
-                                "could not create send completion thread for "
-                                "device (%s)", device_name);
-                        goto out;
-                }
-
-                ret = gf_thread_create (&trav->recv_thread, NULL,
-                                        gf_rdma_recv_completion_proc,
-                                        trav->recv_chan, "rdmarcom");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_RECV_COMP_THREAD_FAILED,
-                                "could not create recv completion thread "
-                                "for device (%s)", device_name);
-                        return NULL;
-                }
-
-                ret = gf_thread_create (&trav->async_event_thread, NULL,
-                                        gf_rdma_async_event_thread,
-                                        ibctx, "rdmaAsyn");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ASYNC_EVENT_THEAD_FAILED,
-                                "could not create async_event_thread");
-                        return NULL;
-                }
-
-                /* qpreg */
-                pthread_mutex_init (&trav->qpreg.lock, NULL);
-                for (i = 0; i < 42; i++) {
-                        trav->qpreg.ents[i].next = &trav->qpreg.ents[i];
-                        trav->qpreg.ents[i].prev = &trav->qpreg.ents[i];
-                }
-        }
-
-        device = trav;
-        trav = NULL;
-out:
-
-        if (trav != NULL) {
-                rdma_ctx->device = trav->next;
-                gf_rdma_destroy_posts (this);
-                mem_pool_destroy (trav->ioq_pool);
-                mem_pool_destroy (trav->request_ctx_pool);
-                mem_pool_destroy (trav->reply_info_pool);
-                if (trav->pd != NULL) {
-                        ibv_dealloc_pd (trav->pd);
-                }
-                gf_rdma_destroy_cq (this);
-                ibv_destroy_comp_channel (trav->recv_chan);
-                ibv_destroy_comp_channel (trav->send_chan);
-                GF_FREE ((char *)trav->device_name);
-                GF_FREE (trav);
-        }
-
-        return device;
-}
-
-
-static rpc_transport_t *
-gf_rdma_transport_new (rpc_transport_t *listener, struct rdma_cm_id *cm_id)
-{
-        gf_rdma_private_t *listener_priv = NULL, *priv = NULL;
-        rpc_transport_t   *this          = NULL, *new = NULL;
-        gf_rdma_options_t *options       = NULL;
-        char              *device_name   = NULL;
-
-        listener_priv = listener->private;
-
-        this = GF_CALLOC (1, sizeof (rpc_transport_t),
-                          gf_common_mt_rpc_transport_t);
-        if (this == NULL) {
-                goto out;
-        }
-
-        this->listener = listener;
-
-        priv = GF_CALLOC (1, sizeof (gf_rdma_private_t),
-                          gf_common_mt_rdma_private_t);
-        if (priv == NULL) {
-                goto out;
-        }
-
-        this->private = priv;
-        priv->options = listener_priv->options;
-
-        priv->listener = listener;
-        priv->entity = GF_RDMA_SERVER;
-
-        options = &priv->options;
-
-        this->ops = listener->ops;
-        this->init = listener->init;
-        this->fini = listener->fini;
-        this->ctx = listener->ctx;
-        this->name = gf_strdup (listener->name);
-        this->notify = listener->notify;
-        this->mydata = listener->mydata;
-        this->xl = listener->xl;
-
-        this->myinfo.sockaddr_len = sizeof (cm_id->route.addr.src_addr);
-        memcpy (&this->myinfo.sockaddr, &cm_id->route.addr.src_addr,
-                this->myinfo.sockaddr_len);
-
-        this->peerinfo.sockaddr_len = sizeof (cm_id->route.addr.dst_addr);
-        memcpy (&this->peerinfo.sockaddr, &cm_id->route.addr.dst_addr,
-                this->peerinfo.sockaddr_len);
-
-        priv->peer.trans = this;
-        gf_rdma_get_transport_identifiers (this);
-
-        device_name = (char *)ibv_get_device_name (cm_id->verbs->device);
-        if (device_name == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get device "
-                        "name (peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                goto out;
-        }
-
-        priv->device = gf_rdma_get_device (this, cm_id->verbs,
-                                           device_name);
-        if (priv->device == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_IB_DEVICE_FAILED, "cannot get infiniband"
-                        " device %s (peer:%s me:%s)", device_name,
-                        this->peerinfo.identifier, this->myinfo.identifier);
-                goto out;
-        }
-
-        priv->peer.send_count = options->send_count;
-        priv->peer.recv_count = options->recv_count;
-        priv->peer.send_size = options->send_size;
-        priv->peer.recv_size = options->recv_size;
-        priv->peer.cm_id = cm_id;
-        INIT_LIST_HEAD (&priv->peer.ioq);
-
-        pthread_mutex_init (&priv->write_mutex, NULL);
-        pthread_mutex_init (&priv->recv_mutex, NULL);
-
-        cm_id->context = this;
-
-        new = rpc_transport_ref (this);
-        this = NULL;
-out:
-        if (this != NULL) {
-                if (this->private != NULL) {
-                        GF_FREE (this->private);
-                }
-
-                if (this->name != NULL) {
-                        GF_FREE (this->name);
-                }
-
-                GF_FREE (this);
-        }
-
-        return new;
-}
-
-
-static int
-gf_rdma_cm_handle_connect_request (struct rdma_cm_event *event)
-{
-        int                     ret         = -1;
-        rpc_transport_t        *this        = NULL, *listener = NULL;
-        struct rdma_cm_id      *child_cm_id = NULL, *listener_cm_id = NULL;
-        struct rdma_conn_param  conn_param  = {0, };
-        gf_rdma_private_t      *priv        = NULL;
-        gf_rdma_options_t      *options     = NULL;
-
-        child_cm_id = event->id;
-        listener_cm_id = event->listen_id;
-
-        listener = listener_cm_id->context;
-        priv = listener->private;
-        options = &priv->options;
-
-        this = gf_rdma_transport_new (listener, child_cm_id);
-        if (this == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_INC_TRANS_FAILED, "could not create "
-                        "a transport for incoming connection"
-                        " (me.name:%s me.identifier:%s)", listener->name,
-                        listener->myinfo.identifier);
-                rdma_destroy_id (child_cm_id);
-                goto out;
-        }
-
-        gf_msg_trace (listener->name, 0, "got a connect request (me:%s peer:"
-                      "%s)", listener->myinfo.identifier,
-                      this->peerinfo.identifier);
-
-        ret = gf_rdma_create_qp (this);
-        if (ret < 0) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_QP_FAILED, "could not create QP "
-                        "(peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
-        }
-
-        conn_param.responder_resources = 1;
-        conn_param.initiator_depth = 1;
-        conn_param.retry_count = options->attr_retry_cnt;
-        conn_param.rnr_retry_count = options->attr_rnr_retry;
-
-        ret = rdma_accept(child_cm_id, &conn_param);
-        if (ret < 0) {
-                gf_msg (listener->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_ACCEPT_FAILED, "rdma_accept failed peer:%s "
-                        "me:%s", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
-        }
-        gf_rdma_cm_handle_connect_init (event);
-        ret = 0;
-
-out:
-        return ret;
-}
-
-
-static int
-gf_rdma_cm_handle_route_resolved (struct rdma_cm_event *event)
-{
-        struct rdma_conn_param  conn_param = {0, };
-        int                     ret        = 0;
-        rpc_transport_t        *this       = NULL;
-        gf_rdma_private_t      *priv       = NULL;
-        gf_rdma_peer_t         *peer       = NULL;
-        gf_rdma_options_t      *options    = NULL;
-
-        if (event == NULL) {
-                goto out;
-        }
-
-        this = event->id->context;
-
-        priv = this->private;
-        peer = &priv->peer;
-        options = &priv->options;
-
-        ret = gf_rdma_create_qp (this);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_QP_FAILED, "could not create QP "
-                        "(peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
-        }
-
-        memset(&conn_param, 0, sizeof conn_param);
-        conn_param.responder_resources = 1;
-        conn_param.initiator_depth = 1;
-        conn_param.retry_count = options->attr_retry_cnt;
-        conn_param.rnr_retry_count = options->attr_rnr_retry;
-
-        ret = rdma_connect(peer->cm_id, &conn_param);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CONNECT_FAILED,
-                        "rdma_connect failed");
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
-        }
-
-        gf_msg_trace (this->name, 0, "route resolved (me:%s peer:%s)",
-                      this->myinfo.identifier, this->peerinfo.identifier);
-
-        ret = 0;
-out:
-        return ret;
-}
-
-
-static int
-gf_rdma_cm_handle_addr_resolved (struct rdma_cm_event *event)
-{
-        rpc_transport_t   *this = NULL;
-        gf_rdma_peer_t    *peer = NULL;
-        gf_rdma_private_t *priv = NULL;
-        int                ret  = 0;
-
-        this = event->id->context;
-
-        priv = this->private;
-        peer = &priv->peer;
-
-        GF_ASSERT (peer->cm_id == event->id);
-
-        this->myinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.src_addr);
-        memcpy (&this->myinfo.sockaddr, &peer->cm_id->route.addr.src_addr,
-                this->myinfo.sockaddr_len);
-
-        this->peerinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.dst_addr);
-        memcpy (&this->peerinfo.sockaddr, &peer->cm_id->route.addr.dst_addr,
-                this->peerinfo.sockaddr_len);
-
-        gf_rdma_get_transport_identifiers (this);
-
-        ret = rdma_resolve_route(peer->cm_id, 2000);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_ROUTE_RESOLVE_FAILED, "rdma_resolve_route "
-                        "failed (me:%s peer:%s)",
-                        this->myinfo.identifier, this->peerinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                return ret;
-        }
-
-        gf_msg_trace (this->name, 0, "Address resolved (me:%s peer:%s)",
-                      this->myinfo.identifier, this->peerinfo.identifier);
-
-        return ret;
-}
-
-
-static void
-gf_rdma_cm_handle_disconnect (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv       = NULL;
-        char               need_unref = 0;
-
-        priv = this->private;
-        gf_msg_debug (this->name, 0, "peer disconnected, cleaning up");
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (priv->peer.cm_id != NULL) {
-                        need_unref = 1;
-                        priv->connected = 0;
-                }
-
-                __gf_rdma_teardown (this);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this);
-
-        if (need_unref)
-                rpc_transport_unref (this);
-
-}
-
-
-static int
-gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event)
-{
-        rpc_transport_t   *this  = NULL;
-        gf_rdma_private_t *priv  = NULL;
-        struct rdma_cm_id *cm_id = NULL;
-        int                ret   = 0;
-
-        cm_id = event->id;
-        this = cm_id->context;
-        priv = this->private;
-
-        if (priv->connected == 1) {
-                gf_msg_trace (this->name, 0, "received event "
-                              "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
-                              this->myinfo.identifier,
-                              this->peerinfo.identifier);
-                return ret;
-        }
-
-        priv->connected = 1;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                priv->peer.quota = 1;
-                priv->peer.quota_set = 0;
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        if (priv->entity == GF_RDMA_CLIENT) {
-                gf_msg_trace (this->name, 0, "received event "
-                              "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
-                              this->myinfo.identifier,
-                              this->peerinfo.identifier);
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_CONNECT, this);
-
-        } else if (priv->entity == GF_RDMA_SERVER) {
-                ret = rpc_transport_notify (priv->listener,
-                                            RPC_TRANSPORT_ACCEPT, this);
-        }
-
-        if (ret < 0) {
-                gf_rdma_disconnect (this, _gf_false);
-        }
-
-        return ret;
-}
-
-
-static int
-gf_rdma_cm_handle_event_error (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv  = NULL;
-
-        priv = this->private;
-
-        if (priv->entity != GF_RDMA_SERVER_LISTENER) {
-                gf_rdma_cm_handle_disconnect (this);
-        }
-
-        return 0;
-}
-
-
-static int
-gf_rdma_cm_handle_device_removal (struct rdma_cm_event *event)
-{
-        return 0;
-}
-
-
-static void *
-gf_rdma_cm_event_handler (void *data)
-{
-        struct rdma_cm_event      *event         = NULL;
-        int                        ret           = 0;
-        rpc_transport_t           *this          = NULL;
-        struct rdma_event_channel *event_channel = NULL;
-
-        event_channel = data;
-
-        while (1) {
-                ret = rdma_get_cm_event (event_channel, &event);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_CM_EVENT_FAILED,
-                                "rdma_cm_get_event failed");
-                        break;
-                }
-
-                switch (event->event) {
-                case RDMA_CM_EVENT_ADDR_RESOLVED:
-                        gf_rdma_cm_handle_addr_resolved (event);
-                        break;
-
-                case RDMA_CM_EVENT_ROUTE_RESOLVED:
-                        gf_rdma_cm_handle_route_resolved (event);
-                        break;
-
-                case RDMA_CM_EVENT_CONNECT_REQUEST:
-                        gf_rdma_cm_handle_connect_request (event);
-                        break;
-
-                case RDMA_CM_EVENT_ESTABLISHED:
-                        gf_rdma_cm_handle_connect_init (event);
-                        break;
-
-                case RDMA_CM_EVENT_ADDR_ERROR:
-                case RDMA_CM_EVENT_ROUTE_ERROR:
-                case RDMA_CM_EVENT_CONNECT_ERROR:
-                case RDMA_CM_EVENT_UNREACHABLE:
-                case RDMA_CM_EVENT_REJECTED:
-                        this = event->id->context;
-
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED, "cma event %s, "
-                                "error %d (me:%s peer:%s)\n",
-                                rdma_event_str(event->event), event->status,
-                                this->myinfo.identifier,
-                                this->peerinfo.identifier);
-
-                        rdma_ack_cm_event (event);
-                        event = NULL;
-
-                        gf_rdma_cm_handle_event_error (this);
-                        continue;
-
-                case RDMA_CM_EVENT_DISCONNECTED:
-                        this = event->id->context;
-
-                        gf_msg_debug (this->name, 0, "received disconnect "
-                                      "(me:%s peer:%s)\n",
-                                      this->myinfo.identifier,
-                                      this->peerinfo.identifier);
-
-                        rdma_ack_cm_event (event);
-                        event = NULL;
-
-                        gf_rdma_cm_handle_disconnect (this);
-                        continue;
-
-                case RDMA_CM_EVENT_DEVICE_REMOVAL:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED, "device "
-                                "removed");
-                        gf_rdma_cm_handle_device_removal (event);
-                        break;
-
-                default:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED,
-                                "unhandled event: %s, ignoring",
-                                rdma_event_str(event->event));
-                        break;
-                }
-
-                rdma_ack_cm_event (event);
-        }
-
-        return NULL;
-}
-
-
-static int32_t
-gf_rdma_post_send (struct ibv_qp *qp, gf_rdma_post_t *post, int32_t len)
-{
-        struct ibv_sge list = {
-                .addr = (unsigned long) post->buf,
-                .length = len,
-                .lkey = post->mr->lkey
-        };
-
-        struct ibv_send_wr wr = {
-                .wr_id      = (unsigned long) post,
-                .sg_list    = &list,
-                .num_sge    = 1,
-                .opcode     = IBV_WR_SEND,
-                .send_flags = IBV_SEND_SIGNALED,
-        }, *bad_wr;
-
-        if (!qp)
-                return EINVAL;
-
-        return ibv_post_send (qp, &wr, &bad_wr);
-}
-
-int
-__gf_rdma_encode_error(gf_rdma_peer_t *peer, gf_rdma_reply_info_t *reply_info,
-                       struct iovec *rpchdr, gf_rdma_header_t *hdr,
-                       gf_rdma_errcode_t err)
-{
-        struct rpc_msg *rpc_msg = NULL;
-
-        if (reply_info != NULL) {
-                hdr->rm_xid = hton32(reply_info->rm_xid);
-        } else {
-                rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
-                                               * only one vector.
-                                               * (which is true)
-                                               */
-                hdr->rm_xid = rpc_msg->rm_xid;
-        }
-
-        hdr->rm_vers = hton32(GF_RDMA_VERSION);
-        hdr->rm_credit = hton32(peer->send_count);
-        hdr->rm_type = hton32(GF_RDMA_ERROR);
-        hdr->rm_body.rm_error.rm_type = hton32(err);
-        if (err == ERR_VERS) {
-                hdr->rm_body.rm_error.rm_version.gf_rdma_vers_low
-                        = hton32(GF_RDMA_VERSION);
-                hdr->rm_body.rm_error.rm_version.gf_rdma_vers_high
-                        = hton32(GF_RDMA_VERSION);
-        }
-
-        return sizeof (*hdr);
-}
-
-
-int32_t
-__gf_rdma_send_error (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                      gf_rdma_post_t *post, gf_rdma_reply_info_t *reply_info,
-                      gf_rdma_errcode_t err)
-{
-        int32_t  ret = -1, len = 0;
-
-        len = __gf_rdma_encode_error (peer, reply_info, entry->rpchdr,
-                                      (gf_rdma_header_t *)post->buf, err);
-        if (len == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encode error returned -1");
-                goto out;
-        }
-
-        gf_rdma_post_ref (post);
-
-        ret = gf_rdma_post_send (peer->qp, post, len);
-        if (!ret) {
-                ret = len;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED,
-                        "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
-
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_create_read_chunks_from_vector (gf_rdma_peer_t *peer,
-                                          gf_rdma_read_chunk_t **readch_ptr,
-                                          int32_t *pos, struct iovec *vector,
-                                          int count,
-                                          gf_rdma_request_context_t *request_ctx)
-{
-        int                   i      = 0;
-        gf_rdma_private_t    *priv   = NULL;
-        gf_rdma_device_t     *device = NULL;
-        struct ibv_mr        *mr     = NULL;
-        gf_rdma_read_chunk_t *readch = NULL;
-        int32_t               ret    = -1;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, readch_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *readch_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
-
-        priv = peer->trans->private;
-        device = priv->device;
-        readch = *readch_ptr;
-
-        for (i = 0; i < count; i++) {
-                readch->rc_discrim = hton32 (1);
-                readch->rc_position = hton32 (*pos);
-
-                mr = gf_rdma_get_pre_registred_mr(peer->trans,
-                                (void *)vector[i].iov_base, vector[i].iov_len);
-                if (!mr) {
-                mr = ibv_reg_mr (device->pd, vector[i].iov_base,
-                                 vector[i].iov_len,
-                                 IBV_ACCESS_REMOTE_READ);
-                }
-                if (!mr) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED,
-                                "memory registration failed (peer:%s)",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
-
-                request_ctx->mr[request_ctx->mr_count++] = mr;
-
-                readch->rc_target.rs_handle = hton32 (mr->rkey);
-                readch->rc_target.rs_length
-                        = hton32 (vector[i].iov_len);
-                readch->rc_target.rs_offset
-                        = hton64 ((uint64_t)(unsigned long)vector[i].iov_base);
-
-                *pos = *pos + vector[i].iov_len;
-                readch++;
-        }
-
-        *readch_ptr = readch;
-
-        ret = 0;
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_create_read_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                              gf_rdma_chunktype_t type, uint32_t **ptr,
-                              gf_rdma_request_context_t *request_ctx)
-{
-        int32_t            ret      = -1;
-        int                pos      = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-
-        request_ctx->iobref = iobref_ref (entry->iobref);
-
-        if (type == gf_rdma_areadch) {
-                pos = 0;
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->rpchdr,
-                                                                entry->rpchdr_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->rpchdr");
-                        goto out;
-                }
-
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->proghdr,
-                                                                entry->proghdr_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->proghdr");
-                }
-
-                if (entry->prog_payload_count != 0) {
-                        ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                        (gf_rdma_read_chunk_t **)ptr,
-                                                                        &pos,
-                                                                        entry->prog_payload,
-                                                                        entry->prog_payload_count,
-                                                                        request_ctx);
-                        if (ret == -1) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                        "cannot create read chunks from vector"
-                                        " entry->prog_payload");
-                        }
-                }
-        } else {
-                pos = iov_length (entry->rpchdr, entry->rpchdr_count);
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->prog_payload,
-                                                                entry->prog_payload_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->prog_payload");
-                }
-        }
-
-        /* terminate read-chunk list*/
-        **ptr = 0;
-        *ptr = *ptr + 1;
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_create_write_chunks_from_vector (gf_rdma_peer_t *peer,
-                                           gf_rdma_write_chunk_t **writech_ptr,
-                                           struct iovec *vector, int count,
-                                           gf_rdma_request_context_t *request_ctx)
-{
-        int                    i       = 0;
-        gf_rdma_private_t     *priv    = NULL;
-        gf_rdma_device_t      *device  = NULL;
-        struct ibv_mr         *mr      = NULL;
-        gf_rdma_write_chunk_t *writech = NULL;
-        int32_t                ret     = -1;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, writech_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *writech_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
-
-        writech = *writech_ptr;
-
-        priv = peer->trans->private;
-        device = priv->device;
-
-        for (i = 0; i < count; i++) {
-
-                mr = gf_rdma_get_pre_registred_mr(peer->trans,
-                                (void *)vector[i].iov_base, vector[i].iov_len);
-                if (!mr) {
-                mr = ibv_reg_mr (device->pd, vector[i].iov_base,
-                                 vector[i].iov_len,
-                                 IBV_ACCESS_REMOTE_WRITE
-                                 | IBV_ACCESS_LOCAL_WRITE);
-                }
-
-                if (!mr) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED, "memory "
-                                "registration failed (peer:%s)",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
-
-                request_ctx->mr[request_ctx->mr_count++] = mr;
-
-                writech->wc_target.rs_handle = hton32 (mr->rkey);
-                writech->wc_target.rs_length = hton32 (vector[i].iov_len);
-                writech->wc_target.rs_offset
-                        = hton64 (((uint64_t)(unsigned long)vector[i].iov_base));
-
-                writech++;
-        }
-
-        *writech_ptr = writech;
-
-        ret = 0;
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_create_write_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                               gf_rdma_chunktype_t chunk_type, uint32_t **ptr,
-                               gf_rdma_request_context_t *request_ctx)
-{
-        int32_t                ret    = -1;
-        gf_rdma_write_array_t *warray = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-
-        if ((chunk_type == gf_rdma_replych)
-            && ((entry->msg.request.rsphdr_count != 1) ||
-                (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_BUFFER_ERROR,
-                        (entry->msg.request.rsphdr_count == 1)
-                        ? "chunktype specified as reply chunk but the vector "
-                        "specifying the buffer to be used for holding reply"
-                        " header is not correct" :
-                        "chunktype specified as reply chunk, but more than one "
-                        "buffer provided for holding reply");
-                goto out;
-        }
-
-/*
-  if ((chunk_type == gf_rdma_writech)
-  && ((entry->msg.request.rsphdr_count == 0)
-  || (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
-  gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-  "vector specifying buffer to hold the program's reply "
-  "header should also be provided when buffers are "
-  "provided for holding the program's payload in reply");
-  goto out;
-  }
-*/
-
-        if (chunk_type == gf_rdma_writech) {
-                warray = (gf_rdma_write_array_t *)*ptr;
-                warray->wc_discrim = hton32 (1);
-                warray->wc_nchunks
-                        = hton32 (entry->msg.request.rsp_payload_count);
-
-                *ptr = (uint32_t *)&warray->wc_array[0];
-
-                ret = __gf_rdma_create_write_chunks_from_vector (peer,
-                                                                 (gf_rdma_write_chunk_t **)ptr,
-                                                                 entry->msg.request.rsp_payload,
-                                                                 entry->msg.request.rsp_payload_count,
-                                                                 request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
-                                "cannot create write chunks from vector "
-                                "entry->rpc_payload");
-                        goto out;
-                }
-
-                /* terminate write chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-
-                /* no reply chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-        } else {
-                /* no write chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-
-                warray = (gf_rdma_write_array_t *)*ptr;
-                warray->wc_discrim = hton32 (1);
-                warray->wc_nchunks = hton32 (entry->msg.request.rsphdr_count);
-
-                *ptr = (uint32_t *)&warray->wc_array[0];
-
-                ret = __gf_rdma_create_write_chunks_from_vector (peer,
-                                                                 (gf_rdma_write_chunk_t **)ptr,
-                                                                 entry->msg.request.rsphdr_vec,
-                                                                 entry->msg.request.rsphdr_count,
-                                                                 request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
-                                "cannot create write chunks from vector "
-                                "entry->rpchdr");
-                        goto out;
-                }
-
-                /* terminate reply chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-        }
-
-out:
-        return ret;
-}
-
-
-static void
-__gf_rdma_deregister_mr (gf_rdma_device_t *device,
-                         struct ibv_mr **mr, int count)
-{
-        gf_rdma_arena_mr    *tmp   = NULL;
-        gf_rdma_arena_mr    *dummy = NULL;
-        int                  i     = 0;
-        int                  found = 0;
-
-               if (mr == NULL) {
-                goto out;
-        }
-
-        for (i = 0; i < count; i++) {
-                 found = 0;
-                 if (!list_empty(&device->all_mr)) {
-                 list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) {
-                        if (tmp->mr == mr[i]) {
-                                found = 1;
-                                break;
-                        }
-                 }
-                 }
-                if (!found)
-                        ibv_dereg_mr (mr[i]);
-
-        }
-
-out:
-        return;
-}
-
-
-static int32_t
-__gf_rdma_quota_put (gf_rdma_peer_t *peer)
-{
-        int32_t ret = 0;
-
-        peer->quota++;
-        ret = peer->quota;
-
-        if (!list_empty (&peer->ioq)) {
-                ret = __gf_rdma_ioq_churn (peer);
-        }
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_quota_put (gf_rdma_peer_t *peer)
-{
-        int32_t            ret  = 0;
-        gf_rdma_private_t *priv = NULL;
-
-        priv = peer->trans->private;
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_quota_put (peer);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        return ret;
-}
-
-
-/* to be called with priv->mutex held */
-void
-__gf_rdma_request_context_destroy (gf_rdma_request_context_t *context)
-{
-        gf_rdma_peer_t    *peer   = NULL;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-        int32_t            ret    = 0;
-
-        if (context == NULL) {
-                goto out;
-        }
-
-        peer = context->peer;
-
-        priv = peer->trans->private;
-        device = priv->device;
-        __gf_rdma_deregister_mr (device, context->mr, context->mr_count);
-
-
-        if (priv->connected) {
-                ret = __gf_rdma_quota_put (peer);
-                if (ret < 0) {
-                        gf_msg_debug ("rdma", 0, "failed to send message");
-                        mem_put (context);
-                        __gf_rdma_disconnect (peer->trans);
-                        goto out;
-                }
-        }
-
-        if (context->iobref != NULL) {
-                iobref_unref (context->iobref);
-                context->iobref = NULL;
-        }
-
-        if (context->rsp_iobref != NULL) {
-                iobref_unref (context->rsp_iobref);
-                context->rsp_iobref = NULL;
-        }
-
-        mem_put (context);
-
-out:
-        return;
-}
-
-
-void
-gf_rdma_post_context_destroy (gf_rdma_device_t *device,
-                              gf_rdma_post_context_t *ctx)
-{
-        if (ctx == NULL) {
-                goto out;
-        }
-
-        __gf_rdma_deregister_mr (device, ctx->mr, ctx->mr_count);
-
-        if (ctx->iobref != NULL) {
-                iobref_unref (ctx->iobref);
-        }
-
-        if (ctx->hdr_iobuf != NULL) {
-                iobuf_unref (ctx->hdr_iobuf);
-        }
-
-        memset (ctx, 0, sizeof (*ctx));
-out:
-        return;
-}
-
-
-int
-gf_rdma_post_unref (gf_rdma_post_t *post)
-{
-        int refcount = -1;
-
-        if (post == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&post->lock);
-        {
-                refcount = --post->refcount;
-        }
-        pthread_mutex_unlock (&post->lock);
-
-        if (refcount == 0) {
-                gf_rdma_post_context_destroy (post->device, &post->ctx);
-                if (post->type == GF_RDMA_SEND_POST) {
-                        gf_rdma_put_post (&post->device->sendq, post);
-                } else {
-                        gf_rdma_post_recv (post->device->srq, post);
-                }
-        }
-out:
-        return refcount;
-}
-
-
-int
-gf_rdma_post_get_refcount (gf_rdma_post_t *post)
-{
-        int refcount = -1;
-
-        if (post == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&post->lock);
-        {
-                refcount = post->refcount;
-        }
-        pthread_mutex_unlock (&post->lock);
-
-out:
-        return refcount;
-}
-
-gf_rdma_post_t *
-gf_rdma_post_ref (gf_rdma_post_t *post)
-{
-        if (post == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&post->lock);
-        {
-                post->refcount++;
-        }
-        pthread_mutex_unlock (&post->lock);
-
-out:
-        return post;
-}
-
-
-int32_t
-__gf_rdma_ioq_churn_request (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                             gf_rdma_post_t *post)
-{
-        gf_rdma_chunktype_t        rtype               = gf_rdma_noch;
-        gf_rdma_chunktype_t        wtype               = gf_rdma_noch;
-        uint64_t                   send_size           = 0;
-        gf_rdma_header_t          *hdr                 = NULL;
-        struct rpc_msg            *rpc_msg             = NULL;
-        uint32_t                  *chunkptr            = NULL;
-        char                      *buf                 = NULL;
-        int32_t                    ret                 = 0;
-        gf_rdma_private_t         *priv                = NULL;
-        gf_rdma_device_t          *device              = NULL;
-        int                        chunk_count         = 0;
-        gf_rdma_request_context_t *request_ctx         = NULL;
-        uint32_t                   prog_payload_length = 0, len = 0;
-        struct rpc_req            *rpc_req             = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out);
-
-        if ((entry->msg.request.rsphdr_count != 0)
-            && (entry->msg.request.rsp_payload_count != 0)) {
-                ret = -1;
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT,
-                        "both write-chunklist and reply-chunk cannot be "
-                        "present");
-                goto out;
-        }
-
-        post->ctx.is_request = 1;
-        priv = peer->trans->private;
-        device = priv->device;
-
-        hdr = (gf_rdma_header_t *)post->buf;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + GLUSTERFS_RDMA_MAX_HEADER_SIZE;
-
-        if (entry->prog_payload_count != 0) {
-                prog_payload_length
-                        = iov_length (entry->prog_payload,
-                                      entry->prog_payload_count);
-        }
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                rtype = gf_rdma_areadch;
-        } else if ((send_size + prog_payload_length)
-                   < GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                rtype = gf_rdma_noch;
-        } else if (entry->prog_payload_count != 0) {
-                rtype = gf_rdma_readch;
-        }
-
-        if (entry->msg.request.rsphdr_count != 0) {
-                wtype = gf_rdma_replych;
-        } else if (entry->msg.request.rsp_payload_count != 0) {
-                wtype = gf_rdma_writech;
-        }
-
-        if (rtype == gf_rdma_readch) {
-                chunk_count += entry->prog_payload_count;
-        } else if (rtype == gf_rdma_areadch) {
-                chunk_count += entry->rpchdr_count;
-                chunk_count += entry->proghdr_count;
-        }
-
-        if (wtype == gf_rdma_writech) {
-                chunk_count += entry->msg.request.rsp_payload_count;
-        } else if (wtype == gf_rdma_replych) {
-                chunk_count += entry->msg.request.rsphdr_count;
-        }
-
-        if (chunk_count > GF_RDMA_MAX_SEGMENTS) {
-                ret = -1;
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS,
-                        "chunk count(%d) exceeding maximum allowed RDMA "
-                        "segment count(%d)", chunk_count, GF_RDMA_MAX_SEGMENTS);
-                goto out;
-        }
-
-        if ((wtype != gf_rdma_noch) || (rtype != gf_rdma_noch)) {
-                request_ctx = mem_get (device->request_ctx_pool);
-                if (request_ctx == NULL) {
-                        ret = -1;
-                        goto out;
-                }
-
-                memset (request_ctx, 0, sizeof (*request_ctx));
-
-                request_ctx->pool = device->request_ctx_pool;
-                request_ctx->peer = peer;
-
-                entry->msg.request.rpc_req->conn_private = request_ctx;
-
-                if (entry->msg.request.rsp_iobref != NULL) {
-                        request_ctx->rsp_iobref
-                                = iobref_ref (entry->msg.request.rsp_iobref);
-                }
-        }
-
-        rpc_msg = (struct rpc_msg *) entry->rpchdr[0].iov_base;
-
-        hdr->rm_xid    = rpc_msg->rm_xid; /* no need of hton32(rpc_msg->rm_xid),
-                                           * since rpc_msg->rm_xid is already
-                                           * hton32ed value of actual xid
-                                           */
-        hdr->rm_vers   = hton32 (GF_RDMA_VERSION);
-        hdr->rm_credit = hton32 (peer->send_count);
-        if (rtype == gf_rdma_areadch) {
-                hdr->rm_type = hton32 (GF_RDMA_NOMSG);
-        } else {
-                hdr->rm_type   = hton32 (GF_RDMA_MSG);
-        }
-
-        chunkptr = &hdr->rm_body.rm_chunks[0];
-        if (rtype != gf_rdma_noch) {
-                ret = __gf_rdma_create_read_chunks (peer, entry, rtype,
-                                                    &chunkptr,
-                                                    request_ctx);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CREATE_READ_CHUNK_FAILED,
-                                "creation of read chunks failed");
-                        goto out;
-                }
-        } else {
-                *chunkptr++ = 0; /* no read chunks */
-        }
-
-        if (wtype != gf_rdma_noch) {
-                ret = __gf_rdma_create_write_chunks (peer, entry, wtype,
-                                                     &chunkptr,
-                                                     request_ctx);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CREATE_WRITE_REPLAY_FAILED,
-                                "creation of write/reply chunk failed");
-                        goto out;
-                }
-        } else {
-                *chunkptr++ = 0; /* no write chunks */
-                *chunkptr++ = 0; /* no reply chunk */
-        }
-
-        buf = (char *)chunkptr;
-
-        if (rtype != gf_rdma_areadch) {
-                iov_unload (buf, entry->rpchdr, entry->rpchdr_count);
-                buf += iov_length (entry->rpchdr, entry->rpchdr_count);
-
-                iov_unload (buf, entry->proghdr, entry->proghdr_count);
-                buf += iov_length (entry->proghdr, entry->proghdr_count);
-
-                if (rtype != gf_rdma_readch) {
-                        iov_unload (buf, entry->prog_payload,
-                                    entry->prog_payload_count);
-                        buf += iov_length (entry->prog_payload,
-                                           entry->prog_payload_count);
-                }
-        }
-
-        len = buf - post->buf;
-
-        gf_rdma_post_ref (post);
-
-        ret = gf_rdma_post_send (peer->qp, post, len);
-        if (!ret) {
-                ret = len;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED,
-                        "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
-
-out:
-        if (ret == -1) {
-                rpc_req = entry->msg.request.rpc_req;
-
-                if (request_ctx != NULL) {
-                        __gf_rdma_request_context_destroy (rpc_req->conn_private);
-                }
-
-                rpc_req->conn_private = NULL;
-        }
-
-        return ret;
-}
-
-
-static void
-__gf_rdma_fill_reply_header (gf_rdma_header_t *header, struct iovec *rpchdr,
-                             gf_rdma_reply_info_t *reply_info, int credits)
-{
-        struct rpc_msg *rpc_msg = NULL;
-
-        if (reply_info != NULL) {
-                header->rm_xid = hton32 (reply_info->rm_xid);
-        } else {
-                rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
-                                               * only one vector.
-                                               * (which is true)
-                                               */
-                header->rm_xid = rpc_msg->rm_xid;
-        }
-
-        header->rm_type = hton32 (GF_RDMA_MSG);
-        header->rm_vers = hton32 (GF_RDMA_VERSION);
-        header->rm_credit = hton32 (credits);
-
-        header->rm_body.rm_chunks[0] = 0; /* no read chunks */
-        header->rm_body.rm_chunks[1] = 0; /* no write chunks */
-        header->rm_body.rm_chunks[2] = 0; /* no reply chunks */
-
-        return;
-}
-
-
-int32_t
-__gf_rdma_send_reply_inline (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                             gf_rdma_post_t *post,
-                             gf_rdma_reply_info_t *reply_info)
-{
-        gf_rdma_header_t *header    = NULL;
-        int32_t           send_size = 0, ret = 0;
-        char             *buf       = NULL;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + iov_length (entry->prog_payload, entry->prog_payload_count)
-                + sizeof (gf_rdma_header_t); /*
-                                              * remember, no chunklists in the
-                                              * reply
-                                              */
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
-                        "msg size (%d) is greater than maximum size "
-                        "of msg that can be sent inlined (%d)",
-                        send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD);
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        buf = (char *)&header->rm_body.rm_chunks[3];
-
-        if (entry->rpchdr_count != 0) {
-                iov_unload (buf, entry->rpchdr, entry->rpchdr_count);
-                buf += iov_length (entry->rpchdr, entry->rpchdr_count);
-        }
-
-        if (entry->proghdr_count != 0) {
-                iov_unload (buf, entry->proghdr, entry->proghdr_count);
-                buf += iov_length (entry->proghdr, entry->proghdr_count);
-        }
-
-        if (entry->prog_payload_count != 0) {
-                iov_unload (buf, entry->prog_payload,
-                            entry->prog_payload_count);
-                buf += iov_length (entry->prog_payload,
-                                   entry->prog_payload_count);
-        }
-
-        gf_rdma_post_ref (post);
-
-        ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf));
-        if (!ret) {
-                ret = send_size;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED, "posting send (to %s) "
-                        "failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
-
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_reply_encode_write_chunks (gf_rdma_peer_t *peer,
-                                     uint32_t payload_size,
-                                     gf_rdma_post_t *post,
-                                     gf_rdma_reply_info_t *reply_info,
-                                     uint32_t **ptr)
-{
-        uint32_t               chunk_size   = 0;
-        int32_t                ret          = -1;
-        gf_rdma_write_array_t *target_array = NULL;
-        int                    i            = 0;
-
-        target_array = (gf_rdma_write_array_t *)*ptr;
-
-        for (i = 0; i < reply_info->wc_array->wc_nchunks; i++) {
-                chunk_size +=
-                        reply_info->wc_array->wc_array[i].wc_target.rs_length;
-        }
-
-        if (chunk_size < payload_size) {
-                gf_msg_debug (GF_RDMA_LOG_NAME, 0, "length of payload (%d) is "
-                              "exceeding the total write chunk length (%d)",
-                              payload_size, chunk_size);
-                goto out;
-        }
-
-        target_array->wc_discrim = hton32 (1);
-        for (i = 0; (i < reply_info->wc_array->wc_nchunks)
-                     && (payload_size != 0);
-             i++) {
-                target_array->wc_array[i].wc_target.rs_offset
-                        = hton64 (reply_info->wc_array->wc_array[i].wc_target.rs_offset);
-
-                target_array->wc_array[i].wc_target.rs_length
-                        = hton32 (min (payload_size,
-                                       reply_info->wc_array->wc_array[i].wc_target.rs_length));
-        }
-
-        target_array->wc_nchunks = hton32 (i);
-        target_array->wc_array[i].wc_target.rs_handle = 0; /* terminate
-                                                              chunklist */
-
-        ret = 0;
-
-        *ptr = &target_array->wc_array[i].wc_target.rs_length;
-out:
-        return ret;
-}
-
-
-static int32_t
-__gf_rdma_register_local_mr_for_rdma (gf_rdma_peer_t *peer,
-                                      struct iovec *vector, int count,
-                                      gf_rdma_post_context_t *ctx)
-{
-        int                i      = 0;
-        int32_t            ret    = -1;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
-
-        priv = peer->trans->private;
-        device = priv->device;
-
-        for (i = 0; i < count; i++) {
-                /* what if the memory is registered more than once?
-                 * Assume that a single write buffer is passed to afr, which
-                 * then passes it to its children. If more than one children
-                 * happen to use rdma, then the buffer is registered more than
-                 * once.
-                 * Ib-verbs specification says that multiple registrations of
-                 * same memory location is allowed. Refer to 10.6.3.8 of
-                 * Infiniband Architecture Specification Volume 1
-                 * (Release 1.2.1)
-                 */
-                ctx->mr[ctx->mr_count] = gf_rdma_get_pre_registred_mr(
-                                peer->trans, (void *)vector[i].iov_base,
-                                vector[i].iov_len);
-
-                if (!ctx->mr[ctx->mr_count]) {
-                ctx->mr[ctx->mr_count] = ibv_reg_mr (device->pd,
-                                                     vector[i].iov_base,
-                                                     vector[i].iov_len,
-                                                     IBV_ACCESS_LOCAL_WRITE);
-                }
-                if (ctx->mr[ctx->mr_count] == NULL) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED,
-                                "registering memory for IBV_ACCESS_LOCAL_WRITE"
-                                " failed");
-                        goto out;
-                }
-
-                ctx->mr_count++;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-/* 1. assumes xfer_len of data is pointed by vector(s) starting from vec[*idx]
- * 2. modifies vec
- */
-int32_t
-__gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post, struct iovec *vec,
-                 uint32_t xfer_len, int *idx, gf_rdma_write_chunk_t *writech)
-{
-        int             size    = 0, num_sge = 0, i = 0;
-        int32_t         ret     = -1;
-        struct ibv_sge *sg_list = NULL;
-        struct ibv_send_wr wr   = {
-                .opcode         = IBV_WR_RDMA_WRITE,
-                .send_flags     = IBV_SEND_SIGNALED,
-        }, *bad_wr;
-
-        if ((peer == NULL) || (writech == NULL) || (idx == NULL)
-            || (post == NULL) || (vec == NULL) || (xfer_len == 0)) {
-                goto out;
-        }
-
-        for (i = *idx; size < xfer_len; i++) {
-                size += vec[i].iov_len;
-        }
-
-        num_sge = i - *idx;
-
-        sg_list = GF_CALLOC (num_sge, sizeof (struct ibv_sge),
-                             gf_common_mt_sge);
-        if (sg_list == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        for ((i = *idx), (num_sge = 0); (xfer_len != 0); i++, num_sge++) {
-                size = min (xfer_len, vec[i].iov_len);
-
-                sg_list[num_sge].addr = (unsigned long)vec[i].iov_base;
-                sg_list[num_sge].length = size;
-                sg_list[num_sge].lkey = post->ctx.mr[i]->lkey;
-
-                xfer_len -= size;
-        }
-
-        *idx = i;
-
-        if (size < vec[i - 1].iov_len) {
-                vec[i - 1].iov_base += size;
-                vec[i - 1].iov_len -= size;
-                *idx = i - 1;
-        }
-
-        wr.sg_list = sg_list;
-        wr.num_sge = num_sge;
-        wr.wr_id = (unsigned long) gf_rdma_post_ref (post);
-        wr.wr.rdma.rkey = writech->wc_target.rs_handle;
-        wr.wr.rdma.remote_addr = writech->wc_target.rs_offset;
-
-        ret = ibv_post_send(peer->qp, &wr, &bad_wr);
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to "
-                        "client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                ret = -1;
-        }
-
-        GF_FREE (sg_list);
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_do_gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                            struct iovec *vector, int count,
-                            struct iobref *iobref,
-                            gf_rdma_reply_info_t *reply_info)
-{
-        int      i            = 0, payload_idx = 0;
-        uint32_t payload_size = 0, xfer_len = 0;
-        int32_t  ret          = -1;
-
-        if (count != 0) {
-                payload_size = iov_length (vector, count);
-        }
-
-        if (payload_size == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        ret = __gf_rdma_register_local_mr_for_rdma (peer, vector, count,
-                                                    &post->ctx);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_MR_ALOC_FAILED,
-                        "registering memory region for rdma failed");
-                goto out;
-        }
-
-        post->ctx.iobref = iobref_ref (iobref);
-
-        for (i = 0; (i < reply_info->wc_array->wc_nchunks)
-                     && (payload_size != 0);
-             i++) {
-                xfer_len = min (payload_size,
-                                reply_info->wc_array->wc_array[i].wc_target.rs_length);
-
-                ret = __gf_rdma_write (peer, post, vector, xfer_len,
-                                       &payload_idx,
-                                       &reply_info->wc_array->wc_array[i]);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to "
-                                "client (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
-
-                payload_size -= xfer_len;
-        }
-
-        ret = 0;
-out:
-
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_send_reply_type_nomsg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                                 gf_rdma_post_t *post,
-                                 gf_rdma_reply_info_t *reply_info)
-{
-        gf_rdma_header_t *header       = NULL;
-        char             *buf          = NULL;
-        uint32_t          payload_size = 0;
-        int               count        = 0, i = 0;
-        int32_t           ret          = 0;
-        struct iovec      vector[MAX_IOVEC];
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        header->rm_type = hton32 (GF_RDMA_NOMSG);
-
-        payload_size = iov_length (entry->rpchdr, entry->rpchdr_count) +
-                iov_length (entry->proghdr, entry->proghdr_count);
-
-        /* encode reply chunklist */
-        buf = (char *)&header->rm_body.rm_chunks[2];
-        ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post,
-                                                   reply_info,
-                                                   (uint32_t **)&buf);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed");
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        gf_rdma_post_ref (post);
-
-        for (i = 0; i < entry->rpchdr_count; i++) {
-                vector[count++] = entry->rpchdr[i];
-        }
-
-        for (i = 0; i < entry->proghdr_count; i++) {
-                vector[count++] = entry->proghdr[i];
-        }
-
-        ret = __gf_rdma_do_gf_rdma_write (peer, post, vector, count,
-                                          entry->iobref, reply_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer "
-                        "(%s) failed", peer->trans->peerinfo.identifier);
-                gf_rdma_post_unref (post);
-                goto out;
-        }
-
-        ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf));
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED, "posting a send request "
-                        "to client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                ret = -1;
-                gf_rdma_post_unref (post);
-        } else {
-                ret = payload_size;
-        }
-
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_send_reply_type_msg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                               gf_rdma_post_t *post,
-                               gf_rdma_reply_info_t *reply_info)
-{
-        gf_rdma_header_t *header       = NULL;
-        int32_t           send_size    = 0, ret = 0;
-        char             *ptr          = NULL;
-        uint32_t          payload_size = 0;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + GLUSTERFS_RDMA_MAX_HEADER_SIZE;
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
-                        "client has provided only write chunks, but the "
-                        "combined size of rpc and program header (%d) is "
-                        "exceeding the size of msg that can be sent using "
-                        "RDMA send (%d)", send_size,
-                        GLUSTERFS_RDMA_INLINE_THRESHOLD);
-
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        payload_size = iov_length (entry->prog_payload,
-                                   entry->prog_payload_count);
-        ptr = (char *)&header->rm_body.rm_chunks[1];
-
-        ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post,
-                                                   reply_info,
-                                                   (uint32_t **)&ptr);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed");
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        *(uint32_t *)ptr = 0;          /* terminate reply chunklist */
-        ptr += sizeof (uint32_t);
-
-        gf_rdma_post_ref (post);
-
-        ret = __gf_rdma_do_gf_rdma_write (peer, post, entry->prog_payload,
-                                          entry->prog_payload_count,
-                                          entry->iobref, reply_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer "
-                        "(%s) failed", peer->trans->peerinfo.identifier);
-                gf_rdma_post_unref (post);
-                goto out;
-        }
-
-        iov_unload (ptr, entry->rpchdr, entry->rpchdr_count);
-        ptr += iov_length (entry->rpchdr, entry->rpchdr_count);
-
-        iov_unload (ptr, entry->proghdr, entry->proghdr_count);
-        ptr += iov_length (entry->proghdr, entry->proghdr_count);
-
-        ret = gf_rdma_post_send (peer->qp, post, (ptr - post->buf));
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_CLIENT_ERROR,
-                        "rdma send to client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                ret = -1;
-        } else {
-                ret = send_size + payload_size;
-        }
-
-out:
-        return ret;
-}
-
-
-void
-gf_rdma_reply_info_destroy (gf_rdma_reply_info_t *reply_info)
-{
-        if (reply_info == NULL) {
-                goto out;
-        }
-
-        if (reply_info->wc_array != NULL) {
-                GF_FREE (reply_info->wc_array);
-                reply_info->wc_array = NULL;
-        }
-
-        mem_put (reply_info);
-out:
-        return;
-}
-
-
-gf_rdma_reply_info_t *
-gf_rdma_reply_info_alloc (gf_rdma_peer_t *peer)
-{
-        gf_rdma_reply_info_t *reply_info = NULL;
-        gf_rdma_private_t    *priv       = NULL;
-
-        priv = peer->trans->private;
-
-        reply_info = mem_get (priv->device->reply_info_pool);
-        if (reply_info == NULL) {
-                goto out;
-        }
-
-        memset (reply_info, 0, sizeof (*reply_info));
-        reply_info->pool = priv->device->reply_info_pool;
-
-out:
-        return reply_info;
-}
-
-
-int32_t
-__gf_rdma_ioq_churn_reply (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                           gf_rdma_post_t *post)
-{
-        gf_rdma_reply_info_t *reply_info = NULL;
-        int32_t               ret        = -1;
-        gf_rdma_chunktype_t   type       = gf_rdma_noch;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out);
-
-        reply_info = entry->msg.reply_info;
-        if (reply_info != NULL) {
-                type = reply_info->type;
-        }
-
-        switch (type) {
-        case gf_rdma_noch:
-                ret = __gf_rdma_send_reply_inline (peer, entry, post,
-                                                   reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply to peer (%s) as an "
-                                "inlined rdma msg",
-                                peer->trans->peerinfo.identifier);
-                }
-                break;
-
-        case gf_rdma_replych:
-                ret = __gf_rdma_send_reply_type_nomsg (peer, entry, post,
-                                                       reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply to peer (%s) as "
-                                "RDMA_NOMSG", peer->trans->peerinfo.identifier);
-                }
-                break;
-
-        case gf_rdma_writech:
-                ret = __gf_rdma_send_reply_type_msg (peer, entry, post,
-                                                     reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply with write chunks "
-                                "to peer (%s)",
-                                peer->trans->peerinfo.identifier);
-                }
-                break;
-
-        default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_CHUNK_TYPE,
-                        "invalid chunktype (%d) specified for sending reply "
-                        " (peer:%s)", type, peer->trans->peerinfo.identifier);
-                break;
-        }
-
-        if (reply_info != NULL) {
-                gf_rdma_reply_info_destroy (reply_info);
-        }
-out:
-        return ret;
-}
-
-
-int32_t
-__gf_rdma_ioq_churn_entry (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry)
-{
-        int32_t            ret     = 0, quota = 0;
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_device_t  *device  = NULL;
-        gf_rdma_options_t *options = NULL;
-        gf_rdma_post_t    *post    = NULL;
-
-        priv = peer->trans->private;
-        options = &priv->options;
-        device = priv->device;
-
-        quota = __gf_rdma_quota_get (peer);
-        if (quota > 0) {
-                post = gf_rdma_get_post (&device->sendq);
-                if (post == NULL) {
-                        post = gf_rdma_new_post (peer->trans, device,
-                                                 (options->send_size + 2048),
-                                                 GF_RDMA_SEND_POST);
-                }
-
-                if (post == NULL) {
-                        ret = -1;
-                        gf_msg_callingfn (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                          RDMA_MSG_POST_SEND_FAILED,
-                                          "not able to get a post to send msg");
-                        goto out;
-                }
-
-                if (entry->is_request) {
-                        ret = __gf_rdma_ioq_churn_request (peer, entry, post);
-                        if (ret < 0) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                        "failed to process request ioq entry "
-                                        "to peer(%s)",
-                                        peer->trans->peerinfo.identifier);
-                        }
-                } else {
-                        ret = __gf_rdma_ioq_churn_reply (peer, entry, post);
-                        if (ret < 0) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                        "failed to process reply ioq entry "
-                                        "to peer (%s)",
-                                        peer->trans->peerinfo.identifier);
-                        }
-                }
-
-                if (ret != 0) {
-                        __gf_rdma_ioq_entry_free (entry);
-                }
-        } else {
-                ret = 0;
-        }
-
-out:
-        return ret;
-}
-
-
-static int32_t
-__gf_rdma_ioq_churn (gf_rdma_peer_t *peer)
-{
-        gf_rdma_ioq_t *entry = NULL;
-        int32_t        ret   = 0;
-
-        while (!list_empty (&peer->ioq)) {
-                /* pick next entry */
-                entry = peer->ioq_next;
-
-                ret = __gf_rdma_ioq_churn_entry (peer, entry);
-
-                if (ret <= 0)
-                        break;
-        }
-
-        /*
-          list_for_each_entry_safe (entry, dummy, &peer->ioq, list) {
-          ret = __gf_rdma_ioq_churn_entry (peer, entry);
-          if (ret <= 0) {
-          break;
-          }
-          }
-        */
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_writev (rpc_transport_t *this, gf_rdma_ioq_t *entry)
-{
-        int32_t            ret  = 0, need_append = 1;
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_peer_t    *peer = NULL;
-
-        priv = this->private;
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->connected) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_DISCONNECTED,
-                                "rdma is not connected to peer (%s)",
-                                this->peerinfo.identifier);
-                        ret = -1;
-                        goto unlock;
-                }
-
-                peer = &priv->peer;
-                if (list_empty (&peer->ioq)) {
-                        ret = __gf_rdma_ioq_churn_entry (peer, entry);
-                        if (ret != 0) {
-                                need_append = 0;
-
-                                if (ret < 0) {
-                                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                                RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                                "processing ioq entry destined"
-                                                " to (%s) failed",
-                                                this->peerinfo.identifier);
-                                }
-                        }
-                }
-
-                if (need_append) {
-                        list_add_tail (&entry->list, &peer->ioq);
-                }
-        }
-unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
-        return ret;
-}
-
-
-gf_rdma_ioq_t *
-gf_rdma_ioq_new (rpc_transport_t *this, rpc_transport_data_t *data)
-{
-        gf_rdma_ioq_t       *entry = NULL;
-        int                  count = 0, i = 0;
-        rpc_transport_msg_t *msg   = NULL;
-        gf_rdma_private_t   *priv  = NULL;
-
-        if ((data == NULL) || (this == NULL)) {
-                goto out;
-        }
-
-        priv = this->private;
-
-        entry = mem_get (priv->device->ioq_pool);
-        if (entry == NULL) {
-                goto out;
-        }
-        memset (entry, 0, sizeof (*entry));
-        entry->pool = priv->device->ioq_pool;
-
-        if (data->is_request) {
-                msg = &data->data.req.msg;
-                if (data->data.req.rsp.rsphdr_count != 0) {
-                        for (i = 0; i < data->data.req.rsp.rsphdr_count; i++) {
-                                entry->msg.request.rsphdr_vec[i]
-                                        = data->data.req.rsp.rsphdr[i];
-                        }
-
-                        entry->msg.request.rsphdr_count =
-                                data->data.req.rsp.rsphdr_count;
-                }
-
-                if (data->data.req.rsp.rsp_payload_count != 0) {
-                        for (i = 0; i < data->data.req.rsp.rsp_payload_count;
-                             i++) {
-                                entry->msg.request.rsp_payload[i]
-                                        = data->data.req.rsp.rsp_payload[i];
-                        }
-
-                        entry->msg.request.rsp_payload_count =
-                                data->data.req.rsp.rsp_payload_count;
-                }
-
-                entry->msg.request.rpc_req = data->data.req.rpc_req;
-
-                if (data->data.req.rsp.rsp_iobref != NULL) {
-                        entry->msg.request.rsp_iobref
-                                = iobref_ref (data->data.req.rsp.rsp_iobref);
-                }
-        } else {
-                msg = &data->data.reply.msg;
-                entry->msg.reply_info = data->data.reply.private;
-        }
-
-        entry->is_request = data->is_request;
-
-        count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
-
-        GF_ASSERT (count <= MAX_IOVEC);
-
-        if (msg->rpchdr != NULL) {
-                memcpy (&entry->rpchdr[0], msg->rpchdr,
-                        sizeof (struct iovec) * msg->rpchdrcount);
-                entry->rpchdr_count = msg->rpchdrcount;
-        }
-
-        if (msg->proghdr != NULL) {
-                memcpy (&entry->proghdr[0], msg->proghdr,
-                        sizeof (struct iovec) * msg->proghdrcount);
-                entry->proghdr_count = msg->proghdrcount;
-        }
-
-        if (msg->progpayload != NULL) {
-                memcpy (&entry->prog_payload[0], msg->progpayload,
-                        sizeof (struct iovec) * msg->progpayloadcount);
-                entry->prog_payload_count = msg->progpayloadcount;
-        }
-
-        if (msg->iobref != NULL) {
-                entry->iobref = iobref_ref (msg->iobref);
-        }
-
-        INIT_LIST_HEAD (&entry->list);
-
-out:
-        return entry;
-}
-
-
-int32_t
-gf_rdma_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
-{
-        int32_t               ret   = 0;
-        gf_rdma_ioq_t        *entry = NULL;
-        rpc_transport_data_t  data  = {0, };
-        gf_rdma_private_t    *priv  = NULL;
-        gf_rdma_peer_t       *peer  = NULL;
-
-        if (req == NULL) {
-                goto out;
-        }
-
-        priv = this->private;
-        if (priv == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        peer = &priv->peer;
-        data.is_request = 1;
-        data.data.req = *req;
-/*
- * when fist message is received on a transport, quota variable will
- * initiaize  and quota_set will set to one. In gluster code client
- * process with respect to transport is the one who sends the first
- * message. Before settng quota_set variable if a submit request is
- * came on server, then the message should not send.
- */
-
-        if (priv->entity == GF_RDMA_SERVER && peer->quota_set == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        entry = gf_rdma_ioq_new (this, &data);
-        if (entry == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
-                        "getting a new ioq entry failed (peer:%s)",
-                        this->peerinfo.identifier);
-                goto out;
-        }
-
-        ret = gf_rdma_writev (this, entry);
-
-        if (ret > 0) {
-                ret = 0;
-        } else if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED,
-                        "sending request to peer (%s) failed",
-                        this->peerinfo.identifier);
-                rpc_transport_disconnect (this, _gf_false);
-        }
-
-out:
-        return ret;
-}
-
-int32_t
-gf_rdma_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
-{
-        int32_t               ret   = 0;
-        gf_rdma_ioq_t        *entry = NULL;
-        rpc_transport_data_t  data  = {0, };
-
-        if (reply == NULL) {
-                goto out;
-        }
-
-        data.data.reply = *reply;
-
-        entry = gf_rdma_ioq_new (this, &data);
-        if (entry == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
-                        "getting a new ioq entry failed (peer:%s)",
-                        this->peerinfo.identifier);
-                goto out;
-        }
-
-        ret = gf_rdma_writev (this, entry);
-        if (ret > 0) {
-                ret = 0;
-        } else if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED,
-                        "sending request to peer (%s) failed",
-                        this->peerinfo.identifier);
-                rpc_transport_disconnect (this, _gf_false);
-        }
-
-out:
-        return ret;
-}
-
-
-static int
-gf_rdma_register_peer (gf_rdma_device_t *device, int32_t qp_num,
-                       gf_rdma_peer_t *peer)
-{
-        struct _qpent   *ent   = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
-        int              ret   = -1;
-
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
-
-        pthread_mutex_lock (&qpreg->lock);
-        {
-                ent = qpreg->ents[hash].next;
-                while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) {
-                        ent = ent->next;
-                }
-
-                if (ent->qp_num == qp_num) {
-                        ret = 0;
-                        goto unlock;
-                }
-
-                ent = (struct _qpent *) GF_CALLOC (1, sizeof (*ent),
-                                                   gf_common_mt_qpent);
-                if (ent == NULL) {
-                        goto unlock;
-                }
-
-                /* TODO: ref reg->peer */
-                ent->peer = peer;
-                ent->next = &qpreg->ents[hash];
-                ent->prev = ent->next->prev;
-                ent->next->prev = ent;
-                ent->prev->next = ent;
-                ent->qp_num = qp_num;
-                qpreg->count++;
-                ret = 0;
-        }
-unlock:
-        pthread_mutex_unlock (&qpreg->lock);
-
-        return ret;
-}
-
-
-static void
-gf_rdma_unregister_peer (gf_rdma_device_t *device, int32_t qp_num)
-{
-        struct _qpent   *ent   = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
-
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
-
-        pthread_mutex_lock (&qpreg->lock);
-        {
-                ent = qpreg->ents[hash].next;
-                while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
-                        ent = ent->next;
-                if (ent->qp_num != qp_num) {
-                        pthread_mutex_unlock (&qpreg->lock);
-                        return;
-                }
-                ent->prev->next = ent->next;
-                ent->next->prev = ent->prev;
-                /* TODO: unref reg->peer */
-                GF_FREE (ent);
-                qpreg->count--;
-        }
-        pthread_mutex_unlock (&qpreg->lock);
-}
-
-
-static gf_rdma_peer_t *
-__gf_rdma_lookup_peer (gf_rdma_device_t *device, int32_t qp_num)
-{
-        struct _qpent   *ent   = NULL;
-        gf_rdma_peer_t  *peer  = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
-
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
-        ent = qpreg->ents[hash].next;
-        while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
-                ent = ent->next;
-
-        if (ent != &qpreg->ents[hash]) {
-                peer = ent->peer;
-        }
-
-        return peer;
-}
-
-
-static void
-__gf_rdma_destroy_qp (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv = NULL;
-
-        priv = this->private;
-        if (priv->peer.qp) {
-                gf_rdma_unregister_peer (priv->device, priv->peer.qp->qp_num);
-                rdma_destroy_qp (priv->peer.cm_id);
-        }
-        priv->peer.qp = NULL;
-
-        return;
-}
-
-
-static int32_t
-gf_rdma_create_qp (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv        = NULL;
-        gf_rdma_device_t  *device      = NULL;
-        int32_t            ret         = 0;
-        gf_rdma_peer_t    *peer        = NULL;
-        char              *device_name = NULL;
-
-        priv = this->private;
-
-        peer = &priv->peer;
-
-        device_name = (char *)ibv_get_device_name (peer->cm_id->verbs->device);
-        if (device_name == NULL) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get "
-                        "device_name");
-                goto out;
-        }
-
-        device = gf_rdma_get_device (this, peer->cm_id->verbs,
-                                     device_name);
-        if (device == NULL) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_FAILED, "cannot get device for "
-                        "device %s", device_name);
-                goto out;
-        }
-
-        if (priv->device == NULL) {
-                priv->device = device;
-        }
-
-        struct ibv_qp_init_attr init_attr = {
-                .send_cq        = device->send_cq,
-                .recv_cq        = device->recv_cq,
-                .srq            = device->srq,
-                .cap            = {
-                        .max_send_wr  = peer->send_count,
-                        .max_recv_wr  = peer->recv_count,
-                        .max_send_sge = 2,
-                        .max_recv_sge = 1
-                },
-                .qp_type = IBV_QPT_RC
-        };
-
-        ret = rdma_create_qp(peer->cm_id, device->pd, &init_attr);
-        if (ret != 0) {
-                gf_msg (peer->trans->name, GF_LOG_CRITICAL, errno,
-                        RDMA_MSG_CREAT_QP_FAILED, "%s: could not create QP",
-                        this->name);
-                ret = -1;
-                goto out;
-        }
-
-        peer->qp = peer->cm_id->qp;
-
-        ret = gf_rdma_register_peer (device, peer->qp->qp_num, peer);
-
-out:
-        if (ret == -1)
-                __gf_rdma_destroy_qp (this);
-
-        return ret;
-}
-
-
-static int32_t
-__gf_rdma_teardown (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_peer_t    *peer = NULL;
-
-        priv = this->private;
-        peer = &priv->peer;
-
-        if (peer->cm_id && peer->cm_id->qp != NULL) {
-                __gf_rdma_destroy_qp (this);
-        }
-
-        if (!list_empty (&priv->peer.ioq)) {
-                __gf_rdma_ioq_flush (peer);
-        }
-
-        if (peer->cm_id != NULL) {
-                rdma_destroy_id (peer->cm_id);
-                peer->cm_id = NULL;
-        }
-
-        /* TODO: decrement cq size */
-        return 0;
-}
-
-
-static int32_t
-gf_rdma_teardown (rpc_transport_t *this)
-{
-        int32_t ret = 0;
-        gf_rdma_private_t *priv = NULL;
-
-        if (this == NULL) {
-                goto out;
-        }
-
-        priv = this->private;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_teardown (this);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-out:
-        return ret;
-}
-
-
-/*
- * allocates new memory to hold write-chunklist. New memory is needed since
- * write-chunklist will be used while sending reply and the post holding initial
- * write-chunklist sent from client will be put back to srq before a pollin
- * event is sent to upper layers.
- */
-int32_t
-gf_rdma_get_write_chunklist (char **ptr, gf_rdma_write_array_t **write_ary)
-{
-        gf_rdma_write_array_t *from = NULL, *to = NULL;
-        int32_t                ret  = -1, size = 0, i = 0;
-
-        from = (gf_rdma_write_array_t *) *ptr;
-        if (from->wc_discrim == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        from->wc_nchunks = ntoh32 (from->wc_nchunks);
-
-        size = sizeof (*from)
-                + (sizeof (gf_rdma_write_chunk_t) * from->wc_nchunks);
-
-        to = GF_CALLOC (1, size, gf_common_mt_char);
-        if (to == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        to->wc_discrim = ntoh32 (from->wc_discrim);
-        to->wc_nchunks = from->wc_nchunks;
-
-        for (i = 0; i < to->wc_nchunks; i++) {
-                to->wc_array[i].wc_target.rs_handle
-                        = ntoh32 (from->wc_array[i].wc_target.rs_handle);
-                to->wc_array[i].wc_target.rs_length
-                        = ntoh32 (from->wc_array[i].wc_target.rs_length);
-                to->wc_array[i].wc_target.rs_offset
-                        = ntoh64 (from->wc_array[i].wc_target.rs_offset);
-        }
-
-        *write_ary = to;
-        ret = 0;
-        *ptr = (char *)&from->wc_array[i].wc_target.rs_handle;
-out:
-        return ret;
-}
-
-
-/*
- * does not allocate new memory to hold read-chunklist. New memory is not
- * needed, since post is not put back to srq till we've completed all the
- * rdma-reads and hence readchunk-list can point to memory held by post.
- */
-int32_t
-gf_rdma_get_read_chunklist (char **ptr, gf_rdma_read_chunk_t **readch)
-{
-        int32_t               ret   = -1;
-        gf_rdma_read_chunk_t *chunk = NULL;
-        int                   i     = 0;
-
-        chunk = (gf_rdma_read_chunk_t *)*ptr;
-        if (chunk[0].rc_discrim == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        for (i = 0; chunk[i].rc_discrim != 0; i++) {
-                chunk[i].rc_discrim = ntoh32 (chunk[i].rc_discrim);
-                chunk[i].rc_position = ntoh32 (chunk[i].rc_position);
-                chunk[i].rc_target.rs_handle
-                        = ntoh32 (chunk[i].rc_target.rs_handle);
-                chunk[i].rc_target.rs_length
-                        = ntoh32 (chunk[i].rc_target.rs_length);
-                chunk[i].rc_target.rs_offset
-                        = ntoh64 (chunk[i].rc_target.rs_offset);
-        }
-
-        *readch = &chunk[0];
-        ret = 0;
-        *ptr = (char *)&chunk[i].rc_discrim;
-out:
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_decode_error_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                          size_t bytes_in_post)
-{
-        gf_rdma_header_t *header  = NULL;
-        struct iobuf     *iobuf   = NULL;
-        struct iobref    *iobref  = NULL;
-        int32_t           ret     = -1;
-        struct rpc_msg    rpc_msg = {0, };
-
-        header = (gf_rdma_header_t *)post->buf;
-        header->rm_body.rm_error.rm_type
-                = ntoh32 (header->rm_body.rm_error.rm_type);
-        if (header->rm_body.rm_error.rm_type == ERR_VERS) {
-                header->rm_body.rm_error.rm_version.gf_rdma_vers_low =
-                        ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_low);
-                header->rm_body.rm_error.rm_version.gf_rdma_vers_high =
-                        ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_high);
-        }
-
-        rpc_msg.rm_xid = header->rm_xid;
-        rpc_msg.rm_direction = REPLY;
-        rpc_msg.rm_reply.rp_stat = MSG_DENIED;
-
-        iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, bytes_in_post);
-        if (iobuf == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        post->ctx.iobref = iobref = iobref_new ();
-        if (iobref == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        iobref_add (iobref, iobuf);
-        iobuf_unref (iobuf);
-
-        ret = rpc_reply_to_xdr (&rpc_msg, iobuf_ptr (iobuf),
-                                iobuf_pagesize (iobuf), &post->ctx.vector[0]);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RPC_REPLY_CREATE_FAILED, "Failed to create "
-                        "RPC reply");
-                goto out;
-        }
-
-        post->ctx.count = 1;
-
-        iobuf = NULL;
-        iobref = NULL;
-
-out:
-        if (ret == -1) {
-                if (iobuf != NULL) {
-                        iobuf_unref (iobuf);
-                }
-
-                if (iobref != NULL) {
-                        iobref_unref (iobref);
-                }
-        }
-
-        return 0;
-}
-
-
-int32_t
-gf_rdma_decode_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                    gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
-{
-        int32_t                ret        = -1;
-        gf_rdma_header_t      *header     = NULL;
-        gf_rdma_reply_info_t  *reply_info = NULL;
-        char                  *ptr        = NULL;
-        gf_rdma_write_array_t *write_ary  = NULL;
-        size_t                 header_len = 0;
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        ptr = (char *)&header->rm_body.rm_chunks[0];
-
-        ret = gf_rdma_get_read_chunklist (&ptr, readch);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_READ_CHUNK_FAILED, "cannot get read "
-                        "chunklist from msg");
-                goto out;
-        }
-
-        /* skip terminator of read-chunklist */
-        ptr = ptr + sizeof (uint32_t);
-
-        ret = gf_rdma_get_write_chunklist (&ptr, &write_ary);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_WRITE_CHUNK_FAILED, "cannot get write "
-                        "chunklist from msg");
-                goto out;
-        }
-
-        /* skip terminator of write-chunklist */
-        ptr = ptr + sizeof (uint32_t);
-
-        if (write_ary != NULL) {
-                reply_info = gf_rdma_reply_info_alloc (peer);
-                if (reply_info == NULL) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_REPLY_INFO_ALLOC_FAILED,
-                                "reply_info_alloc failed");
-                        ret = -1;
-                        goto out;
-                }
-
-                reply_info->type = gf_rdma_writech;
-                reply_info->wc_array = write_ary;
-                reply_info->rm_xid = header->rm_xid;
-        } else {
-                ret = gf_rdma_get_write_chunklist (&ptr, &write_ary);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CHUNKLIST_ERROR, "cannot get reply "
-                                "chunklist from msg");
-                        goto out;
-                }
-
-                if (write_ary != NULL) {
-                        reply_info = gf_rdma_reply_info_alloc (peer);
-                        if (reply_info == NULL) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_REPLY_INFO_ALLOC_FAILED,
-                                        "reply_info_alloc_failed");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        reply_info->type = gf_rdma_replych;
-                        reply_info->wc_array = write_ary;
-                        reply_info->rm_xid = header->rm_xid;
-                }
-        }
-
-        /* skip terminator of reply chunk */
-        ptr = ptr + sizeof (uint32_t);
-        if (header->rm_type != GF_RDMA_NOMSG) {
-                header_len = (long)ptr - (long)post->buf;
-                post->ctx.vector[0].iov_len = (bytes_in_post - header_len);
-
-                post->ctx.hdr_iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool,
-                                                  (bytes_in_post - header_len));
-                if (post->ctx.hdr_iobuf == NULL) {
-                        ret = -1;
-                        goto out;
-                }
-
-                post->ctx.vector[0].iov_base = iobuf_ptr (post->ctx.hdr_iobuf);
-                memcpy (post->ctx.vector[0].iov_base, ptr,
-                        post->ctx.vector[0].iov_len);
-                post->ctx.count = 1;
-        }
-
-        post->ctx.reply_info = reply_info;
-out:
-        if (ret == -1) {
-                if (*readch != NULL) {
-                        GF_FREE (*readch);
-                        *readch = NULL;
-                }
-
-                GF_FREE (write_ary);
-        }
-
-        return ret;
-}
-
-
-/* Assumes only one of either write-chunklist or a reply chunk is present */
-int32_t
-gf_rdma_decode_header (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                       gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
-{
-        int32_t           ret    = -1;
-        gf_rdma_header_t *header = NULL;
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        header->rm_xid = ntoh32 (header->rm_xid);
-        header->rm_vers = ntoh32 (header->rm_vers);
-        header->rm_credit = ntoh32 (header->rm_credit);
-        header->rm_type = ntoh32 (header->rm_type);
-
-        switch (header->rm_type) {
-        case GF_RDMA_MSG:
-        case GF_RDMA_NOMSG:
-                ret = gf_rdma_decode_msg (peer, post, readch, bytes_in_post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_ENCODE_ERROR, "cannot decode msg of "
-                                "type (%d)", header->rm_type);
-                }
-
-                break;
-
-        case GF_RDMA_MSGP:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type "
-                        "GF_RDMA_MSGP should not have been received");
-                ret = -1;
-                break;
-
-        case GF_RDMA_DONE:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type "
-                        "GF_RDMA_DONE should not have been received");
-                ret = -1;
-                break;
-
-        case GF_RDMA_ERROR:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RDMA_ERROR_RECEIVED, "received a msg of type"
-                        " RDMA_ERROR");
-                ret = gf_rdma_decode_error_msg (peer, post, bytes_in_post);
-                break;
-
-        default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "unknown rdma msg-type (%d)",
-                        header->rm_type);
-        }
-
-        return ret;
-}
-
-
-int32_t
-gf_rdma_do_reads (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                  gf_rdma_read_chunk_t *readch)
-{
-        int32_t             ret       = -1, i = 0, count = 0;
-        size_t              size      = 0;
-        char               *ptr       = NULL;
-        struct iobuf       *iobuf     = NULL;
-        gf_rdma_private_t  *priv      = NULL;
-        struct ibv_sge     *list      = NULL;
-        struct ibv_send_wr *wr        = NULL, *bad_wr = NULL;
-        int                 total_ref = 0;
-        priv = peer->trans->private;
-
-        for (i = 0; readch[i].rc_discrim != 0; i++) {
-                size += readch[i].rc_target.rs_length;
-        }
-
-        if (i == 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_CHUNK_TYPE, "message type specified "
-                        "as rdma-read but there are no rdma read-chunks "
-                        "present");
-                goto out;
-        }
-
-        post->ctx.gf_rdma_reads = i;
-        i = 0;
-        iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, size);
-        if (iobuf == NULL) {
-                goto out;
-        }
-
-        if (post->ctx.iobref == NULL) {
-                post->ctx.iobref = iobref_new ();
-                if (post->ctx.iobref == NULL) {
-                        iobuf_unref (iobuf);
-                        goto out;
-                }
-        }
-
-        iobref_add (post->ctx.iobref, iobuf);
-        iobuf_unref (iobuf);
-
-        ptr = iobuf_ptr (iobuf);
-        iobuf = NULL;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->connected) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_DISCONNECTED, "transport not "
-                                "connected to peer (%s), not doing rdma reads",
-                                peer->trans->peerinfo.identifier);
-                        goto unlock;
-                }
-
-                list = GF_CALLOC (post->ctx.gf_rdma_reads,
-                                sizeof (struct ibv_sge), gf_common_mt_sge);
-
-                if (list == NULL) {
-                       errno =  ENOMEM;
-                       ret = -1;
-                       goto unlock;
-                }
-                wr   = GF_CALLOC (post->ctx.gf_rdma_reads,
-                                sizeof (struct ibv_send_wr), gf_common_mt_wr);
-                if (wr == NULL) {
-                       errno =  ENOMEM;
-                       ret = -1;
-                       goto unlock;
-                }
-                for (i = 0; readch[i].rc_discrim != 0; i++) {
-                        count = post->ctx.count++;
-                        post->ctx.vector[count].iov_base = ptr;
-                        post->ctx.vector[count].iov_len
-                                = readch[i].rc_target.rs_length;
-
-                        ret = __gf_rdma_register_local_mr_for_rdma (peer,
-                                &post->ctx.vector[count], 1, &post->ctx);
-                        if (ret == -1) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_MR_ALOC_FAILED,
-                                        "registering local memory"
-                                       " for rdma read failed");
-                                goto unlock;
-                        }
-
-                        list[i].addr = (unsigned long)
-                                       post->ctx.vector[count].iov_base;
-                        list[i].length = post->ctx.vector[count].iov_len;
-                        list[i].lkey =
-                                post->ctx.mr[post->ctx.mr_count - 1]->lkey;
-
-                        wr[i].wr_id      =
-                                (unsigned long) gf_rdma_post_ref (post);
-                        wr[i].sg_list    = &list[i];
-                        wr[i].next       = &wr[i+1];
-                        wr[i].num_sge    = 1;
-                        wr[i].opcode     = IBV_WR_RDMA_READ;
-                        wr[i].send_flags = IBV_SEND_SIGNALED;
-                        wr[i].wr.rdma.remote_addr =
-                                readch[i].rc_target.rs_offset;
-                        wr[i].wr.rdma.rkey = readch[i].rc_target.rs_handle;
-
-                        ptr += readch[i].rc_target.rs_length;
-                        total_ref++;
-                }
-                wr[i-1].next = NULL;
-                ret = ibv_post_send (peer->qp, wr, &bad_wr);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CLIENT_ERROR, "rdma read from "
-                                "client (%s) failed with ret = %d (%s)",
-                                peer->trans->peerinfo.identifier,
-                                ret, (ret > 0) ? strerror (ret) : "");
-
-                        if (!bad_wr) {
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < post->ctx.gf_rdma_reads; i++) {
-                                if (&wr[i] != bad_wr)
-                                        total_ref--;
-                                else
-                                        break;
-                        }
-
-                        ret = -1;
-                }
-
-        }
-unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
-out:
-        if (list)
-                GF_FREE (list);
-        if (wr)
-                GF_FREE (wr);
-
-        if (ret == -1) {
-                while (total_ref-- > 0)
-                        gf_rdma_post_unref (post);
-
-                if (iobuf != NULL) {
-                        iobuf_unref (iobuf);
-                }
-        }
-
-        return ret;
-}
-
-
-int32_t
-gf_rdma_pollin_notify (gf_rdma_peer_t *peer, gf_rdma_post_t *post)
-{
-        int32_t                    ret             = -1;
-        enum msg_type              msg_type        = 0;
-        struct rpc_req            *rpc_req         = NULL;
-        gf_rdma_request_context_t *request_context = NULL;
-        rpc_request_info_t         request_info    = {0, };
-        gf_rdma_private_t         *priv            = NULL;
-        uint32_t                  *ptr             = NULL;
-        rpc_transport_pollin_t    *pollin          = NULL;
-
-        if ((peer == NULL) || (post == NULL)) {
-                goto out;
-        }
-
-        if (post->ctx.iobref == NULL) {
-                post->ctx.iobref = iobref_new ();
-                if (post->ctx.iobref == NULL) {
-                        goto out;
-                }
-
-                /* handling the case where both hdr and payload of
-                 * GF_FOP_READ_CBK were received in a single iobuf
-                 * because of server sending entire msg as inline without
-                 * doing rdma writes.
-                 */
-                if (post->ctx.hdr_iobuf)
-                        iobref_add (post->ctx.iobref, post->ctx.hdr_iobuf);
-        }
-
-        pollin = rpc_transport_pollin_alloc (peer->trans,
-                                             post->ctx.vector,
-                                             post->ctx.count,
-                                             post->ctx.hdr_iobuf,
-                                             post->ctx.iobref,
-                                             post->ctx.reply_info);
-        if (pollin == NULL) {
-                goto out;
-        }
-
-        ptr = (uint32_t *)pollin->vector[0].iov_base;
-
-        request_info.xid = ntoh32 (*ptr);
-        msg_type = ntoh32 (*(ptr + 1));
-
-        if (msg_type == REPLY) {
-                ret = rpc_transport_notify (peer->trans,
-                                            RPC_TRANSPORT_MAP_XID_REQUEST,
-                                            &request_info);
-                if (ret == -1) {
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "cannot get request"
-                                      "information from rpc layer");
-                        goto out;
-                }
-
-                rpc_req = request_info.rpc_req;
-                if (rpc_req == NULL) {
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "rpc request "
-                                      "structure not found");
-                        ret = -1;
-                        goto out;
-                }
-
-                request_context = rpc_req->conn_private;
-                rpc_req->conn_private = NULL;
-
-                priv = peer->trans->private;
-                if (request_context != NULL) {
-                        pthread_mutex_lock (&priv->write_mutex);
-                        {
-                                __gf_rdma_request_context_destroy (request_context);
-                        }
-                        pthread_mutex_unlock (&priv->write_mutex);
-                } else {
-                        gf_rdma_quota_put (peer);
-                }
-
-                pollin->is_reply = 1;
-        }
-
-        ret = rpc_transport_notify (peer->trans, RPC_TRANSPORT_MSG_RECEIVED,
-                                    pollin);
-        if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        TRANS_MSG_TRANSPORT_ERROR, "transport_notify failed");
-        }
-
-out:
-        if (pollin != NULL) {
-                pollin->private = NULL;
-                rpc_transport_pollin_destroy (pollin);
-        }
-
-        return ret;
-}
-
-
-int32_t
-gf_rdma_recv_reply (gf_rdma_peer_t *peer, gf_rdma_post_t *post)
-{
-        int32_t                    ret          = -1;
-        gf_rdma_header_t          *header       = NULL;
-        gf_rdma_reply_info_t      *reply_info   = NULL;
-        gf_rdma_write_array_t     *wc_array     = NULL;
-        int                        i            = 0;
-        uint32_t                  *ptr          = NULL;
-        gf_rdma_request_context_t *ctx          = NULL;
-        rpc_request_info_t         request_info = {0, };
-        struct rpc_req            *rpc_req      = NULL;
-
-        header = (gf_rdma_header_t *)post->buf;
-        reply_info = post->ctx.reply_info;
-
-        /* no write chunklist, just notify upper layers */
-        if (reply_info == NULL) {
-                ret = 0;
-                goto out;
-        }
-
-        wc_array = reply_info->wc_array;
-
-        if (header->rm_type == GF_RDMA_NOMSG) {
-                post->ctx.vector[0].iov_base
-                        = (void *)(long)wc_array->wc_array[0].wc_target.rs_offset;
-                post->ctx.vector[0].iov_len
-                        = wc_array->wc_array[0].wc_target.rs_length;
-
-                post->ctx.count = 1;
-        } else {
-                for (i = 0; i < wc_array->wc_nchunks; i++) {
-                        post->ctx.vector[i + 1].iov_base
-                                = (void *)(long)wc_array->wc_array[i].wc_target.rs_offset;
-                        post->ctx.vector[i + 1].iov_len
-                                = wc_array->wc_array[i].wc_target.rs_length;
-                }
-
-                post->ctx.count += wc_array->wc_nchunks;
-        }
-
-        ptr = (uint32_t *)post->ctx.vector[0].iov_base;
-        request_info.xid = ntoh32 (*ptr);
-
-        ret = rpc_transport_notify (peer->trans,
-                                    RPC_TRANSPORT_MAP_XID_REQUEST,
-                                    &request_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        TRANS_MSG_TRANSPORT_ERROR, "cannot get request "
-                        "information (peer:%s) from rpc layer",
-                        peer->trans->peerinfo.identifier);
-                goto out;
-        }
-
-        rpc_req = request_info.rpc_req;
-        if (rpc_req == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RPC_ST_ERROR, "rpc request structure not "
-                        "found");
-                ret = -1;
-                goto out;
-        }
-
-        ctx = rpc_req->conn_private;
-        if ((post->ctx.iobref == NULL) && ctx->rsp_iobref) {
-                post->ctx.iobref = iobref_ref (ctx->rsp_iobref);
-        }
-
-        ret = 0;
-
-        gf_rdma_reply_info_destroy (reply_info);
-
-out:
-        if (ret == 0) {
-                ret = gf_rdma_pollin_notify (peer, post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_POLL_IN_NOTIFY_FAILED,
-                                "pollin notify failed");
-                }
-        }
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_recv_request (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                      gf_rdma_read_chunk_t *readch)
-{
-        int32_t ret = -1;
-
-        if (readch != NULL) {
-                ret = gf_rdma_do_reads (peer, post, readch);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_READ_FAILED,
-                                "rdma read from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
-        } else {
-                ret = gf_rdma_pollin_notify (peer, post);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_POLL_IN_NOTIFY_FAILED,
-                                "pollin notification failed");
-                }
-        }
-
-        return ret;
-}
-
-void
-gf_rdma_process_recv (gf_rdma_peer_t *peer, struct ibv_wc *wc)
-{
-        gf_rdma_post_t       *post     = NULL;
-        gf_rdma_read_chunk_t *readch   = NULL;
-        int                   ret      = -1;
-        uint32_t             *ptr      = NULL;
-        enum msg_type         msg_type = 0;
-        gf_rdma_header_t     *header   = NULL;
-        gf_rdma_private_t    *priv     = NULL;
-
-        post = (gf_rdma_post_t *) (long) wc->wr_id;
-        if (post == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_MISSING, "no post found in successful "
-                        "work completion element");
-                goto out;
-        }
-
-        ret = gf_rdma_decode_header (peer, post, &readch, wc->byte_len);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_HEADER_DECODE_FAILED, "decoding of header "
-                        "failed");
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        priv = peer->trans->private;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->peer.quota_set) {
-                        priv->peer.quota_set = 1;
-
-                        /* Initially peer.quota is set to 1 as per RFC 5666. We
-                         * have to account for the quota used while sending
-                         * first msg (which may or may not be returned to pool
-                         * at this point) while deriving peer.quota from
-                         * header->rm_credit. Hence the arithmatic below,
-                         * instead of directly setting it to header->rm_credit.
-                         */
-                        priv->peer.quota = header->rm_credit
-                                - (1 - priv->peer.quota);
-                }
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        switch (header->rm_type) {
-        case GF_RDMA_MSG:
-                ptr = (uint32_t *)post->ctx.vector[0].iov_base;
-                msg_type = ntoh32 (*(ptr + 1));
-                break;
-
-        case GF_RDMA_NOMSG:
-                if (readch != NULL) {
-                        msg_type = CALL;
-                } else {
-                        msg_type = REPLY;
-                }
-                break;
-
-        case GF_RDMA_ERROR:
-                if (header->rm_body.rm_error.rm_type == ERR_CHUNK) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_RDMA_ERROR_RECEIVED,
-                                "peer (%s), couldn't encode or decode the msg "
-                                "properly or write chunks were not provided "
-                                "for replies that were bigger than "
-                                "RDMA_INLINE_THRESHOLD (%d)",
-                                peer->trans->peerinfo.identifier,
-                                GLUSTERFS_RDMA_INLINE_THRESHOLD);
-                        ret = gf_rdma_pollin_notify (peer, post);
-                        if (ret == -1) {
-                                gf_msg_debug (GF_RDMA_LOG_NAME, 0, "pollin "
-                                              "notification failed");
-                        }
-                        goto out;
-                } else {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
-                                TRANS_MSG_TRANSPORT_ERROR, "an error has "
-                                "happened while transmission of msg, "
-                                "disconnecting the transport");
-                        ret = -1;
-                        goto out;
-                }
-
-        default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "invalid rdma msg-type (%d)",
-                        header->rm_type);
-                goto out;
-        }
-
-        if (msg_type == CALL) {
-                ret = gf_rdma_recv_request (peer, post, readch);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_REQ_FAILED, "receiving a request"
-                                " from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
-        } else {
-                ret = gf_rdma_recv_reply (peer, post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_REP_FAILED, "receiving a reply "
-                                "from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
-        }
-
-out:
-        if (ret == -1) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
-
-        return;
-}
-
-void *
-gf_rdma_async_event_thread (void *context)
-{
-        struct ibv_async_event event;
-        int ret;
-
-        while (1) {
-                do {
-                        ret = ibv_get_async_event((struct ibv_context *)context,
-                                                  &event);
-
-                        if (ret && errno != EINTR) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_EVENT_ERROR, "Error getting "
-                                        "event");
-                        }
-                } while (ret && errno == EINTR);
-
-                switch (event.event_type) {
-                case IBV_EVENT_SRQ_LIMIT_REACHED:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_EVENT_SRQ_LIMIT_REACHED, "received "
-                                "srq_limit reached");
-                        break;
-
-                default:
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "event (%d) "
-                                      "received", event.event_type);
-                        break;
-                }
-
-                ibv_ack_async_event(&event);
-        }
-
-        return 0;
-}
-
-
-static void *
-gf_rdma_recv_completion_proc (void *data)
-{
-        struct ibv_comp_channel *chan      = NULL;
-        gf_rdma_device_t        *device    = NULL;;
-        gf_rdma_post_t          *post      = NULL;
-        gf_rdma_peer_t          *peer      = NULL;
-        struct ibv_cq           *event_cq  = NULL;
-        struct ibv_wc            wc[10]    = {{0},};
-        void                    *event_ctx = NULL;
-        int32_t                  ret       = 0;
-        int32_t                  num_wr    = 0, index = 0;
-        uint8_t                  failed    = 0;
-
-        chan = data;
-
-        while (1) {
-                failed = 0;
-                ret = ibv_get_cq_event (chan, &event_cq, &event_ctx);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_GET_CQ_FAILED,
-                                "ibv_get_cq_event failed, terminating recv "
-                                "thread %d (%d)", ret, errno);
-                        continue;
-                }
-
-                device = event_ctx;
-
-                ret = ibv_req_notify_cq (event_cq, 0);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
-                                "ibv_req_notify_cq on %s failed, terminating "
-                                "recv thread: %d (%d)",
-                                device->device_name, ret, errno);
-                        continue;
-                }
-
-                device = (gf_rdma_device_t *) event_ctx;
-
-                while (!failed &&
-                       (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) {
-
-                        for (index = 0; index < num_wr && !failed; index++) {
-                                post = (gf_rdma_post_t *) (long)
-                                        wc[index].wr_id;
-
-                                pthread_mutex_lock (&device->qpreg.lock);
-                                {
-                                        peer = __gf_rdma_lookup_peer (device,
-                                                           wc[index].qp_num);
-
-                                /*
-                                 * keep a refcount on transport so that it
-                                 * does not get freed because of some error
-                                 * indicated by wc.status till we are done
-                                 * with usage of peer and thereby that of
-                                 * trans.
-                                 */
-                                if (peer != NULL) {
-                                        rpc_transport_ref (peer->trans);
-                                }
-                                }
-                                pthread_mutex_unlock (&device->qpreg.lock);
-
-                                if (wc[index].status != IBV_WC_SUCCESS) {
-                                        gf_msg (GF_RDMA_LOG_NAME,
-                                        GF_LOG_ERROR, 0,
-                                        RDMA_MSG_RECV_ERROR, "recv work "
-                                        "request on `%s' returned error (%d)",
-                                        device->device_name,
-                                        wc[index].status);
-                                        failed = 1;
-                                if (peer) {
-                                        ibv_ack_cq_events (event_cq, num_wr);
-                                        rpc_transport_unref (peer->trans);
-                                        rpc_transport_disconnect (peer->trans,
-                                                                  _gf_false);
-                                }
-
-                                if (post) {
-                                        gf_rdma_post_unref (post);
-                                }
-                                continue;
-                                }
-
-                                if (peer) {
-                                        gf_rdma_process_recv (peer,
-                                                        &wc[index]);
-                                        rpc_transport_unref (peer->trans);
-                                } else {
-                                        gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-                                                      "could not lookup peer "
-                                                      "for qp_num: %d",
-                                                      wc[index].qp_num);
-                                }
-
-                                gf_rdma_post_unref (post);
-                        }
-                }
-
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_POLL_CQ_ERROR,
-                                "ibv_poll_cq on `%s' returned error "
-                                "(ret = %d, errno = %d)",
-                                device->device_name, ret, errno);
-                        continue;
-                }
-                if (!failed)
-                        ibv_ack_cq_events (event_cq, num_wr);
-        }
-
-        return NULL;
-}
-
-
-void
-gf_rdma_handle_failed_send_completion (gf_rdma_peer_t *peer, struct ibv_wc *wc)
-{
-        gf_rdma_post_t    *post   = NULL;
-        gf_rdma_device_t  *device = NULL;
-        gf_rdma_private_t *priv   = NULL;
-
-        if (peer != NULL) {
-                priv = peer->trans->private;
-                if (priv != NULL) {
-                        device = priv->device;
-                }
-        }
-
-
-        post = (gf_rdma_post_t *) (long) wc->wr_id;
-
-        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                RDMA_MSG_RDMA_HANDLE_FAILED,
-                "send work request on `%s' returned error "
-                "wc.status = %d, wc.vendor_err = %d, post->buf = %p, "
-                "wc.byte_len = %d, post->reused = %d",
-                (device != NULL) ? device->device_name : NULL, wc->status,
-                wc->vendor_err, post->buf, wc->byte_len, post->reused);
-
-        if (wc->status == IBV_WC_RETRY_EXC_ERR) {
-                gf_msg ("rdma", GF_LOG_ERROR, 0, TRANS_MSG_TIMEOUT_EXCEEDED,
-                        "connection between client and server not working. "
-                        "check by running 'ibv_srq_pingpong'. also make sure "
-                        "subnet manager is running (eg: 'opensm'), or check "
-                        "if rdma port is valid (or active) by running "
-                        "'ibv_devinfo'. contact Gluster Support Team if the "
-                        "problem persists.");
-        }
-
-        if (peer) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
-
-        return;
-}
-
-
-void
-gf_rdma_handle_successful_send_completion (gf_rdma_peer_t *peer,
-                                           struct ibv_wc *wc)
-{
-        gf_rdma_post_t   *post   = NULL;
-        int               reads  = 0, ret = 0;
-        gf_rdma_header_t *header = NULL;
-
-        if (wc->opcode != IBV_WC_RDMA_READ) {
-                goto out;
-        }
-
-        post = (gf_rdma_post_t *)(long) wc->wr_id;
-
-        pthread_mutex_lock (&post->lock);
-        {
-                reads = --post->ctx.gf_rdma_reads;
-        }
-        pthread_mutex_unlock (&post->lock);
-
-        if (reads != 0) {
-                /* if it is not the last rdma read, we've got nothing to do */
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        if (header->rm_type == GF_RDMA_NOMSG) {
-                post->ctx.count = 1;
-                post->ctx.vector[0].iov_len += post->ctx.vector[1].iov_len;
-        }
-        /*
-         * if reads performed as vectored, then all the buffers are actually
-         * contiguous memory, so that we can use it as single vector, instead
-         * of multiple.
-         */
-        while (post->ctx.count > 2) {
-                post->ctx.vector[1].iov_len +=
-                        post->ctx.vector[post->ctx.count-1].iov_len;
-                post->ctx.count--;
-        }
-
-        ret = gf_rdma_pollin_notify (peer, post);
-        if ((ret == -1) && (peer != NULL)) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
-
-out:
-        return;
-}
-
-
-static void *
-gf_rdma_send_completion_proc (void *data)
-{
-        struct ibv_comp_channel *chan       = NULL;
-        gf_rdma_post_t          *post       = NULL;
-        gf_rdma_peer_t          *peer       = NULL;
-        struct ibv_cq           *event_cq   = NULL;
-        void                    *event_ctx  = NULL;
-        gf_rdma_device_t        *device     = NULL;
-        struct ibv_wc            wc[10]     = {{0},};
-        char                     is_request = 0;
-        int32_t                  ret        = 0, quota_ret = 0, num_wr = 0;
-        int32_t                  index      = 0, failed = 0;
-        chan = data;
-        while (1) {
-                failed = 0;
-                ret = ibv_get_cq_event (chan, &event_cq, &event_ctx);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_GET_CQ_FAILED,
-                                "ibv_get_cq_event on failed, terminating "
-                                "send thread: %d (%d)", ret, errno);
-                        continue;
-                }
-
-                device = event_ctx;
-
-                ret = ibv_req_notify_cq (event_cq, 0);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME,  GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
-                                "ibv_req_notify_cq on %s failed, terminating "
-                                "send thread: %d (%d)",
-                                device->device_name, ret, errno);
-                        continue;
-                }
-
-                while (!failed &&
-                       (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) {
-                        for (index = 0; index < num_wr && !failed; index++) {
-                                post = (gf_rdma_post_t *) (long)
-                                        wc[index].wr_id;
-
-                                pthread_mutex_lock (&device->qpreg.lock);
-                                {
-                                        peer = __gf_rdma_lookup_peer (device,
-                                                        wc[index].qp_num);
-
-                                /*
-                                 * keep a refcount on transport so that it
-                                 * does not get freed because of some error
-                                 * indicated by wc.status, till we are done
-                                 * with usage of peer and thereby that of trans.
-                                 */
-                                        if (peer != NULL) {
-                                                rpc_transport_ref (peer->trans);
-                                        }
-                                }
-                                pthread_mutex_unlock (&device->qpreg.lock);
-
-                                if (wc[index].status != IBV_WC_SUCCESS) {
-                                        ibv_ack_cq_events (event_cq, num_wr);
-                                        failed = 1;
-                                        gf_rdma_handle_failed_send_completion
-                                                (peer, &wc[index]);
-                                } else {
-                                      gf_rdma_handle_successful_send_completion
-                                                (peer, &wc[index]);
-                                }
-
-                                if (post) {
-                                        is_request = post->ctx.is_request;
-
-                                        ret = gf_rdma_post_unref (post);
-                                        if ((ret == 0)
-                                        && (wc[index].status == IBV_WC_SUCCESS)
-                                        && !is_request
-                                        && (post->type == GF_RDMA_SEND_POST)
-                                        && (peer != NULL)) {
-                                        /* An GF_RDMA_RECV_POST can end up in
-                                         * gf_rdma_send_completion_proc for
-                                         * rdma-reads, and we do not take
-                                         * quota for getting an GF_RDMA_RECV_POST.
-                                         */
-
-                                        /*
-                                         * if it is request, quota is returned
-                                         * after reply has come.
-                                         */
-                                                quota_ret = gf_rdma_quota_put
-                                                        (peer);
-                                                if (quota_ret < 0) {
-                                                        gf_msg_debug ("rdma",
-                                                        0, "failed to send "
-                                                        "message");
-                                                }
-                                        }
-                                }
-
-                                if (peer) {
-                                        rpc_transport_unref (peer->trans);
-                                } else {
-                                        gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-                                        "could not lookup peer for qp_num: %d",
-                                        wc[index].qp_num);
-
-                                }
-                        }
-                }
-
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                        RDMA_MSG_IBV_POLL_CQ_ERROR,
-                        "ibv_poll_cq on `%s' returned error (ret = %d,"
-                        " errno = %d)",
-                        device->device_name, ret, errno);
-                        continue;
-               }
-               if (!failed)
-                       ibv_ack_cq_events (event_cq, num_wr);
-        }
-
-        return NULL;
-}
-
-
-static void
-gf_rdma_options_init (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_options_t *options = NULL;
-        int32_t            mtu     = 0;
-        data_t            *temp    = NULL;
-
-        /* TODO: validate arguments from options below */
-
-        priv = this->private;
-        options = &priv->options;
-        options->send_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4;  512 KB*/
-        options->recv_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4;  512 KB*/
-        options->send_count = 4096;
-        options->recv_count = 4096;
-        options->attr_timeout = GF_RDMA_TIMEOUT;
-        options->attr_retry_cnt = GF_RDMA_RETRY_CNT;
-        options->attr_rnr_retry = GF_RDMA_RNR_RETRY;
-
-        temp = dict_get (this->options, "transport.listen-backlog");
-        if (temp)
-                options->backlog = data_to_uint32 (temp);
-        else
-                options->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
-
-        temp = dict_get (this->options,
-                         "transport.rdma.work-request-send-count");
-        if (temp)
-                options->send_count = data_to_int32 (temp);
-
-        temp = dict_get (this->options,
-                         "transport.rdma.work-request-recv-count");
-        if (temp)
-                options->recv_count = data_to_int32 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-timeout");
-
-        if (temp)
-                options->attr_timeout = data_to_uint8 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-retry-cnt");
-
-        if (temp)
-                options->attr_retry_cnt = data_to_uint8 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-rnr-retry");
-
-        if (temp)
-                options->attr_rnr_retry = data_to_uint8 (temp);
-
-        options->port = 1;
-        temp = dict_get (this->options,
-                         "transport.rdma.port");
-        if (temp)
-                options->port = data_to_uint64 (temp);
-
-        options->mtu = mtu = IBV_MTU_2048;
-        temp = dict_get (this->options,
-                         "transport.rdma.mtu");
-        if (temp)
-                mtu = data_to_int32 (temp);
-        switch (mtu) {
-
-        case 256: options->mtu = IBV_MTU_256;
-                break;
-
-        case 512: options->mtu = IBV_MTU_512;
-                break;
-
-        case 1024: options->mtu = IBV_MTU_1024;
-                break;
-
-        case 2048: options->mtu = IBV_MTU_2048;
-                break;
-
-        case 4096: options->mtu = IBV_MTU_4096;
-                break;
-        default:
-                if (temp)
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_UNRECG_MTU_VALUE, "%s: unrecognized "
-                                "MTU value '%s', defaulting to '2048'",
-                                this->name, data_to_str (temp));
-                else
-                        gf_msg_trace (GF_RDMA_LOG_NAME, 0, "%s: defaulting "
-                                      "MTU to '2048'", this->name);
-                options->mtu = IBV_MTU_2048;
-                break;
-        }
-
-        temp = dict_get (this->options,
-                         "transport.rdma.device-name");
-        if (temp)
-                options->device_name = gf_strdup (temp->data);
-
-        return;
-}
-
-
-gf_rdma_ctx_t *
-__gf_rdma_ctx_create (void)
-{
-        gf_rdma_ctx_t *rdma_ctx = NULL;
-        int            ret      = -1;
-
-        rdma_ctx = GF_CALLOC (1, sizeof (*rdma_ctx), gf_common_mt_char);
-        if (rdma_ctx == NULL) {
-                goto out;
-        }
-        pthread_mutex_init (&rdma_ctx->lock, NULL);
-        rdma_ctx->rdma_cm_event_channel = rdma_create_event_channel ();
-        if (rdma_ctx->rdma_cm_event_channel == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CM_EVENT_FAILED, "rdma_cm event channel "
-                        "creation failed");
-                goto out;
-        }
-
-        ret = gf_thread_create (&rdma_ctx->rdma_cm_thread, NULL,
-                                gf_rdma_cm_event_handler,
-                                rdma_ctx->rdma_cm_event_channel, "rdmaehan");
-        if (ret != 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, ret,
-                        RDMA_MSG_CM_EVENT_FAILED, "creation of thread to "
-                        "handle rdma-cm events failed");
-                goto out;
-        }
-
-out:
-        if (ret < 0) {
-                if (rdma_ctx->rdma_cm_event_channel != NULL) {
-                        rdma_destroy_event_channel (rdma_ctx->rdma_cm_event_channel);
-                }
-
-                GF_FREE (rdma_ctx);
-                rdma_ctx = NULL;
-        }
-
-        return rdma_ctx;
-}
-
-static int32_t
-gf_rdma_init (rpc_transport_t *this)
-{
-        gf_rdma_private_t   *priv    = NULL;
-        int32_t              ret     = 0;
-        glusterfs_ctx_t     *ctx     = NULL;
-        gf_rdma_options_t   *options = NULL;
-
-        ctx = this->ctx;
-
-        priv = this->private;
-
-        ibv_fork_init ();
-        gf_rdma_options_init (this);
-
-        options = &priv->options;
-        priv->peer.send_count = options->send_count;
-        priv->peer.recv_count = options->recv_count;
-        priv->peer.send_size = options->send_size;
-        priv->peer.recv_size = options->recv_size;
-        priv->backlog = options->backlog;
-
-        priv->peer.trans = this;
-        INIT_LIST_HEAD (&priv->peer.ioq);
-
-        pthread_mutex_init (&priv->write_mutex, NULL);
-        pthread_mutex_init (&priv->recv_mutex, NULL);
-        pthread_cond_init (&priv->recv_cond, NULL);
-
-        LOCK (&ctx->lock);
-        {
-                if (ctx->ib == NULL) {
-                        ctx->ib = __gf_rdma_ctx_create ();
-                        if (ctx->ib == NULL) {
-                                ret = -1;
-                        }
-                }
-        }
-        UNLOCK (&ctx->lock);
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait)
-{
-        gf_rdma_private_t *priv = NULL;
-        int32_t            ret  = 0;
-
-        priv = this->private;
-        gf_msg_callingfn (this->name, GF_LOG_DEBUG, 0,
-                          RDMA_MSG_PEER_DISCONNECTED,
-                          "disconnect called (peer:%s)",
-                          this->peerinfo.identifier);
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_disconnect (this);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_connect (struct rpc_transport *this, int port)
-{
-        gf_rdma_private_t   *priv         = NULL;
-        int32_t              ret          = 0;
-        union gf_sock_union  sock_union   = {{0, }, };
-        socklen_t            sockaddr_len = 0;
-        gf_rdma_peer_t      *peer         = NULL;
-        gf_rdma_ctx_t       *rdma_ctx     = NULL;
-        gf_boolean_t         connected    = _gf_false;
-
-        priv = this->private;
-
-        peer = &priv->peer;
-
-        rpc_transport_ref (this);
-
-        ret = gf_rdma_client_get_remote_sockaddr (this,
-                                                  &sock_union.sa,
-                                                  &sockaddr_len, port);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0, "cannot get remote address to "
-                              "connect");
-                goto out;
-        }
-
-        rdma_ctx = this->ctx->ib;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (peer->cm_id != NULL) {
-                        ret = -1;
-                        errno = EINPROGRESS;
-                        connected = _gf_true;
-                        goto unlock;
-                }
-
-                priv->entity = GF_RDMA_CLIENT;
-
-                ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel,
-                                      &peer->cm_id, this, RDMA_PS_TCP);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                RDMA_MSG_CM_EVENT_FAILED, "creation of "
-                                "rdma_cm_id failed");
-                        ret = -errno;
-                        goto unlock;
-                }
-
-                memcpy (&this->peerinfo.sockaddr, &sock_union.storage,
-                        sockaddr_len);
-                this->peerinfo.sockaddr_len = sockaddr_len;
-
-                if (port > 0)
-                        sock_union.sin.sin_port = htons (port);
-
-                ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family =
-                        ((struct sockaddr *)&this->peerinfo.sockaddr)->sa_family;
-
-                ret = gf_rdma_client_bind (this,
-                                           (struct sockaddr *)&this->myinfo.sockaddr,
-                                           &this->myinfo.sockaddr_len,
-                                           peer->cm_id);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                RDMA_MSG_CLIENT_BIND_FAILED,
-                                "client bind failed");
-                        goto unlock;
-                }
-
-                ret = rdma_resolve_addr (peer->cm_id, NULL, &sock_union.sa,
-                                         2000);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED,
-                                "rdma_resolve_addr failed");
-                        goto unlock;
-                }
-
-                priv->connected = 0;
-        }
-unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
-
-out:
-        if (ret != 0) {
-                if (!connected) {
-                        gf_rdma_teardown (this);
-                }
-
-                rpc_transport_unref (this);
-        }
-
-        return ret;
-}
-
-
-static int32_t
-gf_rdma_listen (rpc_transport_t *this)
-{
-        union gf_sock_union  sock_union   = {{0, }, };
-        socklen_t            sockaddr_len = 0;
-        gf_rdma_private_t   *priv         = NULL;
-        gf_rdma_peer_t      *peer         = NULL;
-        int                  ret          = 0;
-        gf_rdma_ctx_t       *rdma_ctx     = NULL;
-        char                 service[NI_MAXSERV], host[NI_MAXHOST];
-        int                  optval = 2;
-
-        priv = this->private;
-        peer = &priv->peer;
-
-        priv->entity = GF_RDMA_SERVER_LISTENER;
-
-        rdma_ctx = this->ctx->ib;
-
-        ret = gf_rdma_server_get_local_sockaddr (this, &sock_union.sa,
-                                                 &sockaddr_len);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NW_ADDR_UNKNOWN,
-                        "cannot find network address of server to bind to");
-                goto err;
-        }
-
-        ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel,
-                              &peer->cm_id, this, RDMA_PS_TCP);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CM_EVENT_FAILED, "creation of rdma_cm_id "
-                        "failed");
-                goto err;
-        }
-
-        memcpy (&this->myinfo.sockaddr, &sock_union.storage,
-                sockaddr_len);
-        this->myinfo.sockaddr_len = sockaddr_len;
-
-        ret = getnameinfo ((struct sockaddr *)&this->myinfo.sockaddr,
-                           this->myinfo.sockaddr_len, host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_NAME_INFO_FAILED,
-                        "getnameinfo failed");
-                goto err;
-        }
-
-        sprintf (this->myinfo.identifier, "%s:%s", host, service);
-
-        ret = rdma_set_option(peer->cm_id, RDMA_OPTION_ID,
-                              RDMA_OPTION_ID_REUSEADDR,
-                              (void *)&optval, sizeof(optval));
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_OPTION_SET_FAILED, "rdma option set failed");
-                goto err;
-        }
-
-        ret = rdma_bind_addr (peer->cm_id, &sock_union.sa);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_RDMA_BIND_ADDR_FAILED,
-                        "rdma_bind_addr failed");
-                goto err;
-        }
-
-        ret = rdma_listen (peer->cm_id, priv->backlog);
-
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_LISTEN_FAILED,
-                        "rdma_listen failed");
-                goto err;
-        }
-
-        rpc_transport_ref (this);
-
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (peer->cm_id != NULL) {
-                        rdma_destroy_id (peer->cm_id);
-                        peer->cm_id = NULL;
-                }
-        }
-
-        return ret;
-}
-
-
-struct rpc_transport_ops tops = {
-        .submit_request = gf_rdma_submit_request,
-        .submit_reply   = gf_rdma_submit_reply,
-        .connect        = gf_rdma_connect,
-        .disconnect     = gf_rdma_disconnect,
-        .listen         = gf_rdma_listen,
-};
-
-int32_t
-init (rpc_transport_t *this)
-{
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_ctx_t *rdma_ctx = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-
-        priv = GF_CALLOC (1, sizeof (*priv), gf_common_mt_rdma_private_t);
-        if (!priv)
-                return -1;
-
-        this->private = priv;
-
-        if (gf_rdma_init (this)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INIT_IB_DEVICE_FAILED,
-                        "Failed to initialize IB Device");
-                this->private = NULL;
-                GF_FREE (priv);
-                return -1;
-        }
-        rdma_ctx = this->ctx->ib;
-        pthread_mutex_lock (&rdma_ctx->lock);
-        {
-                if (rdma_ctx != NULL) {
-                        if (this->dl_handle && (++(rdma_ctx->dlcount)) == 1) {
-                        iobuf_pool = this->ctx->iobuf_pool;
-                        iobuf_pool->rdma_registration = gf_rdma_register_arena;
-                        iobuf_pool->rdma_deregistration =
-                                                      gf_rdma_deregister_arena;
-                        gf_rdma_register_iobuf_pool_with_device
-                                                (rdma_ctx->device, iobuf_pool);
-                        }
-                }
-        }
-        pthread_mutex_unlock (&rdma_ctx->lock);
-
-        return 0;
-}
-
-int
-reconfigure (rpc_transport_t *this, dict_t *options)
-{
-        gf_rdma_private_t *priv          = NULL;
-        uint32_t          backlog        = 0;
-        int               ret            = -1;
-
-        GF_VALIDATE_OR_GOTO ("rdma", this, out);
-        GF_VALIDATE_OR_GOTO ("rdma", this->private, out);
-
-        priv = this->private;
-
-        if (dict_get_uint32 (options, "transport.listen-backlog",
-                             &backlog) == 0) {
-                priv->backlog = backlog;
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                        "transport.listen-backlog=%d", priv->backlog);
-        }
-        ret = 0;
-out:
-        return ret;
-}
-void
-fini (struct rpc_transport *this)
-{
-        /* TODO: verify this function does graceful finish */
-        gf_rdma_private_t *priv = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-        gf_rdma_ctx_t *rdma_ctx = NULL;
-
-        priv = this->private;
-
-        this->private = NULL;
-
-        if (priv) {
-                pthread_mutex_destroy (&priv->recv_mutex);
-                pthread_mutex_destroy (&priv->write_mutex);
-
-                gf_msg_trace (this->name, 0,
-                              "called fini on transport: %p", this);
-                GF_FREE (priv);
-        }
-
-        rdma_ctx = this->ctx->ib;
-        if (!rdma_ctx)
-                return;
-
-        pthread_mutex_lock (&rdma_ctx->lock);
-        {
-                if (this->dl_handle && (--(rdma_ctx->dlcount)) == 0) {
-                        iobuf_pool = this->ctx->iobuf_pool;
-                        gf_rdma_deregister_iobuf_pool (rdma_ctx->device);
-                        iobuf_pool->rdma_registration = NULL;
-                        iobuf_pool->rdma_deregistration = NULL;
-                }
-        }
-        pthread_mutex_unlock (&rdma_ctx->lock);
-
-        return;
-}
-
-/* TODO: expand each option */
-struct volume_options options[] = {
-        { .key   = {"transport.rdma.port",
-                    "rdma-port"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 4,
-          .description = "check the option by 'ibv_devinfo'"
-        },
-        { .key   = {"transport.rdma.mtu",
-                    "rdma-mtu"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"transport.rdma.device-name",
-                    "rdma-device-name"},
-          .type  = GF_OPTION_TYPE_ANY,
-          .description = "check by 'ibv_devinfo'"
-        },
-        { .key   = {"transport.rdma.work-request-send-count",
-                    "rdma-work-request-send-count"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"transport.rdma.work-request-recv-count",
-                    "rdma-work-request-recv-count"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"remote-port",
-                    "transport.remote-port",
-                    "transport.rdma.remote-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-timeout",
-                    "rdma-attr-timeout"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-retry-cnt",
-                    "rdma-attr-retry-cnt"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-rnr-retry",
-                    "rdma-attr-rnr-retry"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.listen-port", "listen-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.connect-path", "connect-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.rdma.bind-path", "bind-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.rdma.listen-path", "listen-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.address-family",
-                    "address-family"},
-          .value = {"inet", "inet6", "inet/inet6", "inet6/inet",
-                    "unix", "inet-sdp" },
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {"transport.socket.lowlat"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key = {NULL} }
-};
diff --git a/rpc/rpc-transport/rdma/src/rdma.h b/rpc/rpc-transport/rdma/src/rdma.h
deleted file mode 100644
index 6bcf6bc6ef2..00000000000
--- a/rpc/rpc-transport/rdma/src/rdma.h
+++ /dev/null
@@ -1,391 +0,0 @@
-/*
-  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _XPORT_RDMA_H
-#define _XPORT_RDMA_H
-
-
-#ifndef MAX_IOVEC
-#define MAX_IOVEC 16
-#endif /* MAX_IOVEC */
-
-#include "rpc-clnt.h"
-#include "rpc-transport.h"
-#include "xlator.h"
-#include "event.h"
-#include <stdio.h>
-#include <list.h>
-#include <arpa/inet.h>
-#include <infiniband/verbs.h>
-#include <rdma/rdma_cma.h>
-
-/* FIXME: give appropriate values to these macros */
-#define GF_DEFAULT_RDMA_LISTEN_PORT (GF_DEFAULT_BASE_PORT + 1)
-
-
-/* If you are changing GF_RDMA_MAX_SEGMENTS, please make sure to update
- * GLUSTERFS_GF_RDMA_MAX_HEADER_SIZE defined in glusterfs.h .
- */
-#define GF_RDMA_MAX_SEGMENTS           8
-
-#define GF_RDMA_VERSION                1
-#define GF_RDMA_POOL_SIZE              512
-
-/* Additional attributes */
-#define GF_RDMA_TIMEOUT                14
-#define GF_RDMA_RETRY_CNT              7
-#define GF_RDMA_RNR_RETRY              7
-
-typedef enum gf_rdma_errcode {
-        ERR_VERS = 1,
-        ERR_CHUNK = 2
-}gf_rdma_errcode_t;
-
-struct gf_rdma_err_vers {
-        uint32_t gf_rdma_vers_low; /* Version range supported by peer */
-        uint32_t gf_rdma_vers_high;
-}__attribute__ ((packed));
-typedef struct gf_rdma_err_vers gf_rdma_err_vers_t;
-
-typedef enum gf_rdma_proc {
-        GF_RDMA_MSG   = 0,           /* An RPC call or reply msg */
-        GF_RDMA_NOMSG = 1,           /* An RPC call or reply msg - separate body */
-        GF_RDMA_MSGP  = 2,           /* An RPC call or reply msg with padding */
-        GF_RDMA_DONE  = 3,           /* Client signals reply completion */
-        GF_RDMA_ERROR = 4            /* An RPC RDMA encoding error */
-}gf_rdma_proc_t;
-
-typedef enum gf_rdma_chunktype {
-        gf_rdma_noch = 0,         /* no chunk */
-        gf_rdma_readch,           /* some argument through rdma read */
-        gf_rdma_areadch,          /* entire request through rdma read */
-        gf_rdma_writech,          /* some result through rdma write */
-        gf_rdma_replych           /* entire reply through rdma write */
-}gf_rdma_chunktype_t;
-
-/* If you are modifying __gf_rdma_header, please make sure to change
- * GLUSTERFS_GF_RDMA_MAX_HEADER_SIZE defined in glusterfs.h to reflect your changes
- */
-struct __gf_rdma_header {
-        uint32_t rm_xid;    /* Mirrors the RPC header xid */
-        uint32_t rm_vers;   /* Version of this protocol */
-        uint32_t rm_credit; /* Buffers requested/granted */
-        uint32_t rm_type;   /* Type of message (enum gf_rdma_proc) */
-        union {
-                struct {                          /* no chunks */
-                        uint32_t rm_empty[3];     /* 3 empty chunk lists */
-                }__attribute__((packed)) rm_nochunks;
-
-                struct {                          /* no chunks and padded */
-                        uint32_t rm_align;        /* Padding alignment */
-                        uint32_t rm_thresh;       /* Padding threshold */
-                        uint32_t rm_pempty[3];    /* 3 empty chunk lists */
-                }__attribute__((packed)) rm_padded;
-
-                struct {
-                        uint32_t rm_type;
-                        gf_rdma_err_vers_t rm_version;
-                }__attribute__ ((packed)) rm_error;
-
-                uint32_t rm_chunks[0];    /* read, write and reply chunks */
-        }__attribute__ ((packed)) rm_body;
-} __attribute__((packed));
-typedef struct __gf_rdma_header gf_rdma_header_t;
-
-/* If you are modifying __gf_rdma_segment or __gf_rdma_read_chunk, please make sure
- * to change GLUSTERFS_GF_RDMA_MAX_HEADER_SIZE defined in glusterfs.h to reflect
- * your changes.
- */
-struct __gf_rdma_segment {
-        uint32_t rs_handle;       /* Registered memory handle */
-        uint32_t rs_length;       /* Length of the chunk in bytes */
-        uint64_t rs_offset;       /* Chunk virtual address or offset */
-} __attribute__((packed));
-typedef struct __gf_rdma_segment gf_rdma_segment_t;
-
-/* read chunk(s), encoded as a linked list. */
-struct __gf_rdma_read_chunk {
-        uint32_t       rc_discrim;      /* 1 indicates presence */
-        uint32_t       rc_position;     /* Position in XDR stream */
-        gf_rdma_segment_t rc_target;
-} __attribute__((packed));
-typedef struct __gf_rdma_read_chunk gf_rdma_read_chunk_t;
-
-/* write chunk, and reply chunk. */
-struct __gf_rdma_write_chunk {
-        gf_rdma_segment_t wc_target;
-} __attribute__((packed));
-typedef struct __gf_rdma_write_chunk gf_rdma_write_chunk_t;
-
-/* write chunk(s), encoded as a counted array. */
-struct __gf_rdma_write_array {
-        uint32_t wc_discrim;      /* 1 indicates presence */
-        uint32_t wc_nchunks;      /* Array count */
-        struct __gf_rdma_write_chunk wc_array[0];
-} __attribute__((packed));
-typedef struct __gf_rdma_write_array gf_rdma_write_array_t;
-
-/* options per transport end point */
-struct __gf_rdma_options {
-        int32_t port;
-        char *device_name;
-        enum ibv_mtu mtu;
-        int32_t  send_count;
-        int32_t  recv_count;
-        uint64_t recv_size;
-        uint64_t send_size;
-	uint8_t  attr_timeout;
-	uint8_t  attr_retry_cnt;
-	uint8_t  attr_rnr_retry;
-        uint32_t backlog;
-};
-typedef struct __gf_rdma_options gf_rdma_options_t;
-
-struct __gf_rdma_reply_info {
-        uint32_t            rm_xid;      /* xid in network endian */
-        gf_rdma_chunktype_t    type;        /*
-                                          * can be either gf_rdma_replych
-                                          * or gf_rdma_writech.
-                                          */
-        gf_rdma_write_array_t *wc_array;
-        struct mem_pool    *pool;
-};
-typedef struct __gf_rdma_reply_info gf_rdma_reply_info_t;
-
-struct __gf_rdma_ioq {
-        union {
-                struct list_head list;
-                struct {
-                        struct __gf_rdma_ioq    *next;
-                        struct __gf_rdma_ioq    *prev;
-                };
-        };
-
-        char               is_request;
-        struct iovec       rpchdr[MAX_IOVEC];
-        int                rpchdr_count;
-        struct iovec       proghdr[MAX_IOVEC];
-        int                proghdr_count;
-        struct iovec       prog_payload[MAX_IOVEC];
-        int                prog_payload_count;
-
-        struct iobref     *iobref;
-
-        union {
-                struct __gf_rdma_ioq_request {
-                        /* used to build reply_chunk for GF_RDMA_NOMSG type msgs */
-                        struct iovec rsphdr_vec[MAX_IOVEC];
-                        int          rsphdr_count;
-
-                        /*
-                         * used to build write_array during operations like
-                         * read.
-                         */
-                        struct iovec rsp_payload[MAX_IOVEC];
-                        int          rsp_payload_count;
-
-                        struct rpc_req *rpc_req; /* FIXME: hack! hack! should be
-                                                  * cleaned up later
-                                                  */
-                        struct iobref  *rsp_iobref;
-                }request;
-
-                gf_rdma_reply_info_t  *reply_info;
-        }msg;
-
-        struct mem_pool *pool;
-};
-typedef struct __gf_rdma_ioq gf_rdma_ioq_t;
-
-typedef enum __gf_rdma_send_post_type {
-        GF_RDMA_SEND_POST_NO_CHUNKLIST,    /* post which is sent using rdma-send
-                                         * and the msg carries no
-                                         * chunklists.
-                                         */
-        GF_RDMA_SEND_POST_READ_CHUNKLIST,  /* post which is sent using rdma-send
-                                         * and the msg carries only read
-                                         * chunklist.
-                                         */
-        GF_RDMA_SEND_POST_WRITE_CHUNKLIST, /* post which is sent using
-                                         * rdma-send and the msg carries
-                                         * only write chunklist.
-                                         */
-        GF_RDMA_SEND_POST_READ_WRITE_CHUNKLIST, /* post which is sent using
-                                              * rdma-send and the msg
-                                              * carries both read and
-                                              * write chunklists.
-                                              */
-        GF_RDMA_SEND_POST_GF_RDMA_READ,              /* RDMA read */
-        GF_RDMA_SEND_POST_GF_RDMA_WRITE,             /* RDMA write */
-}gf_rdma_send_post_type_t;
-
-/* represents one communication peer, two per transport_t */
-struct __gf_rdma_peer {
-        rpc_transport_t   *trans;
-        struct rdma_cm_id *cm_id;
-        struct ibv_qp     *qp;
-        pthread_t          rdma_event_thread;
-        char               quota_set;
-
-        int32_t recv_count;
-        int32_t send_count;
-        int32_t recv_size;
-        int32_t send_size;
-
-        int32_t                        quota;
-        union {
-                struct list_head       ioq;
-                struct {
-                        gf_rdma_ioq_t *ioq_next;
-                        gf_rdma_ioq_t *ioq_prev;
-                };
-        };
-
-        /* QP attributes, needed to connect with remote QP */
-        int32_t               local_lid;
-        int32_t               local_psn;
-        int32_t               local_qpn;
-        int32_t               remote_lid;
-        int32_t               remote_psn;
-        int32_t               remote_qpn;
-};
-typedef struct __gf_rdma_peer gf_rdma_peer_t;
-
-struct __gf_rdma_post_context {
-        struct ibv_mr     *mr[GF_RDMA_MAX_SEGMENTS];
-        int                mr_count;
-        struct iovec       vector[MAX_IOVEC];
-        int                count;
-        struct iobref     *iobref;
-        struct iobuf      *hdr_iobuf;
-        char               is_request;
-        int                gf_rdma_reads;
-        gf_rdma_reply_info_t *reply_info;
-};
-typedef struct __gf_rdma_post_context gf_rdma_post_context_t;
-
-typedef enum {
-        GF_RDMA_SEND_POST,
-        GF_RDMA_RECV_POST
-} gf_rdma_post_type_t;
-
-struct __gf_rdma_post {
-        struct __gf_rdma_post *next, *prev;
-        struct ibv_mr *mr;
-        char *buf;
-        int32_t buf_size;
-        char aux;
-        int32_t reused;
-        struct __gf_rdma_device  *device;
-        gf_rdma_post_type_t      type;
-        gf_rdma_post_context_t   ctx;
-        int                   refcount;
-        pthread_mutex_t       lock;
-};
-typedef struct __gf_rdma_post gf_rdma_post_t;
-
-struct __gf_rdma_queue {
-        gf_rdma_post_t active_posts, passive_posts;
-        int32_t active_count, passive_count;
-        pthread_mutex_t lock;
-};
-typedef struct __gf_rdma_queue gf_rdma_queue_t;
-
-struct __gf_rdma_qpreg {
-        pthread_mutex_t lock;
-        int32_t count;
-        struct _qpent {
-                struct _qpent *next, *prev;
-                int32_t qp_num;
-                gf_rdma_peer_t *peer;
-        } ents[42];
-};
-typedef struct __gf_rdma_qpreg gf_rdma_qpreg_t;
-
-/* context per device, stored in global glusterfs_ctx_t->ib */
-struct __gf_rdma_device {
-        struct __gf_rdma_device *next;
-        const char *device_name;
-        struct ibv_context *context;
-        int32_t port;
-        struct ibv_pd *pd;
-        struct ibv_srq *srq;
-        gf_rdma_qpreg_t qpreg;
-        struct ibv_comp_channel *send_chan, *recv_chan;
-        struct ibv_cq *send_cq, *recv_cq;
-        gf_rdma_queue_t sendq, recvq;
-        pthread_t send_thread, recv_thread, async_event_thread;
-        struct mem_pool *request_ctx_pool;
-        struct mem_pool *ioq_pool;
-        struct mem_pool *reply_info_pool;
-        struct list_head all_mr;
-};
-typedef struct __gf_rdma_device gf_rdma_device_t;
-
-
-struct __gf_rdma_arena_mr {
-        struct list_head list;
-        struct iobuf_arena *iobuf_arena;
-        struct ibv_mr *mr;
-};
-
-typedef struct __gf_rdma_arena_mr gf_rdma_arena_mr;
-struct __gf_rdma_ctx {
-        gf_rdma_device_t          *device;
-        struct rdma_event_channel *rdma_cm_event_channel;
-        pthread_t                  rdma_cm_thread;
-        pthread_mutex_t            lock;
-        int32_t                    dlcount;
-};
-typedef struct __gf_rdma_ctx gf_rdma_ctx_t;
-
-struct __gf_rdma_request_context {
-        struct ibv_mr   *mr[GF_RDMA_MAX_SEGMENTS];
-        int              mr_count;
-        struct mem_pool *pool;
-        gf_rdma_peer_t     *peer;
-        struct iobref   *iobref;
-        struct iobref   *rsp_iobref;
-};
-typedef struct __gf_rdma_request_context gf_rdma_request_context_t;
-
-typedef enum {
-        GF_RDMA_SERVER_LISTENER,
-        GF_RDMA_SERVER,
-        GF_RDMA_CLIENT,
-} gf_rdma_transport_entity_t;
-
-struct __gf_rdma_private {
-        int32_t        idx;
-        unsigned char  connected;
-        in_addr_t      addr;
-        unsigned short port;
-
-        /* IB Verbs Driver specific variables, pointers */
-        gf_rdma_peer_t           peer;
-        struct __gf_rdma_device *device;
-        gf_rdma_options_t        options;
-
-        /* Used by trans->op->receive */
-        char    *data_ptr;
-        int32_t  data_offset;
-        int32_t  data_len;
-
-        /* Mutex */
-        pthread_mutex_t             write_mutex;
-        rpc_transport_t            *listener;
-        pthread_mutex_t             recv_mutex;
-        pthread_cond_t              recv_cond;
-        gf_rdma_transport_entity_t  entity;
-        uint32_t                    backlog;
-};
-typedef struct __gf_rdma_private    gf_rdma_private_t;
-
-#endif /* _XPORT_GF_RDMA_H */
diff --git a/rpc/rpc-transport/rdma/src/rpc-trans-rdma-messages.h b/rpc/rpc-transport/rdma/src/rpc-trans-rdma-messages.h
deleted file mode 100644
index 616b0a20f61..00000000000
--- a/rpc/rpc-transport/rdma/src/rpc-trans-rdma-messages.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-  Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef _RPC_TRANS_RDMA_MESSAGES_H_
-#define _RPC_TRANS_RDMA_MESSAGES_H_
-
-#include "glfs-message-id.h"
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES_RDMA
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
- */
-
-#define GLFS_RPC_TRANS_RDMA_BASE        GLFS_MSGID_COMP_RPC_TRANS_RDMA
-#define GLFS_NUM_MESSAGES_RDMA          77
-#define GLFS_RPC_TRANS_RDMA_MSGID_END   (GLFS_RPC_TRANS_RDMA_BASE + GLFS_NUM_MESSAGES_RDMA + 1)
-
-/* Messages with message IDs */
-
-#define glfs_msg_start_rdma GLFS_RPC_TRANS_RDMA_BASE, "Invalid: Start of messages"
-
-/* This slot/segment is allocated for RDMA message IDs
- * The allocation starts from BASE.
-
-*/
-
-#define RDMA_MSG_PORT_BIND_FAILED                   (GLFS_RPC_TRANS_RDMA_BASE + 1)
-
-#define RDMA_MSG_POST_CREATION_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 2)
-
-#define RDMA_MSG_DEREGISTER_ARENA_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 3)
-
-#define RDMA_MSG_MR_ALOC_FAILED                     (GLFS_RPC_TRANS_RDMA_BASE + 4)
-
-#define RDMA_MSG_PREREG_BUFFER_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 5)
-
-#define RDMA_MSG_CQ_CREATION_FAILED                 (GLFS_RPC_TRANS_RDMA_BASE + 6)
-
-#define RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED          (GLFS_RPC_TRANS_RDMA_BASE + 7)
-
-#define RDMA_MSG_QUERY_DEVICE_FAILED                (GLFS_RPC_TRANS_RDMA_BASE + 8)
-
-#define RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED         (GLFS_RPC_TRANS_RDMA_BASE + 9)
-
-#define RDMA_MSG_SEND_COMP_CHAN_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 10)
-
-#define RDMA_MSG_RECV_COMP_CHAN_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 11)
-
-#define RDMA_MSG_ALOC_PROT_DOM_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 12)
-
-#define RDMA_MSG_CRE_SRQ_FAILED                     (GLFS_RPC_TRANS_RDMA_BASE + 13)
-
-#define RDMA_MSG_ALOC_POST_FAILED                   (GLFS_RPC_TRANS_RDMA_BASE + 14)
-
-#define RDMA_MSG_SEND_COMP_THREAD_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 15)
-
-#define RDMA_MSG_RECV_COMP_THREAD_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 16)
-
-#define RDMA_MSG_ASYNC_EVENT_THEAD_FAILED           (GLFS_RPC_TRANS_RDMA_BASE + 17)
-
-#define RDMA_MSG_GET_DEVICE_NAME_FAILED             (GLFS_RPC_TRANS_RDMA_BASE + 18)
-
-#define RDMA_MSG_GET_IB_DEVICE_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 19)
-
-#define RDMA_MSG_CREAT_INC_TRANS_FAILED             (GLFS_RPC_TRANS_RDMA_BASE + 20)
-
-#define RDMA_MSG_CREAT_QP_FAILED                    (GLFS_RPC_TRANS_RDMA_BASE + 21)
-
-#define RDMA_MSG_ACCEPT_FAILED                      (GLFS_RPC_TRANS_RDMA_BASE + 22)
-
-#define RDMA_MSG_CONNECT_FAILED                     (GLFS_RPC_TRANS_RDMA_BASE + 23)
-
-#define RDMA_MSG_ROUTE_RESOLVE_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 24)
-
-#define RDMA_MSG_GET_DEVICE_FAILED                  (GLFS_RPC_TRANS_RDMA_BASE + 25)
-
-#define RDMA_MSG_PEER_DISCONNECTED                  (GLFS_RPC_TRANS_RDMA_BASE + 26)
-
-#define RDMA_MSG_ENCODE_ERROR                       (GLFS_RPC_TRANS_RDMA_BASE + 27)
-
-#define RDMA_MSG_POST_SEND_FAILED                   (GLFS_RPC_TRANS_RDMA_BASE + 28)
-
-#define RDMA_MSG_READ_CHUNK_VECTOR_FAILED           (GLFS_RPC_TRANS_RDMA_BASE + 29)
-
-#define RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED          (GLFS_RPC_TRANS_RDMA_BASE + 30)
-
-#define RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT        (GLFS_RPC_TRANS_RDMA_BASE + 31)
-
-#define RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS     (GLFS_RPC_TRANS_RDMA_BASE + 32)
-
-#define RDMA_MSG_CREATE_READ_CHUNK_FAILED           (GLFS_RPC_TRANS_RDMA_BASE + 33)
-
-#define RDMA_MSG_CREATE_WRITE_REPLAY_FAILED         (GLFS_RPC_TRANS_RDMA_BASE + 34)
-
-#define RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD   (GLFS_RPC_TRANS_RDMA_BASE + 35)
-
-#define RDMA_MSG_REG_ACCESS_LOCAL_WRITE_FAILED      (GLFS_RPC_TRANS_RDMA_BASE + 36)
-
-#define RDMA_MSG_WRITE_PEER_FAILED                  (GLFS_RPC_TRANS_RDMA_BASE + 37)
-
-#define RDMA_MSG_SEND_REPLY_FAILED                  (GLFS_RPC_TRANS_RDMA_BASE + 38)
-
-#define RDMA_MSG_INVALID_CHUNK_TYPE                 (GLFS_RPC_TRANS_RDMA_BASE + 39)
-
-#define RDMA_MSG_PROC_IOQ_ENTRY_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 40)
-
-#define RDMA_MSG_NEW_IOQ_ENTRY_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 41)
-
-#define RDMA_MSG_RPC_REPLY_CREATE_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 42)
-
-#define RDMA_MSG_GET_READ_CHUNK_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 43)
-
-#define RDMA_MSG_GET_WRITE_CHUNK_FAILED             (GLFS_RPC_TRANS_RDMA_BASE + 44)
-
-#define RDMA_MSG_REPLY_INFO_ALLOC_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 45)
-
-#define RDMA_MSG_RDMA_ERROR_RECEIVED                (GLFS_RPC_TRANS_RDMA_BASE + 46)
-
-#define RDMA_MSG_GET_REQ_INFO_RPC_FAILED            (GLFS_RPC_TRANS_RDMA_BASE + 47)
-
-#define RDMA_MSG_POLL_IN_NOTIFY_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 48)
-
-#define RDMA_MSG_HEADER_DECODE_FAILED               (GLFS_RPC_TRANS_RDMA_BASE + 49)
-
-#define RDMA_MSG_EVENT_SRQ_LIMIT_REACHED            (GLFS_RPC_TRANS_RDMA_BASE + 50)
-
-#define RDMA_MSG_UNRECG_MQ_VALUE                    (GLFS_RPC_TRANS_RDMA_BASE + 51)
-
-#define RDMA_MSG_BUFFER_ERROR                       (GLFS_RPC_TRANS_RDMA_BASE + 52)
-
-#define RDMA_MSG_OPTION_SET_FAILED                  (GLFS_RPC_TRANS_RDMA_BASE + 53)
-
-#define RDMA_MSG_LISTEN_FAILED                      (GLFS_RPC_TRANS_RDMA_BASE + 54)
-
-#define RDMA_MSG_INIT_IB_DEVICE_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 55)
-
-#define RDMA_MSG_WRITE_CLIENT_ERROR                 (GLFS_RPC_TRANS_RDMA_BASE + 56)
-
-#define RDMA_MSG_CHUNKLIST_ERROR                    (GLFS_RPC_TRANS_RDMA_BASE + 57)
-
-#define RDMA_MSG_INVALID_ENTRY                      (GLFS_RPC_TRANS_RDMA_BASE + 58)
-
-#define RDMA_MSG_READ_CLIENT_ERROR                  (GLFS_RPC_TRANS_RDMA_BASE + 59)
-
-#define RDMA_MSG_RPC_ST_ERROR                       (GLFS_RPC_TRANS_RDMA_BASE + 60)
-
-#define RDMA_MSG_PEER_READ_FAILED                   (GLFS_RPC_TRANS_RDMA_BASE + 61)
-
-#define RDMA_MSG_POST_MISSING                       (GLFS_RPC_TRANS_RDMA_BASE + 62)
-
-#define RDMA_MSG_PEER_REQ_FAILED                    (GLFS_RPC_TRANS_RDMA_BASE + 63)
-
-#define RDMA_MSG_PEER_REP_FAILED                    (GLFS_RPC_TRANS_RDMA_BASE + 64)
-
-#define RDMA_MSG_EVENT_ERROR                        (GLFS_RPC_TRANS_RDMA_BASE + 65)
-
-#define RDMA_MSG_IBV_GET_CQ_FAILED                  (GLFS_RPC_TRANS_RDMA_BASE + 66)
-
-#define RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED           (GLFS_RPC_TRANS_RDMA_BASE + 67)
-
-#define RDMA_MSG_RECV_ERROR                         (GLFS_RPC_TRANS_RDMA_BASE + 68)
-
-#define RDMA_MSG_IBV_POLL_CQ_ERROR                  (GLFS_RPC_TRANS_RDMA_BASE + 69)
-
-#define RDMA_MSG_RDMA_HANDLE_FAILED                 (GLFS_RPC_TRANS_RDMA_BASE + 70)
-
-#define RDMA_MSG_CM_EVENT_FAILED                    (GLFS_RPC_TRANS_RDMA_BASE + 71)
-
-#define RDMA_MSG_CLIENT_BIND_FAILED                 (GLFS_RPC_TRANS_RDMA_BASE + 72)
-
-#define RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED           (GLFS_RPC_TRANS_RDMA_BASE + 73)
-
-#define RDMA_MSG_NW_ADDR_UNKNOWN                    (GLFS_RPC_TRANS_RDMA_BASE + 74)
-
-#define RDMA_MSG_RDMA_BIND_ADDR_FAILED              (GLFS_RPC_TRANS_RDMA_BASE + 75)
-
-#define RDMA_MSG_SEND_CLIENT_ERROR                  (GLFS_RPC_TRANS_RDMA_BASE + 76)
-
-#define RDMA_MSG_UNRECG_MTU_VALUE                   (GLFS_RPC_TRANS_RDMA_BASE + 77)
-
-
-
-/*------------*/
-
-#define glfs_msg_end_rdma GLFS_RPC_TRANS_RDMA_MSGID_END, "Invalid: End of messages"
-
-#endif /* !_RPC_TRANS_RDMA_MESSAGES_H_ */
-
diff --git a/rpc/rpc-transport/socket/src/Makefile.am b/rpc/rpc-transport/socket/src/Makefile.am
index a1c9a6120f1..7b488583771 100644
--- a/rpc/rpc-transport/socket/src/Makefile.am
+++ b/rpc/rpc-transport/socket/src/Makefile.am
@@ -8,6 +8,7 @@ socket_la_LDFLAGS = -module -avoid-version
 socket_la_SOURCES = socket.c name.c
 socket_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
                    $(top_builddir)/rpc/xdr/src/libgfxdr.la \
+                   $(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \
                    -lssl
 
 AM_CPPFLAGS = $(GF_CPPFLAGS) \
diff --git a/rpc/rpc-transport/socket/src/name.c b/rpc/rpc-transport/socket/src/name.c
index 04dc2a989a7..9286bbb236d 100644
--- a/rpc/rpc-transport/socket/src/name.c
+++ b/rpc/rpc-transport/socket/src/name.c
@@ -21,758 +21,748 @@
 
 #include "rpc-transport.h"
 #include "socket.h"
-#include "common-utils.h"
+#include <glusterfs/common-utils.h>
 
 static void
-_assign_port (struct sockaddr *sockaddr, uint16_t port)
+_assign_port(struct sockaddr *sockaddr, uint16_t port)
 {
-        switch (sockaddr->sa_family) {
+    switch (sockaddr->sa_family) {
         case AF_INET6:
-                ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port);
-                break;
+            ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port);
+            break;
 
         case AF_INET_SDP:
         case AF_INET:
-                ((struct sockaddr_in *)sockaddr)->sin_port = htons (port);
-                break;
-        }
+            ((struct sockaddr_in *)sockaddr)->sin_port = htons(port);
+            break;
+    }
 }
 
 static int32_t
-af_inet_bind_to_port_lt_ceiling (int fd, struct sockaddr *sockaddr,
-                                 socklen_t sockaddr_len, uint32_t ceiling)
+af_inet_bind_to_port_lt_ceiling(int fd, struct sockaddr *sockaddr,
+                                socklen_t sockaddr_len, uint32_t ceiling)
 {
 #if GF_DISABLE_PRIVPORT_TRACKING
-        _assign_port (sockaddr, 0);
-        return bind (fd, sockaddr, sockaddr_len);
+    _assign_port(sockaddr, 0);
+    return bind(fd, sockaddr, sockaddr_len);
 #else
-        int32_t         ret                             = -1;
-        uint16_t        port                            = ceiling - 1;
-        unsigned char   ports[GF_PORT_ARRAY_SIZE]       = {0,};
-        int             i                               = 0;
+    int32_t ret = -1;
+    uint16_t port = ceiling - 1;
+    unsigned char ports[GF_PORT_ARRAY_SIZE] = {
+        0,
+    };
+    int i = 0;
 
 loop:
-        ret = gf_process_reserved_ports (ports, ceiling);
+    ret = gf_process_reserved_ports(ports, ceiling);
 
-        while (port) {
-                if (port == GF_CLIENT_PORT_CEILING) {
-                        ret = -1;
-                        break;
-                }
+    while (port) {
+        if (port == GF_CLIENT_PORT_CEILING) {
+            ret = -1;
+            break;
+        }
 
-                /* ignore the reserved ports */
-                if (BIT_VALUE (ports, port)) {
-                        port--;
-                        continue;
-                }
+        /* ignore the reserved ports */
+        if (BIT_VALUE(ports, port)) {
+            port--;
+            continue;
+        }
 
-                _assign_port (sockaddr, port);
+        _assign_port(sockaddr, port);
 
-                ret = bind (fd, sockaddr, sockaddr_len);
+        ret = bind(fd, sockaddr, sockaddr_len);
 
-                if (ret == 0)
-                        break;
+        if (ret == 0)
+            break;
 
-                if (ret == -1 && errno == EACCES)
-                        break;
+        if (ret == -1 && errno == EACCES)
+            break;
 
-                port--;
-        }
+        port--;
+    }
 
-        /* Incase if all the secure ports are exhausted, we are no more
-         * binding to secure ports, hence instead of getting a random
-         * port, lets define the range to restrict it from getting from
-         * ports reserved for bricks i.e from range of 49152 - 65535
-         * which further may lead to port clash */
-        if (!port) {
-                ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
-                for (i = 0; i <= ceiling; i++)
-                        BIT_CLEAR (ports, i);
-                goto loop;
-        }
+    /* In case if all the secure ports are exhausted, we are no more
+     * binding to secure ports, hence instead of getting a random
+     * port, lets define the range to restrict it from getting from
+     * ports reserved for bricks i.e from range of 49152 - 65535
+     * which further may lead to port clash */
+    if (!port) {
+        ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
+        for (i = 0; i <= ceiling; i++)
+            BIT_CLEAR(ports, i);
+        goto loop;
+    }
 
-        return ret;
+    return ret;
 #endif /* GF_DISABLE_PRIVPORT_TRACKING */
 }
 
 static int32_t
-af_unix_client_bind (rpc_transport_t *this,
-                     struct sockaddr *sockaddr,
-                     socklen_t sockaddr_len,
-                     int sock)
+af_unix_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+                    socklen_t sockaddr_len, int sock)
 {
-        data_t *path_data = NULL;
-        struct sockaddr_un *addr = NULL;
-        int32_t ret = 0;
-
-        path_data = dict_get (this->options, "transport.socket.bind-path");
-        if (path_data) {
-                char *path = data_to_str (path_data);
-                if (!path || strlen (path) > UNIX_PATH_MAX) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "bind-path not specified for unix socket, "
-                                "letting connect to assign default value");
-                        goto err;
-                }
-
-                addr = (struct sockaddr_un *) sockaddr;
-                strcpy (addr->sun_path, path);
-                ret = bind (sock, (struct sockaddr *)addr, sockaddr_len);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot bind to unix-domain socket %d (%s)",
-                                sock, strerror (errno));
-                        goto err;
-                }
-        } else {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "bind-path not specified for unix socket, "
-                        "letting connect to assign default value");
+    data_t *path_data = NULL;
+    struct sockaddr_un *addr = NULL;
+    int32_t ret = 0;
+
+    path_data = dict_get_sizen(this->options, "transport.socket.bind-path");
+    if (path_data) {
+        char *path = data_to_str(path_data);
+        if (!path || path_data->len > 108) { /* 108 = addr->sun_path length */
+            gf_log(this->name, GF_LOG_TRACE,
+                   "bind-path not specified for unix socket, "
+                   "letting connect to assign default value");
+            goto err;
+        }
+
+        addr = (struct sockaddr_un *)sockaddr;
+        strcpy(addr->sun_path, path);
+        ret = bind(sock, (struct sockaddr *)addr, sockaddr_len);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "cannot bind to unix-domain socket %d (%s)", sock,
+                   strerror(errno));
+            goto err;
         }
+    } else {
+        gf_log(this->name, GF_LOG_TRACE,
+               "bind-path not specified for unix socket, "
+               "letting connect to assign default value");
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-int32_t
-client_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family)
+static int32_t
+client_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family)
 {
-        data_t  *address_family_data = NULL;
-        int32_t  ret                 = -1;
-
-        if (sa_family == NULL) {
-                gf_log_callingfn ("", GF_LOG_WARNING,
-                                  "sa_family argument is NULL");
-                goto out;
-        }
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (!address_family_data) {
-                data_t *remote_host_data = NULL, *connect_path_data = NULL;
-                remote_host_data = dict_get (this->options, "remote-host");
-                connect_path_data = dict_get (this->options,
-                                              "transport.socket.connect-path");
-
-                if (!(remote_host_data || connect_path_data) ||
-                    (remote_host_data && connect_path_data)) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "transport.address-family not specified. "
-                                "Could not guess default value from (remote-host:%s or "
-                                "transport.unix.connect-path:%s) options",
-                                data_to_str (remote_host_data),
-                                data_to_str (connect_path_data));
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
-
-                if (remote_host_data) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "address-family not specified, marking it as unspec "
-                                "for getaddrinfo to resolve from (remote-host: %s)",
-                                data_to_str(remote_host_data));
-                        *sa_family = AF_UNSPEC;
-                } else {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "address-family not specified, guessing it "
-                                "to be unix from (transport.unix.connect-path: %s)", data_to_str (connect_path_data));
-                        *sa_family = AF_UNIX;
-                }
-
+    data_t *address_family_data = NULL;
+    int32_t ret = -1;
+
+    if (sa_family == NULL) {
+        gf_log_callingfn("", GF_LOG_WARNING, "sa_family argument is NULL");
+        goto out;
+    }
+
+    address_family_data = dict_get_sizen(this->options,
+                                         "transport.address-family");
+    if (!address_family_data) {
+        data_t *remote_host_data = NULL, *connect_path_data = NULL;
+        remote_host_data = dict_get_sizen(this->options, "remote-host");
+        connect_path_data = dict_get_sizen(this->options,
+                                           "transport.socket.connect-path");
+
+        if (!(remote_host_data || connect_path_data) ||
+            (remote_host_data && connect_path_data)) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "transport.address-family not specified. "
+                   "Could not guess default value from (remote-host:%s or "
+                   "transport.unix.connect-path:%s) options",
+                   data_to_str(remote_host_data),
+                   data_to_str(connect_path_data));
+            *sa_family = AF_UNSPEC;
+            goto out;
+        }
+
+        if (remote_host_data) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "address-family not specified, marking it as unspec "
+                   "for getaddrinfo to resolve from (remote-host: %s)",
+                   data_to_str(remote_host_data));
+            *sa_family = AF_UNSPEC;
         } else {
-                char *address_family = data_to_str (address_family_data);
-                if (!strcasecmp (address_family, "unix")) {
-                        *sa_family = AF_UNIX;
-                } else if (!strcasecmp (address_family, "inet")) {
-                        *sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        *sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        *sa_family = AF_INET_SDP;
-                } else {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "unknown address-family (%s) specified",
-                                address_family);
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "address-family not specified, guessing it "
+                   "to be unix from (transport.unix.connect-path: %s)",
+                   data_to_str(connect_path_data));
+            *sa_family = AF_UNIX;
+        }
+
+    } else {
+        const char *address_family = data_to_str(address_family_data);
+        if (!strcasecmp(address_family, "unix")) {
+            *sa_family = AF_UNIX;
+        } else if (!strcasecmp(address_family, "inet")) {
+            *sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            *sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            *sa_family = AF_INET_SDP;
+        } else {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "unknown address-family (%s) specified", address_family);
+            *sa_family = AF_UNSPEC;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_inet_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
+af_inet_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len)
 {
-        dict_t *options = this->options;
-        data_t *remote_host_data = NULL;
-        data_t *remote_port_data = NULL;
-        char *remote_host = NULL;
-        uint16_t remote_port = 0;
-        struct addrinfo *addr_info = NULL;
-        int32_t ret = 0;
-
-        remote_host_data = dict_get (options, "remote-host");
-        if (remote_host_data == NULL)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-host missing in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_host = data_to_str (remote_host_data);
-        if (remote_host == NULL)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-host has data NULL in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_port_data = dict_get (options, "remote-port");
-        if (remote_port_data == NULL)
-        {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "option remote-port missing in volume %s. Defaulting to %d",
-                        this->name, GF_DEFAULT_SOCKET_LISTEN_PORT);
-
-                remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
-        }
-        else
-        {
-                remote_port = data_to_uint16 (remote_port_data);
-        }
-
-        if (remote_port == (uint16_t)-1)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-port has invalid port in volume %s",
-                        this->name);
-                ret = -1;
-                goto err;
-        }
-
-        /* TODO: gf_resolve is a blocking call. kick in some
-           non blocking dns techniques */
-        ret = gf_resolve_ip6 (remote_host, remote_port,
-                              sockaddr->sa_family, &this->dnscache, &addr_info);
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "DNS resolution failed on host %s", remote_host);
-                goto err;
-        }
-
-        memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
-        *sockaddr_len = addr_info->ai_addrlen;
+    dict_t *options = this->options;
+    data_t *remote_host_data = NULL;
+    data_t *remote_port_data = NULL;
+    char *remote_host = NULL;
+    uint16_t remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
+    struct addrinfo *addr_info = NULL;
+    int32_t ret = 0;
+    struct in6_addr serveraddr;
+
+    remote_host_data = dict_get_sizen(options, "remote-host");
+    if (remote_host_data == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option remote-host missing in volume %s", this->name);
+        ret = -1;
+        goto err;
+    }
+
+    remote_host = data_to_str(remote_host_data);
+    if (remote_host == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option remote-host has data NULL in volume %s", this->name);
+        ret = -1;
+        goto err;
+    }
+
+    remote_port_data = dict_get_sizen(options, "remote-port");
+    if (remote_port_data == NULL) {
+        gf_log(this->name, GF_LOG_TRACE,
+               "option remote-port missing in volume %s. Defaulting to %d",
+               this->name, GF_DEFAULT_SOCKET_LISTEN_PORT);
+    } else {
+        remote_port = data_to_uint16(remote_port_data);
+        if (remote_port == (uint16_t)-1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "option remote-port has invalid port in volume %s",
+                   this->name);
+            ret = -1;
+            goto err;
+        }
+    }
+
+    /* Need to update transport-address family if address-family is not provided
+       to command-line arguments
+    */
+    if (inet_pton(AF_INET6, remote_host, &serveraddr)) {
+        sockaddr->sa_family = AF_INET6;
+    }
+
+    /* TODO: gf_resolve is a blocking call. kick in some
+       non blocking dns techniques */
+    ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family,
+                         &this->dnscache, &addr_info);
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_ERROR, "DNS resolution failed on host %s",
+               remote_host);
+        goto err;
+    }
+
+    memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
+    *sockaddr_len = addr_info->ai_addrlen;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
+af_unix_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len)
 {
-        struct sockaddr_un *sockaddr_un = NULL;
-        char *connect_path = NULL;
-        data_t *connect_path_data = NULL;
-        int32_t ret = 0;
-
-        connect_path_data = dict_get (this->options,
-                                      "transport.socket.connect-path");
-        if (!connect_path_data) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option transport.unix.connect-path not specified for "
-                        "address-family unix");
-                ret = -1;
-                goto err;
-        }
-
-        connect_path = data_to_str (connect_path_data);
-        if (!connect_path) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "transport.unix.connect-path is null-string");
-                ret = -1;
-                goto err;
-        }
-
-        if ((strlen (connect_path) + 1)  > UNIX_PATH_MAX) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "connect-path value length %"GF_PRI_SIZET" > %d octets",
-                        strlen (connect_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
-
-        gf_log (this->name, GF_LOG_TRACE,
-                "using connect-path %s", connect_path);
-        sockaddr_un = (struct sockaddr_un *)sockaddr;
-        strcpy (sockaddr_un->sun_path, connect_path);
-        *sockaddr_len = sizeof (struct sockaddr_un);
-
+    struct sockaddr_un *sockaddr_un = NULL;
+    char *connect_path = NULL;
+    data_t *connect_path_data = NULL;
+    int32_t ret = -1;
+
+    connect_path_data = dict_get_sizen(this->options,
+                                       "transport.socket.connect-path");
+    if (!connect_path_data) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option transport.unix.connect-path not specified for "
+               "address-family unix");
+        goto err;
+    }
+
+    /* 108 = sockaddr_un->sun_path length */
+    if ((connect_path_data->len + 1) > 108) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "connect-path value length %d > %d octets",
+               connect_path_data->len + 1, UNIX_PATH_MAX);
+        goto err;
+    }
+
+    connect_path = data_to_str(connect_path_data);
+    if (!connect_path) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "transport.unix.connect-path is null-string");
+        goto err;
+    }
+
+    gf_log(this->name, GF_LOG_TRACE, "using connect-path %s", connect_path);
+    sockaddr_un = (struct sockaddr_un *)sockaddr;
+    strcpy(sockaddr_un->sun_path, connect_path);
+    *sockaddr_len = sizeof(struct sockaddr_un);
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        data_t *listen_path_data = NULL;
-        char *listen_path = NULL;
-        int32_t ret = 0;
-        struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
-
-
-        listen_path_data = dict_get (this->options,
-                                     "transport.socket.listen-path");
-        if (!listen_path_data) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "missing option transport.socket.listen-path");
-                ret = -1;
-                goto err;
-        }
-
-        listen_path = data_to_str (listen_path_data);
+    data_t *listen_path_data = NULL;
+    char *listen_path = NULL;
+    int32_t ret = 0;
+    struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
+
+    listen_path_data = dict_get_sizen(this->options,
+                                      "transport.socket.listen-path");
+    if (!listen_path_data) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "missing option transport.socket.listen-path");
+        ret = -1;
+        goto err;
+    }
+
+    listen_path = data_to_str(listen_path_data);
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX 108
 #endif
 
-        if ((strlen (listen_path) + 1)  > UNIX_PATH_MAX) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option transport.unix.listen-path has value length "
-                        "%"GF_PRI_SIZET" > %d",
-                        strlen (listen_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
+    if ((listen_path_data->len + 1) > UNIX_PATH_MAX) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option transport.unix.listen-path has value length "
+               "%" GF_PRI_SIZET " > %d",
+               strlen(listen_path), UNIX_PATH_MAX);
+        ret = -1;
+        goto err;
+    }
 
-        sunaddr->sun_family = AF_UNIX;
-        strcpy (sunaddr->sun_path, listen_path);
-        *addr_len = sizeof (struct sockaddr_un);
+    sunaddr->sun_family = AF_UNIX;
+    strcpy(sunaddr->sun_path, listen_path);
+    *addr_len = sizeof(struct sockaddr_un);
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_inet_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        struct addrinfo hints, *res = 0, *rp = NULL;
-        data_t *listen_port_data = NULL, *listen_host_data = NULL;
-        uint16_t listen_port = -1;
-        char service[NI_MAXSERV], *listen_host = NULL;
-        dict_t *options = NULL;
-        int32_t ret = 0;
-
-        options = this->options;
-
-        listen_port_data = dict_get (options, "transport.socket.listen-port");
-        listen_host_data = dict_get (options, "transport.socket.bind-address");
-
-        if (listen_port_data)
-        {
-                listen_port = data_to_uint16 (listen_port_data);
-        }
-
-        if (listen_port == (uint16_t) -1)
-                listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
-
-
-        if (listen_host_data)
-        {
-                listen_host = data_to_str (listen_host_data);
+    struct addrinfo hints, *res = 0, *rp = NULL;
+    data_t *listen_port_data = NULL, *listen_host_data = NULL;
+    uint16_t listen_port = 0;
+    char service[NI_MAXSERV], *listen_host = NULL;
+    dict_t *options = NULL;
+    int32_t ret = 0;
+
+    /* initializes addr_len */
+    *addr_len = 0;
+
+    options = this->options;
+
+    listen_port_data = dict_get_sizen(options, "transport.socket.listen-port");
+    if (listen_port_data) {
+        listen_port = data_to_uint16(listen_port_data);
+    } else {
+        listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
+    }
+
+    listen_host_data = dict_get_sizen(options, "transport.socket.bind-address");
+    if (listen_host_data) {
+        listen_host = data_to_str(listen_host_data);
+    } else {
+        if (addr->sa_family == AF_INET6) {
+            struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr;
+            in->sin6_addr = in6addr_any;
+            in->sin6_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in6);
+            goto out;
+        } else if (addr->sa_family == AF_INET) {
+            struct sockaddr_in *in = (struct sockaddr_in *)addr;
+            in->sin_addr.s_addr = htonl(INADDR_ANY);
+            in->sin_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in);
+            goto out;
+        }
+    }
+
+    sprintf(service, "%d", listen_port);
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = addr->sa_family;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_PASSIVE;
+
+    ret = getaddrinfo(listen_host, service, &hints, &res);
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "getaddrinfo failed for host %s, service %s (%s)", listen_host,
+               service, gai_strerror(ret));
+        ret = -1;
+        goto out;
+    }
+    /* IPV6 server can handle both ipv4 and ipv6 clients */
+    for (rp = res; rp != NULL; rp = rp->ai_next) {
+        if (rp->ai_addr == NULL)
+            continue;
+        if (rp->ai_family == AF_INET6) {
+            memcpy(addr, rp->ai_addr, rp->ai_addrlen);
+            *addr_len = rp->ai_addrlen;
+        }
+    }
+
+    if (!(*addr_len)) {
+        if (res && res->ai_addr) {
+            memcpy(addr, res->ai_addr, res->ai_addrlen);
+            *addr_len = res->ai_addrlen;
         } else {
-                if (addr->sa_family == AF_INET6) {
-                        struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr;
-                        in->sin6_addr = in6addr_any;
-                        in->sin6_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in6);
-                        goto out;
-                } else if (addr->sa_family == AF_INET) {
-                        struct sockaddr_in *in = (struct sockaddr_in *) addr;
-                        in->sin_addr.s_addr = htonl(INADDR_ANY);
-                        in->sin_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in);
-                        goto out;
-                }
-        }
-
-        memset (service, 0, sizeof (service));
-        sprintf (service, "%d", listen_port);
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = addr->sa_family;
-        hints.ai_socktype = SOCK_STREAM;
-        hints.ai_flags    = AI_PASSIVE;
-
-        ret = getaddrinfo(listen_host, service, &hints, &res);
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "getaddrinfo failed for host %s, service %s (%s)",
-                        listen_host, service, gai_strerror (ret));
-                ret = -1;
-                goto out;
-        }
-        /* IPV6 server can handle both ipv4 and ipv6 clients */
-        for (rp = res; rp != NULL; rp = rp->ai_next) {
-                if (rp->ai_addr == NULL)
-                        continue;
-                if (rp->ai_family == AF_INET6) {
-                        memcpy (addr, rp->ai_addr, rp->ai_addrlen);
-                        *addr_len = rp->ai_addrlen;
-                }
-        }
-
-        if (!(*addr_len)) {
-                memcpy (addr, res->ai_addr, res->ai_addrlen);
-                *addr_len = res->ai_addrlen;
+            ret = -1;
         }
+    }
 
-        freeaddrinfo (res);
+    freeaddrinfo(res);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-client_bind (rpc_transport_t *this,
-             struct sockaddr *sockaddr,
-             socklen_t *sockaddr_len,
-             int sock)
+client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+            socklen_t *sockaddr_len, int sock)
 {
-        int ret = 0;
+    int ret = 0;
 
-        *sockaddr_len = sizeof (struct sockaddr_in6);
-        switch (sockaddr->sa_family)
-        {
+    *sockaddr_len = sizeof(struct sockaddr_in6);
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
         case AF_INET:
-                *sockaddr_len = sizeof (struct sockaddr_in);
-
+            *sockaddr_len = sizeof(struct sockaddr_in);
+        /* Fall through */
         case AF_INET6:
-                if (!this->bind_insecure) {
-                        ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_CLIENT_PORT_CEILING);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "cannot bind inet socket (%d) "
-                                        "to port less than %d (%s)",
-                                        sock, GF_CLIENT_PORT_CEILING,
-                                        strerror (errno));
-                                ret = 0;
-                        }
-                } else {
-                        ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_IANA_PRIV_PORTS_START);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "failed while binding to less than "
-                                        "%d (%s)", GF_IANA_PRIV_PORTS_START,
-                                        strerror (errno));
-                                ret = 0;
-                        }
+            if (!this->bind_insecure) {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    sock, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING);
+                if (ret == -1) {
+                    gf_log(this->name, GF_LOG_DEBUG,
+                           "cannot bind inet socket (%d) "
+                           "to port less than %d (%s)",
+                           sock, GF_CLIENT_PORT_CEILING, strerror(errno));
+                    ret = 0;
+                }
+            } else {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    sock, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START);
+                if (ret == -1) {
+                    gf_log(this->name, GF_LOG_DEBUG,
+                           "failed while binding to less than "
+                           "%d (%s)",
+                           GF_IANA_PRIV_PORTS_START, strerror(errno));
+                    ret = 0;
                 }
-                break;
+            }
+            break;
 
         case AF_UNIX:
-                *sockaddr_len = sizeof (struct sockaddr_un);
-                ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr,
-                                           *sockaddr_len, sock);
-                break;
+            *sockaddr_len = sizeof(struct sockaddr_un);
+            ret = af_unix_client_bind(this, (struct sockaddr *)sockaddr,
+                                      *sockaddr_len, sock);
+            break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address family %d", sockaddr->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address family %d",
+                   sockaddr->sa_family);
+            ret = -1;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-socket_client_get_remote_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *sockaddr,
-                                   socklen_t *sockaddr_len,
-                                   sa_family_t *sa_family)
+socket_client_get_remote_sockaddr(rpc_transport_t *this,
+                                  struct sockaddr *sockaddr,
+                                  socklen_t *sockaddr_len,
+                                  sa_family_t *sa_family)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", sockaddr, err);
-        GF_VALIDATE_OR_GOTO ("socket", sockaddr_len, err);
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, err);
+    GF_VALIDATE_OR_GOTO("socket", sockaddr, err);
+    GF_VALIDATE_OR_GOTO("socket", sockaddr_len, err);
+    GF_VALIDATE_OR_GOTO("socket", sa_family, err);
 
-        ret = client_fill_address_family (this, &sockaddr->sa_family);
-        if (ret) {
-                ret = -1;
-                goto err;
-        }
+    ret = client_fill_address_family(this, &sockaddr->sa_family);
+    if (ret) {
+        ret = -1;
+        goto err;
+    }
 
-        *sa_family = sockaddr->sa_family;
+    *sa_family = sockaddr->sa_family;
 
-        switch (sockaddr->sa_family)
-        {
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
-                sockaddr->sa_family = AF_INET;
-
+            sockaddr->sa_family = AF_INET;
+        /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_client_get_remote_sockaddr (this, sockaddr,
-                                                          sockaddr_len);
-                break;
+            ret = af_inet_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len);
+            break;
 
         case AF_UNIX:
-                ret = af_unix_client_get_remote_sockaddr (this, sockaddr,
-                                                          sockaddr_len);
-                break;
+            ret = af_unix_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len);
+            break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address-family %d", sockaddr->sa_family);
-                ret = -1;
-        }
-
-        if (*sa_family == AF_UNSPEC) {
-                *sa_family = sockaddr->sa_family;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address-family %d",
+                   sockaddr->sa_family);
+            ret = -1;
+    }
+
+    /* Address-family is updated based on remote_host in
+       af_inet_client_get_remote_sockaddr
+    */
+    if (*sa_family != sockaddr->sa_family) {
+        *sa_family = sockaddr->sa_family;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-
-int32_t
-server_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family)
+static int32_t
+server_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family)
 {
-        data_t  *address_family_data = NULL;
-        int32_t  ret                 = -1;
-        char *addr_family            = "inet";
-        sa_family_t default_family   = AF_INET;
-
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, out);
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (address_family_data) {
-                char *address_family = NULL;
-                address_family = data_to_str (address_family_data);
-
-                if (!strcasecmp (address_family, "inet")) {
-                        *sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        *sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        *sa_family = AF_INET_SDP;
-                } else if (!strcasecmp (address_family, "unix")) {
-                        *sa_family = AF_UNIX;
-                } else {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "unknown address family (%s) specified", address_family);
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
-        } else {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "option address-family not specified, "
-                        "defaulting to %s", addr_family);
-                *sa_family = default_family;
-        }
+    data_t *address_family_data = NULL;
+    int32_t ret = -1;
+
+#ifdef IPV6_DEFAULT
+    const char *addr_family = "inet6";
+    sa_family_t default_family = AF_INET6;
+#else
+    const char *addr_family = "inet";
+    sa_family_t default_family = AF_INET;
+#endif
 
-        ret = 0;
+    GF_VALIDATE_OR_GOTO("socket", sa_family, out);
+
+    address_family_data = dict_get_sizen(this->options,
+                                         "transport.address-family");
+    if (address_family_data) {
+        char *address_family = NULL;
+        address_family = data_to_str(address_family_data);
+
+        if (!strcasecmp(address_family, "inet")) {
+            *sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            *sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            *sa_family = AF_INET_SDP;
+        } else if (!strcasecmp(address_family, "unix")) {
+            *sa_family = AF_UNIX;
+        } else {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "unknown address family (%s) specified", address_family);
+            *sa_family = AF_UNSPEC;
+            goto out;
+        }
+    } else {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "option address-family not specified, "
+               "defaulting to %s",
+               addr_family);
+        *sa_family = default_family;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-socket_server_get_local_sockaddr (rpc_transport_t *this, struct sockaddr *addr,
-                                  socklen_t *addr_len, sa_family_t *sa_family)
+socket_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                 socklen_t *addr_len, sa_family_t *sa_family)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, err);
-        GF_VALIDATE_OR_GOTO ("socket", addr, err);
-        GF_VALIDATE_OR_GOTO ("socket", addr_len, err);
+    GF_VALIDATE_OR_GOTO("socket", sa_family, err);
+    GF_VALIDATE_OR_GOTO("socket", addr, err);
+    GF_VALIDATE_OR_GOTO("socket", addr_len, err);
 
-        ret = server_fill_address_family (this, &addr->sa_family);
-        if (ret == -1) {
-                goto err;
-        }
+    ret = server_fill_address_family(this, &addr->sa_family);
+    if (ret == -1) {
+        goto err;
+    }
 
-        *sa_family = addr->sa_family;
+    *sa_family = addr->sa_family;
 
-        switch (addr->sa_family)
-        {
+    switch (addr->sa_family) {
         case AF_INET_SDP:
-                addr->sa_family = AF_INET;
-
+            addr->sa_family = AF_INET;
+        /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_server_get_local_sockaddr (this, addr, addr_len);
-                break;
+            ret = af_inet_server_get_local_sockaddr(this, addr, addr_len);
+            break;
 
         case AF_UNIX:
-                ret = af_unix_server_get_local_sockaddr (this, addr, addr_len);
-                break;
-        }
+            ret = af_unix_server_get_local_sockaddr(this, addr, addr_len);
+            break;
+    }
 
-        if (*sa_family == AF_UNSPEC) {
-                *sa_family = addr->sa_family;
-        }
+    if (*sa_family == AF_UNSPEC) {
+        *sa_family = addr->sa_family;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-int32_t
-fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr,
-                             int32_t addr_len, char *identifier)
+static int32_t
+fill_inet6_inet_identifiers(rpc_transport_t *this,
+                            struct sockaddr_storage *addr, int32_t addr_len,
+                            char *identifier)
 {
-        union gf_sock_union sock_union;
-
-        char    service[NI_MAXSERV] = {0,};
-        char    host[NI_MAXHOST]    = {0,};
-        int32_t ret                 = 0;
-        int32_t tmpaddr_len         = 0;
-        int32_t one_to_four         = 0;
-        int32_t four_to_eight       = 0;
-        int32_t twelve_to_sixteen   = 0;
-        int16_t eight_to_ten        = 0;
-        int16_t ten_to_twelve       = 0;
-
-        memset (&sock_union, 0, sizeof (sock_union));
-        sock_union.storage = *addr;
-        tmpaddr_len = addr_len;
-
-        if (sock_union.sa.sa_family == AF_INET6) {
-                one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
-                four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
+    union gf_sock_union sock_union;
+
+    char service[NI_MAXSERV] = {
+        0,
+    };
+    char host[NI_MAXHOST] = {
+        0,
+    };
+    int32_t ret = 0;
+    int32_t tmpaddr_len = 0;
+    int32_t one_to_four = 0;
+    int32_t four_to_eight = 0;
+    int32_t twelve_to_sixteen = 0;
+    int16_t eight_to_ten = 0;
+    int16_t ten_to_twelve = 0;
+
+    memset(&sock_union, 0, sizeof(sock_union));
+    sock_union.storage = *addr;
+    tmpaddr_len = addr_len;
+
+    if (sock_union.sa.sa_family == AF_INET6) {
+        one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
+        four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
 #ifdef GF_SOLARIS_HOST_OS
-                eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
+        eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
 #else
-                eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
+        eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-                ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
+        ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
 #else
-                ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
+        ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
 #endif
 
-                twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
-
-                /* ipv4 mapped ipv6 address has
-                   bits 0-80: 0
-                   bits 80-96: 0xffff
-                   bits 96-128: ipv4 address
-                */
-
-                if (one_to_four == 0 &&
-                    four_to_eight == 0 &&
-                    eight_to_ten == 0 &&
-                    ten_to_twelve == -1) {
-                        struct sockaddr_in *in_ptr = &sock_union.sin;
-                        memset (&sock_union, 0, sizeof (sock_union));
-
-                        in_ptr->sin_family = AF_INET;
-                        in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
-                        in_ptr->sin_addr.s_addr = twelve_to_sixteen;
-                        tmpaddr_len = sizeof (*in_ptr);
-                }
-        }
+        twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
+
+        /* ipv4 mapped ipv6 address has
+           bits 0-80: 0
+           bits 80-96: 0xffff
+           bits 96-128: ipv4 address
+        */
+
+        if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 &&
+            ten_to_twelve == -1) {
+            struct sockaddr_in *in_ptr = &sock_union.sin;
+            memset(&sock_union, 0, sizeof(sock_union));
 
-        ret = getnameinfo (&sock_union.sa,
-                           tmpaddr_len,
-                           host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST | NI_NUMERICSERV);
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "getnameinfo failed (%s)", gai_strerror (ret));
+            in_ptr->sin_family = AF_INET;
+            in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
+            in_ptr->sin_addr.s_addr = twelve_to_sixteen;
+            tmpaddr_len = sizeof(*in_ptr);
         }
+    }
 
-        sprintf (identifier, "%s:%s", host, service);
+    ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service,
+                      sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV);
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR, "getnameinfo failed (%s)",
+               gai_strerror(ret));
+    }
 
-        return ret;
+    sprintf(identifier, "%s:%s", host, service);
+
+    return ret;
 }
 
 int32_t
-get_transport_identifiers (rpc_transport_t *this)
+get_transport_identifiers(rpc_transport_t *this)
 {
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
+    int32_t ret = 0;
+    char is_inet_sdp = 0;
 
-        switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family)
-        {
+    switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) {
         case AF_INET_SDP:
-                is_inet_sdp = 1;
-                ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET;
-
+            is_inet_sdp = 1;
+            ((struct sockaddr *)&this->peerinfo.sockaddr)
+                ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                  ->sa_family = AF_INET;
+        /* Fall through */
         case AF_INET:
-        case AF_INET6:
-        {
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->myinfo.sockaddr,
-                                                   this->myinfo.sockaddr_len,
-                                                   this->myinfo.identifier);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot fill inet/inet6 identifier for server");
-                        goto err;
-                }
-
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->peerinfo.sockaddr,
-                                                   this->peerinfo.sockaddr_len,
-                                                   this->peerinfo.identifier);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot fill inet/inet6 identifier for client");
-                        goto err;
-                }
+        case AF_INET6: {
+            ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr,
+                                              this->myinfo.sockaddr_len,
+                                              this->myinfo.identifier);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "cannot fill inet/inet6 identifier for server");
+                goto err;
+            }
+
+            ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr,
+                                              this->peerinfo.sockaddr_len,
+                                              this->peerinfo.identifier);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "cannot fill inet/inet6 identifier for client");
+                goto err;
+            }
 
-                if (is_inet_sdp) {
-                        ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP;
-                }
-        }
-        break;
+            if (is_inet_sdp) {
+                ((struct sockaddr *)&this->peerinfo.sockaddr)
+                    ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                      ->sa_family = AF_INET_SDP;
+            }
+        } break;
 
-        case AF_UNIX:
-        {
-                struct sockaddr_un *sunaddr = NULL;
+        case AF_UNIX: {
+            struct sockaddr_un *sunaddr = NULL;
 
-                sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr;
-                strcpy (this->myinfo.identifier, sunaddr->sun_path);
+            sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr;
+            strcpy(this->myinfo.identifier, sunaddr->sun_path);
 
-                sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr;
-                strcpy (this->peerinfo.identifier, sunaddr->sun_path);
-        }
-        break;
+            sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr;
+            strcpy(this->peerinfo.identifier, sunaddr->sun_path);
+        } break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address family (%d)",
-                        ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address family (%d)",
+                   ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family);
+            ret = -1;
+            break;
+    }
 
 err:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-transport/socket/src/name.h b/rpc/rpc-transport/socket/src/name.h
index 0a13d8a9624..080c7588f5a 100644
--- a/rpc/rpc-transport/socket/src/name.h
+++ b/rpc/rpc-transport/socket/src/name.h
@@ -11,25 +11,23 @@
 #ifndef _SOCKET_NAME_H
 #define _SOCKET_NAME_H
 
-#include "compat.h"
+#include <glusterfs/compat.h>
 
 int32_t
-client_bind (rpc_transport_t *this,
-             struct sockaddr *sockaddr,
-             socklen_t *sockaddr_len,
-             int sock);
+client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+            socklen_t *sockaddr_len, int sock);
 
 int32_t
-socket_client_get_remote_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *sockaddr,
-                                   socklen_t *sockaddr_len,
-                                   sa_family_t *sa_family);
+socket_client_get_remote_sockaddr(rpc_transport_t *this,
+                                  struct sockaddr *sockaddr,
+                                  socklen_t *sockaddr_len,
+                                  sa_family_t *sa_family);
 
 int32_t
-socket_server_get_local_sockaddr (rpc_transport_t *this, struct sockaddr *addr,
-                                  socklen_t *addr_len, sa_family_t *sa_family);
+socket_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                 socklen_t *addr_len, sa_family_t *sa_family);
 
 int32_t
-get_transport_identifiers (rpc_transport_t *this);
+get_transport_identifiers(rpc_transport_t *this);
 
 #endif /* _SOCKET_NAME_H */
diff --git a/rpc/rpc-transport/socket/src/socket-mem-types.h b/rpc/rpc-transport/socket/src/socket-mem-types.h
index d1860e6c9a9..241ce67f670 100644
--- a/rpc/rpc-transport/socket/src/socket-mem-types.h
+++ b/rpc/rpc-transport/socket/src/socket-mem-types.h
@@ -11,13 +11,12 @@
 #ifndef __SOCKET_MEM_TYPES_H__
 #define __SOCKET_MEM_TYPES_H__
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 typedef enum gf_sock_mem_types_ {
-        gf_sock_connect_error_state_t     = gf_common_mt_end + 1,
-        gf_sock_mt_lock_array,
-        gf_sock_mt_tid_wrap,
-        gf_sock_mt_end
+    gf_sock_connect_error_state_t = gf_common_mt_end + 1,
+    gf_sock_mt_lock_array,
+    gf_sock_mt_end
 } gf_sock_mem_types_t;
 
 #endif
diff --git a/rpc/rpc-transport/socket/src/socket.c b/rpc/rpc-transport/socket/src/socket.c
index 590d465ccc6..ed8b473be23 100644
--- a/rpc/rpc-transport/socket/src/socket.c
+++ b/rpc/rpc-transport/socket/src/socket.c
@@ -10,21 +10,16 @@
 
 #include "socket.h"
 #include "name.h"
-#include "dict.h"
-#include "rpc-transport.h"
-#include "logging.h"
-#include "xlator.h"
-#include "syscall.h"
-#include "byte-order.h"
-#include "common-utils.h"
-#include "compat-errno.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/syscall.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/compat-errno.h>
 #include "socket-mem-types.h"
-#include "timer.h"
 
 /* ugly #includes below */
 #include "protocol-common.h"
 #include "glusterfs3-xdr.h"
-#include "xdr-nfs3.h"
+#include "glusterfs4-xdr.h"
 #include "rpcsvc.h"
 
 /* for TCP_USER_TIMEOUT */
@@ -34,464 +29,643 @@
 #include <netinet/tcp.h>
 #endif
 
-#include <fcntl.h>
 #include <errno.h>
 #include <rpc/xdr.h>
 #include <sys/ioctl.h>
 #define GF_LOG_ERRNO(errno) ((errno == ENOTCONN) ? GF_LOG_DEBUG : GF_LOG_ERROR)
 #define SA(ptr) ((struct sockaddr *)ptr)
 
-#define SSL_ENABLED_OPT     "transport.socket.ssl-enabled"
-#define SSL_OWN_CERT_OPT    "transport.socket.ssl-own-cert"
+#define SSL_ENABLED_OPT "transport.socket.ssl-enabled"
+#define SSL_OWN_CERT_OPT "transport.socket.ssl-own-cert"
 #define SSL_PRIVATE_KEY_OPT "transport.socket.ssl-private-key"
-#define SSL_CA_LIST_OPT     "transport.socket.ssl-ca-list"
-#define SSL_CERT_DEPTH_OPT  "transport.socket.ssl-cert-depth"
+#define SSL_CA_LIST_OPT "transport.socket.ssl-ca-list"
+#define SSL_CERT_DEPTH_OPT "transport.socket.ssl-cert-depth"
 #define SSL_CIPHER_LIST_OPT "transport.socket.ssl-cipher-list"
-#define SSL_DH_PARAM_OPT    "transport.socket.ssl-dh-param"
-#define SSL_EC_CURVE_OPT    "transport.socket.ssl-ec-curve"
-#define SSL_CRL_PATH_OPT    "transport.socket.ssl-crl-path"
-#define OWN_THREAD_OPT      "transport.socket.own-thread"
+#define SSL_DH_PARAM_OPT "transport.socket.ssl-dh-param"
+#define SSL_EC_CURVE_OPT "transport.socket.ssl-ec-curve"
+#define SSL_CRL_PATH_OPT "transport.socket.ssl-crl-path"
+#define OWN_THREAD_OPT "transport.socket.own-thread"
 
 /* TBD: do automake substitutions etc. (ick) to set these. */
 #if !defined(DEFAULT_ETC_SSL)
-#  ifdef GF_LINUX_HOST_OS
-#    define DEFAULT_ETC_SSL "/etc/ssl"
-#  endif
-#  ifdef GF_BSD_HOST_OS
-#    define DEFAULT_ETC_SSL "/etc/openssl"
-#  endif
-#  ifdef GF_DARWIN_HOST_OS
-#    define DEFAULT_ETC_SSL "/usr/local/etc/openssl"
-#  endif
-#  if !defined(DEFAULT_ETC_SSL)
-#    define DEFAULT_ETC_SSL "/etc/ssl"
-#  endif
+#ifdef GF_LINUX_HOST_OS
+#define DEFAULT_ETC_SSL "/etc/ssl"
+#endif
+#ifdef GF_BSD_HOST_OS
+#define DEFAULT_ETC_SSL "/etc/openssl"
+#endif
+#ifdef GF_DARWIN_HOST_OS
+#define DEFAULT_ETC_SSL "/usr/local/etc/openssl"
+#endif
+#if !defined(DEFAULT_ETC_SSL)
+#define DEFAULT_ETC_SSL "/etc/ssl"
+#endif
 #endif
 
 #if !defined(DEFAULT_CERT_PATH)
-#define DEFAULT_CERT_PATH   DEFAULT_ETC_SSL "/glusterfs.pem"
+#define DEFAULT_CERT_PATH DEFAULT_ETC_SSL "/glusterfs.pem"
 #endif
 #if !defined(DEFAULT_KEY_PATH)
-#define DEFAULT_KEY_PATH    DEFAULT_ETC_SSL "/glusterfs.key"
+#define DEFAULT_KEY_PATH DEFAULT_ETC_SSL "/glusterfs.key"
 #endif
 #if !defined(DEFAULT_CA_PATH)
-#define DEFAULT_CA_PATH     DEFAULT_ETC_SSL "/glusterfs.ca"
+#define DEFAULT_CA_PATH DEFAULT_ETC_SSL "/glusterfs.ca"
 #endif
 #if !defined(DEFAULT_VERIFY_DEPTH)
 #define DEFAULT_VERIFY_DEPTH 1
 #endif
 #define DEFAULT_CIPHER_LIST "EECDH:EDH:HIGH:!3DES:!RC4:!DES:!MD5:!aNULL:!eNULL"
-#define DEFAULT_DH_PARAM   DEFAULT_ETC_SSL "/dhparam.pem"
-#define DEFAULT_EC_CURVE   "prime256v1"
+#define DEFAULT_DH_PARAM DEFAULT_ETC_SSL "/dhparam.pem"
+#define DEFAULT_EC_CURVE "prime256v1"
 
-#define POLL_MASK_INPUT  (POLLIN | POLLPRI)
+#define POLL_MASK_INPUT (POLLIN | POLLPRI)
 #define POLL_MASK_OUTPUT (POLLOUT)
-#define POLL_MASK_ERROR  (POLLERR | POLLHUP | POLLNVAL)
-
-typedef int SSL_unary_func (SSL *);
-typedef int SSL_trinary_func (SSL *, void *, int);
-
-#define __socket_proto_reset_pending(priv) do {                         \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                                                                        \
-                memset (&frag->vector, 0, sizeof (frag->vector));       \
-                frag->pending_vector = &frag->vector;                   \
-                frag->pending_vector->iov_base = frag->fragcurrent;     \
-                priv->incoming.pending_vector =  frag->pending_vector;  \
-        } while (0)
-
-
-#define __socket_proto_update_pending(priv)                             \
-        do {                                                            \
-                uint32_t remaining;                                     \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                if (frag->pending_vector->iov_len == 0) {               \
-                        remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr) \
-                                     - frag->bytes_read);               \
-                                                                        \
-                        frag->pending_vector->iov_len =                 \
-                                (remaining > frag->remaining_size)      \
-                                ? frag->remaining_size : remaining;     \
-                                                                        \
-                        frag->remaining_size -=                         \
-                                frag->pending_vector->iov_len;          \
-                }                                                       \
-        } while (0)
-
-#define __socket_proto_update_priv_after_read(priv, ret, bytes_read)    \
-        {                                                               \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                                                                        \
-                frag->fragcurrent += bytes_read;                        \
-                frag->bytes_read += bytes_read;                         \
-                                                                        \
-                if ((ret > 0) || (frag->remaining_size != 0)) {         \
-                        if (frag->remaining_size != 0 && ret == 0) {    \
-                                __socket_proto_reset_pending (priv);    \
-                        }                                               \
-                                                                        \
-                        gf_log (this->name, GF_LOG_TRACE,               \
-                                "partial read on non-blocking socket"); \
-                                                                        \
-                        break;                                          \
-                }                                                       \
-        }
-
-#define __socket_proto_init_pending(priv,size)                          \
-        do {                                                            \
-            uint32_t remaining = 0;                                     \
-            struct gf_sock_incoming_frag *frag;                         \
-            frag = &priv->incoming.frag;                                \
-                                                                        \
-            remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr)          \
-                         - frag->bytes_read);                           \
-                                                                        \
-            __socket_proto_reset_pending (priv);                        \
-                                                                        \
-            frag->pending_vector->iov_len =                             \
-                    (remaining > size) ? size : remaining;              \
-                                                                        \
-            frag->remaining_size = (size - frag->pending_vector->iov_len); \
-                                                                        \
-            } while(0)
+#define POLL_MASK_ERROR (POLLERR | POLLHUP | POLLNVAL)
 
+typedef int
+SSL_unary_func(SSL *);
+typedef int
+SSL_trinary_func(SSL *, void *, int);
+static int
+ssl_setup_connection_params(rpc_transport_t *this);
+
+#define __socket_proto_reset_pending(priv)                                     \
+    do {                                                                       \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        memset(&frag->vector, 0, sizeof(frag->vector));                        \
+        frag->pending_vector = &frag->vector;                                  \
+        frag->pending_vector->iov_base = frag->fragcurrent;                    \
+        priv->incoming.pending_vector = frag->pending_vector;                  \
+    } while (0)
+
+#define __socket_proto_update_pending(priv)                                    \
+    do {                                                                       \
+        uint32_t remaining;                                                    \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+        if (frag->pending_vector->iov_len == 0) {                              \
+            remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) -                \
+                         frag->bytes_read);                                    \
+                                                                               \
+            frag->pending_vector->iov_len = (remaining > frag->remaining_size) \
+                                                ? frag->remaining_size         \
+                                                : remaining;                   \
+                                                                               \
+            frag->remaining_size -= frag->pending_vector->iov_len;             \
+        }                                                                      \
+    } while (0)
+
+#define __socket_proto_update_priv_after_read(priv, ret, bytes_read)           \
+    {                                                                          \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        frag->fragcurrent += bytes_read;                                       \
+        frag->bytes_read += bytes_read;                                        \
+                                                                               \
+        if ((ret > 0) || (frag->remaining_size != 0)) {                        \
+            if (frag->remaining_size != 0 && ret == 0) {                       \
+                __socket_proto_reset_pending(priv);                            \
+            }                                                                  \
+                                                                               \
+            gf_log(this->name, GF_LOG_TRACE,                                   \
+                   "partial read on non-blocking socket");                     \
+            ret = 0;                                                           \
+            break;                                                             \
+        }                                                                      \
+    }
+
+#define __socket_proto_init_pending(priv, size)                                \
+    do {                                                                       \
+        uint32_t remaining = 0;                                                \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) - frag->bytes_read); \
+                                                                               \
+        __socket_proto_reset_pending(priv);                                    \
+                                                                               \
+        frag->pending_vector->iov_len = (remaining > size) ? size : remaining; \
+                                                                               \
+        frag->remaining_size = (size - frag->pending_vector->iov_len);         \
+                                                                               \
+    } while (0)
 
 /* This will be used in a switch case and breaks from the switch case if all
  * the pending data is not read.
  */
-#define __socket_proto_read(priv, ret)                                  \
-                {                                                       \
-                size_t bytes_read = 0;                                  \
-                struct gf_sock_incoming *in;                            \
-                in = &priv->incoming;                                   \
-                                                                        \
-                __socket_proto_update_pending (priv);                   \
-                                                                        \
-                ret = __socket_readv (this,                             \
-                                      in->pending_vector, 1,            \
-                                      &in->pending_vector,              \
-                                      &in->pending_count,               \
-                                      &bytes_read);                     \
-                if (ret == -1)                                          \
-                        break;                                          \
-                __socket_proto_update_priv_after_read (priv, ret, bytes_read); \
-        }
+#define __socket_proto_read(priv, ret)                                         \
+    {                                                                          \
+        size_t bytes_read = 0;                                                 \
+        struct gf_sock_incoming *in;                                           \
+        in = &priv->incoming;                                                  \
+                                                                               \
+        __socket_proto_update_pending(priv);                                   \
+                                                                               \
+        ret = __socket_readv(this, in->pending_vector, 1, &in->pending_vector, \
+                             &in->pending_count, &bytes_read);                 \
+        if (ret < 0)                                                           \
+            break;                                                             \
+        __socket_proto_update_priv_after_read(priv, ret, bytes_read);          \
+    }
 
 struct socket_connect_error_state_ {
-        xlator_t            *this;
-        rpc_transport_t     *trans;
-        gf_boolean_t         refd;
+    xlator_t *this;
+    rpc_transport_t *trans;
+    gf_boolean_t refd;
 };
 typedef struct socket_connect_error_state_ socket_connect_error_state_t;
 
-static int socket_init (rpc_transport_t *this);
+static int
+socket_init(rpc_transport_t *this);
+static int
+__socket_nonblock(int fd);
+
+static void
+socket_dump_info(struct sockaddr *sa, int is_server, int is_ssl, int sock,
+                 char *log_domain, char *log_label)
+{
+    char addr_buf[INET6_ADDRSTRLEN + 1] = {
+        0,
+    };
+    char *addr = NULL;
+    const char *peer_type = NULL;
+    int af = sa->sa_family;
+    int so_error = -1;
+    socklen_t slen = sizeof(so_error);
+
+    if (af == AF_UNIX) {
+        addr = ((struct sockaddr_un *)(sa))->sun_path;
+    } else {
+        if (af == AF_INET6) {
+            struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)(sa);
+
+            inet_ntop(af, &sin6->sin6_addr, addr_buf, sizeof(addr_buf));
+            addr = addr_buf;
+        } else {
+            struct sockaddr_in *sin = (struct sockaddr_in *)(sa);
+
+            inet_ntop(af, &sin->sin_addr, addr_buf, sizeof(addr_buf));
+            addr = addr_buf;
+        }
+    }
+    if (is_server)
+        peer_type = "server";
+    else
+        peer_type = "client";
+
+    (void)getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_error, &slen);
+
+    gf_log(log_domain, GF_LOG_TRACE,
+           "$$$ %s: %s (af:%d,sock:%d) %s %s (errno:%d:%s)", peer_type,
+           log_label, af, sock, addr, (is_ssl ? "SSL" : "non-SSL"), so_error,
+           strerror(so_error));
+}
 
 static void
-ssl_dump_error_stack (const char *caller)
+ssl_dump_error_stack(const char *caller)
 {
-	unsigned long  errnum = 0;
-	char           errbuf[120] = {0,};
+    unsigned long errnum = 0;
+    char errbuf[120] = {
+        0,
+    };
 
-	/* OpenSSL docs explicitly give 120 as the error-string length. */
+    /* OpenSSL docs explicitly give 120 as the error-string length. */
 
-	while ((errnum = ERR_get_error())) {
-		ERR_error_string(errnum,errbuf);
-		gf_log(caller,GF_LOG_ERROR,"  %s",errbuf);
-	}
+    while ((errnum = ERR_get_error())) {
+        ERR_error_string(errnum, errbuf);
+        gf_log(caller, GF_LOG_ERROR, "  %s", errbuf);
+    }
 }
 
 static int
-ssl_do (rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func)
+ssl_do(rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func)
 {
-	int               r = (-1);
-	struct pollfd     pfd = {-1,};
-	socket_private_t *priv = NULL;
-
-	GF_VALIDATE_OR_GOTO(this->name,this->private,out);
-	priv = this->private;
-
-	for (;;) {
-		if (buf) {
-                        if (priv->connected == -1) {
-                                /*
-                                 * Fields in the SSL structure (especially
-                                 * the BIO pointers) are not valid at this
-                                 * point, so we'll segfault if we pass them
-                                 * to SSL_read/SSL_write.
-                                 */
-                                gf_log(this->name,GF_LOG_INFO,
-                                       "lost connection in %s", __func__);
-                                break;
-                        }
-			r = func(priv->ssl_ssl,buf,len);
-		}
-		else {
-                        /*
-                         * We actually need these functions to get to
-                         * priv->connected == 1.
-                         */
-			r = ((SSL_unary_func *)func)(priv->ssl_ssl);
-		}
-		switch (SSL_get_error(priv->ssl_ssl,r)) {
-		case SSL_ERROR_NONE:
-			return r;
-		case SSL_ERROR_WANT_READ:
-                        /* If we are attempting to connect/accept then we
-                         * should wait here on the poll, for the SSL
-                         * (re)negotiation to complete, else we would error out
-                         * on the accept/connect.
-                         * If we are here when attempting to read/write
-                         * then we return r (or -1) as the socket is always
-                         * primed for the read event, and it would eventually
-                         * call one of the SSL routines */
-                        /* NOTE: Only way to determine this is a accept/connect
-                         * is to examine buf or func, which is not very
-                         * clean */
-                        if ((func == (SSL_trinary_func *)SSL_read)
-                            || (func == (SSL_trinary_func *) SSL_write)) {
-                                return r;
-                        }
-
-			pfd.fd = priv->sock;
-			pfd.events = POLLIN;
-			if (poll(&pfd,1,-1) < 0) {
-				gf_log(this->name,GF_LOG_ERROR,"poll error %d",
-				       errno);
-			}
-			break;
-		case SSL_ERROR_WANT_WRITE:
-                        if ((func == (SSL_trinary_func *)SSL_read)
-                            || (func == (SSL_trinary_func *) SSL_write)) {
-                                errno = EAGAIN;
-                                return r;
-                        }
-			pfd.fd = priv->sock;
-			pfd.events = POLLOUT;
-			if (poll(&pfd,1,-1) < 0) {
-				gf_log(this->name,GF_LOG_ERROR,"poll error %d",
-				       errno);
-			}
-			break;
-		case SSL_ERROR_SYSCALL:
-			/* This is what we get when remote disconnects. */
-			gf_log(this->name,GF_LOG_DEBUG,
-			       "syscall error (probably remote disconnect)");
-			errno = ENODATA;
-			goto out;
-		default:
-			errno = EIO;
-			goto out;	/* "break" would just loop again */
-		}
-	}
+    int r = (-1);
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    if (buf) {
+        if (priv->connected == -1) {
+            /*
+             * Fields in the SSL structure (especially
+             * the BIO pointers) are not valid at this
+             * point, so we'll segfault if we pass them
+             * to SSL_read/SSL_write.
+             */
+            gf_log(this->name, GF_LOG_INFO, "lost connection in %s", __func__);
+            return -1;
+        }
+        r = func(priv->ssl_ssl, buf, len);
+    } else {
+        /* This should be treated as error */
+        gf_log(this->name, GF_LOG_ERROR, "buffer is empty %s", __func__);
+        goto out;
+    }
+    switch (SSL_get_error(priv->ssl_ssl, r)) {
+        case SSL_ERROR_NONE:
+        /* fall through */
+        case SSL_ERROR_WANT_READ:
+        /* fall through */
+        case SSL_ERROR_WANT_WRITE:
+            errno = EAGAIN;
+            return r;
+
+        case SSL_ERROR_SYSCALL:
+            /* Sometimes SSL_ERROR_SYSCALL returns errno as
+             * EAGAIN. In such a case we should reattempt operation
+             * So, for now, just return the return value and the
+             * errno as is.
+             */
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "syscall error (probably remote disconnect) "
+                   "errno:%d:%s",
+                   errno, strerror(errno));
+            return r;
+        default:
+            errno = EIO;
+            goto out; /* "break" would just loop again */
+    }
 out:
-	return -1;
+    return -1;
+}
+
+#define ssl_read_one(t, b, l)                                                  \
+    ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_read)
+#define ssl_write_one(t, b, l)                                                 \
+    ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_write)
+
+/* set crl verify flags only for server */
+/* see man X509_VERIFY_PARAM_SET_FLAGS(3)
+ * X509_V_FLAG_CRL_CHECK enables CRL checking for the certificate chain
+ * leaf certificate. An error occurs if a suitable CRL cannot be found.
+ * Since we're never going to revoke a gluster node cert, we better disable
+ * CRL check for server certs to avoid getting error and failed connection
+ * attempts.
+ */
+static void
+ssl_clear_crl_verify_flags(SSL_CTX *ssl_ctx)
+{
+#ifdef X509_V_FLAG_CRL_CHECK_ALL
+#ifdef HAVE_SSL_CTX_GET0_PARAM
+    X509_VERIFY_PARAM *vpm;
+
+    vpm = SSL_CTX_get0_param(ssl_ctx);
+    if (vpm) {
+        X509_VERIFY_PARAM_clear_flags(
+            vpm, (X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL));
+    }
+#else
+    /* CRL verify flag need not be cleared for rhel6 kind of clients */
+#endif
+#else
+    gf_log(this->name, GF_LOG_ERROR, "OpenSSL version does not support CRL");
+#endif
+    return;
 }
 
-#define ssl_connect_one(t)   ssl_do((t),NULL,0,(SSL_trinary_func *)SSL_connect)
-#define ssl_accept_one(t)    ssl_do((t),NULL,0,(SSL_trinary_func *)SSL_accept)
-#define ssl_read_one(t,b,l)  ssl_do((t),(b),(l),(SSL_trinary_func *)SSL_read)
-#define ssl_write_one(t,b,l) ssl_do((t),(b),(l),(SSL_trinary_func *)SSL_write)
+/* set crl verify flags only for server */
+static void
+ssl_set_crl_verify_flags(SSL_CTX *ssl_ctx)
+{
+#ifdef X509_V_FLAG_CRL_CHECK_ALL
+#ifdef HAVE_SSL_CTX_GET0_PARAM
+    X509_VERIFY_PARAM *vpm;
+
+    vpm = SSL_CTX_get0_param(ssl_ctx);
+    if (vpm) {
+        unsigned long flags;
 
-static char *
-ssl_setup_connection (rpc_transport_t *this, int server)
+        flags = X509_VERIFY_PARAM_get_flags(vpm);
+        flags |= (X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
+        X509_VERIFY_PARAM_set_flags(vpm, flags);
+    }
+#else
+    X509_STORE *x509store;
+
+    x509store = SSL_CTX_get_cert_store(ssl_ctx);
+    X509_STORE_set_flags(x509store,
+                         X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
+#endif
+#else
+    gf_log(this->name, GF_LOG_ERROR, "OpenSSL version does not support CRL");
+#endif
+}
+
+static int
+ssl_setup_connection_prefix(rpc_transport_t *this, gf_boolean_t server)
 {
-	X509             *peer = NULL;
-	char              peer_CN[256] = "";
-	int               ret = -1;
-	socket_private_t *priv = NULL;
-
-	GF_VALIDATE_OR_GOTO(this->name,this->private,done);
-	priv = this->private;
-
-	priv->ssl_ssl = SSL_new(priv->ssl_ctx);
-	if (!priv->ssl_ssl) {
-		gf_log(this->name,GF_LOG_ERROR,"SSL_new failed");
-		ssl_dump_error_stack(this->name);
-		goto done;
-	}
-	priv->ssl_sbio = BIO_new_socket(priv->sock,BIO_NOCLOSE);
-	if (!priv->ssl_sbio) {
-		gf_log(this->name,GF_LOG_ERROR,"BIO_new_socket failed");
-		ssl_dump_error_stack(this->name);
-		goto free_ssl;
-	}
-	SSL_set_bio(priv->ssl_ssl,priv->ssl_sbio,priv->ssl_sbio);
-
-	if (server) {
-		ret = ssl_accept_one(this);
-	}
-	else {
-		ret = ssl_connect_one(this);
-	}
-
-	/* Make sure _the call_ succeeded. */
-	if (ret < 0) {
-		goto ssl_error;
-	}
-
-	/* Make sure _SSL verification_ succeeded, yielding an identity. */
-	if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) {
-		goto ssl_error;
-	}
-	peer = SSL_get_peer_certificate(priv->ssl_ssl);
-	if (!peer) {
-		goto ssl_error;
-	}
-
-	/* Finally, everything seems OK. */
-	X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
-		NID_commonName, peer_CN, sizeof(peer_CN)-1);
-	peer_CN[sizeof(peer_CN)-1] = '\0';
-	gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN);
-        gf_log (this->name, GF_LOG_DEBUG,
-                "SSL verification succeeded (client: %s) (server: %s)",
-                this->peerinfo.identifier, this->myinfo.identifier);
-        return gf_strdup(peer_CN);
-
-	/* Error paths. */
-ssl_error:
-	gf_log (this->name, GF_LOG_ERROR,
-                "SSL connect error (client: %s) (server: %s)",
-                this->peerinfo.identifier, this->myinfo.identifier);
-	ssl_dump_error_stack(this->name);
+    int ret = -1;
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    if (ssl_setup_connection_params(this) < 0) {
+        gf_log(this->name, GF_LOG_TRACE,
+               "+ ssl_setup_connection_params() failed!");
+        goto done;
+    } else {
+        gf_log(this->name, GF_LOG_TRACE,
+               "+ ssl_setup_connection_params() done!");
+    }
+
+    priv->ssl_error_required = SSL_ERROR_NONE;
+    priv->ssl_connected = _gf_false;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_context_created = _gf_false;
+
+    if (!server && priv->crl_path)
+        ssl_clear_crl_verify_flags(priv->ssl_ctx);
+
+    priv->ssl_ssl = SSL_new(priv->ssl_ctx);
+    if (!priv->ssl_ssl) {
+        gf_log(this->name, GF_LOG_ERROR, "SSL_new failed");
+        ssl_dump_error_stack(this->name);
+        goto done;
+    }
+
+    priv->ssl_sbio = BIO_new_socket(priv->sock, BIO_NOCLOSE);
+    if (!priv->ssl_sbio) {
+        gf_log(this->name, GF_LOG_ERROR, "BIO_new_socket failed");
+        ssl_dump_error_stack(this->name);
+        goto free_ssl;
+    }
+
+    SSL_set_bio(priv->ssl_ssl, priv->ssl_sbio, priv->ssl_sbio);
+    ret = 0;
+    goto done;
+
 free_ssl:
-	SSL_free(priv->ssl_ssl);
-        priv->ssl_ssl = NULL;
+    SSL_free(priv->ssl_ssl);
+    priv->ssl_ssl = NULL;
 done:
-	return NULL;
+    return ret;
+}
+
+static char *
+ssl_setup_connection_postfix(rpc_transport_t *this)
+{
+    X509 *peer = NULL;
+    char peer_CN[256] = "";
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    /* Make sure _SSL verification_ succeeded, yielding an identity. */
+    if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) {
+        goto ssl_error;
+    }
+    peer = SSL_get_peer_certificate(priv->ssl_ssl);
+    if (!peer) {
+        goto ssl_error;
+    }
+
+    SSL_set_mode(priv->ssl_ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
+
+    /* Finally, everything seems OK. */
+    X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName,
+                              peer_CN, sizeof(peer_CN) - 1);
+    peer_CN[sizeof(peer_CN) - 1] = '\0';
+    gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN);
+    gf_log(this->name, GF_LOG_DEBUG,
+           "SSL verification succeeded (client: %s) (server: %s)",
+           this->peerinfo.identifier, this->myinfo.identifier);
+    X509_free(peer);
+    return gf_strdup(peer_CN);
+
+    /* Error paths. */
+ssl_error:
+    gf_log(this->name, GF_LOG_ERROR,
+           "SSL connect error (client: %s) (server: %s)",
+           this->peerinfo.identifier, this->myinfo.identifier);
+    ssl_dump_error_stack(this->name);
+
+    SSL_free(priv->ssl_ssl);
+    priv->ssl_ssl = NULL;
+    return NULL;
 }
 
+static int
+ssl_complete_connection(rpc_transport_t *this)
+{
+    int ret = -1; /*  1 : implies go back to epoll_wait()
+                   *  0 : implies successful ssl connection
+                   * -1: implies continue processing current event
+                   *     as if EPOLLERR has been encountered
+                   */
+    char *cname = NULL;
+    int r = -1;
+    int ssl_error = -1;
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    if (priv->is_server) {
+        r = SSL_accept(priv->ssl_ssl);
+    } else {
+        r = SSL_connect(priv->ssl_ssl);
+    }
+
+    ssl_error = SSL_get_error(priv->ssl_ssl, r);
+    priv->ssl_error_required = ssl_error;
+
+    switch (ssl_error) {
+        case SSL_ERROR_NONE:
+            cname = ssl_setup_connection_postfix(this);
+            if (!cname) {
+                /* we've failed to get the cname so
+                 * we must close the connection
+                 *
+                 * treat this as EPOLLERR
+                 */
+                gf_log(this->name, GF_LOG_TRACE, "error getting cname");
+                errno = ECONNRESET;
+                ret = -1;
+            } else {
+                this->ssl_name = cname;
+                if (priv->is_server) {
+                    priv->ssl_accepted = _gf_true;
+                    gf_log(this->name, GF_LOG_TRACE, "ssl_accepted!");
+                } else {
+                    priv->ssl_connected = _gf_true;
+                    gf_log(this->name, GF_LOG_TRACE, "ssl_connected!");
+                }
+                ret = 0;
+            }
+            break;
+
+        case SSL_ERROR_WANT_READ:
+        /* fall through */
+        case SSL_ERROR_WANT_WRITE:
+            errno = EAGAIN;
+            break;
+
+        case SSL_ERROR_SYSCALL:
+            /* Sometimes SSL_ERROR_SYSCALL returns with errno as EAGAIN
+             * So, we should retry the operation.
+             * So, for now, we just return the return value and errno as is.
+             */
+            break;
+
+        case SSL_ERROR_SSL:
+            /* treat this as EPOLLERR */
+            ret = -1;
+            break;
+
+        default:
+            /* treat this as EPOLLERR */
+            errno = EIO;
+            ret = -1;
+            break;
+    }
+    return ret;
+}
 
 static void
-ssl_teardown_connection (socket_private_t *priv)
+ssl_teardown_connection(socket_private_t *priv)
 {
-        if (priv->ssl_ssl) {
-                SSL_shutdown(priv->ssl_ssl);
-                SSL_clear(priv->ssl_ssl);
-                SSL_free(priv->ssl_ssl);
-                priv->ssl_ssl = NULL;
+    if (priv->ssl_ssl) {
+        SSL_shutdown(priv->ssl_ssl);
+        SSL_clear(priv->ssl_ssl);
+        SSL_free(priv->ssl_ssl);
+        SSL_CTX_free(priv->ssl_ctx);
+        priv->ssl_ssl = NULL;
+        priv->ssl_ctx = NULL;
+        if (priv->ssl_private_key) {
+            GF_FREE(priv->ssl_private_key);
+            priv->ssl_private_key = NULL;
+        }
+        if (priv->ssl_own_cert) {
+            GF_FREE(priv->ssl_own_cert);
+            priv->ssl_own_cert = NULL;
+        }
+        if (priv->ssl_ca_list) {
+            GF_FREE(priv->ssl_ca_list);
+            priv->ssl_ca_list = NULL;
         }
-        priv->use_ssl = _gf_false;
+    }
+    priv->use_ssl = _gf_false;
 }
 
-
 static ssize_t
-__socket_ssl_readv (rpc_transport_t *this, struct iovec *opvector, int opcount)
+__socket_ssl_readv(rpc_transport_t *this, struct iovec *opvector, int opcount)
 {
-	socket_private_t    *priv = NULL;
-	int                  sock = -1;
-	int                  ret = -1;
-
-	priv = this->private;
-	sock = priv->sock;
-
-	if (priv->use_ssl) {
-		ret = ssl_read_one (this, opvector->iov_base, opvector->iov_len);
-	} else {
-		ret = sys_readv (sock, opvector, IOV_MIN(opcount));
-	}
-
-	return ret;
+    socket_private_t *priv = NULL;
+    int sock = -1;
+    int ret = -1;
+
+    priv = this->private;
+    sock = priv->sock;
+
+    if (priv->use_ssl) {
+        gf_log(this->name, GF_LOG_TRACE, "***** reading over SSL");
+        ret = ssl_read_one(this, opvector->iov_base, opvector->iov_len);
+    } else {
+        gf_log(this->name, GF_LOG_TRACE, "***** reading over non-SSL");
+        ret = sys_readv(sock, opvector, IOV_MIN(opcount));
+    }
+
+    return ret;
 }
 
-
 static ssize_t
-__socket_ssl_read (rpc_transport_t *this, void *buf, size_t count)
+__socket_ssl_read(rpc_transport_t *this, void *buf, size_t count)
 {
-	struct iovec iov = {0, };
-	int          ret = -1;
+    struct iovec iov = {
+        0,
+    };
+    int ret = -1;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = __socket_ssl_readv (this, &iov, 1);
+    ret = __socket_ssl_readv(this, &iov, 1);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__socket_cached_read (rpc_transport_t *this, struct iovec *opvector, int opcount)
+__socket_cached_read(rpc_transport_t *this, struct iovec *opvector, int opcount)
 {
-	socket_private_t   *priv = NULL;
-	struct gf_sock_incoming *in = NULL;
-	int                 req_len = -1;
-	int                 ret = -1;
-
-	priv = this->private;
-	in = &priv->incoming;
-	req_len = iov_length (opvector, opcount);
-
-	if (in->record_state == SP_STATE_READING_FRAGHDR) {
-		in->ra_read = 0;
-		in->ra_served = 0;
-		in->ra_max = 0;
-		in->ra_buf = NULL;
-		goto uncached;
-	}
-
-	if (!in->ra_max) {
-		/* first call after passing SP_STATE_READING_FRAGHDR */
-		in->ra_max = min (RPC_FRAGSIZE (in->fraghdr), GF_SOCKET_RA_MAX);
-		/* Note that the in->iobuf is the primary iobuf into which
-		   headers are read into, and in->frag.fragcurrent points to
- 		   some position in the buffer. By using this itself as our
-		   read-ahead cache, we can avoid memory copies in iov_load
-		*/
-		in->ra_buf = in->frag.fragcurrent;
-	}
-
-	/* fill read-ahead */
-	if (in->ra_read < in->ra_max) {
-		ret = __socket_ssl_read (this, &in->ra_buf[in->ra_read],
-					 (in->ra_max - in->ra_read));
-		if (ret > 0)
-			in->ra_read += ret;
-
-		/* we proceed to test if there is still cached data to
-		   be served even if readahead could not progress */
-	}
-
-	/* serve cached */
-	if (in->ra_served < in->ra_read) {
-		ret = iov_load (opvector, opcount, &in->ra_buf[in->ra_served],
-				min (req_len, (in->ra_read - in->ra_served)));
-
-		in->ra_served += ret;
-		/* Do not read uncached and cached in the same call */
-		goto out;
-	}
-
-	if (in->ra_read < in->ra_max)
-		/* If there was no cached data to be served, (and we are
-		   guaranteed to have already performed an attempt to progress
-		   readahead above), and we have not yet read out the full
-		   readahead capacity, then bail out for now without doing
-		   the uncached read below (as that will overtake future cached
-		   read)
-		*/
-		goto out;
+    socket_private_t *priv = NULL;
+    struct gf_sock_incoming *in = NULL;
+    int req_len = -1;
+    int ret = -1;
+
+    priv = this->private;
+    in = &priv->incoming;
+    req_len = iov_length(opvector, opcount);
+
+    if (in->record_state == SP_STATE_READING_FRAGHDR) {
+        in->ra_read = 0;
+        in->ra_served = 0;
+        in->ra_max = 0;
+        in->ra_buf = NULL;
+        goto uncached;
+    }
+
+    if (!in->ra_max) {
+        /* first call after passing SP_STATE_READING_FRAGHDR */
+        in->ra_max = min(RPC_FRAGSIZE(in->fraghdr), GF_SOCKET_RA_MAX);
+        /* Note that the in->iobuf is the primary iobuf into which
+           headers are read into, and in->frag.fragcurrent points to
+           some position in the buffer. By using this itself as our
+           read-ahead cache, we can avoid memory copies in iov_load
+        */
+        in->ra_buf = in->frag.fragcurrent;
+    }
+
+    /* fill read-ahead */
+    if (in->ra_read < in->ra_max) {
+        ret = __socket_ssl_read(this, &in->ra_buf[in->ra_read],
+                                (in->ra_max - in->ra_read));
+        if (ret > 0)
+            in->ra_read += ret;
+
+        /* we proceed to test if there is still cached data to
+           be served even if readahead could not progress */
+    }
+
+    /* serve cached */
+    if (in->ra_served < in->ra_read) {
+        ret = iov_load(opvector, opcount, &in->ra_buf[in->ra_served],
+                       min(req_len, (in->ra_read - in->ra_served)));
+
+        in->ra_served += ret;
+        /* Do not read uncached and cached in the same call */
+        goto out;
+    }
+
+    if (in->ra_read < in->ra_max)
+        /* If there was no cached data to be served, (and we are
+           guaranteed to have already performed an attempt to progress
+           readahead above), and we have not yet read out the full
+           readahead capacity, then bail out for now without doing
+           the uncached read below (as that will overtake future cached
+           read)
+        */
+        goto out;
 uncached:
-	ret = __socket_ssl_readv (this, opvector, opcount);
+    ret = __socket_ssl_readv(this, opvector, opcount);
 out:
-	return ret;
+    return ret;
 }
 
 static gf_boolean_t
-__does_socket_rwv_error_need_logging (socket_private_t *priv, int write)
+__does_socket_rwv_error_need_logging(socket_private_t *priv, int write)
 {
-        int read = !write;
+    int read = !write;
 
-        if (priv->connected == -1) /* Didn't even connect, of course it fails */
-                return _gf_false;
+    if (priv->connected == -1) /* Didn't even connect, of course it fails */
+        return _gf_false;
 
-        if (read && (priv->read_fail_log == _gf_false))
-                return _gf_false;
+    if (read && (priv->read_fail_log == _gf_false))
+        return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 /*
@@ -502,825 +676,795 @@ __does_socket_rwv_error_need_logging (socket_private_t *priv, int write)
  */
 
 static int
-__socket_rwv (rpc_transport_t *this, struct iovec *vector, int count,
-              struct iovec **pending_vector, int *pending_count, size_t *bytes,
-              int write)
+__socket_rwv(rpc_transport_t *this, struct iovec *vector, int count,
+             struct iovec **pending_vector, int *pending_count, size_t *bytes,
+             int write)
 {
-        socket_private_t *priv = NULL;
-        int               sock = -1;
-        int               ret = -1;
-        struct iovec     *opvector = NULL;
-        int               opcount = 0;
-        int               moved = 0;
+    socket_private_t *priv = NULL;
+    int sock = -1;
+    int ret = -1;
+    struct iovec *opvector = NULL;
+    int opcount = 0;
+    int moved = 0;
+
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    sock = priv->sock;
+
+    opvector = vector;
+    opcount = count;
+
+    if (bytes != NULL) {
+        *bytes = 0;
+    }
+
+    while (opcount > 0) {
+        if (opvector->iov_len == 0) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "would have passed zero length to read/write");
+            ++opvector;
+            --opcount;
+            continue;
+        }
+        if (priv->use_ssl && !priv->ssl_ssl) {
+            /*
+             * We could end up here with priv->ssl_ssl still NULL
+             * if (a) the connection failed and (b) some fool
+             * called other socket functions anyway.  Demoting to
+             * non-SSL might be insecure, so just fail it outright.
+             */
+            ret = -1;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "### no priv->ssl_ssl yet; ret = -1;");
+        } else if (write) {
+            if (priv->use_ssl) {
+                ret = ssl_write_one(this, opvector->iov_base,
+                                    opvector->iov_len);
+            } else {
+                ret = sys_writev(sock, opvector, IOV_MIN(opcount));
+            }
+
+            if ((ret == 0) || ((ret < 0) && (errno == EAGAIN))) {
+                /* done for now */
+                break;
+            } else if (ret > 0)
+                this->total_bytes_write += ret;
+        } else {
+            ret = __socket_cached_read(this, opvector, opcount);
+            if (ret == 0) {
+                gf_log(this->name, GF_LOG_DEBUG,
+                       "EOF on socket %d (errno:%d:%s); returning ENODATA",
+                       sock, errno, strerror(errno));
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+                errno = ENODATA;
+                ret = -1;
+            }
+            if ((ret < 0) && (errno == EAGAIN)) {
+                /* done for now */
+                break;
+            } else if (ret > 0)
+                this->total_bytes_read += ret;
+        }
 
-        priv = this->private;
-        sock = priv->sock;
+        if (ret == 0) {
+            /* Mostly due to 'umount' in client */
 
-        opvector = vector;
-        opcount  = count;
+            gf_log(this->name, GF_LOG_DEBUG, "EOF from peer %s",
+                   this->peerinfo.identifier);
+            opcount = -1;
+            errno = ENOTCONN;
+            break;
+        }
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+
+            if (__does_socket_rwv_error_need_logging(priv, write)) {
+                GF_LOG_OCCASIONALLY(priv->log_ctr, this->name, GF_LOG_WARNING,
+                                    "%s on %s failed (%s)",
+                                    write ? "writev" : "readv",
+                                    this->peerinfo.identifier, strerror(errno));
+            }
+
+            if (priv->use_ssl && priv->ssl_ssl) {
+                ssl_dump_error_stack(this->name);
+            }
+            opcount = -1;
+            break;
+        }
 
         if (bytes != NULL) {
-                *bytes = 0;
+            *bytes += ret;
         }
 
-        while (opcount > 0) {
-                if (opvector->iov_len == 0) {
-                        gf_log(this->name,GF_LOG_DEBUG,
-                               "would have passed zero length to read/write");
-                        ++opvector;
-                        --opcount;
-                        continue;
-                }
-                if (priv->use_ssl && !priv->ssl_ssl) {
-                        /*
-                         * We could end up here with priv->ssl_ssl still NULL
-                         * if (a) the connection failed and (b) some fool
-                         * called other socket functions anyway.  Demoting to
-                         * non-SSL might be insecure, so just fail it outright.
-                         */
-                        ret = -1;
-                } else if (write) {
-			if (priv->use_ssl) {
-                                ret = ssl_write_one (this, opvector->iov_base,
-                                                     opvector->iov_len);
-			} else {
-				ret = sys_writev (sock, opvector, IOV_MIN(opcount));
-			}
-
-                        if (ret == 0 || (ret == -1 && errno == EAGAIN)) {
-                                /* done for now */
-                                break;
-                        }
-                        this->total_bytes_write += ret;
-                } else {
-			ret = __socket_cached_read (this, opvector, opcount);
-
-			if (ret == 0) {
-				gf_log(this->name,GF_LOG_DEBUG,"EOF on socket");
-				errno = ENODATA;
-				ret = -1;
-			}
-                        if (ret == -1 && errno == EAGAIN) {
-                                /* done for now */
-                                break;
-                        }
-                        this->total_bytes_read += ret;
-                }
-
-                if (ret == 0) {
-                        /* Mostly due to 'umount' in client */
-
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "EOF from peer %s", this->peerinfo.identifier);
-                        opcount = -1;
-                        errno = ENOTCONN;
-                        break;
-                }
-                if (ret == -1) {
-                        if (errno == EINTR)
-                                continue;
-
-                        if (__does_socket_rwv_error_need_logging (priv,
-                                                                  write)) {
-                                GF_LOG_OCCASIONALLY(priv->log_ctr, this->name,
-                                                    GF_LOG_WARNING,
-                                                    "%s on %s failed (%s)",
-                                                    write ? "writev":"readv",
-                                                    this->peerinfo.identifier,
-                                                    strerror (errno));
-                        }
-
-			if (priv->use_ssl && priv->ssl_ssl) {
-				ssl_dump_error_stack(this->name);
-			}
-                        opcount = -1;
-                        break;
-                }
-
-                if (bytes != NULL) {
-                        *bytes += ret;
-                }
-
-                moved = 0;
-
-                while (moved < ret) {
-                        if (!opcount) {
-                                gf_log(this->name,GF_LOG_DEBUG,
-                                       "ran out of iov, moved %d/%d",
-                                       moved, ret);
-                                goto ran_out;
-                        }
-                        if (!opvector[0].iov_len) {
-                                opvector++;
-                                opcount--;
-                                continue;
-                        }
-                        if ((ret - moved) >= opvector[0].iov_len) {
-                                moved += opvector[0].iov_len;
-                                opvector++;
-                                opcount--;
-                        } else {
-                                opvector[0].iov_len -= (ret - moved);
-                                opvector[0].iov_base += (ret - moved);
-                                moved += (ret - moved);
-                        }
-                }
+        moved = 0;
+
+        while (moved < ret) {
+            if (!opcount) {
+                gf_log(this->name, GF_LOG_DEBUG, "ran out of iov, moved %d/%d",
+                       moved, ret);
+                goto ran_out;
+            }
+            if (!opvector[0].iov_len) {
+                opvector++;
+                opcount--;
+                continue;
+            }
+            if ((ret - moved) >= opvector[0].iov_len) {
+                moved += opvector[0].iov_len;
+                opvector++;
+                opcount--;
+            } else {
+                opvector[0].iov_len -= (ret - moved);
+                opvector[0].iov_base += (ret - moved);
+                moved += (ret - moved);
+            }
         }
+    }
 
 ran_out:
 
-        if (pending_vector)
-                *pending_vector = opvector;
+    if (pending_vector)
+        *pending_vector = opvector;
 
-        if (pending_count)
-                *pending_count = opcount;
+    if (pending_count)
+        *pending_count = opcount;
 
 out:
-        return opcount;
+    return opcount;
 }
 
-
 static int
-__socket_readv (rpc_transport_t *this, struct iovec *vector, int count,
-                struct iovec **pending_vector, int *pending_count,
-                size_t *bytes)
+__socket_readv(rpc_transport_t *this, struct iovec *vector, int count,
+               struct iovec **pending_vector, int *pending_count, size_t *bytes)
 {
-        int ret = -1;
-
-        ret = __socket_rwv (this, vector, count,
-                            pending_vector, pending_count, bytes, 0);
-
-        return ret;
+    return __socket_rwv(this, vector, count, pending_vector, pending_count,
+                        bytes, 0);
 }
 
-
 static int
-__socket_writev (rpc_transport_t *this, struct iovec *vector, int count,
-                 struct iovec **pending_vector, int *pending_count)
+__socket_writev(rpc_transport_t *this, struct iovec *vector, int count,
+                struct iovec **pending_vector, int *pending_count)
 {
-        int ret = -1;
-
-        ret = __socket_rwv (this, vector, count,
-                            pending_vector, pending_count, NULL, 1);
-
-        return ret;
+    return __socket_rwv(this, vector, count, pending_vector, pending_count,
+                        NULL, 1);
 }
 
-
 static int
-__socket_shutdown (rpc_transport_t *this)
+__socket_shutdown(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = this->private;
-
-        priv->connected = -1;
-        ret = shutdown (priv->sock, SHUT_RDWR);
-        if (ret) {
-                /* its already disconnected.. no need to understand
-                   why it failed to shutdown in normal cases */
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "shutdown() returned %d. %s",
-                        ret, strerror (errno));
-        }
-
-        return ret;
+    int ret = -1;
+    socket_private_t *priv = this->private;
+
+    priv->connected = -1;
+    ret = shutdown(priv->sock, SHUT_RDWR);
+    if (ret) {
+        /* its already disconnected.. no need to understand
+           why it failed to shutdown in normal cases */
+        gf_log(this->name, GF_LOG_DEBUG, "shutdown() returned %d. %s", ret,
+               strerror(errno));
+    } else {
+        GF_LOG_OCCASIONALLY(priv->shutdown_log_ctr, this->name, GF_LOG_INFO,
+                            "intentional socket shutdown(%d)", priv->sock);
+    }
+
+    return ret;
 }
 
 static int
-__socket_teardown_connection (rpc_transport_t *this)
+__socket_teardown_connection(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = NULL;
+    socket_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    priv = this->private;
 
-        priv = this->private;
+    if (priv->use_ssl)
+        ssl_teardown_connection(priv);
 
-        if (priv->use_ssl)
-                ssl_teardown_connection(priv);
-
-        ret = __socket_shutdown(this);
-out:
-        return ret;
+    return __socket_shutdown(this);
 }
 
 static int
-__socket_disconnect (rpc_transport_t *this)
+__socket_disconnect(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        gf_log (this->name, GF_LOG_TRACE,
-                "disconnecting %p, state=%u gen=%u sock=%d", this,
-                priv->ot_state, priv->ot_gen, priv->sock);
-
-        if (priv->sock != -1) {
-                gf_log_callingfn (this->name, GF_LOG_TRACE,
-                                  "tearing down socket connection");
-                ret = __socket_teardown_connection (this);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "__socket_teardown_connection () failed: %s",
-                                strerror (errno));
-                }
+    int ret = -1;
+    socket_private_t *priv = NULL;
 
-		if (priv->own_thread) {
-                        /*
-                         * Without this, reconnect (= disconnect + connect)
-                         * won't work except by accident.
-                         */
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "OT_PLEASE_DIE on %p", this);
-                        priv->ot_state = OT_PLEASE_DIE;
-                }
+    priv = this->private;
+
+    gf_log(this->name, GF_LOG_TRACE, "disconnecting %p, sock=%d", this,
+           priv->sock);
+
+    if (priv->sock >= 0) {
+        gf_log_callingfn(this->name, GF_LOG_TRACE,
+                         "tearing down socket connection");
+        ret = __socket_teardown_connection(this);
+        if (ret) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "__socket_teardown_connection () failed: %s",
+                   strerror(errno));
         }
+    }
 
-out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_server_bind (rpc_transport_t *this)
+__socket_server_bind(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
-        int               opt = 1;
-        int               reuse_check_sock = -1;
-        struct sockaddr_storage   unix_addr = {0};
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        ret = setsockopt (priv->sock, SOL_SOCKET, SO_REUSEADDR,
-                          &opt, sizeof (opt));
-
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "setsockopt() for SO_REUSEADDR failed (%s)",
-                        strerror (errno));
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    struct sockaddr_storage unix_addr = {0};
+    int ret = -1;
+    int opt = 1;
+    int reuse_check_sock = -1;
+    uint16_t sin_port = 0;
+    int retries = 0;
+
+    priv = this->private;
+    ctx = this->ctx;
+    cmd_args = &ctx->cmd_args;
+
+    ret = setsockopt(priv->sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "setsockopt() for SO_REUSEADDR failed (%s)", strerror(errno));
+    }
+
+    /* reuse-address doesn't work for unix type sockets */
+    if (AF_UNIX == SA(&this->myinfo.sockaddr)->sa_family) {
+        memcpy(&unix_addr, SA(&this->myinfo.sockaddr),
+               this->myinfo.sockaddr_len);
+        reuse_check_sock = sys_socket(AF_UNIX, SOCK_STREAM, 0);
+        if (reuse_check_sock >= 0) {
+            ret = connect(reuse_check_sock, SA(&unix_addr),
+                          this->myinfo.sockaddr_len);
+            if ((ret != 0) && (ECONNREFUSED == errno)) {
+                sys_unlink(((struct sockaddr_un *)&unix_addr)->sun_path);
+            }
+            gf_log(this->name, GF_LOG_INFO,
+                   "closing (AF_UNIX) reuse check socket %d", reuse_check_sock);
+            sys_close(reuse_check_sock);
         }
-
-        /* reuse-address doesn't work for unix type sockets */
-        if (AF_UNIX == SA (&this->myinfo.sockaddr)->sa_family) {
-                memcpy (&unix_addr, SA (&this->myinfo.sockaddr),
-                        this->myinfo.sockaddr_len);
-                reuse_check_sock = socket (AF_UNIX, SOCK_STREAM, 0);
-                if (reuse_check_sock >= 0) {
-                        ret = connect (reuse_check_sock, SA (&unix_addr),
-                                       this->myinfo.sockaddr_len);
-                        if ((ret == -1) && (ECONNREFUSED == errno)) {
-                                sys_unlink (((struct sockaddr_un *)&unix_addr)->sun_path);
-                        }
-                        sys_close (reuse_check_sock);
-                }
+    }
+
+    if (AF_UNIX != SA(&this->myinfo.sockaddr)->sa_family) {
+        sin_port = (int)ntohs(
+            ((struct sockaddr_in *)&this->myinfo.sockaddr)->sin_port);
+        if (!sin_port) {
+            sin_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
+            ((struct sockaddr_in *)&this->myinfo.sockaddr)->sin_port = htons(
+                sin_port);
         }
-
-        ret = bind (priv->sock, (struct sockaddr *)&this->myinfo.sockaddr,
-                    this->myinfo.sockaddr_len);
-
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "binding to %s failed: %s",
-                        this->myinfo.identifier, strerror (errno));
+        retries = 10;
+        while (retries) {
+            ret = bind(priv->sock, (struct sockaddr *)&this->myinfo.sockaddr,
+                       this->myinfo.sockaddr_len);
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_ERROR, "binding to %s failed: %s",
+                       this->myinfo.identifier, strerror(errno));
                 if (errno == EADDRINUSE) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Port is already in use");
-
-                        ret = -EADDRINUSE;
+                    gf_log(this->name, GF_LOG_ERROR, "Port is already in use");
+                    sleep(1);
+                    retries--;
+                } else {
+                    break;
                 }
+            } else {
+                break;
+            }
+        }
+    } else {
+        ret = bind(priv->sock, (struct sockaddr *)&this->myinfo.sockaddr,
+                   this->myinfo.sockaddr_len);
+
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "binding to %s failed: %s",
+                   this->myinfo.identifier, strerror(errno));
+            if (errno == EADDRINUSE) {
+                gf_log(this->name, GF_LOG_ERROR, "Port is already in use");
+            }
+        }
+    }
+    if (AF_UNIX != SA(&this->myinfo.sockaddr)->sa_family) {
+        if (getsockname(priv->sock, SA(&this->myinfo.sockaddr),
+                        &this->myinfo.sockaddr_len) != 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "getsockname on (%d) failed (%s)", priv->sock,
+                   strerror(errno));
+            ret = -1;
+            goto out;
+        }
+        if (!cmd_args->brick_port) {
+            cmd_args->brick_port = (int)ntohs(
+                ((struct sockaddr_in *)&this->myinfo.sockaddr)->sin_port);
+            gf_log(this->name, GF_LOG_INFO,
+                   "process started listening on port (%d)",
+                   cmd_args->brick_port);
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_nonblock (int fd)
+__socket_nonblock(int fd)
 {
-        int flags = 0;
-        int ret = -1;
+    int flags = 0;
+    int ret = -1;
 
-        flags = fcntl (fd, F_GETFL);
+    flags = fcntl(fd, F_GETFL);
 
-        if (flags != -1)
-                ret = fcntl (fd, F_SETFL, flags | O_NONBLOCK);
+    if (flags >= 0)
+        ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 
-        return ret;
+    return ret;
 }
 
 static int
-__socket_nodelay (int fd)
+__socket_nodelay(int fd)
 {
-        int     on = 1;
-        int     ret = -1;
+    int on = 1;
+    int ret = -1;
 
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY,
-                          &on, sizeof (on));
-        if (!ret)
-                gf_log (THIS->name, GF_LOG_TRACE,
-                        "NODELAY enabled for socket %d", fd);
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
+    if (!ret)
+        gf_log(THIS->name, GF_LOG_TRACE, "NODELAY enabled for socket %d", fd);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_keepalive (int fd, int family, int keepaliveintvl,
-                    int keepaliveidle, int keepalivecnt, int timeout)
+__socket_keepalive(int fd, int family, int keepaliveintvl, int keepaliveidle,
+                   int keepalivecnt, int timeout)
 {
-        int     on = 1;
-        int     ret = -1;
-        int     timeout_ms = timeout * 1000;
-
-        ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep alive option on socket %d", fd);
-                goto err;
-        }
+    int on = 1;
+    int ret = -1;
+#if defined(TCP_USER_TIMEOUT)
+    int timeout_ms = timeout * 1000;
+#endif
 
-        if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE)
-                goto done;
+    ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep alive option on socket %d", fd);
+        goto err;
+    }
+
+    if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE)
+        goto done;
 
 #if !defined(GF_LINUX_HOST_OS) && !defined(__NetBSD__)
 #if defined(GF_SOLARIS_HOST_OS) || defined(__FreeBSD__)
-        ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
+    ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
 #else
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
 #endif
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep alive interval on socket %d", fd);
-                goto err;
-        }
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep alive interval on socket %d", fd);
+        goto err;
+    }
 #else
-        if (family != AF_INET && family != AF_INET6)
-                goto done;
-
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle,
-                          sizeof (keepaliveidle));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep idle %d on socket %d, %s",
-                        keepaliveidle, fd, strerror(errno));
-                goto err;
-        }
-        ret = setsockopt (fd, IPPROTO_TCP , TCP_KEEPINTVL, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep interval %d on socket %d, %s",
-                        keepaliveintvl, fd, strerror(errno));
-                goto err;
-        }
+    if (family != AF_INET && family != AF_INET6)
+        goto done;
+
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle,
+                     sizeof(keepaliveidle));
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep idle %d on socket %d, %s", keepaliveidle, fd,
+               strerror(errno));
+        goto err;
+    }
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep interval %d on socket %d, %s",
+               keepaliveintvl, fd, strerror(errno));
+        goto err;
+    }
 
 #if defined(TCP_USER_TIMEOUT)
-        if (timeout_ms < 0)
-                goto done;
-        ret = setsockopt (fd, IPPROTO_TCP , TCP_USER_TIMEOUT, &timeout_ms,
-                          sizeof (timeout_ms));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING, "failed to set "
-                        "TCP_USER_TIMEOUT %d on socket %d, %s", timeout_ms, fd,
-                        strerror(errno));
-                goto err;
-        }
+    if (timeout_ms < 0)
+        goto done;
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout_ms,
+                     sizeof(timeout_ms));
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set "
+               "TCP_USER_TIMEOUT %d on socket %d, %s",
+               timeout_ms, fd, strerror(errno));
+        goto err;
+    }
 #endif
 #if defined(TCP_KEEPCNT)
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt,
-                          sizeof (keepalivecnt));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING, "failed to set "
-                        "TCP_KEEPCNT %d on socket %d, %s", keepalivecnt, fd,
-                        strerror(errno));
-                goto err;
-        }
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt,
+                     sizeof(keepalivecnt));
+    if (ret != 0) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set "
+               "TCP_KEEPCNT %d on socket %d, %s",
+               keepalivecnt, fd, strerror(errno));
+        goto err;
+    }
 #endif
 #endif
 
 done:
-        gf_log (THIS->name, GF_LOG_TRACE, "Keep-alive enabled for socket: %d, "
-                "(idle: %d, interval: %d, max-probes: %d, timeout: %d)",
-                fd, keepaliveidle, keepaliveintvl, keepalivecnt,
-                timeout);
+    gf_log(THIS->name, GF_LOG_TRACE,
+           "Keep-alive enabled for socket: %d, "
+           "(idle: %d, interval: %d, max-probes: %d, timeout: %d)",
+           fd, keepaliveidle, keepaliveintvl, keepalivecnt, timeout);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_connect_finish (int fd)
+__socket_connect_finish(int fd)
 {
-        int       ret = -1;
-        int       optval = 0;
-        socklen_t optlen = sizeof (int);
+    int ret = -1;
+    int optval = 0;
+    socklen_t optlen = sizeof(int);
 
-        ret = getsockopt (fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
+    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
 
-        if (ret == 0 && optval) {
-                errno = optval;
-                ret = -1;
-        }
+    if (ret == 0 && optval) {
+        errno = optval;
+        ret = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__socket_reset (rpc_transport_t *this)
+__socket_reset(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
+    socket_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    priv = this->private;
 
-        priv = this->private;
+    /* TODO: use mem-pool on incoming data */
 
-        /* TODO: use mem-pool on incoming data */
+    if (priv->incoming.iobref) {
+        iobref_unref(priv->incoming.iobref);
+        priv->incoming.iobref = NULL;
+    }
 
-        if (priv->incoming.iobref) {
-                iobref_unref (priv->incoming.iobref);
-                priv->incoming.iobref = NULL;
-        }
-
-        if (priv->incoming.iobuf) {
-                iobuf_unref (priv->incoming.iobuf);
-                priv->incoming.iobuf = NULL;
-        }
-
-        GF_FREE (priv->incoming.request_info);
+    if (priv->incoming.iobuf) {
+        iobuf_unref(priv->incoming.iobuf);
+        priv->incoming.iobuf = NULL;
+    }
 
-        memset (&priv->incoming, 0, sizeof (priv->incoming));
+    GF_FREE(priv->incoming.request_info);
 
-        event_unregister_close (this->ctx->event_pool, priv->sock, priv->idx);
+    memset(&priv->incoming, 0, sizeof(priv->incoming));
 
-        priv->sock = -1;
-        priv->idx = -1;
-        priv->connected = -1;
-
-out:
-        return;
+    gf_event_unregister_close(this->ctx->event_pool, priv->sock, priv->idx);
+    if (priv->use_ssl && priv->ssl_ssl) {
+        SSL_clear(priv->ssl_ssl);
+        SSL_free(priv->ssl_ssl);
+        priv->ssl_ssl = NULL;
+    }
+    if (priv->ssl_ctx) {
+        SSL_CTX_free(priv->ssl_ctx);
+        priv->ssl_ctx = NULL;
+    }
+    priv->sock = -1;
+    priv->idx = -1;
+    priv->connected = -1;
+    priv->ssl_connected = _gf_false;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_context_created = _gf_false;
+
+    if (priv->ssl_private_key) {
+        GF_FREE(priv->ssl_private_key);
+        priv->ssl_private_key = NULL;
+    }
+    if (priv->ssl_own_cert) {
+        GF_FREE(priv->ssl_own_cert);
+        priv->ssl_own_cert = NULL;
+    }
+    if (priv->ssl_ca_list) {
+        GF_FREE(priv->ssl_ca_list);
+        priv->ssl_ca_list = NULL;
+    }
 }
 
-
 static void
-socket_set_lastfrag (uint32_t *fragsize) {
-        (*fragsize) |= 0x80000000U;
+socket_set_lastfrag(uint32_t *fragsize)
+{
+    (*fragsize) |= 0x80000000U;
 }
 
-
 static void
-socket_set_frag_header_size (uint32_t size, char *haddr)
+socket_set_frag_header_size(uint32_t size, char *haddr)
 {
-        size = htonl (size);
-        memcpy (haddr, &size, sizeof (size));
+    size = htonl(size);
+    memcpy(haddr, &size, sizeof(size));
 }
 
-
 static void
-socket_set_last_frag_header_size (uint32_t size, char *haddr)
+socket_set_last_frag_header_size(uint32_t size, char *haddr)
 {
-        socket_set_lastfrag (&size);
-        socket_set_frag_header_size (size, haddr);
+    socket_set_lastfrag(&size);
+    socket_set_frag_header_size(size, haddr);
 }
 
 static struct ioq *
-__socket_ioq_new (rpc_transport_t *this, rpc_transport_msg_t *msg)
+__socket_ioq_new(rpc_transport_t *this, rpc_transport_msg_t *msg)
 {
-        struct ioq       *entry = NULL;
-        int               count = 0;
-        uint32_t          size  = 0;
+    struct ioq *entry = NULL;
+    int count = 0;
+    uint32_t size = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-
-        /* TODO: use mem-pool */
-        entry = GF_CALLOC (1, sizeof (*entry), gf_common_mt_ioq);
-        if (!entry)
-                return NULL;
+    /* TODO: use mem-pool */
+    entry = GF_CALLOC(1, sizeof(*entry), gf_common_mt_ioq);
+    if (!entry)
+        return NULL;
 
-        count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
+    count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
 
-        GF_ASSERT (count <= (MAX_IOVEC - 1));
+    GF_ASSERT(count <= (MAX_IOVEC - 1));
 
-        size = iov_length (msg->rpchdr, msg->rpchdrcount)
-                + iov_length (msg->proghdr, msg->proghdrcount)
-                + iov_length (msg->progpayload, msg->progpayloadcount);
+    size = iov_length(msg->rpchdr, msg->rpchdrcount) +
+           iov_length(msg->proghdr, msg->proghdrcount) +
+           iov_length(msg->progpayload, msg->progpayloadcount);
 
-        if (size > RPC_MAX_FRAGMENT_SIZE) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "msg size (%u) bigger than the maximum allowed size on "
-                        "sockets (%u)", size, RPC_MAX_FRAGMENT_SIZE);
-                GF_FREE (entry);
-                return NULL;
-        }
+    if (size > RPC_MAX_FRAGMENT_SIZE) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "msg size (%u) bigger than the maximum allowed size on "
+               "sockets (%u)",
+               size, RPC_MAX_FRAGMENT_SIZE);
+        GF_FREE(entry);
+        return NULL;
+    }
 
-        socket_set_last_frag_header_size (size, (char *)&entry->fraghdr);
+    socket_set_last_frag_header_size(size, (char *)&entry->fraghdr);
 
-        entry->vector[0].iov_base = (char *)&entry->fraghdr;
-        entry->vector[0].iov_len = sizeof (entry->fraghdr);
-        entry->count = 1;
+    entry->vector[0].iov_base = (char *)&entry->fraghdr;
+    entry->vector[0].iov_len = sizeof(entry->fraghdr);
+    entry->count = 1;
 
-        if (msg->rpchdr != NULL) {
-                memcpy (&entry->vector[1], msg->rpchdr,
-                        sizeof (struct iovec) * msg->rpchdrcount);
-                entry->count += msg->rpchdrcount;
-        }
+    if (msg->rpchdr != NULL) {
+        memcpy(&entry->vector[1], msg->rpchdr,
+               sizeof(struct iovec) * msg->rpchdrcount);
+        entry->count += msg->rpchdrcount;
+    }
 
-        if (msg->proghdr != NULL) {
-                memcpy (&entry->vector[entry->count], msg->proghdr,
-                        sizeof (struct iovec) * msg->proghdrcount);
-                entry->count += msg->proghdrcount;
-        }
+    if (msg->proghdr != NULL) {
+        memcpy(&entry->vector[entry->count], msg->proghdr,
+               sizeof(struct iovec) * msg->proghdrcount);
+        entry->count += msg->proghdrcount;
+    }
 
-        if (msg->progpayload != NULL) {
-                memcpy (&entry->vector[entry->count], msg->progpayload,
-                        sizeof (struct iovec) * msg->progpayloadcount);
-                entry->count += msg->progpayloadcount;
-        }
+    if (msg->progpayload != NULL) {
+        memcpy(&entry->vector[entry->count], msg->progpayload,
+               sizeof(struct iovec) * msg->progpayloadcount);
+        entry->count += msg->progpayloadcount;
+    }
 
-        entry->pending_vector = entry->vector;
-        entry->pending_count  = entry->count;
+    entry->pending_vector = entry->vector;
+    entry->pending_count = entry->count;
 
-        if (msg->iobref != NULL)
-                entry->iobref = iobref_ref (msg->iobref);
+    if (msg->iobref != NULL)
+        entry->iobref = iobref_ref(msg->iobref);
 
-        INIT_LIST_HEAD (&entry->list);
+    INIT_LIST_HEAD(&entry->list);
 
-out:
-        return entry;
+    return entry;
 }
 
-
 static void
-__socket_ioq_entry_free (struct ioq *entry)
+__socket_ioq_entry_free(struct ioq *entry)
 {
-        GF_VALIDATE_OR_GOTO ("socket", entry, out);
+    GF_VALIDATE_OR_GOTO("socket", entry, out);
 
-        list_del_init (&entry->list);
-        if (entry->iobref)
-                iobref_unref (entry->iobref);
+    list_del_init(&entry->list);
+    if (entry->iobref)
+        iobref_unref(entry->iobref);
 
-        /* TODO: use mem-pool */
-        GF_FREE (entry);
+    /* TODO: use mem-pool */
+    GF_FREE(entry);
 
 out:
-        return;
+    return;
 }
 
-
 static void
-__socket_ioq_flush (rpc_transport_t *this)
+__socket_ioq_flush(socket_private_t *priv)
 {
-        socket_private_t *priv = NULL;
-        struct ioq       *entry = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        while (!list_empty (&priv->ioq)) {
-                entry = priv->ioq_next;
-                __socket_ioq_entry_free (entry);
-        }
+    struct ioq *entry = NULL;
 
-out:
-        return;
+    while (!list_empty(&priv->ioq)) {
+        entry = priv->ioq_next;
+        __socket_ioq_entry_free(entry);
+    }
 }
 
-
 static int
-__socket_ioq_churn_entry (rpc_transport_t *this, struct ioq *entry, int direct)
+__socket_ioq_churn_entry(rpc_transport_t *this, struct ioq *entry)
 {
-        int               ret = -1;
-	socket_private_t *priv = NULL;
-	char              a_byte = 0;
+    int ret = -1;
 
-        ret = __socket_writev (this, entry->pending_vector,
-                               entry->pending_count,
-                               &entry->pending_vector,
-                               &entry->pending_count);
+    ret = __socket_writev(this, entry->pending_vector, entry->pending_count,
+                          &entry->pending_vector, &entry->pending_count);
 
-        if (ret == 0) {
-                /* current entry was completely written */
-                GF_ASSERT (entry->pending_count == 0);
-                __socket_ioq_entry_free (entry);
-		priv = this->private;
-		if (priv->own_thread) {
-			/*
-			 * The pipe should only remain readable if there are
-			 * more entries after this, so drain the byte
-			 * representing this entry.
-			 */
-			if (!direct && sys_read (priv->pipe[0], &a_byte, 1) < 1) {
-				gf_log(this->name,GF_LOG_WARNING,
-				       "read error on pipe");
-			}
-		}
-        }
+    if (ret == 0) {
+        /* current entry was completely written */
+        GF_ASSERT(entry->pending_count == 0);
+        __socket_ioq_entry_free(entry);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_ioq_churn (rpc_transport_t *this)
+__socket_ioq_churn(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = 0;
-        struct ioq       *entry = NULL;
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct ioq *entry = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    priv = this->private;
 
-        priv = this->private;
+    while (!list_empty(&priv->ioq)) {
+        /* pick next entry */
+        entry = priv->ioq_next;
 
-        while (!list_empty (&priv->ioq)) {
-                /* pick next entry */
-                entry = priv->ioq_next;
+        ret = __socket_ioq_churn_entry(this, entry);
 
-                ret = __socket_ioq_churn_entry (this, entry, 0);
-
-                if (ret != 0)
-                        break;
-        }
+        if (ret != 0)
+            break;
+    }
 
-        if (!priv->own_thread && list_empty (&priv->ioq)) {
-                /* all pending writes done, not interested in POLLOUT */
-                priv->idx = event_select_on (this->ctx->event_pool,
-                                             priv->sock, priv->idx, -1, 0);
-        }
+    if (list_empty(&priv->ioq)) {
+        /* all pending writes done, not interested in POLLOUT */
+        priv->idx = gf_event_select_on(this->ctx->event_pool, priv->sock,
+                                       priv->idx, -1, 0);
+    }
 
-out:
-        return ret;
+    return ret;
 }
 
-
 static gf_boolean_t
-socket_event_poll_err (rpc_transport_t *this, int gen, int idx)
+socket_event_poll_err(rpc_transport_t *this, int gen, int idx)
 {
-        socket_private_t *priv          = NULL;
-        gf_boolean_t      socket_closed = _gf_false;
+    socket_private_t *priv = NULL;
+    gf_boolean_t socket_closed = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    priv = this->private;
 
-        priv = this->private;
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if ((priv->gen == gen) && (priv->idx == idx) && (priv->sock >= 0)) {
+            __socket_ioq_flush(priv);
+            __socket_reset(this);
+            socket_closed = _gf_true;
+        }
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
-        pthread_mutex_lock (&priv->lock);
+    if (socket_closed) {
+        pthread_mutex_lock(&priv->notify.lock);
         {
-                if ((priv->gen == gen) && (priv->idx == idx)
-                    && (priv->sock != -1)) {
-                        __socket_ioq_flush (this);
-                        __socket_reset (this);
-                        socket_closed = _gf_true;
-                }
+            while (priv->notify.in_progress)
+                pthread_cond_wait(&priv->notify.cond, &priv->notify.lock);
         }
-        pthread_mutex_unlock (&priv->lock);
-
-        if (socket_closed) {
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        while (priv->notify.in_progress)
-                                pthread_cond_wait (&priv->notify.cond,
-                                                   &priv->notify.lock);
-                }
-                pthread_mutex_unlock (&priv->notify.lock);
+        pthread_mutex_unlock(&priv->notify.lock);
 
-                rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this);
-        }
+        rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, this);
+    }
 
-out:
-        return socket_closed;
+    return socket_closed;
 }
 
-
 static int
-socket_event_poll_out (rpc_transport_t *this)
+socket_event_poll_out(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        pthread_mutex_lock (&priv->lock);
-        {
-                if (priv->connected == 1) {
-                        ret = __socket_ioq_churn (this);
-
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "__socket_ioq_churn returned -1; "
-                                        "disconnecting socket");
-                                __socket_disconnect (this);
-                        }
-                }
+    socket_private_t *priv = NULL;
+    int ret = -1;
+
+    priv = this->private;
+
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected == 1) {
+            ret = __socket_ioq_churn(this);
+
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "__socket_ioq_churn returned -1; "
+                       "disconnecting socket");
+                __socket_disconnect(this);
+            }
         }
-        pthread_mutex_unlock (&priv->lock);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
-        if (ret == 0)
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_SENT, NULL);
+    if (ret == 0)
+        rpc_transport_notify(this, RPC_TRANSPORT_MSG_SENT, NULL);
 
-out:
-        return ret;
-}
+    if (ret > 0)
+        ret = 0;
 
+    return ret;
+}
 
 static int
-__socket_read_simple_msg (rpc_transport_t *this)
+__socket_read_simple_msg(rpc_transport_t *this)
 {
-        int                           ret            = 0;
-        uint32_t                      remaining_size = 0;
-        size_t                        bytes_read     = 0;
-        socket_private_t             *priv           = NULL;
-        struct gf_sock_incoming      *in             = NULL;
-        struct gf_sock_incoming_frag *frag           = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    int ret = 0;
+    uint32_t remaining_size = 0;
+    size_t bytes_read = 0;
+    socket_private_t *priv = NULL;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
 
-        priv = this->private;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        in = &priv->incoming;
-        frag = &in->frag;
+    priv = this->private;
 
-        switch (frag->simple_state) {
+    in = &priv->incoming;
+    frag = &in->frag;
 
+    switch (frag->simple_state) {
         case SP_STATE_SIMPLE_MSG_INIT:
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                __socket_proto_init_pending (priv, remaining_size);
+            __socket_proto_init_pending(priv, remaining_size);
 
-                frag->simple_state = SP_STATE_READING_SIMPLE_MSG;
+            frag->simple_state = SP_STATE_READING_SIMPLE_MSG;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_SIMPLE_MSG:
-                ret = 0;
+            ret = 0;
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if (remaining_size > 0) {
-                        ret = __socket_readv (this,
-                                              in->pending_vector, 1,
-                                              &in->pending_vector,
-                                              &in->pending_count,
-                                              &bytes_read);
-                }
+            if (remaining_size > 0) {
+                ret = __socket_readv(this, in->pending_vector, 1,
+                                     &in->pending_vector, &in->pending_count,
+                                     &bytes_read);
+            }
 
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "reading from socket failed. Error (%s), "
-                                "peer (%s)", strerror (errno),
-                                this->peerinfo.identifier);
-                        break;
-                }
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "reading from socket failed. Error (%s), "
+                       "peer (%s)",
+                       strerror(errno), this->peerinfo.identifier);
+                break;
+            }
 
-                frag->bytes_read += bytes_read;
-                frag->fragcurrent += bytes_read;
+            frag->bytes_read += bytes_read;
+            frag->fragcurrent += bytes_read;
 
-                if (ret > 0) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "partial read on non-blocking socket.");
-                        break;
-                }
+            if (ret > 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "partial read on non-blocking socket.");
+                ret = 0;
+                break;
+            }
 
-                if (ret == 0) {
-                        frag->simple_state =  SP_STATE_SIMPLE_MSG_INIT;
-                }
-        }
+            if (ret == 0) {
+                frag->simple_state = SP_STATE_SIMPLE_MSG_INIT;
+            }
+    }
 
 out:
-        return ret;
-}
-
-
-static int
-__socket_read_simple_request (rpc_transport_t *this)
-{
-        return __socket_read_simple_msg (this);
+    return ret;
 }
 
-
 #define rpc_cred_addr(buf) (buf + RPC_MSGTYPE_SIZE + RPC_CALL_BODY_SIZE - 4)
 
 #define rpc_verf_addr(fragcurrent) (fragcurrent - 4)
@@ -1332,1730 +1476,1824 @@ __socket_read_simple_request (rpc_transport_t *this)
 #define rpc_procnum_addr(buf) (buf + RPC_MSGTYPE_SIZE + 12)
 
 static int
-__socket_read_vectored_request (rpc_transport_t *this, rpcsvc_vector_sizer vector_sizer)
+__socket_read_vectored_request(rpc_transport_t *this,
+                               rpcsvc_vector_sizer vector_sizer)
 {
-        socket_private_t *priv                   = NULL;
-        int               ret                    = 0;
-        uint32_t          credlen                = 0, verflen = 0;
-        char             *addr                   = NULL;
-        struct iobuf     *iobuf                  = NULL;
-        uint32_t          remaining_size         = 0;
-        ssize_t           readsize               = 0;
-        size_t            size                   = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-        sp_rpcfrag_request_state_t   *request    = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-        request = &frag->call_body.request;
-
-        switch (request->vector_state) {
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    uint32_t credlen = 0, verflen = 0;
+    char *addr = NULL;
+    struct iobuf *iobuf = NULL;
+    uint32_t remaining_size = 0;
+    ssize_t readsize = 0;
+    size_t size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    sp_rpcfrag_request_state_t *request = NULL;
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+    request = &frag->call_body.request;
+
+    switch (request->vector_state) {
         case SP_STATE_VECTORED_REQUEST_INIT:
-                request->vector_sizer_state = 0;
+            request->vector_sizer_state = 0;
 
-                addr = rpc_cred_addr (iobuf_ptr (in->iobuf));
+            addr = rpc_cred_addr(iobuf_ptr(in->iobuf));
 
-                /* also read verf flavour and verflen */
-                credlen = ntoh32 (*((uint32_t *)addr))
-                        +  RPC_AUTH_FLAVOUR_N_LENGTH_SIZE;
+            /* also read verf flavour and verflen */
+            credlen = ntoh32(*((uint32_t *)addr)) +
+                      RPC_AUTH_FLAVOUR_N_LENGTH_SIZE;
 
-                __socket_proto_init_pending (priv, credlen);
+            __socket_proto_init_pending(priv, credlen);
 
-                request->vector_state = SP_STATE_READING_CREDBYTES;
+            request->vector_state = SP_STATE_READING_CREDBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_CREDBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_CREDBYTES;
+            request->vector_state = SP_STATE_READ_CREDBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_CREDBYTES:
-                addr = rpc_verf_addr (frag->fragcurrent);
-                verflen = ntoh32 (*((uint32_t *)addr));
+            addr = rpc_verf_addr(frag->fragcurrent);
+            verflen = ntoh32(*((uint32_t *)addr));
 
-                if (verflen == 0) {
-                        request->vector_state = SP_STATE_READ_VERFBYTES;
-                        goto sp_state_read_verfbytes;
-                }
-                __socket_proto_init_pending (priv, verflen);
+            if (verflen == 0) {
+                request->vector_state = SP_STATE_READ_VERFBYTES;
+                goto sp_state_read_verfbytes;
+            }
+            __socket_proto_init_pending(priv, verflen);
 
-                request->vector_state = SP_STATE_READING_VERFBYTES;
+            request->vector_state = SP_STATE_READING_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_VERFBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_VERFBYTES;
+            request->vector_state = SP_STATE_READ_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_VERFBYTES:
-sp_state_read_verfbytes:
-		/* set the base_addr 'persistently' across multiple calls
-		   into the state machine */
-                in->proghdr_base_addr = frag->fragcurrent;
+        sp_state_read_verfbytes:
+            /* set the base_addr 'persistently' across multiple calls
+               into the state machine */
+            in->proghdr_base_addr = frag->fragcurrent;
 
-                request->vector_sizer_state =
-                        vector_sizer (request->vector_sizer_state,
-                                      &readsize, in->proghdr_base_addr,
-                                      frag->fragcurrent);
-                __socket_proto_init_pending (priv, readsize);
+            request->vector_sizer_state = vector_sizer(
+                request->vector_sizer_state, &readsize, in->proghdr_base_addr,
+                frag->fragcurrent);
+            __socket_proto_init_pending(priv, readsize);
 
-                request->vector_state = SP_STATE_READING_PROGHDR;
+            request->vector_state = SP_STATE_READING_PROGHDR;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROGHDR:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-		request->vector_state =	SP_STATE_READ_PROGHDR;
+            request->vector_state = SP_STATE_READ_PROGHDR;
 
-		/* fall through */
+            /* fall through */
 
-	case SP_STATE_READ_PROGHDR:
-sp_state_read_proghdr:
-                request->vector_sizer_state =
-                        vector_sizer (request->vector_sizer_state,
-                                      &readsize, in->proghdr_base_addr,
-                                      frag->fragcurrent);
-                if (readsize == 0) {
-                        request->vector_state = SP_STATE_READ_PROGHDR_XDATA;
-			goto sp_state_read_proghdr_xdata;
-                }
+        case SP_STATE_READ_PROGHDR:
+        sp_state_read_proghdr:
+            request->vector_sizer_state = vector_sizer(
+                request->vector_sizer_state, &readsize, in->proghdr_base_addr,
+                frag->fragcurrent);
+            if (readsize == 0) {
+                request->vector_state = SP_STATE_READ_PROGHDR_XDATA;
+                goto sp_state_read_proghdr_xdata;
+            }
 
-		__socket_proto_init_pending (priv, readsize);
+            __socket_proto_init_pending(priv, readsize);
 
-                request->vector_state =	SP_STATE_READING_PROGHDR_XDATA;
+            request->vector_state = SP_STATE_READING_PROGHDR_XDATA;
 
-		/* fall through */
+            /* fall through */
 
-	case SP_STATE_READING_PROGHDR_XDATA:
-		__socket_proto_read (priv, ret);
+        case SP_STATE_READING_PROGHDR_XDATA:
+            __socket_proto_read(priv, ret);
 
-		request->vector_state =	SP_STATE_READ_PROGHDR;
-		/* check if the vector_sizer() has more to say */
-		goto sp_state_read_proghdr;
+            request->vector_state = SP_STATE_READ_PROGHDR;
+            /* check if the vector_sizer() has more to say */
+            goto sp_state_read_proghdr;
 
         case SP_STATE_READ_PROGHDR_XDATA:
-sp_state_read_proghdr_xdata:
-                if (in->payload_vector.iov_base == NULL) {
-
-                        size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-                        if (!iobuf) {
-                                ret = -1;
-                                break;
-                        }
+        sp_state_read_proghdr_xdata:
+            if (in->payload_vector.iov_base == NULL) {
+                size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (!iobuf) {
+                    ret = -1;
+                    break;
+                }
 
-                        if (in->iobref == NULL) {
-                                in->iobref = iobref_new ();
-                                if (in->iobref == NULL) {
-                                        ret = -1;
-                                        iobuf_unref (iobuf);
-                                        break;
-                                }
-                        }
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        break;
+                    }
+                }
 
-                        iobref_add (in->iobref, iobuf);
+                iobref_add(in->iobref, iobuf);
 
-                        in->payload_vector.iov_base = iobuf_ptr (iobuf);
-                        frag->fragcurrent = iobuf_ptr (iobuf);
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                frag->fragcurrent = iobuf_ptr(iobuf);
 
-                        iobuf_unref (iobuf);
-                }
+                iobuf_unref(iobuf);
+            }
 
-                request->vector_state = SP_STATE_READING_PROG;
+            request->vector_state = SP_STATE_READING_PROG;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROG:
-                /* now read the remaining rpc msg into buffer pointed by
-                 * fragcurrent
-                 */
+            /* now read the remaining rpc msg into buffer pointed by
+             * fragcurrent
+             */
 
-                ret = __socket_read_simple_msg (this);
+            ret = __socket_read_simple_msg(this);
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1) ||
-                    ((ret == 0) && (remaining_size == 0)
-                     && RPC_LASTFRAG (in->fraghdr))) {
-                        request->vector_state = SP_STATE_VECTORED_REQUEST_INIT;
-                        in->payload_vector.iov_len
-                                = ((unsigned long)frag->fragcurrent
-                                   - (unsigned long)in->payload_vector.iov_base);
-                }
-                break;
-        }
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              RPC_LASTFRAG(in->fraghdr))) {
+                request->vector_state = SP_STATE_VECTORED_REQUEST_INIT;
+                in->payload_vector.iov_len = ((unsigned long)frag->fragcurrent -
+                                              (unsigned long)
+                                                  in->payload_vector.iov_base);
+            }
+            break;
+    }
 
-out:
-        return ret;
+    return ret;
 }
 
 static int
-__socket_read_request (rpc_transport_t *this)
+__socket_read_request(rpc_transport_t *this)
 {
-        socket_private_t *priv               = NULL;
-        uint32_t          prognum            = 0, procnum = 0, progver = 0;
-        uint32_t          remaining_size     = 0;
-        int               ret                = -1;
-        char             *buf                = NULL;
-        rpcsvc_vector_sizer     vector_sizer = NULL;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-        sp_rpcfrag_request_state_t   *request    = NULL;
+    socket_private_t *priv = NULL;
+    uint32_t prognum = 0, procnum = 0, progver = 0;
+    uint32_t remaining_size = 0;
+    int ret = -1;
+    char *buf = NULL;
+    rpcsvc_vector_sizer vector_sizer = NULL;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    sp_rpcfrag_request_state_t *request = NULL;
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+    request = &frag->call_body.request;
+
+    switch (request->header_state) {
+        case SP_STATE_REQUEST_HEADER_INIT:
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+            __socket_proto_init_pending(priv, RPC_CALL_BODY_SIZE);
 
-        priv = this->private;
+            request->header_state = SP_STATE_READING_RPCHDR1;
 
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-        request = &frag->call_body.request;
+            /* fall through */
 
-        switch (request->header_state) {
+        case SP_STATE_READING_RPCHDR1:
+            __socket_proto_read(priv, ret);
 
-        case SP_STATE_REQUEST_HEADER_INIT:
+            request->header_state = SP_STATE_READ_RPCHDR1;
 
-                __socket_proto_init_pending (priv, RPC_CALL_BODY_SIZE);
+            /* fall through */
 
-                request->header_state = SP_STATE_READING_RPCHDR1;
+        case SP_STATE_READ_RPCHDR1:
+            buf = rpc_prognum_addr(iobuf_ptr(in->iobuf));
+            prognum = ntoh32(*((uint32_t *)buf));
 
-                /* fall through */
+            buf = rpc_progver_addr(iobuf_ptr(in->iobuf));
+            progver = ntoh32(*((uint32_t *)buf));
 
-        case SP_STATE_READING_RPCHDR1:
-                __socket_proto_read (priv, ret);
+            buf = rpc_procnum_addr(iobuf_ptr(in->iobuf));
+            procnum = ntoh32(*((uint32_t *)buf));
 
-                request->header_state = SP_STATE_READ_RPCHDR1;
+            if (priv->is_server) {
+                /* this check is needed as rpcsvc and rpc-clnt
+                 * actor structures are not same */
+                vector_sizer = rpcsvc_get_program_vector_sizer(
+                    (rpcsvc_t *)this->mydata, prognum, progver, procnum);
+            }
 
-                /* fall through */
+            if (vector_sizer) {
+                ret = __socket_read_vectored_request(this, vector_sizer);
+            } else {
+                ret = __socket_read_simple_msg(this);
+            }
 
-        case SP_STATE_READ_RPCHDR1:
-                buf = rpc_prognum_addr (iobuf_ptr (in->iobuf));
-                prognum = ntoh32 (*((uint32_t *)buf));
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                buf = rpc_progver_addr (iobuf_ptr (in->iobuf));
-                progver = ntoh32 (*((uint32_t *)buf));
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              (RPC_LASTFRAG(in->fraghdr)))) {
+                request->header_state = SP_STATE_REQUEST_HEADER_INIT;
+            }
 
-                buf = rpc_procnum_addr (iobuf_ptr (in->iobuf));
-                procnum = ntoh32 (*((uint32_t *)buf));
+            break;
+    }
 
-                if (priv->is_server) {
-                        /* this check is needed as rpcsvc and rpc-clnt
-                         * actor structures are not same */
-                        vector_sizer =
-                                rpcsvc_get_program_vector_sizer ((rpcsvc_t *)this->mydata,
-                                                                 prognum, progver, procnum);
-                }
+    return ret;
+}
 
-                if (vector_sizer) {
-                        ret = __socket_read_vectored_request (this, vector_sizer);
-                } else {
-                        ret = __socket_read_simple_request (this);
-                }
+static int
+__socket_read_accepted_successful_reply(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
+    gfs3_read_rsp read_rsp = {
+        0,
+    };
+    ssize_t size = 0;
+    ssize_t default_read_size = 0;
+    XDR xdr;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    uint32_t remaining_size = 0;
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_success_state) {
+        case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT:
+            default_read_size = xdr_sizeof((xdrproc_t)xdr_gfs3_read_rsp,
+                                           &read_rsp);
+
+            /* We need to store the current base address because we will
+             * need it after a partial read. */
+            in->proghdr_base_addr = frag->fragcurrent;
+
+            __socket_proto_init_pending(priv, default_read_size);
+
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_HEADER;
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            /* fall through */
 
-                if ((ret == -1)
-                    || ((ret == 0)
-                        && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        request->header_state = SP_STATE_REQUEST_HEADER_INIT;
+        case SP_STATE_READING_PROC_HEADER:
+            __socket_proto_read(priv, ret);
+
+            /* there can be 'xdata' in read response, figure it out */
+            default_read_size = frag->fragcurrent - in->proghdr_base_addr;
+            xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size,
+                          XDR_DECODE);
+
+            /* This will fail if there is xdata sent from server, if not,
+               well and good, we don't need to worry about  */
+            xdr_gfs3_read_rsp(&xdr, &read_rsp);
+
+            free(read_rsp.xdata.xdata_val);
+
+            /* need to round off to proper gf_roof (%4), as XDR packing pads
+               the end of opaque object with '0' */
+            size = gf_roof(read_rsp.xdata.xdata_len, 4);
+
+            if (!size) {
+                frag->call_body.reply
+                    .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+                goto read_proc_opaque;
+            }
+
+            __socket_proto_init_pending(priv, size);
+
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_OPAQUE;
+            /* fall through */
+
+        case SP_STATE_READING_PROC_OPAQUE:
+            __socket_proto_read(priv, ret);
+
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+            /* fall through */
+
+        case SP_STATE_READ_PROC_OPAQUE:
+        read_proc_opaque:
+            if (in->payload_vector.iov_base == NULL) {
+                size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read);
+
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (iobuf == NULL) {
+                    ret = -1;
+                    goto out;
                 }
 
-                break;
-        }
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        goto out;
+                    }
+                }
 
-out:
-        return ret;
-}
+                ret = iobref_add(in->iobref, iobuf);
+                iobuf_unref(iobuf);
+                if (ret < 0) {
+                    goto out;
+                }
 
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                in->payload_vector.iov_len = size;
+            }
 
-static int
-__socket_read_accepted_successful_reply (rpc_transport_t *this)
-{
-        socket_private_t *priv              = NULL;
-        int               ret               = 0;
-        struct iobuf     *iobuf             = NULL;
-        gfs3_read_rsp     read_rsp          = {0, };
-        ssize_t           size              = 0;
-        ssize_t           default_read_size = 0;
-        XDR               xdr;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
+            frag->fragcurrent = in->payload_vector.iov_base;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_HEADER;
 
-        priv = this->private;
+            /* fall through */
 
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
+        case SP_STATE_READ_PROC_HEADER:
+            /* now read the entire remaining msg into new iobuf */
+            ret = __socket_read_simple_msg(this);
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              RPC_LASTFRAG(in->fraghdr))) {
+                frag->call_body.reply.accepted_success_state =
+                    SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
+            }
+
+            break;
+    }
 
-        switch (frag->call_body.reply.accepted_success_state) {
+out:
+    return ret;
+}
 
+static int
+__socket_read_accepted_successful_reply_v2(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
+    gfx_read_rsp read_rsp = {
+        0,
+    };
+    ssize_t size = 0;
+    ssize_t default_read_size = 0;
+    XDR xdr;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    uint32_t remaining_size = 0;
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_success_state) {
         case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT:
-                default_read_size = xdr_sizeof ((xdrproc_t) xdr_gfs3_read_rsp,
-                                                &read_rsp);
+            default_read_size = xdr_sizeof((xdrproc_t)xdr_gfx_read_rsp,
+                                           &read_rsp);
 
-                /* We need to store the current base address because we will
-                 * need it after a partial read. */
-                in->proghdr_base_addr = frag->fragcurrent;
+            /* We need to store the current base address because we will
+             * need it after a partial read. */
+            in->proghdr_base_addr = frag->fragcurrent;
 
-                __socket_proto_init_pending (priv, default_read_size);
+            __socket_proto_init_pending(priv, default_read_size);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_HEADER;
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_HEADER;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROC_HEADER:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                /* there can be 'xdata' in read response, figure it out */
-                default_read_size = frag->fragcurrent - in->proghdr_base_addr;
-                xdrmem_create (&xdr, in->proghdr_base_addr, default_read_size,
-                               XDR_DECODE);
+            /* there can be 'xdata' in read response, figure it out */
+            default_read_size = frag->fragcurrent - in->proghdr_base_addr;
 
-                /* This will fail if there is xdata sent from server, if not,
-                   well and good, we don't need to worry about  */
-                xdr_gfs3_read_rsp (&xdr, &read_rsp);
+            xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size,
+                          XDR_DECODE);
 
-                free (read_rsp.xdata.xdata_val);
+            /* This will fail if there is xdata sent from server, if not,
+               well and good, we don't need to worry about  */
+            xdr_gfx_read_rsp(&xdr, &read_rsp);
 
-                /* need to round off to proper roof (%4), as XDR packing pads
-                   the end of opaque object with '0' */
-                size = roof (read_rsp.xdata.xdata_len, 4);
+            free(read_rsp.xdata.pairs.pairs_val);
 
-                if (!size) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_READ_PROC_OPAQUE;
-                        goto read_proc_opaque;
-                }
+            /* need to round off to proper gf_roof (%4), as XDR packing pads
+               the end of opaque object with '0' */
+            size = gf_roof(read_rsp.xdata.xdr_size, 4);
 
-                __socket_proto_init_pending (priv, size);
+            if (!size) {
+                frag->call_body.reply
+                    .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+                goto read_proc_opaque;
+            }
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_OPAQUE;
+            __socket_proto_init_pending(priv, size);
+
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READING_PROC_OPAQUE:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_OPAQUE;
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READ_PROC_OPAQUE:
         read_proc_opaque:
-                if (in->payload_vector.iov_base == NULL) {
-
-                        size = (RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read);
-
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-                        if (iobuf == NULL) {
-                                ret = -1;
-                                goto out;
-                        }
-
-                        if (in->iobref == NULL) {
-                                in->iobref = iobref_new ();
-                                if (in->iobref == NULL) {
-                                        ret = -1;
-                                        iobuf_unref (iobuf);
-                                        goto out;
-                                }
-                        }
+            if (in->payload_vector.iov_base == NULL) {
+                size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read);
 
-                        iobref_add (in->iobref, iobuf);
-                        iobuf_unref (iobuf);
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (iobuf == NULL) {
+                    ret = -1;
+                    goto out;
+                }
 
-                        in->payload_vector.iov_base = iobuf_ptr (iobuf);
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        goto out;
+                    }
+                }
 
-                        in->payload_vector.iov_len = size;
+                ret = iobref_add(in->iobref, iobuf);
+                iobuf_unref(iobuf);
+                if (ret < 0) {
+                    goto out;
                 }
 
-                frag->fragcurrent = in->payload_vector.iov_base;
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                in->payload_vector.iov_len = size;
+            }
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_HEADER;
+            frag->fragcurrent = in->payload_vector.iov_base;
 
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_HEADER;
 
-        case SP_STATE_READ_PROC_HEADER:
-                /* now read the entire remaining msg into new iobuf */
-                ret = __socket_read_simple_msg (this);
-                if ((ret == -1)
-                    || ((ret == 0) && RPC_LASTFRAG (in->fraghdr))) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
-                }
+            /* fall through */
 
-                break;
-        }
+        case SP_STATE_READ_PROC_HEADER:
+            /* now read the entire remaining msg into new iobuf */
+            ret = __socket_read_simple_msg(this);
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              RPC_LASTFRAG(in->fraghdr))) {
+                frag->call_body.reply.accepted_success_state =
+                    SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
+            }
+
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 #define rpc_reply_verflen_addr(fragcurrent) ((char *)fragcurrent - 4)
 #define rpc_reply_accept_status_addr(fragcurrent) ((char *)fragcurrent - 4)
 
 static int
-__socket_read_accepted_reply (rpc_transport_t *this)
+__socket_read_accepted_reply(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int               ret            = -1;
-        char             *buf            = NULL;
-        uint32_t          verflen        = 0, len = 0;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.accepted_state) {
-
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    char *buf = NULL;
+    uint32_t verflen = 0, len = 0;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_state) {
         case SP_STATE_ACCEPTED_REPLY_INIT:
-                __socket_proto_init_pending (priv,
-                                             RPC_AUTH_FLAVOUR_N_LENGTH_SIZE);
+            __socket_proto_init_pending(priv, RPC_AUTH_FLAVOUR_N_LENGTH_SIZE);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READING_REPLY_VERFLEN;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READING_REPLY_VERFLEN;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_VERFLEN:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READ_REPLY_VERFLEN;
+            frag->call_body.reply.accepted_state = SP_STATE_READ_REPLY_VERFLEN;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_VERFLEN:
-                buf = rpc_reply_verflen_addr (frag->fragcurrent);
+            buf = rpc_reply_verflen_addr(frag->fragcurrent);
 
-                verflen = ntoh32 (*((uint32_t *) buf));
+            verflen = ntoh32(*((uint32_t *)buf));
 
-                /* also read accept status along with verf data */
-                len = verflen + RPC_ACCEPT_STATUS_LEN;
+            /* also read accept status along with verf data */
+            len = verflen + RPC_ACCEPT_STATUS_LEN;
 
-                __socket_proto_init_pending (priv, len);
+            __socket_proto_init_pending(priv, len);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READING_REPLY_VERFBYTES;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READING_REPLY_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_VERFBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READ_REPLY_VERFBYTES;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READ_REPLY_VERFBYTES;
 
-                buf = rpc_reply_accept_status_addr (frag->fragcurrent);
+            buf = rpc_reply_accept_status_addr(frag->fragcurrent);
 
-                frag->call_body.reply.accept_status
-                        = ntoh32 (*(uint32_t *) buf);
+            frag->call_body.reply.accept_status = ntoh32(*(uint32_t *)buf);
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_VERFBYTES:
 
-                if (frag->call_body.reply.accept_status
-                    == SUCCESS) {
-                        ret = __socket_read_accepted_successful_reply (this);
+            if (frag->call_body.reply.accept_status == SUCCESS) {
+                /* Need two different methods here for different protocols
+                   Mainly because the exact XDR is used to calculate the
+                   size of response */
+                if ((in->request_info->procnum == GFS3_OP_READ) &&
+                    (in->request_info->prognum == GLUSTER_FOP_PROGRAM) &&
+                    (in->request_info->progver == GLUSTER_FOP_VERSION_v2)) {
+                    ret = __socket_read_accepted_successful_reply_v2(this);
                 } else {
-                        /* read entire remaining msg into buffer pointed to by
-                         * fragcurrent
-                         */
-                        ret = __socket_read_simple_msg (this);
+                    ret = __socket_read_accepted_successful_reply(this);
                 }
+            } else {
+                /* read entire remaining msg into buffer pointed to by
+                 * fragcurrent
+                 */
+                ret = __socket_read_simple_msg(this);
+            }
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr)
-                        - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        frag->call_body.reply.accepted_state
-                                = SP_STATE_ACCEPTED_REPLY_INIT;
-                }
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              (RPC_LASTFRAG(in->fraghdr)))) {
+                frag->call_body.reply
+                    .accepted_state = SP_STATE_ACCEPTED_REPLY_INIT;
+            }
 
-                break;
-        }
+            break;
+    }
 
-out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_denied_reply (rpc_transport_t *this)
+__socket_read_denied_reply(rpc_transport_t *this)
 {
-        return __socket_read_simple_msg (this);
+    return __socket_read_simple_msg(this);
 }
 
-
 #define rpc_reply_status_addr(fragcurrent) ((char *)fragcurrent - 4)
 
-
 static int
-__socket_read_vectored_reply (rpc_transport_t *this)
+__socket_read_vectored_reply(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int               ret            = 0;
-        char             *buf            = NULL;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.status_state) {
-
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    char *buf = NULL;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    priv = this->private;
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.status_state) {
         case SP_STATE_ACCEPTED_REPLY_INIT:
-                __socket_proto_init_pending (priv, RPC_REPLY_STATUS_SIZE);
+            __socket_proto_init_pending(priv, RPC_REPLY_STATUS_SIZE);
 
-                frag->call_body.reply.status_state
-                        = SP_STATE_READING_REPLY_STATUS;
+            frag->call_body.reply.status_state = SP_STATE_READING_REPLY_STATUS;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_STATUS:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                buf = rpc_reply_status_addr (frag->fragcurrent);
+            buf = rpc_reply_status_addr(frag->fragcurrent);
 
-                frag->call_body.reply.accept_status
-                        = ntoh32 (*((uint32_t *) buf));
+            frag->call_body.reply.accept_status = ntoh32(*((uint32_t *)buf));
 
-                frag->call_body.reply.status_state
-                        = SP_STATE_READ_REPLY_STATUS;
+            frag->call_body.reply.status_state = SP_STATE_READ_REPLY_STATUS;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_STATUS:
-                if (frag->call_body.reply.accept_status == MSG_ACCEPTED) {
-                        ret = __socket_read_accepted_reply (this);
-                } else {
-                        ret = __socket_read_denied_reply (this);
-                }
-
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
-
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        frag->call_body.reply.status_state
-                                = SP_STATE_VECTORED_REPLY_STATUS_INIT;
-                        in->payload_vector.iov_len
-                                = (unsigned long)frag->fragcurrent
-                                - (unsigned long)in->payload_vector.iov_base;
-                }
-                break;
-        }
-
-out:
-        return ret;
+            if (frag->call_body.reply.accept_status == MSG_ACCEPTED) {
+                ret = __socket_read_accepted_reply(this);
+            } else {
+                ret = __socket_read_denied_reply(this);
+            }
+
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              (RPC_LASTFRAG(in->fraghdr)))) {
+                frag->call_body.reply
+                    .status_state = SP_STATE_VECTORED_REPLY_STATUS_INIT;
+                in->payload_vector.iov_len = (unsigned long)frag->fragcurrent -
+                                             (unsigned long)
+                                                 in->payload_vector.iov_base;
+            }
+            break;
+    }
+
+    return ret;
 }
 
-
 static int
-__socket_read_simple_reply (rpc_transport_t *this)
+__socket_read_simple_reply(rpc_transport_t *this)
 {
-        return __socket_read_simple_msg (this);
+    return __socket_read_simple_msg(this);
 }
 
 #define rpc_xid_addr(buf) (buf)
 
 static int
-__socket_read_reply (rpc_transport_t *this)
+__socket_read_reply(rpc_transport_t *this)
 {
-        socket_private_t   *priv         = NULL;
-        char               *buf          = NULL;
-        int32_t             ret          = -1;
-        rpc_request_info_t *request_info = NULL;
-        char                map_xid      = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        buf = rpc_xid_addr (iobuf_ptr (in->iobuf));
-
+    socket_private_t *priv = NULL;
+    char *buf = NULL;
+    int32_t ret = -1;
+    rpc_request_info_t *request_info = NULL;
+    char map_xid = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    priv = this->private;
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    buf = rpc_xid_addr(iobuf_ptr(in->iobuf));
+
+    if (in->request_info == NULL) {
+        in->request_info = GF_CALLOC(1, sizeof(*request_info),
+                                     gf_common_mt_rpc_trans_reqinfo_t);
         if (in->request_info == NULL) {
-                in->request_info = GF_CALLOC (1, sizeof (*request_info),
-                                              gf_common_mt_rpc_trans_reqinfo_t);
-                if (in->request_info == NULL) {
-                        goto out;
-                }
-
-                map_xid = 1;
+            goto out;
         }
 
-        request_info = in->request_info;
+        map_xid = 1;
+    }
 
-        if (map_xid) {
-                request_info->xid = ntoh32 (*((uint32_t *) buf));
+    request_info = in->request_info;
 
-                /* release priv->lock, so as to avoid deadlock b/w conn->lock
-                 * and priv->lock, since we are doing an upcall here.
-                 */
-                frag->state = SP_STATE_NOTIFYING_XID;
-                pthread_mutex_unlock (&priv->lock);
-                {
-                        ret = rpc_transport_notify (this,
-                                                    RPC_TRANSPORT_MAP_XID_REQUEST,
-                                                    in->request_info);
-                }
-                pthread_mutex_lock (&priv->lock);
+    if (map_xid) {
+        request_info->xid = ntoh32(*((uint32_t *)buf));
 
-                /* Transition back to externally visible state. */
-                frag->state = SP_STATE_READ_MSGTYPE;
-
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "notify for event MAP_XID failed for %s",
-                                this->peerinfo.identifier);
-                        goto out;
-                }
+        /* release priv->lock, so as to avoid deadlock b/w conn->lock
+         * and priv->lock, since we are doing an upcall here.
+         */
+        frag->state = SP_STATE_NOTIFYING_XID;
+        ret = rpc_transport_notify(this, RPC_TRANSPORT_MAP_XID_REQUEST,
+                                   in->request_info);
+
+        /* Transition back to externally visible state. */
+        frag->state = SP_STATE_READ_MSGTYPE;
+
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "notify for event MAP_XID failed for %s",
+                   this->peerinfo.identifier);
+            goto out;
         }
+    }
 
-        if ((request_info->prognum == GLUSTER_FOP_PROGRAM)
-            && (request_info->procnum == GF_FOP_READ)) {
-                if (map_xid && request_info->rsp.rsp_payload_count != 0) {
-                        in->iobref = iobref_ref (request_info->rsp.rsp_iobref);
-                        in->payload_vector = *request_info->rsp.rsp_payload;
-                }
-
-                ret = __socket_read_vectored_reply (this);
-        } else {
-                ret = __socket_read_simple_reply (this);
+    if ((request_info->prognum == GLUSTER_FOP_PROGRAM) &&
+        (request_info->procnum == GF_FOP_READ)) {
+        if (map_xid && request_info->rsp.rsp_payload_count != 0) {
+            in->iobref = iobref_ref(request_info->rsp.rsp_iobref);
+            in->payload_vector = *request_info->rsp.rsp_payload;
         }
+
+        ret = __socket_read_vectored_reply(this);
+    } else {
+        ret = __socket_read_simple_reply(this);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 /* returns the number of bytes yet to be read in a fragment */
 static int
-__socket_read_frag (rpc_transport_t *this)
+__socket_read_frag(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int32_t           ret            = 0;
-        char             *buf            = NULL;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->state) {
+    socket_private_t *priv = NULL;
+    int32_t ret = 0;
+    char *buf = NULL;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->state) {
         case SP_STATE_NADA:
-                __socket_proto_init_pending (priv, RPC_MSGTYPE_SIZE);
+            __socket_proto_init_pending(priv, RPC_MSGTYPE_SIZE);
 
-                frag->state = SP_STATE_READING_MSGTYPE;
+            frag->state = SP_STATE_READING_MSGTYPE;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_MSGTYPE:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->state = SP_STATE_READ_MSGTYPE;
-                /* fall through */
+            frag->state = SP_STATE_READ_MSGTYPE;
+            /* fall through */
 
         case SP_STATE_READ_MSGTYPE:
-                buf = rpc_msgtype_addr (iobuf_ptr (in->iobuf));
-                in->msg_type = ntoh32 (*((uint32_t *)buf));
-
-                if (in->msg_type == CALL) {
-                        ret = __socket_read_request (this);
-                } else if (in->msg_type == REPLY) {
-                        ret = __socket_read_reply (this);
-                } else if (in->msg_type == (msg_type_t) GF_UNIVERSAL_ANSWER) {
-                        gf_log ("rpc", GF_LOG_ERROR,
-                                "older version of protocol/process trying to "
-                                "connect from %s. use newer version on that node",
-                                this->peerinfo.identifier);
-                } else {
-                        gf_log ("rpc", GF_LOG_ERROR,
-                                "wrong MSG-TYPE (%d) received from %s",
-                                in->msg_type,
-                                this->peerinfo.identifier);
-                        ret = -1;
-                }
+            buf = rpc_msgtype_addr(iobuf_ptr(in->iobuf));
+            in->msg_type = ntoh32(*((uint32_t *)buf));
+
+            if (in->msg_type == CALL) {
+                ret = __socket_read_request(this);
+            } else if (in->msg_type == REPLY) {
+                ret = __socket_read_reply(this);
+            } else if (in->msg_type == (msg_type_t)GF_UNIVERSAL_ANSWER) {
+                gf_log("rpc", GF_LOG_ERROR,
+                       "older version of protocol/process trying to "
+                       "connect from %s. use newer version on that node",
+                       this->peerinfo.identifier);
+            } else {
+                gf_log("rpc", GF_LOG_ERROR,
+                       "wrong MSG-TYPE (%d) received from %s", in->msg_type,
+                       this->peerinfo.identifier);
+                ret = -1;
+            }
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                     /* frag->state = SP_STATE_NADA; */
-                        frag->state = SP_STATE_RPCFRAG_INIT;
-                }
+            if ((ret < 0) || ((ret == 0) && (remaining_size == 0) &&
+                              (RPC_LASTFRAG(in->fraghdr)))) {
+                /* frag->state = SP_STATE_NADA; */
+                frag->state = SP_STATE_RPCFRAG_INIT;
+            }
 
-                break;
+            break;
 
         case SP_STATE_NOTIFYING_XID:
-                /* Another epoll thread is notifying higher layers
-                 *of reply's xid. */
-                errno = EAGAIN;
-                return -1;
-                break;
-
-        }
-
-out:
-        return ret;
+            /* Another epoll thread is notifying higher layers
+             *of reply's xid. */
+            errno = EAGAIN;
+            return -1;
+            break;
+    }
+
+    return ret;
 }
 
-
 static void
-__socket_reset_priv (socket_private_t *priv)
+__socket_reset_priv(socket_private_t *priv)
 {
-        struct gf_sock_incoming   *in    = NULL;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
+    struct gf_sock_incoming *in = NULL;
 
-        if (in->iobref) {
-                iobref_unref (in->iobref);
-                in->iobref = NULL;
-        }
+    /* used to reduce the indirection */
+    in = &priv->incoming;
 
-        if (in->iobuf) {
-                iobuf_unref (in->iobuf);
-                in->iobuf = NULL;
-        }
+    if (in->iobref) {
+        iobref_unref(in->iobref);
+        in->iobref = NULL;
+    }
 
-        if (in->request_info != NULL) {
-                GF_FREE (in->request_info);
-                in->request_info = NULL;
-        }
+    if (in->iobuf) {
+        iobuf_unref(in->iobuf);
+        in->iobuf = NULL;
+    }
 
-        memset (&in->payload_vector, 0,
-                sizeof (in->payload_vector));
+    if (in->request_info != NULL) {
+        GF_FREE(in->request_info);
+        in->request_info = NULL;
+    }
 
+    memset(&in->payload_vector, 0, sizeof(in->payload_vector));
 }
 
-
 static int
-__socket_proto_state_machine (rpc_transport_t *this,
-                              rpc_transport_pollin_t **pollin)
+__socket_proto_state_machine(rpc_transport_t *this,
+                             rpc_transport_pollin_t **pollin)
 {
-        int               ret    = -1;
-        socket_private_t *priv   = NULL;
-        struct iobuf     *iobuf  = NULL;
-        struct iobref    *iobref = NULL;
-        struct iovec      vector[2];
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        while (in->record_state != SP_STATE_COMPLETE) {
-                switch (in->record_state) {
-
-                case SP_STATE_NADA:
-                        in->total_bytes_read = 0;
-                        in->payload_vector.iov_len = 0;
-
-                        in->pending_vector = in->vector;
-                        in->pending_vector->iov_base =  &in->fraghdr;
-
-                        in->pending_vector->iov_len  = sizeof (in->fraghdr);
-
-                        in->record_state = SP_STATE_READING_FRAGHDR;
-
-                        /* fall through */
-
-                case SP_STATE_READING_FRAGHDR:
-                        ret = __socket_readv (this, in->pending_vector, 1,
-                                              &in->pending_vector,
-                                              &in->pending_count,
-                                              NULL);
-                        if (ret == -1)
-                                goto out;
-
-                        if (ret > 0) {
-                                gf_log (this->name, GF_LOG_TRACE, "partial "
-                                        "fragment header read");
-                                goto out;
-                        }
+    int ret = -1;
+    socket_private_t *priv = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec vector[2];
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
 
-                        if (ret == 0) {
-                                in->record_state = SP_STATE_READ_FRAGHDR;
-                        }
-                        /* fall through */
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-                case SP_STATE_READ_FRAGHDR:
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
 
-                        in->fraghdr = ntoh32 (in->fraghdr);
-                        in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr);
+    while (in->record_state != SP_STATE_COMPLETE) {
+        switch (in->record_state) {
+            case SP_STATE_NADA:
+                in->total_bytes_read = 0;
+                in->payload_vector.iov_len = 0;
 
-                        if (in->total_bytes_read >= GF_UNIT_GB) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
+                in->pending_vector = in->vector;
+                in->pending_vector->iov_base = &in->fraghdr;
 
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool,
-                                            (in->total_bytes_read +
-                                             sizeof (in->fraghdr)));
-                        if (!iobuf) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
+                in->pending_vector->iov_len = sizeof(in->fraghdr);
 
-                        if (in->iobuf == NULL) {
-                            /* first fragment */
-                            frag->fragcurrent = iobuf_ptr (iobuf);
-                        } else {
-                            /* second or further fragment */
-                            memcpy(iobuf_ptr (iobuf), iobuf_ptr (in->iobuf),
-                               in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr));
-                            iobuf_unref (in->iobuf);
-                            frag->fragcurrent = (char *) iobuf_ptr (iobuf) +
-                                in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr);
-                            frag->pending_vector->iov_base = frag->fragcurrent;
-                            in->pending_vector = frag->pending_vector;
-                        }
+                in->record_state = SP_STATE_READING_FRAGHDR;
 
-                        in->iobuf = iobuf;
-                        in->iobuf_size = 0;
-                        in->record_state = SP_STATE_READING_FRAG;
-                        /* fall through */
+                /* fall through */
 
-                case SP_STATE_READING_FRAG:
-                        ret = __socket_read_frag (this);
+            case SP_STATE_READING_FRAGHDR:
+                ret = __socket_readv(this, in->pending_vector, 1,
+                                     &in->pending_vector, &in->pending_count,
+                                     NULL);
+                if (ret < 0)
+                    goto out;
 
-                        if ((ret == -1) ||
-                            (frag->bytes_read != RPC_FRAGSIZE (in->fraghdr))) {
-                                goto out;
-                        }
+                if (ret > 0) {
+                    gf_log(this->name, GF_LOG_TRACE,
+                           "partial "
+                           "fragment header read");
+                    ret = 0;
+                    goto out;
+                }
 
-                        frag->bytes_read = 0;
+                if (ret == 0) {
+                    in->record_state = SP_STATE_READ_FRAGHDR;
+                }
+                /* fall through */
 
-                        if (!RPC_LASTFRAG (in->fraghdr)) {
-                                in->pending_vector = in->vector;
-                                in->pending_vector->iov_base = &in->fraghdr;
-                                in->pending_vector->iov_len = sizeof(in->fraghdr);
-                                in->record_state = SP_STATE_READING_FRAGHDR;
-                                break;
-                        }
+            case SP_STATE_READ_FRAGHDR:
 
-                        /* we've read the entire rpc record, notify the
-                         * upper layers.
-                         */
-                        if (pollin != NULL) {
-                                int count = 0;
-                                in->iobuf_size = (in->total_bytes_read -
-                                                  in->payload_vector.iov_len);
-
-                                memset (vector, 0, sizeof (vector));
-
-                                if (in->iobref == NULL) {
-                                        in->iobref = iobref_new ();
-                                        if (in->iobref == NULL) {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-
-                                vector[count].iov_base = iobuf_ptr (in->iobuf);
-                                vector[count].iov_len = in->iobuf_size;
-
-                                iobref = in->iobref;
-
-                                count++;
-
-                                if (in->payload_vector.iov_base != NULL) {
-                                        vector[count] = in->payload_vector;
-                                        count++;
-                                }
-
-                                *pollin = rpc_transport_pollin_alloc (this,
-                                                                      vector,
-                                                                      count,
-                                                                      in->iobuf,
-                                                                      iobref,
-                                                                      in->request_info);
-                                iobuf_unref (in->iobuf);
-                                in->iobuf = NULL;
-
-                                if (*pollin == NULL) {
-                                        gf_log (this->name, GF_LOG_WARNING,
-                                                "transport pollin allocation failed");
-                                        ret = -1;
-                                        goto out;
-                                }
-                                if (in->msg_type == REPLY)
-                                        (*pollin)->is_reply = 1;
-
-                                in->request_info = NULL;
-                        }
-                        in->record_state = SP_STATE_COMPLETE;
-                        break;
+                in->fraghdr = ntoh32(in->fraghdr);
+                in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr);
 
-                case SP_STATE_COMPLETE:
-                        /* control should not reach here */
-                        gf_log (this->name, GF_LOG_WARNING, "control reached to "
-                                "SP_STATE_COMPLETE, which should not have "
-                                "happened");
-                        break;
+                if (in->total_bytes_read >= GF_UNIT_GB) {
+                    ret = -1;
+                    goto out;
                 }
-        }
 
-        if (in->record_state == SP_STATE_COMPLETE) {
-                in->record_state = SP_STATE_NADA;
-                __socket_reset_priv (priv);
-        }
+                iobuf = iobuf_get2(
+                    this->ctx->iobuf_pool,
+                    (in->total_bytes_read + sizeof(in->fraghdr)));
+                if (!iobuf) {
+                    ret = -1;
+                    goto out;
+                }
 
-out:
-        if ((ret == -1) && (errno == EAGAIN)) {
-                ret = 0;
-        }
+                if (in->iobuf == NULL) {
+                    /* first fragment */
+                    frag->fragcurrent = iobuf_ptr(iobuf);
+                } else {
+                    /* second or further fragment */
+                    memcpy(iobuf_ptr(iobuf), iobuf_ptr(in->iobuf),
+                           in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr));
+                    iobuf_unref(in->iobuf);
+                    frag->fragcurrent = (char *)iobuf_ptr(iobuf) +
+                                        in->total_bytes_read -
+                                        RPC_FRAGSIZE(in->fraghdr);
+                    frag->pending_vector->iov_base = frag->fragcurrent;
+                    in->pending_vector = frag->pending_vector;
+                }
 
-        return ret;
-}
+                in->iobuf = iobuf;
+                in->iobuf_size = 0;
+                in->record_state = SP_STATE_READING_FRAG;
+                /* fall through */
 
+            case SP_STATE_READING_FRAG:
+                ret = __socket_read_frag(this);
 
-static int
-socket_proto_state_machine (rpc_transport_t *this,
-                            rpc_transport_pollin_t **pollin)
-{
-        socket_private_t *priv = NULL;
-        int               ret = 0;
+                if ((ret < 0) ||
+                    (frag->bytes_read != RPC_FRAGSIZE(in->fraghdr))) {
+                    goto out;
+                }
+
+                frag->bytes_read = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+                if (!RPC_LASTFRAG(in->fraghdr)) {
+                    in->pending_vector = in->vector;
+                    in->pending_vector->iov_base = &in->fraghdr;
+                    in->pending_vector->iov_len = sizeof(in->fraghdr);
+                    in->record_state = SP_STATE_READING_FRAGHDR;
+                    break;
+                }
 
-        priv = this->private;
+                /* we've read the entire rpc record, notify the
+                 * upper layers.
+                 */
+                if (pollin != NULL) {
+                    int count = 0;
+                    in->iobuf_size = (in->total_bytes_read -
+                                      in->payload_vector.iov_len);
 
-        pthread_mutex_lock (&priv->lock);
-        {
-                ret = __socket_proto_state_machine (this, pollin);
-        }
-        pthread_mutex_unlock (&priv->lock);
+                    memset(vector, 0, sizeof(vector));
 
-out:
-        return ret;
-}
+                    if (in->iobref == NULL) {
+                        in->iobref = iobref_new();
+                        if (in->iobref == NULL) {
+                            ret = -1;
+                            goto out;
+                        }
+                    }
 
+                    vector[count].iov_base = iobuf_ptr(in->iobuf);
+                    vector[count].iov_len = in->iobuf_size;
 
-static int
-socket_event_poll_in (rpc_transport_t *this, gf_boolean_t notify_handled)
-{
-        int                     ret    = -1;
-        rpc_transport_pollin_t *pollin = NULL;
-        socket_private_t       *priv = this->private;
-        glusterfs_ctx_t        *ctx  = NULL;
+                    iobref = in->iobref;
+
+                    count++;
 
-        ctx = this->ctx;
+                    if (in->payload_vector.iov_base != NULL) {
+                        vector[count] = in->payload_vector;
+                        count++;
+                    }
 
-	ret = socket_proto_state_machine (this, &pollin);
+                    *pollin = rpc_transport_pollin_alloc(this, vector, count,
+                                                         in->iobuf, iobref,
+                                                         in->request_info);
+                    iobuf_unref(in->iobuf);
+                    in->iobuf = NULL;
 
-        if (pollin) {
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        priv->notify.in_progress++;
+                    if (*pollin == NULL) {
+                        gf_log(this->name, GF_LOG_WARNING,
+                               "transport pollin allocation failed");
+                        ret = -1;
+                        goto out;
+                    }
+                    if (in->msg_type == REPLY)
+                        (*pollin)->is_reply = 1;
+
+                    in->request_info = NULL;
                 }
-                pthread_mutex_unlock (&priv->notify.lock);
+                in->record_state = SP_STATE_COMPLETE;
+                break;
+
+            case SP_STATE_COMPLETE:
+                /* control should not reach here */
+                gf_log(this->name, GF_LOG_WARNING,
+                       "control reached to "
+                       "SP_STATE_COMPLETE, which should not have "
+                       "happened");
+                break;
         }
+    }
 
+    if (in->record_state == SP_STATE_COMPLETE) {
+        in->record_state = SP_STATE_NADA;
+        __socket_reset_priv(priv);
+    }
+
+out:
+    return ret;
+}
 
-        if (notify_handled && (ret != -1))
-                event_handled (ctx->event_pool, priv->sock, priv->idx,
-                               priv->gen);
+static int
+socket_proto_state_machine(rpc_transport_t *this,
+                           rpc_transport_pollin_t **pollin)
+{
+    return __socket_proto_state_machine(this, pollin);
+}
 
-	if (pollin) {
-                priv->ot_state = OT_CALLBACK;
+static void
+socket_event_poll_in_async(xlator_t *xl, gf_async_t *async)
+{
+    rpc_transport_pollin_t *pollin;
+    rpc_transport_t *this;
+    socket_private_t *priv;
 
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_RECEIVED,
-                                            pollin);
+    pollin = caa_container_of(async, rpc_transport_pollin_t, async);
+    this = pollin->trans;
+    priv = this->private;
 
-                if (priv->ot_state == OT_CALLBACK) {
-                        priv->ot_state = OT_RUNNING;
-                }
+    rpc_transport_notify(this, RPC_TRANSPORT_MSG_RECEIVED, pollin);
 
-                rpc_transport_pollin_destroy (pollin);
+    rpc_transport_unref(this);
 
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        --priv->notify.in_progress;
+    rpc_transport_pollin_destroy(pollin);
 
-                        if (!priv->notify.in_progress)
-                                pthread_cond_signal (&priv->notify.cond);
-                }
-                pthread_mutex_unlock (&priv->notify.lock);
-        }
+    pthread_mutex_lock(&priv->notify.lock);
+    {
+        --priv->notify.in_progress;
 
-        return ret;
+        if (!priv->notify.in_progress)
+            pthread_cond_signal(&priv->notify.cond);
+    }
+    pthread_mutex_unlock(&priv->notify.lock);
 }
 
-
 static int
-socket_connect_finish (rpc_transport_t *this)
+socket_event_poll_in(rpc_transport_t *this, gf_boolean_t notify_handled)
 {
-        int                   ret        = -1;
-        socket_private_t     *priv       = NULL;
-        rpc_transport_event_t event      = 0;
-        char                  notify_rpc = 0;
+    int ret = -1;
+    rpc_transport_pollin_t *pollin = NULL;
+    socket_private_t *priv = this->private;
+    glusterfs_ctx_t *ctx = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    ctx = this->ctx;
 
-        priv = this->private;
+    ret = socket_proto_state_machine(this, &pollin);
 
-        pthread_mutex_lock (&priv->lock);
+    if (pollin) {
+        pthread_mutex_lock(&priv->notify.lock);
         {
-                if (priv->connected != 0)
-                        goto unlock;
-
-                get_transport_identifiers (this);
+            priv->notify.in_progress++;
+        }
+        pthread_mutex_unlock(&priv->notify.lock);
+    }
 
-                ret = __socket_connect_finish (priv->sock);
+    if (notify_handled && (ret >= 0))
+        gf_event_handled(ctx->event_pool, priv->sock, priv->idx, priv->gen);
 
-                if (ret == -1 && errno == EINPROGRESS)
-                        ret = 1;
+    if (pollin) {
+        rpc_transport_ref(this);
+        gf_async(&pollin->async, THIS, socket_event_poll_in_async);
+    }
 
-                if (ret == -1 && errno != EINPROGRESS) {
-                        if (!priv->connect_finish_log) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "connection to %s failed (%s); "
-                                        "disconnecting socket",
-                                        this->peerinfo.identifier,
-                                        strerror (errno));
-                                priv->connect_finish_log = 1;
-                        }
-                        __socket_disconnect (this);
-                        goto unlock;
-                }
+    return ret;
+}
 
-                if (ret == 0) {
-                        notify_rpc = 1;
-
-                        this->myinfo.sockaddr_len =
-                                sizeof (this->myinfo.sockaddr);
-
-                        ret = getsockname (priv->sock,
-                                           SA (&this->myinfo.sockaddr),
-                                           &this->myinfo.sockaddr_len);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "getsockname on (%d) failed (%s) - "
-                                        "disconnecting socket",
-                                        priv->sock, strerror (errno));
-                                __socket_disconnect (this);
-                                event = RPC_TRANSPORT_DISCONNECT;
-                                goto unlock;
-                        }
+static int
+socket_connect_finish(rpc_transport_t *this)
+{
+    int ret = -1;
+    socket_private_t *priv = NULL;
+    rpc_transport_event_t event = 0;
+    char notify_rpc = 0;
+
+    priv = this->private;
+
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected != 0)
+            goto unlock;
+
+        get_transport_identifiers(this);
+
+        ret = __socket_connect_finish(priv->sock);
+
+        if ((ret < 0) && (errno == EINPROGRESS))
+            ret = 1;
+
+        if ((ret < 0) && (errno != EINPROGRESS)) {
+            if (!priv->connect_finish_log) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "connection to %s failed (%s); "
+                       "disconnecting socket",
+                       this->peerinfo.identifier, strerror(errno));
+                priv->connect_finish_log = 1;
+            }
+            __socket_disconnect(this);
+            goto unlock;
+        }
 
-                        priv->connected = 1;
-                        priv->connect_finish_log = 0;
-                        event = RPC_TRANSPORT_CONNECT;
-                }
+        if (ret == 0) {
+            notify_rpc = 1;
+
+            this->myinfo.sockaddr_len = sizeof(this->myinfo.sockaddr);
+
+            ret = getsockname(priv->sock, SA(&this->myinfo.sockaddr),
+                              &this->myinfo.sockaddr_len);
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "getsockname on (%d) failed (%s) - "
+                       "disconnecting socket",
+                       priv->sock, strerror(errno));
+                __socket_disconnect(this);
+                event = RPC_TRANSPORT_DISCONNECT;
+                goto unlock;
+            }
+
+            priv->connected = 1;
+            priv->connect_finish_log = 0;
+            event = RPC_TRANSPORT_CONNECT;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->lock);
+    pthread_mutex_unlock(&priv->out_lock);
 
-        if (notify_rpc) {
-                rpc_transport_notify (this, event, this);
-        }
-out:
-        return ret;
-}
+    if (notify_rpc) {
+        rpc_transport_notify(this, event, this);
+    }
 
-static int socket_disconnect (rpc_transport_t *this, gf_boolean_t wait);
+    return ret;
+}
 
-/* reads rpc_requests during pollin */
 static int
-socket_event_handler (int fd, int idx, int gen, void *data,
-                      int poll_in, int poll_out, int poll_err)
-{
-        rpc_transport_t  *this          = NULL;
-        socket_private_t *priv          = NULL;
-	int               ret           = -1;
-        glusterfs_ctx_t  *ctx           = NULL;
-        gf_boolean_t      socket_closed = _gf_false, notify_handled = _gf_false;
-
-        this = data;
+socket_disconnect(rpc_transport_t *this, gf_boolean_t wait);
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->xl, out);
-
-        THIS = this->xl;
-        priv = this->private;
-        ctx = this->ctx;
+/* socket_is_connected() is for use only in socket_event_handler() */
+static inline gf_boolean_t
+socket_is_connected(socket_private_t *priv)
+{
+    if (priv->use_ssl) {
+        return priv->is_server ? priv->ssl_accepted : priv->ssl_connected;
+    } else {
+        return priv->is_server ? priv->accepted : priv->connected;
+    }
+}
 
-        pthread_mutex_lock (&priv->lock);
-        {
-                priv->idx = idx;
-                priv->gen = gen;
-        }
-        pthread_mutex_unlock (&priv->lock);
+static void
+ssl_rearm_event_fd(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    if (priv->ssl_error_required == SSL_ERROR_WANT_READ)
+        gf_event_select_on(ctx->event_pool, fd, idx, 1, -1);
+    if (priv->ssl_error_required == SSL_ERROR_WANT_WRITE)
+        gf_event_select_on(ctx->event_pool, fd, idx, -1, 1);
+    gf_event_handled(ctx->event_pool, fd, idx, gen);
+}
 
-        if (priv->connected != 1) {
-                if (priv->connect_failed) {
-                        /* connect failed with some other error than
-                        EINPROGRESS or ENOENT, so nothing more to do, fail
-                        reading/writing anything even if poll_in or poll_out
-                        is set */
-                        gf_log ("transport", GF_LOG_DEBUG,
-                                "connect failed with some other error than "
-                                "EINPROGRESS or ENOENT, so nothing more to "
-                                "do; disconnecting socket");
-                        ret = socket_disconnect (this, _gf_false);
-
-                        /* Force ret to be -1, as we are officially done with
-                        this socket */
-                        ret = -1;
-                } else {
-                        ret = socket_connect_finish (this);
-                }
+static int
+ssl_handle_server_connection_attempt(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    if (!priv->ssl_context_created) {
+        ret = ssl_setup_connection_prefix(this, _gf_true);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_TRACE,
+                   "> ssl_setup_connection_prefix() failed!");
+            ret = -1;
+            goto out;
         } else {
-                ret = 0;
+            priv->ssl_context_created = _gf_true;
         }
-
-        if (!ret && poll_out) {
-                ret = socket_event_poll_out (this);
+    }
+    ret = ssl_complete_connection(this);
+    if (ret == 0) {
+        /* nothing to do */
+        gf_event_select_on(ctx->event_pool, fd, idx, 1, 0);
+        gf_event_handled(ctx->event_pool, fd, idx, gen);
+        ret = 1;
+    } else {
+        if (errno == EAGAIN) {
+            ssl_rearm_event_fd(this);
+            ret = 1;
+        } else {
+            ret = -1;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "ssl_complete_connection returned error");
         }
+    }
+out:
+    return ret;
+}
 
-        if (!ret && poll_in) {
-                ret = socket_event_poll_in (this, !poll_err);
-                notify_handled = _gf_true;
+static int
+ssl_handle_client_connection_attempt(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    fd = priv->sock;
+
+    /* SSL client */
+    if (priv->connect_failed) {
+        gf_log(this->name, GF_LOG_TRACE, ">>> disconnecting SSL socket");
+        (void)socket_disconnect(this, _gf_false);
+        /* Force ret to be -1, as we are officially done with
+           this socket */
+        ret = -1;
+    } else {
+        if (!priv->ssl_context_created) {
+            ret = ssl_setup_connection_prefix(this, _gf_false);
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "> ssl_setup_connection_prefix() "
+                       "failed!");
+                ret = -1;
+                goto out;
+            } else {
+                priv->ssl_context_created = _gf_true;
+            }
         }
-
-        if ((ret < 0) || poll_err) {
-                /* Logging has happened already in earlier cases */
-                gf_log ("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG),
-                        "EPOLLERR - disconnecting now");
-
-                socket_closed = socket_event_poll_err (this, gen, idx);
-
-                if (socket_closed)
-                        rpc_transport_unref (this);
-
-	} else if (!notify_handled) {
-                event_handled (ctx->event_pool, fd, idx, gen);
+        ret = ssl_complete_connection(this);
+        if (ret == 0) {
+            ret = socket_connect_finish(this);
+            gf_event_select_on(ctx->event_pool, fd, idx, 1, 0);
+            gf_log(this->name, GF_LOG_TRACE, ">>> completed client connect");
+        } else {
+            if (errno == EAGAIN) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       ">>> retrying client connect 2");
+                ssl_rearm_event_fd(this);
+                ret = 1;
+            } else {
+                /* this is a connection failure */
+                (void)socket_connect_finish(this);
+                gf_log(this->name, GF_LOG_TRACE,
+                       "ssl_complete_connection "
+                       "returned error");
+                ret = -1;
+            }
         }
-
+    }
 out:
-	return ret;
+    return ret;
 }
 
-static int poll_err_cnt;
-static void *
-socket_poller (void *ctx)
+static int
+socket_handle_client_connection_attempt(rpc_transport_t *this)
 {
-        rpc_transport_t  *this = ctx;
-        socket_private_t *priv = this->private;
-	struct pollfd     pfd[2] = {{0,},};
-	gf_boolean_t      to_write = _gf_false;
-	int               ret = 0;
-        uint32_t          gen = 0;
-        char             *cname = NULL;
-
-        GF_ASSERT (this);
-        /* Set THIS early on in the life of this thread, instead of setting it
-         * conditionally
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    /* non-SSL client */
+    if (priv->connect_failed) {
+        /* connect failed with some other error than
+           EINPROGRESS or ENOENT, so nothing more to
+           do, fail reading/writing anything even if
+           poll_in or poll_out
+           is set
+           */
+        gf_log("transport", GF_LOG_DEBUG,
+               "connect failed with some other error "
+               "than EINPROGRESS or ENOENT, so "
+               "nothing more to do; disconnecting "
+               "socket");
+        (void)socket_disconnect(this, _gf_false);
+
+        /* Force ret to be -1, as we are officially
+         * done with this socket
          */
-        THIS = this->xl;
+        ret = -1;
+    } else {
+        ret = socket_connect_finish(this);
+        gf_log(this->name, GF_LOG_TRACE, "socket_connect_finish() returned %d",
+               ret);
+        if (ret == 0 || ret == 1) {
+            /* we don't want to do any reads or
+             * writes on the connection yet in
+             * socket_event_handler, so just
+             * return 1
+             */
+            ret = 1;
+            gf_event_handled(ctx->event_pool, fd, idx, gen);
+        }
+    }
+    return ret;
+}
 
-        if (priv->ot_state == OT_PLEASE_DIE) {
-                gf_log (this->name, GF_LOG_DEBUG, "socket_poller is exiting "
-                        "because socket state is OT_PLEASE_DIE");
-                goto err;
+static int
+socket_complete_connection(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    if (priv->use_ssl) {
+        if (priv->is_server) {
+            ret = ssl_handle_server_connection_attempt(this);
+        } else {
+            ret = ssl_handle_client_connection_attempt(this);
+        }
+    } else {
+        if (priv->is_server) {
+            /* non-SSL server: nothing much to do
+             * connection has already been accepted in
+             * socket_server_event_handler()
+             */
+            priv->accepted = _gf_true;
+            gf_event_handled(ctx->event_pool, fd, idx, gen);
+            ret = 1;
+        } else {
+            ret = socket_handle_client_connection_attempt(this);
         }
+    }
+    return ret;
+}
 
-        priv->ot_state = OT_RUNNING;
+/* reads rpc_requests during pollin */
+static void
+socket_event_handler(int fd, int idx, int gen, void *data, int poll_in,
+                     int poll_out, int poll_err, char event_thread_died)
+{
+    rpc_transport_t *this = NULL;
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_boolean_t socket_closed = _gf_false, notify_handled = _gf_false;
 
-        if (priv->use_ssl) {
-                cname = ssl_setup_connection(this,priv->connected);
-                if (!cname) {
-                        gf_log (this->name,GF_LOG_ERROR, "%s setup failed",
-                                priv->connected ? "server" : "client");
-                        goto err;
-                }
-                if (priv->connected) {
-                        this->ssl_name = cname;
-                }
-                else {
-                        GF_FREE(cname);
-                }
-        }
+    this = data;
 
-        if (!priv->bio) {
-                ret = __socket_nonblock (priv->sock);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "NBIO on %d failed (%s)",
-                                priv->sock, strerror (errno));
-                        goto err;
-                }
-        }
+    if (event_thread_died) {
+        /* to avoid duplicate notifications, notify only for listener sockets */
+        return;
+    }
 
-        if (priv->connected == 0) {
-                ret = socket_connect_finish (this);
-                if (ret != 0) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "asynchronous socket_connect_finish failed");
-                }
-        }
+    /* At this point we are sure no other thread is using the transport because
+     * we cannot receive more events until we call gf_event_handled(). However
+     * this function may call gf_event_handled() in some cases. When this is
+     * done, the transport may be destroyed at any moment if another thread
+     * handled an error event. To prevent that we take a reference here. */
+    rpc_transport_ref(this);
 
-        ret = rpc_transport_notify (this->listener,
-                                    RPC_TRANSPORT_ACCEPT, this);
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "asynchronous rpc_transport_notify failed");
-        }
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this->xl, out);
 
-        gen = priv->ot_gen;
-	for (;;) {
-		pthread_mutex_lock(&priv->lock);
-		to_write = !list_empty(&priv->ioq);
-		pthread_mutex_unlock(&priv->lock);
-		pfd[0].fd = priv->pipe[0];
-		pfd[0].events = POLL_MASK_ERROR;
-		pfd[0].revents = 0;
-		pfd[1].fd = priv->sock;
-		pfd[1].events = POLL_MASK_INPUT | POLL_MASK_ERROR;
-		pfd[1].revents = 0;
-		if (to_write) {
-			pfd[1].events |= POLL_MASK_OUTPUT;
-		}
-		else {
-			pfd[0].events |= POLL_MASK_INPUT;
-		}
-		if (poll(pfd,2,-1) < 0) {
-			gf_log(this->name,GF_LOG_ERROR,"poll failed");
-			break;
-		}
-		if (pfd[0].revents & POLL_MASK_ERROR) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "poll error on pipe");
-			break;
-		}
-
-                if (priv->ot_state == OT_PLEASE_DIE) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "OT_PLEASE_DIE on %p (exiting socket_poller)",
-                                this);
-                        break;
-                }
+    THIS = this->xl;
+    priv = this->private;
+    ctx = this->ctx;
 
-		if (pfd[1].revents & POLL_MASK_INPUT) {
-			ret = socket_event_poll_in(this, 0);
-			if (ret >= 0) {
-				/* Suppress errors while making progress. */
-				pfd[1].revents &= ~POLL_MASK_ERROR;
-			}
-			else if (errno == ENOTCONN) {
-				ret = 0;
-			}
-                        if (priv->ot_state == OT_PLEASE_DIE) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "OT_IDLE on %p (input request)",
-                                        this);
-                                break;
-                        }
-		}
-		else if (pfd[1].revents & POLL_MASK_OUTPUT) {
-			ret = socket_event_poll_out(this);
-			if (ret >= 0) {
-				/* Suppress errors while making progress. */
-				pfd[1].revents &= ~POLL_MASK_ERROR;
-			}
-			else if (errno == ENOTCONN) {
-				ret = 0;
-			}
-                        if (priv->ot_state == OT_PLEASE_DIE) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "OT_IDLE on %p (output request)",
-                                        this);
-                                break;
-                        }
-		}
-		else {
-			/*
-			 * This usually means that we left poll() because
-			 * somebody pushed a byte onto our pipe.  That wakeup
-			 * is why the pipe is there, but once awake we can do
-			 * all the checking we need on the next iteration.
-			 */
-			ret = 0;
-		}
-		if (pfd[1].revents & POLL_MASK_ERROR) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "poll error on socket");
-			break;
-		}
-		if (ret < 0) {
-                        GF_LOG_OCCASIONALLY (poll_err_cnt, this->name,
-                                             GF_LOG_ERROR,
-                                             "socket_poller %s failed (%s)",
-                                             this->peerinfo.identifier,
-                                             strerror (errno));
-			break;
-		}
-                if (priv->ot_gen != gen) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "generation mismatch, my %u != %u",
-                                gen, priv->ot_gen);
-                        return NULL;
-                }
-	}
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        priv->idx = idx;
+        priv->gen = gen;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+
+    gf_log(this->name, GF_LOG_TRACE, "%s (sock:%d) in:%d, out:%d, err:%d",
+           (priv->is_server ? "server" : "client"), priv->sock, poll_in,
+           poll_out, poll_err);
+
+    if (!poll_err) {
+        if (!socket_is_connected(priv)) {
+            gf_log(this->name, GF_LOG_TRACE,
+                   "%s (sock:%d) socket is not connected, "
+                   "completing connection",
+                   (priv->is_server ? "server" : "client"), priv->sock);
+
+            ret = socket_complete_connection(this);
+
+            gf_log(this->name, GF_LOG_TRACE,
+                   "(sock:%d) "
+                   "socket_complete_connection() returned %d",
+                   priv->sock, ret);
+
+            if (ret > 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "(sock:%d) returning to wait on socket", priv->sock);
+                goto out;
+            }
+        } else {
+            char *sock_type = (priv->is_server ? "Server" : "Client");
 
-err:
-	/* All (and only) I/O errors should come here. */
-        pthread_mutex_lock(&priv->lock);
-        {
-                gf_log (this->name, GF_LOG_TRACE, "disconnecting socket");
-                __socket_teardown_connection (this);
-                sys_close (priv->sock);
-                priv->sock = -1;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "%s socket (%d) is already connected", sock_type,
+                   priv->sock);
+            ret = 0;
+        }
+    }
+
+    if (!ret && poll_out) {
+        ret = socket_event_poll_out(this);
+        gf_log(this->name, GF_LOG_TRACE,
+               "(sock:%d) "
+               "socket_event_poll_out returned %d",
+               priv->sock, ret);
+    }
+
+    if (!ret && poll_in) {
+        ret = socket_event_poll_in(this, !poll_err);
+        gf_log(this->name, GF_LOG_TRACE,
+               "(sock:%d) "
+               "socket_event_poll_in returned %d",
+               priv->sock, ret);
+        notify_handled = _gf_true;
+    }
+
+    if ((ret < 0) || poll_err) {
+        struct sockaddr *sa = SA(&this->peerinfo.sockaddr);
+
+        if (priv->is_server &&
+            SA(&this->myinfo.sockaddr)->sa_family == AF_UNIX) {
+            sa = SA(&this->myinfo.sockaddr);
+        }
 
-                sys_close (priv->pipe[0]);
-                sys_close (priv->pipe[1]);
-                priv->pipe[0] = -1;
-                priv->pipe[1] = -1;
+        socket_dump_info(sa, priv->is_server, priv->use_ssl, priv->sock,
+                         this->name, "disconnecting from");
 
-                priv->ot_state = OT_IDLE;
+        /* Dump the SSL error stack to clear any errors that may otherwise
+         * resurface in the future.
+         */
+        if (priv->use_ssl && priv->ssl_ssl) {
+            ssl_dump_error_stack(this->name);
         }
-        pthread_mutex_unlock(&priv->lock);
 
-        rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this);
+        /* Logging has happened already in earlier cases */
+        gf_log("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG),
+               "EPOLLERR - disconnecting (sock:%d) (%s)", priv->sock,
+               (priv->use_ssl ? "SSL" : "non-SSL"));
 
-        GF_REF_PUT (priv);
+        socket_closed = socket_event_poll_err(this, gen, idx);
 
-        rpc_transport_unref (this);
+        if (socket_closed)
+            rpc_transport_unref(this);
 
-	return NULL;
-}
+    } else if (!notify_handled) {
+        gf_event_handled(ctx->event_pool, fd, idx, gen);
+    }
 
+out:
+    rpc_transport_unref(this);
+}
 
-static int
-socket_spawn (rpc_transport_t *this)
+static void
+socket_server_event_handler(int fd, int idx, int gen, void *data, int poll_in,
+                            int poll_out, int poll_err, char event_thread_died)
 {
-        socket_private_t        *priv   = this->private;
-        int ret = -1;
-        switch (priv->ot_state) {
-        case OT_IDLE:
-        case OT_PLEASE_DIE:
-                break;
-        default:
-                gf_log (this->name, GF_LOG_WARNING,
-                        "refusing to start redundant poller");
-                return ret;
-        }
+    rpc_transport_t *this = NULL;
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    int new_sock = -1;
+    rpc_transport_t *new_trans = NULL;
+    struct sockaddr_storage new_sockaddr = {
+        0,
+    };
+    socklen_t addrlen = sizeof(new_sockaddr);
+    socket_private_t *new_priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = data;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this->xl, out);
+    GF_VALIDATE_OR_GOTO("socket", this->ctx, out);
+
+    THIS = this->xl;
+    priv = this->private;
+    ctx = this->ctx;
+
+    if (event_thread_died) {
+        rpc_transport_notify(this, RPC_TRANSPORT_EVENT_THREAD_DIED,
+                             (void *)(unsigned long)gen);
+        return;
+    }
 
-        priv->ot_gen += 7;
-        priv->ot_state = OT_SPAWNING;
-        gf_log (this->name, GF_LOG_TRACE,
-                "spawning %p with gen %u", this, priv->ot_gen);
+    /* NOTE:
+     * We have done away with the critical section in this function. since
+     * there's little that it helps with. There's no other code that
+     * attempts to unref the listener socket/transport from any other
+     * thread context while we are using it here.
+     */
+    priv->idx = idx;
+    priv->gen = gen;
 
-        GF_REF_GET (priv);
+    if (poll_err) {
+        socket_event_poll_err(this, gen, idx);
+        goto out;
+    }
 
-        /* Create thread after enable detach flag */
+    if (poll_in) {
+        int aflags = 0;
 
-        ret = gf_thread_create_detached (&priv->thread, socket_poller, this,
-                                         "spoller");
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "could not create poll thread");
-                ret = -1;
-        }
+        if (!priv->bio)
+            aflags = O_NONBLOCK;
 
-        return ret;
-}
+        new_sock = sys_accept(priv->sock, SA(&new_sockaddr), &addrlen, aflags);
 
-static int
-socket_server_event_handler (int fd, int idx, int gen, void *data,
-                             int poll_in, int poll_out, int poll_err)
-{
-        rpc_transport_t             *this = NULL;
-        socket_private_t        *priv = NULL;
-        int                      ret = 0;
-        int                      new_sock = -1;
-        rpc_transport_t             *new_trans = NULL;
-        struct sockaddr_storage  new_sockaddr = {0, };
-        socklen_t                addrlen = sizeof (new_sockaddr);
-        socket_private_t        *new_priv = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        char                    *cname = NULL;
-
-        this = data;
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->xl, out);
-
-        THIS = this->xl;
-        priv = this->private;
-        ctx  = this->ctx;
-
-        /* NOTE:
-         * We have done away with the critical section in this function. since
-         * there's little that it helps with. There's no other code that
-         * attempts to unref the listener socket/transport from any other
-         * thread context while we are using it here.
-         */
-        priv->idx = idx;
+        gf_event_handled(ctx->event_pool, fd, idx, gen);
 
-        if (poll_in) {
-                new_sock = accept (priv->sock, SA (&new_sockaddr), &addrlen);
+        if (new_sock < 0) {
+            gf_log(this->name, GF_LOG_WARNING, "accept on %d failed (%s)",
+                   priv->sock, strerror(errno));
+            goto out;
+        }
 
-                if (new_sock == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "accept on %d failed (%s)",
-                                priv->sock, strerror (errno));
-                        goto out;
+        if (new_sockaddr.ss_family != AF_UNIX) {
+            if (priv->nodelay) {
+                ret = __socket_nodelay(new_sock);
+                if (ret != 0) {
+                    gf_log(this->name, GF_LOG_WARNING,
+                           "setsockopt() failed for "
+                           "NODELAY (%s)",
+                           strerror(errno));
                 }
+            }
 
-                if (priv->nodelay && (new_sockaddr.ss_family != AF_UNIX)) {
-                        ret = __socket_nodelay (new_sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "setsockopt() failed for "
-                                        "NODELAY (%s)",
-                                        strerror (errno));
-                        }
-                }
+            if (priv->keepalive) {
+                ret = __socket_keepalive(
+                    new_sock, new_sockaddr.ss_family, priv->keepaliveintvl,
+                    priv->keepaliveidle, priv->keepalivecnt, priv->timeout);
+                if (ret != 0)
+                    gf_log(this->name, GF_LOG_WARNING,
+                           "Failed to set keep-alive: %s", strerror(errno));
+            }
+        }
 
-                if (priv->keepalive &&
-                                new_sockaddr.ss_family != AF_UNIX) {
-                        ret = __socket_keepalive (new_sock,
-                                                  new_sockaddr.ss_family,
-                                                  priv->keepaliveintvl,
-                                                  priv->keepaliveidle,
-                                                  priv->keepalivecnt,
-                                                  priv->timeout);
-                        if (ret == -1)
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "Failed to set keep-alive: %s",
-                                        strerror (errno));
-                }
+        new_trans = GF_CALLOC(1, sizeof(*new_trans), gf_common_mt_rpc_trans_t);
+        if (!new_trans) {
+            sys_close(new_sock);
+            gf_log(this->name, GF_LOG_WARNING,
+                   "transport object allocation failure; "
+                   "closed newly accepted socket %d",
+                   new_sock);
+            goto out;
+        }
 
-                new_trans = GF_CALLOC (1, sizeof (*new_trans),
-                                gf_common_mt_rpc_trans_t);
-                if (!new_trans) {
-                        sys_close (new_sock);
-                        goto out;
-                }
+        ret = pthread_mutex_init(&new_trans->lock, NULL);
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "pthread_mutex_init() failed: %s; closing newly accepted "
+                   "socket %d",
+                   strerror(errno), new_sock);
+            sys_close(new_sock);
+            GF_FREE(new_trans);
+            goto out;
+        }
+        INIT_LIST_HEAD(&new_trans->list);
 
-                ret = pthread_mutex_init(&new_trans->lock, NULL);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "pthread_mutex_init() failed: %s",
-                                strerror (errno));
-                        sys_close (new_sock);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
-                INIT_LIST_HEAD (&new_trans->list);
+        new_trans->name = gf_strdup(this->name);
 
-                new_trans->name = gf_strdup (this->name);
+        memcpy(&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen);
+        new_trans->peerinfo.sockaddr_len = addrlen;
 
-                memcpy (&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen);
-                new_trans->peerinfo.sockaddr_len = addrlen;
+        new_trans->myinfo.sockaddr_len = sizeof(new_trans->myinfo.sockaddr);
 
-                new_trans->myinfo.sockaddr_len = sizeof (new_trans->myinfo.sockaddr);
+        ret = getsockname(new_sock, SA(&new_trans->myinfo.sockaddr),
+                          &new_trans->myinfo.sockaddr_len);
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "getsockname on socket %d "
+                   "failed (errno:%s); closing newly accepted socket",
+                   new_sock, strerror(errno));
+            sys_close(new_sock);
+            GF_FREE(new_trans->name);
+            GF_FREE(new_trans);
+            goto out;
+        }
 
-                ret = getsockname (new_sock, SA (&new_trans->myinfo.sockaddr),
-                                   &new_trans->myinfo.sockaddr_len);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "getsockname on %d failed (%s)",
-                                new_sock, strerror (errno));
-                        sys_close (new_sock);
-                        GF_FREE (new_trans->name);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
+        get_transport_identifiers(new_trans);
+        gf_log(this->name, GF_LOG_TRACE, "XXX server:%s, client:%s",
+               new_trans->myinfo.identifier, new_trans->peerinfo.identifier);
+
+        /* Make options available to local socket_init() to create new
+         * SSL_CTX per transport. A separate SSL_CTX per transport is
+         * required to avoid setting crl checking options for client
+         * connections. The verification options eventually get copied
+         * to the SSL object. Unfortunately, there's no way to identify
+         * whether socket_init() is being called after a client-side
+         * connect() or a server-side accept(). Although, we could pass
+         * a flag from the transport init() to the socket_init() and
+         * from this place, this doesn't identify the case where the
+         * server-side transport loading is done for the first time.
+         * Also, SSL doesn't apply for UNIX sockets.
+         */
+        if (new_sockaddr.ss_family != AF_UNIX)
+            new_trans->options = dict_ref(this->options);
+        new_trans->ctx = this->ctx;
 
-                get_transport_identifiers (new_trans);
-                ret = socket_init(new_trans);
-                if (ret != 0) {
-                        sys_close (new_sock);
-                        GF_FREE (new_trans->name);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
-                new_trans->ops = this->ops;
-                new_trans->init = this->init;
-                new_trans->fini = this->fini;
-                new_trans->ctx  = ctx;
-                new_trans->xl   = this->xl;
-                new_trans->mydata = this->mydata;
-                new_trans->notify = this->notify;
-                new_trans->listener = this;
-                new_priv = new_trans->private;
-
-                if (new_sockaddr.ss_family == AF_UNIX) {
-                        new_priv->use_ssl = _gf_false;
-                } else {
-                        switch (priv->srvr_ssl) {
-                                case MGMT_SSL_ALWAYS:
-                                        /* Glusterd with secure_mgmt. */
-                                        new_priv->use_ssl = _gf_true;
-                                        break;
-                                case MGMT_SSL_COPY_IO:
-                                        /* Glusterfsd. */
-                                        new_priv->use_ssl = priv->ssl_enabled;
-                                        break;
-                                default:
-                                        new_priv->use_ssl = _gf_false;
-                        }
-                }
+        ret = socket_init(new_trans);
 
-                new_priv->sock = new_sock;
-                new_priv->own_thread = priv->own_thread;
-
-                new_priv->ssl_ctx = priv->ssl_ctx;
-                if (new_priv->use_ssl && !new_priv->own_thread) {
-                        cname = ssl_setup_connection(new_trans, 1);
-                        if (!cname) {
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "server setup failed");
-                                sys_close (new_sock);
-                                GF_FREE (new_trans->name);
-                                GF_FREE (new_trans);
-                                goto out;
-                        }
-                        this->ssl_name = cname;
-                }
+        /* reset options to NULL to avoid double free */
+        if (new_sockaddr.ss_family != AF_UNIX) {
+            dict_unref(new_trans->options);
+            new_trans->options = NULL;
+        }
 
-                if (!priv->bio && !priv->own_thread) {
-                        ret = __socket_nonblock (new_sock);
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "initialization of new_trans "
+                   "failed; closing newly accepted socket %d",
+                   new_sock);
+            sys_close(new_sock);
+            GF_FREE(new_trans->name);
+            GF_FREE(new_trans);
+            goto out;
+        }
+        new_trans->ops = this->ops;
+        new_trans->init = this->init;
+        new_trans->fini = this->fini;
+        new_trans->ctx = ctx;
+        new_trans->xl = this->xl;
+        new_trans->mydata = this->mydata;
+        new_trans->notify = this->notify;
+        new_trans->listener = this;
+        new_trans->notify_poller_death = this->poller_death_accept;
+        new_priv = new_trans->private;
+
+        if (new_sockaddr.ss_family == AF_UNIX) {
+            new_priv->use_ssl = _gf_false;
+        } else {
+            switch (priv->srvr_ssl) {
+                case MGMT_SSL_ALWAYS:
+                    /* Glusterd with secure_mgmt. */
+                    new_priv->use_ssl = _gf_true;
+                    break;
+                case MGMT_SSL_COPY_IO:
+                    /* Glusterfsd. */
+                    new_priv->use_ssl = priv->ssl_enabled;
+                    break;
+                default:
+                    new_priv->use_ssl = _gf_false;
+            }
+        }
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "NBIO on %d failed (%s)",
-                                        new_sock, strerror (errno));
+        new_priv->sock = new_sock;
 
-                                sys_close (new_sock);
-                                GF_FREE (new_trans->name);
-                                GF_FREE (new_trans);
-                                goto out;
-                        }
-                }
+        new_priv->ssl_enabled = priv->ssl_enabled;
+        new_priv->connected = 1;
+        new_priv->is_server = _gf_true;
 
-                /*
-                 * In the own_thread case, this is used to
-                 * indicate that we're initializing a server
-                 * connection.
-                 */
-                new_priv->connected = 1;
-                new_priv->is_server = _gf_true;
-                rpc_transport_ref (new_trans);
-
-                if (new_priv->own_thread) {
-                        if (pipe(new_priv->pipe) < 0) {
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "could not create pipe");
-                        }
-                        ret = socket_spawn(new_trans);
-                        if (ret) {
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "could not spawn thread");
-                                sys_close (new_priv->pipe[0]);
-                                sys_close (new_priv->pipe[1]);
-                        }
-                }  else {
-                        /* Take a ref on the new_trans to avoid
-                         * getting deleted when event_register()
-                         * causes socket_event_handler() to race
-                         * ahead of this path to eventually find
-                         * a disconnect and unref the transport
-                         */
-                        rpc_transport_ref (new_trans);
-
-                        /* Send a notification to RPCSVC layer
-                         * to save the new_trans in its service
-                         * list before we register the new_sock
-                         * with epoll to begin receiving notifications
-                         * for data handling.
-                         */
-                        ret = rpc_transport_notify (this, RPC_TRANSPORT_ACCEPT, new_trans);
-
-                        if (ret != -1) {
-                                new_priv->idx =
-                                        event_register (ctx->event_pool,
-                                                        new_sock,
-                                                        socket_event_handler,
-                                                        new_trans,
-                                                        1, 0);
-                                if (new_priv->idx == -1) {
-                                        ret = -1;
-                                        gf_log(this->name, GF_LOG_ERROR,
-                                               "failed to register the socket "
-                                               "with event");
-
-                                        /* event_register() could have failed for some
-                                         * reason, implying that the new_sock cannot be
-                                         * added to the epoll set. If we wont get any
-                                         * more notifications for new_sock from epoll,
-                                         * then we better remove the corresponding
-                                         * new_trans object from the RPCSVC service list.
-                                         * Since we've notified RPC service of new_trans
-                                         * before we attempted event_register(), we better
-                                         * unlink the new_trans from the RPCSVC service list
-                                         * to cleanup the stateby sending out a DISCONNECT
-                                         * notification.
-                                         */
-                                        rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, new_trans);
-                                }
-                        }
-
-                        /* this rpc_transport_unref() is for managing race between
-                         * 1. socket_server_event_handler and
-                         * 2. socket_event_handler
-                         * trying to add and remove new_trans from the rpcsvc
-                         * service list
-                         * now that we are done with the notifications, lets
-                         * reduce the reference
-                         */
-                        rpc_transport_unref (new_trans);
-                }
+        /*
+         * This is the first ref on the newly accepted
+         * transport.
+         */
+        rpc_transport_ref(new_trans);
 
-                if (ret == -1) {
-                        sys_close (new_sock);
-                        /* this unref is to actually cause the destruction of
-                         * the new_trans since we've failed at everything so far
-                         */
-                        rpc_transport_unref (new_trans);
+        {
+            /* Take a ref on the new_trans to avoid
+             * getting deleted when event_register()
+             * causes socket_event_handler() to race
+             * ahead of this path to eventually find
+             * a disconnect and unref the transport
+             */
+            rpc_transport_ref(new_trans);
+
+            /* Send a notification to RPCSVC layer
+             * to save the new_trans in its service
+             * list before we register the new_sock
+             * with epoll to begin receiving notifications
+             * for data handling.
+             */
+            ret = rpc_transport_notify(this, RPC_TRANSPORT_ACCEPT, new_trans);
+
+            if (ret >= 0) {
+                new_priv->idx = gf_event_register(
+                    ctx->event_pool, new_sock, socket_event_handler, new_trans,
+                    1, 0, new_trans->notify_poller_death);
+                if (new_priv->idx == -1) {
+                    ret = -1;
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "failed to register the socket "
+                           "with event");
+
+                    /* event_register() could have failed for some
+                     * reason, implying that the new_sock cannot be
+                     * added to the epoll set. If we won't get any
+                     * more notifications for new_sock from epoll,
+                     * then we better remove the corresponding
+                     * new_trans object from the RPCSVC service list.
+                     * Since we've notified RPC service of new_trans
+                     * before we attempted event_register(), we better
+                     * unlink the new_trans from the RPCSVC service list
+                     * to cleanup the stateby sending out a DISCONNECT
+                     * notification.
+                     */
+                    rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT,
+                                         new_trans);
                 }
+            }
+
+            /* this rpc_transport_unref() is for managing race between
+             * 1. socket_server_event_handler and
+             * 2. socket_event_handler
+             * trying to add and remove new_trans from the rpcsvc
+             * service list
+             * now that we are done with the notifications, lets
+             * reduce the reference
+             */
+            rpc_transport_unref(new_trans);
         }
-out:
-        event_handled (ctx->event_pool, fd, idx, gen);
 
-        if (cname && (cname != this->ssl_name)) {
-                GF_FREE(cname);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_WARNING, "closing newly accepted socket");
+            sys_close(new_sock);
+            /* this unref is to actually cause the destruction of
+             * the new_trans since we've failed at everything so far
+             */
+            rpc_transport_unref(new_trans);
         }
-        return ret;
+    }
+out:
+    return;
 }
 
-
 static int
-socket_disconnect (rpc_transport_t *this, gf_boolean_t wait)
+socket_disconnect(rpc_transport_t *this, gf_boolean_t wait)
 {
-        socket_private_t *priv   = NULL;
-        int               ret    = -1;
-        char              a_byte = 'r';
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        if (wait && priv->own_thread) {
-                GF_REF_PUT (priv);
-
-                pthread_mutex_lock (&priv->cond_lock);
-                {
-                        /* Change the state to OT_PLEASE_DIE so that
-                         * socket_poller can exit. */
-                        priv->ot_state = OT_PLEASE_DIE;
-                        /* Write something into the pipe so that poller
-                         * thread can wake up.*/
-                        if (sys_write (priv->pipe[1], &a_byte, 1) < 1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                                "write error on pipe");
-                        }
+    socket_private_t *priv = NULL;
+    int ret = -1;
 
-                        /* Wait for socket_poller to exit */
-                        if (!priv->own_thread_done)
-                                pthread_cond_wait (&priv->cond,
-                                                   &priv->cond_lock);
-                }
-                pthread_mutex_unlock (&priv->cond_lock);
-        }
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->lock);
-        {
-                ret = __socket_disconnect (this);
-        }
-        pthread_mutex_unlock (&priv->lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        ret = __socket_disconnect(this);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
-out:
-        return ret;
+    return ret;
 }
 
-void*
-socket_connect_error_cbk (void *opaque)
+void *
+socket_connect_error_cbk(void *opaque)
 {
-        socket_connect_error_state_t *arg;
+    socket_connect_error_state_t *arg;
 
-        GF_ASSERT (opaque);
+    GF_ASSERT(opaque);
 
-        arg = opaque;
-        THIS = arg->this;
+    arg = opaque;
+    THIS = arg->this;
 
-        rpc_transport_notify (arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans);
+    rpc_transport_notify(arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans);
 
-        if (arg->refd)
-                rpc_transport_unref (arg->trans);
+    if (arg->refd)
+        rpc_transport_unref(arg->trans);
 
-        GF_FREE (opaque);
-        return NULL;
+    GF_FREE(opaque);
+    return NULL;
 }
 
 static void
-socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv,
-                     uint16_t port)
+socket_fix_ssl_opts(rpc_transport_t *this, socket_private_t *priv,
+                    uint16_t port)
 {
-        if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "%s SSL for portmapper connection",
-                        priv->mgmt_ssl ? "enabling" : "disabling");
-                priv->use_ssl = priv->mgmt_ssl;
-        }
-        else if (priv->ssl_enabled && !priv->use_ssl) {
-                gf_log(this->name,GF_LOG_DEBUG,
-                       "re-enabling SSL for I/O connection");
-                priv->use_ssl = _gf_true;
-        }
+    if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s SSL for portmapper connection",
+               priv->mgmt_ssl ? "enabling" : "disabling");
+        priv->use_ssl = priv->mgmt_ssl;
+    } else if (priv->ssl_enabled && !priv->use_ssl) {
+        gf_log(this->name, GF_LOG_DEBUG, "re-enabling SSL for I/O connection");
+        priv->use_ssl = _gf_true;
+    }
 }
 
 /*
@@ -3066,1288 +3304,1003 @@ socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv,
  * as well.
  */
 static int
-connect_loop (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+connect_loop(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
 {
-        int     ret;
-        int     connect_fails   = 0;
+    int ret;
+    int connect_fails = 0;
 
-        for (;;) {
-                ret = connect (sockfd, addr, addrlen);
-                if (ret >= 0) {
-                        break;
-                }
-                if ((errno != ENOENT) || (++connect_fails >= 5)) {
-                        break;
-                }
-                sleep (1);
+    for (;;) {
+        ret = connect(sockfd, addr, addrlen);
+        if (ret >= 0) {
+            break;
+        }
+        if ((errno != ENOENT) || (++connect_fails >= 5)) {
+            break;
         }
+        sleep(1);
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-socket_connect (rpc_transport_t *this, int port)
+socket_connect(rpc_transport_t *this, int port)
 {
-        int                            ret             = -1;
-        int                            th_ret          = -1;
-        int                            sock            = -1;
-        socket_private_t              *priv            = NULL;
-        socklen_t                      sockaddr_len    = 0;
-        glusterfs_ctx_t               *ctx             = NULL;
-        sa_family_t                    sa_family       = {0, };
-        char                          *local_addr      = NULL;
-        union gf_sock_union            sock_union;
-        struct sockaddr_in            *addr            = NULL;
-        gf_boolean_t                   refd      = _gf_false;
-        socket_connect_error_state_t  *arg             = NULL;
-        pthread_t                      th_id           = {0, };
-        char                          *cname           = NULL;
-        gf_boolean_t                   ign_enoent      = _gf_false;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, err);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, err);
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        if (!priv) {
-                gf_log_callingfn (this->name, GF_LOG_WARNING,
-                        "connect() called on uninitialized transport");
-                goto err;
+    int ret = -1;
+    int th_ret = -1;
+    int sock = -1;
+    socket_private_t *priv = NULL;
+    socklen_t sockaddr_len = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    sa_family_t sa_family = {
+        0,
+    };
+    char *local_addr = NULL;
+    union gf_sock_union sock_union;
+    struct sockaddr_in *addr = NULL;
+    gf_boolean_t refd = _gf_false;
+    socket_connect_error_state_t *arg = NULL;
+    pthread_t th_id = {
+        0,
+    };
+    gf_boolean_t ign_enoent = _gf_false;
+    gf_boolean_t connect_attempted = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("socket", this, err);
+    GF_VALIDATE_OR_GOTO("socket", this->private, err);
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    if (!priv) {
+        gf_log_callingfn(this->name, GF_LOG_WARNING,
+                         "connect() called on uninitialized transport");
+        goto err;
+    }
+
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->sock >= 0) {
+            gf_log_callingfn(this->name, GF_LOG_TRACE,
+                             "connect () called on transport "
+                             "already connected");
+            errno = EINPROGRESS;
+            ret = -1;
+            goto unlock;
         }
 
-        pthread_mutex_lock (&priv->lock);
-        {
-                priv->own_thread_done = _gf_false;
-                if (priv->sock != -1) {
-                        gf_log_callingfn (this->name, GF_LOG_TRACE,
-                                          "connect () called on transport "
-                                          "already connected");
-                        errno = EINPROGRESS;
-                        ret = -1;
-                        goto unlock;
-                }
+        gf_log(this->name, GF_LOG_TRACE, "connecting %p, sock=%d", this,
+               priv->sock);
 
-                gf_log (this->name, GF_LOG_TRACE,
-                        "connecting %p, state=%u gen=%u sock=%d", this,
-                        priv->ot_state, priv->ot_gen, priv->sock);
-
-                ret = socket_client_get_remote_sockaddr (this, &sock_union.sa,
-                                                     &sockaddr_len, &sa_family);
-                if (ret == -1) {
-                        /* logged inside client_get_remote_sockaddr */
-                        goto unlock;
-                }
-
-                if (sa_family == AF_UNIX) {
-                        priv->ssl_enabled = _gf_false;
-                        priv->mgmt_ssl = _gf_false;
-                }
-                else {
-                        if (port > 0) {
-                                sock_union.sin.sin_port = htons (port);
-                        }
-                        socket_fix_ssl_opts (this, priv,
-                                             ntohs(sock_union.sin.sin_port));
-                }
-
-                memcpy (&this->peerinfo.sockaddr, &sock_union.storage,
-                        sockaddr_len);
-                this->peerinfo.sockaddr_len = sockaddr_len;
+        ret = socket_client_get_remote_sockaddr(this, &sock_union.sa,
+                                                &sockaddr_len, &sa_family);
+        if (ret < 0) {
+            /* logged inside client_get_remote_sockaddr */
+            goto unlock;
+        }
 
-                priv->sock = socket (sa_family, SOCK_STREAM, 0);
-                if (priv->sock == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "socket creation failed (%s)",
-                                strerror (errno));
-                        ret = -1;
-                        goto unlock;
-                }
+        if (sa_family == AF_UNIX) {
+            priv->ssl_enabled = _gf_false;
+            priv->mgmt_ssl = _gf_false;
+        } else {
+            if (port > 0) {
+                sock_union.sin.sin_port = htons(port);
+            }
+            socket_fix_ssl_opts(this, priv, ntohs(sock_union.sin.sin_port));
+        }
 
-                /* Cant help if setting socket options fails. We can continue
-                 * working nonetheless.
-                 */
-                if (priv->windowsize != 0) {
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting receive window "
-                                        "size failed: %d: %d: %s",
-                                        priv->sock, priv->windowsize,
-                                        strerror (errno));
-                        }
-
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting send window size "
-                                        "failed: %d: %d: %s",
-                                        priv->sock, priv->windowsize,
-                                        strerror (errno));
-                        }
-                }
+        memcpy(&this->peerinfo.sockaddr, &sock_union.storage, sockaddr_len);
+        this->peerinfo.sockaddr_len = sockaddr_len;
 
+        priv->sock = sys_socket(sa_family, SOCK_STREAM, 0);
+        if (priv->sock < 0) {
+            gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)",
+                   strerror(errno));
+            ret = -1;
+            goto unlock;
+        }
 
-                if (priv->nodelay && (sa_family != AF_UNIX)) {
-                        ret = __socket_nodelay (priv->sock);
+        /* Can't help if setting socket options fails. We can continue
+         * working nonetheless.
+         */
+        if (priv->windowsize != 0) {
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting receive window "
+                       "size failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting send window size "
+                       "failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+        }
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NODELAY on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                        }
-                }
+        /* Make sure we are not vulnerable to someone setting
+         * net.ipv6.bindv6only to 1 so that gluster services are
+         * available over IPv4 & IPv6.
+         */
+#ifdef IPV6_DEFAULT
+        int disable_v6only = 0;
+        if (setsockopt(priv->sock, IPPROTO_IPV6, IPV6_V6ONLY,
+                       (void *)&disable_v6only, sizeof(disable_v6only)) < 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Error disabling sockopt IPV6_V6ONLY: \"%s\"",
+                   strerror(errno));
+        }
+#endif
 
-                if (priv->keepalive && sa_family != AF_UNIX) {
-                        ret = __socket_keepalive (priv->sock,
-                                                  sa_family,
-                                                  priv->keepaliveintvl,
-                                                  priv->keepaliveidle,
-                                                  priv->keepalivecnt,
-                                                  priv->timeout);
-                        if (ret == -1)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Failed to set keep-alive: %s",
-                                        strerror (errno));
+        if (sa_family != AF_UNIX) {
+            if (priv->nodelay) {
+                ret = __socket_nodelay(priv->sock);
+                if (ret != 0) {
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "NODELAY on %d failed (%s)", priv->sock,
+                           strerror(errno));
                 }
+            }
 
-                SA (&this->myinfo.sockaddr)->sa_family =
-                        SA (&this->peerinfo.sockaddr)->sa_family;
-
-                /* If a source addr is explicitly specified, use it */
-                ret = dict_get_str (this->options,
-                                    "transport.socket.source-addr",
-                                    &local_addr);
-                if (!ret && SA (&this->myinfo.sockaddr)->sa_family == AF_INET) {
-                        addr = (struct sockaddr_in *)(&this->myinfo.sockaddr);
-                        ret = inet_pton (AF_INET, local_addr,
-                                         &(addr->sin_addr.s_addr));
-                }
+            if (priv->keepalive) {
+                ret = __socket_keepalive(
+                    priv->sock, sa_family, priv->keepaliveintvl,
+                    priv->keepaliveidle, priv->keepalivecnt, priv->timeout);
+                if (ret != 0)
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "Failed to set keep-alive: %s", strerror(errno));
+            }
+        }
 
-                /* If client wants ENOENT to be ignored */
-               ign_enoent = dict_get_str_boolean (this->options,
-                   "transport.socket.ignore-enoent", _gf_false);
+        SA(&this->myinfo.sockaddr)->sa_family = SA(&this->peerinfo.sockaddr)
+                                                    ->sa_family;
 
-                ret = client_bind (this, SA (&this->myinfo.sockaddr),
-                                   &this->myinfo.sockaddr_len, priv->sock);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "client bind failed: %s", strerror (errno));
-                        goto handler;
-                }
+        /* If a source addr is explicitly specified, use it */
+        ret = dict_get_str_sizen(this->options, "transport.socket.source-addr",
+                                 &local_addr);
+        if (!ret && SA(&this->myinfo.sockaddr)->sa_family == AF_INET) {
+            addr = (struct sockaddr_in *)(&this->myinfo.sockaddr);
+            ret = inet_pton(AF_INET, local_addr, &(addr->sin_addr.s_addr));
+        }
 
-                if (!priv->use_ssl && !priv->bio && !priv->own_thread) {
-                        ret = __socket_nonblock (priv->sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NBIO on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                                goto handler;
-                        }
-                }
+        /* If client wants ENOENT to be ignored */
+        ign_enoent = dict_get_str_boolean(
+            this->options, "transport.socket.ignore-enoent", _gf_false);
 
-                this->connect_failed = _gf_false;
-                if (ign_enoent) {
-                        ret = connect_loop (priv->sock,
-                                            SA (&this->peerinfo.sockaddr),
-                                            this->peerinfo.sockaddr_len);
-                } else {
-                        ret = connect (priv->sock,
-                                       SA (&this->peerinfo.sockaddr),
-                                       this->peerinfo.sockaddr_len);
-                }
+        ret = client_bind(this, SA(&this->myinfo.sockaddr),
+                          &this->myinfo.sockaddr_len, priv->sock);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_WARNING, "client bind failed: %s",
+                   strerror(errno));
+            goto handler;
+        }
 
-                if (ret == -1 && errno == ENOENT && ign_enoent) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                               "Ignore failed connection attempt on %s, (%s) ",
-                                this->peerinfo.identifier, strerror (errno));
-
-                        /* connect failed with some other error than EINPROGRESS
-                        so, getsockopt (... SO_ERROR ...), will not catch any
-                        errors and return them to us, we need to remember this
-                        state, and take actions in socket_event_handler
-                        appropriately */
-                        /* TBD: What about ENOENT, we will do getsockopt there
-                        as well, so how is that exempt from such a problem? */
-                        priv->connect_failed = 1;
-                        this->connect_failed = _gf_true;
-
-                        goto handler;
-                }
+        /* make socket non-blocking for all types of sockets */
+        if (!priv->bio) {
+            ret = __socket_nonblock(priv->sock);
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_ERROR, "NBIO on %d failed (%s)",
+                       priv->sock, strerror(errno));
+                goto handler;
+            } else {
+                gf_log(this->name, GF_LOG_TRACE,
+                       ">>> connect() with non-blocking IO for ALL");
+            }
+        }
+        this->connect_failed = _gf_false;
+        priv->connect_failed = 0;
+        priv->connected = 0;
 
-                if (ret == -1 && ((errno != EINPROGRESS) && (errno != ENOENT))) {
-                        /* For unix path based sockets, the socket path is
-                         * cryptic (md5sum of path) and may not be useful for
-                         * the user in debugging so log it in DEBUG
-                         */
-                        gf_log (this->name, ((sa_family == AF_UNIX) ?
-                                GF_LOG_DEBUG : GF_LOG_ERROR),
-                                "connection attempt on %s failed, (%s)",
-                                this->peerinfo.identifier, strerror (errno));
-
-                        /* connect failed with some other error than EINPROGRESS
-                        so, getsockopt (... SO_ERROR ...), will not catch any
-                        errors and return them to us, we need to remember this
-                        state, and take actions in socket_event_handler
-                        appropriately */
-                        /* TBD: What about ENOENT, we will do getsockopt there
-                        as well, so how is that exempt from such a problem? */
-                        priv->connect_failed = 1;
-
-                        goto handler;
-                }
-                else {
-                        /* reset connect_failed so that any previous attempts
-                        state is not carried forward */
-                        priv->connect_failed = 0;
-                        ret = 0;
-                }
+        socket_dump_info(SA(&this->peerinfo.sockaddr), priv->is_server,
+                         priv->use_ssl, priv->sock, this->name,
+                         "connecting to");
 
-                if (priv->use_ssl && !priv->own_thread) {
-                        cname = ssl_setup_connection(this,0);
-                        if (!cname) {
-                                errno = ENOTCONN;
-                                ret = -1;
-                                gf_log(this->name,GF_LOG_ERROR,
-                                       "client setup failed");
-                                goto handler;
-                        }
-                        if (priv->connected) {
-                                this->ssl_name = cname;
-                        }
-                        else {
-                                GF_FREE(cname);
-                        }
-                }
+        if (ign_enoent) {
+            ret = connect_loop(priv->sock, SA(&this->peerinfo.sockaddr),
+                               this->peerinfo.sockaddr_len);
+        } else {
+            ret = connect(priv->sock, SA(&this->peerinfo.sockaddr),
+                          this->peerinfo.sockaddr_len);
+        }
 
-                if (!priv->bio && !priv->own_thread) {
-                        ret = __socket_nonblock (priv->sock);
+        connect_attempted = _gf_true;
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NBIO on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                                goto handler;
-                        }
-                }
+        if ((ret != 0) && (errno == ENOENT) && ign_enoent) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Ignore failed connection attempt on %s, (%s) ",
+                   this->peerinfo.identifier, strerror(errno));
 
-handler:
-                if (ret < 0) {
-                        /* Ignore error from connect. epoll events
-                           should be handled in the socket handler.  shutdown(2)
-                           will result in EPOLLERR, so cleanup is done in
-                           socket_event_handler or socket_poller */
-                        shutdown (priv->sock, SHUT_RDWR);
-                }
+            /* connect failed with some other error than EINPROGRESS
+            so, getsockopt (... SO_ERROR ...), will not catch any
+            errors and return them to us, we need to remember this
+            state, and take actions in socket_event_handler
+            appropriately */
+            /* TBD: What about ENOENT, we will do getsockopt there
+            as well, so how is that exempt from such a problem? */
+            priv->connect_failed = 1;
+            this->connect_failed = _gf_true;
 
-                /*
-                 * In the own_thread case, this is used to indicate that we're
-                 * initializing a client connection.
-                 */
-                priv->connected = 0;
-                priv->is_server = _gf_false;
-                rpc_transport_ref (this);
-                refd = _gf_true;
-
-                if (priv->own_thread) {
-                        if (priv->connect_failed) {
-                                gf_msg_debug (this->name, 0,
-                                              "socket connect is failed so close it");
-                                sys_close (priv->sock);
-                                priv->sock = -1;
-                                ret = -1;
-                                goto unlock;
-                        }
+            goto handler;
+        }
 
-                        if (pipe(priv->pipe) < 0) {
-                                gf_log(this->name,GF_LOG_ERROR,
-                                "could not create pipe");
-                        }
+        if ((ret != 0) && (errno != EINPROGRESS) && (errno != ENOENT)) {
+            /* For unix path based sockets, the socket path is
+             * cryptic (md5sum of path) and may not be useful for
+             * the user in debugging so log it in DEBUG
+             */
+            gf_log(this->name,
+                   ((sa_family == AF_UNIX) ? GF_LOG_DEBUG : GF_LOG_ERROR),
+                   "connection attempt on %s failed, (%s)",
+                   this->peerinfo.identifier, strerror(errno));
+
+            /* connect failed with some other error than EINPROGRESS
+            so, getsockopt (... SO_ERROR ...), will not catch any
+            errors and return them to us, we need to remember this
+            state, and take actions in socket_event_handler
+            appropriately */
+            /* TBD: What about ENOENT, we will do getsockopt there
+            as well, so how is that exempt from such a problem? */
+            priv->connect_failed = 1;
+
+            goto handler;
+        } else {
+            /* reset connect_failed so that any previous attempts
+            state is not carried forward */
+            priv->connect_failed = 0;
+            ret = 0;
+        }
 
-                        this->listener = this;
-                        ret =  socket_spawn(this);
-                        if (ret) {
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "could not spawn thread");
-                                sys_close (priv->pipe[0]);
-                                sys_close (priv->pipe[1]);
-                                sys_close (priv->sock);
-                                priv->sock = -1;
-                        }
-                }
-                else {
-                        priv->idx = event_register (ctx->event_pool, priv->sock,
-                                                    socket_event_handler,
-                                                    this, 1, 1);
-                        if (priv->idx == -1) {
-                                gf_log ("", GF_LOG_WARNING,
-                                        "failed to register the event");
-                                sys_close (priv->sock);
-                                priv->sock = -1;
-                                ret = -1;
-                        }
-                }
+    handler:
+        if (ret < 0 && !connect_attempted) {
+            /* Ignore error from connect. epoll events
+               should be handled in the socket handler.  shutdown(2)
+               will result in EPOLLERR, so cleanup is done in
+               socket_event_handler or socket_poller */
+            shutdown(priv->sock, SHUT_RDWR);
+            ret = 0;
+            gf_log(this->name, GF_LOG_INFO,
+                   "intentional client shutdown(%d, SHUT_RDWR)", priv->sock);
+        }
 
-unlock:
-                sock = priv->sock;
+        priv->connected = 0;
+        priv->is_server = _gf_false;
+        rpc_transport_ref(this);
+        refd = _gf_true;
+
+        this->listener = this;
+        priv->idx = gf_event_register(ctx->event_pool, priv->sock,
+                                      socket_event_handler, this, 1, 1,
+                                      this->notify_poller_death);
+        if (priv->idx == -1) {
+            gf_log("", GF_LOG_WARNING,
+                   "failed to register the event; "
+                   "closing socket %d",
+                   priv->sock);
+            sys_close(priv->sock);
+            priv->sock = -1;
+            ret = -1;
         }
-        pthread_mutex_unlock (&priv->lock);
+
+    unlock:
+        sock = priv->sock;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
 err:
-        /* if sock != -1, then cleanup is done from the event handler */
-        if (ret == -1 && sock == -1) {
-                /* Cleaup requires to send notification to upper layer which
-                   intern holds the big_lock. There can be dead-lock situation
-                   if big_lock is already held by the current thread.
-                   So transfer the ownership to seperate thread for cleanup.
-                */
-                arg = GF_CALLOC (1, sizeof (*arg),
-                                 gf_sock_connect_error_state_t);
-                arg->this = THIS;
-                arg->trans = this;
-                arg->refd = refd;
-                th_ret = gf_thread_create_detached (&th_id,
-                                                    socket_connect_error_cbk,
-                                                    arg, "scleanup");
-                if (th_ret) {
-                        /* Error will be logged by gf_thread_create_attached */
-                        gf_log (this->name, GF_LOG_ERROR, "Thread creation "
-                               "failed");
-                        GF_FREE (arg);
-                        GF_ASSERT (0);
-                }
+    /* if sock >= 0, then cleanup is done from the event handler */
+    if ((ret < 0) && (sock < 0)) {
+        /* Cleaup requires to send notification to upper layer which
+           intern holds the big_lock. There can be dead-lock situation
+           if big_lock is already held by the current thread.
+           So transfer the ownership to separate thread for cleanup.
+        */
+        arg = GF_CALLOC(1, sizeof(*arg), gf_sock_connect_error_state_t);
+        arg->this = THIS;
+        arg->trans = this;
+        arg->refd = refd;
+        th_ret = gf_thread_create_detached(&th_id, socket_connect_error_cbk,
+                                           arg, "scleanup");
+        if (th_ret) {
+            /* Error will be logged by gf_thread_create_attached */
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Thread creation "
+                   "failed");
+            GF_FREE(arg);
+            GF_ASSERT(0);
         }
 
-        return ret;
-}
+        ret = 0;
+    }
 
+    return ret;
+}
 
 static int
-socket_listen (rpc_transport_t *this)
+socket_listen(rpc_transport_t *this)
 {
-        socket_private_t *       priv = NULL;
-        int                      ret = -1;
-        int                      sock = -1;
-        struct sockaddr_storage  sockaddr;
-        socklen_t                sockaddr_len = 0;
-        peer_info_t             *myinfo = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        sa_family_t              sa_family = {0, };
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv   = this->private;
-        myinfo = &this->myinfo;
-        ctx    = this->ctx;
-
-        pthread_mutex_lock (&priv->lock);
-        {
-                sock = priv->sock;
-        }
-        pthread_mutex_unlock (&priv->lock);
-
-        if (sock != -1)  {
-                gf_log_callingfn (this->name, GF_LOG_DEBUG,
-                                  "already listening");
-                return ret;
-        }
-
-        ret = socket_server_get_local_sockaddr (this, SA (&sockaddr),
-                                                &sockaddr_len, &sa_family);
-        if (ret == -1) {
-                return ret;
-        }
-
-        pthread_mutex_lock (&priv->lock);
-        {
-                if (priv->sock != -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "already listening");
-                        goto unlock;
-                }
-
-                memcpy (&myinfo->sockaddr, &sockaddr, sockaddr_len);
-                myinfo->sockaddr_len = sockaddr_len;
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    int sock = -1;
+    struct sockaddr_storage sockaddr;
+    socklen_t sockaddr_len = 0;
+    peer_info_t *myinfo = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    sa_family_t sa_family = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    myinfo = &this->myinfo;
+    ctx = this->ctx;
+
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        sock = priv->sock;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
-                priv->sock = socket (sa_family, SOCK_STREAM, 0);
+    if (sock >= 0) {
+        gf_log_callingfn(this->name, GF_LOG_DEBUG, "already listening");
+        return ret;
+    }
 
-                if (priv->sock == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "socket creation failed (%s)",
-                                strerror (errno));
-                        goto unlock;
-                }
+    ret = socket_server_get_local_sockaddr(this, SA(&sockaddr), &sockaddr_len,
+                                           &sa_family);
+    if (ret < 0) {
+        return ret;
+    }
 
-                /* Cant help if setting socket options fails. We can continue
-                 * working nonetheless.
-                 */
-                if (priv->windowsize != 0) {
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting receive window size "
-                                        "failed: %d: %d: %s", priv->sock,
-                                        priv->windowsize,
-                                        strerror (errno));
-                        }
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->sock >= 0) {
+            gf_log(this->name, GF_LOG_DEBUG, "already listening");
+            goto unlock;
+        }
 
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting send window size failed:"
-                                        " %d: %d: %s", priv->sock,
-                                        priv->windowsize,
-                                        strerror (errno));
-                        }
-                }
+        memcpy(&myinfo->sockaddr, &sockaddr, sockaddr_len);
+        myinfo->sockaddr_len = sockaddr_len;
 
-                if (priv->nodelay && (sa_family != AF_UNIX)) {
-                        ret = __socket_nodelay (priv->sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setsockopt() failed for NODELAY (%s)",
-                                        strerror (errno));
-                        }
-                }
+        priv->sock = sys_socket(sa_family, SOCK_STREAM, 0);
 
-                if (!priv->bio) {
-                        ret = __socket_nonblock (priv->sock);
+        if (priv->sock < 0) {
+            gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)",
+                   strerror(errno));
+            goto unlock;
+        }
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NBIO on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                                sys_close (priv->sock);
-                                priv->sock = -1;
-                                goto unlock;
-                        }
-                }
+        /* Can't help if setting socket options fails. We can continue
+         * working nonetheless.
+         */
+        if (priv->windowsize != 0) {
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting receive window size "
+                       "failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting send window size failed:"
+                       " %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+        }
 
-                ret = __socket_server_bind (this);
+        if (priv->nodelay && (sa_family != AF_UNIX)) {
+            ret = __socket_nodelay(priv->sock);
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setsockopt() failed for NODELAY (%s)", strerror(errno));
+            }
+        }
 
-                if ((ret == -EADDRINUSE) || (ret == -1)) {
-                        /* logged inside __socket_server_bind() */
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        if (!priv->bio) {
+            ret = __socket_nonblock(priv->sock);
+
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "NBIO on socket %d failed "
+                       "(errno:%s); closing socket",
+                       priv->sock, strerror(errno));
+                sys_close(priv->sock);
+                priv->sock = -1;
+                goto unlock;
+            }
+        }
 
-                ret = listen (priv->sock, priv->backlog);
+        /* coverity[SLEEP] */
+        ret = __socket_server_bind(this);
+
+        if (ret < 0) {
+            /* logged inside __socket_server_bind() */
+            gf_log(this->name, GF_LOG_ERROR,
+                   "__socket_server_bind failed;"
+                   "closing socket %d",
+                   priv->sock);
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
+        }
 
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "could not set socket %d to listen mode (%s)",
-                                priv->sock, strerror (errno));
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        socket_dump_info(SA(&this->myinfo.sockaddr), priv->is_server,
+                         priv->use_ssl, priv->sock, this->name, "listening on");
 
-                rpc_transport_ref (this);
+        ret = listen(priv->sock, priv->backlog);
 
-                priv->idx = event_register (ctx->event_pool, priv->sock,
-                                            socket_server_event_handler,
-                                            this, 1, 0);
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "could not set socket %d to listen mode (errno:%s); "
+                   "closing socket",
+                   priv->sock, strerror(errno));
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
+        }
 
-                if (priv->idx == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "could not register socket %d with events",
-                                priv->sock);
-                        ret = -1;
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        rpc_transport_ref(this);
+
+        priv->idx = gf_event_register(ctx->event_pool, priv->sock,
+                                      socket_server_event_handler, this, 1, 0,
+                                      this->notify_poller_death);
+
+        if (priv->idx == -1) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "could not register socket %d with events; "
+                   "closing socket",
+                   priv->sock);
+            ret = -1;
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->lock);
+    pthread_mutex_unlock(&priv->out_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
+socket_submit_outgoing_msg(rpc_transport_t *this, rpc_transport_msg_t *msg)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
-        char              need_poll_out = 0;
-        char              need_append = 1;
-        struct ioq       *entry = NULL;
-        glusterfs_ctx_t  *ctx = NULL;
-	char              a_byte = 'j';
+    int ret = -1;
+    char need_poll_out = 0;
+    char need_append = 1;
+    struct ioq *entry = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    socket_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
-        ctx  = this->ctx;
+    priv = this->private;
+    ctx = this->ctx;
 
-        pthread_mutex_lock (&priv->lock);
-        {
-                if (priv->connected != 1) {
-                        if (!priv->submit_log && !priv->connect_finish_log) {
-                                gf_log (this->name, GF_LOG_INFO,
-                                        "not connected (priv->connected = %d)",
-                                        priv->connected);
-                                priv->submit_log = 1;
-                        }
-                        goto unlock;
-                }
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected != 1) {
+            if (!priv->submit_log && !priv->connect_finish_log) {
+                gf_log(this->name, GF_LOG_INFO,
+                       "not connected (priv->connected = %d)", priv->connected);
+                priv->submit_log = 1;
+            }
+            goto unlock;
+        }
 
-                priv->submit_log = 0;
-                entry = __socket_ioq_new (this, &req->msg);
-                if (!entry)
-                        goto unlock;
+        priv->submit_log = 0;
+        entry = __socket_ioq_new(this, msg);
+        if (!entry)
+            goto unlock;
 
-                if (list_empty (&priv->ioq)) {
-                        ret = __socket_ioq_churn_entry (this, entry, 1);
+        if (list_empty(&priv->ioq)) {
+            ret = __socket_ioq_churn_entry(this, entry);
 
-                        if (ret == 0) {
-                                need_append = 0;
-			}
-                        if (ret > 0) {
-                                need_poll_out = 1;
-			}
-                }
+            if (ret == 0) {
+                need_append = 0;
+            }
+            if (ret > 0) {
+                need_poll_out = 1;
+            }
+        }
 
-                if (need_append) {
-                        list_add_tail (&entry->list, &priv->ioq);
-			if (priv->own_thread) {
-				/*
-				 * Make sure the polling thread wakes up, by
-				 * writing a byte to represent this entry.
-				 */
-				if (sys_write (priv->pipe[1], &a_byte, 1) < 1) {
-					gf_log(this->name,GF_LOG_WARNING,
-					       "write error on pipe");
-				}
-			}
-                        ret = 0;
-                }
-                if (!priv->own_thread && need_poll_out) {
-                        /* first entry to wait. continue writing on POLLOUT */
-                        priv->idx = event_select_on (ctx->event_pool,
-                                                     priv->sock,
-                                                     priv->idx, -1, 1);
-                }
+        if (need_append) {
+            list_add_tail(&entry->list, &priv->ioq);
+            ret = 0;
         }
+        if (need_poll_out) {
+            /* first entry to wait. continue writing on POLLOUT */
+            priv->idx = gf_event_select_on(ctx->event_pool, priv->sock,
+                                           priv->idx, -1, 1);
+        }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->lock);
+    pthread_mutex_unlock(&priv->out_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
+socket_submit_request(rpc_transport_t *this, rpc_transport_req_t *req)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
-        char              need_poll_out = 0;
-        char              need_append = 1;
-        struct ioq       *entry = NULL;
-        glusterfs_ctx_t  *ctx = NULL;
-	char              a_byte = 'd';
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        ctx  = this->ctx;
-
-        pthread_mutex_lock (&priv->lock);
-        {
-                if (priv->connected != 1) {
-                        if (!priv->submit_log && !priv->connect_finish_log) {
-                                gf_log (this->name, GF_LOG_INFO,
-                                        "not connected (priv->connected = %d)",
-                                        priv->connected);
-                                priv->submit_log = 1;
-                        }
-                        goto unlock;
-                }
-
-                priv->submit_log = 0;
-                entry = __socket_ioq_new (this, &reply->msg);
-                if (!entry)
-                        goto unlock;
-
-                if (list_empty (&priv->ioq)) {
-                        ret = __socket_ioq_churn_entry (this, entry, 1);
-
-                        if (ret == 0) {
-                                need_append = 0;
-			}
-                        if (ret > 0) {
-                                need_poll_out = 1;
-			}
-                }
-
-                if (need_append) {
-                        list_add_tail (&entry->list, &priv->ioq);
-			if (priv->own_thread) {
-				/*
-				 * Make sure the polling thread wakes up, by
-				 * writing a byte to represent this entry.
-				 */
-				if (sys_write (priv->pipe[1], &a_byte, 1) < 1) {
-					gf_log(this->name,GF_LOG_WARNING,
-					       "write error on pipe");
-				}
-			}
-                        ret = 0;
-                }
-                if (!priv->own_thread && need_poll_out) {
-                        /* first entry to wait. continue writing on POLLOUT */
-                        priv->idx = event_select_on (ctx->event_pool,
-                                                     priv->sock,
-                                                     priv->idx, -1, 1);
-                }
-        }
-unlock:
-        pthread_mutex_unlock (&priv->lock);
-
-out:
-        return ret;
+    return socket_submit_outgoing_msg(this, &req->msg);
 }
 
+static int32_t
+socket_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply)
+{
+    return socket_submit_outgoing_msg(this, &reply->msg);
+}
 
 static int32_t
-socket_getpeername (rpc_transport_t *this, char *hostname, int hostlen)
+socket_getpeername(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", hostname, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", hostname, out);
 
-        if (hostlen < (strlen (this->peerinfo.identifier) + 1)) {
-                goto out;
-        }
+    if (hostlen < (strlen(this->peerinfo.identifier) + 1)) {
+        goto out;
+    }
 
-        strcpy (hostname, this->peerinfo.identifier);
-        ret = 0;
+    strcpy(hostname, this->peerinfo.identifier);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getpeeraddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                    struct sockaddr_storage *sa, socklen_t salen)
+socket_getpeeraddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                   struct sockaddr_storage *sa, socklen_t salen)
 {
-        int32_t ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", sa, out);
+    int32_t ret = -1;
 
-        *sa = this->peerinfo.sockaddr;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", sa, out);
+    ret = 0;
 
-        if (peeraddr != NULL) {
-                ret = socket_getpeername (this, peeraddr, addrlen);
-        }
-        ret = 0;
+    *sa = this->peerinfo.sockaddr;
 
+    if (peeraddr != NULL) {
+        ret = socket_getpeername(this, peeraddr, addrlen);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getmyname (rpc_transport_t *this, char *hostname, int hostlen)
+socket_getmyname(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", hostname, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", hostname, out);
 
-        if (hostlen < (strlen (this->myinfo.identifier) + 1)) {
-                goto out;
-        }
+    if (hostlen < (strlen(this->myinfo.identifier) + 1)) {
+        goto out;
+    }
 
-        strcpy (hostname, this->myinfo.identifier);
-        ret = 0;
+    strcpy(hostname, this->myinfo.identifier);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getmyaddr (rpc_transport_t *this, char *myaddr, int addrlen,
-                  struct sockaddr_storage *sa, socklen_t salen)
+socket_getmyaddr(rpc_transport_t *this, char *myaddr, int addrlen,
+                 struct sockaddr_storage *sa, socklen_t salen)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", sa, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", sa, out);
 
-        *sa =  this->myinfo.sockaddr;
+    *sa = this->myinfo.sockaddr;
 
-        if (myaddr != NULL) {
-                ret = socket_getmyname (this, myaddr, addrlen);
-        }
+    if (myaddr != NULL) {
+        ret = socket_getmyname(this, myaddr, addrlen);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_throttle (rpc_transport_t *this, gf_boolean_t onoff)
+socket_throttle(rpc_transport_t *this, gf_boolean_t onoff)
 {
-        socket_private_t *priv = NULL;
-
-        priv = this->private;
-
-        /* The way we implement throttling is by taking off
-           POLLIN event from the polled flags. This way we
-           never get called with the POLLIN event and therefore
-           will never read() any more data until throttling
-           is turned off.
-        */
-        pthread_mutex_lock (&priv->lock);
-        {
-
-                /* Throttling is useless on a disconnected transport. In fact,
-                 * it's dangerous since priv->idx and priv->sock are set to -1
-                 * on a disconnected transport, which breaks epoll's event to
-                 * registered fd mapping. */
-
-                if (priv->connected == 1)
-                        priv->idx = event_select_on (this->ctx->event_pool,
-                                                     priv->sock,
-                                                     priv->idx, (int) !onoff,
-                                                     -1);
-        }
-        pthread_mutex_unlock (&priv->lock);
-        return 0;
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    /* The way we implement throttling is by taking off
+       POLLIN event from the polled flags. This way we
+       never get called with the POLLIN event and therefore
+       will never read() any more data until throttling
+       is turned off.
+    */
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        /* Throttling is useless on a disconnected transport. In fact,
+         * it's dangerous since priv->idx and priv->sock are set to -1
+         * on a disconnected transport, which breaks epoll's event to
+         * registered fd mapping. */
+
+        if (priv->connected == 1)
+            priv->idx = gf_event_select_on(this->ctx->event_pool, priv->sock,
+                                           priv->idx, (int)!onoff, -1);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    return 0;
 }
 
-
 struct rpc_transport_ops tops = {
-        .listen             = socket_listen,
-        .connect            = socket_connect,
-        .disconnect         = socket_disconnect,
-        .submit_request     = socket_submit_request,
-        .submit_reply       = socket_submit_reply,
-        .get_peername       = socket_getpeername,
-        .get_peeraddr       = socket_getpeeraddr,
-        .get_myname         = socket_getmyname,
-        .get_myaddr         = socket_getmyaddr,
-	.throttle           = socket_throttle,
+    .listen = socket_listen,
+    .connect = socket_connect,
+    .disconnect = socket_disconnect,
+    .submit_request = socket_submit_request,
+    .submit_reply = socket_submit_reply,
+    .get_peername = socket_getpeername,
+    .get_peeraddr = socket_getpeeraddr,
+    .get_myname = socket_getmyname,
+    .get_myaddr = socket_getmyaddr,
+    .throttle = socket_throttle,
 };
 
 int
-reconfigure (rpc_transport_t *this, dict_t *options)
+reconfigure(rpc_transport_t *this, dict_t *options)
 {
-        socket_private_t *priv          = NULL;
-        gf_boolean_t      tmp_bool      = _gf_false;
-        char             *optstr        = NULL;
-        int               ret           = 0;
-        uint32_t          backlog       = 0;
-        uint64_t          windowsize    = 0;
-        uint32_t          timeout       = 0;
-        int               keepaliveidle  = GF_KEEPALIVE_TIME;
-        int               keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        int               keepalivecnt   = GF_KEEPALIVE_COUNT;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        if (!this || !this->private) {
-                ret =-1;
-                goto out;
+    socket_private_t *priv = NULL;
+    gf_boolean_t tmp_bool = _gf_false;
+    char *optstr = NULL;
+    int ret = -1;
+    uint32_t backlog = 0;
+    uint64_t windowsize = 0;
+    data_t *data;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    if (dict_get_str_sizen(options, "transport.socket.keepalive", &optstr) ==
+        0) {
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.keepalive' takes only "
+                   "boolean options, not taking any action");
+            priv->keepalive = 1;
+            goto out;
         }
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.socket.keepalive");
 
-        priv = this->private;
-
-        if (dict_get_str (options, "transport.socket.keepalive",
-                          &optstr) == 0) {
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.keepalive' takes only "
-                                "boolean options, not taking any action");
-                        priv->keepalive = 1;
-                        ret = -1;
-                        goto out;
-                }
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigured transport.socket.keepalive");
+        priv->keepalive = tmp_bool;
+    } else
+        priv->keepalive = 1;
 
-                priv->keepalive = tmp_bool;
-        }
-        else
-                priv->keepalive = 1;
-
-        if (dict_get_int32 (options, "transport.tcp-user-timeout",
-                            &(priv->timeout)) != 0)
-                priv->timeout = timeout;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.tcp-user-timeout=%d", priv->timeout);
-
-        if (dict_get_uint32 (options, "transport.listen-backlog",
-                             &backlog) == 0) {
-                priv->backlog = backlog;
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                        "transport.listen-backlog=%d", priv->backlog);
-        }
+    if (dict_get_int32_sizen(options, "transport.tcp-user-timeout",
+                             &(priv->timeout)) != 0)
+        priv->timeout = GF_NETWORK_TIMEOUT;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigured transport.tcp-user-timeout=%d", priv->timeout);
 
-        if (dict_get_int32 (options, "transport.socket.keepalive-time",
-                            &(priv->keepaliveidle)) != 0)
-                priv->keepaliveidle = keepaliveidle;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-time=%d", priv->keepaliveidle);
-
-        if (dict_get_int32 (options,
-                            "transport.socket.keepalive-interval",
-                            &(priv->keepaliveintvl)) != 0)
-                priv->keepaliveintvl = keepaliveintvl;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-interval=%d", priv->keepaliveintvl);
-
-        if (dict_get_int32 (options, "transport.socket.keepalive-count",
-                            &(priv->keepalivecnt)) != 0)
-                priv->keepalivecnt = keepalivecnt;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-count=%d", priv->keepalivecnt);
-
-        optstr = NULL;
-        if (dict_get_str (options, "tcp-window-size",
-                          &optstr) == 0) {
-                if (gf_string2uint64 (optstr, &windowsize) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid number format: %s", optstr);
-                        goto out;
-                }
+    if (dict_get_uint32(options, "transport.listen-backlog", &backlog) == 0) {
+        priv->backlog = backlog;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.listen-backlog=%d", priv->backlog);
+    }
+
+    if (priv->keepalive) {
+        if (dict_get_int32_sizen(options, "transport.socket.keepalive-time",
+                                 &(priv->keepaliveidle)) != 0)
+            priv->keepaliveidle = GF_KEEPALIVE_TIME;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.socket.keepalive-time=%d",
+               priv->keepaliveidle);
+
+        if (dict_get_int32_sizen(options, "transport.socket.keepalive-interval",
+                                 &(priv->keepaliveintvl)) != 0)
+            priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.socket.keepalive-interval=%d",
+               priv->keepaliveintvl);
+
+        if (dict_get_int32_sizen(options, "transport.socket.keepalive-count",
+                                 &(priv->keepalivecnt)) != 0)
+            priv->keepalivecnt = GF_KEEPALIVE_COUNT;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.socket.keepalive-count=%d",
+               priv->keepalivecnt);
+    }
+
+    optstr = NULL;
+    if (dict_get_str_sizen(options, "tcp-window-size", &optstr) == 0) {
+        if (gf_string2uint64(optstr, &windowsize) != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s",
+                   optstr);
+            goto out;
         }
+    }
 
-        priv->windowsize = (int)windowsize;
+    priv->windowsize = (int)windowsize;
 
-        if (dict_get (options, "non-blocking-io")) {
-                optstr = data_to_str (dict_get (options,
-                                                "non-blocking-io"));
+    data = dict_get_sizen(options, "non-blocking-io");
+    if (data) {
+        optstr = data_to_str(data);
 
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'non-blocking-io' takes only boolean options,"
-                                " not taking any action");
-                        tmp_bool = 1;
-                }
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'non-blocking-io' takes only boolean options,"
+                   " not taking any action");
+            tmp_bool = 1;
+        }
 
-                if (!tmp_bool) {
-                        priv->bio = 1;
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "disabling non-blocking IO");
-                }
+        if (!tmp_bool) {
+            priv->bio = 1;
+            gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO");
         }
+    }
 
-        if (!priv->bio) {
-                ret = __socket_nonblock (priv->sock);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "NBIO on %d failed (%s)",
-                                priv->sock, strerror (errno));
-                        goto out;
-                }
+    if (!priv->bio) {
+        ret = __socket_nonblock(priv->sock);
+        if (ret != 0) {
+            gf_log(this->name, GF_LOG_WARNING, "NBIO on %d failed (%s)",
+                   priv->sock, strerror(errno));
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
-
+    return ret;
 }
 
-static pthread_mutex_t  *lock_array     = NULL;
+#if OPENSSL_VERSION_NUMBER < 0x1010000f
+static pthread_mutex_t *lock_array = NULL;
 
 static void
-locking_func (int mode, int type, const char *file, int line)
+locking_func(int mode, int type, const char *file, int line)
 {
-        if (mode & CRYPTO_UNLOCK) {
-                pthread_mutex_unlock (&lock_array[type]);
-        } else {
-                pthread_mutex_lock (&lock_array[type]);
-        }
+    if (mode & CRYPTO_UNLOCK) {
+        pthread_mutex_unlock(&lock_array[type]);
+    } else {
+        pthread_mutex_lock(&lock_array[type]);
+    }
 }
 
-#if HAVE_CRYPTO_THREADID
+#if OPENSSL_VERSION_NUMBER >= 0x1000000f
 static void
-threadid_func (CRYPTO_THREADID *id)
+threadid_func(CRYPTO_THREADID *id)
 {
-        /*
-         * We're not supposed to know whether a pthread_t is a number or a
-         * pointer, but we definitely need an unsigned long.  Even though it
-         * happens to be an unsigned long already on Linux, do the cast just in
-         * case that's not so on another platform.  Note that this can still
-         * break if any platforms are left where a pointer is larger than an
-         * unsigned long.  In that case there's not much we can do; hopefully
-         * anyone porting to such a platform will be aware enough to notice the
-         * compile warnings about truncating the pointer value.
-         */
-        CRYPTO_THREADID_set_numeric (id, (unsigned long)pthread_self());
+    /*
+     * We're not supposed to know whether a pthread_t is a number or a
+     * pointer, but we definitely need an unsigned long.  Even though it
+     * happens to be an unsigned long already on Linux, do the cast just in
+     * case that's not so on another platform.  Note that this can still
+     * break if any platforms are left where a pointer is larger than an
+     * unsigned long.  In that case there's not much we can do; hopefully
+     * anyone porting to such a platform will be aware enough to notice the
+     * compile warnings about truncating the pointer value.
+     */
+    CRYPTO_THREADID_set_numeric(id, (unsigned long)pthread_self());
 }
-#else /* older openssl */
+#else  /* older openssl */
 static unsigned long
-legacy_threadid_func (void)
+legacy_threadid_func(void)
 {
-	/* See comments above, it applies here too. */
-	return (unsigned long)pthread_self();
+    /* See comments above, it applies here too. */
+    return (unsigned long)pthread_self();
 }
-#endif
+#endif /* OPENSSL_VERSION_NUMBER >= 0x1000000f */
+#endif /* OPENSSL_VERSION_NUMBER < 0x1010000f */
 
 static void
-init_openssl_mt (void)
+init_openssl_mt(void)
 {
-        int     num_locks       = CRYPTO_num_locks();
-        int     i;
+    static gf_boolean_t initialized = _gf_false;
 
-        if (lock_array) {
-                /* this only needs to be initialized once GLOBALLY no
-                   matter how many translators/sockets we end up with. */
-                return;
-        }
+    if (initialized) {
+        /* this only needs to be initialized once GLOBALLY no
+           matter how many translators/sockets we end up with. */
+        return;
+    }
 
-        SSL_library_init();
-        SSL_load_error_strings();
+    SSL_library_init();
+    SSL_load_error_strings();
 
-        lock_array = GF_CALLOC (num_locks, sizeof(pthread_mutex_t),
-                                gf_sock_mt_lock_array);
-        if (lock_array) {
-                for (i = 0; i < num_locks; ++i) {
-                        pthread_mutex_init (&lock_array[i], NULL);
-                }
-#if HAVE_CRYPTO_THREADID
-                CRYPTO_THREADID_set_callback (threadid_func);
+    initialized = _gf_true;
+
+#if OPENSSL_VERSION_NUMBER < 0x1010000f
+    int num_locks = CRYPTO_num_locks();
+    int i;
+
+    lock_array = GF_CALLOC(num_locks, sizeof(pthread_mutex_t),
+                           gf_sock_mt_lock_array);
+    if (lock_array) {
+        for (i = 0; i < num_locks; ++i) {
+            pthread_mutex_init(&lock_array[i], NULL);
+        }
+#if OPENSSL_VERSION_NUMBER >= 0x1000000f
+        CRYPTO_THREADID_set_callback(threadid_func);
 #else /* older openssl */
-                CRYPTO_set_id_callback (legacy_threadid_func);
+        CRYPTO_set_id_callback(legacy_threadid_func);
+#endif
+        CRYPTO_set_locking_callback(locking_func);
+    }
 #endif
-                CRYPTO_set_locking_callback (locking_func);
-        }
-
 }
 
-static void __attribute__((destructor))
-fini_openssl_mt (void)
+static void __attribute__((destructor)) fini_openssl_mt(void)
 {
-        int i;
+#if OPENSSL_VERSION_NUMBER < 0x1010000f
+    int i;
 
-        if (!lock_array) {
-                return;
-        }
+    if (!lock_array) {
+        return;
+    }
 
-        CRYPTO_set_locking_callback(NULL);
-#if HAVE_CRYPTO_THREADID
-        CRYPTO_THREADID_set_callback (NULL);
+    CRYPTO_set_locking_callback(NULL);
+#if OPENSSL_VERSION_NUMBER >= 0x1000000f
+    CRYPTO_THREADID_set_callback(NULL);
 #else /* older openssl */
-        CRYPTO_set_id_callback (NULL);
+    CRYPTO_set_id_callback(NULL);
 #endif
 
-        for (i = 0; i < CRYPTO_num_locks(); ++i) {
-                pthread_mutex_destroy (&lock_array[i]);
-        }
+    for (i = 0; i < CRYPTO_num_locks(); ++i) {
+        pthread_mutex_destroy(&lock_array[i]);
+    }
 
-        GF_FREE (lock_array);
-        lock_array = NULL;
-
-        ERR_free_strings();
-}
-
-static void
-socket_poller_mayday (socket_private_t *priv)
-{
-        if (priv == NULL)
-                return;
+    GF_FREE(lock_array);
+    lock_array = NULL;
+#endif
 
-        pthread_mutex_lock (&priv->cond_lock);
-        {
-                /* Signal waiting threads before exiting from socket_poller */
-                if (!priv->own_thread_done) {
-                        gf_log ("socket", GF_LOG_TRACE, "priv->cond SIGNALED");
-                        pthread_cond_signal (&priv->cond);
-                        priv->own_thread_done = _gf_true;
-                }
-        }
-        pthread_mutex_unlock (&priv->cond_lock);
+    ERR_free_strings();
 }
 
+/* The function returns 0 if AES bit is enabled on the CPU */
 static int
-socket_init (rpc_transport_t *this)
+ssl_check_aes_bit(void)
 {
-        socket_private_t *priv = NULL;
-        gf_boolean_t      tmp_bool = 0;
-        uint64_t          windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
-        char             *optstr = NULL;
-        uint32_t          timeout = 0;
-        int               keepaliveidle  = GF_KEEPALIVE_TIME;
-        int               keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        int               keepalivecnt   = GF_KEEPALIVE_COUNT;
-        uint32_t          backlog = 0;
-	int               session_id = 0;
-        int32_t           cert_depth = DEFAULT_VERIFY_DEPTH;
-        char             *cipher_list = DEFAULT_CIPHER_LIST;
-        char             *dh_param = DEFAULT_DH_PARAM;
-        char             *ec_curve = DEFAULT_EC_CURVE;
-        char             *crl_path = NULL;
-
-        if (this->private) {
-                gf_log_callingfn (this->name, GF_LOG_ERROR,
-                                  "double init attempted");
-                return -1;
-        }
-
-        priv = GF_CALLOC (1, sizeof (*priv), gf_common_mt_socket_private_t);
-        if (!priv) {
-                return -1;
-        }
-        memset(priv,0,sizeof(*priv));
-
-        pthread_mutex_init (&priv->lock, NULL);
-        pthread_mutex_init (&priv->cond_lock, NULL);
-        pthread_cond_init (&priv->cond, NULL);
-
-        GF_REF_INIT (priv, socket_poller_mayday);
-
-        priv->sock = -1;
-        priv->idx = -1;
-        priv->connected = -1;
-        priv->nodelay = 1;
-        priv->bio = 0;
-        priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
-        INIT_LIST_HEAD (&priv->ioq);
-        pthread_mutex_init (&priv->notify.lock, NULL);
-        pthread_cond_init (&priv->notify.cond, NULL);
-
-        /* All the below section needs 'this->options' to be present */
-        if (!this->options)
-                goto out;
-
-        if (dict_get (this->options, "non-blocking-io")) {
-                optstr = data_to_str (dict_get (this->options,
-                                                "non-blocking-io"));
-
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'non-blocking-io' takes only boolean options,"
-                                " not taking any action");
-                        tmp_bool = 1;
-                }
-
-                if (!tmp_bool) {
-                        priv->bio = 1;
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "disabling non-blocking IO");
-                }
+    FILE *fp = fopen("/proc/cpuinfo", "r");
+    int ret = 1;
+    size_t len = 0;
+    char *line = NULL;
+    char *match = NULL;
+
+    GF_ASSERT(fp != NULL);
+
+    while (getline(&line, &len, fp) > 0) {
+        if (!strncmp(line, "flags", 5)) {
+            match = strstr(line, " aes");
+            if ((match != NULL) && ((match[4] == ' ') || (match[4] == 0))) {
+                ret = 0;
+                break;
+            }
         }
+    }
 
-        optstr = NULL;
+    free(line);
+    fclose(fp);
 
-        // By default, we enable NODELAY
-        if (dict_get (this->options, "transport.socket.nodelay")) {
-                optstr = data_to_str (dict_get (this->options,
-                                                "transport.socket.nodelay"));
+    return ret;
+}
 
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.nodelay' takes only "
-                                "boolean options, not taking any action");
-                        tmp_bool = 1;
-                }
-                if (!tmp_bool) {
-                        priv->nodelay = 0;
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "disabling nodelay");
-                }
-        }
+static int
+ssl_setup_connection_params(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    char *optstr = NULL;
+    static int session_id = 1;
+    int32_t cert_depth = DEFAULT_VERIFY_DEPTH;
+    char *cipher_list = DEFAULT_CIPHER_LIST;
+    char *dh_param = DEFAULT_DH_PARAM;
+    char *ec_curve = DEFAULT_EC_CURVE;
+    gf_boolean_t dh_flag = _gf_false;
+
+    priv = this->private;
+
+    if (priv->ssl_ctx != NULL) {
+        gf_log(this->name, GF_LOG_TRACE, "found old SSL context!");
+        return 0;
+    }
 
-        optstr = NULL;
-        if (dict_get_str (this->options, "tcp-window-size",
-                          &optstr) == 0) {
-                if (gf_string2uint64 (optstr, &windowsize) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid number format: %s", optstr);
-                        return -1;
-                }
+    if (!priv->ssl_enabled && !priv->mgmt_ssl) {
+        return 0;
+    }
+
+    if (!ssl_check_aes_bit()) {
+        cipher_list = "AES128:" DEFAULT_CIPHER_LIST;
+    }
+
+    priv->ssl_own_cert = DEFAULT_CERT_PATH;
+    if (dict_get_str_sizen(this->options, SSL_OWN_CERT_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_OWN_CERT_OPT,
+                   SSL_ENABLED_OPT);
         }
-
-        priv->windowsize = (int)windowsize;
-
-        optstr = NULL;
-        /* Enable Keep-alive by default. */
-        priv->keepalive = 1;
-        priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        priv->keepaliveidle = GF_KEEPALIVE_TIME;
-        priv->keepalivecnt = GF_KEEPALIVE_COUNT;
-        if (dict_get_str (this->options, "transport.socket.keepalive",
-                          &optstr) == 0) {
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.keepalive' takes only "
-                                "boolean options, not taking any action");
-                        tmp_bool = 1;
-                }
-
-                if (!tmp_bool)
-                        priv->keepalive = 0;
+        priv->ssl_own_cert = optstr;
+    }
+    priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert);
+
+    priv->ssl_private_key = DEFAULT_KEY_PATH;
+    if (dict_get_str_sizen(this->options, SSL_PRIVATE_KEY_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_PRIVATE_KEY_OPT,
+                   SSL_ENABLED_OPT);
         }
-
-        if (dict_get_int32 (this->options, "transport.tcp-user-timeout",
-                            &(priv->timeout)) != 0)
-                priv->timeout = timeout;
-        gf_log (this->name, GF_LOG_DEBUG, "Configued "
-                "transport.tcp-user-timeout=%d", priv->timeout);
-
-        if (dict_get_int32 (this->options,
-                            "transport.socket.keepalive-time",
-                            &(priv->keepaliveidle)) != 0) {
-                priv->keepaliveidle = keepaliveidle;
+        priv->ssl_private_key = optstr;
+    }
+    priv->ssl_private_key = gf_strdup(priv->ssl_private_key);
+
+    priv->ssl_ca_list = DEFAULT_CA_PATH;
+    if (dict_get_str_sizen(this->options, SSL_CA_LIST_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_CA_LIST_OPT,
+                   SSL_ENABLED_OPT);
         }
-
-        if (dict_get_int32 (this->options,
-                            "transport.socket.keepalive-interval",
-                            &(priv->keepaliveintvl)) != 0) {
-                priv->keepaliveintvl = keepaliveintvl;
+        priv->ssl_ca_list = optstr;
+    }
+    priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list);
+
+    optstr = NULL;
+    if (dict_get_str_sizen(this->options, SSL_CRL_PATH_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_CRL_PATH_OPT,
+                   SSL_ENABLED_OPT);
         }
+        if (strcasecmp(optstr, "NULL") == 0)
+            priv->crl_path = NULL;
+        else
+            priv->crl_path = gf_strdup(optstr);
+    }
 
-        if (dict_get_int32 (this->options, "transport.socket.keepalive-count",
-                            &(priv->keepalivecnt)) != 0)
-                priv->keepalivecnt = keepalivecnt;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.keepalivecnt=%d", keepalivecnt);
-
-        if (dict_get_uint32 (this->options,
-                             "transport.listen-backlog",
-                             &backlog) != 0) {
-
-                backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
-        }
-        priv->backlog = backlog;
-
-        optstr = NULL;
-
-         /* Check if socket read failures are to be logged */
-        priv->read_fail_log = 1;
-        if (dict_get (this->options, "transport.socket.read-fail-log")) {
-                optstr = data_to_str (dict_get (this->options, "transport.socket.read-fail-log"));
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                   "'transport.socket.read-fail-log' takes only "
-                                   "boolean options; logging socket read fails");
-                }
-                else if (tmp_bool == _gf_false) {
-                        priv->read_fail_log = 0;
-                }
+    if (!priv->mgmt_ssl) {
+        if (!dict_get_int32_sizen(this->options, SSL_CERT_DEPTH_OPT,
+                                  &cert_depth)) {
         }
-
-        priv->windowsize = (int)windowsize;
-
-        priv->ssl_enabled = _gf_false;
-	if (dict_get_str(this->options,SSL_ENABLED_OPT,&optstr) == 0) {
-                if (gf_string2boolean (optstr, &priv->ssl_enabled) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-				"invalid value given for ssl-enabled boolean");
-		}
-	}
-        priv->mgmt_ssl = this->ctx->secure_mgmt;
-        priv->srvr_ssl = this->ctx->secure_srvr;
-
-        priv->ssl_own_cert = DEFAULT_CERT_PATH;
-	if (dict_get_str(this->options,SSL_OWN_CERT_OPT,&optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name,GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_OWN_CERT_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_own_cert = optstr;
-	}
-        priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert);
-
-        priv->ssl_private_key = DEFAULT_KEY_PATH;
-	if (dict_get_str(this->options,SSL_PRIVATE_KEY_OPT,&optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name,GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_PRIVATE_KEY_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_private_key = optstr;
-	}
-        priv->ssl_private_key = gf_strdup(priv->ssl_private_key);
-
-        priv->ssl_ca_list = DEFAULT_CA_PATH;
-	if (dict_get_str(this->options,SSL_CA_LIST_OPT,&optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name,GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_CA_LIST_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_ca_list = optstr;
-	}
-        priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list);
-
-	if (dict_get_str(this->options,SSL_CRL_PATH_OPT,&optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name,GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_CRL_PATH_OPT, SSL_ENABLED_OPT);
-		}
-		if (strcasecmp(optstr, "NULL") == 0)
-			crl_path = NULL;
-		else
-			crl_path = optstr;
-	}
-
-        gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO: GF_LOG_DEBUG,
-               "SSL support on the I/O path is %s",
-               priv->ssl_enabled ? "ENABLED" : "NOT enabled");
-        gf_log(this->name, priv->mgmt_ssl ? GF_LOG_INFO: GF_LOG_DEBUG,
-               "SSL support for glusterd is %s",
-               priv->mgmt_ssl ? "ENABLED" : "NOT enabled");
-        /*
-         * This might get overridden temporarily in socket_connect (q.v.)
-         * if we're using the glusterd portmapper.
-         */
-        priv->use_ssl = priv->ssl_enabled;
-
-	priv->own_thread = priv->use_ssl;
-	if (dict_get_str(this->options,OWN_THREAD_OPT,&optstr) == 0) {
-                gf_log (this->name, GF_LOG_INFO, "OWN_THREAD_OPT found");
-                if (gf_string2boolean (optstr, &priv->own_thread) != 0) {
-                        gf_log (this->name, GF_LOG_WARNING,
-				"invalid value given for own-thread boolean");
-		}
-	}
-	gf_log(this->name, priv->own_thread ? GF_LOG_INFO: GF_LOG_DEBUG,
-               "using %s polling thread",
-	       priv->own_thread ? "private" : "system");
-
-        if (!dict_get_int32 (this->options, SSL_CERT_DEPTH_OPT, &cert_depth)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using certificate depth %d", cert_depth);
-        }
-        if (!dict_get_str (this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using cipher list %s", cipher_list);
-        }
-        if (!dict_get_str (this->options, SSL_DH_PARAM_OPT, &dh_param)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using DH parameters %s", dh_param);
-        }
-        if (!dict_get_str (this->options, SSL_EC_CURVE_OPT, &ec_curve)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using EC curve %s", ec_curve);
-        }
-
-	if (priv->ssl_enabled || priv->mgmt_ssl) {
-                BIO *bio = NULL;
+    } else {
+        cert_depth = this->ctx->ssl_cert_depth;
+    }
+    gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO : GF_LOG_DEBUG,
+           "SSL support for MGMT is %s IO path is %s certificate depth is %d "
+           "for peer %s",
+           (priv->mgmt_ssl ? "ENABLED" : "NOT enabled"),
+           (priv->ssl_enabled ? "ENABLED" : "NOT enabled"), cert_depth,
+           this->peerinfo.identifier);
+
+    if (!dict_get_str_sizen(this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) {
+        gf_log(this->name, GF_LOG_INFO, "using cipher list %s", cipher_list);
+    }
+    if (!dict_get_str_sizen(this->options, SSL_DH_PARAM_OPT, &dh_param)) {
+        dh_flag = _gf_true;
+        gf_log(this->name, GF_LOG_INFO, "using DH parameters %s", dh_param);
+    }
+    if (!dict_get_str_sizen(this->options, SSL_EC_CURVE_OPT, &ec_curve)) {
+        gf_log(this->name, GF_LOG_INFO, "using EC curve %s", ec_curve);
+    }
+
+    if (priv->ssl_enabled || priv->mgmt_ssl) {
+        BIO *bio = NULL;
 
 #if HAVE_TLS_METHOD
-		priv->ssl_meth = (SSL_METHOD *)TLS_method();
+        priv->ssl_meth = (SSL_METHOD *)TLS_method();
 #elif HAVE_TLSV1_2_METHOD
-		priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method();
+        priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method();
 #else
 /*
  * Nobody should use an OpenSSL so old it does not support TLS 1.2.
@@ -4356,355 +4309,493 @@ socket_init (rpc_transport_t *this)
 #ifndef USE_INSECURE_OPENSSL
 #error Old and insecure OpenSSL, use -DUSE_INSECURE_OPENSSL to use it anyway
 #endif
-		/* SSLv23_method uses highest available protocol */
-		priv->ssl_meth = (SSL_METHOD *)SSLv23_method();
+        /* SSLv23_method uses highest available protocol */
+        priv->ssl_meth = SSLv23_method();
 #endif
-		priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth);
+        priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth);
 
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2);
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3);
 #ifdef SSL_OP_NO_TICKET
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET);
 #endif
 #ifdef SSL_OP_NO_COMPRESSION
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION);
 #endif
+        /* Upload file to bio wrapper only if dh param is configured
+         */
+        if (dh_flag) {
+            if ((bio = BIO_new_file(dh_param, "r")) == NULL) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to open %s, "
+                       "DH ciphers are disabled",
+                       dh_param);
+            }
+        }
 
-		if ((bio = BIO_new_file(dh_param, "r")) == NULL) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "failed to open %s, "
-			       "DH ciphers are disabled", dh_param);
-		}
-
-		if (bio != NULL) {
+        if (bio != NULL) {
 #ifdef HAVE_OPENSSL_DH_H
-                        DH *dh;
-                        unsigned long err;
-
-                        dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
-                        BIO_free(bio);
-                        if (dh != NULL) {
-				SSL_CTX_set_options(priv->ssl_ctx,
-						    SSL_OP_SINGLE_DH_USE);
-				SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh);
-				DH_free(dh);
-                        } else {
-                                err = ERR_get_error();
-                                gf_log(this->name,GF_LOG_ERROR,
-                                       "failed to read DH param from %s: %s "
-                                       "DH ciphers are disabled.",
-                                       dh_param, ERR_error_string(err, NULL));
-                        }
-#else /* HAVE_OPENSSL_DH_H */
-                        BIO_free(bio);
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "OpenSSL has no DH support");
+            DH *dh;
+            unsigned long err;
+
+            dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
+            BIO_free(bio);
+            if (dh != NULL) {
+                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_DH_USE);
+                SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh);
+                DH_free(dh);
+            } else {
+                err = ERR_get_error();
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to read DH param from %s: %s "
+                       "DH ciphers are disabled.",
+                       dh_param, ERR_error_string(err, NULL));
+            }
+#else  /* HAVE_OPENSSL_DH_H */
+            BIO_free(bio);
+            gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no DH support");
 #endif /* HAVE_OPENSSL_DH_H */
-                }
+        }
 
-                if (ec_curve != NULL) {
+        if (ec_curve != NULL) {
 #ifdef HAVE_OPENSSL_ECDH_H
-                        EC_KEY *ecdh = NULL;
-                        int nid;
-                        unsigned long err;
-
-                        nid = OBJ_sn2nid(ec_curve);
-                        if (nid != 0)
-                                ecdh = EC_KEY_new_by_curve_name(nid);
-
-                        if (ecdh != NULL) {
-				SSL_CTX_set_options(priv->ssl_ctx,
-						    SSL_OP_SINGLE_ECDH_USE);
-				SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh);
-				EC_KEY_free(ecdh);
-                        } else {
-                                err = ERR_get_error();
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "failed to load EC curve %s: %s. "
-				       "ECDH ciphers are disabled.",
-                                       ec_curve, ERR_error_string(err, NULL));
-			}
-#else /* HAVE_OPENSSL_ECDH_H */
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "OpenSSL has no ECDH support");
+            EC_KEY *ecdh = NULL;
+            int nid;
+            unsigned long err;
+
+            nid = OBJ_sn2nid(ec_curve);
+            if (nid != 0)
+                ecdh = EC_KEY_new_by_curve_name(nid);
+
+            if (ecdh != NULL) {
+                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_ECDH_USE);
+                SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh);
+                EC_KEY_free(ecdh);
+            } else {
+                err = ERR_get_error();
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to load EC curve %s: %s. "
+                       "ECDH ciphers are disabled.",
+                       ec_curve, ERR_error_string(err, NULL));
+            }
+#else  /* HAVE_OPENSSL_ECDH_H */
+            gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no ECDH support");
 #endif /* HAVE_OPENSSL_ECDH_H */
-                }
+        }
 
-		/* This must be done after DH and ECDH setups */
-                if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) {
-                        gf_log(this->name,GF_LOG_ERROR,
-                               "failed to find any valid ciphers");
-                        goto err;
-                }
+        /* This must be done after DH and ECDH setups */
+        if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to find any valid ciphers");
+            goto err;
+        }
 
-		SSL_CTX_set_options(priv->ssl_ctx,
-                                    SSL_OP_CIPHER_SERVER_PREFERENCE);
-
-		if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx,
-							priv->ssl_own_cert)) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "could not load our cert");
-			goto err;
-		}
-
-		if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx,
-						 priv->ssl_private_key,
-						 SSL_FILETYPE_PEM)) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "could not load private key");
-			goto err;
-		}
-
-		if (!SSL_CTX_load_verify_locations(priv->ssl_ctx,
-						   priv->ssl_ca_list,
-						   crl_path)) {
-			gf_log(this->name,GF_LOG_ERROR,
-			       "could not load CA list");
-			goto err;
-		}
-
-#if (OPENSSL_VERSION_NUMBER < 0x00905100L)
-		SSL_CTX_set_verify_depth(ctx,cert_depth);
-#endif
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
 
-		if (crl_path) {
-#ifdef X509_V_FLAG_CRL_CHECK_ALL
-			X509_STORE *x509store;
+        if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx,
+                                                priv->ssl_own_cert)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load our cert at %s",
+                   priv->ssl_own_cert);
+            ssl_dump_error_stack(this->name);
+            goto err;
+        }
 
-			x509store  = SSL_CTX_get_cert_store(priv->ssl_ctx);
-			X509_STORE_set_flags(x509store,
-			    X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
-#else
-			gf_log(this->name,GF_LOG_ERROR,
-			       "OpenSSL version does not support CRL");
-#endif
-		}
+        if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx, priv->ssl_private_key,
+                                         SSL_FILETYPE_PEM)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load private key at %s",
+                   priv->ssl_private_key);
+            ssl_dump_error_stack(this->name);
+            goto err;
+        }
 
-		priv->ssl_session_id = ++session_id;
-		SSL_CTX_set_session_id_context(priv->ssl_ctx,
-					       (void *)&priv->ssl_session_id,
-					       sizeof(priv->ssl_session_id));
+        if (!SSL_CTX_load_verify_locations(priv->ssl_ctx, priv->ssl_ca_list,
+                                           priv->crl_path)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load CA list");
+            goto err;
+        }
 
-		SSL_CTX_set_verify(priv->ssl_ctx,SSL_VERIFY_PEER,0);
+        SSL_CTX_set_verify_depth(priv->ssl_ctx, cert_depth);
 
-                /*
-                 * Since glusterfs shares the same settings for client-side
-                 * and server-side of SSL, we need to ignore any certificate
-                 * usage specification (SSL client vs SSL server), otherwise
-                 * SSL connexions will fail with 'unsupported cerritifcate"
-                 */
-                SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY);
-	}
+        if (priv->crl_path)
+            ssl_set_crl_verify_flags(priv->ssl_ctx);
 
-        if (priv->own_thread) {
-                priv->ot_state = OT_IDLE;
-        }
+        priv->ssl_session_id = session_id++;
+        SSL_CTX_set_session_id_context(priv->ssl_ctx,
+                                       (void *)&priv->ssl_session_id,
+                                       sizeof(priv->ssl_session_id));
 
-out:
-        this->private = priv;
-        return 0;
+        SSL_CTX_set_verify(priv->ssl_ctx, SSL_VERIFY_PEER, 0);
+
+        /*
+         * Since glusterfs shares the same settings for client-side
+         * and server-side of SSL, we need to ignore any certificate
+         * usage specification (SSL client vs SSL server), otherwise
+         * SSL connexions will fail with 'unsupported cerritifcate"
+         */
+        SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY);
+    }
+    return 0;
 
 err:
-        if (priv->ssl_own_cert) {
-                GF_FREE(priv->ssl_own_cert);
+    return -1;
+}
+
+static int
+socket_init(rpc_transport_t *this)
+{
+    socket_private_t *priv = NULL;
+    gf_boolean_t tmp_bool = 0;
+    uint64_t windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
+    char *optstr = NULL;
+    data_t *data;
+
+    if (this->private) {
+        gf_log_callingfn(this->name, GF_LOG_ERROR, "double init attempted");
+        return -1;
+    }
+
+    priv = GF_CALLOC(1, sizeof(*priv), gf_common_mt_socket_private_t);
+    if (!priv) {
+        return -1;
+    }
+
+    this->private = priv;
+    pthread_mutex_init(&priv->out_lock, NULL);
+    pthread_mutex_init(&priv->cond_lock, NULL);
+    pthread_cond_init(&priv->cond, NULL);
+
+    /*GF_REF_INIT (priv, socket_poller_mayday);*/
+
+    priv->sock = -1;
+    priv->idx = -1;
+    priv->connected = -1;
+    priv->nodelay = 1;
+    priv->bio = 0;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_connected = _gf_false;
+    priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
+    INIT_LIST_HEAD(&priv->ioq);
+    pthread_mutex_init(&priv->notify.lock, NULL);
+    pthread_cond_init(&priv->notify.cond, NULL);
+
+    /* All the below section needs 'this->options' to be present */
+    if (!this->options)
+        goto out;
+
+    data = dict_get_sizen(this->options, "non-blocking-io");
+    if (data) {
+        optstr = data_to_str(data);
+
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'non-blocking-io' takes only boolean options,"
+                   " not taking any action");
+            tmp_bool = 1;
         }
-        if (priv->ssl_private_key) {
-                GF_FREE(priv->ssl_private_key);
+
+        if (!tmp_bool) {
+            priv->bio = 1;
+            gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO");
         }
-        if (priv->ssl_ca_list) {
-                GF_FREE(priv->ssl_ca_list);
+    }
+
+    optstr = NULL;
+
+    /* By default, we enable NODELAY */
+    data = dict_get_sizen(this->options, "transport.socket.nodelay");
+    if (data) {
+        optstr = data_to_str(data);
+
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.nodelay' takes only "
+                   "boolean options, not taking any action");
+            tmp_bool = 1;
+        }
+        if (!tmp_bool) {
+            priv->nodelay = 0;
+            gf_log(this->name, GF_LOG_DEBUG, "disabling nodelay");
+        }
+    }
+
+    optstr = NULL;
+    if (dict_get_str_sizen(this->options, "tcp-window-size", &optstr) == 0) {
+        if (gf_string2uint64(optstr, &windowsize) != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s",
+                   optstr);
+            return -1;
+        }
+    }
+
+    priv->windowsize = (int)windowsize;
+
+    optstr = NULL;
+    /* Enable Keep-alive by default. */
+    priv->keepalive = 1;
+    priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+    priv->keepaliveidle = GF_KEEPALIVE_TIME;
+    priv->keepalivecnt = GF_KEEPALIVE_COUNT;
+    if (dict_get_str_sizen(this->options, "transport.socket.keepalive",
+                           &optstr) == 0) {
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.keepalive' takes only "
+                   "boolean options, not taking any action");
+            tmp_bool = 1;
         }
-        GF_FREE(priv);
-        return -1;
-}
 
+        if (!tmp_bool)
+            priv->keepalive = 0;
+    }
+
+    if (dict_get_int32_sizen(this->options, "transport.tcp-user-timeout",
+                             &(priv->timeout)) != 0)
+        priv->timeout = GF_NETWORK_TIMEOUT;
+    gf_log(this->name, GF_LOG_DEBUG, "Configured transport.tcp-user-timeout=%d",
+           priv->timeout);
+
+    if (priv->keepalive) {
+        if (dict_get_int32_sizen(this->options,
+                                 "transport.socket.keepalive-time",
+                                 &(priv->keepaliveidle)) != 0) {
+            priv->keepaliveidle = GF_KEEPALIVE_TIME;
+        }
+
+        if (dict_get_int32_sizen(this->options,
+                                 "transport.socket.keepalive-interval",
+                                 &(priv->keepaliveintvl)) != 0) {
+            priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+        }
+
+        if (dict_get_int32_sizen(this->options,
+                                 "transport.socket.keepalive-count",
+                                 &(priv->keepalivecnt)) != 0)
+            priv->keepalivecnt = GF_KEEPALIVE_COUNT;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.keepalivecnt=%d", priv->keepalivecnt);
+    }
+
+    if (dict_get_uint32(this->options, "transport.listen-backlog",
+                        &(priv->backlog)) != 0) {
+        priv->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
+    }
+
+    optstr = NULL;
+
+    /* Check if socket read failures are to be logged */
+    priv->read_fail_log = 1;
+    data = dict_get_sizen(this->options, "transport.socket.read-fail-log");
+    if (data) {
+        optstr = data_to_str(data);
+        if (gf_string2boolean(optstr, &tmp_bool) != 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "'transport.socket.read-fail-log' takes only "
+                   "boolean options; logging socket read fails");
+        } else if (tmp_bool == _gf_false) {
+            priv->read_fail_log = 0;
+        }
+    }
+
+    priv->windowsize = (int)windowsize;
+
+    priv->ssl_enabled = _gf_false;
+    if (dict_get_str_sizen(this->options, SSL_ENABLED_OPT, &optstr) == 0) {
+        if (gf_string2boolean(optstr, &priv->ssl_enabled) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "invalid value given for ssl-enabled boolean");
+        }
+    }
+    priv->mgmt_ssl = this->ctx->secure_mgmt;
+    priv->srvr_ssl = this->ctx->secure_srvr;
+
+    ssl_setup_connection_params(this);
+out:
+    this->private = priv;
+    return 0;
+}
 
 void
-fini (rpc_transport_t *this)
+fini(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-
-        if (!this)
-                return;
-
-        priv = this->private;
-        if (priv) {
-                if (priv->sock != -1) {
-                        pthread_mutex_lock (&priv->lock);
-                        {
-                                __socket_ioq_flush (this);
-                                __socket_reset (this);
-                        }
-                        pthread_mutex_unlock (&priv->lock);
-                }
-                gf_log (this->name, GF_LOG_TRACE,
-                        "transport %p destroyed", this);
-
-                pthread_mutex_destroy (&priv->lock);
-                pthread_mutex_destroy (&priv->cond_lock);
-                pthread_cond_destroy (&priv->cond);
-		if (priv->ssl_private_key) {
-			GF_FREE(priv->ssl_private_key);
-		}
-		if (priv->ssl_own_cert) {
-			GF_FREE(priv->ssl_own_cert);
-		}
-		if (priv->ssl_ca_list) {
-			GF_FREE(priv->ssl_ca_list);
-		}
-                GF_FREE (priv);
+    socket_private_t *priv = NULL;
+
+    if (!this)
+        return;
+
+    priv = this->private;
+    if (priv) {
+        if (priv->sock >= 0) {
+            pthread_mutex_lock(&priv->out_lock);
+            {
+                __socket_ioq_flush(priv);
+                __socket_reset(this);
+            }
+            pthread_mutex_unlock(&priv->out_lock);
         }
+        gf_log(this->name, GF_LOG_TRACE, "transport %p destroyed", this);
+
+        pthread_mutex_destroy(&priv->out_lock);
+        pthread_mutex_destroy(&priv->cond_lock);
+        pthread_cond_destroy(&priv->cond);
 
-        this->private = NULL;
+        GF_ASSERT(priv->notify.in_progress == 0);
+        pthread_mutex_destroy(&priv->notify.lock);
+        pthread_cond_destroy(&priv->notify.cond);
+
+        if (priv->use_ssl && priv->ssl_ssl) {
+            SSL_clear(priv->ssl_ssl);
+            SSL_free(priv->ssl_ssl);
+            priv->ssl_ssl = NULL;
+        }
+        if (priv->ssl_ctx) {
+            SSL_CTX_free(priv->ssl_ctx);
+            priv->ssl_ctx = NULL;
+        }
+
+        if (priv->ssl_private_key) {
+            GF_FREE(priv->ssl_private_key);
+        }
+        if (priv->ssl_own_cert) {
+            GF_FREE(priv->ssl_own_cert);
+        }
+        if (priv->ssl_ca_list) {
+            GF_FREE(priv->ssl_ca_list);
+        }
+        GF_FREE(priv);
+    }
+
+    this->private = NULL;
 }
 
 int32_t
-init (rpc_transport_t *this)
+init(rpc_transport_t *this)
 {
-        int ret = -1;
+    int ret = -1;
 
-        init_openssl_mt();
+    init_openssl_mt();
 
-        ret = socket_init (this);
+    ret = socket_init(this);
 
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "socket_init() failed");
-        }
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_DEBUG, "socket_init() failed");
+    }
 
-        return ret;
+    return ret;
 }
 
 struct volume_options options[] = {
-        { .key   = {"remote-port",
-                    "transport.remote-port",
-                    "transport.socket.remote-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.socket.listen-port", "listen-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.socket.bind-address", "bind-address" },
-          .type  = GF_OPTION_TYPE_INTERNET_ADDRESS
-        },
-        { .key   = {"transport.socket.connect-path", "connect-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.socket.bind-path", "bind-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.socket.listen-path", "listen-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = { "transport.address-family",
-                     "address-family" },
-          .value = {"inet", "inet6", "unix", "inet-sdp" },
-          .type  = GF_OPTION_TYPE_STR
-        },
-
-        { .key   = {"non-blocking-io"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {"tcp-window-size"},
-          .type  = GF_OPTION_TYPE_SIZET,
-          .min   = GF_MIN_SOCKET_WINDOW_SIZE,
-          .max   = GF_MAX_SOCKET_WINDOW_SIZE
-        },
-        { .key   = {"transport.tcp-user-timeout"},
-          .type  = GF_OPTION_TYPE_INT,
-          .default_value = "0"
-        },
-        { .key   = {"transport.socket.nodelay"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "1"
-        },
-        { .key   = {"transport.socket.lowlat"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {"transport.socket.keepalive"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "1"
-        },
-        { .key   = {"transport.socket.keepalive-interval"},
-          .type  = GF_OPTION_TYPE_INT,
-          .default_value = "2"
-        },
-        { .key   = {"transport.socket.keepalive-time"},
-          .type  = GF_OPTION_TYPE_INT,
-          .default_value = "20"
-        },
-        { .key   = {"transport.socket.keepalive-count"},
-          .type  = GF_OPTION_TYPE_INT,
-          .default_value = "9"
-        },
-        { .key   = {"transport.socket.read-fail-log"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {SSL_ENABLED_OPT},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-	{ .key   = {SSL_OWN_CERT_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_PRIVATE_KEY_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_CA_LIST_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_CERT_DEPTH_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_CIPHER_LIST_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_DH_PARAM_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_EC_CURVE_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {SSL_CRL_PATH_OPT},
-	  .type  = GF_OPTION_TYPE_STR
-	},
-	{ .key   = {OWN_THREAD_OPT},
-	  .type  = GF_OPTION_TYPE_BOOL
-	},
-        { .key   = {"ssl-own-cert"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL certificate. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-private-key"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL private key. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-ca-list"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL CA list. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-cert-depth"},
-          .type  = GF_OPTION_TYPE_INT,
-          .description = "Maximum certificate-chain depth.  If zero, the "
-                         "peer's certificate itself must be in the local "
-                         "certificate list.  Otherwise, there may be up to N "
-                         "signing certificates between the peer's and the "
-                         "local list.  Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-cipher-list"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "Allowed SSL ciphers. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-dh-param"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "DH parameters file. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-ec-curve"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "ECDH curve name. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-crl-path"},
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "Path to directory containing CRL. "
-                         "Ignored if SSL is not enabled."
-        },
-        { .key = {NULL} }
-};
+    {.key = {"remote-port", "transport.remote-port",
+             "transport.socket.remote-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.socket.listen-port", "listen-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.socket.bind-address", "bind-address"},
+     .type = GF_OPTION_TYPE_INTERNET_ADDRESS},
+    {.key = {"transport.socket.connect-path", "connect-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.socket.bind-path", "bind-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.socket.listen-path", "listen-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.address-family", "address-family"},
+     .value = {"inet", "inet6", "unix", "inet-sdp"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .type = GF_OPTION_TYPE_STR},
+    {.key = {"non-blocking-io"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"tcp-window-size"},
+     .type = GF_OPTION_TYPE_SIZET,
+     .op_version = {1},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Option to set TCP SEND/RECV BUFFER SIZE",
+     .min = GF_MIN_SOCKET_WINDOW_SIZE,
+     .max = GF_MAX_SOCKET_WINDOW_SIZE},
+    {
+        .key = {"transport.listen-backlog"},
+        .type = GF_OPTION_TYPE_SIZET,
+        .op_version = {GD_OP_VERSION_3_11_1},
+        .flags = OPT_FLAG_SETTABLE,
+        .description = "This option uses the value of backlog argument that "
+                       "defines the maximum length to which the queue of "
+                       "pending connections for socket fd may grow.",
+        .default_value = "1024",
+    },
+    {.key = {"transport.tcp-user-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = TOSTRING(GF_NETWORK_TIMEOUT)},
+    {.key = {"transport.socket.nodelay"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "1"},
+    {.key = {"transport.socket.keepalive"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .op_version = {1},
+     .default_value = "1"},
+    {.key = {"transport.socket.keepalive-interval"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "2"},
+    {.key = {"transport.socket.keepalive-time"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "20"},
+    {.key = {"transport.socket.keepalive-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "9"},
+    {.key = {"transport.socket.read-fail-log"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {SSL_ENABLED_OPT}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {SSL_OWN_CERT_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_PRIVATE_KEY_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CA_LIST_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CERT_DEPTH_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CIPHER_LIST_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_DH_PARAM_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_EC_CURVE_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CRL_PATH_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {OWN_THREAD_OPT}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"ssl-own-cert"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL certificate. Ignored if SSL is not enabled."},
+    {.key = {"ssl-private-key"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL private key. Ignored if SSL is not enabled."},
+    {.key = {"ssl-ca-list"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL CA list. Ignored if SSL is not enabled."},
+    {.key = {"ssl-cert-depth"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_6_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Maximum certificate-chain depth.  If zero, the "
+                    "peer's certificate itself must be in the local "
+                    "certificate list.  Otherwise, there may be up to N "
+                    "signing certificates between the peer's and the "
+                    "local list.  Ignored if SSL is not enabled."},
+    {.key = {"ssl-cipher-list"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_6_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Allowed SSL ciphers. Ignored if SSL is not enabled."},
+    {.key = {"ssl-dh-param"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "DH parameters file. Ignored if SSL is not enabled."},
+    {.key = {"ssl-ec-curve"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "ECDH curve name. Ignored if SSL is not enabled."},
+    {.key = {"ssl-crl-path"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Path to directory containing CRL. "
+                    "Ignored if SSL is not enabled."},
+    {.key = {NULL}}};
diff --git a/rpc/rpc-transport/socket/src/socket.h b/rpc/rpc-transport/socket/src/socket.h
index e299a3d7bd5..8a2eda70605 100644
--- a/rpc/rpc-transport/socket/src/socket.h
+++ b/rpc/rpc-transport/socket/src/socket.h
@@ -14,6 +14,7 @@
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 #include <openssl/x509v3.h>
+#include <openssl/x509_vfy.h>
 #ifdef HAVE_OPENSSL_DH_H
 #include <openssl/dh.h>
 #endif
@@ -21,19 +22,13 @@
 #include <openssl/ecdh.h>
 #endif
 
-#include "event.h"
 #include "rpc-transport.h"
-#include "logging.h"
-#include "dict.h"
-#include "mem-pool.h"
-#include "globals.h"
-#include "refcount.h"
 
 #ifndef MAX_IOVEC
 #define MAX_IOVEC 16
 #endif /* MAX_IOVEC */
 
-#define GF_DEFAULT_SOCKET_LISTEN_PORT  GF_DEFAULT_BASE_PORT
+#define GF_DEFAULT_SOCKET_LISTEN_PORT GF_DEFAULT_BASE_PORT
 
 #define RPC_MAX_FRAGMENT_SIZE 0x7fffffff
 
@@ -45,222 +40,237 @@
  * setsockopt will fail. Having larger values might be beneficial for
  * IB links.
  */
-#define GF_DEFAULT_SOCKET_WINDOW_SIZE   (0)
-#define GF_MAX_SOCKET_WINDOW_SIZE       (1 * GF_UNIT_MB)
-#define GF_MIN_SOCKET_WINDOW_SIZE       (0)
-#define GF_USE_DEFAULT_KEEPALIVE        (-1)
+#define GF_DEFAULT_SOCKET_WINDOW_SIZE (0)
+#define GF_MAX_SOCKET_WINDOW_SIZE (1 * GF_UNIT_MB)
+#define GF_MIN_SOCKET_WINDOW_SIZE (0)
+#define GF_USE_DEFAULT_KEEPALIVE (-1)
 
-#define GF_KEEPALIVE_TIME               (20)
-#define GF_KEEPALIVE_INTERVAL           (2)
-#define GF_KEEPALIVE_COUNT              (9)
+#define GF_KEEPALIVE_TIME (20)
+#define GF_KEEPALIVE_INTERVAL (2)
+#define GF_KEEPALIVE_COUNT (9)
 
 typedef enum {
-        SP_STATE_NADA = 0,
-        SP_STATE_COMPLETE,
-        SP_STATE_READING_FRAGHDR,
-        SP_STATE_READ_FRAGHDR,
-        SP_STATE_READING_FRAG,
+    SP_STATE_NADA = 0,
+    SP_STATE_COMPLETE,
+    SP_STATE_READING_FRAGHDR,
+    SP_STATE_READ_FRAGHDR,
+    SP_STATE_READING_FRAG,
 } sp_rpcrecord_state_t;
 
 typedef enum {
-        SP_STATE_RPCFRAG_INIT,
-        SP_STATE_READING_MSGTYPE,
-        SP_STATE_READ_MSGTYPE,
-        SP_STATE_NOTIFYING_XID
+    SP_STATE_RPCFRAG_INIT,
+    SP_STATE_READING_MSGTYPE,
+    SP_STATE_READ_MSGTYPE,
+    SP_STATE_NOTIFYING_XID
 } sp_rpcfrag_state_t;
 
 typedef enum {
-        SP_STATE_SIMPLE_MSG_INIT,
-        SP_STATE_READING_SIMPLE_MSG,
+    SP_STATE_SIMPLE_MSG_INIT,
+    SP_STATE_READING_SIMPLE_MSG,
 } sp_rpcfrag_simple_msg_state_t;
 
 typedef enum {
-        SP_STATE_VECTORED_REQUEST_INIT,
-        SP_STATE_READING_CREDBYTES,
-        SP_STATE_READ_CREDBYTES,        /* read credential data. */
-        SP_STATE_READING_VERFBYTES,
-        SP_STATE_READ_VERFBYTES,        /* read verifier data */
-        SP_STATE_READING_PROGHDR,
-        SP_STATE_READ_PROGHDR,
-        SP_STATE_READING_PROGHDR_XDATA,
-        SP_STATE_READ_PROGHDR_XDATA,    /* It's a bad "name" in the generic
-					   RPC state machine, but greatly
-					   aids code review (and xdata is
-					   the only "consumer" of this state)
-					*/
-        SP_STATE_READING_PROG,
+    SP_STATE_VECTORED_REQUEST_INIT,
+    SP_STATE_READING_CREDBYTES,
+    SP_STATE_READ_CREDBYTES, /* read credential data. */
+    SP_STATE_READING_VERFBYTES,
+    SP_STATE_READ_VERFBYTES, /* read verifier data */
+    SP_STATE_READING_PROGHDR,
+    SP_STATE_READ_PROGHDR,
+    SP_STATE_READING_PROGHDR_XDATA,
+    SP_STATE_READ_PROGHDR_XDATA, /* It's a bad "name" in the generic
+                                    RPC state machine, but greatly
+                                    aids code review (and xdata is
+                                    the only "consumer" of this state)
+                                 */
+    SP_STATE_READING_PROG,
 } sp_rpcfrag_vectored_request_state_t;
 
 typedef enum {
-        SP_STATE_REQUEST_HEADER_INIT,
-        SP_STATE_READING_RPCHDR1,
-        SP_STATE_READ_RPCHDR1,     /* read msg from beginning till and
-                                    * including credlen
-                                    */
+    SP_STATE_REQUEST_HEADER_INIT,
+    SP_STATE_READING_RPCHDR1,
+    SP_STATE_READ_RPCHDR1, /* read msg from beginning till and
+                            * including credlen
+                            */
 } sp_rpcfrag_request_header_state_t;
 
 struct ioq {
-        union {
-                struct list_head list;
-                struct {
-                        struct ioq    *next;
-                        struct ioq    *prev;
-                };
+    union {
+        struct list_head list;
+        struct {
+            struct ioq *next;
+            struct ioq *prev;
         };
+    };
 
-        uint32_t           fraghdr;
-        struct iovec       vector[MAX_IOVEC];
-        int                count;
-        struct iovec      *pending_vector;
-        int                pending_count;
-        struct iobref     *iobref;
+    struct iovec vector[MAX_IOVEC];
+    struct iovec *pending_vector;
+    int count;
+    int pending_count;
+    struct iobref *iobref;
+    uint32_t fraghdr;
+    char _pad[4];
 };
 
 typedef struct {
-        sp_rpcfrag_request_header_state_t header_state;
-        sp_rpcfrag_vectored_request_state_t vector_state;
-        int vector_sizer_state;
+    sp_rpcfrag_request_header_state_t header_state;
+    sp_rpcfrag_vectored_request_state_t vector_state;
+    int vector_sizer_state;
 } sp_rpcfrag_request_state_t;
 
 typedef enum {
-        SP_STATE_VECTORED_REPLY_STATUS_INIT,
-        SP_STATE_READING_REPLY_STATUS,
-        SP_STATE_READ_REPLY_STATUS,
+    SP_STATE_VECTORED_REPLY_STATUS_INIT,
+    SP_STATE_READING_REPLY_STATUS,
+    SP_STATE_READ_REPLY_STATUS,
 } sp_rpcfrag_vectored_reply_status_state_t;
 
 typedef enum {
-        SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT,
-        SP_STATE_READING_PROC_HEADER,
-        SP_STATE_READING_PROC_OPAQUE,
-        SP_STATE_READ_PROC_OPAQUE,
-        SP_STATE_READ_PROC_HEADER,
+    SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT,
+    SP_STATE_READING_PROC_HEADER,
+    SP_STATE_READING_PROC_OPAQUE,
+    SP_STATE_READ_PROC_OPAQUE,
+    SP_STATE_READ_PROC_HEADER,
 } sp_rpcfrag_vectored_reply_accepted_success_state_t;
 
 typedef enum {
-        SP_STATE_ACCEPTED_REPLY_INIT,
-        SP_STATE_READING_REPLY_VERFLEN,
-        SP_STATE_READ_REPLY_VERFLEN,
-        SP_STATE_READING_REPLY_VERFBYTES,
-        SP_STATE_READ_REPLY_VERFBYTES,
+    SP_STATE_ACCEPTED_REPLY_INIT,
+    SP_STATE_READING_REPLY_VERFLEN,
+    SP_STATE_READ_REPLY_VERFLEN,
+    SP_STATE_READING_REPLY_VERFBYTES,
+    SP_STATE_READ_REPLY_VERFBYTES,
 } sp_rpcfrag_vectored_reply_accepted_state_t;
 
 typedef struct {
-        uint32_t accept_status;
-        sp_rpcfrag_vectored_reply_status_state_t status_state;
-        sp_rpcfrag_vectored_reply_accepted_state_t accepted_state;
-        sp_rpcfrag_vectored_reply_accepted_success_state_t accepted_success_state;
+    uint32_t accept_status;
+    sp_rpcfrag_vectored_reply_status_state_t status_state;
+    sp_rpcfrag_vectored_reply_accepted_state_t accepted_state;
+    sp_rpcfrag_vectored_reply_accepted_success_state_t accepted_success_state;
 } sp_rpcfrag_vectored_reply_state_t;
 
 struct gf_sock_incoming_frag {
-        char         *fragcurrent;
-        uint32_t      bytes_read;
-        uint32_t      remaining_size;
-        struct iovec  vector;
-        struct iovec *pending_vector;
-        union {
-                sp_rpcfrag_request_state_t        request;
-                sp_rpcfrag_vectored_reply_state_t reply;
-        } call_body;
+    char *fragcurrent;
+    uint32_t bytes_read;
+    uint32_t remaining_size;
+    struct iovec vector;
+    struct iovec *pending_vector;
+    union {
+        sp_rpcfrag_request_state_t request;
+        sp_rpcfrag_vectored_reply_state_t reply;
+    } call_body;
 
-        sp_rpcfrag_simple_msg_state_t     simple_state;
-        sp_rpcfrag_state_t state;
+    sp_rpcfrag_simple_msg_state_t simple_state;
+    sp_rpcfrag_state_t state;
 };
 
 #define GF_SOCKET_RA_MAX 1024
 
 struct gf_sock_incoming {
-        sp_rpcrecord_state_t  record_state;
-        struct gf_sock_incoming_frag frag;
-        char                *proghdr_base_addr;
-        struct iobuf        *iobuf;
-        size_t               iobuf_size;
-        struct iovec         vector[2];
-        int                  count;
-        struct iovec         payload_vector;
-        struct iobref       *iobref;
-        rpc_request_info_t  *request_info;
-        struct iovec        *pending_vector;
-        int                  pending_count;
-        uint32_t             fraghdr;
-        char                 complete_record;
-        msg_type_t           msg_type;
-        size_t               total_bytes_read;
+    char *proghdr_base_addr;
+    struct iobuf *iobuf;
+    size_t iobuf_size;
+    struct gf_sock_incoming_frag frag;
+    struct iovec vector[2];
+    struct iovec payload_vector;
+    struct iobref *iobref;
+    rpc_request_info_t *request_info;
+    struct iovec *pending_vector;
+    int count;
+    int pending_count;
+    size_t total_bytes_read;
 
-	size_t               ra_read;
-	size_t               ra_max;
-	size_t               ra_served;
-	char                *ra_buf;
+    size_t ra_read;
+    size_t ra_max;
+    size_t ra_served;
+    char *ra_buf;
+    uint32_t fraghdr;
+    msg_type_t msg_type;
+    sp_rpcrecord_state_t record_state;
+    char _pad[4];
 };
 
-typedef enum {
-        OT_IDLE,        /* Uninitialized or termination complete. */
-        OT_SPAWNING,    /* Past pthread_create but not in thread yet. */
-        OT_RUNNING,     /* Poller thread running normally. */
-        OT_CALLBACK,    /* Poller thread in the middle of a callback. */
-        OT_PLEASE_DIE,  /* Poller termination requested. */
-} ot_state_t;
-
 typedef struct {
-        int32_t                sock;
-        int32_t                idx;
-        int32_t                gen;
-        /* -1 = not connected. 0 = in progress. 1 = connected */
-        char                   connected;
-        /* 1 = connect failed for reasons other than EINPROGRESS/ENOENT
-        see socket_connect for details */
-        char                   connect_failed;
-        char                   bio;
-        char                   connect_finish_log;
-        char                   submit_log;
-        union {
-                struct list_head     ioq;
-                struct {
-                        struct ioq        *ioq_next;
-                        struct ioq        *ioq_prev;
-                };
-        };
-        struct gf_sock_incoming incoming;
-        pthread_mutex_t        lock;
-        pthread_mutex_t        cond_lock;
-        pthread_cond_t         cond;
-        int                    windowsize;
-        char                   lowlat;
-        char                   nodelay;
-        int                    keepalive;
-        int                    keepaliveidle;
-        int                    keepaliveintvl;
-        int                    keepalivecnt;
-        int                    timeout;
-        uint32_t               backlog;
-        gf_boolean_t           read_fail_log;
-        gf_boolean_t           ssl_enabled;     /* outbound I/O */
-        gf_boolean_t           mgmt_ssl;        /* outbound mgmt */
-        mgmt_ssl_t             srvr_ssl;
-	gf_boolean_t           use_ssl;
-	SSL_METHOD            *ssl_meth;
-	SSL_CTX               *ssl_ctx;
-	int                    ssl_session_id;
-	BIO                   *ssl_sbio;
-	SSL                   *ssl_ssl;
-	char                  *ssl_own_cert;
-	char                  *ssl_private_key;
-	char                  *ssl_ca_list;
-	pthread_t              thread;
-	int                    pipe[2];
-	gf_boolean_t           own_thread;
-        gf_boolean_t           own_thread_done;
-        ot_state_t             ot_state;
-        uint32_t               ot_gen;
-        gf_boolean_t           is_server;
-        int                    log_ctr;
-        GF_REF_DECL;           /* refcount to keep track of socket_poller
-                                  threads */
+    union {
+        struct list_head ioq;
         struct {
-                pthread_mutex_t  lock;
-                pthread_cond_t   cond;
-                uint64_t         in_progress;
-        } notify;
-} socket_private_t;
+            struct ioq *ioq_next;
+            struct ioq *ioq_prev;
+        };
+    };
+    pthread_mutex_t out_lock;
+    pthread_mutex_t cond_lock;
+    pthread_cond_t cond;
+    int windowsize;
+    int keepalive;
+    int keepaliveidle;
+    int keepaliveintvl;
+    int keepalivecnt;
+    int timeout;
+    int log_ctr;
+    int shutdown_log_ctr;
+    /* ssl_error_required is used only during the SSL connection setup
+     * phase.
+     * It holds the error code returned by SSL_get_error() and is used to
+     * arm the epoll event set for the required event for the specific fd.
+     */
+    int ssl_error_required;
+    int ssl_session_id;
 
+    GF_REF_DECL; /* refcount to keep track of socket_poller
+                    threads */
+    struct {
+        pthread_mutex_t lock;
+        pthread_cond_t cond;
+        uint64_t in_progress;
+    } notify;
+    int32_t sock;
+    int32_t idx;
+    int32_t gen;
+    uint32_t backlog;
+    SSL_METHOD *ssl_meth;
+    SSL_CTX *ssl_ctx;
+    BIO *ssl_sbio;
+    SSL *ssl_ssl;
+    char *ssl_own_cert;
+    char *ssl_private_key;
+    char *ssl_ca_list;
+    char *crl_path;
+    struct gf_sock_incoming incoming;
+    mgmt_ssl_t srvr_ssl;
+    /* -1 = not connected. 0 = in progress. 1 = connected */
+    char connected;
+    /* 1 = connect failed for reasons other than EINPROGRESS/ENOENT
+    see socket_connect for details */
+    char connect_failed;
+    char bio;
+    char connect_finish_log;
+    char submit_log;
+    char nodelay;
+    gf_boolean_t read_fail_log;
+    gf_boolean_t ssl_enabled; /* outbound I/O */
+    gf_boolean_t mgmt_ssl;    /* outbound mgmt */
+    gf_boolean_t is_server;
+    gf_boolean_t use_ssl;
+    gf_boolean_t ssl_accepted;  /* To indicate SSL_accept() */
+    gf_boolean_t ssl_connected; /* or SSL_connect() has been
+                                 * been completed on this socket.
+                                 * These are valid only when
+                                 * use_ssl is true.
+                                 */
+    /* SSL_CTX is created for each transport. Since we are now using non-
+     * blocking mechanism for SSL_accept() and SSL_connect(), the SSL
+     * context is created on the first EPOLLIN event which may lead to
+     * SSL_ERROR_WANT_READ/SSL_ERROR_WANT_WRITE and may not complete the
+     * SSL connection at the first attempt.
+     * ssl_context_created is a flag to note that we've created the SSL
+     * context for the connection so that we don't blindly create any more
+     * while !ssl_accepted or !ssl_connected.
+     */
+    gf_boolean_t ssl_context_created;
+    gf_boolean_t accepted; /* explicit flag to be set in
+                            * socket_event_handler() for
+                            * newly accepted socket
+                            */
+    char _pad[4];
+} socket_private_t;
 
 #endif
diff --git a/rpc/xdr/gen/Makefile.am b/rpc/xdr/gen/Makefile.am
deleted file mode 100644
index b1c8e9333d6..00000000000
--- a/rpc/xdr/gen/Makefile.am
+++ /dev/null
@@ -1,49 +0,0 @@
-XDRGENFILES = glusterfs3-xdr.x cli1-xdr.x nlm4-xdr.x nsm-xdr.x \
-	rpc-common-xdr.x glusterd1-xdr.x acl3-xdr.x portmap-xdr.x \
-	mount3udp.x changelog-xdr.x glusterfs-fops.x
-XDRHEADERS = $(XDRGENFILES:.x=.h)
-XDRSOURCES = $(XDRGENFILES:.x=.c)
-
-CLEANFILES = $(XDRSOURCES) $(XDRHEADERS) $(XDRGENFILES)
-
-# trick automake into doing BUILT_SOURCES magic
-BUILT_SOURCES = $(XDRHEADERS) $(XDRSOURCES)
-
-xdrsrc=$(top_srcdir)/rpc/xdr/src
-xdrdst=$(top_builddir)/rpc/xdr/src
-
-# make's dependency resolution may mean that it decides to run
-# rpcgen again (unnecessarily), but as the .c file already exists,
-# rpcgen will exit with an error, resulting in a build error. We
-# could use a '-' (i.e. -@rpcgen ...) and suffer with noisy warnings
-# in the build. Or we do this crufty thing instead.
-$(XDRSOURCES): $(XDRGENFILES)
-	if [ ! -e $(xdrdst)/$@ -o $(@:.c=.x) -nt $(xdrdst)/$@ ]; then \
-		rpcgen -c -o $(xdrdst)/$@ $(@:.c=.x) ;\
-	fi
-
-# d*mn sed in netbsd6 doesn't do -i (inline)
-# (why are we still running smoke on netbsd6 and not netbsd7?)
-$(XDRHEADERS): $(XDRGENFILES)
-	if [ ! -e $(xdrdst)/$@ -o $(@:.h=.x) -nt $(xdrdst)/$@ ]; then \
-		rpcgen -h -o $(@:.h=.tmp) $(@:.h=.x) && \
-		sed -e '/#ifndef/ s/-/_/g' -e '/#define/ s/-/_/g' \
-			-e '/#endif/ s/-/_/' -e 's/TMP_/H_/g' \
-			$(@:.h=.tmp) > $(xdrdst)/$@ && \
-		rm -f $(@:.h=.tmp) ; \
-	fi
-
-
-# link .x files when doing out-of-tree builds
-# have to use .PHONY here to force it; all versions of make
-# will think the file already exists "here" by virtue of the
-# VPATH. And we have to have the .x file in $cwd in order to
-# have rpcgen generate "nice" #include directives
-# i.e. (nice):
-# #include "acl3-xdr.h"
-# versus (not nice):
-# #include "../../../../foo/src/rpc/xdr/src/acl3-xdr.h"
-.PHONY : $(XDRGENFILES)
-$(XDRGENFILES):
-	@if [ ! -e $@ ]; then ln -s $(xdrsrc)/$@ . ; fi;
-
diff --git a/rpc/xdr/src/.gitignore b/rpc/xdr/src/.gitignore
index df738be6c07..a0c8b7ca2b6 100644
--- a/rpc/xdr/src/.gitignore
+++ b/rpc/xdr/src/.gitignore
@@ -8,8 +8,8 @@ glusterd1-xdr.c
 glusterd1-xdr.h
 glusterfs3-xdr.c
 glusterfs3-xdr.h
-glusterfs-fops.h
-glusterfs-fops.c
+glusterfs4-xdr.c
+glusterfs4-xdr.h
 mount3udp.c
 mount3udp.h
 nlm4-xdr.c
diff --git a/rpc/xdr/src/Makefile.am b/rpc/xdr/src/Makefile.am
index 77f545646d6..0e9c377ec93 100644
--- a/rpc/xdr/src/Makefile.am
+++ b/rpc/xdr/src/Makefile.am
@@ -1,10 +1,19 @@
-XDRGENFILES = glusterfs3-xdr.x cli1-xdr.x nlm4-xdr.x nsm-xdr.x \
-	rpc-common-xdr.x glusterd1-xdr.x acl3-xdr.x portmap-xdr.x \
-	mount3udp.x changelog-xdr.x glusterfs-fops.x
+if BUILD_GNFS
+    NFS_XDRS = nlm4-xdr.x nsm-xdr.x acl3-xdr.x mount3udp.x
+    NFS_SRCS = xdr-nfs3.c msg-nfs3.c
+    NFS_HDRS = xdr-nfs3.h msg-nfs3.h
+else
+    NFS_EXTRA_XDRS = nlm4-xdr.x nsm-xdr.x acl3-xdr.x mount3udp.x
+endif
+
+XDRGENFILES = glusterfs3-xdr.x glusterfs4-xdr.x cli1-xdr.x \
+	rpc-common-xdr.x glusterd1-xdr.x changelog-xdr.x \
+	portmap-xdr.x ${NFS_XDRS}
+
 XDRHEADERS = $(XDRGENFILES:.x=.h)
 XDRSOURCES = $(XDRGENFILES:.x=.c)
 
-EXTRA_DIST = $(XDRGENFILES)
+EXTRA_DIST = $(XDRGENFILES) libgfxdr.sym ${NFS_EXTRA_XDRS}
 
 lib_LTLIBRARIES = libgfxdr.la
 
@@ -16,19 +25,61 @@ libgfxdr_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 \
 
 libgfxdr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
 
-libgfxdr_la_LDFLAGS = -version-info $(LIBGFXDR_LT_VERSION)
+libgfxdr_la_LDFLAGS = -version-info $(LIBGFXDR_LT_VERSION) $(GF_LDFLAGS) \
+		      -export-symbols $(top_srcdir)/rpc/xdr/src/libgfxdr.sym
 
-libgfxdr_la_SOURCES = xdr-generic.c xdr-nfs3.c msg-nfs3.c
+libgfxdr_la_SOURCES = xdr-generic.c ${NFS_SRCS}
 nodist_libgfxdr_la_SOURCES = $(XDRSOURCES)
 
-libgfxdr_la_HEADERS = xdr-generic.h xdr-nfs3.h msg-nfs3.h glusterfs3.h \
-	rpc-pragmas.h
+libgfxdr_la_HEADERS = xdr-generic.h glusterfs3.h rpc-pragmas.h ${NFS_HDRS}
 nodist_libgfxdr_la_HEADERS = $(XDRHEADERS)
 
 libgfxdr_ladir = $(includedir)/glusterfs/rpc
 
 CLEANFILES = $(XDRSOURCES) $(XDRHEADERS)
 
-# Generate the .c and .h symlinks from the ../gen/*.x files
-$(XDRSOURCES) $(XDRHEADERS):
-	$(MAKE) -C ../gen $^
+# trick automake into doing BUILT_SOURCES magic
+BUILT_SOURCES = $(XDRHEADERS) $(XDRSOURCES)
+
+xdrsrc=$(top_srcdir)/rpc/xdr/src
+xdrdst=$(top_builddir)/rpc/xdr/src
+
+# make's dependency resolution may mean that it decides to run
+# rpcgen again (unnecessarily), but as the .c file already exists,
+# rpcgen will exit with an error, resulting in a build error. We
+# could use a '-' (i.e. -@rpcgen ...) and suffer with noisy warnings
+# in the build. Or we do this crufty thing instead.
+$(XDRSOURCES): $(XDRGENFILES)
+	@if [ ! -e $(xdrdst)/$@ -o $(@:.c=.x) -nt $(xdrdst)/$@ ]; then \
+		rpcgen -c -o $(xdrdst)/$@ $(@:.c=.x) ;\
+	fi
+
+# d*mn sed in netbsd6 doesn't do -i (inline)
+# (why are we still running smoke on netbsd6 and not netbsd7?)
+$(XDRHEADERS): $(XDRGENFILES)
+	@if [ ! -e $(xdrdst)/$@ -o $(@:.h=.x) -nt $(xdrdst)/$@ ]; then \
+		rpcgen -h -o $(@:.h=.tmp) $(@:.h=.x) && \
+		sed -e '/#ifndef/ s/-/_/g' -e '/#define/ s/-/_/g' \
+			-e '/#endif/ s/-/_/' -e 's/TMP_/H_/g' \
+			$(@:.h=.tmp) > $(xdrdst)/$@ && \
+		rm -f $(@:.h=.tmp) ; \
+	fi
+
+
+# link .x files when doing out-of-tree builds
+# have to use .PHONY here to force it; all versions of make
+# will think the file already exists "here" by virtue of the
+# VPATH. And we have to have the .x file in $cwd in order to
+# have rpcgen generate "nice" #include directives
+# i.e. (nice):
+# #include "acl3-xdr.h"
+# versus (not nice):
+# #include "../../../../foo/src/rpc/xdr/src/acl3-xdr.h"
+.PHONY : $(XDRGENFILES)
+$(XDRGENFILES):
+	@if [ ! -e $@ ]; then ln -s $(xdrsrc)/$@ . ; fi;
+
+clean-local:
+	@if [ $(top_builddir) != $(top_srcdir) ]; then \
+		rm -f $(xdrdst)/*.x; \
+	fi
diff --git a/rpc/xdr/src/acl3-xdr.x b/rpc/xdr/src/acl3-xdr.x
index bd9972c7c53..7f7364971e6 100644
--- a/rpc/xdr/src/acl3-xdr.x
+++ b/rpc/xdr/src/acl3-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 %#include "xdr-nfs3.h"
 
 struct aclentry {
@@ -28,25 +28,25 @@ struct getaclargs {
 struct getaclreply {
 	int status;
 	int attr_follows;
-	struct fattr3 attr;
+	fattr3 attr;
 	int	mask;
 	int aclcount;
-	struct aclentry aclentry<>;
+	aclentry aclentry<>;
 	int daclcount;
-	struct aclentry daclentry<>;
+	aclentry daclentry<>;
 };
 
 struct setaclargs {
 	netobj fh;
 	int mask;
 	int aclcount;
-	struct aclentry aclentry<>;
+	aclentry aclentry<>;
 	int daclcount;
-	struct aclentry daclentry<>;
+	aclentry daclentry<>;
 };
 
 struct setaclreply {
 	int status;
 	int attr_follows;
-	struct fattr3 attr;
+	fattr3 attr;
 };
diff --git a/rpc/xdr/src/changelog-xdr.x b/rpc/xdr/src/changelog-xdr.x
index 0bd6564a7f0..5956245d5ce 100644
--- a/rpc/xdr/src/changelog-xdr.x
+++ b/rpc/xdr/src/changelog-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
 /* XDR: libgfchangelog -> changelog */
 
@@ -27,16 +27,16 @@ struct changelog_probe_rsp {
 /* XDR: changelog -> libgfchangelog */
 struct changelog_event_req {
        /* sequence number for the buffer */
-       unsigned long seq;
+       unsigned hyper seq;
 
        /* time of dispatch */
-       unsigned long tv_sec;
-       unsigned long tv_usec;
+       unsigned hyper tv_sec;
+       unsigned hyper tv_usec;
 };
 
 struct changelog_event_rsp {
        int op_ret;
 
        /* ack'd buffers sequence number */
-       unsigned long seq;
+       unsigned hyper seq;
 };
diff --git a/rpc/xdr/src/cli1-xdr.x b/rpc/xdr/src/cli1-xdr.x
index f62248396ca..777cb0046a2 100644
--- a/rpc/xdr/src/cli1-xdr.x
+++ b/rpc/xdr/src/cli1-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
  enum gf_cli_defrag_type {
 	GF_DEFRAG_CMD_NONE = 0,
@@ -68,6 +68,7 @@ enum gf_bitrot_type {
         GF_BITROT_OPTION_TYPE_EXPIRY_TIME,
         GF_BITROT_CMD_SCRUB_STATUS,
         GF_BITROT_CMD_SCRUB_ONDEMAND,
+        GF_BITROT_OPTION_TYPE_SIGNER_THREADS,
         GF_BITROT_OPTION_TYPE_MAX
 };
 
@@ -180,6 +181,7 @@ enum gf_cli_status_type {
         GF_CLI_STATUS_CALLPOOL     = 0x000010,    /*000000000010000*/
         GF_CLI_STATUS_DETAIL       = 0x000020,    /*000000000100000*/
         GF_CLI_STATUS_TASKS        = 0x000040,    /*00000001000000*/
+        GF_CLI_STATUS_CLIENT_LIST  = 0x000080,    /*00000010000000*/
         GF_CLI_STATUS_MASK         = 0x0000FF,    /*000000011111111 Used to get the op*/
         GF_CLI_STATUS_VOL          = 0x000100,    /*00000000100000000*/
         GF_CLI_STATUS_ALL          = 0x000200,    /*00000001000000000*/
diff --git a/rpc/xdr/src/glusterd1-xdr.x b/rpc/xdr/src/glusterd1-xdr.x
index 1ce57392b5b..b631dea3502 100644
--- a/rpc/xdr/src/glusterd1-xdr.x
+++ b/rpc/xdr/src/glusterd1-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
  enum glusterd_volume_status {
         GLUSTERD_STATUS_NONE = 0,
@@ -132,6 +132,7 @@ struct gd1_mgmt_brick_op_req {
         string  name<>;
         int     op;
         opaque  input<>;
+        opaque  dict<>;
 } ;
 
 struct gd1_mgmt_brick_op_rsp {
@@ -201,6 +202,21 @@ struct gd1_mgmt_v3_commit_rsp {
         string  op_errstr<>;
 }  ;
 
+struct gd1_mgmt_v3_post_commit_req {
+        unsigned char  uuid[16];
+        int     op;
+        opaque  dict<>;
+}  ;
+
+struct gd1_mgmt_v3_post_commit_rsp {
+        unsigned char  uuid[16];
+        int     op;
+        int     op_ret;
+        int     op_errno;
+        opaque  dict<>;
+        string  op_errstr<>;
+}  ;
+
 struct gd1_mgmt_v3_post_val_req {
         unsigned char  uuid[16];
         int     op;
diff --git a/rpc/xdr/src/glusterfs-fops.x b/rpc/xdr/src/glusterfs-fops.x
deleted file mode 100644
index 8a99ef5cfe7..00000000000
--- a/rpc/xdr/src/glusterfs-fops.x
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>
- * This file is part of GlusterFS.
- *
- * This file is licensed to you under your choice of the GNU Lesser
- * General Public License, version 3 or any later version (LGPLv3 or
- * later), or the GNU General Public License, version 2 (GPLv2), in all
- * cases as published by the Free Software Foundation.
- */
-
-#ifdef RPC_XDR
-%#include "rpc-pragmas.h"
-#endif
-%#include "compat.h"
-
-/* NOTE: add members ONLY at the end (just before _MAXVALUE) */
-/*
- * OTHER NOTE: fop_enum_to_str and fop_enum_to_pri_str (in common-utils.h) also
- * contain lists of fops, so if you update this list UPDATE THOSE TOO.
- */
-enum glusterfs_fop_t {
-        GF_FOP_NULL = 0,
-        GF_FOP_STAT,
-        GF_FOP_READLINK,
-        GF_FOP_MKNOD,
-        GF_FOP_MKDIR,
-        GF_FOP_UNLINK,
-        GF_FOP_RMDIR,
-        GF_FOP_SYMLINK,
-        GF_FOP_RENAME,
-        GF_FOP_LINK,
-        GF_FOP_TRUNCATE,
-        GF_FOP_OPEN,
-        GF_FOP_READ,
-        GF_FOP_WRITE,
-        GF_FOP_STATFS,
-        GF_FOP_FLUSH,
-        GF_FOP_FSYNC,      /* 16 */
-        GF_FOP_SETXATTR,
-        GF_FOP_GETXATTR,
-        GF_FOP_REMOVEXATTR,
-        GF_FOP_OPENDIR,
-        GF_FOP_FSYNCDIR,
-        GF_FOP_ACCESS,
-        GF_FOP_CREATE,
-        GF_FOP_FTRUNCATE,
-        GF_FOP_FSTAT,      /* 25 */
-        GF_FOP_LK,
-        GF_FOP_LOOKUP,
-        GF_FOP_READDIR,
-        GF_FOP_INODELK,
-        GF_FOP_FINODELK,
-        GF_FOP_ENTRYLK,
-        GF_FOP_FENTRYLK,
-        GF_FOP_XATTROP,
-        GF_FOP_FXATTROP,
-        GF_FOP_FGETXATTR,
-        GF_FOP_FSETXATTR,
-        GF_FOP_RCHECKSUM,
-        GF_FOP_SETATTR,
-        GF_FOP_FSETATTR,
-        GF_FOP_READDIRP,
-        GF_FOP_FORGET,
-        GF_FOP_RELEASE,
-        GF_FOP_RELEASEDIR,
-        GF_FOP_GETSPEC,
-        GF_FOP_FREMOVEXATTR,
-	GF_FOP_FALLOCATE,
-	GF_FOP_DISCARD,
-        GF_FOP_ZEROFILL,
-        GF_FOP_IPC,
-        GF_FOP_SEEK,
-        GF_FOP_LEASE,
-        GF_FOP_COMPOUND,
-        GF_FOP_GETACTIVELK,
-        GF_FOP_SETACTIVELK,
-        GF_FOP_MAXVALUE
-};
-
-/* Note: Removed event GF_EVENT_CHILD_MODIFIED=8, hence
- *to preserve backward compatibiliy, GF_EVENT_CLEANUP = 9
- */
-enum glusterfs_event_t {
-        GF_EVENT_PARENT_UP = 1,
-        GF_EVENT_POLLIN,
-        GF_EVENT_POLLOUT,
-        GF_EVENT_POLLERR,
-        GF_EVENT_CHILD_UP,
-        GF_EVENT_CHILD_DOWN,
-        GF_EVENT_CHILD_CONNECTING,
-        GF_EVENT_CLEANUP = 9,
-        GF_EVENT_TRANSPORT_CONNECTED,
-        GF_EVENT_VOLFILE_MODIFIED,
-        GF_EVENT_GRAPH_NEW,
-        GF_EVENT_TRANSLATOR_INFO,
-        GF_EVENT_TRANSLATOR_OP,
-        GF_EVENT_AUTH_FAILED,
-        GF_EVENT_VOLUME_DEFRAG,
-        GF_EVENT_PARENT_DOWN,
-        GF_EVENT_VOLUME_BARRIER_OP,
-        GF_EVENT_UPCALL,
-        GF_EVENT_SCRUB_STATUS,
-        GF_EVENT_SOME_DESCENDENT_DOWN,
-        GF_EVENT_SCRUB_ONDEMAND,
-        GF_EVENT_SOME_DESCENDENT_UP,
-        GF_EVENT_CHILD_PING,
-        GF_EVENT_MAXVAL
-};
-
-/* List of compound fops. Add fops at the end. */
-enum glusterfs_compound_fop_t {
-        GF_CFOP_NON_PREDEFINED = 0, /* needs single FOP inspection */
-        GF_CFOP_XATTROP_WRITEV,
-        GF_CFOP_XATTROP_UNLOCK,
-        GF_CFOP_PUT, /* create+write+setxattr+fsync+close+rename */
-        GF_CFOP_MAXVALUE
-};
-
-enum glusterfs_mgmt_t {
-        GF_MGMT_NULL = 0,
-        GF_MGMT_MAXVALUE
-};
-
-enum gf_op_type_t {
-        GF_OP_TYPE_NULL = 0,
-        GF_OP_TYPE_FOP,
-        GF_OP_TYPE_MGMT,
-        GF_OP_TYPE_MAX
-};
-
-/* NOTE: all the miscellaneous flags used by GlusterFS should be listed here */
-enum glusterfs_lk_cmds_t {
-        GF_LK_GETLK = 0,
-        GF_LK_SETLK,
-        GF_LK_SETLKW,
-        GF_LK_RESLK_LCK,
-        GF_LK_RESLK_LCKW,
-        GF_LK_RESLK_UNLCK,
-        GF_LK_GETLK_FD
-};
-
-enum glusterfs_lk_types_t {
-        GF_LK_F_RDLCK = 0,
-        GF_LK_F_WRLCK,
-        GF_LK_F_UNLCK,
-        GF_LK_EOL
-};
-
-/* Lease Types */
-enum gf_lease_types_t {
-        NONE        = 0,
-        GF_RD_LEASE = 1,
-        GF_RW_LEASE = 2,
-        GF_LEASE_MAX_TYPE
-};
-
-/* Lease cmds */
-enum gf_lease_cmds_t {
-        GF_GET_LEASE = 1,
-        GF_SET_LEASE = 2,
-        GF_UNLK_LEASE = 3
-};
-
-%#define LEASE_ID_SIZE 16 /* 128bits */
-struct gf_lease {
-        gf_lease_cmds_t  cmd;
-        gf_lease_types_t lease_type;
-        char             lease_id[LEASE_ID_SIZE];
-        unsigned int     lease_flags;
-};
-
-enum glusterfs_lk_recovery_cmds_t {
-        F_RESLK_LCK = 200,
-        F_RESLK_LCKW,
-        F_RESLK_UNLCK,
-        F_GETLK_FD
-};
-
-enum gf_lk_domain_t {
-        GF_LOCK_POSIX,
-        GF_LOCK_INTERNAL
-};
-
-enum entrylk_cmd {
-        ENTRYLK_LOCK,
-        ENTRYLK_UNLOCK,
-        ENTRYLK_LOCK_NB
-};
-
-enum entrylk_type {
-        ENTRYLK_RDLCK,
-        ENTRYLK_WRLCK
-};
-
-%#define GF_MAX_LOCK_OWNER_LEN 1024 /* 1kB as per NLM */
-
-/* 16strings-16strings-... */
-%#define GF_LKOWNER_BUF_SIZE  ((GF_MAX_LOCK_OWNER_LEN * 2) + (GF_MAX_LOCK_OWNER_LEN / 8))
-
-struct gf_lkowner_t {
-        int  len;
-        char data[GF_MAX_LOCK_OWNER_LEN];
-};
-
-enum gf_xattrop_flags_t {
-        GF_XATTROP_ADD_ARRAY,
-        GF_XATTROP_ADD_ARRAY64,
-        GF_XATTROP_OR_ARRAY,
-        GF_XATTROP_AND_ARRAY,
-        GF_XATTROP_GET_AND_SET,
-        GF_XATTROP_ADD_ARRAY_WITH_DEFAULT,
-        GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT
-};
-
-enum gf_seek_what_t {
-        GF_SEEK_DATA,
-        GF_SEEK_HOLE
-};
-
-enum gf_upcall_flags_t {
-        GF_UPCALL_NULL,
-        GF_UPCALL,
-        GF_UPCALL_CI_STAT,
-        GF_UPCALL_CI_XATTR,
-        GF_UPCALL_CI_RENAME,
-        GF_UPCALL_CI_NLINK,
-        GF_UPCALL_CI_FORGET,
-        GF_UPCALL_LEASE_RECALL,
-        GF_UPCALL_FLAGS_MAXVALUE
-};
diff --git a/rpc/xdr/src/glusterfs3-xdr.x b/rpc/xdr/src/glusterfs3-xdr.x
index d6fb1bee037..1c99099a721 100644
--- a/rpc/xdr/src/glusterfs3-xdr.x
+++ b/rpc/xdr/src/glusterfs3-xdr.x
@@ -11,9 +11,8 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/glusterfs-fops.h>
 %#include "rpc-common-xdr.h"
-%#include "glusterfs-fops.h"
 
 #define GF_REQUEST_MAXGROUPS    16
 struct gf_statfs {
@@ -74,11 +73,11 @@ struct gfs3_cbk_cache_invalidation_req {
         unsigned int   flags;  /* or mask of events incase of inotify */
         unsigned int   expire_time_attr; /* the amount of time which client
                                           * can cache this entry */
-        struct gf_iatt stat;  /* Updated/current stat of the file/dir */
-        struct gf_iatt parent_stat;  /* Updated stat of the parent dir
+        gf_iatt stat;  /* Updated/current stat of the file/dir */
+        gf_iatt parent_stat;  /* Updated stat of the parent dir
                                       * needed in case of create, mkdir,
                                       * unlink, rmdir, rename fops */
-        struct gf_iatt oldparent_stat;  /* Updated stat of the oldparent dir
+        gf_iatt oldparent_stat;  /* Updated stat of the oldparent dir
                                            needed in case of rename fop */
         opaque   xdata<>; /* Extra data */
 };
@@ -90,7 +89,7 @@ struct gfs3_stat_req {
 struct gfs3_stat_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
+	gf_iatt stat;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -103,7 +102,7 @@ struct gfs3_readlink_req {
  struct gfs3_readlink_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt buf;
+        gf_iatt buf;
         string      path<>; /* NULL terminated */
         opaque   xdata<>; /* Extra data */
 } ;
@@ -120,9 +119,9 @@ struct gfs3_readlink_req {
  struct gfs3_mknod_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+	gf_iatt stat;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -137,9 +136,9 @@ struct gfs3_readlink_req {
  struct  gfs3_mkdir_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+	gf_iatt stat;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -153,8 +152,8 @@ struct gfs3_readlink_req {
  struct   gfs3_unlink_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -168,8 +167,8 @@ struct gfs3_readlink_req {
  struct   gfs3_rmdir_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -184,9 +183,9 @@ struct gfs3_readlink_req {
  struct  gfs3_symlink_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+	gf_iatt stat;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -201,11 +200,11 @@ struct gfs3_readlink_req {
  struct   gfs3_rename_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt preoldparent;
-        struct gf_iatt postoldparent;
-        struct gf_iatt prenewparent;
-        struct gf_iatt postnewparent;
+	gf_iatt stat;
+        gf_iatt preoldparent;
+        gf_iatt postoldparent;
+        gf_iatt prenewparent;
+        gf_iatt postnewparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -219,9 +218,9 @@ struct gfs3_readlink_req {
  struct   gfs3_link_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+	gf_iatt stat;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -233,8 +232,8 @@ struct gfs3_readlink_req {
  struct   gfs3_truncate_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt prestat;
-        struct gf_iatt poststat;
+	gf_iatt prestat;
+        gf_iatt poststat;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -263,7 +262,7 @@ struct gfs3_readlink_req {
  struct  gfs3_read_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
+	gf_iatt stat;
         unsigned int size;
         opaque   xdata<>; /* Extra data */
 } ;
@@ -278,8 +277,8 @@ struct   gfs3_lookup_req {
  struct   gfs3_lookup_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
-        struct gf_iatt postparent;
+	gf_iatt stat;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -296,8 +295,8 @@ struct   gfs3_lookup_req {
  struct gfs3_write_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt prestat;
-        struct gf_iatt poststat;
+	gf_iatt prestat;
+        gf_iatt poststat;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -309,7 +308,7 @@ struct   gfs3_lookup_req {
  struct gfs3_statfs_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_statfs statfs;
+	gf_statfs statfs;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -318,26 +317,26 @@ struct   gfs3_lookup_req {
 	int64_t         fd;
 	unsigned int        cmd;
 	unsigned int        type;
-	struct gf_proto_flock flock;
+	gf_proto_flock flock;
         opaque   xdata<>; /* Extra data */
 }  ;
  struct gfs3_lk_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_proto_flock flock;
+	gf_proto_flock flock;
         opaque   xdata<>; /* Extra data */
 }  ;
 
 struct gfs3_lease_req {
         opaque gfid[16];
-        struct gf_proto_lease lease;
+        gf_proto_lease lease;
         opaque   xdata<>; /* Extra data */
 }  ;
 
 struct gfs3_lease_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_proto_lease lease;
+        gf_proto_lease lease;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -352,7 +351,7 @@ struct gfs3_recall_lease_req {
         opaque gfid[16];
 	unsigned int cmd;
 	unsigned int type;
-	struct gf_proto_flock flock;
+	gf_proto_flock flock;
         string     volume<>;
         opaque   xdata<>; /* Extra data */
 }  ;
@@ -362,7 +361,7 @@ struct   gfs3_finodelk_req {
 	quad_t  fd;
 	unsigned int cmd;
 	unsigned int type;
-	struct gf_proto_flock flock;
+	gf_proto_flock flock;
         string volume<>;
         opaque   xdata<>; /* Extra data */
 } ;
@@ -384,8 +383,8 @@ struct   gfs3_finodelk_req {
  struct gfs3_fsync_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt prestat;
-        struct gf_iatt poststat;
+        gf_iatt prestat;
+        gf_iatt poststat;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -538,10 +537,10 @@ struct gfs3_create_req {
 struct  gfs3_create_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
+	gf_iatt stat;
 	u_quad_t       fd;
-        struct gf_iatt preparent;
-        struct gf_iatt postparent;
+        gf_iatt preparent;
+        gf_iatt postparent;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -556,8 +555,8 @@ struct   gfs3_ftruncate_req  {
 struct   gfs3_ftruncate_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt prestat;
-        struct gf_iatt poststat;
+	gf_iatt prestat;
+        gf_iatt poststat;
         opaque   xdata<>; /* Extra data */
 } ;
 
@@ -570,7 +569,7 @@ struct gfs3_fstat_req {
  struct gfs3_fstat_rsp {
         int    op_ret;
         int    op_errno;
-	struct gf_iatt stat;
+	gf_iatt stat;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -600,29 +599,29 @@ struct gfs3_fstat_req {
 
  struct gfs3_setattr_req {
         opaque gfid[16];
-        struct gf_iatt stbuf;
+        gf_iatt stbuf;
         int        valid;
         opaque   xdata<>; /* Extra data */
 }  ;
  struct gfs3_setattr_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt statpre;
-        struct gf_iatt statpost;
+        gf_iatt statpre;
+        gf_iatt statpost;
         opaque   xdata<>; /* Extra data */
 }  ;
 
  struct gfs3_fsetattr_req {
         quad_t        fd;
-        struct gf_iatt stbuf;
+        gf_iatt stbuf;
         int        valid;
         opaque   xdata<>; /* Extra data */
 }  ;
  struct gfs3_fsetattr_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt statpre;
-        struct gf_iatt statpost;
+        gf_iatt statpre;
+        gf_iatt statpost;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -638,8 +637,8 @@ struct gfs3_fstat_req {
  struct gfs3_fallocate_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt statpre;
-        struct gf_iatt statpost;
+        gf_iatt statpre;
+        gf_iatt statpost;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -654,8 +653,8 @@ struct gfs3_fstat_req {
  struct gfs3_discard_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt statpre;
-        struct gf_iatt statpost;
+        gf_iatt statpre;
+        gf_iatt statpost;
         opaque   xdata<>; /* Extra data */
 }  ;
 
@@ -670,8 +669,8 @@ struct gfs3_fstat_req {
  struct gfs3_zerofill_rsp {
         int    op_ret;
         int    op_errno;
-        struct gf_iatt statpre;
-        struct gf_iatt statpost;
+        gf_iatt statpre;
+        gf_iatt statpost;
         opaque   xdata<>;
 }  ;
 
@@ -796,14 +795,14 @@ struct gfs3_dirlist {
        unsigned int d_len;
        unsigned int d_type;
        string name<>;
-       struct gfs3_dirlist *nextentry;
+       gfs3_dirlist *nextentry;
 };
 
 
 struct gfs3_readdir_rsp {
        int op_ret;
        int op_errno;
-       struct gfs3_dirlist *reply;
+       gfs3_dirlist *reply;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -813,15 +812,15 @@ struct gfs3_dirplist {
        unsigned int d_len;
        unsigned int d_type;
        string name<>;
-       struct gf_iatt stat;
+       gf_iatt stat;
        opaque dict<>;
-       struct gfs3_dirplist *nextentry;
+       gfs3_dirplist *nextentry;
 };
 
 struct gfs3_readdirp_rsp {
        int op_ret;
        int op_errno;
-       struct gfs3_dirplist *reply;
+       gfs3_dirplist *reply;
         opaque   xdata<>; /* Extra data */
 };
 
@@ -859,137 +858,17 @@ struct gf_getsnap_name_uuid_rsp {
         opaque dict<>;
 };
 
-union compound_req switch (glusterfs_fop_t fop_enum) {
-        case GF_FOP_STAT:         gfs3_stat_req compound_stat_req;
-        case GF_FOP_READLINK:     gfs3_readlink_req compound_readlink_req;
-        case GF_FOP_MKNOD:        gfs3_mknod_req compound_mknod_req;
-        case GF_FOP_MKDIR:        gfs3_mkdir_req compound_mkdir_req;
-        case GF_FOP_UNLINK:       gfs3_unlink_req compound_unlink_req;
-        case GF_FOP_RMDIR:        gfs3_rmdir_req compound_rmdir_req;
-        case GF_FOP_SYMLINK:      gfs3_symlink_req compound_symlink_req;
-        case GF_FOP_RENAME:       gfs3_rename_req compound_rename_req;
-        case GF_FOP_LINK:         gfs3_link_req compound_link_req;
-        case GF_FOP_TRUNCATE:     gfs3_truncate_req compound_truncate_req;
-        case GF_FOP_OPEN:         gfs3_open_req compound_open_req;
-        case GF_FOP_READ:         gfs3_read_req compound_read_req;
-        case GF_FOP_WRITE:        gfs3_write_req compound_write_req;
-        case GF_FOP_STATFS:       gfs3_statfs_req compound_statfs_req;
-        case GF_FOP_FLUSH:        gfs3_flush_req compound_flush_req;
-        case GF_FOP_FSYNC:        gfs3_fsync_req compound_fsync_req;
-        case GF_FOP_GETXATTR:     gfs3_getxattr_req compound_getxattr_req;
-        case GF_FOP_SETXATTR:     gfs3_setxattr_req compound_setxattr_req;
-        case GF_FOP_REMOVEXATTR:  gfs3_removexattr_req compound_removexattr_req;
-        case GF_FOP_OPENDIR:      gfs3_opendir_req compound_opendir_req;
-        case GF_FOP_FSYNCDIR:     gfs3_fsyncdir_req compound_fsyncdir_req;
-        case GF_FOP_ACCESS:       gfs3_access_req compound_access_req;
-        case GF_FOP_CREATE:       gfs3_create_req compound_create_req;
-        case GF_FOP_FTRUNCATE:    gfs3_ftruncate_req compound_ftruncate_req;
-        case GF_FOP_FSTAT:        gfs3_fstat_req compound_fstat_req;
-        case GF_FOP_LK:           gfs3_lk_req compound_lk_req;
-        case GF_FOP_LOOKUP:       gfs3_lookup_req compound_lookup_req;
-        case GF_FOP_READDIR:      gfs3_readdir_req compound_readdir_req;
-        case GF_FOP_INODELK:      gfs3_inodelk_req compound_inodelk_req;
-        case GF_FOP_FINODELK:     gfs3_finodelk_req compound_finodelk_req;
-        case GF_FOP_ENTRYLK:      gfs3_entrylk_req compound_entrylk_req;
-        case GF_FOP_FENTRYLK:     gfs3_fentrylk_req compound_fentrylk_req;
-        case GF_FOP_XATTROP:      gfs3_xattrop_req compound_xattrop_req;
-        case GF_FOP_FXATTROP:     gfs3_fxattrop_req compound_fxattrop_req;
-        case GF_FOP_FGETXATTR:    gfs3_fgetxattr_req compound_fgetxattr_req;
-        case GF_FOP_FSETXATTR:    gfs3_fsetxattr_req compound_fsetxattr_req;
-        case GF_FOP_RCHECKSUM:    gfs3_rchecksum_req compound_rchecksum_req;
-        case GF_FOP_SETATTR:      gfs3_setattr_req compound_setattr_req;
-        case GF_FOP_FSETATTR:     gfs3_fsetattr_req compound_fsetattr_req;
-        case GF_FOP_READDIRP:     gfs3_readdirp_req compound_readdirp_req;
-        case GF_FOP_RELEASE:      gfs3_release_req compound_release_req;
-        case GF_FOP_RELEASEDIR:   gfs3_releasedir_req compound_releasedir_req;
-        case GF_FOP_FREMOVEXATTR: gfs3_fremovexattr_req compound_fremovexattr_req;
-        case GF_FOP_FALLOCATE:    gfs3_fallocate_req compound_fallocate_req;
-        case GF_FOP_DISCARD:      gfs3_discard_req compound_discard_req;
-        case GF_FOP_ZEROFILL:     gfs3_zerofill_req compound_zerofill_req;
-        case GF_FOP_IPC:          gfs3_ipc_req compound_ipc_req;
-        case GF_FOP_SEEK:         gfs3_seek_req compound_seek_req;
-        case GF_FOP_LEASE:         gfs3_lease_req compound_lease_req;
-        default:                  void;
-};
-
-struct gfs3_compound_req {
-        int                       compound_version;
-        glusterfs_compound_fop_t  compound_fop_enum;
-        compound_req              compound_req_array<>;
-        opaque                    xdata<>;
-};
-
-union compound_rsp switch (glusterfs_fop_t fop_enum) {
-        case GF_FOP_STAT:         gfs3_stat_rsp compound_stat_rsp;
-        case GF_FOP_READLINK:     gfs3_readlink_rsp compound_readlink_rsp;
-        case GF_FOP_MKNOD:        gfs3_mknod_rsp compound_mknod_rsp;
-        case GF_FOP_MKDIR:        gfs3_mkdir_rsp compound_mkdir_rsp;
-        case GF_FOP_UNLINK:       gfs3_unlink_rsp compound_unlink_rsp;
-        case GF_FOP_RMDIR:        gfs3_rmdir_rsp compound_rmdir_rsp;
-        case GF_FOP_SYMLINK:      gfs3_symlink_rsp compound_symlink_rsp;
-        case GF_FOP_RENAME:       gfs3_rename_rsp compound_rename_rsp;
-        case GF_FOP_LINK:         gfs3_link_rsp compound_link_rsp;
-        case GF_FOP_TRUNCATE:     gfs3_truncate_rsp compound_truncate_rsp;
-        case GF_FOP_OPEN:         gfs3_open_rsp compound_open_rsp;
-        case GF_FOP_READ:         gfs3_read_rsp compound_read_rsp;
-        case GF_FOP_WRITE:        gfs3_write_rsp compound_write_rsp;
-        case GF_FOP_STATFS:       gfs3_statfs_rsp compound_statfs_rsp;
-        case GF_FOP_FLUSH:        gf_common_rsp compound_flush_rsp;
-        case GF_FOP_FSYNC:        gfs3_fsync_rsp compound_fsync_rsp;
-        case GF_FOP_GETXATTR:     gfs3_getxattr_rsp compound_getxattr_rsp;
-        case GF_FOP_SETXATTR:     gf_common_rsp compound_setxattr_rsp;
-        case GF_FOP_REMOVEXATTR:  gf_common_rsp compound_removexattr_rsp;
-        case GF_FOP_OPENDIR:      gfs3_opendir_rsp compound_opendir_rsp;
-        case GF_FOP_FSYNCDIR:     gf_common_rsp compound_fsyncdir_rsp;
-        case GF_FOP_ACCESS:       gf_common_rsp compound_access_rsp;
-        case GF_FOP_CREATE:       gfs3_create_rsp compound_create_rsp;
-        case GF_FOP_FTRUNCATE:    gfs3_ftruncate_rsp compound_ftruncate_rsp;
-        case GF_FOP_FSTAT:        gfs3_fstat_rsp compound_fstat_rsp;
-        case GF_FOP_LK:           gfs3_lk_rsp compound_lk_rsp;
-        case GF_FOP_LOOKUP:       gfs3_lookup_rsp compound_lookup_rsp;
-        case GF_FOP_READDIR:      gfs3_readdir_rsp compound_readdir_rsp;
-        case GF_FOP_INODELK:      gf_common_rsp compound_inodelk_rsp;
-        case GF_FOP_FINODELK:     gf_common_rsp compound_finodelk_rsp;
-        case GF_FOP_ENTRYLK:      gf_common_rsp compound_entrylk_rsp;
-        case GF_FOP_FENTRYLK:     gf_common_rsp compound_fentrylk_rsp;
-        case GF_FOP_XATTROP:      gfs3_xattrop_rsp compound_xattrop_rsp;
-        case GF_FOP_FXATTROP:     gfs3_fxattrop_rsp compound_fxattrop_rsp;
-        case GF_FOP_FGETXATTR:    gfs3_fgetxattr_rsp compound_fgetxattr_rsp;
-        case GF_FOP_FSETXATTR:    gf_common_rsp compound_fsetxattr_rsp;
-        case GF_FOP_RCHECKSUM:    gfs3_rchecksum_rsp compound_rchecksum_rsp;
-        case GF_FOP_SETATTR:      gfs3_setattr_rsp compound_setattr_rsp;
-        case GF_FOP_FSETATTR:     gfs3_fsetattr_rsp compound_fsetattr_rsp;
-        case GF_FOP_READDIRP:     gfs3_readdirp_rsp compound_readdirp_rsp;
-        case GF_FOP_RELEASE:      gf_common_rsp compound_release_rsp;
-        case GF_FOP_RELEASEDIR:   gf_common_rsp compound_releasedir_rsp;
-        case GF_FOP_FREMOVEXATTR: gf_common_rsp compound_fremovexattr_rsp;
-        case GF_FOP_FALLOCATE:    gfs3_fallocate_rsp compound_fallocate_rsp;
-        case GF_FOP_DISCARD:      gfs3_discard_rsp compound_discard_rsp;
-        case GF_FOP_ZEROFILL:     gfs3_zerofill_rsp compound_zerofill_rsp;
-        case GF_FOP_IPC:          gfs3_ipc_rsp compound_ipc_rsp;
-        case GF_FOP_SEEK:         gfs3_seek_rsp compound_seek_rsp;
-        case GF_FOP_LEASE:         gfs3_lease_rsp compound_lease_rsp;
-        default:                  void;
-};
-
-struct gfs3_compound_rsp {
-        int           op_ret;
-        int           op_errno;
-        compound_rsp  compound_rsp_array<>;
-        opaque        xdata<>;
-};
-
 struct gfs3_locklist {
-        struct gf_proto_flock flock;
+        gf_proto_flock flock;
         string client_uid<>;
         unsigned int lk_flags;
-        struct gfs3_locklist *nextentry;
+        gfs3_locklist *nextentry;
 };
 
 struct gfs3_getactivelk_rsp {
         int op_ret;
         int op_errno;
-        struct gfs3_locklist *reply;
+        gfs3_locklist *reply;
         opaque xdata<>;
 };
 
@@ -1006,6 +885,6 @@ struct gfs3_setactivelk_rsp {
 
 struct gfs3_setactivelk_req {
         opaque gfid[16];
-        struct gfs3_locklist *request;
+        gfs3_locklist *request;
         opaque xdata<>;
 };
diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h
index 3ca608467b9..86b3a4c0e5d 100644
--- a/rpc/xdr/src/glusterfs3.h
+++ b/rpc/xdr/src/glusterfs3.h
@@ -15,406 +15,943 @@
 
 #include "xdr-generic.h"
 #include "glusterfs3-xdr.h"
-#include "iatt.h"
+#include "glusterfs4-xdr.h"
+#include <glusterfs/iatt.h>
 #include "protocol-common.h"
-#include "upcall-utils.h"
-
-#define xdr_decoded_remaining_addr(xdr)        ((&xdr)->x_private)
-#define xdr_decoded_remaining_len(xdr)         ((&xdr)->x_handy)
-#define xdr_encoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
-#define xdr_decoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
-
-
-#define GF_O_ACCMODE           003
-#define GF_O_RDONLY             00
-#define GF_O_WRONLY             01
-#define GF_O_RDWR               02
-#define GF_O_CREAT            0100
-#define GF_O_EXCL             0200
-#define GF_O_NOCTTY           0400
-#define GF_O_TRUNC           01000
-#define GF_O_APPEND          02000
-#define GF_O_NONBLOCK        04000
-#define GF_O_SYNC           010000
-#define GF_O_ASYNC          020000
-
-#define GF_O_DIRECT         040000
-#define GF_O_DIRECTORY     0200000
-#define GF_O_NOFOLLOW      0400000
-#define GF_O_NOATIME      01000000
-#define GF_O_CLOEXEC      02000000
-
-#define GF_O_LARGEFILE     0100000
-
-#define GF_O_FMODE_EXEC        040
-
-#define XLATE_BIT(from, to, bit)    do {                \
-                if (from & bit)                         \
-                        to = to | GF_##bit;             \
-        } while (0)
-
-#define UNXLATE_BIT(from, to, bit)  do {                \
-                if (from & GF_##bit)                    \
-                        to = to | bit;                  \
-        } while (0)
-
-#define XLATE_ACCESSMODE(from, to) do {                 \
-                switch (from & O_ACCMODE) {             \
-                case O_RDONLY: to |= GF_O_RDONLY;       \
-                        break;                          \
-                case O_WRONLY: to |= GF_O_WRONLY;       \
-                        break;                          \
-                case O_RDWR: to |= GF_O_RDWR;           \
-                        break;                          \
-                }                                       \
-        } while (0)
-
-#define UNXLATE_ACCESSMODE(from, to) do {               \
-                switch (from & GF_O_ACCMODE) {          \
-                case GF_O_RDONLY: to |= O_RDONLY;       \
-                        break;                          \
-                case GF_O_WRONLY: to |= O_WRONLY;       \
-                        break;                          \
-                case GF_O_RDWR: to |= O_RDWR;           \
-                        break;                          \
-                }                                       \
-        } while (0)
+#include <glusterfs/upcall-utils.h>
+
+#define xdr_decoded_remaining_addr(xdr) ((&xdr)->x_private)
+#define xdr_decoded_remaining_len(xdr) ((&xdr)->x_handy)
+#define xdr_encoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+#define xdr_decoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+
+#define GF_O_ACCMODE 003
+#define GF_O_RDONLY 00
+#define GF_O_WRONLY 01
+#define GF_O_RDWR 02
+#define GF_O_CREAT 0100
+#define GF_O_EXCL 0200
+#define GF_O_NOCTTY 0400
+#define GF_O_TRUNC 01000
+#define GF_O_APPEND 02000
+#define GF_O_NONBLOCK 04000
+#define GF_O_SYNC 010000
+#define GF_O_ASYNC 020000
+
+#define GF_O_DIRECT 040000
+#define GF_O_DIRECTORY 0200000
+#define GF_O_NOFOLLOW 0400000
+#define GF_O_NOATIME 01000000
+#define GF_O_CLOEXEC 02000000
+
+#define GF_O_LARGEFILE 0100000
+
+#define GF_O_FMODE_EXEC 040
+
+#define XLATE_BIT(from, to, bit)                                               \
+    do {                                                                       \
+        if (from & bit)                                                        \
+            to = to | GF_##bit;                                                \
+    } while (0)
+
+#define UNXLATE_BIT(from, to, bit)                                             \
+    do {                                                                       \
+        if (from & GF_##bit)                                                   \
+            to = to | bit;                                                     \
+    } while (0)
+
+#define XLATE_ACCESSMODE(from, to)                                             \
+    do {                                                                       \
+        switch (from & O_ACCMODE) {                                            \
+            case O_RDONLY:                                                     \
+                to |= GF_O_RDONLY;                                             \
+                break;                                                         \
+            case O_WRONLY:                                                     \
+                to |= GF_O_WRONLY;                                             \
+                break;                                                         \
+            case O_RDWR:                                                       \
+                to |= GF_O_RDWR;                                               \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define UNXLATE_ACCESSMODE(from, to)                                           \
+    do {                                                                       \
+        switch (from & GF_O_ACCMODE) {                                         \
+            case GF_O_RDONLY:                                                  \
+                to |= O_RDONLY;                                                \
+                break;                                                         \
+            case GF_O_WRONLY:                                                  \
+                to |= O_WRONLY;                                                \
+                break;                                                         \
+            case GF_O_RDWR:                                                    \
+                to |= O_RDWR;                                                  \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
 
 static inline uint32_t
-gf_flags_from_flags (uint32_t flags)
+gf_flags_from_flags(uint32_t flags)
 {
-        uint32_t gf_flags = 0;
-
-        XLATE_ACCESSMODE (flags, gf_flags);
-
-        XLATE_BIT (flags, gf_flags, O_CREAT);
-        XLATE_BIT (flags, gf_flags, O_EXCL);
-        XLATE_BIT (flags, gf_flags, O_NOCTTY);
-        XLATE_BIT (flags, gf_flags, O_TRUNC);
-        XLATE_BIT (flags, gf_flags, O_APPEND);
-        XLATE_BIT (flags, gf_flags, O_NONBLOCK);
-        XLATE_BIT (flags, gf_flags, O_SYNC);
-        XLATE_BIT (flags, gf_flags, O_ASYNC);
-
-        XLATE_BIT (flags, gf_flags, O_DIRECT);
-        XLATE_BIT (flags, gf_flags, O_DIRECTORY);
-        XLATE_BIT (flags, gf_flags, O_NOFOLLOW);
+    uint32_t gf_flags = 0;
+
+    XLATE_ACCESSMODE(flags, gf_flags);
+
+    XLATE_BIT(flags, gf_flags, O_CREAT);
+    XLATE_BIT(flags, gf_flags, O_EXCL);
+    XLATE_BIT(flags, gf_flags, O_NOCTTY);
+    XLATE_BIT(flags, gf_flags, O_TRUNC);
+    XLATE_BIT(flags, gf_flags, O_APPEND);
+    XLATE_BIT(flags, gf_flags, O_NONBLOCK);
+    XLATE_BIT(flags, gf_flags, O_SYNC);
+    XLATE_BIT(flags, gf_flags, O_ASYNC);
+
+    XLATE_BIT(flags, gf_flags, O_DIRECT);
+    XLATE_BIT(flags, gf_flags, O_DIRECTORY);
+    XLATE_BIT(flags, gf_flags, O_NOFOLLOW);
 #ifdef O_NOATIME
-        XLATE_BIT (flags, gf_flags, O_NOATIME);
+    XLATE_BIT(flags, gf_flags, O_NOATIME);
 #endif
 #ifdef O_CLOEXEC
-        XLATE_BIT (flags, gf_flags, O_CLOEXEC);
+    XLATE_BIT(flags, gf_flags, O_CLOEXEC);
 #endif
-        XLATE_BIT (flags, gf_flags, O_LARGEFILE);
-        XLATE_BIT (flags, gf_flags, O_FMODE_EXEC);
+    XLATE_BIT(flags, gf_flags, O_LARGEFILE);
+    XLATE_BIT(flags, gf_flags, O_FMODE_EXEC);
 
-        return gf_flags;
+    return gf_flags;
 }
 
 static inline uint32_t
-gf_flags_to_flags (uint32_t gf_flags)
+gf_flags_to_flags(uint32_t gf_flags)
 {
-        uint32_t flags = 0;
-
-        UNXLATE_ACCESSMODE (gf_flags, flags);
-
-        UNXLATE_BIT (gf_flags, flags, O_CREAT);
-        UNXLATE_BIT (gf_flags, flags, O_EXCL);
-        UNXLATE_BIT (gf_flags, flags, O_NOCTTY);
-        UNXLATE_BIT (gf_flags, flags, O_TRUNC);
-        UNXLATE_BIT (gf_flags, flags, O_APPEND);
-        UNXLATE_BIT (gf_flags, flags, O_NONBLOCK);
-        UNXLATE_BIT (gf_flags, flags, O_SYNC);
-        UNXLATE_BIT (gf_flags, flags, O_ASYNC);
-
-        UNXLATE_BIT (gf_flags, flags, O_DIRECT);
-        UNXLATE_BIT (gf_flags, flags, O_DIRECTORY);
-        UNXLATE_BIT (gf_flags, flags, O_NOFOLLOW);
+    uint32_t flags = 0;
+
+    UNXLATE_ACCESSMODE(gf_flags, flags);
+
+    UNXLATE_BIT(gf_flags, flags, O_CREAT);
+    UNXLATE_BIT(gf_flags, flags, O_EXCL);
+    UNXLATE_BIT(gf_flags, flags, O_NOCTTY);
+    UNXLATE_BIT(gf_flags, flags, O_TRUNC);
+    UNXLATE_BIT(gf_flags, flags, O_APPEND);
+    UNXLATE_BIT(gf_flags, flags, O_NONBLOCK);
+    UNXLATE_BIT(gf_flags, flags, O_SYNC);
+    UNXLATE_BIT(gf_flags, flags, O_ASYNC);
+
+    UNXLATE_BIT(gf_flags, flags, O_DIRECT);
+    UNXLATE_BIT(gf_flags, flags, O_DIRECTORY);
+    UNXLATE_BIT(gf_flags, flags, O_NOFOLLOW);
 #ifdef O_NOATIME
-        UNXLATE_BIT (gf_flags, flags, O_NOATIME);
+    UNXLATE_BIT(gf_flags, flags, O_NOATIME);
 #endif
 #ifdef O_CLOEXEC
-        UNXLATE_BIT (gf_flags, flags, O_CLOEXEC);
+    UNXLATE_BIT(gf_flags, flags, O_CLOEXEC);
 #endif
-        UNXLATE_BIT (gf_flags, flags, O_LARGEFILE);
-        UNXLATE_BIT (gf_flags, flags, O_FMODE_EXEC);
+    UNXLATE_BIT(gf_flags, flags, O_LARGEFILE);
+    UNXLATE_BIT(gf_flags, flags, O_FMODE_EXEC);
 
-        return flags;
+    return flags;
 }
 
-
 static inline void
-gf_statfs_to_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
+gf_statfs_to_statfs(struct gf_statfs *gf_stat, struct statvfs *stat)
 {
-        if (!stat || !gf_stat)
-                return;
-
-	stat->f_bsize   =  (gf_stat->bsize);
-	stat->f_frsize  =  (gf_stat->frsize);
-	stat->f_blocks  =  (gf_stat->blocks);
-	stat->f_bfree   =  (gf_stat->bfree);
-	stat->f_bavail  =  (gf_stat->bavail);
-	stat->f_files   =  (gf_stat->files);
-	stat->f_ffree   =  (gf_stat->ffree);
-	stat->f_favail  =  (gf_stat->favail);
-	stat->f_fsid    =  (gf_stat->fsid);
-	stat->f_flag    =  (gf_stat->flag);
-	stat->f_namemax =  (gf_stat->namemax);
+    if (!stat || !gf_stat)
+        return;
+
+    stat->f_bsize = (gf_stat->bsize);
+    stat->f_frsize = (gf_stat->frsize);
+    stat->f_blocks = (gf_stat->blocks);
+    stat->f_bfree = (gf_stat->bfree);
+    stat->f_bavail = (gf_stat->bavail);
+    stat->f_files = (gf_stat->files);
+    stat->f_ffree = (gf_stat->ffree);
+    stat->f_favail = (gf_stat->favail);
+    stat->f_fsid = (gf_stat->fsid);
+    stat->f_flag = (gf_stat->flag);
+    stat->f_namemax = (gf_stat->namemax);
 }
 
-
 static inline void
-gf_statfs_from_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
+gf_statfs_from_statfs(struct gf_statfs *gf_stat, struct statvfs *stat)
 {
-        if (!stat || !gf_stat)
-                return;
-
-	gf_stat->bsize   = stat->f_bsize;
-	gf_stat->frsize  = stat->f_frsize;
-	gf_stat->blocks  = stat->f_blocks;
-	gf_stat->bfree   = stat->f_bfree;
-	gf_stat->bavail  = stat->f_bavail;
-	gf_stat->files   = stat->f_files;
-	gf_stat->ffree   = stat->f_ffree;
-	gf_stat->favail  = stat->f_favail;
-	gf_stat->fsid    = stat->f_fsid;
-	gf_stat->flag    = stat->f_flag;
-	gf_stat->namemax = stat->f_namemax;
+    if (!stat || !gf_stat)
+        return;
+
+    gf_stat->bsize = stat->f_bsize;
+    gf_stat->frsize = stat->f_frsize;
+    gf_stat->blocks = stat->f_blocks;
+    gf_stat->bfree = stat->f_bfree;
+    gf_stat->bavail = stat->f_bavail;
+    gf_stat->files = stat->f_files;
+    gf_stat->ffree = stat->f_ffree;
+    gf_stat->favail = stat->f_favail;
+    gf_stat->fsid = stat->f_fsid;
+    gf_stat->flag = stat->f_flag;
+    gf_stat->namemax = stat->f_namemax;
 }
 
 static inline void
-gf_proto_lease_to_lease (struct gf_proto_lease *gf_proto_lease, struct gf_lease *gf_lease)
+gf_proto_lease_to_lease(struct gf_proto_lease *gf_proto_lease,
+                        struct gf_lease *gf_lease)
 {
-        if (!gf_lease || !gf_proto_lease)
-                return;
+    if (!gf_lease || !gf_proto_lease)
+        return;
 
-        gf_lease->cmd        = gf_proto_lease->cmd;
-        gf_lease->lease_type = gf_proto_lease->lease_type;
-        memcpy (gf_lease->lease_id, gf_proto_lease->lease_id, LEASE_ID_SIZE);
+    gf_lease->cmd = gf_proto_lease->cmd;
+    gf_lease->lease_type = gf_proto_lease->lease_type;
+    memcpy(gf_lease->lease_id, gf_proto_lease->lease_id, LEASE_ID_SIZE);
 }
 
 static inline void
-gf_proto_lease_from_lease (struct gf_proto_lease *gf_proto_lease, struct gf_lease *gf_lease)
+gf_proto_lease_from_lease(struct gf_proto_lease *gf_proto_lease,
+                          struct gf_lease *gf_lease)
 {
-        if (!gf_lease || !gf_proto_lease)
-                return;
+    if (!gf_lease || !gf_proto_lease)
+        return;
 
-        gf_proto_lease->cmd  = gf_lease->cmd;
-        gf_proto_lease->lease_type = gf_lease->lease_type;
-        memcpy (gf_proto_lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
+    gf_proto_lease->cmd = gf_lease->cmd;
+    gf_proto_lease->lease_type = gf_lease->lease_type;
+    memcpy(gf_proto_lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
 }
 
 static inline int
-gf_proto_recall_lease_to_upcall (struct gfs3_recall_lease_req *recall_lease,
-                                 struct gf_upcall *gf_up_data)
+gf_proto_recall_lease_to_upcall(struct gfs3_recall_lease_req *recall_lease,
+                                struct gf_upcall *gf_up_data)
 {
-        struct gf_upcall_recall_lease *tmp = NULL;
-        int    ret                         = 0;
+    struct gf_upcall_recall_lease *tmp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO(THIS->name, recall_lease, out);
-        GF_VALIDATE_OR_GOTO(THIS->name, gf_up_data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, recall_lease, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, gf_up_data, out);
 
-        tmp = (struct gf_upcall_recall_lease *)gf_up_data->data;
-        tmp->lease_type = recall_lease->lease_type;
-        memcpy (gf_up_data->gfid, recall_lease->gfid, 16);
-        memcpy (tmp->tid, recall_lease->tid, 16);
+    tmp = (struct gf_upcall_recall_lease *)gf_up_data->data;
+    tmp->lease_type = recall_lease->lease_type;
+    memcpy(gf_up_data->gfid, recall_lease->gfid, 16);
+    memcpy(tmp->tid, recall_lease->tid, 16);
 
-        GF_PROTOCOL_DICT_UNSERIALIZE (THIS, tmp->dict,
-                                      (recall_lease->xdata).xdata_val,
-                                      (recall_lease->xdata).xdata_len, ret,
-                                      errno, out);
+    GF_PROTOCOL_DICT_UNSERIALIZE(
+        THIS, tmp->dict, (recall_lease->xdata).xdata_val,
+        (recall_lease->xdata).xdata_len, ret, errno, out);
 out:
-        return ret;
-
+    return ret;
 }
 
 static inline int
-gf_proto_recall_lease_from_upcall (xlator_t *this,
-                                   struct gfs3_recall_lease_req *recall_lease,
-                                   struct gf_upcall *gf_up_data)
+gf_proto_recall_lease_from_upcall(xlator_t *this,
+                                  struct gfs3_recall_lease_req *recall_lease,
+                                  struct gf_upcall *gf_up_data)
 {
-        struct gf_upcall_recall_lease *tmp = NULL;
-        int    ret                         = 0;
+    struct gf_upcall_recall_lease *tmp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO(this->name, recall_lease, out);
-        GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+    GF_VALIDATE_OR_GOTO(this->name, recall_lease, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
 
-        tmp = (struct gf_upcall_recall_lease *)gf_up_data->data;
-        recall_lease->lease_type = tmp->lease_type;
-        memcpy (recall_lease->gfid, gf_up_data->gfid, 16);
-        memcpy (recall_lease->tid, tmp->tid, 16);
+    tmp = (struct gf_upcall_recall_lease *)gf_up_data->data;
+    recall_lease->lease_type = tmp->lease_type;
+    memcpy(recall_lease->gfid, gf_up_data->gfid, 16);
+    memcpy(recall_lease->tid, tmp->tid, 16);
 
-        GF_PROTOCOL_DICT_SERIALIZE (this, tmp->dict,
-                                    &(recall_lease->xdata).xdata_val,
-                                    (recall_lease->xdata).xdata_len, ret, out);
+    GF_PROTOCOL_DICT_SERIALIZE(this, tmp->dict,
+                               &(recall_lease->xdata).xdata_val,
+                               (recall_lease->xdata).xdata_len, ret, out);
 out:
-        return ret;
-
+    return ret;
 }
 
 static inline void
-gf_proto_flock_to_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock *gf_flock)
+gf_proto_flock_to_flock(struct gf_proto_flock *gf_proto_flock,
+                        struct gf_flock *gf_flock)
 {
-        if (!gf_flock || !gf_proto_flock)
-                return;
-
-	gf_flock->l_type     = gf_proto_flock->type;
-	gf_flock->l_whence   = gf_proto_flock->whence;
-	gf_flock->l_start    = gf_proto_flock->start;
-	gf_flock->l_len      = gf_proto_flock->len;
-	gf_flock->l_pid      = gf_proto_flock->pid;
-        gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len;
-        if (gf_flock->l_owner.len &&
-            (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN))
-                memcpy (gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val,
-                        gf_flock->l_owner.len);
+    if (!gf_flock || !gf_proto_flock)
+        return;
+
+    gf_flock->l_type = gf_proto_flock->type;
+    gf_flock->l_whence = gf_proto_flock->whence;
+    gf_flock->l_start = gf_proto_flock->start;
+    gf_flock->l_len = gf_proto_flock->len;
+    gf_flock->l_pid = gf_proto_flock->pid;
+    gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len;
+    if (gf_flock->l_owner.len &&
+        (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN))
+        memcpy(gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val,
+               gf_flock->l_owner.len);
 }
 
+static inline void
+gf_proto_flock_from_flock(struct gf_proto_flock *gf_proto_flock,
+                          struct gf_flock *gf_flock)
+{
+    if (!gf_flock || !gf_proto_flock)
+        return;
+
+    gf_proto_flock->type = (gf_flock->l_type);
+    gf_proto_flock->whence = (gf_flock->l_whence);
+    gf_proto_flock->start = (gf_flock->l_start);
+    gf_proto_flock->len = (gf_flock->l_len);
+    gf_proto_flock->pid = (gf_flock->l_pid);
+    gf_proto_flock->lk_owner.lk_owner_len = gf_flock->l_owner.len;
+    if (gf_flock->l_owner.len)
+        gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data;
+}
 
 static inline void
-gf_proto_flock_from_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock *gf_flock)
+gf_stat_to_iatt(struct gf_iatt *gf_stat, struct iatt *iatt)
 {
-        if (!gf_flock || !gf_proto_flock)
-                return;
-
-	gf_proto_flock->type     =  (gf_flock->l_type);
-	gf_proto_flock->whence   =  (gf_flock->l_whence);
-	gf_proto_flock->start    =  (gf_flock->l_start);
-	gf_proto_flock->len      =  (gf_flock->l_len);
-	gf_proto_flock->pid      =  (gf_flock->l_pid);
-	gf_proto_flock->lk_owner.lk_owner_len =  gf_flock->l_owner.len;
-        if (gf_flock->l_owner.len)
-                gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data;
+    if (!iatt || !gf_stat)
+        return;
+
+    memcpy(iatt->ia_gfid, gf_stat->ia_gfid, 16);
+    iatt->ia_ino = gf_stat->ia_ino;
+    iatt->ia_dev = gf_stat->ia_dev;
+    iatt->ia_type = ia_type_from_st_mode(gf_stat->mode);
+    iatt->ia_prot = ia_prot_from_st_mode(gf_stat->mode);
+    iatt->ia_nlink = gf_stat->ia_nlink;
+    iatt->ia_uid = gf_stat->ia_uid;
+    iatt->ia_gid = gf_stat->ia_gid;
+    iatt->ia_rdev = gf_stat->ia_rdev;
+    iatt->ia_size = gf_stat->ia_size;
+    iatt->ia_blksize = gf_stat->ia_blksize;
+    iatt->ia_blocks = gf_stat->ia_blocks;
+    iatt->ia_atime = gf_stat->ia_atime;
+    iatt->ia_atime_nsec = gf_stat->ia_atime_nsec;
+    iatt->ia_mtime = gf_stat->ia_mtime;
+    iatt->ia_mtime_nsec = gf_stat->ia_mtime_nsec;
+    iatt->ia_ctime = gf_stat->ia_ctime;
+    iatt->ia_ctime_nsec = gf_stat->ia_ctime_nsec;
 }
 
 static inline void
-gf_stat_to_iatt (struct gf_iatt *gf_stat, struct iatt *iatt)
+gf_stat_from_iatt(struct gf_iatt *gf_stat, struct iatt *iatt)
 {
-        if (!iatt || !gf_stat)
-                return;
-
-        memcpy (iatt->ia_gfid, gf_stat->ia_gfid, 16);
-	iatt->ia_ino = gf_stat->ia_ino ;
-	iatt->ia_dev = gf_stat->ia_dev ;
-	iatt->ia_type = ia_type_from_st_mode (gf_stat->mode) ;
-	iatt->ia_prot = ia_prot_from_st_mode (gf_stat->mode) ;
-	iatt->ia_nlink = gf_stat->ia_nlink ;
-	iatt->ia_uid = gf_stat->ia_uid ;
-	iatt->ia_gid = gf_stat->ia_gid ;
-	iatt->ia_rdev = gf_stat->ia_rdev ;
-	iatt->ia_size = gf_stat->ia_size ;
-	iatt->ia_blksize = gf_stat->ia_blksize ;
-	iatt->ia_blocks = gf_stat->ia_blocks ;
-	iatt->ia_atime = gf_stat->ia_atime ;
-	iatt->ia_atime_nsec = gf_stat->ia_atime_nsec ;
-	iatt->ia_mtime = gf_stat->ia_mtime ;
-	iatt->ia_mtime_nsec = gf_stat->ia_mtime_nsec ;
-	iatt->ia_ctime = gf_stat->ia_ctime ;
-	iatt->ia_ctime_nsec = gf_stat->ia_ctime_nsec ;
+    if (!iatt || !gf_stat)
+        return;
+
+    memcpy(gf_stat->ia_gfid, iatt->ia_gfid, 16);
+    gf_stat->ia_ino = iatt->ia_ino;
+    gf_stat->ia_dev = iatt->ia_dev;
+    gf_stat->mode = st_mode_from_ia(iatt->ia_prot, iatt->ia_type);
+    gf_stat->ia_nlink = iatt->ia_nlink;
+    gf_stat->ia_uid = iatt->ia_uid;
+    gf_stat->ia_gid = iatt->ia_gid;
+    gf_stat->ia_rdev = iatt->ia_rdev;
+    gf_stat->ia_size = iatt->ia_size;
+    gf_stat->ia_blksize = iatt->ia_blksize;
+    gf_stat->ia_blocks = iatt->ia_blocks;
+    gf_stat->ia_atime = iatt->ia_atime;
+    gf_stat->ia_atime_nsec = iatt->ia_atime_nsec;
+    gf_stat->ia_mtime = iatt->ia_mtime;
+    gf_stat->ia_mtime_nsec = iatt->ia_mtime_nsec;
+    gf_stat->ia_ctime = iatt->ia_ctime;
+    gf_stat->ia_ctime_nsec = iatt->ia_ctime_nsec;
 }
 
+static inline int
+gf_proto_cache_invalidation_from_upcall(
+    xlator_t *this, gfs3_cbk_cache_invalidation_req *gf_c_req,
+    struct gf_upcall *gf_up_data)
+{
+    struct gf_upcall_cache_invalidation *gf_c_data = NULL;
+    int is_cache_inval = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+
+    is_cache_inval = ((gf_up_data->event_type == GF_UPCALL_CACHE_INVALIDATION)
+                          ? 1
+                          : 0);
+    GF_VALIDATE_OR_GOTO(this->name, is_cache_inval, out);
+
+    gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data;
+    GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out);
+
+    gf_c_req->gfid = uuid_utoa(gf_up_data->gfid);
+    gf_c_req->event_type = gf_up_data->event_type;
+    gf_c_req->flags = gf_c_data->flags;
+    gf_c_req->expire_time_attr = gf_c_data->expire_time_attr;
+    gf_stat_from_iatt(&gf_c_req->stat, &gf_c_data->stat);
+    gf_stat_from_iatt(&gf_c_req->parent_stat, &gf_c_data->p_stat);
+    gf_stat_from_iatt(&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat);
+
+    ret = 0;
+    GF_PROTOCOL_DICT_SERIALIZE(this, gf_c_data->dict,
+                               &(gf_c_req->xdata).xdata_val,
+                               (gf_c_req->xdata).xdata_len, ret, out);
+out:
+    return ret;
+}
 
-static inline void
-gf_stat_from_iatt (struct gf_iatt *gf_stat, struct iatt *iatt)
+static inline int
+gf_proto_cache_invalidation_to_upcall(xlator_t *this,
+                                      gfs3_cbk_cache_invalidation_req *gf_c_req,
+                                      struct gf_upcall *gf_up_data)
 {
-        if (!iatt || !gf_stat)
-                return;
-
-        memcpy (gf_stat->ia_gfid, iatt->ia_gfid, 16);
-	gf_stat->ia_ino = iatt->ia_ino ;
-	gf_stat->ia_dev = iatt->ia_dev ;
-	gf_stat->mode   = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
-	gf_stat->ia_nlink = iatt->ia_nlink ;
-	gf_stat->ia_uid = iatt->ia_uid ;
-	gf_stat->ia_gid = iatt->ia_gid ;
-	gf_stat->ia_rdev = iatt->ia_rdev ;
-	gf_stat->ia_size = iatt->ia_size ;
-	gf_stat->ia_blksize = iatt->ia_blksize ;
-	gf_stat->ia_blocks = iatt->ia_blocks ;
-	gf_stat->ia_atime = iatt->ia_atime ;
-	gf_stat->ia_atime_nsec = iatt->ia_atime_nsec ;
-	gf_stat->ia_mtime = iatt->ia_mtime ;
-	gf_stat->ia_mtime_nsec = iatt->ia_mtime_nsec ;
-	gf_stat->ia_ctime = iatt->ia_ctime ;
-	gf_stat->ia_ctime_nsec = iatt->ia_ctime_nsec ;
+    struct gf_upcall_cache_invalidation *gf_c_data = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+
+    gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data;
+    GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out);
+
+    ret = gf_uuid_parse(gf_c_req->gfid, gf_up_data->gfid);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "gf_uuid_parse(%s) failed",
+               gf_c_req->gfid);
+        gf_up_data->event_type = GF_UPCALL_EVENT_NULL;
+        goto out;
+    }
+
+    gf_up_data->event_type = gf_c_req->event_type;
+
+    gf_c_data->flags = gf_c_req->flags;
+    gf_c_data->expire_time_attr = gf_c_req->expire_time_attr;
+    gf_stat_to_iatt(&gf_c_req->stat, &gf_c_data->stat);
+    gf_stat_to_iatt(&gf_c_req->parent_stat, &gf_c_data->p_stat);
+    gf_stat_to_iatt(&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat);
+
+    ret = 0;
+    GF_PROTOCOL_DICT_UNSERIALIZE(this, gf_c_data->dict,
+                                 (gf_c_req->xdata).xdata_val,
+                                 (gf_c_req->xdata).xdata_len, ret, ret, out);
+
+    /* If no dict was sent, create an empty dict, so that each xlator
+     * need not check if empty then create new dict. Will be unref'd by the
+     * caller */
+    if (!gf_c_data->dict)
+        gf_c_data->dict = dict_new();
+out:
+    return ret;
 }
 
 static inline int
-gf_proto_cache_invalidation_from_upcall (xlator_t *this,
-                                         gfs3_cbk_cache_invalidation_req *gf_c_req,
-                                         struct gf_upcall *gf_up_data)
+gf_proto_inodelk_contention_to_upcall(struct gfs4_inodelk_contention_req *lc,
+                                      struct gf_upcall *gf_up_data)
 {
-        struct gf_upcall_cache_invalidation *gf_c_data = NULL;
-        int    is_cache_inval                          = 0;
-        int    ret                                     = -1;
+    struct gf_upcall_inodelk_contention *tmp = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out);
-        GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+    this = THIS;
 
-        is_cache_inval = ((gf_up_data->event_type ==
-                          GF_UPCALL_CACHE_INVALIDATION) ? 1 : 0);
-        GF_VALIDATE_OR_GOTO(this->name, is_cache_inval, out);
+    GF_VALIDATE_OR_GOTO(this->name, lc, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
 
-        gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data;
-        GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out);
+    tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data;
 
-        gf_c_req->gfid = uuid_utoa (gf_up_data->gfid);
-        gf_c_req->event_type       = gf_up_data->event_type;
-        gf_c_req->flags            = gf_c_data->flags;
-        gf_c_req->expire_time_attr = gf_c_data->expire_time_attr;
-        gf_stat_from_iatt (&gf_c_req->stat, &gf_c_data->stat);
-        gf_stat_from_iatt (&gf_c_req->parent_stat, &gf_c_data->p_stat);
-        gf_stat_from_iatt (&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat);
+    gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid);
+
+    gf_proto_flock_to_flock(&lc->flock, &tmp->flock);
+    tmp->pid = lc->pid;
+    tmp->domain = lc->domain;
+    if ((tmp->domain != NULL) && (*tmp->domain == 0)) {
+        tmp->domain = NULL;
+    }
+
+    GF_PROTOCOL_DICT_UNSERIALIZE(this, tmp->xdata, lc->xdata.xdata_val,
+                                 lc->xdata.xdata_len, ret, op_errno, out);
+
+    ret = 0;
 
-        ret = 0;
-        GF_PROTOCOL_DICT_SERIALIZE (this, gf_c_data->dict, &(gf_c_req->xdata).xdata_val,
-                                    (gf_c_req->xdata).xdata_len, ret, out);
 out:
-        return ret;
+    if (ret < 0) {
+        ret = -op_errno;
+    }
+
+    return ret;
 }
 
 static inline int
-gf_proto_cache_invalidation_to_upcall (xlator_t *this,
-                                       gfs3_cbk_cache_invalidation_req *gf_c_req,
-                                       struct gf_upcall *gf_up_data)
+gf_proto_inodelk_contention_from_upcall(xlator_t *this,
+                                        struct gfs4_inodelk_contention_req *lc,
+                                        struct gf_upcall *gf_up_data)
 {
-        struct gf_upcall_cache_invalidation *gf_c_data = NULL;
-        int    ret                                     = -1;
+    struct gf_upcall_inodelk_contention *tmp = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out);
-        GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+    GF_VALIDATE_OR_GOTO(this->name, lc, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
 
-        gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data;
-        GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out);
+    tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data;
 
-        ret = gf_uuid_parse (gf_c_req->gfid, gf_up_data->gfid);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING, "gf_uuid_parse(%s) failed",
-                        gf_c_req->gfid);
-                gf_up_data->event_type = GF_UPCALL_EVENT_NULL;
-                goto out;
+    gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid);
+
+    gf_proto_flock_from_flock(&lc->flock, &tmp->flock);
+    lc->pid = tmp->pid;
+    lc->domain = (char *)tmp->domain;
+    if (lc->domain == NULL) {
+        lc->domain = "";
+    }
+
+    GF_PROTOCOL_DICT_SERIALIZE(this, tmp->xdata, &lc->xdata.xdata_val,
+                               lc->xdata.xdata_len, op_errno, out);
+
+    ret = 0;
+
+out:
+    if (ret < 0) {
+        ret = -op_errno;
+    }
+
+    return ret;
+}
+
+static inline int
+gf_proto_entrylk_contention_to_upcall(struct gfs4_entrylk_contention_req *lc,
+                                      struct gf_upcall *gf_up_data)
+{
+    struct gf_upcall_entrylk_contention *tmp = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
+
+    this = THIS;
+
+    GF_VALIDATE_OR_GOTO(this->name, lc, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+
+    tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data;
+
+    gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid);
+
+    tmp->type = lc->type;
+    tmp->name = lc->name;
+    if ((tmp->name != NULL) && (*tmp->name == 0)) {
+        tmp->name = NULL;
+    }
+    tmp->pid = lc->pid;
+    tmp->domain = lc->domain;
+    if ((tmp->domain != NULL) && (*tmp->domain == 0)) {
+        tmp->domain = NULL;
+    }
+
+    GF_PROTOCOL_DICT_UNSERIALIZE(this, tmp->xdata, lc->xdata.xdata_val,
+                                 lc->xdata.xdata_len, ret, op_errno, out);
+
+    ret = 0;
+
+out:
+    if (ret < 0) {
+        ret = -op_errno;
+    }
+
+    return ret;
+}
+
+static inline int
+gf_proto_entrylk_contention_from_upcall(xlator_t *this,
+                                        struct gfs4_entrylk_contention_req *lc,
+                                        struct gf_upcall *gf_up_data)
+{
+    struct gf_upcall_entrylk_contention *tmp = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
+
+    GF_VALIDATE_OR_GOTO(this->name, lc, out);
+    GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out);
+
+    tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data;
+
+    gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid);
+
+    lc->type = tmp->type;
+    lc->name = (char *)tmp->name;
+    if (lc->name == NULL) {
+        lc->name = "";
+    }
+    lc->pid = tmp->pid;
+    lc->domain = (char *)tmp->domain;
+    if (lc->domain == NULL) {
+        lc->domain = "";
+    }
+
+    GF_PROTOCOL_DICT_SERIALIZE(this, tmp->xdata, &lc->xdata.xdata_val,
+                               lc->xdata.xdata_len, op_errno, out);
+
+    ret = 0;
+
+out:
+    if (ret < 0) {
+        ret = -op_errno;
+    }
+
+    return ret;
+}
+
+static inline void
+gfx_mdata_iatt_to_mdata_iatt(struct gfx_mdata_iatt *gf_mdata_iatt,
+                             struct mdata_iatt *mdata_iatt)
+{
+    if (!mdata_iatt || !gf_mdata_iatt)
+        return;
+    mdata_iatt->ia_atime = gf_mdata_iatt->ia_atime;
+    mdata_iatt->ia_atime_nsec = gf_mdata_iatt->ia_atime_nsec;
+    mdata_iatt->ia_mtime = gf_mdata_iatt->ia_mtime;
+    mdata_iatt->ia_mtime_nsec = gf_mdata_iatt->ia_mtime_nsec;
+    mdata_iatt->ia_ctime = gf_mdata_iatt->ia_ctime;
+    mdata_iatt->ia_ctime_nsec = gf_mdata_iatt->ia_ctime_nsec;
+}
+
+static inline void
+gfx_mdata_iatt_from_mdata_iatt(struct gfx_mdata_iatt *gf_mdata_iatt,
+                               struct mdata_iatt *mdata_iatt)
+{
+    if (!mdata_iatt || !gf_mdata_iatt)
+        return;
+    gf_mdata_iatt->ia_atime = mdata_iatt->ia_atime;
+    gf_mdata_iatt->ia_atime_nsec = mdata_iatt->ia_atime_nsec;
+    gf_mdata_iatt->ia_mtime = mdata_iatt->ia_mtime;
+    gf_mdata_iatt->ia_mtime_nsec = mdata_iatt->ia_mtime_nsec;
+    gf_mdata_iatt->ia_ctime = mdata_iatt->ia_ctime;
+    gf_mdata_iatt->ia_ctime_nsec = mdata_iatt->ia_ctime_nsec;
+}
+
+static inline void
+gfx_stat_to_iattx(struct gfx_iattx *gf_stat, struct iatt *iatt)
+{
+    if (!iatt || !gf_stat)
+        return;
+
+    memcpy(iatt->ia_gfid, gf_stat->ia_gfid, 16);
+
+    iatt->ia_flags = gf_stat->ia_flags;
+    iatt->ia_ino = gf_stat->ia_ino;
+    iatt->ia_dev = gf_stat->ia_dev;
+    iatt->ia_rdev = gf_stat->ia_rdev;
+    iatt->ia_size = gf_stat->ia_size;
+    iatt->ia_nlink = gf_stat->ia_nlink;
+    iatt->ia_uid = gf_stat->ia_uid;
+    iatt->ia_gid = gf_stat->ia_gid;
+    iatt->ia_blksize = gf_stat->ia_blksize;
+    iatt->ia_blocks = gf_stat->ia_blocks;
+    iatt->ia_atime = gf_stat->ia_atime;
+    iatt->ia_atime_nsec = gf_stat->ia_atime_nsec;
+    iatt->ia_mtime = gf_stat->ia_mtime;
+    iatt->ia_mtime_nsec = gf_stat->ia_mtime_nsec;
+    iatt->ia_ctime = gf_stat->ia_ctime;
+    iatt->ia_ctime_nsec = gf_stat->ia_ctime_nsec;
+    iatt->ia_btime = gf_stat->ia_btime;
+    iatt->ia_btime_nsec = gf_stat->ia_btime_nsec;
+    iatt->ia_attributes = gf_stat->ia_attributes;
+    iatt->ia_attributes_mask = gf_stat->ia_attributes_mask;
+
+    iatt->ia_type = ia_type_from_st_mode(gf_stat->mode);
+    iatt->ia_prot = ia_prot_from_st_mode(gf_stat->mode);
+}
+
+static inline void
+gfx_stat_from_iattx(struct gfx_iattx *gf_stat, struct iatt *iatt)
+{
+    if (!iatt || !gf_stat)
+        return;
+
+    memcpy(gf_stat->ia_gfid, iatt->ia_gfid, 16);
+    gf_stat->ia_ino = iatt->ia_ino;
+    gf_stat->ia_dev = iatt->ia_dev;
+
+    gf_stat->ia_nlink = iatt->ia_nlink;
+    gf_stat->ia_uid = iatt->ia_uid;
+    gf_stat->ia_gid = iatt->ia_gid;
+    gf_stat->ia_rdev = iatt->ia_rdev;
+    gf_stat->ia_size = iatt->ia_size;
+    gf_stat->ia_blksize = iatt->ia_blksize;
+    gf_stat->ia_blocks = iatt->ia_blocks;
+    gf_stat->ia_atime = iatt->ia_atime;
+    gf_stat->ia_atime_nsec = iatt->ia_atime_nsec;
+    gf_stat->ia_mtime = iatt->ia_mtime;
+    gf_stat->ia_mtime_nsec = iatt->ia_mtime_nsec;
+    gf_stat->ia_ctime = iatt->ia_ctime;
+    gf_stat->ia_ctime_nsec = iatt->ia_ctime_nsec;
+
+    gf_stat->ia_flags = iatt->ia_flags;
+    gf_stat->ia_btime = iatt->ia_btime;
+    gf_stat->ia_btime_nsec = iatt->ia_btime_nsec;
+    gf_stat->ia_attributes = iatt->ia_attributes;
+    gf_stat->ia_attributes_mask = iatt->ia_attributes_mask;
+
+    gf_stat->mode = st_mode_from_ia(iatt->ia_prot, iatt->ia_type);
+}
+
+/* dict_to_xdr () */
+static inline int
+dict_to_xdr(dict_t *this, gfx_dict *dict)
+{
+    int ret = -1;
+    int i = 0;
+    int index = 0;
+    data_pair_t *dpair = NULL;
+    gfx_dict_pair *xpair = NULL;
+    ssize_t size = 0;
+
+    /* This is a failure as we expect destination to be valid */
+    if (!dict)
+        goto out;
+
+    /* This is OK as dictionary can be null, in which case, destination
+       should also know that it is NULL. */
+    if (!this) {
+        /* encode special meaning data here,
+           while decoding, you know it is NULL dict */
+        dict->count = -1;
+        /* everything else is normal */
+        dict->pairs.pairs_len = 0;
+        ret = 0;
+        goto out;
+    }
+
+    /* Do the whole operation in locked region */
+    LOCK(&this->lock);
+
+    dict->pairs.pairs_val = GF_CALLOC(1, (this->count * sizeof(gfx_dict_pair)),
+                                      gf_common_mt_char);
+    if (!dict->pairs.pairs_val)
+        goto out;
+
+    dpair = this->members_list;
+    for (i = 0; i < this->count; i++) {
+        xpair = &dict->pairs.pairs_val[index];
+
+        xpair->key.key_val = dpair->key;
+        xpair->key.key_len = strlen(dpair->key) + 1;
+        xpair->value.type = dpair->value->data_type;
+        switch (dpair->value->data_type) {
+                /* Add more type here */
+            case GF_DATA_TYPE_INT:
+                index++;
+                xpair->value.gfx_value_u.value_int = strtoll(dpair->value->data,
+                                                             NULL, 0);
+                break;
+            case GF_DATA_TYPE_UINT:
+                index++;
+                xpair->value.gfx_value_u.value_uint = strtoull(
+                    dpair->value->data, NULL, 0);
+                break;
+            case GF_DATA_TYPE_DOUBLE:
+                index++;
+                xpair->value.gfx_value_u.value_dbl = strtod(dpair->value->data,
+                                                            NULL);
+                break;
+            case GF_DATA_TYPE_STR:
+                index++;
+                xpair->value.gfx_value_u.val_string
+                    .val_string_val = dpair->value->data;
+                xpair->value.gfx_value_u.val_string
+                    .val_string_len = dpair->value->len;
+                break;
+            case GF_DATA_TYPE_IATT:
+                index++;
+                gfx_stat_from_iattx(&xpair->value.gfx_value_u.iatt,
+                                    (struct iatt *)dpair->value->data);
+                break;
+            case GF_DATA_TYPE_MDATA:
+                index++;
+                gfx_mdata_iatt_from_mdata_iatt(
+                    &xpair->value.gfx_value_u.mdata_iatt,
+                    (struct mdata_iatt *)dpair->value->data);
+                break;
+            case GF_DATA_TYPE_GFUUID:
+                index++;
+                memcpy(&xpair->value.gfx_value_u.uuid, dpair->value->data,
+                       sizeof(uuid_t));
+                break;
+
+            case GF_DATA_TYPE_PTR:
+            case GF_DATA_TYPE_STR_OLD:
+                index++;
+                /* Ideally, each type of data stored in dictionary
+                   should have type. A pointer type shouldn't be
+                   sent on wire */
+
+                /* This is done for backward compatibility as dict is
+                   heavily used for transporting data over wire.
+                   Ideally, wherever there is an issue, fix and
+                   move on */
+                xpair->value.gfx_value_u.other.other_val = dpair->value->data;
+                xpair->value.gfx_value_u.other.other_len = dpair->value->len;
+
+                /* Change this to INFO, after taking the above down */
+                gf_msg("dict", GF_LOG_DEBUG, EINVAL, LG_MSG_DICT_SERIAL_FAILED,
+                       "key '%s' would not be sent on wire in the future",
+                       dpair->key);
+                break;
+            default:
+                /* Unknown type and ptr type is not sent on wire */
+                gf_msg("dict", GF_LOG_WARNING, EINVAL,
+                       LG_MSG_DICT_SERIAL_FAILED,
+                       "key '%s' is not sent on wire", dpair->key);
+                break;
         }
+        dpair = dpair->next;
+    }
 
-        gf_up_data->event_type      = gf_c_req->event_type;
+    dict->pairs.pairs_len = index;
+    dict->count = index;
 
-        gf_c_data->flags            = gf_c_req->flags;
-        gf_c_data->expire_time_attr = gf_c_req->expire_time_attr;
-        gf_stat_to_iatt (&gf_c_req->stat, &gf_c_data->stat);
-        gf_stat_to_iatt (&gf_c_req->parent_stat, &gf_c_data->p_stat);
-        gf_stat_to_iatt (&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat);
+    /* This is required mainly in the RPC layer to understand the
+       boundary for proper payload. Hence only send the size of
+       variable XDR size. ie, the formula should be:
+       xdr_size = total size - (xdr_size + count + pairs.pairs_len))  */
+    size = xdr_sizeof((xdrproc_t)xdr_gfx_dict, dict);
+
+    dict->xdr_size = (size > 12) ? (size - 12) : 0;
+
+    ret = 0;
+out:
+    /* this can be null here, so unlock only if its not null */
+    if (this)
+        UNLOCK(&this->lock);
+
+    return ret;
+}
 
+static inline int
+xdr_to_dict(gfx_dict *dict, dict_t **to)
+{
+    int ret = -1;
+    int index = 0;
+    char *key = NULL;
+    char *value = NULL;
+    gfx_dict_pair *xpair = NULL;
+    dict_t *this = NULL;
+    unsigned char *uuid = NULL;
+    struct iatt *iatt = NULL;
+    struct mdata_iatt *mdata_iatt = NULL;
+
+    if (!to || !dict)
+        goto out;
+
+    if (dict->count < 0) {
+        /* indicates NULL dict was passed for encoding */
         ret = 0;
-        GF_PROTOCOL_DICT_UNSERIALIZE (this, gf_c_data->dict,
-                                      (gf_c_req->xdata).xdata_val,
-                                      (gf_c_req->xdata).xdata_len, ret,
-                                      ret, out);
-
-        /* If no dict was sent, create an empty dict, so that each xlator
-         * need not check if empty then create new dict. Will be unref'd by the
-         * caller */
-        if (!gf_c_data->dict)
-                gf_c_data->dict = dict_new ();
-  out:
-        return ret;
+        goto out;
+    }
+
+    this = dict_new();
+    if (!this)
+        goto out;
+
+    for (index = 0; index < dict->pairs.pairs_len; index++) {
+        ret = -1;
+        xpair = &dict->pairs.pairs_val[index];
+
+        key = xpair->key.key_val;
+        switch (xpair->value.type) {
+                /* Add more type here */
+            case GF_DATA_TYPE_INT:
+                ret = dict_set_int64(this, key,
+                                     xpair->value.gfx_value_u.value_int);
+                break;
+            case GF_DATA_TYPE_UINT:
+                ret = dict_set_uint64(this, key,
+                                      xpair->value.gfx_value_u.value_uint);
+                break;
+            case GF_DATA_TYPE_DOUBLE:
+                ret = dict_set_double(this, key,
+                                      xpair->value.gfx_value_u.value_dbl);
+                break;
+            case GF_DATA_TYPE_STR:
+                value = GF_MALLOC(
+                    xpair->value.gfx_value_u.val_string.val_string_len + 1,
+                    gf_common_mt_char);
+                if (!value) {
+                    errno = ENOMEM;
+                    goto out;
+                }
+                memcpy(value,
+                       xpair->value.gfx_value_u.val_string.val_string_val,
+                       xpair->value.gfx_value_u.val_string.val_string_len);
+                value[xpair->value.gfx_value_u.val_string.val_string_len] =
+                    '\0';
+                free(xpair->value.gfx_value_u.val_string.val_string_val);
+                ret = dict_set_dynstr(this, key, value);
+                break;
+            case GF_DATA_TYPE_GFUUID:
+                uuid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t);
+                if (!uuid) {
+                    errno = ENOMEM;
+                    goto out;
+                }
+                memcpy(uuid, xpair->value.gfx_value_u.uuid, sizeof(uuid_t));
+                ret = dict_set_gfuuid(this, key, uuid, false);
+                break;
+            case GF_DATA_TYPE_IATT:
+                iatt = GF_CALLOC(1, sizeof(struct iatt), gf_common_mt_char);
+                if (!iatt) {
+                    errno = ENOMEM;
+                    goto out;
+                }
+                gfx_stat_to_iattx(&xpair->value.gfx_value_u.iatt, iatt);
+                ret = dict_set_iatt(this, key, iatt, false);
+                break;
+            case GF_DATA_TYPE_MDATA:
+                mdata_iatt = GF_CALLOC(1, sizeof(struct mdata_iatt),
+                                       gf_common_mt_char);
+                if (!mdata_iatt) {
+                    errno = ENOMEM;
+                    gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                           "failed to allocate memory. key: %s", key);
+                    ret = -1;
+                    goto out;
+                }
+                gfx_mdata_iatt_to_mdata_iatt(
+                    &xpair->value.gfx_value_u.mdata_iatt, mdata_iatt);
+                ret = dict_set_mdata(this, key, mdata_iatt, false);
+                if (ret != 0) {
+                    GF_FREE(mdata_iatt);
+                    gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM,
+                           LG_MSG_DICT_SET_FAILED,
+                           "failed to set the key (%s)"
+                           " into dict",
+                           key);
+                    ret = -1;
+                    goto out;
+                }
+                break;
+            case GF_DATA_TYPE_PTR:
+            case GF_DATA_TYPE_STR_OLD:
+                value = GF_MALLOC(xpair->value.gfx_value_u.other.other_len + 1,
+                                  gf_common_mt_char);
+                if (!value) {
+                    errno = ENOMEM;
+                    goto out;
+                }
+                memcpy(value, xpair->value.gfx_value_u.other.other_val,
+                       xpair->value.gfx_value_u.other.other_len);
+                value[xpair->value.gfx_value_u.other.other_len] = '\0';
+                free(xpair->value.gfx_value_u.other.other_val);
+                ret = dict_set_dynptr(this, key, value,
+                                      xpair->value.gfx_value_u.other.other_len);
+                break;
+            default:
+                ret = 0;
+                /* Unknown type and ptr type is not sent on wire */
+                break;
+        }
+        if (ret) {
+            gf_msg_debug(THIS->name, ENOMEM,
+                         "failed to set the key (%s) into dict", key);
+        }
+        free(xpair->key.key_val);
+    }
+
+    free(dict->pairs.pairs_val);
+    ret = 0;
+
+    /* If everything is fine, assign the dictionary to target */
+    *to = this;
+    this = NULL;
+
+out:
+    if (this)
+        dict_unref(this);
+
+    return ret;
 }
+
 #endif /* !_GLUSTERFS3_H */
diff --git a/rpc/xdr/src/glusterfs4-xdr.x b/rpc/xdr/src/glusterfs4-xdr.x
new file mode 100644
index 00000000000..d3b1d0dfaf0
--- /dev/null
+++ b/rpc/xdr/src/glusterfs4-xdr.x
@@ -0,0 +1,797 @@
+/*
+ * Copyright (c) 2012 Red Hat, Inc. <http://www.redhat.com>
+ * This file is part of GlusterFS.
+ *
+ * This file is licensed to you under your choice of the GNU Lesser
+ * General Public License, version 3 or any later version (LGPLv3 or
+ * later), or the GNU General Public License, version 2 (GPLv2), in all
+ * cases as published by the Free Software Foundation.
+ */
+
+#ifdef RPC_XDR
+%#include "rpc-pragmas.h"
+#endif
+%#include <glusterfs/glusterfs-fops.h>
+%#include "glusterfs3-xdr.h"
+
+/* Need to consume iattx and new dict in all the fops */
+struct gfx_iattx {
+        opaque       ia_gfid[16];
+
+        unsigned hyper     ia_flags;
+        unsigned hyper     ia_ino;        /* inode number */
+        unsigned hyper     ia_dev;        /* backing device ID */
+        unsigned hyper     ia_rdev;       /* device ID (if special file) */
+        unsigned hyper     ia_size;       /* file size in bytes */
+        unsigned hyper     ia_blocks;     /* number of 512B blocks allocated */
+        unsigned hyper     ia_attributes; /* chattr related:compressed, immutable,
+                                     * append only, encrypted etc.*/
+        unsigned hyper     ia_attributes_mask; /* Mask for the attributes */
+
+        hyper      ia_atime;      /* last access time */
+        hyper      ia_mtime;      /* last modification time */
+        hyper      ia_ctime;      /* last status change time */
+        hyper      ia_btime;      /* creation time. Fill using statx */
+
+        unsigned int     ia_atime_nsec;
+        unsigned int     ia_mtime_nsec;
+        unsigned int     ia_ctime_nsec;
+        unsigned int     ia_btime_nsec;
+        unsigned int     ia_nlink;      /* Link count */
+        unsigned int     ia_uid;        /* user ID of owner */
+        unsigned int     ia_gid;        /* group ID of owner */
+        unsigned int     ia_blksize;    /* blocksize for filesystem I/O */
+        unsigned int     mode;          /* type of file and rwx mode */
+};
+
+struct gfx_mdata_iatt {
+        hyper      ia_atime;      /* last access time */
+        hyper      ia_mtime;      /* last modification time */
+        hyper      ia_ctime;      /* last status change time */
+
+        unsigned int     ia_atime_nsec;
+        unsigned int     ia_mtime_nsec;
+        unsigned int     ia_ctime_nsec;
+};
+
+union gfx_value switch (int type) {
+        case GF_DATA_TYPE_INT:
+                hyper value_int;
+        case GF_DATA_TYPE_UINT:
+                unsigned hyper value_uint;
+        case GF_DATA_TYPE_DOUBLE:
+                double value_dbl;
+        case GF_DATA_TYPE_STR:
+                opaque val_string<>;
+        case GF_DATA_TYPE_IATT:
+                gfx_iattx iatt;
+        case GF_DATA_TYPE_GFUUID:
+                opaque uuid[16];
+        case GF_DATA_TYPE_PTR:
+        case GF_DATA_TYPE_STR_OLD:
+                opaque other<>;
+        case GF_DATA_TYPE_MDATA:
+                gfx_mdata_iatt mdata_iatt;
+};
+
+/* AUTH */
+/* This is used in the rpc header part itself, And not program payload.
+   Avoid sending large data load here. Allowed maximum is 400 bytes.
+   Ref: http://tools.ietf.org/html/rfc5531#section-8.2
+   this is also handled in xdr-common.h
+*/
+struct auth_glusterfs_params_v3 {
+        int pid;
+        unsigned int uid;
+        unsigned int gid;
+
+        /* flags */
+        /* Makes sense to use it for each bits */
+        /* 0x1 == IS_INTERNAL? */
+        /* Another 31 bits are reserved */
+        unsigned int flags;
+
+        /* birth time of the frame / call */
+        unsigned int ctime_nsec; /* good to have 32bit for this */
+        unsigned hyper ctime_sec;
+
+        unsigned int groups<>;
+        opaque lk_owner<>;
+};
+
+struct gfx_dict_pair {
+       opaque key<>;
+       gfx_value value;
+};
+
+struct gfx_dict {
+       unsigned int xdr_size;
+       int count;
+       gfx_dict_pair pairs<>;
+};
+
+/* FOPS */
+struct gfx_common_rsp {
+       int    op_ret;
+       int    op_errno;
+       gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_common_iatt_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       gfx_iattx stat;
+};
+
+struct gfx_common_2iatt_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       gfx_iattx prestat;
+       gfx_iattx poststat;
+};
+
+struct gfx_common_3iatt_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        gfx_iattx preparent;
+        gfx_iattx postparent;
+};
+
+struct gfx_fsetattr_req {
+        opaque gfid[16];
+        hyper        fd;
+        gfx_iattx stbuf;
+        int        valid;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_rchecksum_req {
+        opaque gfid[16];
+        hyper   fd;
+        unsigned hyper  offset;
+        unsigned int  len;
+        unsigned int  flags;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_icreate_req {
+       opaque gfid[16];
+       unsigned int mode;
+       gfx_dict xdata;
+};
+
+struct gfx_put_req {
+        opaque       pargfid[16];
+        string       bname<>;
+        unsigned int mode;
+        unsigned int umask;
+        unsigned int flag;
+        u_quad_t     offset;
+        unsigned int size;
+        gfx_dict     xattr;
+        gfx_dict     xdata;
+};
+
+struct gfx_namelink_req {
+       opaque pargfid[16];
+       string bname<>;
+       gfx_dict xdata;
+};
+
+/* Define every fops */
+/* Changes from Version 3:
+  1. Dict has its own type instead of being opaque
+  2. Iattx instead of iatt on wire
+  3. gfid has 4 extra bytes so it can be used for future
+*/
+struct gfx_stat_req {
+        opaque gfid[16];
+        gfx_dict xdata;
+};
+
+struct gfx_readlink_req {
+        opaque gfid[16];
+        unsigned int   size;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_readlink_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx buf;
+        string path<>; /* NULL terminated */
+};
+
+struct gfx_mknod_req {
+        opaque  pargfid[16];
+        u_quad_t dev;
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct  gfx_mkdir_req {
+        opaque  pargfid[16];
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_unlink_req {
+        opaque  pargfid[16];
+        string     bname<>; /* NULL terminated */
+        unsigned int xflags;
+        gfx_dict xdata; /* Extra data */
+};
+
+
+struct gfx_rmdir_req {
+        opaque  pargfid[16];
+        int        xflags;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_symlink_req {
+        opaque  pargfid[16];
+        string     bname<>;
+        unsigned int umask;
+        string     linkname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct  gfx_rename_req {
+        opaque  oldgfid[16];
+        opaque  newgfid[16];
+        string       oldbname<>; /* NULL terminated */
+        string       newbname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct   gfx_rename_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        gfx_iattx preoldparent;
+        gfx_iattx postoldparent;
+        gfx_iattx prenewparent;
+        gfx_iattx postnewparent;
+};
+
+
+ struct  gfx_link_req {
+        opaque  oldgfid[16];
+        opaque  newgfid[16];
+        string       newbname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct   gfx_truncate_req {
+        opaque gfid[16];
+        u_quad_t offset;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct   gfx_open_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct   gfx_open_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        quad_t fd;
+};
+
+struct gfx_opendir_req {
+        opaque gfid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct   gfx_read_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        unsigned int flag;
+        gfx_dict xdata; /* Extra data */
+};
+ struct  gfx_read_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_iattx stat;
+        unsigned int size;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+struct   gfx_lookup_req {
+        opaque gfid[16];
+        opaque  pargfid[16];
+        unsigned int flags;
+        string     bname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+
+ struct   gfx_write_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        unsigned int flag;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_statfs_req  {
+        opaque gfid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_statfs_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_statfs statfs;
+}  ;
+
+ struct gfx_lk_req {
+        opaque gfid[16];
+        int64_t         fd;
+        unsigned int        cmd;
+        unsigned int        type;
+        gf_proto_flock flock;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_lk_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_proto_flock flock;
+}  ;
+
+struct gfx_lease_req {
+        opaque gfid[16];
+        gf_proto_lease lease;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_lease_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_proto_lease lease;
+}  ;
+
+struct gfx_recall_lease_req {
+        opaque       gfid[16];
+        unsigned int lease_type;
+        opaque       tid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_inodelk_req {
+        opaque gfid[16];
+        unsigned int cmd;
+        unsigned int type;
+        gf_proto_flock flock;
+        string     volume<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct   gfx_finodelk_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int cmd;
+        unsigned int type;
+        gf_proto_flock flock;
+        string volume<>;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+ struct gfx_flush_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fsync_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int data;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_setxattr_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+
+ struct gfx_fsetxattr_req {
+        opaque gfid[16];
+        int64_t  fd;
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+
+ struct gfx_xattrop_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_common_dict_rsp  {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_dict dict;
+        gfx_iattx prestat;
+        gfx_iattx poststat;
+};
+
+
+ struct gfx_fxattrop_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_getxattr_req  {
+        opaque gfid[16];
+        unsigned int namelen;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fgetxattr_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int namelen;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_removexattr_req {
+        opaque gfid[16];
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_fremovexattr_req {
+        opaque gfid[16];
+        quad_t  fd;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fsyncdir_req {
+        opaque gfid[16];
+        quad_t  fd;
+        int  data;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct   gfx_readdir_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_readdirp_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        gfx_dict xdata;
+}  ;
+
+
+struct gfx_access_req  {
+        opaque gfid[16];
+        unsigned int mask;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+struct gfx_create_req {
+        opaque  pargfid[16];
+        unsigned int flags;
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+struct  gfx_create_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        u_quad_t       fd;
+        gfx_iattx preparent;
+        gfx_iattx postparent;
+} ;
+
+struct   gfx_ftruncate_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+struct gfx_fstat_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+struct gfx_entrylk_req {
+        opaque gfid[16];
+        unsigned int  cmd;
+        unsigned int  type;
+        u_quad_t  namelen;
+        string      name<>;
+        string      volume<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_fentrylk_req {
+        opaque gfid[16];
+        quad_t   fd;
+        unsigned int  cmd;
+        unsigned int  type;
+        u_quad_t  namelen;
+        string      name<>;
+        string      volume<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_setattr_req {
+        opaque gfid[16];
+        gfx_iattx stbuf;
+        int        valid;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_fallocate_req {
+        opaque          gfid[16];
+        quad_t          fd;
+        unsigned int    flags;
+        u_quad_t        offset;
+        u_quad_t        size;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_discard_req {
+        opaque          gfid[16];
+        quad_t          fd;
+        u_quad_t        offset;
+        u_quad_t        size;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_zerofill_req {
+        opaque          gfid[16];
+        quad_t           fd;
+        u_quad_t  offset;
+        u_quad_t  size;
+        gfx_dict xdata;
+}  ;
+
+struct gfx_rchecksum_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        unsigned int flags;
+        unsigned int weak_checksum;
+        opaque   strong_checksum<>;
+}  ;
+
+
+struct gfx_ipc_req {
+        int     op;
+        gfx_dict xdata;
+};
+
+
+struct gfx_seek_req {
+        opaque    gfid[16];
+        quad_t    fd;
+        u_quad_t  offset;
+        int       what;
+        gfx_dict xdata;
+};
+
+struct gfx_seek_rsp {
+        int       op_ret;
+        int       op_errno;
+        gfx_dict xdata;
+        u_quad_t  offset;
+};
+
+
+ struct gfx_setvolume_req {
+        gfx_dict dict;
+}  ;
+
+ struct   gfx_copy_file_range_req {
+        opaque gfid1[16];
+        opaque gfid2[16];
+        quad_t  fd_in;
+        quad_t  fd_out;
+        u_quad_t   off_in;
+        u_quad_t   off_out;
+        unsigned int size;
+        unsigned int flag;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct  gfx_setvolume_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict dict;
+} ;
+
+
+ struct gfx_getspec_req {
+        unsigned int flags;
+        string     key<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct  gfx_getspec_rsp {
+        int    op_ret;
+        int    op_errno;
+        string spec<>;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+ struct gfx_notify_req {
+        unsigned int  flags;
+        string buf<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_notify_rsp {
+        int    op_ret;
+        int    op_errno;
+        unsigned int  flags;
+        string buf<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_releasedir_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_release_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_dirlist {
+       u_quad_t d_ino;
+       u_quad_t d_off;
+       unsigned int d_len;
+       unsigned int d_type;
+       string name<>;
+       gfx_dirlist *nextentry;
+};
+
+
+struct gfx_readdir_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata; /* Extra data */
+       gfx_dirlist *reply;
+};
+
+struct gfx_dirplist {
+       u_quad_t d_ino;
+       u_quad_t d_off;
+       unsigned int d_len;
+       unsigned int d_type;
+       string name<>;
+       gfx_iattx stat;
+       gfx_dict dict;
+       gfx_dirplist *nextentry;
+};
+
+struct gfx_readdirp_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata; /* Extra data */
+       gfx_dirplist *reply;
+};
+
+struct gfx_set_lk_ver_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       int lk_ver;
+};
+
+struct gfx_set_lk_ver_req {
+       string uid<>;
+       int lk_ver;
+};
+
+struct gfx_event_notify_req {
+        int op;
+        gfx_dict dict;
+};
+
+
+struct gfx_getsnap_name_uuid_req {
+        gfx_dict dict;
+};
+
+struct gfx_getsnap_name_uuid_rsp {
+        int op_ret;
+        int op_errno;
+        gfx_dict dict;
+        string op_errstr<>;
+};
+
+struct gfx_getactivelk_rsp {
+        int op_ret;
+        int op_errno;
+        gfx_dict xdata;
+        gfs3_locklist *reply;
+};
+
+struct gfx_getactivelk_req {
+        opaque gfid[16];
+        gfx_dict xdata;
+};
+
+struct gfx_setactivelk_req {
+        opaque gfid[16];
+        gfs3_locklist *request;
+        gfx_dict xdata;
+};
+
+struct gfs4_inodelk_contention_req {
+        opaque                gfid[16];
+        struct gf_proto_flock flock;
+        unsigned int          pid;
+        string                domain<>;
+        opaque                xdata<>;
+};
+
+struct gfs4_entrylk_contention_req {
+        opaque                gfid[16];
+        unsigned int          type;
+        unsigned int          pid;
+        string                name<>;
+        string                domain<>;
+        opaque                xdata<>;
+};
diff --git a/rpc/xdr/src/libgfxdr.sym b/rpc/xdr/src/libgfxdr.sym
new file mode 100644
index 00000000000..8fa0e0ddd8a
--- /dev/null
+++ b/rpc/xdr/src/libgfxdr.sym
@@ -0,0 +1,350 @@
+xdr_auth_glusterfs_parms
+xdr_auth_glusterfs_parms_v2
+xdr_auth_glusterfs_params_v3
+xdr_changelog_event_req
+xdr_changelog_event_rsp
+xdr_changelog_probe_req
+xdr_changelog_probe_rsp
+xdr_dirpath
+xdr_free_exports_list
+xdr_free_mountlist
+xdr_gd1_mgmt_brick_op_req
+xdr_gd1_mgmt_brick_op_rsp
+xdr_gd1_mgmt_cluster_lock_req
+xdr_gd1_mgmt_cluster_lock_rsp
+xdr_gd1_mgmt_cluster_unlock_req
+xdr_gd1_mgmt_cluster_unlock_rsp
+xdr_gd1_mgmt_commit_op_req
+xdr_gd1_mgmt_commit_op_rsp
+xdr_gd1_mgmt_friend_req
+xdr_gd1_mgmt_friend_rsp
+xdr_gd1_mgmt_friend_update
+xdr_gd1_mgmt_friend_update_rsp
+xdr_gd1_mgmt_probe_req
+xdr_gd1_mgmt_probe_rsp
+xdr_gd1_mgmt_stage_op_req
+xdr_gd1_mgmt_stage_op_rsp
+xdr_gd1_mgmt_v3_brick_op_req
+xdr_gd1_mgmt_v3_brick_op_rsp
+xdr_gd1_mgmt_v3_commit_req
+xdr_gd1_mgmt_v3_commit_rsp
+xdr_gd1_mgmt_v3_post_commit_req
+xdr_gd1_mgmt_v3_post_commit_rsp
+xdr_gd1_mgmt_v3_lock_req
+xdr_gd1_mgmt_v3_lock_rsp
+xdr_gd1_mgmt_v3_post_val_req
+xdr_gd1_mgmt_v3_post_val_rsp
+xdr_gd1_mgmt_v3_pre_val_req
+xdr_gd1_mgmt_v3_pre_val_rsp
+xdr_gd1_mgmt_v3_unlock_req
+xdr_gd1_mgmt_v3_unlock_rsp
+xdr_gf1_cli_fsm_log_req
+xdr_gf1_cli_fsm_log_rsp
+xdr_gf1_cli_getwd_req
+xdr_gf1_cli_getwd_rsp
+xdr_gf1_cli_mount_req
+xdr_gf1_cli_mount_rsp
+xdr_gf1_cli_peer_list_req
+xdr_gf1_cli_peer_list_rsp
+xdr_gf1_cli_umount_req
+xdr_gf1_cli_umount_rsp
+xdr_gf_cli_req
+xdr_gf_cli_rsp
+xdr_gf_common_rsp
+xdr_gf_dump_req
+xdr_gf_dump_rsp
+xdr_gf_event_notify_req
+xdr_gf_event_notify_rsp
+xdr_gf_getsnap_name_uuid_req
+xdr_gf_getsnap_name_uuid_rsp
+xdr_gf_getspec_req
+xdr_gf_getspec_rsp
+xdr_gf_get_volume_info_req
+xdr_gf_get_volume_info_rsp
+xdr_gf_mgmt_hndsk_req
+xdr_gf_mgmt_hndsk_rsp
+xdr_gfs3_access_req
+xdr_gfs3_cbk_cache_invalidation_req
+xdr_gfs3_compound_req
+xdr_gfs3_compound_rsp
+xdr_gfs3_create_req
+xdr_gfs3_create_rsp
+xdr_gfs3_discard_req
+xdr_gfs3_discard_rsp
+xdr_gfs3_entrylk_req
+xdr_gfs3_fallocate_req
+xdr_gfs3_fallocate_rsp
+xdr_gfs3_fentrylk_req
+xdr_gfs3_fgetxattr_req
+xdr_gfs3_fgetxattr_rsp
+xdr_gfs3_finodelk_req
+xdr_gfs3_flush_req
+xdr_gfs3_fremovexattr_req
+xdr_gfs3_fsetattr_req
+xdr_gfs3_fsetattr_req_v2
+xdr_gfs3_fsetattr_rsp
+xdr_gfs3_fsetxattr_req
+xdr_gfs3_fstat_req
+xdr_gfs3_fstat_rsp
+xdr_gfs3_fsyncdir_req
+xdr_gfs3_fsync_req
+xdr_gfs3_fsync_rsp
+xdr_gfs3_ftruncate_req
+xdr_gfs3_ftruncate_rsp
+xdr_gfs3_fxattrop_req
+xdr_gfs3_fxattrop_rsp
+xdr_gfs3_getactivelk_req
+xdr_gfs3_getactivelk_rsp
+xdr_gfs3_getxattr_req
+xdr_gfs3_getxattr_rsp
+xdr_gfs3_inodelk_req
+xdr_gfs3_ipc_req
+xdr_gfs3_ipc_rsp
+xdr_gfs3_lease_req
+xdr_gfs3_lease_rsp
+xdr_gfs3_link_req
+xdr_gfs3_link_rsp
+xdr_gfs3_lk_req
+xdr_gfs3_lk_rsp
+xdr_gfs3_lookup_req
+xdr_gfs3_lookup_rsp
+xdr_gfs3_mkdir_req
+xdr_gfs3_mkdir_rsp
+xdr_gfs3_mknod_req
+xdr_gfs3_mknod_rsp
+xdr_gfs3_opendir_req
+xdr_gfs3_opendir_rsp
+xdr_gfs3_open_req
+xdr_gfs3_open_rsp
+xdr_gfs3_rchecksum_req
+xdr_gfs3_rchecksum_req_v2
+xdr_gfs3_rchecksum_rsp
+xdr_gfs3_readdirp_req
+xdr_gfs3_readdirp_rsp
+xdr_gfs3_readdir_req
+xdr_gfs3_readdir_rsp
+xdr_gfs3_readlink_req
+xdr_gfs3_readlink_rsp
+xdr_gfs3_read_req
+xdr_gfs3_read_rsp
+xdr_gfs3_recall_lease_req
+xdr_gfs3_releasedir_req
+xdr_gfs3_release_req
+xdr_gfs3_removexattr_req
+xdr_gfs3_rename_req
+xdr_gfs3_rename_rsp
+xdr_gfs3_rmdir_req
+xdr_gfs3_rmdir_rsp
+xdr_gfs3_seek_req
+xdr_gfs3_seek_rsp
+xdr_gfs3_setactivelk_req
+xdr_gfs3_setactivelk_rsp
+xdr_gfs3_setattr_req
+xdr_gfs3_setattr_rsp
+xdr_gfs3_setxattr_req
+xdr_gfs3_statfs_req
+xdr_gfs3_statfs_rsp
+xdr_gfs3_stat_req
+xdr_gfs3_stat_rsp
+xdr_gfs3_symlink_req
+xdr_gfs3_symlink_rsp
+xdr_gfs3_truncate_req
+xdr_gfs3_truncate_rsp
+xdr_gfs3_unlink_req
+xdr_gfs3_unlink_rsp
+xdr_gfs3_write_req
+xdr_gfs3_write_rsp
+xdr_gfs3_xattrop_req
+xdr_gfs3_xattrop_rsp
+xdr_gfs3_zerofill_req
+xdr_gfs3_zerofill_rsp
+xdr_gfs4_entrylk_contention_req
+xdr_gfs4_entrylk_contention_rsp
+xdr_gfs4_icreate_req
+xdr_gfs4_icreate_rsp
+xdr_gfs4_inodelk_contention_req
+xdr_gfs4_inodelk_contention_rsp
+xdr_gfs4_namelink_req
+xdr_gfs4_namelink_rsp
+xdr_gf_set_lk_ver_req
+xdr_gf_set_lk_ver_rsp
+xdr_gf_setvolume_req
+xdr_gf_setvolume_rsp
+xdr_gf_statedump
+xdr_length_round_up
+xdr_mon
+xdr_mountres3
+xdr_mountstat3
+xdr_nlm_sm_status
+xdr_pmap_brick_by_port_req
+xdr_pmap_brick_by_port_rsp
+xdr_pmap_port_by_brick_req
+xdr_pmap_port_by_brick_rsp
+xdr_pmap_signin_req
+xdr_pmap_signin_rsp
+xdr_pmap_signout_req
+xdr_pmap_signout_rsp
+xdr_serialize_access3res
+xdr_serialize_commit3res
+xdr_serialize_create3res
+xdr_serialize_exports
+xdr_serialize_fsinfo3res
+xdr_serialize_fsstat3res
+xdr_serialize_generic
+xdr_serialize_getaclreply
+xdr_serialize_getattr3res
+xdr_serialize_link3res
+xdr_serialize_lookup3res
+xdr_serialize_mkdir3res
+xdr_serialize_mknod3res
+xdr_serialize_mountlist
+xdr_serialize_mountres3
+xdr_serialize_mountstat3
+xdr_serialize_nlm4_res
+xdr_serialize_nlm4_shareres
+xdr_serialize_nlm4_testargs
+xdr_serialize_nlm4_testres
+xdr_serialize_pathconf3res
+xdr_serialize_read3res
+xdr_serialize_read3res_nocopy
+xdr_serialize_readdir3res
+xdr_serialize_readdirp3res
+xdr_serialize_readlink3res
+xdr_serialize_remove3res
+xdr_serialize_rename3res
+xdr_serialize_rmdir3res
+xdr_serialize_setaclreply
+xdr_serialize_setattr3res
+xdr_serialize_symlink3res
+xdr_serialize_write3res
+xdr_sm_stat
+xdr_sm_stat_res
+xdr_to_access3args
+xdr_to_commit3args
+xdr_to_create3args
+xdr_to_fsinfo3args
+xdr_to_fsstat3args
+xdr_to_generic
+xdr_to_getaclargs
+xdr_to_getattr3args
+xdr_to_link3args
+xdr_to_lookup3args
+xdr_to_mkdir3args
+xdr_to_mknod3args
+xdr_to_mountpath
+xdr_to_nlm4_cancelargs
+xdr_to_nlm4_freeallargs
+xdr_to_nlm4_lockargs
+xdr_to_nlm4_shareargs
+xdr_to_nlm4_testargs
+xdr_to_nlm4_unlockargs
+xdr_to_pathconf3args
+xdr_to_read3args
+xdr_to_readdir3args
+xdr_to_readdirp3args
+xdr_to_readlink3args
+xdr_to_remove3args
+xdr_to_rename3args
+xdr_to_rmdir3args
+xdr_to_setaclargs
+xdr_to_setattr3args
+xdr_to_symlink3args
+xdr_to_write3args
+xdr_vector_round_up
+xdr_gfx_read_rsp
+xdr_gfx_iattx
+xdr_gfx_mdata_iatt
+xdr_gfx_value
+xdr_gfx_dict_pair
+xdr_gfx_dict
+xdr_gfx_common_rsp
+xdr_gfx_common_iatt_rsp
+xdr_gfx_common_2iatt_rsp
+xdr_gfx_common_3iatt_rsp
+xdr_gfx_fsetattr_req
+xdr_gfx_rchecksum_req
+xdr_gfx_icreate_req
+xdr_gfx_namelink_req
+xdr_gfx_stat_req
+xdr_gfx_readlink_req
+xdr_gfx_readlink_rsp
+xdr_gfx_mknod_req
+xdr_gfx_mkdir_req
+xdr_gfx_unlink_req
+xdr_gfx_rmdir_req
+xdr_gfx_symlink_req
+xdr_gfx_rename_req
+xdr_gfx_rename_rsp
+xdr_gfx_link_req
+xdr_gfx_truncate_req
+xdr_gfx_open_req
+xdr_gfx_open_rsp
+xdr_gfx_opendir_req
+xdr_gfx_read_req
+xdr_gfx_read_rsp
+xdr_gfx_lookup_req
+xdr_gfx_write_req
+xdr_gfx_statfs_req
+xdr_gfx_statfs_rsp
+xdr_gfx_lk_req
+xdr_gfx_lk_rsp
+xdr_gfx_lease_req
+xdr_gfx_lease_rsp
+xdr_gfx_recall_lease_req
+xdr_gfx_inodelk_req
+xdr_gfx_finodelk_req
+xdr_gfx_flush_req
+xdr_gfx_fsync_req
+xdr_gfx_setxattr_req
+xdr_gfx_fsetxattr_req
+xdr_gfx_xattrop_req
+xdr_gfx_common_dict_rsp
+xdr_gfx_fxattrop_req
+xdr_gfx_getxattr_req
+xdr_gfx_fgetxattr_req
+xdr_gfx_removexattr_req
+xdr_gfx_fremovexattr_req
+xdr_gfx_fsyncdir_req
+xdr_gfx_readdir_req
+xdr_gfx_readdirp_req
+xdr_gfx_access_req
+xdr_gfx_create_req
+xdr_gfx_create_rsp
+xdr_gfx_ftruncate_req
+xdr_gfx_fstat_req
+xdr_gfx_entrylk_req
+xdr_gfx_fentrylk_req
+xdr_gfx_setattr_req
+xdr_gfx_fallocate_req
+xdr_gfx_discard_req
+xdr_gfx_zerofill_req
+xdr_gfx_rchecksum_rsp
+xdr_gfx_ipc_req
+xdr_gfx_seek_req
+xdr_gfx_seek_rsp
+xdr_gfx_setvolume_req
+xdr_gfx_setvolume_rsp
+xdr_gfx_getspec_req
+xdr_gfx_getspec_rsp
+xdr_gfx_notify_req
+xdr_gfx_notify_rsp
+xdr_gfx_releasedir_req
+xdr_gfx_release_req
+xdr_gfx_dirlist
+xdr_gfx_readdir_rsp
+xdr_gfx_dirplist
+xdr_gfx_readdirp_rsp
+xdr_gfx_set_lk_ver_rsp
+xdr_gfx_set_lk_ver_req
+xdr_gfx_event_notify_req
+xdr_gfx_getsnap_name_uuid_req
+xdr_gfx_getsnap_name_uuid_rsp
+xdr_gfx_getactivelk_rsp
+xdr_gfx_getactivelk_req
+xdr_gfx_setactivelk_req
+xdr_gfx_put_req
+xdr_compound_req_v2
+xdr_gfx_compound_req
+xdr_compound_rsp_v2
+xdr_gfx_compound_rsp
+xdr_gfx_copy_file_range_req
diff --git a/rpc/xdr/src/mount3udp.x b/rpc/xdr/src/mount3udp.x
index 4fafaa053f8..e8366df400c 100644
--- a/rpc/xdr/src/mount3udp.x
+++ b/rpc/xdr/src/mount3udp.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
 /* This is used by rpcgen to auto generate the rpc stubs.
  * mount3udp_svc.c is heavily modified though
diff --git a/rpc/xdr/src/msg-nfs3.c b/rpc/xdr/src/msg-nfs3.c
index 040aced6a97..d14a731b62a 100644
--- a/rpc/xdr/src/msg-nfs3.c
+++ b/rpc/xdr/src/msg-nfs3.c
@@ -18,35 +18,34 @@
 #include "xdr-generic.h"
 #include "xdr-common.h"
 
-
 /* Decode the mount path from the network message in inmsg
  * into the memory referenced by outpath.iov_base.
  * The size allocated for outpath.iov_base is outpath.iov_len.
  * The size of the path extracted from the message is returned.
  */
 ssize_t
-xdr_to_mountpath (struct iovec outpath, struct iovec inmsg)
+xdr_to_mountpath(struct iovec outpath, struct iovec inmsg)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
-        char    *mntpath = NULL;
+    XDR xdr;
+    ssize_t ret = -1;
+    char *mntpath = NULL;
 
-        if ((!outpath.iov_base) || (!inmsg.iov_base))
-                return -1;
+    if ((!outpath.iov_base) || (!inmsg.iov_base))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        mntpath = outpath.iov_base;
-        if (!xdr_dirpath (&xdr, (dirpath *)&mntpath)) {
-                ret = -1;
-                goto ret;
-        }
+    mntpath = outpath.iov_base;
+    if (!xdr_dirpath(&xdr, (dirpath *)&mntpath)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
 /* Translate the mountres3 structure in res into XDR format into memory
@@ -54,514 +53,429 @@ ret:
  * Returns the number of bytes used in encoding into XDR format.
  */
 ssize_t
-xdr_serialize_mountres3 (struct iovec outmsg, mountres3 *res)
+xdr_serialize_mountres3(struct iovec outmsg, mountres3 *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mountres3);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mountres3);
 }
 
-
 ssize_t
-xdr_serialize_mountbody (struct iovec outmsg, mountbody *mb)
+xdr_serialize_mountbody(struct iovec outmsg, mountbody *mb)
 {
-        return xdr_serialize_generic (outmsg, (void *)mb,
-                                          (xdrproc_t)xdr_mountbody);
+    return xdr_serialize_generic(outmsg, (void *)mb, (xdrproc_t)xdr_mountbody);
 }
 
 ssize_t
-xdr_serialize_mountlist (struct iovec outmsg, mountlist *ml)
+xdr_serialize_mountlist(struct iovec outmsg, mountlist *ml)
 {
-        return xdr_serialize_generic (outmsg, (void *)ml,
-                                          (xdrproc_t)xdr_mountlist);
+    return xdr_serialize_generic(outmsg, (void *)ml, (xdrproc_t)xdr_mountlist);
 }
 
-
 ssize_t
-xdr_serialize_mountstat3 (struct iovec outmsg, mountstat3 *m)
+xdr_serialize_mountstat3(struct iovec outmsg, mountstat3 *m)
 {
-        return xdr_serialize_generic (outmsg, (void *)m,
-                                          (xdrproc_t)xdr_mountstat3);
+    return xdr_serialize_generic(outmsg, (void *)m, (xdrproc_t)xdr_mountstat3);
 }
 
-
 ssize_t
-xdr_to_getattr3args (struct iovec inmsg, getattr3args *ga)
+xdr_to_getattr3args(struct iovec inmsg, getattr3args *ga)
 {
-        return xdr_to_generic (inmsg, (void *)ga,
-                                   (xdrproc_t)xdr_getattr3args);
+    return xdr_to_generic(inmsg, (void *)ga, (xdrproc_t)xdr_getattr3args);
 }
 
-
 ssize_t
-xdr_serialize_getattr3res (struct iovec outmsg, getattr3res *res)
+xdr_serialize_getattr3res(struct iovec outmsg, getattr3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_getattr3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_getattr3res);
 }
 
-
 ssize_t
-xdr_serialize_setattr3res (struct iovec outmsg, setattr3res *res)
+xdr_serialize_setattr3res(struct iovec outmsg, setattr3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_setattr3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_setattr3res);
 }
 
-
 ssize_t
-xdr_to_setattr3args (struct iovec inmsg, setattr3args *sa)
+xdr_to_setattr3args(struct iovec inmsg, setattr3args *sa)
 {
-        return xdr_to_generic (inmsg, (void *)sa,
-                                   (xdrproc_t)xdr_setattr3args);
+    return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_setattr3args);
 }
 
-
 ssize_t
-xdr_serialize_lookup3res (struct iovec outmsg, lookup3res *res)
+xdr_serialize_lookup3res(struct iovec outmsg, lookup3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_lookup3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_lookup3res);
 }
 
-
 ssize_t
-xdr_to_lookup3args (struct iovec inmsg, lookup3args *la)
+xdr_to_lookup3args(struct iovec inmsg, lookup3args *la)
 {
-        return xdr_to_generic (inmsg, (void *)la,
-                                   (xdrproc_t)xdr_lookup3args);
+    return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_lookup3args);
 }
 
-
 ssize_t
-xdr_to_access3args (struct iovec inmsg, access3args *ac)
+xdr_to_access3args(struct iovec inmsg, access3args *ac)
 {
-        return xdr_to_generic (inmsg,(void *)ac,
-                                   (xdrproc_t)xdr_access3args);
+    return xdr_to_generic(inmsg, (void *)ac, (xdrproc_t)xdr_access3args);
 }
 
-
 ssize_t
-xdr_serialize_access3res (struct iovec outmsg, access3res *res)
+xdr_serialize_access3res(struct iovec outmsg, access3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_access3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_access3res);
 }
 
-
 ssize_t
-xdr_to_readlink3args (struct iovec inmsg, readlink3args *ra)
+xdr_to_readlink3args(struct iovec inmsg, readlink3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_readlink3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_readlink3args);
 }
 
-
 ssize_t
-xdr_serialize_readlink3res (struct iovec outmsg, readlink3res *res)
+xdr_serialize_readlink3res(struct iovec outmsg, readlink3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readlink3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readlink3res);
 }
 
-
 ssize_t
-xdr_to_read3args (struct iovec inmsg, read3args *ra)
+xdr_to_read3args(struct iovec inmsg, read3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra, (xdrproc_t)xdr_read3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_read3args);
 }
 
-
 ssize_t
-xdr_serialize_read3res (struct iovec outmsg, read3res *res)
+xdr_serialize_read3res(struct iovec outmsg, read3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_read3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_read3res);
 }
 
 ssize_t
-xdr_serialize_read3res_nocopy (struct iovec outmsg, read3res *res)
+xdr_serialize_read3res_nocopy(struct iovec outmsg, read3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_read3res_nocopy);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_read3res_nocopy);
 }
 
-
 ssize_t
-xdr_to_write3args (struct iovec inmsg, write3args *wa)
+xdr_to_write3args(struct iovec inmsg, write3args *wa)
 {
-        return xdr_to_generic (inmsg, (void *)wa,(xdrproc_t)xdr_write3args);
+    return xdr_to_generic(inmsg, (void *)wa, (xdrproc_t)xdr_write3args);
 }
 
-
 ssize_t
-xdr_to_write3args_nocopy (struct iovec inmsg, write3args *wa,
-                          struct iovec *payload)
+xdr_to_write3args_nocopy(struct iovec inmsg, write3args *wa,
+                         struct iovec *payload)
 {
-        return xdr_to_generic_payload (inmsg, (void *)wa,
-                                           (xdrproc_t)xdr_write3args, payload);
+    return xdr_to_generic_payload(inmsg, (void *)wa, (xdrproc_t)xdr_write3args,
+                                  payload);
 }
 
-
 ssize_t
-xdr_serialize_write3res (struct iovec outmsg, write3res *res)
+xdr_serialize_write3res(struct iovec outmsg, write3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_write3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_write3res);
 }
 
-
 ssize_t
-xdr_to_create3args (struct iovec inmsg, create3args *ca)
+xdr_to_create3args(struct iovec inmsg, create3args *ca)
 {
-        return xdr_to_generic (inmsg, (void *)ca,
-                                   (xdrproc_t)xdr_create3args);
+    return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_create3args);
 }
 
-
 ssize_t
-xdr_serialize_create3res (struct iovec outmsg, create3res *res)
+xdr_serialize_create3res(struct iovec outmsg, create3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_create3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_create3res);
 }
 
-
 ssize_t
-xdr_serialize_mkdir3res (struct iovec outmsg, mkdir3res *res)
+xdr_serialize_mkdir3res(struct iovec outmsg, mkdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mkdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mkdir3res);
 }
 
-
 ssize_t
-xdr_to_mkdir3args (struct iovec inmsg, mkdir3args *ma)
+xdr_to_mkdir3args(struct iovec inmsg, mkdir3args *ma)
 {
-        return xdr_to_generic (inmsg, (void *)ma,
-                                   (xdrproc_t)xdr_mkdir3args);
+    return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mkdir3args);
 }
 
-
 ssize_t
-xdr_to_symlink3args (struct iovec inmsg, symlink3args *sa)
+xdr_to_symlink3args(struct iovec inmsg, symlink3args *sa)
 {
-        return xdr_to_generic (inmsg, (void *)sa,
-                                   (xdrproc_t)xdr_symlink3args);
+    return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_symlink3args);
 }
 
-
 ssize_t
-xdr_serialize_symlink3res (struct iovec outmsg, symlink3res *res)
+xdr_serialize_symlink3res(struct iovec outmsg, symlink3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_symlink3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_symlink3res);
 }
 
-
 ssize_t
-xdr_to_mknod3args (struct iovec inmsg, mknod3args *ma)
+xdr_to_mknod3args(struct iovec inmsg, mknod3args *ma)
 {
-        return xdr_to_generic (inmsg, (void *)ma,
-                                   (xdrproc_t)xdr_mknod3args);
+    return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mknod3args);
 }
 
-
 ssize_t
-xdr_serialize_mknod3res (struct iovec outmsg, mknod3res *res)
+xdr_serialize_mknod3res(struct iovec outmsg, mknod3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mknod3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mknod3res);
 }
 
-
 ssize_t
-xdr_to_remove3args (struct iovec inmsg, remove3args *ra)
+xdr_to_remove3args(struct iovec inmsg, remove3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_remove3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_remove3args);
 }
 
-
 ssize_t
-xdr_serialize_remove3res (struct iovec outmsg, remove3res *res)
+xdr_serialize_remove3res(struct iovec outmsg, remove3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_remove3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_remove3res);
 }
 
-
 ssize_t
-xdr_to_rmdir3args (struct iovec inmsg, rmdir3args *ra)
+xdr_to_rmdir3args(struct iovec inmsg, rmdir3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_rmdir3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rmdir3args);
 }
 
-
 ssize_t
-xdr_serialize_rmdir3res (struct iovec outmsg, rmdir3res *res)
+xdr_serialize_rmdir3res(struct iovec outmsg, rmdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_rmdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_rmdir3res);
 }
 
-
 ssize_t
-xdr_serialize_rename3res (struct iovec outmsg, rename3res *res)
+xdr_serialize_rename3res(struct iovec outmsg, rename3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_rename3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_rename3res);
 }
 
-
 ssize_t
-xdr_to_rename3args (struct iovec inmsg, rename3args *ra)
+xdr_to_rename3args(struct iovec inmsg, rename3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_rename3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rename3args);
 }
 
-
 ssize_t
-xdr_serialize_link3res (struct iovec outmsg, link3res *li)
+xdr_serialize_link3res(struct iovec outmsg, link3res *li)
 {
-        return xdr_serialize_generic (outmsg, (void *)li,
-                                          (xdrproc_t)xdr_link3res);
+    return xdr_serialize_generic(outmsg, (void *)li, (xdrproc_t)xdr_link3res);
 }
 
-
 ssize_t
-xdr_to_link3args (struct iovec inmsg, link3args *la)
+xdr_to_link3args(struct iovec inmsg, link3args *la)
 {
-        return xdr_to_generic (inmsg, (void *)la, (xdrproc_t)xdr_link3args);
+    return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_link3args);
 }
 
-
 ssize_t
-xdr_to_readdir3args (struct iovec inmsg, readdir3args *rd)
+xdr_to_readdir3args(struct iovec inmsg, readdir3args *rd)
 {
-        return xdr_to_generic (inmsg, (void *)rd,
-                                   (xdrproc_t)xdr_readdir3args);
+    return xdr_to_generic(inmsg, (void *)rd, (xdrproc_t)xdr_readdir3args);
 }
 
-
 ssize_t
-xdr_serialize_readdir3res (struct iovec outmsg, readdir3res *res)
+xdr_serialize_readdir3res(struct iovec outmsg, readdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readdir3res);
 }
 
-
 ssize_t
-xdr_to_readdirp3args (struct iovec inmsg, readdirp3args *rp)
+xdr_to_readdirp3args(struct iovec inmsg, readdirp3args *rp)
 {
-        return xdr_to_generic (inmsg, (void *)rp,
-                                   (xdrproc_t)xdr_readdirp3args);
+    return xdr_to_generic(inmsg, (void *)rp, (xdrproc_t)xdr_readdirp3args);
 }
 
-
 ssize_t
-xdr_serialize_readdirp3res (struct iovec outmsg, readdirp3res *res)
+xdr_serialize_readdirp3res(struct iovec outmsg, readdirp3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readdirp3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readdirp3res);
 }
 
-
 ssize_t
-xdr_to_fsstat3args (struct iovec inmsg, fsstat3args *fa)
+xdr_to_fsstat3args(struct iovec inmsg, fsstat3args *fa)
 {
-        return xdr_to_generic (inmsg, (void *)fa,
-                                   (xdrproc_t)xdr_fsstat3args);
+    return xdr_to_generic(inmsg, (void *)fa, (xdrproc_t)xdr_fsstat3args);
 }
 
-
 ssize_t
-xdr_serialize_fsstat3res (struct iovec outmsg, fsstat3res *res)
+xdr_serialize_fsstat3res(struct iovec outmsg, fsstat3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_fsstat3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_fsstat3res);
 }
 
 ssize_t
-xdr_to_fsinfo3args (struct iovec inmsg, fsinfo3args *fi)
+xdr_to_fsinfo3args(struct iovec inmsg, fsinfo3args *fi)
 {
-        return xdr_to_generic (inmsg, (void *)fi,
-                                   (xdrproc_t)xdr_fsinfo3args);
+    return xdr_to_generic(inmsg, (void *)fi, (xdrproc_t)xdr_fsinfo3args);
 }
 
-
 ssize_t
-xdr_serialize_fsinfo3res (struct iovec outmsg, fsinfo3res *res)
+xdr_serialize_fsinfo3res(struct iovec outmsg, fsinfo3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_fsinfo3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_fsinfo3res);
 }
 
-
 ssize_t
-xdr_to_pathconf3args (struct iovec inmsg, pathconf3args *pc)
+xdr_to_pathconf3args(struct iovec inmsg, pathconf3args *pc)
 {
-        return xdr_to_generic (inmsg, (void *)pc,
-                                   (xdrproc_t)xdr_pathconf3args);}
-
+    return xdr_to_generic(inmsg, (void *)pc, (xdrproc_t)xdr_pathconf3args);
+}
 
 ssize_t
-xdr_serialize_pathconf3res (struct iovec outmsg, pathconf3res *res)
+xdr_serialize_pathconf3res(struct iovec outmsg, pathconf3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_pathconf3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_pathconf3res);
 }
 
-
 ssize_t
-xdr_to_commit3args (struct iovec inmsg, commit3args *ca)
+xdr_to_commit3args(struct iovec inmsg, commit3args *ca)
 {
-        return xdr_to_generic (inmsg, (void *)ca,
-                                   (xdrproc_t)xdr_commit3args);
+    return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_commit3args);
 }
 
-
 ssize_t
-xdr_serialize_commit3res (struct iovec outmsg, commit3res *res)
+xdr_serialize_commit3res(struct iovec outmsg, commit3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_commit3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_commit3res);
 }
 
-
 ssize_t
-xdr_serialize_exports (struct iovec outmsg, exports *elist)
+xdr_serialize_exports(struct iovec outmsg, exports *elist)
 {
-        XDR     xdr;
-        ssize_t  ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!outmsg.iov_base) || (!elist))
-                return -1;
+    if ((!outmsg.iov_base) || (!elist))
+        return -1;
 
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
+    xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
+                  XDR_ENCODE);
 
-        if (!xdr_exports (&xdr, elist))
-                goto ret;
+    if (!xdr_exports(&xdr, elist))
+        goto ret;
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_serialize_nfsstat3 (struct iovec outmsg, nfsstat3 *s)
+xdr_serialize_nfsstat3(struct iovec outmsg, nfsstat3 *s)
 {
-        return xdr_serialize_generic (outmsg, (void *)s,
-                                          (xdrproc_t)xdr_nfsstat3);
+    return xdr_serialize_generic(outmsg, (void *)s, (xdrproc_t)xdr_nfsstat3);
 }
 
 ssize_t
-xdr_to_nlm4_testargs (struct iovec inmsg, nlm4_testargs *args)
+xdr_to_nlm4_testargs(struct iovec inmsg, nlm4_testargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_testargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_testargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_testres (struct iovec outmsg, nlm4_testres *res)
+xdr_serialize_nlm4_testres(struct iovec outmsg, nlm4_testres *res)
 {
-        return xdr_serialize_generic (outmsg, (void*)res,
-                                      (xdrproc_t)xdr_nlm4_testres);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_nlm4_testres);
 }
 
 ssize_t
-xdr_to_nlm4_lockargs (struct iovec inmsg, nlm4_lockargs *args)
+xdr_to_nlm4_lockargs(struct iovec inmsg, nlm4_lockargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_lockargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_lockargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_res (struct iovec outmsg, nlm4_res *res)
+xdr_serialize_nlm4_res(struct iovec outmsg, nlm4_res *res)
 {
-        return xdr_serialize_generic (outmsg, (void*)res,
-                                      (xdrproc_t)xdr_nlm4_res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_nlm4_res);
 }
 
 ssize_t
-xdr_to_nlm4_cancelargs (struct iovec inmsg, nlm4_cancargs *args)
+xdr_to_nlm4_cancelargs(struct iovec inmsg, nlm4_cancargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_cancargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_cancargs);
 }
 
 ssize_t
-xdr_to_nlm4_unlockargs (struct iovec inmsg, nlm4_unlockargs *args)
+xdr_to_nlm4_unlockargs(struct iovec inmsg, nlm4_unlockargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_unlockargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_unlockargs);
 }
 
 ssize_t
-xdr_to_nlm4_shareargs (struct iovec inmsg, nlm4_shareargs *args)
+xdr_to_nlm4_shareargs(struct iovec inmsg, nlm4_shareargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_shareargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_shareargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_shareres (struct iovec outmsg, nlm4_shareres *res)
+xdr_serialize_nlm4_shareres(struct iovec outmsg, nlm4_shareres *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                      (xdrproc_t)xdr_nlm4_shareres);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_nlm4_shareres);
 }
 
 ssize_t
-xdr_serialize_nlm4_testargs (struct iovec outmsg, nlm4_testargs *args)
+xdr_serialize_nlm4_testargs(struct iovec outmsg, nlm4_testargs *args)
 {
-        return xdr_serialize_generic (outmsg, (void*)args,
-                                      (xdrproc_t)xdr_nlm4_testargs);
+    return xdr_serialize_generic(outmsg, (void *)args,
+                                 (xdrproc_t)xdr_nlm4_testargs);
 }
 
 ssize_t
-xdr_to_nlm4_res (struct iovec inmsg, nlm4_res *args)
+xdr_to_nlm4_res(struct iovec inmsg, nlm4_res *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_res);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_res);
 }
 
 ssize_t
-xdr_to_nlm4_freeallargs (struct iovec inmsg, nlm4_freeallargs *args)
+xdr_to_nlm4_freeallargs(struct iovec inmsg, nlm4_freeallargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_freeallargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_freeallargs);
 }
 
 ssize_t
-xdr_to_getaclargs (struct iovec inmsg, getaclargs *args)
+xdr_to_getaclargs(struct iovec inmsg, getaclargs *args)
 {
-        return xdr_to_generic (inmsg, (void *) args,
-                               (xdrproc_t)xdr_getaclargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_getaclargs);
 }
 
 ssize_t
-xdr_to_setaclargs (struct iovec inmsg, setaclargs *args)
+xdr_to_setaclargs(struct iovec inmsg, setaclargs *args)
 {
-        return xdr_to_generic (inmsg, (void *) args,
-                               (xdrproc_t)xdr_setaclargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_setaclargs);
 }
 
 ssize_t
-xdr_serialize_getaclreply (struct iovec inmsg, getaclreply *res)
+xdr_serialize_getaclreply(struct iovec inmsg, getaclreply *res)
 {
-        return xdr_serialize_generic (inmsg, (void *) res,
-                                      (xdrproc_t)xdr_getaclreply);
+    return xdr_serialize_generic(inmsg, (void *)res,
+                                 (xdrproc_t)xdr_getaclreply);
 }
 
 ssize_t
-xdr_serialize_setaclreply (struct iovec inmsg, setaclreply *res)
+xdr_serialize_setaclreply(struct iovec inmsg, setaclreply *res)
 {
-        return xdr_serialize_generic (inmsg, (void *) res,
-                                      (xdrproc_t)xdr_setaclreply);
+    return xdr_serialize_generic(inmsg, (void *)res,
+                                 (xdrproc_t)xdr_setaclreply);
 }
-
diff --git a/rpc/xdr/src/msg-nfs3.h b/rpc/xdr/src/msg-nfs3.h
index 628daea5547..869ddc3524a 100644
--- a/rpc/xdr/src/msg-nfs3.h
+++ b/rpc/xdr/src/msg-nfs3.h
@@ -18,202 +18,202 @@
 #include <sys/uio.h>
 
 extern ssize_t
-xdr_to_mountpath (struct iovec outpath, struct iovec inmsg);
+xdr_to_mountpath(struct iovec outpath, struct iovec inmsg);
 
 extern ssize_t
-xdr_serialize_mountres3 (struct iovec outmsg, mountres3 *res);
+xdr_serialize_mountres3(struct iovec outmsg, mountres3 *res);
 
 extern ssize_t
-xdr_serialize_mountbody (struct iovec outmsg, mountbody *mb);
+xdr_serialize_mountbody(struct iovec outmsg, mountbody *mb);
 
 extern ssize_t
-xdr_to_getattr3args (struct iovec inmsg, getattr3args *ga);
+xdr_to_getattr3args(struct iovec inmsg, getattr3args *ga);
 
 extern ssize_t
-xdr_serialize_getattr3res (struct iovec outmsg, getattr3res *res);
+xdr_serialize_getattr3res(struct iovec outmsg, getattr3res *res);
 
 extern ssize_t
-xdr_serialize_setattr3res (struct iovec outmsg, setattr3res *res);
+xdr_serialize_setattr3res(struct iovec outmsg, setattr3res *res);
 
 extern ssize_t
-xdr_to_setattr3args (struct iovec inmsg, setattr3args *sa);
+xdr_to_setattr3args(struct iovec inmsg, setattr3args *sa);
 
 extern ssize_t
-xdr_serialize_lookup3res (struct iovec outmsg, lookup3res *res);
+xdr_serialize_lookup3res(struct iovec outmsg, lookup3res *res);
 
 extern ssize_t
-xdr_to_lookup3args (struct iovec inmsg, lookup3args *la);
+xdr_to_lookup3args(struct iovec inmsg, lookup3args *la);
 
 extern ssize_t
-xdr_to_access3args (struct iovec inmsg, access3args *ac);
+xdr_to_access3args(struct iovec inmsg, access3args *ac);
 
 extern ssize_t
-xdr_serialize_access3res (struct iovec outmsg, access3res *res);
+xdr_serialize_access3res(struct iovec outmsg, access3res *res);
 
 extern ssize_t
-xdr_to_readlink3args (struct iovec inmsg, readlink3args *ra);
+xdr_to_readlink3args(struct iovec inmsg, readlink3args *ra);
 
 extern ssize_t
-xdr_serialize_readlink3res (struct iovec outmsg, readlink3res *res);
+xdr_serialize_readlink3res(struct iovec outmsg, readlink3res *res);
 
 extern ssize_t
-xdr_to_read3args (struct iovec inmsg, read3args *ra);
+xdr_to_read3args(struct iovec inmsg, read3args *ra);
 
 extern ssize_t
-xdr_serialize_read3res (struct iovec outmsg, read3res *res);
+xdr_serialize_read3res(struct iovec outmsg, read3res *res);
 
 extern ssize_t
-xdr_serialize_read3res_nocopy (struct iovec outmsg, read3res *res);
+xdr_serialize_read3res_nocopy(struct iovec outmsg, read3res *res);
 
 extern ssize_t
-xdr_to_write3args (struct iovec inmsg, write3args *wa);
+xdr_to_write3args(struct iovec inmsg, write3args *wa);
 
 extern ssize_t
-xdr_to_write3args_nocopy (struct iovec inmsg, write3args *wa,
-                          struct iovec *payload);
+xdr_to_write3args_nocopy(struct iovec inmsg, write3args *wa,
+                         struct iovec *payload);
 
 extern ssize_t
-xdr_serialize_write3res (struct iovec outmsg, write3res *res);
+xdr_serialize_write3res(struct iovec outmsg, write3res *res);
 
 extern ssize_t
-xdr_to_create3args (struct iovec inmsg, create3args *ca);
+xdr_to_create3args(struct iovec inmsg, create3args *ca);
 
 extern ssize_t
-xdr_serialize_create3res (struct iovec outmsg, create3res *res);
+xdr_serialize_create3res(struct iovec outmsg, create3res *res);
 
 extern ssize_t
-xdr_serialize_mkdir3res (struct iovec outmsg, mkdir3res *res);
+xdr_serialize_mkdir3res(struct iovec outmsg, mkdir3res *res);
 
 extern ssize_t
-xdr_to_mkdir3args (struct iovec inmsg, mkdir3args *ma);
+xdr_to_mkdir3args(struct iovec inmsg, mkdir3args *ma);
 
 extern ssize_t
-xdr_to_symlink3args (struct iovec inmsg, symlink3args *sa);
+xdr_to_symlink3args(struct iovec inmsg, symlink3args *sa);
 
 extern ssize_t
-xdr_serialize_symlink3res (struct iovec outmsg, symlink3res *res);
+xdr_serialize_symlink3res(struct iovec outmsg, symlink3res *res);
 
 extern ssize_t
-xdr_to_mknod3args (struct iovec inmsg, mknod3args *ma);
+xdr_to_mknod3args(struct iovec inmsg, mknod3args *ma);
 
 extern ssize_t
-xdr_serialize_mknod3res (struct iovec outmsg, mknod3res *res);
+xdr_serialize_mknod3res(struct iovec outmsg, mknod3res *res);
 
 extern ssize_t
-xdr_to_remove3args (struct iovec inmsg, remove3args *ra);
+xdr_to_remove3args(struct iovec inmsg, remove3args *ra);
 
 extern ssize_t
-xdr_serialize_remove3res (struct iovec outmsg, remove3res *res);
+xdr_serialize_remove3res(struct iovec outmsg, remove3res *res);
 
 extern ssize_t
-xdr_to_rmdir3args (struct iovec inmsg, rmdir3args *ra);
+xdr_to_rmdir3args(struct iovec inmsg, rmdir3args *ra);
 
 extern ssize_t
-xdr_serialize_rmdir3res (struct iovec outmsg, rmdir3res *res);
+xdr_serialize_rmdir3res(struct iovec outmsg, rmdir3res *res);
 
 extern ssize_t
-xdr_serialize_rename3res (struct iovec outmsg, rename3res *res);
+xdr_serialize_rename3res(struct iovec outmsg, rename3res *res);
 
 extern ssize_t
-xdr_to_rename3args (struct iovec inmsg, rename3args *ra);
+xdr_to_rename3args(struct iovec inmsg, rename3args *ra);
 
 extern ssize_t
-xdr_serialize_link3res (struct iovec outmsg, link3res *li);
+xdr_serialize_link3res(struct iovec outmsg, link3res *li);
 
 extern ssize_t
-xdr_to_link3args (struct iovec inmsg, link3args *la);
+xdr_to_link3args(struct iovec inmsg, link3args *la);
 
 extern ssize_t
-xdr_to_readdir3args (struct iovec inmsg, readdir3args *rd);
+xdr_to_readdir3args(struct iovec inmsg, readdir3args *rd);
 
 extern ssize_t
-xdr_serialize_readdir3res (struct iovec outmsg, readdir3res *res);
+xdr_serialize_readdir3res(struct iovec outmsg, readdir3res *res);
 
 extern ssize_t
-xdr_to_readdirp3args (struct iovec inmsg, readdirp3args *rp);
+xdr_to_readdirp3args(struct iovec inmsg, readdirp3args *rp);
 
 extern ssize_t
-xdr_serialize_readdirp3res (struct iovec outmsg, readdirp3res *res);
+xdr_serialize_readdirp3res(struct iovec outmsg, readdirp3res *res);
 
 extern ssize_t
-xdr_to_fsstat3args (struct iovec inmsg, fsstat3args *fa);
+xdr_to_fsstat3args(struct iovec inmsg, fsstat3args *fa);
 
 extern ssize_t
-xdr_serialize_fsstat3res (struct iovec outmsg, fsstat3res *res);
+xdr_serialize_fsstat3res(struct iovec outmsg, fsstat3res *res);
 
 extern ssize_t
-xdr_to_fsinfo3args (struct iovec inmsg, fsinfo3args *fi);
+xdr_to_fsinfo3args(struct iovec inmsg, fsinfo3args *fi);
 
 extern ssize_t
-xdr_serialize_fsinfo3res (struct iovec outmsg, fsinfo3res *res);
+xdr_serialize_fsinfo3res(struct iovec outmsg, fsinfo3res *res);
 
 extern ssize_t
-xdr_to_pathconf3args (struct iovec inmsg, pathconf3args *pc);
+xdr_to_pathconf3args(struct iovec inmsg, pathconf3args *pc);
 
 extern ssize_t
-xdr_serialize_pathconf3res (struct iovec outmsg, pathconf3res *res);
+xdr_serialize_pathconf3res(struct iovec outmsg, pathconf3res *res);
 
 extern ssize_t
-xdr_to_commit3args (struct iovec inmsg, commit3args *ca);
+xdr_to_commit3args(struct iovec inmsg, commit3args *ca);
 
 extern ssize_t
-xdr_serialize_commit3res (struct iovec outmsg, commit3res *res);
+xdr_serialize_commit3res(struct iovec outmsg, commit3res *res);
 
 extern ssize_t
-xdr_serialize_exports (struct iovec outmsg, exports *elist);
+xdr_serialize_exports(struct iovec outmsg, exports *elist);
 
 extern ssize_t
-xdr_serialize_mountlist (struct iovec outmsg, mountlist *ml);
+xdr_serialize_mountlist(struct iovec outmsg, mountlist *ml);
 
 extern ssize_t
-xdr_serialize_mountstat3 (struct iovec outmsg, mountstat3 *m);
+xdr_serialize_mountstat3(struct iovec outmsg, mountstat3 *m);
 
 extern ssize_t
-xdr_serialize_nfsstat3 (struct iovec outmsg, nfsstat3 *s);
+xdr_serialize_nfsstat3(struct iovec outmsg, nfsstat3 *s);
 
 extern ssize_t
-xdr_to_nlm4_testargs (struct iovec inmsg, nlm4_testargs *args);
+xdr_to_nlm4_testargs(struct iovec inmsg, nlm4_testargs *args);
 
 extern ssize_t
-xdr_serialize_nlm4_testres (struct iovec outmsg, nlm4_testres *res);
+xdr_serialize_nlm4_testres(struct iovec outmsg, nlm4_testres *res);
 
 extern ssize_t
-xdr_to_nlm4_lockargs (struct iovec inmsg, nlm4_lockargs *args);
+xdr_to_nlm4_lockargs(struct iovec inmsg, nlm4_lockargs *args);
 
 extern ssize_t
-xdr_serialize_nlm4_res (struct iovec outmsg, nlm4_res *res);
+xdr_serialize_nlm4_res(struct iovec outmsg, nlm4_res *res);
 
 extern ssize_t
-xdr_to_nlm4_cancelargs (struct iovec inmsg, nlm4_cancargs *args);
+xdr_to_nlm4_cancelargs(struct iovec inmsg, nlm4_cancargs *args);
 
 extern ssize_t
-xdr_to_nlm4_unlockargs (struct iovec inmsg, nlm4_unlockargs *args);
+xdr_to_nlm4_unlockargs(struct iovec inmsg, nlm4_unlockargs *args);
 
 extern ssize_t
-xdr_to_nlm4_shareargs (struct iovec inmsg, nlm4_shareargs *args);
+xdr_to_nlm4_shareargs(struct iovec inmsg, nlm4_shareargs *args);
 
 extern ssize_t
-xdr_serialize_nlm4_shareres (struct iovec outmsg, nlm4_shareres *res);
+xdr_serialize_nlm4_shareres(struct iovec outmsg, nlm4_shareres *res);
 
 extern ssize_t
-xdr_serialize_nlm4_testargs (struct iovec outmsg, nlm4_testargs *args);
+xdr_serialize_nlm4_testargs(struct iovec outmsg, nlm4_testargs *args);
 
 extern ssize_t
-xdr_to_nlm4_res (struct iovec inmsg, nlm4_res *args);
+xdr_to_nlm4_res(struct iovec inmsg, nlm4_res *args);
 
 extern ssize_t
-xdr_to_nlm4_freeallargs (struct iovec inmsg, nlm4_freeallargs *args);
+xdr_to_nlm4_freeallargs(struct iovec inmsg, nlm4_freeallargs *args);
 
 extern ssize_t
-xdr_to_getaclargs (struct iovec inmsg, getaclargs *args);
+xdr_to_getaclargs(struct iovec inmsg, getaclargs *args);
 
 extern ssize_t
-xdr_to_setaclargs (struct iovec inmsg, setaclargs *args);
+xdr_to_setaclargs(struct iovec inmsg, setaclargs *args);
 
 extern ssize_t
-xdr_serialize_getaclreply (struct iovec inmsg, getaclreply *res);
+xdr_serialize_getaclreply(struct iovec inmsg, getaclreply *res);
 
 extern ssize_t
-xdr_serialize_setaclreply (struct iovec inmsg, setaclreply *res);
+xdr_serialize_setaclreply(struct iovec inmsg, setaclreply *res);
 
 #endif
diff --git a/rpc/xdr/src/nlm4-xdr.x b/rpc/xdr/src/nlm4-xdr.x
index 47538235171..847b0e64491 100644
--- a/rpc/xdr/src/nlm4-xdr.x
+++ b/rpc/xdr/src/nlm4-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
 /* .x file defined as according to the RFC */
 
@@ -90,7 +90,7 @@ struct nlm4_share {
 
 union nlm4_testrply switch (nlm4_stats stat) {
 	case nlm4_denied:
-		struct nlm4_holder holder;
+		nlm4_holder holder;
 	default:
 		void;
 };
@@ -103,7 +103,7 @@ struct nlm4_testres {
 struct nlm4_testargs {
 	nlm4_netobj cookie;
 	bool exclusive;
-	struct nlm4_lock alock;
+	nlm4_lock alock;
 };
 
 struct nlm4_res {
@@ -115,7 +115,7 @@ struct nlm4_lockargs {
 	nlm4_netobj cookie;
 	bool block;
 	bool exclusive;
-	struct nlm4_lock alock;
+	nlm4_lock alock;
 	bool reclaim;		/* used for recovering locks */
 	int32_t state;		/* specify local status monitor state */
 };
@@ -124,12 +124,12 @@ struct nlm4_cancargs {
 	nlm4_netobj cookie;
 	bool block;
 	bool exclusive;
-	struct nlm4_lock alock;
+	nlm4_lock alock;
 };
 
 struct nlm4_unlockargs {
 	nlm4_netobj cookie;
-	struct nlm4_lock alock;
+	nlm4_lock alock;
 };
 
 struct	nlm4_shareargs {
@@ -162,6 +162,6 @@ struct nlm_sm_status {
 
 program NLMCBK_PROGRAM {
         version NLMCBK_V1 {
-                void NLMCBK_SM_NOTIFY(struct nlm_sm_status) = 16;
+                void NLMCBK_SM_NOTIFY(nlm_sm_status) = 16;
         } = 1;
 } = 100021;
diff --git a/rpc/xdr/src/nsm-xdr.x b/rpc/xdr/src/nsm-xdr.x
index 81b0b8cdea2..7c16a741f1d 100644
--- a/rpc/xdr/src/nsm-xdr.x
+++ b/rpc/xdr/src/nsm-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
 /*
  * This defines the maximum length of the string
@@ -46,11 +46,11 @@ struct my_id {
 
 struct mon_id {
     string mon_name<SM_MAXSTRLEN>; /* name of the host to be monitored */
-    struct my_id my_id;
+    my_id my_id;
 };
 
 struct mon {
-    struct mon_id mon_id;
+    mon_id mon_id;
     opaque    priv[16];        /*  private information  */
 };
 
diff --git a/rpc/xdr/src/portmap-xdr.x b/rpc/xdr/src/portmap-xdr.x
index 66a86a1dae1..23515572b9f 100644
--- a/rpc/xdr/src/portmap-xdr.x
+++ b/rpc/xdr/src/portmap-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/compat.h>
 
 struct pmap_port_by_brick_req {
        string   brick<>;
@@ -40,6 +40,7 @@ struct pmap_brick_by_port_rsp {
 struct pmap_signin_req {
        string brick<>;
        int port;
+       int pid;
 };
 
 struct pmap_signin_rsp {
diff --git a/rpc/xdr/src/rpc-common-xdr.x b/rpc/xdr/src/rpc-common-xdr.x
index 7ccfbb11a51..baf8b4313c8 100644
--- a/rpc/xdr/src/rpc-common-xdr.x
+++ b/rpc/xdr/src/rpc-common-xdr.x
@@ -11,7 +11,7 @@
 #ifdef RPC_XDR
 %#include "rpc-pragmas.h"
 #endif
-%#include "compat.h"
+%#include <glusterfs/glusterfs-fops.h>
 
 /* This file has definition of few XDR structures which are
  * not captured in any section specific file */
diff --git a/rpc/xdr/src/xdr-generic.c b/rpc/xdr/src/xdr-generic.c
index fd6fceb9425..20b54eb0a8a 100644
--- a/rpc/xdr/src/xdr-generic.c
+++ b/rpc/xdr/src/xdr-generic.c
@@ -8,118 +8,113 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "xdr-generic.h"
 
-
 ssize_t
-xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc)
+xdr_serialize_generic(struct iovec outmsg, void *res, xdrproc_t proc)
 {
-        ssize_t ret = -1;
-        XDR     xdr;
+    ssize_t ret = -1;
+    XDR xdr;
 
-        if ((!outmsg.iov_base) || (!res) || (!proc))
-                return -1;
+    if ((!outmsg.iov_base) || (!res) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
+    xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
+                  XDR_ENCODE);
 
-        if (!PROC(&xdr, res)) {
-                ret = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, res)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_encoded_length (xdr);
+    ret = xdr_encoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc)
+xdr_to_generic(struct iovec inmsg, void *args, xdrproc_t proc)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
+    if ((!inmsg.iov_base) || (!args) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        if (!PROC (&xdr, args)) {
-                ret = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, args)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc,
-                        struct iovec *pendingpayload)
+xdr_to_generic_payload(struct iovec inmsg, void *args, xdrproc_t proc,
+                       struct iovec *pendingpayload)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
+    if ((!inmsg.iov_base) || (!args) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        if (!PROC (&xdr, args)) {
-                ret  = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, args)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
-        if (pendingpayload) {
-                pendingpayload->iov_base = xdr_decoded_remaining_addr (xdr);
-                pendingpayload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
+    if (pendingpayload) {
+        pendingpayload->iov_base = xdr_decoded_remaining_addr(xdr);
+        pendingpayload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
 
 ret:
-        return ret;
+    return ret;
 }
 
 ssize_t
-xdr_length_round_up (size_t len, size_t bufsize)
+xdr_length_round_up(size_t len, size_t bufsize)
 {
-        int     roundup = 0;
+    int roundup = 0;
 
-        roundup = len % XDR_BYTES_PER_UNIT;
-        if (roundup > 0)
-                roundup = XDR_BYTES_PER_UNIT - roundup;
+    roundup = len % XDR_BYTES_PER_UNIT;
+    if (roundup > 0)
+        roundup = XDR_BYTES_PER_UNIT - roundup;
 
-        if ((roundup > 0) && ((roundup + len) <= bufsize))
-                len += roundup;
+    if ((roundup > 0) && ((roundup + len) <= bufsize))
+        len += roundup;
 
-        return len;
+    return len;
 }
 
 int
-xdr_bytes_round_up (struct iovec *vec, size_t bufsize)
+xdr_bytes_round_up(struct iovec *vec, size_t bufsize)
 {
-        vec->iov_len = xdr_length_round_up (vec->iov_len, bufsize);
-        return 0;
+    vec->iov_len = xdr_length_round_up(vec->iov_len, bufsize);
+    return 0;
 }
 
-
 void
-xdr_vector_round_up (struct iovec *vec, int vcount, uint32_t count)
+xdr_vector_round_up(struct iovec *vec, int vcount, uint32_t count)
 {
-        uint32_t round_count = 0;
+    uint32_t round_count = 0;
 
-        round_count = xdr_length_round_up (count, 1048576);
-        round_count -= count;
-        if (round_count == 0 || vcount <= 0)
-                return;
+    round_count = xdr_length_round_up(count, 1048576);
+    round_count -= count;
+    if (round_count == 0 || vcount <= 0)
+        return;
 
-        vec[vcount-1].iov_len += round_count;
+    vec[vcount - 1].iov_len += round_count;
 }
diff --git a/rpc/xdr/src/xdr-generic.h b/rpc/xdr/src/xdr-generic.h
index 2f12290ef02..794dda508cc 100644
--- a/rpc/xdr/src/xdr-generic.h
+++ b/rpc/xdr/src/xdr-generic.h
@@ -15,14 +15,16 @@
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 
-#include "compat.h"
+#include <glusterfs/compat.h>
 
-#define xdr_decoded_remaining_addr(xdr)        ((&xdr)->x_private)
-#define xdr_decoded_remaining_len(xdr)         ((&xdr)->x_handy)
-#define xdr_encoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
-#define xdr_decoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+#define xdr_decoded_remaining_addr(xdr) ((&xdr)->x_private)
+#define xdr_decoded_remaining_len(xdr) ((&xdr)->x_handy)
+#define xdr_encoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
+#define xdr_decoded_length(xdr)                                                \
+    (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base))
 
-#define XDR_BYTES_PER_UNIT      4
+#define XDR_BYTES_PER_UNIT 4
 
 /*
   On OSX > 10.9
@@ -47,29 +49,28 @@
 */
 
 #if defined(__NetBSD__)
-#define  PROC(xdr, res)  proc(xdr, res)
+#define PROC(xdr, res) proc(xdr, res)
 #else
-#define  PROC(xdr, res)  proc(xdr, res, 0)
+#define PROC(xdr, res) proc(xdr, res, 0)
 #endif
 
 ssize_t
-xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc);
+xdr_serialize_generic(struct iovec outmsg, void *res, xdrproc_t proc);
 
 ssize_t
-xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc);
+xdr_to_generic(struct iovec inmsg, void *args, xdrproc_t proc);
 
 ssize_t
-xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc,
-                        struct iovec *pendingpayload);
-
+xdr_to_generic_payload(struct iovec inmsg, void *args, xdrproc_t proc,
+                       struct iovec *pendingpayload);
 
 extern int
-xdr_bytes_round_up (struct iovec *vec, size_t bufsize);
+xdr_bytes_round_up(struct iovec *vec, size_t bufsize);
 
 extern ssize_t
-xdr_length_round_up (size_t len, size_t bufsize);
+xdr_length_round_up(size_t len, size_t bufsize);
 
 void
-xdr_vector_round_up (struct iovec *vec, int vcount, uint32_t count);
+xdr_vector_round_up(struct iovec *vec, int vcount, uint32_t count);
 
 #endif /* !_XDR_GENERIC_H */
diff --git a/rpc/xdr/src/xdr-nfs3.c b/rpc/xdr/src/xdr-nfs3.c
index 01ccb236993..cfccaaa89b8 100644
--- a/rpc/xdr/src/xdr-nfs3.c
+++ b/rpc/xdr/src/xdr-nfs3.c
@@ -23,1881 +23,1885 @@
 #endif
 
 #include "xdr-nfs3.h"
-#include "mem-pool.h"
+#include <glusterfs/mem-pool.h>
 #include "xdr-common.h"
 
 bool_t
-xdr_uint64 (XDR *xdrs, uint64 *objp)
+xdr_uint64(XDR *xdrs, uint64 *objp)
 {
-	 if (!xdr_uint64_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_int64 (XDR *xdrs, int64 *objp)
+xdr_int64(XDR *xdrs, int64 *objp)
 {
-	 if (!xdr_int64_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_int64_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_uint32 (XDR *xdrs, uint32 *objp)
+xdr_uint32(XDR *xdrs, uint32 *objp)
 {
-	 if (!xdr_uint32_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_int32 (XDR *xdrs, int32 *objp)
+xdr_int32(XDR *xdrs, int32 *objp)
 {
-	 if (!xdr_int32_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_int32_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_filename3 (XDR *xdrs, filename3 *objp)
+xdr_filename3(XDR *xdrs, filename3 *objp)
 {
-	 if (!xdr_string (xdrs, objp, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfspath3 (XDR *xdrs, nfspath3 *objp)
+xdr_nfspath3(XDR *xdrs, nfspath3 *objp)
 {
-	 if (!xdr_string (xdrs, objp, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fileid3 (XDR *xdrs, fileid3 *objp)
+xdr_fileid3(XDR *xdrs, fileid3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_cookie3 (XDR *xdrs, cookie3 *objp)
+xdr_cookie3(XDR *xdrs, cookie3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_cookieverf3 (XDR *xdrs, cookieverf3 objp)
+xdr_cookieverf3(XDR *xdrs, cookieverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_COOKIEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createverf3 (XDR *xdrs, createverf3 objp)
+xdr_createverf3(XDR *xdrs, createverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_CREATEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_writeverf3 (XDR *xdrs, writeverf3 objp)
+xdr_writeverf3(XDR *xdrs, writeverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_WRITEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_uid3 (XDR *xdrs, uid3 *objp)
+xdr_uid3(XDR *xdrs, uid3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_gid3 (XDR *xdrs, gid3 *objp)
+xdr_gid3(XDR *xdrs, gid3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_size3 (XDR *xdrs, size3 *objp)
+xdr_size3(XDR *xdrs, size3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_offset3 (XDR *xdrs, offset3 *objp)
+xdr_offset3(XDR *xdrs, offset3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mode3 (XDR *xdrs, mode3 *objp)
+xdr_mode3(XDR *xdrs, mode3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_count3 (XDR *xdrs, count3 *objp)
+xdr_count3(XDR *xdrs, count3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfsstat3 (XDR *xdrs, nfsstat3 *objp)
+xdr_nfsstat3(XDR *xdrs, nfsstat3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_ftype3 (XDR *xdrs, ftype3 *objp)
+xdr_ftype3(XDR *xdrs, ftype3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_specdata3 (XDR *xdrs, specdata3 *objp)
+xdr_specdata3(XDR *xdrs, specdata3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, &objp->specdata1))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->specdata2))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, &objp->specdata1))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->specdata2))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfs_fh3 (XDR *xdrs, nfs_fh3 *objp)
+xdr_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
 {
-	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
+                   (u_int *)&objp->data.data_len, NFS3_FHSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfstime3 (XDR *xdrs, nfstime3 *objp)
+xdr_nfstime3(XDR *xdrs, nfstime3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, &objp->seconds))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->nseconds))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, &objp->seconds))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->nseconds))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fattr3 (XDR *xdrs, fattr3 *objp)
+xdr_fattr3(XDR *xdrs, fattr3 *objp)
 {
-	 if (!xdr_ftype3 (xdrs, &objp->type))
-		 return FALSE;
-	 if (!xdr_mode3 (xdrs, &objp->mode))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->nlink))
-		 return FALSE;
-	 if (!xdr_uid3 (xdrs, &objp->uid))
-		 return FALSE;
-	 if (!xdr_gid3 (xdrs, &objp->gid))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->used))
-		 return FALSE;
-	 if (!xdr_specdata3 (xdrs, &objp->rdev))
-		 return FALSE;
-	 if (!xdr_uint64 (xdrs, &objp->fsid))
-		 return FALSE;
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->atime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->mtime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->ctime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_ftype3(xdrs, &objp->type))
+        return FALSE;
+    if (!xdr_mode3(xdrs, &objp->mode))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->nlink))
+        return FALSE;
+    if (!xdr_uid3(xdrs, &objp->uid))
+        return FALSE;
+    if (!xdr_gid3(xdrs, &objp->gid))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->used))
+        return FALSE;
+    if (!xdr_specdata3(xdrs, &objp->rdev))
+        return FALSE;
+    if (!xdr_uint64(xdrs, &objp->fsid))
+        return FALSE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->atime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->mtime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->ctime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_post_op_attr (XDR *xdrs, post_op_attr *objp)
+xdr_post_op_attr(XDR *xdrs, post_op_attr *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->attributes_follow))
-		 return FALSE;
-	switch (objp->attributes_follow) {
-	case TRUE:
-		 if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->attributes_follow))
+        return FALSE;
+    switch (objp->attributes_follow) {
+        case TRUE:
+            if (!xdr_fattr3(xdrs, &objp->post_op_attr_u.attributes))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_wcc_attr (XDR *xdrs, wcc_attr *objp)
+xdr_wcc_attr(XDR *xdrs, wcc_attr *objp)
 {
-	 if (!xdr_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->mtime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->ctime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->mtime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->ctime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pre_op_attr (XDR *xdrs, pre_op_attr *objp)
+xdr_pre_op_attr(XDR *xdrs, pre_op_attr *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->attributes_follow))
-		 return FALSE;
-	switch (objp->attributes_follow) {
-	case TRUE:
-		 if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->attributes_follow))
+        return FALSE;
+    switch (objp->attributes_follow) {
+        case TRUE:
+            if (!xdr_wcc_attr(xdrs, &objp->pre_op_attr_u.attributes))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_wcc_data (XDR *xdrs, wcc_data *objp)
+xdr_wcc_data(XDR *xdrs, wcc_data *objp)
 {
-	 if (!xdr_pre_op_attr (xdrs, &objp->before))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->after))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pre_op_attr(xdrs, &objp->before))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->after))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_post_op_fh3 (XDR *xdrs, post_op_fh3 *objp)
-{
-	 if (!xdr_bool (xdrs, &objp->handle_follows))
-		 return FALSE;
-	switch (objp->handle_follows) {
-	case TRUE:
-		 if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
-}
-
-bool_t
-xdr_time_how (XDR *xdrs, time_how *objp)
-{
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+xdr_post_op_fh3(XDR *xdrs, post_op_fh3 *objp)
+{
+    if (!xdr_bool(xdrs, &objp->handle_follows))
+        return FALSE;
+    switch (objp->handle_follows) {
+        case TRUE:
+            if (!xdr_nfs_fh3(xdrs, &objp->post_op_fh3_u.handle))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
+}
+
+bool_t
+xdr_time_how(XDR *xdrs, time_how *objp)
+{
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_set_mode3 (XDR *xdrs, set_mode3 *objp)
+xdr_set_mode3(XDR *xdrs, set_mode3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_mode3(xdrs, &objp->set_mode3_u.mode))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_uid3 (XDR *xdrs, set_uid3 *objp)
+xdr_set_uid3(XDR *xdrs, set_uid3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_uid3(xdrs, &objp->set_uid3_u.uid))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_gid3 (XDR *xdrs, set_gid3 *objp)
+xdr_set_gid3(XDR *xdrs, set_gid3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_gid3(xdrs, &objp->set_gid3_u.gid))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_size3 (XDR *xdrs, set_size3 *objp)
+xdr_set_size3(XDR *xdrs, set_size3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_size3 (xdrs, &objp->set_size3_u.size))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_size3(xdrs, &objp->set_size3_u.size))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_atime (XDR *xdrs, set_atime *objp)
+xdr_set_atime(XDR *xdrs, set_atime *objp)
 {
-	 if (!xdr_time_how (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case SET_TO_CLIENT_TIME:
-		 if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_time_how(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case SET_TO_CLIENT_TIME:
+            if (!xdr_nfstime3(xdrs, &objp->set_atime_u.atime))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_mtime (XDR *xdrs, set_mtime *objp)
+xdr_set_mtime(XDR *xdrs, set_mtime *objp)
 {
-	 if (!xdr_time_how (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case SET_TO_CLIENT_TIME:
-		 if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_time_how(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case SET_TO_CLIENT_TIME:
+            if (!xdr_nfstime3(xdrs, &objp->set_mtime_u.mtime))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_sattr3 (XDR *xdrs, sattr3 *objp)
+xdr_sattr3(XDR *xdrs, sattr3 *objp)
 {
-	 if (!xdr_set_mode3 (xdrs, &objp->mode))
-		 return FALSE;
-	 if (!xdr_set_uid3 (xdrs, &objp->uid))
-		 return FALSE;
-	 if (!xdr_set_gid3 (xdrs, &objp->gid))
-		 return FALSE;
-	 if (!xdr_set_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_set_atime (xdrs, &objp->atime))
-		 return FALSE;
-	 if (!xdr_set_mtime (xdrs, &objp->mtime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_set_mode3(xdrs, &objp->mode))
+        return FALSE;
+    if (!xdr_set_uid3(xdrs, &objp->uid))
+        return FALSE;
+    if (!xdr_set_gid3(xdrs, &objp->gid))
+        return FALSE;
+    if (!xdr_set_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_set_atime(xdrs, &objp->atime))
+        return FALSE;
+    if (!xdr_set_mtime(xdrs, &objp->mtime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_diropargs3 (XDR *xdrs, diropargs3 *objp)
+xdr_diropargs3(XDR *xdrs, diropargs3 *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3args (XDR *xdrs, getattr3args *objp)
+xdr_getattr3args(XDR *xdrs, getattr3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3resok (XDR *xdrs, getattr3resok *objp)
+xdr_getattr3resok(XDR *xdrs, getattr3resok *objp)
 {
-	 if (!xdr_fattr3 (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fattr3(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3res (XDR *xdrs, getattr3res *objp)
+xdr_getattr3res(XDR *xdrs, getattr3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_getattr3resok (xdrs, &objp->getattr3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_getattr3resok(xdrs, &objp->getattr3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_sattrguard3 (XDR *xdrs, sattrguard3 *objp)
+xdr_sattrguard3(XDR *xdrs, sattrguard3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->check))
-		 return FALSE;
-	switch (objp->check) {
-	case TRUE:
-		 if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->check))
+        return FALSE;
+    switch (objp->check) {
+        case TRUE:
+            if (!xdr_nfstime3(xdrs, &objp->sattrguard3_u.obj_ctime))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3args (XDR *xdrs, setattr3args *objp)
+xdr_setattr3args(XDR *xdrs, setattr3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_sattr3 (xdrs, &objp->new_attributes))
-		 return FALSE;
-	 if (!xdr_sattrguard3 (xdrs, &objp->guard))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_sattr3(xdrs, &objp->new_attributes))
+        return FALSE;
+    if (!xdr_sattrguard3(xdrs, &objp->guard))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3resok (XDR *xdrs, setattr3resok *objp)
+xdr_setattr3resok(XDR *xdrs, setattr3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->obj_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->obj_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3resfail (XDR *xdrs, setattr3resfail *objp)
+xdr_setattr3resfail(XDR *xdrs, setattr3resfail *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->obj_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->obj_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3res (XDR *xdrs, setattr3res *objp)
+xdr_setattr3res(XDR *xdrs, setattr3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_setattr3resok (xdrs, &objp->setattr3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_setattr3resfail (xdrs, &objp->setattr3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_setattr3resok(xdrs, &objp->setattr3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_setattr3resfail(xdrs, &objp->setattr3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3args (XDR *xdrs, lookup3args *objp)
+xdr_lookup3args(XDR *xdrs, lookup3args *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->what))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->what))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3resok (XDR *xdrs, lookup3resok *objp)
+xdr_lookup3resok(XDR *xdrs, lookup3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3resfail (XDR *xdrs, lookup3resfail *objp)
+xdr_lookup3resfail(XDR *xdrs, lookup3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3res (XDR *xdrs, lookup3res *objp)
+xdr_lookup3res(XDR *xdrs, lookup3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_lookup3resok (xdrs, &objp->lookup3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_lookup3resfail (xdrs, &objp->lookup3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_lookup3resok(xdrs, &objp->lookup3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_lookup3resfail(xdrs, &objp->lookup3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_access3args (XDR *xdrs, access3args *objp)
+xdr_access3args(XDR *xdrs, access3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->access))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->access))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3resok (XDR *xdrs, access3resok *objp)
+xdr_access3resok(XDR *xdrs, access3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->access))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->access))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3resfail (XDR *xdrs, access3resfail *objp)
+xdr_access3resfail(XDR *xdrs, access3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3res (XDR *xdrs, access3res *objp)
+xdr_access3res(XDR *xdrs, access3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_access3resok (xdrs, &objp->access3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_access3resfail (xdrs, &objp->access3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_access3resok(xdrs, &objp->access3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_access3resfail(xdrs, &objp->access3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3args (XDR *xdrs, readlink3args *objp)
+xdr_readlink3args(XDR *xdrs, readlink3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->symlink))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->symlink))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3resok (XDR *xdrs, readlink3resok *objp)
+xdr_readlink3resok(XDR *xdrs, readlink3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	 if (!xdr_nfspath3 (xdrs, &objp->data))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    if (!xdr_nfspath3(xdrs, &objp->data))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3resfail (XDR *xdrs, readlink3resfail *objp)
+xdr_readlink3resfail(XDR *xdrs, readlink3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3res (XDR *xdrs, readlink3res *objp)
+xdr_readlink3res(XDR *xdrs, readlink3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readlink3resok (xdrs, &objp->readlink3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readlink3resfail (xdrs, &objp->readlink3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readlink3resok(xdrs, &objp->readlink3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readlink3resfail(xdrs, &objp->readlink3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_read3args (XDR *xdrs, read3args *objp)
+xdr_read3args(XDR *xdrs, read3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_read3resok_nocopy (XDR *xdrs, read3resok *objp)
+xdr_read3resok_nocopy(XDR *xdrs, read3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-         if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len))
-                 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len))
+        return FALSE;
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3resok (XDR *xdrs, read3resok *objp)
+xdr_read3resok(XDR *xdrs, read3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
+                   (u_int *)&objp->data.data_len, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_read3resfail (XDR *xdrs, read3resfail *objp)
+xdr_read3resfail(XDR *xdrs, read3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3res_nocopy (XDR *xdrs, read3res *objp)
+xdr_read3res_nocopy(XDR *xdrs, read3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_read3resok_nocopy (xdrs, &objp->read3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_read3resok_nocopy(xdrs, &objp->read3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3res (XDR *xdrs, read3res *objp)
+xdr_read3res(XDR *xdrs, read3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_read3resok (xdrs, &objp->read3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_read3resok(xdrs, &objp->read3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_stable_how (XDR *xdrs, stable_how *objp)
+xdr_stable_how(XDR *xdrs, stable_how *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_write3args (XDR *xdrs, write3args *objp)
+xdr_write3args(XDR *xdrs, write3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_stable_how (xdrs, &objp->stable))
-		 return FALSE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_stable_how(xdrs, &objp->stable))
+        return FALSE;
+
+    /* Added specifically to avoid copies from the xdr buffer into
+     * the write3args structure, which will also require an already
+     * allocated buffer. That is not optimal.
+     */
+    if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len))
+        return FALSE;
 
-         /* Added specifically to avoid copies from the xdr buffer into
-          * the write3args structure, which will also require an already
-          * allocated buffer. That is not optimal.
-          */
-         if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len))
-                 return FALSE;
+    /* The remaining bytes in the xdr buffer are the bytes that need to be
+     * written. See how these bytes are extracted in the xdr_to_write3args
+     * code path. Be careful, while using the write3args structure, since
+     * only the data.data_len has been filled. The actual data is
+     * extracted in xdr_to_write3args path.
+     */
 
-         /* The remaining bytes in the xdr buffer are the bytes that need to be
-          * written. See how these bytes are extracted in the xdr_to_write3args
-          * code path. Be careful, while using the write3args structure, since
-          * only the data.data_len has been filled. The actual data is
-          * extracted in xdr_to_write3args path.
-          */
+    /*	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *)
+       &objp->data.data_len, ~0)) return FALSE;
+            */
+    return TRUE;
+}
 
-         /*	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
-		 return FALSE;
-                 */
-	return TRUE;
+bool_t
+xdr_write3resok(XDR *xdrs, write3resok *objp)
+{
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_stable_how(xdrs, &objp->committed))
+        return FALSE;
+    if (!xdr_writeverf3(xdrs, objp->verf))
+        return FALSE;
+    return TRUE;
+}
+
+bool_t
+xdr_write3resfail(XDR *xdrs, write3resfail *objp)
+{
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    return TRUE;
+}
+
+bool_t
+xdr_write3res(XDR *xdrs, write3res *objp)
+{
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_write3resok(xdrs, &objp->write3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_write3resfail(xdrs, &objp->write3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_write3resok (XDR *xdrs, write3resok *objp)
+xdr_createmode3(XDR *xdrs, createmode3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_stable_how (xdrs, &objp->committed))
-		 return FALSE;
-	 if (!xdr_writeverf3 (xdrs, objp->verf))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_write3resfail (XDR *xdrs, write3resfail *objp)
+xdr_createhow3(XDR *xdrs, createhow3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_createmode3(xdrs, &objp->mode))
+        return FALSE;
+    switch (objp->mode) {
+        case UNCHECKED:
+        case GUARDED:
+            if (!xdr_sattr3(xdrs, &objp->createhow3_u.obj_attributes))
+                return FALSE;
+            break;
+        case EXCLUSIVE:
+            if (!xdr_createverf3(xdrs, objp->createhow3_u.verf))
+                return FALSE;
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_write3res (XDR *xdrs, write3res *objp)
+xdr_create3args(XDR *xdrs, create3args *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_write3resok (xdrs, &objp->write3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_write3resfail (xdrs, &objp->write3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_createhow3(xdrs, &objp->how))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createmode3 (XDR *xdrs, createmode3 *objp)
+xdr_create3resok(XDR *xdrs, create3resok *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createhow3 (XDR *xdrs, createhow3 *objp)
+xdr_create3resfail(XDR *xdrs, create3resfail *objp)
 {
-	 if (!xdr_createmode3 (xdrs, &objp->mode))
-		 return FALSE;
-	switch (objp->mode) {
-	case UNCHECKED:
-	case GUARDED:
-		 if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes))
-			 return FALSE;
-		break;
-	case EXCLUSIVE:
-		 if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf))
-			 return FALSE;
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3args (XDR *xdrs, create3args *objp)
+xdr_create3res(XDR *xdrs, create3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_createhow3 (xdrs, &objp->how))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_create3resok(xdrs, &objp->create3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_create3resfail(xdrs, &objp->create3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_create3resok (XDR *xdrs, create3resok *objp)
+xdr_mkdir3args(XDR *xdrs, mkdir3args *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_sattr3(xdrs, &objp->attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3resfail (XDR *xdrs, create3resfail *objp)
+xdr_mkdir3resok(XDR *xdrs, mkdir3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3res (XDR *xdrs, create3res *objp)
+xdr_mkdir3resfail(XDR *xdrs, mkdir3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_create3resok (xdrs, &objp->create3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_create3resfail (xdrs, &objp->create3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3args (XDR *xdrs, mkdir3args *objp)
+xdr_mkdir3res(XDR *xdrs, mkdir3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_sattr3 (xdrs, &objp->attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_mkdir3resok(xdrs, &objp->mkdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_mkdir3resfail(xdrs, &objp->mkdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3resok (XDR *xdrs, mkdir3resok *objp)
+xdr_symlinkdata3(XDR *xdrs, symlinkdata3 *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_sattr3(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    if (!xdr_nfspath3(xdrs, &objp->symlink_data))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3resfail (XDR *xdrs, mkdir3resfail *objp)
+xdr_symlink3args(XDR *xdrs, symlink3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_symlinkdata3(xdrs, &objp->symlink))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3res (XDR *xdrs, mkdir3res *objp)
+xdr_symlink3resok(XDR *xdrs, symlink3resok *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_mkdir3resok (xdrs, &objp->mkdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_mkdir3resfail (xdrs, &objp->mkdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlinkdata3 (XDR *xdrs, symlinkdata3 *objp)
+xdr_symlink3resfail(XDR *xdrs, symlink3resfail *objp)
 {
-	 if (!xdr_sattr3 (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	 if (!xdr_nfspath3 (xdrs, &objp->symlink_data))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3args (XDR *xdrs, symlink3args *objp)
+xdr_symlink3res(XDR *xdrs, symlink3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_symlinkdata3 (xdrs, &objp->symlink))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_symlink3resok(xdrs, &objp->symlink3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_symlink3resfail(xdrs, &objp->symlink3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3resok (XDR *xdrs, symlink3resok *objp)
+xdr_devicedata3(XDR *xdrs, devicedata3 *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_sattr3(xdrs, &objp->dev_attributes))
+        return FALSE;
+    if (!xdr_specdata3(xdrs, &objp->spec))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3resfail (XDR *xdrs, symlink3resfail *objp)
+xdr_mknoddata3(XDR *xdrs, mknoddata3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_ftype3(xdrs, &objp->type))
+        return FALSE;
+    switch (objp->type) {
+        case NF3CHR:
+        case NF3BLK:
+            if (!xdr_devicedata3(xdrs, &objp->mknoddata3_u.device))
+                return FALSE;
+            break;
+        case NF3SOCK:
+        case NF3FIFO:
+            if (!xdr_sattr3(xdrs, &objp->mknoddata3_u.pipe_attributes))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3res (XDR *xdrs, symlink3res *objp)
+xdr_mknod3args(XDR *xdrs, mknod3args *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_symlink3resok (xdrs, &objp->symlink3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_symlink3resfail (xdrs, &objp->symlink3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_mknoddata3(xdrs, &objp->what))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_devicedata3 (XDR *xdrs, devicedata3 *objp)
+xdr_mknod3resok(XDR *xdrs, mknod3resok *objp)
 {
-	 if (!xdr_sattr3 (xdrs, &objp->dev_attributes))
-		 return FALSE;
-	 if (!xdr_specdata3 (xdrs, &objp->spec))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknoddata3 (XDR *xdrs, mknoddata3 *objp)
+xdr_mknod3resfail(XDR *xdrs, mknod3resfail *objp)
 {
-	 if (!xdr_ftype3 (xdrs, &objp->type))
-		 return FALSE;
-	switch (objp->type) {
-	case NF3CHR:
-	case NF3BLK:
-		 if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.device))
-			 return FALSE;
-		break;
-	case NF3SOCK:
-	case NF3FIFO:
-		 if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3args (XDR *xdrs, mknod3args *objp)
+xdr_mknod3res(XDR *xdrs, mknod3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_mknoddata3 (xdrs, &objp->what))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_mknod3resok(xdrs, &objp->mknod3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_mknod3resfail(xdrs, &objp->mknod3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3resok (XDR *xdrs, mknod3resok *objp)
+xdr_remove3args(XDR *xdrs, remove3args *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3resfail (XDR *xdrs, mknod3resfail *objp)
+xdr_remove3resok(XDR *xdrs, remove3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3res (XDR *xdrs, mknod3res *objp)
+xdr_remove3resfail(XDR *xdrs, remove3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_mknod3resok (xdrs, &objp->mknod3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_mknod3resfail (xdrs, &objp->mknod3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3args (XDR *xdrs, remove3args *objp)
+xdr_remove3res(XDR *xdrs, remove3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_remove3resok(xdrs, &objp->remove3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_remove3resfail(xdrs, &objp->remove3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_remove3resok (XDR *xdrs, remove3resok *objp)
+xdr_rmdir3args(XDR *xdrs, rmdir3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3resfail (XDR *xdrs, remove3resfail *objp)
+xdr_rmdir3resok(XDR *xdrs, rmdir3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3res (XDR *xdrs, remove3res *objp)
+xdr_rmdir3resfail(XDR *xdrs, rmdir3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_remove3resok (xdrs, &objp->remove3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_remove3resfail (xdrs, &objp->remove3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3args (XDR *xdrs, rmdir3args *objp)
+xdr_rmdir3res(XDR *xdrs, rmdir3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_rmdir3resok(xdrs, &objp->rmdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_rmdir3resfail(xdrs, &objp->rmdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3resok (XDR *xdrs, rmdir3resok *objp)
+xdr_rename3args(XDR *xdrs, rename3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->from))
+        return FALSE;
+    if (!xdr_diropargs3(xdrs, &objp->to))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3resfail (XDR *xdrs, rmdir3resfail *objp)
+xdr_rename3resok(XDR *xdrs, rename3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->todir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3res (XDR *xdrs, rmdir3res *objp)
+xdr_rename3resfail(XDR *xdrs, rename3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_rmdir3resok (xdrs, &objp->rmdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_rmdir3resfail (xdrs, &objp->rmdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->todir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3args (XDR *xdrs, rename3args *objp)
+xdr_rename3res(XDR *xdrs, rename3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->from))
-		 return FALSE;
-	 if (!xdr_diropargs3 (xdrs, &objp->to))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_rename3resok(xdrs, &objp->rename3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_rename3resfail(xdrs, &objp->rename3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_rename3resok (XDR *xdrs, rename3resok *objp)
+xdr_link3args(XDR *xdrs, link3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->todir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_diropargs3(xdrs, &objp->link))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3resfail (XDR *xdrs, rename3resfail *objp)
+xdr_link3resok(XDR *xdrs, link3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->todir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3res (XDR *xdrs, rename3res *objp)
+xdr_link3resfail(XDR *xdrs, link3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_rename3resok (xdrs, &objp->rename3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_rename3resfail (xdrs, &objp->rename3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3args (XDR *xdrs, link3args *objp)
+xdr_link3res(XDR *xdrs, link3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_diropargs3 (xdrs, &objp->link))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_link3resok(xdrs, &objp->link3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_link3resfail(xdrs, &objp->link3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_link3resok (XDR *xdrs, link3resok *objp)
+xdr_readdir3args(XDR *xdrs, readdir3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3resfail (XDR *xdrs, link3resfail *objp)
+xdr_entry3(XDR *xdrs, entry3 *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entry3),
+                     (xdrproc_t)xdr_entry3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3res (XDR *xdrs, link3res *objp)
+xdr_dirlist3(XDR *xdrs, dirlist3 *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_link3resok (xdrs, &objp->link3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_link3resfail (xdrs, &objp->link3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entry3),
+                     (xdrproc_t)xdr_entry3))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3args (XDR *xdrs, readdir3args *objp)
+xdr_readdir3resok(XDR *xdrs, readdir3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_dirlist3(xdrs, &objp->reply))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_entry3 (XDR *xdrs, entry3 *objp)
+xdr_readdir3resfail(XDR *xdrs, readdir3resfail *objp)
 {
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirlist3 (XDR *xdrs, dirlist3 *objp)
+xdr_readdir3res(XDR *xdrs, readdir3res *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readdir3resok(xdrs, &objp->readdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readdir3resfail(xdrs, &objp->readdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3resok (XDR *xdrs, readdir3resok *objp)
+xdr_readdirp3args(XDR *xdrs, readdirp3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_dirlist3 (xdrs, &objp->reply))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->dircount))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->maxcount))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3resfail (XDR *xdrs, readdir3resfail *objp)
+xdr_entryp3(XDR *xdrs, entryp3 *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->name_attributes))
+        return FALSE;
+    if (!xdr_post_op_fh3(xdrs, &objp->name_handle))
+        return FALSE;
+    if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entryp3),
+                     (xdrproc_t)xdr_entryp3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3res (XDR *xdrs, readdir3res *objp)
+xdr_dirlistp3(XDR *xdrs, dirlistp3 *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readdir3resok (xdrs, &objp->readdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readdir3resfail (xdrs, &objp->readdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entryp3),
+                     (xdrproc_t)xdr_entryp3))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3args (XDR *xdrs, readdirp3args *objp)
+xdr_readdirp3resok(XDR *xdrs, readdirp3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->dircount))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->maxcount))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_dirlistp3(xdrs, &objp->reply))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_entryp3 (XDR *xdrs, entryp3 *objp)
+xdr_readdirp3resfail(XDR *xdrs, readdirp3resfail *objp)
 {
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->name_attributes))
-		 return FALSE;
-	 if (!xdr_post_op_fh3 (xdrs, &objp->name_handle))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entryp3), (xdrproc_t) xdr_entryp3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirlistp3 (XDR *xdrs, dirlistp3 *objp)
+xdr_readdirp3res(XDR *xdrs, readdirp3res *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryp3), (xdrproc_t) xdr_entryp3))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readdirp3resok(xdrs, &objp->readdirp3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readdirp3resfail(xdrs, &objp->readdirp3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3resok (XDR *xdrs, readdirp3resok *objp)
+xdr_fsstat3args(XDR *xdrs, fsstat3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_dirlistp3 (xdrs, &objp->reply))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->fsroot))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3resfail (XDR *xdrs, readdirp3resfail *objp)
+xdr_fsstat3resok(XDR *xdrs, fsstat3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->tbytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->fbytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->abytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->tfiles))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->ffiles))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->afiles))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->invarsec))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3res (XDR *xdrs, readdirp3res *objp)
+xdr_fsstat3resfail(XDR *xdrs, fsstat3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readdirp3resok (xdrs, &objp->readdirp3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readdirp3resfail (xdrs, &objp->readdirp3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3args (XDR *xdrs, fsstat3args *objp)
+xdr_fsstat3res(XDR *xdrs, fsstat3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->fsroot))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_fsstat3resok(xdrs, &objp->fsstat3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_fsstat3resfail(xdrs, &objp->fsstat3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3resok (XDR *xdrs, fsstat3resok *objp)
+xdr_fsinfo3args(XDR *xdrs, fsinfo3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->tbytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->fbytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->abytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->tfiles))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->ffiles))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->afiles))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->invarsec))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->fsroot))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3resfail (XDR *xdrs, fsstat3resfail *objp)
+xdr_fsinfo3resok(XDR *xdrs, fsinfo3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtpref))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtmult))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtpref))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtmult))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->dtpref))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->maxfilesize))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->time_delta))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->properties))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3res (XDR *xdrs, fsstat3res *objp)
+xdr_fsinfo3resfail(XDR *xdrs, fsinfo3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_fsstat3resok (xdrs, &objp->fsstat3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_fsstat3resfail (xdrs, &objp->fsstat3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsinfo3args (XDR *xdrs, fsinfo3args *objp)
+xdr_fsinfo3res(XDR *xdrs, fsinfo3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->fsroot))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_fsinfo3resok(xdrs, &objp->fsinfo3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_fsinfo3resfail(xdrs, &objp->fsinfo3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
+}
+
+bool_t
+xdr_pathconf3args(XDR *xdrs, pathconf3args *objp)
+{
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsinfo3resok (XDR *xdrs, fsinfo3resok *objp)
+xdr_pathconf3resok(XDR *xdrs, pathconf3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtpref))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtmult))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtpref))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtmult))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->dtpref))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->maxfilesize))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->time_delta))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->properties))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_fsinfo3resfail (XDR *xdrs, fsinfo3resfail *objp)
-{
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_fsinfo3res (XDR *xdrs, fsinfo3res *objp)
-{
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_fsinfo3resok (xdrs, &objp->fsinfo3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_fsinfo3resfail (xdrs, &objp->fsinfo3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
-}
-
-bool_t
-xdr_pathconf3args (XDR *xdrs, pathconf3args *objp)
-{
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_pathconf3resok (XDR *xdrs, pathconf3resok *objp)
-{
-	register int32_t *buf;
-
-
-	if (xdrs->x_op == XDR_ENCODE) {
-		 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->linkmax))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->name_max))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_bool (xdrs, &objp->no_trunc))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->chown_restricted))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_insensitive))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_preserving))
-				 return FALSE;
-		} else {
-			IXDR_PUT_BOOL(buf, objp->no_trunc);
-			IXDR_PUT_BOOL(buf, objp->chown_restricted);
-			IXDR_PUT_BOOL(buf, objp->case_insensitive);
-			IXDR_PUT_BOOL(buf, objp->case_preserving);
-		}
-		return TRUE;
-	} else if (xdrs->x_op == XDR_DECODE) {
-		 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->linkmax))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->name_max))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_bool (xdrs, &objp->no_trunc))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->chown_restricted))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_insensitive))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_preserving))
-				 return FALSE;
-		} else {
-			objp->no_trunc = IXDR_GET_BOOL(buf);
-			objp->chown_restricted = IXDR_GET_BOOL(buf);
-			objp->case_insensitive = IXDR_GET_BOOL(buf);
-			objp->case_preserving = IXDR_GET_BOOL(buf);
-		}
-	 return TRUE;
-	}
+    register int32_t *buf;
+
+    if (xdrs->x_op == XDR_ENCODE) {
+        if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->linkmax))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->name_max))
+            return FALSE;
+        buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
+        if (buf == NULL) {
+            if (!xdr_bool(xdrs, &objp->no_trunc))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->chown_restricted))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_insensitive))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_preserving))
+                return FALSE;
+        } else {
+            IXDR_PUT_BOOL(buf, objp->no_trunc);
+            IXDR_PUT_BOOL(buf, objp->chown_restricted);
+            IXDR_PUT_BOOL(buf, objp->case_insensitive);
+            IXDR_PUT_BOOL(buf, objp->case_preserving);
+        }
+        return TRUE;
+    } else if (xdrs->x_op == XDR_DECODE) {
+        if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->linkmax))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->name_max))
+            return FALSE;
+        buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
+        if (buf == NULL) {
+            if (!xdr_bool(xdrs, &objp->no_trunc))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->chown_restricted))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_insensitive))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_preserving))
+                return FALSE;
+        } else {
+            objp->no_trunc = IXDR_GET_BOOL(buf);
+            objp->chown_restricted = IXDR_GET_BOOL(buf);
+            objp->case_insensitive = IXDR_GET_BOOL(buf);
+            objp->case_preserving = IXDR_GET_BOOL(buf);
+        }
+        return TRUE;
+    }
 
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->linkmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->name_max))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->no_trunc))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->chown_restricted))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->case_insensitive))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->case_preserving))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->linkmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->name_max))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->no_trunc))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->chown_restricted))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->case_insensitive))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->case_preserving))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pathconf3resfail (XDR *xdrs, pathconf3resfail *objp)
+xdr_pathconf3resfail(XDR *xdrs, pathconf3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pathconf3res (XDR *xdrs, pathconf3res *objp)
+xdr_pathconf3res(XDR *xdrs, pathconf3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_pathconf3resok (xdrs, &objp->pathconf3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_pathconf3resfail (xdrs, &objp->pathconf3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_pathconf3resok(xdrs, &objp->pathconf3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_pathconf3resfail(xdrs, &objp->pathconf3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_commit3args (XDR *xdrs, commit3args *objp)
+xdr_commit3args(XDR *xdrs, commit3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3resok (XDR *xdrs, commit3resok *objp)
+xdr_commit3resok(XDR *xdrs, commit3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	 if (!xdr_writeverf3 (xdrs, objp->verf))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    if (!xdr_writeverf3(xdrs, objp->verf))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3resfail (XDR *xdrs, commit3resfail *objp)
+xdr_commit3resfail(XDR *xdrs, commit3resfail *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3res (XDR *xdrs, commit3res *objp)
+xdr_commit3res(XDR *xdrs, commit3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_commit3resok (xdrs, &objp->commit3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_commit3resfail (xdrs, &objp->commit3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_commit3resok(xdrs, &objp->commit3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_commit3resfail(xdrs, &objp->commit3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_fhandle3 (XDR *xdrs, fhandle3 *objp)
+xdr_fhandle3(XDR *xdrs, fhandle3 *objp)
 {
-	 if (!xdr_bytes (xdrs, (char **)&objp->fhandle3_val, (u_int *) &objp->fhandle3_len, FHSIZE3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val,
+                   (u_int *)&objp->fhandle3_len, FHSIZE3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirpath (XDR *xdrs, dirpath *objp)
+xdr_dirpath(XDR *xdrs, dirpath *objp)
 {
-	 if (!xdr_string (xdrs, objp, MNTPATHLEN))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, MNTPATHLEN))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_name (XDR *xdrs, name *objp)
+xdr_name(XDR *xdrs, name *objp)
 {
-	 if (!xdr_string (xdrs, objp, MNTNAMLEN))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, MNTNAMLEN))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountstat3 (XDR *xdrs, mountstat3 *objp)
+xdr_mountstat3(XDR *xdrs, mountstat3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountres3_ok (XDR *xdrs, mountres3_ok *objp)
+xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)
 {
-	 if (!xdr_fhandle3 (xdrs, &objp->fhandle))
-		 return FALSE;
-	 if (!xdr_array (xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (u_int *) &objp->auth_flavors.auth_flavors_len, ~0,
-		sizeof (int), (xdrproc_t) xdr_int))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fhandle3(xdrs, &objp->fhandle))
+        return FALSE;
+    if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val,
+                   (u_int *)&objp->auth_flavors.auth_flavors_len, ~0,
+                   sizeof(int), (xdrproc_t)xdr_int))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountres3 (XDR *xdrs, mountres3 *objp)
+xdr_mountres3(XDR *xdrs, mountres3 *objp)
 {
-	 if (!xdr_mountstat3 (xdrs, &objp->fhs_status))
-		 return FALSE;
-	switch (objp->fhs_status) {
-	case MNT3_OK:
-		 if (!xdr_mountres3_ok (xdrs, &objp->mountres3_u.mountinfo))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_mountstat3(xdrs, &objp->fhs_status))
+        return FALSE;
+    switch (objp->fhs_status) {
+        case MNT3_OK:
+            if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mountlist (XDR *xdrs, mountlist *objp)
+xdr_mountlist(XDR *xdrs, mountlist *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mountbody),
+                     (xdrproc_t)xdr_mountbody))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountbody (XDR *xdrs, mountbody *objp)
+xdr_mountbody(XDR *xdrs, mountbody *objp)
 {
-	 if (!xdr_name (xdrs, &objp->ml_hostname))
-		 return FALSE;
-	 if (!xdr_dirpath (xdrs, &objp->ml_directory))
-		 return FALSE;
-	 if (!xdr_mountlist (xdrs, &objp->ml_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_name(xdrs, &objp->ml_hostname))
+        return FALSE;
+    if (!xdr_dirpath(xdrs, &objp->ml_directory))
+        return FALSE;
+    if (!xdr_mountlist(xdrs, &objp->ml_next))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_groups (XDR *xdrs, groups *objp)
+xdr_groups(XDR *xdrs, groups *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct groupnode),
+                     (xdrproc_t)xdr_groupnode))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_groupnode (XDR *xdrs, groupnode *objp)
+xdr_groupnode(XDR *xdrs, groupnode *objp)
 {
-	 if (!xdr_name (xdrs, &objp->gr_name))
-		 return FALSE;
-	 if (!xdr_groups (xdrs, &objp->gr_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_name(xdrs, &objp->gr_name))
+        return FALSE;
+    if (!xdr_groups(xdrs, &objp->gr_next))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_exports (XDR *xdrs, exports *objp)
+xdr_exports(XDR *xdrs, exports *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct exportnode),
+                     (xdrproc_t)xdr_exportnode))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_exportnode (XDR *xdrs, exportnode *objp)
+xdr_exportnode(XDR *xdrs, exportnode *objp)
 {
-	 if (!xdr_dirpath (xdrs, &objp->ex_dir))
-		 return FALSE;
-	 if (!xdr_groups (xdrs, &objp->ex_groups))
-		 return FALSE;
-	 if (!xdr_exports (xdrs, &objp->ex_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_dirpath(xdrs, &objp->ex_dir))
+        return FALSE;
+    if (!xdr_groups(xdrs, &objp->ex_groups))
+        return FALSE;
+    if (!xdr_exports(xdrs, &objp->ex_next))
+        return FALSE;
+    return TRUE;
 }
 
 static void
-xdr_free_groupnode (struct groupnode *group)
+xdr_free_groupnode(struct groupnode *group)
 {
-        if (!group)
-                return;
+    if (!group)
+        return;
 
-        if (group->gr_next)
-                xdr_free_groupnode (group->gr_next);
+    if (group->gr_next)
+        xdr_free_groupnode(group->gr_next);
 
-        GF_FREE (group->gr_name);
-        GF_FREE (group);
+    GF_FREE(group->gr_name);
+    GF_FREE(group);
 }
 
 void
-xdr_free_exports_list (struct exportnode *first)
+xdr_free_exports_list(struct exportnode *first)
 {
-        struct exportnode       *elist = NULL;
+    struct exportnode *elist = NULL;
 
-        if (!first)
-                return;
+    if (!first)
+        return;
 
-        while (first) {
-                elist = first->ex_next;
-                GF_FREE (first->ex_dir);
+    while (first) {
+        elist = first->ex_next;
+        GF_FREE(first->ex_dir);
 
-                xdr_free_groupnode (first->ex_groups);
-
-                GF_FREE (first);
-                first = elist;
-        }
+        xdr_free_groupnode(first->ex_groups);
 
+        GF_FREE(first);
+        first = elist;
+    }
 }
 
-
 void
-xdr_free_mountlist (mountlist ml)
+xdr_free_mountlist(mountlist ml)
 {
-        struct mountbody        *next = NULL;
+    struct mountbody *next = NULL;
 
-        if (!ml)
-                return;
+    if (!ml)
+        return;
 
-        while (ml) {
-                GF_FREE (ml->ml_hostname);
-                GF_FREE (ml->ml_directory);
-                next = ml->ml_next;
-                GF_FREE (ml);
-                ml = next;
-        }
+    while (ml) {
+        GF_FREE(ml->ml_hostname);
+        GF_FREE(ml->ml_directory);
+        next = ml->ml_next;
+        GF_FREE(ml);
+        ml = next;
+    }
 
-        return;
+    return;
 }
 
-
 /* Free statements are based on the way sunrpc xdr decoding
  * code performs memory allocations.
  */
 void
-xdr_free_write3args_nocopy (write3args *wa)
+xdr_free_write3args_nocopy(write3args *wa)
 {
-        if (!wa)
-                return;
+    if (!wa)
+        return;
 
-        FREE (wa->file.data.data_val);
+    FREE(wa->file.data.data_val);
 }
diff --git a/rpc/xdr/src/xdr-nfs3.h b/rpc/xdr/src/xdr-nfs3.h
index 3861771e299..b7f5abefffd 100644
--- a/rpc/xdr/src/xdr-nfs3.h
+++ b/rpc/xdr/src/xdr-nfs3.h
@@ -14,25 +14,27 @@
 #include <rpc/rpc.h>
 #include <sys/types.h>
 
-#define NFS3_FHSIZE             64
-#define NFS3_COOKIEVERFSIZE     8
-#define NFS3_CREATEVERFSIZE     8
-#define NFS3_WRITEVERFSIZE      8
+#define NFS3_FHSIZE 64
+#define NFS3_COOKIEVERFSIZE 8
+#define NFS3_CREATEVERFSIZE 8
+#define NFS3_WRITEVERFSIZE 8
 
-#define NFS3_ENTRY3_FIXED_SIZE  24
-#define NFS3_POSTOPATTR_SIZE    88
-#define NFS3_READDIR_RESOK_SIZE (NFS3_POSTOPATTR_SIZE + sizeof (bool_t) + NFS3_COOKIEVERFSIZE)
+#define NFS3_ENTRY3_FIXED_SIZE 24
+#define NFS3_POSTOPATTR_SIZE 88
+#define NFS3_READDIR_RESOK_SIZE                                                \
+    (NFS3_POSTOPATTR_SIZE + sizeof(bool_t) + NFS3_COOKIEVERFSIZE)
 
 /* In size of post_op_fh3, the length of the file handle will have to be
  * included separately since we have variable length fh. Here we only account
  * for the field for handle_follows and for the file handle length field.
  */
-#define NFS3_POSTOPFH3_FIXED_SIZE     (sizeof (bool_t) + sizeof (uint32_t))
+#define NFS3_POSTOPFH3_FIXED_SIZE (sizeof(bool_t) + sizeof(uint32_t))
 
 /* Similarly, the size of the entry will have to include the variable length
  * file handle and the length of the entry name.
  */
-#define NFS3_ENTRYP3_FIXED_SIZE  (NFS3_ENTRY3_FIXED_SIZE + NFS3_POSTOPATTR_SIZE + NFS3_POSTOPFH3_FIXED_SIZE)
+#define NFS3_ENTRYP3_FIXED_SIZE                                                \
+    (NFS3_ENTRY3_FIXED_SIZE + NFS3_POSTOPATTR_SIZE + NFS3_POSTOPFH3_FIXED_SIZE)
 
 typedef uint64_t uint64;
 typedef int64_t int64;
@@ -52,284 +54,284 @@ typedef uint64 offset3;
 typedef uint32 mode3;
 typedef uint32 count3;
 
-#define NFS3MODE_SETXUID        0x00800
-#define NFS3MODE_SETXGID        0x00400
-#define NFS3MODE_SAVESWAPTXT    0x00200
-#define NFS3MODE_ROWNER         0x00100
-#define NFS3MODE_WOWNER         0x00080
-#define NFS3MODE_XOWNER         0x00040
-#define NFS3MODE_RGROUP         0x00020
-#define NFS3MODE_WGROUP         0x00010
-#define NFS3MODE_XGROUP         0x00008
-#define NFS3MODE_ROTHER         0x00004
-#define NFS3MODE_WOTHER         0x00002
-#define NFS3MODE_XOTHER         0x00001
+#define NFS3MODE_SETXUID 0x00800
+#define NFS3MODE_SETXGID 0x00400
+#define NFS3MODE_SAVESWAPTXT 0x00200
+#define NFS3MODE_ROWNER 0x00100
+#define NFS3MODE_WOWNER 0x00080
+#define NFS3MODE_XOWNER 0x00040
+#define NFS3MODE_RGROUP 0x00020
+#define NFS3MODE_WGROUP 0x00010
+#define NFS3MODE_XGROUP 0x00008
+#define NFS3MODE_ROTHER 0x00004
+#define NFS3MODE_WOTHER 0x00002
+#define NFS3MODE_XOTHER 0x00001
 
 enum nfsstat3 {
-	NFS3_OK = 0,
-	NFS3ERR_PERM = 1,
-	NFS3ERR_NOENT = 2,
-	NFS3ERR_IO = 5,
-	NFS3ERR_NXIO = 6,
-	NFS3ERR_ACCES = 13,
-	NFS3ERR_EXIST = 17,
-	NFS3ERR_XDEV = 18,
-	NFS3ERR_NODEV = 19,
-	NFS3ERR_NOTDIR = 20,
-	NFS3ERR_ISDIR = 21,
-	NFS3ERR_INVAL = 22,
-	NFS3ERR_FBIG = 27,
-	NFS3ERR_NOSPC = 28,
-	NFS3ERR_ROFS = 30,
-	NFS3ERR_MLINK = 31,
-	NFS3ERR_NAMETOOLONG = 63,
-	NFS3ERR_NOTEMPTY = 66,
-	NFS3ERR_DQUOT = 69,
-	NFS3ERR_STALE = 70,
-	NFS3ERR_REMOTE = 71,
-	NFS3ERR_BADHANDLE = 10001,
-	NFS3ERR_NOT_SYNC = 10002,
-	NFS3ERR_BAD_COOKIE = 10003,
-	NFS3ERR_NOTSUPP = 10004,
-	NFS3ERR_TOOSMALL = 10005,
-	NFS3ERR_SERVERFAULT = 10006,
-	NFS3ERR_BADTYPE = 10007,
-	NFS3ERR_JUKEBOX = 10008,
-	NFS3ERR_END_OF_LIST = -1,
+    NFS3_OK = 0,
+    NFS3ERR_PERM = 1,
+    NFS3ERR_NOENT = 2,
+    NFS3ERR_IO = 5,
+    NFS3ERR_NXIO = 6,
+    NFS3ERR_ACCES = 13,
+    NFS3ERR_EXIST = 17,
+    NFS3ERR_XDEV = 18,
+    NFS3ERR_NODEV = 19,
+    NFS3ERR_NOTDIR = 20,
+    NFS3ERR_ISDIR = 21,
+    NFS3ERR_INVAL = 22,
+    NFS3ERR_FBIG = 27,
+    NFS3ERR_NOSPC = 28,
+    NFS3ERR_ROFS = 30,
+    NFS3ERR_MLINK = 31,
+    NFS3ERR_NAMETOOLONG = 63,
+    NFS3ERR_NOTEMPTY = 66,
+    NFS3ERR_DQUOT = 69,
+    NFS3ERR_STALE = 70,
+    NFS3ERR_REMOTE = 71,
+    NFS3ERR_BADHANDLE = 10001,
+    NFS3ERR_NOT_SYNC = 10002,
+    NFS3ERR_BAD_COOKIE = 10003,
+    NFS3ERR_NOTSUPP = 10004,
+    NFS3ERR_TOOSMALL = 10005,
+    NFS3ERR_SERVERFAULT = 10006,
+    NFS3ERR_BADTYPE = 10007,
+    NFS3ERR_JUKEBOX = 10008,
+    NFS3ERR_END_OF_LIST = -1,
 };
 typedef enum nfsstat3 nfsstat3;
 
 enum ftype3 {
-	NF3REG = 1,
-	NF3DIR = 2,
-	NF3BLK = 3,
-	NF3CHR = 4,
-	NF3LNK = 5,
-	NF3SOCK = 6,
-	NF3FIFO = 7,
+    NF3REG = 1,
+    NF3DIR = 2,
+    NF3BLK = 3,
+    NF3CHR = 4,
+    NF3LNK = 5,
+    NF3SOCK = 6,
+    NF3FIFO = 7,
 };
 typedef enum ftype3 ftype3;
 
 struct specdata3 {
-	uint32 specdata1;
-	uint32 specdata2;
+    uint32 specdata1;
+    uint32 specdata2;
 };
 typedef struct specdata3 specdata3;
 
 struct nfs_fh3 {
-	struct {
-		u_int data_len;
-		char *data_val;
-	} data;
+    struct {
+        u_int data_len;
+        char *data_val;
+    } data;
 };
 typedef struct nfs_fh3 nfs_fh3;
 
 struct nfstime3 {
-	uint32 seconds;
-	uint32 nseconds;
+    uint32 seconds;
+    uint32 nseconds;
 };
 typedef struct nfstime3 nfstime3;
 
 struct fattr3 {
-	ftype3 type;
-	mode3 mode;
-	uint32 nlink;
-	uid3 uid;
-	gid3 gid;
-	size3 size;
-	size3 used;
-	specdata3 rdev;
-	uint64 fsid;
-	fileid3 fileid;
-	nfstime3 atime;
-	nfstime3 mtime;
-	nfstime3 ctime;
+    ftype3 type;
+    mode3 mode;
+    uint32 nlink;
+    uid3 uid;
+    gid3 gid;
+    size3 size;
+    size3 used;
+    specdata3 rdev;
+    uint64 fsid;
+    fileid3 fileid;
+    nfstime3 atime;
+    nfstime3 mtime;
+    nfstime3 ctime;
 };
 typedef struct fattr3 fattr3;
 
 struct post_op_attr {
-	bool_t attributes_follow;
-	union {
-		fattr3 attributes;
-	} post_op_attr_u;
+    bool_t attributes_follow;
+    union {
+        fattr3 attributes;
+    } post_op_attr_u;
 };
 typedef struct post_op_attr post_op_attr;
 
 struct wcc_attr {
-	size3 size;
-	nfstime3 mtime;
-	nfstime3 ctime;
+    size3 size;
+    nfstime3 mtime;
+    nfstime3 ctime;
 };
 typedef struct wcc_attr wcc_attr;
 
 struct pre_op_attr {
-	bool_t attributes_follow;
-	union {
-		wcc_attr attributes;
-	} pre_op_attr_u;
+    bool_t attributes_follow;
+    union {
+        wcc_attr attributes;
+    } pre_op_attr_u;
 };
 typedef struct pre_op_attr pre_op_attr;
 
 struct wcc_data {
-	pre_op_attr before;
-	post_op_attr after;
+    pre_op_attr before;
+    post_op_attr after;
 };
 typedef struct wcc_data wcc_data;
 
 struct post_op_fh3 {
-	bool_t handle_follows;
-	union {
-		nfs_fh3 handle;
-	} post_op_fh3_u;
+    bool_t handle_follows;
+    union {
+        nfs_fh3 handle;
+    } post_op_fh3_u;
 };
 typedef struct post_op_fh3 post_op_fh3;
 
 enum time_how {
-	DONT_CHANGE = 0,
-	SET_TO_SERVER_TIME = 1,
-	SET_TO_CLIENT_TIME = 2,
+    DONT_CHANGE = 0,
+    SET_TO_SERVER_TIME = 1,
+    SET_TO_CLIENT_TIME = 2,
 };
 typedef enum time_how time_how;
 
 struct set_mode3 {
-	bool_t set_it;
-	union {
-		mode3 mode;
-	} set_mode3_u;
+    bool_t set_it;
+    union {
+        mode3 mode;
+    } set_mode3_u;
 };
 typedef struct set_mode3 set_mode3;
 
 struct set_uid3 {
-	bool_t set_it;
-	union {
-		uid3 uid;
-	} set_uid3_u;
+    bool_t set_it;
+    union {
+        uid3 uid;
+    } set_uid3_u;
 };
 typedef struct set_uid3 set_uid3;
 
 struct set_gid3 {
-	bool_t set_it;
-	union {
-		gid3 gid;
-	} set_gid3_u;
+    bool_t set_it;
+    union {
+        gid3 gid;
+    } set_gid3_u;
 };
 typedef struct set_gid3 set_gid3;
 
 struct set_size3 {
-	bool_t set_it;
-	union {
-		size3 size;
-	} set_size3_u;
+    bool_t set_it;
+    union {
+        size3 size;
+    } set_size3_u;
 };
 typedef struct set_size3 set_size3;
 
 struct set_atime {
-	time_how set_it;
-	union {
-		nfstime3 atime;
-	} set_atime_u;
+    time_how set_it;
+    union {
+        nfstime3 atime;
+    } set_atime_u;
 };
 typedef struct set_atime set_atime;
 
 struct set_mtime {
-	time_how set_it;
-	union {
-		nfstime3 mtime;
-	} set_mtime_u;
+    time_how set_it;
+    union {
+        nfstime3 mtime;
+    } set_mtime_u;
 };
 typedef struct set_mtime set_mtime;
 
 struct sattr3 {
-	set_mode3 mode;
-	set_uid3 uid;
-	set_gid3 gid;
-	set_size3 size;
-	set_atime atime;
-	set_mtime mtime;
+    set_mode3 mode;
+    set_uid3 uid;
+    set_gid3 gid;
+    set_size3 size;
+    set_atime atime;
+    set_mtime mtime;
 };
 typedef struct sattr3 sattr3;
 
 struct diropargs3 {
-	nfs_fh3 dir;
-	filename3 name;
+    nfs_fh3 dir;
+    filename3 name;
 };
 typedef struct diropargs3 diropargs3;
 
 struct getattr3args {
-	nfs_fh3 object;
+    nfs_fh3 object;
 };
 typedef struct getattr3args getattr3args;
 
 struct getattr3resok {
-	fattr3 obj_attributes;
+    fattr3 obj_attributes;
 };
 typedef struct getattr3resok getattr3resok;
 
 struct getattr3res {
-	nfsstat3 status;
-	union {
-		getattr3resok resok;
-	} getattr3res_u;
+    nfsstat3 status;
+    union {
+        getattr3resok resok;
+    } getattr3res_u;
 };
 typedef struct getattr3res getattr3res;
 
 struct sattrguard3 {
-	bool_t check;
-	union {
-		nfstime3 obj_ctime;
-	} sattrguard3_u;
+    bool_t check;
+    union {
+        nfstime3 obj_ctime;
+    } sattrguard3_u;
 };
 typedef struct sattrguard3 sattrguard3;
 
 struct setattr3args {
-	nfs_fh3 object;
-	sattr3 new_attributes;
-	sattrguard3 guard;
+    nfs_fh3 object;
+    sattr3 new_attributes;
+    sattrguard3 guard;
 };
 typedef struct setattr3args setattr3args;
 
 struct setattr3resok {
-	wcc_data obj_wcc;
+    wcc_data obj_wcc;
 };
 typedef struct setattr3resok setattr3resok;
 
 struct setattr3resfail {
-	wcc_data obj_wcc;
+    wcc_data obj_wcc;
 };
 typedef struct setattr3resfail setattr3resfail;
 
 struct setattr3res {
-	nfsstat3 status;
-	union {
-		setattr3resok resok;
-		setattr3resfail resfail;
-	} setattr3res_u;
+    nfsstat3 status;
+    union {
+        setattr3resok resok;
+        setattr3resfail resfail;
+    } setattr3res_u;
 };
 typedef struct setattr3res setattr3res;
 
 struct lookup3args {
-	diropargs3 what;
+    diropargs3 what;
 };
 typedef struct lookup3args lookup3args;
 
 struct lookup3resok {
-	nfs_fh3 object;
-	post_op_attr obj_attributes;
-	post_op_attr dir_attributes;
+    nfs_fh3 object;
+    post_op_attr obj_attributes;
+    post_op_attr dir_attributes;
 };
 typedef struct lookup3resok lookup3resok;
 
 struct lookup3resfail {
-	post_op_attr dir_attributes;
+    post_op_attr dir_attributes;
 };
 typedef struct lookup3resfail lookup3resfail;
 
 struct lookup3res {
-	nfsstat3 status;
-	union {
-		lookup3resok resok;
-		lookup3resfail resfail;
-	} lookup3res_u;
+    nfsstat3 status;
+    union {
+        lookup3resok resok;
+        lookup3resfail resfail;
+    } lookup3res_u;
 };
 typedef struct lookup3res lookup3res;
 #define ACCESS3_READ 0x0001
@@ -340,104 +342,104 @@ typedef struct lookup3res lookup3res;
 #define ACCESS3_EXECUTE 0x0020
 
 struct access3args {
-	nfs_fh3 object;
-	uint32 access;
+    nfs_fh3 object;
+    uint32 access;
 };
 typedef struct access3args access3args;
 
 struct access3resok {
-	post_op_attr obj_attributes;
-	uint32 access;
+    post_op_attr obj_attributes;
+    uint32 access;
 };
 typedef struct access3resok access3resok;
 
 struct access3resfail {
-	post_op_attr obj_attributes;
+    post_op_attr obj_attributes;
 };
 typedef struct access3resfail access3resfail;
 
 struct access3res {
-	nfsstat3 status;
-	union {
-		access3resok resok;
-		access3resfail resfail;
-	} access3res_u;
+    nfsstat3 status;
+    union {
+        access3resok resok;
+        access3resfail resfail;
+    } access3res_u;
 };
 typedef struct access3res access3res;
 
 struct readlink3args {
-	nfs_fh3 symlink;
+    nfs_fh3 symlink;
 };
 typedef struct readlink3args readlink3args;
 
 struct readlink3resok {
-	post_op_attr symlink_attributes;
-	nfspath3 data;
+    post_op_attr symlink_attributes;
+    nfspath3 data;
 };
 typedef struct readlink3resok readlink3resok;
 
 struct readlink3resfail {
-	post_op_attr symlink_attributes;
+    post_op_attr symlink_attributes;
 };
 typedef struct readlink3resfail readlink3resfail;
 
 struct readlink3res {
-	nfsstat3 status;
-	union {
-		readlink3resok resok;
-		readlink3resfail resfail;
-	} readlink3res_u;
+    nfsstat3 status;
+    union {
+        readlink3resok resok;
+        readlink3resfail resfail;
+    } readlink3res_u;
 };
 typedef struct readlink3res readlink3res;
 
 struct read3args {
-	nfs_fh3 file;
-	offset3 offset;
-	count3 count;
+    nfs_fh3 file;
+    offset3 offset;
+    count3 count;
 };
 typedef struct read3args read3args;
 
 struct read3resok {
-	post_op_attr file_attributes;
-	count3 count;
-	bool_t eof;
-	struct {
-		u_int data_len;
-		char *data_val;
-	} data;
+    post_op_attr file_attributes;
+    count3 count;
+    bool_t eof;
+    struct {
+        u_int data_len;
+        char *data_val;
+    } data;
 };
 typedef struct read3resok read3resok;
 
 struct read3resfail {
-	post_op_attr file_attributes;
+    post_op_attr file_attributes;
 };
 typedef struct read3resfail read3resfail;
 
 struct read3res {
-	nfsstat3 status;
-	union {
-		read3resok resok;
-		read3resfail resfail;
-	} read3res_u;
+    nfsstat3 status;
+    union {
+        read3resok resok;
+        read3resfail resfail;
+    } read3res_u;
 };
 typedef struct read3res read3res;
 
 enum stable_how {
-	UNSTABLE = 0,
-	DATA_SYNC = 1,
-	FILE_SYNC = 2,
+    UNSTABLE = 0,
+    DATA_SYNC = 1,
+    FILE_SYNC = 2,
 };
 typedef enum stable_how stable_how;
 
 struct write3args {
-	nfs_fh3 file;
-	offset3 offset;
-	count3 count;
-	stable_how stable;
-	struct {
-		u_int data_len;
-		char *data_val;
-	} data;
+    nfs_fh3 file;
+    offset3 offset;
+    count3 count;
+    stable_how stable;
+    struct {
+        u_int data_len;
+        char *data_val;
+    } data;
 };
 typedef struct write3args write3args;
 
@@ -446,393 +448,395 @@ typedef struct write3args write3args;
  * sizeof (nfs_fh3) rather than first trying to extract the fh size of the
  * network followed by a sized-read of the file handle.
  */
-#define NFS3_WRITE3ARGS_SIZE    (sizeof (uint32_t) + NFS3_FHSIZE + sizeof (offset3) + sizeof (count3) + sizeof (uint32_t))
+#define NFS3_WRITE3ARGS_SIZE                                                   \
+    (sizeof(uint32_t) + NFS3_FHSIZE + sizeof(offset3) + sizeof(count3) +       \
+     sizeof(uint32_t))
 struct write3resok {
-	wcc_data file_wcc;
-	count3 count;
-	stable_how committed;
-	writeverf3 verf;
+    wcc_data file_wcc;
+    count3 count;
+    stable_how committed;
+    writeverf3 verf;
 };
 typedef struct write3resok write3resok;
 
 struct write3resfail {
-	wcc_data file_wcc;
+    wcc_data file_wcc;
 };
 typedef struct write3resfail write3resfail;
 
 struct write3res {
-	nfsstat3 status;
-	union {
-		write3resok resok;
-		write3resfail resfail;
-	} write3res_u;
+    nfsstat3 status;
+    union {
+        write3resok resok;
+        write3resfail resfail;
+    } write3res_u;
 };
 typedef struct write3res write3res;
 
 enum createmode3 {
-	UNCHECKED = 0,
-	GUARDED = 1,
-	EXCLUSIVE = 2,
+    UNCHECKED = 0,
+    GUARDED = 1,
+    EXCLUSIVE = 2,
 };
 typedef enum createmode3 createmode3;
 
 struct createhow3 {
-	createmode3 mode;
-	union {
-		sattr3 obj_attributes;
-		createverf3 verf;
-	} createhow3_u;
+    createmode3 mode;
+    union {
+        sattr3 obj_attributes;
+        createverf3 verf;
+    } createhow3_u;
 };
 typedef struct createhow3 createhow3;
 
 struct create3args {
-	diropargs3 where;
-	createhow3 how;
+    diropargs3 where;
+    createhow3 how;
 };
 typedef struct create3args create3args;
 
 struct create3resok {
-	post_op_fh3 obj;
-	post_op_attr obj_attributes;
-	wcc_data dir_wcc;
+    post_op_fh3 obj;
+    post_op_attr obj_attributes;
+    wcc_data dir_wcc;
 };
 typedef struct create3resok create3resok;
 
 struct create3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct create3resfail create3resfail;
 
 struct create3res {
-	nfsstat3 status;
-	union {
-		create3resok resok;
-		create3resfail resfail;
-	} create3res_u;
+    nfsstat3 status;
+    union {
+        create3resok resok;
+        create3resfail resfail;
+    } create3res_u;
 };
 typedef struct create3res create3res;
 
 struct mkdir3args {
-	diropargs3 where;
-	sattr3 attributes;
+    diropargs3 where;
+    sattr3 attributes;
 };
 typedef struct mkdir3args mkdir3args;
 
 struct mkdir3resok {
-	post_op_fh3 obj;
-	post_op_attr obj_attributes;
-	wcc_data dir_wcc;
+    post_op_fh3 obj;
+    post_op_attr obj_attributes;
+    wcc_data dir_wcc;
 };
 typedef struct mkdir3resok mkdir3resok;
 
 struct mkdir3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct mkdir3resfail mkdir3resfail;
 
 struct mkdir3res {
-	nfsstat3 status;
-	union {
-		mkdir3resok resok;
-		mkdir3resfail resfail;
-	} mkdir3res_u;
+    nfsstat3 status;
+    union {
+        mkdir3resok resok;
+        mkdir3resfail resfail;
+    } mkdir3res_u;
 };
 typedef struct mkdir3res mkdir3res;
 
 struct symlinkdata3 {
-	sattr3 symlink_attributes;
-	nfspath3 symlink_data;
+    sattr3 symlink_attributes;
+    nfspath3 symlink_data;
 };
 typedef struct symlinkdata3 symlinkdata3;
 
 struct symlink3args {
-	diropargs3 where;
-	symlinkdata3 symlink;
+    diropargs3 where;
+    symlinkdata3 symlink;
 };
 typedef struct symlink3args symlink3args;
 
 struct symlink3resok {
-	post_op_fh3 obj;
-	post_op_attr obj_attributes;
-	wcc_data dir_wcc;
+    post_op_fh3 obj;
+    post_op_attr obj_attributes;
+    wcc_data dir_wcc;
 };
 typedef struct symlink3resok symlink3resok;
 
 struct symlink3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct symlink3resfail symlink3resfail;
 
 struct symlink3res {
-	nfsstat3 status;
-	union {
-		symlink3resok resok;
-		symlink3resfail resfail;
-	} symlink3res_u;
+    nfsstat3 status;
+    union {
+        symlink3resok resok;
+        symlink3resfail resfail;
+    } symlink3res_u;
 };
 typedef struct symlink3res symlink3res;
 
 struct devicedata3 {
-	sattr3 dev_attributes;
-	specdata3 spec;
+    sattr3 dev_attributes;
+    specdata3 spec;
 };
 typedef struct devicedata3 devicedata3;
 
 struct mknoddata3 {
-	ftype3 type;
-	union {
-		devicedata3 device;
-		sattr3 pipe_attributes;
-	} mknoddata3_u;
+    ftype3 type;
+    union {
+        devicedata3 device;
+        sattr3 pipe_attributes;
+    } mknoddata3_u;
 };
 typedef struct mknoddata3 mknoddata3;
 
 struct mknod3args {
-	diropargs3 where;
-	mknoddata3 what;
+    diropargs3 where;
+    mknoddata3 what;
 };
 typedef struct mknod3args mknod3args;
 
 struct mknod3resok {
-	post_op_fh3 obj;
-	post_op_attr obj_attributes;
-	wcc_data dir_wcc;
+    post_op_fh3 obj;
+    post_op_attr obj_attributes;
+    wcc_data dir_wcc;
 };
 typedef struct mknod3resok mknod3resok;
 
 struct mknod3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct mknod3resfail mknod3resfail;
 
 struct mknod3res {
-	nfsstat3 status;
-	union {
-		mknod3resok resok;
-		mknod3resfail resfail;
-	} mknod3res_u;
+    nfsstat3 status;
+    union {
+        mknod3resok resok;
+        mknod3resfail resfail;
+    } mknod3res_u;
 };
 typedef struct mknod3res mknod3res;
 
 struct remove3args {
-	diropargs3 object;
+    diropargs3 object;
 };
 typedef struct remove3args remove3args;
 
 struct remove3resok {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct remove3resok remove3resok;
 
 struct remove3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct remove3resfail remove3resfail;
 
 struct remove3res {
-	nfsstat3 status;
-	union {
-		remove3resok resok;
-		remove3resfail resfail;
-	} remove3res_u;
+    nfsstat3 status;
+    union {
+        remove3resok resok;
+        remove3resfail resfail;
+    } remove3res_u;
 };
 typedef struct remove3res remove3res;
 
 struct rmdir3args {
-	diropargs3 object;
+    diropargs3 object;
 };
 typedef struct rmdir3args rmdir3args;
 
 struct rmdir3resok {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct rmdir3resok rmdir3resok;
 
 struct rmdir3resfail {
-	wcc_data dir_wcc;
+    wcc_data dir_wcc;
 };
 typedef struct rmdir3resfail rmdir3resfail;
 
 struct rmdir3res {
-	nfsstat3 status;
-	union {
-		rmdir3resok resok;
-		rmdir3resfail resfail;
-	} rmdir3res_u;
+    nfsstat3 status;
+    union {
+        rmdir3resok resok;
+        rmdir3resfail resfail;
+    } rmdir3res_u;
 };
 typedef struct rmdir3res rmdir3res;
 
 struct rename3args {
-	diropargs3 from;
-	diropargs3 to;
+    diropargs3 from;
+    diropargs3 to;
 };
 typedef struct rename3args rename3args;
 
 struct rename3resok {
-	wcc_data fromdir_wcc;
-	wcc_data todir_wcc;
+    wcc_data fromdir_wcc;
+    wcc_data todir_wcc;
 };
 typedef struct rename3resok rename3resok;
 
 struct rename3resfail {
-	wcc_data fromdir_wcc;
-	wcc_data todir_wcc;
+    wcc_data fromdir_wcc;
+    wcc_data todir_wcc;
 };
 typedef struct rename3resfail rename3resfail;
 
 struct rename3res {
-	nfsstat3 status;
-	union {
-		rename3resok resok;
-		rename3resfail resfail;
-	} rename3res_u;
+    nfsstat3 status;
+    union {
+        rename3resok resok;
+        rename3resfail resfail;
+    } rename3res_u;
 };
 typedef struct rename3res rename3res;
 
 struct link3args {
-	nfs_fh3 file;
-	diropargs3 link;
+    nfs_fh3 file;
+    diropargs3 link;
 };
 typedef struct link3args link3args;
 
 struct link3resok {
-	post_op_attr file_attributes;
-	wcc_data linkdir_wcc;
+    post_op_attr file_attributes;
+    wcc_data linkdir_wcc;
 };
 typedef struct link3resok link3resok;
 
 struct link3resfail {
-	post_op_attr file_attributes;
-	wcc_data linkdir_wcc;
+    post_op_attr file_attributes;
+    wcc_data linkdir_wcc;
 };
 typedef struct link3resfail link3resfail;
 
 struct link3res {
-	nfsstat3 status;
-	union {
-		link3resok resok;
-		link3resfail resfail;
-	} link3res_u;
+    nfsstat3 status;
+    union {
+        link3resok resok;
+        link3resfail resfail;
+    } link3res_u;
 };
 typedef struct link3res link3res;
 
 struct readdir3args {
-	nfs_fh3 dir;
-	cookie3 cookie;
-	cookieverf3 cookieverf;
-	count3 count;
+    nfs_fh3 dir;
+    cookie3 cookie;
+    cookieverf3 cookieverf;
+    count3 count;
 };
 typedef struct readdir3args readdir3args;
 
 struct entry3 {
-	fileid3 fileid;
-	filename3 name;
-	cookie3 cookie;
-	struct entry3 *nextentry;
+    fileid3 fileid;
+    filename3 name;
+    cookie3 cookie;
+    struct entry3 *nextentry;
 };
 typedef struct entry3 entry3;
 
 struct dirlist3 {
-	entry3 *entries;
-	bool_t eof;
+    entry3 *entries;
+    bool_t eof;
 };
 typedef struct dirlist3 dirlist3;
 
 struct readdir3resok {
-	post_op_attr dir_attributes;
-	cookieverf3 cookieverf;
-	dirlist3 reply;
+    post_op_attr dir_attributes;
+    cookieverf3 cookieverf;
+    dirlist3 reply;
 };
 typedef struct readdir3resok readdir3resok;
 
 struct readdir3resfail {
-	post_op_attr dir_attributes;
+    post_op_attr dir_attributes;
 };
 typedef struct readdir3resfail readdir3resfail;
 
 struct readdir3res {
-	nfsstat3 status;
-	union {
-		readdir3resok resok;
-		readdir3resfail resfail;
-	} readdir3res_u;
+    nfsstat3 status;
+    union {
+        readdir3resok resok;
+        readdir3resfail resfail;
+    } readdir3res_u;
 };
 typedef struct readdir3res readdir3res;
 
 struct readdirp3args {
-	nfs_fh3 dir;
-	cookie3 cookie;
-	cookieverf3 cookieverf;
-	count3 dircount;
-	count3 maxcount;
+    nfs_fh3 dir;
+    cookie3 cookie;
+    cookieverf3 cookieverf;
+    count3 dircount;
+    count3 maxcount;
 };
 typedef struct readdirp3args readdirp3args;
 
 struct entryp3 {
-	fileid3 fileid;
-	filename3 name;
-	cookie3 cookie;
-	post_op_attr name_attributes;
-	post_op_fh3 name_handle;
-	struct entryp3 *nextentry;
+    fileid3 fileid;
+    filename3 name;
+    cookie3 cookie;
+    post_op_attr name_attributes;
+    post_op_fh3 name_handle;
+    struct entryp3 *nextentry;
 };
 typedef struct entryp3 entryp3;
 
 struct dirlistp3 {
-	entryp3 *entries;
-	bool_t eof;
+    entryp3 *entries;
+    bool_t eof;
 };
 typedef struct dirlistp3 dirlistp3;
 
 struct readdirp3resok {
-	post_op_attr dir_attributes;
-	cookieverf3 cookieverf;
-	dirlistp3   reply;
+    post_op_attr dir_attributes;
+    cookieverf3 cookieverf;
+    dirlistp3 reply;
 };
 typedef struct readdirp3resok readdirp3resok;
 
 struct readdirp3resfail {
-	post_op_attr dir_attributes;
+    post_op_attr dir_attributes;
 };
 typedef struct readdirp3resfail readdirp3resfail;
 
 struct readdirp3res {
-	nfsstat3 status;
-	union {
-		readdirp3resok resok;
-		readdirp3resfail resfail;
-	} readdirp3res_u;
+    nfsstat3 status;
+    union {
+        readdirp3resok resok;
+        readdirp3resfail resfail;
+    } readdirp3res_u;
 };
 typedef struct readdirp3res readdirp3res;
 
 struct fsstat3args {
-	nfs_fh3 fsroot;
+    nfs_fh3 fsroot;
 };
 typedef struct fsstat3args fsstat3args;
 
 struct fsstat3resok {
-	post_op_attr obj_attributes;
-	size3 tbytes;
-	size3 fbytes;
-	size3 abytes;
-	size3 tfiles;
-	size3 ffiles;
-	size3 afiles;
-	uint32 invarsec;
+    post_op_attr obj_attributes;
+    size3 tbytes;
+    size3 fbytes;
+    size3 abytes;
+    size3 tfiles;
+    size3 ffiles;
+    size3 afiles;
+    uint32 invarsec;
 };
 typedef struct fsstat3resok fsstat3resok;
 
 struct fsstat3resfail {
-	post_op_attr obj_attributes;
+    post_op_attr obj_attributes;
 };
 typedef struct fsstat3resfail fsstat3resfail;
 
 struct fsstat3res {
-	nfsstat3 status;
-	union {
-		fsstat3resok resok;
-		fsstat3resfail resfail;
-	} fsstat3res_u;
+    nfsstat3 status;
+    union {
+        fsstat3resok resok;
+        fsstat3resfail resfail;
+    } fsstat3res_u;
 };
 typedef struct fsstat3res fsstat3res;
 #define FSF3_LINK 0x0001
@@ -841,93 +845,93 @@ typedef struct fsstat3res fsstat3res;
 #define FSF3_CANSETTIME 0x0010
 
 struct fsinfo3args {
-	nfs_fh3 fsroot;
+    nfs_fh3 fsroot;
 };
 typedef struct fsinfo3args fsinfo3args;
 
 struct fsinfo3resok {
-	post_op_attr obj_attributes;
-	uint32 rtmax;
-	uint32 rtpref;
-	uint32 rtmult;
-	uint32 wtmax;
-	uint32 wtpref;
-	uint32 wtmult;
-	uint32 dtpref;
-	size3 maxfilesize;
-	nfstime3 time_delta;
-	uint32 properties;
+    post_op_attr obj_attributes;
+    uint32 rtmax;
+    uint32 rtpref;
+    uint32 rtmult;
+    uint32 wtmax;
+    uint32 wtpref;
+    uint32 wtmult;
+    uint32 dtpref;
+    size3 maxfilesize;
+    nfstime3 time_delta;
+    uint32 properties;
 };
 typedef struct fsinfo3resok fsinfo3resok;
 
 struct fsinfo3resfail {
-	post_op_attr obj_attributes;
+    post_op_attr obj_attributes;
 };
 typedef struct fsinfo3resfail fsinfo3resfail;
 
 struct fsinfo3res {
-	nfsstat3 status;
-	union {
-		fsinfo3resok resok;
-		fsinfo3resfail resfail;
-	} fsinfo3res_u;
+    nfsstat3 status;
+    union {
+        fsinfo3resok resok;
+        fsinfo3resfail resfail;
+    } fsinfo3res_u;
 };
 typedef struct fsinfo3res fsinfo3res;
 
 struct pathconf3args {
-	nfs_fh3 object;
+    nfs_fh3 object;
 };
 typedef struct pathconf3args pathconf3args;
 
 struct pathconf3resok {
-	post_op_attr obj_attributes;
-	uint32 linkmax;
-	uint32 name_max;
-	bool_t no_trunc;
-	bool_t chown_restricted;
-	bool_t case_insensitive;
-	bool_t case_preserving;
+    post_op_attr obj_attributes;
+    uint32 linkmax;
+    uint32 name_max;
+    bool_t no_trunc;
+    bool_t chown_restricted;
+    bool_t case_insensitive;
+    bool_t case_preserving;
 };
 typedef struct pathconf3resok pathconf3resok;
 
 struct pathconf3resfail {
-	post_op_attr obj_attributes;
+    post_op_attr obj_attributes;
 };
 typedef struct pathconf3resfail pathconf3resfail;
 
 struct pathconf3res {
-	nfsstat3 status;
-	union {
-		pathconf3resok resok;
-		pathconf3resfail resfail;
-	} pathconf3res_u;
+    nfsstat3 status;
+    union {
+        pathconf3resok resok;
+        pathconf3resfail resfail;
+    } pathconf3res_u;
 };
 typedef struct pathconf3res pathconf3res;
 
 struct commit3args {
-	nfs_fh3 file;
-	offset3 offset;
-	count3 count;
+    nfs_fh3 file;
+    offset3 offset;
+    count3 count;
 };
 typedef struct commit3args commit3args;
 
 struct commit3resok {
-	wcc_data file_wcc;
-	writeverf3 verf;
+    wcc_data file_wcc;
+    writeverf3 verf;
 };
 typedef struct commit3resok commit3resok;
 
 struct commit3resfail {
-	wcc_data file_wcc;
+    wcc_data file_wcc;
 };
 typedef struct commit3resfail commit3resfail;
 
 struct commit3res {
-	nfsstat3 status;
-	union {
-		commit3resok resok;
-		commit3resfail resfail;
-	} commit3res_u;
+    nfsstat3 status;
+    union {
+        commit3resok resok;
+        commit3resfail resfail;
+    } commit3res_u;
 };
 typedef struct commit3res commit3res;
 #define MNTPATHLEN 1024
@@ -935,8 +939,8 @@ typedef struct commit3res commit3res;
 #define FHSIZE3 NFS3_FHSIZE
 
 typedef struct {
-	u_int fhandle3_len;
-	char *fhandle3_val;
+    u_int fhandle3_len;
+    char *fhandle3_val;
 } fhandle3;
 
 typedef char *dirpath;
@@ -944,257 +948,404 @@ typedef char *dirpath;
 typedef char *name;
 
 enum mountstat3 {
-	MNT3_OK = 0,
-	MNT3ERR_PERM = 1,
-	MNT3ERR_NOENT = 2,
-	MNT3ERR_IO = 5,
-	MNT3ERR_ACCES = 13,
-	MNT3ERR_NOTDIR = 20,
-	MNT3ERR_INVAL = 22,
-	MNT3ERR_NAMETOOLONG = 63,
-	MNT3ERR_NOTSUPP = 10004,
-	MNT3ERR_SERVERFAULT = 10006,
+    MNT3_OK = 0,
+    MNT3ERR_PERM = 1,
+    MNT3ERR_NOENT = 2,
+    MNT3ERR_IO = 5,
+    MNT3ERR_ACCES = 13,
+    MNT3ERR_NOTDIR = 20,
+    MNT3ERR_INVAL = 22,
+    MNT3ERR_NAMETOOLONG = 63,
+    MNT3ERR_NOTSUPP = 10004,
+    MNT3ERR_SERVERFAULT = 10006,
 };
 typedef enum mountstat3 mountstat3;
 
 struct mountres3_ok {
-	fhandle3 fhandle;
-	struct {
-		u_int auth_flavors_len;
-		int *auth_flavors_val;
-	} auth_flavors;
+    fhandle3 fhandle;
+    struct {
+        u_int auth_flavors_len;
+        int *auth_flavors_val;
+    } auth_flavors;
 };
 typedef struct mountres3_ok mountres3_ok;
 
 struct mountres3 {
-	mountstat3 fhs_status;
-	union {
-		mountres3_ok mountinfo;
-	} mountres3_u;
+    mountstat3 fhs_status;
+    union {
+        mountres3_ok mountinfo;
+    } mountres3_u;
 };
 typedef struct mountres3 mountres3;
 
 typedef struct mountbody *mountlist;
 
 struct mountbody {
-	name ml_hostname;
-	dirpath ml_directory;
-	mountlist ml_next;
+    name ml_hostname;
+    dirpath ml_directory;
+    mountlist ml_next;
 };
 typedef struct mountbody mountbody;
 
 typedef struct groupnode *groups;
 
 struct groupnode {
-	name gr_name;
-	groups gr_next;
+    name gr_name;
+    groups gr_next;
 };
 typedef struct groupnode groupnode;
 
 typedef struct exportnode *exports;
 
 struct exportnode {
-	dirpath ex_dir;
-	groups ex_groups;
-	exports ex_next;
+    dirpath ex_dir;
+    groups ex_groups;
+    exports ex_next;
 };
 typedef struct exportnode exportnode;
 
-#define NFS_PROGRAM             100003
-#define NFS_V3                  3
-
-#define NFS3_NULL               0
-#define NFS3_GETATTR            1
-#define NFS3_SETATTR            2
-#define NFS3_LOOKUP             3
-#define NFS3_ACCESS             4
-#define NFS3_READLINK           5
-#define NFS3_READ               6
-#define NFS3_WRITE              7
-#define NFS3_CREATE             8
-#define NFS3_MKDIR              9
-#define NFS3_SYMLINK            10
-#define NFS3_MKNOD              11
-#define NFS3_REMOVE             12
-#define NFS3_RMDIR              13
-#define NFS3_RENAME             14
-#define NFS3_LINK               15
-#define NFS3_READDIR            16
-#define NFS3_READDIRP           17
-#define NFS3_FSSTAT             18
-#define NFS3_FSINFO             19
-#define NFS3_PATHCONF           20
-#define NFS3_COMMIT             21
-#define NFS3_PROC_COUNT         22
-
-#define MOUNT_PROGRAM           100005
-#define MOUNT_V3                3
-#define MOUNT_V1                1
-
-#define MOUNT3_NULL             0
-#define MOUNT3_MNT              1
-#define MOUNT3_DUMP             2
-#define MOUNT3_UMNT             3
-#define MOUNT3_UMNTALL          4
-#define MOUNT3_EXPORT           5
-#define MOUNT3_PROC_COUNT       6
-
-#define MOUNT1_NULL             0
-#define MOUNT1_MNT              1
-#define MOUNT1_DUMP             2
-#define MOUNT1_UMNT             3
-#define MOUNT1_UMNTALL          4
-#define MOUNT1_EXPORT           5
-#define MOUNT1_PROC_COUNT       6
+#define NFS_PROGRAM 100003
+#define NFS_V3 3
+
+#define NFS3_NULL 0
+#define NFS3_GETATTR 1
+#define NFS3_SETATTR 2
+#define NFS3_LOOKUP 3
+#define NFS3_ACCESS 4
+#define NFS3_READLINK 5
+#define NFS3_READ 6
+#define NFS3_WRITE 7
+#define NFS3_CREATE 8
+#define NFS3_MKDIR 9
+#define NFS3_SYMLINK 10
+#define NFS3_MKNOD 11
+#define NFS3_REMOVE 12
+#define NFS3_RMDIR 13
+#define NFS3_RENAME 14
+#define NFS3_LINK 15
+#define NFS3_READDIR 16
+#define NFS3_READDIRP 17
+#define NFS3_FSSTAT 18
+#define NFS3_FSINFO 19
+#define NFS3_PATHCONF 20
+#define NFS3_COMMIT 21
+#define NFS3_PROC_COUNT 22
+
+#define MOUNT_PROGRAM 100005
+#define MOUNT_V3 3
+#define MOUNT_V1 1
+
+#define MOUNT3_NULL 0
+#define MOUNT3_MNT 1
+#define MOUNT3_DUMP 2
+#define MOUNT3_UMNT 3
+#define MOUNT3_UMNTALL 4
+#define MOUNT3_EXPORT 5
+#define MOUNT3_PROC_COUNT 6
+
+#define MOUNT1_NULL 0
+#define MOUNT1_MNT 1
+#define MOUNT1_DUMP 2
+#define MOUNT1_UMNT 3
+#define MOUNT1_UMNTALL 4
+#define MOUNT1_EXPORT 5
+#define MOUNT1_PROC_COUNT 6
 /* the xdr functions */
 
-extern  bool_t xdr_uint64 (XDR *, uint64*);
-extern  bool_t xdr_int64 (XDR *, int64*);
-extern  bool_t xdr_uint32 (XDR *, uint32*);
-extern  bool_t xdr_int32 (XDR *, int32*);
-extern  bool_t xdr_filename3 (XDR *, filename3*);
-extern  bool_t xdr_nfspath3 (XDR *, nfspath3*);
-extern  bool_t xdr_fileid3 (XDR *, fileid3*);
-extern  bool_t xdr_cookie3 (XDR *, cookie3*);
-extern  bool_t xdr_cookieverf3 (XDR *, cookieverf3);
-extern  bool_t xdr_createverf3 (XDR *, createverf3);
-extern  bool_t xdr_writeverf3 (XDR *, writeverf3);
-extern  bool_t xdr_uid3 (XDR *, uid3*);
-extern  bool_t xdr_gid3 (XDR *, gid3*);
-extern  bool_t xdr_size3 (XDR *, size3*);
-extern  bool_t xdr_offset3 (XDR *, offset3*);
-extern  bool_t xdr_mode3 (XDR *, mode3*);
-extern  bool_t xdr_count3 (XDR *, count3*);
-extern  bool_t xdr_nfsstat3 (XDR *, nfsstat3*);
-extern  bool_t xdr_ftype3 (XDR *, ftype3*);
-extern  bool_t xdr_specdata3 (XDR *, specdata3*);
-extern  bool_t xdr_nfs_fh3 (XDR *, nfs_fh3*);
-extern  bool_t xdr_nfstime3 (XDR *, nfstime3*);
-extern  bool_t xdr_fattr3 (XDR *, fattr3*);
-extern  bool_t xdr_post_op_attr (XDR *, post_op_attr*);
-extern  bool_t xdr_wcc_attr (XDR *, wcc_attr*);
-extern  bool_t xdr_pre_op_attr (XDR *, pre_op_attr*);
-extern  bool_t xdr_wcc_data (XDR *, wcc_data*);
-extern  bool_t xdr_post_op_fh3 (XDR *, post_op_fh3*);
-extern  bool_t xdr_time_how (XDR *, time_how*);
-extern  bool_t xdr_set_mode3 (XDR *, set_mode3*);
-extern  bool_t xdr_set_uid3 (XDR *, set_uid3*);
-extern  bool_t xdr_set_gid3 (XDR *, set_gid3*);
-extern  bool_t xdr_set_size3 (XDR *, set_size3*);
-extern  bool_t xdr_set_atime (XDR *, set_atime*);
-extern  bool_t xdr_set_mtime (XDR *, set_mtime*);
-extern  bool_t xdr_sattr3 (XDR *, sattr3*);
-extern  bool_t xdr_diropargs3 (XDR *, diropargs3*);
-extern  bool_t xdr_getattr3args (XDR *, getattr3args*);
-extern  bool_t xdr_getattr3resok (XDR *, getattr3resok*);
-extern  bool_t xdr_getattr3res (XDR *, getattr3res*);
-extern  bool_t xdr_sattrguard3 (XDR *, sattrguard3*);
-extern  bool_t xdr_setattr3args (XDR *, setattr3args*);
-extern  bool_t xdr_setattr3resok (XDR *, setattr3resok*);
-extern  bool_t xdr_setattr3resfail (XDR *, setattr3resfail*);
-extern  bool_t xdr_setattr3res (XDR *, setattr3res*);
-extern  bool_t xdr_lookup3args (XDR *, lookup3args*);
-extern  bool_t xdr_lookup3resok (XDR *, lookup3resok*);
-extern  bool_t xdr_lookup3resfail (XDR *, lookup3resfail*);
-extern  bool_t xdr_lookup3res (XDR *, lookup3res*);
-extern  bool_t xdr_access3args (XDR *, access3args*);
-extern  bool_t xdr_access3resok (XDR *, access3resok*);
-extern  bool_t xdr_access3resfail (XDR *, access3resfail*);
-extern  bool_t xdr_access3res (XDR *, access3res*);
-extern  bool_t xdr_readlink3args (XDR *, readlink3args*);
-extern  bool_t xdr_readlink3resok (XDR *, readlink3resok*);
-extern  bool_t xdr_readlink3resfail (XDR *, readlink3resfail*);
-extern  bool_t xdr_readlink3res (XDR *, readlink3res*);
-extern  bool_t xdr_read3args (XDR *, read3args*);
-extern  bool_t xdr_read3resok (XDR *, read3resok*);
-extern  bool_t xdr_read3resfail (XDR *, read3resfail*);
-extern  bool_t xdr_read3res (XDR *, read3res*);
-extern  bool_t xdr_read3res_nocopy (XDR *xdrs, read3res *objp);
-extern  bool_t xdr_stable_how (XDR *, stable_how*);
-extern  bool_t xdr_write3args (XDR *, write3args*);
-extern  bool_t xdr_write3resok (XDR *, write3resok*);
-extern  bool_t xdr_write3resfail (XDR *, write3resfail*);
-extern  bool_t xdr_write3res (XDR *, write3res*);
-extern  bool_t xdr_createmode3 (XDR *, createmode3*);
-extern  bool_t xdr_createhow3 (XDR *, createhow3*);
-extern  bool_t xdr_create3args (XDR *, create3args*);
-extern  bool_t xdr_create3resok (XDR *, create3resok*);
-extern  bool_t xdr_create3resfail (XDR *, create3resfail*);
-extern  bool_t xdr_create3res (XDR *, create3res*);
-extern  bool_t xdr_mkdir3args (XDR *, mkdir3args*);
-extern  bool_t xdr_mkdir3resok (XDR *, mkdir3resok*);
-extern  bool_t xdr_mkdir3resfail (XDR *, mkdir3resfail*);
-extern  bool_t xdr_mkdir3res (XDR *, mkdir3res*);
-extern  bool_t xdr_symlinkdata3 (XDR *, symlinkdata3*);
-extern  bool_t xdr_symlink3args (XDR *, symlink3args*);
-extern  bool_t xdr_symlink3resok (XDR *, symlink3resok*);
-extern  bool_t xdr_symlink3resfail (XDR *, symlink3resfail*);
-extern  bool_t xdr_symlink3res (XDR *, symlink3res*);
-extern  bool_t xdr_devicedata3 (XDR *, devicedata3*);
-extern  bool_t xdr_mknoddata3 (XDR *, mknoddata3*);
-extern  bool_t xdr_mknod3args (XDR *, mknod3args*);
-extern  bool_t xdr_mknod3resok (XDR *, mknod3resok*);
-extern  bool_t xdr_mknod3resfail (XDR *, mknod3resfail*);
-extern  bool_t xdr_mknod3res (XDR *, mknod3res*);
-extern  bool_t xdr_remove3args (XDR *, remove3args*);
-extern  bool_t xdr_remove3resok (XDR *, remove3resok*);
-extern  bool_t xdr_remove3resfail (XDR *, remove3resfail*);
-extern  bool_t xdr_remove3res (XDR *, remove3res*);
-extern  bool_t xdr_rmdir3args (XDR *, rmdir3args*);
-extern  bool_t xdr_rmdir3resok (XDR *, rmdir3resok*);
-extern  bool_t xdr_rmdir3resfail (XDR *, rmdir3resfail*);
-extern  bool_t xdr_rmdir3res (XDR *, rmdir3res*);
-extern  bool_t xdr_rename3args (XDR *, rename3args*);
-extern  bool_t xdr_rename3resok (XDR *, rename3resok*);
-extern  bool_t xdr_rename3resfail (XDR *, rename3resfail*);
-extern  bool_t xdr_rename3res (XDR *, rename3res*);
-extern  bool_t xdr_link3args (XDR *, link3args*);
-extern  bool_t xdr_link3resok (XDR *, link3resok*);
-extern  bool_t xdr_link3resfail (XDR *, link3resfail*);
-extern  bool_t xdr_link3res (XDR *, link3res*);
-extern  bool_t xdr_readdir3args (XDR *, readdir3args*);
-extern  bool_t xdr_entry3 (XDR *, entry3*);
-extern  bool_t xdr_dirlist3 (XDR *, dirlist3*);
-extern  bool_t xdr_readdir3resok (XDR *, readdir3resok*);
-extern  bool_t xdr_readdir3resfail (XDR *, readdir3resfail*);
-extern  bool_t xdr_readdir3res (XDR *, readdir3res*);
-extern  bool_t xdr_readdirp3args (XDR *, readdirp3args*);
-extern  bool_t xdr_entryp3 (XDR *, entryp3*);
-extern  bool_t xdr_dirlistp3 (XDR *, dirlistp3*);
-extern  bool_t xdr_readdirp3resok (XDR *, readdirp3resok*);
-extern  bool_t xdr_readdirp3resfail (XDR *, readdirp3resfail*);
-extern  bool_t xdr_readdirp3res (XDR *, readdirp3res*);
-extern  bool_t xdr_fsstat3args (XDR *, fsstat3args*);
-extern  bool_t xdr_fsstat3resok (XDR *, fsstat3resok*);
-extern  bool_t xdr_fsstat3resfail (XDR *, fsstat3resfail*);
-extern  bool_t xdr_fsstat3res (XDR *, fsstat3res*);
-extern  bool_t xdr_fsinfo3args (XDR *, fsinfo3args*);
-extern  bool_t xdr_fsinfo3resok (XDR *, fsinfo3resok*);
-extern  bool_t xdr_fsinfo3resfail (XDR *, fsinfo3resfail*);
-extern  bool_t xdr_fsinfo3res (XDR *, fsinfo3res*);
-extern  bool_t xdr_pathconf3args (XDR *, pathconf3args*);
-extern  bool_t xdr_pathconf3resok (XDR *, pathconf3resok*);
-extern  bool_t xdr_pathconf3resfail (XDR *, pathconf3resfail*);
-extern  bool_t xdr_pathconf3res (XDR *, pathconf3res*);
-extern  bool_t xdr_commit3args (XDR *, commit3args*);
-extern  bool_t xdr_commit3resok (XDR *, commit3resok*);
-extern  bool_t xdr_commit3resfail (XDR *, commit3resfail*);
-extern  bool_t xdr_commit3res (XDR *, commit3res*);
-extern  bool_t xdr_fhandle3 (XDR *, fhandle3*);
-extern  bool_t xdr_dirpath (XDR *, dirpath*);
-extern  bool_t xdr_name (XDR *, name*);
-extern  bool_t xdr_mountstat3 (XDR *, mountstat3*);
-extern  bool_t xdr_mountres3_ok (XDR *, mountres3_ok*);
-extern  bool_t xdr_mountres3 (XDR *, mountres3*);
-extern  bool_t xdr_mountlist (XDR *, mountlist*);
-extern  bool_t xdr_mountbody (XDR *, mountbody*);
-extern  bool_t xdr_groups (XDR *, groups*);
-extern  bool_t xdr_groupnode (XDR *, groupnode*);
-extern  bool_t xdr_exports (XDR *, exports*);
-extern  bool_t xdr_exportnode (XDR *, exportnode*);
-
-extern void xdr_free_exports_list (struct exportnode *first);
-extern void xdr_free_mountlist (mountlist ml);
-
-extern void xdr_free_write3args_nocopy (write3args *wa);
+extern bool_t
+xdr_uint64(XDR *, uint64 *);
+extern bool_t
+xdr_int64(XDR *, int64 *);
+extern bool_t
+xdr_uint32(XDR *, uint32 *);
+extern bool_t
+xdr_int32(XDR *, int32 *);
+extern bool_t
+xdr_filename3(XDR *, filename3 *);
+extern bool_t
+xdr_nfspath3(XDR *, nfspath3 *);
+extern bool_t
+xdr_fileid3(XDR *, fileid3 *);
+extern bool_t
+xdr_cookie3(XDR *, cookie3 *);
+extern bool_t
+xdr_cookieverf3(XDR *, cookieverf3);
+extern bool_t
+xdr_createverf3(XDR *, createverf3);
+extern bool_t
+xdr_writeverf3(XDR *, writeverf3);
+extern bool_t
+xdr_uid3(XDR *, uid3 *);
+extern bool_t
+xdr_gid3(XDR *, gid3 *);
+extern bool_t
+xdr_size3(XDR *, size3 *);
+extern bool_t
+xdr_offset3(XDR *, offset3 *);
+extern bool_t
+xdr_mode3(XDR *, mode3 *);
+extern bool_t
+xdr_count3(XDR *, count3 *);
+extern bool_t
+xdr_nfsstat3(XDR *, nfsstat3 *);
+extern bool_t
+xdr_ftype3(XDR *, ftype3 *);
+extern bool_t
+xdr_specdata3(XDR *, specdata3 *);
+extern bool_t
+xdr_nfs_fh3(XDR *, nfs_fh3 *);
+extern bool_t
+xdr_nfstime3(XDR *, nfstime3 *);
+extern bool_t
+xdr_fattr3(XDR *, fattr3 *);
+extern bool_t
+xdr_post_op_attr(XDR *, post_op_attr *);
+extern bool_t
+xdr_wcc_attr(XDR *, wcc_attr *);
+extern bool_t
+xdr_pre_op_attr(XDR *, pre_op_attr *);
+extern bool_t
+xdr_wcc_data(XDR *, wcc_data *);
+extern bool_t
+xdr_post_op_fh3(XDR *, post_op_fh3 *);
+extern bool_t
+xdr_time_how(XDR *, time_how *);
+extern bool_t
+xdr_set_mode3(XDR *, set_mode3 *);
+extern bool_t
+xdr_set_uid3(XDR *, set_uid3 *);
+extern bool_t
+xdr_set_gid3(XDR *, set_gid3 *);
+extern bool_t
+xdr_set_size3(XDR *, set_size3 *);
+extern bool_t
+xdr_set_atime(XDR *, set_atime *);
+extern bool_t
+xdr_set_mtime(XDR *, set_mtime *);
+extern bool_t
+xdr_sattr3(XDR *, sattr3 *);
+extern bool_t
+xdr_diropargs3(XDR *, diropargs3 *);
+extern bool_t
+xdr_getattr3args(XDR *, getattr3args *);
+extern bool_t
+xdr_getattr3resok(XDR *, getattr3resok *);
+extern bool_t
+xdr_getattr3res(XDR *, getattr3res *);
+extern bool_t
+xdr_sattrguard3(XDR *, sattrguard3 *);
+extern bool_t
+xdr_setattr3args(XDR *, setattr3args *);
+extern bool_t
+xdr_setattr3resok(XDR *, setattr3resok *);
+extern bool_t
+xdr_setattr3resfail(XDR *, setattr3resfail *);
+extern bool_t
+xdr_setattr3res(XDR *, setattr3res *);
+extern bool_t
+xdr_lookup3args(XDR *, lookup3args *);
+extern bool_t
+xdr_lookup3resok(XDR *, lookup3resok *);
+extern bool_t
+xdr_lookup3resfail(XDR *, lookup3resfail *);
+extern bool_t
+xdr_lookup3res(XDR *, lookup3res *);
+extern bool_t
+xdr_access3args(XDR *, access3args *);
+extern bool_t
+xdr_access3resok(XDR *, access3resok *);
+extern bool_t
+xdr_access3resfail(XDR *, access3resfail *);
+extern bool_t
+xdr_access3res(XDR *, access3res *);
+extern bool_t
+xdr_readlink3args(XDR *, readlink3args *);
+extern bool_t
+xdr_readlink3resok(XDR *, readlink3resok *);
+extern bool_t
+xdr_readlink3resfail(XDR *, readlink3resfail *);
+extern bool_t
+xdr_readlink3res(XDR *, readlink3res *);
+extern bool_t
+xdr_read3args(XDR *, read3args *);
+extern bool_t
+xdr_read3resok(XDR *, read3resok *);
+extern bool_t
+xdr_read3resfail(XDR *, read3resfail *);
+extern bool_t
+xdr_read3res(XDR *, read3res *);
+extern bool_t
+xdr_read3res_nocopy(XDR *xdrs, read3res *objp);
+extern bool_t
+xdr_stable_how(XDR *, stable_how *);
+extern bool_t
+xdr_write3args(XDR *, write3args *);
+extern bool_t
+xdr_write3resok(XDR *, write3resok *);
+extern bool_t
+xdr_write3resfail(XDR *, write3resfail *);
+extern bool_t
+xdr_write3res(XDR *, write3res *);
+extern bool_t
+xdr_createmode3(XDR *, createmode3 *);
+extern bool_t
+xdr_createhow3(XDR *, createhow3 *);
+extern bool_t
+xdr_create3args(XDR *, create3args *);
+extern bool_t
+xdr_create3resok(XDR *, create3resok *);
+extern bool_t
+xdr_create3resfail(XDR *, create3resfail *);
+extern bool_t
+xdr_create3res(XDR *, create3res *);
+extern bool_t
+xdr_mkdir3args(XDR *, mkdir3args *);
+extern bool_t
+xdr_mkdir3resok(XDR *, mkdir3resok *);
+extern bool_t
+xdr_mkdir3resfail(XDR *, mkdir3resfail *);
+extern bool_t
+xdr_mkdir3res(XDR *, mkdir3res *);
+extern bool_t
+xdr_symlinkdata3(XDR *, symlinkdata3 *);
+extern bool_t
+xdr_symlink3args(XDR *, symlink3args *);
+extern bool_t
+xdr_symlink3resok(XDR *, symlink3resok *);
+extern bool_t
+xdr_symlink3resfail(XDR *, symlink3resfail *);
+extern bool_t
+xdr_symlink3res(XDR *, symlink3res *);
+extern bool_t
+xdr_devicedata3(XDR *, devicedata3 *);
+extern bool_t
+xdr_mknoddata3(XDR *, mknoddata3 *);
+extern bool_t
+xdr_mknod3args(XDR *, mknod3args *);
+extern bool_t
+xdr_mknod3resok(XDR *, mknod3resok *);
+extern bool_t
+xdr_mknod3resfail(XDR *, mknod3resfail *);
+extern bool_t
+xdr_mknod3res(XDR *, mknod3res *);
+extern bool_t
+xdr_remove3args(XDR *, remove3args *);
+extern bool_t
+xdr_remove3resok(XDR *, remove3resok *);
+extern bool_t
+xdr_remove3resfail(XDR *, remove3resfail *);
+extern bool_t
+xdr_remove3res(XDR *, remove3res *);
+extern bool_t
+xdr_rmdir3args(XDR *, rmdir3args *);
+extern bool_t
+xdr_rmdir3resok(XDR *, rmdir3resok *);
+extern bool_t
+xdr_rmdir3resfail(XDR *, rmdir3resfail *);
+extern bool_t
+xdr_rmdir3res(XDR *, rmdir3res *);
+extern bool_t
+xdr_rename3args(XDR *, rename3args *);
+extern bool_t
+xdr_rename3resok(XDR *, rename3resok *);
+extern bool_t
+xdr_rename3resfail(XDR *, rename3resfail *);
+extern bool_t
+xdr_rename3res(XDR *, rename3res *);
+extern bool_t
+xdr_link3args(XDR *, link3args *);
+extern bool_t
+xdr_link3resok(XDR *, link3resok *);
+extern bool_t
+xdr_link3resfail(XDR *, link3resfail *);
+extern bool_t
+xdr_link3res(XDR *, link3res *);
+extern bool_t
+xdr_readdir3args(XDR *, readdir3args *);
+extern bool_t
+xdr_entry3(XDR *, entry3 *);
+extern bool_t
+xdr_dirlist3(XDR *, dirlist3 *);
+extern bool_t
+xdr_readdir3resok(XDR *, readdir3resok *);
+extern bool_t
+xdr_readdir3resfail(XDR *, readdir3resfail *);
+extern bool_t
+xdr_readdir3res(XDR *, readdir3res *);
+extern bool_t
+xdr_readdirp3args(XDR *, readdirp3args *);
+extern bool_t
+xdr_entryp3(XDR *, entryp3 *);
+extern bool_t
+xdr_dirlistp3(XDR *, dirlistp3 *);
+extern bool_t
+xdr_readdirp3resok(XDR *, readdirp3resok *);
+extern bool_t
+xdr_readdirp3resfail(XDR *, readdirp3resfail *);
+extern bool_t
+xdr_readdirp3res(XDR *, readdirp3res *);
+extern bool_t
+xdr_fsstat3args(XDR *, fsstat3args *);
+extern bool_t
+xdr_fsstat3resok(XDR *, fsstat3resok *);
+extern bool_t
+xdr_fsstat3resfail(XDR *, fsstat3resfail *);
+extern bool_t
+xdr_fsstat3res(XDR *, fsstat3res *);
+extern bool_t
+xdr_fsinfo3args(XDR *, fsinfo3args *);
+extern bool_t
+xdr_fsinfo3resok(XDR *, fsinfo3resok *);
+extern bool_t
+xdr_fsinfo3resfail(XDR *, fsinfo3resfail *);
+extern bool_t
+xdr_fsinfo3res(XDR *, fsinfo3res *);
+extern bool_t
+xdr_pathconf3args(XDR *, pathconf3args *);
+extern bool_t
+xdr_pathconf3resok(XDR *, pathconf3resok *);
+extern bool_t
+xdr_pathconf3resfail(XDR *, pathconf3resfail *);
+extern bool_t
+xdr_pathconf3res(XDR *, pathconf3res *);
+extern bool_t
+xdr_commit3args(XDR *, commit3args *);
+extern bool_t
+xdr_commit3resok(XDR *, commit3resok *);
+extern bool_t
+xdr_commit3resfail(XDR *, commit3resfail *);
+extern bool_t
+xdr_commit3res(XDR *, commit3res *);
+extern bool_t
+xdr_fhandle3(XDR *, fhandle3 *);
+extern bool_t
+xdr_dirpath(XDR *, dirpath *);
+extern bool_t
+xdr_name(XDR *, name *);
+extern bool_t
+xdr_mountstat3(XDR *, mountstat3 *);
+extern bool_t
+xdr_mountres3_ok(XDR *, mountres3_ok *);
+extern bool_t
+xdr_mountres3(XDR *, mountres3 *);
+extern bool_t
+xdr_mountlist(XDR *, mountlist *);
+extern bool_t
+xdr_mountbody(XDR *, mountbody *);
+extern bool_t
+xdr_groups(XDR *, groups *);
+extern bool_t
+xdr_groupnode(XDR *, groupnode *);
+extern bool_t
+xdr_exports(XDR *, exports *);
+extern bool_t
+xdr_exportnode(XDR *, exportnode *);
+
+extern void
+xdr_free_exports_list(struct exportnode *first);
+extern void
+xdr_free_mountlist(mountlist ml);
+
+extern void
+xdr_free_write3args_nocopy(write3args *wa);
 #endif
diff --git a/run-tests-in-vagrant.sh b/run-tests-in-vagrant.sh
index 162b6893eb7..a3f2ac7c72d 100755
--- a/run-tests-in-vagrant.sh
+++ b/run-tests-in-vagrant.sh
@@ -23,10 +23,25 @@ popd () {
     command popd "$@" >/dev/null
 }
 
+usage() {
+    echo "Usage: $0 [...]"
+    echo ''
+    echo 'The options that this script accepts are:'
+    echo ''
+    echo '-a, --autostart        configure the testVM to autostart on boot'
+    echo '--destroy-now          cleanup the testVM'
+    echo '--destroy-after-test   cleanup once the tests finishes'
+    echo '-h, --help             show this help text'
+    echo '--os=<flavor>          select the OS for the testVM (fedora, centos6)'
+    echo '--ssh                  ssh into the testVM'
+    echo '--verbose              show what commands in the testVM are executed'
+    echo ''
+}
+
 function parse_args () {
     args=`getopt \
-              --options a \
-              --long autostart,os:,destroy-now,destroy-after-test,verbose,ssh \
+              --options ah \
+              --long autostart,os:,destroy-now,destroy-after-test,verbose,ssh,help \
               -n 'run-tests-in-vagrant.sh' \
               --  "$@"`
     eval set -- "$args"
@@ -35,6 +50,7 @@ function parse_args () {
             -a|--autostart) autostart="yes"; shift ;;
             --destroy-after-test) destroy_after_test="yes"; shift ;;
             --destroy-now)  destroy_now="yes"; shift ;;
+            -h|--help) usage ; exit 0 ;;
             --ssh)  sshvm="yes"; shift ;;
             --os)
                 case "$2" in
@@ -95,8 +111,10 @@ function set_branchname_from_git_branch()
 }
 
 
-function destroy_vm_and_exit()
+function destroy_vm()
 {
+    local retval=0
+
     echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!CAUTION!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
     echo "This will destroy VM and delete tests/vagrant/${BRANCHNAME} dir"
     echo
@@ -112,11 +130,12 @@ function destroy_vm_and_exit()
         eval vagrant destroy $redirect
         popd
         rm -rf "tests/vagrant/${BRANCHNAME}"
-        exit 0
     else
         echo "Could not find vagrant dir for corresponding git branch, exiting"
-        exit 1
+        retval=1
     fi
+
+    return ${retval}
 }
 
 
@@ -212,6 +231,7 @@ function compile_gluster()
             --mandir=/usr/share/man \
             --infodir=/usr/share/info \
             --libdir=/usr/lib64 \
+            --enable-gnfs \
             --enable-debug $redirect" -- -t
     if [ $? -ne 0 ]
     then
@@ -219,6 +239,10 @@ function compile_gluster()
             popd
             exit 1
     fi
+    # Test for missing dependencies based on the BuildRequires in the
+    # glusterfs.spec. If anything is missing, install them (and only then, dnf
+    # cache is a large download).
+    vagrant ssh -c "cd /home/vagrant/glusterfs; ( sudo dnf -C -y builddep --spec glusterfs.spec || sudo dnf -y builddep --spec glusterfs.spec ) $redirect" -- -t
     vagrant ssh -c "cd /home/vagrant/glusterfs; sudo make -j install $redirect" -- -t
     if [ $? -ne 0 ]
     then
@@ -231,9 +255,14 @@ function compile_gluster()
 
 function run_tests()
 {
+    local retval=0
+
     pushd "tests/vagrant/${BRANCHNAME}"
     vagrant ssh -c "cd /home/vagrant/glusterfs; sudo ./run-tests.sh $run_tests_args" -- -t
+    retval=$?
     popd
+
+    return ${retval}
 }
 
 function ssh_into_vm_using_exec()
@@ -255,7 +284,8 @@ ansible_check
 set_branchname_from_git_branch
 
 if [ "x$destroy_now" == "xyes" ] ; then
-    destroy_vm_and_exit
+    destroy_vm
+    exit $?
 fi
 
 if [ "x$sshvm" == "xyes" ] ; then
@@ -272,7 +302,10 @@ set_vm_attributes
 copy_source_code
 compile_gluster
 run_tests
+RET=$?
 
 if [ "x$destroy_after_test" == "xyes" ] ; then
-    destroy_vm_and_exit
+    destroy_vm
 fi
+
+exit ${RET}
diff --git a/run-tests.sh b/run-tests.sh
index dbf4a5e3b3c..e2a1655d8e0 100755
--- a/run-tests.sh
+++ b/run-tests.sh
@@ -2,6 +2,14 @@
 # Copyright (c) 2013-2014 Red Hat, Inc. <http://www.redhat.com>
 #
 
+# As many tests are designed to take values of variables from 'env.rc',
+# it is good to source the file. While it is also required to source the
+# file individually in each tests (as it should be possible to run the
+# tests separately), exporting variables from env.rc is not harmful if
+# done here
+
+source ./tests/env.rc
+
 export TZ=UTC
 force="no"
 head="yes"
@@ -10,10 +18,90 @@ tests=""
 exit_on_failure="yes"
 skip_bad_tests="yes"
 skip_known_bugs="yes"
+result_output="/tmp/gluster_regression.txt"
 section_separator="========================================"
+run_timeout=200
+kill_after_time=5
+nfs_tests=$RUN_NFS_TESTS
+
+# Option below preserves log tarballs for each run of a test separately
+#       named: <test>-iteration-<n>.tar
+# If set to any other value, then log tarball is just named after the test and
+# overwritten in each iteration (saves space)
+#       named: <test>.tar
+# Use option -p to override default behavior
+skip_preserve_logs="yes"
 
 OSTYPE=$(uname -s)
 
+# Function for use in generating filenames with increasing "-<n>" index
+# In:
+#       $1 basepath: Directory where file needs to be created
+#       $2 filename: Name of the file sans extension
+#       $3 extension: Extension string that would be appended to the generated
+#               filename
+# Out:
+#       string of next available filename with appended "-<n>"
+# Example:
+#       Interested routines that want to create a file name, say foo-<n>.txt at
+#       location /var/log/gluster would pass in "/var/log/gluster" "foo" "txt"
+#       and be returned next available foo-<n> filename to create.
+# Notes:
+#       Function will not accept empty extension, and will return the same name
+#       over and over (which can be fixed when there is a need for it)
+function get_next_filename()
+{
+        local basepath=$1
+        local filename=$2
+        local extension=$3
+        local next=1
+        local tfilename="${filename}-${next}"
+        while [ -e "${basepath}/${tfilename}.${extension}" ]; do
+                next=$((next+1))
+                tfilename="${filename}-${next}"
+        done
+
+        echo "$tfilename"
+}
+
+# Tar the gluster logs and generate a tarball named after the first parameter
+# passed in to the function. Ideally the test name is passed to this function
+# to generate the required tarball.
+# Tarball name is further controlled by the variable skip_preserve_logs
+function tar_logs()
+{
+        t=$1
+
+        logdir=$(gluster --print-logdir)
+        basetarname=$(basename "$t" .t)
+
+        if [ -n "$logdir" ]
+        then
+                if [[ $skip_preserve_logs == "yes" ]]; then
+                        savetarname=$(get_next_filename "${logdir}" \
+                                "${basetarname}-iteration" "tar" \
+                                | tail -1)
+                else
+                        savetarname="$basetarname"
+                fi
+
+                # Can't use --exclude here because NetBSD doesn't have it.
+                # However, both it and Linux have -X to take patterns from
+                # a file, so use that.
+                (echo '*.tar'; echo .notar) > "${logdir}"/.notar \
+                        && \
+                tar -cf "${logdir}"/"${savetarname}".tar -X "${logdir}"/.notar \
+                        "${logdir}"/* 2> /dev/null \
+                        && \
+                find "$logdir"/* -maxdepth 0 -name '*.tar' -prune \
+                                        -o -exec rm -rf '{}' ';'
+
+                echo "Logs preserved in tarball $savetarname.tar"
+        else
+                echo "Logs not preserved, as logdir is not set"
+        fi
+}
+
 function check_dependencies()
 {
     ## Check all dependencies are present
@@ -39,6 +127,12 @@ function check_dependencies()
       fi
     fi
 
+    # Check for netstat
+    env netstat --version > /dev/null 2>&1
+    if [ $? -ne 0 ]; then
+        MISSING="$MISSING netstat"
+    fi
+
     # Check for the Perl Test Harness
     env prove --version > /dev/null 2>&1
     if [ $? -ne 0 ]; then
@@ -70,6 +164,12 @@ function check_dependencies()
         MISSING="$MISSING pidof"
     fi
 
+    # Check for netstat
+    env netstat --version > /dev/null 2>&1
+    if [ $? -ne 0 ]; then
+        MISSING="$MISSING netstat"
+    fi
+
     # check for psutil python package
     test `uname -s` == "Darwin" || test `uname -s` == "FreeBSD" && {
         pip show psutil | grep -q psutil >/dev/null 2>&1
@@ -165,8 +265,10 @@ function match()
 # G_TESTDEF_TEST_STATUS_NETBSD7
 # Some examples:
 # G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=123456
+# G_TESTDEF_TEST_STATUS_CENTOS6=BRICK_MUX_BAD_TEST,BUG=123456
 # G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=4444444
 # G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=123456;555555
+# G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TESTS,BUG=1385758
 # You can change status of test to enabled or delete the line only if all the
 # bugs are closed or modified or if the patch fixes it.
 function get_test_status ()
@@ -226,7 +328,9 @@ function get_bug_list_for_disabled_test ()
 function run_tests()
 {
     RES=0
+    FLAKY=''
     FAILED=''
+    TESTS_NEEDED_RETRY=''
     GENERATED_CORE=''
     total_tests=0
     selected_tests=0
@@ -237,15 +341,25 @@ function run_tests()
     # key = path of .t file; value = time taken to run the .t file
     declare -A ELAPSEDTIMEMAP
 
-    for t in $(find ${regression_testsdir}/tests -name '*.t' \
-               | LC_COLLATE=C sort) ; do
+    # Test if -k is supported for timeout command
+    # This is not supported on centos6, but spuported on centos7
+    # The flags is required for running the command in both flavors
+    timeout_cmd_exists="yes"
+    timeout -k 1 10 echo "testing 'timeout' command"
+    if [ $? -ne 0 ]; then
+        timeout_cmd_exists="no"
+    fi
+
+    all_tests=($(find ${regression_testsdir}/tests -name '*.t' | sort))
+    all_tests_cnt=${#all_tests[@]}
+    for t in "${all_tests[@]}" ; do
         old_cores=$(ls /*-*.core 2> /dev/null | wc -l)
         total_tests=$((total_tests+1))
         if match $t "$@" ; then
             selected_tests=$((selected_tests+1))
             echo
-            echo $section_separator$section_separator
-            if [[ $(get_test_status $t) == "BAD_TEST" ]] && \
+            echo $section_separator "(${total_tests} / ${all_tests_cnt})" $section_separator
+            if [[ $(get_test_status $t) =~ "BAD_TEST" ]] && \
                [[ $skip_bad_tests == "yes" ]]
             then
                 skipped_bad_tests=$((skipped_bad_tests+1))
@@ -265,12 +379,37 @@ function run_tests()
                 echo
                 continue
             fi
+            if [[ $(get_test_status $t) == "NFS_TEST" ]] && \
+               [[ $nfs_tests == "no" ]]
+            then
+                echo "Skipping nfs test file $t"
+                echo $section_separator$section_separator
+                echo
+                continue
+            fi
             total_run_tests=$((total_run_tests+1))
             echo "[$(date +%H:%M:%S)] Running tests in file $t"
             starttime="$(date +%s)"
-            prove -vfe '/bin/bash' $t
+
+            local cmd_timeout=$run_timeout;
+            if [ ${timeout_cmd_exists} == "yes" ]; then
+                if [ $(grep -c "SCRIPT_TIMEOUT=" ${t}) == 1 ] ; then
+                    cmd_timeout=$(grep "SCRIPT_TIMEOUT=" ${t} | cut -f2 -d'=');
+                    echo "Timeout set is ${cmd_timeout}, default ${run_timeout}"
+                fi
+                timeout --foreground -k ${kill_after_time} ${cmd_timeout} prove -vmfe '/bin/bash' ${t}
+            else
+                prove -vmfe '/bin/bash' ${t}
+            fi
             TMP_RES=$?
             ELAPSEDTIMEMAP[$t]=`expr $(date +%s) - $starttime`
+            tar_logs "$t"
+
+            # timeout always return 124 if it is actually a timeout.
+            if ((${TMP_RES} == 124)); then
+                echo "${t} timed out after ${cmd_timeout} seconds"
+            fi
+
             if [ ${TMP_RES} -ne 0 ]  && [ "x${retry}" = "xyes" ] ; then
                 echo "$t: bad status $TMP_RES"
                 echo ""
@@ -280,13 +419,34 @@ function run_tests()
                 echo "       * we got some spurious failures *"
                 echo "       *********************************"
                 echo ""
-                prove -vfe '/bin/bash' $t
+
+                if [ ${timeout_cmd_exists} == "yes" ]; then
+                    timeout --foreground -k ${kill_after_time} ${cmd_timeout} prove -vmfe '/bin/bash' ${t}
+                else
+                    prove -vmfe '/bin/bash' ${t}
+                fi
                 TMP_RES=$?
+                tar_logs "$t"
+
+                if ((${TMP_RES} == 124)); then
+                    echo "${t} timed out after ${cmd_timeout} seconds"
+                fi
+
+                TESTS_NEEDED_RETRY="${TESTS_NEEDED_RETRY}${t} "
             fi
+
+
             if [ ${TMP_RES} -ne 0 ] ; then
-                RES=${TMP_RES}
-                FAILED="${FAILED}${t} "
+		if [[ "$t" == *"tests/000-flaky/"* ]]; then
+                    FLAKY="${FLAKY}${t} "
+		    echo "FAILURE -> SUCCESS: Flaky test"
+		    TMP_RES=0
+		else
+                    RES=${TMP_RES}
+                    FAILED="${FAILED}${t} "
+		fi
             fi
+
             new_cores=$(ls /*-*.core 2> /dev/null | wc -l)
             if [ x"$new_cores" != x"$old_cores" ]; then
                 core_diff=$((new_cores-old_cores))
@@ -319,13 +479,29 @@ function run_tests()
         echo "$key  -  ${ELAPSEDTIMEMAP["$key"]} second"
     done | sort -rn -k3
 
+    # initialize the output file
+    echo > "${result_output}"
+
+    # Output the errors into a file
     if [ ${RES} -ne 0 ] ; then
         FAILED=$( echo ${FAILED} | tr ' ' '\n' | sort -u )
         FAILED_COUNT=$( echo -n "${FAILED}" | grep -c '^' )
-        echo -e "\n$FAILED_COUNT test(s) failed \n${FAILED}"
+        echo -e "\n$FAILED_COUNT test(s) failed \n${FAILED}" >> "${result_output}"
         GENERATED_CORE=$( echo  ${GENERATED_CORE} | tr ' ' '\n' | sort -u )
         GENERATED_CORE_COUNT=$( echo -n "${GENERATED_CORE}" | grep -c '^' )
-        echo -e "\n$GENERATED_CORE_COUNT test(s) generated core \n${GENERATED_CORE}"
+        echo -e "\n$GENERATED_CORE_COUNT test(s) generated core \n${GENERATED_CORE}" >> "${result_output}"
+        cat "${result_output}"
+    fi
+    TESTS_NEEDED_RETRY=$( echo ${TESTS_NEEDED_RETRY} | tr ' ' '\n' | sort -u )
+    RETRY_COUNT=$( echo -n "${TESTS_NEEDED_RETRY}" | grep -c '^' )
+    if [ ${RETRY_COUNT} -ne 0 ] ; then
+        echo -e "\n${RETRY_COUNT} test(s) needed retry \n${TESTS_NEEDED_RETRY}" >> "${result_output}"
+    fi
+
+    FLAKY_TESTS_FAILED=$( echo ${FLAKY} | tr ' ' '\n' | sort -u )
+    RETRY_COUNT=$( echo -n "${FLAKY_TESTS_FAILED}" | grep -c '^' )
+    if [ ${RETRY_COUNT} -ne 0 ] ; then
+        echo -e "\n${RETRY_COUNT} flaky test(s) marked as success even though they failed \n${FLAKY_TESTS_FAILED}" >> "${result_output}"
     fi
 
     echo
@@ -354,8 +530,38 @@ function run_head_tests()
     run_tests "$htests"
 }
 
-function parse_args () {
-    args=`getopt frcbkhH "$@"`
+function show_usage ()
+{
+    cat <<EOF
+Usage: $0 <opts> [<glob>|<bzid>]...
+
+Options:
+
+-f  force
+-h  skip tests altering from HEAD
+-H  run only tests altering from HEAD
+-r  retry failed tests
+-R  do not retry failed tests
+-c  dont't exit on failure
+-b  don't skip bad tests
+-k  don't skip known bugs
+-p  don't keep logs from preceding runs
+-o  OUTPUT
+-t  TIMEOUT
+-n  skip NFS tests
+--help
+EOF
+}
+
+usage="no"
+
+function parse_args ()
+{
+    args=`getopt -u -l help frRcbkphHno:t: "$@"`
+    if ! [ $? -eq 0 ]; then
+	show_usage
+	exit 1
+    fi
     set -- $args
     while [ $# -gt 0 ]; do
         case "$1" in
@@ -363,9 +569,15 @@ function parse_args () {
         -h)    head="no" ;;
         -H)    head="only" ;;
         -r)    retry="yes" ;;
+        -R)    retry="no" ;;
         -c)    exit_on_failure="no" ;;
         -b)    skip_bad_tests="no" ;;
         -k)    skip_known_bugs="no" ;;
+        -p)    skip_preserve_logs="no" ;;
+        -o)    result_output="$2"; shift;;
+        -t)    run_timeout="$2"; shift;;
+        -n)    nfs_tests="no";;
+        --help) usage="yes" ;;
         --)    shift; break;;
         esac
         shift
@@ -380,6 +592,10 @@ echo
 
 # Get user options
 parse_args "$@"
+if [ x"$usage" == x"yes" ]; then
+    show_usage
+    exit 0
+fi
 
 # Make sure we're running as the root user
 check_user
diff --git a/site.h.in b/site.h.in
index d917d78e59b..eb2f062e60c 100644
--- a/site.h.in
+++ b/site.h.in
@@ -20,8 +20,25 @@
  * what works.
  */
 
+#define SITE_H_ENABLE_LEAST_PRIORITY    "on"
+#define SITE_H_MD_CACHE_TIMEOUT         "1"
+#define SITE_H_NFS_DISABLE              "on"
+
 /*
- * This is just an example, and a way to check whether site.h is actually being
- * included automatically.
+ * As an example of how to use this file, here's what the Facebook version looks
+ * like:
+
+#define SITE_H_ENABLE_LEAST_PRIORITY    "off"
+#define SITE_H_MD_CACHE_TIMEOUT         "180"
+#define SITE_H_NFS_DISABLE              "off"
+
+ * Each time we add a value here, we lessen the risk of values being
+ * inconsistent across production automation, test automation, and manual
+ * developer testing. We also save effort compared to updating values for each
+ * kind of external automation. To do the same thing with configure scripts or
+ * specfiles, we'd have to make much more complicated and less discoverable
+ * changes there.
+ *
+ * Other orgs are likely to have the same issues regarding their preferred
+ * settings, and likewise should add their favorites here as well.
  */
-#define SITE_DOT_H_TEST		9987
diff --git a/submit-for-review.sh b/submit-for-review.sh
new file mode 120000
index 00000000000..a21c0e2869a
--- /dev/null
+++ b/submit-for-review.sh
@@ -0,0 +1 @@
+rfc.sh
+\ No newline at end of file
diff --git a/tests/00-geo-rep/00-georep-verify-non-root-setup.t b/tests/00-geo-rep/00-georep-verify-non-root-setup.t
new file mode 100644
index 00000000000..a55fd3e5e6a
--- /dev/null
+++ b/tests/00-geo-rep/00-georep-verify-non-root-setup.t
@@ -0,0 +1,294 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=600
+
+### Basic Non-root geo-rep setup test with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+##User and group to be used for non-root geo-rep setup
+usr="nroot"
+grp="ggroup"
+
+slave_url=$usr@$slave
+slave_vol=$GSV0
+ssh_url=$usr@$SH0
+
+############################################################
+#SETUP VOLUMES AND VARIABLES
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+
+##Mount master
+#TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+#TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+
+##########################################################
+#TEST FUNCTIONS
+
+function distribute_key_non_root()
+{
+    ${GLUSTER_LIBEXECDIR}/set_geo_rep_pem_keys.sh $usr $master $slave_vol
+    echo $?
+}
+
+
+function check_status_non_root()
+{
+    local search_key=$1
+    $GEOREP_CLI $master $slave_url status | grep -F "$search_key" | wc -l
+}
+
+
+function check_and_clean_group()
+{
+        if [ $(getent group $grp) ]
+        then
+                groupdel $grp;
+                echo $?
+        else
+                echo 0
+        fi
+}
+
+function clean_lock_files()
+{
+        if [ ! -f /etc/passwd.lock ];
+        then
+                rm -rf /etc/passwd.lock;
+        fi
+
+        if [ ! -f /etc/group.lock ];
+        then
+                rm -rf /etc/group.lock;
+        fi
+
+        if [ ! -f /etc/shadow.lock ];
+        then
+                rm -rf /etc/shadow.lock;
+        fi
+
+        if [ ! -f /etc/gshadow.lock ];
+        then
+                rm -rf /etc/gshadow.lock;
+        fi
+}
+
+
+###########################################################
+#SETUP NON-ROOT GEO REPLICATION
+
+##Create ggroup group
+##First test if group exists and then create new one
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_and_clean_group
+
+##cleanup *.lock files
+
+clean_lock_files
+
+TEST /usr/sbin/groupadd $grp
+
+clean_lock_files
+##Del if exists and create non-root user and assign it to newly created group
+userdel -r -f $usr
+TEST /usr/sbin/useradd -G $grp $usr
+
+##Modify password for non-root user to have control over distributing ssh-key
+echo "$usr:pass" | chpasswd
+
+##Set up mountbroker root
+TEST gluster-mountbroker setup /var/mountbroker-root $grp
+
+##Associate volume and non-root user to the mountbroker
+TEST gluster-mountbroker add $slave_vol $usr
+
+##Check ssh setting for clear text passwords
+sed '/^PasswordAuthentication /{s/no/yes/}' -i /etc/ssh/sshd_config && grep '^PasswordAuthentication ' /etc/ssh/sshd_config && service sshd restart
+
+
+##Restart glusterd to reflect mountbroker changages
+TEST killall_gluster;
+TEST glusterd;
+TEST pidof glusterd;
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "3" brick_count ${META_VOL}
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "4" brick_count $GMV0
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "4" brick_count $GSV0
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+## Check status of mount-broker
+TEST gluster-mountbroker status
+
+
+##Setup password-less ssh for non-root user
+#sshpass -p "pass" ssh-copy-id -i ~/.ssh/id_rsa.pub $ssh_url
+##Run ssh agent
+eval "$(ssh-agent -s)"
+PASS="pass"
+
+
+##Create a temp script to echo the SSH password, used by SSH_ASKPASS
+
+SSH_ASKPASS_SCRIPT=/tmp/ssh-askpass-script
+cat > ${SSH_ASKPASS_SCRIPT} <<EOL
+#!/bin/bash
+echo "${PASS}"
+EOL
+chmod u+x ${SSH_ASKPASS_SCRIPT}
+
+##set no display, necessary for ssh to use with setsid and SSH_ASKPASS
+export DISPLAY
+
+export SSH_ASKPASS=${SSH_ASKPASS_SCRIPT}
+
+DISPLAY=: setsid ssh-copy-id -o 'PreferredAuthentications=password' -o 'StrictHostKeyChecking=no' -i ~/.ssh/id_rsa.pub $ssh_url
+
+##Setting up PATH for gluster binaries in case of source installation
+##ssh -oNumberOfPasswordPrompts=0 -oStrictHostKeyChecking=no $ssh_url "echo "export PATH=$PATH:/usr/local/sbin" >> ~/.bashrc"
+
+##Creating secret pem pub file
+TEST gluster-georep-sshkey generate
+
+##Create geo-rep non-root setup
+
+TEST $GEOREP_CLI $master $slave_url create push-pem
+
+#check for session creation
+EXPECT_WITHIN $GEO_REP_TIMEOUT 4 check_status_non_root "Created"
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave_url config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave_url config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+## Test for key distribution
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 distribute_key_non_root
+
+##Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave_url start
+
+## Meta volume is enabled so looking for 2 Active and 2 Passive sessions
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_non_root "Active"
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_non_root "Passive"
+
+#Pause geo-replication session
+TEST $GEOREP_CLI  $master $slave_url pause
+
+#Resume geo-replication session
+TEST $GEOREP_CLI  $master $slave_url resume
+
+#Validate failure of volume stop when geo-rep is running
+TEST ! $CLI volume stop $GMV0
+
+#Negative test for ssh-port
+#Port should be integer and between 1-65535 range
+
+TEST ! $GEOREP_CLI $master $slave_url config ssh-port -22
+
+TEST ! $GEOREP_CLI $master $slave_url config ssh-port abc
+
+TEST ! $GEOREP_CLI $master $slave_url config ssh-port 6875943
+
+TEST ! $GEOREP_CLI $master $slave_url config ssh-port 4.5
+
+TEST ! $GEOREP_CLI $master $slave_url config ssh-port 22a
+
+#Config Set ssh-port to validate int validation
+TEST $GEOREP_CLI $master $slave config ssh-port 22
+
+#Hybrid directory rename test BZ#1763439
+
+TEST $GEOREP_CLI $master $slave_url config change_detector xsync
+#verify master and slave mount
+
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT "^1$" check_mounted ${master_mnt}
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT "^1$" check_mounted ${slave_mnt}
+
+#Create test data for hybrid crawl
+TEST mkdir ${master_mnt}/dir1
+TEST mkdir ${master_mnt}/dir1/dir2
+TEST mkdir ${master_mnt}/dir1/dir3
+TEST mkdir ${master_mnt}/hybrid_d1
+
+mv ${master_mnt}/hybrid_d1 ${master_mnt}/hybrid_rn_d1
+mv ${master_mnt}/dir1/dir2 ${master_mnt}/rn_dir2
+mv ${master_mnt}/dir1/dir3 ${master_mnt}/dir1/rn_dir3
+
+#Verify hybrid crawl data on slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/dir1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_rn_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/rn_dir2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/dir1/rn_dir3
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave_url stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave_url delete
+
+#Cleanup authorized_keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' /home/$usr/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' /home/$usr/.ssh/authorized_keys
+
+#clear mountbroker
+gluster-mountbroker remove --user $usr
+gluster-mountbroker remove --volume $slave_vol
+
+#delete group and user created for non-root setup
+TEST userdel -r -f $usr
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_and_clean_group
+
+##password script cleanup
+rm -rf /tmp/ssh-askpass-script
+
+
+cleanup;
+
diff --git a/tests/00-geo-rep/00-georep-verify-setup.t b/tests/00-geo-rep/00-georep-verify-setup.t
new file mode 100644
index 00000000000..0d46c04102d
--- /dev/null
+++ b/tests/00-geo-rep/00-georep-verify-setup.t
@@ -0,0 +1,110 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=400
+GEO_REP_TIMEOUT=200
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Test invalid slave url
+TEST ! $GEOREP_CLI $master ${SH0}:${GSV0} create push-pem
+TEST ! $GEOREP_CLI $master ${SH0}:::${GSV0} create push-pem
+
+#Create geo-rep session
+TEST create_georep_session $master $slave
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#get-state commamd shouldn't crash glusterd when geo-rep session is configured
+TEST $CLI get-state
+TEST pidof glusterd
+
+TEST $CLI get-state detail
+TEST pidof glusterd
+
+#Pause geo-replication session
+TEST $GEOREP_CLI  $master $slave pause
+
+#Resume geo-replication session
+TEST $GEOREP_CLI  $master $slave resume
+
+#Validate failure of volume stop when geo-rep is running
+TEST ! $CLI volume stop $GMV0
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/01-georep-glusterd-tests.t b/tests/00-geo-rep/01-georep-glusterd-tests.t
new file mode 100644
index 00000000000..47d5116af26
--- /dev/null
+++ b/tests/00-geo-rep/01-georep-glusterd-tests.t
@@ -0,0 +1,213 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=300
+
+#Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+#Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+slave1=root@${SH0}::${GSV1}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+#create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 3 $H0:$B0/${GMV0}{1,2,3};
+
+#Negative testase: Create geo-rep session, master is not started
+TEST ! $GEOREP_CLI $master $slave create push-pem
+
+TEST $CLI volume start $GMV0
+
+#create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 3 $H0:$B0/${GSV0}{1,2,3};
+
+#Negative testcase: Create geo-rep session, slave is not started
+TEST ! $GEOREP_CLI $master $slave create push-pem
+
+TEST $CLI volume start $GSV0
+
+#create_and_start_slave1_volume
+TEST $CLI volume create $GSV1 replica 3 $H0:$B0/${GSV1}{1,2,3};
+TEST $CLI volume start $GSV1
+
+#Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+#Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+#Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION GLUSTERD TESTS WITH FANOUT SETUP
+############################################################
+
+#Negative testcase: Test invalid master
+TEST ! $GEOREP_CLI master1 ${SH0}::${GSV0} create push-pem
+
+#Negatvie testcase: Test invalid slave
+TEST ! $GEOREP_CLI $master ${SH0}::slave3 create push-pem
+
+##------------------- Session 1 Creation Begin-----------------##
+#Create geo-rep session
+TEST create_georep_session $master $slave
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+##------------------- Session 1 Creation End-----------------##
+
+##------------------- Session 2 Creation Begin-----------------##
+#Create geo-rep session2
+TEST $GEOREP_CLI $master $slave1 create ssh-port 22 no-verify
+
+#Config gluster-command-dir for session2
+TEST $GEOREP_CLI $master $slave1 config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir for session2
+TEST $GEOREP_CLI $master $slave1 config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume for session2
+TEST $GEOREP_CLI $master $slave1 config use_meta_volume true
+##------------------- Session 2 Creation End-----------------##
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+#check geo-rep status without specifying master and slave volumes
+TEST $GEOREP_CLI status
+
+#Start_georep force
+TEST $GEOREP_CLI $master $slave1 start force
+
+#Negative testcase: Create the same session after start, fails
+#With root@ prefix
+TEST ! $GEOREP_CLI $master $slave1 create push-pem
+#Without root@ prefix
+TEST ! $GEOREP_CLI $master ${SH0}::${GSV1} create push-pem
+TEST $GEOREP_CLI $master $slave1 create push-pem force
+
+##------------------- Fanout status testcases Begin --------------##
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_fanout_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_fanout_status_num_rows "Passive"
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_fanout_status_detail_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_fanout_status_detail_num_rows "Passive"
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_all_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_all_status_num_rows "Passive"
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_all_status_detail_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_all_status_detail_num_rows "Passive"
+
+##------------------- Fanout status testcases End --------------##
+
+##------Checkpoint Testcase Begin---------------##
+#Write I/O
+echo "test data" > $M0/file1
+TEST $GEOREP_CLI $master $slave config checkpoint now
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_checkpoint_met $master $slave
+touch $M0
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 verify_checkpoint_met $master $slave
+##------Checkpoint Testcase End---------------##
+
+##------------------ Geo-rep config testcases Begin--------------------##
+TEST $GEOREP_CLI $master $slave config
+TEST ! $GEOREP_CLI $master $slave config arsync-options '-W'
+TEST $GEOREP_CLI $master $slave config rsync-options '-W'
+TEST $GEOREP_CLI $master $slave config rsync-options
+TEST $GEOREP_CLI $master $slave config \!rsync-options
+TEST $GEOREP_CLI $master $slave config sync-xattrs false
+##------------------ Geo-rep config testcases End --------------------##
+
+##---------------- Pause/Resume testcase Begin-------------##
+#Negative testcase: Resume geo-replication session when not paused
+TEST ! $GEOREP_CLI  $master $slave1 resume
+TEST $GEOREP_CLI  $master $slave1 resume force
+
+#Pause geo-replication session with root@
+TEST $GEOREP_CLI $master $slave1 pause force
+
+#Resume geo-replication session with root@
+TEST $GEOREP_CLI $master $slave1 resume force
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave1 stop force
+
+#Negative testcase: Resume geo-replication session after geo-rep stop
+TEST ! $GEOREP_CLI  $master $slave1 resume
+##---------------- Pause/Resume testcase End-------------##
+
+##-----------------glusterd slave key/value upgrade testcase Begin ---------##
+#Upgrade test of slave key stored in glusterd info file
+src=$(grep slave2 /var/lib/glusterd/vols/$master/info)
+#Remove slave uuuid (last part after divided by : )
+dst=${src%:*}
+
+#Update glusterd info file with old slave format
+sed -i "s|$src|$dst|g" /var/lib/glusterd/vols/$master/info
+TEST ! grep $src /var/lib/glusterd/vols/$master/info
+
+#Restart glusterd to update in-memory volinfo
+TEST pkill glusterd
+TEST glusterd;
+TEST pidof glusterd
+
+#Start geo-rep and validate slave format is updated
+TEST $GEOREP_CLI $master $slave1 start force
+TEST grep $src /var/lib/glusterd/vols/$master/info
+##-----------------glusted slave key/value upgrade testcase End ---------##
+
+#Negative testcase: Delete Geo-rep 2 fails as geo-rep is running
+TEST ! $GEOREP_CLI $master $slave1 delete
+
+#Stop and Delete Geo-rep 2
+TEST $GEOREP_CLI $master $slave1 stop force
+TEST $GEOREP_CLI $master $slave1 delete reset-sync-time
+
+#Stop and Delete Geo-rep 1
+TEST $GEOREP_CLI $master $slave stop
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/bug-1600145.t b/tests/00-geo-rep/bug-1600145.t
new file mode 100644
index 00000000000..1d38bf92682
--- /dev/null
+++ b/tests/00-geo-rep/bug-1600145.t
@@ -0,0 +1,109 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+SCRIPT_TIMEOUT=600
+TEST glusterd;
+TEST pidof glusterd
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2};
+gluster v set all cluster.brick-multiplex on
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2};
+TEST $CLI volume start $GSV0
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Create geo-rep session
+TEST create_georep_session $master $slave
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Count no. of changelog socket
+brick_pid=`ps -aef | grep glusterfsd | grep -v "shared_storage" | grep -v grep | awk -F " " '{print $2}'`
+n=$(grep -Fc "changelog" /proc/$brick_pid/net/unix)
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Passive"
+
+#Count no. of changelog socket
+brick_pid=`ps -aef | grep glusterfsd | grep -v "shared_storage" | grep -v grep | awk -F " " '{print $2}'`
+c=$(grep -Fc "changelog" /proc/$brick_pid/net/unix)
+let expected=n+2
+TEST [ "$c" -eq "$expected" ]
+
+#Kill the "Active" brick
+brick=$($GEOREP_CLI $master $slave status | grep -F "Active" | awk {'print $3'})
+cat /proc/$brick_pid/net/unix | grep "changelog"
+TEST kill_brick $GMV0 $H0 $brick
+#Expect geo-rep status to be "Faulty"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Faulty"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+
+#Count no. of changelog socket
+brick_pid=`ps -aef | grep glusterfsd | grep -v "shared_storage" | grep -v grep | awk -F " " '{print $2}'`
+cat /proc/$brick_pid/net/unix | grep "changelog"
+ls -lrth /proc/$brick_pid/fd | grep "socket"
+c=$(grep -Fc "changelog" /proc/$brick_pid/net/unix)
+TEST [ "$c" -eq "$n" ]
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
diff --git a/tests/00-geo-rep/bug-1708603.t b/tests/00-geo-rep/bug-1708603.t
new file mode 100644
index 00000000000..26913f1d318
--- /dev/null
+++ b/tests/00-geo-rep/bug-1708603.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=300
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="gluster volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+#Create geo-rep session
+TEST create_georep_session $master $slave
+
+echo n | $GEOREP_CLI $master $slave config ignore-deletes true >/dev/null 2>&1
+EXPECT "false" echo $($GEOREP_CLI $master $slave config ignore-deletes)
+echo y | $GEOREP_CLI $master $slave config ignore-deletes true
+EXPECT "true" echo $($GEOREP_CLI $master $slave config ignore-deletes)
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-dr-rsync-arbiter.t b/tests/00-geo-rep/georep-basic-dr-rsync-arbiter.t
new file mode 100644
index 00000000000..c45d2ff62ce
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-dr-rsync-arbiter.t
@@ -0,0 +1,234 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=4
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 3 arbiter 1 $H0:$B0/${GMV0}{1,2,3,4,5,6};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 3 arbiter 1 $H0:$B0/${GSV0}{1,2,3,4,5,6};
+TEST $CLI volume start $GSV0
+TEST $CLI volume set $GSV0 performance.stat-prefetch off
+TEST $CLI volume set $GSV0 performance.quick-read off
+TEST $CLI volume set $GSV0 performance.readdir-ahead off
+TEST $CLI volume set $GSV0 performance.read-ahead off
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 6 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+#TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#Test rsync-options set BUG:1629561
+TEST gluster volume geo-rep $master $slave config rsync-options "--whole-file"
+TEST "echo sampledata > $master_mnt/rsync_option_test_file"
+
+#rename with existing destination case BUG:1694820
+TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Pause geo-replication session
+TEST $GEOREP_CLI  $master $slave pause force
+
+#Resume geo-replication session
+TEST $GEOREP_CLI  $master $slave resume force
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-dr-rsync.t b/tests/00-geo-rep/georep-basic-dr-rsync.t
new file mode 100644
index 00000000000..d785aa59fc9
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-dr-rsync.t
@@ -0,0 +1,258 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+TEST $CLI volume set $GSV0 performance.stat-prefetch off
+TEST $CLI volume set $GSV0 performance.quick-read off
+TEST $CLI volume set $GSV0 performance.readdir-ahead off
+TEST $CLI volume set $GSV0 performance.read-ahead off
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 4 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Negative test for ssh-port
+#Port should be integer and between 1-65535 range
+
+TEST ! $GEOREP_CLI $master $slave config ssh-port -22
+
+TEST ! $GEOREP_CLI $master $slave config ssh-port abc
+
+TEST ! $GEOREP_CLI $master $slave config ssh-port 6875943
+
+TEST ! $GEOREP_CLI $master $slave config ssh-port 4.5
+
+TEST ! $GEOREP_CLI $master $slave config ssh-port 22a
+
+#Config Set ssh-port to validate int validation
+TEST $GEOREP_CLI $master $slave config ssh-port 22
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST create_rename_symlink_case
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#Test rsync-options set BUG:1629561
+TEST gluster volume geo-rep $master $slave config rsync-options "--whole-file"
+TEST "echo sampledata > $master_mnt/rsync_option_test_file"
+
+#rename with existing destination case BUG:1694820
+TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Test config upgrade BUG: 1707731
+config_file=$GLUSTERD_WORKDIR/geo-replication/${GMV0}_${SH0}_${GSV0}/gsyncd.conf
+cat >> $config_file<<EOL
+[peers ${GMV0} ${GSV0}]
+use_tarssh = true
+timeout = 1
+EOL
+TEST $GEOREP_CLI $master $slave stop
+TEST $GEOREP_CLI $master $slave start
+#verify that the config file is updated
+EXPECT "1" echo $(grep -Fc "vars" $config_file)
+EXPECT "1" echo $(grep -Fc "sync-method = tarssh" $config_file)
+EXPECT "1" echo $(grep -Fc "slave-timeout = 1" $config_file)
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-dr-tarssh-arbiter.t b/tests/00-geo-rep/georep-basic-dr-tarssh-arbiter.t
new file mode 100644
index 00000000000..8fed929ffca
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-dr-tarssh-arbiter.t
@@ -0,0 +1,227 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=4
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 3 arbiter 1 $H0:$B0/${GMV0}{1,2,3,4,5,6};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 3 arbiter 1 $H0:$B0/${GSV0}{1,2,3,4,5,6};
+TEST $CLI volume start $GSV0
+TEST $CLI volume set $GSV0 performance.stat-prefetch off
+TEST $CLI volume set $GSV0 performance.quick-read off
+TEST $CLI volume set $GSV0 performance.readdir-ahead off
+TEST $CLI volume set $GSV0 performance.read-ahead off
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 6 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Config tarssh as sync-engine
+TEST $GEOREP_CLI $master $slave config sync-method tarssh
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+#TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#rename with existing destination case BUG:1694820
+TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-dr-tarssh.t b/tests/00-geo-rep/georep-basic-dr-tarssh.t
new file mode 100644
index 00000000000..feb2de74c90
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-dr-tarssh.t
@@ -0,0 +1,227 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+TEST $CLI volume set $GSV0 performance.stat-prefetch off
+TEST $CLI volume set $GSV0 performance.quick-read off
+TEST $CLI volume set $GSV0 performance.readdir-ahead off
+TEST $CLI volume set $GSV0 performance.read-ahead off
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 4 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Config tarssh as sync-engine
+TEST $GEOREP_CLI $master $slave config sync-method tarssh
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#rename with existing destination case BUG:1694820
+TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-rsync-ec.t b/tests/00-geo-rep/georep-basic-rsync-ec.t
new file mode 100644
index 00000000000..dd1f94edbc9
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-rsync-ec.t
@@ -0,0 +1,224 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distributed Disperse volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=10
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 disperse 3 redundancy 1 $H0:$B0/${GMV0}{0..5};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 disperse 3 redundancy 1 $H0:$B0/${GSV0}{0..5};
+TEST $CLI volume start $GSV0
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 6 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+#TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#Test rsync-options set BUG:1629561
+TEST gluster volume geo-rep $master $slave config rsync-options "--whole-file"
+TEST "echo sampledata > $master_mnt/rsync_option_test_file"
+
+#rename with existing destination case BUG:1694820
+#TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-basic-tarssh-ec.t b/tests/00-geo-rep/georep-basic-tarssh-ec.t
new file mode 100644
index 00000000000..987bd9391c8
--- /dev/null
+++ b/tests/00-geo-rep/georep-basic-tarssh-ec.t
@@ -0,0 +1,223 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distributed Disperse volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=10
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 disperse 3 redundancy 1 $H0:$B0/${GMV0}{0..5};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 disperse 3 redundancy 1 $H0:$B0/${GSV0}{0..5};
+TEST $CLI volume start $GSV0
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Check Hybrid Crawl
+TEST create_data "hybrid"
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 6 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Set changelog roll-over time to 3 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 3
+
+#Config tarssh as sync-engine
+TEST $GEOREP_CLI $master $slave config sync-method tarssh
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Verify "features.read-only" Option
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 check_slave_read_only $GSV0
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "hybrid"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/hybrid_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/hybrid_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/hybrid_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/hybrid_chown_f1
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data "history"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#data_tests "history"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/history_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/history_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok history_f1 ${slave_mnt}/history_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/history_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/history_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/history_chown_f1
+
+#Check Changelog Crawl.
+EXPECT_WITHIN $GEO_REP_TIMEOUT 2 check_status_num_rows "Changelog Crawl"
+TEST create_data "changelog"
+
+# logrotate test
+logrotate_file=${master_mnt}/logrotate/lg_test_file
+TEST mkdir -p ${master_mnt}/logrotate
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+logrotate_simulate $logrotate_file 2
+
+# CREATE + RENAME
+create_rename ${master_mnt}/rename_test_file
+
+# hard-link rename
+hardlink_rename ${master_mnt}/hardlink_rename_test_file
+
+#SYNC CHECK
+#data_tests "changelog"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 regular_file_ok ${slave_mnt}/changelog_f1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/changelog_d1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_file_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 rename_dir_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_f2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 unlink_ok ${slave_mnt}/changelog_d2
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 chown_file_ok ${slave_mnt}/changelog_chown_f1
+
+#logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 directory_ok ${slave_mnt}/logrotate
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt}/logrotate ${slave_mnt}/logrotate
+
+#CREATE+RENAME
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 create_rename_ok ${slave_mnt}/create_rename_test_file
+
+#hardlink rename
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Symlink testcase: Rename symlink and create dir with same name
+TEST create_symlink_rename_mkdir_data
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+TEST create_hardlink_rename_data
+
+#rsnapshot usecase
+#TEST create_rsnapshot_data
+
+#Start Geo-rep
+TEST $GEOREP_CLI $master $slave start
+
+#Wait for geo-rep to come up
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  4 check_status_num_rows "Passive"
+
+#Check for hardlink rename case. BUG: 1296174
+#It should not create src file again on changelog reprocessing
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 hardlink_rename_ok ${slave_mnt}/hardlink_rename_test_file
+
+#Symlink testcase: Rename symlink and create dir with same name
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_symlink_rename_mkdir_data ${slave_mnt}/symlink_test1
+
+#hardlink-rename-unlink usecase. Sonatype Nexus3 Usecase. BUG:1512483
+EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_hardlink_rename_data ${slave_mnt}
+
+#rsnapshot usecase
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rsnapshot_data ${slave_mnt}
+
+#rename with existing destination case BUG:1694820
+#TEST create_rename_with_existing_destination ${master_mnt}
+#verify rename with existing destination case BUG:1694820
+#EXPECT_WITHIN $GEO_REP_TIMEOUT 0 verify_rename_with_existing_destination ${slave_mnt}
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-config-upgrade.t b/tests/00-geo-rep/georep-config-upgrade.t
new file mode 100644
index 00000000000..557461cd9c4
--- /dev/null
+++ b/tests/00-geo-rep/georep-config-upgrade.t
@@ -0,0 +1,132 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=300
+OLD_CONFIG_PATH=$(dirname $0)/gsyncd.conf.old
+WORKING_DIR=/var/lib/glusterd/geo-replication/master_127.0.0.1_slave
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};
+TEST $CLI volume start $GSV0
+
+##Create, start and mount meta_volume
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+#Create geo-rep session
+TEST create_georep_session $master $slave
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Enable_metavolume
+TEST $GEOREP_CLI $master $slave config use_meta_volume true
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  2 check_status_num_rows "Passive"
+
+TEST $GEOREP_CLI $master $slave config sync-method tarssh
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Copy old config file
+mv -f $WORKING_DIR/gsyncd.conf $WORKING_DIR/gsyncd.conf.org
+cp -p $OLD_CONFIG_PATH $WORKING_DIR/gsyncd.conf
+
+#Check if config get all updates config_file
+TEST ! grep "sync-method" $WORKING_DIR/gsyncd.conf
+TEST $GEOREP_CLI $master $slave config
+TEST grep "sync-method" $WORKING_DIR/gsyncd.conf
+
+#Check if config get updates config_file
+rm -f $WORKING_DIR/gsyncd.conf
+cp -p $OLD_CONFIG_PATH $WORKING_DIR/gsyncd.conf
+TEST ! grep "sync-method" $WORKING_DIR/gsyncd.conf
+TEST $GEOREP_CLI $master $slave config sync-method
+TEST grep "sync-method" $WORKING_DIR/gsyncd.conf
+
+#Check if config set updates config_file
+rm -f $WORKING_DIR/gsyncd.conf
+cp -p $OLD_CONFIG_PATH $WORKING_DIR/gsyncd.conf
+TEST ! grep "sync-method" $WORKING_DIR/gsyncd.conf
+TEST $GEOREP_CLI $master $slave config sync-xattrs false
+TEST grep "sync-method" $WORKING_DIR/gsyncd.conf
+
+#Check if config reset updates config_file
+rm -f $WORKING_DIR/gsyncd.conf
+cp -p $OLD_CONFIG_PATH $WORKING_DIR/gsyncd.conf
+TEST ! grep "sync-method" $WORKING_DIR/gsyncd.conf
+TEST $GEOREP_CLI $master $slave config \!sync-xattrs
+TEST grep "sync-method" $WORKING_DIR/gsyncd.conf
+
+#Check if geo-rep start updates config_file
+rm -f $WORKING_DIR/gsyncd.conf
+cp -p $OLD_CONFIG_PATH $WORKING_DIR/gsyncd.conf
+TEST ! grep "sync-method" $WORKING_DIR/gsyncd.conf
+TEST $GEOREP_CLI $master $slave start
+TEST grep "sync-method" $WORKING_DIR/gsyncd.conf
+
+#Stop geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-stderr-hang.t b/tests/00-geo-rep/georep-stderr-hang.t
new file mode 100644
index 00000000000..496f0e6577d
--- /dev/null
+++ b/tests/00-geo-rep/georep-stderr-hang.t
@@ -0,0 +1,128 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../geo-rep.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=500
+
+AREQUAL_PATH=$(dirname $0)/../utils
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+
+### Basic Tests with Distribute Replicate volumes
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+
+##Variables
+GEOREP_CLI="$CLI volume geo-replication"
+master=$GMV0
+SH0="127.0.0.1"
+slave=${SH0}::${GSV0}
+num_active=2
+num_passive=2
+master_mnt=$M0
+slave_mnt=$M1
+
+############################################################
+#SETUP VOLUMES AND GEO-REPLICATION
+############################################################
+
+##create_and_start_master_volume
+TEST $CLI volume create $GMV0 $H0:$B0/${GMV0}1;
+TEST $CLI volume start $GMV0
+
+##create_and_start_slave_volume
+TEST $CLI volume create $GSV0 $H0:$B0/${GSV0}1;
+TEST $CLI volume start $GSV0
+TEST $CLI volume set $GSV0 performance.stat-prefetch off
+TEST $CLI volume set $GSV0 performance.quick-read off
+TEST $CLI volume set $GSV0 performance.readdir-ahead off
+TEST $CLI volume set $GSV0 performance.read-ahead off
+
+##Mount master
+TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
+
+##Mount slave
+TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
+
+############################################################
+#BASIC GEO-REPLICATION TESTS
+############################################################
+
+TEST create_georep_session $master $slave
+EXPECT_WITHIN $GEO_REP_TIMEOUT 1 check_status_num_rows "Created"
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Config gluster-command-dir
+TEST $GEOREP_CLI $master $slave config slave-gluster-command-dir ${GLUSTER_CMD_DIR}
+
+#Set changelog roll-over time to 45 secs
+TEST $CLI volume set $GMV0 changelog.rollover-time 45
+
+#Wait for common secret pem file to be created
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_common_secret_file
+
+#Verify the keys are distributed
+EXPECT_WITHIN $GEO_REP_TIMEOUT  0 check_keys_distributed
+
+#Set sync-jobs to 1
+TEST $GEOREP_CLI $master $slave config sync-jobs 1
+
+#Start_georep
+TEST $GEOREP_CLI $master $slave start
+
+touch $M0
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Changelog Crawl"
+
+#Check History Crawl.
+TEST $GEOREP_CLI $master $slave stop
+TEST create_data_hang "rsync_hang"
+TEST create_data "history_rsync"
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Config tarssh as sync-engine
+TEST $GEOREP_CLI $master $slave config sync-method tarssh
+
+#Create tarssh hang data
+TEST create_data_hang "tarssh_hang"
+TEST create_data "history_tar"
+
+TEST $GEOREP_CLI $master $slave start
+EXPECT_WITHIN $GEO_REP_TIMEOUT  1 check_status_num_rows "Active"
+
+#Verify arequal for whole volume
+EXPECT_WITHIN $GEO_REP_TIMEOUT "x0" arequal_checksum ${master_mnt} ${slave_mnt}
+
+#Stop Geo-rep
+TEST $GEOREP_CLI $master $slave stop
+
+#Delete Geo-rep
+TEST $GEOREP_CLI $master $slave delete
+
+#Cleanup are-equal binary
+TEST rm $AREQUAL_PATH/arequal-checksum
+
+#Cleanup authorized keys
+sed -i '/^command=.*SSH_ORIGINAL_COMMAND#.*/d' ~/.ssh/authorized_keys
+sed -i '/^command=.*gsyncd.*/d' ~/.ssh/authorized_keys
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/00-geo-rep/georep-upgrade.t b/tests/00-geo-rep/georep-upgrade.t
new file mode 100644
index 00000000000..7523068ed50
--- /dev/null
+++ b/tests/00-geo-rep/georep-upgrade.t
@@ -0,0 +1,79 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+SCRIPT_TIMEOUT=500
+
+###############################################################################################
+#Before upgrade
+###############################################################################################
+brick=/bricks/brick1
+epoch1=$(date '+%s')
+sleep 1
+epoch2=$(date '+%s')
+mkdir -p /bricks/brick1/.glusterfs/changelogs/htime
+mkdir -p /bricks/brick1/.glusterfs/changelogs
+
+#multiple htime files(changelog enable/disable scenario)
+TEST touch /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch1
+TEST touch /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch2
+
+#changelog files
+TEST touch /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch1
+TEST touch /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch2
+
+htime_file1=/bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch1
+htime_file2=/bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch2
+
+#data inside htime files before upgrade
+data1=/bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch1
+data2=/bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch2
+
+#data inside htime files after upgrade
+updated_data1=/bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m/%d')`/CHANGELOG.$epoch1
+updated_data2=/bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m/%d')`/CHANGELOG.$epoch2
+
+echo -n $data1>$htime_file1
+echo -n $data2>$htime_file2
+
+echo "Before upgrade:"
+EXPECT '1' echo $(grep $data1 $htime_file1 | wc -l)
+EXPECT '1' echo $(grep $data2 $htime_file2 | wc -l)
+
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch1 | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch1 | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch2 | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch2 | wc -l)
+###############################################################################################
+#Upgrade
+###############################################################################################
+### This needed to be fixed as this very vague finding a file with name in '/'
+### multiple file with same name can exist
+### for temp fix picking only 1st result
+TEST upgrade_script=$(find / -type f -name glusterfs-georep-upgrade.py -print | head -n 1)
+TEST python3 $upgrade_script $brick
+
+###############################################################################################
+#After upgrade
+###############################################################################################
+echo "After upgrade:"
+EXPECT '1' echo $(grep $updated_data1 $htime_file1 | wc -l)
+EXPECT '1' echo $(grep $updated_data2 $htime_file2 | wc -l)
+
+#Check directory structure inside changelogs
+TEST ! ls /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch1
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch1 | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch1.bak | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y')` | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m')` | wc -l)
+EXPECT '2' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m/%d')` | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m/%d')`/CHANGELOG.$epoch1 | wc -l)
+
+TEST ! ls /bricks/brick1/.glusterfs/changelogs/CHANGELOG.$epoch2
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch2 | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/htime/HTIME.$epoch2.bak | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y')` | wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m')`| wc -l)
+EXPECT '1' echo $(ls /bricks/brick1/.glusterfs/changelogs/`echo $(date '+%Y/%m/%d')`/CHANGELOG.$epoch2 | wc -l)
+
+TEST rm -rf /bricks
diff --git a/tests/00-geo-rep/gsyncd.conf.old b/tests/00-geo-rep/gsyncd.conf.old
new file mode 100644
index 00000000000..519acaf8f3e
--- /dev/null
+++ b/tests/00-geo-rep/gsyncd.conf.old
@@ -0,0 +1,47 @@
+[__meta__]
+version = 2.0
+
+[peersrx . .]
+remote_gsyncd = /usr/local/libexec/glusterfs/gsyncd
+georep_session_working_dir = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/
+ssh_command_tar = ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i /var/lib/glusterd/geo-replication/tar_ssh.pem
+changelog_log_file = /var/log/glusterfs/geo-replication/${mastervol}/${eSlave}${local_id}-changes.log
+working_dir = /var/lib/misc/glusterfsd/${mastervol}/${eSlave}
+ignore_deletes = false
+pid_file = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/monitor.pid
+state_file = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/monitor.status
+gluster_command_dir = /usr/local/sbin/
+gluster_params = aux-gfid-mount acl
+ssh_command = ssh -oPasswordAuthentication=no -oStrictHostKeyChecking=no -i /var/lib/glusterd/geo-replication/secret.pem
+state_detail_file = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/${eSlave}-detail.status
+state_socket_unencoded = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/${eSlave}.socket
+socketdir = /var/run/gluster
+log_file = /var/log/glusterfs/geo-replication/${mastervol}/${eSlave}.log
+gluster_log_file = /var/log/glusterfs/geo-replication/${mastervol}/${eSlave}${local_id}.gluster.log
+special_sync_mode = partial
+change_detector = changelog
+pid-file = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/monitor.pid
+state-file = /var/lib/glusterd/geo-replication/${mastervol}_${remotehost}_${slavevol}/monitor.status
+
+[__section_order__]
+peersrx . . = 0
+peersrx . %5essh%3a = 2
+peersrx . = 3
+peers master slave = 4
+
+[peersrx . %5Essh%3A]
+remote_gsyncd = /nonexistent/gsyncd
+
+[peersrx .]
+gluster_command_dir = /usr/local/sbin/
+gluster_params = aux-gfid-mount acl
+log_file = /var/log/glusterfs/geo-replication-slaves/${session_owner}:${local_node}${local_id}.${slavevol}.log
+log_file_mbr = /var/log/glusterfs/geo-replication-slaves/mbr/${session_owner}:${local_node}${local_id}.${slavevol}.log
+gluster_log_file = /var/log/glusterfs/geo-replication-slaves/${session_owner}:${local_node}${local_id}.${slavevol}.gluster.log
+
+[peers master slave]
+session_owner = 0732cbd1-3ec5-4920-ab0d-aa5a896d5214
+master.stime_xattr_name = trusted.glusterfs.0732cbd1-3ec5-4920-ab0d-aa5a896d5214.07a9005c-ace4-4f67-b3c0-73938fb236c4.stime
+volume_id = 0732cbd1-3ec5-4920-ab0d-aa5a896d5214
+use_tarssh = true
+
diff --git a/tests/basic/afr/split-brain-favorite-child-policy.t b/tests/000-flaky/basic_afr_split-brain-favorite-child-policy.t
index 0e321c6f095..77d82a4996f 100644
--- a/tests/basic/afr/split-brain-favorite-child-policy.t
+++ b/tests/000-flaky/basic_afr_split-brain-favorite-child-policy.t
@@ -1,8 +1,8 @@
 #!/bin/bash
 
 #Test the split-brain resolution CLI commands.
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
 
 cleanup;
 
@@ -16,6 +16,7 @@ TEST $CLI volume set $V0 cluster.self-heal-daemon off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
 TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
+TEST $CLI volume set $V0 cluster.heal-timeout 5
 TEST $CLI volume start $V0
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 TEST touch $M0/file
@@ -38,7 +39,7 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 TEST $CLI volume heal $V0
 
-#file fill in split-brain
+#file still in split-brain
 cat $M0/file > /dev/null
 EXPECT "1" echo $?
 
@@ -124,7 +125,7 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 TEST $CLI volume heal $V0
 
-#file fill in split-brain
+#file still in split-brain
 cat $M0/file > /dev/null
 EXPECT "1" echo $?
 
@@ -179,7 +180,7 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
 TEST $CLI volume heal $V0
 
-#file fill in split-brain
+#file still in split-brain
 cat $M0/file > /dev/null
 EXPECT "1" echo $?
 
diff --git a/tests/000-flaky/basic_changelog_changelog-snapshot.t b/tests/000-flaky/basic_changelog_changelog-snapshot.t
new file mode 100644
index 00000000000..f6cd0b04d47
--- /dev/null
+++ b/tests/000-flaky/basic_changelog_changelog-snapshot.t
@@ -0,0 +1,60 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../snapshot.rc
+
+cleanup;
+ROLLOVER_TIME=3
+
+TEST verify_lvm_version;
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST setup_lvm 1
+
+TEST $CLI volume create $V0 $H0:$L1
+BRICK_LOG=$(echo "$L1" | tr / - | sed 's/^-//g')
+TEST $CLI volume start $V0
+
+#Enable changelog
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+#Create snapshot
+S1="${V0}-snap1"
+
+mkdir $M0/RENAME
+mkdir $M0/LINK
+mkdir $M0/UNLINK
+mkdir $M0/RMDIR
+mkdir $M0/SYMLINK
+
+for i in {1..400} ; do touch $M0/RENAME/file$i; done
+for i in {1..400} ; do touch $M0/LINK/file$i; done
+for i in {1..400} ; do touch $M0/UNLINK/file$i; done
+for i in {1..400} ; do mkdir $M0/RMDIR/dir$i; done
+for i in {1..400} ; do touch $M0/SYMLINK/file$i; done
+
+#Write I/O in background
+for i in {1..400} ; do touch $M0/file$i 2>/dev/null; done &
+for i in {1..400} ; do mknod $M0/mknod-file$i p 2>/dev/null; done &
+for i in {1..400} ; do mkdir $M0/dir$i 2>/dev/null; done & 2>/dev/null
+for i in {1..400} ; do mv $M0/RENAME/file$i $M0/RENAME/rn-file$i 2>/dev/null; done &
+for i in {1..400} ; do ln $M0/LINK/file$i $M0/LINK/ln-file$i 2>/dev/null; done &
+for i in {1..400} ; do rm -f $M0/UNLINK/file$i 2>/dev/null; done &
+for i in {1..400} ; do rmdir $M0/RMDIR/dir$i 2>/dev/null; done &
+for i in {1..400} ; do ln -s $M0/SYMLINK/file$i $M0/SYMLINK/sym-file$i 2>/dev/null; done &
+
+sleep 1
+TEST $CLI snapshot create $S1 $V0 no-timestamp
+TEST snapshot_exists 0 $S1
+
+TEST grep '"Enabled changelog barrier"' /var/log/glusterfs/bricks/$BRICK_LOG.log
+TEST grep '"Disabled changelog barrier"' /var/log/glusterfs/bricks/$BRICK_LOG.log
+
+TEST glusterfs -s $H0 --volfile-id=/snaps/$S1/$V0 $M1
+
+#Clean up
+TEST $CLI volume stop $V0 force
+cleanup;
diff --git a/tests/basic/distribute/rebal-all-nodes-migrate.t b/tests/000-flaky/basic_distribute_rebal-all-nodes-migrate.t
index 14f0a53b1f8..eb5d3305ac1 100644
--- a/tests/basic/distribute/rebal-all-nodes-migrate.t
+++ b/tests/000-flaky/basic_distribute_rebal-all-nodes-migrate.t
@@ -1,8 +1,8 @@
 #!/bin/bash
 
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-. $(dirname $0)/../../dht.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../cluster.rc
+. $(dirname $0)/../dht.rc
 
 
 # Check if every single rebalance process migrated some files
@@ -10,11 +10,9 @@
 function cluster_rebal_all_nodes_migrated_files {
         val=0
         a=$($CLI_1 volume rebalance $V0 status | grep "completed" | awk '{print $2}');
-#        echo $a
         b=($a)
         for i in "${b[@]}"
         do
-#                echo "$i";
                 if [ "$i" -eq "0" ]; then
                         echo "false";
                         val=1;
@@ -141,3 +139,4 @@ TEST $CLI_1 volume delete $V0
 ##############################################################
 
 cleanup
+#G_TESTDEF_TEST_STATUS_NETBSD7=1501388
diff --git a/tests/000-flaky/basic_ec_ec-quorum-count-partial-failure.t b/tests/000-flaky/basic_ec_ec-quorum-count-partial-failure.t
new file mode 100644
index 00000000000..42808ce0c0e
--- /dev/null
+++ b/tests/000-flaky/basic_ec_ec-quorum-count-partial-failure.t
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+#This test checks that partial failure of fop results in main fop failure only
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume create $V1 $H0:$B0/${V1}{0..5}
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=/$V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+TEST dd if=/dev/urandom of=$M0/a bs=12347 count=1
+TEST dd if=/dev/urandom of=$M0/b bs=12347 count=1
+TEST cp $M0/b $M0/c
+TEST fallocate -p -l 101 $M0/c
+TEST $CLI volume stop $V0
+TEST $CLI volume set $V0 debug.delay-gen posix;
+TEST $CLI volume set $V0 delay-gen.delay-duration 10000000;
+TEST $CLI volume set $V0 delay-gen.enable WRITE;
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 disperse.quorum-count 6
+TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+cksum=$(dd if=$M0/a bs=12345 count=1 | md5sum | awk '{print $1}')
+truncate -s 12345 $M0/a & #While write is waiting for 5 seconds, introduce failure
+fallocate -p -l 101 $M0/b &
+sleep 1
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST wait
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+EXPECT "12345" stat --format=%s $M0/a
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+cksum_after_heal=$(dd if=$M0/a | md5sum | awk '{print $1}')
+TEST [[ $cksum == $cksum_after_heal ]]
+cksum=$(dd if=$M0/c | md5sum | awk '{print $1}')
+cksum_after_heal=$(dd if=$M0/b | md5sum | awk '{print $1}')
+TEST [[ $cksum == $cksum_after_heal ]]
+
+cleanup;
diff --git a/tests/basic/mount-nfs-auth.t b/tests/000-flaky/basic_mount-nfs-auth.t
index b275e985287..3d4a9cff00b 100755..100644
--- a/tests/basic/mount-nfs-auth.t
+++ b/tests/000-flaky/basic_mount-nfs-auth.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../include.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 # Our mount timeout must be as long as the time for a regular configuration
 # change to be acted upon *plus* AUTH_REFRESH_TIMEOUT, not one replacing the
 # other.  Otherwise this process races vs. the one making the change we're
@@ -41,7 +43,7 @@ function build_dirs () {
 }
 
 function export_allow_this_host_ipv6 () {
-        printf "$EXPORT_ALLOW6\n" > /var/lib/glusterd/nfs/exports
+        printf "$EXPORT_ALLOW6\n" > "$GLUSTERD_WORKDIR"/nfs/exports
 }
 
 function export_allow_this_host () {
diff --git a/tests/bugs/core/multiplex-limit-issue-151.t b/tests/000-flaky/bugs_core_multiplex-limit-issue-151.t
index 9511756ecde..5a88f97d726 100644
--- a/tests/bugs/core/multiplex-limit-issue-151.t
+++ b/tests/000-flaky/bugs_core_multiplex-limit-issue-151.t
@@ -1,8 +1,8 @@
 #!/bin/bash
 
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../traps.rc
-. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../traps.rc
+. $(dirname $0)/../volume.rc
 
 function count_up_bricks {
         $CLI --xml volume status all | grep '<status>1' | wc -l
@@ -26,9 +26,6 @@ TEST ! $CLI volume set all cluster.max-bricks-per-process -1
 TEST ! $CLI volume set all cluster.max-bricks-per-process foobar
 TEST $CLI volume set all cluster.max-bricks-per-process 3
 
-push_trapfunc "$CLI volume set all cluster.brick-multiplex off"
-push_trapfunc "cleanup"
-
 TEST $CLI volume create $V0 $H0:$B0/brick{0..5}
 TEST $CLI volume start $V0
 
@@ -50,8 +47,10 @@ EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_brick_pids
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 7 count_up_bricks
 
 TEST $CLI volume remove-brick $V0 $H0:$B0/brick3 start
-TEST $CLI volume remove-brick $V0 $H0:$B0/brick3 commit
+TEST $CLI volume remove-brick $V0 $H0:$B0/brick3 force
 
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_brick_processes
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_brick_pids
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 count_up_bricks
+
+cleanup;
diff --git a/tests/bugs/distribute/bug-1117851.t b/tests/000-flaky/bugs_distribute_bug-1117851.t
index 678103869cf..5980bf2fd4b 100755..100644
--- a/tests/bugs/distribute/bug-1117851.t
+++ b/tests/000-flaky/bugs_distribute_bug-1117851.t
@@ -1,7 +1,9 @@
 #!/bin/bash
 
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
+SCRIPT_TIMEOUT=250
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
 
 create_files () {
 	for i in {1..1000}; do
diff --git a/tests/bugs/distribute/bug-1122443.t b/tests/000-flaky/bugs_distribute_bug-1122443.t
index 906be7072bd..abd37082b33 100644
--- a/tests/bugs/distribute/bug-1122443.t
+++ b/tests/000-flaky/bugs_distribute_bug-1122443.t
@@ -1,8 +1,8 @@
 #!/bin/bash
 
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../dht.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
 
 make_files() {
     mkdir $1 && \
@@ -42,8 +42,8 @@ TEST glusterfs -s $H0 --volfile-id $V0 $M0
 TEST make_files $M0/subdir
 
 # Get mtime before migration
-BEFORE="$(stat -c %n:%Y $M0/subdir/* | tr '\n' ',')"
-
+BEFORE="$(stat -c %n:%Y $M0/subdir/* | sort | tr '\n' ',')"
+echo $BEFORE
 # Migrate brick
 TEST $CLI volume add-brick $V0 $H0:$B0/${V0}1
 TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}0 start
@@ -51,9 +51,10 @@ EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field
 TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}0 commit
 
 # Get mtime after migration
-EXPECT_WITHIN 5 RECONNECTED bug_1113050_workaround $M0/subdir/*
-AFTER="$(stat -c %n:%Y $M0/subdir/* | tr '\n' ',')"
-
+EXPECT_WITHIN 30 RECONNECTED bug_1113050_workaround $M0/subdir/symlink
+sleep 3
+AFTER="$(stat -c %n:%Y $M0/subdir/* | sort | tr '\n' ',')"
+echo $AFTER
 # Check if mtime is unchanged
 TEST [ "$AFTER" == "$BEFORE" ]
 
diff --git a/tests/bugs/glusterd/bug-857330/common.rc b/tests/000-flaky/bugs_glusterd_bug-857330/common.rc
index d0aa4b1a640..bd122eff18c 100644
--- a/tests/bugs/glusterd/bug-857330/common.rc
+++ b/tests/000-flaky/bugs_glusterd_bug-857330/common.rc
@@ -1,4 +1,4 @@
-. $(dirname $0)/../../../include.rc
+. $(dirname $0)/../../include.rc
 
 UUID_REGEX='[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
 
diff --git a/tests/bugs/glusterd/bug-857330/normal.t b/tests/000-flaky/bugs_glusterd_bug-857330/normal.t
index ad0c8844fae..6c1cf54ec3c 100755
--- a/tests/bugs/glusterd/bug-857330/normal.t
+++ b/tests/000-flaky/bugs_glusterd_bug-857330/normal.t
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 . $(dirname $0)/common.rc
-. $(dirname $0)/../../../volume.rc
+. $(dirname $0)/../../volume.rc
 cleanup;
 
 TEST glusterd
@@ -14,7 +14,7 @@ TEST $CLI volume start $V0;
 
 TEST glusterfs -s $H0 --volfile-id=$V0 $M0;
 
-TEST $PYTHON $(dirname $0)/../../../utils/create-files.py \
+TEST $PYTHON $(dirname $0)/../../utils/create-files.py \
              --multi -b 10 -d 10  -n 10 $M0;
 
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
diff --git a/tests/bugs/glusterd/bug-857330/xml.t b/tests/000-flaky/bugs_glusterd_bug-857330/xml.t
index 8383d2a0711..11785adacdb 100755
--- a/tests/bugs/glusterd/bug-857330/xml.t
+++ b/tests/000-flaky/bugs_glusterd_bug-857330/xml.t
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 . $(dirname $0)/common.rc
-. $(dirname $0)/../../../volume.rc
+. $(dirname $0)/../../volume.rc
 
 cleanup;
 
@@ -15,7 +15,7 @@ TEST $CLI volume start $V0;
 
 TEST glusterfs -s $H0 --volfile-id=$V0 $M0;
 
-TEST $PYTHON $(dirname $0)/../../../utils/create-files.py \
+TEST $PYTHON $(dirname $0)/../../utils/create-files.py \
              --multi -b 10 -d 10  -n 10 $M0;
 
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
diff --git a/tests/000-flaky/bugs_glusterd_quorum-value-check.t b/tests/000-flaky/bugs_glusterd_quorum-value-check.t
new file mode 100644
index 00000000000..a431b8c4fd4
--- /dev/null
+++ b/tests/000-flaky/bugs_glusterd_quorum-value-check.t
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
+function check_quorum_nfs() {
+    local qnfs="$(less /var/lib/glusterd/nfs/nfs-server.vol | grep "quorum-count"| awk '{print $3}')"
+    local qinfo="$($CLI volume info $V0| grep "cluster.quorum-count"| awk '{print $2}')"
+
+    if [ $qnfs = $qinfo ]; then
+        echo "Y"
+    else
+        echo "N"
+    fi
+}
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 nfs.disable off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 cluster.quorum-type fixed
+TEST $CLI volume start $V0
+
+TEST $CLI volume set $V0 cluster.quorum-count 1
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
+TEST $CLI volume set $V0 cluster.quorum-count 2
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
+TEST $CLI volume set $V0 cluster.quorum-count 3
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
+
+cleanup;
diff --git a/tests/bugs/nfs/bug-1116503.t b/tests/000-flaky/bugs_nfs_bug-1116503.t
index c9ed840ec92..fc50021acc7 100644
--- a/tests/bugs/nfs/bug-1116503.t
+++ b/tests/000-flaky/bugs_nfs_bug-1116503.t
@@ -3,10 +3,11 @@
 # Verify that mounting NFS over UDP (MOUNT service only) works.
 #
 
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
 
 cleanup;
 TEST glusterd
diff --git a/tests/features/lock-migration/lkmigration-set-option.t b/tests/000-flaky/features_lock-migration_lkmigration-set-option.t
index 4340438591f..1327ef3579f 100644
--- a/tests/features/lock-migration/lkmigration-set-option.t
+++ b/tests/000-flaky/features_lock-migration_lkmigration-set-option.t
@@ -1,7 +1,7 @@
 #!/bin/bash
 # Test to check
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
 
 #Check lock-migration set option sanity
 cleanup;
diff --git a/tests/afr.rc b/tests/afr.rc
index bdf4075a233..241789903ba 100644
--- a/tests/afr.rc
+++ b/tests/afr.rc
@@ -2,7 +2,7 @@
 
 function create_brick_xattrop_entry {
         local xattrop_dir=$(afr_get_index_path $1)
-        local base_entry=`ls $xattrop_dir`
+        local base_entry=`ls $xattrop_dir|grep xattrop`
         local gfid_str
         local params=`echo "$@" | cut -d' ' -f2-`
         echo $params
@@ -89,3 +89,35 @@ function count_index_entries()
 {
     ls $1/.glusterfs/indices/xattrop | wc -l
 }
+
+function afr_up_status()
+{
+        local v=$1
+        local m=$2
+        local replica_id=$3
+        grep -E "^up = " $m/.meta/graphs/active/${v}-replicate-${replica_id}/private | cut -f2 -d'='
+}
+
+function get_quorum_type()
+{
+        local m="$1"
+        local v="$2"
+        local repl_id="$3"
+        cat $m/.meta/graphs/active/$v-replicate-$repl_id/private|grep quorum-type|awk '{print $3}'
+}
+
+function afr_private_key_value()
+{
+        local v=$1
+        local m=$2
+        local replica_id=$3
+        local key=$4
+#xargs at the end will strip leading spaces
+        grep -E "^${key} = " $m/.meta/graphs/active/${v}-replicate-${replica_id}/private | cut -f2 -d'=' | xargs
+}
+
+function afr_anon_entry_count()
+{
+    local b=$1
+    ls $b/.glusterfs-anonymous-inode* | wc -l
+}
diff --git a/tests/basic/afr/add-brick-self-heal.t b/tests/basic/afr/add-brick-self-heal.t
index a904e22e2a5..c847e22977f 100644
--- a/tests/basic/afr/add-brick-self-heal.t
+++ b/tests/basic/afr/add-brick-self-heal.t
@@ -6,10 +6,16 @@ cleanup;
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+EXPECT 'Created' volinfo_field $V0 'Status';
 TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status';
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
 TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume set $V0 cluster.heal-timeout 5
 
 TEST $CLI volume set $V0 self-heal-daemon off
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
@@ -25,6 +31,7 @@ TEST setfattr -n user.test -v qwerty $M0/file5.txt
 
 # Add brick1
 TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
 
 # New-brick should accuse the old-bricks (Simulating case for data-loss)
 TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/${V0}2/
diff --git a/tests/basic/afr/afr-anon-inode-no-quorum.t b/tests/basic/afr/afr-anon-inode-no-quorum.t
new file mode 100644
index 00000000000..896ba0c9b2c
--- /dev/null
+++ b/tests/basic/afr/afr-anon-inode-no-quorum.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+#Test that anon-inode entry is not cleaned up as long as there exists at least
+#one valid entry
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.readdir-ahead off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST touch $M0/a $M0/b
+
+gfid_a=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/a))
+gfid_b=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/b))
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST mv $M0/a $M0/a-new
+TEST mv $M0/b $M0/b-new
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST ! ls $M0/a
+TEST ! ls $M0/b
+anon_inode_name=$(ls -a $B0/${V0}0 | grep glusterfs-anonymous-inode)
+TEST stat $B0/${V0}0/$anon_inode_name/$gfid_a
+TEST stat $B0/${V0}0/$anon_inode_name/$gfid_b
+#Make sure index heal doesn't happen after enabling heal
+TEST setfattr -x trusted.afr.$V0-client-0 $B0/${V0}1
+TEST rm -f $B0/${V0}1/.glusterfs/indices/xattrop/*
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+TEST $CLI volume heal $V0
+#Allow time for a scan
+sleep 5
+TEST stat $B0/${V0}0/$anon_inode_name/$gfid_a
+TEST stat $B0/${V0}0/$anon_inode_name/$gfid_b
+inum_b=$(STAT_INO $B0/${V0}0/$anon_inode_name/$gfid_b)
+TEST rm -f $M0/a-new
+TEST stat $M0/b-new
+
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/${V0}0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/${V0}1
+EXPECT "$inum_b" STAT_INO $B0/${V0}0/b-new
+
+cleanup
diff --git a/tests/basic/afr/afr-anon-inode.t b/tests/basic/afr/afr-anon-inode.t
new file mode 100644
index 00000000000..f4cf37a2fa0
--- /dev/null
+++ b/tests/basic/afr/afr-anon-inode.t
@@ -0,0 +1,114 @@
+#!/bin/bash
+#Tests that afr-anon-inode test cases work fine as expected
+#These are cases where in entry-heal/name-heal we dont know entry for an inode
+#so these inodes are kept in a special directory
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0..2}
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT "^1$" afr_private_key_value $V0 $M0 0 "use-anonymous-inode"
+TEST $CLI volume set $V0 cluster.use-anonymous-inode no
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^0$" afr_private_key_value $V0 $M0 0 "use-anonymous-inode"
+TEST $CLI volume set $V0 cluster.use-anonymous-inode yes
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "use-anonymous-inode"
+TEST mkdir -p $M0/d1/b $M0/d2/a
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST mv $M0/d2/a $M0/d1
+TEST mv $M0/d1/b $M0/d2
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+anon_inode_name=$(ls -a $B0/${V0}0 | grep glusterfs-anonymous-inode)
+TEST [[ -d $B0/${V0}1/$anon_inode_name ]]
+TEST [[ -d $B0/${V0}2/$anon_inode_name ]]
+anon_gfid=$(gf_get_gfid_xattr $B0/${V0}0/$anon_inode_name)
+EXPECT "$anon_gfid" gf_get_gfid_xattr $B0/${V0}1/$anon_inode_name
+EXPECT "$anon_gfid" gf_get_gfid_xattr $B0/${V0}2/$anon_inode_name
+
+TEST ! ls $M0/$anon_inode_name
+EXPECT "^4$" echo $(ls -a $M0 | wc -l)
+
+#Test purging code path by shd
+TEST $CLI volume heal $V0 disable
+TEST mkdir $M0/l0 $M0/l1 $M0/l2
+TEST touch $M0/del-file $M0/del-file-nolink $M0/l0/file
+TEST ln $M0/del-file $M0/del-file-link
+TEST ln $M0/l0/file $M0/l1/file-link1
+TEST ln $M0/l0/file $M0/l2/file-link2
+TEST mkdir -p $M0/del-recursive-dir/d1
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST rm -f $M0/del-file $M0/del-file-nolink
+TEST rm -rf $M0/del-recursive-dir
+TEST mv $M0/d1/a $M0/d2
+TEST mv $M0/l0/file $M0/l0/renamed-file
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status $V0 0
+
+nolink_gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/del-file-nolink))
+link_gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/del-file))
+dir_gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/del-recursive-dir))
+rename_dir_gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/d1/a))
+rename_file_gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/l0/file))
+TEST ! stat $M0/del-file
+TEST stat $B0/${V0}0/$anon_inode_name/$link_gfid
+TEST ! stat $M0/del-file-nolink
+TEST ! stat $B0/${V0}0/$anon_inode_name/$nolink_gfid
+TEST ! stat $M0/del-recursive-dir
+TEST stat $B0/${V0}0/$anon_inode_name/$dir_gfid
+TEST ! stat $M0/d1/a
+TEST stat $B0/${V0}0/$anon_inode_name/$rename_dir_gfid
+TEST ! stat $M0/l0/file
+TEST stat $B0/${V0}0/$anon_inode_name/$rename_file_gfid
+
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST mv $M0/l1/file-link1 $M0/l1/renamed-file-link1
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status $V0 1
+TEST ! stat $M0/l1/file-link1
+TEST stat $B0/${V0}1/$anon_inode_name/$rename_file_gfid
+
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST mv $M0/l2/file-link2 $M0/l2/renamed-file-link2
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status $V0 2
+TEST ! stat $M0/l2/file-link2
+TEST stat $B0/${V0}2/$anon_inode_name/$rename_file_gfid
+
+#Simulate only anon-inodes present in all bricks
+TEST rm -f $M0/l0/renamed-file $M0/l1/renamed-file-link1 $M0/l2/renamed-file-link2
+
+#Test that shd doesn't cleanup anon-inodes when some bricks are down
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST $CLI volume heal $V0 enable
+$CLI volume heal $V0
+sleep 5 #Allow time for completion of one scan
+TEST stat $B0/${V0}0/$anon_inode_name/$link_gfid
+TEST stat $B0/${V0}0/$anon_inode_name/$rename_dir_gfid
+TEST stat $B0/${V0}0/$anon_inode_name/$dir_gfid
+rename_dir_inum=$(STAT_INO $B0/${V0}0/$anon_inode_name/$rename_dir_gfid)
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status $V0 1
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/${V0}0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/${V0}1
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/${V0}2
+
+#Test that rename indeed happened instead of rmdir/mkdir
+renamed_dir_inum=$(STAT_INO $B0/${V0}0/d2/a)
+EXPECT "$rename_dir_inum" echo $renamed_dir_inum
+cleanup;
diff --git a/tests/basic/afr/afr-no-fsync.t b/tests/basic/afr/afr-no-fsync.t
new file mode 100644
index 00000000000..0966d9b0a11
--- /dev/null
+++ b/tests/basic/afr/afr-no-fsync.t
@@ -0,0 +1,20 @@
+#!/bin/bash
+#Tests that sequential write workload doesn't lead to FSYNCs
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0,1,3}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+TEST $CLI volume profile $V0 start
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST dd if=/dev/zero of=$M0/a bs=1M count=500
+TEST ! "$CLI volume profile $V0 info incremental | grep FSYNC"
+
+cleanup;
diff --git a/tests/basic/afr/afr-read-hash-mode.t b/tests/basic/afr/afr-read-hash-mode.t
new file mode 100644
index 00000000000..eeff10d8ebd
--- /dev/null
+++ b/tests/basic/afr/afr-read-hash-mode.t
@@ -0,0 +1,56 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+function reads_brick_count {
+        $CLI volume profile $V0 info incremental | grep -w READ | wc -l
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/${V0}{0..2}
+
+TEST $CLI volume set $V0 cluster.choose-local off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume start $V0
+
+# Disable all caching
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+TEST dd if=/dev/urandom of=$M0/FILE bs=1M count=8
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+# TEST if the option gives the intended behavior. The way we perform this test
+# is by performing reads from the mount and write to /dev/null. If the
+# read-hash-mode is 3, then for a given file, more than 1 brick should serve the
+# read-fops where as with the default read-hash-mode (i.e. 1), only 1 brick will.
+
+# read-hash-mode=1
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT "1" mount_get_option_value $M0 $V0-replicate-0 read-hash-mode
+TEST $CLI volume profile $V0 start
+TEST dd if=$M0/FILE of=/dev/null bs=1M
+count=`reads_brick_count`
+TEST [ $count -eq 1 ]
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+# read-hash-mode=3
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+TEST $CLI volume set $V0 cluster.read-hash-mode 3
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "3" mount_get_option_value $M0 $V0-replicate-0 read-hash-mode
+TEST $CLI volume profile $V0 info clear
+TEST dd if=$M0/FILE of=/dev/null bs=1M
+count=`reads_brick_count`
+TEST [ $count -eq 2 ]
+
+# Check that the arbiter did not serve any reads
+arbiter_reads=$($CLI volume top $V0 read brick $H0:$B0/${V0}2|grep FILE|awk '{print $1}')
+TEST [ -z $arbiter_reads ]
+
+cleanup;
diff --git a/tests/basic/afr/afr-seek.t b/tests/basic/afr/afr-seek.t
new file mode 100644
index 00000000000..c12ee011660
--- /dev/null
+++ b/tests/basic/afr/afr-seek.t
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+SEEK=$(dirname $0)/seek
+build_tester $(dirname $0)/../seek.c -o ${SEEK}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+TEST mkdir -p $B0/${V0}{0..2}
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0..2}
+
+TEST $CLI volume start $V0
+
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+TEST ${SEEK} create ${M0}/test 0 1 1048576 1
+# Determine underlying filesystem allocation block size
+BSIZE="$(($(${SEEK} scan ${M0}/test hole 0) * 2))"
+
+TEST ${SEEK} create ${M0}/test 0 ${BSIZE} $((${BSIZE} * 4 + 512)) ${BSIZE}
+
+EXPECT "^0$" ${SEEK} scan ${M0}/test data 0
+EXPECT "^$((${BSIZE} / 2))$" ${SEEK} scan ${M0}/test data $((${BSIZE} / 2))
+EXPECT "^$((${BSIZE} - 1))$" ${SEEK} scan ${M0}/test data $((${BSIZE} - 1))
+EXPECT "^$((${BSIZE} * 4))$" ${SEEK} scan ${M0}/test data ${BSIZE}
+EXPECT "^$((${BSIZE} * 4))$" ${SEEK} scan ${M0}/test data $((${BSIZE} * 4))
+EXPECT "^$((${BSIZE} * 5))$" ${SEEK} scan ${M0}/test data $((${BSIZE} * 5))
+EXPECT "^$((${BSIZE} * 5 + 511))$" ${SEEK} scan ${M0}/test data $((${BSIZE} * 5 + 511))
+EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test data $((${BSIZE} * 5 + 512))
+EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test data $((${BSIZE} * 6))
+
+EXPECT "^${BSIZE}$" ${SEEK} scan ${M0}/test hole 0
+EXPECT "^${BSIZE}$" ${SEEK} scan ${M0}/test hole $((${BSIZE} / 2))
+EXPECT "^${BSIZE}$" ${SEEK} scan ${M0}/test hole $((${BSIZE} - 1))
+EXPECT "^${BSIZE}$" ${SEEK} scan ${M0}/test hole ${BSIZE}
+EXPECT "^$((${BSIZE} * 5 + 512))$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 4))
+EXPECT "^$((${BSIZE} * 5 + 512))$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 5))
+EXPECT "^$((${BSIZE} * 5 + 512))$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 5 + 511))
+EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 5 + 512))
+EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 6))
+
+rm -f ${SEEK}
+cleanup
+
+# Centos6 regression slaves seem to not support SEEK_DATA/SEEK_HOLE
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/basic/afr/afr-up.t b/tests/basic/afr/afr-up.t
new file mode 100644
index 00000000000..428aac875e0
--- /dev/null
+++ b/tests/basic/afr/afr-up.t
@@ -0,0 +1,28 @@
+#!/bin/bash
+#Tests that afr up/down works as expected
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,3,4,5,6}
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT "1" afr_up_status $V0 $M0 0
+EXPECT "1" afr_up_status $V0 $M0 1
+
+#kill two bricks in first replica and check that afr_up_status is 0 for it
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" afr_up_status $V0 $M0 0
+EXPECT "1" afr_up_status $V0 $M0 1
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_up_status $V0 $M0 0
+EXPECT "1" afr_up_status $V0 $M0 1
+cleanup;
diff --git a/tests/basic/afr/arbiter-add-brick.t b/tests/basic/afr/arbiter-add-brick.t
index fe919de0ab4..77b93d9a210 100644
--- a/tests/basic/afr/arbiter-add-brick.t
+++ b/tests/basic/afr/arbiter-add-brick.t
@@ -12,6 +12,8 @@ TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume start $V0
 TEST $CLI volume set $V0 self-heal-daemon off
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
 TEST mkdir  $M0/dir1
 TEST dd if=/dev/urandom of=$M0/file1 bs=1024 count=1
 
@@ -24,6 +26,7 @@ TEST dd if=/dev/urandom of=$M0/file1 bs=1024 count=1024
 #convert replica 2 to arbiter volume
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
 
 #syntax check for add-brick.
 TEST ! $CLI volume add-brick $V0 replica 2 arbiter 1 $H0:$B0/${V0}2
@@ -31,6 +34,19 @@ TEST ! $CLI volume add-brick $V0 replica 3 arbiter 2 $H0:$B0/${V0}2
 
 TEST $CLI volume add-brick $V0 replica 3 arbiter 1 $H0:$B0/${V0}2
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+#Trigger name heals from client. If we just rely on index heal, the first index
+#crawl on B0 fails for /, dir2 and /file either due to lock collision or files
+#not being present on the other 2 bricks yet. It is getting healed only in the
+#next crawl after priv->shd.timeout (600 seconds) or by manually launching
+#index heal again.
+TEST $CLI volume set $V0 data-self-heal off
+TEST $CLI volume set $V0 metadata-self-heal off
+TEST $CLI volume set $V0 entry-self-heal off
+TEST stat $M0/dir1
+TEST stat $M0/dir2
+TEST stat $M0/file1
 
 #Heal files
 TEST $CLI volume set $V0 self-heal-daemon on
diff --git a/tests/basic/afr/arbiter-cli.t b/tests/basic/afr/arbiter-cli.t
index 2806b5a376b..ad79de79d02 100644
--- a/tests/basic/afr/arbiter-cli.t
+++ b/tests/basic/afr/arbiter-cli.t
@@ -16,10 +16,15 @@ TEST ! $CLI volume create $V0 arbiter 3 $H0:$B0/${V0}{0,1,2}
 # replica count given after arbiter count.
 TEST ! $CLI volume create $V0 arbiter 1 replica 3 $H0:$B0/${V0}{0,1,2}
 
-#Incorrect values for replica and arbiter count.
-TEST ! $CLI volume create $V0  replica 2 arbiter 1 $H0:$B0/${V0}{0,1,2}
+# Incorrect values for replica and arbiter count.
 TEST ! $CLI volume create $V0  replica 3 arbiter 2 $H0:$B0/${V0}{0,1,2}
 
-# Only permissible value is replica=3 and arbiter=1.
-TEST  $CLI volume create $V0  replica 3 arbiter 1 $H0:$B0/${V0}{0,1,2}
+# Correct setup
+# Only documented value is replica=2 and arbiter=1.
+TEST $CLI volume create $V0  replica 2 arbiter 1 $H0:$B0/${V0}{0,1,2}
+
+# Earlier documents mentioned 'replica 3 arbiter 1' as the valid option
+# Preserve backward compatibility till Oct, 2019.
+TEST  $CLI volume create ${V0}-old  replica 3 arbiter 1 $H0:$B0/${V0}-old{0,1,2}
+
 cleanup
diff --git a/tests/basic/afr/arbiter-mount.t b/tests/basic/afr/arbiter-mount.t
index da99096f81f..404d334d2f9 100644
--- a/tests/basic/afr/arbiter-mount.t
+++ b/tests/basic/afr/arbiter-mount.t
@@ -4,6 +4,9 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../afr.rc
 . $(dirname $0)/../../nfs.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 #Check that mounting fails when only arbiter brick is up.
diff --git a/tests/basic/afr/client-side-heal.t b/tests/basic/afr/client-side-heal.t
index eba7dc2b3c4..1e9336184b5 100755
--- a/tests/basic/afr/client-side-heal.t
+++ b/tests/basic/afr/client-side-heal.t
@@ -17,6 +17,7 @@ TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
 echo "some data" > $M0/datafile
 EXPECT 0 echo $?
 TEST touch $M0/mdatafile
+TEST touch $M0/mdatafile-backend-direct-modify
 TEST mkdir $M0/dir
 
 #Kill a brick and perform I/O to have pending heals.
@@ -29,6 +30,7 @@ EXPECT 0 echo $?
 
 #pending metadata heal
 TEST chmod +x $M0/mdatafile
+TEST chmod +x $B0/${V0}0/mdatafile-backend-direct-modify
 
 #pending entry heal. Also causes pending metadata/data heals on file{1..5}
 TEST touch $M0/dir/file{1..5}
@@ -40,9 +42,12 @@ TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
 
 #Medatada heal via explicit lookup must not happen
-TEST ls $M0/mdatafile
+TEST getfattr -d -m. -e hex $M0/mdatafile
+TEST ls $M0/mdatafile-backend-direct-modify
 
-#Inode refresh must not trigger data and entry heals.
+TEST [[ "$(stat -c %A $B0/${V0}0/mdatafile-backend-direct-modify)" != "$(stat -c %A $B0/${V0}1/mdatafile-backend-direct-modify)" ]]
+
+#Inode refresh must not trigger data metadata and entry heals.
 #To trigger inode refresh for sure, the volume is unmounted and mounted each time.
 #Check that data heal does not happen.
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
@@ -52,7 +57,6 @@ TEST cat $M0/datafile
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
 TEST ls $M0/dir
-
 #No heal must have happened
 EXPECT 8 get_pending_heal_count $V0
 
@@ -61,21 +65,25 @@ TEST $CLI volume set $V0 cluster.data-self-heal on
 TEST $CLI volume set $V0 cluster.metadata-self-heal on
 TEST $CLI volume set $V0 cluster.entry-self-heal on
 
-#Metadata heal is triggered by lookup without need for inode refresh.
-TEST ls $M0/mdatafile
-EXPECT 7 get_pending_heal_count $V0
-
-#Inode refresh must trigger data and entry heals.
+#Inode refresh must trigger data metadata and entry heals.
 #To trigger inode refresh for sure, the volume is unmounted and mounted each time.
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST ls $M0/mdatafile-backend-direct-modify
+
+TEST [[ "$(stat -c %A $B0/${V0}0/mdatafile-backend-direct-modify)" == "$(stat -c %A $B0/${V0}1/mdatafile-backend-direct-modify)" ]]
+
+
+TEST getfattr -d -m. -e hex $M0/mdatafile
+EXPECT_WITHIN $HEAL_TIMEOUT 7 get_pending_heal_count $V0
+
 TEST cat $M0/datafile
 EXPECT_WITHIN $HEAL_TIMEOUT 6 get_pending_heal_count $V0
 
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
 TEST ls $M0/dir
-EXPECT 5 get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT 5 get_pending_heal_count $V0
 
 TEST cat  $M0/dir/file1
 TEST cat  $M0/dir/file2
@@ -83,5 +91,5 @@ TEST cat  $M0/dir/file3
 TEST cat  $M0/dir/file4
 TEST cat  $M0/dir/file5
 
-EXPECT 0 get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT 0 get_pending_heal_count $V0
 cleanup;
diff --git a/tests/basic/afr/compounded-write-txns.t b/tests/basic/afr/compounded-write-txns.t
deleted file mode 100644
index 7cecd87b01b..00000000000
--- a/tests/basic/afr/compounded-write-txns.t
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
-TEST $CLI volume set $V0 write-behind off
-TEST $CLI volume set $V0 client-io-threads off
-TEST $CLI volume start $V0
-TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
-
-# Create and generate data into a src file
-
-TEST `printf %1024s |tr " " "1" > /tmp/source`
-TEST `printf %1024s |tr " " "2" >> /tmp/source`
-
-TEST dd if=/tmp/source of=$M0/file bs=1024 count=2 2>/dev/null
-md5sum_file=$(md5sum $M0/file | awk '{print $1}')
-
-TEST $CLI volume set $V0 cluster.use-compound-fops on
-
-TEST dd if=$M0/file of=$M0/file-copy bs=1024 count=2 2>/dev/null
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
-
-EXPECT "$md5sum_file" echo `md5sum $M0/file-copy | awk '{print $1}'`
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0
-
-TEST rm -f /tmp/source
-cleanup
diff --git a/tests/basic/afr/durability-off.t b/tests/basic/afr/durability-off.t
index 155ffa09ef0..6e0f18b88f8 100644
--- a/tests/basic/afr/durability-off.t
+++ b/tests/basic/afr/durability-off.t
@@ -26,6 +26,8 @@ TEST $CLI volume heal $V0
 EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
 EXPECT "^0$" echo $($CLI volume profile $V0 info | grep -w FSYNC | wc -l)
 
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
 #Test that fsyncs happen when durability is on
 TEST $CLI volume set $V0 cluster.ensure-durability on
 TEST $CLI volume set $V0 performance.strict-write-ordering on
diff --git a/tests/basic/afr/entry-self-heal-anon-dir-off.t b/tests/basic/afr/entry-self-heal-anon-dir-off.t
new file mode 100644
index 00000000000..7bb6ee14193
--- /dev/null
+++ b/tests/basic/afr/entry-self-heal-anon-dir-off.t
@@ -0,0 +1,459 @@
+#!/bin/bash
+
+#This file checks if missing entry self-heal and entry self-heal are working
+#as expected.
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+function get_file_type {
+        stat -c "%a:%F:%g:%t:%T:%u" $1
+}
+
+function diff_dirs {
+        diff <(ls $1 | sort) <(ls $2 | sort)
+}
+
+function heal_status {
+        local f1_path="${1}/${3}"
+        local f2_path="${2}/${3}"
+        local insync=""
+        diff_dirs $f1_path $f2_path
+        if [ $? -eq 0 ];
+        then
+                insync="Y"
+        else
+                insync="N"
+        fi
+        local xattr11=$(get_hex_xattr trusted.afr.$V0-client-0 $f1_path)
+        local xattr12=$(get_hex_xattr trusted.afr.$V0-client-1 $f1_path)
+        local xattr21=$(get_hex_xattr trusted.afr.$V0-client-0 $f2_path)
+        local xattr22=$(get_hex_xattr trusted.afr.$V0-client-1 $f2_path)
+        local dirty1=$(get_hex_xattr trusted.afr.dirty $f1_path)
+        local dirty2=$(get_hex_xattr trusted.afr.dirty $f2_path)
+        if [ -z $xattr11 ]; then xattr11="000000000000000000000000"; fi
+        if [ -z $xattr12 ]; then xattr12="000000000000000000000000"; fi
+        if [ -z $xattr21 ]; then xattr21="000000000000000000000000"; fi
+        if [ -z $xattr22 ]; then xattr22="000000000000000000000000"; fi
+        if [ -z $dirty1 ]; then dirty1="000000000000000000000000"; fi
+        if [ -z $dirty2 ]; then dirty2="000000000000000000000000"; fi
+        echo ${insync}${xattr11}${xattr12}${xattr21}${xattr22}${dirty1}${dirty2}
+}
+
+function is_heal_done {
+        local zero_xattr="000000000000000000000000"
+        if [ "$(heal_status $@)" == "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" ];
+        then
+                echo "Y"
+        else
+                echo "N"
+        fi
+}
+
+function print_pending_heals {
+        local result=":"
+        for i in "$@";
+        do
+                if [ "N" == $(is_heal_done $B0/${V0}0 $B0/${V0}1 $i) ];
+                then
+                        result="$result:$i"
+                fi
+        done
+#To prevent any match for EXPECT_WITHIN, print a char non-existent in file-names
+        if [ $result == ":" ]; then result="~"; fi
+        echo $result
+}
+
+zero_xattr="000000000000000000000000"
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 cluster.use-anonymous-inode off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.readdir-ahead off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --use-readdirp=no $M0
+cd $M0
+#_me_ is dir on which missing entry self-heal happens, _heal is where dir self-heal happens
+#spb is split-brain, fool is all fool
+
+#source_self_accusing means there exists source and a sink which self-accuses.
+#This simulates failures where fops failed on the bricks without it going down.
+#Something like EACCESS/EDQUOT etc
+
+TEST mkdir spb_heal spb spb_me_heal spb_me fool_heal fool_me v1_fool_heal v1_fool_me source_creations_heal source_deletions_heal source_creations_me source_deletions_me v1_dirty_me v1_dirty_heal source_self_accusing
+TEST mkfifo source_deletions_heal/fifo
+TEST mknod  source_deletions_heal/block b 4 5
+TEST mknod  source_deletions_heal/char c 1 5
+TEST touch  source_deletions_heal/file
+TEST ln -s  source_deletions_heal/file source_deletions_heal/slink
+TEST mkdir  source_deletions_heal/dir1
+TEST mkdir  source_deletions_heal/dir1/dir2
+
+TEST mkfifo source_deletions_me/fifo
+TEST mknod  source_deletions_me/block b 4 5
+TEST mknod  source_deletions_me/char c 1 5
+TEST touch  source_deletions_me/file
+TEST ln -s  source_deletions_me/file source_deletions_me/slink
+TEST mkdir  source_deletions_me/dir1
+TEST mkdir  source_deletions_me/dir1/dir2
+
+TEST mkfifo source_self_accusing/fifo
+TEST mknod  source_self_accusing/block b 4 5
+TEST mknod  source_self_accusing/char c 1 5
+TEST touch  source_self_accusing/file
+TEST ln -s  source_self_accusing/file source_self_accusing/slink
+TEST mkdir  source_self_accusing/dir1
+TEST mkdir  source_self_accusing/dir1/dir2
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+
+TEST touch spb_heal/0 spb/0 spb_me_heal/0 spb_me/0 fool_heal/0 fool_me/0 v1_fool_heal/0 v1_fool_me/0 v1_dirty_heal/0 v1_dirty_me/0
+TEST rm -rf source_deletions_heal/fifo source_deletions_heal/block source_deletions_heal/char source_deletions_heal/file source_deletions_heal/slink source_deletions_heal/dir1
+TEST rm -rf source_deletions_me/fifo source_deletions_me/block source_deletions_me/char source_deletions_me/file source_deletions_me/slink source_deletions_me/dir1
+TEST rm -rf source_self_accusing/fifo source_self_accusing/block source_self_accusing/char source_self_accusing/file source_self_accusing/slink source_self_accusing/dir1
+
+#Test that the files are deleted
+TEST ! stat $B0/${V0}1/source_deletions_heal/fifo
+TEST ! stat $B0/${V0}1/source_deletions_heal/block
+TEST ! stat $B0/${V0}1/source_deletions_heal/char
+TEST ! stat $B0/${V0}1/source_deletions_heal/file
+TEST ! stat $B0/${V0}1/source_deletions_heal/slink
+TEST ! stat $B0/${V0}1/source_deletions_heal/dir1
+TEST ! stat $B0/${V0}1/source_deletions_me/fifo
+TEST ! stat $B0/${V0}1/source_deletions_me/block
+TEST ! stat $B0/${V0}1/source_deletions_me/char
+TEST ! stat $B0/${V0}1/source_deletions_me/file
+TEST ! stat $B0/${V0}1/source_deletions_me/slink
+TEST ! stat $B0/${V0}1/source_deletions_me/dir1
+TEST ! stat $B0/${V0}1/source_self_accusing/fifo
+TEST ! stat $B0/${V0}1/source_self_accusing/block
+TEST ! stat $B0/${V0}1/source_self_accusing/char
+TEST ! stat $B0/${V0}1/source_self_accusing/file
+TEST ! stat $B0/${V0}1/source_self_accusing/slink
+TEST ! stat $B0/${V0}1/source_self_accusing/dir1
+
+
+TEST mkfifo source_creations_heal/fifo
+TEST mknod  source_creations_heal/block b 4 5
+TEST mknod  source_creations_heal/char c 1 5
+TEST touch  source_creations_heal/file
+TEST ln -s  source_creations_heal/file source_creations_heal/slink
+TEST mkdir  source_creations_heal/dir1
+TEST mkdir  source_creations_heal/dir1/dir2
+
+TEST mkfifo source_creations_me/fifo
+TEST mknod  source_creations_me/block b 4 5
+TEST mknod  source_creations_me/char c 1 5
+TEST touch  source_creations_me/file
+TEST ln -s  source_creations_me/file source_creations_me/slink
+TEST mkdir  source_creations_me/dir1
+TEST mkdir  source_creations_me/dir1/dir2
+
+$CLI volume stop $V0
+
+#simulate fool fool scenario for fool_* dirs
+setfattr -x trusted.afr.$V0-client-0 $B0/${V0}1/{fool_heal,fool_me}
+setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}1/{fool_heal,fool_me}
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/${V0}1/{v1_fool_heal,v1_fool_me}
+
+#Simulate v1-dirty(self-accusing but no pending ops on others) scenario for v1-dirty
+setfattr -x trusted.afr.$V0-client-0 $B0/${V0}1/v1_dirty_{heal,me}
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/${V0}1/v1_dirty_{heal,me}
+
+$CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+TEST touch spb_heal/1 spb/0 spb_me_heal/1 spb_me/0 fool_heal/1 fool_me/1 v1_fool_heal/1 v1_fool_me/1
+
+$CLI volume stop $V0
+
+#simulate fool fool scenario for fool_* dirs
+setfattr -x trusted.afr.$V0-client-1 $B0/${V0}0/{fool_heal,fool_me}
+setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}1/{fool_heal,fool_me}
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/${V0}1/{v1_fool_heal,v1_fool_me}
+
+#simulate self-accusing for source_self_accusing
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000006 $B0/${V0}0/source_self_accusing
+
+$CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+# Check if conservative merges happened correctly on _me_ dirs
+TEST stat spb_me_heal/1
+TEST stat $B0/${V0}0/spb_me_heal/1
+TEST stat $B0/${V0}1/spb_me_heal/1
+
+TEST stat spb_me_heal/0
+TEST stat $B0/${V0}0/spb_me_heal/0
+TEST stat $B0/${V0}1/spb_me_heal/0
+
+TEST stat fool_me/1
+TEST stat $B0/${V0}0/fool_me/1
+TEST stat $B0/${V0}1/fool_me/1
+
+TEST stat fool_me/0
+TEST stat $B0/${V0}0/fool_me/0
+TEST stat $B0/${V0}1/fool_me/0
+
+TEST stat v1_fool_me/0
+TEST stat $B0/${V0}0/v1_fool_me/0
+TEST stat $B0/${V0}1/v1_fool_me/0
+
+TEST stat v1_fool_me/1
+TEST stat $B0/${V0}0/v1_fool_me/1
+TEST stat $B0/${V0}1/v1_fool_me/1
+
+TEST stat v1_dirty_me/0
+TEST stat $B0/${V0}0/v1_dirty_me/0
+TEST stat $B0/${V0}1/v1_dirty_me/0
+
+#Check if files that have gfid-mismatches in _me_ are giving EIO
+TEST ! stat spb_me/0
+
+#Check if stale files are deleted on access
+TEST ! stat source_deletions_me/fifo
+TEST ! stat $B0/${V0}0/source_deletions_me/fifo
+TEST ! stat $B0/${V0}1/source_deletions_me/fifo
+TEST ! stat source_deletions_me/block
+TEST ! stat $B0/${V0}0/source_deletions_me/block
+TEST ! stat $B0/${V0}1/source_deletions_me/block
+TEST ! stat source_deletions_me/char
+TEST ! stat $B0/${V0}0/source_deletions_me/char
+TEST ! stat $B0/${V0}1/source_deletions_me/char
+TEST ! stat source_deletions_me/file
+TEST ! stat $B0/${V0}0/source_deletions_me/file
+TEST ! stat $B0/${V0}1/source_deletions_me/file
+TEST ! stat source_deletions_me/file
+TEST ! stat $B0/${V0}0/source_deletions_me/file
+TEST ! stat $B0/${V0}1/source_deletions_me/file
+TEST ! stat source_deletions_me/dir1/dir2
+TEST ! stat $B0/${V0}0/source_deletions_me/dir1/dir2
+TEST ! stat $B0/${V0}1/source_deletions_me/dir1/dir2
+TEST ! stat source_deletions_me/dir1
+TEST ! stat $B0/${V0}0/source_deletions_me/dir1
+TEST ! stat $B0/${V0}1/source_deletions_me/dir1
+
+#Test if the files created as part of access are healed correctly
+r=$(get_file_type source_creations_me/fifo)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/fifo
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/fifo
+TEST [ -p source_creations_me/fifo ]
+
+r=$(get_file_type source_creations_me/block)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/block
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/block
+EXPECT "^4 5$" stat -c "%t %T" $B0/${V0}1/source_creations_me/block
+EXPECT "^4 5$" stat -c "%t %T" $B0/${V0}0/source_creations_me/block
+TEST [ -b source_creations_me/block ]
+
+r=$(get_file_type source_creations_me/char)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/char
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/char
+EXPECT "^1 5$" stat -c "%t %T" $B0/${V0}1/source_creations_me/char
+EXPECT "^1 5$" stat -c "%t %T" $B0/${V0}0/source_creations_me/char
+TEST [ -c source_creations_me/char ]
+
+r=$(get_file_type source_creations_me/file)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/file
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/file
+TEST [ -f source_creations_me/file ]
+
+r=$(get_file_type source_creations_me/slink)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/slink
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/slink
+TEST [ -h source_creations_me/slink ]
+
+r=$(get_file_type source_creations_me/dir1/dir2)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/dir1/dir2
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/dir1/dir2
+TEST [ -d source_creations_me/dir1/dir2 ]
+
+r=$(get_file_type source_creations_me/dir1)
+EXPECT "$r" get_file_type $B0/${V0}0/source_creations_me/dir1
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_me/dir1
+TEST [ -d source_creations_me/dir1 ]
+
+#Trigger heal and check _heal dirs are healed properly
+#Trigger change in event generation number. That way inodes would get refreshed during lookup
+TEST kill_brick $V0 $H0 $B0/${V0}1
+$CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+TEST stat spb_heal
+TEST stat spb_me_heal
+TEST stat fool_heal
+TEST stat fool_me
+TEST stat v1_fool_heal
+TEST stat v1_fool_me
+TEST stat source_deletions_heal
+TEST stat source_deletions_me
+TEST stat source_self_accusing
+TEST stat source_creations_heal
+TEST stat source_creations_me
+TEST stat v1_dirty_heal
+TEST stat v1_dirty_me
+TEST $CLI volume stop $V0
+TEST rm -rf $B0/${V0}{0,1}/.glusterfs/indices/xattrop/*
+
+$CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+#Create base entry in indices/xattrop
+echo "Data" > $M0/FILE
+rm -f $M0/FILE
+EXPECT "1" count_index_entries $B0/${V0}0
+EXPECT "1" count_index_entries $B0/${V0}1
+
+TEST $CLI volume stop $V0;
+
+#Create entries for fool_heal and fool_me to ensure they are fully healed and dirty xattrs erased, before triggering index heal
+create_brick_xattrop_entry $B0/${V0}0 fool_heal fool_me source_creations_heal/dir1
+
+$CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+$CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+
+TEST $CLI volume heal $V0;
+EXPECT_WITHIN $HEAL_TIMEOUT "~" print_pending_heals spb_heal spb_me_heal fool_heal fool_me v1_fool_heal v1_fool_me source_deletions_heal source_deletions_me source_creations_heal source_creations_me v1_dirty_heal v1_dirty_me source_self_accusing
+
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 spb_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 spb_me_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 fool_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 fool_me
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 v1_fool_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 v1_fool_me
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 source_deletions_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 source_deletions_me
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 source_self_accusing
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 source_creations_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 source_creations_me
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 v1_dirty_heal
+EXPECT "Y${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}${zero_xattr}" heal_status $B0/${V0}0 $B0/${V0}1 v1_dirty_me
+
+#Don't access the files/dirs from mount point as that may cause self-heals
+# Check if conservative merges happened correctly on heal dirs
+TEST stat $B0/${V0}0/spb_heal/1
+TEST stat $B0/${V0}1/spb_heal/1
+
+TEST stat $B0/${V0}0/spb_heal/0
+TEST stat $B0/${V0}1/spb_heal/0
+
+TEST stat $B0/${V0}0/fool_heal/1
+TEST stat $B0/${V0}1/fool_heal/1
+
+TEST stat $B0/${V0}0/fool_heal/0
+TEST stat $B0/${V0}1/fool_heal/0
+
+TEST stat $B0/${V0}0/v1_fool_heal/0
+TEST stat $B0/${V0}1/v1_fool_heal/0
+
+TEST stat $B0/${V0}0/v1_fool_heal/1
+TEST stat $B0/${V0}1/v1_fool_heal/1
+
+TEST stat $B0/${V0}0/v1_dirty_heal/0
+TEST stat $B0/${V0}1/v1_dirty_heal/0
+
+#Check if files that have gfid-mismatches in spb are giving EIO
+TEST ! stat spb/0
+
+#Check if stale files are deleted on access
+TEST ! stat $B0/${V0}0/source_deletions_heal/fifo
+TEST ! stat $B0/${V0}1/source_deletions_heal/fifo
+TEST ! stat $B0/${V0}0/source_deletions_heal/block
+TEST ! stat $B0/${V0}1/source_deletions_heal/block
+TEST ! stat $B0/${V0}0/source_deletions_heal/char
+TEST ! stat $B0/${V0}1/source_deletions_heal/char
+TEST ! stat $B0/${V0}0/source_deletions_heal/file
+TEST ! stat $B0/${V0}1/source_deletions_heal/file
+TEST ! stat $B0/${V0}0/source_deletions_heal/file
+TEST ! stat $B0/${V0}1/source_deletions_heal/file
+TEST ! stat $B0/${V0}0/source_deletions_heal/dir1/dir2
+TEST ! stat $B0/${V0}1/source_deletions_heal/dir1/dir2
+TEST ! stat $B0/${V0}0/source_deletions_heal/dir1
+TEST ! stat $B0/${V0}1/source_deletions_heal/dir1
+
+#Check if stale files are deleted on access
+TEST ! stat $B0/${V0}0/source_self_accusing/fifo
+TEST ! stat $B0/${V0}1/source_self_accusing/fifo
+TEST ! stat $B0/${V0}0/source_self_accusing/block
+TEST ! stat $B0/${V0}1/source_self_accusing/block
+TEST ! stat $B0/${V0}0/source_self_accusing/char
+TEST ! stat $B0/${V0}1/source_self_accusing/char
+TEST ! stat $B0/${V0}0/source_self_accusing/file
+TEST ! stat $B0/${V0}1/source_self_accusing/file
+TEST ! stat $B0/${V0}0/source_self_accusing/file
+TEST ! stat $B0/${V0}1/source_self_accusing/file
+TEST ! stat $B0/${V0}0/source_self_accusing/dir1/dir2
+TEST ! stat $B0/${V0}1/source_self_accusing/dir1/dir2
+TEST ! stat $B0/${V0}0/source_self_accusing/dir1
+TEST ! stat $B0/${V0}1/source_self_accusing/dir1
+
+#Test if the files created as part of full self-heal correctly
+r=$(get_file_type $B0/${V0}0/source_creations_heal/fifo)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/fifo
+TEST [ -p $B0/${V0}0/source_creations_heal/fifo ]
+EXPECT "^4 5$" stat -c "%t %T" $B0/${V0}1/source_creations_heal/block
+EXPECT "^4 5$" stat -c "%t %T" $B0/${V0}0/source_creations_heal/block
+
+r=$(get_file_type $B0/${V0}0/source_creations_heal/block)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/block
+
+r=$(get_file_type $B0/${V0}0/source_creations_heal/char)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/char
+EXPECT "^1 5$" stat -c "%t %T" $B0/${V0}1/source_creations_heal/char
+EXPECT "^1 5$" stat -c "%t %T" $B0/${V0}0/source_creations_heal/char
+
+r=$(get_file_type $B0/${V0}0/source_creations_heal/file)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/file
+TEST [ -f $B0/${V0}0/source_creations_heal/file ]
+
+r=$(get_file_type source_creations_heal/file $B0/${V0}0/slink)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/file slink
+TEST [ -h $B0/${V0}0/source_creations_heal/slink ]
+
+r=$(get_file_type $B0/${V0}0/source_creations_heal/dir1/dir2)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/dir1/dir2
+TEST [ -d $B0/${V0}0/source_creations_heal/dir1/dir2 ]
+
+r=$(get_file_type $B0/${V0}0/source_creations_heal/dir1)
+EXPECT "$r" get_file_type $B0/${V0}1/source_creations_heal/dir1
+TEST [ -d $B0/${V0}0/source_creations_heal/dir1 ]
+
+cd -
+
+#Anonymous directory shouldn't be created
+TEST mkdir $M0/rename-dir
+before_rename=$(STAT_INO $B0/${V0}1/rename-dir)
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST mv $M0/rename-dir $M0/new-name
+TEST $CLI volume start $V0 force
+#'spb' is in split-brain so pending-heal-count will be 2
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+after_rename=$(STAT_INO $B0/${V0}1/new-name)
+EXPECT "0" echo $(ls -a $B0/${V0}0/ | grep anonymous-inode | wc -l)
+EXPECT "0" echo $(ls -a $B0/${V0}1/ | grep anonymous-inode | wc -l)
+EXPECT_NOT "$before_rename" echo $after_rename
+cleanup
diff --git a/tests/basic/afr/entry-self-heal.t b/tests/basic/afr/entry-self-heal.t
index 3c900fdcf9a..0c1da7d211e 100644
--- a/tests/basic/afr/entry-self-heal.t
+++ b/tests/basic/afr/entry-self-heal.t
@@ -79,6 +79,9 @@ TEST $CLI volume set $V0 performance.open-behind off
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 performance.io-cache off
 TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume start $V0
 
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --use-readdirp=no $M0
diff --git a/tests/basic/afr/gfid-mismatch-resolution-with-fav-child-policy.t b/tests/basic/afr/gfid-mismatch-resolution-with-fav-child-policy.t
index 2f14f838e49..35e295dc170 100644
--- a/tests/basic/afr/gfid-mismatch-resolution-with-fav-child-policy.t
+++ b/tests/basic/afr/gfid-mismatch-resolution-with-fav-child-policy.t
@@ -10,6 +10,7 @@ TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
 TEST $CLI volume start $V0
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST $CLI volume set $V0 cluster.heal-timeout 5
 TEST $CLI volume set $V0 self-heal-daemon off
 TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
@@ -167,8 +168,8 @@ TEST [ "$gfid_1" != "$gfid_2" ]
 #We know that second brick has the bigger size file
 BIGGER_FILE_MD5=$(md5sum $B0/${V0}1/f3 | cut -d\  -f1)
 
-TEST ls $M0/f3
-TEST cat $M0/f3
+TEST ls $M0 #Trigger entry heal via readdir inode refresh
+TEST cat $M0/f3 #Trigger data heal via readv inode refresh
 EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
 
 #gfid split-brain should be resolved
@@ -214,8 +215,8 @@ TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 2
 
-TEST ls $M0/f4
-TEST cat $M0/f4
+TEST ls $M0 #Trigger entry heal via readdir inode refresh
+TEST cat $M0/f4  #Trigger data heal via readv inode refresh
 EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
 
 #gfid split-brain should be resolved
diff --git a/tests/basic/afr/gfid-self-heal.t b/tests/basic/afr/gfid-self-heal.t
index b54edbcae85..5a530681186 100644
--- a/tests/basic/afr/gfid-self-heal.t
+++ b/tests/basic/afr/gfid-self-heal.t
@@ -50,6 +50,10 @@ TEST kill_brick $V0 $H0 $B0/${V0}0
 TEST touch $M0/a
 gfid_1=$(gf_get_gfid_xattr $B0/${V0}1/a)
 TEST touch $B0/${V0}0/a
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 1
 $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
 TEST stat $M0/a
@@ -62,6 +66,10 @@ TEST kill_brick $V0 $H0 $B0/${V0}0
 TEST touch $M0/b
 TEST mkdir $B0/${V0}0/b
 TEST setfattr -x trusted.afr.$V0-client-0 $B0/${V0}1
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 1
 $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
 TEST ! stat $M0/b
@@ -71,6 +79,10 @@ TEST "[[ -z \"$gfid_0\" ]]"
 #Check gfid assigning doesn't happen when there is type mismatch
 TEST touch $B0/${V0}1/c
 TEST mkdir $B0/${V0}0/c
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 1
 TEST ! stat $M0/c
 gfid_1=$(gf_get_gfid_xattr $B0/${V0}1/c)
 gfid_0=$(gf_get_gfid_xattr $B0/${V0}0/c)
@@ -81,6 +93,10 @@ TEST "[[ -z \"$gfid_0\" ]]"
 # gfid split-brain
 TEST kill_brick $V0 $H0 $B0/${V0}0
 TEST touch $B0/${V0}1/d
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 1
 TEST ! stat $M0/d
 gfid_1=$(gf_get_gfid_xattr $B0/${V0}1/d)
 TEST "[[ -z \"$gfid_1\" ]]"
diff --git a/tests/basic/afr/granular-esh/cli.t b/tests/basic/afr/granular-esh/cli.t
index a655180a095..10b6c6398da 100644
--- a/tests/basic/afr/granular-esh/cli.t
+++ b/tests/basic/afr/granular-esh/cli.t
@@ -11,7 +11,7 @@ TESTS_EXPECTED_IN_LOOP=4
 TEST glusterd
 TEST pidof glusterd
 
-TEST   $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST   $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
 # Test that enabling the option should work on a newly created volume
 TEST   $CLI volume set $V0 cluster.granular-entry-heal on
 TEST   $CLI volume set $V0 cluster.granular-entry-heal off
@@ -25,34 +25,6 @@ TEST $CLI volume start $V1
 TEST ! $CLI volume heal $V1 granular-entry-heal enable
 TEST ! $CLI volume heal $V1 granular-entry-heal disable
 
-#######################
-###### TIER TEST ######
-#######################
-# Execute the same command on a disperse + replicate tiered volume and make
-# sure the option is set on the replicate leg of the volume
-TEST $CLI volume attach-tier $V1 replica 2 $H0:$B0/${V1}{3,4}
-TEST $CLI volume heal $V1 granular-entry-heal enable
-EXPECT "enable" volume_get_field $V1 cluster.granular-entry-heal
-TEST $CLI volume heal $V1 granular-entry-heal disable
-EXPECT "disable" volume_get_field $V1 cluster.granular-entry-heal
-
-# Kill a disperse brick and make heal be pending on the volume.
-TEST kill_brick $V1 $H0 $B0/${V1}0
-
-# Now make sure that one offline brick in disperse does not affect enabling the
-# option on the volume.
-TEST $CLI volume heal $V1 granular-entry-heal enable
-EXPECT "enable" volume_get_field $V1 cluster.granular-entry-heal
-TEST $CLI volume heal $V1 granular-entry-heal disable
-EXPECT "disable" volume_get_field $V1 cluster.granular-entry-heal
-
-# Now kill a replicate brick.
-TEST kill_brick $V1 $H0 $B0/${V1}3
-# Now make sure that one offline brick in replicate causes the command to be
-# failed.
-TEST ! $CLI volume heal $V1 granular-entry-heal enable
-EXPECT "disable" volume_get_field $V1 cluster.granular-entry-heal
-
 ######################
 ### REPLICATE TEST ###
 ######################
@@ -136,7 +108,7 @@ TEST ! stat $B0/${V0}1/.glusterfs/indices/entry-changes/$ROOT_GFID
 TEST $CLI volume reset $V0
 # Ensure that granular entry heal is also disabled
 EXPECT "no" volume_get_field $V0 cluster.granular-entry-heal
-EXPECT "on" volume_get_field $V0 cluster.entry-self-heal
+EXPECT "off" volume_get_field $V0 cluster.entry-self-heal
 
 cleanup
 #G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=1399038
diff --git a/tests/basic/afr/granular-esh/replace-brick.t b/tests/basic/afr/granular-esh/replace-brick.t
index 639ed81b95c..5fc7811a8d8 100644
--- a/tests/basic/afr/granular-esh/replace-brick.t
+++ b/tests/basic/afr/granular-esh/replace-brick.t
@@ -12,6 +12,7 @@ TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
 TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 cluster.heal-timeout 5
 TEST $CLI volume heal $V0 granular-entry-heal enable
 
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
diff --git a/tests/basic/afr/halo.t b/tests/basic/afr/halo.t
new file mode 100644
index 00000000000..3f61f5a0402
--- /dev/null
+++ b/tests/basic/afr/halo.t
@@ -0,0 +1,61 @@
+#!/bin/bash
+#Tests that halo basic functionality works as expected
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+function get_up_child()
+{
+    if [ "1" == $(afr_private_key_value $V0 $M0 0 "child_up\[0\]") ];
+    then
+        echo 0
+    elif [ "1" == $(afr_private_key_value $V0 $M0 0 "child_up\[1\]") ]
+    then
+        echo 1
+    fi
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 cluster.halo-enabled yes
+TEST $CLI volume set $V0 cluster.halo-max-replicas 1
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[0\]"
+EXPECT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[1\]"
+EXPECT_NOT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[0\]"
+EXPECT_NOT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[1\]"
+
+up_id=$(get_up_child)
+TEST [[ ! -z "$up_id" ]]
+
+down_id=$((1-up_id))
+
+TEST kill_brick $V0 $H0 $B0/${V0}${up_id}
+#As max-replicas is configured to be 1, down_child should be up now
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[${down_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "child_up\[${down_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" afr_private_key_value $V0 $M0 0 "halo_child_up\[${up_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" afr_private_key_value $V0 $M0 0 "child_up\[${up_id}\]"
+EXPECT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[${up_id}\]"
+EXPECT_NOT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[${down_id}\]"
+
+#Bring the brick back up and the state should be restored
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[${up_id}\]"
+
+up_id=$(get_up_child)
+TEST [[ ! -z "$up_id" ]]
+down_id=$((1-up_id))
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[${down_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" afr_private_key_value $V0 $M0 0 "child_up\[${down_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "halo_child_up\[${up_id}\]"
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" afr_private_key_value $V0 $M0 0 "child_up\[${up_id}\]"
+EXPECT_NOT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[0\]"
+EXPECT_NOT "^-1$" afr_private_key_value $V0 $M0 0 "child_latency\[1\]"
+
+cleanup;
diff --git a/tests/basic/afr/lk-quorum.t b/tests/basic/afr/lk-quorum.t
index ad143659bbe..3364d8a6a1b 100644
--- a/tests/basic/afr/lk-quorum.t
+++ b/tests/basic/afr/lk-quorum.t
@@ -1,5 +1,7 @@
 #!/bin/bash
 
+SCRIPT_TIMEOUT=300
+
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../fileio.rc
diff --git a/tests/basic/afr/name-self-heal.t b/tests/basic/afr/name-self-heal.t
new file mode 100644
index 00000000000..50fc2ecc6c2
--- /dev/null
+++ b/tests/basic/afr/name-self-heal.t
@@ -0,0 +1,112 @@
+#!/bin/bash
+#Self-heal tests
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup;
+
+#Check that when quorum is not enabled name-heal happens correctly
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+TEST touch $M0/a
+TEST touch $M0/c
+TEST kill_brick $V0 $H0 $B0/brick0
+TEST touch $M0/b
+TEST rm -f $M0/a
+TEST rm -f $M0/c
+TEST touch $M0/c #gfid mismatch case
+c_gfid=$(gf_get_gfid_xattr $B0/brick1/c)
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST ! stat $M0/a
+TEST ! stat $B0/brick0/a
+TEST ! stat $B0/brick1/a
+
+TEST stat $M0/b
+TEST stat $B0/brick0/b
+TEST stat $B0/brick1/b
+TEST [[ "$(gf_get_gfid_xattr $B0/brick0/b)" == "$(gf_get_gfid_xattr $B0/brick1/b)" ]]
+
+TEST stat $M0/c
+TEST stat $B0/brick0/c
+TEST stat $B0/brick1/c
+TEST [[ "$(gf_get_gfid_xattr $B0/brick0/c)" == "$c_gfid" ]]
+
+cleanup;
+
+#Check that when quorum is enabled name-heal happens as expected
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+TEST touch $M0/a
+TEST touch $M0/c
+TEST kill_brick $V0 $H0 $B0/brick0
+TEST touch $M0/b
+TEST rm -f $M0/a
+TEST rm -f $M0/c
+TEST touch $M0/c #gfid mismatch case
+c_gfid=$(gf_get_gfid_xattr $B0/brick1/c)
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST ! stat $M0/a
+TEST ! stat $B0/brick0/a
+TEST ! stat $B0/brick1/a
+TEST ! stat $B0/brick2/a
+
+TEST stat $M0/b
+TEST ! stat $B0/brick0/b #Name heal shouldn't be triggered
+TEST stat $B0/brick1/b
+TEST stat $B0/brick2/b
+
+TEST stat $M0/c
+TEST stat $B0/brick0/c
+TEST stat $B0/brick1/c
+TEST stat $B0/brick2/c
+TEST [[ "$(gf_get_gfid_xattr $B0/brick0/c)" == "$c_gfid" ]]
+
+TEST $CLI volume set $V0 cluster.quorum-type none
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "none" get_quorum_type $M0 $V0 0
+TEST stat $M0/b
+TEST stat $B0/brick0/b #Name heal should be triggered
+TEST stat $B0/brick1/b
+TEST stat $B0/brick2/b
+TEST [[ "$(gf_get_gfid_xattr $B0/brick0/b)" == "$(gf_get_gfid_xattr $B0/brick1/b)" ]]
+TEST $CLI volume set $V0 cluster.quorum-type auto
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "auto" get_quorum_type $M0 $V0 0
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#Missing parent xattrs cases
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST $CLI volume heal $V0 disable
+#In cases where a good parent doesn't have pending xattrs and a file,
+#name-heal will be triggered
+TEST gf_rm_file_and_gfid_link $B0/brick1 c
+TEST stat $M0/c
+TEST stat $B0/brick0/c
+TEST stat $B0/brick1/c
+TEST stat $B0/brick2/c
+TEST [[ "$(gf_get_gfid_xattr $B0/brick0/c)" == "$c_gfid" ]]
+cleanup
diff --git a/tests/basic/afr/quorum.t b/tests/basic/afr/quorum.t
index 252e25468d7..58116ba49f5 100644
--- a/tests/basic/afr/quorum.t
+++ b/tests/basic/afr/quorum.t
@@ -31,11 +31,7 @@ TEST $CLI volume set $V0 cluster.quorum-count 2
 TEST test_write
 TEST kill_brick $V0 $H0 $B0/${V0}1
 TEST ! test_write
-EXPECT "abc" cat $M0/b
-TEST $CLI volume set $V0 cluster.quorum-reads on
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "1" mount_get_option_value $M0 $V0-replicate-0 quorum-reads
 TEST ! cat $M0/b
-TEST $CLI volume reset $V0 cluster.quorum-reads
 
 TEST $CLI volume set $V0 cluster.quorum-type auto
 EXPECT auto volume_option $V0 cluster.quorum-type
@@ -44,11 +40,7 @@ EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
 TEST test_write
 TEST kill_brick $V0 $H0 $B0/${V0}1
 TEST ! test_write
-EXPECT "abc" cat $M0/b
-TEST $CLI volume set $V0 cluster.quorum-reads on
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "1" mount_get_option_value $M0 $V0-replicate-0 quorum-reads
 TEST ! cat $M0/b
-TEST $CLI volume reset $V0 cluster.quorum-reads
 
 TEST $CLI volume set $V0 cluster.quorum-type none
 EXPECT none volume_option $V0 cluster.quorum-type
@@ -57,11 +49,6 @@ TEST test_write
 TEST $CLI volume reset $V0 cluster.quorum-type
 TEST test_write
 EXPECT "abc" cat $M0/b
-TEST $CLI volume set $V0 cluster.quorum-reads on
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "1" mount_get_option_value $M0 $V0-replicate-0 quorum-reads
-EXPECT "abc" cat $M0/b
-TEST $CLI volume reset $V0 cluster.quorum-reads
-
 
 cleanup;
 TEST glusterd;
@@ -86,24 +73,14 @@ TEST $CLI volume set $V0 cluster.quorum-count 3
 TEST test_write
 TEST kill_brick $V0 $H0 $B0/${V0}1
 TEST ! test_write
-EXPECT "abc" cat $M0/b
-TEST $CLI volume set $V0 cluster.quorum-reads on
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "1" mount_get_option_value $M0 $V0-replicate-0 quorum-reads
 TEST ! cat $M0/b
-TEST $CLI volume reset $V0 cluster.quorum-reads
-
 
 TEST $CLI volume set $V0 cluster.quorum-type auto
 EXPECT auto volume_option $V0 cluster.quorum-type
 TEST test_write
 TEST kill_brick $V0 $H0 $B0/${V0}3
 TEST ! test_write
-EXPECT "abc" cat $M0/b
-TEST $CLI volume set $V0 cluster.quorum-reads on
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "1" mount_get_option_value $M0 $V0-replicate-0 quorum-reads
 TEST ! cat $M0/b
-TEST $CLI volume reset $V0 cluster.quorum-reads
-
 
 TEST $CLI volume set $V0 cluster.quorum-type none
 EXPECT none volume_option $V0 cluster.quorum-type
diff --git a/tests/basic/afr/rename-data-loss.t b/tests/basic/afr/rename-data-loss.t
new file mode 100644
index 00000000000..256ee2aafce
--- /dev/null
+++ b/tests/basic/afr/rename-data-loss.t
@@ -0,0 +1,72 @@
+#!/bin/bash
+#Self-heal tests
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1}
+TEST $CLI volume set $V0 write-behind off
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 data-self-heal off
+TEST $CLI volume set $V0 metadata-self-heal off
+TEST $CLI volume set $V0 entry-self-heal off
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+cd $M0
+TEST `echo "line1" >> file1`
+TEST mkdir dir1
+TEST mkdir dir2
+TEST mkdir -p dir1/dira/dirb
+TEST `echo "line1">>dir1/dira/dirb/file1`
+TEST mkdir delete_me
+TEST `echo "line1" >> delete_me/file1`
+
+#brick0 has witnessed the second write while brick1 is down.
+TEST kill_brick $V0 $H0 $B0/brick1
+TEST `echo "line2" >> file1`
+TEST `echo "line2" >> dir1/dira/dirb/file1`
+TEST `echo "line2" >> delete_me/file1`
+
+#Toggle the bricks that are up/down.
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+TEST kill_brick $V0 $H0 $B0/brick0
+
+#Rename when the 'source' brick0 for data-selfheals is down.
+mv file1 file2
+mv dir1/dira dir2
+
+#Delete a dir when brick0 is down.
+rm -rf delete_me
+cd -
+
+#Bring everything up and trigger heal
+TEST $CLI volume set $V0 self-heal-daemon on
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/brick0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_anon_entry_count $B0/brick1
+
+#Remount to avoid reading from caches
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT "line2" tail -1 $M0/file2
+EXPECT "line2" tail -1 $M0/dir2/dira/dirb/file1
+TEST ! stat $M0/delete_me/file1
+TEST ! stat $M0/delete_me
+
+anon_inode_name=$(ls -a $B0/brick0 | grep glusterfs-anonymous-inode)
+TEST [[ -d $B0/brick0/$anon_inode_name ]]
+TEST [[ -d $B0/brick1/$anon_inode_name ]]
+cleanup
diff --git a/tests/basic/afr/replace-brick-self-heal.t b/tests/basic/afr/replace-brick-self-heal.t
index a8c01a0f377..0360db71a2f 100644
--- a/tests/basic/afr/replace-brick-self-heal.t
+++ b/tests/basic/afr/replace-brick-self-heal.t
@@ -10,7 +10,7 @@ TEST $CLI volume start $V0
 TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
-
+TEST $CLI volume set $V0 cluster.heal-timeout 5
 TEST $CLI volume set $V0 self-heal-daemon off
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
 
diff --git a/tests/basic/afr/resolve.t b/tests/basic/afr/resolve.t
index f7351f843ba..a741eee6e5e 100644
--- a/tests/basic/afr/resolve.t
+++ b/tests/basic/afr/resolve.t
@@ -24,9 +24,8 @@ TEST kill_brick $V0 $H0 $B0/${V0}0
 rm -rf $B0/${V0}0/.glusterfs $B0/${V0}0/a
 
 #Ideally, disk replacement is done using reset-brick or replace-brick gluster CLI
-#which will create .glusterfs/indices folder.
+#which will create .glusterfs folder.
 mkdir $B0/${V0}0/.glusterfs && chmod 600 $B0/${V0}0/.glusterfs
-mkdir $B0/${V0}0/.glusterfs/indices && chmod 600 $B0/${V0}0/.glusterfs/indices
 
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 0
diff --git a/tests/basic/afr/root-squash-self-heal.t b/tests/basic/afr/root-squash-self-heal.t
index c4fab0a35b2..6e12098465a 100644
--- a/tests/basic/afr/root-squash-self-heal.t
+++ b/tests/basic/afr/root-squash-self-heal.t
@@ -11,6 +11,9 @@ TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 self-heal-daemon off
 TEST $CLI volume set $V0 server.root-squash on
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume start $V0
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --no-root-squash=yes --use-readdirp=no $M0
 TEST kill_brick $V0 $H0 $B0/${V0}0
diff --git a/tests/basic/afr/self-heal.t b/tests/basic/afr/self-heal.t
index e1ac17c2d79..10fb152d046 100644
--- a/tests/basic/afr/self-heal.t
+++ b/tests/basic/afr/self-heal.t
@@ -10,8 +10,6 @@ AREQUAL_PATH=$(dirname $0)/../../utils
 AREQUAL_BIN=$AREQUAL_PATH/arequal-checksum
 CFLAGS=""
 test "`uname -s`" != "Linux" && {
-    CFLAGS="$CFLAGS -I$(dirname $0)/../../../contrib/argp-standalone ";
-    CFLAGS="$CFLAGS -L$(dirname $0)/../../../contrib/argp-standalone -largp ";
     CFLAGS="$CFLAGS -lintl";
 }
 build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
diff --git a/tests/basic/afr/split-brain-favorite-child-policy-client-side-healing.t b/tests/basic/afr/split-brain-favorite-child-policy-client-side-healing.t
new file mode 100644
index 00000000000..7c249c4bcbd
--- /dev/null
+++ b/tests/basic/afr/split-brain-favorite-child-policy-client-side-healing.t
@@ -0,0 +1,124 @@
+#!/bin/bash
+
+#Test the client side split-brain resolution
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+GET_MDATA_PATH=$(dirname $0)/../../utils
+build_tester $GET_MDATA_PATH/get-mdata-xattr.c
+
+TEST glusterd
+TEST pidof glusterd
+
+count_files () {
+         ls $1 | wc -l
+}
+
+#Create replica 2 volume
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 cluster.quorum-type fixed
+TEST $CLI volume set $V0 cluster.quorum-count 1
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
+
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+TEST mkdir $M0/data
+TEST touch $M0/data/file
+
+
+############ Client side healing using favorite-child-policy = mtime #################
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST dd if=/dev/urandom of=$M0/data/file bs=1024 count=1024
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST dd if=/dev/urandom of=$M0/data/file bs=1024 count=1024
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+mtime1=$(get_mtime $B0/${V0}0/data/file)
+mtime2=$(get_mtime $B0/${V0}1/data/file)
+if (( $(echo "$mtime1 > $mtime2" | bc -l) )); then
+        LATEST_MTIME_MD5=$(md5sum $B0/${V0}0/data/file | cut -d\  -f1)
+else
+        LATEST_MTIME_MD5=$(md5sum $B0/${V0}1/data/file | cut -d\  -f1)
+fi
+
+#file will be in split-brain
+cat $M0/data/file > /dev/null
+EXPECT "1" echo $?
+
+TEST $CLI volume set $V0 cluster.favorite-child-policy mtime
+TEST $CLI volume start $V0 force
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" afr_get_split_brain_count $V0
+cat $M0/data/file > /dev/null
+EXPECT "0" echo $?
+M0_MD5=$(md5sum $M0/data/file | cut -d\  -f1)
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_get_split_brain_count $V0
+TEST [ "$LATEST_MTIME_MD5" == "$M0_MD5" ]
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+B0_MD5=$(md5sum $B0/${V0}0/data/file | cut -d\  -f1)
+B1_MD5=$(md5sum $B0/${V0}1/data/file | cut -d\  -f1)
+TEST [ "$LATEST_MTIME_MD5" == "$B0_MD5" ]
+TEST [ "$LATEST_MTIME_MD5" == "$B1_MD5" ]
+
+############ Client side directory conservative merge #################
+TEST $CLI volume reset $V0 cluster.favorite-child-policy
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST touch $M0/data/test
+files=$(count_files $M0/data)
+EXPECT "2" echo $files
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST touch $M0/data/test1
+files=$(count_files $M0/data)
+EXPECT "2" echo $files
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+#data dir will be in entry split-brain
+ls $M0/data > /dev/null
+EXPECT "2" echo $?
+
+TEST $CLI volume set $V0 cluster.favorite-child-policy mtime
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" afr_get_split_brain_count $V0
+
+
+ls $M0/data > /dev/null
+EXPECT "0" echo $?
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" afr_get_split_brain_count $V0
+#Entry Split-brain is gone, but data self-heal is pending on the files
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+
+cat $M0/data/test > /dev/null
+cat $M0/data/test1 > /dev/null
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+files=$(count_files $M0/data)
+EXPECT "3" echo $files
+
+TEST force_umount $M0
+TEST rm $GET_MDATA_PATH/get-mdata-xattr
+
+cleanup
diff --git a/tests/basic/afr/split-brain-heal-info.t b/tests/basic/afr/split-brain-heal-info.t
index 66275c57207..2e4742fff08 100644
--- a/tests/basic/afr/split-brain-heal-info.t
+++ b/tests/basic/afr/split-brain-heal-info.t
@@ -47,9 +47,11 @@ SPB_FILES=$(($SPB_FILES + 1))
 
 #### Simulate entry-split-brain
 TEST kill_brick $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 0
 TEST touch $M0/espb/a
 volume_start_force $V0
 TEST kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 1
 TEST mkdir $M0/espb/a
 volume_start_force $V0
 SPB_FILES=$(($SPB_FILES + 1))
diff --git a/tests/basic/afr/split-brain-healing-ctime.t b/tests/basic/afr/split-brain-healing-ctime.t
new file mode 100644
index 00000000000..676788fce3f
--- /dev/null
+++ b/tests/basic/afr/split-brain-healing-ctime.t
@@ -0,0 +1,252 @@
+#!/bin/bash
+
+#Test the split-brain resolution CLI commands.
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+function get_replicate_subvol_number {
+        local filename=$1
+        #get_backend_paths
+        if [ -f $B0/${V0}1/$filename ]
+        then
+                echo 0
+        elif [ -f $B0/${V0}3/$filename ]
+        then    echo 1
+        else
+                echo -1
+        fi
+}
+
+cleanup;
+
+AREQUAL_PATH=$(dirname $0)/../../utils
+GET_MDATA_PATH=$(dirname $0)/../../utils
+CFLAGS=""
+test "`uname -s`" != "Linux" && {
+    CFLAGS="$CFLAGS -lintl";
+}
+build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+build_tester $GET_MDATA_PATH/get-mdata-xattr.c
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4}
+TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 cluster.data-self-heal off
+TEST $CLI volume set $V0 cluster.metadata-self-heal off
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+cd $M0
+for i in {1..10}
+do
+        echo "Initial content">>file$i
+done
+
+replica_0_files_list=(`ls $B0/${V0}1|grep -v '^\.'`)
+replica_1_files_list=(`ls $B0/${V0}3|grep -v '^\.'`)
+
+############ Create data split-brain in the files. ###########################
+TEST kill_brick $V0 $H0 $B0/${V0}1
+for file in ${!replica_0_files_list[*]}
+do
+        echo "B1 is down">>${replica_0_files_list[$file]}
+done
+TEST kill_brick $V0 $H0 $B0/${V0}3
+for file in ${!replica_1_files_list[*]}
+do
+        echo "B3 is down">>${replica_1_files_list[$file]}
+done
+
+SMALLER_FILE_SIZE=$(stat -c %s file1)
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+TEST kill_brick $V0 $H0 $B0/${V0}2
+for file in ${!replica_0_files_list[*]}
+do
+        echo "B2 is down">>${replica_0_files_list[$file]}
+        echo "appending more content to make it the bigger file">>${replica_0_files_list[$file]}
+done
+TEST kill_brick $V0 $H0 $B0/${V0}4
+for file in ${!replica_1_files_list[*]}
+do
+        echo "B4 is down">>${replica_1_files_list[$file]}
+        echo "appending more content to make it the bigger file">>${replica_1_files_list[$file]}
+done
+
+BIGGER_FILE_SIZE=$(stat -c %s file1)
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 3
+
+
+############### Acessing the files should now give EIO. ###############################
+TEST ! cat file1
+TEST ! cat file2
+TEST ! cat file3
+TEST ! cat file4
+TEST ! cat file5
+TEST ! cat file6
+TEST ! cat file7
+TEST ! cat file8
+TEST ! cat file9
+TEST ! cat file10
+###################
+TEST $CLI volume set $V0 cluster.self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 3
+
+################ Heal file1 using the bigger-file option  ##############
+$CLI volume heal $V0 split-brain bigger-file /file1
+EXPECT "0" echo $?
+EXPECT $BIGGER_FILE_SIZE stat -c %s file1
+
+################ Heal file2 using the bigger-file option and its gfid ##############
+subvolume=$(get_replicate_subvol_number file2)
+if [ $subvolume == 0 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}1/file2)
+elif [ $subvolume == 1 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}3/file2)
+fi
+GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
+$CLI volume heal $V0 split-brain bigger-file $GFIDSTR
+EXPECT "0" echo $?
+
+################ Heal file3 using the source-brick option  ##############
+################ Use the brick having smaller file size as source #######
+subvolume=$(get_replicate_subvol_number file3)
+if [ $subvolume == 0 ]
+then
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}2 /file3
+elif [ $subvolume == 1 ]
+then
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}4 /file3
+fi
+EXPECT "0" echo $?
+EXPECT $SMALLER_FILE_SIZE stat -c %s file3
+
+################ Heal file4 using the source-brick option and it's gfid ##############
+################ Use the brick having smaller file size as source #######
+subvolume=$(get_replicate_subvol_number file4)
+if [ $subvolume == 0 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}1/file4)
+        GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}2 $GFIDSTR
+elif [ $subvolume == 1 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}3/file4)
+        GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}4 $GFIDSTR
+fi
+EXPECT "0" echo $?
+EXPECT $SMALLER_FILE_SIZE stat -c %s file4
+
+# With ctime enabled, the ctime xattr ("trusted.glusterfs.mdata") gets healed
+# as part of metadata heal. So mtime would be same, hence it can't be healed
+# using 'latest-mtime' policy, use 'source-brick' option instead.
+################ Heal file5 using the source-brick option  ##############
+subvolume=$(get_replicate_subvol_number file5)
+if [ $subvolume == 0 ]
+then
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 /file5
+elif [ $subvolume == 1 ]
+then
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}3 /file5
+fi
+EXPECT "0" echo $?
+
+if [ $subvolume == 0 ]
+then
+        mtime1_after_heal=$(get_mtime $B0/${V0}1/file5)
+        mtime2_after_heal=$(get_mtime $B0/${V0}2/file5)
+elif [ $subvolume == 1 ]
+then
+        mtime1_after_heal=$(get_mtime $B0/${V0}3/file5)
+        mtime2_after_heal=$(get_mtime $B0/${V0}4/file5)
+fi
+
+#TODO: To below comparisons on full sub-second resolution
+
+TEST [ $mtime1_after_heal -eq $mtime2_after_heal ]
+
+mtime_mount_after_heal=$(stat -c %Y file5)
+
+TEST [ $mtime1_after_heal -eq $mtime_mount_after_heal ]
+
+################ Heal file6 using the source-brick option and its gfid  ##############
+subvolume=$(get_replicate_subvol_number file6)
+if [ $subvolume == 0 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}1/file6)
+        GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 $GFIDSTR
+elif [ $subvolume == 1 ]
+then
+        GFID=$(gf_get_gfid_xattr $B0/${V0}3/file6)
+        GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
+        $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}3 $GFIDSTR
+fi
+EXPECT "0" echo $?
+
+if [ $subvolume == 0 ]
+then
+        mtime1_after_heal=$(get_mtime $B0/${V0}1/file6)
+        mtime2_after_heal=$(get_mtime $B0/${V0}2/file6)
+elif [ $subvolume == 1 ]
+then
+        mtime1_after_heal=$(get_mtime $B0/${V0}3/file6)
+        mtime2_after_heal=$(get_mtime $B0/${V0}4/file6)
+fi
+
+#TODO: To below comparisons on full sub-second resolution
+
+TEST [ $mtime1_after_heal -eq $mtime2_after_heal ]
+
+mtime_mount_after_heal=$(stat -c %Y file6)
+
+TEST [ $mtime1_after_heal -eq $mtime_mount_after_heal ]
+
+################ Heal remaining SB'ed files of replica_0 using B1 as source ##############
+$CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1
+EXPECT "0" echo $?
+
+################ Heal remaining SB'ed files of replica_1 using B3 as source ##############
+$CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}3
+EXPECT "0" echo $?
+
+############### Reading the files should now succeed. ###############################
+TEST  cat file1
+TEST  cat file2
+TEST  cat file3
+TEST  cat file4
+TEST  cat file5
+TEST  cat file6
+TEST  cat file7
+TEST  cat file8
+TEST  cat file9
+TEST  cat file10
+
+################ File contents on the bricks must be same. ################################
+TEST diff <(arequal-checksum -p $B0/$V01 -i .glusterfs) <(arequal-checksum -p $B0/$V02 -i .glusterfs)
+TEST diff <(arequal-checksum -p $B0/$V03 -i .glusterfs) <(arequal-checksum -p $B0/$V04 -i .glusterfs)
+
+############### Trying to heal files not in SB should fail. ###############################
+$CLI volume heal $V0 split-brain bigger-file /file1
+EXPECT "1" echo $?
+$CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}4 /file3
+EXPECT "1" echo $?
+
+cd -
+TEST rm $AREQUAL_PATH/arequal-checksum
+TEST rm $GET_MDATA_PATH/get-mdata-xattr
+cleanup
diff --git a/tests/basic/afr/split-brain-healing.t b/tests/basic/afr/split-brain-healing.t
index 8b7eaffb268..315e815eb7e 100644
--- a/tests/basic/afr/split-brain-healing.t
+++ b/tests/basic/afr/split-brain-healing.t
@@ -20,13 +20,14 @@ function get_replicate_subvol_number {
 cleanup;
 
 AREQUAL_PATH=$(dirname $0)/../../utils
+GET_MDATA_PATH=$(dirname $0)/../../utils
 CFLAGS=""
 test "`uname -s`" != "Linux" && {
-    CFLAGS="$CFLAGS -I$(dirname $0)/../../../contrib/argp-standalone ";
-    CFLAGS="$CFLAGS -L$(dirname $0)/../../../contrib/argp-standalone -largp ";
     CFLAGS="$CFLAGS -lintl";
 }
 build_tester $AREQUAL_PATH/arequal-checksum.c $CFLAGS
+build_tester $GET_MDATA_PATH/get-mdata-xattr.c
+
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4}
@@ -34,6 +35,7 @@ TEST $CLI volume set $V0 cluster.self-heal-daemon off
 TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume set $V0 ctime off
 TEST $CLI volume start $V0
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 
@@ -78,7 +80,6 @@ do
 done
 
 BIGGER_FILE_SIZE=$(stat -c %s file1)
-
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 3
@@ -155,13 +156,13 @@ EXPECT $SMALLER_FILE_SIZE stat -c %s file4
 subvolume=$(get_replicate_subvol_number file5)
 if [ $subvolume == 0 ]
 then
-        mtime1=$(stat -c %Y $B0/${V0}1/file5)
-        mtime2=$(stat -c %Y $B0/${V0}2/file5)
+        mtime1=$(get_mtime $B0/${V0}1/file5)
+        mtime2=$(get_mtime $B0/${V0}2/file5)
         LATEST_MTIME=$(($mtime1 > $mtime2 ? $mtime1:$mtime2))
 elif [ $subvolume == 1 ]
 then
-        mtime1=$(stat -c %Y $B0/${V0}3/file5)
-        mtime2=$(stat -c %Y $B0/${V0}4/file5)
+        mtime1=$(get_mtime $B0/${V0}3/file5)
+        mtime2=$(get_mtime $B0/${V0}4/file5)
         LATEST_MTIME=$(($mtime1 > $mtime2 ? $mtime1:$mtime2))
 fi
 $CLI volume heal $V0 split-brain latest-mtime /file5
@@ -169,12 +170,12 @@ EXPECT "0" echo $?
 
 if [ $subvolume == 0 ]
 then
-        mtime1_after_heal=$(stat -c %Y $B0/${V0}1/file5)
-        mtime2_after_heal=$(stat -c %Y $B0/${V0}2/file5)
+        mtime1_after_heal=$(get_mtime $B0/${V0}1/file5)
+        mtime2_after_heal=$(get_mtime $B0/${V0}2/file5)
 elif [ $subvolume == 1 ]
 then
-        mtime1_after_heal=$(stat -c %Y $B0/${V0}3/file5)
-        mtime2_after_heal=$(stat -c %Y $B0/${V0}4/file5)
+        mtime1_after_heal=$(get_mtime $B0/${V0}3/file5)
+        mtime2_after_heal=$(get_mtime $B0/${V0}4/file5)
 fi
 
 #TODO: To below comparisons on full sub-second resolution
@@ -191,14 +192,14 @@ subvolume=$(get_replicate_subvol_number file6)
 if [ $subvolume == 0 ]
 then
         GFID=$(gf_get_gfid_xattr $B0/${V0}1/file6)
-        mtime1=$(stat -c %Y $B0/${V0}1/file6)
-        mtime2=$(stat -c %Y $B0/${V0}2/file6)
+        mtime1=$(get_mtime $B0/${V0}1/file6)
+        mtime2=$(get_mtime $B0/${V0}2/file6)
         LATEST_MTIME=$(($mtime1 > $mtime2 ? $mtime1:$mtime2))
 elif [ $subvolume == 1 ]
 then
         GFID=$(gf_get_gfid_xattr $B0/${V0}3/file6)
-        mtime1=$(stat -c %Y $B0/${V0}3/file6)
-        mtime2=$(stat -c %Y $B0/${V0}4/file6)
+        mtime1=$(get_mtime $B0/${V0}3/file6)
+        mtime2=$(get_mtime $B0/${V0}4/file6)
         LATEST_MTIME=$(($mtime1 > $mtime2 ? $mtime1:$mtime2))
 fi
 GFIDSTR="gfid:$(gf_gfid_xattr_to_str $GFID)"
@@ -207,12 +208,12 @@ EXPECT "0" echo $?
 
 if [ $subvolume == 0 ]
 then
-        mtime1_after_heal=$(stat -c %Y $B0/${V0}1/file6)
-        mtime2_after_heal=$(stat -c %Y $B0/${V0}2/file6)
+        mtime1_after_heal=$(get_mtime $B0/${V0}1/file6)
+        mtime2_after_heal=$(get_mtime $B0/${V0}2/file6)
 elif [ $subvolume == 1 ]
 then
-        mtime1_after_heal=$(stat -c %Y $B0/${V0}3/file6)
-        mtime2_after_heal=$(stat -c %Y $B0/${V0}4/file6)
+        mtime1_after_heal=$(get_mtime $B0/${V0}3/file6)
+        mtime2_after_heal=$(get_mtime $B0/${V0}4/file6)
 fi
 
 #TODO: To below comparisons on full sub-second resolution
@@ -256,4 +257,5 @@ EXPECT "1" echo $?
 
 cd -
 TEST rm $AREQUAL_PATH/arequal-checksum
+TEST rm $GET_MDATA_PATH/get-mdata-xattr
 cleanup
diff --git a/tests/basic/afr/split-brain-open.t b/tests/basic/afr/split-brain-open.t
new file mode 100644
index 00000000000..9b2f2856047
--- /dev/null
+++ b/tests/basic/afr/split-brain-open.t
@@ -0,0 +1,38 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume start $V0
+
+#Disable self-heal-daemon
+TEST $CLI volume heal $V0 disable
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+TEST touch $M0/data-split-brain.txt
+
+#Create data split-brain
+TEST kill_brick $V0 $H0 $B0/${V0}0
+
+`echo "brick1_alive" > $M0/data-split-brain.txt`
+TEST [ $? == 0 ];
+
+TEST $CLI volume start $V0 force
+TEST kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+`echo "brick0_alive" > $M0/data-split-brain.txt`
+TEST [ $? == 0 ];
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+echo "all-alive" >> $M0/data-split-brain.txt
+TEST [ $? != 0 ];
+
+cleanup;
diff --git a/tests/basic/afr/split-brain-resolution.t b/tests/basic/afr/split-brain-resolution.t
index e75e15aaa97..834237c96ec 100644
--- a/tests/basic/afr/split-brain-resolution.t
+++ b/tests/basic/afr/split-brain-resolution.t
@@ -11,6 +11,9 @@ function get_split_brain_status {
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume start $V0
 
 #Disable self-heal-daemon
@@ -71,6 +74,18 @@ TEST setfattr -n replica.split-brain-choice -v none $M0/data-split-brain.txt
 TEST ! getfattr -n user.test $M0/metadata-split-brain.txt
 TEST ! cat $M0/data-split-brain.txt
 
+#Check that after timeout fops result in EIO again.
+#Set one minute timeout
+TEST setfattr -n replica.split-brain-choice-timeout -v 1 $M0/
+TEST setfattr -n replica.split-brain-choice -v $V0-client-1 $M0/data-split-brain.txt
+EXPECT "brick1_alive" cat $M0/data-split-brain.txt
+TEST setfattr -n replica.split-brain-choice -v $V0-client-0 $M0/metadata-split-brain.txt
+EXPECT "brick0" get_text_xattr user.test $M0/metadata-split-brain.txt
+#Wait until timeout completes and test that the fops fail again
+sleep 62
+TEST ! getfattr -n user.test $M0/metadata-split-brain.txt
+TEST ! cat $M0/data-split-brain.txt
+
 #Negative test cases should fail
 TEST ! setfattr -n replica.split-brain-choice -v $V0-client-4 $M0/data-split-brain.txt
 TEST ! setfattr -n replica.split-brain-heal-finalize -v $V0-client-4 $M0/metadata-split-brain.txt
@@ -85,3 +100,6 @@ EXPECT "brick1_alive" cat $M0/data-split-brain.txt
 EXPECT 0 get_pending_heal_count $V0
 
 cleanup;
+
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/basic/afr/ta-check-locks.t b/tests/basic/afr/ta-check-locks.t
new file mode 100644
index 00000000000..c0102c35b7b
--- /dev/null
+++ b/tests/basic/afr/ta-check-locks.t
@@ -0,0 +1,68 @@
+#!/bin/bash
+#This test checks if all the locks on
+#ta file are being held and released properly
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+
+function get_lock_count_on_ta()
+{
+    tapid=`cat $B0/ta.pid`
+    local sfile=$(generate_statedump $tapid)
+    count=$(grep "inodelk-count" $sfile | cut -f2 -d'=' | tail -1)
+    ncount=$(grep "inodelk.inodelk" $sfile | grep "len=1" | wc -l)
+    echo "count = $count : ncount = $ncount"
+    if [ "$count" = "" ]
+    then
+        count=0
+    fi
+
+    if [ "$count" -eq "$ncount" ]
+    then
+        echo "$count"
+    else
+        echo "-1"
+    fi
+}
+
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+TEST ta_start_mount_process $M0
+TEST ta_start_mount_process $M1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M1 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST ta_create_shd_volfile brick0 brick1 ta
+TEST ta_start_shd_process glustershd
+shd_pid=$(cat $B0/glustershd.pid)
+
+TEST touch $M0/a.txt
+echo "Hello" >> $M0/a.txt
+EXPECT_WITHIN $IO_WAIT_TIMEOUT "0" get_lock_count_on_ta
+
+TEST ta_kill_brick brick0
+echo "Hello" >> $M0/a.txt
+EXPECT_WITHIN $IO_WAIT_TIMEOUT "1" get_lock_count_on_ta
+
+echo "Hello" >> $M1/a.txt
+EXPECT_WITHIN $IO_WAIT_TIMEOUT "2" get_lock_count_on_ta
+
+echo "xyz" >> $M0/a.txt
+EXPECT_WITHIN $IO_WAIT_TIMEOUT "2" get_lock_count_on_ta
+
+chmod 0666 $M0/a.txt
+EXPECT_WITHIN $IO_WAIT_TIMEOUT "2" get_lock_count_on_ta
+
+TEST ta_start_brick_process brick0
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_lock_count_on_ta
+
+cleanup;
diff --git a/tests/basic/afr/ta-read.t b/tests/basic/afr/ta-read.t
new file mode 100644
index 00000000000..3cfc16b9b8a
--- /dev/null
+++ b/tests/basic/afr/ta-read.t
@@ -0,0 +1,64 @@
+#!/bin/bash
+
+# Test read transaction logic for thin-arbiter.
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST touch $M0/FILE
+TEST ls $B0/brick0/FILE
+TEST ls $B0/brick1/FILE
+TEST ! ls $B0/ta/FILE
+
+# Kill one brick and write to FILE.
+TEST ta_kill_brick brick0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ta_mount_child_up_status $M0 $V0 0
+echo "brick0 down">> $M0/FILE
+TEST [ $? -eq 0 ]
+EXPECT "000000010000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/brick1/FILE
+EXPECT "000000010000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/ta/trusted.afr.patchy-ta-2
+
+#Umount and mount to remove cached data.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 1
+# Read must be allowed since good brick is up.
+TEST  cat $M0/FILE
+
+#Umount and mount to remove cached data.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+# Toggle good and bad data brick processes.
+TEST ta_start_brick_process brick0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 0
+TEST ta_kill_brick brick1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ta_mount_child_up_status $M0 $V0 1
+# Read must now fail.
+TEST ! cat $M0/FILE
+
+# Bring all data bricks up, and kill TA.
+TEST ta_start_brick_process brick1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 1
+TA_PID=$(ta_get_pid_by_brick_name ta)
+TEST [ -n $TA_PID ]
+TEST ta_kill_brick ta
+TA_PID=$(ta_get_pid_by_brick_name ta)
+TEST [ -z $TA_PID ]
+# Read must now succeed.
+TEST cat $M0/FILE
+cleanup;
diff --git a/tests/basic/afr/ta-shd.t b/tests/basic/afr/ta-shd.t
new file mode 100644
index 00000000000..96ecfc678e0
--- /dev/null
+++ b/tests/basic/afr/ta-shd.t
@@ -0,0 +1,49 @@
+#!/bin/bash
+#Self-heal tests
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST ta_create_shd_volfile brick0 brick1 ta
+TEST ta_start_shd_process glustershd
+
+TEST touch $M0/a.txt
+TEST ta_kill_brick brick0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ta_mount_child_up_status $M0 $V0 0
+echo "Hello" >> $M0/a.txt
+EXPECT "000000010000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/brick1/a.txt
+EXPECT "000000010000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/ta/trusted.afr.$V0-ta-2
+
+#TODO: After the write txn changes are merged, take statedump of TA process and
+#check whether AFR_TA_DOM_NOTIFY lock is held by the client here. Take the
+#statedump again after line #38 to check AFR_TA_DOM_NOTIFY lock is released by
+#the SHD process.
+
+TEST ta_start_brick_process brick0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 0
+EXPECT_WITHIN $HEAL_TIMEOUT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/brick1/a.txt
+EXPECT_WITHIN $HEAL_TIMEOUT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/ta/trusted.afr.$V0-ta-2
+
+#Kill the previously up brick and try reading from other brick. Since the heal
+#has happened file content should be same.
+TEST ta_kill_brick brick1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ta_mount_child_up_status $M0 $V0 1
+#Umount and mount to remove cached data.
+TEST umount $M0
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT "Hello" cat $M0/a.txt
+cleanup;
diff --git a/tests/basic/afr/ta-write-on-bad-brick.t b/tests/basic/afr/ta-write-on-bad-brick.t
new file mode 100644
index 00000000000..096ca9f47cf
--- /dev/null
+++ b/tests/basic/afr/ta-write-on-bad-brick.t
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST touch $M0/a.txt
+TEST ls $B0/brick0/a.txt
+TEST ls $B0/brick1/a.txt
+TEST ! ls $B0/ta/a.txt
+
+TEST dd if=/dev/zero of=$M0/a.txt bs=1M count=5
+
+#Good Data brick is down. TA and bad brick are UP
+
+TEST ta_kill_brick brick1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ta_mount_child_up_status $M0 $V0 1
+TEST dd if=/dev/zero of=$M0/a.txt bs=1M count=5
+TEST ta_kill_brick brick0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0"  ta_mount_child_up_status $M0 $V0 0
+TEST ta_start_brick_process brick1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 1
+TEST ! dd if=/dev/zero of=$M0/a.txt bs=1M count=5
+
+# Good Data brick is UP. Bad and TA are down
+TEST ta_kill_brick brick1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0"  ta_mount_child_up_status $M0 $V0 1
+TEST ta_start_brick_process brick0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 0
+TEST ta_kill_brick ta
+TEST ! dd if=/dev/zero of=$M0/a.txt bs=1M count=5
+
+# Good and Bad data bricks are UP. TA is down
+TEST ta_start_brick_process brick1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_mount_child_up_status $M0 $V0 0
+TEST dd if=/dev/zero of=$M0/a.txt bs=1M count=5
+
+cleanup;
diff --git a/tests/basic/afr/ta.t b/tests/basic/afr/ta.t
new file mode 100644
index 00000000000..05d48431c95
--- /dev/null
+++ b/tests/basic/afr/ta.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+#Self-heal tests
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST touch $M0/a.txt
+TEST ls $B0/brick0/a.txt
+TEST ls $B0/brick1/a.txt
+TEST ! ls $B0/ta/a.txt
+
+TEST ta_kill_brick brick0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" afr_child_up_status_meta $M0 $V0-replicate-0 0
+TEST touch $M0/b.txt
+EXPECT "000000000000000000000001" get_hex_xattr trusted.afr.$V0-client-0 $B0/brick1
+EXPECT "000000010000000200000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/brick1/b.txt
+#New entry mark lead to pending data on the file and on ta
+EXPECT "000000010000000100000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/ta/trusted.afr.patchy-ta-2
+TEST ! ls $B0/brick0/b.txt
+TEST ls $B0/brick1/b.txt
+
+#Try to create an entry while good brick is down and bad brick is UP. Should not create
+TEST ta_start_brick_process brick0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 0
+TEST ta_kill_brick brick1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" afr_child_up_status_meta $M0 $V0-replicate-0 1
+TEST ! touch $M0/d.txt
+EXPECT "000000010000000100000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/ta/trusted.afr.patchy-ta-2
+
+TEST ta_start_brick_process brick1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 1
+TEST ta_kill_brick brick0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" afr_child_up_status_meta $M0 $V0-replicate-0 0
+
+TEST ta_kill_brick ta
+# Entry create must fail if only one brick is UP, even if that is a good brick.
+TEST ! touch $M0/c.txt
+TEST ! ls $B0/brick0/c.txt
+TEST ! ls $B0/brick1/c.txt
+
+cleanup;
diff --git a/tests/basic/afr/tarissue.t b/tests/basic/afr/tarissue.t
index f24d0f74f93..83f7463130c 100644
--- a/tests/basic/afr/tarissue.t
+++ b/tests/basic/afr/tarissue.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 TESTS_EXPECTED_IN_LOOP=10
 cleanup;
 
@@ -35,6 +37,3 @@ TEST rm -f /tmp/dir1.tar.gz
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
 
 cleanup;
-
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=1337791
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=1337791
diff --git a/tests/basic/all_squash.t b/tests/basic/all_squash.t
new file mode 100644
index 00000000000..29766c50af7
--- /dev/null
+++ b/tests/basic/all_squash.t
@@ -0,0 +1,74 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../nfs.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 nfs.disable false
+TEST $CLI volume start $V0;
+
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0;
+EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
+TEST mount_nfs $H0:/$V0 $N0 nolock;
+
+# random uid/gid
+uid=22162
+gid=5845
+
+TEST $CLI volume set $V0 server.anonuid $uid;
+TEST $CLI volume set $V0 server.anongid $gid;
+
+# Ensure server.all-squash is disabled
+TEST $CLI volume set $V0 server.all-squash disable;
+
+# Tests for the fuse mount
+mkdir $M0/other;
+chown $uid:$gid $M0/other;
+
+TEST $CLI volume set $V0 server.all-squash enable;
+
+touch $M0/file 2>/dev/null;
+TEST [ $? -ne 0 ]
+mkdir $M0/dir 2>/dev/null;
+TEST [ $? -ne 0 ]
+
+TEST touch $M0/other/file 2>/dev/null;
+TEST [ "$(stat -c %u:%g $M0/other/file)" = "$uid:$gid" ];
+TEST mkdir $M0/other/dir 2>/dev/null;
+TEST [ "$(stat -c %u:%g $M0/other/dir)" = "$uid:$gid" ];
+
+TEST $CLI volume set $V0 server.all-squash disable;
+TEST rm -rf $M0/other;
+
+sleep 1;
+
+# tests for nfs mount
+mkdir $N0/other;
+chown $uid:$gid $N0/other;
+
+TEST $CLI volume set $V0 server.all-squash enable;
+
+touch $N0/file 2>/dev/null;
+TEST [ $? -ne 0 ]
+mkdir $N0/dir 2>/dev/null;
+TEST [ $? -ne 0 ]
+
+TEST touch $N0/other/file 2>/dev/null;
+TEST [ "$(stat -c %u:%g $N0/other/file)" = "$uid:$gid" ];
+TEST mkdir $N0/other/dir 2>/dev/null;
+TEST [ "$(stat -c %u:%g $N0/other/dir)" = "$uid:$gid" ];
+
+TEST $CLI volume set $V0 server.all-squash disable;
+TEST rm -rf $N0/other;
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
+
+TEST $CLI volume stop $V0;
+TEST $CLI volume delete $V0;
+
+cleanup;
diff --git a/tests/basic/bd.t b/tests/basic/bd.t
deleted file mode 100755
index 63622edd709..00000000000
--- a/tests/basic/bd.t
+++ /dev/null
@@ -1,142 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-
-function execute()
-{
-        cmd=$1
-        shift
-        ${cmd} $@ >/dev/null 2>&1
-}
-
-function bd_cleanup()
-{
-        execute vgremove -f ${V0}
-        execute pvremove ${ld}
-        execute losetup -d ${ld}
-        execute rm ${BD_DISK}
-        cleanup
-}
-
-function check()
-{
-        if [ $? -ne 0 ]; then
-                echo prerequsite $@ failed
-                bd_cleanup
-                exit
-        fi
-}
-
-SIZE=256 #in MB
-
-bd_cleanup;
-
-## Configure environment needed for BD backend volumes
-## Create a file with configured size and
-## set it as a temporary loop device to create
-## physical volume & VG. These are basic things needed
-## for testing BD xlator if anyone of these steps fail,
-## test script exits
-function configure()
-{
-    GLDIR=`$CLI system:: getwd`
-    BD_DISK=${GLDIR}/bd_disk
-
-    execute truncate -s${SIZE}M ${BD_DISK}
-    check ${BD_DISK} creation
-
-    execute losetup -f
-    check losetup
-    ld=`losetup -f`
-
-    execute losetup ${ld} ${BD_DISK}
-    check losetup ${BD_DISK}
-    execute pvcreate -f ${ld}
-    check pvcreate ${ld}
-    execute vgcreate ${V0} ${ld}
-    check vgcreate ${V0}
-    execute lvcreate --thin ${V0}/pool --size 128M
-}
-
-function volinfo_field()
-{
-    local vol=$1;
-    local field=$2;
-    $CLI volume info $vol | grep "^$field: " | sed 's/.*: //';
-}
-
-function volume_type()
-{
-        getfattr -n volume.type $M0/. --only-values --absolute-names -e text
-}
-
-case $OSTYPE in
-NetBSD)
-        echo "Skip test on LVM which is not available on NetBSD" >&2
-        SKIP_TESTS
-        exit 0
-        ;;
-*)      
-        ;;
-esac 
-
-TEST glusterd
-TEST pidof glusterd
-configure
-
-TEST $CLI volume create $V0 ${H0}:/$B0/$V0?${V0}
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status'
-
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-EXPECT '1' volume_type
-
-## Create posix file
-TEST touch $M0/posix
-
-TEST touch $M0/lv
-gfid=`getfattr -n glusterfs.gfid.string $M0/lv --only-values --absolute-names`
-TEST setfattr -n user.glusterfs.bd -v "lv:4MB" $M0/lv
-# Check if LV is created
-TEST stat /dev/$V0/${gfid}
-
-## Create filesystem
-sleep 1
-TEST mkfs.ext4 -qF $M0/lv
-# Cloning
-TEST touch $M0/lv_clone
-gfid=`getfattr -n glusterfs.gfid.string $M0/lv_clone --only-values --absolute-names`
-TEST setfattr -n clone -v ${gfid} $M0/lv
-TEST stat /dev/$V0/${gfid}
-
-sleep 1
-## Check mounting
-TEST mount -o loop $M0/lv $M1
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
-
-# Snapshot
-TEST touch $M0/lv_sn
-gfid=`getfattr -n glusterfs.gfid.string $M0/lv_sn --only-values --absolute-names`
-TEST setfattr -n snapshot -v ${gfid} $M0/lv
-TEST stat /dev/$V0/${gfid}
-
-# Merge
-sleep 1
-TEST setfattr -n merge -v "$M0/lv_sn" $M0/lv_sn
-TEST ! stat $M0/lv_sn
-TEST ! stat /dev/$V0/${gfid}
-
-
-rm $M0/* -f
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume stop ${V0}
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-TEST $CLI volume delete ${V0}
-
-bd_cleanup
diff --git a/tests/basic/changelog/changelog-api.t b/tests/basic/changelog/changelog-api.t
new file mode 100644
index 00000000000..516c2f2f60d
--- /dev/null
+++ b/tests/basic/changelog/changelog-api.t
@@ -0,0 +1,37 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../env.rc
+
+cleanup;
+
+CHANGELOG_BIN_PATH=$(dirname $0)/../../utils/changelog
+build_tester $CHANGELOG_BIN_PATH/test-changelog-api.c -lgfchangelog
+
+CHANGELOG_PATH_0="$B0/${V0}0/.glusterfs/changelogs"
+ROLLOVER_TIME=2
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+sleep 3;
+
+#Listen to changelog journal notifcations
+$CHANGELOG_BIN_PATH/test-changelog-api &
+for i in {1..12};do echo "data" > $M0/file$i 2>/dev/null; sleep 1;done &
+
+#Wait for changelogs to be in .processed directory
+sleep 12
+
+EXPECT "Y" processed_changelogs "/tmp/scratch_v1/.processed"
+TEST rm $CHANGELOG_BIN_PATH/test-changelog-api
+rm -rf /tmp/scratch_v1
+
+cleanup;
diff --git a/tests/basic/changelog/changelog-history.t b/tests/basic/changelog/changelog-history.t
new file mode 100644
index 00000000000..ea952619652
--- /dev/null
+++ b/tests/basic/changelog/changelog-history.t
@@ -0,0 +1,91 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../env.rc
+
+cleanup;
+
+SCRIPT_TIMEOUT=300
+HISTORY_BIN_PATH=$(dirname $0)/../../utils/changelog
+build_tester $HISTORY_BIN_PATH/get-history.c -lgfchangelog
+
+time_before_enable1=$(date '+%s')
+CHANGELOG_PATH_0="$B0/${V0}0/.glusterfs/changelogs"
+ROLLOVER_TIME=2
+
+TEST glusterd
+TEST pidof glusterd
+
+sleep 3
+time_before_enable2=$(date '+%s')
+
+sleep 3
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+
+sleep 3
+time_after_enable1=$(date '+%s')
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+touch $M0/file{1..10}
+
+sleep 3
+time_after_enable2=$(date '+%s')
+
+let time_future=time_after_enable2+600
+
+#Fails as start falls before changelog enable
+EXPECT "-3" $HISTORY_BIN_PATH/get-history $time_before_enable1 $time_before_enable2
+
+#Fails as start falls before changelog enable
+EXPECT "-3" $HISTORY_BIN_PATH/get-history $time_before_enable2 $time_after_enable1
+
+#Passes as start and end falls in same htime file
+EXPECT "0" $HISTORY_BIN_PATH/get-history $time_after_enable1 $time_after_enable2
+
+#Passes, gives the changelogs till continuous changelogs are available
+# but returns 1
+EXPECT "1" $HISTORY_BIN_PATH/get-history $time_after_enable2 $time_future
+
+#Disable and enable changelog
+TEST $CLI volume set $V0 changelog.changelog off
+sleep 6
+time_between_htime=$(date '+%s')
+sleep 6
+TEST $CLI volume set $V0 changelog.changelog on
+
+sleep 6
+touch $M0/test{1..10}
+time_in_sec_htime1=$(date '+%s')
+
+sleep 6
+touch $M0/test1{1..10}
+time_in_sec_htime2=$(date '+%s')
+
+sleep 3
+TEST $CLI volume set $V0 changelog.changelog off
+sleep 3
+time_after_disable=$(date '+%s')
+
+TEST $CLI volume set $V0 changelog.changelog on
+sleep 5
+
+#Passes, gives the changelogs till continuous changelogs are available
+# but returns 1
+EXPECT_WITHIN 10 "1" $HISTORY_BIN_PATH/get-history $time_after_enable1 $time_in_sec_htime2
+
+#Fails as start falls between htime files
+EXPECT_WITHIN 10 "-3" $HISTORY_BIN_PATH/get-history $time_between_htime $time_in_sec_htime1
+
+#Passes as start and end falls in same htime file
+EXPECT_WITHIN 10 "0" $HISTORY_BIN_PATH/get-history $time_in_sec_htime1 $time_in_sec_htime2
+
+#Passes, gives the changelogs till continuous changelogs are available
+EXPECT_WITHIN 10 "0" $HISTORY_BIN_PATH/get-history $time_in_sec_htime2 $time_after_disable
+
+TEST rm $HISTORY_BIN_PATH/get-history
+rm -rf /tmp/scratch_v1/*
+
+cleanup;
diff --git a/tests/basic/changelog/changelog-rename.t b/tests/basic/changelog/changelog-rename.t
new file mode 100644
index 00000000000..9a0ef527b5b
--- /dev/null
+++ b/tests/basic/changelog/changelog-rename.t
@@ -0,0 +1,44 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+CHANGELOG_PATH_0="$B0/${V0}0/.glusterfs/changelogs"
+ROLLOVER_TIME=30
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+touch $M0/file1
+mv $M0/file1 $M0/rn_file1
+mkdir $M0/dir1
+mv $M0/dir1 $M0/rn_dir1
+
+EXPECT "2" check_changelog_op ${CHANGELOG_PATH_0} "RENAME"
+
+cleanup;
+
+#####Test on multiple subvolume#####
+#==========================================#
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+touch $M0/gluster_file
+mv $M0/gluster_file $M0/rn_gluster_file
+mkdir $M0/dir1
+mv $M0/dir1 $M0/rn_dir1
+
+EXPECT "2" check_changelog_op ${CHANGELOG_PATH_0} "RENAME"
+
+cleanup;
diff --git a/tests/basic/changelog/history-api.t b/tests/basic/changelog/history-api.t
new file mode 100644
index 00000000000..9e63118cef9
--- /dev/null
+++ b/tests/basic/changelog/history-api.t
@@ -0,0 +1,42 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../env.rc
+
+cleanup;
+
+HISTORY_BIN_PATH=$(dirname $0)/../../utils/changelog
+build_tester $HISTORY_BIN_PATH/test-history-api.c -lgfchangelog
+
+CHANGELOG_PATH_0="$B0/${V0}0/.glusterfs/changelogs"
+ROLLOVER_TIME=2
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+
+sleep 3
+start=$(date '+%s')
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+touch $M0/file{1..10}
+
+for i in {1..12};do echo "data" > $M0/file$i; sleep 1;done
+end=$(date '+%s')
+sleep 2
+
+#Passes as start and end falls in same htime file
+EXPECT "0" $HISTORY_BIN_PATH/test-history-api $start $end
+
+#Wait for changelogs to be in .processed directory
+sleep 2
+
+EXPECT "Y" processed_changelogs "/tmp/scratch_v1/.history/.processed"
+TEST rm $HISTORY_BIN_PATH/test-history-api
+rm -rf /tmp/scratch_v1
+
+cleanup;
diff --git a/tests/basic/cloudsync-sanity.t b/tests/basic/cloudsync-sanity.t
new file mode 100644
index 00000000000..834ba96430c
--- /dev/null
+++ b/tests/basic/cloudsync-sanity.t
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6,7,8,9};
+TEST $CLI volume set $V0 features.cloudsync enable;
+TEST $CLI volume start $V0;
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+# This test covers lookup, mkdir, mknod, symlink, link, rename,
+# create operations
+TEST $(dirname $0)/rpc-coverage.sh $M1
+
+
+TEST cp $(dirname ${0})/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+./glfsxmp $V0 $H0
+cleanup_tester ./glfsxmp
+rm ./glfsxmp.c
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-ec-heal.t b/tests/basic/ctime/ctime-ec-heal.t
new file mode 100644
index 00000000000..142237c5014
--- /dev/null
+++ b/tests/basic/ctime/ctime-ec-heal.t
@@ -0,0 +1,70 @@
+#!/bin/bash
+#
+# This will test self healing of ctime xattr 'trusted.glusterfs.mdata'
+#
+###
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup
+
+#cleate and start volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{1..3}
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+
+# Create files
+mkdir $M0/dir1
+echo "Initial content" > $M0/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+# Kill brick
+TEST kill_brick $V0 $H0 $B0/${V0}3
+
+echo "B3 is down" >> $M0/file1
+echo "Change dir1 time attributes" > $M0/dir1/dir1_file1
+echo "Entry heal file" > $M0/entry_heal_file1
+mkdir $M0/entry_heal_dir1
+
+# Check xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/dir1/dir1_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1/dir1_file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/entry_heal_dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_dir1
+
+TEST $CLI volume start $V0 force
+$CLI volume heal $V0
+
+# Check xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1/dir1_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1/dir1_file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/entry_heal_dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_dir1
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-ec-rebalance.t b/tests/basic/ctime/ctime-ec-rebalance.t
new file mode 100644
index 00000000000..2b73bcdd103
--- /dev/null
+++ b/tests/basic/ctime/ctime-ec-rebalance.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+#
+# This will test healing of ctime xattr 'trusted.glusterfs.mdata' after add-brick and rebalance
+#
+###
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fallocate.rc
+
+cleanup
+
+#cleate and start volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..5}
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+
+# Create files
+mkdir $M0/dir1
+echo "test data" > $M0/dir1/file1
+
+# Add brick
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{6..8}
+
+#Trigger rebalance
+TEST $CLI volume rebalance $V0 start force
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
+
+#Verify ctime xattr heal on directory
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}6/dir1"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}7/dir1"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}8/dir1"
+
+b6_mdata=$(get_mdata "$B0/${V0}6/dir1")
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "${b6_mdata}" get_mdata $B0/${V0}7/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "${b6_mdata}" get_mdata $B0/${V0}8/dir1
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-glfs-init.c b/tests/basic/ctime/ctime-glfs-init.c
new file mode 100644
index 00000000000..e4f197b8f30
--- /dev/null
+++ b/tests/basic/ctime/ctime-glfs-init.c
@@ -0,0 +1,68 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto err;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto err;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto err;
+    }
+
+    glfs_fini(fs);
+    fs = NULL;
+    return 0;
+err:
+    glfs_fini(fs);
+    fs = NULL;
+
+    return -1;
+}
diff --git a/tests/basic/ctime/ctime-glfs-init.t b/tests/basic/ctime/ctime-glfs-init.t
new file mode 100644
index 00000000000..56d7d6caee0
--- /dev/null
+++ b/tests/basic/ctime/ctime-glfs-init.t
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 ${H0}:$B0/brick{1,2,3};
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0;
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/ctime-glfs-init.c -lgfapi -lpthread
+
+TEST ./$(dirname $0)/ctime-glfs-init ${H0} $V0 $logdir/ctime-glfs-init.log
+
+cleanup_tester $(dirname $0)/ctime-glfs-init
+
+cleanup;
+
diff --git a/tests/basic/ctime/ctime-heal-symlinks.t b/tests/basic/ctime/ctime-heal-symlinks.t
new file mode 100644
index 00000000000..547b1807e94
--- /dev/null
+++ b/tests/basic/ctime/ctime-heal-symlinks.t
@@ -0,0 +1,65 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup;
+
+###############################################################################
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST "echo hello_world > FILE"
+TEST ln -s FILE SOFTLINK
+
+# Remove symlink only (not the .glusterfs entry) and trigger named heal.
+TEST rm -f $B0/${V0}2/SOFTLINK
+TEST stat SOFTLINK
+
+# To heal and clear new-entry mark on source bricks.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT 2 stat -c %h  $B0/${V0}2/SOFTLINK
+EXPECT "hello_world" cat $B0/${V0}2/SOFTLINK
+
+cd -
+cleanup
+###############################################################################
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1  $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST "echo hello_world > FILE"
+TEST ln -s FILE SOFTLINK
+
+# Remove symlink only (not the .glusterfs entry) and trigger named heal.
+TEST rm -f $B0/${V0}2/SOFTLINK
+TEST stat SOFTLINK
+
+# To heal and clear new-entry mark on source bricks.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT 2 stat -c %h  $B0/${V0}2/SOFTLINK
+TEST kill_brick $V0 $H0 $B0/${V0}0
+cd -
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+cd $M0
+EXPECT "hello_world" cat SOFTLINK
+
+cd -
+cleanup
+###############################################################################
diff --git a/tests/basic/ctime/ctime-mdata-legacy-files.t b/tests/basic/ctime/ctime-mdata-legacy-files.t
new file mode 100644
index 00000000000..2e782d5c99d
--- /dev/null
+++ b/tests/basic/ctime/ctime-mdata-legacy-files.t
@@ -0,0 +1,83 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup;
+
+###############################################################################
+#Replica volume
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+#Disable ctime and create file, file doesn't contain "trusted.glusterfs.mdata" xattr
+TEST $CLI volume set $V0 ctime off
+
+TEST "mkdir $M0/DIR"
+TEST "echo hello_world > $M0/DIR/FILE"
+
+#Verify absence of xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}0/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}0/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}1/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}1/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}2/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}2/DIR/FILE"
+
+#Enable ctime
+TEST $CLI volume set $V0 ctime on
+sleep 3
+TEST stat $M0/DIR/FILE
+
+#Verify presence "trusted.glusterfs.mdata" xattr on backend
+#The lookup above should have created xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}0/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}0/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}1/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}1/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}2/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}2/DIR/FILE"
+
+###############################################################################
+#Disperse Volume
+
+TEST $CLI volume create $V1 disperse 3 redundancy 1  $H0:$B0/${V1}{0,1,2}
+TEST $CLI volume set $V1 performance.stat-prefetch off
+TEST $CLI volume start $V1
+
+TEST glusterfs --volfile-id=$V1 --volfile-server=$H0 --entry-timeout=0 $M1;
+
+#Disable ctime and create file, file doesn't contain "trusted.glusterfs.mdata" xattr
+TEST $CLI volume set $V1 ctime off
+TEST "mkdir $M1/DIR"
+TEST "echo hello_world > $M1/DIR/FILE"
+
+#Verify absence of xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}0/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}0/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}1/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}1/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}2/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "" check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}2/DIR/FILE"
+
+#Enable ctime
+TEST $CLI volume set $V1 ctime on
+sleep 3
+TEST stat $M1/DIR/FILE
+
+#Verify presence "trusted.glusterfs.mdata" xattr on backend
+#The lookup above should have created xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}0/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}0/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}1/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}1/DIR/FILE"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}2/DIR"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V1}2/DIR/FILE"
+
+cleanup;
+###############################################################################
diff --git a/tests/basic/ctime/ctime-noatime.t b/tests/basic/ctime/ctime-noatime.t
new file mode 100644
index 00000000000..609ccbd72c1
--- /dev/null
+++ b/tests/basic/ctime/ctime-noatime.t
@@ -0,0 +1,49 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup;
+
+function atime_compare {
+    local atime=$1
+    local file_name=$2
+    local atime1=$(stat -c "%X" $file_name)
+
+    if [ $atime == $atime1 ]
+    then
+        echo "0"
+    else
+        echo "1"
+    fi
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.read-after-open off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.io-cache off
+
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST "echo hello_world > FILE"
+atime1=$(stat -c "%X" FILE)
+
+TEST "cat FILE > /dev/null"
+EXPECT "0" atime_compare $atime1 FILE
+
+sleep 1
+
+TEST $CLI volume set $V0 noatime off
+TEST "cat FILE > /dev/null"
+EXPECT "1" atime_compare $atime1 FILE
+
+cd -
+cleanup
diff --git a/tests/basic/ctime/ctime-readdir.c b/tests/basic/ctime/ctime-readdir.c
new file mode 100644
index 00000000000..8760db29ae8
--- /dev/null
+++ b/tests/basic/ctime/ctime-readdir.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <dirent.h>
+#include <string.h>
+#include <assert.h>
+
+int
+main(int argc, char **argv)
+{
+    DIR *dir = NULL;
+    struct dirent *entry = NULL;
+    int ret = 0;
+    char *path = NULL;
+
+    assert(argc == 2);
+    path = argv[1];
+
+    dir = opendir(path);
+    if (!dir) {
+        printf("opendir(%s) failed.\n", path);
+        return -1;
+    }
+
+    while ((entry = readdir(dir)) != NULL) {
+    }
+    if (dir)
+        closedir(dir);
+
+    return ret;
+}
diff --git a/tests/basic/ctime/ctime-readdir.t b/tests/basic/ctime/ctime-readdir.t
new file mode 100644
index 00000000000..4564fc1b667
--- /dev/null
+++ b/tests/basic/ctime/ctime-readdir.t
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 ${H0}:$B0/brick{1,2,3};
+TEST $CLI volume set $V0 performance.stat-prefetch on
+TEST $CLI volume set $V0 performance.readdir-ahead off
+TEST $CLI volume start $V0;
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+TEST mkdir $M0/dir0
+TEST "echo hello_world > $M0/dir0/FILE"
+
+ctime1=$(stat -c %Z $M0/dir0/FILE)
+echo "Mount change time: $ctime1"
+
+sleep 2
+
+#Write to back end directly to modify ctime of backend file
+TEST "echo write_from_backend >> $B0/brick1/dir0/FILE"
+TEST "echo write_from_backend >> $B0/brick2/dir0/FILE"
+TEST "echo write_from_backend >> $B0/brick3/dir0/FILE"
+echo "Backend change time"
+echo "brick1: $(stat -c %Z $B0/brick1/dir0/FILE)"
+echo "brick2: $(stat -c %Z $B0/brick2/dir0/FILE)"
+echo "brick3: $(stat -c %Z $B0/brick3/dir0/FILE)"
+
+#Stop and start to hit the case of no inode for readdir
+TEST umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+TEST build_tester $(dirname $0)/ctime-readdir.c
+
+#Do readdir
+TEST ./$(dirname $0)/ctime-readdir $M0/dir0
+
+EXPECT "$ctime1" stat -c %Z $M0/dir0/FILE
+echo "Mount change time after readdir $(stat -c %Z $M0/dir0/FILE)"
+
+cleanup_tester $(dirname $0)/ctime-readdir
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-rep-heal.t b/tests/basic/ctime/ctime-rep-heal.t
new file mode 100644
index 00000000000..20517c74971
--- /dev/null
+++ b/tests/basic/ctime/ctime-rep-heal.t
@@ -0,0 +1,70 @@
+#!/bin/bash
+#
+# This will test self healing of ctime xattr 'trusted.glusterfs.mdata'
+#
+###
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup
+
+#cleate and start volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1..3}
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+
+# Create files
+mkdir $M0/dir1
+echo "Initial content" > $M0/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+# Kill brick
+TEST kill_brick $V0 $H0 $B0/${V0}3
+
+echo "B3 is down" >> $M0/file1
+echo "Change dir1 time attributes" > $M0/dir1/dir1_file1
+echo "Entry heal file" > $M0/entry_heal_file1
+mkdir $M0/entry_heal_dir1
+
+# Check xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/dir1/dir1_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1/dir1_file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '2' get_mdata_count $B0/${V0}{1..3}/entry_heal_dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_dir1
+
+TEST $CLI volume start $V0 force
+$CLI volume heal $V0
+
+# Check xattr
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/dir1/dir1_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/dir1/dir1_file1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_file1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '3' get_mdata_count $B0/${V0}{1..3}/entry_heal_dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '1' get_mdata_uniq_count $B0/${V0}{1..3}/entry_heal_dir1
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-rep-rebalance.t b/tests/basic/ctime/ctime-rep-rebalance.t
new file mode 100644
index 00000000000..866cf87e6cb
--- /dev/null
+++ b/tests/basic/ctime/ctime-rep-rebalance.t
@@ -0,0 +1,41 @@
+#!/bin/bash
+#
+# This will test healing of ctime xattr 'trusted.glusterfs.mdata' after add-brick and rebalance
+#
+###
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup
+
+#cleate and start volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0..5}
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+
+# Create files
+mkdir $M0/dir1
+
+# Add brick
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{6..8}
+
+#Trigger rebalance
+TEST $CLI volume rebalance $V0 start force
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
+
+#Verify ctime xattr heal on directory
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}6/dir1"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}7/dir1"
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.glusterfs.mdata' check_for_xattr 'trusted.glusterfs.mdata' "$B0/${V0}8/dir1"
+
+b6_mdata=$(get_mdata "$B0/${V0}6/dir1")
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "${b6_mdata}" get_mdata $B0/${V0}7/dir1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "${b6_mdata}" get_mdata $B0/${V0}8/dir1
+
+cleanup;
diff --git a/tests/basic/ctime/ctime-utimesat.t b/tests/basic/ctime/ctime-utimesat.t
new file mode 100644
index 00000000000..540e57aec83
--- /dev/null
+++ b/tests/basic/ctime/ctime-utimesat.t
@@ -0,0 +1,28 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.read-after-open off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.io-cache off
+
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+touch $M0/FILE
+
+atime=$(stat -c "%.X" $M0/FILE)
+EXPECT $atime stat -c "%.Y" $M0/FILE
+EXPECT $atime stat -c "%.Z" $M0/FILE
+
+cleanup
diff --git a/tests/basic/distribute/brick-down.t b/tests/basic/distribute/brick-down.t
new file mode 100644
index 00000000000..522ccc07210
--- /dev/null
+++ b/tests/basic/distribute/brick-down.t
@@ -0,0 +1,83 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../common-utils.rc
+. $(dirname $0)/../../dht.rc
+
+# Test 1 overview:
+# ----------------
+# Test whether lookups are sent after a brick comes up again
+#
+# 1. Create a 3 brick pure distribute volume
+# 2. Fuse mount the volume so the layout is set on the root
+# 3. Kill one brick and try to create a directory which hashes to that brick.
+#    It should fail with EIO.
+# 4. Restart the brick that was killed.
+# 5. Do not remount the volume. Try to create the same directory as in step 3.
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{1..3}
+TEST $CLI volume start $V0
+
+# We want the lookup to reach DHT
+TEST $CLI volume set $V0 performance.stat-prefetch off
+
+# Mount using FUSE and lookup the mount so a layout is set on the brick root
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+
+ls $M0/
+
+TEST mkdir $M0/level1
+
+# Find a dirname that will hash to the brick we are going to kill
+hashed=$V0-client-1
+TEST dht_first_filename_with_hashsubvol "$hashed" $M0 "dir-"
+roottestdir=$fn_return_val
+
+hashed=$V0-client-1
+TEST dht_first_filename_with_hashsubvol "$hashed" $M0/level1 "dir-"
+level1testdir=$fn_return_val
+
+
+TEST kill_brick $V0 $H0 $B0/$V0-2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" brick_up_status $V0 $H0 $B0/$V0-2
+
+TEST $CLI volume status $V0
+
+
+# Unmount and mount the volume again so dht has an incomplete in memory layout
+
+umount -f $M0
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+
+
+mkdir $M0/$roottestdir
+TEST [ $? -ne 0 ]
+
+mkdir $M0/level1/$level1testdir
+TEST [ $? -ne 0 ]
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/$V0-2
+
+#$CLI volume status
+
+# It takes a while for the client to reconnect to the brick
+sleep 5
+
+
+mkdir $M0/$roottestdir
+TEST [ $? -eq 0 ]
+
+mkdir $M0/$level1/level1testdir
+TEST [ $? -eq 0 ]
+
+# Cleanup
+cleanup
+
+
diff --git a/tests/basic/distribute/bug-1265677-use-readdirp.t b/tests/basic/distribute/bug-1265677-use-readdirp.t
index 5b274d62667..eef8affc8b9 100644
--- a/tests/basic/distribute/bug-1265677-use-readdirp.t
+++ b/tests/basic/distribute/bug-1265677-use-readdirp.t
@@ -8,8 +8,7 @@
 cleanup
 TEST glusterd
 TEST pidof glusterd
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..1}
-TEST $CLI volume heal $V0 disable
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0..1}
 TEST $CLI volume set $V0 nfs.disable yes
 TEST $CLI volume set $V0 dht.force-readdirp yes
 TEST $CLI volume set $V0 performance.readdir-ahead off
diff --git a/tests/basic/distribute/debug-xattrs.t b/tests/basic/distribute/debug-xattrs.t
new file mode 100644
index 00000000000..6d87c0e8671
--- /dev/null
+++ b/tests/basic/distribute/debug-xattrs.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../../common-utils.rc
+
+# Test overview: Test the virtual xattrs dht provides for debugging
+
+# Test 1 : "dht.file.hashed-subvol.<filename>"
+# Get the hashed subvolume for file1 in dir1 using xattr
+# Create file1 in dir1
+# Check if the file is created in the brick returned by xattr
+
+hashdebugxattr="dht.file.hashed-subvol."
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{0..3}
+TEST $CLI volume start $V0
+
+# Mount using FUSE and create a file
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+# Test 1 : "dht.file.hashed-subvol.<filename>"
+# Get the hashed subvolume for file1 in dir1 using xattr
+# Create file1 in dir1
+# Check if the file is created in the brick returned by xattr
+# Create a directory on $M0
+
+TEST mkdir $M0/dir1
+
+xattrname=$hashdebugxattr"file1"
+
+hashed=$(getfattr --only-values -n "$xattrname" $M0/dir1)
+
+# Get the brick path for $hashed
+brickpath=$(cat "$M0/.meta/graphs/active/$hashed/options/remote-subvolume")
+brickpath=$brickpath"/dir1/file1"
+
+# Create the file for which we checked the xattr
+TEST touch $M0/dir1/file1
+TEST stat $brickpath
+
+# Non-existent directory
+TEST ! getfattr --only-values -n "$xattrname" $M0/dir2
+
+
+# Cleanup
+cleanup
+
diff --git a/tests/basic/distribute/dir-heal.t b/tests/basic/distribute/dir-heal.t
new file mode 100644
index 00000000000..851f765b245
--- /dev/null
+++ b/tests/basic/distribute/dir-heal.t
@@ -0,0 +1,145 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../../common-utils.rc
+
+# Test 1 overview:
+# ----------------
+#
+# 1. Kill one brick of the volume.
+# 2. Create directories and change directory properties.
+# 3. Bring up the brick and access the directory
+# 4. Check the permissions and xattrs on the backend
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{1..3}
+TEST $CLI volume start $V0
+
+# We want the lookup to reach DHT
+TEST $CLI volume set $V0 performance.stat-prefetch off
+
+# Mount using FUSE , kill a brick and create directories
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+
+ls $M0/
+cd $M0
+
+TEST kill_brick $V0 $H0 $B0/$V0-1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" brick_up_status $V0 $H0 $B0/$V0-1
+
+TEST mkdir dir{1..4}
+
+# No change for dir1
+# Change permissions for dir2
+# Set xattr on dir3
+# Change permissions and set xattr on dir4
+
+TEST chmod 777 $M0/dir2
+
+TEST setfattr -n "user.test" -v "test" $M0/dir3
+
+TEST chmod 777 $M0/dir4
+TEST setfattr -n "user.test" -v "test" $M0/dir4
+
+
+# Start all bricks
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/$V0-1
+
+#$CLI volume status
+
+# It takes a while for the client to reconnect to the brick
+sleep 5
+
+stat $M0/dir* > /dev/null
+
+# Check that directories have been created on the brick that was killed
+
+TEST ls $B0/$V0-1/dir1
+
+TEST ls $B0/$V0-1/dir2
+EXPECT "777" stat -c "%a" $B0/$V0-1/dir2
+
+TEST ls $B0/$V0-1/dir3
+EXPECT "test" getfattr -n "user.test" --absolute-names --only-values $B0/$V0-1/dir3
+
+
+TEST ls $B0/$V0-1/dir4
+EXPECT "777" stat -c "%a" $B0/$V0-1/dir4
+EXPECT "test" getfattr -n "user.test" --absolute-names --only-values $B0/$V0-1/dir4
+
+
+TEST rm -rf $M0/*
+
+cd
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+
+# Test 2 overview:
+# ----------------
+# 1. Create directories with all bricks up.
+# 2. Kill a brick and change directory properties and set user xattr.
+# 2. Bring up the brick and access the directory
+# 3. Check the permissions and xattrs on the backend
+
+
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+
+ls $M0/
+cd $M0
+TEST mkdir dir{1..4}
+
+TEST kill_brick $V0 $H0 $B0/$V0-1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" brick_up_status $V0 $H0 $B0/$V0-1
+
+# No change for dir1
+# Change permissions for dir2
+# Set xattr on dir3
+# Change permissions and set xattr on dir4
+
+TEST chmod 777 $M0/dir2
+
+TEST setfattr -n "user.test" -v "test" $M0/dir3
+
+TEST chmod 777 $M0/dir4
+TEST setfattr -n "user.test" -v "test" $M0/dir4
+
+
+# Start all bricks
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/$V0-1
+
+#$CLI volume status
+
+# It takes a while for the client to reconnect to the brick
+sleep 5
+
+stat $M0/dir* > /dev/null
+
+# Check directories on the brick that was killed
+
+TEST ls $B0/$V0-1/dir2
+EXPECT "777" stat -c "%a" $B0/$V0-1/dir2
+
+TEST ls $B0/$V0-1/dir3
+EXPECT "test" getfattr -n "user.test" --absolute-names --only-values $B0/$V0-1/dir3
+
+
+TEST ls $B0/$V0-1/dir4
+EXPECT "777" stat -c "%a" $B0/$V0-1/dir4
+EXPECT "test" getfattr -n "user.test" --absolute-names --only-values $B0/$V0-1/dir4
+cd
+
+
+# Cleanup
+cleanup
+
diff --git a/tests/basic/distribute/file-create.t b/tests/basic/distribute/file-create.t
new file mode 100644
index 00000000000..41b662eefe2
--- /dev/null
+++ b/tests/basic/distribute/file-create.t
@@ -0,0 +1,120 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../common-utils.rc
+. $(dirname $0)/../../dht.rc
+
+# Test overview: Test file creation in various scenarios
+
+
+# Test 1 : "dht.file.hashed-subvol.<filename>"
+# Get the hashed subvolume for file1 in dir1 using xattr
+# Create file1 in dir1
+# Check if the file is created in the brick returned by xattr
+
+hashdebugxattr="dht.file.hashed-subvol."
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+# We want fixed size bricks to test min-free-disk
+
+# Create 2 loop devices, one per brick.
+TEST   truncate -s 25M $B0/brick1
+TEST   truncate -s 25M $B0/brick2
+
+TEST   L1=`SETUP_LOOP $B0/brick1`
+TEST   MKFS_LOOP $L1
+
+TEST   L2=`SETUP_LOOP $B0/brick2`
+TEST   MKFS_LOOP $L2
+
+
+TEST   mkdir -p $B0/${V0}{1,2}
+
+TEST   MOUNT_LOOP $L1 $B0/${V0}1
+TEST   MOUNT_LOOP $L2 $B0/${V0}2
+
+
+# Create a plain distribute volume with 2 subvols.
+TEST   $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+TEST   $CLI volume start $V0;
+EXPECT "Started" volinfo_field $V0 'Status';
+
+TEST   $CLI volume set $V0 cluster.min-free-disk 40%
+#TEST   $CLI volume set $V0 client-log-level DEBUG
+
+# Mount using FUSE and create a file
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+TEST mkdir $M0/dir1
+
+######################################################
+# Test 1 : Test file creation on correct hashed subvol
+######################################################
+
+hashed="$V0-client-0"
+TEST dht_first_filename_with_hashsubvol "$hashed" $M0/dir1 "big-"
+firstfile=$fn_return_val
+
+#Create a large file to fill up $hashed past the min-free-disk limits
+TEST  dd if=/dev/zero of=$M0/dir1/$firstfile bs=1M count=15
+
+brickpath_0=$(cat "$M0/.meta/graphs/active/$hashed/options/remote-subvolume")
+brickpath_1=$(cat "$M0/.meta/graphs/active/$V0-client-1/options/remote-subvolume")
+
+TEST stat "$brickpath_0/dir1/$firstfile"
+EXPECT "0" is_dht_linkfile "$brickpath_0/dir1/$firstfile"
+
+
+######################################################
+# Test 2: Create a file which hashes to the subvol which has crossed
+# the min-free-disk limit. It should be created on the other subvol
+######################################################
+
+# DHT only checks disk usage every second. Create a new file and introduce a
+# delay here to ensure DHT updates the in memory disk usage
+sleep 2
+TEST  dd if=/dev/zero of=$M0/dir1/file-2 bs=1024 count=1
+
+# Find a file that will hash to $hash_subvol
+TEST dht_first_filename_with_hashsubvol $hashed $M0/dir1 "newfile-"
+newfile=$fn_return_val
+echo $newfile
+
+# Create $newfile - it should be created on the other subvol as its hash subvol
+# has crossed the min-free-disk limit
+TEST  dd if=/dev/zero of=$M0/dir1/$newfile bs=1024 count=20
+TEST stat "$brickpath_0/dir1/$newfile"
+EXPECT "1" is_dht_linkfile "$brickpath_0/dir1/$newfile"
+
+
+#TEST rm -rf $M0/dir1/$firstfile
+#TEST rm -rf $M0/dir1/$newfile
+
+
+######################################################
+# Test 3: Test dht_filter_loc_subvol_key
+######################################################
+
+TEST dht_first_filename_with_hashsubvol $V0-client-1 $M0/dir1 "filter-"
+newfile=$fn_return_val
+echo $newfile
+TEST dd if=/dev/zero of="$M0/dir1/$newfile@$V0-dht:$hashed" bs=1024 count=20
+TEST stat $M0/dir1/$newfile
+TEST stat "$brickpath_0/dir1/$newfile"
+EXPECT "1" is_dht_linkfile "$brickpath_1/dir1/$newfile"
+
+
+force_umount $M0
+TEST $CLI volume stop $V0
+UMOUNT_LOOP ${B0}/${V0}{1,2}
+rm -f ${B0}/brick{1,2}
+
+
+# Cleanup
+cleanup
+
diff --git a/tests/basic/distribute/file-rename.t b/tests/basic/distribute/file-rename.t
new file mode 100644
index 00000000000..63111b8ad8f
--- /dev/null
+++ b/tests/basic/distribute/file-rename.t
@@ -0,0 +1,1021 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../../common-utils.rc
+
+# Test overview:
+# Test all combinations of src-hashed/src-cached/dst-hashed/dst-cached
+
+hashdebugxattr="dht.file.hashed-subvol."
+
+function get_brick_index {
+        local inpath=$1
+        brickroot=$(getfattr -m . -n trusted.glusterfs.pathinfo $inpath | tr ' ' '\n' | sed -n 's/<POSIX(\(.*\)):.*:.*>.*/\1/p')
+        echo ${brickroot:(-1)}
+}
+
+function get_brick_path_for_subvol {
+        local in_subvol=$1
+        local in_brickpath
+
+        in_brickpath=$(cat "$M0/.meta/graphs/active/$in_subvol/options/remote-subvolume")
+        echo $in_brickpath
+
+}
+
+#Checks that file exists only on hashed and/or cached
+function file_existence_check
+{
+        local in_file_path=$1
+        local in_hashed=$2
+        local in_cached=$3
+        local in_client_subvol
+        local in_brickpath
+        local ret
+
+        for i in {0..3}
+        do
+               in_client_subvol="$V0-client-$i"
+               in_brickpath=$(cat "$M0/.meta/graphs/active/$in_client_subvol/options/remote-subvolume")
+               stat "$in_brickpath/$in_file_path" 2>/dev/null
+               ret=$?
+               # Either the linkto or the data file must exist on the hashed
+               if [ "$in_client_subvol" == "$in_hashed" ]; then
+                        if [ $ret -ne 0 ]; then
+                            return 1
+                        fi
+                        continue
+               fi
+
+               # If the cached is non-null, we expect the file to exist on it
+               if [ "$in_client_subvol" == "$in_cached" ]; then
+                        if [ $ret -ne 0 ]; then
+                            return 1
+                        fi
+                        continue
+               fi
+
+               if [ $ret -eq 0 ]; then
+                  return 2
+               fi
+        done
+        return 0
+}
+
+
+# Check if file exists on any of the bricks of the volume
+function file_does_not_exist
+{
+        local inpath=$1
+        for i in `seq 0 3`
+        do
+                file_path=$B0/$V0-$i/$inpath
+                if [ -f "$file_path" ]; then
+                        echo "1"
+                        return 1
+                fi
+        done
+        return 0
+}
+
+
+# Input: filename dirpath
+function get_hash_subvol
+{
+      hash_subvol=$(getfattr --only-values -n "$hashdebugxattr$1" $2 2>/dev/null)
+}
+
+
+
+# Find the first filename that hashes to a subvol
+# other than $1
+
+function first_filename_with_diff_hashsubvol
+{
+        local in_subvol=$1
+        local in_path=$2
+        local file_pattern=$3
+        local in_hash_subvol
+
+        for i in {1..100}
+        do
+               dstfilename="$file_pattern$i"
+               in_hash_subvol=$(get_hash_subvol "$dstfilename" "$in_path")
+               echo $in_hash_subvol
+               if [ "$in_subvol" != "$in_hash_subvol" ]; then
+                        return 0
+               fi
+        done
+        return 1
+}
+
+# Find the first filename that hashes to the same subvol
+# as $1
+function first_filename_with_same_hashsubvol
+{
+        local in_subvol=$1
+        local in_path=$2
+        local in_hash_subvol
+        local file_pattern=$3
+
+        for i in {1..100}
+        do
+               dstfilename="$file_pattern$i"
+               get_hash_subvol "$dstfilename" "$in_path"
+               in_hash_subvol=$hash_subvol
+#               echo $in_hash_subvol
+               if [ "$in_subvol" == "$in_hash_subvol" ]; then
+                        return 0
+               fi
+        done
+        return 1
+}
+
+function file_is_linkto
+{
+    local  brick_filepath=$1
+
+    test=$(stat $brick_filepath 2>&1)
+    if [ $? -ne 0 ]; then
+        echo "2"
+        return
+    fi
+
+    test=$(getfattr -n trusted.glusterfs.dht.linkto -e text $brick_filepath 2>&1)
+
+    if [ $? -eq 0 ]; then
+       echo "1"
+    else
+       echo "0"
+    fi
+}
+
+
+
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+
+# We need at least 4 bricks to test all combinations of hashed and
+# cached files
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{0..3}
+TEST $CLI volume start $V0
+
+# Mount using FUSE
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+
+################################################################
+# The first set of tests are those where the Dst file does not exist
+# dst-cached = NULL
+#
+###############################################################
+
+################### Test 1 ####################################
+#
+# src-hashed = src-cached = dst-hashed
+# dst-cached = null
+# src-file = src-1
+
+echo " **** Test 1 **** "
+
+src_file="src-1"
+
+TEST mkdir $M0/test-1
+TEST touch $M0/test-1/$src_file
+
+TEST get_hash_subvol $src_file $M0/test-1
+src_hashed=$hash_subvol
+#echo "Hashed subvol for $src_file: " $src_hashed
+
+# Find a file name that hashes to the same subvol as $src_file
+TEST first_filename_with_same_hashsubvol "$src_hashed" "$M0/test-1" "dst-"
+#echo "dst-file name: " $dstfilename
+dst_hashed=$src_hashed
+
+src_hash_brick=$(get_brick_path_for_subvol $src_hashed)
+
+echo "Renaming $src_file to $dstfilename"
+
+TEST mv $M0/test-1/$src_file $M0/test-1/$dstfilename
+
+# Expected:
+# dst file is accessible from the mount point
+# dst file exists only on the hashed brick.
+# no linkto files on any bricks
+# src files do not exist
+
+
+TEST stat $M0/test-1/$dstfilename 2>/dev/null
+TEST file_existence_check test-1/$dstfilename $src_hashed
+TEST file_does_not_exist test-1/$src_file
+EXPECT "0" file_is_linkto $src_hash_brick/test-1/$dstfilename
+
+
+################### Test 2 ####################################
+
+# src-hashed = src-cached != dst-hashed
+# dst-cached = null
+
+echo " **** Test 2 **** "
+
+src_file="src-1"
+
+TEST mkdir $M0/test-2
+TEST touch $M0/test-2/$src_file
+
+TEST get_hash_subvol $src_file $M0/test-2
+src_hashed=$hash_subvol
+#echo "Hashed subvol for $src_file: " $src_hashed
+
+# Find a file name that hashes to a diff hashed subvol than $src_file
+TEST first_filename_with_diff_hashsubvol "$src_hashed" "$M0/test-2" "dst-"
+echo "dst-file name: " $dstfilename
+TEST get_hash_subvol $dstfilename $M0/test-2
+dst_hashed=$hash_subvol
+
+src_hash_brick=$(get_brick_path_for_subvol $src_hashed)
+dst_hash_brick=$(get_brick_path_for_subvol $dst_hashed)
+
+echo "Renaming $src_file to $dstfilename"
+
+TEST mv $M0/test-2/$src_file $M0/test-2/$dstfilename
+
+
+# Expected:
+# dst file is accessible from the mount point
+# dst data file on src_hashed and dst linkto file on dst_hashed
+# src files do not exist
+
+
+TEST stat $M0/test-2/$dstfilename 2>/dev/null
+TEST file_existence_check test-2/$dstfilename $dst_hashed $src_hashed
+TEST file_does_not_exist test-2/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-2/$dstfilename
+EXPECT "0" file_is_linkto $src_hash_brick/test-2/$dstfilename
+
+################### Test 3 ####################################
+
+# src-hashed = dst-hashed != src-cached
+
+echo " **** Test 3 **** "
+
+src_file0="abc-1"
+
+# 1. Create src file with src_cached != src_hashed
+TEST mkdir $M0/test-3
+TEST touch $M0/test-3/$src_file0
+
+TEST get_hash_subvol $src_file0 $M0/test-3
+src_cached=$hash_subvol
+#echo "Hashed subvol for $src_file0: " $src_cached
+
+# Find a file name that hashes to a diff hashed subvol than $src_file0
+TEST first_filename_with_diff_hashsubvol "$src_cached" "$M0/test-3" "src-"
+echo "dst-file name: " $dstfilename
+src_file=$dstfilename
+
+TEST mv $M0/test-3/$src_file0 $M0/test-3/$src_file
+
+TEST get_hash_subvol $src_file $M0/test-3
+src_hashed=$hash_subvol
+
+
+# 2. Rename src to dst
+TEST first_filename_with_same_hashsubvol "$src_hashed" "$M0/test-3" "dst-"
+#echo "dst-file name: " $dstfilename
+
+src_hash_brick=$(get_brick_path_for_subvol $src_hashed)
+src_cached_brick=$(get_brick_path_for_subvol $src_cached)
+
+echo "Renaming $src_file to $dstfilename"
+
+TEST mv $M0/test-3/$src_file $M0/test-3/$dstfilename
+
+
+# Expected:
+# dst file is accessible from the mount point
+TEST stat $M0/test-3/$dstfilename 2>/dev/null
+
+# src file does not exist
+TEST file_does_not_exist test-3/$src_file
+
+# dst linkto file on src_hashed and dst data file on src_cached
+TEST file_existence_check test-3/$dstfilename $src_hashed $src_cached
+
+EXPECT "1" file_is_linkto $src_hash_brick/test-3/$dstfilename
+EXPECT "0" file_is_linkto $src_cached_brick/test-3/$dstfilename
+
+
+
+################### Test 4 ####################################
+
+# src-cached = dst-hashed != src-hashed
+
+echo " **** Test 4 **** "
+
+src_file0="abc-1"
+
+# 1. Create src file with src_cached != src_hashed
+TEST mkdir $M0/test-4
+TEST touch $M0/test-4/$src_file0
+
+TEST get_hash_subvol $src_file0 $M0/test-4
+src_cached=$hash_subvol
+#echo "Hashed subvol for $src_file0: " $src_cached
+
+# Find a file name that hashes to a diff hashed subvol than $src_file0
+TEST first_filename_with_diff_hashsubvol "$src_cached" "$M0/test-4" "src-"
+src_file=$dstfilename
+
+TEST mv $M0/test-4/$src_file0 $M0/test-4/$src_file
+
+TEST get_hash_subvol $src_file $M0/test-4
+src_hashed=$hash_subvol
+
+
+# 2. Rename src to dst
+TEST first_filename_with_same_hashsubvol "$src_cached" "$M0/test-4" "dst-"
+#echo "dst-file name: " $dstfilename
+
+src_hash_brick=$(get_brick_path_for_subvol $src_hashed)
+src_cached_brick=$(get_brick_path_for_subvol $src_cached)
+
+echo "Renaming $src_file to $dstfilename"
+
+TEST mv $M0/test-4/$src_file $M0/test-4/$dstfilename
+
+# Expected:
+# dst file is accessible from the mount point
+TEST stat $M0/test-4/$dstfilename 2>/dev/null
+
+# src file does not exist
+TEST file_does_not_exist test-4/$src_file
+
+# dst linkto file on src_hashed and dst data file on src_cached
+TEST file_existence_check test-4/$dstfilename $src_cached
+
+EXPECT "0" file_is_linkto $src_cached_brick/test-4/$dstfilename
+
+
+################### Test 5 ####################################
+
+# src-cached != src-hashed
+# src-hashed != dst-hashed
+# src-cached != dst-hashed
+
+
+echo " **** Test 5 **** "
+
+# 1. Create src and dst files
+
+TEST mkdir $M0/test-5
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-5" "abc-"
+src_file0=$dstfilename
+
+TEST touch $M0/test-5/$src_file0
+
+TEST get_hash_subvol $src_file0 $M0/test-5
+src_cached=$hash_subvol
+#echo "Hashed subvol for $src_file0: " $src_cached
+
+# Find a file name that hashes to a diff hashed subvol than $src_file0
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-5" "src-"
+src_file=$dstfilename
+
+TEST mv $M0/test-5/$src_file0 $M0/test-5/$src_file
+
+TEST get_hash_subvol $src_file $M0/test-5
+src_hashed=$hash_subvol
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-5" "dst-"
+#echo "dst-file name: " $dstfilename
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-2")
+src_cached_brick=$(get_brick_path_for_subvol $src_cached)
+
+
+# 2. Rename src to dst
+echo "Renaming $src_file to $dstfilename"
+
+TEST mv $M0/test-5/$src_file $M0/test-5/$dstfilename
+
+
+# 3. Validate
+
+# Expected:
+# dst file is accessible from the mount point
+TEST stat $M0/test-5/$dstfilename 2>/dev/null
+
+# src file does not exist
+TEST file_does_not_exist test-5/$src_file
+
+# dst linkto file on src_hashed and dst data file on src_cached
+
+EXPECT "0" file_is_linkto $src_cached_brick/test-5/$dstfilename
+EXPECT "1" file_is_linkto $dst_hash_brick/test-5/$dstfilename
+
+
+########################################################################
+#
+# The Dst file exists
+#
+########################################################################
+
+################### Test 6 ####################################
+
+# src_hash = src_cached
+# dst_hash = dst_cached
+# dst_hash = src_hash
+
+
+TEST mkdir $M0/test-6
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-6" "src-"
+src_file=$dstfilename
+
+TEST touch $M0/test-6/$src_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-6" "dst-"
+dst_file=$dstfilename
+
+TEST touch $M0/test-6/$dst_file
+
+
+# 2. Rename src to dst
+
+TEST mv $M0/test-6/$src_file $M0/test-6/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-6/$dst_file 2>/dev/null
+TEST file_existence_check test-6/$dst_file "$V0-client-0"
+TEST file_does_not_exist test-6/$src_file
+EXPECT "0" file_is_linkto $dst_hash_brick/test-6/$dst_file
+
+
+################### Test 7 ####################################
+
+# src_hash = src_cached
+# dst_hash = dst_cached
+# dst_hash != src_hash
+
+
+echo " **** Test 7 **** "
+
+TEST mkdir $M0/test-7
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-7" "src-"
+src_file=$dstfilename
+
+TEST touch $M0/test-7/$src_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-7" "dst-"
+dst_file=$dstfilename
+
+TEST touch $M0/test-7/$dst_file
+
+
+# 2. Rename src to dst
+
+TEST mv $M0/test-7/$src_file $M0/test-7/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-1")
+src_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-7/$dst_file 2>/dev/null
+TEST file_existence_check test-7/$dst_file "$V0-client-1" "$V0-client-0"
+TEST file_does_not_exist test-7/$src_file
+
+EXPECT "0" file_is_linkto $src_hash_brick/test-7/$dst_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-7/$dst_file
+
+
+################### Test 8 ####################################
+
+# src_hash = src_cached
+# dst_hash != dst_cached
+# dst_hash != src_hash
+# dst_cached != src_hash
+
+echo " **** Test 8 **** "
+
+TEST mkdir $M0/test-8
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-8" "src-"
+src_file=$dstfilename
+TEST touch $M0/test-8/$src_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-8" "dst0-"
+dst_file0=$dstfilename
+TEST touch $M0/test-8/$dst_file0
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-8" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-8/$dst_file0  $M0/test-8/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-8/$src_file  $M0/test-8/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-2")
+src_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-8/$dst_file 2>/dev/null
+TEST file_existence_check test-8/$dst_file "$V0-client-2" "$V0-client-0"
+TEST file_does_not_exist test-8/$src_file
+
+EXPECT "0" file_is_linkto $src_hash_brick/test-8/$dst_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-8/$dst_file
+
+################### Test 9 ####################################
+
+# src_hash = src_cached = dst_hash
+# dst_hash != dst_cached
+
+echo " **** Test 9 **** "
+
+TEST mkdir $M0/test-9
+
+
+# 1. Create src and dst files
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-9" "src-"
+src_file=$dstfilename
+TEST touch $M0/test-9/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-9" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-9/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-9" "dst-"
+dst_file=$dstfilename
+
+TEST mv $M0/test-9/$dst0_file $M0/test-9/$dst_file
+
+# 2. Rename the file
+
+mv $M0/test-9/$src_file  $M0/test-9/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-9/$dst_file 2>/dev/null
+TEST file_existence_check test-9/$dst_file "$V0-client-0"
+TEST file_does_not_exist test-9/$src_file
+EXPECT "0" file_is_linkto $dst_hash_brick/test-9/$dst_file
+
+
+################### Test 10 ####################################
+
+# src_hash = src_cached = dst_cached
+# dst_hash != dst_cached
+
+echo " **** Test 10 **** "
+
+TEST mkdir $M0/test-10
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-10" "src-"
+src_file=$dstfilename
+TEST touch $M0/test-10/$src_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-10" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-10/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-10" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-10/$dst0_file  $M0/test-10/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-10/$src_file  $M0/test-10/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-1")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-10/$dst_file 2>/dev/null
+TEST file_existence_check test-10/$dst_file "$V0-client-1" "$V0-client-0"
+TEST file_does_not_exist test-10/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-10/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-10/$dst_file
+
+
+################### Test 11 ####################################
+
+# src_hash != src_cached
+# dst_hash = dst_cached = src_cached
+
+echo " **** Test 11 **** "
+
+TEST mkdir $M0/test-11
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-11" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-11/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-11" "src-"
+src_file=$dstfilename
+
+mv $M0/test-11/$src0_file  $M0/test-11/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-11" "dst-"
+dst_file=$dstfilename
+TEST touch $M0/test-11/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-11/$src_file  $M0/test-11/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-11/$dst_file 2>/dev/null
+TEST file_existence_check test-11/$dst_file "$V0-client-0"
+TEST file_does_not_exist test-11/$src_file
+EXPECT "0" file_is_linkto $dst_hash_brick/test-11/$dst_file
+
+
+################### Test 12 ####################################
+
+# src_hash != src_cached
+# dst_hash = dst_cached = src_hash
+
+echo " **** Test 12 **** "
+
+TEST mkdir $M0/test-12
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-12" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-12/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-12" "src-"
+src_file=$dstfilename
+
+mv $M0/test-12/$src0_file  $M0/test-12/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-12" "dst-"
+dst_file=$dstfilename
+TEST touch $M0/test-12/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-12/$src_file  $M0/test-12/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-1")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-12/$dst_file 2>/dev/null
+TEST file_existence_check test-12/$dst_file "$V0-client-1" "$V0-client-0"
+TEST file_does_not_exist test-12/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-12/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-12/$dst_file
+
+################### Test 13 ####################################
+
+# src_hash != src_cached
+# dst_hash = dst_cached
+# dst_hash != src_cached
+# dst_hash != src_hash
+
+echo " **** Test 13 **** "
+
+TEST mkdir $M0/test-13
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-13" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-13/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-13" "src-"
+src_file=$dstfilename
+
+mv $M0/test-13/$src0_file  $M0/test-13/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-13" "dst-"
+dst_file=$dstfilename
+TEST touch $M0/test-13/$dst_file
+
+# 2. Rename the file
+
+mv $M0/test-13/$src_file  $M0/test-13/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-2")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-13/$dst_file 2>/dev/null
+TEST file_existence_check test-13/$dst_file "$V0-client-2" "$V0-client-0"
+TEST file_does_not_exist test-13/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-13/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-13/$dst_file
+
+
+################### Test 14 ####################################
+
+# src_hash != src_cached
+# dst_hash = src_hash
+# dst_cached = src_cached
+
+echo " **** Test 14 **** "
+
+TEST mkdir $M0/test-14
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-14" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-14/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-14" "src-"
+src_file=$dstfilename
+
+mv $M0/test-14/$src0_file  $M0/test-14/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-14" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-14/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-14" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-14/$dst0_file  $M0/test-14/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-14/$src_file  $M0/test-14/$dst_file
+
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-1")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-14/$dst_file 2>/dev/null
+TEST file_existence_check test-14/$dst_file "$V0-client-1" "$V0-client-0"
+TEST file_does_not_exist test-14/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-14/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-14/$dst_file
+
+################### Test 15 ####################################
+
+# src_hash != src_cached
+# dst_hash != src_hash
+# dst_hash != src_cached
+# dst_cached = src_cached
+
+echo " **** Test 15 **** "
+
+TEST mkdir $M0/test-15
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-15" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-15/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-15" "src-"
+src_file=$dstfilename
+
+mv $M0/test-15/$src0_file  $M0/test-15/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-15" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-15/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-15" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-15/$dst0_file  $M0/test-15/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-15/$src_file  $M0/test-15/$dst_file
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-2")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-15/$dst_file 2>/dev/null
+TEST file_existence_check test-15/$dst_file "$V0-client-2" "$V0-client-0"
+TEST file_does_not_exist test-15/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-15/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-15/$dst_file
+
+
+
+################### Test 16 ####################################
+
+# src_hash != src_cached
+# dst_hash = src_cached
+# dst_cached = src_hash
+
+echo " **** Test 16 **** "
+
+TEST mkdir $M0/test-16
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-16" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-16/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-16" "src-"
+src_file=$dstfilename
+
+mv $M0/test-16/$src0_file  $M0/test-16/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-16" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-16/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-16" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-16/$dst0_file  $M0/test-16/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-16/$src_file  $M0/test-16/$dst_file
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-16/$dst_file 2>/dev/null
+TEST file_existence_check test-16/$dst_file "$V0-client-0"
+TEST file_does_not_exist test-16/$src_file
+EXPECT "0" file_is_linkto $dst_hash_brick/test-16/$dst_file
+
+
+################### Test 17 ####################################
+
+# src_hash != src_cached
+# dst_hash != dst_cached
+# dst_hash != src_hash != src_cached
+# dst_cached = src_hash
+
+
+echo " **** Test 17 **** "
+
+TEST mkdir $M0/test-17
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-17" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-17/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-17" "src-"
+src_file=$dstfilename
+
+mv $M0/test-17/$src0_file  $M0/test-17/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-17" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-17/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-17" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-17/$dst0_file  $M0/test-17/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-17/$src_file  $M0/test-17/$dst_file
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-2")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-17/$dst_file 2>/dev/null
+TEST file_existence_check test-17/$dst_file "$V0-client-2" "$V0-client-0"
+TEST file_does_not_exist test-17/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-17/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-17/$dst_file
+
+
+################### Test 18 ####################################
+
+# src_hash != src_cached
+# dst_hash != dst_cached
+# dst_hash != src_hash != src_cached != dst_cached
+
+
+echo " **** Test 18 **** "
+
+TEST mkdir $M0/test-18
+
+
+# 1. Create src and dst files
+
+TEST first_filename_with_same_hashsubvol "$V0-client-0" "$M0/test-18" "src0-"
+src0_file=$dstfilename
+TEST touch $M0/test-18/$src0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-1" "$M0/test-18" "src-"
+src_file=$dstfilename
+
+mv $M0/test-18/$src0_file  $M0/test-18/$src_file
+
+
+TEST first_filename_with_same_hashsubvol "$V0-client-2" "$M0/test-18" "dst0-"
+dst0_file=$dstfilename
+TEST touch $M0/test-18/$dst0_file
+
+TEST first_filename_with_same_hashsubvol "$V0-client-3" "$M0/test-18" "dst-"
+dst_file=$dstfilename
+
+mv $M0/test-18/$dst0_file  $M0/test-18/$dst_file
+
+
+# 2. Rename the file
+
+mv $M0/test-18/$src_file  $M0/test-18/$dst_file
+
+# 3. Validate
+
+dst_hash_brick=$(get_brick_path_for_subvol "$V0-client-3")
+dst_cached_brick=$(get_brick_path_for_subvol "$V0-client-0")
+
+TEST stat $M0/test-18/$dst_file 2>/dev/null
+TEST file_existence_check test-18/$dst_file "$V0-client-3" "$V0-client-0"
+TEST file_does_not_exist test-18/$src_file
+EXPECT "1" file_is_linkto $dst_hash_brick/test-18/$dst_file
+EXPECT "0" file_is_linkto $dst_cached_brick/test-18/$dst_file
+
+
+# Cleanup
+cleanup
+
diff --git a/tests/basic/distribute/force-migration.t b/tests/basic/distribute/force-migration.t
new file mode 100644
index 00000000000..f6c4997a505
--- /dev/null
+++ b/tests/basic/distribute/force-migration.t
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+#This tests checks if the file migration fails with force-migration
+#option set to off.
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+TEST touch $M0/file
+#This rename creates a link file for tile in the other brick.
+TEST mv $M0/file $M0/tile
+#Lets keep writing to the file which will have a open fd
+dd if=/dev/zero of=$M0/tile bs=1b &
+bg_pid=$!
+#Now rebalance will try to skip the file
+TEST $CLI volume set $V0 force-migration off
+TEST $CLI volume rebalance $V0 start force
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
+skippedcount=`gluster v rebalance $V0 status | awk 'NR==3{print $6}'`
+TEST [[ $skippedcount -eq 1 ]]
+#file should be migrated now
+TEST $CLI volume set $V0 force-migration on
+TEST $CLI volume rebalance $V0 start force
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
+skippedcount=`gluster v rebalance $V0 status | awk 'NR==3{print $6}'`
+rebalancedcount=`gluster v rebalance $V0 status | awk 'NR==3{print $2}'`
+TEST [[ $skippedcount -eq 0 ]]
+TEST [[ $rebalancedcount -eq 1 ]]
+kill -9 $bg_pid > /dev/null 2>&1
+wait > /dev/null 2>&1
+cleanup
+#Bad test because we are not sure writes are happening at the time of
+#rebalance. We need to write a test case which makes sure client
+#writes happen during rebalance. One way would be to set S+T bits on
+#src and write to file from client and then start rebalance. Currently
+#marking this as bad test.
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
+
diff --git a/tests/basic/distribute/lookup.t b/tests/basic/distribute/lookup.t
new file mode 100644
index 00000000000..f757bd99fd9
--- /dev/null
+++ b/tests/basic/distribute/lookup.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../../common-utils.rc
+
+# Test overview:
+# Check that non-privileged users can also clean up stale linkto files
+#
+# 1. Use the current parallel-readdir behaviour of changing the DHT child subvols
+# in the graph to generate stale linkto files
+# 2. Access the file with the stale linkto file as a non-root user
+# 3. This should now succeed (returned EIO before commit 3fb1df7870e03c9de)
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{1..3}
+TEST $CLI volume start $V0
+
+# Mount using FUSE and create a file
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+TEST glusterfs -s $H0 --volfile-id $V0 $M1
+
+ls $M0/FILE-1
+EXPECT "2" echo $?
+
+
+# Create a file and a directory on $M0
+TEST dd if=/dev/urandom of=$M0/FILE-1 count=1 bs=16k
+TEST mkdir $M0/dir1
+
+ls $M0/FILE-1
+EXPECT "0" echo $?
+
+ls $M0/dir1
+EXPECT "0" echo $?
+
+#Use a fresh mount so as to trigger a fresh lookup
+TEST glusterfs -s $H0 --volfile-id $V0 $M1
+
+TEST ls $M1/FILE-1
+EXPECT "0" echo $?
+
+
+ls $M1/dir1
+EXPECT "0" echo $?
+
+# Cleanup
+cleanup
+
diff --git a/tests/basic/distribute/non-root-unlink-stale-linkto.t b/tests/basic/distribute/non-root-unlink-stale-linkto.t
new file mode 100644
index 00000000000..d6c866ffc8e
--- /dev/null
+++ b/tests/basic/distribute/non-root-unlink-stale-linkto.t
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+. $(dirname $0)/../../common-utils.rc
+
+# Test overview:
+# Check that non-privileged users can also clean up stale linkto files
+#
+# 1. Use the current parallel-readdir behaviour of changing the DHT child subvols
+# in the graph to generate stale linkto files
+# 2. Access the file with the stale linkto file as a non-root user
+# 3. This should now succeed (returned EIO before commit 3fb1df7870e03c9de)
+
+USERNAME=user11
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0-{1,2}
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 performance.parallel-readdir on
+
+# Mount using FUSE and create a file
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+# Create a file for testing
+TEST dd if=/dev/urandom of=$M0/FILE-1 count=1 bs=16k
+
+#Rename to create a linkto file
+TEST mv $M0/FILE-1 $M0/FILE-2
+
+# This should change the graph and cause the linkto values to become stale
+TEST $CLI volume set $V0 performance.parallel-readdir off
+
+$CLI volume set $V0 allow-insecure on
+
+
+TEST useradd -m $USERNAME
+
+#Use a fresh mount so as to trigger a lookup everywhere
+TEST glusterfs -s $H0 --volfile-id $V0 $M1
+TEST run_cmd_as_user $USERNAME "ls $M1/FILE-2"
+
+
+# Cleanup
+TEST userdel --force $USERNAME
+cleanup
+
diff --git a/tests/basic/distribute/spare_file_rebalance.t b/tests/basic/distribute/spare_file_rebalance.t
new file mode 100644
index 00000000000..061c02f7392
--- /dev/null
+++ b/tests/basic/distribute/spare_file_rebalance.t
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+# Initialize
+#------------------------------------------------------------
+cleanup;
+
+# Start glusterd
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+# Create a volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+
+# Verify volume creation
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+# Start volume and verify successful start
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+#------------------------------------------------------------
+
+# Test case - Create sparse files on MP and verify
+# file info after rebalance
+#------------------------------------------------------------
+
+# Create some sparse files and get their size
+TEST cd $M0;
+dd if=/dev/urandom of=sparse_file bs=10k count=1 seek=2M
+cp --sparse=always sparse_file sparse_file_3;
+
+# Add a 3rd brick
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}3;
+
+# Trigger rebalance
+TEST $CLI volume rebalance $V0 start force;
+EXPECT_WITHIN $REBALANCE_TIMEOUT "0" rebalance_completed;
+
+# Compare original and rebalanced files
+TEST cd $B0/${V0}2
+TEST cmp sparse_file $B0/${V0}3/sparse_file_3
+EXPECT_WITHIN 30 "";
+
+cleanup;
diff --git a/tests/basic/ec/ec-12-4.t b/tests/basic/ec/ec-12-4.t
deleted file mode 100644
index 76e6f8e77e8..00000000000
--- a/tests/basic/ec/ec-12-4.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-# This test checks basic dispersed volume functionality and cli interface
-
-DISPERSE=12
-REDUNDANCY=4
-
-# This must be equal to 36 * $DISPERSE + 109
-TESTS_EXPECTED_IN_LOOP=541
-
-. $(dirname $0)/ec-common
diff --git a/tests/basic/ec/ec-1468261.t b/tests/basic/ec/ec-1468261.t
index d687d7bf6a0..77d704cf880 100644
--- a/tests/basic/ec/ec-1468261.t
+++ b/tests/basic/ec/ec-1468261.t
@@ -4,6 +4,8 @@
 # changelog enabled on EC volume.
 ###
 
+SCRIPT_TIMEOUT=300
+
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 
@@ -14,6 +16,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
 TEST $CLI volume set $V0 disperse.optimistic-change-log on
+TEST $CLI volume set $V0 disperse.other-eager-lock on
 TEST $CLI volume start $V0
 
 #Mount the volume
@@ -31,11 +34,12 @@ EXPECT_WITHIN $IO_WAIT_TIMEOUT "^$" get_hex_xattr trusted.ec.dirty $B0/${V0}3/te
 EXPECT_WITHIN $IO_WAIT_TIMEOUT "^$" get_hex_xattr trusted.ec.dirty $B0/${V0}4/test_dir
 EXPECT_WITHIN $IO_WAIT_TIMEOUT "^$" get_hex_xattr trusted.ec.dirty $B0/${V0}5/test_dir
 
-#Touch a file and kill two bricks
-TEST touch $M0/test_dir/new_file
+#Kill two bricks and touch a file
 TEST kill_brick $V0 $H0 $B0/${V0}0
 TEST kill_brick $V0 $H0 $B0/${V0}1
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+TEST touch $M0/test_dir/new_file
+sleep 2
 
 #Dirty should be set on up bricks
 EXPECT_WITHIN $IO_WAIT_TIMEOUT  "^00000000000000010000000000000001$" get_hex_xattr trusted.ec.dirty $B0/${V0}2/test_dir
@@ -55,15 +59,13 @@ EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST glusterfs -s $H0 --volfile-id $V0 $M0;
 
 #Create a tar file
-TEST mkdir $M0/test_dir
-for i in {1..3000};do
-dd if=/dev/urandom of=$M0/test_dir/file-$i bs=1k count=10;
-done
-tar -cf $M0/test_dir.tar $M0/test_dir/ 2>/dev/null
-rm -rf $M0/test_dir/
+TEST mkdir /tmp/test_dir
+seq 1 3000 | xargs -n 1 -P 20 -I {} dd if=/dev/urandom of=/tmp/test_dir/file-{} bs=10K count=1
+tar -cf /tmp/test_dir.tar /tmp/test_dir/ 2>/dev/null
+rm -rf /tmp/test_dir/
 
 #Untar the tar file
-tar -C $M0 -xf $M0/test_dir.tar 2>/dev/null&
+tar -C $M0 -xf /tmp/test_dir.tar 2>/dev/null&
 
 #Kill 1st and 2nd brick
 TEST kill_brick $V0 $H0 $B0/${V0}0
@@ -72,6 +74,7 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
 
 #Stop untaring
 TEST kill %1
+rm -f /tmp/test_dir.tar
 
 #Bring up the down bricks
 TEST $CLI volume start $V0 force
diff --git a/tests/basic/ec/ec-5-1.t b/tests/basic/ec/ec-5-1.t
deleted file mode 100644
index 35c205da4b7..00000000000
--- a/tests/basic/ec/ec-5-1.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-# This test checks basic dispersed volume functionality and cli interface
-
-DISPERSE=5
-REDUNDANCY=1
-
-# This must be equal to 36 * $DISPERSE + 109
-TESTS_EXPECTED_IN_LOOP=289
-
-. $(dirname $0)/ec-common
diff --git a/tests/basic/ec/ec-7-3.t b/tests/basic/ec/ec-7-3.t
deleted file mode 100644
index 9d9d5f691bf..00000000000
--- a/tests/basic/ec/ec-7-3.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-# This test checks basic dispersed volume functionality and cli interface
-
-DISPERSE=7
-REDUNDANCY=3
-
-# This must be equal to 36 * $DISPERSE + 109
-TESTS_EXPECTED_IN_LOOP=361
-
-. $(dirname $0)/ec-common
diff --git a/tests/basic/ec/ec-background-heals.t b/tests/basic/ec/ec-background-heals.t
index b9291bc9c32..29778a4f818 100644
--- a/tests/basic/ec/ec-background-heals.t
+++ b/tests/basic/ec/ec-background-heals.t
@@ -17,6 +17,7 @@ TEST $CLI volume set $V0 performance.read-ahead off
 TEST $CLI volume set $V0 performance.io-cache off
 TEST $CLI volume set $V0 disperse.background-heals 0
 TEST $CLI volume set $V0 disperse.eager-lock off
+TEST $CLI volume set $V0 disperse.other-eager-lock off
 TEST $CLI volume start $V0
 
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
diff --git a/tests/basic/ec/ec-badfd.c b/tests/basic/ec/ec-badfd.c
new file mode 100644
index 00000000000..8be23c10eaf
--- /dev/null
+++ b/tests/basic/ec/ec-badfd.c
@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+int
+fill_iov(struct iovec *iov, char fillchar, int count)
+{
+    int ret = -1;
+
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
+        return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
+}
+
+int
+write_sync(glfs_t *fs, glfs_fd_t *glfd, int char_count)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        fprintf(stderr, "failed to create iov");
+        goto out;
+    }
+
+    ret = glfs_pwritev(glfd, &iov, 1, 0, flags);
+out:
+    if (ret < 0) {
+        fprintf(stderr, "glfs_pwritev failed, %d", errno);
+    }
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    char volume_cmd[4096] = {0};
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/tmp/ec-badfd.log", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    ret = write_sync(fs, fd, 16);
+    if (ret < 0) {
+        fprintf(stderr, "write_sync failed\n");
+    }
+
+    snprintf(volume_cmd, sizeof(volume_cmd),
+             "gluster --mode=script volume stop %s", argv[2]);
+    /*Stop the volume so that update-size-version fails*/
+    system(volume_cmd);
+    sleep(8); /* 3 seconds more than eager-lock-timeout*/
+    snprintf(volume_cmd, sizeof(volume_cmd),
+             "gluster --mode=script volume start %s", argv[2]);
+    system(volume_cmd);
+    sleep(8); /*wait for bricks to come up*/
+    ret = glfs_fsync(fd, NULL, NULL);
+    if (ret == 0) {
+        fprintf(stderr, "fsync succeeded on a BADFD\n");
+        exit(1);
+    }
+
+    ret = glfs_close(fd);
+    if (ret == 0) {
+        fprintf(stderr, "flush succeeded on a BADFD\n");
+        exit(1);
+    }
+    ret = 0;
+
+out:
+    unlink("/tmp/ec-badfd.log");
+    glfs_fini(fs);
+
+    return ret;
+}
diff --git a/tests/basic/ec/ec-badfd.t b/tests/basic/ec/ec-badfd.t
new file mode 100755
index 00000000000..56feb47f115
--- /dev/null
+++ b/tests/basic/ec/ec-badfd.t
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{1..6}
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 disperse.eager-lock-timeout 5
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+TEST touch $M0/file
+
+TEST build_tester $(dirname $0)/ec-badfd.c -lgfapi -Wall -O2
+TEST $(dirname $0)/ec-badfd $H0 $V0 /file
+cleanup_tester $(dirname ${0})/ec-badfd
+
+cleanup;
diff --git a/tests/basic/ec/ec-cpu-extensions.t b/tests/basic/ec/ec-cpu-extensions.t
index a599a316925..c9af27ea234 100644
--- a/tests/basic/ec/ec-cpu-extensions.t
+++ b/tests/basic/ec/ec-cpu-extensions.t
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-DISPERSE=6
+DISPERSE=18
 REDUNDANCY=2
 
 . $(dirname $0)/../../include.rc
@@ -39,6 +39,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 redundancy $REDUNDANCY $H0:$B0/${V0}{1..$DISPERSE}
 TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume set $V0 disperse.read-policy round-robin
 EXPECT 'Created' volinfo_field $V0 'Status'
 TEST $CLI volume start $V0
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field $V0 'Status'
diff --git a/tests/basic/ec/ec-dirty-flags.t b/tests/basic/ec/ec-dirty-flags.t
new file mode 100644
index 00000000000..68e66103f08
--- /dev/null
+++ b/tests/basic/ec/ec-dirty-flags.t
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# This checks if the fop keeps the dirty flags settings correctly after
+# finishing the fop.
+
+cleanup
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..2}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+cd $M0
+for i in {1..1000}; do dd if=/dev/zero of=file-${i} bs=512k count=2; done
+cd -
+EXPECT "^0$" get_pending_heal_count $V0
+
+cleanup
diff --git a/tests/basic/ec/ec-discard.t b/tests/basic/ec/ec-discard.t
new file mode 100644
index 00000000000..001f4498c86
--- /dev/null
+++ b/tests/basic/ec/ec-discard.t
@@ -0,0 +1,205 @@
+#!/bin/bash
+#
+# Test discard functionality
+#
+# Test that basic discard (hole punch) functionality works via the fallocate
+# command line tool. Hole punch deallocates a region of a file, creating a hole
+# and a zero-filled data region. We verify that hole punch works, frees blocks
+# and that subsequent reads do not read stale data (caches are invalidated).
+#
+# NOTE: fuse fallocate is known to be broken with regard to cache invalidation
+# 	up to 3.9.0 kernels. Therefore, FOPEN_KEEP_CACHE is not used in this
+#	test (opens will invalidate the fuse cache).
+###
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../fallocate.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+#cleate and start volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume set $V0 disperse.optimistic-change-log on
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+#Check for fallocate and hole punch support
+require_fallocate -l 1m $M0/file
+require_fallocate -p -l 512k $M0/file && rm -f $M0/file
+
+#Write some data, punch a hole and verify the file content changes
+TEST dd if=/dev/urandom of=$M0/file bs=1024k count=1
+TEST cp $M0/file $M0/file.copy.pre
+TEST fallocate -p -o 512k -l 128k $M0/file
+TEST ! cmp $M0/file.copy.pre $M0/file
+TEST rm -f $M0/file $M0/file.copy.pre
+
+#Allocate some blocks, punch a hole and verify block allocation
+TEST fallocate -l 1m $M0/file
+blksz=`stat -c %B $M0/file`
+nblks=`stat -c %b $M0/file`
+TEST [ $(($blksz * $nblks)) -ge 1048576 ]
+TEST fallocate -p -o 512k -l 128k $M0/file
+nblks=`stat -c %b $M0/file`
+TEST [ $(($blksz * $nblks)) -lt $((933889)) ]
+TEST unlink $M0/file
+
+###Punch hole test cases without fallocate
+##With write
+#Touching starting boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 0 -l 500 $B0/test_file
+TEST fallocate -p -o 0 -l 500 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Touching boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 500 -l 1548 $B0/test_file
+TEST fallocate -p -o 500 -l 1548 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Not touching boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 500 -l 1000 $B0/test_file
+TEST fallocate -p -o 500 -l 1000 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Over boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 1500 -l 1000 $B0/test_file
+TEST fallocate -p -o 1500 -l 1000 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+###Punch hole test cases with fallocate
+##Without write
+
+#Zero size
+TEST dd if=/dev/urandom of=$M0/test_file bs=1024 count=8
+TEST ! fallocate -p -o 1500 -l 0 $M0/test_file
+
+#Negative size
+TEST ! fallocate -p -o 1500 -l -100 $M0/test_file
+TEST rm -f $M0/test_file
+
+#Touching boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 2048 -l 2048 $B0/test_file
+TEST fallocate -p -o 2048 -l 2048 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Touching boundary,multiple stripe
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 2048 -l 4096 $B0/test_file
+TEST fallocate -p -o 2048 -l 4096 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+##With write
+
+#Size ends in boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 600 -l 3496 $B0/test_file
+TEST fallocate -p -o 600 -l 3496 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Offset at boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 2048 -l 3072 $B0/test_file
+TEST fallocate -p -o 2048 -l 3072 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Offset and Size not at boundary covering a stripe
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 1500 -l 3000 $B0/test_file
+TEST fallocate -p -o 1500 -l 3000 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+TEST rm -f $B0/test_file $M0/test_file
+
+#Offset and Size not at boundary
+TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=8
+TEST cp $B0/test_file $M0/test_file
+TEST fallocate -p -o 1000 -l 3072 $B0/test_file
+TEST fallocate -p -o 1000 -l 3072 $M0/test_file
+TEST md5_sum=`get_md5_sum $B0/test_file`
+EXPECT $md5_sum get_md5_sum $M0/test_file
+
+#Data Corruption Tests
+#Kill brick1 and brick2
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#verify md5 sum
+EXPECT $md5_sum get_md5_sum $M0/test_file
+
+#Bring up the bricks
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+#Kill brick3 and brick4
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST kill_brick $V0 $H0 $B0/${V0}3
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#verify md5 sum
+EXPECT $md5_sum get_md5_sum $M0/test_file
+
+#Bring up the bricks
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+#Kill brick5 and brick6
+TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick $V0 $H0 $B0/${V0}5
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "4" ec_child_up_count $V0 0
+
+#verify md5 sum
+EXPECT $md5_sum get_md5_sum $M0/test_file
+
+cleanup
diff --git a/tests/basic/ec/ec-fast-fgetxattr.c b/tests/basic/ec/ec-fast-fgetxattr.c
new file mode 100644
index 00000000000..bf982151861
--- /dev/null
+++ b/tests/basic/ec/ec-fast-fgetxattr.c
@@ -0,0 +1,129 @@
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+int cbk_complete = 0;
+ssize_t cbk_ret_val = 0;
+int
+fill_iov(struct iovec *iov, char fillchar, int count)
+{
+    int ret = -1;
+
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
+        return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
+}
+
+void
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        fprintf(stderr, "glfs_write failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+int
+write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        fprintf(stderr, "failed to create iov");
+        goto out;
+    }
+
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk, NULL);
+out:
+    if (ret < 0) {
+        fprintf(stderr, "glfs_pwritev async failed");
+    }
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    char buf[1024] = {0};
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/tmp/ec-fgetxattr.log", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    ret = write_async(fs, fd, 16);
+    if (ret) {
+        fprintf(stderr, "write_async failed\n");
+    }
+
+    sleep(1);
+    ret = glfs_fgetxattr(fd, "trusted.glusterfs.abc", buf, sizeof buf);
+    while (cbk_complete != 1) {
+        /* ret will be -ve as xattr doesn't exist, and fgetxattr should
+         * return waaaayyy before writev */
+        ret = 0;
+        sleep(1);
+    }
+    if (cbk_ret_val < 0) {
+        fprintf(stderr, "cbk_ret_val is -ve\n");
+        ret = -1;
+    }
+    glfs_close(fd);
+
+out:
+    unlink("/tmp/ec-fgetxattr.log");
+    glfs_fini(fs);
+
+    return ret;
+}
diff --git a/tests/basic/ec/ec-fast-fgetxattr.t b/tests/basic/ec/ec-fast-fgetxattr.t
new file mode 100755
index 00000000000..eb12fa4a0ba
--- /dev/null
+++ b/tests/basic/ec/ec-fast-fgetxattr.t
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{1..6}
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.client-io-threads off
+TEST $CLI volume set $V0 brick-log-level DEBUG
+TEST $CLI volume set $V0 delay-gen posix
+TEST $CLI volume set $V0 delay-gen.delay-duration 10000000
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.enable read,write
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+TEST touch $M0/file
+
+# Perform two writes to make sure io-threads have enough threads to perform
+# things in parallel when the test execution happens.
+echo abc > $M0/file1 &
+echo abc > $M0/file2 &
+wait
+
+TEST build_tester $(dirname $0)/ec-fast-fgetxattr.c -lgfapi -Wall -O2
+TEST $(dirname $0)/ec-fast-fgetxattr $H0 $V0 /file
+cleanup_tester $(dirname ${0})/ec-fast-fgetxattr
+
+cleanup;
diff --git a/tests/basic/ec/ec-fix-openfd.t b/tests/basic/ec/ec-fix-openfd.t
new file mode 100644
index 00000000000..04fdd802c62
--- /dev/null
+++ b/tests/basic/ec/ec-fix-openfd.t
@@ -0,0 +1,111 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
+
+# This test checks for open fd heal on EC
+
+#Create Volume
+cleanup
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..2}
+TEST $CLI volume set $V0 performance.read-after-open yes
+TEST $CLI volume set $V0 performance.lazy-open no
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 disperse.background-heals 0
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume start $V0
+
+#Mount the volume
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+
+#Touch a file
+TEST touch "$M0/test_file"
+
+#Kill a brick
+TEST kill_brick $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Open the file in write mode
+TEST fd=`fd_available`
+TEST fd_open $fd 'rw' "$M0/test_file"
+
+#Bring up the killed brick
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+
+sleep 1
+
+#Test the fd count
+EXPECT "0" get_fd_count $V0 $H0 $B0/${V0}0 test_file
+EXPECT "1" get_fd_count $V0 $H0 $B0/${V0}1 test_file
+EXPECT "1" get_fd_count $V0 $H0 $B0/${V0}2 test_file
+
+#Write to file
+dd iflag=fullblock if=/dev/urandom bs=1024 count=2 >&$fd 2>/dev/null
+
+#Test the fd count
+EXPECT "1" get_fd_count $V0 $H0 $B0/${V0}0 test_file
+
+#Close fd
+TEST fd_close $fd
+
+#Stop the volume
+TEST $CLI volume stop $V0
+
+#Start the volume
+TEST $CLI volume start $V0
+
+#Kill brick1
+TEST kill_brick $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Calculate md5 sum
+md5sum0=`get_md5_sum "$M0/test_file"`
+
+#Bring up the brick
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+
+#Kill brick2
+TEST kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Calculate md5 sum
+md5sum1=`get_md5_sum "$M0/test_file"`
+
+#Bring up the brick
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+
+#Kill brick3
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Unmount and mount
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "2" ec_child_up_count $V0 0
+
+#Calculate md5 sum
+md5sum2=`get_md5_sum "$M0/test_file"`
+
+#compare the md5sum
+EXPECT "$md5sum0" echo $md5sum1
+EXPECT "$md5sum0" echo $md5sum2
+EXPECT "$md5sum1" echo $md5sum2
+
+cleanup
diff --git a/tests/basic/ec/ec-optimistic-changelog.t b/tests/basic/ec/ec-optimistic-changelog.t
index 1277da6ca1b..a372cd39a64 100644
--- a/tests/basic/ec/ec-optimistic-changelog.t
+++ b/tests/basic/ec/ec-optimistic-changelog.t
@@ -19,6 +19,7 @@ TEST $CLI volume set $V0 performance.io-cache off
 TEST $CLI volume set $V0 disperse.background-heals 0
 TEST $CLI volume set $V0 disperse.optimistic-change-log off
 TEST $CLI volume set $V0 disperse.eager-lock off
+TEST $CLI volume set $V0 disperse.other-eager-lock off
 TEST $CLI volume start $V0
 
 TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
diff --git a/tests/basic/ec/ec-quorum-count.t b/tests/basic/ec/ec-quorum-count.t
new file mode 100644
index 00000000000..9310ebbb8f2
--- /dev/null
+++ b/tests/basic/ec/ec-quorum-count.t
@@ -0,0 +1,167 @@
+ #!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../ec.rc
+
+cleanup
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume create $V1 $H0:$B0/${V1}{0..5}
+TEST $CLI volume set $V0 disperse.eager-lock-timeout 5
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume set $V0 disperse.background-heals 0
+TEST $CLI volume set $V0 disperse.heal-wait-qlength 0
+
+#Should fail on non-disperse volume
+TEST ! $CLI volume set $V1 disperse.quorum-count 5
+
+#Should succeed on a valid range
+TEST ! $CLI volume set $V0 disperse.quorum-count 0
+TEST ! $CLI volume set $V0 disperse.quorum-count -0
+TEST ! $CLI volume set $V0 disperse.quorum-count abc
+TEST ! $CLI volume set $V0 disperse.quorum-count 10abc
+TEST ! $CLI volume set $V0 disperse.quorum-count 1
+TEST ! $CLI volume set $V0 disperse.quorum-count 2
+TEST ! $CLI volume set $V0 disperse.quorum-count 3
+TEST $CLI volume set $V0 disperse.quorum-count 4
+TEST $CLI volume start $V0
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+#Test that the option is reflected in the mount
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^4$" ec_option_value $V0 $M0 0 quorum-count
+TEST $CLI volume reset $V0 disperse.quorum-count
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^0$" ec_option_value $V0 $M0 0 quorum-count
+TEST $CLI volume set $V0 disperse.quorum-count 6
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^6$" ec_option_value $V0 $M0 0 quorum-count
+
+TEST touch $M0/a
+TEST touch $M0/data
+TEST setfattr -n trusted.def -v def $M0/a
+TEST touch $M0/src
+TEST touch $M0/del-me
+TEST mkdir $M0/dir1
+TEST dd if=/dev/zero of=$M0/read-file bs=1M count=1 oflag=direct
+TEST dd if=/dev/zero of=$M0/del-file bs=1M count=1 oflag=direct
+TEST gf_rm_file_and_gfid_link $B0/${V0}0 del-file
+#modify operations should fail as the file is not in quorum
+TEST ! dd if=/dev/zero of=$M0/del-file bs=1M count=1 oflag=direct
+TEST kill_brick $V0 $H0 $B0/${V0}0
+#Read should succeed even when quorum-count is not met
+TEST dd if=$M0/read-file of=/dev/null iflag=direct
+TEST ! touch $M0/a2
+TEST ! mkdir $M0/dir2
+TEST ! mknod  $M0/b2 b 4 5
+TEST ! ln -s $M0/a $M0/symlink
+TEST ! ln $M0/a $M0/link
+TEST ! mv $M0/src $M0/dst
+TEST ! rm -f $M0/del-me
+TEST ! rmdir $M0/dir1
+TEST ! dd if=/dev/zero of=$M0/a bs=1M count=1 conv=notrunc
+TEST ! dd if=/dev/zero of=$M0/data bs=1M count=1 conv=notrunc
+TEST ! truncate -s 0 $M0/a
+TEST ! setfattr -n trusted.abc -v abc $M0/a
+TEST ! setfattr -x trusted.def $M0/a
+TEST ! chmod +x $M0/a
+TEST ! fallocate -l 2m -n $M0/a
+TEST ! fallocate -p -l 512k $M0/a
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+
+# reset the option and check whether the default redundancy count is
+# accepted or not.
+TEST $CLI volume reset $V0 disperse.quorum-count
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^0$" ec_option_value $V0 $M0 0 quorum-count
+TEST touch $M0/a1
+TEST touch $M0/data1
+TEST setfattr -n trusted.def -v def $M0/a1
+TEST touch $M0/src1
+TEST touch $M0/del-me1
+TEST mkdir $M0/dir11
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST touch $M0/a21
+TEST mkdir $M0/dir21
+TEST mknod  $M0/b21 b 4 5
+TEST ln -s $M0/a1 $M0/symlink1
+TEST ln $M0/a1 $M0/link1
+TEST mv $M0/src1 $M0/dst1
+TEST rm -f $M0/del-me1
+TEST rmdir $M0/dir11
+TEST dd if=/dev/zero of=$M0/a1 bs=1M count=1 conv=notrunc
+TEST dd if=/dev/zero of=$M0/data1 bs=1M count=1 conv=notrunc
+TEST truncate -s 0 $M0/a1
+TEST setfattr -n trusted.abc -v abc $M0/a1
+TEST setfattr -x trusted.def $M0/a1
+TEST chmod +x $M0/a1
+TEST fallocate -l 2m -n $M0/a1
+TEST fallocate -p -l 512k $M0/a1
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+TEST touch $M0/a2
+TEST touch $M0/data2
+TEST setfattr -n trusted.def -v def $M0/a1
+TEST touch $M0/src2
+TEST touch $M0/del-me2
+TEST mkdir $M0/dir12
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST ! touch $M0/a22
+TEST ! mkdir $M0/dir22
+TEST ! mknod  $M0/b22 b 4 5
+TEST ! ln -s $M0/a2 $M0/symlink2
+TEST ! ln $M0/a2 $M0/link2
+TEST ! mv $M0/src2 $M0/dst2
+TEST ! rm -f $M0/del-me2
+TEST ! rmdir $M0/dir12
+TEST ! dd if=/dev/zero of=$M0/a2 bs=1M count=1 conv=notrunc
+TEST ! dd if=/dev/zero of=$M0/data2 bs=1M count=1 conv=notrunc
+TEST ! truncate -s 0 $M0/a2
+TEST ! setfattr -n trusted.abc -v abc $M0/a2
+TEST ! setfattr -x trusted.def $M0/a2
+TEST ! chmod +x $M0/a2
+TEST ! fallocate -l 2m -n $M0/a2
+TEST ! fallocate -p -l 512k $M0/a2
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+
+# Set quorum-count to 5 and kill 1 brick and the fops should pass
+TEST $CLI volume set $V0 disperse.quorum-count 5
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "^5$" ec_option_value $V0 $M0 0 quorum-count
+TEST touch $M0/a3
+TEST touch $M0/data3
+TEST setfattr -n trusted.def -v def $M0/a3
+TEST touch $M0/src3
+TEST touch $M0/del-me3
+TEST mkdir $M0/dir13
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST touch $M0/a31
+TEST mkdir $M0/dir31
+TEST mknod  $M0/b31 b 4 5
+TEST ln -s $M0/a3 $M0/symlink3
+TEST ln $M0/a3 $M0/link3
+TEST mv $M0/src3 $M0/dst3
+TEST rm -f $M0/del-me3
+TEST rmdir $M0/dir13
+TEST dd if=/dev/zero of=$M0/a3 bs=1M count=1 conv=notrunc
+TEST dd if=/dev/zero of=$M0/data3 bs=1M count=1 conv=notrunc
+TEST truncate -s 0 $M0/a3
+TEST setfattr -n trusted.abc -v abc $M0/a3
+TEST setfattr -x trusted.def $M0/a3
+TEST chmod +x $M0/a3
+TEST fallocate -l 2m -n $M0/a3
+TEST fallocate -p -l 512k $M0/a3
+TEST dd if=/dev/urandom of=$M0/heal-file bs=1M count=1 oflag=direct
+cksum_before_heal="$(md5sum $M0/heal-file | awk '{print $1}')"
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick $V0 $H0 $B0/${V0}5
+cksum_after_heal=$(dd if=$M0/heal-file iflag=direct | md5sum | awk '{print $1}')
+TEST [[ $cksum_before_heal == $cksum_after_heal ]]
+cleanup;
diff --git a/tests/basic/ec/ec-read-mask.t b/tests/basic/ec/ec-read-mask.t
new file mode 100644
index 00000000000..ddb556f2973
--- /dev/null
+++ b/tests/basic/ec/ec-read-mask.t
@@ -0,0 +1,114 @@
+ #!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../ec.rc
+
+cleanup
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume start $V0
+
+#Empty read-mask should fail
+TEST ! $GFS --xlator-option=*.ec-read-mask="" -s $H0 --volfile-id $V0 $M0
+
+#Less than 4 number of bricks should fail
+TEST ! $GFS --xlator-option="*.ec-read-mask=0" -s $H0 --volfile-id $V0 $M0
+TEST ! $GFS --xlator-option="*.ec-read-mask=0:1" -s $H0 --volfile-id $V0 $M0
+TEST ! $GFS --xlator-option=*.ec-read-mask="0:1:2" -s $H0 --volfile-id $V0 $M0
+
+#ids greater than 5 should fail
+TEST ! $GFS --xlator-option="*.ec-read-mask=0:1:2:6" -s $H0 --volfile-id $V0 $M0
+
+#ids less than 0 should fail
+TEST ! $GFS --xlator-option="*.ec-read-mask=0:-1:2:5" -s $H0 --volfile-id $V0 $M0
+
+#read-mask with non-alphabet or comma should fail
+TEST ! $GFS --xlator-option="*.ec-read-mask=0:1:2:5:abc" -s $H0 --volfile-id $V0 $M0
+TEST ! $GFS --xlator-option="*.ec-read-mask=0:1:2:5a" -s $H0 --volfile-id $V0 $M0
+
+#mount with at least 4 read-mask-ids and all of them valid should pass
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5:4:3" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^111111$" ec_option_value $V0 $M0 0 read-mask
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+
+TEST dd if=/dev/urandom of=$M0/a bs=1M count=1
+md5=$(md5sum $M0/a | awk '{print $1}')
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#Read on the file should fail if any of the read-mask is down when number of
+#ids is data-count
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST ! dd if=$M0/a of=/dev/null
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST ! dd if=$M0/a of=/dev/null
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST ! dd if=$M0/a of=/dev/null
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}5
+TEST ! dd if=$M0/a of=/dev/null
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+#Read on file should succeed when non-read-mask bricks are down
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}3
+EXPECT "^$md5$" echo $(dd if=$M0/a | md5sum | awk '{print $1}')
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}4
+EXPECT "^$md5$" echo $(dd if=$M0/a | md5sum | awk '{print $1}')
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+TEST kill_brick $V0 $H0 $B0/${V0}3
+TEST kill_brick $V0 $H0 $B0/${V0}4
+EXPECT "^$md5$" echo $(dd if=$M0/a | md5sum | awk '{print $1}')
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume start $V0 force
+
+#Deliberately corrupt chunks 3: 4 and check that reads still give correct data
+TEST dd if=/dev/zero of=$B0/${V0}3/a bs=256k count=1
+TEST dd if=/dev/zero of=$B0/${V0}4/a bs=256k count=1
+TEST $GFS --xlator-option="*.ec-read-mask=0:1:2:5" -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+EXPECT "^100111$" ec_option_value $V0 $M0 0 read-mask
+EXPECT "^$md5$" echo $(dd if=$M0/a | md5sum | awk '{print $1}')
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+cleanup;
diff --git a/tests/basic/ec/ec-read-policy.t b/tests/basic/ec/ec-read-policy.t
index e4390aa07cb..fe6fe6576e7 100644
--- a/tests/basic/ec/ec-read-policy.t
+++ b/tests/basic/ec/ec-read-policy.t
@@ -20,10 +20,9 @@ TEST $CLI volume start $V0
 TEST glusterfs --direct-io-mode=yes --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
 #TEST volume operations work fine
-EXPECT "round-robin" mount_get_option_value $M0 $V0-disperse-0 read-policy
-TEST $CLI volume set $V0 disperse.read-policy gfid-hash
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "gfid-hash" mount_get_option_value $M0 $V0-disperse-0 read-policy
-TEST $CLI volume reset $V0 disperse.read-policy
+
+EXPECT "gfid-hash" mount_get_option_value $M0 $V0-disperse-0 read-policy
+TEST $CLI volume set $V0 disperse.read-policy round-robin
 EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "round-robin" mount_get_option_value $M0 $V0-disperse-0 read-policy
 
 #TEST if the option gives the intended behavior. The way we perform this test
diff --git a/tests/basic/ec/ec-rebalance.t b/tests/basic/ec/ec-rebalance.t
index b5c30727a15..6cda3a3e4be 100644
--- a/tests/basic/ec/ec-rebalance.t
+++ b/tests/basic/ec/ec-rebalance.t
@@ -14,6 +14,7 @@ cleanup
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..2}
+TEST $CLI volume set $V0 lookup-optimize on
 TEST $CLI volume start $V0
 
 #Mount the volume
diff --git a/tests/basic/ec/ec-reset-brick.t b/tests/basic/ec/ec-reset-brick.t
new file mode 100644
index 00000000000..f1a625df4ff
--- /dev/null
+++ b/tests/basic/ec/ec-reset-brick.t
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+function num_entries {
+        ls -l $1 | wc -l
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume start $V0
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+mkdir $M0/dir
+touch $M0/dir/{1..10}
+
+mkdir $M0/dir/dir1
+touch $M0/dir/dir1/{1..10}
+
+#kill brick process
+TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}5 start
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "5" ec_child_up_count $V0 0
+
+#reset-brick by removing all the data and create dir again
+rm -rf $B0/${V0}5
+mkdir $B0/${V0}5
+
+#start brick  process and heal by commiting reset-brick
+TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}5 $H0:$B0/${V0}5 commit force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count_shd $V0 0
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+
+EXPECT "^12$" num_entries $B0/${V0}5/dir
+EXPECT "^11$" num_entries $B0/${V0}5/dir/dir1
+
+ec_version=$(get_hex_xattr trusted.ec.version $B0/${V0}0)
+EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}1
+EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}2
+EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}3
+EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}4
+EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}5
+
+cleanup;
diff --git a/tests/basic/ec/ec-root-heal.t b/tests/basic/ec/ec-root-heal.t
index a133885ef1d..11ea7cdf9d4 100644
--- a/tests/basic/ec/ec-root-heal.t
+++ b/tests/basic/ec/ec-root-heal.t
@@ -22,7 +22,8 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count_shd $V0 0
 # active heal
 TEST $CLI volume heal $V0 full
 #ls -l gives "Total" line so number of lines will be 1 more
-EXPECT_WITHIN $HEAL_TIMEOUT "^11$" num_entries $B0/${V0}6
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}
+EXPECT "^11$" num_entries $B0/${V0}6
 ec_version=$(get_hex_xattr trusted.ec.version $B0/${V0}0)
 EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}1
 EXPECT "$ec_version" get_hex_xattr trusted.ec.version $B0/${V0}2
diff --git a/tests/basic/ec/ec-seek.t b/tests/basic/ec/ec-seek.t
index 6a0060870c8..5a7d31b9f8f 100644
--- a/tests/basic/ec/ec-seek.t
+++ b/tests/basic/ec/ec-seek.t
@@ -6,7 +6,7 @@
 cleanup
 
 SEEK=$(dirname $0)/seek
-build_tester $(dirname $0)/seek.c -o ${SEEK}
+build_tester $(dirname $0)/../seek.c -o ${SEEK}
 
 TEST glusterd
 TEST pidof glusterd
@@ -51,6 +51,7 @@ EXPECT "^$((${BSIZE} * 5 + 512))$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 5
 EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 5 + 512))
 EXPECT "^ENXIO$" ${SEEK} scan ${M0}/test hole $((${BSIZE} * 6))
 
+rm -f ${SEEK}
 cleanup
 
 # Centos6 regression slaves seem to not support SEEK_DATA/SEEK_HOLE
diff --git a/tests/basic/ec/ec-stripe.t b/tests/basic/ec/ec-stripe.t
new file mode 100644
index 00000000000..98b92294feb
--- /dev/null
+++ b/tests/basic/ec/ec-stripe.t
@@ -0,0 +1,227 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# These tests will check the stripe cache functionality of
+# disperse volume
+
+test_index=0
+stripe_count=4
+loop_test=0
+
+TESTS_EXPECTED_IN_LOOP=182
+
+function get_mount_stripe_cache {
+        local sd=$1
+        local field=$2
+        local val=$(grep "$field" $sd | cut -f2 -d'=' | tail -1)
+        echo $val
+}
+
+function get_stripes_in_cache {
+        local target=$1
+        local count=$2
+        local c=0
+        for (( c=0; c<$count; c++ ))
+        do
+            let x=102+$c*1024
+            echo yy | dd of=$target oflag=seek_bytes,sync seek=$x conv=notrunc
+            if [ $? != 0 ]
+            then
+                break
+            fi
+        done
+        echo "$c"
+}
+# tests in this loop = 7
+function mount_get_test_files {
+        let test_index+=1
+        let loop_test+=7
+        echo "Test Case $test_index"
+        local stripe_count=$1
+        TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+        EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+        TEST dd if=/dev/urandom of=$B0/test_file bs=1024 count=20
+        TEST cp $B0/test_file $M0/test_file
+        TEST dd if=/dev/urandom of=$B0/misc_file bs=1024 count=20
+        EXPECT_WITHIN $UMOUNT_TIMEOUT "$stripe_count" get_stripes_in_cache $B0/test_file $stripe_count
+        EXPECT_WITHIN $UMOUNT_TIMEOUT "$stripe_count" get_stripes_in_cache $M0/test_file $stripe_count
+}
+
+#check_statedump_md5sum (hitcount misscount)
+#tests in this loop = 4
+function check_statedump_md5sum {
+        statedump=$(generate_mount_statedump $V0)
+        let loop_test+=4
+        sleep 1
+        nhits=$(get_mount_stripe_cache $statedump "hits")
+        nmisses=$(get_mount_stripe_cache $statedump "misses")
+        EXPECT "$1" echo $nhits
+        EXPECT "$2" echo $nmisses
+        TEST md5_sum=`get_md5_sum $B0/test_file`
+        EXPECT $md5_sum get_md5_sum $M0/test_file
+}
+
+#tests in this loop = 2
+function clean_file_unmount {
+        let loop_test+=2
+        TEST rm -f $B0/test_file $M0/test_file $B0/misc_file
+        cleanup_mount_statedump $V0
+        EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+}
+
+cleanup
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..2}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 disperse.background-heals 0
+TEST $CLI volume set $V0 disperse.eager-lock on
+TEST $CLI volume set $V0 disperse.other-eager-lock on
+TEST $CLI volume set $V0 disperse.stripe-cache 8
+TEST $CLI volume start $V0
+
+### 1 - offset and size in one stripes ####
+
+mount_get_test_files $stripe_count
+# This should have 4 hits on cached stripes
+get_stripes_in_cache $M0/test_file $stripe_count
+check_statedump_md5sum 4 4
+clean_file_unmount
+
+### 2 - Length less than a stripe size, covering two stripes ####
+
+mount_get_test_files $stripe_count
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1022 count=1  oflag=seek_bytes,sync seek=102 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1022 count=1  oflag=seek_bytes,sync seek=102 conv=notrunc
+check_statedump_md5sum 2 4
+clean_file_unmount
+
+### 3 -Length exactly equal to the stripe size, covering a single stripe  ####
+
+mount_get_test_files $stripe_count
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=0 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=0 conv=notrunc
+check_statedump_md5sum 0 4
+clean_file_unmount
+
+### 4 - Length exactly equal to the stripe size, covering two stripes  ####
+
+mount_get_test_files $stripe_count
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=2048 count=1  oflag=seek_bytes,sync seek=1024 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=2048 count=1  oflag=seek_bytes,sync seek=1024 conv=notrunc
+check_statedump_md5sum 0 4
+clean_file_unmount
+
+### 5 - Length greater than a stripe size, covering two stripes  ####
+
+mount_get_test_files $stripe_count
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1030 count=1  oflag=seek_bytes,sync seek=500 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1030 count=1  oflag=seek_bytes,sync seek=500 conv=notrunc
+check_statedump_md5sum 2 4
+clean_file_unmount
+
+### 6 - Length greater than a stripe size, covering three stripes  ####
+
+mount_get_test_files $stripe_count
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=2078 count=1  oflag=seek_bytes,sync seek=1000 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=2078 count=1  oflag=seek_bytes,sync seek=1000 conv=notrunc
+check_statedump_md5sum 2 4
+clean_file_unmount
+
+### 7 - Discard range - all stripe from cache should be invalidated complete stripes  ####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 0 -l 5120 $B0/test_file
+TEST fallocate -p -o 0 -l 5120 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=6  oflag=seek_bytes,sync seek=1030 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=6  oflag=seek_bytes,sync seek=1030 conv=notrunc
+check_statedump_md5sum 5 11
+clean_file_unmount
+
+### 8 - Discard range - starts in the middle of stripe, ends on the middle of next stripe####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 500 -l 1024 $B0/test_file
+TEST fallocate -p -o 500 -l 1024 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=5  oflag=seek_bytes,sync seek=500 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=5  oflag=seek_bytes,sync seek=500 conv=notrunc
+check_statedump_md5sum 10 6
+clean_file_unmount
+
+### 9 - Discard range - starts in the middle of stripe, ends on the middle of 3rd stripe#####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 500 -l 2048 $B0/test_file
+TEST fallocate -p -o 500 -l 2048 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=5  oflag=seek_bytes,sync seek=500 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=5  oflag=seek_bytes,sync seek=500 conv=notrunc
+check_statedump_md5sum 9 7
+clean_file_unmount
+
+### 10 - Discard range - starts and end within one stripe ####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 500 -l 100 $B0/test_file
+TEST fallocate -p -o 500 -l 100 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=0 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=0 conv=notrunc
+check_statedump_md5sum 1 4
+clean_file_unmount
+
+### 11 - Discard range - starts and end in one complete stripe ####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 0 -l 1024 $B0/test_file
+TEST fallocate -p -o 0 -l 1024 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=512 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=512 conv=notrunc
+check_statedump_md5sum 1 5
+clean_file_unmount
+
+### 12 - Discard range - starts and end two complete stripe ####
+
+mount_get_test_files $stripe_count
+TEST fallocate -p -o 0 -l 2048 $B0/test_file
+TEST fallocate -p -o 0 -l 2048 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=4  oflag=seek_bytes,sync seek=300 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=4  oflag=seek_bytes,sync seek=300 conv=notrunc
+check_statedump_md5sum 5 7
+clean_file_unmount
+
+### 13 - Truncate to invalidate  all the stripe in cache  ####
+
+mount_get_test_files $stripe_count
+TEST truncate -s 0 $B0/test_file
+TEST truncate -s 0 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1022 count=5  oflag=seek_bytes,sync seek=400 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1022 count=5  oflag=seek_bytes,sync seek=400 conv=notrunc
+check_statedump_md5sum 4 4
+clean_file_unmount
+
+### 14 - Truncate to invalidate  all but one the stripe in cache  ####
+
+mount_get_test_files $stripe_count
+TEST truncate -s 500 $B0/test_file
+TEST truncate -s 500 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=525 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1024 count=1  oflag=seek_bytes,sync seek=525 conv=notrunc
+check_statedump_md5sum  2 4
+clean_file_unmount
+
+### 15 - Truncate to invalidate  all but one the stripe in cache  ####
+mount_get_test_files $stripe_count
+TEST truncate -s 2148 $B0/test_file
+TEST truncate -s 2148 $M0/test_file
+TEST dd if=$B0/misc_file of=$B0/test_file  bs=1000 count=1  oflag=seek_bytes,sync seek=2050 conv=notrunc
+TEST dd if=$B0/misc_file of=$M0/test_file  bs=1000 count=1  oflag=seek_bytes,sync seek=2050 conv=notrunc
+check_statedump_md5sum 2 4
+clean_file_unmount
+echo "Total loop tests $loop_test"
+cleanup
diff --git a/tests/basic/ec/ec-up.t b/tests/basic/ec/ec-up.t
new file mode 100644
index 00000000000..d54e7e1d022
--- /dev/null
+++ b/tests/basic/ec/ec-up.t
@@ -0,0 +1,28 @@
+#!/bin/bash
+#Tests that ec subvolume is up/down correctly
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../ec.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse-data 2 redundancy 1 $H0:$B0/${V0}{0,1,3,4,5,6}
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+EXPECT "1" ec_up_status $V0 $M0 0
+EXPECT "1" ec_up_status $V0 $M0 1
+
+#kill two bricks in first disperse subvolume and check that ec_up_status is 0 for it
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" ec_up_status $V0 $M0 0
+EXPECT "1" ec_up_status $V0 $M0 1
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ec_up_status $V0 $M0 0
+EXPECT "1" ec_up_status $V0 $M0 1
+cleanup;
diff --git a/tests/basic/ec/gfapi-ec-open-truncate.c b/tests/basic/ec/gfapi-ec-open-truncate.c
new file mode 100644
index 00000000000..fb16807003a
--- /dev/null
+++ b/tests/basic/ec/gfapi-ec-open-truncate.c
@@ -0,0 +1,171 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
+
+int
+fill_iov(struct iovec *iov, char fillchar, int count)
+{
+    int ret = -1;
+
+    iov->iov_base = calloc(count + 1, sizeof(fillchar));
+    if (iov->iov_base == NULL) {
+        return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
+}
+
+glfs_t *
+init_glfs(const char *hostname, const char *volname, const char *logfile)
+{
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
+
+    return fs;
+}
+
+int
+main(int argc, char *argv[])
+{
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    int ret = 0;
+    int i = 0;
+    int count = 200;
+    struct iovec iov = {0};
+    int flags = O_RDWR;
+    int bricksup = 0;
+    int fdopen = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    /* Brick is down and we are opening a file to trigger fd heal. */
+    /* Bypass Write-behind */
+    glfd = glfs_open(fs, "a", O_WRONLY | O_TRUNC | O_SYNC);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_open_truncate failed");
+        exit(1);
+    }
+    system("gluster --mode=script volume start patchy force");
+    /*CHILD_UP_TIMEOUT is 20 seconds*/
+    for (i = 0; i < 20; i++) {
+        ret = system(
+            "[ $(gluster --mode=script volume status patchy | "
+            "grep \" Y \" | awk '{print $(NF-1)}' | wc -l) == 3 ]");
+        if (WIFEXITED(ret) && WEXITSTATUS(ret)) {
+            printf("Ret value of system: %d\n, ifexited: %d, exitstatus: %d",
+                   ret, WIFEXITED(ret), WEXITSTATUS(ret));
+            sleep(1);
+            continue;
+        }
+        printf("Number of loops: %d\n", i);
+        bricksup = 1;
+        break;
+    }
+    if (!bricksup) {
+        system("gluster --mode=script volume status patchy");
+        LOG_ERR("Bricks didn't come up\n");
+        exit(1);
+    }
+
+    /*Not sure how to check that the child-up reached EC, so sleep 3 for now*/
+    sleep(3);
+    ret = fill_iov(&iov, 'a', 200);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        exit(1);
+    }
+
+    /*write will trigger re-open*/
+    ret = glfs_pwritev(glfd, &iov, 1, 0, flags);
+    if (ret < 0) {
+        LOG_ERR("glfs_test_function failed");
+        exit(1);
+    }
+    /*Check reopen happened by checking for open-fds on the brick*/
+    for (i = 0; i < 20; i++) {
+        ret = system(
+            "[ $(for i in $(pgrep glusterfsd); do ls -l /proc/$i/fd | grep "
+            "\"[.]glusterfs\" | grep -v \".glusterfs/[0-9a-f][0-9a-f]\" | grep "
+            "-v health_check; done | wc -l) == 3 ]");
+        if (WIFEXITED(ret) && WEXITSTATUS(ret)) {
+            printf("Ret value of system: %d\n, ifexited: %d, exitstatus: %d",
+                   ret, WIFEXITED(ret), WEXITSTATUS(ret));
+            sleep(1);
+            continue;
+        }
+        fdopen = 1;
+        break;
+    }
+
+    if (!fdopen) {
+        LOG_ERR("fd reopen didn't succeed");
+        exit(1);
+    }
+
+    return 0;
+}
diff --git a/tests/basic/ec/gfapi-ec-open-truncate.t b/tests/basic/ec/gfapi-ec-open-truncate.t
new file mode 100644
index 00000000000..e22562c6ea3
--- /dev/null
+++ b/tests/basic/ec/gfapi-ec-open-truncate.t
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+#This .t tests the functionality of open-fd-heal when opened with O_TRUNC.
+#If re-open is not done with O_TRUNC then the test will pass.
+
+cleanup
+
+TEST glusterd
+
+TEST $CLI volume create $V0 disperse 3 ${H0}:$B0/brick{1,2,3}
+EXPECT 'Created' volinfo_field $V0 'Status'
+#Disable heals to prevent any chance of heals masking the problem
+TEST $CLI volume set $V0 disperse.background-heals 0
+TEST $CLI volume set $V0 disperse.heal-wait-qlength 0
+TEST $CLI volume set $V0 performance.write-behind off
+
+#We need truncate fop to go through before pre-op completes for the write-fop
+#which triggers open-fd heal. Otherwise truncate won't be allowed on 'bad' brick
+TEST $CLI volume set $V0 delay-gen posix
+TEST $CLI volume set $V0 delay-gen.enable fxattrop
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.delay-duration 1000000
+
+TEST $CLI volume heal $V0 disable
+
+TEST $CLI volume start $V0
+TEST $CLI volume profile $V0 start
+EXPECT 'Started' volinfo_field $V0 'Status'
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+TEST touch $M0/a
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST kill_brick $V0 $H0 $B0/brick1
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/gfapi-ec-open-truncate.c -lgfapi
+
+TEST $CLI volume profile $V0 info clear
+TEST ./$(dirname $0)/gfapi-ec-open-truncate ${H0} $V0 $logdir/gfapi-ec-open-truncate.log
+
+EXPECT "^2$" echo $($CLI volume profile $V0 info incremental | grep -i truncate | wc -l)
+cleanup_tester $(dirname $0)/gfapi-ec-open-truncate
+
+cleanup
diff --git a/tests/basic/ec/heal-info.t b/tests/basic/ec/heal-info.t
index 7393d22d222..1549d5fcdb0 100644
--- a/tests/basic/ec/heal-info.t
+++ b/tests/basic/ec/heal-info.t
@@ -71,3 +71,4 @@ done
 EXPECT "^105$" get_pending_heal_count $V0
 
 cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=1533815
diff --git a/tests/basic/ec/lock-contention.t b/tests/basic/ec/lock-contention.t
new file mode 100644
index 00000000000..8f86cee16ad
--- /dev/null
+++ b/tests/basic/ec/lock-contention.t
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# This test verifies that when 'lock-notify-contention' option is enabled,
+# locks xlator actually sends an upcall notification that causes the acquired
+# lock from one client to be released before it's supposed to when another
+# client accesses the file.
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+function elapsed_time() {
+        local start="`date +%s`"
+
+        if [[ "test" == `cat "$1"` ]]; then
+                echo "$((`date +%s` - ${start}))"
+        fi
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0..2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 features.locks-notify-contention off
+TEST $CLI volume set $V0 disperse.eager-lock on
+TEST $CLI volume set $V0 disperse.eager-lock-timeout 6
+TEST $CLI volume set $V0 disperse.other-eager-lock on
+TEST $CLI volume set $V0 disperse.other-eager-lock-timeout 6
+TEST $CLI volume start $V0
+
+TEST $GFS --direct-io-mode=yes --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0 $M0
+
+TEST $GFS --direct-io-mode=yes --volfile-id=/$V0 --volfile-server=$H0 $M1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0 $M1
+
+TEST $(echo "test" >$M0/file)
+
+# With locks-notify-contention set to off, accessing the file from another
+# client should take 6 seconds. Checking against 3 seconds to be safe.
+elapsed="$(elapsed_time $M1/file)"
+TEST [[ ${elapsed} -ge 3 ]]
+
+elapsed="$(elapsed_time $M0/file)"
+TEST [[ ${elapsed} -ge 3 ]]
+
+TEST $CLI volume set $V0 features.locks-notify-contention on
+
+# With locks-notify-contention set to on, accessing the file from another
+# client should be fast. Checking against 3 seconds to be safe.
+elapsed="$(elapsed_time $M1/file)"
+TEST [[ ${elapsed} -le 3 ]]
+
+elapsed="$(elapsed_time $M0/file)"
+TEST [[ ${elapsed} -le 3 ]]
+
+cleanup
diff --git a/tests/basic/ec/nfs.t b/tests/basic/ec/nfs.t
index f0bdff93d5f..3f51a640ef7 100755
--- a/tests/basic/ec/nfs.t
+++ b/tests/basic/ec/nfs.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup
 
 TEST glusterd
diff --git a/tests/basic/ec/seek.c b/tests/basic/ec/seek.c
deleted file mode 100644
index 67036ad4e75..00000000000
--- a/tests/basic/ec/seek.c
+++ /dev/null
@@ -1,185 +0,0 @@
-
-#define _GNU_SOURCE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <string.h>
-#include <errno.h>
-
-static char buffer[65536];
-
-static int
-parse_int(const char *text, size_t *value)
-{
-        char *ptr;
-        size_t val;
-
-        val = strtoul(text, &ptr, 0);
-        if (*ptr != 0) {
-                return 0;
-        }
-
-        *value = val;
-
-        return 1;
-}
-
-static int
-fill_area(int fd, off_t offset, size_t size)
-{
-        size_t len;
-        ssize_t res;
-
-        while (size > 0) {
-                len = sizeof(buffer);
-                if (len > size) {
-                        len = size;
-                }
-                res = pwrite(fd, buffer, len, offset);
-                if (res < 0) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) failed: %d\n",
-                                fd, buffer, size, offset, errno);
-                        return 0;
-                }
-                if (res != len) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) didn't wrote all "
-                                "data: %lu/%lu\n",
-                                fd, buffer, size, offset, res, len);
-                        return 0;
-                }
-                offset += len;
-                size -= len;
-        }
-
-        return 1;
-}
-
-static void
-syntax(void)
-{
-        fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
-        fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
-}
-
-static int
-seek_create(const char *path, int argc, char *argv[])
-{
-        size_t off, size;
-        int fd;
-        int ret = 1;
-
-        fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to create the file\n");
-                goto out;
-        }
-
-        while (argc > 0) {
-                if (!parse_int(argv[0], &off) ||
-                    !parse_int(argv[1], &size)) {
-                        syntax();
-                        goto out_close;
-                }
-                if (!fill_area(fd, off, size)) {
-                        goto out_close;
-                }
-                argv += 2;
-                argc -= 2;
-        }
-
-        ret = 0;
-
-out_close:
-        close(fd);
-out:
-        return ret;
-}
-
-static int
-seek_scan(const char *path, const char *type, const char *pos)
-{
-        size_t off, res;
-        int fd, whence;
-        int ret = 1;
-
-        if (strcmp(type, "data") == 0) {
-                whence = SEEK_DATA;
-        } else if (strcmp(type, "hole") == 0) {
-                whence = SEEK_HOLE;
-        } else {
-                syntax();
-                goto out;
-        }
-
-        if (!parse_int(pos, &off)) {
-                syntax();
-                goto out;
-        }
-
-        fd = open(path, O_RDWR);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to open the file\n");
-                goto out;
-        }
-
-        res = lseek(fd, off, whence);
-        if (res == (off_t)-1) {
-                if (errno != ENXIO) {
-                        fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd,
-                                off, whence, errno);
-                        goto out_close;
-                }
-                fprintf(stdout, "ENXIO\n");
-        } else {
-                fprintf(stdout, "%lu\n", res);
-        }
-
-        ret = 0;
-
-out_close:
-        close(fd);
-out:
-        return ret;
-}
-
-int
-main(int argc, char *argv[])
-{
-        int ret = 1;
-
-        memset(buffer, 0x55, sizeof(buffer));
-
-        if (argc < 3) {
-                syntax();
-                goto out;
-        }
-
-        if (strcmp(argv[1], "create") == 0) {
-                if (((argc - 3) & 1) != 0) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_create(argv[2], argc - 3, argv + 3);
-        } else if (strcmp(argv[1], "scan") == 0) {
-                if (argc != 5) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_scan(argv[2], argv[3], argv[4]);
-        } else {
-                syntax();
-                goto out;
-        }
-
-        ret = 0;
-
-out:
-        return ret;
-}
-
diff --git a/tests/basic/ec/self-heal-read-write-fail.t b/tests/basic/ec/self-heal-read-write-fail.t
new file mode 100644
index 00000000000..0ba591b5bb2
--- /dev/null
+++ b/tests/basic/ec/self-heal-read-write-fail.t
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+#This test verifies that self-heal fails when read/write fails as part of heal
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+TEST touch $M0/a
+TEST kill_brick $V0 $H0 $B0/${V0}0
+echo abc >> $M0/a
+
+# Umount the volume to force all pending writes to reach the bricks
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#Load error-gen and fail read fop and test that heal fails
+TEST $CLI volume stop $V0 #Stop volume so that error-gen can be loaded
+TEST $CLI volume set $V0 debug.error-gen posix
+TEST $CLI volume set $V0 debug.error-fops read
+TEST $CLI volume set $V0 debug.error-number EBADF
+TEST $CLI volume set $V0 debug.error-failure 100
+
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+TEST ! getfattr -n trusted.ec.heal $M0/a
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+
+#fail write fop and test that heal fails
+TEST $CLI volume stop $V0
+TEST $CLI volume set $V0 debug.error-fops write
+
+TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+TEST ! getfattr -n trusted.ec.heal $M0/a
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+
+TEST $CLI volume stop $V0 #Stop volume so that error-gen can be disabled
+TEST $CLI volume reset $V0 debug.error-gen
+TEST $CLI volume reset $V0 debug.error-fops
+TEST $CLI volume reset $V0 debug.error-number
+TEST $CLI volume reset $V0 debug.error-failure
+
+TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" ec_child_up_count $V0 0
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+TEST getfattr -n trusted.ec.heal $M0/a
+EXPECT "^0$" get_pending_heal_count $V0
+
+#Test that heal worked as expected by forcing read from brick0
+#remount to make sure data is not served from any cache
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT "abc" cat $M0/a
+
+cleanup
diff --git a/tests/basic/ec/self-heal.t b/tests/basic/ec/self-heal.t
index 7f3486fe27b..6329bb60248 100644
--- a/tests/basic/ec/self-heal.t
+++ b/tests/basic/ec/self-heal.t
@@ -1,5 +1,7 @@
 #!/bin/bash
 
+SCRIPT_TIMEOUT=300
+
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 
@@ -129,6 +131,8 @@ TEST $CLI volume create $V0 redundancy 2 $H0:$B0/${V0}{0..5}
 TEST $CLI volume set $V0 client-log-level DEBUG
 #Write-behind has a bug where lookup can race over write which leads to size mismatch on the mount after a 'cp'
 TEST $CLI volume set $V0 performance.write-behind off
+#md-cache can return stale stat due to default timeout being 1 sec
+TEST $CLI volume set $V0 performance.stat-prefetch off
 EXPECT "Created" volinfo_field $V0 'Status'
 TEST $CLI volume start $V0
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Started" volinfo_field $V0 'Status'
diff --git a/tests/basic/fencing/afr-lock-heal-advanced.c b/tests/basic/fencing/afr-lock-heal-advanced.c
new file mode 100644
index 00000000000..e202ccd5b29
--- /dev/null
+++ b/tests/basic/fencing/afr-lock-heal-advanced.c
@@ -0,0 +1,227 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <unistd.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define GF_ENFORCE_MANDATORY_LOCK "trusted.glusterfs.enforce-mandatory-lock"
+
+FILE *logfile_fp;
+
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!logfile_fp) {                                                     \
+            fprintf(stderr, "%\n%d %s : returned error (%s)\n", __LINE__,      \
+                    func, strerror(err));                                      \
+            fflush(stderr);                                                    \
+        } else {                                                               \
+            fprintf(logfile_fp, "\n%d %s : returned error (%s)\n", __LINE__,   \
+                    func, strerror(err));                                      \
+            fflush(logfile_fp);                                                \
+        }                                                                      \
+    } while (0)
+
+glfs_t *
+setup_client(char *hostname, char *volname, char *log_file)
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(logfile_fp, "\nglfs_new: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
+                ret, strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_set_logging failed with ret: %d (%s)\n",
+                ret, strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+out:
+    return fs;
+error:
+    return NULL;
+}
+
+glfs_fd_t *
+open_file(glfs_t *fs, char *fname)
+{
+    glfs_fd_t *fd = NULL;
+
+    fd = glfs_creat(fs, fname, O_CREAT, 0644);
+    if (!fd) {
+        LOG_ERR("glfs_creat", errno);
+        goto out;
+    }
+out:
+    return fd;
+}
+
+int
+acquire_mandatory_lock(glfs_t *fs, glfs_fd_t *fd)
+{
+    struct flock lock;
+    int ret = 0;
+
+    /* initialize lock */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 100;
+
+    ret = glfs_fsetxattr(fd, GF_ENFORCE_MANDATORY_LOCK, "set", 8, 0);
+    if (ret < 0) {
+        LOG_ERR("glfs_fsetxattr", errno);
+        ret = -1;
+        goto out;
+    }
+
+    /* take a write mandatory lock */
+    ret = glfs_file_lock(fd, F_SETLKW, &lock, GLFS_LK_MANDATORY);
+    if (ret) {
+        LOG_ERR("glfs_file_lock", errno);
+        ret = -1;
+        goto out;
+    }
+
+out:
+    return ret;
+}
+
+int
+perform_test(glfs_t *fs, char *file1, char *file2)
+{
+    int ret = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *buf = "0123456789";
+
+    fd1 = open_file(fs, file1);
+    if (!fd1) {
+        ret = -1;
+        goto out;
+    }
+    fd2 = open_file(fs, file2);
+    if (!fd2) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Kill one brick from the .t.*/
+    pause();
+
+    ret = acquire_mandatory_lock(fs, fd1);
+    if (ret) {
+        goto out;
+    }
+    ret = acquire_mandatory_lock(fs, fd2);
+    if (ret) {
+        goto out;
+    }
+
+    /* Bring the brick up and let the locks heal. */
+    pause();
+    /*At this point, the .t would have killed and brought back 2 bricks, marking
+     * the fd bad.*/
+
+    ret = glfs_write(fd1, buf, 10, 0);
+    if (ret > 0) {
+        /* Write is supposed to fail with EBADFD*/
+        LOG_ERR("glfs_write", ret);
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (fd1)
+        glfs_close(fd1);
+    if (fd2)
+        glfs_close(fd2);
+    return ret;
+}
+
+static void
+sigusr1_handler(int signo)
+{
+    /*Signal caught. Just continue with the execution.*/
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char log_file[100];
+    char *hostname = NULL;
+    char *fname1 = NULL;
+    char *fname2 = NULL;
+
+    if (argc != 7) {
+        fprintf(stderr,
+                "Expect following args %s <host> <volname> <file1> <file2> "
+                "<log file "
+                "location> <log_file_suffix>\n",
+                argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    fname1 = argv[3];
+    fname2 = argv[4];
+
+    /*Use SIGUSR1 and pause()as a means of hitting break-points this program
+     *when signalled from the .t test case.*/
+    if (signal(SIGUSR1, sigusr1_handler) == SIG_ERR) {
+        LOG_ERR("SIGUSR1 handler error", errno);
+        exit(EXIT_FAILURE);
+    }
+
+    sprintf(log_file, "%s/%s.%s.%s", argv[5], "lock-heal.c", argv[6], "log");
+    logfile_fp = fopen(log_file, "w");
+    if (!logfile_fp) {
+        fprintf(stderr, "\nfailed to open %s\n", log_file);
+        fflush(stderr);
+        return -1;
+    }
+
+    sprintf(log_file, "%s/%s.%s.%s", argv[5], "glfs-client", argv[6], "log");
+    fs = setup_client(hostname, volname, log_file);
+    if (!fs) {
+        LOG_ERR("setup_client", errno);
+        return -1;
+    }
+
+    ret = perform_test(fs, fname1, fname2);
+
+error:
+    if (fs) {
+        /*glfs_fini(fs)*/;  // glfs fini path is racy and crashes the program
+    }
+
+    fclose(logfile_fp);
+
+    return ret;
+}
diff --git a/tests/basic/fencing/afr-lock-heal-advanced.t b/tests/basic/fencing/afr-lock-heal-advanced.t
new file mode 100644
index 00000000000..8a5b5989b5e
--- /dev/null
+++ b/tests/basic/fencing/afr-lock-heal-advanced.t
@@ -0,0 +1,115 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+PROCESS_UP_TIMEOUT=90
+
+function is_gfapi_program_alive()
+{
+        pid=$1
+        ps -p $pid
+        if [ $? -eq 0 ]
+        then
+                echo "Y"
+        else
+                echo "N"
+        fi
+}
+
+function get_active_lock_count {
+    brick=$1
+    i1=$2
+    i2=$3
+    pattern="ACTIVE.*client-${brick: -1}"
+
+    sdump=$(generate_brick_statedump $V0 $H0 $brick)
+    lock_count1="$(egrep "$i1" $sdump -A3| egrep "$pattern"|uniq|wc -l)"
+    lock_count2="$(egrep "$i2" $sdump -A3| egrep "$pattern"|uniq|wc -l)"
+    echo "$((lock_count1+lock_count2))"
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+EXPECT 'Created' volinfo_field $V0 'Status';
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 locks.mandatory-locking forced
+TEST $CLI volume set $V0 enforce-mandatory-lock on
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+TEST build_tester $(dirname $0)/afr-lock-heal-advanced.c -lgfapi -ggdb
+
+#------------------------------------------------------------------------------
+# Use more than 1 fd from same client so that list_for_each_* loops are executed more than once.
+$(dirname $0)/afr-lock-heal-advanced $H0 $V0 "/FILE1" "/FILE2" $logdir C1&
+client_pid=$!
+TEST [ $client_pid ]
+
+TEST sleep 5 # By now, the client would  have opened an fd on FILE1 and FILE2 and waiting for a SIGUSR1.
+EXPECT "Y" is_gfapi_program_alive $client_pid
+
+gfid_str1=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/FILE1))
+inode1="FILE1|gfid:$gfid_str1"
+gfid_str2=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/FILE2))
+inode2="FILE2|gfid:$gfid_str2"
+
+# Kill brick-3 and let client-1 take lock on both files.
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST kill -SIGUSR1 $client_pid
+# If program is still alive, glfs_file_lock() was a success.
+EXPECT "Y" is_gfapi_program_alive $client_pid
+
+# Check lock is present on brick-1 and brick-2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" get_active_lock_count $B0/${V0}0 $inode1 $inode2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" get_active_lock_count $B0/${V0}1 $inode1 $inode2
+
+# Restart brick-3 and check that the lock has healed on it.
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST sleep 10 #Needed for client to re-open fd? Otherwise client_pre_lk_v2() fails with EBADFD for remote-fd.
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" get_active_lock_count $B0/${V0}2 $inode1 $inode2
+
+#------------------------------------------------------------------------------
+# Kill same brick before heal completes the first time and check it completes the second time.
+TEST $CLI volume set $V0 delay-gen locks
+TEST $CLI volume set $V0 delay-gen.delay-duration 5000000
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.enable finodelk
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST $CLI volume reset $V0 delay-gen
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" get_active_lock_count $B0/${V0}0 $inode1 $inode2
+
+#------------------------------------------------------------------------------
+# Kill 2 bricks and bring it back. The fds must be marked bad.
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
+# TODO: `gluster v statedump $V0 client localhost:$client_pid` is not working,
+# so sleep for 20 seconds for the client to connect to connect to the bricks.
+TEST sleep $CHILD_UP_TIMEOUT
+
+# Try to write to FILE1 from the .c; it must fail.
+TEST kill -SIGUSR1 $client_pid
+wait $client_pid
+ret=$?
+TEST [ $ret == 0 ]
+
+cleanup_tester $(dirname $0)/afr-lock-heal-advanced
+cleanup;
diff --git a/tests/basic/fencing/afr-lock-heal-basic.c b/tests/basic/fencing/afr-lock-heal-basic.c
new file mode 100644
index 00000000000..768c9e57181
--- /dev/null
+++ b/tests/basic/fencing/afr-lock-heal-basic.c
@@ -0,0 +1,182 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <unistd.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define GF_ENFORCE_MANDATORY_LOCK "trusted.glusterfs.enforce-mandatory-lock"
+
+FILE *logfile_fp;
+
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!logfile_fp) {                                                     \
+            fprintf(stderr, "%\n%d %s : returned error (%s)\n", __LINE__,      \
+                    func, strerror(err));                                      \
+            fflush(stderr);                                                    \
+        } else {                                                               \
+            fprintf(logfile_fp, "\n%d %s : returned error (%s)\n", __LINE__,   \
+                    func, strerror(err));                                      \
+            fflush(logfile_fp);                                                \
+        }                                                                      \
+    } while (0)
+
+glfs_t *
+setup_client(char *hostname, char *volname, char *log_file)
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(logfile_fp, "\nglfs_new: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
+                ret, strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_set_logging failed with ret: %d (%s)\n",
+                ret, strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(logfile_fp, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+out:
+    return fs;
+error:
+    return NULL;
+}
+
+int
+acquire_mandatory_lock(glfs_t *fs, char *fname)
+{
+    struct flock lock;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+
+    fd = glfs_creat(fs, fname, O_CREAT, 0644);
+    if (!fd) {
+        if (errno != EEXIST) {
+            LOG_ERR("glfs_creat", errno);
+            ret = -1;
+            goto out;
+        }
+        fd = glfs_open(fs, fname, O_RDWR | O_NONBLOCK);
+        if (!fd) {
+            LOG_ERR("glfs_open", errno);
+            ret = -1;
+            goto out;
+        }
+    }
+
+    /* initialize lock */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 100;
+
+    ret = glfs_fsetxattr(fd, GF_ENFORCE_MANDATORY_LOCK, "set", 8, 0);
+    if (ret < 0) {
+        LOG_ERR("glfs_fsetxattr", errno);
+        ret = -1;
+        goto out;
+    }
+
+    pause();
+
+    /* take a write mandatory lock */
+    ret = glfs_file_lock(fd, F_SETLKW, &lock, GLFS_LK_MANDATORY);
+    if (ret) {
+        LOG_ERR("glfs_file_lock", errno);
+        goto out;
+    }
+
+    pause();
+
+out:
+    if (fd) {
+        glfs_close(fd);
+    }
+
+    return ret;
+}
+
+static void
+sigusr1_handler(int signo)
+{
+    /*Signal caught. Just continue with the execution.*/
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char log_file[100];
+    char *hostname = NULL;
+    char *fname = NULL;
+
+    if (argc != 6) {
+        fprintf(stderr,
+                "Expect following args %s <host> <volname> <file> <log file "
+                "location> <log_file_suffix>\n",
+                argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    fname = argv[3];
+
+    /*Use SIGUSR1 and pause()as a means of hitting break-points this program
+     *when signalled from the .t test case.*/
+    if (signal(SIGUSR1, sigusr1_handler) == SIG_ERR) {
+        LOG_ERR("SIGUSR1 handler error", errno);
+        exit(EXIT_FAILURE);
+    }
+
+    sprintf(log_file, "%s/%s.%s.%s", argv[4], "lock-heal-basic.c", argv[5],
+            "log");
+    logfile_fp = fopen(log_file, "w");
+    if (!logfile_fp) {
+        fprintf(stderr, "\nfailed to open %s\n", log_file);
+        fflush(stderr);
+        return -1;
+    }
+
+    sprintf(log_file, "%s/%s.%s.%s", argv[4], "glfs-client", argv[5], "log");
+    fs = setup_client(hostname, volname, log_file);
+    if (!fs) {
+        LOG_ERR("setup_client", errno);
+        return -1;
+    }
+
+    ret = acquire_mandatory_lock(fs, fname);
+
+error:
+    if (fs) {
+        /*glfs_fini(fs)*/;  // glfs fini path is racy and crashes the program
+    }
+
+    fclose(logfile_fp);
+
+    return ret;
+}
diff --git a/tests/basic/fencing/afr-lock-heal-basic.t b/tests/basic/fencing/afr-lock-heal-basic.t
new file mode 100644
index 00000000000..69131af085d
--- /dev/null
+++ b/tests/basic/fencing/afr-lock-heal-basic.t
@@ -0,0 +1,102 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+function is_gfapi_program_alive()
+{
+        pid=$1
+        ps -p $pid
+        if [ $? -eq 0 ]
+        then
+                echo "Y"
+        else
+                echo "N"
+        fi
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+EXPECT 'Created' volinfo_field $V0 'Status';
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 locks.mandatory-locking forced
+TEST $CLI volume set $V0 enforce-mandatory-lock on
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+TEST build_tester $(dirname $0)/afr-lock-heal-basic.c -lgfapi -ggdb
+
+$(dirname $0)/afr-lock-heal-basic $H0 $V0 "/FILE" $logdir C1&
+client1_pid=$!
+TEST [ $client1_pid ]
+
+$(dirname $0)/afr-lock-heal-basic $H0 $V0 "/FILE" $logdir C2&
+client2_pid=$!
+TEST [ $client2_pid ]
+
+TEST sleep 5 # By now, the 2 clients would  have opened an fd on FILE and waiting for a SIGUSR1.
+EXPECT "Y" is_gfapi_program_alive $client1_pid
+EXPECT "Y" is_gfapi_program_alive $client2_pid
+
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/FILE))
+inode="FILE|gfid:$gfid_str"
+
+# Kill brick-3 and let client-1 take lock on the file.
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST kill -SIGUSR1 $client1_pid
+# If program is still alive, glfs_file_lock() was a success.
+EXPECT "Y" is_gfapi_program_alive $client1_pid
+
+# Check lock is present on brick-1 and brick-2
+b1_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}0)
+c1_lock_on_b1="$(egrep "$inode" $b1_sdump -A3| egrep 'ACTIVE.*client-0'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+b2_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}1)
+c1_lock_on_b2="$(egrep "$inode" $b2_sdump -A3| egrep 'ACTIVE.*client-1'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+TEST [ "$c1_lock_on_b1" == "$c1_lock_on_b2" ]
+
+# Restart brick-3 and check that the lock has healed on it.
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST sleep 10 #Needed for client to re-open fd? Otherwise client_pre_lk_v2() fails with EBADFD for remote-fd. Also wait for lock heal.
+
+b3_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}2)
+c1_lock_on_b3="$(egrep "$inode" $b3_sdump -A3| egrep 'ACTIVE.*client-2'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+TEST [ "$c1_lock_on_b1" == "$c1_lock_on_b3" ]
+
+# Kill brick-1 and let client-2 preempt the lock on bricks 2 and 3.
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill -SIGUSR1 $client2_pid
+# If program is still alive, glfs_file_lock() was a success.
+EXPECT "Y" is_gfapi_program_alive $client2_pid
+
+# Restart brick-1 and let lock healing complete.
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+TEST sleep 10 #Needed for client to re-open fd? Otherwise client_pre_lk_v2() fails with EBADFD for remote-fd. Also wait for lock heal.
+
+# Check that all bricks now have locks from client 2 only.
+b1_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}0)
+c2_lock_on_b1="$(egrep "$inode" $b1_sdump -A3| egrep 'ACTIVE.*client-0'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+b2_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}1)
+c2_lock_on_b2="$(egrep "$inode" $b2_sdump -A3| egrep 'ACTIVE.*client-1'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+b3_sdump=$(generate_brick_statedump $V0 $H0 $B0/${V0}2)
+c2_lock_on_b3="$(egrep "$inode" $b3_sdump -A3| egrep 'ACTIVE.*client-2'| uniq| awk '{print $1,$2,$3,S4,$5,$6,$7,$8}'|tr -d '(,), ,')"
+TEST [ "$c2_lock_on_b1" == "$c2_lock_on_b2" ]
+TEST [ "$c2_lock_on_b1" == "$c2_lock_on_b3" ]
+TEST [ "$c2_lock_on_b1" != "$c1_lock_on_b1" ]
+
+#Let the client programs run and exit.
+TEST kill -SIGUSR1 $client1_pid
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "N" is_gfapi_program_alive $client1_pid
+TEST kill -SIGUSR1 $client2_pid
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "N" is_gfapi_program_alive $client2_pid
+
+cleanup_tester $(dirname $0)/afr-lock-heal-basic
+cleanup;
diff --git a/tests/basic/fencing/fence-basic.c b/tests/basic/fencing/fence-basic.c
new file mode 100644
index 00000000000..4aa452e19b0
--- /dev/null
+++ b/tests/basic/fencing/fence-basic.c
@@ -0,0 +1,229 @@
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define NO_INIT 1
+#define GF_ENFORCE_MANDATORY_LOCK "trusted.glusterfs.enforce-mandatory-lock"
+
+FILE *fp;
+char *buf = "0123456789";
+
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!fp) {                                                             \
+            fprintf(stderr, "%\n%d %s : returned error (%s)\n", __LINE__,      \
+                    func, strerror(err));                                      \
+            fflush(stderr);                                                    \
+        } else {                                                               \
+            fprintf(fp, "\n%d %s : returned error (%s)\n", __LINE__, func,     \
+                    strerror(err));                                            \
+            fflush(fp);                                                        \
+        }                                                                      \
+    } while (0)
+
+glfs_t *
+setup_new_client(char *hostname, char *volname, char *log_file, int flag)
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(fp, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(fp, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(fp, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    if (flag == NO_INIT)
+        goto out;
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(fp, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+out:
+    return fs;
+error:
+    return NULL;
+}
+
+/* test plan
+ *
+ *  - take mandatory lock from client 1
+ *  - preempt mandatory lock from client 2
+ *  - write from client 1 which should fail
+ */
+
+int
+test(glfs_t *fs1, glfs_t *fs2, char *fname)
+{
+    struct flock lock;
+    int ret = 0;
+    glfs_fd_t *fd1, *fd2 = NULL;
+
+    fd1 = glfs_creat(fs1, fname, O_RDWR, 0777);
+    if (ret) {
+        LOG_ERR("glfs_creat", errno);
+        ret = -1;
+        goto out;
+    }
+
+    fd2 = glfs_open(fs2, fname, O_RDWR | O_NONBLOCK);
+    if (ret) {
+        LOG_ERR("glfs_open", errno);
+        ret = -1;
+        goto out;
+    }
+
+    /* initialize lock */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 100;
+
+    ret = glfs_fsetxattr(fd1, GF_ENFORCE_MANDATORY_LOCK, "set", 8, 0);
+    if (ret < 0) {
+        LOG_ERR("glfs_fsetxattr", errno);
+        ret = -1;
+        goto out;
+    }
+
+    /* take a write mandatory lock */
+    ret = glfs_file_lock(fd1, F_SETLKW, &lock, GLFS_LK_MANDATORY);
+    if (ret) {
+        LOG_ERR("glfs_file_lock", errno);
+        goto out;
+    }
+
+    ret = glfs_write(fd1, buf, 10, 0);
+    if (ret != 10) {
+        LOG_ERR("glfs_write", errno);
+        ret = -1;
+        goto out;
+    }
+
+    /* write should fail */
+    ret = glfs_write(fd2, buf, 10, 0);
+    if (ret != -1) {
+        LOG_ERR("glfs_write", errno);
+        ret = -1;
+        goto out;
+    }
+
+    /* preempt mandatory lock from client 1*/
+    ret = glfs_file_lock(fd2, F_SETLKW, &lock, GLFS_LK_MANDATORY);
+    if (ret) {
+        LOG_ERR("glfs_file_lock", errno);
+        goto out;
+    }
+
+    /* write should succeed from client 2 */
+    ret = glfs_write(fd2, buf, 10, 0);
+    if (ret == -1) {
+        LOG_ERR("glfs_write", errno);
+        goto out;
+    }
+
+    /* write should fail from client 1 */
+    ret = glfs_write(fd1, buf, 10, 0);
+    if (ret == 10) {
+        LOG_ERR("glfs_write", errno);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    if (fd1) {
+        glfs_close(fd1);
+    }
+
+    if (fd2) {
+        glfs_close(fd2);
+    }
+
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    glfs_t *fs1 = NULL;
+    glfs_t *fs2 = NULL;
+    char *volname = NULL;
+    char log_file[100];
+    char *hostname = NULL;
+    char *fname = "/file";
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+
+    sprintf(log_file, "%s/%s", argv[3], "fence-basic.log");
+    fp = fopen(log_file, "w");
+    if (!fp) {
+        fprintf(stderr, "\nfailed to open %s\n", log_file);
+        fflush(stderr);
+        return -1;
+    }
+
+    sprintf(log_file, "%s/%s", argv[3], "glfs-client-1.log");
+    fs1 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs1) {
+        LOG_ERR("setup_new_client", errno);
+        return -1;
+    }
+
+    sprintf(log_file, "%s/%s", argv[3], "glfs-client-2.log");
+    fs2 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs2) {
+        LOG_ERR("setup_new_client", errno);
+        ret = -1;
+        goto error;
+    }
+
+    ret = test(fs1, fs2, fname);
+
+error:
+    if (fs1) {
+        glfs_fini(fs1);
+    }
+
+    if (fs2) {
+        glfs_fini(fs2);
+    }
+
+    fclose(fp);
+
+    return ret;
+}
diff --git a/tests/basic/fencing/fence-basic.t b/tests/basic/fencing/fence-basic.t
new file mode 100755
index 00000000000..30f379e7b20
--- /dev/null
+++ b/tests/basic/fencing/fence-basic.t
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/brick1
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+TEST $CLI volume set $V0 diagnostics.client-log-flush-timeout 30
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 locks.mandatory-locking forced
+TEST $CLI volume set $V0 enforce-mandatory-lock on
+
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/fence-basic.c -lgfapi -ggdb
+TEST $(dirname $0)/fence-basic $H0 $V0 $logdir
+
+cleanup_tester $(dirname $0)/fence-basic
+
+cleanup;
+\ No newline at end of file
diff --git a/tests/basic/fencing/fencing-crash-conistency.t b/tests/basic/fencing/fencing-crash-conistency.t
new file mode 100644
index 00000000000..0c69411e90c
--- /dev/null
+++ b/tests/basic/fencing/fencing-crash-conistency.t
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+# with lock enforcement flag write should fail with out lock
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+EXPECT 'Created' volinfo_field $V0 'Status';
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $CLI volume set $V0 performance.write-behind off
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+TEST touch $M0/file
+
+#write should pass
+TEST "echo "test" > $M0/file"
+TEST "truncate -s 0 $M0/file"
+
+#enable mandatory locking
+TEST $CLI volume set $V0 locks.mandatory-locking forced
+TEST $CLI volume set $V0 enforce-mandatory-lock on
+
+#write should pass
+TEST "echo "test" >> $M0/file"
+TEST "truncate -s 0 $M0/file"
+
+#enforce lock on the file
+TEST setfattr -n trusted.glusterfs.enforce-mandatory-lock -v 1 $M0/file
+
+#write should fail
+TEST ! "echo "test" >> $M0/file"
+TEST ! "truncate -s 0 $M0/file"
+
+#remove lock enforcement flag
+TEST setfattr -x trusted.glusterfs.enforce-mandatory-lock $M0/file
+
+#write should pass
+TEST "echo "test" >> $M0/file"
+TEST "truncate -s 0 $M0/file"
+
+#enforce lock on the file
+TEST setfattr -n trusted.glusterfs.enforce-mandatory-lock -v 1 $M0/file
+#kill brick
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+TEST $CLI volume start $V0 force
+
+# wait one second for the brick to come online
+sleep 2
+#write should fail (lock xlator gets lock enforcement info from disk)
+TEST ! "echo "test" >> $M0/file"
+TEST ! "truncate -s 0 $M0/file"
+
+cleanup;
+\ No newline at end of file
diff --git a/tests/basic/fencing/test-fence-option.t b/tests/basic/fencing/test-fence-option.t
new file mode 100644
index 00000000000..115cbe7dbdf
--- /dev/null
+++ b/tests/basic/fencing/test-fence-option.t
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+# with lock enforcement flag write should fail with out lock
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+EXPECT 'Created' volinfo_field $V0 'Status';
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+TEST touch $M0/file
+
+#setfattr for mandatory-enforcement will fail
+TEST ! setfattr -n trusted.glusterfs.enforce-mandatory-lock -v 1 $M0/file
+
+#enable mandatory locking
+TEST $CLI volume set $V0 locks.mandatory-locking forced
+
+#setfattr will fail
+TEST ! setfattr -n trusted.glusterfs.enforce-mandatory-lock -v 1 $M0/file
+
+#set lock-enforcement option
+TEST $CLI volume set $V0 enforce-mandatory-lock on
+
+#setfattr should succeed
+TEST setfattr -n trusted.glusterfs.enforce-mandatory-lock -v 1 $M0/file
+
+cleanup;
+\ No newline at end of file
diff --git a/tests/basic/first-test.t b/tests/basic/first-test.t
deleted file mode 100755
index 535b269e6b3..00000000000
--- a/tests/basic/first-test.t
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-
-cat << EOF
-This test should run first for http://review.gluster.org/#/c/13439/ and should
-be removed once that patch has been merged.
-EOF
-
-TEST true
diff --git a/tests/basic/fops-sanity.c b/tests/basic/fops-sanity.c
index 1e2ccde6bd8..ef00aa0f088 100644
--- a/tests/basic/fops-sanity.c
+++ b/tests/basic/fops-sanity.c
@@ -26,6 +26,7 @@
 #include <errno.h>
 #include <string.h>
 #include <dirent.h>
+#include <sys/sysmacros.h>
 
 #ifndef linux
 #include <sys/socket.h>
@@ -34,858 +35,904 @@
 #endif
 
 /* for fd based fops after unlink */
-int fd_based_fops_1 (char *filename);
+int
+fd_based_fops_1(char *filename);
 /* for fd based fops before unlink */
-int fd_based_fops_2 (char *filename);
+int
+fd_based_fops_2(char *filename);
 /* fops based on fd after dup */
-int dup_fd_based_fops (char *filename);
+int
+dup_fd_based_fops(char *filename);
 /* for fops based on path */
-int path_based_fops (char *filename);
+int
+path_based_fops(char *filename);
 /* for fops which operate on directory */
-int dir_based_fops (char *filename);
+int
+dir_based_fops(char *filename);
 /* for fops which operate in link files (symlinks) */
-int link_based_fops (char *filename);
+int
+link_based_fops(char *filename);
 /* to test open syscall with open modes available. */
-int test_open_modes (char *filename);
+int
+test_open_modes(char *filename);
 /* generic function which does open write and read. */
-int generic_open_read_write (char *filename, int flag, mode_t mode);
+int
+generic_open_read_write(char *filename, int flag, mode_t mode);
 
-#define OPEN_MODE   0666
+#define OPEN_MODE 0666
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret           = -1;
-        int   result        = 0;
-        char  filename[255] = {0,};
-
-        if (argc > 1)
-                strcpy(filename, argv[1]);
-        else
-                strcpy(filename, "temp-xattr-test-file");
-
-        ret = fd_based_fops_1 (strcat(filename, "_1"));
-        if (ret < 0) {
-                fprintf (stderr, "fd based file operation 1 failed\n");
-                result |= ret;
-        } else {
-                fprintf (stdout, "fd based file operation 1 passed\n");
-        }
-
-        ret = fd_based_fops_2 (strcat(filename, "_2"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "fd based file operation 2 failed\n");
-        } else {
-                fprintf (stdout, "fd based file operation 2 passed\n");
-        }
-
-        ret = dup_fd_based_fops (strcat (filename, "_3"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "dup fd based file operation failed\n");
-        } else {
-                fprintf (stdout, "dup fd based file operation passed\n");
-        }
-
-        ret = path_based_fops (strcat (filename, "_4"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "path based file operation failed\n");
-        } else {
-                fprintf (stdout, "path based file operation passed\n");
-        }
-
-        ret = dir_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "directory based file operation failed\n");
-        } else {
-                fprintf (stdout, "directory based file operation passed\n");
-        }
-
-        ret = link_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "link based file operation failed\n");
-        } else {
-                fprintf (stdout, "link based file operation passed\n");
-        }
-
-        ret = test_open_modes (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "testing modes of `open' call failed\n");
-        } else {
-                fprintf (stdout, "testing modes of `open' call passed\n");
-        }
-        return result;
+    int ret = -1;
+    int result = 0;
+    char filename[255] = {
+        0,
+    };
+
+    if (argc > 1)
+        strcpy(filename, argv[1]);
+    else
+        strcpy(filename, "temp-xattr-test-file");
+
+    ret = fd_based_fops_1(strcat(filename, "_1"));
+    if (ret < 0) {
+        fprintf(stderr, "fd based file operation 1 failed\n");
+        result |= ret;
+    } else {
+        fprintf(stdout, "fd based file operation 1 passed\n");
+    }
+
+    ret = fd_based_fops_2(strcat(filename, "_2"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "fd based file operation 2 failed\n");
+    } else {
+        fprintf(stdout, "fd based file operation 2 passed\n");
+    }
+
+    ret = dup_fd_based_fops(strcat(filename, "_3"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "dup fd based file operation failed\n");
+    } else {
+        fprintf(stdout, "dup fd based file operation passed\n");
+    }
+
+    ret = path_based_fops(strcat(filename, "_4"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "path based file operation failed\n");
+    } else {
+        fprintf(stdout, "path based file operation passed\n");
+    }
+
+    ret = dir_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "directory based file operation failed\n");
+    } else {
+        fprintf(stdout, "directory based file operation passed\n");
+    }
+
+    ret = link_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "link based file operation failed\n");
+    } else {
+        fprintf(stdout, "link based file operation passed\n");
+    }
+
+    ret = test_open_modes(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "testing modes of `open' call failed\n");
+    } else {
+        fprintf(stdout, "testing modes of `open' call passed\n");
+    }
+    return result;
 }
 
 /* Execute all possible fops on a fd which is unlinked */
 int
-fd_based_fops_1 (char *filename)
+fd_based_fops_1(char *filename)
 {
-        int         fd        = 0;
-        int         ret       = -1;
-        int         result    = 0;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (fd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-/*
- *      These metadata operations fail at the moment because kernel doesn't
- *      pass the client fd in the operation.
- *      The following bug tracks this change.
- *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
- *      ret = fchmod (fd, 0640);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fchown (fd, 10001, 10001);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
- *      if (ret < 0) {
- *              fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = flistxattr (fd, NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fremovexattr (fd, "trusted.xattr-test");
- *      if (ret < 0) {
- *              fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
- */
-
-        if (fd)
-                close(fd);
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    /*
+     *      These metadata operations fail at the moment because kernel doesn't
+     *      pass the client fd in the operation.
+     *      The following bug tracks this change.
+     *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
+     *      ret = fchmod (fd, 0640);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fchown (fd, 10001, 10001);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fsetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = flistxattr (fd, NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "flistxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "fgetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fremovexattr (fd, "trusted.xattr-test");
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fremovexattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+     */
+
+    if (fd)
+        close(fd);
+    return result;
 }
 
-
 int
-fd_based_fops_2 (char *filename)
+fd_based_fops_2(char *filename)
 {
-        int     fd              = 0;
-        int     ret             = -1;
-        int     result          = 0;
-        struct stat stbuf       = {0,};
-        char        wstr[50]    = {0,};
-        char        rstr[50]    = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my second string\n");
-        ret = write (fd, wstr, strlen (wstr));
-        if (ret < 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen (wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close (fd);
-        unlink (filename);
-
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my second string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret < 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(filename);
+
+    return result;
 }
 
 int
-path_based_fops (char *filename)
+path_based_fops(char *filename)
 {
-        int         ret              = -1;
-        int         fd               = 0;
-        int         result           = 0;
-        struct stat stbuf            = {0,};
-        char        newfilename[255] = {0,};
-        char        *hardlink        = "linkfile-hard.txt";
-        char        *symlnk          = "linkfile-soft.txt";
-        char        buf[1024]        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = truncate (filename, 0);
-        if (ret < 0) {
-                fprintf (stderr, "truncate failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (filename, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (filename, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (filename, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (filename, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (filename, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = access (filename, R_OK|W_OK);
-        if (ret < 0) {
-                fprintf (stderr, "access failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = link (filename, hardlink);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(hardlink);
-
-        ret = symlink (filename, symlnk);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-
-        ret = readlink (symlnk, buf, sizeof(buf));
-        if (ret < 0) {
-                fprintf (stderr, "readlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(symlnk);
-
-        /* Create a character special file */
-        ret = mknod ("cspecial", S_IFCHR|S_IRWXU|S_IRWXG, makedev(2,3));
-        if (ret < 0) {
-                fprintf (stderr, "cpsecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("cspecial");
-
-        ret = mknod ("bspecial", S_IFBLK|S_IRWXU|S_IRWXG, makedev(4,5));
-        if (ret < 0) {
-                fprintf (stderr, "bspecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("bspecial");
+    int ret = -1;
+    int fd = 0;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char newfilename[255] = {
+        0,
+    };
+    char *hardlink = "linkfile-hard.txt";
+    char *symlnk = "linkfile-soft.txt";
+    char buf[1024] = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = truncate(filename, 0);
+    if (ret < 0) {
+        fprintf(stderr, "truncate failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(filename, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(filename, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(filename, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(filename, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(filename, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = access(filename, R_OK | W_OK);
+    if (ret < 0) {
+        fprintf(stderr, "access failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = link(filename, hardlink);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(hardlink);
+
+    ret = symlink(filename, symlnk);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = readlink(symlnk, buf, sizeof(buf));
+    if (ret < 0) {
+        fprintf(stderr, "readlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(symlnk);
+
+    /* Create a character special file */
+    ret = mknod("cspecial", S_IFCHR | S_IRWXU | S_IRWXG, makedev(2, 3));
+    if (ret < 0) {
+        fprintf(stderr, "cpsecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("cspecial");
+
+    ret = mknod("bspecial", S_IFBLK | S_IRWXU | S_IRWXG, makedev(4, 5));
+    if (ret < 0) {
+        fprintf(stderr, "bspecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("bspecial");
 
 #ifdef linux
-        ret = mknod ("fifo", S_IFIFO|S_IRWXU|S_IRWXG, 0);
+    ret = mknod("fifo", S_IFIFO | S_IRWXU | S_IRWXG, 0);
 #else
-        ret = mkfifo ("fifo", 0);
+    ret = mkfifo("fifo", 0);
 #endif
-        if (ret < 0) {
-                fprintf (stderr, "fifo mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("fifo");
+    if (ret < 0) {
+        fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("fifo");
 
 #ifdef linux
-        ret = mknod ("sock", S_IFSOCK|S_IRWXU|S_IRWXG, 0);
-        if (ret < 0) {
-                fprintf (stderr, "sock mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
+    ret = mknod("sock", S_IFSOCK | S_IRWXU | S_IRWXG, 0);
+    if (ret < 0) {
+        fprintf(stderr, "sock mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
 #else
-        {
-                int s;
-                const char *pathname = "sock";
-                struct sockaddr_un addr;
-
-                s = socket(PF_LOCAL, SOCK_STREAM, 0);
-                memset(&addr, 0, sizeof(addr));
-                strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
-                ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
-                if (ret < 0) {
-                        fprintf (stderr, "fifo mknod failed: %s\n",
-                                 strerror(errno));
-                        result |= ret;
-                }
-                close(s);
-        }
-#endif
-        unlink("sock");
+    {
+        int s;
+        const char *pathname = "sock";
+        struct sockaddr_un addr;
 
-        strcpy (newfilename, filename);
-        strcat(newfilename, "_new");
-        ret = rename (filename, newfilename);
+        s = socket(PF_LOCAL, SOCK_STREAM, 0);
+        memset(&addr, 0, sizeof(addr));
+        strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
+        ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
         if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
+            fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+            result |= ret;
         }
-        unlink (newfilename);
-
-        if (fd)
-                close (fd);
-
-        unlink (filename);
-        return result;
+        close(s);
+    }
+#endif
+    unlink("sock");
+
+    strcpy(newfilename, filename);
+    strcat(newfilename, "_new");
+    ret = rename(filename, newfilename);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(newfilename);
+
+    if (fd)
+        close(fd);
+
+    unlink(filename);
+    return result;
 }
 
 int
-dup_fd_based_fops (char *filename)
+dup_fd_based_fops(char *filename)
 {
-        int         fd        = 0;
-        int         result    = 0;
-        int         newfd     = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        newfd = dup (fd);
-        if (newfd < 0) {
-                fprintf (stderr, "dup failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        close (fd);
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (newfd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (newfd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (newfd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (newfd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (newfd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (newfd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (newfd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (newfd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (newfd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (newfd)
-                close (newfd);
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-        return result;
+    int fd = 0;
+    int result = 0;
+    int newfd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    newfd = dup(fd);
+    if (newfd < 0) {
+        fprintf(stderr, "dup failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    close(fd);
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(newfd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(newfd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(newfd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(newfd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(newfd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(newfd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(newfd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(newfd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(newfd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (newfd)
+        close(newfd);
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+    return result;
 }
 
 int
-dir_based_fops (char *dirname)
+dir_based_fops(char *dirname)
 {
-        int            ret           = -1;
-        int            result        = 0;
-        DIR           *dp            = NULL;
-        char           buff[255]     = {0,};
-        struct dirent *dbuff         = {0,};
-        struct stat    stbuff        = {0,};
-        char           newdname[255] = {0,};
-        char          *cwd           = NULL;
-
-        ret = mkdir (dirname, 0755);
-        if (ret < 0) {
-                fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        dp = opendir (dirname);
-        if (dp == NULL) {
-                fprintf (stderr, "opendir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        dbuff = readdir (dp);
-        if (NULL == dbuff) {
-                fprintf (stderr, "readdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = closedir (dp);
-        if (ret < 0) {
-                fprintf (stderr, "closedir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (dirname, &stbuff);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (dirname, 0744);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (dirname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (dirname, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (dirname, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "/../");
-        ret = chdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "chdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        cwd = getcwd (buff, 255);
-        if (NULL == cwd) {
-                fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "new");
-        ret = rename (dirname, newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = rmdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        rmdir (dirname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    DIR *dp = NULL;
+    char buff[255] = {
+        0,
+    };
+    struct dirent *dbuff = {
+        0,
+    };
+    struct stat stbuff = {
+        0,
+    };
+    char newdname[255] = {
+        0,
+    };
+    char *cwd = NULL;
+
+    ret = mkdir(dirname, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    dp = opendir(dirname);
+    if (dp == NULL) {
+        fprintf(stderr, "opendir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    dbuff = readdir(dp);
+    if (NULL == dbuff) {
+        fprintf(stderr, "readdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = closedir(dp);
+    if (ret < 0) {
+        fprintf(stderr, "closedir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(dirname, &stbuff);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(dirname, 0744);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(dirname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(dirname, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(dirname, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(dirname, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "/../");
+    ret = chdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "chdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    cwd = getcwd(buff, 255);
+    if (NULL == cwd) {
+        fprintf(stderr, "getcwd failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "new");
+    ret = rename(dirname, newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = rmdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rmdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    rmdir(dirname);
+    return result;
 }
 
 int
-link_based_fops (char *filename)
+link_based_fops(char *filename)
 {
-        int         ret           = -1;
-        int         result        = 0;
-        int         fd            = 0;
-        char        newname[255]  = {0,};
-        char        linkname[255] = {0,};
-        struct stat lstbuf        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        strcpy (newname, filename);
-        strcat (newname, "_hlink");
-        ret = link (filename, newname);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (linkname, filename);
-        strcat (linkname, "_slink");
-        ret = symlink (newname, linkname);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lstat (linkname, &lstbuf);
-        if (ret < 0) {
-                fprintf (stderr, "lstbuf failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lchown (linkname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "lchown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = llistxattr (linkname, NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "llistxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lremovexattr (linkname, "trusted.lxattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close(fd);
-        unlink (linkname);
-        unlink (newname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    int fd = 0;
+    char newname[255] = {
+        0,
+    };
+    char linkname[255] = {
+        0,
+    };
+    struct stat lstbuf = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    strcpy(newname, filename);
+    strcat(newname, "_hlink");
+    ret = link(filename, newname);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(linkname, filename);
+    strcat(linkname, "_slink");
+    ret = symlink(newname, linkname);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lstat(linkname, &lstbuf);
+    if (ret < 0) {
+        fprintf(stderr, "lstbuf failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lchown(linkname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "lchown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = llistxattr(linkname, NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "llistxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lremovexattr(linkname, "trusted.lxattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(linkname);
+    unlink(newname);
+    return result;
 }
 
 int
-test_open_modes (char *filename)
+test_open_modes(char *filename)
 {
-        int ret         = -1;
-        int result      = 0;
-
-        ret = generic_open_read_write (filename, O_CREAT|O_WRONLY, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDONLY, OPEN_MODE);
-        if (ret != 0) {
-                fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n");
-                result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_WRONLY, 0);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_WRONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDWR, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n");
-               result |= ret;
-        }
+    int ret = -1;
+    int result = 0;
+
+    ret = generic_open_read_write(filename, O_CREAT | O_WRONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_WRONLY, 0);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_WRONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDWR, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n");
+        result |= ret;
+    }
 
 #if 0 /* undefined behaviour, unable to reliably test */
         ret = creat (filename, 0644);
@@ -897,87 +944,90 @@ test_open_modes (char *filename)
         }
 #endif
 
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC,
-                                       OPEN_MODE);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_CREAT|O_EXCL, OPEN_MODE);
-        if (0 != ret) {
-                fprintf (stderr, "flag O_CREAT|O_EXCL failed\n");
-                result |= ret;
-        }
-
-        return result;
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC,
+                                  OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_CREAT | O_EXCL, OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_EXCL failed\n");
+        result |= ret;
+    }
+
+    return result;
 }
 
 int
-generic_open_read_write (char *filename, int flag, mode_t mode)
+generic_open_read_write(char *filename, int flag, mode_t mode)
 {
-        int  fd          = 0;
-        int  ret         = -1;
-        char wstring[50] = {0,};
-        char rstring[50] = {0,};
-
-        fd = open (filename, flag, mode);
-        if (fd < 0) {
-                if (flag == (O_CREAT|O_EXCL) && errno == EEXIST) {
-                        unlink (filename);
-                        return 0;
-                }
-                else {
-                        fprintf (stderr, "open failed: %s\n", strerror (errno));
-                        return -1;
-                }
-        }
-
-        strcpy (wstring, "My string to write\n");
-        ret = write (fd, wstring, strlen(wstring));
-        if (ret <= 0) {
-                if (errno != EBADF) {
-                        fprintf (stderr, "write failed: %s\n", strerror (errno));
-                        close (fd);
-                        unlink(filename);
-                        return ret;
-                }
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                close (fd);
-                unlink(filename);
-                return ret;
-        }
-
-        ret = read (fd, rstring, strlen(wstring));
-        if (ret < 0 && flag != (O_CREAT|O_WRONLY) && flag != O_WRONLY && \
-            flag != (O_TRUNC|O_WRONLY)) {
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        /* Compare the rstring with wstring. But we do not want to return
-         * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
-         * O_TRUNC|O_RDONLY. Because in that case we are not writing
-         * anything to the file.*/
-
-        ret = memcmp (wstring, rstring, strlen (wstring));
-        if (0 != ret && flag != (O_TRUNC|O_WRONLY) && flag != O_WRONLY && \
-                                 flag != (O_CREAT|O_WRONLY) && !(flag == \
-                                 (O_CREAT|O_RDONLY) || flag == O_RDONLY \
-                                  || flag == (O_TRUNC|O_RDONLY))) {
-                fprintf (stderr, "read is returning junk\n");
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        close (fd);
-        unlink (filename);
-        return 0;
+    int fd = 0;
+    int ret = -1;
+    char wstring[50] = {
+        0,
+    };
+    char rstring[50] = {
+        0,
+    };
+
+    fd = open(filename, flag, mode);
+    if (fd < 0) {
+        if (flag == (O_CREAT | O_EXCL) && errno == EEXIST) {
+            unlink(filename);
+            return 0;
+        } else {
+            fprintf(stderr, "open failed: %s\n", strerror(errno));
+            return -1;
+        }
+    }
+
+    strcpy(wstring, "My string to write\n");
+    ret = write(fd, wstring, strlen(wstring));
+    if (ret <= 0) {
+        if (errno != EBADF) {
+            fprintf(stderr, "write failed: %s\n", strerror(errno));
+            close(fd);
+            unlink(filename);
+            return ret;
+        }
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    ret = read(fd, rstring, strlen(wstring));
+    if (ret < 0 && flag != (O_CREAT | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_TRUNC | O_WRONLY)) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    /* Compare the rstring with wstring. But we do not want to return
+     * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
+     * O_TRUNC|O_RDONLY. Because in that case we are not writing
+     * anything to the file.*/
+
+    ret = memcmp(wstring, rstring, strlen(wstring));
+    if (0 != ret && flag != (O_TRUNC | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_CREAT | O_WRONLY) &&
+        !(flag == (O_CREAT | O_RDONLY) || flag == O_RDONLY ||
+          flag == (O_TRUNC | O_RDONLY))) {
+        fprintf(stderr, "read is returning junk\n");
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    close(fd);
+    unlink(filename);
+    return 0;
 }
diff --git a/tests/basic/fuse/active-io-graph-switch.t b/tests/basic/fuse/active-io-graph-switch.t
new file mode 100644
index 00000000000..6ec3e1fcbfa
--- /dev/null
+++ b/tests/basic/fuse/active-io-graph-switch.t
@@ -0,0 +1,65 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+TESTS_EXPECTED_IN_LOOP=12
+
+function perform_io_on_mount {
+    local m="$1"
+    local f="$2"
+    local lockfile="$3"
+    while [ -f "$m/$lockfile" ];
+    do
+        dd if=/dev/zero of=$m/$f bs=1M count=1
+    done
+}
+
+function perform_graph_switch {
+    for i in {1..3}
+    do
+        TEST_IN_LOOP $CLI volume set $V0 performance.stat-prefetch off
+        sleep 3
+        TEST_IN_LOOP $CLI volume set $V0 performance.stat-prefetch on
+        sleep 3
+    done
+}
+
+function count_files {
+    ls $M0 | wc -l
+}
+
+cleanup;
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 flush-behind off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST touch $M0/lock
+for i in {1..100}; do perform_io_on_mount $M0 $i lock & done
+EXPECT_WITHIN 5 "101" count_files
+
+perform_graph_switch
+TEST rm -f $M0/lock
+wait
+EXPECT "100" count_files
+TEST rm -f $M0/{1..100}
+EXPECT "0" count_files
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#Repeat the tests with reader-thread-count
+TEST $GFS --reader-thread-count=10 --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST touch $M0/lock
+for i in {1..100}; do perform_io_on_mount $M0 $i lock & done
+EXPECT_WITHIN 5 "101" count_files
+
+perform_graph_switch
+TEST rm -f $M0/lock
+wait
+EXPECT "100" count_files
+TEST rm -f $M0/{1..100}
+EXPECT "0" count_files
+
+cleanup
diff --git a/tests/basic/fuse/seek.c b/tests/basic/fuse/seek.c
index e4db41c03d7..30943ad0f33 100644
--- a/tests/basic/fuse/seek.c
+++ b/tests/basic/fuse/seek.c
@@ -17,64 +17,66 @@
 #include <unistd.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int          ret        = EXIT_SUCCESS;
-        int          fd         = -1;
-        char        *filename   = NULL;
-        struct stat  st         = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
+    int ret = EXIT_SUCCESS;
+    int fd = -1;
+    char *filename = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
 
-        if (argc != 2) {
-                fprintf (stderr, "Invalid argument, use %s <file>\n", argv[0]);
-                return EXIT_FAILURE;
-        }
-
-        filename = argv[1];
+    if (argc != 2) {
+        fprintf(stderr, "Invalid argument, use %s <file>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        fd = open (filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("open");
-                return EXIT_FAILURE;
-        }
+    filename = argv[1];
 
-        if (fstat (fd, &st)) {
-                perror ("fstat");
-                return EXIT_FAILURE;
-        }
+    fd = open(filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
 
-        while (hole_end < st.st_size) {
-                hole_start = lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO) {
-                        /* no more holes */
-                        break;
-                } else if (hole_start == -1 && errno == ENOTSUP) {
-                        /* SEEK_HOLE is not supported */
-                        perror ("lseek(SEEK_HOLE)");
-                        ret = EXIT_FAILURE;
-                        break;
-                } else if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
+    if (fstat(fd, &st)) {
+        perror("fstat");
+        return EXIT_FAILURE;
+    }
 
-                hole_end = lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                } else if (hole_end == -1 && errno == ENOTSUP) {
-                        /* SEEK_DATA is not supported */
-                        perror ("lseek(SEEK_DATA)");
-                        ret = EXIT_FAILURE;
-                        break;
-                }
+    while (hole_end < st.st_size) {
+        hole_start = lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO) {
+            /* no more holes */
+            break;
+        } else if (hole_start == -1 && errno == ENOTSUP) {
+            /* SEEK_HOLE is not supported */
+            perror("lseek(SEEK_HOLE)");
+            ret = EXIT_FAILURE;
+            break;
+        } else if (hole_start == -1) {
+            perror("no more holes");
+            break;
+        }
 
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
+        hole_end = lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
+        } else if (hole_end == -1 && errno == ENOTSUP) {
+            /* SEEK_DATA is not supported */
+            perror("lseek(SEEK_DATA)");
+            ret = EXIT_FAILURE;
+            break;
         }
 
-        close (fd);
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
+
+    close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/geo-replication/marker-xattrs.t b/tests/basic/geo-replication/marker-xattrs.t
index e5b26a6bd5b..7e5ea8eebec 100755
--- a/tests/basic/geo-replication/marker-xattrs.t
+++ b/tests/basic/geo-replication/marker-xattrs.t
@@ -7,7 +7,7 @@ TEST glusterd
 TEST pidof glusterd
 
 ## Start and create a replicated volume
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}-{0,1,2,3}
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}-{0,1,2,3,4,5}
 
 TEST $CLI volume set $V0 indexing on
 
@@ -78,34 +78,3 @@ TEST $CLI volume stop $V0;
 TEST $CLI volume delete $V0;
 
 cleanup
-TEST glusterd
-TEST pidof glusterd
-## Start and create a stripe volume
-TEST $CLI volume create $V0 stripe 2 $H0:$B0/${V0}-{0,1}
-
-TEST $CLI volume set $V0 indexing on
-
-TEST $CLI volume start $V0;
-
-## Mount native
-TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
-
-## Mount client-pid=-1
-TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 --client-pid=-1 $M1
-
-TEST touch $M0
-
-vol_uuid=$(get_volume_mark $M1)
-xtime=trusted.glusterfs.$vol_uuid.xtime
-
-TEST "getfattr -n $xtime $B0/${V0}-0 | grep -q ${xtime}="
-
-TEST "getfattr -n $xtime $B0/${V0}-1 | grep -q ${xtime}="
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
-
-TEST $CLI volume stop $V0;
-TEST $CLI volume delete $V0;
-
-cleanup
diff --git a/tests/basic/gfapi/Makefile b/tests/basic/gfapi/Makefile
index e30fefea5b9..1c5cf03ca3d 100644
--- a/tests/basic/gfapi/Makefile
+++ b/tests/basic/gfapi/Makefile
@@ -5,7 +5,8 @@ CFLAGS   = -Wall -g $(shell pkg-config --cflags glusterfs-api)
 LDFLAGS  = $(shell pkg-config --libs glusterfs-api)
 
 BINARIES = upcall-cache-invalidate libgfapi-fini-hang anonymous_fd seek \
-	bug1283983 bug1291259 gfapi-ssl-test gfapi-load-volfile
+	bug1283983 bug1291259 gfapi-ssl-test gfapi-load-volfile \
+        mandatory-lock-optimal
 
 %: %.c
 	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
diff --git a/tests/basic/gfapi/anonymous_fd_read_write.c b/tests/basic/gfapi/anonymous_fd_read_write.c
index 6945dd634f0..fc276ca4310 100644
--- a/tests/basic/gfapi/anonymous_fd_read_write.c
+++ b/tests/basic/gfapi/anonymous_fd_read_write.c
@@ -9,95 +9,98 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret            = 0;
-        glfs_t                  *fs            = NULL;
-        struct glfs_object      *root = NULL, *file_obj = NULL;
-        struct stat             sb             = {0, };
-        char                    readbuf[32], writebuf[32];
-        char                    *filename      = "file.txt";
-        char                    *logfile       = NULL;
-        char                    *volname       = NULL;
-        char                    *hostname      = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-
-        file_obj = glfs_h_creat (fs, root, filename, O_CREAT, 0644, &sb);
-        if (file_obj == NULL) {
-                fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
-                         filename, root, strerror (errno));
-                goto out;
-        }
-
-        /* test read/write based on anonymous fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-
-        ret = glfs_h_anonymous_write (fs, file_obj, writebuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_write", ret);
-
-        ret = glfs_h_anonymous_read (fs, file_obj, readbuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_read", ret);
-
-        if (memcmp (readbuf, writebuf, 32)) {
-                fprintf (stderr, "Failed to read what I wrote: %s %s\n", readbuf,
-                         writebuf);
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_object *root = NULL, *file_obj = NULL;
+    struct stat sb = {
+        0,
+    };
+    char readbuf[32], writebuf[32];
+    char *filename = "file.txt";
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+
+    file_obj = glfs_h_creat(fs, root, filename, O_CREAT, 0644, &sb);
+    if (file_obj == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                filename, root, strerror(errno));
+        goto out;
+    }
+
+    /* test read/write based on anonymous fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+
+    ret = glfs_h_anonymous_write(fs, file_obj, writebuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_write", ret);
+
+    ret = glfs_h_anonymous_read(fs, file_obj, readbuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_read", ret);
+
+    if (memcmp(readbuf, writebuf, 32)) {
+        fprintf(stderr, "Failed to read what I wrote: %s %s\n", readbuf,
+                writebuf);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (file_obj)
-                glfs_h_close (file_obj);
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-        if (ret)
-                exit(1);
-        exit(0);
+    if (file_obj)
+        glfs_h_close(file_obj);
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/bug-1241104.c b/tests/basic/gfapi/bug-1241104.c
index 311323f672a..78c87595a71 100644
--- a/tests/basic/gfapi/bug-1241104.c
+++ b/tests/basic/gfapi/bug-1241104.c
@@ -12,81 +12,82 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-        struct flock lock = {0, };
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
-
-	/* validate locks for negative range */
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 10;
-        lock.l_len = -9;
-
-        ret = glfs_posix_lock (fd, F_SETLK, &lock);
-        LOG_ERR ("glfs_posix_lock", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    struct flock lock = {
+        0,
+    };
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    /* validate locks for negative range */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 10;
+    lock.l_len = -9;
+
+    ret = glfs_posix_lock(fd, F_SETLK, &lock);
+    LOG_ERR("glfs_posix_lock", ret);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug-1507896.c b/tests/basic/gfapi/bug-1507896.c
new file mode 100644
index 00000000000..1cc20849c2b
--- /dev/null
+++ b/tests/basic/gfapi/bug-1507896.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+int
+main(int argc, char *argv[])
+{
+    int ret = -1;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new(fs)", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server(fs)", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging(fs)", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init(fs)", ret, out);
+
+out:
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+    return ret;
+}
diff --git a/tests/basic/gfapi/bug-1507896.t b/tests/basic/gfapi/bug-1507896.t
new file mode 100644
index 00000000000..4764e650232
--- /dev/null
+++ b/tests/basic/gfapi/bug-1507896.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/bug-1507896.c -lgfapi
+
+TEST ./$(dirname $0)/bug-1507896 $H0 $V0 $logdir/bug-1507896.log
+
+#volume name precedding with '/'
+TEST ! ./$(dirname $0)/bug-1507896 $H0 /$V0 $logdir/bug-1507896.log
+
+#volume name passed with any special characters
+TEST ! ./$(dirname $0)/bug-1507896 $H0 test@_$V0 $logdir/bug-1507896.log
+
+cleanup_tester $(dirname $0)/bug-1507896
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup;
diff --git a/tests/basic/gfapi/bug1283983.c b/tests/basic/gfapi/bug1283983.c
index 3334b290d9e..b920013d0e0 100644
--- a/tests/basic/gfapi/bug1283983.c
+++ b/tests/basic/gfapi/bug1283983.c
@@ -10,114 +10,113 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        char                     *filename = "/a1";
-        char                     *filename2 = "/a2";
-        struct stat               sb = {0, };
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        int                       cnt = 1;
-        struct glfs_upcall_inode *in_arg = NULL;
-        struct glfs_object       *root = NULL, *leaf = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    int cnt = 1;
+    struct glfs_upcall_inode *in_arg = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1] volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    leaf = glfs_h_creat(fs, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    leaf = glfs_h_lookupat(fs, root, filename2, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    ret = glfs_h_rename(fs, root, filename, root, filename2);
+    LOG_ERR("glfs_rename", ret);
+
+    while (cnt++ < 5) {
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+
+        /* There should not be any upcalls sent */
+        if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
+            fprintf(stderr, "Error: Upcall received(%d)\n",
+                    glfs_upcall_get_reason(cbk));
+            exit(1);
         }
 
-        hostname = argv[1]
-        volname = argv[2];
-        logfile = argv[3];
+        glfs_free(cbk);
+    }
 
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        leaf = glfs_h_creat (fs, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        leaf = glfs_h_lookupat (fs, root, filename2, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        ret = glfs_h_rename (fs, root, filename, root, filename2);
-        LOG_ERR("glfs_rename", ret);
-
-        while (cnt++ < 5) {
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                /* There should not be any upcalls sent */
-                if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
-                        fprintf (stderr, "Error: Upcall received(%d)\n",
-                                 glfs_upcall_get_reason(cbk));
-                        exit (1);
-                }
-
-                glfs_free (cbk);
-        }
-
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1291259.c b/tests/basic/gfapi/bug1291259.c
index 26fc1e01449..cd7bc65268b 100644
--- a/tests/basic/gfapi/bug1291259.c
+++ b/tests/basic/gfapi/bug1291259.c
@@ -10,174 +10,172 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 #define GLAPI_UUID_LENGTH 16
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                     *fs = NULL;
-        glfs_t                     *fs2 = NULL;
-        int                         ret = 0, i;
-        glfs_fd_t                  *fd = NULL;
-        char                       *filename = "/a1";
-        char                       *filename2 = "/a2";
-        struct                      stat sb = {0, };
-        char                       *logfile = NULL;
-        char                       *volname = NULL;
-        char                       *hostname = NULL;
-        int                         cnt = 1;
-        int                         upcall_received = 0;
-        struct glfs_upcall         *cbk = NULL;
-        struct glfs_object         *root = NULL, *leaf = NULL;
-        unsigned char               globjhdl[GFAPI_HANDLE_LENGTH];
-        unsigned char               globjhdl2[GFAPI_HANDLE_LENGTH];
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int cnt = 1;
+    int upcall_received = 0;
+    struct glfs_upcall *cbk = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+    unsigned char globjhdl[GFAPI_HANDLE_LENGTH];
+    unsigned char globjhdl2[GFAPI_HANDLE_LENGTH];
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    root = glfs_h_lookupat(fs2, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_creat(fs2, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    while (cnt++ < 5 && !upcall_received) {
+        enum glfs_upcall_reason reason = 0;
+        struct glfs_upcall_inode *in_arg = NULL;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+        if (ret)
+            goto retry;
 
+        reason = glfs_upcall_get_reason(cbk);
+        fprintf(stderr, "Upcall received(%d)\n", reason);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+            struct glfs_object *object = NULL;
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
+            in_arg = glfs_upcall_get_event(cbk);
+            object = glfs_upcall_inode_get_object(in_arg);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
+            ret = glfs_h_extract_handle(root, globjhdl + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+            ret = glfs_h_extract_handle(object, globjhdl2 + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-        fs2 = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
+            if (memcmp(globjhdl + GLAPI_UUID_LENGTH,
+                       globjhdl2 + GLAPI_UUID_LENGTH, 16)) {
+                fprintf(stderr, "Error: gfid mismatch\n");
+                exit(1);
+            }
+            upcall_received = 1;
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init", ret);
+    retry:
+        if (!upcall_received)
+            sleep(1); /* glfs_h_poll_upcall() does not block */
 
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        while (cnt++ < 5 && !upcall_received) {
-                enum glfs_upcall_reason     reason = 0;
-                struct glfs_upcall_inode   *in_arg = NULL;
-
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-                if (ret)
-                        goto retry;
-
-                reason = glfs_upcall_get_reason (cbk);
-                fprintf (stderr, "Upcall received(%d)\n", reason);
-
-                if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                        struct glfs_object *object = NULL;
-
-                        in_arg = glfs_upcall_get_event (cbk);
-                        object = glfs_upcall_inode_get_object (in_arg);
-
-                        ret = glfs_h_extract_handle (root,
-                                                     globjhdl+GLAPI_UUID_LENGTH,
-                                                     GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        ret = glfs_h_extract_handle (object,
-                                                  globjhdl2+GLAPI_UUID_LENGTH,
-                                                  GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        if (memcmp (globjhdl+GLAPI_UUID_LENGTH,
-                                    globjhdl2+GLAPI_UUID_LENGTH, 16)) {
-                                fprintf (stderr, "Error: gfid mismatch\n");
-                                exit (1);
-                        }
-                        upcall_received = 1;
-                }
-
-retry:
-                if (!upcall_received)
-                        sleep (1); /* glfs_h_poll_upcall() does not block */
-
-                if (!ret) {
-                        glfs_free (cbk);
-                        cbk = NULL;
-                }
+        if (!ret) {
+            glfs_free(cbk);
+            cbk = NULL;
         }
+    }
 
-        if (!upcall_received) {
-                fprintf (stderr, "Error: Upcall not received\n");
-                exit (1);
-        }
+    if (!upcall_received) {
+        fprintf(stderr, "Error: Upcall not received\n");
+        exit(1);
+    }
 
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1613098.c b/tests/basic/gfapi/bug1613098.c
new file mode 100644
index 00000000000..ee67e97a034
--- /dev/null
+++ b/tests/basic/gfapi/bug1613098.c
@@ -0,0 +1,96 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define ACL_TYPE_ACCESS (0x8000)
+
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+int
+main(int argc, char *argv[])
+{
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    struct glfs_object *object = NULL;
+    acl_t acl = NULL;
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd = glfs_creat(fs, filename, flags, 0044);
+    if (fd == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+    glfs_close(fd);
+
+    object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
+    if (object == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out);
+    }
+
+    ret = glfs_chown(fs, filename, 99, 99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out);
+
+    ret = glfs_setfsuid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out);
+
+    ret = glfs_setfsgid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out);
+
+    acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
+    if (acl == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
+    }
+
+    ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
+out:
+    glfs_setfsuid(0);
+    glfs_setfsgid(0);
+
+    if (object)
+        glfs_h_close(object);
+
+    if (fs)
+        glfs_fini(fs);
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/bug1613098.t b/tests/basic/gfapi/bug1613098.t
new file mode 100755
index 00000000000..e4acc2b76bf
--- /dev/null
+++ b/tests/basic/gfapi/bug1613098.t
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+TEST glusterd
+
+TEST $CLI volume create $V0 ${H0}:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+build_tester $(dirname $0)/bug1613098.c -lgfapi
+
+TEST ./$(dirname $0)/bug1613098 $V0 $logdir/bug1613098.log
+
+cleanup_tester $(dirname $0)/bug1613098
+
+cleanup;
diff --git a/tests/basic/gfapi/gfapi-async-calls-test.c b/tests/basic/gfapi/gfapi-async-calls-test.c
index 277067bee2c..55835b14709 100644
--- a/tests/basic/gfapi/gfapi-async-calls-test.c
+++ b/tests/basic/gfapi/gfapi-async-calls-test.c
@@ -9,169 +9,486 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 int cbk_complete = 0;
 int cbk_ret_val = -1;
 
-int
-fill_iov (struct iovec *iov, char fillchar, int count)
+void
+cbk_check()
 {
-        int ret = -1;
+    while (cbk_complete != 1) {
+        sleep(1);
+    }
+    if (cbk_ret_val < 0) {
+        fprintf(stderr, "cbk_ret_val is -ve\n");
+    }
+}
 
-        iov->iov_base = calloc (count + 1, sizeof(fillchar));
-        if (iov->iov_base == NULL) {
-                return ret;
-        } else {
-                iov->iov_len = count;
-                ret = 0;
-        }
-        memset (iov->iov_base, fillchar, count);
-        memset (iov->iov_base + count, '\0', 1);
+int
+fill_iov(struct iovec *iov, char fillchar, int count)
+{
+    int ret = -1;
 
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
         return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
 }
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
-{
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
+init_glfs(const char *hostname, const char *volname, const char *logfile)
+{
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        ret = 0;
+    return fs;
+}
+
+void
+pwritev_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                  struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_pwritev failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+int
+pwritev_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+    void *write_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    write_cookie = strdup("write_cookie");
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, pwritev_async_cbk,
+                             &write_cookie);
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret < 0) {
+        LOG_ERR("glfs_pwritev async failed");
+    }
+    return ret;
+}
 
-        return fs;
+void
+pwrite_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                 struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_pwrite_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+int
+pwrite_async(glfs_fd_t *glfd)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    char buf1[10];
+    char *buf2 = "ten bytes!";
+    void *write_cookie = strdup("write_cookie");
+    ret = glfs_pwrite_async(glfd, buf1, 10, 0, flags, pwrite_async_cbk,
+                            &write_cookie);
+
+    if (ret < 0) {
+        LOG_ERR("glfs_pwrite_async failed");
+    }
+    return ret;
 }
 
 void
-write_async_cbk (glfs_fd_t *fd, ssize_t ret, void *cookie)
+writev_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                 struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_writev_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+int
+writev_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
 {
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+    void *write_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    write_cookie = strdup("write_cookie");
+    ret = glfs_writev_async(glfd, &iov, 1, flags, writev_async_cbk,
+                            &write_cookie);
+out:
+    if (ret < 0) {
+        LOG_ERR("glfs_writev_async failed");
+    }
+    return ret;
+}
 
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-        }
-        cbk_ret_val = ret;
-        cbk_complete = 1;
+void
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_write_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count)
+write_async(glfs_fd_t *glfd)
 {
-        ssize_t         ret          = -1;
-        int             flags        = O_RDWR;
-        const char     *buff         = "This is from my prog\n";
-        struct iovec    iov          = {0};
-        void           *write_cookie = NULL;
-        void           *read_cookie  = NULL;
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    char buf1[10];
+    char *buf2 = "ten bytes!";
+    void *write_cookie = strdup("write_cookie");
+    ret = glfs_write_async(glfd, buf1, 10, flags, write_async_cbk,
+                           &write_cookie);
+
+    if (ret < 0) {
+        LOG_ERR("glfs_write_async failed");
+    }
+    return ret;
+}
 
+void
+preadv_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                 struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_preadv_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
 
+int
+preadv_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+    void *read_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    read_cookie = strdup("preadv_cookie");
+    ret = glfs_preadv_async(glfd, &iov, 1, 0, flags, preadv_async_cbk,
+                            &read_cookie);
+out:
+    if (ret < 0) {
+        LOG_ERR("glfs_preadv async failed");
+    }
+    return ret;
+}
+
+void
+pread_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_pread_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+int
+pread_async(glfs_fd_t *glfd)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    char buf1[10];
+    void *read_cookie = strdup("read_cookie");
+    ret = glfs_pread_async(glfd, buf1, 10, 0, flags, pread_async_cbk,
+                           &read_cookie);
+    if (ret < 0) {
+        LOG_ERR("glfs_pread_async failed");
+    }
+
+    return ret;
+}
 
-        ret = fill_iov (&iov, 'a', char_count);
-        if (ret) {
-                LOG_ERR ("failed to create iov");
-                goto out;
-        }
+void
+readv_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_readv_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
 
-        write_cookie = strdup ("write_cookie");
-        ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk,
-                                  &write_cookie);
+int
+readv_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
+    void *read_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    read_cookie = strdup("read_cookie");
+    ret = glfs_readv_async(glfd, &iov, 1, flags, readv_async_cbk, &read_cookie);
 out:
-        if (ret < 0) {
-                LOG_ERR ("glfs_pwritev async failed");
-        }
-        return ret;
+    if (ret < 0) {
+        LOG_ERR("glfs_readv_async failed");
+    }
+    return ret;
+}
 
+void
+read_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+               struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_read_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-main (int argc, char *argv[])
-{
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
-        const char *filename = "glfs_test.txt";
-        int         flags    = (O_RDWR|O_CREAT);
-        glfs_fd_t  *glfd     = NULL;
-        int         count    = 200;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                exit(1);
-        }
-
-        ret = write_async (fs, glfd, count);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-                exit(1);
-        }
-
-        while (cbk_complete != 1) {
-                sleep(1);
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs close  failed");
-        }
-
-        /*
-         * skipping fini
-         */
-
-        if (cbk_ret_val == count)
-                return 0;
-        else
-                return -1;
+read_async(glfs_fd_t *glfd)
+{
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    char buf1[10];
+    void *read_cookie = strdup("read_cookie");
+    ret = glfs_read_async(glfd, buf1, 10, flags, read_async_cbk, &read_cookie);
+
+    if (ret < 0) {
+        LOG_ERR("glfs_read_async failed");
+    }
+    return ret;
+}
+
+void
+fsync_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_fsync_async_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
+
+void
+fdatasync_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                    struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_fdatasync_async_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
+void
+ftruncate_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                    struct stat *poststat, void *cookie)
+{
+    if (ret < 0) {
+        LOG_ERR("glfs_ftruncate_async_cbk failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
+}
 
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    const char *filename = "glfs_test.txt";
+    int flags = (O_RDWR | O_CREAT);
+    glfs_fd_t *glfd = NULL;
+    int count = 200;
+    void *data = strdup("Sample_text");
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        exit(1);
+    }
+
+    ret = pwritev_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_pwritev_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = writev_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_writev_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = write_async(glfd);
+    if (ret) {
+        LOG_ERR("glfs_write_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = preadv_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_preadv_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = pread_async(glfd);
+    if (ret) {
+        LOG_ERR("glfs_pread_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = readv_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_readv_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = read_async(glfd);
+    if (ret) {
+        LOG_ERR("glfs_read_async_test failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = glfs_fsync(glfd, NULL, NULL);
+    if (ret < 0) {
+        LOG_ERR("glfs_fsync failed");
+        exit(1);
+    }
+
+    ret = glfs_fdatasync(glfd, NULL, NULL);
+    if (ret < 0) {
+        LOG_ERR("glfs_fdatasync failed");
+        exit(1);
+    }
+
+    ret = glfs_fsync_async(glfd, fsync_async_cbk, data);
+    if (ret < 0) {
+        LOG_ERR("glfs_fsync_async failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = glfs_fdatasync_async(glfd, fdatasync_async_cbk, data);
+    if (ret < 0) {
+        LOG_ERR("glfs_fdatasync_async failed");
+        exit(1);
+    }
+    cbk_check();
+
+    ret = glfs_ftruncate_async(glfd, 4, ftruncate_async_cbk, data);
+    if (ret < 0) {
+        LOG_ERR("glfs_ftruncate_async failed");
+        exit(1);
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs close  failed");
+    }
+
+    ret = glfs_fini(fs);
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/gfapi-copy-file-range.t b/tests/basic/gfapi/gfapi-copy-file-range.t
new file mode 100644
index 00000000000..a56d3a58e07
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-copy-file-range.t
@@ -0,0 +1,82 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+mkfs.xfs 2>&1 | grep reflink
+if [ $? -ne 0 ]; then
+    SKIP_TESTS
+    exit
+fi
+
+
+TEST glusterd
+
+TEST truncate -s 2G $B0/xfs_image
+# for now, a xfs filesystem with reflink support is created.
+# In future, better to make changes in MKFS_LOOP so that,
+# once can create a xfs filesystem with reflink enabled in
+# generic and simple way, instead of doing below steps each
+# time.
+TEST mkfs.xfs -f -i size=512 -m reflink=1 $B0/xfs_image;
+
+TEST mkdir $B0/bricks
+TEST mount -t xfs -o loop $B0/xfs_image $B0/bricks
+
+# Just a single brick volume. More test cases need to be
+# added in future for distribute, replicate,
+# distributed replicate and distributed replicated sharded
+# volumes.
+TEST $CLI volume create $V0 $H0:$B0/bricks/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST dd if=/dev/urandom of=$M0/file bs=1M count=555;
+
+# check for the existence of the created file
+TEST stat  $M0/file;
+
+# grab the size of the file
+SRC_SIZE=$(stat -c %s $M0/file);
+
+logdir=`gluster --print-logdir`
+
+# TODO:
+# For now, do not call copy-file-range utility. This is because,
+# the regression machines are centos-7 based which does not have
+# copy_file_range API available. So, instead of this testcase
+# causing regression failures, for now, this is just a dummy test
+# case. Uncomment the below tests (until volume stop) when there
+# is support for copy_file_range in the regression machines.
+#
+
+TEST build_tester $(dirname $0)/glfs-copy-file-range.c -lgfapi
+
+TEST ./$(dirname $0)/glfs-copy-file-range $H0 $V0 $logdir/gfapi-copy-file-range.log /file /new
+
+# check whether the destination file is created or not
+TEST stat $M0/new
+
+# check the size of the destination file
+DST_SIZE=$(stat -c %s $M0/new);
+
+# The sizes of the source and destination should be same.
+# Atleast it ensures that, copy_file_range API is working
+# as expected. Whether the actual cloning happened via reflink
+# or a read/write happened is different matter.
+TEST [ $SRC_SIZE == $DST_SIZE ];
+
+cleanup_tester $(dirname $0)/glfs-copy-file-range
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+UMOUNT_LOOP $B0/bricks;
+
+cleanup;
diff --git a/tests/basic/gfapi/gfapi-dup.c b/tests/basic/gfapi/gfapi-dup.c
index 96f133eae33..028108e4590 100644
--- a/tests/basic/gfapi/gfapi-dup.c
+++ b/tests/basic/gfapi/gfapi-dup.c
@@ -4,81 +4,81 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        glfs_fd_t      *fd2 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        char           *hostname = NULL;
-        const char     *filename = "file_tmp";
-        const char     *buff = "An opinion should be the result of thought, "
-                                "not a substitute for it.";
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, strlen (buff), flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        fd2 = glfs_dup(fd1);
-        if (fd2 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_dup", ret, out);
-        }
-
-        ret = glfs_lseek (fd2, 0, SEEK_SET);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_lseek", ret, out);
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    const char *filename = "file_tmp";
+    const char *buff =
+        "An opinion should be the result of thought, "
+        "not a substitute for it.";
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, strlen(buff), flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    fd2 = glfs_dup(fd1);
+    if (fd2 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_dup", ret, out);
+    }
+
+    ret = glfs_lseek(fd2, 0, SEEK_SET);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_lseek", ret, out);
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fd2 != NULL)
-                glfs_close(fd2);
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fd2 != NULL)
+        glfs_close(fd2);
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-graph-switch-open-fd.t b/tests/basic/gfapi/gfapi-graph-switch-open-fd.t
new file mode 100644
index 00000000000..2e666be7ec7
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-graph-switch-open-fd.t
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 ${H0}:$B0/brick{0..2};
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST touch $M0/sync
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/gfapi-keep-writing.c -lgfapi
+
+
+#Launch a program to keep doing writes on an fd
+./$(dirname $0)/gfapi-keep-writing ${H0} $V0 $logdir/gfapi-async-calls-test.log sync &
+p=$!
+sleep 1 #Let some writes go through
+#Check if graph switch will lead to any pending markers for ever
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+
+
+TEST rm -f $M0/sync #Make sure the glfd is closed
+TEST wait #Wait for background process to die
+#Goal is to check if there is permanent FOOL changelog
+sleep 5
+EXPECT "0x000000000000000000000000" afr_get_changelog_xattr $B0/brick0/glfs_test.txt trusted.afr.dirty
+EXPECT "0x000000000000000000000000" afr_get_changelog_xattr $B0/brick1/glfs_test.txt trusted.afr.dirty
+EXPECT "0x000000000000000000000000" afr_get_changelog_xattr $B0/brick2/glfs_test.txt trusted.afr.dirty
+
+cleanup_tester $(dirname $0)/gfapi-async-calls-test
+
+cleanup;
diff --git a/tests/basic/gfapi/gfapi-keep-writing.c b/tests/basic/gfapi/gfapi-keep-writing.c
new file mode 100644
index 00000000000..91b59cea02b
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-keep-writing.c
@@ -0,0 +1,129 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
+
+glfs_t *
+init_glfs(const char *hostname, const char *volname, const char *logfile)
+{
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
+
+    return fs;
+}
+
+int
+glfs_test_function(const char *hostname, const char *volname,
+                   const char *logfile, const char *syncfile)
+{
+    int ret = -1;
+    int flags = O_CREAT | O_RDWR;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    const char *buff = "This is from my prog\n";
+    const char *filename = "glfs_test.txt";
+    struct stat buf = {0};
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        goto out;
+    }
+
+    while (glfs_stat(fs, syncfile, &buf) == 0) {
+        ret = glfs_write(glfd, buff, strlen(buff), flags);
+        if (ret < 0) {
+            LOG_ERR("glfs_write failed");
+            goto out;
+        }
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+out:
+    ret = glfs_fini(fs);
+    if (ret) {
+        LOG_ERR("glfs_fini failed");
+    }
+
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *syncfile = NULL;
+
+    if (argc != 5) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+    syncfile = argv[4];
+
+    ret = glfs_test_function(hostname, volname, logfile, syncfile);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+    }
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/gfapi-load-volfile.c b/tests/basic/gfapi/gfapi-load-volfile.c
index 91d5677bd44..fbfc6045cd7 100644
--- a/tests/basic/gfapi/gfapi-load-volfile.c
+++ b/tests/basic/gfapi/gfapi-load-volfile.c
@@ -9,57 +9,57 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <api/glfs.h>
+#include <glusterfs/api/glfs.h>
 
 #define PROGNAME "gfapi-load-volfile"
 
 void
 usage(FILE *output)
 {
-	fprintf(output, "Usage: " PROGNAME " <volfile>\n");
+    fprintf(output, "Usage: " PROGNAME " <volfile>\n");
 }
 
 void
 main(int argc, char **argv)
 {
-	int ret = 0;
-	glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_t *fs = NULL;
 
-	if (argc != 2) {
-		usage(stderr);
-		exit(EXIT_FAILURE);
-	}
+    if (argc != 2) {
+        usage(stderr);
+        exit(EXIT_FAILURE);
+    }
 
-	if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
-		usage(stdout);
-		exit(EXIT_SUCCESS);
-	}
+    if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
+        usage(stdout);
+        exit(EXIT_SUCCESS);
+    }
 
-	fs = glfs_new(PROGNAME);
-	if (!fs) {
-		perror("glfs_new failed");
-		exit(EXIT_FAILURE);
-	}
+    fs = glfs_new(PROGNAME);
+    if (!fs) {
+        perror("glfs_new failed");
+        exit(EXIT_FAILURE);
+    }
 
-	glfs_set_logging(fs, PROGNAME ".log", 9);
+    glfs_set_logging(fs, PROGNAME ".log", 9);
 
-	ret = glfs_set_volfile(fs, argv[1]);
-	if (ret) {
-		perror("glfs_set_volfile failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_set_volfile(fs, argv[1]);
+    if (ret) {
+        perror("glfs_set_volfile failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = glfs_init(fs);
-	if (ret) {
-		perror("glfs_init failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_init(fs);
+    if (ret) {
+        perror("glfs_init failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = EXIT_SUCCESS;
+    ret = EXIT_SUCCESS;
 out:
-	glfs_fini(fs);
+    glfs_fini(fs);
 
-	exit(ret);
+    exit(ret);
 }
diff --git a/tests/basic/gfapi/gfapi-ssl-load-volfile-test.c b/tests/basic/gfapi/gfapi-ssl-load-volfile-test.c
new file mode 100644
index 00000000000..7beb8dd1fe4
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-ssl-load-volfile-test.c
@@ -0,0 +1,127 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
+
+glfs_t *
+init_glfs(const char *hostname, const char *volname, const char *volfile,
+          const char *logfile)
+{
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile(fs, volfile);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
+
+    return fs;
+}
+
+int
+glfs_test_function(const char *hostname, const char *volname,
+                   const char *volfile, const char *logfile)
+{
+    int ret = -1;
+    int flags = O_CREAT | O_RDWR;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    const char *buff = "This is from my prog\n";
+    const char *filename = "glfs_test.txt";
+
+    fs = init_glfs(hostname, volname, volfile, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        goto out;
+    }
+
+    ret = glfs_write(glfd, buff, strlen(buff), flags);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+out:
+    ret = glfs_fini(fs);
+    if (ret) {
+        LOG_ERR("glfs_fini failed");
+    }
+
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *volfile = NULL;
+    char *logfile = NULL;
+
+    if (argc != 5) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    volfile = argv[3];
+    logfile = argv[4];
+
+    ret = glfs_test_function(hostname, volname, volfile, logfile);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+    }
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/gfapi-ssl-load-volfile-test.t b/tests/basic/gfapi/gfapi-ssl-load-volfile-test.t
new file mode 100755
index 00000000000..8e94df9d321
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-ssl-load-volfile-test.t
@@ -0,0 +1,76 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../traps.rc
+. $(dirname $0)/../../ssl.rc
+
+cleanup;
+
+sed -e "s,@@HOSTNAME@@,${H0},g" -e "s,@@BRICKPATH@@,${B0}/brick1,g" \
+            -e "s,@@SSL@@,off,g" \
+            $(dirname ${0})/protocol-client-ssl.vol.in \
+            > $(dirname ${0})/protocol-client-ssl.vol
+
+TEST create_self_signed_certs
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/gfapi-ssl-load-volfile-test.c -lgfapi
+
+# Run test without I/O or management encryption
+TEST $(dirname $0)/gfapi-ssl-load-volfile-test $H0 $V0 \
+        $(dirname ${0})/protocol-client-ssl.vol \
+        $logdir/gfapi-ssl-load-volfile-test.log
+
+# Enable management encryption
+touch $GLUSTERD_WORKDIR/secure-access
+
+killall_gluster
+
+TEST glusterd
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
+
+# Run test with management encryption (No I/O encryption)
+TEST $(dirname $0)/gfapi-ssl-load-volfile-test $H0 $V0 \
+        $(dirname ${0})/protocol-client-ssl.vol \
+        $logdir/gfapi-ssl-load-volfile-test.log
+
+# Enable I/O encryption
+TEST $CLI volume set $V0 server.ssl on
+
+killall_gluster
+
+sed -e "s,@@HOSTNAME@@,${H0},g" -e "s,@@BRICKPATH@@,${B0}/brick1,g" \
+            -e "s,@@SSL@@,on,g" \
+            $(dirname ${0})/protocol-client-ssl.vol.in \
+            > $(dirname ${0})/protocol-client-ssl.vol
+
+TEST glusterd
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
+
+# Run test without I/O or management encryption
+TEST $(dirname $0)/gfapi-ssl-load-volfile-test $H0 $V0 \
+        $(dirname ${0})/protocol-client-ssl.vol \
+        $logdir/gfapi-ssl-load-volfile-test.log
+
+cleanup_tester $(dirname $0)/gfapi-ssl-load-volfile-test
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup;
+
+# NetBSD build scripts are not up to date therefore this test
+# is failing in NetBSD. Therefore skipping the test in NetBSD
+# as of now.
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/gfapi/gfapi-ssl-test.c b/tests/basic/gfapi/gfapi-ssl-test.c
index 41126bdc6db..a27b5233702 100644
--- a/tests/basic/gfapi/gfapi-ssl-test.c
+++ b/tests/basic/gfapi/gfapi-ssl-test.c
@@ -9,118 +9,116 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
 int
-glfs_test_function (const char *hostname, const char *volname,
-                    const char *logfile)
+glfs_test_function(const char *hostname, const char *volname,
+                   const char *logfile)
 {
-        int             ret      = -1;
-        int             flags    = O_CREAT | O_RDWR;
-        glfs_t         *fs       = NULL;
-        glfs_fd_t      *glfd     = NULL;
-        const char     *buff     = "This is from my prog\n";
-        const char     *filename = "glfs_test.txt";
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                goto out;
-        }
-
-        ret = glfs_write (glfd, buff, strlen (buff), flags);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
+    int ret = -1;
+    int flags = O_CREAT | O_RDWR;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    const char *buff = "This is from my prog\n";
+    const char *filename = "glfs_test.txt";
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        goto out;
+    }
+
+    ret = glfs_write(glfd, buff, strlen(buff), flags);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
 
 out:
-        ret = glfs_fini (fs);
-        if (ret) {
-                LOG_ERR ("glfs_fini failed");
-        }
+    ret = glfs_fini(fs);
+    if (ret) {
+        LOG_ERR("glfs_fini failed");
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret = 0;
-        char *hostname = NULL;
-        char *volname = NULL;
-        char *logfile = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        ret = glfs_test_function (hostname, volname, logfile);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-        }
-
-        return ret;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    ret = glfs_test_function(hostname, volname, logfile);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-statx-basic.c b/tests/basic/gfapi/gfapi-statx-basic.c
new file mode 100644
index 00000000000..a4943fa0fd1
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-statx-basic.c
@@ -0,0 +1,184 @@
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <glusterfs/api/glfs.h>
+
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define GOTO_LABEL_ON_FALSE(compstr, ret, label)                               \
+    do {                                                                       \
+        if (ret == false) {                                                    \
+            fprintf(stderr, "%s : comparison failed!\n", compstr);             \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define WRITE_SIZE 513
+#define TRUNC_SIZE 4096
+
+/* Using private function and hence providing a forward declation in sync with
+code in glfs-internal.h */
+int
+glfs_statx(struct glfs *fs, const char *path, unsigned int mask,
+           struct glfs_stat *statxbuf);
+
+int
+main(int argc, char *argv[])
+{
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    const char buff[WRITE_SIZE];
+    struct stat sb;
+    unsigned int mask;
+    struct glfs_stat statx;
+    bool bret;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        fprintf(stderr, "Usage: %s <volname> <logfile>\n", argv[0]);
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_truncate(fs, filename, TRUNC_SIZE);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out);
+
+    ret = glfs_write(fd1, buff, WRITE_SIZE, flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    ret = glfs_fstat(fd1, &sb);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out);
+
+    if (sb.st_size != TRUNC_SIZE) {
+        fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size,
+                (intmax_t)2048);
+        ret = -1;
+        goto out;
+    }
+
+    glfs_close(fd1);
+    fd1 = NULL;
+
+    /* TEST 1: Invalid mask to statx */
+    mask = 0xfafadbdb;
+    ret = glfs_statx(fs, filename, mask, NULL);
+    if (ret == 0 || ((ret == -1) && (errno != EINVAL))) {
+        fprintf(stderr,
+                "Invalid args passed, but error returned is"
+                " incorrect (ret - %d, errno - %d)\n",
+                ret, errno);
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
+
+    /* TEST 2: Call statx and validate fields against prior fstat data */
+    /* NOTE: This fails, as iatt->ia_flags are not carried through the stack,
+     * for example if mdc_to_iatt is invoked to serve cached stat, we will loose
+     * the flags. */
+    mask = GLFS_STAT_ALL;
+    ret = glfs_statx(fs, filename, mask, &statx);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_statx", ret, out);
+
+    if ((statx.glfs_st_mask & GLFS_STAT_BASIC_STATS) != GLFS_STAT_BASIC_STATS) {
+        fprintf(stderr, "Invalid glfs_st_mask, expecting 0x%x got 0x%x\n",
+                GLFS_STAT_ALL, statx.glfs_st_mask);
+        ret = -1;
+        goto out;
+    }
+
+    bret = (sb.st_ino == statx.glfs_st_ino);
+    GOTO_LABEL_ON_FALSE("(sb.st_ino == statx.glfs_st_ino)", bret, out);
+
+    bret = (sb.st_mode == statx.glfs_st_mode);
+    GOTO_LABEL_ON_FALSE("(sb.st_mode == statx.glfs_st_mode)", bret, out);
+
+    bret = (sb.st_nlink == statx.glfs_st_nlink);
+    GOTO_LABEL_ON_FALSE("(sb.st_nlink == statx.glfs_st_nlink)", bret, out);
+
+    bret = (sb.st_uid == statx.glfs_st_uid);
+    GOTO_LABEL_ON_FALSE("(sb.st_uid == statx.glfs_st_uid)", bret, out);
+
+    bret = (sb.st_gid == statx.glfs_st_gid);
+    GOTO_LABEL_ON_FALSE("(sb.st_gid == statx.glfs_st_gid)", bret, out);
+
+    bret = (sb.st_size == statx.glfs_st_size);
+    GOTO_LABEL_ON_FALSE("(sb.st_size == statx.glfs_st_size)", bret, out);
+
+    bret = (sb.st_blksize == statx.glfs_st_blksize);
+    GOTO_LABEL_ON_FALSE("(sb.st_blksize == statx.glfs_st_blksize)", bret, out);
+
+    bret = (sb.st_blocks == statx.glfs_st_blocks);
+    GOTO_LABEL_ON_FALSE("(sb.st_blocks == statx.glfs_st_blocks)", bret, out);
+
+    bret = (!memcmp(&sb.st_atim, &statx.glfs_st_atime,
+                    sizeof(struct timespec)));
+    GOTO_LABEL_ON_FALSE("(sb.st_atim == statx.glfs_st_atime)", bret, out);
+
+    bret = (!memcmp(&sb.st_mtim, &statx.glfs_st_mtime,
+                    sizeof(struct timespec)));
+    GOTO_LABEL_ON_FALSE("(sb.st_mtim == statx.glfs_st_mtime)", bret, out);
+
+    bret = (!memcmp(&sb.st_ctim, &statx.glfs_st_ctime,
+                    sizeof(struct timespec)));
+    GOTO_LABEL_ON_FALSE("(sb.st_ctim == statx.glfs_st_ctime)", bret, out);
+
+    /* TEST 3: Check if partial masks are accepted */
+    mask = GLFS_STAT_TYPE | GLFS_STAT_UID | GLFS_STAT_GID;
+    ret = glfs_statx(fs, filename, mask, &statx);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_statx", ret, out);
+
+    /* We currently still return all stats, as is acceptable based on the API
+     * definition in the header (and in statx as well) */
+    if ((statx.glfs_st_mask & GLFS_STAT_BASIC_STATS) != GLFS_STAT_BASIC_STATS) {
+        fprintf(stderr, "Invalid glfs_st_mask, expecting 0x%x got 0x%x\n",
+                GLFS_STAT_ALL, statx.glfs_st_mask);
+        ret = -1;
+        goto out;
+    }
+out:
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fs) {
+        (void)glfs_fini(fs);
+    }
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/gfapi-statx-basic.t b/tests/basic/gfapi/gfapi-statx-basic.t
new file mode 100755
index 00000000000..d9acbce2f99
--- /dev/null
+++ b/tests/basic/gfapi/gfapi-statx-basic.t
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 ${H0}:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+# NOTE: Test is passing due to very specific volume configuration
+# Disable md-cache, as it does not save and return ia_flags from iatt
+# This is possibly going to be true of other xlators as well (ec/afr), need to
+# ensure these are fixed, or hack statx to return all basic attrs anyway.
+TEST $CLI volume set $V0 performance.md-cache-timeout 0
+
+logdir=`gluster --print-logdir`
+
+build_tester $(dirname $0)/gfapi-statx-basic.c -lgfapi
+
+TEST ./$(dirname $0)/gfapi-statx-basic $V0 $logdir/gfapi-statx-basic.log
+
+cleanup_tester $(dirname $0)/gfapi-statx-basic
+
+cleanup;
diff --git a/tests/basic/gfapi/gfapi-trunc.c b/tests/basic/gfapi/gfapi-trunc.c
index af187e50c78..769f6cfa1d9 100644
--- a/tests/basic/gfapi/gfapi-trunc.c
+++ b/tests/basic/gfapi/gfapi-trunc.c
@@ -5,86 +5,85 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define WRITE_SIZE      4096
-#define TRUNC_SIZE      1234
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define WRITE_SIZE 4096
+#define TRUNC_SIZE 1234
 /* Make sure TRUNC_SIZE is smaller than WRITE_SIZE at compile time. */
-typedef char _size_check[WRITE_SIZE-TRUNC_SIZE];
+typedef char _size_check[WRITE_SIZE - TRUNC_SIZE];
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        const char     *filename = "file_tmp";
-        const char     buff[WRITE_SIZE];
-        struct stat    sb;
-
-        if (argc != 3) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        volname = argv[1];
-        logfile = argv[2];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, WRITE_SIZE, flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        ret = glfs_truncate (fs, filename, TRUNC_SIZE);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out);
-
-        ret = glfs_fstat (fd1, &sb);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out);
-
-        if (sb.st_size != TRUNC_SIZE) {
-                fprintf (stderr, "wrong size %jd should be %jd\n",
-                         (intmax_t)sb.st_size, (intmax_t)2048);
-                ret = -1;
-        }
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    const char buff[WRITE_SIZE];
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, WRITE_SIZE, flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    ret = glfs_truncate(fs, filename, TRUNC_SIZE);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out);
+
+    ret = glfs_fstat(fd1, &sb);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out);
+
+    if (sb.st_size != TRUNC_SIZE) {
+        fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size,
+                (intmax_t)2048);
+        ret = -1;
+    }
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fs) {
-                /*
-                 * If this fails (as it does on Special Snowflake NetBSD for no
-                 * good reason), it shouldn't affect the result of the test.
-                 */
-                (void) glfs_fini(fs);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fs) {
+        /*
+         * If this fails (as it does on Special Snowflake NetBSD for no
+         * good reason), it shouldn't affect the result of the test.
+         */
+        (void)glfs_fini(fs);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/glfd-lkowner.c b/tests/basic/gfapi/glfd-lkowner.c
index 031a076683c..ec0429dc3c4 100644
--- a/tests/basic/gfapi/glfd-lkowner.c
+++ b/tests/basic/gfapi/glfd-lkowner.c
@@ -13,200 +13,202 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-               fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 char lownera[8] = "lownera", lownerb[8] = "lownerb";
 char lownerc[8] = "lownerc";
 
-int lock_test (glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail,
-               int l1_start, int l1_len, char *l1_owner, int lo1_len,
-               int l2_start, int l2_len, char *l2_owner, int lo2_len)
+int
+lock_test(glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail, int l1_start,
+          int l1_len, char *l1_owner, int lo1_len, int l2_start, int l2_len,
+          char *l2_owner, int lo2_len)
 {
-        int ret = -1, f_ret = -1;
-        struct flock lock1 = {0, }, lock2 = {0, };
+    int ret = -1, f_ret = -1;
+    struct flock lock1 =
+                     {
+                         0,
+                     },
+                 lock2 = {
+                     0,
+                 };
 
 lock1:
-        if (!glfd1)
-                goto lock2;
+    if (!glfd1)
+        goto lock2;
 
-        /* lock on glfd1 */
-        lock1.l_type = F_WRLCK;
-        lock1.l_whence = SEEK_SET;
-        lock1.l_start = l1_start;
-        lock1.l_len = l1_len;
+    /* lock on glfd1 */
+    lock1.l_type = F_WRLCK;
+    lock1.l_whence = SEEK_SET;
+    lock1.l_start = l1_start;
+    lock1.l_len = l1_len;
 
-        ret = glfs_fd_set_lkowner (glfd1, l1_owner, lo1_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd1", ret);
+    ret = glfs_fd_set_lkowner(glfd1, l1_owner, lo1_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd1", ret);
 
-        ret = glfs_posix_lock (glfd1, F_SETLK, &lock1);
-        LOG_ERR ("glfs_posix_lock on glfd1", ret);
+    ret = glfs_posix_lock(glfd1, F_SETLK, &lock1);
+    LOG_ERR("glfs_posix_lock on glfd1", ret);
 
 lock2:
-        if (!glfd2)
-                goto out;
-
-        /* lock on glfd2 */
-        lock2.l_type = F_WRLCK;
-        lock2.l_whence = SEEK_SET;
-        lock2.l_start = l2_start;
-        lock2.l_len = l2_len;
-
-        ret = glfs_fd_set_lkowner (glfd2, l2_owner, lo2_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd2", ret);
-
-        ret = glfs_posix_lock (glfd2, F_SETLK, &lock2);
-
-        if (should_fail && ret) {
-                f_ret = 0;
-        } else if (!ret && !should_fail) {
-                f_ret = 0;
-        } else {
-                f_ret = -1;
-        }
+    if (!glfd2)
+        goto out;
+
+    /* lock on glfd2 */
+    lock2.l_type = F_WRLCK;
+    lock2.l_whence = SEEK_SET;
+    lock2.l_start = l2_start;
+    lock2.l_len = l2_len;
+
+    ret = glfs_fd_set_lkowner(glfd2, l2_owner, lo2_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd2", ret);
+
+    ret = glfs_posix_lock(glfd2, F_SETLK, &lock2);
+
+    if (should_fail && ret) {
+        f_ret = 0;
+    } else if (!ret && !should_fail) {
+        f_ret = 0;
+    } else {
+        f_ret = -1;
+    }
 out:
-        fprintf (stderr, "Lock test on glfd1 (start(%d), len(%d),"
-                         " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
-                         "lk_owner(%s)) - expected(%s) - result(%s)\n",
-                         l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
-                         (should_fail ? "FAIL" : "SUCCESS"),
-                         (ret ? "FAIL" : "SUCCESS"));
-        return f_ret;
+    fprintf(stderr,
+            "Lock test on glfd1 (start(%d), len(%d),"
+            " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
+            "lk_owner(%s)) - expected(%s) - result(%s)\n",
+            l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
+            (should_fail ? "FAIL" : "SUCCESS"), (ret ? "FAIL" : "SUCCESS"));
+    return f_ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd1 = NULL;
-        glfs_fd_t *fd2 = NULL;
-        glfs_fd_t *fd3 = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd1 = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd1 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd1 - %d\n", fd1);
-
-        fd2 = glfs_dup(fd1);
-        fprintf (stderr, "glfs-dup fd2 - %d\n", fd2);
-
-        fd3 = glfs_open(fs, filename, O_RDWR|O_SYNC);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open", ret);
-        }
-        fprintf (stderr, "glfs-open fd3 - %d\n", fd3);
-
-        /* TEST 1: Conflicting ranges, same lk_owner
-         * lock1 (0, 10, lownera)
-         * lock2 (5, 10, lownera)
-         * Expected: should not fail but get merged
-         */
-        ret = lock_test (fd1, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_1", ret);
-
-        /* TEST 2: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (5, 10, lownerb)
-         * Expected: should fail and not get merged
-         */
-        ret = lock_test (NULL, fd2, true, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_2", ret);
-
-        /* TEST 3: Different ranges, same lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (30, 10, lownera)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         30, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_3", ret);
-
-        /* TEST 4: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (50, 10, lownerb)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         50, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_4", ret);
-
-        /* TEST 5: Close fd1 & retry TEST2
-         * lock1 (not applicable)
-         * lock2 (5, 10, lownerb)
-         * Expected: should succeed now
-         */
-        ret = glfs_close(fd1);
-        LOG_ERR ("glfs_close", ret);
-
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_5", ret);
-
-        /* TEST 6: Check closing fd1 doesn't flush fd2 locks
-         * retry TEST 4 but with fd2 and fd3.
-         * lock1 (50, 10, lownerb) - already taken
-         * lock2 (55, 10, lownerc)
-         * Expected: should fail
-         */
-        ret = lock_test (NULL, fd3, true, 50, 10, lownerb, 8,
-                         55, 10, lownerc, 8);
-        LOG_ERR ("==== glfs_lock_test_6", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd1 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd1 - %d\n", fd1);
+
+    fd2 = glfs_dup(fd1);
+    fprintf(stderr, "glfs-dup fd2 - %d\n", fd2);
+
+    fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open", ret);
+    }
+    fprintf(stderr, "glfs-open fd3 - %d\n", fd3);
+
+    /* TEST 1: Conflicting ranges, same lk_owner
+     * lock1 (0, 10, lownera)
+     * lock2 (5, 10, lownera)
+     * Expected: should not fail but get merged
+     */
+    ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_1", ret);
+
+    /* TEST 2: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (5, 10, lownerb)
+     * Expected: should fail and not get merged
+     */
+    ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_2", ret);
+
+    /* TEST 3: Different ranges, same lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (30, 10, lownera)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_3", ret);
+
+    /* TEST 4: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (50, 10, lownerb)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_4", ret);
+
+    /* TEST 5: Close fd1 & retry TEST2
+     * lock1 (not applicable)
+     * lock2 (5, 10, lownerb)
+     * Expected: should succeed now
+     */
+    ret = glfs_close(fd1);
+    LOG_ERR("glfs_close", ret);
+
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_5", ret);
+
+    /* TEST 6: Check closing fd1 doesn't flush fd2 locks
+     * retry TEST 4 but with fd2 and fd3.
+     * lock1 (50, 10, lownerb) - already taken
+     * lock2 (55, 10, lownerc)
+     * Expected: should fail
+     */
+    ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8);
+    LOG_ERR("==== glfs_lock_test_6", ret);
 
 err:
-        ret = glfs_close(fd2);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd2);
+    LOG_ERR("glfs_close", ret);
 
-        ret = glfs_close(fd3);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd3);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/glfs-copy-file-range.c b/tests/basic/gfapi/glfs-copy-file-range.c
new file mode 100644
index 00000000000..1c5fd81fc87
--- /dev/null
+++ b/tests/basic/gfapi/glfs-copy-file-range.c
@@ -0,0 +1,180 @@
+/*
+ Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+ This file is part of GlusterFS.
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <string.h>
+#include <time.h>
+#include <libgen.h>
+
+static void
+cleanup(glfs_t *fs)
+{
+    if (!fs)
+        return;
+#if 0
+        /* glfs fini path is still racy and crashing the program. Since
+         * this program any way has to die, we are not going to call fini
+         * in the released versions. i.e. final builds. For all
+         * internal testing lets enable this so that glfs_fini code
+         * path becomes stable. */
+        glfs_fini (fs);
+#endif
+}
+
+int
+main(int argc, char **argv)
+{
+    glfs_t *fs = NULL;
+    int ret = -1;
+    char *volname = NULL;
+    char *logfilepath = NULL;
+    char *path_src = NULL;
+    char *path_dst = NULL;
+    glfs_fd_t *glfd_in = NULL;
+    glfs_fd_t *glfd_out = NULL;
+    char *volfile_server = NULL;
+
+    struct stat stbuf = {
+        0,
+    };
+    struct glfs_stat stat_src = {
+        0,
+    };
+    struct glfs_stat prestat_dst = {
+        0,
+    };
+    struct glfs_stat poststat_dst = {
+        0,
+    };
+    size_t len;
+
+    if (argc < 6) {
+        printf("%s <volume> <log file path> <source> <destination>", argv[0]);
+        ret = -1;
+        goto out;
+    }
+
+    volfile_server = argv[1];
+    volname = argv[2];
+    logfilepath = argv[3];
+    path_src = argv[4];
+    path_dst = argv[5];
+
+    if (path_src[0] != '/') {
+        fprintf(stderr, "source path %s is not absolute", path_src);
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (path_dst[0] != '/') {
+        fprintf(stderr, "destination path %s is not absolute", path_dst);
+        errno = EINVAL;
+        goto out;
+    }
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        ret = -errno;
+        fprintf(stderr, "Not able to initialize volume '%s'", volname);
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", volfile_server, 24007);
+    if (ret < 0) {
+        ret = -errno;
+        fprintf(stderr,
+                "Failed to set the volfile server, "
+                "%s",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfilepath, 7);
+    if (ret < 0) {
+        ret = -errno;
+        fprintf(stderr,
+                "Failed to set the log file path, "
+                "%s",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        ret = -errno;
+        if (errno == ENOENT) {
+            fprintf(stderr, "Volume %s does not exist", volname);
+        } else {
+            fprintf(stderr,
+                    "%s: Not able to fetch "
+                    "volfile from glusterd",
+                    volname);
+        }
+        goto out;
+    }
+
+    glfd_in = glfs_open(fs, path_src, O_RDONLY | O_NONBLOCK);
+    if (!glfd_in) {
+        ret = -errno;
+        goto out;
+    } else {
+        printf("OPEN_SRC: opening %s is success\n", path_src);
+    }
+
+    glfd_out = glfs_creat(fs, path_dst, O_RDWR, 0644);
+    if (!glfd_out) {
+        fprintf(stderr,
+                "FAILED_DST_OPEN: failed to "
+                "open (create) %s (%s)\n",
+                path_dst, strerror(errno));
+        ret = -errno;
+        goto out;
+    } else {
+        printf("OPEN_DST: opening %s is success\n", path_dst);
+    }
+
+    ret = glfs_fstat(glfd_in, &stbuf);
+    if (ret < 0) {
+        ret = -errno;
+        goto out;
+    } else {
+        printf("FSTAT_SRC: fstat on %s is success\n", path_dst);
+    }
+
+    len = stbuf.st_size;
+
+    do {
+        ret = glfs_copy_file_range(glfd_in, NULL, glfd_out, NULL, len, 0,
+                                   &stat_src, &prestat_dst, &poststat_dst);
+        if (ret == -1) {
+            fprintf(stderr, "copy_file_range failed with %s\n",
+                    strerror(errno));
+            ret = -errno;
+            break;
+        } else {
+            printf("copy_file_range successful\n");
+            len -= ret;
+        }
+    } while (len > 0);
+
+out:
+    if (glfd_in)
+        glfs_close(glfd_in);
+    if (glfd_out)
+        glfs_close(glfd_out);
+
+    cleanup(fs);
+
+    return ret;
+}
diff --git a/tests/basic/gfapi/glfs_h_creat_open.c b/tests/basic/gfapi/glfs_h_creat_open.c
new file mode 100644
index 00000000000..7672561e73f
--- /dev/null
+++ b/tests/basic/gfapi/glfs_h_creat_open.c
@@ -0,0 +1,118 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    int ret = 0;
+    struct glfs_object *root = NULL, *leaf = NULL;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/ro-file";
+    struct stat sb = {
+        0,
+    };
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    char buf[32] = "abcdefghijklmnopqrstuvwxyz012345";
+
+    fprintf(stderr, "Starting glfs_h_creat_open\n");
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    leaf = glfs_h_creat_open(fs, root, filename, O_RDONLY, 00444, &sb, &fd);
+    if (!leaf || !fd) {
+        ret = -1;
+        LOG_ERR("glfs_h_creat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create_open leaf - %p\n", leaf);
+
+    ret = glfs_write(fd, buf, 32, 0);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_write: error writing to file %s, %s\n", filename,
+                strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    LOG_ERR("glfs_h_getattrs", ret);
+
+    if (sb.st_size != 32) {
+        fprintf(stderr, "glfs_write: post size mismatch\n");
+        goto out;
+    }
+
+    fprintf(stderr, "Successfully opened and written to a read-only file \n");
+out:
+    if (fd)
+        glfs_close(fd);
+
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
+
+    fprintf(stderr, "End of libgfapi_fini\n");
+
+    exit(0);
+}
diff --git a/tests/basic/gfapi/glfs_h_creat_open.t b/tests/basic/gfapi/glfs_h_creat_open.t
new file mode 100755
index 00000000000..f24ae7395be
--- /dev/null
+++ b/tests/basic/gfapi/glfs_h_creat_open.t
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/glfs_h_creat_open.c -lgfapi
+
+TEST ./$(dirname $0)/glfs_h_creat_open $H0 $V0  $logdir/glfs.log
+
+cleanup_tester $(dirname $0)/glfs_h_creat_open
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup;
diff --git a/tests/basic/gfapi/glfs_sysrq.c b/tests/basic/gfapi/glfs_sysrq.c
index c843c2a3559..13e06be6df2 100644
--- a/tests/basic/gfapi/glfs_sysrq.c
+++ b/tests/basic/gfapi/glfs_sysrq.c
@@ -10,52 +10,51 @@
 #include <glusterfs/api/glfs.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        /* cmdline arguments */
-        char   *host    = NULL;
-        char   *volume  = NULL;
-        char   *logfile = NULL;
-
-        /* other variables */
-        glfs_t *fs      = NULL;
-        int     ret     = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Usage: %s <host> <volume> <logfile>\n",
-                         argv[0]);
-                return -1;
-        }
-
-        host = argv[1];
-        volume = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volume);
-        if (!fs) {
-                return -1;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", host, 24007);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        /* checking of the results is easier in the script running this test */
-        glfs_sysrq (fs, GLFS_SYSRQ_HELP);
-        glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP);
-
-        glfs_fini (fs);
-
-        return 0;
+    /* cmdline arguments */
+    char *host = NULL;
+    char *volume = NULL;
+    char *logfile = NULL;
+
+    /* other variables */
+    glfs_t *fs = NULL;
+    int ret = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Usage: %s <host> <volume> <logfile>\n", argv[0]);
+        return -1;
+    }
+
+    host = argv[1];
+    volume = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volume);
+    if (!fs) {
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    /* checking of the results is easier in the script running this test */
+    glfs_sysrq(fs, GLFS_SYSRQ_HELP);
+    glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
+
+    glfs_fini(fs);
+
+    return 0;
 }
diff --git a/tests/basic/gfapi/glfs_xreaddirplus_r.c b/tests/basic/gfapi/glfs_xreaddirplus_r.c
index 17f4d1b1d57..0c4c79123eb 100644
--- a/tests/basic/gfapi/glfs_xreaddirplus_r.c
+++ b/tests/basic/gfapi/glfs_xreaddirplus_r.c
@@ -6,237 +6,237 @@
 #include <glusterfs/api/glfs-handles.h>
 #include <time.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label) do { \
-        if (!bool_var) {            \
-                fprintf (stderr, "%s : returned error (%s)\n", \
-                         func, strerror (errno)); \
-                ret = -1;                         \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label)      \
+    do {                                                                       \
+        if (!bool_var) {                                                       \
+            fprintf(stderr, "%s : returned error (%s)\n", func,                \
+                    strerror(errno));                                          \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 #define MAX_FILES_CREATE 10
-#define MAXPATHNAME      512
+#define MAXPATHNAME 512
 
 void
-assimilatetime (struct timespec *ts, struct timespec ts_st,
-                struct timespec ts_ed)
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
 {
-        if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
-                ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
-        } else {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
-                ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
-        }
-
-        if (ts->tv_nsec > 1000000000) {
-                ts->tv_nsec = ts->tv_nsec - 1000000000;
-                ts->tv_sec += 1;
-        }
-
-        return;
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
 }
 
 /*
  * Returns '%' difference between ts1 & ts2
  */
 int
-comparetime (struct timespec ts1, struct timespec ts2)
+comparetime(struct timespec ts1, struct timespec ts2)
 {
-        uint64_t ts1_n, ts2_n;
-        int pct = 0;
+    uint64_t ts1_n, ts2_n;
+    int pct = 0;
 
-        ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
-        ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
+    ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
+    ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
 
-        pct = ((ts1_n - ts2_n)*100)/ts1_n;
+    pct = ((ts1_n - ts2_n) * 100) / ts1_n;
 
-        return pct;
+    return pct;
 }
 
 int
-old_readdir (glfs_t *fs)
+old_readdir(glfs_t *fs)
 {
-        struct glfs_object     *root = NULL;
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        char buf[512];
-        struct dirent          *entry = NULL;
-        int                     ret = -1;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        root = glfs_h_lookupat (fs, NULL, "/", sb, 0);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!root, ret, out);
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) {
-                if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
-                        glhandle = glfs_h_lookupat (fs, root, "/", sb, 0);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!glhandle, ret, out);
-                }
+    struct glfs_object *root = NULL;
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    char buf[512];
+    struct dirent *entry = NULL;
+    int ret = -1;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    root = glfs_h_lookupat(fs, NULL, "/", sb, 0);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!root, ret, out);
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
+            glhandle = glfs_h_lookupat(fs, root, "/", sb, 0);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!glhandle,
+                                                  ret, out);
         }
+    }
 
-        glfs_closedir (fd);
+    glfs_closedir(fd);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-new_xreaddirplus (glfs_t *fs)
+new_xreaddirplus(glfs_t *fs)
 {
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        int                     ret = -1;
-        uint32_t                rflags = (GFAPI_XREADDIRP_STAT |
-                                          GFAPI_XREADDIRP_HANDLE);
-        struct glfs_xreaddirp_stat   *xstat = NULL;
-        struct dirent           de;
-        struct dirent          *pde = NULL;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
-        while (ret > 0 && pde != NULL) {
-                if (xstat) {
-                        sb = glfs_xreaddirplus_get_stat (xstat);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_stat", !!sb, ret, out);
-
-                        if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
-                                glhandle = glfs_xreaddirplus_get_object (xstat);
-                                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_object", !!glhandle, ret, out);
-                        }
-                }
-
-                if (xstat) {
-                        glfs_free(xstat);
-                        xstat = NULL;
-                }
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    int ret = -1;
+    uint32_t rflags = (GFAPI_XREADDIRP_STAT | GFAPI_XREADDIRP_HANDLE);
+    struct glfs_xreaddirp_stat *xstat = NULL;
+    struct dirent de;
+    struct dirent *pde = NULL;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+    while (ret > 0 && pde != NULL) {
+        if (xstat) {
+            sb = glfs_xreaddirplus_get_stat(xstat);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirplus_get_stat",
+                                                  !!sb, ret, out);
+
+            if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
+                glhandle = glfs_xreaddirplus_get_object(xstat);
+                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(
+                    "glfs_xreaddirplus_get_object", !!glhandle, ret, out);
+            }
+        }
 
-                ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+        if (xstat) {
+            glfs_free(xstat);
+            xstat = NULL;
+        }
 
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirp_r", ret, out);
+        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
 
-        }
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirp_r", ret, out);
+    }
 
-        if (xstat)
-                glfs_free(xstat);
+    if (xstat)
+        glfs_free(xstat);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret = -1;
-        glfs_t                 *fs = NULL;
-        char                   *volname = NULL;
-        char                   *logfile = NULL;
-        char                   *hostname = NULL;
-        char                   *my_file = "file_";
-        char                    my_file_name[MAXPATHNAME];
-        uint32_t                flags = O_RDWR|O_SYNC;
-        struct glfs_fd         *fd = NULL;
-        int                     i = 0;
-        int                     pct = 0;
-        struct timespec         timestamp = {0, 0}, st_timestamp, ed_timestamp;
-        struct timespec         otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
+    int ret = -1;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    char *my_file = "file_";
+    char my_file_name[MAXPATHNAME];
+    uint32_t flags = O_RDWR | O_SYNC;
+    struct glfs_fd *fd = NULL;
+    int i = 0;
+    int pct = 0;
+    struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp;
+    struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
 
-        fs = glfs_new (volname);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_new", !!fs, ret, out);
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
+    fs = glfs_new(volname);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
 
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s%d", my_file, i);
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
 
-                fd = glfs_creat(fs, my_file_name, flags, 0644);
-                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", !!fd, ret, out);
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
 
-                glfs_close (fd);
-        }
+        fd = glfs_creat(fs, my_file_name, flags, 0644);
+        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out);
 
-        /* measure performance using old readdir call and new xreaddirplus call and compare */
-        ret = clock_gettime (CLOCK_REALTIME, &ost_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+        glfs_close(fd);
+    }
 
-        ret = old_readdir (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("old_readdir", ret, out);
+    /* measure performance using old readdir call and new xreaddirplus call and
+     * compare */
+    ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &oed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = old_readdir(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out);
 
-        assimilatetime (&otimestamp, ost_timestamp, oed_timestamp);
+    ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        printf ("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                otimestamp.tv_sec, otimestamp.tv_nsec);
+    assimilatetime(&otimestamp, ost_timestamp, oed_timestamp);
 
+    printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           otimestamp.tv_sec, otimestamp.tv_nsec);
 
-        ret = clock_gettime (CLOCK_REALTIME, &st_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &st_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = new_xreaddirplus (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("new_xreaddirplus", ret, out);
+    ret = new_xreaddirplus(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &ed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        assimilatetime (&timestamp, st_timestamp, ed_timestamp);
+    assimilatetime(&timestamp, st_timestamp, ed_timestamp);
 
-        printf ("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                timestamp.tv_sec, timestamp.tv_nsec);
+    printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           timestamp.tv_sec, timestamp.tv_nsec);
 
+    pct = comparetime(otimestamp, timestamp);
+    printf("There is improvement by %d%%\n", pct);
 
-        pct = comparetime (otimestamp, timestamp);
-        printf ("There is improvement by %d%%\n", pct);
-
-        ret = 0;
+    ret = 0;
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
 
-        return ret;
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/glfsxmp-coverage.c b/tests/basic/gfapi/glfsxmp-coverage.c
new file mode 100644
index 00000000000..51650023efd
--- /dev/null
+++ b/tests/basic/gfapi/glfsxmp-coverage.c
@@ -0,0 +1,1900 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <string.h>
+#include <time.h>
+
+#define TEST_STR_LEN 2048
+
+int
+test_dirops(glfs_t *fs)
+{
+    glfs_fd_t *fd = NULL;
+    char buf[2048];
+    struct dirent *entry = NULL;
+
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "Entries:\n");
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        fprintf(stderr, "%s: %lu\n", entry->d_name, glfs_telldir(fd));
+    }
+
+    /* Should internally call fsyncdir(), hopefully */
+    glfs_fsync(fd, NULL, NULL);
+
+    glfs_closedir(fd);
+    return 0;
+}
+
+int
+test_xattr(glfs_t *fs)
+{
+    char *filename = "/filename2";
+    char *linkfile = "/linkfile";
+    glfs_fd_t *fd = NULL;
+    char buf[512];
+    char *ptr;
+    int ret;
+
+    ret = glfs_setxattr(fs, filename, "user.testkey", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_setxattr(fs, filename, "user.testkey2", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_getxattr(fs, filename, "user.testkey", buf, 512);
+    fprintf(stderr, "getxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_listxattr(fs, filename, buf, 512);
+    fprintf(stderr, "listxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_symlink(fs, "filename", linkfile);
+    fprintf(stderr, "symlink(%s %s): %s\n", filename, linkfile,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_readlink(fs, linkfile, buf, 512);
+    fprintf(stderr, "readlink(%s) : %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_lsetxattr(fs, filename, "user.testkey3", "testval", 8, 0);
+    fprintf(stderr, "lsetxattr(%s) : %d (%s)\n", linkfile, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_llistxattr(fs, linkfile, buf, 512);
+    fprintf(stderr, "llistxattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    ret = glfs_lgetxattr(fs, filename, "user.testkey3", buf, 512);
+    fprintf(stderr, "lgetxattr(%s): %d (%s)\n", linkfile, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    for (ptr = buf; ptr < buf + ret; ptr++) {
+        printf("key=%s\n", ptr);
+        ptr += strlen(ptr);
+    }
+
+    ret = glfs_removexattr(fs, filename, "user.testkey2");
+    fprintf(stderr, "removexattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+
+    fd = glfs_open(fs, filename, O_RDWR);
+    fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    ret = glfs_fsetxattr(fd, "user.testkey2", "testval", 8, 0);
+    fprintf(stderr, "fsetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_fgetxattr(fd, "user.testkey2", buf, 512);
+    fprintf(stderr, "fgetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_flistxattr(fd, buf, 512);
+    fprintf(stderr, "flistxattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+    if (ret < 0)
+        return -1;
+
+    for (ptr = buf; ptr < buf + ret; ptr++) {
+        printf("key=%s\n", ptr);
+        ptr += strlen(ptr);
+    }
+
+    ret = glfs_fremovexattr(fd, "user.testkey2");
+    fprintf(stderr, "fremovexattr(%s): %d (%s)\n", filename, ret,
+            strerror(errno));
+
+    glfs_close(fd);
+
+    return 0;
+}
+
+int
+test_chdir(glfs_t *fs)
+{
+    int ret = -1;
+    char *dir = "/dir";
+    char *topdir = "/topdir";
+    char *linkdir = "/linkdir";
+    char *linkdir2 = "/linkdir2";
+    char *subdir = "./subdir";
+    char *respath = NULL;
+    char pathbuf[4096];
+
+    ret = glfs_mkdir(fs, topdir, 0755);
+    fprintf(stderr, "mkdir(%s): %s\n", topdir, strerror(errno));
+    if (ret)
+        return -1;
+
+    ret = glfs_mkdir(fs, dir, 0755);
+    fprintf(stderr, "mkdir(%s): %s\n", dir, strerror(errno));
+    if (ret)
+        return -1;
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    ret = glfs_symlink(fs, "topdir", linkdir);
+    if (ret) {
+        fprintf(stderr, "symlink(%s, %s): %s\n", topdir, linkdir,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_chdir(fs, linkdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", linkdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (respath) {
+        fprintf(stderr, "realpath(%s) worked unexpectedly: %s\n", subdir,
+                respath);
+        return -1;
+    }
+
+    ret = glfs_mkdir(fs, subdir, 0755);
+    if (ret) {
+        fprintf(stderr, "mkdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(%s): %s\n", subdir, strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(%s) = %s\n", subdir, respath);
+    }
+
+    ret = glfs_chdir(fs, subdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, "/linkdir/subdir", pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(/linkdir/subdir): %s\n", strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(/linkdir/subdir) = %s\n", respath);
+    }
+
+    return 0;
+}
+
+#ifdef DEBUG
+static void
+peek_stat(struct stat *sb)
+{
+    printf("Dumping stat information:\n");
+    printf("File type:                ");
+
+    switch (sb->st_mode & S_IFMT) {
+        case S_IFBLK:
+            printf("block device\n");
+            break;
+        case S_IFCHR:
+            printf("character device\n");
+            break;
+        case S_IFDIR:
+            printf("directory\n");
+            break;
+        case S_IFIFO:
+            printf("FIFO/pipe\n");
+            break;
+        case S_IFLNK:
+            printf("symlink\n");
+            break;
+        case S_IFREG:
+            printf("regular file\n");
+            break;
+        case S_IFSOCK:
+            printf("socket\n");
+            break;
+        default:
+            printf("unknown?\n");
+            break;
+    }
+
+    printf("I-node number:            %ld\n", (long)sb->st_ino);
+
+    printf("Mode:                     %lo (octal)\n",
+           (unsigned long)sb->st_mode);
+
+    printf("Link count:               %ld\n", (long)sb->st_nlink);
+    printf("Ownership:                UID=%ld   GID=%ld\n", (long)sb->st_uid,
+           (long)sb->st_gid);
+
+    printf("Preferred I/O block size: %ld bytes\n", (long)sb->st_blksize);
+    printf("File size:                %lld bytes\n", (long long)sb->st_size);
+    printf("Blocks allocated:         %lld\n", (long long)sb->st_blocks);
+
+    printf("Last status change:       %s", ctime(&sb->st_ctime));
+    printf("Last file access:         %s", ctime(&sb->st_atime));
+    printf("Last file modification:   %s", ctime(&sb->st_mtime));
+
+    return;
+}
+
+static void
+peek_handle(unsigned char *glid)
+{
+    int i;
+
+    for (i = 0; i < GFAPI_HANDLE_LENGTH; i++) {
+        printf(":%02x:", glid[i]);
+    }
+    printf("\n");
+}
+#else  /* DEBUG */
+static void
+peek_stat(struct stat *sb)
+{
+    return;
+}
+
+static void
+peek_handle(unsigned char *id)
+{
+    return;
+}
+#endif /* DEBUG */
+
+glfs_t *fs = NULL;
+char *full_parent_name = "/testdir", *parent_name = "testdir";
+
+void
+test_h_unlink(void)
+{
+    char *my_dir = "unlinkdir";
+    char *my_file = "file.txt";
+    char *my_subdir = "dir1";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
+                       *subdir = NULL, *subleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_unlink tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subdir = glfs_h_mkdir(fs, dir, my_subdir, 0755, &sb);
+    if (subdir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subleaf = glfs_h_creat(fs, subdir, my_file, O_CREAT, 0644, &sb);
+    if (subleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non empty directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
+                my_subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, subdir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s: invalid errno "
+                ",%d, %s\n",
+                my_file, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s:  invalid "
+                "errno ,%d, %s\n",
+                my_subdir, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, parent, my_dir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_dir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_unlink tests: PASSED\n");
+
+out:
+    if (dir)
+        glfs_h_close(dir);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (subdir)
+        glfs_h_close(subdir);
+    if (subleaf)
+        glfs_h_close(subleaf);
+    if (parent)
+        glfs_h_close(parent);
+
+    return;
+}
+
+void
+test_h_getsetattrs(void)
+{
+    char *my_dir = "attrdir";
+    char *my_file = "attrfile.txt";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb, retsb;
+    int ret, valid;
+    struct timespec timestamp;
+
+    printf("glfs_h_getattrs and setattrs tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_getattrs(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+    /* TODO: Compare stat information */
+
+    retsb.st_mode = 00666;
+    retsb.st_uid = 1000;
+    retsb.st_gid = 1001;
+    ret = clock_gettime(CLOCK_REALTIME, &timestamp);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    retsb.st_atim = timestamp;
+    retsb.st_mtim = timestamp;
+    valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
+            GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
+    peek_stat(&retsb);
+
+    ret = glfs_h_setattrs(fs, dir, &retsb, valid);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_setattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    memset(&retsb, 0, sizeof(struct stat));
+    ret = glfs_h_stat(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_stat: error %s: from (%p),%s\n", my_dir, dir,
+                strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+
+    printf("glfs_h_getattrs and setattrs tests: PASSED\n");
+out:
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dir)
+        glfs_h_close(dir);
+
+    return;
+}
+
+void
+test_h_truncate(void)
+{
+    char *my_dir = "truncatedir";
+    char *my_file = "file.txt";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
+    struct stat sb;
+    glfs_fd_t *fd = NULL;
+    char buf[32];
+    off_t offset = 0;
+    int ret = 0;
+
+    printf("glfs_h_truncate tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n", my_file,
+                strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    memcpy(buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, buf, 32, 0);
+
+    /* run tests */
+    /* truncate lower */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate higher */
+    offset = 32;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate equal */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_truncate tests: PASSED\n");
+out:
+    if (fd)
+        glfs_close(fd);
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return;
+}
+
+void
+test_h_links(void)
+{
+    char *my_dir = "linkdir";
+    char *my_file = "file.txt";
+    char *my_symlnk = "slnk.txt";
+    char *my_lnk = "lnk.txt";
+    char *linksrc_dir = "dir1";
+    char *linktgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct glfs_object *ln1 = NULL;
+    struct stat sb;
+    int ret;
+    char *buf = NULL;
+
+    printf("glfs_h_link(s) tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, linksrc_dir, 0755, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linksrc_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, linktgt_dir, 0755, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linktgt_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
+    ln1 = glfs_h_symlink(fs, parent, my_symlnk, "./file.txt", &sb);
+    if (ln1 == NULL) {
+        fprintf(stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
+                my_symlnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    buf = calloc(1024, sizeof(char));
+    if (buf == NULL) {
+        fprintf(stderr, "Error allocating memory\n");
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    ret = glfs_h_readlink(fs, ln1, buf, 1024);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
+                my_symlnk, ln1, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    if (!(strncmp(buf, my_symlnk, strlen(my_symlnk)))) {
+        fprintf(stderr,
+                "glfs_h_readlink: error mismatch in link name: actual %s: "
+                "retrieved %s\n",
+                my_symlnk, buf);
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    /* link: /testdir/linkdir/file.txt to ./lnk.txt */
+    ret = glfs_h_link(fs, leaf, parent, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
+    ret = glfs_h_link(fs, dleaf, dirtgt, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, dirtgt, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    printf("glfs_h_link(s) tests: PASSED\n");
+
+out:
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+    if (ln1)
+        glfs_h_close(ln1);
+    if (buf)
+        free(buf);
+
+    return;
+}
+
+void
+test_h_rename(void)
+{
+    char *my_dir = "renamedir";
+    char *my_file = "file.txt";
+    char *src_dir = "dir1";
+    char *tgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_rename tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, src_dir, 0755, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                src_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, tgt_dir, 0755, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                tgt_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* Rename file.txt -> file1.txt */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "file1.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file1.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1/file.txt -> file.txt */
+    ret = glfs_h_rename(fs, dirsrc, "file.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
+                src_dir, "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file1.txt -> file.txt (exists) */
+    ret = glfs_h_rename(fs, parent, "file1.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1 -> dir3 */
+    ret = glfs_h_rename(fs, parent, "dir1", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir1",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir2 ->dir3 (exists) */
+    ret = glfs_h_rename(fs, parent, "dir2", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir2",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file.txt -> dir3 (fail) */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "dir3");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "file.txt", "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir3 -> file.txt (fail) */
+    ret = glfs_h_rename(fs, parent, "dir3", parent, "file.txt");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "dir3", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_rename tests: PASSED\n");
+
+out:
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+
+    return;
+}
+
+void
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
+{
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
+}
+
+#define MAX_FILES_CREATE 10
+#define MAXPATHNAME 512
+void
+test_h_performance(void)
+{
+    char *my_dir = "perftest", *full_dir_path = "/testdir/perftest";
+    char *my_file = "file_", my_file_name[MAXPATHNAME];
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb;
+    int ret, i;
+    struct glfs_fd *fd;
+    struct timespec c_ts = {0, 0}, c_ts_st, c_ts_ed;
+    struct timespec o_ts = {0, 0}, o_ts_st, o_ts_ed;
+
+    printf("glfs_h_performance tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* create performance */
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        leaf = glfs_h_lookupat(fs, dir, my_file_name, &sb, 0);
+        if (leaf != NULL) {
+            fprintf(stderr, "glfs_h_lookup: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
+        }
+
+        leaf = glfs_h_creat(fs, dir, my_file_name, O_CREAT, 0644, &sb);
+        if (leaf == NULL) {
+            fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
+        }
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_h_close(leaf);
+        leaf = NULL;
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (handle based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
+
+    /* create using path */
+    c_ts.tv_sec = o_ts.tv_sec = 0;
+    c_ts.tv_nsec = o_ts.tv_nsec = 0;
+
+    sprintf(my_file_name, "%s1", full_dir_path);
+    ret = glfs_mkdir(fs, my_file_name, 0755);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_mkdir: error creating %s: from (%p),%s\n", my_dir,
+                parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        ret = glfs_stat(fs, my_file_name, &sb);
+        if (ret == 0) {
+            fprintf(stderr, "glfs_stat: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
+        }
+
+        fd = glfs_creat(fs, my_file_name, O_CREAT, 0644);
+        if (fd == NULL) {
+            fprintf(stderr, "glfs_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
+        }
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_close(fd);
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (path based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
+out:
+    return;
+}
+
+int
+test_handleops(int argc, char *argv[])
+{
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL, *tmp = NULL;
+    char readbuf[32], writebuf[32];
+    unsigned char leaf_handle[GFAPI_HANDLE_LENGTH];
+
+    char *full_leaf_name = "/testdir/testfile.txt", *leaf_name = "testfile.txt",
+         *relative_leaf_name = "testdir/testfile.txt";
+    char *leaf_name1 = "testfile1.txt";
+    char *full_newparent_name = "/testdir/dir1", *newparent_name = "dir1";
+    char *full_newnod_name = "/testdir/nod1", *newnod_name = "nod1";
+
+    /* Initialize test area */
+    ret = glfs_mkdir(fs, full_parent_name, 0755);
+    if (ret != 0 && errno != EEXIST) {
+        fprintf(stderr, "%s: (%p) %s\n", full_parent_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    } else if (ret != 0) {
+        printf("Found test directory %s to be existing\n", full_parent_name);
+        printf("Cleanup test directory and restart tests\n");
+        goto out;
+    }
+
+    fd = glfs_creat(fs, full_leaf_name, O_CREAT, 0644);
+    if (fd == NULL) {
+        fprintf(stderr, "%s: (%p) %s\n", full_leaf_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    }
+    glfs_close(fd);
+
+    printf("Initialized the test area, within volume %s\n", argv[1]);
+
+    /* Handle based APIs test area */
+
+    /* glfs_lookupat test */
+    printf("glfs_h_lookupat tests: In Progress\n");
+    /* start at root of the volume */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a parent within root */
+    parent = glfs_h_lookupat(fs, root, parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a leaf/child within the parent */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check absolute paths */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_lookupat(fs, NULL, full_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    /* check multiple component paths */
+    leaf = glfs_h_lookupat(fs, root, relative_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                relative_leaf_name, parent, strerror(errno));
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check symlinks in path */
+
+    /* TODO: -ve test cases */
+    /* parent invalid
+     * path invalid
+     * path does not exist after some components
+     * no parent, but relative path
+     * parent and full path? -ve?
+     */
+
+    printf("glfs_h_lookupat tests: PASSED\n");
+
+    /* glfs_openat test */
+    printf("glfs_h_open tests: In Progress\n");
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 10, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", readbuf, writebuf);
+        glfs_close(fd);
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_close(fd);
+
+    printf("glfs_h_open tests: PASSED\n");
+
+    /* Create tests */
+    printf("glfs_h_creat tests: In Progress\n");
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_creat: existing file, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    tmp = glfs_h_creat(fs, root, parent_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
+        fprintf(stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (tmp != NULL) {
+            glfs_h_close(tmp);
+            tmp = NULL;
+        }
+    }
+
+    /* TODO: Other combinations and -ve cases as applicable */
+    printf("glfs_h_creat tests: PASSED\n");
+
+    /* extract handle and create from handle test */
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: In "
+        "Progress\n");
+    /* TODO: Change the lookup to create below for a GIFD recovery failure,
+     * that needs to be fixed */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name1, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_extract_handle(leaf, leaf_handle, GFAPI_HANDLE_LENGTH);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_handle(leaf_handle);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_create_from_handle(fs, leaf_handle, GFAPI_HANDLE_LENGTH, &sb);
+    if (leaf == NULL) {
+        fprintf(
+            stderr,
+            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+            leaf_name1, leaf_handle, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 0, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", writebuf, writebuf);
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        glfs_close(fd);
+        goto out;
+    }
+
+    glfs_close(fd);
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
+
+    /* Mkdir tests */
+    printf("glfs_h_mkdir tests: In Progress\n");
+
+    ret = glfs_rmdir(fs, full_newparent_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_rmdir: Failed for %s: %s\n", full_newparent_name,
+                strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newparent_name, parent, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mkdir tests: PASSED\n");
+
+    /* Mknod tests */
+    printf("glfs_h_mknod tests: In Progress\n");
+    ret = glfs_unlink(fs, full_newnod_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_unlink: Failed for %s: %s\n", full_newnod_name,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, S_IFIFO, 0, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newnod_name, parent, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* TODO: create op on a FIFO node hangs, need to check and fix
+    tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || errno != EINVAL) {
+            fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno =
+    %s\n", tmp, strerror (errno)); printf ("glfs_h_creat/mknod tests:
+    FAILED\n"); if (tmp != NULL) { glfs_h_close(tmp); tmp = NULL;
+            }
+    } */
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, 0644, 0, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mknod tests: PASSED\n");
+
+    /* unlink tests */
+    test_h_unlink();
+
+    /* TODO: opendir tests */
+
+    /* getattr tests */
+    test_h_getsetattrs();
+
+    /* TODO: setattr tests */
+
+    /* truncate tests */
+    test_h_truncate();
+
+    /* link tests */
+    test_h_links();
+
+    /* rename tests */
+    test_h_rename();
+
+    /* performance tests */
+    test_h_performance();
+
+    /* END: New APIs test area */
+
+out:
+    /* Cleanup glfs handles */
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return ret;
+}
+
+int
+test_write_apis(glfs_t *fs)
+{
+    /* Add more content here */
+    /* Some apis we can get are */
+    /*
+      0. glfs_set_xlator_option()
+
+      Read/Write combinations:
+      . glfs_{p,}readv/{p,}writev
+      . glfs_pread/pwrite
+
+      tests/basic/gfapi/gfapi-async-calls-test.c
+      . glfs_read_async/write_async
+      . glfs_pread_async/pwrite_async
+      . glfs_readv_async/writev_async
+      . glfs_preadv_async/pwritev_async
+
+      . ftruncate/ftruncate_async
+      . fsync/fsync_async
+      . fdatasync/fdatasync_async
+
+    */
+
+    glfs_fd_t *fd = NULL;
+    char *filename = "/filename2";
+    int flags = O_RDWR;
+    char *buf = "some bytes!";
+    char writestr[TEST_STR_LEN];
+    struct iovec iov = {&writestr, TEST_STR_LEN};
+    int ret, i;
+
+    for (i = 0; i < TEST_STR_LEN; i++)
+        writestr[i] = 0x11;
+
+    fd = glfs_open(fs, filename, flags);
+    if (!fd)
+        fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    ret = glfs_writev(fd, &iov, 1, flags);
+    if (ret < 0) {
+        fprintf(stderr, "writev(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    ret = glfs_pwrite(fd, buf, 10, 4, flags, NULL, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "pwrite(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    ret = glfs_pwritev(fd, &iov, 1, 4, flags);
+    if (ret < 0) {
+        fprintf(stderr, "pwritev(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    ret = glfs_fsync(fd, NULL, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "fsync(%s): %d (%s)\n", filename, ret, strerror(errno));
+    }
+
+    glfs_close(fd);
+
+    return 0;
+}
+
+int
+test_metadata_ops(glfs_t *fs, glfs_t *fs2)
+{
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_stat gsb = {
+        0,
+    };
+    struct statvfs sfs;
+    char readbuf[32];
+    char writebuf[11] = "helloworld";
+
+    char *filename = "/filename2";
+    int ret;
+
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
+
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    if (!fd)
+        fprintf(stderr, "creat(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    fd2 = glfs_open(fs2, filename, O_RDWR);
+    if (!fd2)
+        fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
+
+    ret = glfs_lstat(fs, filename, &sb);
+    if (ret)
+        fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
+
+    ret = glfs_write(fd, writebuf, 11, 0);
+    if (ret < 0) {
+        fprintf(stderr, "writev(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+    }
+
+    glfs_fsync(fd, NULL, NULL);
+
+    glfs_lseek(fd2, 5, SEEK_SET);
+
+    ret = glfs_read(fd2, readbuf, 32, 0);
+
+    printf("read %d, %s", ret, readbuf);
+
+    /* get stat */
+    ret = glfs_fstat(fd2, &sb);
+    if (ret)
+        fprintf(stderr, "fstat(%s): %d (%s)\n", filename, ret, strerror(errno));
+
+    ret = glfs_access(fs, filename, R_OK);
+    if (ret)
+        fprintf(stderr, "access(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+
+    ret = glfs_fallocate(fd2, 1024, 1024, 1024);
+    if (ret)
+        fprintf(stderr, "fallocate(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+
+    ret = glfs_discard(fd2, 1024, 512);
+    if (ret)
+        fprintf(stderr, "discard(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+
+    ret = glfs_zerofill(fd2, 2048, 1024);
+    if (ret)
+        fprintf(stderr, "zerofill(%s): %d (%s)\n", filename, ret,
+                strerror(errno));
+
+    /* set stat */
+    /* TODO: got some errors, need to fix */
+    ret = glfs_fsetattr(fd2, &gsb);
+
+    glfs_close(fd);
+    glfs_close(fd2);
+
+    filename = "/filename3";
+    ret = glfs_mknod(fs, filename, S_IFIFO, 0);
+    if (ret)
+        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
+
+    ret = glfs_lstat(fs, filename, &sb);
+    if (ret)
+        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
+
+    ret = glfs_rename(fs, filename, "/filename4");
+    if (ret)
+        fprintf(stderr, "rename(%s): (%d) %s\n", filename, ret,
+                strerror(errno));
+
+    ret = glfs_unlink(fs, "/filename4");
+    if (ret)
+        fprintf(stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
+                strerror(errno));
+
+    filename = "/dirname2";
+    ret = glfs_mkdir(fs, filename, 0);
+    if (ret)
+        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
+
+    ret = glfs_lstat(fs, filename, &sb);
+    if (ret)
+        fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
+
+    ret = glfs_rmdir(fs, filename);
+    if (ret)
+        fprintf(stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror(errno));
+}
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs2 = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_stat gsb = {
+        0,
+    };
+    struct statvfs sfs;
+    char readbuf[32];
+    char writebuf[32];
+    char volumeid[64];
+
+    char *filename = "/filename2";
+
+    if ((argc < 2) || (argc > 3)) {
+        printf("Usage:\n\t%s <volname> <hostname>\n\t%s <volfile-path>",
+               argv[0], argv[0]);
+        return -1;
+    }
+
+    if (argc == 2) {
+        /* Generally glfs_new() requires volume name as an argument */
+        fs = glfs_new("test-only");
+        if (!fs) {
+            fprintf(stderr, "glfs_new: returned NULL\n");
+            return 1;
+        }
+        ret = glfs_set_volfile(fs, argv[1]);
+        if (ret)
+            fprintf(stderr, "glfs_set_volfile failed\n");
+    } else {
+        fs = glfs_new(argv[1]);
+        if (!fs) {
+            fprintf(stderr, "glfs_new: returned NULL\n");
+            return 1;
+        }
+        // ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
+        ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
+        if (ret)
+            fprintf(stderr, "glfs_set_volfile_server failed\n");
+    }
+
+    /* Change this to relevant file when running locally */
+    ret = glfs_set_logging(fs, "/dev/stderr", 5);
+    if (ret)
+        fprintf(stderr, "glfs_set_logging failed\n");
+
+    ret = glfs_init(fs);
+    if (ret)
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+
+    if (ret)
+        goto out;
+
+    /* no major use for getting the volume id in this test, done for coverage */
+    ret = glfs_get_volumeid(fs, volumeid, 64);
+    if (ret) {
+        fprintf(stderr, "glfs_get_volumeid: returned %d\n", ret);
+    }
+
+    sleep(2);
+
+    if (argc == 2) {
+        /* Generally glfs_new() requires volume name as an argument */
+        fs2 = glfs_new("test_only_volume");
+        if (!fs2) {
+            fprintf(stderr, "glfs_new(fs2): returned NULL\n");
+            return 1;
+        }
+        ret = glfs_set_volfile(fs2, argv[1]);
+        if (ret)
+            fprintf(stderr, "glfs_set_volfile failed(fs2)\n");
+    } else {
+        fs2 = glfs_new(argv[1]);
+        if (!fs2) {
+            fprintf(stderr, "glfs_new(fs2): returned NULL\n");
+            return 1;
+        }
+        ret = glfs_set_volfile_server(fs2, "tcp", argv[2], 24007);
+        if (ret)
+            fprintf(stderr, "glfs_set_volfile_server failed(fs2)\n");
+    }
+
+    ret = glfs_set_statedump_path(fs2, "/tmp");
+    if (ret) {
+        fprintf(stderr, "glfs_set_statedump_path: %s\n", strerror(errno));
+    }
+
+    ret = glfs_init(fs2);
+    if (ret)
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+
+    test_metadata_ops(fs, fs2);
+
+    test_dirops(fs);
+
+    test_xattr(fs);
+
+    test_chdir(fs);
+
+    test_handleops(argc, argv);
+    // done
+
+    /* Test some extra apis */
+    test_write_apis(fs);
+
+    glfs_statvfs(fs, "/", &sfs);
+
+    glfs_unset_volfile_server(fs, "tcp", argv[2], 24007);
+
+    glfs_fini(fs);
+    glfs_fini(fs2);
+
+    ret = 0;
+out:
+    return ret;
+}
diff --git a/tests/basic/gfapi/glfsxmp.t b/tests/basic/gfapi/glfsxmp.t
new file mode 100644
index 00000000000..b3e6645c0f5
--- /dev/null
+++ b/tests/basic/gfapi/glfsxmp.t
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0,1,2}
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+$CLI system getspec $V0 > fubar.vol
+
+TEST cp $(dirname $0)/glfsxmp-coverage.c ./glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+
+TEST ./glfsxmp fubar.vol
+
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/basic/gfapi/libgfapi-fini-hang.c b/tests/basic/gfapi/libgfapi-fini-hang.c
index e192751f295..37800e3188b 100644
--- a/tests/basic/gfapi/libgfapi-fini-hang.c
+++ b/tests/basic/gfapi/libgfapi-fini-hang.c
@@ -8,56 +8,55 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d\n", func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-} while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d\n", func, ret);            \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i;
-        glfs_fd_t *fd = NULL;
-        char       readbuf[32];
-        char      *logname = NULL;
-        char      *hostname = NULL;
-        char      *volname = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-
-        if (argc < 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logname = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                exit(1);
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 0);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logname, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        /* Do not call glfs_init.
-         * glfs_fini() shouldn't hang in that case*/
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-        fprintf (stderr, "End of libgfapi_fini\n");
-
-        exit(0);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char readbuf[32];
+    char *logname = NULL;
+    char *hostname = NULL;
+    char *volname = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+
+    if (argc < 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logname = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        exit(1);
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 0);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logname, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    /* Do not call glfs_init.
+     * glfs_fini() shouldn't hang in that case*/
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
+    fprintf(stderr, "End of libgfapi_fini\n");
+
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/mandatory-lock-optimal.c b/tests/basic/gfapi/mandatory-lock-optimal.c
new file mode 100644
index 00000000000..34fef8d0b80
--- /dev/null
+++ b/tests/basic/gfapi/mandatory-lock-optimal.c
@@ -0,0 +1,532 @@
+/* Pre-requisites:-
+ *
+ * 1. Make sure that performance translators are switched off while running this
+ * test.
+ * 2. Perform the following volume set operation:
+ *    # gluster volume set <VOLNAME> locks.mandatory-locking optimal
+ * 3. For installation under non-standard paths, export LD_LIBRARY_PATH to
+ *    automatically load exact libgfapi.so and compile this C file as follows:
+ *    $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L
+ * <include path for libgfapi shared library>
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <glusterfs/api/glfs.h>
+
+#define TOTAL_TEST_COUNT 8
+
+/* C1 = Client 1 : C2 = Client 2 : C3 = Client 3 :
+ * fs1, fd1 are associated with C1. Similarly fs2, fd2 for C2
+ * and fs3, fd3 for C3 */
+
+FILE *fp;
+glfs_t *fs1, *fs2, *fs3;
+glfs_fd_t *fd, *fd1, *fd2, *fd3;
+struct flock lock;
+char buf1[10], *buf2 = "ten bytes!", *fname = "/mand.lock";
+int ret, test_count;
+off_t offset;
+
+/* run_test_1 ()   : C1 takes byte range mandatory read lock.
+                     C2 attempts to read from a conflicting range.
+   Expected result : Read from C2 should pass.
+
+ * run_test_2 ()   : C1 takes byte range mandatory read lock.
+                     C2 attempts write to a conflicting range.
+   Expected result : Write from C2 should fail with EAGAIN.
+
+ * run_test_3 ()   : C1 takes byte range advisory write lock.
+                     C2 attempts to read from a conflicting range.
+   Expected result : Read from C2 should pass.
+
+ * run_test_4 ()   : C1 takes byte range advisory write lock.
+                     C2 attempts write to a conflicting range.
+   Expected result : Write from C2 should pass.
+
+ * run_test_5 ()   : C1 takes byte range advisory read lock.
+                     C2 attempts to open the same file with O_TRUNC.
+   Expected result : Open from C2 should pass.
+
+ * run_test_6 ()   : C1 takes byte range mandatory read lock.
+                     C2 attempts to open the same file with O_TRUNC.
+   Expected result : Open from C2 should fail with EAGAIN.
+
+ * run_test_7 ()   : C1 takes byte range mandatory read lock.
+                     C2 attempts ftruncate on a conflicting range.
+   Expected result : Write from C2 should fail with EAGAIN.
+
+ * run_test_8 ()   : C1 takes byte range advisory read lock.
+                     C2 takes byte range mandatory read lock
+                     within the byte range for which C1 already
+                     holds an advisory lock so as to perform a
+                     basic split/merge. C3 repositions fd3 to
+                     start of C2's byte range mandatory lock
+                     offset and attempts a write. Then it again
+                     repositions fd3 to one byte past C2's byte
+                     range mandatoy lock and again attempts a write.
+   Expected result : First write should fail with EAGAIN.
+                     Second write should pass. */
+
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!fp)                                                               \
+            fprintf(stderr, "\n%s : returned error (%s)\n", func,              \
+                    strerror(err));                                            \
+        else                                                                   \
+            fprintf(fp, "\n%s : returned error (%s)\n", func, strerror(err));  \
+        cleanup_and_exit(err);                                                 \
+    } while (0)
+
+void
+cleanup_and_exit(int exit_status)
+{
+    if (exit_status || test_count != TOTAL_TEST_COUNT) {
+        fprintf(fp, "\nAborting due to some test failures.\n");
+        exit_status = 1;
+    } else
+        fprintf(fp, "\nAll tests ran successfully.\n");
+    if (fp)
+        fclose(fp);
+    if (fd)
+        glfs_close(fd);
+    if (fd1)
+        glfs_close(fd1);
+    if (fd2)
+        glfs_close(fd2);
+
+    glfs_unlink(fs1, fname);
+
+    if (fs1)
+        glfs_fini(fs1);
+    if (fs2)
+        glfs_fini(fs2);
+
+    exit(exit_status);
+}
+
+glfs_t *
+new_client_create(char *hostname, char *volname, char *logfile_name)
+{
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs)
+        LOG_ERR("glfs_new", errno);
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret)
+        LOG_ERR("glfs_set_volfile_server", errno);
+
+    ret = glfs_set_logging(fs, logfile_name, 7);
+    if (ret)
+        LOG_ERR("glfs_set_logging", errno);
+
+    ret = glfs_init(fs);
+    if (ret)
+        LOG_ERR("glfs_init", errno);
+
+    return fs;
+}
+
+void
+run_test_1(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* On successful read, 0 is returned as there is no content inside the
+     * file
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_2(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_3(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* Still there is no content inside file. So following read should
+     * return 0
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_4(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_5(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_6(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (fd2)
+        LOG_ERR("glfs_open", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_7(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDWR | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    ret = glfs_ftruncate(fd2, 4, NULL, NULL);
+    if (ret == 0 || errno != EAGAIN)
+        LOG_ERR("glfs_ftruncate", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+void
+run_test_8(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 10L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 5L;
+    lock.l_len = 2L;
+
+    ret = glfs_file_lock(fd2, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd3 = glfs_open(fs3, fname, O_RDWR | O_NONBLOCK);
+    if (!fd3)
+        LOG_ERR("glfs_open", errno);
+
+    offset = glfs_lseek(fd3, 5L, SEEK_SET);
+    if (offset != 5)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
+
+    offset = glfs_lseek(fd3, 8L, SEEK_SET);
+    if (offset != 8)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    ret = glfs_close(fd3);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd3 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
+}
+
+int
+main(int argc, char *argv[])
+{
+    char logfile[50];
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Usage: %s <server ip/hostname> <volume name> <test log "
+                "directory>\n",
+                argv[0]);
+        return 0;
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log");
+    fp = fopen(logfile, "w");
+    if (!fp) {
+        fprintf(stderr, "\n%s\n", logfile);
+        LOG_ERR("Log file creation", errno);
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-1.log");
+    fs1 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs1)
+        LOG_ERR("client-1 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-2.log");
+    fs2 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs2)
+        LOG_ERR("client-2 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-3.log");
+    fs3 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs3)
+        LOG_ERR("client-3 creation", EINVAL);
+
+    fd = glfs_creat(fs1, fname, O_RDWR, 0644);
+    if (!fd)
+        LOG_ERR("glfs_creat", errno);
+
+    test_count = 0;
+
+    run_test_1(1);
+    run_test_2(2);
+    run_test_3(3);
+    run_test_4(4);
+    run_test_5(5);
+    run_test_6(6);
+    run_test_7(7);
+    run_test_8(8);
+
+    cleanup_and_exit(0);
+
+    return 0;
+}
diff --git a/tests/basic/gfapi/mandatory-lock-optimal.t b/tests/basic/gfapi/mandatory-lock-optimal.t
new file mode 100644
index 00000000000..27062e1f6c2
--- /dev/null
+++ b/tests/basic/gfapi/mandatory-lock-optimal.t
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+TEST glusterd
+
+# Create and start the volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+TEST $CLI volume start $V0
+
+logdir=`gluster --print-logdir`
+
+# Switch off performance translators
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.readdir-ahead off
+
+# Enable optimal mandatory-locking mode and restart the volume
+TEST $CLI volume set $V0 locks.mandatory-locking optimal
+TEST $CLI volume stop $V0
+TEST $CLI volume start $V0
+
+# Compile and run the test program
+TEST build_tester $(dirname $0)/mandatory-lock-optimal.c -lgfapi
+TEST ./$(dirname $0)/mandatory-lock-optimal $H0 $V0 $logdir
+
+# Cleanup the environment
+cleanup_tester $(dirname $0)/mandatory-lock-optimal
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/basic/gfapi/protocol-client-ssl.vol.in b/tests/basic/gfapi/protocol-client-ssl.vol.in
new file mode 100644
index 00000000000..cdc0c9d0671
--- /dev/null
+++ b/tests/basic/gfapi/protocol-client-ssl.vol.in
@@ -0,0 +1,15 @@
+#
+# This .vol file expects that there is
+#
+#  1. GlusterD listening on @@HOSTNAME@@
+#  2. a volume that provides a brick on @@BRICKPATH@@
+#  3. the volume with the brick has been started
+#
+volume test
+    type protocol/client
+    option remote-host @@HOSTNAME@@
+    option remote-subvolume @@BRICKPATH@@
+    option transport-type socket
+    option transport.socket.ssl-enabled @@SSL@@
+end-volume
+
diff --git a/tests/basic/gfapi/seek.c b/tests/basic/gfapi/seek.c
index fb2f6361bf3..85ea9b88141 100644
--- a/tests/basic/gfapi/seek.c
+++ b/tests/basic/gfapi/seek.c
@@ -18,80 +18,82 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        glfs_t      *fs       = NULL;
-        int          ret      = 0;
-        glfs_fd_t   *fd       = NULL;
-        char        *filename = NULL;
-        char        *volname  = NULL;
-        char        *hostname = NULL;
-        struct stat  st       = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
-                                 argv[0]);
-                exit (1);
+    glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
+                argv[0]);
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    filename = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        perror("glfs_new() returned NULL");
+        return 1;
+    }
+
+    if (glfs_set_volfile_server(fs, "tcp", hostname, 24007)) {
+        perror("glfs_set_volfile_server");
+        return 1;
+    }
+
+    if (glfs_init(fs)) {
+        perror("glfs_init");
+        return 1;
+    }
+
+    fd = glfs_open(fs, filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("glfs_open");
+        return 1;
+    }
+
+    if (glfs_fstat(fd, &st)) {
+        perror("glfs_fstat");
+        return 1;
+    }
+
+    while (hole_end < st.st_size) {
+        hole_start = glfs_lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO)
+            /* no more holes */
+            break;
+        if (hole_start == -1) {
+            perror("no more holes");
+            break;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        filename = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                perror ("glfs_new() returned NULL");
-                return 1;
-        }
-
-        if (glfs_set_volfile_server (fs, "tcp", hostname, 24007)) {
-                perror ("glfs_set_volfile_server");
-                return 1;
+        hole_end = glfs_lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
         }
 
-        if (glfs_init (fs)) {
-                perror ("glfs_init");
-                return 1;
-        }
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
 
-        fd = glfs_open (fs, filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("glfs_open");
-                return 1;
-        }
+    glfs_close(fd);
 
-        if (glfs_fstat (fd, &st)) {
-                perror ("glfs_fstat");
-                return 1;
-        }
-
-        while (hole_end < st.st_size) {
-                hole_start = glfs_lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO)
-                        /* no more holes */
-                        break;
-                if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
-
-                hole_end = glfs_lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                }
-
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
-        }
-
-        glfs_close (fd);
-
-        if (fs) {
-                glfs_fini (fs);
-        }
+    if (fs) {
+        glfs_fini(fs);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/upcall-cache-invalidate.c b/tests/basic/gfapi/upcall-cache-invalidate.c
index 9add3381278..078286a8956 100644
--- a/tests/basic/gfapi/upcall-cache-invalidate.c
+++ b/tests/basic/gfapi/upcall-cache-invalidate.c
@@ -9,204 +9,201 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        glfs_t                   *fs2 = NULL;
-        glfs_t                   *fs_tmp = NULL;
-        glfs_t                   *fs_tmp2 = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        glfs_fd_t                *fd2 = NULL;
-        glfs_fd_t                *fd_tmp = NULL;
-        glfs_fd_t                *fd_tmp2 = NULL;
-        char                      readbuf[32];
-        char                     *filename = "file_tmp";
-        char                     *writebuf = NULL;
-        char                     *vol_id  = NULL;
-        unsigned int              cnt = 1;
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        char                     *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *filename = "file_tmp";
+    char *writebuf = NULL;
+    char *vol_id = NULL;
+    unsigned int cnt = 1;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+    fprintf(stderr, "glfs-open fd2 - %d\n", fd2);
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
+                ret = -1;
+                LOG_ERR("glfs_write", ret);
+            } else {
+                fprintf(stderr, "glfs_write succeeded\n");
+            }
+            free(writebuf);
+        } else {
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
         }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
 
-        fs2 = glfs_new (volname);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new fs2: returned NULL\n");
-                return 1;
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
+        } else {
+            fprintf(stderr, "glfs_read: %s\n", readbuf);
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server-fs2", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging-fs2", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init-fs2", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
+        /* Open() fops seem to be not performed on server side until
+         * there are I/Os on that fd
+         */
+        if (cnt > 2) {
+            struct glfs_upcall_inode *in_arg = NULL;
+            enum glfs_upcall_reason reason = 0;
+            struct glfs_object *object = NULL;
+            uint64_t flags = 0;
+            uint64_t expire = 0;
+
+            ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+            LOG_ERR("glfs_h_poll_upcall", ret);
+
+            reason = glfs_upcall_get_reason(cbk);
+
+            /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
+            if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+                in_arg = glfs_upcall_get_event(cbk);
+
+                object = glfs_upcall_inode_get_object(in_arg);
+                flags = glfs_upcall_inode_get_flags(in_arg);
+                expire = glfs_upcall_inode_get_expire(in_arg);
+
+                fprintf(stderr,
+                        " upcall event type - %d,"
+                        " object(%p), flags(%d), "
+                        " expire_time_attr(%d)\n",
+                        reason, object, flags, expire);
+            } else {
+                fprintf(stderr, "Didn't receive upcall notify event");
                 ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
+                goto err;
+            }
 
-        fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open-fs2", ret);
+            glfs_free(cbk);
         }
-        fprintf (stderr, "glfs-open fd2 - %d\n", fd2);
-
-        do {
-                if (cnt%2) {
-                        fd_tmp = fd;
-                        fs_tmp = fs;
-                        fd_tmp2 = fd2;
-                        fs_tmp2 = fs2;
-                } else {
-                        fd_tmp = fd2;
-                        fs_tmp = fs2;
-                        fd_tmp2 = fd;
-                        fs_tmp2 = fs;
-                }
-
-                /* WRITE on fd_tmp */
-                writebuf = malloc(10);
-                if (writebuf) {
-                        memcpy (writebuf, "abcd", 4);
-                        ret = glfs_write (fd_tmp, writebuf, 4, 0);
-                        if (ret <= 0)   {
-                                ret = -1;
-                                LOG_ERR ("glfs_write", ret);
-                        } else {
-                                fprintf (stderr,
-                                         "glfs_write suceeded\n");
-                        }
-                        free(writebuf);
-                } else {
-                        fprintf (stderr,
-                                 "Could not allocate writebuf\n");
-                        return -1;
-                }
-
-                /* READ on fd_tmp2 */
-                ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
-                LOG_ERR ("glfs_lseek", ret);
-
-                memset (readbuf, 0, sizeof(readbuf));
-                ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0);
-
-                if (ret <= 0) {
-                        ret = -1;
-                        LOG_ERR ("glfs_pread", ret);
-                } else {
-                        fprintf (stderr, "glfs_read: %s\n", readbuf);
-                }
-
-                /* Open() fops seem to be not performed on server side until
-                 * there are I/Os on that fd
-                 */
-                if (cnt > 2) {
-                        struct glfs_upcall_inode *in_arg = NULL;
-                        enum glfs_upcall_reason   reason = 0;
-                        struct glfs_object       *object = NULL;
-                        uint64_t                  flags = 0;
-                        uint64_t                  expire = 0;
-
-                        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-                        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                        reason = glfs_upcall_get_reason (cbk);
-
-                        /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
-                        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                                in_arg = glfs_upcall_get_event (cbk);
-
-                                object = glfs_upcall_inode_get_object (in_arg);
-                                flags = glfs_upcall_inode_get_flags (in_arg);
-                                expire = glfs_upcall_inode_get_expire (in_arg);
-
-                                fprintf (stderr, " upcall event type - %d,"
-                                         " object(%p), flags(%d), "
-                                         " expire_time_attr(%d)\n" ,
-                                         reason, object, flags, expire);
-                        } else {
-                                fprintf (stderr,
-                                         "Didnt receive upcall notify event");
-                                ret = -1;
-                                goto err;
-                        }
-
-                        glfs_free (cbk);
-                }
-
-                sleep(5);
-        } while (++cnt < 5);
+
+        sleep(5);
+    } while (++cnt < 5);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
-        glfs_close(fd2);
-        LOG_ERR ("glfs_close-fd2", ret);
+    glfs_close(fd2);
+    LOG_ERR("glfs_close-fd2", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (fs2) {
-                ret = glfs_fini(fs2);
-                fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/upcall-register-api.c b/tests/basic/gfapi/upcall-register-api.c
new file mode 100644
index 00000000000..53ce0ecdb68
--- /dev/null
+++ b/tests/basic/gfapi/upcall-register-api.c
@@ -0,0 +1,286 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+
+int upcall_recv = 0;
+
+void
+up_async_invalidate(struct glfs_upcall *up_arg, void *data)
+{
+    struct glfs_upcall_inode *in_arg = NULL;
+    enum glfs_upcall_reason reason = 0;
+    struct glfs_object *object = NULL;
+    uint64_t flags = 0;
+    uint64_t expire = 0;
+
+    if (!up_arg)
+        return;
+
+    reason = glfs_upcall_get_reason(up_arg);
+
+    /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
+
+    if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+        in_arg = glfs_upcall_get_event(up_arg);
+
+        object = glfs_upcall_inode_get_object(in_arg);
+        flags = glfs_upcall_inode_get_flags(in_arg);
+        expire = glfs_upcall_inode_get_expire(in_arg);
+
+        fprintf(stderr,
+                " upcall event type - %d,"
+                " object(%p), flags(%d), "
+                " expire_time_attr(%d)\n",
+                reason, object, flags, expire);
+        upcall_recv++;
+    }
+
+    glfs_free(up_arg);
+    return;
+}
+
+int
+perform_io(glfs_t *fs, glfs_t *fs2, int cnt)
+{
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *writebuf = NULL;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *filename = "file_tmp";
+    int ret = -1;
+
+    if (!fs || !fs2)
+        return -1;
+
+    /* Create file from fs and open it from fs2 */
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
+        }
+
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
+                ret = -1;
+                LOG_ERR("glfs_write", ret);
+            }
+            free(writebuf);
+        } else {
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
+        }
+
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
+
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
+
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
+        }
+
+        sleep(2);
+    } while (--cnt > 0);
+
+    sleep(2);
+
+    ret = 0;
+err:
+    glfs_close(fd);
+
+    glfs_close(fd2);
+
+out:
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    char *vol_id = NULL;
+    unsigned int cnt = 5;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int up_events = GLFS_EVENT_ANY;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    /* Initialize fs */
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* Initialize fs2 */
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    /* Register Upcalls */
+    ret = glfs_upcall_register(fs, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_register(fs2, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    /* Perform I/O */
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv == 0) {
+        fprintf(stderr, "Upcalls are not received.\n");
+        ret = -1;
+    } else {
+        fprintf(stderr, "Received %d upcalls as expected\n", upcall_recv);
+        ret = 0;
+    }
+
+    sleep(5); /* to flush out previous upcalls if any */
+
+    /* Now unregister and check there are no upcall events received */
+    ret = glfs_upcall_unregister(fs, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_unregister return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_unregister(fs2, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_unregister return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    upcall_recv = 0;
+
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv != 0) {
+        fprintf(stderr, "%d upcalls received even after unregister.\n",
+                upcall_recv);
+        ret = -1;
+    } else {
+        fprintf(stderr,
+                "Post unregister, no upcalls received as"
+                " expected\n");
+        ret = 0;
+    }
+
+out:
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
+}
diff --git a/tests/basic/gfapi/upcall-register-api.t b/tests/basic/gfapi/upcall-register-api.t
new file mode 100755
index 00000000000..a46234ed7af
--- /dev/null
+++ b/tests/basic/gfapi/upcall-register-api.t
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+## Enable Upcall cache-invalidation feature
+TEST $CLI volume set $V0 features.cache-invalidation on;
+
+TEST build_tester $(dirname $0)/upcall-register-api.c -lgfapi
+
+TEST ./$(dirname $0)/upcall-register-api $H0 $V0  $logdir/upcall-register-api.log
+
+cleanup_tester $(dirname $0)/upcall-register-api
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup;
diff --git a/tests/basic/gfproxy.t b/tests/basic/gfproxy.t
new file mode 100755
index 00000000000..7aa8b70b793
--- /dev/null
+++ b/tests/basic/gfproxy.t
@@ -0,0 +1,71 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../nfs.rc
+
+function file_exists
+{
+        if [ -f $1 ]; then echo "Y"; else echo "N"; fi
+}
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 config.gfproxyd enable
+TEST $CLI volume set $V0 failover-hosts "127.0.0.1,192.168.122.215,192.168.122.90"
+TEST $CLI volume set $V0 client-log-level TRACE
+TEST $CLI volume start $V0
+
+sleep 2
+
+REGULAR_CLIENT_VOLFILE="/var/lib/glusterd/vols/${V0}/trusted-${V0}.tcp-fuse.vol"
+GFPROXY_CLIENT_VOLFILE="/var/lib/glusterd/vols/${V0}/trusted-${V0}.tcp-gfproxy-fuse.vol"
+GFPROXYD_VOLFILE="/var/lib/glusterd/vols/${V0}/${V0}.gfproxyd.vol"
+
+# Client volfile must exist
+TEST [ -f $GFPROXY_CLIENT_VOLFILE ]
+
+# write-behind translators must exist
+TEST grep "performance/write-behind" $GFPROXY_CLIENT_VOLFILE
+
+# Make sure we didn't screw up the existing client
+TEST grep "performance/write-behind" $REGULAR_CLIENT_VOLFILE
+TEST grep "cluster/replicate" $REGULAR_CLIENT_VOLFILE
+TEST grep "cluster/distribute" $REGULAR_CLIENT_VOLFILE
+
+TEST [ -f $GFPROXYD_VOLFILE ]
+
+TEST grep "cluster/replicate" $GFPROXYD_VOLFILE
+TEST grep "cluster/distribute" $GFPROXYD_VOLFILE
+
+# write-behind must *not* exist
+TEST ! grep "performance/write-behind" $GFPROXYD_VOLFILE
+
+# Test that we can start the server and the client
+TEST glusterfs --thin-client --volfile-id=patchy --volfile-server=$H0 -l /var/log/glusterfs/${V0}-gfproxy-client.log $M0
+sleep 2
+TEST grep gfproxy-client/${V0} /proc/mounts
+
+# Write data to the mount and checksum it
+TEST dd if=/dev/urandom bs=1M count=10 of=/tmp/testfile1
+md5=$(md5sum /tmp/testfile1 | awk '{print $1}')
+TEST cp -v /tmp/testfile1 $M0/testfile1
+TEST [ "$(md5sum $M0/testfile1 | awk '{print $1}')" == "$md5" ]
+
+rm /tmp/testfile1
+
+dd if=/dev/zero of=$M0/bigfile bs=1K count=10240 &
+BG_STRESS_PID=$!
+
+TEST wait $BG_STRESS_PID
+
+# Perform graph change and make sure the gfproxyd restarts
+TEST $CLI volume set $V0 stat-prefetch off
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" file_exists $M0/bigfile
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=1501392
diff --git a/tests/basic/global-threading.t b/tests/basic/global-threading.t
new file mode 100644
index 00000000000..f7d34044b09
--- /dev/null
+++ b/tests/basic/global-threading.t
@@ -0,0 +1,104 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+# Test if the given process has a number of threads of a given type between
+# min and max.
+function check_threads() {
+    local pid="${1}"
+    local pattern="${2}"
+    local min="${3}"
+    local max="${4-}"
+    local count
+
+    count="$(ps hH -o comm ${pid} | grep "${pattern}" | wc -l)"
+    if [[ ${min} -gt ${count} ]]; then
+        return 1
+    fi
+    if [[ ! -z "${max}" && ${max} -lt ${count} ]]; then
+        return 1
+    fi
+
+    return 0
+}
+
+cleanup
+
+TEST glusterd
+
+# Glusterd shouldn't use any thread
+TEST check_threads $(get_glusterd_pid) glfs_tpw 0 0
+TEST check_threads $(get_glusterd_pid) glfs_iotwr 0 0
+
+TEST pkill -9 glusterd
+
+TEST glusterd --global-threading
+
+# Glusterd shouldn't use global threads, even if enabled
+TEST check_threads $(get_glusterd_pid) glfs_tpw 0 0
+TEST check_threads $(get_glusterd_pid) glfs_iotwr 0 0
+
+TEST $CLI volume create $V0 replica 2 $H0:$B0/b{0,1}
+
+# Normal configuration using io-threads on bricks
+TEST $CLI volume set $V0 config.global-threading off
+TEST $CLI volume set $V0 performance.iot-pass-through off
+TEST $CLI volume set $V0 performance.client-io-threads off
+TEST $CLI volume start $V0
+
+# There shouldn't be global threads
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b0) glfs_tpw 0 0
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b1) glfs_tpw 0 0
+
+# There should be at least 1 io-thread
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b0) glfs_iotwr 1
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b1) glfs_iotwr 1
+
+# Self-heal should be using global threads
+TEST check_threads $(get_shd_process_pid) glfs_tpw 1
+TEST check_threads $(get_shd_process_pid) glfs_iotwr 0 0
+
+TEST $CLI volume stop $V0
+
+# Configuration with global threads on bricks
+TEST $CLI volume set $V0 config.global-threading on
+TEST $CLI volume set $V0 performance.iot-pass-through on
+TEST $CLI volume start $V0
+
+# There should be at least 1 global thread
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b0) glfs_tpw 1
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b1) glfs_tpw 1
+
+# There shouldn't be any io-thread worker threads
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b0) glfs_iotwr 0 0
+TEST check_threads $(get_brick_pid $V0 $H0 $B0/b1) glfs_iotwr 0 0
+
+# Normal configuration using io-threads on clients
+TEST $CLI volume set $V0 performance.iot-pass-through off
+TEST $CLI volume set $V0 performance.client-io-threads on
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+# There shouldn't be global threads
+TEST check_threads $(get_mount_process_pid $V0 $M0) glfs_tpw 0 0
+
+# There should be at least 1 io-thread
+TEST check_threads $(get_mount_process_pid $V0 $M0) glfs_iotwr 1
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+# Configuration with global threads on clients
+TEST $CLI volume set $V0 performance.client-io-threads off
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --global-threading $M0
+
+# There should be at least 1 global thread
+TEST check_threads $(get_mount_process_pid $V0 $M0) glfs_tpw 1
+
+# There shouldn't be io-threads
+TEST check_threads $(get_mount_process_pid $V0 $M0) glfs_iotwr 0 0
+
+# Some basic volume access checks with global-threading enabled everywhere
+TEST mkdir ${M0}/dir
+TEST dd if=/dev/zero of=${M0}/dir/file bs=128k count=8
+
+cleanup
diff --git a/tests/basic/glusterd-restart-shd-mux.t b/tests/basic/glusterd-restart-shd-mux.t
new file mode 100644
index 00000000000..46d0dac2fce
--- /dev/null
+++ b/tests/basic/glusterd-restart-shd-mux.t
@@ -0,0 +1,96 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TESTS_EXPECTED_IN_LOOP=20
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 cluster.background-self-heal-count 0
+TEST $CLI volume set $V0 cluster.eager-lock off
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+
+for i in $(seq 1 3); do
+   TEST $CLI volume create ${V0}_afr$i replica 3 $H0:$B0/${V0}_afr${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_afr$i
+   TEST $CLI volume create ${V0}_ec$i disperse 6 redundancy 2 $H0:$B0/${V0}_ec${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+
+#Stop the glusterd
+TEST pkill glusterd
+#Only stopping glusterd, so there will be one shd
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^1$" shd_count
+TEST glusterd
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+#Check the thread count become to number of volumes*number of ec subvolume (3*6=18)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to number of volumes*number of afr subvolume (4*6=24)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^24$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+shd_pid=$(get_shd_mux_pid $V0)
+for i in $(seq 1 3); do
+    afr_path="/var/run/gluster/shd/${V0}_afr$i/${V0}_afr$i-shd.pid"
+    EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" cat $afr_path
+    ec_path="/var/run/gluster/shd/${V0}_ec$i/${V0}_ec${i}-shd.pid"
+    EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" cat $ec_path
+done
+
+#Reboot a node scenario
+TEST pkill gluster
+#Only stopped glusterd, so there will be one shd
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+
+TEST glusterd
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+
+#Check the thread count become to number of volumes*number of ec subvolume (3*6=18)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to number of volumes*number of afr subvolume (4*6=24)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^24$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+shd_pid=$(get_shd_mux_pid $V0)
+for i in $(seq 1 3); do
+    afr_path="/var/run/gluster/shd/${V0}_afr$i/${V0}_afr$i-shd.pid"
+    EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" cat $afr_path
+    ec_path="/var/run/gluster/shd/${V0}_ec$i/${V0}_ec${i}-shd.pid"
+    EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" cat $ec_path
+done
+
+for i in $(seq 1 3); do
+   TEST $CLI volume stop ${V0}_afr$i
+   TEST $CLI volume stop ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}3
+
+TEST touch $M0/foo{1..100}
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^204$" get_pending_heal_count $V0
+
+TEST $CLI volume start ${V0} force
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+TEST rm -rf $M0/*
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+
+TEST $CLI volume stop ${V0}
+TEST $CLI volume delete ${V0}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^0$" shd_count
+
+cleanup
diff --git a/tests/basic/glusterd/arbiter-volume.t b/tests/basic/glusterd/arbiter-volume.t
deleted file mode 100644
index 03f9aca2daf..00000000000
--- a/tests/basic/glusterd/arbiter-volume.t
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-# This command tests the volume create command validation for arbiter volumes.
-
-cleanup;
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
-EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
-
-TEST $CLI volume delete $V0
-TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/b{4..9}
-EXPECT "2 x \(2 \+ 1\) = 6" volinfo_field $V0 "Number of Bricks"
-
-TEST $CLI volume delete $V0
-TEST $CLI volume create $V0 stripe 2 replica 3 arbiter 1 $H0:$B0/b{10..15}
-EXPECT "1 x 2 x \(2 \+ 1\) = 6" volinfo_field $V0 "Number of Bricks"
-
-TEST $CLI volume delete $V0
-TEST rm -rf $B0/b{1..3}
-TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
-EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
-TEST killall -15 glusterd
-TEST glusterd
-TEST pidof glusterd
-EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
-
-#cleanup
diff --git a/tests/basic/glusterd/check-cloudsync-ancestry.t b/tests/basic/glusterd/check-cloudsync-ancestry.t
new file mode 100644
index 00000000000..ff6ffee8db7
--- /dev/null
+++ b/tests/basic/glusterd/check-cloudsync-ancestry.t
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# When shard and cloudsync xlators enabled on a volume, shard xlator
+# should be an ancestor of cloudsync. This testcase is to check this condition.
+
+cleanup;
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
+
+volfile=$(gluster system:: getwd)"/vols/$V0/trusted-$V0.tcp-fuse.vol"
+
+#Test that both shard and cloudsync are not loaded
+EXPECT "N" volgen_volume_exists $volfile $V0-shard features shard
+EXPECT "N" volgen_volume_exists $volfile $V0-cloudsync features cloudsync
+
+#Enable shard and cloudsync in that order and check if volfile is correct
+TEST $CLI volume set $V0 shard on
+TEST $CLI volume set $V0 cloudsync on
+
+#Test that both shard and cloudsync are loaded
+EXPECT "Y" volgen_volume_exists $volfile $V0-shard features shard
+EXPECT "Y" volgen_volume_exists $volfile $V0-cloudsync features cloudsync
+
+EXPECT "Y" volgen_check_ancestry $volfile features shard features cloudsync
+
+#Disable shard and cloudsync
+TEST $CLI volume set $V0 shard off
+TEST $CLI volume set $V0 cloudsync off
+
+#Test that both shard and cloudsync are not loaded
+EXPECT "N" volgen_volume_exists $volfile $V0-shard features shard
+EXPECT "N" volgen_volume_exists $volfile $V0-cloudsync features cloudsync
+
+#Enable cloudsync and shard in that order and check if volfile is correct
+TEST $CLI volume set $V0 cloudsync on
+TEST $CLI volume set $V0 shard on
+
+#Test that both shard and cloudsync are loaded
+EXPECT "Y" volgen_volume_exists $volfile $V0-shard features shard
+EXPECT "Y" volgen_volume_exists $volfile $V0-cloudsync features cloudsync
+
+EXPECT "Y" volgen_check_ancestry $volfile features shard features cloudsync
+
+cleanup;
diff --git a/tests/basic/glusterd/disperse-create.t b/tests/basic/glusterd/disperse-create.t
index e5ce74c12b2..db8a621d48e 100644
--- a/tests/basic/glusterd/disperse-create.t
+++ b/tests/basic/glusterd/disperse-create.t
@@ -20,6 +20,10 @@ TEST $CLI volume create $V0 disperse 3 redundancy 1 $H0:$B0/b7 $H0:$B0/b8 $H0:$B
 EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
 
 TEST $CLI volume delete $V0
+TEST $CLI volume create $V0 disperse-data 2 $H0:$B0/b10 $H0:$B0/b11 $H0:$B0/b12
+EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
+
+TEST $CLI volume delete $V0
 TEST $CLI volume create $V0 redundancy 1 $H0:$B0/b10 $H0:$B0/b11 $H0:$B0/b12
 EXPECT "1 x \(2 \+ 1\) = 3" volinfo_field $V0 "Number of Bricks"
 
@@ -48,6 +52,7 @@ TEST ! $CLI volume create $V0 redundancy 1 redundancy 1 $H0:$B0/b20 $H0:$B0/b21
 #Minimum counts test
 TEST ! $CLI volume create $V0 disperse 2 $H0:$B0/b20 $H0:$B0/b22
 TEST ! $CLI volume create $V0 disperse-data 1 redundancy 0 $H0:$B0/b20 $H0:$B0/b22
+TEST ! $CLI volume create $V0 disperse 4 disperse-data 4 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b23 $H0:$B0/b24
 TEST ! $CLI volume create $V0 redundancy 0 $H0:$B0/b20 $H0:$B0/b22
 
 #Wrong count n != k+m
@@ -64,18 +69,5 @@ TEST ! $CLI volume create $V0 redundancy 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0
 TEST ! $CLI volume create $V0 replica 2 disperse 4 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
 TEST ! $CLI volume create $V0 replica 2 disperse-data 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22 $H0:$B0/b23
 TEST ! $CLI volume create $V0 replica 2 redundancy 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-#Stripe + Disperse
-TEST ! $CLI volume create $V0 disperse 4 stripe 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 disperse-data 2 stripe 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22 $H0:$B0/b23
-TEST ! $CLI volume create $V0 redundancy 2 stripe 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 stripe 2 disperse 4 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 stripe 2 disperse-data 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22 $H0:$B0/b23
-TEST ! $CLI volume create $V0 stripe 2 redundancy 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-#Stripe + Replicate + Disperse, It is failing with striped-dispersed volume.
-TEST ! $CLI volume create $V0 disperse 4 stripe 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 disperse-data 2 stripe 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22 $H0:$B0/b23
-TEST ! $CLI volume create $V0 redundancy 2 stripe 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 stripe 2 disperse 4 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
-TEST ! $CLI volume create $V0 stripe 2 disperse-data 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22 $H0:$B0/b23
-TEST ! $CLI volume create $V0 stripe 2 redundancy 2 replica 2 $H0:$B0/b20 $H0:$B0/b21 $H0:$B0/b22
+
 cleanup
diff --git a/tests/basic/glusterd/heald.t b/tests/basic/glusterd/heald.t
index bdfda8ff0d6..7dae3c3f0fb 100644
--- a/tests/basic/glusterd/heald.t
+++ b/tests/basic/glusterd/heald.t
@@ -7,70 +7,73 @@
 # Covers enable/disable at the moment. Will be enhanced later to include
 # the other commands as well.
 
+function is_pid_running {
+    local pid=$1
+    num=`ps auxww | grep glustershd | grep $pid | grep -v grep | wc -l`
+    echo $num
+}
+
 cleanup;
 TEST glusterd
 TEST pidof glusterd
 
-volfile=$(gluster system:: getwd)"/glustershd/glustershd-server.vol"
 #Commands should fail when volume doesn't exist
 TEST ! $CLI volume heal non-existent-volume enable
 TEST ! $CLI volume heal non-existent-volume disable
 
-# Commands should fail when volume is of distribute/stripe type.
 # Glustershd shouldn't be running as long as there are no replicate/disperse
 # volumes
 TEST $CLI volume create dist $H0:$B0/dist
 TEST $CLI volume start dist
-TEST "[ -z $(get_shd_process_pid)]"
+TEST "[ -z $(get_shd_process_pid dist)]"
 TEST ! $CLI volume heal dist enable
 TEST ! $CLI volume heal dist disable
-TEST $CLI volume create st stripe 3 $H0:$B0/st1 $H0:$B0/st2 $H0:$B0/st3
-TEST $CLI volume start st
-TEST "[ -z $(get_shd_process_pid)]"
-TEST ! $CLI volume heal st
-TEST ! $CLI volume heal st disable
 
 # Commands should work on replicate/disperse volume.
 TEST $CLI volume create r2 replica 2 $H0:$B0/r2_0 $H0:$B0/r2_1
-TEST "[ -z $(get_shd_process_pid)]"
+TEST "[ -z $(get_shd_process_pid r2)]"
 TEST $CLI volume start r2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid r2
 TEST $CLI volume heal r2 enable
 EXPECT "enable" volume_option r2 "cluster.self-heal-daemon"
-EXPECT "enable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+volfiler2=$(gluster system:: getwd)"/vols/r2/r2-shd.vol"
+EXPECT "enable" volgen_volume_option $volfiler2 r2-replicate-0 cluster replicate self-heal-daemon
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid r2
+pid=$( get_shd_process_pid r2 )
 TEST $CLI volume heal r2 disable
 EXPECT "disable" volume_option r2 "cluster.self-heal-daemon"
-EXPECT "disable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+EXPECT "disable" volgen_volume_option $volfiler2 r2-replicate-0 cluster replicate self-heal-daemon
+EXPECT "1" is_pid_running $pid
 
 # Commands should work on disperse volume.
 TEST $CLI volume create ec2 disperse 3 redundancy 1 $H0:$B0/ec2_0 $H0:$B0/ec2_1 $H0:$B0/ec2_2
 TEST $CLI volume start ec2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid ec2
 TEST $CLI volume heal ec2 enable
 EXPECT "enable" volume_option ec2 "cluster.disperse-self-heal-daemon"
-EXPECT "enable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+volfileec2=$(gluster system:: getwd)"/vols/ec2/ec2-shd.vol"
+EXPECT "enable" volgen_volume_option $volfileec2 ec2-disperse-0 cluster disperse self-heal-daemon
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid ec2
+pid=$(get_shd_process_pid ec2)
 TEST $CLI volume heal ec2 disable
 EXPECT "disable" volume_option ec2 "cluster.disperse-self-heal-daemon"
-EXPECT "disable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
+EXPECT "disable" volgen_volume_option $volfileec2 ec2-disperse-0 cluster disperse self-heal-daemon
+EXPECT "1" is_pid_running $pid
 
 #Check that shd graph is rewritten correctly on volume stop/start
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
+EXPECT "Y" volgen_volume_exists $volfileec2 ec2-disperse-0 cluster disperse
+
+EXPECT "Y" volgen_volume_exists $volfiler2 r2-replicate-0 cluster replicate
 TEST $CLI volume stop r2
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "N" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
+EXPECT "Y" volgen_volume_exists $volfileec2 ec2-disperse-0 cluster disperse
 TEST $CLI volume stop ec2
 # When both the volumes are stopped glustershd volfile is not modified just the
 # process is stopped
-TEST "[ -z $(get_shd_process_pid) ]"
+TEST "[ -z $(get_shd_process_pid dist) ]"
+TEST "[ -z $(get_shd_process_pid ec2) ]"
 
 TEST $CLI volume start r2
-EXPECT "N" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
+EXPECT "Y" volgen_volume_exists $volfiler2 r2-replicate-0 cluster replicate
 
 TEST $CLI volume set r2 self-heal-daemon on
 TEST $CLI volume set r2 cluster.self-heal-daemon off
diff --git a/tests/basic/glusterd/thin-arbiter-volume-probe.t b/tests/basic/glusterd/thin-arbiter-volume-probe.t
new file mode 100644
index 00000000000..acc6943806d
--- /dev/null
+++ b/tests/basic/glusterd/thin-arbiter-volume-probe.t
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+#This tests if the thin-arbiter-count is transferred to the other peer.
+function check_peers {
+        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup;
+
+TEST launch_cluster 2;
+TEST $CLI_1 peer probe $H2;
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
+
+kill_glusterd 2
+$CLI_1 volume create $V0 replica 2 thin-arbiter 1 $H0:$B0/b{1..3}
+TEST $glusterd_2
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
+EXPECT "1 x 2 = 2" volinfo_field_1 $V0 "Number of Bricks"
+EXPECT "1 x 2 = 2" volinfo_field_2 $V0 "Number of Bricks"
+
+cleanup;
diff --git a/tests/basic/glusterd/thin-arbiter-volume.t b/tests/basic/glusterd/thin-arbiter-volume.t
new file mode 100644
index 00000000000..4e813890a45
--- /dev/null
+++ b/tests/basic/glusterd/thin-arbiter-volume.t
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../ volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+
+#This command tests the volume create command validation for thin-arbiter volumes.
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 2 thin-arbiter 1 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
+EXPECT "1 x 2 = 2" volinfo_field $V0 "Number of Bricks"
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+TEST touch $M0/a.txt
+TEST ls $B0/b1/a.txt 
+TEST ls $B0/b2/a.txt 
+TEST ! ls $B0/b3/a.txt
+
+TEST umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+TEST $CLI volume create $V0 replica 2 thin-arbiter 1 $H0:$B0/b{4..8}
+EXPECT "2 x 2 = 4" volinfo_field $V0 "Number of Bricks"
+
+TEST $CLI volume delete $V0
+
+TEST rm -rf $B0/b{1..3}
+
+TEST $CLI volume create $V0 replica 2 thin-arbiter 1 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
+EXPECT "1 x 2 = 2" volinfo_field $V0 "Number of Bricks"
+
+TEST killall -15 glusterd
+TEST glusterd
+TEST pidof glusterd
+EXPECT "1 x 2 = 2" volinfo_field $V0 "Number of Bricks"
+
+cleanup
+
diff --git a/tests/basic/glusterd/volfile_server_switch.t b/tests/basic/glusterd/volfile_server_switch.t
index 309060919b7..e11cfed509a 100644
--- a/tests/basic/glusterd/volfile_server_switch.t
+++ b/tests/basic/glusterd/volfile_server_switch.t
@@ -34,7 +34,7 @@ TEST glusterfs --volfile-id=/$V0 --volfile-server=$H1 --volfile-server=$H2 --vol
 
 TEST kill_glusterd 1
 
-TEST $CLI_2 volume set $V0 performance.io-cache off
+TEST $CLI_2 volume set $V0 performance.write-behind off
 
 # make sure by this time directory will be created
 # TODO: suggest ideal time to wait
diff --git a/tests/basic/glusterd/volume-brick-count.t b/tests/basic/glusterd/volume-brick-count.t
new file mode 100644
index 00000000000..dc1a5278f4f
--- /dev/null
+++ b/tests/basic/glusterd/volume-brick-count.t
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+function test_volume_config()
+{
+        volname=$1
+        type_string=$2
+        brickCount=$3
+        distCount=$4
+        replicaCount=$5
+        arbiterCount=$6
+        disperseCount=$7
+        redundancyCount=$8
+
+        EXPECT "$type_string" volinfo_field $volname "Number of Bricks"
+        EXPECT "$brickCount" get-xml "volume info $volname" "brickCount"
+        EXPECT "$distCount" get-xml "volume info $volname" "distCount"
+        EXPECT "$replicaCount" get-xml "volume info $volname" "replicaCount"
+        EXPECT "$arbiterCount" get-xml "volume info $volname" "arbiterCount"
+        EXPECT "$disperseCount" get-xml "volume info $volname" "disperseCount"
+        EXPECT "$redundancyCount" get-xml "volume info $volname" "redundancyCount"
+}
+
+# This command tests the volume create command and number of bricks for different volume types.
+cleanup;
+TESTS_EXPECTED_IN_LOOP=56
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create ${V0}_1 replica 3 arbiter 1 $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
+test_volume_config "${V0}_1" "1 x \(2 \+ 1\) = 3" "3" "1" "3" "1" "0" "0"
+
+TEST $CLI volume create ${V0}_2 replica 3 arbiter 1 $H0:$B0/b{4..9}
+test_volume_config "${V0}_2" "2 x \(2 \+ 1\) = 6" "6" "2" "3" "1" "0" "0"
+
+
+TEST $CLI volume create ${V0}_3 replica 3 arbiter 1 $H0:$B0/b{10..12}
+test_volume_config "${V0}_3" "1 x \(2 \+ 1\) = 3" "3" "1" "3" "1" "0" "0"
+TEST killall -15 glusterd
+TEST glusterd
+TEST pidof glusterd
+test_volume_config "${V0}_3" "1 x \(2 \+ 1\) = 3" "3" "1" "3" "1" "0" "0"
+
+TEST $CLI volume create ${V0}_4 replica 3 $H0:$B0/b{13..15}
+test_volume_config "${V0}_4" "1 x 3 = 3" "3" "1" "3" "0" "0" "0"
+
+TEST $CLI volume create ${V0}_5 replica 3 $H0:$B0/b{16..21}
+test_volume_config "${V0}_5" "2 x 3 = 6" "6" "2" "3" "0" "0" "0"
+
+TEST $CLI volume create ${V0}_6 disperse 3 redundancy 1 $H0:$B0/b{22..24}
+test_volume_config "${V0}_6" "1 x \(2 \+ 1\) = 3" "3" "1" "1" "0" "3" "1"
+
+TEST $CLI volume create ${V0}_7 disperse 3 redundancy 1 $H0:$B0/b{25..30}
+test_volume_config "${V0}_7" "2 x \(2 \+ 1\) = 6" "6" "2" "1" "0" "3" "1"
+
+TEST $CLI volume create ${V0}_8 $H0:$B0/b{31..33}
+test_volume_config "${V0}_8" "3" "3" "3" "1" "0" "0" "0"
+
+cleanup
diff --git a/tests/basic/glusterfsd-args.t b/tests/basic/glusterfsd-args.t
new file mode 100644
index 00000000000..2dd84b8c29e
--- /dev/null
+++ b/tests/basic/glusterfsd-args.t
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+EXPECT $GLUSTER_LIBEXECDIR glusterfsd --print-libexecdir
diff --git a/tests/basic/graph-cleanup-brick-down-shd-mux.t b/tests/basic/graph-cleanup-brick-down-shd-mux.t
new file mode 100644
index 00000000000..3c621cdcc26
--- /dev/null
+++ b/tests/basic/graph-cleanup-brick-down-shd-mux.t
@@ -0,0 +1,64 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TESTS_EXPECTED_IN_LOOP=4
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 cluster.background-self-heal-count 0
+TEST $CLI volume set $V0 cluster.eager-lock off
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+
+for i in $(seq 1 2); do
+   TEST $CLI volume create ${V0}_afr$i replica 3 $H0:$B0/${V0}_afr${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_afr$i
+   TEST $CLI volume create ${V0}_ec$i disperse 6 redundancy 2 $H0:$B0/${V0}_ec${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+#Check the thread count become to number of volumes*number of ec subvolume (2*6=12)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to number of volumes*number of afr subvolume (3*6=18)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#kill one brick and test cleanup
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST $CLI volume stop $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+
+#kill an entire subvol and test cleanup
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST kill_brick $V0 $H0 $B0/${V0}2
+#wait for some time to create a race sceanrio
+sleep 1
+TEST $CLI volume stop $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+
+#kill all bricks and test cleanup
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST kill_brick $V0 $H0 $B0/${V0}3
+TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick $V0 $H0 $B0/${V0}5
+#wait for some time to create a race sceanrio
+sleep 2
+
+TEST $CLI volume stop $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd ${V0}_afr1 "afr_shd_index_healer"
+
+cleanup
diff --git a/tests/basic/hardlink-limit.t b/tests/basic/hardlink-limit.t
new file mode 100644
index 00000000000..ee65c650b59
--- /dev/null
+++ b/tests/basic/hardlink-limit.t
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6};
+
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+EXPECT '6' brick_count $V0
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $CLI volume set $V0 storage.max-hardlinks 3
+TEST glusterfs -s $H0 --volfile-id $V0 $M0;
+
+TEST dd if=/dev/zero of=$M0/testfile count=1
+
+# max-hardlinks is 3, should be able to create 2 links.
+TEST link $M0/testfile $M0/testfile.link1
+TEST link $M0/testfile $M0/testfile.link2
+
+# But not 3.
+TEST ! link $M0/testfile $M0/testfile.link3
+# If we remove one...
+TEST rm $M0/testfile.link1
+# Now we can add one.
+TEST link $M0/testfile $M0/testfile.link3
+
+# But not another
+TEST ! link $M0/testfile $M0/testfile.link4
+
+# Unless we disable the limit...
+TEST $CLI volume set $V0 storage.max-hardlinks 0
+TEST link $M0/testfile $M0/testfile.link4
+
+cleanup;
diff --git a/tests/basic/inode-leak.t b/tests/basic/inode-leak.t
new file mode 100644
index 00000000000..e112fdddf8a
--- /dev/null
+++ b/tests/basic/inode-leak.t
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1,2,3}
+TEST $CLI volume start $V0
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+EXPECT "1" get_mount_active_size_value $V0 $M0
+EXPECT "0" get_mount_lru_size_value $V0 $M0
+
+TEST cp -rf /etc $M0
+TEST find $M0
+TEST rm -rf $M0/*
+
+EXPECT "1" get_mount_active_size_value $V0 $M0
+EXPECT "0" get_mount_lru_size_value $V0 $M0
+
+cleanup
+
+# Mainly marking it as known-issue as it is taking a *lot* of time.
+# Revert back if we are below an hour in regression runs.
+# Or consider running only in nightly regressions.
+
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/ios-dump.t b/tests/basic/ios-dump.t
new file mode 100644
index 00000000000..0cfbdc6ae7c
--- /dev/null
+++ b/tests/basic/ios-dump.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+function check_brick_inter_stats() {
+  local counter="$1"
+  local inter_cnt=""
+
+  inter_cnt=$(grep -h "\".*inter.*$counter\"" \
+    /var/lib/glusterd/stats/glusterfsd*.dump 2>/dev/null |
+    grep -v '\"0.0000\"' | wc -l)
+  if (( $inter_cnt == 3 )); then
+    echo "Y"
+  else
+    echo "N"
+  fi
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 5
+TEST $CLI volume set $V0 diagnostics.count-fop-hits on
+TEST $CLI volume set $V0 diagnostics.latency-measurement on
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+
+# Generate some FOPs
+cd $M0
+for i in {1..10}; do
+  mkdir a
+  cd a
+  for g in {1..10}; do
+    dd if=/dev/zero of=test$g bs=128k count=1
+  done
+done
+
+EXPECT_WITHIN 30 "Y" check_brick_inter_stats fop.weighted_latency_ave_usec
+
+cleanup
diff --git a/tests/basic/jbr/jbr-volgen.t b/tests/basic/jbr/jbr-volgen.t
new file mode 100644
index 00000000000..f368710c158
--- /dev/null
+++ b/tests/basic/jbr/jbr-volgen.t
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+volfiles=${GLUSTERD_WORKDIR}/vols/${V0}/
+check_brick_volfiles () {
+        for vf in ${volfiles}${V0}.$(hostname).*.vol; do
+                grep -qs experimental/jbr $vf || return
+                # At least for now, nothing else would put a client translator
+                # in a brick volfile.
+                grep -qs protocol/client $vf || return
+        done
+        echo "OK"
+}
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2}
+TEST $CLI volume set $V0 cluster.jbr on
+
+# Check that the client volfile got modified properly.
+TEST grep -qs experimental/jbrc ${volfiles}${V0}.tcp-fuse.vol
+
+# Check that the brick volfiles got modified as well.
+EXPECT "OK" check_brick_volfiles
+
+# Put things back and make sure the "undo" worked.
+TEST $CLI volume set $V0 cluster.jbr off
+TEST $CLI volume start $V0
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+echo hello > $M0/probe
+EXPECT hello cat ${B0}/${V0}1/probe
+EXPECT hello cat ${B0}/${V0}2/probe
+
+cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1385758
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1385758
diff --git a/tests/basic/jbr/jbr.t b/tests/basic/jbr/jbr.t
new file mode 100755
index 00000000000..605344b5a7e
--- /dev/null
+++ b/tests/basic/jbr/jbr.t
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../snapshot.rc
+. $(dirname $0)/../../fdl.rc
+
+cleanup;
+
+TEST verify_lvm_version;
+#Create cluster with 3 nodes
+TEST launch_cluster 3;
+TEST setup_lvm 3
+
+TEST $CLI_1 peer probe $H2;
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count;
+
+TEST $CLI_1 volume create $V0 replica 3 $H1:$L1 $H2:$L2 $H3:$L3
+TEST $CLI_1 volume set $V0 cluster.jbr on
+TEST $CLI_1 volume set $V0 cluster.jbr.quorum-percent 100
+TEST $CLI_1 volume set $V0 features.fdl on
+#TEST $CLI_1 volume set $V0 diagnostics.brick-log-level DEBUG
+TEST $CLI_1 volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H1 --entry-timeout=0 $M0;
+
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" jbrc_child_up_status $V0 0
+
+echo "file" > $M0/file1
+TEST stat $L1/file1
+TEST stat $L2/file1
+TEST stat $L3/file1
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1385758
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1385758
diff --git a/tests/basic/logchecks-messages.h b/tests/basic/logchecks-messages.h
index 6344037b44a..bf364848ec7 100644
--- a/tests/basic/logchecks-messages.h
+++ b/tests/basic/logchecks-messages.h
@@ -11,7 +11,7 @@
 #ifndef _LOGCHECKS_MESSAGES_H_
 #define _LOGCHECKS_MESSAGES_H_
 
-#include "glfs-message-id.h"
+#include <glusterfs/glfs-message-id.h>
 
 /* NOTE: Rules for message additions
  * 1) Each instance of a message is _better_ left with a unique message ID, even
@@ -35,44 +35,70 @@
  *    holes.
  */
 
-#define GLFS_COMP_BASE          1000
-#define GLFS_NUM_MESSAGES       19
-#define GLFS_MSGID_END          (GLFS_COMP_BASE + GLFS_NUM_MESSAGES + 1)
+#define GLFS_COMP_BASE 1000
+#define GLFS_NUM_MESSAGES 19
+#define GLFS_MSGID_END (GLFS_COMP_BASE + GLFS_NUM_MESSAGES + 1)
 /* Messaged with message IDs */
 #define glfs_msg_start_x GLFS_COMP_BASE, "Invalid: Start of messages"
 /*------------*/
-#define logchecks_msg_1 (GLFS_COMP_BASE + 1), "Informational: Testing logging" \
-                                " in gluster"
-#define logchecks_msg_2 (GLFS_COMP_BASE + 2), "Informational: Format testing:" \
-                                " %d:%s:%x"
-#define logchecks_msg_3 (GLFS_COMP_BASE + 3), "Critical: Testing logging" \
-                                " in gluster"
-#define logchecks_msg_4 (GLFS_COMP_BASE + 4), "Critical: Format testing:" \
-                                " %d:%s:%x"
+#define logchecks_msg_1                                                        \
+    (GLFS_COMP_BASE + 1),                                                      \
+        "Informational: Testing logging"                                       \
+        " in gluster"
+#define logchecks_msg_2                                                        \
+    (GLFS_COMP_BASE + 2),                                                      \
+        "Informational: Format testing:"                                       \
+        " %d:%s:%x"
+#define logchecks_msg_3                                                        \
+    (GLFS_COMP_BASE + 3),                                                      \
+        "Critical: Testing logging"                                            \
+        " in gluster"
+#define logchecks_msg_4                                                        \
+    (GLFS_COMP_BASE + 4),                                                      \
+        "Critical: Format testing:"                                            \
+        " %d:%s:%x"
 #define logchecks_msg_5 (GLFS_COMP_BASE + 5), "Critical: Rotated the log"
 #define logchecks_msg_6 (GLFS_COMP_BASE + 6), "Critical: Flushed the log"
 #define logchecks_msg_7 (GLFS_COMP_BASE + 7), "Informational: gf_msg_callingfn"
-#define logchecks_msg_8 (GLFS_COMP_BASE + 8), "Informational: " \
-                                "gf_msg_callingfn: Format testing: %d:%s:%x"
+#define logchecks_msg_8                                                        \
+    (GLFS_COMP_BASE + 8),                                                      \
+        "Informational: "                                                      \
+        "gf_msg_callingfn: Format testing: %d:%s:%x"
 #define logchecks_msg_9 (GLFS_COMP_BASE + 9), "Critical: gf_msg_callingfn"
-#define logchecks_msg_10 (GLFS_COMP_BASE + 10), "Critical: " \
-                                "gf_msg_callingfn: Format testing: %d:%s:%x"
+#define logchecks_msg_10                                                       \
+    (GLFS_COMP_BASE + 10),                                                     \
+        "Critical: "                                                           \
+        "gf_msg_callingfn: Format testing: %d:%s:%x"
 #define logchecks_msg_11 (GLFS_COMP_BASE + 11), "=========================="
-#define logchecks_msg_12 (GLFS_COMP_BASE + 12), "Test 1: Only stderr and" \
-                                " partial syslog"
-#define logchecks_msg_13 (GLFS_COMP_BASE + 13), "Test 2: Only checklog and" \
-                                " partial syslog"
-#define logchecks_msg_14 (GLFS_COMP_BASE + 14), "Test 5: Changing to" \
-                                " traditional format"
-#define logchecks_msg_15 (GLFS_COMP_BASE + 15), "Test 6: Changing log level" \
-                                " to critical and above"
+#define logchecks_msg_12                                                       \
+    (GLFS_COMP_BASE + 12),                                                     \
+        "Test 1: Only stderr and"                                              \
+        " partial syslog"
+#define logchecks_msg_13                                                       \
+    (GLFS_COMP_BASE + 13),                                                     \
+        "Test 2: Only checklog and"                                            \
+        " partial syslog"
+#define logchecks_msg_14                                                       \
+    (GLFS_COMP_BASE + 14),                                                     \
+        "Test 5: Changing to"                                                  \
+        " traditional format"
+#define logchecks_msg_15                                                       \
+    (GLFS_COMP_BASE + 15),                                                     \
+        "Test 6: Changing log level"                                           \
+        " to critical and above"
 #define logchecks_msg_16 (GLFS_COMP_BASE + 16), "Test 7: Only to syslog"
-#define logchecks_msg_17 (GLFS_COMP_BASE + 17), "Test 8: Only to syslog," \
-                                " traditional format"
-#define logchecks_msg_18 (GLFS_COMP_BASE + 18), "Test 9: Only to syslog," \
-                                " only critical and above"
-#define logchecks_msg_19 (GLFS_COMP_BASE + 19), "Pre init message, not to be" \
-                                " seen in logs"
+#define logchecks_msg_17                                                       \
+    (GLFS_COMP_BASE + 17),                                                     \
+        "Test 8: Only to syslog,"                                              \
+        " traditional format"
+#define logchecks_msg_18                                                       \
+    (GLFS_COMP_BASE + 18),                                                     \
+        "Test 9: Only to syslog,"                                              \
+        " only critical and above"
+#define logchecks_msg_19                                                       \
+    (GLFS_COMP_BASE + 19),                                                     \
+        "Pre init message, not to be"                                          \
+        " seen in logs"
 /*------------*/
 #define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
 
diff --git a/tests/basic/logchecks.c b/tests/basic/logchecks.c
index 58b57003640..df0be28ace0 100644
--- a/tests/basic/logchecks.c
+++ b/tests/basic/logchecks.c
@@ -11,198 +11,204 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "glusterfs.h"
-#include "globals.h"
-#include "logging.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/globals.h>
+#include <glusterfs/logging.h>
 
 #include "logchecks-messages.h"
 #include "../../libglusterfs/src/logging.h"
 
-glusterfs_ctx_t   *ctx = NULL;
+glusterfs_ctx_t *ctx = NULL;
 
-#define TEST_FILENAME           "/tmp/logchecks.log"
-#define GF_LOG_CONTROL_FILE     "/etc/glusterfs/logger.conf"
+#define TEST_FILENAME "/tmp/logchecks.log"
+#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf"
 
 int
 go_log_vargs(gf_loglevel_t level, const char *fmt, ...)
 {
-        va_list  ap;
+    va_list ap;
 
-        va_start (ap, fmt);
-        gf_msg_vplain (level, fmt, ap);
-        va_end (ap);
+    va_start(ap, fmt);
+    gf_msg_vplain(level, fmt, ap);
+    va_end(ap);
 
-        return 0;
+    return 0;
 }
 
 int
-go_log (void)
+go_log(void)
 {
-        /*** gf_msg ***/
-        gf_msg ("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
-        gf_msg ("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two",
-                42);
-        /* change criticality */
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42,
-                "Forty-Two", 42);
-
-        /*** msg_nomem ***/
-        gf_msg_nomem ("logchecks", GF_LOG_ALERT, 555);
-        gf_msg_nomem ("logchecks", GF_LOG_INFO, 555);
-
-        /*** msg_plain ***/
-        gf_msg_plain (GF_LOG_INFO, "Informational: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        gf_msg_plain (GF_LOG_ALERT, "Alert: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_vplain ***/
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_plain_nomem ***/
-        gf_msg_plain_nomem (GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
-        gf_msg_plain_nomem (GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
-
-        /*** msg_backtrace_nomem ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_backtrace_nomem (GF_LOG_INFO, 5);
-        gf_msg_backtrace_nomem (GF_LOG_ALERT, 5);
-
-        /*** gf_msg_callingfn ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
-                          "Forty-Two", 42);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
-                          "Forty-Two", 42);
-
-        /*** gf_msg_debug ***/
-        gf_msg_debug ("logchecks", 0, "Debug: Hello World!!!");
-        gf_msg_debug ("logchecks", 22, "Debug: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_trace ***/
-        gf_msg_trace ("logchecks", 0, "Trace: Hello World!!!");
-        gf_msg_trace ("logchecks", 22, "Trace: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_backtrace ***/
-        // TODO: Test with lower callstr values to check truncation
-
-        return 0;
+    /*** gf_msg ***/
+    gf_msg("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
+    gf_msg("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two", 42);
+    /* change criticality */
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42, "Forty-Two",
+           42);
+
+    /*** msg_nomem ***/
+    gf_msg_nomem("logchecks", GF_LOG_ALERT, 555);
+    gf_msg_nomem("logchecks", GF_LOG_INFO, 555);
+
+    /*** msg_plain ***/
+    gf_msg_plain(GF_LOG_INFO,
+                 "Informational: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    gf_msg_plain(GF_LOG_ALERT,
+                 "Alert: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_vplain ***/
+    go_log_vargs(GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Informational: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    go_log_vargs(GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Critical: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_plain_nomem ***/
+    gf_msg_plain_nomem(GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
+
+    /*** msg_backtrace_nomem ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_backtrace_nomem(GF_LOG_INFO, 5);
+    gf_msg_backtrace_nomem(GF_LOG_ALERT, 5);
+
+    /*** gf_msg_callingfn ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
+                     "Forty-Two", 42);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
+                     "Forty-Two", 42);
+
+    /*** gf_msg_debug ***/
+    gf_msg_debug("logchecks", 0, "Debug: Hello World!!!");
+    gf_msg_debug("logchecks", 22, "Debug: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_trace ***/
+    gf_msg_trace("logchecks", 0, "Trace: Hello World!!!");
+    gf_msg_trace("logchecks", 22, "Trace: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_backtrace ***/
+    // TODO: Test with lower callstr values to check truncation
+
+    return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                ret = -1;
-
-        unlink (GF_LOG_CONTROL_FILE);
-        creat (GF_LOG_CONTROL_FILE, O_RDONLY);
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return -1;
-
-        ret = glusterfs_globals_init (ctx);
-        if (ret) {
-                printf ("Error from glusterfs_globals_init [%s]\n",
-                        strerror (errno));
-                return ret;
-        }
-
-        /* Pre init test, message should not be printed */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
-
-        THIS->ctx = ctx;
-
-        /* TEST 1: messages before initializing the log, goes to stderr
-         * and syslog based on criticality */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 2: messages post initialization, goes to glusterlog and
-         * syslog based on severity */
-        ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
-        if (ret != 0) {
-                printf ("Error from gf_log_init [%s]\n", strerror (errno));
-                return -1;
-        }
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 3: Test rotation */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_logrotate (0);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 4: Check flush, nothing noticeable should occur :) */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_flush ();
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 5: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 6: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* Reset to run with syslog */
-        gf_log_set_logformat (gf_logformat_withmsgid);
-        gf_log_set_loglevel (GF_LOG_INFO);
-
-        /* Run tests with logger changed to syslog */
-        /* TEST 7: No more gluster logs */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logger (gf_logger_syslog);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 8: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 9: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        // TODO: signal crash prints, but not yet feasible here
-        // TODO: Graph printing
-        // TODO: Multi threaded logging
-
-        /* Close out the logging */
-        gf_log_fini (ctx);
-        gf_log_globals_fini ();
-
-        unlink (GF_LOG_CONTROL_FILE);
-        unlink (TEST_FILENAME);
-
-        return 0;
+    int ret = -1;
+
+    unlink(GF_LOG_CONTROL_FILE);
+    creat(GF_LOG_CONTROL_FILE, O_RDONLY);
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return -1;
+
+    ret = glusterfs_globals_init(ctx);
+    if (ret) {
+        printf("Error from glusterfs_globals_init [%s]\n", strerror(errno));
+        return ret;
+    }
+
+    /* Pre init test, message should not be printed */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
+
+    THIS->ctx = ctx;
+
+    /* TEST 1: messages before initializing the log, goes to stderr
+     * and syslog based on criticality */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 2: messages post initialization, goes to glusterlog and
+     * syslog based on severity */
+    ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
+    if (ret != 0) {
+        printf("Error from gf_log_init [%s]\n", strerror(errno));
+        return -1;
+    }
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 3: Test rotation */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_logrotate(0);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 4: Check flush, nothing noticeable should occur :) */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_flush();
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 5: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 6: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* Reset to run with syslog */
+    gf_log_set_logformat(gf_logformat_withmsgid);
+    gf_log_set_loglevel(ctx, GF_LOG_INFO);
+
+    /* Run tests with logger changed to syslog */
+    /* TEST 7: No more gluster logs */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logger(gf_logger_syslog);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 8: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 9: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    // TODO: signal crash prints, but not yet feasible here
+    // TODO: Graph printing
+    // TODO: Multi threaded logging
+
+    /* Close out the logging */
+    gf_log_fini(ctx);
+    gf_log_globals_fini();
+
+    unlink(GF_LOG_CONTROL_FILE);
+    unlink(TEST_FILENAME);
+
+    return 0;
 }
diff --git a/tests/basic/md-cache/bug-1418249.t b/tests/basic/md-cache/bug-1418249.t
index 119a6aecf80..85a4f58ec10 100755
--- a/tests/basic/md-cache/bug-1418249.t
+++ b/tests/basic/md-cache/bug-1418249.t
@@ -16,5 +16,5 @@ EXPECT '600' volinfo_field $V0 'performance.md-cache-timeout'
 EXPECT 'on' volinfo_field $V0 'performance.stat-prefetch'
 EXPECT '600' volinfo_field $V0 'features.cache-invalidation-timeout'
 EXPECT 'on' volinfo_field $V0 'features.cache-invalidation'
-EXPECT '50000' volinfo_field $V0  'network.inode-lru-limit'
+EXPECT '200000' volinfo_field $V0  'network.inode-lru-limit'
 cleanup;
diff --git a/tests/basic/meta.t b/tests/basic/meta.t
index 55ca005824b..0bac3c6797d 100755
--- a/tests/basic/meta.t
+++ b/tests/basic/meta.t
@@ -9,7 +9,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 4 $H0:$B0/${V0}{1..16};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1..9};
 
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
diff --git a/tests/basic/metadisp/fsyncdir.c b/tests/basic/metadisp/fsyncdir.c
new file mode 100644
index 00000000000..62b532b9ce4
--- /dev/null
+++ b/tests/basic/metadisp/fsyncdir.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <fcntl.h>
+
+int
+main(int argc, char **argv)
+{
+    int pfd;
+
+    pfd = open(argv[1], O_RDONLY | O_DIRECTORY);
+    if (pfd == (-1)) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
+
+    if (rename(argv[2], argv[3]) == (-1)) {
+        perror("rename");
+        return EXIT_FAILURE;
+    }
+
+    if (fsync(pfd) == (-1)) {
+        perror("fsync");
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/tests/basic/metadisp/ftruncate.c b/tests/basic/metadisp/ftruncate.c
new file mode 100644
index 00000000000..c9185212c31
--- /dev/null
+++ b/tests/basic/metadisp/ftruncate.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <fcntl.h>
+
+int
+main(int argc, char **argv)
+{
+    int pfd;
+
+    pfd = open(argv[1], O_RDWR);
+    if (pfd == (-1)) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
+
+    if (ftruncate(pfd, 0) == (-1)) {
+        perror("ftruncate");
+        return EXIT_FAILURE;
+    }
+
+    if (write(pfd, "hello", 5) == (-1)) {
+        perror("write");
+        return EXIT_FAILURE;
+    }
+
+    if (fsync(pfd) == (-1)) {
+        perror("fsync");
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/tests/basic/metadisp/fxattr.c b/tests/basic/metadisp/fxattr.c
new file mode 100644
index 00000000000..e552057778a
--- /dev/null
+++ b/tests/basic/metadisp/fxattr.c
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/xattr.h>
+
+static char MY_XATTR[] = "user.fxtest";
+static char *PROGRAM;
+#define CONSUME(v)                                                             \
+    do {                                                                       \
+        if (!argc) {                                                           \
+            fprintf(stderr, "missing argument\n");                             \
+            return EXIT_FAILURE;                                               \
+        }                                                                      \
+        v = argv[0];                                                           \
+        ++argv;                                                                \
+        --argc;                                                                \
+    } while (0)
+
+static int
+do_get(int argc, char **argv, int fd)
+{
+    char *value;
+    int ret;
+    char buf[1024];
+
+    CONSUME(value);
+
+    ret = fgetxattr(fd, MY_XATTR, buf, sizeof(buf));
+    if (ret == (-1)) {
+        perror("fgetxattr");
+        return EXIT_FAILURE;
+    }
+
+    if (strncmp(buf, value, ret) != 0) {
+        fprintf(stderr, "data mismatch\n");
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
+
+static int
+do_set(int argc, char **argv, int fd)
+{
+    char *value;
+    int ret;
+
+    CONSUME(value);
+
+    ret = fsetxattr(fd, MY_XATTR, value, strlen(value), 0);
+    if (ret == (-1)) {
+        perror("fsetxattr");
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
+
+static int
+do_remove(int argc, char **argv, int fd)
+{
+    int ret;
+
+    ret = fremovexattr(fd, MY_XATTR);
+    if (ret == (-1)) {
+        perror("femovexattr");
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
+
+int
+main(int argc, char **argv)
+{
+    int fd;
+    char *path;
+    char *cmd;
+
+    CONSUME(PROGRAM);
+    CONSUME(path);
+    CONSUME(cmd);
+
+    fd = open(path, O_RDWR);
+    if (fd == (-1)) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
+
+    if (strcmp(cmd, "get") == 0) {
+        return do_get(argc, argv, fd);
+    }
+
+    if (strcmp(cmd, "set") == 0) {
+        return do_set(argc, argv, fd);
+    }
+
+    if (strcmp(cmd, "remove") == 0) {
+        return do_remove(argc, argv, fd);
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/tests/basic/metadisp/gfs-fsetxattr.c b/tests/basic/metadisp/gfs-fsetxattr.c
new file mode 100644
index 00000000000..63578bc528f
--- /dev/null
+++ b/tests/basic/metadisp/gfs-fsetxattr.c
@@ -0,0 +1,141 @@
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int gfapi = 1;
+
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    char *basename = NULL;
+    char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
+    struct stat sb = {
+        0,
+    };
+
+    if (argc != 5) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file> <basename>\n",
+            argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    logfile = argv[3];
+    basename = argv[4];
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = asprintf(&dir1, "%s-dir", basename);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+        return ret;
+    }
+
+    ret = glfs_mkdir(fs, dir1, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir(%s): %s\n", dir1, strerror(errno));
+        return -1;
+    }
+
+    fd = glfs_opendir(fs, dir1);
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_fsetxattr(fd, "user.dirfattr", "fsetxattr", 9, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret, strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_closedir(fd);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_closedir failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = asprintf(&filename1, "%s-file", basename);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+        return ret;
+    }
+
+    ret = asprintf(&filename2, "%s-file-renamed", basename);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+        return ret;
+    }
+
+    fd = glfs_creat(fs, filename1, O_RDWR, 0644);
+    if (!fd) {
+        fprintf(stderr, "%s: (%p) %s\n", filename1, fd, strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_rename(fs, filename1, filename2);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_rename failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_lstat(fs, filename2, &sb);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_lstat failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_fsetxattr(fd, "user.filefattr", "fsetxattr", 9, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret, strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_close(fd);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_close failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+}
diff --git a/tests/basic/metadisp/metadisp.t b/tests/basic/metadisp/metadisp.t
new file mode 100644
index 00000000000..894ffe07226
--- /dev/null
+++ b/tests/basic/metadisp/metadisp.t
@@ -0,0 +1,316 @@
+#!/usr/bin/env bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+
+# Considering `--enable-metadisp` is an option for `./configure`,
+# which is disabled by default, this test will never pass regression.
+# But to see the value of this test, run below after configuring
+# with above option :
+# `prove -vmfe '/bin/bash' tests/basic/metadisp/metadisp.t`
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST
+
+cleanup;
+
+TEST mkdir -p $B0/b0/{0,1}
+
+TEST setfattr -n trusted.glusterfs.volume-id -v 0xddab9eece7b64a95b07351a1f748f56f ${B0}/b0/0
+TEST setfattr -n trusted.glusterfs.volume-id -v 0xddab9eece7b64a95b07351a1f748f56f ${B0}/b0/1
+
+TEST $GFS --volfile=$(dirname $0)/metadisp.vol --volfile-id=$V0 $M0;
+
+NUM_FILES=40
+TEST touch $M0/{1..${NUM_FILES}}
+
+# each drive should get 40 files
+TEST [ $(dir -1 $B0/b0/0/ | wc -l) -eq $NUM_FILES ]
+TEST [ $(dir -1 $B0/b0/1/ | wc -l) -eq $NUM_FILES ]
+
+# now write some data to a file
+echo "hello" > $M0/3
+filename=$$
+echo "hello" > /tmp/metadisp-write-${filename}
+checksum=$(md5sum /tmp/metadisp-write-${filename} | awk '{print $1}')
+TEST [ "$(md5sum $M0/3 | awk '{print $1}')" == "$checksum" ]
+
+# check that the backend file exists on b1
+gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/b0/*/3))
+TEST [ $(dir -1 $B0/b0/1/$gfid | wc -l) -eq 1 ]
+
+# check that the backend file matches the frontend
+TEST [ "$(md5sum $B0/b0/1/$gfid | awk '{print $1}')" == "$checksum" ]
+
+# delete the file
+TEST rm $M0/3
+
+# ensure the frontend and backend files are cleaned up
+TEST ! -e $M0/3
+TEST ! [ stat $B0/b*/*/$gfid ]
+
+# Test TRUNCATE + WRITE flow
+echo "hello" | tee $M0/4
+echo "goo"   | tee $M0/4
+filename=$$
+echo "goo" | tee /tmp/metadisp-truncate-${filename}
+checksum=$(md5sum /tmp/metadisp-truncate-${filename} | awk '{print $1}')
+TEST [ "$(md5sum $M0/4 | awk '{print $1}')" == "$checksum" ]
+
+# Test mkdir + rmdir.
+TEST mkdir $M0/rmdir_me
+nfiles=$(ls -d $B0/b*/*/rmdir_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+TEST rmdir $M0/rmdir_me
+nfiles=$(ls -d $B0/b*/*/rmdir_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+
+# Test rename.
+TEST touch $M0/rename_me
+nfiles=$(ls $B0/b*/*/rename_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+nfiles=$(ls $B0/b*/*/such_rename 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+TEST mv $M0/rename_me $M0/such_rename
+nfiles=$(ls $B0/b*/*/rename_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+nfiles=$(ls $B0/b*/*/such_rename 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+
+# Test rename of a file that doesn't exist.
+TEST ! mv $M0/does-not-exist $M0/neither-does-this
+
+
+# cleanup all the other files.
+TEST rm -v $M0/1 $M0/2 $M0/{4..${NUM_FILES}}
+TEST rm $M0/such_rename
+TEST [ $(ls /d/backends/b0/0/ | wc -l) -eq 0 ]
+TEST [ $(ls /d/backends/b0/1/ | wc -l) -eq 0 ]
+
+# Test CREATE flow
+NUM_FILES=40
+TEST touch $M0/{1..${NUM_FILES}}
+TEST [ $(ls /d/backends/b0/0/ | wc -l) -eq $NUM_FILES ]
+TEST [ $(ls /d/backends/b0/1/ | wc -l) -eq $NUM_FILES ]
+
+# Test UNLINK flow
+# No drives should have any files
+TEST rm -v $M0/{1..${NUM_FILES}}
+TEST [ $(ls /d/backends/b0/0/ | wc -l) -eq 0 ]
+TEST [ $(ls /d/backends/b0/1/ | wc -l) -eq 0 ]
+
+# Test CREATE + WRITE + READ flow
+filename=$$
+dd if=/dev/urandom of=/tmp/${filename} bs=1M count=10
+checksum=$(md5sum /tmp/${filename} | awk '{print $1}')
+TEST cp -v /tmp/${filename} $M0/1
+TEST cp -v /tmp/${filename} $M0/2
+TEST cp -v /tmp/${filename} $M0/3
+TEST cp -v /tmp/${filename} $M0/4
+TEST [ "$(md5sum $M0/1 | awk '{print $1}')" == "$checksum" ]
+TEST [ "$(md5sum $M0/2 | awk '{print $1}')" == "$checksum" ]
+TEST [ "$(md5sum $M0/3 | awk '{print $1}')" == "$checksum" ]
+TEST [ "$(md5sum $M0/4 | awk '{print $1}')" == "$checksum" ]
+
+# Test TRUNCATE + WRITE flow
+TEST dd if=/dev/zero of=$M0/1 bs=1M count=20
+
+# Check that readdir stats the files properly and we get the correct sizes
+TEST [ $(find $M0 -size +9M | wc -l) -eq 4 ];
+
+# Test mkdir + rmdir.
+TEST mkdir $M0/rmdir_me
+nfiles=$(ls -d $B0/b*/*/rmdir_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+TEST rmdir $M0/rmdir_me
+nfiles=$(ls -d $B0/b*/*/rmdir_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+
+# Test rename.
+# Still flaky, so disabled until it can be debugged.
+TEST touch $M0/rename_me
+nfiles=$(ls $B0/b*/*/rename_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+nfiles=$(ls $B0/b*/*/such_rename 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+TEST mv $M0/rename_me $M0/such_rename
+nfiles=$(ls $B0/b*/*/rename_me 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "0" ]
+nfiles=$(ls $B0/b*/*/such_rename 2> /dev/null | wc -l)
+TEST [ "$nfiles" = "1" ]
+
+# Test rename of a file that doesn't exist.
+TEST ! mv $M0/does-not-exist $M0/neither-does-this
+
+# Test rename over an existing file.
+ok=yes
+for i in $(seq 0 9); do
+        echo foo > $M0/src$i
+        echo bar > $M0/dst$i
+done
+for i in $(seq 0 9); do
+        mv $M0/src$i $M0/dst$i
+done
+for i in $(seq 0 9); do
+        nfiles=$(cat $B0/b0/*/dst$i | wc -l)
+        if [ "$nfiles" = "2" ]; then
+                echo "COLLISION on dst$i"
+                (ls -l $B0/b0/*/dst$i; cat $B0/b0/*/dst$i) | sed "/^/s//  /"
+                ok=no
+        fi
+done
+EXPECT "yes" echo $ok
+
+# Test rename of a directory.
+count_copies () {
+        ls -d $B0/b?/?/$1 2> /dev/null | wc -l
+}
+TEST mkdir $M0/foo_dir
+EXPECT 1 count_copies foo_dir
+EXPECT 0 count_copies bar_dir
+TEST mv $M0/foo_dir $M0/bar_dir
+EXPECT 0 count_copies foo_dir
+EXPECT 1 count_copies bar_dir
+
+for x in $(seq 0 99); do
+        touch $M0/target$x
+        ln -s $M0/target$x $M0/link$x
+done
+on_0=$(ls $B0/b*/0/link* | wc -l)
+on_1=$(ls $B0/b*/1/link* | wc -l)
+TEST [ "$on_0" -eq 100 ]
+TEST [ "$on_1" -eq 0 ]
+TEST [ "$(ls -l $M0/link* | wc -l)" = 100 ]
+
+# Test (hard) link.
+_test_hardlink () {
+        local b
+        local has_src
+        local has_dst
+        local src_inum
+        local dst_inum
+        touch $M0/hardsrc$1
+        ln $M0/hardsrc$1 $M0/harddst$1
+        for b in $B0/b{0}/{0,1}; do
+                [ -f $b/hardsrc$1 ]; has_src=$?
+                [ -f $b/harddst$1 ]; has_dst=$?
+                if [ "$has_src" != "$has_dst" ]; then
+                        echo "MISSING $b/hardxxx$1 $has_src $has_dst"
+                        return
+                fi
+                if [ "$has_src$has_dst" = "00" ]; then
+                        src_inum=$(stat -c '%i' $b/hardsrc$1)
+                        dst_inum=$(stat -c '%i' $b/harddst$1)
+                        if [ "$dst_inum" != "$src_inum" ]; then
+                                echo "MISMATCH $b/hardxx$i $src_inum $dst_inum"
+                                return
+                        fi
+                fi
+        done
+        echo "OK"
+}
+
+test_hardlink () {
+        local result=$(_test_hardlink $*)
+        # [ "$result" = "OK" ] || echo $result > /dev/tty
+        echo $result
+}
+
+# Do this multiple times to make sure colocation isn't a fluke.
+EXPECT "OK" test_hardlink 0
+EXPECT "OK" test_hardlink 1
+EXPECT "OK" test_hardlink 2
+EXPECT "OK" test_hardlink 3
+EXPECT "OK" test_hardlink 4
+EXPECT "OK" test_hardlink 5
+EXPECT "OK" test_hardlink 6
+EXPECT "OK" test_hardlink 7
+EXPECT "OK" test_hardlink 8
+EXPECT "OK" test_hardlink 9
+
+# Test remove hardlink source. ensure deleting one file
+# doesn't delete the data unless link-count is 1
+TEST mkdir $M0/hardlink
+TEST touch $M0/hardlink/fileA
+echo "data" >> $M0/hardlink/fileA
+checksum=$(md5sum $M0/hardlink/fileA | awk '{print $1}')
+TEST ln $M0/hardlink/fileA $M0/hardlink/fileB
+TEST [ $(dir -1 $M0/hardlink/ | wc -l) -eq 2 ]
+TEST rm $M0/hardlink/fileA
+TEST [ $(dir -1 $M0/hardlink/ | wc -l) -eq 1 ]
+TEST [ "$(md5sum $M0/hardlink/fileB | awk '{print $1}')" == "$checksum" ]
+
+#
+# FIXME: statfs values look ok but the test is bad
+#
+# Test statfs. If we're doing it right, the numbers for the mountpoint should be
+# double those for the brick filesystem times the number of bricks,
+# but unless we're on a completely idle
+# system (which never happens) the numbers can change even while this function
+# runs and that would trip us up. Do a sloppy comparison to deal with that.
+#compare_fields () {
+#       val1=$(df $1 | grep / | awk "{print \$$3}")
+#        val2=$(df $2 | grep / | awk "{print \$$3}")
+#       [ "$val2" -gt "$(((val1/(29/10))*19/10))" -a "$val2" -lt "$(((val1/(31/10))*21/10))" ]
+#}
+
+#brick_df=$(df $B0 | grep /)
+#mount_df=$(df $M0 | grep /)
+#TEST compare_fields $B0 $M0 2       # Total blocks
+#TEST compare_fields $B0 $M0 3       # Used
+#TEST compare_fields $B0 $M0 4       # Available
+
+# Test removexattr.
+#RXATTR_FILE=$(get_file_not_on_disk0 rxtest)
+#TEST setfattr -n user.foo -v bar $M0/$RXATTR_FILE
+#TEST getfattr -n user.foo $B0/b0/1/$RXATTR_FILE
+#TEST setfattr -x user.foo $M0/$RXATTR_FILE
+#TEST ! getfattr -n user.foo $B0/b0/1/$RXATTR_FILE
+
+# Test fsyncdir. We can't really test whether it's doing the right thing,
+# but we can test that it doesn't fail and we can hand-check that it's calling
+# down to all of the disks instead of just one.
+#
+# P.S. There's no fsyncdir test in the rest of Gluster, so who even knows if
+# other translators are handling it correctly?
+
+#FSYNCDIR_EXE=$(dirname $0)/fsyncdir
+#build_tester ${FSYNCDIR_EXE}.c
+#TEST touch $M0/fsyncdir_src
+#TEST $FSYNCDIR_EXE $M0 $M0/fsyncdir_src $M0/fsyncdir_dst
+#TEST rm -f $FSYNCDIR_EXE
+
+# Test fsetxattr, fgetxattr, fremovexattr (in that order).
+FXATTR_FILE=$M0/fxfile1
+TEST touch $FXATTR_FILE
+FXATTR_EXE=$(dirname $0)/fxattr
+build_tester ${FXATTR_EXE}.c
+TEST ! getfattr -n user.fxtest $FXATTR_FILE
+TEST $FXATTR_EXE $FXATTR_FILE set value1
+TEST getfattr -n user.fxtest $FXATTR_FILE
+TEST setfattr -n user.fxtest -v value2 $FXATTR_FILE
+TEST $FXATTR_EXE $FXATTR_FILE get value2
+TEST $FXATTR_EXE $FXATTR_FILE remove
+TEST ! getfattr -n user.fxtest $FXATTR_FILE
+TEST rm -f $FXATTR_EXE
+
+# Test ftruncate
+FTRUNCATE_EXE=$(dirname $0)/ftruncate
+build_tester ${FTRUNCATE_EXE}.c
+FTRUNCATE_FILE=$M0/ftfile1
+TEST dd if=/dev/urandom of=$FTRUNCATE_FILE count=1 bs=1MB 
+TEST $FTRUNCATE_EXE $FTRUNCATE_FILE
+#gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/b0/*/ftfile1))
+
+# Test fallocate, discard, zerofill. Actually we don't so much check that these
+# *work* as that they don't throw any errors (especially ENOENT because the
+# file's not on disk zero).
+FALLOC_FILE=fatest1
+TEST touch $M0/$FALLOC_FILE
+TEST fallocate -l $((4096*5)) $M0/$FALLOC_FILE
+TEST fallocate -p -o 4096 -l 4096 $M0/$FALLOC_FILE
+# This actually fails with "operation not supported" on most filesystems, so
+# don't leave it enabled except to test changes.
+#TEST fallocate -z -o $((4096*3)) -l 4096 $M0/$FALLOC_FILE
+
+#cleanup;
diff --git a/tests/basic/metadisp/metadisp.vol b/tests/basic/metadisp/metadisp.vol
new file mode 100644
index 00000000000..58ae2f6f2a8
--- /dev/null
+++ b/tests/basic/metadisp/metadisp.vol
@@ -0,0 +1,14 @@
+volume posix-0
+  type storage/posix
+  option directory /d/backends/b0/0
+end-volume
+
+volume posix-1
+  type storage/posix
+  option directory /d/backends/b0/1
+end-volume
+
+volume metadisp-0
+  type features/metadisp
+  subvolumes posix-0 posix-1
+end-volume
diff --git a/tests/basic/mount-options.disabled b/tests/basic/mount-options.disabled
index 2373e4461ce..a04c8686276 100644
--- a/tests/basic/mount-options.disabled
+++ b/tests/basic/mount-options.disabled
@@ -127,6 +127,9 @@ EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --volfile-server-transport=ib-verbs
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --auto-invalidation=off
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
 TEST ! glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --volfile-server-port=socket
 
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --volume-name=$V0
diff --git a/tests/basic/mount.t b/tests/basic/mount.t
index 52e760d048d..3a3d7cc9d8d 100755
--- a/tests/basic/mount.t
+++ b/tests/basic/mount.t
@@ -3,15 +3,16 @@
 . $(dirname $0)/../include.rc
 . $(dirname $0)/../nfs.rc
 
-cleanup;
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
 
+cleanup;
 
 ## Start and create a volume
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6,7,8,9};
 TEST $CLI volume set $V0 nfs.disable false
 
 function volinfo_field()
@@ -68,6 +69,9 @@ TEST rm -f $N0/newfile;
 TEST ! stat $M0/newfile;
 TEST ! stat $M1/newfile;
 
+# No need to check for status here right now
+$(dirname $0)/rpc-coverage.sh $N0 >/dev/null
+
 ## Before killing daemon to avoid deadlocks
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
 
diff --git a/tests/basic/mpx-compat.t b/tests/basic/mpx-compat.t
index 4ca262ee349..baf629dbf9b 100644
--- a/tests/basic/mpx-compat.t
+++ b/tests/basic/mpx-compat.t
@@ -15,16 +15,22 @@ function count_processes {
 	pgrep glusterfsd | wc -w
 }
 
+function count_brick_pids {
+        $CLI --xml volume status all | sed -n '/.*<pid>\([^<]*\).*/s//\1/p' \
+                                     | grep -v "N/A" | sort | uniq | wc -l
+}
+
 cleanup
 TEST glusterd
 TEST $CLI volume set all cluster.brick-multiplex yes
-push_trapfunc "$CLI volume set all cluster.brick-multiplex off"
-push_trapfunc "cleanup"
 
 # Create two vanilla volumes.
 TEST $CLI volume create $V0 $H0:$B0/brick-${V0}-{0,1}
 TEST $CLI volume create $V1 $H0:$B0/brick-${V1}-{0,1}
 
+# Enable brick log-level to DEBUG
+gluster v set $V0 diagnostics.brick-log-level DEBUG
+
 # Start both.
 TEST $CLI volume start $V0
 TEST $CLI volume start $V1
@@ -34,6 +40,7 @@ TEST $CLI volume start $V1
 # coming up, and yield a false positive.
 sleep $PROCESS_UP_TIMEOUT
 EXPECT "1" count_processes
+EXPECT 1 count_brick_pids
 
 # Make the second volume incompatible with the first.
 TEST $CLI volume stop $V1
@@ -42,3 +49,5 @@ TEST $CLI volume start $V1
 
 # There should be two processes this time (can't share protocol/server).
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" count_processes
+
+cleanup;
+\ No newline at end of file
diff --git a/tests/basic/multiple-volume-shd-mux.t b/tests/basic/multiple-volume-shd-mux.t
new file mode 100644
index 00000000000..d7cfbaec85f
--- /dev/null
+++ b/tests/basic/multiple-volume-shd-mux.t
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TESTS_EXPECTED_IN_LOOP=16
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume start $V0
+
+shd_pid=$(get_shd_mux_pid $V0)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+for i in $(seq 1 3); do
+   TEST $CLI volume create ${V0}_afr$i replica 3 $H0:$B0/${V0}_afr${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_afr$i
+   TEST $CLI volume create ${V0}_ec$i disperse 6 redundancy 2 $H0:$B0/${V0}_ec${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_ec$i
+done
+
+#Check the thread count become to number of volumes*number of ec subvolume (3*6=18)
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^18$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to number of volumes*number of afr subvolume (4*6=24)
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^24$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+#Delete the volumes
+for i in $(seq 1 3); do
+   TEST $CLI volume stop ${V0}_afr$i
+   TEST $CLI volume stop ${V0}_ec$i
+   TEST $CLI volume delete ${V0}_afr$i
+   TEST $CLI volume delete ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $CLI volume stop ${V0}
+TEST $CLI volume delete ${V0}
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+
+cleanup
diff --git a/tests/basic/multiplex.t b/tests/basic/multiplex.t
index 2f0f462f14d..2f558a6824b 100644
--- a/tests/basic/multiplex.t
+++ b/tests/basic/multiplex.t
@@ -21,8 +21,6 @@ cleanup
 
 TEST glusterd
 TEST $CLI volume set all cluster.brick-multiplex on
-push_trapfunc "$CLI volume set all cluster.brick-multiplex off"
-push_trapfunc "cleanup"
 
 TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
 TEST $CLI volume set $V0 features.trash enable
@@ -77,3 +75,4 @@ TEST glusterd
 EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 1 count_brick_pids
 EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 1 count_brick_processes
 
+cleanup;
+\ No newline at end of file
diff --git a/tests/basic/namespace.t b/tests/basic/namespace.t
new file mode 100644
index 00000000000..d1bbe7eea29
--- /dev/null
+++ b/tests/basic/namespace.t
@@ -0,0 +1,131 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../nfs.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
+# These hashes are a result of calling SuperFastHash
+# on the corresponding folder names.
+NAMESPACE_HASH=28153613
+NAMESPACE2_HASH=3926991974
+NAMESPACE3_HASH=3493960770
+
+function check_brick_multiplex() {
+        local ret=$($CLI volume info|grep "cluster.brick-multiplex"|cut -d" " -f2)
+        local cnt="$(ls /var/log/glusterfs/bricks|wc -l)"
+        local bcnt="$(brick_count)"
+
+        if [ $bcnt -ne 1 ]; then
+           if [ -z $ret ]; then
+              ret="no"
+           fi
+
+           if [ $ret = "on" ] || [ $cnt -eq 1 ]; then
+              echo "Y"
+           else
+              echo "N"
+           fi
+        else
+           echo "N"
+        fi
+}
+
+function check_samples() {
+        local FOP_TYPE=$1
+        local NS_HASH=$2
+        local FILE=$3
+        local BRICK=$4
+        local GFID="$(getfattr -n trusted.gfid -e text --only-values $B0/$BRICK$FILE | xxd -p)"
+        local val="$(check_brick_multiplex)"
+
+        if [ $val = "Y" ]; then
+           BRICK="${V0}0"
+        fi
+
+        grep -i "ns_$OP" /var/log/glusterfs/bricks/d-backends-$BRICK.log |
+             grep -- $NS_HASH | sed 's/\-//g' | grep -- $GFID
+        if [ $? -eq 0 ]; then
+          echo "Y"
+         else
+          echo "N"
+        fi
+}
+
+cleanup;
+
+TEST mkdir -p $B0/${V0}{0,1,2,3,4,5,6,7,8,9}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5,6,7,8}
+TEST $CLI volume set $V0 nfs.disable off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.nfs.stat-prefetch off
+TEST $CLI volume set $V0 cluster.read-subvolume-index 0
+TEST $CLI volume set $V0 diagnostics.brick-log-level DEBUG
+TEST $CLI volume set $V0 features.tag-namespaces on
+TEST $CLI volume set $V0 storage.build-pgfid on
+TEST $CLI volume start $V0
+
+sleep 2
+
+TEST mount_nfs $H0:/$V0 $N0 nolock;
+
+################################
+# Paths in the samples #
+################################
+
+mkdir -p $N0/namespace
+
+# subvol_1 = bar, subvol_2 = foo, subvol_3 = hey
+# Test create, write (tagged by loc, fd respectively).
+touch $N0/namespace/{bar,foo,hey}
+echo "garbage" > $N0/namespace/bar
+echo "garbage" > $N0/namespace/foo
+echo "garbage" > $N0/namespace/hey
+EXPECT_WITHIN 10 "Y" check_samples CREATE $NAMESPACE_HASH /namespace/bar patchy0
+EXPECT_WITHIN 10 "Y" check_samples CREATE $NAMESPACE_HASH /namespace/foo patchy3
+EXPECT_WITHIN 10 "Y" check_samples CREATE $NAMESPACE_HASH /namespace/hey patchy6
+EXPECT_WITHIN 10 "Y" check_samples WRITEV $NAMESPACE_HASH /namespace/bar patchy0
+EXPECT_WITHIN 10 "Y" check_samples WRITEV $NAMESPACE_HASH /namespace/foo patchy3
+EXPECT_WITHIN 10 "Y" check_samples WRITEV $NAMESPACE_HASH /namespace/hey patchy6
+
+# Test stat (tagged by loc)
+stat $N0/namespace/bar &> /dev/null
+stat $N0/namespace/foo &> /dev/null
+stat $N0/namespace/hey &> /dev/null
+EXPECT_WITHIN 10 "Y" check_samples STAT $NAMESPACE_HASH /namespace/bar patchy0
+EXPECT_WITHIN 10 "Y" check_samples STAT $NAMESPACE_HASH /namespace/foo patchy3
+EXPECT_WITHIN 10 "Y" check_samples STAT $NAMESPACE_HASH /namespace/hey patchy6
+
+EXPECT_WITHIN 10 "Y" umount_nfs $N0;
+sleep 1
+TEST mount_nfs $H0:/$V0 $N0 nolock;
+
+cat $N0/namespace/bar &> /dev/null
+EXPECT_WITHIN 10 "Y" check_samples READ $NAMESPACE_HASH /namespace/bar patchy0
+
+dir $N0/namespace &> /dev/null
+EXPECT_WITHIN 10 "Y" check_samples LOOKUP $NAMESPACE_HASH /namespace patchy0
+
+mkdir -p $N0/namespace{2,3}
+EXPECT_WITHIN 10 "Y" check_samples MKDIR $NAMESPACE2_HASH /namespace2 patchy0
+EXPECT_WITHIN 10 "Y" check_samples MKDIR $NAMESPACE3_HASH /namespace3 patchy0
+
+touch $N0/namespace2/file
+touch $N0/namespace3/file
+EXPECT_WITHIN 10 "Y" check_samples CREATE $NAMESPACE2_HASH /namespace2/file patchy0
+EXPECT_WITHIN 10 "Y" check_samples CREATE $NAMESPACE3_HASH /namespace3/file patchy0
+
+truncate -s 0 $N0/namespace/bar
+EXPECT_WITHIN 10 "Y" check_samples TRUNCATE $NAMESPACE_HASH /namespace/bar patchy0
+
+ln -s $N0/namespace/foo $N0/namespace/foo_link
+EXPECT_WITHIN 10 "Y" check_samples SYMLINK $NAMESPACE_HASH /namespace/foo patchy3
+
+open $N0/namespace/hey
+EXPECT_WITHIN 10 "Y" check_samples OPEN $NAMESPACE_HASH /namespace/hey patchy6
+
+cleanup;
diff --git a/tests/basic/nl-cache.t b/tests/basic/nl-cache.t
index 2979a9be0d4..90c778c8a88 100755
--- a/tests/basic/nl-cache.t
+++ b/tests/basic/nl-cache.t
@@ -15,7 +15,7 @@ EXPECT '600' volinfo_field $V0 'performance.nl-cache-timeout'
 EXPECT 'on' volinfo_field $V0 'performance.nl-cache'
 EXPECT '600' volinfo_field $V0 'features.cache-invalidation-timeout'
 EXPECT 'on' volinfo_field $V0 'features.cache-invalidation'
-EXPECT '50000' volinfo_field $V0  'network.inode-lru-limit'
+EXPECT '200000' volinfo_field $V0  'network.inode-lru-limit'
 TEST $CLI volume set $V0 nl-cache-positive-entry on
 
 TEST $CLI volume start $V0;
@@ -64,5 +64,35 @@ TEST rm $M0/dir1/file_link
 TEST rmdir $M0/dir1/dir2
 TEST rmdir $M0/dir1
 
+#Check mknod
+TEST ! ls -l $M0/dir
+TEST mkdir $M0/dir
+TEST mknod -m 0666 $M0/dir/block b 4 5
+TEST mknod -m 0666 $M0/dir/char c 1 5
+TEST mknod -m 0666 $M0/dir/fifo p
+TEST rm $M0/dir/block
+TEST rm $M0/dir/char
+TEST rm $M0/dir/fifo
+
+#Check getxattr
+TEST touch $M0/file1
+TEST getfattr -d -m. -e hex $M0/file1
+TEST getfattr -n "glusterfs.get_real_filename:file1" $M0;
+TEST getfattr -n "glusterfs.get_real_filename:FILE1" $M0;
+TEST ! getfattr -n "glusterfs.get_real_filename:FILE2" $M0;
+
+#Check statedump
+TEST generate_mount_statedump $V0 $M0
+TEST cleanup_mount_statedump $V0
+
+#Check reconfigure
+TEST $CLI volume reset $V0 nl-cache-timeout
+TEST $CLI volume reset $V0 nl-cache-positive-entry
+TEST $CLI volume reset $V0 nl-cache-limit
+TEST $CLI volume reset $V0 nl-cache-pass-through
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
 cleanup;
 #G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/nufa.t b/tests/basic/nufa.t
index 1d74d376b7d..cb09fc5bbbf 100644
--- a/tests/basic/nufa.t
+++ b/tests/basic/nufa.t
@@ -4,18 +4,20 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 TEST $CLI volume set $V0 nfs.disable false
 
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '8' brick_count $V0
+EXPECT '6' brick_count $V0
 
 TEST $CLI volume set $V0 nufa on;
 
diff --git a/tests/basic/op_errnos.t b/tests/basic/op_errnos.t
index 8b16267cb50..9c48d7a02ad 100755
--- a/tests/basic/op_errnos.t
+++ b/tests/basic/op_errnos.t
@@ -17,8 +17,6 @@ TEST setup_lvm 1
 
 TEST $CLI volume create $V0 $H0:$L1
 TEST $CLI volume start $V0
-TEST $CLI volume create $V1 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-TEST $CLI volume start $V1
 
 EXPECT 0 get-op_errno-xml "snapshot create snap1 $V0 no-timestamp"
 EXPECT 30806 get-op_errno-xml "snapshot create snap1 imaginary_volume"
@@ -29,10 +27,8 @@ EXPECT 30810 get-op_errno-xml "snapshot create snap1 $V0"
 TEST $CLI volume start $V0
 EXPECT 30811 get-op_errno-xml "snapshot clone $V0 snap1"
 EXPECT 30812 get-op_errno-xml "snapshot create snap1 $V0 no-timestamp"
-EXPECT 30815 get-op_errno-xml "snapshot create snap2 $V1 no-timestamp"
 
 EXPECT 0 get-op_errno-xml "snapshot delete snap1"
 TEST $CLI volume stop $V0
-TEST $CLI volume stop $V1
 
 cleanup;
diff --git a/tests/basic/open-behind/open-behind.t b/tests/basic/open-behind/open-behind.t
new file mode 100644
index 00000000000..5e865d602e2
--- /dev/null
+++ b/tests/basic/open-behind/open-behind.t
@@ -0,0 +1,183 @@
+#!/bin/bash
+
+WD="$(dirname "${0}")"
+
+. ${WD}/../../include.rc
+. ${WD}/../../volume.rc
+
+function assign() {
+    local _assign_var="${1}"
+    local _assign_value="${2}"
+
+    printf -v "${_assign_var}" "%s" "${_assign_value}"
+}
+
+function pipe_create() {
+    local _pipe_create_var="${1}"
+    local _pipe_create_name
+    local _pipe_create_fd
+
+    _pipe_create_name="$(mktemp -u)"
+    mkfifo "${_pipe_create_name}"
+    exec {_pipe_create_fd}<>"${_pipe_create_name}"
+    rm "${_pipe_create_name}"
+
+    assign "${_pipe_create_var}" "${_pipe_create_fd}"
+}
+
+function pipe_close() {
+    local _pipe_close_fd="${!1}"
+
+    exec {_pipe_close_fd}>&-
+}
+
+function tester_start() {
+    declare -ag tester
+    local tester_in
+    local tester_out
+
+    pipe_create tester_in
+    pipe_create tester_out
+
+    ${WD}/tester <&${tester_in} >&${tester_out} &
+
+    tester=("$!" "${tester_in}" "${tester_out}")
+}
+
+function tester_send() {
+    declare -ag tester
+    local tester_res
+    local tester_extra
+
+    echo "${*}" >&${tester[1]}
+
+    read -t 3 -u ${tester[2]} tester_res tester_extra
+    echo "${tester_res} ${tester_extra}"
+    if [[ "${tester_res}" == "OK" ]]; then
+        return 0
+    fi
+
+    return 1
+}
+
+function tester_stop() {
+    declare -ag tester
+    local tester_res
+
+    tester_send "quit"
+
+    tester_res=0
+    if ! wait ${tester[0]}; then
+        tester_res=$?
+    fi
+
+    unset tester
+
+    return ${tester_res}
+}
+
+function count_open() {
+    local file="$(realpath "${B0}/${V0}/${1}")"
+    local count="0"
+    local inode
+    local ref
+
+    inode="$(stat -c %i "${file}")"
+
+    for fd in /proc/${BRICK_PID}/fd/*; do
+        ref="$(readlink "${fd}")"
+        if [[ "${ref}" == "${B0}/${V0}/"* ]]; then
+            if [[ "$(stat -c %i "${ref}")" == "${inode}" ]]; then
+                count="$((${count} + 1))"
+            fi
+        fi
+    done
+
+    echo "${count}"
+}
+
+cleanup
+
+TEST build_tester ${WD}/tester.c ${WD}/tester-fd.c
+
+TEST glusterd
+TEST pidof glusterd
+TEST ${CLI} volume create ${V0} ${H0}:${B0}/${V0}
+TEST ${CLI} volume set ${V0} flush-behind off
+TEST ${CLI} volume set ${V0} write-behind off
+TEST ${CLI} volume set ${V0} quick-read off
+TEST ${CLI} volume set ${V0} stat-prefetch on
+TEST ${CLI} volume set ${V0} io-cache off
+TEST ${CLI} volume set ${V0} open-behind on
+TEST ${CLI} volume set ${V0} lazy-open off
+TEST ${CLI} volume set ${V0} read-after-open off
+TEST ${CLI} volume start ${V0}
+
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+BRICK_PID="$(get_brick_pid ${V0} ${H0} ${B0}/${V0})"
+
+TEST touch "${M0}/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+TEST tester_start
+
+TEST tester_send fd open 0 "${M0}/test"
+EXPECT_WITHIN 5 "1" count_open "/test"
+TEST tester_send fd close 0
+EXPECT_WITHIN 5 "0" count_open "/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ${CLI} volume set ${V0} lazy-open on
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+TEST tester_send fd open 0 "${M0}/test"
+sleep 2
+EXPECT "0" count_open "/test"
+TEST tester_send fd write 0 "test"
+EXPECT "1" count_open "/test"
+TEST tester_send fd close 0
+EXPECT_WITHIN 5 "0" count_open "/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+TEST tester_send fd open 0 "${M0}/test"
+EXPECT "0" count_open "/test"
+EXPECT "test" tester_send fd read 0 64
+# Even though read-after-open is disabled, use-anonymous-fd is also disabled,
+# so reads need to open the file first.
+EXPECT "1" count_open "/test"
+TEST tester_send fd close 0
+EXPECT "0" count_open "/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+TEST tester_send fd open 0 "${M0}/test"
+EXPECT "0" count_open "/test"
+TEST tester_send fd open 1 "${M0}/test"
+EXPECT "2" count_open "/test"
+TEST tester_send fd close 0
+EXPECT_WITHIN 5 "1" count_open "/test"
+TEST tester_send fd close 1
+EXPECT_WITHIN 5 "0" count_open "/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST ${CLI} volume set ${V0} read-after-open on
+TEST ${GFS} --volfile-id=/${V0} --volfile-server=${H0} ${M0};
+
+TEST tester_send fd open 0 "${M0}/test"
+EXPECT "0" count_open "/test"
+EXPECT "test" tester_send fd read 0 64
+EXPECT "1" count_open "/test"
+TEST tester_send fd close 0
+EXPECT_WITHIN 5 "0" count_open "/test"
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST tester_stop
+
+cleanup
diff --git a/tests/basic/open-behind/tester-fd.c b/tests/basic/open-behind/tester-fd.c
new file mode 100644
index 00000000000..00f02bc5b0a
--- /dev/null
+++ b/tests/basic/open-behind/tester-fd.c
@@ -0,0 +1,99 @@
+/*
+  Copyright (c) 2020 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#include "tester.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+static int32_t
+fd_open(context_t *ctx, command_t *cmd)
+{
+    obj_t *obj;
+    int32_t fd;
+
+    obj = cmd->args[0].obj.ref;
+
+    fd = open(cmd->args[1].str.data, O_RDWR);
+    if (fd < 0) {
+        return error(errno, "open() failed");
+    }
+
+    obj->type = OBJ_TYPE_FD;
+    obj->fd = fd;
+
+    out_ok("%d", fd);
+
+    return 0;
+}
+
+static int32_t
+fd_close(context_t *ctx, command_t *cmd)
+{
+    obj_t *obj;
+
+    obj = cmd->args[0].obj.ref;
+    obj->type = OBJ_TYPE_NONE;
+
+    if (close(obj->fd) != 0) {
+        return error(errno, "close() failed");
+    }
+
+    out_ok();
+
+    return 0;
+}
+
+static int32_t
+fd_write(context_t *ctx, command_t *cmd)
+{
+    ssize_t len, ret;
+
+    len = strlen(cmd->args[1].str.data);
+    ret = write(cmd->args[0].obj.ref->fd, cmd->args[1].str.data, len);
+    if (ret < 0) {
+        return error(errno, "write() failed");
+    }
+
+    out_ok("%zd", ret);
+
+    return 0;
+}
+
+static int32_t
+fd_read(context_t *ctx, command_t *cmd)
+{
+    char data[cmd->args[1].num.value + 1];
+    ssize_t ret;
+
+    ret = read(cmd->args[0].obj.ref->fd, data, cmd->args[1].num.value);
+    if (ret < 0) {
+        return error(errno, "read() failed");
+    }
+
+    data[ret] = 0;
+
+    out_ok("%zd %s", ret, data);
+
+    return 0;
+}
+
+command_t fd_commands[] = {
+    {"open", fd_open, CMD_ARGS(ARG_VAL(OBJ_TYPE_NONE), ARG_STR(1024))},
+    {"close", fd_close, CMD_ARGS(ARG_VAL(OBJ_TYPE_FD))},
+    {"write", fd_write, CMD_ARGS(ARG_VAL(OBJ_TYPE_FD), ARG_STR(1024))},
+    {"read", fd_read, CMD_ARGS(ARG_VAL(OBJ_TYPE_FD), ARG_NUM(0, 1024))},
+    CMD_END};
diff --git a/tests/basic/open-behind/tester.c b/tests/basic/open-behind/tester.c
new file mode 100644
index 00000000000..b2da71c8385
--- /dev/null
+++ b/tests/basic/open-behind/tester.c
@@ -0,0 +1,444 @@
+/*
+  Copyright (c) 2020 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#include "tester.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+static void *
+mem_alloc(size_t size)
+{
+    void *ptr;
+
+    ptr = malloc(size);
+    if (ptr == NULL) {
+        error(ENOMEM, "Failed to allocate memory (%zu bytes)", size);
+    }
+
+    return ptr;
+}
+
+static void
+mem_free(void *ptr)
+{
+    free(ptr);
+}
+
+static bool
+buffer_create(context_t *ctx, size_t size)
+{
+    ctx->buffer.base = mem_alloc(size);
+    if (ctx->buffer.base == NULL) {
+        return false;
+    }
+
+    ctx->buffer.size = size;
+    ctx->buffer.len = 0;
+    ctx->buffer.pos = 0;
+
+    return true;
+}
+
+static void
+buffer_destroy(context_t *ctx)
+{
+    mem_free(ctx->buffer.base);
+    ctx->buffer.size = 0;
+    ctx->buffer.len = 0;
+}
+
+static int32_t
+buffer_get(context_t *ctx)
+{
+    ssize_t len;
+
+    if (ctx->buffer.pos >= ctx->buffer.len) {
+        len = read(0, ctx->buffer.base, ctx->buffer.size);
+        if (len < 0) {
+            return error(errno, "read() failed");
+        }
+        if (len == 0) {
+            return 0;
+        }
+
+        ctx->buffer.len = len;
+        ctx->buffer.pos = 0;
+    }
+
+    return ctx->buffer.base[ctx->buffer.pos++];
+}
+
+static int32_t
+str_skip_spaces(context_t *ctx, int32_t current)
+{
+    while ((current > 0) && (current != '\n') && isspace(current)) {
+        current = buffer_get(ctx);
+    }
+
+    return current;
+}
+
+static int32_t
+str_token(context_t *ctx, char *buffer, uint32_t size, int32_t current)
+{
+    uint32_t len;
+
+    current = str_skip_spaces(ctx, current);
+
+    len = 0;
+    while ((size > 0) && (current > 0) && (current != '\n') &&
+           !isspace(current)) {
+        len++;
+        *buffer++ = current;
+        size--;
+        current = buffer_get(ctx);
+    }
+
+    if (len == 0) {
+        return error(ENODATA, "Expecting a token");
+    }
+
+    if (size == 0) {
+        return error(ENOBUFS, "Token too long");
+    }
+
+    *buffer = 0;
+
+    return current;
+}
+
+static int32_t
+str_number(context_t *ctx, uint64_t min, uint64_t max, uint64_t *value,
+           int32_t current)
+{
+    char text[32], *ptr;
+    uint64_t num;
+
+    current = str_token(ctx, text, sizeof(text), current);
+    if (current > 0) {
+        num = strtoul(text, &ptr, 0);
+        if ((*ptr != 0) || (num < min) || (num > max)) {
+            return error(ERANGE, "Invalid number");
+        }
+        *value = num;
+    }
+
+    return current;
+}
+
+static int32_t
+str_eol(context_t *ctx, int32_t current)
+{
+    current = str_skip_spaces(ctx, current);
+    if (current != '\n') {
+        return error(EINVAL, "Expecting end of command");
+    }
+
+    return current;
+}
+
+static void
+str_skip(context_t *ctx, int32_t current)
+{
+    while ((current > 0) && (current != '\n')) {
+        current = buffer_get(ctx);
+    }
+}
+
+static int32_t
+cmd_parse_obj(context_t *ctx, arg_t *arg, int32_t current)
+{
+    obj_t *obj;
+    uint64_t id;
+
+    current = str_number(ctx, 0, ctx->obj_count, &id, current);
+    if (current <= 0) {
+        return current;
+    }
+
+    obj = &ctx->objs[id];
+    if (obj->type != arg->obj.type) {
+        if (obj->type != OBJ_TYPE_NONE) {
+            return error(EBUSY, "Object is in use");
+        }
+        return error(ENOENT, "Object is not defined");
+    }
+
+    arg->obj.ref = obj;
+
+    return current;
+}
+
+static int32_t
+cmd_parse_num(context_t *ctx, arg_t *arg, int32_t current)
+{
+    return str_number(ctx, arg->num.min, arg->num.max, &arg->num.value,
+                      current);
+}
+
+static int32_t
+cmd_parse_str(context_t *ctx, arg_t *arg, int32_t current)
+{
+    return str_token(ctx, arg->str.data, arg->str.size, current);
+}
+
+static int32_t
+cmd_parse_args(context_t *ctx, command_t *cmd, int32_t current)
+{
+    arg_t *arg;
+
+    for (arg = cmd->args; arg->type != ARG_TYPE_NONE; arg++) {
+        switch (arg->type) {
+            case ARG_TYPE_OBJ:
+                current = cmd_parse_obj(ctx, arg, current);
+                break;
+            case ARG_TYPE_NUM:
+                current = cmd_parse_num(ctx, arg, current);
+                break;
+            case ARG_TYPE_STR:
+                current = cmd_parse_str(ctx, arg, current);
+                break;
+            default:
+                return error(EINVAL, "Unknown argument type");
+        }
+    }
+
+    if (current < 0) {
+        return current;
+    }
+
+    current = str_eol(ctx, current);
+    if (current <= 0) {
+        return error(EINVAL, "Syntax error");
+    }
+
+    return cmd->handler(ctx, cmd);
+}
+
+static int32_t
+cmd_parse(context_t *ctx, command_t *cmds)
+{
+    char text[32];
+    command_t *cmd;
+    int32_t current;
+
+    cmd = cmds;
+    do {
+        current = str_token(ctx, text, sizeof(text), buffer_get(ctx));
+        if (current <= 0) {
+            return current;
+        }
+
+        while (cmd->name != NULL) {
+            if (strcmp(cmd->name, text) == 0) {
+                if (cmd->handler != NULL) {
+                    return cmd_parse_args(ctx, cmd, current);
+                }
+                cmd = cmd->cmds;
+                break;
+            }
+            cmd++;
+        }
+    } while (cmd->name != NULL);
+
+    str_skip(ctx, current);
+
+    return error(ENOTSUP, "Unknown command");
+}
+
+static void
+cmd_fini(context_t *ctx, command_t *cmds)
+{
+    command_t *cmd;
+    arg_t *arg;
+
+    for (cmd = cmds; cmd->name != NULL; cmd++) {
+        if (cmd->handler == NULL) {
+            cmd_fini(ctx, cmd->cmds);
+        } else {
+            for (arg = cmd->args; arg->type != ARG_TYPE_NONE; arg++) {
+                switch (arg->type) {
+                    case ARG_TYPE_STR:
+                        mem_free(arg->str.data);
+                        arg->str.data = NULL;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+}
+
+static bool
+cmd_init(context_t *ctx, command_t *cmds)
+{
+    command_t *cmd;
+    arg_t *arg;
+
+    for (cmd = cmds; cmd->name != NULL; cmd++) {
+        if (cmd->handler == NULL) {
+            if (!cmd_init(ctx, cmd->cmds)) {
+                return false;
+            }
+        } else {
+            for (arg = cmd->args; arg->type != ARG_TYPE_NONE; arg++) {
+                switch (arg->type) {
+                    case ARG_TYPE_STR:
+                        arg->str.data = mem_alloc(arg->str.size);
+                        if (arg->str.data == NULL) {
+                            return false;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool
+objs_create(context_t *ctx, uint32_t count)
+{
+    uint32_t i;
+
+    ctx->objs = mem_alloc(sizeof(obj_t) * count);
+    if (ctx->objs == NULL) {
+        return false;
+    }
+    ctx->obj_count = count;
+
+    for (i = 0; i < count; i++) {
+        ctx->objs[i].type = OBJ_TYPE_NONE;
+    }
+
+    return true;
+}
+
+static int32_t
+objs_destroy(context_t *ctx)
+{
+    uint32_t i;
+    int32_t err;
+
+    err = 0;
+    for (i = 0; i < ctx->obj_count; i++) {
+        if (ctx->objs[i].type != OBJ_TYPE_NONE) {
+            err = error(ENOTEMPTY, "Objects not destroyed");
+            break;
+        }
+    }
+
+    mem_free(ctx->objs);
+    ctx->objs = NULL;
+    ctx->obj_count = 0;
+
+    return err;
+}
+
+static context_t *
+init(size_t size, uint32_t objs, command_t *cmds)
+{
+    context_t *ctx;
+
+    ctx = mem_alloc(sizeof(context_t));
+    if (ctx == NULL) {
+        goto failed;
+    }
+
+    if (!buffer_create(ctx, size)) {
+        goto failed_ctx;
+    }
+
+    if (!objs_create(ctx, objs)) {
+        goto failed_buffer;
+    }
+
+    if (!cmd_init(ctx, cmds)) {
+        goto failed_objs;
+    }
+
+    ctx->active = true;
+
+    return ctx;
+
+failed_objs:
+    cmd_fini(ctx, cmds);
+    objs_destroy(ctx);
+failed_buffer:
+    buffer_destroy(ctx);
+failed_ctx:
+    mem_free(ctx);
+failed:
+    return NULL;
+}
+
+static int32_t
+fini(context_t *ctx, command_t *cmds)
+{
+    int32_t ret;
+
+    cmd_fini(ctx, cmds);
+    buffer_destroy(ctx);
+
+    ret = objs_destroy(ctx);
+
+    ctx->active = false;
+
+    return ret;
+}
+
+static int32_t
+exec_quit(context_t *ctx, command_t *cmd)
+{
+    ctx->active = false;
+
+    return 0;
+}
+
+static command_t commands[] = {{"fd", NULL, CMD_SUB(fd_commands)},
+                               {"quit", exec_quit, CMD_ARGS()},
+                               CMD_END};
+
+int32_t
+main(int32_t argc, char *argv[])
+{
+    context_t *ctx;
+    int32_t res;
+
+    ctx = init(1024, 16, commands);
+    if (ctx == NULL) {
+        return 1;
+    }
+
+    do {
+        res = cmd_parse(ctx, commands);
+        if (res < 0) {
+            out_err(-res);
+        }
+    } while (ctx->active);
+
+    res = fini(ctx, commands);
+    if (res >= 0) {
+        out_ok();
+        return 0;
+    }
+
+    out_err(-res);
+
+    return 1;
+}
diff --git a/tests/basic/open-behind/tester.h b/tests/basic/open-behind/tester.h
new file mode 100644
index 00000000000..64e940c78fc
--- /dev/null
+++ b/tests/basic/open-behind/tester.h
@@ -0,0 +1,145 @@
+/*
+  Copyright (c) 2020 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#ifndef __TESTER_H__
+#define __TESTER_H__
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdbool.h>
+
+enum _obj_type;
+typedef enum _obj_type obj_type_t;
+
+enum _arg_type;
+typedef enum _arg_type arg_type_t;
+
+struct _buffer;
+typedef struct _buffer buffer_t;
+
+struct _obj;
+typedef struct _obj obj_t;
+
+struct _context;
+typedef struct _context context_t;
+
+struct _arg;
+typedef struct _arg arg_t;
+
+struct _command;
+typedef struct _command command_t;
+
+enum _obj_type { OBJ_TYPE_NONE, OBJ_TYPE_FD };
+
+enum _arg_type { ARG_TYPE_NONE, ARG_TYPE_OBJ, ARG_TYPE_NUM, ARG_TYPE_STR };
+
+struct _buffer {
+    char *base;
+    uint32_t size;
+    uint32_t len;
+    uint32_t pos;
+};
+
+struct _obj {
+    obj_type_t type;
+    union {
+        int32_t fd;
+    };
+};
+
+struct _context {
+    obj_t *objs;
+    buffer_t buffer;
+    uint32_t obj_count;
+    bool active;
+};
+
+struct _arg {
+    arg_type_t type;
+    union {
+        struct {
+            obj_type_t type;
+            obj_t *ref;
+        } obj;
+        struct {
+            uint64_t value;
+            uint64_t min;
+            uint64_t max;
+        } num;
+        struct {
+            uint32_t size;
+            char *data;
+        } str;
+    };
+};
+
+struct _command {
+    const char *name;
+    int32_t (*handler)(context_t *ctx, command_t *cmd);
+    union {
+        arg_t *args;
+        command_t *cmds;
+    };
+};
+
+#define msg(_stream, _fmt, _args...)                                           \
+    do {                                                                       \
+        fprintf(_stream, _fmt "\n", ##_args);                                  \
+        fflush(_stream);                                                       \
+    } while (0)
+
+#define msg_out(_fmt, _args...) msg(stdout, _fmt, ##_args)
+#define msg_err(_err, _fmt, _args...)                                          \
+    ({                                                                         \
+        int32_t __msg_err = (_err);                                            \
+        msg(stderr, "[%4u:%-15s] " _fmt, __LINE__, __FUNCTION__, __msg_err,    \
+            ##_args);                                                          \
+        -__msg_err;                                                            \
+    })
+
+#define error(_err, _fmt, _args...) msg_err(_err, "E(%4d) " _fmt, ##_args)
+#define warn(_err, _fmt, _args...) msg_err(_err, "W(%4d) " _fmt, ##_args)
+#define info(_err, _fmt, _args...) msg_err(_err, "I(%4d) " _fmt, ##_args)
+
+#define out_ok(_args...) msg_out("OK " _args)
+#define out_err(_err) msg_out("ERR %d", _err)
+
+#define ARG_END                                                                \
+    {                                                                          \
+        ARG_TYPE_NONE                                                          \
+    }
+
+#define CMD_ARGS1(_x, _args...)                                                \
+    .args = (arg_t[]) { _args }
+#define CMD_ARGS(_args...) CMD_ARGS1(, ##_args, ARG_END)
+
+#define CMD_SUB(_cmds) .cmds = _cmds
+
+#define CMD_END                                                                \
+    {                                                                          \
+        NULL, NULL, CMD_SUB(NULL)                                              \
+    }
+
+#define ARG_VAL(_type)                                                         \
+    {                                                                          \
+        ARG_TYPE_OBJ, .obj = {.type = _type }                                  \
+    }
+#define ARG_NUM(_min, _max)                                                    \
+    {                                                                          \
+        ARG_TYPE_NUM, .num = {.min = _min, .max = _max }                       \
+    }
+#define ARG_STR(_size)                                                         \
+    {                                                                          \
+        ARG_TYPE_STR, .str = {.size = _size }                                  \
+    }
+
+extern command_t fd_commands[];
+
+#endif /* __TESTER_H__ */
+\ No newline at end of file
diff --git a/tests/basic/open-fd-snap-delete.t b/tests/basic/open-fd-snap-delete.t
new file mode 100644
index 00000000000..a9f47cac19d
--- /dev/null
+++ b/tests/basic/open-fd-snap-delete.t
@@ -0,0 +1,74 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../snapshot.rc
+. $(dirname $0)/../fileio.rc
+
+cleanup;
+
+TEST init_n_bricks 3;
+TEST setup_lvm 3;
+
+# start glusterd
+TEST glusterd;
+
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 $H0:$L1 $H0:$L2 $H0:$L3;
+TEST $CLI volume set $V0 nfs.disable false
+
+
+TEST $CLI volume start $V0;
+
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0;
+
+for i in {1..10} ; do echo "file" > $M0/file$i ; done
+
+# Create file and directory
+TEST touch $M0/f1
+TEST mkdir $M0/dir
+
+TEST $CLI snapshot config activate-on-create enable
+TEST $CLI volume set $V0 features.uss enable;
+
+for i in {1..10} ; do echo "file" > $M0/dir/file$i ; done
+
+TEST $CLI snapshot create snap1 $V0 no-timestamp;
+
+for i in {11..20} ; do echo "file" > $M0/file$i ; done
+for i in {11..20} ; do echo "file" > $M0/dir/file$i ; done
+
+TEST $CLI snapshot create snap2 $V0 no-timestamp;
+
+TEST fd1=`fd_available`
+TEST fd_open $fd1 'r' $M0/.snaps/snap2/dir/file11;
+TEST fd_cat $fd1
+
+TEST $CLI snapshot delete snap2;
+
+TEST ! fd_cat $fd1;
+
+# the return value of this command (i.e. fd_close) depetends
+# mainly on how the release operation on a file descriptor is
+# handled in snapview-server process. As of now snapview-server
+# returns 0 for the release operation. And it is similar to how
+# posix xlator does. So, as of now the expectation is to receive
+# success for the close operation.
+TEST fd_close $fd1;
+
+# This check is mainly to ensure that the snapshot daemon
+# (snapd) is up and running. If it is not running, the following
+# stat would receive ENOTCONN.
+
+TEST stat $M0/.snaps/snap1/dir/file1
+
+TEST $CLI snapshot delete snap1;
+
+TEST rm -rf $M0/*;
+
+TEST $CLI volume stop $V0;
+
+TEST $CLI volume delete $V0;
+
+cleanup
diff --git a/tests/basic/peer-parsing.t b/tests/basic/peer-parsing.t
new file mode 100644
index 00000000000..813b65e2ae1
--- /dev/null
+++ b/tests/basic/peer-parsing.t
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+PEER_DIR="$GLUSTERD_WORKDIR"/peers
+TEST mkdir -p $PEER_DIR
+
+declare -i HOST_NUM=100
+
+create_random_peer_files() {
+        for i in $(seq 0 9); do
+                local peer_uuid=$(uuidgen)
+                # The rules for quoting and variable substitution in
+                # here documents would force this to be even less
+                # readable that way.
+                (
+                        echo "state=1"
+                        echo "uuid=$peer_uuid"
+                        echo "hostname=127.0.0.$HOST_NUM"
+                ) > $PEER_DIR/$peer_uuid
+                HOST_NUM+=1
+        done
+}
+
+create_non_peer_file() {
+        echo "random stuff" > $PEER_DIR/not_a_peer_file
+}
+
+create_malformed_peer_file() {
+        echo "more random stuff" > $PEER_DIR/$(uuidgen)
+}
+
+# We create lots of files, in batches, to ensure that our bogus ones are
+# properly interspersed with the valid ones.
+
+TEST create_random_peer_files
+TEST create_non_peer_file
+TEST create_random_peer_files
+TEST create_malformed_peer_file
+TEST create_random_peer_files
+
+# There should be 30 peers, not counting the two bogus files.
+TEST glusterd
+N_PEERS=$($CLI peer status | grep ^Uuid: | wc -l)
+TEST [ "$N_PEERS" = "30" ]
+
+# For extra credit, check the logs for messages about bogus files.
+
+cleanup
+
+
+
diff --git a/tests/basic/playground/template-xlator-sanity.t b/tests/basic/playground/template-xlator-sanity.t
new file mode 100755
index 00000000000..1c665502bfe
--- /dev/null
+++ b/tests/basic/playground/template-xlator-sanity.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST mkdir -p $B0/single-brick
+cat > $B0/template.vol <<EOF
+volume posix
+  type storage/posix
+  option directory $B0/single-brick
+end-volume
+
+volume template
+  type playground/template
+  subvolumes posix
+  option dummy 13
+end-volume
+EOF
+
+TEST glusterfs -f $B0/template.vol $M0
+
+TEST $(dirname $0)/../rpc-coverage.sh --no-locks $M0
+
+# Take statedump to get maximum code coverage
+pid=$(ps auxww | grep glusterfs | grep -E "template.vol" | awk '{print $2}' | head -1)
+
+TEST generate_statedump $pid
+
+# For monitor output
+kill -USR2 $pid
+
+# Handle SIGHUP and reconfigure
+sed -i -e '/s/dummy 13/dummy 42/g' $B0/template.vol
+kill -HUP $pid
+
+# for calling 'fini()'
+kill -TERM $pid
+
+force_umount $M0
+
+cleanup;
diff --git a/tests/basic/posix/shared-statfs.t b/tests/basic/posix/shared-statfs.t
index 8caa9fa2110..0e4a1bb409f 100644
--- a/tests/basic/posix/shared-statfs.t
+++ b/tests/basic/posix/shared-statfs.t
@@ -20,14 +20,18 @@ TEST mkdir -p $B0/${V0}1 $B0/${V0}2
 TEST MOUNT_LOOP $LO1 $B0/${V0}1
 TEST MOUNT_LOOP $LO2 $B0/${V0}2
 
+total_brick_blocks=$(df -P $B0/${V0}1 $B0/${V0}2 | tail -2 | awk '{sum = sum+$2}END{print sum}')
+#Account for rounding error
+brick_blocks_two_percent_less=$((total_brick_blocks*98/100))
 # Create a subdir in mountpoint and use that for volume.
 TEST $CLI volume create $V0 $H0:$B0/${V0}1/1 $H0:$B0/${V0}2/1;
 TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" online_brick_count
 TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
-total_space=$(df -P $M0 | tail -1 | awk '{ print $2}')
+total_mount_blocks=$(df -P $M0 | tail -1 | awk '{ print $2}')
 # Keeping the size less than 200M mainly because XFS will use
 # some storage in brick to keep its own metadata.
-TEST [ $total_space -gt 194000 -a $total_space -lt 200000 ]
+TEST [ $total_mount_blocks -gt $brick_blocks_two_percent_less -a $total_mount_blocks -lt 200000 ]
 
 
 TEST force_umount $M0
@@ -38,9 +42,10 @@ EXPECT 'Stopped' volinfo_field $V0 'Status';
 TEST $CLI volume add-brick $V0 $H0:$B0/${V0}1/2 $H0:$B0/${V0}2/2 $H0:$B0/${V0}1/3 $H0:$B0/${V0}2/3
 
 TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "6" online_brick_count
 TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
-total_space=$(df -P $M0 | tail -1 | awk '{ print $2}')
-TEST [ $total_space -gt 194000 -a $total_space -lt 200000 ]
+total_mount_blocks=$(df -P $M0 | tail -1 | awk '{ print $2}')
+TEST [ $total_mount_blocks -gt $brick_blocks_two_percent_less -a $total_mount_blocks -lt 200000 ]
 
 TEST force_umount $M0
 TEST $CLI volume stop $V0
diff --git a/tests/basic/posix/zero-fill-enospace.c b/tests/basic/posix/zero-fill-enospace.c
new file mode 100644
index 00000000000..b1f142c6be9
--- /dev/null
+++ b/tests/basic/posix/zero-fill-enospace.c
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    off_t size = 0;
+
+    if (argc != 6) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n",
+                argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, argv[4], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    size = strtol(argv[5], NULL, 10);
+    if (size < 0) {
+        fprintf(stderr, "Wrong size %s", argv[5]);
+        goto out;
+    }
+    ret = glfs_zerofill(fd, 0, size);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_zerofill: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
+}
diff --git a/tests/basic/posix/zero-fill-enospace.t b/tests/basic/posix/zero-fill-enospace.t
new file mode 100644
index 00000000000..ac2e61b10cf
--- /dev/null
+++ b/tests/basic/posix/zero-fill-enospace.t
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST truncate -s 100M $B0/brick1
+
+TEST L1=`SETUP_LOOP $B0/brick1`
+TEST MKFS_LOOP $L1
+
+TEST mkdir -p $B0/${V0}1
+
+TEST MOUNT_LOOP $L1 $B0/${V0}1
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+
+TEST $CLI volume start $V0;
+
+TEST glusterfs -s $H0 --volfile-id=$V0 $M0
+TEST touch $M0/foo
+TEST build_tester $(dirname $0)/zero-fill-enospace.c -lgfapi -Wall -O2
+TEST ! $(dirname $0)/zero-fill-enospace $H0 $V0 /foo `gluster --print-logdir`/glfs-$V0.log 104857600
+
+TEST force_umount $M0
+TEST $CLI volume stop $V0
+UMOUNT_LOOP ${B0}/${V0}1
+rm -f ${B0}/brick1
+
+cleanup
diff --git a/tests/basic/quick-read-with-upcall.t b/tests/basic/quick-read-with-upcall.t
new file mode 100644
index 00000000000..dfb751dfcdb
--- /dev/null
+++ b/tests/basic/quick-read-with-upcall.t
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+ #. $(dirname $0)/../volume.rc
+
+cleanup;
+
+#Basic checks
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+#Create a distributed volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..2};
+TEST $CLI volume start $V0
+
+# Mount FUSE without selinux:
+TEST glusterfs -s $H0 --volfile-id $V0 --direct-io-mode=enable $M0;
+TEST glusterfs -s $H0 --volfile-id $V0 --direct-io-mode=enable $M1;
+
+D0="test-message0";
+D1="test-message1";
+
+function write_to()
+{
+    local file="$1";
+    local data="$2";
+    echo "$data" > "$file";
+}
+
+
+TEST write_to "$M0/test.txt" "$D0"
+EXPECT "$D0" cat $M0/test.txt
+EXPECT "$D0" cat $M1/test.txt
+
+TEST write_to "$M0/test.txt" "$D1"
+EXPECT "$D1" cat $M0/test.txt
+EXPECT "$D0" cat $M1/test.txt
+
+sleep 1
+
+# TODO: This line normally fails
+EXPECT "$D1" cat $M1/test.txt
+
+TEST $CLI volume set $V0 features.cache-invalidation on
+TEST $CLI volume set $V0 performance.quick-read-cache-timeout 15
+TEST $CLI volume set $V0 performance.md-cache-timeout 15
+
+TEST write_to "$M0/test1.txt" "$D0"
+EXPECT "$D0" cat $M0/test1.txt
+EXPECT "$D0" cat $M1/test1.txt
+
+TEST write_to "$M0/test1.txt" "$D1"
+EXPECT "$D1" cat $M0/test1.txt
+EXPECT "$D0" cat $M1/test1.txt
+
+sleep 1
+EXPECT "$D0" cat $M1/test1.txt
+
+sleep 30
+EXPECT "$D1" cat $M1/test1.txt
+
+TEST $CLI volume set $V0 performance.quick-read-cache-invalidation on
+TEST $CLI volume set $V0 performance.cache-invalidation on
+
+TEST write_to "$M0/test2.txt" "$D0"
+EXPECT "$D0" cat $M0/test2.txt
+EXPECT "$D0" cat $M1/test2.txt
+
+TEST write_to "$M0/test2.txt" "$D1"
+EXPECT "$D1" cat $M0/test2.txt
+EXPECT "$D1" cat $M1/test2.txt
diff --git a/tests/basic/quota-anon-fd-nfs.t b/tests/basic/quota-anon-fd-nfs.t
index 11fbe49c7ff..9e6675af6ec 100755
--- a/tests/basic/quota-anon-fd-nfs.t
+++ b/tests/basic/quota-anon-fd-nfs.t
@@ -5,6 +5,8 @@
 . $(dirname $0)/../nfs.rc
 . $(dirname $0)/../fileio.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 QDD=$(dirname $0)/quota
diff --git a/tests/basic/quota-nfs.t b/tests/basic/quota-nfs.t
index 663a8da90ad..de94a950a7f 100755
--- a/tests/basic/quota-nfs.t
+++ b/tests/basic/quota-nfs.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 QDD=$(dirname $0)/quota
 # compile the test write program and run it
diff --git a/tests/basic/quota.c b/tests/basic/quota.c
index f69b0ea9bc5..809ceb8e54c 100644
--- a/tests/basic/quota.c
+++ b/tests/basic/quota.c
@@ -8,83 +8,82 @@
 #include <unistd.h>
 
 ssize_t
-nwrite (int fd, const void *buf, size_t count)
+nwrite(int fd, const void *buf, size_t count)
 {
-        ssize_t  ret        = 0;
-        ssize_t  written    = 0;
+    ssize_t ret = 0;
+    ssize_t written = 0;
 
-        for (written = 0; written != count; written += ret) {
-                ret = write (fd, buf + written, count - written);
-                if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+    for (written = 0; written != count; written += ret) {
+        ret = write(fd, buf + written, count - written);
+        if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = written;
+    ret = written;
 out:
-        return ret;
+    return ret;
 }
 
 int
-file_write (char *filename, int bs, int count)
+file_write(char *filename, int bs, int count)
 {
-        int  fd              = 0;
-        int  ret             = -1;
-        int  i               = 0;
-        char *buf            = NULL;
+    int fd = 0;
+    int ret = -1;
+    int i = 0;
+    char *buf = NULL;
 
-        bs = bs * 1024;
+    bs = bs * 1024;
 
-        buf = (char *) malloc (bs);
-        if (buf == NULL)
-                goto out;
+    buf = (char *)malloc(bs);
+    if (buf == NULL)
+        goto out;
 
-        memset (buf, 0, bs);
+    memset(buf, 0, bs);
 
-        fd = open (filename, O_RDWR|O_CREAT|O_SYNC, 0600);
-        while (i < count) {
-                ret = nwrite(fd, buf, bs);
-                if (ret == -1) {
-                        close (fd);
-                        goto out;
-                }
-                i++;
+    fd = open(filename, O_RDWR | O_CREAT | O_SYNC, 0600);
+    while (i < count) {
+        ret = nwrite(fd, buf, bs);
+        if (ret == -1) {
+            close(fd);
+            goto out;
         }
+        i++;
+    }
 
-        ret = fdatasync(fd);
-        if (ret) {
-                close (fd);
-                goto out;
-        }
+    ret = fdatasync(fd);
+    if (ret) {
+        close(fd);
+        goto out;
+    }
 
-        ret = close(fd);
-        if (ret)
-                goto out;
+    ret = close(fd);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (buf)
-                free (buf);
-        return ret;
+    if (buf)
+        free(buf);
+    return ret;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        if (argc != 4) {
-                printf("Usage: %s <filename> <block size in k> <count>\n",
-                        argv[0]);
-                return EXIT_FAILURE;
-        }
+    if (argc != 4) {
+        printf("Usage: %s <filename> <block size in k> <count>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        if (file_write (argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
-                perror ("write failed");
-                return EXIT_FAILURE;
-        }
+    if (file_write(argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
+        perror("write failed");
+        return EXIT_FAILURE;
+    }
 
-        return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }
diff --git a/tests/basic/quota.t b/tests/basic/quota.t
index 7f8b21de6f8..46d1bafff84 100755
--- a/tests/basic/quota.t
+++ b/tests/basic/quota.t
@@ -6,6 +6,8 @@
 . $(dirname $0)/../dht.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 QDD=$(dirname $0)/quota
diff --git a/tests/basic/rpc-coverage.sh b/tests/basic/rpc-coverage.sh
index 11d3be66dcb..6203f0ac7cb 100755
--- a/tests/basic/rpc-coverage.sh
+++ b/tests/basic/rpc-coverage.sh
@@ -419,9 +419,15 @@ function test_rmdir()
     rm -rf $PFX || fail "rm -rf"
 }
 
+function test_statvfs()
+{
+    df $DIR 2>&1 || fail "df"
+}
+
 
 function run_tests()
 {
+    test_statvfs;
     test_mkdir;
     test_create;
     test_statfs;
@@ -436,13 +442,15 @@ function run_tests()
     test_rename;
     test_chmod;
     test_chown;
-    test_utimes;
-    test_locks;
     test_readdir;
     test_setxattr;
     test_listxattr;
     test_getxattr;
     test_removexattr;
+    if [ "$run_lock_tests" = "1" ]; then
+        test_locks;
+    fi
+    test_utimes;
     test_unlink;
     test_rmdir;
 }
@@ -453,14 +461,19 @@ function _init()
     DIR=$(pwd);
 }
 
-
+run_lock_tests=1
 function parse_cmdline()
 {
     if [ "x$1" == "x" ] ; then
-        echo "Usage: $0 /path/mount"
+        echo "Usage: $0 [--no-locks] /path/mount"
         exit 1
     fi
 
+    if [ "$1" == "--no-locks" ] ; then
+        run_lock_tests=0
+        shift
+    fi
+
     DIR=$1;
 
     if [ ! -d "$DIR" ] ; then
diff --git a/tests/basic/rpc-coverage.t b/tests/basic/rpc-coverage.t
index a76ba7084eb..2c1bcd5a63a 100755
--- a/tests/basic/rpc-coverage.t
+++ b/tests/basic/rpc-coverage.t
@@ -9,11 +9,11 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2  $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6,7,8,9};
 
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '8' brick_count $V0
+EXPECT '9' brick_count $V0
 
 TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
diff --git a/tests/basic/sdfs-sanity.t b/tests/basic/sdfs-sanity.t
new file mode 100644
index 00000000000..16d0bed866f
--- /dev/null
+++ b/tests/basic/sdfs-sanity.t
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6,7,8,9};
+TEST $CLI volume set $V0 features.sdfs enable;
+TEST $CLI volume start $V0;
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+# This test covers lookup, mkdir, mknod, symlink, link, rename,
+# create operations
+TEST $(dirname $0)/rpc-coverage.sh $M1
+
+TEST cp $(dirname ${0})/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+cleanup;
diff --git a/tests/basic/seek.c b/tests/basic/seek.c
new file mode 100644
index 00000000000..54fa6f463af
--- /dev/null
+++ b/tests/basic/seek.c
@@ -0,0 +1,182 @@
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+static char buffer[65536];
+
+static int
+parse_int(const char *text, size_t *value)
+{
+    char *ptr;
+    size_t val;
+
+    val = strtoul(text, &ptr, 0);
+    if (*ptr != 0) {
+        return 0;
+    }
+
+    *value = val;
+
+    return 1;
+}
+
+static int
+fill_area(int fd, off_t offset, size_t size)
+{
+    size_t len;
+    ssize_t res;
+
+    while (size > 0) {
+        len = sizeof(buffer);
+        if (len > size) {
+            len = size;
+        }
+        res = pwrite(fd, buffer, len, offset);
+        if (res < 0) {
+            fprintf(stderr, "pwrite(%d, %p, %lu, %lu) failed: %d\n", fd, buffer,
+                    size, offset, errno);
+            return 0;
+        }
+        if (res != len) {
+            fprintf(stderr,
+                    "pwrite(%d, %p, %lu, %lu) didn't wrote all "
+                    "data: %lu/%lu\n",
+                    fd, buffer, size, offset, res, len);
+            return 0;
+        }
+        offset += len;
+        size -= len;
+    }
+
+    return 1;
+}
+
+static void
+syntax(void)
+{
+    fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
+    fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
+}
+
+static int
+seek_create(const char *path, int argc, char *argv[])
+{
+    size_t off, size;
+    int fd;
+    int ret = 1;
+
+    fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to create the file\n");
+        goto out;
+    }
+
+    while (argc > 0) {
+        if (!parse_int(argv[0], &off) || !parse_int(argv[1], &size)) {
+            syntax();
+            goto out_close;
+        }
+        if (!fill_area(fd, off, size)) {
+            goto out_close;
+        }
+        argv += 2;
+        argc -= 2;
+    }
+
+    ret = 0;
+
+out_close:
+    close(fd);
+out:
+    return ret;
+}
+
+static int
+seek_scan(const char *path, const char *type, const char *pos)
+{
+    size_t off, res;
+    int fd, whence;
+    int ret = 1;
+
+    if (strcmp(type, "data") == 0) {
+        whence = SEEK_DATA;
+    } else if (strcmp(type, "hole") == 0) {
+        whence = SEEK_HOLE;
+    } else {
+        syntax();
+        goto out;
+    }
+
+    if (!parse_int(pos, &off)) {
+        syntax();
+        goto out;
+    }
+
+    fd = open(path, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to open the file\n");
+        goto out;
+    }
+
+    res = lseek(fd, off, whence);
+    if (res == (off_t)-1) {
+        if (errno != ENXIO) {
+            fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd, off, whence,
+                    errno);
+            goto out_close;
+        }
+        fprintf(stdout, "ENXIO\n");
+    } else {
+        fprintf(stdout, "%lu\n", res);
+    }
+
+    ret = 0;
+
+out_close:
+    close(fd);
+out:
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 1;
+
+    memset(buffer, 0x55, sizeof(buffer));
+
+    if (argc < 3) {
+        syntax();
+        goto out;
+    }
+
+    if (strcmp(argv[1], "create") == 0) {
+        if (((argc - 3) & 1) != 0) {
+            syntax();
+            goto out;
+        }
+        ret = seek_create(argv[2], argc - 3, argv + 3);
+    } else if (strcmp(argv[1], "scan") == 0) {
+        if (argc != 5) {
+            syntax();
+            goto out;
+        }
+        ret = seek_scan(argv[2], argv[3], argv[4]);
+    } else {
+        syntax();
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    return ret;
+}
diff --git a/tests/basic/shd-mux-afr.t b/tests/basic/shd-mux-afr.t
new file mode 100644
index 00000000000..cf300c148bb
--- /dev/null
+++ b/tests/basic/shd-mux-afr.t
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 cluster.background-self-heal-count 0
+TEST $CLI volume set $V0 cluster.eager-lock off
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+shd_pid=$(get_shd_mux_pid $V0)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#Create a one more volume
+TEST $CLI volume create ${V0}_1 replica 3 $H0:$B0/${V0}_1{0,1,2,3,4,5}
+TEST $CLI volume start ${V0}_1
+
+#Check whether the shd has multiplexed or not
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid ${V0}_1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid ${V0}
+
+TEST $CLI volume set ${V0}_1 cluster.background-self-heal-count 0
+TEST $CLI volume set ${V0}_1 cluster.eager-lock off
+TEST $CLI volume set ${V0}_1 performance.flush-behind off
+TEST $GFS --volfile-id=/${V0}_1 --volfile-server=$H0 $M1
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick ${V0}_1 $H0 $B0/${V0}_10
+TEST kill_brick ${V0}_1 $H0 $B0/${V0}_14
+
+TEST touch $M0/foo{1..100}
+TEST touch $M1/foo{1..100}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^204$" get_pending_heal_count $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^204$" get_pending_heal_count ${V0}_1
+
+TEST $CLI volume start ${V0} force
+TEST $CLI volume start ${V0}_1 force
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}_1
+
+TEST rm -rf $M0/*
+TEST rm -rf $M1/*
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
+
+#Stop the volume
+TEST $CLI volume stop ${V0}_1
+TEST $CLI volume delete ${V0}_1
+
+#Check the stop succeeded and detached the volume with out restarting it
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid $V0
+
+#Check the thread count become to earlier number after stopping
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $CLI volume stop ${V0}
+TEST $CLI volume delete ${V0}
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+cleanup
diff --git a/tests/basic/shd-mux-ec.t b/tests/basic/shd-mux-ec.t
new file mode 100644
index 00000000000..ef4d65018d3
--- /dev/null
+++ b/tests/basic/shd-mux-ec.t
@@ -0,0 +1,75 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 cluster.background-self-heal-count 0
+TEST $CLI volume set $V0 cluster.eager-lock off
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+shd_pid=$(get_shd_mux_pid $V0)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#Now create a  ec volume and check mux works
+TEST $CLI volume create ${V0}_2 disperse 6 redundancy 2 $H0:$B0/${V0}_2{0,1,2,3,4,5}
+TEST $CLI volume start ${V0}_2
+
+#Check whether the shd has multiplexed or not
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid ${V0}_2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid ${V0}
+
+TEST $CLI volume set ${V0}_2 cluster.background-self-heal-count 0
+TEST $CLI volume set ${V0}_2 cluster.eager-lock off
+TEST $CLI volume set ${V0}_2 performance.flush-behind off
+TEST $GFS --volfile-id=/${V0}_2 --volfile-server=$H0 $M1
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick ${V0}_2 $H0 $B0/${V0}_20
+TEST kill_brick ${V0}_2 $H0 $B0/${V0}_22
+
+TEST touch $M0/foo{1..100}
+TEST touch $M1/foo{1..100}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^204$" get_pending_heal_count $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^404$" get_pending_heal_count ${V0}_2
+
+TEST $CLI volume start ${V0} force
+TEST $CLI volume start ${V0}_2 force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count ${V0}_2
+
+TEST rm -rf $M0/*
+TEST rm -rf $M1/*
+
+
+#Stop the volume
+TEST $CLI volume stop ${V0}_2
+TEST $CLI volume delete ${V0}_2
+
+#Check the stop succeeded and detached the volume with out restarting it
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^${shd_pid}$" get_shd_mux_pid $V0
+
+#Check the thread count become to zero for ec related threads
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to earlier number after stopping
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $CLI volume stop ${V0}
+TEST $CLI volume delete ${V0}
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+
+cleanup
diff --git a/tests/basic/stats-dump.t b/tests/basic/stats-dump.t
index 5f35db4e0bd..ed73fd1d14a 100644
--- a/tests/basic/stats-dump.t
+++ b/tests/basic/stats-dump.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
@@ -12,6 +14,7 @@ TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
 TEST $CLI volume set $V0 diagnostics.latency-measurement on
 TEST $CLI volume set $V0 diagnostics.count-fop-hits on
 TEST $CLI volume set $V0 diagnostics.stats-dump-interval 1
+TEST $CLI volume set $V0 performance.nfs.io-threads on
 TEST $CLI volume set $V0 nfs.disable off
 TEST $CLI volume start $V0
 EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available
@@ -25,8 +28,16 @@ done
 for i in {1..10};do
   dd if=/dev/zero of=$N0/nfs_testfile$i bs=4k count=100
 done
+
+# Wait for one dump interval to be done, some seconds past 1 that is the dump
+# interval set
 sleep 2
 
+# Change the dump interval to 0, so that when reading the file contents we
+# do not get them truncated by the next interval that is overwriting the latest
+# stats data
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 0
+
 # Verify we have non-zero write counts from the bricks, gNFSd
 # and the FUSE mount.
 TEST [ $(grep 'aggr.fop.write.count' ${GLUSTERD_WORKDIR}/stats/glusterfs_nfsd.dump|tail -1|cut -d: -f2) != "0," ]
@@ -35,4 +46,10 @@ TEST [ $(grep 'aggr.fop.write.count' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_bac
 TEST [ $(grep 'aggr.fop.write.count' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_backends_patchy1.dump|tail -1|cut -d: -f2) != "0," ]
 TEST [ $(grep 'aggr.fop.write.count' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_backends_patchy2.dump|tail -1|cut -d: -f2) != "0," ]
 
+# Test that io-stats is getting queue sizes from io-threads
+TEST grep '.queue_size' ${GLUSTERD_WORKDIR}/stats/glusterfs_nfsd.dump
+TEST grep '.queue_size' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_backends_patchy0.dump
+TEST grep '.queue_size' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_backends_patchy1.dump
+TEST grep '.queue_size' ${GLUSTERD_WORKDIR}/stats/glusterfsd__d_backends_patchy2.dump
+
 cleanup;
diff --git a/tests/basic/symbol-check.sh b/tests/basic/symbol-check.sh
index f84d591facb..0f8243ca731 100755
--- a/tests/basic/symbol-check.sh
+++ b/tests/basic/symbol-check.sh
@@ -13,6 +13,8 @@ syscalls32=$'creat\nfallocate\nftruncate\n__fxstat\n__fxstatat\n\
 lseek\n__lxstat\nopenat\nreaddir\nstatvfs\ntruncate\nstat\n\
 preadv\npwritev\npread\npwrite'
 
+glibccalls=$'tmpfile'
+
 exclude_files=$'/libglusterfs/src/.libs/libglusterfs_la-syscall.o\n\
 /libglusterfs/src/.libs/libglusterfs_la-gen_uuid.o\n\
 /contrib/fuse-util/fusermount.o\n\
@@ -33,13 +35,14 @@ function main()
     done
 
     local retval=0
-    local t=$(nm ${1} | grep " U " | sed -e "s/  //g" -e "s/ U //g")
+    local t
+    t=$(nm "${1}" | grep " U " | sed -e "s/  //g" -e "s/ U //g")
 
     for symy in ${t}; do
 
         for symx in ${syscalls}; do
 
-            if [[ ${symx} = ${symy} ]]; then
+            if [[ ${symx} = "${symy}" ]]; then
 
                 case ${symx} in
                 "creat64") sym="creat";;
@@ -70,12 +73,36 @@ function main()
 
         for symx in ${syscalls32}; do
 
-            if [[ ${symx} = ${symy} ]]; then
+            if [[ ${symx} = "${symy}" ]]; then
 
                 echo "${1} was not compiled with -D_FILE_OFFSET_BITS=64" >&2
                 retval=1
             fi
         done
+
+        symy_glibc=$(echo "${symy}" | sed -e "s/@@GLIBC.*//g")
+        # Eliminate false positives, check if we have a GLIBC symbol in 'y'
+        if [[ ${symy} != "${symy_glibc}" ]]; then
+            for symx in ${glibccalls}; do
+
+                if [[ ${symx} = "${symy_glibc}" ]]; then
+
+                    case ${symx} in
+                    "tmpfile") alt="mkstemp";;
+                    *) alt="none";;
+                    esac
+
+                    if [[ ${alt} = "none" ]]; then
+                        echo "${1} should not call ${symy_glibc}";
+                    else
+                        echo "${1} should use ${alt} instead of ${symy_glibc}" >&2;
+                    fi
+
+                    retval=1
+                fi
+            done
+        fi
+
     done
 
     if [ ${retval} = 1 ]; then
diff --git a/tests/basic/tier/bug-1214222-directories_missing_after_attach_tier.t b/tests/basic/tier/bug-1214222-directories_missing_after_attach_tier.t
deleted file mode 100755
index 7ab8ac3e8f2..00000000000
--- a/tests/basic/tier/bug-1214222-directories_missing_after_attach_tier.t
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-LAST_BRICK=3
-CACHE_BRICK_FIRST=4
-CACHE_BRICK_LAST=5
-DEMOTE_TIMEOUT=12
-PROMOTE_TIMEOUT=5
-
-
-LAST_BRICK=1
-CACHE_BRICK=2
-DEMOTE_TIMEOUT=12
-PROMOTE_TIMEOUT=5
-MIGRATION_TIMEOUT=10
-cleanup
-
-
-TEST glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-TEST $CLI volume start $V0
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-
-# Basic operations.
-cd $M0
-TEST stat .
-TEST mkdir d1
-TEST [ -d d1 ]
-TEST touch file1
-TEST [ -e file1 ]
-
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-TEST $CLI volume set $V0 features.ctr-enabled on
-
-#check whether the directory's and files are present on mount or not.
-TEST [ -d d1 ]
-TEST [ -e file1 ]
-
-cd
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
-
-tier_status ()
-{
-	$CLI volume tier $V0 detach status | grep progress | wc -l
-}
-
-TEST $CLI volume detach-tier $V0 start
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_status
-TEST $CLI volume detach-tier $V0 commit
-
-EXPECT "0" confirm_tier_removed ${V0}${CACHE_BRICK_FIRST}
-
-EXPECT_WITHIN $REBALANCE_TIMEOUT "0" confirm_vol_stopped $V0
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/tier/ctr-rename-overwrite.t b/tests/basic/tier/ctr-rename-overwrite.t
deleted file mode 100755
index 8bccd3b3489..00000000000
--- a/tests/basic/tier/ctr-rename-overwrite.t
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-LAST_BRICK=1
-CACHE_BRICK_FIRST=4
-CACHE_BRICK_LAST=5
-
-DEMOTE_FREQ=5
-PROMOTE_FREQ=5
-
-cleanup
-
-# Start glusterd
-TEST glusterd
-TEST pidof glusterd
-
-# Set-up tier cluster
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-TEST $CLI volume start $V0
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-
-TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-
-# Start and mount the volume after enabling CTR
-TEST $CLI volume set $V0 features.ctr-enabled on
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-
-# create two files
-echo "hello world" > $M0/file1
-echo "hello world" > $M0/file2
-
-# db in hot brick shows 4 record. 2 for file1 and 2 for file2
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 4 ]
-
-#overwrite file2 with file1
-mv -f $M0/file1 $M0/file2
-
-# Now the db in hot tier should have only 2 records for file1.
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 2 ]
-
-cleanup
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/file_lock.c b/tests/basic/tier/file_lock.c
deleted file mode 100644
index 730cca92e42..00000000000
--- a/tests/basic/tier/file_lock.c
+++ /dev/null
@@ -1,75 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-
-void usage (void)
-{
-
-        printf ("Usage: testlock <filepath> [R|W]\n");
-        return;
-}
-
-
-int main (int argc, char *argv[])
-{
-        char *file_path = NULL;
-        int fd = -1;
-        struct flock lock = {0};
-        int ret = -1;
-        int c = 0;
-
-        if (argc != 3) {
-                usage ();
-                exit (1);
-        }
-
-        file_path = argv[1];
-        fd = open (file_path, O_RDWR);
-
-        if (-1 == fd) {
-                printf ("Failed to open file %s. %m\n", file_path);
-                exit (1);
-        }
-
-        /* TODO: Check for invalid input*/
-
-        if (!strcmp (argv[2], "W")) {
-                lock.l_type = F_WRLCK;
-                printf("Taking write lock\n");
-
-        } else {
-                lock.l_type = F_RDLCK;
-                printf("Taking read lock\n");
-        }
-
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-        lock.l_pid = getpid ();
-
-
-        printf ("Acquiring lock on %s\n", file_path);
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to acquire lock on %s (%m)\n", file_path);
-                close (fd);
-                exit (1);
-        }
-
-        sleep(10);
-
-        /*Unlock*/
-
-        printf ("Releasing lock on %s\n", file_path);
-        lock.l_type = F_UNLCK;
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to release lock on %s (%m)\n", file_path);
-        }
-
-        close (fd);
-        return ret;
-
-}
diff --git a/tests/basic/tier/file_with_spaces.t b/tests/basic/tier/file_with_spaces.t
deleted file mode 100755
index bd99e71ffe5..00000000000
--- a/tests/basic/tier/file_with_spaces.t
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-NUM_BRICKS=3
-DEMOTE_FREQ=5
-DEMOTE_TIMEOUT=10
-PROMOTE_FREQ=5
-
-FILE_SPACE="Testing filenames with spaces.log"
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-
-# The file will be created on the hot tier
-
-touch "$M0/$FILE_SPACE"
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  "$FILE_SPACE"`
-echo "File path on hot tier: "$HPATH
-
-EXPECT "yes" exists_and_regular_file $HPATH
-
-# Wait for the tier process to demote the file
-sleep $DEMOTE_TIMEOUT
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  "$FILE_SPACE"`
-echo "File path on cold tier: "$CPATH
-
-EXPECT "yes" exists_and_regular_file $CPATH
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/fops-during-migration-pause.t b/tests/basic/tier/fops-during-migration-pause.t
deleted file mode 100755
index 10bd3f4667a..00000000000
--- a/tests/basic/tier/fops-during-migration-pause.t
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-NUM_BRICKS=3
-DEMOTE_FREQ=10
-PROMOTE_FREQ=10
-
-TEST_STR="Testing write and truncate fops on tier migration"
-
-function is_sticky_set () {
-        echo $1
-        if [ -k $1 ];
-        then
-                echo "yes"
-        else
-                echo "no"
-        fi
-}
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-TEST mkdir $M0/dir1
-
-# Create a large file (800MB), so that rebalance takes time
-# The file will be created on the hot tier
-sleep_until_mid_cycle $DEMOTE_FREQ
-dd if=/dev/zero of=$M0/dir1/FILE1 bs=256k count=5120
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  FILE1`
-echo "File path on hot tier: "$HPATH
-
-
-# Wait for the tier process to demote the file
-EXPECT_WITHIN $REBALANCE_TIMEOUT "yes" is_sticky_set $HPATH
-
-TEST $CLI volume set $V0 cluster.tier-pause on
-
-# Wait for the tier process to finish migrating the file
-EXPECT_WITHIN $REBALANCE_TIMEOUT "no" is_sticky_set $HPATH
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  FILE1`
-
-# make sure destination is empty
-TEST ! test -s $CPATH
-
-# make sure source exists and not empty
-TEST test -s $HPATH
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/fops-during-migration.t b/tests/basic/tier/fops-during-migration.t
deleted file mode 100755
index cd3109f0888..00000000000
--- a/tests/basic/tier/fops-during-migration.t
+++ /dev/null
@@ -1,104 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-NUM_BRICKS=3
-DEMOTE_FREQ=5
-PROMOTE_FREQ=5
-
-TEST_STR="Testing write and truncate fops on tier migration"
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-
-# Checks that the contents of the file matches the input string
-#$1 : file_path
-#$2 : comparison string
-
-function check_file_content () {
-        contents=`cat $1`
-        echo $contents
-        if [ "$contents" = "$2" ]; then
-                echo "1"
-        else
-                echo "0"
-        fi
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-$CLI volume set $V0 diagnostics.client-log-level DEBUG
-
-TEST mkdir $M0/dir1
-
-# Create a large file (320MB), so that rebalance takes time
-# The file will be created on the hot tier
-
-dd if=/dev/zero of=$M0/dir1/FILE1 bs=64k count=5120
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  FILE1`
-echo "File path on hot tier: "$HPATH
-
-
-# Wait for the tier process to demote the file
-EXPECT_WITHIN $REBALANCE_TIMEOUT "yes" is_sticky_set $HPATH
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  FILE1`
-echo "File path on cold tier: "$CPATH
-
-# Test setxattr
-TEST setfattr -n "user.test_xattr" -v "qwerty" $M0/dir1/FILE1
-
-# Change the file contents while it is being migrated
-echo $TEST_STR > $M0/dir1/FILE1
-
-# The file contents should have changed even if the file
-# is not done migrating
-EXPECT "1" check_file_content $M0/dir1/FILE1 "$TEST_STR"
-
-
-# Wait for the tier process to finish migrating the file
-EXPECT_WITHIN $REBALANCE_TIMEOUT "no" is_sticky_set $CPATH
-
-# The file contents should have changed
-EXPECT "1" check_file_content $M0/dir1/FILE1 "$TEST_STR"
-
-
-TEST getfattr -n "user.test_xattr" $M0/dir1/FILE1
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/tier/frequency-counters.t b/tests/basic/tier/frequency-counters.t
deleted file mode 100644
index c335c02c563..00000000000
--- a/tests/basic/tier/frequency-counters.t
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-NUM_BRICKS=3
-DEMOTE_FREQ=10
-PROMOTE_FREQ=10
-NUM_FILES=5
-TEST_DIR=test
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume start $V0
-}
-
-function create_dist_tier_vol () {
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-mode test
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 features.record-counters on
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 2
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 2
-}
-
-cleanup;
-
-
-TEST glusterd
-
-#Create and start a tiered volume
-create_dist_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-# create some files
-mkdir $M0/$TEST_DIR
-cd $M0/${TEST_DIR}
-
-date > file1
-touch file2
-
-# attach tier
-create_dist_tier_vol $NUM_BRICKS
-
-sleep_until_mid_cycle $PROMOTE_FREQ
-
-# check if promotion on single hit, should fail
-date >> file2
-cat file1
-drop_cache $M0
-sleep $PROMOTE_FREQ
-EXPECT "0" check_counters 0 0
-
-# check if promotion on double hit, should suceed
-sleep_until_mid_cycle $PROMOTE_FREQ
-date >> file2
-drop_cache $M0
-cat file1
-date >> file2
-drop_cache $M0
-cat file1
-
-EXPECT_WITHIN $PROMOTE_FREQ "0" check_counters 2 0
-
-TEST ! $CLI volume set $V0 features.record-counters off
-
-cd /
-
-cleanup
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/legacy-many.t b/tests/basic/tier/legacy-many.t
deleted file mode 100644
index 1782ca70088..00000000000
--- a/tests/basic/tier/legacy-many.t
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-LAST_BRICK=3
-CACHE_BRICK_FIRST=4
-CACHE_BRICK_LAST=5
-DEMOTE_TIMEOUT=12
-PROMOTE_TIMEOUT=12
-MIGRATION_TIMEOUT=10
-DEMOTE_FREQ=60
-PROMOTE_FREQ=10
-TEST_DIR="test_files"
-NUM_FILES=15
-
-function read_all {
-    for file in *
-    do
-        cat $file
-    done
-}
-
-function tier_status () {
-        $CLI volume tier $V0 status | grep "success" | wc -l
-}
-
-cleanup
-
-TEST glusterd
-TEST pidof glusterd
-
-# Create distributed replica volume
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-TEST $CLI volume start $V0
-
-TEST $CLI volume set $V0 performance.quick-read off
-TEST $CLI volume set $V0 performance.io-cache off
-TEST $CLI volume set $V0 features.ctr-enabled on
-
-
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-
-# Create a number of "legacy" files before attaching tier
-mkdir $M0/${TEST_DIR}
-cd $M0/${TEST_DIR}
-TEST create_many_files file $NUM_FILES
-wait
-
-# Attach tier
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-
-TEST $CLI volume set $V0 cluster.tier-mode test
-TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-
-# wait a little for lookup heal to finish
-wait_for_tier_start
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_status
-
-# make sure fix layout completed
-CPATH=$B0/${V0}0
-echo $CPATH > /tmp/out
-TEST getfattr -n "trusted.tier.fix.layout.complete" $CPATH
-
-# Read "legacy" files
-drop_cache $M0
-
-sleep_until_mid_cycle $DEMOTE_FREQ
-
-TEST read_all
-
-# Test to make sure files were promoted as expected
-sleep $PROMOTE_TIMEOUT
-EXPECT_WITHIN $PROMOTE_TIMEOUT "0" check_counters $NUM_FILES 0
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" detach_start $V0
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0 $H0:$B0/${V0}${CACHE_BRICK_FIRST}"
-
-TEST $CLI volume tier $V0 detach commit
-
-# fix layout flag should be cleared
-TEST ! getfattr -n "trusted.tier.fix.layout.complete" $CPATH
-
-cd;
-cleanup
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/locked_file_migration.t b/tests/basic/tier/locked_file_migration.t
deleted file mode 100755
index 1a7e3f53c8e..00000000000
--- a/tests/basic/tier/locked_file_migration.t
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-NUM_BRICKS=3
-DEMOTE_FREQ=7
-PROMOTE_FREQ=30
-DEMOTE_TIMEOUT=15
-
-TEST_STR="Testing write and truncate fops on tier migration"
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-
-#We don't want promotes to happen in this test
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 10
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 10
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-
-# Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-TEST mkdir $M0/dir1
-build_tester $(dirname $0)/file_lock.c -o file_lock
-cp $(dirname $0)/file_lock $M0/file_lock
-
-# The files will be created on the hot tier
-touch $M0/dir1/FILE1
-touch $M0/dir1/FILE2
-
-# For FILE1, take a POSIX write lock on the entire file.
-# Don't take a lock on FILE2
-
-./file_lock $M0/dir1/FILE1 W &
-
-sleep $DEMOTE_FREQ
-
-# Wait for the tier process to demote the file
-# Only FILE2 and file_lock should be demoted
-# FILE1 should be skipped because of the lock held
-# on it
-
-EXPECT_WITHIN $DEMOTE_TIMEOUT "0" check_counters 0 2
-
-sleep 10
-
-rm $(dirname $0)/file_lock
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/new-tier-cmds.t b/tests/basic/tier/new-tier-cmds.t
deleted file mode 100644
index d341e62dc51..00000000000
--- a/tests/basic/tier/new-tier-cmds.t
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-. $(dirname $0)/../../cluster.rc
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function check_peers {
-    $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-function create_dist_tier_vol () {
-        TEST $CLI_1 volume create $V0 $H1:$B1/${V0} $H2:$B2/${V0} $H3:$B3/${V0}
-        TEST $CLI_1 volume start $V0
-        TEST $CLI_1 volume tier $V0 attach $H1:$B1/${V0}_h1 $H2:$B2/${V0}_h2 $H3:$B3/${V0}_h3
-}
-
-function tier_daemon_status {
-        local _VAR=CLI_$1
-        local xpath_sel='//node[hostname="Tier Daemon"][path="localhost"]/status'
-        ${!_VAR} --xml volume status $V0 \
-                | xmllint --xpath "$xpath_sel" - \
-                | sed -n '/.*<status>\([0-9]*\).*/s//\1/p'
-}
-
-function detach_xml_status {
-        $CLI_1 volume tier $V0 detach status --xml | sed -n \
-        '/.*<opErrstr>Detach tier status successful/p' | wc -l
-}
-
-cleanup;
-
-#setup cluster and test volume
-TEST launch_cluster 3; # start 3-node virtual cluster
-TEST $CLI_1 peer probe $H2; # peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H3; # peer probe server 3 from server 1 cli
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers;
-
-#Create and start a tiered volume
-create_dist_tier_vol
-
-########### check failure for older commands #############
-
-TEST ! $CLI_1 volume rebalance $V0 tier status
-
-# failure for older command can be removed in 3.11
-
-##########################################################
-
-#Issue detach tier on the tiered volume
-#Will throw error saying detach tier not started
-
-EXPECT "Tier command failed" $CLI_1 volume tier $V0 detach status
-
-EXPECT "0" detach_xml_status
-
-#after starting detach tier the detach tier status should display the status
-
-TEST $CLI_1 volume tier $V0 detach start
-
-EXPECT "1" detach_xml_status
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_detach_status
-
-#kill a node
-TEST kill_node 2
-
-#check if we have the rest of the node available printed in the output of detach status
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_detach_status_node_down
-
-#check if we have the rest of the node available printed in the output of tier status
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_status_node_down
-
-TEST $glusterd_2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers;
-# Make sure we check that the *bricks* are up and not just the node.  >:-(
-EXPECT_WITHIN $CHILD_UP_TIMEOUT 1 brick_up_status_1 $V0 $H2 $B2/${V0}
-EXPECT_WITHIN $CHILD_UP_TIMEOUT 1 brick_up_status_1 $V0 $H2 $B2/${V0}_h2
-
-# Parsing normal output doesn't work because of line-wrap issues on our
-# regression machines, and the version of xmllint there doesn't support --xpath
-# so we can't do it that way either.  In short, there's no way for us to detect
-# when we can stop waiting, so we just have to wait the maximum time every time
-# and hope any failures will show up later in the script.
-sleep $PROCESS_UP_TIMEOUT
-#XPECT_WITHIN $PROCESS_UP_TIMEOUT 1 tier_daemon_status 2
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_detach_status
-
-TEST $CLI_1 volume tier $V0 detach stop
-
-#If detach tier is stopped the detach tier command will fail
-
-EXPECT "Tier command failed" $CLI_1 volume tier $V0 detach status
-
-TEST $CLI_1 volume tier $V0 detach start
-
-#wait for the detach to complete
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" tier_detach_commit
-
-#If detach tier is committed then the detach status should fail throwing an error
-#saying its not a tiered volume
-
-EXPECT "Tier command failed" $CLI_1 volume tier $V0 detach status
-
-########### check failure for older commands #############
-
-TEST ! $CLI_1 volume rebalance $V0 tier start
-
-# failure for older command can be removed in 3.11
-
-##########################################################
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/readdir-during-migration.t b/tests/basic/tier/readdir-during-migration.t
deleted file mode 100644
index e2a43c93572..00000000000
--- a/tests/basic/tier/readdir-during-migration.t
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-NUM_BRICKS=3
-DEMOTE_FREQ=5
-PROMOTE_FREQ=5
-NUM_FILES=30
-TEST_DIR=test
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-mode test
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-}
-
-function check_file_count() {
-    if [ $(ls -1 | wc -l) == $1 ]; then
-        echo "1"
-    else
-        echo "0"
-    fi
-}
-
-cleanup;
-
-
-TEST glusterd
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-# Create a number of "legacy" files before attaching tier
-mkdir $M0/${TEST_DIR}
-cd $M0/${TEST_DIR}
-TEST create_many_files tfile $NUM_FILES
-
-EXPECT "1" check_file_count $NUM_FILES
-
-sleep $DEMOTE_FREQ
-
-EXPECT "1" check_file_count $NUM_FILES
-
-cd /
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/record-metadata-heat.t b/tests/basic/tier/record-metadata-heat.t
deleted file mode 100755
index 44dda56a038..00000000000
--- a/tests/basic/tier/record-metadata-heat.t
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-NUM_BRICKS=3
-DEMOTE_FREQ=5
-DEMOTE_TIMEOUT=10
-PROMOTE_FREQ=5
-
-FILE="file1.txt"
-FILE_LINK="file2.txt"
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-mode test
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 4
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 4
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-
-# The file will be created on the hot tier
-touch "$M0/$FILE"
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  "$FILE"`
-echo "File path on hot tier: "$HPATH
-
-############################################
-# as per the changes on b8b050c3
-# To test the xttr set by EC
-TEST ! getfattr -n "trusted.ec.size" $HPATH
-############################################
-
-# Expecting the file to be on the hot tier
-EXPECT "yes" exists_and_regular_file $HPATH
-
-sleep_until_mid_cycle $DEMOTE_FREQ
-
-# Try to heat the file using 5 metadata operations
-# WITHOUT setting ctr-record-metadata-heat on
-touch "$M0/$FILE"
-chmod +x "$M0/$FILE"
-chown root "$M0/$FILE"
-ln "$M0/$FILE" "$M0/$FILE_LINK"
-rm -rf "$M0/$FILE_LINK"
-
-# Wait for the tier process to demote the file
-sleep $DEMOTE_TIMEOUT
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  "$FILE"`
-echo "File path on cold tier: "$CPATH
-
-# Expecting the file to be on cold tier
-EXPECT "yes" exists_and_regular_file $CPATH
-
-#Set ctr-record-metadata-heat on
-TEST $CLI volume set $V0 ctr-record-metadata-heat on
-
-sleep_until_mid_cycle $DEMOTE_FREQ
-
-# Heating the file using 5 metadata operations
-touch "$M0/$FILE"
-chmod +x "$M0/$FILE"
-chown root "$M0/$FILE"
-ln "$M0/$FILE" "$M0/$FILE_LINK"
-rm -rf "$M0/$FILE_LINK"
-
-# Wait for the tier process to demote the file
-sleep $DEMOTE_TIMEOUT
-
-# Get the path of the file on the hot tier
-echo "File path on hot tier: "$HPATH
-
-# Expecting the file to be on the hot tier
-EXPECT "yes" exists_and_regular_file $HPATH
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/tier/tier-heald.t b/tests/basic/tier/tier-heald.t
deleted file mode 100644
index 8dcdd39c619..00000000000
--- a/tests/basic/tier/tier-heald.t
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-# This test contains volume heal commands handled by glusterd.
-# Covers enable/disable at the moment. Will be enhanced later to include
-# the other commands as well.
-
-cleanup;
-TEST glusterd
-TEST pidof glusterd
-
-volfile=$(gluster system:: getwd)"/glustershd/glustershd-server.vol"
-
-# Commands should fail when both tiers are not of distribute type.
-# Glustershd shouldn't be running as long as there are no replicate/disperse
-# volumes
-TEST $CLI volume create dist_tier $H0:$B0/cold
-TEST $CLI volume start dist_tier
-TEST $CLI volume attach-tier dist_tier $H0:$B0/hot
-
-TEST "[ -z $(get_shd_process_pid)]"
-TEST ! $CLI volume heal dist_tier enable
-TEST ! $CLI volume heal dist_tier disable
-
-# Commands should work on replicate/disperse volume.
-TEST $CLI volume create r2 replica 2 $H0:$B0/r2_0 $H0:$B0/r2_1
-TEST "[ -z $(get_shd_process_pid)]"
-TEST $CLI volume start r2
-
-TEST $CLI volume attach-tier r2 $H0:$B0/r2_hot
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-TEST $CLI volume heal r2 enable
-EXPECT "enable" volume_option r2 "cluster.self-heal-daemon"
-EXPECT "enable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-TEST $CLI volume heal r2 disable
-EXPECT "disable" volume_option r2 "cluster.self-heal-daemon"
-EXPECT "disable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-# Commands should work on disperse volume.
-TEST $CLI volume create ec2 disperse 3 redundancy 1 $H0:$B0/ec2_0 $H0:$B0/ec2_1 $H0:$B0/ec2_2
-TEST $CLI volume start ec2
-
-TEST $CLI volume attach-tier ec2 replica 2 $H0:$B0/ec2_hot{1..4}
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-TEST $CLI volume heal ec2 enable
-EXPECT "enable" volume_option ec2 "cluster.disperse-self-heal-daemon"
-EXPECT "enable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-TEST $CLI volume heal ec2 disable
-EXPECT "disable" volume_option ec2 "cluster.disperse-self-heal-daemon"
-EXPECT "disable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid
-
-#Check that shd graph is rewritten correctly on volume stop/start
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
-TEST $CLI volume stop r2
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "N" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
-TEST $CLI volume stop ec2
-# When both the volumes are stopped glustershd volfile is not modified just the
-# process is stopped
-TEST "[ -z $(get_shd_process_pid) ]"
-
-TEST $CLI volume start r2
-EXPECT "N" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate
-
-TEST $CLI volume start ec2
-
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "Y" volgen_volume_exists $volfile ec2-replicate-0 cluster replicate
-
-TEST $CLI volume detach-tier ec2 force
-
-EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse
-EXPECT "N" volgen_volume_exists $volfile ec2-replicate-0 cluster replicate
-
-TEST $CLI volume set r2 self-heal-daemon on
-TEST $CLI volume set r2 cluster.self-heal-daemon off
-TEST ! $CLI volume set ec2 self-heal-daemon off
-TEST ! $CLI volume set ec2 cluster.self-heal-daemon on
-TEST ! $CLI volume set dist self-heal-daemon off
-TEST ! $CLI volume set dist cluster.self-heal-daemon on
-
-TEST $CLI volume set ec2 disperse-self-heal-daemon off
-TEST $CLI volume set ec2 cluster.disperse-self-heal-daemon on
-TEST ! $CLI volume set r2 disperse-self-heal-daemon on
-TEST ! $CLI volume set r2 cluster.disperse-self-heal-daemon off
-TEST ! $CLI volume set dist disperse-self-heal-daemon off
-TEST ! $CLI volume set dist cluster.disperse-self-heal-daemon on
-
-cleanup
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/tier-snapshot.t b/tests/basic/tier/tier-snapshot.t
deleted file mode 100644
index 6d040d711c8..00000000000
--- a/tests/basic/tier/tier-snapshot.t
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../snapshot.rc
-
-cleanup;
-
-TEST init_n_bricks 4;
-TEST setup_lvm 4;
-
-TEST glusterd;
-
-TEST $CLI volume create $V0 replica 2 $H0:$L1 $H0:$L2 ;
-
-TEST $CLI volume start $V0;
-
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$L3 $H0:$L4 ;
-
-TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0;
-
-for i in {1..10} ; do echo "file" > $M0/file$i ; done
-
-TEST $CLI snapshot config activate-on-create enable
-
-TEST $CLI snapshot create snap1 $V0 no-timestamp;
-
-for i in {11..20} ; do echo "file" > $M0/file$i ; done
-
-TEST $CLI snapshot create snap2 $V0 no-timestamp;
-
-mkdir $M0/dir1;
-mkdir $M0/dir2;
-
-for i in {1..10} ; do echo "foo" > $M0/dir1/foo$i ; done
-for i in {1..10} ; do echo "foo" > $M0/dir2/foo$i ; done
-
-TEST $CLI snapshot create snap3 $V0 no-timestamp;
-
-for i in {11..20} ; do echo "foo" > $M0/dir1/foo$i ; done
-for i in {11..20} ; do echo "foo" > $M0/dir2/foo$i ; done
-
-TEST $CLI snapshot create snap4 $V0 no-timestamp;
-
-TEST $CLI snapshot delete all;
-
-cleanup;
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/tier/tier.t b/tests/basic/tier/tier.t
deleted file mode 100755
index 1798541becd..00000000000
--- a/tests/basic/tier/tier.t
+++ /dev/null
@@ -1,219 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-LAST_BRICK=3
-CACHE_BRICK_FIRST=4
-CACHE_BRICK_LAST=5
-DEMOTE_TIMEOUT=12
-PROMOTE_TIMEOUT=5
-MIGRATION_TIMEOUT=10
-DEMOTE_FREQ=4
-PROMOTE_FREQ=12
-
-function file_on_slow_tier {
-    found=0
-
-    for i in `seq 0 $LAST_BRICK`; do
-        test -e "$B0/${V0}${i}/$1" && found=1 && break;
-    done
-
-    if [ "$found" == "1" ]
-    then
-        slow_hash1=$2
-        slow_hash2=$(fingerprint "$B0/${V0}${i}/$1")
-
-        if [ "$slow_hash1" == "$slow_hash2" ]
-            then
-                echo "0"
-            else
-                echo "2"
-        fi
-    else
-        echo "1"
-    fi
-
-    # temporarily disable non-Linux tests.
-    case $OSTYPE in
-        NetBSD | FreeBSD | Darwin)
-            echo "0"
-            ;;
-    esac
-}
-
-function file_on_fast_tier {
-    found=0
-
-    for j in `seq $CACHE_BRICK_FIRST $CACHE_BRICK_LAST`; do
-        test -e "$B0/${V0}${j}/$1" && found=1 && break;
-    done
-
-
-    if [ "$found" == "1" ]
-    then
-        fast_hash1=$2
-        fast_hash2=$(fingerprint "$B0/${V0}${j}/$1")
-
-        if [ "$fast_hash1" == "$fast_hash2" ]
-            then
-                echo "0"
-            else
-                echo "2"
-        fi
-    else
-        echo "1"
-    fi
-}
-
-
-cleanup
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-# testing bug 1215122, ie should fail if replica count and bricks are not compatible.
-
-TEST ! $CLI volume tier $V0 attach replica 5 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-
-TEST $CLI volume start $V0
-
-# The following two commands instigate a graph switch. Do them
-# before attaching the tier. If done on a tiered volume the rebalance
-# daemon will terminate and must be restarted manually.
-TEST $CLI volume set $V0 performance.quick-read off
-TEST $CLI volume set $V0 performance.io-cache off
-
-#Not a tier volume
-TEST ! $CLI volume set $V0 cluster.tier-demote-frequency 4
-
-#testing bug #1228112, glusterd crashed when trying to detach-tier commit force on a non-tiered volume.
-TEST ! $CLI volume tier $V0 detach commit force
-
-TEST $CLI volume tier $V0 attach replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-
-TEST $CLI volume set $V0 cluster.tier-mode test
-
-# create a file, make sure it can be deleted after attach tier.
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-cd $M0
-TEST touch delete_me.txt
-TEST rm -f delete_me.txt
-
-# confirm watermark CLI works
-TEST $CLI volume set $V0 cluster.watermark-hi 85
-TEST $CLI volume set $V0 cluster.watermark-low 75
-TEST $CLI volume set $V0 cluster.tier-max-mb 1000
-TEST $CLI volume set $V0 cluster.tier-max-files 1000
-TEST $CLI volume set $V0 cluster.tier-max-promote-file-size 1000
-TEST ! $CLI volume set $V0 cluster.tier-max-files -3
-TEST ! $CLI volume set $V0 cluster.watermark-low 90
-TEST ! $CLI volume set $V0 cluster.watermark-hi 75
-TEST ! $CLI volume set $V0 cluster.read-freq-threshold -12
-TEST ! $CLI volume set $V0 cluster.write-freq-threshold -12
-
-#check for watermark reset
-TEST $CLI volume set $V0 cluster.watermark-low 10
-TEST $CLI volume set $V0 cluster.watermark-hi 30
-TEST ! $CLI volume reset $V0 cluster.watermark-low
-TEST $CLI volume reset $V0 cluster.watermark-hi
-TEST $CLI volume reset $V0 cluster.watermark-low
-
-# stop the volume and restart it. The rebalance daemon should restart.
-cd /tmp
-umount $M0
-TEST $CLI volume stop $V0
-TEST $CLI volume start $V0
-
-wait_for_tier_start
-
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-cd $M0
-
-sleep_first_cycle $DEMOTE_FREQ
-$CLI volume tier $V0 status
-
-#Tier options expect non-negative value
-TEST ! $CLI volume set $V0 cluster.tier-promote-frequency -1
-
-#Tier options expect non-negative value
-TEST ! $CLI volume set $V0 cluster.read-freq-threshold qwerty
-
-
-TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-
-# Basic operations.
-TEST stat .
-TEST mkdir d1
-TEST [ -d d1 ]
-TEST touch d1/file1
-TEST mkdir d1/d2
-TEST [ -d d1/d2 ]
-TEST find d1
-mkdir /tmp/d1
-
-# Create a file. It should be on the fast tier.
-uuidgen > /tmp/d1/data.txt
-md5data=$(fingerprint /tmp/d1/data.txt)
-mv /tmp/d1/data.txt ./d1/data.txt
-
-TEST file_on_fast_tier d1/data.txt $md5data
-
-uuidgen > /tmp/d1/data2.txt
-md5data2=$(fingerprint /tmp/d1/data2.txt)
-cp /tmp/d1/data2.txt ./d1/data2.txt
-
-#File with spaces and special characters.
-SPACE_FILE="file with spaces & $peci@l ch@r@cter$ @!@$%^$#@^^*&%$#$%.txt"
-
-uuidgen > "/tmp/d1/$SPACE_FILE"
-md5space=$(fingerprint "/tmp/d1/$SPACE_FILE")
-mv "/tmp/d1/$SPACE_FILE" "./d1/$SPACE_FILE"
-
-# Check auto-demotion on write new.
-sleep $DEMOTE_TIMEOUT
-
-# Check auto-promotion on write append.
-UUID=$(uuidgen)
-echo $UUID >> /tmp/d1/data2.txt
-md5data2=$(fingerprint /tmp/d1/data2.txt)
-
-sleep_until_mid_cycle $DEMOTE_FREQ
-drop_cache $M0
-
-echo $UUID >> ./d1/data2.txt
-cat "./d1/$SPACE_FILE"
-
-sleep $PROMOTE_TIMEOUT
-sleep $DEMOTE_FREQ
-EXPECT_WITHIN $DEMOTE_TIMEOUT "0" check_counters 2 6
-
-# stop gluster, when it comes back info file should have tiered volume
-killall glusterd
-TEST glusterd
-
-EXPECT "0" file_on_slow_tier d1/data.txt $md5data
-EXPECT "0" file_on_slow_tier d1/data2.txt $md5data2
-EXPECT "0" file_on_slow_tier "./d1/$SPACE_FILE" $md5space
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" detach_start $V0
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0 $H0:$B0/${V0}${CACHE_BRICK_FIRST}"
-
-TEST $CLI volume tier $V0 detach commit
-
-EXPECT "0" confirm_tier_removed ${V0}${CACHE_BRICK_FIRST}
-
-confirm_vol_stopped $V0
-
-cd;
-
-cleanup
-rm -rf /tmp/d1
-
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/tier_lookup_heal.t b/tests/basic/tier/tier_lookup_heal.t
deleted file mode 100755
index 7dac1fdf1ec..00000000000
--- a/tests/basic/tier/tier_lookup_heal.t
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-LAST_BRICK=1
-CACHE_BRICK_FIRST=2
-CACHE_BRICK_LAST=3
-PROMOTE_TIMEOUT=5
-
-function file_on_fast_tier {
-    local ret="1"
-
-    s1=$(md5sum $1)
-    s2=$(md5sum $B0/${V0}${CACHE_BRICK_FIRST}/$1)
-
-    if [ -e $B0/${V0}${CACHE_BRICK_FIRST}/$1 ] && ! [ "$s1" == "$s2" ]; then
-        echo "0"
-    else
-        echo "1"
-    fi
-}
-
-cleanup
-
-
-TEST glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-TEST $CLI volume start $V0
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-
-# Create files before CTR xlator is on.
-cd $M0
-TEST stat .
-TEST touch file1
-TEST stat file1
-
-# gf_file_tb and gf_flink_tb should be empty
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}$LAST_BRICK/.glusterfs/${V0}$LAST_BRICK.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 0 ]
-
-
-#Attach tier and switch ON CTR Xlator.
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-TEST $CLI volume set $V0 features.ctr-enabled on
-TEST $CLI volume set $V0 cluster.tier-demote-frequency 4
-TEST $CLI volume set $V0 cluster.tier-promote-frequency 4
-TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-TEST $CLI volume set $V0 performance.quick-read off
-TEST $CLI volume set $V0 performance.io-cache off
-TEST $CLI volume set $V0 cluster.tier-mode test
-
-#The lookup should heal the database.
-TEST ls file1
-
-# gf_file_tb and gf_flink_tb should NOT be empty
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}$LAST_BRICK/.glusterfs/${V0}$LAST_BRICK.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 2 ]
-
-# Heat-up the file
-uuidgen > file1
-sleep 5
-
-#Check if the file is promoted
-EXPECT_WITHIN $PROMOTE_TIMEOUT "0" file_on_fast_tier file1
-
-cd;
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/basic/tier/tierd_check.t b/tests/basic/tier/tierd_check.t
deleted file mode 100644
index 55ca09a6b2f..00000000000
--- a/tests/basic/tier/tierd_check.t
+++ /dev/null
@@ -1,128 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-. $(dirname $0)/../../cluster.rc
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function check_peers {
-    $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-function create_dist_tier_vol () {
-        TEST $CLI_1 volume create $V0 $H1:$B1/${V0} $H2:$B2/${V0}
-        TEST $CLI_1 volume start $V0
-        TEST $CLI_1 volume attach-tier $V0 $H1:$B1/${V0}_h1 $H2:$B2/${V0}_h2
-}
-
-function tier_status () {
-	#$CLI_1 volume tier $V0 status | grep progress | wc -l
-	# I don't want to disable the entire test, but this part of it seems
-	# highly suspect.  *Why* do we always expect the number of lines to be
-	# exactly two?  What would it mean for it to be otherwise?  Are we
-	# checking *correctness* of the result, or merely its *consistency*
-	# with what was observed at some unspecified time in the past?  Does
-	# this check only serve to inhibit actual improvements?  Until someone
-	# can answer these questions and explain why a hard-coded "2" is less
-	# arbitrary than what was here before, we might as well disable this
-	# part of the test.
-	echo "2"
-}
-
-function tier_daemon_kill () {
-pkill -f "tierd/$V0"
-echo "$?"
-}
-
-cleanup;
-
-#setup cluster and test volume
-TEST launch_cluster 3; # start 3-node virtual cluster
-TEST $CLI_1 peer probe $H2; # peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H3; # peer probe server 3 from server 1 cli
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers;
-
-#Create and start a tiered volume
-create_dist_tier_vol
-
-wait_for_tier_start
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 tier_daemon_check
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 tier_daemon_kill
-
-TEST $CLI_1 volume tier $V0 start
-
-wait_for_tier_start
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_daemon_check
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_daemon_kill
-
-TEST $CLI_3 volume tier $V0 start force
-
-wait_for_tier_start
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_daemon_check
-
-#The pattern progress should occur twice only.
-#it shouldn't come up on the third node without tierd even
-#after the tier start force is issued on the node without
-#tierd
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-#kill the node on which tier is not supposed to run
-TEST kill_node 3
-
-#bring the node back, it should not have tierd running on it
-TEST $glusterd_3;
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-#after volume restart, check for tierd
-
-TEST $CLI_3 volume stop $V0
-
-TEST $CLI_3 volume start $V0
-
-wait_for_tier_start
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-#check for detach start and stop
-
-TEST $CLI_3 volume tier $V0 detach start
-
-TEST $CLI_3 volume tier $V0 detach stop
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" tier_status
-
-TEST $CLI_1 volume tier $V0 start force
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_daemon_check
-
-# To test for detach start fail while the brick is down
-
-TEST pkill -f "$B1/$V0"
-
-TEST ! $CLI_1 volume tier $V0 detach start
-
-cleanup
-# This test isn't worth keeping.  Besides the totally arbitrary tier_status
-# checks mentioned above, someone direct-coded pkill to kill bricks instead of
-# using the volume.rc function we already had.  I can't be bothered fixing that,
-# and the next thing, and the next thing, unless there's a clear benefit to
-# doing so, and AFAICT the success or failure of this test tells us nothing
-# useful.  Therefore, it's disabled until further notice.
-#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=000000
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/tier/unlink-during-migration.t b/tests/basic/tier/unlink-during-migration.t
deleted file mode 100755
index 0c2255cfda6..00000000000
--- a/tests/basic/tier/unlink-during-migration.t
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-DEMOTE_FREQ=5
-PROMOTE_FREQ=5
-
-function create_dist_rep_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 replica 2 $H0:$B0/cold/${V0}{0..3}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume set $V0 features.ctr-enabled on
-        TEST $CLI volume start $V0
-}
-
-function attach_dist_rep_tier () {
-        TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/hot/${V0}{0..3}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 0
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-
-#Create and start a volume
-create_dist_rep_vol
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-# Create a large file (320MB), so that rebalance takes time
-TEST dd if=/dev/zero of=$M0/foo bs=64k count=5120
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  foo`
-echo "File path on cold tier: "$CPATH
-
-#Now attach the tier
-attach_dist_rep_tier
-
-#Write into the file to promote it
-echo "good morning">>$M0/foo
-
-# Wait for the tier process to promote the file
-EXPECT_WITHIN $REBALANCE_TIMEOUT "yes" is_sticky_set $CPATH
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  foo`
-
-echo "File path on hot tier: "$HPATH
-TEST rm -rf $M0/foo
-TEST ! stat $HPATH
-TEST ! stat $CPATH
-
-#unlink during demotion
-HPATH="";
-CPATH="";
-
-# Create a large file (320MB), so that rebalance takes time
-TEST dd if=/dev/zero of=$M0/foo1 bs=64k count=5120
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  foo1`
-echo "File path on hot tier : "$HPATH
-
-EXPECT_WITHIN $REBALANCE_TIMEOUT "yes" is_sticky_set $HPATH
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  foo1`
-echo "File path on cold tier : "$CPATH
-
-TEST rm -rf $M0/foo1
-
-TEST ! stat $HPATH
-TEST ! stat $CPATH
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/basic/trace.t b/tests/basic/trace.t
new file mode 100755
index 00000000000..01e7c9e0a25
--- /dev/null
+++ b/tests/basic/trace.t
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST mkdir -p $B0/single-brick
+cat > $B0/template.vol <<EOF
+volume posix
+  type storage/posix
+  option directory $B0/single-brick
+end-volume
+
+volume trace
+  type debug/trace
+  option log-file yes
+  option log-history yes
+  subvolumes posix
+end-volume
+EOF
+
+TEST glusterfs -f $B0/template.vol $M0
+
+TEST $(dirname $0)/rpc-coverage.sh --no-locks $M0
+
+# Take statedump to get maximum code coverage
+pid=$(ps auxww | grep glusterfs | grep -E "template.vol" | awk '{print $2}' | head -1)
+
+TEST generate_statedump $pid
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+# Now, use the glusterd way of enabling trace
+TEST glusterd
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6};
+
+TEST $CLI volume set $V0 debug.trace marker
+TEST $CLI volume set $V0 debug.log-file yes
+#TEST $CLI volume set $V0 debug.log-history yes
+
+TEST $CLI volume start $V0;
+
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+TEST $(dirname $0)/rpc-coverage.sh --no-locks $M1
+cp $(dirname ${0})/gfapi/glfsxmp-coverage.c ./glfsxmp.c
+build_tester ./glfsxmp.c -lgfapi
+./glfsxmp $V0 $H0 > /dev/null
+cleanup_tester ./glfsxmp
+rm ./glfsxmp.c
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
+
+cleanup;
diff --git a/tests/basic/uss.t b/tests/basic/uss.t
index 6cfc0303895..09dd00ef995 100644
--- a/tests/basic/uss.t
+++ b/tests/basic/uss.t
@@ -6,6 +6,8 @@
 . $(dirname $0)/../fileio.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 function check_readonly()
 {
     $@ 2>&1 | grep -q 'Read-only file system'
@@ -34,6 +36,7 @@ TEST glusterd;
 TEST pidof glusterd;
 
 TEST $CLI volume create $V0 $H0:$L1 $H0:$L2 $H0:$L3;
+
 TEST $CLI volume set $V0 nfs.disable false
 
 
@@ -52,6 +55,7 @@ TEST ln $M0/f1 $M0/dir/f3
 TEST $CLI snapshot config activate-on-create enable
 TEST $CLI volume set $V0 features.uss enable;
 
+TEST ! $CLI snapshot create snap1 $V0 no-timestamp description "";
 TEST $CLI snapshot create snap1 $V0 no-timestamp;
 
 for i in {11..20} ; do echo "file" > $M0/file$i ; done
@@ -371,6 +375,15 @@ TEST rm -f $M0/aaa;
 
 TEST $CLI snapshot delete snap6;
 
+# drop the caches so that, the dentry for "snap6" is
+# is forgotten from the client cache.
+drop_cache $M0
+
+EXPECT_WITHIN 30 "5" count_snaps $M0;
+
+# This should fail, as snap6 just got deleted.
+TEST ! stat $M0/.history/snap6
+
 TEST $CLI snapshot create snap6 $V0 no-timestamp
 
 TEST ls $M0/.history;
@@ -381,4 +394,28 @@ TEST ls $M0/.history/snap6/;
 
 TEST ! stat $M0/.history/snap6/aaa;
 
+TEST stat $M0
+
+# done with the tests start cleaning up of things
+TEST $CLI volume set $V0 features.uss disable
+
+TEST $CLI snapshot delete snap6;
+
+TEST $CLI snapshot delete snap5;
+
+TEST $CLI snapshot delete snap4;
+
+TEST $CLI snapshot delete snap3;
+
+TEST $CLI snapshot delete snap2;
+
+TEST $CLI snapshot delete snap1;
+
+# nfs client has been already unmounted at line 333
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST $CLI volume stop $V0
+
+TEST $CLI volume delete $V0
+
 cleanup;
diff --git a/tests/basic/volfile-sanity.t b/tests/basic/volfile-sanity.t
new file mode 100644
index 00000000000..ef2f9344468
--- /dev/null
+++ b/tests/basic/volfile-sanity.t
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0  $H0:$B0/${V0}1
+
+killall glusterd
+
+# Client by default tries to connect to port 24007
+# So, start server on that port, and you can see
+# client successfully working.
+TEST $GFS --xlator-option "${V0}-server.transport.socket.listen-port=24007" \
+     -f /var/lib/glusterd/vols/${V0}/${V0}.${H0}.*.vol
+TEST $GFS -f /var/lib/glusterd/vols/${V0}/${V0}.tcp-fuse.vol $M0
+
+TEST $(df -h $M0 | grep -q ${V0})
+TEST $(cat /proc/mounts | grep -q $M0)
+
+TEST ! stat $M0/newfile;
+TEST touch $M0/newfile;
+TEST rm $M0/newfile;
+
+cleanup;
diff --git a/tests/basic/volume-scale-shd-mux.t b/tests/basic/volume-scale-shd-mux.t
new file mode 100644
index 00000000000..102de22468e
--- /dev/null
+++ b/tests/basic/volume-scale-shd-mux.t
@@ -0,0 +1,116 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TESTS_EXPECTED_IN_LOOP=6
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 cluster.background-self-heal-count 0
+TEST $CLI volume set $V0 cluster.eager-lock off
+TEST $CLI volume set $V0 performance.flush-behind off
+TEST $CLI volume start $V0
+
+for i in $(seq 1 2); do
+   TEST $CLI volume create ${V0}_afr$i replica 3 $H0:$B0/${V0}_afr${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_afr$i
+   TEST $CLI volume create ${V0}_ec$i disperse 6 redundancy 2 $H0:$B0/${V0}_ec${i}{0,1,2,3,4,5}
+   TEST $CLI volume start ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+#Check the thread count become to number of volumes*number of ec subvolume (2*6=12)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+#Check the thread count become to number of volumes*number of afr subvolume (3*6=18)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}{6,7,8};
+#Check the thread count become to number of volumes*number of afr subvolume plus 3 additional threads from newly added bricks (3*6+3=21)
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^21$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#Remove the brick and check the detach is successful
+$CLI volume remove-brick $V0 $H0:$B0/${V0}{6,7,8} force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" number_healer_threads_shd $V0 "glusterfs_graph_cleanup"
+TEST $CLI volume add-brick ${V0}_ec1 $H0:$B0/${V0}_ec1_add{0,1,2,3,4,5};
+#Check the thread count become to number of volumes*number of ec subvolume plus 2 additional threads from newly added bricks (2*6+6=18)
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^18$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+
+#Remove the brick and check the detach is successful
+$CLI volume remove-brick ${V0}_ec1 $H0:$B0/${V0}_ec1_add{0,1,2,3,4,5} force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^12$" number_healer_threads_shd $V0 "ec_shd_index_healer"
+
+
+for i in $(seq 1 2); do
+   TEST $CLI volume stop ${V0}_afr$i
+   TEST $CLI volume stop ${V0}_ec$i
+done
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}4
+
+TEST touch $M0/foo{1..100}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^204$" get_pending_heal_count $V0
+
+TEST $CLI volume start ${V0} force
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+TEST rm -rf $M0/*
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+shd_pid=$(get_shd_mux_pid $V0)
+TEST $CLI volume create ${V0}_distribute1 $H0:$B0/${V0}_distribute10
+TEST $CLI volume start ${V0}_distribute1
+
+#Creating a non-replicate/non-ec volume should not have any effect in shd
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+EXPECT "^${shd_pid}$" get_shd_mux_pid $V0
+
+TEST mkdir $B0/add/
+#Now convert the distributed volume to replicate
+TEST $CLI volume add-brick ${V0}_distribute1 replica 3 $H0:$B0/add/{2..3}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^9$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#scale down the volume
+TEST $CLI volume remove-brick ${V0}_distribute1 replica 1 $H0:$B0/add/{2..3} force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^6$" number_healer_threads_shd $V0 "afr_shd_index_healer"
+
+#Before stopping the process, make sure there is no pending clenup threads hanging
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" number_healer_threads_shd $V0 "glusterfs_graph_cleanup"
+
+TEST $CLI volume stop ${V0}
+TEST $CLI volume delete ${V0}
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+
+TEST rm -rf $B0/add/2 $B0/add/3
+
+#Now convert the distributed volume back to replicate and make sure that a new shd is spawned
+TEST $CLI volume add-brick ${V0}_distribute1 replica 3 $H0:$B0/add/{2..3};
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" shd_count
+EXPECT_WITHIN $HEAL_TIMEOUT "^3$" number_healer_threads_shd ${V0}_distribute1 "afr_shd_index_healer"
+
+#Now convert the replica volume to distribute again and make sure the shd is now stopped
+TEST $CLI volume remove-brick ${V0}_distribute1 replica 1 $H0:$B0/add/{2..3} force
+TEST rm -rf $B0/add/
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^0$" shd_count
+
+cleanup
+
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=1708929
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=1708929
diff --git a/tests/basic/volume-snap-scheduler.t b/tests/basic/volume-snap-scheduler.t
new file mode 100644
index 00000000000..a638c5cc46a
--- /dev/null
+++ b/tests/basic/volume-snap-scheduler.t
@@ -0,0 +1,49 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
+TEST $CLI volume start $V0
+
+## Create, start and mount meta_volume as
+## snap_scheduler expects shared storage to be enabled.
+## This test is very basic in nature not creating any snapshot
+## and purpose is to validate snap scheduling commands.
+
+TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
+TEST $CLI volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT
+
+##function to check status
+function check_status_scheduler()
+{
+     local key=$1
+     snap_scheduler.py status | grep -F "$key" | wc -l
+}
+
+##Basic snap_scheduler command test init/enable/disable/list
+
+TEST snap_scheduler.py init
+
+TEST snap_scheduler.py enable
+
+EXPECT 1 check_status_scheduler "Enabled"
+
+TEST snap_scheduler.py disable
+
+EXPECT 1 check_status_scheduler "Disabled"
+
+TEST snap_scheduler.py list
+
+TEST $CLI volume stop $V0;
+
+TEST $CLI volume delete $V0;
+
+cleanup;
diff --git a/tests/basic/volume-snapshot-xml.t b/tests/basic/volume-snapshot-xml.t
index 3ba25f4ddbb..ff63b54538d 100755
--- a/tests/basic/volume-snapshot-xml.t
+++ b/tests/basic/volume-snapshot-xml.t
@@ -1,13 +1,9 @@
 #!/bin/bash
 
 . $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
 . $(dirname $0)/../snapshot.rc
 
-function get-xml()
-{
-        $CLI $1 --xml | xmllint --format - | grep $2 | sed 's/\(<"$2">\|<\/"$2">\)//g'
-}
-
 cleanup;
 TEST verify_lvm_version;
 TEST glusterd;
diff --git a/tests/basic/volume-status.t b/tests/basic/volume-status.t
index f87b0a93edf..01d7ebf6c07 100644
--- a/tests/basic/volume-status.t
+++ b/tests/basic/volume-status.t
@@ -4,13 +4,27 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
+function gluster_client_list_status () {
+        gluster volume status $V0 client-list | sed -n '/Name/','/total/'p | wc -l
+}
+
+function gluster_fd_status () {
+        gluster volume status $V0 fd | sed -n '/Brick :/ p' | wc -l
+}
+
+function gluster_inode_status () {
+        gluster volume status $V0 inode | sed -n '/Connection / p' | wc -l
+}
+
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 TEST $CLI volume set $V0 nfs.disable false
 
 TEST $CLI volume start $V0;
@@ -20,6 +34,14 @@ EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" nfs_up_status
 
 ## Mount FUSE
 TEST $GFS -s $H0 --volfile-id $V0 $M0;
+TEST touch $M0/file{1..20}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "6" gluster_fd_status
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "768" gluster_inode_status
+
+##Disabling this test until the client-list command works for brick-multiplexing
+#EXPECT_WITHIN $PROCESS_UP_TIMEOUT "7" gluster_client_list_status
 
 ##Wait for connection establishment between nfs server and brick process
 EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
@@ -36,6 +58,8 @@ function test_nfs_cmds () {
     for cmd in ${nfs_cmds[@]}; do
         $CLI volume status $V0 nfs $cmd
         (( ret += $? ))
+        $CLI volume status $V0 nfs $cmd --xml
+        (( ret += $? ))
     done
     return $ret
 }
@@ -46,6 +70,8 @@ function test_shd_cmds () {
     for cmd in ${shd_cmds[@]}; do
         $CLI volume status $V0 shd $cmd
         (( ret += $? ))
+        $CLI volume status $V0 shd $cmd --xml
+        (( ret += $? ))
     done
     return $ret
 }
@@ -57,14 +83,29 @@ function test_brick_cmds () {
         for i in {1..2}; do
             $CLI volume status $V0 $H0:$B0/${V0}$i $cmd
             (( ret += $? ))
+            $CLI volume status $V0 $H0:$B0/${V0}$i $cmd --xml
+            (( ret += $? ))
         done
     done
     return $ret
 }
 
+function test_status_cmds () {
+    local ret=0
+    declare -a cmds=("detail" "clients" "mem" "inode" "fd" "callpool" "tasks" "client-list")
+    for cmd in ${cmds[@]}; do
+        $CLI volume status $V0 $cmd
+        (( ret += $? ))
+        $CLI volume status $V0 $cmd --xml
+        (( ret += $? ))
+    done
+    return $ret
+}
+
 TEST test_shd_cmds;
 TEST test_nfs_cmds;
 TEST test_brick_cmds;
+TEST test_status_cmds;
 
 
 ## Before killing daemon to avoid deadlocks
diff --git a/tests/basic/volume.t b/tests/basic/volume.t
index 23b740af1ed..27fe093d07d 100755..100644
--- a/tests/basic/volume.t
+++ b/tests/basic/volume.t
@@ -9,26 +9,52 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '8' brick_count $V0
+EXPECT '6' brick_count $V0
 
 TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
 
-TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{9,10,11,12};
-EXPECT '12' brick_count $V0
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{9,10,11};
+EXPECT '9' brick_count $V0
+
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}{1,2,3} force;
+EXPECT '6' brick_count $V0
+
+TEST $CLI volume top $V0 read-perf bs 4096 count 1000
+TEST $CLI volume top $V0 write-perf bs 1048576 count 2
+
+TEST touch $M0/foo
+
+# statedump path should be a directory, setting it to a file path should fail
+
+TEST ! $CLI v set $V0 server.statedump-path $M0/foo;
+EXPECT '/var/run/gluster' $CLI v get $V0 server.statedump-path
+
+#set the statedump path to an existing ditectory which should succeed
+TEST mkdir $D0/level;
+TEST $CLI v set $V0 server.statedump-path $D0/level
+EXPECT '/level' volinfo_field $V0 'server.statedump-path'
+
+ret=$(ls $D0/level | wc -l);
+TEST [ $ret == 0 ]
+TEST $CLI v statedump $V0;
+ret=$(ls $D0/level | wc -l);
+TEST ! [ $ret == 0 ]
+
+#set the statedump path to a non - existing directory which should fail
+TEST ! $CLI v set $V0 server.statedump-path /root/test
+EXPECT '/level' volinfo_field $V0 'server.statedump-path'
 
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}{1,2,3,4} force;
-EXPECT '8' brick_count $V0
+TEST rm -rf $D0/level
 
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
+TEST $CLI volume stop $V0
+EXPECT 'Stopped' volinfo_field $V0 'Status'
 
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
+TEST $CLI volume delete $V0
+TEST ! $CLI volume info $V0
 
 cleanup;
diff --git a/tests/basic/xlator-pass-through-sanity.t b/tests/basic/xlator-pass-through-sanity.t
new file mode 100644
index 00000000000..e996be89260
--- /dev/null
+++ b/tests/basic/xlator-pass-through-sanity.t
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}
+TEST $CLI volume set $V0 performance.io-cache-pass-through enable;
+TEST $CLI volume start $V0;
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+# This test covers lookup, mkdir, mknod, symlink, link, rename,
+# create operations
+TEST $(dirname $0)/rpc-coverage.sh $M1
+
+cleanup;
diff --git a/tests/bitrot/br-signer-threads-config-1797869.t b/tests/bitrot/br-signer-threads-config-1797869.t
new file mode 100644
index 00000000000..657ef3eedaf
--- /dev/null
+++ b/tests/bitrot/br-signer-threads-config-1797869.t
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../cluster.rc
+
+function get_bitd_count_1 {
+        ps auxww | grep glusterfs | grep bitd.pid | grep -v grep | grep $H1 | wc -l
+}
+
+function get_bitd_count_2 {
+        ps auxww | grep glusterfs | grep bitd.pid | grep -v grep | grep $H2 | wc -l
+}
+
+function get_bitd_pid_1 {
+        ps auxww | grep glusterfs | grep bitd.pid | grep -v grep | grep $H1 | awk '{print $2}'
+}
+
+function get_bitd_pid_2 {
+        ps auxww | grep glusterfs | grep bitd.pid | grep -v grep | grep $H2 | awk '{print $2}'
+}
+
+function get_signer_th_count_1 {
+        ps -eL | grep $(get_bitd_pid_1) | grep glfs_brpobj | wc -l
+}
+
+function get_signer_th_count_2 {
+        ps -eL | grep $(get_bitd_pid_2) | grep glfs_brpobj | wc -l
+}
+
+cleanup;
+
+TEST launch_cluster 2
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
+
+TEST $CLI_1 volume create $V0 $H1:$B1
+TEST $CLI_1 volume create $V1 $H2:$B2
+EXPECT 'Created' volinfo_field_1 $V0 'Status';
+EXPECT 'Created' volinfo_field_1 $V1 'Status';
+
+TEST $CLI_1 volume start $V0
+TEST $CLI_1 volume start $V1
+EXPECT 'Started' volinfo_field_1 $V0 'Status';
+EXPECT 'Started' volinfo_field_1 $V1 'Status';
+
+#Enable bitrot
+TEST $CLI_1 volume bitrot $V0 enable
+TEST $CLI_1 volume bitrot $V1 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count_1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count_2
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "4" get_signer_th_count_1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "4" get_signer_th_count_2
+
+old_bitd_pid_1=$(get_bitd_pid_1)
+old_bitd_pid_2=$(get_bitd_pid_2)
+TEST $CLI_1 volume bitrot $V0 signer-threads 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_signer_th_count_1
+EXPECT_NOT "$old_bitd_pid_1" get_bitd_pid_1;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "4" get_signer_th_count_2
+EXPECT "$old_bitd_pid_2" get_bitd_pid_2;
+
+old_bitd_pid_1=$(get_bitd_pid_1)
+old_bitd_pid_2=$(get_bitd_pid_2)
+TEST $CLI_1 volume bitrot $V1 signer-threads 2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" get_signer_th_count_2
+EXPECT_NOT "$old_bitd_pid_2" get_bitd_pid_2;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_signer_th_count_1
+EXPECT "$old_bitd_pid_1" get_bitd_pid_1;
+
+cleanup;
diff --git a/tests/bitrot/br-state-check.t b/tests/bitrot/br-state-check.t
index e165462cfcd..2142275699e 100644
--- a/tests/bitrot/br-state-check.t
+++ b/tests/bitrot/br-state-check.t
@@ -5,6 +5,7 @@
 . $(dirname $0)/../nfs.rc
 
 cleanup;
+SCRIPT_TIMEOUT=350
 
 TEST glusterd
 TEST pidof glusterd
diff --git a/tests/bitrot/br-stub.c b/tests/bitrot/br-stub.c
index 5b862832e77..1111f710f59 100644
--- a/tests/bitrot/br-stub.c
+++ b/tests/bitrot/br-stub.c
@@ -15,179 +15,181 @@
 
 /* NOTE: no size discovery */
 int
-brstub_validate_version (char *bpath, unsigned long version)
+brstub_validate_version(char *bpath, unsigned long version)
 {
-        int ret = 0;
-        int match = 0;
-        size_t xsize = 0;
-        br_version_t *xv = NULL;
-
-        xsize = sizeof (br_version_t);
-
-        xv = calloc (1, xsize);
-        if (!xv) {
-                match = -1;
-                goto err;
-        }
-
-        ret = getxattr (bpath, "trusted.bit-rot.version", xv, xsize);
-        if (ret < 0) {
-                if (errno == ENODATA)
-                        match = -2;
-                goto err;
-        }
-
-        if (xv->ongoingversion != version) {
-                match = -3;
-                fprintf (stderr, "ongoingversion: %lu\n", xv->ongoingversion);
-        }
-        free (xv);
-
- err:
-        return match;
+    int ret = 0;
+    int match = 0;
+    size_t xsize = 0;
+    br_version_t *xv = NULL;
+
+    xsize = sizeof(br_version_t);
+
+    xv = calloc(1, xsize);
+    if (!xv) {
+        match = -1;
+        goto err;
+    }
+
+    ret = getxattr(bpath, "trusted.bit-rot.version", xv, xsize);
+    if (ret < 0) {
+        if (errno == ENODATA)
+            match = -2;
+        goto err;
+    }
+
+    if (xv->ongoingversion != version) {
+        match = -3;
+        fprintf(stderr, "ongoingversion: %lu\n", xv->ongoingversion);
+    }
+    free(xv);
+
+err:
+    return match;
 }
 
 int
-brstub_write_validation (char *filp, char *bpath, unsigned long startversion)
+brstub_write_validation(char *filp, char *bpath, unsigned long startversion)
 {
-        int fd1 = 0;
-        int fd2 = 0;
-        int ret = 0;
-        char *string = "string\n";
-
-        /* read only check */
-        fd1 = open (filp, O_RDONLY);
-        if (fd1 < 0)
-                goto err;
-        close (fd1);
-
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != -2)
-                goto err;
-
-        /* single open (write/) check */
-        fd1 = open (filp, O_RDWR);
-        if (fd1 < 0)
-                goto err;
-
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-        /**
-         * Fsync is done so that the write call has properly reached the
-         * disk. For fuse mounts write-behind xlator would have held the
-         * writes with itself and for nfs, client would have held the
-         * write in its cache. So write fop would not have triggered the
-         * versioning as it would have not reached the bit-rot-stub.
-         */
-        fsync (fd1);
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-        fsync (fd1); /* let it reach the disk */
-
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-
-        close (fd1);
-
-        /**
-         * Well, this is not a _real_ test per se . For this test to pass
-         * the inode should not get a forget() in the interim. Therefore,
-         * perform this test asap.
-         */
-
-        /* multi open (write/) check */
-        fd1 = open (filp, O_RDWR);
-        if (fd1 < 0)
-                goto err;
-        fd2 = open (filp, O_WRONLY);
-        if (fd1 < 0)
-                goto err;
-
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-
-        ret = write (fd2, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-
-        /* probably do a syncfs() */
-        fsync (fd1);
-        fsync (fd2);
-
-        close (fd1);
-        close (fd2);
-
-        /**
-         * incremented once per write()/write().../close()/close() sequence
-         */
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-
-        return 0;
-
- err:
-        return -1;
+    int fd1 = 0;
+    int fd2 = 0;
+    int ret = 0;
+    char *string = "string\n";
+
+    /* read only check */
+    fd1 = open(filp, O_RDONLY);
+    if (fd1 < 0)
+        goto err;
+    close(fd1);
+
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != -2)
+        goto err;
+
+    /* single open (write/) check */
+    fd1 = open(filp, O_RDWR);
+    if (fd1 < 0)
+        goto err;
+
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+    /**
+     * Fsync is done so that the write call has properly reached the
+     * disk. For fuse mounts write-behind xlator would have held the
+     * writes with itself and for nfs, client would have held the
+     * write in its cache. So write fop would not have triggered the
+     * versioning as it would have not reached the bit-rot-stub.
+     */
+    fsync(fd1);
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+    fsync(fd1); /* let it reach the disk */
+
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+
+    close(fd1);
+
+    /**
+     * Well, this is not a _real_ test per se . For this test to pass
+     * the inode should not get a forget() in the interim. Therefore,
+     * perform this test asap.
+     */
+
+    /* multi open (write/) check */
+    fd1 = open(filp, O_RDWR);
+    if (fd1 < 0)
+        goto err;
+    fd2 = open(filp, O_WRONLY);
+    if (fd1 < 0)
+        goto err;
+
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+
+    ret = write(fd2, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+
+    /* probably do a syncfs() */
+    fsync(fd1);
+    fsync(fd2);
+
+    close(fd1);
+    close(fd2);
+
+    /**
+     * incremented once per write()/write().../close()/close() sequence
+     */
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+
+    return 0;
+
+err:
+    return -1;
 }
 
 int
-brstub_new_object_validate (char *filp, char *brick)
+brstub_new_object_validate(char *filp, char *brick)
 {
-        int ret = 0;
-        char *fname = NULL;
-        char bpath[PATH_MAX] = {0,};
+    int ret = 0;
+    char *fname = NULL;
+    char bpath[PATH_MAX] = {
+        0,
+    };
 
-        fname = basename (filp);
-        if (!fname)
-                goto err;
+    fname = basename(filp);
+    if (!fname)
+        goto err;
 
-        (void) snprintf (bpath, PATH_MAX, "%s/%s", brick, fname);
+    (void)snprintf(bpath, PATH_MAX, "%s/%s", brick, fname);
 
-        printf ("Validating initial version..\n");
-        ret = brstub_validate_version (bpath, 2);
-        if (ret != -2) /* version _should_ be missing */
-                goto err;
+    printf("Validating initial version..\n");
+    ret = brstub_validate_version(bpath, 2);
+    if (ret != -2) /* version _should_ be missing */
+        goto err;
 
-        printf ("Validating version on modifications..\n");
-        ret = brstub_write_validation (filp, bpath, 2);
-        if (ret < 0)
-                goto err;
+    printf("Validating version on modifications..\n");
+    ret = brstub_write_validation(filp, bpath, 2);
+    if (ret < 0)
+        goto err;
 
-        return 0;
+    return 0;
 
- err:
-        return -1;
+err:
+    return -1;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int ret = 0;
-        char *filp = NULL;
-        char *brick = NULL;
+    int ret = 0;
+    char *filp = NULL;
+    char *brick = NULL;
 
-        if (argc != 3) {
-                printf ("Usage: %s <path> <brick>\n", argv[0]);
-                goto err;
-        }
+    if (argc != 3) {
+        printf("Usage: %s <path> <brick>\n", argv[0]);
+        goto err;
+    }
 
-        filp = argv[1];
-        brick = argv[2];
+    filp = argv[1];
+    brick = argv[2];
 
-        printf ("Validating object version [%s]\n", filp);
-        ret = brstub_new_object_validate (filp, brick);
-        if (ret < 0)
-                goto err;
+    printf("Validating object version [%s]\n", filp);
+    ret = brstub_new_object_validate(filp, brick);
+    if (ret < 0)
+        goto err;
 
-        return 0;
+    return 0;
 
- err:
-        return -1;
+err:
+    return -1;
 }
diff --git a/tests/bitrot/br-stub.t b/tests/bitrot/br-stub.t
index 5013398482a..cc0319afac9 100644
--- a/tests/bitrot/br-stub.t
+++ b/tests/bitrot/br-stub.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 STUB_SOURCE=$(dirname $0)/br-stub.c
 STUB_EXEC=$(dirname $0)/br-stub
 
diff --git a/tests/bitrot/bug-1244613.t b/tests/bitrot/bug-1244613.t
index 5674e6f4ef5..57b86a94ac0 100644
--- a/tests/bitrot/bug-1244613.t
+++ b/tests/bitrot/bug-1244613.t
@@ -5,6 +5,8 @@
 . $(dirname $0)/../nfs.rc
 . $(dirname $0)/../fileio.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TESTS_EXPECTED_IN_LOOP=16
diff --git a/tests/bitrot/bug-1294786.t b/tests/bitrot/bug-1294786.t
index b177574f756..5b4b6ddb4d3 100644
--- a/tests/bitrot/bug-1294786.t
+++ b/tests/bitrot/bug-1294786.t
@@ -65,8 +65,8 @@ EXPECT "4" get_quarantine_count "$B1";
 TEST $CLI_1 volume stop $V0
 TEST $CLI_1 volume start $V0
 EXPECT 'Started' volinfo_field_1 $V0 'Status';
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count_1
diff --git a/tests/bitrot/bug-1373520.t b/tests/bitrot/bug-1373520.t
index 225d3b1a9bc..6af5124e86e 100644
--- a/tests/bitrot/bug-1373520.t
+++ b/tests/bitrot/bug-1373520.t
@@ -11,13 +11,20 @@ TEST pidof glusterd
 #Create a disperse volume
 TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
 TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "6" online_brick_count
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field $V0 'Status'
 
-#Disable md-cache
+#Disable self heal daemon as it races in this test with lookup on volume
+#stop and start.
+$CLI volume set $V0 self-heal-daemon off
+
+#Disable few perf xlators to get the first lookup on the brick
 TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.force-readdirp off
+TEST $CLI volume set $V0 dht.force-readdirp off
 
 #Mount the volume
-TEST $GFS -s $H0 --volfile-id $V0 $M0
+TEST $GFS -s $H0 --use-readdirp=no --attribute-timeout=0 --entry-timeout=0 --volfile-id $V0 $M0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
 
 #Enable bitrot
@@ -49,10 +56,16 @@ EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
 #Delete file and all links from backend
 TEST rm -rf $(find $B0/${V0}5 -inum $(stat -c %i $B0/${V0}5/FILE1))
 
+#New mount for recovery
+TEST $GFS -s $H0 --use-readdirp=no --attribute-timeout=0 --entry-timeout=0 --volfile-id $V0 $M1
+
+$CLI volume set $V0 self-heal-daemon on
+TEST $CLI volume heal $V0
+
 #Access files
-TEST cat $M0/FILE1
+TEST cat $M1/FILE1
 EXPECT_WITHIN $HEAL_TIMEOUT "$SIZE" path_size $B0/${V0}5/FILE1
-TEST cat $M0/HL_FILE1
+TEST cat $M1/HL_FILE1
 EXPECT_WITHIN $HEAL_TIMEOUT "$SIZE" path_size $B0/${V0}5/HL_FILE1
 
 cleanup;
diff --git a/tests/bitrot/bug-1700078.t b/tests/bitrot/bug-1700078.t
new file mode 100644
index 00000000000..f27374211fe
--- /dev/null
+++ b/tests/bitrot/bug-1700078.t
@@ -0,0 +1,87 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+## Start glusterd
+TEST glusterd;
+TEST pidof glusterd;
+
+## Lets create and start the volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+TEST $CLI volume start $V0
+
+## Enable bitrot for volume $V0
+TEST $CLI volume bitrot $V0 enable
+
+## Turn off quick-read so that it wont cache the contents
+# of the file in lookup. For corrupted files, it might
+# end up in reads being served from the cache instead of
+# an error.
+TEST $CLI volume set $V0 performance.quick-read off
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Active' scrub_status $V0 'State of scrub'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '/var/log/glusterfs/bitd.log' scrub_status $V0 'Bitrot error log location'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '/var/log/glusterfs/scrub.log' scrub_status $V0 'Scrubber error log location'
+
+## Set expiry-timeout to 1 sec
+TEST $CLI volume set $V0 features.expiry-time 1
+
+##Mount $V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+
+## Turn off quick-read xlator so that, the contents are not served from the
+# quick-read cache.
+TEST $CLI volume set $V0 performance.quick-read off
+
+#Create sample file
+TEST `echo "1234" > $M0/FILE1`
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.bit-rot.signature' check_for_xattr 'trusted.bit-rot.signature' "/$B0/${V0}1/FILE1"
+
+##disable bitrot
+TEST $CLI volume bitrot $V0 disable
+
+## modify the file
+TEST `echo "write" >> $M0/FILE1`
+
+# unmount and remount when the file has to be accessed.
+# This is to ensure that, when the remount happens,
+# and the file is read, its contents are served from the
+# brick instead of cache.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+##enable bitrot
+TEST $CLI volume bitrot $V0 enable
+
+# expiry time is set to 1 second. Hence sleep for 2 seconds for the
+# oneshot crawler to finish its crawling and sign the file properly.
+sleep 2
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Active' scrub_status $V0 'State of scrub'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '/var/log/glusterfs/bitd.log' scrub_status $V0 'Bitrot error log location'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT '/var/log/glusterfs/scrub.log' scrub_status $V0 'Scrubber error log location'
+
+## Ondemand scrub
+TEST $CLI volume bitrot $V0 scrub ondemand
+
+# the scrub ondemand CLI command, just ensures that
+# the scrubber has received the ondemand scrub directive
+# and started. sleep for 2 seconds for scrubber to finish
+# crawling and marking file(s) as bad (if if finds that
+# corruption has happened) which are filesystem operations.
+sleep 2
+
+TEST ! getfattr -n 'trusted.bit-rot.bad-file' $B0/${V0}1/FILE1
+
+##Mount $V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+
+TEST cat $M0/FILE1
+
+cleanup;
diff --git a/tests/bugs/access-control/bug-1051896.c b/tests/bugs/access-control/bug-1051896.c
index 27aa1559453..31799d97a71 100644
--- a/tests/bugs/access-control/bug-1051896.c
+++ b/tests/bugs/access-control/bug-1051896.c
@@ -13,85 +13,82 @@
 #include <utime.h>
 #include <sys/acl.h>
 
-int do_setfacl(const char *path, const char *options, const char *textacl)
+int
+do_setfacl(const char *path, const char *options, const char *textacl)
 {
-	int r;
-	int type;
-	acl_t acl;
-	int dob;
-	int dok;
-	int dom;
-	struct stat st;
-	char textmode[30];
+    int r;
+    int type;
+    acl_t acl;
+    int dob;
+    int dok;
+    int dom;
+    struct stat st;
+    char textmode[30];
 
-	r = 0;
-	dob = strchr(options, 'b') != (char *)NULL;
-	dok = strchr(options, 'k') != (char *)NULL;
-	dom = strchr(options, 'm') != (char *)NULL;
-	if ((dom && !textacl)
-	    || (!dom && (textacl || (!dok && !dob) ||
-                                    strchr(options, 'd')))) {
-		errno = EBADRQC; /* "bad request" */
-		r = -1;
-	} else {
-		if (dob || dok) {
-			r = acl_delete_def_file(path);
-		}
-		if (dob && !r) {
-			if (!stat(path, &st)) {
-				sprintf(textmode,
-                                        "u::%c%c%c,g::%c%c%c,o::%c%c%c",
-					(st.st_mode & 0400 ? 'r' : '-'),
-					(st.st_mode & 0200 ? 'w' : '-'),
-					(st.st_mode & 0100 ? 'x' : '-'),
-					(st.st_mode & 0040 ? 'r' : '-'),
-					(st.st_mode & 0020 ? 'w' : '-'),
-					(st.st_mode & 0010 ? 'x' : '-'),
-					(st.st_mode & 004 ? 'r' : '-'),
-					(st.st_mode & 002 ? 'w' : '-'),
-					(st.st_mode & 001 ? 'x' : '-'));
-				acl = acl_from_text(textmode);
-				if (acl) {
-					r = acl_set_file(path,
-                                                         ACL_TYPE_ACCESS, acl);
-					acl_free(acl);
-				} else
-					r = -1;
-			} else
-				r = -1;
-		}
-		if (!r && dom) {
-			if (strchr(options, 'd'))
-				type = ACL_TYPE_DEFAULT;
-			else
-				type = ACL_TYPE_ACCESS;
-			acl = acl_from_text(textacl);
-			if (acl) {
-				r = acl_set_file(path, type, acl);
-				acl_free(acl);
-			} else
-				r = -1;
-		}
-	}
-	if (r)
-		r = -errno;
-	return r;
+    r = 0;
+    dob = strchr(options, 'b') != (char *)NULL;
+    dok = strchr(options, 'k') != (char *)NULL;
+    dom = strchr(options, 'm') != (char *)NULL;
+    if ((dom && !textacl) ||
+        (!dom && (textacl || (!dok && !dob) || strchr(options, 'd')))) {
+        errno = EBADRQC; /* "bad request" */
+        r = -1;
+    } else {
+        if (dob || dok) {
+            r = acl_delete_def_file(path);
+        }
+        if (dob && !r) {
+            if (!stat(path, &st)) {
+                sprintf(textmode, "u::%c%c%c,g::%c%c%c,o::%c%c%c",
+                        (st.st_mode & 0400 ? 'r' : '-'),
+                        (st.st_mode & 0200 ? 'w' : '-'),
+                        (st.st_mode & 0100 ? 'x' : '-'),
+                        (st.st_mode & 0040 ? 'r' : '-'),
+                        (st.st_mode & 0020 ? 'w' : '-'),
+                        (st.st_mode & 0010 ? 'x' : '-'),
+                        (st.st_mode & 004 ? 'r' : '-'),
+                        (st.st_mode & 002 ? 'w' : '-'),
+                        (st.st_mode & 001 ? 'x' : '-'));
+                acl = acl_from_text(textmode);
+                if (acl) {
+                    r = acl_set_file(path, ACL_TYPE_ACCESS, acl);
+                    acl_free(acl);
+                } else
+                    r = -1;
+            } else
+                r = -1;
+        }
+        if (!r && dom) {
+            if (strchr(options, 'd'))
+                type = ACL_TYPE_DEFAULT;
+            else
+                type = ACL_TYPE_ACCESS;
+            acl = acl_from_text(textacl);
+            if (acl) {
+                r = acl_set_file(path, type, acl);
+                acl_free(acl);
+            } else
+                r = -1;
+        }
+    }
+    if (r)
+        r = -errno;
+    return r;
 }
 
-
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-	int rc = 0;
+    int rc = 0;
 
-	if (argc != 4) {
-		fprintf(stderr,
-                        "usage: ./setfacl_test <path> <options> <textacl>\n");
-		return 0;
-	}
-	rc = do_setfacl(argv[1], argv[2], argv[3]);
-	if (rc != 0) {
-		fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno));
-		return rc;
-	}
-	return 0;
+    if (argc != 4) {
+        fprintf(stderr, "usage: ./setfacl_test <path> <options> <textacl>\n");
+        return 0;
+    }
+    rc = do_setfacl(argv[1], argv[2], argv[3]);
+    if (rc != 0) {
+        fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno));
+        return rc;
+    }
+    return 0;
 }
diff --git a/tests/bugs/access-control/bug-1387241.c b/tests/bugs/access-control/bug-1387241.c
index 04e0d6ea11f..e2e843a2fda 100644
--- a/tests/bugs/access-control/bug-1387241.c
+++ b/tests/bugs/access-control/bug-1387241.c
@@ -3,15 +3,16 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        int ret = EXIT_FAILURE;
-        int fd = open(argv[1], O_RDONLY|O_TRUNC);
+    int ret = EXIT_FAILURE;
+    int fd = open(argv[1], O_RDONLY | O_TRUNC);
 
-        if (fd) {
-                ret = EXIT_SUCCESS;
-                close(fd);
-        }
+    if (fd) {
+        ret = EXIT_SUCCESS;
+        close(fd);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/access-control/bug-958691.t b/tests/bugs/access-control/bug-958691.t
index 6c45b47b166..8b70607bdbb 100644
--- a/tests/bugs/access-control/bug-958691.t
+++ b/tests/bugs/access-control/bug-958691.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/bitrot/bug-1227996.t b/tests/bugs/bitrot/bug-1227996.t
index 47ebc4235cf..121c7b5f279 100644
--- a/tests/bugs/bitrot/bug-1227996.t
+++ b/tests/bugs/bitrot/bug-1227996.t
@@ -17,7 +17,6 @@ TEST pidof glusterd;
 ## Lets create and start the volume
 TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1
 TEST $CLI volume start $V0
-
 ## Enable bitrot on volume $V0
 TEST $CLI volume bitrot $V0 enable
 
diff --git a/tests/bugs/bitrot/bug-1245981.t b/tests/bugs/bitrot/bug-1245981.t
index 2bed4d980fa..f3955256b01 100644
--- a/tests/bugs/bitrot/bug-1245981.t
+++ b/tests/bugs/bitrot/bug-1245981.t
@@ -47,9 +47,9 @@ touch $M0/5
 sleep `expr $SLEEP_TIME \* 2`
 
 backpath=$(get_backend_paths $fname)
-TEST getfattr -m . -n trusted.bit-rot.signature $backpath
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.bit-rot.signature' check_for_xattr 'trusted.bit-rot.signature' $backpath
 
 backpath=$(get_backend_paths $M0/new_file)
-TEST getfattr -m . -n trusted.bit-rot.signature $backpath
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'trusted.bit-rot.signature' check_for_xattr 'trusted.bit-rot.signature' $backpath
 
 cleanup;
diff --git a/tests/bugs/bug-1064147.t b/tests/bugs/bug-1064147.t
new file mode 100755
index 00000000000..27ffde4eb44
--- /dev/null
+++ b/tests/bugs/bug-1064147.t
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+# Initialize
+#------------------------------------------------------------
+cleanup;
+
+# Start glusterd
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+# Create a volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
+
+# Verify volume creation
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+# Start volume and verify successful start
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+#------------------------------------------------------------
+
+# Test case 1 - Subvolume down + Healing
+#------------------------------------------------------------
+# Kill 2nd brick process
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "1" online_brick_count
+
+# Change root permissions
+TEST chmod 444 $M0
+
+# Store permission for comparision
+TEST permission_new=`stat -c "%A" $M0`
+
+# Bring up the killed brick process
+TEST $CLI volume start $V0 force
+
+# Perform lookup
+sleep 5
+TEST ls $M0
+
+# Check brick permissions
+TEST brick_perm=`stat -c "%A" $B0/${V0}2`
+TEST [ ${brick_perm} = ${permission_new} ]
+#------------------------------------------------------------
+
+# Test case 2 - Add-brick + Healing
+#------------------------------------------------------------
+# Change root permissions
+TEST chmod 777 $M0
+
+# Store permission for comparision
+TEST permission_new_2=`stat -c "%A" $M0`
+
+# Add a 3rd brick
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}3
+
+# Perform lookup
+sleep 5
+TEST ls $M0
+
+# Check permissions on the new brick
+TEST brick_perm2=`stat -c "%A" $B0/${V0}3`
+
+TEST [ ${brick_perm2} = ${permission_new_2} ]
+
+cleanup;
diff --git a/tests/bugs/bug-1110262.t b/tests/bugs/bug-1110262.t
index be785f4f3f7..90b101fc98d 100644
--- a/tests/bugs/bug-1110262.t
+++ b/tests/bugs/bug-1110262.t
@@ -23,6 +23,12 @@ TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
 TEST glusterfs -s $H0 --volfile-id=$V0 $M0
 
+#do some operation on mount, so that kill_brick is guaranteed to be
+#done _after_ first lookup on root and dht has a proper layout on
+#it. Otherwise mkdir done in later stages of script might fail due to
+#lack of layout on "/" as dht-self-heal won't proceed if any of its
+#subvolumes are down.
+TEST ls $M0
 #kill one of the brick process
 TEST kill_brick $V0 $H0 $B0/${V0}2
 
diff --git a/tests/bugs/bug-1138841.t b/tests/bugs/bug-1138841.t
new file mode 100644
index 00000000000..abec5e89d56
--- /dev/null
+++ b/tests/bugs/bug-1138841.t
@@ -0,0 +1,25 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+## Create a volume and set auth.allow using cidr format ip
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 auth.allow 127.0.0.1/20
+TEST $CLI volume start $V0
+
+
+## mount the volume and create a file on the mount point
+
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+TEST touch $M0/tmp1
+
+## Stop the volume and do the cleanup
+
+TEST $CLI volume stop $V0
+cleanup
diff --git a/tests/bugs/bug-1258069.t b/tests/bugs/bug-1258069.t
index 8df4a8a9e1b..b87ecbf2fe8 100755
--- a/tests/bugs/bug-1258069.t
+++ b/tests/bugs/bug-1258069.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup
 
 TEST glusterd
diff --git a/tests/bugs/bug-1368312.t b/tests/bugs/bug-1368312.t
index 135048f448e..c60d562bbd7 100644
--- a/tests/bugs/bug-1368312.t
+++ b/tests/bugs/bug-1368312.t
@@ -29,46 +29,46 @@ TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
 TEST mkdir $M0/tmp1
 
 #Create metadata split-brain
-TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST kill_brick $V0 $H0 $B0/${V0}2
 TEST chmod 666 $M0/tmp1
 TEST $CLI volume start $V0 force
-TEST kill_brick $V0 $H0 $B0/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST kill_brick $V0 $H0 $B0/${V0}3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
 
 TEST chmod 757 $M0/tmp1
 
 TEST $CLI volume start $V0 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 3
 
 EXPECT 2 get_pending_heal_count $V0
 
 
-TEST kill_brick $V0 $H0 $B0/${V0}2
+TEST kill_brick $V0 $H0 $B0/${V0}4
 TEST chmod 755 $M0/tmp1
 TEST $CLI volume start $V0 force
-TEST kill_brick $V0 $H0 $B0/${V0}3
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+TEST kill_brick $V0 $H0 $B0/${V0}5
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 4
 
 TEST chmod 766 $M0/tmp1
 
 TEST $CLI volume start $V0 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 4
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 5
 
 EXPECT 4 get_pending_heal_count $V0
 
-TEST kill_brick $V0 $H0 $B0/${V0}4
+TEST kill_brick $V0 $H0 $B0/${V0}0
 TEST chmod 765 $M0/tmp1
 TEST $CLI volume start $V0 force
-TEST kill_brick $V0 $H0 $B0/${V0}5
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 4
+TEST kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
 
 TEST chmod 756 $M0/tmp1
 
 TEST $CLI volume start $V0 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 4
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 5
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
 
 EXPECT 6 get_pending_heal_count $V0
 
@@ -82,3 +82,5 @@ EXPECT 0 compare_get_split_brain_status ./tmp1 patchy-client-5
 
 cd -
 cleanup
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/bug-1371806.t b/tests/bugs/bug-1371806.t
new file mode 100644
index 00000000000..08180525650
--- /dev/null
+++ b/tests/bugs/bug-1371806.t
@@ -0,0 +1,81 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+function get_getfattr {
+        local path=$1
+        echo `getfattr -n user.foo $path` | cut -f2 -d"=" | sed -e 's/^"//'  -e 's/"$//'
+}
+
+function set_fattr {
+        for i in `seq 1 10`
+        do
+                setfattr -n user.foo -v "newabc" ./tmp${i}
+                if [ "$?" = "0" ]
+                 then
+                    succ=$((succ+1))
+                else
+                    fail=$((fail+1))
+                fi
+        done
+}
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume start $V0
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "6" online_brick_count
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST mkdir tmp{1..10}
+
+##First set user.foo xattr with value abc on all dirs
+
+TEST setfattr -n user.foo -v "abc" ./tmp{1..10}
+EXPECT "abc" get_getfattr ./tmp{1..10}
+EXPECT "abc" get_getfattr $B0/${V0}5/tmp{1..10}
+
+TEST kill_brick $V0 $H0 $B0/${V0}5
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "5" online_brick_count
+
+succ=fail=0
+## set user.foo xattr with value newabc after kill one brick
+set_fattr
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "6" online_brick_count
+
+cd -
+TEST umount $M0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+## At this point dht code will heal xattr on down brick only for those dirs
+## hashed subvol was up at the time of update xattr
+TEST stat ./tmp{1..10}
+
+## Count the user.foo xattr value with abc on mount point and compare with fail value
+count=`getfattr -n user.foo ./tmp{1..10} | grep "user.foo" | grep -iw "abc" | wc -l`
+EXPECT "$fail" echo $count
+
+## Count the user.foo xattr value with newabc on mount point and compare with succ value
+count=`getfattr -n user.foo ./tmp{1..10} | grep "user.foo" | grep -iw "newabc" | wc -l`
+EXPECT "$succ" echo $count
+
+## Count the user.foo xattr value with abc on brick and compare with succ value
+count=`getfattr -n user.foo $B0/${V0}5/tmp{1..10} | grep "user.foo" | grep -iw "abc" | wc -l`
+EXPECT "$fail" echo $count
+
+## Count the user.foo xattr value with newabc on brick and compare with succ value
+count=`getfattr -n user.foo $B0/${V0}5/tmp{1..10} | grep "user.foo" | grep -iw "newabc" | wc -l`
+EXPECT "$succ" echo $count
+
+
+cd -
+cleanup
+exit
diff --git a/tests/bugs/bug-1371806_1.t b/tests/bugs/bug-1371806_1.t
new file mode 100644
index 00000000000..df19a8c1c2a
--- /dev/null
+++ b/tests/bugs/bug-1371806_1.t
@@ -0,0 +1,48 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+function get_getfattr {
+        local path=$1
+        echo `getfattr -n user.foo $path` | cut -f2 -d"=" | sed -e 's/^"//'  -e 's/"$//'
+}
+
+function remove_mds_xattr {
+
+       for i in `seq 1 10`
+       do
+               setfattr -x trusted.glusterfs.dht.mds $1/tmp${i} 2> /dev/null
+       done
+}
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3}
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+cd $M0
+TEST mkdir tmp{1..10}
+
+##Remove internal mds xattr from all directory
+remove_mds_xattr $B0/${V0}0
+remove_mds_xattr $B0/${V0}1
+remove_mds_xattr $B0/${V0}2
+remove_mds_xattr $B0/${V0}3
+
+cd -
+umount $M0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+cd $M0
+
+TEST setfattr -n user.foo -v "abc" ./tmp{1..10}
+EXPECT "abc" get_getfattr ./tmp{1..10}
+
+cd -
+cleanup
diff --git a/tests/bugs/bug-1371806_2.t b/tests/bugs/bug-1371806_2.t
new file mode 100644
index 00000000000..e6aa8e7c1ad
--- /dev/null
+++ b/tests/bugs/bug-1371806_2.t
@@ -0,0 +1,52 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+function get_getfattr {
+        local path=$1
+        echo `getfattr -n user.foo $path` | cut -f2 -d"=" | sed -e 's/^"//'  -e 's/"$//'
+}
+
+function remove_mds_xattr {
+
+       for i in `seq 1 10`
+       do
+               setfattr -x trusted.glusterfs.dht.mds $1/tmp${i} 2> /dev/null
+       done
+}
+
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3}
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 --attribute-timeout=0 $M0;
+cd $M0
+TEST mkdir tmp{1..10}
+
+##Remove internal mds xattr from all directory
+remove_mds_xattr $B0/${V0}0
+remove_mds_xattr $B0/${V0}1
+remove_mds_xattr $B0/${V0}2
+remove_mds_xattr $B0/${V0}3
+
+##First set user.foo xattr with value abc on all dirs
+
+TEST setfattr -n user.foo -v "abc" ./tmp{1..10}
+EXPECT "abc" get_getfattr ./tmp{1..10}
+EXPECT "abc" get_getfattr $B0/${V0}0/tmp{1..10}
+EXPECT "abc" get_getfattr $B0/${V0}1/tmp{1..10}
+EXPECT "abc" get_getfattr $B0/${V0}2/tmp{1..10}
+EXPECT "abc" get_getfattr $B0/${V0}3/tmp{1..10}
+
+cd -
+TEST umount $M0
+
+cd -
+cleanup
+exit
diff --git a/tests/bugs/bug-1371806_3.t b/tests/bugs/bug-1371806_3.t
new file mode 100644
index 00000000000..cb13f37c737
--- /dev/null
+++ b/tests/bugs/bug-1371806_3.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+function get_getfattr {
+        local path=$1
+        echo `getfattr -n user.foo $path` | cut -f2 -d"=" | sed -e 's/^"//'  -e 's/"$//'
+}
+
+function set_fattr {
+        for i in `seq 1 10`
+        do
+                setfattr -n user.foo -v "newabc" ./tmp${i}
+                if [ "$?" = "0" ]
+                 then
+                    succ=$((succ+1))
+                else
+                    fail=$((fail+1))
+                fi
+        done
+}
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3}
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 --attribute-timeout=0 $M0;
+
+cd $M0
+TEST mkdir tmp{1..10}
+
+TEST kill_brick $V0 $H0 $B0/${V0}3
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "3" online_brick_count
+
+succ=fail=0
+## set user.foo xattr with value newabc after kill one brick
+set_fattr
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "4" online_brick_count
+
+cd -
+TEST umount $M0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 --attribute-timeout=0 $M0;
+
+cd $M0
+## At this point dht code will heal xattr on down brick only for those dirs
+## hashed subvol was up at the time of update xattr
+TEST stat ./tmp{1..10}
+
+
+## Count the user.foo xattr value with newabc on brick and compare with succ value
+count=`getfattr -n user.foo $B0/${V0}3/tmp{1..10} | grep "user.foo" | grep -iw "newabc" | wc -l`
+EXPECT "$succ" echo $count
+
+
+cd -
+cleanup
+exit
diff --git a/tests/bugs/bug-1371806_acl.t b/tests/bugs/bug-1371806_acl.t
new file mode 100644
index 00000000000..c39165628cc
--- /dev/null
+++ b/tests/bugs/bug-1371806_acl.t
@@ -0,0 +1,96 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+TEST useradd tmpuser
+
+function set_facl_user {
+        for i in `seq 1 10`
+        do
+                setfacl -m u:tmpuser:rw ./tmp${i}
+                if [ "$?" = "0" ]
+                 then
+                    succ=$((succ+1))
+                else
+                    fail=$((fail+1))
+                fi
+        done
+}
+
+function set_facl_default {
+        for i in `seq 1 10`
+        do
+                setfacl -m d:o:rw ./tmp${i}
+                if [ "$?" = "0" ]
+                 then
+                    succ1=$((succ1+1))
+                else
+                    fail1=$((fail1+1))
+                fi
+        done
+}
+
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume set $V0 diagnostics.client-log-level DEBUG
+TEST $CLI volume start $V0
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "6" online_brick_count
+
+TEST glusterfs --volfile-id=$V0 --acl --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST mkdir tmp{1..10}
+TEST setfacl -m u:tmpuser:rwx ./tmp{1..10}
+count=`getfacl -p $M0/tmp{1..10} | grep -c "user:tmpuser:rwx"`
+EXPECT "10" echo $count
+TEST setfacl -m d:o:rwx ./tmp{1..10}
+count=`getfacl -p $M0/tmp{1..10} | grep -c "default:other::rwx"`
+EXPECT "10" echo $count
+count=`getfacl -p $B0/${V0}5/tmp{1..10} | grep -c "user:tmpuser:rwx"`
+EXPECT "10" echo $count
+count=`getfacl -p $B0/${V0}5/tmp{1..10} | grep -c "default:other::rwx"`
+EXPECT "10" echo $count
+
+
+TEST kill_brick $V0 $H0 $B0/${V0}5
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "5" online_brick_count
+
+succ=fail=0
+## Update acl attributes on dir after kill one brick
+set_facl_user
+succ1=fail1=0
+set_facl_default
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "6" online_brick_count
+
+cd -
+TEST umount $M0
+TEST glusterfs --volfile-id=$V0 --acl --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+## At this point dht will heal xatts on down brick only for those hashed_subvol
+## was up at the time of updated xattrs
+TEST stat ./tmp{1..10}
+
+# Make sure to send a write and read on the file inside mount
+echo "helloworld" > ./tmp1/file
+TEST cat ./tmp1/file
+
+## Compare succ value with updated acl attributes
+count=`getfacl -p $B0/${V0}5/tmp{1..10} | grep -c "user:tmpuser:rw-"`
+EXPECT "$succ" echo $count
+
+
+count=`getfacl -p $B0/${V0}5/tmp{1..10} | grep -c "default:other::rw-"`
+EXPECT "$succ1" echo $count
+
+cd -
+userdel --force tmpuser
+
+cleanup
diff --git a/tests/bugs/bug-1584517.t b/tests/bugs/bug-1584517.t
new file mode 100644
index 00000000000..7f48015a034
--- /dev/null
+++ b/tests/bugs/bug-1584517.t
@@ -0,0 +1,70 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+#This test case verifies attributes (uid/gid/perm) for the
+#directory are healed after stop/start brick. To verify the same
+#test case change attributes of the directory after down a DHT subvolume
+#and one AFR children. After start the volume with force and run lookup
+#operation attributes should be healed on started bricks at the backend.
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5}
+TEST $CLI volume start $V0
+TEST useradd dev -M
+TEST groupadd QA
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+TEST mkdir $M0/dironedown
+
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "5" online_brick_count
+
+TEST kill_brick $V0 $H0 $B0/${V0}3
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "4" online_brick_count
+
+TEST kill_brick $V0 $H0 $B0/${V0}4
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "3" online_brick_count
+
+TEST kill_brick $V0 $H0 $B0/${V0}5
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "2" online_brick_count
+
+TEST chown dev $M0/dironedown
+TEST chgrp QA $M0/dironedown
+TEST chmod 777 $M0/dironedown
+
+#store the permissions for comparision
+permission_onedown=`ls -l $M0 | grep dironedown | awk '{print $1}'`
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "6" online_brick_count
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+#Run lookup two times to hit revalidate code path in dht
+# to heal user attr
+
+TEST ls $M0/dironedown
+
+#check attributes those were created post brick going down
+TEST brick_perm=`ls -l $B0/${V0}3 | grep dironedown | awk '{print $1}'`
+TEST echo $brick_perm
+TEST [ ${brick_perm} = ${permission_onedown} ]
+uid=`ls -l $B0/${V0}3 | grep dironedown | awk '{print $3}'`
+TEST echo $uid
+TEST [ $uid = dev ]
+gid=`ls -l $B0/${V0}3 | grep dironedown | awk '{print $4}'`
+TEST echo $gid
+TEST [ $gid = QA ]
+
+TEST umount $M0
+userdel --force dev
+groupdel QA
+
+cleanup
+exit
+
diff --git a/tests/bugs/bug-1620580.t b/tests/bugs/bug-1620580.t
new file mode 100644
index 00000000000..0c74d4a6089
--- /dev/null
+++ b/tests/bugs/bug-1620580.t
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+## Start glusterd
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+## Lets create volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+
+## Verify volume is created
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+## Start volume and verify
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST glusterfs -s $H0 --volfile-id=$V0 $M0
+
+#do some operation on mount, so that kill_brick is guaranteed to be
+#done _after_ first lookup on root
+
+TEST ls $M0
+TEST touch $M0/file
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+# Case of Same volume name, but different bricks
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{3,4};
+TEST $CLI volume start $V0;
+
+# Give time for 'reconnect' to happen
+sleep 4
+
+TEST ! ls $M0
+TEST ! touch $M0/file1
+
+# Case of Same brick, but different volume (ie, recreated).
+TEST $CLI volume create $V1 $H0:$B0/${V0}{1,2};
+TEST $CLI volume start $V1;
+
+# Give time for 'reconnect' to happen
+sleep 4
+TEST ! ls $M0
+TEST ! touch $M0/file2
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+TEST $CLI volume stop $V1
+TEST $CLI volume delete $V1
+
+# Case of Same brick, but different volume (but same volume name)
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
+TEST $CLI volume start $V0;
+
+# Give time for 'reconnect' to happen
+sleep 4
+TEST ! ls $M0
+TEST ! touch $M0/file3
+
+
+cleanup
diff --git a/tests/bugs/bug-1694920.t b/tests/bugs/bug-1694920.t
new file mode 100644
index 00000000000..5bf93c92f94
--- /dev/null
+++ b/tests/bugs/bug-1694920.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+SCRIPT_TIMEOUT=300
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../fileio.rc
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0};
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume start $V0
+TEST $GFS -s $H0 --volfile-id=$V0  $M0;
+
+TEST touch $M0/a
+
+#When all bricks are up, lock and unlock should succeed
+TEST fd1=`fd_available`
+TEST fd_open $fd1 'w' $M0/a
+TEST flock -x $fd1
+TEST fd_close $fd1
+
+#When all bricks are down, lock/unlock should fail
+TEST fd1=`fd_available`
+TEST fd_open $fd1 'w' $M0/a
+TEST $CLI volume stop $V0
+TEST ! flock -x $fd1
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" client_connected_status_meta $M0 $V0-client-0
+TEST fd_close $fd1
+
+#When a brick goes down and comes back up operations on fd which had locks on it should succeed by default
+TEST fd1=`fd_available`
+TEST fd_open $fd1 'w' $M0/a
+TEST flock -x $fd1
+TEST $CLI volume stop $V0
+sleep 2
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" client_connected_status_meta $M0 $V0-client-0
+TEST fd_write $fd1 "data"
+TEST fd_close $fd1
+
+#When a brick goes down and comes back up operations on fd which had locks on it should fail when client.strict-locks is on
+TEST $CLI volume set $V0 client.strict-locks on
+TEST fd1=`fd_available`
+TEST fd_open $fd1 'w' $M0/a
+TEST flock -x $fd1
+TEST $CLI volume stop $V0
+sleep 2
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" client_connected_status_meta $M0 $V0-client-0
+TEST ! fd_write $fd1 "data"
+TEST fd_close $fd1
+
+cleanup
diff --git a/tests/bugs/bug-1702299.t b/tests/bugs/bug-1702299.t
new file mode 100644
index 00000000000..1cff2ed5d3d
--- /dev/null
+++ b/tests/bugs/bug-1702299.t
@@ -0,0 +1,67 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../dht.rc
+cleanup;
+
+function get_getfattr {
+        local path=$1
+        echo `getfattr -n user.foo $path` | cut -f2 -d"=" | sed -e 's/^"//'  -e 's/"$//'
+}
+
+function set_fattr {
+        for i in `seq 1 10`
+        do
+                setfattr -n user.foo -v "newabc" ./tmp${i}
+                if [ "$?" = "0" ]
+                 then
+                    succ=$((succ+1))
+                else
+                    fail=$((fail+1))
+                fi
+        done
+}
+
+
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1,2,3}
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 --attribute-timeout=0 $M0;
+
+cd $M0
+TEST mkdir tmp{1..10}
+
+succ=fail=0
+## set user.foo xattr with value newabc after kill one brick
+set_fattr
+count=10
+EXPECT "$succ" echo $count
+count=0
+EXPECT "$fail" echo $count
+
+cd -
+
+# Add-brick
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{4,5}
+
+cd $M0
+## At this point dht code will heal xattr on down brick only for those dirs
+## hashed subvol was up at the time of update xattr
+TEST stat ./tmp{1..10}
+
+
+## Count the user.foo xattr value with newabc on brick and compare with succ value
+count=`getfattr -n user.foo $B0/${V0}4/tmp{1..10} | grep "user.foo" | grep -iw "newabc" | wc -l`
+EXPECT "$succ" echo $count
+
+## Count the user.foo xattr value with newabc on brick and compare with succ value
+count=`getfattr -n user.foo $B0/${V0}5/tmp{1..10} | grep "user.foo" | grep -iw "newabc" | wc -l`
+EXPECT "$succ" echo $count
+
+
+cd -
+TEST umount $M0
+cleanup
diff --git a/tests/bugs/cli/bug-1169302.c b/tests/bugs/cli/bug-1169302.c
index aa9f950abf2..7c6b5fbf856 100644
--- a/tests/bugs/cli/bug-1169302.c
+++ b/tests/bugs/cli/bug-1169302.c
@@ -7,72 +7,73 @@
 
 int keep_running = 1;
 
-void stop_running(int sig)
+void
+stop_running(int sig)
 {
-        if (sig == SIGTERM)
-                keep_running = 0;
+    if (sig == SIGTERM)
+        keep_running = 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t *fs = NULL;
-        int ret = 0;
-        glfs_fd_t *fd = NULL;
-        char *filename = NULL;
-        char *logfile = NULL;
-        char *host = NULL;
-
-        if (argc != 5) {
-                return -1;
-        }
-
-        host = argv[2];
-        logfile = argv[3];
-        filename = argv[4];
-
-        /* setup signal handler for exiting */
-        signal (SIGTERM, stop_running);
-
-        fs = glfs_new (argv[1]);
-        if (!fs) {
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", host, 24007);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        if (!fd) {
-                return -1;
-        }
-
-        /* sleep until SIGTERM has been received */
-        while (keep_running) {
-                sleep (1);
-        }
-
-        ret = glfs_close (fd);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        return 0;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = NULL;
+    char *logfile = NULL;
+    char *host = NULL;
+
+    if (argc != 5) {
+        return -1;
+    }
+
+    host = argv[2];
+    logfile = argv[3];
+    filename = argv[4];
+
+    /* setup signal handler for exiting */
+    signal(SIGTERM, stop_running);
+
+    fs = glfs_new(argv[1]);
+    if (!fs) {
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    if (!fd) {
+        return -1;
+    }
+
+    /* sleep until SIGTERM has been received */
+    while (keep_running) {
+        sleep(1);
+    }
+
+    ret = glfs_close(fd);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    return 0;
 }
diff --git a/tests/bugs/cli/bug-1169302.t b/tests/bugs/cli/bug-1169302.t
index 24355e55646..19660e033a8 100755
--- a/tests/bugs/cli/bug-1169302.t
+++ b/tests/bugs/cli/bug-1169302.t
@@ -20,6 +20,9 @@ TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0 $H3:$B3/$V0
 TEST $CLI_1 volume start $V0
 
 # test CLI parameter acceptance
+TEST $CLI_1 volume statedump $V0
+TEST $CLI_2 volume statedump $V0
+TEST $CLI_3 volume statedump $V0
 TEST ! $CLI_1 volume statedump $V0 client $H2:0
 TEST ! $CLI_2 volume statedump $V0 client $H2:-1
 TEST $CLI_3 volume statedump $V0 client $H2:765
@@ -40,11 +43,13 @@ cleanup_statedump
 # hostname or IP-address with the connection from the bug-1169302 executable.
 # In our CI it seems not possible to use $H0, 'localhost', $(hostname --fqdn)
 # or even "127.0.0.1"....
-TEST $CLI_3 volume statedump $V0 client $H1:$GFAPI_PID
+sleep 2
+host=`netstat -nap | grep $GFAPI_PID | grep 24007 |  awk '{print $4}' | cut -d: -f1`
+TEST $CLI_3 volume statedump $V0 client $host:$GFAPI_PID
 EXPECT_WITHIN $STATEDUMP_TIMEOUT "Y" path_exists $statedumpdir/glusterdump.$GFAPI_PID*
 
 kill $GFAPI_PID
 
 cleanup_statedump
 cleanup_tester $(dirname $0)/bug-1169302
-cleanup
+cleanup
+\ No newline at end of file
diff --git a/tests/bugs/cli/bug-1320388.t b/tests/bugs/cli/bug-1320388.t
index ca23ab8371d..e719fc59033 100755
--- a/tests/bugs/cli/bug-1320388.t
+++ b/tests/bugs/cli/bug-1320388.t
@@ -19,9 +19,9 @@ SSL_CA=$SSL_BASE/glusterfs.ca
 
 cleanup;
 rm -f $SSL_BASE/glusterfs.*
-touch /var/lib/glusterd/secure-access
+touch "$GLUSTERD_WORKDIR"/secure-access
 
-TEST openssl genrsa -out $SSL_KEY 1024
+TEST openssl genrsa -out $SSL_KEY 2048
 TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
 ln $SSL_CERT $SSL_CA
 
@@ -29,6 +29,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
 TEST $CLI volume set $V0 disperse.eager-lock off
+TEST $CLI volume set $V0 disperse.other-eager-lock off
 TEST $CLI volume start $V0
 TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "^6$" ec_child_up_count $V0 0
diff --git a/tests/bugs/cli/bug-1353156-get-state-cli-validations.t b/tests/bugs/cli/bug-1353156-get-state-cli-validations.t
index c9c06cc6567..a4556c9c997 100644
--- a/tests/bugs/cli/bug-1353156-get-state-cli-validations.t
+++ b/tests/bugs/cli/bug-1353156-get-state-cli-validations.t
@@ -43,7 +43,6 @@ push_trapfunc rm -rf $ODIR
 
 TEST $CLI volume create $V0 disperse $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
 TEST $CLI volume start $V0
-TEST $CLI volume tier $V0 attach replica 2 $H0:$B1/b4 $H0:$B1/b5
 
 TEST setup_lvm 1
 TEST $CLI volume create $V1 $H0:$L1;
diff --git a/tests/bugs/cli/bug-1378842-volume-get-all.t b/tests/bugs/cli/bug-1378842-volume-get-all.t
index c798ce5ceff..be41f25b000 100644
--- a/tests/bugs/cli/bug-1378842-volume-get-all.t
+++ b/tests/bugs/cli/bug-1378842-volume-get-all.t
@@ -12,9 +12,6 @@ TEST $CLI volume set all server-quorum-ratio 80
 # Execute volume get without having an explicit option, this should fail
 TEST ! $CLI volume get all
 
-# Also volume get on an option not applicable for all volumes should fail
-TEST ! $CLI volume get all cluster.tier-mode
-
 # Execute volume get with an explicit global option
 TEST $CLI volume get all server-quorum-ratio
 EXPECT '80' volume_get_field all 'cluster.server-quorum-ratio'
diff --git a/tests/bugs/cli/bug-770655.t b/tests/bugs/cli/bug-770655.t
deleted file mode 100755
index 4e0b20d62da..00000000000
--- a/tests/bugs/cli/bug-770655.t
+++ /dev/null
@@ -1,168 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start and create a distribute-replicate volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Distributed-Replicate' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST ! $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
-
-## Start and create a replicate volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 8 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Replicate' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST ! $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
-
-## Start and create a distribute volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Distribute' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST ! $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
-
-## Start and create a stripe volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 stripe 8 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Stripe' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '10MB' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
-
-## Start and create a distributed stripe volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 stripe 4 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Distributed-Stripe' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '10MB' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
-
-## Start and create a distributed stripe replicate volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 stripe 2 replica 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Distributed-Striped-Replicate' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting stripe-block-size as 10MB
-TEST $CLI volume set $V0 stripe-block-size 10MB
-EXPECT '10MB' volinfo_field $V0 'cluster.stripe-block-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/cli/bug-822830.t b/tests/bugs/cli/bug-822830.t
index b66aa4f8981..a9904854110 100755
--- a/tests/bugs/cli/bug-822830.t
+++ b/tests/bugs/cli/bug-822830.t
@@ -8,7 +8,7 @@ cleanup;
 ## Start and create a volume
 TEST glusterd;
 TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
diff --git a/tests/bugs/cli/bug-961307.t b/tests/bugs/cli/bug-961307.t
index 68fc7bb6a15..602a6e34bce 100644
--- a/tests/bugs/cli/bug-961307.t
+++ b/tests/bugs/cli/bug-961307.t
@@ -13,7 +13,7 @@ TEST pidof glusterd
 TEST $CLI volume create $V0 replica $REPLICA $H0:$B0/${V0}-00 $H0:$B0/${V0}-01 $H0:$B0/${V0}-10 $H0:$B0/${V0}-11
 TEST $CLI volume start $V0
 
-var1=$(gluster volume remove-brick $H0:$B0/${V0}-00 $H0:$B0/${V0}-01 start 2>&1)
+var1=$($CLI volume remove-brick $H0:$B0/${V0}-00 $H0:$B0/${V0}-01 start 2>&1)
 var2="volume remove-brick start: failed: Volume $H0:$B0/${V0}-00 does not exist"
 
 EXPECT "$var2" echo "$var1"
diff --git a/tests/bugs/cli/bug-983317-volume-get.t b/tests/bugs/cli/bug-983317-volume-get.t
index 8f09d588565..c793bbc9f0c 100644
--- a/tests/bugs/cli/bug-983317-volume-get.t
+++ b/tests/bugs/cli/bug-983317-volume-get.t
@@ -7,7 +7,8 @@ cleanup;
 TEST glusterd
 TEST pidof glusterd
 
-TEST $CLI volume create $V0 $H0:$B0/$V0
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+EXPECT 'Created' volinfo_field $V0 'Status';
 
 # Set a volume option
 TEST $CLI volume set $V0 open-behind on
@@ -32,3 +33,13 @@ EXPECT '80' volume_get_field $V0 'server-quorum-ratio'
 
 # Check user.* options can also be retrived using volume get
 EXPECT 'dummy' volume_get_field $V0 'user.metadata'
+
+TEST $CLI volume set all brick-multiplex enable
+EXPECT 'enable' volume_get_field $V0 'brick-multiplex'
+
+TEST $CLI volume set all brick-multiplex disable
+EXPECT 'disable' volume_get_field $V0 'brick-multiplex'
+
+#setting an cluster level option for single volume should fail
+TEST ! $CLI volume set $V0 brick-multiplex enable
+
diff --git a/tests/bugs/core/brick-mux-fd-cleanup.t b/tests/bugs/core/brick-mux-fd-cleanup.t
new file mode 100644
index 00000000000..de11c177b8a
--- /dev/null
+++ b/tests/bugs/core/brick-mux-fd-cleanup.t
@@ -0,0 +1,78 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+#This .t tests that the fds from client are closed on brick when gluster volume
+#stop is executed in brick-mux setup.
+
+cleanup;
+TEST glusterd
+TEST pidof glusterd
+
+function keep_fd_open {
+#This function has to be run as background job because opening the fd in
+#foreground and running commands is leading to flush calls on these fds
+#which is making it very difficult to create the race where fds will be left
+#open even after the brick dies.
+    exec 5>$M1/a
+    exec 6>$M1/b
+    while [ -f $M0/a ]; do sleep 1; done
+}
+
+function count_open_files {
+    local brick_pid="$1"
+    local pattern="$2"
+    ls -l /proc/$brick_pid/fd | grep -i "$pattern" | wc -l
+}
+
+TEST $CLI volume set all cluster.brick-multiplex on
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume create $V1 replica 2 $H0:$B0/${V1}{2,3}
+#Have same configuration on both bricks so that they are multiplexed
+#Delay flush fop for a second
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume heal $V1 disable
+TEST $CLI volume set $V0 delay-gen posix
+TEST $CLI volume set $V0 delay-gen.enable flush
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.delay-duration 1000000
+TEST $CLI volume set $V1 delay-gen posix
+TEST $CLI volume set $V1 delay-gen.enable flush
+TEST $CLI volume set $V1 delay-gen.delay-percentage 100
+TEST $CLI volume set $V1 delay-gen.delay-duration 1000000
+
+TEST $CLI volume start $V0
+TEST $CLI volume start $V1
+
+TEST $GFS -s $H0 --volfile-id=$V0 --direct-io-mode=enable $M0
+TEST $GFS -s $H0 --volfile-id=$V1 --direct-io-mode=enable $M1
+
+TEST touch $M0/a
+keep_fd_open &
+TEST $CLI volume profile $V1 start
+brick_pid=$(get_brick_pid $V1 $H0 $B0/${V1}2)
+TEST count_open_files $brick_pid "$B0/${V1}2/a"
+TEST count_open_files $brick_pid "$B0/${V1}2/b"
+TEST count_open_files $brick_pid "$B0/${V1}3/a"
+TEST count_open_files $brick_pid "$B0/${V1}3/b"
+
+#If any other flush fops are introduced into the system other than the one at
+#cleanup it interferes with the race, so test for it
+EXPECT "^0$" echo "$($CLI volume profile $V1 info incremental | grep -i flush | wc -l)"
+#Stop the volume
+TEST $CLI volume stop $V1
+
+#Wait for cleanup resources or volume V1
+EXPECT_WITHIN $GRAPH_SWITCH_TIMEOUT "^0$" count_open_files $brick_pid "$B0/${V1}2/a"
+EXPECT_WITHIN $GRAPH_SWITCH_TIMEOUT "^0$" count_open_files $brick_pid "$B0/${V1}2/b"
+EXPECT_WITHIN $GRAPH_SWITCH_TIMEOUT "^0$" count_open_files $brick_pid "$B0/${V1}3/a"
+EXPECT_WITHIN $GRAPH_SWITCH_TIMEOUT "^0$" count_open_files $brick_pid "$B0/${V1}3/b"
+
+TEST rm -f $M0/a #Exit keep_fd_open()
+wait
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
+
+cleanup
diff --git a/tests/bugs/core/bug-1402841.t-mt-dir-scan-race.t b/tests/bugs/core/bug-1402841.t-mt-dir-scan-race.t
index 6351ba22511..a1b9a851bf7 100755
--- a/tests/bugs/core/bug-1402841.t-mt-dir-scan-race.t
+++ b/tests/bugs/core/bug-1402841.t-mt-dir-scan-race.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../volume.rc
 cleanup;
 
+FILE_COUNT=500
+
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
@@ -11,15 +13,14 @@ TEST $CLI volume set $V0 cluster.shd-wait-qlength 100
 TEST $CLI volume start $V0
 
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
-touch $M0/file{1..200}
-
+for i in `seq 1 $FILE_COUNT`;  do touch $M0/file$i; done
 TEST kill_brick $V0 $H0 $B0/${V0}1
-for i in {1..200}; do echo hello>$M0/file$i; done
+for i in `seq 1 $FILE_COUNT`; do echo hello>$M0/file$i; chmod -x $M0/file$i; done
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
 
-EXPECT "200" get_pending_heal_count $V0
+EXPECT "$FILE_COUNT" get_pending_heal_count $V0
 TEST $CLI volume set $V0 self-heal-daemon on
 
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
diff --git a/tests/bugs/core/bug-1432542-mpx-restart-crash.t b/tests/bugs/core/bug-1432542-mpx-restart-crash.t
index 970a181c83d..2793d7008e1 100644
--- a/tests/bugs/core/bug-1432542-mpx-restart-crash.t
+++ b/tests/bugs/core/bug-1432542-mpx-restart-crash.t
@@ -1,10 +1,14 @@
 #!/bin/bash
 
+SCRIPT_TIMEOUT=800
+
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../traps.rc
 
-NUM_VOLS=20
+cleanup;
+
+NUM_VOLS=15
 MOUNT_BASE=$(dirname $M0)
 
 # GlusterD reports that bricks are started when in fact their attach requests
@@ -28,12 +32,17 @@ get_mount_point () {
 	printf "%s/vol%02d" $MOUNT_BASE $1
 }
 
+function count_up_bricks {
+        vol=$1;
+        $CLI --xml volume status $vol | grep '<status>1' | wc -l
+}
+
 create_volume () {
 
 	local vol_name=$(printf "%s-vol%02d" $V0 $1)
 
 	local brick_base=$(get_brick_base $1)
-	local cmd="$CLI volume create $vol_name replica 2"
+	local cmd="$CLI volume create $vol_name replica 3"
 	local b
 	for b in $(seq 0 5); do
 		local this_brick=${brick_base}/brick$b
@@ -42,7 +51,8 @@ create_volume () {
 	done
 	TEST $cmd
 	TEST $CLI volume start $vol_name
-	EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Started" volinfo_field $vol_name "Status"
+	# check for 6 bricks and 1 shd daemon to be up and running
+        EXPECT_WITHIN 120 7 count_up_bricks $vol_name
 	local mount_point=$(get_mount_point $1)
 	mkdir -p $mount_point
 	TEST $GFS -s $H0 --volfile-id=$vol_name $mount_point
@@ -69,12 +79,27 @@ TEST $CLI volume set all cluster.brick-multiplex on
 # Our infrastructure can't handle an arithmetic expression here.  The formula
 # is (NUM_VOLS-1)*5 because it sees each TEST/EXPECT once but needs the other
 # NUM_VOLS-1 and there are 5 such statements in each iteration.
-TESTS_EXPECTED_IN_LOOP=95
+TESTS_EXPECTED_IN_LOOP=84
 for i in $(seq 1 $NUM_VOLS); do
+        starttime="$(date +%s)";
+
 	create_volume $i
 	TEST dd if=/dev/zero of=$(get_mount_point $i)/a_file bs=4k count=1
+        # Unmounting to reduce memory footprint on regression hosts
+        mnt_point=$(get_mount_point $i)
+        EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $mnt_point
+        endtime=$(expr $(date +%s) - $starttime)
+
+        echo "Memory Used after $i volumes : $(pmap -x $(pgrep glusterfsd) | grep total)"
+        echo "Thread Count after $i volumes: $(ps -T -p $(pgrep glusterfsd) | wc -l)"
+        echo "Time taken                   : ${endtime} seconds"
 done
 
+echo "=========="
+echo "List of all the threads in the Brick process"
+ps -T -p $(pgrep glusterfsd)
+echo "=========="
+
 # Kill glusterd, and wait a bit for all traces to disappear.
 TEST killall -9 glusterd
 sleep 5
diff --git a/tests/bugs/core/bug-1650403.t b/tests/bugs/core/bug-1650403.t
new file mode 100644
index 00000000000..43d09bc8bd9
--- /dev/null
+++ b/tests/bugs/core/bug-1650403.t
@@ -0,0 +1,113 @@
+#!/bin/bash
+
+SCRIPT_TIMEOUT=500
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../traps.rc
+
+cleanup;
+
+NUM_VOLS=5
+MOUNT_BASE=$(dirname $M0)
+
+# GlusterD reports that bricks are started when in fact their attach requests
+# might still need to be retried.  That's a bit of a hack, but there's no
+# feasible way to wait at that point (in attach_brick) and the rest of the
+# code is unprepared to deal with transient errors so the whole "brick start"
+# would fail.  Meanwhile, glusterfsd can only handle attach requests at a
+# rather slow rate.  After GlusterD tries to start a couple of hundred bricks,
+# glusterfsd can fall behind and we start getting mount failures.  Arguably,
+# those are spurious because we will eventually catch up.  We're just not
+# ready *yet*.  More to the point, even if the errors aren't spurious that's
+# not what we're testing right now.  Therefore, we give glusterfsd a bit more
+# breathing room for this test than we would otherwise.
+MOUNT_TIMEOUT=15
+
+get_brick_base () {
+	printf "%s/vol%02d" $B0 $1
+}
+
+get_mount_point () {
+	printf "%s/vol%02d" $MOUNT_BASE $1
+}
+
+function count_up_bricks {
+        vol=$1;
+        $CLI --xml volume status $vol | grep '<status>1' | wc -l
+}
+
+create_volume () {
+
+	local vol_name=$(printf "%s-vol%02d" $V0 $1)
+
+	local brick_base=$(get_brick_base $1)
+	local cmd="$CLI volume create $vol_name replica 3"
+	local b
+	for b in $(seq 0 5); do
+		local this_brick=${brick_base}/brick$b
+		mkdir -p $this_brick
+		cmd="$cmd $H0:$this_brick"
+	done
+	TEST $cmd
+	TEST $CLI volume start $vol_name
+	# check for 6 bricks and 1 shd daemon to be up and running
+        EXPECT_WITHIN 120 7 count_up_bricks $vol_name
+	local mount_point=$(get_mount_point $1)
+	mkdir -p $mount_point
+	TEST $GFS -s $H0 --volfile-id=$vol_name $mount_point
+}
+
+cleanup_func () {
+	local v
+	for v in $(seq 1 $NUM_VOLS); do
+		local mount_point=$(get_mount_point $v)
+		force_umount $mount_point
+		rm -rf $mount_point
+		local vol_name=$(printf "%s-vol%02d" $V0 $v)
+		$CLI volume stop $vol_name
+		$CLI volume delete $vol_name
+		rm -rf $(get_brick_base $1) &
+	done &> /dev/null
+	wait
+}
+push_trapfunc cleanup_func
+
+TEST glusterd
+TEST $CLI volume set all cluster.brick-multiplex on
+
+# Our infrastructure can't handle an arithmetic expression here.  The formula
+# is (NUM_VOLS-1)*5 because it sees each TEST/EXPECT once but needs the other
+# NUM_VOLS-1 and there are 5 such statements in each iteration.
+TESTS_EXPECTED_IN_LOOP=24
+for i in $(seq 1 $NUM_VOLS); do
+	create_volume $i
+	TEST dd if=/dev/zero of=$(get_mount_point $i)/a_file bs=4k count=1
+        # Unmounting to reduce memory footprint on regression hosts
+        mnt_point=$(get_mount_point $i)
+        EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $mnt_point
+done
+
+glustershd_pid=`ps auxwww | grep glustershd | grep -v grep | awk -F " " '{print $2}'`
+TEST [ $glustershd_pid != 0 ]
+start=`pmap -x $glustershd_pid | grep total | awk -F " " '{print $4}'`
+echo "Memory consumption for glustershd process"
+for i in $(seq 1 50); do
+        pmap -x $glustershd_pid | grep total
+        for j in $(seq 1 $NUM_VOLS); do
+                vol_name=$(printf "%s-vol%02d" $V0 $j)
+                gluster v set $vol_name cluster.self-heal-daemon off > /dev/null
+                gluster v set $vol_name cluster.self-heal-daemon on  > /dev/null
+        done
+done
+
+end=`pmap -x $glustershd_pid | grep total | awk -F " " '{print $4}'`
+diff=$((end-start))
+
+# If memory consumption is more than 10M it means some leak in reconfigure
+# code path
+
+TEST [ $diff -lt 10000 ]
+
+trap - EXIT
+cleanup
diff --git a/tests/bugs/core/bug-1699025-brick-mux-detach-brick-fd-issue.t b/tests/bugs/core/bug-1699025-brick-mux-detach-brick-fd-issue.t
new file mode 100644
index 00000000000..1acbaa8dc0b
--- /dev/null
+++ b/tests/bugs/core/bug-1699025-brick-mux-detach-brick-fd-issue.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+cleanup
+
+#bug-1444596 - validating brick mux
+
+TEST glusterd
+TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
+TEST $CLI volume create $V1 $H0:$B0/brick{2,3}
+
+TEST $CLI volume set all cluster.brick-multiplex on
+
+TEST $CLI volume start $V0
+TEST $CLI volume start $V1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+EXPECT 1 count_brick_processes
+
+TEST $CLI volume stop $V1
+# At the time initialize brick daemon it always keeps open
+# standard fd's (0, 1 , 2) so after stop 1 volume fd's should
+# be open
+nofds=$(ls -lrth /proc/`pgrep glusterfsd`/fd | grep dev/null | wc -l)
+TEST [ $((nofds)) -eq 3 ]
+
+cleanup
diff --git a/tests/bugs/core/bug-834465.c b/tests/bugs/core/bug-834465.c
index 61d3deac077..33dd270b112 100644
--- a/tests/bugs/core/bug-834465.c
+++ b/tests/bugs/core/bug-834465.c
@@ -7,55 +7,54 @@
 #include <fcntl.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1;
-        char        *filename = NULL;
-        struct flock lock     = {0, };
-        int          i        = 0;
-        int          ret      = -1;
-
-        if (argc != 2) {
-                fprintf (stderr, "Usage: %s <filename> ", argv[0]);
-                goto out;
+    int fd = -1;
+    char *filename = NULL;
+    struct flock lock = {
+        0,
+    };
+    int i = 0;
+    int ret = -1;
+
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <filename> ", argv[0]);
+        goto out;
+    }
+
+    filename = argv[1];
+
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 1;
+    lock.l_len = 1;
+
+    while (i < 100) {
+        lock.l_type = F_WRLCK;
+        ret = fcntl(fd, F_SETLK, &lock);
+        if (ret < 0) {
+            fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno));
+            goto out;
         }
 
-        filename = argv[1];
-
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
+        lock.l_type = F_UNLCK;
+        ret = fcntl(fd, F_SETLK, &lock);
+        if (ret < 0) {
+            fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno));
+            goto out;
         }
 
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 1;
-        lock.l_len = 1;
-
-        while (i < 100) {
-                lock.l_type = F_WRLCK;
-                ret = fcntl (fd, F_SETLK, &lock);
-                if (ret < 0) {
-                        fprintf (stderr, "fcntl setlk failed (%s)\n",
-                                        strerror (errno));
-                        goto out;
-                }
-
-                lock.l_type = F_UNLCK;
-                ret = fcntl (fd, F_SETLK, &lock);
-                if (ret < 0) {
-                        fprintf (stderr, "fcntl setlk failed (%s)\n",
-                                        strerror (errno));
-                        goto out;
-                }
-
-                i++;
-        }
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/core/bug-908146.t b/tests/bugs/core/bug-908146.t
index bf34992fee5..327be6e54bc 100755
--- a/tests/bugs/core/bug-908146.t
+++ b/tests/bugs/core/bug-908146.t
@@ -2,18 +2,8 @@
 
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
 
-function get_fd_count {
-        local vol=$1
-        local host=$2
-        local brick=$3
-        local fname=$4
-        local gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $brick/$fname))
-        local statedump=$(generate_brick_statedump $vol $host $brick)
-        local count=$(grep "gfid=$gfid_str" $statedump -A2 | grep fd-count | cut -f2 -d'=' | tail -1)
-        rm -f $statedump
-        echo $count
-}
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/core/bug-927616.t b/tests/bugs/core/bug-927616.t
index 6bb64743183..18257131ac7 100755
--- a/tests/bugs/core/bug-927616.t
+++ b/tests/bugs/core/bug-927616.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/core/io-stats-1322825.t b/tests/bugs/core/io-stats-1322825.t
index d232ecb2420..53f2d040daa 100755
--- a/tests/bugs/core/io-stats-1322825.t
+++ b/tests/bugs/core/io-stats-1322825.t
@@ -23,7 +23,7 @@ TEST $CLI volume profile $V0 start
 TEST mkdir $M0/dir1
 
 # Generate the stat dump across the io-stat instances
-TEST setfattr -n trusted.io-stats-dump -v /tmp/io-stats-1322825 $M0
+TEST setfattr -n trusted.io-stats-dump -v io-stats-1322825 $M0
 
 # Check if $M0 is clean w.r.t xattr information
 # TODO: if there are better ways to check we really get no attr error, please
@@ -42,12 +42,12 @@ ret=$(echo $?)
 EXPECT 0 echo $ret
 
 # Check if we have 5 io-stat files in /tmp
-EXPECT 5 ls -1 /tmp/io-stats-1322825*
+EXPECT 5 ls -1 /var/run/gluster/io-stats-1322825*
 # Cleanup the 5 generated files
-rm -f /tmp/io-stats-1322825*
+rm -f /var/run/gluster/io-stats-1322825*
 
 # Rinse and repeat above for a directory
-TEST setfattr -n trusted.io-stats-dump -v /tmp/io-stats-1322825 $M0/dir1
+TEST setfattr -n trusted.io-stats-dump -v io-stats-1322825 $M0/dir1
 getfattr -n trusted.io-stats-dump $B0/${V0}1/dir1 2>&1 | grep -qi "no such attribute"
 ret=$(echo $?)
 EXPECT 0 echo $ret
@@ -61,7 +61,7 @@ getfattr -n trusted.io-stats-dump $B0/${V0}4/dir1 2>&1 | grep -qi "no such attri
 ret=$(echo $?)
 EXPECT 0 echo $ret
 
-EXPECT 5 ls -1 /tmp/io-stats-1322825*
-rm -f /tmp/io-stats-1322825*
+EXPECT 5 ls -1 /var/run/gluster/io-stats-1322825*
+rm -f /var/run/gluster/io-stats-1322825*
 
 cleanup;
diff --git a/tests/bugs/ctime/issue-832.t b/tests/bugs/ctime/issue-832.t
new file mode 100755
index 00000000000..740f731ab73
--- /dev/null
+++ b/tests/bugs/ctime/issue-832.t
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../traps.rc
+
+#Trigger trusted.glusterfs.mdata setting codepath and see things work as expected
+cleanup
+
+TEST_USER=test-ctime-user
+TEST_UID=27341
+
+TEST useradd -o -M -u ${TEST_UID} ${TEST_USER}
+push_trapfunc "userdel --force ${TEST_USER}"
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0
+TEST $CLI volume start $V0
+
+$GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+echo abc > $M0/test
+TEST chmod 755 $M0/
+TEST chmod 744 $M0/test
+TEST setfattr -x trusted.glusterfs.mdata $B0/$V0/test
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+$GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
+su ${TEST_USER} -c "cat $M0/test"
+TEST getfattr -n trusted.glusterfs.mdata $B0/$V0/test
+
+cleanup
diff --git a/tests/bugs/distribute/bug-1125824.t b/tests/bugs/distribute/bug-1125824.t
index 3bafbf31fe5..7e401092273 100755
--- a/tests/bugs/distribute/bug-1125824.t
+++ b/tests/bugs/distribute/bug-1125824.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 create_files () {
         for i in {1..10}; do
                 orig=$(printf %s/file%04d $1 $i)
diff --git a/tests/bugs/distribute/bug-1161156.t b/tests/bugs/distribute/bug-1161156.t
index fed90e7f478..2b9e15407ca 100755
--- a/tests/bugs/distribute/bug-1161156.t
+++ b/tests/bugs/distribute/bug-1161156.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 QDD=$(dirname $0)/quota
diff --git a/tests/bugs/distribute/bug-1161311.t b/tests/bugs/distribute/bug-1161311.t
index d88642edc32..62796068928 100755
--- a/tests/bugs/distribute/bug-1161311.t
+++ b/tests/bugs/distribute/bug-1161311.t
@@ -1,5 +1,7 @@
 #!/bin/bash
 
+SCRIPT_TIMEOUT=350
+
 # This tests for hard link preservation for files that are linked, when the
 # file is undergoing migration
 
@@ -74,14 +76,12 @@ TEST glusterfs -s $H0 --volfile-id $V0 $M0;
 TEST mkdir $M0/dir1
 TEST mkdir -p $M0/dir2/dir3
 
-# Create a large file (6.4 GB), so that rebalance takes time
-# Reading from /dev/urandom is slow, so we'll cat it together
-dd if=/dev/urandom of=/tmp/FILE2 bs=64k count=10240
-for i in {1..10}; do
-  cat /tmp/FILE2 >> $M0/dir1/FILE2
-done
-
-#dd if=/dev/urandom of=$M0/dir1/FILE2 bs=64k count=10240
+# Create a large file (8 GB), so that rebalance takes time
+# Since we really don't care about the contents of the file, we use fallocate
+# to generate the file much faster. We could also use truncate, which is even
+# faster, but rebalance could take advantage of an sparse file and migrate it
+# in an optimized way, but we don't want a fast migration.
+TEST fallocate -l 8G $M0/dir1/FILE2
 
 # Rename the file to create a linkto, for rebalance to
 # act on the file
@@ -89,6 +89,8 @@ done
 ## into separate bricks when brick count is 3
 TEST mv $M0/dir1/FILE2 $M0/dir1/FILE1
 
+brick_loc=$(get_backend_paths $M0/dir1/FILE1)
+
 # unmount and remount the volume
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST glusterfs -s $H0 --volfile-id $V0 $M0;
@@ -98,7 +100,7 @@ TEST $CLI volume rebalance $V0 start force
 
 # Wait for FILE to get the sticky bit on, so that file is under
 # active rebalance, before creating the links
-TEST checksticky $B0/${V0}3/dir1/FILE1
+TEST checksticky $brick_loc
 
 # Create the links
 ## FILE3 FILE5 FILE7 have hashes, c8c91469 566d26ce 22ce7eba
@@ -119,7 +121,7 @@ cd /
 
 # Ideally for this test to have done its job, the file should still be
 # under migration, so check the sticky bit again
-TEST checksticky $B0/${V0}3/dir1/FILE1
+TEST checksticky $brick_loc
 
 # Wait for rebalance to complete
 EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
@@ -152,6 +154,11 @@ TEST ln ./dir1/FILE7 ./FILE7
 cd /
 linkcountsrc=$(stat -c %h $M0/dir1/FILE1)
 TEST [[ $linkcountsrc == 14 ]]
+
+
+# Stop the volume
+TEST $CLI volume stop $V0;
+
 UMOUNT_LOOP ${B0}/${V0}{1..3}
 rm -f ${B0}/brick{1..3}
 cleanup;
diff --git a/tests/bugs/distribute/bug-1190734.t b/tests/bugs/distribute/bug-1190734.t
index d48d74d2c35..9256088f7a0 100644
--- a/tests/bugs/distribute/bug-1190734.t
+++ b/tests/bugs/distribute/bug-1190734.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 BRICK_COUNT=3
 FILE_COUNT=100
 FILE_COUNT_TIME=5
diff --git a/tests/bugs/distribute/bug-1193636.c b/tests/bugs/distribute/bug-1193636.c
index eae90783f8e..ea3f79a4e06 100644
--- a/tests/bugs/distribute/bug-1193636.c
+++ b/tests/bugs/distribute/bug-1193636.c
@@ -1,70 +1,68 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
 #include <fcntl.h>
 #include <string.h>
 
+#define MY_XATTR_NAME "user.ftest"
+#define MY_XATTR_VAL "ftestval"
 
-#define MY_XATTR_NAME   "user.ftest"
-#define MY_XATTR_VAL    "ftestval"
-
-
-void usage (void)
+void
+usage(void)
 {
-        printf ("Usage : bug-1193636 <filename> <xattr_name> <op>\n");
-        printf ("   op : 0 - set, 1 - remove\n");
+    printf("Usage : bug-1193636 <filename> <xattr_name> <op>\n");
+    printf("   op : 0 - set, 1 - remove\n");
 }
 
-
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int fd;
-        int err = 0;
-        char *xattr_name = NULL;
-        int op = 0;
-
-        if (argc != 4) {
-                usage ();
-                exit (1);
-        }
-
-        op = atoi (argv[3]);
-
-        if ((op != 0) && (op != 1)) {
-                printf ("Invalid operation specified.\n");
-                usage ();
-                exit (1);
+    int fd;
+    int err = 0;
+    char *xattr_name = NULL;
+    int op = 0;
+
+    if (argc != 4) {
+        usage();
+        exit(1);
+    }
+
+    op = atoi(argv[3]);
+
+    if ((op != 0) && (op != 1)) {
+        printf("Invalid operation specified.\n");
+        usage();
+        exit(1);
+    }
+
+    xattr_name = argv[2];
+
+    fd = open(argv[1], O_RDWR);
+    if (fd == -1) {
+        printf("Failed to open file %s\n", argv[1]);
+        exit(1);
+    }
+
+    if (!op) {
+        err = fsetxattr(fd, xattr_name, MY_XATTR_VAL, strlen(MY_XATTR_VAL) + 1,
+                        XATTR_CREATE);
+
+        if (err) {
+            printf("Failed to set xattr %s: %m\n", xattr_name);
+            exit(1);
         }
 
-        xattr_name = argv[2];
+    } else {
+        err = fremovexattr(fd, xattr_name);
 
-        fd = open(argv[1], O_RDWR);
-        if (fd == -1) {
-                printf ("Failed to open file %s\n", argv[1]);
-                exit (1);
+        if (err) {
+            printf("Failed to remove xattr %s: %m\n", xattr_name);
+            exit(1);
         }
+    }
 
-        if (!op) {
-                err = fsetxattr (fd, xattr_name, MY_XATTR_VAL,
-                                 strlen (MY_XATTR_VAL) + 1, XATTR_CREATE);
+    close(fd);
 
-                if (err) {
-                        printf ("Failed to set xattr %s: %m\n", xattr_name);
-                        exit (1);
-                }
-
-        } else {
-                err = fremovexattr (fd, xattr_name);
-
-                if (err) {
-                        printf ("Failed to remove xattr %s: %m\n", xattr_name);
-                        exit (1);
-                }
-        }
-
-        close (fd);
-
-        return 0;
+    return 0;
 }
-
diff --git a/tests/bugs/distribute/bug-1193636.t b/tests/bugs/distribute/bug-1193636.t
index ccde02edc70..b377910336e 100644
--- a/tests/bugs/distribute/bug-1193636.t
+++ b/tests/bugs/distribute/bug-1193636.t
@@ -41,11 +41,13 @@ dd if=/dev/zero of=$M0/dir1/FILE2 bs=64k count=10240
 # act on the file
 TEST mv $M0/dir1/FILE2 $M0/dir1/FILE1
 
+brick_loc=$(get_backend_paths $M0/dir1/FILE1)
+
 build_tester $(dirname $0)/bug-1193636.c
 
 TEST $CLI volume rebalance $V0 start force
 
-TEST checksticky $B0/${V0}3/dir1/FILE1
+TEST checksticky $brick_loc
 
 TEST setfattr -n "user.test1" -v "test1" $M0/dir1/FILE1
 TEST setfattr -n "user.test2" -v "test1" $M0/dir1/FILE1
diff --git a/tests/bugs/distribute/bug-1247563.t b/tests/bugs/distribute/bug-1247563.t
index f7f92582e04..a2fc722896f 100644
--- a/tests/bugs/distribute/bug-1247563.t
+++ b/tests/bugs/distribute/bug-1247563.t
@@ -30,6 +30,7 @@ TEST glusterfs --acl -s $H0 --volfile-id $V0 $M0
 TEST mkdir $M0/dir1
 
 echo "Testing pacls on rebalance" > $M0/dir1/FILE1
+
 FPATH1=`find $B0/ -name FILE1`
 
 # Rename the file to create a linkto, for rebalance to
@@ -55,3 +56,7 @@ COUNT=`getfacl $FPATH2 |grep -c "user:root:rwx"`
 EXPECT "0" echo $COUNT
 
 cleanup;
+
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/bugs/distribute/bug-1368012.t b/tests/bugs/distribute/bug-1368012.t
index f89314b1f2e..0b626353aab 100644
--- a/tests/bugs/distribute/bug-1368012.t
+++ b/tests/bugs/distribute/bug-1368012.t
@@ -15,13 +15,14 @@ TEST pidof glusterd;
 TEST $CLI volume info;
 
 ## Lets create volume
-TEST $CLI volume create $V0 $H0:/${V0}{1,2};
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
 
 ## Verify volume is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
 ## Start volume and verify
 TEST $CLI volume start $V0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" online_brick_count
 TEST $CLI volume set $V0 performance.stat-prefetch off
 EXPECT 'Started' volinfo_field $V0 'Status';
 TEST glusterfs -s $H0 --volfile-id=$V0 $M0
@@ -35,16 +36,16 @@ TEST chmod 444 $M0
 TEST permission_root=`stat -c "%A" $M0`
 TEST echo $permission_root
 #Add-brick
-TEST $CLI volume add-brick $V0 $H0:/${V0}3
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "3" online_brick_count
 
 #Allow one lookup to happen
-TEST pushd $M0
-TEST ls
+TEST ls $M0
 #Generate another lookup
 echo 3 > /proc/sys/vm/drop_caches
-TEST ls
+TEST ls $M0
 #check root permission
 EXPECT_WITHIN "5" $permission_root get_permission $M0
 #check permission on the new-brick
-EXPECT $permission_root get_permission /${V0}3
+EXPECT $permission_root get_permission $B0/${V0}3
 cleanup
diff --git a/tests/bugs/distribute/bug-1543279.t b/tests/bugs/distribute/bug-1543279.t
new file mode 100644
index 00000000000..47b8b4a4a95
--- /dev/null
+++ b/tests/bugs/distribute/bug-1543279.t
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+TESTS_EXPECTED_IN_LOOP=44
+SCRIPT_TIMEOUT=600
+
+rename_files() {
+    MOUNT=$1
+    ITERATIONS=$2
+    for i in $(seq 1 $ITERATIONS); do uuid="`uuidgen`"; echo "some data" > $MOUNT/test$uuid; mv $MOUNT/test$uuid $MOUNT/test -f || return $?; done
+}
+
+run_test_for_volume() {
+    VOLUME=$1
+    ITERATIONS=$2
+    TEST_IN_LOOP $CLI volume start $VOLUME
+
+    TEST_IN_LOOP glusterfs -s $H0 --volfile-id $VOLUME $M0
+    TEST_IN_LOOP glusterfs -s $H0 --volfile-id $VOLUME $M1
+    TEST_IN_LOOP glusterfs -s $H0 --volfile-id $VOLUME $M2
+    TEST_IN_LOOP glusterfs -s $H0 --volfile-id $VOLUME $M3
+
+    rename_files $M0 $ITERATIONS &
+    M0_RENAME_PID=$!
+
+    rename_files $M1 $ITERATIONS &
+    M1_RENAME_PID=$!
+
+    rename_files $M2 $ITERATIONS &
+    M2_RENAME_PID=$!
+
+    rename_files $M3 $ITERATIONS &
+    M3_RENAME_PID=$!
+
+    TEST_IN_LOOP wait $M0_RENAME_PID
+    TEST_IN_LOOP wait $M1_RENAME_PID
+    TEST_IN_LOOP wait $M2_RENAME_PID
+    TEST_IN_LOOP wait $M3_RENAME_PID
+
+    TEST_IN_LOOP $CLI volume stop $VOLUME
+    TEST_IN_LOOP $CLI volume delete $VOLUME
+    umount $M0 $M1 $M2 $M3
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0..8} force
+run_test_for_volume $V0 200
+
+TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/${V0}{0..8} force
+run_test_for_volume $V0 200
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0..8} force
+run_test_for_volume $V0 200
+
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5} force
+run_test_for_volume $V0 200
+
+cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/bugs/distribute/bug-1600379.t b/tests/bugs/distribute/bug-1600379.t
new file mode 100644
index 00000000000..8d2f6154100
--- /dev/null
+++ b/tests/bugs/distribute/bug-1600379.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# Initialize
+#------------------------------------------------------------
+cleanup;
+
+# Start glusterd
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+# Create a volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
+
+# Verify volume creation
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+# Start volume and verify successful start
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+#------------------------------------------------------------
+
+# Test case - Remove xattr from killed brick on lookup
+#------------------------------------------------------------
+# Create a dir and set custom xattr
+TEST mkdir $M0/testdir
+TEST setfattr -n user.attr -v val $M0/testdir
+xattr_val=`getfattr -d $B0/${V0}2/testdir | awk '{print $1}'`;
+TEST ${xattr_val}='user.attr="val"';
+
+# Kill 2nd brick process
+TEST kill_brick $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "1" online_brick_count
+
+# Remove custom xattr
+TEST setfattr -x user.attr $M0/testdir
+
+# Bring up the killed brick process
+TEST $CLI volume start $V0 force
+
+# Perform lookup
+sleep 5
+TEST ls $M0/testdir
+
+# Check brick xattrs
+xattr_val_2=`getfattr -d $B0/${V0}2/testdir`;
+TEST [ ${xattr_val_2} = ''] ;
+
+cleanup;
diff --git a/tests/bugs/distribute/bug-1667804.t b/tests/bugs/distribute/bug-1667804.t
new file mode 100644
index 00000000000..3f7c43111d7
--- /dev/null
+++ b/tests/bugs/distribute/bug-1667804.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+function confirm_all_linkto_files ()
+{
+   inpath=$1
+   for infile in $inpath/*
+   do
+      echo $infile
+      ret1=$(is_dht_linkfile $infile)
+      if [ "$ret1" -eq 0 ]; then
+        echo "$infile is not a linkto file"
+        echo 0
+        return
+      fi
+   done
+   echo  1
+}
+
+cleanup;
+
+#Basic checks
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+#Create a distributed volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..2};
+TEST $CLI volume start $V0
+
+# Mount FUSE
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+
+#Create files and rename them in order to create linkto files
+TEST mkdir -p $M0/dir0/dir1
+TEST touch $M0/dir0/dir1/file-{1..50}
+
+for i in {1..50}; do
+    mv $M0/dir0/dir1/file-$i $M0/dir0/dir1/nfile-$i;
+done
+
+#Remove the second brick to force the creation of linkto files
+#on the removed brick
+
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0 $H0:$B0/${V0}2"
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 stop
+
+EXPECT "1" confirm_all_linkto_files $B0/${V0}2/dir0/dir1
+
+#Modify the xattrs of the linkto files on the removed brick to point to itself.
+
+target=$(cat $M0/.meta/graphs/active/$V0-dht/subvolumes/1/name)
+
+setfattr -n trusted.glusterfs.dht.linkto -v "$target\0" $B0/${V0}2/dir0/dir1/nfile*
+
+
+TEST rm -rf $M0/dir0
+
+cleanup;
diff --git a/tests/bugs/distribute/bug-1786679.t b/tests/bugs/distribute/bug-1786679.t
new file mode 100755
index 00000000000..219ce51c8a9
--- /dev/null
+++ b/tests/bugs/distribute/bug-1786679.t
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+SCRIPT_TIMEOUT=250
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+
+# create 2 subvols
+# create a dir
+# create a file
+# change layout
+# remove the file
+# execute create from a different mount
+# Without the patch, the file will be present on both of the bricks
+
+cleanup
+
+function get_layout () {
+
+layout=`getfattr -n trusted.glusterfs.dht -e hex $1 2>&1 | grep dht | gawk -F"=" '{print $2}'`
+
+echo $layout
+
+}
+
+function set_layout()
+{
+    setfattr -n  "trusted.glusterfs.dht" -v $1 $2
+}
+
+TEST glusterd
+TEST pidof glusterd
+
+BRICK1=$B0/${V0}-0
+BRICK2=$B0/${V0}-1
+
+TEST $CLI volume create $V0 $H0:$BRICK1 $H0:$BRICK2
+TEST $CLI volume start $V0
+
+# Mount FUSE and create symlink
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+TEST mkdir $M0/dir
+TEST touch $M0/dir/file
+TEST ! stat "$BRICK1/dir/file"
+TEST stat "$BRICK2/dir/file"
+
+layout1="$(get_layout "$BRICK1/dir")"
+layout2="$(get_layout "$BRICK2/dir")"
+
+TEST set_layout $layout1 "$BRICK2/dir"
+TEST set_layout $layout2 "$BRICK1/dir"
+
+TEST rm $M0/dir/file -f
+TEST gluster v set $V0 client-log-level DEBUG
+
+#Without the patch in place, this client will create the file in $BRICK2
+#which will lead to two files being on both the bricks when a new client
+#create the file with the same name
+TEST touch $M0/dir/file
+
+TEST glusterfs -s $H0 --volfile-id $V0 $M1
+TEST touch $M1/dir/file
+
+TEST stat "$BRICK1/dir/file"
+TEST ! stat "$BRICK2/dir/file"
+
+cleanup
diff --git a/tests/bugs/distribute/bug-853258.t b/tests/bugs/distribute/bug-853258.t
index e39f507baf9..6817d9e2cd3 100755
--- a/tests/bugs/distribute/bug-853258.t
+++ b/tests/bugs/distribute/bug-853258.t
@@ -31,6 +31,7 @@ done
 
 # Expand the volume and force assignment of new ranges.
 TEST $CLI volume add-brick $V0 $H0:$B0/${V0}3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "4" online_brick_count
 # Force assignment of initial ranges.
 TEST $CLI volume rebalance $V0 fix-layout start
 EXPECT_WITHIN $REBALANCE_TIMEOUT "fix-layout completed" fix-layout_status_field $V0
diff --git a/tests/bugs/distribute/bug-860663.c b/tests/bugs/distribute/bug-860663.c
index bee4e7d40b1..ca0c31ffe8f 100644
--- a/tests/bugs/distribute/bug-860663.c
+++ b/tests/bugs/distribute/bug-860663.c
@@ -6,38 +6,36 @@
 #include <err.h>
 #include <sys/param.h>
 
-int
-main(argc, argv)
-        int argc;
-        char **argv;
+int main(argc, argv) int argc;
+char **argv;
 {
-        char *basepath;
-        char path[MAXPATHLEN + 1];
-        unsigned int count;
-        int i, fd;
+    char *basepath;
+    char path[MAXPATHLEN + 1];
+    unsigned int count;
+    int i, fd;
 
-        if (argc != 3)
-                errx(1, "usage: %s path count", argv[0]);
+    if (argc != 3)
+        errx(1, "usage: %s path count", argv[0]);
 
-        basepath = argv[1];
-        count = atoi(argv[2]);
+    basepath = argv[1];
+    count = atoi(argv[2]);
 
-        if (count > 999999)
-                errx(1, "count too big");
+    if (count > 999999)
+        errx(1, "count too big");
 
-        if (strlen(basepath) > MAXPATHLEN - 6)
-                errx(1, "path too long");
+    if (strlen(basepath) > MAXPATHLEN - 6)
+        errx(1, "path too long");
 
-        for (i = 0; i < count; i++) {
-                (void)sprintf(path, "%s%06d", basepath, i);
+    for (i = 0; i < count; i++) {
+        (void)sprintf(path, "%s%06d", basepath, i);
 
-                fd = open(path, O_CREAT|O_RDWR, 0644);
-                if (fd == -1)
-                        err(1, "create %s failed", path);
+        fd = open(path, O_CREAT | O_RDWR, 0644);
+        if (fd == -1)
+            err(1, "create %s failed", path);
 
-                if (close(fd) != 0)
-                        warn("close %s failed", path);
-        }
+        if (close(fd) != 0)
+            warn("close %s failed", path);
+    }
 
-        return 0;
+    return 0;
 }
diff --git a/tests/bugs/distribute/bug-862967.t b/tests/bugs/distribute/bug-862967.t
index 09dac376d94..2fb0848bd7c 100644
--- a/tests/bugs/distribute/bug-862967.t
+++ b/tests/bugs/distribute/bug-862967.t
@@ -37,7 +37,7 @@ chown 1:1 $M0/dir;
 
 # Kill a brick process
 
-kill_brick $V0 $H0 $B0/${V0}1
+kill_brick $V0 $H0 $B0/${V0}2
 # change dir ownership
 NEW_UID=36;
 NEW_GID=36;
@@ -51,9 +51,8 @@ sleep 10;
 ls -l $M0/dir;
 
 # check if uid/gid is healed on backend brick which was taken down
-BACKEND_UID=`stat -c %u $B0/${V0}1/dir`;
-BACKEND_GID=`stat -c %g $B0/${V0}1/dir`;
-
+BACKEND_UID=`stat -c %u $B0/${V0}2/dir`;
+BACKEND_GID=`stat -c %g $B0/${V0}2/dir`;
 
 EXPECT "0" uid_gid_compare $NEW_UID $NEW_GID $BACKEND_UID $BACKEND_GID
 
diff --git a/tests/bugs/distribute/issue-1327.t b/tests/bugs/distribute/issue-1327.t
new file mode 100755
index 00000000000..acd8c8c6614
--- /dev/null
+++ b/tests/bugs/distribute/issue-1327.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+SCRIPT_TIMEOUT=250
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../dht.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+BRICK1=$B0/${V0}-0
+BRICK2=$B0/${V0}-1
+
+TEST $CLI volume create $V0 $H0:$BRICK1 $H0:$BRICK2
+TEST $CLI volume start $V0
+
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+TEST mkdir $M0/dir
+
+#remove dir from one of the brick
+TEST rmdir $BRICK2/dir
+
+#safe cache timeout for lookup to be triggered
+sleep 2
+
+TEST ls $M0/dir
+
+TEST stat $BRICK2/dir
+
+cleanup
diff --git a/tests/bugs/distribute/overlap.py b/tests/bugs/distribute/overlap.py
index 15f2da473f1..2813979787b 100755
--- a/tests/bugs/distribute/overlap.py
+++ b/tests/bugs/distribute/overlap.py
@@ -1,27 +1,27 @@
-#!/usr/bin/python
 
+from __future__ import print_function
 import sys
 
 def calculate_one (ov, nv):
-    old_start = int(ov[18:26],16)
-    old_end = int(ov[26:34],16)
-    new_start = int(nv[18:26],16)
-    new_end = int(nv[26:34],16)
+    old_start = int(ov[18:26], 16)
+    old_end = int(ov[26:34], 16)
+    new_start = int(nv[18:26], 16)
+    new_end = int(nv[26:34], 16)
     if (new_end < old_start) or (new_start > old_end):
         #print '%s, %s -> ZERO' % (ov, nv)
         return 0
-    all_start = max(old_start,new_start)
-    all_end = min(old_end,new_end)
+    all_start = max(old_start, new_start)
+    all_end = min(old_end, new_end)
     #print '%s, %s -> %08x' % (ov, nv, all_end - all_start + 1)
     return all_end - all_start + 1
 
 def calculate_all (values):
     total = 0
-    nv_index = len(values) / 2
+    nv_index = len(values) // 2
     for old_val in values[:nv_index]:
         new_val = values[nv_index]
         nv_index += 1
-        total += calculate_one(old_val,new_val)
+        total += calculate_one(old_val, new_val)
     return total
 
 """
@@ -44,16 +44,16 @@ test2_vals = [
     '0x000000000000000055555555aaaaaaa9',   # second third
 ]
 
-print '%08x' % calculate_one(test1_vals[0],test1_vals[3])
-print '%08x' % calculate_one(test1_vals[1],test1_vals[4])
-print '%08x' % calculate_one(test1_vals[2],test1_vals[5])
+print '%08x' % calculate_one(test1_vals[0], test1_vals[3])
+print '%08x' % calculate_one(test1_vals[1], test1_vals[4])
+print '%08x' % calculate_one(test1_vals[2], test1_vals[5])
 print '= %08x' % calculate_all(test1_vals)
-print '%08x' % calculate_one(test2_vals[0],test2_vals[3])
-print '%08x' % calculate_one(test2_vals[1],test2_vals[4])
-print '%08x' % calculate_one(test2_vals[2],test2_vals[5])
+print '%08x' % calculate_one(test2_vals[0], test2_vals[3])
+print '%08x' % calculate_one(test2_vals[1], test2_vals[4])
+print '%08x' % calculate_one(test2_vals[2], test2_vals[5])
 print '= %08x' % calculate_all(test2_vals)
 """
 
 if __name__ == '__main__':
     # Return decimal so bash can reason about it.
-    print '%d' % calculate_all(sys.argv[1:])
+    print('%d' % calculate_all(sys.argv[1:]))
diff --git a/tests/bugs/ec/bug-1161886.c b/tests/bugs/ec/bug-1161886.c
index e8093e48a7a..1f12650ea6d 100644
--- a/tests/bugs/ec/bug-1161886.c
+++ b/tests/bugs/ec/bug-1161886.c
@@ -4,50 +4,50 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-
-        if (argc != 4) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, "/dev/null", 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-        glfs_close(fd);
-
-        ret = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/dev/null", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+    glfs_close(fd);
+
+    ret = 0;
 
 out:
-        glfs_fini (fs);
+    glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/ec/bug-1187474.t b/tests/bugs/ec/bug-1187474.t
index fb4b2082f8f..e6344c26e73 100644
--- a/tests/bugs/ec/bug-1187474.t
+++ b/tests/bugs/ec/bug-1187474.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 function check_dir()
 {
     local count
diff --git a/tests/bugs/ec/bug-1236065.t b/tests/bugs/ec/bug-1236065.t
index 9395aa33e8c..9181e73ec19 100644
--- a/tests/bugs/ec/bug-1236065.t
+++ b/tests/bugs/ec/bug-1236065.t
@@ -2,6 +2,7 @@
 
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
+SCRIPT_TIMEOUT=400
 
 cleanup
 
@@ -84,7 +85,6 @@ TEST pidof glusterd
 EXPECT "$V0" volinfo_field $V0 'Volume Name'
 EXPECT 'Started' volinfo_field $V0 'Status'
 EXPECT '7' online_brick_count
-
 ## cleanup
 cd
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
diff --git a/tests/bugs/ec/bug-1547662.t b/tests/bugs/ec/bug-1547662.t
new file mode 100644
index 00000000000..5748218587e
--- /dev/null
+++ b/tests/bugs/ec/bug-1547662.t
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# Immediately after replace-brick, trusted.ec.version will be absent, so if it
+# is present we can assume that heal was started on root
+function root_heal_attempted {
+        if [ -z $(get_hex_xattr trusted.ec.version $1) ]; then
+                echo "N"
+        else
+                echo "Y"
+        fi
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST ${CLI} volume create ${V0} disperse 6 redundancy 2 ${H0}:${B0}/${V0}{0..5}
+TEST ${CLI} volume start ${V0}
+TEST ${GFS} --volfile-server ${H0} --volfile-id ${V0} ${M0}
+EXPECT_WITHIN ${CHILD_UP_TIMEOUT} "6" ec_child_up_count ${V0} 0
+
+TEST mkdir ${M0}/base
+TEST mkdir ${M0}/base/dir.{1,2}
+TEST mkdir ${M0}/base/dir.{1,2}/dir.{1,2}
+TEST mkdir ${M0}/base/dir.{1,2}/dir.{1,2}/dir.{1,2}
+TEST mkdir ${M0}/base/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}
+TEST mkdir ${M0}/base/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}
+TEST mkdir ${M0}/base/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}/dir.{1,2}
+
+TEST ${CLI} volume replace-brick ${V0} ${H0}:${B0}/${V0}5 ${H0}:${B0}/${V0}6 commit force
+EXPECT_WITHIN ${CHILD_UP_TIMEOUT} "6" ec_child_up_count ${V0} 0
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "Y" glustershd_up_status
+EXPECT_WITHIN ${CHILD_UP_TIMEOUT} "6" ec_child_up_count_shd ${V0} 0
+EXPECT_WITHIN ${HEAL_TIMEOUT} "Y" root_heal_attempted ${B0}/${V0}6
+EXPECT_WITHIN ${HEAL_TIMEOUT} "^0$" get_pending_heal_count ${V0}
+EXPECT "^127$" echo $(find ${B0}/${V0}6/base -type d | wc -l)
+
+cleanup;
diff --git a/tests/bugs/ec/bug-1699866-check-reopen-fd.t b/tests/bugs/ec/bug-1699866-check-reopen-fd.t
new file mode 100644
index 00000000000..4386d010318
--- /dev/null
+++ b/tests/bugs/ec/bug-1699866-check-reopen-fd.t
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume set $V0 disperse.background-heals 0
+TEST $CLI volume set $V0 write-behind off
+TEST $CLI volume set $V0 open-behind off
+TEST $CLI volume start $V0
+TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+
+TEST mkdir -p $M0/dir
+
+fd="$(fd_available)"
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "5" ec_child_up_count $V0 0
+
+TEST fd_open ${fd} rw $M0/dir/test
+TEST fd_write ${fd} "test1"
+TEST $CLI volume replace-brick ${V0} $H0:$B0/${V0}0 $H0:$B0/${V0}0_1 commit force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0
+TEST fd_write ${fd} "test2"
+TEST fd_close ${fd}
+
+cleanup
diff --git a/tests/bugs/ec/bug-1708156-honor-inodelk-contention-notify-on-partial-locks.t b/tests/bugs/ec/bug-1708156-honor-inodelk-contention-notify-on-partial-locks.t
new file mode 100644
index 00000000000..67fdb184b46
--- /dev/null
+++ b/tests/bugs/ec/bug-1708156-honor-inodelk-contention-notify-on-partial-locks.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+function do_ls() {
+    local dir="${1}"
+    local i
+
+    for i in {1..50}; do
+        ls -l $M0/${dir} >/dev/null &
+        ls -l $M1/${dir} >/dev/null &
+        ls -l $M2/${dir} >/dev/null &
+        ls -l $M3/${dir} >/dev/null &
+    done
+    wait
+}
+
+function measure_time() {
+    {
+        LC_ALL=C
+        time -p "${@}"
+    } 2>&1 | awk '/^real/ { print $2 * 1000 }'
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+
+TEST $CLI volume set $V0 disperse.eager-lock on
+TEST $CLI volume set $V0 disperse.other-eager-lock on
+TEST $CLI volume set $V0 features.locks-notify-contention on
+TEST $CLI volume set $V0 disperse.eager-lock-timeout 10
+TEST $CLI volume set $V0 disperse.other-eager-lock-timeout 10
+
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M1
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M2
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M3
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0 $M1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0 $M2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "6" ec_child_up_count $V0 0 $M3
+TEST mkdir $M0/dir
+TEST touch $M0/dir/file.{1..10}
+
+# Run multiple 'ls' concurrently from multiple clients so that they collide and
+# cause partial locks.
+TEST [[ $(measure_time do_ls dir) -lt 10000 ]]
+
+cleanup
diff --git a/tests/bugs/error-gen/bug-767095.t b/tests/bugs/error-gen/bug-767095.t
index 4649a783b23..6cc254f559d 100755
--- a/tests/bugs/error-gen/bug-767095.t
+++ b/tests/bugs/error-gen/bug-767095.t
@@ -9,7 +9,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 function volinfo_field()
 {
diff --git a/tests/bugs/fuse/bug-1126048.c b/tests/bugs/fuse/bug-1126048.c
index 01c3484172d..19165ecf6f7 100644
--- a/tests/bugs/fuse/bug-1126048.c
+++ b/tests/bugs/fuse/bug-1126048.c
@@ -12,30 +12,32 @@
  * fsync should fail without crashing the mount process.
  */
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int ret = 0;
-        int fd = 0;
-        char    *cmd = argv[1];
-        struct stat stbuf = {0, };
+    int ret = 0;
+    int fd = 0;
+    char *cmd = argv[1];
+    struct stat stbuf = {
+        0,
+    };
 
-        printf ("cmd is: %s\n", cmd);
-        fd = open("a.txt", O_CREAT|O_RDWR, 0644);
-        if (fd < 0)
-                printf ("open failed: %s\n", strerror(errno));
+    printf("cmd is: %s\n", cmd);
+    fd = open("a.txt", O_CREAT | O_RDWR, 0644);
+    if (fd < 0)
+        printf("open failed: %s\n", strerror(errno));
 
-        ret = unlink("a.txt");
-        if (ret < 0)
-                printf ("unlink failed: %s\n", strerror(errno));
-        if (write (fd, "abc", 3) < 0)
-                printf ("Not able to print %s\n", strerror (errno));
-        system(cmd);
-        sleep(1); /* No way to confirm graph switch so sleep 1 */
-        ret = fstat (fd, &stbuf);
-        if (ret < 0)
-                printf ("fstat failed %\n", strerror (errno));
-        ret = fsync(fd);
-        if (ret < 0)
-                printf ("Not able to fsync %s\n", strerror (errno));
-        return 0;
+    ret = unlink("a.txt");
+    if (ret < 0)
+        printf("unlink failed: %s\n", strerror(errno));
+    if (write(fd, "abc", 3) < 0)
+        printf("Not able to print %s\n", strerror(errno));
+    system(cmd);
+    sleep(1); /* No way to confirm graph switch so sleep 1 */
+    ret = fstat(fd, &stbuf);
+    if (ret < 0)
+        printf("fstat failed %\n", strerror(errno));
+    ret = fsync(fd);
+    if (ret < 0)
+        printf("Not able to fsync %s\n", strerror(errno));
+    return 0;
 }
diff --git a/tests/bugs/fuse/bug-1309462.t b/tests/bugs/fuse/bug-1309462.t
index f3b74bd2935..975d72d82ed 100644
--- a/tests/bugs/fuse/bug-1309462.t
+++ b/tests/bugs/fuse/bug-1309462.t
@@ -46,4 +46,5 @@ TEST getfattr -n security.capability ${TESTFILE}
 TEST setfattr -x security.capability ${TESTFILE}
 
 TEST umount $M0
-
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=1581735
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=1581735
+\ No newline at end of file
diff --git a/tests/bugs/fuse/bug-858215.t b/tests/bugs/fuse/bug-858215.t
index acfaca9bb4b..95999f6ad24 100755
--- a/tests/bugs/fuse/bug-858215.t
+++ b/tests/bugs/fuse/bug-858215.t
@@ -10,7 +10,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 TEST $CLI volume set $V0 nfs.disable off
 
 function volinfo_field()
@@ -40,9 +40,9 @@ TEST touch $M0/newfile;
 TEST stat $M0/newfile;
 TEST rm $M0/newfile;
 
-nfs_pid=$(cat $GLUSTERD_PIDFILEDIR/nfs/nfs.pid);
-glustershd_pid=$(cat $GLUSTERD_PIDFILEDIR/glustershd/glustershd.pid);
-
+nfs_pid=$(cat $GLUSTERD_PIDFILEDIR/nfs/nfs.pid || echo -1);
+glustershd_pid=`ps auxwww | grep glustershd | grep -v grep | awk -F " " '{print $2}'`
+TEST [ $glustershd_pid != 0 ];
 pids=$(pidof glusterfs);
 for i in $pids
 do
diff --git a/tests/bugs/fuse/bug-924726.t b/tests/bugs/fuse/bug-924726.t
index 65c56aa57b8..2d3c7680798 100755
--- a/tests/bugs/fuse/bug-924726.t
+++ b/tests/bugs/fuse/bug-924726.t
@@ -43,5 +43,3 @@ SOCKETS_AFTER_SWITCH=`netstat -nap | grep $GLFS_MNT_PID | grep ESTABLISHED | wc
 TEST [ $SOCKETS_AFTER_SWITCH = `expr $SOCKETS_BEFORE_SWITCH + 1` ]
 
 cleanup;
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/fuse/bug-985074.t b/tests/bugs/fuse/bug-985074.t
index d10fd9f8b41..ffa6df54144 100644
--- a/tests/bugs/fuse/bug-985074.t
+++ b/tests/bugs/fuse/bug-985074.t
@@ -30,7 +30,7 @@ TEST glusterd
 
 TEST $CLI volume create $V0 $H0:$B0/$V0
 TEST $CLI volume start $V0
-TEST $CLI volume set $V0 md-cache-timeout 3
+TEST $CLI volume set $V0 performance.stat-prefetch off
 
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0 --entry-timeout=0 --attribute-timeout=0
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M1 --entry-timeout=0 --attribute-timeout=0
@@ -40,8 +40,7 @@ TEST ln $M0/file $M0/file.link
 TEST ls -ali $M0 $M1
 TEST rm -f $M1/file.link
 TEST ls -ali $M0 $M1
-# expire the md-cache timeout
-sleep 3
+
 TEST mv $M0/file $M0/file.link
 TEST stat $M0/file.link
 TEST ! stat $M0/file
diff --git a/tests/bugs/fuse/many-groups-for-acl.t b/tests/bugs/fuse/many-groups-for-acl.t
index d959f750ee0..a51b1bc7267 100755
--- a/tests/bugs/fuse/many-groups-for-acl.t
+++ b/tests/bugs/fuse/many-groups-for-acl.t
@@ -38,6 +38,13 @@ do
 done
 TEST useradd -o -M -u ${NEW_UID} -g ${NEW_GID} -G ${NEW_USER}-${NEW_GIDS} ${NEW_USER}
 
+# Linux < 3.8 exports only first 32 gids of pid to userspace
+kernel_exports_few_gids=0
+if [ "$OSTYPE" = Linux ] && \
+   su -m ${NEW_USER} -c "grep ^Groups: /proc/self/status | wc -w | xargs -I@ expr @ - 1 '<' $LAST_GID - $NEW_GID + 1" > /dev/null; then
+       kernel_exports_few_gids=1
+fi
+
 # preparation done, start the tests
 
 TEST glusterd
@@ -48,6 +55,8 @@ TEST $CLI volume set $V0 nfs.disable off
 TEST $CLI volume set ${V0} server.manage-gids off
 TEST $CLI volume start ${V0}
 
+# This is just a synchronization hack to make sure the bricks are
+# up before going on.
 EXPECT_WITHIN ${NFS_EXPORT_TIMEOUT} "1" is_nfs_export_available
 
 # mount the volume with POSIX ACL support, without --resolve-gids
@@ -69,8 +78,8 @@ TEST [ $? -eq 0 ]
 su -m ${NEW_USER} -c "touch ${M0}/first-32-gids-2/success > /dev/null"
 TEST [ $? -eq 0 ]
 
-su -m ${NEW_USER} -c "touch ${M0}/gid-64/failure > /dev/null"
-TEST [ $? -ne 0 ]
+su -m ${NEW_USER} -c "touch ${M0}/gid-64/success--if-all-gids-exported > /dev/null"
+TEST [ $? -eq $kernel_exports_few_gids ]
 
 su -m ${NEW_USER} -c "touch ${M0}/gid-120/failure > /dev/null"
 TEST [ $? -ne 0 ]
diff --git a/tests/bugs/gfapi/bug-1093594.c b/tests/bugs/gfapi/bug-1093594.c
index aff271e4caf..f7a06dd5ba8 100644
--- a/tests/bugs/gfapi/bug-1093594.c
+++ b/tests/bugs/gfapi/bug-1093594.c
@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define WRITE_SIZE (128*1024)
+#define WRITE_SIZE (128 * 1024)
 #define READ_WRITE_LOOP 100
 #define FOP_LOOP_COUNT 20
 #define TEST_CASE_LOOP 20
@@ -14,304 +14,298 @@ int gfapi = 1;
 static int extension = 1;
 
 static int
-large_number_of_fops (glfs_t *fs) {
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *dir1     = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
-        char      *buf      = NULL;
-        struct stat sb      = {0, };
-
-        for (i = 0 ; i < FOP_LOOP_COUNT ; i++) {
-                ret = asprintf (&dir1, "dir%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                 strerror (errno));
-                        return ret;
-                }
-
-                extension++;
-
-                ret = glfs_mkdir (fs, dir1, 0755);
-                if (ret < 0) {
-                        fprintf (stderr, "mkdir(%s): %s\n", dir1, strerror (errno));
-                        return -1;
-                }
-
-                fd = glfs_opendir (fs, dir1);
-                if (!fd) {
-                        fprintf (stderr, "/: %s\n", strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_fsetxattr (fd, "user.dirfattr", "fsetxattr", 8, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret,
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_closedir (fd);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_closedir failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_rmdir (fs, dir1);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = asprintf (&filename1, "file%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                strerror (errno));
-                        return ret;
-                }
-
-                ret = asprintf (&filename2, "file-%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                strerror (errno));
-                        return ret;
-                }
-
-                extension++;
-
-                fd = glfs_creat (fs, filename1, O_RDWR, 0644);
-                if (!fd) {
-                        fprintf (stderr, "%s: (%p) %s\n", filename1, fd,
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_rename (fs, filename1, filename2);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_rename failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_lstat (fs, filename2, &sb);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_lstat failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_close (fd);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_close failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_unlink (fs, filename2);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
+large_number_of_fops(glfs_t *fs)
+{
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
+    char *buf = NULL;
+    struct stat sb = {
+        0,
+    };
+
+    for (i = 0; i < FOP_LOOP_COUNT; i++) {
+        ret = asprintf(&dir1, "dir%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
         }
-}
 
-static int
-large_read_write (glfs_t *fs) {
+        extension++;
 
-        int       ret       = 0;
-        int       j         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *filename = NULL;
-        char      *buf      = NULL;
+        ret = glfs_mkdir(fs, dir1, 0755);
+        if (ret < 0) {
+            fprintf(stderr, "mkdir(%s): %s\n", dir1, strerror(errno));
+            return -1;
+        }
 
-        ret = asprintf (&filename, "filerw%d", extension);
+        fd = glfs_opendir(fs, dir1);
+        if (!fd) {
+            fprintf(stderr, "/: %s\n", strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_fsetxattr(fd, "user.dirfattr", "fsetxattr", 8, 0);
         if (ret < 0) {
-                fprintf (stderr, "cannot construct filename (%s)",
-                         strerror (errno));
-                return ret;
+            fprintf(stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret,
+                    strerror(errno));
+            return -1;
         }
 
-        extension++;
+        ret = glfs_closedir(fd);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_closedir failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
 
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        if (!fd) {
-                fprintf (stderr, "%s: (%p) %s\n", filename, fd,
-                        strerror (errno));
-                return -1;
+        ret = glfs_rmdir(fs, dir1);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        buf = (char *) malloc (WRITE_SIZE);
-        memset (buf, '-', WRITE_SIZE);
+        ret = asprintf(&filename1, "file%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
+        }
 
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_write (fd, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = asprintf(&filename2, "file-%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
         }
 
-        fd1 = glfs_open (fs, filename, O_RDWR);
-        if (fd1 < 0) {
-                fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret,
-                        strerror (errno));
-                return -1;
+        extension++;
+
+        fd = glfs_creat(fs, filename1, O_RDWR, 0644);
+        if (!fd) {
+            fprintf(stderr, "%s: (%p) %s\n", filename1, fd, strerror(errno));
+            return -1;
         }
 
-        glfs_lseek (fd1, 0, SEEK_SET);
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_read (fd1, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = glfs_rename(fs, filename1, filename2);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_rename failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_write (fd1, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = glfs_lstat(fs, filename2, &sb);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_lstat failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        glfs_close (fd);
-        glfs_close (fd1);
-        ret = glfs_unlink (fs, filename);
+        ret = glfs_close(fd);
         if (ret < 0) {
-                fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
+            fprintf(stderr, "glfs_close failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        free (buf);
-        free (filename);
+        ret = glfs_unlink(fs, filename2);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+    }
 }
 
 static int
-volfile_change (const char *volname) {
-        int   ret = 0;
-        char *cmd = NULL, *cmd1 = NULL;
+large_read_write(glfs_t *fs)
+{
+    int ret = 0;
+    int j = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *filename = NULL;
+    char *buf = NULL;
+
+    ret = asprintf(&filename, "filerw%d", extension);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+        return ret;
+    }
 
-        ret = asprintf (&cmd, "gluster volume set %s stat-prefetch off",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+    extension++;
 
-        ret = asprintf (&cmd1, "gluster volume set %s stat-prefetch on",
-                        volname);
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    if (!fd) {
+        fprintf(stderr, "%s: (%p) %s\n", filename, fd, strerror(errno));
+        return -1;
+    }
+
+    buf = (char *)malloc(WRITE_SIZE);
+    memset(buf, '-', WRITE_SIZE);
+
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_write(fd, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
+            fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
 
-        ret = system (cmd);
+    fd1 = glfs_open(fs, filename, O_RDWR);
+    if (fd1 < 0) {
+        fprintf(stderr, "Open(%s): %d (%s)\n", filename, ret, strerror(errno));
+        return -1;
+    }
+
+    glfs_lseek(fd1, 0, SEEK_SET);
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_read(fd1, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "stat-prefetch off on (%s) failed", volname);
-                return ret;
+            fprintf(stderr, "Read(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
 
-        ret = system (cmd1);
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_write(fd1, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "stat-prefetch on on (%s) failed", volname);
-                return ret;
+            fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
+
+    glfs_close(fd);
+    glfs_close(fd1);
+    ret = glfs_unlink(fs, filename);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    free(buf);
+    free(filename);
+}
 
-        free (cmd);
-        free (cmd1);
+static int
+volfile_change(const char *volname)
+{
+    int ret = 0;
+    char *cmd = NULL, *cmd1 = NULL;
+
+    ret = asprintf(&cmd, "gluster volume set %s stat-prefetch off", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
         return ret;
+    }
+
+    ret = asprintf(&cmd1, "gluster volume set %s stat-prefetch on", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
+
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "stat-prefetch off on (%s) failed", volname);
+        return ret;
+    }
+
+    ret = system(cmd1);
+    if (ret < 0) {
+        fprintf(stderr, "stat-prefetch on on (%s) failed", volname);
+        return ret;
+    }
+
+    free(cmd);
+    free(cmd1);
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs       = NULL;
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *topdir   = "topdir", *filename = "file1";
-        char      *buf      = NULL;
-        char      *logfile  = NULL;
-        char      *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                        "Expect following args %s <hostname> <Vol> <log file>\n"
-                        , argv[0]);
-                return -1;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <hostname> <Vol> <log file>\n",
+                argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    logfile = argv[3];
+
+    for (i = 0; i < TEST_CASE_LOOP; i++) {
+        fs = glfs_new(argv[2]);
+        if (!fs) {
+            fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno));
+            return -1;
         }
 
-        hostname = argv[1];
-        logfile = argv[3];
-
-        for (i = 0; i < TEST_CASE_LOOP; i++) {
-                fs = glfs_new (argv[2]);
-                if (!fs) {
-                        fprintf (stderr, "glfs_new: returned NULL (%s)\n",
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n",
-                        ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_set_logging (fs, logfile, 7);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_init (fs);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_init failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = large_number_of_fops (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_read_write (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = volfile_change (argv[2]);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_number_of_fops (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_read_write (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = glfs_fini (fs);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
+        ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_set_logging(fs, logfile, 7);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_init(fs);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = large_number_of_fops(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = large_read_write(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = volfile_change(argv[2]);
+        if (ret < 0)
+            return -1;
+
+        ret = large_number_of_fops(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = large_read_write(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = glfs_fini(fs);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
-        return 0;
+    }
+    return 0;
 }
diff --git a/tests/bugs/gfapi/bug-1319374.c b/tests/bugs/gfapi/bug-1319374.c
index bf2da998d6e..ea0dfb6b0f2 100644
--- a/tests/bugs/gfapi/bug-1319374.c
+++ b/tests/bugs/gfapi/bug-1319374.c
@@ -3,128 +3,129 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define NO_INIT 1
 
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_file, int flag)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_file, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        if (flag == NO_INIT)
-                goto out;
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    if (flag == NO_INIT)
+        goto out;
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
 
 out:
-        return fs;
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret         = 0;
-        glfs_t    *fs1         = NULL;
-        glfs_t    *fs2         = NULL;
-        glfs_t    *fs3         = NULL;
-        char      *volname     = NULL;
-        char      *log_file    = NULL;
-        char      *hostname    = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        log_file = argv[3];
-
-        fs1 = setup_new_client (hostname, volname, log_file, NO_INIT);
-        if (!fs1) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fs2 = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs2) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fs3 = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs3) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_fini (fs3);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets
-         * triggered when 30s timer expires, hence the sleep of 31s
-         */
-        sleep (31);
-        ret = glfs_fini (fs2);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs1);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_fini (fs1);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs1 = NULL;
+    glfs_t *fs2 = NULL;
+    glfs_t *fs3 = NULL;
+    char *volname = NULL;
+    char *log_file = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
         return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    log_file = argv[3];
+
+    fs1 = setup_new_client(hostname, volname, log_file, NO_INIT);
+    if (!fs1) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fs2 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs2) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fs3 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs3) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_fini(fs3);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets
+     * triggered when 30s timer expires, hence the sleep of 31s
+     */
+    sleep(31);
+    ret = glfs_fini(fs2);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs1);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_fini(fs1);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/gfapi/bug-1447266/1460514.c b/tests/bugs/gfapi/bug-1447266/1460514.c
index f04d2d1463f..c721559a668 100644
--- a/tests/bugs/gfapi/bug-1447266/1460514.c
+++ b/tests/bugs/gfapi/bug-1447266/1460514.c
@@ -9,135 +9,142 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret            = 0;
-        glfs_t                  *fs            = NULL;
-        struct glfs_object      *root = NULL, *dir = NULL, *subdir = NULL;
-        struct stat             sb             = {0, };
-        char                    *dirname       = "dir";
-        char                    *subdirname    = "subdir";
-        char                    *logfile       = NULL;
-        char                    *volname       = NULL;
-        char                    *hostname      = NULL;
-        unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'};
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("first attempt glfs_init", ret);
-
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        dir = glfs_h_mkdir (fs, root, dirname, 0644, &sb);
-        if (dir == NULL) {
-                 fprintf (stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        subdir = glfs_h_mkdir (fs, root, subdirname, 0644, &sb);
-        if (subdir == NULL) {
-                 fprintf (stderr, "glfs_h_mkdir: error on directory creation subdir ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        ret = glfs_h_extract_handle (subdir, subdir_handle,
-                                             GFAPI_HANDLE_LENGTH);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n",
-                         subdirname, strerror (errno));
-                goto out;
-        }
-
-        glfs_h_close (subdir);
-        subdir = NULL;
-        glfs_h_close (dir);
-        dir = NULL;
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("second attempt glfs_init", ret);
-
-        subdir = glfs_h_create_from_handle (fs, subdir_handle, GFAPI_HANDLE_LENGTH,
-                                          &sb);
-        if (subdir == NULL) {
-                fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
-                         subdirname, subdir_handle, strerror (errno));
-                goto out;
-        }
-        dir = glfs_h_lookupat (fs, subdir, "..", &sb, 0);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_object *root = NULL, *dir = NULL, *subdir = NULL;
+    struct stat sb = {
+        0,
+    };
+    char *dirname = "dir";
+    char *subdirname = "subdir";
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'};
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("first attempt glfs_init", ret);
+
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    dir = glfs_h_mkdir(fs, root, dirname, 0644, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    subdir = glfs_h_mkdir(fs, root, subdirname, 0644, &sb);
+    if (subdir == NULL) {
+        fprintf(stderr,
+                "glfs_h_mkdir: error on directory creation subdir ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    ret = glfs_h_extract_handle(subdir, subdir_handle, GFAPI_HANDLE_LENGTH);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+                subdirname, strerror(errno));
+        goto out;
+    }
+
+    glfs_h_close(subdir);
+    subdir = NULL;
+    glfs_h_close(dir);
+    dir = NULL;
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("second attempt glfs_init", ret);
+
+    subdir = glfs_h_create_from_handle(fs, subdir_handle, GFAPI_HANDLE_LENGTH,
+                                       &sb);
+    if (subdir == NULL) {
+        fprintf(
+            stderr,
+            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+            subdirname, subdir_handle, strerror(errno));
+        goto out;
+    }
+    dir = glfs_h_lookupat(fs, subdir, "..", &sb, 0);
+    if (dir == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n",
+                strerror(errno));
+        goto out;
+    }
 
 out:
-        if (subdir)
-                glfs_h_close (subdir);
-        if (dir)
-                glfs_h_close (dir);
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (subdir)
+        glfs_h_close(subdir);
+    if (dir)
+        glfs_h_close(dir);
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/bugs/gfapi/bug-1447266/bug-1447266.c b/tests/bugs/gfapi/bug-1447266/bug-1447266.c
index e4b3c888a57..2b7e2d627fe 100644
--- a/tests/bugs/gfapi/bug-1447266/bug-1447266.c
+++ b/tests/bugs/gfapi/bug-1447266/bug-1447266.c
@@ -4,102 +4,104 @@
 #include <string.h>
 #include <stdlib.h>
 #define TOTAL_ARGS 4
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        char *cwd = (char *)malloc(PATH_MAX*sizeof(char *));
-        char *resolved = NULL;
-        char *result = NULL;
-        char *buf = NULL;
-        struct stat st;
-        char *path = NULL;
-        int ret;
-
-        if (argc != TOTAL_ARGS) {
-                printf ("Please give all required command line args.\n"
-                         "Format : <volname> <server_ip> <path_name>\n");
-                goto out;
-        }
-
-        glfs_t *fs = glfs_new (argv[1]);
-
-        if (fs == NULL) {
-                printf ("glfs_new: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
-        if (ret) {
-                printf ("glfs_set_volfile_server: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        path = argv[3];
-
-        ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7);
-        if (ret) {
-                printf ("glfs_set_logging: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        ret = glfs_init(fs);
-        if (ret) {
-                printf ("glfs_init: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        sleep(1);
-
-        ret = glfs_chdir(fs, path);
-        if (ret) {
-                printf ("glfs_chdir: %s\n", strerror(errno));
-                goto out;
-        }
-
-        buf = glfs_getcwd(fs, cwd, PATH_MAX);
-        if (cwd == NULL) {
-                printf ("glfs_getcwd: %s\n", strerror(errno));
-                goto out;
-        }
-
-        printf ("\ncwd = %s\n\n", cwd);
-
-        result = glfs_realpath(fs, path, resolved);
-        if (result == NULL) {
-                printf ("glfs_realpath: %s\n", strerror(errno));
-                goto out;
-        }
-
-        ret = glfs_stat(fs, path, &st);
-        if (ret) {
-                printf ("glfs_stat: %s\n", strerror(errno));
-                goto out;
-        }
-        if (cwd)
-                free(cwd);
-
-        result = glfs_realpath(fs, path, resolved);
-        if (result == NULL) {
-                printf ("glfs_realpath: %s\n", strerror(errno));
-                goto out;
-        }
-
-        ret = glfs_fini(fs);
-        if (ret) {
-                printf ("glfs_fini: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        printf ("\n");
+    char *cwd = (char *)malloc(PATH_MAX * sizeof(char *));
+    char *resolved = NULL;
+    char *result = NULL;
+    char *buf = NULL;
+    struct stat st;
+    char *path = NULL;
+    int ret;
+
+    if (argc != TOTAL_ARGS) {
+        printf(
+            "Please give all required command line args.\n"
+            "Format : <volname> <server_ip> <path_name>\n");
+        goto out;
+    }
+
+    glfs_t *fs = glfs_new(argv[1]);
+
+    if (fs == NULL) {
+        printf("glfs_new: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
+    if (ret) {
+        printf("glfs_set_volfile_server: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    path = argv[3];
+
+    ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7);
+    if (ret) {
+        printf("glfs_set_logging: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret) {
+        printf("glfs_init: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    sleep(1);
+
+    ret = glfs_chdir(fs, path);
+    if (ret) {
+        printf("glfs_chdir: %s\n", strerror(errno));
+        goto out;
+    }
+
+    buf = glfs_getcwd(fs, cwd, PATH_MAX);
+    if (cwd == NULL) {
+        printf("glfs_getcwd: %s\n", strerror(errno));
+        goto out;
+    }
+
+    printf("\ncwd = %s\n\n", cwd);
+
+    result = glfs_realpath(fs, path, resolved);
+    if (result == NULL) {
+        printf("glfs_realpath: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_stat(fs, path, &st);
+    if (ret) {
+        printf("glfs_stat: %s\n", strerror(errno));
+        goto out;
+    }
+    if (cwd)
+        free(cwd);
+
+    result = glfs_realpath(fs, path, resolved);
+    if (result == NULL) {
+        printf("glfs_realpath: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_fini(fs);
+    if (ret) {
+        printf("glfs_fini: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    printf("\n");
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/gfapi/bug-1447266/bug-1447266.t b/tests/bugs/gfapi/bug-1447266/bug-1447266.t
index 2bf72f8c6d7..45547f4f0e7 100644
--- a/tests/bugs/gfapi/bug-1447266/bug-1447266.t
+++ b/tests/bugs/gfapi/bug-1447266/bug-1447266.t
@@ -56,5 +56,5 @@ TEST ! $(dirname $0)/bug-1447266 $V0 $H0 "/.snaps/.././snap3"
 TEST $(dirname $0)/bug-1447266 $V0 $H0 "/.snaps/../."
 TEST $(dirname $0)/bug-1447266 $V0 $H0 "/.snaps/./snap1/./../snap1/dir/."
 
-cleanup_tester $(dirname $0)/bug-1319374
+cleanup_tester $(dirname $0)/bug-1447266
 cleanup;
diff --git a/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.c b/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.c
new file mode 100644
index 00000000000..d151784627c
--- /dev/null
+++ b/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.c
@@ -0,0 +1,112 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+int
+main(int argc, char *argv[])
+{
+    int ret = -1;
+    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+    int do_write = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *dirname = "/some_dir1";
+    const char *filename = "/some_dir1/testfile";
+    const char *short_filename = "testfile";
+    struct stat sb;
+    char buf[512];
+    struct dirent *entry = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        fprintf(stderr, "Usage: %s <volname> <logfile> <do-write [0/1]\n",
+                argv[0]);
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+    do_write = atoi(argv[3]);
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    ret = glfs_mkdir(fs, dirname, 0755);
+    if (ret && errno != EEXIST)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_mkdir", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    if (do_write) {
+        ret = glfs_write(fd1, "hello world", 11, flags);
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+    }
+
+    fd2 = glfs_opendir(fs, dirname);
+    if (fd2 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", ret, out);
+    }
+
+    do {
+        ret = glfs_readdirplus_r(fd2, &sb, (struct dirent *)buf, &entry);
+        if (entry != NULL) {
+            if (!strcmp(entry->d_name, short_filename)) {
+                if (sb.st_mode == 0) {
+                    fprintf(
+                        stderr,
+                        "Mode bits are incorrect: d_name - %s, st_mode - %jd\n",
+                        entry->d_name, (intmax_t)sb.st_mode);
+                    ret = -1;
+                    goto out;
+                }
+            }
+        }
+    } while (entry != NULL);
+
+out:
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fd2 != NULL)
+        glfs_closedir(fd2);
+
+    if (fs) {
+        /*
+         * If this fails (as it does on Special Snowflake NetBSD for no
+         * good reason), it shouldn't affect the result of the test.
+         */
+        (void)glfs_fini(fs);
+    }
+
+    return ret;
+}
diff --git a/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.t b/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.t
new file mode 100644
index 00000000000..ac59aeeb47b
--- /dev/null
+++ b/tests/bugs/gfapi/bug-1630804/gfapi-bz1630804.t
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+. $(dirname $0)/../../../include.rc
+. $(dirname $0)/../../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 ${H0}:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+build_tester $(dirname $0)/gfapi-bz1630804.c -lgfapi
+
+TEST ./$(dirname $0)/gfapi-bz1630804 $V0 $logdir/gfapi-bz1630804.log 0
+TEST ./$(dirname $0)/gfapi-bz1630804 $V0 $logdir/gfapi-bz1630804.log 1
+
+cleanup_tester $(dirname $0)/gfapi-trunc
+
+cleanup;
diff --git a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
index 68011171744..f38f01144d3 100644
--- a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
+++ b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
@@ -10,156 +10,154 @@
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_fileile)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_fileile, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-        return fs;
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-write_something (glfs_t *fs)
+write_something(glfs_t *fs)
 {
-        glfs_fd_t *fd       = NULL;
-        char      *buf      = NULL;
-        int       ret       = 0;
-        int       j         = 0;
-
-        fd = glfs_creat (fs, "filename", O_RDWR, 0644);
-        if (!fd) {
-                fprintf (stderr, "%s: (%p) %s\n", "filename", fd,
-                        strerror (errno));
-                return -1;
-        }
+    glfs_fd_t *fd = NULL;
+    char *buf = NULL;
+    int ret = 0;
+    int j = 0;
+
+    fd = glfs_creat(fs, "filename", O_RDWR, 0644);
+    if (!fd) {
+        fprintf(stderr, "%s: (%p) %s\n", "filename", fd, strerror(errno));
+        return -1;
+    }
+
+    buf = (char *)malloc(WRITE_SIZE);
+    memset(buf, '-', WRITE_SIZE);
 
-        buf = (char *) malloc (WRITE_SIZE);
-        memset (buf, '-', WRITE_SIZE);
-
-        for (j = 0; j < 4; j++) {
-                ret = glfs_write (fd, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", "filename", ret,
-                                strerror (errno));
-                        return ret;
-                }
-                glfs_lseek (fd, 0, SEEK_SET);
+    for (j = 0; j < 4; j++) {
+        ret = glfs_write(fd, buf, WRITE_SIZE, 0);
+        if (ret < 0) {
+            fprintf(stderr, "Write(%s): %d (%s)\n", "filename", ret,
+                    strerror(errno));
+            return ret;
         }
-        return 0;
+        glfs_lseek(fd, 0, SEEK_SET);
+    }
+    return 0;
 }
 
 static int
-volfile_change (const char *volname) {
-        int   ret = 0;
-        char *cmd = NULL, *cmd1 = NULL;
-
-        ret = asprintf (&cmd, "gluster volume set %s quick-read on",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+volfile_change(const char *volname)
+{
+    int ret = 0;
+    char *cmd = NULL, *cmd1 = NULL;
 
-        ret = asprintf (&cmd1, "gluster volume set %s quick-read off",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+    ret = asprintf(&cmd, "gluster volume set %s quick-read on", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read off on (%s) failed", volname);
-                return ret;
-        }
+    ret = asprintf(&cmd1, "gluster volume set %s quick-read off", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
 
-        ret = system (cmd1);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read on on (%s) failed", volname);
-                return ret;
-        }
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read off on (%s) failed", volname);
+        return ret;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read off on (%s) failed", volname);
-                return ret;
-        }
+    ret = system(cmd1);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read on on (%s) failed", volname);
+        return ret;
+    }
 
-        free (cmd);
-        free (cmd1);
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read off on (%s) failed", volname);
         return ret;
+    }
+
+    free(cmd);
+    free(cmd1);
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret      = 0;
-        glfs_t    *fs       = NULL;
-	char       buf[100];
-        glfs_fd_t *fd       = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        fs = setup_new_client (argv[1], argv[2], argv[3]);
-	if (!fs)
-		goto error;
-
-        ret = volfile_change (argv[2]);
-        if (ret < 0)
-                goto error;
-
-        /* This is required as volfile change takes a while to reach this
-         * gfapi client and precess the graph change. Without this the issue
-         * cannot be reproduced as in cannot be tested.
-         */
-        sleep (10);
-
-	ret = write_something (fs);
-        if (ret < 0)
-                goto error;
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs = NULL;
+    char buf[100];
+    glfs_fd_t *fd = NULL;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
         return -1;
+    }
+
+    fs = setup_new_client(argv[1], argv[2], argv[3]);
+    if (!fs)
+        goto error;
+
+    ret = volfile_change(argv[2]);
+    if (ret < 0)
+        goto error;
+
+    /* This is required as volfile change takes a while to reach this
+     * gfapi client and precess the graph change. Without this the issue
+     * cannot be reproduced as in cannot be tested.
+     */
+    sleep(10);
+
+    ret = write_something(fs);
+    if (ret < 0)
+        goto error;
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/glusterd/859927/repl.t b/tests/bugs/glusterd/859927/repl.t
index 70143e2c193..6e7c23b5b1d 100755
--- a/tests/bugs/glusterd/859927/repl.t
+++ b/tests/bugs/glusterd/859927/repl.t
@@ -23,6 +23,9 @@ TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2};
 TEST $CLI volume set $V0 cluster.self-heal-daemon off
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 client-log-level DEBUG
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume start $V0
 TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0;
 
diff --git a/tests/bugs/glusterd/add-brick-and-validate-replicated-volume-options.t b/tests/bugs/glusterd/add-brick-and-validate-replicated-volume-options.t
new file mode 100644
index 00000000000..95d0eb69ac1
--- /dev/null
+++ b/tests/bugs/glusterd/add-brick-and-validate-replicated-volume-options.t
@@ -0,0 +1,110 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2};
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field $V0 'Status';
+
+#bug-1102656 - validating volume top command
+
+TEST $CLI volume top $V0 open
+TEST ! $CLI volume top $V0 open brick $H0:/tmp/brick
+TEST $CLI volume top $V0 read
+
+TEST $CLI volume status
+
+#bug- 1002556
+EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
+
+TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}3
+EXPECT '1 x 3 = 3' volinfo_field $V0 'Number of Bricks';
+
+TEST $CLI volume remove-brick $V0 replica 2 $H0:$B0/${V0}3 force
+EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
+
+TEST killall glusterd
+TEST glusterd
+
+EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
+
+#bug-1406411- fail-add-brick-when-replica-count-changes
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+#add-brick should fail
+TEST ! $CLI_NO_FORCE volume add-brick $V0 replica 3 $H0:$B0/${V0}3
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}3
+
+TEST $CLI volume create $V1 $H0:$B0/${V1}{1,2};
+TEST $CLI volume start $V1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}2
+TEST kill_brick $V1 $H0 $B0/${V1}1
+
+#add-brick should fail
+TEST ! $CLI_NO_FORCE volume add-brick $V1 replica 2 $H0:$B0/${V1}{3,4}
+
+TEST $CLI volume start $V1 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}2
+
+TEST $CLI volume add-brick $V1 replica 2 $H0:$B0/${V1}{3,4}
+
+#bug-905307 - validate cluster.post-op-delay-secs option
+
+#Strings should not be accepted.
+TEST ! $CLI volume set $V0 cluster.post-op-delay-secs abc
+
+#-ve ints should not be accepted.
+TEST ! $CLI volume set $V0 cluster.post-op-delay-secs -1
+
+#INT_MAX+1 should not be accepted.
+TEST ! $CLI volume set $V0 cluster.post-op-delay-secs 2147483648
+
+#floats should not be accepted.
+TEST ! $CLI volume set $V0 cluster.post-op-delay-secs 1.25
+
+#min val 0 should be accepted
+TEST $CLI volume set $V0 cluster.post-op-delay-secs 0
+EXPECT "0" volume_option $V0 cluster.post-op-delay-secs
+
+#max val 2147483647 should be accepted
+TEST $CLI volume set $V0 cluster.post-op-delay-secs 2147483647
+EXPECT "2147483647" volume_option $V0 cluster.post-op-delay-secs
+
+#some middle val in range 2147 should be accepted
+TEST $CLI volume set $V0 cluster.post-op-delay-secs 2147
+EXPECT "2147" volume_option $V0 cluster.post-op-delay-secs
+
+#bug-1265479 - validate-replica-volume-options
+
+#Setting data-self-heal option on for distribute-replicate volume
+TEST $CLI volume set $V1 data-self-heal on
+EXPECT 'on' volinfo_field $V1 'cluster.data-self-heal';
+TEST $CLI volume set $V1 cluster.data-self-heal on
+EXPECT 'on' volinfo_field $V1 'cluster.data-self-heal';
+
+#Setting metadata-self-heal option on for distribute-replicate volume
+TEST $CLI volume set $V1 metadata-self-heal on
+EXPECT 'on' volinfo_field $V1 'cluster.metadata-self-heal';
+TEST $CLI volume set $V1 cluster.metadata-self-heal on
+
+#Setting entry-self-heal option on for distribute-replicate volume
+TEST $CLI volume set $V1 entry-self-heal on
+EXPECT 'on' volinfo_field $V1 'cluster.entry-self-heal';
+TEST $CLI volume set $V1 cluster.entry-self-heal on
+EXPECT 'on' volinfo_field $V1 'cluster.entry-self-heal';
+
+cleanup
diff --git a/tests/bugs/glusterd/brick-mux-validation-in-cluster.t b/tests/bugs/glusterd/brick-mux-validation-in-cluster.t
new file mode 100644
index 00000000000..b6af487a791
--- /dev/null
+++ b/tests/bugs/glusterd/brick-mux-validation-in-cluster.t
@@ -0,0 +1,108 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+function count_brick_pids {
+        $CLI_1 --xml volume status all | sed -n '/.*<pid>\([^<]*\).*/s//\1/p' \
+                                     | grep -v "N/A" | sort | uniq | wc -l
+}
+
+function count_N/A_brick_pids {
+        $CLI_1 --xml volume status all | sed -n '/.*<pid>\([^<]*\).*/s//\1/p' \
+                                     | grep -- '\-1' | sort | uniq | wc -l
+}
+
+function check_peers {
+        $CLI_2 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup;
+
+TEST launch_cluster 3
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+TEST $CLI_1 volume set all cluster.brick-multiplex on
+#bug-1609163 - bricks of normal volume should not attach to bricks of gluster_shared_storage volume
+
+##Create, start and mount meta_volume i.e., shared_storage
+TEST $CLI_1 volume create $META_VOL replica 3 $H1:$B1/${META_VOL}1 $H2:$B2/${META_VOL}1 $H3:$B3/${META_VOL}1
+TEST $CLI_1 volume start $META_VOL
+TEST mkdir -p $META_MNT
+TEST glusterfs -s $H1 --volfile-id $META_VOL $META_MNT
+
+TEST $CLI_1 volume info gluster_shared_storage
+
+EXPECT 3 count_brick_processes
+
+#create and start a new volume
+TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/${V0}{1..3} $H2:$B2/${V0}{1..3}
+TEST $CLI_1 volume start $V0
+
+# bricks of normal volume should not attach to bricks of gluster_shared_storage volume
+EXPECT 5 count_brick_processes
+
+#bug-1549996 - stale brick processes on the nodes after volume deletion
+
+TEST $CLI_1 volume create $V1 replica 3 $H1:$B1/${V1}{1..3} $H2:$B2/${V1}{1..3}
+TEST $CLI_1 volume start $V1
+
+EXPECT 5 count_brick_processes
+
+TEST $CLI_1 volume stop $V0
+TEST $CLI_1 volume stop $V1
+
+EXPECT 3 count_brick_processes
+
+TEST $CLI_1 volume stop $META_VOL
+
+TEST $CLI_1 volume delete $META_VOL
+TEST $CLI_1 volume delete $V0
+TEST $CLI_1 volume delete $V1
+
+#bug-1773856 - Brick process fails to come up with brickmux on
+
+TEST $CLI_1 volume create $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}1 $H3:$B3/${V0}1 force
+TEST $CLI_1 volume start $V0
+
+
+EXPECT 3 count_brick_processes
+
+#create and start a new volume
+TEST $CLI_1 volume create $V1 $H1:$B1/${V1}2 $H2:$B2/${V1}2 $H3:$B3/${V1}2 force
+TEST $CLI_1 volume start $V1
+
+EXPECT 3 count_brick_processes
+
+V2=patchy2
+TEST $CLI_1 volume create $V2 $H1:$B1/${V2}3 $H2:$B2/${V2}3 $H3:$B3/${V2}3 force
+TEST $CLI_1 volume start $V2
+
+EXPECT 3 count_brick_processes
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_brick_pids
+
+TEST kill_node 1
+
+sleep 10
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers;
+
+$CLI_2 volume set $V0 performance.readdir-ahead on
+$CLI_2 volume set $V1 performance.readdir-ahead on
+
+TEST $glusterd_1;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_brick_pids
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0  count_N/A_brick_pids
+
+cleanup;
diff --git a/tests/bugs/glusterd/brick-mux-validation.t b/tests/bugs/glusterd/brick-mux-validation.t
new file mode 100644
index 00000000000..61b0455f9a8
--- /dev/null
+++ b/tests/bugs/glusterd/brick-mux-validation.t
@@ -0,0 +1,104 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../traps.rc
+. $(dirname $0)/../../volume.rc
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+function count_brick_pids {
+        $CLI --xml volume status all | sed -n '/.*<pid>\([^<]*\).*/s//\1/p' \
+                                     | grep -v "N/A" | sort | uniq | wc -l
+}
+
+cleanup;
+
+#bug-1451248 - validate brick mux after glusterd reboot
+
+TEST glusterd
+TEST $CLI volume set all cluster.brick-multiplex on
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..3}
+TEST $CLI volume start $V0
+
+EXPECT 1 count_brick_processes
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 online_brick_count
+
+pkill gluster
+TEST glusterd
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 online_brick_count
+
+TEST $CLI volume create $V1 $H0:$B0/${V1}{1..3}
+TEST $CLI volume start $V1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 online_brick_count
+
+#bug-1560957 - brick status goes offline after remove-brick followed by add-brick
+
+pkill glusterd
+TEST glusterd
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 force
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}1_new force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 online_brick_count
+
+#bug-1446172 - reset brick with brick multiplexing enabled
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+# Create files
+for i in {1..5}
+do
+        echo $i > $M0/file$i.txt
+done
+
+TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}1_new start
+
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 5 online_brick_count
+EXPECT 1 count_brick_processes
+
+# Negative case with brick killed but volume-id xattr present
+TEST ! $CLI volume reset-brick $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}1 commit
+
+# reset-brick commit force should work and should bring up the brick
+TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}1_new $H0:$B0/${V0}1_new commit force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 online_brick_count
+EXPECT 1 count_brick_processes
+TEST glusterfs --volfile-id=$V1 --volfile-server=$H0 $M1;
+# Create files
+for i in {1..5}
+do
+        echo $i > $M1/file$i.txt
+done
+
+TEST $CLI volume reset-brick $V1 $H0:$B0/${V1}1 start
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 5 online_brick_count
+EXPECT 1 count_brick_processes
+
+# Simulate reset disk
+for i in {1..5}
+do
+        rm -rf $B0/${V1}1/file$i.txt
+done
+
+setfattr -x trusted.glusterfs.volume-id $B0/${V1}1
+setfattr -x trusted.gfid $B0/${V1}1
+
+# Test reset-brick commit. Using CLI_IGNORE_PARTITION since normal CLI  uses
+# the --wignore flag that essentially makes the command act like "commit force"
+TEST $CLI_IGNORE_PARTITION volume reset-brick $V1 $H0:$B0/${V1}1 $H0:$B0/${V1}1 commit
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 online_brick_count
+EXPECT 1 count_brick_processes
+
+cleanup;
diff --git a/tests/bugs/glusterd/brick-mux.t b/tests/bugs/glusterd/brick-mux.t
new file mode 100644
index 00000000000..927940534c1
--- /dev/null
+++ b/tests/bugs/glusterd/brick-mux.t
@@ -0,0 +1,81 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+cleanup
+
+#bug-1444596 - validating brick mux
+
+TEST glusterd -LDEBUG
+TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
+TEST $CLI volume create $V1 $H0:$B0/brick{2,3}
+
+TEST $CLI volume set all cluster.brick-multiplex on
+
+TEST $CLI volume start $V0
+TEST $CLI volume start $V1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+EXPECT 1 count_brick_processes
+
+#bug-1499509 - stop all the bricks when a brick process is killed
+kill -9 $(pgrep glusterfsd)
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 online_brick_count
+
+TEST $CLI volume start $V0 force
+TEST $CLI volume start $V1 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+
+
+pkill glusterd
+TEST glusterd
+
+#Check brick status after restart glusterd
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+EXPECT 1 count_brick_processes
+
+TEST $CLI volume set $V1 performance.io-cache-size 32MB
+TEST $CLI volume stop $V1
+TEST $CLI volume start $V1
+
+#Check No. of brick processes after change option
+EXPECT 2 count_brick_processes
+
+pkill glusterd
+TEST glusterd
+
+#Check brick status after restart glusterd should not be NA
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+EXPECT 2 count_brick_processes
+
+pkill glusterd
+TEST glusterd
+
+#Check brick status after restart glusterd should not be NA
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 online_brick_count
+EXPECT 2 count_brick_processes
+
+#bug-1444596_brick_mux_posix_hlth_chk_status
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+TEST rm -rf $H0:$B0/brick{0,1}
+
+#Check No. of brick processes after remove brick from back-end
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 online_brick_count
+
+TEST glusterfs -s $H0 --volfile-id $V1 $M0
+TEST touch $M0/file{1..10}
+
+pkill glusterd
+TEST glusterd -LDEBUG
+sleep 5
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 online_brick_count
+
+cleanup
+
diff --git a/tests/bugs/glusterd/brick-order-check-add-brick.t b/tests/bugs/glusterd/brick-order-check-add-brick.t
new file mode 100644
index 00000000000..0be31dac768
--- /dev/null
+++ b/tests/bugs/glusterd/brick-order-check-add-brick.t
@@ -0,0 +1,61 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup;
+
+TEST verify_lvm_version;
+#Create cluster with 3 nodes
+TEST launch_cluster 3 -NO_DEBUG -NO_FORCE
+TEST setup_lvm 3
+
+TEST $CLI_1 peer probe $H2
+TEST $CLI_1 peer probe $H3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+TEST $CLI_1 volume create $V0 replica 3 $H1:$L1/$V0 $H2:$L2/$V0 $H3:$L3/$V0
+EXPECT '1 x 3 = 3' volinfo_field $V0 'Number of Bricks'
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+#add-brick with or without mentioning the replica count should not fail
+TEST $CLI_1 volume add-brick $V0 replica 3 $H1:$L1/${V0}_1 $H2:$L2/${V0}_1 $H3:$L3/${V0}_1
+EXPECT '2 x 3 = 6' volinfo_field $V0 'Number of Bricks'
+
+TEST $CLI_1 volume add-brick $V0 $H1:$L1/${V0}_2 $H2:$L2/${V0}_2 $H3:$L3/${V0}_2
+EXPECT '3 x 3 = 9' volinfo_field $V0 'Number of Bricks'
+
+#adding bricks from same host should fail the brick order check
+TEST ! $CLI_1 volume add-brick $V0 $H1:$L1/${V0}_3 $H1:$L1/${V0}_4 $H1:$L1/${V0}_5
+EXPECT '3 x 3 = 9' volinfo_field $V0 'Number of Bricks'
+
+#adding bricks from same host with force should succeed
+TEST $CLI_1 volume add-brick $V0 $H1:$L1/${V0}_3 $H1:$L1/${V0}_4 $H1:$L1/${V0}_5 force
+EXPECT '4 x 3 = 12' volinfo_field $V0 'Number of Bricks'
+
+TEST $CLI_1 volume stop $V0
+TEST $CLI_1 volume delete $V0
+
+TEST $CLI_1 volume create $V0 replica 2 $H1:$L1/${V0}1 $H2:$L2/${V0}1
+EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks'
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+#Add-brick with Increasing replica count
+TEST $CLI_1 volume add-brick $V0 replica 3 $H3:$L3/${V0}1
+EXPECT '1 x 3 = 3' volinfo_field $V0 'Number of Bricks'
+
+#Add-brick with Increasing replica count from same host should fail
+TEST ! $CLI_1 volume add-brick $V0 replica 5 $H1:$L1/${V0}2 $H1:$L1/${V0}3
+
+#adding multiple bricks from same host should fail the brick order check
+TEST ! $CLI_1 volume add-brick $V0 replica 3 $H1:$L1/${V0}{4..6} $H2:$L2/${V0}{7..9}
+EXPECT '1 x 3 = 3' volinfo_field $V0 'Number of Bricks'
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-000000.t b/tests/bugs/glusterd/bug-000000.t
deleted file mode 100755
index 55f7b11f598..00000000000
--- a/tests/bugs/glusterd/bug-000000.t
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1002556.t b/tests/bugs/glusterd/bug-1002556.t
deleted file mode 100755
index ac71d06d533..00000000000
--- a/tests/bugs/glusterd/bug-1002556.t
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
-TEST $CLI volume start $V0
-EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
-
-TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}2
-EXPECT '1 x 3 = 3' volinfo_field $V0 'Number of Bricks';
-
-TEST $CLI volume remove-brick $V0 replica 2 $H0:$B0/${V0}1 force
-EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
-
-TEST killall glusterd
-TEST glusterd
-
-EXPECT '1 x 2 = 2' volinfo_field $V0 'Number of Bricks';
-cleanup
diff --git a/tests/bugs/glusterd/bug-1004744.t b/tests/bugs/glusterd/bug-1004744.t
deleted file mode 100644
index 66a827daa74..00000000000
--- a/tests/bugs/glusterd/bug-1004744.t
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-#Test case: After a rebalance fix-layout, check if the rebalance status command
-#displays the appropriate message at the CLI.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-#Create a 2x1 distributed volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-
-# Mount FUSE and create file/directory
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-for i in `seq 1 10`;
-do
-       mkdir $M0/dir_$i
-       echo file>$M0/dir_$i/file_$i
-       for j in `seq 1 100`;
-       do
-                mkdir $M0/dir_$i/dir_$j
-                echo file>$M0/dir_$i/dir_$j/file_$j
-       done
-done
-
-#add 2 bricks
-TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{3,4};
-
-#perform rebalance fix-layout
-TEST $CLI volume rebalance $V0 fix-layout start
-
-EXPECT_WITHIN $REBALANCE_TIMEOUT "fix-layout completed" fix-layout_status_field $V0;
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1022055.t b/tests/bugs/glusterd/bug-1022055.t
deleted file mode 100755
index 9f39c80b6b6..00000000000
--- a/tests/bugs/glusterd/bug-1022055.t
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-cleanup;
-
-TEST launch_cluster 2;
-
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers;
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0;
-
-TEST $CLI_1 volume start $V0;
-
-TEST $CLI_1 volume log rotate $V0;
-
-TEST $CLI_1 volume status;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1027171.t b/tests/bugs/glusterd/bug-1027171.t
deleted file mode 100644
index 1b457d8f660..00000000000
--- a/tests/bugs/glusterd/bug-1027171.t
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/bin/bash
-
-#Test case: Do not allow commit if the bricks are not decommissioned
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-#Create a Distributed volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1..2};
-TEST $CLI volume start $V0
-
-#Remove bricks and commit without starting
-function remove_brick_commit_status {
-        $CLI volume remove-brick $V0 \
-        $H0:$B0/${V0}2 commit 2>&1 |grep -oE "success|decommissioned"
-}
-EXPECT "decommissioned"  remove_brick_commit_status;
-
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0
-TEST ! $CLI volume info $V0
-
-#Create a Distributed-Replicate volume
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1..4};
-TEST $CLI volume start $V0
-
-#Try to reduce replica count with start option
-function remove_brick_start_status {
-        $CLI volume remove-brick $V0 replica 1 \
-        $H0:$B0/${V0}1  $H0:$B0/${V0}3 start 2>&1 |grep -oE "success|failed"
-}
-EXPECT "failed"  remove_brick_start_status;
-
-#Remove bricks with commit option
-function remove_brick_commit_status2 {
-        $CLI volume remove-brick $V0 replica 1 \
-        $H0:$B0/${V0}1  $H0:$B0/${V0}3 commit 2>&1  |
-        grep -oE "success|decommissioned"
-}
-EXPECT "decommissioned"  remove_brick_commit_status2;
-
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0
-TEST ! $CLI volume info $V0
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1040408.t b/tests/bugs/glusterd/bug-1040408.t
deleted file mode 100644
index c378000630b..00000000000
--- a/tests/bugs/glusterd/bug-1040408.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-#Test case: Create a distributed replicate volume, and reduce
-#replica count
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-#Create a 2X3 distributed-replicate volume
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1..6};
-TEST $CLI volume start $V0
-
-# Reduce to 2x2 volume by specifying bricks in reverse order
-function remove_brick_status {
-        $CLI volume remove-brick $V0 replica 2 \
-        $H0:$B0/${V0}6  $H0:$B0/${V0}3 force 2>&1 |grep -oE "success|failed"
-}
-EXPECT "success"  remove_brick_status;
-
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1046308.t b/tests/bugs/glusterd/bug-1046308.t
deleted file mode 100644
index 9c827c4a492..00000000000
--- a/tests/bugs/glusterd/bug-1046308.t
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-volname="StartMigrationDuringRebalanceTest"
-TEST glusterd
-TEST pidof glusterd;
-
-TEST $CLI volume info;
-TEST $CLI volume create $volname $H0:$B0/${volname}{1,2};
-TEST $CLI volume start $volname;
-TEST $CLI volume rebalance $volname start;
-
-cleanup;
-
-
-
diff --git a/tests/bugs/glusterd/bug-1047955.t b/tests/bugs/glusterd/bug-1047955.t
deleted file mode 100644
index a409d9f7195..00000000000
--- a/tests/bugs/glusterd/bug-1047955.t
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-cleanup;
-
-# Create a 2x2 dist-rep volume; peer probe a new node.
-# Performing remove-brick from this new node must succeed
-# without crashing it's glusterd
-
-TEST launch_cluster 2;
-TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/${V0}{1,2,3,4}
-TEST $CLI_1 volume start $V0;
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers;
-TEST $CLI_2 volume remove-brick $V0 $H1:$B1/${V0}{3,4} start;
-TEST $CLI_2 volume info
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1070734.t b/tests/bugs/glusterd/bug-1070734.t
index ea160d7ec6b..0afcb3b37b3 100755
--- a/tests/bugs/glusterd/bug-1070734.t
+++ b/tests/bugs/glusterd/bug-1070734.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 ## Start glusterd
diff --git a/tests/bugs/glusterd/bug-1075087.t b/tests/bugs/glusterd/bug-1075087.t
deleted file mode 100644
index 35155a0b8c9..00000000000
--- a/tests/bugs/glusterd/bug-1075087.t
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}0 $H0:$B0/${V0}1 \
-				      $H0:$B0/${V0}2 $H0:$B0/${V0}3
-TEST $CLI volume start $V0
-
-## Mount FUSE
-TEST glusterfs -s $H0 --volfile-id=$V0 $M0;
-
-TEST mkdir $M0/dir{1..10};
-TEST touch $M0/dir{1..10}/files{1..10};
-
-TEST $CLI volume add-brick $V0 $H0:$B0/${V0}4 $H0:/$B0/${V0}5
-
-TEST $CLI volume rebalance $V0 start force
-EXPECT_WITHIN 60 "completed" rebalance_status_field $V0
-
-TEST pkill gluster
-TEST glusterd
-TEST pidof glusterd
-
-# status should be "completed" immediate after glusterd has respawned.
-EXPECT_WITHIN 5 "completed" rebalance_status_field $V0
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1085330.t b/tests/bugs/glusterd/bug-1085330-and-bug-916549.t
index ffcfe9274eb..892a30d74ea 100755..100644
--- a/tests/bugs/glusterd/bug-1085330.t
+++ b/tests/bugs/glusterd/bug-1085330-and-bug-916549.t
@@ -11,6 +11,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
+#testcase: bug-1085330
 
 # Construct volname string such that its more than 256 characters
 for i in {1..30}
@@ -73,8 +74,20 @@ TEST ! $CLI volume create $volname $H0:$B0/$brick;
 TEST $CLI volume info;
 
 # Positive test case
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+TEST $CLI volume create $V0 $H0:$B0/${V0}1;
 
 TEST $CLI volume info;
 
-cleanup;
+TEST $CLI volume start $V0;
+
+#testcase: bug-916549
+
+pid_file=$(ls $GLUSTERD_PIDFILEDIR/vols/$V0/);
+brick_pid=$(cat $GLUSTERD_PIDFILEDIR/vols/$V0/$pid_file);
+
+kill -SIGKILL $brick_pid;
+TEST $CLI volume start $V0 force;
+TEST process_leak_count $(pidof glusterd);
+
+cleanup
+
diff --git a/tests/bugs/glusterd/bug-1089668.t b/tests/bugs/glusterd/bug-1089668.t
deleted file mode 100755
index c8eb7c30055..00000000000
--- a/tests/bugs/glusterd/bug-1089668.t
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../dht.rc
-
-cleanup
-
-#This script checks command "gluster volume rebalance <volname> status will not
-#show any output when user have done only remove-brick start and command
-#'gluster volume remove-brick <volname> <brick_name> status' will not show
-#any output when user have triggered only rebalance start.
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
-TEST $CLI volume start $V0
-
-TEST $CLI volume rebalance $V0 start
-TEST ! $CLI volume remove-brick $V0 $H0:$B0/${V0}1 status
-EXPECT_WITHIN $REBALANCE_TIMEOUT "0" rebalance_completed
-
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
-TEST ! $CLI volume rebalance $V0 status
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-1092841.t b/tests/bugs/glusterd/bug-1092841.t
deleted file mode 100644
index d3dcf07fd02..00000000000
--- a/tests/bugs/glusterd/bug-1092841.t
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-
-TEST $CLI volume start $V0;
-
-TEST $CLI volume barrier $V0 enable;
-
-TEST ! $CLI volume barrier $V0 enable;
-
-TEST $CLI volume barrier $V0 disable;
-
-TEST ! $CLI volume barrier $V0 disable;
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t b/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t
deleted file mode 100644
index 30d375a1eb0..00000000000
--- a/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ: 1094119  Remove replace-brick support from gluster
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-# Start glusterd
-TEST glusterd
-TEST pidof glusterd
-
-## Lets create and start volume
-TEST $CLI volume create $V0 replica 2 $H0:$B0/brick1 $H0:$B0/brick2
-TEST $CLI volume start $V0
-
-## Now with this patch replace-brick only accept following commad
-## volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> {commit force}
-## Apart form this replace brick command will failed.
-
-TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 start
-TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 status
-TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 abort
-
-
-## replace-brick commit force command should success
-TEST $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 commit force
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1095097.t b/tests/bugs/glusterd/bug-1095097.t
deleted file mode 100755
index 0a616f7831e..00000000000
--- a/tests/bugs/glusterd/bug-1095097.t
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 $H0:$B0/brick1 $H0:$B1/brick1;
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-TEST $CLI volume profile $V0 start
-TEST $CLI volume profile $V0 info
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1102656.t b/tests/bugs/glusterd/bug-1102656.t
deleted file mode 100644
index e80f4930a63..00000000000
--- a/tests/bugs/glusterd/bug-1102656.t
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 2 $H0:$B0/brick0 $H0:$B0/brick1
-TEST $CLI volume start $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field $V0 'Status';
-
-TEST $CLI volume top $V0 open
-TEST ! $CLI volume top $V0 open brick $H0:/tmp/brick
-TEST $CLI volume top $V0 read
-
-TEST $CLI volume status
-TEST $CLI volume stop $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Stopped' volinfo_field $V0 'Status';
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1104642.t b/tests/bugs/glusterd/bug-1104642.t
deleted file mode 100644
index 000093a8ae2..00000000000
--- a/tests/bugs/glusterd/bug-1104642.t
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-function get_value()
-{
-        local key=$1
-        local var="CLI_$2"
-
-        eval cli_index=\$$var
-
-        $cli_index volume info | grep "^$key"\
-                               | sed 's/.*: //'
-}
-
-cleanup
-
-TEST launch_cluster 2
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}0 $H2:$B2/${V0}1
-EXPECT "$V0" get_value 'Volume Name' 1
-EXPECT "Created" get_value 'Status' 1
-
-TEST $CLI_1 volume start $V0
-EXPECT "Started" get_value 'Status' 1
-
-#Bring down 2nd glusterd
-TEST kill_glusterd 2
-
-#set the volume all options from the 1st glusterd
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 80
-
-#Bring back the 2nd glusterd
-TEST $glusterd_2
-
-#Verify whether the value has been synced
-EXPECT '80' get_value 'cluster.server-quorum-ratio' 1
-EXPECT_WITHIN $PROBE_TIMEOUT '1' peer_count
-EXPECT_WITHIN $PROBE_TIMEOUT '80' get_value 'cluster.server-quorum-ratio' 2
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1109741-auth-mgmt-handshake.t b/tests/bugs/glusterd/bug-1109741-auth-mgmt-handshake.t
deleted file mode 100644
index 561b90740fa..00000000000
--- a/tests/bugs/glusterd/bug-1109741-auth-mgmt-handshake.t
+++ /dev/null
@@ -1,50 +0,0 @@
-#! /bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-# The test will attempt to verify that management handshake requests to
-# GlusterD are authenticated before being allowed to change a GlusterD's
-# op-version
-#
-# 1. Launch 3 glusterds
-# 2. Probe 2 of them to form a cluster. This should succeed.
-# 3. Probe either of the first two GlusterD's from the 3rd GlusterD. This should fail.
-# 4. a. Reduce the op-version of 3rd GlusterD and restart it.
-#    b. Probe either of the first two GlusterD's from the 3rd GlusterD. This should fail.
-# 5. Check current op-version of first two GlusterDs. It shouldn't have changed.
-# 6. Probe third GlusterD from the cluster. This should succeed.
-
-
-cleanup
-
-TEST launch_cluster 3
-
-TEST $CLI_1 peer probe $H2
-
-TEST ! $CLI_3 peer probe $H1
-
-GD1_WD=$($CLI_1 system getwd)
-OP_VERS_ORIG=$(grep 'operating-version' ${GD1_WD}/glusterd.info | cut -d '=' -f 2)
-
-TEST $CLI_3 system uuid get # Needed for glusterd.info to be created
-
-GD3_WD=$($CLI_3 system getwd)
-TEST sed -rnie "'s/(operating-version=)\w+/\130600/gip'" ${GD3_WD}/glusterd.info
-
-TEST kill_glusterd 3
-TEST start_glusterd 3
-
-TEST ! $CLI_3 peer probe $H1
-
-OP_VERS_NEW=$(grep 'operating-version' ${GD1_WD}/glusterd.info | cut -d '=' -f 2)
-TEST [[ $OP_VERS_ORIG == $OP_VERS_NEW ]]
-
-TEST $CLI_1 peer probe $H3
-
-kill_node 1
-kill_node 2
-kill_node 3
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1120647.t b/tests/bugs/glusterd/bug-1120647.t
deleted file mode 100644
index 90d069ca502..00000000000
--- a/tests/bugs/glusterd/bug-1120647.t
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{1..4}
-TEST $CLI volume start $V0
-TEST $CLI volume remove-brick $V0 $H0:$B0/brick{3..4} start
-EXPECT_WITHIN 10 "completed" remove_brick_status_completed_field  "$V0 $H0:$B0/brick3"
-EXPECT_WITHIN 10 "completed" remove_brick_status_completed_field  "$V0 $H0:$B0/brick4"
-TEST $CLI volume remove-brick $V0 $H0:$B0/brick{3..4} commit
-TEST $CLI volume remove-brick $V0 replica 1 $H0:$B0/brick2 force
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1121584-brick-existing-validation-for-remove-brick-status-stop.t b/tests/bugs/glusterd/bug-1121584-brick-existing-validation-for-remove-brick-status-stop.t
deleted file mode 100644
index de80afcc2eb..00000000000
--- a/tests/bugs/glusterd/bug-1121584-brick-existing-validation-for-remove-brick-status-stop.t
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ-1121584. Execution of remove-brick status/stop command
-## should give error for brick which is not part of volume.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../dht.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd
-TEST pidof glusterd
-
-## Lets Create and start volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}2
-TEST $CLI volume start $V0
-
-## Start remove-brick operation on the volume
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
-
-## By giving non existing brick for remove-brick status/stop command should
-## give error.
-TEST ! $CLI volume remove-brick $V0 $H0:$B0/ABCD status
-TEST ! $CLI volume remove-brick $V0 $H0:$B0/ABCD stop
-
-## By giving brick which is part of volume for remove-brick status/stop command
-## should print statistics of remove-brick operation or stop remove-brick
-## operation.
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 status
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 stop
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1163108-min-free-disk-option-validation.t b/tests/bugs/glusterd/bug-1163108-min-free-disk-option-validation.t
deleted file mode 100644
index 9fc7ac3b845..00000000000
--- a/tests/bugs/glusterd/bug-1163108-min-free-disk-option-validation.t
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-## Test case for cluster.min-free-disk option validation.
-
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd
-TEST pidof glusterd
-
-## Lets create and start volume
-TEST $CLI volume create $V0 $H0:$B0/brick1 $H0:$B0/brick2
-TEST $CLI volume start $V0
-
-## Setting invalid value for option cluster.min-free-disk should fail
-TEST ! $CLI volume set $V0 min-free-disk ""
-TEST ! $CLI volume set $V0 min-free-disk 143.!/12
-TEST ! $CLI volume set $V0 min-free-disk 123%
-TEST ! $CLI volume set $V0 min-free-disk 194.34%
-
-## Setting fractional value as a size (unit is byte) for option
-## cluster.min-free-disk should fail
-TEST ! $CLI volume set $V0 min-free-disk 199.051
-TEST ! $CLI volume set $V0 min-free-disk 111.999
-
-## Setting valid value for option cluster.min-free-disk should pass
-TEST  $CLI volume set $V0 min-free-disk 12%
-TEST  $CLI volume set $V0 min-free-disk 56.7%
-TEST  $CLI volume set $V0 min-free-disk 120
-TEST  $CLI volume set $V0 min-free-disk 369.0000
-
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1173414-mgmt-v3-remote-lock-failure.t b/tests/bugs/glusterd/bug-1173414-mgmt-v3-remote-lock-failure.t
deleted file mode 100755
index 5a6cf81fd53..00000000000
--- a/tests/bugs/glusterd/bug-1173414-mgmt-v3-remote-lock-failure.t
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-cleanup;
-
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0
-TEST $CLI_1 volume create $V1 $H1:$B1/$V1
-TEST $CLI_1 volume start $V0
-TEST $CLI_1 volume start $V1
-
-for i in {1..20}
-do
-    $CLI_1 volume set $V0 diagnostics.client-log-level DEBUG &
-    $CLI_1 volume set $V1 barrier on
-    $CLI_2 volume set $V0 diagnostics.client-log-level DEBUG &
-    $CLI_2 volume set $V1 barrier on
-done
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
-TEST $CLI_1 volume status
-TEST $CLI_2 volume status
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1177132-quorum-validation.t b/tests/bugs/glusterd/bug-1177132-quorum-validation.t
deleted file mode 100644
index f18b5a178d3..00000000000
--- a/tests/bugs/glusterd/bug-1177132-quorum-validation.t
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/bin/bash
-
-# Test case for quorum validation in glusterd for syncop framework
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-cleanup;
-
-TEST launch_cluster 2
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-# Lets create the volume and set quorum type as a server
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}0 $H2:$B2/${V0}1
-TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-
-# Set quorum ratio 52. means 52 % or more than 52% nodes of total available node
-# should be available for performing volume operation.
-# i.e. Server-side quorum is met if the number of nodes that are available is
-# greater than or equal to 'quorum-ratio' times the number of nodes in the
-# cluster
-
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 52
-
-# Bring down 2nd glusterd
-TEST kill_glusterd 2
-
-# Now quorum is not meet. Add-brick, Remove-brick, volume-set command
-#(Command based on syncop framework)should fail
-TEST ! $CLI_1 volume add-brick $V0 $H1:$B1/${V0}1
-TEST ! $CLI_1 volume remove-brick $V0 $H1:$B1/${V0}0 start
-TEST ! $CLI_1 volume set $V0 barrier enable
-
-# Now execute a command which goes through op state machine and it should fail
-TEST ! $CLI_1 volume profile $V0 start
-
-# Volume set all command and volume reset all command should be successful
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 80
-TEST $CLI_1 volume reset all
-
-# Bring back 2nd glusterd
-TEST $glusterd_2
-
-# After 2nd glusterd come back, there will be 2 nodes in a clusater
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
-
-# Now quorum is meet.
-# Add-brick, Remove-brick, volume-set command should success
-TEST  $CLI_1 volume add-brick $V0 $H2:$B2/${V0}2
-TEST  $CLI_1 volume remove-brick $V0 $H2:$B2/${V0}2 start
-TEST  $CLI_1 volume set $V0 barrier enable
-TEST  $CLI_1 volume remove-brick $V0 $H2:$B2/${V0}2 stop
-
-## Stop the volume
-TEST $CLI_1 volume stop $V0
-
-## Bring down 2nd glusterd
-TEST kill_glusterd 2
-
-## Now quorum is not meet. Starting volume on 1st node should not success
-TEST ! $CLI_1 volume start $V0
-
-## Bring back 2nd glusterd
-TEST $glusterd_2
-
-# After 2nd glusterd come back, there will be 2 nodes in a clusater
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
-
-## Now quorum is meet. Starting volume on 1st node should be success.
-TEST $CLI_1 volume start $V0
-
-# Now re-execute the same profile command and this time it should succeed
-TEST $CLI_1 volume profile $V0 start
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1179175-uss-option-validation.t b/tests/bugs/glusterd/bug-1179175-uss-option-validation.t
deleted file mode 100644
index 6bbe3c9336f..00000000000
--- a/tests/bugs/glusterd/bug-1179175-uss-option-validation.t
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-## Test case for option features.uss validation.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd;
-TEST pidof glusterd;
-
-## Lets create and start volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-
-## Set features.uss option with non-boolean value. These non-boolean value
-## for features.uss option should fail.
-TEST ! $CLI volume set $V0 features.uss abcd
-TEST ! $CLI volume set $V0 features.uss #$#$
-TEST ! $CLI volume set $V0 features.uss 2324
-
-## Setting other options with valid value. These options should succeed.
-TEST $CLI volume set $V0 barrier enable
-TEST $CLI volume set $V0 ping-timeout 60
-
-## Set features.uss option with valid boolean value. It should succeed.
-TEST  $CLI volume set $V0 features.uss enable
-TEST  $CLI volume set $V0 features.uss disable
-
-
-## Setting other options with valid value. These options should succeed.
-TEST $CLI volume set $V0 barrier enable
-TEST $CLI volume set $V0 ping-timeout 60
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1199451-op-version-retrieving-fix.t b/tests/bugs/glusterd/bug-1199451-op-version-retrieving-fix.t
deleted file mode 100644
index 43661b67628..00000000000
--- a/tests/bugs/glusterd/bug-1199451-op-version-retrieving-fix.t
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ-1199451 (gluster command should retrieve current op-version
-## of the NODE)
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd
-TEST pidof glusterd
-
-## Lets create and start volume
-TEST $CLI volume create $V0 $H0:$B0/brick1 $H0:$B0/brick2
-TEST $CLI volume start $V0
-
-## glusterd command should retrieve current op-version of the node
-TEST $CLI volume get $V0 cluster.op-version
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1209329_daemon-svcs-on-reset-volume.t b/tests/bugs/glusterd/bug-1209329_daemon-svcs-on-reset-volume.t
deleted file mode 100644
index f6ca953e40b..00000000000
--- a/tests/bugs/glusterd/bug-1209329_daemon-svcs-on-reset-volume.t
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../nfs.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd;
-TEST pidof glusterd;
-
-## Lets create volume
-TEST $CLI volume create $V0 $H0:$B0/${V0};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-##enable the bitrot and verify bitd is running or not
-TEST $CLI volume bitrot $V0 enable
-EXPECT 'on' volinfo_field $V0 'features.bitrot'
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
-
-##Do reset force which set the bitrot options to default
-TEST $CLI volume reset $V0 force;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_bitd_count
-
-##enable the uss option and verify snapd is running or not
-TEST $CLI volume set $V0 features.uss on
-EXPECT 'on' volinfo_field $V0 'features.uss'
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_snapd_count
-
-##Do reset force which set the uss options to default
-TEST $CLI volume reset $V0 force;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_snapd_count
-
-##verify initial nfs disabled by default
-EXPECT "0" get_nfs_count
-
-##enable nfs and verify
-TEST $CLI volume set $V0 nfs.disable off
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available
-EXPECT "1" get_nfs_count
-
-##Do reset force which set the nfs.option to default
-TEST $CLI volume reset $V0 force;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_nfs_count
-
-##enable the uss option and verify snapd is running or not
-TEST $CLI volume set $V0 features.uss on
-EXPECT 'on' volinfo_field $V0 'features.uss'
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_snapd_count
-
-##Disable the uss option using set command and verify snapd
-TEST $CLI volume set $V0 features.uss  off
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_snapd_count
-
-##enable nfs.disable and verify
-TEST $CLI volume set $V0 nfs.disable on
-EXPECT 'on' volinfo_field $V0 'nfs.disable'
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_nfs_count
-
-## disable nfs.disable option using set command
-TEST $CLI volume set $V0 nfs.disable  off
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_nfs_count
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1213295-snapd-svc-uninitialized.t b/tests/bugs/glusterd/bug-1213295-snapd-svc-uninitialized.t
deleted file mode 100644
index 1dbfdf8697b..00000000000
--- a/tests/bugs/glusterd/bug-1213295-snapd-svc-uninitialized.t
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup
-
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-
-kill_glusterd 2
-TEST start_glusterd 2
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-#volume stop should not crash
-TEST $CLI_2 volume stop $V0
-
-# check whether glusterd instance is running on H2 as this is the node which
-# restored the volume configuration after a restart
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-cleanup
diff --git a/tests/bugs/glusterd/bug-1223213-peerid-fix.t b/tests/bugs/glusterd/bug-1223213-peerid-fix.t
deleted file mode 100755
index 8e7589c9c3b..00000000000
--- a/tests/bugs/glusterd/bug-1223213-peerid-fix.t
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 2;
-
-# Fool the cluster to operate with 3.5 version even though binary's op-version
-# is > 3.5. This is to ensure 3.5 code path is hit to test that volume status
-# works when a node is upgraded from 3.5 to 3.7 or higher as mgmt_v3 lock is
-# been introduced in 3.6 version and onwards
-
-GD1_WD=$($CLI_1 system getwd)
-$CLI_1 system uuid get
-TEST sed -rnie "'s/(operating-version=)\w+/\130500/gip'" ${GD1_WD}/glusterd.info
-
-TEST kill_glusterd 1
-TEST start_glusterd 1
-
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-
-TEST $CLI_1 volume status $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1225716-brick-online-validation-remove-brick.t b/tests/bugs/glusterd/bug-1225716-brick-online-validation-remove-brick.t
deleted file mode 100644
index d168866ab63..00000000000
--- a/tests/bugs/glusterd/bug-1225716-brick-online-validation-remove-brick.t
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 $H0:$B0/${V0}2
-TEST $CLI volume start $V0
-
-#kill a brick process
-kill_brick $V0 $H0 $B0/${V0}1
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status $V0 $H0 $B0/${V0}1
-
-#remove-brick start should fail as the brick is down
-TEST ! $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
-
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
-
-#remove-brick start should succeed as the brick is up
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
-
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0 $H0:$B0/${V0}1"
-
-#kill a brick process
-kill_brick $V0 $H0 $B0/${V0}1
-
-#remove-brick commit should pass even if the brick is down
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 commit
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1231437-rebalance-test-in-cluster.t b/tests/bugs/glusterd/bug-1231437-rebalance-test-in-cluster.t
deleted file mode 100644
index 3257f6994dd..00000000000
--- a/tests/bugs/glusterd/bug-1231437-rebalance-test-in-cluster.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-. $(dirname $0)/../../volume.rc
-
-
-cleanup;
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-$CLI_1 volume create $V0 $H1:$B1/$V0  $H2:$B2/$V0
-EXPECT 'Created' cluster_volinfo_field 1 $V0 'Status';
-
-$CLI_1 volume start $V0
-EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
-
-#Mount FUSE
-TEST glusterfs -s $H1 --volfile-id=$V0 $M0;
-
-TEST mkdir $M0/dir{1..4};
-TEST touch $M0/dir{1..4}/files{1..4};
-
-TEST $CLI_1 volume add-brick $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}1
-
-TEST $CLI_1 volume rebalance $V0  start
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status_field 1  $V0
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1238135-lazy-daemon-initialization-on-demand.t b/tests/bugs/glusterd/bug-1238135-lazy-daemon-initialization-on-demand.t
deleted file mode 100644
index 54c3187cbdb..00000000000
--- a/tests/bugs/glusterd/bug-1238135-lazy-daemon-initialization-on-demand.t
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd;
-
-GDWD=$($CLI system getwd)
-
-# glusterd.info file will be created on either first peer probe or volume
-# creation, hence we expect file to be not present in this case
-TEST ! -e $GDWD/glusterd.info
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1242543-replace-brick.t b/tests/bugs/glusterd/bug-1242543-replace-brick.t
deleted file mode 100644
index 0b1087f1d51..00000000000
--- a/tests/bugs/glusterd/bug-1242543-replace-brick.t
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
-TEST $CLI volume start $V0
-
-TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
-
-# Replace brick1 without killing the brick
-TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}1_new commit force
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
-
-TEST kill_brick $V0 $H0 $B0/${V0}1_new
-
-# Replace brick1 after killing the brick
-TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}1_new $H0:$B0/${V0}1_newer commit force
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1260185-donot-allow-detach-commit-unnecessarily.t b/tests/bugs/glusterd/bug-1260185-donot-allow-detach-commit-unnecessarily.t
deleted file mode 100644
index 4798959380e..00000000000
--- a/tests/bugs/glusterd/bug-1260185-donot-allow-detach-commit-unnecessarily.t
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ: 1260185
-## Do not allow detach-tier commit without "force" option or without
-## user have not started "detach-tier start" operation
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd;
-TEST pidof glusterd;
-
-## Lets create and start the volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1..2}
-TEST $CLI volume start $V0
-
-## Perform attach-tier operation on volume $V0
-TEST $CLI volume tier $V0 attach $H0:$B0/${V0}{3..4}
-
-## detach-tier commit operation without force option on volume $V0
-## should not succeed
-TEST ! $CLI --mode=script volume tier $V0 detach commit
-
-## detach-tier commit operation with force option on volume $V0
-## should succeed
-TEST  $CLI volume tier $V0 detach force
-
-sleep 3
-
-## Again performing attach-tier operation on volume $V0
-TEST $CLI volume tier $V0 attach $H0:$B0/${V0}{5..6}
-
-## Do detach-tier start on volume $V0
-TEST $CLI volume tier $V0 detach start
-
-## Now detach-tier commit on volume $V0 should succeed.
-TEST $CLI volume tier $V0 detach commit
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1265479-validate-replica-volume-options.t b/tests/bugs/glusterd/bug-1265479-validate-replica-volume-options.t
deleted file mode 100644
index e2d43ca817b..00000000000
--- a/tests/bugs/glusterd/bug-1265479-validate-replica-volume-options.t
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-#Create a distributed volume
-TEST $CLI volume create $V0 $H0:$B0/${V00}{1..2};
-TEST $CLI volume start $V0
-
-#Setting data-self-heal option on for distribute volume
-TEST ! $CLI volume set $V0 data-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.data-self-heal';
-TEST ! $CLI volume set $V0 cluster.data-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.data-self-heal';
-
-#Setting metadata-self-heal option on for distribute volume
-TEST ! $CLI volume set $V0 metadata-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.metadata-self-heal';
-TEST ! $CLI volume set $V0 cluster.metadata-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.metadata-self-heal';
-
-#Setting entry-self-heal option on for distribute volume
-TEST ! $CLI volume set $V0 entry-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.entrydata-self-heal';
-TEST ! $CLI volume set $V0 cluster.entry-self-heal on
-EXPECT '' volinfo_field $V0 'cluster.entrydata-self-heal';
-
-#Delete the volume
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-
-
-#Create a distribute-replicate volume
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4};
-TEST $CLI volume start $V0
-
-#Setting data-self-heal option on for distribute-replicate volume
-TEST $CLI volume set $V0 data-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.data-self-heal';
-TEST $CLI volume set $V0 cluster.data-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.data-self-heal';
-
-#Setting metadata-self-heal option on for distribute-replicate volume
-TEST $CLI volume set $V0 metadata-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.metadata-self-heal';
-TEST $CLI volume set $V0 cluster.metadata-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.metadata-self-heal';
-
-#Setting entry-self-heal option on for distribute-replicate volume
-TEST $CLI volume set $V0 entry-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.entry-self-heal';
-TEST $CLI volume set $V0 cluster.entry-self-heal on
-EXPECT 'on' volinfo_field $V0 'cluster.entry-self-heal';
-
-#Delete the volume
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1266818-shared-storage-disable.t b/tests/bugs/glusterd/bug-1266818-shared-storage-disable.t
deleted file mode 100644
index a9ccf1b8954..00000000000
--- a/tests/bugs/glusterd/bug-1266818-shared-storage-disable.t
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ 1266818;
-## Disabling enable-shared-storage option should not delete user created
-## volume with name glusterd_shared_storage
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-## Start a 2 node virtual cluster
-TEST launch_cluster 2;
-
-## Peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-## Creating a volume with name glusterd_shared_storage
-TEST $CLI_1 volume create glusterd_shared_storage  $H1:$B1/${V0}0 $H2:$B1/${V0}1
-
-## Disabling enable-shared-storage should not succeed and should not delete the
-## user created volume with name "glusterd_shared_storage"
-TEST ! $CLI_1 volume all enable-shared-storage disable
-
-## Volume with name should exist
-TEST $CLI_1 volume info glusterd_shared_storage
-
-cleanup;
-
-
-
-
-
diff --git a/tests/bugs/glusterd/bug-1293414-import-brickinfo-uuid.t b/tests/bugs/glusterd/bug-1293414-import-brickinfo-uuid.t
deleted file mode 100755
index 9f67e4ccfa0..00000000000
--- a/tests/bugs/glusterd/bug-1293414-import-brickinfo-uuid.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 4;
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-
-
-TEST $CLI_1 peer probe $H3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
-TEST $CLI_1 peer probe $H4;
-EXPECT_WITHIN $PROBE_TIMEOUT 3 peer_count
-
-# peers hosting bricks can't be detached
-TEST ! $CLI_3 peer detach $H1
-TEST ! $CLI_3 peer detach $H2
-
-
-# peer not hosting bricks should be detachable
-TEST $CLI_3 peer detach $H4
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1303028-Rebalance-glusterd-rpc-connection-issue.t b/tests/bugs/glusterd/bug-1303028-Rebalance-glusterd-rpc-connection-issue.t
deleted file mode 100644
index 00f20c1ff78..00000000000
--- a/tests/bugs/glusterd/bug-1303028-Rebalance-glusterd-rpc-connection-issue.t
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{1..3}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume start $V0
-        TEST $CLI volume attach-tier $V0 $H0:$B0/hot/${V0}{1..2}
-        TEST $CLI volume set $V0 cluster.tier-mode test
-}
-
-function non_zero_check () {
-        if [ "$1" -ne 0 ]
-        then
-                echo "0"
-        else
-                echo "1"
-        fi
-}
-
-function num_bricks_up {
-        local b
-        local n_up=0
-
-        for b in $B0/hot/${V0}{1..2} $B0/cold/${V0}{1..3}; do
-                if [ x"$(brick_up_status $V0 $H0 $b)" = x"1" ]; then
-                        n_up=$((n_up+1))
-                fi
-        done
-
-        echo $n_up
-}
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume status
-
-
-#Create and start a tiered volume
-create_dist_tier_vol
-# Wait for the bricks to come up, *then* the tier daemon.
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 5 num_bricks_up
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 tier_daemon_check
-sleep 5   #wait for some time to run tier daemon
-time_before_restarting=$(rebalance_run_time $V0);
-
-#checking for elapsed time after sleeping for two seconds.
-EXPECT "0" non_zero_check $time_before_restarting;
-
-#Difference of elapsed time should be positive
-
-kill -9 $(pidof glusterd);
-TEST glusterd;
-sleep 2;
-# Wait for the bricks to come up, *then* the tier daemon.
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 5 num_bricks_up
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" tier_daemon_check;
-sleep 1;
-time1=$(rebalance_run_time $V0);
-EXPECT "0" non_zero_check $time1;
-sleep 2;
-time2=$(rebalance_run_time $V0);
-EXPECT "0" non_zero_check $time2;
-diff=`expr $time2 - $time1`
-EXPECT "0" non_zero_check $diff;
diff --git a/tests/bugs/glusterd/bug-1314649-group-virt.t b/tests/bugs/glusterd/bug-1314649-group-virt.t
deleted file mode 100644
index 257e7845611..00000000000
--- a/tests/bugs/glusterd/bug-1314649-group-virt.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-TEST $CLI volume set $V0 group virt;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1315186-reject-lowering-down-op-version.t b/tests/bugs/glusterd/bug-1315186-reject-lowering-down-op-version.t
deleted file mode 100644
index 4bd6eaac59f..00000000000
--- a/tests/bugs/glusterd/bug-1315186-reject-lowering-down-op-version.t
+++ /dev/null
@@ -1,22 +0,0 @@
-#! /bin/bash
-
-. $(dirname $0)/../../include.rc
-
-# The test validates that lowering down the op-version should fail
-
-cleanup
-
-TEST glusterd
-TEST pidof glusterd
-
-#volume create is just to ensure glusterd.info file is created
-TEST $CLI volume create $V0 $H0:$B0/b1
-
-GDWD=$($CLI system getwd)
-OP_VERS_ORIG=$(grep 'operating-version' ${GDWD}/glusterd.info | cut -d '=' -f 2)
-OP_VERS_NEW=`expr $OP_VERS_ORIG-1`
-
-TEST ! $CLI volume set all $V0 cluster.op-version $OP_VERS_NEW
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1318591-skip-non-directories-inside-vols.t b/tests/bugs/glusterd/bug-1318591-skip-non-directories-inside-vols.t
deleted file mode 100644
index c776b489957..00000000000
--- a/tests/bugs/glusterd/bug-1318591-skip-non-directories-inside-vols.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../env.rc
-. $(dirname $0)/../../snapshot.rc
-
-cleanup;
-
-TEST verify_lvm_version
-TEST glusterd
-TEST pidof glusterd
-
-TEST setup_lvm 1
-
-TEST $CLI volume create $V0 $H0:$L1
-TEST $CLI volume start $V0
-
-TEST $CLI volume status $V0;
-
-TEST touch $GLUSTERD_WORKDIR/vols/file
-
-TEST $CLI snapshot create snap1 $V0 no-timestamp
-
-TEST touch $GLUSTERD_WORKDIR/snaps/snap1/file
-
-TEST killall_gluster
-
-TEST glusterd
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1321836-fix-opret-for-volume-info-xml-output.t b/tests/bugs/glusterd/bug-1321836-fix-opret-for-volume-info-xml-output.t
deleted file mode 100644
index 48fccc621d8..00000000000
--- a/tests/bugs/glusterd/bug-1321836-fix-opret-for-volume-info-xml-output.t
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-## Check that opRet field has correct value assigned for non existent volumes
-## --------------------------------------------------------------------------
-
-function get_opret_value () {
-  local VOL=$1
-  $CLI volume info $VOL --xml | sed -ne 's/.*<opRet>\([-0-9]*\)<\/opRet>/\1/p'
-}
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 $H0:$B0/$V0;
-
-EXPECT 0 get_opret_value $V0
-EXPECT -1 get_opret_value "novol"
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1323287-real_path-handshake-test.t b/tests/bugs/glusterd/bug-1323287-real_path-handshake-test.t
deleted file mode 100644
index 12b722bae36..00000000000
--- a/tests/bugs/glusterd/bug-1323287-real_path-handshake-test.t
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-. $(dirname $0)/../../volume.rc
-
-function volume_get_field()
-{
-     local vol=$1
-     local field=$2
-     $CLI_2 volume get $vol $field | tail -1 | awk '{print $2}'
-}
-
-cleanup;
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0  $H2:$B2/$V0
-EXPECT 'Created' cluster_volinfo_field 1 $V0 'Status';
-
-TEST $CLI_1 volume start $V0
-EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
-
-#kill glusterd2 and do a volume set command to change the version
-kill_glusterd 2
-
-TEST $CLI_1 volume set $V0 performance.write-behind off
-TEST start_glusterd 2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-#Check for handshake completion.
-EXPECT_WITHIN $PROBE_TIMEOUT 'off' volume_get_field $V0 'write-behind'
-
-#During hanndshake, if we failed to populate real_path,
-#then volume create will fail.
-TEST $CLI_1 volume create $V1 $H1:$B1/$V1  $H2:$B2/$V1
diff --git a/tests/bugs/glusterd/bug-1344407-volume-delete-on-node-down.t b/tests/bugs/glusterd/bug-1344407-volume-delete-on-node-down.t
deleted file mode 100755
index 5081c373e47..00000000000
--- a/tests/bugs/glusterd/bug-1344407-volume-delete-on-node-down.t
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 2;
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0
-
-TEST kill_glusterd 2
-TEST ! $CLI_1 volume delete $V0
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1345727-bricks-stop-on-no-quorum-validation.t b/tests/bugs/glusterd/bug-1345727-bricks-stop-on-no-quorum-validation.t
deleted file mode 100644
index 34959f5b0c6..00000000000
--- a/tests/bugs/glusterd/bug-1345727-bricks-stop-on-no-quorum-validation.t
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/bin/bash
-
-# Test case to check if bricks are down when quorum is not met
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 3
-
-TEST $CLI_1 peer probe $H2;
-TEST $CLI_1 peer probe $H3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
-# Lets create the volume and set quorum type as a server
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}2 $H3:$B3/${V0}3
-TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H3 $B3/${V0}3
-
-# Bring down 2nd and 3rd glusterd
-TEST kill_glusterd 2
-TEST kill_glusterd 3
-
-# Server quorum is not met. Brick on 1st node must be down
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status_1 $V0 $H1 $B1/${V0}1
-
-# Set quorum ratio 95. means 95 % or more than 95% nodes of total available node
-# should be available for performing volume operation.
-# i.e. Server-side quorum is met if the number of nodes that are available is
-# greater than or equal to 'quorum-ratio' times the number of nodes in the
-# cluster
-
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 95
-
-# Bring back 2nd glusterd
-TEST $glusterd_2
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-# Server quorum is still not met. Bricks should be down on 1st and 2nd nodes
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status_1 $V0 $H2 $B2/${V0}2
-
-# Bring back 3rd glusterd
-TEST $glusterd_3
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
-# Server quorum is met now. Bricks should be up on all nodes
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H3 $B3/${V0}3
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1351021-rebalance-info-post-glusterd-restart.t b/tests/bugs/glusterd/bug-1351021-rebalance-info-post-glusterd-restart.t
deleted file mode 100755
index cb3206f7d49..00000000000
--- a/tests/bugs/glusterd/bug-1351021-rebalance-info-post-glusterd-restart.t
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-function get_rebalanced_info()
-{
-        local rebal_info_key=$2
-        $CLI  volume rebalance $1 status | awk '{print $'$rebal_info_key'}' |sed -n 3p| sed 's/ *$//g'
-}
-
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1..3};
-TEST $CLI volume start $V0;
-
-#Mount volume and create data
-TEST glusterfs -s $H0 --volfile-id $V0 $M0;
-TEST mkdir $M0/dir{1..10}
-TEST touch $M0/dir{1..10}/file{1..10}
-
-# Add-brick and start rebalance
-TEST $CLI volume add-brick $V0 $H0:$B0/${V0}4
-TEST $CLI volume rebalance $V0 start
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
-
-#Rebalance info before glusterd restart
-OLD_REBAL_FILES=$(get_rebalanced_info $V0 2)
-OLD_SIZE=$(get_rebalanced_info $V0 3)
-OLD_SCANNED=$(get_rebalanced_info $V0 4)
-OLD_FAILURES=$(get_rebalanced_info $V0 5)
-OLD_SKIPPED=$(get_rebalanced_info $V0 6)
-
-
-pkill glusterd;
-pkill glusterfsd;
-TEST glusterd
-
-#Rebalance info after glusterd restart
-NEW_REBAL_FILES=$(get_rebalanced_info $V0 2)
-NEW_SIZE=$(get_rebalanced_info $V0 3)
-NEW_SCANNED=$(get_rebalanced_info $V0 4)
-NEW_FAILURES=$(get_rebalanced_info $V0 5)
-NEW_SKIPPED=$(get_rebalanced_info $V0 6)
-
-#Check rebalance info before and after glusterd restart
-TEST [ $OLD_REBAL_FILES == $NEW_REBAL_FILES ]
-TEST [ $OLD_SIZE == $NEW_SIZE ]
-TEST [ $OLD_SCANNED == $NEW_SCANNED ]
-TEST [ $OLD_FAILURES == $NEW_FAILURES ]
-TEST [ $OLD_SKIPPED == $NEW_SKIPPED ]
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1352277-spawn-daemons-on-two-node-setup.t b/tests/bugs/glusterd/bug-1352277-spawn-daemons-on-two-node-setup.t
deleted file mode 100644
index 53d8d34160e..00000000000
--- a/tests/bugs/glusterd/bug-1352277-spawn-daemons-on-two-node-setup.t
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# Test case for checking whether the brick process(es) come up on a two node
-# cluster if one of them is already down and other is going through a restart
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 2
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1  peer_count
-
-# Lets create the volume
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}2
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-
-# Bring down all the gluster processes
-TEST killall_gluster
-
-#Bring back 1st glusterd and check whether the brick process comes back
-TEST $glusterd_1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-
-#Enabling quorum should bring down the brick
-TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" brick_up_status_1 $V0 $H1 $B1/${V0}1
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1367478-volume-start-validation-after-glusterd-restart.t b/tests/bugs/glusterd/bug-1367478-volume-start-validation-after-glusterd-restart.t
deleted file mode 100644
index 4329c66474f..00000000000
--- a/tests/bugs/glusterd/bug-1367478-volume-start-validation-after-glusterd-restart.t
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash
-
-# Test case to check for successful startup of volume bricks on glusterd restart
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 2
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-# Lets create the volume and set quorum type as a server
-TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/${V0}1 $H2:$B2/${V0}2
-TEST $CLI_1 volume create $V1 replica 2 $H1:$B1/${V1}1 $H2:$B2/${V1}2
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-TEST $CLI_1 volume start $V1
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V1 $H1 $B1/${V1}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V1 $H2 $B2/${V1}2
-
-# Restart 2nd glusterd
-TEST kill_glusterd 2
-TEST $glusterd_2
-
-# Check if all bricks are up
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V1 $H1 $B1/${V1}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V1 $H2 $B2/${V1}2
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1383893-daemons-to-follow-quorum.t b/tests/bugs/glusterd/bug-1383893-daemons-to-follow-quorum.t
deleted file mode 100644
index 105292ab5bb..00000000000
--- a/tests/bugs/glusterd/bug-1383893-daemons-to-follow-quorum.t
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/bash
-
-# This test checks for if shd or any other daemons brought down (apart from
-# brick processes) is not brought up automatically when glusterd on the other
-# node is (re)started
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-function shd_up_status_1 {
-        $CLI_1 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $7}'
-}
-
-function shd_up_status_2 {
-        $CLI_2 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $7}'
-}
-
-function get_shd_pid_2 {
-        $CLI_2 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $8}'
-}
-cleanup;
-
-TEST launch_cluster 3
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1  peer_count
-
-TEST $CLI_1 peer probe $H3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2  peer_count
-
-# Lets create the volume
-TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/${V0}1 $H2:$B2/${V0}2
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H1 $B1/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_2
-
-# Bring down shd on 2nd node
-kill -15 $(get_shd_pid_2)
-
-# Bring down glusterd on 1st node
-TEST kill_glusterd 1
-
-#Bring back 1st glusterd
-TEST $glusterd_1
-
-# We need to wait till PROCESS_UP_TIMEOUT and then check shd service does not
-# come up on node 2
-sleep $PROCESS_UP_TIMEOUT
-EXPECT "N" shd_up_status_2
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1406411-fail-add-brick-on-replica-count-change.t b/tests/bugs/glusterd/bug-1406411-fail-add-brick-on-replica-count-change.t
deleted file mode 100644
index a9dd2b7a811..00000000000
--- a/tests/bugs/glusterd/bug-1406411-fail-add-brick-on-replica-count-change.t
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
-TEST kill_brick $V0 $H0 $B0/${V0}1
-
-#add-brick should fail
-TEST ! $CLI_NO_FORCE volume add-brick $V0 replica 3 $H0:$B0/${V0}3
-
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
-TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}3
-
-TEST $CLI volume create $V1 $H0:$B0/${V1}{1,2};
-TEST $CLI volume start $V1
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}2
-TEST kill_brick $V1 $H0 $B0/${V1}1
-
-#add-brick should fail
-TEST ! $CLI_NO_FORCE volume add-brick $V1 replica 2 $H0:$B0/${V1}{3,4}
-
-TEST $CLI volume start $V1 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}2
-TEST $CLI volume add-brick $V1 replica 2 $H0:$B0/${V1}{3,4}
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1420637-volume-sync-fix.t b/tests/bugs/glusterd/bug-1420637-volume-sync-fix.t
deleted file mode 100644
index 0bd9988f6be..00000000000
--- a/tests/bugs/glusterd/bug-1420637-volume-sync-fix.t
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash
-
-# Test case for checking when server-quorum-ratio value is changed on one
-# glusterd where the other is down, the other changes done get synced back
-properly when the glusterd is brought up.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup;
-
-TEST launch_cluster 2
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-# Lets create & start the volume
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}0 $H2:$B2/${V0}1
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-TEST $CLI_1 volume set $V0 performance.readdir-ahead on
-
-# Bring down 2nd glusterd
-TEST kill_glusterd 2
-
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 60
-TEST $CLI_1 volume set $V0 performance.readdir-ahead off
-
-# Bring back 2nd glusterd
-TEST $glusterd_2
-
-# After 2nd glusterd come back, there will be 2 nodes in a clusater
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
-
-EXPECT_WITHIN $PROBE_TIMEOUT "60" volinfo_field_2 all cluster.server-quorum-ratio
-EXPECT_WITHIN $PROBE_TIMEOUT "off" volinfo_field_2 $V0 performance.readdir-ahead
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1433578-invalid-peer-glusterd-crash.t b/tests/bugs/glusterd/bug-1433578-invalid-peer-glusterd-crash.t
deleted file mode 100644
index 1aea8bc134d..00000000000
--- a/tests/bugs/glusterd/bug-1433578-invalid-peer-glusterd-crash.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd;
-TEST pidof glusterd;
-
-TEST ! $CLI peer probe invalid-peer
-
-TEST pidof glusterd;
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1444596_brick_mux_gd_status_restart.t b/tests/bugs/glusterd/bug-1444596_brick_mux_gd_status_restart.t
deleted file mode 100644
index 950cb5f8046..00000000000
--- a/tests/bugs/glusterd/bug-1444596_brick_mux_gd_status_restart.t
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-function count_up_bricks {
-        $CLI --xml volume status $1 | grep '<status>1' | wc -l
-}
-
-function count_brick_processes {
-        pgrep glusterfsd | wc -l
-}
-
-cleanup
-TEST glusterd
-TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
-TEST $CLI volume create $V1 $H0:$B0/brick{2,3}
-
-TEST $CLI volume set all cluster.brick-multiplex on
-
-TEST $CLI volume start $V0
-TEST $CLI volume start $V1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V1
-EXPECT 1 count_brick_processes
-
-pkill glusterd
-TEST glusterd
-
-#Check brick status after restart glusterd
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V1
-
-
-TEST $CLI volume stop $V0
-TEST $CLI volume stop $V1
-
-cleanup
-
-TEST glusterd
-TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
-TEST $CLI volume create $V1 $H0:$B0/brick{2,3}
-
-TEST $CLI volume set all cluster.brick-multiplex on
-
-TEST $CLI volume start $V0
-TEST $CLI volume start $V1
-
-EXPECT 1 count_brick_processes
-
-TEST $CLI volume set $V0 performance.cache-size 32MB
-TEST $CLI volume stop $V0
-TEST $CLI volume start $V0
-
-#Check No. of brick processes after change option
-EXPECT 2 count_brick_processes
-
-pkill glusterd
-TEST glusterd
-
-#Check brick status after restart glusterd should not be NA
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V1
-EXPECT 2 count_brick_processes
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-1444596_brick_mux_posix_hlth_chk_status.t b/tests/bugs/glusterd/bug-1444596_brick_mux_posix_hlth_chk_status.t
deleted file mode 100644
index e082ba12173..00000000000
--- a/tests/bugs/glusterd/bug-1444596_brick_mux_posix_hlth_chk_status.t
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-function count_up_bricks {
-        $CLI --xml volume status $1 | grep '<status>1' | wc -l
-}
-
-function count_brick_processes {
-        pgrep glusterfsd | wc -l
-}
-
-cleanup
-TEST glusterd -LDEBUG
-TEST $CLI volume create $V0 $H0:$B0/brick{0,1}
-TEST $CLI volume create $V1 $H0:$B0/brick{2,3}
-
-TEST $CLI volume set all cluster.brick-multiplex on
-
-TEST $CLI volume start $V0
-TEST $CLI volume start $V1
-
-EXPECT 1 count_brick_processes
-
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0
-TEST rm -rf $H0:$B0/brick{0,1}
-
-#Check No. of brick processes after remove brick from back-end
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V1
-
-EXPECT 1 count_brick_processes
-
-TEST glusterfs -s $H0 --volfile-id $V1 $M0
-TEST touch $M0/file{1..10}
-
-pkill glusterd
-TEST glusterd -LDEBUG
-sleep 5
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks $V1
-
-
-cleanup
-
diff --git a/tests/bugs/glusterd/bug-1446172-brick-mux-reset-brick.t b/tests/bugs/glusterd/bug-1446172-brick-mux-reset-brick.t
deleted file mode 100644
index e6aaaa4e87c..00000000000
--- a/tests/bugs/glusterd/bug-1446172-brick-mux-reset-brick.t
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../traps.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-function count_up_bricks {
-        $CLI --xml volume status | grep '<status>1' | wc -l
-}
-
-function count_brick_processes {
-	pgrep glusterfsd | wc -l
-}
-
-TEST glusterd
-
-TEST $CLI volume set all cluster.brick-multiplex on
-push_trapfunc "$CLI volume set all cluster.brick-multiplex off"
-push_trapfunc "cleanup"
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
-TEST $CLI volume create $V1 $H0:$B0/${V1}{0,1}
-
-TEST $CLI volume start $V0
-TEST $CLI volume start $V1
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_up_bricks
-EXPECT 1 count_brick_processes
-
-TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
-# Create files
-for i in {1..5}
-do
-        echo $i > $M0/file$i.txt
-done
-
-TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}1 start
-
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 3 count_up_bricks
-EXPECT 1 count_brick_processes
-
-# Negative case with brick killed but volume-id xattr present
-TEST ! $CLI volume reset-brick $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}1 commit
-
-# reset-brick commit force should work and should bring up the brick
-TEST $CLI volume reset-brick $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}1 commit force
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_up_bricks
-EXPECT 1 count_brick_processes
-
-TEST glusterfs --volfile-id=$V1 --volfile-server=$H0 $M1;
-# Create files
-for i in {1..5}
-do
-        echo $i > $M1/file$i.txt
-done
-
-TEST $CLI volume reset-brick $V1 $H0:$B0/${V1}1 start
-
-EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 3 count_up_bricks
-EXPECT 1 count_brick_processes
-
-# Simulate reset disk
-for i in {1..5}
-do
-        rm -rf $B0/${V1}1/file$i.txt
-done
-
-setfattr -x trusted.glusterfs.volume-id $B0/${V1}1
-setfattr -x trusted.gfid $B0/${V1}1
-
-# Test reset-brick commit. Using CLI_IGNORE_PARTITION since normal CLI  uses
-# the --wignore flag that essentially makes the command act like "commit force"
-TEST $CLI_IGNORE_PARTITION volume reset-brick $V1 $H0:$B0/${V1}1 $H0:$B0/${V1}1 commit
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_up_bricks
-EXPECT 1 count_brick_processes
diff --git a/tests/bugs/glusterd/bug-1451248-mux-reboot-node.t b/tests/bugs/glusterd/bug-1451248-mux-reboot-node.t
deleted file mode 100644
index 5d8ce6e75e6..00000000000
--- a/tests/bugs/glusterd/bug-1451248-mux-reboot-node.t
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../traps.rc
-. $(dirname $0)/../../volume.rc
-
-function count_up_bricks {
-        $CLI --xml volume status all | grep '<status>1' | wc -l
-}
-
-function count_brick_processes {
-	pgrep glusterfsd | wc -l
-}
-
-function count_brick_pids {
-        $CLI --xml volume status all | sed -n '/.*<pid>\([^<]*\).*/s//\1/p' \
-                                     | grep -v "N/A" | sort | uniq | wc -l
-}
-
-cleanup;
-
-TEST glusterd
-TEST $CLI volume set all cluster.brick-multiplex on
-push_trapfunc "$CLI volume set all cluster.brick-multiplex off"
-push_trapfunc "cleanup"
-
-TEST $CLI volume create $V0 $H0:$B0/brick{0..2}
-TEST $CLI volume start $V0
-
-EXPECT 1 count_brick_processes
-EXPECT 1 count_brick_pids
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_up_bricks
-
-pkill gluster
-TEST glusterd
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_up_bricks
-
-pkill glusterd
-TEST glusterd
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_up_bricks
-
-TEST $CLI volume create $V1 $H0:$B0/brick{3..5}
-TEST $CLI volume start $V1
-
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_processes
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 count_brick_pids
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 6 count_up_bricks
-
diff --git a/tests/bugs/glusterd/bug-1454418-seg-fault.t b/tests/bugs/glusterd/bug-1454418-seg-fault.t
deleted file mode 100644
index eafaa55ede8..00000000000
--- a/tests/bugs/glusterd/bug-1454418-seg-fault.t
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-
-cleanup;
-
-## Setting Port number in specific range
-sysctl net.ipv4.ip_local_reserved_ports="24007-24008,32765-32768,49152-49156"
-
-## Start a 2 node virtual cluster
-TEST launch_cluster 2;
-
-
-## Peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-sysctl net.ipv4.ip_local_reserved_ports="
-"
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-1482344-volume-option-set-cluster-level.t b/tests/bugs/glusterd/bug-1482344-volume-option-set-cluster-level.t
deleted file mode 100644
index 481dee186b8..00000000000
--- a/tests/bugs/glusterd/bug-1482344-volume-option-set-cluster-level.t
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-#Test case: glusterd should disallow a volume level option to be set cluster
-wide and glusterd should not crash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-
-#Create a 2x1 distributed volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-
-TEST ! $CLI volume set all transport.listen-backlog 128
-
-# Check the volume info output, if glusterd would have crashed then this command
-# will fail
-TEST $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1483058-replace-brick-quorum-validation.t b/tests/bugs/glusterd/bug-1483058-replace-brick-quorum-validation.t
deleted file mode 100644
index 3dbe28a7917..00000000000
--- a/tests/bugs/glusterd/bug-1483058-replace-brick-quorum-validation.t
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/bin/bash
-
-# Test case for quorum validation in glusterd for syncop framework
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-cleanup;
-
-TEST launch_cluster 3
-
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-TEST $CLI_1 peer probe $H3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
-# Lets create the volume and set quorum type as a server
-TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/${V0}0 $H2:$B2/${V0}1 $H3:$B3/${V0}2
-TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
-
-# Start the volume
-TEST $CLI_1 volume start $V0
-
-# Set quorum ratio 95. means 95 % or more than 95% nodes of total available node
-# should be available for performing volume operation.
-# i.e. Server-side quorum is met if the number of nodes that are available is
-# greater than or equal to 'quorum-ratio' times the number of nodes in the
-# cluster
-
-TEST $CLI_1 volume set all cluster.server-quorum-ratio 95
-# Bring down 2nd glusterd
-TEST kill_glusterd 2
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
-
-# Now quorum is not meet. Now execute replace-brick command
-# This command should fail as cluster is not in quorum
-TEST ! $CLI_1 volume replace-brick $V0 $H2:$B2/${V0}1 $H1:$B1/${V0}1_new commit force
-
-# Bring 2nd glusterd up
-TEST start_glusterd 2
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
-# Now quorum is met. replace-brick will execute successfuly
-TEST  $CLI_1 volume replace-brick $V0 $H2:$B2/${V0}1 $H1:$B1/${V0}1_new commit force
-
-#cleanup;
diff --git a/tests/bugs/glusterd/bug-1499509-disconnect-in-brick-mux.t b/tests/bugs/glusterd/bug-1499509-disconnect-in-brick-mux.t
deleted file mode 100644
index 3c5bebee0c7..00000000000
--- a/tests/bugs/glusterd/bug-1499509-disconnect-in-brick-mux.t
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-cleanup
-
-TEST glusterd
-TEST pidof glusterd
-
-## Enable brick multiplexing
-TEST $CLI volume set all cluster.brick-multiplex on
-
-## creating 1x3 replicated volumes
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}_{1..3}
-TEST $CLI volume create $V1 replica 3 $H0:$B1/${V1}_{1..3}
-
-## Start the volume
-TEST $CLI volume start $V0
-TEST $CLI volume start $V1
-
-kill -9 $(pgrep glusterfsd)
-
-EXPECT 0 online_brick_count
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-1507466-reset-brick-commit-force.t b/tests/bugs/glusterd/bug-1507466-reset-brick-commit-force.t
deleted file mode 100644
index 764399dfab9..00000000000
--- a/tests/bugs/glusterd/bug-1507466-reset-brick-commit-force.t
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-cleanup;
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-TEST launch_cluster 3
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
-
-TEST $CLI_1 volume create $V0 replica 2 $H1:$B0/${V0} $H2:$B0/${V0}
-TEST $CLI_1 volume start $V0
-
-# Negative case with brick not killed && volume-id xattrs present
-TEST ! $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} $H1:$B0/${V0} commit force
-
-TEST $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} start
-# Now test if reset-brick commit force works
-TEST $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} $H1:$B0/${V0} commit force
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-1595320.t b/tests/bugs/glusterd/bug-1595320.t
new file mode 100644
index 00000000000..c10e11821a1
--- /dev/null
+++ b/tests/bugs/glusterd/bug-1595320.t
@@ -0,0 +1,93 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup
+
+function count_up_bricks {
+        $CLI --xml volume status $V0 | grep '<status>1' | wc -l
+}
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+# Setup 3 LVMS
+LVM_PREFIX="test"
+TEST init_n_bricks 3
+TEST setup_lvm 3
+
+# Start glusterd
+TEST glusterd
+TEST pidof glusterd
+
+# Create volume and enable brick multiplexing
+TEST $CLI volume create $V0 $H0:$L1 $H0:$L2 $H0:$L3
+TEST $CLI v set all cluster.brick-multiplex on
+
+# Start the volume
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_up_bricks
+EXPECT 1 count_brick_processes
+
+# Kill volume ungracefully
+brick_pid=`pgrep glusterfsd`
+
+# Make sure every brick root should be consumed by a brick process
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L1 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L2 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L3 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+
+b1_pid_file=$(ls $GLUSTERD_PIDFILEDIR/vols/$V0/*d-backends-1*.pid)
+b2_pid_file=$(ls $GLUSTERD_PIDFILEDIR/vols/$V0/*d-backends-2*.pid)
+b3_pid_file=$(ls $GLUSTERD_PIDFILEDIR/vols/$V0/*d-backends-3*.pid)
+
+kill -9 $brick_pid
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 count_brick_processes
+
+# Unmount 3rd brick root from node
+brick_root=$L3
+_umount_lv 3
+
+# Start the volume only 2 brick should be start
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 count_up_bricks
+EXPECT 1 count_brick_processes
+
+brick_pid=`pgrep glusterfsd`
+
+# Make sure only two brick root should be consumed by a brick process
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L1 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L2 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L3 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 0 ]
+
+# Mount the brick root
+TEST mkdir -p $brick_root
+TEST mount -t xfs -o nouuid  /dev/test_vg_3/brick_lvm $brick_root
+
+# Replace brick_pid file to test brick_attach code
+TEST cp $b1_pid_file $b3_pid_file
+
+# Start the volume all brick should be up
+TEST $CLI volume start $V0 force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 count_up_bricks
+EXPECT 1 count_brick_processes
+
+# Make sure every brick root should be consumed by a brick process
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L1 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L2 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+n=`ls -lrth /proc/$brick_pid/fd | grep -iw $L3 | grep -v ".glusterfs" | wc -l`
+TEST [ $n -eq 1 ]
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-1696046.t b/tests/bugs/glusterd/bug-1696046.t
new file mode 100644
index 00000000000..e1c1eb2ceb9
--- /dev/null
+++ b/tests/bugs/glusterd/bug-1696046.t
@@ -0,0 +1,113 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+function count_up_bricks {
+        $CLI --xml volume status $1 | grep '<status>1' | wc -l
+}
+
+function count_brick_processes {
+        pgrep glusterfsd | wc -l
+}
+
+logdir=`gluster --print-logdir`
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume set all cluster.brick-multiplex on
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3};
+TEST $CLI volume create $V1 replica 3 $H0:$B0/${V1}{1,2,3};
+
+## Start volume and verify
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $CLI volume start $V1;
+EXPECT 'Started' volinfo_field $V1 'Status';
+
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_up_bricks $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 4 count_up_bricks $V1
+
+EXPECT 1 count_brick_processes
+
+# Mount V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+function client-log-file-name()
+{
+    logfilename=$M0".log"
+    echo ${logfilename:1} | tr / -
+}
+
+function brick-log-file-name()
+{
+    logfilename=$B0"/"$V0"1.log"
+    echo ${logfilename:1} | tr / -
+}
+
+log_file=$logdir"/"`client-log-file-name`
+nofdlog=$(cat $log_file | grep " D " | wc -l)
+TEST [ $((nofdlog)) -eq 0 ]
+
+brick_log_file=$logdir"/bricks/"`brick-log-file-name`
+nofdlog=$(cat $brick_log_file | grep " D " | wc -l)
+TEST [ $((nofdlog)) -eq 0 ]
+
+## Set brick-log-level to DEBUG
+TEST $CLI volume set $V0 diagnostics.brick-log-level DEBUG
+
+# Do some operation
+touch $M0/file1
+
+# Check debug message debug message should be exist only for V0
+# Server xlator is common in brick_mux so after enabling DEBUG log
+# some debug message should be available for other xlators like posix
+
+brick_log_file=$logdir"/bricks/"`brick-log-file-name`
+nofdlog=$(cat $brick_log_file | grep file1 | grep -v server | wc -l)
+TEST [ $((nofdlog)) -ne 0 ]
+
+#Check if any debug log exist in client-log file
+nofdlog=$(cat $log_file | grep " D " | wc -l)
+TEST [ $((nofdlog)) -eq 0 ]
+
+## Set brick-log-level to INFO
+TEST $CLI volume set $V0 diagnostics.brick-log-level INFO
+
+## Set client-log-level to DEBUG
+TEST $CLI volume set $V0 diagnostics.client-log-level DEBUG
+
+# Do some operation
+touch $M0/file2
+
+nofdlog=$(cat $brick_log_file | grep " D " | grep file2 | wc -l)
+TEST [ $((nofdlog)) -eq 0 ]
+
+nofdlog=$(cat $log_file | grep " D " | wc -l)
+TEST [ $((nofdlog)) -ne 0 ]
+
+# Unmount V0
+TEST umount $M0
+
+#Mount V1
+TEST glusterfs --volfile-id=$V1 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+#do some operation
+touch $M0/file3
+
+
+# DEBUG log level is enabled only for V0 so no debug message should be available
+# in log specific to file2 creation except for server xlator, server xlator is
+# common xlator in brick mulitplex
+nofdlog=$(cat $brick_log_file | grep file3 | grep -v server | wc -l)
+TEST [ $((nofdlog)) -eq 0 ]
+
+# Unmount V1
+TEST umount $M0
+
+cleanup;
diff --git a/tests/bugs/glusterd/bug-1699339.t b/tests/bugs/glusterd/bug-1699339.t
new file mode 100644
index 00000000000..bb8d4f46eb8
--- /dev/null
+++ b/tests/bugs/glusterd/bug-1699339.t
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+cleanup;
+
+NUM_VOLS=15
+
+
+get_brick_base () {
+	printf "%s/vol%02d" $B0 $1
+}
+
+function count_up_bricks {
+        vol=$1;
+        $CLI_1 --xml volume status $vol | grep '<status>1' | wc -l
+}
+
+create_volume () {
+
+	local vol_name=$(printf "%s-vol%02d" $V0 $1)
+
+        TEST $CLI_1 volume create $vol_name replica 3 $H1:$B1/${vol_name} $H2:$B2/${vol_name} $H3:$B3/${vol_name}
+	TEST $CLI_1 volume start $vol_name
+}
+
+TEST launch_cluster 3
+TEST $CLI_1 volume set all cluster.brick-multiplex on
+
+# The option accepts the value in the range from 5 to 200
+TEST ! $CLI_1 volume set all glusterd.vol_count_per_thread 210
+TEST ! $CLI_1 volume set all glusterd.vol_count_per_thread 4
+
+TEST $CLI_1 volume set all glusterd.vol_count_per_thread 5
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+# Our infrastructure can't handle an arithmetic expression here.  The formula
+# is (NUM_VOLS-1)*5 because it sees each TEST/EXPECT once but needs the other
+# NUM_VOLS-1 and there are 5 such statements in each iteration.
+TESTS_EXPECTED_IN_LOOP=28
+for i in $(seq 1 $NUM_VOLS); do
+        starttime="$(date +%s)";
+	create_volume $i
+done
+
+TEST kill_glusterd 1
+
+TESTS_EXPECTED_IN_LOOP=4
+for i in `seq 1 3 15`
+do
+vol1=$(printf "%s-vol%02d" $V0 $i)
+TEST $CLI_2 volume set $vol1 performance.readdir-ahead on
+done
+
+# Bring back 1st glusterd
+TEST $glusterd_1
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+TESTS_EXPECTED_IN_LOOP=4
+for i in `seq 1 3 15`
+do
+vol1=$(printf "%s-vol%02d" $V0 $i)
+EXPECT_WITHIN $PROBE_TIMEOUT "on" volinfo_field_1 $vol1 performance.readdir-ahead
+done
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-1720566.t b/tests/bugs/glusterd/bug-1720566.t
new file mode 100644
index 00000000000..99bcf6ff785
--- /dev/null
+++ b/tests/bugs/glusterd/bug-1720566.t
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../volume.rc
+
+
+cleanup;
+V0="TestLongVolnamec363b7b536700ff06eedeae0dd9037fec363b7b536700ff06eedeae0dd9037fec363b7b536700ff06eedeae0dd9abcd"
+V1="TestLongVolname3102bd28a16c49440bd5210e4ec4d5d93102bd28a16c49440bd5210e4ec4d5d933102bd28a16c49440bd5210e4ebbcd"
+TEST launch_cluster 2;
+TEST $CLI_1 peer probe $H2;
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+$CLI_1 volume create $V0 $H1:$B1/$V0  $H2:$B2/$V0
+EXPECT 'Created' cluster_volinfo_field 1 $V0 'Status';
+$CLI_1 volume create $V1 $H1:$B1/$V1  $H2:$B2/$V1
+EXPECT 'Created' cluster_volinfo_field 1 $V1 'Status';
+
+$CLI_1 volume start $V0
+EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
+
+$CLI_1 volume start $V1
+EXPECT 'Started' cluster_volinfo_field 1 $V1 'Status';
+
+#Mount FUSE
+TEST glusterfs -s $H1 --volfile-id=$V0 $M0;
+
+
+#Mount FUSE
+TEST glusterfs -s $H1 --volfile-id=$V1 $M1;
+
+TEST mkdir $M0/dir{1..4};
+TEST touch $M0/dir{1..4}/files{1..4};
+
+TEST mkdir $M1/dir{1..4};
+TEST touch $M1/dir{1..4}/files{1..4};
+
+TEST $CLI_1 volume add-brick $V0 $H1:$B1/${V0}_1 $H2:$B2/${V0}_1
+TEST $CLI_1 volume add-brick $V1 $H1:$B1/${V1}_1 $H2:$B2/${V1}_1
+
+
+TEST $CLI_1 volume rebalance $V0 start
+TEST $CLI_1 volume rebalance $V1  start
+
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status_field 1 $V0
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status_field 1  $V1
+
+cleanup;
diff --git a/tests/bugs/glusterd/bug-765230-remove-quota-related-option-after-disabling-quota.t b/tests/bugs/glusterd/bug-765230-remove-quota-related-option-after-disabling-quota.t
deleted file mode 100755
index d943dcf5780..00000000000
--- a/tests/bugs/glusterd/bug-765230-remove-quota-related-option-after-disabling-quota.t
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start and create a volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting soft-timeout as 20
-TEST $CLI volume set $V0 features.soft-timeout 20
-EXPECT '20' volinfo_field $V0 'features.soft-timeout';
-
-## Enabling features.quota-deem-statfs
-TEST ! $CLI volume set $V0 features.quota-deem-statfs on
-EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
-
-## Enabling quota
-TEST $CLI volume quota $V0 enable
-EXPECT 'on' volinfo_field $V0 'features.quota'
-
-## Setting soft-timeout as 20
-TEST $CLI volume set $V0 features.soft-timeout 20
-EXPECT '20' volinfo_field $V0 'features.soft-timeout';
-
-## Enabling features.quota-deem-statfs
-TEST $CLI volume set $V0 features.quota-deem-statfs on
-EXPECT 'on' volinfo_field $V0 'features.quota-deem-statfs'
-
-## Disabling quota
-TEST $CLI volume quota $V0 disable
-EXPECT 'off' volinfo_field $V0 'features.quota'
-EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
-EXPECT '' volinfo_field $V0 'features.soft-timeout'
-
-## Setting soft-timeout as 30
-TEST $CLI volume set $V0 features.soft-timeout 30
-EXPECT '30' volinfo_field $V0 'features.soft-timeout';
-
-## Disabling features.quota-deem-statfs
-TEST ! $CLI volume set $V0 features.quota-deem-statfs off
-EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
-
-## Finish up
-TEST $CLI volume stop $V0
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-782095.t b/tests/bugs/glusterd/bug-782095.t
deleted file mode 100755
index dd8a8dc3026..00000000000
--- a/tests/bugs/glusterd/bug-782095.t
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start and create a volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting performance cache min size as 2MB
-TEST $CLI volume set $V0 performance.cache-min-file-size 2MB
-EXPECT '2MB' volinfo_field $V0 'performance.cache-min-file-size';
-
-## Setting performance cache max size as 20MB
-TEST $CLI volume set $V0 performance.cache-max-file-size 20MB
-EXPECT '20MB' volinfo_field $V0 'performance.cache-max-file-size';
-
-## Trying to set performance cache min size as 25MB
-TEST ! $CLI volume set $V0 performance.cache-min-file-size 25MB
-EXPECT '2MB' volinfo_field $V0 'performance.cache-min-file-size';
-
-## Able to set performance cache min size as long as its lesser than max size
-TEST $CLI volume set $V0 performance.cache-min-file-size 15MB
-EXPECT '15MB' volinfo_field $V0 'performance.cache-min-file-size';
-
-## Trying it out with only cache-max-file-size in CLI as 10MB
-TEST ! $CLI volume set $V0 cache-max-file-size 10MB
-EXPECT '20MB' volinfo_field $V0 'performance.cache-max-file-size';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-824753-file-locker.c b/tests/bugs/glusterd/bug-824753-file-locker.c
index 915161b626b..f5dababad30 100644
--- a/tests/bugs/glusterd/bug-824753-file-locker.c
+++ b/tests/bugs/glusterd/bug-824753-file-locker.c
@@ -5,13 +5,13 @@
 #include <unistd.h>
 #include <stdlib.h>
 
-
-int main (int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-    int              fd            = -1;
-    int              ret           = -1;
-    char             command[2048] = "";
-    char             filepath[255]     = "";
+    int fd = -1;
+    int ret = -1;
+    char command[2048] = "";
+    char filepath[255] = "";
     struct flock fl;
 
     fl.l_type = F_WRLCK;
@@ -36,7 +36,7 @@ int main (int argc, char *argv[])
              " grep %s | awk -F'..: ' '{print $1}' | grep %s:%s/%s",
              argv[1], argv[5], argv[2], argv[2], argv[3], argv[1]);
 
-    ret = system (command);
+    ret = system(command);
     close(fd);
 
     if (ret)
diff --git a/tests/bugs/glusterd/bug-824753.t b/tests/bugs/glusterd/bug-824753.t
index 2ce4a07c5bd..b969e28f35e 100755
--- a/tests/bugs/glusterd/bug-824753.t
+++ b/tests/bugs/glusterd/bug-824753.t
@@ -9,7 +9,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 function volinfo_field()
 {
diff --git a/tests/bugs/glusterd/bug-839595.t b/tests/bugs/glusterd/bug-839595.t
deleted file mode 100644
index b2fe9789a8c..00000000000
--- a/tests/bugs/glusterd/bug-839595.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}1
-TEST $CLI volume set $V0 cluster.server-quorum-type server
-EXPECT "server" volume_option $V0 cluster.server-quorum-type
-TEST $CLI volume set $V0 cluster.server-quorum-type none
-EXPECT "none" volume_option $V0 cluster.server-quorum-type
-TEST $CLI volume reset $V0 cluster.server-quorum-type
-TEST ! $CLI volume set $V0 cluster.server-quorum-type abc
-TEST ! $CLI volume set all cluster.server-quorum-type none
-TEST ! $CLI volume set $V0 cluster.server-quorum-ratio 100
-
-TEST ! $CLI volume set all cluster.server-quorum-ratio abc
-TEST ! $CLI volume set all cluster.server-quorum-ratio -1
-TEST ! $CLI volume set all cluster.server-quorum-ratio 100.0000005
-TEST $CLI volume set all cluster.server-quorum-ratio 0
-EXPECT "0" volume_option $V0 cluster.server-quorum-ratio
-TEST $CLI volume set all cluster.server-quorum-ratio 100
-EXPECT "100" volume_option $V0 cluster.server-quorum-ratio
-TEST $CLI volume set all cluster.server-quorum-ratio 0.0000005
-EXPECT "0.0000005" volume_option $V0 cluster.server-quorum-ratio
-TEST $CLI volume set all cluster.server-quorum-ratio 100%
-EXPECT "100%" volume_option $V0 cluster.server-quorum-ratio
-cleanup;
diff --git a/tests/bugs/glusterd/bug-859927.t b/tests/bugs/glusterd/bug-859927.t
deleted file mode 100755
index c30d2b852d4..00000000000
--- a/tests/bugs/glusterd/bug-859927.t
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-cleanup;
-
-glusterd;
-
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-TEST ! $CLI volume set $V0 statedump-path ""
-TEST ! $CLI volume set $V0 statedump-path "     "
-TEST   $CLI volume set $V0 statedump-path "/home/"
-EXPECT "/home/" volume_option $V0 server.statedump-path
-
-TEST ! $CLI volume set $V0 background-self-heal-count ""
-TEST ! $CLI volume set $V0 background-self-heal-count "      "
-TEST   $CLI volume set $V0 background-self-heal-count 10
-EXPECT "10" volume_option $V0 cluster.background-self-heal-count
-
-TEST ! $CLI volume set $V0 cache-size ""
-TEST ! $CLI volume set $V0 cache-size "    "
-TEST   $CLI volume set $V0 cache-size 512MB
-EXPECT "512MB" volume_option $V0 performance.cache-size
-
-TEST ! $CLI volume set $V0 self-heal-daemon ""
-TEST ! $CLI volume set $V0 self-heal-daemon "    "
-TEST   $CLI volume set $V0 self-heal-daemon on
-EXPECT "on" volume_option $V0 cluster.self-heal-daemon
-
-TEST ! $CLI volume set $V0 read-subvolume ""
-TEST ! $CLI volume set $V0 read-subvolume "    "
-TEST   $CLI volume set $V0 read-subvolume $V0-client-0
-EXPECT "$V0-client-0" volume_option  $V0 cluster.read-subvolume
-
-TEST ! $CLI volume set $V0 data-self-heal-algorithm ""
-TEST ! $CLI volume set $V0 data-self-heal-algorithm "     "
-TEST ! $CLI volume set $V0 data-self-heal-algorithm on
-TEST   $CLI volume set $V0 data-self-heal-algorithm full
-EXPECT "full" volume_option $V0 cluster.data-self-heal-algorithm
-
-TEST ! $CLI volume set $V0 min-free-inodes ""
-TEST ! $CLI volume set $V0 min-free-inodes "     "
-TEST   $CLI volume set $V0 min-free-inodes 60%
-EXPECT "60%" volume_option $V0 cluster.min-free-inodes
-
-TEST ! $CLI volume set $V0 min-free-disk ""
-TEST ! $CLI volume set $V0 min-free-disk "     "
-TEST   $CLI volume set $V0 min-free-disk 60%
-EXPECT "60%" volume_option $V0 cluster.min-free-disk
-
-TEST   $CLI volume set $V0 min-free-disk 120
-EXPECT "120" volume_option $V0 cluster.min-free-disk
-
-TEST ! $CLI volume set $V0 frame-timeout ""
-TEST ! $CLI volume set $V0 frame-timeout "      "
-TEST   $CLI volume set $V0 frame-timeout 0
-EXPECT "0" volume_option $V0 network.frame-timeout
-
-TEST ! $CLI volume set $V0 auth.allow ""
-TEST ! $CLI volume set $V0 auth.allow "       "
-TEST   $CLI volume set $V0 auth.allow 192.168.122.1
-EXPECT "192.168.122.1" volume_option $V0 auth.allow
-
-TEST ! $CLI volume set $V0 stripe-block-size ""
-TEST ! $CLI volume set $V0 stripe-block-size "      "
-TEST   $CLI volume set $V0 stripe-block-size 512MB
-EXPECT "512MB" volume_option $V0 cluster.stripe-block-size
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-862834.t b/tests/bugs/glusterd/bug-862834.t
deleted file mode 100755
index ac2f956a1ed..00000000000
--- a/tests/bugs/glusterd/bug-862834.t
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-V1="patchy2"
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-
-function check_brick()
-{
-        vol=$1;
-        num=$2
-        $CLI volume info $V0 | grep "Brick$num" | awk '{print $2}';
-}
-
-function volinfo_field()
-{
-        local vol=$1;
-        local field=$2;
-
-        $CLI volume info $vol | grep "^$field: " | sed 's/.*: //';
-}
-
-function brick_count()
-{
-        local vol=$1;
-
-        $CLI volume info $vol | egrep "^Brick[0-9]+: " | wc -l;
-}
-
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '2' brick_count $V0
-
-
-EXPECT "$H0:$B0/${V0}1" check_brick $V0 '1';
-EXPECT "$H0:$B0/${V0}2" check_brick $V0 '2';
-
-TEST ! $CLI volume create $V1 $H0:$B0/${V1}0 $H0:$B0/${V0}1;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-878004.t b/tests/bugs/glusterd/bug-878004.t
deleted file mode 100644
index 8abada3c3b3..00000000000
--- a/tests/bugs/glusterd/bug-878004.t
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}2 $H0:$B0/${V0}3;
-
-function brick_count()
-{
-    local vol=$1;
-
-    $CLI volume info $vol | egrep "^Brick[0-9]+: " | wc -l;
-}
-
-
-TEST $CLI volume start $V0
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 force;
-EXPECT '2' brick_count $V0
-
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}3 force;
-EXPECT '1' brick_count $V0
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-888752.t b/tests/bugs/glusterd/bug-888752.t
deleted file mode 100644
index ed0602e34e2..00000000000
--- a/tests/bugs/glusterd/bug-888752.t
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-# Check if xml output is generated correctly for volume status for a single brick
-# present on another peer and no async tasks are running.
-
-function get_peer_count {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-cleanup
-
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 get_peer_count
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-
-TEST $CLI_1 volume status $V0 $H2:$B2/$V0 --xml
-
-TEST $CLI_1 volume stop $V0
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-889630.t b/tests/bugs/glusterd/bug-889630.t
deleted file mode 100755
index 4fefd94d66f..00000000000
--- a/tests/bugs/glusterd/bug-889630.t
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-function volume_count {
-        local cli=$1;
-        if [ $cli -eq '1' ] ; then
-                $CLI_1 volume info | grep 'Volume Name' | wc -l;
-        else
-                $CLI_2 volume info | grep 'Volume Name' | wc -l;
-        fi
-}
-
-cleanup;
-
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-
-b="B1";
-
-#Create an extra file in the originator's volume store
-touch ${!b}/glusterd/vols/$V0/run/file
-
-TEST $CLI_1 volume stop $V0
-#Test for self-commit failure
-TEST $CLI_1 volume delete $V0
-
-#Check whether delete succeeded on both the nodes
-EXPECT "0" volume_count '1'
-EXPECT "0" volume_count '2'
-
-#Check whether the volume name can be reused after deletion
-TEST $CLI_1 volume create $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}1
-TEST $CLI_1 volume start $V0
-
-#Create an extra file in the peer's volume store
-touch ${!b}/glusterd/vols/$V0/run/file
-
-TEST $CLI_1 volume stop $V0
-#Test for commit failure on the other node
-TEST $CLI_2 volume delete $V0
-
-EXPECT "0" volume_count '1';
-EXPECT "0" volume_count '2';
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-905307.t b/tests/bugs/glusterd/bug-905307.t
deleted file mode 100644
index dd1c1bc0795..00000000000
--- a/tests/bugs/glusterd/bug-905307.t
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-TEST glusterd
-TEST pidof glusterd
-
-#test functionality of post-op-delay-secs
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
-
-#Strings should not be accepted.
-TEST ! $CLI volume set $V0 cluster.post-op-delay-secs abc
-
-#-ve ints should not be accepted.
-TEST ! $CLI volume set $V0 cluster.post-op-delay-secs -1
-
-#INT_MAX+1 should not be accepted.
-TEST ! $CLI volume set $V0 cluster.post-op-delay-secs 2147483648
-
-#floats should not be accepted.
-TEST ! $CLI volume set $V0 cluster.post-op-delay-secs 1.25
-
-#min val 0 should be accepted
-TEST $CLI volume set $V0 cluster.post-op-delay-secs 0
-EXPECT "0" volume_option $V0 cluster.post-op-delay-secs
-
-#max val 2147483647 should be accepted
-TEST $CLI volume set $V0 cluster.post-op-delay-secs 2147483647
-EXPECT "2147483647" volume_option $V0 cluster.post-op-delay-secs
-
-#some middle val in range 2147 should be accepted
-TEST $CLI volume set $V0 cluster.post-op-delay-secs 2147
-EXPECT "2147" volume_option $V0 cluster.post-op-delay-secs
-cleanup;
diff --git a/tests/bugs/glusterd/bug-913487.t b/tests/bugs/glusterd/bug-913487.t
deleted file mode 100644
index 9c616ea28fb..00000000000
--- a/tests/bugs/glusterd/bug-913487.t
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd;
-
-TEST ! $CLI volume set $V0 performance.open-behind off;
-
-TEST pidof glusterd;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-913555.t b/tests/bugs/glusterd/bug-913555.t
deleted file mode 100755
index 9bc875340d1..00000000000
--- a/tests/bugs/glusterd/bug-913555.t
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/bash
-
-# Test that a volume becomes unwritable when the cluster loses quorum.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-
-function check_fs {
-	df $1 &> /dev/null
-	echo $?
-}
-
-function check_peers {
-	$CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-function online_brick_count {
-       $CLI_1 --xml volume status | grep '<status>1' | wc -l
-}
-
-cleanup;
-
-TEST launch_cluster 3; # start 3-node virtual cluster
-TEST $CLI_1 peer probe $H2; # peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H3; # peer probe server 3 from server 1 cli
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0 $H3:$B3/$V0
-TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
-TEST $CLI_1 volume start $V0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 online_brick_count;
-
-TEST glusterfs --volfile-server=$H1 --volfile-id=$V0 $M0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
-
-# Kill one pseudo-node, make sure the others survive and volume stays up.
-TEST kill_node 3;
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 2 online_brick_count;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
-
-# Kill another pseudo-node, make sure the last one dies and volume goes down.
-TEST kill_node 2;
-EXPECT_WITHIN $PROBE_TIMEOUT 0 check_peers
-#two glusterfsds of the other two glusterds must be dead
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 online_brick_count;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 check_fs $M0;
-
-TEST $glusterd_2;
-TEST $glusterd_3;
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 3 online_brick_count; # restore quorum, all ok
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
-
-cleanup
diff --git a/tests/bugs/glusterd/bug-916549.t b/tests/bugs/glusterd/bug-916549.t
deleted file mode 100755
index 6e3612dce94..00000000000
--- a/tests/bugs/glusterd/bug-916549.t
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-
-cleanup;
-
-TEST glusterd;
-TEST $CLI volume create $V0 $H0:$B0/${V0}1;
-TEST $CLI volume start $V0;
-
-pid_file=$(ls $GLUSTERD_PIDFILEDIR/vols/$V0/);
-brick_pid=$(cat $GLUSTERD_PIDFILEDIR/vols/$V0/$pid_file);
-
-
-kill -SIGKILL $brick_pid;
-TEST $CLI volume start $V0 force;
-TEST process_leak_count $(pidof glusterd);
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-948686.t b/tests/bugs/glusterd/bug-948686.t
deleted file mode 100755
index dfe11ff153f..00000000000
--- a/tests/bugs/glusterd/bug-948686.t
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-    $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-cleanup;
-#setup cluster and test volume
-TEST launch_cluster 3; # start 3-node virtual cluster
-TEST $CLI_1 peer probe $H2; # peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H3; # peer probe server 3 from server 1 cli
-
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers;
-
-TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/$V0 $H1:$B1/${V0}_1 $H2:$B2/$V0 $H3:$B3/$V0
-TEST $CLI_1 volume start $V0
-TEST glusterfs --volfile-server=$H1 --volfile-id=$V0 $M0
-
-#kill a node
-TEST kill_node 3
-
-#modify volume config to see change in volume-sync
-TEST $CLI_1 volume set $V0 write-behind off
-#add some files to the volume to see effect of volume-heal cmd
-TEST touch $M0/{1..100};
-TEST $CLI_1 volume stop $V0;
-TEST $glusterd_3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers;
-TEST $CLI_3 volume start $V0;
-TEST $CLI_2 volume stop $V0;
-TEST $CLI_2 volume delete $V0;
-
-cleanup;
-
-TEST glusterd;
-TEST $CLI volume create $V0 $H0:$B0/$V0
-TEST $CLI volume start $V0
-pkill glusterd;
-pkill glusterfsd;
-TEST glusterd
-TEST $CLI volume status $V0
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-955588.t b/tests/bugs/glusterd/bug-955588.t
deleted file mode 100755
index 028a34edd7d..00000000000
--- a/tests/bugs/glusterd/bug-955588.t
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-TEST glusterd
-TEST pidof glusterd
-
-function get_brick_host_uuid()
-{
-    local vol=$1;
-    local uuid_regex='[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
-    local host_uuid_list=$($CLI volume info $vol --xml | grep "brick.uuid" | grep -o -E "$uuid_regex");
-
-    echo $host_uuid_list | awk '{print $1}'
-}
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
-
-uuid=`grep UUID $GLUSTERD_WORKDIR/glusterd.info | cut -f2 -d=`
-EXPECT $uuid get_brick_host_uuid $V0
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-958790.t b/tests/bugs/glusterd/bug-958790.t
deleted file mode 100644
index 39be0a19137..00000000000
--- a/tests/bugs/glusterd/bug-958790.t
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume info;
-
-touch $GLUSTERD_WORKDIR/groups/test
-echo "read-ahead=off" > $GLUSTERD_WORKDIR/groups/test
-echo "open-behind=off" >> $GLUSTERD_WORKDIR/groups/test
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume set $V0 group test
-EXPECT "off" volume_option $V0 performance.read-ahead
-EXPECT "off" volume_option $V0 performance.open-behind
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-961669.t b/tests/bugs/glusterd/bug-961669.t
deleted file mode 100644
index b02f2f50af1..00000000000
--- a/tests/bugs/glusterd/bug-961669.t
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/bash
-
-#Test case: Fail remove-brick 'start' variant when reducing the replica count of a volume.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-#Create a 3x3 dist-rep volume
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5,6,7,8};
-TEST $CLI volume start $V0
-
-# Mount FUSE and create file/directory
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-TEST touch $M0/zerobytefile.txt
-TEST mkdir $M0/test_dir
-TEST dd if=/dev/zero of=$M0/file bs=1024 count=1024
-
-function remove_brick_start {
-        $CLI volume remove-brick $V0 replica 2 $H0:$B0/${V0}{1,4,7} start 2>&1|grep -oE 'success|failed'
-}
-
-function remove_brick {
-        $CLI volume remove-brick $V0 replica 2 $H0:$B0/${V0}{1,4,7} force 2>&1|grep -oE 'success|failed'
-}
-
-#remove-brick start variant
-#Actual message displayed at cli is:
-#"volume remove-brick start: failed: Rebalancing not needed when reducing replica count. Try without the 'start' option"
-EXPECT "failed" remove_brick_start;
-
-#remove-brick commit-force
-#Actual message displayed at cli is:
-#"volume remove-brick commit force: success"
-EXPECT "success" remove_brick
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterd/bug-963541.t b/tests/bugs/glusterd/bug-963541.t
deleted file mode 100755
index ff94db3e6ef..00000000000
--- a/tests/bugs/glusterd/bug-963541.t
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1..3};
-TEST $CLI volume start $V0;
-
-# Start a remove-brick and try to start a rebalance/remove-brick without committing
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
-
-TEST ! $CLI volume rebalance $V0 start
-TEST ! $CLI volume remove-brick $V0 $H0:$B0/${V0}2 start
-
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field \
-"$V0" "$H0:$B0/${V0}1"
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 commit
-
-gluster volume status
-
-TEST $CLI volume rebalance $V0 start
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
-TEST $CLI volume rebalance $V0 stop
-
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 start
-TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 stop
-
-TEST $CLI volume stop $V0
-
-cleanup;
-
diff --git a/tests/bugs/glusterd/bug-964059.t b/tests/bugs/glusterd/bug-964059.t
deleted file mode 100755
index 7b4f60454b8..00000000000
--- a/tests/bugs/glusterd/bug-964059.t
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../cluster.rc
-
-function check_peers {
-        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
-}
-
-function volume_count {
-        local cli=$1;
-        if [ $cli -eq '1' ] ; then
-                $CLI_1 volume info | grep 'Volume Name' | wc -l;
-        else
-                $CLI_2 volume info | grep 'Volume Name' | wc -l;
-        fi
-}
-
-cleanup;
-
-TEST launch_cluster 2;
-TEST $CLI_1 peer probe $H2;
-
-EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
-
-TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
-TEST $CLI_1 volume start $V0
-TEST $CLI_1 volume remove-brick $V0 $H2:$B2/$V0 start
-TEST $CLI_1 volume status
-cleanup;
diff --git a/tests/bugs/glusterd/check_elastic_server.t b/tests/bugs/glusterd/check_elastic_server.t
new file mode 100644
index 00000000000..41d2140aa2b
--- /dev/null
+++ b/tests/bugs/glusterd/check_elastic_server.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../volume.rc
+
+function cluster_rebalance_status {
+        local vol=$1
+        $CLI_2 volume status | grep -iw "Rebalance" -A 5 | grep "Status" | sed 's/.*: //'
+}
+
+cleanup;
+TEST launch_cluster 4;
+TEST $CLI_1 peer probe $H2;
+TEST $CLI_1 peer probe $H3;
+TEST $CLI_1 peer probe $H4;
+
+EXPECT_WITHIN $PROBE_TIMEOUT 3 peer_count
+
+TEST $CLI_1 volume create $V0 $H1:$B1/$V0  $H2:$B2/$V0
+EXPECT 'Created' cluster_volinfo_field 1 $V0 'Status';
+
+$CLI_1 volume start $V0
+EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
+
+#Mount invalid volume
+TEST ! glusterfs -s $H1 --volfile-id=$V0_NA $M0;
+
+#Mount FUSE
+TEST glusterfs -s $H1 --volfile-id=$V0 $M0;
+
+TEST mkdir $M0/dir{1..4};
+TEST touch $M0/dir{1..4}/files{1..4};
+
+TEST $CLI_1 volume remove-brick $V0 $H1:$B1/$V0 start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_remove_brick_status_completed_field "$V0 $H1:$B1/$V0"
+
+TEST $CLI_1 volume remove-brick $V0 $H1:$B1/$V0 commit
+
+kill_glusterd 1
+
+total_files=`find $M0 -name "files*" | wc -l`
+TEST [ $total_files -eq 16 ];
+
+TEST $CLI_2 volume add-brick $V0 $H3:$B3/$V0
+
+TEST $CLI_2 volume rebalance $V0  start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status $V0
+
+total_files=`find $M0 -name "files*" | wc -l`
+TEST [ $total_files -eq 16 ];
+
+TEST $CLI_2 volume add-brick $V0 $H4:$B4/$V0
+
+TEST $CLI_2 volume rebalance $V0  start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status $V0
+kill_glusterd 2
+
+total_files=`find $M0 -name "files*" | wc -l`
+TEST [ $total_files -eq 16 ];
+
+cleanup;
+
diff --git a/tests/bugs/glusterd/daemon-log-level-option.t b/tests/bugs/glusterd/daemon-log-level-option.t
new file mode 100644
index 00000000000..66e55e3d758
--- /dev/null
+++ b/tests/bugs/glusterd/daemon-log-level-option.t
@@ -0,0 +1,93 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+
+function Info_messages_count() {
+        local shd_log=$1
+        cat $shd_log | grep " I " | wc -l
+}
+
+function Warning_messages_count() {
+        local shd_log=$1
+        cat $shd_log | grep " W " | wc -l
+}
+
+function Debug_messages_count() {
+        local shd_log=$1
+        cat $shd_log | grep " D " | wc -l
+}
+
+function Trace_messages_count() {
+        local shd_log=$1
+        cat $shd_log | grep " T " | wc -l
+}
+
+cleanup;
+
+# Basic checks
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+# set cluster.daemon-log-level option to DEBUG
+TEST $CLI volume set all cluster.daemon-log-level DEBUG
+
+#Create a 3X2 distributed-replicate volume
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1..6};
+TEST $CLI volume start $V0
+
+# log should not have any trace messages
+EXPECT 0 Trace_messages_count "/var/log/glusterfs/glustershd.log"
+
+# stop the volume and remove glustershd log
+TEST $CLI volume stop $V0
+rm -f /var/log/glusterfs/glustershd.log
+
+# set cluster.daemon-log-level option to INFO and start the volume
+TEST $CLI volume set all cluster.daemon-log-level INFO
+TEST $CLI volume start $V0
+
+# log should not have any debug messages
+EXPECT 0 Debug_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any trace messages
+EXPECT 0 Trace_messages_count "/var/log/glusterfs/glustershd.log"
+
+# stop the volume and remove glustershd log
+TEST $CLI volume stop $V0
+rm -f /var/log/glusterfs/glustershd.log
+
+# set cluster.daemon-log-level option to WARNING and start the volume
+TEST $CLI volume set all cluster.daemon-log-level WARNING
+TEST $CLI volume start $V0
+
+# log should not have any info messages
+EXPECT 0 Info_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any debug messages
+EXPECT 0 Debug_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any trace messages
+EXPECT 0 Trace_messages_count "/var/log/glusterfs/glustershd.log"
+
+# stop the volume and remove glustershd log
+TEST $CLI volume stop $V0
+rm -f /var/log/glusterfs/glustershd.log
+
+# set cluster.daemon-log-level option to ERROR and start the volume
+TEST $CLI volume set all cluster.daemon-log-level ERROR
+TEST $CLI volume start $V0
+
+# log should not have any info messages
+EXPECT 0 Info_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any warning messages
+EXPECT 0 Warning_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any debug messages
+EXPECT 0 Debug_messages_count "/var/log/glusterfs/glustershd.log"
+
+# log should not have any trace messages
+EXPECT 0 Trace_messages_count "/var/log/glusterfs/glustershd.log"
+
+cleanup
diff --git a/tests/bugs/glusterd/df-results-post-replace-brick-operations.t b/tests/bugs/glusterd/df-results-post-replace-brick-operations.t
new file mode 100644
index 00000000000..04f75889388
--- /dev/null
+++ b/tests/bugs/glusterd/df-results-post-replace-brick-operations.t
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+TEST glusterd
+
+#Create brick partitions
+TEST truncate -s 100M $B0/brick1
+TEST truncate -s 100M $B0/brick2
+TEST truncate -s 100M $B0/brick3
+TEST truncate -s 100M $B0/brick4
+TEST truncate -s 100M $B0/brick5
+
+LO1=`SETUP_LOOP $B0/brick1`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO1
+
+LO2=`SETUP_LOOP $B0/brick2`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO2
+
+LO3=`SETUP_LOOP $B0/brick3`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO3
+
+LO4=`SETUP_LOOP $B0/brick4`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO4
+
+LO5=`SETUP_LOOP $B0/brick5`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO5
+
+TEST mkdir -p $B0/${V0}1 $B0/${V0}2 $B0/${V0}3 $B0/${V0}4 $B0/${V0}5
+TEST MOUNT_LOOP $LO1 $B0/${V0}1
+TEST MOUNT_LOOP $LO2 $B0/${V0}2
+TEST MOUNT_LOOP $LO3 $B0/${V0}3
+TEST MOUNT_LOOP $LO4 $B0/${V0}4
+TEST MOUNT_LOOP $LO5 $B0/${V0}5
+
+# create a subdirectory in mount point and use it for volume creation
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}1/brick1 $H0:$B0/${V0}2/brick1 $H0:$B0/${V0}3/brick1
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "3" online_brick_count
+
+# mount the volume and check the size at mount point
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+total_space=$(df -P $M0 | tail -1 | awk '{ print $2}')
+
+# perform replace brick operations
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}1/brick1 $H0:$B0/${V0}4/brick1 commit force
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}2/brick1 $H0:$B0/${V0}5/brick1 commit force
+
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+# check for the size at mount point, it should be same as previous
+total_space_new=$(df -P $M0 | tail -1 | awk '{ print $2}')
+TEST [ $total_space -eq $total_space_new ]
diff --git a/tests/bugs/glusterd/mgmt-handshake-and-volume-sync-post-glusterd-restart.t b/tests/bugs/glusterd/mgmt-handshake-and-volume-sync-post-glusterd-restart.t
new file mode 100644
index 00000000000..8001359e6b3
--- /dev/null
+++ b/tests/bugs/glusterd/mgmt-handshake-and-volume-sync-post-glusterd-restart.t
@@ -0,0 +1,71 @@
+#! /bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+function check_peers {
+eval \$CLI_$1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup
+
+TEST launch_cluster 3
+
+TEST $CLI_1 peer probe $H2
+
+#bug-1109741 - validate mgmt handshake
+
+TEST ! $CLI_3 peer probe $H1
+
+GD1_WD=$($CLI_1 system getwd)
+OP_VERS_ORIG=$(grep 'operating-version' ${GD1_WD}/glusterd.info | cut -d '=' -f 2)
+
+TEST $CLI_3 system uuid get # Needed for glusterd.info to be created
+
+GD3_WD=$($CLI_3 system getwd)
+TEST sed -rnie "'s/(operating-version=)\w+/\130600/gip'" ${GD3_WD}/glusterd.info
+
+TEST kill_glusterd 3
+TEST start_glusterd 3
+
+TEST ! $CLI_3 peer probe $H1
+
+OP_VERS_NEW=$(grep 'operating-version' ${GD1_WD}/glusterd.info | cut -d '=' -f 2)
+TEST [[ $OP_VERS_ORIG == $OP_VERS_NEW ]]
+
+#bug-948686 - volume sync after bringing up the killed node
+
+TEST $CLI_1 peer probe $H3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 1
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 2
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 3
+
+TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/$V0 $H1:$B1/${V0}_1 $H2:$B2/$V0 $H3:$B3/$V0
+TEST $CLI_1 volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field_1 $V0 'Status'
+TEST glusterfs --volfile-server=$H1 --volfile-id=$V0 $M0
+
+#kill a node
+TEST kill_node 3
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers 1
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers 2
+
+#modify volume config to see change in volume-sync
+TEST $CLI_1 volume set $V0 write-behind off
+#add some files to the volume to see effect of volume-heal cmd
+TEST touch $M0/{1..100};
+TEST $CLI_1 volume stop $V0;
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 'Stopped' volinfo_field_1 $V0 'Status'
+
+TEST $glusterd_3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 1
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 2
+EXPECT_WITHIN $PROBE_TIMEOUT 2 check_peers 3
+
+sleep 5
+TEST $CLI_3 volume start $V0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field_1 $V0 'Status'
+TEST $CLI_2 volume stop $V0;
+TEST $CLI_2 volume delete $V0;
+
+cleanup
diff --git a/tests/bugs/glusterd/optimized-basic-testcases-in-cluster.t b/tests/bugs/glusterd/optimized-basic-testcases-in-cluster.t
new file mode 100644
index 00000000000..99272e14245
--- /dev/null
+++ b/tests/bugs/glusterd/optimized-basic-testcases-in-cluster.t
@@ -0,0 +1,115 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../volume.rc
+
+function peer_count {
+eval \$CLI_$1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup;
+
+#bug-1454418 -  Setting Port number in specific range
+sysctl net.ipv4.ip_local_reserved_ports="24007-24008,32765-32768,49152-49156"
+
+TEST launch_cluster 4;
+
+#bug-1223213
+
+# Fool the cluster to operate with 3.5 version even though binary's op-version
+# is > 3.5. This is to ensure 3.5 code path is hit to test that volume status
+# works when a node is upgraded from 3.5 to 3.7 or higher as mgmt_v3 lock is
+# been introduced in 3.6 version and onwards
+
+GD1_WD=$($CLI_1 system getwd)
+$CLI_1 system uuid get
+Old_op_version=$(cat ${GD1_WD}/glusterd.info | grep operating-version | cut -d '=' -f 2)
+
+TEST sed -rnie "'s/(operating-version=)\w+/\130500/gip'" ${GD1_WD}/glusterd.info
+
+TEST kill_glusterd 1
+TEST start_glusterd 1
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
+
+TEST `sed -i "s/"30500"/${Old_op_version}/g" ${GD1_WD}/glusterd.info`
+
+TEST kill_glusterd 1
+TEST start_glusterd 1
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 2
+
+#bug-1454418
+sysctl net.ipv4.ip_local_reserved_ports="
+"
+
+TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
+TEST $CLI_1 volume start $V0
+
+#bug-888752 - volume status --xml from peer in the cluster
+
+TEST $CLI_1 volume status $V0 $H2:$B2/$V0 --xml
+
+TEST $CLI_1 volume stop $V0
+TEST $CLI_1 volume delete $V0
+
+TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
+TEST $CLI_1 volume create $V1 $H1:$B1/$V1
+
+# bug - 1635820
+# rebooting a node which doen't host bricks for any one volume
+# peer should not go into rejected state
+TEST kill_glusterd 2
+TEST start_glusterd 2
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 2
+
+TEST $CLI_1 volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field_1 $V0 'Status'
+
+TEST $CLI_1 volume start $V1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 'Started' volinfo_field_1 $V1 'Status'
+
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
+
+TEST $CLI_1 peer probe $H4;
+EXPECT_WITHIN $PROBE_TIMEOUT 3 peer_count 1
+
+#bug-1173414 - validate mgmt-v3-remote-lock-failure
+
+for i in {1..20}
+do
+$CLI_1 volume set $V0 diagnostics.client-log-level DEBUG &
+$CLI_1 volume set $V1 barrier on
+$CLI_2 volume set $V0 diagnostics.client-log-level DEBUG &
+$CLI_2 volume set $V1 barrier on
+done
+
+EXPECT_WITHIN $PROBE_TIMEOUT 3 peer_count 1
+TEST $CLI_1 volume status
+TEST $CLI_2 volume status
+
+#bug-1293414 - validate peer detach
+
+# peers hosting bricks cannot be detached
+TEST ! $CLI_4 peer detach $H1
+EXPECT_WITHIN $PROBE_TIMEOUT 3 peer_count 1
+
+# peer not hosting bricks should be detachable
+TEST $CLI_4 peer detach $H3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
+
+#bug-1344407 - deleting a volume when peer is down should fail
+
+#volume should be stopped before deletion
+TEST $CLI_1 volume stop $V0
+
+TEST kill_glusterd 2
+TEST ! $CLI_1 volume delete $V0
+
+cleanup
diff --git a/tests/bugs/glusterd/optimized-basic-testcases.t b/tests/bugs/glusterd/optimized-basic-testcases.t
new file mode 100644
index 00000000000..b89ca22415e
--- /dev/null
+++ b/tests/bugs/glusterd/optimized-basic-testcases.t
@@ -0,0 +1,305 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+
+function get_opret_value () {
+  local VOL=$1
+  $CLI volume info $VOL --xml | sed -ne 's/.*<opRet>\([-0-9]*\)<\/opRet>/\1/p'
+}
+
+function check_brick()
+{
+        vol=$1;
+        num=$2
+        $CLI volume info $V0 | grep "Brick$num" | awk '{print $2}';
+}
+
+function brick_count()
+{
+        local vol=$1;
+
+        $CLI volume info $vol | egrep "^Brick[0-9]+: " | wc -l;
+}
+
+function get_brick_host_uuid()
+{
+    local vol=$1;
+    local uuid_regex='[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
+    local host_uuid_list=$($CLI volume info $vol --xml | grep "brick.uuid" | grep -o -E "$uuid_regex");
+
+    echo $host_uuid_list | awk '{print $1}'
+}
+
+function generate_statedump_and_check_for_glusterd_info {
+        pid=`pidof glusterd`
+        #remove old stale statedumps
+        cleanup_statedump $pid
+        kill -USR1 $pid
+        #Wait till the statedump is generated
+        sleep 1
+        fname=$(ls $statedumpdir | grep -E "\.$pid\.dump\.")
+        cat $statedumpdir/$fname | grep "xlator.glusterd.priv" | wc -l
+}
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+
+#bug-1238135-lazy-daemon-initialization-on-demand
+
+GDWD=$($CLI system getwd)
+
+# glusterd.info file will be created on either first peer probe or volume
+# creation, hence we expect file to be not present in this case
+TEST ! -e $GDWD/glusterd.info
+
+#bug-913487 - setting volume options before creation of volume should fail
+
+TEST ! $CLI volume set $V0 performance.open-behind off;
+TEST pidof glusterd;
+
+#bug-1433578 - glusterd should not crash after probing a invalid peer
+
+TEST ! $CLI peer probe invalid-peer
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+#bug-1786478 - default volume option after volume reset
+addr_family=`volinfo_field $V0 'transport.address-family'`
+TEST $CLI volume reset $V0
+EXPECT $addr_family  volinfo_field $V0 'transport.address-family'
+
+#bug-955588 - uuid validation
+
+uuid=`grep UUID $GLUSTERD_WORKDIR/glusterd.info | cut -f2 -d=`
+EXPECT $uuid get_brick_host_uuid $V0
+TEST $CLI volume delete $V0;
+TEST ! $CLI volume info $V0;
+
+#bug-958790 - set options from file
+
+touch $GLUSTERD_WORKDIR/groups/test
+echo "read-ahead=off" > $GLUSTERD_WORKDIR/groups/test
+echo "open-behind=off" >> $GLUSTERD_WORKDIR/groups/test
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
+TEST $CLI volume set $V0 group test
+EXPECT "off" volume_option $V0 performance.read-ahead
+EXPECT "off" volume_option $V0 performance.open-behind
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+#bug-1321836 - validate opret value for non existing volume
+
+EXPECT 0 get_opret_value $V0
+EXPECT -1 get_opret_value "novol"
+
+EXPECT '2' brick_count $V0
+
+#bug-862834 - validate brick status
+
+EXPECT "$H0:$B0/${V0}1" check_brick $V0 '1';
+EXPECT "$H0:$B0/${V0}2" check_brick $V0 '2';
+
+TEST ! $CLI volume create $V1 $H0:$B0/${V1}0 $H0:$B0/${V0}1;
+
+#bug-1482344 - setting volume-option-at-cluster-level should not result in glusterd crash
+
+TEST ! $CLI volume set all transport.listen-backlog 128
+
+# Check the volume info output, if glusterd would have crashed then this command
+# will fail
+TEST $CLI volume info $V0;
+
+#bug-1002556 and bug-1199451 - command should retrieve current op-version of the node
+TEST $CLI volume get all cluster.op-version
+
+#bug-1315186 - reject-lowering-down-op-version
+
+OP_VERS_ORIG=$(grep 'operating-version' ${GDWD}/glusterd.info | cut -d '=' -f 2)
+OP_VERS_NEW=`expr $OP_VERS_ORIG-1`
+
+TEST ! $CLI volume set all $V0 cluster.op-version $OP_VERS_NEW
+
+#bug-1022055 - validate log rotate command
+
+TEST ! $CLI volume log rotate $V0;
+TEST $CLI volume log $V0 rotate;
+
+#bug-1092841 - validating barrier enable/disable
+
+TEST $CLI volume barrier $V0 enable;
+TEST ! $CLI volume barrier $V0 enable;
+
+TEST $CLI volume barrier $V0 disable;
+TEST ! $CLI volume barrier $V0 disable;
+
+#bug-1095097 - validate volume profile command
+
+TEST $CLI volume profile $V0 start
+TEST $CLI volume profile $V0 info
+
+#bug-839595 - validate server-quorum options
+
+TEST $CLI volume set $V0 cluster.server-quorum-type server
+EXPECT "server" volume_option $V0 cluster.server-quorum-type
+TEST $CLI volume set $V0 cluster.server-quorum-type none
+EXPECT "none" volume_option $V0 cluster.server-quorum-type
+TEST $CLI volume reset $V0 cluster.server-quorum-type
+TEST ! $CLI volume set $V0 cluster.server-quorum-type abc
+TEST ! $CLI volume set all cluster.server-quorum-type none
+TEST ! $CLI volume set $V0 cluster.server-quorum-ratio 100
+
+TEST ! $CLI volume set all cluster.server-quorum-ratio abc
+TEST ! $CLI volume set all cluster.server-quorum-ratio -1
+TEST ! $CLI volume set all cluster.server-quorum-ratio 100.0000005
+TEST $CLI volume set all cluster.server-quorum-ratio 0
+EXPECT "0" volume_option $V0 cluster.server-quorum-ratio
+TEST $CLI volume set all cluster.server-quorum-ratio 100
+EXPECT "100" volume_option $V0 cluster.server-quorum-ratio
+TEST $CLI volume set all cluster.server-quorum-ratio 0.0000005
+EXPECT "0.0000005" volume_option $V0 cluster.server-quorum-ratio
+TEST $CLI volume set all cluster.server-quorum-ratio 100%
+EXPECT "100%" volume_option $V0 cluster.server-quorum-ratio
+
+#bug-1265479 - validate-distributed-volume-options
+
+#Setting data-self-heal option on for distribute volume
+TEST ! $CLI volume set $V0 data-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.data-self-heal';
+TEST ! $CLI volume set $V0 cluster.data-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.data-self-heal';
+
+#Setting metadata-self-heal option on for distribute volume
+TEST ! $CLI volume set $V0 metadata-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.metadata-self-heal';
+TEST ! $CLI volume set $V0 cluster.metadata-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.metadata-self-heal';
+
+#Setting entry-self-heal option on for distribute volume
+TEST ! $CLI volume set $V0 entry-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.entrydata-self-heal';
+TEST ! $CLI volume set $V0 cluster.entry-self-heal on
+EXPECT '' volinfo_field $V0 'cluster.entrydata-self-heal';
+
+#bug-1163108 - validate min-free-disk-option
+
+## Setting invalid value for option cluster.min-free-disk should fail
+TEST ! $CLI volume set $V0 min-free-disk ""
+TEST ! $CLI volume set $V0 min-free-disk 143.!/12
+TEST ! $CLI volume set $V0 min-free-disk 123%
+TEST ! $CLI volume set $V0 min-free-disk 194.34%
+
+## Setting fractional value as a size (unit is byte) for option
+## cluster.min-free-disk should fail
+TEST ! $CLI volume set $V0 min-free-disk 199.051
+TEST ! $CLI volume set $V0 min-free-disk 111.999
+
+## Setting valid value for option cluster.min-free-disk should pass
+TEST  $CLI volume set $V0 min-free-disk 12%
+TEST  $CLI volume set $V0 min-free-disk 56.7%
+TEST  $CLI volume set $V0 min-free-disk 120
+TEST  $CLI volume set $V0 min-free-disk 369.0000
+
+#bug-1179175-uss-option-validation
+
+## Set features.uss option with non-boolean value. These non-boolean value
+## for features.uss option should fail.
+TEST ! $CLI volume set $V0 features.uss abcd
+TEST ! $CLI volume set $V0 features.uss #$#$
+TEST ! $CLI volume set $V0 features.uss 2324
+
+## Setting other options with valid value. These options should succeed.
+TEST $CLI volume set $V0 barrier enable
+TEST $CLI volume set $V0 ping-timeout 60
+
+## Set features.uss option with valid boolean value. It should succeed.
+TEST  $CLI volume set $V0 features.uss enable
+TEST  $CLI volume set $V0 features.uss disable
+
+
+## Setting other options with valid value. These options should succeed.
+TEST $CLI volume set $V0 barrier enable
+TEST $CLI volume set $V0 ping-timeout 60
+
+#bug-1209329 - daemon-svcs-on-reset-volume
+
+##enable the bitrot and verify bitd is running or not
+TEST $CLI volume bitrot $V0 enable
+EXPECT 'on' volinfo_field $V0 'features.bitrot'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
+
+##Do reset force which set the bitrot options to default
+TEST $CLI volume reset $V0 force;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_bitd_count
+
+##enable the uss option and verify snapd is running or not
+TEST $CLI volume set $V0 features.uss on
+EXPECT 'on' volinfo_field $V0 'features.uss'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_snapd_count
+
+##Do reset force which set the uss options to default
+TEST $CLI volume reset $V0 force;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_snapd_count
+
+##verify initial nfs disabled by default
+EXPECT "0" get_nfs_count
+
+##enable nfs and verify
+TEST $CLI volume set $V0 nfs.disable off
+EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available
+EXPECT "1" get_nfs_count
+
+##Do reset force which set the nfs.option to default
+TEST $CLI volume reset $V0 force;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_nfs_count
+
+##enable the uss option and verify snapd is running or not
+TEST $CLI volume set $V0 features.uss on
+EXPECT 'on' volinfo_field $V0 'features.uss'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_snapd_count
+
+##Disable the uss option using set command and verify snapd
+TEST $CLI volume set $V0 features.uss  off
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_snapd_count
+
+##enable nfs.disable and verify
+TEST $CLI volume set $V0 nfs.disable on
+EXPECT 'on' volinfo_field $V0 'nfs.disable'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" get_nfs_count
+
+## disable nfs.disable option using set command
+TEST $CLI volume set $V0 nfs.disable  off
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_nfs_count
+
+TEST $CLI volume info;
+TEST $CLI volume create $V1 $H0:$B0/${V1}1
+TEST $CLI volume start $V1
+pkill glusterd;
+pkill glusterfsd;
+TEST glusterd
+TEST $CLI volume status $V1
+
+#bug-853601 - Avoid using /var/lib/glusterd as a brick
+TEST ! $CLI volume create "test" $H0:/var/lib/glusterd
+TEST ! $CLI volume create "test" $H0:/var/lib/glusterd force
+TEST ! $CLI volume create "test" $H0:/var/lib/glusterd/abc
+TEST ! $CLI volume create "test" $H0:/var/lib/glusterd/abc force
+mkdir -p /xyz/var/lib/glusterd/abc
+
+#bug 1716812 - volfile should be created with transport type both
+TEST  $CLI volume create "test" transport tcp,rdma $H0:/xyz/var/lib/glusterd/abc
+EXPECT 'Created' volinfo_field "test" 'Status';
+
+#While taking a statedump, there is a TRY_LOCK on call_frame, which might may cause
+#failure. So Adding a EXPECT_WITHIN
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" generate_statedump_and_check_for_glusterd_info
+
+cleanup_statedump `pidof glusterd`
+cleanup
diff --git a/tests/bugs/glusterd/quorum-validation.t b/tests/bugs/glusterd/quorum-validation.t
new file mode 100644
index 00000000000..3cc3351b43b
--- /dev/null
+++ b/tests/bugs/glusterd/quorum-validation.t
@@ -0,0 +1,122 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+cleanup;
+
+TEST launch_cluster 2
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 volume create $V0 $H1:$B1/${V0}0 $H2:$B2/${V0}1
+TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
+TEST $CLI_1 volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}1
+
+#bug-1177132 - sync server quorum options when a node is brought up
+TEST $CLI_1 volume set all cluster.server-quorum-ratio 52
+
+#Bring down 2nd glusterd
+TEST kill_glusterd 2
+EXPECT_WITHIN $PROBE_TIMEOUT 0 peer_count
+
+#bug-1104642 - sync server quorum options when a node is brought up
+#set the volume all options from the 1st glusterd
+TEST $CLI_1 volume set all cluster.server-quorum-ratio 80
+
+# Now quorum is not meet. Add-brick, Remove-brick, volume-set command
+#(Command based on syncop framework)should fail
+TEST ! $CLI_1 volume add-brick $V0 $H1:$B1/${V0}2
+TEST ! $CLI_1 volume remove-brick $V0 $H1:$B1/${V0}0 start
+TEST ! $CLI_1 volume set $V0 barrier enable
+
+#quorum is not met, rebalance/profile start should fail
+TEST ! $CLI_1 volume rebalance $V0 start
+TEST ! $CLI_1 volume profile $V0 start
+
+#bug-1690753 - Volume stop when quorum not met is successful
+TEST ! $CLI_1 volume stop $V0
+
+#Bring back the 2nd glusterd
+TEST $glusterd_2
+
+#verify whether the value has been synced
+EXPECT_WITHIN $PROBE_TIMEOUT "80" volinfo_field_1 all cluster.server-quorum-ratio
+EXPECT_WITHIN $PROBE_TIMEOUT '1' peer_count
+EXPECT_WITHIN $PROBE_TIMEOUT "80" volinfo_field_2 all cluster.server-quorum-ratio
+
+# Now quorum is meet.
+# Add-brick, Remove-brick, volume-set command should success
+TEST  $CLI_1 volume add-brick $V0 $H2:$B2/${V0}2
+TEST  $CLI_1 volume remove-brick $V0 $H2:$B2/${V0}2 start
+TEST  $CLI_1 volume set $V0 barrier enable
+TEST  $CLI_1 volume remove-brick $V0 $H2:$B2/${V0}2 stop
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}1
+
+## Stop the volume
+TEST $CLI_1 volume stop $V0
+
+## Bring down 2nd glusterd
+TEST kill_glusterd 2
+
+## Now quorum is not meet. Starting volume on 1st node should not success
+TEST ! $CLI_1 volume start $V0
+
+## Bring back 2nd glusterd
+TEST $glusterd_2
+
+# After 2nd glusterd come back, there will be 2 nodes in a cluster
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
+
+## Now quorum is meet. Starting volume on 1st node should be success.
+TEST $CLI_1 volume start $V0
+
+# Now re-execute the same profile command and this time it should succeed
+TEST $CLI_1 volume profile $V0 start
+
+#bug-1352277
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}1
+
+TEST $CLI_1 volume set $V0 cluster.server-quorum-type none
+
+# Bring down all the gluster processes
+TEST killall_gluster
+
+#bring back 1st glusterd and check whether the brick process comes back
+TEST $glusterd_1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+
+#enabling quorum should bring down the brick
+TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+
+TEST $glusterd_2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}1
+
+#bug-1367478 - brick processes should not be up when quorum is not met
+TEST $CLI_1 volume create $V1 $H1:$B1/${V1}1 $H2:$B2/${V1}2
+TEST $CLI_1 volume start $V1
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V1 $H1 $B1/${V1}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V1 $H2 $B2/${V1}2
+
+# Restart 2nd glusterd
+TEST kill_glusterd 2
+TEST $glusterd_2
+
+# Check if all bricks are up
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V1 $H1 $B1/${V1}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V1 $H2 $B2/${V1}2
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-1245142-rebalance_test.t b/tests/bugs/glusterd/rebalance-in-cluster.t
index a28810ea71c..469ec6cd48e 100644
--- a/tests/bugs/glusterd/bug-1245142-rebalance_test.t
+++ b/tests/bugs/glusterd/rebalance-in-cluster.t
@@ -4,6 +4,9 @@
 . $(dirname $0)/../../cluster.rc
 . $(dirname $0)/../../volume.rc
 
+function rebalance_status_field_1 {
+        $CLI_1 volume rebalance $1 status | awk '{print $7}' | sed -n 3p
+}
 
 cleanup;
 TEST launch_cluster 2;
@@ -17,6 +20,26 @@ EXPECT 'Created' cluster_volinfo_field 1 $V0 'Status';
 $CLI_1 volume start $V0
 EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
 
+#bug-1231437
+
+#Mount FUSE
+TEST glusterfs -s $H1 --volfile-id=$V0 $M0;
+
+TEST mkdir $M0/dir{1..4};
+TEST touch $M0/dir{1..4}/files{1..4};
+
+TEST $CLI_1 volume add-brick $V0 $H1:$B1/${V0}1 $H2:$B2/${V0}1
+
+TEST $CLI_1 volume rebalance $V0  start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" cluster_rebalance_status_field 1  $V0
+
+#bug - 1764119 - rebalance status should display detailed info when any of the node is dowm
+TEST kill_glusterd 2
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field_1 $V0
+
+TEST start_glusterd 2
+#bug-1245142
+
 $CLI_1 volume rebalance $V0  start &
 #kill glusterd2 after requst sent, so that call back is called
 #with rpc->status fail ,so roughly 1sec delay is introduced to get this scenario.
@@ -26,3 +49,4 @@ kill_glusterd 2
 EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
 
 cleanup;
+
diff --git a/tests/bugs/glusterd/rebalance-operations-in-single-node.t b/tests/bugs/glusterd/rebalance-operations-in-single-node.t
new file mode 100644
index 00000000000..ef85887f440
--- /dev/null
+++ b/tests/bugs/glusterd/rebalance-operations-in-single-node.t
@@ -0,0 +1,131 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+function get_rebalanced_info()
+{
+        local rebal_info_key=$2
+        $CLI  volume rebalance $1 status | awk '{print $'$rebal_info_key'}' |sed -n 3p| sed 's/ *$//g'
+}
+
+volname="StartMigrationDuringRebalanceTest"
+TEST glusterd
+TEST pidof glusterd;
+
+TEST $CLI volume info;
+TEST $CLI volume create $volname $H0:$B0/${volname}{1..4};
+TEST $CLI volume start $volname;
+
+#bug-1046308 - validate rebalance on a specified volume name
+TEST $CLI volume rebalance $volname start;
+
+#bug-1089668 - validation of rebalance status and remove brick status
+#bug-963541 - after remove brick start rebalance/remove brick start without commiting should fail
+
+TEST ! $CLI volume remove-brick $volname $H0:$B0/${volname}1 status
+
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $volname
+
+TEST $CLI volume remove-brick $volname $H0:$B0/${volname}1 start
+TEST ! $CLI volume rebalance $volname start
+TEST ! $CLI volume rebalance $volname status
+TEST ! $CLI volume remove-brick $volname $H0:$B0/${volname}2 start
+
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field \
+"$volname" "$H0:$B0/${volname}1"
+TEST $CLI volume remove-brick $volname $H0:$B0/${volname}1 commit
+
+TEST $CLI volume rebalance $volname start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $volname
+TEST $CLI volume rebalance $volname stop
+
+TEST $CLI volume remove-brick $volname $H0:$B0/${volname}2 start
+TEST $CLI volume remove-brick $volname $H0:$B0/${volname}2 stop
+
+#bug-1351021-rebalance-info-post-glusterd-restart
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..3};
+TEST $CLI volume start $V0;
+
+#Mount volume and create data
+TEST glusterfs -s $H0 --volfile-id $V0 $M0;
+TEST mkdir $M0/dir{1..10}
+TEST touch $M0/dir{1..10}/file{1..10}
+
+# Add-brick and start rebalance
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}4
+TEST $CLI volume rebalance $V0 start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" rebalance_status_field $V0
+
+#Rebalance info before glusterd restart
+OLD_REBAL_FILES=$(get_rebalanced_info $V0 2)
+OLD_SIZE=$(get_rebalanced_info $V0 3)
+OLD_SCANNED=$(get_rebalanced_info $V0 4)
+OLD_FAILURES=$(get_rebalanced_info $V0 5)
+OLD_SKIPPED=$(get_rebalanced_info $V0 6)
+
+
+pkill glusterd;
+pkill glusterfsd;
+TEST glusterd
+
+#Rebalance info after glusterd restart
+NEW_REBAL_FILES=$(get_rebalanced_info $V0 2)
+NEW_SIZE=$(get_rebalanced_info $V0 3)
+NEW_SCANNED=$(get_rebalanced_info $V0 4)
+NEW_FAILURES=$(get_rebalanced_info $V0 5)
+NEW_SKIPPED=$(get_rebalanced_info $V0 6)
+#Check rebalance info before and after glusterd restart
+TEST [ $OLD_REBAL_FILES == $NEW_REBAL_FILES ]
+TEST [ $OLD_SIZE == $NEW_SIZE ]
+TEST [ $OLD_SCANNED == $NEW_SCANNED ]
+TEST [ $OLD_FAILURES == $NEW_FAILURES ]
+TEST [ $OLD_SKIPPED == $NEW_SKIPPED ]
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#bug-1004744 - validation of rebalance fix layout
+
+TEST $CLI volume start $V0 force
+TEST glusterfs -s $H0 --volfile-id $V0 $M0;
+
+for i in `seq 11 20`;
+do
+       mkdir $M0/dir_$i
+       echo file>$M0/dir_$i/file_$i
+       for j in `seq 1 100`;
+       do
+                mkdir $M0/dir_$i/dir_$j
+                echo file>$M0/dir_$i/dir_$j/file_$j
+       done
+done
+
+#add 2 bricks
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{5,6};
+
+#perform rebalance fix-layout
+TEST $CLI volume rebalance $V0 fix-layout start
+
+EXPECT_WITHIN $REBALANCE_TIMEOUT "fix-layout completed" fix-layout_status_field $V0;
+
+#bug-1075087 - rebalance post add brick
+TEST mkdir $M0/dir{21..30};
+TEST touch $M0/dir{21..30}/files{1..10};
+
+TEST $CLI volume add-brick $V0 $H0:$B0/${V0}{7,8}
+
+TEST $CLI volume rebalance $V0 start force
+EXPECT_WITHIN 180 "completed" rebalance_status_field $V0
+
+TEST pkill gluster
+TEST glusterd
+TEST pidof glusterd
+
+# status should be "completed" immediate after glusterd has respawned.
+EXPECT_WITHIN 20 "completed" rebalance_status_field $V0
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-1230121-replica_subvol_count_correct_cal.t b/tests/bugs/glusterd/remove-brick-in-cluster.t
index 71d98e18491..de94220a906 100644
--- a/tests/bugs/glusterd/bug-1230121-replica_subvol_count_correct_cal.t
+++ b/tests/bugs/glusterd/remove-brick-in-cluster.t
@@ -1,23 +1,32 @@
 #!/bin/bash
 
-## Test case for BZ:1230121  glusterd crashed while trying to remove a bricks
-## one selected from each replica set - after shrinking nX3 to nX2 to nX1
-
 . $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../cluster.rc
 
 cleanup;
 
-## Start a 2 node virtual cluster
 TEST launch_cluster 2;
-TEST pidof glusterd
 
-## Peer probe server 2 from server 1 cli
-TEST $CLI_1 peer probe $H2;
+#bug-1047955 - remove brick from new peer in cluster
+TEST $CLI_1 volume create $V0 replica 2 $H1:$B1/${V0}{1,2,3,4}
+TEST $CLI_1 volume start $V0;
 
+TEST $CLI_1 peer probe $H2;
 EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
 
+TEST $CLI_2 volume remove-brick $V0 $H1:$B1/${V0}{3,4} start;
+TEST $CLI_2 volume info
+
+#bug-964059 - volume status post remove brick start
+TEST $CLI_1 volume create $V1 $H1:$B1/${V1}0 $H2:$B2/${V1}1
+TEST $CLI_1 volume start $V1
+TEST $CLI_1 volume remove-brick $V1 $H2:$B2/${V1}1 start
+TEST $CLI_1 volume status
+
+TEST $CLI_1 volume stop $V0
+TEST $CLI_1 volume delete $V0
+
+#bug-1230121 - decrease replica count by remove-brick and increse by add-brick
 ## Creating a 2x3 replicate volume
 TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/brick1 $H2:$B2/brick2 \
                                         $H1:$B1/brick3 $H2:$B2/brick4 \
@@ -26,7 +35,6 @@ TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/brick1 $H2:$B2/brick2 \
 ## Start the volume
 TEST $CLI_1 volume start $V0
 
-
 ## Shrinking volume replica 2x3 to 2x2 by performing remove-brick operation.
 TEST $CLI_1 volume remove-brick $V0 replica 2 $H1:$B1/brick1 $H2:$B2/brick6 force
 
@@ -37,7 +45,6 @@ TEST $CLI_1 volume remove-brick $V0 replica 2 $H1:$B1/brick3 $H2:$B2/brick2 forc
 TEST $CLI_1 volume remove-brick $V0 replica 1 $H1:$B1/brick5 force
 
 
-
 ### Expanding volume replica by performing add-brick operation.
 
 ## Expend volume replica from 1x1 to 1x2 by performing add-brick operation
@@ -49,4 +56,5 @@ TEST $CLI_1 volume add-brick $V0 replica 2 $H1:$B1/brick3 $H2:$B2/brick2 force
 ## Expend volume replica from 2x2 to 2x3 by performing add-brick operation
 TEST $CLI_1 volume add-brick $V0 replica 3 $H1:$B1/brick1 $H2:$B2/brick6 force
 
-cleanup;
+cleanup
+
diff --git a/tests/bugs/glusterd/remove-brick-testcases.t b/tests/bugs/glusterd/remove-brick-testcases.t
new file mode 100644
index 00000000000..2f982d5266f
--- /dev/null
+++ b/tests/bugs/glusterd/remove-brick-testcases.t
@@ -0,0 +1,119 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+function check_peers {
+        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+function brick_count()
+{
+    local vol=$1;
+
+    $CLI volume info $vol | egrep "^Brick[0-9]+: " | wc -l;
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..5}
+TEST $CLI volume start $V0
+
+#bug-1225716 - remove-brick on a brick which is down should fail
+#kill a brick process
+kill_brick $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status $V0 $H0 $B0/${V0}1
+
+#remove-brick start should fail as the brick is down
+TEST ! $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
+#remove-brick start should succeed as the brick is up
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 start
+
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0 $H0:$B0/${V0}1"
+
+#kill a brick process
+kill_brick $V0 $H0 $B0/${V0}1
+
+#remove-brick commit should pass even if the brick is down
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}1 commit
+
+#bug-1121584 - brick-existing-validation-for-remove-brick-status-stop
+## Start remove-brick operation on the volume
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 start
+
+## By giving non existing brick for remove-brick status/stop command should
+## give error.
+TEST ! $CLI volume remove-brick $V0 $H0:$B0/ABCD status
+TEST ! $CLI volume remove-brick $V0 $H0:$B0/ABCD stop
+
+## By giving brick which is part of volume for remove-brick status/stop command
+## should print statistics of remove-brick operation or stop remove-brick
+## operation.
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 status
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 stop
+
+#bug-878004 - validate remove brick force
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 force;
+EXPECT '3' brick_count $V0
+
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}3 force;
+EXPECT '2' brick_count $V0
+
+#bug-1027171 - Do not allow commit if the bricks are not decommissioned
+#Remove bricks and commit without starting
+function remove_brick_commit_status {
+        $CLI volume remove-brick $V0 \
+        $H0:$B0/${V0}4 commit 2>&1 |grep -oE "success|decommissioned"
+}
+EXPECT "decommissioned"  remove_brick_commit_status;
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0;
+
+#Create a 2X3 distributed-replicate volume
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1..6};
+TEST $CLI volume start $V0
+
+#Try to reduce replica count with start option
+function remove_brick_start_status {
+        $CLI volume remove-brick $V0 replica 2 \
+        $H0:$B0/${V0}3  $H0:$B0/${V0}6 start 2>&1 |grep -oE "success|failed"
+}
+EXPECT "failed"  remove_brick_start_status;
+
+#Remove bricks with commit option
+function remove_brick_commit_status2 {
+        $CLI volume remove-brick $V0 replica 2 \
+        $H0:$B0/${V0}3  $H0:$B0/${V0}6 commit 2>&1  |
+        grep -oE "success|decommissioned"
+}
+EXPECT "decommissioned"  remove_brick_commit_status2;
+TEST $CLI volume info $V0
+
+#bug-1040408 - reduce replica count of distributed replicate volume
+
+# Reduce to 2x2 volume by specifying bricks in reverse order
+function remove_brick_status {
+        $CLI volume remove-brick $V0 replica 2 \
+        $H0:$B0/${V0}6  $H0:$B0/${V0}3 force 2>&1 |grep -oE "success|failed"
+}
+EXPECT "success"  remove_brick_status;
+TEST $CLI volume info $V0
+
+#bug-1120647 - remove brick validation
+
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}{4..5} start
+EXPECT_WITHIN 10 "completed" remove_brick_status_completed_field  "$V0 $H0:$B0/${V0}5"
+EXPECT_WITHIN 10 "completed" remove_brick_status_completed_field  "$V0 $H0:$B0/${V0}4"
+TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}{4..5} commit
+TEST $CLI volume remove-brick $V0 replica 1 $H0:$B0/${V0}2 force
+
+cleanup
diff --git a/tests/bugs/glusterd/bug-1245045-remove-brick-validation.t b/tests/bugs/glusterd/remove-brick-validation.t
index 597c40ca4ec..a0ff4ff6a24 100644
--- a/tests/bugs/glusterd/bug-1245045-remove-brick-validation.t
+++ b/tests/bugs/glusterd/remove-brick-validation.t
@@ -1,14 +1,27 @@
 #!/bin/bash
 
 . $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../cluster.rc
 
-cleanup
+function peer_count {
+eval \$CLI_$1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup;
 
+## start a 3 node virtual cluster
 TEST launch_cluster 3;
+
+## peer probe server 2 from server 1 cli
 TEST $CLI_1 peer probe $H2;
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
+
+#testcase: bug-1245045-remove-brick-validation
+
 TEST $CLI_1 peer probe $H3;
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
 
 TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
 TEST $CLI_1 volume start $V0
@@ -18,25 +31,25 @@ kill_glusterd 2
 #remove-brick should fail as the peer hosting the brick is down
 TEST ! $CLI_1 volume remove-brick $V0 $H2:$B2/${V0} start
 
-TEST start_glusterd 2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}
+TEST $glusterd_2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}
 
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
 
 #volume status should work
 TEST $CLI_2 volume status
 
-
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 3
 TEST $CLI_1 volume remove-brick $V0 $H2:$B2/${V0} start
 kill_glusterd 2
 
 #remove-brick commit should fail as the peer hosting the brick is down
 TEST ! $CLI_1 volume remove-brick $V0 $H2:$B2/${V0} commit
 
-TEST start_glusterd 2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status_1 $V0 $H2 $B2/${V0}
+TEST $glusterd_2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}
 
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
 
 #volume status should work
 TEST $CLI_2 volume status
@@ -44,13 +57,12 @@ TEST $CLI_2 volume status
 TEST $CLI_1 volume remove-brick $V0 $H2:$B2/${V0} stop
 
 kill_glusterd 3
-EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
 
 TEST $CLI_1 volume remove-brick $V0 $H2:$B2/${V0} start
 
 TEST start_glusterd 3
-EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
-
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
 TEST $CLI_3 volume status
 
 cleanup
diff --git a/tests/bugs/glusterd/bug-974007.t b/tests/bugs/glusterd/removing-multiple-bricks-in-single-remove-brick-command.t
index 5759adb583f..00beab59137 100644
--- a/tests/bugs/glusterd/bug-974007.t
+++ b/tests/bugs/glusterd/removing-multiple-bricks-in-single-remove-brick-command.t
@@ -1,8 +1,5 @@
 #!/bin/bash
 
-#Test case: Create a distributed replicate volume, and remove multiple
-#replica pairs in a single remove-brick command.
-
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 
@@ -17,6 +14,7 @@ TEST $CLI volume info
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1..6};
 TEST $CLI volume start $V0
 
+#bug-974007 - remove multiple replica pairs in a single brick command
 # Mount FUSE and create files
 TEST glusterfs -s $H0 --volfile-id $V0 $M0
 TEST touch $M0/file{1..10}
@@ -41,12 +39,42 @@ function remove_brick_commit_status {
 }
 EXPECT "success" remove_brick_commit_status;
 
+
 # Check the volume type
 EXPECT "Replicate" echo `$CLI volume info |grep Type |awk '{print $2}'`
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#bug-961669 - remove brick start should fail when reducing the replica count
+
+#Create a 3x3 dist-rep volume
+TEST $CLI volume create $V1 replica 3 $H0:$B0/${V1}{0,1,2,3,4,5,6,7,8};
+TEST $CLI volume start $V1
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "9" brick_count ${V1}
+
+# Mount FUSE and create file/directory
+TEST glusterfs -s $H0 --volfile-id $V1 $M0
+TEST touch $M0/zerobytefile.txt
+TEST mkdir $M0/test_dir
+TEST dd if=/dev/zero of=$M0/file bs=1024 count=1024
+
+function remove_brick_start {
+        $CLI volume remove-brick $V1 replica 2 $H0:$B0/${V1}{1,4,7} start 2>&1|grep -oE 'success|failed'
+}
+
+function remove_brick {
+        $CLI volume remove-brick $V1 replica 2 $H0:$B0/${V1}{1,4,7} force 2>&1|grep -oE 'success|failed'
+}
+
+#remove-brick start variant
+#Actual message displayed at cli is:
+#"volume remove-brick start: failed: Rebalancing not needed when reducing replica count. Try without the 'start' option"
+EXPECT "failed" remove_brick_start;
+
+#remove-brick commit-force
+#Actual message displayed at cli is:
+#"volume remove-brick commit force: success"
+EXPECT "success" remove_brick
 
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume stop $V0
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
 
 cleanup;
diff --git a/tests/bugs/glusterd/replace-brick-operations.t b/tests/bugs/glusterd/replace-brick-operations.t
new file mode 100644
index 00000000000..044aa3d6c6d
--- /dev/null
+++ b/tests/bugs/glusterd/replace-brick-operations.t
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+## Test case for BZ: 1094119  Remove replace-brick support from gluster
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+# Start glusterd
+TEST glusterd
+TEST pidof glusterd
+
+## Lets create and start volume
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2}
+TEST $CLI volume start $V0
+
+#bug-1094119-remove-replace-brick-support-from-glusterd
+
+## Now with this patch replace-brick only accept following commad
+## volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> {commit force}
+## Apart form this replace brick command will failed.
+
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/${V0}2 $H0:$B0/${V0}3 start
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/${V0}2 $H0:$B0/${V0}3 status
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/${V0}2 $H0:$B0/${V0}3 abort
+
+
+## replace-brick commit force command should success
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}2 $H0:$B0/${V0}3 commit force
+
+#bug-1242543-replace-brick validation
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+# Replace brick1 without killing
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}1 $H0:$B0/${V0}1_new commit force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+TEST kill_brick $V0 $H0 $B0/${V0}1_new
+
+# Replace brick1 after killing the brick
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}1_new $H0:$B0/${V0}1_newer commit force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+cleanup;
diff --git a/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t b/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t
new file mode 100644
index 00000000000..e6e65c48456
--- /dev/null
+++ b/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+function shd_up_status_1 {
+        $CLI_1 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $7}'
+}
+
+function shd_up_status_2 {
+        $CLI_2 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $7}'
+}
+
+function get_shd_pid_2 {
+        $CLI_2 volume status | grep "localhost" | grep "Self-heal Daemon" | awk '{print $8}'
+}
+
+cleanup;
+
+function check_peers {
+        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+TEST launch_cluster 3
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers
+
+TEST $CLI_1 volume create $V0 replica 2 $H1:$B0/${V0} $H2:$B0/${V0}
+TEST $CLI_1 volume start $V0
+
+#testcase: bug-1507466 - validate reset-brick commit force
+# Negative case with brick not killed && volume-id xattrs present
+TEST ! $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} $H1:$B0/${V0} commit force
+
+TEST $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} start
+# Now test if reset-brick commit force works
+TEST $CLI_1 volume reset-brick $V0 $H1:$B0/${V0} $H1:$B0/${V0} commit force
+
+#testcase: bug-1383893 - shd should not come up after restarting the peer glusterd
+
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2  peer_count
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B0/${V0}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B0/${V0}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_2
+
+# Bring down shd on 2nd node
+kill -15 $(get_shd_pid_2)
+
+# Bring down glusterd on 1st node
+TEST kill_glusterd 1
+
+#Bring back 1st glusterd
+TEST $glusterd_1
+
+# We need to wait till PROCESS_UP_TIMEOUT and then check shd service started
+#on node 2, because once glusterd regains quorum, it will restart all volume
+#level daemons
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_2
+
+cleanup;
diff --git a/tests/bugs/glusterd/serialize-shd-manager-glusterd-restart.t b/tests/bugs/glusterd/serialize-shd-manager-glusterd-restart.t
new file mode 100644
index 00000000000..a871e112d87
--- /dev/null
+++ b/tests/bugs/glusterd/serialize-shd-manager-glusterd-restart.t
@@ -0,0 +1,54 @@
+#! /bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+function check_peers {
+count=`$CLI_3 peer status | grep 'Peer in Cluster (Connected)' | wc -l`
+echo $count
+}
+
+function check_shd {
+ps aux | grep $1 | grep glustershd | wc -l
+}
+
+cleanup
+
+
+TEST launch_cluster 6
+
+TESTS_EXPECTED_IN_LOOP=25
+for i in $(seq 2 6); do
+    hostname="H$i"
+    TEST $CLI_1 peer probe ${!hostname}
+done
+
+
+EXPECT_WITHIN $PROBE_TIMEOUT 5 check_peers;
+for i in $(seq 1 5); do
+
+    TEST $CLI_1 volume create ${V0}_$i replica 3 $H1:$B1/${V0}_$i $H2:$B2/${V0}_$i $H3:$B3/${V0}_$i $H4:$B4/${V0}_$i $H5:$B5/${V0}_$i $H6:$B6/${V0}_$i
+    TEST $CLI_1 volume start ${V0}_$i force
+
+done
+
+#kill a node
+TEST kill_node 3
+
+TEST $glusterd_3;
+EXPECT_WITHIN $PROBE_TIMEOUT 5 check_peers
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 check_shd $H3
+
+for i in $(seq 1 5); do
+
+    TEST $CLI_1 volume stop ${V0}_$i
+    TEST $CLI_1 volume delete ${V0}_$i
+
+done
+
+for i in $(seq 1 6); do
+    hostname="H$i"
+    EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT 0 check_shd ${!hostname}
+done
+cleanup
diff --git a/tests/bugs/glusterd/bug-1322145-disallow-detatch-peer.t b/tests/bugs/glusterd/snapshot-operations.t
index 60eceb4f44d..4705577d741 100644
--- a/tests/bugs/glusterd/bug-1322145-disallow-detatch-peer.t
+++ b/tests/bugs/glusterd/snapshot-operations.t
@@ -7,6 +7,7 @@
 
 
 cleanup;
+
 TEST verify_lvm_version
 TEST launch_cluster 3;
 TEST setup_lvm 3;
@@ -20,8 +21,17 @@ EXPECT 'Created' volinfo_field $V0 'Status'
 TEST $CLI_1 volume start $V0
 EXPECT 'Started' volinfo_field $V0 'Status'
 
+#bug-1318591 - skip-non-directories-inside-vols
+
+b="B1"
+TEST touch ${!b}/glusterd/vols/file
+
 TEST $CLI_1 snapshot create snap1 $V0 no-timestamp;
 
+TEST touch ${!b}/glusterd/snaps/snap1/file
+
+#bug-1322145 - peer hosting snapshotted bricks should not be detachable
+
 kill_glusterd 2
 
 TEST $CLI_1 peer probe $H3;
@@ -29,8 +39,12 @@ EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
 
 TEST $CLI_1 volume replace-brick $V0 $H2:$L2 $H3:$L3 commit force
 
-
 # peer hosting snapshotted bricks should not be detachable
 TEST ! $CLI_1 peer detach $H2
+
+TEST killall_gluster
+TEST $glusterd_1
+TEST $glusterd_2
+
 cleanup;
 
diff --git a/tests/bugs/glusterd/sync-post-glusterd-restart.t b/tests/bugs/glusterd/sync-post-glusterd-restart.t
new file mode 100644
index 00000000000..de3dff715ab
--- /dev/null
+++ b/tests/bugs/glusterd/sync-post-glusterd-restart.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+function volume_get_field()
+{
+     local vol=$1
+     local field=$2
+     $CLI_2 volume get $vol $field | tail -1 | awk '{print $2}'
+}
+
+cleanup
+
+TEST launch_cluster 2;
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0
+TEST $CLI_1 volume start $V0
+
+TEST $CLI_1 volume set $V0 performance.readdir-ahead on
+
+# Bring down 2nd glusterd
+TEST kill_glusterd 2
+
+##bug-1420637 and bug-1323287 - sync post glusterd restart
+
+TEST $CLI_1 volume set all cluster.server-quorum-ratio 60
+TEST $CLI_1 volume set $V0 performance.readdir-ahead off
+TEST $CLI_1 volume set $V0 performance.write-behind off
+
+# Bring back 2nd glusterd
+TEST $glusterd_2
+
+# After 2nd glusterd come back, there will be 2 nodes in a cluster
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
+
+#bug-1420637-volume sync post glusterd restart
+
+EXPECT_WITHIN $PROBE_TIMEOUT "60" volinfo_field_2 all cluster.server-quorum-ratio
+EXPECT_WITHIN $PROBE_TIMEOUT "off" volinfo_field_2 $V0 performance.readdir-ahead
+
+#bug-1323287
+EXPECT_WITHIN $PROBE_TIMEOUT 'off' volume_get_field $V0 'write-behind'
+
+#bug-1213295 - volume stop should not crash glusterd post glusterd restart
+
+TEST $CLI_2 volume stop $V0
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 volume create $V1 $H1:$B1/$V1  $H2:$B2/$V1
+
+cleanup
diff --git a/tests/bugs/glusterd/validating-options-for-replicated-volume.t b/tests/bugs/glusterd/validating-options-for-replicated-volume.t
new file mode 100644
index 00000000000..ddc80b17870
--- /dev/null
+++ b/tests/bugs/glusterd/validating-options-for-replicated-volume.t
@@ -0,0 +1,142 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
+
+## start volume and verify
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+#bug-1314649 - validate group virt
+TEST $CLI volume set $V0 group virt;
+
+#bug-765230 - remove-quota-related-option-after-disabling-quota
+## setting soft-timeout as 20
+TEST $CLI volume set $V0 features.soft-timeout 20
+EXPECT '20' volinfo_field $V0 'features.soft-timeout';
+
+## enabling features.quota-deem-statfs
+TEST ! $CLI volume set $V0 features.quota-deem-statfs on
+EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
+
+## enabling quota
+TEST $CLI volume quota $V0 enable
+EXPECT 'on' volinfo_field $V0 'features.quota'
+
+## eetting soft-timeout as 20
+TEST $CLI volume set $V0 features.soft-timeout 20
+EXPECT '20' volinfo_field $V0 'features.soft-timeout';
+
+## enabling features.quota-deem-statfs
+TEST $CLI volume set $V0 features.quota-deem-statfs on
+EXPECT 'on' volinfo_field $V0 'features.quota-deem-statfs'
+
+## disabling quota
+TEST $CLI volume quota $V0 disable
+EXPECT 'off' volinfo_field $V0 'features.quota'
+EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
+EXPECT '' volinfo_field $V0 'features.soft-timeout'
+
+## setting soft-timeout as 30
+TEST $CLI volume set $V0 features.soft-timeout 30
+EXPECT '30' volinfo_field $V0 'features.soft-timeout';
+
+## disabling features.quota-deem-statfs
+TEST ! $CLI volume set $V0 features.quota-deem-statfs off
+EXPECT '' volinfo_field $V0 'features.quota-deem-statfs'
+
+TEST ! $CLI volume set $V0 statedump-path ""
+TEST ! $CLI volume set $V0 statedump-path "     "
+TEST   $CLI volume set $V0 statedump-path "/home/"
+EXPECT "/home/" volume_option $V0 server.statedump-path
+
+TEST ! $CLI volume set $V0 background-self-heal-count ""
+TEST ! $CLI volume set $V0 background-self-heal-count "      "
+TEST   $CLI volume set $V0 background-self-heal-count 10
+EXPECT "10" volume_option $V0 cluster.background-self-heal-count
+
+TEST ! $CLI volume set $V0 io-cache-size ""
+TEST ! $CLI volume set $V0 io-cache-size "    "
+TEST   $CLI volume set $V0 io-cache-size 64MB
+EXPECT "64MB" volume_option $V0 performance.io-cache-size
+
+TEST ! $CLI volume set $V0 quick-read-cache-size ""
+TEST ! $CLI volume set $V0 quick-read-cache-size "    "
+TEST   $CLI volume set $V0 quick-read-cache-size 512MB
+EXPECT "512MB" volume_option $V0 performance.quick-read-cache-size
+
+TEST ! $CLI volume set $V0 self-heal-daemon ""
+TEST ! $CLI volume set $V0 self-heal-daemon "    "
+TEST   $CLI volume set $V0 self-heal-daemon on
+EXPECT "on" volume_option $V0 cluster.self-heal-daemon
+
+TEST ! $CLI volume set $V0 read-subvolume ""
+TEST ! $CLI volume set $V0 read-subvolume "    "
+TEST   $CLI volume set $V0 read-subvolume $V0-client-0
+EXPECT "$V0-client-0" volume_option  $V0 cluster.read-subvolume
+
+TEST ! $CLI volume set $V0 data-self-heal-algorithm ""
+TEST ! $CLI volume set $V0 data-self-heal-algorithm "     "
+TEST ! $CLI volume set $V0 data-self-heal-algorithm on
+TEST   $CLI volume set $V0 data-self-heal-algorithm full
+EXPECT "full" volume_option $V0 cluster.data-self-heal-algorithm
+
+TEST ! $CLI volume set $V0 min-free-inodes ""
+TEST ! $CLI volume set $V0 min-free-inodes "     "
+TEST  $CLI volume set $V0 min-free-inodes 60%
+EXPECT "60%" volume_option $V0 cluster.min-free-inodes
+
+TEST ! $CLI volume set $V0 min-free-disk ""
+TEST ! $CLI volume set $V0 min-free-disk "     "
+TEST  $CLI volume set $V0 min-free-disk 60%
+EXPECT "60%" volume_option $V0 cluster.min-free-disk
+
+TEST  $CLI volume set $V0 min-free-disk 120
+EXPECT "120" volume_option $V0 cluster.min-free-disk
+
+TEST ! $CLI volume set $V0 frame-timeout ""
+TEST ! $CLI volume set $V0 frame-timeout "      "
+TEST  $CLI volume set $V0 frame-timeout 0
+EXPECT "0" volume_option $V0 network.frame-timeout
+
+TEST ! $CLI volume set $V0 auth.allow ""
+TEST ! $CLI volume set $V0 auth.allow "       "
+TEST   $CLI volume set $V0 auth.allow 192.168.122.1
+EXPECT "192.168.122.1" volume_option $V0 auth.allow
+
+#bug-782095 - validate performance cache min/max size value
+
+## setting performance cache min size as 2MB
+TEST $CLI volume set $V0 performance.cache-min-file-size 2MB
+EXPECT '2MB' volinfo_field $V0 'performance.cache-min-file-size';
+
+## setting performance cache max size as 20MB
+TEST $CLI volume set $V0 performance.cache-max-file-size 20MB
+EXPECT '20MB' volinfo_field $V0 'performance.cache-max-file-size';
+
+## trying to set performance cache min size as 25MB
+TEST ! $CLI volume set $V0 performance.cache-min-file-size 25MB
+EXPECT '2MB' volinfo_field $V0 'performance.cache-min-file-size';
+
+## able to set performance cache min size as long as its lesser than max size
+TEST $CLI volume set $V0 performance.cache-min-file-size 15MB
+EXPECT '15MB' volinfo_field $V0 'performance.cache-min-file-size';
+
+## trying it out with only cache-max-file-size in CLI as 10MB
+TEST ! $CLI volume set $V0 cache-max-file-size 10MB
+EXPECT '20MB' volinfo_field $V0 'performance.cache-max-file-size';
+
+## finish up
+TEST $CLI volume stop $V0;
+EXPECT 'Stopped' volinfo_field $V0 'Status';
+
+TEST $CLI volume delete $V0;
+TEST ! $CLI volume info $V0;
+
+cleanup
diff --git a/tests/bugs/glusterd/validating-server-quorum.t b/tests/bugs/glusterd/validating-server-quorum.t
new file mode 100644
index 00000000000..ae7d83fd81c
--- /dev/null
+++ b/tests/bugs/glusterd/validating-server-quorum.t
@@ -0,0 +1,125 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../cluster.rc
+
+function check_fs {
+        df $1 &> /dev/null
+        echo $?
+}
+
+function check_peers {
+        $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup;
+
+TEST launch_cluster 3
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1  peer_count
+
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2  peer_count
+
+# Lets create the volume
+TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/${V0}1 $H2:$B2/${V0}2 $H3:$B3/${V0}3
+TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
+
+# Start the volume
+TEST $CLI_1 volume start $V0
+
+#bug-1345727 - bricks should be down when quorum is not met
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H3 $B3/${V0}3
+
+# Bring down glusterd on 2nd node
+TEST kill_glusterd 2
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST kill_glusterd 3
+EXPECT_WITHIN $PROBE_TIMEOUT 0 peer_count
+
+# Server quorum is not met. Brick on 1st node must be down
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+
+# Set quorum ratio 95. means 95 % or more than 95% nodes of total available node
+# should be available for performing volume operation.
+# i.e. Server-side quorum is met if the number of nodes that are available is
+# greater than or equal to 'quorum-ratio' times the number of nodes in the
+# cluster
+TEST $CLI_1 volume set all cluster.server-quorum-ratio 95
+
+#bug-1483058 - replace-brick should fail when quorum is not met
+TEST ! $CLI_1 volume replace-brick $V0 $H2:$B2/${V0}2 $H1:$B1/${V0}2_new commit force
+
+#Bring back 2nd glusterd
+TEST $glusterd_2
+
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+# Server quorum is still not met. Bricks should be down on 1st and 2nd nodes
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}2
+
+# Bring back 3rd glusterd
+TEST $glusterd_3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count
+
+# Server quorum is met now. Bricks should be up on all nodes
+# Check from 3rd instance of glusterd so that the 3rd node finishes all its
+# handshake and then report back the brick status
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H2 $B2/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H3 $B3/${V0}3
+
+# Check from 1st instance of glusterd
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H2 $B2/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 3 $V0 $H3 $B3/${V0}3
+
+# TODO : Because commit fe71ee7 introduced a delay of 1 sec to wait for shd connect and
+# disconnect events to be serially processed during a restart of shd daemon,
+# this introduced a race where while releasing big lock, if any command sneaks
+# and acquires the big lock, it might be able to work on a volinfo which is
+# stale. We need to find a better way to fix this.
+
+sleep 3
+
+# quorum is met. replace-brick will execute successfully
+EXPECT_WITHIN $PEER_SYNC_TIMEOUT 0 attempt_replace_brick 1 $V0 $H2:$B2/${V0}2 $H2:$B2/${V0}2_new
+
+TEST $CLI_1 volume reset all
+TEST $CLI_1 volume set $V0 cluster.server-quorum-type server
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}2_new
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H3 $B3/${V0}3
+
+
+#bug-913555 - volume should become unwritable when quorum does not met
+
+TEST glusterfs --volfile-server=$H1 --volfile-id=$V0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
+
+# Kill one pseudo-node, make sure the others survive and volume stays up.
+TEST kill_node 3;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 check_peers;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H2 $B2/${V0}2_new
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
+
+# Kill another pseudo-node, make sure the last one dies and volume goes down.
+TEST kill_node 2;
+EXPECT_WITHIN $PROBE_TIMEOUT 0 check_peers
+#two glusterfsds of the other two glusterds must be dead
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" cluster_brick_up_status 1 $V0 $H1 $B1/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 1 check_fs $M0;
+
+TEST $glusterd_2;
+TEST $glusterd_3;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT 0 check_fs $M0;
+
+cleanup
diff --git a/tests/bugs/glusterfs-server/bug-852147.t b/tests/bugs/glusterfs-server/bug-852147.t
index 8cb5fd13f85..75db2a26e05 100755
--- a/tests/bugs/glusterfs-server/bug-852147.t
+++ b/tests/bugs/glusterfs-server/bug-852147.t
@@ -11,7 +11,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
@@ -42,7 +42,7 @@ function vol_prof_info()
 {
     $CLI volume profile $V0 info | grep Brick | wc -l
 }
-EXPECT "8" vol_prof_info
+EXPECT "6" vol_prof_info
 
 EXPECT "Stopping volume profile on $V0 has been successful " $CLI volume profile $V0 stop
 
@@ -66,7 +66,7 @@ ren_file=$log_file".*"
 rm -rf $ren_file
 
 #Initiating log rotate
-TEST $CLI volume log rotate $V0
+TEST $CLI volume log $V0 rotate
 
 #Capturing new log file's size
 new_file_size=`file-size $log_file`
diff --git a/tests/bugs/glusterfs-server/bug-864222.t b/tests/bugs/glusterfs-server/bug-864222.t
index 3a46c283599..01a7a4e3afd 100755
--- a/tests/bugs/glusterfs-server/bug-864222.t
+++ b/tests/bugs/glusterfs-server/bug-864222.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/glusterfs-server/bug-873549.t b/tests/bugs/glusterfs-server/bug-873549.t
index a3b2f9c9bf7..8b5534728fd 100644
--- a/tests/bugs/glusterfs-server/bug-873549.t
+++ b/tests/bugs/glusterfs-server/bug-873549.t
@@ -10,7 +10,7 @@ TEST $CLI volume info;
 
 TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
 
-TEST $CLI volume set $V0 performance.cache-size 512MB
+TEST $CLI volume set $V0 performance.quick-read-cache-size 512MB
 TEST $CLI volume start $V0
 TEST $CLI volume statedump $V0 all
 
diff --git a/tests/bugs/glusterfs-server/bug-877992.t b/tests/bugs/glusterfs-server/bug-877992.t
index aeb73ed94dd..300000bcf2c 100755
--- a/tests/bugs/glusterfs-server/bug-877992.t
+++ b/tests/bugs/glusterfs-server/bug-877992.t
@@ -46,7 +46,9 @@ TEST $CLI volume create $V0 $H0:$B0/${V0}1;
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
 EXPECT 'createPre' cat /tmp/pre.out;
-EXPECT 'createPost' cat /tmp/post.out;
+# Spost.sh comes after S10selinux-label-brick.sh under create post hook script
+# list. So consider the delay in setting SELinux context on bricks
+EXPECT_WITHIN 5 'createPost' cat /tmp/post.out;
 hooks_cleanup 'create'
 
 
diff --git a/tests/bugs/glusterfs-server/bug-887145.t b/tests/bugs/glusterfs-server/bug-887145.t
index 9b940259f55..db2cf3c050b 100755
--- a/tests/bugs/glusterfs-server/bug-887145.t
+++ b/tests/bugs/glusterfs-server/bug-887145.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
@@ -27,7 +29,15 @@ chmod 600 $M0/file;
 
 TEST mount_nfs $H0:/$V0 $N0 nolock;
 
-chown -R nfsnobody:nfsnobody $M0/dir;
+grep nfsnobody /etc/passwd > /dev/null
+if [ $? -eq 1 ]; then
+usr=nobody
+grp=nobody
+else
+usr=nfsnobody
+grp=nfsnobody
+fi
+chown -R $usr:$grp $M0/dir;
 chown -R tmp_user:tmp_user $M0/other;
 
 TEST $CLI volume set $V0 server.root-squash on;
@@ -36,7 +46,7 @@ EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
 
 # create files and directories in the root of the glusterfs and nfs mount
 # which is owned by root and hence the right behavior is getting EACCESS
-# as the fops are executed as nfsnobody.
+# as the fops are executed as nfsnobody/nobody.
 touch $M0/foo 2>/dev/null;
 TEST [ $? -ne 0 ]
 touch $N0/foo 2>/dev/null;
@@ -59,7 +69,7 @@ cat $N0/passwd 1>/dev/null;
 TEST [ $? -eq 0 ]
 
 # create files and directories should succeed as the fops are being executed
-# inside the directory owned by nfsnobody
+# inside the directory owned by nfsnobody/nobody
 TEST touch $M0/dir/file;
 TEST touch $N0/dir/foo;
 TEST mkdir $M0/dir/new;
diff --git a/tests/bugs/glusterfs-server/bug-904300.t b/tests/bugs/glusterfs-server/bug-904300.t
index eea1c5b5463..95d5d381c8b 100755
--- a/tests/bugs/glusterfs-server/bug-904300.t
+++ b/tests/bugs/glusterfs-server/bug-904300.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 # 1-8
diff --git a/tests/bugs/glusterfs-server/bug-905864.c b/tests/bugs/glusterfs-server/bug-905864.c
index 3cc4cc5d232..f70003736e7 100644
--- a/tests/bugs/glusterfs-server/bug-905864.c
+++ b/tests/bugs/glusterfs-server/bug-905864.c
@@ -4,10 +4,9 @@
 #include <fcntl.h>
 #include <pthread.h>
 
-
-pthread_t   th[5] = {0};
+pthread_t th[5] = {0};
 void
-flock_init (struct flock *f, short int type, off_t start, off_t len)
+flock_init(struct flock *f, short int type, off_t start, off_t len)
 {
     f->l_type = type;
     f->l_start = start;
@@ -15,68 +14,70 @@ flock_init (struct flock *f, short int type, off_t start, off_t len)
 }
 
 int
-flock_range_in_steps (int fd, int is_set, short l_type,
-                      int start, int end, int step)
+flock_range_in_steps(int fd, int is_set, short l_type, int start, int end,
+                     int step)
 {
-        int         ret = 0;
-        int         i = 0;
-        struct      flock f = {0,};
+    int ret = 0;
+    int i = 0;
+    struct flock f = {
+        0,
+    };
 
-        for (i = start; i+step < end; i += step) {
-                flock_init (&f, l_type, i, step);
-                ret = fcntl (fd, (is_set) ? F_SETLKW : F_GETLK, &f);
-                if (ret) {
-                        perror ("fcntl");
-                        goto out;
-                }
+    for (i = start; i + step < end; i += step) {
+        flock_init(&f, l_type, i, step);
+        ret = fcntl(fd, (is_set) ? F_SETLKW : F_GETLK, &f);
+        if (ret) {
+            perror("fcntl");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void *
-random_locker (void *arg)
+random_locker(void *arg)
 {
-        int         fd = *(int *)arg;
-        int         i = 0;
-        int         is_set = 0;
+    int fd = *(int *)arg;
+    int i = 0;
+    int is_set = 0;
 
-        /* use thread id to choose GETLK or SETLK operation*/
-        is_set = pthread_self () % 2;
-        (void)flock_range_in_steps (fd, is_set, F_WRLCK, 0, 400, 1);
+    /* use thread id to choose GETLK or SETLK operation*/
+    is_set = pthread_self() % 2;
+    (void)flock_range_in_steps(fd, is_set, F_WRLCK, 0, 400, 1);
 
-        return NULL;
+    return NULL;
 }
 
-
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int         fd = -1;
-        int         ret = 1;
-        int         i = 0;
-        char        *fname = NULL;
+    int fd = -1;
+    int ret = 1;
+    int i = 0;
+    char *fname = NULL;
 
-        if (argc < 2)
-                goto out;
+    if (argc < 2)
+        goto out;
 
-        fname = argv[1];
-        fd = open (fname, O_RDWR);
-        if (fd == -1) {
-                perror ("open");
-                goto out;
-        }
+    fname = argv[1];
+    fd = open(fname, O_RDWR);
+    if (fd == -1) {
+        perror("open");
+        goto out;
+    }
 
-        ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2);
-        for (i = 0; i < 5; i++) {
-                pthread_create (&th[i], NULL, random_locker, (void *) &fd);
-        }
-        ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2);
-        for (i = 0; i < 5; i++) {
-                pthread_join (th[i], NULL);
-        }
+    ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2);
+    for (i = 0; i < 5; i++) {
+        pthread_create(&th[i], NULL, random_locker, (void *)&fd);
+    }
+    ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2);
+    for (i = 0; i < 5; i++) {
+        pthread_join(th[i], NULL);
+    }
 out:
-        if (fd != -1)
-                close (fd);
+    if (fd != -1)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/glusterfs-server/bug-912297.t b/tests/bugs/glusterfs-server/bug-912297.t
index f1f4147e6aa..08f5dcea9b9 100755
--- a/tests/bugs/glusterfs-server/bug-912297.t
+++ b/tests/bugs/glusterfs-server/bug-912297.t
@@ -8,7 +8,7 @@ cleanup;
 ## Start and create a volume
 TEST glusterd;
 TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
diff --git a/tests/bugs/glusterfs/bug-1482528.t b/tests/bugs/glusterfs/bug-1482528.t
new file mode 100644
index 00000000000..3adf260bdcd
--- /dev/null
+++ b/tests/bugs/glusterfs/bug-1482528.t
@@ -0,0 +1,100 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+#Basic checks
+TEST glusterd
+TEST pidof glusterd
+
+#Create a distributed volume
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1..2}
+TEST $CLI volume start $V0
+
+# Mount FUSE without selinux:
+TEST glusterfs -s $H0 --volfile-id $V0 $@ $M0
+
+TEST touch $M0/default.txt
+EXPECT "644" stat -c %a $M0/default.txt
+
+TEST chmod 0444 $M0/default.txt
+EXPECT "444" stat -c %a $M0/default.txt
+
+TEST mkdir $M0/default
+EXPECT "755" stat -c %a $M0/default
+
+TEST chmod 0444 $M0/default
+EXPECT "444" stat -c %a $M0/default
+
+TEST mkfifo $M0/mkfifo
+EXPECT "644" stat -c %a $M0/mkfifo
+
+TEST mknod $M0/dmknod b 4 5
+EXPECT "644" stat -c %a $M0/dmknod
+
+#Set the create-directory-mask and create-mask options
+TEST $CLI volume set $V0 storage.create-directory-mask 0444
+TEST $CLI volume set $V0 storage.create-mask 0444
+
+TEST mkdir $M0/create-directory
+EXPECT "444" stat -c %a $M0/create-directory
+
+TEST touch $M0/create-mask.txt
+EXPECT "444" stat -c %a $M0/create-mask.txt
+
+TEST chmod 0777 $M0/create-mask.txt
+EXPECT "444" stat -c %a $M0/create-mask.txt
+
+TEST chmod 0400 $M0/create-mask.txt
+EXPECT "400" stat -c %a $M0/create-mask.txt
+
+TEST chmod 0777 $M0/create-directory
+EXPECT "444" stat -c %a $M0/create-directory
+
+TEST chmod 0400 $M0/create-directory
+EXPECT "400" stat -c %a $M0/create-directory
+
+TEST mkfifo $M0/cfifo
+EXPECT "444" stat -c %a $M0/cfifo
+
+TEST chmod 0777 $M0/cfifo
+EXPECT "444" stat -c %a $M0/cfifo
+
+TEST mknod $M0/cmknod b 4 5
+EXPECT "444" stat -c %a $M0/cmknod
+
+#set force-create-mode and force-directory-mode options
+TEST $CLI volume set $V0 storage.force-create-mode 0777
+TEST $CLI volume set $V0 storage.force-directory-mode 0333
+
+TEST touch $M0/force-create-mode.txt
+EXPECT "777" stat -c %a $M0/force-create-mode.txt
+
+TEST mkdir $M0/force-directory
+EXPECT "777" stat -c %a $M0/force-directory
+
+TEST chmod 0222 $M0/force-create-mode.txt
+EXPECT "777" stat -c %a $M0/force-create-mode.txt
+
+TEST chmod 0222 $M0/force-directory
+EXPECT "333" stat -c %a $M0/force-directory
+
+TEST mkdir $M0/link
+TEST ln -s $M0/force-create-mode.txt $M0/link
+EXPECT "777" stat -c %a $M0/link/force-create-mode.txt
+
+TEST ln $M0/force-create-mode.txt $M0/link/fc.txt
+EXPECT "777" stat -c %a $M0/link/fc.txt
+
+TEST setfacl -m o:r $M0/force-create-mode.txt
+EXPECT "777" stat -c %a $M0/force-create-mode.txt
+
+TEST ln -s $M0/force-directory $M0/link
+EXPECT "777" stat -c %a $M0/link/force-directory
+
+TEST mkfifo $M0/ffifo
+EXPECT "777" stat -c %a $M0/ffifo
+
+TEST mknod $M0/mknod b 4 5
+EXPECT "777" stat -c %a $M0/mknod
diff --git a/tests/bugs/glusterfs/bug-844688.t b/tests/bugs/glusterfs/bug-844688.t
index a1b0b15f5ed..65f41b342a5 100755
--- a/tests/bugs/glusterfs/bug-844688.t
+++ b/tests/bugs/glusterfs/bug-844688.t
@@ -3,6 +3,17 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 
+function check_callstack_log {
+    local text=$1
+    statedump_file=$(generate_mount_statedump $V0);
+    grep $text $statedump_file 2>/dev/null 1>/dev/null;
+    if [ $? -eq 0 ]; then
+        echo "1";
+    else
+        echo "0";
+    fi;
+}
+
 cleanup;
 
 TEST glusterd
@@ -13,21 +24,31 @@ TEST glusterfs -s $H0 --volfile-id $V0 $M0
 
 mount_pid=$(get_mount_process_pid $V0);
 # enable dumping of call stack creation and frame creation times in statedump
-kill -USR2 $mount_pid;
+# monitoring is enabled by default
+
+# We want to make sure that there is a pending frame in gluster stack.
+# For that we are creating a blocking lock scenario.
+
+TEST touch $M0/lockfile;
+# Open two fd's on the same file
+exec 8>$M0/lockfile;
+exec 9>$M0/lockfile;
+
+# First flock will succeed and the second one will block, hence the background run.
+flock -x 8 ;
+flock -x 9 &
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" check_callstack_log "callstack-creation-time";
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" check_callstack_log "frame-creation-time";
 
-TEST touch $M0/touchfile;
-(dd if=/dev/urandom of=$M0/file bs=5k 2>/dev/null 1>/dev/null)&
-back_pid=$!;
-statedump_file=$(generate_mount_statedump $V0);
-grep "callstack-creation-time" $statedump_file 2>/dev/null 1>/dev/null;
-TEST [ $? -eq 0 ];
-grep "frame-creation-time" $statedump_file 2>/dev/null 1>/dev/null;
-TEST [ $? -eq 0 ];
+flock -u 8
+flock -u 9;
 
-kill -SIGTERM $back_pid;
-wait >/dev/null 2>&1;
+# Closing the fd's
+exec 8>&-
+exec 9>&-
 
-TEST rm -f $M0/touchfile $M0/file;
+TEST rm -f $M0/lockfile;
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 
 rm -f $statedumpdir/glusterdump.$mount_pid.*;
diff --git a/tests/bugs/glusterfs/bug-867253.t b/tests/bugs/glusterfs/bug-867253.t
index c2c6c2ab629..8c3c39baace 100644
--- a/tests/bugs/glusterfs/bug-867253.t
+++ b/tests/bugs/glusterfs/bug-867253.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 function file_count()
diff --git a/tests/bugs/glusterfs/bug-872923.t b/tests/bugs/glusterfs/bug-872923.t
index 72e8f230864..00e02c89cbe 100755
--- a/tests/bugs/glusterfs/bug-872923.t
+++ b/tests/bugs/glusterfs/bug-872923.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/glusterfs/bug-873962-spb.t b/tests/bugs/glusterfs/bug-873962-spb.t
index db84a223089..db71cc0f6fe 100644
--- a/tests/bugs/glusterfs/bug-873962-spb.t
+++ b/tests/bugs/glusterfs/bug-873962-spb.t
@@ -14,6 +14,7 @@ TEST $CLI volume set $V0 performance.io-cache off
 TEST $CLI volume set $V0 performance.write-behind off
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.open-behind off
 TEST $CLI volume set $V0 cluster.background-self-heal-count 0
 TEST $CLI volume start $V0
 TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0 --direct-io-mode=enable
diff --git a/tests/bugs/glusterfs/bug-879490.t b/tests/bugs/glusterfs/bug-879490.t
index c254b4f59eb..fb8d4263919 100755
--- a/tests/bugs/glusterfs/bug-879490.t
+++ b/tests/bugs/glusterfs/bug-879490.t
@@ -10,7 +10,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
diff --git a/tests/bugs/glusterfs/bug-879494.t b/tests/bugs/glusterfs/bug-879494.t
index 06a5e5d876d..12ee466b33a 100755
--- a/tests/bugs/glusterfs/bug-879494.t
+++ b/tests/bugs/glusterfs/bug-879494.t
@@ -10,7 +10,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
diff --git a/tests/bugs/glusterfs/bug-893338.t b/tests/bugs/glusterfs/bug-893338.t
index 0df1b9af2fe..b915d3e791e 100644
--- a/tests/bugs/glusterfs/bug-893338.t
+++ b/tests/bugs/glusterfs/bug-893338.t
@@ -10,7 +10,7 @@ TEST glusterd;
 TEST pidof glusterd;
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 stripe 2 $H0:$B0/${V0}{1,2,3,4};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
diff --git a/tests/bugs/glusterfs/bug-896431.t b/tests/bugs/glusterfs/bug-896431.t
index 7764a88d896..61f71141713 100755
--- a/tests/bugs/glusterfs/bug-896431.t
+++ b/tests/bugs/glusterfs/bug-896431.t
@@ -8,7 +8,7 @@ cleanup;
 ## Start and create a volume
 TEST glusterd;
 TEST pidof glusterd;
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 ## Verify volume is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
@@ -87,38 +87,3 @@ TEST $CLI volume delete $V0;
 TEST ! $CLI volume info $V0;
 
 cleanup;
-
-## Start and create a pure stripe volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume create $V0 stripe 8 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
-
-## Verify volume is created
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT 'Stripe' volinfo_field $V0 'Type';
-
-## Start volume and verify
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Setting cluster.subvols-per-directory as 8 for a stripe volume
-TEST ! $CLI volume set $V0 cluster.subvols-per-directory 8
-EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory';
-TEST ! $CLI volume set $V0 subvols-per-directory 8
-EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory';
-
-## Setting cluster.subvols-per-directory as 1 for a stripe volume
-TEST $CLI volume set $V0 cluster.subvols-per-directory 1
-EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory';
-TEST $CLI volume set $V0 subvols-per-directory 1
-EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory';
-
-## Finish up
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-cleanup;
diff --git a/tests/bugs/glusterfs/bug-902610.t b/tests/bugs/glusterfs/bug-902610.t
index b45e92b8a3b..112c947e116 100755
--- a/tests/bugs/glusterfs/bug-902610.t
+++ b/tests/bugs/glusterfs/bug-902610.t
@@ -28,7 +28,7 @@ function get_layout()
 	fi
 
 	# Figure out where the join point is.
-	target=$( $PYTHON -c "print '%08x' % (0x$layout1_e + 1)")
+	target=$( $PYTHON -c "print('%08x' % (0x$layout1_e + 1))")
 	#echo "target for layout2 = $target" > /dev/tty
 
 	# The second layout should cover everything that the first doesn't.
diff --git a/tests/bugs/glusterfs/bug-906646.t b/tests/bugs/glusterfs/bug-906646.t
index 45c85d9f67c..37b8fe5c8eb 100644
--- a/tests/bugs/glusterfs/bug-906646.t
+++ b/tests/bugs/glusterfs/bug-906646.t
@@ -13,7 +13,6 @@ TEST pidof glusterd
 TEST $CLI volume create $V0 replica $REPLICA $H0:$B0/${V0}-00 $H0:$B0/${V0}-01 $H0:$B0/${V0}-10 $H0:$B0/${V0}-11
 TEST $CLI volume start $V0
 
-TEST $CLI volume set $V0 cluster.self-heal-daemon off
 TEST $CLI volume set $V0 cluster.background-self-heal-count 0
 
 ## Mount FUSE with caching disabled
@@ -82,10 +81,15 @@ EXPECT 1 xattr_query_check ${backend_paths_array[1]} "trusted.name"
 # restart the brick process
 TEST $CLI volume start $V0 force
 
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 `expr $brick_id - 1`
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 3
 
-cat $pth >/dev/null
+TEST $CLI volume heal $V0
 
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
 # check backends - xattr should not be present anywhere
 EXPECT 1 xattr_query_check ${backend_paths_array[0]} "trusted.name"
 EXPECT 1 xattr_query_check ${backend_paths_array[1]} "trusted.name"
diff --git a/tests/bugs/glusterfs/getlk_owner.c b/tests/bugs/glusterfs/getlk_owner.c
index 85fd1042496..cbe277318c1 100644
--- a/tests/bugs/glusterfs/getlk_owner.c
+++ b/tests/bugs/glusterfs/getlk_owner.c
@@ -3,24 +3,24 @@
 #include <fcntl.h>
 #include <string.h>
 
-#define GETLK_OWNER_CHECK(f, cp, label)                     \
-    do {                                                    \
-        switch (f.l_type) {                                 \
-        case F_RDLCK:                                       \
-        case F_WRLCK:                                       \
-            ret = 1;                                        \
-            goto label;                                     \
-        case F_UNLCK:                                       \
-            if (!are_flocks_sane (&f, &cp)) {               \
-                ret = 1;                                    \
-                goto label;                                 \
-            }                                               \
-            break;                                          \
-        }                                                   \
+#define GETLK_OWNER_CHECK(f, cp, label)                                        \
+    do {                                                                       \
+        switch (f.l_type) {                                                    \
+            case F_RDLCK:                                                      \
+            case F_WRLCK:                                                      \
+                ret = 1;                                                       \
+                goto label;                                                    \
+            case F_UNLCK:                                                      \
+                if (!are_flocks_sane(&f, &cp)) {                               \
+                    ret = 1;                                                   \
+                    goto label;                                                \
+                }                                                              \
+                break;                                                         \
+        }                                                                      \
     } while (0)
 
 void
-flock_init (struct flock *f, short int type, off_t start, off_t len)
+flock_init(struct flock *f, short int type, off_t start, off_t len)
 {
     f->l_type = type;
     f->l_start = start;
@@ -28,17 +28,16 @@ flock_init (struct flock *f, short int type, off_t start, off_t len)
 }
 
 int
-flock_cp (struct flock *dst, struct flock *src)
+flock_cp(struct flock *dst, struct flock *src)
 {
-    memcpy ((void *) dst, (void *) src, sizeof (struct flock));
+    memcpy((void *)dst, (void *)src, sizeof(struct flock));
 }
 
 int
-are_flocks_sane (struct flock *src, struct flock *cpy)
+are_flocks_sane(struct flock *src, struct flock *cpy)
 {
     return ((src->l_whence == cpy->l_whence) &&
-            (src->l_start == cpy->l_start) &&
-            (src->l_len == cpy->l_len));
+            (src->l_start == cpy->l_start) && (src->l_len == cpy->l_len));
 }
 
 /*
@@ -53,68 +52,73 @@ are_flocks_sane (struct flock *src, struct flock *cpy)
  *
  * */
 
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
     int fd = -1;
     int ret = 1;
     char *fname = NULL;
-    struct flock f = {0,};
-    struct flock cp = {0,};
+    struct flock f = {
+        0,
+    };
+    struct flock cp = {
+        0,
+    };
 
     if (argc < 2)
         goto out;
 
     fname = argv[1];
-    fd = open (fname, O_RDWR);
+    fd = open(fname, O_RDWR);
     if (fd == -1) {
-        perror ("open");
+        perror("open");
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 0, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_SETLK, &f);
+    flock_init(&f, F_WRLCK, 0, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_SETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         goto out;
     }
-    if (!are_flocks_sane (&f, &cp)) {
+    if (!are_flocks_sane(&f, &cp)) {
         ret = 1;
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_SETLK, &f);
+    flock_init(&f, F_WRLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_SETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         goto out;
     }
-    if (!are_flocks_sane (&f, &cp)) {
+    if (!are_flocks_sane(&f, &cp)) {
         ret = 1;
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_GETLK, &f);
+    flock_init(&f, F_WRLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_GETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         return 1;
     }
-    GETLK_OWNER_CHECK (f, cp, out);
+    GETLK_OWNER_CHECK(f, cp, out);
 
-    flock_init (&f, F_RDLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_GETLK, &f);
+    flock_init(&f, F_RDLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_GETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         return 1;
     }
-    GETLK_OWNER_CHECK (f, cp, out);
+    GETLK_OWNER_CHECK(f, cp, out);
 
 out:
     if (fd != -1)
-        close (fd);
+        close(fd);
     return ret;
 }
diff --git a/tests/bugs/heal-symlinks.t b/tests/bugs/heal-symlinks.t
new file mode 100644
index 00000000000..ecd2b525be1
--- /dev/null
+++ b/tests/bugs/heal-symlinks.t
@@ -0,0 +1,65 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../afr.rc
+cleanup;
+
+###############################################################################
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST "echo hello_world > FILE"
+TEST ln -s FILE SOFTLINK
+
+# Remove symlink only (not the .glusterfs entry) and trigger named heal.
+TEST rm -f $B0/${V0}2/SOFTLINK
+TEST stat SOFTLINK
+
+# To heal and clear new-entry mark on source bricks.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT 2 stat -c %h  $B0/${V0}2/SOFTLINK
+EXPECT "hello_world" cat $B0/${V0}2/SOFTLINK
+
+cd -
+cleanup
+###############################################################################
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 disperse 3 redundancy 1  $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+
+cd $M0
+TEST "echo hello_world > FILE"
+TEST ln -s FILE SOFTLINK
+
+# Remove symlink only (not the .glusterfs entry) and trigger named heal.
+TEST rm -f $B0/${V0}2/SOFTLINK
+TEST stat SOFTLINK
+
+# To heal and clear new-entry mark on source bricks.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT 2 stat -c %h  $B0/${V0}2/SOFTLINK
+TEST kill_brick $V0 $H0 $B0/${V0}0
+cd -
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 --entry-timeout=0 $M0;
+cd $M0
+EXPECT "hello_world" cat SOFTLINK
+
+cd -
+cleanup
+###############################################################################
diff --git a/tests/bugs/index/bug-1559004-EMLINK-handling.t b/tests/bugs/index/bug-1559004-EMLINK-handling.t
new file mode 100644
index 00000000000..5596fa56c4c
--- /dev/null
+++ b/tests/bugs/index/bug-1559004-EMLINK-handling.t
@@ -0,0 +1,91 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+function create_fake_links() {
+        local dst="$1"
+        local dir="$2"
+        local end=0
+        local start=0
+        local src
+
+        src="$(ls ${dst}/.glusterfs/indices/${dir}/${dir}-* | head -1)"
+        mkdir -p ${dst}/.glusterfs/dummy/${dir}
+        while ln ${src} ${dst}/.glusterfs/dummy/${dir}/link-${end}; do
+                end="$((${end} + 1))"
+        done
+
+        if [[ ${end} -gt 50 ]]; then
+                start="$((${end} - 50))"
+        fi
+        if [[ ${end} -gt 0 ]]; then
+                end="$((${end} - 1))"
+        fi
+
+        for i in $(seq ${start} ${end}); do
+                rm -f ${dst}/.glusterfs/dummy/${dir}/link-${i}
+        done
+}
+
+function count_fake_links() {
+        local dst="$1"
+        local dir="$2"
+
+        echo "$(find ${dst}/.glusterfs/dummy/${dir}/ -name "link-*" | wc -l)"
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info
+
+TEST touch $B0/ext4-1
+TEST touch $B0/ext4-2
+TEST touch $B0/ext4-3
+TEST truncate -s 2GB $B0/ext4-1
+TEST truncate -s 2GB $B0/ext4-2
+TEST truncate -s 2GB $B0/ext4-3
+
+TEST mkfs.ext4 -F $B0/ext4-1
+TEST mkfs.ext4 -F $B0/ext4-2
+TEST mkfs.ext4 -F $B0/ext4-3
+TEST mkdir $B0/ext41
+TEST mkdir $B0/ext42
+TEST mkdir $B0/ext43
+TEST mount -t ext4 -o loop $B0/ext4-1 $B0/ext41
+TEST mount -t ext4 -o loop $B0/ext4-2 $B0/ext42
+TEST mount -t ext4 -o loop $B0/ext4-3 $B0/ext43
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/ext4{1,2,3}
+TEST $CLI volume start $V0
+TEST $CLI volume heal $V0 granular-entry-heal enable
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+TEST kill_brick $V0 $H0 $B0/ext41
+
+# Make sure indices exist and are initialized
+TEST touch $M0/dummy
+
+# Create enough hard links on bricks to make it fail faster. This is much
+# faster than creating ~70000 files on a volume.
+create_fake_links $B0/ext42 xattrop &
+create_fake_links $B0/ext42 entry-changes &
+wait
+count_xattrop="$(count_fake_links $B0/ext42 xattrop)"
+count_entry="$(count_fake_links $B0/ext42 entry-changes)"
+
+TEST mkdir $M0/d{1..10}
+TEST touch $M0/d{1..10}/{1..10}
+
+#On ext4 max number of hardlinks is ~65k, so there should be 2 base index files
+EXPECT "^2$" echo $(ls $B0/ext42/.glusterfs/indices/xattrop | grep xattrop | wc -l)
+EXPECT "^2$" echo $(ls $B0/ext42/.glusterfs/indices/entry-changes | grep entry-changes | wc -l)
+
+#Number of hardlinks: count_xattrop/count_entry for fake links, 101 for files,
+# 10 for dirs and 2 for base-indices and root-dir for xattrop
+EXPECT "$((${count_xattrop} + 114))" echo $(ls -l $B0/ext42/.glusterfs/indices/xattrop | grep xattrop | awk '{sum+=$2} END{print sum}')
+EXPECT "$((${count_entry} + 113))" echo $(ls -l $B0/ext42/.glusterfs/indices/entry-changes | grep entry-changes | awk '{sum+=$2} END{print sum}')
+
+cleanup
diff --git a/tests/bugs/io-cache/bug-858242.c b/tests/bugs/io-cache/bug-858242.c
index b6a412d578c..ac87a15533e 100644
--- a/tests/bugs/io-cache/bug-858242.c
+++ b/tests/bugs/io-cache/bug-858242.c
@@ -10,72 +10,75 @@
 #include <unistd.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char        *filename = NULL, *volname = NULL, *cmd = NULL;
-        char  buffer[1024]    = {0, };
-        int          fd       = -1;
-        int          ret      = -1;
-        struct stat  statbuf  = {0, };
+    char *filename = NULL, *volname = NULL, *cmd = NULL;
+    char buffer[1024] = {
+        0,
+    };
+    int fd = -1;
+    int ret = -1;
+    struct stat statbuf = {
+        0,
+    };
 
-        if (argc != 3) {
-                fprintf (stderr, "usage: %s <file-name> <volname>\n", argv[0]);
-                goto out;
-        }
+    if (argc != 3) {
+        fprintf(stderr, "usage: %s <file-name> <volname>\n", argv[0]);
+        goto out;
+    }
 
-        filename = argv[1];
-        volname = argv[2];
+    filename = argv[1];
+    volname = argv[2];
 
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
 
-        ret = write (fd, "test-content", 12);
-        if (ret < 0) {
-                fprintf (stderr, "write failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = write(fd, "test-content", 12);
+    if (ret < 0) {
+        fprintf(stderr, "write failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = fstat (fd, &statbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = fstat(fd, &statbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = asprintf (&cmd, "gluster --mode=script volume stop %s force",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                goto out;
-        }
+    ret = asprintf(&cmd, "gluster --mode=script volume stop %s force", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        goto out;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "stopping volume (%s) failed", volname);
-                goto out;
-        }
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "stopping volume (%s) failed", volname);
+        goto out;
+    }
 
-        sleep (3);
+    sleep(3);
 
-        ret = read (fd, buffer, 1024);
-        if (ret >= 0) {
-                fprintf (stderr, "read should've returned error, "
-                         "but is successful\n");
-                ret = -1;
-                goto out;
-        }
+    ret = read(fd, buffer, 1024);
+    if (ret >= 0) {
+        fprintf(stderr,
+                "read should've returned error, "
+                "but is successful\n");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/io-cache/bug-read-hang.c b/tests/bugs/io-cache/bug-read-hang.c
index 74dfddd7a6e..e1fae97e7e8 100644
--- a/tests/bugs/io-cache/bug-read-hang.c
+++ b/tests/bugs/io-cache/bug-read-hang.c
@@ -9,117 +9,117 @@
 
 int count = 0;
 void
-read_cbk (glfs_fd_t *fd, ssize_t ret, void *data) {
-count++;
+read_cbk(glfs_fd_t *fd, ssize_t ret, void *data)
+{
+    count++;
 }
 
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_file, int flag)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_file, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        if (flag == NO_INIT)
-                goto out;
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    if (flag == NO_INIT)
+        goto out;
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
 
 out:
-        return fs;
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret         = 0;
-        glfs_t    *fs          = NULL;
-        struct glfs_fd *fd     = NULL;
-        char      *volname     = NULL;
-        char      *log_file    = NULL;
-        char      *hostname    = NULL;
-        char      *buf = NULL;
-        struct stat stat;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        log_file = argv[3];
-
-        fs = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "/: %s\n", strerror (errno));
-                return -1;
-        }
-
-        glfs_readdirplus (fd, &stat);
-
-        fd = glfs_open (fs, "/test", O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto error;
-        }
-
-        buf = (char *) malloc (5);
-
-        ret = glfs_pread (fd, buf, 5, 0, 0);
-        if (ret < 0) {
-                fprintf (stderr, "Read(%s): %d (%s)\n", "test", ret,
-                         strerror (errno));
-                return ret;
-        }
-
-        free (buf);
-        glfs_close (fd);
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                return -1;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_fd *fd = NULL;
+    char *volname = NULL;
+    char *log_file = NULL;
+    char *hostname = NULL;
+    char *buf = NULL;
+    struct stat stat;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    log_file = argv[3];
+
+    fs = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    glfs_readdirplus(fd, &stat);
+
+    fd = glfs_open(fs, "/test", O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto error;
+    }
+
+    buf = (char *)malloc(5);
+
+    ret = glfs_pread(fd, buf, 5, 0, 0, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Read(%s): %d (%s)\n", "test", ret, strerror(errno));
+        return ret;
+    }
+
+    free(buf);
+    glfs_close(fd);
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
         return -1;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/io-stats/bug-1598548.t b/tests/bugs/io-stats/bug-1598548.t
new file mode 100755
index 00000000000..19b0c053d08
--- /dev/null
+++ b/tests/bugs/io-stats/bug-1598548.t
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../nfs.rc
+
+checkdumpthread () {
+        local brick_pid=$(get_brick_pid $1 $2 $3)
+        local thread_count=$(gstack $brick_pid | grep -c _ios_dump_thread)
+        echo $thread_count
+}
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume start $V0
+
+TEST $CLI volume profile $V0 start
+EXPECT 0 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 3
+EXPECT 1 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 10
+EXPECT 1 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 0
+EXPECT 0 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 7
+EXPECT 1 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 0
+EXPECT 0 checkdumpthread $V0 $H0 $B0/${V0}0
+
+TEST $CLI volume set $V0 diagnostics.stats-dump-interval 11
+EXPECT 1 checkdumpthread $V0 $H0 $B0/${V0}0
+
+cleanup;
diff --git a/tests/bugs/logging/bug-823081.t b/tests/bugs/logging/bug-823081.t
index 0ed8f4c26c1..bd1965d2d49 100755
--- a/tests/bugs/logging/bug-823081.t
+++ b/tests/bugs/logging/bug-823081.t
@@ -22,20 +22,20 @@ function set_tail ()
 set_tail $V0;
 
 TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 5-`
+tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 6-`
 TEST [[ \"$tail\" == \"$tail_success\" ]]
 
 TEST ! $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 5-`
+tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 6-`
 TEST [[ \"$tail\" == \"$tail_failure\" ]]
 
 set_tail $V1;
 TEST gluster volume create $V1 $H0:$B0/${V1}{1,2} force;
-tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 5-`
+tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 6-`
 TEST [[ \"$tail\" == \"$tail_success_force\" ]]
 
 TEST ! gluster volume create $V1 $H0:$B0/${V1}{1,2} force;
-tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 5-`
+tail=`tail -n 1 $logdir/$cmd_log_history | cut -d " " -f 6-`
 TEST [[ \"$tail\" == \"$tail_failure_force\" ]]
 
 cleanup;
diff --git a/tests/bugs/md-cache/bug-1211863.t b/tests/bugs/md-cache/bug-1211863.t
index ece42fe8d81..ba9bde9fee8 100644..100755
--- a/tests/bugs/md-cache/bug-1211863.t
+++ b/tests/bugs/md-cache/bug-1211863.t
@@ -16,7 +16,7 @@ TEST $CLI volume start $V0
 
 ## 4. Enable the upcall xlator, and increase the md-cache timeout to max
 TEST $CLI volume set $V0 performance.md-cache-timeout 600
-TEST $CLI volume set $V0 performance.cache-samba-metadata on
+TEST $CLI volume set $V0 performance.xattr-cache-list "user.*"
 
 ## 6. Create two gluster mounts
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
diff --git a/tests/bugs/md-cache/bug-1632503.t b/tests/bugs/md-cache/bug-1632503.t
new file mode 100755
index 00000000000..aeb57f65639
--- /dev/null
+++ b/tests/bugs/md-cache/bug-1632503.t
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+TESTS_EXPECTED_IN_LOOP=5
+
+TEST glusterd;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2,3};
+
+TEST $CLI volume start $V0
+
+TEST $CLI volume set $V0 performance.md-cache-timeout 600
+TEST $CLI volume set $V0 performance.md-cache-statfs on
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+for i in $(seq 1 5); do
+    TEST_IN_LOOP df $M0;
+done
+
+cleanup;
diff --git a/tests/bugs/md-cache/bug-1726205.t b/tests/bugs/md-cache/bug-1726205.t
new file mode 100644
index 00000000000..795130e9bd8
--- /dev/null
+++ b/tests/bugs/md-cache/bug-1726205.t
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2,3};
+
+TEST $CLI volume start $V0
+
+TEST $CLI volume set $V0 group samba
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST touch $M0/file
+TEST "setfattr -n "user.DosStream.Zone.Identifier:\$DATA" -v '\0' $M0/file"
+TEST "getfattr -n "user.DosStream.Zone.Identifier:\$DATA" -e hex $M0/file | grep -q 0x00"
+
+cleanup;
diff --git a/tests/bugs/md-cache/setxattr-prepoststat.t b/tests/bugs/md-cache/setxattr-prepoststat.t
new file mode 100755
index 00000000000..01fa768299c
--- /dev/null
+++ b/tests/bugs/md-cache/setxattr-prepoststat.t
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+## 1. Start glusterd
+TEST glusterd;
+
+## 2. Lets create volume
+TEST $CLI volume create $V0 disperse 6 redundancy 2 $H0:$B0/${V0}{0..5}
+
+TEST $CLI volume set $V0 group metadata-cache
+TEST $CLI volume set $V0 performance.xattr-cache-list "user.*"
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M1
+
+TEST touch $M0/file1
+TEST `echo "abakjshdjahskjdhakjhdskjac" >> $M0/file1`
+size=`stat -c '%s' $M0/file1`
+
+## Setxattr from mount-0
+TEST "setfattr -n user.DOSATTRIB -v "abc" $M0/file1"
+EXPECT $size stat -c '%s' $M0/file1
+
+## Getxattr from mount-1, this should return the correct value
+TEST "getfattr -n user.DOSATTRIB $M1/file1 | grep -q abc"
+
+TEST "setfattr -x user.DOSATTRIB $M1/file1"
+EXPECT $size stat -c '%s' $M1/file1
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
+
+cleanup;
diff --git a/tests/bugs/nfs/bug-1053579.t b/tests/bugs/nfs/bug-1053579.t
index f616eb2baa5..2f53172e24c 100755
--- a/tests/bugs/nfs/bug-1053579.t
+++ b/tests/bugs/nfs/bug-1053579.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup
 
 # prepare the users and groups
diff --git a/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t b/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
index b194b3744b4..c360db4c91c 100644
--- a/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
+++ b/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
@@ -2,6 +2,9 @@
 
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/nfs/bug-1157223-symlink-mounting.t b/tests/bugs/nfs/bug-1157223-symlink-mounting.t
index 740d638193d..dea609ed193 100644
--- a/tests/bugs/nfs/bug-1157223-symlink-mounting.t
+++ b/tests/bugs/nfs/bug-1157223-symlink-mounting.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 ## Start and create a volume
diff --git a/tests/bugs/nfs/bug-1161092-nfs-acls.t b/tests/bugs/nfs/bug-1161092-nfs-acls.t
index 1304ad905bf..45a22e79336 100644
--- a/tests/bugs/nfs/bug-1161092-nfs-acls.t
+++ b/tests/bugs/nfs/bug-1161092-nfs-acls.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/nfs/bug-1166862.t b/tests/bugs/nfs/bug-1166862.t
index f986fe36ab7..c4f51a2d446 100755
--- a/tests/bugs/nfs/bug-1166862.t
+++ b/tests/bugs/nfs/bug-1166862.t
@@ -5,6 +5,8 @@
 # Based on: bug-904065.t
 #
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 # count the lines of a file, return 0 if the file does not exist
 function count_lines()
 {
diff --git a/tests/bugs/nfs/bug-1210338.c b/tests/bugs/nfs/bug-1210338.c
index 7a17b9d68ce..d4099244176 100644
--- a/tests/bugs/nfs/bug-1210338.c
+++ b/tests/bugs/nfs/bug-1210338.c
@@ -7,26 +7,25 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret  = -1;
-        int   fd   = -1;
+    int ret = -1;
+    int fd = -1;
 
-        fd = open (argv[1], O_CREAT|O_EXCL, 0644);
+    fd = open(argv[1], O_CREAT | O_EXCL, 0644);
 
-        if (fd == -1) {
-                fprintf (stderr, "creation of the file %s failed (%s)\n", argv[1],
-                         strerror (errno));
-                goto out;
-        }
+    if (fd == -1) {
+        fprintf(stderr, "creation of the file %s failed (%s)\n", argv[1],
+                strerror(errno));
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd > 0)
-                close (fd);
+    if (fd > 0)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/nfs/bug-1210338.t b/tests/bugs/nfs/bug-1210338.t
index 4232b9d8748..b5c9245affd 100644
--- a/tests/bugs/nfs/bug-1210338.t
+++ b/tests/bugs/nfs/bug-1210338.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 NFS_SOURCE=$(dirname $0)/bug-1210338.c
diff --git a/tests/bugs/nfs/bug-847622.t b/tests/bugs/nfs/bug-847622.t
index 3b836745a07..5ccee722ed9 100755
--- a/tests/bugs/nfs/bug-847622.t
+++ b/tests/bugs/nfs/bug-847622.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 case $OSTYPE in
 NetBSD)
         echo "Skip test on ACL which are not available on NetBSD" >&2
diff --git a/tests/bugs/nfs/bug-877885.t b/tests/bugs/nfs/bug-877885.t
index a47893d7fcb..dca315a3d01 100755
--- a/tests/bugs/nfs/bug-877885.t
+++ b/tests/bugs/nfs/bug-877885.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/nfs/bug-904065.t b/tests/bugs/nfs/bug-904065.t
index effd5972c9a..0eba86e7ee8 100755
--- a/tests/bugs/nfs/bug-904065.t
+++ b/tests/bugs/nfs/bug-904065.t
@@ -7,6 +7,8 @@
 # sufficient.
 #
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 # count the lines of a file, return 0 if the file does not exist
 function count_lines()
 {
diff --git a/tests/bugs/nfs/bug-915280.t b/tests/bugs/nfs/bug-915280.t
index d70c36f0a53..bd279157c25 100755
--- a/tests/bugs/nfs/bug-915280.t
+++ b/tests/bugs/nfs/bug-915280.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/nfs/bug-974972.t b/tests/bugs/nfs/bug-974972.t
index d05e7df1a9f..975c46f85a4 100755
--- a/tests/bugs/nfs/bug-974972.t
+++ b/tests/bugs/nfs/bug-974972.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 #This script checks that nfs mount does not fail lookup on files with split-brain
 cleanup;
 
@@ -11,6 +13,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
 TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 cluster.eager-lock off
 TEST $CLI volume set $V0 nfs.disable false
 TEST $CLI volume start $V0
 EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
diff --git a/tests/bugs/nfs/showmount-many-clients.t b/tests/bugs/nfs/showmount-many-clients.t
index f1b6859d528..c6c9c35d60a 100644
--- a/tests/bugs/nfs/showmount-many-clients.t
+++ b/tests/bugs/nfs/showmount-many-clients.t
@@ -12,6 +12,8 @@
 # the groups into their own structures, this testcase passes.
 #
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
diff --git a/tests/bugs/nfs/socket-as-fifo.py b/tests/bugs/nfs/socket-as-fifo.py
index 1fce5b96896..eb507e1d30b 100755
--- a/tests/bugs/nfs/socket-as-fifo.py
+++ b/tests/bugs/nfs/socket-as-fifo.py
@@ -1,10 +1,10 @@
-#!/usr/bin/env python
 #
 # Create a unix domain socket and test if it is a socket (and not a fifo/pipe).
 #
 # Author: Niels de Vos <ndevos@redhat.com>
 #
 
+from __future__ import print_function
 import os
 import stat
 import sys
@@ -13,7 +13,7 @@ import socket
 ret = 1
 
 if len(sys.argv) != 2:
-        print 'Usage: %s <socket>' % (sys.argv[0])
+        print('Usage: %s <socket>' % (sys.argv[0]))
         sys.exit(ret)
 
 path = sys.argv[1]
diff --git a/tests/bugs/nfs/socket-as-fifo.t b/tests/bugs/nfs/socket-as-fifo.t
index ca5f2af6f2b..d9b9e959ce3 100644
--- a/tests/bugs/nfs/socket-as-fifo.t
+++ b/tests/bugs/nfs/socket-as-fifo.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
@@ -16,7 +18,7 @@ EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
 TEST mount_nfs $H0:/$V0 $N0 nolock
 
 # this is the actual test
-TEST $(dirname $0)/socket-as-fifo.py $N0/not-a-fifo.socket
+TEST $PYTHON $(dirname $0)/socket-as-fifo.py $N0/not-a-fifo.socket
 
 TEST umount_nfs $N0
 
diff --git a/tests/bugs/nfs/subdir-trailing-slash.t b/tests/bugs/nfs/subdir-trailing-slash.t
index a00959443d0..6a114877ac7 100644
--- a/tests/bugs/nfs/subdir-trailing-slash.t
+++ b/tests/bugs/nfs/subdir-trailing-slash.t
@@ -10,6 +10,7 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
 
 cleanup;
 TEST glusterd
diff --git a/tests/bugs/nfs/zero-atime.t b/tests/bugs/nfs/zero-atime.t
index 631240a692f..2a940091ad9 100755
--- a/tests/bugs/nfs/zero-atime.t
+++ b/tests/bugs/nfs/zero-atime.t
@@ -8,6 +8,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup
 
 TEST glusterd
diff --git a/tests/bugs/posix/bug-1040275-brick-uid-reset-on-volume-restart.t b/tests/bugs/posix/bug-1040275-brick-uid-reset-on-volume-restart.t
index e67616db618..3839c6e3380 100755
--- a/tests/bugs/posix/bug-1040275-brick-uid-reset-on-volume-restart.t
+++ b/tests/bugs/posix/bug-1040275-brick-uid-reset-on-volume-restart.t
@@ -11,17 +11,21 @@ function get_gid() {
     stat -c '%g' $1;
 }
 
+function check_stat() {
+    stat $1
+    echo $?
+}
 
 cleanup;
 
 TEST glusterd
 TEST pidof glusterd
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '8' brick_count $V0
+EXPECT '6' brick_count $V0
 
 TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
@@ -37,7 +41,10 @@ EXPECT 100 get_uid $M0;
 EXPECT 101 get_gid $M0;
 
 TEST $CLI volume stop $V0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" online_brick_count
+
 TEST $CLI volume start $V0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "6" online_brick_count
 
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
@@ -45,9 +52,8 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 3
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 4
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 5
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 6
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 7
 
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" check_stat $M0
 EXPECT 100 get_uid $M0;
 EXPECT 101 get_gid $M0;
 
diff --git a/tests/bugs/posix/bug-1175711.c b/tests/bugs/posix/bug-1175711.c
index fbbea3f636b..8ab193c4014 100644
--- a/tests/bugs/posix/bug-1175711.c
+++ b/tests/bugs/posix/bug-1175711.c
@@ -6,32 +6,32 @@
 int
 main(int argc, char **argv)
 {
-        DIR *dir = NULL;
-        struct dirent *entry = NULL;
-        int ret = 0;
-        char *path = NULL;
+    DIR *dir = NULL;
+    struct dirent *entry = NULL;
+    int ret = 0;
+    char *path = NULL;
 
-        assert (argc == 2);
-        path = argv[1];
+    assert(argc == 2);
+    path = argv[1];
 
-        dir = opendir(path);
-        if (!dir) {
-                printf("opendir(%s) failed.\n", path);
-                return -1;
-        }
+    dir = opendir(path);
+    if (!dir) {
+        printf("opendir(%s) failed.\n", path);
+        return -1;
+    }
 
 #ifdef _DIRENT_HAVE_D_TYPE
-        while ((entry = readdir(dir)) != NULL) {
-                if (entry->d_type == DT_UNKNOWN) {
-                        printf("d_type found to be DT_UNKNOWN\n");
-                        ret = -1;
-                        break;
-                }
+    while ((entry = readdir(dir)) != NULL) {
+        if (entry->d_type == DT_UNKNOWN) {
+            printf("d_type found to be DT_UNKNOWN\n");
+            ret = -1;
+            break;
         }
+    }
 #endif
 
-        if (dir)
-                closedir(dir);
+    if (dir)
+        closedir(dir);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/posix/bug-1619720.t b/tests/bugs/posix/bug-1619720.t
new file mode 100755
index 00000000000..bfd304dc809
--- /dev/null
+++ b/tests/bugs/posix/bug-1619720.t
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../dht.rc
+
+cleanup;
+
+
+# Test steps:
+# The test checks to make sure that the trusted.pgfid.xx xattr is set on
+# both the linkto and data files post the final rename.
+# The test creates files file-1 and file-3 so that src_hashed = dst_hashed,
+# src_cached = dst_cached and xxx_hashed != xxx_cached.
+# It then renames file-1 to file-3 which triggers the posix_mknod call
+# which updates the trusted.pgfid.xx xattr.
+
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 storage.build-pgfid on
+
+## Mount FUSE
+TEST glusterfs -s $H0 --volfile-id $V0 $M0;
+
+TEST mkdir $M0/tmp
+
+
+
+# Not the best way to do this but I need files which hash to the same subvol and
+# whose cached subvols are the same.
+# In a 2 subvol distributed volume, file-{1,3} hash to the same subvol.
+# file-2 will hash to the other subvol
+
+TEST touch $M0/tmp/file-2
+pgfid_xattr_name=$(getfattr -m "trusted.pgfid.*" $B0/${V0}1/tmp/file-2 | grep "trusted.pgfid")
+echo $pgfid_xattr_name
+
+
+TEST mv $M0/tmp/file-2 $M0/tmp/file-1
+TEST touch $M0/tmp/file-2
+TEST mv $M0/tmp/file-2 $M0/tmp/file-3
+
+# At this point, both the file-1 and file-3 data files exist on one subvol
+# and both linkto files on the other
+
+TEST mv -f $M0/tmp/file-1 $M0/tmp/file-3
+
+
+TEST getfattr -n $pgfid_xattr_name $B0/${V0}0/tmp/file-3
+TEST getfattr -n $pgfid_xattr_name $B0/${V0}1/tmp/file-3
+
+# Not required for the test but an extra check if required.
+# The linkto file was not renamed Without the fix.
+#TEST mv $M0/tmp/file-3 $M0/tmp/file-6
+cleanup;
diff --git a/tests/bugs/posix/bug-1651445.t b/tests/bugs/posix/bug-1651445.t
new file mode 100644
index 00000000000..4d08b69b9b0
--- /dev/null
+++ b/tests/bugs/posix/bug-1651445.t
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup
+
+TEST verify_lvm_version
+TEST glusterd
+TEST pidof glusterd
+TEST init_n_bricks 3
+TEST setup_lvm 3
+
+TEST $CLI volume create $V0 replica 3 $H0:$L{1,2,3}
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+#Setting the size in bytes
+TEST $CLI volume set $V0 storage.reserve 40MB
+
+#wait 5s to reset disk_space_full flag
+sleep 5
+
+TEST dd if=/dev/zero of=$M0/a bs=100M count=1
+TEST dd if=/dev/zero of=$M0/b bs=10M count=1
+
+# Wait 5s to update disk_space_full flag because thread check disk space
+# after every 5s
+
+sleep 5
+# setup_lvm create lvm partition of 150M and 40M are reserve so after
+# consuming more than 110M next dd should fail
+TEST ! dd if=/dev/zero of=$M0/c bs=5M count=1
+TEST dd if=/dev/urandom of=$M0/a  bs=1022 count=1  oflag=seek_bytes,sync seek=102 conv=notrunc
+
+rm -rf $M0/*
+
+#Setting the size in percent and repeating the above steps
+TEST $CLI volume set $V0 storage.reserve 40
+
+sleep 5
+
+TEST dd if=/dev/zero of=$M0/a bs=80M count=1
+TEST dd if=/dev/zero of=$M0/b bs=10M count=1
+
+sleep 5
+TEST ! dd if=/dev/zero of=$M0/c bs=5M count=1
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/posix/bug-990028.t b/tests/bugs/posix/bug-990028.t
index c86421492cd..bef36a8897d 100755
--- a/tests/bugs/posix/bug-990028.t
+++ b/tests/bugs/posix/bug-990028.t
@@ -78,7 +78,7 @@ function links_across_directories()
     TEST [ $LINES = 2 ]
 
     for i in $(seq 1  2); do
-        HL=`getfattr -m "trusted.pgfid.*" -de hex $B0/brick/dir$i/file$i 2>&1 | grep "trusted.pgfid" | cut -d$'\n' -f$i | cut -d'=' -f2`
+        HL=`getfattr -m "trusted.pgfid.*" -de hex $B0/brick/dir$i/file$i 2>&1 | grep "trusted.pgfid" | awk -v n=$i 'NR==n' | cut -d'=' -f2`
         TEST_IN_LOOP [ $HL = "0x00000001" ]
     done
 
diff --git a/tests/bugs/posix/bug-gfid-path.t b/tests/bugs/posix/bug-gfid-path.t
new file mode 100644
index 00000000000..1bbbe9f0670
--- /dev/null
+++ b/tests/bugs/posix/bug-gfid-path.t
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# This test case is for the bug where, even though a file is
+# created when gfid2path option is turned off (default is ON),
+# getfattr of "glusterfs.gfidtopath" was succeeding for that
+# file. Ideally the getfattr should fail, as the file does not
+# have its path(s) stored as a extended attribute (because it
+# was created when gfid2path option was off)
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2,3,4};
+
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+EXPECT '4' brick_count $V0
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+TEST glusterfs -s $H0 --volfile-id $V0 $M0;
+
+TEST mkdir $M0/dir
+TEST mkdir $M0/new
+TEST mkdir $M0/3
+
+TEST touch $M0/dir/file
+
+# except success as by default gfid2path is enabled
+# and the glusterfs.gfidtopath xattr should give the
+# path of the object as the value
+
+TEST getfattr -n glusterfs.gfidtopath $M0/dir/file
+
+# turn off gfid2path feature
+TEST $CLI volume set $V0 storage.gfid2path off
+
+TEST touch $M0/new/foo
+
+# again enable gfid2path. This has to be enabled before
+# trying the getfattr. Because, glusterfs.gfidtopath xattr
+# request is handled only if gfid2path is enabled. If not,
+# then getxattr on glusterfs.gfid2path fails anyways. In this
+# context we want getfattr to fail, because the file was created
+# when gfid2path feature was disabled and not because gfid2path
+# feature itself is disabled.
+TEST $CLI volume set $V0 storage.gfid2path on
+
+# getfattr should fail as it is attempted on a file
+# which does not have its path stored as a xattr
+# (because file got created after disabling gfid2path)
+TEST ! getfattr -n glusterfs.gfidtopath $M0/new/foo;
+
+
+
+TEST touch $M0/3/new
+
+# should be successful
+TEST getfattr -n glusterfs.gfidtopath $M0/3/new
+
+TEST rm -rf $M0/*
+
+cleanup;
diff --git a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
index 325edbbed97..4ed3181d48f 100644
--- a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
+++ b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
@@ -5,94 +5,100 @@
 #include <string.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs       = NULL;
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        char      *logfile  = NULL;
-        char      *hostname = NULL;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
 
-        if (argc != 4) {
-                fprintf (stderr,
-                        "Expect following args %s <hostname> <Vol> <log file>\n"
-                        , argv[0]);
-                return -1;
-        }
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <hostname> <Vol> <log file>\n",
+                argv[0]);
+        return -1;
+    }
 
-        hostname = argv[1];
-        logfile = argv[3];
+    hostname = argv[1];
+    logfile = argv[3];
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL (%s)\n",
-                        strerror (errno));
-                return -1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n",
-                ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_init failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "glfs_opendir failed with (%s)\n",
-                         strerror (errno));
-                return -1;
-        }
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "glfs_opendir failed with (%s)\n", strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.gfid");
-        if (ret == 0 || errno != EPERM) {
-                fprintf (stderr, "glfs_fremovexattr gfid exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.gfid");
+    if (ret == 0 || errno != EPERM) {
+        fprintf(stderr,
+                "glfs_fremovexattr gfid exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.glusterfs.volume-id");
-        if (ret == 0 || errno != EPERM) {
-                fprintf (stderr, "glfs_fremovexattr volume-id exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.glusterfs.volume-id");
+    if (ret == 0 || errno != EPERM) {
+        fprintf(stderr,
+                "glfs_fremovexattr volume-id exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fsetxattr (fd, "trusted.abc", "abc", 3, 0);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fsetxattr trusted.abc exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fsetxattr(fd, "trusted.abc", "abc", 3, 0);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_fsetxattr trusted.abc exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.abc");
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fremovexattr trusted.abc exited with "
-                         "ret: %d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.abc");
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_fremovexattr trusted.abc exited with "
+                "ret: %d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        (void) glfs_closedir(fd);
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
-        return 0;
+    (void)glfs_closedir(fd);
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+    return 0;
 }
diff --git a/tests/bugs/protocol/bug-1321578.t b/tests/bugs/protocol/bug-1321578.t
index 160fc408fba..83904817467 100644
--- a/tests/bugs/protocol/bug-1321578.t
+++ b/tests/bugs/protocol/bug-1321578.t
@@ -6,6 +6,7 @@ check_mounted () {
 	df | grep $1 | wc -l
 }
 
+CHECK_MOUNT_TIMEOUT=7
 
 TEST glusterd
 TEST $CLI volume create $V0 $H0:$B0/$V0
@@ -23,15 +24,59 @@ $CLI system getspec $V0 | sed -e /username/d -e /password/d > fubar.vol
 # This mount should fail because auth.allow doesn't include us.
 TEST $GFS -f fubar.vol $M0
 
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT 0 check_mounted $M0
+
+# Add tests when only username is present, but not password
+# "System getspec" will include the username and password if the request comes
+# from a server (which we are).  Unfortunately, this will cause authentication
+# to succeed in auth.login regardless of whether auth.addr is working properly
+# or not, which is useless to us.  To get a proper test, strip out those lines.
+$CLI system getspec $V0 | sed -e /password/d > fubar.vol
+
+# This mount should fail because auth.allow doesn't include our password.
+TEST $GFS -f fubar.vol $M0
+
 # If we had DONT_EXPECT_WITHIN we could use that, but we don't.
-sleep 10
-EXPECT 0 check_mounted $M0
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT 0 check_mounted $M0
+
+# Now, add a test for login failure when server doesn't have the password entry
+# Add tests when only username is present, but not password
+# "System getspec" will include the username and password if the request comes
+# from a server (which we are).  Unfortunately, this will cause authentication
+# to succeed in auth.login regardless of whether auth.addr is working properly
+# or not, which is useless to us.  To get a proper test, strip out those lines.
+$CLI system getspec $V0 > fubar.vol
+TEST $CLI volume stop $V0
+
+sed -i -e '/password /d' /var/lib/glusterd/vols/$V0/$V0.*$V0.vol
+
+TEST $CLI volume start $V0
+
+# This mount should fail because auth.allow doesn't include our password.
+TEST $GFS -f fubar.vol $M0
+
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT 0 check_mounted $M0
 
 # Set auth.allow to include us.  This mount should therefore succeed.
 TEST $CLI volume set $V0 auth.allow $H0
+$CLI system getspec $V0 | sed -e /password/d > fubar.vol
+
+TEST $GFS -f fubar.vol $M0
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT 1 check_mounted $M0
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+# Set auth.reject to include us.  This mount should therefore fail.
+TEST $CLI volume stop $V0
+
+TEST $CLI volume set $V0 auth.allow "\*"
+TEST $CLI volume set $V0 auth.reject $H0
+TEST $CLI volume start $V0
+
+# Do this, so login module is not in picture
+$CLI system getspec $V0 | sed -e /password/d > fubar.vol
 
 TEST $GFS -f fubar.vol $M0
-sleep 10
-EXPECT 1 check_mounted $M0
+EXPECT_WITHIN $CHECK_MOUNT_TIMEOUT 0 check_mounted $M0
 
 cleanup
diff --git a/tests/bugs/protocol/bug-1390914.t b/tests/bugs/protocol/bug-1390914.t
new file mode 100644
index 00000000000..e3dab92de5a
--- /dev/null
+++ b/tests/bugs/protocol/bug-1390914.t
@@ -0,0 +1,36 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
+cleanup;
+
+#test that fops are not wound on anon-fd when fd is not open on that brick
+TEST glusterd;
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3};
+TEST $CLI volume set $V0 performance.open-behind off
+TEST $CLI volume set $V0 diagnostics.client-log-level DEBUG
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume start $V0
+TEST $CLI volume profile $V0 start
+TEST $GFS -s $H0 --volfile-id=$V0 --direct-io-mode=enable $M0;
+
+TEST touch $M0/1
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST fd_open 200 'w' "$M0/1"
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+#lk should only happen on 2 bricks, if there is a bug, it will plant a lock
+#with anon-fd on first-brick which will never be released because flush won't
+#be wound below server xlator for anon-fd
+TEST flock -x -n 200
+TEST fd_close 200
+
+TEST fd_open 200 'w' "$M0/1"
+#this lock will fail if there is a stale lock
+TEST flock -x -n 200
+TEST fd_close 200
+cleanup;
diff --git a/tests/bugs/protocol/bug-1433815-auth-allow.t b/tests/bugs/protocol/bug-1433815-auth-allow.t
index fa22ad8afd5..a78c0eb7111 100644
--- a/tests/bugs/protocol/bug-1433815-auth-allow.t
+++ b/tests/bugs/protocol/bug-1433815-auth-allow.t
@@ -17,6 +17,7 @@ TEST $CLI volume create $V0 $H0:$B0/$V0
 # Set auth.allow so it *doesn't* include ourselves.
 TEST $CLI volume set $V0 auth.allow 1.2.3.4
 TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
 
 # "System getspec" will include the username and password if the request comes
 # from a server (which we are).  Unfortunately, this will cause authentication
diff --git a/tests/bugs/protocol/bug-762989.t b/tests/bugs/protocol/bug-762989.t
index 1607fcf57f8..7d201b78b58 100755
--- a/tests/bugs/protocol/bug-762989.t
+++ b/tests/bugs/protocol/bug-762989.t
@@ -21,7 +21,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8};
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
 
 TEST $CLI volume start $V0;
 
diff --git a/tests/bugs/protocol/bug-808400-fcntl.c b/tests/bugs/protocol/bug-808400-fcntl.c
index 87a83f317b8..a703ca5c120 100644
--- a/tests/bugs/protocol/bug-808400-fcntl.c
+++ b/tests/bugs/protocol/bug-808400-fcntl.c
@@ -12,106 +12,113 @@
 #endif
 
 int
-run_child (char *filename)
+run_child(char *filename)
 {
-        int          fd   = -1, ret = -1;
-        struct flock lock = {0, };
-        int          ppid = 0;
-
-        fd = open (filename, O_RDWR);
-        if (fd < 0) {
-                fprintf (stderr, "open failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        ppid = getppid ();
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-
-        ret = fcntl (fd, F_GETLK, &lock);
-        if (ret < 0) {
-                fprintf (stderr, "GETLK failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        if ((lock.l_type == F_UNLCK) ||
-            (ppid != lock.l_pid)) {
-                fprintf (stderr, "no locks present, though parent has held "
-                         "one\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int fd = -1, ret = -1;
+    struct flock lock = {
+        0,
+    };
+    int ppid = 0;
+
+    fd = open(filename, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "open failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    ppid = getppid();
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    ret = fcntl(fd, F_GETLK, &lock);
+    if (ret < 0) {
+        fprintf(stderr, "GETLK failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    if ((lock.l_type == F_UNLCK) || (ppid != lock.l_pid)) {
+        fprintf(stderr,
+                "no locks present, though parent has held "
+                "one\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1, ret = -1, status = 0;
-        char        *filename = NULL, *cmd = NULL;
-        struct stat  stbuf    = {0, };
-        struct flock lock     = {0, };
-
-        if (argc != 3) {
-                fprintf (stderr, "Usage: %s <filename> "
-                         "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]);
-                goto out;
-        }
-
-        filename = argv[1];
-        cmd = argv[2];
-
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret < 0) {
-                fprintf (stderr, "fcntl failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        system (cmd);
-
-        /* wait till graph switch completes */
-        ret = fstat64 (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        sleep (10);
-
-        /* By now old-graph would be disconnected and locks should be cleaned
-         * up if they are not migrated. Check that by trying to acquire a lock
-         * on a new fd opened by another process on same file.
-         */
-        ret = fork ();
-        if (ret == 0) {
-                ret = run_child (filename);
+    int fd = -1, ret = -1, status = 0;
+    char *filename = NULL, *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    struct flock lock = {
+        0,
+    };
+
+    if (argc != 3) {
+        fprintf(stderr,
+                "Usage: %s <filename> "
+                "<gluster-cmd-to-trigger-graph-switch>\n",
+                argv[0]);
+        goto out;
+    }
+
+    filename = argv[1];
+    cmd = argv[2];
+
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret < 0) {
+        fprintf(stderr, "fcntl failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    system(cmd);
+
+    /* wait till graph switch completes */
+    ret = fstat64(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    sleep(10);
+
+    /* By now old-graph would be disconnected and locks should be cleaned
+     * up if they are not migrated. Check that by trying to acquire a lock
+     * on a new fd opened by another process on same file.
+     */
+    ret = fork();
+    if (ret == 0) {
+        ret = run_child(filename);
+    } else {
+        wait(&status);
+        if (WIFEXITED(status)) {
+            ret = WEXITSTATUS(status);
         } else {
-                wait (&status);
-                if (WIFEXITED(status)) {
-                        ret = WEXITSTATUS(status);
-                } else {
-                        ret = 0;
-                }
+            ret = 0;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/protocol/bug-808400-flock.c b/tests/bugs/protocol/bug-808400-flock.c
index bd2ce8cfb01..54a507cc227 100644
--- a/tests/bugs/protocol/bug-808400-flock.c
+++ b/tests/bugs/protocol/bug-808400-flock.c
@@ -12,85 +12,89 @@
 #endif
 
 int
-run_child (char *filename)
+run_child(char *filename)
 {
-        int fd = -1, ret = -1;
+    int fd = -1, ret = -1;
 
-        fd = open (filename, O_RDWR);
-        if (fd < 0) {
-                fprintf (stderr, "open failed (%s)\n", strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "open failed (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        ret = flock (fd, LOCK_EX | LOCK_NB);
-        if ((ret == 0) || (errno != EWOULDBLOCK)) {
-                fprintf (stderr, "no locks present, though parent has held "
-                         "one\n");
-                ret = -1;
-                goto out;
-        }
+    ret = flock(fd, LOCK_EX | LOCK_NB);
+    if ((ret == 0) || (errno != EWOULDBLOCK)) {
+        fprintf(stderr,
+                "no locks present, though parent has held "
+                "one\n");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1, ret = -1, status = 0;
-        char        *filename = NULL, *cmd = NULL;
-        struct stat  stbuf    = {0, };
+    int fd = -1, ret = -1, status = 0;
+    char *filename = NULL, *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
 
-        if (argc != 3) {
-                fprintf (stderr, "Usage: %s <filename> "
-                         "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]);
-                goto out;
-        }
+    if (argc != 3) {
+        fprintf(stderr,
+                "Usage: %s <filename> "
+                "<gluster-cmd-to-trigger-graph-switch>\n",
+                argv[0]);
+        goto out;
+    }
 
-        filename = argv[1];
-        cmd = argv[2];
+    filename = argv[1];
+    cmd = argv[2];
 
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
 
-        ret = flock (fd, LOCK_EX);
-        if (ret < 0) {
-                fprintf (stderr, "flock failed (%s)\n", strerror (errno));
-                goto out;
-        }
+    ret = flock(fd, LOCK_EX);
+    if (ret < 0) {
+        fprintf(stderr, "flock failed (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        system (cmd);
+    system(cmd);
 
-        /* wait till graph switch completes */
-        ret = fstat64 (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno));
-                goto out;
-        }
+    /* wait till graph switch completes */
+    ret = fstat64(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        sleep (10);
+    sleep(10);
 
-        /* By now old-graph would be disconnected and locks should be cleaned
-         * up if they are not migrated. Check that by trying to acquire a lock
-         * on a new fd opened by another process on same file
-         */
-        ret = fork ();
-        if (ret == 0) {
-                ret = run_child (filename);
+    /* By now old-graph would be disconnected and locks should be cleaned
+     * up if they are not migrated. Check that by trying to acquire a lock
+     * on a new fd opened by another process on same file
+     */
+    ret = fork();
+    if (ret == 0) {
+        ret = run_child(filename);
+    } else {
+        wait(&status);
+        if (WIFEXITED(status)) {
+            ret = WEXITSTATUS(status);
         } else {
-                wait (&status);
-                if (WIFEXITED(status)) {
-                        ret = WEXITSTATUS(status);
-                } else {
-                        ret = 0;
-                }
+            ret = 0;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/protocol/bug-808400-stripe.t b/tests/bugs/protocol/bug-808400-stripe.t
deleted file mode 100755
index 6d6c7271852..00000000000
--- a/tests/bugs/protocol/bug-808400-stripe.t
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 stripe 2 $H0:$B0/brick1 $H0:$B0/brick2;
-EXPECT 'Created' volinfo_field $V0 'Status';
-
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-MOUNTDIR=$M0;
-TEST glusterfs --entry-timeout=0 --attribute-timeout=0 --volfile-server=$H0 --volfile-id=$V0 $MOUNTDIR;
-
-build_tester $(dirname $0)/bug-808400-flock.c
-build_tester $(dirname $0)/bug-808400-fcntl.c
-
-TEST $(dirname $0)/bug-808400-flock $MOUNTDIR/testfile \'gluster volume set $V0 performance.write-behind off\'
-TEST $(dirname $0)/bug-808400-fcntl $MOUNTDIR/testfile \'gluster volume set $V0 performance.write-behind on\'
-
-TEST rm -rf $MOUNTDIR/*
-TEST rm -rf $(dirname $0)/bug-808400-flock $(dirname $0)/bug-808400-fcntl $(dirname $0)/glusterfs.log
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $MOUNTDIR
-
-cleanup;
diff --git a/tests/bugs/quick-read/bug-846240.t b/tests/bugs/quick-read/bug-846240.t
index c47040de1d1..bb997e10013 100755
--- a/tests/bugs/quick-read/bug-846240.t
+++ b/tests/bugs/quick-read/bug-846240.t
@@ -29,6 +29,8 @@ TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $MOUNTDIR;
 TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M1;
 
 TEST touch $M0/testfile;
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0;
 
 # open the file with the fd as 4
 TEST fd=`fd_available`;
@@ -46,8 +48,7 @@ TEST rm -f $M1/testfile;
 # the file would have been removed from the mount $M1. open() gets error
 # and the write call which is put into a stub (open had to be sent first)
 # should unwind with the error received in the open call.
-echo "data" >> $M0/testfile 2>/dev/null 1>/dev/null;
-TEST [ $? -ne 0 ]
+TEST ! fd_write $fd data
 
 TEST fd_close $fd;
 
diff --git a/tests/bugs/quick-read/bz1523599/bz1523599.t b/tests/bugs/quick-read/bz1523599/bz1523599.t
new file mode 100755
index 00000000000..5027efe8e9a
--- /dev/null
+++ b/tests/bugs/quick-read/bz1523599/bz1523599.t
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+. $(dirname $0)/../../../include.rc
+. $(dirname $0)/../../../volume.rc
+. $(dirname $0)/../../../fileio.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick1;
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/test_bz1523599.c -lgfapi -o $(dirname $0)/test_bz1523599
+TEST ./$(dirname $0)/test_bz1523599 0 $H0 $V0 test_bz1523599 $logdir/bz1523599.log
+TEST ./$(dirname $0)/test_bz1523599 1 $H0 $V0 test_bz1523599 $logdir/bz1523599.log
+TEST ./$(dirname $0)/test_bz1523599 0 $H0 $V0 test_bz1523599 $logdir/bz1523599.log
+TEST ./$(dirname $0)/test_bz1523599 2 $H0 $V0 test_bz1523599 $logdir/bz1523599.log
+
+cleanup_tester $(dirname $0)/test_bz1523599
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup;
+
diff --git a/tests/bugs/quick-read/bz1523599/test_bz1523599.c b/tests/bugs/quick-read/bz1523599/test_bz1523599.c
new file mode 100644
index 00000000000..5076a9447f3
--- /dev/null
+++ b/tests/bugs/quick-read/bz1523599/test_bz1523599.c
@@ -0,0 +1,198 @@
+/*
+ * ./test_bz1523599 0 vm140-111 gv0 test211 log
+ * ./test_bz1523599 1 vm140-111 gv0 test211 log
+ * Open - Discard - Read - Then check read information to see if the initial
+ * TEST_STR_LEN/2 bytes read zero
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <errno.h>
+#include <sys/uio.h>
+
+#define TEST_STR_LEN 2048
+
+enum fallocate_flag {
+    TEST_WRITE,
+    TEST_DISCARD,
+    TEST_ZEROFILL,
+};
+
+void
+print_str(char *str, int len)
+{
+    int i, addr;
+
+    printf("%07x\t", 0);
+    for (i = 0; i < len; i++) {
+        printf("%02x", str[i]);
+        if (i) {
+            if ((i + 1) % 16 == 0)
+                printf("\n%07x\t", i + 1);
+            else if ((i + 1) % 4 == 0)
+                printf(" ");
+        }
+    }
+    printf("\n");
+}
+
+int
+test_read(char *str, int total_length, int len_zero)
+{
+    int i;
+    int ret = 0;
+
+    for (i = 0; i < len_zero; i++) {
+        if (str[i]) {
+            fprintf(stderr, "char at position %d not zeroed out\n", i);
+            ret = -EIO;
+            goto out;
+        }
+    }
+
+    for (i = len_zero; i < total_length; i++) {
+        if (str[i] != 0x11) {
+            fprintf(stderr, "char at position %d does not contain pattern\n",
+                    i);
+            ret = -EIO;
+            goto out;
+        }
+    }
+out:
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int opcode;
+    char *host_name, *volume_name, *file_path, *glfs_log_path;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    off_t offset = 0;
+    size_t len_zero = TEST_STR_LEN / 2;
+    char writestr[TEST_STR_LEN];
+    char readstr[TEST_STR_LEN];
+    struct iovec iov = {&readstr, TEST_STR_LEN};
+    int i;
+    int ret = 1;
+
+    for (i = 0; i < TEST_STR_LEN; i++)
+        writestr[i] = 0x11;
+    for (i = 0; i < TEST_STR_LEN; i++)
+        readstr[i] = 0x22;
+
+    if (argc != 6) {
+        fprintf(
+            stderr,
+            "Syntax: %s <test type> <host> <volname> <file-path> <log-file>\n",
+            argv[0]);
+        return 1;
+    }
+
+    opcode = atoi(argv[1]);
+    host_name = argv[2];
+    volume_name = argv[3];
+    file_path = argv[4];
+    glfs_log_path = argv[5];
+
+    fs = glfs_new(volume_name);
+    if (!fs) {
+        perror("glfs_new");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host_name, 24007);
+    if (ret != 0) {
+        perror("glfs_set_volfile_server");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, glfs_log_path, 7);
+    if (ret != 0) {
+        perror("glfs_set_logging");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        perror("glfs_init");
+        goto out;
+    }
+
+    fd = glfs_creat(fs, file_path, O_RDWR, 0777);
+    if (fd == NULL) {
+        perror("glfs_creat");
+        ret = -1;
+        goto out;
+    }
+
+    switch (opcode) {
+        case TEST_WRITE:
+            fprintf(stderr, "Test Write\n");
+            ret = glfs_write(fd, writestr, TEST_STR_LEN, 0);
+            if (ret < 0) {
+                perror("glfs_write");
+                goto out;
+            } else if (ret != TEST_STR_LEN) {
+                fprintf(stderr, "insufficient data written %d \n", ret);
+                ret = -EIO;
+                goto out;
+            }
+            ret = 0;
+            goto out;
+        case TEST_DISCARD:
+            fprintf(stderr, "Test Discard\n");
+            ret = glfs_discard(fd, offset, len_zero);
+            if (ret < 0) {
+                if (errno == EOPNOTSUPP) {
+                    fprintf(stderr, "Operation not supported\n");
+                    ret = 0;
+                    goto out;
+                }
+                perror("glfs_discard");
+                goto out;
+            }
+            goto test_read;
+        case TEST_ZEROFILL:
+            fprintf(stderr, "Test Zerofill\n");
+            ret = glfs_zerofill(fd, offset, len_zero);
+            if (ret < 0) {
+                if (errno == EOPNOTSUPP) {
+                    fprintf(stderr, "Operation not supported\n");
+                    ret = 0;
+                    goto out;
+                }
+                perror("glfs_zerofill");
+                goto out;
+            }
+            goto test_read;
+        default:
+            ret = -1;
+            fprintf(stderr, "Incorrect test code %d\n", opcode);
+            goto out;
+    }
+
+test_read:
+    ret = glfs_readv(fd, &iov, 1, 0);
+    if (ret < 0) {
+        perror("glfs_readv");
+        goto out;
+    }
+
+    /* printf("Read str\n"); print_str(readstr, TEST_STR_LEN); printf("\n"); */
+    ret = test_read(readstr, TEST_STR_LEN, len_zero);
+
+out:
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+
+    if (ret)
+        return -1;
+
+    return 0;
+}
diff --git a/tests/bugs/quota/bug-1035576.t b/tests/bugs/quota/bug-1035576.t
index eaf4439a063..cbc1b69ebb3 100644
--- a/tests/bugs/quota/bug-1035576.t
+++ b/tests/bugs/quota/bug-1035576.t
@@ -18,6 +18,9 @@ TEST $CLI volume set $V0 performance.write-behind off
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 performance.read-ahead off
 TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume quota $V0 enable
 
 TEST kill_brick $V0 $H0 $B0/${V0}0
diff --git a/tests/bugs/quota/bug-1087198.t b/tests/bugs/quota/bug-1087198.t
index 95133085f13..618a46b957d 100644
--- a/tests/bugs/quota/bug-1087198.t
+++ b/tests/bugs/quota/bug-1087198.t
@@ -17,6 +17,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 QDD=$(dirname $0)/quota
diff --git a/tests/bugs/quota/bug-1153964.t b/tests/bugs/quota/bug-1153964.t
index d84a9b36d26..2e449d3ba00 100644
--- a/tests/bugs/quota/bug-1153964.t
+++ b/tests/bugs/quota/bug-1153964.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 function rename_loop()
 {
         local i=0
diff --git a/tests/bugs/quota/bug-1243798.t b/tests/bugs/quota/bug-1243798.t
index 53f8b10adba..fa6abeb08fb 100644
--- a/tests/bugs/quota/bug-1243798.t
+++ b/tests/bugs/quota/bug-1243798.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/quota/bug-1288474.t b/tests/bugs/quota/bug-1288474.t
deleted file mode 100755
index 57a66197cde..00000000000
--- a/tests/bugs/quota/bug-1288474.t
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-NUM_BRICKS=2
-
-function create_dist_tier_vol () {
-        mkdir -p $B0/cold/${V0}{0..$1}
-        mkdir -p $B0/hot/${V0}{0..$1}
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-	TEST $CLI volume set $V0 nfs.disable false
-        TEST $CLI volume start $V0
-        TEST $CLI volume tier $V0 attach $H0:$B0/hot/${V0}{0..$1}
-}
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
-touch $M0/foobar
-
-TEST $CLI volume quota $V0 enable
-TEST $CLI volume quota $V0 limit-usage / 10MB
-
-EXPECT_WITHIN $MARKER_UPDATE_TIMEOUT "10.0MB" quota_list_field "/" 5
-
-#check quota list after detach tier
-TEST $CLI volume detach-tier $V0 start
-sleep 1
-TEST $CLI volume detach-tier $V0 force
-
-EXPECT_WITHIN $MARKER_UPDATE_TIMEOUT "10.0MB" quota_list_field "/" 5
-
-#check quota list after attach tier
-rm -rf $B0/hot
-mkdir $B0/hot
-TEST $CLI volume tier $V0 attach $H0:$B0/hot/${V0}{0..$1}
-
-EXPECT_WITHIN $MARKER_UPDATE_TIMEOUT "10.0MB" quota_list_field "/" 5
-
-TEST umount $M0
-
-cleanup;
-
diff --git a/tests/bugs/quota/bug-1292020.t b/tests/bugs/quota/bug-1292020.t
index 05c22776987..b70047ae3f9 100644
--- a/tests/bugs/quota/bug-1292020.t
+++ b/tests/bugs/quota/bug-1292020.t
@@ -4,14 +4,10 @@
 . $(dirname $0)/../../volume.rc
 
 function write_sample_data () {
-        dd if=/dev/zero of=$M0/f1 bs=256k count=400 2>&1 | grep -i exceeded
+        dd if=/dev/zero of=$M0/f1 bs=256k count=400 2>&1 |
+            egrep -i 'exceeded|no space' && echo 'passed'
 }
 
-# Remove below block once we fix the actual hang
-echo "TODO: Validate and fix the hang issue soon";
-SKIP_TESTS
-exit 0
-
 cleanup;
 
 TEST glusterd;
@@ -24,8 +20,8 @@ TEST $CLI volume quota $V0 limit-usage / 1
 
 TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0;
 
-# Needed one extra lookup sometimes on this
-EXPECT_WITHIN 30 "exceeded" write_sample_data
+
+EXPECT_WITHIN 30 "passed" write_sample_data
 
 TEST $CLI volume stop $V0
 TEST $CLI volume delete $V0
diff --git a/tests/bugs/quota/bug-1293601.t b/tests/bugs/quota/bug-1293601.t
index 52b03bcc059..741758b73f5 100644
--- a/tests/bugs/quota/bug-1293601.t
+++ b/tests/bugs/quota/bug-1293601.t
@@ -9,6 +9,7 @@ TEST glusterd
 
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4}
 TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "4" online_brick_count
 TEST $CLI volume quota $V0 enable
 
 TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0;
@@ -27,6 +28,6 @@ EXPECT_WITHIN $MARKER_UPDATE_TIMEOUT "1.0MB" quotausage "/"
 TEST $CLI volume quota $V0 disable
 TEST $CLI volume quota $V0 enable
 
-EXPECT_WITHIN $MARKER_UPDATE_TIMEOUT "1.0MB" quotausage "/"
+EXPECT_WITHIN 60 "1.0MB" quotausage "/"
 
 cleanup;
diff --git a/tests/bugs/readdir-ahead/bug-1390050.c b/tests/bugs/readdir-ahead/bug-1390050.c
new file mode 100644
index 00000000000..9578df2dd90
--- /dev/null
+++ b/tests/bugs/readdir-ahead/bug-1390050.c
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <string.h>
+#include <errno.h>
+
+int
+main(int argc, char *argv[])
+{
+    const char *glfs_dir = NULL, *filepath = NULL;
+    DIR *dirfd = NULL;
+    int filefd = 0, ret = 0;
+    struct stat stbuf = {
+        0,
+    };
+    size_t size_before_write = 0;
+
+    glfs_dir = argv[1];
+    filepath = argv[2];
+    dirfd = opendir(glfs_dir);
+    if (dirfd == NULL) {
+        fprintf(stderr, "opening directory failed (%s)\n", strerror(errno));
+        goto err;
+    }
+
+    filefd = open(filepath, O_RDWR);
+    if (filefd < 0) {
+        fprintf(stderr, "open failed on path %s (%s)\n", filepath,
+                strerror(errno));
+        goto err;
+    }
+
+    ret = stat(filepath, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed on path %s (%s)\n", filepath,
+                strerror(errno));
+        goto err;
+    }
+
+    size_before_write = stbuf.st_size;
+
+    ret = write(filefd, "testdata", strlen("testdata123") + 1);
+    if (ret <= 0) {
+        fprintf(stderr, "write failed (%s)\n", strerror(errno));
+        goto err;
+    }
+
+    while (readdir(dirfd)) {
+        /* do nothing */
+    }
+
+    ret = stat(filepath, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed on path %s (%s)\n", strerror(errno));
+        goto err;
+    }
+
+    if (stbuf.st_size == size_before_write) {
+        fprintf(stderr,
+                "file size (%lu) has not changed even after "
+                "its written to\n",
+                stbuf.st_size);
+        goto err;
+    }
+
+    return 0;
+err:
+    return -1;
+}
diff --git a/tests/bugs/readdir-ahead/bug-1390050.t b/tests/bugs/readdir-ahead/bug-1390050.t
new file mode 100644
index 00000000000..ab1d7d4ead9
--- /dev/null
+++ b/tests/bugs/readdir-ahead/bug-1390050.t
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B{0..1}/$V0
+TEST $CLI volume set $V0 readdir-ahead on
+
+DIRECTORY="$M0/subdir1/subdir2"
+
+#Make sure md-cache has large timeout to hold stat from readdirp_cbk in its cache
+TEST $CLI volume set $V0 performance.md-cache-timeout 600
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
+rm -rf $M0/*
+TEST mkdir -p $DIRECTORY
+rm -rf $DIRECTORY/*
+TEST touch $DIRECTORY/file{0..10}
+rdd_tester=$(dirname $0)/rdd-tester
+TEST build_tester $(dirname $0)/bug-1390050.c -o $rdd_tester
+TEST $rdd_tester $DIRECTORY $DIRECTORY/file4
+rm -f $rdd_tester
+cleanup;
+
diff --git a/tests/bugs/readdir-ahead/bug-1436090.t b/tests/bugs/readdir-ahead/bug-1436090.t
index 58e9093f1c3..e0877f15684 100755
--- a/tests/bugs/readdir-ahead/bug-1436090.t
+++ b/tests/bugs/readdir-ahead/bug-1436090.t
@@ -19,12 +19,12 @@ EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
 TEST glusterfs -s $H1 --volfile-id $V0 $M0;
 TEST mkdir $M0/dir1
 
-# Create a large file (3.2 GB), so that rebalance takes time
-# Reading from /dev/urandom is slow, so we will cat it together
-dd if=/dev/urandom of=/tmp/FILE2 bs=64k count=10240
-for i in {1..5}; do
-  cat /tmp/FILE2 >> $M0/dir1/foo
-done
+# Create a large file (4 GB), so that rebalance takes time
+# Since we really don't care about the contents of the file, we use fallocate
+# to generate the file much faster. We could also use truncate, which is even
+# faster, but rebalance could take advantage of an sparse file and migrate it
+# in an optimized way, but we don't want a fast migration.
+TEST fallocate -l 4G $M0/dir1/foo
 
 TEST mv $M0/dir1/foo $M0/dir1/bar
 
diff --git a/tests/bugs/readdir-ahead/bug-1439640.t b/tests/bugs/readdir-ahead/bug-1439640.t
index cc6c829fccc..dcd54076444 100755
--- a/tests/bugs/readdir-ahead/bug-1439640.t
+++ b/tests/bugs/readdir-ahead/bug-1439640.t
@@ -8,6 +8,7 @@ cleanup;
 TEST glusterd
 
 TEST $CLI volume create $V0 $H0:$B{0..1}/$V0
+TEST $CLI volume set $V0 readdir-ahead on
 TEST $CLI volume start $V0
 
 TEST ! $CLI volume set $V0 parallel-readdir sdf
diff --git a/tests/bugs/readdir-ahead/bug-1512437.t b/tests/bugs/readdir-ahead/bug-1512437.t
new file mode 100755
index 00000000000..50eaa7d6696
--- /dev/null
+++ b/tests/bugs/readdir-ahead/bug-1512437.t
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+TEST $CLI volume start $V0
+
+TEST $CLI volume set $V0 parallel-readdir on
+TEST $CLI volume set $V0 readdir-optimize on
+
+TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
+TEST mkdir -p $M0/subdir1/subdir2;
+umount $M0
+TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
+count=`ls -1 $M0/subdir1 | wc -l`
+TEST [ $count -eq 1 ]
+
+cleanup;
diff --git a/tests/bugs/readdir-ahead/bug-1670253-consistent-metadata.t b/tests/bugs/readdir-ahead/bug-1670253-consistent-metadata.t
new file mode 100644
index 00000000000..6adfc17c92c
--- /dev/null
+++ b/tests/bugs/readdir-ahead/bug-1670253-consistent-metadata.t
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 readdir-ahead on #on by default as of writing this .t.
+TEST $CLI volume set $V0 consistent-metadata on
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
+TEST touch $M0/FILE
+echo "abc" >> $M0/FILE
+EXPECT "^0$" echo $?
+EXPECT "abc" cat $M0/FILE
+echo "truncate" >$M0/FILE
+EXPECT "^0$" echo $?
+EXPECT "truncate" cat $M0/FILE
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+cleanup;
diff --git a/tests/bugs/replicate/bug-1015990-rep.t b/tests/bugs/replicate/bug-1015990-rep.t
index 1b104969d10..ab8166e372a 100755
--- a/tests/bugs/replicate/bug-1015990-rep.t
+++ b/tests/bugs/replicate/bug-1015990-rep.t
@@ -11,7 +11,6 @@ TEST pidof glusterd;
 TEST $CLI volume info;
 
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2,3,4};
-
 ## Verify volume is is created
 EXPECT "$V0" volinfo_field $V0 'Volume Name';
 EXPECT 'Created' volinfo_field $V0 'Status';
@@ -20,22 +19,23 @@ EXPECT 'Created' volinfo_field $V0 'Status';
 TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
 
-
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
-
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 3
 
 
 TEST kill_brick $V0 $H0 $B0/$V0"1"
-sleep 5
 TEST kill_brick $V0 $H0 $B0/$V0"3"
-sleep 5
 
 for  i in  {1..100}; do echo "STRING" > $M0/File$i; done
 
+# Check shd is connected to all up bricks before running statistics command.
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 3
 
 command_output=$(gluster volume heal $V0 statistics heal-count replica $H0:$B0/$V0"1")
-
-
 substring="Number of entries:"
 count=0
 while read -r line;
@@ -48,15 +48,8 @@ do
 
 done <<< "$command_output"
 
-brick_2_entries_count=$(($count-$value))
-
-EXPECT "0" echo $brick_2_entries_count
-
 brick_2_entries_count=$count
-
-
 xattrop_count_brick_2=$(count_sh_entries $B0/$V0"2")
-
 EXPECT $brick_2_entries_count echo $xattrop_count_brick_2
 
 ## Finish up
diff --git a/tests/bugs/replicate/bug-1046624.t b/tests/bugs/replicate/bug-1046624.t
index 9ae40879228..e2762ea6764 100755
--- a/tests/bugs/replicate/bug-1046624.t
+++ b/tests/bugs/replicate/bug-1046624.t
@@ -25,11 +25,12 @@ TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
 
 ## Mount native
-TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0 --use-readdirp=no
+TEST ${GFS} --volfile-server=$H0 --volfile-id=$V0 --use-readdirp=no $M0
 
 TEST `echo "TEST-FILE" > $M0/File`
 TEST `mkdir $M0/Dir`
 TEST kill_brick $V0 $H0 $B0/${V0}-0
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 0
 
 TEST `ln -s $M0/File $M0/Link1`
 TEST `ln -s $M0/Dir $M0/Link2`
diff --git a/tests/bugs/replicate/bug-1058797.t b/tests/bugs/replicate/bug-1058797.t
index 99ab3eb3a66..598062a0dab 100644
--- a/tests/bugs/replicate/bug-1058797.t
+++ b/tests/bugs/replicate/bug-1058797.t
@@ -12,6 +12,9 @@ TEST glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1};
 TEST $CLI volume start $V0
 TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 
 # FUSE mount;create a file
 TEST glusterfs -s $H0 --volfile-id $V0 $M0
diff --git a/tests/bugs/replicate/bug-1101647.t b/tests/bugs/replicate/bug-1101647.t
index 8f420eec012..708bc1a1e29 100644
--- a/tests/bugs/replicate/bug-1101647.t
+++ b/tests/bugs/replicate/bug-1101647.t
@@ -12,6 +12,8 @@ TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2};
 TEST $CLI volume start $V0;
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 
 #Create base entry in indices/xattrop
 echo "Data">$M0/file
diff --git a/tests/bugs/replicate/bug-1130892.t b/tests/bugs/replicate/bug-1130892.t
index 9005791a597..c7509f33cc2 100644
--- a/tests/bugs/replicate/bug-1130892.t
+++ b/tests/bugs/replicate/bug-1130892.t
@@ -16,6 +16,11 @@ EXPECT 'Created' volinfo_field $V0 'Status';
 # Disable self-heal daemon
 TEST gluster volume set $V0 self-heal-daemon off
 
+# Enable Client side heal
+TEST $CLI volume set $V0 cluster.data-self-heal off
+TEST $CLI volume set $V0 cluster.metadata-self-heal off
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+
 # Disable all perf-xlators
 TEST $CLI volume set $V0 performance.quick-read off
 TEST $CLI volume set $V0 performance.io-cache off
@@ -28,7 +33,7 @@ TEST $CLI volume start $V0;
 EXPECT 'Started' volinfo_field $V0 'Status';
 
 # FUSE Mount
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
+TEST ${GFS} -s $H0 --volfile-id $V0 $M0
 
 # Create files and dirs
 TEST mkdir -p $M0/one/two/
@@ -36,13 +41,13 @@ TEST `echo "Carpe diem" > $M0/one/two/three`
 
 # Simulate disk-replacement
 TEST kill_brick $V0 $H0 $B0/${V0}-1
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 1
 TEST rm -rf $B0/${V0}-1/one
 TEST rm -rf $B0/${V0}-1/.glusterfs
 
 #Ideally, disk replacement is done using reset-brick or replace-brick gluster CLI
-#which will create .glusterfs/indices folder.
+#which will create .glusterfs folder.
 mkdir $B0/${V0}-1/.glusterfs && chmod 600 $B0/${V0}-1/.glusterfs
-mkdir $B0/${V0}-1/.glusterfs/indices && chmod 600 $B0/${V0}-1/.glusterfs/indices
 
 # Start force
 TEST $CLI volume start $V0 force
@@ -51,10 +56,12 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
 
 TEST stat $M0/one
 
+sleep 1
+
 # Check pending xattrs
 EXPECT "00000000" afr_get_specific_changelog_xattr $B0/${V0}-0/one trusted.afr.$V0-client-1 data
 EXPECT_NOT "00000000" afr_get_specific_changelog_xattr $B0/${V0}-0/one trusted.afr.$V0-client-1 entry
-EXPECT "00000000" afr_get_specific_changelog_xattr $B0/${V0}-0/one trusted.afr.$V0-client-1 metadata
+EXPECT_NOT "00000000" afr_get_specific_changelog_xattr $B0/${V0}-0/one trusted.afr.$V0-client-1 metadata
 
 TEST gluster volume set $V0 self-heal-daemon on
 
diff --git a/tests/bugs/replicate/bug-1134691-afr-lookup-metadata-heal.t b/tests/bugs/replicate/bug-1134691-afr-lookup-metadata-heal.t
index 44c2ed25f9d..b69a38ae788 100644
--- a/tests/bugs/replicate/bug-1134691-afr-lookup-metadata-heal.t
+++ b/tests/bugs/replicate/bug-1134691-afr-lookup-metadata-heal.t
@@ -10,6 +10,9 @@ TEST pidof glusterd
 TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0,1,2}
 TEST $CLI volume set $V0 performance.stat-prefetch off
 TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 TEST $CLI volume start $V0
 TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
 
@@ -22,9 +25,11 @@ iatt=$(stat -c "%g:%u:%A" file)
 
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+EXPECT 2 get_pending_heal_count $V0
 
 #Trigger metadataheal
 TEST stat file
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
 
 #iattrs must be matching
 iatt1=$(stat -c "%g:%u:%A" $B0/brick0/file)
diff --git a/tests/bugs/replicate/bug-1180545.t b/tests/bugs/replicate/bug-1180545.t
index e9531625ee2..5e40edd6c38 100644
--- a/tests/bugs/replicate/bug-1180545.t
+++ b/tests/bugs/replicate/bug-1180545.t
@@ -7,6 +7,31 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../afr.rc
 
+function check_sh_entries() {
+        local expected="$1"
+        local count=
+        local good="0"
+        shift
+
+        for i in $*; do
+                count="$(count_sh_entries $i)"
+                if [[ "x${count}" == "x${expected}" ]]; then
+                        good="$((good + 1))"
+                fi
+        done
+        if [[ "x${good}" != "x${last_good}" ]]; then
+                last_good="${good}"
+# This triggers a sweep of the heal index. However if more than one brick
+# tries to heal the same directory at the same time, one of them will take
+# the lock and the other will give up, waiting for the next heal cycle, which
+# is set to 60 seconds (the minimum valid value). So, each time we detect
+# that one brick has completed the heal, we trigger another heal.
+                $CLI volume heal $V0
+        fi
+
+        echo "${good}"
+}
+
 cleanup;
 
 TEST glusterd
@@ -15,6 +40,7 @@ TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1}
 TEST $CLI volume set $V0 cluster.heal-timeout 60
 TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 stat-prefetch off
 TEST $CLI volume start $V0
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
 
@@ -35,13 +61,16 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 
 #Trigger heal and verify number of entries in backend
 TEST $CLI volume set $V0 cluster.self-heal-daemon on
-EXPECT_WITHIN PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+
 TEST $CLI volume heal $V0
 
-EXPECT_WITHIN $HEAL_TIMEOUT '2' count_sh_entries $B0/brick0
-EXPECT_WITHIN $HEAL_TIMEOUT '2' count_sh_entries $B0/brick1
+last_good=""
+
+EXPECT_WITHIN $HEAL_TIMEOUT "2" check_sh_entries 2 $B0/brick{0,1}
+
 #Two entries for DIR and two for FILE
 EXPECT_WITHIN $HEAL_TIMEOUT "4" get_pending_heal_count $V0
 TEST diff <(ls $B0/brick0/DIR) <(ls $B0/brick1/DIR)
diff --git a/tests/bugs/replicate/bug-1221481-allow-fops-on-dir-split-brain.t b/tests/bugs/replicate/bug-1221481-allow-fops-on-dir-split-brain.t
index c4752c488f4..6ff471fbf15 100644
--- a/tests/bugs/replicate/bug-1221481-allow-fops-on-dir-split-brain.t
+++ b/tests/bugs/replicate/bug-1221481-allow-fops-on-dir-split-brain.t
@@ -11,19 +11,27 @@ TEST pidof glusterd;
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1};
 TEST $CLI volume set $V0 cluster.self-heal-daemon off
 TEST $CLI volume start $V0;
-TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 TEST mkdir $M0/dir
 TEST touch $M0/dir/file{1..5}
 
 #Create entry split-brain
 TEST kill_brick $V0 $H0 $B0/$V0"1"
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 1
 TEST touch $M0/dir/FILE
+EXPECT_WITHIN ${UMOUNT_TIMEOUT} "^Y$" force_umount $M0
 TEST $CLI volume start $V0 force
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT '1' afr_child_up_status_meta $M0 $V0-replicate-0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT '1' afr_child_up_status_meta $M0 $V0-replicate-0 1
 TEST kill_brick $V0 $H0 $B0/$V0"0"
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} "^0$" afr_child_up_status $V0 0
 TEST touch $M0/dir/FILE
+EXPECT_WITHIN ${UMOUNT_TIMEOUT} "^Y$" force_umount $M0
 TEST $CLI volume start $V0 force
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT '1' afr_child_up_status_meta $M0 $V0-replicate-0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT '1' afr_child_up_status_meta $M0 $V0-replicate-0 1
 
 cd $M0/dir
 EXPECT "6" echo $(ls | wc -l)
diff --git a/tests/bugs/replicate/bug-1238398-split-brain-resolution.t b/tests/bugs/replicate/bug-1238398-split-brain-resolution.t
index 7ba09f0dc5d..8ef3aae979f 100644
--- a/tests/bugs/replicate/bug-1238398-split-brain-resolution.t
+++ b/tests/bugs/replicate/bug-1238398-split-brain-resolution.t
@@ -46,3 +46,6 @@ TEST setfattr -n replica.split-brain-choice -v $V0-client-1 $M0/metadata-split-b
 EXPECT "666" stat -c %a $M0/metadata-split-brain.txt
 
 cleanup;
+
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/replicate/bug-1250170-fsync.c b/tests/bugs/replicate/bug-1250170-fsync.c
index 1d3025bcd9f..21fd96594aa 100644
--- a/tests/bugs/replicate/bug-1250170-fsync.c
+++ b/tests/bugs/replicate/bug-1250170-fsync.c
@@ -7,50 +7,50 @@
 #include <unistd.h>
 #include <string.h>
 
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        char *file = NULL;
-        int fd = -1;
-        char *buffer = NULL;
-        size_t buf_size = 0;
-        size_t written = 0;
-        int ret = 0;
-        off_t offset = 0;
-        int i = 0;
-        int loop_count = 5;
+    char *file = NULL;
+    int fd = -1;
+    char *buffer = NULL;
+    size_t buf_size = 0;
+    size_t written = 0;
+    int ret = 0;
+    off_t offset = 0;
+    int i = 0;
+    int loop_count = 5;
 
-        if (argc < 2) {
-                printf ("Usage:%s <filename>\n", argv[0]);
-                return -1;
-        }
+    if (argc < 2) {
+        printf("Usage:%s <filename>\n", argv[0]);
+        return -1;
+    }
 
-        file = argv[1];
-        buf_size = 1024;
-        buffer = calloc(1, buf_size);
-        if (!buffer) {
-                perror("calloc");
-                return -1;
-        }
-        memset (buffer, 'R', buf_size);
+    file = argv[1];
+    buf_size = 1024;
+    buffer = malloc(buf_size);
+    if (!buffer) {
+        perror("malloc");
+        return -1;
+    }
+    memset(buffer, 'R', buf_size);
 
-        fd = open(file, O_WRONLY);
-        if (fd == -1) {
-                perror("open");
-                return -1;
-        }
+    fd = open(file, O_WRONLY);
+    if (fd == -1) {
+        perror("open");
+        return -1;
+    }
 
-        for (i = 0; i < loop_count; i++) {
-                ret =  write (fd, buffer, buf_size);
-                if (ret == -1) {
-                        perror("write");
-                        return ret;
-                } else {
-                        written += ret;
-                }
-                offset = lseek (fd, 0 , SEEK_SET);
+    for (i = 0; i < loop_count; i++) {
+        ret = write(fd, buffer, buf_size);
+        if (ret == -1) {
+            perror("write");
+            return ret;
+        } else {
+            written += ret;
         }
+        offset = lseek(fd, 0, SEEK_SET);
+    }
 
-        free(buffer);
-        return 0;
-
+    free(buffer);
+    return 0;
 }
diff --git a/tests/bugs/replicate/bug-1290965-detect-bitrotten-objects.t b/tests/bugs/replicate/bug-1290965-detect-bitrotten-objects.t
deleted file mode 100644
index 1828e6f3493..00000000000
--- a/tests/bugs/replicate/bug-1290965-detect-bitrotten-objects.t
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/bin/bash
-#Self-heal tests
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1}
-TEST $CLI volume set $V0 self-heal-daemon off
-TEST $CLI volume set $V0 entry-self-heal off
-TEST $CLI volume set $V0 metadata-self-heal off
-TEST $CLI volume set $V0 data-self-heal off
-TEST $CLI volume set $V0 performance.stat-prefetch off
-TEST $CLI volume start $V0
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/brick{2,3}
-TEST $CLI volume bitrot $V0 enable
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
-TEST $CLI volume bitrot $V0 scrub-frequency hourly
-TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
-TEST dd if=/dev/urandom of=$M0/FILE bs=1024 count=1
-
-#Corrupt file from back-end
-TEST stat $B0/brick3/FILE
-echo "Corrupted data" >> $B0/brick3/FILE
-#Manually set bad-file xattr since we can't wait for an hour.
-TEST setfattr -n trusted.bit-rot.bad-file -v 0x3100 $B0/brick3/FILE
-
-TEST $CLI volume stop $V0
-TEST $CLI volume start $V0
-EXPECT 'Started' volinfo_field $V0 'Status';
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick0
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick2
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick3
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 2
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 3
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" get_bitd_count
-#Trigger lookup so that bitrot xlator marks file as bad in its inode context.
-stat $M0/FILE
-# Remove hot-tier
-TEST $CLI volume tier $V0  detach start
-sleep 1
-EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" detach_tier_status_field_complete $V0
-TEST $CLI volume tier $V0  detach commit
-#Test that file has migrated to cold tier.
-EXPECT "1024" stat -c "%s" $B0/brick0/FILE
-EXPECT "1024" stat -c "%s" $B0/brick1/FILE
-TEST umount $M0
-cleanup
diff --git a/tests/bugs/replicate/bug-1292379.t b/tests/bugs/replicate/bug-1292379.t
index f0865020d54..be1bf699173 100644
--- a/tests/bugs/replicate/bug-1292379.t
+++ b/tests/bugs/replicate/bug-1292379.t
@@ -39,6 +39,7 @@ TEST $CLI volume start $V0 force
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 TEST fd_write $wfd "pqrs"
 TEST $CLI volume set $V0 self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 
diff --git a/tests/bugs/replicate/bug-1340623-mkdir-fails-remove-brick-started.t b/tests/bugs/replicate/bug-1340623-mkdir-fails-remove-brick-started.t
index 5467127bd59..6d177a7d3f8 100644
--- a/tests/bugs/replicate/bug-1340623-mkdir-fails-remove-brick-started.t
+++ b/tests/bugs/replicate/bug-1340623-mkdir-fails-remove-brick-started.t
@@ -3,6 +3,9 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/replicate/bug-1363721.t b/tests/bugs/replicate/bug-1363721.t
index ec39889b27e..0ed34d8a4f4 100644
--- a/tests/bugs/replicate/bug-1363721.t
+++ b/tests/bugs/replicate/bug-1363721.t
@@ -18,6 +18,10 @@ function size_increased {
         fi
 }
 
+function has_write_failed {
+        local pid=$1
+        if [ -d /proc/$pid ]; then echo "N"; else echo "Y"; fi
+}
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
@@ -27,7 +31,7 @@ TEST $CLI volume set $V0 cluster.data-self-heal off
 TEST $CLI volume set $V0 cluster.metadata-self-heal off
 TEST $CLI volume set $V0 cluster.entry-self-heal off
 TEST $CLI volume start $V0
-TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0 --direct-io-mode=enable
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 --direct-io-mode=enable $M0
 
 cd $M0
 
@@ -67,8 +71,10 @@ sleep 3
 # Now kill the second brick
 kill_brick $V0 $H0 $B0/${V0}2
 
-# At this point the write should have been failed. But make sure that the second
-# brick is never an accused.
+# At this point the write should have been failed.
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "Y" has_write_failed $dd_pid
+
+# Also make sure that the second brick is never an accused.
 
 md5sum_2=$(md5sum $B0/${V0}2/file1 | awk '{print $1}')
 
diff --git a/tests/bugs/replicate/bug-1402730.t b/tests/bugs/replicate/bug-1402730.t
index 28c6761f91f..c7866df463b 100644
--- a/tests/bugs/replicate/bug-1402730.t
+++ b/tests/bugs/replicate/bug-1402730.t
@@ -24,9 +24,8 @@ rm -rf $B0/${V0}2/*
 rm -rf $B0/${V0}2/.glusterfs
 
 #Ideally, disk replacement is done using reset-brick or replace-brick gluster CLI
-#which will create .glusterfs/indices folder.
+#which will create .glusterfs folder.
 mkdir $B0/${V0}2/.glusterfs && chmod 600 $B0/${V0}2/.glusterfs
-mkdir $B0/${V0}2/.glusterfs/indices && chmod 600 $B0/${V0}2/.glusterfs/indices
 
 TEST $CLI volume start $V0 force
 
diff --git a/tests/bugs/replicate/bug-1408712.t b/tests/bugs/replicate/bug-1408712.t
index 18376b649f4..9499a598ef1 100644
--- a/tests/bugs/replicate/bug-1408712.t
+++ b/tests/bugs/replicate/bug-1408712.t
@@ -13,6 +13,11 @@ TEST pidof glusterd
 
 TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
 TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+
 TEST $CLI volume set $V0 features.shard on
 TEST $CLI volume set $V0 features.shard-block-size 4MB
 TEST $CLI volume heal $V0 granular-entry-heal enable
@@ -23,13 +28,21 @@ TEST $CLI volume set $V0 self-heal-daemon off
 TEST $CLI volume set $V0 performance.flush-behind off
 
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 2
+
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M1 $V0-replicate-0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M1 $V0-replicate-0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M1 $V0-replicate-0 2
 
-cd $M0
+TEST cd $M0
 TEST dd if=/dev/zero of=file bs=1M count=8
 
 # Kill brick-0.
 TEST kill_brick $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "0" brick_up_status $V0 $H0 $B0/${V0}0
 
 TEST "dd if=/dev/zero bs=1M count=8 >> file"
 
@@ -45,7 +58,7 @@ do
         TEST_IN_LOOP stat $B0/${V0}2/.glusterfs/indices/entry-changes/$DOT_SHARD_GFID/$FILE_GFID.$i
 done
 
-cd ~
+TEST cd ~
 TEST md5sum $M1/file
 
 # Test that the index associated with '/.shard' and the created shards do not disappear on B1 and B2.
diff --git a/tests/bugs/replicate/bug-1417522-block-split-brain-resolution.t b/tests/bugs/replicate/bug-1417522-block-split-brain-resolution.t
index 4592ebf8d23..d0e2fee8bcd 100644
--- a/tests/bugs/replicate/bug-1417522-block-split-brain-resolution.t
+++ b/tests/bugs/replicate/bug-1417522-block-split-brain-resolution.t
@@ -64,3 +64,6 @@ TEST [ "$SOURCE_BRICK_MD5" == "$B2_MD5" ]
 
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 cleanup;
+
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/replicate/bug-1433571-undo-pending-only-on-up-bricks.t b/tests/bugs/replicate/bug-1433571-undo-pending-only-on-up-bricks.t
index 271abb4fe9a..10ce0131f4f 100644
--- a/tests/bugs/replicate/bug-1433571-undo-pending-only-on-up-bricks.t
+++ b/tests/bugs/replicate/bug-1433571-undo-pending-only-on-up-bricks.t
@@ -49,25 +49,15 @@ TEST $CLI volume start $V0 force
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 2
 
-#Kill brick 0 and turn on the client side heal and do ls to trigger the heal.
-#The pending xattrs on bricks 1 & 2 should have pending entry on brick 0.
-TEST kill_brick $V0 $H0 $B0/${V0}0
+# We were killing one brick and checking that entry heal does not reset the
+# pending xattrs for the down brick. Now that we need all bricks to be up for
+# entry heal, I'm removing that test from the .t
+
 TEST $CLI volume set $V0 cluster.data-self-heal on
 TEST $CLI volume set $V0 cluster.metadata-self-heal on
 TEST $CLI volume set $V0 cluster.entry-self-heal on
 
 TEST ls $M0
-EXPECT "000000000000000000000001" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}1
-EXPECT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-2 $B0/${V0}1
-EXPECT "000000000000000000000001" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}2
-EXPECT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}2
-
-#Bring back all the bricks and trigger the heal again by doing ls. Now the
-#pending xattrs on all the bricks should be 0.
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
-TEST ls $M0
-
 TEST cat $M0/f1
 TEST cat $M0/f2
 TEST cat $M0/f3
diff --git a/tests/bugs/replicate/bug-1438255-do-not-mark-self-accusing-xattrs.t b/tests/bugs/replicate/bug-1438255-do-not-mark-self-accusing-xattrs.t
index edfd0d7820d..cdcaf62c925 100644
--- a/tests/bugs/replicate/bug-1438255-do-not-mark-self-accusing-xattrs.t
+++ b/tests/bugs/replicate/bug-1438255-do-not-mark-self-accusing-xattrs.t
@@ -42,5 +42,5 @@ TEST ! getfattr -n trusted.afr.$V0-client-2 $B0/${V0}2/FILE
 TEST userdel --force ${NEW_USER}
 TEST groupdel ${NEW_USER}-${NEW_GID}
 cleanup
-
-
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/bugs/replicate/bug-1448804-check-quorum-type-values.t b/tests/bugs/replicate/bug-1448804-check-quorum-type-values.t
index 4b654e704c5..5bacf3edcfe 100644
--- a/tests/bugs/replicate/bug-1448804-check-quorum-type-values.t
+++ b/tests/bugs/replicate/bug-1448804-check-quorum-type-values.t
@@ -1,6 +1,7 @@
 #!/bin/bash
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
 cleanup;
 
 TEST glusterd
@@ -11,9 +12,8 @@ EXPECT 'Started' volinfo_field $V0 'Status'
 
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
 
-
 # Default quorum-type for replica 2 is none. quorum-count is zero but it is not displayed.
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "none" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-type|awk '{print $3}'`
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "none" get_quorum_type $M0 $V0 0
 cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-count
 TEST [ $? -ne 0 ]
 
@@ -22,25 +22,25 @@ TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}2
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
 
 # Default quorum-type for replica 3 is auto. quorum-count is INT_MAX but it is not displayed.
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "auto" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-type|awk '{print $3}'`
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "auto" get_quorum_type $M0 $V0 0
 cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-count
 TEST [ $? -ne 0 ]
 
 # Change the type to fixed.
 TEST $CLI volume set $V0 cluster.quorum-type fixed
 # We haven't set quorum-count yet, so it takes the default value of zero in reconfigure() and hence the quorum-type is displayed as none.
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "none" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-type|awk '{print $3}'`
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "none" get_quorum_type $M0 $V0 0
 cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-count
 TEST [ $? -ne 0 ]
 
 # set quorum-count and check.
 TEST $CLI volume set $V0 cluster.quorum-count 1
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "fixed" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-type|awk '{print $3}'`
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "fixed" get_quorum_type $M0 $V0 0
 EXPECT "1" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-count|awk '{print $3}'`
 
 # reset to default values.
 TEST $CLI volume reset $V0 cluster.quorum-type
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "auto" echo `cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-type|awk '{print $3}'`
+EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "auto" get_quorum_type $M0 $V0 0
 cat $M0/.meta/graphs/active/$V0-replicate-0/private|grep quorum-count
 TEST [ $? -ne 0 ]
 
diff --git a/tests/bugs/replicate/bug-1468279-source-not-blaming-sinks.t b/tests/bugs/replicate/bug-1468279-source-not-blaming-sinks.t
deleted file mode 100644
index 054a4adb90d..00000000000
--- a/tests/bugs/replicate/bug-1468279-source-not-blaming-sinks.t
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
-TEST $CLI volume start $V0
-TEST $CLI volume set $V0 cluster.self-heal-daemon off
-TEST $CLI volume set $V0 cluster.metadata-self-heal off
-TEST $GFS --volfile-id=$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0;
-TEST touch $M0/file
-
-# Kill B1, create a pending metadata heal.
-TEST kill_brick $V0 $H0 $B0/${V0}0
-TEST setfattr -n user.xattr -v value1 $M0/file
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}1/file
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}2/file
-
-# Kill B2, heal from B3 to B1.
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
-TEST kill_brick $V0 $H0 $B0/${V0}1
-TEST $CLI volume set $V0 cluster.self-heal-daemon on
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
-$CLI volume heal $V0
-EXPECT_WITHIN $HEAL_TIMEOUT  "00000000" afr_get_specific_changelog_xattr $B0/${V0}2/file trusted.afr.$V0-client-0 "metadata"
-TEST $CLI volume set $V0 cluster.self-heal-daemon off
-
-# Create another pending metadata heal.
-TEST setfattr -n user.xattr -v value2 $M0/file
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}0/file
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}2/file
-
-# Kill B1, heal from B3 to B2
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
-TEST kill_brick $V0 $H0 $B0/${V0}0
-TEST $CLI volume set $V0 cluster.self-heal-daemon on
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
-$CLI volume heal $V0
-EXPECT_WITHIN $HEAL_TIMEOUT  "00000000" afr_get_specific_changelog_xattr $B0/${V0}2/file trusted.afr.$V0-client-1 "metadata"
-TEST $CLI volume set $V0 cluster.self-heal-daemon off
-
-# ALL bricks up again.
-TEST $CLI volume start $V0 force
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
-# B1 and B2 blame each other, B3 doesn't blame anyone.
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}0/file
-EXPECT "0000000000000010000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}1/file
-EXPECT "0000000000000000000000" get_hex_xattr trusted.afr.$V0-client-0 $B0/${V0}2/file
-EXPECT "0000000000000000000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}2/file
-TEST $CLI volume set $V0 cluster.self-heal-daemon on
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
-TEST $CLI volume heal $V0
-EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
-
-cleanup;
diff --git a/tests/bugs/replicate/bug-1473026.t b/tests/bugs/replicate/bug-1473026.t
new file mode 100644
index 00000000000..efb3ffa0d39
--- /dev/null
+++ b/tests/bugs/replicate/bug-1473026.t
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1473026
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1473026
+
+cleanup;
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume start $V0;
+
+#kill one brick (this has some issue)
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+#kill the brick to be replaced
+TEST kill_brick $V0 $H0 $B0/${V0}0
+
+# We know this command would fail because file system is read only now
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}4 commit force
+
+TEST pkill glusterd
+
+# Glusterd should start but the volume info and brick volfiles don't match
+TEST glusterd
+TEST pidof glusterd
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1477169-entry-selfheal-rename.t b/tests/bugs/replicate/bug-1477169-entry-selfheal-rename.t
index 465800b19da..bb858a8a63d 100644
--- a/tests/bugs/replicate/bug-1477169-entry-selfheal-rename.t
+++ b/tests/bugs/replicate/bug-1477169-entry-selfheal-rename.t
@@ -13,10 +13,10 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 2
 
-TEST mkdir -p $M0/d1/dir $M0/d2
+TEST mkdir -p $M0/d1/dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 $M0/d2
 gfid_d1=$(gf_get_gfid_xattr $B0/${V0}0/d1)
 gfid_d2=$(gf_get_gfid_xattr $B0/${V0}0/d2)
-gfid_dir=$(gf_get_gfid_xattr $B0/${V0}0/d1/dir)
+gfid_dir=$(gf_get_gfid_xattr $B0/${V0}0/d1/dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789)
 
 gfid_str_d1=$(gf_gfid_xattr_to_str $gfid_d1)
 gfid_str_d2=$(gf_gfid_xattr_to_str $gfid_d2)
@@ -24,7 +24,7 @@ gfid_str_d3=$(gf_gfid_xattr_to_str $gfid_dir)
 
 # Kill 3rd brick and rename the dir from mount.
 TEST kill_brick $V0 $H0 $B0/${V0}2
-TEST mv $M0/d1/dir $M0/d2
+TEST mv $M0/d1/dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 $M0/d2
 
 # Bring it back and trigger heal.
 TEST $CLI volume start $V0 force
@@ -38,10 +38,15 @@ EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
 TEST $CLI volume heal $V0
 EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
 
-# Check that .glusterfs symlink for dir exists and points to d2/dir
+# Check that .glusterfs symlink for dir exists and points to d2/dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
 TEST linkname=$(readlink $B0/${V0}2/.glusterfs/${gfid_str_d3:0:2}/${gfid_str_d3:2:2}/$gfid_str_d3)
-EXPECT "dir" basename $linkname
+EXPECT "dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" basename $linkname
 TEST parent_dir_gfid_str=$(echo $linkname|cut -d / -f5)
 EXPECT $gfid_str_d2 echo $parent_dir_gfid_str
 
+TEST rmdir $M0/d2/dir012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
+
+TEST ! stat $B0/${V0}0/.glusterfs/${gfid_str_d3:0:2}/${gfid_str_d3:2:2}/$gfid_str_d3
+TEST ! stat $B0/${V0}1/.glusterfs/${gfid_str_d3:0:2}/${gfid_str_d3:2:2}/$gfid_str_d3
+TEST ! stat $B0/${V0}2/.glusterfs/${gfid_str_d3:0:2}/${gfid_str_d3:2:2}/$gfid_str_d3
 cleanup;
diff --git a/tests/bugs/replicate/bug-1493415-gfid-heal.t b/tests/bugs/replicate/bug-1493415-gfid-heal.t
index 125c35a7a21..8a79febf4b4 100644
--- a/tests/bugs/replicate/bug-1493415-gfid-heal.t
+++ b/tests/bugs/replicate/bug-1493415-gfid-heal.t
@@ -27,6 +27,11 @@ gfid_str_f1=$(gf_gfid_xattr_to_str $gfid_f1)
 TEST setfattr -x trusted.gfid $B0/${V0}1/f1
 TEST rm $B0/${V0}1/.glusterfs/${gfid_str_f1:0:2}/${gfid_str_f1:2:2}/$gfid_str_f1
 
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 2
+
 # Assume there were no pending xattrs on parent dir due to 1st brick crashing
 # too. Then name heal from client must heal the gfid.
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
@@ -52,6 +57,11 @@ TEST rm $B0/${V0}1/.glusterfs/${gfid_str_f2:0:2}/${gfid_str_f2:2:2}/$gfid_str_f2
 TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/${V0}0/dir
 create_brick_xattrop_entry $B0/${V0}0 dir
 
+# storage/posix considers that a file without gfid changed less than a second
+# before doesn't exist, so we need to wait for a second to force posix to
+# consider that this is a valid file but without gfid.
+sleep 2
+
 #Trigger entry-heal via shd
 TEST $CLI volume set $V0 self-heal-daemon on
 EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
diff --git a/tests/bugs/replicate/bug-1539358-split-brain-detection.t b/tests/bugs/replicate/bug-1539358-split-brain-detection.t
new file mode 100755
index 00000000000..7b71a7a9e7d
--- /dev/null
+++ b/tests/bugs/replicate/bug-1539358-split-brain-detection.t
@@ -0,0 +1,89 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+
+###############################################################################yy
+# Case of 2 bricks blaming the third and the third blaming the other two.
+
+TEST `echo "hello" >> $M0/file`
+
+# B0 and B2 must blame B1
+TEST kill_brick $V0 $H0 $B0/$V0"1"
+TEST `echo "append" >> $M0/file`
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}0/file trusted.afr.$V0-client-1 data
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}2/file trusted.afr.$V0-client-1 data
+CLIENT_MD5=$(md5sum $M0/file | cut -d\  -f1)
+
+# B1 must blame B0 and B2
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/$V0"1"/file
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/$V0"1"/file
+
+# Launch heal
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+TEST $CLI volume set $V0 self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+B0_MD5=$(md5sum $B0/${V0}0/file | cut -d\  -f1)
+B1_MD5=$(md5sum $B0/${V0}1/file | cut -d\  -f1)
+B2_MD5=$(md5sum $B0/${V0}2/file | cut -d\  -f1)
+TEST [ "$CLIENT_MD5" == "$B0_MD5" ]
+TEST [ "$CLIENT_MD5" == "$B1_MD5" ]
+TEST [ "$CLIENT_MD5" == "$B2_MD5" ]
+
+TEST rm $M0/file
+
+###############################################################################yy
+# Case of each brick blaming the next one in a cyclic manner
+
+TEST `echo "hello" >> $M0/file`
+# Mark cyclic xattrs and modify file content directly on the bricks.
+TEST $CLI volume set $V0 self-heal-daemon off
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000000000000 $B0/$V0"0"/file
+setfattr -n trusted.afr.dirty -v 0x000000010000000000000000 $B0/$V0"0"/file
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/$V0"1"/file
+setfattr -n trusted.afr.dirty -v 0x000000010000000000000000 $B0/$V0"1"/file
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/$V0"2"/file
+setfattr -n trusted.afr.dirty -v 0x000000010000000000000000 $B0/$V0"2"/file
+
+TEST `echo "ab" >> $B0/$V0"0"/file`
+TEST `echo "cdef" >> $B0/$V0"1"/file`
+TEST `echo "ghi" >> $B0/$V0"2"/file`
+
+# Add entry to xattrop dir to trigger index heal.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/file))
+ln $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_str
+EXPECT_WITHIN $HEAL_TIMEOUT "^1$" get_pending_heal_count $V0
+
+# Launch heal
+TEST $CLI volume set $V0 self-heal-daemon on
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+B0_MD5=$(md5sum $B0/${V0}0/file | cut -d\  -f1)
+B1_MD5=$(md5sum $B0/${V0}1/file | cut -d\  -f1)
+B2_MD5=$(md5sum $B0/${V0}2/file | cut -d\  -f1)
+TEST [ "$B0_MD5" == "$B1_MD5" ]
+TEST [ "$B0_MD5" == "$B2_MD5" ]
+###############################################################################yy
+cleanup
diff --git a/tests/bugs/replicate/bug-1561129-enospc.t b/tests/bugs/replicate/bug-1561129-enospc.t
new file mode 100644
index 00000000000..1b402fcc781
--- /dev/null
+++ b/tests/bugs/replicate/bug-1561129-enospc.t
@@ -0,0 +1,24 @@
+#!/bin/bash
+#Tests that sequential write workload doesn't lead to FSYNCs
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST truncate -s 128M $B0/xfs_image
+TEST mkfs.xfs -f $B0/xfs_image
+TEST mkdir $B0/bricks
+TEST mount -t xfs -o loop $B0/xfs_image $B0/bricks
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/bricks/brick{0,1,3}
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+# Write 50MB of data, which will try to consume 50x3=150MB on $B0/bricks.
+# Before that, we hit ENOSPC in pre-op cbk, which should not crash the mount.
+TEST ! dd if=/dev/zero of=$M0/a bs=1M count=50
+TEST stat $M0/a
+cleanup;
diff --git a/tests/bugs/replicate/bug-1586020-mark-dirty-for-entry-txn-on-quorum-failure.t b/tests/bugs/replicate/bug-1586020-mark-dirty-for-entry-txn-on-quorum-failure.t
new file mode 100644
index 00000000000..49c4dea4e9c
--- /dev/null
+++ b/tests/bugs/replicate/bug-1586020-mark-dirty-for-entry-txn-on-quorum-failure.t
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+function create_files {
+        local i=1
+        while (true)
+        do
+                dd if=/dev/zero of=$M0/file$i bs=1M count=10
+                if [ -e $B0/${V0}0/file$i ] || [ -e $B0/${V0}1/file$i ]; then
+                        ((i++))
+                else
+                        break
+                fi
+        done
+        echo $i
+}
+
+TEST glusterd
+
+#Create brick partitions
+TEST truncate -s 100M $B0/brick0
+TEST truncate -s 100M $B0/brick1
+#Have the 3rd brick of a higher size to test the scenario of entry transaction
+#passing on only one brick and not on other bricks.
+TEST truncate -s 110M $B0/brick2
+LO1=`SETUP_LOOP $B0/brick0`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO1
+LO2=`SETUP_LOOP $B0/brick1`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO2
+LO3=`SETUP_LOOP $B0/brick2`
+TEST [ $? -eq 0 ]
+TEST MKFS_LOOP $LO3
+TEST mkdir -p $B0/${V0}0 $B0/${V0}1 $B0/${V0}2
+TEST MOUNT_LOOP $LO1 $B0/${V0}0
+TEST MOUNT_LOOP $LO2 $B0/${V0}1
+TEST MOUNT_LOOP $LO3 $B0/${V0}2
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+
+i=$(create_files)
+TEST ! ls $B0/${V0}0/file$i
+TEST ! ls $B0/${V0}1/file$i
+TEST ls $B0/${V0}2/file$i
+dirty=$(get_hex_xattr trusted.afr.dirty $B0/${V0}2)
+TEST [ "$dirty" != "000000000000000000000000" ]
+
+TEST $CLI volume set $V0 self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST rm -f $M0/file1
+
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
+TEST force_umount $M0
+TEST $CLI volume stop $V0
+EXPECT 'Stopped' volinfo_field $V0 'Status';
+TEST $CLI volume delete $V0;
+UMOUNT_LOOP ${B0}/${V0}{0,1,2}
+rm -f ${B0}/brick{0,1,2}
+cleanup;
diff --git a/tests/bugs/replicate/bug-1591193-assign-gfid-and-heal.t b/tests/bugs/replicate/bug-1591193-assign-gfid-and-heal.t
new file mode 100644
index 00000000000..c6e5459e9a8
--- /dev/null
+++ b/tests/bugs/replicate/bug-1591193-assign-gfid-and-heal.t
@@ -0,0 +1,128 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+function check_gfid_and_link_count
+{
+        local file=$1
+
+        file_gfid_b0=$(gf_get_gfid_xattr $B0/${V0}0/$file)
+        TEST [ ! -z $file_gfid_b0 ]
+        file_gfid_b1=$(gf_get_gfid_xattr $B0/${V0}1/$file)
+        file_gfid_b2=$(gf_get_gfid_xattr $B0/${V0}2/$file)
+        EXPECT $file_gfid_b0 echo $file_gfid_b1
+        EXPECT $file_gfid_b0 echo $file_gfid_b2
+
+        EXPECT "2" stat -c %h $B0/${V0}0/$file
+        EXPECT "2" stat -c %h $B0/${V0}1/$file
+        EXPECT "2" stat -c %h $B0/${V0}2/$file
+}
+TESTS_EXPECTED_IN_LOOP=30
+
+##############################################################################
+# Test on 1x3 volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+
+# Create files directly in the backend on different bricks
+echo $RANDOM >> $B0/${V0}0/file1
+echo $RANDOM >> $B0/${V0}1/file2
+echo $RANDOM >> $B0/${V0}2/file3
+
+# To prevent is_fresh_file code path
+sleep 2
+
+# Access them from mount to trigger name + gfid heal.
+TEST stat $M0/file1
+TEST stat $M0/file2
+TEST stat $M0/file3
+
+# Launch index heal to complete any pending data/metadata heals.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# Check each file has a gfid and the .glusterfs hardlink
+check_gfid_and_link_count file1
+check_gfid_and_link_count file2
+check_gfid_and_link_count file3
+
+TEST rm $M0/file1
+TEST rm $M0/file2
+TEST rm $M0/file3
+cleanup;
+
+##############################################################################
+# Test on 1x (2+1) volume
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+
+# Create files directly in the backend on different bricks
+echo $RANDOM >> $B0/${V0}0/file1
+echo $RANDOM >> $B0/${V0}1/file2
+touch $B0/${V0}2/file3
+
+# To prevent is_fresh_file code path
+sleep 2
+
+# Access them from mount to trigger name + gfid heal.
+TEST stat $M0/file1
+TEST stat $M0/file2
+
+# Though file is created on all 3 bricks, lookup will fail as arbiter blames the
+# other 2 bricks and ariter is not 'readable'.
+TEST ! stat $M0/file3
+
+# Launch index heal to complete any pending data/metadata heals.
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# Now file3 should be accesible from mount.
+TEST stat $M0/file3
+
+# Check each file has a gfid and the .glusterfs hardlink
+check_gfid_and_link_count file1
+check_gfid_and_link_count file2
+check_gfid_and_link_count file3
+
+TEST rm $M0/file1
+TEST rm $M0/file2
+TEST rm $M0/file3
+cleanup;
diff --git a/tests/bugs/replicate/bug-1626994-info-split-brain.t b/tests/bugs/replicate/bug-1626994-info-split-brain.t
new file mode 100644
index 00000000000..86bfecb1a9e
--- /dev/null
+++ b/tests/bugs/replicate/bug-1626994-info-split-brain.t
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+# Test to check dirs having dirty xattr do not show up in info split-brain.
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+# Create base entry in indices/xattrop
+echo "Data" > $M0/FILE
+rm -f $M0/FILE
+EXPECT "1" count_index_entries $B0/${V0}0
+EXPECT "1" count_index_entries $B0/${V0}1
+EXPECT "1" count_index_entries $B0/${V0}2
+
+TEST mkdir $M0/dirty_dir
+TEST mkdir $M0/pending_dir
+
+# Set dirty xattrs on all bricks to simulate the case where entry transaction
+# succeeded only the pre-op phase.
+TEST setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}0/dirty_dir
+TEST setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}1/dirty_dir
+TEST setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}2/dirty_dir
+create_brick_xattrop_entry $B0/${V0}0  dirty_dir
+# Should not show up as split-brain.
+EXPECT "0" afr_get_split_brain_count $V0
+
+# replace/reset brick case where the new brick has dirty and the other 2 bricks
+# blame it should not be reported as split-brain.
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/${V0}0
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/${V0}1
+TEST setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}2
+create_brick_xattrop_entry $B0/${V0}0 "/"
+# Should not show up as split-brain.
+EXPECT "0" afr_get_split_brain_count $V0
+
+# Set pending xattrs on all bricks blaming each other to simulate the case of
+# entry split-brain.
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/${V0}0/pending_dir
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/${V0}1/pending_dir
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/${V0}2/pending_dir
+create_brick_xattrop_entry $B0/${V0}0 pending_dir
+# Should show up as split-brain.
+EXPECT "1" afr_get_split_brain_count $V0
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1637249-gfid-heal.t b/tests/bugs/replicate/bug-1637249-gfid-heal.t
new file mode 100644
index 00000000000..e824f14531e
--- /dev/null
+++ b/tests/bugs/replicate/bug-1637249-gfid-heal.t
@@ -0,0 +1,149 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1};
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 entry-self-heal off
+TEST $CLI volume start $V0;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+###############################################################################
+
+# Test for gfid + name heal when there is no 'source' brick, i.e. parent dir
+# xattrs are in split-brain or have dirty xattrs.
+
+TEST mkdir $M0/dir_pending
+TEST dd if=/dev/urandom of=$M0/dir_pending/file1 bs=1024 count=1024
+TEST mkdir $M0/dir_pending/dir11
+TEST mkdir $M0/dir_dirty
+TEST touch $M0/dir_dirty/file2
+
+# Set pending entry xattrs on dir_pending and remove gfid of entries under it on one brick.
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/${V0}0/dir_pending
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/${V0}1/dir_pending
+
+gfid_f1=$(gf_get_gfid_xattr $B0/${V0}0/dir_pending/file1)
+gfid_str_f1=$(gf_gfid_xattr_to_str $gfid_f1)
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir_pending/file1
+TEST rm $B0/${V0}1/.glusterfs/${gfid_str_f1:0:2}/${gfid_str_f1:2:2}/$gfid_str_f1
+
+gfid_d11=$(gf_get_gfid_xattr $B0/${V0}0/dir_pending/dir11)
+gfid_str_d11=$(gf_gfid_xattr_to_str $gfid_d11)
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir_pending/dir11
+TEST rm $B0/${V0}1/.glusterfs/${gfid_str_d11:0:2}/${gfid_str_d11:2:2}/$gfid_str_d11
+
+
+# Set dirty entry xattrs on dir_dirty and remove gfid of entries under it on one brick.
+TEST setfattr -n trusted.afr.dirty -v 0x000000000000000000000001 $B0/${V0}1/dir_dirty
+gfid_f2=$(gf_get_gfid_xattr $B0/${V0}0/dir_dirty/file2)
+gfid_str_f2=$(gf_gfid_xattr_to_str $gfid_f2)
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir_dirty/file2
+TEST rm $B0/${V0}1/.glusterfs/${gfid_str_f2:0:2}/${gfid_str_f2:2:2}/$gfid_str_f2
+
+# Create a file under dir_pending directly on the backend only on 1 brick
+TEST touch $B0/${V0}1/dir_pending/file3
+
+# Create a file under dir_pending directly on the backend on all bricks
+TEST touch $B0/${V0}0/dir_pending/file4
+TEST touch $B0/${V0}1/dir_pending/file4
+
+# Stop  & start the volume and mount client again.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop  $V0
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+TEST stat $M0/dir_pending/file1
+EXPECT "$gfid_f1" gf_get_gfid_xattr $B0/${V0}1/dir_pending/file1
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_f1:0:2}/${gfid_str_f1:2:2}/$gfid_str_f1
+
+TEST stat $M0/dir_pending/dir11
+EXPECT "$gfid_d11" gf_get_gfid_xattr $B0/${V0}1/dir_pending/dir11
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_d11:0:2}/${gfid_str_d11:2:2}/$gfid_str_d11
+
+
+TEST stat $M0/dir_dirty/file2
+EXPECT "$gfid_f2" gf_get_gfid_xattr $B0/${V0}1/dir_dirty/file2
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_f2:0:2}/${gfid_str_f2:2:2}/$gfid_str_f2
+
+TEST stat $M0/dir_pending/file3 # This assigns gfid on 2nd brick and heals the entry on to the 1st brick.
+gfid_f3=$(gf_get_gfid_xattr $B0/${V0}1/dir_pending/file3)
+TEST [ ! -z "$gfid_f3" ]
+EXPECT "$gfid_f3" gf_get_gfid_xattr $B0/${V0}0/dir_pending/file3
+
+TEST stat $M0/dir_pending/file4
+gfid_f4=$(gf_get_gfid_xattr $B0/${V0}0/dir_pending/file4)
+TEST [ ! -z "$gfid_f4" ]
+EXPECT "$gfid_f4" gf_get_gfid_xattr $B0/${V0}1/dir_pending/file4
+###############################################################################
+
+# Test for gfid + name heal when all bricks are 'source', i.e. parent dir
+# does not have any pending or dirty xattrs.
+
+TEST mkdir $M0/dir_clean
+TEST dd if=/dev/urandom of=$M0/dir_clean/file1 bs=1024 count=1024
+TEST mkdir $M0/dir_clean/dir11
+
+gfid_f1=$(gf_get_gfid_xattr $B0/${V0}0/dir_clean/file1)
+gfid_str_f1=$(gf_gfid_xattr_to_str $gfid_f1)
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir_clean/file1
+TEST rm $B0/${V0}1/.glusterfs/${gfid_str_f1:0:2}/${gfid_str_f1:2:2}/$gfid_str_f1
+
+gfid_d11=$(gf_get_gfid_xattr $B0/${V0}0/dir_clean/dir11)
+gfid_str_d11=$(gf_gfid_xattr_to_str $gfid_d11)
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir_clean/dir11
+TEST rm $B0/${V0}1/.glusterfs/${gfid_str_d11:0:2}/${gfid_str_d11:2:2}/$gfid_str_d11
+
+# Create a file under dir_clean directly on the backend only on 1 brick
+TEST touch $B0/${V0}1/dir_clean/file3
+
+# Create a file under dir_clean directly on the backend on all bricks
+TEST touch $B0/${V0}0/dir_clean/file4
+TEST touch $B0/${V0}1/dir_clean/file4
+
+# Stop  & start the volume and mount client again.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop  $V0
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+TEST stat $M0/dir_clean/file1
+EXPECT "$gfid_f1" gf_get_gfid_xattr $B0/${V0}1/dir_clean/file1
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_f1:0:2}/${gfid_str_f1:2:2}/$gfid_str_f1
+
+TEST stat $M0/dir_clean/dir11
+EXPECT "$gfid_d11" gf_get_gfid_xattr $B0/${V0}1/dir_clean/dir11
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_d11:0:2}/${gfid_str_d11:2:2}/$gfid_str_d11
+
+TEST stat $M0/dir_clean/file3 # This assigns gfid on 2nd brick and heals the entry on to the 1st brick.
+gfid_f3=$(gf_get_gfid_xattr $B0/${V0}1/dir_clean/file3)
+TEST [ ! -z "$gfid_f3" ]
+EXPECT "$gfid_f3" gf_get_gfid_xattr $B0/${V0}0/dir_clean/file3
+
+TEST stat $M0/dir_clean/file4
+gfid_f4=$(gf_get_gfid_xattr $B0/${V0}0/dir_clean/file4)
+TEST [ ! -z "$gfid_f4" ]
+EXPECT "$gfid_f4" gf_get_gfid_xattr $B0/${V0}1/dir_clean/file4
+###############################################################################
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1637802-arbiter-stale-data-heal-lock.t b/tests/bugs/replicate/bug-1637802-arbiter-stale-data-heal-lock.t
new file mode 100644
index 00000000000..d7d1f285e01
--- /dev/null
+++ b/tests/bugs/replicate/bug-1637802-arbiter-stale-data-heal-lock.t
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+# Test to check that data self-heal does not leave any stale lock.
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+# Create base entry in indices/xattrop
+echo "Data" > $M0/FILE
+
+# Kill arbiter brick and write to FILE.
+TEST kill_brick $V0 $H0 $B0/${V0}2
+echo "arbiter down" >> $M0/FILE
+EXPECT 2 get_pending_heal_count $V0
+
+# Bring it back up and let heal complete.
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# write to the FILE must succeed.
+echo "this must succeed" >> $M0/FILE
+TEST [ $? -eq 0 ]
+cleanup;
diff --git a/tests/bugs/replicate/bug-1655050-dir-sbrain-size-policy.t b/tests/bugs/replicate/bug-1655050-dir-sbrain-size-policy.t
new file mode 100644
index 00000000000..63f72e86bf6
--- /dev/null
+++ b/tests/bugs/replicate/bug-1655050-dir-sbrain-size-policy.t
@@ -0,0 +1,55 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+#Create replica 2 volume
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 data-self-heal off
+TEST $CLI volume set $V0 entry-self-heal off
+TEST $CLI volume set $V0 metadata-self-heal off
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+
+cd $M0
+TEST mkdir dir
+
+#Create metadata split-brain
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST chmod 757 dir
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST chmod 747 dir
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+
+#Use size as fav-child policy.
+TEST $CLI volume set $V0 cluster.favorite-child-policy size
+
+#Enable shd and heal the file.
+TEST $CLI volume set $V0 cluster.self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+TEST $CLI volume heal $V0
+
+EXPECT_WITHIN $HEAL_TIMEOUT "2" get_pending_heal_count $V0
+
+b1c1dir=$(afr_get_specific_changelog_xattr $B0/${V0}0/dir \
+          trusted.afr.$V0-client-1 "metadata")
+b2c0dir=$(afr_get_specific_changelog_xattr $B0/${V0}1/dir \
+          trusted.afr.$V0-client-0 "metadata")
+
+EXPECT "00000001" echo $b1c1dir
+EXPECT "00000001" echo $b2c0dir
+
+#Finish up
+TEST force_umount $M0
+cleanup;
diff --git a/tests/bugs/replicate/bug-1655052-sbrain-policy-same-size.t b/tests/bugs/replicate/bug-1655052-sbrain-policy-same-size.t
new file mode 100755
index 00000000000..319736e1157
--- /dev/null
+++ b/tests/bugs/replicate/bug-1655052-sbrain-policy-same-size.t
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+#Test the split-brain resolution CLI commands.
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+#Create replica 2 volume
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume set $V0 cluster.data-self-heal off
+TEST $CLI volume set $V0 cluster.metadata-self-heal off
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+TEST touch $M0/file
+
+############ Healing using favorite-child-policy = size and size of bricks is same #################
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST dd if=/dev/urandom of=$M0/file bs=1024 count=1024
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST dd if=/dev/urandom of=$M0/file bs=1024 count=1024
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+TEST $CLI volume set $V0 cluster.self-heal-daemon on
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+TEST $CLI volume heal $V0
+
+#file still in split-brain
+EXPECT_WITHIN $HEAL_TIMEOUT "2" get_pending_heal_count $V0
+cat $M0/file > /dev/null
+EXPECT_NOT "^0$" echo $?
+
+#We know that both bricks have same size file
+TEST $CLI volume set $V0 cluster.favorite-child-policy size
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "2" get_pending_heal_count $V0
+cat $M0/file > /dev/null
+EXPECT_NOT "^0$" echo $?
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+cleanup
+
diff --git a/tests/bugs/replicate/bug-1655854-support-dist-to-rep3-arb-conversion.t b/tests/bugs/replicate/bug-1655854-support-dist-to-rep3-arb-conversion.t
new file mode 100644
index 00000000000..783016dc3c0
--- /dev/null
+++ b/tests/bugs/replicate/bug-1655854-support-dist-to-rep3-arb-conversion.t
@@ -0,0 +1,95 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+# Conversion from 2x1 to 2x3
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+EXPECT 'Created' volinfo_field $V0 'Status';
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST mkdir $M0/dir
+TEST dd if=/dev/urandom of=$M0/dir/file bs=100K count=5
+file_md5sum=$(md5sum $M0/dir/file | awk '{print $1}')
+
+TEST $CLI volume add-brick $V0 replica 3 $H0:$B0/${V0}{2..5}
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}4
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}5
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 3
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 4
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 5
+
+# Trigger heal and wait for for it to complete
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# Check whether the directory & file are healed to the newly added bricks
+TEST ls $B0/${V0}2/dir
+TEST ls $B0/${V0}3/dir
+TEST ls $B0/${V0}4/dir
+TEST ls $B0/${V0}5/dir
+
+TEST [ $file_md5sum == $(md5sum $B0/${V0}4/dir/file | awk '{print $1}') ]
+TEST [ $file_md5sum == $(md5sum $B0/${V0}5/dir/file | awk '{print $1}') ]
+
+
+# Conversion from 2x1 to 2x(2+1)
+
+TEST $CLI volume create $V1 $H0:$B0/${V1}{0,1}
+EXPECT 'Created' volinfo_field $V1 'Status';
+TEST $CLI volume start $V1
+EXPECT 'Started' volinfo_field $V1 'Status';
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}1
+
+TEST $GFS --volfile-id=$V1 --volfile-server=$H0 $M1;
+TEST mkdir $M1/dir
+TEST dd if=/dev/urandom of=$M1/dir/file bs=100K count=5
+file_md5sum=$(md5sum $M1/dir/file | awk '{print $1}')
+
+TEST $CLI volume add-brick $V1 replica 3 arbiter 1 $H0:$B0/${V1}{2..5}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}3
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}4
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V1 $H0 $B0/${V1}5
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 2
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 3
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 4
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V1 5
+
+# Trigger heal and wait for for it to complete
+TEST $CLI volume heal $V1
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V1
+
+# Check whether the directory & file are healed to the newly added bricks
+TEST ls $B0/${V1}2/dir
+TEST ls $B0/${V1}3/dir
+TEST ls $B0/${V1}4/dir
+TEST ls $B0/${V1}5/dir
+
+EXPECT "0" stat -c %s $B0/${V1}5/dir/file
+TEST [ $file_md5sum == $(md5sum $B0/${V1}4/dir/file | awk '{print $1}') ]
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1657783-do-not-update-read-subvol-on-rename-link.t b/tests/bugs/replicate/bug-1657783-do-not-update-read-subvol-on-rename-link.t
new file mode 100644
index 00000000000..b180f0e1239
--- /dev/null
+++ b/tests/bugs/replicate/bug-1657783-do-not-update-read-subvol-on-rename-link.t
@@ -0,0 +1,40 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0..2}
+TEST $CLI volume set $V0 self-heal-daemon off
+TEST $CLI volume set $V0 cluster.data-self-heal off
+TEST $CLI volume set $V0 cluster.metadata-self-heal off
+TEST $CLI volume set $V0 cluster.entry-self-heal off
+TEST $CLI volume set $V0 performance.write-behind off
+
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST mkdir $M0/dir
+TEST "echo abc > $M0/file1"
+TEST "echo uvw > $M0/file2"
+
+TEST kill_brick $V0 $H0 $B0/${V0}0
+TEST "echo def > $M0/file1"
+TEST "echo xyz > $M0/file2"
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+
+TEST kill_brick $V0 $H0 $B0/${V0}1
+
+# Rename file1 and read it. Read should be served from the 3rd brick
+TEST mv $M0/file1 $M0/file3
+EXPECT "def" cat $M0/file3
+
+# Create a link to file2 and read it. Read should be served from the 3rd brick
+TEST ln $M0/file2 $M0/dir/file4
+EXPECT "xyz" cat $M0/dir/file4
+EXPECT "xyz" cat $M0/file2
+
+cleanup
diff --git a/tests/bugs/replicate/bug-1686568-send-truncate-on-arbiter-from-shd.t b/tests/bugs/replicate/bug-1686568-send-truncate-on-arbiter-from-shd.t
new file mode 100644
index 00000000000..78581e99614
--- /dev/null
+++ b/tests/bugs/replicate/bug-1686568-send-truncate-on-arbiter-from-shd.t
@@ -0,0 +1,38 @@
+#!/bin/bash
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+CHANGELOG_PATH_0="$B0/${V0}2/.glusterfs/changelogs"
+ROLLOVER_TIME=100
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 changelog.changelog on
+TEST $CLI volume set $V0 changelog.rollover-time $ROLLOVER_TIME
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST dd if=/dev/zero of=$M0/file1 bs=128K count=5
+
+TEST $CLI volume profile $V0 start
+TEST $CLI volume add-brick $V0 replica 3 arbiter 1 $H0:$B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+TEST $CLI volume profile $V0 info
+truncate_count=$($CLI volume profile $V0 info | grep TRUNCATE | awk '{count += $8} END {print count}')
+
+EXPECT "1" echo $truncate_count
+EXPECT "1" check_changelog_op ${CHANGELOG_PATH_0} "^ D "
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1696599-io-hang.t b/tests/bugs/replicate/bug-1696599-io-hang.t
new file mode 100755
index 00000000000..869cdb94bda
--- /dev/null
+++ b/tests/bugs/replicate/bug-1696599-io-hang.t
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fileio.rc
+
+#Tests that local structures in afr are removed from granted/blocked list of
+#locks when inodelk fails on all bricks
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1..3}
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 performance.client-io-threads off
+TEST $CLI volume set $V0 delay-gen locks
+TEST $CLI volume set $V0 delay-gen.delay-duration 5000000
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.enable finodelk
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+TEST touch $M0/file
+#Trigger write and stop bricks so inodelks fail on all bricks leading to
+#lock failure condition
+echo abc >> $M0/file &
+
+TEST $CLI volume stop $V0
+TEST $CLI volume reset $V0 delay-gen
+wait
+TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_meta $M0 $V0-replicate-0 2
+#Test that only one write succeeded, this tests that delay-gen worked as
+#expected
+echo abc >> $M0/file
+EXPECT "abc" cat $M0/file
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1717819-metadata-split-brain-detection.t b/tests/bugs/replicate/bug-1717819-metadata-split-brain-detection.t
new file mode 100644
index 00000000000..76d1f2170f2
--- /dev/null
+++ b/tests/bugs/replicate/bug-1717819-metadata-split-brain-detection.t
@@ -0,0 +1,136 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $CLI volume heal $V0 disable
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+###############################################################################
+# Case of 2 bricks blaming the third and the third blaming the other two.
+
+TEST mkdir $M0/dir
+
+# B0 and B2 must blame B1
+TEST kill_brick $V0 $H0 $B0/$V0"1"
+TEST setfattr -n user.metadata -v 1 $M0/dir
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}0/dir trusted.afr.$V0-client-1 metadata
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}2/dir trusted.afr.$V0-client-1 metadata
+CLIENT_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $M0/dir)
+
+# B1 must blame B0 and B2
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000100000000 $B0/$V0"1"/dir
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000100000000 $B0/$V0"1"/dir
+
+# Launch heal
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" brick_up_status $V0 $H0 $B0/${V0}1
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+B0_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}0/dir)
+B1_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}1/dir)
+B2_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}2/dir)
+
+TEST [ "$CLIENT_XATTR" == "$B0_XATTR" ]
+TEST [ "$CLIENT_XATTR" == "$B1_XATTR" ]
+TEST [ "$CLIENT_XATTR" == "$B2_XATTR" ]
+TEST setfattr -x user.metadata $M0/dir
+
+###############################################################################
+# Case of each brick blaming the next one in a cyclic manner
+
+TEST $CLI volume heal $V0 disable
+TEST `echo "hello" >> $M0/dir/file`
+# Mark cyclic xattrs and modify metadata directly on the bricks.
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000100000000 $B0/$V0"0"/dir/file
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000100000000 $B0/$V0"1"/dir/file
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000100000000 $B0/$V0"2"/dir/file
+
+setfattr -n user.metadata -v 1 $B0/$V0"0"/dir/file
+setfattr -n user.metadata -v 2 $B0/$V0"1"/dir/file
+setfattr -n user.metadata -v 3 $B0/$V0"2"/dir/file
+
+# Add entry to xattrop dir to trigger index heal.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/dir/file))
+ln $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_str
+EXPECT_WITHIN $HEAL_TIMEOUT "^1$" get_pending_heal_count $V0
+
+# Launch heal
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+B0_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}0/dir/file)
+B1_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}1/dir/file)
+B2_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}2/dir/file)
+
+TEST [ "$B0_XATTR" == "$B1_XATTR" ]
+TEST [ "$B0_XATTR" == "$B2_XATTR" ]
+TEST rm -f $M0/dir/file
+
+###############################################################################
+# Case of 2 bricks having quorum blaming and the other having only one blaming.
+
+TEST $CLI volume heal $V0 disable
+TEST `echo "hello" >> $M0/dir/file`
+# B0 and B2 must blame B1
+TEST kill_brick $V0 $H0 $B0/$V0"1"
+TEST setfattr -n user.metadata -v 1 $M0/dir/file
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}0/dir/file trusted.afr.$V0-client-1 metadata
+EXPECT "00000001" afr_get_specific_changelog_xattr $B0/${V0}2/dir/file trusted.afr.$V0-client-1 metadata
+
+# B1 must blame B0 and B2
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000100000000 $B0/$V0"1"/dir/file
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000100000000 $B0/$V0"1"/dir/file
+
+# B0 must blame B2
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000100000000 $B0/$V0"0"/dir/file
+
+# Modify the metadata directly on the bricks B1 & B2.
+setfattr -n user.metadata -v 2 $B0/$V0"1"/dir/file
+setfattr -n user.metadata -v 3 $B0/$V0"2"/dir/file
+
+# Launch heal
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^1$" brick_up_status $V0 $H0 $B0/${V0}1
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+B0_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}0/dir/file)
+B1_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}1/dir/file)
+B2_XATTR=$(getfattr -n 'user.metadata' --absolute-names --only-values $B0/${V0}2/dir/file)
+
+TEST [ "$B0_XATTR" == "$B1_XATTR" ]
+TEST [ "$B0_XATTR" == "$B2_XATTR" ]
+
+###############################################################################
+
+cleanup
diff --git a/tests/bugs/replicate/bug-1722507-type-mismatch-error-handling.t b/tests/bugs/replicate/bug-1722507-type-mismatch-error-handling.t
new file mode 100644
index 00000000000..0aeaaafc84c
--- /dev/null
+++ b/tests/bugs/replicate/bug-1722507-type-mismatch-error-handling.t
@@ -0,0 +1,116 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+TEST $CLI volume set $V0 cluster.heal-timeout 5
+TEST $CLI volume heal $V0 disable
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST mkdir $M0/dir
+
+##########################################################################################
+# GFID link file and the GFID is missing on one brick and all the bricks are being blamed.
+
+TEST touch $M0/dir/file
+#TEST kill_brick $V0 $H0 $B0/$V0"1"
+
+#B0 and B2 must blame B1
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/$V0"2"/dir
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/$V0"0"/dir
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/$V0"0"/dir
+
+# Add entry to xattrop dir to trigger index heal.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/dir/))
+ln -s $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_str
+EXPECT "^1$" get_pending_heal_count $V0
+
+# Remove the gfid xattr and the link file on one brick.
+gfid_file=$(gf_get_gfid_xattr $B0/$V0"0"/dir/file)
+gfid_str_file=$(gf_gfid_xattr_to_str $gfid_file)
+TEST setfattr -x trusted.gfid $B0/${V0}0/dir/file
+TEST rm -f $B0/${V0}0/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+
+# Launch heal
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+
+# Wait for 2 second to force posix to consider that this is a valid file but
+# without gfid.
+sleep 2
+TEST $CLI volume heal $V0
+
+# Heal should not fail as the file is missing gfid xattr and the link file,
+# which is not actually the gfid or type mismatch.
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT "$gfid_file" gf_get_gfid_xattr $B0/${V0}0/dir/file
+TEST stat $B0/${V0}0/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+rm -f $M0/dir/file
+
+
+###########################################################################################
+# GFID link file and the GFID is missing on two bricks and all the bricks are being blamed.
+
+TEST $CLI volume heal $V0 disable
+TEST touch $M0/dir/file
+#TEST kill_brick $V0 $H0 $B0/$V0"1"
+
+#B0 and B2 must blame B1
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/$V0"2"/dir
+setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000001 $B0/$V0"0"/dir
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/$V0"0"/dir
+
+# Add entry to xattrop dir to trigger index heal.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/dir/))
+ln -s $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_str
+EXPECT "^1$" get_pending_heal_count $V0
+
+# Remove the gfid xattr and the link file on two bricks.
+gfid_file=$(gf_get_gfid_xattr $B0/$V0"0"/dir/file)
+gfid_str_file=$(gf_gfid_xattr_to_str $gfid_file)
+TEST setfattr -x trusted.gfid $B0/${V0}0/dir/file
+TEST rm -f $B0/${V0}0/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+TEST setfattr -x trusted.gfid $B0/${V0}1/dir/file
+TEST rm -f $B0/${V0}1/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+
+# Launch heal
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+
+# Wait for 2 second to force posix to consider that this is a valid file but
+# without gfid.
+sleep 2
+TEST $CLI volume heal $V0
+
+# Heal should not fail as the file is missing gfid xattr and the link file,
+# which is not actually the gfid or type mismatch.
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+EXPECT "$gfid_file" gf_get_gfid_xattr $B0/${V0}0/dir/file
+TEST stat $B0/${V0}0/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+EXPECT "$gfid_file" gf_get_gfid_xattr $B0/${V0}1/dir/file
+TEST stat $B0/${V0}1/.glusterfs/${gfid_str_file:0:2}/${gfid_str_file:2:2}/$gfid_str_file
+
+cleanup
diff --git a/tests/bugs/replicate/bug-1728770-pass-xattrs.t b/tests/bugs/replicate/bug-1728770-pass-xattrs.t
new file mode 100644
index 00000000000..159c4fcc6a1
--- /dev/null
+++ b/tests/bugs/replicate/bug-1728770-pass-xattrs.t
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup;
+
+function fop_on_bad_disk {
+    local path=$1
+    mkdir $path/dir{1..1000} 2>/dev/null
+    mv $path/dir1 $path/newdir
+    touch $path/foo.txt
+    echo $?
+}
+
+function ls_fop_on_bad_disk {
+    local path=$1
+    ls $path
+    echo $?
+}
+
+TEST init_n_bricks 6;
+TEST setup_lvm 6;
+
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 replica 3 $H0:$L1 $H0:$L2 $H0:$L3 $H0:$L4 $H0:$L5 $H0:$L6;
+TEST $CLI volume set $V0 health-check-interval 1000;
+
+TEST $CLI volume start $V0;
+
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0;
+#corrupt last disk
+dd if=/dev/urandom of=/dev/mapper/patchy_snap_vg_6-brick_lvm bs=512K count=200 status=progress && sync
+
+
+# Test the disk is now returning EIO for touch and ls
+EXPECT_WITHIN $DISK_FAIL_TIMEOUT "^1$" fop_on_bad_disk "$L6"
+EXPECT_WITHIN $DISK_FAIL_TIMEOUT "^2$" ls_fop_on_bad_disk "$L6"
+
+TEST touch $M0/foo{1..100}
+TEST $CLI volume remove-brick $V0 replica 3 $H0:$L4 $H0:$L5 $H0:$L6 start
+EXPECT_WITHIN $REBALANCE_TIMEOUT "completed" remove_brick_status_completed_field "$V0" "$H0:$L4 $H0:$L5 $H0:$L6";
+
+#check that remove-brick status should not have any failed or skipped files
+var=`$CLI volume remove-brick $V0 $H0:$L4 $H0:$L5 $H0:$L6 status | grep completed`
+TEST [ `echo $var | awk '{print $5}'` = "0"  ]
+TEST [ `echo $var | awk '{print $6}'` = "0"  ]
+
+cleanup;
diff --git a/tests/bugs/replicate/bug-1734370-entry-heal-restore-time.t b/tests/bugs/replicate/bug-1734370-entry-heal-restore-time.t
new file mode 100644
index 00000000000..14dfae89135
--- /dev/null
+++ b/tests/bugs/replicate/bug-1734370-entry-heal-restore-time.t
@@ -0,0 +1,102 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+function time_stamps_match {
+        path=$1
+        mtime_source_b0=$(get_mtime $B0/${V0}0/$path)
+        atime_source_b0=$(get_atime $B0/${V0}0/$path)
+        mtime_source_b2=$(get_mtime $B0/${V0}2/$path)
+        atime_source_b2=$(get_atime $B0/${V0}2/$path)
+        mtime_sink_b1=$(get_mtime $B0/${V0}1/$path)
+        atime_sink_b1=$(get_atime $B0/${V0}1/$path)
+
+        #The same brick must be the source of heal for both atime and mtime.
+        if [[ ( $mtime_source_b0 -eq $mtime_sink_b1 && $atime_source_b0 -eq $atime_sink_b1 ) || \
+              ( $mtime_source_b2 -eq $mtime_sink_b1 && $atime_source_b2 -eq $atime_sink_b1 ) ]]
+        then
+            echo "Y"
+        else
+            echo "Mtimes: $mtime_source_b0:$mtime_sink_b1:$mtime_source_b2 Atimes: $atime_source_b0:$atime_sink_b1:$atime_source_b2"
+        fi
+
+}
+
+function mtimes_match {
+        path=$1
+        mtime_source_b0=$(get_mtime $B0/${V0}0/$path)
+        mtime_source_b2=$(get_mtime $B0/${V0}2/$path)
+        mtime_sink_b1=$(get_mtime $B0/${V0}1/$path)
+
+        if [[ ( $mtime_source_b0 -eq $mtime_sink_b1) || \
+              ( $mtime_source_b2 -eq $mtime_sink_b1) ]]
+        then
+            echo "Y"
+        else
+            echo "Mtimes: $mtime_source_b0:$mtime_sink_b1:$mtime_source_b2"
+        fi
+
+}
+
+# Test that the parent dir's timestamps are restored during entry-heal.
+GET_MDATA_PATH=$(dirname $0)/../../utils
+build_tester $GET_MDATA_PATH/get-mdata-xattr.c
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 --attribute-timeout=0 --entry-timeout=0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+###############################################################################
+TEST mkdir $M0/DIR
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST touch $M0/DIR/FILE
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
+
+EXPECT "Y" time_stamps_match DIR
+ctime_source1=$(get_ctime $B0/${V0}0/$path)
+ctime_source2=$(get_ctime $B0/${V0}2/$path)
+ctime_sink=$(get_ctime $B0/${V0}1/$path)
+TEST [ $ctime_source1 -eq $ctime_sink ]
+TEST [ $ctime_source2 -eq $ctime_sink ]
+
+
+###############################################################################
+# Repeat the test with ctime feature disabled.
+TEST $CLI volume set $V0 features.ctime off
+TEST mkdir $M0/DIR2
+TEST kill_brick $V0 $H0 $B0/${V0}1
+TEST touch $M0/DIR2/FILE
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+#Executing parallel heal may lead to changing atime after heal. So better
+#to test just the mtime
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
+
+EXPECT "Y" mtimes_match DIR2
+
+TEST rm $GET_MDATA_PATH/get-mdata-xattr
+cleanup;
diff --git a/tests/bugs/replicate/bug-1744548-heal-timeout.t b/tests/bugs/replicate/bug-1744548-heal-timeout.t
new file mode 100644
index 00000000000..011535066f9
--- /dev/null
+++ b/tests/bugs/replicate/bug-1744548-heal-timeout.t
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+function get_cumulative_opendir_count {
+#sed command prints content between Cumulative and Interval, this keeps content from Cumulative stats
+    $CLI volume profile $V0 info |sed -n '/^Cumulative/,/^Interval/p'|grep OPENDIR| awk '{print $8}'|tr -d '\n'
+}
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume heal $V0 disable
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST ! $CLI volume heal $V0
+
+# Enable shd and verify that index crawl is triggered immediately.
+TEST $CLI volume profile $V0 start
+TEST $CLI volume profile $V0 info clear
+TEST $CLI volume heal $V0 enable
+# Each brick does 4 opendirs, corresponding to dirty, xattrop and entry-changes, anonymous-inode
+EXPECT_WITHIN 4 "^444$" get_cumulative_opendir_count
+
+# Check that a change in heal-timeout is honoured immediately.
+TEST $CLI volume set $V0 cluster.heal-timeout 5
+sleep 10
+# Two crawls must have happened.
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^121212$" get_cumulative_opendir_count
+
+# shd must not heal if it is disabled and heal-timeout is changed.
+TEST $CLI volume heal $V0 disable
+#Wait for configuration update and any opendir fops to complete
+sleep 10
+TEST $CLI volume profile $V0 info clear
+TEST $CLI volume set $V0 cluster.heal-timeout 6
+#Better to wait for more than 6 seconds to account for configuration updates
+sleep 10
+COUNT=`$CLI volume profile $V0 info incremental |grep OPENDIR|awk '{print $8}'|tr -d '\n'`
+TEST [ -z $COUNT ]
+cleanup;
diff --git a/tests/bugs/replicate/bug-1749322-entry-heal-not-happening.t b/tests/bugs/replicate/bug-1749322-entry-heal-not-happening.t
new file mode 100644
index 00000000000..96279084065
--- /dev/null
+++ b/tests/bugs/replicate/bug-1749322-entry-heal-not-happening.t
@@ -0,0 +1,89 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup
+
+function check_gfid_and_link_count
+{
+        local file=$1
+
+        file_gfid_b0=$(gf_get_gfid_xattr $B0/${V0}0/$file)
+        TEST [ ! -z $file_gfid_b0 ]
+        file_gfid_b1=$(gf_get_gfid_xattr $B0/${V0}1/$file)
+        file_gfid_b2=$(gf_get_gfid_xattr $B0/${V0}2/$file)
+        EXPECT $file_gfid_b0 echo $file_gfid_b1
+        EXPECT $file_gfid_b0 echo $file_gfid_b2
+
+        EXPECT "2" stat -c %h $B0/${V0}0/$file
+        EXPECT "2" stat -c %h $B0/${V0}1/$file
+        EXPECT "2" stat -c %h $B0/${V0}2/$file
+}
+TESTS_EXPECTED_IN_LOOP=18
+
+################################################################################
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume start $V0;
+TEST $CLI volume set $V0 cluster.heal-timeout 5
+TEST $CLI volume heal $V0 disable
+EXPECT 'Started' volinfo_field $V0 'Status';
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+
+TEST mkdir $M0/dir
+TEST `echo "File 1 " > $M0/dir/file1`
+TEST touch $M0/dir/file{2..4}
+
+# Remove file2 from 1st & 3rd bricks
+TEST rm -f $B0/$V0"0"/dir/file2
+TEST rm -f $B0/$V0"2"/dir/file2
+
+# Remove file3 and the .glusterfs hardlink from 1st & 2nd bricks
+gfid_file3=$(gf_get_gfid_xattr $B0/$V0"0"/dir/file3)
+gfid_str_file3=$(gf_gfid_xattr_to_str $gfid_file3)
+TEST rm $B0/$V0"0"/.glusterfs/${gfid_str_file3:0:2}/${gfid_str_file3:2:2}/$gfid_str_file3
+TEST rm $B0/$V0"1"/.glusterfs/${gfid_str_file3:0:2}/${gfid_str_file3:2:2}/$gfid_str_file3
+TEST rm -f $B0/$V0"0"/dir/file3
+TEST rm -f $B0/$V0"1"/dir/file3
+
+# Remove the .glusterfs hardlink and the gfid xattr of file4 on 3rd brick
+gfid_file4=$(gf_get_gfid_xattr $B0/$V0"0"/dir/file4)
+gfid_str_file4=$(gf_gfid_xattr_to_str $gfid_file4)
+TEST rm $B0/$V0"2"/.glusterfs/${gfid_str_file4:0:2}/${gfid_str_file4:2:2}/$gfid_str_file4
+TEST setfattr -x trusted.gfid $B0/$V0"2"/dir/file4
+
+# B0 and B2 blame each other
+setfattr -n trusted.afr.$V0-client-0 -v 0x000000000000000000000001 $B0/$V0"2"/dir
+setfattr -n trusted.afr.$V0-client-2 -v 0x000000000000000000000001 $B0/$V0"0"/dir
+
+# Add entry to xattrop dir on first brick.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/dir/))
+TEST ln $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_str
+
+EXPECT "^1$" get_pending_heal_count $V0
+
+# Launch heal
+TEST $CLI volume heal $V0 enable
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "^Y$" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "^1$" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# All the files must be present on all the bricks after conservative merge and
+# should have the gfid xattr and the .glusterfs hardlink.
+check_gfid_and_link_count dir/file1
+check_gfid_and_link_count dir/file2
+check_gfid_and_link_count dir/file3
+check_gfid_and_link_count dir/file4
+
+cleanup
diff --git a/tests/bugs/replicate/bug-1756938-replica-3-sbrain-cli.t b/tests/bugs/replicate/bug-1756938-replica-3-sbrain-cli.t
new file mode 100644
index 00000000000..c1bdf34ee6d
--- /dev/null
+++ b/tests/bugs/replicate/bug-1756938-replica-3-sbrain-cli.t
@@ -0,0 +1,111 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+
+cleanup;
+
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard enable
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+
+TEST $CLI volume start $V0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+TEST glusterfs --volfile-server=$H0 --volfile-id=/$V0 $M0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+#Create split-brain by setting afr xattrs/gfids manually.
+#file1 is non-sharded and will be in data split-brain.
+#file2 will have one shard which will be in data split-brain.
+#file3 will have one shard which will be in gfid split-brain.
+#file4 will have one shard which will be in data & metadata split-brain.
+TEST dd if=/dev/zero of=$M0/file1 bs=1024 count=1024 oflag=direct
+TEST dd if=/dev/zero of=$M0/file2 bs=1M count=6 oflag=direct
+TEST dd if=/dev/zero of=$M0/file3 bs=1M count=6 oflag=direct
+TEST dd if=/dev/zero of=$M0/file4 bs=1M count=6 oflag=direct
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+#-------------------------------------------------------------------------------
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000000000000 $B0/${V0}0/file1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/${V0}0/file1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/${V0}1/file1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/${V0}1/file1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/${V0}2/file1
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000000000000 $B0/${V0}2/file1
+
+#-------------------------------------------------------------------------------
+gfid_f2=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/file2))
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000000000000 $B0/${V0}0/.shard/$gfid_f2.1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/${V0}0/.shard/$gfid_f2.1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/${V0}1/.shard/$gfid_f2.1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000000000000 $B0/${V0}1/.shard/$gfid_f2.1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000000000000 $B0/${V0}2/.shard/$gfid_f2.1
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000000000000 $B0/${V0}2/.shard/$gfid_f2.1
+
+#-------------------------------------------------------------------------------
+TESTS_EXPECTED_IN_LOOP=5
+function assign_new_gfid {
+    brickpath=$1
+    filename=$2
+    gfid=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $brickpath/$filename))
+    gfid_shard=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $brickpath/.shard/$gfid.1))
+
+    TEST rm $brickpath/.glusterfs/${gfid_shard:0:2}/${gfid_shard:2:2}/$gfid_shard
+    TEST setfattr -x trusted.gfid $brickpath/.shard/$gfid.1
+    new_gfid=$(get_random_gfid)
+    new_gfid_str=$(gf_gfid_xattr_to_str $new_gfid)
+    TEST setfattr -n trusted.gfid -v $new_gfid $brickpath/.shard/$gfid.1
+    TEST mkdir -p $brickpath/.glusterfs/${new_gfid_str:0:2}/${new_gfid_str:2:2}
+    TEST ln $brickpath/.shard/$gfid.1 $brickpath/.glusterfs/${new_gfid_str:0:2}/${new_gfid_str:2:2}/$new_gfid_str
+}
+assign_new_gfid $B0/$V0"1" file3
+assign_new_gfid $B0/$V0"2" file3
+
+#-------------------------------------------------------------------------------
+gfid_f4=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/file4))
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000100000000 $B0/${V0}0/.shard/$gfid_f4.1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000100000000 $B0/${V0}0/.shard/$gfid_f4.1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000100000000 $B0/${V0}1/.shard/$gfid_f4.1
+TEST setfattr -n trusted.afr.$V0-client-2 -v 0x000000010000000100000000 $B0/${V0}1/.shard/$gfid_f4.1
+TEST setfattr -n trusted.afr.$V0-client-0 -v 0x000000010000000100000000 $B0/${V0}2/.shard/$gfid_f4.1
+TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000010000000100000000 $B0/${V0}2/.shard/$gfid_f4.1
+
+#-------------------------------------------------------------------------------
+#Add entry to xattrop dir on first brick and check for split-brain.
+xattrop_dir0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_dir0`
+
+gfid_f1=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/file1))
+TEST ln  $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_f1
+
+gfid_f2_shard1=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/.shard/$gfid_f2.1))
+TEST ln  $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_f2_shard1
+
+gfid_f3=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/${V0}0/file3))
+gfid_f3_shard1=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/.shard/$gfid_f3.1))
+TEST ln $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_f3_shard1
+
+gfid_f4_shard1=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/.shard/$gfid_f4.1))
+TEST ln  $xattrop_dir0/$base_entry_b0 $xattrop_dir0/$gfid_f4_shard1
+
+#-------------------------------------------------------------------------------
+#gfid split-brain won't show up in split-brain count.
+EXPECT "3" afr_get_split_brain_count $V0
+EXPECT_NOT "^0$" get_pending_heal_count $V0
+
+#Resolve split-brains
+TEST $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 /file1
+GFIDSTR="gfid:$gfid_f2_shard1"
+TEST $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 $GFIDSTR
+TEST $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 /.shard/$gfid_f3.1
+TEST $CLI volume heal $V0 split-brain source-brick $H0:$B0/${V0}1 /.shard/$gfid_f4.1
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+cleanup;
diff --git a/tests/bugs/replicate/bug-1761531-metadata-heal-restore-time.t b/tests/bugs/replicate/bug-1761531-metadata-heal-restore-time.t
new file mode 100644
index 00000000000..7e24eaec03d
--- /dev/null
+++ b/tests/bugs/replicate/bug-1761531-metadata-heal-restore-time.t
@@ -0,0 +1,74 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../afr.rc
+cleanup
+
+GET_MDATA_PATH=$(dirname $0)/../../utils
+build_tester $GET_MDATA_PATH/get-mdata-xattr.c
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0..2}
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+
+TEST touch $M0/a
+sleep 1
+TEST kill_brick $V0 $H0 $B0/brick0
+TEST touch $M0/a
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+mtime0=$(get_mtime $B0/brick0/a)
+mtime1=$(get_mtime $B0/brick1/a)
+TEST [ $mtime0 -eq $mtime1 ]
+
+ctime0=$(get_ctime $B0/brick0/a)
+ctime1=$(get_ctime $B0/brick1/a)
+TEST [ $ctime0 -eq $ctime1 ]
+
+###############################################################################
+# Repeat the test with ctime feature disabled.
+TEST $CLI volume set $V0 features.ctime off
+
+TEST touch $M0/b
+sleep 1
+TEST kill_brick $V0 $H0 $B0/brick0
+TEST touch $M0/b
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^2$" get_pending_heal_count $V0
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+mtime2=$(get_mtime $B0/brick0/b)
+mtime3=$(get_mtime $B0/brick1/b)
+TEST [ $mtime2 -eq $mtime3 ]
+
+TEST rm $GET_MDATA_PATH/get-mdata-xattr
+
+TEST force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/replicate/bug-1801624-entry-heal.t b/tests/bugs/replicate/bug-1801624-entry-heal.t
new file mode 100644
index 00000000000..94b465181fa
--- /dev/null
+++ b/tests/bugs/replicate/bug-1801624-entry-heal.t
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/brick{0,1,2}
+TEST $CLI volume set $V0 heal-timeout 5
+TEST $CLI volume start $V0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0 granular-entry-heal enable
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+echo "Data">$M0/FILE
+ret=$?
+TEST [ $ret -eq 0 ]
+
+# Re-create the file when a brick is down.
+TEST kill_brick $V0 $H0 $B0/brick1
+TEST rm $M0/FILE
+echo "New Data">$M0/FILE
+ret=$?
+TEST [ $ret -eq 0 ]
+EXPECT_WITHIN $HEAL_TIMEOUT "4" get_pending_heal_count $V0
+
+# Launching index heal must not reset parent dir afr xattrs or remove granular entry indices.
+$CLI volume heal $V0 # CLI will fail but heal is launched anyway.
+TEST sleep 5 # give index heal a chance to do one run.
+brick0_pending=$(get_hex_xattr trusted.afr.$V0-client-1 $B0/brick0/)
+brick2_pending=$(get_hex_xattr trusted.afr.$V0-client-1 $B0/brick2/)
+TEST [ $brick0_pending -eq "000000000000000000000002" ]
+TEST [ $brick2_pending -eq "000000000000000000000002" ]
+EXPECT "FILE" ls $B0/brick0/.glusterfs/indices/entry-changes/00000000-0000-0000-0000-000000000001/
+EXPECT "FILE" ls $B0/brick2/.glusterfs/indices/entry-changes/00000000-0000-0000-0000-000000000001/
+
+TEST $CLI volume start $V0 force
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+$CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "0" get_pending_heal_count $V0
+
+# No gfid-split-brain (i.e. EIO) must be seen. Try on fresh mount to avoid cached values.
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+TEST cat $M0/FILE
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+cleanup;
diff --git a/tests/bugs/replicate/bug-802417.t b/tests/bugs/replicate/bug-802417.t
index c5ba98b65fd..f213439401e 100755
--- a/tests/bugs/replicate/bug-802417.t
+++ b/tests/bugs/replicate/bug-802417.t
@@ -10,6 +10,18 @@ function write_file()
 }
 
 cleanup;
+
+#####################################################
+# We are currently not triggering data heal unless all bricks of the replica are
+# up. We will need to modify this .t once the fix for preventing stale reads
+# being served to clients for files in spurious split-brains is done. Spurious
+# split-brains here means afr xattrs indicates sbrain but it is actually not.
+# Self-heal will heal such files automatically but before the heal completes,
+# reads can be served which needs fixing.
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
+######################################################
+
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
diff --git a/tests/bugs/replicate/bug-830665.t b/tests/bugs/replicate/bug-830665.t
index d044dae75ea..68180424803 100755
--- a/tests/bugs/replicate/bug-830665.t
+++ b/tests/bugs/replicate/bug-830665.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 function recreate {
@@ -77,9 +79,8 @@ volid=$(getfattr -e hex -n trusted.glusterfs.volume-id $B0/${V0}-0 2> /dev/null
 rm -rf $B0/${V0}-0;
 mkdir $B0/${V0}-0;
 #Ideally, disk replacement is done using reset-brick or replace-brick gluster CLI
-#which will create .glusterfs/indices folder.
+#which will create .glusterfs folder.
 mkdir $B0/${V0}-0/.glusterfs && chmod 600 $B0/${V0}-0/.glusterfs
-mkdir $B0/${V0}-0/.glusterfs/indices && chmod 600 $B0/${V0}-0/.glusterfs/indices
 
 setfattr -n trusted.glusterfs.volume-id -v $volid $B0/${V0}-0
 
diff --git a/tests/bugs/replicate/bug-880898.t b/tests/bugs/replicate/bug-880898.t
index 123e7e16425..660d34ca25f 100644
--- a/tests/bugs/replicate/bug-880898.t
+++ b/tests/bugs/replicate/bug-880898.t
@@ -1,12 +1,19 @@
 #!/bin/bash
 
 . $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
 
 cleanup;
 
 TEST glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/brick1 $H0:$B0/brick2
 TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/brick2
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
 pkill glusterfs
 uuid=""
 for line in $(cat $GLUSTERD_WORKDIR/glusterd.info)
diff --git a/tests/bugs/replicate/bug-913051.t b/tests/bugs/replicate/bug-913051.t
index 43d1330b138..6794995e6fe 100644
--- a/tests/bugs/replicate/bug-913051.t
+++ b/tests/bugs/replicate/bug-913051.t
@@ -37,17 +37,6 @@ TEST fd_open $rfd "r" $M0/dir/b
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0
 
-#check that the files are not opned on brick-0
-TEST stat $M0/dir/a
-realpatha=$(gf_get_gfid_backend_file_path $B0/${V0}0 "dir/a")
-EXPECT "N" gf_check_file_opened_in_brick $V0 $H0 $B0/${V0}0 "$realpatha"
-EXPECT "N" gf_check_file_opened_in_brick $V0 $H0 $B0/${V0}0 $B0/${V0}0/dir/a
-
-TEST stat $M0/dir/b
-realpathb=$(gf_get_gfid_backend_file_path $B0/${V0}0 "dir/b")
-EXPECT "N" gf_check_file_opened_in_brick $V0 $H0 $B0/${V0}0 "$realpathb"
-EXPECT "N" gf_check_file_opened_in_brick $V0 $H0 $B0/${V0}0 $B0/${V0}0/dir/b
-
 #attempt self-heal so that the files are created on brick-0
 
 TEST dd if=$M0/dir/a of=/dev/null bs=1024k
diff --git a/tests/bugs/replicate/bug-966018.t b/tests/bugs/replicate/bug-966018.t
deleted file mode 100644
index 1b5296b498b..00000000000
--- a/tests/bugs/replicate/bug-966018.t
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../nfs.rc
-
-#This tests if cluster.eager-lock blocks metadata operations on nfs/fuse mounts.
-#If it is not woken up, INODELK from the next command waits
-#for post-op-delay secs.
-
-cleanup;
-TEST glusterd
-TEST pidof glusterd
-
-TEST $CLI volume create $V0 replica 2 $H0:$B0/r2_0 $H0:$B0/r2_1
-TEST $CLI volume set $V0 ensure-durability off
-TEST $CLI volume set $V0 cluster.eager-lock on
-TEST $CLI volume set $V0 cluster.post-op-delay-secs 3
-TEST $CLI volume set $V0 nfs.disable false
-
-TEST $CLI volume start $V0
-TEST $CLI volume profile $V0 start
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
-TEST mount_nfs $H0:/$V0 $N0 nolock;
-TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0
-echo 1 > $N0/1 && chmod +x $N0/1
-echo 1 > $M0/1 && chmod +x $M0/1
-
-#Check that INODELK MAX latency is not in the order of seconds
-#Test if the MAX INODELK fop latency is of the order of seconds.
-inodelk_max_latency=$($CLI volume profile $V0 info | grep INODELK | awk 'BEGIN {max = 0} {if ($6 > max) max=$6;} END {print max}' | cut -d. -f 1 | egrep "[0-9]{7,}")
-
-TEST [ -z $inodelk_max_latency ]
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
-
-cleanup;
diff --git a/tests/bugs/replicate/bug-977797.t b/tests/bugs/replicate/bug-977797.t
index ea9a98adc23..9a8f36c956c 100755
--- a/tests/bugs/replicate/bug-977797.t
+++ b/tests/bugs/replicate/bug-977797.t
@@ -26,8 +26,11 @@ TEST $CLI volume set $V0 quick-read off
 TEST $CLI volume set $V0 read-ahead off
 TEST $CLI volume set $V0 write-behind off
 TEST $CLI volume set $V0 io-cache off
+TEST $CLI volume set $V0 cluster.data-self-heal on
+TEST $CLI volume set $V0 cluster.metadata-self-heal on
+TEST $CLI volume set $V0 cluster.entry-self-heal on
 
-TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 
 
 TEST mkdir -p $M0/a
@@ -53,6 +56,8 @@ TEST chmod 757 $M0/a/file
 TEST $CLI volume start $V0 force
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1;
 
+#Trigger entry heal of $M0/a
+getfattr -n user.nosuchattr $M0/a
 dd if=$M0/a/file of=/dev/null bs=1024k
 #read fails, but heal is triggered.
 TEST [ $? -ne 0 ]
@@ -72,7 +77,7 @@ afr_get_specific_changelog_xattr $B0/$V0"2"/a/file trusted.afr.$V0-client-1 "dat
 EXPECT_WITHIN $HEAL_TIMEOUT "00000000" \
 afr_get_specific_changelog_xattr $B0/$V0"1"/a trusted.afr.$V0-client-0 "entry"
 
-EXPECT_WITHIN HEAL_TIMEOUT "00000000" \
+EXPECT_WITHIN $HEAL_TIMEOUT "00000000" \
 afr_get_specific_changelog_xattr $B0/$V0"1"/a trusted.afr.$V0-client-1 "entry"
 
 EXPECT_WITHIN $HEAL_TIMEOUT "00000000" \
diff --git a/tests/bugs/replicate/issue-1254-prioritize-enospc.t b/tests/bugs/replicate/issue-1254-prioritize-enospc.t
new file mode 100644
index 00000000000..fab94b71b27
--- /dev/null
+++ b/tests/bugs/replicate/issue-1254-prioritize-enospc.t
@@ -0,0 +1,80 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+function create_bricks {
+    TEST truncate -s 100M $B0/brick0
+    TEST truncate -s 100M $B0/brick1
+    TEST truncate -s 20M $B0/brick2
+    LO1=`SETUP_LOOP $B0/brick0`
+    TEST [ $? -eq 0 ]
+    TEST MKFS_LOOP $LO1
+    LO2=`SETUP_LOOP $B0/brick1`
+    TEST [ $? -eq 0 ]
+    TEST MKFS_LOOP $LO2
+    LO3=`SETUP_LOOP $B0/brick2`
+    TEST [ $? -eq 0 ]
+    TEST MKFS_LOOP $LO3
+    TEST mkdir -p $B0/${V0}0 $B0/${V0}1 $B0/${V0}2
+    TEST MOUNT_LOOP $LO1 $B0/${V0}0
+    TEST MOUNT_LOOP $LO2 $B0/${V0}1
+    TEST MOUNT_LOOP $LO3 $B0/${V0}2
+}
+
+function create_files {
+        local i=1
+        while (true)
+        do
+                touch $M0/file$i
+                if [ -e $B0/${V0}2/file$i ];
+                then
+                        ((i++))
+                else
+                        break
+                fi
+        done
+}
+
+TESTS_EXPECTED_IN_LOOP=13
+
+#Arbiter volume: Check for ENOSPC when arbiter brick becomes full#
+TEST glusterd
+create_bricks
+TEST $CLI volume create $V0 replica 3 arbiter 1 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+
+create_files
+TEST kill_brick $V0 $H0 $B0/${V0}1
+error1=$(touch $M0/file-1 2>&1)
+EXPECT "No space left on device" echo $error1
+error2=$(mkdir $M0/dir-1 2>&1)
+EXPECT "No space left on device" echo $error2
+error3=$((echo "Test" > $M0/file-3) 2>&1)
+EXPECT "No space left on device" echo $error3
+
+cleanup
+
+#Replica-3 volume: Check for ENOSPC when one of the brick becomes full#
+#Keeping the third brick of lower size to simulate disk full scenario#
+TEST glusterd
+create_bricks
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+
+create_files
+TEST kill_brick $V0 $H0 $B0/${V0}1
+error1=$(touch $M0/file-1 2>&1)
+EXPECT "No space left on device" echo $error1
+error2=$(mkdir $M0/dir-1 2>&1)
+EXPECT "No space left on device" echo $error2
+error3=$((cat /dev/zero > $M0/file1) 2>&1)
+EXPECT "No space left on device" echo $error3
+
+cleanup
diff --git a/tests/bugs/replicate/mdata-heal-no-xattrs.t b/tests/bugs/replicate/mdata-heal-no-xattrs.t
new file mode 100644
index 00000000000..d3b0c504c80
--- /dev/null
+++ b/tests/bugs/replicate/mdata-heal-no-xattrs.t
@@ -0,0 +1,59 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2};
+TEST $CLI volume set $V0 cluster.self-heal-daemon off
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" afr_child_up_status $V0 2
+echo "Data">$M0/FILE
+ret=$?
+TEST [ $ret -eq 0 ]
+
+# Change permission on brick-0: simulates the case where there is metadata
+# mismatch but no pending xattrs. This brick will become the source for heal.
+TEST chmod +x $B0/$V0"0"/FILE
+
+# Add gfid to xattrop
+xattrop_b0=$(afr_get_index_path $B0/$V0"0")
+base_entry_b0=`ls $xattrop_b0`
+gfid_str_FILE=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $B0/$V0"0"/FILE))
+TEST ln $xattrop_b0/$base_entry_b0 $xattrop_b0/$gfid_str_FILE
+EXPECT_WITHIN $HEAL_TIMEOUT "^1$" get_pending_heal_count $V0
+
+TEST $CLI volume set $V0 cluster.self-heal-daemon on
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 0
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 1
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_shd $V0 2
+TEST $CLI volume heal $V0
+EXPECT_WITHIN $HEAL_TIMEOUT "^0$" get_pending_heal_count $V0
+
+# Brick-0 should contain xattrs blaming other 2 bricks.
+# The values will be zero because heal is over.
+EXPECT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-1 $B0/${V0}0/FILE
+EXPECT "000000000000000000000000" get_hex_xattr trusted.afr.$V0-client-2 $B0/${V0}0/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-0 $B0/${V0}0/FILE
+
+# Brick-1 and Brick-2 must not contain any afr xattrs.
+TEST ! getfattr -n trusted.afr.$V0-client-0 $B0/${V0}1/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-1 $B0/${V0}1/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-2 $B0/${V0}1/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-0 $B0/${V0}2/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-1 $B0/${V0}2/FILE
+TEST ! getfattr -n trusted.afr.$V0-client-2 $B0/${V0}2/FILE
+
+# check permission bits.
+EXPECT '755' stat -c %a $B0/${V0}0/FILE
+EXPECT '755' stat -c %a $B0/${V0}1/FILE
+EXPECT '755' stat -c %a $B0/${V0}2/FILE
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+cleanup;
diff --git a/tests/bugs/replicate/ta-inode-refresh-read.t b/tests/bugs/replicate/ta-inode-refresh-read.t
new file mode 100644
index 00000000000..6dd6ff7f163
--- /dev/null
+++ b/tests/bugs/replicate/ta-inode-refresh-read.t
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Test read transaction inode refresh logic for thin-arbiter.
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../thin-arbiter.rc
+cleanup;
+TEST ta_create_brick_and_volfile brick0
+TEST ta_create_brick_and_volfile brick1
+TEST ta_create_ta_and_volfile ta
+TEST ta_start_brick_process brick0
+TEST ta_start_brick_process brick1
+TEST ta_start_ta_process ta
+
+TEST ta_create_mount_volfile brick0 brick1 ta
+# Set afr xlator options to choose brick0 as read-subvol.
+sed -i '/iam-self-heal-daemon/a \     option read-subvolume-index 0' $B0/mount.vol
+TEST [ $? -eq 0 ]
+sed -i '/iam-self-heal-daemon/a \     option choose-local false' $B0/mount.vol
+TEST [ $? -eq 0 ]
+
+TEST ta_start_mount_process $M0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" ta_up_status $V0 $M0 0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "trusted.afr.patchy-ta-2" ls $B0/ta
+
+TEST touch $M0/FILE
+TEST ls $B0/brick0/FILE
+TEST ls $B0/brick1/FILE
+TEST ! ls $B0/ta/FILE
+TEST setfattr -n user.name -v ravi $M0/FILE
+
+# Remove gfid hardlink from brick0 which is the read-subvol for FILE.
+# This triggers inode refresh up on a getfattr and eventually calls
+# afr_ta_read_txn(). Without this patch, afr_ta_read_txn() will again query
+# brick0 causing getfattr to fail.
+TEST rm -f $(gf_get_gfid_backend_file_path $B0/brick0 FILE)
+TEST getfattr -n user.name $M0/FILE
+
+cleanup;
diff --git a/tests/bugs/rpc/bug-1043886.t b/tests/bugs/rpc/bug-1043886.t
index b18680289ae..c1ea7a71e8b 100755
--- a/tests/bugs/rpc/bug-1043886.t
+++ b/tests/bugs/rpc/bug-1043886.t
@@ -3,6 +3,8 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 TEST glusterd
diff --git a/tests/bugs/rpc/bug-847624.t b/tests/bugs/rpc/bug-847624.t
index 31a63b56a34..fe8fc982887 100755
--- a/tests/bugs/rpc/bug-847624.t
+++ b/tests/bugs/rpc/bug-847624.t
@@ -3,6 +3,9 @@
 . $(dirname $0)/../../include.rc
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
+
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup
 
 #1
diff --git a/tests/bugs/rpc/bug-921072.t b/tests/bugs/rpc/bug-921072.t
index 458996b57bf..ae7eb0101bc 100755
--- a/tests/bugs/rpc/bug-921072.t
+++ b/tests/bugs/rpc/bug-921072.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 #1
diff --git a/tests/bugs/rpc/bug-954057.t b/tests/bugs/rpc/bug-954057.t
index 65af274f09d..40acdc2fdc7 100755
--- a/tests/bugs/rpc/bug-954057.t
+++ b/tests/bugs/rpc/bug-954057.t
@@ -25,7 +25,15 @@ TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
 
 TEST mkdir $M0/dir
 TEST mkdir $M0/nobody
-TEST chown nfsnobody:nfsnobody $M0/nobody
+grep nfsnobody /etc/passwd > /dev/null
+if [ $? -eq 1 ]; then
+usr=nobody
+grp=nobody
+else
+usr=nfsnobody
+grp=nfsnobody
+fi
+TEST chown $usr:$grp $M0/nobody
 TEST `echo "file" >> $M0/file`
 TEST cp $M0/file $M0/new
 TEST chmod 700 $M0/new
diff --git a/tests/bugs/shard/bug-1245547.t b/tests/bugs/shard/bug-1245547.t
index c19b2a6a042..3c46785d10f 100644
--- a/tests/bugs/shard/bug-1245547.t
+++ b/tests/bugs/shard/bug-1245547.t
@@ -25,11 +25,11 @@ TEST touch $M0/bar
 TEST truncate -s 10G $M0/bar
 #Unlink on such a file should succeed.
 TEST unlink $M0/bar
-#
+
 #Create a file 'baz' with holes.
 TEST touch $M0/baz
 TEST truncate -s 10G $M0/baz
 #Rename with a sharded existing dest that has holes must succeed.
 TEST mv -f $M0/foo $M0/baz
 
-cleanup;
+cleanup
diff --git a/tests/bugs/shard/bug-1272986.t b/tests/bugs/shard/bug-1272986.t
index 762887051fa..66e896ad0c4 100644
--- a/tests/bugs/shard/bug-1272986.t
+++ b/tests/bugs/shard/bug-1272986.t
@@ -16,16 +16,16 @@ TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0
 TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M1
 
 # Write some data into a file, such that its size crosses the shard block size.
-TEST dd if=/dev/zero of=$M1/file bs=1M count=5 conv=notrunc
+TEST dd if=/dev/urandom of=$M1/file bs=1M count=5 conv=notrunc oflag=direct
 
 md5sum1_reader=$(md5sum $M0/file | awk '{print $1}')
 
 EXPECT "$md5sum1_reader" echo `md5sum $M1/file | awk '{print $1}'`
 
 # Append some more data into the file.
-TEST `echo "abcdefg" >> $M1/file`
+TEST dd if=/dev/urandom of=$M1/file bs=256k count=1 conv=notrunc oflag=direct
 
-md5sum2_reader=$(md5sum $M0/file | awk '{print $1}')
+md5sum2_reader=$(dd if=$M0/file iflag=direct bs=256k| md5sum | awk '{print $1}')
 
 # Test to see if the reader refreshes its cache correctly as part of the reads
 # triggered through md5sum. If it does, then the md5sum on the reader and writer
diff --git a/tests/bugs/shard/bug-1468483.t b/tests/bugs/shard/bug-1468483.t
new file mode 100644
index 00000000000..e462b8d54d5
--- /dev/null
+++ b/tests/bugs/shard/bug-1468483.t
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../common-utils.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 16MB
+TEST $CLI volume start $V0
+TEST $CLI volume profile $V0 start
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+TEST dd if=/dev/zero conv=fsync of=$M0/foo bs=1M count=100
+
+#This should ensure /.shard is created on the bricks.
+TEST stat $B0/${V0}0/.shard
+
+gfid_foo=$(get_gfid_string $M0/foo)
+
+TEST stat $B0/${V0}0/.shard/$gfid_foo.1
+TEST stat $B0/${V0}0/.shard/$gfid_foo.2
+TEST stat $B0/${V0}0/.shard/$gfid_foo.3
+TEST stat $B0/${V0}0/.shard/$gfid_foo.4
+TEST stat $B0/${V0}0/.shard/$gfid_foo.5
+TEST stat $B0/${V0}0/.shard/$gfid_foo.6
+
+# For a file with 7 shards, there should be 7 fsyncs on the brick. Without this
+# fix, I was seeing only 1 fsync (on the base shard alone).
+
+EXPECT "7" echo `$CLI volume profile $V0 info incremental | grep -w FSYNC | awk '{print $8}'`
+
+useradd -M test_user 2>/dev/null
+
+TEST touch $M0/bar
+
+# Change ownership to non-root on bar.
+TEST chown test_user:test_user $M0/bar
+
+TEST $CLI volume profile $V0 stop
+TEST $CLI volume profile $V0 start
+
+# Write 100M of data on bar as non-root.
+TEST run_cmd_as_user test_user "dd if=/dev/zero conv=fsync of=$M0/bar bs=1M count=100"
+
+EXPECT "7" echo `$CLI volume profile $V0 info incremental | grep -w FSYNC | awk '{print $8}'`
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+userdel test_user
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-1568521-EEXIST.t b/tests/bugs/shard/bug-1568521-EEXIST.t
new file mode 100644
index 00000000000..2f9f165aa63
--- /dev/null
+++ b/tests/bugs/shard/bug-1568521-EEXIST.t
@@ -0,0 +1,91 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+function get_file_count {
+    ls $1* | wc -l
+}
+
+FILE_COUNT_TIME=5
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume start $V0
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST mkdir $M0/dir
+# Unlink a temporary file to trigger creation of .remove_me
+TEST touch $M0/tmp
+TEST unlink $M0/tmp
+
+TEST stat $B0/${V0}0/.shard/.remove_me
+TEST stat $B0/${V0}1/.shard/.remove_me
+
+TEST dd if=/dev/zero of=$M0/dir/file bs=1024 count=9216
+gfid_file=$(get_gfid_string $M0/dir/file)
+
+# Create marker file from the backend to simulate ENODATA.
+touch $B0/${V0}0/.shard/.remove_me/$gfid_file
+touch $B0/${V0}1/.shard/.remove_me/$gfid_file
+
+# Set block and file size to incorrect values of 64MB and 5MB to simulate "stale xattrs" case
+# and confirm that the correct values are set when the actual unlink takes place
+
+TEST setfattr -n trusted.glusterfs.shard.block-size -v 0x0000000004000000 $B0/${V0}0/.shard/.remove_me/$gfid_file
+TEST setfattr -n trusted.glusterfs.shard.block-size -v 0x0000000004000000 $B0/${V0}1/.shard/.remove_me/$gfid_file
+
+TEST setfattr -n trusted.glusterfs.shard.file-size -v 0x0000000000500000000000000000000000000000000000000000000000000000 $B0/${V0}0/.shard/.remove_me/$gfid_file
+TEST setfattr -n trusted.glusterfs.shard.file-size -v 0x0000000000500000000000000000000000000000000000000000000000000000 $B0/${V0}1/.shard/.remove_me/$gfid_file
+
+# Sleep for 2 seconds to prevent posix_gfid_heal() from believing marker file is "fresh" and failing lookup with ENOENT
+sleep 2
+
+TEST unlink $M0/dir/file
+TEST ! stat $B0/${V0}0/dir/file
+TEST ! stat $B0/${V0}1/dir/file
+
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_file
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_file
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_file
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_file
+
+##############################
+### Repeat test for rename ###
+##############################
+
+TEST touch $M0/src
+TEST dd if=/dev/zero of=$M0/dir/dst bs=1024 count=9216
+gfid_dst=$(get_gfid_string $M0/dir/dst)
+
+# Create marker file from the backend to simulate ENODATA.
+touch $B0/${V0}0/.shard/.remove_me/$gfid_dst
+touch $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+# Set block and file size to incorrect values of 64MB and 5MB to simulate "stale xattrs" case
+# and confirm that the correct values are set when the actual unlink takes place
+
+TEST setfattr -n trusted.glusterfs.shard.block-size -v 0x0000000004000000 $B0/${V0}0/.shard/.remove_me/$gfid_dst
+TEST setfattr -n trusted.glusterfs.shard.block-size -v 0x0000000004000000 $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+TEST setfattr -n trusted.glusterfs.shard.file-size -v 0x0000000000500000000000000000000000000000000000000000000000000000 $B0/${V0}0/.shard/.remove_me/$gfid_dst
+TEST setfattr -n trusted.glusterfs.shard.file-size -v 0x0000000000500000000000000000000000000000000000000000000000000000 $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+# Sleep for 2 seconds to prevent posix_gfid_heal() from believing marker file is "fresh" and failing lookup with ENOENT
+sleep 2
+
+TEST mv -f $M0/src $M0/dir/dst
+TEST ! stat $B0/${V0}0/src
+TEST ! stat $B0/${V0}1/src
+
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_dst
+
+cleanup
diff --git a/tests/bugs/shard/bug-1568521.t b/tests/bugs/shard/bug-1568521.t
new file mode 100644
index 00000000000..167fb635ac8
--- /dev/null
+++ b/tests/bugs/shard/bug-1568521.t
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+
+
+function delete_files {
+        local mountpoint=$1;
+        local success=0;
+        local value=$2
+        for i in {1..500}; do
+                unlink $mountpoint/file-$i 2>/dev/null 1>/dev/null
+                if [ $? -eq 0 ]; then
+                        echo $2 >> $B0/output.txt
+                fi
+        done
+        echo $success
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 shard-block-size 4MB
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M1
+
+for i in {1..500}; do
+        dd if=/dev/urandom of=$M0/file-$i bs=1M count=2
+done
+
+for i in {1..500}; do
+        stat $M1/file-$i > /dev/null
+done
+
+delete_files $M0 0 &
+delete_files $M1 1 &
+wait
+
+success1=$(grep 0 $B0/output.txt | wc -l);
+success2=$(grep 1 $B0/output.txt | wc -l);
+
+echo "Success1 is $success1";
+echo "Success2 is $success2";
+
+success_total=$((success1 + success2));
+
+EXPECT 500 echo $success_total
+
+cleanup
diff --git a/tests/bugs/shard/bug-1605056-2.t b/tests/bugs/shard/bug-1605056-2.t
new file mode 100644
index 00000000000..a9c10fec3ea
--- /dev/null
+++ b/tests/bugs/shard/bug-1605056-2.t
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 25
+TEST $CLI volume set $V0 performance.write-behind off
+
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+# Perform a write that would cause 25 shards to be created under .shard
+TEST dd if=/dev/zero of=$M0/foo bs=1M count=104
+
+# Write into another file bar to ensure all of foo's shards are evicted from lru list of $M0
+TEST dd if=/dev/zero of=$M0/bar bs=1M count=104
+
+# Delete foo from $M0. If there's a bug, the mount will crash.
+TEST unlink $M0/foo
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-1605056.t b/tests/bugs/shard/bug-1605056.t
new file mode 100644
index 00000000000..c2329ea79f8
--- /dev/null
+++ b/tests/bugs/shard/bug-1605056.t
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+SHARD_COUNT_TIME=5
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 25
+TEST $CLI volume set $V0 performance.write-behind off
+
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M1
+
+# Perform a write that would cause 25 shards to be created under .shard
+TEST dd if=/dev/zero of=$M0/foo bs=1M count=104
+
+# Read the file from $M1, indirectly filling up the lru list.
+TEST `cat $M1/foo > /dev/null`
+statedump=$(generate_mount_statedump $V0 $M1)
+sleep 1
+EXPECT "25" echo $(grep "inode-count" $statedump | cut -f2 -d'=' | tail -1)
+rm -f $statedump
+
+# Delete foo from $M0.
+TEST unlink $M0/foo
+
+# Send stat on foo from $M1 to force $M1 to "forget" inode associated with foo.
+# Now the ghost shards associated with "foo" are still in lru list of $M1.
+TEST ! stat $M1/foo
+
+# Let's force the ghost shards of "foo" out of lru list by looking up more shards
+# through I/O on a file named "bar" from $M1. This should crash if the base inode
+# had been destroyed by now.
+
+TEST dd if=/dev/zero of=$M1/bar bs=1M count=104
+
+###############################################
+#### Now for some inode ref-leak tests ... ####
+###############################################
+
+# Expect there to be 29 active inodes - 26 belonging to "bar", 1 for .shard,
+# 1 for .shard/remove_me and 1 for '/'
+EXPECT_WITHIN $SHARD_COUNT_TIME `expr 26 + 3` get_mount_active_size_value $V0 $M1
+
+TEST rm -f $M1/bar
+EXPECT_WITHIN $SHARD_COUNT_TIME 3 get_mount_active_size_value $V0 $M1
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-1669077.t b/tests/bugs/shard/bug-1669077.t
new file mode 100644
index 00000000000..8d3a67a36be
--- /dev/null
+++ b/tests/bugs/shard/bug-1669077.t
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+SHARD_COUNT_TIME=5
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 25
+
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+# If the bug still exists, client should crash during fallocate below
+TEST fallocate -l 200M $M0/foo
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-1696136-lru-limit-equals-deletion-rate.t b/tests/bugs/shard/bug-1696136-lru-limit-equals-deletion-rate.t
new file mode 100644
index 00000000000..3e4a65af19a
--- /dev/null
+++ b/tests/bugs/shard/bug-1696136-lru-limit-equals-deletion-rate.t
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fallocate.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 120
+TEST $CLI volume set $V0 features.shard-deletion-rate 120
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST build_tester $(dirname $0)/bug-1696136.c -lgfapi -Wall -O2
+
+# Create a file
+TEST touch $M0/file1
+
+# Fallocate a 500M file. This will make sure number of participant shards are > lru-limit
+TEST $(dirname $0)/bug-1696136 $H0 $V0 "0" "0" "536870912" /file1 `gluster --print-logdir`/glfs-$V0.log
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+rm -f $(dirname $0)/bug-1696136
+
+cleanup
diff --git a/tests/bugs/shard/bug-1696136.c b/tests/bugs/shard/bug-1696136.c
new file mode 100644
index 00000000000..cb650535b09
--- /dev/null
+++ b/tests/bugs/shard/bug-1696136.c
@@ -0,0 +1,122 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+
+enum fallocate_flag {
+    TEST_FALLOCATE_NONE,
+    TEST_FALLOCATE_KEEP_SIZE,
+    TEST_FALLOCATE_ZERO_RANGE,
+    TEST_FALLOCATE_PUNCH_HOLE,
+    TEST_FALLOCATE_MAX,
+};
+
+int
+get_fallocate_flag(int opcode)
+{
+    int ret = 0;
+
+    switch (opcode) {
+        case TEST_FALLOCATE_NONE:
+            ret = 0;
+            break;
+        case TEST_FALLOCATE_KEEP_SIZE:
+            ret = FALLOC_FL_KEEP_SIZE;
+            break;
+        case TEST_FALLOCATE_ZERO_RANGE:
+            ret = FALLOC_FL_ZERO_RANGE;
+            break;
+        case TEST_FALLOCATE_PUNCH_HOLE:
+            ret = FALLOC_FL_PUNCH_HOLE;
+            break;
+        default:
+            ret = -1;
+            break;
+    }
+    return ret;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 1;
+    int opcode = -1;
+    off_t offset = 0;
+    size_t len = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+
+    if (argc != 8) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <opcode> <offset> <len> "
+                "<file-path> <log-file>\n",
+                argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, argv[7], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    opcode = atoi(argv[3]);
+    opcode = get_fallocate_flag(opcode);
+    if (opcode < 0) {
+        fprintf(stderr, "get_fallocate_flag: invalid flag \n");
+        goto out;
+    }
+
+    /* Note that off_t is signed but size_t isn't. */
+    offset = strtol(argv[4], NULL, 10);
+    len = strtoul(argv[5], NULL, 10);
+
+    fd = glfs_open(fs, argv[6], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    ret = glfs_fallocate(fd, opcode, offset, len);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fallocate: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = glfs_unlink(fs, argv[6]);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_unlink: returned %d\n", ret);
+        goto out;
+    }
+    /* Sleep for 3s to give enough time for background deletion to complete
+     * during which if the bug exists, the process will crash.
+     */
+    sleep(3);
+    ret = 0;
+
+out:
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
+}
diff --git a/tests/bugs/shard/bug-1696136.t b/tests/bugs/shard/bug-1696136.t
new file mode 100644
index 00000000000..b6dc858f083
--- /dev/null
+++ b/tests/bugs/shard/bug-1696136.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fallocate.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 120
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST build_tester $(dirname $0)/bug-1696136.c -lgfapi -Wall -O2
+
+# Create a file
+TEST touch $M0/file1
+
+# Fallocate a 500M file. This will make sure number of participant shards are > lru-limit
+TEST $(dirname $0)/bug-1696136 $H0 $V0 "0" "0" "536870912" /file1 `gluster --print-logdir`/glfs-$V0.log
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+rm -f $(dirname $0)/bug-1696136
+
+cleanup
diff --git a/tests/bugs/shard/bug-1705884.t b/tests/bugs/shard/bug-1705884.t
new file mode 100644
index 00000000000..f6e50376a58
--- /dev/null
+++ b/tests/bugs/shard/bug-1705884.t
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../fallocate.rc
+
+cleanup
+
+require_fallocate -l 1m $M0/file
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST fallocate -l 200M $M0/foo
+EXPECT `echo "$(( ( 200 * 1024 * 1024 ) / 512 ))"`  stat -c %b $M0/foo
+TEST truncate -s 0 $M0/foo
+EXPECT "0" stat -c %b $M0/foo
+TEST fallocate -l 100M $M0/foo
+EXPECT `echo "$(( ( 100 * 1024 * 1024 ) / 512 ))"`  stat -c %b $M0/foo
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-1738419.t b/tests/bugs/shard/bug-1738419.t
new file mode 100644
index 00000000000..8d0a31d9754
--- /dev/null
+++ b/tests/bugs/shard/bug-1738419.t
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 network.remote-dio off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.strict-o-direct on
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST dd if=/dev/zero of=$M0/metadata bs=501 count=1
+
+EXPECT "501" echo $("dd" if=$M0/metadata bs=4096 count=1 of=/dev/null iflag=direct 2>&1 | awk '/bytes/ {print $1}')
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/bug-shard-discard.c b/tests/bugs/shard/bug-shard-discard.c
index 645bacf7d83..6fa93fb89d1 100644
--- a/tests/bugs/shard/bug-shard-discard.c
+++ b/tests/bugs/shard/bug-shard-discard.c
@@ -4,63 +4,67 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret = 0;
-        off_t      off = 0;
-        size_t     len = 0;
-        glfs_t    *fs  = NULL;
-        glfs_fd_t *fd  = NULL;
+    int ret = 0;
+    off_t off = 0;
+    size_t len = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
 
-        if (argc != 7) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 7) {
+        fprintf(
+            stderr,
+            "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n",
+            argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_set_logging (fs, argv[6], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_logging(fs, argv[6], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        off = atoi (argv[4]);
-        len = atoi (argv[5]);
+    /* Note that off_t is signed but size_t isn't. */
+    off = strtol(argv[4], NULL, 10);
+    len = strtoul(argv[5], NULL, 10);
 
-        ret = glfs_discard (fd, off, len);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_discard: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_discard(fd, off, len);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_discard: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close (fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/shard/bug-shard-discard.t b/tests/bugs/shard/bug-shard-discard.t
index 72d8586a2dc..910ade14801 100644
--- a/tests/bugs/shard/bug-shard-discard.t
+++ b/tests/bugs/shard/bug-shard-discard.t
@@ -5,6 +5,12 @@
 
 cleanup
 
+FILE_COUNT_TIME=5
+
+function get_shard_count {
+    ls $1/$2.* | wc -l
+}
+
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..3}
@@ -42,14 +48,11 @@ EXPECT_NOT "1" file_all_zeroes `find $B0 -name $gfid_foo.1`
 
 # Now unlink the file. And ensure that all shards associated with the file are cleaned up
 TEST unlink $M0/foo
-TEST ! stat $B0/${V0}0/.shard/$gfid_foo.1
-TEST ! stat $B0/${V0}1/.shard/$gfid_foo.1
-TEST ! stat $B0/${V0}2/.shard/$gfid_foo.1
-TEST ! stat $B0/${V0}3/.shard/$gfid_foo.1
-TEST ! stat $B0/${V0}0/.shard/$gfid_foo.2
-TEST ! stat $B0/${V0}1/.shard/$gfid_foo.2
-TEST ! stat $B0/${V0}2/.shard/$gfid_foo.2
-TEST ! stat $B0/${V0}3/.shard/$gfid_foo.2
+
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_shard_count $B0/${V0}0/.shard $gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_shard_count $B0/${V0}1/.shard $gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_shard_count $B0/${V0}2/.shard $gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_shard_count $B0/${V0}3/.shard $gfid_foo
 TEST ! stat $M0/foo
 
 #clean up everything
diff --git a/tests/bugs/shard/bug-shard-zerofill.c b/tests/bugs/shard/bug-shard-zerofill.c
index 838a656b3bb..ed4c8c54dc2 100644
--- a/tests/bugs/shard/bug-shard-zerofill.c
+++ b/tests/bugs/shard/bug-shard-zerofill.c
@@ -3,57 +3,58 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-
-        if (argc != 5) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, argv[4], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-
-        /* Zero-fill "foo" with 10MB of data */
-        ret = glfs_zerofill (fd, 0, 10485760);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_zerofill: returned %d\n", ret);
-                goto out;
-        }
-
-        ret = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+
+    if (argc != 5) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n",
+                argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, argv[4], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    /* Zero-fill "foo" with 10MB of data */
+    ret = glfs_zerofill(fd, 0, 10485760);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_zerofill: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/shard/configure-lru-limit.t b/tests/bugs/shard/configure-lru-limit.t
new file mode 100644
index 00000000000..923a4d8d747
--- /dev/null
+++ b/tests/bugs/shard/configure-lru-limit.t
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 features.shard-lru-limit 25
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status';
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}0
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}1
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" brick_up_status $V0 $H0 $B0/${V0}2
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+# Perform a write that would cause 25 shards to be created, 24 of them under .shard
+TEST dd if=/dev/zero of=$M0/foo bs=1M count=100
+
+statedump=$(generate_mount_statedump $V0)
+sleep 1
+EXPECT "25" echo $(grep "lru-max-limit" $statedump | cut -f2 -d'=' | tail -1)
+
+# Base shard is never added to this list. So all other shards should make up for 24 inodes in lru list
+EXPECT "24" echo $(grep "inode-count" $statedump | cut -f2 -d'=' | tail -1)
+
+rm -f $statedump
+
+# Test to ensure there's no "reconfiguration" of the value once set.
+TEST $CLI volume set $V0 features.shard-lru-limit 30
+statedump=$(generate_mount_statedump $V0)
+sleep 1
+EXPECT "25" echo $(grep "lru-max-limit" $statedump | cut -f2 -d'=' | tail -1)
+rm -f $statedump
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+statedump=$(generate_mount_statedump $V0)
+sleep 1
+EXPECT "30" echo $(grep "lru-max-limit" $statedump | cut -f2 -d'=' | tail -1)
+rm -f $statedump
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/issue-1243.t b/tests/bugs/shard/issue-1243.t
new file mode 100644
index 00000000000..ba22d2b74fe
--- /dev/null
+++ b/tests/bugs/shard/issue-1243.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.strict-o-direct on
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST $CLI volume set $V0 md-cache-timeout 10
+
+# Write data into a file such that its size crosses shard-block-size
+TEST dd if=/dev/zero of=$M0/foo bs=1048576 count=8 oflag=direct
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+# Execute a setxattr on the file.
+TEST setfattr -n trusted.libvirt -v some-value $M0/foo
+
+# Size of the file should be the aggregated size, not the shard-block-size
+EXPECT '8388608' stat -c %s $M0/foo
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+# Execute a removexattr on the file.
+TEST setfattr -x trusted.libvirt $M0/foo
+
+# Size of the file should be the aggregated size, not the shard-block-size
+EXPECT '8388608' stat -c %s $M0/foo
+cleanup
diff --git a/tests/bugs/shard/issue-1281.t b/tests/bugs/shard/issue-1281.t
new file mode 100644
index 00000000000..9704caa8944
--- /dev/null
+++ b/tests/bugs/shard/issue-1281.t
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 performance.quick-read off
+TEST $CLI volume set $V0 performance.io-cache off
+TEST $CLI volume set $V0 performance.read-ahead off
+TEST $CLI volume set $V0 performance.write-behind off
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+#Open a file and store descriptor in fd = 5
+exec 5>$M0/foo
+
+#Unlink the same file which is opened in prev step
+TEST unlink $M0/foo
+
+#Write something on the file using the open fd = 5
+echo "issue-1281" >&5
+
+#Write on the descriptor should be succesful
+EXPECT 0 echo $?
+
+#Close the fd = 5
+exec 5>&-
+
+cleanup
diff --git a/tests/bugs/shard/issue-1425.t b/tests/bugs/shard/issue-1425.t
new file mode 100644
index 00000000000..bbe82c0e5b2
--- /dev/null
+++ b/tests/bugs/shard/issue-1425.t
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+FILE_COUNT_TIME=5
+
+function get_file_count {
+    ls $1* | wc -l
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume start $V0
+TEST $CLI volume profile $V0 start
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST fallocate -l 20M $M0/foo
+gfid_new=$(get_gfid_string $M0/foo)
+
+# Check for the base shard
+TEST stat $M0/foo
+TEST stat $B0/${V0}0/foo
+
+# There should be 4 associated shards
+EXPECT_WITHIN $FILE_COUNT_TIME 4 get_file_count $B0/${V0}0/.shard/$gfid_new
+
+# There should be 1+4 shards and we expect 4 lookups less than on the build without this patch
+EXPECT "21" echo `$CLI volume profile $V0 info incremental | grep -w LOOKUP | awk '{print $8}'`
+
+# Delete the base shard and check shards get cleaned up
+TEST unlink $M0/foo
+
+TEST ! stat $M0/foo
+TEST ! stat $B0/${V0}0/foo
+
+# There should be no shards now
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_new
+cleanup
diff --git a/tests/bugs/shard/shard-append-test.c b/tests/bugs/shard/shard-append-test.c
index 92dff3d078d..c7debb2b182 100644
--- a/tests/bugs/shard/shard-append-test.c
+++ b/tests/bugs/shard/shard-append-test.c
@@ -10,9 +10,10 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 /*This test tests that shard xlator handles offset in appending writes
  * correctly. This test performs writes of 1025 bytes 1025 times, in 5 threads
@@ -26,154 +27,157 @@ pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 int thread_data = '1';
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
+    int ret = -1;
+    glfs_t *fs = NULL;
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
-void*
-write_data (void *data)
+void *
+write_data(void *data)
 {
-        char           buf[1025] = {0};
-        glfs_fd_t      *glfd = NULL;
-        glfs_t         *fs       = data;
-        int            i     = 0;
-
-        pthread_mutex_lock (&lock);
-        {
-                memset(buf, thread_data, sizeof(buf));
-                thread_data++;
+    char buf[1025] = {0};
+    glfs_fd_t *glfd = NULL;
+    glfs_t *fs = data;
+    int i = 0;
+
+    pthread_mutex_lock(&lock);
+    {
+        memset(buf, thread_data, sizeof(buf));
+        thread_data++;
+    }
+    pthread_mutex_unlock(&lock);
+
+    for (i = 0; i < 1025; i++) {
+        glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND,
+                          S_IRUSR | S_IWUSR | O_SYNC);
+        if (!glfd) {
+            LOG_ERR("Failed to create file");
+            exit(1);
         }
-        pthread_mutex_unlock (&lock);
-
-        for (i = 0; i < 1025; i++) {
-                glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND,
-                                   S_IRUSR | S_IWUSR | O_SYNC);
-                if (!glfd) {
-                        LOG_ERR ("Failed to create file");
-                        exit(1);
-                }
-
-                if (glfs_write (glfd, buf, sizeof(buf), 0) < 0) {
-                        LOG_ERR ("Failed to write to file");
-                        exit(1);
-                }
-                if (glfs_close(glfd) != 0) {
-                        LOG_ERR ("Failed to close file");
-                        exit(1);
-                }
+
+        if (glfs_write(glfd, buf, sizeof(buf), 0) < 0) {
+            LOG_ERR("Failed to write to file");
+            exit(1);
         }
-        return NULL;
+        if (glfs_close(glfd) != 0) {
+            LOG_ERR("Failed to close file");
+            exit(1);
+        }
+    }
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        pthread_t  tid[5] = {0};
-        char       buf[1025] = {0};
-        char       cmp_buf[1025] = {0};
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
-        glfs_fd_t  *glfd     = NULL;
-        ssize_t     bytes_read = 0;
-        ssize_t     total_bytes_read = 0;
-        int i = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        for (i = 0; i < 5; i++) {
-                pthread_create(&tid[i], NULL, write_data, fs);
-        }
-
-        for (i = 0; i < 5; i++) {
-                pthread_join(tid[i], NULL);
-        }
-        glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY);
-        if (!glfd) {
-                LOG_ERR ("Failed to open file for reading");
-                exit(1);
+    pthread_t tid[5] = {0};
+    char buf[1025] = {0};
+    char cmp_buf[1025] = {0};
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    ssize_t bytes_read = 0;
+    ssize_t total_bytes_read = 0;
+    int i = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    for (i = 0; i < 5; i++) {
+        pthread_create(&tid[i], NULL, write_data, fs);
+    }
+
+    for (i = 0; i < 5; i++) {
+        pthread_join(tid[i], NULL);
+    }
+    glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY);
+    if (!glfd) {
+        LOG_ERR("Failed to open file for reading");
+        exit(1);
+    }
+
+    while ((bytes_read = glfs_read(glfd, buf, sizeof(buf), 0)) > 0) {
+        if (bytes_read != sizeof(buf)) {
+            fprintf(stderr,
+                    "Didn't read complete data read: %zd "
+                    "expected: %lu",
+                    bytes_read, sizeof(buf));
+            exit(1);
         }
 
-        while ((bytes_read = glfs_read (glfd, buf, sizeof(buf), 0)) > 0) {
-                if (bytes_read != sizeof(buf)) {
-                        fprintf (stderr, "Didn't read complete data read: %zd "
-                                 "expected: %lu", bytes_read, sizeof(buf));
-                        exit(1);
-                }
-
-                total_bytes_read += bytes_read;
-                if (buf[0] < '1' || buf[0] >= thread_data) {
-                        fprintf(stderr, "Invalid character found: %c", buf[0]);
-                        exit(1);
-                }
-                memset(cmp_buf, buf[0], sizeof(cmp_buf));
-                if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) {
-                        LOG_ERR ("Data corrupted");
-                        exit(1);
-                }
-                memset(cmp_buf, 0, sizeof(cmp_buf));
+        total_bytes_read += bytes_read;
+        if (buf[0] < '1' || buf[0] >= thread_data) {
+            fprintf(stderr, "Invalid character found: %c", buf[0]);
+            exit(1);
         }
-
-        if (total_bytes_read != 5*1025*1025) {
-                fprintf(stderr, "Failed to read what is written, read; %zd, "
-                        "expected %zu", total_bytes_read, 5*1025*1025);
-                exit(1);
-        }
-
-        if (glfs_close(glfd) != 0) {
-                LOG_ERR ("Failed to close");
-                exit(1);
+        memset(cmp_buf, buf[0], sizeof(cmp_buf));
+        if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) {
+            LOG_ERR("Data corrupted");
+            exit(1);
         }
-        return 0;
+        memset(cmp_buf, 0, sizeof(cmp_buf));
+    }
+
+    if (total_bytes_read != 5 * 1025 * 1025) {
+        fprintf(stderr,
+                "Failed to read what is written, read; %zd, "
+                "expected %zu",
+                total_bytes_read, 5 * 1025 * 1025);
+        exit(1);
+    }
+
+    if (glfs_close(glfd) != 0) {
+        LOG_ERR("Failed to close");
+        exit(1);
+    }
+    return 0;
 }
diff --git a/tests/bugs/shard/shard-fallocate.c b/tests/bugs/shard/shard-fallocate.c
index e16620964c9..cb0714e8564 100644
--- a/tests/bugs/shard/shard-fallocate.c
+++ b/tests/bugs/shard/shard-fallocate.c
@@ -6,104 +6,108 @@
 #include <glusterfs/api/glfs-handles.h>
 
 enum fallocate_flag {
-        TEST_FALLOCATE_NONE,
-        TEST_FALLOCATE_KEEP_SIZE,
-        TEST_FALLOCATE_ZERO_RANGE,
-        TEST_FALLOCATE_PUNCH_HOLE,
-        TEST_FALLOCATE_MAX,
+    TEST_FALLOCATE_NONE,
+    TEST_FALLOCATE_KEEP_SIZE,
+    TEST_FALLOCATE_ZERO_RANGE,
+    TEST_FALLOCATE_PUNCH_HOLE,
+    TEST_FALLOCATE_MAX,
 };
 
 int
-get_fallocate_flag (int opcode)
+get_fallocate_flag(int opcode)
 {
-        int ret = 0;
+    int ret = 0;
 
-        switch (opcode) {
+    switch (opcode) {
         case TEST_FALLOCATE_NONE:
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case TEST_FALLOCATE_KEEP_SIZE:
-                ret = FALLOC_FL_KEEP_SIZE;
-                break;
+            ret = FALLOC_FL_KEEP_SIZE;
+            break;
         case TEST_FALLOCATE_ZERO_RANGE:
-                ret = FALLOC_FL_ZERO_RANGE;
-                break;
+            ret = FALLOC_FL_ZERO_RANGE;
+            break;
         case TEST_FALLOCATE_PUNCH_HOLE:
-                ret = FALLOC_FL_PUNCH_HOLE;
-                break;
+            ret = FALLOC_FL_PUNCH_HOLE;
+            break;
         default:
-                ret = -1;
-                break;
-        }
-        return ret;
+            ret = -1;
+            break;
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret = 1;
-        int        opcode = -1;
-        off_t      offset = 0;
-        size_t     len = 0;
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
+    int ret = 1;
+    int opcode = -1;
+    off_t offset = 0;
+    size_t len = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
 
-        if (argc != 8) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <opcode> <offset> <len> <file-path> <log-file>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 8) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <opcode> <offset> <len> "
+                "<file-path> <log-file>\n",
+                argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_set_logging (fs, argv[7], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_logging(fs, argv[7], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        opcode = atoi (argv[3]);
-        opcode = get_fallocate_flag (opcode);
-        if (opcode < 0) {
-                fprintf (stderr, "get_fallocate_flag: invalid flag \n");
-                goto out;
-        }
+    opcode = atoi(argv[3]);
+    opcode = get_fallocate_flag(opcode);
+    if (opcode < 0) {
+        fprintf(stderr, "get_fallocate_flag: invalid flag \n");
+        goto out;
+    }
 
-        offset = atoi (argv[4]);
-        len    = atoi (argv[5]);
+    /* Note that off_t is signed but size_t isn't. */
+    offset = strtol(argv[4], NULL, 10);
+    len = strtoul(argv[5], NULL, 10);
 
-        fd = glfs_open (fs, argv[6], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[6], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        ret = glfs_fallocate (fd, opcode, offset, len);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_fallocate: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_fallocate(fd, opcode, offset, len);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fallocate: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/shard/shard-inode-refcount-test.t b/tests/bugs/shard/shard-inode-refcount-test.t
new file mode 100644
index 00000000000..3fd181be690
--- /dev/null
+++ b/tests/bugs/shard/shard-inode-refcount-test.t
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup
+
+SHARD_COUNT_TIME=5
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}0
+TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
+TEST $CLI volume start $V0
+
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0
+
+TEST dd if=/dev/zero conv=fsync of=$M0/one-plus-five-shards bs=1M count=23
+
+ACTIVE_INODES_BEFORE=$(get_mount_active_size_value $V0)
+TEST rm -f $M0/one-plus-five-shards
+# Expect 5 inodes less. But one inode more than before because .remove_me would be created.
+EXPECT_WITHIN $SHARD_COUNT_TIME `expr $ACTIVE_INODES_BEFORE - 5 + 1` get_mount_active_size_value $V0 $M0
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/bugs/shard/unlinks-and-renames.t b/tests/bugs/shard/unlinks-and-renames.t
index a8f188b2d3a..990ca69a8b1 100644
--- a/tests/bugs/shard/unlinks-and-renames.t
+++ b/tests/bugs/shard/unlinks-and-renames.t
@@ -9,6 +9,12 @@ cleanup
 # and rename fops in sharding and make sure they work fine.
 #
 
+FILE_COUNT_TIME=5
+
+function get_file_count {
+    ls $1* | wc -l
+}
+
 #################################################
 ################### UNLINK ######################
 #################################################
@@ -25,18 +31,25 @@ TEST mkdir $M0/dir
 TEST touch $M0/dir/foo
 TEST touch $M0/dir/new
 
-######################################
-##### Unlink with /.shard absent #####
-######################################
+##########################################
+##### 01. Unlink with /.shard absent #####
+##########################################
+
 TEST truncate -s 5M $M0/dir/foo
 TEST ! stat $B0/${V0}0/.shard
 TEST ! stat $B0/${V0}1/.shard
 # Test to ensure that unlink doesn't fail due to absence of /.shard
+gfid_foo=$(get_gfid_string $M0/dir/foo)
 TEST unlink $M0/dir/foo
+TEST stat $B0/${V0}0/.shard/.remove_me
+TEST stat $B0/${V0}1/.shard/.remove_me
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_foo
+
+######################################################
+##### 02. Unlink of a sharded file without holes #####
+######################################################
 
-##################################################
-##### Unlink of a sharded file without holes #####
-##################################################
 # Create a 9M sharded file
 TEST dd if=/dev/zero of=$M0/dir/new bs=1024 count=9216
 gfid_new=$(get_gfid_string $M0/dir/new)
@@ -46,17 +59,18 @@ TEST stat $B0/${V0}1/.shard/$gfid_new.1
 TEST stat $B0/${V0}0/.shard/$gfid_new.2
 TEST stat $B0/${V0}1/.shard/$gfid_new.2
 TEST unlink $M0/dir/new
-TEST ! stat $B0/${V0}0/.shard/$gfid_new.1
-TEST ! stat $B0/${V0}1/.shard/$gfid_new.1
-TEST ! stat $B0/${V0}0/.shard/$gfid_new.2
-TEST ! stat $B0/${V0}1/.shard/$gfid_new.2
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_new
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_new
 TEST ! stat $M0/dir/new
 TEST ! stat $B0/${V0}0/dir/new
 TEST ! stat $B0/${V0}1/dir/new
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_new
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_new
+
+###########################################
+##### 03. Unlink with /.shard present #####
+###########################################
 
-#######################################
-##### Unlink with /.shard present #####
-#######################################
 TEST truncate -s 5M $M0/dir/foo
 gfid_foo=$(get_gfid_string $M0/dir/foo)
 # Ensure its shards are absent.
@@ -67,21 +81,28 @@ TEST unlink $M0/dir/foo
 TEST ! stat $B0/${V0}0/dir/foo
 TEST ! stat $B0/${V0}1/dir/foo
 TEST ! stat $M0/dir/foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_foo
+
+#################################################################
+##### 04. Unlink of a file with only one block (the zeroth) #####
+#################################################################
 
-#############################################################
-##### Unlink of a file with only one block (the zeroth) #####
-#############################################################
 TEST touch $M0/dir/foo
+gfid_foo=$(get_gfid_string $M0/dir/foo)
 TEST dd if=/dev/zero of=$M0/dir/foo bs=1024 count=1024
-# Test to ensure that unlink of a sparse file works fine.
+# Test to ensure that unlink of a file with only base shard works fine.
 TEST unlink $M0/dir/foo
 TEST ! stat $B0/${V0}0/dir/foo
 TEST ! stat $B0/${V0}1/dir/foo
 TEST ! stat $M0/dir/foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_foo
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_foo
+
+########################################################
+##### 05. Unlink of a sharded file with hard-links #####
+########################################################
 
-####################################################
-##### Unlink of a sharded file with hard-links #####
-####################################################
 # Create a 9M sharded file
 TEST dd if=/dev/zero of=$M0/dir/original bs=1024 count=9216
 gfid_original=$(get_gfid_string $M0/dir/original)
@@ -94,6 +115,8 @@ TEST stat $B0/${V0}1/.shard/$gfid_original.2
 TEST ln $M0/dir/original $M0/link
 # Now delete the original file.
 TEST unlink $M0/dir/original
+TEST ! stat $B0/${V0}0/.shard/.remove_me/$gfid_original
+TEST ! stat $B0/${V0}1/.shard/.remove_me/$gfid_original
 # Ensure the shards are still intact.
 TEST stat $B0/${V0}0/.shard/$gfid_original.1
 TEST stat $B0/${V0}1/.shard/$gfid_original.1
@@ -105,11 +128,11 @@ TEST stat $B0/${V0}0/link
 TEST stat $B0/${V0}1/link
 # Now delete the last link.
 TEST unlink $M0/link
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_original
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_original
 # Ensure that the shards are all cleaned up.
-TEST ! stat $B0/${V0}0/.shard/$gfid_original.1
-TEST ! stat $B0/${V0}1/.shard/$gfid_original.1
-TEST ! stat $B0/${V0}0/.shard/$gfid_original.2
-TEST ! stat $B0/${V0}1/.shard/$gfid_original.2
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_original
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_original
 TEST ! stat $M0/link
 TEST ! stat $B0/${V0}0/link
 TEST ! stat $B0/${V0}1/link
@@ -136,10 +159,12 @@ TEST mkdir $M0/dir
 TEST touch $M0/dir/src
 TEST touch $M0/dir/dst
 
-######################################
-##### Rename with /.shard absent #####
-######################################
+##########################################
+##### 06. Rename with /.shard absent #####
+##########################################
+
 TEST truncate -s 5M $M0/dir/dst
+gfid_dst=$(get_gfid_string $M0/dir/dst)
 TEST ! stat $B0/${V0}0/.shard
 TEST ! stat $B0/${V0}1/.shard
 # Test to ensure that rename doesn't fail due to absence of /.shard
@@ -150,10 +175,13 @@ TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
 TEST   stat $B0/${V0}0/dir/dst
 TEST   stat $B0/${V0}1/dir/dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+######################################################
+##### 07. Rename to a sharded file without holes #####
+######################################################
 
-##################################################
-##### Rename to a sharded file without holes #####
-##################################################
 TEST unlink $M0/dir/dst
 TEST touch $M0/dir/src
 # Create a 9M sharded file
@@ -165,24 +193,26 @@ TEST stat $B0/${V0}1/.shard/$gfid_dst.1
 TEST stat $B0/${V0}0/.shard/$gfid_dst.2
 TEST stat $B0/${V0}1/.shard/$gfid_dst.2
 TEST mv -f $M0/dir/src $M0/dir/dst
-TEST ! stat $B0/${V0}0/.shard/$gfid_dst.1
-TEST ! stat $B0/${V0}1/.shard/$gfid_dst.1
-TEST ! stat $B0/${V0}0/.shard/$gfid_dst.2
-TEST ! stat $B0/${V0}1/.shard/$gfid_dst.2
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_dst
 TEST ! stat $M0/dir/src
 TEST   stat $M0/dir/dst
 TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
 TEST   stat $B0/${V0}0/dir/dst
 TEST   stat $B0/${V0}1/dir/dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+#######################################################
+##### 08. Rename of dst file with /.shard present #####
+#######################################################
 
-###################################################
-##### Rename of dst file with /.shard present #####
-###################################################
 TEST unlink $M0/dir/dst
 TEST touch $M0/dir/src
 TEST truncate -s 5M $M0/dir/dst
-# Test to ensure that unlink of a sparse file works fine.
+gfid_dst=$(get_gfid_string $M0/dir/dst)
+# Test to ensure that rename into a sparse file works fine.
 TEST mv -f $M0/dir/src $M0/dir/dst
 TEST ! stat $M0/dir/src
 TEST   stat $M0/dir/dst
@@ -190,14 +220,18 @@ TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
 TEST   stat $B0/${V0}0/dir/dst
 TEST   stat $B0/${V0}1/dir/dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+###################################################################
+##### 09. Rename of dst file with only one block (the zeroth) #####
+###################################################################
 
-###############################################################
-##### Rename of dst file with only one block (the zeroth) #####
-###############################################################
 TEST unlink $M0/dir/dst
 TEST touch $M0/dir/src
 TEST dd if=/dev/zero of=$M0/dir/dst bs=1024 count=1024
-# Test to ensure that unlink of a sparse file works fine.
+gfid_dst=$(get_gfid_string $M0/dir/dst)
+# Test to ensure that rename into a file with only base shard works fine.
 TEST mv -f $M0/dir/src $M0/dir/dst
 TEST ! stat $M0/dir/src
 TEST   stat $M0/dir/dst
@@ -205,10 +239,13 @@ TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
 TEST   stat $B0/${V0}0/dir/dst
 TEST   stat $B0/${V0}1/dir/dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+############################################################
+##### 10. Rename to a dst sharded file with hard-links #####
+############################################################
 
-########################################################
-##### Rename to a dst sharded file with hard-links #####
-########################################################
 TEST unlink $M0/dir/dst
 TEST touch $M0/dir/src
 # Create a 9M sharded file
@@ -231,10 +268,14 @@ TEST stat $B0/${V0}1/.shard/$gfid_dst.2
 TEST ! stat $M0/dir/src
 TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
+TEST ! stat $B0/${V0}0/.shard/.remove_me/$gfid_dst
+TEST ! stat $B0/${V0}1/.shard/.remove_me/$gfid_dst
 # Now rename another file to the last link.
 TEST touch $M0/dir/src2
 TEST mv -f $M0/dir/src2 $M0/link
 # Ensure that the shards are all cleaned up.
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/$gfid_dst
 TEST ! stat $B0/${V0}0/.shard/$gfid_dst.1
 TEST ! stat $B0/${V0}1/.shard/$gfid_dst.1
 TEST ! stat $B0/${V0}0/.shard/$gfid_dst.2
@@ -242,8 +283,13 @@ TEST ! stat $B0/${V0}1/.shard/$gfid_dst.2
 TEST ! stat $M0/dir/src2
 TEST ! stat $B0/${V0}0/dir/src2
 TEST ! stat $B0/${V0}1/dir/src2
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}0/.shard/.remove_me/$gfid_dst
+EXPECT_WITHIN $FILE_COUNT_TIME 0 get_file_count $B0/${V0}1/.shard/.remove_me/$gfid_dst
+
+##############################################################
+##### 11. Rename with non-existent dst and a sharded src #####
+##############################################################l
 
-# Rename with non-existent dst and a sharded src
 TEST touch $M0/dir/src
 TEST dd if=/dev/zero of=$M0/dir/src bs=1024 count=9216
 gfid_src=$(get_gfid_string $M0/dir/src)
@@ -253,7 +299,7 @@ TEST stat $B0/${V0}1/.shard/$gfid_src.1
 TEST stat $B0/${V0}0/.shard/$gfid_src.2
 TEST stat $B0/${V0}1/.shard/$gfid_src.2
 # Now rename src to the dst.
-TEST mv $M0/dir/src $M0/dir/dst
+TEST mv $M0/dir/src $M0/dir/dst2
 
 TEST   stat $B0/${V0}0/.shard/$gfid_src.1
 TEST   stat $B0/${V0}1/.shard/$gfid_src.1
@@ -262,23 +308,26 @@ TEST   stat $B0/${V0}1/.shard/$gfid_src.2
 TEST ! stat $M0/dir/src
 TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
-TEST   stat $M0/dir/dst
-TEST   stat $B0/${V0}0/dir/dst
-TEST   stat $B0/${V0}1/dir/dst
+TEST   stat $M0/dir/dst2
+TEST   stat $B0/${V0}0/dir/dst2
+TEST   stat $B0/${V0}1/dir/dst2
+
+#############################################################################
+##### 12. Rename with non-existent dst and a sharded src with no shards #####
+#############################################################################
 
-# Rename with non-existent dst and a sharded src with no shards
 TEST touch $M0/dir/src
 TEST dd if=/dev/zero of=$M0/dir/src bs=1024 count=1024
 gfid_src=$(get_gfid_string $M0/dir/src)
 TEST ! stat $B0/${V0}0/.shard/$gfid_src.1
 TEST ! stat $B0/${V0}1/.shard/$gfid_src.1
 # Now rename src to the dst.
-TEST mv $M0/dir/src $M0/dir/dst
+TEST mv $M0/dir/src $M0/dir/dst1
 TEST ! stat $M0/dir/src
 TEST ! stat $B0/${V0}0/dir/src
 TEST ! stat $B0/${V0}1/dir/src
-TEST   stat $M0/dir/dst
-TEST   stat $B0/${V0}0/dir/dst
-TEST   stat $B0/${V0}1/dir/dst
+TEST   stat $M0/dir/dst1
+TEST   stat $B0/${V0}0/dir/dst1
+TEST   stat $B0/${V0}1/dir/dst1
 
 cleanup
diff --git a/tests/bugs/shard/zero-flag.t b/tests/bugs/shard/zero-flag.t
index 84cb9635a1b..1f39787ab9f 100644
--- a/tests/bugs/shard/zero-flag.t
+++ b/tests/bugs/shard/zero-flag.t
@@ -14,6 +14,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1,2,3}
 TEST $CLI volume set $V0 features.shard on
+TEST $CLI volume set $V0 features.shard-block-size 4MB
 TEST $CLI volume start $V0
 
 TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
diff --git a/tests/bugs/snapshot/bug-1109889.t b/tests/bugs/snapshot/bug-1109889.t
index 6b29cdd9eb1..5fdc7dc9506 100644
--- a/tests/bugs/snapshot/bug-1109889.t
+++ b/tests/bugs/snapshot/bug-1109889.t
@@ -19,9 +19,9 @@ TEST $CLI volume create $V0 $H0:$L1 $H0:$L2 $H0:$L3;
 
 TEST $CLI volume start $V0;
 
-TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0;
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0;
 
-MOUNT_PID=`ps ax |grep "glusterfs --volfile-sever $H0 --volfile-id=$V0 $M0" | grep -v grep | awk '{print $1}' | head -1`
+MOUNT_PID=$(get_mount_process_pid $V0 $M0)
 
 for i in {1..10} ; do echo "file" > $M0/file$i ; done
 
diff --git a/tests/bugs/snapshot/bug-1111041.t b/tests/bugs/snapshot/bug-1111041.t
index f771d64f2a3..efda9688d8b 100755
--- a/tests/bugs/snapshot/bug-1111041.t
+++ b/tests/bugs/snapshot/bug-1111041.t
@@ -11,6 +11,10 @@ function is_snapd_running {
          $CLI volume status $1 | grep "Snapshot Daemon" | wc -l;
 }
 
+function snapd_pid {
+    $CLI volume status $V0 | grep "Snapshot Daemon" | awk {'print $8'}
+}
+
 TEST glusterd;
 
 TEST pidof glusterd;
@@ -25,14 +29,12 @@ TEST $CLI volume set $V0 features.uss enable;
 
 EXPECT "1" is_snapd_running $V0
 
-SNAPD_PID=$($CLI volume status $V0 | grep "Snapshot Daemon" | awk {'print $8'});
+SNAPD_PID=$(snapd_pid);
 
 TEST [ $SNAPD_PID -gt 0 ]
 
 kill -9 $SNAPD_PID
 
-SNAPD_PID=$($CLI volume status $V0 | grep "Snapshot Daemon" | awk {'print $8'});
-
-TEST [ $SNAPD_PID = 'N/A' ]
+EXPECT_WITHIN $PROCESS_DOWN_TIMEOUT "^N/A$" snapd_pid
 
 cleanup  ;
diff --git a/tests/bugs/snapshot/bug-1140162-file-snapshot-features-encrypt-opts-validation.t b/tests/bugs/snapshot/bug-1140162-file-snapshot-features-encrypt-opts-validation.t
deleted file mode 100644
index c536c8261e4..00000000000
--- a/tests/bugs/snapshot/bug-1140162-file-snapshot-features-encrypt-opts-validation.t
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-
-## Test case for BZ-1140160  Volume option set <vol> <file-snapshot> and
-## <features.encryption> <value> command input should validate correctly.
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-cleanup;
-
-## Start glusterd
-TEST glusterd;
-TEST pidof glusterd;
-
-## Lets create and start volume
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-
-## Set features.file-snapshot and features.encryption option with non-boolean
-## value. These options should fail.
-TEST ! $CLI volume set $V0 features.file-snapshot abcd
-TEST ! $CLI volume set $V0 features.encryption redhat
-
-## Set other options with valid value. These options should succeed.
-TEST $CLI volume set $V0 barrier enable
-TEST $CLI volume set $V0 ping-timeout 60
-
-## Set features.file-snapshot and features.encryption option with valid boolean
-## value. These options should succeed.
-TEST $CLI volume set $V0 features.file-snapshot on
-
-## Before setting the crypt xlator on, it is required to create master key
-## Otherwise glusterfs client process will fail to start
-echo "0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff" > $GLUSTERD_WORKDIR/$V0-master-key
-
-## Specify location of master key
-TEST $CLI volume set $V0 encryption.master-key $GLUSTERD_WORKDIR/$V0-master-key
-
-TEST $CLI volume set $V0 features.encryption on
-
-cleanup;
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/snapshot/bug-1166197.t b/tests/bugs/snapshot/bug-1166197.t
index 7350acfa9ed..b070ae271ba 100755
--- a/tests/bugs/snapshot/bug-1166197.t
+++ b/tests/bugs/snapshot/bug-1166197.t
@@ -5,6 +5,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 CURDIR=`pwd`
 
diff --git a/tests/bugs/snapshot/bug-1167580-set-proper-uid-and-gid-during-nfs-access.t b/tests/bugs/snapshot/bug-1167580-set-proper-uid-and-gid-during-nfs-access.t
index 3776451c158..52a7a790b97 100644
--- a/tests/bugs/snapshot/bug-1167580-set-proper-uid-and-gid-during-nfs-access.t
+++ b/tests/bugs/snapshot/bug-1167580-set-proper-uid-and-gid-during-nfs-access.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../volume.rc
 . $(dirname $0)/../../snapshot.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 # This function returns a value "Y" if user can execute
 # the given command. Else it will return "N"
 # @arg-1 : Name of the user
@@ -199,3 +201,5 @@ TEST $CLI snapshot delete all
 cleanup;
 
 
+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
+#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
diff --git a/tests/bugs/snapshot/bug-1227646.t b/tests/bugs/snapshot/bug-1227646.t
index 643d814e2ee..9b73dfdb32f 100644
--- a/tests/bugs/snapshot/bug-1227646.t
+++ b/tests/bugs/snapshot/bug-1227646.t
@@ -20,7 +20,6 @@ TEST $CLI snapshot create snap1 $V0 no-timestamp;
 TEST $CLI volume stop $V0
 TEST $CLI snapshot restore snap1;
 TEST $CLI volume start $V0
-TEST $CLI volume attach-tier $V0 $H0:$L1 $H0:$L2
 
 TEST pkill gluster
 TEST glusterd
diff --git a/tests/bugs/snapshot/bug-1260848.t b/tests/bugs/snapshot/bug-1260848.t
index 7eae3982e43..6455d8297b2 100644
--- a/tests/bugs/snapshot/bug-1260848.t
+++ b/tests/bugs/snapshot/bug-1260848.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../../nfs.rc
 . $(dirname $0)/../../volume.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 ## Start and create a volume
diff --git a/tests/bugs/snapshot/bug-1279327.t b/tests/bugs/snapshot/bug-1279327.t
index fd5fec24471..4e4be6eeea6 100644
--- a/tests/bugs/snapshot/bug-1279327.t
+++ b/tests/bugs/snapshot/bug-1279327.t
@@ -15,7 +15,6 @@ TEST setup_lvm 3
 TEST $CLI volume create $V0 $H0:$L1
 TEST $CLI volume start $V0
 TEST $CLI volume quota $V0 enable
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$L2 $H0:$L3
 
 TEST $CLI snapshot create snap1 $V0 no-timestamp
 TEST $CLI snapshot activate snap1
diff --git a/tests/bugs/snapshot/bug-1322772-real-path-fix-for-snapshot.t b/tests/bugs/snapshot/bug-1322772-real-path-fix-for-snapshot.t
index bf625eca89b..488bd462a01 100644
--- a/tests/bugs/snapshot/bug-1322772-real-path-fix-for-snapshot.t
+++ b/tests/bugs/snapshot/bug-1322772-real-path-fix-for-snapshot.t
@@ -26,6 +26,7 @@ EXPECT 'Started' volinfo_field $V0 'Status'
 TEST $CLI volume start $V1
 EXPECT 'Started' volinfo_field $V1 'Status'
 
+TEST $CLI snapshot config activate-on-create enable
 TEST $CLI snapshot create ${V0}_snap $V0 no-timestamp
 TEST $CLI snapshot create ${V1}_snap $V1 no-timestamp
 
diff --git a/tests/bugs/snapshot/bug-1482023-snpashot-issue-with-other-processes-accessing-mounted-path.t b/tests/bugs/snapshot/bug-1482023-snpashot-issue-with-other-processes-accessing-mounted-path.t
new file mode 100644
index 00000000000..04a85db0c1a
--- /dev/null
+++ b/tests/bugs/snapshot/bug-1482023-snpashot-issue-with-other-processes-accessing-mounted-path.t
@@ -0,0 +1,133 @@
+#!/bin/bash
+
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+
+function create_snapshots() {
+        $CLI_1 snapshot create ${V0}_snap ${V0} no-timestamp &
+        PID_1=$!
+
+        $CLI_1 snapshot create ${V1}_snap ${V1} no-timestamp &
+        PID_2=$!
+
+        wait $PID_1 $PID_2
+}
+
+function activate_snapshots() {
+        $CLI_1 snapshot activate ${V0}_snap &
+        PID_1=$!
+
+        $CLI_1 snapshot activate ${V1}_snap &
+        PID_2=$!
+
+        wait $PID_1 $PID_2
+}
+
+function deactivate_snapshots() {
+        $CLI_1 snapshot deactivate ${V0}_snap &
+        PID_1=$!
+
+        $CLI_1 snapshot deactivate ${V1}_snap &
+        PID_2=$!
+
+        wait $PID_1 $PID_2
+}
+cleanup;
+
+TEST verify_lvm_version;
+# Create cluster with 3 nodes
+TEST launch_cluster 3;
+TEST setup_lvm 3
+
+TEST $CLI_1 peer probe $H2;
+TEST $CLI_1 peer probe $H3;
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count;
+
+# Create volumes
+TEST $CLI_1 volume create $V0 $H1:$L1
+TEST $CLI_2 volume create $V1 $H2:$L2 $H3:$L3
+
+# Start volumes
+TEST $CLI_1 volume start $V0
+TEST $CLI_2 volume start $V1
+
+TEST $CLI_1 snapshot config activate-on-create enable
+
+# Snapshot Operations
+create_snapshots
+
+EXPECT 'Started' snapshot_status ${V0}_snap;
+EXPECT 'Started' snapshot_status ${V1}_snap;
+
+deactivate_snapshots
+
+EXPECT 'Stopped' snapshot_status ${V0}_snap;
+EXPECT 'Stopped' snapshot_status ${V1}_snap;
+
+activate_snapshots
+
+EXPECT 'Started' snapshot_status ${V0}_snap;
+EXPECT 'Started' snapshot_status ${V1}_snap;
+
+# This Function will get snap id form snap info command and will
+# check for mount point in system against snap id.
+function mounted_snaps
+{
+        snap_id=`$CLI_1 snap info $1_snap | grep "Snap Volume Name" |
+                  awk -F ":" '{print $2}'`
+        echo `mount | grep $snap_id | wc -l`
+}
+
+EXPECT "1" mounted_snaps ${V0}
+EXPECT "2" mounted_snaps ${V1}
+
+deactivate_snapshots
+
+EXPECT "0" mounted_snaps ${V0}
+EXPECT "0" mounted_snaps ${V1}
+
+# This part of test is designed to validate that updates are properly being
+# handled during handshake.
+
+activate_snapshots
+
+EXPECT 'Started' snapshot_status ${V0}_snap;
+EXPECT 'Started' snapshot_status ${V1}_snap;
+
+kill_glusterd 2
+
+deactivate_snapshots
+EXPECT 'Stopped' snapshot_status ${V0}_snap;
+EXPECT 'Stopped' snapshot_status ${V1}_snap;
+
+TEST start_glusterd 2
+
+# Updates form friend should reflect as snap was deactivated while glusterd
+# process was inactive and mount point should also not exist.
+
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count;
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" mounted_snaps ${V0}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "0" mounted_snaps ${V1}
+
+# It might be possible that the import snap synctask is still updating the data,
+# we need to allow a buffer time to be on the safer side
+sleep 2
+
+kill_glusterd 2
+activate_snapshots
+EXPECT 'Started' snapshot_status ${V0}_snap;
+EXPECT 'Started' snapshot_status ${V1}_snap;
+TEST start_glusterd 2
+
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count;
+
+# Updates form friend should reflect as snap was activated while glusterd
+# process was inactive and mount point should exist.
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" mounted_snaps ${V0}
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" mounted_snaps ${V1}
+
+cleanup;
+# run first!
+#G_TESTDEF_TEST_STATUS_CENTOS6=BRICK_MUX_BAD_TEST,BUG=1743069
diff --git a/tests/bugs/snapshot/bug-1512451-snapshot-creation-failed-after-brick-reset.t b/tests/bugs/snapshot/bug-1512451-snapshot-creation-failed-after-brick-reset.t
new file mode 100644
index 00000000000..53b274e8819
--- /dev/null
+++ b/tests/bugs/snapshot/bug-1512451-snapshot-creation-failed-after-brick-reset.t
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../cluster.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup;
+TEST verify_lvm_version
+TEST launch_cluster 2
+TEST setup_lvm 2
+
+TEST $CLI_1 peer probe $H2
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count
+
+TEST $CLI_1 volume create $V0 $H1:$L1/B1 $H2:$L2/B1
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+TEST $CLI_1 snapshot create ${V0}_snap1 ${V0} no-timestamp
+TEST snapshot_exists 1 ${V0}_snap1
+
+TEST $CLI_1 snapshot delete ${V0}_snap1
+TEST ! snapshot_exists 1 ${V0}_snap1
+
+TEST $CLI_1 volume reset-brick $V0 $H1:$L1/B1 start
+TEST $CLI_1 volume reset-brick $V0 $H1:$L1/B1 $H1:$L1/B1 commit force
+
+EXPECT_WITHIN $PROCESS_UP_TIMEOUT "1" cluster_brick_up_status 1 $V0 $H1 $L1/B1
+
+TEST $CLI_1 snapshot create ${V0}_snap1 ${V0} no-timestamp
+TEST snapshot_exists 1 ${V0}_snap1
+
+TEST $CLI_1 snapshot delete ${V0}_snap1
+TEST ! snapshot_exists 1 ${V0}_snap1
+
+cleanup;
diff --git a/tests/bugs/snapshot/bug-1597662.t b/tests/bugs/snapshot/bug-1597662.t
new file mode 100644
index 00000000000..f582930476a
--- /dev/null
+++ b/tests/bugs/snapshot/bug-1597662.t
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+
+cleanup;
+
+TEST init_n_bricks 3;
+TEST setup_lvm 3;
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 $H0:$L1 $H0:$L2 $H0:$L3;
+TEST $CLI volume start $V0;
+
+snap_path=/var/run/gluster/snaps
+
+TEST $CLI snapshot create snap1 $V0 no-timestamp;
+
+$CLI snapshot activate snap1;
+
+EXPECT 'Started' snapshot_status snap1;
+
+# This Function will check for entry /var/run/gluster/snaps/<snap-name>
+# against snap-name
+
+function is_snap_path
+{
+        echo `ls $snap_path | grep snap1 | wc -l`
+}
+
+# snap is active so snap_path should exist
+EXPECT "1" is_snap_path
+
+$CLI snapshot deactivate snap1;
+EXPECT_WITHIN ${PROCESS_DOWN_TIMEOUT} 'Stopped' snapshot_status snap1
+# snap is deactivated so snap_path should not exist
+EXPECT "0" is_snap_path
+
+# activate snap again
+$CLI snapshot activate snap1;
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} 'Started' snapshot_status snap1
+
+# snap is active so snap_path should exist
+EXPECT "1" is_snap_path
+
+# delete snap now
+TEST $CLI snapshot delete snap1;
+
+# snap is deleted so snap_path should not exist
+EXPECT "0" is_snap_path
+
+TEST $CLI volume stop $V0;
+TEST $CLI volume delete $V0;
+
+cleanup;
+
diff --git a/tests/bugs/snapshot/bug-1618004-fix-memory-corruption-in-snap-import.t b/tests/bugs/snapshot/bug-1618004-fix-memory-corruption-in-snap-import.t
new file mode 100644
index 00000000000..a2c004e435e
--- /dev/null
+++ b/tests/bugs/snapshot/bug-1618004-fix-memory-corruption-in-snap-import.t
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+. $(dirname $0)/../../snapshot.rc
+. $(dirname $0)/../../cluster.rc
+
+function get_volume_info ()
+{
+        local var=$1
+        $CLI_1 volume info $V0 | grep "^$var" | sed 's/.*: //'
+}
+
+cleanup;
+
+TEST verify_lvm_version
+TEST launch_cluster 2
+TEST setup_lvm 2
+
+TEST $CLI_1 peer probe $H2;
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count;
+
+TEST $CLI_1 volume create $V0 $H1:$L1 $H2:$L2
+EXPECT "$V0" get_volume_info 'Volume Name';
+EXPECT 'Created' get_volume_info 'Status';
+
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' get_volume_info 'Status';
+
+
+# Setting system limit
+TEST $CLI_1 snapshot config activate-on-create enable
+
+TEST $CLI_1 snapshot create snap1 $V0 no-timestamp description "test"
+TEST kill_glusterd 1
+#deactivate snapshot for changing snap version, so that handshake will
+#happen when glusterd is restarted
+TEST $CLI_2 snapshot deactivate snap1
+TEST start_glusterd 1
+
+#Wait till handshake complete
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} 'Stopped' snapshot_status snap1
+
+#Delete the snapshot, without this fix, delete will lead to assertion failure
+$CLI_1 snapshot delete all
+EXPECT '0' get_snap_count CLI_1;
+cleanup;
+
diff --git a/tests/bugs/tier/bug-1205545-CTR-and-trash-integration.t b/tests/bugs/tier/bug-1205545-CTR-and-trash-integration.t
deleted file mode 100644
index 752c517adc3..00000000000
--- a/tests/bugs/tier/bug-1205545-CTR-and-trash-integration.t
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-
-LAST_BRICK=3
-CACHE_BRICK_FIRST=4
-CACHE_BRICK_LAST=5
-
-cleanup
-
-# Start glusterd [1-2]
-TEST glusterd
-TEST pidof glusterd
-
-# Set-up tier cluster [3-4]
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0..$LAST_BRICK}
-TEST $CLI volume start $V0
-TEST $CLI volume attach-tier $V0 replica 2 $H0:$B0/${V0}$CACHE_BRICK_FIRST $H0:$B0/${V0}$CACHE_BRICK_LAST
-
-# Start and mount the volume after enabling CTR and trash [5-8]
-TEST $CLI volume set $V0 features.ctr-enabled on
-TEST $CLI volume set $V0 features.trash on
-TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0;
-
-# Create an empty file
-touch $M0/foo
-
-# gf_file_tb and gf_flink_tb should contain one entry each [9]
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 2 ]
-
-# Create two hard links
-ln $M0/foo $M0/lnk1
-ln $M0/foo $M0/lnk2
-
-# Now gf_flink_tb should contain 3 entries [10]
-ENTRY_COUNT=$(echo "select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 3 ]
-
-# Delete the hard link
-rm -rf $M0/lnk1
-
-# Corresponding hard link entry must be removed from gf_flink_tb
-# but gf_file_tb should still contain the file entry [11]
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 3 ]
-
-# Remove the file
-rm -rf $M0/foo
-
-# Another hardlink removed [12]
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 2 ]
-
-# Remove the last hardlink
-rm -rf $M0/lnk2
-
-# All entried must be removed from gf_flink_tb and gf_file_tb [13]
-ENTRY_COUNT=$(echo "select * from gf_file_tb; select * from gf_flink_tb;" | \
-        sqlite3 $B0/${V0}5/.glusterfs/${V0}5.db | wc -l )
-TEST [ $ENTRY_COUNT -eq 0 ]
-
-cleanup
-
-
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/bugs/tier/bug-1279376-rename-demoted-file.t b/tests/bugs/tier/bug-1279376-rename-demoted-file.t
deleted file mode 100755
index c4a50d9d9f7..00000000000
--- a/tests/bugs/tier/bug-1279376-rename-demoted-file.t
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../../include.rc
-. $(dirname $0)/../../volume.rc
-. $(dirname $0)/../../tier.rc
-
-
-NUM_BRICKS=2
-DEMOTE_FREQ=15
-DEMOTE_TIMEOUT=10
-PROMOTE_FREQ=500
-
-
-#Both src and dst files must hash to the same hot tier subvol
-SRC_FILE="file1.txt"
-DST_FILE="newfile1.txt"
-
-
-# Creates a tiered volume with pure distribute hot and cold tiers
-# Both hot and cold tiers will have an equal number of bricks.
-
-function create_dist_tier_vol () {
-        mkdir $B0/cold
-        mkdir $B0/hot
-        TEST $CLI volume create $V0 $H0:$B0/cold/${V0}{0..$1}
-        TEST $CLI volume set $V0 performance.quick-read off
-        TEST $CLI volume set $V0 performance.io-cache off
-        TEST $CLI volume start $V0
-        TEST $CLI volume tier $V0 attach $H0:$B0/hot/${V0}{0..$1}
-        TEST $CLI volume set $V0 cluster.tier-demote-frequency $DEMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-promote-frequency $PROMOTE_FREQ
-        TEST $CLI volume set $V0 cluster.tier-mode test
-
-#We do not want any files to be promoted during this test
-        TEST $CLI volume set $V0 features.record-counters on
-        TEST $CLI volume set $V0 cluster.read-freq-threshold 50
-        TEST $CLI volume set $V0 cluster.write-freq-threshold 50
-}
-
-
-cleanup;
-
-#Basic checks
-TEST glusterd
-TEST pidof glusterd
-TEST $CLI volume info
-
-
-#Create and start a tiered volume
-create_dist_tier_vol $NUM_BRICKS
-
-# Mount FUSE
-TEST glusterfs -s $H0 --volfile-id $V0 $M0
-
-
-# The file will be created on the hot tier
-
-TEST touch "$M0/$SRC_FILE"
-
-# Get the path of the file on the hot tier
-HPATH=`find $B0/hot/ -name  "$SRC_FILE"`
-echo "File path on hot tier: "$HPATH
-
-
-EXPECT "yes" exists_and_regular_file $HPATH
-
-# Wait for the tier process to demote the file
-sleep $DEMOTE_FREQ
-
-# Get the path of the file on the cold tier
-CPATH=`find $B0/cold/ -name  "$SRC_FILE"`
-echo "File path on cold tier: "$CPATH
-
-EXPECT_WITHIN $DEMOTE_TIMEOUT "yes" exists_and_regular_file $CPATH
-
-#We don't want $DST_FILE to get demoted
-TEST $CLI volume set $V0 cluster.tier-demote-frequency $PROMOTE_FREQ
-
-#This will be created on the hot tier
-
-touch "$M0/$DST_FILE"
-HPATH=`find $B0/hot/ -name "$DST_FILE"`
-echo "File path on hot tier: "$HPATH
-
-TEST mv $M0/$SRC_FILE $M0/$DST_FILE
-
-# We expect a single file to exist at this point
-# when viewed on the mountpoint
-EXPECT 1 echo $(ls -l $M0 | grep $DST_FILE | wc -l)
-
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=000000
diff --git a/tests/bugs/transport/bug-873367.t b/tests/bugs/transport/bug-873367.t
index d4c07024ed0..8070bc1b83c 100755
--- a/tests/bugs/transport/bug-873367.t
+++ b/tests/bugs/transport/bug-873367.t
@@ -13,7 +13,7 @@ rm -f $SSL_BASE/glusterfs.*
 mkdir -p $B0/1
 mkdir -p $M0
 
-TEST openssl genrsa -out $SSL_KEY 1024
+TEST openssl genrsa -out $SSL_KEY 2048
 TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
 ln $SSL_CERT $SSL_CA
 
diff --git a/tests/bugs/write-behind/bug-1058663.c b/tests/bugs/write-behind/bug-1058663.c
index 5e522e98048..aedf97d7487 100644
--- a/tests/bugs/write-behind/bug-1058663.c
+++ b/tests/bugs/write-behind/bug-1058663.c
@@ -19,101 +19,105 @@ static int sigbus_received;
 /* test for truncate()/seek()/write()/mmap()
  * There should ne no SIGBUS triggered.
  */
-void seek_write(char *filename)
+void
+seek_write(char *filename)
 {
-	int fd;
-	uint8_t *map;
-	int i;
-
-	fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
-	lseek(fd, FILE_SIZE - 1, SEEK_SET);
-	write(fd, "\xff", 1);
-
-	map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);
-	for (i = 0; i < (FILE_SIZE - 1); i++) {
-		if (map[i] != 0) /* should never be true */
-			abort();
-	}
-	munmap(map, FILE_SIZE);
-
-	close(fd);
+    int fd;
+    uint8_t *map;
+    int i;
+
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    lseek(fd, FILE_SIZE - 1, SEEK_SET);
+    write(fd, "\xff", 1);
+
+    map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);
+    for (i = 0; i < (FILE_SIZE - 1); i++) {
+        if (map[i] != 0) /* should never be true */
+            abort();
+    }
+    munmap(map, FILE_SIZE);
+
+    close(fd);
 }
 
-int read_after_eof(char *filename)
+int
+read_after_eof(char *filename)
 {
-	int ret = 0;
-	int fd;
-	char *data;
-	uint8_t *map;
-
-	fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
-	lseek(fd, FILE_SIZE - 1, SEEK_SET);
-	write(fd, "\xff", 1);
-
-	/* trigger verify that reading after EOF fails */
-	ret = read(fd, data, FILE_SIZE / 2);
-	if (ret != 0)
-		return 1;
-
-	/* map an area of 1 byte after FILE_SIZE */
-	map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE);
-	/* map[0] is an access after EOF, it should trigger SIGBUS */
-	if (map[0] != 0)
-		/* it is expected that we exit before we get here */
-		if (!sigbus_received)
-			return 1;
-	munmap(map, FILE_SIZE);
-
-	close(fd);
-
-	return ret;
+    int ret = 0;
+    int fd;
+    char *data;
+    uint8_t *map;
+
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    lseek(fd, FILE_SIZE - 1, SEEK_SET);
+    write(fd, "\xff", 1);
+
+    /* trigger verify that reading after EOF fails */
+    ret = read(fd, data, FILE_SIZE / 2);
+    if (ret != 0)
+        return 1;
+
+    /* map an area of 1 byte after FILE_SIZE */
+    map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE);
+    /* map[0] is an access after EOF, it should trigger SIGBUS */
+    if (map[0] != 0)
+        /* it is expected that we exit before we get here */
+        if (!sigbus_received)
+            return 1;
+    munmap(map, FILE_SIZE);
+
+    close(fd);
+
+    return ret;
 }
 
 /* signal handler for SIGBUS */
-void catch_sigbus(int signum)
+void
+catch_sigbus(int signum)
 {
-	switch (signum) {
+    switch (signum) {
 #ifdef __NetBSD__
-	/* Depending on architecture, we can get SIGSEGV */
-	case SIGSEGV: /* FALLTHROUGH */
+        /* Depending on architecture, we can get SIGSEGV */
+        case SIGSEGV: /* FALLTHROUGH */
 #endif
-	case SIGBUS:
-		sigbus_received++;
-		if (!expect_sigbus)
-			exit(EXIT_FAILURE);
-		if (sigbus_received >= MAX_SIGBUS)
-			exit(EXIT_SUCCESS);
-		break;
-	default:
-		printf("Unexpected signal received: %d\n", signum);
-	}
+        case SIGBUS:
+            sigbus_received++;
+            if (!expect_sigbus)
+                exit(EXIT_FAILURE);
+            if (sigbus_received >= MAX_SIGBUS)
+                exit(EXIT_SUCCESS);
+            break;
+        default:
+            printf("Unexpected signal received: %d\n", signum);
+    }
 }
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-	int i = 0;
+    int i = 0;
 
-	if (argc == 1) {
-		printf("Usage: %s <filename>\n", argv[0]);
-		return EXIT_FAILURE;
-	}
+    if (argc == 1) {
+        printf("Usage: %s <filename>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
 #ifdef __NetBSD__
-	/* Depending on architecture, we can get SIGSEGV */
-	signal(SIGSEGV, catch_sigbus);
+    /* Depending on architecture, we can get SIGSEGV */
+    signal(SIGSEGV, catch_sigbus);
 #endif
-	signal(SIGBUS, catch_sigbus);
+    signal(SIGBUS, catch_sigbus);
 
-	/* the next test should not trigger SIGBUS */
-	expect_sigbus = 0;
-	for (i = 0; i < RUN_LOOP; i++) {
-		seek_write(argv[1]);
-	}
+    /* the next test should not trigger SIGBUS */
+    expect_sigbus = 0;
+    for (i = 0; i < RUN_LOOP; i++) {
+        seek_write(argv[1]);
+    }
 
-	/* the next test should trigger SIGBUS */
-	expect_sigbus = 1;
-	if (read_after_eof(argv[1]))
-		return EXIT_FAILURE;
+    /* the next test should trigger SIGBUS */
+    expect_sigbus = 1;
+    if (read_after_eof(argv[1]))
+        return EXIT_FAILURE;
 
-	return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }
diff --git a/tests/bugs/write-behind/bug-1279730.c b/tests/bugs/write-behind/bug-1279730.c
index 535d289c582..706ae67b102 100644
--- a/tests/bugs/write-behind/bug-1279730.c
+++ b/tests/bugs/write-behind/bug-1279730.c
@@ -8,124 +8,142 @@
 #include <assert.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd                = -1, ret = -1, len = 0;
-        char        *path              = NULL, buf[128] = {0, }, *cmd = NULL;
-        struct stat  stbuf             = {0, };
-        int          write_to_child[2] = {0, }, write_to_parent[2] = {0, };
+    int fd = -1, ret = -1, len = 0;
+    char *path = NULL,
+         buf[128] =
+             {
+                 0,
+             },
+         *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    int write_to_child[2] =
+        {
+            0,
+        },
+        write_to_parent[2] = {
+            0,
+        };
+
+    path = argv[1];
+    cmd = argv[2];
+
+    assert(argc == 3);
+
+    ret = pipe(write_to_child);
+    if (ret < 0) {
+        fprintf(stderr,
+                "creation of write-to-child pipe failed "
+                "(%s)\n",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = pipe(write_to_parent);
+    if (ret < 0) {
+        fprintf(stderr,
+                "creation of write-to-parent pipe failed "
+                "(%s)\n",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = fork();
+    switch (ret) {
+        case 0:
+            close(write_to_child[1]);
+            close(write_to_parent[0]);
+
+            /* child, wait for instructions to execute command */
+            ret = read(write_to_child[0], buf, 128);
+            if (ret < 0) {
+                fprintf(stderr, "child: read on pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
 
-        path = argv[1];
-        cmd = argv[2];
+            system(cmd);
+
+            ret = write(write_to_parent[1], "1", 2);
+            if (ret < 0) {
+                fprintf(stderr, "child: write to pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
+            break;
 
-        assert (argc == 3);
+        case -1:
+            fprintf(stderr, "fork failed (%s)\n", strerror(errno));
+            goto out;
+
+        default:
+            close(write_to_parent[1]);
+            close(write_to_child[0]);
 
-        ret = pipe (write_to_child);
-        if (ret < 0) {
-                fprintf (stderr, "creation of write-to-child pipe failed "
-                         "(%s)\n", strerror (errno));
+            fd = open(path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU);
+            if (fd < 0) {
+                fprintf(stderr, "open failed (%s)\n", strerror(errno));
                 goto out;
-        }
+            }
+
+            len = strlen("test-content") + 1;
+            ret = write(fd, "test-content", len);
+
+            if (ret < len) {
+                fprintf(stderr, "write failed %d (%s)\n", ret, strerror(errno));
+            }
+
+            ret = pread(fd, buf, 128, 0);
+            if ((ret == len) && (strcmp(buf, "test-content") == 0)) {
+                fprintf(stderr,
+                        "read should've failed as previous "
+                        "write would've failed with EDQUOT, but its "
+                        "successful");
+                ret = -1;
+                goto out;
+            }
 
-        ret = pipe (write_to_parent);
-        if (ret < 0) {
-                fprintf (stderr, "creation of write-to-parent pipe failed "
-                         "(%s)\n", strerror (errno));
+            ret = write(write_to_child[1], "1", 2);
+            if (ret < 0) {
+                fprintf(stderr, "parent: write to pipe failed (%s)\n",
+                        strerror(errno));
                 goto out;
-        }
+            }
 
-        ret = fork ();
-        switch (ret) {
-        case 0:
-                close (write_to_child[1]);
-                close (write_to_parent[0]);
-
-                /* child, wait for instructions to execute command */
-                ret = read (write_to_child[0], buf, 128);
-                if (ret < 0) {
-                        fprintf (stderr, "child: read on pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                system (cmd);
-
-                ret = write (write_to_parent[1], "1", 2);
-                if (ret < 0) {
-                        fprintf (stderr, "child: write to pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-                break;
+            ret = read(write_to_parent[0], buf, 128);
+            if (ret < 0) {
+                fprintf(stderr, "parent: read from pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
+
+            /* this will force a sync on cached-write and now that quota
+               limit is increased, sync will be successful. ignore return
+               value as fstat would fail with EDQUOT (picked up from
+               cached-write because of previous sync failure.
+            */
+            fstat(fd, &stbuf);
+
+            ret = pread(fd, buf, 128, 0);
+            if (ret != len) {
+                fprintf(stderr,
+                        "post cmd read failed %d (data:%s) "
+                        "(error:%s)\n",
+                        ret, buf, strerror(errno));
+                goto out;
+            }
 
-        case -1:
-                fprintf (stderr, "fork failed (%s)\n", strerror (errno));
+            if (strcmp(buf, "test-content")) {
+                fprintf(stderr, "wrong data (%s)\n", buf);
                 goto out;
+            }
+    }
 
-        default:
-                close (write_to_parent[1]);
-                close (write_to_child[0]);
-
-                fd = open (path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU);
-                if (fd < 0) {
-                        fprintf (stderr, "open failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                len = strlen ("test-content") + 1;
-                ret = write (fd, "test-content", len);
-
-                if (ret < len) {
-                        fprintf (stderr, "write failed %d (%s)\n", ret,
-                                 strerror (errno));
-                }
-
-                ret = pread (fd, buf, 128, 0);
-                if ((ret == len) && (strcmp (buf, "test-content") == 0)) {
-                        fprintf (stderr, "read should've failed as previous "
-                                 "write would've failed with EDQUOT, but its "
-                                 "successful");
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = write (write_to_child[1], "1", 2);
-                if (ret < 0) {
-                        fprintf (stderr, "parent: write to pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                ret = read (write_to_parent[0], buf, 128);
-                if (ret < 0) {
-                        fprintf (stderr, "parent: read from pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                /* this will force a sync on cached-write and now that quota
-                   limit is increased, sync will be successful. ignore return
-                   value as fstat would fail with EDQUOT (picked up from
-                   cached-write because of previous sync failure.
-                */
-                fstat (fd, &stbuf);
-
-                ret = pread (fd, buf, 128, 0);
-                if (ret != len) {
-                        fprintf (stderr, "post cmd read failed %d (data:%s) "
-                                 "(error:%s)\n", ret, buf, strerror (errno));
-                        goto out;
-                }
-
-                if (strcmp (buf, "test-content")) {
-                        fprintf (stderr, "wrong data (%s)\n", buf);
-                        goto out;
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/write-behind/issue-884.c b/tests/bugs/write-behind/issue-884.c
new file mode 100644
index 00000000000..e9c33b351ad
--- /dev/null
+++ b/tests/bugs/write-behind/issue-884.c
@@ -0,0 +1,267 @@
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pthread.h>
+
+#include <glusterfs/api/glfs.h>
+
+/* Based on a reproducer by Stefan Ring. It seems to be quite sensible to any
+ * timing modification, so the code has been maintained as is, only with minor
+ * changes. */
+
+struct glfs *glfs;
+
+pthread_mutex_t the_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t the_cond = PTHREAD_COND_INITIALIZER;
+
+typedef struct _my_aiocb {
+    int64_t size;
+    volatile int64_t seq;
+    int which;
+} my_aiocb;
+
+typedef struct _worker_data {
+    my_aiocb cb;
+    struct iovec iov;
+    int64_t offset;
+} worker_data;
+
+typedef struct {
+    worker_data wdata[2];
+
+    volatile unsigned busy;
+} all_data_t;
+
+all_data_t all_data;
+
+static void
+completion_fnc(struct glfs_fd *fd, ssize_t ret, struct glfs_stat *pre,
+               struct glfs_stat *post, void *arg)
+{
+    void *the_thread;
+    my_aiocb *cb = (my_aiocb *)arg;
+    long seq = cb->seq;
+
+    assert(ret == cb->size);
+
+    pthread_mutex_lock(&the_mutex);
+    pthread_cond_broadcast(&the_cond);
+
+    all_data.busy &= ~(1 << cb->which);
+    cb->seq = -1;
+
+    the_thread = (void *)pthread_self();
+    printf("worker %d is done from thread %p, seq %ld!\n", cb->which,
+           the_thread, seq);
+
+    pthread_mutex_unlock(&the_mutex);
+}
+
+static void
+init_wdata(worker_data *data, int which)
+{
+    data->cb.which = which;
+    data->cb.seq = -1;
+
+    data->iov.iov_base = malloc(1024 * 1024);
+    memset(data->iov.iov_base, 6,
+           1024 * 1024); /* tail part never overwritten */
+}
+
+static void
+init()
+{
+    all_data.busy = 0;
+
+    init_wdata(&all_data.wdata[0], 0);
+    init_wdata(&all_data.wdata[1], 1);
+}
+
+static void
+do_write(struct glfs_fd *fd, int content, int size, int64_t seq,
+         worker_data *wdata, const char *name)
+{
+    int ret;
+
+    wdata->cb.size = size;
+    wdata->cb.seq = seq;
+
+    if (content >= 0)
+        memset(wdata->iov.iov_base, content, size);
+    wdata->iov.iov_len = size;
+
+    pthread_mutex_lock(&the_mutex);
+    printf("(%d) dispatching write \"%s\", offset %lx, len %x, seq %ld\n",
+           wdata->cb.which, name, (long)wdata->offset, size, (long)seq);
+    pthread_mutex_unlock(&the_mutex);
+    ret = glfs_pwritev_async(fd, &wdata->iov, 1, wdata->offset, 0,
+                             completion_fnc, &wdata->cb);
+    assert(ret >= 0);
+}
+
+#define IDLE 0  // both workers must be idle
+#define ANY 1   // use any worker, other one may be busy
+
+int
+get_worker(int waitfor, int64_t excl_seq)
+{
+    int which;
+
+    pthread_mutex_lock(&the_mutex);
+
+    while (waitfor == IDLE && (all_data.busy & 3) != 0 ||
+           waitfor == ANY &&
+               ((all_data.busy & 3) == 3 ||
+                excl_seq >= 0 && (all_data.wdata[0].cb.seq == excl_seq ||
+                                  all_data.wdata[1].cb.seq == excl_seq)))
+        pthread_cond_wait(&the_cond, &the_mutex);
+
+    if (!(all_data.busy & 1))
+        which = 0;
+    else
+        which = 1;
+
+    all_data.busy |= (1 << which);
+
+    pthread_mutex_unlock(&the_mutex);
+
+    return which;
+}
+
+static int
+doit(struct glfs_fd *fd)
+{
+    int ret;
+    int64_t seq = 0;
+    int64_t offset = 0;     // position in file, in blocks
+    int64_t base = 0x1000;  // where to place the data, in blocks
+
+    int async_mode = ANY;
+
+    init();
+
+    for (;;) {
+        int which;
+        worker_data *wdata;
+
+        // for growing to the first offset
+        for (;;) {
+            int gap = base + 0x42 - offset;
+            if (!gap)
+                break;
+            if (gap > 80)
+                gap = 80;
+
+            which = get_worker(IDLE, -1);
+            wdata = &all_data.wdata[which];
+
+            wdata->offset = offset << 9;
+            do_write(fd, 0, gap << 9, seq++, wdata, "gap-filling");
+
+            offset += gap;
+        }
+
+        // 8700
+        which = get_worker(IDLE, -1);
+        wdata = &all_data.wdata[which];
+
+        wdata->offset = (base + 0x42) << 9;
+        do_write(fd, 1, 62 << 9, seq++, wdata, "!8700");
+
+        // 8701
+        which = get_worker(IDLE, -1);
+        wdata = &all_data.wdata[which];
+
+        wdata->offset = (base + 0x42) << 9;
+        do_write(fd, 2, 55 << 9, seq++, wdata, "!8701");
+
+        // 8702
+        which = get_worker(async_mode, -1);
+        wdata = &all_data.wdata[which];
+
+        wdata->offset = (base + 0x79) << 9;
+        do_write(fd, 3, 54 << 9, seq++, wdata, "!8702");
+
+        // 8703
+        which = get_worker(async_mode, -1);
+        wdata = &all_data.wdata[which];
+
+        wdata->offset = (base + 0xaf) << 9;
+        do_write(fd, 4, 81 << 9, seq++, wdata, "!8703");
+
+        // 8704
+        // this writes both 5s and 6s
+        // the range of 5s is the one that overwrites 8703
+
+        which = get_worker(async_mode, seq - 1);
+        wdata = &all_data.wdata[which];
+
+        memset(wdata->iov.iov_base, 5, 81 << 9);
+        wdata->offset = (base + 0xaf) << 9;
+        do_write(fd, -1, 1623 << 9, seq++, wdata, "!8704");
+
+        offset = base + 0x706;
+        base += 0x1000;
+        if (base >= 0x100000)
+            break;
+    }
+
+    printf("done!\n");
+    fflush(stdout);
+
+    pthread_mutex_lock(&the_mutex);
+
+    while ((all_data.busy & 3) != 0)
+        pthread_cond_wait(&the_cond, &the_mutex);
+
+    pthread_mutex_unlock(&the_mutex);
+
+    ret = glfs_close(fd);
+    assert(ret >= 0);
+    /*
+        ret = glfs_fini(glfs);
+        assert(ret >= 0);
+    */
+    return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret;
+    int open_flags = O_RDWR | O_DIRECT | O_TRUNC;
+    struct glfs_fd *fd;
+
+    glfs = glfs_new(argv[1]);
+    if (!glfs) {
+        printf("glfs_new!\n");
+        goto out;
+    }
+    ret = glfs_set_volfile_server(glfs, "tcp", "localhost", 24007);
+    if (ret < 0) {
+        printf("set_volfile!\n");
+        goto out;
+    }
+    ret = glfs_init(glfs);
+    if (ret) {
+        printf("init!\n");
+        goto out;
+    }
+    fd = glfs_open(glfs, argv[2], open_flags);
+    if (!fd) {
+        printf("open!\n");
+        goto out;
+    }
+    srand(time(NULL));
+    return doit(fd);
+out:
+    return 1;
+}
diff --git a/tests/bugs/write-behind/issue-884.t b/tests/bugs/write-behind/issue-884.t
new file mode 100755
index 00000000000..2bcf7d15265
--- /dev/null
+++ b/tests/bugs/write-behind/issue-884.t
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+# This test tries to detect a race condition in write-behind. It's based on a
+# reproducer written by Stefan Ring that is able to hit it sometimes. On my
+# system, it happened around 10% of the runs. This means that if this bug
+# appears again, this test will fail once every 10 runs. Most probably this
+# failure will be hidden by the automatic test retry of the testing framework.
+#
+# Please, if this test fails, it needs to be analyzed in detail.
+
+function run() {
+    "${@}" >/dev/null
+}
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/$V0
+# This makes it easier to hit the issue
+TEST $CLI volume set $V0 client-log-level TRACE
+TEST $CLI volume start $V0
+
+TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
+
+build_tester $(dirname $0)/issue-884.c -lgfapi
+
+TEST touch $M0/testfile
+
+# This program generates a file of 535694336 bytes with a fixed pattern
+TEST run $(dirname $0)/issue-884 $V0 testfile
+
+# This is the md5sum of the expected pattern without corruption
+EXPECT "ad105f9349345a70fc697632cbb5eec8" echo "$(md5sum $B0/$V0/testfile | awk '{ print $1; }')"
+
+cleanup
diff --git a/tests/cluster.rc b/tests/cluster.rc
index c1ff8ab5b74..34f5b02398f 100644
--- a/tests/cluster.rc
+++ b/tests/cluster.rc
@@ -11,7 +11,7 @@ function launch_cluster() {
     define_backends $count;
     define_hosts $count;
     define_glusterds $count $2;
-    define_clis $count;
+    define_clis $count $3;
 
     start_glusterds;
 }
@@ -50,15 +50,16 @@ function define_glusterds() {
         sopt="management.glusterd-sockfile=${!b}/glusterd/gd.sock"
         #Get the logdir
         logdir=`gluster --print-logdir`
+        clopt="management.cluster-test-mode=${logdir}/$i";
         #Fetch the testcases name and prefix the glusterd log with it
         logfile=`echo ${0##*/}`_glusterd$i.log
-        lopt="--log-file=$logdir/$logfile"
+        lopt="--log-file=$logdir/$i/$logfile"
         if [ "$2" == "-LDEBUG" ]; then
-            eval "glusterd_$i='glusterd -LDEBUG --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt $lopt $popt'";
-            eval "glusterd$i='glusterd -LDEBUG --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt $lopt $popt'";
+            eval "glusterd_$i='glusterd -LDEBUG --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt --xlator-option $clopt $lopt $popt'";
+            eval "glusterd$i='glusterd -LDEBUG --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt --xlator-option $clopt $lopt $popt'";
         else
-            eval "glusterd_$i='glusterd --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt $lopt $popt'";
-            eval "glusterd$i='glusterd --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt $lopt $popt'";
+            eval "glusterd_$i='glusterd --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt --xlator-option $clopt $lopt $popt'";
+            eval "glusterd$i='glusterd --xlator-option $wopt --xlator-option $bopt --xlator-option $ropt --xlator-option $sopt --xlator-option $clopt $lopt $popt'";
         fi
     done
 }
@@ -89,6 +90,20 @@ function kill_glusterd() {
     kill `cat $pidfile`;
 }
 
+function restart_glusterd() {
+    local index=$1
+    local b
+    local pidfile
+    local g
+
+    b="B$index"
+    pidfile="${!b}/glusterd.pid"
+
+    kill `cat $pidfile`
+
+    g="glusterd_${index}"
+    ${!g}
+}
 
 function kill_node() {
     local index=$1;
@@ -96,7 +111,7 @@ function kill_node() {
 
     h="H$index";
 
-    kill -9 $(ps -ef | grep gluster | grep ${!h} | awk '{print $2}');
+    terminate_pids $(ps -ef | grep gluster | grep ${!h} | awk '{print $2}')
     find $B0/$index/glusterd/vols -name '*.pid' | xargs rm -f
 }
 
@@ -133,8 +148,13 @@ function define_clis() {
         lopt1="--log-file=$logdir/$logfile1"
 
 
-        eval "CLI_$i='$CLI --glusterd-sock=${!b}/glusterd/gd.sock $lopt'";
-        eval "CLI$i='$CLI --glusterd-sock=${!b}/glusterd/gd.sock $lopt1'";
+        if [ "$2" == "-NO_FORCE" ]; then
+                eval "CLI_$i='$CLI_NO_FORCE --glusterd-sock=${!b}/glusterd/gd.sock $lopt'";
+                eval "CLI$i='$CLI_NO_FORCE --glusterd-sock=${!b}/glusterd/gd.sock $lopt1'";
+        else
+                eval "CLI_$i='$CLI --glusterd-sock=${!b}/glusterd/gd.sock $lopt'";
+                eval "CLI$i='$CLI --glusterd-sock=${!b}/glusterd/gd.sock $lopt1'";
+        fi
     done
 }
 
@@ -142,6 +162,16 @@ function peer_count() {
     $CLI_1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
 }
 
+function attempt_replace_brick {
+    local cli_no=$1
+    local vol=$2;
+    local src_brick=$3;
+    local dst_brick=$4;
+
+    eval \$CLI_$cli_no volume replace-brick $vol $src_brick $dst_brick commit force;
+    echo $?
+}
+
 function cluster_rebalance_status_field {
         #The rebalance status can be up to 3 words, (e.g.:'fix-layout in progress'), hence the awk-print $7 thru $9.
         #But if the status is less than 3 words, it also prints the next field i.e the run_time_in_secs.(e.g.:'completed 3.00').
@@ -174,10 +204,15 @@ function volinfo_field_2()
     $CLI_2 volume info $vol | grep "^$field: " | sed 's/.*: //';
 }
 
-function brick_up_status_1 {
-        local vol=$1
-        local host=$2
-        local brick=$3
-        $CLI_1 volume status $vol $host:$brick --xml | sed -ne 's/.*<status>\([01]\)<\/status>/\1/p'
+function cluster_brick_up_status {
+        local vol=$2
+        local host=$3
+        local brick=$4
+        eval \$CLI_$1 volume status $vol $host:$brick --xml | sed -ne 's/.*<status>\([01]\)<\/status>/\1/p'
 }
 
+function cluster_remove_brick_status_completed_field {
+        local vol=$1
+        local brick_list=$2
+        $CLI_1 volume remove-brick $vol $brick_list status | awk '{print $7}' | sed -n 3p
+}
diff --git a/tests/dht.rc b/tests/dht.rc
index 53b00645e66..6918ebde04b 100644
--- a/tests/dht.rc
+++ b/tests/dht.rc
@@ -1,5 +1,6 @@
 #!/bin/bash
 
+dhthashdebugxattr="dht.file.hashed-subvol."
 
 function get_layout()
 {
@@ -133,3 +134,41 @@ function is_dht_linkfile()
         echo $retval
         return $retval
 }
+
+
+# Given an existing directory on the volume, get the hashed subvol for a file
+# in that directory
+# Input: filename dirpath_on_mount
+
+function dht_get_hash_subvol()
+{
+        local hashed_subvol
+        hashed_subvol=$(getfattr --only-values -n "$dhthashdebugxattr$1" $2 2>/dev/null)
+        echo $hashed_subvol
+}
+
+
+# Find the first filename that hashes to the same subvol
+# as $1
+# Input: subvol_name dirpath_on_mount file_pattern
+
+function dht_first_filename_with_hashsubvol()
+{
+        local in_subvol=$1
+        local in_path=$2
+        local in_hash_subvol
+        local file_pattern=$3
+        local filename
+
+        for i in {1..50}
+        do
+               filename="$file_pattern$i"
+               in_hash_subvol=$(dht_get_hash_subvol "$filename" "$in_path")
+        #       echo $in_hash_subvol
+               if [ "$in_subvol" == "$in_hash_subvol" ]; then
+                        fn_return_val=$filename
+                        return 0
+               fi
+        done
+        return 1
+}
diff --git a/tests/ec.rc b/tests/ec.rc
new file mode 100644
index 00000000000..f18752fc99a
--- /dev/null
+++ b/tests/ec.rc
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+function ec_up_status()
+{
+        local v=$1
+        local m=$2
+        local ec_id=$3
+        grep -E "^up =" $m/.meta/graphs/active/${v}-disperse-${ec_id}/private | cut -f2 -d'='
+}
+
+function ec_option_value()
+{
+    local v=$1
+    local m=$2
+    local ec_id=$3
+    local opt=$4
+    grep -E "^$opt =" $m/.meta/graphs/active/${v}-disperse-${ec_id}/private | cut -f2 -d'='| awk '{print $1}'
+}
diff --git a/tests/encryption/crypt.t b/tests/encryption/crypt.t
deleted file mode 100755
index 2f965b0e8b7..00000000000
--- a/tests/encryption/crypt.t
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-
-cleanup;
-
-TEST glusterd
-TEST pidof glusterd
-
-## Create a volume with one brick
-TEST $CLI volume create $V0 $H0:$B0/${V0}1;
-EXPECT "$V0" volinfo_field $V0 'Volume Name';
-EXPECT 'Created' volinfo_field $V0 'Status';
-EXPECT '1' brick_count $V0
-
-## Turn off performance translators
-
-TEST $CLI volume set $V0 performance.quick-read off
-EXPECT 'off' volinfo_field $V0 'performance.quick-read'
-TEST $CLI volume set $V0 performance.write-behind off
-EXPECT 'off' volinfo_field $V0 'performance.write-behind'
-TEST $CLI volume set $V0 performance.open-behind off
-EXPECT 'off' volinfo_field $V0 'performance.open-behind'
-
-## Create a file with master key
-
-echo "0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff" > $GLUSTERD_WORKDIR/$V0-master-key
-
-## Specify location of master key
-TEST $CLI volume set $V0 encryption.master-key $GLUSTERD_WORKDIR/$V0-master-key
-
-## Turn on crypt xlator by setting features.encryption to on
-TEST $CLI volume set $V0 encryption on
-EXPECT 'on' volinfo_field $V0 'features.encryption'
-
-## Start the volume
-TEST $CLI volume start $V0;
-EXPECT 'Started' volinfo_field $V0 'Status';
-
-## Mount the volume
-TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0;
-
-## Testing writev, readv, ftruncate:
-## Create fragmented files and compare them with the reference files
-
-build_tester $(dirname $0)/frag.c
-TEST $(dirname $0)/frag $M0/testfile /tmp/$V0-goodfile 262144 500
-
-## Testing link, unlink, symlink, rename
-
-TEST ln $M0/testfile $M0/testfile-link
-TEST mv $M0/testfile $M0/testfile-renamed
-TEST ln -s $M0/testfile-link $M0/testfile-symlink
-TEST rm -f $M0/testfile-renamed
-
-## Remount the volume
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0;
-
-TEST diff -u $M0/testfile-symlink /tmp/$V0-goodfile
-EXPECT ''
-
-TEST rm -f $M0/testfile-symlink
-TEST rm -f $M0/testfile-link
-
-## Cleanup files
-
-TEST rm -f /tmp/$V0-master-key
-TEST rm -f /tmp/$V0-goodfile
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-
-## Reset crypt options
-TEST $CLI volume reset $V0 encryption.block-size
-TEST $CLI volume reset $V0 encryption.data-key-size
-
-## Stop the volume
-TEST $CLI volume stop $V0;
-EXPECT 'Stopped' volinfo_field $V0 'Status';
-
-## Delete the volume
-TEST $CLI volume delete $V0;
-TEST ! $CLI volume info $V0;
-
-TEST rm -rf $(dirname $0)/frag
-cleanup;
-
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/encryption/frag.c b/tests/encryption/frag.c
deleted file mode 100644
index 86da037c607..00000000000
--- a/tests/encryption/frag.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
-  Copyright (c) 2008-2013 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-#define MAX_NUM_OPS (1 << 20)
-#define MAX_FILE_SIZE (1 << 30)
-
-typedef enum {
-	READ_OP,
-	WRITE_OP,
-	TRUNC_OP,
-	LAST_OP
-} frag_op;
-
-struct frag_ctx {
-	int test_fd;
-	int good_fd;
-	char *test_buf;
-	char *good_buf;
-	char *content;
-	int max_file_size;
-};
-
-typedef int (*frag_op_t)(struct frag_ctx *ctx, off_t offset, size_t count);
-
-static int doread(int fd, off_t offset, size_t count,
-		  char *buf, int max_file_size)
-{
-	int ret = 0;
-	int was_read = 0;
-
-	if (lseek(fd, offset, SEEK_SET) == -1) {
-		perror("lseek failed");
-                return -1;
-	}
-	while (count) {
-		ret = read(fd, buf + offset + was_read, count);
-		if (ret < 0)
-			return -1;
-		if (ret == 0)
-			break;
-		if (ret > count) {
-			fprintf(stderr, "READ: read more than asked\n");
-			return -1;
-		}
-		count -= ret;
-		was_read += ret;
-	}
-	return ret;
-}
-
-static int dowrite(int fd, off_t offset, size_t count, char *buf)
-{
-	int ret;
-
-	ret = lseek(fd, offset, SEEK_SET);
-	if (ret == -1)
-                return ret;
-	return write(fd, buf, count);
-}
-
-static int dotrunc(int fd, off_t offset)
-{
-	int ret;
-
-	ret = ftruncate(fd, offset);
-	if (ret == -1)
-		perror("truncate failed");
-	return ret;
-}
-
-static int prepare_file(char *filename, int *fd, char **buf, int max_file_size)
-{
-	int ret;
-
-	*buf = malloc(max_file_size);
-	if (*buf == NULL) {
-		perror("malloc failed");
-	        return -1;
-	}
-	*fd = open(filename, O_CREAT | O_RDWR, S_IRWXU);
-	if (*fd == -1) {
-		perror("open failed");
-		free(*buf);
-		*buf = NULL;
-		return -1;
-	}
-	return 0;
-}
-
-/*
- * @offset, @count: random values from [0, max_file_size - 1]
- */
-static int frag_write(struct frag_ctx *ctx, off_t offset, size_t count)
-{
-	int ret;
-	struct stat test_stbuf;
-	struct stat good_stbuf;
-
-	if (offset + count > ctx->max_file_size)
-		offset = offset / 2;
-	if (offset + count > ctx->max_file_size)
-		count = count / 2;
-
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "WRITE: fstat of test file failed\n");
-		return -1;
-	}
-	if (offset > test_stbuf.st_size)
-		printf("writing hole\n");
-
-	ret = dowrite(ctx->test_fd, offset, count, ctx->content);
-	if (ret < 0 || ret != count){
-		fprintf(stderr, "WRITE: failed to write test file\n");
-		return -1;
-	}
-	ret = dowrite(ctx->good_fd, offset, count, ctx->content);
-	if (ret < 0 || ret != count) {
-		fprintf(stderr, "WRITE: failed to write test file\n");
-		return -1;
-	}	
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-                fprintf(stderr, "WRITE: fstat of test file failed\n");
-		return -1;
-	}
-	if (fstat(ctx->good_fd, &good_stbuf)) {
-                fprintf(stderr, "WRITE: fstat of good file failed\n");
-		return -1;
-	}
-	if (test_stbuf.st_size != good_stbuf.st_size) {
-		fprintf(stderr,
-			"READ: Bad file size %d (expected %d)\n",
-			(int)test_stbuf.st_size,
-			(int)good_stbuf.st_size);
-		return -1;
-	}
-	return 0;
-}
-
-/*
- * @offset, @count: random values from [0, max_file_size - 1]
- */
-static int frag_read(struct frag_ctx *ctx, off_t offset, size_t count)
-{
-	ssize_t test_ret;
-	ssize_t good_ret;
-
-	test_ret = doread(ctx->test_fd,
-			  offset, count, ctx->test_buf, ctx->max_file_size);
-	if (test_ret < 0) {
-		fprintf(stderr, "READ: failed to read test file\n");
-		return -1;
-	}
-	good_ret = doread(ctx->good_fd,
-			  offset, count, ctx->good_buf, ctx->max_file_size);
-	if (good_ret < 0) {
-		fprintf(stderr, "READ: failed to read good file\n");
-		return -1;
-	}
-	if (test_ret != good_ret) {
-		fprintf(stderr,
-			"READ: Bad return value %d (expected %d\n)",
-			test_ret, good_ret);
-		return -1;
-	}
-	if (memcmp(ctx->test_buf + offset, ctx->good_buf + offset, good_ret)) {
-		fprintf(stderr, "READ: bad data\n");
-		return -1;
-	}
-	return 0;
-}
-
-/*
- * @offset: random value from [0, max_file_size - 1]
- */
-static int frag_truncate(struct frag_ctx *ctx,
-			 off_t offset, __attribute__((unused))size_t count)
-{
-	int ret;
-	struct stat test_stbuf;
-	struct stat good_stbuf;
-
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
-		return -1;
-	}
-	if (offset > test_stbuf.st_size)
-		printf("expanding truncate to %d\n", offset);
-	else if (offset < test_stbuf.st_size)
-		printf("shrinking truncate to %d\n", offset);
-	else
-		printf("trivial truncate\n");
-	
-	ret = dotrunc(ctx->test_fd, offset);
-	if (ret == -1) {
-		fprintf(stderr, "TRUNCATE: failed for test file\n");
-		return -1;
-	}
-	ret = dotrunc(ctx->good_fd, offset);
-	if (ret == -1) {
-		fprintf(stderr, "TRUNCATE: failed for good file\n");
-		return -1;
-	}
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
-		return -1;
-	}
-	if (fstat(ctx->good_fd, &good_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of good file failed\n");
-		return -1;
-	}
-	if (test_stbuf.st_size != good_stbuf.st_size) {
-		fprintf(stderr,
-			"TRUNCATE: bad test file size %d (expected %d)\n",
-			test_stbuf.st_size,
-			good_stbuf.st_size);
-		return -1;
-	}
-	return 0;
-}
-
-frag_op_t frag_ops[LAST_OP] = {
-	[READ_OP]  = frag_read,
-	[WRITE_OP] = frag_write,
-	[TRUNC_OP] = frag_truncate
-};
-
-static void put_ctx(struct frag_ctx *ctx)
-{
-	if (ctx->test_buf)
-		free(ctx->test_buf);
-	if (ctx->good_buf)
-		free(ctx->good_buf);
-	if (ctx->content)
-		free(ctx->content);
-}
-
-main (int argc, char *argv[])
-{
-	int i;
-	int ret = 0;
-	struct frag_ctx ctx;
-	char *test_filename = NULL;
-	char *good_filename = NULL;
-	int num_ops;
-	int max_file_size;
-
-	memset(&ctx, 0, sizeof(ctx));
-	if (argc != 5) {
-                fprintf(stderr,
-			"usage: %s <test-file-name> <good-file-name> <max-file-size> <number-of-operations>\n",
-			argv[0]);
-		ret = -1;
-                goto exit;
-        }
-	test_filename = argv[1];
-	good_filename = argv[2];
-	max_file_size = atoi(argv[3]);
-	if (max_file_size > MAX_FILE_SIZE)
-		max_file_size = MAX_FILE_SIZE;
-	num_ops = atoi(argv[4]);
-	if (num_ops > MAX_NUM_OPS)
-		num_ops = MAX_NUM_OPS;
-
-	ret = prepare_file(test_filename,
-			   &ctx.test_fd, &ctx.test_buf, max_file_size);
-	if (ret)
-		goto exit;
-	ret = prepare_file(good_filename,
-			   &ctx.good_fd, &ctx.good_buf, max_file_size);
-	if (ret) {
-		if (close(ctx.test_fd) == -1)
-			perror("close test_buf failed");
-		goto exit;
-	}
-	ctx.content = malloc(max_file_size);
-	if (!ctx.content) {
-		perror("malloc failed");
-		goto close;
-	}
-	ctx.max_file_size = max_file_size;
-	for (i = 0; i < max_file_size; i++)
-                ctx.content[i] = random() % 256;
-
-	for (i = 0; i < num_ops; i++) {
-		ret = frag_ops[random() % LAST_OP](&ctx,
-					random() % max_file_size, /* offset */
-					random() % max_file_size  /* count */);
-		if (ret)
-			break;
-	}
- close:
-	if (close(ctx.test_fd) == -1)
-		perror("close test_fd failed");
-	if (close(ctx.good_fd) == -1)
-		perror("close good_fd failed");	
- exit:
-	put_ctx(&ctx);
-	if (ret)
-		exit(1);
-	exit(0);
-}
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/tests/env.rc.in b/tests/env.rc.in
index 3f3394bd5ec..0478d66aec6 100644
--- a/tests/env.rc.in
+++ b/tests/env.rc.in
@@ -2,7 +2,7 @@ prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 
-PATH=@sbindir@:$PATH
+PATH=@bindir@:@sbindir@:$PATH
 export PATH
 
 GLUSTERD_PIDFILEDIR=@localstatedir@/run/gluster
@@ -31,3 +31,12 @@ export PYTHON
 
 PYTHONPATH=@BUILD_PYTHON_SITE_PACKAGES@:$PYTHON_PATH
 export PYTHONPATH
+
+GLUSTER_CMD_DIR=@sbindir@
+export GLUSTER_CMD_DIR
+
+GLUSTER_LIBEXECDIR=@GLUSTERFS_LIBEXECDIR@
+export GLUSTER_LIBEXECDIR
+
+RUN_NFS_TESTS=@BUILD_GNFS@
+export RUN_NFS_TESTS
diff --git a/tests/features/delay-gen.t b/tests/features/delay-gen.t
new file mode 100755
index 00000000000..72e6dbb7697
--- /dev/null
+++ b/tests/features/delay-gen.t
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}1
+
+EXPECT "$V0" volinfo_field $V0 'Volume Name'
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI volume set $V0 delay-gen posix
+TEST $CLI volume set $V0 delay-gen.delay-duration 1000000
+TEST $CLI volume set $V0 delay-gen.delay-percentage 100
+TEST $CLI volume set $V0 delay-gen.enable read,write
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+TEST $CLI volume profile $V0 start
+## Mount FUSE with caching disabled (read-write)
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+
+TEST dd if=/dev/zero of=$M0/1 count=1 bs=128k oflag=sync
+
+#Write should take at least a second
+write_max_latency=$($CLI volume profile $V0 info | grep WRITE | awk 'BEGIN {max = 0} {if ($6 > max) max=$6;} END {print max}' | cut -d. -f 1 | egrep "[0-9]{7,}")
+
+#Create should not take a second
+create_max_latency=$($CLI volume profile $V0 info | grep CREATE | awk 'BEGIN {max = 0} {if ($6 > max) max=$6;} END {print max}' | cut -d. -f 1 | egrep "[0-9]{7,}")
+
+TEST [ ! -z $write_max_latency ];
+TEST [ -z $create_max_latency ];
+
+# Not providing a particular fop will make it test everything
+TEST $CLI volume reset $V0 delay-gen.enable
+TEST $CLI volume set $V0 delay-gen.delay-duration 100
+
+cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+build_tester ./glfsxmp.c -lgfapi
+./glfsxmp $V0 $H0 >/dev/null
+cleanup_tester ./glfsxmp
+rm ./glfsxmp.c
+
+$(dirname $0)/../basic/rpc-coverage.sh $M0 >/dev/null
+
+cleanup;
+#G_TESTDEF_TEST_STATUS_NETBSD7=1501397
diff --git a/tests/features/fdl-overflow.t b/tests/features/fdl-overflow.t
new file mode 100644
index 00000000000..34b941d2f2a
--- /dev/null
+++ b/tests/features/fdl-overflow.t
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../fdl.rc
+
+_check_sizes () {
+	local n=0
+	local sz
+	local total_sz=0
+
+	# We don't care about the sizes of the meta files.  That would be
+	# embedding too much of the implementation into the test.
+	n=$(ls ${log_base}/${log_id}-meta-*.jnl | wc -l)
+	[ $n = 2 ] || return 1
+
+	# We *do* care about the sizes of the data files, which should exactly
+	# reflect the amount of data written via dd.
+	n=0
+	while read sz name; do
+                G_LOG "found journal ${name} size ${sz}MB"
+		n=$((n+1))
+		total_sz=$((total_sz+sz))
+	done < <(du -sm ${log_base}/${log_id}-data-*.jnl)
+	[ $n = 2 ] || return 1
+	# On our CentOS and NetBSD regression-test systems, but not on my Fedora
+	# development system, each file ends up being slightly larger than its
+	# data size because of metadata, and 'du' rounds that up to a full extra
+	# megabyte.  We'll allow either result, because what we're really
+	# looking for is a complete failure to roll over from one file to
+	# another at the appropriate size.
+	[ $total_sz = 20 -o $total_sz = $((n+20)) ] || return 1
+
+	return 0
+}
+
+check_sizes () {
+	set -x
+	_check_sizes
+	ret=$?
+	set +x
+	return ret
+}
+
+if [ x"$OSTYPE" = x"NetBSD" ]; then
+        CREAT_OFLAG="creat,"
+else
+        CREAT_OFLAG=""
+fi
+
+TEST rm -f ${log_base}/${log_id}-*.log
+TEST glusterd
+TEST pidof glusterd
+
+# Get a simple volume set up and mounted with FDL active.
+TEST $CLI volume create $V0 ${H0}:${B0}/${V0}-0
+TEST $CLI volume set $V0 changelog.changelog off
+TEST $CLI volume set $V0 features.fdl on
+TEST $CLI volume start $V0
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+
+# Generate some I/O and unmount/stop so we can see log sizes.
+TEST dd if=/dev/zero of=$M0/twentyMB bs=1048576 count=20 \
+     oflag=${CREAT_OFLAG}sync
+TEST umount $M0
+TEST $CLI volume stop $V0
+
+TEST _check_sizes
+
+cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1385758
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1385758
diff --git a/tests/features/fdl.t b/tests/features/fdl.t
new file mode 100644
index 00000000000..5a3c13fc850
--- /dev/null
+++ b/tests/features/fdl.t
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../fdl.rc
+
+if [ x"$OSTYPE" = x"NetBSD" ]; then
+        CREAT_OFLAG="creat,"
+else
+        CREAT_OFLAG=""
+fi
+
+TEST rm -f $FDL_META_FILE $FDL_DATA_FILE
+TEST glusterd
+TEST pidof glusterd
+
+# Get a simple volume set up and mounted with FDL active.
+TEST $CLI volume create $V0 ${H0}:${B0}/${V0}-0
+TEST $CLI volume set $V0 changelog.changelog off
+TEST $CLI volume set $V0 features.fdl on
+TEST $CLI volume start $V0
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+
+# Generate some I/O and unmount.
+TEST mkdir -p $M0/abc/def
+TEST dd if=/dev/zero of=$M0/abc/def/ghi bs=128 count=2 \
+     oflag=${CREAT_OFLAG}sync
+TEST chmod 314 $M0/abc/def/ghi
+TEST rm -rf $M0/abc
+TEST umount $M0
+
+# Check that gf_logdump works, and shows the ops we just issued.  There will be
+# more SETATTR ops than the one corresponding to our chmod, because some are
+# issued internally.  We have to guess a bit about where the log will be.
+TEST check_logfile GF_FOP_MKDIR 2
+TEST check_logfile GF_FOP_CREATE 1
+TEST check_logfile GF_FOP_WRITE 2
+TEST check_logfile GF_FOP_SETATTR 1
+TEST check_logfile GF_FOP_UNLINK 1
+TEST check_logfile GF_FOP_RMDIR 2
+
+cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1385758
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1385758
diff --git a/tests/features/flock_interrupt.t b/tests/features/flock_interrupt.t
new file mode 100644
index 00000000000..b8717e30dfb
--- /dev/null
+++ b/tests/features/flock_interrupt.t
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}0;
+
+## Verify volume is is created
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+## Start volume and verify
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST touch $M0/testfile;
+
+echo > got_lock
+flock $M0/testfile sleep 6 & { sleep 0.3; flock -w 2 $M0/testfile true; echo ok > got_lock; } &
+
+EXPECT_WITHIN 4 ok cat got_lock;
+
+## Finish up
+rm -f got_lock;
+cleanup;
diff --git a/tests/features/fuse-lru-limit.t b/tests/features/fuse-lru-limit.t
new file mode 100644
index 00000000000..dd6be2d5397
--- /dev/null
+++ b/tests/features/fuse-lru-limit.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 $H0:$B0/${V0}{0,1}
+TEST $CLI volume start $V0
+TEST glusterfs -s $H0 --volfile-id $V0 $M0
+EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "2" online_brick_count
+
+EXPECT "1" get_mount_active_size_value $V0 $M0
+EXPECT "0" get_mount_lru_size_value $V0 $M0
+
+mkdir ${M0}/dir-{1..9}
+for i in {1..9}; do
+    for j in {1..1000}; do
+        echo "Test file" > ${M0}/dir-$i/file-$j;
+    done;
+done
+lc=$(get_mount_lru_size_value $V0 ${M0})
+# ideally it should be 9000+
+TEST [ $lc -ge 9000 ]
+
+TEST umount $M0
+
+TEST glusterfs -s $H0 --volfile-id $V0 --lru-limit 1000 $M0
+
+TEST find $M0
+lc=$(get_mount_lru_size_value $V0 ${M0})
+# ideally it should be <1000
+# Not sure if there are any possibilities of buffer need.
+TEST [ $lc -le 1000 ]
+
+TEST rm -rf $M0/*
+
+EXPECT "1" get_mount_active_size_value $V0 $M0
+EXPECT "0" get_mount_lru_size_value $V0 $M0
+
+cleanup
diff --git a/tests/features/glfs-lease-recall.c b/tests/features/glfs-lease-recall.c
new file mode 100644
index 00000000000..9a60f9beec1
--- /dev/null
+++ b/tests/features/glfs-lease-recall.c
@@ -0,0 +1,372 @@
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* Few rules:
+ * 1. A client may have multiple lease keys, but a lease key cannot be shared by
+ * multiple clients.
+ * 2. Lease key can be set before open, or in glfs_lease request. A lease key
+ * set like this is valid for the lifetime of the fd, i.e. a fd cannot have
+ * multiple lease key. But a lease key can be shared across multiple fds.
+ */
+glfs_t *client1 = NULL, *client2 = NULL;
+glfs_fd_t *fd1 = NULL;
+FILE *log_file = NULL;
+char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1",
+     lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
+char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {
+                                                  0,
+};
+char *volname = NULL, *glfs_log_file = NULL;
+int upcall_recv = 0;
+
+#define MAX_CLIENTS 4
+#define MAX_FDS 4
+#define TEST_FILE "/test/lease"
+#define SHUD_PASS 0
+#define SHUD_FAIL -1
+#define NONE 0
+
+static void
+recall_cbk(struct glfs_lease lease, void *data);
+
+static int
+set_read_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, fd);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RD_LEASE");
+    return ret;
+}
+
+static int
+set_write_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RW_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RW_LEASE");
+    return ret;
+}
+
+static int
+get_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_GET_LEASE;
+    lease.lease_type = -1;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    GET_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    if (lease.lease_type == GLFS_RD_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE");
+    else if (lease.lease_type == GLFS_RW_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RW_LEASE");
+    else if (lease.lease_type == 3)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
+    else if (lease.lease_type == 0)
+        fprintf(log_file, "\n    Esisting Lease: NONE");
+    else
+        fprintf(log_file, "\n    Existing lease type:%d", lease.lease_type);
+    return lease.lease_type;
+}
+
+static int
+unlk_write_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RW_LEASE");
+    return ret;
+}
+
+static int
+unlk_read_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RD_LEASE");
+    return ret;
+}
+
+void
+up_async_lease_recall(struct glfs_upcall *up_arg, void *data)
+{
+    struct glfs_upcall_lease *in_arg = NULL;
+    enum glfs_upcall_reason reason = 0;
+    struct glfs_object *object = NULL;
+    uint64_t flags = 0;
+    uint64_t expire = 0;
+
+    if (!up_arg)
+        return;
+
+    reason = glfs_upcall_get_reason(up_arg);
+
+    /* Expect 'GLFS_UPCALL_RECALL_LEASE' upcall event. */
+
+    if (reason == GLFS_UPCALL_RECALL_LEASE) {
+        in_arg = glfs_upcall_get_event(up_arg);
+
+        object = glfs_upcall_lease_get_object(in_arg);
+
+        fprintf(log_file,
+                " upcall event type - %d,"
+                " object(%p)\n",
+                reason, object);
+        upcall_recv = 1;
+    }
+
+    glfs_free(up_arg);
+    return;
+}
+
+glfs_t *
+setup_new_client(char *volname, char *log_fileile)
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+    int up_events = GLFS_EVENT_ANY;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(log_file, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    /* Register Upcalls */
+    ret = glfs_upcall_register(fs, up_events, up_async_lease_recall, NULL);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_RECALL_LEASE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event - GLFS_EVENT_RECALL_LEASE\n");
+        goto error;
+    }
+
+    return fs;
+error:
+    if (fs)
+        glfs_fini(fs);
+    return NULL;
+}
+
+#define OPEN(client, flags, fd, lease_id)                                      \
+    do {                                                                       \
+        int ret_val = 0;                                                       \
+        ret_val = glfs_setfsleaseid(lease_id);                                 \
+        if (ret_val) {                                                         \
+            fprintf(log_file,                                                  \
+                    "\nglfs_setfsleaseid failed with ret: %d (%s)\n", ret,     \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+        fd = glfs_open(client, TEST_FILE, flags);                              \
+        if (fd == NULL) {                                                      \
+            fprintf(log_file, "\nglfs_open failed with ret: %d (%s)\n", ret,   \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define VERIFY_RESULT(test_case, ret, value)                                   \
+    do {                                                                       \
+        if (ret != value) {                                                    \
+            fprintf(log_file,                                                  \
+                    "\n    Testcase %d failed, ret = %d, value=%d\n",          \
+                    test_case, ret, value);                                    \
+            goto error; /*test unsuccessful*/                                  \
+        }                                                                      \
+        fprintf(log_file, "\n    Testcase %d Succeeded\n", test_case);         \
+    } while (0)
+
+static void
+recall_cbk(struct glfs_lease lease, void *data)
+{
+    int ret = -1;
+    char ld[GLFS_LEASE_ID_SIZE] = "";
+
+    fprintf(log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
+    memcpy(ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
+    ret = unlk_write_lease((glfs_fd_t *)data, ld);
+    VERIFY_RESULT(500, ret, SHUD_PASS);
+error:
+    return;
+}
+
+static int
+testcase_recall_conflict_lease()
+{
+    struct glfs_object *obj = NULL;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    fprintf(log_file,
+            "\n Basic test case for conflicting lease causing recall");
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    /* reset counter */
+    upcall_recv = 0;
+
+    obj = glfs_h_lookupat(client2, NULL, TEST_FILE, NULL, 0);
+    ret = glfs_h_lease(client2, obj, &lease);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
+
+    sleep(3);
+    /* should recv upcall */
+    VERIFY_RESULT(6, !upcall_recv, SHUD_PASS);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = glfs_h_close(obj);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    int x = 0;
+    ssize_t xattr_size = -1;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <Vol> <glfs client log file> "
+                "<testcase log file>\n",
+                argv[0]);
+        return -1;
+    }
+
+    log_file = fopen(argv[3], "w");
+    if (!log_file)
+        goto error;
+
+    volname = argv[1];
+    glfs_log_file = argv[2];
+
+    /* Setup 2 clients */
+    client1 = setup_new_client(volname, glfs_log_file);
+    client2 = setup_new_client(volname, glfs_log_file);
+
+    ret = testcase_recall_conflict_lease();
+    VERIFY_RESULT(101, ret, SHUD_PASS);
+
+    glfs_fini(client1);
+    glfs_fini(client2);
+
+    fclose(log_file);
+    return 0;
+error:
+    return -1;
+}
diff --git a/tests/features/glfs-lease.c b/tests/features/glfs-lease.c
new file mode 100644
index 00000000000..e82cd875b38
--- /dev/null
+++ b/tests/features/glfs-lease.c
@@ -0,0 +1,717 @@
+#include <glusterfs/api/glfs.h>
+#include <glusterfs/api/glfs-handles.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* Few rules:
+ * 1. A client may have multiple lease keys, but a lease key cannot be shared by
+ * multiple clients.
+ * 2. Lease key can be set before open, or in glfs_lease request. A lease key
+ * set like this is valid for the lifetime of the fd, i.e. a fd cannot have
+ * multiple lease key. But a lease key can be shared across multiple fds.
+ */
+glfs_t *client1 = NULL, *client2 = NULL, *client3 = NULL, *client4 = NULL;
+glfs_fd_t *fd1 = NULL, *fd2 = NULL, *fd3 = NULL, *fd4 = NULL;
+FILE *log_file = NULL;
+char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1",
+     lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
+char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {
+                                                  0,
+};
+char *volname = NULL, *glfs_log_file = NULL;
+
+#define MAX_CLIENTS 4
+#define MAX_FDS 4
+#define TEST_FILE "/test/lease"
+#define SHUD_PASS 0
+#define SHUD_FAIL -1
+#define NONE 0
+
+static void
+recall_cbk(struct glfs_lease lease, void *data);
+
+static int
+set_read_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, fd);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RD_LEASE");
+    return ret;
+}
+
+static int
+set_write_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RW_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RW_LEASE");
+    return ret;
+}
+
+static int
+get_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_GET_LEASE;
+    lease.lease_type = -1;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    GET_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    if (lease.lease_type == GLFS_RD_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE");
+    else if (lease.lease_type == GLFS_RW_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RW_LEASE");
+    else if (lease.lease_type == 3)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
+    else if (lease.lease_type == 0)
+        fprintf(log_file, "\n    Esisting Lease: NONE");
+    else
+        fprintf(log_file, "\n    Existing lease type:%d", lease.lease_type);
+    return lease.lease_type;
+}
+
+static int
+unlk_write_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RW_LEASE");
+    return ret;
+}
+
+static int
+unlk_read_lease(glfs_fd_t *fd, char ld[])
+{
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RD_LEASE");
+    return ret;
+}
+
+glfs_t *
+setup_new_client(char *volname, char *log_fileile)
+{
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(log_file, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+    return fs;
+error:
+    return NULL;
+}
+
+#define OPEN(client, flags, fd, lease_id)                                      \
+    do {                                                                       \
+        int ret_val = 0;                                                       \
+        ret_val = glfs_setfsleaseid(lease_id);                                 \
+        if (ret_val) {                                                         \
+            fprintf(log_file,                                                  \
+                    "\nglfs_setfsleaseid failed with ret: %d (%s)\n", ret,     \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+        fd = glfs_open(client, TEST_FILE, flags);                              \
+        if (fd == NULL) {                                                      \
+            fprintf(log_file, "\nglfs_open failed with ret: %d (%s)\n", ret,   \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define VERIFY_RESULT(test_case, ret, value)                                   \
+    do {                                                                       \
+        if (ret != value) {                                                    \
+            fprintf(log_file,                                                  \
+                    "\n    Testcase %d failed, ret = %d, value=%d\n",          \
+                    test_case, ret, value);                                    \
+            goto error; /*test unsuccessful*/                                  \
+        }                                                                      \
+        fprintf(log_file, "\n    Testcase %d Succeeded\n", test_case);         \
+    } while (0)
+
+static void
+recall_cbk(struct glfs_lease lease, void *data)
+{
+    int ret = -1;
+    char ld[GLFS_LEASE_ID_SIZE] = "";
+
+    fprintf(log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
+    memcpy(ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
+    ret = unlk_write_lease((glfs_fd_t *)data, ld);
+    VERIFY_RESULT(500, ret, SHUD_PASS);
+error:
+    return;
+}
+
+static int
+testcase1_rd_lease()
+{
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for Read lease:");
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
+
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_FAIL);
+
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
+
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase2_wr_lease()
+{
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_WRONLY, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, GLFS_RW_LEASE);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
+
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_FAIL);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase3_rd_wr_lease()
+{
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for Read Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE));
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, GLFS_RD_LEASE);
+
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, NONE);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase4_rd_lease_multi_clnt()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for multi client Read lease:");
+
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
+
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDONLY, fd2, lid2);
+
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
+
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
+
+    ret = get_lease(fd2, lid2);
+    VERIFY_RESULT(7, ret, NONE);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase5_openfd_multi_lid()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for multi lid openfd check:");
+
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
+
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
+    OPEN(client2, O_RDWR, fd3, lid2);
+
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(
+        1, ret,
+        SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/
+
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(
+        2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
+
+    ret = glfs_close(fd3);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase6_openfd_same_lid()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for same lid openfd check:");
+
+    /* Open fd on client 2 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid2);
+    OPEN(client1, O_RDWR, fd2, lid2);
+
+    ret = set_write_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = unlk_write_lease(fd1, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase7_rd_multi_lid()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for multi lease id Read lease:");
+
+    /* Open fd on client 1 in RD mode */
+    OPEN(client2, O_RDONLY, fd1, lid2);
+
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
+
+    ret = set_read_lease(fd1, lid2);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    ret = set_read_lease(fd2, lid3);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
+
+    ret = unlk_read_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    ret = unlk_read_lease(fd2, lid3);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(6, ret, NONE);
+
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(7, ret, NONE);
+
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase8_client_disconnect()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for client disconnect cleanup");
+
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, GLFS_RD_LEASE);
+
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE));
+
+    ret = glfs_fini(client1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
+
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(6, ret, NONE);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
+
+    client1 = setup_new_client(volname, glfs_log_file);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase9_recall_conflict_lease()
+{
+    struct glfs_object *obj = NULL;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    fprintf(log_file,
+            "\n Basic test case for conflicting lease causing recall");
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    obj = glfs_h_lookupat(client2, NULL, TEST_FILE, NULL, 0);
+    ret = glfs_h_lease(client2, obj, &lease);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    sleep(3);
+    ret = glfs_h_close(obj);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+static int
+testcase10_recall_open_conflict()
+{
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
+
+    fprintf(log_file, "\n Basic test case for conflicting open causing recall");
+
+    /* Open fd on client 1 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    /* Open fd on client 1 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
+
+    /* TODO: Check for recall cbk functionality */
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
+
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+
+    return 0;
+error:
+    return -1;
+}
+
+int
+main(int argc, char *argv[])
+{
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    int x = 0;
+    ssize_t xattr_size = -1;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <Vol> <glfs client log file> "
+                "<testcase log file>\n",
+                argv[0]);
+        return -1;
+    }
+
+    log_file = fopen(argv[3], "w");
+    if (!log_file)
+        goto error;
+
+    volname = argv[1];
+    glfs_log_file = argv[2];
+
+    /* Setup 3 clients */
+    client1 = setup_new_client(volname, glfs_log_file);
+    client2 = setup_new_client(volname, glfs_log_file);
+    client3 = setup_new_client(volname, glfs_log_file);
+
+    ret = testcase1_rd_lease();
+    VERIFY_RESULT(101, ret, SHUD_PASS);
+
+    ret = testcase2_wr_lease();
+    VERIFY_RESULT(102, ret, SHUD_PASS);
+
+    ret = testcase3_rd_wr_lease();
+    VERIFY_RESULT(103, ret, SHUD_PASS);
+
+    ret = testcase4_rd_lease_multi_clnt();
+    VERIFY_RESULT(104, ret, SHUD_PASS);
+
+    ret = testcase5_openfd_multi_lid();
+    VERIFY_RESULT(105, ret, SHUD_PASS);
+
+    ret = testcase6_openfd_same_lid();
+    VERIFY_RESULT(106, ret, SHUD_PASS);
+
+    ret = testcase7_rd_multi_lid();
+    VERIFY_RESULT(107, ret, SHUD_PASS);
+
+    ret = testcase8_client_disconnect();
+    VERIFY_RESULT(108, ret, SHUD_PASS);
+
+    ret = testcase9_recall_conflict_lease();
+    VERIFY_RESULT(109, ret, SHUD_PASS);
+
+    ret = testcase10_recall_open_conflict();
+    VERIFY_RESULT(110, ret, SHUD_PASS);
+
+    glfs_fini(client1);
+    glfs_fini(client2);
+    glfs_fini(client3);
+
+    fclose(log_file);
+    return 0;
+error:
+    return -1;
+}
diff --git a/tests/features/glfs-lease.t b/tests/features/glfs-lease.t
new file mode 100755
index 00000000000..6ef6da05043
--- /dev/null
+++ b/tests/features/glfs-lease.t
@@ -0,0 +1,31 @@
+#!/bin/bash
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0};
+TEST $CLI volume set $V0 leases on
+TEST $CLI volume set $V0 open-behind off
+TEST $CLI volume set $V0 write-behind on
+TEST $CLI volume start $V0
+
+logdir=`gluster --print-logdir`
+TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST mkdir $M0/test
+TEST touch $M0/test/lease
+
+build_tester $(dirname $0)/glfs-lease.c -lgfapi
+build_tester $(dirname $0)/glfs-lease-recall.c -lgfapi
+TEST $(dirname $0)/glfs-lease $V0 $logdir/glfs-lease.log $logdir/lease-test.log
+TEST $(dirname $0)/glfs-lease-recall $V0 $logdir/glfs-lease-recall.log $logdir/lease-test-recall.log
+
+TEST $CLI volume set $V0 leases off
+
+cleanup_tester $(dirname $0)/glfs-lease
+cleanup;
diff --git a/tests/features/glupy.t b/tests/features/glupy.t
deleted file mode 100755
index faa4cf33a14..00000000000
--- a/tests/features/glupy.t
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-
-echo $PYTHON_PATH >&2
-cleanup;
-
-TEST mkdir -p $B0/glupytest
-cat > $B0/glupytest.vol <<EOF
-volume vol-posix
-    type storage/posix
-    option directory $B0/glupytest
-end-volume
-
-volume vol-glupy
-    type features/glupy
-    option module-name helloworld
-    subvolumes vol-posix
-end-volume
-EOF
-
-TEST glusterfs -f $B0/glupytest.vol -l $LOGDIR/glupy.log $M0;
-
-TEST touch $M0/filename;
-EXPECT "filename" ls $M0
-TEST rm -f $M0/filename;
-
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
-
-cleanup;
diff --git a/tests/features/interrupt.t b/tests/features/interrupt.t
new file mode 100644
index 00000000000..067eb1b7486
--- /dev/null
+++ b/tests/features/interrupt.t
@@ -0,0 +1,71 @@
+#!/bin/bash
+
+##Copy this file to tests/bugs before running run.sh (cp extras/test/bug-920583.t tests/bugs/)
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+TESTS_EXPECTED_IN_LOOP=4
+
+cleanup;
+logdir=`gluster --print-logdir`
+
+TEST build_tester $(dirname $0)/open_and_sleep.c
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6,7,8,9};
+
+## Verify volume is is created
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+
+## Start volume and verify
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+function log-file-name()
+{
+    logfilename=$M0".log"
+    echo ${logfilename:1} | tr / -
+}
+
+log_file=$logdir"/"`log-file-name`
+
+function test_interrupt {
+        local handlebool="$1"
+        local logpattern="$2"
+
+        TEST $GFS --volfile-id=$V0 --volfile-server=$H0 --fuse-flush-handle-interrupt=$handlebool --log-level=DEBUG $M0
+
+        # If the test helper fails (which is considered a setup error, not failure of the test
+        # case itself), kill will be invoked without argument, and that will be the actual
+        # error which is caught.
+        TEST "./$(dirname $0)/open_and_sleep $M0/testfile-$handlebool | { sleep 0.1; xargs -n1 kill -INT; }"
+
+        TEST "grep -E '$logpattern' $log_file"
+        # Basic sanity check, making sure filesystem has not crashed.
+        TEST test -f $M0/testfile-$handlebool
+}
+
+# Theoretically FLUSH might finish before INTERRUPT is handled,
+# in which case we'd get the "no handler found" message instead of
+# "interrupt handler triggered" (but it's unlikely).
+# If that's observed, the pattern can be changed to
+# 'FLUSH.*interrupt handler triggered|[I]NTERRUPT.*no handler found'
+# to fix the test.
+test_interrupt yes '[F]LUSH.*interrupt handler triggered'
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
+test_interrupt no '[I]NTERRUPT.*no handler found'
+
+## Finish up
+TEST $CLI volume stop $V0;
+EXPECT 'Stopped' volinfo_field $V0 'Status';
+
+TEST $CLI volume delete $V0;
+TEST ! $CLI volume info $V0;
+
+cleanup_tester $(dirname $0)/open_and_sleep;
+cleanup;
diff --git a/tests/features/ipctest.py b/tests/features/ipctest.py
index 5aff319b8d0..f6f699cf5c4 100755
--- a/tests/features/ipctest.py
+++ b/tests/features/ipctest.py
@@ -1,25 +1,19 @@
-#!/usr/bin/python
 
+from __future__ import print_function
 import ctypes
-import ctypes.util
 
-# find_library does not lookup LD_LIBRARY_PATH and may miss the
-# function. In that case, retry with less portable but explicit name.
-libgfapi = ctypes.util.find_library("gfapi")
-if libgfapi == None:
-	libgfapi = "libgfapi.so"
-api = ctypes.CDLL(libgfapi,mode=ctypes.RTLD_GLOBAL)
+api = ctypes.CDLL("libgfapi.so", mode=ctypes.RTLD_GLOBAL)
 
 api.glfs_ipc.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p ]
 api.glfs_ipc.restype = ctypes.c_int
 
 def do_ipc (host, volume):
 	fs = api.glfs_new(volume)
-	#api.glfs_set_logging(fs,"/dev/stderr",7)
-	api.glfs_set_volfile_server(fs,"tcp",host,24007)
+	#api.glfs_set_logging(fs, "/dev/stderr", 7)
+	api.glfs_set_volfile_server(fs, "tcp", host, 24007)
 
 	api.glfs_init(fs)
-	ret  = api.glfs_ipc(fs,1470369258,0,0)
+	ret  = api.glfs_ipc(fs, 1470369258, 0, 0)
 	api.glfs_fini(fs)
 
 	return ret
@@ -28,7 +22,7 @@ if __name__ == "__main__":
 	import sys
 
 	try:
-		res = apply(do_ipc,sys.argv[1:3])
-		print res
+		res = do_ipc(*sys.argv[1:3])
+		print(res)
 	except:
-		print "IPC failed (volume not started?)"
+		print("IPC failed (volume not started?)")
diff --git a/tests/features/leases.t b/tests/features/leases.t
deleted file mode 100755
index 27f0405cfb1..00000000000
--- a/tests/features/leases.t
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-
-cleanup;
-
-## Start and create a volume
-TEST glusterd;
-TEST pidof glusterd;
-TEST $CLI volume info;
-
-TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2};
-TEST $CLI volume start $V0
-TEST $CLI volume set $V0 leases on
-
-TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0;
-TEST mkdir $M0/test
-TEST touch $M0/test/lease
-
-TEST $CLI volume set $V0 leases off
-
-cleanup;
diff --git a/tests/features/mandatory-lock-forced.c b/tests/features/mandatory-lock-forced.c
index f37206845f1..4028d6c6eaf 100644
--- a/tests/features/mandatory-lock-forced.c
+++ b/tests/features/mandatory-lock-forced.c
@@ -6,133 +6,138 @@
 #include <string.h>
 #include <sys/wait.h>
 
-#define LOG_ERR(func, err) do {                                                \
-        fprintf (stderr, "%s : returned error (%s)\n", func, strerror(err));   \
-        exit (err);                                                            \
-} while (0)
-
-int       fd;
-struct    flock lock;
-char      *buf = "ten bytes!";
-char      *fname = "/mnt/glusterfs/0/mand.lock";
-int       open_flags, child, err, status, blocked = 0;
-
-int do_child (char *argv[]) {
-        /* Initialize file open flags */
-        if (strcmp (argv[2], "BLOCK") == 0)
-                open_flags = O_RDWR;
-        else if (strcmp (argv[2], "TRUNC") == 0)
-                open_flags = O_RDWR | O_TRUNC | O_NONBLOCK;
-        else if (strcmp (argv[2], "NONE") == 0)
-                open_flags = O_RDWR | O_NONBLOCK;
-        else
-                LOG_ERR ("Invalid option:", EINVAL);
-
-        /* Open the file */
-        fd = open (fname, open_flags);
-        if (fd == -1)
-                LOG_ERR ("Child open", errno);
-
-        /* Perform the file operation*/
-        if (strcmp (argv[3], "READ") == 0) {
-                buf = NULL;
-                err = read (fd, buf, 10);
-                if (err == -1)
-                        LOG_ERR ("Child read", errno);
-        } else if (strcmp (argv[3], "WRITE") == 0) {
-                err = write (fd, buf, 10);
-                if (err == -1)
-                        LOG_ERR ("Child write", errno);
-        } else if (strcmp (argv[3], "FTRUNCATE") == 0) {
-                err = ftruncate (fd, 5);
-                if (err)
-                        LOG_ERR ("Child ftruncate", errno);
-        } else
-                LOG_ERR ("Invalid operation:", EINVAL);
-
-        /* Close child fd */
-        err = close (fd);
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        fprintf(stderr, "%s : returned error (%s)\n", func, strerror(err));    \
+        exit(err);                                                             \
+    } while (0)
+
+int fd;
+struct flock lock;
+char *buf = "ten bytes!";
+char *fname = "/mnt/glusterfs/0/mand.lock";
+int open_flags, child, err, status, blocked = 0;
+
+int
+do_child(char *argv[])
+{
+    /* Initialize file open flags */
+    if (strcmp(argv[2], "BLOCK") == 0)
+        open_flags = O_RDWR;
+    else if (strcmp(argv[2], "TRUNC") == 0)
+        open_flags = O_RDWR | O_TRUNC | O_NONBLOCK;
+    else if (strcmp(argv[2], "NONE") == 0)
+        open_flags = O_RDWR | O_NONBLOCK;
+    else
+        LOG_ERR("Invalid option:", EINVAL);
+
+    /* Open the file */
+    fd = open(fname, open_flags);
+    if (fd == -1)
+        LOG_ERR("Child open", errno);
+
+    /* Perform the file operation*/
+    if (strcmp(argv[3], "READ") == 0) {
+        buf = NULL;
+        err = read(fd, buf, 10);
+        if (err == -1)
+            LOG_ERR("Child read", errno);
+    } else if (strcmp(argv[3], "WRITE") == 0) {
+        err = write(fd, buf, 10);
+        if (err == -1)
+            LOG_ERR("Child write", errno);
+    } else if (strcmp(argv[3], "FTRUNCATE") == 0) {
+        err = ftruncate(fd, 5);
         if (err)
-                LOG_ERR ("Child close", errno);
+            LOG_ERR("Child ftruncate", errno);
+    } else
+        LOG_ERR("Invalid operation:", EINVAL);
 
-        /* Exit success */
-        exit (0);
+    /* Close child fd */
+    err = close(fd);
+    if (err)
+        LOG_ERR("Child close", errno);
+
+    /* Exit success */
+    exit(0);
 }
 
-int main (int argc, char *argv[]) {
-        if (argc < 4) {
-                fprintf (stderr, "Wrong usage: Use as ./mandatory-lock "
-                                "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> "
-                                "<READ/WRITE/FTRUNCATE\n");
-                exit(EINVAL);
+int
+main(int argc, char *argv[])
+{
+    if (argc < 4) {
+        fprintf(stderr,
+                "Wrong usage: Use as ./mandatory-lock "
+                "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> "
+                "<READ/WRITE/FTRUNCATE\n");
+        exit(EINVAL);
+    }
+    /* Create an empty lock file */
+    fd = open(fname, O_CREAT | O_RDWR, 0755);
+    if (fd == -1)
+        LOG_ERR("Parent create", errno);
+
+    /* Determine the type of lock */
+    if (strcmp(argv[1], "RD_LCK") == 0)
+        lock.l_type = F_RDLCK;
+    else if (strcmp(argv[1], "WR_LCK") == 0)
+        lock.l_type = F_WRLCK;
+    else
+        LOG_ERR("Parent lock type", EINVAL);
+
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 0L;
+
+    /* Let parent acquire the initial lock */
+    err = fcntl(fd, F_SETLK, &lock);
+    if (err)
+        LOG_ERR("Parent lock", errno);
+
+    /* Now fork a child */
+    child = fork();
+    if (child == 0)
+        /* Perform the child operations */
+        do_child(argv);
+    else {
+        /* If blocking mode, then sleep for 2 seconds
+         * and wait for the child */
+        if (strcmp(argv[2], "NONE") != 0) {
+            sleep(2);
+            if (waitpid(child, &status, WNOHANG) == 0)
+                blocked = 1;
+            /* Release the parent lock so that the
+             * child can terminate */
+            lock.l_type = F_UNLCK;
+            err = fcntl(fd, F_SETLK, &lock);
+            if (err)
+                LOG_ERR("Parent unlock", errno);
         }
-        /* Create an empty lock file */
-        fd = open (fname, O_CREAT | O_RDWR, 0755);
-        if (fd == -1)
-                LOG_ERR ("Parent create", errno);
-
-        /* Determine the type of lock */
-        if (strcmp (argv[1], "RD_LCK") == 0)
-                lock.l_type = F_RDLCK;
-        else if (strcmp (argv[1], "WR_LCK") == 0)
-                lock.l_type = F_WRLCK;
-        else
-                LOG_ERR ("Parent lock type", EINVAL);
-
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 0L;
-
-        /* Let parent acquire the initial lock */
-        err = fcntl (fd, F_SETLK, &lock);
+
+        /* Wait for child to finish */
+        waitpid(child, &status, 0);
+
+        /* Close the parent fd */
+        err = close(fd);
         if (err)
-                LOG_ERR ("Parent lock", errno);
-
-        /* Now fork a child */
-        child = fork ();
-        if (child == 0)
-                /* Perform the child operations */
-                do_child (argv);
-        else {
-                /* If blocking mode, then sleep for 2 seconds
-                 * and wait for the child */
-                if (strcmp (argv[2], "NONE") != 0) {
-                        sleep (2);
-                        if (waitpid (child, &status, WNOHANG) == 0)
-                                blocked = 1;
-                        /* Release the parent lock so that the
-                         * child can terminate */
-                        lock.l_type = F_UNLCK;
-                        err = fcntl (fd, F_SETLK, &lock);
-                        if (err)
-                                LOG_ERR ("Parent unlock", errno);
-                }
-
-                /* Wait for child to finish */
-                waitpid (child, &status, 0);
-
-                /* Close the parent fd */
-                err = close (fd);
-                if (err)
-                        LOG_ERR ("Parent close", errno);
-
-                /* Remove the lock file*/
-                err = unlink (fname);
-                if (err)
-                        LOG_ERR ("Parent unlink", errno);
-
-                /* If not blocked, exit with child exit status*/
-                errno = WEXITSTATUS(status);
-
-                /* If blocked, exit with corresponding
-                 * error code */
-                if (blocked)
-                        errno = EWOULDBLOCK;
-
-                if (errno != 0)
-                        printf ("%s\n", strerror(errno));
-
-                exit (errno);
+            LOG_ERR("Parent close", errno);
 
-        }
+        /* Remove the lock file*/
+        err = unlink(fname);
+        if (err)
+            LOG_ERR("Parent unlink", errno);
+
+        /* If not blocked, exit with child exit status*/
+        errno = WEXITSTATUS(status);
+
+        /* If blocked, exit with corresponding
+         * error code */
+        if (blocked)
+            errno = EWOULDBLOCK;
+
+        if (errno != 0)
+            printf("%s\n", strerror(errno));
+
+        exit(errno);
+    }
 }
diff --git a/tests/features/nuke.t b/tests/features/nuke.t
index ace847bc99b..f1f5f9f90ab 100755
--- a/tests/features/nuke.t
+++ b/tests/features/nuke.t
@@ -20,7 +20,7 @@ LANDFILL=$B0/${V0}1/.glusterfs/landfill
 
 TEST glusterd
 
-TEST $CLI volume create $V0 $H0:$B0/${V0}1
+TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
 TEST $CLI volume start $V0
 TEST $GFS -s $H0 --volfile-id $V0 $M0
 
diff --git a/tests/features/open_and_sleep.c b/tests/features/open_and_sleep.c
new file mode 100644
index 00000000000..7d0e22a2503
--- /dev/null
+++ b/tests/features/open_and_sleep.c
@@ -0,0 +1,27 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+
+int
+main(int argc, char **argv)
+{
+    pid_t pid;
+    int fd;
+
+    if (argc >= 2) {
+        fd = open(argv[1], O_RDWR | O_CREAT, 0644);
+        if (fd == -1) {
+            fprintf(stderr, "cannot open/create %s\n", argv[1]);
+            return 1;
+        }
+    }
+
+    pid = getpid();
+    printf("%d\n", pid);
+    fflush(stdout);
+
+    for (;;)
+        sleep(1);
+
+    return 0;
+}
diff --git a/tests/features/recon.t b/tests/features/recon.t
new file mode 100644
index 00000000000..82ef6fd755d
--- /dev/null
+++ b/tests/features/recon.t
@@ -0,0 +1,59 @@
+#!/bin/bash
+
+. $(dirname $0)/../traps.rc
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../fdl.rc
+
+tmpdir=$(mktemp -d -t ${0##*/}.XXXXXX)
+push_trapfunc "rm -rf $tmpdir"
+
+write_file () {
+	echo "peekaboo" > $1
+}
+
+TEST rm -f $FDL_META_FILE $FDL_DATA_FILE
+TEST glusterd
+TEST pidof glusterd
+
+# Get a simple volume set up and mounted with FDL active.
+TEST $CLI volume create $V0 ${H0}:${B0}/${V0}-0
+TEST $CLI volume set $V0 features.fdl on
+TEST $CLI volume start $V0
+TEST $GFS -s $H0 --volfile-id $V0 $M0
+
+# Generate some I/O and then copy off the journal files for later.
+TEST mkdir -p $M0/abc/def
+TEST write_file $M0/abc/def/ghi
+#EST chmod 314 $M0/abc/def/ghi
+cp ${FDL_META_FILE} ${FDL_DATA_FILE} ${tmpdir}
+
+# Get back to an empty state and unmount.
+TEST rm -rf $M0/abc
+TEST umount $M0
+
+# Make sure we really are in an empty state.  Otherwise the tests below could
+# pass just because we never cleaned up in the first place.
+TEST [ ! -d ${B0}/${V0}-0/abc ]
+
+# Create a stub volfile.
+vol_file=${GLUSTERD_WORKDIR}/vols/${V0}/${V0}.${H0}.${log_id}.vol
+vol_id_line=$(grep volume-id ${vol_file})
+cat > ${tmpdir}/recon.vol << EOF
+volume recon-posix
+    type storage/posix
+    option directory ${B0}/${V0}-0
+${vol_id_line}
+end-volume
+EOF
+
+TEST gf_recon ${tmpdir}/recon.vol ${tmpdir}/$(basename ${FDL_META_FILE}) \
+				  ${tmpdir}/$(basename ${FDL_DATA_FILE})
+
+TEST [ -d ${B0}/${V0}-0/abc/def ]
+EXPECT "peekaboo" cat ${B0}/${V0}-0/abc/def/ghi
+# TBD: test permissions, xattrs
+
+cleanup
+#G_TESTDEF_TEST_STATUS_CENTOS6=KNOWN_ISSUE,BUG=1385758
+#G_TESTDEF_TEST_STATUS_NETBSD7=KNOWN_ISSUE,BUG=1385758
diff --git a/tests/features/ssl-authz.t b/tests/features/ssl-authz.t
index 3cb45b5e582..497083e5a3a 100755
--- a/tests/features/ssl-authz.t
+++ b/tests/features/ssl-authz.t
@@ -25,6 +25,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
+TEST $CLI v set all cluster.brick-multiplex on
 # Construct a cipher list that excludes CBC because of POODLE.
 # http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-3566
 #
@@ -41,16 +42,16 @@ function valid_ciphers {
 		-e '/:$/s///'
 }
 
-TEST openssl genrsa -out $SSL_KEY 1024
+TEST openssl genrsa -out $SSL_KEY 2048
 TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
 ln $SSL_CERT $SSL_CA
 
-TEST $CLI volume create $V0 $H0:$B0/1
+TEST $CLI volume create $V0 replica 3 $H0:$B0/{1,2,3} force
 TEST $CLI volume set $V0 server.ssl on
 TEST $CLI volume set $V0 client.ssl on
 TEST $CLI volume set $V0 ssl.cipher-list $(valid_ciphers)
 TEST $CLI volume start $V0
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" online_brick_count
 
 # This mount should SUCCEED because ssl-allow=* by default.  This effectively
 # disables SSL authorization, though authentication and encryption might still
@@ -59,11 +60,28 @@ TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
 TEST ping_file $M0/before
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 
+glusterfsd_pid=`pgrep glusterfsd`
+TEST [ $glusterfsd_pid != 0 ]
+start=`pmap -x $glusterfsd_pid | grep total | awk -F " " '{print $4}'`
+echo "Memory consumption for glusterfsd process"
+for i in $(seq 1 100); do
+        gluster v heal $V0 info >/dev/null
+done
+#Wait to cleanup memory
+sleep 10
+end=`pmap -x $glusterfsd_pid | grep total | awk -F " " '{print $4}'`
+diff=$((end-start))
+
+# If memory consumption is more than 15M some leak in SSL code path
+
+TEST [ $diff -lt 15000 ]
+
+
 # Set ssl-allow to a wildcard that includes our identity.
 TEST $CLI volume stop $V0
 TEST $CLI volume set $V0 auth.ssl-allow Any*
 TEST $CLI volume start $V0
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
+EXPECT_WITHIN $CHILD_UP_TIMEOUT "3" online_brick_count
 
 # This mount should SUCCEED because we match the wildcard.
 TEST glusterfs --volfile-server=$H0 --volfile-id=$V0 $M0
diff --git a/tests/features/ssl-ciphers.t b/tests/features/ssl-ciphers.t
index 563d37c5277..b70fe360e02 100644
--- a/tests/features/ssl-ciphers.t
+++ b/tests/features/ssl-ciphers.t
@@ -33,18 +33,26 @@ wait_mount() {
 openssl_connect() {
 	ssl_opt="-verify 3 -verify_return_error -CAfile $SSL_CA"
 	ssl_opt="$ssl_opt -crl_check_all -CApath $TMPDIR"
-	#echo openssl s_client $ssl_opt $@ > /dev/tty
-	#read -p "Continue? " nothing
-	CIPHER=`echo "" |
-                openssl s_client $ssl_opt $@ 2>/dev/null |
-		awk '/^    Cipher/{print $3}'`
-	if [ "x${CIPHER}" = "x" -o "x${CIPHER}" = "x0000" ] ; then
+        cmd="echo "" | openssl s_client $ssl_opt $@ 2>/dev/null"
+        CIPHER=$(eval $cmd | awk -F "Cipher is" '{print $2}' | tr -d '[:space:]' | awk -F " " '{print $1}')
+	if [ "x${CIPHER}" = "x" -o "x${CIPHER}" = "x0000" -o "x${CIPHER}" = "x(NONE)" ] ; then
 		echo "N"
 	else
 		echo "Y"
 	fi
 }
 
+#Validate the cipher to pass EXPECT test case before call openssl_connect
+check_cipher() {
+       cmd="echo "" | openssl s_client $@ 2> /dev/null"
+       cipher=$(eval $cmd |awk -F "Cipher is" '{print $2}' | tr -d '[:space:]' | awk -F " " '{print $1}')
+       if [ "x${cipher}" = "x" -o "x${cipher}" = "x0000" -o "x${cipher}" = "x(NONE)" ] ; then
+                echo "N"
+        else
+                echo "Y"
+       fi
+}
+
 cleanup;
 mkdir -p $B0
 mkdir -p $M0
@@ -65,7 +73,7 @@ TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info;
 
-TEST openssl genrsa -out $SSL_KEY 1024 2>/dev/null
+TEST openssl genrsa -out $SSL_KEY 2048 2>/dev/null
 TEST openssl req -config $SSL_CFG -new -key $SSL_KEY -x509 \
                   -subj /CN=CA -out $SSL_CA
 TEST openssl req -config $SSL_CFG -new -key $SSL_KEY \
@@ -102,32 +110,47 @@ EXPECT "N" openssl_connect -ssl2 -connect $H0:$BRICK_PORT
 # Test SSLv3 protocol fails
 EXPECT "N" openssl_connect -ssl3 -connect $H0:$BRICK_PORT
 
-# Test TLSv1 protocol fails
-EXPECT "N" openssl_connect -tls1 -connect $H0:$BRICK_PORT
+# Test TLSv1 protocol based on openssl version
+cmd="openssl version"
+ver=$(eval $cmd | awk -F " " '{print $2}' | grep "^1.1")
+if [ "x${ver}" = "x" ]; then
+    supp="N"
+else
+    supp="Y"
+fi
+EXPECT "${supp}" openssl_connect -tls1 -connect $H0:$BRICK_PORT
 
 # Test a HIGH CBC cipher
-EXPECT "Y" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
 
 # Test EECDH
-EXPECT "Y" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
 
 # test MD5 fails
-EXPECT "N" openssl_connect -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT
 
 # test RC4 fails
-EXPECT "N" openssl_connect -cipher RC4-SHA -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher RC4-SHA -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher RC4-SHA -connect $H0:$BRICK_PORT
 
 # test eNULL fails
-EXPECT "N" openssl_connect -cipher NULL-SHA256 -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher NULL-SHA256 -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher NULL-SHA256 -connect $H0:$BRICK_PORT
 
 # test SHA2
-EXPECT "Y" openssl_connect -cipher AES256-SHA256 -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES256-SHA256 -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES256-SHA256 -connect $H0:$BRICK_PORT
 
 # test GCM
-EXPECT "Y" openssl_connect -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT
 
 # Test DH fails without DH params
-EXPECT "N" openssl_connect -cipher EDH -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher EDH -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher EDH -connect $H0:$BRICK_PORT
 
 # Test DH with DH params
 TEST $CLI volume set $V0 ssl.dh-param `pwd`/`dirname $0`/dh1024.pem
@@ -145,8 +168,10 @@ TEST $CLI volume stop $V0
 TEST $CLI volume start $V0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
 BRICK_PORT=`brick_port $V0`
-EXPECT "Y" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
-EXPECT "N" openssl_connect -cipher AES128-SHA -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES128-SHA -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES128-SHA -connect $H0:$BRICK_PORT
 
 # Test the ec-curve option
 TEST $CLI volume set $V0 ssl.cipher-list EECDH:EDH:!TLSv1
@@ -155,8 +180,10 @@ TEST $CLI volume stop $V0
 TEST $CLI volume start $V0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
 BRICK_PORT=`brick_port $V0`
-EXPECT "N" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
-EXPECT "Y" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
 
 TEST $CLI volume set $V0 ssl.ec-curve invalid
 EXPECT invalid volume_option $V0 ssl.ec-curve
@@ -164,7 +191,8 @@ TEST $CLI volume stop $V0
 TEST $CLI volume start $V0
 EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
 BRICK_PORT=`brick_port $V0`
-EXPECT "N" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
 
 TEST $CLI volume set $V0 ssl.ec-curve secp521r1
 EXPECT secp521r1 volume_option $V0 ssl.ec-curve
@@ -175,8 +203,6 @@ BRICK_PORT=`brick_port $V0`
 EXPECT "Y" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
 
 # test revocation
-# no need to restart the volume since the options are used
-# by the client here.
 TEST $CLI volume set $V0 ssl.crl-path $TMPDIR
 EXPECT $TMPDIR volume_option $V0 ssl.crl-path
 $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
@@ -189,14 +215,25 @@ TEST openssl ca -batch -config $SSL_CFG -revoke $SSL_CERT 2>&1
 TEST openssl ca -config $SSL_CFG -gencrl -out $SSL_CRL 2>&1
 
 # Failed once revoked
+# Although client fails to mount without restarting the server after crl-path
+# is set when no actual crl file is found on the client, it would also fail
+# when server is restarted for the same reason. Since the socket initialization
+# code is the same for client and server, the crl verification flags need to
+# be turned off for the client to avoid SSL searching for CRLs in the
+# ssl.crl-path. If no CRL files are found in the ssl.crl-path, SSL fails the
+# connect() attempt on the client.
+TEST $CLI volume stop $V0
+TEST $CLI volume start $V0
 $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
 EXPECT "N" wait_mount $M0
 TEST ! test -f $TEST_FILE
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 
 # Succeed with CRL disabled
+TEST $CLI volume stop $V0
 TEST $CLI volume set $V0 ssl.crl-path NULL
 EXPECT NULL volume_option $V0 ssl.crl-path
+TEST $CLI volume start $V0
 $GFS --volfile-id=$V0 --volfile-server=$H0 $M0
 EXPECT "Y" wait_mount $M0
 TEST test -f $TEST_FILE
diff --git a/tests/features/subdir-mount.t b/tests/features/subdir-mount.t
index 1742f8655e8..a02bd6befc4 100644
--- a/tests/features/subdir-mount.t
+++ b/tests/features/subdir-mount.t
@@ -85,12 +85,17 @@ TEST $CLI volume start $V0
 TEST $GFS --subdir-mount /subdir1/subdir1.1/subdir1.2 -s $H0 --volfile-id $V0 $M2
 TEST stat $M2
 
+initcnt=`grep -i create-subdir-mounts /var/log/glusterfs/glusterd.log  | wc -l`
 # mount shouldn't fail even after add-brick
 TEST $CLI volume add-brick $V0 replica 2 $H0:$B0/${V0}{5,6};
 
-# Give time for client process to get notified and use the new
-# volfile after add-brick
-sleep 1
+# Wait to execute create-subdir-mounts.sh script by glusterd
+newcnt=`grep -i create-subdir-mounts /var/log/glusterfs/glusterd.log  | wc -l`
+while [ $newcnt -eq $initcnt ]
+do
+   newcnt=`grep -i create-subdir-mounts /var/log/glusterfs/glusterd.log  | wc -l`
+   sleep 1
+done
 
 # Existing mount should still be active
 mount_inode=$(stat --format "%i" "$M2")
@@ -98,22 +103,14 @@ TEST test "$mount_inode" == "1"
 
 TEST umount $M2
 
-# because the subdir is not yet 'healed', below should fail.
+# Now the exported subdirs should be automatically healed due to
+# hook scripts. Check if the mount is successful.
 TEST $GFS --subdir-mount /subdir2 -s $H0 --volfile-id $V0 $M2
 mount_inode=$(stat --format "%i" "$M2")
-TEST test "$mount_inode" != "1"
-
-# Allow the heal to complete
-TEST stat $M0/subdir1/subdir1.1/subdir1.2/subdir1.2_file;
-TEST stat $M0/subdir2/
-
-# Now the mount should succeed
-TEST $GFS --subdir-mount /subdir2 -s $H0 --volfile-id $V0 $M1
-TEST stat $M1
+TEST test "$mount_inode" == "1"
 
-# umount $M1 / $M2
 TEST umount $M0
-TEST umount $M1
+TEST umount $M2
 
 
 TEST $CLI volume stop $V0;
diff --git a/tests/features/trash.t b/tests/features/trash.t
index 472e909e567..da5b50bc85a 100755
--- a/tests/features/trash.t
+++ b/tests/features/trash.t
@@ -94,105 +94,105 @@ wildcard_not_exists() {
         if [ $? -eq 0 ]; then echo "Y"; else echo "N"; fi
 }
 
-# testing glusterd [1-3]
+# testing glusterd
 TEST glusterd
 TEST pidof glusterd
 TEST $CLI volume info
 
-# creating distributed volume [4]
+# creating distributed volume
 TEST $CLI volume create $V0 $H0:$B0/${V0}{1,2}
 
-# checking volume status [5-7]
+# checking volume status
 EXPECT "$V0" volinfo_field $V0 'Volume Name'
 EXPECT 'Created' volinfo_field $V0 'Status'
 EXPECT '2' brick_count $V0
 
-# test without enabling trash translator [8]
+# test without enabling trash translator
 TEST start_vol $V0 $M0
 
-# test on enabling trash translator [9-10]
+# test on enabling trash translator
 TEST $CLI volume set $V0 features.trash on
 EXPECT 'on' volinfo_field $V0 'features.trash'
 
-# files directly under mount point [11]
+# files directly under mount point
 create_files $M0/file1 $M0/file2
 TEST file_exists $V0 file1 file2
 
-# perform unlink [12]
+# perform unlink
 TEST unlink_op file1
 
-# perform truncate [13]
+# perform truncate
 TEST truncate_op file2 4
 
-# create files directory hierarchy and check [14]
+# create files directory hierarchy and check
 mkdir -p $M0/1/2/3
 create_files $M0/1/2/3/foo1 $M0/1/2/3/foo2
 TEST file_exists $V0 1/2/3/foo1 1/2/3/foo2
 
-# perform unlink [15]
+# perform unlink
 TEST unlink_op 1/2/3/foo1
 
-# perform truncate [16]
+# perform truncate
 TEST truncate_op 1/2/3/foo2 4
 
 # create a directory for eliminate pattern
 mkdir $M0/a
 
-# set the eliminate pattern [17-18]
+# set the eliminate pattern
 TEST $CLI volume set $V0 features.trash-eliminate-path /a
 EXPECT '/a' volinfo_field $V0 'features.trash-eliminate-path'
 
-# create two files and check [19]
+# create two files and check
 create_files $M0/a/test1 $M0/a/test2
 TEST file_exists $V0 a/test1 a/test2
 
-# remove from eliminate pattern [20]
+# remove from eliminate pattern
 rm -f $M0/a/test1
 EXPECT "Y" wildcard_not_exists $M0/.trashcan/a/test1*
 
-# truncate from eliminate path [21-23]
+# truncate from eliminate path
 truncate -s 2 $M0/a/test2
 TEST [ -e $M0/a/test2 ]
 TEST [ `ls -l $M0/a/test2 | awk '{print $5}'` -eq 2 ]
 EXPECT "Y" wildcard_not_exists $M0/.trashcan/a/test2*
 
-# set internal op on [24-25]
+# set internal op on
 TEST $CLI volume set $V0 features.trash-internal-op on
 EXPECT 'on' volinfo_field $V0 'features.trash-internal-op'
 
-# again create two files and check [26]
+# again create two files and check
 create_files $M0/inop1 $M0/inop2
 TEST file_exists $V0 inop1 inop2
 
-# perform unlink [27]
+# perform unlink
 TEST unlink_op inop1
 
-# perform truncate [28]
+# perform truncate
 TEST truncate_op inop2 4
 
-# remove one brick and restart the volume [28-31]
+# remove one brick and restart the volume
 TEST $CLI volume remove-brick $V0 $H0:$B0/${V0}2 force
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 TEST $CLI volume stop $V0
 TEST start_vol $V0 $M0 $M0/.trashcan
 
-# again create two files and check [33]
+# again create two files and check
 create_files $M0/rebal1 $M0/rebal2
 TEST file_exists $V0 rebal1 rebal2
 
-# add one brick [34-35]
+# add one brick
 TEST $CLI volume add-brick $V0 $H0:$B0/${V0}3
 TEST [ -d $B0/${V0}3 ]
 
 
-# perform rebalance [36]
+# perform rebalance
 TEST $CLI volume rebalance $V0 start force
 EXPECT_WITHIN $REBALANCE_TIMEOUT "0" rebalance_completed
 
 #Find out which file was migrated to the new brick
 file_name=$(ls $B0/${V0}3/rebal*| xargs basename)
 
-# check whether rebalance was succesful [37-40]
+# check whether rebalance was succesful
 EXPECT "Y" wildcard_exists $B0/${V0}3/$file_name*
 EXPECT "Y" wildcard_exists $B0/${V0}1/.trashcan/internal_op/$file_name*
 
@@ -201,52 +201,42 @@ EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
 # force required in case rebalance is not over
 TEST $CLI volume stop $V0 force
 
-# create a replicated volume [41]
+# create a replicated volume
 TEST $CLI volume create $V1 replica 2 $H0:$B0/${V1}{1,2}
 
-# checking volume status [42-45]
+# checking volume status
 EXPECT "$V1" volinfo_field $V1 'Volume Name'
 EXPECT 'Replicate' volinfo_field $V1 'Type'
 EXPECT 'Created' volinfo_field $V1 'Status'
 EXPECT '2' brick_count $V1
 
-# enable trash with options and start the replicate volume by disabling automatic self-heal [46-50]
+# enable trash with options and start the replicate volume by disabling automatic self-heal
 TEST $CLI volume set $V1 features.trash on
 TEST $CLI volume set $V1 features.trash-internal-op on
 EXPECT 'on' volinfo_field $V1 'features.trash'
 EXPECT 'on' volinfo_field $V1 'features.trash-internal-op'
 TEST start_vol $V1 $M1 $M1/.trashcan
 
-# mount and check for trash directory [51]
+# mount and check for trash directory
 TEST [ -d $M1/.trashcan/internal_op ]
 
-# create a file and check [52]
+# create a file and check
 touch $M1/self
 TEST [ -e $B0/${V1}1/self -a -e $B0/${V1}2/self ]
 
-# kill one brick and delete the file from mount point [53-54]
+# kill one brick and delete the file from mount point
 kill_brick $V1 $H0 $B0/${V1}1
 EXPECT_WITHIN ${PROCESS_UP_TIMEOUT} "1" online_brick_count
 rm -f $M1/self
 EXPECT "Y" wildcard_exists $B0/${V1}2/.trashcan/self*
 
-# force start the volume and trigger the self-heal manually [55-57]
-TEST $CLI volume start $V1 force
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" online_brick_count
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status
-# Since we created the file under root of the volume, it will be
-# healed automatically
-
-# check for the removed file in trashcan [58]
-EXPECT_WITHIN $HEAL_TIMEOUT "Y" wildcard_exists $B0/${V1}1/.trashcan/internal_op/self*
-
-# check renaming of trash directory through cli [59-62]
+# check renaming of trash directory through cli
 TEST $CLI volume set $V0 trash-dir abc
 TEST start_vol $V0 $M0 $M0/abc
 TEST [ -e $M0/abc -a ! -e $M0/.trashcan ]
 EXPECT "Y" wildcard_exists $B0/${V0}1/abc/internal_op/rebal*
 
-# ensure that rename and delete operation on trash directory fails [63-65]
+# ensure that rename and delete operation on trash directory fails
 rm -rf $M0/abc/internal_op
 TEST [ -e $M0/abc/internal_op ]
 rm -rf $M0/abc/
diff --git a/tests/features/unhashed-auto.t b/tests/features/unhashed-auto.t
index ddebd03299d..0a6bbfbb07d 100755
--- a/tests/features/unhashed-auto.t
+++ b/tests/features/unhashed-auto.t
@@ -114,7 +114,7 @@ TEST [ x"$new_hash" = x"00000001" ]
 
 # Unset the option and check that newly created directories get 1 in the
 # disk layout
-TEST $CLI volume reset $V0 cluster.lookup-optimize
+TEST $CLI volume set $V0 cluster.lookup-optimize off
 TEST mkdir $M0/dir1
 new_hash=$(get_xattr_hash $B0/${V0}1/dir1)
 TEST [ x"$new_hash" = x"00000001" ]
diff --git a/tests/features/worm.t b/tests/features/worm.t
index f8f05065918..40b08cdee02 100755
--- a/tests/features/worm.t
+++ b/tests/features/worm.t
@@ -57,6 +57,60 @@ TEST rm -f $M0/file2
 sleep 10
 TEST rm -f $M0/file1
 
+## Test for state transition over write.
+TEST `echo "worm 1" > $M0/file3`
+sleep 5
+TEST `echo "worm 2" >> $M0/file3`
+EXPECT 'worm 1' cat $M0/file3
+TEST ! rm -f $M0/file3
+
+## Test for checking if Worm files are undeletable after setting worm-files-deletable as 0.
+TEST $CLI volume set $V0 features.worm-files-deletable 0
+TEST `echo "worm 1" > $M0/file4`
+TEST chmod 0444 $M0/file4
+sleep 10
+TEST `echo "worm 1" >> $M0/file4`
+TEST ! rm -f $M0/file4
+
+## Test for state transition if auto-commit-period is 0
+TEST $CLI volume set $V0 features.auto-commit-period 0
+TEST `echo "worm 1" > $M0/file5`
+EXPECT '3/10/0' echo $(getfattr -e text --absolute-names --only-value -n "trusted.reten_state" $B0/${V0}1/file5)
+EXPECT 'worm 1' cat $M0/file5
+TEST ! rm -f $M0/file5
+TEST $CLI volume set $V0 features.auto-commit-period 5
+
+## Test for checking if retention-period is updated on increasing the access time of a WORM-RETAINED file.
+TEST $CLI volume set $V0 features.worm-files-deletable 1
+TEST `echo "worm 1" >> $M0/file1`
+initial_timestamp=$(date +%s)
+current_time_seconds=$(date +%S | sed 's/^0*//' );
+TEST chmod 0444 $M0/file1
+EXPECT '3/10/5' echo $(getfattr -e text --absolute-names --only-value -n "trusted.reten_state" $B0/${V0}1/file1)
+changed_timestamp=$(date +%Y%m%d%H%M --date '60 seconds');
+seconds_diff=`expr 60 - $((current_time_seconds))`
+TEST `touch -a -t "${changed_timestamp}" $M0/file1`
+EXPECT "3/$seconds_diff/5" echo $(getfattr -e text --absolute-names --only-value -n "trusted.reten_state" $B0/${V0}1/file1)
+sleep $seconds_diff
+TEST `echo "worm 2" >> $M0/file1`
+EXPECT  "$initial_timestamp" echo $(stat --printf %X $M0/file1)
+
+
+## Test for checking if retention-period is updated on decreasing the access time of a WORM-RETAINED file
+TEST $CLI volume set $V0 features.default-retention-period 120
+initial_timestamp=$(date +%s)
+current_time_seconds=$(date +%S | sed 's/^0*//' );
+TEST chmod 0444 $M0/file1
+EXPECT '3/120/5' echo $(getfattr -e text --absolute-names --only-value -n "trusted.reten_state" $B0/${V0}1/file1)
+changed_timestamp=$(date +%Y%m%d%H%M --date '60 seconds');
+seconds_diff=`expr 60 - $((current_time_seconds))`
+TEST `touch -a -t "${changed_timestamp}" $M0/file1`
+EXPECT "3/$seconds_diff/5" echo $(getfattr -e text --absolute-names --only-value -n "trusted.reten_state" $B0/${V0}1/file1)
+sleep $seconds_diff
+TEST `echo "worm 4" >> $M0/file1`
+EXPECT  "$initial_timestamp" echo $(stat --printf %X $M0/file1)
+TEST rm -f $M0/file1
+
 TEST $CLI volume stop $V0
 EXPECT 'Stopped' volinfo_field $V0 'Status'
 
diff --git a/tests/geo-rep.rc b/tests/geo-rep.rc
index 1a44b4a3941..9ba4262730e 100644
--- a/tests/geo-rep.rc
+++ b/tests/geo-rep.rc
@@ -1,18 +1,75 @@
-function check_status()
-{
-	local search_key=$1
-	$GEOREP_CLI $master $slave status detail | egrep -i "$search_key"
+GEO_REP_TIMEOUT=120
+CHECK_MOUNT_TIMEOUT=50
+#check for mount point
+function check_mounted () {
+  df | grep $1 | wc -l
 }
 
 function check_status_num_rows()
 {
-	local search_key=$1
-	$GEOREP_CLI $master $slave status detail | egrep -i "$search_key" | wc -l
+    local search_key=$1
+    $GEOREP_CLI $master $slave status | grep -F "$search_key" | wc -l
+}
+
+function check_fanout_status_num_rows()
+{
+    local search_key=$1
+    $GEOREP_CLI $master status | grep -F "$search_key" | wc -l
+}
+
+function check_fanout_status_detail_num_rows()
+{
+    local search_key=$1
+    $GEOREP_CLI $master status detail | grep -F "$search_key" | wc -l
+}
+
+function check_all_status_num_rows()
+{
+    local search_key=$1
+    $GEOREP_CLI status | grep -F "$search_key" | wc -l
+}
+
+function check_all_status_detail_num_rows()
+{
+    local search_key=$1
+    $GEOREP_CLI status detail | grep -F "$search_key" | wc -l
+}
+
+function verify_checkpoint_met()
+{
+    local master=$1
+    local slave=$2
+    $GEOREP_CLI $master $slave status detail| grep -F "Yes" | wc -l
+}
+
+function check_keys_distributed()
+{
+    local search_key=$(cat /var/lib/glusterd/geo-replication/master_slave_common_secret.pem.pub)
+    grep -F "$search_key" ~/.ssh/authorized_keys > /dev/null
+    echo $?
+}
+
+function check_common_secret_file()
+{
+    stat /var/lib/glusterd/geo-replication/master_slave_common_secret.pem.pub
+    echo $?
+}
+
+function create_rename_symlink_case()
+{
+    mkdir ${mastermnt}/MUL_REN_SYMLINK
+    cd ${mastermnt}/MUL_REN_SYMLINK
+    mkdir sym_dir1
+    ln -s "sym_dir1" sym1
+    mv sym1 sym2
+    mv sym2 sym3
+    mv sym3 sym4
+    cd -
 }
 
 function create_data()
 {
-	prefix=$1
+    prefix=$1
 
     # GF_FOP_MKNOD
     # GF_FOP_MKDIR
@@ -26,139 +83,210 @@ function create_data()
     # GF_FOP_CREATE
     # GF_FOP_SETATTR
 
-	# Regular file
-	touch ${master_mnt}/${prefix}_f1
-	touch ${master_mnt}/${prefix}_f2
-	touch ${master_mnt}/${prefix}_f3
-
-	# dir
-	mkdir ${master_mnt}/${prefix}_d1
-	mkdir ${master_mnt}/${prefix}_d2
-	touch ${master_mnt}/${prefix}_d3
-
-	# Hardlink
-	ln ${master_mnt}/${prefix}_f1 ${master_mnt}/${prefix}_hl1
-
-	# Symlink
-        cd ${master_mnt}
-	ln -s ${prefix}_f1 ${prefix}_sl1
-        cd -
-
-	# data
-	echo "HelloWorld!" >> ${master_mnt}/${prefix}_f1
-
-	# UNLINK
-	rm ${master_mnt}/${prefix}_f2
-
-	# RMDIR
-	rmdir ${master_mnt}/${prefix}_d2
-
-	# Rename - File
-	mv ${master_mnt}/${prefix}_f3 ${master_mnt}/${prefix}_f4
-
-	# Rename - Dir
-	mv ${master_mnt}/${prefix}_d3 ${master_mnt}/${prefix}_d4
+    # Regular file + data
+    echo "HelloWorld!" > ${master_mnt}/${prefix}_f1
+    touch ${master_mnt}/${prefix}_f2
+    touch ${master_mnt}/${prefix}_f3
+
+    # non-ascii filename test
+    echo "Hello non-ascii" > ${master_mnt}/${prefix}_f1_ಸಂತಸ
+    touch ${master_mnt}/${prefix}_f2_ಸಂತಸ
+    touch ${master_mnt}/${prefix}_f3_ಸಂತಸ
+
+    # dir
+    mkdir ${master_mnt}/${prefix}_d1
+    mkdir ${master_mnt}/${prefix}_d2
+    mkdir ${master_mnt}/${prefix}_d3
+
+    # non-ascii dir and filename test
+    mkdir ${master_mnt}/${prefix}_d1_ನನ್ನ
+    mkdir ${master_mnt}/${prefix}_d2_ಸಂತಸ
+    mkdir ${master_mnt}/${prefix}_d3_ಸಂತಸ
+    echo "Hello non-ascii" >  ${master_mnt}/${prefix}_d1_ನನ್ನ/ಸಂತಸ
+
+    # Hardlink + non-ascii name
+    ln ${master_mnt}/${prefix}_f1 ${master_mnt}/${prefix}_hl1
+    ln ${master_mnt}/${prefix}_f1 ${master_mnt}/${prefix}_hl1_ಸಂತಸ
+
+    # Symlink
+    cd ${master_mnt}
+    ln -s ${prefix}_f1 ${prefix}_sl1
+    ln -s ${prefix}_f1 ${prefix}_sl1_ಸಂತಸ
+    cd -
+
+    # UNLINK
+    rm ${master_mnt}/${prefix}_f2
+    rm ${master_mnt}/${prefix}_f2_ಸಂತಸ
+
+    # RMDIR
+    rmdir ${master_mnt}/${prefix}_d2
+    rmdir ${master_mnt}/${prefix}_d2_ಸಂತಸ
+
+    # Rename - File
+    mv ${master_mnt}/${prefix}_f3 ${master_mnt}/${prefix}_f4
+    mv ${master_mnt}/${prefix}_f3_ಸಂತಸ  ${master_mnt}/${prefix}_f4_ಸಂತಸ
+
+    # Rename - Dir
+    mv ${master_mnt}/${prefix}_d3 ${master_mnt}/${prefix}_d4
+    mv ${master_mnt}/${prefix}_d3_ಸಂತಸ  ${master_mnt}/${prefix}_d4_ಸಂತಸ
+
+    # chown
+    touch ${master_mnt}/${prefix}_chown_f1
+    chown 1000:1000 ${master_mnt}/${prefix}_chown_f1
+    touch ${master_mnt}/${prefix}_chown_f1_ಸಂತಸ
+    chown 1000:1000 ${master_mnt}/${prefix}_chown_f1_ಸಂತಸ
+}
 
-        # chown
-	touch ${master_mnt}/${prefix}_chown_f1
-	chown 1000:1000 ${master_mnt}/${prefix}_chown_f1
+function create_data_hang()
+{
+    prefix=$1
+    mkdir ${master_mnt}/${prefix}
+    cd ${master_mnt}/${prefix}
+    # ~1k files is required with 1 sync-job and hang happens if
+    # stderr buffer of tar/ssh executed with Popen is full (i.e., 64k).
+    # 64k is hit when ~800 files were  not found while syncing data
+    # from master. So around 1k files is required to hit the condition.
+    for i in {1..1000}
+    do
+        echo "test data" > file$i
+        mv -f file$i file
+    done
+    cd -
 }
 
 function chown_file_ok()
 {
-        local file_owner=$(stat --format "%u:%g" "$1" 2>/dev/null)
-        if test "X$file_owner" != "X1000:1000"; then return 1;fi
+    local file_owner=$(stat --format "%u:%g" "$1")
+    if test "X$file_owner" != "X1000:1000"; then echo 1; else echo 0; fi
 }
 
 function regular_file_ok()
 {
-	local file_type=$(stat --format "%F" "$1")
-	if test "X$file_type" != "Xregular file"; then return 1; fi
+    local file_type=$(stat --format "%F" "$1")
+    if test "X$file_type" != "Xregular file"; then echo 1; else echo 0; fi
 }
 
 function directory_ok()
 {
-	file_type=$(stat --format "%F" "$1")
-	if test "X$file_type" != "Xdirectory"; then return 1; fi
+    file_type=$(stat --format "%F" "$1")
+    if test "X$file_type" != "Xdirectory"; then echo 1; else echo 0; fi
 }
 
 function unlink_ok()
 {
-        stat "$1" stat ./case > /dev/null 2>&1
-        rc=$?
-        if test $rc != 0; then return 0; fi
-        return 1;
+    stat "$1" > /dev/null 2>&1
+    rc=$?
+    echo $rc
 }
 
 function hardlink_file_ok()
 {
-	orig_file=$1
-	link_file=$2
-
-	orig_inode=$(stat --format "%i" "$orig_file")
-	rc=$?
-	if test $rc != 0; then return $rc; fi
-
-	link_inode=$(stat --format "%i" "$link_file")
-	rc=$?
-	if test $rc != 0; then return $rc; fi
-
-	if test $orig_inode != $link_inode
-	then
-		return 1
-	fi
+    orig_file=$1
+    link_file=$2
+
+    orig_inode=$(stat --format "%i" "$orig_file")
+    rc=$?
+    if test $rc != 0; then
+        echo $rc
+    else
+        link_inode=$(stat --format "%i" "$link_file")
+        rc=$?
+        if test $rc != 0; then
+            echo $rc
+        else
+            if test $orig_inode != $link_inode; then
+                echo 1
+            else
+                echo 0
+            fi
+        fi
+    fi
 }
 
 function data_ok()
 {
-	path=$1
-	data1="$2"
-        data2=$(cat $path)
-        echo "data1:$data1"
-        echo "data2:$data2"
-        if test "X$data1" != "X$data2"
-        then
-                return 1
-        fi
+    path=$1
+    data1="$2"
+    data2=$(cat $path)
+    echo "data1:$data1"
+    echo "data2:$data2"
+    if test "X$data1" != "X$data2"; then
+        echo 1
+    else
+        echo 0
+    fi
 }
 
-function symlink_ok()
+function arequal_checksum()
 {
-	local orig_file_name=$1
-	local symlink_file=$2
-
+    master=$1
+    slave=$2
+    ret=$(diff <(arequal-checksum -p $master) <(arequal-checksum -p $slave) | wc -l)
+    echo x$ret
+}
 
-	local file_type=$(stat --format "%F" "$symlink_file")
-	if test "X$file_type" != "Xsymbolic link"; then return 1; fi
+function symlink_ok()
+{
+    local orig_file_name=$1
+    local symlink_file=$2
+
+    local file_type=$(stat --format "%F" "$symlink_file")
+    if test "X$file_type" != "Xsymbolic link"; then
+        echo 1
+    else
+        local fname=$(readlink $symlink_file)
+        if test "X$fname" != "X$orig_file_name"; then
+            echo 2
+        else
+            echo 0
+        fi
+    fi
 
-	local fname=$(readlink $symlink_file)
-	if test "X$fname" != "X$orig_file_name"; then return 1; fi
 }
 
-function rename_ok()
+function rename_file_ok()
 {
-	old_name=$1
-	new_name=$2
-
-	if [ -f $old_name ]
-	then
-		return 1
-	fi
+    old_name=$1
+    new_name=$2
+
+    if [ -f $old_name ]; then
+        echo 1
+    elif [ ! -f $new_name ]; then
+        echo 2
+    else
+        echo 0
+    fi
+}
 
-	if [ ! -f $new_name ]
-	then
-		return 1
-	fi
+function rename_dir_ok()
+{
+    old_name=$1
+    new_name=$2
+
+    if [ -d $old_name ]; then
+        echo 1
+    elif [ ! -d $new_name ]; then
+        echo 2
+    else
+        echo 0
+    fi
 }
 
 function create_georep_session()
 {
-        $CLI system:: execute gsec_create
-	rc=$?
-	if test $rc != 0; then return $rc; fi
+    $CLI system:: execute gsec_create
+    rc=$?
+    if test $rc != 0; then
+        echo $rc
+    else
         $CLI volume geo-rep $master $slave create push-pem
-	rc=$?
-	if test $rc != 0; then return $rc; fi
+        rc=$?
+        if test $rc != 0; then
+            echo $rc
+        else
+            echo 0
+        fi
+    fi
 }
 
 # logrotate_simulate should be called (rotate_count + 1) times to cause
@@ -167,66 +295,201 @@ function create_georep_session()
 # calls
 function logrotate_simulate()
 {
-        file_name=$1
-        declare -i rotate_count=$2
-
-        while [ $rotate_count -ge 0 ]; do
-                source_file="${master_mnt}/$file_name.$((rotate_count))"
-                if [ $rotate_count -eq 0 ]; then
-                        source_file="${master_mnt}/$file_name"
-                fi
-                if [ -f "${source_file}" ]; then
-                        mv "${source_file}" "${master_mnt}/$file_name.$((rotate_count+1))"
-                fi
-                ((rotate_count--))
-        done
-
-        # logrotate causes gfid to be rellocated to a new file created
-        # after an unlink and a blind rename later causes georep session
-        # to go Faulty
-        # this should not happen if source basename on slave is tested
-        # to be linked with its own gfid as on master, before invoking
-        # the rename syscall
-        touch ${master_mnt}/$file_name
-        rotate_count=$2
-        unlink_file_name="${master_mnt}/$file_name.$((rotate_count+1))"
-        unlink $unlink_file_name
+    file_name=$1
+    declare -i rotate_count=$2
+
+    while [ $rotate_count -ge 0 ]; do
+        source_file="$file_name.$((rotate_count))"
+        if [ $rotate_count -eq 0 ]; then
+            source_file="$file_name"
+        fi
+        if [ -f "${source_file}" ]; then
+                mv "${source_file}" "$file_name.$((rotate_count+1))"
+        fi
+        ((rotate_count--))
+    done
+
+    # logrotate causes gfid to be rellocated to a new file created
+    # after an unlink and a blind rename later causes georep session
+    # to go Faulty
+    # this should not happen if source basename on slave is tested
+    # to be linked with its own gfid as on master, before invoking
+    # the rename syscall
+    touch $file_name
+    rotate_count=$2
+    unlink_file_name="$file_name.$((rotate_count+1))"
+    unlink $unlink_file_name 2>/dev/null
 }
 
 function create_rename()
 {
-        file_name=$1
-        echo $file_name > ${master_mnt}/$file_name
-        mv ${master_mnt}/$file_name ${master_mnt}/$file_name.bak
+    file_name=$1
+    echo $file_name > $file_name
+    mv $file_name $file_name.bak
 }
 
 function create_rename_ok()
 {
-        file_name=$1
-        # after a log replay, we don't expect the original file
-        # to be recreated i.e. a dangling entry without a corresponding
-        # back-end gfid link should not exist on the slave
-        if [ -f "${slave_mnt}/$file_name" ]; then
-                return 1
-        fi
-        return 0
+    file_name=$1
+    # after a log replay, we don't expect the original file
+    # to be recreated i.e. a dangling entry without a corresponding
+    # back-end gfid link should not exist on the slave
+    if [ -f "$file_name" ]; then
+        echo 1
+    else
+        echo 0
+    fi
 }
 
 function hardlink_rename()
 {
-        file_name=$1
-        echo $file_name > ${master_mnt}/$file_name
-        ln ${master_mnt}/$file_name ${master_mnt}/$file_name.hl
-        mv ${master_mnt}/$file_name.hl ${master_mnt}/$file_name
+    file_name=$1
+    echo $file_name > $file_name
+    ln $file_name $file_name.hl
+    mv $file_name.hl $file_name.hl1
 }
 
 function hardlink_rename_ok()
 {
-        file_name=$1
-        # the hardlink file should not exist on the slave after renaming
-        # to one of its links
-        if [ -f "${slave_mnt}/$file_name.hl" ]; then
-                return 1
-        fi
-        return 0
+    file_name=$1
+    # the hardlink file should not exist on the slave after renaming
+    # to one of its links on changelog reprocessing
+    if [ ! -f "$file_name" ]; then
+        echo 1
+    elif [ ! -f "$file_name.hl1" ]; then
+        echo 2
+    elif [ -f "$file_name.hl" ]; then
+        echo 3
+    else
+        echo 0
+    fi
+}
+
+function create_symlink_rename_mkdir_data()
+{
+    mkdir ${master_mnt}/symlink_test1
+    touch ${master_mnt}/symlink_test1/file1
+    ln -s "./file1" ${master_mnt}/symlink_test1/sym_link
+    mv ${master_mnt}/symlink_test1/sym_link ${master_mnt}/symlink_test1/rn_sym_link
+    mkdir ${master_mnt}/symlink_test1/sym_link
+}
+function verify_symlink_rename_mkdir_data()
+{
+    sym_dir=$1
+    if [ ! -f $sym_dir/file1 ]; then
+        echo 1
+    elif [ ! -h $sym_dir/rn_sym_link ]; then
+        echo 2
+    elif [ ! -d $sym_dir/sym_link ]; then
+        echo 3
+    else
+        echo 0
+    fi
+}
+
+function create_rsnapshot_data()
+{
+    rm -rf /tmp/rsnapshot_symlinkbug
+    mkdir /tmp/rsnapshot_symlinkbug
+    ln -f -s /does/not/exist /tmp/rsnapshot_symlinkbug/a_symlink
+    rsync -a /tmp/rsnapshot_symlinkbug ${master_mnt}/
+    cp -al ${master_mnt}/rsnapshot_symlinkbug ${master_mnt}/rsnapshot_symlinkbug.0
+    ln -f -s /does/not/exist2 /tmp/rsnapshot_symlinkbug/a_symlink
+    rsync -a /tmp/rsnapshot_symlinkbug ${master_mnt}/
+    cp -al ${master_mnt}/rsnapshot_symlinkbug ${master_mnt}/rsnapshot_symlinkbug.1
+}
+
+function verify_rsnapshot_data()
+{
+    dir="$1/rsnapshot_symlinkbug"
+    dir0="$1/rsnapshot_symlinkbug.0"
+    dir1="$1/rsnapshot_symlinkbug.1"
+    if [ ! -d "$dir" ]; then
+        echo 1
+    elif [ ! -h $dir/a_symlink ]; then
+        echo 2
+    elif test "X$(readlink $dir/a_symlink)" != "X/does/not/exist2"; then
+        echo 3
+    elif [ ! -h $dir0/a_symlink ]; then
+        echo 4
+    elif test "X$(readlink $dir0/a_symlink)" != "X/does/not/exist"; then
+        echo 5
+    elif [ ! -h $dir1/a_symlink ]; then
+        echo 6
+    elif test "X$(readlink $dir1/a_symlink)" != "X/does/not/exist2"; then
+        echo 7
+    else
+        echo 0
+    fi
+}
+
+function create_hardlink_rename_data()
+{
+    dir=${master_mnt}/hardlink_rename_issue
+    mkdir $dir
+    echo "test_data" > $dir/f1
+    ln $dir/f1 $dir/f2
+    mv $dir/f2 $dir/f3
+    unlink $dir/f1
+}
+
+function verify_hardlink_rename_data()
+{
+    dir=$1/hardlink_rename_issue
+    if [ ! -d $dir ]; then
+        echo 1
+    elif [ -f $dir/f1 ]; then
+        echo 2
+    elif [ -f $dir/f2 ]; then
+        echo 3
+    elif [ ! -f $dir/f3 ]; then
+        echo 4
+    elif test "Xtest_data" != "X$(cat $dir/f3)"; then
+        echo 5
+    else
+        echo 0
+    fi
+}
+
+function check_slave_read_only()
+{
+    volum=$1
+    gluster volume info $1 | grep 'features.read-only: on'
+    echo $?
+}
+
+function create_rename_with_existing_destination()
+{
+    dir=$1/rename_with_existing_destination
+    mkdir $dir
+    for i in {1..5}
+    do
+        echo "Data_set$i" > $dir/data_set$i
+        mv $dir/data_set$i $dir/data_set -f
+    done
+}
+
+function verify_rename_with_existing_destination()
+{
+    dir=$1/rename_with_existing_destination
+
+    if [ ! -d $dir ]; then
+        echo 1
+    elif [ ! -f $dir/data_set ]; then
+        echo 2
+    elif [ -f $dir/data_set1 ]; then
+        echo 3
+    elif [ -f $dir/data_set2 ]; then
+        echo 4
+    elif [ -f $dir/data_set3 ]; then
+        echo 5
+    elif [ -f $dir/data_set4 ]; then
+        echo 6
+    elif [ -f $dir/data_set5 ]; then
+        echo 7
+    elif test "XData_set5" != "X$(cat $dir/data_set)"; then
+        echo 8
+    else
+        echo 0
+    fi
 }
diff --git a/tests/geo-rep/georep-basic-dr-rsync.t b/tests/geo-rep/georep-basic-dr-rsync.t
deleted file mode 100644
index 39da524f639..00000000000
--- a/tests/geo-rep/georep-basic-dr-rsync.t
+++ /dev/null
@@ -1,156 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-. $(dirname $0)/../geo-rep.rc
-
-### Basic Tests with Distribute Replicate volumes
-
-##Cleanup and start glusterd
-cleanup;
-TEST glusterd;
-TEST pidof glusterd
-
-
-##Variables
-GEOREP_CLI="$CLI volume geo-replication"
-master=$GMV0
-slave=${H0}::${GSV0}
-num_active=2
-num_passive=2
-master_mnt=$M0
-slave_mnt=$M1
-
-############################################################
-#SETUP VOLUMES AND GEO-REPLICATION
-############################################################
-
-##create_and_start_master_volume
-TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
-TEST $CLI volume start $GMV0
-
-##create_and_start_slave_volume
-TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};   #5
-TEST $CLI volume start $GSV0
-
-##Create, start and mount meta_volume
-TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
-TEST $CLI volume start $META_VOL
-TEST mkdir -p $META_MNT
-TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT     #10
-
-##Mount master
-TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
-
-##Mount slave
-TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
-
-############################################################
-#BASIC GEO-REPLICATION TESTS
-############################################################
-
-#Check Hybrid Crawl
-TEST create_data "hybrid"
-TEST create_georep_session $master $slave
-EXPECT 4 check_status_num_rows "Created"             #15
-
-#Enable_metavolume
-TEST $GEOREP_CLI $master $slave config use_meta_volume true
-
-#Start_georep
-TEST $GEOREP_CLI $master $slave start
-
-sleep 10
-EXPECT 2 check_status_num_rows "Active"
-EXPECT 2 check_status_num_rows "Passive"
-
-#DATA_TESTS HYBRID
-sleep 15
-TEST regular_file_ok ${slave_mnt}/hybrid_f1         #20
-TEST directory_ok ${slave_mnt}/$hybrid_d1
-TEST rename_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
-TEST rename_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
-TEST symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1
-TEST hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1 #25
-TEST unlink_ok ${slave_mnt}/hybrid_f2
-TEST unlink_ok ${slave_mnt}/hybrid_d2
-TEST data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
-TEST chown_file_ok ${slave_mnt}/hybrid_chown_f1
-
-
-#Check History Crawl.
-TEST $GEOREP_CLI $master $slave stop                #30
-TEST create_data "history"
-TEST $GEOREP_CLI $master $slave start
-sleep 10
-EXPECT 2 check_status_num_rows "Active"
-EXPECT 2 check_status_num_rows "Passive"
-
-
-
-#data_tests "history"
-sleep 15
-TEST regular_file_ok ${slave_mnt}/history_f1        #35
-TEST directory_ok ${slave_mnt}/history_d1
-TEST rename_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
-TEST rename_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
-TEST symlink_ok history_f1 ${slave_mnt}/history_sl1
-TEST hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1   #40
-TEST unlink_ok ${slave_mnt}/history_f2
-TEST unlink_ok ${slave_mnt}/history_d2
-TEST data_ok ${slave_mnt}/history_f1 "HelloWorld!"
-TEST chown_file_ok ${slave_mnt}/history_chown_f1
-
-#Check History Crawl.
-TEST create_data "changelog"                        #45
-sleep 15
-TEST check_status "Changelog Crawl"
-
-#data_tests "changelog"
-sleep 15
-TEST regular_file_ok ${slave_mnt}/changelog_f1
-TEST directory_ok ${slave_mnt}/changelog_d1
-TEST rename_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4
-TEST rename_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4      #50
-TEST symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
-TEST hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
-TEST unlink_ok ${slave_mnt}/changelog_f2
-TEST unlink_ok ${slave_mnt}/changelog_d2
-TEST data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"                    #55
-TEST chown_file_ok ${slave_mnt}/changelog_chown_f1
-
-# logrotate test
-logrotate_simulate logrotate_test_file 2
-logrotate_simulate logrotate_test_file 2
-logrotate_simulate logrotate_test_file 2
-logrotate_simulate logrotate_test_file 2
-sleep 15
-EXPECT 0 check_status_num_rows "Faulty"
-
-# CREATE + RENAME
-create_rename create_rename_test_file
-sleep 15
-TEST $GEOREP_CLI $master $slave stop
-sleep 5
-TEST $GEOREP_CLI $master $slave start
-sleep 15
-TEST create_rename_ok create_rename_test_file                                #58
-
-# hard-link rename
-hardlink_rename hardlink_rename_test_file
-sleep 15
-TEST $GEOREP_CLI $master $slave stop
-sleep 5
-TEST $GEOREP_CLI $master $slave start
-sleep 15
-TEST hardlink_rename_ok hardlink_rename_test_file
-
-#Stop Geo-rep
-TEST $GEOREP_CLI $master $slave stop
-
-#Delete Geo-rep
-TEST $GEOREP_CLI $master $slave delete
-
-cleanup;
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/geo-rep/georep-basic-dr-tarssh.t b/tests/geo-rep/georep-basic-dr-tarssh.t
deleted file mode 100644
index 5f879db99cf..00000000000
--- a/tests/geo-rep/georep-basic-dr-tarssh.t
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/bin/bash
-
-. $(dirname $0)/../include.rc
-. $(dirname $0)/../volume.rc
-. $(dirname $0)/../geo-rep.rc
-
-#################################################
-# BASIC TESTS WITH DISTRIBUTE REPLICATE VOLUMES
-#################################################
-
-##Cleanup and start glusterd
-cleanup;
-TEST glusterd;
-TEST pidof glusterd
-
-
-##Variables
-GEOREP_CLI="$CLI volume geo-replication"
-master=$GMV0
-slave=${H0}::${GSV0}
-num_active=2
-num_passive=2
-master_mnt=$M0
-slave_mnt=$M1
-
-############################################################
-#SETUP VOLUMES AND GEO-REPLICATION
-############################################################
-
-##create_and_start_master_volume
-TEST $CLI volume create $GMV0 replica 2 $H0:$B0/${GMV0}{1,2,3,4};
-TEST $CLI volume start $GMV0
-
-##create_and_start_slave_volume
-TEST $CLI volume create $GSV0 replica 2 $H0:$B0/${GSV0}{1,2,3,4};   #5
-TEST $CLI volume start $GSV0
-
-##Create, start and mount meta_volume
-TEST $CLI volume create $META_VOL replica 3 $H0:$B0/${META_VOL}{1,2,3};
-TEST $CLI volume start $META_VOL
-TEST mkdir -p $META_MNT
-TEST glusterfs -s $H0 --volfile-id $META_VOL $META_MNT     #10
-
-##Mount master
-TEST glusterfs -s $H0 --volfile-id $GMV0 $M0
-
-##Mount slave
-TEST glusterfs -s $H0 --volfile-id $GSV0 $M1
-
-############################################################
-#BASIC GEO-REPLICATION TESTS
-############################################################
-
-#Check Hybrid Crawl
-TEST create_data "hybrid"
-TEST create_georep_session $master $slave
-EXPECT 4 check_status_num_rows "Created"             #15
-
-#Enable_metavolume
-TEST $GEOREP_CLI $master $slave config use_meta_volume true
-
-#Config tarssh as sync-engine
-TEST $GEOREP_CLI $master $slave config use_tarssh true
-
-#Start_georep
-TEST $GEOREP_CLI $master $slave start
-
-sleep 10
-EXPECT 2 check_status_num_rows "Active"
-EXPECT 2 check_status_num_rows "Passive"            #20
-
-#DATA_TESTS HYBRID
-sleep 15
-TEST regular_file_ok ${slave_mnt}/hybrid_f1
-TEST directory_ok ${slave_mnt}/$hybrid_d1
-TEST rename_ok ${slave_mnt}/hybrid_f3 ${slave_mnt}/hybrid_f4
-TEST rename_ok ${slave_mnt}/hybrid_d3 ${slave_mnt}/hybrid_d4
-TEST symlink_ok hybrid_f1 ${slave_mnt}/hybrid_sl1                    #25
-TEST hardlink_file_ok ${slave_mnt}/hybrid_f1 ${slave_mnt}/hybrid_hl1
-TEST unlink_ok ${slave_mnt}/hybrid_f2
-TEST unlink_ok ${slave_mnt}/hybrid_d2
-TEST data_ok ${slave_mnt}/hybrid_f1 "HelloWorld!"
-TEST chown_file_ok ${slave_mnt}/hybrid_chown_f1       #30
-
-#Check History Crawl.
-TEST $GEOREP_CLI $master $slave stop
-TEST create_data "history"
-TEST $GEOREP_CLI $master $slave start
-sleep 10
-EXPECT 2 check_status_num_rows "Active"
-EXPECT 2 check_status_num_rows "Passive"            #35
-
-#data_tests "history"
-sleep 15
-TEST regular_file_ok ${slave_mnt}/history_f1
-TEST directory_ok ${slave_mnt}/history_d1
-TEST rename_ok ${slave_mnt}/history_f3 ${slave_mnt}/history_f4
-TEST rename_ok ${slave_mnt}/history_d3 ${slave_mnt}/history_d4
-TEST symlink_ok history_f1 ${slave_mnt}/history_sl1                      #40
-TEST hardlink_file_ok ${slave_mnt}/history_f1 ${slave_mnt}/history_hl1
-TEST unlink_ok ${slave_mnt}/history_f2
-TEST unlink_ok ${slave_mnt}/history_d2
-TEST data_ok ${slave_mnt}/history_f1 "HelloWorld!"
-TEST chown_file_ok ${slave_mnt}/history_chown_f1       #45
-
-#Check History Crawl.
-TEST create_data "changelog"
-sleep 15
-TEST check_status "Changelog Crawl"
-
-#data_tests "changelog"
-sleep 15
-TEST regular_file_ok ${slave_mnt}/changelog_f1
-TEST directory_ok ${slave_mnt}/changelog_d1
-TEST rename_ok ${slave_mnt}/changelog_f3 ${slave_mnt}/changelog_f4    #50
-TEST rename_ok ${slave_mnt}/changelog_d3 ${slave_mnt}/changelog_d4
-TEST symlink_ok changelog_f1 ${slave_mnt}/changelog_sl1
-TEST hardlink_file_ok ${slave_mnt}/changelog_f1 ${slave_mnt}/changelog_hl1
-TEST unlink_ok ${slave_mnt}/changelog_f2
-TEST unlink_ok ${slave_mnt}/changelog_d2            #55
-TEST data_ok ${slave_mnt}/changelog_f1 "HelloWorld!"
-TEST chown_file_ok ${slave_mnt}/changelog_chown_f1
-
-#Stop Geo-rep
-TEST $GEOREP_CLI $master $slave stop
-
-#Delete Geo-rep
-TEST $GEOREP_CLI $master $slave delete
-
-cleanup;
-#G_TESTDEF_TEST_STATUS_CENTOS6=BAD_TEST,BUG=000000
-#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000
diff --git a/tests/gfid2path/gfid2path_fuse.t b/tests/gfid2path/gfid2path_fuse.t
index c7e79466673..d0fe1fc16ae 100644
--- a/tests/gfid2path/gfid2path_fuse.t
+++ b/tests/gfid2path/gfid2path_fuse.t
@@ -47,7 +47,7 @@ TEST $CLI_SETGFID2PATH $backpath
 #Check for the presence of xattr
 pgfid_bname=$pgfid/before_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -62,7 +62,7 @@ backpath=$B0/${V0}1/file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -74,7 +74,7 @@ backpath=$B0/${V0}1/mknod_file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/mknod_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -88,13 +88,13 @@ backpath2=$B0/${V0}1/hl_file1
 #Check for the presence of two xattrs
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath1
 
 pgfid_bname=$pgfid/hl_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath2
 
@@ -107,13 +107,13 @@ backpath=$B0/${V0}1/rn_file1
 #Check for the presence of new xattr
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT_NOT $pgfid_bname get_text_xattr $key $backpath
 
 pgfid_bname=$pgfid/rn_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -126,13 +126,13 @@ backpath=$B0/${V0}1/rn_file1
 #Check removal of xattr
 pgfid_bname=$pgfid/hl_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT_NOT $pgfid_bname get_text_xattr $key $backpath
 
 pgfid_bname=$pgfid/rn_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -145,7 +145,7 @@ backpath=$B0/${V0}1/sym_file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/sym_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
diff --git a/tests/gfid2path/gfid2path_nfs.t b/tests/gfid2path/gfid2path_nfs.t
index 239dafd46fb..d1ea7df2f4d 100644
--- a/tests/gfid2path/gfid2path_nfs.t
+++ b/tests/gfid2path/gfid2path_nfs.t
@@ -4,6 +4,8 @@
 . $(dirname $0)/../volume.rc
 . $(dirname $0)/../nfs.rc
 
+#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
+
 cleanup;
 
 XXHSUM_SOURCE="$(dirname $0)/../../contrib/xxhash/xxhsum.c $(dirname $0)/../../contrib/xxhash/xxhash.c"
@@ -46,7 +48,7 @@ backpath=$B0/${V0}1/file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -58,7 +60,7 @@ backpath=$B0/${V0}1/mknod_file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/mknod_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -72,13 +74,13 @@ backpath2=$B0/${V0}1/hl_file1
 #Check for the presence of two xattrs
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath1
 
 pgfid_bname=$pgfid/hl_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath2
 
@@ -91,13 +93,13 @@ backpath=$B0/${V0}1/rn_file1
 #Check for the presence of new xattr
 pgfid_bname=$pgfid/file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT_NOT $pgfid_bname get_text_xattr $key $backpath
 
 pgfid_bname=$pgfid/rn_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -110,13 +112,13 @@ backpath=$B0/${V0}1/rn_file1
 #Check removal of xattr
 pgfid_bname=$pgfid/hl_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT_NOT $pgfid_bname get_text_xattr $key $backpath
 
 pgfid_bname=$pgfid/rn_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
@@ -129,7 +131,7 @@ backpath=$B0/${V0}1/sym_file1
 #Check for the presence of xattr
 pgfid_bname=$pgfid/sym_file1
 echo -n $pgfid_bname > $xxh64_file
-xxh64sum=$($XXHSUM_EXEC $xxh64_file | awk '{print $1}')
+xxh64sum=$(($XXHSUM_EXEC $xxh64_file) 2>/dev/null | awk '{print $1}')
 key="trusted.gfid2path.$xxh64sum"
 EXPECT $pgfid_bname get_text_xattr $key $backpath
 
diff --git a/tests/glusterfind/glusterfind-basic.t b/tests/glusterfind/glusterfind-basic.t
new file mode 100644
index 00000000000..ccb33fb1fc8
--- /dev/null
+++ b/tests/glusterfind/glusterfind-basic.t
@@ -0,0 +1,84 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+. $(dirname $0)/../env.rc
+
+SCRIPT_TIMEOUT=300
+
+##Cleanup and start glusterd
+cleanup;
+TEST glusterd;
+TEST pidof glusterd
+
+##create .keys
+mkdir -p /var/lib/glusterd/glusterfind/.keys
+
+#create_and_start test_volume
+TEST $CLI volume create test-vol $H0:$B0/b1 $H0:$B0/b2 $H0:$B0/b3
+TEST gluster volume start test-vol
+
+##Mount test-vol
+TEST glusterfs -s $H0 --volfile-id test-vol $M0
+
+TEST timestamp1=$(date +'%s')
+
+##Create files and dirs inside the mount point
+TEST mkdir -p $M0/dir1
+TEST touch $M0/file1
+
+##Glusterfind Create
+TEST glusterfind create sess_vol1 test-vol --force
+
+##################################################################################
+#Incremental crawl
+##################################################################################
+##Glusterfind Pre
+TEST glusterfind pre sess_vol1 test-vol output_file.txt
+
+#Glusterfind Post
+TEST glusterfind post sess_vol1 test-vol
+
+##Glusterfind List
+EXPECT '1' echo $(glusterfind list | grep sess_vol1 | wc -l)
+
+TEST timestamp2=$(date +'%s')
+
+##Glusterfind Query
+TEST glusterfind query test-vol --since-time $timestamp1 --end-time $timestamp2 output_file.txt
+
+#################################################################################
+#Full Crawl
+#################################################################################
+##Glusterfind Pre
+TEST glusterfind pre sess_vol1 test-vol output_file.txt --full --regenerate-outfile
+EXPECT '1' echo $(grep 'NEW dir1' output_file.txt | wc -l)
+EXPECT '1' echo $(grep 'NEW file1' output_file.txt | wc -l)
+
+##Glusterfind Query commands
+TEST glusterfind query test-vol --full output_file.txt
+EXPECT '1' echo $(grep 'NEW dir1' output_file.txt | wc -l)
+EXPECT '1' echo $(grep 'NEW file1' output_file.txt | wc -l)
+
+##using tag, full crawl
+TEST glusterfind query test-vol --full --tag-for-full-find NEW output_file.txt
+EXPECT '1' echo $(grep 'NEW dir1' output_file.txt | wc -l)
+EXPECT '1' echo $(grep 'NEW file1' output_file.txt | wc -l)
+
+##using -field-separator option, full crawl
+glusterfind query test-vol --full output_file.txt --field-separator "=="
+EXPECT '1' echo $(grep 'NEW==dir1' output_file.txt | wc -l)
+EXPECT '1' echo $(grep 'NEW==file1' output_file.txt | wc -l)
+
+##Adding or Replacing a Brick from an Existing Glusterfind Session
+TEST gluster volume add-brick test-vol $H0:$B0/b4 force
+
+##To make existing session work after brick add
+TEST glusterfind create sess_vol test-vol --force
+EXPECT '1' echo $(glusterfind list | grep sess_vol1 | wc -l)
+
+##glusterfind delete
+TEST glusterfind delete sess_vol test-vol
+
+rm -rf output_file.txt
+cleanup;
diff --git a/tests/include.rc b/tests/include.rc
index 7470ea13e5f..0dc7d830449 100644
--- a/tests/include.rc
+++ b/tests/include.rc
@@ -1,14 +1,19 @@
+
+checkpoint_time="$(date +%s%N)"
+
 M0=${M0:=/mnt/glusterfs/0};   # 0th mount point for FUSE
 M1=${M1:=/mnt/glusterfs/1};   # 1st mount point for FUSE
 M2=${M2:=/mnt/glusterfs/2};   # 2nd mount point for FUSE
+M3=${M3:=/mnt/glusterfs/3};   # 3rd mount point for FUSE
 N0=${N0:=/mnt/nfs/0};         # 0th mount point for NFS
 N1=${N1:=/mnt/nfs/1};         # 1st mount point for NFS
 V0=${V0:=patchy};             # volume name to use in tests
 V1=${V1:=patchy1};            # volume name to use in tests
 GMV0=${GMV0:=master};	      # master volume name to use in geo-rep tests
 GSV0=${GSV0:=slave};	      # slave volume name to use in geo-rep tests
+GSV1=${GSV1:=slave1};	      # slave volume name to use in geo-rep tests
 B0=${B0:=/d/backends};        # top level of brick directories
-WORKDIRS="$B0 $M0 $M1 $M2 $N0 $N1"
+WORKDIRS="$B0 $M0 $M1 $M2 $M3 $N0 $N1"
 
 ROOT_GFID="00000000-0000-0000-0000-000000000001"
 DOT_SHARD_GFID="be318638-e8a0-4c6d-977d-7a937aa84806"
@@ -30,6 +35,7 @@ while true; do
                 ENV_RC="/not/found"
                 break
         fi
+        old_dir=$env_dir
         env_dir=$new_dir
 done
 
@@ -69,11 +75,12 @@ esac
 DEBUG=${DEBUG:=0}             # turn on debugging?
 
 PROCESS_DOWN_TIMEOUT=5
-PROCESS_UP_TIMEOUT=30
+PROCESS_UP_TIMEOUT=45
 NFS_EXPORT_TIMEOUT=20
 CHILD_UP_TIMEOUT=20
 PROBE_TIMEOUT=60
-REBALANCE_TIMEOUT=360
+PEER_SYNC_TIMEOUT=20
+REBALANCE_TIMEOUT=600
 REOPEN_TIMEOUT=20
 HEAL_TIMEOUT=80
 IO_HEAL_TIMEOUT=120
@@ -86,6 +93,7 @@ GRAPH_SWITCH_TIMEOUT=10
 UNLINK_TIMEOUT=5
 MDC_TIMEOUT=5
 IO_WAIT_TIMEOUT=5
+DISK_FAIL_TIMEOUT=80
 
 LOGDIR=$(gluster --print-logdir)
 
@@ -98,6 +106,24 @@ CLI_NO_FORCE="gluster --mode=script";
 # root partition is ignored while running the command in a "no force" mode
 CLI_IGNORE_PARTITION="gluster --mode=script --wignore-partition"
 
+function wait_delay() {
+        local delay="$1"
+        local interval="$2"
+        shift 2
+        local deadline="$(($(date +%s%N) + ${delay}000000000))"
+
+        $*
+        while [[ $? -ne 0 ]]; do
+                if [[ $(date +%s%N) -ge ${deadline} ]]; then
+                        return 1
+                fi
+                sleep ${interval}
+                $*
+        done
+
+        return 0
+}
+
 _GFS () {
 	glusterfs "$@"
 	local mount_ret=$?
@@ -109,8 +135,8 @@ _GFS () {
 	while true; do
 		touch $mount_point/xy_zzy 2> /dev/null && break
 		i=$((i+1))
-		[ $i -lt 10 ] || break
-		sleep 1
+		[ $i -lt 100 ] || break
+		sleep 0.1
 	done
 	rm -f $mount_point/xy_zzy
 	return $mount_ret
@@ -186,6 +212,7 @@ function test_header()
         dbg "=========================";
         dbg "TEST $t (line $TESTLINE): $*";
         saved_cmd="$*"
+        start_time="$(date +%s%N)"
 }
 
 
@@ -194,15 +221,18 @@ function test_footer()
         RET=$?
         local lineno=$1
         local err=$2
-
+        local end_time
+        local elapsed1
+        local elapsed2
+
+        end_time="$(date +%s%N)"
+        elapsed1="$(((start_time - checkpoint_time) / 1000000))"
+        elapsed2="$(((end_time - start_time) / 1000000))"
+        checkpoint_time="$end_time"
         if [ $RET -eq 0 ]; then
-                echo "ok $t, LINENUM:$lineno";
+                printf "ok %3d [%7d/%7d] <%4d> '%s'\n" "$t" "$elapsed1" "$elapsed2" "$lineno" "$saved_cmd";
         else
-                echo "not ok $t $err, LINENUM:$lineno";
-                # With DEBUG, this was already printed out, so skip it.
-                if [ x"$DEBUG" = x"0" ]; then
-                        echo "FAILED COMMAND: $saved_cmd"
-                fi
+                printf "not ok %3d [%7d/%7d] <%4d> '%s' -> '%s'\n" "$t" "$elapsed1" "$elapsed2" "$lineno" "$saved_cmd" "$err"
                 if [ "$EXIT_EARLY" = "1" ]; then
 			cleanup
                         exit $RET
@@ -335,12 +365,12 @@ function _EXPECT_WITHIN()
         a="";
         shift;
 
-        local endtime=$(( ${timeout}+`date +%s` ))
+        local endtime="$(( ${timeout}000000000 + $(date +%s%N) ))"
 
         # We *want* this to be globally visible.
         EW_RETRIES=0
 
-        while [ `date +%s` -lt $endtime ]; do
+        while [[ "$(date +%s%N)" < "$endtime" ]]; do
                 a=$("$@" | tail -1 ; exit ${PIPESTATUS[0]})
                 ## Check command success
                 if [ $? -ne 0 ]; then
@@ -350,7 +380,7 @@ function _EXPECT_WITHIN()
                 if [[ "$a" =~ $e ]]; then
                         break;
                 fi
-                sleep 1;
+                sleep 0.25;
                 EW_RETRIES=$((EW_RETRIES+1))
         done
 
@@ -461,8 +491,103 @@ stat -c %s /dev/null > /dev/null 2>&1 || {
   }
 }
 
+function signal_pids() {
+        local sig="$1"
+        shift
+        local pids=($*)
+
+        if [[ ${#pids[@]} -gt 0 ]]; then
+                kill -${sig} ${pids[@]} 2>/dev/null || true
+        fi
+}
+
+function check_pids() {
+        local pids=($*)
+        local tmp=()
+        local pid
+
+        for pid in "${pids[@]}"; do
+                kill -0 "${pid}" 2>/dev/null && tmp+=(${pid})
+        done
+
+        echo "${tmp[@]}"
+}
+
+function pids_alive() {
+        local pids=($*)
+
+        if [[ "$(check_pids ${pids[@]})" != "" ]]; then
+                return 1;
+        fi
+
+        return 0
+}
+
+function terminate_pids() {
+        local pids=($*)
+
+        signal_pids TERM ${pids[@]}
+        wait_delay ${PROCESS_DOWN_TIMEOUT} 0.1 pids_alive ${pids[@]}
+        if [[ $? -ne 0 ]]; then
+                pids=($(check_pids ${pids[@]}))
+                signal_pids KILL ${pids[@]}
+                wait_delay 1 0.1 pids_alive ${pids[@]}
+                if [[ $? -ne 0 ]]; then
+                        return 2
+                fi
+
+                return 1
+        fi
+
+        return 0
+}
+
+function process_pids() {
+        local proc
+        local pids=()
+
+        for proc in $*; do
+                pids+=($(pgrep ${proc}))
+        done
+
+        echo "${pids[@]}"
+}
+
+## Lock files should get automatically removed once "usradd" or "groupadd"
+## command finishes. But sometimes we encounter situations (bugs) where
+## some of these files may not get properly unlocked after the execution of
+## the command. In that case, when we execute useradd next time, it may show
+## the error “cannot lock /etc/password” or “unable to lock group file”.
+## So, to avoid any such errors, check for any lock files under /etc.
+## and remove those.
+
+function remove_lock_files()
+{
+        if [ ! -f /etc/passwd.lock ];
+        then
+                rm -rf /etc/passwd.lock;
+        fi
+
+        if [ ! -f /etc/group.lock ];
+        then
+                rm -rf /etc/group.lock;
+        fi
+
+        if [ ! -f /etc/shadow.lock ];
+        then
+                rm -rf /etc/shadow.lock;
+        fi
+
+        if [ ! -f /etc/gshadow.lock ];
+        then
+                rm -rf /etc/gshadow.lock;
+        fi
+}
+
+
 function cleanup()
 {
+        local end_time
 
         # Prepare flags for umount
         case `uname -s` in
@@ -480,6 +605,9 @@ function cleanup()
                 ;;
         esac
 
+        # Clean up lock files.
+        remove_lock_files
+
         # Clean up all client mounts
         for m in `mount | grep fuse.glusterfs | awk '{print $3}'`; do
                 umount $flag $m
@@ -498,8 +626,9 @@ function cleanup()
         umount $flag /tmp/mnt* 2>/dev/null
 
 
-        # Send SIGKILL to all gluster processes and rpc.statd that are still running
-        killall -9 glusterfs glusterfsd glusterd rpc.statd 2>/dev/null || true;
+        # Send SIGTERM to all gluster processes and rpc.statd that are still running
+        terminate_pids $(process_pids glusterfs glusterfsd glusterd rpc.statd)
+
         test x"$OSTYPE" = x"NetBSD" && pkill -9 perfused || true
 
         # unregister nfs and related services from portmapper/rpcbind
@@ -596,31 +725,14 @@ function cleanup()
                 return 1;
         fi >&2
 
-        # tar logs at the start and end of every test
-        if [ -n "$LOGDIR" -a -z "$STOP_WASTING_SPACE" ]
-        then
-                tarname=$(basename $0 .t)
-		# Can't use --exclude here because NetBSD doesn't have it.
-		# However, both it and Linux have -X to take patterns from
-		# a file, so use that.
-		(echo '*.tar'; echo .notar) > ${LOGDIR}/.notar \
-			&& \
-                tar -cf ${LOGDIR}/${tarname}.tar -X ${LOGDIR}/.notar \
-			${LOGDIR}/* 2> /dev/null \
-                        && \
-                find $LOGDIR/* -maxdepth 0 -name '*.tar' -prune \
-                                        -o -exec rm -rf '{}' ';'
-        else
-                echo "LOGDIR is not set"
-        fi
-
         mkdir -p $WORKDIRS
 	# This is usually the last thing a test script calls, so our return
 	# value becomes their exit value.  While it's not great for the mkdir
 	# above to fail, promoting that into a failure of the whole test (and
 	# thus of an entire regression-test run) seems a bit excessive.  Make
 	# sure we return good status anyway.
-	return 0
+
+        return 0
 }
 
 function force_terminate () {
@@ -1229,3 +1341,10 @@ function STAT_INO()
                 echo 0
         fi
 }
+
+function get_md5_sum()
+{
+    local file=$1;
+    md5_sum=$(md5sum $file | awk '{print $1}');
+    echo $md5_sum
+}
diff --git a/tests/line-coverage/afr-heal-info.t b/tests/line-coverage/afr-heal-info.t
new file mode 100644
index 00000000000..182665917c4
--- /dev/null
+++ b/tests/line-coverage/afr-heal-info.t
@@ -0,0 +1,43 @@
+#!/bin/bash
+#Test that parallel heal-info command execution doesn't result in spurious
+#entries with locking-scheme granular
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+
+function write_and_del_file {
+        dd of=$M0/a.txt if=/dev/zero bs=1024k count=100
+        rm -f $M0/b.txt
+}
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume create $V0 replica 2 $H0:$B0/brick{0,1}
+TEST $CLI volume set $V0 locking-scheme granular
+TEST $CLI volume start $V0
+TEST $GFS --volfile-id=$V0 --volfile-server=$H0 $M0;
+TEST touch $M0/a.txt $M0/b.txt
+write_and_del_file &
+touch $B0/f1 $B0/f2
+
+# All above is similar to basic/afr/heal-info.t
+
+TEST $CLI volume heal $V0 enable
+TEST $CLI volume heal $V0 info --xml
+TEST $CLI volume heal $V0 info summary
+TEST $CLI volume heal $V0 info summary --xml
+TEST $CLI volume heal $V0 info split-brain
+TEST $CLI volume heal $V0 info split-brain --xml
+
+TEST $CLI volume heal $V0 statistics heal-count
+
+# It may fail as the file is not in splitbrain
+$CLI volume heal $V0 split-brain latest-mtime /a.txt
+
+TEST $CLI volume heal $V0 disable
+
+TEST $CLI volume stop $V0
+cleanup;
diff --git a/tests/line-coverage/arbiter-coverage.t b/tests/line-coverage/arbiter-coverage.t
new file mode 100755
index 00000000000..82b470141b5
--- /dev/null
+++ b/tests/line-coverage/arbiter-coverage.t
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 2 arbiter 1 $H0:$B0/${V0}{1,2,3,4,5,6};
+
+## Start volume and verify
+TEST $CLI volume start $V0;
+
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+build_tester ./glfsxmp.c -lgfapi
+$(dirname $0)/../basic/rpc-coverage.sh $M1 >/dev/null
+./glfsxmp $V0 $H0 >/dev/null
+
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+## Finish up
+TEST $CLI volume stop $V0;
+
+TEST $CLI volume delete $V0;
+
+cleanup;
diff --git a/tests/line-coverage/cli-peer-and-volume-operations.t b/tests/line-coverage/cli-peer-and-volume-operations.t
new file mode 100644
index 00000000000..0cf8dbe81f9
--- /dev/null
+++ b/tests/line-coverage/cli-peer-and-volume-operations.t
@@ -0,0 +1,135 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../cluster.rc
+. $(dirname $0)/../volume.rc
+
+function peer_count {
+eval \$CLI_$1 peer status | grep 'Peer in Cluster (Connected)' | wc -l
+}
+
+cleanup
+
+TEST launch_cluster 3
+
+TEST $CLI_1 system uuid reset
+
+## basic peer commands
+TEST $CLI_1 peer probe $H2
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 1
+EXPECT_WITHIN $PROBE_TIMEOUT 1 peer_count 2
+
+#probe a unreachable node
+TEST kill_glusterd 3
+TEST ! $CLI_1 peer probe $H3
+
+#detach a node which is not a part of cluster
+TEST ! $CLI_1 peer detach $H3
+TEST ! $CLI_1 peer detach $H3 force
+
+TEST start_glusterd 3
+TEST $CLI_1 peer probe $H3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 1
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 2
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 3
+
+# probe a node which is already part of cluster
+TEST $CLI_1 peer probe $H3
+
+#probe an invalid address
+TEST ! $CLI_1 peer probe 1024.1024.1024.1024
+
+TEST $CLI_1 pool list
+
+TEST $CLI_1 --help
+TEST $CLI_1 --version
+TEST $CLI_1 --print-logdir
+TEST $CLI_1 --print-statedumpdir
+
+# try unrecognised command
+TEST ! $CLI_1 volume
+TEST pidof glusterd
+
+## all help commands
+TEST $CLI_1 global help
+TEST $CLI_1 help
+
+TEST $CLI_1 peer help
+TEST $CLI_1 volume help
+TEST $CLI_1 volume bitrot help
+TEST $CLI_1 volume quota help
+TEST $CLI_1 snapshot help
+
+## volume operations
+TEST $CLI_1 volume create $V0 $H1:$B1/$V0 $H2:$B2/$V0 $H3:$B3/$V0
+# create a volume with already existing volume name
+TEST ! $CLI_1 volume create $V0 $H1:$B1/$V1 $H2:$B2/$V1
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
+
+# Mount the volume and create files
+TEST glusterfs -s $H1 --volfile-id $V0 $M1
+TEST touch $M1/file{1..100}
+
+#fails because $V0 is not shd compatible
+TEST ! $CLI_1 volume status $V0 shd
+
+#test explicitly provided options
+TEST $CLI_1 --timeout=120 --log-level=INFO volume status
+
+#changing timezone to a different one, to check localtime logging feature
+TEST export TZ='Asia/Kolkata'
+TEST restart_glusterd 1
+
+#localtime logging enable
+TEST $CLI_1 volume set all cluster.localtime-logging enable
+EXPECT '1' logging_time_check $LOGDIR
+
+#localtime logging disable
+TEST $CLI_1 volume set all cluster.localtime-logging disable
+EXPECT '0' logging_time_check $LOGDIR
+
+#changing timezone back to original timezone
+TEST export TZ='UTC'
+
+#negative tests for volume options
+#'set' option to enable quota/inode-quota is now depreciated
+TEST ! $CLI_1 volume set $V0 quota enable
+TEST ! $CLI_1 volume set $V0 inode-quota enable
+
+#invalid transport type 'rcp'
+TEST ! $CLI_1 volume set $V0 config.transport rcp
+
+#'op-version' option is not valid for a single volume
+TEST ! $CLI_1 volume set $V0 cluster.op-version 72000
+
+#'op-version' option can't be used with any other option
+TEST ! $CLI_1 volume set all cluster.localtime-logging disable cluster.op-version 72000
+
+#invalid format of 'op-version'
+TEST ! $CLI_1 volume set all cluster.op-version 72-000
+
+#provided 'op-version' value is greater than max allowed op-version
+op_version=$($CLI_1 volume get all cluster.max-op-version | awk 'NR==3 {print$2}')
+op_version=$((op_version+1000))  #this can be any number greater than 0
+TEST ! $CLI_1 volume set all cluster.op-version $op_version
+
+#provided 'op-verison' value cannot be less than the current cluster op-version value
+TEST ! $CLI_1 volume set all cluster.op-version 00000
+
+# system commnds
+TEST $CLI_1 system help
+TEST $CLI_1 system uuid get
+TEST $CLI_1 system getspec $V0
+TEST $CLI_1 system getwd
+TEST $CLI_1 system fsm log
+
+# Both these may fail, but it covers xdr functions and some
+# more code in cli/glusterd
+$CLI_1 system:: mount test local:/$V0
+$CLI_1 system:: umount $M0 lazy
+$CLI_1 system:: copy file options
+$CLI_1 system:: portmap brick2port $H0:$B0/brick
+$CLI_1 system:: uuid reset
+
+cleanup
diff --git a/tests/line-coverage/cli-volume-top-profile-coverage.t b/tests/line-coverage/cli-volume-top-profile-coverage.t
new file mode 100644
index 00000000000..35713c26faa
--- /dev/null
+++ b/tests/line-coverage/cli-volume-top-profile-coverage.t
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../cluster.rc
+. $(dirname $0)/../volume.rc
+
+cleanup
+
+# Creating cluster
+TEST launch_cluster 3
+
+# Probing peers
+TEST $CLI_1 peer probe $H2
+TEST $CLI_1 peer probe $H3
+EXPECT_WITHIN $PROBE_TIMEOUT 2 peer_count 3
+
+# Creating a volume and starting it.
+TEST $CLI_1 volume create $V0 replica 3 $H1:$B1/$V0 $H2:$B2/$V0 $H3:$B3/$V0
+TEST $CLI_1 volume start $V0
+EXPECT 'Started' cluster_volinfo_field 1 $V0 'Status';
+
+TEST glusterfs -s $H1 --volfile-id $V0 $M1
+TEST touch $M1/file{1..100}
+
+# Testing volume top command with and without xml output
+function test_volume_top_cmds () {
+    local ret=0
+    declare -a top_cmds=("read" "open" "write" "opendir" "readdir")
+    for cmd in ${top_cmds[@]}; do
+        $CLI_1 volume top $V0 $cmd
+        (( ret += $? ))
+        $CLI_1 volume top $V0 clear
+        (( ret += $? ))
+        $CLI_1 volume top $V0 $cmd --xml
+        (( ret += $? ))
+        $CLI_1 volume top $V0 $cmd brick $H1:$B1/$V0
+        (( ret += $? ))
+        $CLI_1 volume top $V0 clear brick $H1:$B1/$V0
+        (( ret += $? ))
+        $CLI_1 volume top $V0 $cmd brick $H1:$B1/$V0 --xml
+        (( ret += $? ))
+    done
+    return $ret
+}
+
+# Testing volume profile command with and without xml
+function test_volume_profile_cmds () {
+    local ret=0
+    declare -a profile_cmds=("start" "info" "info peek" "info cumulative" "info clear" "info incremental peek" "stop")
+    for cmd in "${profile_cmds[@]}"; do
+        $CLI_1 volume profile $V0 $cmd
+        (( ret += $? ))
+        $CLI_1 volume profile $V0 $cmd --xml
+        (( ret += $? ))
+    done
+    return $ret
+}
+
+TEST test_volume_top_cmds;
+TEST test_volume_profile_cmds;
+
+cleanup
diff --git a/tests/line-coverage/errorgen-coverage.t b/tests/line-coverage/errorgen-coverage.t
new file mode 100755
index 00000000000..f4622428d79
--- /dev/null
+++ b/tests/line-coverage/errorgen-coverage.t
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+
+# Because I have added 10 iterations of rpc-coverage and glfsxmp for errorgen
+SCRIPT_TIMEOUT=600
+
+cleanup;
+
+## Start and create a volume
+TEST glusterd;
+TEST pidof glusterd;
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{1,2,3,4,5,6};
+
+TEST $CLI volume set $V0 error-gen posix;
+TEST $CLI volume set $V0 debug.error-failure 3%;
+
+## Start volume and verify
+TEST $CLI volume start $V0;
+
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+build_tester ./glfsxmp.c -lgfapi
+for i in $(seq 1 10); do
+    # as there is error-gen, there can be errors, so no
+    # need to test for success of below two commands
+    $(dirname $0)/../basic/rpc-coverage.sh $M1 >/dev/null
+    ./glfsxmp $V0 $H0 >/dev/null
+done
+
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+## Finish up
+TEST $CLI volume stop $V0;
+
+TEST $CLI volume delete $V0;
+
+cleanup;
diff --git a/tests/line-coverage/log-and-brick-ops-negative-case.t b/tests/line-coverage/log-and-brick-ops-negative-case.t
new file mode 100644
index 00000000000..d86cb452282
--- /dev/null
+++ b/tests/line-coverage/log-and-brick-ops-negative-case.t
@@ -0,0 +1,82 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup
+TEST glusterd
+TEST pidof glusterd
+
+#create volumes
+TEST $CLI volume create ${V0}_1 $H0:$B0/v{1..2}
+
+TEST $CLI volume create ${V0}_2 replica 3 arbiter 1 $H0:$B0/v{3..5}
+
+TEST $CLI volume create ${V0}_3 disperse 3 redundancy 1 $H0:$B0/v{6..8}
+TEST $CLI volume start ${V0}_3
+EXPECT 'Started' volinfo_field ${V0}_3 'Status'
+
+TEST $CLI volume create ${V0}_4 replica 3 $H0:$B0/v{9..14}
+TEST $CLI volume start ${V0}_4
+EXPECT 'Started' volinfo_field ${V0}_4 'Status'
+
+#log rotate option
+#provided volume does not exist
+TEST ! $CLI volume log ${V0}_5 rotate
+
+#volume must be started before using log rotate option
+TEST ! $CLI volume log ${V0}_1 rotate
+TEST $CLI volume start ${V0}_1
+EXPECT 'Started' volinfo_field ${V0}_1 'Status'
+
+#incorrect brick provided for the volume
+TEST ! $CLI volume log ${V0}_1 rotate $H0:$B0/v15
+
+#add-brick operations
+#volume must be in started to state to increase replica count
+TEST ! $CLI volume add-brick ${V0}_2 replica 4 $H0:$B0/v15
+TEST $CLI volume start ${V0}_2
+EXPECT 'Started' volinfo_field ${V0}_2 'Status'
+
+#incorrect number of bricks for a replica 4 volume
+TEST ! $CLI volume add-brick ${V0}_1 replica 4 $H0:$B0/v15
+
+#replica count provided is less than the current replica count
+TEST ! $CLI volume add-brick ${V0}_2 replica 2 $H0:$B0/v15
+
+#dispersed to replicated dispersed not possible
+TEST ! $CLI volume add-brick ${V0}_3 replica 2 $H0:$B0/v15
+
+#remove-brick operations
+#replica count option provided for dispersed vol
+TEST ! $CLI volume remove-brick ${V0}_3 replica 2 $H0:$B0/v8 start
+
+#given replica count is greater than the current replica count
+TEST ! $CLI volume remove-brick ${V0}_2 replica 4 $H0:$B0/v5 start
+
+#number of bricks to be removed, must be a multiple of replica count
+TEST ! $CLI volume remove-brick ${V0}_2 replica 3 $H0:$B0/v{3..4} start
+
+#less number of bricks given to reduce the replica count
+TEST ! $CLI volume remove-brick ${V0}_2 replica 1 $H0:$B0/v3 start
+
+#bricks should be from different subvol
+TEST ! $CLI volume remove-brick ${V0}_4 replica 2 $H0:$B0/v{13..14} start
+
+#arbiter must be removed to reduce replica count
+TEST ! $CLI volume remove-brick ${V0}_2 replica 1 $H0:$B0/v{3..4} start
+
+#removal of bricks is not allowed without reducing the replica count explicitly
+TEST ! $CLI volume remove-brick ${V0}_2 replica 3 $H0:$B0/v{3..5} start
+
+#incorrect brick for given vol
+TEST ! $CLI volume  remove-brick ${V0}_1 $H0:$B0/v15 start
+
+#removing all the bricks are not allowed
+TEST ! $CLI volume remove-brick ${V0}_1 $H0:$B0/v{1..2} start
+
+#volume must not be stopped state while removing bricks
+TEST $CLI volume stop ${V0}_1
+TEST ! $CLI volume remove-brick ${V0}_1 $H0:$B0/v1 start
+
+cleanup
+\ No newline at end of file
diff --git a/tests/line-coverage/meta-max-coverage.t b/tests/line-coverage/meta-max-coverage.t
new file mode 100755
index 00000000000..1cc07610aa7
--- /dev/null
+++ b/tests/line-coverage/meta-max-coverage.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}
+TEST $CLI volume start $V0;
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1
+
+TEST stat $M1/.meta/
+
+# expect failures in rpc-coverage.sh execution.
+res=$($(dirname $0)/../basic/rpc-coverage.sh $M1/.meta)
+
+
+# Expect errors here, hence no need to 'check for success'
+for file in $(find $M1/.meta type f -print); do
+    cat $file >/dev/null
+    echo 1>$file
+    echo hello>$file
+done
+
+TEST umount $M1
+
+cleanup;
diff --git a/tests/line-coverage/namespace-linecoverage.t b/tests/line-coverage/namespace-linecoverage.t
new file mode 100644
index 00000000000..8de6a0f279b
--- /dev/null
+++ b/tests/line-coverage/namespace-linecoverage.t
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+cleanup;
+
+TEST glusterd
+TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2,3,4,5,6,7,8}
+TEST $CLI volume set $V0 performance.stat-prefetch off
+TEST $CLI volume set $V0 cluster.read-subvolume-index 0
+TEST $CLI volume set $V0 features.tag-namespaces on
+TEST $CLI volume start $V0
+TEST $CLI volume set $V0 storage.build-pgfid on
+
+sleep 2
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+
+mkdir -p $M1/namespace
+
+# subvol_1 = bar, subvol_2 = foo, subvol_3 = hey
+# Test create, write (tagged by loc, fd respectively).
+touch $M1/namespace/{bar,foo,hey}
+
+open $M1/namespace/hey
+
+## TODO: best way to increase coverage is to have a gfapi program
+## which covers maximum fops
+TEST $(dirname $0)/../basic/rpc-coverage.sh $M1
+
+TEST cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+cleanup;
diff --git a/tests/line-coverage/old-protocol.t b/tests/line-coverage/old-protocol.t
new file mode 100755
index 00000000000..5676e5636db
--- /dev/null
+++ b/tests/line-coverage/old-protocol.t
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6};
+
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+EXPECT '6' brick_count $V0
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+file="/var/lib/glusterd/vols/$V0/trusted-$V0.tcp-fuse.vol"
+sed -i -e 's$send-gids true$send-gids true\n    option testing.old-protocol true$g' $file
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+## TODO: best way to increase coverage is to have a gfapi program
+## which covers maximum fops
+TEST $(dirname $0)/../basic/rpc-coverage.sh $M1
+
+TEST cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+cleanup;
diff --git a/tests/line-coverage/quiesce-coverage.t b/tests/line-coverage/quiesce-coverage.t
new file mode 100755
index 00000000000..ca29343451e
--- /dev/null
+++ b/tests/line-coverage/quiesce-coverage.t
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 replica 3  $H0:$B0/${V0}{1,2,3,4,5,6};
+
+EXPECT "$V0" volinfo_field $V0 'Volume Name';
+EXPECT 'Created' volinfo_field $V0 'Status';
+EXPECT '6' brick_count $V0
+
+TEST $CLI volume start $V0;
+EXPECT 'Started' volinfo_field $V0 'Status';
+
+file="/var/lib/glusterd/vols/$V0/trusted-$V0.tcp-fuse.vol"
+
+cat >> ${file} <<EOF
+
+volume quiesce
+  type features/quiesce
+  subvolumes ${V0}
+end-volume
+EOF
+
+## Mount FUSE
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+## TODO: best way to increase coverage is to have a gfapi program
+## which covers maximum fops
+TEST $(dirname $0)/../basic/rpc-coverage.sh $M1
+
+TEST cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+cleanup;
diff --git a/tests/line-coverage/shard-coverage.t b/tests/line-coverage/shard-coverage.t
new file mode 100644
index 00000000000..1797999c146
--- /dev/null
+++ b/tests/line-coverage/shard-coverage.t
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup
+
+TEST glusterd
+
+TEST $CLI volume create $V0 $H0:$B0/brick
+TEST $CLI volume set $V0 features.shard on
+EXPECT 'Created' volinfo_field $V0 'Status'
+
+TEST $CLI volume start $V0
+EXPECT 'Started' volinfo_field $V0 'Status'
+
+# It is good to copy the file locally and build it, so the scope remains
+# inside tests directory.
+TEST cp $(dirname ${0})/../basic/gfapi/glfsxmp-coverage.c glfsxmp.c
+TEST build_tester ./glfsxmp.c -lgfapi
+TEST ./glfsxmp $V0 $H0
+TEST cleanup_tester ./glfsxmp
+TEST rm ./glfsxmp.c
+
+TEST $GFS -s $H0 --volfile-id $V0 $M1;
+
+TEST $(dirname $0)/../basic/rpc-coverage.sh $M1
+
+
+TEST $CLI volume stop $V0
+TEST $CLI volume delete $V0
+
+cleanup
diff --git a/tests/line-coverage/some-features-in-libglusterfs.t b/tests/line-coverage/some-features-in-libglusterfs.t
new file mode 100644
index 00000000000..5719c4e039c
--- /dev/null
+++ b/tests/line-coverage/some-features-in-libglusterfs.t
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+function grep_string {
+    local f=$1
+    local string=$2
+    # The output of test script also shows up in log. Ignore them.
+    echo $(grep ${string} ${f} | grep -v "++++++" | wc -l)
+}
+
+cleanup;
+
+TEST glusterd
+TEST pidof glusterd
+TEST $CLI volume info;
+
+TEST $CLI volume create $V0 $H0:$B0/${V0}
+TEST $CLI volume set $V0 client-log-level TRACE
+TEST $CLI volume start $V0;
+
+log_file="$(gluster --print-logdir)/gluster.log"
+## Mount FUSE
+TEST $GFS -s $H0 --log-file $log_file --volfile-id $V0 $M1
+
+## Cover 'monitoring.c' here
+pgrep 'glusterfs' | xargs kill -USR2
+
+EXPECT_WITHIN 2 1 grep_string $log_file 'sig:USR2'
+
+## Also cover statedump
+pgrep 'glusterfs' | xargs kill -USR1
+
+EXPECT_WITHIN 2 1 grep_string $log_file 'sig:USR1'
+
+## Also cover SIGHUP
+pgrep 'glusterfs' | xargs kill -HUP
+
+EXPECT_WITHIN 2 1 grep_string $log_file 'sig:HUP'
+
+## Also cover SIGTERM
+pgrep 'glusterfs' | xargs kill -TERM
+
+EXPECT_WITHIN 2 1 grep_string $log_file 'cleanup_and_exit'
+
+# Previous call should make umount of the process.
+# force_umount $M1
+
+# TODO: below section is commented out, mainly as our regression treats the test
+# as failure because sending ABRT signal will cause the process to dump core.
+# Our regression treats the test as failure, if there is a core.
+# FIXME: figure out a way to run this test, because this part of the code gets
+# executed only when there is coredump, and it is critical for debugging, to
+# keep it working always.
+
+# # Restart client
+# TEST $GFS -s $H0 --log-file $log_file --volfile-id $V0 $M1
+#
+# ## Also cover SIGABRT
+# pgrep 'glusterfs ' | xargs kill -ABRT
+#
+# TEST [ 1 -eq $(grep 'pending frames' $log_file | wc -l) ]
+
+TEST rm $log_file
+
+cleanup;
diff --git a/tests/line-coverage/volfile-with-all-graph-syntax.t b/tests/line-coverage/volfile-with-all-graph-syntax.t
new file mode 100644
index 00000000000..b137432cceb
--- /dev/null
+++ b/tests/line-coverage/volfile-with-all-graph-syntax.t
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+. $(dirname $0)/../include.rc
+. $(dirname $0)/../volume.rc
+
+cleanup;
+
+TEST mkdir -p $B0/test
+cat > $B0/test.vol <<EOF
+volume test
+  type storage/posix
+  option directory $B0/test
+  option multiple-line-string "I am
+ testing a feature of volfile graph.l"
+  option single-line-string "this is running on $H0"
+  option option-with-back-tick `date +%Y%M%d`
+end-volume
+EOF
+
+# This should succeed, but it will have some unknown options, which is OK.
+TEST glusterfs -f $B0/test.vol $M0;
+
+EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0;
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+volume test
+  type storage/posix
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+  type storage/posix
+end-volume
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+volume test
+end-volume
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+volume test
+  option test and test
+end-volume
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+volume test
+  subvolumes
+end-volume
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+# This should not succeed
+cat > $B0/test.vol <<EOF
+volume test
+  type storage/posix
+  new-option key value
+  option directory $B0/test
+end-volume
+EOF
+TEST ! glusterfs -f $B0/test.vol $M0;
+
+cleanup;
diff --git a/tests/ssl.rc b/tests/ssl.rc
index 127f83f7577..b1ccc4c8d38 100644
--- a/tests/ssl.rc
+++ b/tests/ssl.rc
@@ -20,7 +20,7 @@ SSL_CA=$SSL_BASE/glusterfs.ca
 
 # Create self-signed certificates
 function create_self_signed_certs (){
-        openssl genrsa -out $SSL_KEY 1024
+        openssl genrsa -out $SSL_KEY 2048
         openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
         ln $SSL_CERT $SSL_CA
         return $?
diff --git a/tests/thin-arbiter.rc b/tests/thin-arbiter.rc
new file mode 100644
index 00000000000..e26d91b1907
--- /dev/null
+++ b/tests/thin-arbiter.rc
@@ -0,0 +1,613 @@
+declare -A PORTMAP
+PORTCURR=49152
+function ta_create_ta_and_volfile()
+{
+        local b=$B0/$1
+        mkdir -p $b/.glusterfs/indices
+cat > $B0/ta.vol <<EOF
+volume ta-posix
+    type storage/posix
+    option directory $b
+end-volume
+
+volume ta-thin-arbiter
+    type features/thin-arbiter
+    subvolumes ta-posix
+end-volume
+
+volume ta-locks
+    type features/locks
+    option notify-contention yes
+    subvolumes ta-thin-arbiter
+end-volume
+
+volume ta-upcall
+    type features/upcall
+    option cache-invalidation off
+    subvolumes ta-locks
+end-volume
+
+volume ta-io-threads
+    type performance/io-threads
+    subvolumes ta-upcall
+end-volume
+
+volume ta-index
+    type features/index
+    option xattrop-pending-watchlist trusted.afr.ta-
+    option xattrop-dirty-watchlist trusted.afr.dirty
+    option index-base $b/.glusterfs/indices
+    subvolumes ta-io-threads
+end-volume
+
+volume ta-io-stats
+    type debug/io-stats
+    option count-fop-hits off
+    option latency-measurement off
+    option log-level WARNING
+    option unique-id $b
+    subvolumes ta-index
+end-volume
+
+volume ta-server
+    type protocol/server
+    option transport.listen-backlog 10
+    option transport.socket.keepalive-count 9
+    option transport.socket.keepalive-interval 2
+    option transport.socket.keepalive-time 20
+    option transport.tcp-user-timeout 0
+    option transport.socket.keepalive 1
+    option auth.addr.$b.allow *
+    option auth-path $b
+    option transport.address-family inet
+    option transport-type tcp
+    subvolumes ta-io-stats
+end-volume
+EOF
+}
+
+function ta_create_brick_and_volfile()
+{
+        local b=$B0/$1
+        mkdir -p $b/.glusterfs/indices
+cat > $B0/${1}.vol <<EOF
+volume ${V0}-posix
+    type storage/posix
+    option directory $b
+end-volume
+
+volume ${V0}-locks
+    type features/locks
+    subvolumes ${V0}-posix
+end-volume
+
+volume ${V0}-leases
+    type features/leases
+    option leases off
+    subvolumes ${V0}-locks
+end-volume
+
+volume ${V0}-upcall
+    type features/upcall
+    option cache-invalidation off
+    subvolumes ${V0}-leases
+end-volume
+
+volume ${V0}-io-threads
+    type performance/io-threads
+    subvolumes ${V0}-upcall
+end-volume
+
+volume ${V0}-index
+    type features/index
+    option xattrop-pending-watchlist trusted.afr.${V0}-
+    option xattrop-dirty-watchlist trusted.afr.dirty
+    option index-base $b/.glusterfs/indices
+    subvolumes ${V0}-io-threads
+end-volume
+
+volume $b
+    type debug/io-stats
+    option count-fop-hits off
+    option latency-measurement off
+    option log-level INFO
+    option unique-id $b
+    subvolumes ${V0}-index
+end-volume
+
+volume ${V0}-server
+    type protocol/server
+    option transport.listen-backlog 1024
+    option transport.socket.keepalive-count 9
+    option transport.socket.keepalive-interval 2
+    option transport.socket.keepalive-time 20
+    option transport.tcp-user-timeout 0
+    option transport.socket.keepalive 1
+    option auth.addr.$b.allow *
+    option auth-path $b
+    option auth.login.459d48e8-2a92-4f11-89f2-077b29f6f86d.password a0ad63dd-8314-4f97-9160-1b93e3cb1f0b
+    option auth.login.$b.allow 459d48e8-2a92-4f11-89f2-077b29f6f86d
+    option transport.address-family inet
+    option transport-type tcp
+    subvolumes $b
+end-volume
+EOF
+}
+
+function ta_set_port_by_name()
+{
+        if [ -z ${PORTMAP[$1]} ]
+        then
+                PORTMAP[$1]=$PORTCURR
+                PORTCURR=$((PORTCURR+1))
+        fi
+}
+
+function ta_start_brick_process()
+{
+        ta_set_port_by_name $1
+        local p=${PORTMAP[$1]}
+        if glusterfs -p $B0/${1}.pid --volfile=$B0/${1}.vol -l $(gluster --print-logdir)/${1}.log --xlator-option ${V0}-server.listen-port=$p
+        then
+                cat $B0/${1}.pid
+        else
+                echo ""
+                return 1
+        fi
+}
+
+function ta_start_ta_process()
+{
+        ta_set_port_by_name $1
+        local p=${PORTMAP[$1]}
+        if glusterfs -p $B0/${1}.pid --volfile=$B0/${1}.vol -l $(gluster --print-logdir)/${1}.log --xlator-option ta-server.listen-port=$p
+        then
+                cat $B0/${1}.pid
+        else
+                echo ""
+                return 1
+        fi
+}
+
+function ta_start_mount_process()
+{
+        mkdir -p $1
+        identifier=$(echo $1 | tr / .)
+        if glusterfs --entry-timeout=0 --attribute-timeout=0 -p $B0/${identifier}.pid --volfile=$B0/mount.vol $1
+        then
+                cat $B0/$identifier.pid
+        else
+                echo ""
+                return 1
+        fi
+}
+
+function ta_get_mount_pid()
+{
+    local mount_path=$1
+    identifier=$(echo $mount_path | tr / .)
+    cat $B0/${identifier}.pid
+}
+
+function ta_create_mount_volfile()
+{
+        local b0=$B0/$1
+        local b1=$B0/$2
+        local ta=$B0/$3
+        local b0_port=${PORTMAP[$1]}
+        local b1_port=${PORTMAP[$2]}
+        local ta_port=${PORTMAP[$3]}
+cat > $B0/mount.vol <<EOF
+volume ${V0}-client-0
+     type protocol/client
+     option remote-host $H0
+     option client-bind-insecure off
+     option transport.socket.keepalive-interval 2
+     option transport.socket.keepalive-time 20
+     option transport.socket.ssl-enabled off
+     option remote-subvolume $b0
+     option transport.tcp-user-timeout 0
+     option transport.socket.keepalive-count 9
+     option transport-type tcp
+     option ping-timeout 42
+     option send-gids on
+     option remote-port $b0_port
+     option password a0ad63dd-8314-4f97-9160-1b93e3cb1f0b
+     option username 459d48e8-2a92-4f11-89f2-077b29f6f86d
+end-volume
+
+volume ${V0}-client-1
+     type protocol/client
+     option remote-host $H0
+     option client-bind-insecure off
+     option transport.socket.keepalive-interval 2
+     option transport.socket.keepalive-time 20
+     option transport.socket.ssl-enabled off
+     option remote-subvolume $b1
+     option transport.tcp-user-timeout 0
+     option transport.socket.keepalive-count 9
+     option transport-type tcp
+     option ping-timeout 42
+     option send-gids on
+     option remote-port $b1_port
+     option password a0ad63dd-8314-4f97-9160-1b93e3cb1f0b
+     option username 459d48e8-2a92-4f11-89f2-077b29f6f86d
+end-volume
+
+volume ${V0}-thin-arbiter-client
+     type protocol/client
+     option client-bind-insecure off
+     option transport.socket.ssl-enabled off
+     option remote-subvolume $ta
+     option ping-timeout 42
+     option remote-host $H0
+     option send-gids on
+     option transport.socket.keepalive-interval 2
+     option remote-port $ta_port
+     option transport-type tcp
+     option transport.tcp-user-timeout 0
+     option transport.socket.keepalive-time 20
+     option transport.socket.keepalive-count 9
+end-volume
+
+volume ${V0}-replicate-0
+     type cluster/replicate
+     option afr-dirty-xattr trusted.afr.dirty
+     option iam-self-heal-daemon off
+     option afr-pending-xattr ${V0}-client-0,${V0}-client-1,${V0}-ta-2
+     option thin-arbiter $H0:$ta
+     subvolumes ${V0}-client-0 ${V0}-client-1 ${V0}-thin-arbiter-client
+end-volume
+
+volume ${V0}-distribute
+     type cluster/distribute
+     option rebal-throttle normal
+     option force-migration off
+     option lookup-optimize on
+     option weighted-rebalance on
+     option write-freq-threshold 0
+     option assert-no-child-down off
+     option lock-migration off
+     option lookup-unhashed on
+     option randomize-hash-range-by-gfid off
+     option unhashed-sticky-bit off
+     option use-readdirp on
+     option readdir-optimize off
+     option xattr-name trusted.glusterfs.dht
+     option read-freq-threshold 0
+     option min-free-disk 10%
+     option min-free-inodes 5%
+     option rebalance-stats off
+     subvolumes ${V0}-replicate-0
+end-volume
+
+volume ${V0}-write-behind
+     type performance/write-behind
+     option strict-O_DIRECT off
+     option strict-write-ordering off
+     option resync-failed-syncs-after-fsync off
+     option aggregate-size 128KB
+     option flush-behind on
+     option cache-size 1MB
+     option trickling-writes on
+     subvolumes ${V0}-distribute
+end-volume
+
+volume ${V0}-read-ahead
+     type performance/read-ahead
+     option force-atime-update false
+     option page-count 4
+     option page-size 131072
+     option pass-through false
+     subvolumes ${V0}-write-behind
+end-volume
+
+volume ${V0}-readdir-ahead
+     type performance/readdir-ahead
+     option rda-low-wmark 4096
+     option rda-high-wmark 128KB
+     option rda-cache-limit 10MB
+     option parallel-readdir off
+     option pass-through false
+     option rda-request-size 131072
+     subvolumes ${V0}-read-ahead
+end-volume
+
+volume ${V0}-io-cache
+     type performance/io-cache
+     option cache-timeout 1
+     option cache-size 32MB
+     option min-file-size 0
+     option max-file-size 0
+     option pass-through false
+     subvolumes ${V0}-readdir-ahead
+end-volume
+
+volume ${V0}-quick-read
+     type performance/quick-read
+     option cache-invalidation false
+     option ctime-invalidation false
+     option cache-size 128MB
+     option cache-timeout 1
+     option max-file-size 64KB
+     subvolumes ${V0}-io-cache
+end-volume
+
+volume ${V0}-open-behind
+     type performance/open-behind
+     option use-anonymous-fd yes
+     option lazy-open yes
+     option read-after-open no
+     option pass-through false
+     subvolumes ${V0}-quick-read
+end-volume
+
+volume ${V0}-md-cache
+     type performance/md-cache
+     option pass-through false
+     option cache-capability-xattrs true
+     option cache-posix-acl false
+     option cache-swift-metadata true
+     option cache-samba-metadata false
+     option md-cache-timeout 1
+     option force-readdirp true
+     option cache-invalidation false
+     option md-cache-statfs off
+     option cache-selinux false
+     option cache-ima-xattrs true
+     subvolumes ${V0}-open-behind
+end-volume
+
+volume ${V0}-io-threads
+     type performance/io-threads
+     option normal-prio-threads 16
+     option enable-least-priority on
+     option idle-time 120
+     option cleanup-disconnected-reqs off
+     option pass-through false
+     option thread-count 16
+     option high-prio-threads 16
+     option low-prio-threads 16
+     option least-prio-threads 1
+     subvolumes ${V0}-md-cache
+end-volume
+
+volume ${V0}
+     type debug/io-stats
+     option client-logger gluster-log
+     option client-log-buf-size 5
+     option latency-measurement off
+     option client-log-level INFO
+     option brick-log-level INFO
+     option count-fop-hits off
+     option sys-log-level CRITICAL
+     option brick-log-format with-msg-id
+     option brick-log-buf-size 5
+     option dump-fd-stats off
+     option ios-dump-interval 0
+     option ios-dump-format json
+     option client-log-format with-msg-id
+     option log-buf-size 5
+     option log-flush-timeout 120
+     option client-log-flush-timeout 120
+     option ios-sample-interval 0
+     option ios-sample-buf-size 65535
+     option brick-logger gluster-log
+     option ios-dnscache-ttl-sec 86400
+     option brick-log-flush-timeout 120
+     option unique-id /no/such/path
+     subvolumes ${V0}-io-threads
+end-volume
+EOF
+}
+
+function ta_kill_brick()
+{
+        local p=$(cat $B0/${1}.pid)
+        echo > $B0/${1}.pid
+        kill -9 $p
+}
+
+function ta_get_pid_by_brick_name()
+{
+        cat $B0/${1}.pid
+}
+
+function ta_up_status()
+{
+        local v=$1
+        local m=$2
+        local replica_id=$3
+        grep -E "^up = " $m/.meta/graphs/active/${v}-replicate-${replica_id}/private | cut -f2 -d'='
+}
+
+function ta_create_shd_volfile()
+{
+        local b0=$B0/$1
+        local b1=$B0/$2
+        local ta=$B0/$3
+        local b0_port=${PORTMAP[$1]}
+        local b1_port=${PORTMAP[$2]}
+        local ta_port=${PORTMAP[$3]}
+cat > $B0/glustershd.vol <<EOF
+volume ${V0}-replicate-0-client-0
+    type protocol/client
+    option send-gids on
+    option transport.socket.keepalive-interval 2
+    option remote-host $H0
+    option remote-subvolume $b0
+    option ping-timeout 42
+    option client-bind-insecure off
+    option transport.socket.own-thread off
+    option frame-timeout 1800
+    option non-blocking-io off
+    option transport.socket.keepalive 1
+    option transport.socket.keepalive-count 9
+    option transport.tcp-user-timeout 0
+    option transport.socket.nodelay 1
+    option transport.socket.keepalive-time 20
+    option transport.socket.read-fail-log off
+    option transport-type tcp
+    option filter-O_DIRECT disable
+    option event-threads 2
+    option transport.listen-backlog 1024
+    option transport.socket.ssl-enabled off
+    option password a0ad63dd-8314-4f97-9160-1b93e3cb1f0b
+    option username 459d48e8-2a92-4f11-89f2-077b29f6f86d
+    option remote-port $b0_port
+end-volume
+
+volume ${V0}-replicate-0-client-1
+    type protocol/client
+    option remote-host $H0
+    option transport.socket.keepalive-time 20
+    option transport.socket.keepalive-count 9
+    option transport.socket.own-thread off
+    option transport.socket.ssl-enabled off
+    option transport-type tcp
+    option remote-subvolume $b1
+    option event-threads 2
+    option transport.tcp-user-timeout 0
+    option transport.socket.keepalive 1
+    option transport.socket.nodelay 1
+    option transport.socket.read-fail-log off
+    option frame-timeout 1800
+    option ping-timeout 42
+    option client-bind-insecure off
+    option filter-O_DIRECT disable
+    option send-gids on
+    option non-blocking-io off
+    option transport.listen-backlog 1024
+    option transport.socket.keepalive-interval 2
+    option password a0ad63dd-8314-4f97-9160-1b93e3cb1f0b
+    option username 459d48e8-2a92-4f11-89f2-077b29f6f86d
+    option remote-port $b1_port
+end-volume
+
+volume ${V0}-replicate-0-thin-arbiter-client
+    type protocol/client
+    option frame-timeout 1800
+    option event-threads 2
+    option transport.listen-backlog 1024
+    option transport.socket.nodelay 1
+    option transport.socket.keepalive-count 9
+    option transport.socket.ssl-enabled off
+    option transport-type tcp
+    option remote-subvolume $ta
+    option filter-O_DIRECT disable
+    option non-blocking-io off
+    option transport.socket.keepalive-interval 2
+    option transport.socket.read-fail-log off
+    option remote-host $H0
+    option send-gids on
+    option transport.tcp-user-timeout 0
+    option transport.socket.keepalive-time 20
+    option ping-timeout 42
+    option client-bind-insecure off
+    option transport.socket.keepalive 1
+    option transport.socket.own-thread off
+    option remote-port $ta_port
+end-volume
+
+volume ${V0}-replicate-0
+    type cluster/replicate
+    option background-self-heal-count 8
+    option metadata-self-heal on
+    option data-change-log on
+    option entrylk-trace off
+    option iam-self-heal-daemon yes
+    option afr-dirty-xattr trusted.afr.dirty
+    option heal-timeout 10
+    option read-hash-mode 1
+    option metadata-splitbrain-forced-heal off
+    option thin-arbiter $H0:$ta
+    option shd-max-threads 1
+    option afr-pending-xattr ${V0}-client-0,${V0}-client-1,${V0}-ta-2
+    option halo-max-latency 5
+    option halo-max-replicas 99999
+    option entry-change-log on
+    option halo-nfsd-max-latency 5
+    option inodelk-trace off
+    option pre-op-compat on
+    option eager-lock on
+    option self-heal-readdir-size 1KB
+    option ensure-durability on
+    option locking-scheme full
+    option halo-enabled False
+    option heal-wait-queue-length 128
+    option entry-self-heal on
+    option self-heal-daemon on
+    option quorum-reads no
+    option shd-wait-qlength 1024
+    option choose-local true
+    option halo-min-replicas 2
+    option data-self-heal on
+    option metadata-change-log on
+    option consistent-metadata no
+    option full-lock yes
+    option use-compound-fops no
+    option halo-shd-max-latency 99999
+    option quorum-type none
+    option favorite-child-policy none
+    option read-subvolume-index -1
+    option optimistic-change-log on
+    option iam-nfs-daemon off
+    option post-op-delay-secs 1
+    option granular-entry-heal no
+    option consistent-io no
+    option data-self-heal-window-size 1
+    subvolumes ${V0}-replicate-0-client-0 ${V0}-replicate-0-client-1 ${V0}-replicate-0-thin-arbiter-client
+end-volume
+
+volume glustershd
+    type debug/io-stats
+    option log-buf-size 5
+    option ios-dump-format json
+    option latency-measurement off
+    option sys-log-level CRITICAL
+    option brick-log-level INFO
+    option client-logger gluster-log
+    option client-log-format with-msg-id
+    option brick-log-format with-msg-id
+    option client-log-buf-size 5
+    option log-flush-timeout 120
+    option ios-dump-interval 0
+    option ios-sample-interval 0
+    option ios-dnscache-ttl-sec 86400
+    option count-fop-hits off
+    option client-log-level INFO
+    option brick-logger gluster-log
+    option brick-log-buf-size 5
+    option ios-sample-buf-size 65535
+    option client-log-flush-timeout 120
+    option brick-log-flush-timeout 120
+    option unique-id /no/such/path
+    option dump-fd-stats off
+    subvolumes ${V0}-replicate-0
+end-volume
+EOF
+}
+
+function ta_start_shd_process()
+{
+        if glusterfs -p $B0/${1}.pid --volfile=$B0/${1}.vol -l $(gluster --print-logdir)/${1}.log --process-name=glustershd
+        then
+                cat $B0/${1}.pid
+        else
+                echo ""
+                return 1
+        fi
+}
+
+function ta_mount_child_up_status()
+{
+        local mount_path=$1
+        #brick_id is (brick-num in volume info - 1)
+        local vol=$2
+        local brick_id=$3
+        local pid=$(ta_get_mount_pid $mount_path)
+        local fpath=$(generate_statedump $pid)
+        up=$(grep -a -B1 trusted.afr.$vol-client-$brick_id $fpath | head -1 | cut -f2 -d'=')
+        rm -f $fpath
+        echo "$up"
+}
diff --git a/tests/tier.rc b/tests/tier.rc
deleted file mode 100644
index da6b0ee4777..00000000000
--- a/tests/tier.rc
+++ /dev/null
@@ -1,155 +0,0 @@
-#!/bin/bash
-
-# Common tier functions
-
-# Check if a file is being migrated
-# by checking for the presence of
-# the sticky bit
-# Args: $1 : path to file
-
-function is_sticky_set () {
-        echo $1
-        if [ -k $1 ];
-        then
-                echo "yes"
-        else
-                echo "no"
-        fi
-}
-
-
-function exists_and_regular_file () {
-        filepath=$1
-        if [ -n "$filepath" ];
-        then
-                if [ -k "$filepath" ]
-                then
-                        echo "no"
-                else
-                        echo "yes"
-                fi
-        else
-                echo "no"
-        fi
-}
-
-
-function check_counters {
-    index=0
-    ret=0
-    rm -f /tmp/tc*.txt
-    echo "0" > /tmp/tc2.txt
-    $CLI volume tier $V0 status | grep localhost > /tmp/tc.txt
-
-    promote=`cat /tmp/tc.txt |awk '{print $2}'`
-    demote=`cat /tmp/tc.txt |awk '{print $3}'`
-    if [ "${promote}" != "${1}" ]; then
-         echo "1" > /tmp/tc2.txt
-
-    elif [ "${demote}" != "${2}" ]; then
-         echo "2" > /tmp/tc2.txt
-    fi
-
-    # temporarily disable non-Linux tests.
-    case $OSTYPE in
-        NetBSD | FreeBSD | Darwin)
-            echo "0" > /tmp/tc2.txt
-            ;;
-    esac
-    cat /tmp/tc2.txt
-}
-
-
-function detach_start {
-        $CLI volume tier $1 detach start
-        echo $?;
-}
-
-
-# Grab md5sum without file path (failed attempt notifications are discarded)
-function fingerprint {
-    md5sum $1 2> /dev/null | grep --only-matching -m 1 '^[0-9a-f]*'
-}
-
-
-
-# Create a large number of files in the current directory.
-# $1 : file name prefix. Will create files $2-1 to $2-$3
-# $2 : number of files
-
-function create_many_files {
-    filename=$1
-    num=$2
-
-    for i in `seq 1 $num`; do
-        dd if=/dev/urandom of=./${dirname}/${filename}$i bs=104857 count=1;
-    done
-}
-
-
-function confirm_tier_removed {
-    $CLI system getspec $V0 | grep $1
-    if [ $? == 0 ]; then
-        echo "1"
-    else
-        echo "0"
-    fi
-}
-
-function confirm_vol_stopped {
-    $CLI volume stop $1
-    if [ $? == 0 ]; then
-        echo "0"
-    else
-        echo "1"
-    fi
-}
-
-
-function sleep_first_cycle {
-    startTime=$(date +%s)
-    mod=$(( ( $startTime % $1 ) + 1 ))
-    sleep $mod
-}
-
-function sleep_until_mid_cycle {
-    startTime=$(date +%s)
-    mod=$(( ( $startTime % $1 ) + 1 ))
-    mod=$(( $1 - $mod ))
-    mod=$(( $mod + $1 / 2 ))
-    sleep $mod
-}
-
-function tier_daemon_check () {
-    pgrep -f "tierd/$V0"
-    echo "$?"
-}
-
-function rebalance_run_time () {
-    local time=$($CLI volume tier $1 status | awk '{print $6}' | sed -n 3p);
-    local hh=$(echo $time | cut -d ':' -f1);
-    local mm=$(echo $time | cut -d ':' -f2);
-    local ss=$(echo $time | cut -d ':' -f3);
-    local total=$(($hh * 3600 + $mm * 60 + $ss));
-    echo $total;
-}
-
-function tier_detach_commit () {
-	$CLI_1 volume tier $V0 detach commit | grep "success" | wc -l
-}
-
-function tier_detach_status_node_down () {
-        $CLI_1 volume tier $V0 detach status | grep "WARNING" | wc -l
-}
-
-function tier_status_node_down () {
-        $CLI_1 volume tier $V0 status | grep "WARNING" | wc -l
-}
-
-function tier_detach_status () {
-        $CLI_1 volume tier $V0 detach status | grep "success" | wc -l
-}
-
-function wait_for_tier_start () {
-        sleep 5
-}
diff --git a/tests/utils/arequal-checksum.c b/tests/utils/arequal-checksum.c
index aede4f48adb..b51a054162b 100644
--- a/tests/utils/arequal-checksum.c
+++ b/tests/utils/arequal-checksum.c
@@ -31,7 +31,7 @@
 
 /*
  * FTW_ACTIONRETVAL is a GNU libc extension. It is used here to skip
- * hiearchies. On other systems we will still walk the tree, ignoring
+ * hierarchies. On other systems we will still walk the tree, ignoring
  * entries.
  */
 #ifndef FTW_ACTIONRETVAL
@@ -41,605 +41,593 @@
 int debug = 0;
 
 typedef struct {
-        char test_directory[4096];
-        char **ignored_directory;
-        unsigned int directories_ignored;
+    char test_directory[4096];
+    char **ignored_directory;
+    unsigned int directories_ignored;
 } arequal_config_t;
 
 static arequal_config_t arequal_config;
 
 static error_t
-arequal_parse_opts (int key, char *arg, struct argp_state *_state);
+arequal_parse_opts(int key, char *arg, struct argp_state *_state);
 
 static struct argp_option arequal_options[] = {
-        { "ignore", 'i', "IGNORED", 0,
-          "entry in the given path to be ignored"},
-        { "path", 'p', "PATH", 0, "path where arequal has to be run"},
-        {0, 0, 0, 0, 0}
-};
-
-#define DBG(fmt ...) do {                       \
-                if (debug) {                    \
-                        fprintf (stderr, "D "); \
-                        fprintf (stderr, fmt);  \
-                }                               \
-        } while (0)
+    {"ignore", 'i', "IGNORED", 0, "entry in the given path to be ignored"},
+    {"path", 'p', "PATH", 0, "path where arequal has to be run"},
+    {0, 0, 0, 0, 0}};
+
+#define DBG(fmt...)                                                            \
+    do {                                                                       \
+        if (debug) {                                                           \
+            fprintf(stderr, "D ");                                             \
+            fprintf(stderr, fmt);                                              \
+        }                                                                      \
+    } while (0)
 
 void
-add_to_list (char *arg);
+add_to_list(char *arg);
 void
-get_absolute_path (char directory[], char *arg);
+get_absolute_path(char directory[], char *arg);
 
-static int roof(int a, int b)
+static int
+roof(int a, int b)
 {
-        return ((((a)+(b)-1)/((b)?(b):1))*(b));
+    return ((((a) + (b)-1) / ((b) ? (b) : 1)) * (b));
 }
 
 void
-add_to_list (char *arg)
+add_to_list(char *arg)
 {
-        char *string = NULL;
-        int index = 0;
+    char *string = NULL;
+    int index = 0;
 
-        index = arequal_config.directories_ignored - 1;
-        string = strdup (arg);
+    index = arequal_config.directories_ignored - 1;
+    string = strdup(arg);
 
-        if (!arequal_config.ignored_directory) {
-                arequal_config.ignored_directory = calloc (1, sizeof (char *));
-        } else
-                arequal_config.ignored_directory =
-                        realloc (arequal_config.ignored_directory,
-                                 sizeof (char *) * (index+1));
+    if (!arequal_config.ignored_directory) {
+        arequal_config.ignored_directory = calloc(1, sizeof(char *));
+    } else
+        arequal_config.ignored_directory = realloc(
+            arequal_config.ignored_directory, sizeof(char *) * (index + 1));
 
-        arequal_config.ignored_directory[index] = string;
+    arequal_config.ignored_directory[index] = string;
 }
 
 static error_t
-arequal_parse_opts (int key, char *arg, struct argp_state *_state)
+arequal_parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        switch (key) {
-        case 'i':
-        {
-                arequal_config.directories_ignored++;
-                add_to_list (arg);
-        }
-        break;
-        case 'p':
-        {
-                if (arg[0] == '/')
-                        strcpy (arequal_config.test_directory, arg);
-                else
-                        get_absolute_path (arequal_config.test_directory, arg);
-
-                if (arequal_config.test_directory
-                    [strlen(arequal_config.test_directory) - 1] == '/')
-                        arequal_config.test_directory
-                                [strlen(arequal_config.test_directory) - 1] = '\0';
-        }
-        break;
+    switch (key) {
+        case 'i': {
+            arequal_config.directories_ignored++;
+            add_to_list(arg);
+        } break;
+        case 'p': {
+            if (arg[0] == '/')
+                strcpy(arequal_config.test_directory, arg);
+            else
+                get_absolute_path(arequal_config.test_directory, arg);
+
+            if (arequal_config
+                    .test_directory[strlen(arequal_config.test_directory) -
+                                    1] == '/')
+                arequal_config
+                    .test_directory[strlen(arequal_config.test_directory) - 1] =
+                    '\0';
+        } break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
+            break;
         case ARGP_KEY_END:
-                if (_state->argc == 1) {
-                       argp_usage (_state);
-                }
+            if (_state->argc == 1) {
+                argp_usage(_state);
+            }
+    }
 
-        }
-
-        return 0;
+    return 0;
 }
 
 void
-get_absolute_path (char directory[], char *arg)
+get_absolute_path(char directory[], char *arg)
 {
-        char   cwd[4096] = {0,};
-
-        if (getcwd (cwd, sizeof (cwd)) == NULL)
-                printf ("some error in getting cwd\n");
-
-        if (strcmp (arg, ".") != 0) {
-                if (cwd[strlen(cwd)] != '/')
-                        cwd[strlen (cwd)] = '/';
-                strcat (cwd, arg);
-        }
-        strcpy (directory, cwd);
+    char cwd[4096] = {
+        0,
+    };
+
+    if (getcwd(cwd, sizeof(cwd)) == NULL)
+        printf("some error in getting cwd\n");
+
+    if (strcmp(arg, ".") != 0) {
+        if (cwd[strlen(cwd)] != '/')
+            cwd[strlen(cwd)] = '/';
+        strcat(cwd, arg);
+    }
+    strcpy(directory, cwd);
 }
 
 static struct argp argp = {
-        arequal_options,
-        arequal_parse_opts,
-        "",
-        "arequal - Tool which calculates the checksum of all the entries"
-        "present in a given directory"
-};
+    arequal_options, arequal_parse_opts, "",
+    "arequal - Tool which calculates the checksum of all the entries"
+    "present in a given directory"};
 
 /* All this runs in single thread, hence using 'global' variables */
 
-unsigned long long     avg_uid_file    = 0;
-unsigned long long     avg_uid_dir     = 0;
-unsigned long long     avg_uid_symlink = 0;
-unsigned long long     avg_uid_other   = 0;
+unsigned long long avg_uid_file = 0;
+unsigned long long avg_uid_dir = 0;
+unsigned long long avg_uid_symlink = 0;
+unsigned long long avg_uid_other = 0;
 
-unsigned long long     avg_gid_file    = 0;
-unsigned long long     avg_gid_dir     = 0;
-unsigned long long     avg_gid_symlink = 0;
-unsigned long long     avg_gid_other   = 0;
+unsigned long long avg_gid_file = 0;
+unsigned long long avg_gid_dir = 0;
+unsigned long long avg_gid_symlink = 0;
+unsigned long long avg_gid_other = 0;
 
-unsigned long long     avg_mode_file    = 0;
-unsigned long long     avg_mode_dir     = 0;
-unsigned long long     avg_mode_symlink = 0;
-unsigned long long     avg_mode_other   = 0;
+unsigned long long avg_mode_file = 0;
+unsigned long long avg_mode_dir = 0;
+unsigned long long avg_mode_symlink = 0;
+unsigned long long avg_mode_other = 0;
 
 unsigned long long global_ctime_checksum = 0;
 
+unsigned long long count_dir = 0;
+unsigned long long count_file = 0;
+unsigned long long count_symlink = 0;
+unsigned long long count_other = 0;
 
-unsigned long long      count_dir        = 0;
-unsigned long long      count_file       = 0;
-unsigned long long      count_symlink    = 0;
-unsigned long long      count_other      = 0;
+unsigned long long checksum_file1 = 0;
+unsigned long long checksum_file2 = 0;
+unsigned long long checksum_dir = 0;
+unsigned long long checksum_symlink = 0;
+unsigned long long checksum_other = 0;
 
+unsigned long long
+checksum_path(const char *path)
+{
+    unsigned long long csum = 0;
+    unsigned long long *nums = 0;
+    int len = 0;
+    int cnt = 0;
 
-unsigned long long      checksum_file1   = 0;
-unsigned long long      checksum_file2   = 0;
-unsigned long long      checksum_dir     = 0;
-unsigned long long      checksum_symlink = 0;
-unsigned long long      checksum_other   = 0;
+    len = roof(strlen(path), sizeof(csum));
+    cnt = len / sizeof(csum);
 
+    nums = __builtin_alloca(len);
+    memset(nums, 0, len);
+    strcpy((char *)nums, path);
 
-unsigned long long
-checksum_path (const char *path)
-{
-        unsigned long long   csum = 0;
-        unsigned long long  *nums = 0;
-        int                  len = 0;
-        int                  cnt = 0;
-
-        len = roof (strlen (path), sizeof (csum));
-        cnt = len / sizeof (csum);
-
-        nums = __builtin_alloca (len);
-        memset (nums, 0, len);
-        strcpy ((char *)nums, path);
-
-        while (cnt) {
-                csum ^= *nums;
-                nums++;
-                cnt--;
-        }
+    while (cnt) {
+        csum ^= *nums;
+        nums++;
+        cnt--;
+    }
 
-        return csum;
+    return csum;
 }
 
 int
-checksum_md5 (const char *path, const struct stat *sb)
+checksum_md5(const char *path, const struct stat *sb)
 {
-        uint64_t    this_data_checksum = 0;
-        FILE       *filep              = NULL;
-        char        *cmd               = NULL;
-        char        strvalue[17]       = {0,};
-        int         ret                = -1;
-        int         len                = 0;
-        const char  *pos               = NULL;
-        char        *cpos              = NULL;
-
-        /* Have to escape single-quotes in filename.
-         * First, calculate the size of the buffer I'll need.
-         */
-        for (pos = path; *pos; pos++) {
-                if ( *pos == '\'' )
-                        len += 4;
-                else
-                        len += 1;
-        }
-
-        cmd = malloc(sizeof(char) * (len + 20));
-        cmd[0] = '\0';
-
-        /* Now, build the command with single quotes escaped. */
-
-        cpos = cmd;
+    uint64_t this_data_checksum = 0;
+    FILE *filep = NULL;
+    char *cmd = NULL;
+    char strvalue[17] = {
+        0,
+    };
+    int ret = -1;
+    int len = 0;
+    const char *pos = NULL;
+    char *cpos = NULL;
+
+    /* Have to escape single-quotes in filename.
+     * First, calculate the size of the buffer I'll need.
+     */
+    for (pos = path; *pos; pos++) {
+        if (*pos == '\'')
+            len += 4;
+        else
+            len += 1;
+    }
+
+    cmd = malloc(sizeof(char) * (len + 20));
+    cmd[0] = '\0';
+
+    /* Now, build the command with single quotes escaped. */
+
+    cpos = cmd;
 #if defined(linux)
-        strcpy(cpos, "md5sum '");
-        cpos += 8;
+    strcpy(cpos, "md5sum '");
+    cpos += 8;
 #elif defined(__NetBSD__)
-        strcpy(cpos, "md5 -n '");
-        cpos += 8;
+    strcpy(cpos, "md5 -n '");
+    cpos += 8;
 #elif defined(__FreeBSD__) || defined(__APPLE__)
-        strcpy(cpos, "md5 -q '");
-        cpos += 8;
+    strcpy(cpos, "md5 -q '");
+    cpos += 8;
 #else
 #error "Please add system-specific md5 command"
 #endif
 
-        /* Add the file path, with every single quotes replaced with this sequence:
-         * '\''
-         */
-
-        for (pos = path; *pos; pos++) {
-                if ( *pos == '\'' ) {
-                        strcpy(cpos, "'\\''");
-                        cpos += 4;
-                } else {
-                        *cpos = *pos;
-                        cpos++;
-                }
-        }
-
-        /* Add on the trailing single-quote and null-terminate. */
-        strcpy(cpos, "'");
-
-        filep = popen (cmd, "r");
-        if (!filep) {
-                perror (path);
-                goto out;
-        }
-
-        if (fread (strvalue, sizeof (char), 16, filep) != 16) {
-                fprintf (stderr, "%s: short read\n", path);
-                goto out;
+    /* Add the file path, with every single quotes replaced with this sequence:
+     * '\''
+     */
+
+    for (pos = path; *pos; pos++) {
+        if (*pos == '\'') {
+            strcpy(cpos, "'\\''");
+            cpos += 4;
+        } else {
+            *cpos = *pos;
+            cpos++;
         }
-
-        this_data_checksum = strtoull (strvalue, NULL, 16);
-        if (-1 == this_data_checksum) {
-                fprintf (stderr, "%s: %s\n", strvalue, strerror (errno));
-                goto out;
-        }
-        checksum_file1 ^= this_data_checksum;
-
-        if (fread (strvalue, sizeof (char), 16, filep) != 16) {
-                fprintf (stderr, "%s: short read\n", path);
-                goto out;
-        }
-
-        this_data_checksum = strtoull (strvalue, NULL, 16);
-        if (-1 == this_data_checksum) {
-                fprintf (stderr, "%s: %s\n", strvalue, strerror (errno));
-                goto out;
-        }
-        checksum_file2 ^= this_data_checksum;
-
-        ret = 0;
+    }
+
+    /* Add on the trailing single-quote and null-terminate. */
+    strcpy(cpos, "'");
+
+    filep = popen(cmd, "r");
+    if (!filep) {
+        perror(path);
+        goto out;
+    }
+
+    if (fread(strvalue, sizeof(char), 16, filep) != 16) {
+        fprintf(stderr, "%s: short read\n", path);
+        goto out;
+    }
+
+    this_data_checksum = strtoull(strvalue, NULL, 16);
+    if (-1 == this_data_checksum) {
+        fprintf(stderr, "%s: %s\n", strvalue, strerror(errno));
+        goto out;
+    }
+    checksum_file1 ^= this_data_checksum;
+
+    if (fread(strvalue, sizeof(char), 16, filep) != 16) {
+        fprintf(stderr, "%s: short read\n", path);
+        goto out;
+    }
+
+    this_data_checksum = strtoull(strvalue, NULL, 16);
+    if (-1 == this_data_checksum) {
+        fprintf(stderr, "%s: %s\n", strvalue, strerror(errno));
+        goto out;
+    }
+    checksum_file2 ^= this_data_checksum;
+
+    ret = 0;
 out:
-        if (filep)
-                pclose (filep);
+    if (filep)
+        pclose(filep);
 
-        if (cmd)
-                free(cmd);
+    if (cmd)
+        free(cmd);
 
-        return ret;
+    return ret;
 }
 
 int
-checksum_filenames (const char *path, const struct stat *sb)
+checksum_filenames(const char *path, const struct stat *sb)
 {
-        DIR                *dirp = NULL;
-        struct dirent      *entry = NULL;
-        unsigned long long  csum = 0;
-        int                 i = 0;
-        int                 found = 0;
-
-        dirp = opendir (path);
-        if (!dirp) {
-                perror (path);
-                goto out;
-        }
-
-        errno = 0;
-        while ((entry = readdir (dirp))) {
-                /* do not calculate the checksum of the entries which user has
-                   told to ignore and proceed to other siblings.*/
-                if (arequal_config.ignored_directory) {
-                        for (i = 0;i < arequal_config.directories_ignored;i++) {
-                                if ((strcmp (entry->d_name,
-                                             arequal_config.ignored_directory[i])
-                                     == 0)) {
-                                        found = 1;
-                                        DBG ("ignoring the entry %s\n",
-                                             entry->d_name);
-                                        break;
-                                }
-                        }
-                        if (found == 1) {
-                                found = 0;
-                                continue;
-                        }
+    DIR *dirp = NULL;
+    struct dirent *entry = NULL;
+    unsigned long long csum = 0;
+    int i = 0;
+    int found = 0;
+
+    dirp = opendir(path);
+    if (!dirp) {
+        perror(path);
+        goto out;
+    }
+
+    errno = 0;
+    while ((entry = readdir(dirp))) {
+        /* do not calculate the checksum of the entries which user has
+           told to ignore and proceed to other siblings.*/
+        if (arequal_config.ignored_directory) {
+            for (i = 0; i < arequal_config.directories_ignored; i++) {
+                if ((strcmp(entry->d_name,
+                            arequal_config.ignored_directory[i]) == 0)) {
+                    found = 1;
+                    DBG("ignoring the entry %s\n", entry->d_name);
+                    break;
                 }
-                csum = checksum_path (entry->d_name);
-                checksum_dir ^= csum;
+            }
+            if (found == 1) {
+                found = 0;
+                continue;
+            }
         }
+        csum = checksum_path(entry->d_name);
+        checksum_dir ^= csum;
+    }
 
-        if (errno) {
-                perror (path);
-                goto out;
-        }
+    if (errno) {
+        perror(path);
+        goto out;
+    }
 
 out:
-        if (dirp)
-                closedir (dirp);
+    if (dirp)
+        closedir(dirp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-process_file (const char *path, const struct stat *sb)
+process_file(const char *path, const struct stat *sb)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        count_file++;
+    count_file++;
 
-        avg_uid_file ^= sb->st_uid;
-        avg_gid_file ^= sb->st_gid;
-        avg_mode_file ^= sb->st_mode;
+    avg_uid_file ^= sb->st_uid;
+    avg_gid_file ^= sb->st_gid;
+    avg_mode_file ^= sb->st_mode;
 
-        ret = checksum_md5 (path, sb);
+    ret = checksum_md5(path, sb);
 
-        return ret;
+    return ret;
 }
 
-
 int
-process_dir (const char *path, const struct stat *sb)
+process_dir(const char *path, const struct stat *sb)
 {
-        unsigned long long csum = 0;
+    unsigned long long csum = 0;
 
-        count_dir++;
+    count_dir++;
 
-        avg_uid_dir ^= sb->st_uid;
-        avg_gid_dir ^= sb->st_gid;
-        avg_mode_dir ^= sb->st_mode;
+    avg_uid_dir ^= sb->st_uid;
+    avg_gid_dir ^= sb->st_gid;
+    avg_mode_dir ^= sb->st_mode;
 
-        csum = checksum_filenames (path, sb);
+    csum = checksum_filenames(path, sb);
 
-        checksum_dir ^= csum;
+    checksum_dir ^= csum;
 
-        return 0;
+    return 0;
 }
 
-
 int
-process_symlink (const char *path, const struct stat *sb)
+process_symlink(const char *path, const struct stat *sb)
 {
-        int                ret = 0;
-        char               buf[4096] = {0, };
-        unsigned long long csum = 0;
+    int ret = 0;
+    char buf[4096] = {
+        0,
+    };
+    unsigned long long csum = 0;
 
-        count_symlink++;
+    count_symlink++;
 
-        avg_uid_symlink ^= sb->st_uid;
-        avg_gid_symlink ^= sb->st_gid;
-        avg_mode_symlink ^= sb->st_mode;
+    avg_uid_symlink ^= sb->st_uid;
+    avg_gid_symlink ^= sb->st_gid;
+    avg_mode_symlink ^= sb->st_mode;
 
-        ret = readlink (path, buf, 4096);
-        if (ret < 0) {
-                perror (path);
-                goto out;
-        }
+    ret = readlink(path, buf, 4096);
+    if (ret < 0) {
+        perror(path);
+        goto out;
+    }
 
-        DBG ("readlink (%s) => %s\n", path, buf);
+    DBG("readlink (%s) => %s\n", path, buf);
 
-        csum = checksum_path (buf);
+    csum = checksum_path(buf);
 
-        DBG ("checksum_path (%s) => %llx\n", buf, csum);
+    DBG("checksum_path (%s) => %llx\n", buf, csum);
 
-        checksum_symlink ^= csum;
+    checksum_symlink ^= csum;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-process_other (const char *path, const struct stat *sb)
+process_other(const char *path, const struct stat *sb)
 {
-        count_other++;
+    count_other++;
 
-        avg_uid_other ^= sb->st_uid;
-        avg_gid_other ^= sb->st_gid;
-        avg_mode_other ^= sb->st_mode;
+    avg_uid_other ^= sb->st_uid;
+    avg_gid_other ^= sb->st_gid;
+    avg_mode_other ^= sb->st_mode;
 
-        checksum_other ^= sb->st_rdev;
+    checksum_other ^= sb->st_rdev;
 
-        return 0;
+    return 0;
 }
 
 static int
 ignore_entry(const char *bname, const char *dname)
 {
-        int i;
+    int i;
 
-	for (i  = 0; i < arequal_config.directories_ignored; i++) {
-		if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 &&
-                    strncmp(arequal_config.test_directory, dname,
-                            strlen(arequal_config.test_directory)) == 0)
-                        return 1;
-        }
+    for (i = 0; i < arequal_config.directories_ignored; i++) {
+        if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 &&
+            strncmp(arequal_config.test_directory, dname,
+                    strlen(arequal_config.test_directory)) == 0)
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-process_entry (const char *path, const struct stat *sb,
-               int typeflag, struct FTW *ftwbuf)
+process_entry(const char *path, const struct stat *sb, int typeflag,
+              struct FTW *ftwbuf)
 {
-        int ret = 0;
-        char *name = NULL;
-        char *bname = NULL;
-        char *dname = NULL;
-        int  i = 0;
-
-        /* The if condition below helps in ignoring some directories in
-           the given path. If the name of the entry is one of the directory
-           names that the user told to ignore, then that directory will not
-           be processed and will return FTW_SKIP_SUBTREE to nftw which will
-           not crawl this directory and move on to other siblings.
-           Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL
-           should be passed as an argument to nftw.
-
-           This mainly helps in calculating the checksum of network filesystems
-           (client-server), where the server might have some hidden directories
-           for managing the filesystem. So to calculate the sanity of filesytem
-           one has to get the checksum of the client and then the export directory
-           of server by telling arequal to ignore some of the directories which
-           are not part of the namespace.
-        */
-
-        if (arequal_config.ignored_directory) {
+    int ret = 0;
+    char *name = NULL;
+    char *bname = NULL;
+    char *dname = NULL;
+    int i = 0;
+
+    /* The if condition below helps in ignoring some directories in
+       the given path. If the name of the entry is one of the directory
+       names that the user told to ignore, then that directory will not
+       be processed and will return FTW_SKIP_SUBTREE to nftw which will
+       not crawl this directory and move on to other siblings.
+       Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL
+       should be passed as an argument to nftw.
+
+       This mainly helps in calculating the checksum of network filesystems
+       (client-server), where the server might have some hidden directories
+       for managing the filesystem. So to calculate the sanity of filesystem
+       one has to get the checksum of the client and then the export directory
+       of server by telling arequal to ignore some of the directories which
+       are not part of the namespace.
+    */
+
+    if (arequal_config.ignored_directory) {
 #ifndef FTW_SKIP_SUBTREE
-                char *cp;
-
-                name = strdup (path);
-                dname = dirname (name);
-
-                for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) {
-                        if (ignore_entry(cp, dname)) {
-                                DBG ("ignoring %s\n", path);
-                                if (name)
-                                        free (name);
-                                return 0;
-                        }
-                }
-#else /* FTW_SKIP_SUBTREE */
-                name = strdup (path);
-
-                name[strlen(name)] = '\0';
-
-                bname = strrchr (name, '/');
-                if (bname)
-                        bname++;
-
-                dname = dirname (name);
-                if (ignore_entry(bname, dname)) {
-                                DBG ("ignoring %s\n", bname);
-                                ret = FTW_SKIP_SUBTREE;
-                                if (name)
-                                        free (name);
-                                return ret;
-                }
-#endif /* FTW_SKIP_SUBTREE */
+        char *cp;
+
+        name = strdup(path);
+        dname = dirname(name);
+
+        for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) {
+            if (ignore_entry(cp, dname)) {
+                DBG("ignoring %s\n", path);
+                if (name)
+                    free(name);
+                return 0;
+            }
         }
+#else  /* FTW_SKIP_SUBTREE */
+        name = strdup(path);
+
+        name[strlen(name)] = '\0';
+
+        bname = strrchr(name, '/');
+        if (bname)
+            bname++;
+
+        dname = dirname(name);
+        if (ignore_entry(bname, dname)) {
+            DBG("ignoring %s\n", bname);
+            ret = FTW_SKIP_SUBTREE;
+            if (name)
+                free(name);
+            return ret;
+        }
+#endif /* FTW_SKIP_SUBTREE */
+    }
 
-        DBG ("processing entry %s\n", path);
+    DBG("processing entry %s\n", path);
 
-        switch ((S_IFMT & sb->st_mode)) {
+    switch ((S_IFMT & sb->st_mode)) {
         case S_IFDIR:
-                ret = process_dir (path, sb);
-                break;
+            ret = process_dir(path, sb);
+            break;
         case S_IFREG:
-                ret = process_file (path, sb);
-                break;
+            ret = process_file(path, sb);
+            break;
         case S_IFLNK:
-                ret = process_symlink (path, sb);
-                break;
+            ret = process_symlink(path, sb);
+            break;
         default:
-                ret = process_other (path, sb);
-                break;
-        }
+            ret = process_other(path, sb);
+            break;
+    }
 
-        if (name)
-                free (name);
-        return ret;
+    if (name)
+        free(name);
+    return ret;
 }
 
-
 int
-display_counts (FILE *fp)
+display_counts(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Entry counts\n");
-        fprintf (fp, "Regular files   : %lld\n", count_file);
-        fprintf (fp, "Directories     : %lld\n", count_dir);
-        fprintf (fp, "Symbolic links  : %lld\n", count_symlink);
-        fprintf (fp, "Other           : %lld\n", count_other);
-        fprintf (fp, "Total           : %lld\n",
-                 (count_file + count_dir + count_symlink + count_other));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Entry counts\n");
+    fprintf(fp, "Regular files   : %lld\n", count_file);
+    fprintf(fp, "Directories     : %lld\n", count_dir);
+    fprintf(fp, "Symbolic links  : %lld\n", count_symlink);
+    fprintf(fp, "Other           : %lld\n", count_other);
+    fprintf(fp, "Total           : %lld\n",
+            (count_file + count_dir + count_symlink + count_other));
+
+    return 0;
 }
 
-
 int
-display_checksums (FILE *fp)
+display_checksums(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Checksums\n");
-        fprintf (fp, "Regular files   : %llx%llx\n", checksum_file1, checksum_file2);
-        fprintf (fp, "Directories     : %llx\n", checksum_dir);
-        fprintf (fp, "Symbolic links  : %llx\n", checksum_symlink);
-        fprintf (fp, "Other           : %llx\n", checksum_other);
-        fprintf (fp, "Total           : %llx\n",
-                 (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^ checksum_other));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Checksums\n");
+    fprintf(fp, "Regular files   : %llx%llx\n", checksum_file1, checksum_file2);
+    fprintf(fp, "Directories     : %llx\n", checksum_dir);
+    fprintf(fp, "Symbolic links  : %llx\n", checksum_symlink);
+    fprintf(fp, "Other           : %llx\n", checksum_other);
+    fprintf(fp, "Total           : %llx\n",
+            (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^
+             checksum_other));
+
+    return 0;
 }
 
-
 int
-display_metadata (FILE *fp)
+display_metadata(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Metadata checksums\n");
-        fprintf (fp, "Regular files   : %llx\n",
-                 (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7));
-        fprintf (fp, "Directories     : %llx\n",
-                 (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7));
-        fprintf (fp, "Symbolic links  : %llx\n",
-                 (avg_uid_symlink + 13) * (avg_gid_symlink + 11) * (avg_mode_symlink + 7));
-        fprintf (fp, "Other           : %llx\n",
-                 (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Metadata checksums\n");
+    fprintf(fp, "Regular files   : %llx\n",
+            (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7));
+    fprintf(fp, "Directories     : %llx\n",
+            (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7));
+    fprintf(fp, "Symbolic links  : %llx\n",
+            (avg_uid_symlink + 13) * (avg_gid_symlink + 11) *
+                (avg_mode_symlink + 7));
+    fprintf(fp, "Other           : %llx\n",
+            (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7));
+
+    return 0;
 }
 
 int
-display_stats (FILE *fp)
+display_stats(FILE *fp)
 {
-        display_counts (fp);
+    display_counts(fp);
 
-        display_metadata (fp);
+    display_metadata(fp);
 
-        display_checksums (fp);
+    display_checksums(fp);
 
-        return 0;
+    return 0;
 }
 
-
 int
 main(int argc, char *argv[])
 {
-        int  ret = 0;
-        int  i = 0;
-
-        ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
-        if (ret != 0) {
-                fprintf (stderr, "parsing arguments failed\n");
-                return -2;
-        }
-
-         /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */
-         /* the return value of the callback function */
-         /* (process_entry in this case) */
-        ret = nftw (arequal_config.test_directory, process_entry, 30,
-                    FTW_ACTIONRETVAL|FTW_PHYS|FTW_MOUNT);
-        if (ret != 0) {
-                fprintf (stderr, "ftw (%s) returned %d (%s), terminating\n",
-                         argv[1], ret, strerror (errno));
-                return 1;
-        }
-
-        display_stats (stdout);
-
-        if (arequal_config.ignored_directory) {
-                for (i = 0; i < arequal_config.directories_ignored; i++) {
-                        if (arequal_config.ignored_directory[i])
-                            free (arequal_config.ignored_directory[i]);
-                }
-                free (arequal_config.ignored_directory);
+    int ret = 0;
+    int i = 0;
+
+    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
+    if (ret != 0) {
+        fprintf(stderr, "parsing arguments failed\n");
+        return -2;
+    }
+
+    /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */
+    /* the return value of the callback function */
+    /* (process_entry in this case) */
+    ret = nftw(arequal_config.test_directory, process_entry, 30,
+               FTW_ACTIONRETVAL | FTW_PHYS | FTW_MOUNT);
+    if (ret != 0) {
+        fprintf(stderr, "ftw (%s) returned %d (%s), terminating\n", argv[1],
+                ret, strerror(errno));
+        return 1;
+    }
+
+    display_stats(stdout);
+
+    if (arequal_config.ignored_directory) {
+        for (i = 0; i < arequal_config.directories_ignored; i++) {
+            if (arequal_config.ignored_directory[i])
+                free(arequal_config.ignored_directory[i]);
         }
+        free(arequal_config.ignored_directory);
+    }
 
-        return 0;
+    return 0;
 }
diff --git a/tests/utils/changelog/changelog.h b/tests/utils/changelog/changelog.h
new file mode 100644
index 00000000000..1502b689eb4
--- /dev/null
+++ b/tests/utils/changelog/changelog.h
@@ -0,0 +1,125 @@
+/*
+   Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#ifndef _GF_CHANGELOG_H
+#define _GF_CHANGELOG_H
+
+struct gf_brick_spec;
+
+/**
+ * Max bit shiter for event selection
+ */
+#define CHANGELOG_EV_SELECTION_RANGE 5
+
+#define CHANGELOG_OP_TYPE_JOURNAL (1 << 0)
+#define CHANGELOG_OP_TYPE_OPEN (1 << 1)
+#define CHANGELOG_OP_TYPE_CREATE (1 << 2)
+#define CHANGELOG_OP_TYPE_RELEASE (1 << 3)
+#define CHANGELOG_OP_TYPE_BR_RELEASE                                           \
+    (1 << 4) /* logical release (last close()),                                \
+                sent by bitrot stub */
+#define CHANGELOG_OP_TYPE_MAX (1 << CHANGELOG_EV_SELECTION_RANGE)
+
+struct ev_open {
+    unsigned char gfid[16];
+    int32_t flags;
+};
+
+struct ev_creat {
+    unsigned char gfid[16];
+    int32_t flags;
+};
+
+struct ev_release {
+    unsigned char gfid[16];
+};
+
+struct ev_release_br {
+    unsigned long version;
+    unsigned char gfid[16];
+    int32_t sign_info;
+};
+
+struct ev_changelog {
+    char path[PATH_MAX];
+};
+
+typedef struct changelog_event {
+    unsigned int ev_type;
+
+    union {
+        struct ev_open open;
+        struct ev_creat create;
+        struct ev_release release;
+        struct ev_changelog journal;
+        struct ev_release_br releasebr;
+    } u;
+} changelog_event_t;
+
+#define CHANGELOG_EV_SIZE (sizeof(changelog_event_t))
+
+/**
+ * event callback, connected & disconnection defs
+ */
+typedef void(CALLBACK)(void *, char *, void *, changelog_event_t *);
+typedef void *(INIT)(void *, struct gf_brick_spec *);
+typedef void(FINI)(void *, char *, void *);
+typedef void(CONNECT)(void *, char *, void *);
+typedef void(DISCONNECT)(void *, char *, void *);
+
+struct gf_brick_spec {
+    char *brick_path;
+    unsigned int filter;
+
+    INIT *init;
+    FINI *fini;
+    CALLBACK *callback;
+    CONNECT *connected;
+    DISCONNECT *disconnected;
+
+    void *ptr;
+};
+
+/* API set */
+
+int
+gf_changelog_register(char *brick_path, char *scratch_dir, char *log_file,
+                      int log_levl, int max_reconnects);
+ssize_t
+gf_changelog_scan();
+
+int
+gf_changelog_start_fresh();
+
+ssize_t
+gf_changelog_next_change(char *bufptr, size_t maxlen);
+
+int
+gf_changelog_done(char *file);
+
+/* newer flexible API */
+int
+gf_changelog_init(void *xl);
+
+int
+gf_changelog_register_generic(struct gf_brick_spec *bricks, int count,
+                              int ordered, char *logfile, int lvl, void *xl);
+
+int
+gf_history_changelog(char *changelog_dir, unsigned long start,
+                     unsigned long end, int n_parallel,
+                     unsigned long *actual_end);
+int
+gf_history_changelog_scan();
+ssize_t
+gf_history_changelog_next_change(char *bufptr, size_t maxlen);
+int
+gf_history_changelog_done(char *file);
+#endif
diff --git a/tests/utils/changelog/get-history.c b/tests/utils/changelog/get-history.c
new file mode 100644
index 00000000000..9963ab76958
--- /dev/null
+++ b/tests/utils/changelog/get-history.c
@@ -0,0 +1,71 @@
+/*
+   Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+/**
+ * get set of new changes every 10 seconds (just print the file names)
+ *
+ * Compile it using:
+ *  gcc -o gethistory `pkg-config --cflags libgfchangelog` get-history.c \
+ *  `pkg-config --libs libgfchangelog`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include "changelog.h"
+
+int
+main(int argc, char **argv)
+{
+    int ret = 0;
+    unsigned long end_ts = 0;
+    int start = 0;
+    int end = 0;
+
+    ret = gf_changelog_init(NULL);
+    if (ret) {
+        printf("-1");
+        fflush(stdout);
+        return -1;
+    }
+
+    ret = gf_changelog_register("/d/backends/patchy0", "/tmp/scratch_v1",
+                                "/var/log/glusterfs/changes.log", 9, 5);
+    if (ret) {
+        printf("-2");
+        fflush(stdout);
+        return -1;
+    }
+
+    start = atoi(argv[1]);
+    end = atoi(argv[2]);
+
+    ret = gf_history_changelog("/d/backends/patchy0/.glusterfs/changelogs",
+                               start, end, 3, &end_ts);
+    if (ret < 0) {
+        printf("-3");
+        fflush(stdout);
+        return -1;
+    } else if (ret == 1) {
+        printf("1");
+        fflush(stdout);
+        return 0;
+    }
+
+out:
+    printf("0");
+    fflush(stdout);
+    return 0;
+}
diff --git a/tests/utils/changelog/test-changelog-api.c b/tests/utils/changelog/test-changelog-api.c
new file mode 100644
index 00000000000..f4eb066b630
--- /dev/null
+++ b/tests/utils/changelog/test-changelog-api.c
@@ -0,0 +1,98 @@
+/*
+   Copyright (c) 2019 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+/**
+ * get set of new changes every 5 seconds (just print the file names)
+ *
+ * Compile it using:
+ *  gcc -o getchanges `pkg-config --cflags libgfchangelog` get-changes.c \
+ *  `pkg-config --libs libgfchangelog`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <errno.h>
+
+#include "changelog.h"
+
+int
+main(int argc, char **argv)
+{
+    int i = 0;
+    int ret = 0;
+    ssize_t nr_changes = 0;
+    ssize_t changes = 0;
+    char fbuf[PATH_MAX] = {
+        0,
+    };
+
+    ret = gf_changelog_init(NULL);
+    if (ret) {
+        printf("-1");
+        fflush(stdout);
+        return -1;
+    }
+
+    /* get changes for brick "/d/backends/patchy0" */
+    ret = gf_changelog_register("/d/backends/patchy0", "/tmp/scratch_v1",
+                                "/var/log/glusterfs/changes.log", 9, 5);
+    if (ret) {
+        printf("-2");
+        fflush(stdout);
+        return -1;
+    }
+
+    while (1) {
+        i = 0;
+        nr_changes = gf_changelog_scan();
+        if (nr_changes < 0) {
+            printf("-4");
+            fflush(stdout);
+            return -1;
+        }
+
+        if (nr_changes == 0)
+            goto next;
+
+        while ((changes = gf_changelog_next_change(fbuf, PATH_MAX)) > 0) {
+            /* process changelog */
+            /* ... */
+            /* ... */
+            /* ... */
+            /* done processing */
+
+            ret = gf_changelog_done(fbuf);
+            if (ret) {
+                printf("-5");
+                fflush(stdout);
+                return -1;
+            }
+        }
+
+        if (changes == -1) {
+            printf("-6");
+            fflush(stdout);
+            return -1;
+        }
+
+    next:
+        sleep(2);
+    }
+
+out:
+    printf("0");
+    fflush(stdout);
+    return ret;
+}
diff --git a/tests/utils/changelog/test-history-api.c b/tests/utils/changelog/test-history-api.c
new file mode 100644
index 00000000000..d78e387df10
--- /dev/null
+++ b/tests/utils/changelog/test-history-api.c
@@ -0,0 +1,111 @@
+/*
+   Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+/**
+ * get set of new changes every 10 seconds (just print the file names)
+ *
+ * Compile it using:
+ *  gcc -o gethistory `pkg-config --cflags libgfchangelog` get-history.c \
+ *  `pkg-config --libs libgfchangelog`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include "changelog.h"
+
+int
+main(int argc, char **argv)
+{
+    int ret = 0;
+    int i = 0;
+    unsigned long end_ts = 0;
+    ssize_t nr_changes = 0;
+    ssize_t changes = 0;
+    int start = 0;
+    int end = 0;
+    char fbuf[PATH_MAX] = {
+        0,
+    };
+
+    ret = gf_changelog_init(NULL);
+    if (ret) {
+        printf("-1");
+        fflush(stdout);
+        return -1;
+    }
+
+    ret = gf_changelog_register("/d/backends/patchy0", "/tmp/scratch_v1",
+                                "/var/log/glusterfs/changes.log", 9, 5);
+    if (ret) {
+        printf("-2");
+        fflush(stdout);
+        return -1;
+    }
+
+    start = atoi(argv[1]);
+    end = atoi(argv[2]);
+
+    ret = gf_history_changelog("/d/backends/patchy0/.glusterfs/changelogs",
+                               start, end, 3, &end_ts);
+    if (ret < 0) {
+        printf("-3");
+        fflush(stdout);
+        return -1;
+    } else if (ret == 1) {
+        printf("1");
+        fflush(stdout);
+        return 0;
+    }
+
+    while (1) {
+        nr_changes = gf_history_changelog_scan();
+        if (nr_changes < 0) {
+            printf("-4");
+            fflush(stdout);
+            return -1;
+        }
+
+        if (nr_changes == 0) {
+            goto out;
+        }
+
+        while ((changes = gf_history_changelog_next_change(fbuf, PATH_MAX)) >
+               0) {
+            /* process changelog */
+            /* ... */
+            /* ... */
+            /* ... */
+            /* done processing */
+
+            ret = gf_history_changelog_done(fbuf);
+            if (ret) {
+                printf("-5");
+                fflush(stdout);
+                return -1;
+            }
+        }
+        if (changes == -1) {
+            printf("-6");
+            fflush(stdout);
+            return -1;
+        }
+    }
+
+out:
+    printf("0");
+    fflush(stdout);
+    return 0;
+}
diff --git a/tests/utils/changelogparser.py b/tests/utils/changelogparser.py
new file mode 100644
index 00000000000..3b8f81d1bad
--- /dev/null
+++ b/tests/utils/changelogparser.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+"""
+Why?
+
+Converts this
+
+GlusterFS Changelog | version: v1.1 | encoding : 2
+E0b99ef11-4b79-4cd0-9730-b5a0e8c4a8c0^@4^@16877^@0^@0^@00000000-0000-0000-0000-
+000000000001/dir1^@Ec5250af6-720e-4bfe-b938-827614304f39^@23^@33188^@0^@0^@0b99
+ef11-4b79-4cd0-9730-b5a0e8c4a8c0/hello.txt^@Dc5250af6-720e-4bfe-b938-827614304f
+39^@Dc5250af6-720e-4bfe-b938-827614304f39^@
+
+
+to human readable :)
+
+E 0b99ef11-4b79-4cd0-9730-b5a0e8c4a8c0 MKDIR 16877 0 000000000-0000-0000-0000
+  -000000000001/dir1
+E c5250af6-720e-4bfe-b938-827614304f39 CREATE 33188 0 0 0b99ef11-4b79-4cd0-9730
+  -b5a0e8c4a8c0/hello.txt
+D c5250af6-720e-4bfe-b938-827614304f39
+D c5250af6-720e-4bfe-b938-827614304f39
+
+
+"""
+import sys
+import codecs
+
+ENTRY = 'E'
+META = 'M'
+DATA = 'D'
+SEP = "\x00"
+
+GF_FOP = [
+    "NULL", "STAT", "READLINK", "MKNOD", "MKDIR", "UNLINK",
+    "RMDIR", "SYMLINK", "RENAME", "LINK", "TRUNCATE", "OPEN",
+    "READ", "WRITE", "STATFS", "FLUSH", "FSYNC", "SETXATTR",
+    "GETXATTR", "REMOVEXATTR", "OPENDIR", "FSYNCDIR", "ACCESS",
+    "CREATE", "FTRUNCATE", "FSTAT", "LK", "LOOKUP", "READDIR",
+    "INODELK", "FINODELK", "ENTRYLK", "FENTRYLK", "XATTROP",
+    "FXATTROP", "FSETXATTR", "FGETXATTR", "RCHECKSUM", "SETATTR",
+    "FSETATTR", "READDIRP", "GETSPEC", "FORGET", "RELEASE",
+    "RELEASEDIR", "FREMOVEXATTR", "FALLOCATE", "DISCARD", "ZEROFILL"]
+
+
+class NumTokens_V11(object):
+    E = 7
+    M = 3
+    D = 2
+    NULL = 3
+    MKNOD = 7
+    MKDIR = 7
+    UNLINK = 4
+    RMDIR = 4
+    SYMLINK = 4
+    RENAME = 5
+    LINK = 4
+    SETXATTR = 3
+    REMOVEXATTR = 3
+    CREATE = 7
+    SETATTR = 3
+    FTRUNCATE = 3
+    FXATTROP = 3
+
+
+class NumTokens_V12(NumTokens_V11):
+    UNLINK = 5
+    RMDIR = 5
+
+
+class Version:
+    V11 = "v1.1"
+    V12 = "v1.2"
+
+
+class Record(object):
+    def __init__(self, **kwargs):
+        self.ts = kwargs.get("ts", None)
+        self.fop_type = kwargs.get("fop_type", None)
+        self.gfid = kwargs.get("gfid", None)
+        self.path = kwargs.get("path", None)
+        self.fop = kwargs.get("fop", None)
+        self.path1 = kwargs.get("path1", None)
+        self.path2 = kwargs.get("path2", None)
+        self.mode = kwargs.get("mode", None)
+        self.uid = kwargs.get("uid", None)
+        self.gid = kwargs.get("gid", None)
+
+    def create_mknod_mkdir(self, **kwargs):
+        self.path = kwargs.get("path", None)
+        self.fop = kwargs.get("fop", None)
+        self.mode = kwargs.get("mode", None)
+        self.uid = kwargs.get("uid", None)
+        self.gid = kwargs.get("gid", None)
+
+    def metadata(self, **kwargs):
+        self.fop = kwargs.get("fop", None)
+
+    def rename(self, **kwargs):
+        self.fop = kwargs.get("fop", None)
+        self.path1 = kwargs.get("path1", None)
+        self.path2 = kwargs.get("path2", None)
+
+    def link_symlink_unlink_rmdir(self, **kwargs):
+        self.path = kwargs.get("path", None)
+        self.fop = kwargs.get("fop", None)
+
+    def __unicode__(self):
+        if self.fop_type == "D":
+            return u"{ts} {fop_type} {gfid}".format(**self.__dict__)
+        elif self.fop_type == "M":
+            return u"{ts} {fop_type} {gfid} {fop}".format(**self.__dict__)
+        elif self.fop_type == "E":
+            if self.fop in ["CREATE", "MKNOD", "MKDIR"]:
+                return (u"{ts} {fop_type} {gfid} {fop} "
+                        u"{path} {mode} {uid} {gid}".format(**self.__dict__))
+            elif self.fop == "RENAME":
+                return (u"{ts} {fop_type} {gfid} {fop} "
+                        u"{path1} {path2}".format(**self.__dict__))
+            elif self.fop in ["LINK", "SYMLINK", "UNLINK", "RMDIR"]:
+                return (u"{ts} {fop_type} {gfid} {fop} "
+                        u"{path}".format(**self.__dict__))
+            else:
+                return repr(self.__dict__)
+        else:
+            return repr(self.__dict__)
+
+    def __str__(self):
+        if sys.version_info >= (3,):
+            return self.__unicode__()
+        else:
+            return unicode(self).encode('utf-8')
+
+
+def get_num_tokens(data, tokens, version=Version.V11):
+    if version == Version.V11:
+        cls_numtokens = NumTokens_V11
+    elif version == Version.V12:
+        cls_numtokens = NumTokens_V12
+    else:
+        sys.stderr.write("Unknown Changelog Version\n")
+        sys.exit(1)
+
+    if data[tokens[0]] in [ENTRY, META]:
+        if len(tokens) >= 3:
+            return getattr(cls_numtokens, GF_FOP[int(data[tokens[2]])])
+        else:
+            return None
+    else:
+        return getattr(cls_numtokens, data[tokens[0]])
+
+
+def process_record(data, tokens, changelog_ts, callback):
+    if data[tokens[0]] in [ENTRY, META]:
+        try:
+            tokens[2] = GF_FOP[int(data[tokens[2]])]
+        except ValueError:
+            tokens[2] = "NULL"
+
+    if not changelog_ts:
+        ts1 = int(changelog_ts)
+    else:
+        ts1=""
+    record = Record(ts=ts1, fop_type=data[tokens[0]],
+                    gfid=data[tokens[1]])
+    if data[tokens[0]] == META:
+        record.metadata(fop=tokens[2])
+    elif data[tokens[0]] == ENTRY:
+        if tokens[2] in ["CREATE", "MKNOD", "MKDIR"]:
+            record.create_mknod_mkdir(fop=tokens[2],
+                                      path=data[tokens[6]],
+                                      mode=int(data[tokens[3]]),
+                                      uid=int(data[tokens[4]]),
+                                      gid=int(data[tokens[5]]))
+        elif tokens[2] == "RENAME":
+            record.rename(fop=tokens[2],
+                          path1=data[tokens[3]],
+                          path2=data[tokens[4]])
+        if tokens[2] in ["LINK", "SYMLINK", "UNLINK", "RMDIR"]:
+            record.link_symlink_unlink_rmdir(fop=tokens[2],
+                                             path=data[tokens[3]])
+    callback(record)
+
+
+def default_callback(record):
+    sys.stdout.write(u"{0}\n".format(record))
+
+
+def parse(filename, callback=default_callback):
+    data = None
+    tokens = []
+    changelog_ts = filename.rsplit(".")[-1]
+    with codecs.open(filename, mode="rb", encoding="utf-8") as f:
+        # GlusterFS Changelog | version: v1.1 | encoding : 2
+        header = f.readline()
+        version = header.split()[4]
+
+        data = f.readline()
+
+        slice_start = 0
+        in_record = False
+
+        prev_char = ""
+        next_char = ""
+        for i, c in enumerate(data):
+            next_char = ""
+            if len(data) >= (i + 2):
+                next_char = data[i+1]
+
+            if not in_record and c in [ENTRY, META, DATA]:
+                tokens.append(slice(slice_start, i+1))
+                slice_start = i+1
+                in_record = True
+                continue
+
+            if c == SEP and ((prev_char != SEP and next_char == SEP) or
+                             (prev_char == SEP and next_char != SEP) or
+                             (prev_char != SEP and next_char != SEP)):
+                tokens.append(slice(slice_start, i))
+                slice_start = i+1
+
+                num_tokens = get_num_tokens(data, tokens, version)
+
+                if num_tokens == len(tokens):
+                    process_record(data, tokens, changelog_ts, callback)
+                    in_record = False
+                    tokens = []
+
+            prev_char = c
+
+        # process last record
+        if slice_start < (len(data) - 1):
+            tokens.append(slice(slice_start, len(data)))
+            process_record(data, tokens, changelog_ts, callback)
+            tokens = []
+
+parse(sys.argv[1])
diff --git a/tests/utils/create-files.py b/tests/utils/create-files.py
index bef4201bf1f..04736e9c73b 100755
--- a/tests/utils/create-files.py
+++ b/tests/utils/create-files.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python2
 
 # This script was developed by Vijaykumar Koppad (vkoppad@redhat.com)
 # The latest version of this script can found at
@@ -20,6 +19,11 @@ import argparse
 datsiz = 0
 timr = 0
 
+def get_ascii_upper_alpha_digits():
+    if sys.version_info > (3,0):
+        return string.ascii_uppercase+string.digits
+    else:
+        return string.uppercase+string.digits
 
 def setLogger(filename):
     global logger
@@ -51,7 +55,7 @@ def os_rd(src, size):
 def os_wr(dest, data):
     global timr
     st = time.time()
-    fd = os.open(dest, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0644)
+    fd = os.open(dest, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
     os.write(fd, data)
     os.close(fd)
     ed = time.time()
@@ -88,7 +92,7 @@ def create_txt_file(fil, size, mins, maxs, rand):
     else:
         data = os_rd("/etc/services", 512*1024)
         file_size = 0
-        fd = os.open(fil, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0644)
+        fd = os.open(fil, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
         while file_size < size:
             os.write(fd, data)
             file_size += 500*1024
@@ -112,7 +116,7 @@ def create_tar_file(fil, size, mins, maxs, rand):
 
 def get_filename(flen):
     size = flen
-    char = string.uppercase+string.digits
+    char = get_ascii_upper_alpha_digits()
     st = ''.join(random.choice(char) for i in range(size))
     ti = str((hex(int(str(time.time()).split('.')[0])))[2:])
     return ti+"%%"+st
@@ -176,7 +180,7 @@ def tar_files(files, file_count, inter, size, mins, maxs,
 
 
 def setxattr_files(files, randname, dir_path):
-    char = string.uppercase+string.digits
+    char = get_ascii_upper_alpha_digits()
     if not randname:
         for k in range(files):
             v = ''.join(random.choice(char) for i in range(10))
@@ -323,9 +327,9 @@ def human2bytes(size):
 
 def bytes2human(byts):
     abbr = {
-        1 << 30L: "GB",
-        1 << 20L: "MB",
-        1 << 10L: "KB",
+        1 << 30: "GB",
+        1 << 20: "MB",
+        1 << 10: "KB",
         1: "bytes"
     }
     if byts == 1:
diff --git a/tests/utils/get-mdata-xattr.c b/tests/utils/get-mdata-xattr.c
new file mode 100644
index 00000000000..e9f54717263
--- /dev/null
+++ b/tests/utils/get-mdata-xattr.c
@@ -0,0 +1,152 @@
+/*
+   Copyright (c) 2019 Red Hat, Inc. <http://www.redhat.com>
+   This file is part of GlusterFS.
+
+   This file is licensed to you under your choice of the GNU Lesser
+   General Public License, version 3 or any later version (LGPLv3 or
+   later), or the GNU General Public License, version 2 (GPLv2), in all
+   cases as published by the Free Software Foundation.
+*/
+
+#include <stdlib.h>
+#include <endian.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/xattr.h>
+#include <errno.h>
+
+typedef struct gf_timespec_disk {
+    uint64_t tv_sec;
+    uint64_t tv_nsec;
+} gf_timespec_disk_t;
+
+/* posix_mdata_t on disk structure */
+typedef struct __attribute__((__packed__)) posix_mdata_disk {
+    /* version of structure, bumped up if any new member is added */
+    uint8_t version;
+    /* flags indicates valid fields in the structure */
+    uint64_t flags;
+    gf_timespec_disk_t ctime;
+    gf_timespec_disk_t mtime;
+    gf_timespec_disk_t atime;
+} posix_mdata_disk_t;
+
+/* In memory representation posix metadata xattr */
+typedef struct {
+    /* version of structure, bumped up if any new member is added */
+    uint8_t version;
+    /* flags indicates valid fields in the structure */
+    uint64_t flags;
+    struct timespec ctime;
+    struct timespec mtime;
+    struct timespec atime;
+} posix_mdata_t;
+
+#define GF_XATTR_MDATA_KEY "trusted.glusterfs.mdata"
+
+/* posix_mdata_from_disk converts posix_mdata_disk_t into host byte order
+ */
+static inline void
+posix_mdata_from_disk(posix_mdata_t *out, posix_mdata_disk_t *in)
+{
+    out->version = in->version;
+    out->flags = be64toh(in->flags);
+
+    out->ctime.tv_sec = be64toh(in->ctime.tv_sec);
+    out->ctime.tv_nsec = be64toh(in->ctime.tv_nsec);
+
+    out->mtime.tv_sec = be64toh(in->mtime.tv_sec);
+    out->mtime.tv_nsec = be64toh(in->mtime.tv_nsec);
+
+    out->atime.tv_sec = be64toh(in->atime.tv_sec);
+    out->atime.tv_nsec = be64toh(in->atime.tv_nsec);
+}
+
+/* posix_fetch_mdata_xattr fetches the posix_mdata_t from disk */
+static int
+posix_fetch_mdata_xattr(const char *real_path, posix_mdata_t *metadata)
+{
+    size_t size = -1;
+    char *value = NULL;
+    char gfid_str[64] = {0};
+
+    char *key = GF_XATTR_MDATA_KEY;
+
+    if (!metadata || !real_path) {
+        goto err;
+    }
+
+    /* Get size */
+    size = lgetxattr(real_path, key, NULL, 0);
+    if (size == -1) {
+        goto err;
+    }
+
+    value = calloc(size + 1, sizeof(char));
+    if (!value) {
+        goto err;
+    }
+
+    /* Get xattr value */
+    size = lgetxattr(real_path, key, value, size);
+    if (size == -1) {
+        goto err;
+    }
+    posix_mdata_from_disk(metadata, (posix_mdata_disk_t *)value);
+
+out:
+    if (value)
+        free(value);
+    return 0;
+err:
+    if (value)
+        free(value);
+    return -1;
+}
+
+int
+main(int argc, char *argv[])
+{
+    posix_mdata_t metadata;
+    uint64_t result;
+
+    if (argc != 3) {
+        /*
+        Usage: get_mdata_xattr -c|-m|-a <file-name>
+                       where -c --> ctime
+                             -m --> mtime
+                             -a --> atime
+        */
+        printf("-1");
+        goto err;
+    }
+
+    if (posix_fetch_mdata_xattr(argv[2], &metadata)) {
+        printf("-1");
+        goto err;
+    }
+
+    switch (argv[1][1]) {
+        case 'c':
+            result = metadata.ctime.tv_sec;
+            break;
+        case 'm':
+            result = metadata.mtime.tv_sec;
+            break;
+        case 'a':
+            result = metadata.atime.tv_sec;
+            break;
+        default:
+            printf("-1");
+            goto err;
+    }
+    printf("%" PRIu64, result);
+    fflush(stdout);
+    return 0;
+err:
+    fflush(stdout);
+    return -1;
+}
diff --git a/tests/utils/getfattr.py b/tests/utils/getfattr.py
index 1a8369af7c4..3eb40e1c887 100755
--- a/tests/utils/getfattr.py
+++ b/tests/utils/getfattr.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python2
 
+from __future__ import print_function
 import os
 import sys
 from optparse import OptionParser
@@ -32,22 +32,22 @@ def getfattr(path, option):
 def print_getfattr (path, option, encoded_attr=None):
     if encoded_attr:
         if option.encoding == "hex":
-            print ("%s=0x%s" % (option.name, encoded_attr))
+            print(("%s=0x%s" % (option.name, encoded_attr)))
         elif option.encoding == "base64":
-            print ("%s=0s%s" % (option.name, encoded_attr))
+            print(("%s=0s%s" % (option.name, encoded_attr)))
         else:
-            print ("%s=\"%s\"" % (option.name, encoded_attr))
+            print(("%s=\"%s\"" % (option.name, encoded_attr)))
     else:
-        print option.name
+        print(option.name)
 
     return
 
 def print_header (path, absnames):
     if absnames:
-        print ("# file: %s" % path)
+        print(("# file: %s" % path))
     else:
         print ("getfattr: Removing leading '/' from absolute path names")
-        print ("# file: %s" % path[1:])
+        print(("# file: %s" % path[1:]))
 
 if __name__ == '__main__':
     usage = "usage: %prog [-n name|-d] [-e en] [-m pattern] path...."
@@ -64,7 +64,7 @@ if __name__ == '__main__':
                       " them. Valid values of [en] are `text`, `hex`,"
                       " and `base64`. Values encoded as text strings are"
                       " enclosed in double quotes (\"), while strings"
-                      " encoded as hexidecimal and base64 are prefixed with"
+                      " encoded as hexadecimal and base64 are prefixed with"
                       " 0x and 0s, respectively.")
     parser.add_option("-m", action="store", dest="pattern", type="string",
                       help="Only include attributes with names matching the"
@@ -99,8 +99,8 @@ if __name__ == '__main__':
         if (not (option.encoding.strip() == "hex" or
                  option.encoding.strip() == "base64" or
                  option.encoding.strip() == "text")):
-            print ("unrecognized encoding parameter... %s, please use"
-                   " `text`, `base64` or `hex`" % option.encoding)
+            print(("unrecognized encoding parameter... %s, please use"
+                   " `text`, `base64` or `hex`" % option.encoding))
             sys.exit(1)
 
     args[0] = os.path.abspath(args[0])
@@ -110,7 +110,7 @@ if __name__ == '__main__':
         try:
             getfattr(args[0], option)
         except KeyError as err:
-            print ("Invalid key %s" % err)
+            print(("Invalid key %s" % err))
             sys.exit(1)
         except IOError as err:
             print (err)
diff --git a/tests/utils/gfid-access.py b/tests/utils/gfid-access.py
index 81258073da1..c35c1223df6 100755
--- a/tests/utils/gfid-access.py
+++ b/tests/utils/gfid-access.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python2
 #
 # Copyright (c) 2011-2014 Red Hat, Inc. <http://www.redhat.com>
 # This file is part of GlusterFS.
@@ -9,6 +8,7 @@
 # cases as published by the Free Software Foundation.
 #
 
+from __future__ import print_function
 import os
 import sys
 import stat
@@ -33,28 +33,56 @@ def _fmt_mkdir(l):
 def _fmt_symlink(l1, l2):
     return "!II%dsI%ds%ds" % (37, l1+1, l2+1)
 
-def entry_pack_reg(gf, bn, mo, uid, gid):
-    blen = len(bn)
-    return struct.pack(_fmt_mknod(blen),
-                       uid, gid, gf, mo, bn,
-                       stat.S_IMODE(mo), 0, umask())
 
-def entry_pack_dir(gf, bn, mo, uid, gid):
-    blen = len(bn)
-    return struct.pack(_fmt_mkdir(blen),
-                       uid, gid, gf, mo, bn,
-                       stat.S_IMODE(mo), umask())
-
-def entry_pack_symlink(gf, bn, lnk, mo, uid, gid):
-    blen = len(bn)
-    llen = len(lnk)
-    return struct.pack(_fmt_symlink(blen, llen),
-                       uid, gid, gf, mo, bn, lnk)
+if sys.version_info > (3,):
+    def entry_pack_reg(gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(_fmt_mknod(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), 0, umask())
+
+    # mkdir
+    def entry_pack_dir(gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(_fmt_mkdir(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), umask())
+    # symlink
+    def entry_pack_symlink(gf, bn, lnk, st):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        lnk_encoded = lnk.encode()
+        llen = len(lnk_encoded)
+        return struct.pack(_fmt_symlink(blen, llen),
+                           st['uid'], st['gid'],
+                           gf.encode(), st['mode'], bn_encoded,
+                           lnk_encoded)
+
+else:
+    def entry_pack_reg(gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(_fmt_mknod(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), 0, umask())
+
+    def entry_pack_dir(gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(_fmt_mkdir(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), umask())
+
+    def entry_pack_symlink(gf, bn, lnk, mo, uid, gid):
+        blen = len(bn)
+        llen = len(lnk)
+        return struct.pack(_fmt_symlink(blen, llen),
+                           uid, gid, gf, mo, bn, lnk)
 
 if __name__ == '__main__':
     if len(sys.argv) < 9:
-        print("USAGE: %s <mount> <pargfid|ROOT> <filename> <GFID> <file type>"
-              " <uid> <gid> <file permission(octal str)>" % (sys.argv[0]))
+        print(("USAGE: %s <mount> <pargfid|ROOT> <filename> <GFID> <file type>"
+              " <uid> <gid> <file permission(octal str)>" % (sys.argv[0])))
         sys.exit(-1) # nothing to do
     mtpt       = sys.argv[1]
     pargfid    = sys.argv[2]
@@ -63,7 +91,7 @@ if __name__ == '__main__':
     ftype      = sys.argv[5]
     uid        = int(sys.argv[6])
     gid        = int(sys.argv[7])
-    perm       = int(sys.argv[8],8)
+    perm       = int(sys.argv[8], 8)
 
     os.chdir(mtpt)
     if pargfid == 'ROOT':
@@ -92,5 +120,5 @@ if __name__ == '__main__':
         if not ex.errno in [EEXIST]:
             raise
             sys.exit(-1)
-    print "File creation OK"
+    print("File creation OK")
     sys.exit(0)
diff --git a/tests/utils/libcxattr.py b/tests/utils/libcxattr.py
index 149db72e6ee..3f3ed1fffbb 100644
--- a/tests/utils/libcxattr.py
+++ b/tests/utils/libcxattr.py
@@ -10,13 +10,14 @@
 
 import os
 import sys
-from ctypes import CDLL, c_int, create_string_buffer
-from ctypes.util import find_library
+from ctypes import CDLL, c_int
+from py2py3 import bytearray_to_str, gr_create_string_buffer
+from py2py3 import gr_query_xattr, gr_lsetxattr, gr_lremovexattr
 
 
 class Xattr(object):
 
-    """singleton that wraps the extended attribues system
+    """singleton that wraps the extended attributes system
        interface for python using ctypes
 
        Just implement it to the degree we need it, in particular
@@ -28,9 +29,9 @@ class Xattr(object):
 
     if sys.hexversion >= 0x02060000:
         from ctypes import DEFAULT_MODE
-        libc = CDLL(find_library("libc"), DEFAULT_MODE, None, True)
+        libc = CDLL("libc.so.6", DEFAULT_MODE, None, True)
     else:
-        libc = CDLL(find_library("libc"))
+        libc = CDLL("libc.so.6")
 
     @classmethod
     def geterrno(cls):
@@ -48,20 +49,23 @@ class Xattr(object):
     @classmethod
     def _query_xattr(cls, path, siz, syscall, *a):
         if siz:
-            buf = create_string_buffer('\0' * siz)
+            buf = gr_create_string_buffer(siz)
         else:
             buf = None
         ret = getattr(cls.libc, syscall)(*((path,) + a + (buf, siz)))
         if ret == -1:
             cls.raise_oserr()
         if siz:
-            return buf.raw[:ret]
+            # py2 and py3 compatibility. Convert bytes array
+            # to string
+            result = bytearray_to_str(buf.raw)
+            return result[:ret]
         else:
             return ret
 
     @classmethod
     def lgetxattr(cls, path, attr, siz=0):
-        return cls._query_xattr(path, siz, 'lgetxattr', attr)
+        return gr_query_xattr(cls, path, siz, 'lgetxattr', attr)
 
     @classmethod
     def lgetxattr_buf(cls, path, attr):
@@ -75,20 +79,21 @@ class Xattr(object):
 
     @classmethod
     def llistxattr(cls, path, siz=0):
-        ret = cls._query_xattr(path, siz, 'llistxattr')
+        ret = gr_query_xattr(cls, path, siz, 'llistxattr')
         if isinstance(ret, str):
-            ret = ret.split('\0')
+            ret = ret.strip('\0')
+            ret = ret.split('\0') if ret else []
         return ret
 
     @classmethod
     def lsetxattr(cls, path, attr, val):
-        ret = cls.libc.lsetxattr(path, attr, val, len(val), 0)
+        ret = gr_lsetxattr(cls, path, attr, val)
         if ret == -1:
             cls.raise_oserr()
 
     @classmethod
     def lremovexattr(cls, path, attr):
-        ret = cls.libc.lremovexattr(path, attr)
+        ret = gr_lremovexattr(cls, path, attr)
         if ret == -1:
             cls.raise_oserr()
 
diff --git a/tests/utils/pidof.py b/tests/utils/pidof.py
index 575b899b6cc..4b7071c0a48 100755
--- a/tests/utils/pidof.py
+++ b/tests/utils/pidof.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python
 
+from __future__ import print_function
 import sys
 
 try:
@@ -21,14 +21,14 @@ def pidof(processname):
             continue
         if "gluster" in processname:
             if processname == "glusterd" and pmap_find(p, "glusterd"):
-                print (p.pid)
+                print((p.pid))
             if processname == "glusterfs" and pmap_find(p, "client"):
-                print (p.pid)
+                print((p.pid))
             if processname == "glusterfsd" and pmap_find(p, "posix-acl"):
-                print (p.pid)
+                print((p.pid))
             continue
         if processname.strip() == p.name():
-            print (p.pid)
+            print((p.pid))
 
 def main(argv):
     if len(argv) < 2:
@@ -37,7 +37,7 @@ def main(argv):
     try:
         pidof(argv[1])
     except Exception as err:
-        print err
+        print(err)
         sys.stderr.write("Please be root - %s\n" % err);
         sys.exit(1)
 
diff --git a/tests/utils/py2py3.py b/tests/utils/py2py3.py
new file mode 100644
index 00000000000..63aca10fd26
--- /dev/null
+++ b/tests/utils/py2py3.py
@@ -0,0 +1,186 @@
+#
+# Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+# This file is part of GlusterFS.
+
+# This file is licensed to you under your choice of the GNU Lesser
+# General Public License, version 3 or any later version (LGPLv3 or
+# later), or the GNU General Public License, version 2 (GPLv2), in all
+# cases as published by the Free Software Foundation.
+#
+
+# All python2/python3 compatibility routines
+
+import sys
+import os
+import stat
+import struct
+from ctypes import create_string_buffer
+
+def umask():
+    return os.umask(0)
+
+if sys.version_info >= (3,):
+    def pipe():
+        (r, w) = os.pipe()
+        os.set_inheritable(r, True)
+        os.set_inheritable(w, True)
+        return (r, w)
+
+    # Raw conversion of bytearray to string. Used in the cases where
+    # buffer is created by create_string_buffer which is a 8-bit char
+    # array and passed to syscalls to fetch results. Using encode/decode
+    # doesn't work as it converts to string altering the size.
+    def bytearray_to_str(byte_arr):
+        return ''.join([chr(b) for b in byte_arr])
+
+    # Raw conversion of string to bytes. This is required to convert
+    # back the string into bytearray(c char array) to use in struc
+    # pack/unpacking. Again encode/decode can't be used as it
+    # converts it alters size.
+    def str_to_bytearray(string):
+        return bytes([ord(c) for c in string])
+
+    def gr_create_string_buffer(size):
+        return create_string_buffer(b'\0', size)
+
+    def gr_query_xattr(cls, path, size, syscall, attr=None):
+        if attr:
+            return cls._query_xattr(path.encode(), size, syscall,
+                                    attr.encode())
+        else:
+            return cls._query_xattr(path.encode(), size, syscall)
+
+    def gr_lsetxattr(cls, path, attr, val):
+        return cls.libc.lsetxattr(path.encode(), attr.encode(), val,
+                                  len(val), 0)
+
+    def gr_lremovexattr(cls, path, attr):
+        return cls.libc.lremovexattr(path.encode(), attr.encode())
+
+    def gr_cl_register(cls, brick, path, log_file, log_level, retries):
+        return cls._get_api('gf_changelog_register')(brick.encode(),
+                                                     path.encode(),
+                                                     log_file.encode(),
+                                                     log_level, retries)
+
+    def gr_cl_done(cls, clfile):
+        return cls._get_api('gf_changelog_done')(clfile.encode())
+
+    def gr_cl_history_changelog(cls, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return cls._get_api('gf_history_changelog')(changelog_path.encode(),
+                                                    start, end, num_parallel,
+                                                    actual_end)
+
+    def gr_cl_history_done(cls, clfile):
+        return cls._get_api('gf_history_changelog_done')(clfile.encode())
+
+    # regular file
+
+    def entry_pack_reg(cls, gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(cls._fmt_mknod(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), 0, umask())
+
+    def entry_pack_reg_stat(cls, gf, bn, st):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        mo = st['mode']
+        return struct.pack(cls._fmt_mknod(blen),
+                           st['uid'], st['gid'],
+                           gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), 0, umask())
+    # mkdir
+
+    def entry_pack_mkdir(cls, gf, bn, mo, uid, gid):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        return struct.pack(cls._fmt_mkdir(blen),
+                           uid, gid, gf.encode(), mo, bn_encoded,
+                           stat.S_IMODE(mo), umask())
+    # symlink
+
+    def entry_pack_symlink(cls, gf, bn, lnk, st):
+        bn_encoded = bn.encode()
+        blen = len(bn_encoded)
+        lnk_encoded = lnk.encode()
+        llen = len(lnk_encoded)
+        return struct.pack(cls._fmt_symlink(blen, llen),
+                           st['uid'], st['gid'],
+                           gf.encode(), st['mode'], bn_encoded,
+                           lnk_encoded)
+else:
+    def pipe():
+        (r, w) = os.pipe()
+        return (r, w)
+
+    # Raw conversion of bytearray to string
+    def bytearray_to_str(byte_arr):
+        return byte_arr
+
+    # Raw conversion of string to bytearray
+    def str_to_bytearray(string):
+        return string
+
+    def gr_create_string_buffer(size):
+        return create_string_buffer('\0', size)
+
+    def gr_query_xattr(cls, path, size, syscall, attr=None):
+        if attr:
+            return cls._query_xattr(path, size, syscall, attr)
+        else:
+            return cls._query_xattr(path, size, syscall)
+
+    def gr_lsetxattr(cls, path, attr, val):
+        return cls.libc.lsetxattr(path, attr, val, len(val), 0)
+
+    def gr_lremovexattr(cls, path, attr):
+        return cls.libc.lremovexattr(path, attr)
+
+    def gr_cl_register(cls, brick, path, log_file, log_level, retries):
+        return cls._get_api('gf_changelog_register')(brick, path, log_file,
+                                                     log_level, retries)
+
+    def gr_cl_done(cls, clfile):
+        return cls._get_api('gf_changelog_done')(clfile)
+
+    def gr_cl_history_changelog(cls, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return cls._get_api('gf_history_changelog')(changelog_path, start, end,
+                                                    num_parallel, actual_end)
+
+    def gr_cl_history_done(cls, clfile):
+        return cls._get_api('gf_history_changelog_done')(clfile)
+
+    # regular file
+
+    def entry_pack_reg(cls, gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(cls._fmt_mknod(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), 0, umask())
+
+    def entry_pack_reg_stat(cls, gf, bn, st):
+        blen = len(bn)
+        mo = st['mode']
+        return struct.pack(cls._fmt_mknod(blen),
+                           st['uid'], st['gid'],
+                           gf, mo, bn,
+                           stat.S_IMODE(mo), 0, umask())
+    # mkdir
+
+    def entry_pack_mkdir(cls, gf, bn, mo, uid, gid):
+        blen = len(bn)
+        return struct.pack(cls._fmt_mkdir(blen),
+                           uid, gid, gf, mo, bn,
+                           stat.S_IMODE(mo), umask())
+    # symlink
+
+    def entry_pack_symlink(cls, gf, bn, lnk, st):
+        blen = len(bn)
+        llen = len(lnk)
+        return struct.pack(cls._fmt_symlink(blen, llen),
+                           st['uid'], st['gid'],
+                           gf, st['mode'], bn, lnk)
diff --git a/tests/utils/setfattr.py b/tests/utils/setfattr.py
index d714d05edf3..8b7b6abacc0 100755
--- a/tests/utils/setfattr.py
+++ b/tests/utils/setfattr.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python2
 
 import os
 import sys
@@ -46,7 +45,7 @@ if __name__ == '__main__':
     parser.add_option("-x", action="store", dest="xname", type="string",
                       help="Remove the named extended attribute entirely.")
 
-    (option,args) = parser.parse_args()
+    (option, args) = parser.parse_args()
     if not args:
         print ("Usage: setfattr {-n name} [-v value] file...")
         print ("       setfattr {-x name} file...")
diff --git a/tests/vagrant/vagrant-template-centos6/roles/install-pkgs/tasks/main.yml b/tests/vagrant/vagrant-template-centos6/roles/install-pkgs/tasks/main.yml
index 37dbc108d9f..bf3eff077b4 100644
--- a/tests/vagrant/vagrant-template-centos6/roles/install-pkgs/tasks/main.yml
+++ b/tests/vagrant/vagrant-template-centos6/roles/install-pkgs/tasks/main.yml
@@ -17,6 +17,7 @@
     - attr
     - autoconf
     - automake
+    - bc
     - bison
       #- libcmocka-devel
     - dbench
diff --git a/tests/vagrant/vagrant-template-fedora/roles/install-pkgs/tasks/main.yml b/tests/vagrant/vagrant-template-fedora/roles/install-pkgs/tasks/main.yml
index 4e7d8d0d7b8..2512034cdd7 100644
--- a/tests/vagrant/vagrant-template-fedora/roles/install-pkgs/tasks/main.yml
+++ b/tests/vagrant/vagrant-template-fedora/roles/install-pkgs/tasks/main.yml
@@ -11,6 +11,7 @@
     - attr
     - autoconf
     - automake
+    - bc
     - bison
     - libcmocka-devel
     - cifs-utils
diff --git a/tests/volume.rc b/tests/volume.rc
index 1cee648993b..b38848c0e52 100644
--- a/tests/volume.rc
+++ b/tests/volume.rc
@@ -48,7 +48,10 @@ function online_brick_count ()
        v3=`check_brick_status "Quota"`
        v4=`check_brick_status "Snapshot"`
        v5=`check_brick_status "Tier"`
-       tot=$((v1-v2-v3-v4-v5))
+       v6=`check_brick_status "Scrubber"`
+       v7=`check_brick_status "Bitrot"`
+
+       tot=$((v1-v2-v3-v4-v5-v6-v7))
        echo $tot
 
 }
@@ -81,10 +84,6 @@ function fix-layout_status_field {
         $CLI volume rebalance $1 status | awk '{print $2,$3,$4}' |sed -n 3p |tr -d '[^0-9+\.]'|sed 's/ *$//g'
 }
 
-function detach_tier_status_field_complete {
-        $CLI volume tier  $1 detach status | awk '{print $7}' |sed -n 4p
-}
-
 function remove_brick_status_completed_field {
         local vol=$1
         local brick_list=$2
@@ -93,7 +92,8 @@ function remove_brick_status_completed_field {
 
 function get_mount_process_pid {
         local vol=$1
-        ps auxww | grep glusterfs | grep -E "volfile-id[ =]/?$vol " | awk '{print $2}' | head -1
+        local mnt=$2
+        ps auxww | grep glusterfs | grep -E "volfile-id[ =]/?$vol .*$mnt" | awk '{print $2}' | head -1
 }
 
 function get_nfs_pid ()
@@ -112,21 +112,39 @@ function cleanup_statedump {
        #.vimrc friendly comment */
 }
 
+function wait_statedump_ready {
+        local maxtime="${1}000000000"
+        local pid="$2"
+        local deadline="$(($(date +%s%N) + maxtime))"
+        local fname
+
+        while [[ "$(date +%s%N)" < "$deadline" ]]; do
+                fname="$statedumpdir/$(ls $statedumpdir | grep -E "\.$pid\.dump\.")"
+                if [[ -f "$fname" ]]; then
+                        grep "^DUMP-END-TIME" "$fname" >/dev/null
+                        if [[ $? -eq 0 ]]; then
+                                echo $fname
+                                return
+                        fi
+                fi
+                sleep 0.1
+        done
+
+        echo "nostatedump"
+}
+
 function generate_statedump {
-        local fpath=""
         pid=$1
         #remove old stale statedumps
         cleanup_statedump $pid
         kill -USR1 $pid
-        #Wait till the statedump is generated
-        sleep 1
-        fname=$(ls $statedumpdir | grep -E "\.$pid\.dump\.")
-        echo $statedumpdir/$fname
+        wait_statedump_ready 3 $pid
 }
 
 function generate_mount_statedump {
         local vol=$1
-        generate_statedump $(get_mount_process_pid $vol)
+        local mnt=$2
+        generate_statedump $(get_mount_process_pid $vol $mnt)
 }
 
 function cleanup_mount_statedump {
@@ -137,7 +155,7 @@ function cleanup_mount_statedump {
 function snap_client_connected_status {
          local vol=$1
          local fpath=$(generate_mount_statedump $vol)
-         up=$(grep -a -A2 xlator.protocol.client.$vol-snapd-client.priv $fpath | tail -1 | cut -f 2 -d'=')
+         up=$(grep -a -A1 xlator.protocol.client.$vol-snapd-client.priv $fpath | tail -1 | cut -f 2 -d'=')
          rm -f $fpath
          echo "$up"
 }
@@ -175,7 +193,7 @@ function afr_child_up_status_meta {
         local mnt=$1
         local repl=$2
         local child=$3
-        grep "child_up\[$child\]" $mnt/.meta/graphs/active/$repl/private | awk '{print $3}'
+        grep -E "^child_up\[$child\]" $mnt/.meta/graphs/active/$repl/private | awk '{print $3}'
 }
 
 function client_connected_status_meta {
@@ -205,14 +223,16 @@ function ec_child_up_status {
         local vol=$1
         local dist_id=$2
         local brick_id=$(($3 + 1))
-        local mask=$(ec_get_info $vol $dist_id "childs_up_mask" $(generate_mount_statedump $vol))
+        local mnt=$4
+        local mask=$(ec_get_info $vol $dist_id "childs_up_mask" $(generate_mount_statedump $vol $mnt))
         echo "${mask: -$brick_id:1}"
 }
 
 function ec_child_up_count {
         local vol=$1
         local dist_id=$2
-        ec_get_info $vol $dist_id "childs_up" $(generate_mount_statedump $vol)
+        local mnt=$3
+        ec_get_info $vol $dist_id "childs_up" $(generate_mount_statedump $vol $mnt)
 }
 
 function ec_child_up_status_shd {
@@ -230,11 +250,13 @@ function ec_child_up_count_shd {
 }
 
 function get_shd_process_pid {
-        ps auxww | grep glusterfs | grep -E "glustershd/glustershd.pid" | awk '{print $2}' | head -1
+        local vol=$1
+        ps auxww | grep "process-name\ glustershd" | awk '{print $2}' | head -1
 }
 
 function generate_shd_statedump {
-        generate_statedump $(get_shd_process_pid)
+        local vol=$1
+        generate_statedump $(get_shd_process_pid $vol)
 }
 
 function generate_nfs_statedump {
@@ -274,6 +296,10 @@ function quotad_up_status {
         gluster volume status | grep "Quota Daemon" | awk '{print $7}'
 }
 
+function get_glusterd_pid {
+        pgrep '^glusterd$' | head -1
+}
+
 function get_brick_pidfile {
         local vol=$1
         local host=$2
@@ -297,15 +323,12 @@ function kill_brick {
 
 	gf_attach -d $socket $brick
 
-	# When the last brick in a process is terminated, the process has to
-	# sleep for a second to give the RPC response a chance to get back to
-	# GlusterD.  Without that, we get random failures in tests that use
-	# "volume stop" whenever the process termination is observed before the
-	# RPC response.  However, that same one-second sleep can cause other
-	# random failures in tests that assume a brick will already be gone
-	# before "gf_attach -d" returns.  There are too many of those to fix,
-	# so we compensate by putting the same one-second sleep here.
-	sleep 1
+        local deadline="$(($(date +%s%N) + ${PROCESS_UP_TIMEOUT}000000000))"
+        while [[ "$(date +%s%N)" < "$deadline" ]]; do
+                if [[ "$(brick_up_status $vol $host $brick)" == "0" ]]; then
+                        break
+                fi
+        done
 }
 
 function check_option_help_presence {
@@ -364,6 +387,19 @@ function get_gfid2path {
         getfattr -h --only-values -n glusterfs.gfidtopath $path 2>/dev/null
 }
 
+function get_mdata {
+        local path=$1
+        getfattr -h -e hex -n trusted.glusterfs.mdata $path 2>/dev/null | grep "trusted.glusterfs.mdata" | cut -f2 -d'='
+}
+
+function get_mdata_count {
+    getfattr -d -m . -e hex $@ 2>/dev/null | grep mdata | wc -l
+}
+
+function get_mdata_uniq_count {
+    getfattr -d -m . -e hex $@ 2>/dev/null | grep mdata | uniq | wc -l
+}
+
 function get_xattr_key {
         local key=$1
         local path=$2
@@ -533,9 +569,8 @@ function volume_exists() {
 }
 
 function killall_gluster() {
-        pkill gluster
+        terminate_pids $(process_pids gluster)
         find $GLUSTERD_PIDFILEDIR -name '*.pid' | xargs rm -f
-        sleep 1
 }
 
 function afr_get_index_count {
@@ -796,3 +831,172 @@ function count_sh_entries()
 {
     ls $1/.glusterfs/indices/xattrop | grep -v "xattrop-" | wc -l
 }
+
+function check_brick_multiplex() {
+        cnt="$(ls /var/log/glusterfs/bricks|wc -l)"
+        local ret=$($CLI volume info|grep "cluster.brick-multiplex"|cut -d" " -f2)
+        local bcnt="$(brick_count)"
+
+        if [ $bcnt -ne 1 ]; then
+           if [ "$ret" = "on" ] || [ $cnt -eq 1 ]; then
+              echo "Y"
+           else
+              echo "N"
+           fi
+        else
+           echo "N"
+        fi
+}
+
+function get_fd_count {
+        local vol=$1
+        local host=$2
+        local brick=$3
+        local fname=$4
+        local val="$(check_brick_multiplex)"
+        local gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $brick/$fname))
+        local statedump=$(generate_brick_statedump $vol $host $brick)
+        if [ $val == "N" ]; then
+            count=$(grep "gfid=$gfid_str" $statedump -A2 | grep fd-count | cut -f2 -d'=' | tail -1)
+        else
+            count=$(grep "${brick}.active.1" -A3 $statedump | grep "gfid=$gfid_str" -A2 | grep fd-count | cut -f2 -d'=' | tail -1)
+        fi
+# If no information is found for a given gfid, it means it has not been
+# accessed, so it doesn't have any open fd. In this case we return 0.
+        count="${count:-0}"
+        rm -f $statedump
+        echo $count
+}
+
+
+function get_active_fd_count {
+        local vol=$1
+        local host=$2
+        local brick=$3
+        local fname=$4
+        local val="$(check_brick_multiplex)"
+        local gfid_str=$(gf_gfid_xattr_to_str $(gf_get_gfid_xattr $brick/$fname))
+        local statedump=$(generate_brick_statedump $vol $host $brick)
+        if [ $val == "N" ]; then
+            count=$(grep "gfid=$gfid_str" $statedump -A2 | grep fd-count | cut -f2 -d'=' | tail -1)
+        else
+            count=$(grep "${brick}.active.1" -A3 $statedump | grep "gfid=$gfid_str" -A2 | grep fd-count | cut -f2 -d'=' | tail -1)
+        fi
+        rm -f $statedump
+        echo $count
+}
+
+function get_mount_active_size_value {
+        local vol=$1
+        local mount=$2
+        local statedump=$(generate_mount_statedump $vol $mount)
+        local val=$(grep "active_size" $statedump | cut -f2 -d'=' | tail -1)
+        rm -f $statedump
+        echo $val
+}
+
+function get_mount_lru_size_value {
+        local vol=$1
+        local mount=$2
+        local statedump=$(generate_mount_statedump $vol $mount)
+        local val=$(grep "lru_size" $statedump | cut -f2 -d'=' | tail -1)
+        rm -f $statedump
+        echo $val
+}
+
+function check_changelog_op {
+        local clog_path=$1
+        local op=$2
+
+        $PYTHON $(dirname $0)/../../utils/changelogparser.py ${clog_path}/CHANGELOG | grep "$op" | wc -l
+}
+
+function processed_changelogs {
+        local processed_dir=$1
+        count=$(ls -l $processed_dir | grep CHANGELOG | wc -l)
+        if [ $count -gt 0 ];
+        then
+            echo "Y"
+        else
+            echo "N"
+        fi
+}
+
+function volgen_check_ancestry {
+        #Returns Y if ancestor_xl is an ancestor of $child_xl according to the volfile
+        local volfile="$1"
+
+        local child_xl_type="$2"
+        local child_xl="$3"
+
+        local ancestor_xl_type="$4"
+        local ancestor_xl="$5"
+
+        child_linenum=$(awk '/type $child_xl_type\/$child_xl/ {print FNR}' $volfile)
+        ancestor_linenum=$(awk '/type $ancestor_xl_type\/$ancestor_xl/ {print FNR}' $volfile)
+
+        if [ $child_linenum -lt $ancestor_linenum ];
+        then
+                echo "Y"
+        else
+                echo "N"
+        fi
+}
+
+function get_shd_mux_pid {
+   local volume=$1
+   pid=`$CLI volume status $volume shd | awk '/Self-heal/{print $8}'`
+   echo $pid
+}
+
+function shd_count {
+   ps aux | grep "glustershd" | grep -v grep | wc -l
+}
+
+function number_healer_threads_shd {
+   local pid=$(get_shd_mux_pid $1)
+   pstack $pid | grep $2 | wc -l
+}
+
+function get_mtime {
+    local time=$(get-mdata-xattr -m $1)
+    if [ $time == "-1" ];
+    then
+        echo $(stat -c %Y $1)
+    else
+        echo $time
+    fi
+}
+
+function get_ctime {
+    local time=$(get-mdata-xattr -c $1)
+    if [ $time == "-1" ];
+    then
+        echo $(stat -c %Z $1)
+    else
+        echo $time
+    fi
+}
+
+function get_atime {
+    local time=$(get-mdata-xattr -a $1)
+    if [ $time == "-1" ];
+    then
+        echo $(stat -c %X $1)
+    else
+        echo $time
+    fi
+}
+
+function get-xml()
+{
+        $CLI $1 --xml | xmllint --format - | grep $2 | sed 's/\(<"$2">\|<\/"$2">\)//g'
+}
+
+function logging_time_check()
+{
+    local logdir=$1
+    local logfile=`echo ${0##*/}`_glusterd1.log
+
+    cat $logdir/1/$logfile | tail -n 2 | head -n 1 | grep $(date +%H:%M) | wc -l
+}
diff --git a/tools/gfind_missing_files/Makefile.am b/tools/gfind_missing_files/Makefile.am
index f77f7899efb..181fe7091f3 100644
--- a/tools/gfind_missing_files/Makefile.am
+++ b/tools/gfind_missing_files/Makefile.am
@@ -1,12 +1,16 @@
 gfindmissingfilesdir = $(GLUSTERFS_LIBEXECDIR)/gfind_missing_files
 
+if WITH_SERVER
 gfindmissingfiles_SCRIPTS = gfind_missing_files.sh gfid_to_path.sh \
 	gfid_to_path.py
+endif
 
 EXTRA_DIST = gfind_missing_files.sh gfid_to_path.sh \
 	gfid_to_path.py
 
+if WITH_SERVER
 gfindmissingfiles_PROGRAMS = gcrawler
+endif
 
 gcrawler_SOURCES = gcrawler.c
 gcrawler_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
@@ -16,11 +20,13 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src
 
 AM_CFLAGS = -Wall $(GF_CFLAGS)
 
+if WITH_SERVER
 uninstall-local:
 	rm -f $(DESTDIR)$(sbindir)/gfind_missing_files
 
 install-data-local:
 	rm -f $(DESTDIR)$(sbindir)/gfind_missing_files
 	ln -s $(GLUSTERFS_LIBEXECDIR)/gfind_missing_files/gfind_missing_files.sh $(DESTDIR)$(sbindir)/gfind_missing_files
+endif
 
 CLEANFILES =
diff --git a/tools/gfind_missing_files/gcrawler.c b/tools/gfind_missing_files/gcrawler.c
index 02b644a1a77..4acbe92bc8f 100644
--- a/tools/gfind_missing_files/gcrawler.c
+++ b/tools/gfind_missing_files/gcrawler.c
@@ -16,33 +16,50 @@
 #include <string.h>
 #include <dirent.h>
 #include <assert.h>
-#include "locking.h"
+#include <glusterfs/locking.h>
 
-#include "compat.h"
-#include "list.h"
-#include "syscall.h"
+#include <glusterfs/compat.h>
+#include <glusterfs/list.h>
+#include <glusterfs/syscall.h>
 
 #define THREAD_MAX 32
 #define BUMP(name) INC(name, 1)
 #define DEFAULT_WORKERS 4
 
-#define NEW(x) {                              \
-        x = calloc (1, sizeof (typeof (*x))); \
-        }
-
-#define err(x ...) fprintf(stderr, x)
-#define out(x ...) fprintf(stdout, x)
-#define dbg(x ...) do { if (debug) fprintf(stdout, x); } while (0)
-#define tout(x ...) do { out("[%ld] ", pthread_self()); out(x); } while (0)
-#define terr(x ...) do { err("[%ld] ", pthread_self()); err(x); } while (0)
-#define tdbg(x ...) do { dbg("[%ld] ", pthread_self()); dbg(x); } while (0)
+#define NEW(x)                                                                 \
+    {                                                                          \
+        x = calloc(1, sizeof(typeof(*x)));                                     \
+    }
+
+#define err(x...) fprintf(stderr, x)
+#define out(x...) fprintf(stdout, x)
+#define dbg(x...)                                                              \
+    do {                                                                       \
+        if (debug)                                                             \
+            fprintf(stdout, x);                                                \
+    } while (0)
+#define tout(x...)                                                             \
+    do {                                                                       \
+        out("[%ld] ", pthread_self());                                         \
+        out(x);                                                                \
+    } while (0)
+#define terr(x...)                                                             \
+    do {                                                                       \
+        err("[%ld] ", pthread_self());                                         \
+        err(x);                                                                \
+    } while (0)
+#define tdbg(x...)                                                             \
+    do {                                                                       \
+        dbg("[%ld] ", pthread_self());                                         \
+        dbg(x);                                                                \
+    } while (0)
 
 int debug = 0;
 const char *slavemnt = NULL;
 int workers = 0;
 
 struct stats {
-        unsigned long long int cnt_skipped_gfids;
+    unsigned long long int cnt_skipped_gfids;
 };
 
 pthread_spinlock_t stats_lock;
@@ -50,518 +67,515 @@ pthread_spinlock_t stats_lock;
 struct stats stats_total;
 int stats = 0;
 
-#define INC(name, val) do {                             \
-        if (!stats)                                     \
-                break;                                  \
-        pthread_spin_lock(&stats_lock);                 \
-        {                                               \
-                stats_total.cnt_##name += val;          \
-        }                                               \
-        pthread_spin_unlock(&stats_lock);               \
-        } while (0)
+#define INC(name, val)                                                         \
+    do {                                                                       \
+        if (!stats)                                                            \
+            break;                                                             \
+        pthread_spin_lock(&stats_lock);                                        \
+        {                                                                      \
+            stats_total.cnt_##name += val;                                     \
+        }                                                                      \
+        pthread_spin_unlock(&stats_lock);                                      \
+    } while (0)
 
 void
 stats_dump()
 {
-        if (!stats)
-                return;
+    if (!stats)
+        return;
 
-        out("-------------------------------------------\n");
-        out("Skipped_Files : %10lld\n", stats_total.cnt_skipped_gfids);
-        out("-------------------------------------------\n");
+    out("-------------------------------------------\n");
+    out("Skipped_Files : %10lld\n", stats_total.cnt_skipped_gfids);
+    out("-------------------------------------------\n");
 }
 
 struct dirjob {
-        struct list_head    list;
+    struct list_head list;
 
-        char               *dirname;
+    char *dirname;
 
-        struct dirjob      *parent;
-        int                 ret;    /* final status of this subtree */
-        int                 refcnt; /* how many dirjobs have this as parent */
+    struct dirjob *parent;
+    int ret;    /* final status of this subtree */
+    int refcnt; /* how many dirjobs have this as parent */
 
-        pthread_spinlock_t  lock;
+    pthread_spinlock_t lock;
 };
 
-
 struct xwork {
-        pthread_t        cthreads[THREAD_MAX]; /* crawler threads */
-        int              count;
-        int              idle;
-        int              stop;
+    pthread_t cthreads[THREAD_MAX]; /* crawler threads */
+    int count;
+    int idle;
+    int stop;
 
-        struct dirjob    crawl;
+    struct dirjob crawl;
 
-        struct dirjob   *rootjob; /* to verify completion in xwork_fini() */
+    struct dirjob *rootjob; /* to verify completion in xwork_fini() */
 
-        pthread_mutex_t  mutex;
-        pthread_cond_t   cond;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
 };
 
-
 struct dirjob *
-dirjob_ref (struct dirjob *job)
+dirjob_ref(struct dirjob *job)
 {
-        pthread_spin_lock (&job->lock);
-        {
-                job->refcnt++;
-        }
-        pthread_spin_unlock (&job->lock);
+    pthread_spin_lock(&job->lock);
+    {
+        job->refcnt++;
+    }
+    pthread_spin_unlock(&job->lock);
 
-        return job;
+    return job;
 }
 
-
 void
-dirjob_free (struct dirjob *job)
+dirjob_free(struct dirjob *job)
 {
-        assert (list_empty (&job->list));
+    assert(list_empty(&job->list));
 
-        pthread_spin_destroy (&job->lock);
-        free (job->dirname);
-        free (job);
+    pthread_spin_destroy(&job->lock);
+    free(job->dirname);
+    free(job);
 }
 
 void
-dirjob_ret (struct dirjob *job, int err)
+dirjob_ret(struct dirjob *job, int err)
 {
-        int            ret = 0;
-        int            refcnt = 0;
-        struct dirjob *parent = NULL;
-
-        pthread_spin_lock (&job->lock);
-        {
-                refcnt = --job->refcnt;
-                job->ret = (job->ret || err);
-        }
-        pthread_spin_unlock (&job->lock);
-
-        if (refcnt == 0) {
-                ret = job->ret;
-
-                if (ret)
-                        terr ("Failed: %s (%d)\n", job->dirname, ret);
-                else
-                        tdbg ("Finished: %s\n", job->dirname);
-
-                parent = job->parent;
-                if (parent)
-                        dirjob_ret (parent, ret);
+    int ret = 0;
+    int refcnt = 0;
+    struct dirjob *parent = NULL;
+
+    pthread_spin_lock(&job->lock);
+    {
+        refcnt = --job->refcnt;
+        job->ret = (job->ret || err);
+    }
+    pthread_spin_unlock(&job->lock);
+
+    if (refcnt == 0) {
+        ret = job->ret;
+
+        if (ret)
+            terr("Failed: %s (%d)\n", job->dirname, ret);
+        else
+            tdbg("Finished: %s\n", job->dirname);
+
+        parent = job->parent;
+        if (parent)
+            dirjob_ret(parent, ret);
 
-                dirjob_free (job);
-                job = NULL;
-        }
+        dirjob_free(job);
+        job = NULL;
+    }
 }
 
-
 struct dirjob *
-dirjob_new (const char *dir, struct dirjob *parent)
+dirjob_new(const char *dir, struct dirjob *parent)
 {
-        struct dirjob *job = NULL;
+    struct dirjob *job = NULL;
 
-        NEW(job);
-        if (!job)
-                return NULL;
+    NEW(job);
+    if (!job)
+        return NULL;
 
-        job->dirname = strdup (dir);
-        if (!job->dirname) {
-                free (job);
-                return NULL;
-        }
+    job->dirname = strdup(dir);
+    if (!job->dirname) {
+        free(job);
+        return NULL;
+    }
 
-        INIT_LIST_HEAD(&job->list);
-        pthread_spin_init (&job->lock, PTHREAD_PROCESS_PRIVATE);
-        job->ret = 0;
+    INIT_LIST_HEAD(&job->list);
+    pthread_spin_init(&job->lock, PTHREAD_PROCESS_PRIVATE);
+    job->ret = 0;
 
-        if (parent)
-                job->parent = dirjob_ref (parent);
+    if (parent)
+        job->parent = dirjob_ref(parent);
 
-        job->refcnt = 1;
+    job->refcnt = 1;
 
-        return job;
+    return job;
 }
 
 void
-xwork_addcrawl (struct xwork *xwork, struct dirjob *job)
+xwork_addcrawl(struct xwork *xwork, struct dirjob *job)
 {
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                list_add_tail (&job->list, &xwork->crawl.list);
-                pthread_cond_broadcast (&xwork->cond);
-        }
-        pthread_mutex_unlock (&xwork->mutex);
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        list_add_tail(&job->list, &xwork->crawl.list);
+        pthread_cond_broadcast(&xwork->cond);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
 }
 
 int
-xwork_add (struct xwork *xwork, const char *dir, struct dirjob *parent)
+xwork_add(struct xwork *xwork, const char *dir, struct dirjob *parent)
 {
-        struct dirjob *job = NULL;
+    struct dirjob *job = NULL;
 
-        job = dirjob_new (dir, parent);
-        if (!job)
-                return -1;
+    job = dirjob_new(dir, parent);
+    if (!job)
+        return -1;
 
-        xwork_addcrawl (xwork, job);
+    xwork_addcrawl(xwork, job);
 
-        return 0;
+    return 0;
 }
 
-
 struct dirjob *
-xwork_pick (struct xwork *xwork, int block)
+xwork_pick(struct xwork *xwork, int block)
 {
-        struct dirjob *job = NULL;
-        struct list_head *head = NULL;
+    struct dirjob *job = NULL;
+    struct list_head *head = NULL;
 
-        head = &xwork->crawl.list;
+    head = &xwork->crawl.list;
 
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                for (;;) {
-                        if (xwork->stop)
-                                break;
-
-                        if (!list_empty (head)) {
-                                job = list_entry (head->next, typeof(*job),
-                                                  list);
-                                list_del_init (&job->list);
-                                break;
-                        }
-
-                        if (((xwork->count * 2) == xwork->idle) &&
-                            list_empty (&xwork->crawl.list)) {
-                                /* no outstanding jobs, and no
-                                   active workers
-                                */
-                                tdbg ("Jobless. Terminating\n");
-                                xwork->stop = 1;
-                                pthread_cond_broadcast (&xwork->cond);
-                                break;
-                        }
-
-                        if (!block)
-                                break;
-
-                        xwork->idle++;
-                        pthread_cond_wait (&xwork->cond, &xwork->mutex);
-                        xwork->idle--;
-                }
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        for (;;) {
+            if (xwork->stop)
+                break;
+
+            if (!list_empty(head)) {
+                job = list_entry(head->next, typeof(*job), list);
+                list_del_init(&job->list);
+                break;
+            }
+
+            if (((xwork->count * 2) == xwork->idle) &&
+                list_empty(&xwork->crawl.list)) {
+                /* no outstanding jobs, and no
+                   active workers
+                */
+                tdbg("Jobless. Terminating\n");
+                xwork->stop = 1;
+                pthread_cond_broadcast(&xwork->cond);
+                break;
+            }
+
+            if (!block)
+                break;
+
+            xwork->idle++;
+            pthread_cond_wait(&xwork->cond, &xwork->mutex);
+            xwork->idle--;
         }
-        pthread_mutex_unlock (&xwork->mutex);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
 
-        return job;
+    return job;
 }
 
 int
-skip_name (const char *dirname, const char *name)
+skip_name(const char *dirname, const char *name)
 {
-        if (strcmp (name, ".") == 0)
-                return 1;
+    if (strcmp(name, ".") == 0)
+        return 1;
 
-        if (strcmp (name, "..") == 0)
-                return 1;
+    if (strcmp(name, "..") == 0)
+        return 1;
 
-        if (strcmp (name, "changelogs") == 0)
-                return 1;
+    if (strcmp(name, "changelogs") == 0)
+        return 1;
 
-        if (strcmp (name, "health_check") == 0)
-                return 1;
+    if (strcmp(name, "health_check") == 0)
+        return 1;
 
-        if (strcmp (name, "indices") == 0)
-                return 1;
+    if (strcmp(name, "indices") == 0)
+        return 1;
 
-        if (strcmp (name, "landfill") == 0)
-                return 1;
+    if (strcmp(name, "landfill") == 0)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 int
-skip_stat (struct dirjob *job, const char *name)
+skip_stat(struct dirjob *job, const char *name)
 {
-        if (job == NULL)
-                return 0;
-
-        if (strcmp (job->dirname, ".glusterfs") == 0) {
-                tdbg ("Directly adding directories under .glusterfs "
-                      "to global list: %s\n", name);
-                return 1;
-        }
+    if (job == NULL)
+        return 0;
 
-        if (job->parent != NULL) {
-                if (strcmp (job->parent->dirname, ".glusterfs") == 0) {
-                        tdbg ("Directly adding directories under .glusterfs/XX "
-                              "to global list: %s\n", name);
-                        return 1;
-                }
+    if (strcmp(job->dirname, ".glusterfs") == 0) {
+        tdbg(
+            "Directly adding directories under .glusterfs "
+            "to global list: %s\n",
+            name);
+        return 1;
+    }
+
+    if (job->parent != NULL) {
+        if (strcmp(job->parent->dirname, ".glusterfs") == 0) {
+            tdbg(
+                "Directly adding directories under .glusterfs/XX "
+                "to global list: %s\n",
+                name);
+            return 1;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-xworker_do_crawl (struct xwork *xwork, struct dirjob *job)
+xworker_do_crawl(struct xwork *xwork, struct dirjob *job)
 {
-        DIR            *dirp = NULL;
-        int             ret = -1;
-        int             boff;
-        int             plen;
-        char           *path = NULL;
-        struct dirjob  *cjob = NULL;
-        struct stat     statbuf = {0,};
-        struct dirent  *entry;
-        struct dirent   scratch[2] = {{0,},};
-        char            gfid_path[PATH_MAX] = {0,};
-
-
-        plen = strlen (job->dirname) + 256 + 2;
-        path = alloca (plen);
-
-        tdbg ("Entering: %s\n", job->dirname);
-
-        dirp = sys_opendir (job->dirname);
-        if (!dirp) {
-                terr ("opendir failed on %s (%s)\n", job->dirname,
-                     strerror (errno));
+    DIR *dirp = NULL;
+    int ret = -1;
+    int boff;
+    int plen;
+    char *path = NULL;
+    struct dirjob *cjob = NULL;
+    struct stat statbuf = {
+        0,
+    };
+    struct dirent *entry;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    char gfid_path[PATH_MAX] = {
+        0,
+    };
+
+    plen = strlen(job->dirname) + 256 + 2;
+    path = alloca(plen);
+
+    tdbg("Entering: %s\n", job->dirname);
+
+    dirp = sys_opendir(job->dirname);
+    if (!dirp) {
+        terr("opendir failed on %s (%s)\n", job->dirname, strerror(errno));
+        goto out;
+    }
+
+    boff = sprintf(path, "%s/", job->dirname);
+
+    for (;;) {
+        errno = 0;
+        entry = sys_readdir(dirp, scratch);
+        if (!entry || errno != 0) {
+            if (errno != 0) {
+                err("readdir(%s): %s\n", job->dirname, strerror(errno));
+                ret = errno;
                 goto out;
+            }
+            break;
         }
 
-        boff = sprintf (path, "%s/", job->dirname);
+        if (entry->d_ino == 0)
+            continue;
+
+        if (skip_name(job->dirname, entry->d_name))
+            continue;
+
+        /* It is sure that, children and grandchildren of .glusterfs
+         * are directories, just add them to global queue.
+         */
+        if (skip_stat(job, entry->d_name)) {
+            strncpy(path + boff, entry->d_name, (plen - boff));
+            cjob = dirjob_new(path, job);
+            if (!cjob) {
+                err("dirjob_new(%s): %s\n", path, strerror(errno));
+                ret = -1;
+                goto out;
+            }
+            xwork_addcrawl(xwork, cjob);
+            continue;
+        }
 
-        for (;;) {
-                errno = 0;
-                entry = sys_readdir (dirp, scratch);
-                if (!entry || errno != 0) {
-                        if (errno != 0) {
-                                err ("readdir(%s): %s\n", job->dirname,
-                                     strerror (errno));
-                                ret = errno;
-                                goto out;
-                        }
-                        break;
-                }
-
-                if (entry->d_ino == 0)
-                        continue;
-
-                if (skip_name (job->dirname, entry->d_name))
-                        continue;
-
-                /* It is sure that, children and grandchildren of .glusterfs
-                 * are directories, just add them to global queue.
-                 */
-                if (skip_stat (job, entry->d_name)) {
-                        strncpy (path + boff, entry->d_name, (plen-boff));
-                        cjob = dirjob_new (path, job);
-                        if (!cjob) {
-                                err ("dirjob_new(%s): %s\n",
-                                     path, strerror (errno));
-                                ret = -1;
-                                goto out;
-                        }
-                        xwork_addcrawl (xwork, cjob);
-                        continue;
-                }
-
-                (void) snprintf (gfid_path, sizeof(gfid_path), "%s/.gfid/%s",
-                                 slavemnt, entry->d_name);
-                ret = sys_lstat (gfid_path, &statbuf);
-
-                if (ret && errno == ENOENT) {
-                        out ("%s\n", entry->d_name);
-                        BUMP (skipped_gfids);
-                }
-
-                if (ret && errno != ENOENT) {
-                        err ("stat on slave failed(%s): %s\n",
-                             gfid_path, strerror (errno));
-                        goto out;
-                }
+        (void)snprintf(gfid_path, sizeof(gfid_path), "%s/.gfid/%s", slavemnt,
+                       entry->d_name);
+        ret = sys_lstat(gfid_path, &statbuf);
+
+        if (ret && errno == ENOENT) {
+            out("%s\n", entry->d_name);
+            BUMP(skipped_gfids);
+        }
+
+        if (ret && errno != ENOENT) {
+            err("stat on slave failed(%s): %s\n", gfid_path, strerror(errno));
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (dirp)
-                (void) sys_closedir (dirp);
+    if (dirp)
+        (void)sys_closedir(dirp);
 
-        return ret;
+    return ret;
 }
 
-
 void *
-xworker_crawl (void *data)
+xworker_crawl(void *data)
 {
-        struct xwork *xwork = data;
-        struct dirjob *job = NULL;
-        int            ret = -1;
+    struct xwork *xwork = data;
+    struct dirjob *job = NULL;
+    int ret = -1;
 
-        while ((job = xwork_pick (xwork, 0))) {
-                ret = xworker_do_crawl (xwork, job);
-                dirjob_ret (job, ret);
-        }
+    while ((job = xwork_pick(xwork, 0))) {
+        ret = xworker_do_crawl(xwork, job);
+        dirjob_ret(job, ret);
+    }
 
-        return NULL;
+    return NULL;
 }
 
 int
-xwork_fini (struct xwork *xwork, int stop)
+xwork_fini(struct xwork *xwork, int stop)
 {
-        int i = 0;
-        int ret = 0;
-        void *tret = 0;
-
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                xwork->stop = (xwork->stop || stop);
-                pthread_cond_broadcast (&xwork->cond);
-        }
-        pthread_mutex_unlock (&xwork->mutex);
-
-        for (i = 0; i < xwork->count; i++) {
-                pthread_join (xwork->cthreads[i], &tret);
-                tdbg ("CThread id %ld returned %p\n",
-                      xwork->cthreads[i], tret);
-        }
-
-        if (debug) {
-                assert (xwork->rootjob->refcnt == 1);
-                dirjob_ret (xwork->rootjob, 0);
-        }
-
-        if (stats)
-                pthread_spin_destroy(&stats_lock);
-
-        return ret;
+    int i = 0;
+    int ret = 0;
+    void *tret = 0;
+
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        xwork->stop = (xwork->stop || stop);
+        pthread_cond_broadcast(&xwork->cond);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
+
+    for (i = 0; i < xwork->count; i++) {
+        pthread_join(xwork->cthreads[i], &tret);
+        tdbg("CThread id %ld returned %p\n", xwork->cthreads[i], tret);
+    }
+
+    if (debug) {
+        assert(xwork->rootjob->refcnt == 1);
+        dirjob_ret(xwork->rootjob, 0);
+    }
+
+    if (stats)
+        pthread_spin_destroy(&stats_lock);
+
+    return ret;
 }
 
-
 int
-xwork_init (struct xwork *xwork, int count)
+xwork_init(struct xwork *xwork, int count)
 {
-        int  i = 0;
-        int  ret = 0;
-        struct dirjob *rootjob = NULL;
+    int i = 0;
+    int ret = 0;
+    struct dirjob *rootjob = NULL;
 
-        if (stats)
-                pthread_spin_init (&stats_lock, PTHREAD_PROCESS_PRIVATE);
+    if (stats)
+        pthread_spin_init(&stats_lock, PTHREAD_PROCESS_PRIVATE);
 
-        pthread_mutex_init (&xwork->mutex, NULL);
-        pthread_cond_init (&xwork->cond, NULL);
+    pthread_mutex_init(&xwork->mutex, NULL);
+    pthread_cond_init(&xwork->cond, NULL);
 
-        INIT_LIST_HEAD (&xwork->crawl.list);
+    INIT_LIST_HEAD(&xwork->crawl.list);
 
-        rootjob = dirjob_new (".glusterfs", NULL);
-        if (debug)
-                xwork->rootjob = dirjob_ref (rootjob);
+    rootjob = dirjob_new(".glusterfs", NULL);
+    if (debug)
+        xwork->rootjob = dirjob_ref(rootjob);
 
-        xwork_addcrawl (xwork, rootjob);
+    xwork_addcrawl(xwork, rootjob);
 
-        xwork->count = count;
-        for (i = 0; i < count; i++) {
-                ret = pthread_create (&xwork->cthreads[i], NULL,
-                                      xworker_crawl, xwork);
-                if (ret)
-                        break;
-                tdbg ("Spawned crawler %d thread %ld\n", i,
-                      xwork->cthreads[i]);
-        }
+    xwork->count = count;
+    for (i = 0; i < count; i++) {
+        ret = pthread_create(&xwork->cthreads[i], NULL, xworker_crawl, xwork);
+        if (ret)
+            break;
+        tdbg("Spawned crawler %d thread %ld\n", i, xwork->cthreads[i]);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-xfind (const char *basedir)
+xfind(const char *basedir)
 {
-        struct xwork xwork;
-        int          ret = 0;
-        char         *cwd = NULL;
-
-        ret = chdir (basedir);
-        if (ret) {
-                err ("%s: %s\n", basedir, strerror (errno));
-                return ret;
-        }
+    struct xwork xwork;
+    int ret = 0;
+    char *cwd = NULL;
 
-        cwd = getcwd (0, 0);
-        if (!cwd) {
-                err ("getcwd(): %s\n", strerror (errno));
-                return -1;
-        }
+    ret = chdir(basedir);
+    if (ret) {
+        err("%s: %s\n", basedir, strerror(errno));
+        return ret;
+    }
 
-        tdbg ("Working directory: %s\n", cwd);
-        free (cwd);
+    cwd = getcwd(0, 0);
+    if (!cwd) {
+        err("getcwd(): %s\n", strerror(errno));
+        return -1;
+    }
 
-        memset (&xwork, 0, sizeof (xwork));
+    tdbg("Working directory: %s\n", cwd);
+    free(cwd);
 
-        ret = xwork_init (&xwork, workers);
-        if (ret == 0)
-                xworker_crawl (&xwork);
+    memset(&xwork, 0, sizeof(xwork));
 
-        ret = xwork_fini (&xwork, ret);
-        stats_dump ();
+    ret = xwork_init(&xwork, workers);
+    if (ret == 0)
+        xworker_crawl(&xwork);
 
-        return ret;
+    ret = xwork_fini(&xwork, ret);
+    stats_dump();
+
+    return ret;
 }
 
 static char *
-parse_and_validate_args (int argc, char *argv[])
+parse_and_validate_args(int argc, char *argv[])
 {
-        char        *basedir = NULL;
-        struct stat  d = {0, };
-        int          ret = -1;
+    char *basedir = NULL;
+    struct stat d = {
+        0,
+    };
+    int ret = -1;
 #ifndef __FreeBSD__
-        unsigned char volume_id[16];
+    unsigned char volume_id[16];
 #endif /* __FreeBSD__ */
-        char        *slv_mnt = NULL;
+    char *slv_mnt = NULL;
 
-        if (argc != 4) {
-                err ("Usage: %s <DIR> <SLAVE-VOL-MOUNT> <CRAWL-THREAD-COUNT>\n",
-                      argv[0]);
-                return NULL;
-        }
+    if (argc != 4) {
+        err("Usage: %s <DIR> <SLAVE-VOL-MOUNT> <CRAWL-THREAD-COUNT>\n",
+            argv[0]);
+        return NULL;
+    }
 
-        basedir = argv[1];
-        ret = sys_lstat (basedir, &d);
-        if (ret) {
-                err ("%s: %s\n", basedir, strerror (errno));
-                return NULL;
-        }
+    basedir = argv[1];
+    ret = sys_lstat(basedir, &d);
+    if (ret) {
+        err("%s: %s\n", basedir, strerror(errno));
+        return NULL;
+    }
 
 #ifndef __FreeBSD__
-        ret = sys_lgetxattr (basedir, "trusted.glusterfs.volume-id",
-                             volume_id, 16);
-        if (ret != 16) {
-                err ("%s:Not a valid brick path.\n", basedir);
-                return NULL;
-        }
+    ret = sys_lgetxattr(basedir, "trusted.glusterfs.volume-id", volume_id, 16);
+    if (ret != 16) {
+        err("%s:Not a valid brick path.\n", basedir);
+        return NULL;
+    }
 #endif /* __FreeBSD__ */
 
-        slv_mnt = argv[2];
-        ret = sys_lstat (slv_mnt, &d);
-        if (ret) {
-                err ("%s: %s\n", slv_mnt, strerror (errno));
-                return NULL;
-        }
-        slavemnt = argv[2];
+    slv_mnt = argv[2];
+    ret = sys_lstat(slv_mnt, &d);
+    if (ret) {
+        err("%s: %s\n", slv_mnt, strerror(errno));
+        return NULL;
+    }
+    slavemnt = argv[2];
 
-        workers = atoi(argv[3]);
-        if (workers <= 0)
-                workers = DEFAULT_WORKERS;
+    workers = atoi(argv[3]);
+    if (workers <= 0)
+        workers = DEFAULT_WORKERS;
 
-        return basedir;
+    return basedir;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char *basedir = NULL;
+    char *basedir = NULL;
 
-        basedir = parse_and_validate_args (argc, argv);
-        if (!basedir)
-                return 1;
+    basedir = parse_and_validate_args(argc, argv);
+    if (!basedir)
+        return 1;
 
-        xfind (basedir);
+    xfind(basedir);
 
-        return 0;
+    return 0;
 }
diff --git a/tools/gfind_missing_files/gfid_to_path.py b/tools/gfind_missing_files/gfid_to_path.py
index 8362f68b955..01e08a9494a 100644
--- a/tools/gfind_missing_files/gfid_to_path.py
+++ b/tools/gfind_missing_files/gfid_to_path.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
 # This file is part of GlusterFS.
diff --git a/tools/gfind_missing_files/gfind_missing_files.sh b/tools/gfind_missing_files/gfind_missing_files.sh
index f42fe7b05af..e7aaa0b5dd4 100644
--- a/tools/gfind_missing_files/gfind_missing_files.sh
+++ b/tools/gfind_missing_files/gfind_missing_files.sh
@@ -61,7 +61,7 @@ mount_slave()
 
 parse_cli()
 {
-    if [[ $# -ne 4 ]]; then
+    if [ "$#" -ne 4 ]; then
         echo "Usage: gfind_missing_files <brick-path> <slave-host> <slave-vol> <OUTFILE>"
         exit 1
     else
diff --git a/tools/glusterfind/Makefile.am b/tools/glusterfind/Makefile.am
index 92fa61461ad..f17dbdb228e 100644
--- a/tools/glusterfind/Makefile.am
+++ b/tools/glusterfind/Makefile.am
@@ -1,11 +1,14 @@
 SUBDIRS = src
 
-EXTRA_DIST = S57glusterfind-delete-post.py
+EXTRA_DIST = S57glusterfind-delete-post.py glusterfind
 
+if WITH_SERVER
 bin_SCRIPTS = glusterfind
+endif
 
 CLEANFILES = $(bin_SCRIPTS)
 
+if WITH_SERVER
 deletehookscriptsdir = $(GLUSTERFS_LIBEXECDIR)/glusterfind/
 deletehookscripts_SCRIPTS = S57glusterfind-delete-post.py
 
@@ -18,3 +21,4 @@ install-data-local:
 	rm -f $(DESTDIR)$(GLUSTERD_WORKDIR)/hooks/1/delete/post/S57glusterfind-delete-post
 	ln -s $(GLUSTERFS_LIBEXECDIR)/glusterfind/S57glusterfind-delete-post.py \
 		$(DESTDIR)$(GLUSTERD_WORKDIR)/hooks/1/delete/post/S57glusterfind-delete-post
+endif
diff --git a/tools/glusterfind/S57glusterfind-delete-post.py b/tools/glusterfind/S57glusterfind-delete-post.py
index fb6c222df03..5beece220f0 100755
--- a/tools/glusterfind/S57glusterfind-delete-post.py
+++ b/tools/glusterfind/S57glusterfind-delete-post.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 import os
 import shutil
 from errno import ENOENT
@@ -18,7 +18,7 @@ def handle_rm_error(func, path, exc_info):
 
 def get_glusterd_workdir():
     p = Popen(["gluster", "system::", "getwd"],
-              stdout=PIPE, stderr=PIPE)
+              stdout=PIPE, stderr=PIPE, universal_newlines=True)
 
     out, _ = p.communicate()
 
diff --git a/tools/glusterfind/glusterfind.in b/tools/glusterfind/glusterfind.in
index cff8973980a..ca154b625dd 100644
--- a/tools/glusterfind/glusterfind.in
+++ b/tools/glusterfind/glusterfind.in
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
 # This file is part of GlusterFS.
@@ -10,6 +10,7 @@
 
 import sys
 sys.path.insert(1, '@GLUSTERFS_LIBEXECDIR@/')
+sys.path.insert(1, '@GLUSTERFS_LIBEXECDIR@/glusterfind')
 
 from glusterfind.main import main
 
diff --git a/tools/glusterfind/src/Makefile.am b/tools/glusterfind/src/Makefile.am
index e4469c1c0cf..43b6141b01c 100644
--- a/tools/glusterfind/src/Makefile.am
+++ b/tools/glusterfind/src/Makefile.am
@@ -1,12 +1,14 @@
 glusterfinddir = $(GLUSTERFS_LIBEXECDIR)/glusterfind
 
+if WITH_SERVER
 glusterfind_PYTHON = conf.py utils.py __init__.py \
-	main.py libgfchangelog.py changelogdata.py
+	main.py libgfchangelog.py changelogdata.py gfind_py2py3.py
 
 glusterfind_SCRIPTS = changelog.py nodeagent.py \
 	brickfind.py
 
 glusterfind_DATA = tool.conf
+endif
 
 EXTRA_DIST = changelog.py nodeagent.py brickfind.py \
 	tool.conf changelogdata.py
diff --git a/tools/glusterfind/src/brickfind.py b/tools/glusterfind/src/brickfind.py
index e914bacd4ab..73b6350188d 100644
--- a/tools/glusterfind/src/brickfind.py
+++ b/tools/glusterfind/src/brickfind.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
@@ -13,7 +13,10 @@ import os
 import sys
 import logging
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
-import urllib
+try:
+    import urllib.parse as urllib
+except ImportError:
+    import urllib
 import time
 
 from utils import mkdirp, setup_logger, create_file, output_write, find
@@ -38,12 +41,20 @@ def brickfind_crawl(brick, args):
     with open(args.outfile, "a+") as fout:
         brick_path_len = len(brick)
 
-        def output_callback(path, filter_result):
+        def output_callback(path, filter_result, is_dir):
             path = path.strip()
             path = path[brick_path_len+1:]
-            output_write(fout, path, args.output_prefix,
-                         encode=(not args.no_encode), tag=args.tag,
-                         field_separator=args.field_separator)
+
+            if args.type == "both":
+                output_write(fout, path, args.output_prefix,
+                             encode=(not args.no_encode), tag=args.tag,
+                             field_separator=args.field_separator)
+            else:
+                if (is_dir and args.type == "d") or (
+                    (not is_dir) and args.type == "f"):
+                    output_write(fout, path, args.output_prefix,
+                    encode=(not args.no_encode), tag=args.tag,
+                    field_separator=args.field_separator)
 
         ignore_dirs = [os.path.join(brick, dirname)
                        for dirname in
@@ -74,6 +85,9 @@ def _get_args():
                         action="store_true")
     parser.add_argument("--output-prefix", help="File prefix in output",
                         default=".")
+    parser.add_argument('--type', help="type: f, f-files only"
+                        " d, d-directories only, by default = both",
+                        default='both')
     parser.add_argument("--field-separator", help="Field separator",
                         default=" ")
 
@@ -84,7 +98,7 @@ if __name__ == "__main__":
     args = _get_args()
     session_dir = os.path.join(conf.get_opt("session_dir"), args.session)
     status_file = os.path.join(session_dir, args.volume,
-                               "%s.status" % urllib.quote_plus(args.brick))
+                     "%s.status" % urllib.quote_plus(args.brick))
     status_file_pre = status_file + ".pre"
     mkdirp(os.path.join(session_dir, args.volume), exit_on_err=True,
            logger=logger)
@@ -99,6 +113,6 @@ if __name__ == "__main__":
     time_to_update = int(time.time())
     brickfind_crawl(args.brick, args)
     if not args.only_query:
-        with open(status_file_pre, "w", buffering=0) as f:
+        with open(status_file_pre, "w") as f:
             f.write(str(time_to_update))
     sys.exit(0)
diff --git a/tools/glusterfind/src/changelog.py b/tools/glusterfind/src/changelog.py
index 2376af26e72..a5e9ea4288f 100644
--- a/tools/glusterfind/src/changelog.py
+++ b/tools/glusterfind/src/changelog.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
@@ -14,9 +14,13 @@ import sys
 import time
 import xattr
 import logging
+from gfind_py2py3 import bytearray_to_str
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 import hashlib
-import urllib
+try:
+    import urllib.parse as urllib
+except ImportError:
+    import urllib
 import codecs
 
 import libgfchangelog
@@ -47,7 +51,7 @@ def pgfid_to_path(brick, changelog_data):
     """
     # pgfid1 to path1 in case of CREATE/MKNOD/MKDIR/LINK/SYMLINK
     for row in changelog_data.gfidpath_get_distinct("pgfid1", {"path1": ""}):
-        # In case of Data/Metadata only, pgfid1 will not be their
+        # In case of Data/Metadata only, pgfid1 will not be there
         if row[0] == "":
             continue
 
@@ -102,15 +106,55 @@ def populate_pgfid_and_inodegfid(brick, changelog_data):
                 changelog_data.inodegfid_add(os.stat(p).st_ino, gfid)
                 file_xattrs = xattr.list(p)
                 for x in file_xattrs:
-                    if x.startswith("trusted.pgfid."):
+                    x_str = bytearray_to_str(x)
+                    if x_str.startswith("trusted.pgfid."):
                         # PGFID in pgfid table
-                        changelog_data.pgfid_add(x.split(".")[-1])
+                        changelog_data.pgfid_add(x_str.split(".")[-1])
             except (IOError, OSError):
                 # All OS Errors ignored, since failures will be logged
                 # in End. All GFIDs present in gfidpath table
                 continue
 
 
+def enum_hard_links_using_gfid2path(brick, gfid, args):
+    hardlinks = []
+    p = os.path.join(brick, ".glusterfs", gfid[0:2], gfid[2:4], gfid)
+    if not os.path.isdir(p):
+        # we have a symlink or a normal file
+        try:
+            file_xattrs = xattr.list(p)
+            for x in file_xattrs:
+                x_str = bytearray_to_str(x)
+                if x_str.startswith("trusted.gfid2path."):
+                    # get the value for the xattr i.e. <PGFID>/<BN>
+                    v = xattr.getxattr(p, x_str)
+                    v_str = bytearray_to_str(v)
+                    pgfid, bn = v_str.split(os.sep)
+                    try:
+                        path = symlink_gfid_to_path(brick, pgfid)
+                        fullpath = os.path.join(path, bn)
+                        fullpath = output_path_prepare(fullpath, args)
+                        hardlinks.append(fullpath)
+                    except (IOError, OSError) as e:
+                        logger.warn("Error converting to path: %s" % e)
+                        continue
+        except (IOError, OSError):
+            pass
+    return hardlinks
+
+
+def gfid_to_all_paths_using_gfid2path(brick, changelog_data, args):
+    path = ""
+    for row in changelog_data.gfidpath_get({"path1": "", "type": "MODIFY"}):
+        gfid = row[3].strip()
+        logger.debug("Processing gfid %s" % gfid)
+        hardlinks = enum_hard_links_using_gfid2path(brick, gfid, args)
+
+        path = ",".join(hardlinks)
+
+        changelog_data.gfidpath_update({"path1": path}, {"gfid": gfid})
+
+
 def gfid_to_path_using_pgfid(brick, changelog_data, args):
     """
     For all the pgfids collected, Converts to Path and
@@ -243,7 +287,7 @@ def get_changes(brick, hash_dir, log_file, start, end, args):
     session_dir = os.path.join(conf.get_opt("session_dir"),
                                args.session)
     status_file = os.path.join(session_dir, args.volume,
-                               "%s.status" % urllib.quote_plus(args.brick))
+                     "%s.status" % urllib.quote_plus(args.brick))
 
     # Get previous session
     try:
@@ -273,6 +317,7 @@ def get_changes(brick, hash_dir, log_file, start, end, args):
         fail("%s: %s Historical Changelogs not available: %s" %
              (args.node, brick, e), logger=logger)
 
+    logger.info("[1/4] Starting changelog parsing ...")
     try:
         # scan followed by getchanges till scan returns zero.
         # history_scan() is blocking call, till it gets the number
@@ -301,18 +346,27 @@ def get_changes(brick, hash_dir, log_file, start, end, args):
         fail("%s Error during Changelog Crawl: %s" % (brick, e),
              logger=logger)
 
+    logger.info("[1/4] Finished changelog parsing.")
+
     # Convert all pgfid available from Changelogs
+    logger.info("[2/4] Starting 'pgfid to path' conversions ...")
     pgfid_to_path(brick, changelog_data)
     changelog_data.commit()
+    logger.info("[2/4] Finished 'pgfid to path' conversions.")
 
-    # Convert all GFIDs for which no other additional details available
-    gfid_to_path_using_pgfid(brick, changelog_data, args)
+    # Convert all gfids recorded for data and metadata to all hardlink paths
+    logger.info("[3/4] Starting 'gfid2path' conversions ...")
+    gfid_to_all_paths_using_gfid2path(brick, changelog_data, args)
     changelog_data.commit()
+    logger.info("[3/4] Finished 'gfid2path' conversions.")
 
     # If some GFIDs fail to get converted from previous step,
     # convert using find
+    logger.info("[4/4] Starting 'gfid to path using batchfind' "
+                "conversions ...")
     gfid_to_path_using_batchfind(brick, changelog_data)
     changelog_data.commit()
+    logger.info("[4/4] Finished 'gfid to path using batchfind' conversions.")
 
     return actual_end
 
@@ -326,7 +380,7 @@ def changelog_crawl(brick, start, end, args):
 
     # WORKING_DIR/BRICKHASH/OUTFILE
     working_dir = os.path.dirname(args.outfile)
-    brickhash = hashlib.sha1(brick)
+    brickhash = hashlib.sha1(brick.encode())
     brickhash = str(brickhash.hexdigest())
     working_dir = os.path.join(working_dir, brickhash)
 
@@ -361,6 +415,7 @@ def _get_args():
                         action="store_true")
     parser.add_argument("--output-prefix", help="File prefix in output",
                         default=".")
+    parser.add_argument("--type",default="both")
     parser.add_argument("-N", "--only-namespace-changes",
                         help="List only namespace changes",
                         action="store_true")
@@ -380,7 +435,7 @@ if __name__ == "__main__":
 
     session_dir = os.path.join(conf.get_opt("session_dir"), args.session)
     status_file = os.path.join(session_dir, args.volume,
-                               "%s.status" % urllib.quote_plus(args.brick))
+                     "%s.status" % urllib.quote_plus(args.brick))
     status_file_pre = status_file + ".pre"
     mkdirp(os.path.join(session_dir, args.volume), exit_on_err=True,
            logger=logger)
@@ -406,7 +461,7 @@ if __name__ == "__main__":
                                                                     end))
     actual_end = changelog_crawl(args.brick, start, end, args)
     if not args.only_query:
-        with open(status_file_pre, "w", buffering=0) as f:
+        with open(status_file_pre, "w") as f:
             f.write(str(actual_end))
 
     logger.info("%s Finished Changelog Crawl - End: %s" % (args.brick,
diff --git a/tools/glusterfind/src/changelogdata.py b/tools/glusterfind/src/changelogdata.py
index 3140d945b49..641593cf4b1 100644
--- a/tools/glusterfind/src/changelogdata.py
+++ b/tools/glusterfind/src/changelogdata.py
@@ -112,6 +112,11 @@ class ChangelogData(object):
         """
         self.cursor.execute(create_table)
 
+        create_index = """
+        CREATE INDEX gfid_index ON gfidpath(gfid);
+        """
+        self.cursor.execute(create_index)
+
     def _create_table_inodegfid(self):
         drop_table = "DROP TABLE IF EXISTS inodegfid"
         self.cursor.execute(drop_table)
diff --git a/tools/glusterfind/src/conf.py b/tools/glusterfind/src/conf.py
index d91746bda13..3849ba5dd1f 100644
--- a/tools/glusterfind/src/conf.py
+++ b/tools/glusterfind/src/conf.py
@@ -9,9 +9,12 @@
 # cases as published by the Free Software Foundation.
 
 import os
-import ConfigParser
+try:
+    from ConfigParser import ConfigParser
+except ImportError:
+    from configparser import ConfigParser
 
-config = ConfigParser.ConfigParser()
+config = ConfigParser()
 config.read(os.path.join(os.path.dirname(os.path.abspath(__file__)),
                          "tool.conf"))
 
diff --git a/tools/glusterfind/src/gfind_py2py3.py b/tools/glusterfind/src/gfind_py2py3.py
new file mode 100644
index 00000000000..87324fbf350
--- /dev/null
+++ b/tools/glusterfind/src/gfind_py2py3.py
@@ -0,0 +1,88 @@
+#
+# Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
+# This file is part of GlusterFS.
+
+# This file is licensed to you under your choice of the GNU Lesser
+# General Public License, version 3 or any later version (LGPLv3 or
+# later), or the GNU General Public License, version 2 (GPLv2), in all
+# cases as published by the Free Software Foundation.
+#
+
+# All python2/python3 compatibility routines
+
+import os
+import sys
+from ctypes import create_string_buffer
+
+if sys.version_info >= (3,):
+
+    # Raw conversion of bytearray to string. Used in the cases where
+    # buffer is created by create_string_buffer which is a 8-bit char
+    # array and passed to syscalls to fetch results. Using encode/decode
+    # doesn't work as it converts to string altering the size.
+    # def bytearray_to_str(byte_arr):
+    def bytearray_to_str(byte_arr):
+        return ''.join([chr(b) for b in byte_arr])
+
+    def gf_create_string_buffer(size):
+        return create_string_buffer(b'\0', size)
+
+    def gfind_history_changelog(libgfc, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return libgfc.gf_history_changelog(changelog_path.encode(), start, end, num_parallel,
+                       actual_end)
+
+    def gfind_changelog_register(libgfc, brick, path, log_file, log_level,
+                                 retries):
+        return libgfc.gf_changelog_register(brick.encode(), path.encode(), log_file.encode(),
+                       log_level, retries)
+
+    def gfind_history_changelog_done(libgfc, clfile):
+        return libgfc.gf_history_changelog_done(clfile.encode())
+
+    def gfind_write_row(f, row, field_separator, p_rep, row_2_rep):
+        f.write(u"{0}{1}{2}{3}{4}\n".format(row,
+                                            field_separator,
+                                            p_rep,
+                                            field_separator,
+                                            row_2_rep))
+
+    def gfind_write(f, row, field_separator, p_rep):
+        f.write(u"{0}{1}{2}\n".format(row,
+                                      field_separator,
+                                      p_rep))
+
+
+else:
+
+    # Raw conversion of bytearray to string
+    def bytearray_to_str(byte_arr):
+        return byte_arr
+
+    def gf_create_string_buffer(size):
+        return create_string_buffer('\0', size)
+
+    def gfind_history_changelog(libgfc, changelog_path, start, end, num_parallel,
+                                actual_end):
+        return libgfc.gf_history_changelog(changelog_path, start, end,
+                                                    num_parallel, actual_end)
+
+    def gfind_changelog_register(libgfc, brick, path, log_file, log_level,
+                                 retries):
+        return libgfc.gf_changelog_register(brick, path, log_file,
+                                                     log_level, retries)
+
+    def gfind_history_changelog_done(libgfc, clfile):
+        return libgfc.gf_history_changelog_done(clfile)
+
+    def gfind_write_row(f, row, field_separator, p_rep, row_2_rep):
+        f.write(u"{0}{1}{2}{3}{4}\n".format(row,
+                                            field_separator,
+                                            p_rep,
+                                            field_separator,
+                                            row_2_rep).encode())
+
+    def gfind_write(f, row, field_separator, p_rep):
+        f.write(u"{0}{1}{2}\n".format(row,
+                                      field_separator,
+                                      p_rep).encode())
diff --git a/tools/glusterfind/src/libgfchangelog.py b/tools/glusterfind/src/libgfchangelog.py
index 0f6b40d6c9c..513bb101e93 100644
--- a/tools/glusterfind/src/libgfchangelog.py
+++ b/tools/glusterfind/src/libgfchangelog.py
@@ -9,51 +9,52 @@
 # cases as published by the Free Software Foundation.
 
 import os
-from ctypes import CDLL, get_errno, create_string_buffer, c_ulong, byref
-from ctypes import RTLD_GLOBAL
+from ctypes import CDLL, RTLD_GLOBAL, get_errno, create_string_buffer, c_ulong, byref
 from ctypes.util import find_library
+from gfind_py2py3 import bytearray_to_str, gf_create_string_buffer
+from gfind_py2py3 import gfind_history_changelog, gfind_changelog_register
+from gfind_py2py3 import gfind_history_changelog_done
 
 
 class ChangelogException(OSError):
     pass
 
+libgfc = CDLL(find_library("gfchangelog"), mode=RTLD_GLOBAL, use_errno=True)
 
-libgfc = CDLL(find_library("gfchangelog"), use_errno=True, mode=RTLD_GLOBAL)
 
-
-def raise_oserr():
+def raise_oserr(prefix=None):
     errn = get_errno()
-    raise ChangelogException(errn, os.strerror(errn))
+    prefix_or_empty = prefix + ": " if prefix else ""
+    raise ChangelogException(errn, prefix_or_empty + os.strerror(errn))
 
 
 def cl_init():
     ret = libgfc.gf_changelog_init(None)
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_changelog_init")
 
 
 def cl_register(brick, path, log_file, log_level, retries=0):
-    ret = libgfc.gf_changelog_register(brick, path, log_file,
-                                       log_level, retries)
+    ret = gfind_changelog_register(libgfc, brick, path, log_file,log_level, retries)
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_changelog_register")
 
 
 def cl_history_scan():
     ret = libgfc.gf_history_changelog_scan()
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_history_changelog_scan")
 
     return ret
 
 
 def cl_history_changelog(changelog_path, start, end, num_parallel):
     actual_end = c_ulong()
-    ret = libgfc.gf_history_changelog(changelog_path, start, end,
+    ret = gfind_history_changelog(libgfc,changelog_path, start, end,
                                       num_parallel,
                                       byref(actual_end))
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_history_changelog")
 
     return actual_end.value
 
@@ -61,7 +62,7 @@ def cl_history_changelog(changelog_path, start, end, num_parallel):
 def cl_history_startfresh():
     ret = libgfc.gf_history_changelog_start_fresh()
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_history_changelog_start_fresh")
 
 
 def cl_history_getchanges():
@@ -70,20 +71,22 @@ def cl_history_getchanges():
         return f.split('.')[-1]
 
     changes = []
-    buf = create_string_buffer('\0', 4096)
+    buf = gf_create_string_buffer(4096)
 
     while True:
         ret = libgfc.gf_history_changelog_next_change(buf, 4096)
         if ret in (0, -1):
             break
-        changes.append(buf.raw[:ret - 1])
+        # py2 and py3 compatibility
+        result = bytearray_to_str(buf.raw[:ret - 1])
+        changes.append(result)
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_history_changelog_next_change")
 
     return sorted(changes, key=clsort)
 
 
 def cl_history_done(clfile):
-    ret = libgfc.gf_history_changelog_done(clfile)
+    ret = gfind_history_changelog_done(libgfc, clfile)
     if ret == -1:
-        raise_oserr()
+        raise_oserr(prefix="gf_history_changelog_done")
diff --git a/tools/glusterfind/src/main.py b/tools/glusterfind/src/main.py
index e7e9889569c..4b5466d0114 100644
--- a/tools/glusterfind/src/main.py
+++ b/tools/glusterfind/src/main.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
@@ -16,12 +16,14 @@ from multiprocessing import Process
 import os
 import xml.etree.cElementTree as etree
 from argparse import ArgumentParser, RawDescriptionHelpFormatter, Action
+from gfind_py2py3 import gfind_write_row, gfind_write
 import logging
 import shutil
 import tempfile
 import signal
 from datetime import datetime
 import codecs
+import re
 
 from utils import execute, is_host_local, mkdirp, fail
 from utils import setup_logger, human_time, handle_rm_error
@@ -35,9 +37,9 @@ GlusterFS Incremental API
 ParseError = etree.ParseError if hasattr(etree, 'ParseError') else SyntaxError
 
 logger = logging.getLogger()
-node_outfiles = []
 vol_statusStr = ""
 gtmpfilename = None
+g_pid_nodefile_map = {}
 
 
 class StoreAbsPath(Action):
@@ -75,12 +77,27 @@ def node_cmd(host, host_uuid, task, cmd, args, opts):
             cmd = ["ssh",
                    "-oNumberOfPasswordPrompts=0",
                    "-oStrictHostKeyChecking=no",
+                   # We force TTY allocation (-t -t) so that Ctrl+C is handed
+                   # through; see:
+                   #   https://bugzilla.redhat.com/show_bug.cgi?id=1382236
+                   # Note that this turns stderr of the remote `cmd`
+                   # into stdout locally.
                    "-t",
                    "-t",
                    "-i", pem_key_path,
                    "root@%s" % host] + cmd
 
-        execute(cmd, exit_msg="%s - %s failed" % (host, task), logger=logger)
+        (returncode, err, out) = execute(cmd, logger=logger)
+        if returncode != 0:
+            # Because the `-t -t` above turns the remote stderr into
+            # local stdout, we need to log both stderr and stdout
+            # here to print all error messages.
+            fail("%s - %s failed; stdout (including remote stderr):\n"
+                 "%s\n"
+                 "stderr:\n"
+                 "%s" % (host, task, out, err),
+                 returncode,
+                 logger=logger)
 
         if opts.get("copy_outfile", False) and not localdir:
             cmd_copy = ["scp",
@@ -96,7 +113,7 @@ def node_cmd(host, host_uuid, task, cmd, args, opts):
 
 
 def run_cmd_nodes(task, args, **kwargs):
-    global node_outfiles
+    global g_pid_nodefile_map
     nodes = get_nodes(args.volume)
     pool = []
     for num, node in enumerate(nodes):
@@ -127,7 +144,6 @@ def run_cmd_nodes(task, args, **kwargs):
                 if tag == "":
                     tag = '""' if not is_host_local(host_uuid) else ""
 
-            node_outfiles.append(node_outfile)
             # remote file will be copied into this directory
             mkdirp(os.path.dirname(node_outfile),
                    exit_on_err=True, logger=logger)
@@ -150,6 +166,7 @@ def run_cmd_nodes(task, args, **kwargs):
                 (["--no-encode"] if args.no_encode else []) + \
                 (["--only-namespace-changes"] if args.only_namespace_changes
                  else []) + \
+                (["--type", args.type]) + \
                 (["--field-separator", FS] if args.full else [])
 
             opts["node_outfile"] = node_outfile
@@ -164,7 +181,6 @@ def run_cmd_nodes(task, args, **kwargs):
                 if tag == "":
                     tag = '""' if not is_host_local(host_uuid) else ""
 
-            node_outfiles.append(node_outfile)
             # remote file will be copied into this directory
             mkdirp(os.path.dirname(node_outfile),
                    exit_on_err=True, logger=logger)
@@ -188,6 +204,7 @@ def run_cmd_nodes(task, args, **kwargs):
                 (["--no-encode"] if args.no_encode else []) + \
                 (["--only-namespace-changes"]
                     if args.only_namespace_changes else []) + \
+                (["--type", args.type]) + \
                 (["--field-separator", FS] if args.full else [])
 
             opts["node_outfile"] = node_outfile
@@ -247,6 +264,7 @@ def run_cmd_nodes(task, args, **kwargs):
                         args=(host, host_uuid, task, cmd, args, opts))
             p.start()
             pool.append(p)
+            g_pid_nodefile_map[p.pid] = node_outfile
 
     for num, p in enumerate(pool):
         p.join()
@@ -254,8 +272,11 @@ def run_cmd_nodes(task, args, **kwargs):
             logger.warn("Command %s failed in %s" % (task, nodes[num][1]))
             if task in ["create", "delete"]:
                 fail("Command %s failed in %s" % (task, nodes[num][1]))
-            elif task == "pre" and args.disable_partial:
-                sys.exit(1)
+            elif task == "pre" or task == "query":
+                if args.disable_partial:
+                    sys.exit(1)
+                else:
+                    del g_pid_nodefile_map[p.pid]
 
 
 @cache_output
@@ -305,6 +326,7 @@ def _get_args():
     parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
                             description=PROG_DESCRIPTION)
     subparsers = parser.add_subparsers(dest="mode")
+    subparsers.required = True
 
     # create <SESSION> <VOLUME> [--debug] [--force]
     parser_create = subparsers.add_parser('create')
@@ -355,6 +377,9 @@ def _get_args():
                             help="Tag prefix for file names emitted during"
                             " a full find operation; default: \"NEW\"",
                             default="NEW")
+    parser_pre.add_argument('--type', help="type: f, f-files only"
+                            " d, d-directories only, by default = both",
+                            default='both', choices=["f", "d", "both"])
     parser_pre.add_argument("--field-separator", help="Field separator string",
                             default=" ")
 
@@ -366,7 +391,7 @@ def _get_args():
                               action=StoreAbsPath)
     parser_query.add_argument("--since-time", help="UNIX epoch time since "
                               "which listing is required", type=int)
-    parser_query.add_argument("--end-time", help="UNIX epoch time upto "
+    parser_query.add_argument("--end-time", help="UNIX epoch time up to "
                               "which listing is required", type=int)
     parser_query.add_argument("--no-encode",
                               help="Do not encode path in output file",
@@ -384,6 +409,9 @@ def _get_args():
                               help="Tag prefix for file names emitted during"
                               " a full find operation; default: \"NEW\"",
                               default="NEW")
+    parser_query.add_argument('--type', help="type: f, f-files only"
+                              " d, d-directories only, by default = both",
+                              default='both', choices=["f", "d", "both"])
     parser_query.add_argument("--field-separator",
                               help="Field separator string",
                               default=" ")
@@ -488,22 +516,13 @@ def write_output(outfile, outfilemerger, field_separator):
                     continue
 
                 if row_2_rep and row_2_rep != "":
-                    f.write(u"{0}{1}{2}{3}{4}\n".format(row[0],
-                                                        field_separator,
-                                                        p_rep,
-                                                        field_separator,
-                                                        row_2_rep))
-                else:
-                    f.write(u"{0}{1}{2}\n".format(row[0],
-                                                  field_separator,
-                                                  p_rep))
-
+                    gfind_write_row(f, row[0], field_separator, p_rep, row_2_rep)
 
-def mode_create(session_dir, args):
-    logger.debug("Init is called - Session: %s, Volume: %s"
-                 % (args.session, args.volume))
+                else:
+                    gfind_write(f, row[0], field_separator, p_rep)
 
-    cmd = ["gluster", 'volume', 'info', args.volume, "--xml"]
+def validate_volume(volume):
+    cmd = ["gluster", 'volume', 'info', volume, "--xml"]
     _, data, _ = execute(cmd,
                          exit_msg="Failed to Run Gluster Volume Info",
                          logger=logger)
@@ -511,11 +530,42 @@ def mode_create(session_dir, args):
         tree = etree.fromstring(data)
         statusStr = tree.find('volInfo/volumes/volume/statusStr').text
     except (ParseError, AttributeError) as e:
-        fail("Invalid Volume: %s" % e, logger=logger)
-
+        fail("Invalid Volume: Check the Volume name! %s" % e)
     if statusStr != "Started":
-        fail("Volume %s is not online" % args.volume, logger=logger)
+        fail("Volume %s is not online" % volume)
+
+# The rules for a valid session name.
+SESSION_NAME_RULES = {
+    'min_length': 2,
+    'max_length': 256,  # same as maximum volume length
+    # Specifies all alphanumeric characters, underscore, hyphen.
+    'valid_chars': r'0-9a-zA-Z_-',
+}
+
+
+# checks valid session name, fail otherwise
+def validate_session_name(session):
+    # Check for minimum length
+    if len(session) < SESSION_NAME_RULES['min_length']:
+        fail('session_name must be at least ' +
+                 str(SESSION_NAME_RULES['min_length']) + ' characters long.')
+    # Check for maximum length
+    if len(session) > SESSION_NAME_RULES['max_length']:
+        fail('session_name must not exceed ' +
+                 str(SESSION_NAME_RULES['max_length']) + ' characters length.')
+
+    # Matches strings composed entirely of characters specified within
+    if not re.match(r'^[' + SESSION_NAME_RULES['valid_chars'] +
+                        ']+$', session):
+        fail('Session name can only contain these characters: ' +
+                         SESSION_NAME_RULES['valid_chars'])
 
+
+def mode_create(session_dir, args):
+    validate_session_name(args.session)
+
+    logger.debug("Init is called - Session: %s, Volume: %s"
+                 % (args.session, args.volume))
     mkdirp(session_dir, exit_on_err=True, logger=logger)
     mkdirp(os.path.join(session_dir, args.volume), exit_on_err=True,
            logger=logger)
@@ -536,7 +586,7 @@ def mode_create(session_dir, args):
     run_cmd_nodes("create", args, time_to_update=str(time_to_update))
 
     if not os.path.exists(status_file) or args.reset_session_time:
-        with open(status_file, "w", buffering=0) as f:
+        with open(status_file, "w") as f:
             f.write(str(time_to_update))
 
     sys.stdout.write("Session %s created with volume %s\n" %
@@ -547,6 +597,7 @@ def mode_create(session_dir, args):
 
 def mode_query(session_dir, args):
     global gtmpfilename
+    global g_pid_nodefile_map
 
     # Verify volume status
     cmd = ["gluster", 'volume', 'info', args.volume, "--xml"]
@@ -574,6 +625,8 @@ def mode_query(session_dir, args):
     enable_volume_options(args)
 
     # Test options
+    if not args.full and args.type in ["f", "d"]:
+        fail("--type can only be used with --full")
     if not args.since_time and not args.end_time and not args.full:
         fail("Please specify either {--since-time and optionally --end-time} "
              "or --full", logger=logger)
@@ -608,14 +661,20 @@ def mode_query(session_dir, args):
 
     # Merger
     if args.full:
-        cmd = ["sort", "-u"] + node_outfiles + ["-o", args.outfile]
-        execute(cmd,
-                exit_msg="Failed to merge output files "
-                "collected from nodes", logger=logger)
+        if len(g_pid_nodefile_map) > 0:
+            cmd = ["sort", "-u"] + list(g_pid_nodefile_map.values()) + \
+                  ["-o", args.outfile]
+            execute(cmd,
+                    exit_msg="Failed to merge output files "
+                    "collected from nodes", logger=logger)
+        else:
+            fail("Failed to collect any output files from peers. "
+                 "Looks like all bricks are offline.", logger=logger)
     else:
         # Read each Changelogs db and generate finaldb
         create_file(args.outfile, exit_on_err=True, logger=logger)
-        outfilemerger = OutputMerger(args.outfile + ".db", node_outfiles)
+        outfilemerger = OutputMerger(args.outfile + ".db",
+                                     list(g_pid_nodefile_map.values()))
         write_output(args.outfile, outfilemerger, args.field_separator)
 
     try:
@@ -630,6 +689,7 @@ def mode_query(session_dir, args):
 
 def mode_pre(session_dir, args):
     global gtmpfilename
+    global g_pid_nodefile_map
 
     """
     Read from Session file and write to session.pre file
@@ -641,6 +701,9 @@ def mode_pre(session_dir, args):
 
     mkdirp(os.path.dirname(args.outfile), exit_on_err=True, logger=logger)
 
+    if not args.full and args.type in ["f", "d"]:
+        fail("--type can only be used with --full")
+
     # If Pre status file exists and running pre command again
     if os.path.exists(status_file_pre) and not args.regenerate_outfile:
         fail("Post command is not run after last pre, "
@@ -667,14 +730,20 @@ def mode_pre(session_dir, args):
 
     # Merger
     if args.full:
-        cmd = ["sort", "-u"] + node_outfiles + ["-o", args.outfile]
-        execute(cmd,
-                exit_msg="Failed to merge output files "
-                "collected from nodes", logger=logger)
+        if len(g_pid_nodefile_map) > 0:
+            cmd = ["sort", "-u"] + list(g_pid_nodefile_map.values()) + \
+                  ["-o", args.outfile]
+            execute(cmd,
+                    exit_msg="Failed to merge output files "
+                    "collected from nodes", logger=logger)
+        else:
+            fail("Failed to collect any output files from peers. "
+                 "Looks like all bricks are offline.", logger=logger)
     else:
         # Read each Changelogs db and generate finaldb
         create_file(args.outfile, exit_on_err=True, logger=logger)
-        outfilemerger = OutputMerger(args.outfile + ".db", node_outfiles)
+        outfilemerger = OutputMerger(args.outfile + ".db",
+                                     list(g_pid_nodefile_map.values()))
         write_output(args.outfile, outfilemerger, args.field_separator)
 
     try:
@@ -684,7 +753,7 @@ def mode_pre(session_dir, args):
 
     run_cmd_nodes("cleanup", args, tmpfilename=gtmpfilename)
 
-    with open(status_file_pre, "w", buffering=0) as f:
+    with open(status_file_pre, "w") as f:
         f.write(str(endtime_to_update))
 
     sys.stdout.write("Generated output file %s\n" % args.outfile)
@@ -810,6 +879,11 @@ def main():
                 args.mode not in ["create", "list", "query"]:
             fail("Invalid session %s" % args.session)
 
+        # volume involved, validate the volume first
+        if args.mode not in ["list"]:
+            validate_volume(args.volume)
+
+
         # "default" is a system defined session name
         if args.mode in ["create", "post", "pre", "delete"] and \
                 args.session == "default":
diff --git a/tools/glusterfind/src/nodeagent.py b/tools/glusterfind/src/nodeagent.py
index 07d82826e0d..679daa6fa76 100644
--- a/tools/glusterfind/src/nodeagent.py
+++ b/tools/glusterfind/src/nodeagent.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com/>
@@ -14,7 +14,10 @@ import sys
 import os
 import logging
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
-import urllib
+try:
+    import urllib.parse as urllib
+except ImportError:
+    import urllib
 from errno import ENOTEMPTY
 
 from utils import setup_logger, mkdirp, handle_rm_error
@@ -49,13 +52,13 @@ def mode_create(args):
     session_dir = os.path.join(conf.get_opt("session_dir"),
                                args.session)
     status_file = os.path.join(session_dir, args.volume,
-                               "%s.status" % urllib.quote_plus(args.brick))
+                     "%s.status" % urllib.quote_plus(args.brick))
 
     mkdirp(os.path.join(session_dir, args.volume), exit_on_err=True,
            logger=logger)
 
     if not os.path.exists(status_file) or args.reset_session_time:
-        with open(status_file, "w", buffering=0) as f:
+        with open(status_file, "w") as f:
             f.write(args.time_to_update)
 
     sys.exit(0)
@@ -64,7 +67,7 @@ def mode_create(args):
 def mode_post(args):
     session_dir = os.path.join(conf.get_opt("session_dir"), args.session)
     status_file = os.path.join(session_dir, args.volume,
-                               "%s.status" % urllib.quote_plus(args.brick))
+                     "%s.status" % urllib.quote_plus(args.brick))
 
     mkdirp(os.path.join(session_dir, args.volume), exit_on_err=True,
            logger=logger)
diff --git a/tools/glusterfind/src/utils.py b/tools/glusterfind/src/utils.py
index c24258e6ef8..906ebd8f252 100644
--- a/tools/glusterfind/src/utils.py
+++ b/tools/glusterfind/src/utils.py
@@ -36,10 +36,10 @@ class RecordType(object):
 def cache_output(func):
     def wrapper(*args, **kwargs):
         global cache_data
-        if cache_data.get(func.func_name, None) is None:
-            cache_data[func.func_name] = func(*args, **kwargs)
+        if cache_data.get(func.__name__, None) is None:
+            cache_data[func.__name__] = func(*args, **kwargs)
 
-        return cache_data[func.func_name]
+        return cache_data[func.__name__]
     return wrapper
 
 
@@ -58,12 +58,13 @@ def find(path, callback_func=lambda x: True, filter_func=lambda x: True,
     # Capture filter_func output and pass it to callback function
     filter_result = filter_func(path)
     if filter_result is not None:
-        callback_func(path, filter_result)
+        callback_func(path, filter_result, os.path.isdir(path))
 
     for p in os.listdir(path):
         full_path = os.path.join(path, p)
 
-        if os.path.isdir(full_path):
+        is_dir = os.path.isdir(full_path)
+        if is_dir:
             if subdirs_crawl:
                 find(full_path, callback_func, filter_func, ignore_dirs)
             else:
@@ -73,7 +74,7 @@ def find(path, callback_func=lambda x: True, filter_func=lambda x: True,
         else:
             filter_result = filter_func(full_path)
             if filter_result is not None:
-                callback_func(full_path, filter_result)
+                callback_func(full_path, filter_result, is_dir)
 
 
 def output_write(f, path, prefix=".", encode=False, tag="",
@@ -229,7 +230,11 @@ def get_changelog_rollover_time(volumename):
 
     try:
         tree = etree.fromstring(out)
-        return int(tree.find('volGetopts/Opt/Value').text)
+        val = tree.find('volGetopts/Opt/Value').text
+        if val is not None:
+            # Filter the value by split, as it may be 'X (DEFAULT)'
+            # and we only need 'X'
+            return int(val.split(' ', 1)[0])
     except ParseError:
         return DEFAULT_CHANGELOG_INTERVAL
 
diff --git a/tools/setgfid2path/src/Makefile.am b/tools/setgfid2path/src/Makefile.am
index 45520cadafb..7316d117070 100644
--- a/tools/setgfid2path/src/Makefile.am
+++ b/tools/setgfid2path/src/Makefile.am
@@ -1,6 +1,8 @@
 gluster_setgfid2pathdir = $(sbindir)
 
+if WITH_SERVER
 gluster_setgfid2path_PROGRAMS = gluster-setgfid2path
+endif
 
 gluster_setgfid2path_SOURCES = main.c
 
diff --git a/tools/setgfid2path/src/main.c b/tools/setgfid2path/src/main.c
index 07d7a48b15d..4320a7b2481 100644
--- a/tools/setgfid2path/src/main.c
+++ b/tools/setgfid2path/src/main.c
@@ -10,119 +10,121 @@
 #include <stdio.h>
 #include <libgen.h>
 
-#include "common-utils.h"
-#include "syscall.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/syscall.h>
 
 #define MAX_GFID2PATH_LINK_SUP 500
 #define GFID_SIZE 16
 #define GFID_XATTR_KEY "trusted.gfid"
 
-
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int             ret                               = 0;
-        struct stat     st;
-        char           *dname                             = NULL;
-        char           *bname                             = NULL;
-        ssize_t         ret_size                          = 0;
-        uuid_t          pgfid_raw                         = {0,};
-        char            pgfid[36]                         = "";
-        char            xxh64[GF_XXH64_DIGEST_LENGTH*2+1] = {0,};
-        char            pgfid_bname[1024]                 = {0,};
-        char           *key                               = NULL;
-        char           *val                               = NULL;
-        size_t          key_size                          = 0;
-        size_t          val_size                          = 0;
-        const char     *file_path                         = NULL;
-        char           *file_path1                        = NULL;
-        char           *file_path2                        = NULL;
-
-        if (argc != 2) {
-                fprintf (stderr, "Usage: setgfid2path <file-path>\n");
-                return -1;
-        }
-
-        ret = sys_lstat (argv[1], &st);
-        if (ret != 0) {
-                fprintf (stderr, "Invalid File Path\n");
-                return -1;
-        }
-
-        if (st.st_nlink >= MAX_GFID2PATH_LINK_SUP) {
-                fprintf (stderr,
-                         "Number of Hardlink support exceeded. "
-                         "max=%d\n", MAX_GFID2PATH_LINK_SUP);
-                return -1;
+    int ret = 0;
+    struct stat st;
+    char *dname = NULL;
+    char *bname = NULL;
+    ssize_t ret_size = 0;
+    uuid_t pgfid_raw = {
+        0,
+    };
+    char pgfid[36 + 1] = "";
+    char xxh64[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    char pgfid_bname[1024] = {
+        0,
+    };
+    char *key = NULL;
+    char *val = NULL;
+    size_t key_size = 0;
+    size_t val_size = 0;
+    const char *file_path = NULL;
+    char *file_path1 = NULL;
+    char *file_path2 = NULL;
+
+    if (argc != 2) {
+        fprintf(stderr, "Usage: setgfid2path <file-path>\n");
+        return -1;
+    }
+
+    ret = sys_lstat(argv[1], &st);
+    if (ret != 0) {
+        fprintf(stderr, "Invalid File Path\n");
+        return -1;
+    }
+
+    if (st.st_nlink >= MAX_GFID2PATH_LINK_SUP) {
+        fprintf(stderr,
+                "Number of Hardlink support exceeded. "
+                "max=%d\n",
+                MAX_GFID2PATH_LINK_SUP);
+        return -1;
+    }
+
+    file_path = argv[1];
+    file_path1 = strdup(file_path);
+    file_path2 = strdup(file_path);
+
+    dname = dirname(file_path1);
+    bname = basename(file_path2);
+
+    /* Get GFID of Parent directory */
+    ret_size = sys_lgetxattr(dname, GFID_XATTR_KEY, pgfid_raw, GFID_SIZE);
+    if (ret_size != GFID_SIZE) {
+        fprintf(stderr, "Failed to get GFID of parent directory. dir=%s\n",
+                dname);
+        ret = -1;
+        goto out;
+    }
+
+    /* Convert to UUID format */
+    if (uuid_utoa_r(pgfid_raw, pgfid) == NULL) {
+        fprintf(stderr,
+                "Failed to format GFID of parent directory. "
+                "dir=%s GFID=%s\n",
+                dname, pgfid_raw);
+        ret = -1;
+        goto out;
+    }
+
+    /* Find xxhash for PGFID/BaseName */
+    snprintf(pgfid_bname, sizeof(pgfid_bname), "%s/%s", pgfid, bname);
+    gf_xxh64_wrapper((unsigned char *)pgfid_bname, strlen(pgfid_bname),
+                     GF_XXHSUM64_DEFAULT_SEED, xxh64);
+
+    key_size = SLEN(GFID2PATH_XATTR_KEY_PREFIX) + GF_XXH64_DIGEST_LENGTH * 2 +
+               1;
+    key = alloca(key_size);
+    snprintf(key, key_size, GFID2PATH_XATTR_KEY_PREFIX "%s", xxh64);
+
+    val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2;
+    val = alloca(val_size);
+    snprintf(val, val_size, "%s/%s", pgfid, bname);
+
+    /* Set the Xattr, ignore if same key xattr already exists */
+    ret = sys_lsetxattr(file_path, key, val, strlen(val), XATTR_CREATE);
+    if (ret == -1) {
+        if (errno == EEXIST) {
+            printf("Xattr already exists, ignoring..\n");
+            ret = 0;
+            goto out;
         }
 
-        file_path = argv[1];
-        file_path1 = strdup (file_path);
-        file_path2 = strdup (file_path);
-
-        dname = dirname (file_path1);
-        bname = basename (file_path2);
-
-        /* Get GFID of Parent directory */
-        ret_size = sys_lgetxattr (dname, GFID_XATTR_KEY, pgfid_raw, GFID_SIZE);
-        if (ret_size != GFID_SIZE) {
-                fprintf (stderr,
-                         "Failed to get GFID of parent directory. dir=%s\n",
-                         dname);
-                ret = -1;
-                goto out;
-        }
-
-        /* Convert to UUID format */
-        if (uuid_utoa_r (pgfid_raw, pgfid) == NULL) {
-                fprintf (stderr,
-                         "Failed to format GFID of parent directory. "
-                         "dir=%s GFID=%s\n", dname, pgfid_raw);
-                ret = -1;
-                goto out;
-        }
-
-        /* Find xxhash for PGFID/BaseName */
-        snprintf (pgfid_bname, sizeof (pgfid_bname), "%s/%s", pgfid, bname);
-        gf_xxh64_wrapper (
-                        (unsigned char *)pgfid_bname,
-                        strlen (pgfid_bname),
-                        GF_XXHSUM64_DEFAULT_SEED,
-                        xxh64
-                        );
-
-        key_size = strlen(GFID2PATH_XATTR_KEY_PREFIX) +
-                GF_XXH64_DIGEST_LENGTH*2+1;
-        key = alloca (key_size);
-        snprintf (key, key_size, GFID2PATH_XATTR_KEY_PREFIX"%s", xxh64);
-
-        val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2;
-        val = alloca (val_size);
-        snprintf (val, val_size, "%s/%s", pgfid, bname);
-
-        /* Set the Xattr, ignore if same key xattr already exists */
-        ret = sys_lsetxattr (file_path, key, val, strlen(val), XATTR_CREATE);
-        if (ret == -1) {
-                if (errno == EEXIST) {
-                        printf ("Xattr already exists, ignoring..\n");
-                        ret = 0;
-                        goto out;
-                }
-
-                fprintf (stderr,
-                         "Failed to set gfid2path xattr. errno=%d\n error=%s",
-                         errno, strerror(errno));
-                ret = -1;
-                goto out;
-        }
+        fprintf(stderr, "Failed to set gfid2path xattr. errno=%d\n error=%s",
+                errno, strerror(errno));
+        ret = -1;
+        goto out;
+    }
 
-        printf ("Success. file=%s key=%s value=%s\n", file_path, key, val);
+    printf("Success. file=%s key=%s value=%s\n", file_path, key, val);
 
 out:
-        if (file_path1 != NULL)
-                free (file_path1);
+    if (file_path1 != NULL)
+        free(file_path1);
 
-        if (file_path2 != NULL)
-                free (file_path2);
+    if (file_path2 != NULL)
+        free(file_path2);
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/Makefile.am b/xlators/Makefile.am
index 29549db724e..ef20cbb64fa 100644
--- a/xlators/Makefile.am
+++ b/xlators/Makefile.am
@@ -2,10 +2,10 @@ if BUILD_GNFS
   GNFS_DIR = nfs
 endif
 
-DIST_SUBDIRS = cluster storage protocol performance debug features encryption \
+DIST_SUBDIRS = cluster storage protocol performance debug features \
           mount nfs mgmt system playground meta
 
-SUBDIRS = cluster storage protocol performance debug features encryption \
+SUBDIRS = cluster storage protocol performance debug features \
           mount ${GNFS_DIR} mgmt system playground meta
 
 EXTRA_DIST = xlator.sym
diff --git a/xlators/cluster/Makefile.am b/xlators/cluster/Makefile.am
index 903fbb39f12..8e067d5ab58 100644
--- a/xlators/cluster/Makefile.am
+++ b/xlators/cluster/Makefile.am
@@ -1,3 +1,3 @@
-SUBDIRS = stripe afr dht ec
+SUBDIRS = afr dht ec
 
 CLEANFILES = 
diff --git a/xlators/cluster/afr/src/afr-common.c b/xlators/cluster/afr/src/afr-common.c
index 2925a1dc1da..032ab5c8001 100644
--- a/xlators/cluster/afr/src/afr-common.c
+++ b/xlators/cluster/afr/src/afr-common.c
@@ -15,25 +15,20 @@
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "afr.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
-#include "byte-order.h"
-#include "statedump.h"
-#include "inode.h"
-#include "events.h"
-#include "upcall-utils.h"
-#include "fd.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/hashfn.h>
+#include <glusterfs/list.h>
+#include <glusterfs/call-stub.h>
+#include <glusterfs/defaults.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/statedump.h>
+#include <glusterfs/events.h>
+#include <glusterfs/upcall-utils.h>
 
 #include "afr-inode-read.h"
 #include "afr-inode-write.h"
@@ -43,120 +38,798 @@
 #include "afr-self-heal.h"
 #include "afr-self-heald.h"
 #include "afr-messages.h"
-#include "compound-fop-utils.h"
 
 int32_t
-afr_quorum_errno (afr_private_t *priv)
+afr_quorum_errno(afr_private_t *priv)
 {
-        if (priv->quorum_reads)
-                return ENOTCONN;
-        return EROFS;
+    return ENOTCONN;
+}
+
+gf_boolean_t
+afr_is_private_directory(afr_private_t *priv, uuid_t pargfid, const char *name,
+                         pid_t pid)
+{
+    if (!__is_root_gfid(pargfid)) {
+        return _gf_false;
+    }
+
+    if (strcmp(name, GF_REPLICATE_TRASH_DIR) == 0) {
+        /*For backward compatibility /.landfill is private*/
+        return _gf_true;
+    }
+
+    if (pid == GF_CLIENT_PID_GSYNCD) {
+        /*geo-rep needs to create/sync private directory on slave because
+         * it appears in changelog*/
+        return _gf_false;
+    }
+
+    if (pid == GF_CLIENT_PID_GLFS_HEAL || pid == GF_CLIENT_PID_SELF_HEALD) {
+        if (strcmp(name, priv->anon_inode_name) == 0) {
+            /* anonymous-inode dir is private*/
+            return _gf_true;
+        }
+    } else {
+        if (strncmp(name, AFR_ANON_DIR_PREFIX, strlen(AFR_ANON_DIR_PREFIX)) ==
+            0) {
+            /* anonymous-inode dir prefix is private for geo-rep to work*/
+            return _gf_true;
+        }
+    }
+
+    return _gf_false;
+}
+
+void
+afr_fill_success_replies(afr_local_t *local, afr_private_t *priv,
+                         unsigned char *replies)
+{
+    int i = 0;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].op_ret == 0) {
+            replies[i] = 1;
+        } else {
+            replies[i] = 0;
+        }
+    }
 }
 
 int
-afr_fav_child_reset_sink_xattrs (void *opaque);
+afr_fav_child_reset_sink_xattrs(void *opaque);
 
 int
-afr_fav_child_reset_sink_xattrs_cbk (int ret, call_frame_t *frame,
-                                     void *opaque);
+afr_fav_child_reset_sink_xattrs_cbk(int ret, call_frame_t *frame, void *opaque);
 
 static void
-afr_discover_done (call_frame_t *frame, xlator_t *this);
+afr_discover_done(call_frame_t *frame, xlator_t *this);
 
-gf_boolean_t
-afr_is_consistent_io_possible (afr_local_t *local, afr_private_t *priv,
-                               int32_t *op_errno)
+int
+afr_dom_lock_acquire_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        if (priv->consistent_io && local->call_count != priv->child_count) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0,
-                        AFR_MSG_SUBVOLS_DOWN, "All subvolumes are not up");
-                if (op_errno)
-                        *op_errno = ENOTCONN;
-                return _gf_false;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    int i = (long)cookie;
+
+    local->cont.lk.dom_lock_op_ret[i] = op_ret;
+    local->cont.lk.dom_lock_op_errno[i] = op_errno;
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_LK_HEAL_DOM,
+               "%s: Failed to acquire %s on %s",
+               uuid_utoa(local->fd->inode->gfid), AFR_LK_HEAL_DOM,
+               priv->children[i]->name);
+    } else {
+        local->cont.lk.dom_locked_nodes[i] = 1;
+    }
+
+    syncbarrier_wake(&local->barrier);
+
+    return 0;
+}
+
+int
+afr_dom_lock_acquire(call_frame_t *frame)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0;
+
+    priv = frame->this->private;
+    local = frame->local;
+    local->cont.lk.dom_locked_nodes = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lk.locked_nodes),
+        gf_afr_mt_char);
+    if (!local->cont.lk.dom_locked_nodes) {
+        return -ENOMEM;
+    }
+    local->cont.lk.dom_lock_op_ret = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lk.dom_lock_op_ret),
+        gf_afr_mt_int32_t);
+    if (!local->cont.lk.dom_lock_op_ret) {
+        return -ENOMEM; /* CALLOC'd members are freed in afr_local_cleanup. */
+    }
+    local->cont.lk.dom_lock_op_errno = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lk.dom_lock_op_errno),
+        gf_afr_mt_int32_t);
+    if (!local->cont.lk.dom_lock_op_errno) {
+        return -ENOMEM; /* CALLOC'd members are freed in afr_local_cleanup. */
+    }
+    flock.l_type = F_WRLCK;
+
+    AFR_ONALL(frame, afr_dom_lock_acquire_cbk, finodelk, AFR_LK_HEAL_DOM,
+              local->fd, F_SETLK, &flock, NULL);
+
+    if (!afr_has_quorum(local->cont.lk.dom_locked_nodes, frame->this, NULL))
+        goto blocking_lock;
+
+    /*If any of the bricks returned EAGAIN, we still need blocking locks.*/
+    if (AFR_COUNT(local->cont.lk.dom_locked_nodes, priv->child_count) !=
+        priv->child_count) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->cont.lk.dom_lock_op_ret[i] == -1 &&
+                local->cont.lk.dom_lock_op_errno[i] == EAGAIN)
+                goto blocking_lock;
         }
-        return _gf_true;
+    }
+
+    return 0;
+
+blocking_lock:
+    afr_dom_lock_release(frame);
+    AFR_ONALL(frame, afr_dom_lock_acquire_cbk, finodelk, AFR_LK_HEAL_DOM,
+              local->fd, F_SETLKW, &flock, NULL);
+    if (!afr_has_quorum(local->cont.lk.dom_locked_nodes, frame->this, NULL)) {
+        afr_dom_lock_release(frame);
+        return -afr_quorum_errno(priv);
+    }
+
+    return 0;
 }
 
-call_frame_t *
-afr_copy_frame (call_frame_t *base)
+int
+afr_dom_lock_release_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-	call_frame_t *frame = NULL;
-	int op_errno = 0;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    int i = (long)cookie;
+
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_LK_HEAL_DOM,
+               "%s: Failed to release %s on %s", local->loc.path,
+               AFR_LK_HEAL_DOM, priv->children[i]->name);
+    }
+    local->cont.lk.dom_locked_nodes[i] = 0;
 
-	frame = copy_frame (base);
-	if (!frame)
-		return NULL;
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local) {
-		AFR_STACK_DESTROY (frame);
-		return NULL;
-	}
+    syncbarrier_wake(&local->barrier);
 
-	return frame;
+    return 0;
 }
 
-/* Check if an entry or inode could be undergoing a transaction. */
-gf_boolean_t
-afr_is_possibly_under_txn (afr_transaction_type type, afr_local_t *local,
-                           xlator_t *this)
+void
+afr_dom_lock_release(call_frame_t *frame)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+
+    local = frame->local;
+    priv = frame->this->private;
+    locked_on = local->cont.lk.dom_locked_nodes;
+    if (AFR_COUNT(locked_on, priv->child_count) == 0)
+        return;
+    flock.l_type = F_UNLCK;
+
+    AFR_ONLIST(locked_on, frame, afr_dom_lock_release_cbk, finodelk,
+               AFR_LK_HEAL_DOM, local->fd, F_SETLK, &flock, NULL);
+
+    return;
+}
+
+static void
+afr_lk_heal_info_cleanup(afr_lk_heal_info_t *info)
+{
+    if (!info)
+        return;
+    if (info->xdata_req)
+        dict_unref(info->xdata_req);
+    if (info->fd)
+        fd_unref(info->fd);
+    GF_FREE(info->locked_nodes);
+    GF_FREE(info->child_up_event_gen);
+    GF_FREE(info->child_down_event_gen);
+    GF_FREE(info);
+}
+
+static int
+afr_add_lock_to_saved_locks(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
+    afr_lk_heal_info_t *info = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int ret = -ENOMEM;
+
+    info = GF_CALLOC(sizeof(*info), 1, gf_afr_mt_lk_heal_info_t);
+    if (!info) {
+        goto cleanup;
+    }
+    INIT_LIST_HEAD(&info->pos);
+    info->fd = fd_ref(local->fd);
+    info->cmd = local->cont.lk.cmd;
+    info->pid = frame->root->pid;
+    info->flock = local->cont.lk.user_flock;
+    info->xdata_req = dict_copy_with_ref(local->xdata_req, NULL);
+    if (!info->xdata_req) {
+        goto cleanup;
+    }
+    info->lk_owner = frame->root->lk_owner;
+    info->locked_nodes = GF_MALLOC(
+        sizeof(*info->locked_nodes) * priv->child_count, gf_afr_mt_char);
+    if (!info->locked_nodes) {
+        goto cleanup;
+    }
+    memcpy(info->locked_nodes, local->cont.lk.locked_nodes,
+           sizeof(*info->locked_nodes) * priv->child_count);
+    info->child_up_event_gen = GF_CALLOC(sizeof(*info->child_up_event_gen),
+                                         priv->child_count, gf_afr_mt_int32_t);
+    if (!info->child_up_event_gen) {
+        goto cleanup;
+    }
+    info->child_down_event_gen = GF_CALLOC(sizeof(*info->child_down_event_gen),
+                                           priv->child_count,
+                                           gf_afr_mt_int32_t);
+    if (!info->child_down_event_gen) {
+        goto cleanup;
+    }
+
+    LOCK(&local->fd->lock);
+    {
+        fd_ctx = __afr_fd_ctx_get(local->fd, this);
+        if (fd_ctx)
+            fd_ctx->lk_heal_info = info;
+    }
+    UNLOCK(&local->fd->lock);
+    if (!fd_ctx) {
+        goto cleanup;
+    }
+
+    LOCK(&priv->lock);
+    {
+        list_add_tail(&info->pos, &priv->saved_locks);
+    }
+    UNLOCK(&priv->lock);
+
+    return 0;
+cleanup:
+    gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_LK_HEAL_DOM,
+           "%s: Failed to add lock to healq",
+           uuid_utoa(local->fd->inode->gfid));
+    if (info) {
+        afr_lk_heal_info_cleanup(info);
+        if (fd_ctx) {
+            LOCK(&local->fd->lock);
+            {
+                fd_ctx->lk_heal_info = NULL;
+            }
+            UNLOCK(&local->fd->lock);
+        }
+    }
+    return ret;
+}
+
+static int
+afr_remove_lock_from_saved_locks(afr_local_t *local, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    struct gf_flock flock = local->cont.lk.user_flock;
+    afr_lk_heal_info_t *info = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int ret = -EINVAL;
+
+    fd_ctx = afr_fd_ctx_get(local->fd, this);
+    if (!fd_ctx || !fd_ctx->lk_heal_info) {
+        goto out;
+    }
+
+    info = fd_ctx->lk_heal_info;
+    if ((info->flock.l_start != flock.l_start) ||
+        (info->flock.l_whence != flock.l_whence) ||
+        (info->flock.l_len != flock.l_len)) {
+        /*TODO: Compare lkowners too.*/
+        goto out;
+    }
+
+    LOCK(&priv->lock);
+    {
+        list_del(&fd_ctx->lk_heal_info->pos);
+    }
+    UNLOCK(&priv->lock);
+
+    afr_lk_heal_info_cleanup(info);
+    fd_ctx->lk_heal_info = NULL;
+    ret = 0;
+out:
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_LK_HEAL_DOM,
+               "%s: Failed to remove lock from healq",
+               uuid_utoa(local->fd->inode->gfid));
+    return ret;
+}
+
+int
+afr_lock_heal_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                  dict_t *xdata)
 {
-        int i = 0;
-        int tmp = 0;
-	afr_private_t *priv = NULL;
-        GF_UNUSED char *key = NULL;
+    afr_local_t *local = frame->local;
+    int i = (long)cookie;
 
-        priv = this->private;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (op_ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_LK_HEAL_DOM,
+               "Failed to heal lock on child %d for %s", i,
+               uuid_utoa(local->fd->inode->gfid));
+    }
+    syncbarrier_wake(&local->barrier);
+    return 0;
+}
 
-        if (type == AFR_ENTRY_TRANSACTION)
-                key = GLUSTERFS_PARENT_ENTRYLK;
-        else if (type == AFR_DATA_TRANSACTION)
-                /*FIXME: Use GLUSTERFS_INODELK_DOM_COUNT etc. once
-                 * pl_inodelk_xattr_fill supports separate keys for different
-                 * domains.*/
-                key = GLUSTERFS_INODELK_COUNT;
+int
+afr_getlk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
+{
+    afr_local_t *local = frame->local;
+    int i = (long)cookie;
+
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (op_ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_LK_HEAL_DOM,
+               "Failed getlk for %s", uuid_utoa(local->fd->inode->gfid));
+    } else {
+        local->cont.lk.getlk_rsp[i] = *lock;
+    }
+
+    syncbarrier_wake(&local->barrier);
+    return 0;
+}
+
+static gf_boolean_t
+afr_does_lk_owner_match(call_frame_t *frame, afr_private_t *priv,
+                        afr_lk_heal_info_t *info)
+{
+    int i = 0;
+    afr_local_t *local = frame->local;
+    struct gf_flock flock = {
+        0,
+    };
+    gf_boolean_t ret = _gf_true;
+    char *wind_on = alloca0(priv->child_count);
+    unsigned char *success_replies = alloca0(priv->child_count);
+    local->cont.lk.getlk_rsp = GF_CALLOC(sizeof(*local->cont.lk.getlk_rsp),
+                                         priv->child_count, gf_afr_mt_gf_lock);
+
+    flock = info->flock;
+    for (i = 0; i < priv->child_count; i++) {
+        if (info->locked_nodes[i])
+            wind_on[i] = 1;
+    }
+
+    AFR_ONLIST(wind_on, frame, afr_getlk_cbk, lk, info->fd, F_GETLK, &flock,
+               info->xdata_req);
+
+    afr_fill_success_replies(local, priv, success_replies);
+    if (AFR_COUNT(success_replies, priv->child_count) == 0) {
+        ret = _gf_false;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid || local->replies[i].op_ret != 0)
+            continue;
+        if (local->cont.lk.getlk_rsp[i].l_type == F_UNLCK)
+            continue;
+        /*TODO: Do we really need to compare lkowner if F_UNLCK is true?*/
+        if (!is_same_lkowner(&local->cont.lk.getlk_rsp[i].l_owner,
+                             &info->lk_owner)) {
+            ret = _gf_false;
+            break;
+        }
+    }
+out:
+    afr_local_replies_wipe(local, priv);
+    GF_FREE(local->cont.lk.getlk_rsp);
+    local->cont.lk.getlk_rsp = NULL;
+    return ret;
+}
+
+static void
+afr_mark_fd_bad(fd_t *fd, xlator_t *this)
+{
+    afr_fd_ctx_t *fd_ctx = NULL;
 
+    if (!fd)
+        return;
+    LOCK(&fd->lock);
+    {
+        fd_ctx = __afr_fd_ctx_get(fd, this);
+        if (fd_ctx) {
+            fd_ctx->is_fd_bad = _gf_true;
+            fd_ctx->lk_heal_info = NULL;
+        }
+    }
+    UNLOCK(&fd->lock);
+}
+
+static void
+afr_add_lock_to_lkhealq(afr_private_t *priv, afr_lk_heal_info_t *info)
+{
+    LOCK(&priv->lock);
+    {
+        list_del(&info->pos);
+        list_add_tail(&info->pos, &priv->lk_healq);
+    }
+    UNLOCK(&priv->lock);
+}
+
+static void
+afr_lock_heal_do(call_frame_t *frame, afr_private_t *priv,
+                 afr_lk_heal_info_t *info)
+{
+    int i = 0;
+    int op_errno = 0;
+    int32_t *current_event_gen = NULL;
+    afr_local_t *local = frame->local;
+    xlator_t *this = frame->this;
+    char *wind_on = alloca0(priv->child_count);
+    gf_boolean_t retry = _gf_true;
+
+    frame->root->pid = info->pid;
+    lk_owner_copy(&frame->root->lk_owner, &info->lk_owner);
+
+    op_errno = -afr_dom_lock_acquire(frame);
+    if ((op_errno != 0)) {
+        goto release;
+    }
+
+    if (!afr_does_lk_owner_match(frame, priv, info)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_LK_HEAL_DOM,
+               "Ignoring lock heal for %s since lk-onwers mismatch. "
+               "Lock possibly pre-empted by another client.",
+               uuid_utoa(info->fd->inode->gfid));
+        goto release;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (info->locked_nodes[i])
+            continue;
+        wind_on[i] = 1;
+    }
+
+    current_event_gen = alloca(priv->child_count);
+    memcpy(current_event_gen, info->child_up_event_gen,
+           priv->child_count * sizeof *current_event_gen);
+    AFR_ONLIST(wind_on, frame, afr_lock_heal_cbk, lk, info->fd, info->cmd,
+               &info->flock, info->xdata_req);
+
+    LOCK(&priv->lock);
+    {
         for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].xdata)
-			continue;
-		if (dict_get_int32 (local->replies[i].xdata, key, &tmp) == 0)
-			if (tmp)
-				return _gf_true;
-	}
+            if (!wind_on[i])
+                continue;
+            if ((!local->replies[i].valid) || (local->replies[i].op_ret != 0)) {
+                continue;
+            }
 
-        return _gf_false;
+            if ((current_event_gen[i] == info->child_up_event_gen[i]) &&
+                (current_event_gen[i] > info->child_down_event_gen[i])) {
+                info->locked_nodes[i] = 1;
+                retry = _gf_false;
+                list_del_init(&info->pos);
+                list_add_tail(&info->pos, &priv->saved_locks);
+            } else {
+                /*We received subsequent child up/down events while heal was in
+                 * progress; don't mark child as healed. Attempt again on the
+                 * new child up*/
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_LK_HEAL_DOM,
+                       "Event gen mismatch: skipped healing lock on child %d "
+                       "for %s.",
+                       i, uuid_utoa(info->fd->inode->gfid));
+            }
+        }
+    }
+    UNLOCK(&priv->lock);
+
+release:
+    afr_dom_lock_release(frame);
+    if (retry)
+        afr_add_lock_to_lkhealq(priv, info);
+    return;
 }
 
-int
-__afr_inode_ctx_get (xlator_t *this, inode_t *inode, afr_inode_ctx_t **ctx)
+static int
+afr_lock_heal_done(int ret, call_frame_t *frame, void *opaque)
 {
-        uint64_t                ctx_int = 0;
-        int                     ret     = -1;
-        afr_inode_ctx_t        *tmp_ctx = NULL;
+    STACK_DESTROY(frame->root);
+    return 0;
+}
 
-        ret = __inode_ctx_get (inode, this, &ctx_int);
-        if (ret) {
-                tmp_ctx = GF_CALLOC (1, sizeof (afr_inode_ctx_t),
-                                     gf_afr_mt_inode_ctx_t);
-                if (!tmp_ctx)
-                        goto out;
-
-                ctx_int = (long) tmp_ctx;
-                ret = __inode_ctx_set (inode, this, &ctx_int);
-                if (ret) {
-                        GF_FREE (tmp_ctx);
-                        goto out;
-                }
-                tmp_ctx->spb_choice = -1;
-                tmp_ctx->read_subvol = 0;
-        } else {
-                tmp_ctx = (afr_inode_ctx_t *) ctx_int;
+static int
+afr_lock_heal(void *opaque)
+{
+    call_frame_t *frame = (call_frame_t *)opaque;
+    call_frame_t *iter_frame = NULL;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
+    afr_lk_heal_info_t *info = NULL;
+    afr_lk_heal_info_t *tmp = NULL;
+    struct list_head healq = {
+        0,
+    };
+    int ret = 0;
+
+    iter_frame = afr_copy_frame(frame);
+    if (!iter_frame) {
+        return ENOMEM;
+    }
+
+    INIT_LIST_HEAD(&healq);
+    LOCK(&priv->lock);
+    {
+        list_splice_init(&priv->lk_healq, &healq);
+    }
+    UNLOCK(&priv->lock);
+
+    list_for_each_entry_safe(info, tmp, &healq, pos)
+    {
+        GF_ASSERT((AFR_COUNT(info->locked_nodes, priv->child_count) <
+                   priv->child_count));
+        ((afr_local_t *)(iter_frame->local))->fd = fd_ref(info->fd);
+        afr_lock_heal_do(iter_frame, priv, info);
+        AFR_STACK_RESET(iter_frame);
+        if (iter_frame->local == NULL) {
+            ret = ENOTCONN;
+            gf_msg(frame->this->name, GF_LOG_ERROR, ENOTCONN,
+                   AFR_MSG_LK_HEAL_DOM,
+                   "Aborting processing of lk_healq."
+                   "Healing will be reattempted on next child up for locks "
+                   "that are still in quorum.");
+            LOCK(&priv->lock);
+            {
+                list_add_tail(&healq, &priv->lk_healq);
+            }
+            UNLOCK(&priv->lock);
+            break;
         }
+    }
 
-        *ctx = tmp_ctx;
-        ret = 0;
+    AFR_STACK_DESTROY(iter_frame);
+    return ret;
+}
+
+static int
+__afr_lock_heal_synctask(xlator_t *this, afr_private_t *priv, int child)
+{
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    afr_lk_heal_info_t *info = NULL;
+    afr_lk_heal_info_t *tmp = NULL;
+
+    if (priv->shd.iamshd)
+        return 0;
+
+    list_for_each_entry_safe(info, tmp, &priv->saved_locks, pos)
+    {
+        info->child_up_event_gen[child] = priv->event_generation;
+        list_del_init(&info->pos);
+        list_add_tail(&info->pos, &priv->lk_healq);
+    }
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        return -1;
+
+    ret = synctask_new(this->ctx->env, afr_lock_heal, afr_lock_heal_done, frame,
+                       frame);
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_LK_HEAL_DOM,
+               "Failed to launch lock heal synctask");
+
+    return ret;
+}
+
+static int
+__afr_mark_pending_lk_heal(xlator_t *this, afr_private_t *priv, int child)
+{
+    afr_lk_heal_info_t *info = NULL;
+    afr_lk_heal_info_t *tmp = NULL;
+
+    if (priv->shd.iamshd)
+        return 0;
+    list_for_each_entry_safe(info, tmp, &priv->saved_locks, pos)
+    {
+        info->child_down_event_gen[child] = priv->event_generation;
+        if (info->locked_nodes[child] == 1)
+            info->locked_nodes[child] = 0;
+        if (!afr_has_quorum(info->locked_nodes, this, NULL)) {
+            /* Since the lock was lost on quorum no. of nodes, we should
+             * not attempt to heal it anymore. Some other client could have
+             * acquired the lock, modified data and released it and this
+             * client wouldn't know about it if we heal it.*/
+            afr_mark_fd_bad(info->fd, this);
+            list_del(&info->pos);
+            afr_lk_heal_info_cleanup(info);
+            /* We're not winding an unlock on the node where the lock is still
+             * present because when fencing logic switches over to the new
+             * client (since we marked the fd bad), it should preempt any
+             * existing lock. */
+        }
+    }
+    return 0;
+}
+
+gf_boolean_t
+afr_is_consistent_io_possible(afr_local_t *local, afr_private_t *priv,
+                              int32_t *op_errno)
+{
+    if (priv->consistent_io && local->call_count != priv->child_count) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOLS_DOWN,
+               "All subvolumes are not up");
+        if (op_errno)
+            *op_errno = ENOTCONN;
+        return _gf_false;
+    }
+    return _gf_true;
+}
+
+gf_boolean_t
+afr_is_lock_mode_mandatory(dict_t *xdata)
+{
+    int ret = 0;
+    uint32_t lk_mode = GF_LK_ADVISORY;
+
+    ret = dict_get_uint32(xdata, GF_LOCK_MODE, &lk_mode);
+    if (!ret && lk_mode == GF_LK_MANDATORY)
+        return _gf_true;
+
+    return _gf_false;
+}
+
+call_frame_t *
+afr_copy_frame(call_frame_t *base)
+{
+    afr_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    int op_errno = 0;
+
+    frame = copy_frame(base);
+    if (!frame)
+        return NULL;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local) {
+        AFR_STACK_DESTROY(frame);
+        return NULL;
+    }
+
+    return frame;
+}
+
+/* Check if an entry or inode could be undergoing a transaction. */
+gf_boolean_t
+afr_is_possibly_under_txn(afr_transaction_type type, afr_local_t *local,
+                          xlator_t *this)
+{
+    int i = 0;
+    int tmp = 0;
+    afr_private_t *priv = NULL;
+    GF_UNUSED char *key = NULL;
+    int keylen = 0;
+
+    priv = this->private;
+
+    if (type == AFR_ENTRY_TRANSACTION) {
+        key = GLUSTERFS_PARENT_ENTRYLK;
+        keylen = SLEN(GLUSTERFS_PARENT_ENTRYLK);
+    } else if (type == AFR_DATA_TRANSACTION) {
+        /*FIXME: Use GLUSTERFS_INODELK_DOM_COUNT etc. once
+         * pl_inodelk_xattr_fill supports separate keys for different
+         * domains.*/
+        key = GLUSTERFS_INODELK_COUNT;
+        keylen = SLEN(GLUSTERFS_INODELK_COUNT);
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].xdata)
+            continue;
+        if (dict_get_int32n(local->replies[i].xdata, key, keylen, &tmp) == 0)
+            if (tmp)
+                return _gf_true;
+    }
+
+    return _gf_false;
+}
+
+static void
+afr_inode_ctx_destroy(afr_inode_ctx_t *ctx)
+{
+    int i = 0;
+
+    if (!ctx)
+        return;
+
+    for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+        GF_FREE(ctx->pre_op_done[i]);
+    }
+
+    GF_FREE(ctx);
+}
+
+int
+__afr_inode_ctx_get(xlator_t *this, inode_t *inode, afr_inode_ctx_t **ctx)
+{
+    uint64_t ctx_int = 0;
+    int ret = -1;
+    int i = -1;
+    int num_locks = -1;
+    afr_inode_ctx_t *ictx = NULL;
+    afr_lock_t *lock = NULL;
+    afr_private_t *priv = this->private;
+
+    ret = __inode_ctx_get(inode, this, &ctx_int);
+    if (ret == 0) {
+        *ctx = (afr_inode_ctx_t *)(uintptr_t)ctx_int;
+        return 0;
+    }
+
+    ictx = GF_CALLOC(1, sizeof(afr_inode_ctx_t), gf_afr_mt_inode_ctx_t);
+    if (!ictx)
+        goto out;
+
+    for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+        ictx->pre_op_done[i] = GF_CALLOC(sizeof *ictx->pre_op_done[i],
+                                         priv->child_count, gf_afr_mt_int32_t);
+        if (!ictx->pre_op_done[i]) {
+            ret = -ENOMEM;
+            goto out;
+        }
+    }
+
+    num_locks = sizeof(ictx->lock) / sizeof(afr_lock_t);
+    for (i = 0; i < num_locks; i++) {
+        lock = &ictx->lock[i];
+        INIT_LIST_HEAD(&lock->post_op);
+        INIT_LIST_HEAD(&lock->frozen);
+        INIT_LIST_HEAD(&lock->waiting);
+        INIT_LIST_HEAD(&lock->owners);
+    }
+
+    ctx_int = (uint64_t)(uintptr_t)ictx;
+    ret = __inode_ctx_set(inode, this, &ctx_int);
+    if (ret) {
+        goto out;
+    }
+
+    ictx->spb_choice = -1;
+    ictx->read_subvol = 0;
+    ictx->write_subvol = 0;
+    ictx->lock_count = 0;
+    ret = 0;
+    *ctx = ictx;
 out:
-        return ret;
+    if (ret) {
+        afr_inode_ctx_destroy(ictx);
+    }
+    return ret;
 }
 
 /*
@@ -190,1588 +863,1681 @@ out:
  */
 
 int
-__afr_set_in_flight_sb_status (xlator_t *this, afr_local_t *local,
-                               inode_t *inode)
-{
-        int                 i               = 0;
-        int                 ret             = -1;
-        int                 txn_type        = 0;
-        int                 count           = 0;
-        int                 index           = -1;
-        uint16_t            datamap_old     = 0;
-        uint16_t            metadatamap_old = 0;
-        uint16_t            datamap         = 0;
-        uint16_t            metadatamap     = 0;
-        uint16_t            tmp_map         = 0;
-        uint16_t            mask            = 0;
-        uint32_t            event           = 0;
-        uint64_t            val             = 0;
-        afr_private_t      *priv            = NULL;
-        afr_inode_ctx_t    *ctx             = NULL;
-
-        priv = this->private;
-        txn_type = local->transaction.type;
-
-        ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret < 0)
-                return ret;
-
-        val = ctx->read_subvol;
-
-        metadatamap_old = metadatamap = (val & 0x000000000000ffff);
-        datamap_old = datamap = (val & 0x00000000ffff0000) >> 16;
-        event = (val & 0xffffffff00000000) >> 32;
-
-        if (txn_type == AFR_DATA_TRANSACTION)
-                tmp_map = datamap;
-        else if (txn_type == AFR_METADATA_TRANSACTION)
-                tmp_map = metadatamap;
-
-        count = gf_bits_count (tmp_map);
-
-        if (count == 1)
-                index = gf_bits_index (tmp_map);
-
-        for (i = 0; i < priv->child_count; i++) {
-                mask = 0;
-                if (!local->transaction.failed_subvols[i])
-                        continue;
-
-                mask = 1 << i;
-                if (txn_type == AFR_METADATA_TRANSACTION)
-                        metadatamap &= ~mask;
-                else if (txn_type == AFR_DATA_TRANSACTION)
-                        datamap &= ~mask;
-        }
-
-        switch (txn_type) {
+__afr_set_in_flight_sb_status(xlator_t *this, afr_local_t *local,
+                              inode_t *inode)
+{
+    int i = 0;
+    int txn_type = 0;
+    int count = 0;
+    int index = -1;
+    uint16_t datamap_old = 0;
+    uint16_t metadatamap_old = 0;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint16_t tmp_map = 0;
+    uint16_t mask = 0;
+    uint32_t event = 0;
+    uint64_t val = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    txn_type = local->transaction.type;
+
+    if (txn_type == AFR_DATA_TRANSACTION)
+        val = local->inode_ctx->write_subvol;
+    else
+        val = local->inode_ctx->read_subvol;
+
+    metadatamap_old = metadatamap = (val & 0x000000000000ffff);
+    datamap_old = datamap = (val & 0x00000000ffff0000) >> 16;
+    event = (val & 0xffffffff00000000) >> 32;
+
+    if (txn_type == AFR_DATA_TRANSACTION)
+        tmp_map = datamap;
+    else if (txn_type == AFR_METADATA_TRANSACTION)
+        tmp_map = metadatamap;
+
+    count = gf_bits_count(tmp_map);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.failed_subvols[i])
+            continue;
+
+        mask = 1 << i;
+        if (txn_type == AFR_METADATA_TRANSACTION)
+            metadatamap &= ~mask;
+        else if (txn_type == AFR_DATA_TRANSACTION)
+            datamap &= ~mask;
+    }
+
+    switch (txn_type) {
         case AFR_METADATA_TRANSACTION:
-                if ((metadatamap_old != 0) && (metadatamap == 0) &&
-                    (count == 1)) {
-                        local->transaction.in_flight_sb_errno =
-                                                local->replies[index].op_errno;
-                        local->transaction.in_flight_sb = _gf_true;
-                        metadatamap |= (1 << index);
-                }
-                if (metadatamap_old != metadatamap)
-                        event = 0;
-                break;
+            if ((metadatamap_old != 0) && (metadatamap == 0) && (count == 1)) {
+                index = gf_bits_index(tmp_map);
+                local->transaction.in_flight_sb_errno = local->replies[index]
+                                                            .op_errno;
+                local->transaction.in_flight_sb = _gf_true;
+                metadatamap |= (1 << index);
+            }
+            if (metadatamap_old != metadatamap) {
+                __afr_inode_need_refresh_set(inode, this);
+            }
+            break;
 
         case AFR_DATA_TRANSACTION:
-                if ((datamap_old != 0) && (datamap == 0) && (count == 1)) {
-                        local->transaction.in_flight_sb_errno =
-                                                local->replies[index].op_errno;
-                        local->transaction.in_flight_sb = _gf_true;
-                        datamap |= (1 << index);
-                }
-                if (datamap_old != datamap)
-                        event = 0;
-                break;
+            if ((datamap_old != 0) && (datamap == 0) && (count == 1)) {
+                index = gf_bits_index(tmp_map);
+                local->transaction.in_flight_sb_errno = local->replies[index]
+                                                            .op_errno;
+                local->transaction.in_flight_sb = _gf_true;
+                datamap |= (1 << index);
+            }
+            if (datamap_old != datamap)
+                __afr_inode_need_refresh_set(inode, this);
+            break;
 
         default:
-                break;
-        }
+            break;
+    }
 
-        val = ((uint64_t) metadatamap) |
-                (((uint64_t) datamap) << 16) |
-                (((uint64_t) event) << 32);
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
 
-        ctx->read_subvol = val;
+    if (txn_type == AFR_DATA_TRANSACTION)
+        local->inode_ctx->write_subvol = val;
+    local->inode_ctx->read_subvol = val;
 
-        return ret;
+    return 0;
 }
 
-int
-afr_set_in_flight_sb_status (xlator_t *this, afr_local_t *local, inode_t *inode)
+gf_boolean_t
+afr_is_symmetric_error(call_frame_t *frame, xlator_t *this)
 {
-        int            ret  = -1;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int op_errno = 0;
+    int i_errno = 0;
+    gf_boolean_t matching_errors = _gf_true;
+    int i = 0;
 
-        priv = this->private;
+    priv = this->private;
+    local = frame->local;
 
-        /* If this transaction saw no failures, then exit. */
-        if (AFR_COUNT (local->transaction.failed_subvols,
-                       priv->child_count) == 0)
-                return 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret != -1) {
+            /* Operation succeeded on at least one subvol,
+               so it is not a failed-everywhere situation.
+            */
+            matching_errors = _gf_false;
+            break;
+        }
+        i_errno = local->replies[i].op_errno;
 
-        LOCK (&inode->lock);
-        {
-                ret = __afr_set_in_flight_sb_status (this, local, inode);
+        if (i_errno == ENOTCONN) {
+            /* ENOTCONN is not a symmetric error. We do not
+               know if the operation was performed on the
+               backend or not.
+            */
+            matching_errors = _gf_false;
+            break;
         }
-        UNLOCK (&inode->lock);
 
-        return ret;
+        if (!op_errno) {
+            op_errno = i_errno;
+        } else if (op_errno != i_errno) {
+            /* Mismatching op_errno's */
+            matching_errors = _gf_false;
+            break;
+        }
+    }
+
+    return matching_errors;
 }
 
 int
-__afr_inode_read_subvol_get_small (inode_t *inode, xlator_t *this,
-				   unsigned char *data, unsigned char *metadata,
-				   int *event_p)
+afr_set_in_flight_sb_status(xlator_t *this, call_frame_t *frame, inode_t *inode)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	uint16_t datamap = 0;
-	uint16_t metadatamap = 0;
-	uint32_t event = 0;
-	uint64_t val = 0;
-	int i = 0;
-        afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-	priv = this->private;
+    priv = this->private;
+    local = frame->local;
 
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-	if (ret < 0)
-		return ret;
-
-        val = ctx->read_subvol;
+    /* If this transaction saw no failures, then exit. */
+    if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count) == 0)
+        return 0;
 
-	metadatamap = (val & 0x000000000000ffff);
-	datamap =     (val & 0x00000000ffff0000) >> 16;
-	event =       (val & 0xffffffff00000000) >> 32;
+    if (afr_is_symmetric_error(frame, this))
+        return 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (metadata)
-			metadata[i] = (metadatamap >> i) & 1;
-		if (data)
-			data[i] = (datamap >> i) & 1;
-	}
+    LOCK(&inode->lock);
+    {
+        ret = __afr_set_in_flight_sb_status(this, local, inode);
+    }
+    UNLOCK(&inode->lock);
 
-	if (event_p)
-		*event_p = event;
-	return ret;
+    return ret;
 }
 
-
 int
-__afr_inode_read_subvol_set_small (inode_t *inode, xlator_t *this,
-				   unsigned char *data, unsigned char *metadata,
-				   int event)
-{
-	afr_private_t *priv = NULL;
-	uint16_t datamap = 0;
-	uint16_t metadatamap = 0;
-	uint64_t val = 0;
-	int i = 0;
-        int ret = -1;
-        afr_inode_ctx_t *ctx = NULL;
-
-	priv = this->private;
-
-        ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                goto out;
+__afr_inode_read_subvol_get_small(inode_t *inode, xlator_t *this,
+                                  unsigned char *data, unsigned char *metadata,
+                                  int *event_p)
+{
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint32_t event = 0;
+    uint64_t val = 0;
+    int i = 0;
+    afr_inode_ctx_t *ctx = NULL;
+
+    priv = this->private;
+
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret < 0)
+        return ret;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (data[i])
-			datamap |= (1 << i);
-		if (metadata[i])
-			metadatamap |= (1 << i);
-	}
+    val = ctx->read_subvol;
 
-	val = ((uint64_t) metadatamap) |
-		(((uint64_t) datamap) << 16) |
-		(((uint64_t) event) << 32);
+    metadatamap = (val & 0x000000000000ffff);
+    datamap = (val & 0x00000000ffff0000) >> 16;
+    event = (val & 0xffffffff00000000) >> 32;
 
-        ctx->read_subvol = val;
+    for (i = 0; i < priv->child_count; i++) {
+        if (metadata)
+            metadata[i] = (metadatamap >> i) & 1;
+        if (data)
+            data[i] = (datamap >> i) & 1;
+    }
 
-        ret = 0;
-out:
-        return ret;
+    if (event_p)
+        *event_p = event;
+    return ret;
 }
 
 int
-__afr_inode_event_gen_reset_small (inode_t *inode, xlator_t *this)
+__afr_inode_read_subvol_set_small(inode_t *inode, xlator_t *this,
+                                  unsigned char *data, unsigned char *metadata,
+                                  int event)
 {
-	int               ret         = -1;
-	uint16_t          datamap     = 0;
-	uint16_t          metadatamap = 0;
-	uint32_t          event       = 0;
-	uint64_t          val         = 0;
-        afr_inode_ctx_t  *ctx         = NULL;
+    afr_private_t *priv = NULL;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint64_t val = 0;
+    int i = 0;
+    int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
 
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                return ret;
+    priv = this->private;
 
-        val = ctx->read_subvol;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret)
+        goto out;
 
-	metadatamap = (val & 0x000000000000ffff) >> 0;
-	datamap =     (val & 0x00000000ffff0000) >> 16;
-	event = 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (data[i])
+            datamap |= (1 << i);
+        if (metadata[i])
+            metadatamap |= (1 << i);
+    }
 
-	val = ((uint64_t) metadatamap) |
-		(((uint64_t) datamap) << 16) |
-		(((uint64_t) event) << 32);
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
 
-        ctx->read_subvol = val;
+    ctx->read_subvol = val;
 
-        return ret;
+    ret = 0;
+out:
+    return ret;
 }
 
-
 int
-__afr_inode_read_subvol_get (inode_t *inode, xlator_t *this,
-			     unsigned char *data, unsigned char *metadata,
-			     int *event_p)
+__afr_inode_read_subvol_get(inode_t *inode, xlator_t *this, unsigned char *data,
+                            unsigned char *metadata, int *event_p)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    int ret = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_read_subvol_get_small (inode, this, data,
-							 metadata, event_p);
-	else
-		/* TBD: allocate structure with array and read from it */
-		ret = -1;
+    if (priv->child_count <= 16)
+        ret = __afr_inode_read_subvol_get_small(inode, this, data, metadata,
+                                                event_p);
+    else
+        /* TBD: allocate structure with array and read from it */
+        ret = -1;
 
-	return ret;
+    return ret;
 }
 
 int
-__afr_inode_split_brain_choice_get (inode_t *inode, xlator_t *this,
-			            int *spb_choice)
+__afr_inode_split_brain_choice_get(inode_t *inode, xlator_t *this,
+                                   int *spb_choice)
 {
-        afr_inode_ctx_t *ctx = NULL;
-        int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret < 0)
-                return ret;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret < 0)
+        return ret;
 
-        *spb_choice = ctx->spb_choice;
-        return 0;
+    *spb_choice = ctx->spb_choice;
+    return 0;
 }
 
 int
-__afr_inode_read_subvol_set (inode_t *inode, xlator_t *this, unsigned char *data,
-			     unsigned char *metadata, int event)
+__afr_inode_read_subvol_set(inode_t *inode, xlator_t *this, unsigned char *data,
+                            unsigned char *metadata, int event)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    int ret = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_read_subvol_set_small (inode, this, data,
-							 metadata, event);
-	else
-		ret = -1;
+    if (priv->child_count <= 16)
+        ret = __afr_inode_read_subvol_set_small(inode, this, data, metadata,
+                                                event);
+    else
+        ret = -1;
 
-	return ret;
+    return ret;
 }
 
 int
-__afr_inode_split_brain_choice_set (inode_t *inode, xlator_t *this,
-                                    int spb_choice)
+__afr_inode_split_brain_choice_set(inode_t *inode, xlator_t *this,
+                                   int spb_choice)
 {
-        afr_inode_ctx_t *ctx = NULL;
-	int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                goto out;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret)
+        goto out;
 
-        ctx->spb_choice = spb_choice;
+    ctx->spb_choice = spb_choice;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__afr_inode_event_gen_reset (inode_t *inode, xlator_t *this)
+afr_inode_read_subvol_get(inode_t *inode, xlator_t *this, unsigned char *data,
+                          unsigned char *metadata, int *event_p)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    int ret = -1;
 
-	priv = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_event_gen_reset_small (inode, this);
-	else
-		ret = -1;
-
-	return ret;
-}
-
-
-int
-afr_inode_read_subvol_get (inode_t *inode, xlator_t *this, unsigned char *data,
-			   unsigned char *metadata, int *event_p)
-{
-	int ret = -1;
-
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-
-        LOCK(&inode->lock);
-	{
-		ret = __afr_inode_read_subvol_get (inode, this, data,
-						   metadata, event_p);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_read_subvol_get(inode, this, data, metadata, event_p);
+    }
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_inode_get_readable (call_frame_t *frame, inode_t *inode, xlator_t *this,
+afr_inode_get_readable(call_frame_t *frame, inode_t *inode, xlator_t *this,
                        unsigned char *readable, int *event_p, int type)
 {
-
-        afr_private_t *priv = this->private;
-        afr_local_t *local = frame->local;
-        unsigned char *data = alloca0 (priv->child_count);
-        unsigned char *metadata = alloca0 (priv->child_count);
-        int data_count = 0;
-        int metadata_count = 0;
-        int event_generation = 0;
-        int ret = 0;
-
-        ret = afr_inode_read_subvol_get (inode, this, data, metadata,
-                                         &event_generation);
-        if (ret == -1)
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
+    unsigned char *data = alloca0(priv->child_count);
+    unsigned char *metadata = alloca0(priv->child_count);
+    int data_count = 0;
+    int metadata_count = 0;
+    int event_generation = 0;
+    int ret = 0;
+
+    ret = afr_inode_read_subvol_get(inode, this, data, metadata,
+                                    &event_generation);
+    if (ret == -1)
+        return -EIO;
+
+    data_count = AFR_COUNT(data, priv->child_count);
+    metadata_count = AFR_COUNT(metadata, priv->child_count);
+
+    if (inode->ia_type == IA_IFDIR) {
+        /* For directories, allow even if it is in data split-brain. */
+        if (type == AFR_METADATA_TRANSACTION || local->op == GF_FOP_STAT ||
+            local->op == GF_FOP_FSTAT) {
+            if (!metadata_count)
                 return -EIO;
+        }
+    } else {
+        /* For files, abort in case of data/metadata split-brain. */
+        if (!data_count || !metadata_count) {
+            return -EIO;
+        }
+    }
 
-        data_count = AFR_COUNT (data, priv->child_count);
-        metadata_count = AFR_COUNT (metadata, priv->child_count);
+    if (type == AFR_METADATA_TRANSACTION && readable)
+        memcpy(readable, metadata, priv->child_count * sizeof *metadata);
+    if (type == AFR_DATA_TRANSACTION && readable) {
+        if (!data_count)
+            memcpy(readable, local->child_up,
+                   priv->child_count * sizeof *readable);
+        else
+            memcpy(readable, data, priv->child_count * sizeof *data);
+    }
+    if (event_p)
+        *event_p = event_generation;
+    return 0;
+}
 
-        if (inode->ia_type == IA_IFDIR) {
-                /* For directories, allow even if it is in data split-brain. */
-                if (type == AFR_METADATA_TRANSACTION ||
-                    local->op == GF_FOP_STAT || local->op == GF_FOP_FSTAT) {
-                        if (!metadata_count)
-                                return -EIO;
-                }
-        } else {
-                /* For files, abort in case of data/metadata split-brain. */
-                if (!data_count || !metadata_count)
-                        return -EIO;
-        }
-
-        if (type == AFR_METADATA_TRANSACTION && readable)
-                memcpy (readable, metadata, priv->child_count * sizeof *metadata);
-        if (type == AFR_DATA_TRANSACTION && readable) {
-                if (!data_count)
-                        memcpy (readable, local->child_up,
-                                priv->child_count * sizeof *readable);
-                else
-                        memcpy (readable, data, priv->child_count * sizeof *data);
-        }
-        if (event_p)
-                *event_p = event_generation;
-        return 0;
+static int
+afr_inode_split_brain_choice_get(inode_t *inode, xlator_t *this,
+                                 int *spb_choice)
+{
+    int ret = -1;
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_split_brain_choice_get(inode, this, spb_choice);
+    }
+    UNLOCK(&inode->lock);
+out:
+    return ret;
 }
 
+/*
+ * frame is used to get the favourite policy. Since
+ * afr_inode_split_brain_choice_get was called with afr_open, it is possible to
+ * have a frame with out local->replies. So in that case, frame is passed as
+ * null, hence this function will handle the frame NULL case.
+ */
 int
-afr_inode_split_brain_choice_get (inode_t *inode, xlator_t *this,
-                                  int *spb_choice)
+afr_split_brain_read_subvol_get(inode_t *inode, xlator_t *this,
+                                call_frame_t *frame, int *spb_subvol)
 {
-	int ret = -1;
+    int ret = -1;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO("afr", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, spb_subvol, out);
 
-	LOCK(&inode->lock);
-	{
-		ret = __afr_inode_split_brain_choice_get (inode, this,
-                                                          spb_choice);
-	}
-	UNLOCK(&inode->lock);
-out:
-        return ret;
-}
+    priv = this->private;
 
+    ret = afr_inode_split_brain_choice_get(inode, this, spb_subvol);
+    if (*spb_subvol < 0 && priv->fav_child_policy && frame && frame->local) {
+        local = frame->local;
+        *spb_subvol = afr_sh_get_fav_by_policy(this, local->replies, inode,
+                                               NULL);
+        if (*spb_subvol >= 0) {
+            ret = 0;
+        }
+    }
 
+out:
+    return ret;
+}
 int
-afr_inode_read_subvol_set (inode_t *inode, xlator_t *this, unsigned char *data,
-			   unsigned char *metadata, int event)
+afr_inode_read_subvol_set(inode_t *inode, xlator_t *this, unsigned char *data,
+                          unsigned char *metadata, int event)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-	{
-		ret = __afr_inode_read_subvol_set (inode, this, data, metadata,
-						   event);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_read_subvol_set(inode, this, data, metadata, event);
+    }
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-afr_inode_split_brain_choice_set (inode_t *inode, xlator_t *this,
-                                  int spb_choice)
+afr_inode_split_brain_choice_set(inode_t *inode, xlator_t *this, int spb_choice)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-	LOCK(&inode->lock);
-	{
-		ret = __afr_inode_split_brain_choice_set (inode, this,
-                                                          spb_choice);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_split_brain_choice_set(inode, this, spb_choice);
+    }
+    UNLOCK(&inode->lock);
 out:
-	return ret;
+    return ret;
 }
 
-
 /* The caller of this should perform afr_inode_refresh, if this function
  * returns _gf_true
  */
 gf_boolean_t
-afr_is_inode_refresh_reqd (inode_t *inode, xlator_t *this,
-                           int event_gen1, int event_gen2)
+afr_is_inode_refresh_reqd(inode_t *inode, xlator_t *this, int event_gen1,
+                          int event_gen2)
 {
-        gf_boolean_t     need_refresh = _gf_false;
-        afr_inode_ctx_t  *ctx         = NULL;
-        int              ret          = -1;
+    gf_boolean_t need_refresh = _gf_false;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret)
-                        goto unlock;
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
+        if (ret)
+            goto unlock;
 
-                need_refresh = ctx->need_refresh;
-                /* Hoping that the caller will do inode_refresh followed by
-                 * this, hence setting the need_refresh to false */
-                ctx->need_refresh = _gf_false;
-        }
+        need_refresh = ctx->need_refresh;
+        /* Hoping that the caller will do inode_refresh followed by
+         * this, hence setting the need_refresh to false */
+        ctx->need_refresh = _gf_false;
+    }
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 
-        if (event_gen1 != event_gen2)
-                need_refresh = _gf_true;
+    if (event_gen1 != event_gen2)
+        need_refresh = _gf_true;
 out:
-        return need_refresh;
+    return need_refresh;
 }
 
-
-static int
-afr_inode_need_refresh_set (inode_t *inode, xlator_t *this)
+int
+__afr_inode_need_refresh_set(inode_t *inode, xlator_t *this)
 {
-        int               ret         = -1;
-        afr_inode_ctx_t  *ctx         = NULL;
+    int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret == 0) {
+        ctx->need_refresh = _gf_true;
+    }
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret)
-                        goto unlock;
-
-                ctx->need_refresh = _gf_true;
-        }
-unlock:
-        UNLOCK(&inode->lock);
-out:
-        return ret;
+    return ret;
 }
 
 int
-afr_inode_event_gen_reset (inode_t *inode, xlator_t *this)
+afr_inode_need_refresh_set(inode_t *inode, xlator_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_event_gen_reset (inode, this);
-        }
-        UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_need_refresh_set(inode, this);
+    }
+    UNLOCK(&inode->lock);
 out:
-	return ret;
+    return ret;
 }
 
 int
-afr_spb_choice_timeout_cancel (xlator_t *this, inode_t *inode)
+afr_spb_choice_timeout_cancel(xlator_t *this, inode_t *inode)
 {
-        afr_inode_ctx_t *ctx    = NULL;
-        int              ret    = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        if (!inode)
-                return ret;
+    if (!inode)
+        return ret;
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret < 0 || !ctx) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to cancel split-brain choice timer.");
-                        goto out;
-                }
-                ctx->spb_choice = -1;
-                if (ctx->timer) {
-                        gf_timer_call_cancel (this->ctx, ctx->timer);
-                        ctx->timer = NULL;
-                }
-                ret = 0;
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
+        if (ret < 0 || !ctx) {
+            UNLOCK(&inode->lock);
+            gf_msg(this->name, GF_LOG_WARNING, 0,
+                   AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+                   "Failed to cancel split-brain choice timer.");
+            goto out;
+        }
+        ctx->spb_choice = -1;
+        if (ctx->timer) {
+            gf_timer_call_cancel(this->ctx, ctx->timer);
+            ctx->timer = NULL;
         }
+        ret = 0;
+    }
+    UNLOCK(&inode->lock);
 out:
-        UNLOCK(&inode->lock);
-        return ret;
+    return ret;
 }
 
 void
-afr_set_split_brain_choice_cbk (void *data)
+afr_set_split_brain_choice_cbk(void *data)
 {
-        inode_t      *inode     = data;
-        xlator_t     *this      = THIS;
+    inode_t *inode = data;
+    xlator_t *this = THIS;
 
-        afr_spb_choice_timeout_cancel (this, inode);
-        inode_unref (inode);
-        return;
+    afr_spb_choice_timeout_cancel(this, inode);
+    inode_invalidate(inode);
+    inode_unref(inode);
+    return;
 }
 
-
 int
-afr_set_split_brain_choice (int ret, call_frame_t *frame, void *opaque)
-{
-        int                 op_errno         = ENOMEM;
-        afr_private_t      *priv             = NULL;
-        afr_inode_ctx_t    *ctx              = NULL;
-        inode_t            *inode            = NULL;
-        loc_t              *loc              = NULL;
-        xlator_t           *this             = NULL;
-        afr_spbc_timeout_t *data             = opaque;
-        struct              timespec delta   = {0, };
-        gf_boolean_t        timer_set        = _gf_false;
-        gf_boolean_t        timer_cancelled  = _gf_false;
-        gf_boolean_t        timer_reset      = _gf_false;
-        int                 old_spb_choice   = -1;
-
-        frame = data->frame;
-        loc = data->loc;
-        this = frame->this;
-        priv = this->private;
-
+afr_set_split_brain_choice(int ret, call_frame_t *frame, void *opaque)
+{
+    int op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_inode_ctx_t *ctx = NULL;
+    inode_t *inode = NULL;
+    loc_t *loc = NULL;
+    xlator_t *this = NULL;
+    afr_spbc_timeout_t *data = opaque;
+    struct timespec delta = {
+        0,
+    };
+    gf_boolean_t timer_set = _gf_false;
+    gf_boolean_t timer_cancelled = _gf_false;
+    gf_boolean_t timer_reset = _gf_false;
+    int old_spb_choice = -1;
+
+    frame = data->frame;
+    loc = data->loc;
+    this = frame->this;
+    priv = this->private;
+
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    delta.tv_sec = priv->spb_choice_timeout;
+    delta.tv_nsec = 0;
+
+    if (!loc->inode) {
+        ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (!(data->d_spb || data->m_spb)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+               "Cannot set "
+               "replica.split-brain-choice on %s. File is"
+               " not in data/metadata split-brain.",
+               uuid_utoa(loc->gfid));
+        ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /*
+     * we're ref'ing the inode before LOCK like it is done elsewhere in the
+     * code. If we ref after LOCK, coverity complains of possible deadlocks.
+     */
+    inode = inode_ref(loc->inode);
+
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
         if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
+            UNLOCK(&inode->lock);
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+                   "Failed to get inode_ctx for %s", loc->name);
+            goto post_unlock;
         }
 
-        delta.tv_sec = priv->spb_choice_timeout;
-        delta.tv_nsec = 0;
+        old_spb_choice = ctx->spb_choice;
+        ctx->spb_choice = data->spb_child_index;
 
-        if (!loc->inode) {
-                ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (!(data->d_spb || data->m_spb)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR, "Cannot set "
-                        "replica.split-brain-choice on %s. File is"
-                        " not in data/metadata split-brain.",
-                        uuid_utoa (loc->gfid));
-                ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        /*
-         * we're ref'ing the inode before LOCK like it is done elsewhere in the
-         * code. If we ref after LOCK, coverity complains of possible deadlocks.
+        /* Possible changes in spb-choice :
+         *         valid to -1    : cancel timer and unref
+         *         valid to valid : cancel timer and inject new one
+         *         -1    to -1    : unref and do not do anything
+         *         -1 to valid    : inject timer
          */
-        inode = inode_ref (loc->inode);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to get inode_ctx for %s", loc->name);
-                        goto unlock;
+        /* ctx->timer is NULL iff previous value of
+         * ctx->spb_choice is -1
+         */
+        if (ctx->timer) {
+            if (ctx->spb_choice == -1) {
+                if (!gf_timer_call_cancel(this->ctx, ctx->timer)) {
+                    ctx->timer = NULL;
+                    timer_cancelled = _gf_true;
                 }
-
-                old_spb_choice = ctx->spb_choice;
-                ctx->spb_choice = data->spb_child_index;
-
-                /* Possible changes in spb-choice :
-                 *         valid to -1    : cancel timer and unref
-                 *         valid to valid : cancel timer and inject new one
-                 *         -1    to -1    : unref and do not do anything
-                 *         -1 to valid    : inject timer
-                 */
-
-                /* ctx->timer is NULL iff previous value of
-                 * ctx->spb_choice is -1
+                /* If timer cancel failed here it means that the
+                 *  previous cbk will be executed which will set
+                 *  spb_choice to -1. So we can consider the
+                 *  'valid to -1' case to be a success
+                 *  (i.e. ret = 0) and goto unlock.
                  */
-                if (ctx->timer) {
-                        if (ctx->spb_choice == -1) {
-                                if (!gf_timer_call_cancel (this->ctx,
-                                                            ctx->timer)) {
-                                        ctx->timer = NULL;
-                                        timer_cancelled = _gf_true;
-                                }
-                                /* If timer cancel failed here it means that the
-                                *  previous cbk will be executed which will set
-                                *  spb_choice to -1. So we can consider the
-                                *  'valid to -1' case to be a sucess
-                                *  (i.e. ret = 0) and goto unlock.
-                                */
-                                goto unlock;
-                        }
-                        goto reset_timer;
-                } else {
-                        if (ctx->spb_choice == -1)
-                                goto unlock;
-                        goto set_timer;
-                }
-
-reset_timer:
-                ret = gf_timer_call_cancel (this->ctx, ctx->timer);
-                if (ret != 0) {
-                        /* We need to bail out now instead of launching a new
-                         * timer. Otherwise the cbk of the previous timer event
-                         * will cancel the new ctx->timer.
-                         */
-                        ctx->spb_choice = old_spb_choice;
-                        ret = -1;
-                        op_errno = EAGAIN;
-                        goto unlock;
-                }
-                ctx->timer = NULL;
-                timer_reset = _gf_true;
-
-set_timer:
-                ctx->timer = gf_timer_call_after (this->ctx, delta,
-                                                  afr_set_split_brain_choice_cbk,
-                                                  inode);
-                if (!ctx->timer) {
-                        ctx->spb_choice = old_spb_choice;
-                        ret = -1;
-                        op_errno = ENOMEM;
-                }
-                if (!timer_reset && ctx->timer)
-                        timer_set = _gf_true;
-                if (timer_reset && !ctx->timer)
-                        timer_cancelled = _gf_true;
+                goto unlock;
+            }
+            goto reset_timer;
+        } else {
+            if (ctx->spb_choice == -1)
+                goto unlock;
+            goto set_timer;
         }
+
+    reset_timer:
+        ret = gf_timer_call_cancel(this->ctx, ctx->timer);
+        if (ret != 0) {
+            /* We need to bail out now instead of launching a new
+             * timer. Otherwise the cbk of the previous timer event
+             * will cancel the new ctx->timer.
+             */
+            ctx->spb_choice = old_spb_choice;
+            ret = -1;
+            op_errno = EAGAIN;
+            goto unlock;
+        }
+        ctx->timer = NULL;
+        timer_reset = _gf_true;
+
+    set_timer:
+        ctx->timer = gf_timer_call_after(this->ctx, delta,
+                                         afr_set_split_brain_choice_cbk, inode);
+        if (!ctx->timer) {
+            ctx->spb_choice = old_spb_choice;
+            ret = -1;
+            op_errno = ENOMEM;
+        }
+        if (!timer_reset && ctx->timer)
+            timer_set = _gf_true;
+        if (timer_reset && !ctx->timer)
+            timer_cancelled = _gf_true;
+    }
 unlock:
-        UNLOCK(&inode->lock);
-        if (!timer_set)
-                inode_unref (inode);
-        if (timer_cancelled)
-                inode_unref (inode);
-        /*
-         * We need to invalidate the inode to prevent the kernel from serving
-         * reads from an older cached value despite a change in spb_choice to
-         * a new value.
-         */
-        inode_invalidate (inode);
+    UNLOCK(&inode->lock);
+post_unlock:
+    if (!timer_set)
+        inode_unref(inode);
+    if (timer_cancelled)
+        inode_unref(inode);
+    /*
+     * We need to invalidate the inode to prevent the kernel from serving
+     * reads from an older cached value despite a change in spb_choice to
+     * a new value.
+     */
+    inode_invalidate(inode);
 out:
-        if (data)
-                GF_FREE (data);
-        AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        return 0;
+    GF_FREE(data);
+    AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    return 0;
 }
 
 int
-afr_accused_fill (xlator_t *this, dict_t *xdata, unsigned char *accused,
-		  afr_transaction_type type)
+afr_accused_fill(xlator_t *this, dict_t *xdata, unsigned char *accused,
+                 afr_transaction_type type)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int idx = afr_index_for_transaction_type (type);
-	void *pending_raw = NULL;
-	int pending[3];
-	int ret = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int idx = afr_index_for_transaction_type(type);
+    void *pending_raw = NULL;
+    int pending[3];
+    int ret = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		ret = dict_get_ptr (xdata, priv->pending_key[i],
-				    &pending_raw);
-		if (ret) /* no pending flags */
-			continue;
-		memcpy (pending, pending_raw, sizeof(pending));
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_get_ptr(xdata, priv->pending_key[i], &pending_raw);
+        if (ret) /* no pending flags */
+            continue;
+        memcpy(pending, pending_raw, sizeof(pending));
 
-		if (ntoh32 (pending[idx]))
-			accused[i] = 1;
-	}
+        if (ntoh32(pending[idx]))
+            accused[i] = 1;
+    }
 
-	return 0;
+    return 0;
 }
 
 int
-afr_accuse_smallfiles (xlator_t *this, struct afr_reply *replies,
-		       unsigned char *data_accused)
+afr_accuse_smallfiles(xlator_t *this, struct afr_reply *replies,
+                      unsigned char *data_accused)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	uint64_t maxsize = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t maxsize = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid && replies[i].xdata &&
-                    dict_get (replies[i].xdata, GLUSTERFS_BAD_INODE))
-                        continue;
-		if (data_accused[i])
-			continue;
-		if (replies[i].poststat.ia_size > maxsize)
-			maxsize = replies[i].poststat.ia_size;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].xdata &&
+            dict_get_sizen(replies[i].xdata, GLUSTERFS_BAD_INODE))
+            continue;
+        if (data_accused[i])
+            continue;
+        if (replies[i].poststat.ia_size > maxsize)
+            maxsize = replies[i].poststat.ia_size;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (data_accused[i])
-			continue;
-                if (AFR_IS_ARBITER_BRICK(priv, i))
-                        continue;
-		if (replies[i].poststat.ia_size < maxsize)
-			data_accused[i] = 1;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_accused[i])
+            continue;
+        if (AFR_IS_ARBITER_BRICK(priv, i))
+            continue;
+        if (replies[i].poststat.ia_size < maxsize)
+            data_accused[i] = 1;
+    }
 
-	return 0;
+    return 0;
 }
 
 int
-afr_replies_interpret (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                       gf_boolean_t *start_heal)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	struct afr_reply *replies = NULL;
-	int event_generation = 0;
-	int i = 0;
-	unsigned char *data_accused = NULL;
-	unsigned char *metadata_accused = NULL;
-	unsigned char *data_readable = NULL;
-	unsigned char *metadata_readable = NULL;
-	int ret = 0;
-
-	local = frame->local;
-	priv = this->private;
-	replies = local->replies;
-	event_generation = local->event_generation;
-
-	data_accused = alloca0 (priv->child_count);
-	data_readable = alloca0 (priv->child_count);
-	metadata_accused = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-
-	for (i = 0; i < priv->child_count; i++) {
-		data_readable[i] = 1;
-		metadata_readable[i] = 1;
-	}
-        if (AFR_IS_ARBITER_BRICK (priv, ARBITER_BRICK_INDEX)) {
-                data_readable[ARBITER_BRICK_INDEX] =  0;
-                metadata_readable[ARBITER_BRICK_INDEX] = 0;
-        }
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid) {
-			data_readable[i] = 0;
-			metadata_readable[i] = 0;
-			continue;
-		}
-
-		if (replies[i].op_ret == -1) {
-			data_readable[i] = 0;
-			metadata_readable[i] = 0;
-			continue;
-		}
-
-                if (replies[i].xdata &&
-                    dict_get (replies[i].xdata, GLUSTERFS_BAD_INODE)) {
-			data_readable[i] = 0;
-			metadata_readable[i] = 0;
-			continue;
-                }
+afr_readables_fill(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                   unsigned char *data_accused, unsigned char *metadata_accused,
+                   unsigned char *data_readable,
+                   unsigned char *metadata_readable, struct afr_reply *replies)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
+    int ret = 0;
+    ia_type_t ia_type = IA_INVAL;
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        data_readable[i] = 1;
+        metadata_readable[i] = 1;
+    }
+    if (AFR_IS_ARBITER_BRICK(priv, ARBITER_BRICK_INDEX)) {
+        data_readable[ARBITER_BRICK_INDEX] = 0;
+        metadata_readable[ARBITER_BRICK_INDEX] = 0;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies) { /* Lookup */
+            if (!replies[i].valid || replies[i].op_ret == -1 ||
+                (replies[i].xdata &&
+                 dict_get_sizen(replies[i].xdata, GLUSTERFS_BAD_INODE))) {
+                data_readable[i] = 0;
+                metadata_readable[i] = 0;
+                continue;
+            }
 
-		afr_accused_fill (this, replies[i].xdata, data_accused,
-				  (replies[i].poststat.ia_type == IA_IFDIR) ?
-				   AFR_ENTRY_TRANSACTION : AFR_DATA_TRANSACTION);
-
-		afr_accused_fill (this, replies[i].xdata,
-				  metadata_accused, AFR_METADATA_TRANSACTION);
-
-	}
-
-	if ((inode->ia_type != IA_IFDIR) &&
-            /* We want to accuse small files only when we know for sure that
-             * there is no IO happening. Otherwise, the ia_sizes obtained in
-             * post-refresh replies may  mismatch due to a race between inode-
-             * refresh and ongoing writes, causing spurious heal launches*/
-            !afr_is_possibly_under_txn (AFR_DATA_TRANSACTION, local, this))
-		afr_accuse_smallfiles (this, replies, data_accused);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (data_accused[i]) {
-			data_readable[i] = 0;
-			ret = 1;
-		}
-		if (metadata_accused[i]) {
-			metadata_readable[i] = 0;
-			ret = 1;
-		}
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (start_heal && priv->child_up[i] &&
-                    (data_accused[i] || metadata_accused[i])) {
-                        *start_heal = _gf_true;
-                        break;
-                }
+            xdata = replies[i].xdata;
+            ia_type = replies[i].poststat.ia_type;
+        } else { /* pre-op xattrop */
+            xdata = local->transaction.changelog_xdata[i];
+            ia_type = inode->ia_type;
         }
-	afr_inode_read_subvol_set (inode, this, data_readable,
-				   metadata_readable, event_generation);
-	return ret;
-}
 
+        if (!xdata)
+            continue; /* mkdir_cbk sends NULL xdata_rsp. */
+        afr_accused_fill(this, xdata, data_accused,
+                         (ia_type == IA_IFDIR) ? AFR_ENTRY_TRANSACTION
+                                               : AFR_DATA_TRANSACTION);
+
+        afr_accused_fill(this, xdata, metadata_accused,
+                         AFR_METADATA_TRANSACTION);
+    }
 
+    if (replies && ia_type != IA_INVAL && ia_type != IA_IFDIR &&
+        /* We want to accuse small files only when we know for
+         * sure that there is no IO happening. Otherwise, the
+         * ia_sizes obtained in post-refresh replies may
+         * mismatch due to a race between inode-refresh and
+         * ongoing writes, causing spurious heal launches*/
+        !afr_is_possibly_under_txn(AFR_DATA_TRANSACTION, local, this)) {
+        afr_accuse_smallfiles(this, replies, data_accused);
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_accused[i]) {
+            data_readable[i] = 0;
+            ret = 1;
+        }
+        if (metadata_accused[i]) {
+            metadata_readable[i] = 0;
+            ret = 1;
+        }
+    }
+    return ret;
+}
+
+int
+afr_replies_interpret(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                      gf_boolean_t *start_heal)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int event_generation = 0;
+    int i = 0;
+    unsigned char *data_accused = NULL;
+    unsigned char *metadata_accused = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    priv = this->private;
+    replies = local->replies;
+    event_generation = local->event_generation;
+
+    data_accused = alloca0(priv->child_count);
+    data_readable = alloca0(priv->child_count);
+    metadata_accused = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+
+    ret = afr_readables_fill(frame, this, inode, data_accused, metadata_accused,
+                             data_readable, metadata_readable, replies);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (start_heal && priv->child_up[i] &&
+            (data_accused[i] || metadata_accused[i])) {
+            *start_heal = _gf_true;
+            break;
+        }
+    }
+    afr_inode_read_subvol_set(inode, this, data_readable, metadata_readable,
+                              event_generation);
+    return ret;
+}
 
 int
-afr_refresh_selfheal_done (int ret, call_frame_t *heal, void *opaque)
+afr_refresh_selfheal_done(int ret, call_frame_t *heal, void *opaque)
 {
-	if (heal)
-                AFR_STACK_DESTROY (heal);
-	return 0;
+    if (heal)
+        AFR_STACK_DESTROY(heal);
+    return 0;
 }
 
 int
-afr_inode_refresh_err (call_frame_t *frame, xlator_t *this)
+afr_inode_refresh_err(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int err = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int err = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].valid && !local->replies[i].op_ret) {
-			err = 0;
-			goto ret;
-		}
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && !local->replies[i].op_ret) {
+            err = 0;
+            goto ret;
+        }
+    }
 
-	err = afr_final_errno (local, priv);
+    err = afr_final_errno(local, priv);
 ret:
-	return -err;
+    return err;
 }
 
 gf_boolean_t
-afr_selfheal_enabled (xlator_t *this)
+afr_selfheal_enabled(const xlator_t *this)
 {
-	afr_private_t *priv = NULL;
-	gf_boolean_t data = _gf_false;
-        int ret = 0;
-
-	priv = this->private;
+    const afr_private_t *priv = this->private;
 
-	ret = gf_string2boolean (priv->data_self_heal, &data);
-        GF_ASSERT (!ret);
-
-	return data || priv->metadata_self_heal || priv->entry_self_heal;
+    return priv->data_self_heal || priv->metadata_self_heal ||
+           priv->entry_self_heal;
 }
 
-
 int
-afr_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
-{
-
-        call_frame_t *heal_frame = NULL;
-        afr_local_t *heal_local = NULL;
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        inode_t *inode = NULL;
-        int event_generation = 0;
-        int read_subvol = -1;
-        int op_errno = ENOMEM;
-        int ret = 0;
-
-        local = frame->local;
-        inode = local->inode;
-        priv = this->private;
-
-        if (err)
-                goto refresh_done;
-
-        if (local->op == GF_FOP_LOOKUP)
-                goto refresh_done;
-
-        ret = afr_inode_get_readable (frame, inode, this, local->readable,
-                                      &event_generation,
-                                      local->transaction.type);
-
-        if (ret == -EIO || (local->is_read_txn && !event_generation)) {
-                /* No readable subvolume even after refresh ==> splitbrain.*/
-                if (!priv->fav_child_policy) {
-                        err = -EIO;
-                        goto refresh_done;
-                }
-                read_subvol = afr_sh_get_fav_by_policy (this, local->replies,
-                                                        inode, NULL);
-                if (read_subvol == -1) {
-                        err = -EIO;
-                        goto refresh_done;
-                }
+afr_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
+{
+    call_frame_t *heal_frame = NULL;
+    afr_local_t *heal_local = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    int event_generation = 0;
+    int read_subvol = -1;
+    int ret = 0;
+
+    local = frame->local;
+    inode = local->inode;
+    priv = this->private;
+
+    if (err)
+        goto refresh_done;
+
+    if (local->op == GF_FOP_LOOKUP)
+        goto refresh_done;
+
+    ret = afr_inode_get_readable(frame, inode, this, local->readable,
+                                 &event_generation, local->transaction.type);
+
+    if (ret == -EIO) {
+        /* No readable subvolume even after refresh ==> splitbrain.*/
+        if (!priv->fav_child_policy) {
+            err = EIO;
+            goto refresh_done;
+        }
+        read_subvol = afr_sh_get_fav_by_policy(this, local->replies, inode,
+                                               NULL);
+        if (read_subvol == -1) {
+            err = EIO;
+            goto refresh_done;
+        }
 
-                heal_frame = copy_frame (frame);
-                if (!heal_frame) {
-                        err = -EIO;
-                        goto refresh_done;
-                }
-                heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-                heal_local = AFR_FRAME_INIT (heal_frame, op_errno);
-                if (!heal_local) {
-                        err = -EIO;
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->xdata_req = dict_new();
-                if (!heal_local->xdata_req) {
-                        err = -EIO;
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->heal_frame = frame;
-                ret = synctask_new (this->ctx->env,
-                                    afr_fav_child_reset_sink_xattrs,
-                                    afr_fav_child_reset_sink_xattrs_cbk,
-                                    heal_frame,
-                                    heal_frame);
-                return 0;
+        heal_frame = afr_frame_create(this, NULL);
+        if (!heal_frame) {
+            err = EIO;
+            goto refresh_done;
         }
+        heal_local = heal_frame->local;
+        heal_local->xdata_req = dict_new();
+        if (!heal_local->xdata_req) {
+            err = EIO;
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
+        }
+        heal_local->heal_frame = frame;
+        ret = synctask_new(this->ctx->env, afr_fav_child_reset_sink_xattrs,
+                           afr_fav_child_reset_sink_xattrs_cbk, heal_frame,
+                           heal_frame);
+        return 0;
+    }
 
 refresh_done:
-        afr_local_replies_wipe (local, this->private);
-        local->refreshfn (frame, this, err);
+    afr_local_replies_wipe(local, this->private);
+    local->refreshfn(frame, this, err);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_inode_refresh_done (call_frame_t *frame, xlator_t *this, int error)
-{
-	call_frame_t *heal_frame = NULL;
-	afr_local_t *local = NULL;
-        gf_boolean_t start_heal = _gf_false;
-        afr_local_t *heal_local = NULL;
-        int op_errno = ENOMEM;
-	int ret = 0;
-	int err = 0;
-
-	if (error != 0) {
-		err = error;
-		goto refresh_done;
-	}
-
-	local = frame->local;
-
-	ret = afr_replies_interpret (frame, this, local->refreshinode,
-                                     &start_heal);
-
-	err = afr_inode_refresh_err (frame, this);
-
-	if (ret && afr_selfheal_enabled (this) && start_heal) {
-                heal_frame = copy_frame (frame);
-                if (!heal_frame)
-                        goto refresh_done;
-                heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-                heal_local = AFR_FRAME_INIT (heal_frame, op_errno);
-                if (!heal_local) {
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->refreshinode = inode_ref (local->refreshinode);
-                heal_local->heal_frame = heal_frame;
-                if (!afr_throttled_selfheal (heal_frame, this)) {
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
+afr_inode_refresh_done(call_frame_t *frame, xlator_t *this, int error)
+{
+    call_frame_t *heal_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t start_heal = _gf_false;
+    afr_local_t *heal_local = NULL;
+    unsigned char *success_replies = NULL;
+    int ret = 0;
+
+    if (error != 0) {
+        goto refresh_done;
+    }
+
+    local = frame->local;
+    priv = this->private;
+    success_replies = alloca0(priv->child_count);
+    afr_fill_success_replies(local, priv, success_replies);
+
+    if (priv->thin_arbiter_count && local->is_read_txn &&
+        AFR_COUNT(success_replies, priv->child_count) != priv->child_count) {
+        /* We need to query the good bricks and/or thin-arbiter.*/
+        if (success_replies[0]) {
+            local->read_txn_query_child = AFR_CHILD_ZERO;
+        } else if (success_replies[1]) {
+            local->read_txn_query_child = AFR_CHILD_ONE;
+        }
+        error = EINVAL;
+        goto refresh_done;
+    }
+
+    if (!afr_has_quorum(success_replies, this, frame)) {
+        error = afr_final_errno(frame->local, this->private);
+        if (!error)
+            error = afr_quorum_errno(priv);
+        goto refresh_done;
+    }
+
+    ret = afr_replies_interpret(frame, this, local->refreshinode, &start_heal);
+
+    if (ret && afr_selfheal_enabled(this) && start_heal) {
+        heal_frame = afr_frame_create(this, NULL);
+        if (!heal_frame)
+            goto refresh_done;
+        heal_local = heal_frame->local;
+        heal_local->refreshinode = inode_ref(local->refreshinode);
+        heal_local->heal_frame = heal_frame;
+        if (!afr_throttled_selfheal(heal_frame, this)) {
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
         }
+    }
 
 refresh_done:
-        afr_txn_refresh_done (frame, this, err);
+    afr_txn_refresh_done(frame, this, error);
 
-	return 0;
+    return 0;
 }
 
 void
-afr_inode_refresh_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int op_ret, int op_errno, struct iatt *buf,
-                              dict_t *xdata, struct iatt *par)
-{
-        afr_local_t *local = NULL;
-        int call_child = (long) cookie;
-        int8_t need_heal = 1;
-        int call_count = 0;
-        GF_UNUSED int ret = 0;
+afr_inode_refresh_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, struct iatt *buf,
+                             dict_t *xdata, struct iatt *par)
+{
+    afr_local_t *local = NULL;
+    int call_child = (long)cookie;
+    int8_t need_heal = 1;
+    int call_count = 0;
+    int ret = 0;
+
+    local = frame->local;
+    local->replies[call_child].valid = 1;
+    local->replies[call_child].op_ret = op_ret;
+    local->replies[call_child].op_errno = op_errno;
+    if (op_ret != -1) {
+        local->replies[call_child].poststat = *buf;
+        if (par)
+            local->replies[call_child].postparent = *par;
+        if (xdata)
+            local->replies[call_child].xdata = dict_ref(xdata);
+    }
 
-        local = frame->local;
-        local->replies[call_child].valid = 1;
-        local->replies[call_child].op_ret = op_ret;
-        local->replies[call_child].op_errno = op_errno;
-	if (op_ret != -1) {
-		local->replies[call_child].poststat = *buf;
-		if (par)
-                        local->replies[call_child].postparent = *par;
-                if (xdata)
-		        local->replies[call_child].xdata = dict_ref (xdata);
-	}
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[call_child].need_heal = need_heal;
-        } else {
-                local->replies[call_child].need_heal = need_heal;
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        if (ret) {
+            gf_msg_debug(this->name, -ret, "Unable to get link count");
         }
+    }
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-		afr_inode_refresh_done (frame, this, 0);
+    local->replies[call_child].need_heal = need_heal;
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        ret = afr_inode_refresh_err(frame, this);
+        if (ret) {
+            gf_msg_debug(this->name, ret, "afr_inode_refresh_err failed");
         }
-
+        afr_inode_refresh_done(frame, this, ret);
+    }
 }
 
 int
-afr_inode_refresh_subvol_with_lookup_cbk (call_frame_t *frame, void *cookie,
-                                          xlator_t *this, int op_ret,
-                                          int op_errno, inode_t *inode,
-                                          struct iatt *buf, dict_t *xdata,
-                                          struct iatt *par)
+afr_inode_refresh_subvol_with_lookup_cbk(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int op_ret,
+                                         int op_errno, inode_t *inode,
+                                         struct iatt *buf, dict_t *xdata,
+                                         struct iatt *par)
 {
-        afr_inode_refresh_subvol_cbk (frame, cookie, this, op_ret, op_errno,
-                                      buf, xdata, par);
-	return 0;
+    afr_inode_refresh_subvol_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                                 xdata, par);
+    return 0;
 }
 
-
 int
-afr_inode_refresh_subvol_with_lookup (call_frame_t *frame, xlator_t *this,
-                                      int i, inode_t *inode, uuid_t gfid,
-                                      dict_t *xdata)
+afr_inode_refresh_subvol_with_lookup(call_frame_t *frame, xlator_t *this, int i,
+                                     inode_t *inode, uuid_t gfid, dict_t *xdata)
 {
-	loc_t loc = {0, };
-	afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	loc.inode = inode;
-        if (gf_uuid_is_null (inode->gfid) && gfid) {
-                /* To handle setattr/setxattr on yet to be linked inode from
-                 * dht */
-                gf_uuid_copy (loc.gfid, gfid);
-        } else {
-                gf_uuid_copy (loc.gfid, inode->gfid);
-        }
+    loc.inode = inode;
+    if (gf_uuid_is_null(inode->gfid) && gfid) {
+        /* To handle setattr/setxattr on yet to be linked inode from
+         * dht */
+        gf_uuid_copy(loc.gfid, gfid);
+    } else {
+        gf_uuid_copy(loc.gfid, inode->gfid);
+    }
 
-	STACK_WIND_COOKIE (frame, afr_inode_refresh_subvol_with_lookup_cbk,
-			   (void *) (long) i, priv->children[i],
-			   priv->children[i]->fops->lookup, &loc, xdata);
-	return 0;
+    STACK_WIND_COOKIE(frame, afr_inode_refresh_subvol_with_lookup_cbk,
+                      (void *)(long)i, priv->children[i],
+                      priv->children[i]->fops->lookup, &loc, xdata);
+    return 0;
 }
 
 int
-afr_inode_refresh_subvol_with_fstat_cbk (call_frame_t *frame,
-                                         void *cookie, xlator_t *this,
-                                         int32_t op_ret, int32_t op_errno,
-                                         struct iatt *buf, dict_t *xdata)
+afr_inode_refresh_subvol_with_fstat_cbk(call_frame_t *frame, void *cookie,
+                                        xlator_t *this, int32_t op_ret,
+                                        int32_t op_errno, struct iatt *buf,
+                                        dict_t *xdata)
 {
-        afr_inode_refresh_subvol_cbk (frame, cookie, this, op_ret, op_errno,
-                                      buf, xdata, NULL);
-        return 0;
+    afr_inode_refresh_subvol_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                                 xdata, NULL);
+    return 0;
 }
 
 int
-afr_inode_refresh_subvol_with_fstat (call_frame_t *frame, xlator_t *this, int i,
-			             dict_t *xdata)
+afr_inode_refresh_subvol_with_fstat(call_frame_t *frame, xlator_t *this, int i,
+                                    dict_t *xdata)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        STACK_WIND_COOKIE (frame, afr_inode_refresh_subvol_with_fstat_cbk,
-                           (void *) (long) i, priv->children[i],
-                           priv->children[i]->fops->fstat, local->fd, xdata);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_inode_refresh_subvol_with_fstat_cbk,
+                      (void *)(long)i, priv->children[i],
+                      priv->children[i]->fops->fstat, local->fd, xdata);
+    return 0;
 }
 
 int
-afr_inode_refresh_do (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
-	int i = 0;
-        int ret = 0;
-	dict_t *xdata = NULL;
-        afr_fd_ctx_t  *fd_ctx = NULL;
-        unsigned char *wind_subvols = NULL;
-
-	priv = this->private;
-	local = frame->local;
-        wind_subvols = alloca0 (priv->child_count);
-
-        afr_local_replies_wipe (local, priv);
-
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        afr_inode_refresh_done (frame, this, EINVAL);
-                        return 0;
-                }
-        }
+afr_inode_refresh_do(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int i = 0;
+    int ret = 0;
+    dict_t *xdata = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    unsigned char *wind_subvols = NULL;
 
-	xdata = dict_new ();
-	if (!xdata) {
-		afr_inode_refresh_done (frame, this, ENOMEM);
-		return 0;
-	}
+    priv = this->private;
+    local = frame->local;
+    wind_subvols = alloca0(priv->child_count);
 
-	ret = afr_xattr_req_prepare (this, xdata);
-	if (ret != 0) {
-		dict_unref (xdata);
-		afr_inode_refresh_done (frame, this, -ret);
-		return 0;
-	}
+    afr_local_replies_wipe(local, priv);
 
-        ret = dict_set_str (xdata, "link-count", GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
+    if (local->fd) {
+        fd_ctx = afr_fd_ctx_get(local->fd, this);
+        if (!fd_ctx) {
+            afr_inode_refresh_done(frame, this, EINVAL);
+            return 0;
         }
+    }
 
-        ret = dict_set_str (xdata, GLUSTERFS_INODELK_DOM_COUNT, this->name);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set inodelk-dom-count in dict ");
+    xdata = dict_new();
+    if (!xdata) {
+        afr_inode_refresh_done(frame, this, ENOMEM);
+        return 0;
+    }
 
-        }
+    ret = afr_xattr_req_prepare(this, xdata);
+    if (ret != 0) {
+        dict_unref(xdata);
+        afr_inode_refresh_done(frame, this, -ret);
+        return 0;
+    }
 
-        if (local->fd) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (local->child_up[i] &&
-                            fd_ctx->opened_on[i] == AFR_FD_OPENED)
-                                wind_subvols[i] = 1;
-                }
-        } else {
-                memcpy (wind_subvols, local->child_up,
-                        sizeof (*local->child_up) * priv->child_count);
-        }
+    ret = dict_set_sizen_str_sizen(xdata, "link-count", GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
 
-	local->call_count = AFR_COUNT (wind_subvols, priv->child_count);
+    ret = dict_set_str_sizen(xdata, GLUSTERFS_INODELK_DOM_COUNT, this->name);
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "Unable to set inodelk-dom-count in dict ");
+    }
 
-	call_count = local->call_count;
-        if (!call_count) {
-                dict_unref (xdata);
-		if (local->fd && AFR_COUNT(local->child_up, priv->child_count))
-	                afr_inode_refresh_done (frame, this, EBADFD);
-		else
-	                afr_inode_refresh_done (frame, this, ENOTCONN);
-                return 0;
+    if (local->fd) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->child_up[i] && fd_ctx->opened_on[i] == AFR_FD_OPENED)
+                wind_subvols[i] = 1;
         }
-	for (i = 0; i < priv->child_count; i++) {
-		if (!wind_subvols[i])
-			continue;
+    } else {
+        memcpy(wind_subvols, local->child_up,
+               sizeof(*local->child_up) * priv->child_count);
+    }
 
-                if (local->fd)
-                        afr_inode_refresh_subvol_with_fstat (frame, this, i,
-                                                             xdata);
-                else
-                        afr_inode_refresh_subvol_with_lookup (frame, this, i,
-                                                    local->refreshinode,
-                                                    local->refreshgfid, xdata);
+    local->call_count = AFR_COUNT(wind_subvols, priv->child_count);
 
-		if (!--call_count)
-			break;
-	}
+    call_count = local->call_count;
+    if (!call_count) {
+        dict_unref(xdata);
+        if (local->fd && AFR_COUNT(local->child_up, priv->child_count))
+            afr_inode_refresh_done(frame, this, EBADFD);
+        else
+            afr_inode_refresh_done(frame, this, ENOTCONN);
+        return 0;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!wind_subvols[i])
+            continue;
 
-	dict_unref (xdata);
+        if (local->fd)
+            afr_inode_refresh_subvol_with_fstat(frame, this, i, xdata);
+        else
+            afr_inode_refresh_subvol_with_lookup(
+                frame, this, i, local->refreshinode, local->refreshgfid, xdata);
 
-	return 0;
-}
+        if (!--call_count)
+            break;
+    }
 
+    dict_unref(xdata);
+
+    return 0;
+}
 
 int
-afr_inode_refresh (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                   uuid_t gfid, afr_inode_refresh_cbk_t refreshfn)
+afr_inode_refresh(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                  uuid_t gfid, afr_inode_refresh_cbk_t refreshfn)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	local->refreshfn = refreshfn;
+    local->refreshfn = refreshfn;
 
-	if (local->refreshinode) {
-		inode_unref (local->refreshinode);
-		local->refreshinode = NULL;
-	}
+    if (local->refreshinode) {
+        inode_unref(local->refreshinode);
+        local->refreshinode = NULL;
+    }
 
-	local->refreshinode = inode_ref (inode);
+    local->refreshinode = inode_ref(inode);
 
-        if (gfid)
-                gf_uuid_copy (local->refreshgfid, gfid);
-        else
-                gf_uuid_clear (local->refreshgfid);
+    if (gfid)
+        gf_uuid_copy(local->refreshgfid, gfid);
+    else
+        gf_uuid_clear(local->refreshgfid);
 
-	afr_inode_refresh_do (frame, this);
+    afr_inode_refresh_do(frame, this);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_xattr_req_prepare (xlator_t *this, dict_t *xattr_req)
+afr_xattr_req_prepare(xlator_t *this, dict_t *xattr_req)
 {
-        int             i           = 0;
-        afr_private_t   *priv       = NULL;
-        int             ret         = 0;
-
-        priv   = this->private;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int ret = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                ret = dict_set_uint64 (xattr_req, priv->pending_key[i],
-                                       AFR_NUM_CHANGE_LOGS * sizeof(int));
-                if (ret < 0)
-                        gf_msg (this->name, GF_LOG_WARNING,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Unable to set dict value for %s",
-                                priv->pending_key[i]);
-                /* 3 = data+metadata+entry */
-        }
-        ret = dict_set_uint64 (xattr_req, AFR_DIRTY,
-			       AFR_NUM_CHANGE_LOGS * sizeof(int));
-        if (ret) {
-                gf_msg_debug (this->name, -ret, "failed to set dirty "
-                              "query flag");
-        }
+    priv = this->private;
 
-        ret = dict_set_int32 (xattr_req, "list-xattr", 1);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set list-xattr in dict ");
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_uint64(xattr_req, priv->pending_key[i],
+                              AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret < 0)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Unable to set dict value for %s", priv->pending_key[i]);
+        /* 3 = data+metadata+entry */
+    }
+    ret = dict_set_uint64(xattr_req, AFR_DIRTY,
+                          AFR_NUM_CHANGE_LOGS * sizeof(int));
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "failed to set dirty "
+                     "query flag");
+    }
+
+    ret = dict_set_int32_sizen(xattr_req, "list-xattr", 1);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set list-xattr in dict ");
+    }
+
+    return ret;
+}
 
-	return ret;
+int
+afr_lookup_xattr_req_prepare(afr_local_t *local, xlator_t *this,
+                             dict_t *xattr_req, loc_t *loc)
+{
+    int ret = -ENOMEM;
+
+    if (!local->xattr_req)
+        local->xattr_req = dict_new();
+
+    if (!local->xattr_req)
+        goto out;
+
+    if (xattr_req && (xattr_req != local->xattr_req))
+        dict_copy(xattr_req, local->xattr_req);
+
+    ret = afr_xattr_req_prepare(this, local->xattr_req);
+
+    ret = dict_set_uint64(local->xattr_req, GLUSTERFS_INODELK_COUNT, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_INODELK_COUNT);
+    }
+    ret = dict_set_uint64(local->xattr_req, GLUSTERFS_ENTRYLK_COUNT, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_ENTRYLK_COUNT);
+    }
+
+    ret = dict_set_uint32(local->xattr_req, GLUSTERFS_PARENT_ENTRYLK, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_PARENT_ENTRYLK);
+    }
+
+    ret = dict_set_sizen_str_sizen(local->xattr_req, "link-count",
+                                   GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
+
+    ret = 0;
+out:
+    return ret;
 }
 
 int
-afr_lookup_xattr_req_prepare (afr_local_t *local, xlator_t *this,
-                              dict_t *xattr_req, loc_t *loc)
+afr_least_pending_reads_child(afr_private_t *priv, unsigned char *readable)
 {
-        int     ret = -ENOMEM;
-
-        if (!local->xattr_req)
-                local->xattr_req = dict_new ();
+    int i = 0;
+    int child = -1;
+    int64_t read_iter = -1;
+    int64_t pending_read = -1;
 
-        if (!local->xattr_req)
-                goto out;
-
-        if (xattr_req && (xattr_req != local->xattr_req))
-                dict_copy (xattr_req, local->xattr_req);
+    for (i = 0; i < priv->child_count; i++) {
+        if (AFR_IS_ARBITER_BRICK(priv, i) || !readable[i])
+            continue;
+        read_iter = GF_ATOMIC_GET(priv->pending_reads[i]);
+        if (child == -1 || read_iter < pending_read) {
+            pending_read = read_iter;
+            child = i;
+        }
+    }
 
-        ret = afr_xattr_req_prepare (this, local->xattr_req);
+    return child;
+}
 
-        ret = dict_set_uint64 (local->xattr_req, GLUSTERFS_INODELK_COUNT, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_INODELK_COUNT);
-        }
-        ret = dict_set_uint64 (local->xattr_req, GLUSTERFS_ENTRYLK_COUNT, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_ENTRYLK_COUNT);
-        }
+static int32_t
+afr_least_latency_child(afr_private_t *priv, unsigned char *readable)
+{
+    int32_t i = 0;
+    int child = -1;
 
-        ret = dict_set_uint32 (local->xattr_req, GLUSTERFS_PARENT_ENTRYLK, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_PARENT_ENTRYLK);
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (AFR_IS_ARBITER_BRICK(priv, i) || !readable[i] ||
+            priv->child_latency[i] < 0)
+            continue;
 
-        ret = dict_set_str (local->xattr_req, "link-count",
-                            GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
+        if (child == -1 ||
+            priv->child_latency[i] < priv->child_latency[child]) {
+            child = i;
         }
-
-        ret = 0;
-out:
-        return ret;
+    }
+    return child;
 }
 
-
-int
-afr_hash_child (afr_read_subvol_args_t *args, int32_t child_count, int hashmode)
+static int32_t
+afr_least_latency_times_pending_reads_child(afr_private_t *priv,
+                                            unsigned char *readable)
 {
-        uuid_t gfid_copy = {0,};
-        pid_t pid;
+    int32_t i = 0;
+    int child = -1;
+    int64_t pending_read = 0;
+    int64_t latency = -1;
+    int64_t least_latency = -1;
 
-        if (!hashmode) {
-                return -1;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (AFR_IS_ARBITER_BRICK(priv, i) || !readable[i] ||
+            priv->child_latency[i] < 0)
+            continue;
 
-        gf_uuid_copy (gfid_copy, args->gfid);
+        pending_read = GF_ATOMIC_GET(priv->pending_reads[i]);
+        latency = (pending_read + 1) * priv->child_latency[i];
 
-        if ((hashmode > 1) && (args->ia_type != IA_IFDIR)) {
+        if (child == -1 || latency < least_latency) {
+            least_latency = latency;
+            child = i;
+        }
+    }
+    return child;
+}
+
+int
+afr_hash_child(afr_read_subvol_args_t *args, afr_private_t *priv,
+               unsigned char *readable)
+{
+    uuid_t gfid_copy = {
+        0,
+    };
+    pid_t pid;
+    int child = -1;
+
+    switch (priv->hash_mode) {
+        case AFR_READ_POLICY_FIRST_UP:
+            break;
+        case AFR_READ_POLICY_GFID_HASH:
+            gf_uuid_copy(gfid_copy, args->gfid);
+            child = SuperFastHash((char *)gfid_copy, sizeof(gfid_copy)) %
+                    priv->child_count;
+            break;
+        case AFR_READ_POLICY_GFID_PID_HASH:
+            if (args->ia_type != IA_IFDIR) {
                 /*
                  * Why getpid?  Because it's one of the cheapest calls
-                 * available - faster than gethostname etc. - and returns a
-                 * constant-length value that's sure to be shorter than a UUID.
-                 * It's still very unlikely to be the same across clients, so
-                 * it still provides good mixing.  We're not trying for
-                 * perfection here.  All we need is a low probability that
-                 * multiple clients won't converge on the same subvolume.
+                 * available - faster than gethostname etc. - and
+                 * returns a constant-length value that's sure to be
+                 * shorter than a UUID. It's still very unlikely to be
+                 * the same across clients, so it still provides good
+                 * mixing.  We're not trying for perfection here. All we
+                 * need is a low probability that multiple clients
+                 * won't converge on the same subvolume.
                  */
+                gf_uuid_copy(gfid_copy, args->gfid);
                 pid = getpid();
-                memcpy (gfid_copy, &pid, sizeof(pid));
-        }
-
-        return SuperFastHash((char *)gfid_copy,
-                             sizeof(gfid_copy)) % child_count;
+                *(pid_t *)gfid_copy ^= pid;
+            }
+            child = SuperFastHash((char *)gfid_copy, sizeof(gfid_copy)) %
+                    priv->child_count;
+            break;
+        case AFR_READ_POLICY_LESS_LOAD:
+            child = afr_least_pending_reads_child(priv, readable);
+            break;
+        case AFR_READ_POLICY_LEAST_LATENCY:
+            child = afr_least_latency_child(priv, readable);
+            break;
+        case AFR_READ_POLICY_LOAD_LATENCY_HYBRID:
+            child = afr_least_latency_times_pending_reads_child(priv, readable);
+            break;
+    }
+
+    return child;
 }
 
-
 int
-afr_read_subvol_select_by_policy (inode_t *inode, xlator_t *this,
-				  unsigned char *readable,
-                                  afr_read_subvol_args_t *args)
+afr_read_subvol_select_by_policy(inode_t *inode, xlator_t *this,
+                                 unsigned char *readable,
+                                 afr_read_subvol_args_t *args)
 {
-	int             i           = 0;
-	int             read_subvol = -1;
-	afr_private_t  *priv        = NULL;
-        afr_read_subvol_args_t local_args = {0,};
+    int i = 0;
+    int read_subvol = -1;
+    afr_private_t *priv = NULL;
+    afr_read_subvol_args_t local_args = {
+        0,
+    };
 
-	priv = this->private;
+    priv = this->private;
 
-	/* first preference - explicitly specified or local subvolume */
-	if (priv->read_child >= 0 && readable[priv->read_child])
-                return priv->read_child;
+    /* first preference - explicitly specified or local subvolume */
+    if (priv->read_child >= 0 && readable[priv->read_child])
+        return priv->read_child;
 
-        if (inode_is_linked (inode)) {
-                gf_uuid_copy (local_args.gfid, inode->gfid);
-                local_args.ia_type = inode->ia_type;
-        } else if (args) {
-                local_args = *args;
-        }
+    if (inode_is_linked(inode)) {
+        gf_uuid_copy(local_args.gfid, inode->gfid);
+        local_args.ia_type = inode->ia_type;
+    } else if (args) {
+        local_args = *args;
+    }
 
-	/* second preference - use hashed mode */
-	read_subvol = afr_hash_child (&local_args, priv->child_count,
-                                      priv->hash_mode);
-	if (read_subvol >= 0 && readable[read_subvol])
-                return read_subvol;
+    /* second preference - use hashed mode */
+    read_subvol = afr_hash_child(&local_args, priv, readable);
+    if (read_subvol >= 0 && readable[read_subvol])
+        return read_subvol;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (readable[i])
-                return i;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (readable[i])
+            return i;
+    }
 
-        /* no readable subvolumes, either split brain or all subvols down */
+    /* no readable subvolumes, either split brain or all subvols down */
 
-        return -1;
+    return -1;
 }
 
-
 int
-afr_inode_read_subvol_type_get (inode_t *inode, xlator_t *this,
-				unsigned char *readable, int *event_p,
-				int type)
+afr_inode_read_subvol_type_get(inode_t *inode, xlator_t *this,
+                               unsigned char *readable, int *event_p, int type)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (type == AFR_METADATA_TRANSACTION)
-		ret = afr_inode_read_subvol_get (inode, this, 0, readable,
-						 event_p);
-	else
-		ret = afr_inode_read_subvol_get (inode, this, readable, 0,
-						 event_p);
-	return ret;
+    if (type == AFR_METADATA_TRANSACTION)
+        ret = afr_inode_read_subvol_get(inode, this, 0, readable, event_p);
+    else
+        ret = afr_inode_read_subvol_get(inode, this, readable, 0, event_p);
+    return ret;
 }
 
+void
+afr_readables_intersect_get(inode_t *inode, xlator_t *this, int *event,
+                            unsigned char *intersection)
+{
+    afr_private_t *priv = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    unsigned char *intersect = NULL;
 
-int
-afr_read_subvol_get (inode_t *inode, xlator_t *this, int *subvol_p,
-                     unsigned char *readables,
-		     int *event_p, afr_transaction_type type,
-                     afr_read_subvol_args_t *args)
-{
-	afr_private_t *priv = NULL;
-	unsigned char *data_readable = NULL;
-	unsigned char *metadata_readable = NULL;
-	unsigned char *readable = NULL;
-	unsigned char *intersection = NULL;
-	int subvol = -1;
-	int event = 0;
-
-	priv = this->private;
-
-	readable = alloca0 (priv->child_count);
-	data_readable = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-	intersection = alloca0 (priv->child_count);
-
-	afr_inode_read_subvol_type_get (inode, this, readable, &event, type);
-
-	afr_inode_read_subvol_get (inode, this, data_readable, metadata_readable,
-				   &event);
-
-	AFR_INTERSECT (intersection, data_readable, metadata_readable,
-		       priv->child_count);
-
-	if (AFR_COUNT (intersection, priv->child_count) > 0)
-		subvol = afr_read_subvol_select_by_policy (inode, this,
-							   intersection, args);
-	else
-		subvol = afr_read_subvol_select_by_policy (inode, this,
-							   readable, args);
-	if (subvol_p)
-		*subvol_p = subvol;
-	if (event_p)
-		*event_p = event;
-        if (readables)
-                memcpy (readables, readable,
-                        sizeof (*readables) * priv->child_count);
-	return subvol;
-}
+    priv = this->private;
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+    intersect = alloca0(priv->child_count);
 
+    afr_inode_read_subvol_get(inode, this, data_readable, metadata_readable,
+                              event);
 
-void
-afr_local_transaction_cleanup (afr_local_t *local, xlator_t *this)
-{
-        afr_private_t *priv    = NULL;
-        int           i        = 0;
+    AFR_INTERSECT(intersect, data_readable, metadata_readable,
+                  priv->child_count);
+    if (intersection)
+        memcpy(intersection, intersect,
+               sizeof(*intersection) * priv->child_count);
+}
 
-        priv = this->private;
+int
+afr_read_subvol_get(inode_t *inode, xlator_t *this, int *subvol_p,
+                    unsigned char *readables, int *event_p,
+                    afr_transaction_type type, afr_read_subvol_args_t *args)
+{
+    afr_private_t *priv = NULL;
+    unsigned char *readable = NULL;
+    unsigned char *intersection = NULL;
+    int subvol = -1;
+    int event = 0;
 
-        afr_matrix_cleanup (local->pending, priv->child_count);
+    priv = this->private;
 
-        GF_FREE (local->internal_lock.locked_nodes);
+    readable = alloca0(priv->child_count);
+    intersection = alloca0(priv->child_count);
 
-        for (i = 0; local->internal_lock.inodelk[i].domain; i++) {
-                GF_FREE (local->internal_lock.inodelk[i].locked_nodes);
-        }
+    afr_inode_read_subvol_type_get(inode, this, readable, &event, type);
 
-        GF_FREE (local->internal_lock.lower_locked_nodes);
+    afr_readables_intersect_get(inode, this, &event, intersection);
 
-        afr_entry_lockee_cleanup (&local->internal_lock);
+    if (AFR_COUNT(intersection, priv->child_count) > 0)
+        subvol = afr_read_subvol_select_by_policy(inode, this, intersection,
+                                                  args);
+    else
+        subvol = afr_read_subvol_select_by_policy(inode, this, readable, args);
+    if (subvol_p)
+        *subvol_p = subvol;
+    if (event_p)
+        *event_p = event;
+    if (readables)
+        memcpy(readables, readable, sizeof(*readables) * priv->child_count);
+    return subvol;
+}
 
-        GF_FREE (local->transaction.pre_op);
+void
+afr_local_transaction_cleanup(afr_local_t *local, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-        GF_FREE (local->transaction.pre_op_sources);
-        if (local->transaction.pre_op_xdata) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->transaction.pre_op_xdata[i])
-                                continue;
-                        dict_unref (local->transaction.pre_op_xdata[i]);
-                }
-                GF_FREE (local->transaction.pre_op_xdata);
-        }
+    priv = this->private;
 
-        GF_FREE (local->transaction.eager_lock);
-        GF_FREE (local->transaction.failed_subvols);
+    afr_matrix_cleanup(local->pending, priv->child_count);
 
-        GF_FREE (local->transaction.basename);
-        GF_FREE (local->transaction.new_basename);
+    GF_FREE(local->internal_lock.lower_locked_nodes);
 
-        loc_wipe (&local->transaction.parent_loc);
-        loc_wipe (&local->transaction.new_parent_loc);
+    afr_lockees_cleanup(&local->internal_lock);
 
-}
+    GF_FREE(local->transaction.pre_op);
 
-void
-afr_reply_wipe (struct afr_reply *reply)
-{
-        if (reply->xdata) {
-                dict_unref (reply->xdata);
-                reply->xdata = NULL;
+    GF_FREE(local->transaction.pre_op_sources);
+    if (local->transaction.changelog_xdata) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (!local->transaction.changelog_xdata[i])
+                continue;
+            dict_unref(local->transaction.changelog_xdata[i]);
         }
+        GF_FREE(local->transaction.changelog_xdata);
+    }
 
-        if (reply->xattr) {
-                dict_unref (reply->xattr);
-                reply->xattr = NULL;
-        }
+    GF_FREE(local->transaction.failed_subvols);
+
+    GF_FREE(local->transaction.basename);
+    GF_FREE(local->transaction.new_basename);
+
+    loc_wipe(&local->transaction.parent_loc);
+    loc_wipe(&local->transaction.new_parent_loc);
 }
 
 void
-afr_replies_wipe (struct afr_reply *replies, int count)
+afr_reply_wipe(struct afr_reply *reply)
 {
-        int i = 0;
+    if (reply->xdata) {
+        dict_unref(reply->xdata);
+        reply->xdata = NULL;
+    }
 
-        for (i = 0; i < count; i++) {
-                afr_reply_wipe (&replies[i]);
-        }
+    if (reply->xattr) {
+        dict_unref(reply->xattr);
+        reply->xattr = NULL;
+    }
 }
 
 void
-afr_local_replies_wipe (afr_local_t *local, afr_private_t *priv)
+afr_replies_wipe(struct afr_reply *replies, int count)
 {
+    int i = 0;
 
-	if (!local->replies)
-		return;
-
-        afr_replies_wipe (local->replies, priv->child_count);
-
-	memset (local->replies, 0, sizeof(*local->replies) * priv->child_count);
+    for (i = 0; i < count; i++) {
+        afr_reply_wipe(&replies[i]);
+    }
 }
 
 void
-afr_remove_eager_lock_stub (afr_local_t *local)
+afr_local_replies_wipe(afr_local_t *local, afr_private_t *priv)
 {
-        LOCK (&local->fd->lock);
-        {
-                list_del_init (&local->transaction.eager_locked);
-        }
-        UNLOCK (&local->fd->lock);
+    if (!local->replies)
+        return;
+
+    afr_replies_wipe(local->replies, priv->child_count);
+
+    memset(local->replies, 0, sizeof(*local->replies) * priv->child_count);
 }
 
 static gf_boolean_t
-afr_fop_lock_is_unlock (call_frame_t *frame)
+afr_fop_lock_is_unlock(call_frame_t *frame)
 {
-        afr_local_t *local = frame->local;
-        switch (local->op) {
+    afr_local_t *local = frame->local;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                if ((F_UNLCK == local->cont.inodelk.in_flock.l_type) &&
-                   (local->cont.inodelk.in_cmd == F_SETLKW ||
-                    local->cont.inodelk.in_cmd == F_SETLK))
-                        return _gf_true;
-                break;
+            if ((F_UNLCK == local->cont.inodelk.in_flock.l_type) &&
+                (local->cont.inodelk.in_cmd == F_SETLKW ||
+                 local->cont.inodelk.in_cmd == F_SETLK))
+                return _gf_true;
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                if (ENTRYLK_UNLOCK == local->cont.entrylk.in_cmd)
-                        return _gf_true;
-                break;
+            if (ENTRYLK_UNLOCK == local->cont.entrylk.in_cmd)
+                return _gf_true;
+            break;
         default:
-                return _gf_false;
-        }
-        return _gf_false;
+            return _gf_false;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_lk_is_unlock (int32_t cmd, struct gf_flock *flock)
+afr_lk_is_unlock(int32_t cmd, struct gf_flock *flock)
 {
-        switch (cmd) {
+    switch (cmd) {
         case F_RESLK_UNLCK:
-                return _gf_true;
-                break;
+            return _gf_true;
+            break;
 
 #if F_SETLKW != F_SETLKW64
         case F_SETLKW64:
@@ -1782,509 +2548,573 @@ afr_lk_is_unlock (int32_t cmd, struct gf_flock *flock)
         case F_SETLK64:
 #endif
         case F_SETLK:
-                if (F_UNLCK == flock->l_type)
-                        return _gf_true;
-                break;
+            if (F_UNLCK == flock->l_type)
+                return _gf_true;
+            break;
         default:
-                return _gf_false;
-        }
-        return _gf_false;
+            return _gf_false;
+    }
+    return _gf_false;
 }
 
 void
-afr_handle_inconsistent_fop (call_frame_t *frame, int32_t *op_ret,
-                             int32_t *op_errno)
+afr_handle_inconsistent_fop(call_frame_t *frame, int32_t *op_ret,
+                            int32_t *op_errno)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t   *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        if (!frame || !frame->this || !frame->local || !frame->this->private)
-                return;
+    if (!frame || !frame->this || !frame->local || !frame->this->private)
+        return;
 
-        if (*op_ret < 0)
-                return;
+    if (*op_ret < 0)
+        return;
 
-        /* Failing inodelk/entrylk/lk here is not a good idea because we
-         * need to cleanup the locks on the other bricks if we choose to fail
-         * the fop here. The brick may go down just after unwind happens as well
-         * so anyways the fop will fail when the next fop is sent so leaving
-         * it like this for now.*/
-        local = frame->local;
-        switch (local->op) {
+    /* Failing inodelk/entrylk/lk here is not a good idea because we
+     * need to cleanup the locks on the other bricks if we choose to fail
+     * the fop here. The brick may go down just after unwind happens as well
+     * so anyways the fop will fail when the next fop is sent so leaving
+     * it like this for now.*/
+    local = frame->local;
+    switch (local->op) {
         case GF_FOP_LOOKUP:
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
         case GF_FOP_LK:
-                return;
+            return;
         default:
-                break;
-        }
+            break;
+    }
 
-        priv = frame->this->private;
-        if (!priv->consistent_io)
-                return;
+    priv = frame->this->private;
+    if (!priv->consistent_io)
+        return;
 
-        if (local->event_generation &&
-            (local->event_generation != priv->event_generation))
-                goto inconsistent;
+    if (local->event_generation &&
+        (local->event_generation != priv->event_generation))
+        goto inconsistent;
 
-        return;
+    return;
 inconsistent:
-        *op_ret = -1;
-        *op_errno = ENOTCONN;
+    *op_ret = -1;
+    *op_errno = ENOTCONN;
 }
 
 void
-afr_local_cleanup (afr_local_t *local, xlator_t *this)
+afr_local_cleanup(afr_local_t *local, xlator_t *this)
 {
-        afr_private_t * priv = NULL;
-
-        if (!local)
-                return;
-
-	syncbarrier_destroy (&local->barrier);
-
-        if (local->transaction.eager_lock_on &&
-            !list_empty (&local->transaction.eager_locked))
-                afr_remove_eager_lock_stub (local);
-
-        afr_local_transaction_cleanup (local, this);
-
-        priv = this->private;
-
-        loc_wipe (&local->loc);
-        loc_wipe (&local->newloc);
+    afr_private_t *priv = NULL;
 
-        if (local->fd)
-                fd_unref (local->fd);
-
-        if (local->xattr_req)
-                dict_unref (local->xattr_req);
-
-        if (local->xattr_rsp)
-                dict_unref (local->xattr_rsp);
+    if (!local)
+        return;
 
-        if (local->dict)
-                dict_unref (local->dict);
+    syncbarrier_destroy(&local->barrier);
 
-        afr_local_replies_wipe (local, priv);
-	GF_FREE(local->replies);
+    afr_local_transaction_cleanup(local, this);
 
-        GF_FREE (local->child_up);
+    priv = this->private;
 
-        GF_FREE (local->read_attempted);
+    loc_wipe(&local->loc);
+    loc_wipe(&local->newloc);
 
-        GF_FREE (local->readable);
-        GF_FREE (local->readable2);
+    if (local->fd)
+        fd_unref(local->fd);
 
-	if (local->inode)
-		inode_unref (local->inode);
+    if (local->xattr_req)
+        dict_unref(local->xattr_req);
 
-	if (local->parent)
-		inode_unref (local->parent);
+    if (local->xattr_rsp)
+        dict_unref(local->xattr_rsp);
 
-	if (local->parent2)
-		inode_unref (local->parent2);
+    if (local->dict)
+        dict_unref(local->dict);
 
-	if (local->refreshinode)
-		inode_unref (local->refreshinode);
+    afr_local_replies_wipe(local, priv);
+    GF_FREE(local->replies);
 
-        { /* getxattr */
-                GF_FREE (local->cont.getxattr.name);
-        }
+    GF_FREE(local->child_up);
 
-        { /* lk */
-                GF_FREE (local->cont.lk.locked_nodes);
-        }
+    GF_FREE(local->read_attempted);
+
+    GF_FREE(local->readable);
+    GF_FREE(local->readable2);
+
+    if (local->inode)
+        inode_unref(local->inode);
 
-        { /* create */
-                if (local->cont.create.fd)
-                        fd_unref (local->cont.create.fd);
-                if (local->cont.create.params)
-                        dict_unref (local->cont.create.params);
-        }
+    if (local->parent)
+        inode_unref(local->parent);
 
-        { /* mknod */
-                if (local->cont.mknod.params)
-                        dict_unref (local->cont.mknod.params);
-        }
+    if (local->parent2)
+        inode_unref(local->parent2);
 
-        { /* mkdir */
-                if (local->cont.mkdir.params)
-                        dict_unref (local->cont.mkdir.params);
-        }
+    if (local->refreshinode)
+        inode_unref(local->refreshinode);
 
-        { /* symlink */
-                if (local->cont.symlink.params)
-                        dict_unref (local->cont.symlink.params);
-        }
+    { /* getxattr */
+        GF_FREE(local->cont.getxattr.name);
+    }
 
-        { /* writev */
-                GF_FREE (local->cont.writev.vector);
-                if (local->cont.writev.iobref)
-                        iobref_unref (local->cont.writev.iobref);
-        }
+    { /* lk */
+        GF_FREE(local->cont.lk.locked_nodes);
+        GF_FREE(local->cont.lk.dom_locked_nodes);
+        GF_FREE(local->cont.lk.dom_lock_op_ret);
+        GF_FREE(local->cont.lk.dom_lock_op_errno);
+    }
 
-        { /* setxattr */
-                if (local->cont.setxattr.dict)
-                        dict_unref (local->cont.setxattr.dict);
-        }
+    { /* create */
+        if (local->cont.create.fd)
+            fd_unref(local->cont.create.fd);
+        if (local->cont.create.params)
+            dict_unref(local->cont.create.params);
+    }
 
-        { /* fsetxattr */
-                if (local->cont.fsetxattr.dict)
-                        dict_unref (local->cont.fsetxattr.dict);
-        }
+    { /* mknod */
+        if (local->cont.mknod.params)
+            dict_unref(local->cont.mknod.params);
+    }
 
-        { /* removexattr */
-                GF_FREE (local->cont.removexattr.name);
-        }
-        { /* xattrop */
-                if (local->cont.xattrop.xattr)
-                        dict_unref (local->cont.xattrop.xattr);
-        }
-        { /* symlink */
-                GF_FREE (local->cont.symlink.linkpath);
-        }
+    { /* mkdir */
+        if (local->cont.mkdir.params)
+            dict_unref(local->cont.mkdir.params);
+    }
 
-        { /* opendir */
-                GF_FREE (local->cont.opendir.checksum);
-        }
+    { /* symlink */
+        if (local->cont.symlink.params)
+            dict_unref(local->cont.symlink.params);
+    }
 
-        { /* readdirp */
-                if (local->cont.readdir.dict)
-                        dict_unref (local->cont.readdir.dict);
-        }
+    { /* writev */
+        GF_FREE(local->cont.writev.vector);
+        if (local->cont.writev.iobref)
+            iobref_unref(local->cont.writev.iobref);
+    }
 
-        { /* inodelk */
-                GF_FREE (local->cont.inodelk.volume);
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-        }
+    { /* setxattr */
+        if (local->cont.setxattr.dict)
+            dict_unref(local->cont.setxattr.dict);
+    }
 
-        { /* entrylk */
-                GF_FREE (local->cont.entrylk.volume);
-                GF_FREE (local->cont.entrylk.basename);
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-        }
+    { /* fsetxattr */
+        if (local->cont.fsetxattr.dict)
+            dict_unref(local->cont.fsetxattr.dict);
+    }
 
-        if (local->xdata_req)
-                dict_unref (local->xdata_req);
+    { /* removexattr */
+        GF_FREE(local->cont.removexattr.name);
+    }
+    { /* xattrop */
+        if (local->cont.xattrop.xattr)
+            dict_unref(local->cont.xattrop.xattr);
+    }
+    { /* symlink */
+        GF_FREE(local->cont.symlink.linkpath);
+    }
 
-        if (local->xdata_rsp)
-                dict_unref (local->xdata_rsp);
+    { /* opendir */
+        GF_FREE(local->cont.opendir.checksum);
+    }
+
+    { /* open */
+        if (local->cont.open.fd)
+            fd_unref(local->cont.open.fd);
+    }
+
+    { /* readdirp */
+        if (local->cont.readdir.dict)
+            dict_unref(local->cont.readdir.dict);
+    }
+
+    { /* inodelk */
+        GF_FREE(local->cont.inodelk.volume);
+        if (local->cont.inodelk.xdata)
+            dict_unref(local->cont.inodelk.xdata);
+    }
+
+    { /* entrylk */
+        GF_FREE(local->cont.entrylk.volume);
+        GF_FREE(local->cont.entrylk.basename);
+        if (local->cont.entrylk.xdata)
+            dict_unref(local->cont.entrylk.xdata);
+    }
+
+    if (local->xdata_req)
+        dict_unref(local->xdata_req);
+
+    if (local->xdata_rsp)
+        dict_unref(local->xdata_rsp);
 }
 
-
 int
-afr_frame_return (call_frame_t *frame)
+afr_frame_return(call_frame_t *frame)
 {
-        afr_local_t *local = NULL;
-        int          call_count = 0;
+    afr_local_t *local = NULL;
+    int call_count = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                call_count = --local->call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        return call_count;
+    return call_count;
 }
 
-static char *afr_ignore_xattrs[] = {
-        GF_SELINUX_XATTR_KEY,
-        QUOTA_SIZE_KEY,
-        NULL
-};
+static char *afr_ignore_xattrs[] = {GF_SELINUX_XATTR_KEY, QUOTA_SIZE_KEY, NULL};
 
 gf_boolean_t
-afr_is_xattr_ignorable (char *key)
+afr_is_xattr_ignorable(char *key)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!strncmp (key, AFR_XATTR_PREFIX, strlen(AFR_XATTR_PREFIX)))
-                return _gf_true;
-        for (i = 0; afr_ignore_xattrs[i]; i++) {
-                if (!strcmp (key, afr_ignore_xattrs[i]))
-                       return _gf_true;
-        }
-        return _gf_false;
+    if (!strncmp(key, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX)))
+        return _gf_true;
+    for (i = 0; afr_ignore_xattrs[i]; i++) {
+        if (!strcmp(key, afr_ignore_xattrs[i]))
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_xattr_match_needed (dict_t *this, char *key1, data_t *value1, void *data)
+afr_xattr_match_needed(dict_t *this, char *key1, data_t *value1, void *data)
 {
-        /* Ignore all non-disk (i.e. virtual) xattrs right away. */
-        if (!gf_is_valid_xattr_namespace (key1))
-                return _gf_false;
+    /* Ignore all non-disk (i.e. virtual) xattrs right away. */
+    if (!gf_is_valid_xattr_namespace(key1))
+        return _gf_false;
 
-        /* Ignore on-disk xattrs that AFR doesn't need to heal. */
-        if (!afr_is_xattr_ignorable (key1))
-                return _gf_true;
+    /* Ignore on-disk xattrs that AFR doesn't need to heal. */
+    if (!afr_is_xattr_ignorable(key1))
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 gf_boolean_t
-afr_xattrs_are_equal (dict_t *dict1, dict_t *dict2)
+afr_xattrs_are_equal(dict_t *dict1, dict_t *dict2)
 {
-        return are_dicts_equal (dict1, dict2, afr_xattr_match_needed, NULL);
+    return are_dicts_equal(dict1, dict2, afr_xattr_match_needed, NULL);
 }
 
 static int
-afr_get_parent_read_subvol (xlator_t *this, inode_t *parent,
-                            struct afr_reply *replies, unsigned char *readable)
+afr_get_parent_read_subvol(xlator_t *this, inode_t *parent,
+                           struct afr_reply *replies, unsigned char *readable)
 {
-        int             i                    = 0;
-        int             par_read_subvol      = -1;
-        int             par_read_subvol_iter = -1;
-        afr_private_t  *priv                 = NULL;
-
-        priv = this->private;
-
-        if (parent)
-                par_read_subvol = afr_data_subvol_get (parent, this, NULL, NULL,
-                                                       NULL, NULL);
+    int i = 0;
+    int par_read_subvol = -1;
+    int par_read_subvol_iter = -1;
+    afr_private_t *priv = NULL;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid)
-                        continue;
+    priv = this->private;
 
-                if (replies[i].op_ret < 0)
-                        continue;
+    if (parent)
+        par_read_subvol = afr_data_subvol_get(parent, this, NULL, NULL, NULL,
+                                              NULL);
 
-                if (par_read_subvol_iter == -1) {
-                        par_read_subvol_iter = i;
-                        continue;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if ((par_read_subvol_iter != par_read_subvol) && readable[i])
-                        par_read_subvol_iter = i;
+        if (replies[i].op_ret < 0)
+            continue;
 
-                if (i == par_read_subvol)
-                        par_read_subvol_iter = i;
+        if (par_read_subvol_iter == -1) {
+            par_read_subvol_iter = i;
+            continue;
         }
-        /* At the end of the for-loop, the only reason why @par_read_subvol_iter
-         * could be -1 is when this LOOKUP has failed on all sub-volumes.
-         * So it is okay to send an arbitrary subvolume (0 in this case)
-         * as parent read subvol.
-         */
-        if (par_read_subvol_iter == -1)
-                par_read_subvol_iter = 0;
 
-        return par_read_subvol_iter;
+        if ((par_read_subvol_iter != par_read_subvol) && readable[i])
+            par_read_subvol_iter = i;
 
+        if (i == par_read_subvol)
+            par_read_subvol_iter = i;
+    }
+    /* At the end of the for-loop, the only reason why @par_read_subvol_iter
+     * could be -1 is when this LOOKUP has failed on all sub-volumes.
+     * So it is okay to send an arbitrary subvolume (0 in this case)
+     * as parent read subvol.
+     */
+    if (par_read_subvol_iter == -1)
+        par_read_subvol_iter = 0;
+
+    return par_read_subvol_iter;
 }
 
 int
-afr_read_subvol_decide (inode_t *inode, xlator_t *this,
-                        afr_read_subvol_args_t *args)
+afr_read_subvol_decide(inode_t *inode, xlator_t *this,
+                       afr_read_subvol_args_t *args, unsigned char *readable)
 {
-        int data_subvol  = -1;
-        int mdata_subvol = -1;
+    int event = 0;
+    afr_private_t *priv = NULL;
+    unsigned char *intersection = NULL;
+
+    priv = this->private;
+    intersection = alloca0(priv->child_count);
+
+    afr_readables_intersect_get(inode, this, &event, intersection);
 
-        data_subvol = afr_data_subvol_get (inode, this, NULL, NULL, NULL, args);
-        mdata_subvol = afr_metadata_subvol_get (inode, this,
-                                                NULL, NULL, NULL, args);
-        if (data_subvol == -1 || mdata_subvol == -1)
-                return -1;
+    if (AFR_COUNT(intersection, priv->child_count) <= 0) {
+        /* TODO: If we have one brick with valid data_readable and
+         * another with metadata_readable, try to send an iatt with
+         * valid bits from both.*/
+        return -1;
+    }
+
+    memcpy(readable, intersection, sizeof(*readable) * priv->child_count);
 
-        return data_subvol;
+    return afr_read_subvol_select_by_policy(inode, this, intersection, args);
 }
 
 static inline int
-afr_first_up_child (call_frame_t *frame, xlator_t *this)
+afr_first_up_child(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-        int                  i     = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++)
-                if (local->replies[i].valid &&
-                    local->replies[i].op_ret == 0)
-                        return i;
-        return 0;
+    for (i = 0; i < priv->child_count; i++)
+        if (local->replies[i].valid && local->replies[i].op_ret == 0)
+            return i;
+    return -1;
 }
 
 static void
-afr_lookup_done (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-	int                 i = -1;
-	int                 op_errno = 0;
-	int                 read_subvol = 0;
-        int                 par_read_subvol = 0;
-        int                 ret         = -1;
-	unsigned char      *readable = NULL;
-	int                 event = 0;
-	struct afr_reply   *replies = NULL;
-	uuid_t              read_gfid = {0, };
-	gf_boolean_t        locked_entry = _gf_false;
-	gf_boolean_t        can_interpret = _gf_true;
-        inode_t            *parent = NULL;
-        int                 spb_choice = -1;
-        ia_type_t           ia_type = IA_INVAL;
-        afr_read_subvol_args_t args = {0,};
-        char               *gfid_heal_msg = NULL;
-
-        priv  = this->private;
-        local = frame->local;
-	replies = local->replies;
-        parent = local->loc.parent;
-
-	locked_entry = afr_is_possibly_under_txn (AFR_ENTRY_TRANSACTION, local,
-                                                  this);
-
-	readable = alloca0 (priv->child_count);
-
-	afr_inode_read_subvol_get (parent, this, readable, NULL, &event);
-
-        afr_inode_split_brain_choice_get (local->inode, this,
-                                                &spb_choice);
-	/* First, check if we have a gfid-change from somewhere,
-	   If so, propagate that so that a fresh lookup can be
-	   issued
-	*/
-        if (local->cont.lookup.needs_fresh_lookup) {
-                local->op_ret = -1;
-                local->op_errno = ESTALE;
-                goto unwind;
-        }
-
-	op_errno = afr_final_errno (frame->local, this->private);
-	local->op_errno = op_errno;
-
-	read_subvol = -1;
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-		if (locked_entry && replies[i].op_ret == -1 &&
-		    replies[i].op_errno == ENOENT) {
-			/* Second, check entry is still
-			   "underway" in creation */
-			local->op_ret = -1;
-			local->op_errno = ENOENT;
-			goto unwind;
-		}
-
-		if (replies[i].op_ret == -1)
-			continue;
-
-		if (read_subvol == -1 || !readable[read_subvol]) {
-			read_subvol = i;
-			gf_uuid_copy (read_gfid, replies[i].poststat.ia_gfid);
-                        ia_type = replies[i].poststat.ia_type;
-			local->op_ret = 0;
-		}
-	}
-
-	if (read_subvol == -1)
-		goto unwind;
-	/* We now have a read_subvol, which is readable[] (if there
-	   were any). Next we look for GFID mismatches. We don't
-	   consider a GFID mismatch as an error if read_subvol is
-	   readable[] but the mismatching GFID subvol is not.
-	*/
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid || replies[i].op_ret == -1) {
-			if (priv->child_up[i])
-				can_interpret = _gf_false;
-			continue;
-		}
-
-		if (!gf_uuid_compare (replies[i].poststat.ia_gfid, read_gfid))
-                        continue;
-
-		can_interpret = _gf_false;
-
-		if (locked_entry)
-			continue;
-
-		/* Now GFIDs mismatch. It's OK as long as this subvol
-		   is not readable[] but read_subvol is */
-		if (readable[read_subvol] && !readable[i])
-			continue;
-
-		/* LOG ERROR */
-		local->op_ret = -1;
-		local->op_errno = EIO;
-		goto unwind;
-	}
-
-	/* Forth, for the finalized GFID, pick the best subvolume
-	   to return stats from.
-	*/
-	if (can_interpret) {
-		/* It is safe to call afr_replies_interpret() because we have
-		   a response from all the UP subvolumes and all of them resolved
-		   to the same GFID
-		*/
-                gf_uuid_copy (args.gfid, read_gfid);
-                args.ia_type = ia_type;
-		if (afr_replies_interpret (frame, this, local->inode, NULL)) {
-                        read_subvol = afr_read_subvol_decide (local->inode,
-                                                              this, &args);
-			afr_inode_event_gen_reset (local->inode, this);
-			goto cant_interpret;
-		} else {
-                        read_subvol = afr_data_subvol_get (local->inode, this,
-                                                       NULL, NULL, NULL, &args);
-		}
-	} else {
-	cant_interpret:
-                if (read_subvol == -1) {
-                        if (spb_choice >= 0)
-                                read_subvol = spb_choice;
-                        else
-                                read_subvol = afr_first_up_child (frame, this);
-                }
-		dict_del (replies[read_subvol].xdata, GF_CONTENT_KEY);
-	}
+afr_attempt_readsubvol_set(call_frame_t *frame, xlator_t *this,
+                           unsigned char *success_replies,
+                           unsigned char *data_readable, int *read_subvol)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int spb_subvol = -1;
+    int child_count = -1;
 
-	afr_handle_quota_size (frame, this);
+    if (*read_subvol != -1)
+        return;
 
-unwind:
-        afr_set_need_heal (this, local);
-        if (read_subvol == -1) {
-                if (spb_choice >= 0)
-                        read_subvol = spb_choice;
-                else
-                        read_subvol = afr_first_up_child (frame, this);
+    priv = this->private;
+    local = frame->local;
+    child_count = priv->child_count;
+
+    afr_split_brain_read_subvol_get(local->inode, this, frame, &spb_subvol);
+    if ((spb_subvol >= 0) &&
+        (AFR_COUNT(success_replies, child_count) == child_count)) {
+        *read_subvol = spb_subvol;
+    } else if (!priv->quorum_count ||
+               frame->root->pid == GF_CLIENT_PID_GLFS_HEAL) {
+        *read_subvol = afr_first_up_child(frame, this);
+    } else if (priv->quorum_count &&
+               afr_has_quorum(data_readable, this, NULL)) {
+        /* read_subvol is guaranteed to be valid if we hit this path. */
+        *read_subvol = afr_first_up_child(frame, this);
+    } else {
+        /* If quorum is enabled and we do not have a
+           readable yet, it means all good copies are down.
+        */
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_READ_SUBVOL_ERROR,
+               "no read "
+               "subvols for %s",
+               local->loc.path);
+    }
+    if (*read_subvol >= 0)
+        dict_del_sizen(local->replies[*read_subvol].xdata, GF_CONTENT_KEY);
+}
+
+static void
+afr_lookup_done(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = -1;
+    int op_errno = 0;
+    int read_subvol = 0;
+    int par_read_subvol = 0;
+    int ret = -1;
+    unsigned char *readable = NULL;
+    unsigned char *success_replies = NULL;
+    int event = 0;
+    struct afr_reply *replies = NULL;
+    uuid_t read_gfid = {
+        0,
+    };
+    gf_boolean_t locked_entry = _gf_false;
+    gf_boolean_t in_flight_create = _gf_false;
+    gf_boolean_t can_interpret = _gf_true;
+    inode_t *parent = NULL;
+    ia_type_t ia_type = IA_INVAL;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+    char *gfid_heal_msg = NULL;
+
+    priv = this->private;
+    local = frame->local;
+    replies = local->replies;
+    parent = local->loc.parent;
+
+    locked_entry = afr_is_possibly_under_txn(AFR_ENTRY_TRANSACTION, local,
+                                             this);
+
+    readable = alloca0(priv->child_count);
+    success_replies = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(parent, this, readable, NULL, &event);
+    par_read_subvol = afr_get_parent_read_subvol(this, parent, replies,
+                                                 readable);
+
+    /* First, check if we have a gfid-change from somewhere,
+       If so, propagate that so that a fresh lookup can be
+       issued
+    */
+    if (local->cont.lookup.needs_fresh_lookup) {
+        local->op_ret = -1;
+        local->op_errno = ESTALE;
+        goto error;
+    }
+
+    op_errno = afr_final_errno(frame->local, this->private);
+    local->op_errno = op_errno;
+
+    read_subvol = -1;
+    afr_fill_success_replies(local, priv, success_replies);
 
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret == -1) {
+            if (locked_entry && replies[i].op_errno == ENOENT) {
+                in_flight_create = _gf_true;
+            }
+            continue;
         }
-        par_read_subvol = afr_get_parent_read_subvol (this, parent, replies,
-                                                      readable);
-        if (AFR_IS_ARBITER_BRICK (priv, read_subvol) && local->op_ret == 0) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOTCONN;
+
+        if (read_subvol == -1 || !readable[read_subvol]) {
+            read_subvol = i;
+            gf_uuid_copy(read_gfid, replies[i].poststat.ia_gfid);
+            ia_type = replies[i].poststat.ia_type;
+            local->op_ret = 0;
         }
+    }
 
-        ret = dict_get_str (local->xattr_req, "gfid-heal-msg", &gfid_heal_msg);
-        if (!ret) {
-                ret = dict_set_str (local->replies[read_subvol].xdata,
-                                    "gfid-heal-msg", gfid_heal_msg);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_DICT_SET_FAILED,
-                                "Error setting gfid-heal-msg dict");
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                }
+    if (in_flight_create && !afr_has_quorum(success_replies, this, NULL)) {
+        local->op_ret = -1;
+        local->op_errno = ENOENT;
+        goto error;
+    }
+
+    if (read_subvol == -1)
+        goto error;
+    /* We now have a read_subvol, which is readable[] (if there
+       were any). Next we look for GFID mismatches. We don't
+       consider a GFID mismatch as an error if read_subvol is
+       readable[] but the mismatching GFID subvol is not.
+    */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1) {
+            continue;
+        }
+
+        if (!gf_uuid_compare(replies[i].poststat.ia_gfid, read_gfid))
+            continue;
+
+        can_interpret = _gf_false;
+
+        if (locked_entry)
+            continue;
+
+        /* Now GFIDs mismatch. It's OK as long as this subvol
+           is not readable[] but read_subvol is */
+        if (readable[read_subvol] && !readable[i])
+            continue;
+
+        /* If we were called from glfsheal and there is still a gfid
+         * mismatch, succeed the lookup and let glfsheal print the
+         * response via gfid-heal-msg.*/
+        if (!dict_get_str_sizen(local->xattr_req, "gfid-heal-msg",
+                                &gfid_heal_msg))
+            goto cant_interpret;
+
+        /* LOG ERROR */
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        goto error;
+    }
+
+    /* Forth, for the finalized GFID, pick the best subvolume
+       to return stats from.
+    */
+    read_subvol = -1;
+    memset(readable, 0, sizeof(*readable) * priv->child_count);
+    if (can_interpret) {
+        if (!afr_has_quorum(success_replies, this, NULL))
+            goto cant_interpret;
+        /* It is safe to call afr_replies_interpret() because we have
+           a response from all the UP subvolumes and all of them resolved
+           to the same GFID
+        */
+        gf_uuid_copy(args.gfid, read_gfid);
+        args.ia_type = ia_type;
+        ret = afr_replies_interpret(frame, this, local->inode, NULL);
+        read_subvol = afr_read_subvol_decide(local->inode, this, &args,
+                                             readable);
+        if (read_subvol == -1)
+            goto cant_interpret;
+        if (ret) {
+            afr_inode_need_refresh_set(local->inode, this);
+            dict_del_sizen(local->replies[read_subvol].xdata, GF_CONTENT_KEY);
         }
+    } else {
+    cant_interpret:
+        afr_attempt_readsubvol_set(frame, this, success_replies, readable,
+                                   &read_subvol);
+        if (read_subvol == -1) {
+            goto error;
+        }
+    }
+
+    afr_handle_quota_size(frame, this);
 
-	AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-			  local->inode, &local->replies[read_subvol].poststat,
-			  local->replies[read_subvol].xdata,
-			  &local->replies[par_read_subvol].postparent);
+    afr_set_need_heal(this, local);
+    if (AFR_IS_ARBITER_BRICK(priv, read_subvol) && local->op_ret == 0) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg_debug(this->name, 0,
+                     "Arbiter cannot be a read subvol "
+                     "for %s",
+                     local->loc.path);
+        goto error;
+    }
+
+    ret = dict_get_str_sizen(local->xattr_req, "gfid-heal-msg", &gfid_heal_msg);
+    if (!ret) {
+        ret = dict_set_str_sizen(local->replies[read_subvol].xdata,
+                                 "gfid-heal-msg", gfid_heal_msg);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting gfid-heal-msg dict");
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        }
+    }
+
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->replies[read_subvol].poststat,
+                     local->replies[read_subvol].xdata,
+                     &local->replies[par_read_subvol].postparent);
+    return;
+
+error:
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno, NULL, NULL,
+                     NULL, NULL);
 }
 
 /*
@@ -2292,676 +3122,845 @@ unwind:
  * others in that they must be given higher priority while
  * returning to the user.
  *
- * The hierarchy is ENODATA > ENOENT > ESTALE > others
+ * The hierarchy is ENODATA > ENOENT > ESTALE > ENOSPC others
  */
 
 int
-afr_higher_errno (int32_t old_errno, int32_t new_errno)
+afr_higher_errno(int32_t old_errno, int32_t new_errno)
 {
-	if (old_errno == ENODATA || new_errno == ENODATA)
-		return ENODATA;
-        if (old_errno == ENOENT || new_errno == ENOENT)
-                return ENOENT;
-	if (old_errno == ESTALE || new_errno == ESTALE)
-		return ESTALE;
+    if (old_errno == ENODATA || new_errno == ENODATA)
+        return ENODATA;
+    if (old_errno == ENOENT || new_errno == ENOENT)
+        return ENOENT;
+    if (old_errno == ESTALE || new_errno == ESTALE)
+        return ESTALE;
+    if (old_errno == ENOSPC || new_errno == ENOSPC)
+        return ENOSPC;
 
-	return new_errno;
+    return new_errno;
 }
 
-
 int
-afr_final_errno (afr_local_t *local, afr_private_t *priv)
+afr_final_errno(afr_local_t *local, afr_private_t *priv)
 {
-	int i = 0;
-	int op_errno = 0;
-	int tmp_errno = 0;
+    int i = 0;
+    int op_errno = 0;
+    int tmp_errno = 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret >= 0)
-			continue;
-		tmp_errno = local->replies[i].op_errno;
-		op_errno = afr_higher_errno (op_errno, tmp_errno);
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret >= 0)
+            continue;
+        tmp_errno = local->replies[i].op_errno;
+        op_errno = afr_higher_errno(op_errno, tmp_errno);
+    }
 
-	return op_errno;
+    return op_errno;
 }
 
 static int32_t
-afr_local_discovery_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			 int32_t op_ret, int32_t op_errno, dict_t *dict,
-			 dict_t *xdata)
-{
-        int              ret            = 0;
-        char            *pathinfo       = NULL;
-        gf_boolean_t     is_local        = _gf_false;
-        afr_private_t   *priv           = NULL;
-        int32_t          child_index    = -1;
-
-        if (op_ret != 0) {
-                goto out;
-        }
-
-	priv = this->private;
-	child_index = (int32_t)(long)cookie;
-
-        ret = dict_get_str (dict, GF_XATTR_PATHINFO_KEY, &pathinfo);
-        if (ret != 0) {
-                goto out;
-        }
-
-        ret = glusterfs_is_local_pathinfo (pathinfo, &is_local);
-        if (ret) {
-                goto out;
-        }
-
-        /*
-         * Note that one local subvolume will override another here.  The only
-         * way to avoid that would be to retain extra information about whether
-         * the previous read_child is local, and it's just not worth it.  Even
-         * the slowest local subvolume is far preferable to a remote one.
-         */
-        if (is_local) {
-                priv->local[child_index] = 1;
-                /* Don't set arbiter as read child. */
-                if (AFR_IS_ARBITER_BRICK(priv, child_index))
-                        goto out;
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_LOCAL_CHILD, "selecting local read_child %s",
-                        priv->children[child_index]->name);
-
-                priv->read_child = child_index;
-        }
+afr_local_discovery_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *dict,
+                        dict_t *xdata)
+{
+    int ret = 0;
+    char *pathinfo = NULL;
+    gf_boolean_t is_local = _gf_false;
+    afr_private_t *priv = NULL;
+    int32_t child_index = -1;
+
+    if (op_ret != 0) {
+        goto out;
+    }
+
+    priv = this->private;
+    child_index = (int32_t)(long)cookie;
+
+    ret = dict_get_str_sizen(dict, GF_XATTR_PATHINFO_KEY, &pathinfo);
+    if (ret != 0) {
+        goto out;
+    }
+
+    ret = glusterfs_is_local_pathinfo(pathinfo, &is_local);
+    if (ret) {
+        goto out;
+    }
+
+    /*
+     * Note that one local subvolume will override another here.  The only
+     * way to avoid that would be to retain extra information about whether
+     * the previous read_child is local, and it's just not worth it.  Even
+     * the slowest local subvolume is far preferable to a remote one.
+     */
+    if (is_local) {
+        priv->local[child_index] = 1;
+        /* Don't set arbiter as read child. */
+        if (AFR_IS_ARBITER_BRICK(priv, child_index))
+            goto out;
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_LOCAL_CHILD,
+               "selecting local read_child %s",
+               priv->children[child_index]->name);
+
+        priv->read_child = child_index;
+    }
 out:
-        STACK_DESTROY(frame->root);
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static void
-afr_attempt_local_discovery (xlator_t *this, int32_t child_index)
+afr_attempt_local_discovery(xlator_t *this, int32_t child_index)
 {
-        call_frame_t    *newframe = NULL;
-        loc_t            tmploc = {0,};
-        afr_private_t   *priv = this->private;
+    call_frame_t *newframe = NULL;
+    loc_t tmploc = {
+        0,
+    };
+    afr_private_t *priv = this->private;
 
-        newframe = create_frame(this,this->ctx->pool);
-        if (!newframe) {
-                return;
-        }
+    newframe = create_frame(this, this->ctx->pool);
+    if (!newframe) {
+        return;
+    }
 
-        tmploc.gfid[sizeof(tmploc.gfid)-1] = 1;
-        STACK_WIND_COOKIE (newframe, afr_local_discovery_cbk,
-                           (void *)(long)child_index,
-                           priv->children[child_index],
-                           priv->children[child_index]->fops->getxattr,
-                           &tmploc, GF_XATTR_PATHINFO_KEY, NULL);
+    tmploc.gfid[sizeof(tmploc.gfid) - 1] = 1;
+    STACK_WIND_COOKIE(newframe, afr_local_discovery_cbk,
+                      (void *)(long)child_index, priv->children[child_index],
+                      priv->children[child_index]->fops->getxattr, &tmploc,
+                      GF_XATTR_PATHINFO_KEY, NULL);
 }
 
 int
-afr_lookup_sh_metadata_wrap (void *opaque)
-{
-        call_frame_t *frame       = opaque;
-        afr_local_t  *local       = NULL;
-        xlator_t     *this        = NULL;
-        inode_t      *inode       = NULL;
-        afr_private_t *priv       = NULL;
-        struct afr_reply *replies = NULL;
-        int i= 0, first = -1;
-        int ret = -1;
-        dict_t *dict = NULL;
+afr_lookup_sh_metadata_wrap(void *opaque)
+{
+    call_frame_t *frame = opaque;
+    afr_local_t *local = NULL;
+    xlator_t *this = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0, first = -1;
+    int ret = -1;
+    dict_t *dict = NULL;
+
+    local = frame->local;
+    this = frame->this;
+    priv = this->private;
+    replies = local->replies;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        first = i;
+        break;
+    }
+    if (first == -1)
+        goto out;
+
+    if (afr_selfheal_metadata_by_stbuf(this, &replies[first].poststat))
+        goto out;
+
+    afr_local_replies_wipe(local, this->private);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+    if (local->xattr_req) {
+        dict_copy(local->xattr_req, dict);
+    }
+
+    ret = dict_set_sizen_str_sizen(dict, "link-count", GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
+
+    if (loc_is_nameless(&local->loc)) {
+        ret = afr_selfheal_unlocked_discover_on(frame, local->inode,
+                                                local->loc.gfid, local->replies,
+                                                local->child_up, dict);
+    } else {
+        inode = afr_selfheal_unlocked_lookup_on(frame, local->loc.parent,
+                                                local->loc.name, local->replies,
+                                                local->child_up, dict);
+    }
+    if (inode)
+        inode_unref(inode);
+out:
+    if (loc_is_nameless(&local->loc))
+        afr_discover_done(frame, this);
+    else
+        afr_lookup_done(frame, this);
 
-        local = frame->local;
-        this  = frame->this;
-        priv  = this->private;
-        replies = local->replies;
-
-        for (i =0; i < priv->child_count; i++) {
-                if(!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                first = i;
-                break;
-        }
-        if (first == -1)
-                goto out;
+    if (dict)
+        dict_unref(dict);
 
-        if (afr_selfheal_metadata_by_stbuf (this, &replies[first].poststat))
-                goto out;
+    return 0;
+}
 
-        afr_local_replies_wipe (local, this->private);
+gf_boolean_t
+afr_is_pending_set(xlator_t *this, dict_t *xdata, int type)
+{
+    int idx = -1;
+    afr_private_t *priv = NULL;
+    void *pending_raw = NULL;
+    int *pending_int = NULL;
+    int i = 0;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-        ret = dict_set_str (dict, "link-count", GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
+    priv = this->private;
+    idx = afr_index_for_transaction_type(type);
+
+    if (dict_get_ptr(xdata, AFR_DIRTY, &pending_raw) == 0) {
+        if (pending_raw) {
+            pending_int = pending_raw;
+
+            if (ntoh32(pending_int[idx]))
+                return _gf_true;
         }
+    }
 
-        if (loc_is_nameless (&local->loc)) {
-                ret = afr_selfheal_unlocked_discover_on (frame, local->inode,
-                                                         local->loc.gfid,
-                                                         local->replies,
-                                                         local->child_up);
-        } else {
-                inode = afr_selfheal_unlocked_lookup_on (frame,
-                                                         local->loc.parent,
-                                                         local->loc.name,
-                                                         local->replies,
-                                                         local->child_up, dict);
-        }
-        if (inode)
-                inode_unref (inode);
-out:
-        if (loc_is_nameless (&local->loc))
-                afr_discover_done (frame, this);
-        else
-                afr_lookup_done (frame, this);
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
+        if (!pending_raw)
+            continue;
+        pending_int = pending_raw;
 
-        if (dict)
-                dict_unref (dict);
+        if (ntoh32(pending_int[idx]))
+            return _gf_true;
+    }
 
-        return 0;
+    return _gf_false;
 }
 
 static gf_boolean_t
 afr_can_start_metadata_self_heal(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        struct afr_reply *replies = NULL;
-        int i = 0, first = -1;
-        gf_boolean_t start = _gf_false;
-        struct iatt stbuf = {0, };
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0, first = -1;
+    gf_boolean_t start = _gf_false;
+    struct iatt stbuf = {
+        0,
+    };
 
-        local = frame->local;
-        replies = local->replies;
-        priv = this->private;
+    local = frame->local;
+    replies = local->replies;
+    priv = this->private;
 
-        if (!priv->metadata_self_heal)
-                return _gf_false;
+    if (!priv->metadata_self_heal)
+        return _gf_false;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if(!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (first == -1) {
-                        first = i;
-                        stbuf = replies[i].poststat;
-                        continue;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (first == -1) {
+            first = i;
+            stbuf = replies[i].poststat;
+            continue;
+        }
 
-                if (gf_uuid_compare (stbuf.ia_gfid, replies[i].poststat.ia_gfid)) {
-                        start = _gf_false;
-                        break;
-                }
-                if (!IA_EQUAL (stbuf, replies[i].poststat, type)) {
-                        start = _gf_false;
-                        break;
-                }
+        if (afr_is_pending_set(this, replies[i].xdata,
+                               AFR_METADATA_TRANSACTION)) {
+            /* Let shd do the heal so that lookup is not blocked
+             * on getting metadata lock/doing the heal */
+            start = _gf_false;
+            break;
+        }
 
-                /*Check if iattrs need heal*/
-                if ((!IA_EQUAL (stbuf, replies[i].poststat, uid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, gid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, prot))) {
-                        start = _gf_true;
-                        continue;
-                }
+        if (gf_uuid_compare(stbuf.ia_gfid, replies[i].poststat.ia_gfid)) {
+            start = _gf_false;
+            break;
+        }
+        if (!IA_EQUAL(stbuf, replies[i].poststat, type)) {
+            start = _gf_false;
+            break;
+        }
 
-                /*Check if xattrs need heal*/
-                if (!afr_xattrs_are_equal (replies[first].xdata,
-                                           replies[i].xdata))
-                        start = _gf_true;
+        /*Check if iattrs need heal*/
+        if ((!IA_EQUAL(stbuf, replies[i].poststat, uid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, gid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, prot))) {
+            start = _gf_true;
+            continue;
         }
 
-        return start;
+        /*Check if xattrs need heal*/
+        if (!afr_xattrs_are_equal(replies[first].xdata, replies[i].xdata))
+            start = _gf_true;
+    }
+
+    return start;
 }
 
 int
-afr_lookup_metadata_heal_check (call_frame_t *frame, xlator_t *this)
+afr_lookup_metadata_heal_check(call_frame_t *frame, xlator_t *this)
 
 {
-        call_frame_t *heal = NULL;
-        afr_local_t *local = NULL;
-        int ret            = 0;
+    call_frame_t *heal = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
-        if (!afr_can_start_metadata_self_heal (frame, this))
-                goto out;
+    local = frame->local;
+    if (!afr_can_start_metadata_self_heal(frame, this))
+        goto out;
 
-        heal = afr_frame_create (this);
-        if (!heal)
-                goto out;
+    heal = afr_frame_create(this, &ret);
+    if (!heal) {
+        ret = -ret;
+        goto out;
+    }
 
-        ret = synctask_new (this->ctx->env, afr_lookup_sh_metadata_wrap,
-                            afr_refresh_selfheal_done, heal, frame);
-        if (ret)
-                goto out;
-        return ret;
+    ret = synctask_new(this->ctx->env, afr_lookup_sh_metadata_wrap,
+                       afr_refresh_selfheal_done, heal, frame);
+    if (ret)
+        goto out;
+    return ret;
 out:
-        if (loc_is_nameless (&local->loc))
-                afr_discover_done (frame, this);
-        else
-                afr_lookup_done (frame, this);
-        if (heal)
-                AFR_STACK_DESTROY (heal);
-        return ret;
+    if (loc_is_nameless(&local->loc))
+        afr_discover_done(frame, this);
+    else
+        afr_lookup_done(frame, this);
+    if (heal)
+        AFR_STACK_DESTROY(heal);
+    return ret;
 }
 
 int
-afr_lookup_selfheal_wrap (void *opaque)
+afr_lookup_selfheal_wrap(void *opaque)
 {
-        int ret = 0;
-	call_frame_t *frame = opaque;
-	afr_local_t *local = NULL;
-	xlator_t *this = NULL;
-	inode_t *inode = NULL;
-        uuid_t pargfid = {0,};
+    int ret = 0;
+    call_frame_t *frame = opaque;
+    afr_local_t *local = NULL;
+    xlator_t *this = NULL;
+    inode_t *inode = NULL;
+    uuid_t pargfid = {
+        0,
+    };
 
-	local = frame->local;
-	this = frame->this;
-        loc_pargfid (&local->loc, pargfid);
+    local = frame->local;
+    this = frame->this;
+    loc_pargfid(&local->loc, pargfid);
 
-	ret = afr_selfheal_name (frame->this, pargfid, local->loc.name,
-                                 &local->cont.lookup.gfid_req, local->xattr_req);
-        if (ret == -EIO)
-                goto unwind;
+    ret = afr_selfheal_name(frame->this, pargfid, local->loc.name,
+                            &local->cont.lookup.gfid_req, local->xattr_req);
+    if (ret == -EIO)
+        goto unwind;
 
-        afr_local_replies_wipe (local, this->private);
+    afr_local_replies_wipe(local, this->private);
 
-	inode = afr_selfheal_unlocked_lookup_on (frame, local->loc.parent,
-						 local->loc.name, local->replies,
-						 local->child_up, NULL);
-	if (inode)
-		inode_unref (inode);
+    inode = afr_selfheal_unlocked_lookup_on(frame, local->loc.parent,
+                                            local->loc.name, local->replies,
+                                            local->child_up, local->xattr_req);
+    if (inode)
+        inode_unref(inode);
 
-        afr_lookup_metadata_heal_check(frame, this);
-        return 0;
+    afr_lookup_metadata_heal_check(frame, this);
+    return 0;
 
 unwind:
-	AFR_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-afr_lookup_entry_heal (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	call_frame_t *heal = NULL;
-	int i = 0, first = -1;
-	gf_boolean_t need_heal = _gf_false;
-	struct afr_reply *replies = NULL;
-	int ret = 0;
-
-	local = frame->local;
-	replies = local->replies;
-	priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA))
-                        need_heal = _gf_true;
-
-		if (first == -1) {
-			first = i;
-			continue;
-		}
-
-		if (replies[i].op_ret != replies[first].op_ret) {
-			need_heal = _gf_true;
-			break;
-		}
-
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[first].poststat.ia_gfid)) {
-			need_heal = _gf_true;
-			break;
-		}
-	}
-
-	if (need_heal) {
-		heal = afr_frame_create (this);
-		if (!heal)
-                        goto metadata_heal;
-
-		ret = synctask_new (this->ctx->env, afr_lookup_selfheal_wrap,
-				    afr_refresh_selfheal_done, heal, frame);
-		if (ret) {
-                        AFR_STACK_DESTROY (heal);
-			goto metadata_heal;
-                }
-                return ret;
-	}
-metadata_heal:
-        ret = afr_lookup_metadata_heal_check (frame, this);
+afr_lookup_entry_heal(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    call_frame_t *heal = NULL;
+    int i = 0, first = -1;
+    gf_boolean_t name_state_mismatch = _gf_false;
+    struct afr_reply *replies = NULL;
+    int ret = 0;
+    unsigned char *par_readables = NULL;
+    unsigned char *success = NULL;
+    int32_t op_errno = 0;
+    uuid_t gfid = {0};
+
+    local = frame->local;
+    replies = local->replies;
+    priv = this->private;
+    par_readables = alloca0(priv->child_count);
+    success = alloca0(priv->child_count);
+
+    ret = afr_inode_read_subvol_get(local->loc.parent, this, par_readables,
+                                    NULL, NULL);
+    if (ret < 0 || AFR_COUNT(par_readables, priv->child_count) == 0) {
+        /* In this case set par_readables to all 1 so that name_heal
+         * need checks at the end of this function will flag missing
+         * entry when name state mismatches*/
+        memset(par_readables, 1, priv->child_count);
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret == 0) {
+            if (gf_uuid_is_null(gfid)) {
+                gf_uuid_copy(gfid, replies[i].poststat.ia_gfid);
+            }
+            success[i] = 1;
+        } else {
+            if ((replies[i].op_errno != ENOTCONN) &&
+                (replies[i].op_errno != ENOENT) &&
+                (replies[i].op_errno != ESTALE)) {
+                op_errno = replies[i].op_errno;
+            }
+        }
 
-	return ret;
-}
+        /*gfid is missing, needs heal*/
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA)) {
+            goto name_heal;
+        }
 
+        if (first == -1) {
+            first = i;
+            continue;
+        }
 
-int
-afr_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-		dict_t *xdata, struct iatt *postparent)
-{
-        afr_local_t *   local = NULL;
-        int             call_count      = -1;
-        int             child_index     = -1;
-        GF_UNUSED int   ret             = 0;
-	int8_t need_heal                = 1;
-
-	child_index = (long) cookie;
-
-	local = frame->local;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        /*
-         * On revalidate lookup if the gfid-changed, afr should unwind the fop
-         * with ESTALE so that a fresh lookup will be sent by the top xlator.
-         * So remember it.
-         */
-        if (xdata && dict_get (xdata, "gfid-changed"))
-                local->cont.lookup.needs_fresh_lookup = _gf_true;
+        if (replies[i].op_ret != replies[first].op_ret) {
+            name_state_mismatch = _gf_true;
+        }
 
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[child_index].need_heal = need_heal;
-        } else {
-                local->replies[child_index].need_heal = need_heal;
+        if (replies[i].op_ret == 0) {
+            /* Rename after this lookup may succeed if we don't do
+             * a name-heal and the destination may not have pending xattrs
+             * to indicate which name is good and which is bad so always do
+             * this heal*/
+            if (gf_uuid_compare(replies[i].poststat.ia_gfid, gfid)) {
+                goto name_heal;
+            }
         }
-	if (op_ret != -1) {
-		local->replies[child_index].poststat = *buf;
-		local->replies[child_index].postparent = *postparent;
-		if (xdata)
-			local->replies[child_index].xdata = dict_ref (xdata);
-	}
+    }
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-		afr_lookup_entry_heal (frame, this);
+    if (name_state_mismatch) {
+        if (!priv->quorum_count)
+            goto name_heal;
+        if (!afr_has_quorum(success, this, NULL))
+            goto name_heal;
+        if (op_errno)
+            goto name_heal;
+        for (i = 0; i < priv->child_count; i++) {
+            if (!replies[i].valid)
+                continue;
+            if (par_readables[i] && replies[i].op_ret < 0 &&
+                replies[i].op_errno != ENOTCONN) {
+                goto name_heal;
+            }
         }
+    }
+
+    goto metadata_heal;
+
+name_heal:
+    heal = afr_frame_create(this, NULL);
+    if (!heal)
+        goto metadata_heal;
 
-	return 0;
+    ret = synctask_new(this->ctx->env, afr_lookup_selfheal_wrap,
+                       afr_refresh_selfheal_done, heal, frame);
+    if (ret) {
+        AFR_STACK_DESTROY(heal);
+        goto metadata_heal;
+    }
+    return ret;
+
+metadata_heal:
+    ret = afr_lookup_metadata_heal_check(frame, this);
+
+    return ret;
 }
 
+int
+afr_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+               struct iatt *postparent)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
+    GF_UNUSED int ret = 0;
+    int8_t need_heal = 1;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    /*
+     * On revalidate lookup if the gfid-changed, afr should unwind the fop
+     * with ESTALE so that a fresh lookup will be sent by the top xlator.
+     * So remember it.
+     */
+    if (xdata && dict_get_sizen(xdata, "gfid-changed"))
+        local->cont.lookup.needs_fresh_lookup = _gf_true;
+
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[child_index].need_heal = need_heal;
+    } else {
+        local->replies[child_index].need_heal = need_heal;
+    }
+    if (op_ret != -1) {
+        local->replies[child_index].poststat = *buf;
+        local->replies[child_index].postparent = *postparent;
+        if (xdata)
+            local->replies[child_index].xdata = dict_ref(xdata);
+    }
+
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        afr_lookup_entry_heal(frame, this);
+    }
 
+    return 0;
+}
 
 static void
-afr_discover_done (call_frame_t *frame, xlator_t *this)
+afr_discover_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-	int                 i = -1;
-	int                 op_errno = 0;
-	int                 spb_choice = -1;
-	int                 read_subvol = -1;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int read_subvol = -1;
+    int ret = 0;
+    unsigned char *data_readable = NULL;
+    unsigned char *success_replies = NULL;
 
-        priv  = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
+    data_readable = alloca0(priv->child_count);
+    success_replies = alloca0(priv->child_count);
 
-        afr_inode_split_brain_choice_get (local->inode, this,
-                                          &spb_choice);
+    afr_fill_success_replies(local, priv, success_replies);
+    if (AFR_COUNT(success_replies, priv->child_count) > 0)
+        local->op_ret = 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret == 0)
-			local->op_ret = 0;
-	}
+    if (local->op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(frame->local, this->private);
+        goto error;
+    }
 
-	op_errno = afr_final_errno (frame->local, this->private);
+    if (!afr_has_quorum(success_replies, this, frame))
+        goto unwind;
 
-        if (local->op_ret < 0) {
-		local->op_errno = op_errno;
-		local->op_ret = -1;
-                goto unwind;
-	}
+    ret = afr_replies_interpret(frame, this, local->inode, NULL);
+    if (ret) {
+        afr_inode_need_refresh_set(local->inode, this);
+    }
 
-	afr_replies_interpret (frame, this, local->inode, NULL);
+    read_subvol = afr_read_subvol_decide(local->inode, this, NULL,
+                                         data_readable);
 
-	read_subvol = afr_read_subvol_decide (local->inode, this, NULL);
-	if (read_subvol == -1) {
-	        gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_READ_SUBVOL_ERROR, "no read subvols for %s",
-			local->loc.path);
+unwind:
+    afr_attempt_readsubvol_set(frame, this, success_replies, data_readable,
+                               &read_subvol);
+    if (read_subvol == -1)
+        goto error;
 
-                if (spb_choice >= 0) {
-                        read_subvol = spb_choice;
-                } else {
-                        read_subvol = afr_first_up_child (frame, this);
-                }
-	}
+    if (AFR_IS_ARBITER_BRICK(priv, read_subvol) && local->op_ret == 0) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg_debug(this->name, 0,
+                     "Arbiter cannot be a read subvol "
+                     "for %s",
+                     local->loc.path);
+    }
 
-unwind:
-	if (read_subvol == -1) {
-                if (spb_choice >= 0)
-                        read_subvol = spb_choice;
-                else
-                        read_subvol = afr_first_up_child (frame, this);
-        }
-        if (AFR_IS_ARBITER_BRICK (priv, read_subvol) && local->op_ret == 0) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOTCONN;
-        }
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->replies[read_subvol].poststat,
+                     local->replies[read_subvol].xdata,
+                     &local->replies[read_subvol].postparent);
+    return;
 
-	AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-			  local->inode, &local->replies[read_subvol].poststat,
-			  local->replies[read_subvol].xdata,
-			  &local->replies[read_subvol].postparent);
+error:
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno, NULL, NULL,
+                     NULL, NULL);
 }
 
+static int
+afr_ta_id_file_check(void *opaque)
+{
+    afr_private_t *priv = NULL;
+    xlator_t *this = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    dict_t *dict = NULL;
+    uuid_t gfid = {
+        0,
+    };
+    fd_t *fd = NULL;
+    int ret = 0;
+
+    this = opaque;
+    priv = this->private;
+
+    ret = afr_fill_ta_loc(this, &loc, _gf_false);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        goto out;
+    }
+
+    ret = syncop_lookup(priv->children[THIN_ARBITER_BRICK_INDEX], &loc, &stbuf,
+                        0, 0, 0);
+    if (ret == 0) {
+        goto out;
+    } else if (ret == -ENOENT) {
+        fd = fd_create(loc.inode, getpid());
+        if (!fd)
+            goto out;
+        dict = dict_new();
+        if (!dict)
+            goto out;
+        gf_uuid_generate(gfid);
+        ret = dict_set_gfuuid(dict, "gfid-req", gfid, true);
+        ret = syncop_create(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                            O_RDWR, 0664, fd, &stbuf, dict, NULL);
+    }
 
-int
-afr_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		  int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-		  dict_t *xdata, struct iatt *postparent)
-{
-        afr_local_t *   local = NULL;
-        int             call_count      = -1;
-        int             child_index     = -1;
-        GF_UNUSED int ret               = 0;
-	int8_t need_heal                = 1;
-
-	child_index = (long) cookie;
-
-	local = frame->local;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-	if (op_ret != -1) {
-		local->replies[child_index].poststat = *buf;
-		local->replies[child_index].postparent = *postparent;
-		if (xdata)
-			local->replies[child_index].xdata = dict_ref (xdata);
-	}
-
-        if (local->do_discovery && (op_ret == 0))
-                afr_attempt_local_discovery (this, child_index);
-
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[child_index].need_heal = need_heal;
-        } else {
-                local->replies[child_index].need_heal = need_heal;
-        }
-
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-                afr_lookup_metadata_heal_check (frame, this);
-        }
+out:
+    if (ret == 0) {
+        gf_uuid_copy(priv->ta_gfid, stbuf.ia_gfid);
+    } else {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to lookup/create thin-arbiter id file.");
+    }
+    if (dict)
+        dict_unref(dict);
+    if (fd)
+        fd_unref(fd);
+    loc_wipe(&loc);
 
-	return 0;
+    return 0;
 }
 
+static int
+afr_ta_id_file_check_cbk(int ret, call_frame_t *ta_frame, void *opaque)
+{
+    return 0;
+}
 
-int
-afr_discover_do (call_frame_t *frame, xlator_t *this, int err)
+static void
+afr_discover_done(call_frame_t *frame, xlator_t *this)
 {
-	int ret = 0;
-	int i = 0;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
+    int ret = 0;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    priv = this->private;
+    if (!priv->thin_arbiter_count)
+        goto unwind;
+    if (!gf_uuid_is_null(priv->ta_gfid))
+        goto unwind;
 
-	if (err) {
-		local->op_errno = -err;
-		ret = -1;
-		goto out;
-	}
+    ret = synctask_new(this->ctx->env, afr_ta_id_file_check,
+                       afr_ta_id_file_check_cbk, NULL, this);
+    if (ret)
+        goto unwind;
+unwind:
+    afr_discover_unwind(frame, this);
+}
 
-	call_count = local->call_count = AFR_COUNT (local->child_up,
-						    priv->child_count);
+int
+afr_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+                 struct iatt *postparent)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
+    GF_UNUSED int ret = 0;
+    int8_t need_heal = 1;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (op_ret != -1) {
+        local->replies[child_index].poststat = *buf;
+        local->replies[child_index].postparent = *postparent;
+        if (xdata)
+            local->replies[child_index].xdata = dict_ref(xdata);
+    }
+
+    if (local->do_discovery && (op_ret == 0))
+        afr_attempt_local_discovery(this, child_index);
+
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[child_index].need_heal = need_heal;
+    } else {
+        local->replies[child_index].need_heal = need_heal;
+    }
+
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        afr_lookup_metadata_heal_check(frame, this);
+    }
 
-        ret = afr_lookup_xattr_req_prepare (local, this, local->xattr_req,
-					    &local->loc);
-        if (ret) {
-                local->op_errno = -ret;
-		ret = -1;
-                goto out;
-        }
+    return 0;
+}
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_discover_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        if (!--call_count)
-                                break;
-                }
+int
+afr_discover_do(call_frame_t *frame, xlator_t *this, int err)
+{
+    int ret = 0;
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (err) {
+        local->op_errno = err;
+        goto out;
+    }
+
+    call_count = local->call_count = AFR_COUNT(local->child_up,
+                                               priv->child_count);
+
+    ret = afr_lookup_xattr_req_prepare(local, this, local->xattr_req,
+                                       &local->loc);
+    if (ret) {
+        local->op_errno = -ret;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(
+                frame, afr_discover_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->lookup, &local->loc, local->xattr_req);
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
+    return 0;
 }
 
-
 int
-afr_discover (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+afr_discover(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
 {
-	int op_errno = ENOMEM;
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int event = 0;
+    int op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int event = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        if (!local->call_count) {
-                op_errno = ENOTCONN;
-                goto out;
-        }
+    if (!local->call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
 
-	if (__is_root_gfid (loc->inode->gfid)) {
-		if (!this->itable)
-			this->itable = loc->inode->table;
-		if (!priv->root_inode)
-			priv->root_inode = inode_ref (loc->inode);
+    if (__is_root_gfid(loc->inode->gfid)) {
+        if (!priv->root_inode)
+            priv->root_inode = inode_ref(loc->inode);
 
-		if (priv->choose_local && !priv->did_discovery) {
-			/* Logic to detect which subvolumes of AFR are
-			   local, in order to prefer them for reads
-			*/
-			local->do_discovery = _gf_true;
-                        priv->did_discovery = _gf_true;
-                }
-	}
+        if (priv->choose_local && !priv->did_discovery) {
+            /* Logic to detect which subvolumes of AFR are
+               local, in order to prefer them for reads
+            */
+            local->do_discovery = _gf_true;
+            priv->did_discovery = _gf_true;
+        }
+    }
 
-        local->op = GF_FOP_LOOKUP;
+    local->op = GF_FOP_LOOKUP;
 
-        loc_copy (&local->loc, loc);
+    loc_copy(&local->loc, loc);
 
-	local->inode = inode_ref (loc->inode);
+    local->inode = inode_ref(loc->inode);
 
-	if (xattr_req)
-		/* If xattr_req was null, afr_lookup_xattr_req_prepare() will
-		   allocate one for us */
-		local->xattr_req = dict_ref (xattr_req);
+    if (xattr_req) {
+        /* If xattr_req was null, afr_lookup_xattr_req_prepare() will
+           allocate one for us */
+        local->xattr_req = dict_copy_with_ref(xattr_req, NULL);
+        if (!local->xattr_req) {
+            op_errno = ENOMEM;
+            goto out;
+        }
+    }
 
-	if (gf_uuid_is_null (loc->inode->gfid)) {
-		afr_discover_do (frame, this, 0);
-		return 0;
-	}
+    if (gf_uuid_is_null(loc->inode->gfid)) {
+        afr_discover_do(frame, this, 0);
+        return 0;
+    }
 
-	afr_read_subvol_get (loc->inode, this, NULL, NULL, &event,
-			     AFR_DATA_TRANSACTION, NULL);
+    afr_read_subvol_get(loc->inode, this, NULL, NULL, &event,
+                        AFR_DATA_TRANSACTION, NULL);
 
-	if (afr_is_inode_refresh_reqd (loc->inode, this, event,
-                                       local->event_generation))
-		afr_inode_refresh (frame, this, loc->inode, NULL,
-                                   afr_discover_do);
-	else
-		afr_discover_do (frame, this, 0);
+    afr_discover_do(frame, this, 0);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-afr_lookup_do (call_frame_t *frame, xlator_t *this, int err)
-{
-	int ret = 0;
-	int i = 0;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (err < 0) {
-		local->op_errno = -err;
-		ret = -1;
-		goto out;
-	}
-
-	call_count = local->call_count = AFR_COUNT (local->child_up,
-						    priv->child_count);
-
-        ret = afr_lookup_xattr_req_prepare (local, this, local->xattr_req,
-					    &local->loc);
-        if (ret) {
-                local->op_errno = -ret;
-		ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_lookup_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        if (!--call_count)
-                                break;
-                }
+afr_lookup_do(call_frame_t *frame, xlator_t *this, int err)
+{
+    int ret = 0;
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (err < 0) {
+        local->op_errno = err;
+        goto out;
+    }
+
+    call_count = local->call_count = AFR_COUNT(local->child_up,
+                                               priv->child_count);
+
+    ret = afr_lookup_xattr_req_prepare(local, this, local->xattr_req,
+                                       &local->loc);
+    if (ret) {
+        local->op_errno = -ret;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(
+                frame, afr_lookup_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->lookup, &local->loc, local->xattr_req);
+            if (!--call_count)
+                break;
         }
-	return 0;
+    }
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
+    return 0;
 }
 
 /*
@@ -3001,1633 +4000,1722 @@ out:
  */
 
 int
-afr_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-        afr_local_t   *local = NULL;
-        int32_t        op_errno = 0;
-	int            event = 0;
-        void          *gfid_req = NULL;
-        int            ret = 0;
-
-        if (loc_is_nameless (loc)) {
-                if (xattr_req)
-                        dict_del (xattr_req, "gfid-req");
-		afr_discover (frame, this, loc, xattr_req);
-		return 0;
-	}
-
-	if (__is_root_gfid (loc->parent->gfid)) {
-		if (!strcmp (loc->name, GF_REPLICATE_TRASH_DIR)) {
-			op_errno = EPERM;
-			goto out;
-		}
-	}
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        if (!local->call_count) {
-                op_errno = ENOTCONN;
-                goto out;
-        }
+afr_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    int event = 0;
+    int ret = 0;
 
-        local->op = GF_FOP_LOOKUP;
+    if (loc_is_nameless(loc)) {
+        if (xattr_req)
+            dict_del_sizen(xattr_req, "gfid-req");
+        afr_discover(frame, this, loc, xattr_req);
+        return 0;
+    }
 
-        loc_copy (&local->loc, loc);
+    if (afr_is_private_directory(this->private, loc->parent->gfid, loc->name,
+                                 frame->root->pid)) {
+        op_errno = EPERM;
+        goto out;
+    }
 
-	local->inode = inode_ref (loc->inode);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	if (xattr_req) {
-		/* If xattr_req was null, afr_lookup_xattr_req_prepare() will
-		   allocate one for us */
-		local->xattr_req = dict_copy_with_ref (xattr_req, NULL);
-		if (!local->xattr_req) {
-		        op_errno = ENOMEM;
-		        goto out;
-                }
-                ret = dict_get_ptr (local->xattr_req, "gfid-req", &gfid_req);
-                if (ret == 0) {
-                        gf_uuid_copy (local->cont.lookup.gfid_req, gfid_req);
-                        dict_del (local->xattr_req, "gfid-req");
-                }
+    if (!local->call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
+
+    local->op = GF_FOP_LOOKUP;
+
+    loc_copy(&local->loc, loc);
+
+    local->inode = inode_ref(loc->inode);
+
+    if (xattr_req) {
+        /* If xattr_req was null, afr_lookup_xattr_req_prepare() will
+           allocate one for us */
+        local->xattr_req = dict_copy_with_ref(xattr_req, NULL);
+        if (!local->xattr_req) {
+            op_errno = ENOMEM;
+            goto out;
+        }
+        ret = dict_get_gfuuid(local->xattr_req, "gfid-req",
+                              &local->cont.lookup.gfid_req);
+        if (ret == 0) {
+            dict_del_sizen(local->xattr_req, "gfid-req");
         }
+    }
 
-	afr_read_subvol_get (loc->parent, this, NULL, NULL, &event,
-			     AFR_DATA_TRANSACTION, NULL);
+    afr_read_subvol_get(loc->parent, this, NULL, NULL, &event,
+                        AFR_DATA_TRANSACTION, NULL);
 
-	if (afr_is_inode_refresh_reqd (loc->inode, this, event,
-                                       local->event_generation))
-		afr_inode_refresh (frame, this, loc->parent, NULL,
-                                   afr_lookup_do);
-	else
-		afr_lookup_do (frame, this, 0);
+    afr_lookup_do(frame, this, 0);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 void
-_afr_cleanup_fd_ctx (afr_fd_ctx_t *fd_ctx)
+_afr_cleanup_fd_ctx(xlator_t *this, afr_fd_ctx_t *fd_ctx)
 {
-        int i = 0;
+    afr_private_t *priv = this->private;
 
-
-	for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++)
-		GF_FREE (fd_ctx->pre_op_done[i]);
-
-        GF_FREE (fd_ctx->opened_on);
-
-        GF_FREE (fd_ctx->lock_piggyback);
-
-        GF_FREE (fd_ctx->lock_acquired);
-
-	pthread_mutex_destroy (&fd_ctx->delay_lock);
-
-        GF_FREE (fd_ctx);
-
-        return;
+    if (fd_ctx->lk_heal_info) {
+        LOCK(&priv->lock);
+        {
+            list_del(&fd_ctx->lk_heal_info->pos);
+        }
+        afr_lk_heal_info_cleanup(fd_ctx->lk_heal_info);
+        fd_ctx->lk_heal_info = NULL;
+    }
+    GF_FREE(fd_ctx->opened_on);
+    GF_FREE(fd_ctx);
+    return;
 }
 
 int
-afr_cleanup_fd_ctx (xlator_t *this, fd_t *fd)
+afr_cleanup_fd_ctx(xlator_t *this, fd_t *fd)
 {
-        uint64_t        ctx = 0;
-        afr_fd_ctx_t    *fd_ctx = NULL;
-        int             ret = 0;
+    uint64_t ctx = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int ret = 0;
 
-        ret = fd_ctx_get (fd, this, &ctx);
-        if (ret < 0)
-                goto out;
+    ret = fd_ctx_get(fd, this, &ctx);
+    if (ret < 0)
+        goto out;
 
-        fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+    fd_ctx = (afr_fd_ctx_t *)(long)ctx;
 
-        if (fd_ctx) {
-                /*no need to take any locks*/
-                if (!list_empty (&fd_ctx->eager_locked))
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_INVALID_DATA, "%s: Stale "
-                                "Eager-lock stubs found",
-                                uuid_utoa (fd->inode->gfid));
-
-                _afr_cleanup_fd_ctx (fd_ctx);
-
-        }
+    if (fd_ctx) {
+        _afr_cleanup_fd_ctx(this, fd_ctx);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-afr_release (xlator_t *this, fd_t *fd)
+afr_release(xlator_t *this, fd_t *fd)
 {
-        afr_cleanup_fd_ctx (this, fd);
+    afr_cleanup_fd_ctx(this, fd);
 
-        return 0;
+    return 0;
 }
 
 afr_fd_ctx_t *
-__afr_fd_ctx_get (fd_t *fd, xlator_t *this)
+__afr_fd_ctx_get(fd_t *fd, xlator_t *this)
 {
-        uint64_t       ctx = 0;
-        int            ret = 0;
-        afr_fd_ctx_t  *fd_ctx = NULL;
+    uint64_t ctx = 0;
+    int ret = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        ret = __fd_ctx_get (fd, this, &ctx);
+    ret = __fd_ctx_get(fd, this, &ctx);
 
-        if (ret < 0) {
-                ret = __afr_fd_ctx_set (this, fd);
-                if (ret < 0)
-                        goto out;
+    if (ret < 0) {
+        ret = __afr_fd_ctx_set(this, fd);
+        if (ret < 0)
+            goto out;
 
-                ret = __fd_ctx_get (fd, this, &ctx);
-                if (ret < 0)
-                        goto out;
-        }
+        ret = __fd_ctx_get(fd, this, &ctx);
+        if (ret < 0)
+            goto out;
+    }
 
-        fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+    fd_ctx = (afr_fd_ctx_t *)(long)ctx;
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
-
 afr_fd_ctx_t *
-afr_fd_ctx_get (fd_t *fd, xlator_t *this)
+afr_fd_ctx_get(fd_t *fd, xlator_t *this)
 {
-        afr_fd_ctx_t  *fd_ctx = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        LOCK(&fd->lock);
-        {
-                fd_ctx = __afr_fd_ctx_get (fd, this);
-        }
-        UNLOCK(&fd->lock);
+    LOCK(&fd->lock);
+    {
+        fd_ctx = __afr_fd_ctx_get(fd, this);
+    }
+    UNLOCK(&fd->lock);
 
-        return fd_ctx;
+    return fd_ctx;
 }
 
-
 int
-__afr_fd_ctx_set (xlator_t *this, fd_t *fd)
+__afr_fd_ctx_set(xlator_t *this, fd_t *fd)
 {
-        afr_private_t * priv   = NULL;
-        int             ret    = -1;
-        uint64_t        ctx    = 0;
-        afr_fd_ctx_t *  fd_ctx = NULL;
-	int             i = 0;
-
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (fd, out);
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    uint64_t ctx = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int i = 0;
 
-        priv = this->private;
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(fd, out);
 
-        ret = __fd_ctx_get (fd, this, &ctx);
+    priv = this->private;
 
-        if (ret == 0)
-                goto out;
-
-        fd_ctx = GF_CALLOC (1, sizeof (afr_fd_ctx_t),
-                            gf_afr_mt_afr_fd_ctx_t);
-        if (!fd_ctx) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    ret = __fd_ctx_get(fd, this, &ctx);
 
-        ret = pthread_mutex_init (&fd_ctx->delay_lock, NULL);
-        if (ret) {
-                GF_FREE (fd_ctx);
-                fd_ctx = NULL;
-                goto out;
-        }
+    if (ret == 0)
+        goto out;
 
-	for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
-		fd_ctx->pre_op_done[i] = GF_CALLOC (sizeof (*fd_ctx->pre_op_done[i]),
-						    priv->child_count,
-						    gf_afr_mt_int32_t);
-		if (!fd_ctx->pre_op_done[i]) {
-			ret = -ENOMEM;
-			goto out;
-		}
-	}
-
-        fd_ctx->opened_on = GF_CALLOC (sizeof (*fd_ctx->opened_on),
-                                       priv->child_count,
-                                       gf_afr_mt_int32_t);
-        if (!fd_ctx->opened_on) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (fd_is_anonymous (fd))
-			fd_ctx->opened_on[i] = AFR_FD_OPENED;
-		else
-			fd_ctx->opened_on[i] = AFR_FD_NOT_OPENED;
-	}
-
-        fd_ctx->lock_piggyback = GF_CALLOC (sizeof (*fd_ctx->lock_piggyback),
-                                            priv->child_count,
-                                            gf_afr_mt_char);
-        if (!fd_ctx->lock_piggyback) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    fd_ctx = GF_CALLOC(1, sizeof(afr_fd_ctx_t), gf_afr_mt_afr_fd_ctx_t);
+    if (!fd_ctx) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        fd_ctx->lock_acquired = GF_CALLOC (sizeof (*fd_ctx->lock_acquired),
-                                           priv->child_count,
-                                           gf_afr_mt_char);
-        if (!fd_ctx->lock_acquired) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    fd_ctx->opened_on = GF_CALLOC(sizeof(*fd_ctx->opened_on), priv->child_count,
+                                  gf_afr_mt_int32_t);
+    if (!fd_ctx->opened_on) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-	fd_ctx->readdir_subvol = -1;
+    for (i = 0; i < priv->child_count; i++) {
+        if (fd_is_anonymous(fd))
+            fd_ctx->opened_on[i] = AFR_FD_OPENED;
+        else
+            fd_ctx->opened_on[i] = AFR_FD_NOT_OPENED;
+    }
 
-        INIT_LIST_HEAD (&fd_ctx->eager_locked);
+    fd_ctx->readdir_subvol = -1;
+    fd_ctx->lk_heal_info = NULL;
 
-        ret = __fd_ctx_set (fd, this, (uint64_t)(long) fd_ctx);
-        if (ret)
-                gf_msg_debug (this->name, 0,
-                              "failed to set fd ctx (%p)", fd);
+    ret = __fd_ctx_set(fd, this, (uint64_t)(long)fd_ctx);
+    if (ret)
+        gf_msg_debug(this->name, 0, "failed to set fd ctx (%p)", fd);
 out:
-        if (ret && fd_ctx)
-                _afr_cleanup_fd_ctx (fd_ctx);
-        return ret;
+    if (ret && fd_ctx)
+        _afr_cleanup_fd_ctx(this, fd_ctx);
+    return ret;
 }
 
-
 /* {{{ flush */
 
 int
-afr_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = -1;
+    afr_local_t *local = NULL;
+    int call_count = -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret != -1) {
-			local->op_ret = op_ret;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		} else {
-			local->op_errno = op_errno;
-		}
+    LOCK(&frame->lock);
+    {
+        if (op_ret != -1) {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        } else {
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-	if (call_count == 0)
-		AFR_STACK_UNWIND (flush, frame, local->op_ret,
-				  local->op_errno, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(flush, frame, local->op_ret, local->op_errno,
+                         local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_flush_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-        int           i      = 0;
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int call_count       = -1;
-
-        priv = this->private;
-        local = frame->local;
-        call_count = local->call_count;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_flush_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->flush,
-                                           local->fd, xdata);
-                        if (!--call_count)
-                                break;
-
-                }
+afr_flush_wrapper(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+{
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+
+    priv = this->private;
+    local = frame->local;
+    call_count = local->call_count;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, afr_flush_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->flush,
+                              local->fd, xdata);
+            if (!--call_count)
+                break;
         }
+    }
 
-        return 0;
-}
-
-int
-afr_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-        afr_local_t   *local = NULL;
-        call_stub_t   *stub = NULL;
-        int            op_errno   = ENOMEM;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_FLUSH;
-	if (!afr_is_consistent_io_possible (local, this->private, &op_errno))
-		goto out;
-
-	local->fd = fd_ref(fd);
-
-        stub = fop_flush_stub (frame, afr_flush_wrapper, fd, xdata);
-        if (!stub)
-                goto out;
-
-        afr_delayed_changelog_wake_resume (this, fd, stub);
-
-	return 0;
-out:
-	AFR_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-        return 0;
+    return 0;
 }
 
-/* }}} */
-
-
-/* {{{ fsync */
-
-int
-afr_fsync_unwind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+afr_local_t *
+afr_wakeup_same_fd_delayed_op(xlator_t *this, afr_lock_t *lock, fd_t *fd)
 {
-        AFR_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf,
-                          xdata);
-        return 0;
-}
-
-int
-afr_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-               struct iatt *postbuf, dict_t *xdata)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int i = 0;
-        int call_count = -1;
-        int child_index = (long) cookie;
-	int read_subvol = 0;
-	call_stub_t *stub = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        priv = this->private;
-
-        LOCK (&frame->lock);
-        {
-                local->replies[child_index].valid = 1;
-                local->replies[child_index].op_ret = op_ret;
-                local->replies[child_index].op_errno = op_errno;
-                if (op_ret == 0) {
-                        if (prebuf)
-                                local->replies[child_index].prestat = *prebuf;
-                        if (postbuf)
-                                local->replies[child_index].poststat = *postbuf;
-                        if (xdata)
-                                local->replies[child_index].xdata =
-                                        dict_ref (xdata);
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                local->op_ret = -1;
-                local->op_errno = afr_final_errno (local, priv);
-	        read_subvol = afr_data_subvol_get (local->inode, this, NULL,
-                                                   local->readable, NULL, NULL);
-                /* Pick a reply that is valid and readable, with a preference
-                 * given to read_subvol. */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->replies[i].valid)
-                                continue;
-                        if (local->replies[i].op_ret != 0)
-                                continue;
-                        if (!local->readable[i])
-                                continue;
-                        local->op_ret = local->replies[i].op_ret;
-                        local->op_errno = local->replies[i].op_errno;
-                        local->cont.inode_wfop.prebuf =
-                                local->replies[i].prestat;
-                        local->cont.inode_wfop.postbuf =
-                                local->replies[i].poststat;
-                        if (local->replies[i].xdata) {
-                                if (local->xdata_rsp)
-                                        dict_unref (local->xdata_rsp);
-                                local->xdata_rsp =
-                                        dict_ref (local->replies[i].xdata);
-                        }
-                        if (i == read_subvol)
-                                break;
-                }
-
-		/* Make a stub out of the frame, and register it
-		   with the waking up post-op. When the call-stub resumes,
-		   we are guaranteed that there was no post-op pending
-		   (i.e changelogs were unset in the server). This is an
-		   essential "guarantee", that fsync() returns only after
-		   completely finishing EVERYTHING, including the delayed
-		   post-op. This guarantee is expected by FUSE graph switching
-		   for example.
-		*/
-		stub = fop_fsync_cbk_stub (frame, afr_fsync_unwind_cbk,
-                                           local->op_ret, local->op_errno,
-                                           &local->cont.inode_wfop.prebuf,
-                                           &local->cont.inode_wfop.postbuf,
-                                           local->xdata_rsp);
-		if (!stub) {
-			AFR_STACK_UNWIND (fsync, frame, -1, ENOMEM, 0, 0, 0);
-			return 0;
-		}
-
-		/* If no new unstable writes happened between the
-		   time we cleared the unstable write witness flag in afr_fsync
-		   and now, calling afr_delayed_changelog_wake_up() should
-		   wake up and skip over the fsync phase and go straight to
-		   afr_changelog_post_op_now()
-		*/
-		afr_delayed_changelog_wake_resume (this, local->fd, stub);
+    if (lock->delay_timer) {
+        local = list_entry(lock->post_op.next, afr_local_t,
+                           transaction.owner_list);
+        if (fd == local->fd) {
+            if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+                local = NULL;
+            } else {
+                lock->delay_timer = NULL;
+            }
+        } else {
+            local = NULL;
         }
+    }
 
-        return 0;
+    return local;
 }
 
+void
+afr_delayed_changelog_wake_resume(xlator_t *this, inode_t *inode,
+                                  call_stub_t *stub)
+{
+    afr_inode_ctx_t *ctx = NULL;
+    afr_lock_t *lock = NULL;
+    afr_local_t *metadata_local = NULL;
+    afr_local_t *data_local = NULL;
+    LOCK(&inode->lock);
+    {
+        (void)__afr_inode_ctx_get(this, inode, &ctx);
+        lock = &ctx->lock[AFR_DATA_TRANSACTION];
+        data_local = afr_wakeup_same_fd_delayed_op(this, lock, stub->args.fd);
+        lock = &ctx->lock[AFR_METADATA_TRANSACTION];
+        metadata_local = afr_wakeup_same_fd_delayed_op(this, lock,
+                                                       stub->args.fd);
+    }
+    UNLOCK(&inode->lock);
+
+    if (data_local) {
+        data_local->transaction.resume_stub = stub;
+    } else if (metadata_local) {
+        metadata_local->transaction.resume_stub = stub;
+    } else {
+        call_resume(stub);
+    }
+    if (data_local) {
+        afr_delayed_changelog_wake_up_cbk(data_local);
+    }
+    if (metadata_local) {
+        afr_delayed_changelog_wake_up_cbk(metadata_local);
+    }
+}
 
 int
-afr_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-	   dict_t *xdata)
+afr_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-	afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
-        int32_t call_count = 0;
-        int32_t op_errno = ENOMEM;
-
-	priv = this->private;
+    afr_local_t *local = NULL;
+    call_stub_t *stub = NULL;
+    int op_errno = ENOMEM;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_FSYNC;
-	if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
+    local->op = GF_FOP_FLUSH;
+    if (!afr_is_consistent_io_possible(local, this->private, &op_errno))
+        goto out;
 
-        local->fd = fd_ref (fd);
+    local->fd = fd_ref(fd);
 
-	if (afr_fd_has_witnessed_unstable_write (this, fd)) {
-		/* don't care. we only wanted to CLEAR the bit */
-	}
+    stub = fop_flush_stub(frame, afr_flush_wrapper, fd, xdata);
+    if (!stub)
+        goto out;
 
-	local->inode = inode_ref (fd->inode);
-
-        call_count = local->call_count;
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_fsync_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->fsync,
-                                           fd, datasync, xdata);
-                        if (!--call_count)
-                                break;
-                }
-        }
+    afr_delayed_changelog_wake_resume(this, fd->inode, stub);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-
-        return 0;
+    AFR_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-/* }}} */
-
-/* {{{ fsync */
-
 int
-afr_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = -1;
+    afr_local_t *local = NULL;
+    int call_count = -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == 0) {
-                        local->op_ret = 0;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		} else {
-			local->op_errno = op_errno;
-		}
+    LOCK(&frame->lock);
+    {
+        if (op_ret == 0) {
+            local->op_ret = 0;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        } else {
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (call_count == 0)
-                AFR_STACK_UNWIND (fsyncdir, frame, local->op_ret,
-				  local->op_errno, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
+                         local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-	      dict_t *xdata)
-{
-	afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
-        int32_t call_count = 0;
-        int32_t op_errno = ENOMEM;
-
-	priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_FSYNCDIR;
-	if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
-
-        call_count = local->call_count;
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND (frame, afr_fsyncdir_cbk,
-                                    priv->children[i],
-                                    priv->children[i]->fops->fsyncdir,
-                                    fd, datasync, xdata);
-                        if (!--call_count)
-                                break;
-                }
+afr_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+             dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int32_t call_count = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_FSYNCDIR;
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    call_count = local->call_count;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND(frame, afr_fsyncdir_cbk, priv->children[i],
+                       priv->children[i]->fops->fsyncdir, fd, datasync, xdata);
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fsyncdir, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
 
 static int
-afr_serialized_lock_wind (call_frame_t *frame, xlator_t *this);
+afr_serialized_lock_wind(call_frame_t *frame, xlator_t *this);
 
 static gf_boolean_t
-afr_is_conflicting_lock_present (int32_t op_ret, int32_t op_errno)
+afr_is_conflicting_lock_present(int32_t op_ret, int32_t op_errno)
 {
-        if (op_ret == -1 && op_errno == EAGAIN)
-                return _gf_true;
-        return _gf_false;
+    if (op_ret == -1 && op_errno == EAGAIN)
+        return _gf_true;
+    return _gf_false;
 }
 
 static void
-afr_fop_lock_unwind (call_frame_t *frame, glusterfs_fop_t op, int32_t op_ret,
-                     int32_t op_errno, dict_t *xdata)
+afr_fop_lock_unwind(call_frame_t *frame, glusterfs_fop_t op, int32_t op_ret,
+                    int32_t op_errno, dict_t *xdata)
 {
-        switch (op) {
+    switch (op) {
         case GF_FOP_INODELK:
-                AFR_STACK_UNWIND (inodelk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(inodelk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_FINODELK:
-                AFR_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(finodelk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                AFR_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(entrylk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                AFR_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(fentrylk, frame, op_ret, op_errno, xdata);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 }
 
 static void
-afr_fop_lock_wind (call_frame_t *frame, xlator_t *this, int child_index,
-                   int32_t (*lock_cbk) (call_frame_t *, void *, xlator_t *,
-                                        int32_t, int32_t, dict_t *))
+afr_fop_lock_wind(call_frame_t *frame, xlator_t *this, int child_index,
+                  int32_t (*lock_cbk)(call_frame_t *, void *, xlator_t *,
+                                      int32_t, int32_t, dict_t *))
 {
-        afr_local_t *local = frame->local;
-        afr_private_t *priv = this->private;
-        int i = child_index;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    int i = child_index;
 
-        switch (local->op) {
+    switch (local->op) {
         case GF_FOP_INODELK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->inodelk,
-                                   (const char *)local->cont.inodelk.volume,
-                                   &local->loc, local->cont.inodelk.cmd,
-                                   &local->cont.inodelk.flock,
-                                   local->cont.inodelk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->inodelk,
+                (const char *)local->cont.inodelk.volume, &local->loc,
+                local->cont.inodelk.cmd, &local->cont.inodelk.flock,
+                local->cont.inodelk.xdata);
+            break;
         case GF_FOP_FINODELK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->finodelk,
-                                   (const char *)local->cont.inodelk.volume,
-                                   local->fd, local->cont.inodelk.cmd,
-                                   &local->cont.inodelk.flock,
-                                   local->cont.inodelk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->finodelk,
+                (const char *)local->cont.inodelk.volume, local->fd,
+                local->cont.inodelk.cmd, &local->cont.inodelk.flock,
+                local->cont.inodelk.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->entrylk,
-                                   local->cont.entrylk.volume, &local->loc,
-                                   local->cont.entrylk.basename,
-                                   local->cont.entrylk.cmd,
-                                   local->cont.entrylk.type,
-                                   local->cont.entrylk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->entrylk, local->cont.entrylk.volume,
+                &local->loc, local->cont.entrylk.basename,
+                local->cont.entrylk.cmd, local->cont.entrylk.type,
+                local->cont.entrylk.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->fentrylk,
-                                   local->cont.entrylk.volume, local->fd,
-                                   local->cont.entrylk.basename,
-                                   local->cont.entrylk.cmd,
-                                   local->cont.entrylk.type,
-                                   local->cont.entrylk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->fentrylk, local->cont.entrylk.volume,
+                local->fd, local->cont.entrylk.basename,
+                local->cont.entrylk.cmd, local->cont.entrylk.type,
+                local->cont.entrylk.xdata);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 }
 
 void
-afr_fop_lock_proceed (call_frame_t *frame)
+afr_fop_lock_proceed(call_frame_t *frame)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = frame->this->private;
-
-        if (local->fop_lock_state != AFR_FOP_LOCK_PARALLEL) {
-                afr_fop_lock_unwind (frame, local->op, local->op_ret,
-                                     local->op_errno, local->xdata_rsp);
-                return;
-        }
-        /* At least one child is up */
-        /*
-         * Non-blocking locks also need to be serialized.  Otherwise there is
-         * a chance that both the mounts which issued same non-blocking inodelk
-         * may endup not acquiring the lock on any-brick.
-         * Ex: Mount1 and Mount2
-         * request for full length lock on file f1.  Mount1 afr may acquire the
-         * partial lock on brick-1 and may not acquire the lock on brick-2
-         * because Mount2 already got the lock on brick-2, vice versa.  Since
-         * both the mounts only got partial locks, afr treats them as failure in
-         * gaining the locks and unwinds with EAGAIN errno.
-         */
-        local->op_ret = -1;
-        local->op_ret = EUCLEAN;
-        local->fop_lock_state = AFR_FOP_LOCK_SERIAL;
-        afr_local_replies_wipe (local, priv);
-        if (local->xdata_rsp)
-                dict_unref (local->xdata_rsp);
-        local->xdata_rsp = NULL;
-        switch (local->op) {
+    local = frame->local;
+    priv = frame->this->private;
+
+    if (local->fop_lock_state != AFR_FOP_LOCK_PARALLEL) {
+        afr_fop_lock_unwind(frame, local->op, local->op_ret, local->op_errno,
+                            local->xdata_rsp);
+        return;
+    }
+    /* At least one child is up */
+    /*
+     * Non-blocking locks also need to be serialized.  Otherwise there is
+     * a chance that both the mounts which issued same non-blocking inodelk
+     * may endup not acquiring the lock on any-brick.
+     * Ex: Mount1 and Mount2
+     * request for full length lock on file f1.  Mount1 afr may acquire the
+     * partial lock on brick-1 and may not acquire the lock on brick-2
+     * because Mount2 already got the lock on brick-2, vice versa.  Since
+     * both the mounts only got partial locks, afr treats them as failure in
+     * gaining the locks and unwinds with EAGAIN errno.
+     */
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
+    local->fop_lock_state = AFR_FOP_LOCK_SERIAL;
+    afr_local_replies_wipe(local, priv);
+    if (local->xdata_rsp)
+        dict_unref(local->xdata_rsp);
+    local->xdata_rsp = NULL;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                local->cont.inodelk.cmd = local->cont.inodelk.in_cmd;
-                local->cont.inodelk.flock = local->cont.inodelk.in_flock;
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-                local->cont.inodelk.xdata = NULL;
-                if (local->xdata_req)
-                        local->cont.inodelk.xdata = dict_ref (local->xdata_req);
-                break;
+            local->cont.inodelk.cmd = local->cont.inodelk.in_cmd;
+            local->cont.inodelk.flock = local->cont.inodelk.in_flock;
+            if (local->cont.inodelk.xdata)
+                dict_unref(local->cont.inodelk.xdata);
+            local->cont.inodelk.xdata = NULL;
+            if (local->xdata_req)
+                local->cont.inodelk.xdata = dict_ref(local->xdata_req);
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                local->cont.entrylk.cmd = local->cont.entrylk.in_cmd;
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-                local->cont.entrylk.xdata = NULL;
-                if (local->xdata_req)
-                        local->cont.entrylk.xdata = dict_ref (local->xdata_req);
-                break;
+            local->cont.entrylk.cmd = local->cont.entrylk.in_cmd;
+            if (local->cont.entrylk.xdata)
+                dict_unref(local->cont.entrylk.xdata);
+            local->cont.entrylk.xdata = NULL;
+            if (local->xdata_req)
+                local->cont.entrylk.xdata = dict_ref(local->xdata_req);
+            break;
         default:
-                break;
-        }
-        afr_serialized_lock_wind (frame, frame->this);
+            break;
+    }
+    afr_serialized_lock_wind(frame, frame->this);
 }
 
 static int32_t
-afr_unlock_partial_lock_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret,
-                             int32_t op_errno, dict_t *xdata)
+afr_unlock_partial_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int call_count = -1;
-        int child_index = (long)cookie;
-        uuid_t  gfid = {0};
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+    int child_index = (long)cookie;
+    uuid_t gfid = {0};
 
-        local = frame->local;
-        priv = this->private;
-
-        if (op_ret < 0 && op_errno != ENOTCONN) {
-                if (local->fd)
-                        gf_uuid_copy (gfid, local->fd->inode->gfid);
-                else
-                        loc_gfid (&local->loc, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "%s: Failed to unlock %s on %s "
-                        "with lk_owner: %s", uuid_utoa (gfid),
-                        gf_fop_list[local->op],
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
-
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                afr_fop_lock_proceed (frame);
+    local = frame->local;
+    priv = this->private;
 
-        return 0;
+    if (op_ret < 0 && op_errno != ENOTCONN) {
+        if (local->fd)
+            gf_uuid_copy(gfid, local->fd->inode->gfid);
+        else
+            loc_gfid(&local->loc, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "%s: Failed to unlock %s on %s "
+               "with lk_owner: %s",
+               uuid_utoa(gfid), gf_fop_list[local->op],
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
+
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        afr_fop_lock_proceed(frame);
+
+    return 0;
 }
 
 static int32_t
-afr_unlock_locks_and_proceed (call_frame_t *frame, xlator_t *this,
+afr_unlock_locks_and_proceed(call_frame_t *frame, xlator_t *this,
                              int call_count)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        if (call_count == 0) {
-                afr_fop_lock_proceed (frame);
-                goto out;
-        }
+    if (call_count == 0) {
+        afr_fop_lock_proceed(frame);
+        goto out;
+    }
 
-        local = frame->local;
-        priv = this->private;
-        local->call_count = call_count;
-        switch (local->op) {
+    local = frame->local;
+    priv = this->private;
+    local->call_count = call_count;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                local->cont.inodelk.flock.l_type = F_UNLCK;
-                local->cont.inodelk.cmd = F_SETLK;
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-                local->cont.inodelk.xdata = NULL;
-                break;
+            local->cont.inodelk.flock.l_type = F_UNLCK;
+            local->cont.inodelk.cmd = F_SETLK;
+            if (local->cont.inodelk.xdata)
+                dict_unref(local->cont.inodelk.xdata);
+            local->cont.inodelk.xdata = NULL;
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                local->cont.entrylk.cmd = ENTRYLK_UNLOCK;
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-                local->cont.entrylk.xdata = NULL;
-                break;
+            local->cont.entrylk.cmd = ENTRYLK_UNLOCK;
+            if (local->cont.entrylk.xdata)
+                dict_unref(local->cont.entrylk.xdata);
+            local->cont.entrylk.xdata = NULL;
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
 
-                if (local->replies[i].op_ret == -1)
-                        continue;
+        if (local->replies[i].op_ret == -1)
+            continue;
 
-                afr_fop_lock_wind (frame, this, i, afr_unlock_partial_lock_cbk);
+        afr_fop_lock_wind(frame, this, i, afr_unlock_partial_lock_cbk);
 
-                if (!--call_count)
-                        break;
-        }
+        if (!--call_count)
+            break;
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_fop_lock_done (call_frame_t *frame, xlator_t *this)
+afr_fop_lock_done(call_frame_t *frame, xlator_t *this)
 {
-        int i = 0;
-        int lock_count = 0;
-        unsigned char *success = NULL;
-
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    int lock_count = 0;
+    unsigned char *success = NULL;
 
-        local = frame->local;
-        priv = this->private;
-        success = alloca0(priv->child_count);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-                if (local->replies[i].op_ret == 0) {
-                        lock_count++;
-                        success[i] = 1;
-                }
+    local = frame->local;
+    priv = this->private;
+    success = alloca0(priv->child_count);
 
-                if (local->op_ret == -1 && local->op_errno == EAGAIN)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
 
-                if ((local->replies[i].op_ret == -1) &&
-                    (local->replies[i].op_errno == EAGAIN)) {
-                        local->op_ret = -1;
-                        local->op_errno = EAGAIN;
-                        continue;
-                }
+        if (local->replies[i].op_ret == 0) {
+            lock_count++;
+            success[i] = 1;
+        }
 
-                if (local->replies[i].op_ret == 0)
-                        local->op_ret = 0;
+        if (local->op_ret == -1 && local->op_errno == EAGAIN)
+            continue;
 
-                local->op_errno = local->replies[i].op_errno;
+        if ((local->replies[i].op_ret == -1) &&
+            (local->replies[i].op_errno == EAGAIN)) {
+            local->op_ret = -1;
+            local->op_errno = EAGAIN;
+            continue;
         }
 
-        if (afr_fop_lock_is_unlock (frame))
-                goto unwind;
+        if (local->replies[i].op_ret == 0)
+            local->op_ret = 0;
 
-        if (afr_is_conflicting_lock_present (local->op_ret, local->op_errno)) {
-                afr_unlock_locks_and_proceed (frame, this, lock_count);
-        } else if (priv->quorum_count && !afr_has_quorum (success, this)) {
-                local->fop_lock_state = AFR_FOP_LOCK_QUORUM_FAILED;
-                local->op_ret = -1;
-                local->op_errno = afr_final_errno (local, priv);
-                if (local->op_errno == 0)
-                        local->op_errno = afr_quorum_errno (priv);
-                afr_unlock_locks_and_proceed (frame, this, lock_count);
-        } else {
-                goto unwind;
-        }
+        local->op_errno = local->replies[i].op_errno;
+    }
 
-        return 0;
+    if (afr_fop_lock_is_unlock(frame))
+        goto unwind;
+
+    if (afr_is_conflicting_lock_present(local->op_ret, local->op_errno)) {
+        afr_unlock_locks_and_proceed(frame, this, lock_count);
+    } else if (priv->quorum_count && !afr_has_quorum(success, this, NULL)) {
+        local->fop_lock_state = AFR_FOP_LOCK_QUORUM_FAILED;
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
+        if (local->op_errno == 0)
+            local->op_errno = afr_quorum_errno(priv);
+        afr_unlock_locks_and_proceed(frame, this, lock_count);
+    } else {
+        goto unwind;
+    }
+
+    return 0;
 unwind:
-        afr_fop_lock_unwind (frame, local->op, local->op_ret,
-                             local->op_errno, local->xdata_rsp);
-        return 0;
+    afr_fop_lock_unwind(frame, local->op, local->op_ret, local->op_errno,
+                        local->xdata_rsp);
+    return 0;
 }
 
 static int
-afr_common_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_common_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int child_index = (long)cookie;
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->replies[child_index].valid = 1;
-        local->replies[child_index].op_ret = op_ret;
-        local->replies[child_index].op_errno = op_errno;
-        if (op_ret == 0 && xdata) {
-                local->replies[child_index].xdata = dict_ref (xdata);
-                LOCK (&frame->lock);
-                {
-                        if (!local->xdata_rsp)
-                                local->xdata_rsp = dict_ref (xdata);
-                }
-                UNLOCK (&frame->lock);
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (op_ret == 0 && xdata) {
+        local->replies[child_index].xdata = dict_ref(xdata);
+        LOCK(&frame->lock);
+        {
+            if (!local->xdata_rsp)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        return 0;
+        UNLOCK(&frame->lock);
+    }
+    return 0;
 }
 
 static int32_t
-afr_serialized_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_serialized_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int child_index = (long)cookie;
-        int next_child  = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = (long)cookie;
+    int next_child = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        for (next_child = child_index + 1; next_child < priv->child_count;
-             next_child++) {
-                if (local->child_up[next_child])
-                        break;
-        }
+    for (next_child = child_index + 1; next_child < priv->child_count;
+         next_child++) {
+        if (local->child_up[next_child])
+            break;
+    }
 
-        if (afr_is_conflicting_lock_present (op_ret, op_errno) ||
-            (next_child == priv->child_count)) {
-                afr_fop_lock_done (frame, this);
-        } else {
-                afr_fop_lock_wind (frame, this, next_child,
-                                   afr_serialized_lock_cbk);
-        }
+    if (afr_is_conflicting_lock_present(op_ret, op_errno) ||
+        (next_child == priv->child_count)) {
+        afr_fop_lock_done(frame, this);
+    } else {
+        afr_fop_lock_wind(frame, this, next_child, afr_serialized_lock_cbk);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_serialized_lock_wind (call_frame_t *frame, xlator_t *this)
+afr_serialized_lock_wind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local  = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        afr_fop_lock_wind (frame, this, i,
-                                           afr_serialized_lock_cbk);
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            afr_fop_lock_wind(frame, this, i, afr_serialized_lock_cbk);
+            break;
         }
-        return 0;
+    }
+    return 0;
 }
 
 static int32_t
-afr_parallel_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_parallel_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        int     call_count = 0;
+    int call_count = 0;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                afr_fop_lock_done (frame, this);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        afr_fop_lock_done(frame, this);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_parallel_lock_wind (call_frame_t *frame, xlator_t *this)
+afr_parallel_lock_wind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local  = NULL;
-        int         call_count = 0;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
-        call_count = local->call_count;
+    priv = this->private;
+    local = frame->local;
+    call_count = local->call_count;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->child_up[i])
-                        continue;
-                afr_fop_lock_wind (frame, this, i, afr_parallel_lock_cbk);
-                if (!--call_count)
-                        break;
-        }
-        return 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
+        afr_fop_lock_wind(frame, this, i, afr_parallel_lock_cbk);
+        if (!--call_count)
+            break;
+    }
+    return 0;
 }
 
 static int
-afr_fop_handle_lock (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = frame->local;
-        int op_errno = 0;
-
-        if (!afr_fop_lock_is_unlock (frame)) {
-                if (!afr_is_consistent_io_possible (local, this->private,
-                                                &op_errno))
-                        goto out;
-
-                switch (local->op) {
-                case GF_FOP_INODELK:
-                case GF_FOP_FINODELK:
-                        local->cont.inodelk.cmd = F_SETLK;
-                        break;
-                case GF_FOP_ENTRYLK:
-                case GF_FOP_FENTRYLK:
-                        local->cont.entrylk.cmd = ENTRYLK_LOCK_NB;
-                        break;
-                default:
-                        break;
-                }
+afr_fop_handle_lock(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = frame->local;
+    int op_errno = 0;
+
+    if (!afr_fop_lock_is_unlock(frame)) {
+        if (!afr_is_consistent_io_possible(local, this->private, &op_errno))
+            goto out;
+
+        switch (local->op) {
+            case GF_FOP_INODELK:
+            case GF_FOP_FINODELK:
+                local->cont.inodelk.cmd = F_SETLK;
+                break;
+            case GF_FOP_ENTRYLK:
+            case GF_FOP_FENTRYLK:
+                local->cont.entrylk.cmd = ENTRYLK_LOCK_NB;
+                break;
+            default:
+                break;
         }
+    }
 
-        if (local->xdata_req) {
-                switch (local->op) {
-                case GF_FOP_INODELK:
-                case GF_FOP_FINODELK:
-                        local->cont.inodelk.xdata = dict_ref (local->xdata_req);
-                        break;
-                case GF_FOP_ENTRYLK:
-                case GF_FOP_FENTRYLK:
-                        local->cont.entrylk.xdata = dict_ref (local->xdata_req);
-                        break;
-                default:
-                        break;
-                }
+    if (local->xdata_req) {
+        switch (local->op) {
+            case GF_FOP_INODELK:
+            case GF_FOP_FINODELK:
+                local->cont.inodelk.xdata = dict_ref(local->xdata_req);
+                break;
+            case GF_FOP_ENTRYLK:
+            case GF_FOP_FENTRYLK:
+                local->cont.entrylk.xdata = dict_ref(local->xdata_req);
+                break;
+            default:
+                break;
         }
+    }
 
-        local->fop_lock_state = AFR_FOP_LOCK_PARALLEL;
-        afr_parallel_lock_wind (frame, this);
+    local->fop_lock_state = AFR_FOP_LOCK_PARALLEL;
+    afr_parallel_lock_wind(frame, this);
 out:
-        return -op_errno;
+    return -op_errno;
 }
 
 static int32_t
-afr_handle_inodelk (call_frame_t *frame, glusterfs_fop_t fop,
-                    const char *volume, loc_t *loc, fd_t *fd, int32_t cmd,
-                    struct gf_flock *flock, dict_t *xdata)
-{
-        afr_local_t *local  = NULL;
-        int32_t op_errno = ENOMEM;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = fop;
-        if (loc)
-                loc_copy (&local->loc, loc);
-        if (fd)
-                local->fd = fd_ref (fd);
-
-        local->cont.inodelk.volume = gf_strdup (volume);
-        if (!local->cont.inodelk.volume) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        local->cont.inodelk.in_cmd = cmd;
-        local->cont.inodelk.cmd = cmd;
-        local->cont.inodelk.in_flock = *flock;
-        local->cont.inodelk.flock = *flock;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-
-        op_errno = -afr_fop_handle_lock (frame, frame->this);
-        if (op_errno)
-                goto out;
-        return 0;
+afr_handle_inodelk(call_frame_t *frame, xlator_t *this, glusterfs_fop_t fop,
+                   const char *volume, loc_t *loc, fd_t *fd, int32_t cmd,
+                   struct gf_flock *flock, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = fop;
+    if (loc)
+        loc_copy(&local->loc, loc);
+    if (fd && (flock->l_type != F_UNLCK)) {
+        AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+        local->fd = fd_ref(fd);
+    }
+
+    local->cont.inodelk.volume = gf_strdup(volume);
+    if (!local->cont.inodelk.volume) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->cont.inodelk.in_cmd = cmd;
+    local->cont.inodelk.cmd = cmd;
+    local->cont.inodelk.in_flock = *flock;
+    local->cont.inodelk.flock = *flock;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    op_errno = -afr_fop_handle_lock(frame, frame->this);
+    if (op_errno)
+        goto out;
+    return 0;
 out:
-        afr_fop_lock_unwind (frame, fop, -1, op_errno, NULL);
+    afr_fop_lock_unwind(frame, fop, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_inodelk (call_frame_t *frame, xlator_t *this,
-             const char *volume, loc_t *loc, int32_t cmd,
-             struct gf_flock *flock, dict_t *xdata)
+afr_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        afr_handle_inodelk (frame, GF_FOP_INODELK, volume, loc, NULL, cmd,
-                            flock, xdata);
-        return 0;
+    afr_handle_inodelk(frame, this, GF_FOP_INODELK, volume, loc, NULL, cmd,
+                       flock, xdata);
+    return 0;
 }
 
 int32_t
-afr_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-	      int32_t cmd, struct gf_flock *flock, dict_t *xdata)
+afr_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        afr_handle_inodelk (frame, GF_FOP_FINODELK, volume, NULL, fd, cmd,
-                            flock, xdata);
-        return 0;
+    afr_handle_inodelk(frame, this, GF_FOP_FINODELK, volume, NULL, fd, cmd,
+                       flock, xdata);
+    return 0;
 }
 
 static int
-afr_handle_entrylk (call_frame_t *frame, glusterfs_fop_t fop,
-                    const char *volume, loc_t *loc, fd_t *fd,
-                    const char *basename, entrylk_cmd cmd,
-                    entrylk_type type, dict_t *xdata)
+afr_handle_entrylk(call_frame_t *frame, xlator_t *this, glusterfs_fop_t fop,
+                   const char *volume, loc_t *loc, fd_t *fd,
+                   const char *basename, entrylk_cmd cmd, entrylk_type type,
+                   dict_t *xdata)
 {
-        afr_local_t *local  = NULL;
-        int32_t op_errno = ENOMEM;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = fop;
-        if (loc)
-                loc_copy (&local->loc, loc);
-        if (fd)
-                local->fd = fd_ref (fd);
-        local->cont.entrylk.cmd = cmd;
-        local->cont.entrylk.in_cmd = cmd;
-        local->cont.entrylk.type = type;
-        local->cont.entrylk.volume = gf_strdup (volume);
-        local->cont.entrylk.basename = gf_strdup (basename);
-        if (!local->cont.entrylk.volume || !local->cont.entrylk.basename) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-        op_errno = -afr_fop_handle_lock (frame, frame->this);
-        if (op_errno)
-                goto out;
-
-        return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = fop;
+    if (loc)
+        loc_copy(&local->loc, loc);
+    if (fd && (cmd != ENTRYLK_UNLOCK)) {
+        AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+        local->fd = fd_ref(fd);
+    }
+    local->cont.entrylk.cmd = cmd;
+    local->cont.entrylk.in_cmd = cmd;
+    local->cont.entrylk.type = type;
+    local->cont.entrylk.volume = gf_strdup(volume);
+    local->cont.entrylk.basename = gf_strdup(basename);
+    if (!local->cont.entrylk.volume || !local->cont.entrylk.basename) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+    op_errno = -afr_fop_handle_lock(frame, frame->this);
+    if (op_errno)
+        goto out;
+
+    return 0;
 out:
-        afr_fop_lock_unwind (frame, fop, -1, op_errno, NULL);
-        return 0;
+    afr_fop_lock_unwind(frame, fop, -1, op_errno, NULL);
+    return 0;
 }
 
 int
-afr_entrylk (call_frame_t *frame, xlator_t *this, const char *volume,
-	     loc_t *loc, const char *basename, entrylk_cmd cmd,
-	     entrylk_type type, dict_t *xdata)
+afr_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata)
 {
-        afr_handle_entrylk (frame, GF_FOP_ENTRYLK, volume, loc, NULL, basename,
-                            cmd, type, xdata);
-        return 0;
+    afr_handle_entrylk(frame, this, GF_FOP_ENTRYLK, volume, loc, NULL, basename,
+                       cmd, type, xdata);
+    return 0;
 }
 
 int
-afr_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-              const char *basename, entrylk_cmd cmd, entrylk_type type,
-	      dict_t *xdata)
+afr_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             const char *basename, entrylk_cmd cmd, entrylk_type type,
+             dict_t *xdata)
 {
-        afr_handle_entrylk (frame, GF_FOP_FENTRYLK, volume, NULL, fd, basename,
-                            cmd, type, xdata);
-        return 0;
+    afr_handle_entrylk(frame, this, GF_FOP_FENTRYLK, volume, NULL, fd, basename,
+                       cmd, type, xdata);
+    return 0;
 }
 
-
 int
-afr_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-		int op_errno, struct statvfs *statvfs, dict_t *xdata)
+afr_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = 0;
-	struct statvfs *buf = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    struct statvfs *buf = NULL;
 
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
-
-                if (op_ret != 0) {
-                        local->op_errno = op_errno;
-			goto unlock;
-		}
-
-		local->op_ret = op_ret;
-
-		buf = &local->cont.statfs.buf;
-		if (local->cont.statfs.buf_set) {
-			if (statvfs->f_bavail < buf->f_bavail) {
-				*buf = *statvfs;
-				if (xdata) {
-					if (local->xdata_rsp)
-						dict_unref (local->xdata_rsp);
-					local->xdata_rsp = dict_ref (xdata);
-				}
-			}
-		} else {
-			*buf = *statvfs;
-			local->cont.statfs.buf_set = 1;
-			if (xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		}
+    local = frame->local;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret != 0) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        call_count = afr_frame_return (frame);
+        local->op_ret = op_ret;
+
+        buf = &local->cont.statfs.buf;
+        if (local->cont.statfs.buf_set) {
+            if (statvfs->f_bavail < buf->f_bavail) {
+                *buf = *statvfs;
+                if (xdata) {
+                    if (local->xdata_rsp)
+                        dict_unref(local->xdata_rsp);
+                    local->xdata_rsp = dict_ref(xdata);
+                }
+            }
+        } else {
+            *buf = *statvfs;
+            local->cont.statfs.buf_set = 1;
+            if (xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        }
+    }
+unlock:
+    call_count = --local->call_count;
+    UNLOCK(&frame->lock);
 
-        if (call_count == 0)
-                AFR_STACK_UNWIND (statfs, frame, local->op_ret, local->op_errno,
-                                  &local->cont.statfs.buf, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                         &local->cont.statfs.buf, local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+afr_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_STATFS;
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    if (priv->arbiter_count == 1 && local->child_up[ARBITER_BRICK_INDEX])
+        local->call_count--;
+    call_count = local->call_count;
+    if (!call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            if (AFR_IS_ARBITER_BRICK(priv, i))
+                continue;
+            STACK_WIND(frame, afr_statfs_cbk, priv->children[i],
+                       priv->children[i]->fops->statfs, loc, xdata);
+            if (!--call_count)
+                break;
+        }
+    }
+
+    return 0;
+out:
+    AFR_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
+
+    return 0;
+}
+
+int32_t
+afr_lk_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                  dict_t *xdata)
 {
-        afr_local_t   *  local       = NULL;
-	afr_private_t   *priv        = NULL;
-        int              i           = 0;
-        int              call_count = 0;
-        int32_t          op_errno    = ENOMEM;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = this->private;
+    int call_count = -1;
+    int child_index = (long)cookie;
+
+    local = frame->local;
 
-	priv = this->private;
+    if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "gfid=%s: unlock failed on subvolume %s "
+               "with lock owner %s",
+               uuid_utoa(local->fd->inode->gfid),
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno, NULL,
+                         local->xdata_rsp);
+    }
 
-        local->op = GF_FOP_STATFS;
-	if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
+    return 0;
+}
 
-        if (priv->arbiter_count == 1 && local->child_up[ARBITER_BRICK_INDEX])
-                local->call_count--;
-        call_count = local->call_count;
-	if (!call_count) {
-		op_errno = ENOTCONN;
-		goto out;
-	}
+int32_t
+afr_lk_unlock(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        if (AFR_IS_ARBITER_BRICK(priv, i))
-                                continue;
-                        STACK_WIND (frame, afr_statfs_cbk,
-                                    priv->children[i],
-                                    priv->children[i]->fops->statfs,
-                                    loc, xdata);
-                        if (!--call_count)
-                                break;
-                }
-        }
+    local = frame->local;
+    priv = this->private;
 
-	return 0;
-out:
-	AFR_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
+    call_count = afr_locked_nodes_count(local->cont.lk.locked_nodes,
+                                        priv->child_count);
 
+    if (call_count == 0) {
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno, NULL,
+                         local->xdata_rsp);
         return 0;
-}
+    }
+
+    local->call_count = call_count;
+
+    local->cont.lk.user_flock.l_type = F_UNLCK;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->cont.lk.locked_nodes[i]) {
+            STACK_WIND_COOKIE(frame, afr_lk_unlock_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->lk,
+                              local->fd, F_SETLK, &local->cont.lk.user_flock,
+                              NULL);
+
+            if (!--call_count)
+                break;
+        }
+    }
 
+    return 0;
+}
 
 int32_t
-afr_lk_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-                   dict_t *xdata)
+afr_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+           int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = this->private;
-        int call_count = -1;
-        int child_index = (long)cookie;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = -1;
 
-        local = frame->local;
+    local = frame->local;
+    priv = this->private;
 
-        if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "gfid=%s: unlock failed on subvolume %s "
-                        "with lock owner %s",
-                        uuid_utoa (local->fd->inode->gfid),
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
+    child_index = (long)cookie;
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  NULL, local->xdata_rsp);
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    if (op_ret < 0 && op_errno == EAGAIN) {
+        local->op_ret = -1;
+        local->op_errno = EAGAIN;
 
+        afr_lk_unlock(frame, this);
         return 0;
-}
+    }
+
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->op_errno = 0;
+        local->cont.lk.locked_nodes[child_index] = 1;
+        local->cont.lk.ret_flock = *lock;
+    }
+
+    child_index++;
+
+    if (child_index < priv->child_count) {
+        STACK_WIND_COOKIE(frame, afr_lk_cbk, (void *)(long)child_index,
+                          priv->children[child_index],
+                          priv->children[child_index]->fops->lk, local->fd,
+                          local->cont.lk.cmd, &local->cont.lk.user_flock,
+                          local->xdata_req);
+    } else if (priv->quorum_count &&
+               !afr_has_quorum(local->cont.lk.locked_nodes, this, NULL)) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
 
+        afr_lk_unlock(frame, this);
+    } else {
+        if (local->op_ret < 0)
+            local->op_errno = afr_final_errno(local, priv);
 
-int32_t
-afr_lk_unlock (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   * local = NULL;
-        afr_private_t * priv  = NULL;
-        int i = 0;
-        int call_count = 0;
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno,
+                         &local->cont.lk.ret_flock, local->xdata_rsp);
+    }
 
-        local = frame->local;
-        priv  = this->private;
+    return 0;
+}
 
-        call_count = afr_locked_nodes_count (local->cont.lk.locked_nodes,
-                                             priv->child_count);
+int
+afr_lk_transaction_cbk(int ret, call_frame_t *frame, void *opaque)
+{
+    return 0;
+}
+
+int
+afr_lk_txn_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                    dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int child_index = -1;
+
+    local = frame->local;
+    child_index = (long)cookie;
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->op_errno = 0;
+        local->cont.lk.locked_nodes[child_index] = 1;
+        local->cont.lk.ret_flock = *lock;
+    }
+    syncbarrier_wake(&local->barrier);
+    return 0;
+}
 
-        if (call_count == 0) {
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  NULL, local->xdata_rsp);
-                return 0;
+int
+afr_lk_txn_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                      dict_t *xdata)
+{
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    int child_index = (long)cookie;
+
+    if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "gfid=%s: unlock failed on subvolume %s "
+               "with lock owner %s",
+               uuid_utoa(local->fd->inode->gfid),
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
+    return 0;
+}
+int
+afr_lk_transaction(void *opaque)
+{
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    char *wind_on = NULL;
+    int op_errno = 0;
+    int i = 0;
+    int ret = 0;
+
+    frame = (call_frame_t *)opaque;
+    local = frame->local;
+    this = frame->this;
+    priv = this->private;
+    wind_on = alloca0(priv->child_count);
+
+    if (priv->arbiter_count || priv->child_count != 3) {
+        op_errno = ENOTSUP;
+        gf_msg(frame->this->name, GF_LOG_ERROR, op_errno, AFR_MSG_LK_HEAL_DOM,
+               "%s: Lock healing supported only for replica 3 volumes.",
+               uuid_utoa(local->fd->inode->gfid));
+        goto err;
+    }
+
+    op_errno = -afr_dom_lock_acquire(frame);  // Released during
+                                              // AFR_STACK_UNWIND
+    if (op_errno != 0) {
+        goto err;
+    }
+    if (priv->quorum_count &&
+        !afr_has_quorum(local->cont.lk.dom_locked_nodes, this, NULL)) {
+        op_errno = afr_final_errno(local, priv);
+        goto err;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->child_up[i] && local->cont.lk.dom_locked_nodes[i])
+            wind_on[i] = 1;
+    }
+    AFR_ONLIST(wind_on, frame, afr_lk_txn_wind_cbk, lk, local->fd,
+               local->cont.lk.cmd, &local->cont.lk.user_flock,
+               local->xdata_req);
+
+    if (priv->quorum_count &&
+        !afr_has_quorum(local->cont.lk.locked_nodes, this, NULL)) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
+        goto unlock;
+    } else {
+        if (local->cont.lk.user_flock.l_type == F_UNLCK)
+            ret = afr_remove_lock_from_saved_locks(local, this);
+        else
+            ret = afr_add_lock_to_saved_locks(frame, this);
+        if (ret) {
+            local->op_ret = -1;
+            local->op_errno = -ret;
+            goto unlock;
         }
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno,
+                         &local->cont.lk.ret_flock, local->xdata_rsp);
+    }
 
-        local->call_count = call_count;
+    return 0;
 
-        local->cont.lk.user_flock.l_type = F_UNLCK;
+unlock:
+    local->cont.lk.user_flock.l_type = F_UNLCK;
+    AFR_ONLIST(local->cont.lk.locked_nodes, frame, afr_lk_txn_unlock_cbk, lk,
+               local->fd, F_SETLK, &local->cont.lk.user_flock, NULL);
+err:
+    AFR_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
+    return -1;
+}
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->cont.lk.locked_nodes[i]) {
-                        STACK_WIND_COOKIE (frame, afr_lk_unlock_cbk,
-                                    (void *) (long) i, priv->children[i],
-                                    priv->children[i]->fops->lk,
-                                    local->fd, F_SETLK,
-                                    &local->cont.lk.user_flock, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+int
+afr_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+       struct gf_flock *flock, dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
+    int i = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_LK;
+    if (!afr_lk_is_unlock(cmd, flock)) {
+        AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+        if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+            goto out;
+    }
+
+    local->cont.lk.locked_nodes = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lk.locked_nodes),
+        gf_afr_mt_char);
+
+    if (!local->cont.lk.locked_nodes) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->fd = fd_ref(fd);
+    local->cont.lk.cmd = cmd;
+    local->cont.lk.user_flock = *flock;
+    local->cont.lk.ret_flock = *flock;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    if (afr_is_lock_mode_mandatory(xdata)) {
+        ret = synctask_new(this->ctx->env, afr_lk_transaction,
+                           afr_lk_transaction_cbk, frame, frame);
+        if (ret) {
+            op_errno = ENOMEM;
+            goto out;
         }
-
         return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_lk_cbk, (void *)(long)0, priv->children[i],
+                      priv->children[i]->fops->lk, fd, cmd, flock,
+                      local->xdata_req);
+
+    return 0;
+out:
+    AFR_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
+
+    return 0;
 }
 
+int32_t
+afr_lease_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
+                     dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+
+    local = frame->local;
+    call_count = afr_frame_return(frame);
+
+    if (call_count == 0)
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno, lease,
+                         xdata);
+
+    return 0;
+}
 
 int32_t
-afr_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-            dict_t *xdata)
+afr_lease_unlock(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int child_index = -1;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
 
+    local = frame->local;
+    priv = this->private;
 
-        local = frame->local;
-        priv  = this->private;
+    call_count = afr_locked_nodes_count(local->cont.lease.locked_nodes,
+                                        priv->child_count);
 
-        child_index = (long) cookie;
+    if (call_count == 0) {
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno,
+                         &local->cont.lease.ret_lease, NULL);
+        return 0;
+    }
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        if (op_ret < 0 && op_errno == EAGAIN) {
-                local->op_ret   = -1;
-                local->op_errno = EAGAIN;
+    local->call_count = call_count;
 
-                afr_lk_unlock (frame, this);
-                return 0;
-        }
+    local->cont.lease.user_lease.cmd = GF_UNLK_LEASE;
 
-        if (op_ret == 0) {
-                local->op_ret        = 0;
-                local->op_errno      = 0;
-                local->cont.lk.locked_nodes[child_index] = 1;
-                local->cont.lk.ret_flock = *lock;
-        }
-
-        child_index++;
-
-        if (child_index < priv->child_count) {
-                STACK_WIND_COOKIE (frame, afr_lk_cbk, (void *) (long) child_index,
-                                   priv->children[child_index],
-                                   priv->children[child_index]->fops->lk,
-                                   local->fd, local->cont.lk.cmd,
-                                   &local->cont.lk.user_flock,
-                                   local->xdata_req);
-        } else if (priv->quorum_count &&
-                   !afr_has_quorum (local->cont.lk.locked_nodes, this)) {
-                local->op_ret   = -1;
-                local->op_errno = afr_final_errno (local, priv);
-
-                afr_lk_unlock (frame, this);
-        } else {
-                if (local->op_ret < 0)
-                        local->op_errno = afr_final_errno (local, priv);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->cont.lease.locked_nodes[i]) {
+            STACK_WIND(frame, afr_lease_unlock_cbk, priv->children[i],
+                       priv->children[i]->fops->lease, &local->loc,
+                       &local->cont.lease.user_lease, NULL);
 
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  &local->cont.lk.ret_flock, local->xdata_rsp);
+            if (!--call_count)
+                break;
         }
+    }
+
+    return 0;
+}
+
+int32_t
+afr_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct gf_lease *lease, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = -1;
+
+    local = frame->local;
+    priv = this->private;
 
+    child_index = (long)cookie;
+
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    if (op_ret < 0 && op_errno == EAGAIN) {
+        local->op_ret = -1;
+        local->op_errno = EAGAIN;
+
+        afr_lease_unlock(frame, this);
         return 0;
+    }
+
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->op_errno = 0;
+        local->cont.lease.locked_nodes[child_index] = 1;
+        local->cont.lease.ret_lease = *lease;
+    }
+
+    child_index++;
+    if (child_index < priv->child_count) {
+        STACK_WIND_COOKIE(frame, afr_lease_cbk, (void *)(long)child_index,
+                          priv->children[child_index],
+                          priv->children[child_index]->fops->lease, &local->loc,
+                          &local->cont.lease.user_lease, xdata);
+    } else if (priv->quorum_count &&
+               !afr_has_quorum(local->cont.lease.locked_nodes, this, NULL)) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
+
+        afr_lease_unlock(frame, this);
+    } else {
+        if (local->op_ret < 0)
+            local->op_errno = afr_final_errno(local, priv);
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno,
+                         &local->cont.lease.ret_lease, NULL);
+    }
+
+    return 0;
 }
 
 int
-afr_lk (call_frame_t *frame, xlator_t *this,
-        fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata)
+afr_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+          struct gf_lease *lease, dict_t *xdata)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
-        int32_t op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = GF_FOP_LK;
-        if (!afr_lk_is_unlock (cmd, flock) &&
-            !afr_is_consistent_io_possible (local, priv, &op_errno))
-                goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.lk.locked_nodes = GF_CALLOC (priv->child_count,
-                                                 sizeof (*local->cont.lk.locked_nodes),
-                                                 gf_afr_mt_char);
+    local->op = GF_FOP_LEASE;
+    local->cont.lease.locked_nodes = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lease.locked_nodes),
+        gf_afr_mt_char);
 
-        if (!local->cont.lk.locked_nodes) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (!local->cont.lease.locked_nodes) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-        local->fd            = fd_ref (fd);
-        local->cont.lk.cmd   = cmd;
-        local->cont.lk.user_flock = *flock;
-        local->cont.lk.ret_flock = *flock;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
+    loc_copy(&local->loc, loc);
+    local->cont.lease.user_lease = *lease;
+    local->cont.lease.ret_lease = *lease;
 
-        STACK_WIND_COOKIE (frame, afr_lk_cbk, (void *) (long) 0,
-                           priv->children[i],
-                           priv->children[i]->fops->lk,
-                           fd, cmd, flock, local->xdata_req);
+    STACK_WIND_COOKIE(frame, afr_lease_cbk, (void *)(long)0, priv->children[0],
+                      priv->children[0]->fops->lease, loc, lease, xdata);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lk, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(lease, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_local_t   *local          = NULL;
-        int            child_index    = (long)cookie;
-        int            call_count     = 0;
-        gf_boolean_t   failed         = _gf_false;
-        gf_boolean_t   succeded       = _gf_false;
-        int            i              = 0;
-        afr_private_t *priv           = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-        local->replies[child_index].valid = 1;
-        local->replies[child_index].op_ret = op_ret;
-        local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
-
-        call_count = afr_frame_return (frame);
-        if (call_count)
-                goto out;
-        /* If any of the subvolumes failed with other than ENOTCONN
-         * return error else return success unless all the subvolumes
-         * failed.
-         * TODO: In case of failure, we need to unregister the xattrs
-         * from the other subvolumes where it succeded (once upcall
-         * fixes the Bz-1371622)*/
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-                if (local->replies[i].op_ret < 0 &&
-                    local->replies[i].op_errno != ENOTCONN) {
-                        local->op_ret = local->replies[i].op_ret;
-                        local->op_errno = local->replies[i].op_errno;
-                        if (local->xdata_rsp)
-                                dict_unref (local->xdata_rsp);
-                        local->xdata_rsp = NULL;
-                        if (local->replies[i].xdata) {
-                                local->xdata_rsp =
-                                        dict_ref (local->replies[i].xdata);
-                        }
-                        failed = _gf_true;
-                        break;
-                }
-                if (local->replies[i].op_ret == 0) {
-                        succeded = _gf_true;
-                        local->op_ret = 0;
-                        local->op_errno = 0;
-                        if (!local->xdata_rsp && local->replies[i].xdata) {
-                                local->xdata_rsp =
-                                        dict_ref (local->replies[i].xdata);
-                        }
-                }
+afr_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = 0;
+    gf_boolean_t failed = _gf_false;
+    gf_boolean_t succeeded = _gf_false;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
+
+    call_count = afr_frame_return(frame);
+    if (call_count)
+        goto out;
+    /* If any of the subvolumes failed with other than ENOTCONN
+     * return error else return success unless all the subvolumes
+     * failed.
+     * TODO: In case of failure, we need to unregister the xattrs
+     * from the other subvolumes where it succeeded (once upcall
+     * fixes the Bz-1371622)*/
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0 &&
+            local->replies[i].op_errno != ENOTCONN) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+            if (local->xdata_rsp)
+                dict_unref(local->xdata_rsp);
+            local->xdata_rsp = NULL;
+            if (local->replies[i].xdata) {
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+            failed = _gf_true;
+            break;
+        }
+        if (local->replies[i].op_ret == 0) {
+            succeeded = _gf_true;
+            local->op_ret = 0;
+            local->op_errno = 0;
+            if (!local->xdata_rsp && local->replies[i].xdata) {
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
         }
+    }
 
-        if (!succeded && !failed) {
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-        }
+    if (!succeeded && !failed) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+    }
 
-        AFR_STACK_UNWIND (ipc, frame, local->op_ret, local->op_errno,
-                          local->xdata_rsp);
+    AFR_STACK_UNWIND(ipc, frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-afr_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+afr_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        afr_local_t    *local    = NULL;
-        int32_t         op_errno = -1;
-        afr_private_t  *priv     = NULL;
-        int             i        = 0;
-        int             call_cnt = -1;
+    afr_local_t *local = NULL;
+    int32_t op_errno = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_cnt = -1;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
 
-        if (op != GF_IPC_TARGET_UPCALL)
-                goto wind_default;
+    if (op != GF_IPC_TARGET_UPCALL)
+        goto wind_default;
 
-        VALIDATE_OR_GOTO (this->private, err);
-        priv = this->private;
+    VALIDATE_OR_GOTO(this->private, err);
+    priv = this->private;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto err;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto err;
 
-        call_cnt = local->call_count;
+    call_cnt = local->call_count;
 
-        if (xdata) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (dict_set_int8 (xdata, priv->pending_key[i], 0) < 0)
-                                goto err;
-                }
+    if (xdata) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (dict_set_int8(xdata, priv->pending_key[i], 0) < 0)
+                goto err;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->child_up[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
 
-                STACK_WIND_COOKIE (frame, afr_ipc_cbk,
-                                   (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->ipc,
-                                   op, xdata);
-                if (!--call_cnt)
-                        break;
-        }
-        return 0;
+        STACK_WIND_COOKIE(frame, afr_ipc_cbk, (void *)(long)i,
+                          priv->children[i], priv->children[i]->fops->ipc, op,
+                          xdata);
+        if (!--call_cnt)
+            break;
+    }
+    return 0;
 
 err:
-        if (op_errno == -1)
-                op_errno = errno;
-        AFR_STACK_UNWIND (ipc, frame, -1, op_errno, NULL);
+    if (op_errno == -1)
+        op_errno = errno;
+    AFR_STACK_UNWIND(ipc, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 
 wind_default:
-        STACK_WIND (frame, default_ipc_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->ipc, op, xdata);
-        return 0;
+    STACK_WIND(frame, default_ipc_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ipc, op, xdata);
+    return 0;
 }
 
 int
-afr_forget (xlator_t *this, inode_t *inode)
+afr_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t        ctx_int = 0;
-        afr_inode_ctx_t *ctx    = NULL;
-
-        afr_spb_choice_timeout_cancel (this, inode);
-        inode_ctx_del (inode, this, &ctx_int);
-        if (!ctx_int)
-                return 0;
+    uint64_t ctx_int = 0;
+    afr_inode_ctx_t *ctx = NULL;
 
-        ctx = (afr_inode_ctx_t *)ctx_int;
-        GF_FREE (ctx);
+    afr_spb_choice_timeout_cancel(this, inode);
+    inode_ctx_del(inode, this, &ctx_int);
+    if (!ctx_int)
         return 0;
+
+    ctx = (afr_inode_ctx_t *)(uintptr_t)ctx_int;
+    afr_inode_ctx_destroy(ctx);
+    return 0;
 }
 
 int
-afr_priv_dump (xlator_t *this)
-{
-        afr_private_t *priv = NULL;
-        char  key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char  key[GF_DUMP_MAX_BUF_LEN];
-        int   i = 0;
-
-
-        GF_ASSERT (this);
-        priv = this->private;
-
-        GF_ASSERT (priv);
-        snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
-        gf_proc_dump_add_section(key_prefix);
-        gf_proc_dump_write("child_count", "%u", priv->child_count);
-        for (i = 0; i < priv->child_count; i++) {
-                sprintf (key, "child_up[%d]", i);
-                gf_proc_dump_write(key, "%d", priv->child_up[i]);
-                sprintf (key, "pending_key[%d]", i);
-                gf_proc_dump_write(key, "%s", priv->pending_key[i]);
-        }
-        gf_proc_dump_write("data_self_heal", "%s", priv->data_self_heal);
-        gf_proc_dump_write("metadata_self_heal", "%d", priv->metadata_self_heal);
-        gf_proc_dump_write("entry_self_heal", "%d", priv->entry_self_heal);
-        gf_proc_dump_write("data_change_log", "%d", priv->data_change_log);
-        gf_proc_dump_write("metadata_change_log", "%d", priv->metadata_change_log);
-        gf_proc_dump_write("entry-change_log", "%d", priv->entry_change_log);
-        gf_proc_dump_write("read_child", "%d", priv->read_child);
-        gf_proc_dump_write("favorite_child", "%d", priv->favorite_child);
-        gf_proc_dump_write("wait_count", "%u", priv->wait_count);
-        gf_proc_dump_write("quorum-reads", "%d", priv->quorum_reads);
-        gf_proc_dump_write("heal-wait-queue-length", "%d",
-                           priv->heal_wait_qlen);
-        gf_proc_dump_write("heal-waiters", "%d", priv->heal_waiters);
-        gf_proc_dump_write("background-self-heal-count", "%d",
-                           priv->background_self_heal_count);
-        gf_proc_dump_write("healers", "%d", priv->healers);
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                gf_proc_dump_write ("quorum-type", "auto");
-        } else if (priv->quorum_count == 0) {
-                gf_proc_dump_write ("quorum-type", "none");
-        } else {
-                gf_proc_dump_write("quorum-type", "fixed");
-                gf_proc_dump_write("quorum-count", "%d", priv->quorum_count);
-        }
-
-        return 0;
+afr_priv_dump(xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+
+    GF_ASSERT(this);
+    priv = this->private;
+
+    GF_ASSERT(priv);
+    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
+    gf_proc_dump_add_section("%s", key_prefix);
+    gf_proc_dump_write("child_count", "%u", priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        sprintf(key, "child_up[%d]", i);
+        gf_proc_dump_write(key, "%d", priv->child_up[i]);
+        sprintf(key, "pending_key[%d]", i);
+        gf_proc_dump_write(key, "%s", priv->pending_key[i]);
+        sprintf(key, "pending_reads[%d]", i);
+        gf_proc_dump_write(key, "%" PRId64,
+                           GF_ATOMIC_GET(priv->pending_reads[i]));
+        sprintf(key, "child_latency[%d]", i);
+        gf_proc_dump_write(key, "%" PRId64, priv->child_latency[i]);
+        sprintf(key, "halo_child_up[%d]", i);
+        gf_proc_dump_write(key, "%d", priv->halo_child_up[i]);
+    }
+    gf_proc_dump_write("data_self_heal", "%d", priv->data_self_heal);
+    gf_proc_dump_write("metadata_self_heal", "%d", priv->metadata_self_heal);
+    gf_proc_dump_write("entry_self_heal", "%d", priv->entry_self_heal);
+    gf_proc_dump_write("read_child", "%d", priv->read_child);
+    gf_proc_dump_write("wait_count", "%u", priv->wait_count);
+    gf_proc_dump_write("heal-wait-queue-length", "%d", priv->heal_wait_qlen);
+    gf_proc_dump_write("heal-waiters", "%d", priv->heal_waiters);
+    gf_proc_dump_write("background-self-heal-count", "%d",
+                       priv->background_self_heal_count);
+    gf_proc_dump_write("healers", "%d", priv->healers);
+    gf_proc_dump_write("read-hash-mode", "%d", priv->hash_mode);
+    gf_proc_dump_write("use-anonymous-inode", "%d", priv->use_anon_inode);
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        gf_proc_dump_write("quorum-type", "auto");
+    } else if (priv->quorum_count == 0) {
+        gf_proc_dump_write("quorum-type", "none");
+    } else {
+        gf_proc_dump_write("quorum-type", "fixed");
+        gf_proc_dump_write("quorum-count", "%d", priv->quorum_count);
+    }
+    gf_proc_dump_write("up", "%u", afr_has_quorum(priv->child_up, this, NULL));
+    if (priv->thin_arbiter_count) {
+        gf_proc_dump_write("ta_child_up", "%d", priv->ta_child_up);
+        gf_proc_dump_write("ta_bad_child_index", "%d",
+                           priv->ta_bad_child_index);
+        gf_proc_dump_write("ta_notify_dom_lock_offset", "%" PRId64,
+                           priv->ta_notify_dom_lock_offset);
+    }
+
+    return 0;
 }
 
-
 /**
  * find_child_index - find the child's index in the array of subvolumes
  * @this: AFR
@@ -4635,1785 +5723,2156 @@ afr_priv_dump (xlator_t *this)
  */
 
 static int
-find_child_index (xlator_t *this, xlator_t *child)
+afr_find_child_index(xlator_t *this, xlator_t *child)
 {
-        afr_private_t *priv = NULL;
-        int i = -1;
+    afr_private_t *priv = NULL;
+    int child_count = -1;
+    int i = -1;
 
-        priv = this->private;
+    priv = this->private;
+    child_count = priv->child_count;
+    if (priv->thin_arbiter_count) {
+        child_count++;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if ((xlator_t *) child == priv->children[i])
-                        break;
-        }
+    for (i = 0; i < child_count; i++) {
+        if ((xlator_t *)child == priv->children[i])
+            break;
+    }
 
-        return i;
+    return i;
 }
 
-static int
-__afr_get_up_children_count (afr_private_t *priv)
+int
+__afr_get_up_children_count(afr_private_t *priv)
 {
-        int             up_children         = 0;
-        int             i = 0;
+    int up_children = 0;
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++)
-                if (priv->child_up[i] == 1)
-                        up_children++;
+    for (i = 0; i < priv->child_count; i++)
+        if (priv->child_up[i] == 1)
+            up_children++;
 
-        return up_children;
+    return up_children;
 }
 
-glusterfs_event_t
-__afr_transform_event_from_state (afr_private_t *priv)
+static int
+__get_heard_from_all_status(xlator_t *this)
 {
-        int i = 0;
-        int up_children = 0;
-
-        if (AFR_COUNT (priv->last_event, priv->child_count) ==
-                       priv->child_count)
-                /* have_heard_from_all. Let afr_notify() do the propagation. */
-                return GF_EVENT_MAXVAL;
+    afr_private_t *priv = this->private;
+    int i;
 
-        up_children = __afr_get_up_children_count (priv);
-        /* Treat the children with pending notification, as having sent a
-         * GF_EVENT_CHILD_DOWN. i.e. set the event as GF_EVENT_SOME_DESCENDENT_DOWN,
-         * as done in afr_notify() */
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->last_event[i])
-                        continue;
-                priv->last_event[i] = GF_EVENT_SOME_DESCENDENT_DOWN;
-                priv->child_up[i] = 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!priv->last_event[i]) {
+            return 0;
         }
+    }
+    if (priv->thin_arbiter_count && !priv->ta_child_up) {
+        return 0;
+    }
+    return 1;
+}
 
-        if (up_children)
-                /* We received at least one child up */
-                return GF_EVENT_CHILD_UP;
-        else
-                return GF_EVENT_CHILD_DOWN;
+glusterfs_event_t
+__afr_transform_event_from_state(xlator_t *this)
+{
+    int i = 0;
+    int up_children = 0;
+    afr_private_t *priv = this->private;
 
+    if (__get_heard_from_all_status(this))
+        /* have_heard_from_all. Let afr_notify() do the propagation. */
         return GF_EVENT_MAXVAL;
-}
 
-static void
-afr_notify_cbk (void *data)
-{
-        xlator_t *this = data;
-        afr_private_t *priv = this->private;
-        glusterfs_event_t event = GF_EVENT_MAXVAL;
-        gf_boolean_t propagate = _gf_false;
+    up_children = __afr_get_up_children_count(priv);
+    /* Treat the children with pending notification, as having sent a
+     * GF_EVENT_CHILD_DOWN. i.e. set the event as GF_EVENT_SOME_DESCENDENT_DOWN,
+     * as done in afr_notify() */
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->last_event[i])
+            continue;
+        priv->last_event[i] = GF_EVENT_SOME_DESCENDENT_DOWN;
+        priv->child_up[i] = 0;
+    }
 
-        LOCK (&priv->lock);
-        {
-                if (!priv->timer) {
-                        /*
-                         * Either child_up/child_down is already sent to parent.
-                         * This is a spurious wake up.
-                         */
-                        goto unlock;
-                }
-                priv->timer = NULL;
-                event = __afr_transform_event_from_state (priv);
-                if (event != GF_EVENT_MAXVAL)
-                        propagate = _gf_true;
-        }
-unlock:
-        UNLOCK (&priv->lock);
-        if (propagate)
-                default_notify (this, event, NULL);
+    if (up_children)
+        /* We received at least one child up */
+        return GF_EVENT_CHILD_UP;
+    else
+        return GF_EVENT_CHILD_DOWN;
+
+    return GF_EVENT_MAXVAL;
 }
 
 static void
-__afr_launch_notify_timer (xlator_t *this, afr_private_t *priv)
-{
-
-        struct timespec delay = {0, };
-
-        gf_msg_debug (this->name, 0, "Initiating child-down timer");
-        delay.tv_sec = 10;
-        delay.tv_nsec = 0;
-        priv->timer = gf_timer_call_after (this->ctx, delay,
-                                           afr_notify_cbk, this);
-        if (priv->timer == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_TIMER_CREATE_FAIL,
-                        "Cannot create timer for delayed initialization");
-        }
+afr_notify_cbk(void *data)
+{
+    xlator_t *this = data;
+    afr_private_t *priv = this->private;
+    glusterfs_event_t event = GF_EVENT_MAXVAL;
+    gf_boolean_t propagate = _gf_false;
+
+    LOCK(&priv->lock);
+    {
+        if (!priv->timer) {
+            /*
+             * Either child_up/child_down is already sent to parent.
+             * This is a spurious wake up.
+             */
+            goto unlock;
+        }
+        priv->timer = NULL;
+        event = __afr_transform_event_from_state(this);
+        if (event != GF_EVENT_MAXVAL)
+            propagate = _gf_true;
+    }
+unlock:
+    UNLOCK(&priv->lock);
+    if (propagate)
+        default_notify(this, event, NULL);
 }
 
-int
-__get_heard_from_all_status (xlator_t *this)
+static void
+__afr_launch_notify_timer(xlator_t *this, afr_private_t *priv)
 {
-        afr_private_t *priv          = this->private;
-        int           heard_from_all = 1;
-        int           i              = 0;
+    struct timespec delay = {
+        0,
+    };
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!priv->last_event[i]) {
-                        heard_from_all = 0;
-                        break;
-                }
-        }
-        return heard_from_all;
+    gf_msg_debug(this->name, 0, "Initiating child-down timer");
+    delay.tv_sec = 10;
+    delay.tv_nsec = 0;
+    priv->timer = gf_timer_call_after(this->ctx, delay, afr_notify_cbk, this);
+    if (priv->timer == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_TIMER_CREATE_FAIL,
+               "Cannot create timer for delayed initialization");
+    }
 }
 
 static int
-find_best_down_child (xlator_t *this)
+find_best_down_child(xlator_t *this)
 {
-        afr_private_t   *priv               = NULL;
-        int             i                   = -1;
-        int32_t         best_child          = -1;
-        int64_t         best_latency        = INT64_MAX;
+    afr_private_t *priv = NULL;
+    int i = -1;
+    int32_t best_child = -1;
+    int64_t best_latency = INT64_MAX;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->child_up[i] &&
-                    priv->child_latency[i] >= 0 &&
-                    priv->child_latency[i] < best_latency) {
-                        best_child = i;
-                        best_latency = priv->child_latency[i];
-                }
-        }
-        if (best_child >= 0) {
-                gf_msg_debug (this->name, 0, "Found best down child (%d) "
-                              "@ %ld ms latency", best_child, best_latency);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!priv->child_up[i] && priv->child_latency[i] >= 0 &&
+            priv->child_latency[i] < best_latency) {
+            best_child = i;
+            best_latency = priv->child_latency[i];
         }
-        return best_child;
+    }
+    if (best_child >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "Found best down child (%d) @ %" PRId64 " ms latency",
+                     best_child, best_latency);
+    }
+    return best_child;
 }
 
 int
-find_worst_up_child (xlator_t *this)
+find_worst_up_child(xlator_t *this)
 {
-        afr_private_t   *priv               = NULL;
-        int             i                   = -1;
-        int32_t         worst_child         = -1;
-        int64_t         worst_latency       = INT64_MIN;
+    afr_private_t *priv = NULL;
+    int i = -1;
+    int32_t worst_child = -1;
+    int64_t worst_latency = INT64_MIN;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->child_up[i] &&
-                    priv->child_latency[i] >= 0 &&
-                    priv->child_latency[i] > worst_latency) {
-                        worst_child = i;
-                        worst_latency = priv->child_latency[i];
-                }
-        }
-        if (worst_child >= 0) {
-                gf_msg_debug (this->name, 0, "Found worst up child (%d)"
-                              " @ %ld ms latency", worst_child, worst_latency);
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->child_up[i] && priv->child_latency[i] >= 0 &&
+            priv->child_latency[i] > worst_latency) {
+            worst_child = i;
+            worst_latency = priv->child_latency[i];
         }
-        return worst_child;
+    }
+    if (worst_child >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "Found worst up child (%d) @ %" PRId64 " ms latency",
+                     worst_child, worst_latency);
+    }
+    return worst_child;
 }
 
 void
-__afr_handle_ping_event (xlator_t *this, xlator_t *child_xlator,
-                const int idx, int64_t halo_max_latency_msec, int32_t *event,
-                int64_t child_latency_msec)
+__afr_handle_ping_event(xlator_t *this, xlator_t *child_xlator, const int idx,
+                        int64_t halo_max_latency_msec, int32_t *event,
+                        int64_t child_latency_msec)
 {
-        afr_private_t   *priv               = NULL;
-        int             up_children         = 0;
+    afr_private_t *priv = NULL;
+    int up_children = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        priv->child_latency[idx] = child_latency_msec;
-        gf_msg_debug (child_xlator->name, 0, "Client ping @ %ld ms",
-                      child_latency_msec);
-
-        up_children = __afr_get_up_children_count (priv);
-
-        if (child_latency_msec > halo_max_latency_msec &&
-            priv->child_up[idx] == 1 &&
-            up_children > priv->halo_min_replicas) {
-                if ((up_children - 1) <
-                    priv->halo_min_replicas) {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                               "Overriding halo threshold, "
-                               "min replicas: %d",
-                               priv->halo_min_replicas);
-                } else {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                                "Child latency (%ld ms) "
-                                "exceeds halo threshold (%ld), "
-                                "marking child down.",
-                                child_latency_msec,
-                                halo_max_latency_msec);
-                        *event = GF_EVENT_CHILD_DOWN;
-                }
-        } else if (child_latency_msec < halo_max_latency_msec &&
-                   priv->child_up[idx] == 0) {
-                if (up_children < priv->halo_max_replicas) {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                                "Child latency (%ld ms) "
-                                "below halo threshold (%ld), "
-                                "marking child up.",
-                                child_latency_msec,
-                                halo_max_latency_msec);
-                        *event = GF_EVENT_CHILD_UP;
-                } else {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                            "Not marking child %d up, "
-                            "max replicas (%d) reached.", idx,
-                            priv->halo_max_replicas);
-                }
+    priv->child_latency[idx] = child_latency_msec;
+    gf_msg_debug(child_xlator->name, 0, "Client ping @ %" PRId64 " ms",
+                 child_latency_msec);
+    if (priv->shd.iamshd)
+        return;
+
+    up_children = __afr_get_up_children_count(priv);
+
+    if (child_latency_msec > halo_max_latency_msec &&
+        priv->child_up[idx] == 1 && up_children > priv->halo_min_replicas) {
+        if ((up_children - 1) < priv->halo_min_replicas) {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Overriding halo threshold, "
+                   "min replicas: %d",
+                   priv->halo_min_replicas);
+        } else {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Child latency (%" PRId64
+                   " ms) "
+                   "exceeds halo threshold (%" PRId64
+                   "), "
+                   "marking child down.",
+                   child_latency_msec, halo_max_latency_msec);
+            if (priv->halo_child_up[idx]) {
+                *event = GF_EVENT_CHILD_DOWN;
+            }
+        }
+    } else if (child_latency_msec < halo_max_latency_msec &&
+               priv->child_up[idx] == 0) {
+        if (up_children < priv->halo_max_replicas) {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Child latency (%" PRId64
+                   " ms) "
+                   "below halo threshold (%" PRId64
+                   "), "
+                   "marking child up.",
+                   child_latency_msec, halo_max_latency_msec);
+            if (priv->halo_child_up[idx]) {
+                *event = GF_EVENT_CHILD_UP;
+            }
+        } else {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Not marking child %d up, "
+                   "max replicas (%d) reached.",
+                   idx, priv->halo_max_replicas);
         }
+    }
 }
 
-void
-__afr_handle_child_up_event (xlator_t *this, xlator_t *child_xlator,
-                const int idx, int64_t halo_max_latency_msec,
-                int32_t *event, int32_t *call_psh, int32_t *up_child)
+static int64_t
+afr_get_halo_latency(xlator_t *this)
 {
-        afr_private_t   *priv               = NULL;
-        int             up_children         = 0;
-        int             worst_up_child      = -1;
-
-        priv = this->private;
+    afr_private_t *priv = NULL;
+    int64_t halo_max_latency_msec = 0;
 
-        /*
-         * This only really counts if the child was never up
-         * (value = -1) or had been down (value = 0).  See
-         * comment at GF_EVENT_CHILD_DOWN for a more detailed
-         * explanation.
-         */
-        if (priv->child_up[idx] != 1) {
-                priv->event_generation++;
-        }
-        priv->child_up[idx] = 1;
+    priv = this->private;
 
-        *call_psh = 1;
-        *up_child = idx;
-        up_children = __afr_get_up_children_count (priv);
+    if (priv->shd.iamshd) {
+        halo_max_latency_msec = priv->shd.halo_max_latency_msec;
+    } else if (priv->nfsd.iamnfsd) {
+        halo_max_latency_msec = priv->nfsd.halo_max_latency_msec;
+    } else {
+        halo_max_latency_msec = priv->halo_max_latency_msec;
+    }
+    gf_msg_debug(this->name, 0, "Using halo latency %" PRId64,
+                 halo_max_latency_msec);
+    return halo_max_latency_msec;
+}
 
-        /*
-         * Handle the edge case where we exceed
-         * halo_min_replicas and we've got a child which is
-         * marked up as it was helping to satisfy the
-         * halo_min_replicas even though it's latency exceeds
-         * halo_max_latency_msec.
-         */
-        if (up_children > priv->halo_min_replicas) {
-                worst_up_child = find_worst_up_child (this);
-                if (worst_up_child >= 0 &&
-                    priv->child_latency[worst_up_child] >
-                    halo_max_latency_msec) {
-                        gf_msg_debug (this->name, 0, "Marking child %d down, "
-                                "doesn't meet halo threshold (%ld), and > "
-                                "halo_min_replicas (%d)",
-                                worst_up_child, halo_max_latency_msec,
-                                priv->halo_min_replicas);
-                        priv->child_up[worst_up_child] = 0;
-                        up_children--;
-                }
-        }
-        if (up_children > priv->halo_max_replicas &&
-            !priv->shd.iamshd) {
-                worst_up_child = find_worst_up_child (this);
-                if (worst_up_child < 0) {
-                        worst_up_child = idx;
-                }
-                priv->child_up[worst_up_child] = 0;
-                up_children--;
-                gf_msg_debug (this->name, 0, "Marking child %d down, "
-                        "up_children (%d) > halo_max_replicas (%d)",
-                        worst_up_child, up_children, priv->halo_max_replicas);
-        }
-
-        if (up_children == 1) {
-                gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOL_UP,
-                        "Subvolume '%s' came back up; "
-                        "going online.",
-                        child_xlator->name);
-                gf_event (EVENT_AFR_SUBVOL_UP, "subvol=%s", this->name);
-        } else {
-                *event = GF_EVENT_SOME_DESCENDENT_UP;
-        }
+void
+__afr_handle_child_up_event(xlator_t *this, xlator_t *child_xlator,
+                            const int idx, int64_t child_latency_msec,
+                            int32_t *event, int32_t *call_psh,
+                            int32_t *up_child)
+{
+    afr_private_t *priv = NULL;
+    int up_children = 0;
+    int worst_up_child = -1;
+    int64_t halo_max_latency_msec = afr_get_halo_latency(this);
+
+    priv = this->private;
+
+    /*
+     * This only really counts if the child was never up
+     * (value = -1) or had been down (value = 0).  See
+     * comment at GF_EVENT_CHILD_DOWN for a more detailed
+     * explanation.
+     */
+    if (priv->child_up[idx] != 1) {
+        priv->event_generation++;
+    }
+    priv->child_up[idx] = 1;
+
+    *call_psh = 1;
+    *up_child = idx;
+    up_children = __afr_get_up_children_count(priv);
+    /*
+     * If this is an _actual_ CHILD_UP event, we
+     * want to set the child_latency to MAX to indicate
+     * the child needs ping data to be available before doing child-up
+     */
+    if (!priv->halo_enabled)
+        goto out;
+
+    if (child_latency_msec < 0) {
+        /*set to INT64_MAX-1 so that it is found for best_down_child*/
+        priv->halo_child_up[idx] = 1;
+        if (priv->child_latency[idx] < 0) {
+            priv->child_latency[idx] = AFR_HALO_MAX_LATENCY;
+        }
+    }
+
+    /*
+     * Handle the edge case where we exceed
+     * halo_min_replicas and we've got a child which is
+     * marked up as it was helping to satisfy the
+     * halo_min_replicas even though it's latency exceeds
+     * halo_max_latency_msec.
+     */
+    if (up_children > priv->halo_min_replicas) {
+        worst_up_child = find_worst_up_child(this);
+        if (worst_up_child >= 0 &&
+            priv->child_latency[worst_up_child] > halo_max_latency_msec) {
+            gf_msg_debug(this->name, 0,
+                         "Marking child %d down, "
+                         "doesn't meet halo threshold (%" PRId64
+                         "), and > "
+                         "halo_min_replicas (%d)",
+                         worst_up_child, halo_max_latency_msec,
+                         priv->halo_min_replicas);
+            priv->child_up[worst_up_child] = 0;
+            up_children--;
+        }
+    }
+
+    if (up_children > priv->halo_max_replicas && !priv->shd.iamshd) {
+        worst_up_child = find_worst_up_child(this);
+        if (worst_up_child < 0) {
+            worst_up_child = idx;
+        }
+        priv->child_up[worst_up_child] = 0;
+        up_children--;
+        gf_msg_debug(this->name, 0,
+                     "Marking child %d down, "
+                     "up_children (%d) > halo_max_replicas (%d)",
+                     worst_up_child, up_children, priv->halo_max_replicas);
+    }
+out:
+    if (up_children == 1) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOL_UP,
+               "Subvolume '%s' came back up; "
+               "going online.",
+               child_xlator->name);
+        gf_event(EVENT_AFR_SUBVOL_UP, "client-pid=%d; subvol=%s",
+                 this->ctx->cmd_args.client_pid, this->name);
+    } else {
+        *event = GF_EVENT_SOME_DESCENDENT_UP;
+    }
 
-        priv->last_event[idx] = *event;
+    priv->last_event[idx] = *event;
 }
 
 void
-__afr_handle_child_down_event (xlator_t *this, xlator_t *child_xlator,
-                int idx, int64_t child_latency_msec, int32_t *event,
-                int32_t *call_psh, int32_t *up_child)
-{
-        afr_private_t   *priv               = NULL;
-        int             i                   = 0;
-        int             up_children         = 0;
-        int             down_children       = 0;
-        int             best_down_child     = -1;
-
-        priv = this->private;
-
-        /*
-         * If a brick is down when we start, we'll get a
-         * CHILD_DOWN to indicate its initial state.  There
-         * was never a CHILD_UP in this case, so if we
-         * increment "down_count" the difference between than
-         * and "up_count" will no longer be the number of
-         * children that are currently up.  This has serious
-         * implications e.g. for quorum enforcement, so we
-         * don't increment these values unless the event
-         * represents an actual state transition between "up"
-         * (value = 1) and anything else.
-         */
-        if (priv->child_up[idx] == 1) {
-                priv->event_generation++;
-        }
+__afr_handle_child_down_event(xlator_t *this, xlator_t *child_xlator, int idx,
+                              int64_t child_latency_msec, int32_t *event,
+                              int32_t *call_psh, int32_t *up_child)
+{
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int up_children = 0;
+    int down_children = 0;
+    int best_down_child = -1;
+
+    priv = this->private;
+
+    /*
+     * If a brick is down when we start, we'll get a
+     * CHILD_DOWN to indicate its initial state.  There
+     * was never a CHILD_UP in this case, so if we
+     * increment "down_count" the difference between than
+     * and "up_count" will no longer be the number of
+     * children that are currently up.  This has serious
+     * implications e.g. for quorum enforcement, so we
+     * don't increment these values unless the event
+     * represents an actual state transition between "up"
+     * (value = 1) and anything else.
+     */
+    if (priv->child_up[idx] == 1) {
+        priv->event_generation++;
+    }
+
+    /*
+     * If this is an _actual_ CHILD_DOWN event, we
+     * want to set the child_latency to < 0 to indicate
+     * the child is really disconnected.
+     */
+    if (child_latency_msec < 0) {
+        priv->child_latency[idx] = child_latency_msec;
+        priv->halo_child_up[idx] = 0;
+    }
+    priv->child_up[idx] = 0;
+
+    up_children = __afr_get_up_children_count(priv);
+    /*
+     * Handle the edge case where we need to find the
+     * next best child (to mark up) as marking this child
+     * down would cause us to fall below halo_min_replicas.
+     * We will also force the SHD to heal this child _now_
+     * as we want it to be up to date if we are going to
+     * begin using it synchronously.
+     */
+    if (priv->halo_enabled && up_children < priv->halo_min_replicas) {
+        best_down_child = find_best_down_child(this);
+        if (best_down_child >= 0) {
+            gf_msg_debug(this->name, 0,
+                         "Swapping out child %d for "
+                         "child %d to satisfy halo_min_replicas (%d).",
+                         idx, best_down_child, priv->halo_min_replicas);
+            priv->child_up[best_down_child] = 1;
+            *call_psh = 1;
+            *up_child = best_down_child;
+        }
+    }
+    for (i = 0; i < priv->child_count; i++)
+        if (priv->child_up[i] == 0)
+            down_children++;
+    if (down_children == priv->child_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SUBVOLS_DOWN,
+               "All subvolumes are down. Going "
+               "offline until at least one of them "
+               "comes back up.");
+        gf_event(EVENT_AFR_SUBVOLS_DOWN, "client-pid=%d; subvol=%s",
+                 this->ctx->cmd_args.client_pid, this->name);
+    } else {
+        *event = GF_EVENT_SOME_DESCENDENT_DOWN;
+    }
+    priv->last_event[idx] = *event;
+}
 
-        /*
-         * If this is an _actual_ CHILD_DOWN event, we
-         * want to set the child_latency to < 0 to indicate
-         * the child is really disconnected.
-         */
-        if (child_latency_msec < 0) {
-                priv->child_latency[idx] = child_latency_msec;
-        }
-        priv->child_up[idx] = 0;
+void
+afr_ta_lock_release_synctask(xlator_t *this)
+{
+    call_frame_t *ta_frame = NULL;
+    int ret = 0;
 
-        up_children = __afr_get_up_children_count (priv);
-        /*
-         * Handle the edge case where we need to find the
-         * next best child (to mark up) as marking this child
-         * down would cause us to fall below halo_min_replicas.
-         * We will also force the SHD to heal this child _now_
-         * as we want it to be up to date if we are going to
-         * begin using it synchronously.
-         */
-        if (up_children < priv->halo_min_replicas) {
-                best_down_child = find_best_down_child (this);
-                if (best_down_child >= 0) {
-                        gf_msg_debug (this->name, 0,
-                                "Swapping out child %d for "
-                                "child %d to satisfy halo_min_replicas (%d).",
-                                idx, best_down_child, priv->halo_min_replicas);
-                        priv->child_up[best_down_child] = 1;
-                        *call_psh = 1;
-                        *up_child = best_down_child;
-                }
-        }
+    ta_frame = afr_ta_frame_create(this);
+    if (!ta_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to create ta_frame");
+        return;
+    }
 
-        for (i = 0; i < priv->child_count; i++)
-                if (priv->child_up[i] == 0)
-                        down_children++;
-        if (down_children == priv->child_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SUBVOLS_DOWN,
-                        "All subvolumes are down. Going "
-                        "offline until atleast one of them "
-                        "comes back up.");
-                gf_event (EVENT_AFR_SUBVOLS_DOWN, "subvol=%s", this->name);
-        } else {
-                *event = GF_EVENT_SOME_DESCENDENT_DOWN;
-        }
-        priv->last_event[idx] = *event;
+    ret = synctask_new(this->ctx->env, afr_release_notify_lock_for_ta,
+                       afr_ta_lock_release_done, ta_frame, this);
+    if (ret) {
+        STACK_DESTROY(ta_frame->root);
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to release "
+               "AFR_TA_DOM_NOTIFY lock.");
+    }
 }
 
-static int64_t
-afr_get_halo_latency (xlator_t *this)
+static void
+afr_handle_inodelk_contention(xlator_t *this, struct gf_upcall *upcall)
 {
-        afr_private_t *priv           = NULL;
-        int64_t halo_max_latency_msec = 0;
+    struct gf_upcall_inodelk_contention *lc = NULL;
+    unsigned int inmem_count = 0;
+    unsigned int onwire_count = 0;
+    afr_private_t *priv = this->private;
 
-        priv = this->private;
+    lc = upcall->data;
 
-        if (priv->shd.iamshd) {
-                halo_max_latency_msec = priv->shd.halo_max_latency_msec;
-        } else if (priv->nfsd.iamnfsd) {
-                halo_max_latency_msec =
-                        priv->nfsd.halo_max_latency_msec;
-        } else {
-                halo_max_latency_msec = priv->halo_max_latency_msec;
-        }
-        gf_msg_debug (this->name, 0, "Using halo latency %ld",
-                halo_max_latency_msec);
-        return halo_max_latency_msec;
-}
+    if (strcmp(lc->domain, AFR_TA_DOM_NOTIFY) != 0)
+        return;
 
+    if (priv->shd.iamshd) {
+        /* shd should ignore AFR_TA_DOM_NOTIFY release requests. */
+        return;
+    }
+    LOCK(&priv->lock);
+    {
+        if (priv->release_ta_notify_dom_lock == _gf_true) {
+            /* Ignore multiple release requests from shds.*/
+            UNLOCK(&priv->lock);
+            return;
+        }
+        priv->release_ta_notify_dom_lock = _gf_true;
+        inmem_count = priv->ta_in_mem_txn_count;
+        onwire_count = priv->ta_on_wire_txn_count;
+    }
+    UNLOCK(&priv->lock);
+    if (inmem_count || onwire_count)
+        /* lock release will happen in txn code path after
+         * in-memory or on-wire txns are over.*/
+        return;
 
-int32_t
-afr_notify (xlator_t *this, int32_t event,
-            void *data, void *data2)
-{
-        afr_private_t   *priv               = NULL;
-        xlator_t        *child_xlator       = NULL;
-        int             i                   = -1;
-        int             propagate           = 0;
-        int             had_heard_from_all  = 0;
-        int             have_heard_from_all = 0;
-        int             idx                 = -1;
-        int             ret                 = -1;
-        int             call_psh            = 0;
-        int             up_child            = -1;
-        dict_t          *input              = NULL;
-        dict_t          *output             = NULL;
-        gf_boolean_t    had_quorum          = _gf_false;
-        gf_boolean_t    has_quorum          = _gf_false;
-        struct gf_upcall *up_data           = NULL;
-        struct gf_upcall_cache_invalidation *up_ci = NULL;
-        inode_table_t  *itable              = NULL;
-        inode_t        *inode               = NULL;
-        int64_t         halo_max_latency_msec = 0;
-        int64_t         child_latency_msec   = -1;
-
-        child_xlator = (xlator_t *)data;
-
-        priv = this->private;
-
-        if (!priv)
-                return 0;
-
-        /*
-         * We need to reset this in case children come up in "staggered"
-         * fashion, so that we discover a late-arriving local subvolume.  Note
-         * that we could end up issuing N lookups to the first subvolume, and
-         * O(N^2) overall, but N is small for AFR so it shouldn't be an issue.
-         */
-        priv->did_discovery = _gf_false;
+    afr_ta_lock_release_synctask(this);
+}
 
+static void
+afr_handle_upcall_event(xlator_t *this, struct gf_upcall *upcall)
+{
+    struct gf_upcall_cache_invalidation *up_ci = NULL;
+    afr_private_t *priv = this->private;
+    inode_t *inode = NULL;
+    inode_table_t *itable = NULL;
+    int i = 0;
+
+    switch (upcall->event_type) {
+        case GF_UPCALL_INODELK_CONTENTION:
+            afr_handle_inodelk_contention(this, upcall);
+            break;
+        case GF_UPCALL_CACHE_INVALIDATION:
+            up_ci = (struct gf_upcall_cache_invalidation *)upcall->data;
+
+            /* Since md-cache will be aggressively filtering
+             * lookups, the stale read issue will be more
+             * pronounced. Hence when a pending xattr is set notify
+             * all the md-cache clients to invalidate the existing
+             * stat cache and send the lookup next time */
+            if (!up_ci->dict)
+                break;
+            for (i = 0; i < priv->child_count; i++) {
+                if (!dict_get(up_ci->dict, priv->pending_key[i]))
+                    continue;
+                up_ci->flags |= UP_INVAL_ATTR;
+                itable = ((xlator_t *)this->graph->top)->itable;
+                /*Internal processes may not have itable for
+                 *top xlator*/
+                if (itable)
+                    inode = inode_find(itable, upcall->gfid);
+                if (inode)
+                    afr_inode_need_refresh_set(inode, this);
+                break;
+            }
+            break;
+        default:
+            break;
+    }
+}
 
-        /* parent xlators dont need to know about every child_up, child_down
-         * because of afr ha. If all subvolumes go down, child_down has
-         * to be triggered. In that state when 1 subvolume comes up child_up
-         * needs to be triggered. dht optimizes revalidate lookup by sending
-         * it only to one of its subvolumes. When child up/down happens
-         * for afr's subvolumes dht should be notified by child_modified. The
-         * subsequent revalidate lookup happens on all the dht's subvolumes
-         * which triggers afr self-heals if any.
-         */
-        idx = find_child_index (this, child_xlator);
-        if (idx < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_CHILD_UP,
-                        "Received child_up from invalid subvolume");
-                goto out;
-        }
+int32_t
+afr_notify(xlator_t *this, int32_t event, void *data, void *data2)
+{
+    afr_private_t *priv = NULL;
+    xlator_t *child_xlator = NULL;
+    int i = -1;
+    int propagate = 0;
+    int had_heard_from_all = 0;
+    int have_heard_from_all = 0;
+    int idx = -1;
+    int ret = -1;
+    int call_psh = 0;
+    int up_child = -1;
+    dict_t *input = NULL;
+    dict_t *output = NULL;
+    gf_boolean_t had_quorum = _gf_false;
+    gf_boolean_t has_quorum = _gf_false;
+    int64_t halo_max_latency_msec = 0;
+    int64_t child_latency_msec = -1;
+
+    child_xlator = (xlator_t *)data;
+
+    priv = this->private;
+
+    if (!priv)
+        return 0;
 
-        had_quorum = priv->quorum_count && afr_has_quorum (priv->child_up,
-                                                           this);
+    /*
+     * We need to reset this in case children come up in "staggered"
+     * fashion, so that we discover a late-arriving local subvolume.  Note
+     * that we could end up issuing N lookups to the first subvolume, and
+     * O(N^2) overall, but N is small for AFR so it shouldn't be an issue.
+     */
+    priv->did_discovery = _gf_false;
+
+    /* parent xlators don't need to know about every child_up, child_down
+     * because of afr ha. If all subvolumes go down, child_down has
+     * to be triggered. In that state when 1 subvolume comes up child_up
+     * needs to be triggered. dht optimizes revalidate lookup by sending
+     * it only to one of its subvolumes. When child up/down happens
+     * for afr's subvolumes dht should be notified by child_modified. The
+     * subsequent revalidate lookup happens on all the dht's subvolumes
+     * which triggers afr self-heals if any.
+     */
+    idx = afr_find_child_index(this, child_xlator);
+    if (idx < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_CHILD_UP,
+               "Received child_up from invalid subvolume");
+        goto out;
+    }
+
+    had_quorum = priv->quorum_count &&
+                 afr_has_quorum(priv->child_up, this, NULL);
+    if (event == GF_EVENT_CHILD_PING) {
+        child_latency_msec = (int64_t)(uintptr_t)data2;
         if (priv->halo_enabled) {
-                halo_max_latency_msec = afr_get_halo_latency (this);
-
-                if (event == GF_EVENT_CHILD_PING) {
-                        /* Calculates the child latency and sets event
-                         */
-                        child_latency_msec = (int64_t)(uintptr_t)data2;
-                        LOCK (&priv->lock);
-                        {
-                                __afr_handle_ping_event (this, child_xlator,
-                                        idx, halo_max_latency_msec, &event,
+            halo_max_latency_msec = afr_get_halo_latency(this);
+
+            /* Calculates the child latency and sets event
+             */
+            LOCK(&priv->lock);
+            {
+                __afr_handle_ping_event(this, child_xlator, idx,
+                                        halo_max_latency_msec, &event,
                                         child_latency_msec);
-                        }
-                        UNLOCK (&priv->lock);
-                }
-        }
-
-        if (event == GF_EVENT_CHILD_PING) {
-                /* This is the only xlator that handles PING, no reason to
-                 * propagate.
-                 */
-                goto out;
             }
-
-        if (event == GF_EVENT_TRANSLATOR_OP) {
-                LOCK (&priv->lock);
-                {
-                        had_heard_from_all = __get_heard_from_all_status (this);
-                }
-                UNLOCK (&priv->lock);
-
-                if (!had_heard_from_all) {
-                        ret = -1;
-                } else {
-                        input = data;
-                        output = data2;
-                        ret = afr_xl_op (this, input, output);
-                }
-                goto out;
+            UNLOCK(&priv->lock);
+        } else {
+            LOCK(&priv->lock);
+            {
+                priv->child_latency[idx] = child_latency_msec;
+            }
+            UNLOCK(&priv->lock);
         }
+    }
 
-        LOCK (&priv->lock);
+    if (event == GF_EVENT_CHILD_PING) {
+        /* This is the only xlator that handles PING, no reason to
+         * propagate.
+         */
+        goto out;
+    }
+
+    if (event == GF_EVENT_TRANSLATOR_OP) {
+        LOCK(&priv->lock);
         {
-                had_heard_from_all = __get_heard_from_all_status (this);
-                switch (event) {
-                case GF_EVENT_PARENT_UP:
-                        __afr_launch_notify_timer (this, priv);
-                        propagate = 1;
-                        break;
-                case GF_EVENT_CHILD_UP:
-                        __afr_handle_child_up_event (this, child_xlator,
-                                idx, halo_max_latency_msec, &event, &call_psh,
-                                &up_child);
-                        break;
-
-                case GF_EVENT_CHILD_DOWN:
-                        __afr_handle_child_down_event (this, child_xlator, idx,
-                                child_latency_msec, &event, &call_psh,
-                                &up_child);
-                        break;
-
-                case GF_EVENT_CHILD_CONNECTING:
-                        priv->last_event[idx] = event;
-
-                        break;
-
-                case GF_EVENT_SOME_DESCENDENT_DOWN:
-                        priv->last_event[idx] = event;
-                        break;
-                case GF_EVENT_UPCALL:
-                        up_data = (struct gf_upcall *)data;
-                        if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
-                                break;
-                        up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
-
-                        /* Since md-cache will be aggressively filtering
-                         * lookups, the stale read issue will be more
-                         * pronounced. Hence when a pending xattr is set notify
-                         * all the md-cache clients to invalidate the existing
-                         * stat cache and send the lookup next time */
-                        if (!up_ci->dict)
-                                break;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (dict_get (up_ci->dict, priv->pending_key[i])) {
-                                         up_ci->flags |= UP_INVAL_ATTR;
-                                         itable = ((xlator_t *)this->graph->top)->itable;
-                                         /*Internal processes may not have itable for top xlator*/
-                                         if (itable)
-                                                 inode = inode_find (itable, up_data->gfid);
-                                         if (inode)
-                                                 afr_inode_need_refresh_set (inode, this);
-
-                                         break;
-                                }
-                        }
-                        break;
-                default:
-                        propagate = 1;
-                        break;
-                }
-                have_heard_from_all = __get_heard_from_all_status (this);
-                if (!had_heard_from_all && have_heard_from_all) {
-                        if (priv->timer) {
-                                gf_timer_call_cancel (this->ctx, priv->timer);
-                                priv->timer = NULL;
-                        }
-                        /* This is the first event which completes aggregation
-                           of events from all subvolumes. If at least one subvol
-                           had come up, propagate CHILD_UP, but only this time
-                        */
-                        event = GF_EVENT_CHILD_DOWN;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (priv->last_event[i] == GF_EVENT_CHILD_UP) {
-                                        event = GF_EVENT_CHILD_UP;
-                                        break;
-                                }
-
-                                if (priv->last_event[i] ==
-                                                GF_EVENT_CHILD_CONNECTING) {
-                                        event = GF_EVENT_CHILD_CONNECTING;
-                               /* continue to check other events for CHILD_UP */
-                                }
-                        }
-                }
+            had_heard_from_all = __get_heard_from_all_status(this);
         }
-        UNLOCK (&priv->lock);
+        UNLOCK(&priv->lock);
 
-        if (priv->quorum_count) {
-                has_quorum = afr_has_quorum (priv->child_up, this);
-                if (!had_quorum && has_quorum) {
-                        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_QUORUM_MET,
-                                "Client-quorum is met");
-                        gf_event  (EVENT_AFR_QUORUM_MET,
-                                   "subvol=%s", this->name);
+        if (!had_heard_from_all) {
+            ret = -1;
+        } else {
+            input = data;
+            output = data2;
+            ret = afr_xl_op(this, input, output);
+        }
+        goto out;
+    }
+
+    if (event == GF_EVENT_UPCALL) {
+        afr_handle_upcall_event(this, data);
+    }
+
+    LOCK(&priv->lock);
+    {
+        had_heard_from_all = __get_heard_from_all_status(this);
+        switch (event) {
+            case GF_EVENT_PARENT_UP:
+                __afr_launch_notify_timer(this, priv);
+                propagate = 1;
+                break;
+            case GF_EVENT_CHILD_UP:
+                if (priv->thin_arbiter_count &&
+                    (idx == AFR_CHILD_THIN_ARBITER)) {
+                    priv->ta_child_up = 1;
+                    priv->ta_event_gen++;
+                    break;
                 }
-                if (had_quorum && !has_quorum) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_QUORUM_FAIL,
-                                "Client-quorum is not met");
-                        gf_event  (EVENT_AFR_QUORUM_FAIL, "subvol=%s",
-                                   this->name);
+                __afr_handle_child_up_event(this, child_xlator, idx,
+                                            child_latency_msec, &event,
+                                            &call_psh, &up_child);
+                __afr_lock_heal_synctask(this, priv, idx);
+                break;
+
+            case GF_EVENT_CHILD_DOWN:
+                if (priv->thin_arbiter_count &&
+                    (idx == AFR_CHILD_THIN_ARBITER)) {
+                    priv->ta_child_up = 0;
+                    priv->ta_event_gen++;
+                    afr_ta_locked_priv_invalidate(priv);
+                    break;
                 }
-        }
+                __afr_handle_child_down_event(this, child_xlator, idx,
+                                              child_latency_msec, &event,
+                                              &call_psh, &up_child);
+                __afr_mark_pending_lk_heal(this, priv, idx);
+                break;
+
+            case GF_EVENT_CHILD_CONNECTING:
+                priv->last_event[idx] = event;
+
+                break;
 
-        /* if all subvols have reported status, no need to hide anything
-           or wait for anything else. Just propagate blindly */
-        if (have_heard_from_all)
+            case GF_EVENT_SOME_DESCENDENT_DOWN:
+                priv->last_event[idx] = event;
+                break;
+            default:
                 propagate = 1;
+                break;
+        }
+        have_heard_from_all = __get_heard_from_all_status(this);
+        if (!had_heard_from_all && have_heard_from_all) {
+            if (priv->timer) {
+                gf_timer_call_cancel(this->ctx, priv->timer);
+                priv->timer = NULL;
+            }
+            /* This is the first event which completes aggregation
+               of events from all subvolumes. If at least one subvol
+               had come up, propagate CHILD_UP, but only this time
+            */
+            event = GF_EVENT_CHILD_DOWN;
+            for (i = 0; i < priv->child_count; i++) {
+                if (priv->last_event[i] == GF_EVENT_CHILD_UP) {
+                    event = GF_EVENT_CHILD_UP;
+                    break;
+                }
 
-        ret = 0;
-        if (propagate)
-                ret = default_notify (this, event, data);
-
-        if ((!had_heard_from_all) || call_psh) {
-                /* Launch self-heal on all local subvolumes if:
-                 * a) We have_heard_from_all for the first time
-                 * b) Already heard from everyone, but we now got a child-up
-                 *    event.
-                 */
-                if (have_heard_from_all && priv->shd.iamshd) {
-                        for (i = 0; i < priv->child_count; i++)
-                                if (priv->child_up[i])
-                                        afr_selfheal_childup (this, i);
+                if (priv->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
+                    event = GF_EVENT_CHILD_CONNECTING;
+                    /* continue to check other events for CHILD_UP */
                 }
+            }
+        }
+    }
+    UNLOCK(&priv->lock);
+
+    if (priv->quorum_count) {
+        has_quorum = afr_has_quorum(priv->child_up, this, NULL);
+        if (!had_quorum && has_quorum) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_QUORUM_MET,
+                   "Client-quorum is met");
+            gf_event(EVENT_AFR_QUORUM_MET, "client-pid=%d; subvol=%s",
+                     this->ctx->cmd_args.client_pid, this->name);
+        }
+        if (had_quorum && !has_quorum) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
+                   "Client-quorum is not met");
+            gf_event(EVENT_AFR_QUORUM_FAIL, "client-pid=%d; subvol=%s",
+                     this->ctx->cmd_args.client_pid, this->name);
+        }
+    }
+
+    /* if all subvols have reported status, no need to hide anything
+       or wait for anything else. Just propagate blindly */
+    if (have_heard_from_all)
+        propagate = 1;
+
+    ret = 0;
+    if (propagate)
+        ret = default_notify(this, event, data);
+
+    if ((!had_heard_from_all) || call_psh) {
+        /* Launch self-heal on all local subvolumes if:
+         * a) We have_heard_from_all for the first time
+         * b) Already heard from everyone, but we now got a child-up
+         *    event.
+         */
+        if (have_heard_from_all) {
+            afr_selfheal_childup(this, priv);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_local_init (afr_local_t *local, afr_private_t *priv, int32_t *op_errno)
+afr_local_init(afr_local_t *local, afr_private_t *priv, int32_t *op_errno)
 {
-        local->op_ret = -1;
-        local->op_errno = EUCLEAN;
+    int __ret = -1;
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
 
-	syncbarrier_init (&local->barrier);
-
-        local->child_up = GF_CALLOC (priv->child_count,
-                                     sizeof (*local->child_up),
-                                     gf_afr_mt_char);
-        if (!local->child_up) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
-
-        memcpy (local->child_up, priv->child_up,
-                sizeof (*local->child_up) * priv->child_count);
-        local->call_count = AFR_COUNT (local->child_up, priv->child_count);
-        if (local->call_count == 0) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0,
-                        AFR_MSG_SUBVOLS_DOWN, "no subvolumes up");
-                if (op_errno)
-                        *op_errno = ENOTCONN;
-                goto out;
-        }
-
-	local->event_generation = priv->event_generation;
+    __ret = syncbarrier_init(&local->barrier);
+    if (__ret) {
+        if (op_errno)
+            *op_errno = __ret;
+        goto out;
+    }
 
-	local->read_attempted = GF_CALLOC (priv->child_count, sizeof (char),
-					   gf_afr_mt_char);
-	if (!local->read_attempted) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
+    local->child_up = GF_MALLOC(priv->child_count * sizeof(*local->child_up),
+                                gf_afr_mt_char);
+    if (!local->child_up) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    memcpy(local->child_up, priv->child_up,
+           sizeof(*local->child_up) * priv->child_count);
+    local->call_count = AFR_COUNT(local->child_up, priv->child_count);
+    if (local->call_count == 0) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOLS_DOWN,
+               "no subvolumes up");
+        if (op_errno)
+            *op_errno = ENOTCONN;
+        goto out;
+    }
 
-	local->readable = GF_CALLOC (priv->child_count, sizeof (char),
-				     gf_afr_mt_char);
-	if (!local->readable) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
+    local->event_generation = priv->event_generation;
 
-        local->readable2 = GF_CALLOC (priv->child_count, sizeof (char),
+    local->read_attempted = GF_CALLOC(priv->child_count, sizeof(char),
                                       gf_afr_mt_char);
-        if (!local->readable2) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
+    if (!local->read_attempted) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->readable = GF_CALLOC(priv->child_count, sizeof(char),
+                                gf_afr_mt_char);
+    if (!local->readable) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
 
-	local->replies = GF_CALLOC(priv->child_count, sizeof(*local->replies),
-				   gf_afr_mt_reply_t);
-	if (!local->replies) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
+    local->readable2 = GF_CALLOC(priv->child_count, sizeof(char),
+                                 gf_afr_mt_char);
+    if (!local->readable2) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
 
-        local->need_full_crawl = _gf_false;
+    local->read_subvol = -1;
 
-        local->compound = _gf_false;
-        INIT_LIST_HEAD (&local->healer);
-	return 0;
+    local->replies = GF_CALLOC(priv->child_count, sizeof(*local->replies),
+                               gf_afr_mt_reply_t);
+    if (!local->replies) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->need_full_crawl = _gf_false;
+    if (priv->thin_arbiter_count) {
+        local->ta_child_up = priv->ta_child_up;
+        local->ta_failed_subvol = AFR_CHILD_UNKNOWN;
+        local->read_txn_query_child = AFR_CHILD_UNKNOWN;
+        local->ta_event_gen = priv->ta_event_gen;
+        local->fop_state = TA_SUCCESS;
+    }
+    local->is_new_entry = _gf_false;
+
+    INIT_LIST_HEAD(&local->healer);
+    return 0;
 out:
-        return -1;
+    return -1;
 }
 
 int
-afr_internal_lock_init (afr_internal_lock_t *lk, size_t child_count,
-                        transaction_lk_type_t lk_type)
+afr_internal_lock_init(afr_internal_lock_t *lk, size_t child_count)
 {
-        int             ret = -ENOMEM;
-
-        lk->locked_nodes = GF_CALLOC (sizeof (*lk->locked_nodes),
-                                      child_count, gf_afr_mt_char);
-        if (NULL == lk->locked_nodes)
-                goto out;
+    int ret = -ENOMEM;
 
-        lk->lower_locked_nodes = GF_CALLOC (sizeof (*lk->lower_locked_nodes),
-                                            child_count, gf_afr_mt_char);
-        if (NULL == lk->lower_locked_nodes)
-                goto out;
+    lk->lower_locked_nodes = GF_CALLOC(sizeof(*lk->lower_locked_nodes),
+                                       child_count, gf_afr_mt_char);
+    if (NULL == lk->lower_locked_nodes)
+        goto out;
 
-        lk->lock_op_ret   = -1;
-        lk->lock_op_errno = EUCLEAN;
-        lk->transaction_lk_type = lk_type;
+    lk->lock_op_ret = -1;
+    lk->lock_op_errno = EUCLEAN;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 void
-afr_matrix_cleanup (int32_t **matrix, unsigned int m)
+afr_matrix_cleanup(int32_t **matrix, unsigned int m)
 {
-        int             i         = 0;
+    int i = 0;
 
-        if (!matrix)
-                goto out;
-        for (i = 0; i < m; i++) {
-                GF_FREE (matrix[i]);
-        }
+    if (!matrix)
+        goto out;
+    for (i = 0; i < m; i++) {
+        GF_FREE(matrix[i]);
+    }
 
-        GF_FREE (matrix);
+    GF_FREE(matrix);
 out:
-        return;
+    return;
 }
 
-int32_t**
-afr_matrix_create (unsigned int m, unsigned int n)
+int32_t **
+afr_matrix_create(unsigned int m, unsigned int n)
 {
-        int32_t         **matrix = NULL;
-        int             i       = 0;
+    int32_t **matrix = NULL;
+    int i = 0;
 
-        matrix = GF_CALLOC (sizeof (*matrix), m, gf_afr_mt_int32_t);
-        if (!matrix)
-                goto out;
+    matrix = GF_CALLOC(sizeof(*matrix), m, gf_afr_mt_int32_t);
+    if (!matrix)
+        goto out;
 
-        for (i = 0; i < m; i++) {
-                matrix[i] = GF_CALLOC (sizeof (*matrix[i]), n,
-                                       gf_afr_mt_int32_t);
-                if (!matrix[i])
-                        goto out;
-        }
-        return matrix;
+    for (i = 0; i < m; i++) {
+        matrix[i] = GF_CALLOC(sizeof(*matrix[i]), n, gf_afr_mt_int32_t);
+        if (!matrix[i])
+            goto out;
+    }
+    return matrix;
 out:
-        afr_matrix_cleanup (matrix, m);
-        return NULL;
+    afr_matrix_cleanup(matrix, m);
+    return NULL;
 }
 
 int
-afr_inodelk_init (afr_inodelk_t *lk, char *dom, size_t child_count)
-{
-        int             ret = -ENOMEM;
-
-        lk->domain = dom;
-        lk->locked_nodes = GF_CALLOC (sizeof (*lk->locked_nodes),
-                                      child_count, gf_afr_mt_char);
-        if (NULL == lk->locked_nodes)
-                goto out;
-        ret = 0;
+afr_transaction_local_init(afr_local_t *local, xlator_t *this)
+{
+    int ret = -ENOMEM;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    INIT_LIST_HEAD(&local->transaction.wait_list);
+    INIT_LIST_HEAD(&local->transaction.owner_list);
+    INIT_LIST_HEAD(&local->ta_waitq);
+    INIT_LIST_HEAD(&local->ta_onwireq);
+    ret = afr_internal_lock_init(&local->internal_lock, priv->child_count);
+    if (ret < 0)
+        goto out;
+
+    ret = -ENOMEM;
+    local->pre_op_compat = priv->pre_op_compat;
+
+    local->transaction.pre_op = GF_CALLOC(sizeof(*local->transaction.pre_op),
+                                          priv->child_count, gf_afr_mt_char);
+    if (!local->transaction.pre_op)
+        goto out;
+
+    local->transaction.changelog_xdata = GF_CALLOC(
+        sizeof(*local->transaction.changelog_xdata), priv->child_count,
+        gf_afr_mt_dict_t);
+    if (!local->transaction.changelog_xdata)
+        goto out;
+
+    if (priv->arbiter_count == 1) {
+        local->transaction.pre_op_sources = GF_CALLOC(
+            sizeof(*local->transaction.pre_op_sources), priv->child_count,
+            gf_afr_mt_char);
+        if (!local->transaction.pre_op_sources)
+            goto out;
+    }
+
+    local->transaction.failed_subvols = GF_CALLOC(
+        sizeof(*local->transaction.failed_subvols), priv->child_count,
+        gf_afr_mt_char);
+    if (!local->transaction.failed_subvols)
+        goto out;
+
+    local->pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!local->pending)
+        goto out;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-int
-afr_transaction_local_init (afr_local_t *local, xlator_t *this)
+void
+afr_set_low_priority(call_frame_t *frame)
 {
-        int            ret = -ENOMEM;
-        afr_private_t *priv = NULL;
-
-        priv = this->private;
-        ret = afr_internal_lock_init (&local->internal_lock, priv->child_count,
-                                      AFR_TRANSACTION_LK);
-        if (ret < 0)
-                goto out;
-
-        if ((local->transaction.type == AFR_DATA_TRANSACTION) ||
-            (local->transaction.type == AFR_METADATA_TRANSACTION)) {
-                ret = afr_inodelk_init (&local->internal_lock.inodelk[0],
-                                        this->name, priv->child_count);
-                if (ret < 0)
-                        goto out;
-        }
-
-        ret = -ENOMEM;
-	local->pre_op_compat = priv->pre_op_compat;
-
-        local->transaction.eager_lock =
-                GF_CALLOC (sizeof (*local->transaction.eager_lock),
-                           priv->child_count,
-                           gf_afr_mt_int32_t);
-
-        if (!local->transaction.eager_lock)
-                goto out;
-
-        local->transaction.pre_op = GF_CALLOC (sizeof (*local->transaction.pre_op),
-                                               priv->child_count,
-                                               gf_afr_mt_char);
-        if (!local->transaction.pre_op)
-                goto out;
-
-        if (priv->arbiter_count == 1) {
-                local->transaction.pre_op_xdata =
-                        GF_CALLOC (sizeof (*local->transaction.pre_op_xdata),
-                                   priv->child_count, gf_afr_mt_dict_t);
-                if (!local->transaction.pre_op_xdata)
-                        goto out;
-
-                local->transaction.pre_op_sources =
-                        GF_CALLOC (sizeof (*local->transaction.pre_op_sources),
-                                   priv->child_count, gf_afr_mt_char);
-                if (!local->transaction.pre_op_sources)
-                        goto out;
-        }
-
-        local->transaction.failed_subvols = GF_CALLOC (sizeof (*local->transaction.failed_subvols),
-						       priv->child_count,
-						       gf_afr_mt_char);
-        if (!local->transaction.failed_subvols)
-                goto out;
-
-        local->pending = afr_matrix_create (priv->child_count,
-                                            AFR_NUM_CHANGE_LOGS);
-        if (!local->pending)
-                goto out;
-
-        local->compound = _gf_false;
-	INIT_LIST_HEAD (&local->transaction.eager_locked);
+    frame->root->pid = LOW_PRIO_PROC_PID;
+}
 
-        ret = 0;
+void
+afr_priv_destroy(afr_private_t *priv)
+{
+    int i = 0;
+    int child_count = -1;
+
+    if (!priv)
+        goto out;
+
+    GF_FREE(priv->sh_domain);
+    GF_FREE(priv->last_event);
+
+    child_count = priv->child_count;
+    if (priv->thin_arbiter_count) {
+        child_count++;
+    }
+    if (priv->pending_key) {
+        for (i = 0; i < child_count; i++)
+            GF_FREE(priv->pending_key[i]);
+    }
+
+    GF_FREE(priv->pending_reads);
+    GF_FREE(priv->local);
+    GF_FREE(priv->pending_key);
+    GF_FREE(priv->children);
+    GF_FREE(priv->anon_inode);
+    GF_FREE(priv->child_up);
+    GF_FREE(priv->halo_child_up);
+    GF_FREE(priv->child_latency);
+    LOCK_DESTROY(&priv->lock);
+
+    GF_FREE(priv);
 out:
-        return ret;
+    return;
 }
 
-
-void
-afr_set_low_priority (call_frame_t *frame)
+int **
+afr_mark_pending_changelog(afr_private_t *priv, unsigned char *pending,
+                           dict_t *xattr, ia_type_t iat)
 {
-        frame->root->pid = LOW_PRIO_PROC_PID;
-}
+    int i = 0;
+    int **changelog = NULL;
+    int idx = -1;
+    int m_idx = 0;
+    int d_idx = 0;
+    int ret = 0;
 
+    m_idx = afr_index_for_transaction_type(AFR_METADATA_TRANSACTION);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
 
-void
-afr_priv_destroy (afr_private_t *priv)
-{
-        int            i           = 0;
+    idx = afr_index_from_ia_type(iat);
 
-        if (!priv)
-                goto out;
-        GF_FREE (priv->last_event);
-        if (priv->pending_key) {
-                for (i = 0; i < priv->child_count; i++)
-                        GF_FREE (priv->pending_key[i]);
-        }
-        GF_FREE (priv->pending_key);
-        GF_FREE (priv->children);
-        GF_FREE (priv->child_up);
-        LOCK_DESTROY (&priv->lock);
+    changelog = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!changelog)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!pending[i])
+            continue;
 
-        GF_FREE (priv);
+        changelog[i][m_idx] = hton32(1);
+        if (idx != -1)
+            changelog[i][idx] = hton32(1);
+        /* If the newentry marking is on a newly created directory,
+         * then mark it with the full-heal indicator.
+         */
+        if ((IA_ISDIR(iat)) && (priv->esh_granular))
+            changelog[i][d_idx] = hton32(1);
+    }
+    ret = afr_set_pending_dict(priv, xattr, changelog);
+    if (ret < 0) {
+        afr_matrix_cleanup(changelog, priv->child_count);
+        return NULL;
+    }
 out:
-        return;
+    return changelog;
 }
 
-void
-afr_handle_open_fd_count (call_frame_t *frame, xlator_t *this)
+static dict_t *
+afr_set_heal_info(char *status)
 {
-        afr_local_t     *local = NULL;
-        afr_fd_ctx_t    *fd_ctx   = NULL;
+    dict_t *dict = NULL;
+    int ret = -1;
 
-        local = frame->local;
-
-        if (!local->fd)
-		return;
-
-	fd_ctx = afr_fd_ctx_get (local->fd, this);
-	if (!fd_ctx)
-		return;
+    dict = dict_new();
+    if (!dict) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = dict_set_dynstr_sizen(dict, "heal-info", status);
+    if (ret)
+        gf_msg("", GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Failed to set heal-info key to "
+               "%s",
+               status);
+out:
+    /* Any error other than EINVAL, dict_set_dynstr frees status */
+    if (ret == -ENOMEM || ret == -EINVAL) {
+        GF_FREE(status);
+    }
 
-	fd_ctx->open_fd_count = local->open_fd_count;
+    if (ret && dict) {
+        dict_unref(dict);
+        dict = NULL;
+    }
+    return dict;
 }
 
-int**
-afr_mark_pending_changelog (afr_private_t *priv, unsigned char *pending,
-                            dict_t *xattr, ia_type_t iat)
+static gf_boolean_t
+afr_is_dirty_count_non_unary_for_txn(xlator_t *this, struct afr_reply *replies,
+                                     afr_transaction_type type)
 {
-       int i = 0;
-       int **changelog = NULL;
-       int idx = -1;
-       int m_idx = 0;
-       int d_idx = 0;
-       int ret = 0;
+    afr_private_t *priv = this->private;
+    int *dirty = alloca0(priv->child_count * sizeof(int));
+    int i = 0;
 
-       m_idx = afr_index_for_transaction_type (AFR_METADATA_TRANSACTION);
-       d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
+    afr_selfheal_extract_xattr(this, replies, type, dirty, NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (dirty[i] > 1)
+            return _gf_true;
+    }
 
-       idx = afr_index_from_ia_type (iat);
+    return _gf_false;
+}
 
-       changelog = afr_matrix_create (priv->child_count, AFR_NUM_CHANGE_LOGS);
-       if (!changelog)
-                goto out;
+static gf_boolean_t
+afr_is_dirty_count_non_unary(xlator_t *this, struct afr_reply *replies,
+                             ia_type_t ia_type)
+{
+    gf_boolean_t data_chk = _gf_false;
+    gf_boolean_t mdata_chk = _gf_false;
+    gf_boolean_t entry_chk = _gf_false;
+
+    switch (ia_type) {
+        case IA_IFDIR:
+            mdata_chk = _gf_true;
+            entry_chk = _gf_true;
+            break;
+        case IA_IFREG:
+            mdata_chk = _gf_true;
+            data_chk = _gf_true;
+            break;
+        default:
+            /*IA_IFBLK, IA_IFCHR, IA_IFLNK, IA_IFIFO, IA_IFSOCK*/
+            mdata_chk = _gf_true;
+            break;
+    }
 
-       for (i = 0; i < priv->child_count; i++) {
-               if (!pending[i])
-                       continue;
+    if (data_chk && afr_is_dirty_count_non_unary_for_txn(
+                        this, replies, AFR_DATA_TRANSACTION)) {
+        return _gf_true;
+    } else if (mdata_chk && afr_is_dirty_count_non_unary_for_txn(
+                                this, replies, AFR_METADATA_TRANSACTION)) {
+        return _gf_true;
+    } else if (entry_chk && afr_is_dirty_count_non_unary_for_txn(
+                                this, replies, AFR_ENTRY_TRANSACTION)) {
+        return _gf_true;
+    }
 
-               changelog[i][m_idx] = hton32(1);
-               if (idx != -1)
-                       changelog[i][idx] = hton32(1);
-                /* If the newentry marking is on a newly created directory,
-                 * then mark it with the full-heal indicator.
-                 */
-                if ((IA_ISDIR (iat)) && (priv->esh_granular))
-                        changelog[i][d_idx] = hton32(1);
-       }
-       ret = afr_set_pending_dict (priv, xattr, changelog);
-       if (ret < 0) {
-               afr_matrix_cleanup (changelog, priv->child_count);
-               return NULL;
-       }
-out:
-       return changelog;
+    return _gf_false;
 }
 
-gf_boolean_t
-afr_decide_heal_info (afr_private_t *priv, unsigned char *sources, int source)
-{
-        int sources_count = 0;
-
-        if (source < 0)
-                goto out;
-
-        sources_count = AFR_COUNT (sources, priv->child_count);
-        if (sources_count == priv->child_count)
-                return _gf_false;
-out:
-        return _gf_true;
+static int
+afr_update_heal_status(xlator_t *this, struct afr_reply *replies,
+                       ia_type_t ia_type, gf_boolean_t *esh, gf_boolean_t *dsh,
+                       gf_boolean_t *msh, unsigned char pending)
+{
+    int ret = -1;
+    GF_UNUSED int ret1 = 0;
+    int i = 0;
+    int io_domain_lk_count = 0;
+    int shd_domain_lk_count = 0;
+    afr_private_t *priv = NULL;
+    char *key1 = NULL;
+    char *key2 = NULL;
+
+    priv = this->private;
+    key1 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +
+                   strlen(this->name));
+    key2 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +
+                   strlen(priv->sh_domain));
+    sprintf(key1, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, this->name);
+    sprintf(key2, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, priv->sh_domain);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if ((replies[i].valid != 1) || (replies[i].op_ret != 0))
+            continue;
+        if (!io_domain_lk_count) {
+            ret1 = dict_get_int32(replies[i].xdata, key1, &io_domain_lk_count);
+        }
+        if (!shd_domain_lk_count) {
+            ret1 = dict_get_int32(replies[i].xdata, key2, &shd_domain_lk_count);
+        }
+    }
+
+    if (!pending) {
+        if ((afr_is_dirty_count_non_unary(this, replies, ia_type)) ||
+            (!io_domain_lk_count)) {
+            /* Needs heal. */
+            ret = 0;
+        } else {
+            /* No heal needed. */
+            *dsh = *esh = *msh = 0;
+        }
+    } else {
+        if (shd_domain_lk_count) {
+            ret = -EAGAIN; /*For 'possibly-healing'. */
+        } else {
+            ret = 0; /*needs heal. Just set a non -ve value so that it is
+                       assumed as the source index.*/
+        }
+    }
+    return ret;
 }
 
+/*return EIO, EAGAIN or pending*/
 int
-afr_selfheal_locked_metadata_inspect (call_frame_t *frame, xlator_t *this,
-                                      inode_t *inode, gf_boolean_t *msh,
-                                      gf_boolean_t *pending)
-{
-        int ret = -1;
-        unsigned char *locked_on = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        struct afr_reply *locked_replies = NULL;
-
-        afr_private_t *priv = this->private;
-
-        locked_on = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-                                    LLONG_MAX - 1, 0, locked_on);
-        {
-                if (ret == 0) {
-                        /* Not a single lock */
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN;/* all invalid responses */
-                        goto out;
-                }
-                ret = __afr_selfheal_metadata_prepare (frame, this, inode,
-                                                       locked_on, sources,
-                                                       sinks, healed_sinks,
-                                                       undid_pending,
-                                                       locked_replies,
-                                                       pending);
-                *msh = afr_decide_heal_info (priv, sources, ret);
-        }
-        afr_selfheal_uninodelk (frame, this, inode, this->name,
-                                LLONG_MAX - 1, 0, locked_on);
+afr_lockless_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,
+                     inode_t **inode, gf_boolean_t *entry_selfheal,
+                     gf_boolean_t *data_selfheal,
+                     gf_boolean_t *metadata_selfheal, unsigned char *pending)
+{
+    int ret = -1;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    gf_boolean_t dsh = _gf_false;
+    gf_boolean_t msh = _gf_false;
+    gf_boolean_t esh = _gf_false;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *valid_on = NULL;
+    uint64_t *witness = NULL;
+
+    priv = this->private;
+    replies = alloca0(sizeof(*replies) * priv->child_count);
+    sources = alloca0(sizeof(*sources) * priv->child_count);
+    sinks = alloca0(sizeof(*sinks) * priv->child_count);
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    valid_on = alloca0(sizeof(*valid_on) * priv->child_count);
+
+    ret = afr_selfheal_unlocked_inspect(frame, this, gfid, inode, &dsh, &msh,
+                                        &esh, replies);
+    if (ret)
+        goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            valid_on[i] = 1;
+        }
+    }
+    if (msh) {
+        ret = afr_selfheal_find_direction(frame, this, replies,
+                                          AFR_METADATA_TRANSACTION, valid_on,
+                                          sources, sinks, witness, pending);
+        if (*pending & PFLAG_SBRAIN)
+            ret = -EIO;
+        if (ret)
+            goto out;
+    }
+    if (dsh) {
+        ret = afr_selfheal_find_direction(frame, this, replies,
+                                          AFR_DATA_TRANSACTION, valid_on,
+                                          sources, sinks, witness, pending);
+        if (*pending & PFLAG_SBRAIN)
+            ret = -EIO;
+        if (ret)
+            goto out;
+    }
+    if (esh) {
+        ret = afr_selfheal_find_direction(frame, this, replies,
+                                          AFR_ENTRY_TRANSACTION, valid_on,
+                                          sources, sinks, witness, pending);
+        if (*pending & PFLAG_SBRAIN)
+            ret = -EIO;
+        if (ret)
+            goto out;
+    }
+
+    ret = afr_update_heal_status(this, replies, (*inode)->ia_type, &esh, &dsh,
+                                 &msh, *pending);
 out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-        return ret;
+    *data_selfheal = dsh;
+    *entry_selfheal = esh;
+    *metadata_selfheal = msh;
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    return ret;
 }
 
 int
-afr_selfheal_locked_data_inspect (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, gf_boolean_t *dsh,
-                                  gf_boolean_t *pflag)
-{
-        int ret = -1;
-        unsigned char *data_lock = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        afr_private_t   *priv = NULL;
-        fd_t          *fd = NULL;
-        struct afr_reply *locked_replies = NULL;
-
-        priv = this->private;
-        data_lock = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-        /* Heal-info does an open() on the file being examined so that the
-         * current eager-lock holding client, if present, at some point sees
-         * open-fd count being > 1 and releases the eager-lock so that heal-info
-         * doesn't remain blocked forever until IO completes.
-         */
-        ret = afr_selfheal_data_open (this, inode, &fd);
+afr_get_heal_info(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    gf_boolean_t data_selfheal = _gf_false;
+    gf_boolean_t metadata_selfheal = _gf_false;
+    gf_boolean_t entry_selfheal = _gf_false;
+    unsigned char pending = 0;
+    dict_t *dict = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+    inode_t *inode = NULL;
+    char *substr = NULL;
+    char *status = NULL;
+    call_frame_t *heal_frame = NULL;
+    afr_local_t *heal_local = NULL;
+
+    /*Use frame with lk-owner set*/
+    heal_frame = afr_frame_create(frame->this, &op_errno);
+    if (!heal_frame) {
+        ret = -1;
+        goto out;
+    }
+    heal_local = heal_frame->local;
+    heal_frame->local = frame->local;
+
+    ret = afr_lockless_inspect(heal_frame, this, loc->gfid, &inode,
+                               &entry_selfheal, &data_selfheal,
+                               &metadata_selfheal, &pending);
+
+    if (ret == -ENOMEM) {
+        ret = -1;
+        goto out;
+    }
+
+    if (pending & PFLAG_PENDING) {
+        gf_asprintf(&substr, "-pending");
+        if (!substr)
+            goto out;
+    }
+
+    if (ret == -EIO) {
+        ret = gf_asprintf(&status, "split-brain%s", substr ? substr : "");
+        if (ret < 0) {
+            goto out;
+        }
+        dict = afr_set_heal_info(status);
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
+    } else if (ret == -EAGAIN) {
+        ret = gf_asprintf(&status, "possibly-healing%s", substr ? substr : "");
         if (ret < 0) {
-                gf_msg_debug (this->name, -ret, "%s: Failed to open",
-                              uuid_utoa (inode->gfid));
+            goto out;
+        }
+        dict = afr_set_heal_info(status);
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
+    } else if (ret >= 0) {
+        /* value of ret = source index
+         * so ret >= 0 and at least one of the 3 booleans set to
+         * true means a source is identified; heal is required.
+         */
+        if (!data_selfheal && !entry_selfheal && !metadata_selfheal) {
+            status = gf_strdup("no-heal");
+            if (!status) {
+                ret = -1;
+                goto out;
+            }
+            dict = afr_set_heal_info(status);
+            if (!dict) {
+                ret = -1;
+                goto out;
+            }
+        } else {
+            ret = gf_asprintf(&status, "heal%s", substr ? substr : "");
+            if (ret < 0) {
+                goto out;
+            }
+            dict = afr_set_heal_info(status);
+            if (!dict) {
+                ret = -1;
+                goto out;
+            }
+        }
+    } else if (ret < 0) {
+        /* Apart from above checked -ve ret values, there are
+         * other possible ret values like ENOTCONN
+         * (returned when number of valid replies received are
+         * less than 2)
+         * in which case heal is required when one of the
+         * selfheal booleans is set.
+         */
+        if (data_selfheal || entry_selfheal || metadata_selfheal) {
+            ret = gf_asprintf(&status, "heal%s", substr ? substr : "");
+            if (ret < 0) {
+                goto out;
+            }
+            dict = afr_set_heal_info(status);
+            if (!dict) {
+                ret = -1;
                 goto out;
+            }
         }
+    }
 
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
+    ret = 0;
+    op_errno = 0;
 
-        ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-                                    0, 0, data_lock);
-        {
-                if (ret == 0) {
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN; /* all invalid responses */
-                        goto out;
-                }
-                ret = __afr_selfheal_data_prepare (frame, this, inode,
-                                                   data_lock, sources, sinks,
-                                                   healed_sinks, undid_pending,
-                                                   locked_replies, pflag);
-                *dsh = afr_decide_heal_info (priv, sources, ret);
-        }
-        afr_selfheal_uninodelk (frame, this, inode, this->name, 0, 0,
-                                data_lock);
 out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (heal_frame) {
+        heal_frame->local = heal_local;
+        AFR_STACK_DESTROY(heal_frame);
+    }
+    AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    if (dict)
+        dict_unref(dict);
+    if (inode)
+        inode_unref(inode);
+    GF_FREE(substr);
+    return ret;
 }
 
 int
-afr_selfheal_locked_entry_inspect (call_frame_t *frame, xlator_t *this,
-                                   inode_t *inode,
-                                   gf_boolean_t *esh, gf_boolean_t *pflag)
-{
-        int ret = -1;
-        int source = -1;
-        afr_private_t   *priv = NULL;
-        unsigned char *locked_on = NULL;
-        unsigned char *data_lock = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        struct afr_reply *locked_replies = NULL;
-        gf_boolean_t granular_locks = _gf_false;
-
-        priv = this->private;
-	if (strcmp ("granular", priv->locking_scheme) == 0)
-	        granular_locks = _gf_true;
-        locked_on = alloca0 (priv->child_count);
-        data_lock = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        if (!granular_locks) {
-                ret = afr_selfheal_tryentrylk (frame, this, inode,
-                                              priv->sh_domain, NULL, locked_on);
-        }
-        {
-                if (!granular_locks && ret == 0) {
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN;/* all invalid responses */
-                        goto out;
-                }
-
-                ret = afr_selfheal_entrylk (frame, this, inode, this->name,
-                                            NULL, data_lock);
-                {
-                        if (ret == 0) {
-                                ret = -afr_final_errno (frame->local, priv);
-                                if (ret == 0)
-                                        ret = -ENOTCONN;
-                                /* all invalid responses */
-                                goto unlock;
-                        }
-                        ret = __afr_selfheal_entry_prepare (frame, this, inode,
-                                                            data_lock, sources,
-                                                            sinks, healed_sinks,
-                                                            locked_replies,
-                                                            &source, pflag);
-                        if ((ret == 0) && source < 0)
-                                ret = -EIO;
-                        *esh = afr_decide_heal_info (priv, sources, ret);
-                }
-                afr_selfheal_unentrylk (frame, this, inode, this->name, NULL,
-                                        data_lock, NULL);
-        }
-unlock:
-        if (!granular_locks)
-                afr_selfheal_unentrylk (frame, this, inode, priv->sh_domain,
-                                        NULL, locked_on, NULL);
-out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
+_afr_is_split_brain(call_frame_t *frame, xlator_t *this,
+                    struct afr_reply *replies, afr_transaction_type type,
+                    gf_boolean_t *spb)
+{
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    int sources_count = 0;
+    int ret = 0;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    witness = alloca0(priv->child_count * sizeof(*witness));
+
+    ret = afr_selfheal_find_direction(frame, this, replies, type,
+                                      priv->child_up, sources, sinks, witness,
+                                      NULL);
+    if (ret)
         return ret;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+    if (!sources_count)
+        *spb = _gf_true;
+
+    return ret;
 }
 
 int
-afr_selfheal_locked_inspect (call_frame_t *frame, xlator_t *this, uuid_t gfid,
-                             inode_t **inode,
-                             gf_boolean_t *entry_selfheal,
-                             gf_boolean_t *data_selfheal,
-                             gf_boolean_t *metadata_selfheal,
-                             gf_boolean_t *pending)
-
+afr_is_split_brain(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                   uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb)
 {
-        int ret             = -1;
-        gf_boolean_t    dsh = _gf_false;
-        gf_boolean_t    msh = _gf_false;
-        gf_boolean_t    esh = _gf_false;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
 
-        ret = afr_selfheal_unlocked_inspect (frame, this, gfid, inode,
-                                             &dsh, &msh, &esh);
-        if (ret)
-                goto out;
+    priv = this->private;
 
-        /* For every heal type hold locks and check if it indeed needs heal */
+    replies = alloca0(sizeof(*replies) * priv->child_count);
 
-        if (msh) {
-                ret = afr_selfheal_locked_metadata_inspect (frame, this,
-                                                            *inode, &msh,
-                                                            pending);
-                if (ret == -EIO)
-                        goto out;
-        }
+    ret = afr_selfheal_unlocked_discover(frame, inode, gfid, replies);
+    if (ret)
+        goto out;
 
-        if (dsh) {
-                ret = afr_selfheal_locked_data_inspect (frame, this, *inode,
-                                                        &dsh, pending);
-                if (ret == -EIO || (ret == -EAGAIN))
-                        goto out;
-        }
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        ret = -EAGAIN;
+        goto out;
+    }
 
-        if (esh) {
-                ret = afr_selfheal_locked_entry_inspect (frame, this, *inode,
-                                                         &esh, pending);
-        }
+    ret = _afr_is_split_brain(frame, this, replies, AFR_DATA_TRANSACTION,
+                              d_spb);
+    if (ret)
+        goto out;
 
+    ret = _afr_is_split_brain(frame, this, replies, AFR_METADATA_TRANSACTION,
+                              m_spb);
 out:
-        *data_selfheal = dsh;
-        *entry_selfheal = esh;
-        *metadata_selfheal = msh;
-        return ret;
+    if (replies) {
+        afr_replies_wipe(replies, priv->child_count);
+        replies = NULL;
+    }
+    return ret;
 }
 
-dict_t*
-afr_set_heal_info (char *status)
+int
+afr_get_split_brain_status_cbk(int ret, call_frame_t *frame, void *opaque)
 {
-        dict_t *dict = NULL;
-        int    ret   = -1;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "heal-info", status);
-        if (ret)
-                gf_msg ("", GF_LOG_WARNING, -ret,
-                        AFR_MSG_DICT_SET_FAILED,
-                        "Failed to set heal-info key to "
-                        "%s", status);
-out:
-        return dict;
+    GF_FREE(opaque);
+    return 0;
 }
 
 int
-afr_get_heal_info (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        gf_boolean_t    data_selfheal     = _gf_false;
-        gf_boolean_t    metadata_selfheal = _gf_false;
-        gf_boolean_t    entry_selfheal    = _gf_false;
-        gf_boolean_t    pending           = _gf_false;
-        dict_t         *dict              = NULL;
-        int             ret               = -1;
-        int             op_errno          = 0;
-        int             size              = 0;
-        inode_t        *inode             = NULL;
-        char           *substr            = NULL;
-        char           *status            = NULL;
-
-        ret = afr_selfheal_locked_inspect (frame, this, loc->gfid, &inode,
-                                           &entry_selfheal,
-                                           &data_selfheal, &metadata_selfheal,
-                                           &pending);
-
-        if (ret == -ENOMEM) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
+afr_get_split_brain_status(void *opaque)
+{
+    gf_boolean_t d_spb = _gf_false;
+    gf_boolean_t m_spb = _gf_false;
+    int ret = -1;
+    int op_errno = 0;
+    int i = 0;
+    char *choices = NULL;
+    char *status = NULL;
+    dict_t *dict = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    loc_t *loc = NULL;
+    afr_spb_status_t *data = NULL;
+
+    data = opaque;
+    frame = data->frame;
+    this = frame->this;
+    loc = data->loc;
+    priv = this->private;
+    children = priv->children;
+
+    inode = afr_inode_find(this, loc->gfid);
+    if (!inode)
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        op_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    /* Calculation for string length :
+     * (child_count X length of child-name) + SLEN("    Choices :")
+     * child-name consists of :
+     * a) 251 = max characters for volname according to GD_VOLUME_NAME_MAX
+     * b) strlen("-client-00,") assuming 16 replicas
+     */
+    choices = alloca0(priv->child_count * (256 + SLEN("-client-00,")) +
+                      SLEN("    Choices:"));
+
+    ret = afr_is_split_brain(frame, this, inode, loc->gfid, &d_spb, &m_spb);
+    if (ret) {
+        op_errno = -ret;
+        if (ret == -EAGAIN) {
+            ret = dict_set_sizen_str_sizen(dict, GF_AFR_SBRAIN_STATUS,
+                                           SBRAIN_HEAL_NO_GO_MSG);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_WARNING, -ret,
+                       AFR_MSG_DICT_SET_FAILED,
+                       "Failed to set GF_AFR_SBRAIN_STATUS in dict");
+            }
         }
+        ret = -1;
+        goto out;
+    }
 
-        if (pending) {
-                size = strlen ("-pending") + 1;
-                gf_asprintf (&substr, "-pending");
-                if (!substr)
-                        goto out;
+    if (d_spb || m_spb) {
+        sprintf(choices, "    Choices:");
+        for (i = 0; i < priv->child_count; i++) {
+            strcat(choices, children[i]->name);
+            strcat(choices, ",");
         }
+        choices[strlen(choices) - 1] = '\0';
 
-        if (ret == -EIO) {
-                size += strlen ("split-brain") + 1;
-                ret = gf_asprintf (&status, "split-brain%s",
-                                   substr? substr : "");
-                if (ret < 0)
-                        goto out;
-                dict = afr_set_heal_info (status);
-        } else if (ret == -EAGAIN) {
-                size += strlen ("possibly-healing") + 1;
-                ret = gf_asprintf (&status, "possibly-healing%s",
-                                   substr? substr : "");
-                if (ret < 0)
-                        goto out;
-                dict = afr_set_heal_info (status);
-        } else if (ret >= 0) {
-                /* value of ret = source index
-                 * so ret >= 0 and at least one of the 3 booleans set to
-                 * true means a source is identified; heal is required.
-                 */
-                if (!data_selfheal && !entry_selfheal &&
-                    !metadata_selfheal) {
-                        dict = afr_set_heal_info ("no-heal");
-                } else {
-                        size += strlen ("heal") + 1;
-                        ret = gf_asprintf (&status, "heal%s",
-                                           substr? substr : "");
-                        if (ret < 0)
-                                goto out;
-                        dict = afr_set_heal_info (status);
-                }
-        } else if (ret < 0) {
-                /* Apart from above checked -ve ret values, there are
-                 * other possible ret values like ENOTCONN
-                 * (returned when number of valid replies received are
-                 * less than 2)
-                 * in which case heal is required when one of the
-                 * selfheal booleans is set.
-                 */
-                if (data_selfheal || entry_selfheal ||
-                    metadata_selfheal) {
-                        size += strlen ("heal") + 1;
-                        ret = gf_asprintf (&status, "heal%s",
-                                           substr? substr : "");
-                        if (ret < 0)
-                                goto out;
-                        dict = afr_set_heal_info (status);
-                }
+        ret = gf_asprintf(&status,
+                          "data-split-brain:%s    "
+                          "metadata-split-brain:%s%s",
+                          (d_spb) ? "yes" : "no", (m_spb) ? "yes" : "no",
+                          choices);
+
+        if (-1 == ret) {
+            op_errno = ENOMEM;
+            goto out;
         }
-        ret = 0;
+        ret = dict_set_dynstr_sizen(dict, GF_AFR_SBRAIN_STATUS, status);
+        if (ret) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    } else {
+        ret = dict_set_sizen_str_sizen(dict, GF_AFR_SBRAIN_STATUS,
+                                       SFILE_NOT_UNDER_DATA);
+        if (ret) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
 
+    ret = 0;
 out:
-        AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        if (dict)
-               dict_unref (dict);
-        if (inode)
-                inode_unref (inode);
-        GF_FREE (substr);
-        return ret;
+    AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    if (dict)
+        dict_unref(dict);
+    if (inode)
+        inode_unref(inode);
+    return ret;
 }
 
-int
-_afr_is_split_brain (call_frame_t *frame, xlator_t *this,
-                         struct afr_reply *replies,
-                         afr_transaction_type type,
-                         gf_boolean_t *spb)
-{
-        afr_private_t    *priv              = NULL;
-        uint64_t         *witness           = NULL;
-        unsigned char    *sources           = NULL;
-        unsigned char    *sinks             = NULL;
-        int               sources_count     = 0;
-        int               ret               = 0;
-
-        priv = this->private;
-
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        witness = alloca0(priv->child_count * sizeof (*witness));
-
-        ret = afr_selfheal_find_direction (frame, this, replies,
-					   type, priv->child_up, sources,
-                                           sinks, witness, NULL);
+int32_t
+afr_heal_splitbrain_file(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    int ret = 0;
+    int op_errno = 0;
+    dict_t *dict = NULL;
+    afr_local_t *local = NULL;
+    afr_local_t *heal_local = NULL;
+    call_frame_t *heal_frame = NULL;
+
+    local = frame->local;
+    dict = dict_new();
+    if (!dict) {
+        op_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    heal_frame = afr_frame_create(this, &op_errno);
+    if (!heal_frame) {
+        ret = -1;
+        goto out;
+    }
+    heal_local = heal_frame->local;
+    heal_frame->local = frame->local;
+    /*Initiate heal with heal_frame with lk-owner set so that inodelk/entrylk
+     * work correctly*/
+    ret = afr_selfheal_do(heal_frame, this, loc->gfid);
+
+    if (ret == 1 || ret == 2) {
+        ret = dict_set_sizen_str_sizen(dict, "sh-fail-msg",
+                                       SFILE_NOT_IN_SPLIT_BRAIN);
         if (ret)
-                return ret;
-
-        sources_count = AFR_COUNT (sources, priv->child_count);
-        if (!sources_count)
-                *spb = _gf_true;
+            gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Failed to set sh-fail-msg in dict");
+        ret = 0;
+        goto out;
+    } else {
+        if (local->xdata_rsp) {
+            /* 'sh-fail-msg' has been set in the dict during self-heal.*/
+            dict_copy(local->xdata_rsp, dict);
+            ret = 0;
+        } else if (ret < 0) {
+            op_errno = -ret;
+            ret = -1;
+        }
+    }
 
-        return ret;
+out:
+    if (heal_frame) {
+        heal_frame->local = heal_local;
+        AFR_STACK_DESTROY(heal_frame);
+    }
+    if (local->op == GF_FOP_GETXATTR)
+        AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    else if (local->op == GF_FOP_SETXATTR)
+        AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int
-afr_is_split_brain (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                    uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb)
+afr_get_child_index_from_name(xlator_t *this, char *name)
 {
-        int    ret                          = -1;
-        afr_private_t    *priv              = NULL;
-        struct afr_reply *replies           = NULL;
+    afr_private_t *priv = this->private;
+    int index = -1;
 
-        priv = this->private;
+    for (index = 0; index < priv->child_count; index++) {
+        if (!strcmp(priv->children[index]->name, name))
+            goto out;
+    }
+    index = -1;
+out:
+    return index;
+}
 
-        replies = alloca0 (sizeof (*replies) * priv->child_count);
+void
+afr_priv_need_heal_set(afr_private_t *priv, gf_boolean_t need_heal)
+{
+    LOCK(&priv->lock);
+    {
+        priv->need_heal = need_heal;
+    }
+    UNLOCK(&priv->lock);
+}
 
-        ret = afr_selfheal_unlocked_discover (frame, inode, gfid, replies);
-        if (ret)
-                goto out;
+void
+afr_set_need_heal(xlator_t *this, afr_local_t *local)
+{
+    int i = 0;
+    afr_private_t *priv = this->private;
+    gf_boolean_t need_heal = _gf_false;
 
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                ret = -EAGAIN;
-                goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].need_heal) {
+            need_heal = _gf_true;
+            break;
         }
+    }
+    afr_priv_need_heal_set(priv, need_heal);
+    return;
+}
 
-        ret = _afr_is_split_brain (frame, this, replies,
-                                    AFR_DATA_TRANSACTION, d_spb);
-        if (ret)
-                goto out;
+gf_boolean_t
+afr_get_need_heal(xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    gf_boolean_t need_heal = _gf_true;
 
-        ret = _afr_is_split_brain (frame, this, replies,
-                                    AFR_METADATA_TRANSACTION, m_spb);
-out:
-        if (replies) {
-                afr_replies_wipe (replies, priv->child_count);
-                replies = NULL;
-        }
-        return ret;
+    LOCK(&priv->lock);
+    {
+        need_heal = priv->need_heal;
+    }
+    UNLOCK(&priv->lock);
+    return need_heal;
 }
 
 int
-afr_get_split_brain_status_cbk (int ret, call_frame_t *frame, void *opaque)
+afr_get_msg_id(char *op_type)
 {
-        GF_FREE (opaque);
-        return 0;
+    if (!strcmp(op_type, GF_AFR_REPLACE_BRICK))
+        return AFR_MSG_REPLACE_BRICK_STATUS;
+    else if (!strcmp(op_type, GF_AFR_ADD_BRICK))
+        return AFR_MSG_ADD_BRICK_STATUS;
+    return -1;
 }
 
 int
-afr_get_split_brain_status (void *opaque)
-{
-        gf_boolean_t      d_spb             = _gf_false;
-        gf_boolean_t      m_spb             = _gf_false;
-        int               ret               = -1;
-        int               op_errno          = 0;
-        int               i                 = 0;
-        char             *choices           = NULL;
-        char             *status            = NULL;
-        dict_t           *dict              = NULL;
-        inode_t          *inode             = NULL;
-        afr_private_t    *priv              = NULL;
-        xlator_t         **children         = NULL;
-        call_frame_t     *frame             = NULL;
-        xlator_t         *this              = NULL;
-        loc_t            *loc               = NULL;
-        afr_spb_status_t *data              = NULL;
-
-        data     = opaque;
-        frame    = data->frame;
-        this     = frame->this;
-        loc      = data->loc;
-        priv     = this->private;
-        children = priv->children;
-
-        inode = afr_inode_find (this, loc->gfid);
-        if (!inode)
-                goto out;
+afr_fav_child_reset_sink_xattrs_cbk(int ret, call_frame_t *heal_frame,
+                                    void *opaque)
+{
+    call_frame_t *txn_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_local_t *heal_local = NULL;
+    xlator_t *this = NULL;
 
-        dict = dict_new ();
-        if (!dict) {
-                op_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    heal_local = heal_frame->local;
+    txn_frame = heal_local->heal_frame;
+    local = txn_frame->local;
+    this = txn_frame->this;
 
-        /* Calculation for string length :
-        * (child_count X length of child-name) + strlen ("    Choices :")
-        * child-name consists of :
-        * a) 256 = max characters for volname according to GD_VOLUME_NAME_MAX
-        * b) strlen ("-client-00,") assuming 16 replicas
-        */
-        choices = alloca0 (priv->child_count * (256 + strlen ("-client-00,")) +
-                           strlen ("    Choices:"));
+    /* Refresh the inode agan and proceed with the transaction.*/
+    afr_inode_refresh(txn_frame, this, local->inode, NULL, local->refreshfn);
 
-        ret = afr_is_split_brain (frame, this, inode, loc->gfid, &d_spb,
-                                  &m_spb);
-        if (ret) {
-                op_errno = -ret;
-                if (ret == -EAGAIN)
-                        ret = dict_set_str (dict, GF_AFR_SBRAIN_STATUS,
-                                            SBRAIN_HEAL_NO_GO_MSG);
-                ret = -1;
-                goto out;
-        }
+    AFR_STACK_DESTROY(heal_frame);
 
-        if (d_spb || m_spb) {
-                sprintf (choices, "    Choices:");
-                for (i = 0; i < priv->child_count; i++) {
-                        strcat (choices, children[i]->name);
-                        strcat (choices, ",");
-                }
-                choices[strlen (choices) - 1] = '\0';
+    return 0;
+}
+
+int
+afr_fav_child_reset_sink_xattrs(void *opaque)
+{
+    call_frame_t *heal_frame = NULL;
+    call_frame_t *txn_frame = NULL;
+    xlator_t *this = NULL;
+    gf_boolean_t d_spb = _gf_false;
+    gf_boolean_t m_spb = _gf_false;
+    afr_local_t *heal_local = NULL;
+    afr_local_t *txn_local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    unsigned char *locked_on = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    int ret = 0;
+
+    heal_frame = (call_frame_t *)opaque;
+    heal_local = heal_frame->local;
+    txn_frame = heal_local->heal_frame;
+    txn_local = txn_frame->local;
+    this = txn_frame->this;
+    inode = txn_local->inode;
+    priv = this->private;
+    locked_on = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = _afr_is_split_brain(txn_frame, this, txn_local->replies,
+                              AFR_DATA_TRANSACTION, &d_spb);
+
+    ret = _afr_is_split_brain(txn_frame, this, txn_local->replies,
+                              AFR_METADATA_TRANSACTION, &m_spb);
+
+    /* Take appropriate locks and reset sink xattrs. */
+    if (d_spb) {
+        ret = afr_selfheal_inodelk(heal_frame, this, inode, this->name, 0, 0,
+                                   locked_on);
+        {
+            if (ret < priv->child_count)
+                goto data_unlock;
+            ret = __afr_selfheal_data_prepare(
+                heal_frame, this, inode, locked_on, sources, sinks,
+                healed_sinks, undid_pending, locked_replies, NULL);
+        }
+    data_unlock:
+        afr_selfheal_uninodelk(heal_frame, this, inode, this->name, 0, 0,
+                               locked_on);
+    }
+
+    if (m_spb) {
+        memset(locked_on, 0, sizeof(*locked_on) * priv->child_count);
+        memset(undid_pending, 0, sizeof(*undid_pending) * priv->child_count);
+        ret = afr_selfheal_inodelk(heal_frame, this, inode, this->name,
+                                   LLONG_MAX - 1, 0, locked_on);
+        {
+            if (ret < priv->child_count)
+                goto mdata_unlock;
+            ret = __afr_selfheal_metadata_prepare(
+                heal_frame, this, inode, locked_on, sources, sinks,
+                healed_sinks, undid_pending, locked_replies, NULL);
+        }
+    mdata_unlock:
+        afr_selfheal_uninodelk(heal_frame, this, inode, this->name,
+                               LLONG_MAX - 1, 0, locked_on);
+    }
 
-                ret = gf_asprintf (&status, "data-split-brain:%s    "
-                                    "metadata-split-brain:%s%s",
-                                    (d_spb) ? "yes" : "no",
-                                    (m_spb) ? "yes" : "no", choices);
+    return ret;
+}
 
-                if (-1 == ret) {
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                ret = dict_set_dynstr (dict, GF_AFR_SBRAIN_STATUS, status);
-                if (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
+/*
+ * Concatenates the xattrs in local->replies separated by a delimiter.
+ */
+int
+afr_serialize_xattrs_with_delimiter(call_frame_t *frame, xlator_t *this,
+                                    char *buf, const char *default_str,
+                                    int32_t *serz_len, char delimiter)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    char *xattr = NULL;
+    int i = 0;
+    int len = 0;
+    int keylen = 0;
+    size_t str_len = 0;
+    int ret = -1;
+
+    priv = this->private;
+    local = frame->local;
+
+    keylen = strlen(local->cont.getxattr.name);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid || local->replies[i].op_ret) {
+            str_len = strlen(default_str);
+            buf = strncat(buf, default_str, str_len);
+            len += str_len;
+            buf[len++] = delimiter;
+            buf[len] = '\0';
         } else {
-                ret = dict_set_str (dict, GF_AFR_SBRAIN_STATUS,
-                                    "The file is not under data or"
-                                    " metadata split-brain");
-                if (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        }
+            ret = dict_get_strn(local->replies[i].xattr,
+                                local->cont.getxattr.name, keylen, &xattr);
+            if (ret) {
+                gf_msg("TEST", GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                       "Failed to get the node_uuid of brick "
+                       "%d",
+                       i);
+                goto out;
+            }
+            str_len = strlen(xattr);
+            buf = strncat(buf, xattr, str_len);
+            len += str_len;
+            buf[len++] = delimiter;
+            buf[len] = '\0';
+        }
+    }
+    buf[--len] = '\0'; /*remove the last delimiter*/
+    if (serz_len)
+        *serz_len = ++len;
+    ret = 0;
 
-        ret = 0;
 out:
-        AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        if (dict)
-               dict_unref (dict);
-        if (inode)
-                inode_unref (inode);
-        return ret;
+    return ret;
 }
 
-int32_t
-afr_heal_splitbrain_file(call_frame_t *frame, xlator_t *this, loc_t *loc)
+uint64_t
+afr_write_subvol_get(call_frame_t *frame, xlator_t *this)
 {
-        int             ret               = 0;
-        int             op_errno          = 0;
-        dict_t         *dict              = NULL;
-        afr_local_t    *local             = NULL;
-
-        local = frame->local;
-        dict = dict_new ();
-        if (!dict) {
-                op_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    afr_local_t *local = NULL;
+    uint64_t write_subvol = 0;
 
-        ret = afr_selfheal_do (frame, this, loc->gfid);
+    local = frame->local;
+    LOCK(&local->inode->lock);
+    write_subvol = local->inode_ctx->write_subvol;
+    UNLOCK(&local->inode->lock);
 
-        if (ret == 1 || ret == 2) {
-                ret = dict_set_str (dict, "sh-fail-msg",
-                                    "File not in split-brain");
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Failed to set sh-fail-msg in dict");
-                ret = 0;
-                goto out;
-        } else {
-                if (local->xdata_rsp) {
-                        /* 'sh-fail-msg' has been set in the dict during self-heal.*/
-                        dict_copy (local->xdata_rsp, dict);
-                        ret = 0;
-                } else if (ret < 0) {
-                        op_errno = -ret;
-                        ret = -1;
-                }
-        }
+    return write_subvol;
+}
 
-out:
-        if (local->op == GF_FOP_GETXATTR)
-                AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        else if (local->op == GF_FOP_SETXATTR)
-                AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        if (dict)
-                dict_unref(dict);
-        return ret;
+int
+afr_write_subvol_set(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *data_accused = NULL;
+    unsigned char *metadata_accused = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint64_t val = 0;
+    int event = 0;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+    data_accused = alloca0(priv->child_count);
+    metadata_accused = alloca0(priv->child_count);
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+    event = local->event_generation;
+
+    afr_readables_fill(frame, this, local->inode, data_accused,
+                       metadata_accused, data_readable, metadata_readable,
+                       NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_readable[i])
+            datamap |= (1 << i);
+        if (metadata_readable[i])
+            metadatamap |= (1 << i);
+    }
+
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
+
+    LOCK(&local->inode->lock);
+    {
+        if (local->inode_ctx->write_subvol == 0 &&
+            local->transaction.type == AFR_DATA_TRANSACTION) {
+            local->inode_ctx->write_subvol = val;
+        }
+    }
+    UNLOCK(&local->inode->lock);
+
+    return 0;
 }
 
 int
-afr_get_child_index_from_name (xlator_t *this, char *name)
+afr_write_subvol_reset(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv  = this->private;
-        int            index = -1;
+    afr_local_t *local = NULL;
 
-        for (index = 0; index < priv->child_count; index++) {
-                if (!strcmp (priv->children[index]->name, name))
-                        goto out;
-        }
-        index = -1;
-out:
-        return index;
-}
+    local = frame->local;
+    LOCK(&local->inode->lock);
+    {
+        GF_ASSERT(local->inode_ctx->lock_count > 0);
+        local->inode_ctx->lock_count--;
 
-void
-afr_priv_need_heal_set (afr_private_t *priv, gf_boolean_t need_heal)
-{
-        LOCK (&priv->lock);
-        {
-                priv->need_heal = need_heal;
-        }
-        UNLOCK (&priv->lock);
+        if (!local->inode_ctx->lock_count)
+            local->inode_ctx->write_subvol = 0;
+    }
+    UNLOCK(&local->inode->lock);
+
+    return 0;
 }
 
-void
-afr_set_need_heal (xlator_t *this, afr_local_t *local)
+int
+afr_set_inode_local(xlator_t *this, afr_local_t *local, inode_t *inode)
 {
-        int             i         = 0;
-        afr_private_t  *priv      = this->private;
-        gf_boolean_t    need_heal = _gf_false;
+    int ret = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->replies[i].valid && local->replies[i].need_heal) {
-                        need_heal = _gf_true;
-                        break;
-                }
-        }
-        afr_priv_need_heal_set (priv, need_heal);
-        return;
+    local->inode = inode_ref(inode);
+    LOCK(&local->inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, local->inode, &local->inode_ctx);
+    }
+    UNLOCK(&local->inode->lock);
+    if (ret < 0) {
+        gf_msg_callingfn(
+            this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_INODE_CTX_GET_FAILED,
+            "Error getting inode ctx %s", uuid_utoa(local->inode->gfid));
+    }
+    return ret;
 }
 
 gf_boolean_t
-afr_get_need_heal (xlator_t *this)
+afr_ta_is_fop_called_from_synctask(xlator_t *this)
 {
-        afr_private_t  *priv      = this->private;
-        gf_boolean_t    need_heal = _gf_true;
+    struct synctask *task = NULL;
+    gf_lkowner_t tmp_owner = {
+        0,
+    };
 
-        LOCK (&priv->lock);
-        {
-                need_heal = priv->need_heal;
-        }
-        UNLOCK (&priv->lock);
-        return need_heal;
+    task = synctask_get();
+    if (!task)
+        return _gf_false;
+
+    set_lk_owner_from_ptr(&tmp_owner, (void *)this);
+
+    if (!is_same_lkowner(&tmp_owner, &task->frame->root->lk_owner))
+        return _gf_false;
+
+    return _gf_true;
 }
 
 int
-afr_get_msg_id (char *op_type)
-{
+afr_ta_post_op_lock(xlator_t *this, loc_t *loc)
+{
+    int ret = 0;
+    uuid_t gfid = {
+        0,
+    };
+    afr_private_t *priv = this->private;
+    gf_boolean_t locked = _gf_false;
+    struct gf_flock flock1 = {
+        0,
+    };
+    struct gf_flock flock2 = {
+        0,
+    };
+    int32_t cmd = 0;
+
+    /* Clients must take AFR_TA_DOM_NOTIFY lock only when the previous lock
+     * has been released in afr_notify due to upcall notification from shd.
+     */
+    GF_ASSERT(priv->ta_notify_dom_lock_offset == 0);
+
+    if (!priv->shd.iamshd)
+        GF_ASSERT(afr_ta_is_fop_called_from_synctask(this));
+    flock1.l_type = F_WRLCK;
+
+    while (!locked) {
+        if (priv->shd.iamshd) {
+            cmd = F_SETLKW;
+            flock1.l_start = 0;
+            flock1.l_len = 0;
+        } else {
+            cmd = F_SETLK;
+            gf_uuid_generate(gfid);
+            flock1.l_start = gfid_to_ino(gfid);
+            if (flock1.l_start < 0)
+                flock1.l_start = -flock1.l_start;
+            flock1.l_len = 1;
+        }
+        ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                             AFR_TA_DOM_NOTIFY, loc, cmd, &flock1, NULL, NULL);
+        if (!ret) {
+            locked = _gf_true;
+            priv->ta_notify_dom_lock_offset = flock1.l_start;
+        } else if (ret == -EAGAIN) {
+            continue;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+                   "Failed to get "
+                   "AFR_TA_DOM_NOTIFY lock on %s.",
+                   loc->name);
+            goto out;
+        }
+    }
+
+    flock2.l_type = F_WRLCK;
+    flock2.l_start = 0;
+    flock2.l_len = 0;
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, loc, F_SETLKW, &flock2, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to get AFR_TA_DOM_MODIFY lock on %s.", loc->name);
+        flock1.l_type = F_UNLCK;
+        ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                             AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock1, NULL,
+                             NULL);
+    }
+out:
+    return ret;
+}
 
-        if (!strcmp (op_type, GF_AFR_REPLACE_BRICK))
-                return AFR_MSG_REPLACE_BRICK_STATUS;
-        else if (!strcmp (op_type, GF_AFR_ADD_BRICK))
-                return AFR_MSG_ADD_BRICK_STATUS;
-        return -1;
+int
+afr_ta_post_op_unlock(xlator_t *this, loc_t *loc)
+{
+    afr_private_t *priv = this->private;
+    struct gf_flock flock = {
+        0,
+    };
+    int ret = 0;
+
+    if (!priv->shd.iamshd)
+        GF_ASSERT(afr_ta_is_fop_called_from_synctask(this));
+    flock.l_type = F_UNLCK;
+    flock.l_start = 0;
+    flock.l_len = 0;
+
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to unlock AFR_TA_DOM_MODIFY lock.");
+        goto out;
+    }
+
+    if (!priv->shd.iamshd)
+        /* Mounts (clients) will not release the AFR_TA_DOM_NOTIFY lock
+         * in post-op as they use it as a notification mechanism. When
+         * shd sends a lock request on TA during heal, the clients will
+         * receive a lock-contention upcall notification upon which they
+         * will release the AFR_TA_DOM_NOTIFY lock after completing the
+         * in flight I/O.*/
+        goto out;
+
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to unlock AFR_TA_DOM_NOTIFY lock.");
+    }
+out:
+    return ret;
 }
 
-gf_boolean_t
-afr_can_compound_pre_op_and_op (afr_private_t *priv, glusterfs_fop_t fop)
+call_frame_t *
+afr_ta_frame_create(xlator_t *this)
 {
-        if (priv->arbiter_count != 0)
-                return _gf_false;
-
-        if (!priv->use_compound_fops)
-                return _gf_false;
+    call_frame_t *frame = NULL;
+    void *lk_owner = NULL;
 
-        switch (fop) {
-        case GF_FOP_WRITE:
-                return _gf_true;
-        default:
-                return _gf_false;
-        }
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        return NULL;
+    lk_owner = (void *)this;
+    afr_set_lk_owner(frame, this, lk_owner);
+    return frame;
 }
 
-afr_compound_cbk_t
-afr_pack_fop_args (call_frame_t *frame, compound_args_t *args,
-                   glusterfs_fop_t fop, int index)
+gf_boolean_t
+afr_ta_has_quorum(afr_private_t *priv, afr_local_t *local)
 {
-        afr_local_t     *local  = frame->local;
+    int data_count = 0;
 
-        switch (fop) {
-        case GF_FOP_WRITE:
-                COMPOUND_PACK_ARGS (writev, GF_FOP_WRITE,
-                                    args, index,
-                                    local->fd, local->cont.writev.vector,
-                                    local->cont.writev.count,
-                                    local->cont.writev.offset,
-                                    local->cont.writev.flags,
-                                    local->cont.writev.iobref,
-                                    local->xdata_req);
-                return afr_pre_op_writev_cbk;
-        default:
-                break;
-        }
-        return NULL;
+    data_count = AFR_COUNT(local->child_up, priv->child_count);
+    if (data_count == 2) {
+        return _gf_true;
+    } else if (data_count == 1 && local->ta_child_up) {
+        return _gf_true;
+    }
+
+    return _gf_false;
 }
 
-int
-afr_fav_child_reset_sink_xattrs_cbk (int ret, call_frame_t *heal_frame,
-                                     void *opaque)
+static gf_boolean_t
+afr_is_add_replica_mount_lookup_on_root(call_frame_t *frame)
 {
+    afr_local_t *local = NULL;
 
-        call_frame_t *txn_frame = NULL;
-        afr_local_t *local = NULL;
-        afr_local_t *heal_local = NULL;
-        xlator_t *this = NULL;
+    if (frame->root->pid != GF_CLIENT_PID_ADD_REPLICA_MOUNT)
+        return _gf_false;
 
-        heal_local = heal_frame->local;
-        txn_frame = heal_local->heal_frame;
-        local = txn_frame->local;
-        this = txn_frame->this;
+    local = frame->local;
 
-        /* Refresh the inode agan and proceed with the transaction.*/
-        afr_inode_refresh (txn_frame, this, local->inode, NULL,
-                           local->refreshfn);
+    if (local->op != GF_FOP_LOOKUP)
+        /* TODO:If the replica count is being increased on a plain distribute
+         * volume that was never mounted, we need to allow setxattr on '/' with
+         * GF_CLIENT_PID_NO_ROOT_SQUASH to accomodate for DHT layout setting */
+        return _gf_false;
 
-        if (heal_frame)
-                AFR_STACK_DESTROY (heal_frame);
+    if (local->inode == NULL)
+        return _gf_false;
 
-        return 0;
+    if (!__is_root_gfid(local->inode->gfid))
+        return _gf_false;
+
+    return _gf_true;
 }
 
-int
-afr_fav_child_reset_sink_xattrs (void *opaque)
-{
-        call_frame_t *heal_frame = NULL;
-        call_frame_t *txn_frame = NULL;
-        xlator_t *this = NULL;
-        gf_boolean_t d_spb = _gf_false;
-        gf_boolean_t m_spb = _gf_false;
-        afr_local_t *heal_local = NULL;
-        afr_local_t *txn_local = NULL;
-        afr_private_t *priv = NULL;
-        inode_t *inode  = NULL;
-        unsigned char *locked_on = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        struct afr_reply *locked_replies = NULL;
-        int ret = 0;
-
-        heal_frame = (call_frame_t *) opaque;
-        heal_local = heal_frame->local;
-        txn_frame = heal_local->heal_frame;
-        txn_local = txn_frame->local;
-        this = txn_frame->this;
-        inode = txn_local->inode;
-        priv = this->private;
-        locked_on = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        ret = _afr_is_split_brain (txn_frame, this, txn_local->replies,
-                                   AFR_DATA_TRANSACTION, &d_spb);
-
-        ret = _afr_is_split_brain (txn_frame, this, txn_local->replies,
-                                   AFR_METADATA_TRANSACTION, &m_spb);
-
-        /* Take appropriate locks and reset sink xattrs. */
-        if (d_spb) {
-                ret = afr_selfheal_inodelk (heal_frame, this, inode, this->name,
-                                            0, 0, locked_on);
-                {
-                        if (ret < AFR_SH_MIN_PARTICIPANTS)
-                                goto data_unlock;
-                        ret = __afr_selfheal_data_prepare (heal_frame, this,
-                                                           inode, locked_on,
-                                                           sources, sinks,
-                                                           healed_sinks,
-                                                           undid_pending,
-                                                           locked_replies,
-                                                           NULL);
-                }
-data_unlock:
-                afr_selfheal_uninodelk (heal_frame, this, inode, this->name,
-                                        0, 0, locked_on);
-        }
-
-        if (m_spb) {
-                memset (locked_on, 0, sizeof (*locked_on) * priv->child_count);
-                memset (undid_pending, 0,
-                        sizeof (*undid_pending) * priv->child_count);
-                ret = afr_selfheal_inodelk (heal_frame, this, inode, this->name,
-                                            LLONG_MAX-1, 0, locked_on);
-                {
-                        if (ret < AFR_SH_MIN_PARTICIPANTS)
-                                goto mdata_unlock;
-                        ret = __afr_selfheal_metadata_prepare (heal_frame, this,
-                                                               inode, locked_on,
-                                                               sources, sinks,
-                                                               healed_sinks,
-                                                               undid_pending,
-                                                               locked_replies,
-                                                               NULL);
+gf_boolean_t
+afr_lookup_has_quorum(call_frame_t *frame, const unsigned int up_children_count)
+{
+    if (frame && (up_children_count > 0) &&
+        afr_is_add_replica_mount_lookup_on_root(frame))
+        return _gf_true;
 
-                }
-mdata_unlock:
-                afr_selfheal_uninodelk (heal_frame, this, inode, this->name,
-                                        LLONG_MAX-1, 0, locked_on);
-        }
+    return _gf_false;
+}
 
-        return ret;
+void
+afr_handle_replies_quorum(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    unsigned char *success_replies = NULL;
 
-}
+    success_replies = alloca0(priv->child_count);
+    afr_fill_success_replies(local, priv, success_replies);
 
-/*
- * Concatenates the xattrs in local->replies separated by a delimiter.
- */
-int
-afr_serialize_xattrs_with_delimiter (call_frame_t *frame, xlator_t *this,
-                                     char *buf, const char *default_str,
-                                     int32_t *serz_len, char delimiter)
-{
-        afr_private_t *priv      = NULL;
-        afr_local_t   *local     = NULL;
-        char          *xattr     = NULL;
-        int            i         = 0;
-        int            len       = 0;
-        int            ret       = -1;
-
-        priv = this->private;
-        local = frame->local;
+    if (priv->quorum_count && !afr_has_quorum(success_replies, this, NULL)) {
+        local->op_errno = afr_final_errno(local, priv);
+        if (!local->op_errno)
+            local->op_errno = afr_quorum_errno(priv);
+        local->op_ret = -1;
+    }
+}
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid || local->replies[i].op_ret) {
-                        buf = strncat (buf, default_str, strlen (default_str));
-                        len += strlen (default_str);
-                        buf[len++] = delimiter;
-                        buf[len] = '\0';
-                } else {
-                        ret = dict_get_str (local->replies[i].xattr,
-                                            local->cont.getxattr.name, &xattr);
-                        if (ret) {
-                                gf_msg ("TEST", GF_LOG_ERROR, -ret,
-                                        AFR_MSG_DICT_GET_FAILED,
-                                        "Failed to get the node_uuid of brick "
-                                        "%d", i);
-                                goto out;
-                        }
-                        buf = strncat (buf, xattr, strlen (xattr));
-                        len += strlen (xattr);
-                        buf[len++] = delimiter;
-                        buf[len] = '\0';
-                }
+gf_boolean_t
+afr_ta_dict_contains_pending_xattr(dict_t *dict, afr_private_t *priv, int child)
+{
+    int *pending = NULL;
+    int ret = 0;
+    int i = 0;
+
+    ret = dict_get_ptr(dict, priv->pending_key[child], (void *)&pending);
+    if (ret == 0) {
+        for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+            /* Not doing a ntoh32(pending) as we just want to check
+             * if it is non-zero or not. */
+            if (pending[i]) {
+                return _gf_true;
+            }
         }
-        buf[--len] = '\0'; /*remove the last delimiter*/
-        if (serz_len)
-                *serz_len = ++len;
-        ret = 0;
+    }
 
-out:
-        return ret;
+    return _gf_false;
 }
diff --git a/xlators/cluster/afr/src/afr-dir-read.c b/xlators/cluster/afr/src/afr-dir-read.c
index 4e29171482a..f8bf8340dab 100644
--- a/xlators/cluster/afr/src/afr-dir-read.c
+++ b/xlators/cluster/afr/src/afr-dir-read.c
@@ -8,349 +8,339 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
-#include <fnmatch.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <string.h>
 
-#include "glusterfs.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
-#include "checksum.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/dict.h>
+#include <glusterfs/list.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
 
 #include "afr.h"
 #include "afr-transaction.h"
 
-
 int32_t
-afr_opendir_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno,
-                 fd_t *fd, dict_t *xdata)
+afr_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t   *local             = NULL;
-        int            call_count        = -1;
-        int32_t        child_index       = 0;
-	afr_fd_ctx_t  *fd_ctx = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-        child_index = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                } else {
-                        local->op_ret = op_ret;
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-                }
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int32_t child_index = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+    child_index = (long)cookie;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+        } else {
+            local->op_ret = op_ret;
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        UNLOCK (&frame->lock);
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    if (call_count == 0) {
+        afr_handle_replies_quorum(frame, this);
+        AFR_STACK_UNWIND(opendir, frame, local->op_ret, local->op_errno,
+                         local->fd, NULL);
+    }
 
-        if (call_count == 0)
-		AFR_STACK_UNWIND (opendir, frame, local->op_ret,
-				  local->op_errno, local->fd, NULL);
-        return 0;
+    return 0;
 }
 
-
 int
-afr_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd)
+afr_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+            dict_t *xdata)
 {
-        afr_private_t * priv        = NULL;
-        afr_local_t   * local       = NULL;
-        int             i           = 0;
-        int             call_count  = -1;
-        int32_t         op_errno    = ENOMEM;
-	afr_fd_ctx_t *fd_ctx = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = -1;
+    int32_t op_errno = ENOMEM;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_OPENDIR;
-        if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
+    local->op = GF_FOP_OPENDIR;
 
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		goto out;
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this, NULL)) {
+        op_errno = afr_quorum_errno(priv);
+        goto out;
+    }
 
-        loc_copy (&local->loc, loc);
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
 
-        local->fd    = fd_ref (fd);
-	local->fd_ctx = fd_ctx;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
+        goto out;
 
-        call_count = local->call_count;
+    loc_copy(&local->loc, loc);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_opendir_cbk,
-                                           (void*) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->opendir,
-                                           loc, fd, NULL);
+    local->fd = fd_ref(fd);
+    local->fd_ctx = fd_ctx;
 
-                        if (!--call_count)
-                                break;
-                }
+    call_count = local->call_count;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, afr_opendir_cbk, (void *)(long)i,
+                              priv->children[i],
+                              priv->children[i]->fops->opendir, loc, fd, NULL);
+
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (opendir, frame, -1, op_errno, fd, NULL);
-        return 0;
+    AFR_STACK_UNWIND(opendir, frame, -1, op_errno, fd, NULL);
+    return 0;
 }
 
 static int
-afr_validate_read_subvol (inode_t *inode, xlator_t *this, int par_read_subvol)
+afr_validate_read_subvol(inode_t *inode, xlator_t *this, int par_read_subvol)
 {
-	int             gen               = 0;
-        int             entry_read_subvol = 0;
-	unsigned char  *data_readable     = NULL;
-	unsigned char  *metadata_readable = NULL;
-        afr_private_t  *priv              = NULL;
-
-        priv = this->private;
-	data_readable = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-
-	afr_inode_read_subvol_get (inode, this, data_readable,
-				   metadata_readable, &gen);
-
-        if (gen != priv->event_generation ||
-                !data_readable[par_read_subvol] ||
-                !metadata_readable[par_read_subvol])
-                return -1;
-
-        /* Once the control reaches the following statement, it means that the
-         * parent's read subvol is perfectly readable. So calling
-         * either afr_data_subvol_get() or afr_metadata_subvol_get() would
-         * yield the same result. Hence, choosing afr_data_subvol_get() below.
-         */
-
-        if (!priv->consistent_metadata)
-                return 0;
-
-        /* For an inode fetched through readdirp which is yet to be linked,
-         * inode ctx would not be initialised (yet). So this function returns
-         * -1 above due to gen being 0, which is why it is OK to pass NULL for
-         *  read_subvol_args here.
-         */
-        entry_read_subvol = afr_data_subvol_get (inode, this, NULL, NULL,
-                                                 NULL, NULL);
-        if (entry_read_subvol != par_read_subvol)
-                return -1;
-
+    int gen = 0;
+    int entry_read_subvol = 0;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(inode, this, data_readable, metadata_readable,
+                              &gen);
+
+    if (gen != priv->event_generation || !data_readable[par_read_subvol] ||
+        !metadata_readable[par_read_subvol])
+        return -1;
+
+    /* Once the control reaches the following statement, it means that the
+     * parent's read subvol is perfectly readable. So calling
+     * either afr_data_subvol_get() or afr_metadata_subvol_get() would
+     * yield the same result. Hence, choosing afr_data_subvol_get() below.
+     */
+
+    if (!priv->consistent_metadata)
         return 0;
 
+    /* For an inode fetched through readdirp which is yet to be linked,
+     * inode ctx would not be initialised (yet). So this function returns
+     * -1 above due to gen being 0, which is why it is OK to pass NULL for
+     *  read_subvol_args here.
+     */
+    entry_read_subvol = afr_data_subvol_get(inode, this, NULL, NULL, NULL,
+                                            NULL);
+    if (entry_read_subvol != par_read_subvol)
+        return -1;
+
+    return 0;
 }
 
 static void
-afr_readdir_transform_entries (gf_dirent_t *subvol_entries, int subvol,
-			       gf_dirent_t *entries, fd_t *fd)
+afr_readdir_transform_entries(call_frame_t *frame, gf_dirent_t *subvol_entries,
+                              int subvol, gf_dirent_t *entries, fd_t *fd)
 {
-        int            ret   = -1;
-        gf_dirent_t   *entry = NULL;
-        gf_dirent_t   *tmp   = NULL;
-        xlator_t      *this  = NULL;
-        afr_private_t *priv  = NULL;
-        gf_boolean_t  need_heal = _gf_false;
-        gf_boolean_t  validate_subvol = _gf_false;
-
-        this = THIS;
-        priv = this->private;
-
-        need_heal = afr_get_need_heal (this);
-        validate_subvol = need_heal | priv->consistent_metadata;
-
-        list_for_each_entry_safe (entry, tmp, &subvol_entries->list, list) {
-                if (__is_root_gfid (fd->inode->gfid) &&
-                    !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR)) {
-			continue;
-                }
-
-		list_del_init (&entry->list);
-		list_add_tail (&entry->list, &entries->list);
-
-                if (!validate_subvol)
-                        continue;
-
-		if (entry->inode) {
-                        ret = afr_validate_read_subvol (entry->inode, this,
-                                                        subvol);
-                        if (ret == -1) {
-				inode_unref (entry->inode);
-				entry->inode = NULL;
-                                continue;
-			}
-		}
+    int ret = -1;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    xlator_t *this = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t need_heal = _gf_false;
+    gf_boolean_t validate_subvol = _gf_false;
+
+    this = THIS;
+    priv = this->private;
+
+    need_heal = afr_get_need_heal(this);
+    validate_subvol = need_heal | priv->consistent_metadata;
+
+    list_for_each_entry_safe(entry, tmp, &subvol_entries->list, list)
+    {
+        if (afr_is_private_directory(priv, fd->inode->gfid, entry->d_name,
+                                     frame->root->pid)) {
+            continue;
         }
-}
 
+        list_del_init(&entry->list);
+        list_add_tail(&entry->list, &entries->list);
+
+        if (!validate_subvol)
+            continue;
+
+        if (entry->inode) {
+            ret = afr_validate_read_subvol(entry->inode, this, subvol);
+            if (ret == -1) {
+                inode_unref(entry->inode);
+                entry->inode = NULL;
+                continue;
+            }
+        }
+    }
+}
 
 int32_t
-afr_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		 int32_t op_ret, int32_t op_errno, gf_dirent_t *subvol_entries,
-		 dict_t *xdata)
+afr_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, gf_dirent_t *subvol_entries,
+                dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	gf_dirent_t  entries;
+    afr_local_t *local = NULL;
+    gf_dirent_t entries;
 
-	INIT_LIST_HEAD (&entries.list);
+    INIT_LIST_HEAD(&entries.list);
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0 && !local->cont.readdir.offset) {
-		/* failover only if this was first readdir, detected
-		   by offset == 0 */
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0 && !local->cont.readdir.offset) {
+        /* failover only if this was first readdir, detected
+           by offset == 0 */
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (op_ret >= 0)
-		afr_readdir_transform_entries (subvol_entries, (long) cookie,
-					       &entries, local->fd);
+    if (op_ret >= 0)
+        afr_readdir_transform_entries(frame, subvol_entries, (long)cookie,
+                                      &entries, local->fd);
 
-        AFR_STACK_UNWIND (readdir, frame, op_ret, op_errno, &entries, xdata);
+    AFR_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, xdata);
 
-        gf_dirent_free (&entries);
+    gf_dirent_free(&entries);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_readdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-	priv = this->private;
-	local = frame->local;
-	fd_ctx = afr_fd_ctx_get (local->fd, this);
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (readdir, frame, local->op_ret,
-				  local->op_errno, 0, 0);
-		return 0;
-	}
-
-	fd_ctx->readdir_subvol = subvol;
-
-        if (local->op == GF_FOP_READDIR)
-                STACK_WIND_COOKIE (frame, afr_readdir_cbk,
-                                   (void *) (long) subvol,
-                                   priv->children[subvol],
-                                   priv->children[subvol]->fops->readdir,
-				   local->fd, local->cont.readdir.size,
-                                   local->cont.readdir.offset,
-				   local->xdata_req);
-        else
-                STACK_WIND_COOKIE (frame, afr_readdir_cbk,
-                                   (void *) (long) subvol,
-                                   priv->children[subvol],
-                                   priv->children[subvol]->fops->readdirp,
-				   local->fd, local->cont.readdir.size,
-				   local->cont.readdir.offset,
-				   local->xdata_req);
-	return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    priv = this->private;
+    local = frame->local;
+    fd_ctx = afr_fd_ctx_get(local->fd, this);
+    if (!fd_ctx) {
+        local->op_errno = EINVAL;
+        local->op_ret = -1;
+    }
+
+    if (subvol == -1 || !fd_ctx) {
+        AFR_STACK_UNWIND(readdir, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
+
+    fd_ctx->readdir_subvol = subvol;
+
+    if (local->op == GF_FOP_READDIR)
+        STACK_WIND_COOKIE(frame, afr_readdir_cbk, (void *)(long)subvol,
+                          priv->children[subvol],
+                          priv->children[subvol]->fops->readdir, local->fd,
+                          local->cont.readdir.size, local->cont.readdir.offset,
+                          local->xdata_req);
+    else
+        STACK_WIND_COOKIE(frame, afr_readdir_cbk, (void *)(long)subvol,
+                          priv->children[subvol],
+                          priv->children[subvol]->fops->readdirp, local->fd,
+                          local->cont.readdir.size, local->cont.readdir.offset,
+                          local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-		off_t offset, int whichop, dict_t *dict)
+afr_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t offset, int whichop, dict_t *dict)
 {
-        afr_local_t   *local     = NULL;
-        int32_t       op_errno   = 0;
-	int           subvol = -1;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx) {
-	        op_errno = EINVAL;
-		goto out;
-        }
-
-	local->op = whichop;
-        local->fd = fd_ref (fd);
-        local->cont.readdir.size = size;
-	local->cont.readdir.offset = offset;
-        local->xdata_req = (dict)? dict_ref (dict) : NULL;
-
-	subvol = fd_ctx->readdir_subvol;
-
-	if (offset == 0 || subvol == -1) {
-		/* First readdir has option of failing over and selecting
-		   an appropriate read subvolume */
-		afr_read_txn (frame, this, fd->inode, afr_readdir_wind,
-			      AFR_DATA_TRANSACTION);
-	} else {
-		/* But continued readdirs MUST stick to the same subvolume
-		   without an option to failover */
-		afr_readdir_wind (frame, this, subvol);
-	}
-
-        return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    int subvol = -1;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    local->op = whichop;
+    local->fd = fd_ref(fd);
+    local->cont.readdir.size = size;
+    local->cont.readdir.offset = offset;
+    local->xdata_req = (dict) ? dict_ref(dict) : NULL;
+
+    subvol = fd_ctx->readdir_subvol;
+
+    if (offset == 0 || subvol == -1) {
+        /* First readdir has option of failing over and selecting
+           an appropriate read subvolume */
+        afr_read_txn(frame, this, fd->inode, afr_readdir_wind,
+                     AFR_DATA_TRANSACTION);
+    } else {
+        /* But continued readdirs MUST stick to the same subvolume
+           without an option to failover */
+        afr_readdir_wind(frame, this, subvol);
+    }
+
+    return 0;
 out:
-        AFR_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-afr_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, dict_t *xdata)
+afr_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t offset, dict_t *xdata)
 {
-	afr_do_readdir (frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
+    afr_do_readdir(frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t offset, dict_t *dict)
+afr_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t offset, dict_t *dict)
 {
-        afr_do_readdir (frame, this, fd, size, offset, GF_FOP_READDIRP, dict);
+    afr_do_readdir(frame, this, fd, size, offset, GF_FOP_READDIRP, dict);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_releasedir (xlator_t *this, fd_t *fd)
+afr_releasedir(xlator_t *this, fd_t *fd)
 {
-        afr_cleanup_fd_ctx (this, fd);
+    afr_cleanup_fd_ctx(this, fd);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-dir-read.h b/xlators/cluster/afr/src/afr-dir-read.h
index 09456d15949..773e925ec6c 100644
--- a/xlators/cluster/afr/src/afr-dir-read.h
+++ b/xlators/cluster/afr/src/afr-dir-read.h
@@ -11,26 +11,23 @@
 #ifndef __DIR_READ_H__
 #define __DIR_READ_H__
 
-
 int32_t
-afr_opendir (call_frame_t *frame, xlator_t *this,
-	     loc_t *loc, fd_t *fd, dict_t *xdata);
+afr_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+            dict_t *xdata);
 
 int32_t
-afr_releasedir (xlator_t *this, fd_t *fd);
+afr_releasedir(xlator_t *this, fd_t *fd);
 
 int32_t
-afr_readdir (call_frame_t *frame, xlator_t *this,
-	     fd_t *fd, size_t size, off_t offset, dict_t *xdata);
-
+afr_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t offset, dict_t *xdata);
 
 int32_t
-afr_readdirp (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, size_t size, off_t offset, dict_t *dict);
+afr_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t offset, dict_t *dict);
 
 int32_t
-afr_checksum (call_frame_t *frame, xlator_t *this,
-	      loc_t *loc, int32_t flags, dict_t *xdata);
-
+afr_checksum(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             dict_t *xdata);
 
 #endif /* __DIR_READ_H__ */
diff --git a/xlators/cluster/afr/src/afr-dir-write.c b/xlators/cluster/afr/src/afr-dir-write.c
index 9099b8c1eee..b7cceb79158 100644
--- a/xlators/cluster/afr/src/afr-dir-write.c
+++ b/xlators/cluster/afr/src/afr-dir-write.c
@@ -8,530 +8,493 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
-#include <fnmatch.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "afr.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
-#include "byte-order.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/list.h>
+#include <glusterfs/defaults.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/byte-order.h>
 
 #include "afr.h"
 #include "afr-transaction.h"
 
 void
-afr_mark_entry_pending_changelog (call_frame_t *frame, xlator_t *this);
+afr_mark_entry_pending_changelog(call_frame_t *frame, xlator_t *this);
 
 int
-afr_build_parent_loc (loc_t *parent, loc_t *child, int32_t *op_errno)
+afr_build_parent_loc(loc_t *parent, loc_t *child, int32_t *op_errno)
 {
-        int     ret = -1;
-        char    *child_path = NULL;
-
-        if (!child->parent) {
-                if (op_errno)
-                        *op_errno = EINVAL;
-                goto out;
-        }
-
-        child_path = gf_strdup (child->path);
-        if (!child_path) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
-
-        parent->path = gf_strdup (dirname (child_path));
-        if (!parent->path) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
-
-        parent->inode = inode_ref (child->parent);
-	gf_uuid_copy (parent->gfid, child->pargfid);
-
-        ret = 0;
+    int ret = -1;
+    char *child_path = NULL;
+
+    if (!child->parent) {
+        if (op_errno)
+            *op_errno = EINVAL;
+        goto out;
+    }
+
+    child_path = gf_strdup(child->path);
+    if (!child_path) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    parent->path = gf_strdup(dirname(child_path));
+    if (!parent->path) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    parent->inode = inode_ref(child->parent);
+    gf_uuid_copy(parent->gfid, child->pargfid);
+
+    ret = 0;
 out:
-        GF_FREE (child_path);
+    GF_FREE(child_path);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__afr_dir_write_finalize (call_frame_t *frame, xlator_t *this)
+__afr_dir_write_finalize(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int inode_read_subvol = -1;
-	int parent_read_subvol = -1;
-	int parent2_read_subvol = -1;
-	int i = 0;
-        afr_read_subvol_args_t args = {0,};
-
-	local = frame->local;
-	priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-	        if (!local->replies[i].valid)
-	                continue;
-	        if (local->replies[i].op_ret == -1)
-	                continue;
-                gf_uuid_copy (args.gfid, local->replies[i].poststat.ia_gfid);
-                args.ia_type = local->replies[i].poststat.ia_type;
-                break;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int inode_read_subvol = -1;
+    int parent_read_subvol = -1;
+    int parent2_read_subvol = -1;
+    int i = 0;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret == -1)
+            continue;
+        gf_uuid_copy(args.gfid, local->replies[i].poststat.ia_gfid);
+        args.ia_type = local->replies[i].poststat.ia_type;
+        break;
+    }
+
+    if (local->inode) {
+        if (local->op != GF_FOP_RENAME && local->op != GF_FOP_LINK)
+            afr_replies_interpret(frame, this, local->inode, NULL);
+
+        inode_read_subvol = afr_data_subvol_get(local->inode, this, NULL, NULL,
+                                                NULL, &args);
+    }
+
+    if (local->parent)
+        parent_read_subvol = afr_data_subvol_get(local->parent, this, NULL,
+                                                 local->readable, NULL, NULL);
+
+    if (local->parent2)
+        parent2_read_subvol = afr_data_subvol_get(local->parent2, this, NULL,
+                                                  local->readable2, NULL, NULL);
+
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    afr_pick_error_xdata(local, priv, local->parent, local->readable,
+                         local->parent2, local->readable2);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0) {
+            if (local->inode)
+                afr_inode_need_refresh_set(local->inode, this);
+            if (local->parent)
+                afr_inode_need_refresh_set(local->parent, this);
+            if (local->parent2)
+                afr_inode_need_refresh_set(local->parent2, this);
+            continue;
         }
 
-	if (local->inode) {
-		afr_replies_interpret (frame, this, local->inode, NULL);
-		inode_read_subvol = afr_data_subvol_get (local->inode, this,
-                                                       NULL, NULL, NULL, &args);
-	}
-
-	if (local->parent)
-		parent_read_subvol = afr_data_subvol_get (local->parent, this,
-                                             NULL, local->readable, NULL, NULL);
-
-	if (local->parent2)
-		parent2_read_subvol = afr_data_subvol_get (local->parent2, this,
-                                            NULL, local->readable2, NULL, NULL);
-
-	local->op_ret = -1;
-	local->op_errno = afr_final_errno (local, priv);
-        afr_pick_error_xdata (local, priv, local->parent, local->readable,
-                              local->parent2, local->readable2);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret < 0) {
-			if (local->inode)
-				afr_inode_event_gen_reset (local->inode, this);
-			if (local->parent)
-				afr_inode_event_gen_reset (local->parent,
-							     this);
-			if (local->parent2)
-				afr_inode_event_gen_reset (local->parent2,
-							     this);
-			continue;
-		}
-
-		if (local->op_ret == -1) {
-			local->op_ret = local->replies[i].op_ret;
-			local->op_errno = local->replies[i].op_errno;
-
-			local->cont.dir_fop.buf =
-				local->replies[i].poststat;
-			local->cont.dir_fop.preparent =
-				local->replies[i].preparent;
-			local->cont.dir_fop.postparent =
-				local->replies[i].postparent;
-			local->cont.dir_fop.prenewparent =
-				local->replies[i].preparent2;
-			local->cont.dir_fop.postnewparent =
-				local->replies[i].postparent2;
-                        if (local->xdata_rsp) {
-                                dict_unref (local->xdata_rsp);
-                                local->xdata_rsp = NULL;
-                        }
-
-			if (local->replies[i].xdata)
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			continue;
-		}
-
-		if (i == inode_read_subvol) {
-			local->cont.dir_fop.buf =
-				local->replies[i].poststat;
-			if (local->replies[i].xdata) {
-				if (local->xdata_rsp)
-					dict_unref (local->xdata_rsp);
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			}
-		}
-
-		if (i == parent_read_subvol) {
-			local->cont.dir_fop.preparent =
-				local->replies[i].preparent;
-			local->cont.dir_fop.postparent =
-				local->replies[i].postparent;
-		}
-
-		if (i == parent2_read_subvol) {
-			local->cont.dir_fop.prenewparent =
-				local->replies[i].preparent2;
-			local->cont.dir_fop.postnewparent =
-				local->replies[i].postparent2;
-		}
-	}
+        if (local->op_ret == -1) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+
+            local->cont.dir_fop.buf = local->replies[i].poststat;
+            local->cont.dir_fop.preparent = local->replies[i].preparent;
+            local->cont.dir_fop.postparent = local->replies[i].postparent;
+            local->cont.dir_fop.prenewparent = local->replies[i].preparent2;
+            local->cont.dir_fop.postnewparent = local->replies[i].postparent2;
+            if (local->xdata_rsp) {
+                dict_unref(local->xdata_rsp);
+                local->xdata_rsp = NULL;
+            }
+
+            if (local->replies[i].xdata)
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            continue;
+        }
 
-}
+        if (i == inode_read_subvol) {
+            local->cont.dir_fop.buf = local->replies[i].poststat;
+            if (local->replies[i].xdata) {
+                if (local->xdata_rsp)
+                    dict_unref(local->xdata_rsp);
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+        }
 
+        if (i == parent_read_subvol) {
+            local->cont.dir_fop.preparent = local->replies[i].preparent;
+            local->cont.dir_fop.postparent = local->replies[i].postparent;
+        }
+
+        if (i == parent2_read_subvol) {
+            local->cont.dir_fop.prenewparent = local->replies[i].preparent2;
+            local->cont.dir_fop.postnewparent = local->replies[i].postparent2;
+        }
+    }
+}
 
 static void
-__afr_dir_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
-		      int op_ret, int op_errno, struct iatt *poststat,
-		      struct iatt *preparent, struct iatt *postparent,
-		      struct iatt *preparent2, struct iatt *postparent2,
-		      dict_t *xdata)
+__afr_dir_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
+                     int op_ret, int op_errno, struct iatt *poststat,
+                     struct iatt *preparent, struct iatt *postparent,
+                     struct iatt *preparent2, struct iatt *postparent2,
+                     dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
-
-
-	if (op_ret >= 0) {
-		if (poststat)
-			local->replies[child_index].poststat = *poststat;
-		if (preparent)
-			local->replies[child_index].preparent = *preparent;
-		if (postparent)
-			local->replies[child_index].postparent = *postparent;
-		if (preparent2)
-			local->replies[child_index].preparent2 = *preparent2;
-		if (postparent2)
-			local->replies[child_index].postparent2 = *postparent2;
-		if (fd_ctx)
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-	} else {
-		if (op_errno != ENOTEMPTY)
-			afr_transaction_fop_failed (frame, this, child_index);
-		if (fd_ctx)
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-	}
-
-        return;
+    afr_local_t *local = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        if (poststat)
+            local->replies[child_index].poststat = *poststat;
+        if (preparent)
+            local->replies[child_index].preparent = *preparent;
+        if (postparent)
+            local->replies[child_index].postparent = *postparent;
+        if (preparent2)
+            local->replies[child_index].preparent2 = *preparent2;
+        if (postparent2)
+            local->replies[child_index].postparent2 = *postparent2;
+        if (fd_ctx)
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+    } else {
+        if (op_errno != ENOTEMPTY)
+            afr_transaction_fop_failed(frame, this, child_index);
+        if (fd_ctx)
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+    }
+
+    return;
 }
 
-
 static int
-__afr_dir_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		     int op_ret, int op_errno, struct iatt *buf,
-		     struct iatt *preparent, struct iatt *postparent,
-		     struct iatt *preparent2, struct iatt *postparent2,
-                     dict_t *xdata)
+__afr_dir_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iatt *buf,
+                    struct iatt *preparent, struct iatt *postparent,
+                    struct iatt *preparent2, struct iatt *postparent2,
+                    dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_private_t *priv = NULL;
-
-        priv  = this->private;
-        local = frame->local;
-
-	LOCK (&frame->lock);
-	{
-		__afr_dir_write_fill (frame, this, child_index, op_ret,
-				      op_errno, buf, preparent, postparent,
-				      preparent2, postparent2, xdata);
-	}
-	UNLOCK (&frame->lock);
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-		__afr_dir_write_finalize (frame, this);
-
-		if (afr_txn_nothing_failed (frame, this)) {
-                        /*if it did pre-op, it will do post-op changing ctime*/
-                        if (priv->consistent_metadata &&
-                            afr_needs_changelog_update (local))
-                                afr_zero_fill_stat (local);
-                        local->transaction.unwind (frame, this);
-                }
-
-		afr_mark_entry_pending_changelog (frame, this);
-
-                local->transaction.resume (frame, this);
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    LOCK(&frame->lock);
+    {
+        __afr_dir_write_fill(frame, this, child_index, op_ret, op_errno, buf,
+                             preparent, postparent, preparent2, postparent2,
+                             xdata);
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        __afr_dir_write_finalize(frame, this);
+
+        if (afr_txn_nothing_failed(frame, this)) {
+            /*if it did pre-op, it will do post-op changing ctime*/
+            if (priv->consistent_metadata && afr_needs_changelog_update(local))
+                afr_zero_fill_stat(local);
+            local->transaction.unwind(frame, this);
         }
 
-        return 0;
-}
+        afr_mark_entry_pending_changelog(frame, this);
+
+        afr_transaction_resume(frame, this);
+    }
 
+    return 0;
+}
 
 int
-afr_mark_new_entry_changelog_cbk (call_frame_t *frame, void *cookie,
-				  xlator_t *this, int op_ret, int op_errno,
-                                  dict_t *xattr, dict_t *xdata)
+afr_mark_new_entry_changelog_cbk(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int op_ret, int op_errno,
+                                 dict_t *xattr, dict_t *xdata)
 {
-        int call_count = 0;
+    int call_count = 0;
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-                AFR_STACK_DESTROY (frame);
+    if (call_count == 0)
+        AFR_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 void
-afr_mark_new_entry_changelog (call_frame_t *frame, xlator_t *this)
+afr_mark_new_entry_changelog(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t  *new_frame  = NULL;
-        afr_local_t   *local      = NULL;
-        afr_local_t   *new_local  = NULL;
-        afr_private_t *priv       = NULL;
-        dict_t        *xattr      = NULL;
-        int32_t       **changelog = NULL;
-        int           i           = 0;
-        int           op_errno    = ENOMEM;
-	unsigned char *pending    = NULL;
-	int           call_count   = 0;
-
-        local = frame->local;
-        priv = this->private;
-
-        new_frame = copy_frame (frame);
-        if (!new_frame)
-                goto out;
-
-	new_local = AFR_FRAME_INIT (new_frame, op_errno);
-	if (!new_local)
-		goto out;
-
-        xattr = dict_new ();
-	if (!xattr)
-		goto out;
-
-	pending = alloca0 (priv->child_count);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->transaction.pre_op[i] &&
-		    !local->transaction.failed_subvols[i]) {
-			call_count ++;
-			continue;
-		}
-		pending[i] = 1;
-	}
-
-        changelog = afr_mark_pending_changelog (priv, pending, xattr,
-                                            local->cont.dir_fop.buf.ia_type);
-        if (!changelog)
-                goto out;
-
-        new_local->pending = changelog;
-        gf_uuid_copy (new_local->loc.gfid, local->cont.dir_fop.buf.ia_gfid);
-        new_local->loc.inode = inode_ref (local->inode);
-
-        new_local->call_count = call_count;
-
-        for (i = 0; i < priv->child_count; i++) {
-		if (pending[i])
-                        continue;
-
-                STACK_WIND_COOKIE (new_frame, afr_mark_new_entry_changelog_cbk,
-                                   (void *) (long) i, priv->children[i],
-                                   priv->children[i]->fops->xattrop,
-                                   &new_local->loc, GF_XATTROP_ADD_ARRAY,
-                                   xattr, NULL);
-		if (!--call_count)
-			break;
+    call_frame_t *new_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_local_t *new_local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int32_t **changelog = NULL;
+    int i = 0;
+    int op_errno = ENOMEM;
+    unsigned char *pending = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    new_frame = copy_frame(frame);
+    if (!new_frame)
+        goto out;
+
+    new_local = AFR_FRAME_INIT(new_frame, op_errno);
+    if (!new_local)
+        goto out;
+
+    xattr = dict_new();
+    if (!xattr)
+        goto out;
+
+    pending = alloca0(priv->child_count);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] &&
+            !local->transaction.failed_subvols[i]) {
+            call_count++;
+            continue;
         }
+        pending[i] = 1;
+    }
+
+    changelog = afr_mark_pending_changelog(priv, pending, xattr,
+                                           local->cont.dir_fop.buf.ia_type);
+    if (!changelog)
+        goto out;
+
+    new_local->pending = changelog;
+    gf_uuid_copy(new_local->loc.gfid, local->cont.dir_fop.buf.ia_gfid);
+    new_local->loc.inode = inode_ref(local->inode);
 
-        new_frame = NULL;
+    new_local->call_count = call_count;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (pending[i])
+            continue;
+
+        STACK_WIND_COOKIE(new_frame, afr_mark_new_entry_changelog_cbk,
+                          (void *)(long)i, priv->children[i],
+                          priv->children[i]->fops->xattrop, &new_local->loc,
+                          GF_XATTROP_ADD_ARRAY, xattr, NULL);
+        if (!--call_count)
+            break;
+    }
+
+    new_frame = NULL;
 out:
-        if (new_frame)
-                AFR_STACK_DESTROY (new_frame);
-	if (xattr)
-		dict_unref (xattr);
-        return;
+    if (new_frame)
+        AFR_STACK_DESTROY(new_frame);
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
-
 void
-afr_mark_entry_pending_changelog (call_frame_t *frame, xlator_t *this)
+afr_mark_entry_pending_changelog(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-	int pre_op_count = 0;
-	int failed_count = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int pre_op_count = 0;
+    int failed_count = 0;
+    unsigned char *success_replies = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        if (local->op_ret < 0)
-		return;
+    if (local->op_ret < 0)
+        return;
 
-	if (local->op != GF_FOP_CREATE && local->op != GF_FOP_MKNOD &&
-            local->op != GF_FOP_MKDIR)
-		return;
+    if (local->op != GF_FOP_CREATE && local->op != GF_FOP_MKNOD &&
+        local->op != GF_FOP_MKDIR)
+        return;
 
-	pre_op_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
-	failed_count = AFR_COUNT (local->transaction.failed_subvols,
-				  priv->child_count);
+    pre_op_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
+    failed_count = AFR_COUNT(local->transaction.failed_subvols,
+                             priv->child_count);
 
-	if (pre_op_count == priv->child_count && !failed_count)
-		return;
+    /* FOP succeeded on all bricks. */
+    if (pre_op_count == priv->child_count && !failed_count)
+        return;
 
-        afr_mark_new_entry_changelog (frame, this);
+    /* FOP did not suceed on quorum no. of bricks. */
+    success_replies = alloca0(priv->child_count);
+    afr_fill_success_replies(local, priv, success_replies);
+    if (!afr_has_quorum(success_replies, this, NULL))
+        return;
 
+    if (priv->thin_arbiter_count) {
+        /*Mark new entry using ta file*/
+        local->is_new_entry = _gf_true;
         return;
-}
+    }
 
+    afr_mark_new_entry_changelog(frame, this);
+
+    return;
+}
 
 /* {{{ create */
 
 int
-afr_create_unwind (call_frame_t *frame, xlator_t *this)
+afr_create_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
+    local = frame->local;
 
-        if (!main_frame)
-		return 0;
+    main_frame = afr_transaction_detach_fop_frame(frame);
 
-	AFR_STACK_UNWIND (create, main_frame, local->op_ret, local->op_errno,
-			  local->cont.create.fd, local->inode,
-			  &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(create, main_frame, local->op_ret, local->op_errno,
+                     local->cont.create.fd, local->inode,
+                     &local->cont.dir_fop.buf, &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_create_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+afr_create_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_create_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_create_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_create_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->create,
-			   &local->loc, local->cont.create.flags,
-			   local->cont.create.mode, local->umask,
-			   local->cont.create.fd, local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_create_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->create, &local->loc,
+                      local->cont.create.flags, local->cont.create.mode,
+                      local->umask, local->cont.create.fd, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-	    mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+afr_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-
-	local->fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!local->fd_ctx)
-		goto out;
-
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->op                = GF_FOP_CREATE;
-        local->cont.create.flags = flags;
-        local->fd_ctx->flags     = flags;
-        local->cont.create.mode  = mode;
-        local->cont.create.fd    = fd_ref (fd);
-        local->umask  = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->transaction.wind   = afr_create_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_create_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-            op_errno = -ret;
-            goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+
+    local->fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!local->fd_ctx)
+        goto out;
+
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->op = GF_FOP_CREATE;
+    local->cont.create.flags = flags;
+    local->fd_ctx->flags = flags;
+    local->cont.create.mode = mode;
+    local->cont.create.fd = fd_ref(fd);
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->transaction.wind = afr_create_wind;
+    local->transaction.unwind = afr_create_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -539,524 +502,436 @@ out:
 /* {{{ mknod */
 
 int
-afr_mknod_unwind (call_frame_t *frame, xlator_t *this)
+afr_mknod_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (mknod, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(mknod, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_mknod_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_mknod_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-	return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_mknod_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_mknod_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv  = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_mknod_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->mknod,
-			   &local->loc, local->cont.mknod.mode,
-			   local->cont.mknod.dev, local->umask,
-			   local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_mknod_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->mknod, &local->loc,
+                      local->cont.mknod.mode, local->cont.mknod.dev,
+                      local->umask, local->xdata_req);
+    return 0;
 }
 
 int
-afr_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-           dev_t dev, mode_t umask, dict_t *xdata)
+afr_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t dev, mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->op               = GF_FOP_MKNOD;
-        local->cont.mknod.mode  = mode;
-        local->cont.mknod.dev   = dev;
-        local->umask = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->transaction.wind   = afr_mknod_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_mknod_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->op = GF_FOP_MKNOD;
+    local->cont.mknod.mode = mode;
+    local->cont.mknod.dev = dev;
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->transaction.wind = afr_mknod_wind;
+    local->transaction.unwind = afr_mknod_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ mkdir */
 
-
 int
-afr_mkdir_unwind (call_frame_t *frame, xlator_t *this)
+afr_mkdir_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (mkdir, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(mkdir, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_mkdir_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_mkdir_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-	return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_mkdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_mkdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_mkdir_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->mkdir, &local->loc,
-			   local->cont.mkdir.mode, local->umask,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_mkdir_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->mkdir, &local->loc,
+                      local->cont.mkdir.mode, local->umask, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-	   mode_t umask, dict_t *xdata)
+afr_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.mkdir.mode  = mode;
-        local->umask = umask;
-
-        if (!xdata || !dict_get (xdata, "gfid-req")) {
-                op_errno = EPERM;
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, op_errno,
-                                  AFR_MSG_GFID_NULL, "mkdir: %s is received "
-                                  "without gfid-req %p", loc->path, xdata);
-	        goto out;
-        }
-
-        local->xdata_req = dict_copy_with_ref (xdata, NULL);
-        if (!local->xdata_req) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        local->op = GF_FOP_MKDIR;
-        local->transaction.wind   = afr_mkdir_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_mkdir_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.mkdir.mode = mode;
+    local->umask = umask;
+
+    if (!xdata || !dict_get_sizen(xdata, "gfid-req")) {
+        op_errno = EPERM;
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, op_errno,
+                         AFR_MSG_GFID_NULL,
+                         "mkdir: %s is received "
+                         "without gfid-req %p",
+                         loc->path, xdata);
+        goto out;
+    }
+
+    local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    if (!local->xdata_req) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->op = GF_FOP_MKDIR;
+    local->transaction.wind = afr_mkdir_wind;
+    local->transaction.unwind = afr_mkdir_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ link */
 
-
 int
-afr_link_unwind (call_frame_t *frame, xlator_t *this)
+afr_link_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (link, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(link, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_link_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+afr_link_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_link_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_link_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_link_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->link,
-			   &local->loc, &local->newloc, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_link_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->link, &local->loc,
+                      &local->newloc, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-	  dict_t *xdata)
+afr_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc,    oldloc);
-        loc_copy (&local->newloc, newloc);
-
-	local->inode = inode_ref (oldloc->inode);
-	local->parent = inode_ref (newloc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_LINK;
-
-        local->transaction.wind   = afr_link_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_link_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, newloc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (newloc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, oldloc);
+    loc_copy(&local->newloc, newloc);
 
-	return 0;
+    local->inode = inode_ref(oldloc->inode);
+    local->parent = inode_ref(newloc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_LINK;
+
+    local->transaction.wind = afr_link_wind;
+    local->transaction.unwind = afr_link_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, newloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(newloc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ symlink */
 
-
 int
-afr_symlink_unwind (call_frame_t *frame, xlator_t *this)
+afr_symlink_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (symlink, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(symlink, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_symlink_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, inode_t *inode,
-                      struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata)
+afr_symlink_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, inode_t *inode,
+                     struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_symlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_symlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_symlink_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->symlink,
-			   local->cont.symlink.linkpath, &local->loc,
-			   local->umask, local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_symlink_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->symlink,
+                      local->cont.symlink.linkpath, &local->loc, local->umask,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-	     loc_t *loc, mode_t umask, dict_t *xdata)
+afr_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+            loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.symlink.linkpath = gf_strdup (linkpath);
-        local->umask = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_SYMLINK;
-        local->transaction.wind   = afr_symlink_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_symlink_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.symlink.linkpath = gf_strdup(linkpath);
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_SYMLINK;
+    local->transaction.wind = afr_symlink_wind;
+    local->transaction.unwind = afr_symlink_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(symlink, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -1064,161 +939,118 @@ out:
 /* {{{ rename */
 
 int
-afr_rename_unwind (call_frame_t *frame, xlator_t *this)
+afr_rename_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (rename, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent,
-			  &local->cont.dir_fop.prenewparent,
-			  &local->cont.dir_fop.postnewparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(rename, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.buf, &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent,
+                     &local->cont.dir_fop.prenewparent,
+                     &local->cont.dir_fop.postnewparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_rename_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-                     dict_t *xdata)
+afr_rename_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                    struct iatt *preoldparent, struct iatt *postoldparent,
+                    struct iatt *prenewparent, struct iatt *postnewparent,
+                    dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preoldparent, postoldparent, prenewparent,
-				    postnewparent, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preoldparent, postoldparent, prenewparent,
+                               postnewparent, xdata);
 }
 
-
 int
-afr_rename_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_rename_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_rename_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->rename,
-			   &local->loc, &local->newloc, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_rename_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->rename, &local->loc,
+                      &local->newloc, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-	    dict_t *xdata)
+afr_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-        int                     nlockee                 = 0;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc,    oldloc);
-        loc_copy (&local->newloc, newloc);
-
-	local->inode = inode_ref (oldloc->inode);
-	local->parent = inode_ref (oldloc->parent);
-	local->parent2 = inode_ref (newloc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_RENAME;
-        local->transaction.wind   = afr_rename_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_rename_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, oldloc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-        ret = afr_build_parent_loc (&local->transaction.new_parent_loc, newloc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (oldloc->path);
-        local->transaction.new_basename = AFR_BASENAME (newloc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = nlockee = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.new_parent_loc,
-                                     local->transaction.new_basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        if (local->newloc.inode && IA_ISDIR (local->newloc.inode->ia_type)) {
-                ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                             &local->newloc,
-                                             NULL,
-                                             priv->child_count);
-                if (ret)
-                        goto out;
-
-                nlockee++;
-        }
-        qsort (int_lock->lockee, nlockee, sizeof (*int_lock->lockee),
-               afr_entry_lockee_cmp);
-        int_lock->lockee_count = nlockee;
-
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_RENAME_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, oldloc);
+    loc_copy(&local->newloc, newloc);
+
+    local->inode = inode_ref(oldloc->inode);
+    local->parent = inode_ref(oldloc->parent);
+    local->parent2 = inode_ref(newloc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_RENAME;
+    local->transaction.wind = afr_rename_wind;
+    local->transaction.unwind = afr_rename_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, oldloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+    ret = afr_build_parent_loc(&local->transaction.new_parent_loc, newloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(oldloc->path);
+    local->transaction.new_basename = AFR_BASENAME(newloc->path);
+    ret = afr_transaction(transaction_frame, this,
+                          AFR_ENTRY_RENAME_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -1226,263 +1058,205 @@ out:
 /* {{{ unlink */
 
 int
-afr_unlink_unwind (call_frame_t *frame, xlator_t *this)
+afr_unlink_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (unlink, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(unlink, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_unlink_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+afr_unlink_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, NULL,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_unlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_unlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_unlink_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->unlink,
-			   &local->loc, local->xflag, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_unlink_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->unlink, &local->loc,
+                      local->xflag, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-	    dict_t *xdata)
+afr_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-        local->xflag = xflag;
-
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_UNLINK;
-        local->transaction.wind   = afr_unlink_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_unlink_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->xflag = xflag;
+
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_UNLINK;
+    local->transaction.wind = afr_unlink_wind;
+    local->transaction.unwind = afr_unlink_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ rmdir */
 
-
-
 int
-afr_rmdir_unwind (call_frame_t *frame, xlator_t *this)
+afr_rmdir_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (rmdir, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(rmdir, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_rmdir_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_rmdir_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, NULL,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_rmdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_rmdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_rmdir_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->rmdir,
-			   &local->loc, local->cont.rmdir.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_rmdir_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->rmdir, &local->loc,
+                      local->cont.rmdir.flags, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-	   dict_t *xdata)
+afr_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-        int                     nlockee                 = 0;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.rmdir.flags = flags;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_RMDIR;
-        local->transaction.wind   = afr_rmdir_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_rmdir_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = nlockee = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->loc,
-                                     NULL,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        qsort (int_lock->lockee, nlockee, sizeof (*int_lock->lockee),
-               afr_entry_lockee_cmp);
-        int_lock->lockee_count = nlockee;
-
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.rmdir.flags = flags;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_RMDIR;
+    local->transaction.wind = afr_rmdir_wind;
+    local->transaction.unwind = afr_rmdir_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
diff --git a/xlators/cluster/afr/src/afr-dir-write.h b/xlators/cluster/afr/src/afr-dir-write.h
index 02f0a3682d9..1d88c3b9b26 100644
--- a/xlators/cluster/afr/src/afr-dir-write.h
+++ b/xlators/cluster/afr/src/afr-dir-write.h
@@ -12,36 +12,35 @@
 #define __DIR_WRITE_H__
 
 int32_t
-afr_create (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, int32_t flags, mode_t mode,
-            mode_t umask, fd_t *fd, dict_t *xdata);
+afr_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata);
 
 int32_t
-afr_mknod (call_frame_t *frame, xlator_t *this,
-	   loc_t *loc, mode_t mode, dev_t dev, mode_t umask, dict_t *xdata);
+afr_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t dev, mode_t umask, dict_t *xdata);
 
 int32_t
-afr_mkdir (call_frame_t *frame, xlator_t *this,
-	   loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata);
+afr_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *xdata);
 
 int32_t
-afr_unlink (call_frame_t *frame, xlator_t *this,
-	    loc_t *loc, int xflag, dict_t *xdata);
+afr_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata);
 
 int32_t
-afr_rmdir (call_frame_t *frame, xlator_t *this,
-	   loc_t *loc, int flags, dict_t *xdata);
+afr_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata);
 
 int32_t
-afr_link (call_frame_t *frame, xlator_t *this,
-	  loc_t *oldloc, loc_t *newloc, dict_t *xdata);
+afr_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata);
 
 int32_t
-afr_rename (call_frame_t *frame, xlator_t *this,
-	    loc_t *oldloc, loc_t *newloc, dict_t *xdata);
+afr_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata);
 
 int
-afr_symlink (call_frame_t *frame, xlator_t *this,
-	     const char *linkpath, loc_t *oldloc, mode_t umask, dict_t *params);
+afr_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+            loc_t *oldloc, mode_t umask, dict_t *params);
 
 #endif /* __DIR_WRITE_H__ */
diff --git a/xlators/cluster/afr/src/afr-inode-read.c b/xlators/cluster/afr/src/afr-inode-read.c
index ecf94a523db..c5521704de2 100644
--- a/xlators/cluster/afr/src/afr-inode-read.c
+++ b/xlators/cluster/afr/src/afr-inode-read.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
 #include <fnmatch.h>
@@ -16,21 +15,17 @@
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "afr.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "byte-order.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
-#include "quota-common-utils.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/list.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/defaults.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/quota-common-utils.h>
 
 #include "afr-transaction.h"
 #include "afr-messages.h"
@@ -45,146 +40,146 @@
  * */
 
 int
-afr_handle_quota_size (call_frame_t *frame, xlator_t *this)
+afr_handle_quota_size(call_frame_t *frame, xlator_t *this)
 {
-        unsigned char *readable   = NULL;
-        afr_local_t *local        = NULL;
-        afr_private_t *priv       = NULL;
-        struct afr_reply *replies = NULL;
-        int i                     = 0;
-        int ret                   = 0;
-        quota_meta_t size         = {0, };
-        quota_meta_t max_size     = {0, };
-        int readable_cnt          = 0;
-        int read_subvol           = -1;
-
-        local = frame->local;
-        priv = this->private;
-        replies = local->replies;
-
-        readable = alloca0 (priv->child_count);
-
-        afr_inode_read_subvol_get (local->inode, this, readable, 0, 0);
-
-        readable_cnt = AFR_COUNT (readable, priv->child_count);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (readable_cnt && !readable[i])
-                        continue;
-                if (!replies[i].xdata)
-                        continue;
-                ret = quota_dict_get_meta (replies[i].xdata, QUOTA_SIZE_KEY,
-                                           &size);
-                if (ret == -1)
-                        continue;
-                if (read_subvol == -1)
-                        read_subvol = i;
-                if (size.size > max_size.size ||
-                    (size.file_count + size.dir_count) >
-                    (max_size.file_count + max_size.dir_count))
-                        read_subvol = i;
-
-                if (size.size > max_size.size)
-                        max_size.size = size.size;
-                if (size.file_count > max_size.file_count)
-                        max_size.file_count = size.file_count;
-                if (size.dir_count > max_size.dir_count)
-                        max_size.dir_count = size.dir_count;
-        }
-
-        if (max_size.size == 0 && max_size.file_count == 0 &&
-            max_size.dir_count == 0)
-                return read_subvol;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (readable_cnt && !readable[i])
-                        continue;
-                if (!replies[i].xdata)
-                        continue;
-                quota_dict_set_meta (replies[i].xdata, QUOTA_SIZE_KEY,
-                                     &max_size, IA_IFDIR);
-        }
-
+    unsigned char *readable = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0;
+    int ret = 0;
+    quota_meta_t size = {
+        0,
+    };
+    quota_meta_t max_size = {
+        0,
+    };
+    int readable_cnt = 0;
+    int read_subvol = -1;
+
+    local = frame->local;
+    priv = this->private;
+    replies = local->replies;
+
+    readable = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(local->inode, this, readable, 0, 0);
+
+    readable_cnt = AFR_COUNT(readable, priv->child_count);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (readable_cnt && !readable[i])
+            continue;
+        if (!replies[i].xdata)
+            continue;
+        ret = quota_dict_get_meta(replies[i].xdata, QUOTA_SIZE_KEY,
+                                  SLEN(QUOTA_SIZE_KEY), &size);
+        if (ret == -1)
+            continue;
+        if (read_subvol == -1)
+            read_subvol = i;
+        if (size.size > max_size.size ||
+            (size.file_count + size.dir_count) >
+                (max_size.file_count + max_size.dir_count))
+            read_subvol = i;
+
+        if (size.size > max_size.size)
+            max_size.size = size.size;
+        if (size.file_count > max_size.file_count)
+            max_size.file_count = size.file_count;
+        if (size.dir_count > max_size.dir_count)
+            max_size.dir_count = size.dir_count;
+    }
+
+    if (max_size.size == 0 && max_size.file_count == 0 &&
+        max_size.dir_count == 0)
         return read_subvol;
-}
 
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (readable_cnt && !readable[i])
+            continue;
+        if (!replies[i].xdata)
+            continue;
+        quota_dict_set_meta(replies[i].xdata, QUOTA_SIZE_KEY, &max_size,
+                            IA_IFDIR);
+    }
+
+    return read_subvol;
+}
 
 /* {{{ access */
 
 int
-afr_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, dict_t *xdata)
+afr_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (access, frame, op_ret, op_errno, xdata);
+    AFR_STACK_UNWIND(access, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_access_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_access_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (access, frame, local->op_ret,
-				  local->op_errno, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_access_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->access,
-                           &local->loc, local->cont.access.mask,
-			   local->xdata_req);
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(access, frame, local->op_ret, local->op_errno, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_access_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->access, &local->loc,
+                      local->cont.access.mask, local->xdata_req);
+    return 0;
 }
 
 int
-afr_access (call_frame_t *frame, xlator_t *this, loc_t *loc,
-	    int mask, dict_t *xdata)
+afr_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
+           dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_ACCESS;
-	loc_copy (&local->loc, loc);
-	local->cont.access.mask = mask;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_ACCESS;
+    loc_copy(&local->loc, loc);
+    local->cont.access.mask = mask;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_access_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_access_wind,
+                 AFR_METADATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (access, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(access, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -192,152 +187,140 @@ out:
 /* {{{ stat */
 
 int
-afr_stat_cbk (call_frame_t *frame, void *cookie,
-              xlator_t *this, int32_t op_ret, int32_t op_errno,
-              struct iatt *buf, dict_t *xdata)
+afr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata);
+    AFR_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_stat_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_stat_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (stat, frame, local->op_ret, local->op_errno,
-				  0, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_stat_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->stat,
-                           &local->loc, local->xdata_req);
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(
+        frame, afr_stat_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->stat, &local->loc, local->xdata_req);
+    return 0;
 }
 
 int
-afr_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+afr_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_STAT;
-	loc_copy (&local->loc, loc);
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_STAT;
+    loc_copy(&local->loc, loc);
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_stat_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_stat_wind, AFR_DATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ fstat */
 
 int
-afr_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *buf,
-               dict_t *xdata)
+afr_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata);
+    AFR_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fstat_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fstat_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (fstat, frame, local->op_ret, local->op_errno,
-				  0, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_fstat_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->fstat,
-                           local->fd, local->xdata_req);
-	return 0;
-}
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
 
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(
+        frame, afr_fstat_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->fstat, local->fd, local->xdata_req);
+    return 0;
+}
 
 int32_t
-afr_fstat (call_frame_t *frame, xlator_t *this,
-           fd_t *fd, dict_t *xdata)
+afr_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_FSTAT;
-	local->fd = fd_ref (fd);
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_FSTAT;
+    local->fd = fd_ref(fd);
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_fstat_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_fstat_wind, AFR_DATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -345,1555 +328,1493 @@ out:
 /* {{{ readlink */
 
 int
-afr_readlink_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno,
-                  const char *buf, struct iatt *sbuf, dict_t *xdata)
+afr_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, const char *buf,
+                 struct iatt *sbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (readlink, frame, op_ret, op_errno,
-			  buf, sbuf, xdata);
-	return 0;
+    AFR_STACK_UNWIND(readlink, frame, op_ret, op_errno, buf, sbuf, xdata);
+    return 0;
 }
 
 int
-afr_readlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (readlink, frame, local->op_ret,
-				  local->op_errno, 0, 0, 0);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_readlink_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->readlink,
-			   &local->loc, local->cont.readlink.size,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(readlink, frame, local->op_ret, local->op_errno, 0, 0,
+                         0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_readlink_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->readlink, &local->loc,
+                      local->cont.readlink.size, local->xdata_req);
+    return 0;
+}
 
 int
-afr_readlink (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, size_t size, dict_t *xdata)
+afr_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata)
 {
-        afr_local_t   * local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_READLINK;
-        loc_copy (&local->loc, loc);
-        local->cont.readlink.size = size;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_READLINK;
+    loc_copy(&local->loc, loc);
+    local->cont.readlink.size = size;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_readlink_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_readlink_wind,
+                 AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND(readlink, frame, -1, op_errno, 0, 0, 0);
+    AFR_STACK_UNWIND(readlink, frame, -1, op_errno, 0, 0, 0);
 
-	return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ getxattr */
 
 struct _xattr_key {
-        char *key;
-        struct list_head list;
+    char *key;
+    struct list_head list;
 };
 
-
 int
-__gather_xattr_keys (dict_t *dict, char *key, data_t *value,
-                     void *data)
+__gather_xattr_keys(dict_t *dict, char *key, data_t *value, void *data)
 {
-        struct list_head *  list  = data;
-        struct _xattr_key * xkey  = NULL;
-
-        if (!strncmp (key, AFR_XATTR_PREFIX,
-                      strlen (AFR_XATTR_PREFIX))) {
+    struct list_head *list = data;
+    struct _xattr_key *xkey = NULL;
 
-                xkey = GF_CALLOC (1, sizeof (*xkey), gf_afr_mt_xattr_key);
-                if (!xkey)
-                        return -1;
+    if (!strncmp(key, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX))) {
+        xkey = GF_MALLOC(sizeof(*xkey), gf_afr_mt_xattr_key);
+        if (!xkey)
+            return -1;
 
-                xkey->key = key;
-                INIT_LIST_HEAD (&xkey->list);
+        xkey->key = key;
+        INIT_LIST_HEAD(&xkey->list);
 
-                list_add_tail (&xkey->list, list);
-        }
-        return 0;
+        list_add_tail(&xkey->list, list);
+    }
+    return 0;
 }
 
-
 void
-afr_filter_xattrs (dict_t *dict)
+afr_filter_xattrs(dict_t *dict)
 {
-        struct list_head   keys = {0,};
-        struct _xattr_key *key  = NULL;
-        struct _xattr_key *tmp  = NULL;
+    struct list_head keys = {
+        0,
+    };
+    struct _xattr_key *key = NULL;
+    struct _xattr_key *tmp = NULL;
 
-        INIT_LIST_HEAD (&keys);
+    INIT_LIST_HEAD(&keys);
 
-        dict_foreach (dict, __gather_xattr_keys,
-                      (void *) &keys);
+    dict_foreach(dict, __gather_xattr_keys, (void *)&keys);
 
-        list_for_each_entry_safe (key, tmp, &keys, list) {
-                dict_del (dict, key->key);
+    list_for_each_entry_safe(key, tmp, &keys, list)
+    {
+        dict_del(dict, key->key);
 
-                list_del_init (&key->list);
+        list_del_init(&key->list);
 
-                GF_FREE (key);
-        }
+        GF_FREE(key);
+    }
 }
 
-static
-gf_boolean_t
-afr_getxattr_ignorable_errnos (int32_t op_errno)
+static gf_boolean_t
+afr_getxattr_ignorable_errnos(int32_t op_errno)
 {
-        if (op_errno == ENODATA || op_errno == ENOTSUP || op_errno == ERANGE ||
-            op_errno == ENAMETOOLONG)
-                return _gf_true;
+    if (op_errno == ENODATA || op_errno == ENOTSUP || op_errno == ERANGE ||
+        op_errno == ENAMETOOLONG)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 int
-afr_getxattr_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno,
-                  dict_t *dict, dict_t *xdata)
+afr_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0 && !afr_getxattr_ignorable_errnos(op_errno)) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0 && !afr_getxattr_ignorable_errnos(op_errno)) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (dict)
-		afr_filter_xattrs (dict);
+    if (dict)
+        afr_filter_xattrs(dict);
 
-	AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
+    AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_getxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_getxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-				  local->op_errno, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_getxattr_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->getxattr,
-			   &local->loc, local->cont.getxattr.name,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno, NULL,
+                         NULL);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_getxattr_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->getxattr, &local->loc,
+                      local->cont.getxattr.name, local->xdata_req);
+    return 0;
+}
 
 int32_t
-afr_getxattr_unwind (call_frame_t *frame, int op_ret, int op_errno,
-                     dict_t *dict, dict_t *xdata)
+afr_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno, dict_t *dict,
+                    dict_t *xdata)
 
 {
-        AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_clrlk_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *dict, dict_t *xdata)
+afr_fgetxattr_clrlk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *dict,
+                        dict_t *xdata)
 {
-        afr_local_t     *local                  = NULL;
-        afr_private_t   *priv                   = NULL;
-        xlator_t        **children              = NULL;
-        dict_t          *xattr                  = NULL;
-        char            *tmp_report             = NULL;
-        char            lk_summary[1024]        = {0,};
-        int             serz_len                = 0;
-        int32_t         callcnt                 = 0;
-        long int        cky                     = 0;
-        int             ret                     = 0;
-
-        priv     = this->private;
-        children = priv->children;
-
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret == -1)
-                        local->replies[cky].op_errno = op_errno;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (local->dict) {
-                        ret = dict_get_str (dict, local->cont.getxattr.name,
-                                            &tmp_report);
-                        if (ret)
-                                goto unlock;
-                        ret = dict_set_dynstr (local->dict,
-                                               children[cky]->name,
-                                               gf_strdup (tmp_report));
-                        if (ret)
-                                goto unlock;
-                }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    dict_t *xattr = NULL;
+    char *tmp_report = NULL;
+    char lk_summary[1024] = {
+        0,
+    };
+    int serz_len = 0;
+    int32_t callcnt = 0;
+    long int cky = 0;
+    int ret = 0;
+    int keylen = 0;
+    int children_keylen = 0;
+
+    priv = this->private;
+    children = priv->children;
+
+    local = frame->local;
+    cky = (long)cookie;
+    keylen = strlen(local->cont.getxattr.name);
+    children_keylen = strlen(children[cky]->name);
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret == -1)
+            local->replies[cky].op_errno = op_errno;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (local->dict) {
+            ret = dict_get_strn(dict, local->cont.getxattr.name, keylen,
+                                &tmp_report);
+            if (ret)
+                goto unlock;
+            ret = dict_set_dynstrn(local->dict, children[cky]->name,
+                                   children_keylen, gf_strdup(tmp_report));
+            if (ret)
+                goto unlock;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                xattr = dict_new ();
-                if (!xattr) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       lk_summary,
-                                                       &serz_len, '\n');
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                if (serz_len == -1)
-                        snprintf (lk_summary, sizeof (lk_summary),
-                                  "No locks cleared.");
-                ret = dict_set_dynstr (xattr, local->cont.getxattr.name,
-                                       gf_strdup (lk_summary));
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                ENOMEM, AFR_MSG_DICT_SET_FAILED,
-                                "Error setting dictionary");
-                        goto unwind;
-                }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        xattr = dict_new();
+        if (!xattr) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        ret = dict_serialize_value_with_delim(local->dict, lk_summary,
+                                              &serz_len, '\n');
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        if (serz_len == -1)
+            snprintf(lk_summary, sizeof(lk_summary), "No locks cleared.");
+        ret = dict_set_dynstrn(xattr, local->cont.getxattr.name, keylen,
+                               gf_strdup(lk_summary));
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting dictionary");
+            goto unwind;
+        }
 
-                op_errno = afr_final_errno (local, priv);
+        op_errno = afr_final_errno(local, priv);
 
-unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, xattr,
-                                  xdata);
-                if (xattr)
-                        dict_unref (xattr);
-        }
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
+        if (xattr)
+            dict_unref(xattr);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_getxattr_clrlk_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this, int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+afr_getxattr_clrlk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        afr_local_t     *local                  = NULL;
-        afr_private_t   *priv                   = NULL;
-        xlator_t        **children              = NULL;
-        dict_t          *xattr                  = NULL;
-        char            *tmp_report             = NULL;
-        char            lk_summary[1024]        = {0,};
-        int             serz_len                = 0;
-        int32_t         callcnt                 = 0;
-        long int        cky                     = 0;
-        int             ret                     = 0;
-
-        priv     = this->private;
-        children = priv->children;
-
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret == -1)
-                        local->replies[cky].op_errno = op_errno;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (local->dict) {
-                        ret = dict_get_str (dict, local->cont.getxattr.name,
-                                            &tmp_report);
-                        if (ret)
-                                goto unlock;
-                        ret = dict_set_dynstr (local->dict,
-                                               children[cky]->name,
-                                               gf_strdup (tmp_report));
-                        if (ret)
-                                goto unlock;
-                }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    dict_t *xattr = NULL;
+    char *tmp_report = NULL;
+    char lk_summary[1024] = {
+        0,
+    };
+    int serz_len = 0;
+    int32_t callcnt = 0;
+    long int cky = 0;
+    int ret = 0;
+    int keylen = 0;
+    int children_keylen = 0;
+
+    priv = this->private;
+    children = priv->children;
+
+    local = frame->local;
+    cky = (long)cookie;
+
+    keylen = strlen(local->cont.getxattr.name);
+    children_keylen = strlen(children[cky]->name);
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret == -1)
+            local->replies[cky].op_errno = op_errno;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (local->dict) {
+            ret = dict_get_strn(dict, local->cont.getxattr.name, keylen,
+                                &tmp_report);
+            if (ret)
+                goto unlock;
+            ret = dict_set_dynstrn(local->dict, children[cky]->name,
+                                   children_keylen, gf_strdup(tmp_report));
+            if (ret)
+                goto unlock;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                xattr = dict_new ();
-                if (!xattr) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       lk_summary,
-                                                       &serz_len, '\n');
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                if (serz_len == -1)
-                        snprintf (lk_summary, sizeof (lk_summary),
-                                  "No locks cleared.");
-                ret = dict_set_dynstr (xattr, local->cont.getxattr.name,
-                                       gf_strdup (lk_summary));
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                ENOMEM, AFR_MSG_DICT_SET_FAILED,
-                                "Error setting dictionary");
-                        goto unwind;
-                }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        xattr = dict_new();
+        if (!xattr) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        ret = dict_serialize_value_with_delim(local->dict, lk_summary,
+                                              &serz_len, '\n');
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        if (serz_len == -1)
+            snprintf(lk_summary, sizeof(lk_summary), "No locks cleared.");
+        ret = dict_set_dynstrn(xattr, local->cont.getxattr.name, keylen,
+                               gf_strdup(lk_summary));
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting dictionary");
+            goto unwind;
+        }
 
-                op_errno = afr_final_errno (local, priv);
+        op_errno = afr_final_errno(local, priv);
 
-unwind:
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata);
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
-                if (xattr)
-                        dict_unref (xattr);
-        }
+        if (xattr)
+            dict_unref(xattr);
+    }
 
-        return ret;
+    return ret;
 }
 
 /**
  * node-uuid cbk uses next child querying mechanism
  */
 int32_t
-afr_getxattr_node_uuid_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_getxattr_node_uuid_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        afr_private_t  *priv            = NULL;
-        afr_local_t    *local           = NULL;
-        xlator_t      **children        = NULL;
-        int             unwind          = 1;
-        int             curr_call_child = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    xlator_t **children = NULL;
+    int unwind = 1;
+    int curr_call_child = 0;
 
-        priv = this->private;
-        children = priv->children;
+    priv = this->private;
+    children = priv->children;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret == -1) { /** query the _next_ child */
-
-                /**
-                 * _current_ becomes _next_
-                 * If done with all childs and yet no success; give up !
-                 */
-                curr_call_child = (int) ((long)cookie);
-                if (++curr_call_child == priv->child_count)
-                        goto unwind;
-
-                gf_msg_debug (this->name, op_errno,
-                              "op_ret (-1): Re-querying afr-child (%d/%d)",
-                              curr_call_child, priv->child_count);
-
-                unwind = 0;
-                STACK_WIND_COOKIE (frame, afr_getxattr_node_uuid_cbk,
-                                   (void *) (long) curr_call_child,
-                                   children[curr_call_child],
-                                   children[curr_call_child]->fops->getxattr,
-                                   &local->loc,
-                                   local->cont.getxattr.name,
-                                   local->xdata_req);
-        }
+    if (op_ret == -1) { /** query the _next_ child */
 
- unwind:
-        if (unwind)
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict,
-                                  xdata);
+        /**
+         * _current_ becomes _next_
+         * If done with all children and yet no success; give up !
+         */
+        curr_call_child = (int)((long)cookie);
+        if (++curr_call_child == priv->child_count)
+            goto unwind;
+
+        gf_msg_debug(this->name, op_errno,
+                     "op_ret (-1): Re-querying afr-child (%d/%d)",
+                     curr_call_child, priv->child_count);
+
+        unwind = 0;
+        STACK_WIND_COOKIE(
+            frame, afr_getxattr_node_uuid_cbk, (void *)(long)curr_call_child,
+            children[curr_call_child],
+            children[curr_call_child]->fops->getxattr, &local->loc,
+            local->cont.getxattr.name, local->xdata_req);
+    }
 
-        return 0;
+unwind:
+    if (unwind)
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+
+    return 0;
 }
 
 /**
  * list-node-uuids cbk returns the list of node_uuids for the subvolume.
  */
 int32_t
-afr_getxattr_list_node_uuids_cbk (call_frame_t *frame, void *cookie,
-                                  xlator_t *this, int32_t op_ret,
-                                  int32_t op_errno, dict_t *dict, dict_t *xdata)
+afr_getxattr_list_node_uuids_cbk(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int32_t op_ret,
+                                 int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        afr_local_t    *local          = NULL;
-        afr_private_t  *priv           = NULL;
-        int32_t         callcnt        = 0;
-        int             ret            = 0;
-        char           *xattr_serz     = NULL;
-        long            cky            = 0;
-        int32_t         tlen           = 0;
-
-        local = frame->local;
-        priv = this->private;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                local->replies[cky].valid = 1;
-                local->replies[cky].op_ret = op_ret;
-                local->replies[cky].op_errno = op_errno;
-
-                if (op_ret < 0)
-                        goto unlock;
-
-                local->op_ret = 0;
-
-                if (!local->xdata_rsp && xdata)
-                                local->xdata_rsp = dict_ref (xdata);
-                local->replies[cky].xattr = dict_ref (dict);
-        }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr_serz = NULL;
+    long cky = 0;
+    int32_t tlen = 0;
+
+    local = frame->local;
+    priv = this->private;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        local->replies[cky].valid = 1;
+        local->replies[cky].op_ret = op_ret;
+        local->replies[cky].op_errno = op_errno;
+
+        if (op_ret < 0)
+            goto unlock;
+
+        local->op_ret = 0;
+
+        if (!local->xdata_rsp && xdata)
+            local->xdata_rsp = dict_ref(xdata);
+        local->replies[cky].xattr = dict_ref(dict);
+    }
 
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-
-                if (local->op_ret != 0) {
-                        /* All bricks gave an error. */
-                        local->op_errno = afr_final_errno (local, priv);
-                        goto unwind;
-                }
-
-                /*Since we store the UUID0_STR as node uuid for down bricks and
-                 *for non zero op_ret, assigning length to  priv->child_count
-                 *number of uuids*/
-                local->cont.getxattr.xattr_len = (strlen (UUID0_STR) + 2) *
-                                                  priv->child_count;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (!local->dict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+    if (!callcnt) {
+        if (local->op_ret != 0) {
+            /* All bricks gave an error. */
+            local->op_errno = afr_final_errno(local, priv);
+            goto unwind;
+        }
 
-                xattr_serz = GF_CALLOC (local->cont.getxattr.xattr_len,
-                                        sizeof (char), gf_common_mt_char);
+        /*Since we store the UUID0_STR as node uuid for down bricks and
+         *for non zero op_ret, assigning length to  priv->child_count
+         *number of uuids*/
+        local->cont.getxattr.xattr_len = (SLEN(UUID0_STR) + 2) *
+                                         priv->child_count;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (!local->dict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                if (!xattr_serz) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+        xattr_serz = GF_CALLOC(local->cont.getxattr.xattr_len, sizeof(char),
+                               gf_common_mt_char);
 
-                ret = afr_serialize_xattrs_with_delimiter (frame, this,
-                                                           xattr_serz,
-                                                           UUID0_STR, &tlen,
-                                                           ' ');
-                if (ret) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_set_dynstr (local->dict,
-                                       GF_XATTR_LIST_NODE_UUIDS_KEY,
-                                       xattr_serz);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set node_uuid key in dict");
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        local->op_ret = local->cont.getxattr.xattr_len - 1;
-                        local->op_errno = 0;
-                }
+        if (!xattr_serz) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-unwind:
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->dict,
-                                  local->xdata_rsp);
+        ret = afr_serialize_xattrs_with_delimiter(frame, this, xattr_serz,
+                                                  UUID0_STR, &tlen, ' ');
+        if (ret) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            GF_FREE(xattr_serz);
+            goto unwind;
+        }
+        ret = dict_set_dynstr_sizen(local->dict, GF_XATTR_LIST_NODE_UUIDS_KEY,
+                                    xattr_serz);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set node_uuid key in dict");
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            if (ret == -EINVAL)
+                GF_FREE(xattr_serz);
+        } else {
+            local->op_ret = local->cont.getxattr.xattr_len - 1;
+            local->op_errno = 0;
         }
 
-        return ret;
-}
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->dict, local->xdata_rsp);
+    }
 
+    return ret;
+}
 
 int32_t
-afr_getxattr_quota_size_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret, int32_t op_errno,
-                             dict_t *dict, dict_t *xdata)
+afr_getxattr_quota_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *dict,
+                            dict_t *xdata)
 {
-        int         idx         = (long) cookie;
-        int         call_count  = 0;
-        afr_local_t *local      = frame->local;
-        int         read_subvol = -1;
-
-        local->replies[idx].valid = 1;
-        local->replies[idx].op_ret = op_ret;
-        local->replies[idx].op_errno = op_errno;
-        if (dict)
-                local->replies[idx].xdata = dict_ref (dict);
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                local->inode = inode_ref (local->loc.inode);
-                read_subvol = afr_handle_quota_size (frame, this);
-                if (read_subvol != -1) {
-                        op_ret = local->replies[read_subvol].op_ret;
-                        op_errno = local->replies[read_subvol].op_errno;
-                        dict = local->replies[read_subvol].xdata;
-                }
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict,
-                                  xdata);
+    int idx = (long)cookie;
+    int call_count = 0;
+    afr_local_t *local = frame->local;
+    int read_subvol = -1;
+
+    local->replies[idx].valid = 1;
+    local->replies[idx].op_ret = op_ret;
+    local->replies[idx].op_errno = op_errno;
+    if (dict)
+        local->replies[idx].xdata = dict_ref(dict);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        local->inode = inode_ref(local->loc.inode);
+        read_subvol = afr_handle_quota_size(frame, this);
+        if (read_subvol != -1) {
+            op_ret = local->replies[read_subvol].op_ret;
+            op_errno = local->replies[read_subvol].op_errno;
+            dict = local->replies[read_subvol].xdata;
         }
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_getxattr_lockinfo_cbk (call_frame_t *frame, void *cookie,
-                           xlator_t *this, int32_t op_ret, int32_t op_errno,
-                           dict_t *dict, dict_t *xdata)
+afr_getxattr_lockinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *dict,
+                          dict_t *xdata)
 {
-        int          call_cnt     = 0, len = 0;
-        char        *lockinfo_buf = NULL;
-        dict_t      *lockinfo     = NULL, *newdict = NULL;
-        afr_local_t *local        = NULL;
-
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
+    int call_cnt = 0, len = 0;
+    char *lockinfo_buf = NULL;
+    dict_t *lockinfo = NULL, *newdict = NULL;
+    afr_local_t *local = NULL;
 
-                call_cnt = --local->call_count;
+    LOCK(&frame->lock);
+    {
+        local = frame->local;
 
-                if ((op_ret < 0) || (!dict && !xdata)) {
-                        goto unlock;
-                }
+        call_cnt = --local->call_count;
 
-                if (xdata) {
-                        if (!local->xdata_rsp) {
-                                local->xdata_rsp = dict_new ();
-                                if (!local->xdata_rsp) {
-                                        local->op_ret = -1;
-                                        local->op_errno = ENOMEM;
-                                        goto unlock;
-                                }
-                        }
-                }
+        if ((op_ret < 0) || (!dict && !xdata)) {
+            goto unlock;
+        }
 
-                if (!dict) {
-                        goto unlock;
+        if (xdata) {
+            if (!local->xdata_rsp) {
+                local->xdata_rsp = dict_new();
+                if (!local->xdata_rsp) {
+                    local->op_ret = -1;
+                    local->op_errno = ENOMEM;
+                    goto unlock;
                 }
+            }
+        }
 
-                op_ret = dict_get_ptr_and_len (dict, GF_XATTR_LOCKINFO_KEY,
-                                               (void **)&lockinfo_buf, &len);
+        if (!dict) {
+            goto unlock;
+        }
 
-                if (!lockinfo_buf) {
-                        goto unlock;
-                }
+        op_ret = dict_get_ptr_and_len(dict, GF_XATTR_LOCKINFO_KEY,
+                                      (void **)&lockinfo_buf, &len);
 
-                if (!local->dict) {
-                        local->dict = dict_new ();
-                        if (!local->dict) {
-                                local->op_ret = -1;
-                                local->op_errno = ENOMEM;
-                                goto unlock;
-                        }
-                }
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (lockinfo_buf != NULL) {
-                lockinfo = dict_new ();
-                if (lockinfo == NULL) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        op_ret = dict_unserialize (lockinfo_buf, len,
-                                                   &lockinfo);
-
-                        if (lockinfo && local->dict) {
-                                dict_copy (lockinfo, local->dict);
-                        }
-                }
+        if (!lockinfo_buf) {
+            goto unlock;
         }
 
-        if (xdata && local->xdata_rsp) {
-                dict_copy (xdata, local->xdata_rsp);
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict) {
+                local->op_ret = -1;
+                local->op_errno = ENOMEM;
+                goto unlock;
+            }
         }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!call_cnt) {
-                newdict = dict_new ();
-                if (!newdict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
-
-                len = dict_serialized_length (local->dict);
-                if (len <= 0) {
-                        goto unwind;
-                }
-
-                lockinfo_buf = GF_CALLOC (1, len, gf_common_mt_char);
-                if (!lockinfo_buf) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+    if (lockinfo_buf != NULL) {
+        lockinfo = dict_new();
+        if (lockinfo == NULL) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        } else {
+            op_ret = dict_unserialize(lockinfo_buf, len, &lockinfo);
 
-                op_ret = dict_serialize (local->dict, lockinfo_buf);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                }
+            if (lockinfo && local->dict) {
+                dict_copy(lockinfo, local->dict);
+            }
+        }
+    }
+
+    if (xdata && local->xdata_rsp) {
+        dict_copy(xdata, local->xdata_rsp);
+    }
+
+    if (!call_cnt) {
+        newdict = dict_new();
+        if (!newdict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                op_ret = dict_set_dynptr (newdict, GF_XATTR_LOCKINFO_KEY,
-                                          (void *)lockinfo_buf, len);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                        goto unwind;
-                }
+        op_ret = dict_allocate_and_serialize(
+            local->dict, (char **)&lockinfo_buf, (unsigned int *)&len);
+        if (op_ret != 0) {
+            local->op_ret = -1;
+            goto unwind;
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (getxattr, frame, op_ret,
-                                  op_errno, newdict,
-                                  local->xdata_rsp);
+        op_ret = dict_set_dynptr(newdict, GF_XATTR_LOCKINFO_KEY,
+                                 (void *)lockinfo_buf, len);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+            goto unwind;
         }
 
-        dict_unref (lockinfo);
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, newdict,
+                         local->xdata_rsp);
+    }
 
-        return 0;
+    dict_unref(lockinfo);
+
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_lockinfo_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_fgetxattr_lockinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        int          call_cnt     = 0, len = 0;
-        char        *lockinfo_buf = NULL;
-        dict_t      *lockinfo     = NULL, *newdict = NULL;
-        afr_local_t *local        = NULL;
+    int call_cnt = 0, len = 0;
+    char *lockinfo_buf = NULL;
+    dict_t *lockinfo = NULL, *newdict = NULL;
+    afr_local_t *local = NULL;
 
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
+    LOCK(&frame->lock);
+    {
+        local = frame->local;
 
-                call_cnt = --local->call_count;
+        call_cnt = --local->call_count;
 
-                if ((op_ret < 0) || (!dict && !xdata)) {
-                        goto unlock;
-                }
-
-                if (xdata) {
-                        if (!local->xdata_rsp) {
-                                local->xdata_rsp = dict_new ();
-                                if (!local->xdata_rsp) {
-                                        local->op_ret = -1;
-                                        local->op_errno = ENOMEM;
-                                        goto unlock;
-                                }
-                        }
-                }
+        if ((op_ret < 0) || (!dict && !xdata)) {
+            goto unlock;
+        }
 
-                if (!dict) {
-                        goto unlock;
+        if (xdata) {
+            if (!local->xdata_rsp) {
+                local->xdata_rsp = dict_new();
+                if (!local->xdata_rsp) {
+                    local->op_ret = -1;
+                    local->op_errno = ENOMEM;
+                    goto unlock;
                 }
+            }
+        }
 
-                op_ret = dict_get_ptr_and_len (dict, GF_XATTR_LOCKINFO_KEY,
-                                               (void **)&lockinfo_buf, &len);
+        if (!dict) {
+            goto unlock;
+        }
 
-                if (!lockinfo_buf) {
-                        goto unlock;
-                }
+        op_ret = dict_get_ptr_and_len(dict, GF_XATTR_LOCKINFO_KEY,
+                                      (void **)&lockinfo_buf, &len);
 
-                if (!local->dict) {
-                        local->dict = dict_new ();
-                        if (!local->dict) {
-                                local->op_ret = -1;
-                                local->op_errno = ENOMEM;
-                                goto unlock;
-                        }
-                }
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (lockinfo_buf != NULL) {
-                lockinfo = dict_new ();
-                if (lockinfo == NULL) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        op_ret = dict_unserialize (lockinfo_buf, len,
-                                                   &lockinfo);
-
-                        if (lockinfo && local->dict) {
-                                dict_copy (lockinfo, local->dict);
-                        }
-                }
+        if (!lockinfo_buf) {
+            goto unlock;
         }
 
-        if (xdata && local->xdata_rsp) {
-                dict_copy (xdata, local->xdata_rsp);
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict) {
+                local->op_ret = -1;
+                local->op_errno = ENOMEM;
+                goto unlock;
+            }
         }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!call_cnt) {
-                newdict = dict_new ();
-                if (!newdict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
-
-                len = dict_serialized_length (local->dict);
-                if (len <= 0) {
-                        goto unwind;
-                }
-
-                lockinfo_buf = GF_CALLOC (1, len, gf_common_mt_char);
-                if (!lockinfo_buf) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+    if (lockinfo_buf != NULL) {
+        lockinfo = dict_new();
+        if (lockinfo == NULL) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        } else {
+            op_ret = dict_unserialize(lockinfo_buf, len, &lockinfo);
 
-                op_ret = dict_serialize (local->dict, lockinfo_buf);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                }
+            if (lockinfo && local->dict) {
+                dict_copy(lockinfo, local->dict);
+            }
+        }
+    }
+
+    if (xdata && local->xdata_rsp) {
+        dict_copy(xdata, local->xdata_rsp);
+    }
+
+    if (!call_cnt) {
+        newdict = dict_new();
+        if (!newdict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                op_ret = dict_set_dynptr (newdict, GF_XATTR_LOCKINFO_KEY,
-                                          (void *)lockinfo_buf, len);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                        goto unwind;
-                }
+        op_ret = dict_allocate_and_serialize(
+            local->dict, (char **)&lockinfo_buf, (unsigned int *)&len);
+        if (op_ret != 0) {
+            local->op_ret = -1;
+            goto unwind;
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, op_ret,
-                                  op_errno, newdict,
-                                  local->xdata_rsp);
+        op_ret = dict_set_dynptr(newdict, GF_XATTR_LOCKINFO_KEY,
+                                 (void *)lockinfo_buf, len);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+            goto unwind;
         }
 
-        dict_unref (lockinfo);
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, newdict,
+                         local->xdata_rsp);
+    }
 
-        return 0;
+    dict_unref(lockinfo);
+
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_pathinfo_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_fgetxattr_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
-        int          ret            = 0;
-        char        *xattr          = NULL;
-        char        *xattr_serz     = NULL;
-        char        xattr_cky[1024] = {0,};
-        dict_t      *nxattr         = NULL;
-        long         cky            = 0;
-        int32_t      padding        = 0;
-        int32_t      tlen           = 0;
-
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr = NULL;
+    char *xattr_serz = NULL;
+    int keylen = 0;
+    char xattr_cky[1024] = {
+        0,
+    };
+    int xattr_cky_len = 0;
+    dict_t *nxattr = NULL;
+    long cky = 0;
+    int32_t padding = 0;
+    int32_t tlen = 0;
+
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
+
+    local = frame->local;
+    cky = (long)cookie;
+    keylen = strlen(local->cont.getxattr.name);
+    xattr_cky_len = snprintf(xattr_cky, sizeof(xattr_cky), "%s-%ld",
+                             local->cont.getxattr.name, cky);
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret < 0) {
+            local->op_errno = op_errno;
+        } else {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
 
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret < 0) {
-                        local->op_errno = op_errno;
-                } else {
-                        local->op_ret = op_ret;
-                        if (!local->xdata_rsp && xdata)
-                                local->xdata_rsp = dict_ref (xdata);
-                }
+        if (!dict || (op_ret < 0))
+            goto unlock;
 
-                if (!dict || (op_ret < 0))
-                        goto unlock;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-
-                if (local->dict) {
-                        ret = dict_get_str (dict,
-                                            local->cont.getxattr.name,
-                                            &xattr);
-                        if (ret)
-                                goto unlock;
-
-                        xattr = gf_strdup (xattr);
-
-                        (void)snprintf (xattr_cky, 1024, "%s-%ld",
-                                        local->cont.getxattr.name, cky);
-                        ret = dict_set_dynstr (local->dict,
-                                               xattr_cky, xattr);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR,
-                                        -ret, AFR_MSG_DICT_SET_FAILED,
-                                        "Cannot set xattr cookie key");
-                                goto unlock;
-                        }
-
-                        local->cont.getxattr.xattr_len
-                                += strlen (xattr) + 1;
-                }
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict)
+                goto unlock;
+        }
+        ret = dict_get_strn(dict, local->cont.getxattr.name, keylen, &xattr);
+        if (ret)
+            goto unlock;
+
+        xattr = gf_strdup(xattr);
+
+        ret = dict_set_dynstrn(local->dict, xattr_cky, xattr_cky_len, xattr);
+        if (ret) {
+            UNLOCK(&frame->lock);
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set xattr cookie key");
+            goto post_unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (!local->cont.getxattr.xattr_len)
-                        goto unwind;
-
-                nxattr = dict_new ();
-                if (!nxattr)
-                        goto unwind;
-
-                /* extra bytes for decorations (brackets and <>'s) */
-                padding += strlen (this->name)
-                        + strlen (AFR_PATHINFO_HEADER) + 4;
-                local->cont.getxattr.xattr_len += (padding + 2);
-
-                xattr_serz = GF_CALLOC (local->cont.getxattr.xattr_len,
-                                        sizeof (char), gf_common_mt_char);
-
-                if (!xattr_serz)
-                        goto unwind;
-
-                /* the xlator info */
-                (void) sprintf (xattr_serz, "(<"AFR_PATHINFO_HEADER"%s> ",
-                                this->name);
-
-                /* actual series of pathinfo */
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       xattr_serz
-                                                       + strlen (xattr_serz),
-                                                       &tlen, ' ');
-                if (ret) {
-                        goto unwind;
-                }
 
-                /* closing part */
-                *(xattr_serz + padding + tlen) = ')';
-                *(xattr_serz + padding + tlen + 1) = '\0';
+        local->cont.getxattr.xattr_len += strlen(xattr) + 1;
+    }
+unlock:
+    UNLOCK(&frame->lock);
+post_unlock:
+    if (!callcnt) {
+        if (!local->cont.getxattr.xattr_len)
+            goto unwind;
+
+        nxattr = dict_new();
+        if (!nxattr)
+            goto unwind;
+
+        /* extra bytes for decorations (brackets and <>'s) */
+        padding += strlen(this->name) + SLEN(AFR_PATHINFO_HEADER) + 4;
+        local->cont.getxattr.xattr_len += (padding + 2);
+
+        xattr_serz = GF_MALLOC(local->cont.getxattr.xattr_len,
+                               gf_common_mt_char);
+
+        if (!xattr_serz)
+            goto unwind;
+
+        /* the xlator info */
+        int xattr_serz_len = sprintf(
+            xattr_serz, "(<" AFR_PATHINFO_HEADER "%s> ", this->name);
+
+        /* actual series of pathinfo */
+        ret = dict_serialize_value_with_delim(
+            local->dict, xattr_serz + xattr_serz_len, &tlen, ' ');
+        if (ret) {
+            GF_FREE(xattr_serz);
+            goto unwind;
+        }
 
-                ret = dict_set_dynstr (nxattr, local->cont.getxattr.name,
-                                       xattr_serz);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set pathinfo key in dict");
+        /* closing part */
+        *(xattr_serz + padding + tlen) = ')';
+        *(xattr_serz + padding + tlen + 1) = '\0';
+
+        ret = dict_set_dynstrn(nxattr, local->cont.getxattr.name, keylen,
+                               xattr_serz);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set pathinfo key in dict");
+            if (ret == -EINVAL)
+                GF_FREE(xattr_serz);
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, local->op_ret,
-                                  local->op_errno, nxattr, local->xdata_rsp);
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, local->op_ret, local->op_errno,
+                         nxattr, local->xdata_rsp);
 
-                if (nxattr)
-                        dict_unref (nxattr);
-        }
+        if (nxattr)
+            dict_unref(nxattr);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_getxattr_pathinfo_cbk (call_frame_t *frame, void *cookie,
-                           xlator_t *this, int32_t op_ret, int32_t op_errno,
-                           dict_t *dict, dict_t *xdata)
+afr_getxattr_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *dict,
+                          dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
-        int          ret            = 0;
-        char        *xattr          = NULL;
-        char        *xattr_serz     = NULL;
-        char        xattr_cky[1024] = {0,};
-        dict_t      *nxattr         = NULL;
-        long         cky            = 0;
-        int32_t      padding        = 0;
-        int32_t      tlen           = 0;
-
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
-        }
-
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-                {
-                        callcnt = --local->call_count;
-
-                        if (op_ret < 0) {
-                                local->op_errno = op_errno;
-                        } else {
-                                local->op_ret = op_ret;
-                                if (!local->xdata_rsp && xdata)
-                                        local->xdata_rsp = dict_ref (xdata);
-                        }
-
-                        if (!dict || (op_ret < 0))
-                                goto unlock;
-
-                        if (!local->dict)
-                                local->dict = dict_new ();
-
-                        if (local->dict) {
-                                ret = dict_get_str (dict,
-                                                    local->cont.getxattr.name,
-                                                    &xattr);
-                                if (ret)
-                                        goto unlock;
-
-                                xattr = gf_strdup (xattr);
-
-                                (void)snprintf (xattr_cky, 1024, "%s-%ld",
-                                                local->cont.getxattr.name, cky);
-                                ret = dict_set_dynstr (local->dict,
-                                                       xattr_cky, xattr);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                -ret,
-                                                AFR_MSG_DICT_SET_FAILED,
-                                                "Cannot set xattr "
-                                                "cookie key");
-                                        goto unlock;
-                                }
-
-                                local->cont.getxattr.xattr_len += strlen (xattr) + 1;
-                        }
-                }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (!local->cont.getxattr.xattr_len)
-                        goto unwind;
-
-                nxattr = dict_new ();
-                if (!nxattr)
-                        goto unwind;
-
-                /* extra bytes for decorations (brackets and <>'s) */
-                padding += strlen (this->name) + strlen (AFR_PATHINFO_HEADER) + 4;
-                local->cont.getxattr.xattr_len += (padding + 2);
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr = NULL;
+    char *xattr_serz = NULL;
+    char xattr_cky[1024] = {
+        0,
+    };
+    int keylen = 0;
+    int xattr_cky_len = 0;
+    dict_t *nxattr = NULL;
+    long cky = 0;
+    int32_t padding = 0;
+    int32_t tlen = 0;
+
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
+
+    local = frame->local;
+    cky = (long)cookie;
+    keylen = strlen(local->cont.getxattr.name);
+    xattr_cky_len = snprintf(xattr_cky, sizeof(xattr_cky), "%s-%ld",
+                             local->cont.getxattr.name, cky);
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                xattr_serz = GF_CALLOC (local->cont.getxattr.xattr_len,
-                                        sizeof (char), gf_common_mt_char);
-
-                if (!xattr_serz)
-                        goto unwind;
+        if (op_ret < 0) {
+            local->op_errno = op_errno;
+        } else {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        }
 
-                /* the xlator info */
-                (void) sprintf (xattr_serz, "(<"AFR_PATHINFO_HEADER"%s> ",
-                                this->name);
+        if (!dict || (op_ret < 0))
+            goto unlock;
 
-                /* actual series of pathinfo */
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       xattr_serz + strlen (xattr_serz),
-                                                       &tlen, ' ');
-                if (ret) {
-                        goto unwind;
-                }
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict)
+                goto unlock;
+        }
+        ret = dict_get_strn(dict, local->cont.getxattr.name, keylen, &xattr);
+        if (ret)
+            goto unlock;
+
+        xattr = gf_strdup(xattr);
+
+        ret = dict_set_dynstrn(local->dict, xattr_cky, xattr_cky_len, xattr);
+        if (ret) {
+            UNLOCK(&frame->lock);
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set xattr cookie key");
+            goto post_unlock;
+        }
 
-                /* closing part */
-                *(xattr_serz + padding + tlen) = ')';
-                *(xattr_serz + padding + tlen + 1) = '\0';
+        local->cont.getxattr.xattr_len += strlen(xattr) + 1;
+    }
+unlock:
+    UNLOCK(&frame->lock);
+post_unlock:
+    if (!callcnt) {
+        if (!local->cont.getxattr.xattr_len)
+            goto unwind;
+
+        nxattr = dict_new();
+        if (!nxattr)
+            goto unwind;
+
+        /* extra bytes for decorations (brackets and <>'s) */
+        padding += strlen(this->name) + SLEN(AFR_PATHINFO_HEADER) + 4;
+        local->cont.getxattr.xattr_len += (padding + 2);
+
+        xattr_serz = GF_MALLOC(local->cont.getxattr.xattr_len,
+                               gf_common_mt_char);
+
+        if (!xattr_serz)
+            goto unwind;
+
+        /* the xlator info */
+        int xattr_serz_len = sprintf(
+            xattr_serz, "(<" AFR_PATHINFO_HEADER "%s> ", this->name);
+
+        /* actual series of pathinfo */
+        ret = dict_serialize_value_with_delim(
+            local->dict, xattr_serz + xattr_serz_len, &tlen, ' ');
+        if (ret) {
+            GF_FREE(xattr_serz);
+            goto unwind;
+        }
 
-                ret = dict_set_dynstr (nxattr, local->cont.getxattr.name,
-                                       xattr_serz);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set pathinfo key in dict");
+        /* closing part */
+        *(xattr_serz + padding + tlen) = ')';
+        *(xattr_serz + padding + tlen + 1) = '\0';
+
+        ret = dict_set_dynstrn(nxattr, local->cont.getxattr.name, keylen,
+                               xattr_serz);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set pathinfo key in dict");
+            if (ret == -EINVAL)
+                GF_FREE(xattr_serz);
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, nxattr, local->xdata_rsp);
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         nxattr, local->xdata_rsp);
 
-                if (nxattr)
-                        dict_unref (nxattr);
-        }
+        if (nxattr)
+            dict_unref(nxattr);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-afr_aggregate_stime_xattr (dict_t *this, char *key, data_t *value, void *data)
+afr_aggregate_stime_xattr(dict_t *this, char *key, data_t *value, void *data)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (fnmatch (GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0)
-                ret = gf_get_max_stime (THIS, data, key, value);
+    if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0)
+        ret = gf_get_max_stime(THIS, data, key, value);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_common_getxattr_stime_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this, int32_t op_ret, int32_t op_errno,
-                               dict_t *dict, dict_t *xdata)
+afr_common_getxattr_stime_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno, dict_t *dict,
+                              dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
 
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
-        }
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (!dict || (op_ret < 0)) {
-                        local->op_errno = op_errno;
-                        goto cleanup;
-                }
-
-                if (!local->dict)
-                        local->dict = dict_copy_with_ref (dict, NULL);
-                else
-                        dict_foreach (dict, afr_aggregate_stime_xattr,
-                                      local->dict);
-                local->op_ret = 0;
+        if (!dict || (op_ret < 0)) {
+            local->op_errno = op_errno;
+            goto cleanup;
         }
 
+        if (!local->dict)
+            local->dict = dict_copy_with_ref(dict, NULL);
+        else
+            dict_foreach(dict, afr_aggregate_stime_xattr, local->dict);
+        local->op_ret = 0;
+    }
+
 cleanup:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->dict, xdata);
-        }
+    if (!callcnt) {
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->dict, xdata);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 static gf_boolean_t
-afr_is_special_xattr (const char *name, fop_getxattr_cbk_t *cbk,
-                      gf_boolean_t is_fgetxattr)
+afr_is_special_xattr(const char *name, fop_getxattr_cbk_t *cbk,
+                     gf_boolean_t is_fgetxattr)
 {
-        gf_boolean_t    is_spl = _gf_true;
-
-        GF_ASSERT (cbk);
-        if (!cbk || !name) {
-                is_spl = _gf_false;
-                goto out;
+    gf_boolean_t is_spl = _gf_true;
+
+    GF_ASSERT(cbk);
+    if (!cbk || !name) {
+        is_spl = _gf_false;
+        goto out;
+    }
+
+    if (!strcmp(name, GF_XATTR_PATHINFO_KEY) ||
+        !strcmp(name, GF_XATTR_USER_PATHINFO_KEY)) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_pathinfo_cbk;
+        } else {
+            *cbk = afr_getxattr_pathinfo_cbk;
         }
-
-        if (!strcmp (name, GF_XATTR_PATHINFO_KEY) ||
-	    !strcmp (name, GF_XATTR_USER_PATHINFO_KEY)) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_pathinfo_cbk;
-                } else {
-                        *cbk = afr_getxattr_pathinfo_cbk;
-                }
-        } else if (!strncmp (name, GF_XATTR_CLRLK_CMD,
-                             strlen (GF_XATTR_CLRLK_CMD))) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_clrlk_cbk;
-                } else {
-                        *cbk = afr_getxattr_clrlk_cbk;
-                }
-        } else if (!strncmp (name, GF_XATTR_LOCKINFO_KEY,
-                             strlen (GF_XATTR_LOCKINFO_KEY))) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_lockinfo_cbk;
-                } else {
-                        *cbk = afr_getxattr_lockinfo_cbk;
-                }
-        } else if (fnmatch (GF_XATTR_STIME_PATTERN, name, FNM_NOESCAPE) == 0) {
-                *cbk = afr_common_getxattr_stime_cbk;
-        } else if (strcmp (name, QUOTA_SIZE_KEY) == 0) {
-                *cbk = afr_getxattr_quota_size_cbk;
-        } else if (!strcmp (name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
-                *cbk = afr_getxattr_list_node_uuids_cbk;
+    } else if (!strncmp(name, GF_XATTR_CLRLK_CMD, SLEN(GF_XATTR_CLRLK_CMD))) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_clrlk_cbk;
         } else {
-                is_spl = _gf_false;
+            *cbk = afr_getxattr_clrlk_cbk;
         }
+    } else if (!strncmp(name, GF_XATTR_LOCKINFO_KEY,
+                        SLEN(GF_XATTR_LOCKINFO_KEY))) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_lockinfo_cbk;
+        } else {
+            *cbk = afr_getxattr_lockinfo_cbk;
+        }
+    } else if (fnmatch(GF_XATTR_STIME_PATTERN, name, FNM_NOESCAPE) == 0) {
+        *cbk = afr_common_getxattr_stime_cbk;
+    } else if (strcmp(name, QUOTA_SIZE_KEY) == 0) {
+        *cbk = afr_getxattr_quota_size_cbk;
+    } else if (!strcmp(name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
+        *cbk = afr_getxattr_list_node_uuids_cbk;
+    } else {
+        is_spl = _gf_false;
+    }
 
 out:
-        return is_spl;
+    return is_spl;
 }
 
 static void
-afr_getxattr_all_subvols (xlator_t *this, call_frame_t *frame,
-			  const char *name, loc_t *loc,
-			  fop_getxattr_cbk_t cbk)
+afr_getxattr_all_subvols(xlator_t *this, call_frame_t *frame, const char *name,
+                         loc_t *loc, fop_getxattr_cbk_t cbk)
 {
-        afr_private_t   *priv           = NULL;
-        afr_local_t     *local          = NULL;
-        int             i               = 0;
-        int             call_count      = 0;
-
-        priv     = this->private;
-
-        local = frame->local;
-        //local->call_count set in afr_local_init
-        call_count = local->call_count;
-
-        if (!strcmp (name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
-                GF_FREE (local->cont.getxattr.name);
-                local->cont.getxattr.name = gf_strdup (GF_XATTR_NODE_UUID_KEY);
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+
+    priv = this->private;
+
+    local = frame->local;
+    // local->call_count set in afr_local_init
+    call_count = local->call_count;
+
+    if (!strcmp(name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
+        GF_FREE(local->cont.getxattr.name);
+        local->cont.getxattr.name = gf_strdup(GF_XATTR_NODE_UUID_KEY);
+    }
+
+    // If up-children count is 0, afr_local_init would have failed already
+    // and the call would have unwound so not handling it here.
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, cbk, (void *)(long)i, priv->children[i],
+                              priv->children[i]->fops->getxattr, loc,
+                              local->cont.getxattr.name, NULL);
+            if (!--call_count)
+                break;
         }
-
-        //If up-children count is 0, afr_local_init would have failed already
-        //and the call would have unwound so not handling it here.
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, cbk,
-                                           (void *) (long) i, priv->children[i],
-                                           priv->children[i]->fops->getxattr,
-                                           loc, local->cont.getxattr.name,
-                                           NULL);
-                        if (!--call_count)
-                                break;
-                }
-        }
-        return;
+    }
+    return;
 }
 
 int
-afr_marker_populate_args (call_frame_t *frame, int type, int *gauge,
-                          xlator_t **subvols)
+afr_marker_populate_args(call_frame_t *frame, int type, int *gauge,
+                         xlator_t **subvols)
 {
-        xlator_t *this = frame->this;
-        afr_private_t *priv = this->private;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
 
-        memcpy (subvols, priv->children, sizeof (*subvols) * priv->child_count);
+    memcpy(subvols, priv->children, sizeof(*subvols) * priv->child_count);
 
-        if (type == MARKER_XTIME_TYPE) {
-                /*Don't error out on ENOENT/ENOTCONN */
-                gauge[MCNT_NOTFOUND] = 0;
-                gauge[MCNT_ENOTCONN] = 0;
-        }
-        return priv->child_count;
+    if (type == MARKER_XTIME_TYPE) {
+        /*Don't error out on ENOENT/ENOTCONN */
+        gauge[MCNT_NOTFOUND] = 0;
+        gauge[MCNT_ENOTCONN] = 0;
+    }
+    return priv->child_count;
 }
 
 static int
-afr_handle_heal_xattrs (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                        const char *heal_op)
+afr_handle_heal_xattrs(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       const char *heal_op)
 {
-        int                     ret     = -1;
-        afr_spb_status_t       *data    = NULL;
+    int ret = -1;
+    afr_spb_status_t *data = NULL;
 
-        if (!strcmp (heal_op, GF_HEAL_INFO)) {
-                afr_get_heal_info (frame, this, loc);
-                ret = 0;
-                goto out;
-        }
+    if (!strcmp(heal_op, GF_HEAL_INFO)) {
+        afr_get_heal_info(frame, this, loc);
+        ret = 0;
+        goto out;
+    }
 
-        if (!strcmp (heal_op, GF_AFR_HEAL_SBRAIN)) {
-                afr_heal_splitbrain_file (frame, this, loc);
-                ret = 0;
-                goto out;
+    if (!strcmp(heal_op, GF_AFR_HEAL_SBRAIN)) {
+        afr_heal_splitbrain_file(frame, this, loc);
+        ret = 0;
+        goto out;
+    }
+
+    if (!strcmp(heal_op, GF_AFR_SBRAIN_STATUS)) {
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_spb_status_t);
+        if (!data) {
+            ret = 1;
+            goto out;
         }
-
-        if (!strcmp (heal_op, GF_AFR_SBRAIN_STATUS)) {
-                data = GF_CALLOC (1, sizeof (*data), gf_afr_mt_spb_status_t);
-                if (!data) {
-                        ret = 1;
-                        goto out;
-                }
-                data->frame = frame;
-                data->loc = loc;
-                ret = synctask_new (this->ctx->env,
-                                    afr_get_split_brain_status,
-                                    afr_get_split_brain_status_cbk,
-                                    NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_STATUS,
-                                "Failed to create"
-                                " synctask. Unable to fetch split-brain status"
-                                " for %s.", loc->name);
-                        ret = 1;
-                        goto out;
-                }
-                goto out;
+        data->frame = frame;
+        data->loc = loc;
+        ret = synctask_new(this->ctx->env, afr_get_split_brain_status,
+                           afr_get_split_brain_status_cbk, NULL, data);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN_STATUS,
+                   "Failed to create"
+                   " synctask. Unable to fetch split-brain status"
+                   " for %s.",
+                   loc->name);
+            ret = 1;
+            goto out;
         }
+        goto out;
+    }
 
 out:
-        if (ret == 1) {
-                AFR_STACK_UNWIND (getxattr, frame, -1, ENOMEM, NULL, NULL);
-                if (data)
-                        GF_FREE (data);
-                ret = 0;
-        }
-        return ret;
+    if (ret == 1) {
+        AFR_STACK_UNWIND(getxattr, frame, -1, ENOMEM, NULL, NULL);
+        if (data)
+            GF_FREE(data);
+        ret = 0;
+    }
+    return ret;
 }
 
 int32_t
-afr_getxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, const char *name, dict_t *xdata)
+afr_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+             dict_t *xdata)
 {
-        afr_private_t           *priv         = NULL;
-        afr_local_t             *local        = NULL;
-        xlator_t                **children    = NULL;
-        int                     i             = 0;
-        int32_t                 op_errno      = 0;
-        int                     ret           = -1;
-        fop_getxattr_cbk_t      cbk           = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    xlator_t **children = NULL;
+    int i = 0;
+    int32_t op_errno = 0;
+    int ret = -1;
+    fop_getxattr_cbk_t cbk = NULL;
 
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    priv = this->private;
 
-        priv     = this->private;
+    children = priv->children;
 
-        children = priv->children;
+    loc_copy(&local->loc, loc);
 
-        loc_copy (&local->loc, loc);
+    local->op = GF_FOP_GETXATTR;
 
-	local->op = GF_FOP_GETXATTR;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    if (!name)
+        goto no_name;
 
-        if (!name)
-                goto no_name;
+    local->cont.getxattr.name = gf_strdup(name);
 
-        local->cont.getxattr.name = gf_strdup (name);
+    if (!local->cont.getxattr.name) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	if (!local->cont.getxattr.name) {
-		op_errno = ENOMEM;
-		goto out;
-	}
+    if (!strncmp(name, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX))) {
+        op_errno = ENODATA;
+        goto out;
+    }
 
-        if (!strncmp (name, AFR_XATTR_PREFIX,
-                      strlen (AFR_XATTR_PREFIX))) {
-                op_errno = ENODATA;
-                goto out;
-        }
-
-        if (cluster_handle_marker_getxattr (frame, loc, name, priv->vol_uuid,
-                                            afr_getxattr_unwind,
-                                            afr_marker_populate_args) == 0)
-                return 0;
+    if (cluster_handle_marker_getxattr(frame, loc, name, priv->vol_uuid,
+                                       afr_getxattr_unwind,
+                                       afr_marker_populate_args) == 0)
+        return 0;
 
-        ret = afr_handle_heal_xattrs (frame, this, &local->loc, name);
-        if (ret == 0)
-                return 0;
+    ret = afr_handle_heal_xattrs(frame, this, &local->loc, name);
+    if (ret == 0)
+        return 0;
 
-        /*
-         * Special xattrs which need responses from all subvols
-         */
-        if (afr_is_special_xattr (name, &cbk, 0)) {
-                afr_getxattr_all_subvols (this, frame, name, loc, cbk);
-                return 0;
-        }
+    /*
+     * Heal daemons don't have IO threads ... and as a result they
+     * send this getxattr down and eventually crash :(
+     */
+    op_errno = -1;
+    GF_CHECK_XATTR_KEY_AND_GOTO(name, IO_THREADS_QUEUE_SIZE_KEY, op_errno, out);
+
+    /*
+     * Special xattrs which need responses from all subvols
+     */
+    if (afr_is_special_xattr(name, &cbk, 0)) {
+        afr_getxattr_all_subvols(this, frame, name, loc, cbk);
+        return 0;
+    }
 
-        if (XATTR_IS_NODE_UUID (name)) {
-                i = 0;
-                STACK_WIND_COOKIE (frame, afr_getxattr_node_uuid_cbk,
-                                   (void *) (long) i,
-                                   children[i],
-                                   children[i]->fops->getxattr,
-                                   loc, name, xdata);
-                return 0;
-        }
+    if (XATTR_IS_NODE_UUID(name)) {
+        i = 0;
+        STACK_WIND_COOKIE(frame, afr_getxattr_node_uuid_cbk, (void *)(long)i,
+                          children[i], children[i]->fops->getxattr, loc, name,
+                          xdata);
+        return 0;
+    }
 
 no_name:
 
-	afr_read_txn (frame, this, local->loc.inode, afr_getxattr_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, local->loc.inode, afr_getxattr_wind,
+                 AFR_METADATA_TRANSACTION);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret < 0)
-                AFR_STACK_UNWIND (getxattr, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    if (ret < 0)
+        AFR_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 /* {{{ fgetxattr */
 
-
 int32_t
-afr_fgetxattr_cbk (call_frame_t *frame, void *cookie,
-                   xlator_t *this, int32_t op_ret, int32_t op_errno,
-                   dict_t *dict, dict_t *xdata)
+afr_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (dict)
-		afr_filter_xattrs (dict);
+    if (dict)
+        afr_filter_xattrs(dict);
 
-	AFR_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, dict, xdata);
+    AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, dict, xdata);
 
-	return 0;
+    return 0;
 }
 
 int
-afr_fgetxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fgetxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (fgetxattr, frame, local->op_ret,
-				  local->op_errno, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_fgetxattr_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fgetxattr,
-			   local->fd, local->cont.getxattr.name,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
 
-static void
-afr_fgetxattr_all_subvols (xlator_t *this, call_frame_t *frame,
-			   fop_fgetxattr_cbk_t cbk)
-{
-        afr_private_t   *priv           = NULL;
-        afr_local_t     *local          = NULL;
-        int             i               = 0;
-        int             call_count      = 0;
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(fgetxattr, frame, local->op_ret, local->op_errno, NULL,
+                         NULL);
+        return 0;
+    }
 
-        priv     = this->private;
+    STACK_WIND_COOKIE(frame, afr_fgetxattr_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fgetxattr, local->fd,
+                      local->cont.getxattr.name, local->xdata_req);
+    return 0;
+}
 
-        local = frame->local;
-        //local->call_count set in afr_local_init
-        call_count = local->call_count;
-
-        //If up-children count is 0, afr_local_init would have failed already
-        //and the call would have unwound so not handling it here.
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->fgetxattr,
-                                           local->fd, local->cont.getxattr.name,
-					   NULL);
-                        if (!--call_count)
-                                break;
-                }
+static void
+afr_fgetxattr_all_subvols(xlator_t *this, call_frame_t *frame,
+                          fop_fgetxattr_cbk_t cbk)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+
+    priv = this->private;
+
+    local = frame->local;
+    // local->call_count set in afr_local_init
+    call_count = local->call_count;
+
+    // If up-children count is 0, afr_local_init would have failed already
+    // and the call would have unwound so not handling it here.
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, cbk, (void *)(long)i, priv->children[i],
+                              priv->children[i]->fops->fgetxattr, local->fd,
+                              local->cont.getxattr.name, NULL);
+            if (!--call_count)
+                break;
         }
+    }
 
-        return;
+    return;
 }
 
-
 int
-afr_fgetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, const char *name, dict_t *xdata)
+afr_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+              dict_t *xdata)
 {
-        afr_local_t          *local      = NULL;
-        int32_t               op_errno   = 0;
-        fop_fgetxattr_cbk_t   cbk        = NULL;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-	local->op = GF_FOP_FGETXATTR;
-        local->fd = fd_ref (fd);
-        if (name) {
-                local->cont.getxattr.name = gf_strdup (name);
-		if (!local->cont.getxattr.name) {
-			op_errno = ENOMEM;
-			goto out;
-		}
-	}
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
-
-        /* pathinfo gets handled only in getxattr(), but we need to handle
-         * lockinfo.
-         * If we are doing fgetxattr with lockinfo as the key then we
-         * collect information from all children.
-         */
-        if (afr_is_special_xattr (name, &cbk, 1)) {
-                afr_fgetxattr_all_subvols (this, frame, cbk);
-                return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    fop_fgetxattr_cbk_t cbk = NULL;
+
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_FGETXATTR;
+    local->fd = fd_ref(fd);
+    if (name) {
+        local->cont.getxattr.name = gf_strdup(name);
+        if (!local->cont.getxattr.name) {
+            op_errno = ENOMEM;
+            goto out;
         }
+    }
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    /* pathinfo gets handled only in getxattr(), but we need to handle
+     * lockinfo.
+     * If we are doing fgetxattr with lockinfo as the key then we
+     * collect information from all children.
+     */
+    if (afr_is_special_xattr(name, &cbk, 1)) {
+        afr_fgetxattr_all_subvols(this, frame, cbk);
+        return 0;
+    }
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_fgetxattr_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_fgetxattr_wind,
+                 AFR_METADATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fgetxattr, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(fgetxattr, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ readv */
 
 int
-afr_readv_cbk (call_frame_t *frame, void *cookie,
-               xlator_t *this, int32_t op_ret, int32_t op_errno,
-               struct iovec *vector, int32_t count, struct iatt *buf,
-               struct iobref *iobref, dict_t *xdata)
+afr_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vector, int32_t count,
+              struct iatt *buf, struct iobref *iobref, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (readv, frame, op_ret, op_errno,
-			  vector, count, buf, iobref, xdata);
-	return 0;
+    AFR_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, buf, iobref,
+                     xdata);
+    return 0;
 }
 
-
 int
-afr_readv_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readv_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (readv, frame, local->op_ret, local->op_errno,
-				  0, 0, 0, 0, 0);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_readv_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->readv,
-			   local->fd, local->cont.readv.size,
-			   local->cont.readv.offset, local->cont.readv.flags,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(readv, frame, local->op_ret, local->op_errno, 0, 0, 0,
+                         0, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(
+        frame, afr_readv_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->readv, local->fd, local->cont.readv.size,
+        local->cont.readv.offset, local->cont.readv.flags, local->xdata_req);
+    return 0;
+}
 
 int
-afr_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-	   off_t offset, uint32_t flags, dict_t *xdata)
+afr_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+          off_t offset, uint32_t flags, dict_t *xdata)
 {
-        afr_local_t   * local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_READ;
-        local->fd = fd_ref (fd);
-        local->cont.readv.size = size;
-        local->cont.readv.offset = offset;
-        local->cont.readv.flags = flags;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_READ;
+    local->fd = fd_ref(fd);
+    local->cont.readv.size = size;
+    local->cont.readv.offset = offset;
+    local->cont.readv.flags = flags;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_readv_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_readv_wind, AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
+    AFR_STACK_UNWIND(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
 
-	return 0;
+    return 0;
 }
 
 /* }}} */
@@ -1901,77 +1822,73 @@ out:
 /* {{{ seek */
 
 int
-afr_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
+afr_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, off_t offset, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-
-                afr_read_txn_continue (frame, this, (long) cookie);
-                return 0;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-        AFR_STACK_UNWIND (seek, frame, op_ret, op_errno, offset, xdata);
+        afr_read_txn_continue(frame, this, (long)cookie);
         return 0;
-}
+    }
 
+    AFR_STACK_UNWIND(seek, frame, op_ret, op_errno, offset, xdata);
+    return 0;
+}
 
 int
-afr_seek_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_seek_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        if (subvol == -1) {
-                AFR_STACK_UNWIND (seek, frame, local->op_ret, local->op_errno,
-                                  0, NULL);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-        STACK_WIND_COOKIE (frame, afr_seek_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->seek,
-                           local->fd, local->cont.seek.offset,
-                           local->cont.seek.what, local->xdata_req);
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(seek, frame, local->op_ret, local->op_errno, 0, NULL);
         return 0;
-}
+    }
 
+    STACK_WIND_COOKIE(
+        frame, afr_seek_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->seek, local->fd, local->cont.seek.offset,
+        local->cont.seek.what, local->xdata_req);
+    return 0;
+}
 
 int
-afr_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-          gf_seek_what_t what, dict_t *xdata)
+afr_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+         gf_seek_what_t what, dict_t *xdata)
 {
-        afr_local_t    *local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_SEEK;
-        local->fd = fd_ref (fd);
-        local->cont.seek.offset = offset;
-        local->cont.seek.what = what;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_SEEK;
+    local->fd = fd_ref(fd);
+    local->cont.seek.offset = offset;
+    local->cont.seek.what = what;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        afr_read_txn (frame, this, fd->inode, afr_seek_wind,
-                      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_seek_wind, AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-        AFR_STACK_UNWIND (seek, frame, -1, op_errno, 0, NULL);
+    AFR_STACK_UNWIND(seek, frame, -1, op_errno, 0, NULL);
 
-        return 0;
+    return 0;
 }
 /* }}} */
diff --git a/xlators/cluster/afr/src/afr-inode-read.h b/xlators/cluster/afr/src/afr-inode-read.h
index d128134ef2a..8c982bc7e6f 100644
--- a/xlators/cluster/afr/src/afr-inode-read.h
+++ b/xlators/cluster/afr/src/afr-inode-read.h
@@ -12,34 +12,34 @@
 #define __INODE_READ_H__
 
 int32_t
-afr_access (call_frame_t *frame, xlator_t *this,
-	    loc_t *loc, int32_t mask, dict_t *xdata);
+afr_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+           dict_t *xdata);
 
 int32_t
-afr_stat (call_frame_t *frame, xlator_t *this,
-	  loc_t *loc, dict_t *xdata);
+afr_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
 
 int32_t
-afr_fstat (call_frame_t *frame, xlator_t *this,
-	   fd_t *fd, dict_t *xdata);
+afr_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
 
 int32_t
-afr_readlink (call_frame_t *frame, xlator_t *this,
-	      loc_t *loc, size_t size, dict_t *xdata);
+afr_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata);
 
 int32_t
-afr_readv (call_frame_t *frame, xlator_t *this,
-	   fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata);
+afr_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+          off_t offset, uint32_t flags, dict_t *xdata);
 
 int32_t
-afr_getxattr (call_frame_t *frame, xlator_t *this,
-	      loc_t *loc, const char *name, dict_t *xdata);
+afr_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+             dict_t *xdata);
 
 int32_t
-afr_fgetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, const char *name, dict_t *xdata);
-
+afr_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+              dict_t *xdata);
 
 int
-afr_handle_quota_size (call_frame_t *frame, xlator_t *this);
+afr_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+         gf_seek_what_t what, dict_t *xdata);
+int
+afr_handle_quota_size(call_frame_t *frame, xlator_t *this);
 #endif /* __INODE_READ_H__ */
diff --git a/xlators/cluster/afr/src/afr-inode-write.c b/xlators/cluster/afr/src/afr-inode-write.c
index 6651e92f482..1d6e4f3570a 100644
--- a/xlators/cluster/afr/src/afr-inode-write.c
+++ b/xlators/cluster/afr/src/afr-inode-write.c
@@ -8,797 +8,779 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include <libgen.h>
 #include <unistd.h>
-#include <fnmatch.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "afr.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/defaults.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
 #include "protocol-common.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "afr-transaction.h"
 #include "afr-self-heal.h"
 #include "afr-messages.h"
 
 static void
-__afr_inode_write_finalize (call_frame_t *frame, xlator_t *this)
-{
-	int                       i               = 0;
-        int                       ret             = 0;
-	int                       read_subvol     = 0;
-        struct iatt              *stbuf           = NULL;
-	afr_local_t              *local           = NULL;
-	afr_private_t            *priv            = NULL;
-        afr_read_subvol_args_t    args            = {0,};
-
-	local = frame->local;
-	priv = this->private;
-
-        /*This code needs to stay till DHT sends fops on linked
-         * inodes*/
-        if (local->inode && !inode_is_linked (local->inode)) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->replies[i].valid)
-                                continue;
-                        if (local->replies[i].op_ret == -1)
-                                continue;
-                        if (!gf_uuid_is_null
-                                        (local->replies[i].poststat.ia_gfid)) {
-                                gf_uuid_copy (args.gfid,
-                                            local->replies[i].poststat.ia_gfid);
-                                args.ia_type =
-                                        local->replies[i].poststat.ia_type;
-                                break;
-                        } else {
-                                ret = dict_get_bin (local->replies[i].xdata,
-                                                    DHT_IATT_IN_XDATA_KEY,
-                                                    (void **) &stbuf);
-                                if (ret)
-                                        continue;
-                                gf_uuid_copy (args.gfid, stbuf->ia_gfid);
-                                args.ia_type = stbuf->ia_type;
-                                break;
-                        }
-                }
+__afr_inode_write_finalize(call_frame_t *frame, xlator_t *this)
+{
+    int i = 0;
+    int ret = 0;
+    int read_subvol = 0;
+    struct iatt *stbuf = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+
+    local = frame->local;
+    priv = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, local->inode, out);
+
+    /*This code needs to stay till DHT sends fops on linked
+     * inodes*/
+    if (!inode_is_linked(local->inode)) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (!local->replies[i].valid)
+                continue;
+            if (local->replies[i].op_ret == -1)
+                continue;
+            if (!gf_uuid_is_null(local->replies[i].poststat.ia_gfid)) {
+                gf_uuid_copy(args.gfid, local->replies[i].poststat.ia_gfid);
+                args.ia_type = local->replies[i].poststat.ia_type;
+                break;
+            } else {
+                ret = dict_get_bin(local->replies[i].xdata,
+                                   DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+                if (ret)
+                    continue;
+                gf_uuid_copy(args.gfid, stbuf->ia_gfid);
+                args.ia_type = stbuf->ia_type;
+                break;
+            }
+        }
+    }
+
+    if (local->transaction.type == AFR_METADATA_TRANSACTION) {
+        read_subvol = afr_metadata_subvol_get(local->inode, this, NULL,
+                                              local->readable, NULL, &args);
+    } else {
+        read_subvol = afr_data_subvol_get(local->inode, this, NULL,
+                                          local->readable, NULL, &args);
+    }
+
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    afr_pick_error_xdata(local, priv, local->inode, local->readable, NULL,
+                         NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0)
+            continue;
+
+        /* Order of checks in the compound conditional
+           below is important.
+
+           - Highest precedence: largest op_ret
+           - Next precedence: if all op_rets are equal, read subvol
+           - Least precedence: any succeeded subvol
+        */
+        if ((local->op_ret < local->replies[i].op_ret) ||
+            ((local->op_ret == local->replies[i].op_ret) &&
+             (i == read_subvol))) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+
+            local->cont.inode_wfop.prebuf = local->replies[i].prestat;
+            local->cont.inode_wfop.postbuf = local->replies[i].poststat;
+
+            if (local->replies[i].xdata) {
+                if (local->xdata_rsp)
+                    dict_unref(local->xdata_rsp);
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+            if (local->replies[i].xattr) {
+                if (local->xattr_rsp)
+                    dict_unref(local->xattr_rsp);
+                local->xattr_rsp = dict_ref(local->replies[i].xattr);
+            }
         }
+    }
 
-	if (local->inode) {
-		if (local->transaction.type == AFR_METADATA_TRANSACTION)
-                        read_subvol = afr_metadata_subvol_get (local->inode,
-                                      this, NULL, local->readable, NULL, &args);
-		else
-			read_subvol = afr_data_subvol_get (local->inode, this,
-                                            NULL, local->readable, NULL, &args);
-	}
-
-	local->op_ret = -1;
-	local->op_errno = afr_final_errno (local, priv);
-        afr_pick_error_xdata (local, priv, local->inode, local->readable, NULL,
-                              NULL);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret < 0)
-			continue;
-
-		/* Order of checks in the compound conditional
-		   below is important.
-
-		   - Highest precedence: largest op_ret
-		   - Next precendence: if all op_rets are equal, read subvol
-		   - Least precedence: any succeeded subvol
-		*/
-		if ((local->op_ret < local->replies[i].op_ret) ||
-		    ((local->op_ret == local->replies[i].op_ret) &&
-		     (i == read_subvol))) {
-
-			local->op_ret = local->replies[i].op_ret;
-			local->op_errno = local->replies[i].op_errno;
-
-			local->cont.inode_wfop.prebuf =
-				local->replies[i].prestat;
-			local->cont.inode_wfop.postbuf =
-				local->replies[i].poststat;
-
-			if (local->replies[i].xdata) {
-				if (local->xdata_rsp)
-					dict_unref (local->xdata_rsp);
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			}
-			if (local->replies[i].xattr) {
-				if (local->xattr_rsp)
-					dict_unref (local->xattr_rsp);
-				local->xattr_rsp =
-					dict_ref (local->replies[i].xattr);
-			}
-		}
-	}
-
-        afr_set_in_flight_sb_status (this, local, local->inode);
+    afr_set_in_flight_sb_status(this, frame, local->inode);
+out:
+    return;
 }
 
-
 static void
-__afr_inode_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
-			int op_ret, int op_errno,
-			struct iatt *prebuf, struct iatt *postbuf,
-			dict_t *xattr, dict_t *xdata)
+__afr_inode_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
+                       int op_ret, int op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	local->replies[child_index].valid = 1;
+    local->replies[child_index].valid = 1;
 
-        if (AFR_IS_ARBITER_BRICK(priv, child_index) && op_ret == 1)
-                op_ret = iov_length (local->cont.writev.vector,
-                                     local->cont.writev.count);
+    if (AFR_IS_ARBITER_BRICK(priv, child_index) && op_ret == 1)
+        op_ret = iov_length(local->cont.writev.vector,
+                            local->cont.writev.count);
 
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
 
-	if (op_ret >= 0) {
-		if (prebuf)
-			local->replies[child_index].prestat = *prebuf;
-		if (postbuf)
-			local->replies[child_index].poststat = *postbuf;
-		if (xattr)
-			local->replies[child_index].xattr = dict_ref (xattr);
-	} else {
-		afr_transaction_fop_failed (frame, this, child_index);
-	}
+    if (op_ret >= 0) {
+        if (prebuf)
+            local->replies[child_index].prestat = *prebuf;
+        if (postbuf)
+            local->replies[child_index].poststat = *postbuf;
+        if (xattr)
+            local->replies[child_index].xattr = dict_ref(xattr);
+    } else {
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
 
-        return;
+    return;
 }
 
-
 static int
-__afr_inode_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
-{
-        afr_local_t *local = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_private_t *priv = NULL;
-
-        priv = this->private;
-        local = frame->local;
-
-        LOCK (&frame->lock);
-        {
-                __afr_inode_write_fill (frame, this, child_index, op_ret,
-					op_errno, prebuf, postbuf, xattr,
-					xdata);
+__afr_inode_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    LOCK(&frame->lock);
+    {
+        __afr_inode_write_fill(frame, this, child_index, op_ret, op_errno,
+                               prebuf, postbuf, xattr, xdata);
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        __afr_inode_write_finalize(frame, this);
+
+        if (afr_txn_nothing_failed(frame, this)) {
+            /*if it did pre-op, it will do post-op changing ctime*/
+            if (priv->consistent_metadata && afr_needs_changelog_update(local))
+                afr_zero_fill_stat(local);
+            local->transaction.unwind(frame, this);
         }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
 
-        if (call_count == 0) {
-		__afr_inode_write_finalize (frame, this);
-
-		if (afr_txn_nothing_failed (frame, this)) {
-                        /*if it did pre-op, it will do post-op changing ctime*/
-                        if (priv->consistent_metadata &&
-                            afr_needs_changelog_update (local))
-                                afr_zero_fill_stat (local);
-                        local->transaction.unwind (frame, this);
-                }
-
-                local->transaction.resume (frame, this);
-        }
+        afr_transaction_resume(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* {{{ writev */
 
 void
-afr_writev_copy_outvars (call_frame_t *src_frame, call_frame_t *dst_frame)
+afr_writev_copy_outvars(call_frame_t *src_frame, call_frame_t *dst_frame)
 {
-        afr_local_t *src_local = NULL;
-        afr_local_t *dst_local = NULL;
+    afr_local_t *src_local = NULL;
+    afr_local_t *dst_local = NULL;
 
-        src_local = src_frame->local;
-        dst_local = dst_frame->local;
+    src_local = src_frame->local;
+    dst_local = dst_frame->local;
 
-        dst_local->op_ret = src_local->op_ret;
-        dst_local->op_errno = src_local->op_errno;
-        dst_local->cont.inode_wfop.prebuf = src_local->cont.inode_wfop.prebuf;
-        dst_local->cont.inode_wfop.postbuf = src_local->cont.inode_wfop.postbuf;
-	if (src_local->xdata_rsp)
-		dst_local->xdata_rsp = dict_ref (src_local->xdata_rsp);
+    dst_local->op_ret = src_local->op_ret;
+    dst_local->op_errno = src_local->op_errno;
+    dst_local->cont.inode_wfop.prebuf = src_local->cont.inode_wfop.prebuf;
+    dst_local->cont.inode_wfop.postbuf = src_local->cont.inode_wfop.postbuf;
+    if (src_local->xdata_rsp)
+        dst_local->xdata_rsp = dict_ref(src_local->xdata_rsp);
 }
 
 void
-afr_writev_unwind (call_frame_t *frame, xlator_t *this)
+afr_writev_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = this->private;
 
-        local = frame->local;
+    local = frame->local;
 
-       if (priv->consistent_metadata)
-               afr_zero_fill_stat (local);
+    if (priv->consistent_metadata)
+        afr_zero_fill_stat(local);
 
-        AFR_STACK_UNWIND (writev, frame,
-                          local->op_ret, local->op_errno,
-                          &local->cont.inode_wfop.prebuf,
-                          &local->cont.inode_wfop.postbuf,
-                          local->xdata_rsp);
+    AFR_STACK_UNWIND(writev, frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
 }
 
-
 int
-afr_transaction_writev_unwind (call_frame_t *frame, xlator_t *this)
+afr_transaction_writev_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *fop_frame = NULL;
+    call_frame_t *fop_frame = NULL;
 
-        fop_frame = afr_transaction_detach_fop_frame (frame);
+    fop_frame = afr_transaction_detach_fop_frame(frame);
 
-        if (fop_frame) {
-                afr_writev_copy_outvars (frame, fop_frame);
-                afr_writev_unwind (fop_frame, this);
-        }
-        return 0;
+    if (fop_frame) {
+        afr_writev_copy_outvars(frame, fop_frame);
+        afr_writev_unwind(fop_frame, this);
+    }
+    return 0;
 }
 
 static void
-afr_writev_handle_short_writes (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int           i      = 0;
-
-        local = frame->local;
-        priv = this->private;
-        /*
-         * We already have the best case result of the writev calls staged
-         * as the return value. Any writev that returns some value less
-         * than the best case is now out of sync, so mark the fop as
-         * failed. Note that fops that have returned with errors have
-         * already been marked as failed.
-         */
-        for (i = 0; i < priv->child_count; i++) {
-                if ((!local->replies[i].valid) ||
-                    (local->replies[i].op_ret == -1))
-                        continue;
-
-                if (local->replies[i].op_ret < local->op_ret)
-                        afr_transaction_fop_failed (frame, this, i);
-        }
+afr_writev_handle_short_writes(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+    /*
+     * We already have the best case result of the writev calls staged
+     * as the return value. Any writev that returns some value less
+     * than the best case is now out of sync, so mark the fop as
+     * failed. Note that fops that have returned with errors have
+     * already been marked as failed.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if ((!local->replies[i].valid) || (local->replies[i].op_ret == -1))
+            continue;
+
+        if (local->replies[i].op_ret < local->op_ret)
+            afr_transaction_fop_failed(frame, this, i);
+    }
 }
 
 void
-afr_inode_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
+afr_inode_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                      struct iatt *postbuf, dict_t *xdata)
 {
-        int ret = 0;
-        afr_local_t *local = frame->local;
-        uint32_t open_fd_count = 0;
-        uint32_t write_is_append = 0;
-
-        LOCK (&frame->lock);
-        {
-                __afr_inode_write_fill (frame, this, child_index, op_ret,
-					op_errno, prebuf, postbuf, NULL, xdata);
-		if (op_ret == -1 || !xdata)
-			goto unlock;
-
-		write_is_append = 0;
-		ret = dict_get_uint32 (xdata, GLUSTERFS_WRITE_IS_APPEND,
-				       &write_is_append);
-		if (ret || !write_is_append)
-			local->append_write = _gf_false;
-
-		ret = dict_get_uint32 (xdata, GLUSTERFS_OPEN_FD_COUNT,
-				       &open_fd_count);
-		if (ret == -1)
-			goto unlock;
-		if (open_fd_count > local->open_fd_count) {
-                        local->open_fd_count = open_fd_count;
-                        local->update_open_fd_count = _gf_true;
-		}
+    int ret = 0;
+    afr_local_t *local = frame->local;
+    uint32_t open_fd_count = 0;
+    uint32_t write_is_append = 0;
+    int32_t num_inodelks = 0;
+
+    LOCK(&frame->lock);
+    {
+        __afr_inode_write_fill(frame, this, child_index, op_ret, op_errno,
+                               prebuf, postbuf, NULL, xdata);
+        if (op_ret == -1 || !xdata)
+            goto unlock;
+
+        write_is_append = 0;
+        ret = dict_get_uint32(xdata, GLUSTERFS_WRITE_IS_APPEND,
+                              &write_is_append);
+        if (ret || !write_is_append)
+            local->append_write = _gf_false;
+
+        ret = dict_get_uint32(xdata, GLUSTERFS_ACTIVE_FD_COUNT, &open_fd_count);
+        if (ret < 0)
+            goto unlock;
+        if (open_fd_count > local->open_fd_count) {
+            local->open_fd_count = open_fd_count;
+            local->update_open_fd_count = _gf_true;
         }
+
+        ret = dict_get_int32_sizen(xdata, GLUSTERFS_INODELK_COUNT,
+                                   &num_inodelks);
+        if (ret < 0)
+            goto unlock;
+        if (num_inodelks > local->num_inodelks) {
+            local->num_inodelks = num_inodelks;
+            local->update_num_inodelks = _gf_true;
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 }
 
 void
-afr_process_post_writev (call_frame_t *frame, xlator_t *this)
+afr_process_post_writev(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t     *local = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    afr_lock_t *lock = NULL;
 
-        if (!local->stable_write && !local->append_write)
-                /* An appended write removes the necessity to
-                   fsync() the file. This is because self-heal
-                   has the logic to check for larger file when
-                   the xattrs are not reliably pointing at
-                   a stale file.
-                */
-                afr_fd_report_unstable_write (this, local->fd);
+    local = frame->local;
 
-        __afr_inode_write_finalize (frame, this);
+    if (!local->stable_write && !local->append_write)
+        /* An appended write removes the necessity to
+           fsync() the file. This is because self-heal
+           has the logic to check for larger file when
+           the xattrs are not reliably pointing at
+           a stale file.
+        */
+        afr_fd_report_unstable_write(this, local);
 
-        afr_writev_handle_short_writes (frame, this);
+    __afr_inode_write_finalize(frame, this);
 
-        if (local->update_open_fd_count)
-                afr_handle_open_fd_count (frame, this);
+    afr_writev_handle_short_writes(frame, this);
 
+    if (local->update_open_fd_count)
+        local->inode_ctx->open_fd_count = local->open_fd_count;
+    if (local->update_num_inodelks &&
+        local->transaction.type == AFR_DATA_TRANSACTION) {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        lock->num_inodelks = local->num_inodelks;
+    }
 }
 
 int
-afr_writev_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata)
+afr_writev_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
-        call_frame_t    *fop_frame = NULL;
-        int child_index = (long) cookie;
-        int call_count  = -1;
-
-        local = frame->local;
-
-        afr_inode_write_fill (frame, this, child_index, op_ret, op_errno,
-                              prebuf, postbuf, xdata);
-
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                afr_process_post_writev (frame, this);
-
-                if (!afr_txn_nothing_failed (frame, this)) {
-                        //Don't unwind until post-op is complete
-                        local->transaction.resume (frame, this);
-                } else {
-                /*
-                 * Generally inode-write fops do transaction.unwind then
-                 * transaction.resume, but writev needs to make sure that
-                 * delayed post-op frame is placed in fdctx before unwind
-                 * happens. This prevents the race of flush doing the
-                 * changelog wakeup first in fuse thread and then this
-                 * writev placing its delayed post-op frame in fdctx.
-                 * This helps flush make sure all the delayed post-ops are
-                 * completed.
-                 */
-
-                        fop_frame = afr_transaction_detach_fop_frame (frame);
-                        afr_writev_copy_outvars (frame, fop_frame);
-                        local->transaction.resume (frame, this);
-                        afr_writev_unwind (fop_frame, this);
-                }
+    call_frame_t *fop_frame = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+
+    afr_inode_write_fill(frame, this, child_index, op_ret, op_errno, prebuf,
+                         postbuf, xdata);
+
+    call_count = afr_frame_return(frame);
+
+    if (call_count == 0) {
+        afr_process_post_writev(frame, this);
+
+        if (!afr_txn_nothing_failed(frame, this)) {
+            // Don't unwind until post-op is complete
+            afr_transaction_resume(frame, this);
+        } else {
+            /*
+             * Generally inode-write fops do transaction.unwind then
+             * transaction.resume, but writev needs to make sure that
+             * delayed post-op frame is placed in fdctx before unwind
+             * happens. This prevents the race of flush doing the
+             * changelog wakeup first in fuse thread and then this
+             * writev placing its delayed post-op frame in fdctx.
+             * This helps flush make sure all the delayed post-ops are
+             * completed.
+             */
+
+            fop_frame = afr_transaction_detach_fop_frame(frame);
+            afr_writev_copy_outvars(frame, fop_frame);
+            afr_transaction_resume(frame, this);
+            afr_writev_unwind(fop_frame, this);
         }
-        return 0;
+    }
+    return 0;
 }
 
 static int
-afr_arbiter_writev_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_arbiter_writev_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = frame->local;
-        afr_private_t *priv = this->private;
-        static char byte = 0xFF;
-        static struct iovec vector = {&byte, 1};
-        int32_t count = 1;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    static char byte = 0xFF;
+    static struct iovec vector = {&byte, 1};
+    int32_t count = 1;
 
-        STACK_WIND_COOKIE (frame, afr_writev_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->writev,
-			   local->fd, &vector, count, local->cont.writev.offset,
-			   local->cont.writev.flags, local->cont.writev.iobref,
-			   local->xdata_req);
+    STACK_WIND_COOKIE(
+        frame, afr_writev_wind_cbk, (void *)(long)subvol,
+        priv->children[subvol], priv->children[subvol]->fops->writev, local->fd,
+        &vector, count, local->cont.writev.offset, local->cont.writev.flags,
+        local->cont.writev.iobref, local->xdata_req);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_writev_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_writev_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
-
-        if (AFR_IS_ARBITER_BRICK(priv, subvol)) {
-                afr_arbiter_writev_wind (frame, this, subvol);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_writev_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->writev,
-			   local->fd, local->cont.writev.vector,
-			   local->cont.writev.count, local->cont.writev.offset,
-			   local->cont.writev.flags, local->cont.writev.iobref,
-			   local->xdata_req);
+    if (AFR_IS_ARBITER_BRICK(priv, subvol)) {
+        afr_arbiter_writev_wind(frame, this, subvol);
         return 0;
-}
+    }
 
+    STACK_WIND_COOKIE(frame, afr_writev_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->writev, local->fd,
+                      local->cont.writev.vector, local->cont.writev.count,
+                      local->cont.writev.offset, local->cont.writev.flags,
+                      local->cont.writev.iobref, local->xdata_req);
+    return 0;
+}
 
 int
-afr_do_writev (call_frame_t *frame, xlator_t *this)
+afr_do_writev(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t    *transaction_frame = NULL;
-        afr_local_t     *local             = NULL;
-        int             ret   = -1;
-        int             op_errno = ENOMEM;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    call_frame_t *transaction_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        local = frame->local;
-        transaction_frame->local = local;
-	frame->local = NULL;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	if (!AFR_FRAME_INIT (frame, op_errno))
-		goto out;
+    local = frame->local;
+    transaction_frame->local = local;
+    frame->local = NULL;
 
-        local->op = GF_FOP_WRITE;
+    if (!AFR_FRAME_INIT(frame, op_errno))
+        goto out;
 
-        local->transaction.wind   = afr_writev_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_transaction_writev_unwind;
+    local->op = GF_FOP_WRITE;
 
-        local->transaction.main_frame = frame;
+    local->transaction.wind = afr_writev_wind;
+    local->transaction.unwind = afr_transaction_writev_unwind;
 
-        if (local->fd->flags & O_APPEND) {
-               /*
-                * Backend vfs ignores the 'offset' for append mode fd so
-                * locking just the region provided for the writev does not
-                * give consistency guarantee. The actual write may happen at a
-                * completely different range than the one provided by the
-                * offset, len in the fop. So lock the entire file.
-                */
-                local->transaction.start   = 0;
-                local->transaction.len     = 0;
-        } else {
-                local->transaction.start   = local->cont.writev.offset;
-                local->transaction.len     = iov_length (local->cont.writev.vector,
-                                                         local->cont.writev.count);
-        }
+    local->transaction.main_frame = frame;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-            op_errno = -ret;
-            goto out;
-        }
-
-	return 0;
+    if (local->fd->flags & O_APPEND) {
+        /*
+         * Backend vfs ignores the 'offset' for append mode fd so
+         * locking just the region provided for the writev does not
+         * give consistency guarantee. The actual write may happen at a
+         * completely different range than the one provided by the
+         * offset, len in the fop. So lock the entire file.
+         */
+        local->transaction.start = 0;
+        local->transaction.len = 0;
+    } else {
+        local->transaction.start = local->cont.writev.offset;
+        local->transaction.len = iov_length(local->cont.writev.vector,
+                                            local->cont.writev.count);
+    }
+
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-afr_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-            struct iovec *vector, int32_t count, off_t offset,
-            uint32_t flags, struct iobref *iobref, dict_t *xdata)
+afr_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    int op_errno = ENOMEM;
+    int ret = -1;
+
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local->cont.writev.vector = iov_dup(vector, count);
+    if (!local->cont.writev.vector)
+        goto out;
+    local->cont.writev.count = count;
+    local->cont.writev.offset = offset;
+    local->cont.writev.flags = flags;
+    local->cont.writev.iobref = iobref_ref(iobref);
 
-        local->cont.writev.vector = iov_dup (vector, count);
-	if (!local->cont.writev.vector)
-		goto out;
-        local->cont.writev.count      = count;
-        local->cont.writev.offset     = offset;
-        local->cont.writev.flags      = flags;
-        local->cont.writev.iobref     = iobref_ref (iobref);
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (!local->xdata_req)
+        goto out;
 
-	if (!local->xdata_req)
-		goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    if (dict_set_uint32(local->xdata_req, GLUSTERFS_ACTIVE_FD_COUNT, 4)) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	if (dict_set_uint32 (local->xdata_req, GLUSTERFS_OPEN_FD_COUNT, 4)) {
-		op_errno = ENOMEM;
-		goto out;
-	}
+    if (dict_set_str_sizen(local->xdata_req, GLUSTERFS_INODELK_DOM_COUNT,
+                           this->name)) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	if (dict_set_uint32 (local->xdata_req, GLUSTERFS_WRITE_IS_APPEND, 4)) {
-		op_errno = ENOMEM;
-		goto out;
-	}
+    if (dict_set_uint32(local->xdata_req, GLUSTERFS_WRITE_IS_APPEND, 4)) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	/* Set append_write to be true speculatively. If on any
-	   server it turns not be true, we unset it in the
-	   callback.
-	*/
-	local->append_write = _gf_true;
+    /* Set append_write to be true speculatively. If on any
+       server it turns not be true, we unset it in the
+       callback.
+    */
+    local->append_write = _gf_true;
 
-	/* detect here, but set it in writev_wind_cbk *after* the unstable
-	   write is performed
-	*/
-	local->stable_write = !!((fd->flags|flags)&(O_SYNC|O_DSYNC));
+    /* detect here, but set it in writev_wind_cbk *after* the unstable
+       write is performed
+    */
+    local->stable_write = !!((fd->flags | flags) & (O_SYNC | O_DSYNC));
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        afr_do_writev (frame, this);
+    afr_do_writev(frame, this);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ truncate */
 
 int
-afr_truncate_unwind (call_frame_t *frame, xlator_t *this)
+afr_truncate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (truncate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(truncate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_truncate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
+afr_truncate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
-		local->stable_write = _gf_false;
+    if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
+        local->stable_write = _gf_false;
 
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_truncate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_truncate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_truncate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->truncate,
-			   &local->loc, local->cont.truncate.offset,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_truncate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->truncate, &local->loc,
+                      local->cont.truncate.offset, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_truncate (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, off_t offset, dict_t *xdata)
+afr_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata)
 {
-        afr_local_t   * local = NULL;
-        call_frame_t   *transaction_frame = NULL;
-	int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.truncate.offset  = offset;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.truncate.offset = offset;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-	local->transaction.wind   = afr_truncate_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_truncate_unwind;
+    local->transaction.wind = afr_truncate_wind;
+    local->transaction.unwind = afr_truncate_unwind;
 
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-        local->op = GF_FOP_TRUNCATE;
+    local->op = GF_FOP_TRUNCATE;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = offset;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = offset;
+    local->transaction.len = 0;
 
-	/* Set it true speculatively, will get reset in afr_truncate_wind_cbk
-	   if truncate was not a NOP */
-	local->stable_write = _gf_true;
+    /* Set it true speculatively, will get reset in afr_truncate_wind_cbk
+       if truncate was not a NOP */
+    local->stable_write = _gf_true;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ ftruncate */
 
-
 int
-afr_ftruncate_unwind (call_frame_t *frame, xlator_t *this)
+afr_ftruncate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (ftruncate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(ftruncate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_ftruncate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_ftruncate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
-		local->stable_write = _gf_false;
+    if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
+        local->stable_write = _gf_false;
 
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_ftruncate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_ftruncate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_ftruncate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->ftruncate,
-			   local->fd, local->cont.ftruncate.offset,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_ftruncate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->ftruncate, local->fd,
+                      local->cont.ftruncate.offset, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-	       dict_t *xdata)
+afr_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	call_frame_t *transaction_frame = NULL;
-	int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-        local = AFR_FRAME_INIT (transaction_frame, op_errno);
-        if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.ftruncate.offset  = offset;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.ftruncate.offset = offset;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-        local->op = GF_FOP_FTRUNCATE;
+    local->op = GF_FOP_FTRUNCATE;
 
-	local->transaction.wind   = afr_ftruncate_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_ftruncate_unwind;
+    local->transaction.wind = afr_ftruncate_wind;
+    local->transaction.unwind = afr_ftruncate_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.ftruncate.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.ftruncate.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	/* Set it true speculatively, will get reset in afr_ftruncate_wind_cbk
-	   if truncate was not a NOP */
-	local->stable_write = _gf_true;
+    /* Set it true speculatively, will get reset in afr_ftruncate_wind_cbk
+       if truncate was not a NOP */
+    local->stable_write = _gf_true;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -806,1707 +788,1778 @@ out:
 /* {{{ setattr */
 
 int
-afr_setattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_setattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (setattr, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(setattr, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_setattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno,
-                      struct iatt *preop, struct iatt *postop, dict_t *xdata)
+afr_setattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *preop,
+                     struct iatt *postop, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      preop, postop, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, preop,
+                                 postop, NULL, xdata);
 }
 
-
 int
-afr_setattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_setattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_setattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->setattr,
-			   &local->loc, &local->cont.setattr.in_buf,
-			   local->cont.setattr.valid, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_setattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->setattr, &local->loc,
+                      &local->cont.setattr.in_buf, local->cont.setattr.valid,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *buf,
-	     int32_t valid, dict_t *xdata)
+afr_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *buf,
+            int32_t valid, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.setattr.in_buf = *buf;
-        local->cont.setattr.valid  = valid;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.setattr.in_buf = *buf;
+    local->cont.setattr.valid = valid;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_setattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_setattr_unwind;
+    local->transaction.wind = afr_setattr_wind;
+    local->transaction.unwind = afr_setattr_unwind;
 
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_SETATTR;
+    local->op = GF_FOP_SETATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* {{{ fsetattr */
 
 int
-afr_fsetattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fsetattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fsetattr, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fsetattr, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fsetattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *preop, struct iatt *postop, dict_t *xdata)
+afr_fsetattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                      struct iatt *postop, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      preop, postop, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, preop,
+                                 postop, NULL, xdata);
 }
 
-
 int
-afr_fsetattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fsetattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fsetattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fsetattr,
-			   local->fd, &local->cont.fsetattr.in_buf,
-			   local->cont.fsetattr.valid, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fsetattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsetattr, local->fd,
+                      &local->cont.fsetattr.in_buf, local->cont.fsetattr.valid,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fsetattr (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, struct iatt *buf, int32_t valid, dict_t *xdata)
+afr_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *buf,
+             int32_t valid, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fsetattr.in_buf = *buf;
-        local->cont.fsetattr.valid  = valid;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.fsetattr.in_buf = *buf;
+    local->cont.fsetattr.valid = valid;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fsetattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_fsetattr_unwind;
+    local->transaction.wind = afr_fsetattr_wind;
+    local->transaction.unwind = afr_fsetattr_unwind;
 
-        local->fd                 = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FSETATTR;
+    local->op = GF_FOP_FSETATTR;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* {{{ setxattr */
 
-
 int
-afr_setxattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_setxattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (setxattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(setxattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_setxattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_setxattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_setxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_setxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t      *local         = NULL;
-        afr_private_t    *priv          = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_setxattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->setxattr,
-			   &local->loc, local->cont.setxattr.dict,
-			   local->cont.setxattr.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_setxattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->setxattr, &local->loc,
+                      local->cont.setxattr.dict, local->cont.setxattr.flags,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_emptyb_set_pending_changelog_cbk (call_frame_t *frame, void *cookie,
-                                  xlator_t *this, int op_ret, int op_errno,
-                                  dict_t *xattr, dict_t *xdata)
+afr_emptyb_set_pending_changelog_cbk(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int op_ret, int op_errno,
+                                     dict_t *xattr, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int i, ret = 0;
-        char *op_type = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i, ret = 0;
+    char *op_type = NULL;
 
-        local = frame->local;
-        priv = this->private;
-        i = (long) cookie;
+    local = frame->local;
+    priv = this->private;
+    i = (long)cookie;
 
-        local->replies[i].valid = 1;
-        local->replies[i].op_ret = op_ret;
-        local->replies[i].op_errno = op_errno;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
 
-        ret = dict_get_str (local->xdata_req, "replicate-brick-op", &op_type);
-        if (ret)
-                goto out;
+    ret = dict_get_str_sizen(local->xdata_req, "replicate-brick-op", &op_type);
+    if (ret)
+        goto out;
 
-        gf_msg (this->name, op_ret ? GF_LOG_ERROR : GF_LOG_INFO,
-                op_ret ? op_errno : 0,
-                afr_get_msg_id (op_type),
-                "Set of pending xattr %s on"
-                " %s.", op_ret ? "failed" : "succeeded",
-                priv->children[i]->name);
+    gf_smsg(this->name, op_ret ? GF_LOG_ERROR : GF_LOG_INFO,
+            op_ret ? op_errno : 0, AFR_MSG_SET_PEND_XATTR, "name=%s",
+            priv->children[i]->name, "op_ret=%s",
+            op_ret ? "failed" : "succeeded", NULL);
 
 out:
-        syncbarrier_wake (&local->barrier);
-        return 0;
+    syncbarrier_wake(&local->barrier);
+    return 0;
 }
 
 int
-afr_emptyb_set_pending_changelog (call_frame_t *frame, xlator_t *this,
-                                unsigned char *locked_nodes)
+afr_emptyb_set_pending_changelog(call_frame_t *frame, xlator_t *this,
+                                 unsigned char *locked_nodes)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int ret = 0, i = 0;
-
-        local = frame->local;
-        priv = this->private;
-
-        AFR_ONLIST (locked_nodes, frame, afr_emptyb_set_pending_changelog_cbk,
-                    xattrop, &local->loc, GF_XATTROP_ADD_ARRAY,
-                    local->xattr_req, NULL);
-
-        /* It is sufficient if xattrop was successful on one child */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-
-                if (local->replies[i].op_ret == 0) {
-                        ret = 0;
-                        goto out;
-                } else {
-                        ret = afr_higher_errno (ret,
-                                                local->replies[i].op_errno);
-                }
-        }
-out:
-        return -ret;
-}
-
-int
-_afr_handle_empty_brick_type (xlator_t *this, call_frame_t *frame,
-                            loc_t *loc, int empty_index,
-                            afr_transaction_type type,
-                            char *op_type)
-{
-        int              count            = 0;
-        int              ret              = -ENOMEM;
-        int              idx              = -1;
-        int              d_idx            = -1;
-        unsigned char   *locked_nodes     = NULL;
-        afr_local_t     *local            = NULL;
-        afr_private_t   *priv             = NULL;
-
-        priv = this->private;
-        local = frame->local;
-
-        locked_nodes = alloca0 (priv->child_count);
-
-        idx = afr_index_for_transaction_type (type);
-        d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
-
-        local->pending = afr_matrix_create (priv->child_count,
-                                            AFR_NUM_CHANGE_LOGS);
-        if (!local->pending)
-                goto out;
-
-        local->pending[empty_index][idx] = hton32 (1);
-
-        if ((priv->esh_granular) && (type == AFR_ENTRY_TRANSACTION))
-                        local->pending[empty_index][d_idx] = hton32 (1);
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int ret = 0, i = 0;
 
-        local->xdata_req = dict_new ();
-        if (!local->xdata_req)
-                goto out;
-
-        ret = dict_set_str (local->xdata_req, "replicate-brick-op", op_type);
-        if (ret)
-                goto out;
+    local = frame->local;
+    priv = this->private;
 
-        local->xattr_req = dict_new ();
-        if (!local->xattr_req)
-                goto out;
+    AFR_ONLIST(locked_nodes, frame, afr_emptyb_set_pending_changelog_cbk,
+               xattrop, &local->loc, GF_XATTROP_ADD_ARRAY, local->xattr_req,
+               NULL);
 
-        ret = afr_set_pending_dict (priv, local->xattr_req, local->pending);
-        if (ret < 0)
-                goto out;
+    /* It is sufficient if xattrop was successful on one child */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
 
-        if (AFR_ENTRY_TRANSACTION == type) {
-                count = afr_selfheal_entrylk (frame, this, loc->inode,
-                                              this->name, NULL, locked_nodes);
+        if (local->replies[i].op_ret == 0) {
+            ret = 0;
+            goto out;
         } else {
-                count = afr_selfheal_inodelk (frame, this, loc->inode,
-                                              this->name, LLONG_MAX - 1, 0,
-                                              locked_nodes);
-        }
-
-        if (!count) {
-                gf_msg (this->name, GF_LOG_ERROR, EAGAIN,
-                        AFR_MSG_REPLACE_BRICK_STATUS, "Couldn't acquire lock on"
-                        " any child.");
-                ret = -EAGAIN;
-                goto unlock;
+            ret = afr_higher_errno(ret, local->replies[i].op_errno);
         }
+    }
+out:
+    return -ret;
+}
 
-        ret = afr_emptyb_set_pending_changelog (frame, this, locked_nodes);
-        if (ret)
-                goto unlock;
-        ret = 0;
+static int
+_afr_handle_empty_brick_type(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                             int empty_index, afr_transaction_type type,
+                             char *op_type, const int op_type_len)
+{
+    int count = 0;
+    int ret = -ENOMEM;
+    int idx = -1;
+    int d_idx = -1;
+    unsigned char *locked_nodes = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    locked_nodes = alloca0(priv->child_count);
+
+    idx = afr_index_for_transaction_type(type);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
+
+    local->pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!local->pending)
+        goto out;
+
+    local->pending[empty_index][idx] = hton32(1);
+
+    if ((priv->esh_granular) && (type == AFR_ENTRY_TRANSACTION))
+        local->pending[empty_index][d_idx] = hton32(1);
+
+    local->xdata_req = dict_new();
+    if (!local->xdata_req)
+        goto out;
+
+    ret = dict_set_nstrn(local->xdata_req, "replicate-brick-op",
+                         SLEN("replicate-brick-op"), op_type, op_type_len);
+    if (ret)
+        goto out;
+
+    local->xattr_req = dict_new();
+    if (!local->xattr_req)
+        goto out;
+
+    ret = afr_set_pending_dict(priv, local->xattr_req, local->pending);
+    if (ret < 0)
+        goto out;
+
+    if (AFR_ENTRY_TRANSACTION == type) {
+        count = afr_selfheal_entrylk(frame, this, loc->inode, this->name, NULL,
+                                     locked_nodes);
+    } else {
+        count = afr_selfheal_inodelk(frame, this, loc->inode, this->name,
+                                     LLONG_MAX - 1, 0, locked_nodes);
+    }
+
+    if (!count) {
+        gf_smsg(this->name, GF_LOG_ERROR, EAGAIN, AFR_MSG_REPLACE_BRICK_STATUS,
+                NULL);
+        ret = -EAGAIN;
+        goto unlock;
+    }
+
+    ret = afr_emptyb_set_pending_changelog(frame, this, locked_nodes);
+    if (ret)
+        goto unlock;
+    ret = 0;
 unlock:
-        if (AFR_ENTRY_TRANSACTION == type) {
-                afr_selfheal_unentrylk (frame, this, loc->inode, this->name,
-                                        NULL, locked_nodes, NULL);
-        } else {
-                afr_selfheal_uninodelk (frame, this, loc->inode, this->name,
-                                        LLONG_MAX - 1, 0, locked_nodes);
-        }
+    if (AFR_ENTRY_TRANSACTION == type) {
+        afr_selfheal_unentrylk(frame, this, loc->inode, this->name, NULL,
+                               locked_nodes, NULL);
+    } else {
+        afr_selfheal_uninodelk(frame, this, loc->inode, this->name,
+                               LLONG_MAX - 1, 0, locked_nodes);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void
-afr_brick_args_cleanup (void *opaque)
-{
-        afr_empty_brick_args_t *data = NULL;
-
-        data = opaque;
-        loc_wipe (&data->loc);
-        GF_FREE (data);
-}
-
-int
-_afr_handle_empty_brick_cbk (int ret, call_frame_t *frame, void *opaque)
-{
-        afr_brick_args_cleanup (opaque);
-        return 0;
-}
-
-int
-_afr_handle_empty_brick (void *opaque)
-{
-
-        afr_local_t     *local          = NULL;
-        afr_private_t   *priv           = NULL;
-        int              empty_index       = -1;
-        int              ret            = -1;
-        int              op_errno       = ENOMEM;
-        call_frame_t    *frame          = NULL;
-        xlator_t        *this           = NULL;
-        char            *op_type        = NULL;
-        afr_empty_brick_args_t *data  = NULL;
-
-        data = opaque;
-        frame = data->frame;
-        empty_index = data->empty_index;
-        op_type = data->op_type;
-        this = frame->this;
-        priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        loc_copy (&local->loc, &data->loc);
-
-        gf_msg (this->name, GF_LOG_INFO, 0, 0, "New brick is : %s",
-                priv->children[empty_index]->name);
-
-        ret = _afr_handle_empty_brick_type (this, frame, &local->loc, empty_index,
-                                          AFR_METADATA_TRANSACTION, op_type);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        dict_unref (local->xdata_req);
-        dict_unref (local->xattr_req);
-        afr_matrix_cleanup (local->pending, priv->child_count);
-        local->pending = NULL;
-        local->xattr_req = NULL;
-        local->xdata_req = NULL;
-
-        ret = _afr_handle_empty_brick_type (this, frame, &local->loc, empty_index,
-                                          AFR_ENTRY_TRANSACTION, op_type);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+afr_brick_args_cleanup(void *opaque)
+{
+    afr_empty_brick_args_t *data = NULL;
+
+    data = opaque;
+    loc_wipe(&data->loc);
+    GF_FREE(data);
+}
+
+int
+_afr_handle_empty_brick_cbk(int ret, call_frame_t *frame, void *opaque)
+{
+    afr_brick_args_cleanup(opaque);
+    return 0;
+}
+
+int
+_afr_handle_empty_brick(void *opaque)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int empty_index = -1;
+    int ret = -1;
+    int op_errno = ENOMEM;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    char *op_type = NULL;
+    int op_type_len = 0;
+    afr_empty_brick_args_t *data = NULL;
+    call_frame_t *op_frame = NULL;
+
+    data = opaque;
+    frame = data->frame;
+    empty_index = data->empty_index;
+    if (!data->op_type)
+        goto out;
+
+    op_frame = copy_frame(frame);
+    if (!op_frame) {
+        ret = -1;
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    op_type = data->op_type;
+    op_type_len = strlen(op_type);
+    this = op_frame->this;
+    priv = this->private;
+
+    afr_set_lk_owner(op_frame, this, op_frame->root);
+    local = AFR_FRAME_INIT(op_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, &data->loc);
+
+    gf_smsg(this->name, GF_LOG_INFO, 0, AFR_MSG_NEW_BRICK, "name=%s",
+            priv->children[empty_index]->name, NULL);
+
+    ret = _afr_handle_empty_brick_type(this, op_frame, &local->loc, empty_index,
+                                       AFR_METADATA_TRANSACTION, op_type,
+                                       op_type_len);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    dict_unref(local->xdata_req);
+    dict_unref(local->xattr_req);
+    afr_matrix_cleanup(local->pending, priv->child_count);
+    local->pending = NULL;
+    local->xattr_req = NULL;
+    local->xdata_req = NULL;
+
+    ret = _afr_handle_empty_brick_type(this, op_frame, &local->loc, empty_index,
+                                       AFR_ENTRY_TRANSACTION, op_type,
+                                       op_type_len);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 out:
-        AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        return 0;
+    if (op_frame) {
+        AFR_STACK_DESTROY(op_frame);
+    }
+    AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    return 0;
+}
+
+int
+afr_split_brain_resolve_do(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                           char *data)
+{
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    local->xdata_req = dict_new();
+
+    if (!local->xdata_req) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(local->xdata_req, "heal-op",
+                               GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str_sizen(local->xdata_req, "child-name", data);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    /* set spb choice to -1 whether heal succeeds or not:
+     * If heal succeeds : spb-choice should be set to -1 as
+     *                    it is no longer valid; file is not
+     *                    in split-brain anymore.
+     * If heal doesn't succeed:
+     *                    spb-choice should be set to -1
+     *                    otherwise reads will be served
+     *                    from spb-choice which is misleading.
+     */
+    ret = afr_inode_split_brain_choice_set(loc->inode, this, -1);
+    if (ret)
+        gf_smsg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN_SET_FAILED,
+                NULL);
+    afr_heal_splitbrain_file(frame, this, loc);
+    ret = 0;
+out:
+    if (ret < 0)
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-afr_split_brain_resolve_do (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                            char *data)
+afr_get_split_brain_child_index(xlator_t *this, void *value, size_t len)
 {
-        afr_local_t    *local             = NULL;
-        int     ret                       = -1;
-        int     op_errno                  = EINVAL;
+    int spb_child_index = -1;
+    char *spb_child_str = NULL;
 
-        local = frame->local;
-        local->xdata_req = dict_new ();
+    spb_child_str = alloca0(len + 1);
+    memcpy(spb_child_str, value, len);
 
-        if (!local->xdata_req) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (!strcmp(spb_child_str, "none"))
+        return -2;
 
-        ret = dict_set_int32 (local->xdata_req, "heal-op",
-                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str (local->xdata_req, "child-name", data);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        /* set spb choice to -1 whether heal succeeds or not:
-         * If heal succeeds : spb-choice should be set to -1 as
-         *                    it is no longer valid; file is not
-         *                    in split-brain anymore.
-         * If heal doesn't succeed:
-         *                    spb-choice should be set to -1
-         *                    otherwise reads will be served
-         *                    from spb-choice which is misleading.
-         */
-        ret = afr_inode_split_brain_choice_set (loc->inode, this, -1);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR, "Failed to set"
-                        "split-brain choice to -1");
-        afr_heal_splitbrain_file (frame, this, loc);
-        ret = 0;
-out:
-        if (ret < 0)
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-        return 0;
+    spb_child_index = afr_get_child_index_from_name(this, spb_child_str);
+    if (spb_child_index < 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                "subvol=%s", spb_child_str, NULL);
+    }
+    return spb_child_index;
 }
 
 int
-afr_get_split_brain_child_index (xlator_t *this, void *value, size_t len)
+afr_can_set_split_brain_choice(void *opaque)
 {
-        int             spb_child_index   = -1;
-        char           *spb_child_str     = NULL;
+    afr_spbc_timeout_t *data = opaque;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    loc_t *loc = NULL;
+    int ret = -1;
 
-        spb_child_str =  alloca0 (len + 1);
-        memcpy (spb_child_str, value, len);
+    frame = data->frame;
+    loc = data->loc;
+    this = frame->this;
 
-        if (!strcmp (spb_child_str, "none"))
-                return -2;
+    ret = afr_is_split_brain(frame, this, loc->inode, loc->gfid, &data->d_spb,
+                             &data->m_spb);
 
-        spb_child_index = afr_get_child_index_from_name (this,
-                                                         spb_child_str);
-        if (spb_child_index < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_SUBVOL, "Invalid subvol: %s",
-                        spb_child_str);
-        }
-        return spb_child_index;
+    if (ret)
+        gf_smsg(this->name, GF_LOG_ERROR, 0,
+                AFR_MSG_SPLIT_BRAIN_DETERMINE_FAILED, "gfid=%s",
+                uuid_utoa(loc->gfid), NULL);
+    return ret;
 }
 
 int
-afr_can_set_split_brain_choice (void *opaque)
+afr_handle_split_brain_commands(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                                dict_t *dict)
 {
-        afr_spbc_timeout_t        *data         = opaque;
-        call_frame_t              *frame        = NULL;
-        xlator_t                  *this         = NULL;
-        loc_t                     *loc          = NULL;
-        int                        ret          = -1;
+    void *choice_value = NULL;
+    void *resolve_value = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_spbc_timeout_t *data = NULL;
+    int len = 0;
+    int spb_child_index = -1;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        frame = data->frame;
-        loc = data->loc;
-        this = frame->this;
+    priv = this->private;
 
-        ret = afr_is_split_brain (frame, this, loc->inode, loc->gfid,
-                                  &data->d_spb, &data->m_spb);
+    ret = dict_get_ptr_and_len(dict, GF_AFR_SBRAIN_CHOICE, &choice_value, &len);
+    ret = dict_get_ptr_and_len(dict, GF_AFR_SBRAIN_RESOLVE, &resolve_value,
+                               &len);
+    if (!choice_value && !resolve_value) {
+        ret = -1;
+        goto out;
+    }
 
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                        "Failed to determine if %s"
-                        " is in split-brain. "
-                        "Aborting split-brain-choice set.",
-                        uuid_utoa (loc->gfid));
-        return ret;
-}
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local) {
+        ret = 1;
+        goto out;
+    }
 
-int
-afr_handle_split_brain_commands (xlator_t *this, call_frame_t *frame,
-                                loc_t *loc, dict_t *dict)
-{
-        void           *value             = NULL;
-        afr_private_t  *priv              = NULL;
-        afr_local_t    *local             = NULL;
-        afr_spbc_timeout_t *data          = NULL;
-        int             len               = 0;
-        int             spb_child_index   = -1;
-        int             ret               = -1;
-        int             op_errno          = EINVAL;
+    local->op = GF_FOP_SETXATTR;
 
-        priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local) {
+    if (choice_value) {
+        spb_child_index = afr_get_split_brain_child_index(this, choice_value,
+                                                          len);
+        if (spb_child_index < 0) {
+            /* Case where value was "none" */
+            if (spb_child_index == -2)
+                spb_child_index = -1;
+            else {
                 ret = 1;
+                op_errno = EINVAL;
                 goto out;
+            }
         }
 
-        local->op = GF_FOP_SETXATTR;
-
-        ret =  dict_get_ptr_and_len (dict, GF_AFR_SBRAIN_CHOICE, &value,
-                                     &len);
-        if (value) {
-                spb_child_index = afr_get_split_brain_child_index (this, value,
-                                                                   len);
-                if (spb_child_index < 0) {
-                        /* Case where value was "none" */
-                        if (spb_child_index == -2)
-                                spb_child_index = -1;
-                        else {
-                                ret = 1;
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                }
-
-                data = GF_CALLOC (1, sizeof (*data), gf_afr_mt_spbc_timeout_t);
-                if (!data) {
-                        ret = 1;
-                        goto out;
-                }
-                data->spb_child_index = spb_child_index;
-                data->frame = frame;
-                loc_copy (&local->loc, loc);
-                data->loc = &local->loc;
-                ret = synctask_new (this->ctx->env,
-                                    afr_can_set_split_brain_choice,
-                                    afr_set_split_brain_choice, NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to create"
-                                " synctask. Aborting split-brain choice set"
-                                " for %s", loc->name);
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                ret = 0;
-                goto out;
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_spbc_timeout_t);
+        if (!data) {
+            ret = 1;
+            goto out;
+        }
+        data->spb_child_index = spb_child_index;
+        data->frame = frame;
+        loc_copy(&local->loc, loc);
+        data->loc = &local->loc;
+        ret = synctask_new(this->ctx->env, afr_can_set_split_brain_choice,
+                           afr_set_split_brain_choice, NULL, data);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN_STATUS,
+                    "name=%s", loc->name, NULL);
+            ret = 1;
+            op_errno = ENOMEM;
+            goto out;
         }
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_get_ptr_and_len (dict, GF_AFR_SBRAIN_RESOLVE, &value, &len);
-        if (value) {
-                spb_child_index = afr_get_split_brain_child_index (this, value,
-                                                                   len);
-                if (spb_child_index < 0) {
-                        ret = 1;
-                        goto out;
-                }
-
-                afr_split_brain_resolve_do (frame, this, loc,
-                                            priv->children[spb_child_index]->name);
-                ret = 0;
+    if (resolve_value) {
+        spb_child_index = afr_get_split_brain_child_index(this, resolve_value,
+                                                          len);
+        if (spb_child_index < 0) {
+            ret = 1;
+            goto out;
         }
+
+        afr_split_brain_resolve_do(frame, this, loc,
+                                   priv->children[spb_child_index]->name);
+        ret = 0;
+    }
 out:
-        /* key was correct but value was invalid when ret == 1 */
-        if (ret == 1) {
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-                if (data)
-                        GF_FREE (data);
-                ret = 0;
-        }
-        return ret;
+    /* key was correct but value was invalid when ret == 1 */
+    if (ret == 1) {
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+        if (data)
+            GF_FREE(data);
+        ret = 0;
+    }
+    return ret;
 }
 
 int
-afr_handle_spb_choice_timeout (xlator_t *this, call_frame_t *frame,
-                               dict_t *dict)
+afr_handle_spb_choice_timeout(xlator_t *this, call_frame_t *frame, dict_t *dict)
 {
-        int             ret               = -1;
-        int             op_errno          = 0;
-        uint64_t        timeout           = 0;
-        afr_private_t  *priv              = NULL;
+    int ret = -1;
+    int op_errno = 0;
+    uint64_t timeout = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        ret = dict_get_uint64 (dict, GF_AFR_SPB_CHOICE_TIMEOUT, &timeout);
-        if (!ret) {
-                priv->spb_choice_timeout = timeout * 60;
-                AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        }
+    ret = dict_get_uint64(dict, GF_AFR_SPB_CHOICE_TIMEOUT, &timeout);
+    if (!ret) {
+        priv->spb_choice_timeout = timeout * 60;
+        AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-afr_handle_empty_brick (xlator_t *this, call_frame_t *frame, loc_t *loc,
-                        dict_t *dict)
+afr_handle_empty_brick(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                       dict_t *dict)
 {
-        int             ret               = -1;
-        int             ab_ret            = -1;
-        int             empty_index        = -1;
-        int             op_errno          = EPERM;
-        char           *empty_brick         = NULL;
-        char           *op_type           = NULL;
-        afr_empty_brick_args_t *data        = NULL;
+    int ret = -1;
+    int ab_ret = -1;
+    int empty_index = -1;
+    int op_errno = EPERM;
+    char *empty_brick = NULL;
+    char *op_type = NULL;
+    afr_empty_brick_args_t *data = NULL;
 
-        ret =  dict_get_str (dict, GF_AFR_REPLACE_BRICK, &empty_brick);
-        if (!ret)
-                op_type = GF_AFR_REPLACE_BRICK;
+    ret = dict_get_str_sizen(dict, GF_AFR_REPLACE_BRICK, &empty_brick);
+    if (!ret)
+        op_type = GF_AFR_REPLACE_BRICK;
 
-        ab_ret = dict_get_str (dict, GF_AFR_ADD_BRICK, &empty_brick);
-        if (!ab_ret)
-                op_type = GF_AFR_ADD_BRICK;
+    ab_ret = dict_get_str_sizen(dict, GF_AFR_ADD_BRICK, &empty_brick);
+    if (!ab_ret)
+        op_type = GF_AFR_ADD_BRICK;
 
-        if (ret && ab_ret)
-                goto out;
+    if (ret && ab_ret)
+        goto out;
 
-        if (frame->root->pid != GF_CLIENT_PID_SELF_HEALD) {
-                gf_msg (this->name, GF_LOG_ERROR, EPERM,
-                        afr_get_msg_id (op_type),
-                        "'%s' is an internal extended attribute.",
-                        op_type);
-                ret = 1;
-                goto out;
+    if (frame->root->pid != GF_CLIENT_PID_ADD_REPLICA_MOUNT) {
+        gf_smsg(this->name, GF_LOG_ERROR, EPERM, AFR_MSG_INTERNAL_ATTR,
+                "op_type=%s", op_type, NULL);
+        ret = 1;
+        goto out;
+    }
+    empty_index = afr_get_child_index_from_name(this, empty_brick);
+
+    if (empty_index < 0) {
+        /* Didn't belong to this replica pair
+         * Just do a no-op
+         */
+        AFR_STACK_UNWIND(setxattr, frame, 0, 0, NULL);
+        return 0;
+    } else {
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_empty_brick_t);
+        if (!data) {
+            ret = 1;
+            op_errno = ENOMEM;
+            goto out;
         }
-        empty_index = afr_get_child_index_from_name (this, empty_brick);
-
-        if (empty_index < 0) {
-                 /* Didn't belong to this replica pair
-                  * Just do a no-op
-                  */
-                AFR_STACK_UNWIND (setxattr, frame, 0, 0, NULL);
-                return 0;
-        } else {
-                data = GF_CALLOC (1, sizeof (*data),
-                                  gf_afr_mt_empty_brick_t);
-                if (!data) {
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                data->frame = frame;
-                loc_copy (&data->loc, loc);
-                data->empty_index = empty_index;
-                data->op_type = op_type;
-                ret = synctask_new (this->ctx->env,
-                                    _afr_handle_empty_brick,
-                                    _afr_handle_empty_brick_cbk,
-                                    NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                afr_get_msg_id (op_type),
-                                "Failed to create synctask.");
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        afr_brick_args_cleanup (data);
-                        goto out;
-                }
+        data->frame = frame;
+        loc_copy(&data->loc, loc);
+        data->empty_index = empty_index;
+        data->op_type = op_type;
+        ret = synctask_new(this->ctx->env, _afr_handle_empty_brick,
+                           _afr_handle_empty_brick_cbk, NULL, data);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN_STATUS,
+                    NULL);
+            ret = 1;
+            op_errno = ENOMEM;
+            afr_brick_args_cleanup(data);
+            goto out;
         }
-        ret = 0;
+    }
+    ret = 0;
 out:
-        if (ret == 1) {
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-                ret = 0;
-        }
-        return ret;
+    if (ret == 1) {
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+        ret = 0;
+    }
+    return ret;
 }
 
 static int
-afr_handle_special_xattr (xlator_t *this, call_frame_t *frame, loc_t *loc,
-                          dict_t *dict)
+afr_handle_special_xattr(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                         dict_t *dict)
 {
-        int     ret     = -1;
+    int ret = -1;
 
-        ret = afr_handle_split_brain_commands (this, frame, loc, dict);
-        if (ret == 0)
-                goto out;
+    ret = afr_handle_split_brain_commands(this, frame, loc, dict);
+    if (ret == 0)
+        goto out;
 
-        ret = afr_handle_spb_choice_timeout (this, frame, dict);
-        if (ret == 0)
-                goto out;
+    ret = afr_handle_spb_choice_timeout(this, frame, dict);
+    if (ret == 0)
+        goto out;
 
-        /* Applicable for replace-brick and add-brick commands */
-        ret = afr_handle_empty_brick (this, frame, loc, dict);
+    /* Applicable for replace-brick and add-brick commands */
+    ret = afr_handle_empty_brick(this, frame, loc, dict);
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-	      int32_t flags, dict_t *xdata)
+afr_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+             int32_t flags, dict_t *xdata)
 {
-        afr_local_t    *local             = NULL;
-        call_frame_t   *transaction_frame = NULL;
-        int             ret               = -1;
-        int             op_errno          = EINVAL;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.afr.*", dict, op_errno, out);
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.afr.*", dict, op_errno, out);
 
-        ret = afr_handle_special_xattr (this, frame, loc, dict);
-        if (ret == 0)
-                return 0;
+    ret = afr_handle_special_xattr(this, frame, loc, dict);
+    if (ret == 0)
+        return 0;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.setxattr.dict  = dict_ref (dict);
-        local->cont.setxattr.flags = flags;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.setxattr.dict = dict_ref(dict);
+    local->cont.setxattr.flags = flags;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_setxattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_setxattr_unwind;
+    local->transaction.wind = afr_setxattr_wind;
+    local->transaction.unwind = afr_setxattr_unwind;
 
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-	local->op = GF_FOP_SETXATTR;
+    local->op = GF_FOP_SETXATTR;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* {{{ fsetxattr */
 
-
 int
-afr_fsetxattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fsetxattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t    *local         = NULL;
-        call_frame_t   *main_frame    = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fsetxattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fsetxattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fsetxattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_fsetxattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_fsetxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fsetxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t        *local       = NULL;
-        afr_private_t      *priv        = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fsetxattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fsetxattr,
-			   local->fd, local->cont.fsetxattr.dict,
-			   local->cont.fsetxattr.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fsetxattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsetxattr, local->fd,
+                      local->cont.fsetxattr.dict, local->cont.fsetxattr.flags,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fsetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+afr_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+              int32_t flags, dict_t *xdata)
 {
-        afr_local_t      *local             = NULL;
-        call_frame_t     *transaction_frame = NULL;
-        int               ret               = -1;
-        int               op_errno          = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.afr.*", dict, op_errno, out);
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.afr.*", dict, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fsetxattr.dict  = dict_ref (dict);
-        local->cont.fsetxattr.flags = flags;
+    local->cont.fsetxattr.dict = dict_ref(dict);
+    local->cont.fsetxattr.flags = flags;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fsetxattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_fsetxattr_unwind;
+    local->transaction.wind = afr_fsetxattr_wind;
+    local->transaction.unwind = afr_fsetxattr_unwind;
 
-        local->fd                 = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FSETXATTR;
+    local->op = GF_FOP_FSETXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start  = LLONG_MAX - 1;
-        local->transaction.len    = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
 /* }}} */
 
-
 /* {{{ removexattr */
 
-
 int
-afr_removexattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_removexattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (removexattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(removexattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_removexattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_removexattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_removexattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_removexattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_removexattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->removexattr,
-			   &local->loc, local->cont.removexattr.name,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_removexattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->removexattr, &local->loc,
+                      local->cont.removexattr.name, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_removexattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, const char *name, dict_t *xdata)
+afr_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *name, dict_t *xdata)
 {
-        afr_local_t     *local             = NULL;
-        call_frame_t    *transaction_frame = NULL;
-        int              ret               = -1;
-        int              op_errno          = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.afr.*", name, op_errno, out);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.afr.*", name, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.removexattr.name = gf_strdup (name);
+    local->cont.removexattr.name = gf_strdup(name);
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_removexattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_removexattr_unwind;
+    local->transaction.wind = afr_removexattr_wind;
+    local->transaction.unwind = afr_removexattr_unwind;
 
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_REMOVEXATTR;
+    local->op = GF_FOP_REMOVEXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
 /* ffremovexattr */
 int
-afr_fremovexattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fremovexattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fremovexattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fremovexattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fremovexattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+afr_fremovexattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_fremovexattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fremovexattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fremovexattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fremovexattr,
-			   local->fd, local->cont.removexattr.name,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fremovexattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fremovexattr, local->fd,
+                      local->cont.removexattr.name, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		  const char *name, dict_t *xdata)
+afr_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 const char *name, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.afr.*", name, op_errno, out);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.afr.*", name, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.removexattr.name = gf_strdup (name);
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.removexattr.name = gf_strdup(name);
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fremovexattr_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_fremovexattr_unwind;
+    local->transaction.wind = afr_fremovexattr_wind;
+    local->transaction.unwind = afr_fremovexattr_unwind;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FREMOVEXATTR;
+    local->op = GF_FOP_FREMOVEXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fallocate_unwind (call_frame_t *frame, xlator_t *this)
+afr_fallocate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (fallocate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fallocate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fallocate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_fallocate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_fallocate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fallocate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fallocate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fallocate,
-			   local->fd, local->cont.fallocate.mode,
-			   local->cont.fallocate.offset,
-			   local->cont.fallocate.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fallocate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fallocate, local->fd,
+                      local->cont.fallocate.mode, local->cont.fallocate.offset,
+                      local->cont.fallocate.len, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-               off_t offset, size_t len, dict_t *xdata)
+afr_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata)
 {
-        call_frame_t *transaction_frame = NULL;
-        afr_local_t *local = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    call_frame_t *transaction_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fallocate.mode = mode;
-        local->cont.fallocate.offset  = offset;
-        local->cont.fallocate.len = len;
+    local->cont.fallocate.mode = mode;
+    local->cont.fallocate.offset = offset;
+    local->cont.fallocate.len = len;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_FALLOCATE;
+    local->op = GF_FOP_FALLOCATE;
 
-        local->transaction.wind   = afr_fallocate_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_fallocate_unwind;
+    local->transaction.wind = afr_fallocate_wind;
+    local->transaction.unwind = afr_fallocate_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.fallocate.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.fallocate.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ discard */
 
 int
-afr_discard_unwind (call_frame_t *frame, xlator_t *this)
+afr_discard_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (discard, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(discard, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_discard_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+afr_discard_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_discard_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_discard_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_discard_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->discard,
-			   local->fd, local->cont.discard.offset,
-			   local->cont.discard.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_discard_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->discard, local->fd,
+                      local->cont.discard.offset, local->cont.discard.len,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             size_t len, dict_t *xdata)
+afr_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.discard.offset  = offset;
-        local->cont.discard.len = len;
+    local->cont.discard.offset = offset;
+    local->cont.discard.len = len;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_DISCARD;
+    local->op = GF_FOP_DISCARD;
 
-        local->transaction.wind   = afr_discard_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_discard_unwind;
+    local->transaction.wind = afr_discard_wind;
+    local->transaction.unwind = afr_discard_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.discard.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.discard.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* {{{ zerofill */
 
 int
-afr_zerofill_unwind (call_frame_t *frame, xlator_t *this)
+afr_zerofill_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (discard, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(discard, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_zerofill_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+afr_zerofill_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                       struct iatt *postbuf, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_zerofill_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_zerofill_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_zerofill_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->zerofill,
-			   local->fd, local->cont.zerofill.offset,
-			   local->cont.zerofill.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_zerofill_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->zerofill, local->fd,
+                      local->cont.zerofill.offset, local->cont.zerofill.len,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+afr_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
              size_t len, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.zerofill.offset  = offset;
-        local->cont.zerofill.len = len;
+    local->cont.zerofill.offset = offset;
+    local->cont.zerofill.len = len;
 
-        local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_ZEROFILL;
+    local->op = GF_FOP_ZEROFILL;
 
-        local->transaction.wind   = afr_zerofill_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_zerofill_unwind;
+    local->transaction.wind = afr_zerofill_wind;
+    local->transaction.unwind = afr_zerofill_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.discard.offset;
-        local->transaction.len     = len;
+    local->transaction.start = local->cont.zerofill.offset;
+    local->transaction.len = len;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 int32_t
-afr_xattrop_wind_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret, int32_t op_errno,
-                      dict_t *xattr, dict_t *xdata)
+afr_xattrop_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                     dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, xattr, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, xattr, xdata);
 }
 
 int
-afr_xattrop_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_xattrop_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_xattrop_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->xattrop,
-			   &local->loc, local->cont.xattrop.optype,
-			   local->cont.xattrop.xattr, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_xattrop_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->xattrop, &local->loc,
+                      local->cont.xattrop.optype, local->cont.xattrop.xattr,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_xattrop_unwind (call_frame_t *frame, xlator_t *this)
+afr_xattrop_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (xattrop, main_frame, local->op_ret, local->op_errno,
-			  local->xattr_rsp, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
+
+    AFR_STACK_UNWIND(xattrop, main_frame, local->op_ret, local->op_errno,
+                     local->xattr_rsp, local->xdata_rsp);
+    return 0;
 }
 
 int32_t
-afr_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
+afr_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.xattrop.xattr = dict_ref (xattr);
-        local->cont.xattrop.optype = optype;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->cont.xattrop.xattr = dict_ref(xattr);
+    local->cont.xattrop.optype = optype;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        local->transaction.wind   = afr_xattrop_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_xattrop_unwind;
+    local->transaction.wind = afr_xattrop_wind;
+    local->transaction.unwind = afr_xattrop_unwind;
 
-        loc_copy (&local->loc, loc);
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_XATTROP;
+    local->op = GF_FOP_XATTROP;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (xattrop, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int32_t
-afr_fxattrop_wind_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+afr_fxattrop_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                      dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, xattr, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, xattr, xdata);
 }
 
 int
-afr_fxattrop_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fxattrop_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fxattrop_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fxattrop,
-			   local->fd, local->cont.xattrop.optype,
-			   local->cont.xattrop.xattr, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fxattrop_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fxattrop, local->fd,
+                      local->cont.xattrop.optype, local->cont.xattrop.xattr,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_fxattrop_unwind (call_frame_t *frame, xlator_t *this)
+afr_fxattrop_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fxattrop, main_frame, local->op_ret, local->op_errno,
-			  local->xattr_rsp, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
+
+    AFR_STACK_UNWIND(fxattrop, main_frame, local->op_ret, local->op_errno,
+                     local->xattr_rsp, local->xdata_rsp);
+    return 0;
 }
 
 int32_t
-afr_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
+afr_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.xattrop.xattr = dict_ref (xattr);
-        local->cont.xattrop.optype = optype;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->cont.xattrop.xattr = dict_ref(xattr);
+    local->cont.xattrop.optype = optype;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        local->transaction.wind   = afr_fxattrop_wind;
-        local->transaction.fop    = __afr_txn_write_fop;
-        local->transaction.done   = __afr_txn_write_done;
-        local->transaction.unwind = afr_fxattrop_unwind;
+    local->transaction.wind = afr_fxattrop_wind;
+    local->transaction.unwind = afr_fxattrop_unwind;
 
-	local->fd = fd_ref (fd);
-	local->inode = inode_ref (fd->inode);
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FXATTROP;
+    local->op = GF_FOP_FXATTROP;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this,
-                               AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
+
+    AFR_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
+    return 0;
+}
+
+int
+afr_fsync_unwind(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	AFR_STACK_UNWIND (fxattrop, frame, -1, op_errno, NULL, NULL);
+    local = frame->local;
+
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
+
+    AFR_STACK_UNWIND(fsync, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+
+    return 0;
+}
+
+int
+afr_fsync_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
+{
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
+}
+
+int
+afr_fsync_wind(call_frame_t *frame, xlator_t *this, int subvol)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_fsync_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsync, local->fd,
+                      local->cont.fsync.datasync, local->xdata_req);
+    return 0;
+}
+
+int
+afr_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+          dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int32_t op_errno = ENOMEM;
+    int8_t last_fsync = 0;
+
+    AFR_ERROR_OUT_IF_FDCTX_INVALID(fd, this, op_errno, out);
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    if (xdata) {
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+        if (dict_get_int8(xdata, "last-fsync", &last_fsync) == 0) {
+            if (last_fsync) {
+                local->transaction.disable_delayed_post_op = _gf_true;
+            }
+        }
+    } else {
+        local->xdata_req = dict_new();
+    }
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
+
+    local->op = GF_FOP_FSYNC;
+    local->cont.fsync.datasync = datasync;
+
+    if (afr_fd_has_witnessed_unstable_write(this, fd->inode)) {
+        /* don't care. we only wanted to CLEAR the bit */
+    }
+
+    local->transaction.wind = afr_fsync_wind;
+    local->transaction.unwind = afr_fsync_unwind;
+
+    local->transaction.main_frame = frame;
+
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
+out:
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
+
+    AFR_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-inode-write.h b/xlators/cluster/afr/src/afr-inode-write.h
index e174cc2d610..a787069b7a1 100644
--- a/xlators/cluster/afr/src/afr-inode-write.h
+++ b/xlators/cluster/afr/src/afr-inode-write.h
@@ -12,79 +12,83 @@
 #define __INODE_WRITE_H__
 
 int32_t
-afr_chmod (call_frame_t *frame, xlator_t *this,
-	   loc_t *loc, mode_t mode, dict_t *xdata);
+afr_chmod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dict_t *xdata);
 
 int32_t
-afr_chown (call_frame_t *frame, xlator_t *this,
-	   loc_t *loc, uid_t uid, gid_t gid, dict_t *xdata);
+afr_chown(call_frame_t *frame, xlator_t *this, loc_t *loc, uid_t uid, gid_t gid,
+          dict_t *xdata);
 
 int
-afr_fchown (call_frame_t *frame, xlator_t *this,
-	    fd_t *fd, uid_t uid, gid_t gid, dict_t *xdata);
+afr_fchown(call_frame_t *frame, xlator_t *this, fd_t *fd, uid_t uid, gid_t gid,
+           dict_t *xdata);
 
 int32_t
-afr_fchmod (call_frame_t *frame, xlator_t *this,
-	    fd_t *fd, mode_t mode, dict_t *xdata);
+afr_fchmod(call_frame_t *frame, xlator_t *this, fd_t *fd, mode_t mode,
+           dict_t *xdata);
 
 int32_t
-afr_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-	    struct iovec *vector, int32_t count, off_t offset,
-            uint32_t flags, struct iobref *iobref, dict_t *xdata);
+afr_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata);
 
 int32_t
-afr_truncate (call_frame_t *frame, xlator_t *this,
-	      loc_t *loc, off_t offset, dict_t *xdata);
+afr_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata);
 
 int32_t
-afr_ftruncate (call_frame_t *frame, xlator_t *this,
-	       fd_t *fd, off_t offset, dict_t *xdata);
+afr_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata);
 
 int32_t
-afr_utimens (call_frame_t *frame, xlator_t *this,
-	     loc_t *loc, struct timespec tv[2], dict_t *xdata);
+afr_utimens(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            struct timespec tv[2], dict_t *xdata);
 
 int
-afr_setattr (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, struct iatt *buf, int32_t valid, dict_t *xdata);
+afr_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *buf,
+            int32_t valid, dict_t *xdata);
 
 int
-afr_fsetattr (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, struct iatt *buf, int32_t valid, dict_t *xdata);
+afr_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *buf,
+             int32_t valid, dict_t *xdata);
 
 int32_t
-afr_setxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata);
+afr_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+             int32_t flags, dict_t *xdata);
 
 int32_t
-afr_fsetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata);
+afr_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+              int32_t flags, dict_t *xdata);
 
 int32_t
-afr_removexattr (call_frame_t *frame, xlator_t *this,
-		 loc_t *loc, const char *name, dict_t *xdata);
+afr_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *name, dict_t *xdata);
 
 int32_t
-afr_fremovexattr (call_frame_t *frame, xlator_t *this,
-                  fd_t *fd, const char *name, dict_t *xdata);
+afr_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 const char *name, dict_t *xdata);
 
 int
-afr_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             size_t len, dict_t *xdata);
+afr_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata);
 
 int
-afr_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-               off_t offset, size_t len, dict_t *xdata);
+afr_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata);
 
 int
 afr_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
              off_t len, dict_t *xdata);
 
 int32_t
-afr_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
+afr_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
 
 int32_t
-afr_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
+afr_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata);
+
+int
+afr_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+          dict_t *xdata);
 #endif /* __INODE_WRITE_H__ */
diff --git a/xlators/cluster/afr/src/afr-lk-common.c b/xlators/cluster/afr/src/afr-lk-common.c
index 1f2a11755bf..bc8eabe0f43 100644
--- a/xlators/cluster/afr/src/afr-lk-common.c
+++ b/xlators/cluster/afr/src/afr-lk-common.c
@@ -8,9 +8,9 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "dict.h"
-#include "byte-order.h"
-#include "common-utils.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/common-utils.h>
 
 #include "afr.h"
 #include "afr-transaction.h"
@@ -18,1755 +18,774 @@
 
 #include <signal.h>
 
-
-#define LOCKED_NO       0x0        /* no lock held */
-#define LOCKED_YES      0x1        /* for DATA, METADATA, ENTRY and higher_path */
-#define LOCKED_LOWER    0x2        /* for lower path */
-
-#define AFR_TRACE_INODELK_IN(frame, this, params ...)           \
-        do {                                                    \
-                afr_private_t *_priv = this->private;           \
-                if (!_priv->inodelk_trace)                      \
-                        break;                                  \
-                afr_trace_inodelk_in (frame, this, params);     \
-        } while (0);
-
-#define AFR_TRACE_INODELK_OUT(frame, this, params ...)          \
-        do {                                                    \
-                afr_private_t *_priv = this->private;           \
-                if (!_priv->inodelk_trace)                      \
-                        break;                                  \
-                afr_trace_inodelk_out (frame, this, params);    \
-        } while (0);
-
-#define AFR_TRACE_ENTRYLK_IN(frame, this, params ...)           \
-        do {                                                    \
-                afr_private_t *_priv = this->private;           \
-                if (!_priv->entrylk_trace)                      \
-                        break;                                  \
-                afr_trace_entrylk_in (frame, this, params);     \
-        } while (0);
-
-#define AFR_TRACE_ENTRYLK_OUT(frame, this, params ...)          \
-        do {                                                    \
-                afr_private_t *_priv = this->private;           \
-                if (!_priv->entrylk_trace)                      \
-                        break;                                  \
-                afr_trace_entrylk_out (frame, this, params);    \
-        } while (0);
-
-int
-afr_entry_lockee_cmp (const void *l1, const void *l2)
-{
-        const afr_entry_lockee_t       *r1 = l1;
-        const afr_entry_lockee_t       *r2 = l2;
-        int                            ret = 0;
-        uuid_t                         gfid1 = {0};
-        uuid_t                         gfid2 = {0};
-
-        loc_gfid ((loc_t*)&r1->loc, gfid1);
-        loc_gfid ((loc_t*)&r2->loc, gfid2);
-        ret = gf_uuid_compare (gfid1, gfid2);
-        /*Entrylks with NULL basename are the 'smallest'*/
-        if (ret == 0) {
-                if (!r1->basename)
-                        return -1;
-                if (!r2->basename)
-                        return 1;
-                ret = strcmp (r1->basename, r2->basename);
-        }
-
-        if (ret <= 0)
-                return -1;
-        else
-                return 1;
-}
-
-int afr_lock_blocking (call_frame_t *frame, xlator_t *this, int child_index);
-
-static int
-afr_copy_locked_nodes (call_frame_t *frame, xlator_t *this);
-
-static uint64_t afr_lock_number = 1;
-
-static uint64_t
-get_afr_lock_number ()
-{
-        return (++afr_lock_number);
-}
-
-int
-afr_set_lock_number (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        int_lock->lock_number = get_afr_lock_number ();
-
-        return 0;
-}
+#define LOCKED_NO 0x0    /* no lock held */
+#define LOCKED_YES 0x1   /* for DATA, METADATA, ENTRY and higher_path */
+#define LOCKED_LOWER 0x2 /* for lower path */
 
 void
-afr_set_lk_owner (call_frame_t *frame, xlator_t *this, void *lk_owner)
+afr_lockee_cleanup(afr_lockee_t *lockee)
 {
-        gf_msg_trace (this->name, 0,
-                      "Setting lk-owner=%llu",
-                      (unsigned long long) (unsigned long)lk_owner);
+    if (lockee->fd) {
+        fd_unref(lockee->fd);
+        lockee->fd = NULL;
+    } else {
+        loc_wipe(&lockee->loc);
+    }
 
-        set_lk_owner_from_ptr (&frame->root->lk_owner, lk_owner);
-}
+    GF_FREE(lockee->basename);
+    lockee->basename = NULL;
+    GF_FREE(lockee->locked_nodes);
+    lockee->locked_nodes = NULL;
 
-static int
-is_afr_lock_selfheal (afr_local_t *local)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        int                  ret      = -1;
-
-        int_lock = &local->internal_lock;
-
-        switch (int_lock->selfheal_lk_type) {
-        case AFR_DATA_SELF_HEAL_LK:
-        case AFR_METADATA_SELF_HEAL_LK:
-                ret = 1;
-                break;
-        case AFR_ENTRY_SELF_HEAL_LK:
-                ret = 0;
-                break;
-        }
-
-        return ret;
-
-}
-
-int32_t
-internal_lock_count (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int32_t call_count = 0;
-        int i = 0;
-
-        local = frame->local;
-        priv  = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i])
-                        ++call_count;
-        }
-
-        return call_count;
-}
-
-static void
-afr_print_inodelk (char *str, int size, int cmd,
-                   struct gf_flock *flock, gf_lkowner_t *owner)
-{
-        char *cmd_str = NULL;
-        char *type_str = NULL;
-
-        switch (cmd) {
-#if F_GETLK != F_GETLK64
-        case F_GETLK64:
-#endif
-        case F_GETLK:
-                cmd_str = "GETLK";
-                break;
-
-#if F_SETLK != F_SETLK64
-        case F_SETLK64:
-#endif
-        case F_SETLK:
-                cmd_str = "SETLK";
-                break;
-
-#if F_SETLKW != F_SETLKW64
-        case F_SETLKW64:
-#endif
-        case F_SETLKW:
-                cmd_str = "SETLKW";
-                break;
-
-        default:
-                cmd_str = "<null>";
-                break;
-        }
-
-        switch (flock->l_type) {
-        case F_RDLCK:
-                type_str = "READ";
-                break;
-        case F_WRLCK:
-                type_str = "WRITE";
-                break;
-        case F_UNLCK:
-                type_str = "UNLOCK";
-                break;
-        default:
-                type_str = "UNKNOWN";
-                break;
-        }
-
-        snprintf (str, size, "lock=INODELK, cmd=%s, type=%s, "
-                  "start=%llu, len=%llu, pid=%llu, lk-owner=%s",
-                  cmd_str, type_str, (unsigned long long) flock->l_start,
-                  (unsigned long long) flock->l_len,
-                  (unsigned long long) flock->l_pid,
-                  lkowner_utoa (owner));
-
-}
-
-static void
-afr_print_lockee (char *str, int size, loc_t *loc, fd_t *fd,
-                  int child_index)
-{
-        snprintf (str, size, "path=%s, fd=%p, child=%d",
-                  loc->path ? loc->path : "<nul>",
-                  fd ? fd : NULL,
-                  child_index);
+    return;
 }
 
 void
-afr_print_entrylk (char *str, int size, const char *basename,
-                   gf_lkowner_t *owner)
-{
-        snprintf (str, size, "Basename=%s, lk-owner=%s",
-                  basename ? basename : "<nul>",
-                  lkowner_utoa (owner));
-}
-
-static void
-afr_print_verdict (int op_ret, int op_errno, char *str)
+afr_lockees_cleanup(afr_internal_lock_t *int_lock)
 {
-        if (op_ret < 0) {
-                if (op_errno == EAGAIN)
-                        strcpy (str, "EAGAIN");
-                else
-                        strcpy (str, "FAILED");
-        }
-        else
-                strcpy (str, "GRANTED");
-}
+    int i = 0;
 
-static void
-afr_set_lock_call_type (afr_lock_call_type_t lock_call_type,
-                        char *lock_call_type_str,
-                        afr_internal_lock_t *int_lock)
-{
-        switch (lock_call_type) {
-        case AFR_INODELK_TRANSACTION:
-                if (int_lock->transaction_lk_type == AFR_TRANSACTION_LK)
-                        strcpy (lock_call_type_str, "AFR_INODELK_TRANSACTION");
-                else
-                        strcpy (lock_call_type_str, "AFR_INODELK_SELFHEAL");
-                break;
-        case AFR_INODELK_NB_TRANSACTION:
-                if (int_lock->transaction_lk_type == AFR_TRANSACTION_LK)
-                        strcpy (lock_call_type_str, "AFR_INODELK_NB_TRANSACTION");
-                else
-                        strcpy (lock_call_type_str, "AFR_INODELK_NB_SELFHEAL");
-                break;
-        case AFR_ENTRYLK_TRANSACTION:
-                if (int_lock->transaction_lk_type == AFR_TRANSACTION_LK)
-                        strcpy (lock_call_type_str, "AFR_ENTRYLK_TRANSACTION");
-                else
-                        strcpy (lock_call_type_str, "AFR_ENTRYLK_SELFHEAL");
-                break;
-        case AFR_ENTRYLK_NB_TRANSACTION:
-                if (int_lock->transaction_lk_type == AFR_TRANSACTION_LK)
-                        strcpy (lock_call_type_str, "AFR_ENTRYLK_NB_TRANSACTION");
-                else
-                        strcpy (lock_call_type_str, "AFR_ENTRYLK_NB_SELFHEAL");
-                break;
-        default:
-                strcpy (lock_call_type_str, "UNKNOWN");
-                break;
-        }
+    for (i = 0; i < int_lock->lockee_count; i++) {
+        afr_lockee_cleanup(&int_lock->lockee[i]);
+    }
 
+    return;
 }
-
-static void
-afr_trace_inodelk_out (call_frame_t *frame, xlator_t *this,
-                       afr_lock_call_type_t lock_call_type,
-                       afr_lock_op_type_t lk_op_type, struct gf_flock *flock,
-                       int op_ret, int op_errno, int32_t child_index)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-
-        char lockee[256];
-        char lock_call_type_str[256];
-        char verdict[16];
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        afr_print_lockee (lockee, 256, &local->loc, local->fd, child_index);
-
-        afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock);
-
-        afr_print_verdict (op_ret, op_errno, verdict);
-
-        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_LOCK_INFO,
-                "[%s %s] [%s] lk-owner=%s Lockee={%s} Number={%llu}",
-                lock_call_type_str,
-                lk_op_type == AFR_LOCK_OP ? "LOCK REPLY" : "UNLOCK REPLY",
-                verdict, lkowner_utoa (&frame->root->lk_owner), lockee,
-                (unsigned long long) int_lock->lock_number);
-
-}
-
-static void
-afr_trace_inodelk_in (call_frame_t *frame, xlator_t *this,
-                      afr_lock_call_type_t lock_call_type,
-                      afr_lock_op_type_t lk_op_type, struct gf_flock *flock,
-                      int32_t cmd, int32_t child_index)
-{
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-
-        char lock[256];
-        char lockee[256];
-        char lock_call_type_str[256];
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        afr_print_inodelk (lock, 256, cmd, flock, &frame->root->lk_owner);
-        afr_print_lockee (lockee, 256, &local->loc, local->fd, child_index);
-
-        afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock);
-
-        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_LOCK_INFO,
-                "[%s %s] Lock={%s} Lockee={%s} Number={%llu}",
-                lock_call_type_str,
-                lk_op_type == AFR_LOCK_OP ? "LOCK REQUEST" : "UNLOCK REQUEST",
-                lock, lockee,
-                (unsigned long long) int_lock->lock_number);
-
+int
+afr_entry_lockee_cmp(const void *l1, const void *l2)
+{
+    const afr_lockee_t *r1 = l1;
+    const afr_lockee_t *r2 = l2;
+    int ret = 0;
+    uuid_t gfid1 = {0};
+    uuid_t gfid2 = {0};
+
+    loc_gfid((loc_t *)&r1->loc, gfid1);
+    loc_gfid((loc_t *)&r2->loc, gfid2);
+    ret = gf_uuid_compare(gfid1, gfid2);
+    /*Entrylks with NULL basename are the 'smallest'*/
+    if (ret == 0) {
+        if (!r1->basename)
+            return -1;
+        if (!r2->basename)
+            return 1;
+        ret = strcmp(r1->basename, r2->basename);
+    }
+
+    if (ret <= 0)
+        return -1;
+    else
+        return 1;
 }
 
-static void
-afr_trace_entrylk_in (call_frame_t *frame, xlator_t *this,
-                      afr_lock_call_type_t lock_call_type,
-                      afr_lock_op_type_t lk_op_type, const char *basename,
-                      int32_t cookie)
-{
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
-        int                 child_index = 0;
-        int                 lockee_no = 0;
-
-        char lock[256];
-        char lockee[256];
-        char lock_call_type_str[256];
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        if (!priv->entrylk_trace) {
-                return;
-        }
-        lockee_no = cookie / priv->child_count;
-        child_index = cookie % priv->child_count;
-
-        afr_print_entrylk (lock, 256, basename, &frame->root->lk_owner);
-        afr_print_lockee (lockee, 256, &int_lock->lockee[lockee_no].loc, local->fd,
-                          child_index);
-
-        afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock);
-
-        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_LOCK_INFO,
-                "[%s %s] Lock={%s} Lockee={%s} Number={%llu}, Cookie={%d}",
-                lock_call_type_str,
-                lk_op_type == AFR_LOCK_OP ? "LOCK REQUEST" : "UNLOCK REQUEST",
-                lock, lockee,
-                (unsigned long long) int_lock->lock_number,
-                cookie);
-}
+int
+afr_lock_blocking(call_frame_t *frame, xlator_t *this, int child_index);
 
-static void
-afr_trace_entrylk_out (call_frame_t *frame, xlator_t *this,
-                       afr_lock_call_type_t lock_call_type,
-                       afr_lock_op_type_t lk_op_type, const char *basename,
-                       int op_ret, int op_errno, int32_t cookie)
+void
+afr_set_lk_owner(call_frame_t *frame, xlator_t *this, void *lk_owner)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        int                 lockee_no = 0;
-        int                 child_index = 0;
-
-        char lock[256];
-        char lockee[256];
-        char lock_call_type_str[256];
-        char verdict[16];
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        if (!priv->entrylk_trace) {
-                return;
-        }
-        lockee_no = cookie / priv->child_count;
-        child_index = cookie % priv->child_count;
-
-        afr_print_entrylk (lock, 256, basename, &frame->root->lk_owner);
-        afr_print_lockee (lockee, 256, &int_lock->lockee[lockee_no].loc, local->fd,
-                          child_index);
-
-        afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock);
-
-        afr_print_verdict (op_ret, op_errno, verdict);
-
-        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_LOCK_INFO,
-                "[%s %s] [%s] Lock={%s} Lockee={%s} Number={%llu} Cookie={%d}",
-                lock_call_type_str,
-                lk_op_type == AFR_LOCK_OP ? "LOCK REPLY" : "UNLOCK REPLY",
-                verdict,
-                lock, lockee,
-                (unsigned long long) int_lock->lock_number,
-                cookie);
+    gf_msg_trace(this->name, 0, "Setting lk-owner=%llu",
+                 (unsigned long long)(unsigned long)lk_owner);
 
+    set_lk_owner_from_ptr(&frame->root->lk_owner, lk_owner);
 }
 
-static int
-transaction_lk_op (afr_local_t *local)
+int32_t
+internal_lock_count(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        int ret = -1;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int32_t call_count = 0;
+    int i = 0;
 
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    priv = this->private;
 
-        if (int_lock->transaction_lk_type == AFR_TRANSACTION_LK) {
-                gf_msg_debug (THIS->name, 0,
-                              "lk op is for a transaction");
-                ret = 1;
-        }
-        else if (int_lock->transaction_lk_type == AFR_SELFHEAL_LK) {
-                gf_msg_debug (THIS->name, 0,
-                              "lk op is for a self heal");
-
-                ret = 0;
-        }
-
-        if (ret == -1)
-                gf_msg_debug (THIS->name, 0,
-                              "lk op is not set");
-
-        return ret;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i])
+            ++call_count;
+    }
 
+    return call_count;
 }
 
 int
-afr_is_inodelk_transaction(afr_local_t *local)
+afr_add_entry_lockee(afr_local_t *local, loc_t *loc, char *basename,
+                     int child_count)
 {
-        int ret = 0;
+    int ret = -ENOMEM;
+    afr_internal_lock_t *int_lock = &local->internal_lock;
+    afr_lockee_t *lockee = &int_lock->lockee[int_lock->lockee_count];
 
-        switch (local->transaction.type) {
-        case AFR_DATA_TRANSACTION:
-        case AFR_METADATA_TRANSACTION:
-                ret = 1;
-                break;
+    GF_ASSERT(int_lock->lockee_count < AFR_LOCKEE_COUNT_MAX);
+    loc_copy(&lockee->loc, loc);
+    lockee->basename = (basename) ? gf_strdup(basename) : NULL;
+    if (basename && !lockee->basename)
+        goto out;
 
-        case AFR_ENTRY_RENAME_TRANSACTION:
-        case AFR_ENTRY_TRANSACTION:
-                ret = 0;
-                break;
+    lockee->locked_count = 0;
+    lockee->locked_nodes = GF_CALLOC(child_count, sizeof(*lockee->locked_nodes),
+                                     gf_afr_mt_afr_node_character);
 
-        }
+    if (!lockee->locked_nodes)
+        goto out;
 
-        return ret;
+    ret = 0;
+    int_lock->lockee_count++;
+out:
+    if (ret) {
+        afr_lockee_cleanup(lockee);
+    }
+    return ret;
 }
 
 int
-afr_init_entry_lockee (afr_entry_lockee_t *lockee, afr_local_t *local,
-                       loc_t *loc, char *basename, int child_count)
+afr_add_inode_lockee(afr_local_t *local, int child_count)
 {
-        int     ret     = -1;
+    int ret = -ENOMEM;
+    afr_internal_lock_t *int_lock = &local->internal_lock;
+    afr_lockee_t *lockee = &int_lock->lockee[int_lock->lockee_count];
 
-        loc_copy (&lockee->loc, loc);
-        lockee->basename        = (basename)? gf_strdup (basename): NULL;
-        if (basename && !lockee->basename)
-                goto out;
+    if (local->fd) {
+        lockee->fd = fd_ref(local->fd);
+    } else {
+        loc_copy(&lockee->loc, &local->loc);
+    }
 
-        lockee->locked_count    = 0;
-        lockee->locked_nodes    = GF_CALLOC (child_count,
-                                             sizeof (*lockee->locked_nodes),
-                                             gf_afr_mt_afr_node_character);
+    lockee->locked_count = 0;
+    lockee->locked_nodes = GF_CALLOC(child_count, sizeof(*lockee->locked_nodes),
+                                     gf_afr_mt_afr_node_character);
 
-        if (!lockee->locked_nodes)
-                goto out;
+    if (!lockee->locked_nodes)
+        goto out;
 
-        ret = 0;
+    ret = 0;
+    int_lock->lockee_count++;
 out:
-        return ret;
-
-}
-
-void
-afr_entry_lockee_cleanup (afr_internal_lock_t *int_lock)
-{
-        int     i   = 0;
-
-        for (i = 0; i < int_lock->lockee_count; i++) {
-                loc_wipe (&int_lock->lockee[i].loc);
-                if (int_lock->lockee[i].basename)
-                        GF_FREE (int_lock->lockee[i].basename);
-                if (int_lock->lockee[i].locked_nodes)
-                       GF_FREE (int_lock->lockee[i].locked_nodes);
-        }
-
-        return;
+    if (ret) {
+        afr_lockee_cleanup(lockee);
+    }
+    return ret;
 }
 
 static int
-initialize_entrylk_variables (call_frame_t *frame, xlator_t *this)
+initialize_internal_lock_variables(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
-
-        int i = 0;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        int_lock->entrylk_lock_count = 0;
-        int_lock->lock_op_ret        = -1;
-        int_lock->lock_op_errno      = 0;
-
-        for (i = 0; i < AFR_LOCKEE_COUNT_MAX; i++) {
-                if (!int_lock->lockee[i].locked_nodes)
-                        break;
-                int_lock->lockee[i].locked_count = 0;
-                memset (int_lock->lockee[i].locked_nodes, 0,
-                        sizeof (*int_lock->lockee[i].locked_nodes) *
-                        priv->child_count);
-        }
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_private_t *priv = NULL;
 
-        return 0;
-}
+    int i = 0;
 
-static int
-initialize_inodelk_variables (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    int_lock->lock_count = 0;
+    int_lock->lock_op_ret = -1;
+    int_lock->lock_op_errno = 0;
+    int_lock->lk_attempted_count = 0;
 
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
+    for (i = 0; i < AFR_LOCKEE_COUNT_MAX; i++) {
+        if (!int_lock->lockee[i].locked_nodes)
+            break;
+        int_lock->lockee[i].locked_count = 0;
+        memset(int_lock->lockee[i].locked_nodes, 0,
+               sizeof(*int_lock->lockee[i].locked_nodes) * priv->child_count);
+    }
 
-        inodelk->lock_count    = 0;
-        int_lock->lk_attempted_count = 0;
-        int_lock->lock_op_ret   = -1;
-        int_lock->lock_op_errno = 0;
-
-        memset (inodelk->locked_nodes, 0,
-                sizeof (*inodelk->locked_nodes) * priv->child_count);
-        memset (int_lock->locked_nodes, 0,
-                sizeof (*int_lock->locked_nodes) * priv->child_count);
-
-        return 0;
+    return 0;
 }
 
 int
-afr_lockee_locked_nodes_count (afr_internal_lock_t *int_lock)
+afr_lockee_locked_nodes_count(afr_internal_lock_t *int_lock)
 {
-        int call_count  = 0;
-        int i           = 0;
+    int call_count = 0;
+    int i = 0;
 
-        for (i = 0; i < int_lock->lockee_count; i++)
-                call_count += int_lock->lockee[i].locked_count;
+    for (i = 0; i < int_lock->lockee_count; i++)
+        call_count += int_lock->lockee[i].locked_count;
 
-        return call_count;
+    return call_count;
 }
 
 int
-afr_locked_nodes_count (unsigned char *locked_nodes, int child_count)
-
-{
-        int i = 0;
-        int call_count = 0;
+afr_locked_nodes_count(unsigned char *locked_nodes, int child_count)
 
-        for (i = 0; i < child_count; i++) {
-                if (locked_nodes[i] & LOCKED_YES)
-                        call_count++;
-        }
-
-        return call_count;
-}
-
-/* FIXME: What if UNLOCK fails */
-static int32_t
-afr_unlock_common_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        int call_count = 0;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    int i = 0;
+    int call_count = 0;
 
-        LOCK (&frame->lock);
-        {
-                call_count = --int_lock->lk_call_count;
-        }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "All internal locks unlocked");
-
-                int_lock->lock_cbk (frame, this);
-        }
+    for (i = 0; i < child_count; i++) {
+        if (locked_nodes[i] & LOCKED_YES)
+            call_count++;
+    }
 
-        return 0;
+    return call_count;
 }
 
-void
-afr_update_uninodelk (afr_local_t *local, afr_internal_lock_t *int_lock,
-                    int32_t child_index)
+static void
+afr_log_locks_failure(call_frame_t *frame, char *where, char *what,
+                      int op_errno)
 {
-        afr_inodelk_t       *inodelk = NULL;
+    xlator_t *this = frame->this;
+    gf_lkowner_t *lk_owner = &frame->root->lk_owner;
+    afr_local_t *local = frame->local;
+    const char *fop = NULL;
+    char *gfid = NULL;
+    const char *name = NULL;
 
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-        inodelk->locked_nodes[child_index] &= LOCKED_NO;
-        if (local->transaction.eager_lock)
-                local->transaction.eager_lock[child_index] = 0;
+    fop = gf_fop_list[local->op];
 
+    switch (local->transaction.type) {
+        case AFR_ENTRY_RENAME_TRANSACTION:
+        case AFR_ENTRY_TRANSACTION:
+            switch (local->op) {
+                case GF_FOP_LINK:
+                    gfid = uuid_utoa(local->newloc.pargfid);
+                    name = local->newloc.name;
+                    break;
+                default:
+                    gfid = uuid_utoa(local->loc.pargfid);
+                    name = local->loc.name;
+                    break;
+            }
+            gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                   AFR_MSG_INTERNAL_LKS_FAILED,
+                   "Unable to do entry %s with lk-owner:%s on %s "
+                   "while attempting %s on {pgfid:%s, name:%s}.",
+                   what, lkowner_utoa(lk_owner), where, fop, gfid, name);
+            break;
+        case AFR_DATA_TRANSACTION:
+        case AFR_METADATA_TRANSACTION:
+            gfid = uuid_utoa(local->inode->gfid);
+            gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                   AFR_MSG_INTERNAL_LKS_FAILED,
+                   "Unable to do inode %s with lk-owner:%s on %s "
+                   "while attempting %s on gfid:%s.",
+                   what, lkowner_utoa(lk_owner), where, fop, gfid);
+            break;
+    }
 }
 
 static int32_t
-afr_unlock_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_local_t         *local = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        int32_t             child_index = (long)cookie;
-        afr_private_t       *priv = NULL;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
-
-        AFR_TRACE_INODELK_OUT (frame, this, AFR_INODELK_TRANSACTION,
-                               AFR_UNLOCK_OP, NULL, op_ret,
-                               op_errno, child_index);
-
-        priv = this->private;
-
-        if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "path=%s gfid=%s: unlock failed on subvolume %s "
-                        "with lock owner %s", local->loc.path,
-                        loc_gfid_utoa (&(local->loc)),
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
-
-        afr_update_uninodelk (local, int_lock, child_index);
-
-        afr_unlock_common_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-
-        return 0;
-
-}
-
-static int
-afr_unlock_inodelk (call_frame_t *frame, xlator_t *this)
+afr_unlock_common_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        struct gf_flock flock = {0,};
-        struct gf_flock full_flock = {0,};
-        struct gf_flock *flock_use = NULL;
-        int call_count = 0;
-        int i = 0;
-        int piggyback = 0;
-        afr_fd_ctx_t        *fd_ctx      = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    int lockee_num = 0;
+    int call_count = 0;
+    int child_index = 0;
+    int ret = 0;
 
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+    lockee_num = (int)((long)cookie) / priv->child_count;
+    child_index = (int)((long)cookie) % priv->child_count;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
+    if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
+        afr_log_locks_failure(frame, priv->children[child_index]->name,
+                              "unlock", op_errno);
+    }
 
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
+    int_lock->lockee[lockee_num].locked_nodes[child_index] &= LOCKED_NO;
+    if (local->transaction.type == AFR_DATA_TRANSACTION && op_ret != 1)
+        ret = afr_write_subvol_reset(frame, this);
 
-        flock.l_start = inodelk->flock.l_start;
-        flock.l_len   = inodelk->flock.l_len;
-        flock.l_type  = F_UNLCK;
+    LOCK(&frame->lock);
+    {
+        call_count = --int_lock->lk_call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        full_flock.l_type = F_UNLCK;
-        call_count = afr_locked_nodes_count (inodelk->locked_nodes,
-                                             priv->child_count);
+    if (call_count == 0) {
+        int_lock->lock_cbk(frame, this);
+    }
 
-        int_lock->lk_call_count = call_count;
-
-        if (!call_count) {
-                gf_msg_trace (this->name, 0,
-                              "No internal locks unlocked");
-
-                int_lock->lock_cbk (frame, this);
-                goto out;
-        }
-
-        if (local->fd)
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if ((inodelk->locked_nodes[i] & LOCKED_YES) != LOCKED_YES)
-                        continue;
-
-                if (local->fd) {
-                        flock_use = &flock;
-                        if (!local->transaction.eager_lock[i]) {
-                                goto wind;
-                        }
-
-                        piggyback = 0;
-
-                        LOCK (&local->fd->lock);
-                        {
-                                if (fd_ctx->lock_piggyback[i]) {
-                                        fd_ctx->lock_piggyback[i]--;
-                                        piggyback = 1;
-                                } else {
-                                        fd_ctx->lock_acquired[i]--;
-                                }
-                        }
-                        UNLOCK (&local->fd->lock);
-
-                        if (piggyback) {
-                                afr_unlock_inodelk_cbk (frame, (void *) (long) i,
-                                                        this, 1, 0, NULL);
-                                if (!--call_count)
-                                        break;
-                                continue;
-                        }
-
-                        flock_use = &full_flock;
-                wind:
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_TRANSACTION,
-                                              AFR_UNLOCK_OP, flock_use, F_SETLK,
-                                              i);
-
-                        STACK_WIND_COOKIE (frame, afr_unlock_inodelk_cbk,
-                                           (void *) (long)i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLK, flock_use, NULL);
-
-                        if (!--call_count)
-                                break;
-
-                } else {
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_TRANSACTION,
-                                              AFR_UNLOCK_OP, &flock, F_SETLK, i);
-
-                        STACK_WIND_COOKIE (frame, afr_unlock_inodelk_cbk,
-                                           (void *) (long)i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLK, &flock, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
-        }
-out:
-        return 0;
+    return ret;
 }
 
-static int32_t
-afr_unlock_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_local_t         *local = NULL;
-        afr_private_t       *priv  = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        int32_t             child_index = 0;
-        int                 lockee_no   = 0;
-
-        priv = this->private;
-        lockee_no = (int)((long) cookie) / priv->child_count;
-        child_index = (int) ((long) cookie) % priv->child_count;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
-
-        AFR_TRACE_ENTRYLK_OUT (frame, this, AFR_ENTRYLK_TRANSACTION,
-                               AFR_UNLOCK_OP,
-                               int_lock->lockee[lockee_no].basename, op_ret,
-                               op_errno, (int) ((long)cookie));
-
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_ENTRY_UNLOCK_FAIL,
-                        "%s: unlock failed on %s", local->loc.path,
-                        priv->children[child_index]->name);
-        }
-
-        int_lock->lockee[lockee_no].locked_nodes[child_index] &= LOCKED_NO;
-        afr_unlock_common_cbk (frame, cookie, this, op_ret, op_errno, NULL);
+void
+afr_internal_lock_wind(call_frame_t *frame,
+                       int32_t (*cbk)(call_frame_t *, void *, xlator_t *,
+                                      int32_t, int32_t, dict_t *),
+                       void *cookie, int child, int lockee_num,
+                       gf_boolean_t blocking, gf_boolean_t unlock)
+{
+    afr_local_t *local = frame->local;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
+    afr_internal_lock_t *int_lock = &local->internal_lock;
+    entrylk_cmd cmd = ENTRYLK_LOCK_NB;
+    int32_t cmd1 = F_SETLK;
+    struct gf_flock flock = {
+        0,
+    };
+
+    switch (local->transaction.type) {
+        case AFR_ENTRY_TRANSACTION:
+        case AFR_ENTRY_RENAME_TRANSACTION:
+            if (unlock) {
+                cmd = ENTRYLK_UNLOCK;
+            } else if (blocking) { /*Doesn't make sense to have blocking
+                                      unlock*/
+                cmd = ENTRYLK_LOCK;
+            }
+
+            if (local->fd) {
+                STACK_WIND_COOKIE(frame, cbk, cookie, priv->children[child],
+                                  priv->children[child]->fops->fentrylk,
+                                  int_lock->domain,
+                                  int_lock->lockee[lockee_num].fd,
+                                  int_lock->lockee[lockee_num].basename, cmd,
+                                  ENTRYLK_WRLCK, NULL);
+            } else {
+                STACK_WIND_COOKIE(frame, cbk, cookie, priv->children[child],
+                                  priv->children[child]->fops->entrylk,
+                                  int_lock->domain,
+                                  &int_lock->lockee[lockee_num].loc,
+                                  int_lock->lockee[lockee_num].basename, cmd,
+                                  ENTRYLK_WRLCK, NULL);
+            }
+            break;
 
-        return 0;
+        case AFR_DATA_TRANSACTION:
+        case AFR_METADATA_TRANSACTION:
+            flock = int_lock->lockee[lockee_num].flock;
+            if (unlock) {
+                flock.l_type = F_UNLCK;
+            } else if (blocking) { /*Doesn't make sense to have blocking
+                                      unlock*/
+                cmd1 = F_SETLKW;
+            }
+
+            if (local->fd) {
+                STACK_WIND_COOKIE(
+                    frame, cbk, cookie, priv->children[child],
+                    priv->children[child]->fops->finodelk, int_lock->domain,
+                    int_lock->lockee[lockee_num].fd, cmd1, &flock, NULL);
+            } else {
+                STACK_WIND_COOKIE(
+                    frame, cbk, cookie, priv->children[child],
+                    priv->children[child]->fops->inodelk, int_lock->domain,
+                    &int_lock->lockee[lockee_num].loc, cmd1, &flock, NULL);
+            }
+            break;
+    }
 }
 
 static int
-afr_unlock_entrylk (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t     *int_lock       = NULL;
-        afr_local_t             *local          = NULL;
-        afr_private_t           *priv           = NULL;
-        int                     call_count      = 0;
-        int                     index           = 0;
-        int                     lockee_no       = 0;
-        int                     copies          = 0;
-        int                     i               = -1;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-        copies   = priv->child_count;
-
-        call_count = afr_lockee_locked_nodes_count (int_lock);
-
-        int_lock->lk_call_count = call_count;
-
-        if (!call_count){
-                gf_msg_trace (this->name, 0,
-                              "No internal locks unlocked");
-                int_lock->lock_cbk (frame, this);
-                goto out;
-        }
-
-        for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
-                lockee_no = i / copies;
-                index     = i % copies;
-                if (int_lock->lockee[lockee_no].locked_nodes[index] & LOCKED_YES) {
-                        AFR_TRACE_ENTRYLK_IN (frame, this, AFR_ENTRYLK_NB_TRANSACTION,
-                                              AFR_UNLOCK_OP,
-                                              int_lock->lockee[lockee_no].basename,
-                                              i);
-
-                        STACK_WIND_COOKIE (frame, afr_unlock_entrylk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[index],
-                                           priv->children[index]->fops->entrylk,
-                                           int_lock->domain,
-                                           &int_lock->lockee[lockee_no].loc,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+afr_unlock_now(call_frame_t *frame, xlator_t *this)
+{
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int child_index = 0;
+    int lockee_num = 0;
+    int i = -1;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+
+    call_count = afr_lockee_locked_nodes_count(int_lock);
+
+    int_lock->lk_call_count = call_count;
+
+    if (!call_count) {
+        gf_msg_trace(this->name, 0, "No internal locks unlocked");
+        int_lock->lock_cbk(frame, this);
+        goto out;
+    }
+
+    for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
+        lockee_num = i / priv->child_count;
+        child_index = i % priv->child_count;
+        if (int_lock->lockee[lockee_num].locked_nodes[child_index] &
+            LOCKED_YES) {
+            afr_internal_lock_wind(frame, afr_unlock_common_cbk,
+                                   (void *)(long)i, child_index, lockee_num,
+                                   _gf_false, _gf_true);
+            if (!--call_count)
+                break;
         }
+    }
 
 out:
-        return 0;
-
+    return 0;
 }
 
 static int32_t
-afr_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_internal_lock_t     *int_lock       = NULL;
-        afr_local_t             *local          = NULL;
-        afr_private_t           *priv           = NULL;
-        int                     cky             = (long) cookie;
-        int                     child_index     = 0;
-        int                     lockee_no       = 0;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        child_index = ((int)cky) % priv->child_count;
-        lockee_no   = ((int)cky) / priv->child_count;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno == ENOSYS) {
-                                /* return ENOTSUP */
-                                gf_msg (this->name, GF_LOG_ERROR, ENOSYS,
-                                        AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-                                        "subvolume does not support locking. "
-                                        "please load features/locks xlator on server");
-                                local->op_ret = op_ret;
-                                int_lock->lock_op_ret = op_ret;
-                        }
-
-                        local->op_errno              = op_errno;
-                        int_lock->lock_op_errno      = op_errno;
-                }
-
-		int_lock->lk_attempted_count++;
-        }
-        UNLOCK (&frame->lock);
-
-        if ((op_ret == -1) &&
-            (op_errno == ENOSYS)) {
-                afr_unlock (frame, this);
-        } else {
-                if (op_ret == 0) {
-                        if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
-                            local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                                int_lock->lockee[lockee_no].locked_nodes[child_index] |= LOCKED_YES;
-                                int_lock->lockee[lockee_no].locked_count++;
-                                int_lock->entrylk_lock_count++;
-                        } else {
-                                int_lock->locked_nodes[child_index] |= LOCKED_YES;
-                                int_lock->lock_count++;
-                        }
+afr_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, dict_t *xdata)
+{
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int cky = (long)cookie;
+    int child_index = 0;
+    int lockee_num = 0;
+
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
+
+    child_index = ((int)cky) % priv->child_count;
+    lockee_num = ((int)cky) / priv->child_count;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno == ENOSYS) {
+                /* return ENOTSUP */
+                gf_msg(this->name, GF_LOG_ERROR, ENOSYS,
+                       AFR_MSG_LOCK_XLATOR_NOT_LOADED,
+                       "subvolume does not support locking. "
+                       "please load features/locks xlator on server");
+                local->op_ret = op_ret;
+                int_lock->lock_op_ret = op_ret;
+            }
+
+            local->op_errno = op_errno;
+            int_lock->lock_op_errno = op_errno;
+        }
+
+        int_lock->lk_attempted_count++;
+    }
+    UNLOCK(&frame->lock);
+
+    if ((op_ret == -1) && (op_errno == ENOSYS)) {
+        afr_unlock_now(frame, this);
+    } else {
+        if (op_ret == 0) {
+            int_lock->lockee[lockee_num]
+                .locked_nodes[child_index] |= LOCKED_YES;
+            int_lock->lockee[lockee_num].locked_count++;
+            int_lock->lock_count++;
+            if (local->transaction.type == AFR_DATA_TRANSACTION) {
+                LOCK(&local->inode->lock);
+                {
+                    local->inode_ctx->lock_count++;
                 }
-                afr_lock_blocking (frame, this, cky + 1);
-        }
-
-        return 0;
-}
-
-static int32_t
-afr_blocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        AFR_TRACE_INODELK_OUT (frame, this, AFR_INODELK_TRANSACTION,
-                               AFR_LOCK_OP, NULL, op_ret,
-                               op_errno, (long) cookie);
-
-        afr_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        return 0;
-
-}
-
-static int32_t
-afr_blocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        AFR_TRACE_ENTRYLK_OUT (frame, this, AFR_ENTRYLK_TRANSACTION,
-                               AFR_LOCK_OP, NULL, op_ret,
-                               op_errno, (long)cookie);
-
-        afr_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        return 0;
-}
-
-static int
-afr_copy_locked_nodes (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        switch (local->transaction.type) {
-        case AFR_DATA_TRANSACTION:
-        case AFR_METADATA_TRANSACTION:
-                inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-                memcpy (inodelk->locked_nodes, int_lock->locked_nodes,
-                        sizeof (*inodelk->locked_nodes) * priv->child_count);
-                inodelk->lock_count = int_lock->lock_count;
-                break;
-
-        case AFR_ENTRY_RENAME_TRANSACTION:
-        case AFR_ENTRY_TRANSACTION:
-                /*entrylk_count is being used in both non-blocking and blocking
-                 * modes */
-                break;
-        }
-
-        return 0;
-
-}
-
-static gf_boolean_t
-afr_is_entrylk (afr_internal_lock_t *int_lock,
-                afr_transaction_type trans_type)
-{
-        gf_boolean_t is_entrylk = _gf_false;
-
-        if ((int_lock->transaction_lk_type == AFR_SELFHEAL_LK) &&
-            int_lock->selfheal_lk_type == AFR_ENTRY_SELF_HEAL_LK) {
-
-                is_entrylk = _gf_true;
-
-        } else if ((int_lock->transaction_lk_type == AFR_TRANSACTION_LK) &&
-                 (trans_type == AFR_ENTRY_TRANSACTION ||
-                  trans_type == AFR_ENTRY_RENAME_TRANSACTION)) {
-
-                is_entrylk = _gf_true;
-
-        } else {
-                is_entrylk = _gf_false;
+                UNLOCK(&local->inode->lock);
+            }
         }
+        afr_lock_blocking(frame, this, cky + 1);
+    }
 
-        return is_entrylk;
+    return 0;
 }
 
 static gf_boolean_t
-_is_lock_wind_needed (afr_local_t *local, int child_index)
-{
-        if (!local->child_up[child_index])
-                return _gf_false;
-
-        return _gf_true;
-}
-
-static void
-afr_log_entry_locks_failure(xlator_t *this, afr_local_t *local,
-                            afr_internal_lock_t *int_lock)
+_is_lock_wind_needed(afr_local_t *local, int child_index)
 {
-        const char *fop = NULL;
-        char *pargfid = NULL;
-        const char *name = NULL;
+    if (!local->child_up[child_index])
+        return _gf_false;
 
-        fop = gf_fop_list[local->op];
-
-        switch (local->op) {
-        case GF_FOP_LINK:
-                pargfid = uuid_utoa(local->newloc.pargfid);
-                name = local->newloc.name;
-                break;
-        default:
-                pargfid = uuid_utoa(local->loc.pargfid);
-                name = local->loc.name;
-                break;
-        }
-
-        gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_BLOCKING_LKS_FAILED,
-                "Unable to obtain sufficient blocking entry locks on at least "
-                "one child while attempting %s on {pgfid:%s, name:%s}.", fop,
-                pargfid, name);
+    return _gf_true;
 }
 
 static gf_boolean_t
-is_blocking_locks_count_sufficient (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t  *local = NULL;
-        afr_private_t *priv = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        gf_boolean_t is_entrylk = _gf_false;
-        int child = 0;
-        int nlockee = 0;
-        int lockee_count = 0;
-        gf_boolean_t ret = _gf_true;
-
-        local = frame->local;
-        priv = this->private;
-        int_lock = &local->internal_lock;
-        lockee_count = int_lock->lockee_count;
-        is_entrylk = afr_is_entrylk (int_lock, local->transaction.type);
-
-        if (!is_entrylk) {
-                if (int_lock->lock_count == 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_BLOCKING_LKS_FAILED, "Unable to obtain "
-                                "blocking inode lock on even one child for "
-                                "gfid:%s.", uuid_utoa (local->inode->gfid));
-                        return _gf_false;
-                } else {
-                        /*inodelk succeded on atleast one child. */
-                        return _gf_true;
-                }
-
-        } else {
-                if (int_lock->entrylk_lock_count == 0) {
-                        afr_log_entry_locks_failure (this, local, int_lock);
-                        return _gf_false;
-                }
-                /* For FOPS that take multiple sets of locks (mkdir, rename),
-                 * there must be atleast one brick on which the locks from
-                 * all lock sets were successful. */
-                for (child = 0; child < priv->child_count; child++) {
-                        ret = _gf_true;
-                        for (nlockee = 0; nlockee < lockee_count; nlockee++) {
-                                if (!(int_lock->lockee[nlockee].locked_nodes[child] & LOCKED_YES))
-                                        ret = _gf_false;
-                        }
-                        if (ret)
-                                return ret;
-                }
-                if (!ret)
-                        afr_log_entry_locks_failure (this, local, int_lock);
-        }
-
-        return ret;
-
+is_blocking_locks_count_sufficient(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    int child = 0;
+    int nlockee = 0;
+    int lockee_count = 0;
+    gf_boolean_t ret = _gf_true;
+
+    local = frame->local;
+    priv = this->private;
+    int_lock = &local->internal_lock;
+    lockee_count = int_lock->lockee_count;
+
+    if (int_lock->lock_count == 0) {
+        afr_log_locks_failure(frame, "any subvolume", "lock",
+                              int_lock->lock_op_errno);
+        return _gf_false;
+    }
+    /* For FOPS that take multiple sets of locks (mkdir, rename),
+     * there must be at least one brick on which the locks from
+     * all lock sets were successful. */
+    for (child = 0; child < priv->child_count; child++) {
+        ret = _gf_true;
+        for (nlockee = 0; nlockee < lockee_count; nlockee++) {
+            if (!(int_lock->lockee[nlockee].locked_nodes[child] & LOCKED_YES))
+                ret = _gf_false;
+        }
+        if (ret)
+            return ret;
+    }
+    if (!ret)
+        afr_log_locks_failure(frame, "all", "lock", int_lock->lock_op_errno);
+
+    return ret;
 }
 
 int
-afr_lock_blocking (call_frame_t *frame, xlator_t *this, int cookie)
+afr_lock_blocking(call_frame_t *frame, xlator_t *this, int cookie)
 {
-        afr_internal_lock_t *int_lock    = NULL;
-        afr_inodelk_t       *inodelk     = NULL;
-        afr_local_t         *local       = NULL;
-        afr_private_t       *priv        = NULL;
-        struct gf_flock flock = {0,};
-        uint64_t ctx = 0;
-        int ret = 0;
-        int child_index = 0;
-        int lockee_no   = 0;
-        gf_boolean_t is_entrylk = _gf_false;
-
-        local         = frame->local;
-        int_lock      = &local->internal_lock;
-        priv          = this->private;
-        child_index   = cookie % priv->child_count;
-        lockee_no     = cookie / priv->child_count;
-        is_entrylk    = afr_is_entrylk (int_lock, local->transaction.type);
-
-
-        if (!is_entrylk) {
-                inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-                flock.l_start = inodelk->flock.l_start;
-                flock.l_len   = inodelk->flock.l_len;
-                flock.l_type  = inodelk->flock.l_type;
-        }
-
-        if (local->fd) {
-                ret = fd_ctx_get (local->fd, this, &ctx);
-
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
-
-                        afr_copy_locked_nodes (frame, this);
-
-                        afr_unlock (frame, this);
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    uint64_t ctx = 0;
+    int ret = 0;
+    int child_index = 0;
+    int lockee_num = 0;
 
-                        return 0;
-                }
-        }
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+    child_index = cookie % priv->child_count;
+    lockee_num = cookie / priv->child_count;
 
-        if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
-                if (!is_blocking_locks_count_sufficient (frame, this)) {
+    if (local->fd) {
+        ret = fd_ctx_get(local->fd, this, &ctx);
 
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_FD_CTX_GET_FAILED,
+                   "unable to get fd ctx for fd=%p", local->fd);
 
-                        afr_copy_locked_nodes (frame, this);
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
 
-                        afr_unlock(frame, this);
+            afr_unlock_now(frame, this);
 
-                        return 0;
-                }
+            return 0;
         }
+    }
 
-        if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
-                /* we're done locking */
+    if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
+        if (!is_blocking_locks_count_sufficient(frame, this)) {
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
 
-                gf_msg_debug (this->name, 0,
-                              "we're done locking");
+            afr_unlock_now(frame, this);
 
-                afr_copy_locked_nodes (frame, this);
-
-                int_lock->lock_op_ret = 0;
-                int_lock->lock_cbk (frame, this);
-                return 0;
+            return 0;
         }
+    }
 
-        if (!_is_lock_wind_needed (local, child_index)) {
-                afr_lock_blocking (frame, this, cookie + 1);
-                return 0;
-        }
+    if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
+        /* we're done locking */
 
-        switch (local->transaction.type) {
-        case AFR_DATA_TRANSACTION:
-        case AFR_METADATA_TRANSACTION:
-
-                if (local->fd) {
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_TRANSACTION,
-                                              AFR_LOCK_OP, &flock, F_SETLKW,
-                                              child_index);
-
-                        STACK_WIND_COOKIE (frame, afr_blocking_inodelk_cbk,
-                                           (void *) (long) child_index,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLKW, &flock, NULL);
-
-                } else {
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_TRANSACTION,
-                                              AFR_LOCK_OP, &flock, F_SETLKW,
-                                              child_index);
-
-                        STACK_WIND_COOKIE (frame, afr_blocking_inodelk_cbk,
-                                           (void *) (long) child_index,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLKW, &flock, NULL);
-                }
+        gf_msg_debug(this->name, 0, "we're done locking");
 
-                break;
+        int_lock->lock_op_ret = 0;
+        int_lock->lock_cbk(frame, this);
+        return 0;
+    }
 
-        case AFR_ENTRY_RENAME_TRANSACTION:
-        case AFR_ENTRY_TRANSACTION:
-                /*Accounting for child_index increments on 'down'
-                 *and 'fd-less' children */
-
-                if (local->fd) {
-                        AFR_TRACE_ENTRYLK_IN (frame, this, AFR_ENTRYLK_TRANSACTION,
-                                              AFR_LOCK_OP,
-                                              int_lock->lockee[lockee_no].basename,
-                                              cookie);
-
-                        STACK_WIND_COOKIE (frame, afr_blocking_entrylk_cbk,
-                                           (void *) (long) cookie,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->fentrylk,
-                                           int_lock->domain, local->fd,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                } else {
-                        AFR_TRACE_ENTRYLK_IN (frame, this,
-                                              AFR_ENTRYLK_TRANSACTION,
-                                              AFR_LOCK_OP, local->transaction.basename,
-                                              child_index);
-
-                        STACK_WIND_COOKIE (frame, afr_blocking_entrylk_cbk,
-                                           (void *) (long) cookie,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->entrylk,
-                                           int_lock->domain,
-                                           &int_lock->lockee[lockee_no].loc,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                }
+    if (!_is_lock_wind_needed(local, child_index)) {
+        afr_lock_blocking(frame, this, cookie + 1);
+        return 0;
+    }
 
-                break;
-        }
+    afr_internal_lock_wind(frame, afr_lock_cbk, (void *)(long)cookie,
+                           child_index, lockee_num, _gf_true, _gf_false);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_blocking_lock (call_frame_t *frame, xlator_t *this)
+afr_blocking_lock(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        int                  up_count = 0;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int up_count = 0;
 
-        switch (local->transaction.type) {
-        case AFR_DATA_TRANSACTION:
-        case AFR_METADATA_TRANSACTION:
-                initialize_inodelk_variables (frame, this);
-                break;
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        case AFR_ENTRY_RENAME_TRANSACTION:
-        case AFR_ENTRY_TRANSACTION:
-                up_count = AFR_COUNT (local->child_up, priv->child_count);
-                int_lock->lk_call_count = int_lock->lk_expected_count
-                                        = (int_lock->lockee_count *
-                                           up_count);
-                initialize_entrylk_variables (frame, this);
-                break;
-        }
+    up_count = AFR_COUNT(local->child_up, priv->child_count);
+    int_lock->lk_call_count = int_lock->lk_expected_count =
+        (int_lock->lockee_count * up_count);
+    initialize_internal_lock_variables(frame, this);
 
-        afr_lock_blocking (frame, this, 0);
+    afr_lock_blocking(frame, this, 0);
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-afr_nonblocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        int call_count          = 0;
-        int child_index         = (long) cookie;
-        int copies              = 0;
-        int index               = 0;
-        int lockee_no           = 0;
-        afr_private_t       *priv = NULL;
-
-        priv = this->private;
-
-        copies = priv->child_count;
-        index = child_index % copies;
-        lockee_no = child_index / copies;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        AFR_TRACE_ENTRYLK_OUT (frame, this, AFR_ENTRYLK_TRANSACTION,
-                               AFR_LOCK_OP,
-                               int_lock->lockee[lockee_no].basename, op_ret,
-                               op_errno, (long) cookie);
-
-	LOCK (&frame->lock);
-	{
-		if (op_ret < 0 ) {
-			if (op_errno == ENOSYS) {
-                        /* return ENOTSUP */
-			        gf_msg (this->name, GF_LOG_ERROR,
-                                        ENOSYS, AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-                                        "subvolume does not support "
-                                        "locking. please load features/locks"
-                                        " xlator on server");
-				local->op_ret         = op_ret;
-				int_lock->lock_op_ret = op_ret;
-
-				int_lock->lock_op_errno      = op_errno;
-				local->op_errno              = op_errno;
-			}
-		} else if (op_ret == 0) {
-			int_lock->lockee[lockee_no].locked_nodes[index] |= \
-				LOCKED_YES;
-			int_lock->lockee[lockee_no].locked_count++;
-			int_lock->entrylk_lock_count++;
-		}
-
-                call_count = --int_lock->lk_call_count;
-        }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Last locking reply received");
-                /* all locks successful. Proceed to call FOP */
-                if (int_lock->entrylk_lock_count ==
-                                int_lock->lk_expected_count) {
-                        gf_msg_trace (this->name, 0,
-                                      "All servers locked. Calling the cbk");
-                        int_lock->lock_op_ret = 0;
-                        int_lock->lock_cbk (frame, this);
-                }
-                /* Not all locks were successful. Unlock and try locking
-                   again, this time with serially blocking locks */
-                else {
-                        gf_msg_trace (this->name, 0,
-                                      "%d servers locked. Trying again "
-                                      "with blocking calls",
-                                      int_lock->lock_count);
-
-                        afr_unlock(frame, this);
-                }
-        }
-
-        return 0;
-}
-
-int
-afr_nonblocking_entrylk (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t *int_lock   = NULL;
-        afr_local_t         *local      = NULL;
-        afr_private_t       *priv       = NULL;
-        afr_fd_ctx_t        *fd_ctx     = NULL;
-        int                 copies      = 0;
-        int                 index       = 0;
-        int                 lockee_no   = 0;
-        int32_t             call_count  = 0;
-        int i = 0;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        copies = priv->child_count;
-        initialize_entrylk_variables (frame, this);
-
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
-                        local->op_errno         = EINVAL;
-                        int_lock->lock_op_errno = EINVAL;
-
-			afr_unlock (frame, this);
-                        return -1;
-                }
-
-                call_count = int_lock->lockee_count * internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
-
-                if (!call_count) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_INFO_COMMON,
-                                "fd not open on any subvolumes. aborting.");
-                        afr_unlock (frame, this);
-                        goto out;
-                }
-
-                /* Send non-blocking entrylk calls only on up children
-                   and where the fd has been opened */
-                for (i = 0; i < int_lock->lockee_count*priv->child_count; i++) {
-                        index = i%copies;
-                        lockee_no = i/copies;
-                        if (local->child_up[index]) {
-                                AFR_TRACE_ENTRYLK_IN (frame, this, AFR_ENTRYLK_NB_TRANSACTION,
-                                                      AFR_LOCK_OP,
-                                                      int_lock->lockee[lockee_no].basename,
-                                                      i);
-
-                                STACK_WIND_COOKIE (frame, afr_nonblocking_entrylk_cbk,
-                                                   (void *) (long) i,
-                                                   priv->children[index],
-                                                   priv->children[index]->fops->fentrylk,
-                                                   this->name, local->fd,
-                                                   int_lock->lockee[lockee_no].basename,
-                                                   ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                                                   NULL);
-                                if (!--call_count)
-                                        break;
-                        }
-                }
-        } else {
-                call_count = int_lock->lockee_count * internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
-
-                for (i = 0; i < int_lock->lockee_count*priv->child_count; i++) {
-                        index = i%copies;
-                        lockee_no = i/copies;
-                        if (local->child_up[index]) {
-                                AFR_TRACE_ENTRYLK_IN (frame, this, AFR_ENTRYLK_NB_TRANSACTION,
-                                                      AFR_LOCK_OP,
-                                                      int_lock->lockee[lockee_no].basename,
-                                                      i);
-
-                                STACK_WIND_COOKIE (frame, afr_nonblocking_entrylk_cbk,
-                                                   (void *) (long) i,
-                                                   priv->children[index],
-                                                   priv->children[index]->fops->entrylk,
-                                                   this->name, &int_lock->lockee[lockee_no].loc,
-                                                   int_lock->lockee[lockee_no].basename,
-                                                   ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                                                   NULL);
-
-                                if (!--call_count)
-                                        break;
-                        }
-                }
-        }
-out:
-        return 0;
-}
-
-int32_t
-afr_nonblocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_nb_internal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
-        afr_local_t         *local    = NULL;
-        int call_count  = 0;
-        int child_index = (long) cookie;
-        afr_fd_ctx_t        *fd_ctx = NULL;
-
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    int child_index = 0;
+    int lockee_num = 0;
+    afr_private_t *priv = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
+    priv = this->private;
 
-        AFR_TRACE_INODELK_OUT (frame, this, AFR_INODELK_NB_TRANSACTION,
-                               AFR_LOCK_OP, NULL, op_ret,
-                               op_errno, (long) cookie);
+    child_index = ((long)cookie) % priv->child_count;
+    lockee_num = ((long)cookie) / priv->child_count;
 
-	if (local->fd)
-		fd_ctx = afr_fd_ctx_get (local->fd, this);
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        LOCK (&frame->lock);
+    if (op_ret == 0 && local->transaction.type == AFR_DATA_TRANSACTION) {
+        LOCK(&local->inode->lock);
         {
-		if (op_ret < 0) {
-			if (op_errno == ENOSYS) {
-				/* return ENOTSUP */
-		                gf_msg (this->name, GF_LOG_ERROR, ENOSYS,
-                                        AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-					"subvolume does not support "
-                                        "locking. please load features/locks"
-                                        " xlator on server");
-				local->op_ret                = op_ret;
-				int_lock->lock_op_ret        = op_ret;
-				int_lock->lock_op_errno      = op_errno;
-				local->op_errno              = op_errno;
-			}
-			if (local->transaction.eager_lock)
-				local->transaction.eager_lock[child_index] = 0;
-		} else {
-			inodelk->locked_nodes[child_index] |= LOCKED_YES;
-			inodelk->lock_count++;
-
-			if (local->transaction.eager_lock &&
-			    local->transaction.eager_lock[child_index] &&
-			    local->fd) {
-				/* piggybacked */
-				if (op_ret == 1) {
-					/* piggybacked */
-				} else if (op_ret == 0) {
-					/* lock acquired from server */
-                                        fd_ctx->lock_acquired[child_index]++;
-				}
-			}
-		}
-
-                call_count = --int_lock->lk_call_count;
-        }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Last inode locking reply received");
-                /* all locks successful. Proceed to call FOP */
-                if (inodelk->lock_count == int_lock->lk_expected_count) {
-                        gf_msg_trace (this->name, 0,
-                                      "All servers locked. Calling the cbk");
-                        int_lock->lock_op_ret = 0;
-                        int_lock->lock_cbk (frame, this);
-                }
-                /* Not all locks were successful. Unlock and try locking
-                   again, this time with serially blocking locks */
-                else {
-                        gf_msg_trace (this->name, 0,
-                                      "%d servers locked. "
-                                      "Trying again with blocking calls",
-                                      int_lock->lock_count);
-
-                        afr_unlock(frame, this);
-                }
+            local->inode_ctx->lock_count++;
         }
+        UNLOCK(&local->inode->lock);
+    }
 
-        return 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret < 0) {
+            if (op_errno == ENOSYS) {
+                /* return ENOTSUP */
+                gf_msg(this->name, GF_LOG_ERROR, ENOSYS,
+                       AFR_MSG_LOCK_XLATOR_NOT_LOADED,
+                       "subvolume does not support "
+                       "locking. please load features/locks"
+                       " xlator on server");
+                local->op_ret = op_ret;
+                int_lock->lock_op_ret = op_ret;
+
+                int_lock->lock_op_errno = op_errno;
+                local->op_errno = op_errno;
+            }
+        } else if (op_ret == 0) {
+            int_lock->lockee[lockee_num]
+                .locked_nodes[child_index] |= LOCKED_YES;
+            int_lock->lockee[lockee_num].locked_count++;
+            int_lock->lock_count++;
+        }
+
+        call_count = --int_lock->lk_call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        gf_msg_trace(this->name, 0, "Last locking reply received");
+        /* all locks successful. Proceed to call FOP */
+        if (int_lock->lock_count == int_lock->lk_expected_count) {
+            gf_msg_trace(this->name, 0, "All servers locked. Calling the cbk");
+            int_lock->lock_op_ret = 0;
+            int_lock->lock_cbk(frame, this);
+        }
+        /* Not all locks were successful. Unlock and try locking
+           again, this time with serially blocking locks */
+        else {
+            gf_msg_trace(this->name, 0,
+                         "%d servers locked. Trying again "
+                         "with blocking calls",
+                         int_lock->lock_count);
+
+            afr_unlock_now(frame, this);
+        }
+    }
+
+    return 0;
 }
 
 int
-afr_nonblocking_inodelk (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        afr_fd_ctx_t        *fd_ctx   = NULL;
-        int32_t             call_count = 0;
-        int                 i          = 0;
-        int                 ret        = 0;
-        struct              gf_flock flock = {0,};
-        struct              gf_flock full_flock = {0,};
-        struct              gf_flock *flock_use = NULL;
-        int                 piggyback = 0;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-
-        flock.l_start = inodelk->flock.l_start;
-        flock.l_len   = inodelk->flock.l_len;
-        flock.l_type  = inodelk->flock.l_type;
-
-        full_flock.l_type = inodelk->flock.l_type;
-
-        initialize_inodelk_variables (frame, this);
-
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
-                        local->op_errno         = EINVAL;
-                        int_lock->lock_op_errno = EINVAL;
-
-			afr_unlock (frame, this);
-                        ret = -1;
-                        goto out;
-                }
-
-                call_count = internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
-
-                if (!call_count) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_SUBVOLS_DOWN,
-                                "All bricks are down, aborting.");
-                        afr_unlock (frame, this);
-                        goto out;
-                }
-
-                /* Send non-blocking inodelk calls only on up children
-                   and where the fd has been opened */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->child_up[i])
-                                continue;
-
-                        flock_use = &flock;
-                        if (!local->transaction.eager_lock_on) {
-                                goto wind;
-                        }
-
-                        piggyback = 0;
-                        local->transaction.eager_lock[i] = 1;
-
-			afr_set_delayed_post_op (frame, this);
-
-                        LOCK (&local->fd->lock);
-                        {
-                                if (fd_ctx->lock_acquired[i]) {
-                                        fd_ctx->lock_piggyback[i]++;
-                                        piggyback = 1;
-                                }
-                        }
-                        UNLOCK (&local->fd->lock);
-
-                        if (piggyback) {
-                                /* (op_ret == 1) => indicate piggybacked lock */
-                                afr_nonblocking_inodelk_cbk (frame, (void *) (long) i,
-                                                             this, 1, 0, NULL);
-                                if (!--call_count)
-                                        break;
-                                continue;
-                        }
-                        flock_use = &full_flock;
-                wind:
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_NB_TRANSACTION,
-                                              AFR_LOCK_OP, flock_use, F_SETLK, i);
-
-                        STACK_WIND_COOKIE (frame, afr_nonblocking_inodelk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLK, flock_use, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
-        } else {
-                call_count = internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
-
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->child_up[i])
-                                continue;
-                        AFR_TRACE_INODELK_IN (frame, this,
-                                              AFR_INODELK_NB_TRANSACTION,
-                                              AFR_LOCK_OP, &flock, F_SETLK, i);
-
-                        STACK_WIND_COOKIE (frame, afr_nonblocking_inodelk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLK, &flock, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+afr_lock_nonblocking(call_frame_t *frame, xlator_t *this)
+{
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int child = 0;
+    int lockee_num = 0;
+    int32_t call_count = 0;
+    int i = 0;
+    int ret = 0;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+
+    initialize_internal_lock_variables(frame, this);
+
+    if (local->fd) {
+        fd_ctx = afr_fd_ctx_get(local->fd, this);
+        if (!fd_ctx) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_FD_CTX_GET_FAILED,
+                   "unable to get fd ctx for fd=%p", local->fd);
+
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
+            local->op_errno = EINVAL;
+            int_lock->lock_op_errno = EINVAL;
+
+            afr_unlock_now(frame, this);
+            ret = -1;
+            goto out;
+        }
+    }
+
+    call_count = int_lock->lockee_count * internal_lock_count(frame, this);
+    int_lock->lk_call_count = call_count;
+    int_lock->lk_expected_count = call_count;
+
+    if (!call_count) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_INFO_COMMON,
+               "fd not open on any subvolumes. aborting.");
+        afr_unlock_now(frame, this);
+        goto out;
+    }
+
+    /* Send non-blocking lock calls only on up children
+       and where the fd has been opened */
+    for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
+        child = i % priv->child_count;
+        lockee_num = i / priv->child_count;
+        if (local->child_up[child]) {
+            afr_internal_lock_wind(frame, afr_nb_internal_lock_cbk,
+                                   (void *)(long)i, child, lockee_num,
+                                   _gf_false, _gf_false);
+            if (!--call_count)
+                break;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_unlock (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-
-        local = frame->local;
-
-        if (transaction_lk_op (local)) {
-                if (afr_is_inodelk_transaction(local))
-                        afr_unlock_inodelk (frame, this);
-                else
-                        afr_unlock_entrylk (frame, this);
-
-        } else {
-                if (is_afr_lock_selfheal (local))
-                        afr_unlock_inodelk (frame, this);
-                else
-                        afr_unlock_entrylk (frame, this);
-        }
-
+afr_unlock(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_lock_t *lock = NULL;
+
+    local = frame->local;
+
+    if (!local->transaction.eager_lock_on)
+        goto out;
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        list_del_init(&local->transaction.owner_list);
+        if (list_empty(&lock->owners) && list_empty(&lock->post_op)) {
+            local->transaction.do_eager_unlock = _gf_true;
+            /*TODO: Need to get metadata use on_disk and inherit/uninherit
+             *GF_ASSERT (!local->inode_ctx->on_disk[local->transaction.type]);
+             *GF_ASSERT (!local->inode_ctx->inherited[local->transaction.type]);
+             */
+            GF_ASSERT(lock->release);
+        }
+    }
+    UNLOCK(&local->inode->lock);
+    if (!local->transaction.do_eager_unlock) {
+        local->internal_lock.lock_cbk(frame, this);
         return 0;
-}
-
-int
-afr_lk_transfer_datalock (call_frame_t *dst, call_frame_t *src, char *dom,
-                          unsigned int child_count)
-{
-        afr_local_t         *dst_local   = NULL;
-        afr_local_t         *src_local   = NULL;
-        afr_internal_lock_t *dst_lock    = NULL;
-        afr_internal_lock_t *src_lock    = NULL;
-        afr_inodelk_t       *dst_inodelk = NULL;
-        afr_inodelk_t       *src_inodelk = NULL;
-        int                 ret = -1;
-
-        src_local = src->local;
-        src_lock  = &src_local->internal_lock;
-        src_inodelk = afr_get_inodelk (src_lock, dom);
-        dst_local = dst->local;
-        dst_lock  = &dst_local->internal_lock;
-        dst_inodelk = afr_get_inodelk (dst_lock, dom);
-        if (!dst_inodelk || !src_inodelk)
-                goto out;
-        if (src_inodelk->locked_nodes) {
-                memcpy (dst_inodelk->locked_nodes, src_inodelk->locked_nodes,
-                        sizeof (*dst_inodelk->locked_nodes) * child_count);
-                memset (src_inodelk->locked_nodes, 0,
-                        sizeof (*src_inodelk->locked_nodes) * child_count);
-        }
+    }
 
-        dst_lock->transaction_lk_type = src_lock->transaction_lk_type;
-        dst_lock->selfheal_lk_type    = src_lock->selfheal_lk_type;
-        dst_inodelk->lock_count = src_inodelk->lock_count;
-        src_inodelk->lock_count = 0;
-        ret = 0;
 out:
-        return ret;
+    afr_unlock_now(frame, this);
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-mem-types.h b/xlators/cluster/afr/src/afr-mem-types.h
index c7d6261b110..816065fb57a 100644
--- a/xlators/cluster/afr/src/afr-mem-types.h
+++ b/xlators/cluster/afr/src/afr-mem-types.h
@@ -8,46 +8,31 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef __AFR_MEM_TYPES_H__
 #define __AFR_MEM_TYPES_H__
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 enum gf_afr_mem_types_ {
-        gf_afr_mt_iovec  = gf_common_mt_end + 1,
-        gf_afr_mt_afr_fd_ctx_t,
-        gf_afr_mt_afr_private_t,
-        gf_afr_mt_int32_t,
-        gf_afr_mt_char,
-        gf_afr_mt_xattr_key,
-        gf_afr_mt_dict_t,
-        gf_afr_mt_xlator_t,
-        gf_afr_mt_iatt,
-        gf_afr_mt_int,
-        gf_afr_mt_afr_node_character,
-        gf_afr_mt_sh_diff_loop_state,
-        gf_afr_mt_uint8_t,
-        gf_afr_mt_loc_t,
-        gf_afr_mt_entry_name,
-        gf_afr_mt_pump_priv,
-        gf_afr_mt_locked_fd,
-        gf_afr_mt_inode_ctx_t,
-        gf_afr_fd_paused_call_t,
-        gf_afr_mt_crawl_data_t,
-        gf_afr_mt_brick_pos_t,
-        gf_afr_mt_shd_bool_t,
-        gf_afr_mt_shd_timer_t,
-        gf_afr_mt_shd_event_t,
-        gf_afr_mt_time_t,
-        gf_afr_mt_pos_data_t,
-	gf_afr_mt_reply_t,
-	gf_afr_mt_subvol_healer_t,
-	gf_afr_mt_spbc_timeout_t,
-        gf_afr_mt_spb_status_t,
-        gf_afr_mt_empty_brick_t,
-        gf_afr_mt_child_latency_t,
+    gf_afr_mt_afr_fd_ctx_t = gf_common_mt_end + 1,
+    gf_afr_mt_afr_private_t,
+    gf_afr_mt_int32_t,
+    gf_afr_mt_char,
+    gf_afr_mt_xattr_key,
+    gf_afr_mt_dict_t,
+    gf_afr_mt_xlator_t,
+    gf_afr_mt_afr_node_character,
+    gf_afr_mt_inode_ctx_t,
+    gf_afr_mt_shd_event_t,
+    gf_afr_mt_reply_t,
+    gf_afr_mt_subvol_healer_t,
+    gf_afr_mt_spbc_timeout_t,
+    gf_afr_mt_spb_status_t,
+    gf_afr_mt_empty_brick_t,
+    gf_afr_mt_child_latency_t,
+    gf_afr_mt_atomic_t,
+    gf_afr_mt_lk_heal_info_t,
+    gf_afr_mt_gf_lock,
     gf_afr_mt_end
 };
 #endif
-
diff --git a/xlators/cluster/afr/src/afr-messages.h b/xlators/cluster/afr/src/afr-messages.h
index 02eb206fd08..e73fd997765 100644
--- a/xlators/cluster/afr/src/afr-messages.h
+++ b/xlators/cluster/afr/src/afr-messages.h
@@ -11,363 +11,157 @@
 #ifndef _AFR_MESSAGES_H_
 #define _AFR_MESSAGES_H_
 
-#include "glfs-message-id.h"
-
-/*! \file afr-messages.h
- *  \brief AFR log-message IDs and their descriptions.
- */
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- * if the message format is the same. Reasoning is that, if the message
- * format needs to change in one instance, the other instances are not
- * impacted or the new change does not change the ID of the instance being
- * modified.
- * 2) Addition of a message,
- * - Should increment the GLFS_NUM_MESSAGES
- * - Append to the list of messages defined, towards the end
- * - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- * anywhere. If reused then then the modifications should ensure correctness
- * everywhere, or needs a new message ID as (1) above was not adhered to. If
- * not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- * anywhere, then can be deleted, but will leave a hole by design, as
- * addition rules specify modification to the end of the list and not filling
- * holes.
+#include <glusterfs/glfs-message-id.h>
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
  */
 
-#define GLFS_COMP_BASE_AFR      GLFS_MSGID_COMP_AFR
-#define GLFS_NUM_MESSAGES       42
-#define GLFS_MSGID_END          (GLFS_COMP_BASE_AFR + GLFS_NUM_MESSAGES + 1)
-
-#define glfs_msg_start_x GLFS_COMP_BASE_AFR, "Invalid: Start of messages"
-
-/*!
- * @messageid 108001
- * @diagnosis Client quorum is not met due to which file modification
- * operations are disallowed.
- * @recommendedaction Some brick processes are down/ not visible from the
- * client. Ensure that the bricks are up/ network traffic is not blocked.
- */
-#define AFR_MSG_QUORUM_FAIL             (GLFS_COMP_BASE_AFR + 1)
-
-
-/*!
- * @messageid 108002
- * @diagnosis The bricks that were down are now up and quorum is restored.
- * @recommendedaction Possibly check why the bricks went down to begin with.
- */
-#define AFR_MSG_QUORUM_MET              (GLFS_COMP_BASE_AFR + 2)
-
-
-/*!
- * @messageid 108003
- * @diagnosis Client quorum-type was set to auto due to which the quorum-count
- * option is no longer valid.
- * @recommendedaction None.
- */
-#define AFR_MSG_QUORUM_OVERRIDE         (GLFS_COMP_BASE_AFR + 3)
-
-
-/*!
- * @messageid 108004
- * @diagnosis Replication sub volume witnessed a connection notification
- * from a brick which does not belong to its replica set.
- * @recommendedaction None. This is a safety check in code.
- */
-#define AFR_MSG_INVALID_CHILD_UP        (GLFS_COMP_BASE_AFR + 4)
-
-
-/*!
- * @messageid 108005
- * @diagnosis A replica set that was inaccessible because all its bricks were
- * down is now accessible because at least one of its bricks came back up.
- * @recommendedaction Possibly check why all the bricks of that replica set
- * went down to begin with.
- */
-#define AFR_MSG_SUBVOL_UP               (GLFS_COMP_BASE_AFR + 5)
-
-
-/*!
- * @messageid 108006
- * @diagnosis bricks of a replica set are down. Data residing in that
- * replica cannot be accessed until one of the bricks come back up.
- * @recommendedaction Ensure that the bricks are up.
- */
-#define AFR_MSG_SUBVOLS_DOWN            (GLFS_COMP_BASE_AFR + 6)
-
-
-/*!
- * @messageid 108007
- * @diagnosis Entry unlocks failed on a brick.
- * @recommendedaction Error number in the log should give the reason why it
- * failed. Also observe brick logs for more information.
-*/
-#define AFR_MSG_ENTRY_UNLOCK_FAIL       (GLFS_COMP_BASE_AFR + 7)
-
-
-/*!
- * @messageid 108008
- * @diagnosis There is an inconsistency in the file's data/metadata/gfid
- * amongst the bricks of a replica set.
- * @recommendedaction Resolve the split brain by clearing the AFR changelog
- * attributes from the appropriate brick and trigger self-heal.
- */
-#define AFR_MSG_SPLIT_BRAIN             (GLFS_COMP_BASE_AFR + 8)
-
-
-/*!
- * @messageid 108009
- * @diagnosis open/opendir failed on a brick.
- * @recommendedaction Error number in the log should give the reason why it
- * failed. Also observe brick logs for more information.
- */
-#define AFR_MSG_OPEN_FAIL               (GLFS_COMP_BASE_AFR + 9)
-
-
-/*!
- * @messageid 108010
- * @diagnosis unlocks failed on a brick.
- * @recommendedaction Error number in the log should give the reason why it
- * failed. Also observe brick logs for more information.
-*/
-#define AFR_MSG_UNLOCK_FAIL       (GLFS_COMP_BASE_AFR + 10)
-
-/*!
- * @messageid 108011
- * @diagnosis Setting of pending xattrs succeeded/failed during replace-brick
- * operation.
- * @recommendedaction In case of failure, error number in the log should give
- * the reason why it failed. Also observe brick logs for more information.
-*/
-#define AFR_MSG_REPLACE_BRICK_STATUS     (GLFS_COMP_BASE_AFR + 11)
-
-/*!
- * @messageid 108012
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_GFID_NULL                       (GLFS_COMP_BASE_AFR + 12)
-
-/*!
- * @messageid 108013
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_FD_CREATE_FAILED                (GLFS_COMP_BASE_AFR + 13)
-
-/*!
- * @messageid 108014
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_DICT_SET_FAILED                 (GLFS_COMP_BASE_AFR + 14)
-
-/*!
- * @messageid 108015
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_EXPUNGING_FILE_OR_DIR           (GLFS_COMP_BASE_AFR + 15)
-
-/*!
- * @messageid 108016
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_MIGRATION_IN_PROGRESS           (GLFS_COMP_BASE_AFR + 16)
-
-/*!
- * @messageid 108017
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_CHILD_MISCONFIGURED             (GLFS_COMP_BASE_AFR + 17)
-
-/*!
- * @messageid 108018
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_VOL_MISCONFIGURED               (GLFS_COMP_BASE_AFR + 18)
-
-/*!
- * @messageid 108019
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_BLOCKING_LKS_FAILED             (GLFS_COMP_BASE_AFR + 19)
-
-/*!
- * @messageid 108020
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INVALID_FD                      (GLFS_COMP_BASE_AFR + 20)
-
-/*!
- * @messageid 108021
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_LOCK_INFO                       (GLFS_COMP_BASE_AFR + 21)
-
-/*!
- * @messageid 108022
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_LOCK_XLATOR_NOT_LOADED          (GLFS_COMP_BASE_AFR + 22)
-
-/*!
- * @messageid 108023
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_FD_CTX_GET_FAILED               (GLFS_COMP_BASE_AFR + 23)
-
-/*!
- * @messageid 108024
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INVALID_SUBVOL                    (GLFS_COMP_BASE_AFR + 24)
-
-/*!
- * @messageid 108025
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_PUMP_XLATOR_ERROR               (GLFS_COMP_BASE_AFR + 25)
-
-/*!
- * @messageid 108026
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_SELF_HEAL_INFO                  (GLFS_COMP_BASE_AFR + 26)
-
-/*!
- * @messageid 108027
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_READ_SUBVOL_ERROR               (GLFS_COMP_BASE_AFR + 27)
-
-/*!
- * @messageid 108028
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_DICT_GET_FAILED                 (GLFS_COMP_BASE_AFR + 28)
-
-
-/*!
- * @messageid 108029
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INFO_COMMON                     (GLFS_COMP_BASE_AFR + 29)
-
-/*!
- * @messageid 108030
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR         (GLFS_COMP_BASE_AFR + 30)
-
-/*!
- * @messageid 108031
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_LOCAL_CHILD         (GLFS_COMP_BASE_AFR + 31)
-
-/*!
- * @messageid 108032
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INVALID_DATA         (GLFS_COMP_BASE_AFR + 32)
-
-/*!
- * @messageid 108033
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INVALID_ARG         (GLFS_COMP_BASE_AFR + 33)
-
-/*!
- * @messageid 108034
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_INDEX_DIR_GET_FAILED         (GLFS_COMP_BASE_AFR + 34)
-
-/*!
- * @messageid 108035
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_FSYNC_FAILED         (GLFS_COMP_BASE_AFR + 35)
-
-/*!
- * @messageid 108036
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_FAVORITE_CHILD         (GLFS_COMP_BASE_AFR + 36)
-/*!
- * @messageid 108037
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_SELF_HEAL_FAILED                (GLFS_COMP_BASE_AFR + 37)
-
-/*!
- * @messageid 108038
- * @diagnosis
- * @recommendedaction
-*/
-#define AFR_MSG_SPLIT_BRAIN_STATUS      (GLFS_COMP_BASE_AFR + 38)
-
-/*!
- * @messageid 108039
- * @diagnosis Setting of pending xattrs succeeded/failed during add-brick
- * operation.
- * @recommendedaction In case of failure, error number in the log should give
- * the reason why it failed. Also observe brick logs for more information.
-*/
-#define AFR_MSG_ADD_BRICK_STATUS        (GLFS_COMP_BASE_AFR + 39)
-
-
-/*!
- * @messageid 108040
- * @diagnosis AFR was unable to be loaded because the pending-changelog xattrs
- * were not found in the volfile.
- * @recommendedaction Please ensure cluster op-version is atleast 30707 and the
- * volfiles are regenerated.
-*/
-#define AFR_MSG_NO_CHANGELOG  (GLFS_COMP_BASE_AFR + 40)
-
-/*!
- * @messageid 108041
- * @diagnosis Unable to create timer thread for delayed initialization.
- * @recommendedaction Possibly check process's log file for messages from
- * timer infra.
-*/
-#define AFR_MSG_TIMER_CREATE_FAIL               (GLFS_COMP_BASE_AFR + 41)
-
-/*!
- * @messageid 108042
- * @diagnosis Log messages relating to automated resolution of split-brain files
- * based on favorite child policies.
- * @recommendedaction
-*/
-#define AFR_MSG_SBRAIN_FAV_CHILD_POLICY  (GLFS_COMP_BASE_AFR + 42)
-
-#define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
+GLFS_MSGID(
+    AFR, AFR_MSG_QUORUM_FAIL, AFR_MSG_QUORUM_MET, AFR_MSG_QUORUM_OVERRIDE,
+    AFR_MSG_INVALID_CHILD_UP, AFR_MSG_SUBVOL_UP, AFR_MSG_SUBVOLS_DOWN,
+    AFR_MSG_ENTRY_UNLOCK_FAIL, AFR_MSG_SPLIT_BRAIN, AFR_MSG_OPEN_FAIL,
+    AFR_MSG_UNLOCK_FAIL, AFR_MSG_REPLACE_BRICK_STATUS, AFR_MSG_GFID_NULL,
+    AFR_MSG_FD_CREATE_FAILED, AFR_MSG_DICT_SET_FAILED,
+    AFR_MSG_EXPUNGING_FILE_OR_DIR, AFR_MSG_MIGRATION_IN_PROGRESS,
+    AFR_MSG_CHILD_MISCONFIGURED, AFR_MSG_VOL_MISCONFIGURED,
+    AFR_MSG_INTERNAL_LKS_FAILED, AFR_MSG_INVALID_FD, AFR_MSG_LOCK_INFO,
+    AFR_MSG_LOCK_XLATOR_NOT_LOADED, AFR_MSG_FD_CTX_GET_FAILED,
+    AFR_MSG_INVALID_SUBVOL, AFR_MSG_PUMP_XLATOR_ERROR, AFR_MSG_SELF_HEAL_INFO,
+    AFR_MSG_READ_SUBVOL_ERROR, AFR_MSG_DICT_GET_FAILED, AFR_MSG_INFO_COMMON,
+    AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR, AFR_MSG_LOCAL_CHILD, AFR_MSG_INVALID_DATA,
+    AFR_MSG_INVALID_ARG, AFR_MSG_INDEX_DIR_GET_FAILED, AFR_MSG_FSYNC_FAILED,
+    AFR_MSG_FAVORITE_CHILD, AFR_MSG_SELF_HEAL_FAILED,
+    AFR_MSG_SPLIT_BRAIN_STATUS, AFR_MSG_ADD_BRICK_STATUS, AFR_MSG_NO_CHANGELOG,
+    AFR_MSG_TIMER_CREATE_FAIL, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+    AFR_MSG_INODE_CTX_GET_FAILED, AFR_MSG_THIN_ARB,
+    AFR_MSG_THIN_ARB_XATTROP_FAILED, AFR_MSG_THIN_ARB_LOC_POP_FAILED,
+    AFR_MSG_GET_PEND_VAL, AFR_MSG_THIN_ARB_SKIP_SHD, AFR_MSG_UNKNOWN_SET,
+    AFR_MSG_NO_XL_ID, AFR_MSG_SELF_HEAL_INFO_START,
+    AFR_MSG_SELF_HEAL_INFO_FINISH, AFR_MSG_INCRE_COUNT,
+    AFR_MSG_ADD_TO_OUTPUT_FAILED, AFR_MSG_SET_TIME_FAILED,
+    AFR_MSG_GFID_MISMATCH_DETECTED, AFR_MSG_GFID_HEAL_MSG,
+    AFR_MSG_THIN_ARB_LOOKUP_FAILED, AFR_MSG_DICT_CREATE_FAILED,
+    AFR_MSG_NO_MAJORITY_TO_RESOLVE, AFR_MSG_TYPE_MISMATCH,
+    AFR_MSG_SIZE_POLICY_NOT_APPLICABLE, AFR_MSG_NO_CHILD_SELECTED,
+    AFR_MSG_INVALID_CHILD, AFR_MSG_RESOLVE_CONFLICTING_DATA,
+    SERROR_GETTING_SRC_BRICK, SNO_DIFF_IN_MTIME, SNO_BIGGER_FILE,
+    SALL_BRICKS_UP_TO_RESOLVE, AFR_MSG_UNLOCK_FAILED, AFR_MSG_POST_OP_FAILED,
+    AFR_MSG_TA_FRAME_CREATE_FAILED, AFR_MSG_SET_KEY_XATTROP_FAILED,
+    AFR_MSG_BLOCKING_ENTRYLKS_FAILED, AFR_MSG_FOP_FAILED,
+    AFR_MSG_CLEAN_UP_FAILED, AFR_MSG_UNABLE_TO_FETCH, AFR_MSG_XATTR_SET_FAILED,
+    AFR_MSG_SPLIT_BRAIN_REPLICA, AFR_MSG_INODE_CTX_FAILED,
+    AFR_MSG_LOOKUP_FAILED, AFR_MSG_ALL_SUBVOLS_DOWN,
+    AFR_MSG_RELEASE_LOCK_FAILED, AFR_MSG_CLEAR_TIME_SPLIT_BRAIN,
+    AFR_MSG_READ_FAILED, AFR_MSG_LAUNCH_FAILED, AFR_MSG_READ_SUBVOL_NOT_UP,
+    AFR_MSG_LK_HEAL_DOM, AFR_MSG_NEW_BRICK, AFR_MSG_SPLIT_BRAIN_SET_FAILED,
+    AFR_MSG_SPLIT_BRAIN_DETERMINE_FAILED, AFR_MSG_HEALER_SPAWN_FAILED,
+    AFR_MSG_ADD_CRAWL_EVENT_FAILED, AFR_MSG_NULL_DEREF, AFR_MSG_SET_PEND_XATTR,
+    AFR_MSG_INTERNAL_ATTR);
+
+#define AFR_MSG_DICT_GET_FAILED_STR "Dict get failed"
+#define AFR_MSG_DICT_SET_FAILED_STR "Dict set failed"
+#define AFR_MSG_HEALER_SPAWN_FAILED_STR "Healer spawn failed"
+#define AFR_MSG_ADD_CRAWL_EVENT_FAILED_STR "Adding crawl event failed"
+#define AFR_MSG_INVALID_ARG_STR "Invalid argument"
+#define AFR_MSG_INDEX_DIR_GET_FAILED_STR "unable to get index-dir on "
+#define AFR_MSG_THIN_ARB_LOOKUP_FAILED_STR "Failed lookup on file"
+#define AFR_MSG_DICT_CREATE_FAILED_STR "Failed to create dict."
+#define AFR_MSG_THIN_ARB_XATTROP_FAILED_STR "Xattrop failed."
+#define AFR_MSG_THIN_ARB_LOC_POP_FAILED_STR                                    \
+    "Failed to populate loc for thin-arbiter"
+#define AFR_MSG_GET_PEND_VAL_STR "Error getting value of pending"
+#define AFR_MSG_THIN_ARB_SKIP_SHD_STR "I am not the god shd. skipping."
+#define AFR_MSG_UNKNOWN_SET_STR "Unknown set"
+#define AFR_MSG_NO_XL_ID_STR "xl does not have id"
+#define AFR_MSG_SELF_HEAL_INFO_START_STR "starting full sweep on"
+#define AFR_MSG_SELF_HEAL_INFO_FINISH_STR "finished full sweep on"
+#define AFR_MSG_INCRE_COUNT_STR "Could not increment the counter."
+#define AFR_MSG_ADD_TO_OUTPUT_FAILED_STR "Could not add to output"
+#define AFR_MSG_SET_TIME_FAILED_STR "Could not set time"
+#define AFR_MSG_GFID_HEAL_MSG_STR "Error setting gfid-heal-msg dict"
+#define AFR_MSG_NO_MAJORITY_TO_RESOLVE_STR                                     \
+    "No majority to resolve gfid split brain"
+#define AFR_MSG_GFID_MISMATCH_DETECTED_STR "Gfid mismatch dectected"
+#define AFR_MSG_SELF_HEAL_INFO_STR "performing selfheal"
+#define AFR_MSG_TYPE_MISMATCH_STR "TYPE mismatch"
+#define AFR_MSG_SIZE_POLICY_NOT_APPLICABLE_STR                                 \
+    "Size policy is not applicable to directories."
+#define AFR_MSG_NO_CHILD_SELECTED_STR                                          \
+    "No child selected by favorite-child policy"
+#define AFR_MSG_INVALID_CHILD_STR "Invalid child"
+#define AFR_MSG_RESOLVE_CONFLICTING_DATA_STR                                   \
+    "selected as authentic to resolve conflicting data"
+#define SERROR_GETTING_SRC_BRICK_STR "Error getting the source brick"
+#define SNO_DIFF_IN_MTIME_STR "No difference in mtime"
+#define SNO_BIGGER_FILE_STR "No bigger file"
+#define SALL_BRICKS_UP_TO_RESOLVE_STR                                          \
+    "All the bricks should be up to resolve the gfid split brain"
+#define AFR_MSG_UNLOCK_FAILED_STR "Failed to unlock"
+#define AFR_MSG_POST_OP_FAILED_STR "Post-op on thin-arbiter failed"
+#define AFR_MSG_TA_FRAME_CREATE_FAILED_STR "Failed to create ta_frame"
+#define AFR_MSG_SET_KEY_XATTROP_FAILED_STR "Could not set key during xattrop"
+#define AFR_MSG_BLOCKING_ENTRYLKS_FAILED_STR "Blocking entrylks failed"
+#define AFR_MSG_FSYNC_FAILED_STR "fsync failed"
+#define AFR_MSG_QUORUM_FAIL_STR "quorum is not met"
+#define AFR_MSG_FOP_FAILED_STR "Failing Fop"
+#define AFR_MSG_INVALID_SUBVOL_STR "not a subvolume"
+#define AFR_MSG_VOL_MISCONFIGURED_STR "Volume is dangling"
+#define AFR_MSG_CHILD_MISCONFIGURED_STR                                        \
+    "replicate translator needs more than one subvolume defined"
+#define AFR_MSG_CLEAN_UP_FAILED_STR "Failed to clean up healer threads"
+#define AFR_MSG_QUORUM_OVERRIDE_STR "overriding quorum-count"
+#define AFR_MSG_UNABLE_TO_FETCH_STR                                            \
+    "Unable to fetch afr-pending-xattr option from volfile. Falling back to "  \
+    "using client translator names"
+#define AFR_MSG_NULL_DEREF_STR "possible NULL deref"
+#define AFR_MSG_XATTR_SET_FAILED_STR "Cannot set xattr cookie key"
+#define AFR_MSG_SPLIT_BRAIN_STATUS_STR "Failed to create synctask"
+#define AFR_MSG_SUBVOLS_DOWN_STR "All subvolumes are not up"
+#define AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR_STR                                   \
+    "Failed to cancel split-brain choice"
+#define AFR_MSG_SPLIT_BRAIN_REPLICA_STR                                        \
+    "Cannot set replica. File is not in data/metadata split-brain"
+#define AFR_MSG_INODE_CTX_FAILED_STR "Failed to get inode_ctx"
+#define AFR_MSG_READ_SUBVOL_ERROR_STR "no read subvols"
+#define AFR_MSG_LOCAL_CHILD_STR "selecting local read-child"
+#define AFR_MSG_LOOKUP_FAILED_STR "Failed to lookup/create thin-arbiter id file"
+#define AFR_MSG_TIMER_CREATE_FAIL_STR                                          \
+    "Cannot create timer for delayed initialization"
+#define AFR_MSG_SUBVOL_UP_STR "Subvolume came back up; going online"
+#define AFR_MSG_ALL_SUBVOLS_DOWN_STR                                           \
+    "All subvolumes are down. Going offline until atleast one of them is up"
+#define AFR_MSG_RELEASE_LOCK_FAILED_STR "Failed to release lock"
+#define AFR_MSG_INVALID_CHILD_UP_STR "Received child_up from invalid subvolume"
+#define AFR_MSG_QUORUM_MET_STR "Client-quorum is met"
+#define AFR_MSG_EXPUNGING_FILE_OR_DIR_STR "expunging file or dir"
+#define AFR_MSG_SELF_HEAL_FAILED_STR "Invalid"
+#define AFR_MSG_SPLIT_BRAIN_STR "Skipping conservative mergeon the file"
+#define AFR_MSG_CLEAR_TIME_SPLIT_BRAIN_STR "clear time split brain"
+#define AFR_MSG_READ_FAILED_STR "Failing read since good brick is down"
+#define AFR_MSG_LAUNCH_FAILED_STR "Failed to launch synctask"
+#define AFR_MSG_READ_SUBVOL_NOT_UP_STR                                         \
+    "read subvolume in this generation is not up"
+#define AFR_MSG_INTERNAL_LKS_FAILED_STR                                        \
+    "Unable to work with lk-owner while attempting fop"
+#define AFR_MSG_LOCK_XLATOR_NOT_LOADED_STR                                     \
+    "subvolume does not support locking. please load features/locks xlator "   \
+    "on server."
+#define AFR_MSG_FD_CTX_GET_FAILED_STR "unable to get fd ctx"
+#define AFR_MSG_INFO_COMMON_STR "fd not open on any subvolumes, aborting."
+#define AFR_MSG_REPLACE_BRICK_STATUS_STR "Couldn't acquire lock on any child."
+#define AFR_MSG_NEW_BRICK_STR "New brick"
+#define AFR_MSG_SPLIT_BRAIN_SET_FAILED_STR                                     \
+    "Failed to set split-brain choice to -1"
+#define AFR_MSG_SPLIT_BRAIN_DETERMINE_FAILED_STR                               \
+    "Failed to determine split-brain. Aborting split-brain-choice set"
+#define AFR_MSG_OPEN_FAIL_STR "Failed to open subvolume"
+#define AFR_MSG_SET_PEND_XATTR_STR "Set of pending xattr"
+#define AFR_MSG_INTERNAL_ATTR_STR "is an internal extended attribute"
 #endif /* !_AFR_MESSAGES_H_ */
diff --git a/xlators/cluster/afr/src/afr-open.c b/xlators/cluster/afr/src/afr-open.c
index 7a628350c34..64856042b65 100644
--- a/xlators/cluster/afr/src/afr-open.c
+++ b/xlators/cluster/afr/src/afr-open.c
@@ -8,326 +8,346 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <libgen.h>
 #include <unistd.h>
-#include <fnmatch.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <signal.h>
 
-#include "glusterfs.h"
+#include <glusterfs/glusterfs.h>
 #include "afr.h"
-#include "dict.h"
-#include "xlator.h"
-#include "hashfn.h"
-#include "logging.h"
-#include "stack.h"
-#include "list.h"
-#include "call-stub.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "compat-errno.h"
-#include "compat.h"
-#include "byte-order.h"
-#include "statedump.h"
-
-#include "fd.h"
-
-#include "afr-inode-read.h"
-#include "afr-inode-write.h"
-#include "afr-dir-read.h"
-#include "afr-dir-write.h"
-#include "afr-transaction.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/defaults.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/compat.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/statedump.h>
 
+#include "afr-transaction.h"
 
 gf_boolean_t
-afr_is_fd_fixable (fd_t *fd)
+afr_is_fd_fixable(fd_t *fd)
 {
-        if (!fd || !fd->inode)
-                return _gf_false;
-        else if (fd_is_anonymous (fd))
-                return _gf_false;
-        else if (gf_uuid_is_null (fd->inode->gfid))
-                return _gf_false;
-
-        return _gf_true;
+    if (!fd || !fd->inode)
+        return _gf_false;
+    else if (fd_is_anonymous(fd))
+        return _gf_false;
+    else if (gf_uuid_is_null(fd->inode->gfid))
+        return _gf_false;
+
+    return _gf_true;
 }
 
-
 int
-afr_open_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_open_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        afr_local_t * local = frame->local;
+    afr_local_t *local = frame->local;
 
-        AFR_STACK_UNWIND (open, frame, local->op_ret, local->op_errno,
-                          local->fd, xdata);
-        return 0;
+    AFR_STACK_UNWIND(open, frame, local->op_ret, local->op_errno,
+                     local->cont.open.fd, xdata);
+    return 0;
 }
 
-
 int
-afr_open_cbk (call_frame_t *frame, void *cookie,
-              xlator_t *this, int32_t op_ret, int32_t op_errno,
-              fd_t *fd, dict_t *xdata)
+afr_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t *  local       = NULL;
-        int            call_count  = -1;
-        int            child_index = (long) cookie;
-	afr_fd_ctx_t  *fd_ctx = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                } else {
-                        local->op_ret = op_ret;
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-                }
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = (long)cookie;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+        } else {
+            local->op_ret = op_ret;
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                if ((fd_ctx->flags & O_TRUNC) && (local->op_ret >= 0)) {
-                        STACK_WIND (frame, afr_open_ftruncate_cbk,
-                                    this, this->fops->ftruncate,
-                                    fd, 0, NULL);
-                } else {
-                        AFR_STACK_UNWIND (open, frame, local->op_ret,
-                                          local->op_errno, local->fd,
-					  local->xdata_rsp);
-                }
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        afr_handle_replies_quorum(frame, this);
+        if (local->op_ret == -1) {
+            AFR_STACK_UNWIND(open, frame, local->op_ret, local->op_errno, NULL,
+                             NULL);
+        } else if (fd_ctx->flags & O_TRUNC) {
+            STACK_WIND(frame, afr_open_ftruncate_cbk, this,
+                       this->fops->ftruncate, fd, 0, NULL);
+        } else {
+            AFR_STACK_UNWIND(open, frame, local->op_ret, local->op_errno,
+                             local->cont.open.fd, local->xdata_rsp);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-          fd_t *fd, dict_t *xdata)
+afr_open_continue(call_frame_t *frame, xlator_t *this, int err)
 {
-        afr_private_t * priv       = NULL;
-        afr_local_t *   local      = NULL;
-        int             i          = 0;
-        int32_t         call_count = 0;
-        int32_t         op_errno   = 0;
-	afr_fd_ctx_t   *fd_ctx = NULL;
-
-        //We can't let truncation to happen outside transaction.
-
-        priv = this->private;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_OPEN;
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx) {
-		op_errno = ENOMEM;
-		goto out;
-	}
-
-        if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
-
-        local->fd = fd_ref (fd);
-	local->fd_ctx = fd_ctx;
-	fd_ctx->flags = flags;
-
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (err) {
+        AFR_STACK_UNWIND(open, frame, -1, err, NULL, NULL);
+    } else {
+        local->call_count = AFR_COUNT(local->child_up, priv->child_count);
         call_count = local->call_count;
 
-        local->cont.open.flags = flags;
-
         for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_open_cbk, (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->open,
-                                           loc, (flags & ~O_TRUNC), fd, xdata);
-                        if (!--call_count)
-                                break;
-                }
+            if (local->child_up[i]) {
+                STACK_WIND_COOKIE(frame, afr_open_cbk, (void *)(long)i,
+                                  priv->children[i],
+                                  priv->children[i]->fops->open, &local->loc,
+                                  (local->cont.open.flags & ~O_TRUNC),
+                                  local->cont.open.fd, local->xdata_req);
+                if (!--call_count)
+                    break;
+            }
         }
+    }
+    return 0;
+}
 
-	return 0;
+int
+afr_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+         fd_t *fd, dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int spb_subvol = 0;
+    int event_generation = 0;
+    int ret = 0;
+    int32_t op_errno = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    // We can't let truncation to happen outside transaction.
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_OPEN;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this, NULL)) {
+        op_errno = afr_quorum_errno(priv);
+        goto out;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    local->inode = inode_ref(loc->inode);
+    loc_copy(&local->loc, loc);
+    local->fd_ctx = fd_ctx;
+    fd_ctx->flags = flags;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    local->cont.open.flags = flags;
+    local->cont.open.fd = fd_ref(fd);
+
+    ret = afr_inode_get_readable(frame, local->inode, this, NULL,
+                                 &event_generation, AFR_DATA_TRANSACTION);
+    if ((ret < 0) &&
+        (afr_split_brain_read_subvol_get(local->inode, this, NULL,
+                                         &spb_subvol) == 0) &&
+        spb_subvol < 0) {
+        afr_inode_refresh(frame, this, local->inode, local->inode->gfid,
+                          afr_open_continue);
+    } else {
+        afr_open_continue(frame, this, 0);
+    }
+
+    return 0;
 out:
-	AFR_STACK_UNWIND (open, frame, -1, op_errno, fd, NULL);
+    AFR_STACK_UNWIND(open, frame, -1, op_errno, fd, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_openfd_fix_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, fd_t *fd,
-                         dict_t *xdata)
+afr_openfd_fix_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, fd_t *fd,
+                        dict_t *xdata)
 {
-        afr_local_t   *local      = NULL;
-        afr_private_t *priv       = NULL;
-        afr_fd_ctx_t  *fd_ctx     = NULL;
-        int           call_count  = 0;
-        int           child_index = (long) cookie;
-
-        priv     = this->private;
-        local    = frame->local;
-
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int call_count = 0;
+    int child_index = (long)cookie;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (op_ret >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "fd for %s opened "
+                     "successfully on subvolume %s",
+                     local->loc.path, priv->children[child_index]->name);
+    } else {
+        gf_smsg(this->name, fop_log_level(GF_FOP_OPEN, op_errno), op_errno,
+                AFR_MSG_OPEN_FAIL, "path=%s", local->loc.path, "subvolume=%s",
+                priv->children[child_index]->name, NULL);
+    }
+
+    fd_ctx = local->fd_ctx;
+
+    LOCK(&local->fd->lock);
+    {
         if (op_ret >= 0) {
-                gf_msg_debug (this->name, 0, "fd for %s opened "
-                              "successfully on subvolume %s", local->loc.path,
-                              priv->children[child_index]->name);
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
         } else {
-                gf_msg (this->name, fop_log_level (GF_FOP_OPEN, op_errno),
-                        op_errno, AFR_MSG_OPEN_FAIL, "Failed to open %s on "
-                        "subvolume %s", local->loc.path,
-                        priv->children[child_index]->name);
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
         }
+    }
+    UNLOCK(&local->fd->lock);
 
-        fd_ctx = local->fd_ctx;
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        AFR_STACK_DESTROY(frame);
 
-        LOCK (&local->fd->lock);
-        {
-                if (op_ret >= 0) {
-                        fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-                } else {
-                        fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                }
-        }
-        UNLOCK (&local->fd->lock);
+    return 0;
+}
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                AFR_STACK_DESTROY (frame);
+static int
+afr_fd_ctx_need_open(fd_t *fd, xlator_t *this, unsigned char *need_open)
+{
+    afr_fd_ctx_t *fd_ctx = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int count = 0;
+
+    priv = this->private;
 
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
         return 0;
-}
 
+    LOCK(&fd->lock);
+    {
+        for (i = 0; i < priv->child_count; i++) {
+            if (fd_ctx->opened_on[i] == AFR_FD_NOT_OPENED &&
+                priv->child_up[i]) {
+                fd_ctx->opened_on[i] = AFR_FD_OPENING;
+                need_open[i] = 1;
+                count++;
+            } else {
+                need_open[i] = 0;
+            }
+        }
+    }
+    UNLOCK(&fd->lock);
 
-static int
-afr_fd_ctx_need_open (fd_t *fd, xlator_t *this, unsigned char *need_open)
-{
-	afr_fd_ctx_t *fd_ctx = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int count = 0;
-
-	priv = this->private;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		return 0;
-
-	LOCK (&fd->lock);
-	{
-		for (i = 0; i < priv->child_count; i++) {
-			if (fd_ctx->opened_on[i] == AFR_FD_NOT_OPENED &&
-			    priv->child_up[i]) {
-				fd_ctx->opened_on[i] = AFR_FD_OPENING;
-				need_open[i] = 1;
-				count++;
-			} else {
-				need_open[i] = 0;
-			}
-		}
-	}
-	UNLOCK (&fd->lock);
-
-	return count;
+    return count;
 }
 
-
 void
-afr_fix_open (fd_t *fd, xlator_t *this)
+afr_fix_open(fd_t *fd, xlator_t *this)
 {
-        afr_private_t *priv    = NULL;
-        int           i        = 0;
-        call_frame_t  *frame   = NULL;
-        afr_local_t   *local   = NULL;
-        int           ret      = -1;
-        int32_t       op_errno = 0;
-        afr_fd_ctx_t  *fd_ctx  = NULL;
-	unsigned char *need_open = NULL;
-	int call_count = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int32_t op_errno = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    unsigned char *need_open = NULL;
+    int call_count = 0;
 
-        priv  = this->private;
+    priv = this->private;
 
-        if (!afr_is_fd_fixable (fd))
-                goto out;
+    if (!afr_is_fd_fixable(fd))
+        goto out;
 
-        fd_ctx = afr_fd_ctx_get (fd, this);
-        if (!fd_ctx)
-                goto out;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
+        goto out;
 
-	need_open = alloca0 (priv->child_count);
+    need_open = alloca0(priv->child_count);
 
-	call_count = afr_fd_ctx_need_open (fd, this, need_open);
-	if (!call_count)
-		goto out;
+    call_count = afr_fd_ctx_need_open(fd, this, need_open);
+    if (!call_count)
+        goto out;
 
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->loc.inode = inode_ref (fd->inode);
-        ret = loc_path (&local->loc, NULL);
-        if (ret < 0)
-                goto out;
+    local->loc.inode = inode_ref(fd->inode);
+    ret = loc_path(&local->loc, NULL);
+    if (ret < 0)
+        goto out;
 
-        local->fd = fd_ref (fd);
-	local->fd_ctx = fd_ctx;
+    local->fd = fd_ref(fd);
+    local->fd_ctx = fd_ctx;
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        gf_msg_debug (this->name, 0, "need open count: %d",
-                      call_count);
+    gf_msg_debug(this->name, 0, "need open count: %d", call_count);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!need_open[i])
-                        continue;
-
-                if (IA_IFDIR == fd->inode->ia_type) {
-                        gf_msg_debug (this->name, 0,
-                                      "opening fd for dir %s on subvolume %s",
-                                      local->loc.path, priv->children[i]->name);
-
-                        STACK_WIND_COOKIE (frame, afr_openfd_fix_open_cbk,
-                                           (void*) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->opendir,
-                                           &local->loc, local->fd,
-                                           NULL);
-                } else {
-                        gf_msg_debug (this->name, 0,
-                                      "opening fd for file %s on subvolume %s",
-                                      local->loc.path, priv->children[i]->name);
-
-                        STACK_WIND_COOKIE (frame, afr_openfd_fix_open_cbk,
-                                           (void *)(long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->open,
-                                           &local->loc,
-                                           fd_ctx->flags & (~O_TRUNC),
-                                           local->fd, NULL);
-                }
-
-		if (!--call_count)
-			break;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!need_open[i])
+            continue;
+
+        if (IA_IFDIR == fd->inode->ia_type) {
+            gf_msg_debug(this->name, 0, "opening fd for dir %s on subvolume %s",
+                         local->loc.path, priv->children[i]->name);
+
+            STACK_WIND_COOKIE(frame, afr_openfd_fix_open_cbk, (void *)(long)i,
+                              priv->children[i],
+                              priv->children[i]->fops->opendir, &local->loc,
+                              local->fd, NULL);
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "opening fd for file %s on subvolume %s",
+                         local->loc.path, priv->children[i]->name);
+
+            STACK_WIND_COOKIE(frame, afr_openfd_fix_open_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->open,
+                              &local->loc, fd_ctx->flags & (~O_TRUNC),
+                              local->fd, NULL);
         }
 
-	return;
+        if (!--call_count)
+            break;
+    }
+
+    return;
 out:
-        if (frame)
-                AFR_STACK_DESTROY (frame);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 }
diff --git a/xlators/cluster/afr/src/afr-read-txn.c b/xlators/cluster/afr/src/afr-read-txn.c
index 50e8040d33e..6fc2c75145c 100644
--- a/xlators/cluster/afr/src/afr-read-txn.c
+++ b/xlators/cluster/afr/src/afr-read-txn.c
@@ -12,107 +12,327 @@
 #include "afr-transaction.h"
 #include "afr-messages.h"
 
-int
-afr_read_txn_next_subvol (call_frame_t *frame, xlator_t *this)
+void
+afr_pending_read_increment(afr_private_t *priv, int child_index)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int subvol = -1;
-
-	local = frame->local;
-	priv = this->private;
-
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->readable[i]) {
-			/* don't even bother trying here.
-			   just mark as attempted and move on. */
-			local->read_attempted[i] = 1;
-			continue;
-		}
-
-		if (!local->read_attempted[i]) {
-			subvol = i;
-			break;
-		}
-	}
-
-	/* If no more subvols were available for reading, we leave
-	   @subvol as -1, which is an indication we have run out of
-	   readable subvols. */
-	if (subvol != -1)
-		local->read_attempted[subvol] = 1;
-	local->readfn (frame, this, subvol);
-
-	return 0;
+    if (child_index < 0 || child_index > priv->child_count)
+        return;
+
+    GF_ATOMIC_INC(priv->pending_reads[child_index]);
+}
+
+void
+afr_pending_read_decrement(afr_private_t *priv, int child_index)
+{
+    if (child_index < 0 || child_index > priv->child_count)
+        return;
+
+    GF_ATOMIC_DEC(priv->pending_reads[child_index]);
+}
+
+void
+afr_read_txn_wind(call_frame_t *frame, xlator_t *this, int subvol)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    afr_pending_read_decrement(priv, local->read_subvol);
+    local->read_subvol = subvol;
+    afr_pending_read_increment(priv, subvol);
+    local->readfn(frame, this, subvol);
 }
 
 int
-afr_read_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
+afr_read_txn_next_subvol(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	int read_subvol = 0;
-	inode_t *inode = NULL;
-	int ret = -1;
-        int spb_choice = -1;
-
-	local = frame->local;
-	inode = local->inode;
-
-        if (err) {
-                read_subvol = -1;
-                goto readfn;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int subvol = -1;
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->readable[i]) {
+            /* don't even bother trying here.
+               just mark as attempted and move on. */
+            local->read_attempted[i] = 1;
+            continue;
         }
 
-	read_subvol = afr_read_subvol_select_by_policy (inode, this,
-							local->readable, NULL);
-	if (read_subvol == -1) {
-                err = -EIO;
-                goto readfn;
+        if (!local->read_attempted[i]) {
+            subvol = i;
+            break;
         }
+    }
 
-	if (local->read_attempted[read_subvol]) {
-		afr_read_txn_next_subvol (frame, this);
-		return 0;
-	}
+    /* If no more subvols were available for reading, we leave
+       @subvol as -1, which is an indication we have run out of
+       readable subvols. */
+    if (subvol != -1)
+        local->read_attempted[subvol] = 1;
+    afr_read_txn_wind(frame, this, subvol);
 
-	local->read_attempted[read_subvol] = 1;
-readfn:
-        if (read_subvol == -1) {
-                ret = afr_inode_split_brain_choice_get (inode, this,
-                                                        &spb_choice);
-                if ((ret == 0) && spb_choice >= 0)
-                        read_subvol = spb_choice;
-        }
+    return 0;
+}
 
-        if (read_subvol == -1) {
-                AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN (-1, -err);
-        }
-	local->readfn (frame, this, read_subvol);
+static int
+afr_ta_read_txn_done(int ret, call_frame_t *ta_frame, void *opaque)
+{
+    STACK_DESTROY(ta_frame->root);
+    return 0;
+}
 
-	return 0;
+static int
+afr_ta_read_txn(void *opaque)
+{
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    int read_subvol = -1;
+    int query_child = AFR_CHILD_UNKNOWN;
+    int possible_bad_child = AFR_CHILD_UNKNOWN;
+    int ret = 0;
+    int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    dict_t *xdata_req = NULL;
+    dict_t *xdata_rsp = NULL;
+    int **pending = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    frame = (call_frame_t *)opaque;
+    this = frame->this;
+    local = frame->local;
+    priv = this->private;
+    query_child = local->read_txn_query_child;
+
+    if (query_child == AFR_CHILD_ZERO) {
+        possible_bad_child = AFR_CHILD_ONE;
+    } else if (query_child == AFR_CHILD_ONE) {
+        possible_bad_child = AFR_CHILD_ZERO;
+    } else {
+        /*read_txn_query_child is AFR_CHILD_UNKNOWN*/
+        goto out;
+    }
+
+    /* Ask the query_child to see if it blames the possibly bad one. */
+    xdata_req = dict_new();
+    if (!xdata_req)
+        goto out;
+
+    pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!pending)
+        goto out;
+
+    ret = afr_set_pending_dict(priv, xdata_req, pending);
+    if (ret < 0)
+        goto out;
+
+    if (local->fd) {
+        ret = syncop_fxattrop(priv->children[query_child], local->fd,
+                              GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
+                              NULL);
+    } else {
+        ret = syncop_xattrop(priv->children[query_child], &local->loc,
+                             GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
+                             NULL);
+    }
+    if (ret || !xdata_rsp) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed xattrop for gfid %s on %s",
+               uuid_utoa(local->inode->gfid),
+               priv->children[query_child]->name);
+        op_errno = -ret;
+        goto out;
+    }
+
+    if (afr_ta_dict_contains_pending_xattr(xdata_rsp, priv,
+                                           possible_bad_child)) {
+        read_subvol = query_child;
+        goto out;
+    }
+    dict_unref(xdata_rsp);
+    xdata_rsp = NULL;
+
+    /* It doesn't. So query thin-arbiter to see if it blames any data brick. */
+    ret = afr_fill_ta_loc(this, &loc, _gf_true);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        goto out;
+    }
+    flock.l_type = F_WRLCK; /*start and length are already zero. */
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, &loc, F_SETLKW, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed to get AFR_TA_DOM_MODIFY lock on %s.",
+               uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+        op_errno = -ret;
+        goto out;
+    }
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                         GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
+                         NULL);
+    if (ret || !xdata_rsp) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed xattrop on %s.", uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+        op_errno = -ret;
+        goto unlock;
+    }
+
+    if (!afr_ta_dict_contains_pending_xattr(xdata_rsp, priv, query_child)) {
+        read_subvol = query_child;
+    } else {
+        gf_msg(this->name, GF_LOG_ERROR, EIO, AFR_MSG_THIN_ARB,
+               "Failing read for gfid %s since good brick %s is down",
+               uuid_utoa(local->inode->gfid),
+               priv->children[possible_bad_child]->name);
+        op_errno = EIO;
+    }
+
+unlock:
+    flock.l_type = F_UNLCK;
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, &loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed to unlock AFR_TA_DOM_MODIFY lock on "
+               "%s.",
+               uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+    }
+out:
+    if (xdata_req)
+        dict_unref(xdata_req);
+    if (xdata_rsp)
+        dict_unref(xdata_rsp);
+    if (pending)
+        afr_matrix_cleanup(pending, priv->child_count);
+    loc_wipe(&loc);
+
+    if (read_subvol == -1) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
+    afr_read_txn_wind(frame, this, read_subvol);
+    return ret;
 }
 
+void
+afr_ta_read_txn_synctask(call_frame_t *frame, xlator_t *this)
+{
+    call_frame_t *ta_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    ta_frame = afr_ta_frame_create(this);
+    if (!ta_frame) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to create ta_frame");
+        goto out;
+    }
+    ret = synctask_new(this->ctx->env, afr_ta_read_txn, afr_ta_read_txn_done,
+                       ta_frame, frame);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to launch "
+               "afr_ta_read_txn synctask for gfid %s.",
+               uuid_utoa(local->inode->gfid));
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        STACK_DESTROY(ta_frame->root);
+        goto out;
+    }
+    return;
+out:
+    afr_read_txn_wind(frame, this, -1);
+}
 
 int
-afr_read_txn_continue (call_frame_t *frame, xlator_t *this, int subvol)
+afr_read_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
 {
-	afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int read_subvol = -1;
+    inode_t *inode = NULL;
+    int ret = -1;
+    int spb_subvol = -1;
+
+    local = frame->local;
+    inode = local->inode;
+    priv = this->private;
+
+    if (err) {
+        if (!priv->thin_arbiter_count)
+            goto readfn;
+        if (err != EINVAL)
+            goto readfn;
+        /* We need to query the good bricks and/or thin-arbiter.*/
+        afr_ta_read_txn_synctask(frame, this);
+        return 0;
+    }
+
+    read_subvol = afr_read_subvol_select_by_policy(inode, this, local->readable,
+                                                   NULL);
+    if (read_subvol == -1) {
+        err = EIO;
+        goto readfn;
+    }
+
+    if (local->read_attempted[read_subvol]) {
+        afr_read_txn_next_subvol(frame, this);
+        return 0;
+    }
+
+    local->read_attempted[read_subvol] = 1;
+readfn:
+    if (read_subvol == -1) {
+        ret = afr_split_brain_read_subvol_get(inode, this, frame, &spb_subvol);
+        if ((ret == 0) && spb_subvol >= 0)
+            read_subvol = spb_subvol;
+    }
+
+    if (read_subvol == -1) {
+        AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, err);
+    }
+    afr_read_txn_wind(frame, this, read_subvol);
+
+    return 0;
+}
 
-	local = frame->local;
+int
+afr_read_txn_continue(call_frame_t *frame, xlator_t *this, int subvol)
+{
+    afr_local_t *local = NULL;
 
-	if (!local->refreshed) {
-		local->refreshed = _gf_true;
-		afr_inode_refresh (frame, this, local->inode, NULL,
-				   afr_read_txn_refresh_done);
-	} else {
-		afr_read_txn_next_subvol (frame, this);
-	}
+    local = frame->local;
 
-	return 0;
-}
+    if (!local->refreshed) {
+        local->refreshed = _gf_true;
+        afr_inode_refresh(frame, this, local->inode, NULL,
+                          afr_read_txn_refresh_done);
+    } else {
+        afr_read_txn_next_subvol(frame, this);
+    }
 
+    return 0;
+}
 
 /* afr_read_txn_wipe:
 
@@ -122,27 +342,26 @@ afr_read_txn_continue (call_frame_t *frame, xlator_t *this, int subvol)
 */
 
 void
-afr_read_txn_wipe (call_frame_t *frame, xlator_t *this)
+afr_read_txn_wipe(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	local->readfn = NULL;
+    local->readfn = NULL;
 
-	if (local->inode)
-		inode_unref (local->inode);
+    if (local->inode)
+        inode_unref(local->inode);
 
-	for (i = 0; i < priv->child_count; i++) {
-		local->read_attempted[i] = 0;
-		local->readable[i] = 0;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        local->read_attempted[i] = 0;
+        local->readable[i] = 0;
+    }
 }
 
-
 /*
   afr_read_txn:
 
@@ -171,88 +390,105 @@ afr_read_txn_wipe (call_frame_t *frame, xlator_t *this)
 */
 
 int
-afr_read_txn (call_frame_t *frame, xlator_t *this, inode_t *inode,
-	      afr_read_txn_wind_t readfn, afr_transaction_type type)
+afr_read_txn(call_frame_t *frame, xlator_t *this, inode_t *inode,
+             afr_read_txn_wind_t readfn, afr_transaction_type type)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        unsigned char *data = NULL;
-        unsigned char *metadata = NULL;
-	int read_subvol = -1;
-	int event_generation = 0;
-	int ret = -1;
-
-	priv = this->private;
-	local = frame->local;
-        data = alloca0 (priv->child_count);
-        metadata = alloca0 (priv->child_count);
-
-	afr_read_txn_wipe (frame, this);
-
-	local->readfn = readfn;
-	local->inode = inode_ref (inode);
-        local->is_read_txn = _gf_true;
-
-        if (priv->quorum_reads &&
-            priv->quorum_count && !afr_has_quorum (priv->child_up, this)) {
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-                read_subvol = -1;
-                goto read;
-        }
-
-        if (!afr_is_consistent_io_possible (local, priv, &local->op_errno)) {
-                local->op_ret = -1;
-                read_subvol = -1;
-                goto read;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *data = NULL;
+    unsigned char *metadata = NULL;
+    int read_subvol = -1;
+    int event_generation = 0;
+    int ret = -1;
+
+    priv = this->private;
+    local = frame->local;
+    data = alloca0(priv->child_count);
+    metadata = alloca0(priv->child_count);
+
+    afr_read_txn_wipe(frame, this);
+
+    local->readfn = readfn;
+    local->inode = inode_ref(inode);
+    local->is_read_txn = _gf_true;
+    local->transaction.type = type;
+
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this, NULL)) {
+        local->op_ret = -1;
+        local->op_errno = afr_quorum_errno(priv);
+        goto read;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &local->op_errno)) {
+        local->op_ret = -1;
+        goto read;
+    }
+
+    if (priv->thin_arbiter_count && !afr_ta_has_quorum(priv, local)) {
+        local->op_ret = -1;
+        local->op_errno = -afr_quorum_errno(priv);
+        goto read;
+    }
+
+    if (priv->thin_arbiter_count &&
+        AFR_COUNT(local->child_up, priv->child_count) != priv->child_count) {
+        if (local->child_up[0]) {
+            local->read_txn_query_child = AFR_CHILD_ZERO;
+        } else if (local->child_up[1]) {
+            local->read_txn_query_child = AFR_CHILD_ONE;
         }
-
-	local->transaction.type = type;
-        ret = afr_inode_read_subvol_get (inode, this, data, metadata,
-                                         &event_generation);
-	if (ret == -1)
-		/* very first transaction on this inode */
-		goto refresh;
-        AFR_INTERSECT (local->readable, data, metadata, priv->child_count);
-
-        gf_msg_debug (this->name, 0, "%s: generation now vs cached: %d, "
-                      "%d", uuid_utoa (inode->gfid), local->event_generation,
-                      event_generation);
-	if (afr_is_inode_refresh_reqd (inode, this, local->event_generation,
-                                       event_generation))
-		/* servers have disconnected / reconnected, and possibly
-		   rebooted, very likely changing the state of freshness
-		   of copies */
-		goto refresh;
-
-	read_subvol = afr_read_subvol_select_by_policy (inode, this,
-							local->readable, NULL);
-
-	if (read_subvol < 0 || read_subvol > priv->child_count) {
-	        gf_msg_debug (this->name, 0, "Unreadable subvolume %d found "
-                       "with event generation %d for gfid %s.",
-                        read_subvol, event_generation, uuid_utoa(inode->gfid));
-		goto refresh;
-	}
-
-	if (!local->child_up[read_subvol]) {
-		/* should never happen, just in case */
-	        gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_READ_SUBVOL_ERROR, "subvolume %d is the "
-			"read subvolume in this generation, but is not up",
-			read_subvol);
-		goto refresh;
-	}
-
-	local->read_attempted[read_subvol] = 1;
+        afr_ta_read_txn_synctask(frame, this);
+        return 0;
+    }
+
+    ret = afr_inode_read_subvol_get(inode, this, data, metadata,
+                                    &event_generation);
+    if (ret == -1)
+        /* very first transaction on this inode */
+        goto refresh;
+    AFR_INTERSECT(local->readable, data, metadata, priv->child_count);
+
+    gf_msg_debug(this->name, 0,
+                 "%s: generation now vs cached: %d, "
+                 "%d",
+                 uuid_utoa(inode->gfid), local->event_generation,
+                 event_generation);
+    if (afr_is_inode_refresh_reqd(inode, this, local->event_generation,
+                                  event_generation))
+        /* servers have disconnected / reconnected, and possibly
+           rebooted, very likely changing the state of freshness
+           of copies */
+        goto refresh;
+
+    read_subvol = afr_read_subvol_select_by_policy(inode, this, local->readable,
+                                                   NULL);
+
+    if (read_subvol < 0 || read_subvol > priv->child_count) {
+        gf_msg_debug(this->name, 0,
+                     "Unreadable subvolume %d found "
+                     "with event generation %d for gfid %s.",
+                     read_subvol, event_generation, uuid_utoa(inode->gfid));
+        goto refresh;
+    }
+
+    if (!local->child_up[read_subvol]) {
+        /* should never happen, just in case */
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_READ_SUBVOL_ERROR,
+               "subvolume %d is the "
+               "read subvolume in this generation, but is not up",
+               read_subvol);
+        goto refresh;
+    }
+
+    local->read_attempted[read_subvol] = 1;
 
 read:
-	local->readfn (frame, this, read_subvol);
+    afr_read_txn_wind(frame, this, read_subvol);
 
-	return 0;
+    return 0;
 
 refresh:
-	afr_inode_refresh (frame, this, inode, NULL, afr_read_txn_refresh_done);
+    afr_inode_refresh(frame, this, inode, NULL, afr_read_txn_refresh_done);
 
-	return 0;
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-common.c b/xlators/cluster/afr/src/afr-self-heal-common.c
index 20e81dd43e0..a580a1584cc 100644
--- a/xlators/cluster/afr/src/afr-self-heal-common.c
+++ b/xlators/cluster/afr/src/afr-self-heal-common.c
@@ -8,743 +8,808 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "protocol-common.h"
 #include "afr-messages.h"
-#include "events.h"
+#include <glusterfs/events.h>
 
 void
-afr_heal_synctask (xlator_t *this, afr_local_t *local);
+afr_heal_synctask(xlator_t *this, afr_local_t *local);
 
 int
-afr_lookup_and_heal_gfid (xlator_t *this, inode_t *parent, const char *name,
-                          inode_t *inode, struct afr_reply *replies,
-                          int source,  void *gfid)
-{
-        afr_private_t *priv = NULL;
-        call_frame_t   *frame    = NULL;
-        afr_local_t *local = NULL;
-        unsigned char *wind_on = NULL;
-        ia_type_t ia_type = IA_INVAL;
-        dict_t *xdata = NULL;
-        loc_t loc = {0, };
-        int ret = 0;
-        int i = 0;
-
-        priv = this->private;
-        wind_on = alloca0 (priv->child_count);
+afr_lookup_and_heal_gfid(xlator_t *this, inode_t *parent, const char *name,
+                         inode_t *inode, struct afr_reply *replies, int source,
+                         unsigned char *sources, void *gfid, int *gfid_idx)
+{
+    afr_private_t *priv = NULL;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    unsigned char *wind_on = NULL;
+    ia_type_t ia_type = IA_INVAL;
+    dict_t *xdata = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
+    int i = 0;
+
+    priv = this->private;
+    wind_on = alloca0(priv->child_count);
+    if (source >= 0 && replies[source].valid && replies[source].op_ret == 0)
         ia_type = replies[source].poststat.ia_type;
 
-        /* gfid heal on those subvolumes that do not have gfid associated
-         * with the inode and update those replies.
-         */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-                if (!gf_uuid_is_null (replies[i].poststat.ia_gfid) ||
-                    replies[i].poststat.ia_type != ia_type)
-                        continue;
-
-                wind_on[i] = 1;
+    if (ia_type != IA_INVAL)
+        goto heal;
+
+    /* If ia_type is still invalid, it means either
+     * (a)'source' was -1, i.e. parent dir pending xattrs are in split-brain
+     * (or) (b) The parent dir pending xattrs are all zeroes (i.e. all bricks
+     * are sources) and the 'source' we selected earlier might be the one where
+     * the file is not actually present.
+     *
+     * In both cases, let us pick a brick with a successful reply and use its
+     * ia_type.
+     * */
+    for (i = 0; i < priv->child_count; i++) {
+        if (source == -1) {
+            /* case (a) above. */
+            if (replies[i].valid && replies[i].op_ret == 0 &&
+                replies[i].poststat.ia_type != IA_INVAL) {
+                ia_type = replies[i].poststat.ia_type;
+                break;
+            }
+        } else {
+            /* case (b) above. */
+            if (i == source)
+                continue;
+            if (sources[i] && replies[i].valid && replies[i].op_ret == 0 &&
+                replies[i].poststat.ia_type != IA_INVAL) {
+                ia_type = replies[i].poststat.ia_type;
+                break;
+            }
         }
+    }
 
-        if (AFR_COUNT(wind_on, priv->child_count) == 0)
-                return 0;
+heal:
+    /* gfid heal on those subvolumes that do not have gfid associated
+     * with the inode and update those replies.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-        xdata = dict_new ();
-        if (!xdata) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (gf_uuid_is_null(gfid) &&
+            !gf_uuid_is_null(replies[i].poststat.ia_gfid) &&
+            replies[i].poststat.ia_type == ia_type)
+            gfid = replies[i].poststat.ia_gfid;
 
-        ret = dict_set_static_bin (xdata, "gfid-req", gfid, 16);
-        if (ret) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!gf_uuid_is_null(replies[i].poststat.ia_gfid) ||
+            replies[i].poststat.ia_type != ia_type)
+            continue;
 
-        frame = afr_frame_create (this);
-        if (!frame) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        wind_on[i] = 1;
+    }
 
-        local = frame->local;
-        loc.parent = inode_ref (parent);
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.name = name;
-        loc.inode = inode_ref (inode);
+    if (AFR_COUNT(wind_on, priv->child_count) == 0)
+        return 0;
+
+    xdata = dict_new();
+    if (!xdata) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        AFR_ONLIST (wind_on, frame, afr_selfheal_discover_cbk, lookup,
-                    &loc, xdata);
+    ret = dict_set_gfuuid(xdata, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    local = frame->local;
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
+
+    AFR_ONLIST(wind_on, frame, afr_selfheal_discover_cbk, lookup, &loc, xdata);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!wind_on[i])
+            continue;
+        afr_reply_wipe(&replies[i]);
+        afr_reply_copy(&replies[i], &local->replies[i]);
+    }
+    if (gfid_idx && (*gfid_idx == -1)) {
+        /*Pick a brick where the gifd heal was successful.*/
         for (i = 0; i < priv->child_count; i++) {
-                if (!wind_on[i])
-                        continue;
-                afr_reply_wipe (&replies[i]);
-                afr_reply_copy (&replies[i], &local->replies[i]);
+            if (!wind_on[i])
+                continue;
+            if (replies[i].valid && replies[i].op_ret == 0 &&
+                !gf_uuid_is_null(replies[i].poststat.ia_gfid)) {
+                *gfid_idx = i;
+                break;
+            }
         }
+    }
 out:
-        loc_wipe (&loc);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        if (xdata)
-                dict_unref (xdata);
+    if (gfid_idx && (*gfid_idx == -1) && (ret == 0) && local) {
+        ret = -afr_final_errno(local, priv);
+    }
+    loc_wipe(&loc);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    if (xdata)
+        dict_unref(xdata);
 
-        return ret;
+    return ret;
 }
 
 int
-afr_gfid_sbrain_source_from_src_brick (xlator_t *this,
-                                       struct afr_reply *replies,
-                                       char *src_brick)
+afr_gfid_sbrain_source_from_src_brick(xlator_t *this, struct afr_reply *replies,
+                                      char *src_brick)
 {
-        int             i        = 0;
-        afr_private_t  *priv     = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (strcmp (priv->children[i]->name, src_brick) == 0)
-                        return i;
-        }
-        return -1;
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (strcmp(priv->children[i]->name, src_brick) == 0)
+            return i;
+    }
+    return -1;
 }
 
 int
-afr_selfheal_gfid_mismatch_by_majority (struct afr_reply *replies,
-                                        int child_count)
-{
-        int             j                  = 0;
-        int             i                  = 0;
-        int             src                = -1;
-        int             votes[child_count];
-
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-
-                votes[i] = 1;
-                for (j = i+1; j < child_count; j++) {
-                        if ((!gf_uuid_compare (replies[i].poststat.ia_gfid,
-                            replies[j].poststat.ia_gfid)))
-                                votes[i]++;
-                        if (votes[i] > child_count / 2) {
-                                src = i;
-                                goto out;
-                        }
-                }
+afr_selfheal_gfid_mismatch_by_majority(struct afr_reply *replies,
+                                       int child_count)
+{
+    int j = 0;
+    int i = 0;
+    int votes;
+
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+
+        votes = 1;
+        for (j = i + 1; j < child_count; j++) {
+            if ((!gf_uuid_compare(replies[i].poststat.ia_gfid,
+                                  replies[j].poststat.ia_gfid)))
+                votes++;
+            if (votes > child_count / 2)
+                return i;
         }
+    }
 
-out:
-        return src;
+    return -1;
 }
 
-int afr_gfid_sbrain_source_from_bigger_file (struct afr_reply *replies,
-                                             int child_count)
+int
+afr_gfid_sbrain_source_from_bigger_file(struct afr_reply *replies,
+                                        int child_count)
 {
-        int       i       = 0;
-        int       src     = -1;
-        uint64_t  size    = 0;
-
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (size < replies[i].poststat.ia_size) {
-                        src = i;
-                        size = replies[i].poststat.ia_size;
-                } else if (replies[i].poststat.ia_size == size) {
-                        src = -1;
-                }
-        }
-        return src;
-}
-
-int afr_gfid_sbrain_source_from_latest_mtime (struct afr_reply *replies,
-                                              int child_count)
-{
-        int       i             = 0;
-        int       src           = -1;
-        uint32_t  mtime         = 0;
-        uint32_t  mtime_nsec    = 0;
-
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-                if ((mtime < replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
-                        src = i;
-                        mtime = replies[i].poststat.ia_mtime;
-                        mtime_nsec = replies[i].poststat.ia_mtime_nsec;
-                } else if ((mtime == replies[i].poststat.ia_mtime) &&
-                           (mtime_nsec == replies[i].poststat.ia_mtime_nsec)) {
-                        src = -1;
-                }
+    int i = 0;
+    int src = -1;
+    uint64_t size = 0;
+
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (size < replies[i].poststat.ia_size) {
+            src = i;
+            size = replies[i].poststat.ia_size;
+        } else if (replies[i].poststat.ia_size == size) {
+            src = -1;
         }
-        return src;
+    }
+    return src;
 }
 
 int
-afr_gfid_split_brain_source (xlator_t *this, struct afr_reply *replies,
-                             inode_t *inode, uuid_t pargfid, const char *bname,
-                             int src_idx, int child_idx,
-                             unsigned char *locked_on, int *src, dict_t *xdata)
-{
-        afr_private_t   *priv      = NULL;
-        char             g1[64]    = {0,};
-        char             g2[64]    = {0,};
-        int              up_count  = 0;
-        int              heal_op   = -1;
-        int              ret       = -1;
-        char            *src_brick = NULL;
-
-        *src = -1;
-        priv = this->private;
-        up_count = AFR_COUNT (locked_on, priv->child_count);
-        if (up_count != priv->child_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
-                        "All the bricks should be up to resolve the gfid split "
-                        "barin");
-                if (xdata) {
-                        ret = dict_set_str (xdata, "gfid-heal-msg", "All the "
-                                            "bricks should be up to resolve the"
-                                            " gfid split barin");
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_DICT_SET_FAILED, "Error setting"
-                                        " gfid-heal-msg dict");
-                }
-                goto out;
+afr_gfid_sbrain_source_from_latest_mtime(struct afr_reply *replies,
+                                         int child_count)
+{
+    int i = 0;
+    int src = -1;
+    uint32_t mtime = 0;
+    uint32_t mtime_nsec = 0;
+
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
+        if ((mtime < replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
+            src = i;
+            mtime = replies[i].poststat.ia_mtime;
+            mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+        } else if ((mtime == replies[i].poststat.ia_mtime) &&
+                   (mtime_nsec == replies[i].poststat.ia_mtime_nsec)) {
+            src = -1;
         }
+    }
+    return src;
+}
 
+int
+afr_gfid_split_brain_source(xlator_t *this, struct afr_reply *replies,
+                            inode_t *inode, uuid_t pargfid, const char *bname,
+                            int src_idx, int child_idx,
+                            unsigned char *locked_on, int *src, dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    char g1[64] = {
+        0,
+    };
+    char g2[64] = {
+        0,
+    };
+    int up_count = 0;
+    int heal_op = -1;
+    int ret = -1;
+    char *src_brick = NULL;
+
+    *src = -1;
+    priv = this->private;
+    up_count = AFR_COUNT(locked_on, priv->child_count);
+    if (up_count != priv->child_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+               "All the bricks should be up to resolve the gfid split "
+               "barin");
         if (xdata) {
-                ret = dict_get_int32 (xdata, "heal-op", &heal_op);
-                if (ret)
-                        goto fav_child;
-        } else {
-                goto fav_child;
+            ret = dict_set_sizen_str_sizen(xdata, "gfid-heal-msg",
+                                           SALL_BRICKS_UP_TO_RESOLVE);
+            if (ret)
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                       "Error setting"
+                       " gfid-heal-msg dict");
         }
+        goto out;
+    }
+
+    if (xdata) {
+        ret = dict_get_int32_sizen(xdata, "heal-op", &heal_op);
+        if (ret)
+            goto fav_child;
+    } else {
+        goto fav_child;
+    }
 
-        switch (heal_op) {
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                *src = afr_gfid_sbrain_source_from_bigger_file (replies,
-                                                                priv->child_count);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No bigger file");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "No bigger file");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                " setting gfid-heal-msg dict");
-                        }
+            *src = afr_gfid_sbrain_source_from_bigger_file(replies,
+                                                           priv->child_count);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       SNO_BIGGER_FILE);
+                if (xdata) {
+                    ret = dict_set_sizen_str_sizen(xdata, "gfid-heal-msg",
+                                                   SNO_BIGGER_FILE);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               " setting gfid-heal-msg dict");
                 }
-                break;
+            }
+            break;
 
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                *src = afr_gfid_sbrain_source_from_latest_mtime (replies,
-                                                                 priv->child_count);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No difference in mtime");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "No difference in mtime");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                "setting gfid-heal-msg dict");
-                        }
+            *src = afr_gfid_sbrain_source_from_latest_mtime(replies,
+                                                            priv->child_count);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       SNO_DIFF_IN_MTIME);
+                if (xdata) {
+                    ret = dict_set_sizen_str_sizen(xdata, "gfid-heal-msg",
+                                                   SNO_DIFF_IN_MTIME);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               "setting gfid-heal-msg dict");
                 }
-                break;
+            }
+            break;
 
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (xdata, "child-name", &src_brick);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Error getting the source "
-                                "brick");
-                        break;
-                }
-                *src = afr_gfid_sbrain_source_from_src_brick (this, replies,
-                                                              src_brick);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Error getting the source "
-                                "brick");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "Error getting the source "
-                                                    "brick");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                " setting gfid-heal-msg dict");
-                        }
-                }
+            ret = dict_get_str_sizen(xdata, "child-name", &src_brick);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Error getting the source "
+                       "brick");
                 break;
+            }
+            *src = afr_gfid_sbrain_source_from_src_brick(this, replies,
+                                                         src_brick);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       SERROR_GETTING_SRC_BRICK);
+                if (xdata) {
+                    ret = dict_set_sizen_str_sizen(xdata, "gfid-heal-msg",
+                                                   SERROR_GETTING_SRC_BRICK);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               " setting gfid-heal-msg dict");
+                }
+            }
+            break;
 
         default:
-                break;
-        }
-        goto out;
+            break;
+    }
+    goto out;
 
 fav_child:
-        switch (priv->fav_child_policy) {
+    switch (priv->fav_child_policy) {
         case AFR_FAV_CHILD_BY_SIZE:
-                *src = afr_sh_fav_by_size (this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_size(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_MTIME:
-                *src = afr_sh_fav_by_mtime (this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_mtime(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_CTIME:
-                *src = afr_sh_fav_by_ctime(this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_ctime(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_MAJORITY:
-                if (priv->child_count != 2)
-                        *src = afr_selfheal_gfid_mismatch_by_majority (replies,
-                                                                       priv->child_count);
-                else
-                        *src = -1;
-
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No majority to resolve "
-                                "gfid split brain");
-                }
-                break;
+            if (priv->child_count != 2)
+                *src = afr_selfheal_gfid_mismatch_by_majority(
+                    replies, priv->child_count);
+            else
+                *src = -1;
+
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "No majority to resolve "
+                       "gfid split brain");
+            }
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
 out:
-        if (*src == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
-                        "Gfid mismatch detected for <gfid:%s>/%s>, %s on %s and"
-                        " %s on %s.", uuid_utoa (pargfid), bname,
-                        uuid_utoa_r (replies[child_idx].poststat.ia_gfid, g1),
-                        priv->children[child_idx]->name,
-                        uuid_utoa_r (replies[src_idx].poststat.ia_gfid, g2),
-                        priv->children[src_idx]->name);
-                gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=gfid;file="
-                          "<gfid:%s>/%s>;count=2;child-%d=%s;gfid-%d=%s;"
-                          "child-%d=%s;gfid-%d=%s", this->name,
-                          uuid_utoa (pargfid), bname, child_idx,
-                          priv->children[child_idx]->name, child_idx,
-                          uuid_utoa_r (replies[child_idx].poststat.ia_gfid, g1),
-                          src_idx, priv->children[src_idx]->name, src_idx,
-                          uuid_utoa_r (replies[src_idx].poststat.ia_gfid, g2));
-                return -1;
-        }
-        return 0;
+    if (*src == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+               "Gfid mismatch detected for <gfid:%s>/%s>, %s on %s and"
+               " %s on %s.",
+               uuid_utoa(pargfid), bname,
+               uuid_utoa_r(replies[child_idx].poststat.ia_gfid, g1),
+               priv->children[child_idx]->name,
+               uuid_utoa_r(replies[src_idx].poststat.ia_gfid, g2),
+               priv->children[src_idx]->name);
+        gf_event(EVENT_AFR_SPLIT_BRAIN,
+                 "client-pid=%d;"
+                 "subvol=%s;type=gfid;file="
+                 "<gfid:%s>/%s>;count=2;child-%d=%s;gfid-%d=%s;"
+                 "child-%d=%s;gfid-%d=%s",
+                 this->ctx->cmd_args.client_pid, this->name, uuid_utoa(pargfid),
+                 bname, child_idx, priv->children[child_idx]->name, child_idx,
+                 uuid_utoa_r(replies[child_idx].poststat.ia_gfid, g1), src_idx,
+                 priv->children[src_idx]->name, src_idx,
+                 uuid_utoa_r(replies[src_idx].poststat.ia_gfid, g2));
+        return -1;
+    }
+    return 0;
 }
 
-
 int
-afr_selfheal_post_op_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			  int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+afr_selfheal_post_op_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
-	syncbarrier_wake (&local->barrier);
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    syncbarrier_wake(&local->barrier);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_post_op (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      int subvol, dict_t *xattr, dict_t *xdata)
+afr_selfheal_post_op(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     int subvol, dict_t *xattr, dict_t *xdata)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	loc_t loc = {0, };
-        int ret = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-	STACK_WIND (frame, afr_selfheal_post_op_cbk, priv->children[subvol],
-		    priv->children[subvol]->fops->xattrop, &loc,
-		    GF_XATTROP_ADD_ARRAY, xattr, xdata);
+    STACK_WIND(frame, afr_selfheal_post_op_cbk, priv->children[subvol],
+               priv->children[subvol]->fops->xattrop, &loc,
+               GF_XATTROP_ADD_ARRAY, xattr, xdata);
 
-	syncbarrier_wait (&local->barrier, 1);
-        if (local->op_ret < 0)
-                ret = -local->op_errno;
+    syncbarrier_wait(&local->barrier, 1);
+    if (local->op_ret < 0)
+        ret = -local->op_errno;
 
-        loc_wipe (&loc);
-        local->op_ret = 0;
+    loc_wipe(&loc);
+    local->op_ret = 0;
 
-	return ret;
+    return ret;
 }
 
 int
-afr_check_stale_error (struct afr_reply *replies, afr_private_t *priv)
-{
-        int i = 0;
-        int op_errno = 0;
-        int tmp_errno = 0;
-        int stale_count = 0;
-
-        for (i = 0; i < priv->child_count; i++) {
-                tmp_errno = replies[i].op_errno;
-                if (tmp_errno == ENOENT || tmp_errno == ESTALE) {
-                        op_errno = afr_higher_errno (op_errno, tmp_errno);
-                        stale_count++;
-                }
+afr_check_stale_error(struct afr_reply *replies, afr_private_t *priv)
+{
+    int i = 0;
+    int op_errno = 0;
+    int tmp_errno = 0;
+    int stale_count = 0;
+
+    for (i = 0; i < priv->child_count; i++) {
+        tmp_errno = replies[i].op_errno;
+        if (tmp_errno == ENOENT || tmp_errno == ESTALE) {
+            op_errno = afr_higher_errno(op_errno, tmp_errno);
+            stale_count++;
         }
-        if (stale_count != priv->child_count)
-                return -ENOTCONN;
-        else
-                return -op_errno;
+    }
+    if (stale_count != priv->child_count)
+        return -ENOTCONN;
+    else
+        return -op_errno;
 }
 
 int
-afr_sh_generic_fop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-          int op_ret, int op_errno, struct iatt *pre, struct iatt *post,
-          dict_t *xdata)
+afr_sh_generic_fop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *pre,
+                       struct iatt *post, dict_t *xdata)
 {
-        int i = (long) cookie;
-        afr_local_t *local = NULL;
+    int i = (long)cookie;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->replies[i].valid = 1;
-        local->replies[i].op_ret = op_ret;
-        local->replies[i].op_errno = op_errno;
-        if (pre)
-                local->replies[i].prestat = *pre;
-        if (post)
-                local->replies[i].poststat = *post;
-        if (xdata)
-                local->replies[i].xdata = dict_ref (xdata);
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (pre)
+        local->replies[i].prestat = *pre;
+    if (post)
+        local->replies[i].poststat = *post;
+    if (xdata)
+        local->replies[i].xdata = dict_ref(xdata);
 
-        syncbarrier_wake (&local->barrier);
+    syncbarrier_wake(&local->barrier);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_selfheal_restore_time (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                           int source, unsigned char *healed_sinks,
-                           struct afr_reply *replies)
+afr_selfheal_restore_time(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          int source, unsigned char *healed_sinks,
+                          struct afr_reply *replies)
 {
-        loc_t loc = {0, };
+    loc_t loc = {
+        0,
+    };
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, setattr, &loc,
-                    &replies[source].poststat,
-                    (GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME), NULL);
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, setattr, &loc,
+               &replies[source].poststat,
+               (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME | GF_SET_ATTR_CTIME),
+               NULL);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return 0;
+    return 0;
 }
 
 dict_t *
-afr_selfheal_output_xattr (xlator_t *this, gf_boolean_t is_full_crawl,
-                           afr_transaction_type type, int *output_dirty,
-                           int **output_matrix, int subvol,
-                           int **full_heal_mtx_out)
-{
-	int                j     = 0;
-	int                idx   = 0;
-	int                d_idx = 0;
-	int                ret   = 0;
-	int               *raw   = 0;
-	dict_t            *xattr = NULL;
-	afr_private_t     *priv  = NULL;
-
-	priv = this->private;
-	idx = afr_index_for_transaction_type (type);
-        d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
-
-	xattr = dict_new ();
-	if (!xattr)
-		return NULL;
-
-	/* clear dirty */
-	raw = GF_CALLOC (sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
-	if (!raw)
-		goto err;
-
-	raw[idx] = hton32 (output_dirty[subvol]);
-	ret = dict_set_bin (xattr, AFR_DIRTY, raw,
-			    sizeof(int) * AFR_NUM_CHANGE_LOGS);
-	if (ret) {
-                GF_FREE (raw);
-		goto err;
-        }
+afr_selfheal_output_xattr(xlator_t *this, gf_boolean_t is_full_crawl,
+                          afr_transaction_type type, int *output_dirty,
+                          int **output_matrix, int subvol,
+                          int **full_heal_mtx_out)
+{
+    int j = 0;
+    int idx = 0;
+    int d_idx = 0;
+    int ret = 0;
+    int *raw = 0;
+    dict_t *xattr = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    idx = afr_index_for_transaction_type(type);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
+
+    xattr = dict_new();
+    if (!xattr)
+        return NULL;
 
-	/* clear/set pending */
-	for (j = 0; j < priv->child_count; j++) {
-		raw = GF_CALLOC (sizeof(int), AFR_NUM_CHANGE_LOGS,
-				 gf_afr_mt_int32_t);
-		if (!raw)
-			goto err;
-
-		raw[idx] = hton32 (output_matrix[subvol][j]);
-                if (is_full_crawl)
-                        raw[d_idx] = hton32 (full_heal_mtx_out[subvol][j]);
-
-		ret = dict_set_bin (xattr, priv->pending_key[j],
-				    raw, sizeof(int) * AFR_NUM_CHANGE_LOGS);
-		if (ret) {
-                        GF_FREE (raw);
-			goto err;
-                }
-	}
+    /* clear dirty */
+    raw = GF_CALLOC(sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
+    if (!raw)
+        goto err;
+
+    raw[idx] = hton32(output_dirty[subvol]);
+    ret = dict_set_bin(xattr, AFR_DIRTY, raw,
+                       sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret) {
+        GF_FREE(raw);
+        goto err;
+    }
+
+    /* clear/set pending */
+    for (j = 0; j < priv->child_count; j++) {
+        raw = GF_CALLOC(sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
+        if (!raw)
+            goto err;
+
+        raw[idx] = hton32(output_matrix[subvol][j]);
+        if (is_full_crawl)
+            raw[d_idx] = hton32(full_heal_mtx_out[subvol][j]);
+
+        ret = dict_set_bin(xattr, priv->pending_key[j], raw,
+                           sizeof(int) * AFR_NUM_CHANGE_LOGS);
+        if (ret) {
+            GF_FREE(raw);
+            goto err;
+        }
+    }
 
-	return xattr;
+    return xattr;
 err:
-	if (xattr)
-		dict_unref (xattr);
-	return NULL;
+    if (xattr)
+        dict_unref(xattr);
+    return NULL;
 }
 
-
 int
-afr_selfheal_undo_pending (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			   unsigned char *sources, unsigned char *sinks,
-			   unsigned char *healed_sinks,
-                           unsigned char *undid_pending,
-                           afr_transaction_type type, struct afr_reply *replies,
-                           unsigned char *locked_on)
-{
-	afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-	int i = 0;
-	int j = 0;
-	unsigned char *pending = NULL;
-	int *input_dirty = NULL;
-	int **input_matrix = NULL;
-	int **full_heal_mtx_in = NULL;
-	int **full_heal_mtx_out = NULL;
-	int *output_dirty = NULL;
-	int **output_matrix = NULL;
-	dict_t *xattr = NULL;
-	dict_t *xdata = NULL;
-
-	priv = this->private;
-        local = frame->local;
-
-	pending = alloca0 (priv->child_count);
-
-	input_dirty = alloca0 (priv->child_count * sizeof (int));
-	input_matrix = ALLOC_MATRIX (priv->child_count, int);
-	full_heal_mtx_in = ALLOC_MATRIX (priv->child_count, int);
-	full_heal_mtx_out = ALLOC_MATRIX (priv->child_count, int);
-	output_dirty = alloca0 (priv->child_count * sizeof (int));
-	output_matrix = ALLOC_MATRIX (priv->child_count, int);
-
-        xdata = dict_new ();
-        if (!xdata)
-                return -1;
+afr_selfheal_undo_pending(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          unsigned char *sources, unsigned char *sinks,
+                          unsigned char *healed_sinks,
+                          unsigned char *undid_pending,
+                          afr_transaction_type type, struct afr_reply *replies,
+                          unsigned char *locked_on)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int j = 0;
+    unsigned char *pending = NULL;
+    int *input_dirty = NULL;
+    int **input_matrix = NULL;
+    int **full_heal_mtx_in = NULL;
+    int **full_heal_mtx_out = NULL;
+    int *output_dirty = NULL;
+    int **output_matrix = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    pending = alloca0(priv->child_count);
+
+    input_dirty = alloca0(priv->child_count * sizeof(int));
+    input_matrix = ALLOC_MATRIX(priv->child_count, int);
+    full_heal_mtx_in = ALLOC_MATRIX(priv->child_count, int);
+    full_heal_mtx_out = ALLOC_MATRIX(priv->child_count, int);
+    output_dirty = alloca0(priv->child_count * sizeof(int));
+    output_matrix = ALLOC_MATRIX(priv->child_count, int);
+
+    xdata = dict_new();
+    if (!xdata)
+        return -1;
 
-	afr_selfheal_extract_xattr (this, replies, type, input_dirty,
-				    input_matrix);
-
-        if (local->need_full_crawl)
-                afr_selfheal_extract_xattr (this, replies, AFR_DATA_TRANSACTION,
-                                            NULL, full_heal_mtx_in);
-
-	for (i = 0; i < priv->child_count; i++)
-		if (sinks[i] && !healed_sinks[i])
-			pending[i] = 1;
-
-	for (i = 0; i < priv->child_count; i++) {
-		for (j = 0; j < priv->child_count; j++) {
-			if (pending[j]) {
-				output_matrix[i][j] = 1;
-                                if (type == AFR_ENTRY_TRANSACTION)
-                                        full_heal_mtx_out[i][j] = 1;
-			} else if (locked_on[j]) {
-				output_matrix[i][j] = -input_matrix[i][j];
-                                if (type == AFR_ENTRY_TRANSACTION)
-                                        full_heal_mtx_out[i][j] = -full_heal_mtx_in[i][j];
-                        }
-		}
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!pending[i])
-			output_dirty[i] = -input_dirty[i];
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!locked_on[i])
-			/* perform post-op only on subvols we had locked
-			   and inspected on.
-			*/
-			continue;
-                if (undid_pending[i])
-                        /* We already unset the pending xattrs in
-                         * _afr_fav_child_reset_sink_xattrs(). */
-                        continue;
-
-		xattr = afr_selfheal_output_xattr (this, local->need_full_crawl,
-                                                   type, output_dirty,
-                                                   output_matrix, i,
-                                                   full_heal_mtx_out);
-		if (!xattr) {
-			continue;
-		}
-
-                if ((type == AFR_ENTRY_TRANSACTION) && (priv->esh_granular)) {
-                        if (xdata &&
-                            dict_set_int8 (xdata, GF_XATTROP_PURGE_INDEX, 1))
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        AFR_MSG_DICT_SET_FAILED, "Failed to set"
-                                        " dict value for %s",
-                                        GF_XATTROP_PURGE_INDEX);
-                }
+    afr_selfheal_extract_xattr(this, replies, type, input_dirty, input_matrix);
+
+    if (local->need_full_crawl)
+        afr_selfheal_extract_xattr(this, replies, AFR_DATA_TRANSACTION, NULL,
+                                   full_heal_mtx_in);
+
+    for (i = 0; i < priv->child_count; i++)
+        if (sinks[i] && !healed_sinks[i])
+            pending[i] = 1;
+
+    for (i = 0; i < priv->child_count; i++) {
+        for (j = 0; j < priv->child_count; j++) {
+            if (pending[j]) {
+                output_matrix[i][j] = 1;
+                if (type == AFR_ENTRY_TRANSACTION)
+                    full_heal_mtx_out[i][j] = 1;
+            } else if (locked_on[j]) {
+                output_matrix[i][j] = -input_matrix[i][j];
+                if (type == AFR_ENTRY_TRANSACTION)
+                    full_heal_mtx_out[i][j] = -full_heal_mtx_in[i][j];
+            }
+        }
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!pending[i])
+            output_dirty[i] = -input_dirty[i];
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!locked_on[i])
+            /* perform post-op only on subvols we had locked
+               and inspected on.
+            */
+            continue;
+        if (undid_pending[i])
+            /* We already unset the pending xattrs in
+             * _afr_fav_child_reset_sink_xattrs(). */
+            continue;
+
+        xattr = afr_selfheal_output_xattr(this, local->need_full_crawl, type,
+                                          output_dirty, output_matrix, i,
+                                          full_heal_mtx_out);
+        if (!xattr) {
+            continue;
+        }
+
+        if ((type == AFR_ENTRY_TRANSACTION) && (priv->esh_granular)) {
+            if (xdata && dict_set_int8(xdata, GF_XATTROP_PURGE_INDEX, 1))
+                gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_DICT_SET_FAILED,
+                       "Failed to set"
+                       " dict value for %s",
+                       GF_XATTROP_PURGE_INDEX);
+        }
 
-		afr_selfheal_post_op (frame, this, inode, i, xattr, xdata);
-		dict_unref (xattr);
-	}
+        afr_selfheal_post_op(frame, this, inode, i, xattr, xdata);
+        dict_unref(xattr);
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    if (xdata)
+        dict_unref(xdata);
 
-	return 0;
+    return 0;
 }
 
 void
-afr_reply_copy (struct afr_reply *dst, struct afr_reply *src)
-{
-	dict_t *xdata = NULL;
-
-        dst->valid = src->valid;
-	dst->op_ret = src->op_ret;
-	dst->op_errno = src->op_errno;
-	dst->prestat = src->prestat;
-	dst->poststat = src->poststat;
-	dst->preparent = src->preparent;
-	dst->postparent = src->postparent;
-	dst->preparent2 = src->preparent2;
-	dst->postparent2 = src->postparent2;
-	if (src->xdata)
-		xdata = dict_ref (src->xdata);
-	else
-		xdata = NULL;
-	if (dst->xdata)
-		dict_unref (dst->xdata);
-	dst->xdata = xdata;
-	memcpy (dst->checksum, src->checksum, MD5_DIGEST_LENGTH);
+afr_reply_copy(struct afr_reply *dst, struct afr_reply *src)
+{
+    dict_t *xdata = NULL;
+
+    dst->valid = src->valid;
+    dst->op_ret = src->op_ret;
+    dst->op_errno = src->op_errno;
+    dst->prestat = src->prestat;
+    dst->poststat = src->poststat;
+    dst->preparent = src->preparent;
+    dst->postparent = src->postparent;
+    dst->preparent2 = src->preparent2;
+    dst->postparent2 = src->postparent2;
+    if (src->xdata)
+        xdata = dict_ref(src->xdata);
+    else
+        xdata = NULL;
+    if (dst->xdata)
+        dict_unref(dst->xdata);
+    dst->xdata = xdata;
+    if (xdata && dict_get_str_boolean(xdata, "fips-mode-rchecksum",
+                                      _gf_false) == _gf_true) {
+        memcpy(dst->checksum, src->checksum, SHA256_DIGEST_LENGTH);
+    } else {
+        memcpy(dst->checksum, src->checksum, MD5_DIGEST_LENGTH);
+    }
+    dst->fips_mode_rchecksum = src->fips_mode_rchecksum;
 }
 
 void
-afr_replies_copy (struct afr_reply *dst, struct afr_reply *src, int count)
+afr_replies_copy(struct afr_reply *dst, struct afr_reply *src, int count)
 {
-	int i = 0;
+    int i = 0;
 
-	if (dst == src)
-		return;
+    if (dst == src)
+        return;
 
-	for (i = 0; i < count; i++) {
-                afr_reply_copy (&dst[i], &src[i]);
-	}
+    for (i = 0; i < count; i++) {
+        afr_reply_copy(&dst[i], &src[i]);
+    }
 }
 
 int
-afr_selfheal_fill_dirty (xlator_t *this, int *dirty, int subvol,
-			 int idx, dict_t *xdata)
+afr_selfheal_fill_dirty(xlator_t *this, int *dirty, int subvol, int idx,
+                        dict_t *xdata)
 {
-	void *pending_raw = NULL;
-	int pending[3] = {0, };
+    void *pending_raw = NULL;
+    int pending[3] = {
+        0,
+    };
 
-        if (!dirty)
-                return 0;
+    if (!dirty)
+        return 0;
 
-	if (dict_get_ptr (xdata, AFR_DIRTY, &pending_raw))
-		return -1;
+    if (dict_get_ptr(xdata, AFR_DIRTY, &pending_raw))
+        return -1;
 
-	if (!pending_raw)
-		return -1;
+    if (!pending_raw)
+        return -1;
 
-	memcpy (pending, pending_raw, sizeof(pending));
+    memcpy(pending, pending_raw, sizeof(pending));
 
-	dirty[subvol] = ntoh32 (pending[idx]);
+    dirty[subvol] = ntoh32(pending[idx]);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_fill_matrix (xlator_t *this, int **matrix, int subvol,
-			  int idx, dict_t *xdata)
+afr_selfheal_fill_matrix(xlator_t *this, int **matrix, int subvol, int idx,
+                         dict_t *xdata)
 {
-	int i = 0;
-	void *pending_raw = NULL;
-	int pending[3] = {0, };
-	afr_private_t *priv = NULL;
+    int i = 0;
+    void *pending_raw = NULL;
+    int pending[3] = {
+        0,
+    };
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-        if (!matrix)
-                return 0;
+    if (!matrix)
+        return 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (dict_get_ptr (xdata, priv->pending_key[i], &pending_raw))
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
 
-		if (!pending_raw)
-			continue;
+        if (!pending_raw)
+            continue;
 
-		memcpy (pending, pending_raw, sizeof(pending));
+        memcpy(pending, pending_raw, sizeof(pending));
 
-		matrix[subvol][i] = ntoh32 (pending[idx]);
-	}
+        matrix[subvol][i] = ntoh32(pending[idx]);
+    }
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_extract_xattr (xlator_t *this, struct afr_reply *replies,
-			    afr_transaction_type type, int *dirty, int **matrix)
+afr_selfheal_extract_xattr(xlator_t *this, struct afr_reply *replies,
+                           afr_transaction_type type, int *dirty, int **matrix)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	dict_t *xdata = NULL;
-	int idx = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    dict_t *xdata = NULL;
+    int idx = -1;
 
-	idx = afr_index_for_transaction_type (type);
+    idx = afr_index_for_transaction_type(type);
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-		if (!replies[i].xdata)
-			continue;
+        if (!replies[i].xdata)
+            continue;
 
-		xdata = replies[i].xdata;
+        xdata = replies[i].xdata;
 
-		afr_selfheal_fill_dirty (this, dirty, i, idx, xdata);
-		afr_selfheal_fill_matrix (this, matrix, i, idx, xdata);
-	}
+        afr_selfheal_fill_dirty(this, dirty, i, idx, xdata);
+        afr_selfheal_fill_matrix(this, matrix, i, idx, xdata);
+    }
 
-	return 0;
+    return 0;
 }
 
 /*
@@ -754,560 +819,566 @@ afr_selfheal_extract_xattr (xlator_t *this, struct afr_reply *replies,
  * This can happen if data was directly modified in the backend or for snapshots
  */
 void
-afr_mark_largest_file_as_source (xlator_t *this, unsigned char *sources,
-                                 struct afr_reply *replies)
-{
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint64_t size = 0;
-
-        /* Find source with biggest file size */
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (!replies[i].valid || replies[i].op_ret != 0) {
-                        sources[i] = 0;
-                        continue;
-                }
-                if (size <= replies[i].poststat.ia_size) {
-                        size = replies[i].poststat.ia_size;
-                }
+afr_mark_largest_file_as_source(xlator_t *this, unsigned char *sources,
+                                struct afr_reply *replies)
+{
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t size = 0;
+
+    /* Find source with biggest file size */
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (!replies[i].valid || replies[i].op_ret != 0) {
+            sources[i] = 0;
+            continue;
         }
-
-        /* Mark sources with less size as not source */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (size > replies[i].poststat.ia_size)
-                        sources[i] = 0;
+        if (size <= replies[i].poststat.ia_size) {
+            size = replies[i].poststat.ia_size;
         }
+    }
+
+    /* Mark sources with less size as not source */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (size > replies[i].poststat.ia_size)
+            sources[i] = 0;
+    }
 }
 
 void
-afr_mark_latest_mtime_file_as_source (xlator_t *this, unsigned char *sources,
-                                 struct afr_reply *replies)
-{
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint32_t mtime = 0;
-        uint32_t mtime_nsec = 0;
-
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (!replies[i].valid || replies[i].op_ret != 0) {
-                        sources[i] = 0;
-                        continue;
-                }
-                if ((mtime < replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
-                        mtime = replies[i].poststat.ia_mtime;
-                        mtime_nsec = replies[i].poststat.ia_mtime_nsec;
-                }
+afr_mark_latest_mtime_file_as_source(xlator_t *this, unsigned char *sources,
+                                     struct afr_reply *replies)
+{
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint32_t mtime = 0;
+    uint32_t mtime_nsec = 0;
+
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (!replies[i].valid || replies[i].op_ret != 0) {
+            sources[i] = 0;
+            continue;
         }
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if ((mtime > replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec > replies[i].poststat.ia_mtime_nsec))) {
-                        sources[i] = 0;
-                }
+        if ((mtime < replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
+            mtime = replies[i].poststat.ia_mtime;
+            mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+        }
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if ((mtime > replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec > replies[i].poststat.ia_mtime_nsec))) {
+            sources[i] = 0;
         }
+    }
 }
 
 void
-afr_mark_active_sinks (xlator_t *this, unsigned char *sources,
-                       unsigned char *locked_on, unsigned char *sinks)
+afr_mark_active_sinks(xlator_t *this, unsigned char *sources,
+                      unsigned char *locked_on, unsigned char *sinks)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        memset (sinks, 0, sizeof (*sinks) * priv->child_count);
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i] && locked_on[i])
-                        sinks[i] = 1;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] && locked_on[i])
+            sinks[i] = 1;
+        else
+            sinks[i] = 0;
+    }
 }
 
 gf_boolean_t
-afr_dict_contains_heal_op (call_frame_t *frame)
+afr_dict_contains_heal_op(call_frame_t *frame)
 {
-        afr_local_t   *local     = NULL;
-        dict_t        *xdata_req = NULL;
-        int            ret       = 0;
-        int            heal_op   = -1;
+    afr_local_t *local = NULL;
+    dict_t *xdata_req = NULL;
+    int ret = 0;
+    int heal_op = -1;
 
-        local = frame->local;
-        xdata_req = local->xdata_req;
-        ret = dict_get_int32 (xdata_req, "heal-op", &heal_op);
-        if (ret)
-                return _gf_false;
-        if (local->xdata_rsp == NULL) {
-                local->xdata_rsp = dict_new();
-                if (!local->xdata_rsp)
-                        return _gf_true;
-        }
-        ret = dict_set_str (local->xdata_rsp, "sh-fail-msg",
-                            "File not in split-brain");
+    local = frame->local;
+    xdata_req = local->xdata_req;
+    ret = dict_get_int32_sizen(xdata_req, "heal-op", &heal_op);
+    if (ret)
+        return _gf_false;
+    if (local->xdata_rsp == NULL) {
+        local->xdata_rsp = dict_new();
+        if (!local->xdata_rsp)
+            return _gf_true;
+    }
+    ret = dict_set_sizen_str_sizen(local->xdata_rsp, "sh-fail-msg",
+                                   SFILE_NOT_IN_SPLIT_BRAIN);
 
-        return _gf_true;
+    return _gf_true;
 }
 
 gf_boolean_t
-afr_can_decide_split_brain_source_sinks (struct afr_reply *replies,
-                                         int child_count)
+afr_can_decide_split_brain_source_sinks(struct afr_reply *replies,
+                                        int child_count)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < child_count; i++)
-                if (replies[i].valid != 1 || replies[i].op_ret != 0)
-                        return _gf_false;
+    for (i = 0; i < child_count; i++)
+        if (replies[i].valid != 1 || replies[i].op_ret != 0)
+            return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-afr_mark_split_brain_source_sinks_by_heal_op (call_frame_t *frame,
-                                   xlator_t *this, unsigned char *sources,
-                                   unsigned char *sinks,
-                                   unsigned char *healed_sinks,
-                                   unsigned char *locked_on,
-                                   struct afr_reply *replies,
-                                   afr_transaction_type type, int heal_op)
-{
-        afr_local_t   *local     = NULL;
-        afr_private_t *priv      = NULL;
-        dict_t        *xdata_req = NULL;
-        dict_t        *xdata_rsp = NULL;
-        int            ret       = 0;
-        int            i         = 0;
-        char          *name      = NULL;
-        int            source     = -1;
-
-        local = frame->local;
-        priv = this->private;
-        xdata_req = local->xdata_req;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (locked_on[i])
-                        if (sources[i] || !sinks[i] || !healed_sinks[i]) {
-                                ret = -1;
-                                goto out;
-                        }
-        }
-        if (local->xdata_rsp == NULL) {
-                local->xdata_rsp = dict_new();
-                if (!local->xdata_rsp) {
-                        ret = -1;
-                        goto out;
-                }
-        }
-        xdata_rsp = local->xdata_rsp;
-
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                    SBRAIN_HEAL_NO_GO_MSG);
+afr_mark_split_brain_source_sinks_by_heal_op(
+    call_frame_t *frame, xlator_t *this, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type, int heal_op)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata_req = NULL;
+    dict_t *xdata_rsp = NULL;
+    int ret = 0;
+    int i = 0;
+    char *name = NULL;
+    int source = -1;
+
+    local = frame->local;
+    priv = this->private;
+    xdata_req = local->xdata_req;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (locked_on[i])
+            if (sources[i] || !sinks[i] || !healed_sinks[i]) {
                 ret = -1;
                 goto out;
+            }
+    }
+    if (local->xdata_rsp == NULL) {
+        local->xdata_rsp = dict_new();
+        if (!local->xdata_rsp) {
+            ret = -1;
+            goto out;
         }
+    }
+    xdata_rsp = local->xdata_rsp;
+
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                       SBRAIN_HEAL_NO_GO_MSG);
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0 ; i < priv->child_count; i++)
-                if (locked_on[i])
-                        sources[i] = 1;
-        switch (heal_op) {
+    for (i = 0; i < priv->child_count; i++)
+        if (locked_on[i])
+            sources[i] = 1;
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                if (type == AFR_METADATA_TRANSACTION) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Use source-brick option to"
-                                            " heal metadata split-brain");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                afr_mark_largest_file_as_source (this, sources, replies);
-                if (AFR_COUNT (sources, priv->child_count) != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "No bigger file");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                break;
+            if (type == AFR_METADATA_TRANSACTION) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SUSE_SOURCE_BRICK_TO_HEAL);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            afr_mark_largest_file_as_source(this, sources, replies);
+            if (AFR_COUNT(sources, priv->child_count) != 1) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SNO_BIGGER_FILE);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                if (type == AFR_METADATA_TRANSACTION) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Use source-brick option to"
-                                            " heal metadata split-brain");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                afr_mark_latest_mtime_file_as_source (this, sources, replies);
-                if (AFR_COUNT (sources, priv->child_count) != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "No difference in mtime");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                break;
+            if (type == AFR_METADATA_TRANSACTION) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SUSE_SOURCE_BRICK_TO_HEAL);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            afr_mark_latest_mtime_file_as_source(this, sources, replies);
+            if (AFR_COUNT(sources, priv->child_count) != 1) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SNO_DIFF_IN_MTIME);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (xdata_req, "child-name", &name);
-                if (ret)
-                        goto out;
-                source = afr_get_child_index_from_name (this, name);
-                if (source < 0) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Invalid brick name");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                if (locked_on[source] != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Brick is not up");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                sources[source] = 1;
-                break;
-        default:
-                ret = -1;
+            ret = dict_get_str_sizen(xdata_req, "child-name", &name);
+            if (ret)
                 goto out;
+            source = afr_get_child_index_from_name(this, name);
+            if (source < 0) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SINVALID_BRICK_NAME);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            if (locked_on[source] != 1) {
+                ret = dict_set_sizen_str_sizen(xdata_rsp, "sh-fail-msg",
+                                               SBRICK_IS_NOT_UP);
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            memset(sources, 0, sizeof(*sources) * priv->child_count);
+            sources[source] = 1;
+            break;
+        default:
+            ret = -1;
+            goto out;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            break;
         }
-        for (i = 0 ; i < priv->child_count; i++) {
-                if (sources[i]) {
-                        source = i;
-                        break;
-                }
-        }
-        sinks[source] = 0;
-        healed_sinks[source] = 0;
-        ret = source;
+    }
+    sinks[source] = 0;
+    healed_sinks[source] = 0;
+    ret = source;
 out:
-        if (ret < 0)
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-        return ret;
-
+    if (ret < 0)
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+    return ret;
 }
 
 int
-afr_sh_fav_by_majority (xlator_t *this, struct afr_reply *replies,
-                        inode_t *inode)
-{
-        afr_private_t   *priv;
-        int             vote_count = -1;
-        int             fav_child = -1;
-        int             i = 0;
-        int             k = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "mtime_sec = %d, size = %lu for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_mtime,
-                                replies[i].poststat.ia_size,
-                                uuid_utoa (inode->gfid));
-                                vote_count = 0;
-                        for (k = 0; k < priv->child_count; k++) {
-                                if ((replies[k].poststat.ia_mtime ==
-                                     replies[i].poststat.ia_mtime) &&
-                                    (replies[k].poststat.ia_size ==
-                                     replies[i].poststat.ia_size)
-                                   ) {
-                                        vote_count++;
-                                }
-                        }
-                        if (vote_count > priv->child_count/2) {
-                                fav_child = i;
-                                break;
-                        }
+afr_sh_fav_by_majority(xlator_t *this, struct afr_reply *replies,
+                       inode_t *inode)
+{
+    afr_private_t *priv;
+    int vote_count = -1;
+    int fav_child = -1;
+    int i = 0;
+    int k = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s mtime_sec = %" PRId64 ", size = %" PRIu64
+                         " for gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_mtime,
+                         replies[i].poststat.ia_size, uuid_utoa(inode->gfid));
+            vote_count = 0;
+            for (k = 0; k < priv->child_count; k++) {
+                if ((replies[k].poststat.ia_mtime ==
+                     replies[i].poststat.ia_mtime) &&
+                    (replies[k].poststat.ia_size ==
+                     replies[i].poststat.ia_size)) {
+                    vote_count++;
                 }
+            }
+            if (vote_count > priv->child_count / 2) {
+                fav_child = i;
+                break;
+            }
         }
-        return fav_child;
+    }
+    return fav_child;
 }
 
 /*
  * afr_sh_fav_by_mtime: Choose favorite child by mtime.
  */
 int
-afr_sh_fav_by_mtime (xlator_t *this, struct afr_reply *replies, inode_t *inode)
-{
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint32_t cmp_mtime = 0;
-        uint32_t cmp_mtime_nsec = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "mtime = %d, mtime_nsec = %d for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_mtime,
-                                replies[i].poststat.ia_mtime_nsec,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_mtime > cmp_mtime) {
-                                cmp_mtime = replies[i].poststat.ia_mtime;
-                                cmp_mtime_nsec =
-                                        replies[i].poststat.ia_mtime_nsec;
-                                fav_child = i;
-                        } else if ((replies[i].poststat.ia_mtime == cmp_mtime)
-                                    && (replies[i].poststat.ia_mtime_nsec >
-                                    cmp_mtime_nsec)) {
-                                cmp_mtime = replies[i].poststat.ia_mtime;
-                                cmp_mtime_nsec =
-                                        replies[i].poststat.ia_mtime_nsec;
-                                fav_child = i;
-                        }
-                }
+afr_sh_fav_by_mtime(xlator_t *this, struct afr_reply *replies, inode_t *inode)
+{
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint32_t cmp_mtime = 0;
+    uint32_t cmp_mtime_nsec = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s mtime = %" PRId64
+                         ", mtime_nsec = %d for "
+                         "gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_mtime,
+                         replies[i].poststat.ia_mtime_nsec,
+                         uuid_utoa(inode->gfid));
+            if (replies[i].poststat.ia_mtime > cmp_mtime) {
+                cmp_mtime = replies[i].poststat.ia_mtime;
+                cmp_mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+                fav_child = i;
+            } else if ((replies[i].poststat.ia_mtime == cmp_mtime) &&
+                       (replies[i].poststat.ia_mtime_nsec > cmp_mtime_nsec)) {
+                cmp_mtime = replies[i].poststat.ia_mtime;
+                cmp_mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+                fav_child = i;
+            }
         }
-        return fav_child;
+    }
+    return fav_child;
 }
 
 /*
  * afr_sh_fav_by_ctime: Choose favorite child by ctime.
  */
 int
-afr_sh_fav_by_ctime (xlator_t *this, struct afr_reply *replies, inode_t *inode)
-{
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint32_t cmp_ctime = 0;
-        uint32_t cmp_ctime_nsec = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "ctime = %d, ctime_nsec = %d for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_ctime,
-                                replies[i].poststat.ia_ctime_nsec,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_ctime > cmp_ctime) {
-                                cmp_ctime = replies[i].poststat.ia_ctime;
-                                cmp_ctime_nsec =
-                                        replies[i].poststat.ia_ctime_nsec;
-                                fav_child = i;
-                        } else if ((replies[i].poststat.ia_ctime == cmp_ctime)
-                                    && (replies[i].poststat.ia_ctime_nsec >
-                                    cmp_ctime_nsec)) {
-                                cmp_ctime = replies[i].poststat.ia_ctime;
-                                cmp_ctime_nsec =
-                                        replies[i].poststat.ia_ctime_nsec;
-                                fav_child = i;
-                        }
-                }
+afr_sh_fav_by_ctime(xlator_t *this, struct afr_reply *replies, inode_t *inode)
+{
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint32_t cmp_ctime = 0;
+    uint32_t cmp_ctime_nsec = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s ctime = %" PRId64
+                         ", ctime_nsec = %d for "
+                         "gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_ctime,
+                         replies[i].poststat.ia_ctime_nsec,
+                         uuid_utoa(inode->gfid));
+            if (replies[i].poststat.ia_ctime > cmp_ctime) {
+                cmp_ctime = replies[i].poststat.ia_ctime;
+                cmp_ctime_nsec = replies[i].poststat.ia_ctime_nsec;
+                fav_child = i;
+            } else if ((replies[i].poststat.ia_ctime == cmp_ctime) &&
+                       (replies[i].poststat.ia_ctime_nsec > cmp_ctime_nsec)) {
+                cmp_ctime = replies[i].poststat.ia_ctime;
+                cmp_ctime_nsec = replies[i].poststat.ia_ctime_nsec;
+                fav_child = i;
+            }
         }
-        return fav_child;
+    }
+    return fav_child;
 }
 
 /*
- * afr_sh_fav_by_size: Choose favorite child by size.
+ * afr_sh_fav_by_size: Choose favorite child by size
+ * when not all files are of zero size.
  */
 int
-afr_sh_fav_by_size (xlator_t *this, struct afr_reply *replies, inode_t *inode)
+afr_sh_fav_by_size(xlator_t *this, struct afr_reply *replies, inode_t *inode)
 {
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint64_t cmp_sz = 0;
-
-        priv = this->private;
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint64_t cmp_sz = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "file size = %lu for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_size,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_size > cmp_sz) {
-                                cmp_sz = replies[i].poststat.ia_size;
-                                fav_child = i;
-                        }
-                }
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid) {
+            continue;
         }
-        return fav_child;
+        gf_msg_debug(this->name, 0,
+                     "Child:%s file size = %" PRIu64 " for gfid %s",
+                     priv->children[i]->name, replies[i].poststat.ia_size,
+                     uuid_utoa(inode->gfid));
+        if (replies[i].poststat.ia_type == IA_IFDIR) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+                   "Cannot perform selfheal on %s. "
+                   "Size policy is not applicable to directories.",
+                   uuid_utoa(inode->gfid));
+            break;
+        }
+        if (replies[i].poststat.ia_size > cmp_sz) {
+            cmp_sz = replies[i].poststat.ia_size;
+            fav_child = i;
+        } else if (replies[i].poststat.ia_size == cmp_sz) {
+            fav_child = -1;
+        }
+    }
+    if (fav_child == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+               "No bigger file");
+    }
+    return fav_child;
 }
 
 int
-afr_sh_get_fav_by_policy (xlator_t *this, struct afr_reply *replies,
-                          inode_t *inode, char **policy_str)
+afr_sh_get_fav_by_policy(xlator_t *this, struct afr_reply *replies,
+                         inode_t *inode, char **policy_str)
 {
-        afr_private_t *priv = NULL;
-        int fav_child = -1;
+    afr_private_t *priv = NULL;
+    int fav_child = -1;
 
-        priv = this->private;
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                return -1;
-        }
+    priv = this->private;
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        return -1;
+    }
 
-        switch (priv->fav_child_policy) {
+    switch (priv->fav_child_policy) {
         case AFR_FAV_CHILD_BY_SIZE:
-                fav_child = afr_sh_fav_by_size (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "SIZE";
-                }
-                break;
+            fav_child = afr_sh_fav_by_size(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "SIZE";
+            }
+            break;
         case AFR_FAV_CHILD_BY_CTIME:
-                fav_child = afr_sh_fav_by_ctime (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "CTIME";
-                }
-                break;
+            fav_child = afr_sh_fav_by_ctime(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "CTIME";
+            }
+            break;
         case AFR_FAV_CHILD_BY_MTIME:
-                fav_child = afr_sh_fav_by_mtime (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "MTIME";
-                }
-                break;
+            fav_child = afr_sh_fav_by_mtime(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "MTIME";
+            }
+            break;
         case AFR_FAV_CHILD_BY_MAJORITY:
-                fav_child = afr_sh_fav_by_majority (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "MAJORITY";
-                }
-                break;
+            fav_child = afr_sh_fav_by_majority(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "MAJORITY";
+            }
+            break;
         case AFR_FAV_CHILD_NONE:
         default:
-                break;
-        }
+            break;
+    }
 
-        return fav_child;
+    return fav_child;
 }
 
 int
-afr_mark_split_brain_source_sinks_by_policy (call_frame_t *frame,
-                                             xlator_t *this,
-                                             inode_t *inode,
-                                             unsigned char *sources,
-                                             unsigned char *sinks,
-                                             unsigned char *healed_sinks,
-                                             unsigned char *locked_on,
-                                             struct afr_reply *replies,
-                                             afr_transaction_type type)
-{
-        afr_private_t *priv = NULL;
-        int fav_child = -1;
-        char mtime_str[256];
-        char ctime_str[256];
-        char *policy_str = NULL;
-        struct tm *tm_ptr;
-        time_t time;
-
-        priv = this->private;
-
-        fav_child = afr_sh_get_fav_by_policy (this, replies, inode,
-                                              &policy_str);
-        if (fav_child > priv->child_count - 1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_SBRAIN_FAV_CHILD_POLICY, "Invalid child (%d) "
-                        "selected by policy %s.", fav_child, policy_str);
-        } else if (fav_child >= 0) {
-                time = replies[fav_child].poststat.ia_mtime;
-                tm_ptr = localtime (&time);
-                strftime (mtime_str, sizeof (mtime_str), "%Y-%m-%d %H:%M:%S",
-                          tm_ptr);
-                time = replies[fav_child].poststat.ia_ctime;
-                tm_ptr = localtime (&time);
-                strftime (ctime_str, sizeof (ctime_str), "%Y-%m-%d %H:%M:%S",
-                          tm_ptr);
-
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SBRAIN_FAV_CHILD_POLICY, "Source %s "
-                        "selected as authentic to resolve conflicting "
-                         "data in file (gfid:%s) by %s (%lu bytes @ %s mtime, "
-                         "%s ctime).",
-                         priv->children[fav_child]->name,
-                         uuid_utoa (inode->gfid),
-                         policy_str,
-                         replies[fav_child].poststat.ia_size,
-                         mtime_str,
-                         ctime_str);
-
-                sources[fav_child] = 1;
-                sinks[fav_child] = 0;
-                healed_sinks[fav_child] = 0;
-        }
-        return fav_child;
+afr_mark_split_brain_source_sinks_by_policy(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type)
+{
+    afr_private_t *priv = NULL;
+    int fav_child = -1;
+    char mtime_str[256];
+    char ctime_str[256];
+    char *policy_str = NULL;
+    struct tm *tm_ptr;
+    time_t time;
+
+    priv = this->private;
+
+    fav_child = afr_sh_get_fav_by_policy(this, replies, inode, &policy_str);
+    if (fav_child == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+               "No child selected by favorite-child policy.");
+    } else if (fav_child > priv->child_count - 1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+               "Invalid child (%d) "
+               "selected by policy %s.",
+               fav_child, policy_str);
+    } else if (fav_child >= 0) {
+        time = replies[fav_child].poststat.ia_mtime;
+        tm_ptr = localtime(&time);
+        strftime(mtime_str, sizeof(mtime_str), "%Y-%m-%d %H:%M:%S", tm_ptr);
+        time = replies[fav_child].poststat.ia_ctime;
+        tm_ptr = localtime(&time);
+        strftime(ctime_str, sizeof(ctime_str), "%Y-%m-%d %H:%M:%S", tm_ptr);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+               "Source %s selected as authentic to resolve conflicting data "
+               "in file (gfid:%s) by %s (%" PRIu64
+               " bytes @ %s mtime, %s "
+               "ctime).",
+               priv->children[fav_child]->name, uuid_utoa(inode->gfid),
+               policy_str, replies[fav_child].poststat.ia_size, mtime_str,
+               ctime_str);
+
+        sources[fav_child] = 1;
+        sinks[fav_child] = 0;
+        healed_sinks[fav_child] = 0;
+    }
+    return fav_child;
 }
 
-int
-afr_mark_source_sinks_if_file_empty (xlator_t *this, unsigned char *sources,
-                                     unsigned char *sinks,
-                                     unsigned char *healed_sinks,
-                                     unsigned char *locked_on,
-                                     struct afr_reply *replies,
-                                     afr_transaction_type type)
-{
-        int source = -1;
-        int i = 0;
-        afr_private_t *priv = this->private;
-        struct iatt stbuf = {0, };
-
-        if ((AFR_COUNT (locked_on, priv->child_count) < priv->child_count) ||
-            (afr_success_count(replies, priv->child_count) < priv->child_count))
-                return -1;
+gf_boolean_t
+afr_is_file_empty_on_all_children(afr_private_t *priv,
+                                  struct afr_reply *replies)
+{
+    int i = 0;
 
-        if (type == AFR_DATA_TRANSACTION) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (replies[i].poststat.ia_size != 0)
-                                return -1;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if ((!replies[i].valid) || (replies[i].op_ret != 0) ||
+            (replies[i].poststat.ia_size != 0))
+            return _gf_false;
+    }
 
-                goto mark;
-        }
+    return _gf_true;
+}
 
-        /*For AFR_METADATA_TRANSACTION, metadata must be same on all bricks.*/
-        stbuf = replies[0].poststat;
-        for (i = 1; i < priv->child_count; i++) {
-                if ((!IA_EQUAL (stbuf, replies[i].poststat, type)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, uid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, gid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, prot)))
-                        return -1;
-        }
-        for (i = 1; i < priv->child_count; i++) {
-                if (!afr_xattrs_are_equal (replies[0].xdata,
-                                           replies[i].xdata))
-                        return -1;
-        }
+int
+afr_mark_source_sinks_if_file_empty(xlator_t *this, unsigned char *sources,
+                                    unsigned char *sinks,
+                                    unsigned char *healed_sinks,
+                                    unsigned char *locked_on,
+                                    struct afr_reply *replies,
+                                    afr_transaction_type type)
+{
+    int source = -1;
+    int i = 0;
+    afr_private_t *priv = this->private;
+    struct iatt stbuf = {
+        0,
+    };
+
+    if ((AFR_COUNT(locked_on, priv->child_count) < priv->child_count) ||
+        (afr_success_count(replies, priv->child_count) < priv->child_count))
+        return -1;
+
+    if (type == AFR_DATA_TRANSACTION) {
+        if (!afr_is_file_empty_on_all_children(priv, replies))
+            return -1;
+        goto mark;
+    }
+
+    /*For AFR_METADATA_TRANSACTION, metadata must be same on all bricks.*/
+    stbuf = replies[0].poststat;
+    for (i = 1; i < priv->child_count; i++) {
+        if ((!IA_EQUAL(stbuf, replies[i].poststat, type)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, uid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, gid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, prot)))
+            return -1;
+    }
+    for (i = 1; i < priv->child_count; i++) {
+        if (!afr_xattrs_are_equal(replies[0].xdata, replies[i].xdata))
+            return -1;
+    }
 
 mark:
-        /* data/metadata is same on all bricks. Pick one of them as source. Rest
-         * are sinks.*/
-        for (i = 0 ; i < priv->child_count; i++) {
-                if (source == -1) {
-                        source = i;
-                        sources[i] = 1;
-                        sinks[i] = 0;
-                        healed_sinks[i] = 0;
-                        continue;
-                }
-                sources[i] = 0;
-                sinks[i] = 1;
-                healed_sinks[i] = 1;
+    /* data/metadata is same on all bricks. Pick one of them as source. Rest
+     * are sinks.*/
+    for (i = 0; i < priv->child_count; i++) {
+        if (source == -1) {
+            source = i;
+            sources[i] = 1;
+            sinks[i] = 0;
+            healed_sinks[i] = 0;
+            continue;
         }
+        sources[i] = 0;
+        sinks[i] = 1;
+        healed_sinks[i] = 1;
+    }
 
-        return source;
+    return source;
 }
 
 /* Return a source depending on the type of heal_op, and set sources[source],
@@ -1318,141 +1389,156 @@ mark:
  * sinks[node] are 1. This should be the case if the file is in split-brain.
  */
 int
-afr_mark_split_brain_source_sinks (call_frame_t *frame, xlator_t *this,
-                                   inode_t *inode,
-                                   unsigned char *sources,
-                                   unsigned char *sinks,
-                                   unsigned char *healed_sinks,
-                                   unsigned char *locked_on,
-                                   struct afr_reply *replies,
-                                   afr_transaction_type type)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        dict_t *xdata_req = NULL;
-        int heal_op = -1;
-        int ret = -1;
-        int source = -1;
-
-        local = frame->local;
-        priv = this->private;
-        xdata_req = local->xdata_req;
-
-        source = afr_mark_source_sinks_if_file_empty (this, sources, sinks,
-                                                      healed_sinks, locked_on,
-                                                      replies, type);
-        if (source >= 0)
-                return source;
-
-        ret = dict_get_int32 (xdata_req, "heal-op", &heal_op);
-        if (ret)
-                goto autoheal;
-
-        source = afr_mark_split_brain_source_sinks_by_heal_op (frame, this,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                            type, heal_op);
+afr_mark_split_brain_source_sinks(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata_req = NULL;
+    int heal_op = -1;
+    int ret = -1;
+    int source = -1;
+
+    local = frame->local;
+    priv = this->private;
+    xdata_req = local->xdata_req;
+
+    source = afr_mark_source_sinks_if_file_empty(
+        this, sources, sinks, healed_sinks, locked_on, replies, type);
+    if (source >= 0)
         return source;
 
+    ret = dict_get_int32_sizen(xdata_req, "heal-op", &heal_op);
+    if (ret)
+        goto autoheal;
+
+    source = afr_mark_split_brain_source_sinks_by_heal_op(
+        frame, this, sources, sinks, healed_sinks, locked_on, replies, type,
+        heal_op);
+    return source;
+
 autoheal:
-        /* Automatically heal if fav_child_policy is set. */
-        if (priv->fav_child_policy != AFR_FAV_CHILD_NONE) {
-                source = afr_mark_split_brain_source_sinks_by_policy (frame,
-                                                                      this,
-                                                                      inode,
-                                                                      sources,
-                                                                      sinks,
-                                                                   healed_sinks,
-                                                                      locked_on,
-                                                                      replies,
-                                                                      type);
-                if (source != -1) {
-                        ret = dict_set_int32 (xdata_req, "fav-child-policy", 1);
-                        if (ret)
-                                return -1;
-                }
+    /* Automatically heal if fav_child_policy is set. */
+    if (priv->fav_child_policy != AFR_FAV_CHILD_NONE) {
+        source = afr_mark_split_brain_source_sinks_by_policy(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, type);
+        if (source != -1) {
+            ret = dict_set_int32_sizen(xdata_req, "fav-child-policy", 1);
+            if (ret)
+                return -1;
         }
+    }
 
-        return source;
+    return source;
 }
 
 int
-_afr_fav_child_reset_sink_xattrs (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, int source,
-                                  unsigned char *healed_sinks,
-                                  unsigned char *undid_pending,
-                                  afr_transaction_type type,
-                                  unsigned char *locked_on,
-                                  struct afr_reply *replies)
+_afr_fav_child_reset_sink_xattrs(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, int source,
+                                 unsigned char *healed_sinks,
+                                 unsigned char *undid_pending,
+                                 afr_transaction_type type,
+                                 unsigned char *locked_on,
+                                 struct afr_reply *replies)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int *input_dirty = NULL;
-        int **input_matrix = NULL;
-	int *output_dirty = NULL;
-	int **output_matrix = NULL;
-        dict_t *xattr = NULL;
-        dict_t *xdata = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int *input_dirty = NULL;
+    int **input_matrix = NULL;
+    int *output_dirty = NULL;
+    int **output_matrix = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        if (!dict_get (local->xdata_req, "fav-child-policy"))
-                return 0;
+    if (!dict_get_sizen(local->xdata_req, "fav-child-policy"))
+        return 0;
 
-        xdata = dict_new();
-        if (!xdata)
-                return -1;
+    xdata = dict_new();
+    if (!xdata)
+        return -1;
 
-        input_dirty = alloca0 (priv->child_count * sizeof (int));
-	input_matrix = ALLOC_MATRIX (priv->child_count, int);
-	output_dirty = alloca0 (priv->child_count * sizeof (int));
-	output_matrix = ALLOC_MATRIX (priv->child_count, int);
+    input_dirty = alloca0(priv->child_count * sizeof(int));
+    input_matrix = ALLOC_MATRIX(priv->child_count, int);
+    output_dirty = alloca0(priv->child_count * sizeof(int));
+    output_matrix = ALLOC_MATRIX(priv->child_count, int);
 
-        afr_selfheal_extract_xattr (this, replies, type, input_dirty,
-                                    input_matrix);
+    afr_selfheal_extract_xattr(this, replies, type, input_dirty, input_matrix);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == source || !healed_sinks[i])
-                        continue;
-                output_dirty[i] = -input_dirty[i];
-                output_matrix[i][source] = -input_matrix[i][source];
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || !healed_sinks[i])
+            continue;
+        output_dirty[i] = -input_dirty[i];
+        output_matrix[i][source] = -input_matrix[i][source];
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!healed_sinks[i] || !locked_on[i])
-                        continue;
-                xattr = afr_selfheal_output_xattr (this, _gf_false, type,
-                                                   output_dirty, output_matrix,
-                                                   i, NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i] || !locked_on[i])
+            continue;
+        xattr = afr_selfheal_output_xattr(this, _gf_false, type, output_dirty,
+                                          output_matrix, i, NULL);
 
-                afr_selfheal_post_op (frame, this, inode, i, xattr, xdata);
+        afr_selfheal_post_op(frame, this, inode, i, xattr, xdata);
 
-                undid_pending[i] = 1;
-                dict_unref (xattr);
-        }
+        undid_pending[i] = 1;
+        dict_unref(xattr);
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    if (xdata)
+        dict_unref(xdata);
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_does_witness_exist (xlator_t *this, uint64_t *witness)
+afr_does_witness_exist(xlator_t *this, uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (witness[i])
-                        return _gf_true;
+    for (i = 0; i < priv->child_count; i++) {
+        if (witness[i])
+            return _gf_true;
+    }
+    return _gf_false;
+}
+
+unsigned int
+afr_get_quorum_count(afr_private_t *priv)
+{
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        return priv->child_count / 2 + 1;
+    } else {
+        return priv->quorum_count;
+    }
+}
+
+void
+afr_selfheal_post_op_failure_accounting(afr_private_t *priv, char *accused,
+                                        unsigned char *sources,
+                                        unsigned char *locked_on)
+{
+    int i = 0;
+    unsigned int quorum_count = 0;
+
+    if (AFR_COUNT(sources, priv->child_count) != 0)
+        return;
+
+    quorum_count = afr_get_quorum_count(priv);
+    for (i = 0; i < priv->child_count; i++) {
+        if ((accused[i] < quorum_count) && locked_on[i]) {
+            sources[i] = 1;
         }
-        return _gf_false;
+    }
+    return;
 }
 
 /*
@@ -1475,691 +1561,711 @@ afr_does_witness_exist (xlator_t *this, uint64_t *witness)
  */
 
 int
-afr_selfheal_find_direction (call_frame_t *frame, xlator_t *this,
-                             struct afr_reply *replies,
-                             afr_transaction_type type,
-                             unsigned char *locked_on, unsigned char *sources,
-                             unsigned char *sinks, uint64_t *witness,
-                             gf_boolean_t *pflag)
-{
-        afr_private_t *priv = NULL;
-        int i = 0;
-        int j = 0;
-        int *dirty = NULL; /* Denotes if dirty xattr is set */
-        int **matrix = NULL;/* Changelog matrix */
-        char *accused = NULL;/* Accused others without any self-accusal */
-        char *pending = NULL;/* Have pending operations on others */
-        char *self_accused = NULL; /* Accused itself */
-
-	priv = this->private;
-
-	dirty = alloca0 (priv->child_count * sizeof (int));
-	accused = alloca0 (priv->child_count);
-        pending = alloca0 (priv->child_count);
-        self_accused = alloca0 (priv->child_count);
-	matrix = ALLOC_MATRIX(priv->child_count, int);
-        memset (witness, 0, sizeof (*witness) * priv->child_count);
-
-	/* First construct the pending matrix for further analysis */
-	afr_selfheal_extract_xattr (this, replies, type, dirty, matrix);
-
-        if (pflag) {
-                for (i = 0; i < priv->child_count; i++) {
-                        for (j = 0; j < priv->child_count; j++)
-                                if (matrix[i][j])
-                                        *pflag = _gf_true;
-                        if (*pflag)
-                                break;
-                }
+afr_selfheal_find_direction(call_frame_t *frame, xlator_t *this,
+                            struct afr_reply *replies,
+                            afr_transaction_type type, unsigned char *locked_on,
+                            unsigned char *sources, unsigned char *sinks,
+                            uint64_t *witness, unsigned char *pflag)
+{
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int j = 0;
+    int *dirty = NULL;         /* Denotes if dirty xattr is set */
+    int **matrix = NULL;       /* Changelog matrix */
+    char *accused = NULL;      /* Accused others without any self-accusal */
+    char *pending = NULL;      /* Have pending operations on others */
+    char *self_accused = NULL; /* Accused itself */
+
+    priv = this->private;
+
+    dirty = alloca0(priv->child_count * sizeof(int));
+    accused = alloca0(priv->child_count);
+    pending = alloca0(priv->child_count);
+    self_accused = alloca0(priv->child_count);
+    matrix = ALLOC_MATRIX(priv->child_count, int);
+    memset(witness, 0, sizeof(*witness) * priv->child_count);
+
+    /* First construct the pending matrix for further analysis */
+    afr_selfheal_extract_xattr(this, replies, type, dirty, matrix);
+
+    if (pflag) {
+        for (i = 0; i < priv->child_count; i++) {
+            for (j = 0; j < priv->child_count; j++)
+                if (matrix[i][j])
+                    *pflag |= PFLAG_PENDING;
+            if (*pflag)
+                break;
         }
-
-        if (afr_success_count (replies,
-                               priv->child_count) < AFR_SH_MIN_PARTICIPANTS) {
-                /* Treat this just like locks not being acquired */
-                return -ENOTCONN;
+    }
+
+    if (afr_success_count(replies, priv->child_count) < priv->child_count) {
+        /* Treat this just like locks not being acquired */
+        return -ENOTCONN;
+    }
+
+    /* short list all self-accused */
+    for (i = 0; i < priv->child_count; i++) {
+        if (matrix[i][i])
+            self_accused[i] = 1;
+    }
+
+    /* Next short list all accused to exclude them from being sources */
+    /* Self-accused can't accuse others as they are FOOLs */
+    for (i = 0; i < priv->child_count; i++) {
+        for (j = 0; j < priv->child_count; j++) {
+            if (matrix[i][j]) {
+                if (!self_accused[i])
+                    accused[j] += 1;
+                if (i != j)
+                    pending[i] += 1;
+            }
         }
+    }
 
-        /* short list all self-accused */
-        for (i = 0; i < priv->child_count; i++) {
-                if (matrix[i][i])
-                        self_accused[i] = 1;
+    /* Short list all non-accused as sources */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!accused[i] && locked_on[i])
+            sources[i] = 1;
+        else
+            sources[i] = 0;
+    }
+
+    /* Everyone accused by non-self-accused sources are sinks */
+    memset(sinks, 0, priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (self_accused[i])
+            continue;
+        for (j = 0; j < priv->child_count; j++) {
+            if (matrix[i][j])
+                sinks[j] = 1;
         }
-
-	/* Next short list all accused to exclude them from being sources */
-        /* Self-accused can't accuse others as they are FOOLs */
-	for (i = 0; i < priv->child_count; i++) {
-		for (j = 0; j < priv->child_count; j++) {
-                        if (matrix[i][j]) {
-                                 if (!self_accused[i])
-                                         accused[j] = 1;
-
-                                 if (i != j)
-                                         pending[i] = 1;
-                         }
-		}
-	}
-
-	/* Short list all non-accused as sources */
-	memset (sources, 0, priv->child_count);
-	for (i = 0; i < priv->child_count; i++) {
-		if (!accused[i] && locked_on[i])
-			sources[i] = 1;
-	}
-
-        /* Everyone accused by non-self-accused sources are sinks */
-        memset (sinks, 0, priv->child_count);
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (self_accused[i])
-                        continue;
-                for (j = 0; j < priv->child_count; j++) {
-                        if (matrix[i][j])
-                                sinks[j] = 1;
-                }
+    }
+
+    /* For breaking ties provide with number of fops they witnessed */
+
+    /*
+     * count the pending fops witnessed from itself to others when it is
+     * self-accused
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!self_accused[i])
+            continue;
+        for (j = 0; j < priv->child_count; j++) {
+            if (i == j)
+                continue;
+            witness[i] += matrix[i][j];
         }
+    }
 
-        /* For breaking ties provide with number of fops they witnessed */
+    if (type == AFR_DATA_TRANSACTION || type == AFR_METADATA_TRANSACTION)
+        afr_selfheal_post_op_failure_accounting(priv, accused, sources,
+                                                locked_on);
 
-        /*
-         * count the pending fops witnessed from itself to others when it is
-         * self-accused
-         */
+    /* If no sources, all locked nodes are sinks - split brain */
+    if (AFR_COUNT(sources, priv->child_count) == 0) {
         for (i = 0; i < priv->child_count; i++) {
-                if (!self_accused[i])
-                        continue;
-                for (j = 0; j < priv->child_count; j++) {
-                        if (i == j)
-                                continue;
-                        witness[i] += matrix[i][j];
-                }
+            if (locked_on[i])
+                sinks[i] = 1;
         }
-
-         /* If no sources, all locked nodes are sinks - split brain */
-         if (AFR_COUNT (sources, priv->child_count) == 0) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (locked_on[i])
-                                sinks[i] = 1;
-                }
+        if (pflag)
+            *pflag |= PFLAG_SBRAIN;
+    }
+
+    /* One more class of witness similar to dirty in v2 is where no pending
+     * exists but we have self-accusing markers. This can happen in afr-v1
+     * if the brick crashes just after doing xattrop on self but
+     * before xattrop on the other xattrs on the brick in pre-op. */
+    if (AFR_COUNT(pending, priv->child_count) == 0) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (self_accused[i])
+                witness[i] += matrix[i][i];
         }
-
-        /* One more class of witness similar to dirty in v2 is where no pending
-         * exists but we have self-accusing markers. This can happen in afr-v1
-         * if the brick crashes just after doing xattrop on self but
-         * before xattrop on the other xattrs on the brick in pre-op. */
-        if (AFR_COUNT (pending, priv->child_count) == 0) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (self_accused[i])
-                                witness[i] += matrix[i][i];
-                }
-        } else {
-                /* In afr-v1 if a file is self-accused and has pending
-                 * operations on others then it is similar to 'dirty' in afr-v2.
-                 * Consider such cases as witness.
-                 */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (self_accused[i] && pending[i])
-                                witness[i] += matrix[i][i];
-                }
+    } else {
+        /* In afr-v1 if a file is self-accused and has pending
+         * operations on others then it is similar to 'dirty' in afr-v2.
+         * Consider such cases as witness.
+         */
+        for (i = 0; i < priv->child_count; i++) {
+            if (self_accused[i] && pending[i])
+                witness[i] += matrix[i][i];
         }
+    }
 
+    /* count the number of dirty fops witnessed */
+    for (i = 0; i < priv->child_count; i++)
+        witness[i] += dirty[i];
 
-        /* count the number of dirty fops witnessed */
-        for (i = 0; i < priv->child_count; i++)
-                witness[i] += dirty[i];
-
-	return 0;
+    return 0;
 }
 
 void
-afr_log_selfheal (uuid_t gfid, xlator_t *this, int ret, char *type,
-                  int source, unsigned char *sources,
-                  unsigned char *healed_sinks)
-{
-        char *status = NULL;
-        char *sinks_str = NULL;
-        char *p = NULL;
-        char *sources_str = NULL;
-        char *q = NULL;
-        afr_private_t *priv = NULL;
-        gf_loglevel_t loglevel = GF_LOG_NONE;
-        int i = 0;
-
-        priv = this->private;
-        sinks_str = alloca0 (priv->child_count * 8);
-        p = sinks_str;
-        sources_str = alloca0 (priv->child_count * 8);
-        q = sources_str;
-        for (i = 0; i < priv->child_count; i++) {
-                if (healed_sinks[i])
-                        p += sprintf (p, "%d ", i);
-                if (sources[i]) {
-                        if (source == i) {
-                                q += sprintf (q, "[%d] ", i);
-                        } else {
-                                q += sprintf (q, "%d ", i);
-                        }
-                }
+afr_log_selfheal(uuid_t gfid, xlator_t *this, int ret, char *type, int source,
+                 unsigned char *sources, unsigned char *healed_sinks)
+{
+    char *status = NULL;
+    char *sinks_str = NULL;
+    char *p = NULL;
+    char *sources_str = NULL;
+    char *q = NULL;
+    afr_private_t *priv = NULL;
+    gf_loglevel_t loglevel = GF_LOG_NONE;
+    int i = 0;
+
+    priv = this->private;
+    sinks_str = alloca0(priv->child_count * 8);
+    p = sinks_str;
+    sources_str = alloca0(priv->child_count * 8);
+    q = sources_str;
+    for (i = 0; i < priv->child_count; i++) {
+        if (healed_sinks[i])
+            p += sprintf(p, "%d ", i);
+        if (sources[i]) {
+            if (source == i) {
+                q += sprintf(q, "[%d] ", i);
+            } else {
+                q += sprintf(q, "%d ", i);
+            }
         }
+    }
 
-        if (ret < 0) {
-                status = "Failed";
-                loglevel = GF_LOG_DEBUG;
-        } else {
-                status = "Completed";
-                loglevel = GF_LOG_INFO;
-        }
+    if (ret < 0) {
+        status = "Failed";
+        loglevel = GF_LOG_DEBUG;
+    } else {
+        status = "Completed";
+        loglevel = GF_LOG_INFO;
+    }
 
-        gf_msg (this->name, loglevel, 0,
-                AFR_MSG_SELF_HEAL_INFO, "%s %s selfheal on %s. "
-                "sources=%s sinks=%s", status, type, uuid_utoa (gfid),
-                sources_str, sinks_str);
+    gf_msg(this->name, loglevel, 0, AFR_MSG_SELF_HEAL_INFO,
+           "%s %s selfheal on %s. "
+           "sources=%s sinks=%s",
+           status, type, uuid_utoa(gfid), sources_str, sinks_str);
 }
 
 int
-afr_selfheal_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			   int op_ret, int op_errno, inode_t *inode,
-			   struct iatt *buf, dict_t *xdata, struct iatt *parbuf)
-{
-	afr_local_t *local = NULL;
-	int i = -1;
-        GF_UNUSED int ret = -1;
-	int8_t need_heal = 1;
-
-	local = frame->local;
-	i = (long) cookie;
-
-	local->replies[i].valid = 1;
-	local->replies[i].op_ret = op_ret;
-	local->replies[i].op_errno = op_errno;
-	if (buf)
-		local->replies[i].poststat = *buf;
-	if (parbuf)
-		local->replies[i].postparent = *parbuf;
-	if (xdata) {
-		local->replies[i].xdata = dict_ref (xdata);
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[i].need_heal = need_heal;
-        } else {
-                local->replies[i].need_heal = need_heal;
-        }
-
-	syncbarrier_wake (&local->barrier);
+afr_selfheal_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xdata, struct iatt *parbuf)
+{
+    afr_local_t *local = NULL;
+    int i = -1;
+    GF_UNUSED int ret = -1;
+    int8_t need_heal = 1;
 
-	return 0;
-}
+    local = frame->local;
+    i = (long)cookie;
 
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (buf)
+        local->replies[i].poststat = *buf;
+    if (parbuf)
+        local->replies[i].postparent = *parbuf;
+    if (xdata) {
+        local->replies[i].xdata = dict_ref(xdata);
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+    }
 
-inode_t *
-afr_selfheal_unlocked_lookup_on (call_frame_t *frame, inode_t *parent,
-				 const char *name, struct afr_reply *replies,
-				 unsigned char *lookup_on, dict_t *xattr)
-{
-	loc_t loc = {0, };
-	dict_t *xattr_req = NULL;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	inode_t *inode = NULL;
+    local->replies[i].need_heal = need_heal;
+    syncbarrier_wake(&local->barrier);
 
-	local = frame->local;
-	priv = frame->this->private;
+    return 0;
+}
 
-	xattr_req = dict_new ();
-	if (!xattr_req)
-		return NULL;
+inode_t *
+afr_selfheal_unlocked_lookup_on(call_frame_t *frame, inode_t *parent,
+                                const char *name, struct afr_reply *replies,
+                                unsigned char *lookup_on, dict_t *xattr)
+{
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr_req = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+
+    local = frame->local;
+    priv = frame->this->private;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        return NULL;
 
-        if (xattr)
-                dict_copy (xattr, xattr_req);
+    if (xattr)
+        dict_copy(xattr, xattr_req);
 
-	if (afr_xattr_req_prepare (frame->this, xattr_req) != 0) {
-		dict_unref (xattr_req);
-		return NULL;
-	}
+    if (afr_xattr_req_prepare(frame->this, xattr_req) != 0) {
+        dict_unref(xattr_req);
+        return NULL;
+    }
 
-	inode = inode_new (parent->table);
-	if (!inode) {
-		dict_unref (xattr_req);
-		return NULL;
-	}
+    inode = inode_new(parent->table);
+    if (!inode) {
+        dict_unref(xattr_req);
+        return NULL;
+    }
 
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, parent->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
 
-	AFR_ONLIST (lookup_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
-		    xattr_req);
+    AFR_ONLIST(lookup_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               xattr_req);
 
-	afr_replies_copy (replies, local->replies, priv->child_count);
+    afr_replies_copy(replies, local->replies, priv->child_count);
 
-	loc_wipe (&loc);
-	dict_unref (xattr_req);
+    loc_wipe(&loc);
+    dict_unref(xattr_req);
 
-	return inode;
+    return inode;
 }
 
-int
-afr_selfheal_unlocked_discover_on (call_frame_t *frame, inode_t *inode,
-				   uuid_t gfid, struct afr_reply *replies,
-				   unsigned char *discover_on)
+static int
+afr_set_multi_dom_lock_count_request(xlator_t *this, dict_t *dict)
 {
-	loc_t loc = {0, };
-	dict_t *xattr_req = NULL;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    char *key1 = NULL;
+    char *key2 = NULL;
+
+    priv = this->private;
+    key1 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +
+                   strlen(this->name));
+    key2 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +
+                   strlen(priv->sh_domain));
 
-	local = frame->local;
-	priv = frame->this->private;
+    ret = dict_set_uint32(dict, GLUSTERFS_MULTIPLE_DOM_LK_CNT_REQUESTS, 1);
+    if (ret)
+        return ret;
 
-	xattr_req = dict_new ();
-	if (!xattr_req)
-		return -ENOMEM;
+    sprintf(key1, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, this->name);
+    ret = dict_set_uint32(dict, key1, 1);
+    if (ret)
+        return ret;
 
-	if (afr_xattr_req_prepare (frame->this, xattr_req) != 0) {
-		dict_unref (xattr_req);
-		return -ENOMEM;
-	}
+    sprintf(key2, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, priv->sh_domain);
+    ret = dict_set_uint32(dict, key2, 1);
+    if (ret)
+        return ret;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, gfid);
+    return 0;
+}
+
+int
+afr_selfheal_unlocked_discover_on(call_frame_t *frame, inode_t *inode,
+                                  uuid_t gfid, struct afr_reply *replies,
+                                  unsigned char *discover_on, dict_t *dict)
+{
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr_req = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = frame->this->private;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        return -ENOMEM;
+    if (dict)
+        dict_copy(dict, xattr_req);
+
+    if (afr_xattr_req_prepare(frame->this, xattr_req) != 0) {
+        dict_unref(xattr_req);
+        return -ENOMEM;
+    }
+
+    if (afr_set_multi_dom_lock_count_request(frame->this, xattr_req)) {
+        dict_unref(xattr_req);
+        return -1;
+    }
 
-	AFR_ONLIST (discover_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
-		    xattr_req);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, gfid);
 
-	afr_replies_copy (replies, local->replies, priv->child_count);
+    AFR_ONLIST(discover_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               xattr_req);
 
-	loc_wipe (&loc);
-	dict_unref (xattr_req);
+    afr_replies_copy(replies, local->replies, priv->child_count);
 
-	return 0;
+    loc_wipe(&loc);
+    dict_unref(xattr_req);
+
+    return 0;
 }
 
 int
-afr_selfheal_unlocked_discover (call_frame_t *frame, inode_t *inode,
-				uuid_t gfid, struct afr_reply *replies)
+afr_selfheal_unlocked_discover(call_frame_t *frame, inode_t *inode, uuid_t gfid,
+                               struct afr_reply *replies)
 {
-	afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    dict_t *dict = NULL;
+
+    local = frame->local;
 
-	priv = frame->this->private;
+    if (local->xattr_req)
+        dict = local->xattr_req;
 
-	return afr_selfheal_unlocked_discover_on (frame, inode, gfid, replies,
-						  priv->child_up);
+    return afr_selfheal_unlocked_discover_on(frame, inode, gfid, replies,
+                                             local->child_up, dict);
 }
 
 unsigned int
-afr_success_count (struct afr_reply *replies, unsigned int count)
+afr_success_count(struct afr_reply *replies, unsigned int count)
 {
-        int     i = 0;
-        unsigned int success = 0;
+    int i = 0;
+    unsigned int success = 0;
 
-        for (i = 0; i < count; i++)
-                if (replies[i].valid && replies[i].op_ret == 0)
-                        success++;
-        return success;
+    for (i = 0; i < count; i++)
+        if (replies[i].valid && replies[i].op_ret == 0)
+            success++;
+    return success;
 }
 
 int
-afr_selfheal_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		       int op_ret, int op_errno, dict_t *xdata)
+afr_selfheal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-	int i = 0;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-	local = frame->local;
-	i = (long) cookie;
+    local = frame->local;
+    i = (long)cookie;
 
-	local->replies[i].valid = 1;
-	local->replies[i].op_ret = op_ret;
-	local->replies[i].op_errno = op_errno;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
 
-	syncbarrier_wake (&local->barrier);
+    syncbarrier_wake(&local->barrier);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_locked_fill (call_frame_t *frame, xlator_t *this,
-                 unsigned char *locked_on)
+afr_locked_fill(call_frame_t *frame, xlator_t *this, unsigned char *locked_on)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int count = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int count = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].valid && local->replies[i].op_ret == 0) {
-			locked_on[i] = 1;
-			count++;
-		} else {
-			locked_on[i] = 0;
-		}
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].op_ret == 0) {
+            locked_on[i] = 1;
+            count++;
+        } else {
+            locked_on[i] = 0;
+        }
+    }
 
-	return count;
+    return count;
 }
 
-
 int
-afr_selfheal_tryinodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, off_t off, size_t size,
-			 unsigned char *locked_on)
+afr_selfheal_tryinodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, off_t off, size_t size,
+                        unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		    &loc, F_SETLK, &flock, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_inodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, off_t off, size_t size,
-		      unsigned char *locked_on)
-{
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
-	afr_local_t *local = NULL;
-	int i = 0;
-	afr_private_t *priv = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
-
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		    &loc, F_SETLK, &flock, NULL);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].op_ret == -1 &&
-		    local->replies[i].op_errno == EAGAIN) {
-			afr_locked_fill (frame, this, locked_on);
-			afr_selfheal_uninodelk (frame, this, inode, dom, off,
-						size, locked_on);
-
-			AFR_SEQ (frame, afr_selfheal_lock_cbk, inodelk, dom,
-				 &loc, F_SETLKW, &flock, NULL);
-			break;
-		}
-	}
+afr_selfheal_inodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, off_t off, size_t size,
+                     unsigned char *locked_on)
+{
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
+
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == -1 &&
+            local->replies[i].op_errno == EAGAIN) {
+            afr_locked_fill(frame, this, locked_on);
+            afr_selfheal_uninodelk(frame, this, inode, dom, off, size,
+                                   locked_on);
+
+            AFR_SEQ(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLKW,
+                    &flock, NULL);
+            break;
+        }
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 static void
-afr_get_lock_and_eagain_counts (afr_private_t *priv, struct afr_reply *replies,
-                                int *lock_count, int *eagain_count)
-{
-	int i = 0;
-
-	for (i = 0; i < priv->child_count; i++) {
-	        if (!replies[i].valid)
-	                continue;
-	        if (replies[i].op_ret == 0) {
-	                (*lock_count)++;
-                } else if (replies[i].op_ret == -1 &&
-		         replies[i].op_errno == EAGAIN) {
-		        (*eagain_count)++;
-                }
-	}
+afr_get_lock_and_eagain_counts(afr_private_t *priv, struct afr_reply *replies,
+                               int *lock_count, int *eagain_count)
+{
+    int i = 0;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret == 0) {
+            (*lock_count)++;
+        } else if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            (*eagain_count)++;
+        }
+    }
 }
 
 /*Do blocking locks if number of locks acquired is majority and there were some
  * EAGAINs. Useful for odd-way replication*/
 int
-afr_selfheal_tie_breaker_inodelk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, off_t off,
-                                  size_t size, unsigned char *locked_on)
+afr_selfheal_tie_breaker_inodelk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, off_t off,
+                                 size_t size, unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int lock_count = 0;
-	int eagain_count = 0;
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int lock_count = 0;
+    int eagain_count = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		   &loc, F_SETLK, &flock, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
 
-        afr_get_lock_and_eagain_counts (priv, local->replies, &lock_count,
-                                        &eagain_count);
+    afr_get_lock_and_eagain_counts(priv, local->replies, &lock_count,
+                                   &eagain_count);
 
-	if (lock_count > priv->child_count/2 && eagain_count) {
-                afr_locked_fill (frame, this, locked_on);
-                afr_selfheal_uninodelk (frame, this, inode, dom, off,
-                                        size, locked_on);
+    if (lock_count > priv->child_count / 2 && eagain_count) {
+        afr_locked_fill(frame, this, locked_on);
+        afr_selfheal_uninodelk(frame, this, inode, dom, off, size, locked_on);
 
-                AFR_SEQ (frame, afr_selfheal_lock_cbk, inodelk, dom,
-                         &loc, F_SETLKW, &flock, NULL);
-        }
+        AFR_SEQ(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLKW,
+                &flock, NULL);
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 int
-afr_selfheal_uninodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, off_t off, size_t size,
-			const unsigned char *locked_on)
+afr_selfheal_uninodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, off_t off, size_t size,
+                       const unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
-
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_UNLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_UNLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONLIST (locked_on, frame, afr_selfheal_lock_cbk, inodelk,
-		    dom, &loc, F_SETLK, &flock, NULL);
+    AFR_ONLIST(locked_on, frame, afr_selfheal_lock_cbk, inodelk, dom, &loc,
+               F_SETLK, &flock, NULL);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_tryentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, const char *name, unsigned char *locked_on)
+afr_selfheal_tryentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, const char *name, unsigned char *locked_on)
 {
-	loc_t loc = {0,};
+    loc_t loc = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom,
-		   &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_entrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, const char *name, unsigned char *locked_on)
-{
-	loc_t loc = {0,};
-	afr_local_t *local = NULL;
-	int i = 0;
-	afr_private_t *priv = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
-		   name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].op_ret == -1 &&
-		    local->replies[i].op_errno == EAGAIN) {
-			afr_locked_fill (frame, this, locked_on);
-			afr_selfheal_unentrylk (frame, this, inode, dom, name,
-						locked_on, NULL);
-
-			AFR_SEQ (frame, afr_selfheal_lock_cbk, entrylk, dom,
-				 &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-			break;
-		}
-	}
+afr_selfheal_entrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, const char *name, unsigned char *locked_on)
+{
+    loc_t loc = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == -1 &&
+            local->replies[i].op_errno == EAGAIN) {
+            afr_locked_fill(frame, this, locked_on);
+            afr_selfheal_unentrylk(frame, this, inode, dom, name, locked_on,
+                                   NULL);
+
+            AFR_SEQ(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+                    ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+            break;
+        }
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 int
-afr_selfheal_tie_breaker_entrylk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, const char *name,
-                                  unsigned char *locked_on)
+afr_selfheal_tie_breaker_entrylk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, const char *name,
+                                 unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int lock_count = 0;
-	int eagain_count = 0;
+    loc_t loc = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int lock_count = 0;
+    int eagain_count = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
-		   name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-        afr_get_lock_and_eagain_counts (priv, local->replies, &lock_count,
-                                        &eagain_count);
+    afr_get_lock_and_eagain_counts(priv, local->replies, &lock_count,
+                                   &eagain_count);
 
-	if (lock_count > priv->child_count/2 && eagain_count) {
-                afr_locked_fill (frame, this, locked_on);
-                afr_selfheal_unentrylk (frame, this, inode, dom, name,
-                                        locked_on, NULL);
+    if (lock_count > priv->child_count / 2 && eagain_count) {
+        afr_locked_fill(frame, this, locked_on);
+        afr_selfheal_unentrylk(frame, this, inode, dom, name, locked_on, NULL);
 
-                AFR_SEQ (frame, afr_selfheal_lock_cbk, entrylk, dom,
-                         &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-	}
+        AFR_SEQ(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+                ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_unentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, const char *name, unsigned char *locked_on,
-                        dict_t *xdata)
-{
-	loc_t loc = {0,};
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	AFR_ONLIST (locked_on, frame, afr_selfheal_lock_cbk, entrylk,
-		    dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, xdata);
-
-	loc_wipe (&loc);
-
-	return 0;
-}
-
-
-gf_boolean_t
-afr_is_pending_set (xlator_t *this, dict_t *xdata, int type)
+afr_selfheal_unentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, const char *name, unsigned char *locked_on,
+                       dict_t *xdata)
 {
-	int idx = -1;
-	afr_private_t *priv = NULL;
-	void *pending_raw = NULL;
-	int *pending_int = NULL;
-	int i = 0;
+    loc_t loc = {
+        0,
+    };
 
-	priv = this->private;
-	idx = afr_index_for_transaction_type (type);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	if (dict_get_ptr (xdata, AFR_DIRTY, &pending_raw) == 0) {
-		if (pending_raw) {
-			pending_int = pending_raw;
+    AFR_ONLIST(locked_on, frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
+               name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, xdata);
 
-			if (ntoh32 (pending_int[idx]))
-				return _gf_true;
-		}
-	}
+    loc_wipe(&loc);
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (dict_get_ptr (xdata, priv->pending_key[i],
-				  &pending_raw))
-			continue;
-		if (!pending_raw)
-			continue;
-		pending_int = pending_raw;
-
-		if (ntoh32 (pending_int[idx]))
-			return _gf_true;
-	}
-
-	return _gf_false;
+    return 0;
 }
 
-
 gf_boolean_t
-afr_is_data_set (xlator_t *this, dict_t *xdata)
+afr_is_data_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_DATA_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_DATA_TRANSACTION);
 }
 
 gf_boolean_t
-afr_is_metadata_set (xlator_t *this, dict_t *xdata)
+afr_is_metadata_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_METADATA_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_METADATA_TRANSACTION);
 }
 
 gf_boolean_t
-afr_is_entry_set (xlator_t *this, dict_t *xdata)
+afr_is_entry_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_ENTRY_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_ENTRY_TRANSACTION);
 }
 
 /*
@@ -2172,307 +2278,310 @@ afr_is_entry_set (xlator_t *this, dict_t *xdata)
  */
 
 int
-afr_selfheal_unlocked_inspect (call_frame_t *frame, xlator_t *this,
-			       uuid_t gfid, inode_t **link_inode,
-			       gf_boolean_t *data_selfheal,
-			       gf_boolean_t *metadata_selfheal,
-			       gf_boolean_t *entry_selfheal)
-{
-	afr_private_t *priv = NULL;
-        inode_t *inode = NULL;
-	int i = 0;
-	int valid_cnt = 0;
-	struct iatt first = {0, };
-        int first_idx = 0;
-	struct afr_reply *replies = NULL;
-	int ret = -1;
-
-	priv = this->private;
-
-        inode = afr_inode_find (this, gfid);
-        if (!inode)
-                goto out;
+afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,
+                              inode_t **link_inode, gf_boolean_t *data_selfheal,
+                              gf_boolean_t *metadata_selfheal,
+                              gf_boolean_t *entry_selfheal,
+                              struct afr_reply *replies_dst)
+{
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    int i = 0;
+    int valid_cnt = 0;
+    struct iatt first = {
+        0,
+    };
+    int first_idx = 0;
+    struct afr_reply *replies = NULL;
+    int ret = -1;
+
+    priv = this->private;
+
+    inode = afr_inode_find(this, gfid);
+    if (!inode)
+        goto out;
 
-	replies = alloca0 (sizeof (*replies) * priv->child_count);
+    replies = alloca0(sizeof(*replies) * priv->child_count);
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, gfid, replies);
-	if (ret)
-                goto out;
+    ret = afr_selfheal_unlocked_discover(frame, inode, gfid, replies);
+    if (ret)
+        goto out;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-		if (replies[i].op_ret == -1)
-			continue;
-
-                /* The data segment of the changelog can be non-zero to indicate
-                 * the directory needs a full heal. So the check below ensures
-                 * it's not a directory before setting the data_selfheal boolean.
-                 */
-		if (data_selfheal && !IA_ISDIR (replies[i].poststat.ia_type) &&
-                    afr_is_data_set (this, replies[i].xdata))
-			*data_selfheal = _gf_true;
-
-		if (metadata_selfheal &&
-                    afr_is_metadata_set (this, replies[i].xdata))
-			*metadata_selfheal = _gf_true;
-
-		if (entry_selfheal && afr_is_entry_set (this, replies[i].xdata))
-			*entry_selfheal = _gf_true;
-
-		valid_cnt++;
-		if (valid_cnt == 1) {
-			first = replies[i].poststat;
-                        first_idx = i;
-			continue;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, type)) {
-		        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN,
-				"TYPE mismatch %d vs %d on %s for gfid:%s",
-				(int) first.ia_type,
-				(int) replies[i].poststat.ia_type,
-				priv->children[i]->name,
-				uuid_utoa (replies[i].poststat.ia_gfid));
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;"
-                                "type=file;gfid=%s;"
-                                "ia_type-%d=%s;ia_type-%d=%s",
-                                this->name,
-                                uuid_utoa (replies[i].poststat.ia_gfid),
-                                first_idx,
-                                gf_inode_type_to_str (first.ia_type), i,
-                            gf_inode_type_to_str (replies[i].poststat.ia_type));
-                        ret = -EIO;
-                        goto out;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, uid)) {
-		        gf_msg_debug (this->name, 0,
-				      "UID mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) first.ia_uid,
-				      (int) replies[i].poststat.ia_uid,
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, gid)) {
-		        gf_msg_debug (this->name, 0,
-				      "GID mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) first.ia_uid,
-				      (int) replies[i].poststat.ia_uid,
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, prot)) {
-		        gf_msg_debug (this->name, 0,
-			              "MODE mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) st_mode_from_ia (first.ia_prot, 0),
-				      (int) st_mode_from_ia
-                                      (replies[i].poststat.ia_prot, 0),
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (IA_ISREG(first.ia_type) &&
-		    !IA_EQUAL (first, replies[i].poststat, size)) {
-		        gf_msg_debug (this->name, 0,
-                                      "SIZE mismatch "
-                                      "%lld vs %lld on %s for gfid:%s",
-                                      (long long) first.ia_size,
-                                      (long long) replies[i].poststat.ia_size,
-                                      priv->children[i]->name,
-                                      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (data_selfheal)
-                                *data_selfheal = _gf_true;
-		}
-	}
-
-	if (valid_cnt > 0 && link_inode) {
-		*link_inode = inode_link (inode, NULL, NULL, &first);
-                if (!*link_inode) {
-                        ret = -EINVAL;
-                        goto out;
-                }
-        } else if (valid_cnt < 2) {
-                ret = afr_check_stale_error (replies, priv);
-                goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret == -1)
+            continue;
+
+        /* The data segment of the changelog can be non-zero to indicate
+         * the directory needs a full heal. So the check below ensures
+         * it's not a directory before setting the data_selfheal boolean.
+         */
+        if (data_selfheal && !IA_ISDIR(replies[i].poststat.ia_type) &&
+            afr_is_data_set(this, replies[i].xdata))
+            *data_selfheal = _gf_true;
+
+        if (metadata_selfheal && afr_is_metadata_set(this, replies[i].xdata))
+            *metadata_selfheal = _gf_true;
+
+        if (entry_selfheal && afr_is_entry_set(this, replies[i].xdata))
+            *entry_selfheal = _gf_true;
+
+        valid_cnt++;
+        if (valid_cnt == 1) {
+            first = replies[i].poststat;
+            first_idx = i;
+            continue;
         }
 
-        ret = 0;
+        if (!IA_EQUAL(first, replies[i].poststat, type)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                   "TYPE mismatch %d vs %d on %s for gfid:%s",
+                   (int)first.ia_type, (int)replies[i].poststat.ia_type,
+                   priv->children[i]->name,
+                   uuid_utoa(replies[i].poststat.ia_gfid));
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "client-pid=%d;"
+                     "subvol=%s;"
+                     "type=file;gfid=%s;"
+                     "ia_type-%d=%s;ia_type-%d=%s",
+                     this->ctx->cmd_args.client_pid, this->name,
+                     uuid_utoa(replies[i].poststat.ia_gfid), first_idx,
+                     gf_inode_type_to_str(first.ia_type), i,
+                     gf_inode_type_to_str(replies[i].poststat.ia_type));
+            ret = -EIO;
+            goto out;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, uid)) {
+            gf_msg_debug(this->name, 0,
+                         "UID mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)first.ia_uid, (int)replies[i].poststat.ia_uid,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, gid)) {
+            gf_msg_debug(this->name, 0,
+                         "GID mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)first.ia_uid, (int)replies[i].poststat.ia_uid,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, prot)) {
+            gf_msg_debug(this->name, 0,
+                         "MODE mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)st_mode_from_ia(first.ia_prot, 0),
+                         (int)st_mode_from_ia(replies[i].poststat.ia_prot, 0),
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (IA_ISREG(first.ia_type) &&
+            !IA_EQUAL(first, replies[i].poststat, size)) {
+            gf_msg_debug(this->name, 0,
+                         "SIZE mismatch "
+                         "%lld vs %lld on %s for gfid:%s",
+                         (long long)first.ia_size,
+                         (long long)replies[i].poststat.ia_size,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (data_selfheal)
+                *data_selfheal = _gf_true;
+        }
+    }
+
+    if (valid_cnt > 0 && link_inode) {
+        *link_inode = inode_link(inode, NULL, NULL, &first);
+        if (!*link_inode) {
+            ret = -EINVAL;
+            goto out;
+        }
+    } else if (valid_cnt < 2) {
+        ret = afr_check_stale_error(replies, priv);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (inode)
-                inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
+    if (replies && replies_dst)
+        afr_replies_copy(replies_dst, replies, priv->child_count);
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-afr_inode_find (xlator_t *this, uuid_t gfid)
+afr_inode_find(xlator_t *this, uuid_t gfid)
 {
-	inode_table_t *table = NULL;
-	inode_t *inode = NULL;
+    inode_table_t *table = NULL;
+    inode_t *inode = NULL;
 
-	table = this->itable;
-	if (!table)
-		return NULL;
+    table = this->itable;
+    if (!table)
+        return NULL;
 
-	inode = inode_find (table, gfid);
-	if (inode)
-		return inode;
+    inode = inode_find(table, gfid);
+    if (inode)
+        return inode;
 
-	inode = inode_new (table);
-	if (!inode)
-		return NULL;
+    inode = inode_new(table);
+    if (!inode)
+        return NULL;
 
-	gf_uuid_copy (inode->gfid, gfid);
+    gf_uuid_copy(inode->gfid, gfid);
 
-	return inode;
+    return inode;
 }
 
-
 call_frame_t *
-afr_frame_create (xlator_t *this)
+afr_frame_create(xlator_t *this, int32_t *op_errno)
 {
-	call_frame_t *frame    = NULL;
-	afr_local_t  *local    = NULL;
-	int           op_errno = 0;
-	pid_t         pid      = GF_CLIENT_PID_SELF_HEALD;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    pid_t pid = GF_CLIENT_PID_SELF_HEALD;
 
-	frame = create_frame (this, this->ctx->pool);
-	if (!frame)
-		return NULL;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        return NULL;
+    }
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local) {
-		STACK_DESTROY (frame->root);
-		return NULL;
-	}
+    local = AFR_FRAME_INIT(frame, (*op_errno));
+    if (!local) {
+        STACK_DESTROY(frame->root);
+        return NULL;
+    }
 
-	syncopctx_setfspid (&pid);
+    syncopctx_setfspid(&pid);
 
-	frame->root->pid = pid;
+    frame->root->pid = pid;
 
-	afr_set_lk_owner (frame, this, frame->root);
+    afr_set_lk_owner(frame, this, frame->root);
 
-	return frame;
+    return frame;
 }
 
 int
-afr_selfheal_newentry_mark (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			    int source, struct afr_reply *replies,
-			    unsigned char *sources, unsigned char *newentry)
+afr_selfheal_newentry_mark(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                           int source, struct afr_reply *replies,
+                           unsigned char *sources, unsigned char *newentry)
 {
-	int ret = 0;
-	int i = 0;
-	afr_private_t *priv = NULL;
-	dict_t *xattr = NULL;
-	int **changelog = NULL;
+    int ret = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int **changelog = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	gf_uuid_copy (inode->gfid, replies[source].poststat.ia_gfid);
+    gf_uuid_copy(inode->gfid, replies[source].poststat.ia_gfid);
 
-	xattr = dict_new();
-	if (!xattr)
-		return -ENOMEM;
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
 
-        changelog = afr_mark_pending_changelog (priv, newentry, xattr,
-                                            replies[source].poststat.ia_type);
+    changelog = afr_mark_pending_changelog(priv, newentry, xattr,
+                                           replies[source].poststat.ia_type);
 
-        if (!changelog) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    if (!changelog) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!sources[i])
-			continue;
-		ret |= afr_selfheal_post_op (frame, this, inode, i, xattr,
-                                             NULL);
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        ret |= afr_selfheal_post_op(frame, this, inode, i, xattr, NULL);
+    }
 out:
-        if (changelog)
-                afr_matrix_cleanup (changelog, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
-	return ret;
+    if (changelog)
+        afr_matrix_cleanup(changelog, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
+    return ret;
 }
 
 int
-afr_selfheal_do (call_frame_t *frame, xlator_t *this, uuid_t gfid)
-{
-	int           ret               = -1;
-        int           entry_ret         = 1;
-        int           metadata_ret      = 1;
-        int           data_ret          = 1;
-        int           or_ret            = 0;
-        inode_t      *inode             = NULL;
-	gf_boolean_t  data_selfheal     = _gf_false;
-	gf_boolean_t  metadata_selfheal = _gf_false;
-	gf_boolean_t  entry_selfheal    = _gf_false;
-        afr_private_t *priv            = NULL;
-        gf_boolean_t dataheal_enabled   = _gf_false;
-
-        priv = this->private;
-
-        ret = gf_string2boolean (priv->data_self_heal, &dataheal_enabled);
-        if (ret)
-                goto out;
+afr_selfheal_do(call_frame_t *frame, xlator_t *this, uuid_t gfid)
+{
+    int ret = -1;
+    int entry_ret = 1;
+    int metadata_ret = 1;
+    int data_ret = 1;
+    int or_ret = 0;
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    gf_boolean_t data_selfheal = _gf_false;
+    gf_boolean_t metadata_selfheal = _gf_false;
+    gf_boolean_t entry_selfheal = _gf_false;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    ret = afr_selfheal_unlocked_inspect(frame, this, gfid, &inode,
+                                        &data_selfheal, &metadata_selfheal,
+                                        &entry_selfheal, NULL);
+    if (ret)
+        goto out;
 
-	ret = afr_selfheal_unlocked_inspect (frame, this, gfid, &inode,
-					     &data_selfheal,
-					     &metadata_selfheal,
-					     &entry_selfheal);
-	if (ret)
-		goto out;
+    if (!(data_selfheal || metadata_selfheal || entry_selfheal)) {
+        ret = 2;
+        goto out;
+    }
 
-        if (!(data_selfheal || metadata_selfheal || entry_selfheal)) {
-                ret = 2;
-                goto out;
+    if (inode->ia_type == IA_IFREG) {
+        ret = afr_selfheal_data_open(this, inode, &fd);
+        if (!fd) {
+            ret = -EIO;
+            goto out;
         }
+    }
 
-	if (data_selfheal && dataheal_enabled)
-                data_ret = afr_selfheal_data (frame, this, inode);
+    if (data_selfheal && priv->data_self_heal)
+        data_ret = afr_selfheal_data(frame, this, fd);
 
-	if (metadata_selfheal && priv->metadata_self_heal)
-                metadata_ret = afr_selfheal_metadata (frame, this, inode);
+    if (metadata_selfheal && priv->metadata_self_heal)
+        metadata_ret = afr_selfheal_metadata(frame, this, inode);
 
-	if (entry_selfheal && priv->entry_self_heal)
-                entry_ret = afr_selfheal_entry (frame, this, inode);
+    if (entry_selfheal && priv->entry_self_heal)
+        entry_ret = afr_selfheal_entry(frame, this, inode);
 
-        or_ret = (data_ret | metadata_ret | entry_ret);
+    or_ret = (data_ret | metadata_ret | entry_ret);
 
-        if (data_ret == -EIO || metadata_ret == -EIO || entry_ret == -EIO)
-                ret = -EIO;
-        else if (data_ret == 1 && metadata_ret == 1 && entry_ret == 1)
-                ret = 1;
-        else if (or_ret < 0)
-                ret = or_ret;
-        else
-                ret = 0;
+    if (data_ret == -EIO || metadata_ret == -EIO || entry_ret == -EIO)
+        ret = -EIO;
+    else if (data_ret == 1 && metadata_ret == 1 && entry_ret == 1)
+        ret = 1;
+    else if (or_ret < 0)
+        ret = or_ret;
+    else
+        ret = 0;
 
 out:
-        if (inode)
-                inode_unref (inode);
-        return ret;
+    if (inode)
+        inode_unref(inode);
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 /*
  * This is the entry point for healing a given GFID. The return values for this
@@ -2484,161 +2593,342 @@ out:
  */
 
 int
-afr_selfheal (xlator_t *this, uuid_t gfid)
+afr_selfheal(xlator_t *this, uuid_t gfid)
 {
-        int           ret   = -1;
-	call_frame_t *frame = NULL;
-        afr_local_t *local = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
 
-	frame = afr_frame_create (this);
-	if (!frame)
-		return ret;
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        return ret;
 
-        local = frame->local;
-        local->xdata_req = dict_new();
+    local = frame->local;
+    local->xdata_req = dict_new();
 
-        ret = afr_selfheal_do (frame, this, gfid);
+    ret = afr_selfheal_do(frame, this, gfid);
 
-	if (frame)
-		AFR_STACK_DESTROY (frame);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 
-	return ret;
+    return ret;
 }
 
-afr_local_t*
-__afr_dequeue_heals (afr_private_t *priv)
+afr_local_t *
+__afr_dequeue_heals(afr_private_t *priv)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        if (list_empty (&priv->heal_waiting))
-                goto none;
-        if ((priv->background_self_heal_count > 0) &&
-            (priv->healers >= priv->background_self_heal_count))
-                goto none;
+    if (list_empty(&priv->heal_waiting))
+        goto none;
+    if ((priv->background_self_heal_count > 0) &&
+        (priv->healers >= priv->background_self_heal_count))
+        goto none;
 
-        local = list_entry (priv->heal_waiting.next, afr_local_t, healer);
-        priv->heal_waiters--;
-        GF_ASSERT (priv->heal_waiters >= 0);
-        list_del_init(&local->healer);
-        list_add(&local->healer, &priv->healing);
-        priv->healers++;
-        return local;
+    local = list_entry(priv->heal_waiting.next, afr_local_t, healer);
+    priv->heal_waiters--;
+    GF_ASSERT(priv->heal_waiters >= 0);
+    list_del_init(&local->healer);
+    list_add(&local->healer, &priv->healing);
+    priv->healers++;
+    return local;
 none:
-        gf_msg_debug (THIS->name, 0, "Nothing dequeued. "
-                      "Num healers: %d, Num Waiters: %d",
-                      priv->healers, priv->heal_waiters);
-        return NULL;
+    gf_msg_debug(THIS->name, 0,
+                 "Nothing dequeued. "
+                 "Num healers: %d, Num Waiters: %d",
+                 priv->healers, priv->heal_waiters);
+    return NULL;
 }
 
 int
-afr_refresh_selfheal_wrap (void *opaque)
+afr_refresh_selfheal_wrap(void *opaque)
 {
-        call_frame_t *heal_frame = opaque;
-        afr_local_t *local = heal_frame->local;
-        int ret = 0;
+    call_frame_t *heal_frame = opaque;
+    afr_local_t *local = heal_frame->local;
+    int ret = 0;
 
-        ret = afr_selfheal (heal_frame->this, local->refreshinode->gfid);
-        return ret;
+    ret = afr_selfheal(heal_frame->this, local->refreshinode->gfid);
+    return ret;
 }
 
 int
-afr_refresh_heal_done (int ret, call_frame_t *frame, void *opaque)
-{
-        call_frame_t *heal_frame = opaque;
-        xlator_t *this = heal_frame->this;
-        afr_private_t *priv = this->private;
-        afr_local_t *local = heal_frame->local;
-
-        LOCK (&priv->lock);
-        {
-                list_del_init(&local->healer);
-                priv->healers--;
-                GF_ASSERT (priv->healers >= 0);
-                local = __afr_dequeue_heals (priv);
-        }
-        UNLOCK (&priv->lock);
+afr_refresh_heal_done(int ret, call_frame_t *frame, void *opaque)
+{
+    call_frame_t *heal_frame = opaque;
+    xlator_t *this = heal_frame->this;
+    afr_private_t *priv = this->private;
+    afr_local_t *local = heal_frame->local;
 
-        if (heal_frame)
-                AFR_STACK_DESTROY (heal_frame);
+    LOCK(&priv->lock);
+    {
+        list_del_init(&local->healer);
+        priv->healers--;
+        GF_ASSERT(priv->healers >= 0);
+        local = __afr_dequeue_heals(priv);
+    }
+    UNLOCK(&priv->lock);
 
-        if (local)
-                afr_heal_synctask (this, local);
-        return 0;
+    AFR_STACK_DESTROY(heal_frame);
 
+    if (local)
+        afr_heal_synctask(this, local);
+    return 0;
 }
 
 void
-afr_heal_synctask (xlator_t *this, afr_local_t *local)
+afr_heal_synctask(xlator_t *this, afr_local_t *local)
 {
-        int ret = 0;
-        call_frame_t *heal_frame = NULL;
+    int ret = 0;
+    call_frame_t *heal_frame = NULL;
 
-        heal_frame = local->heal_frame;
-        ret = synctask_new (this->ctx->env, afr_refresh_selfheal_wrap,
-                            afr_refresh_heal_done, heal_frame, heal_frame);
-        if (ret < 0)
-                /* Heal not launched. Will be queued when the next inode
-                 * refresh happens and shd hasn't healed it yet. */
-                afr_refresh_heal_done (ret, heal_frame, heal_frame);
+    heal_frame = local->heal_frame;
+    ret = synctask_new(this->ctx->env, afr_refresh_selfheal_wrap,
+                       afr_refresh_heal_done, heal_frame, heal_frame);
+    if (ret < 0)
+        /* Heal not launched. Will be queued when the next inode
+         * refresh happens and shd hasn't healed it yet. */
+        afr_refresh_heal_done(ret, heal_frame, heal_frame);
 }
 
 gf_boolean_t
-afr_throttled_selfheal (call_frame_t *frame, xlator_t *this)
-{
-        gf_boolean_t can_heal = _gf_true;
-        afr_private_t *priv = this->private;
-        afr_local_t *local = frame->local;
-
-        LOCK (&priv->lock);
-        {
-                if ((priv->background_self_heal_count > 0) &&
-                    (priv->heal_wait_qlen + priv->background_self_heal_count) >
-                    (priv->heal_waiters + priv->healers)) {
-                        list_add_tail(&local->healer, &priv->heal_waiting);
-                        priv->heal_waiters++;
-                        local = __afr_dequeue_heals (priv);
-                } else {
-                        can_heal = _gf_false;
-                }
-        }
-        UNLOCK (&priv->lock);
-
-        if (can_heal) {
-                if (local)
-                        afr_heal_synctask (this, local);
-                else
-                        gf_msg_debug (this->name, 0, "Max number of heals are "
-                                      "pending, background self-heal rejected.");
+afr_throttled_selfheal(call_frame_t *frame, xlator_t *this)
+{
+    gf_boolean_t can_heal = _gf_true;
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
+
+    LOCK(&priv->lock);
+    {
+        if ((priv->background_self_heal_count > 0) &&
+            (priv->heal_wait_qlen + priv->background_self_heal_count) >
+                (priv->heal_waiters + priv->healers)) {
+            list_add_tail(&local->healer, &priv->heal_waiting);
+            priv->heal_waiters++;
+            local = __afr_dequeue_heals(priv);
+        } else {
+            can_heal = _gf_false;
         }
+    }
+    UNLOCK(&priv->lock);
 
-        return can_heal;
+    if (can_heal) {
+        if (local)
+            afr_heal_synctask(this, local);
+        else
+            gf_msg_debug(this->name, 0,
+                         "Max number of heals are "
+                         "pending, background self-heal rejected.");
+    }
+
+    return can_heal;
 }
 
 int
-afr_choose_source_by_policy (afr_private_t *priv, unsigned char *sources,
-                             afr_transaction_type type)
+afr_choose_source_by_policy(afr_private_t *priv, unsigned char *sources,
+                            afr_transaction_type type)
 {
-        int source = -1;
-        int i      = 0;
+    int source = -1;
+    int i = 0;
 
-        /* Give preference to local child to save on bandwidth */
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->local[i] && sources[i]) {
-                        if ((type == AFR_DATA_TRANSACTION) &&
-                            AFR_IS_ARBITER_BRICK (priv, i))
-                                continue;
+    /* Give preference to local child to save on bandwidth */
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->local[i] && sources[i]) {
+            if ((type == AFR_DATA_TRANSACTION) && AFR_IS_ARBITER_BRICK(priv, i))
+                continue;
 
-                        source = i;
-                        goto out;
-                }
+            source = i;
+            goto out;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i]) {
-                        source = i;
-                        goto out;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            goto out;
         }
+    }
 out:
-        return source;
+    return source;
+}
+
+static int
+afr_anon_inode_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, inode_t *inode,
+                         struct iatt *buf, struct iatt *preparent,
+                         struct iatt *postparent, dict_t *xdata)
+{
+    afr_local_t *local = frame->local;
+    int i = (long)cookie;
+
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->replies[i].poststat = *buf;
+        local->replies[i].preparent = *preparent;
+        local->replies[i].postparent = *postparent;
+    }
+    if (xdata) {
+        local->replies[i].xdata = dict_ref(xdata);
+    }
+
+    syncbarrier_wake(&local->barrier);
+    return 0;
+}
+
+int
+afr_anon_inode_create(xlator_t *this, int child, inode_t **linked_inode)
+{
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = this->private;
+    unsigned char *mkdir_on = alloca0(priv->child_count);
+    unsigned char *lookup_on = alloca0(priv->child_count);
+    loc_t loc = {0};
+    int32_t op_errno = 0;
+    int32_t child_op_errno = 0;
+    struct iatt iatt = {0};
+    dict_t *xdata = NULL;
+    uuid_t anon_inode_gfid = {0};
+    int mkdir_count = 0;
+    int i = 0;
+
+    /*Try to mkdir everywhere and return success if the dir exists on 'child'
+     */
+
+    if (!priv->use_anon_inode) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    frame = afr_frame_create(this, &op_errno);
+    if (op_errno) {
+        goto out;
+    }
+    local = frame->local;
+    if (!local->child_up[child]) {
+        /*Other bricks may need mkdir so don't error out yet*/
+        child_op_errno = ENOTCONN;
+    }
+    gf_uuid_parse(priv->anon_gfid_str, anon_inode_gfid);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
+
+        if (priv->anon_inode[i]) {
+            mkdir_on[i] = 0;
+        } else {
+            mkdir_on[i] = 1;
+            mkdir_count++;
+        }
+    }
+
+    if (mkdir_count == 0) {
+        *linked_inode = inode_find(this->itable, anon_inode_gfid);
+        if (*linked_inode) {
+            op_errno = 0;
+            goto out;
+        }
+    }
+
+    loc.parent = inode_ref(this->itable->root);
+    loc.name = priv->anon_inode_name;
+    loc.inode = inode_new(this->itable);
+    if (!loc.inode) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    op_errno = -dict_set_gfuuid(xdata, "gfid-req", anon_inode_gfid, _gf_true);
+    if (op_errno) {
+        goto out;
+    }
+
+    if (mkdir_count == 0) {
+        memcpy(lookup_on, local->child_up, priv->child_count);
+        goto lookup;
+    }
+
+    AFR_ONLIST(mkdir_on, frame, afr_anon_inode_mkdir_cbk, mkdir, &loc, 0755, 0,
+               xdata);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!mkdir_on[i]) {
+            continue;
+        }
+
+        if (local->replies[i].op_ret == 0) {
+            priv->anon_inode[i] = 1;
+            iatt = local->replies[i].poststat;
+        } else if (local->replies[i].op_ret < 0 &&
+                   local->replies[i].op_errno == EEXIST) {
+            lookup_on[i] = 1;
+        } else if (i == child) {
+            child_op_errno = local->replies[i].op_errno;
+        }
+    }
+
+    if (AFR_COUNT(lookup_on, priv->child_count) == 0) {
+        goto link;
+    }
+
+lookup:
+    AFR_ONLIST(lookup_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               xdata);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!lookup_on[i]) {
+            continue;
+        }
+
+        if (local->replies[i].op_ret == 0) {
+            if (gf_uuid_compare(anon_inode_gfid,
+                                local->replies[i].poststat.ia_gfid) == 0) {
+                priv->anon_inode[i] = 1;
+                iatt = local->replies[i].poststat;
+            } else {
+                if (i == child)
+                    child_op_errno = EINVAL;
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_DATA,
+                       "%s has gfid: %s", priv->anon_inode_name,
+                       uuid_utoa(local->replies[i].poststat.ia_gfid));
+            }
+        } else if (i == child) {
+            child_op_errno = local->replies[i].op_errno;
+        }
+    }
+link:
+    if (!gf_uuid_is_null(iatt.ia_gfid)) {
+        *linked_inode = inode_link(loc.inode, loc.parent, loc.name, &iatt);
+        if (*linked_inode) {
+            op_errno = 0;
+            inode_lookup(*linked_inode);
+        } else {
+            op_errno = ENOMEM;
+        }
+        goto out;
+    }
+
+out:
+    if (xdata)
+        dict_unref(xdata);
+    loc_wipe(&loc);
+    /*child_op_errno takes precedence*/
+    if (child_op_errno == 0) {
+        child_op_errno = op_errno;
+    }
+
+    if (child_op_errno && *linked_inode) {
+        inode_unref(*linked_inode);
+        *linked_inode = NULL;
+    }
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return -child_op_errno;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-data.c b/xlators/cluster/afr/src/afr-self-heal-data.c
index 2c254e80aa1..37bcc2b3f9e 100644
--- a/xlators/cluster/afr/src/afr-self-heal-data.c
+++ b/xlators/cluster/afr/src/afr-self-heal-data.c
@@ -8,592 +8,592 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "protocol-common.h"
 #include "afr-messages.h"
-#include "events.h"
-
-enum {
-	AFR_SELFHEAL_DATA_FULL = 0,
-	AFR_SELFHEAL_DATA_DIFF,
-};
-
+#include <glusterfs/events.h>
 
 #define HAS_HOLES(i) ((i->ia_blocks * 512) < (i->ia_size))
 static int
-__checksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, uint32_t weak, uint8_t *strong,
-		dict_t *xdata)
+__checksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, uint32_t weak, uint8_t *strong, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-        struct afr_reply *replies = NULL;
-	int i = (long) cookie;
-
-	local = frame->local;
-        replies = local->replies;
-
-	replies[i].valid = 1;
-	replies[i].op_ret = op_ret;
-	replies[i].op_errno = op_errno;
-        if (xdata)
-                replies[i].buf_has_zeroes = dict_get_str_boolean (xdata,
-                                                   "buf-has-zeroes", _gf_false);
-	if (strong)
-		memcpy (local->replies[i].checksum, strong, MD5_DIGEST_LENGTH);
-
-	syncbarrier_wake (&local->barrier);
-	return 0;
+    afr_local_t *local = NULL;
+    struct afr_reply *replies = NULL;
+    int i = (long)cookie;
+
+    local = frame->local;
+    replies = local->replies;
+
+    replies[i].valid = 1;
+    replies[i].op_ret = op_ret;
+    replies[i].op_errno = op_errno;
+    if (xdata) {
+        replies[i].buf_has_zeroes = dict_get_str_boolean(
+            xdata, "buf-has-zeroes", _gf_false);
+        replies[i].fips_mode_rchecksum = dict_get_str_boolean(
+            xdata, "fips-mode-rchecksum", _gf_false);
+    }
+    if (strong) {
+        if (replies[i].fips_mode_rchecksum) {
+            memcpy(local->replies[i].checksum, strong, SHA256_DIGEST_LENGTH);
+        } else {
+            memcpy(local->replies[i].checksum, strong, MD5_DIGEST_LENGTH);
+        }
+    }
+
+    syncbarrier_wake(&local->barrier);
+    return 0;
 }
 
 static gf_boolean_t
-__afr_can_skip_data_block_heal (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                                int source, unsigned char *healed_sinks,
-				off_t offset, size_t size,
-                                struct iatt *poststat)
+__afr_can_skip_data_block_heal(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               int source, unsigned char *healed_sinks,
+                               off_t offset, size_t size, struct iatt *poststat)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	unsigned char *wind_subvols = NULL;
-        gf_boolean_t checksum_match = _gf_true;
-        dict_t *xdata = NULL;
-	int i = 0;
-
-	priv = this->private;
-	local = frame->local;
-
-        xdata = dict_new();
-        if (!xdata)
-                goto out;
-        if (dict_set_int32 (xdata, "check-zero-filled", 1)) {
-                dict_unref (xdata);
-                goto out;
-        }
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    unsigned char *wind_subvols = NULL;
+    gf_boolean_t checksum_match = _gf_true;
+    struct afr_reply *replies = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
+
+    priv = this->private;
+    local = frame->local;
+    replies = local->replies;
+
+    xdata = dict_new();
+    if (!xdata)
+        goto out;
+    if (dict_set_int32_sizen(xdata, "check-zero-filled", 1)) {
+        dict_unref(xdata);
+        goto out;
+    }
+
+    wind_subvols = alloca0(priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || healed_sinks[i])
+            wind_subvols[i] = 1;
+    }
+
+    AFR_ONLIST(wind_subvols, frame, __checksum_cbk, rchecksum, fd, offset, size,
+               xdata);
+    if (xdata)
+        dict_unref(xdata);
+
+    if (!replies[source].valid || replies[source].op_ret != 0)
+        return _gf_false;
 
-	wind_subvols = alloca0 (priv->child_count);
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source || healed_sinks[i])
-			wind_subvols[i] = 1;
-	}
-
-	AFR_ONLIST (wind_subvols, frame, __checksum_cbk, rchecksum, fd,
-		    offset, size, xdata);
-        if (xdata)
-                dict_unref (xdata);
-
-	if (!local->replies[source].valid || local->replies[source].op_ret != 0)
-		return _gf_false;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source)
-			continue;
-                if (local->replies[i].valid) {
-                        if (memcmp (local->replies[source].checksum,
-                                    local->replies[i].checksum,
-                                    MD5_DIGEST_LENGTH)) {
-                                checksum_match = _gf_false;
-                                break;
-                        }
-                }
-	}
-
-        if (checksum_match) {
-                if (HAS_HOLES (poststat))
-                        return _gf_true;
-
-                /* For non-sparse files, we might be better off writing the
-                 * zeroes to sinks to avoid mismatch of disk-usage in bricks. */
-                if (local->replies[source].buf_has_zeroes)
-                        return _gf_false;
-                else
-                        return _gf_true;
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source)
+            continue;
+        if (replies[i].valid) {
+            if (memcmp(replies[source].checksum, replies[i].checksum,
+                       replies[source].fips_mode_rchecksum
+                           ? SHA256_DIGEST_LENGTH
+                           : MD5_DIGEST_LENGTH)) {
+                checksum_match = _gf_false;
+                break;
+            }
         }
+    }
+
+    if (checksum_match) {
+        if (HAS_HOLES(poststat))
+            return _gf_true;
+
+        /* For non-sparse files, we might be better off writing the
+         * zeroes to sinks to avoid mismatch of disk-usage in bricks. */
+        if (local->replies[source].buf_has_zeroes)
+            return _gf_false;
+        else
+            return _gf_true;
+    }
 out:
-        return _gf_false;
+    return _gf_false;
 }
 
-
 static gf_boolean_t
-__afr_is_sink_zero_filled (xlator_t *this, fd_t *fd, size_t size,
-                           off_t offset, int sink)
+__afr_is_sink_zero_filled(xlator_t *this, fd_t *fd, size_t size, off_t offset,
+                          int sink)
 {
-        afr_private_t *priv   = NULL;
-        struct iobref *iobref = NULL;
-        struct iovec  *iovec  = NULL;
-        int            count  = 0;
-        int            ret    = 0;
-        gf_boolean_t   zero_filled   = _gf_false;
-
-        priv = this->private;
-        ret = syncop_readv (priv->children[sink], fd, size, offset, 0, &iovec,
-                            &count, &iobref, NULL, NULL);
-        if (ret < 0)
-                goto out;
-        ret = iov_0filled (iovec, count);
-        if (!ret)
-                zero_filled = _gf_true;
+    afr_private_t *priv = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec *iovec = NULL;
+    int count = 0;
+    int ret = 0;
+    gf_boolean_t zero_filled = _gf_false;
+
+    priv = this->private;
+    ret = syncop_readv(priv->children[sink], fd, size, offset, 0, &iovec,
+                       &count, &iobref, NULL, NULL, NULL);
+    if (ret < 0)
+        goto out;
+    ret = iov_0filled(iovec, count);
+    if (!ret)
+        zero_filled = _gf_true;
 out:
-        if (iovec)
-                GF_FREE (iovec);
-        if (iobref)
-                iobref_unref (iobref);
-        return zero_filled;
+    if (iovec)
+        GF_FREE(iovec);
+    if (iobref)
+        iobref_unref(iobref);
+    return zero_filled;
 }
 
 static int
-__afr_selfheal_data_read_write (call_frame_t *frame, xlator_t *this, fd_t *fd,
-				int source, unsigned char *healed_sinks,
-				off_t offset, size_t size,
-				struct afr_reply *replies, int type)
+__afr_selfheal_data_read_write(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               int source, unsigned char *healed_sinks,
+                               off_t offset, size_t size,
+                               struct afr_reply *replies, int type)
 {
-	struct iovec *iovec = NULL;
-	int count = 0;
-	struct iobref *iobref = NULL;
-	int ret = 0;
-	int i = 0;
-	afr_private_t *priv = NULL;
-
-	priv = this->private;
-
-	ret = syncop_readv (priv->children[source], fd, size, offset, 0,
-			    &iovec, &count, &iobref, NULL, NULL);
-	if (ret <= 0)
-		return ret;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!healed_sinks[i])
-			continue;
-
-		/*
-		 * TODO: Use fiemap() and discard() to heal holes
-		 * in the future.
-		 *
-		 * For now,
-		 *
-		 * - if the source had any holes at all,
-		 * AND
-		 * - if we are writing past the original file size
-		 *   of the sink
-		 * AND
-		 * - is NOT the last block of the source file. if
-		 *   the block contains EOF, it has to be written
-		 *   in order to set the file size even if the
-		 *   last block is 0-filled.
-		 * AND
-		 * - if the read buffer is filled with only 0's
-		 *
-		 * then, skip writing to this source. We don't depend
-		 * on the write to happen to update the size as we
-		 * have performed an ftruncate() upfront anyways.
-		 */
-#define is_last_block(o,b,s) ((s >= o) && (s <= (o + b)))
-		if (HAS_HOLES ((&replies[source].poststat)) &&
-		    offset >= replies[i].poststat.ia_size &&
-		    !is_last_block (offset, size,
-				    replies[source].poststat.ia_size) &&
-		    (iov_0filled (iovec, count) == 0))
-			continue;
-
-                /* Avoid filling up sparse regions of the sink with 0-filled
-                 * writes.*/
-                if (type == AFR_SELFHEAL_DATA_FULL &&
-                    HAS_HOLES ((&replies[source].poststat)) &&
-                    ((offset + size) <= replies[i].poststat.ia_size) &&
-                    (iov_0filled (iovec, count) == 0) &&
-                    __afr_is_sink_zero_filled (this, fd, size, offset, i)) {
-                                continue;
-                }
-
-		ret = syncop_writev (priv->children[i], fd, iovec, count,
-				     offset, iobref, 0, NULL, NULL);
-		if (ret != iov_length (iovec, count)) {
-			/* write() failed on this sink. unset the corresponding
-			   member in sinks[] (which is healed_sinks[] in the
-			   caller) so that this server does NOT get considered
-			   as successfully healed.
-			*/
-			healed_sinks[i] = 0;
-		}
-	}
-        if (iovec)
-                GF_FREE (iovec);
-	if (iobref)
-		iobref_unref (iobref);
-
-	return ret;
+    struct iovec *iovec = NULL;
+    int count = 0;
+    struct iobref *iobref = NULL;
+    int ret = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    ret = syncop_readv(priv->children[source], fd, size, offset, 0, &iovec,
+                       &count, &iobref, NULL, NULL, NULL);
+    if (ret <= 0)
+        return ret;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
+
+            /*
+             * TODO: Use fiemap() and discard() to heal holes
+             * in the future.
+             *
+             * For now,
+             *
+             * - if the source had any holes at all,
+             * AND
+             * - if we are writing past the original file size
+             *   of the sink
+             * AND
+             * - is NOT the last block of the source file. if
+             *   the block contains EOF, it has to be written
+             *   in order to set the file size even if the
+             *   last block is 0-filled.
+             * AND
+             * - if the read buffer is filled with only 0's
+             *
+             * then, skip writing to this source. We don't depend
+             * on the write to happen to update the size as we
+             * have performed an ftruncate() upfront anyways.
+             */
+#define is_last_block(o, b, s) ((s >= o) && (s <= (o + b)))
+        if (HAS_HOLES((&replies[source].poststat)) &&
+            offset >= replies[i].poststat.ia_size &&
+            !is_last_block(offset, size, replies[source].poststat.ia_size) &&
+            (iov_0filled(iovec, count) == 0))
+            continue;
+
+        /* Avoid filling up sparse regions of the sink with 0-filled
+         * writes.*/
+        if (type == AFR_SELFHEAL_DATA_FULL &&
+            HAS_HOLES((&replies[source].poststat)) &&
+            ((offset + size) <= replies[i].poststat.ia_size) &&
+            (iov_0filled(iovec, count) == 0) &&
+            __afr_is_sink_zero_filled(this, fd, size, offset, i)) {
+            continue;
+        }
+
+        ret = syncop_writev(priv->children[i], fd, iovec, count, offset, iobref,
+                            0, NULL, NULL, NULL, NULL);
+        if (ret != iov_length(iovec, count)) {
+            /* write() failed on this sink. unset the corresponding
+               member in sinks[] (which is healed_sinks[] in the
+               caller) so that this server does NOT get considered
+               as successfully healed.
+            */
+            healed_sinks[i] = 0;
+        }
+    }
+    if (iovec)
+        GF_FREE(iovec);
+    if (iobref)
+        iobref_unref(iobref);
+
+    return ret;
 }
 
-static int
-afr_selfheal_data_block (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			 int source, unsigned char *healed_sinks, off_t offset,
-			 size_t size, int type, struct afr_reply *replies)
+static gf_boolean_t
+afr_source_sinks_locked(xlator_t *this, unsigned char *locked_on, int source,
+                        unsigned char *healed_sinks)
 {
-	int ret = -1;
-	int sink_count = 0;
-	afr_private_t *priv = NULL;
-	unsigned char *data_lock = NULL;
-
-	priv = this->private;
-	sink_count = AFR_COUNT (healed_sinks, priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name,
-				    offset, size, data_lock);
-	{
-		if (ret < sink_count) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		if (type == AFR_SELFHEAL_DATA_DIFF &&
-		    __afr_can_skip_data_block_heal (frame, this, fd, source,
-					            healed_sinks, offset, size,
-                                                   &replies[source].poststat)) {
-			ret = 0;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data_read_write (frame, this, fd, source,
-						      healed_sinks, offset, size,
-						      replies, type);
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name,
-				offset, size, data_lock);
-	return ret;
-}
+    afr_private_t *priv = this->private;
+    int i = 0;
 
+    if (!locked_on[source])
+        return _gf_false;
 
+    for (i = 0; i < priv->child_count; i++) {
+        if (healed_sinks[i] && locked_on[i])
+            return _gf_true;
+    }
 
-static int
-afr_selfheal_data_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			 unsigned char *healed_sinks)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-        if (!priv->ensure_durability)
-                return 0;
-
-	AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, fsync, fd, 0,
-                    NULL);
-
-	for (i = 0; i < priv->child_count; i++)
-		if (healed_sinks[i] && local->replies[i].op_ret != 0)
-			/* fsync() failed. Do NOT consider this server
-			   as successfully healed. Mark it so.
-			*/
-			healed_sinks[i] = 0;
-	return 0;
+    return _gf_false;
 }
 
 static int
-afr_data_self_heal_type_get (afr_private_t *priv, unsigned char *healed_sinks,
-                             int source, struct afr_reply *replies)
+afr_selfheal_data_block(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        int source, unsigned char *healed_sinks, off_t offset,
+                        size_t size, int type, struct afr_reply *replies)
 {
-        int type = AFR_SELFHEAL_DATA_FULL;
-        int i = 0;
-
-        if (priv->data_self_heal_algorithm == NULL) {
-                type = AFR_SELFHEAL_DATA_FULL;
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!healed_sinks[i] && i != source)
-                                continue;
-                        if (replies[i].poststat.ia_size) {
-                                type = AFR_SELFHEAL_DATA_DIFF;
-                                break;
-                        }
-                }
-        } else if (strcmp (priv->data_self_heal_algorithm, "full") == 0) {
-                type = AFR_SELFHEAL_DATA_FULL;
-        } else if (strcmp (priv->data_self_heal_algorithm, "diff") == 0) {
-                type = AFR_SELFHEAL_DATA_DIFF;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    unsigned char *data_lock = NULL;
+
+    priv = this->private;
+    data_lock = alloca0(priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, offset, size,
+                               data_lock);
+    {
+        if (!afr_source_sinks_locked(this, data_lock, source, healed_sinks)) {
+            ret = -ENOTCONN;
+            goto unlock;
         }
-        return type;
-}
 
-static int
-afr_selfheal_data_do (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		      int source, unsigned char *healed_sinks,
-		      struct afr_reply *replies)
-{
-	afr_private_t *priv = NULL;
-	off_t off = 0;
-	size_t block = 0;
-	int type = AFR_SELFHEAL_DATA_FULL;
-	int ret = -1;
-	call_frame_t *iter_frame = NULL;
-        unsigned char arbiter_sink_status = 0;
-
-	priv = this->private;
-        if (priv->arbiter_count) {
-                arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
-                healed_sinks[ARBITER_BRICK_INDEX] = 0;
+        if (type == AFR_SELFHEAL_DATA_DIFF &&
+            __afr_can_skip_data_block_heal(frame, this, fd, source,
+                                           healed_sinks, offset, size,
+                                           &replies[source].poststat)) {
+            ret = 0;
+            goto unlock;
         }
 
-        block = 128 * 1024 * priv->data_self_heal_window_size;
-
-        type = afr_data_self_heal_type_get (priv, healed_sinks, source,
-                                            replies);
+        ret = __afr_selfheal_data_read_write(
+            frame, this, fd, source, healed_sinks, offset, size, replies, type);
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, offset, size,
+                           data_lock);
+    return ret;
+}
 
-	iter_frame = afr_copy_frame (frame);
-	if (!iter_frame) {
-                ret = -ENOMEM;
-                goto out;
-        }
+static int
+afr_selfheal_data_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        unsigned char *healed_sinks)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-	for (off = 0; off < replies[source].poststat.ia_size; off += block) {
-                if (AFR_COUNT (healed_sinks, priv->child_count) == 0) {
-                        ret = -ENOTCONN;
-                        goto out;
-                }
+    local = frame->local;
+    priv = this->private;
 
-		ret = afr_selfheal_data_block (iter_frame, this, fd, source,
-					       healed_sinks, off, block, type,
-					       replies);
-		if (ret < 0)
-			goto out;
+    if (!priv->ensure_durability)
+        return 0;
 
-		AFR_STACK_RESET (iter_frame);
-		if (iter_frame->local == NULL) {
-		        ret = -ENOTCONN;
-		        goto out;
-                }
-	}
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, fsync, fd, 0, NULL);
 
-	ret = afr_selfheal_data_fsync (frame, this, fd, healed_sinks);
+    for (i = 0; i < priv->child_count; i++)
+        if (healed_sinks[i] && local->replies[i].op_ret != 0)
+            /* fsync() failed. Do NOT consider this server
+               as successfully healed. Mark it so.
+            */
+            healed_sinks[i] = 0;
+    return 0;
+}
 
-out:
-        if (arbiter_sink_status)
-                healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
+static int
+afr_data_self_heal_type_get(afr_private_t *priv, unsigned char *healed_sinks,
+                            int source, struct afr_reply *replies)
+{
+    int type = AFR_SELFHEAL_DATA_FULL;
+    int i = 0;
 
-	if (iter_frame)
-		AFR_STACK_DESTROY (iter_frame);
-	return ret;
+    if (priv->data_self_heal_algorithm == AFR_SELFHEAL_DATA_DYNAMIC) {
+        type = AFR_SELFHEAL_DATA_FULL;
+        for (i = 0; i < priv->child_count; i++) {
+            if (!healed_sinks[i] && i != source)
+                continue;
+            if (replies[i].poststat.ia_size) {
+                type = AFR_SELFHEAL_DATA_DIFF;
+                break;
+            }
+        }
+    } else {
+        type = priv->data_self_heal_algorithm;
+    }
+    return type;
 }
 
-
 static int
-__afr_selfheal_truncate_sinks (call_frame_t *frame, xlator_t *this,
-			       fd_t *fd, unsigned char *healed_sinks,
-			       uint64_t size)
+afr_selfheal_data_do(call_frame_t *frame, xlator_t *this, fd_t *fd, int source,
+                     unsigned char *healed_sinks, struct afr_reply *replies)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        unsigned char arbiter_sink_status = 0;
-	int i = 0;
+    afr_private_t *priv = NULL;
+    off_t off = 0;
+    size_t block = 0;
+    int type = AFR_SELFHEAL_DATA_FULL;
+    int ret = -1;
+    call_frame_t *iter_frame = NULL;
+    unsigned char arbiter_sink_status = 0;
+
+    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+           "performing data selfheal on %s", uuid_utoa(fd->inode->gfid));
+
+    priv = this->private;
+    if (priv->arbiter_count) {
+        arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
+        healed_sinks[ARBITER_BRICK_INDEX] = 0;
+    }
+
+    block = 128 * 1024 * priv->data_self_heal_window_size;
+
+    type = afr_data_self_heal_type_get(priv, healed_sinks, source, replies);
+
+    iter_frame = afr_copy_frame(frame);
+    if (!iter_frame) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    for (off = 0; off < replies[source].poststat.ia_size; off += block) {
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            ret = -ENOTCONN;
+            goto out;
+        }
 
-	local = frame->local;
-	priv = this->private;
+        ret = afr_selfheal_data_block(iter_frame, this, fd, source,
+                                      healed_sinks, off, block, type, replies);
+        if (ret < 0)
+            goto out;
 
-        if (priv->arbiter_count) {
-                arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
-                healed_sinks[ARBITER_BRICK_INDEX] = 0;
+        AFR_STACK_RESET(iter_frame);
+        if (iter_frame->local == NULL) {
+            ret = -ENOTCONN;
+            goto out;
         }
+    }
+
+    ret = afr_selfheal_data_fsync(frame, this, fd, healed_sinks);
 
-	AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, ftruncate, fd,
-                    size, NULL);
+out:
+    if (arbiter_sink_status)
+        healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
 
-	for (i = 0; i < priv->child_count; i++)
-		if (healed_sinks[i] && local->replies[i].op_ret == -1)
-			/* truncate() failed. Do NOT consider this server
-			   as successfully healed. Mark it so.
-			*/
-			healed_sinks[i] = 0;
+    if (iter_frame)
+        AFR_STACK_DESTROY(iter_frame);
+    return ret;
+}
 
-        if (arbiter_sink_status)
-                healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
-	return 0;
+static int
+__afr_selfheal_truncate_sinks(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                              unsigned char *healed_sinks, uint64_t size)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    /* This will send truncate on the arbiter brick as well if it is marked as
+     * sink. If changelog is enabled on the volume it captures truncate as a
+     * data transactions on the arbiter brick. This will help geo-rep to
+     * properly sync the data from master to slave if arbiter is the ACTIVE
+     * brick during syncing and which had got some entries healed for data as
+     * part of self heal.
+     */
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, ftruncate, fd, size,
+               NULL);
+
+    for (i = 0; i < priv->child_count; i++)
+        if (healed_sinks[i] && local->replies[i].op_ret == -1)
+            /* truncate() failed. Do NOT consider this server
+               as successfully healed. Mark it so.
+            */
+            healed_sinks[i] = 0;
+
+    return 0;
 }
 
 gf_boolean_t
-afr_has_source_witnesses (xlator_t *this, unsigned char *sources,
-                          uint64_t *witness)
+afr_has_source_witnesses(xlator_t *this, unsigned char *sources,
+                         uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i] && witness[i])
-                        return _gf_true;
-        }
-        return _gf_false;
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i] && witness[i])
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_does_size_mismatch (xlator_t *this, unsigned char *sources,
-                        struct afr_reply *replies)
+afr_does_size_mismatch(xlator_t *this, unsigned char *sources,
+                       struct afr_reply *replies)
 {
-        int     i = 0;
-        afr_private_t *priv = NULL;
-        struct iatt *min = NULL;
-        struct iatt *max = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    struct iatt *min = NULL;
+    struct iatt *max = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if (replies[i].op_ret < 0)
-                        continue;
+        if (replies[i].op_ret < 0)
+            continue;
 
-                if (!sources[i])
-                        continue;
+        if (!sources[i])
+            continue;
 
-                if (AFR_IS_ARBITER_BRICK (priv, i) &&
-                    (replies[i].poststat.ia_size == 0))
-                        continue;
+        if (AFR_IS_ARBITER_BRICK(priv, i) && (replies[i].poststat.ia_size == 0))
+            continue;
 
-                if (!min)
-                        min = &replies[i].poststat;
+        if (!min)
+            min = &replies[i].poststat;
 
-                if (!max)
-                        max = &replies[i].poststat;
+        if (!max)
+            max = &replies[i].poststat;
 
-                if (min->ia_size > replies[i].poststat.ia_size)
-                        min = &replies[i].poststat;
+        if (min->ia_size > replies[i].poststat.ia_size)
+            min = &replies[i].poststat;
 
-                if (max->ia_size < replies[i].poststat.ia_size)
-                        max = &replies[i].poststat;
-        }
+        if (max->ia_size < replies[i].poststat.ia_size)
+            max = &replies[i].poststat;
+    }
 
-        if (min && max) {
-                if (min->ia_size != max->ia_size)
-                        return _gf_true;
-        }
+    if (min && max) {
+        if (min->ia_size != max->ia_size)
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static void
-afr_mark_biggest_witness_as_source (xlator_t *this, unsigned char *sources,
-                                    uint64_t *witness)
+afr_mark_biggest_witness_as_source(xlator_t *this, unsigned char *sources,
+                                   uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint64_t biggest_witness = 0;
-
-        priv = this->private;
-        /* Find source with biggest witness count */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (biggest_witness < witness[i])
-                        biggest_witness = witness[i];
-        }
-
-        /* Mark files with less witness count as not source */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (witness[i] < biggest_witness)
-                        sources[i] = 0;
-        }
-
-        return;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t biggest_witness = 0;
+
+    priv = this->private;
+    /* Find source with biggest witness count */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (biggest_witness < witness[i])
+            biggest_witness = witness[i];
+    }
+
+    /* Mark files with less witness count as not source */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (witness[i] < biggest_witness)
+            sources[i] = 0;
+    }
+
+    return;
 }
 
 /* This is a tie breaker function. Only one source be assigned here */
 static void
-afr_mark_newest_file_as_source (xlator_t *this, unsigned char *sources,
-                                struct afr_reply *replies)
+afr_mark_newest_file_as_source(xlator_t *this, unsigned char *sources,
+                               struct afr_reply *replies)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        int source = -1;
-        uint32_t max_ctime = 0;
-
-        priv = this->private;
-        /* Find source with latest ctime */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-
-                if (max_ctime <= replies[i].poststat.ia_ctime) {
-                        source = i;
-                        max_ctime = replies[i].poststat.ia_ctime;
-                }
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    uint32_t max_ctime = 0;
+
+    priv = this->private;
+    /* Find source with latest ctime */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+
+        if (max_ctime <= replies[i].poststat.ia_ctime) {
+            source = i;
+            max_ctime = replies[i].poststat.ia_ctime;
         }
+    }
 
-        /* Only mark one of the files as source to break ties */
-        memset (sources, 0, sizeof (*sources) * priv->child_count);
-        sources[source] = 1;
+    /* Only mark one of the files as source to break ties */
+    memset(sources, 0, sizeof(*sources) * priv->child_count);
+    sources[source] = 1;
 }
 
 static int
-__afr_selfheal_data_finalize_source (call_frame_t *frame, xlator_t *this,
-                                     inode_t *inode,
-                                     unsigned char *sources,
-                                     unsigned char *sinks,
-				     unsigned char *healed_sinks,
-				     unsigned char *locked_on,
-				     unsigned char *undid_pending,
-				     struct afr_reply *replies,
-                                     uint64_t *witness)
+__afr_selfheal_data_finalize_source(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    unsigned char *undid_pending, struct afr_reply *replies, uint64_t *witness)
 {
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count) {
-		/* split brain */
-                source = afr_mark_split_brain_source_sinks (frame, this, inode,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                          AFR_DATA_TRANSACTION);
-                if (source < 0) {
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=data;"
-                                 "file=%s", this->name, uuid_utoa(inode->gfid));
-                        return -EIO;
-                }
-
-                _afr_fav_child_reset_sink_xattrs (frame, this, inode, source,
-                                                 healed_sinks, undid_pending,
-                                                 AFR_DATA_TRANSACTION,
-                                                 locked_on, replies);
-                goto out;
-	}
-
-        /* No split brain at this point. If we were called from
-         * afr_heal_splitbrain_file(), abort.*/
-        if (afr_dict_contains_heal_op(frame))
-                return -EIO;
-
-        /* If there are no witnesses/size-mismatches on sources we are done*/
-        if (!afr_does_size_mismatch (this, sources, replies) &&
-            !afr_has_source_witnesses (this, sources, witness))
-                goto out;
-
-        afr_mark_largest_file_as_source (this, sources, replies);
-        afr_mark_biggest_witness_as_source (this, sources, witness);
-        afr_mark_newest_file_as_source (this, sources, replies);
-        if (priv->arbiter_count)
-                /* Choose non-arbiter brick as source for empty files. */
-                afr_mark_source_sinks_if_file_empty (this, sources, sinks,
-                                                     healed_sinks, locked_on,
-                                                     replies,
-                                                     AFR_DATA_TRANSACTION);
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count) {
+        /* split brain */
+        source = afr_mark_split_brain_source_sinks(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, AFR_DATA_TRANSACTION);
+        if (source < 0) {
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "client-pid=%d;"
+                     "subvol=%s;type=data;"
+                     "file=%s",
+                     this->ctx->cmd_args.client_pid, this->name,
+                     uuid_utoa(inode->gfid));
+            return -EIO;
+        }
+
+        _afr_fav_child_reset_sink_xattrs(
+            frame, this, inode, source, healed_sinks, undid_pending,
+            AFR_DATA_TRANSACTION, locked_on, replies);
+        goto out;
+    }
+
+    /* No split brain at this point. If we were called from
+     * afr_heal_splitbrain_file(), abort.*/
+    if (afr_dict_contains_heal_op(frame))
+        return -EIO;
+
+    /* If there are no witnesses/size-mismatches on sources we are done*/
+    if (!afr_does_size_mismatch(this, sources, replies) &&
+        !afr_has_source_witnesses(this, sources, witness))
+        goto out;
+
+    afr_mark_largest_file_as_source(this, sources, replies);
+    afr_mark_biggest_witness_as_source(this, sources, witness);
+    afr_mark_newest_file_as_source(this, sources, replies);
+    if (priv->arbiter_count)
+        /* Choose non-arbiter brick as source for empty files. */
+        afr_mark_source_sinks_if_file_empty(this, sources, sinks, healed_sinks,
+                                            locked_on, replies,
+                                            AFR_DATA_TRANSACTION);
 
 out:
-        afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_DATA_TRANSACTION);
+    afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+    source = afr_choose_source_by_policy(priv, sources, AFR_DATA_TRANSACTION);
 
-	return source;
+    return source;
 }
 
 /*
@@ -606,250 +606,286 @@ out:
  * for self-healing, or -1 if no healing is necessary/split brain.
  */
 int
-__afr_selfheal_data_prepare (call_frame_t *frame, xlator_t *this,
-                             inode_t *inode, unsigned char *locked_on,
-                             unsigned char *sources, unsigned char *sinks,
-                             unsigned char *healed_sinks,
-                             unsigned char *undid_pending,
-			     struct afr_reply *replies, gf_boolean_t *pflag)
+__afr_selfheal_data_prepare(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                            unsigned char *locked_on, unsigned char *sources,
+                            unsigned char *sinks, unsigned char *healed_sinks,
+                            unsigned char *undid_pending,
+                            struct afr_reply *replies, unsigned char *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        uint64_t *witness = NULL;
-
-	priv = this->private;
-
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-
-        if (ret)
-                return ret;
-
-        witness = alloca0(priv->child_count * sizeof (*witness));
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_DATA_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_data_finalize_source (frame, this, inode,
-                                                      sources, sinks,
-                                                      healed_sinks,
-                                                      locked_on, undid_pending,
-                                                      replies, witness);
-	if (source < 0)
-		return -EIO;
-
-	return source;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
+
+    priv = this->private;
+
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+
+    if (ret)
+        return ret;
+
+    witness = alloca0(priv->child_count * sizeof(*witness));
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_DATA_TRANSACTION, locked_on, sources,
+                                      sinks, witness, pflag);
+    if (ret)
+        return ret;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    source = __afr_selfheal_data_finalize_source(
+        frame, this, inode, sources, sinks, healed_sinks, locked_on,
+        undid_pending, replies, witness);
+    if (source < 0)
+        return -EIO;
+
+    return source;
 }
 
-
 static int
-__afr_selfheal_data (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		     unsigned char *locked_on)
+__afr_selfheal_data(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    unsigned char *locked_on)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *data_lock = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *undid_pending = NULL;
-	struct afr_reply *locked_replies = NULL;
-	int source = -1;
-        gf_boolean_t did_sh = _gf_true;
-        gf_boolean_t is_arbiter_the_only_sink = _gf_false;
-
-	priv = this->private;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name, 0, 0,
-				    data_lock);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "self-heal as only %d number "
-                                      "of subvolumes "
-                                      "could be locked",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data_prepare (frame, this, fd->inode,
-                                                   data_lock, sources, sinks,
-                                                   healed_sinks, undid_pending,
-                                                   locked_replies, NULL);
-		if (ret < 0)
-			goto unlock;
-
-                if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-		source = ret;
-
-                if (AFR_IS_ARBITER_BRICK(priv, source)) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                if (priv->arbiter_count &&
-                    AFR_COUNT (healed_sinks, priv->child_count) == 1 &&
-                    healed_sinks[ARBITER_BRICK_INDEX]) {
-                        is_arbiter_the_only_sink = _gf_true;
-                        goto restore_time;
-                }
-
-		ret = __afr_selfheal_truncate_sinks (frame, this, fd, healed_sinks,
-						     locked_replies[source].poststat.ia_size);
-		if (ret < 0)
-			goto unlock;
-
-		ret = 0;
-
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name, 0, 0,
-				data_lock);
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    int source = -1;
+    gf_boolean_t did_sh = _gf_true;
+    gf_boolean_t is_arbiter_the_only_sink = _gf_false;
+    gf_boolean_t empty_file = _gf_false;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, 0, 0,
+                               data_lock);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "self-heal as only %d number "
+                         "of subvolumes "
+                         "could be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_data_prepare(frame, this, fd->inode, data_lock,
+                                          sources, sinks, healed_sinks,
+                                          undid_pending, locked_replies, NULL);
         if (ret < 0)
-		goto out;
+            goto unlock;
 
-        if (!did_sh)
-                goto out;
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
+        }
+
+        source = ret;
+
+        if (AFR_IS_ARBITER_BRICK(priv, source)) {
+            empty_file = afr_is_file_empty_on_all_children(priv,
+                                                           locked_replies);
+            if (empty_file)
+                goto restore_time;
+
+            did_sh = _gf_false;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_truncate_sinks(
+            frame, this, fd, healed_sinks,
+            locked_replies[source].poststat.ia_size);
+        if (ret < 0)
+            goto unlock;
+
+        if (priv->arbiter_count &&
+            AFR_COUNT(healed_sinks, priv->child_count) == 1 &&
+            healed_sinks[ARBITER_BRICK_INDEX]) {
+            is_arbiter_the_only_sink = _gf_true;
+            goto restore_time;
+        }
+        ret = 0;
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, 0, 0, data_lock);
+    if (ret < 0)
+        goto out;
+
+    if (!did_sh)
+        goto out;
 
-	ret = afr_selfheal_data_do (frame, this, fd, source, healed_sinks,
-				    locked_replies);
-	if (ret)
-                goto out;
+    ret = afr_selfheal_data_do(frame, this, fd, source, healed_sinks,
+                               locked_replies);
+    if (ret)
+        goto out;
 restore_time:
-	afr_selfheal_restore_time (frame, this, fd->inode, source,
-					healed_sinks, locked_replies);
-
-        if (!is_arbiter_the_only_sink) {
-                ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name,
-                                            0, 0, data_lock);
-                if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        ret = -ENOTCONN;
-                        did_sh = _gf_false;
-                        goto skip_undo_pending;
-                }
+    afr_selfheal_restore_time(frame, this, fd->inode, source, healed_sinks,
+                              locked_replies);
+
+    if (!is_arbiter_the_only_sink && !empty_file) {
+        ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, 0, 0,
+                                   data_lock);
+        if (ret < priv->child_count) {
+            ret = -ENOTCONN;
+            did_sh = _gf_false;
+            goto skip_undo_pending;
         }
-        ret = afr_selfheal_undo_pending (frame, this, fd->inode,
-                                         sources, sinks, healed_sinks,
-                                         undid_pending, AFR_DATA_TRANSACTION,
-                                         locked_replies, data_lock);
+    }
+    ret = afr_selfheal_undo_pending(
+        frame, this, fd->inode, sources, sinks, healed_sinks, undid_pending,
+        AFR_DATA_TRANSACTION, locked_replies, data_lock);
 skip_undo_pending:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name, 0, 0,
-				data_lock);
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, 0, 0, data_lock);
 out:
 
-        if (did_sh)
-                afr_log_selfheal (fd->inode->gfid, this, ret, "data", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
+    if (did_sh)
+        afr_log_selfheal(fd->inode->gfid, this, ret, "data", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
 
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
+int
+afr_selfheal_data_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, fd_t *fd,
+                           dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int i = (long)cookie;
+
+    local = frame->local;
+
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+
+    syncbarrier_wake(&local->barrier);
+
+    return 0;
+}
 
 int
-afr_selfheal_data_open (xlator_t *this, inode_t *inode, fd_t **fd)
+afr_selfheal_data_open(xlator_t *this, inode_t *inode, fd_t **fd)
 {
-	int         ret    = 0;
-        fd_t       *fd_tmp = NULL;
-	loc_t       loc    = {0,};
-
-	fd_tmp = fd_create (inode, 0);
-	if (!fd_tmp)
-		return -ENOMEM;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	ret = syncop_open (this, &loc, O_RDWR|O_LARGEFILE, fd_tmp, NULL, NULL);
-	if (ret < 0) {
-		fd_unref (fd_tmp);
-                goto out;
-	} else {
-		fd_bind (fd_tmp);
-	}
-
-        *fd = fd_tmp;
+    int ret = 0;
+    fd_t *fd_tmp = NULL;
+    loc_t loc = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    priv = this->private;
+
+    fd_tmp = fd_create(inode, 0);
+    if (!fd_tmp)
+        return -ENOMEM;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        fd_unref(fd_tmp);
+        goto out;
+    }
+    local = frame->local;
+
+    AFR_ONLIST(local->child_up, frame, afr_selfheal_data_open_cbk, open, &loc,
+               O_RDWR | O_LARGEFILE, fd_tmp, NULL);
+
+    ret = -ENOTCONN;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+
+        if (local->replies[i].op_ret < 0) {
+            ret = -local->replies[i].op_errno;
+            continue;
+        }
+
+        ret = 0;
+        break;
+    }
+
+    if (ret < 0) {
+        fd_unref(fd_tmp);
+        goto out;
+    } else {
+        fd_bind(fd_tmp);
+    }
+
+    *fd = fd_tmp;
 out:
-        loc_wipe (&loc);
-	return ret;
+    loc_wipe(&loc);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-afr_selfheal_data (call_frame_t *frame, xlator_t *this, inode_t *inode)
+afr_selfheal_data(call_frame_t *frame, xlator_t *this, fd_t *fd)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *locked_on = NULL;
-	int ret = 0;
-	fd_t *fd = NULL;
-
-	priv = this->private;
-
-	ret = afr_selfheal_data_open (this, inode, &fd);
-	if (!fd) {
-                gf_msg_debug (this->name, -ret, "%s: Failed to open",
-                              uuid_utoa (inode->gfid));
-                return -EIO;
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    int ret = 0;
+    inode_t *inode = fd->inode;
+
+    priv = this->private;
+
+    locked_on = alloca0(priv->child_count);
+
+    ret = afr_selfheal_tie_breaker_inodelk(frame, this, inode, priv->sh_domain,
+                                           0, 0, locked_on);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "self-heal as only %d number of "
+                         "subvolumes could be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            /* Either less than two subvols available, or another
+               selfheal (from another server) is in progress. Skip
+               for now in any case there isn't anything to do.
+            */
+            ret = -ENOTCONN;
+            goto unlock;
         }
 
-	locked_on = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_tie_breaker_inodelk (frame, this, inode,
-	                                        priv->sh_domain, 0, 0,
-				                locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "self-heal as only %d number of "
-                                      "subvolumes could be locked",
-                                      uuid_utoa (fd->inode->gfid),
-                                ret);
-			/* Either less than two subvols available, or another
-			   selfheal (from another server) is in progress. Skip
-			   for now in any case there isn't anything to do.
-			*/
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data (frame, this, fd, locked_on);
-	}
+        ret = __afr_selfheal_data(frame, this, fd, locked_on);
+    }
 unlock:
-	afr_selfheal_uninodelk (frame, this, inode, priv->sh_domain, 0, 0,
-	                        locked_on);
-
-	if (fd)
-		fd_unref (fd);
+    afr_selfheal_uninodelk(frame, this, inode, priv->sh_domain, 0, 0,
+                           locked_on);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-entry.c b/xlators/cluster/afr/src/afr-self-heal-entry.c
index 647dd71911b..64893f441e3 100644
--- a/xlators/cluster/afr/src/afr-self-heal-entry.c
+++ b/xlators/cluster/afr/src/afr-self-heal-entry.c
@@ -8,1115 +8,1269 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "afr-transaction.h"
 #include "afr-messages.h"
-#include "syncop-utils.h"
-#include "events.h"
+#include <glusterfs/syncop-utils.h>
+#include <glusterfs/events.h>
 
-static int
-afr_selfheal_entry_delete (xlator_t *this, inode_t *dir, const char *name,
-                           inode_t *inode, int child, struct afr_reply *replies)
+int
+afr_selfheal_entry_anon_inode(xlator_t *this, inode_t *dir, const char *name,
+                              inode_t *inode, int child,
+                              struct afr_reply *replies,
+                              gf_boolean_t *anon_inode)
 {
-	afr_private_t *priv = NULL;
-	xlator_t *subvol = NULL;
-	int ret = 0;
-	loc_t loc = {0, };
-	char g[64];
-
-	priv = this->private;
-
-	subvol = priv->children[child];
-
-	loc.parent = inode_ref (dir);
-	gf_uuid_copy (loc.pargfid, dir->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
-
-	if (replies[child].valid && replies[child].op_ret == 0) {
-		switch (replies[child].poststat.ia_type) {
-		case IA_IFDIR:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-				"expunging dir %s/%s (%s) on %s",
-				uuid_utoa (dir->gfid), name,
-				uuid_utoa_r (replies[child].poststat.ia_gfid, g),
-				subvol->name);
-			ret = syncop_rmdir (subvol, &loc, 1, NULL, NULL);
-			break;
-		default:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-				"expunging file %s/%s (%s) on %s",
-				uuid_utoa (dir->gfid), name,
-				uuid_utoa_r (replies[child].poststat.ia_gfid, g),
-				subvol->name);
-			ret = syncop_unlink (subvol, &loc, NULL, NULL);
-			break;
-		}
-	}
-
-	loc_wipe (&loc);
-
-	return ret;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    int ret = 0;
+    int i = 0;
+    char g[64] = {0};
+    unsigned char *lookup_success = NULL;
+    call_frame_t *frame = NULL;
+    loc_t loc2 = {
+        0,
+    };
+    loc_t loc = {
+        0,
+    };
+
+    priv = this->private;
+    subvol = priv->children[child];
+    lookup_success = alloca0(priv->child_count);
+    uuid_utoa_r(replies[child].poststat.ia_gfid, g);
+    loc.inode = inode_new(inode->table);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    if (replies[child].poststat.ia_type == IA_IFDIR) {
+        /* This directory may have sub-directory hierarchy which may need to
+         * be preserved for subsequent heals. So unconditionally move the
+         * directory to anonymous-inode directory*/
+        *anon_inode = _gf_true;
+        goto anon_inode;
+    }
+
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+    local = frame->local;
+    gf_uuid_copy(loc.gfid, replies[child].poststat.ia_gfid);
+    AFR_ONLIST(local->child_up, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == 0) {
+            lookup_success[i] = 1;
+        } else if (local->replies[i].op_errno != ENOENT &&
+                   local->replies[i].op_errno != ESTALE) {
+            ret = -local->replies[i].op_errno;
+        }
+    }
+
+    if (priv->quorum_count) {
+        if (afr_has_quorum(lookup_success, this, NULL)) {
+            *anon_inode = _gf_true;
+        }
+    } else if (AFR_COUNT(lookup_success, priv->child_count) > 1) {
+        *anon_inode = _gf_true;
+    } else if (ret) {
+        goto out;
+    }
+
+anon_inode:
+    if (!*anon_inode) {
+        ret = 0;
+        goto out;
+    }
+
+    loc.parent = inode_ref(dir);
+    gf_uuid_copy(loc.pargfid, dir->gfid);
+    loc.name = name;
+
+    ret = afr_anon_inode_create(this, child, &loc2.parent);
+    if (ret < 0)
+        goto out;
+
+    loc2.name = g;
+    ret = syncop_rename(subvol, &loc, &loc2, NULL, NULL);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_EXPUNGING_FILE_OR_DIR,
+               "Rename to %s dir %s/%s (%s) on %s failed",
+               priv->anon_inode_name, uuid_utoa(dir->gfid), name, g,
+               subvol->name);
+    } else {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_EXPUNGING_FILE_OR_DIR,
+               "Rename to %s dir %s/%s (%s) on %s successful",
+               priv->anon_inode_name, uuid_utoa(dir->gfid), name, g,
+               subvol->name);
+    }
+
+out:
+    loc_wipe(&loc);
+    loc_wipe(&loc2);
+    if (frame) {
+        AFR_STACK_DESTROY(frame);
+    }
+
+    return ret;
 }
 
 int
-afr_selfheal_recreate_entry (call_frame_t *frame, int dst, int source,
-                             unsigned char *sources, inode_t *dir,
-                             const char *name, inode_t *inode,
-                             struct afr_reply *replies)
+afr_selfheal_entry_delete(xlator_t *this, inode_t *dir, const char *name,
+                          inode_t *inode, int child, struct afr_reply *replies)
 {
-	int ret = 0;
-	loc_t loc = {0,};
-	loc_t srcloc = {0,};
-        xlator_t *this = frame->this;
-	afr_private_t *priv = NULL;
-	dict_t *xdata = NULL;
-	struct iatt *iatt = NULL;
-	char *linkname = NULL;
-	mode_t mode = 0;
-	struct iatt newent = {0,};
-        unsigned char *newentry = NULL;
-
-        priv = this->private;
-	iatt = &replies[source].poststat;
-        if (iatt->ia_type == IA_INVAL || gf_uuid_is_null (iatt->ia_gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SELF_HEAL_FAILED,
-                        "Invalid ia_type (%d) or gfid(%s). source brick=%d, "
-                        "pargfid=%s, name=%s", iatt->ia_type,
-                        uuid_utoa(iatt->ia_gfid), source,
-                        uuid_utoa(dir->gfid), name);
-                ret = -EINVAL;
-                goto out;
-        }
+    char g[64] = {0};
+    afr_private_t *priv = NULL;
+    xlator_t *subvol = NULL;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    gf_boolean_t anon_inode = _gf_false;
+
+    priv = this->private;
+    subvol = priv->children[child];
+
+    if ((!replies[child].valid) || (replies[child].op_ret < 0)) {
+        /*Nothing to do*/
+        ret = 0;
+        goto out;
+    }
+
+    if (priv->use_anon_inode) {
+        ret = afr_selfheal_entry_anon_inode(this, dir, name, inode, child,
+                                            replies, &anon_inode);
+        if (ret < 0 || anon_inode)
+            goto out;
+    }
+
+    loc.parent = inode_ref(dir);
+    loc.inode = inode_new(inode->table);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    loc.name = name;
+    switch (replies[child].poststat.ia_type) {
+        case IA_IFDIR:
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                   "expunging dir %s/%s (%s) on %s", uuid_utoa(dir->gfid), name,
+                   uuid_utoa_r(replies[child].poststat.ia_gfid, g),
+                   subvol->name);
+            ret = syncop_rmdir(subvol, &loc, 1, NULL, NULL);
+            break;
+        default:
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                   "expunging file %s/%s (%s) on %s", uuid_utoa(dir->gfid),
+                   name, uuid_utoa_r(replies[child].poststat.ia_gfid, g),
+                   subvol->name);
+            ret = syncop_unlink(subvol, &loc, NULL, NULL);
+            break;
+    }
 
-	xdata = dict_new();
-	if (!xdata)
-		return -ENOMEM;
-        newentry = alloca0 (priv->child_count);
-	loc.parent = inode_ref (dir);
-	gf_uuid_copy (loc.pargfid, dir->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
-
-	ret = afr_selfheal_entry_delete (this, dir, name, inode, dst, replies);
-	if (ret)
-		goto out;
-
-	ret = dict_set_static_bin (xdata, "gfid-req",
-				   replies[source].poststat.ia_gfid, 16);
-	if (ret)
-		goto out;
-
-	srcloc.inode = inode_ref (inode);
-	gf_uuid_copy (srcloc.gfid, iatt->ia_gfid);
-        if (iatt->ia_type != IA_IFDIR)
-                ret = syncop_lookup (priv->children[dst], &srcloc, 0, 0, 0, 0);
-        if (iatt->ia_type == IA_IFDIR || ret == -ENOENT || ret == -ESTALE) {
-                newentry[dst] = 1;
-                ret = afr_selfheal_newentry_mark (frame, this, inode, source,
-                                                  replies, sources, newentry);
-                if (ret)
-                        goto out;
-        }
+out:
+    loc_wipe(&loc);
+    return ret;
+}
 
-	mode = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
-
-	switch (iatt->ia_type) {
-	case IA_IFDIR:
-		ret = syncop_mkdir (priv->children[dst], &loc, mode, 0,
-                                    xdata, NULL);
-		break;
-	case IA_IFLNK:
-		if (!newentry[dst]) {
-			ret = syncop_link (priv->children[dst], &srcloc, &loc,
-					   &newent, NULL, NULL);
-		} else {
-			ret = syncop_readlink (priv->children[source], &srcloc,
-					       &linkname, 4096, NULL, NULL);
-			if (ret <= 0)
-				goto out;
-			ret = syncop_symlink (priv->children[dst], &loc,
-                                              linkname, NULL, xdata, NULL);
-                }
-		break;
-	default:
-		ret = dict_set_int32 (xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
-		if (ret)
-			goto out;
-		ret = syncop_mknod (priv->children[dst], &loc, mode,
-                    makedev (ia_major(iatt->ia_rdev), ia_minor (iatt->ia_rdev)),
-                    &newent, xdata, NULL);
-		break;
-	}
+int
+afr_selfheal_recreate_entry(call_frame_t *frame, int dst, int source,
+                            unsigned char *sources, inode_t *dir,
+                            const char *name, inode_t *inode,
+                            struct afr_reply *replies)
+{
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    loc_t srcloc = {
+        0,
+    };
+    loc_t anonloc = {
+        0,
+    };
+    xlator_t *this = frame->this;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    struct iatt *iatt = NULL;
+    char *linkname = NULL;
+    mode_t mode = 0;
+    struct iatt newent = {
+        0,
+    };
+    unsigned char *newentry = NULL;
+    char iatt_uuid_str[64] = {0};
+    char dir_uuid_str[64] = {0};
+
+    priv = this->private;
+    iatt = &replies[source].poststat;
+    uuid_utoa_r(iatt->ia_gfid, iatt_uuid_str);
+    if (iatt->ia_type == IA_INVAL || gf_uuid_is_null(iatt->ia_gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SELF_HEAL_FAILED,
+               "Invalid ia_type (%d) or gfid(%s). source brick=%d, "
+               "pargfid=%s, name=%s",
+               iatt->ia_type, iatt_uuid_str, source,
+               uuid_utoa_r(dir->gfid, dir_uuid_str), name);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata)
+        return -ENOMEM;
+    newentry = alloca0(priv->child_count);
+    loc.parent = inode_ref(dir);
+    gf_uuid_copy(loc.pargfid, dir->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
+
+    ret = afr_selfheal_entry_delete(this, dir, name, inode, dst, replies);
+    if (ret)
+        goto out;
+
+    ret = dict_set_gfuuid(xdata, "gfid-req", replies[source].poststat.ia_gfid,
+                          true);
+    if (ret)
+        goto out;
+
+    srcloc.inode = inode_ref(inode);
+    gf_uuid_copy(srcloc.gfid, iatt->ia_gfid);
+    ret = syncop_lookup(priv->children[dst], &srcloc, 0, 0, 0, 0);
+    if (ret == -ENOENT || ret == -ESTALE) {
+        newentry[dst] = 1;
+        ret = afr_selfheal_newentry_mark(frame, this, inode, source, replies,
+                                         sources, newentry);
+        if (ret)
+            goto out;
+    } else if (ret == 0 && iatt->ia_type == IA_IFDIR && priv->use_anon_inode) {
+        // Try rename from hidden directory
+        ret = afr_anon_inode_create(this, dst, &anonloc.parent);
+        if (ret < 0)
+            goto out;
+        anonloc.inode = inode_ref(inode);
+        anonloc.name = iatt_uuid_str;
+        ret = syncop_rename(priv->children[dst], &anonloc, &loc, NULL, NULL);
+        if (ret == -ENOENT || ret == -ESTALE)
+            ret = -1; /*This sets 'mismatch' to true*/
+        goto out;
+    }
+
+    mode = st_mode_from_ia(iatt->ia_prot, iatt->ia_type);
+
+    switch (iatt->ia_type) {
+        case IA_IFDIR:
+            ret = syncop_mkdir(priv->children[dst], &loc, mode, 0, xdata, NULL);
+            break;
+        case IA_IFLNK:
+            if (!newentry[dst]) {
+                ret = syncop_link(priv->children[dst], &srcloc, &loc, &newent,
+                                  NULL, NULL);
+            } else {
+                ret = syncop_readlink(priv->children[source], &srcloc,
+                                      &linkname, 4096, NULL, NULL);
+                if (ret <= 0)
+                    goto out;
+                ret = syncop_symlink(priv->children[dst], &loc, linkname, NULL,
+                                     xdata, NULL);
+            }
+            break;
+        default:
+            ret = dict_set_int32_sizen(xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
+            if (ret)
+                goto out;
+            ret = syncop_mknod(
+                priv->children[dst], &loc, mode,
+                makedev(ia_major(iatt->ia_rdev), ia_minor(iatt->ia_rdev)),
+                &newent, xdata, NULL);
+            break;
+    }
 
 out:
-	if (xdata)
-		dict_unref (xdata);
-	GF_FREE (linkname);
-	loc_wipe (&loc);
-	loc_wipe (&srcloc);
-	return ret;
+    if (xdata)
+        dict_unref(xdata);
+    GF_FREE(linkname);
+    loc_wipe(&loc);
+    loc_wipe(&srcloc);
+    loc_wipe(&anonloc);
+    return ret;
 }
 
 static int
-__afr_selfheal_heal_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			    char *name, inode_t *inode, int source,
-			    unsigned char *sources, unsigned char *healed_sinks,
-			    unsigned char *locked_on, struct afr_reply *replies)
+__afr_selfheal_heal_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                           char *name, inode_t *inode, int source,
+                           unsigned char *sources, unsigned char *healed_sinks,
+                           unsigned char *locked_on, struct afr_reply *replies)
 {
-	int ret = 0;
-	afr_private_t *priv = NULL;
-	int i = 0;
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (!replies[source].valid)
-		return -EIO;
+    if (!replies[source].valid)
+        return -EIO;
 
-        /* Skip healing this entry if the last lookup on it failed for reasons
-         * other than ENOENT.
-         */
-        if ((replies[source].op_ret < 0) &&
-            (replies[source].op_errno != ENOENT))
-                return -replies[source].op_errno;
-
-        if (replies[source].op_ret == 0) {
-                ret = afr_lookup_and_heal_gfid (this, fd->inode, name,
-                                                inode, replies, source,
-                                             &replies[source].poststat.ia_gfid);
-                if (ret)
-                        return ret;
+    /* Skip healing this entry if the last lookup on it failed for reasons
+     * other than ENOENT.
+     */
+    if ((replies[source].op_ret < 0) && (replies[source].op_errno != ENOENT))
+        return -replies[source].op_errno;
+
+    if (replies[source].op_ret == 0) {
+        ret = afr_lookup_and_heal_gfid(this, fd->inode, name, inode, replies,
+                                       source, sources,
+                                       &replies[source].poststat.ia_gfid, NULL);
+        if (ret)
+            return ret;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
+        if (replies[source].op_ret == -1 &&
+            replies[source].op_errno == ENOENT) {
+            ret = afr_selfheal_entry_delete(this, fd->inode, name, inode, i,
+                                            replies);
+        } else {
+            if (!gf_uuid_compare(replies[i].poststat.ia_gfid,
+                                 replies[source].poststat.ia_gfid))
+                continue;
+
+            ret = afr_selfheal_recreate_entry(frame, i, source, sources,
+                                              fd->inode, name, inode, replies);
         }
+        if (ret < 0)
+            break;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!healed_sinks[i])
-			continue;
-		if (replies[source].op_ret == -1 &&
-		    replies[source].op_errno == ENOENT) {
-			ret = afr_selfheal_entry_delete (this, fd->inode, name,
-                                                         inode, i, replies);
-                } else {
-			if (!gf_uuid_compare (replies[i].poststat.ia_gfid,
-					   replies[source].poststat.ia_gfid))
-				continue;
-
-			ret = afr_selfheal_recreate_entry (frame, i, source,
-                                                           sources, fd->inode,
-                                                           name, inode,
-							   replies);
-                }
-		if (ret < 0)
-			break;
-	}
-
-	return ret;
+    return ret;
 }
 
 static int
-afr_selfheal_detect_gfid_and_type_mismatch (xlator_t *this,
-                                            struct afr_reply *replies,
-                                            inode_t *inode,
-                                            uuid_t pargfid,
-                                            char *bname, int src_idx,
-                                            unsigned char *locked_on,
-                                            int *src)
+afr_selfheal_detect_gfid_and_type_mismatch(xlator_t *this,
+                                           struct afr_reply *replies,
+                                           inode_t *inode, uuid_t pargfid,
+                                           char *bname, int src_idx,
+                                           unsigned char *locked_on, int *src)
 {
-        int             i        = 0;
-        int             ret      = -1;
-        afr_private_t  *priv     = NULL;
-        void *gfid               = NULL;
-        ia_type_t ia_type        = IA_INVAL;
+    int i = 0;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    void *gfid = NULL;
+    ia_type_t ia_type = IA_INVAL;
 
-        priv = this->private;
-        gfid = &replies[src_idx].poststat.ia_gfid;
-        ia_type = replies[src_idx].poststat.ia_type;
+    priv = this->private;
+    gfid = &replies[src_idx].poststat.ia_gfid;
+    ia_type = replies[src_idx].poststat.ia_type;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == src_idx)
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                if (gf_uuid_compare (gfid, replies[i].poststat.ia_gfid) &&
-                    (ia_type == replies[i].poststat.ia_type)) {
-                        ret = afr_gfid_split_brain_source (this, replies, inode,
-                                                           pargfid, bname,
-                                                           src_idx, i,
-                                                           locked_on, src,
-                                                           NULL);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_SPLIT_BRAIN,
-                                        "Skipping conservative merge on the "
-                                        "file.");
-                        return ret;
-                }
-
-                if (ia_type != replies[i].poststat.ia_type) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Type mismatch detected "
-                                "for <gfid:%s>/%s>, %s on %s and %s on %s. "
-                                "Skipping conservative merge on the file.",
-                                uuid_utoa (pargfid), bname,
-                                gf_inode_type_to_str (replies[i].poststat.ia_type),
-                                priv->children[i]->name,
-                                gf_inode_type_to_str (replies[src_idx].poststat.ia_type),
-                                priv->children[src_idx]->name);
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=file;"
-                                  "file=<gfid:%s>/%s>;count=2;child-%d=%s;type-"
-                                  "%d=%s;child-%d=%s;type-%d=%s",
-                                  this->name, uuid_utoa (pargfid), bname, i,
-                                  priv->children[i]->name, i,
-                                  gf_inode_type_to_str(replies[i].poststat.ia_type),
-                                  src_idx, priv->children[src_idx]->name, src_idx,
-                                  gf_inode_type_to_str(replies[src_idx].poststat.ia_type));
-                        return -1;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == src_idx)
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        if (gf_uuid_is_null(replies[i].poststat.ia_gfid))
+            continue;
+
+        if (replies[i].poststat.ia_type == IA_INVAL)
+            continue;
+
+        if (ia_type == IA_INVAL || gf_uuid_is_null(gfid)) {
+            src_idx = i;
+            ia_type = replies[src_idx].poststat.ia_type;
+            gfid = &replies[src_idx].poststat.ia_gfid;
+            continue;
         }
 
-        return 0;
+        if (gf_uuid_compare(gfid, replies[i].poststat.ia_gfid) &&
+            (ia_type == replies[i].poststat.ia_type)) {
+            ret = afr_gfid_split_brain_source(this, replies, inode, pargfid,
+                                              bname, src_idx, i, locked_on, src,
+                                              NULL);
+            if (ret)
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Skipping conservative merge on the "
+                       "file.");
+            return ret;
+        }
+
+        if (ia_type != replies[i].poststat.ia_type) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                   "Type mismatch detected "
+                   "for <gfid:%s>/%s>, %s on %s and %s on %s. "
+                   "Skipping conservative merge on the file.",
+                   uuid_utoa(pargfid), bname,
+                   gf_inode_type_to_str(replies[i].poststat.ia_type),
+                   priv->children[i]->name,
+                   gf_inode_type_to_str(replies[src_idx].poststat.ia_type),
+                   priv->children[src_idx]->name);
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "client-pid=%d;"
+                     "subvol=%s;type=file;"
+                     "file=<gfid:%s>/%s>;count=2;child-%d=%s;type-"
+                     "%d=%s;child-%d=%s;type-%d=%s",
+                     this->ctx->cmd_args.client_pid, this->name,
+                     uuid_utoa(pargfid), bname, i, priv->children[i]->name, i,
+                     gf_inode_type_to_str(replies[i].poststat.ia_type), src_idx,
+                     priv->children[src_idx]->name, src_idx,
+                     gf_inode_type_to_str(replies[src_idx].poststat.ia_type));
+            return -1;
+        }
+    }
+
+    return 0;
 }
 
 static int
-__afr_selfheal_merge_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			     char *name, inode_t *inode, unsigned char *sources,
-			     unsigned char *healed_sinks, unsigned char *locked_on,
-			     struct afr_reply *replies)
+__afr_selfheal_merge_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            char *name, inode_t *inode, unsigned char *sources,
+                            unsigned char *healed_sinks,
+                            unsigned char *locked_on, struct afr_reply *replies)
 {
-        int             ret       = 0;
-        int             i         = 0;
-        int             source    = -1;
-        int             src       = -1;
-        afr_private_t  *priv      = NULL;
+    int ret = 0;
+    int i = 0;
+    int source = -1;
+    int src = -1;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            source = i;
+            break;
+        }
+    }
+
+    if (source == -1) {
+        /* entry got deleted in the mean time? */
+        return 0;
+    }
 
-	priv = this->private;
+    /* Set all the sources as 1, otheriwse newentry_mark won't be set */
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            sources[i] = 1;
+        }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-		if (replies[i].valid && replies[i].op_ret == 0) {
-			source = i;
-			break;
-		}
-	}
-
-	if (source == -1) {
-		/* entry got deleted in the mean time? */
-		return 0;
-	}
-
-        /* Set all the sources as 1, otheriwse newentry_mark won't be set */
-	for (i = 0; i < priv->child_count; i++) {
-		if (replies[i].valid && replies[i].op_ret == 0) {
-			sources[i] = 1;
-		}
-	}
-
-        ret = afr_lookup_and_heal_gfid (this, fd->inode, name, inode, replies,
-                                        source,
-                                        &replies[source].poststat.ia_gfid);
-        if (ret)
-                return ret;
+    ret = afr_lookup_and_heal_gfid(this, fd->inode, name, inode, replies,
+                                   source, sources,
+                                   &replies[source].poststat.ia_gfid, NULL);
+    if (ret)
+        return ret;
 
-        /* In case of type mismatch / unable to resolve gfid mismatch on the
-         * entry, return -1.*/
-        ret = afr_selfheal_detect_gfid_and_type_mismatch (this, replies, inode,
-                                                          fd->inode->gfid,
-                                                          name, source,
-                                                          locked_on, &src);
+    /* In case of type mismatch / unable to resolve gfid mismatch on the
+     * entry, return -1.*/
+    ret = afr_selfheal_detect_gfid_and_type_mismatch(
+        this, replies, inode, fd->inode->gfid, name, source, locked_on, &src);
 
-        if (ret < 0)
-                return ret;
-        if (src != -1) {
-                source = src;
-                for (i = 0; i < priv->child_count; i++) {
-                        if (i != src && replies[i].valid &&
-                            gf_uuid_compare (replies[src].poststat.ia_gfid,
-                            replies[i].poststat.ia_gfid)) {
-                                sources[i] = 0;
-                        }
-                }
+    if (ret < 0)
+        return ret;
+    if (src != -1) {
+        source = src;
+        for (i = 0; i < priv->child_count; i++) {
+            if (i != src && replies[i].valid &&
+                gf_uuid_compare(replies[src].poststat.ia_gfid,
+                                replies[i].poststat.ia_gfid)) {
+                sources[i] = 0;
+            }
         }
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source || !healed_sinks[i])
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || !healed_sinks[i])
+            continue;
 
-                if (src != -1) {
-                        if (!gf_uuid_compare (replies[src].poststat.ia_gfid,
-                                              replies[i].poststat.ia_gfid))
-                                continue;
-                } else if (replies[i].op_errno != ENOENT) {
-			continue;
-                }
+        if (src != -1) {
+            if (!gf_uuid_compare(replies[src].poststat.ia_gfid,
+                                 replies[i].poststat.ia_gfid))
+                continue;
+        } else if (replies[i].op_errno != ENOENT) {
+            continue;
+        }
 
-		ret |= afr_selfheal_recreate_entry (frame, i, source, sources,
-                                                    fd->inode, name, inode,
-                                                    replies);
-	}
+        ret |= afr_selfheal_recreate_entry(frame, i, source, sources, fd->inode,
+                                           name, inode, replies);
+    }
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__afr_selfheal_entry_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             char *name, inode_t *inode, int source,
-                             unsigned char *sources, unsigned char *healed_sinks,
-                             unsigned char *locked_on,
-                             struct afr_reply *replies)
+__afr_selfheal_entry_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            char *name, inode_t *inode, int source,
+                            unsigned char *sources, unsigned char *healed_sinks,
+                            unsigned char *locked_on, struct afr_reply *replies)
 {
-	int ret = -1;
-
-	if (source < 0)
-		ret = __afr_selfheal_merge_dirent (frame, this, fd, name, inode,
-						   sources, healed_sinks,
-						   locked_on, replies);
-	else
-		ret = __afr_selfheal_heal_dirent (frame, this, fd, name, inode,
-						  source, sources, healed_sinks,
-						  locked_on, replies);
-	return ret;
+    int ret = -1;
+
+    if (source < 0)
+        ret = __afr_selfheal_merge_dirent(frame, this, fd, name, inode, sources,
+                                          healed_sinks, locked_on, replies);
+    else
+        ret = __afr_selfheal_heal_dirent(frame, this, fd, name, inode, source,
+                                         sources, healed_sinks, locked_on,
+                                         replies);
+    return ret;
 }
 
 static gf_boolean_t
-is_full_heal_marker_present (xlator_t *this, dict_t *xdata, int idx)
+is_full_heal_marker_present(xlator_t *this, dict_t *xdata, int idx)
 {
-        int                  i           = 0;
-        int                  pending[3]  = {0,};
-        void                *pending_raw = NULL;
-        afr_private_t       *priv        = NULL;
+    int i = 0;
+    int pending[3] = {
+        0,
+    };
+    void *pending_raw = NULL;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!xdata)
-                return _gf_false;
+    if (!xdata)
+        return _gf_false;
 
-        /* Iterate over each of the priv->pending_keys[] elements and then
-         * see if any of them have data segment non-zero. If they do, return
-         * true. Else return false.
-         */
-        for (i = 0; i < priv->child_count; i++) {
-                if (dict_get_ptr (xdata, priv->pending_key[i], &pending_raw))
-                        continue;
+    /* Iterate over each of the priv->pending_keys[] elements and then
+     * see if any of them have data segment non-zero. If they do, return
+     * true. Else return false.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
 
-                if (!pending_raw)
-                        continue;
+        if (!pending_raw)
+            continue;
 
-                memcpy (pending, pending_raw, sizeof (pending));
-                if (ntoh32 (pending[idx]))
-                        return _gf_true;
-        }
+        memcpy(pending, pending_raw, sizeof(pending));
+        if (ntoh32(pending[idx]))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_need_full_heal (xlator_t *this, struct afr_reply *replies, int source,
-                    unsigned char *healed_sinks, afr_transaction_type type)
+afr_need_full_heal(xlator_t *this, struct afr_reply *replies, int source,
+                   unsigned char *healed_sinks, afr_transaction_type type)
 {
-        int                i     = 0;
-        int                idx   = 0;
-        afr_private_t     *priv  = NULL;
+    int i = 0;
+    int idx = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!priv->esh_granular)
-                return _gf_true;
+    if (!priv->esh_granular)
+        return _gf_true;
 
-        if (type != AFR_ENTRY_TRANSACTION)
-                return _gf_true;
+    if (type != AFR_ENTRY_TRANSACTION)
+        return _gf_true;
 
-        priv = this->private;
-        idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
+    priv = this->private;
+    idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
 
-        /* If there is a clear source, check whether the full-heal-indicator
-         * is present in its xdata. Otherwise, we need to examine all the
-         * participating bricks and then figure if *even* one of them has a
-         * full-heal-indicator.
-         */
+    /* If there is a clear source, check whether the full-heal-indicator
+     * is present in its xdata. Otherwise, we need to examine all the
+     * participating bricks and then figure if *even* one of them has a
+     * full-heal-indicator.
+     */
 
-        if (source != -1) {
-                if (is_full_heal_marker_present (this, replies[source].xdata,
-                                                 idx))
-                        return _gf_true;
-        }
+    if (source != -1) {
+        if (is_full_heal_marker_present(this, replies[source].xdata, idx))
+            return _gf_true;
+    }
 
-        /* else ..*/
+    /* else ..*/
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!healed_sinks[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
 
-                if (is_full_heal_marker_present (this, replies[i].xdata, idx))
-                        return _gf_true;
-        }
+        if (is_full_heal_marker_present(this, replies[i].xdata, idx))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static int
-__afr_selfheal_entry_finalize_source (xlator_t *this, unsigned char *sources,
-				      unsigned char *healed_sinks,
-                                      unsigned char *locked_on,
-                                      struct afr_reply *replies,
-                                      uint64_t *witness)
+__afr_selfheal_entry_finalize_source(xlator_t *this, unsigned char *sources,
+                                     unsigned char *healed_sinks,
+                                     unsigned char *locked_on,
+                                     struct afr_reply *replies,
+                                     uint64_t *witness)
 {
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
+    int i = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	sources_count = AFR_COUNT (sources, priv->child_count);
+    sources_count = AFR_COUNT(sources, priv->child_count);
 
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count || afr_does_witness_exist (this, witness)) {
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count || afr_does_witness_exist(this, witness)) {
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+        afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+        return -1;
+    }
 
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-		return -1;
-	}
+    source = afr_choose_source_by_policy(priv, sources, AFR_ENTRY_TRANSACTION);
+
+    /*If the selected source does not blame any other brick, then mark
+     * everything as sink to trigger conservative merge.
+     */
+    if (source != -1 && !AFR_COUNT(healed_sinks, priv->child_count)) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (locked_on[i]) {
+                sources[i] = 0;
+                healed_sinks[i] = 1;
+            }
+        }
+        return -1;
+    }
 
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_ENTRY_TRANSACTION);
-	return source;
+    return source;
 }
 
 int
-__afr_selfheal_entry_prepare (call_frame_t *frame, xlator_t *this,
-                              inode_t *inode, unsigned char *locked_on,
-                              unsigned char *sources, unsigned char *sinks,
-                              unsigned char *healed_sinks,
-			      struct afr_reply *replies, int *source_p,
-                              gf_boolean_t *pflag)
+__afr_selfheal_entry_prepare(call_frame_t *frame, xlator_t *this,
+                             inode_t *inode, unsigned char *locked_on,
+                             unsigned char *sources, unsigned char *sinks,
+                             unsigned char *healed_sinks,
+                             struct afr_reply *replies, int *source_p,
+                             unsigned char *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        uint64_t *witness = NULL;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-        if (ret)
-                return ret;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_ENTRY_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_entry_finalize_source (this, sources,
-                                                       healed_sinks,
-						       locked_on, replies,
-                                                       witness);
-
-	if (source < 0) {
-		/* If source is < 0 (typically split-brain), we perform a
-		   conservative merge of entries rather than erroring out */
-	}
-	*source_p = source;
-
-	return ret;
-}
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+    if (ret)
+        return ret;
 
-static int
-afr_selfheal_entry_dirent (call_frame_t *frame, xlator_t *this,
-                           fd_t *fd, char *name, inode_t *parent_idx_inode,
-                           xlator_t *subvol, gf_boolean_t full_crawl)
-{
-        int                ret          = 0;
-        int                source       = -1;
-        unsigned char     *locked_on    = NULL;
-        unsigned char     *sources      = NULL;
-        unsigned char     *sinks        = NULL;
-        unsigned char     *healed_sinks = NULL;
-        inode_t           *inode        = NULL;
-        struct afr_reply  *replies      = NULL;
-        struct afr_reply  *par_replies  = NULL;
-        afr_private_t     *priv         = NULL;
-        dict_t            *xattr        = NULL;
-
-	priv = this->private;
-
-        xattr = dict_new ();
-        if (!xattr)
-                return -ENOMEM;
-        ret = dict_set_int32 (xattr, GF_GFIDLESS_LOOKUP, 1);
-        if (ret) {
-                dict_unref (xattr);
-                return -1;
-        }
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_ENTRY_TRANSACTION, locked_on, sources,
+                                      sinks, witness, pflag);
+    if (ret)
+        return ret;
 
-        sources = alloca0 (priv->child_count);
-        sinks   = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-	locked_on = alloca0 (priv->child_count);
-
-	replies = alloca0 (priv->child_count * sizeof(*replies));
-	par_replies = alloca0 (priv->child_count * sizeof(*par_replies));
-
-        ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-                                    locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes "
-                                      " could be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret, this->name);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-                ret = __afr_selfheal_entry_prepare (frame, this, fd->inode,
-                                                    locked_on,
-                                                    sources, sinks,
-                                                    healed_sinks, par_replies,
-                                                    &source, NULL);
-                if (ret < 0)
-                        goto unlock;
-
-		inode = afr_selfheal_unlocked_lookup_on (frame, fd->inode, name,
-							 replies, locked_on,
-                                                         xattr);
-		if (!inode) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_entry_dirent (frame, this, fd, name, inode,
-						   source, sources, healed_sinks,
-						   locked_on, replies);
-
-                if ((ret == 0) && (priv->esh_granular) && parent_idx_inode) {
-                        ret = afr_shd_index_purge (subvol, parent_idx_inode,
-                                                   name, inode->ia_type);
-                        /* Why is ret force-set to 0? We do not care about
-                         * index purge failing for full heal as it is quite
-                         * possible during replace-brick that not all files
-                         * and directories have their name indices present in
-                         * entry-changes/.
-                         */
-                        ret = 0;
-                }
-	}
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
 
-unlock:
-        afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-                                locked_on, NULL);
-	if (inode)
-		inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-        if (par_replies)
-                afr_replies_wipe (par_replies, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
-
-	return ret;
-}
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
 
+    source = __afr_selfheal_entry_finalize_source(this, sources, healed_sinks,
+                                                  locked_on, replies, witness);
 
-static inode_t *
-afr_shd_entry_changes_index_inode (xlator_t *this, xlator_t *subvol,
-                                   uuid_t pargfid)
+    if (source < 0) {
+        /* If source is < 0 (typically split-brain), we perform a
+           conservative merge of entries rather than erroring out */
+    }
+    *source_p = source;
+
+    return ret;
+}
+
+static int
+afr_selfheal_entry_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                          char *name, inode_t *parent_idx_inode,
+                          xlator_t *subvol, gf_boolean_t full_crawl)
 {
-        int             ret         = -1;
-        void           *index_gfid  = NULL;
-        loc_t           rootloc     = {0,};
-        loc_t           loc         = {0,};
-        dict_t         *xattr       = NULL;
-        inode_t        *inode       = NULL;
-        struct iatt     iatt        = {0,};
-
-        rootloc.inode = inode_ref (this->itable->root);
-        gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
-
-        ret = syncop_getxattr (subvol, &rootloc, &xattr,
-                               GF_XATTROP_ENTRY_CHANGES_GFID, NULL, NULL);
-        if (ret || !xattr) {
-                errno = -ret;
-                goto out;
+    int ret = 0;
+    int source = -1;
+    unsigned char *locked_on = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    inode_t *inode = NULL;
+    struct afr_reply *replies = NULL;
+    struct afr_reply *par_replies = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+
+    priv = this->private;
+
+    if (afr_is_private_directory(priv, fd->inode->gfid, name,
+                                 GF_CLIENT_PID_SELF_HEALD)) {
+        return 0;
+    }
+
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
+    ret = dict_set_int32_sizen(xattr, GF_GFIDLESS_LOOKUP, 1);
+    if (ret) {
+        dict_unref(xattr);
+        return -1;
+    }
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    locked_on = alloca0(priv->child_count);
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+    par_replies = alloca0(priv->child_count * sizeof(*par_replies));
+
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               locked_on);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes "
+                         " could be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, this->name);
+            ret = -ENOTCONN;
+            goto unlock;
         }
 
-        ret = dict_get_ptr (xattr, GF_XATTROP_ENTRY_CHANGES_GFID, &index_gfid);
-        if (ret) {
-                errno = EINVAL;
-                goto out;
-        }
+        ret = __afr_selfheal_entry_prepare(frame, this, fd->inode, locked_on,
+                                           sources, sinks, healed_sinks,
+                                           par_replies, &source, NULL);
+        if (ret < 0)
+            goto unlock;
 
-        loc.inode = inode_new (this->itable);
-        if (!loc.inode) {
-                errno = ENOMEM;
-                goto out;
+        inode = afr_selfheal_unlocked_lookup_on(frame, fd->inode, name, replies,
+                                                locked_on, xattr);
+        if (!inode) {
+            ret = -ENOMEM;
+            goto unlock;
         }
 
-        gf_uuid_copy (loc.pargfid, index_gfid);
-        loc.name = gf_strdup (uuid_utoa (pargfid));
-
-        ret = syncop_lookup (subvol, &loc, &iatt, NULL, NULL, NULL);
-        if (ret < 0) {
-                errno = -ret;
-                goto out;
+        ret = __afr_selfheal_entry_dirent(frame, this, fd, name, inode, source,
+                                          sources, healed_sinks, locked_on,
+                                          replies);
+
+        if ((ret == 0) && (priv->esh_granular) && parent_idx_inode) {
+            ret = afr_shd_entry_purge(subvol, parent_idx_inode, name,
+                                      inode->ia_type);
+            /* Why is ret force-set to 0? We do not care about
+             * index purge failing for full heal as it is quite
+             * possible during replace-brick that not all files
+             * and directories have their name indices present in
+             * entry-changes/.
+             */
+            ret = 0;
         }
+    }
+
+unlock:
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL, locked_on,
+                           NULL);
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    if (par_replies)
+        afr_replies_wipe(par_replies, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
+
+    return ret;
+}
 
-        inode = inode_link (loc.inode, NULL, NULL, &iatt);
+static inode_t *
+afr_shd_entry_changes_index_inode(xlator_t *this, xlator_t *subvol,
+                                  uuid_t pargfid)
+{
+    int ret = -1;
+    void *index_gfid = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
+
+    ret = syncop_getxattr(subvol, &rootloc, &xattr,
+                          GF_XATTROP_ENTRY_CHANGES_GFID, NULL, NULL);
+    if (ret || !xattr) {
+        errno = -ret;
+        goto out;
+    }
+
+    ret = dict_get_ptr(xattr, GF_XATTROP_ENTRY_CHANGES_GFID, &index_gfid);
+    if (ret) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    loc.inode = inode_new(this->itable);
+    if (!loc.inode) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_copy(loc.pargfid, index_gfid);
+    loc.name = gf_strdup(uuid_utoa(pargfid));
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, NULL, NULL);
+    if (ret < 0) {
+        errno = -ret;
+        goto out;
+    }
+
+    inode = inode_link(loc.inode, NULL, NULL, &iatt);
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        loc_wipe (&rootloc);
-        GF_FREE ((char *)loc.name);
-        loc_wipe (&loc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&rootloc);
+    GF_FREE((char *)loc.name);
+    loc_wipe(&loc);
 
-        return inode;
+    return inode;
 }
 
 static int
-afr_selfheal_entry_do_subvol (call_frame_t *frame, xlator_t *this,
-                              fd_t *fd, int child)
+afr_selfheal_entry_do_subvol(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                             int child)
 {
-	int ret = 0;
-	gf_dirent_t entries;
-	gf_dirent_t *entry = NULL;
-	off_t offset = 0;
-	call_frame_t *iter_frame = NULL;
-	xlator_t *subvol = NULL;
-	afr_private_t *priv = NULL;
-        gf_boolean_t mismatch = _gf_false;
-        afr_local_t *local = NULL;
-        loc_t loc = {0,};
-
-	priv = this->private;
-	subvol = priv->children[child];
-
-	INIT_LIST_HEAD (&entries.list);
-
-        local = frame->local;
-
-	iter_frame = afr_copy_frame (frame);
-	if (!iter_frame)
-		return -ENOMEM;
-
-        loc.inode = afr_shd_entry_changes_index_inode (this, subvol,
-                                                       fd->inode->gfid);
-
-	while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      NULL, NULL))) {
-		if (ret > 0)
-			ret = 0;
-		list_for_each_entry (entry, &entries.list, list) {
-			offset = entry->d_off;
-
-			if (!strcmp (entry->d_name, ".") ||
-			    !strcmp (entry->d_name, ".."))
-				continue;
-
-			if (__is_root_gfid (fd->inode->gfid) &&
-			    !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR))
-				continue;
-
-			ret = afr_selfheal_entry_dirent (iter_frame, this, fd,
-                                                         entry->d_name,
-                                                         loc.inode, subvol,
-                                                        local->need_full_crawl);
-			AFR_STACK_RESET (iter_frame);
-			if (iter_frame->local == NULL) {
-                                ret = -ENOTCONN;
-                                break;
-                        }
-
-                        if (ret == -1) {
-                                /* gfid or type mismatch. */
-                                mismatch = _gf_true;
-                                ret = 0;
-                        }
-			if (ret)
-				break;
-		}
-
-		gf_dirent_free (&entries);
-		if (ret)
-			break;
-	}
-
-        loc_wipe (&loc);
-
-	AFR_STACK_DESTROY (iter_frame);
-        if (mismatch == _gf_true)
-                /* undo pending will be skipped */
-                ret = -1;
-	return ret;
-}
+    int ret = 0;
+    gf_dirent_t entries;
+    gf_dirent_t *entry = NULL;
+    off_t offset = 0;
+    call_frame_t *iter_frame = NULL;
+    xlator_t *subvol = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t mismatch = _gf_false;
+    afr_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    priv = this->private;
+    subvol = priv->children[child];
+
+    INIT_LIST_HEAD(&entries.list);
+
+    local = frame->local;
+
+    iter_frame = afr_copy_frame(frame);
+    if (!iter_frame)
+        return -ENOMEM;
+
+    loc.inode = afr_shd_entry_changes_index_inode(this, subvol,
+                                                  fd->inode->gfid);
+
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, NULL,
+                                 NULL))) {
+        if (ret > 0)
+            ret = 0;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-static int
-afr_selfheal_entry_granular_dirent (xlator_t *subvol, gf_dirent_t *entry,
-                                    loc_t *parent, void *data)
-{
-        int                      ret  = 0;
-        loc_t                    loc  = {0,};
-        struct iatt              iatt = {0,};
-        afr_granular_esh_args_t *args = data;
-
-        /* Look up the actual inode associated with entry. If the lookup returns
-         * ESTALE or ENOENT, then it means we have a stale index. Remove it.
-         * This is analogous to the check in afr_shd_index_heal() except that
-         * here it is achieved through LOOKUP and in afr_shd_index_heal() through
-         * a GETXATTR.
-         */
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
+
+            ret = afr_selfheal_entry_dirent(iter_frame, this, fd, entry->d_name,
+                                            loc.inode, subvol,
+                                            local->need_full_crawl);
+            AFR_STACK_RESET(iter_frame);
+            if (iter_frame->local == NULL) {
+                ret = -ENOTCONN;
+                break;
+            }
 
-        loc.inode = inode_new (args->xl->itable);
-        loc.parent = inode_ref (args->heal_fd->inode);
-        gf_uuid_copy (loc.pargfid, loc.parent->gfid);
-        loc.name = entry->d_name;
-
-        ret = syncop_lookup (args->xl, &loc, &iatt, NULL, NULL, NULL);
-        if ((ret == -ENOENT) || (ret == -ESTALE)) {
-                /* The name indices under the pgfid index dir are guaranteed
-                 * to be regular files. Hence the hardcoding.
-                 */
-                afr_shd_index_purge (subvol, parent->inode, entry->d_name,
-                                     IA_IFREG);
+            if (ret == -1) {
+                /* gfid or type mismatch. */
+                mismatch = _gf_true;
                 ret = 0;
-                goto out;
+            }
+            if (ret)
+                break;
         }
-        /* TBD: afr_shd_zero_xattrop? */
 
-        ret = afr_selfheal_entry_dirent (args->frame, args->xl, args->heal_fd,
-                                         entry->d_name, parent->inode, subvol,
-                                         _gf_false);
-        AFR_STACK_RESET (args->frame);
-        if (args->frame->local == NULL)
-                ret = -ENOTCONN;
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
 
-        if (ret == -1)
-                args->mismatch = _gf_true;
+    loc_wipe(&loc);
 
-out:
-        loc_wipe (&loc);
-        return 0;
+    AFR_STACK_DESTROY(iter_frame);
+    if (mismatch == _gf_true)
+        /* undo pending will be skipped */
+        ret = -1;
+    return ret;
 }
 
 static int
-afr_selfheal_entry_granular (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             int subvol_idx, gf_boolean_t is_src)
+afr_selfheal_entry_granular_dirent(xlator_t *subvol, gf_dirent_t *entry,
+                                   loc_t *parent, void *data)
 {
-        int                         ret    = 0;
-        loc_t                       loc    = {0,};
-        xlator_t                   *subvol = NULL;
-        afr_private_t              *priv   = NULL;
-        afr_granular_esh_args_t     args   = {0,};
-
-        priv = this->private;
-        subvol = priv->children[subvol_idx];
-
-        args.frame = afr_copy_frame (frame);
-        args.xl = this;
-        /* args.heal_fd represents the fd associated with the original directory
-         * on which entry heal is being attempted.
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    afr_granular_esh_args_t *args = data;
+
+    /* Look up the actual inode associated with entry. If the lookup returns
+     * ESTALE or ENOENT, then it means we have a stale index. Remove it.
+     * This is analogous to the check in afr_shd_index_heal() except that
+     * here it is achieved through LOOKUP and in afr_shd_index_heal() through
+     * a GETXATTR.
+     */
+
+    loc.inode = inode_new(args->xl->itable);
+    loc.parent = inode_ref(args->heal_fd->inode);
+    gf_uuid_copy(loc.pargfid, loc.parent->gfid);
+    loc.name = entry->d_name;
+
+    ret = syncop_lookup(args->xl, &loc, &iatt, NULL, NULL, NULL);
+    if ((ret == -ENOENT) || (ret == -ESTALE)) {
+        /* The name indices under the pgfid index dir are guaranteed
+         * to be regular files. Hence the hardcoding.
          */
-        args.heal_fd = fd;
+        afr_shd_entry_purge(subvol, parent->inode, entry->d_name, IA_IFREG);
+        ret = 0;
+        goto out;
+    }
+    /* TBD: afr_shd_zero_xattrop? */
+
+    ret = afr_selfheal_entry_dirent(args->frame, args->xl, args->heal_fd,
+                                    entry->d_name, parent->inode, subvol,
+                                    _gf_false);
+    AFR_STACK_RESET(args->frame);
+    if (args->frame->local == NULL)
+        ret = -ENOTCONN;
+
+    if (ret == -1)
+        args->mismatch = _gf_true;
 
-        /* @subvol here represents the subvolume of AFR where
-         * indices/entry-changes/<pargfid> will be processed
-         */
-        loc.inode = afr_shd_entry_changes_index_inode (this, subvol,
-                                                       fd->inode->gfid);
-        if (!loc.inode) {
-                /* If granular heal failed on the sink (as it might sometimes
-                 * because it is the src that would mostly contain the granular
-                 * changelogs and the sink's entry-changes would be empty),
-                 * do not treat heal as failure.
-                 */
-                if (is_src)
-                        return -errno;
-                else
-                        return 0;
-        }
+out:
+    loc_wipe(&loc);
+    return 0;
+}
 
-        ret = syncop_dir_scan (subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
-                               &args, afr_selfheal_entry_granular_dirent);
+static int
+afr_selfheal_entry_granular(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            int subvol_idx, gf_boolean_t is_src)
+{
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    xlator_t *subvol = NULL;
+    afr_private_t *priv = NULL;
+    afr_granular_esh_args_t args = {
+        0,
+    };
+
+    priv = this->private;
+    subvol = priv->children[subvol_idx];
+
+    args.frame = afr_copy_frame(frame);
+    if (!args.frame)
+        goto out;
+    args.xl = this;
+    /* args.heal_fd represents the fd associated with the original directory
+     * on which entry heal is being attempted.
+     */
+    args.heal_fd = fd;
+
+    /* @subvol here represents the subvolume of AFR where
+     * indices/entry-changes/<pargfid> will be processed
+     */
+    loc.inode = afr_shd_entry_changes_index_inode(this, subvol,
+                                                  fd->inode->gfid);
+    if (!loc.inode) {
+        /* If granular heal failed on the sink (as it might sometimes
+         * because it is the src that would mostly contain the granular
+         * changelogs and the sink's entry-changes would be empty),
+         * do not treat heal as failure.
+         */
+        if (is_src)
+            ret = -errno;
+        else
+            ret = 0;
+        goto out;
+    }
 
-        loc_wipe (&loc);
+    ret = syncop_dir_scan(subvol, &loc, GF_CLIENT_PID_SELF_HEALD, &args,
+                          afr_selfheal_entry_granular_dirent);
 
-        if (args.mismatch == _gf_true)
-                ret = -1;
+    loc_wipe(&loc);
 
-        return ret;
+    if (args.mismatch == _gf_true)
+        ret = -1;
+out:
+    if (args.frame)
+        AFR_STACK_DESTROY(args.frame);
+    return ret;
 }
 
 static int
-afr_selfheal_entry_do (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		       int source, unsigned char *sources,
-		       unsigned char *healed_sinks)
+afr_selfheal_entry_do(call_frame_t *frame, xlator_t *this, fd_t *fd, int source,
+                      unsigned char *sources, unsigned char *healed_sinks)
 {
-	int i                   = 0;
-	int ret                 = 0;
-        gf_boolean_t   mismatch = _gf_false;
-        afr_local_t   *local    = NULL;
-	afr_private_t *priv     = NULL;
-
-	priv = this->private;
-        local = frame->local;
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                AFR_MSG_SELF_HEAL_INFO, "performing entry selfheal on %s",
-		uuid_utoa (fd->inode->gfid));
-
-	for (i = 0; i < priv->child_count; i++) {
-                /* Expunge */
-		if (!healed_sinks[i])
-			continue;
-
-                if (!local->need_full_crawl)
-                /* Why call afr_selfheal_entry_granular() on a "healed sink",
-                 * given that it is the source that contains the granular
-                 * indices?
-                 * If the index for this directory is non-existent or empty on
-                 * this subvol (=> clear sink), then it will return early
-                 * without failure status.
-                 * If the index is non-empty and it is yet a 'healed sink', then
-                 * it is due to a split-brain in which case we anyway need to
-                 * crawl the indices/entry-changes/pargfid directory.
-                 */
-                        ret = afr_selfheal_entry_granular (frame, this, fd, i,
-                                                           _gf_false);
-                else
-                        ret = afr_selfheal_entry_do_subvol (frame, this, fd, i);
-
-                if (ret == -1) {
-                        /* gfid or type mismatch. */
-                        mismatch = _gf_true;
-                        ret = 0;
-                }
-                if (ret)
-                        break;
-	}
-
-        if (!ret && source != -1) {
-                /* Impunge */
-                if (local->need_full_crawl)
-                        ret = afr_selfheal_entry_do_subvol (frame, this, fd,
-                                                            source);
-                else
-                        ret = afr_selfheal_entry_granular (frame, this, fd,
-                                                           source, _gf_true);
+    int i = 0;
+    int ret = 0;
+    gf_boolean_t mismatch = _gf_false;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+           "performing entry selfheal on %s", uuid_utoa(fd->inode->gfid));
+
+    for (i = 0; i < priv->child_count; i++) {
+        /* Expunge */
+        if (!healed_sinks[i])
+            continue;
+
+        if (!local->need_full_crawl)
+            /* Why call afr_selfheal_entry_granular() on a "healed sink",
+             * given that it is the source that contains the granular
+             * indices?
+             * If the index for this directory is non-existent or empty on
+             * this subvol (=> clear sink), then it will return early
+             * without failure status.
+             * If the index is non-empty and it is yet a 'healed sink', then
+             * it is due to a split-brain in which case we anyway need to
+             * crawl the indices/entry-changes/pargfid directory.
+             */
+            ret = afr_selfheal_entry_granular(frame, this, fd, i, _gf_false);
+        else
+            ret = afr_selfheal_entry_do_subvol(frame, this, fd, i);
+
+        if (ret == -1) {
+            /* gfid or type mismatch. */
+            mismatch = _gf_true;
+            ret = 0;
         }
+        if (ret)
+            break;
+    }
 
-        if (mismatch == _gf_true)
-                /* undo pending will be skipped */
-                ret = -1;
-	return ret;
+    if (!ret && source != -1) {
+        /* Impunge */
+        if (local->need_full_crawl)
+            ret = afr_selfheal_entry_do_subvol(frame, this, fd, source);
+        else
+            ret = afr_selfheal_entry_granular(frame, this, fd, source,
+                                              _gf_true);
+    }
+
+    if (mismatch == _gf_true)
+        /* undo pending will be skipped */
+        ret = -1;
+    return ret;
 }
 
 static int
-__afr_selfheal_entry (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		      unsigned char *locked_on)
+__afr_selfheal_entry(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     unsigned char *locked_on)
 {
-	int                     ret                   = -1;
-	int                     source                = -1;
-	unsigned char          *sources               = NULL;
-	unsigned char          *sinks                 = NULL;
-	unsigned char          *data_lock             = NULL;
-        unsigned char          *postop_lock           = NULL;
-	unsigned char          *healed_sinks          = NULL;
-	unsigned char          *undid_pending         = NULL;
-	struct afr_reply       *locked_replies        = NULL;
-        afr_local_t            *local                 = NULL;
-	afr_private_t          *priv                  = NULL;
-        gf_boolean_t            did_sh                = _gf_true;
-
-	priv = this->private;
-        local = frame->local;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	undid_pending = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-        postop_lock = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-				    data_lock);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes could "
-                                      "be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid), ret,
-                                      this->name);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_entry_prepare (frame, this, fd->inode,
-                                                    data_lock, sources, sinks,
-                                                    healed_sinks,
-						    locked_replies, &source,
-                                                    NULL);
-                if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                local->need_full_crawl = afr_need_full_heal (this,
-                                                             locked_replies,
-                                                             source,
-                                                             healed_sinks,
-                                                         AFR_ENTRY_TRANSACTION);
-	}
-unlock:
-	afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-				data_lock, NULL);
-	if (ret < 0)
-		goto out;
+    int ret = -1;
+    int source = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *postop_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t did_sh = _gf_true;
+
+    priv = this->private;
+    local = frame->local;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+    postop_lock = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               data_lock);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes could "
+                         "be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, this->name);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
 
-        if (!did_sh)
-                goto out;
+        ret = __afr_selfheal_entry_prepare(frame, this, fd->inode, data_lock,
+                                           sources, sinks, healed_sinks,
+                                           locked_replies, &source, NULL);
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
+        }
 
-	ret = afr_selfheal_entry_do (frame, this, fd, source, sources,
-                                     healed_sinks);
-	if (ret)
-		goto out;
-
-        /* Take entrylks in xlator domain before doing post-op (undo-pending) in
-         * entry self-heal. This is to prevent a parallel name self-heal on
-         * an entry under @fd->inode from reading pending xattrs while it is
-         * being modified by SHD after entry sh below, given that
-         * name self-heal takes locks ONLY in xlator domain and is free to read
-         * pending changelog in the absence of the following locking.
-         */
-        ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-                                    postop_lock);
-        {
-                if (AFR_CMP (data_lock, postop_lock, priv->child_count) != 0) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "post-op after entry self-heal as %d "
-                                      "sub-volumes, as opposed to %d, "
-                                      "could be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret, AFR_COUNT (data_lock,
-                                      priv->child_count), this->name);
-                        ret = -ENOTCONN;
-                        goto postop_unlock;
-                }
-
-                ret = afr_selfheal_undo_pending (frame, this, fd->inode,
-                                                 sources, sinks, healed_sinks,
-                                                 undid_pending,
-                                                 AFR_ENTRY_TRANSACTION,
-                                                 locked_replies, postop_lock);
+        local->need_full_crawl = afr_need_full_heal(
+            this, locked_replies, source, healed_sinks, AFR_ENTRY_TRANSACTION);
+    }
+unlock:
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL, data_lock,
+                           NULL);
+    if (ret < 0)
+        goto out;
+
+    if (!did_sh)
+        goto out;
+
+    ret = afr_selfheal_entry_do(frame, this, fd, source, sources, healed_sinks);
+    if (ret)
+        goto out;
+
+    /* Take entrylks in xlator domain before doing post-op (undo-pending) in
+     * entry self-heal. This is to prevent a parallel name self-heal on
+     * an entry under @fd->inode from reading pending xattrs while it is
+     * being modified by SHD after entry sh below, given that
+     * name self-heal takes locks ONLY in xlator domain and is free to read
+     * pending changelog in the absence of the following locking.
+     */
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               postop_lock);
+    {
+        if (AFR_CMP(data_lock, postop_lock, priv->child_count) != 0) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "post-op after entry self-heal as %d "
+                         "sub-volumes, as opposed to %d, "
+                         "could be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret,
+                         AFR_COUNT(data_lock, priv->child_count), this->name);
+            ret = -ENOTCONN;
+            goto postop_unlock;
         }
+
+        afr_selfheal_restore_time(frame, this, fd->inode, source, healed_sinks,
+                                  locked_replies);
+        ret = afr_selfheal_undo_pending(
+            frame, this, fd->inode, sources, sinks, healed_sinks, undid_pending,
+            AFR_ENTRY_TRANSACTION, locked_replies, postop_lock);
+    }
 postop_unlock:
-        afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-                                postop_lock, NULL);
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL,
+                           postop_lock, NULL);
 out:
-        if (did_sh)
-                afr_log_selfheal (fd->inode->gfid, this, ret, "entry", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
-
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-	return ret;
+    if (did_sh)
+        afr_log_selfheal(fd->inode->gfid, this, ret, "entry", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
+
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
 }
 
-
 static fd_t *
-afr_selfheal_data_opendir (xlator_t *this, inode_t *inode)
+afr_selfheal_data_opendir(xlator_t *this, inode_t *inode)
 {
-	loc_t loc = {0,};
-	int ret = 0;
-	fd_t *fd = NULL;
-
-	fd = fd_create (inode, 0);
-	if (!fd)
-		return NULL;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	ret = syncop_opendir (this, &loc, fd, NULL, NULL);
-	if (ret) {
-		fd_unref (fd);
-		fd = NULL;
-	} else {
-		fd_bind (fd);
-	}
-
-	loc_wipe (&loc);
-        return fd;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
+    fd_t *fd = NULL;
+
+    fd = fd_create(inode, 0);
+    if (!fd)
+        return NULL;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    ret = syncop_opendir(this, &loc, fd, NULL, NULL);
+    if (ret) {
+        fd_unref(fd);
+        fd = NULL;
+    } else {
+        fd_bind(fd);
+    }
+
+    loc_wipe(&loc);
+    return fd;
 }
 
-
 int
-afr_selfheal_entry (call_frame_t *frame, xlator_t *this, inode_t *inode)
+afr_selfheal_entry(call_frame_t *frame, xlator_t *this, inode_t *inode)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *locked_on = NULL;
-	fd_t *fd = NULL;
-	int ret = 0;
-
-	priv = this->private;
-
-	fd = afr_selfheal_data_opendir (this, inode);
-	if (!fd)
-		return -EIO;
-
-	locked_on = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_tie_breaker_entrylk (frame, this, inode,
-	                                        priv->sh_domain, NULL,
-                                                locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes could "
-                                      "be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid), ret,
-                                      priv->sh_domain);
-			/* Either less than two subvols available, or another
-			   selfheal (from another server) is in progress. Skip
-			   for now in any case there isn't anything to do.
-			*/
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-                ret = __afr_selfheal_entry (frame, this, fd, locked_on);
-	}
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    fd_t *fd = NULL;
+    int ret = 0;
+
+    priv = this->private;
+
+    fd = afr_selfheal_data_opendir(this, inode);
+    if (!fd)
+        return -EIO;
+
+    locked_on = alloca0(priv->child_count);
+
+    ret = afr_selfheal_tie_breaker_entrylk(frame, this, inode, priv->sh_domain,
+                                           NULL, locked_on);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes could "
+                         "be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, priv->sh_domain);
+            /* Either less than two subvols available, or another
+               selfheal (from another server) is in progress. Skip
+               for now in any case there isn't anything to do.
+            */
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_entry(frame, this, fd, locked_on);
+    }
 unlock:
-	afr_selfheal_unentrylk (frame, this, inode, priv->sh_domain, NULL,
-                                locked_on, NULL);
+    afr_selfheal_unentrylk(frame, this, inode, priv->sh_domain, NULL, locked_on,
+                           NULL);
 
-	if (fd)
-		fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-metadata.c b/xlators/cluster/afr/src/afr-self-heal-metadata.c
index f23cf8ec6ee..03f43bad16e 100644
--- a/xlators/cluster/afr/src/afr-self-heal-metadata.c
+++ b/xlators/cluster/afr/src/afr-self-heal-metadata.c
@@ -8,109 +8,108 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
-#include "byte-order.h"
+#include <glusterfs/byte-order.h>
 #include "protocol-common.h"
-#include "events.h"
+#include <glusterfs/events.h>
 
-#define AFR_HEAL_ATTR (GF_SET_ATTR_UID|GF_SET_ATTR_GID|GF_SET_ATTR_MODE)
+#define AFR_HEAL_ATTR (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE)
 
 static gf_boolean_t
-_afr_ignorable_key_match (dict_t *d, char *k, data_t *val, void *mdata)
+_afr_ignorable_key_match(dict_t *d, char *k, data_t *val, void *mdata)
 {
-        return afr_is_xattr_ignorable (k);
+    return afr_is_xattr_ignorable(k);
 }
 
 void
-afr_delete_ignorable_xattrs (dict_t *xattr)
+afr_delete_ignorable_xattrs(dict_t *xattr)
 {
-        dict_foreach_match (xattr, _afr_ignorable_key_match, NULL,
-                            dict_remove_foreach_fn, NULL);
+    dict_foreach_match(xattr, _afr_ignorable_key_match, NULL,
+                       dict_remove_foreach_fn, NULL);
 }
 
 int
-__afr_selfheal_metadata_do (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                            int source, unsigned char *healed_sinks,
-                            struct afr_reply *locked_replies)
+__afr_selfheal_metadata_do(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                           int source, unsigned char *healed_sinks,
+                           struct afr_reply *locked_replies)
 {
-	int ret = -1;
-	loc_t loc = {0,};
-	dict_t *xattr = NULL;
-	dict_t *old_xattr = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-
-	priv = this->private;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                AFR_MSG_SELF_HEAL_INFO, "performing metadata selfheal on %s",
-		uuid_utoa (inode->gfid));
-
-	ret = syncop_getxattr (priv->children[source], &loc, &xattr, NULL,
-                               NULL, NULL);
-	if (ret < 0) {
-		ret = -EIO;
-                goto out;
-	}
-
-	afr_delete_ignorable_xattrs (xattr);
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (old_xattr) {
-                        dict_unref (old_xattr);
-                        old_xattr = NULL;
-                }
-
-		if (!healed_sinks[i])
-			continue;
-
-		ret = syncop_setattr (priv->children[i], &loc,
-				      &locked_replies[source].poststat,
-				      AFR_HEAL_ATTR, NULL, NULL, NULL, NULL);
-		if (ret)
-			healed_sinks[i] = 0;
-
-		ret = syncop_getxattr (priv->children[i], &loc, &old_xattr, 0,
-                                       NULL, NULL);
-		if (old_xattr) {
-			afr_delete_ignorable_xattrs (old_xattr);
-			ret = syncop_removexattr (priv->children[i], &loc, "",
-						  old_xattr, NULL);
-                        if (ret)
-                                healed_sinks[i] = 0;
-		}
-
-		ret = syncop_setxattr (priv->children[i], &loc, xattr, 0, NULL,
-                                       NULL);
-		if (ret)
-			healed_sinks[i] = 0;
-	}
-        ret = 0;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    dict_t *old_xattr = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    priv = this->private;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+           "performing metadata selfheal on %s", uuid_utoa(inode->gfid));
+
+    ret = syncop_getxattr(priv->children[source], &loc, &xattr, NULL, NULL,
+                          NULL);
+    if (ret < 0) {
+        ret = -EIO;
+        goto out;
+    }
+
+    afr_delete_ignorable_xattrs(xattr);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (old_xattr) {
+            dict_unref(old_xattr);
+            old_xattr = NULL;
+        }
+
+        if (!healed_sinks[i])
+            continue;
+
+        ret = syncop_setattr(priv->children[i], &loc,
+                             &locked_replies[source].poststat, AFR_HEAL_ATTR,
+                             NULL, NULL, NULL, NULL);
+        if (ret)
+            healed_sinks[i] = 0;
+
+        ret = syncop_getxattr(priv->children[i], &loc, &old_xattr, 0, NULL,
+                              NULL);
+        if (old_xattr) {
+            afr_delete_ignorable_xattrs(old_xattr);
+            ret = syncop_removexattr(priv->children[i], &loc, "", old_xattr,
+                                     NULL);
+            if (ret)
+                healed_sinks[i] = 0;
+        }
+
+        ret = syncop_setxattr(priv->children[i], &loc, xattr, 0, NULL, NULL);
+        if (ret)
+            healed_sinks[i] = 0;
+    }
+    ret = 0;
 
 out:
-	loc_wipe (&loc);
-	if (xattr)
-		dict_unref (xattr);
-        if (old_xattr)
-                dict_unref (old_xattr);
+    loc_wipe(&loc);
+    if (xattr)
+        dict_unref(xattr);
+    if (old_xattr)
+        dict_unref(old_xattr);
 
-	return ret;
+    return ret;
 }
 
 static uint64_t
 mtime_ns(struct iatt *ia)
 {
-        uint64_t ret;
+    uint64_t ret;
 
-        ret = (((uint64_t)(ia->ia_mtime)) * 1000000000)
-            + (uint64_t)(ia->ia_mtime_nsec);
+    ret = (((uint64_t)(ia->ia_mtime)) * 1000000000) +
+          (uint64_t)(ia->ia_mtime_nsec);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -123,382 +122,425 @@ mtime_ns(struct iatt *ia)
  * the source with the most recent modification date.
  */
 static int
-afr_dirtime_splitbrain_source (call_frame_t *frame, xlator_t *this,
-                               struct afr_reply *replies,
-                               unsigned char *locked_on)
+afr_dirtime_splitbrain_source(call_frame_t *frame, xlator_t *this,
+                              struct afr_reply *replies,
+                              unsigned char *locked_on)
 {
-        afr_private_t *priv  = NULL;
-        int            source = -1;
-        struct iatt    source_ia;
-        struct iatt    child_ia;
-        uint64_t       mtime = 0;
-        int            i;
-        int            ret   = -1;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!locked_on[i])
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                if (mtime_ns(&replies[i].poststat) <= mtime)
-                        continue;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    struct iatt source_ia;
+    struct iatt child_ia;
+    uint64_t mtime = 0;
+    int i;
+    int ret = -1;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!locked_on[i])
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        if (mtime_ns(&replies[i].poststat) <= mtime)
+            continue;
+
+        mtime = mtime_ns(&replies[i].poststat);
+        source = i;
+    }
+
+    if (source == -1)
+        goto out;
+
+    source_ia = replies[source].poststat;
+    if (source_ia.ia_type != IA_IFDIR)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source)
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        child_ia = replies[i].poststat;
+
+        if (!IA_EQUAL(source_ia, child_ia, gfid) ||
+            !IA_EQUAL(source_ia, child_ia, type) ||
+            !IA_EQUAL(source_ia, child_ia, prot) ||
+            !IA_EQUAL(source_ia, child_ia, uid) ||
+            !IA_EQUAL(source_ia, child_ia, gid) ||
+            !afr_xattrs_are_equal(replies[source].xdata, replies[i].xdata))
+            goto out;
+    }
+
+    /*
+     * Metadata split brain is just about [amc]time
+     * We return our source.
+     */
+    ret = source;
+out:
+    return ret;
+}
 
-                mtime = mtime_ns(&replies[i].poststat);
-                source = i;
+static int
+__afr_selfheal_metadata_mark_pending_xattrs(call_frame_t *frame, xlator_t *this,
+                                            inode_t *inode,
+                                            struct afr_reply *replies,
+                                            unsigned char *sources)
+{
+    int ret = 0;
+    int i = 0;
+    int m_idx = 0;
+    afr_private_t *priv = NULL;
+    int raw[AFR_NUM_CHANGE_LOGS] = {0};
+    dict_t *xattr = NULL;
+
+    priv = this->private;
+    m_idx = afr_index_for_transaction_type(AFR_METADATA_TRANSACTION);
+    raw[m_idx] = 1;
+
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i])
+            continue;
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], raw,
+                                  sizeof(int) * AFR_NUM_CHANGE_LOGS);
+        if (ret) {
+            ret = -1;
+            goto out;
         }
-
-        if (source == -1)
-                goto out;
-
-        source_ia = replies[source].poststat;
-        if (source_ia.ia_type != IA_IFDIR)
-                goto out;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == source)
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                child_ia = replies[i].poststat;
-
-                if (!IA_EQUAL(source_ia, child_ia, gfid) ||
-                    !IA_EQUAL(source_ia, child_ia, type) ||
-                    !IA_EQUAL(source_ia, child_ia, prot) ||
-                    !IA_EQUAL(source_ia, child_ia, uid) ||
-                    !IA_EQUAL(source_ia, child_ia, gid) ||
-                    !afr_xattrs_are_equal (replies[source].xdata,
-                                           replies[i].xdata))
-                        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        ret = afr_selfheal_post_op(frame, this, inode, i, xattr, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, AFR_MSG_SELF_HEAL_INFO,
+                   "Failed to set pending metadata xattr on child %d for %s", i,
+                   uuid_utoa(inode->gfid));
+            goto out;
         }
+    }
+
+    afr_replies_wipe(replies, priv->child_count);
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
 
-        /*
-         * Metadata split brain is just about [amc]time
-         * We return our source.
-         */
-        ret = source;
 out:
-        return ret;
+    if (xattr)
+        dict_unref(xattr);
+    return ret;
 }
 
-
 /*
  * Look for mismatching uid/gid or mode or user xattrs even if
  * AFR xattrs don't say so, and pick one arbitrarily as winner. */
 
 static int
-__afr_selfheal_metadata_finalize_source (call_frame_t *frame, xlator_t *this,
-                                         inode_t *inode,
-                                         unsigned char *sources,
-                                         unsigned char *sinks,
-					 unsigned char *healed_sinks,
-					 unsigned char *undid_pending,
-					 unsigned char *locked_on,
-					 struct afr_reply *replies)
+__afr_selfheal_metadata_finalize_source(call_frame_t *frame, xlator_t *this,
+                                        inode_t *inode, unsigned char *sources,
+                                        unsigned char *sinks,
+                                        unsigned char *healed_sinks,
+                                        unsigned char *undid_pending,
+                                        unsigned char *locked_on,
+                                        struct afr_reply *replies)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	struct iatt srcstat = {0, };
-	int source = -1;
-	int sources_count = 0;
-
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-	    || !sources_count) {
-
-                source = afr_mark_split_brain_source_sinks (frame, this, inode,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                      AFR_METADATA_TRANSACTION);
-                if (source >= 0) {
-                        _afr_fav_child_reset_sink_xattrs (frame, this, inode,
-                                                         source, healed_sinks,
-                                                         undid_pending,
-                                                       AFR_METADATA_TRANSACTION,
-                                                         locked_on, replies);
-                        goto out;
-                }
-
-		/* If this is a directory mtime/ctime only split brain
-		   use the most recent */
-		source = afr_dirtime_splitbrain_source (frame, this,
-							replies, locked_on);
-		if (source != -1) {
-		        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_SPLIT_BRAIN, "clear time "
-				"split brain on %s",
-				 uuid_utoa (replies[source].poststat.ia_gfid));
-			sources[source] = 1;
-			healed_sinks[source] = 0;
-                        goto out;
-		}
-
-		if (!priv->metadata_splitbrain_forced_heal) {
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;"
-                                  "type=metadata;file=%s",
-                                  this->name, uuid_utoa(inode->gfid));
-			return -EIO;
-		}
-
-		/* Metadata split brain, select one subvol
-		   arbitrarily */
-		for (i = 0; i < priv->child_count; i++) {
-			if (locked_on[i] && healed_sinks[i]) {
-				sources[i] = 1;
-				healed_sinks[i] = 0;
-				break;
-			}
-		}
-	}
-
-        /* No split brain at this point. If we were called from
-         * afr_heal_splitbrain_file(), abort.*/
-        if (afr_dict_contains_heal_op(frame))
-                return -EIO;
-
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_METADATA_TRANSACTION);
-        srcstat = replies[source].poststat;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!sources[i] || i == source)
-			continue;
-		if (!IA_EQUAL (srcstat, replies[i].poststat, type) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, uid) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, gid) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, prot)) {
-                        gf_msg_debug (this->name, 0, "%s: iatt mismatch "
-                                      "for source(%d) vs (%d)",
-                                      uuid_utoa
-                                      (replies[source].poststat.ia_gfid),
-                                      source, i);
-			sources[i] = 0;
-			healed_sinks[i] = 1;
-		}
-	}
-
-        for (i =0; i < priv->child_count; i++) {
-		if (!sources[i] || i == source)
-			continue;
-                if (!afr_xattrs_are_equal (replies[source].xdata,
-                                           replies[i].xdata)) {
-                        gf_msg_debug (this->name, 0, "%s: xattr mismatch "
-                                      "for source(%d) vs (%d)",
-                                      uuid_utoa
-                                      (replies[source].poststat.ia_gfid),
-                                      source, i);
-                        sources[i] = 0;
-                        healed_sinks[i] = 1;
-                }
+    int i = 0;
+    afr_private_t *priv = NULL;
+    struct iatt srcstat = {
+        0,
+    };
+    int source = -1;
+    int sources_count = 0;
+    int ret = 0;
+
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count) {
+        source = afr_mark_split_brain_source_sinks(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, AFR_METADATA_TRANSACTION);
+        if (source >= 0) {
+            _afr_fav_child_reset_sink_xattrs(
+                frame, this, inode, source, healed_sinks, undid_pending,
+                AFR_METADATA_TRANSACTION, locked_on, replies);
+            goto out;
+        }
+
+        /* If this is a directory mtime/ctime only split brain
+           use the most recent */
+        source = afr_dirtime_splitbrain_source(frame, this, replies, locked_on);
+        if (source != -1) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SPLIT_BRAIN,
+                   "clear time "
+                   "split brain on %s",
+                   uuid_utoa(replies[source].poststat.ia_gfid));
+            sources[source] = 1;
+            healed_sinks[source] = 0;
+            goto out;
+        }
+
+        if (!priv->metadata_splitbrain_forced_heal) {
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "client-pid=%d;"
+                     "subvol=%s;"
+                     "type=metadata;file=%s",
+                     this->ctx->cmd_args.client_pid, this->name,
+                     uuid_utoa(inode->gfid));
+            return -EIO;
         }
 
+        /* Metadata split brain, select one subvol
+           arbitrarily */
+        for (i = 0; i < priv->child_count; i++) {
+            if (locked_on[i] && healed_sinks[i]) {
+                sources[i] = 1;
+                healed_sinks[i] = 0;
+                break;
+            }
+        }
+    }
+
+    /* No split brain at this point. If we were called from
+     * afr_heal_splitbrain_file(), abort.*/
+    if (afr_dict_contains_heal_op(frame))
+        return -EIO;
+
+    source = afr_choose_source_by_policy(priv, sources,
+                                         AFR_METADATA_TRANSACTION);
+    srcstat = replies[source].poststat;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] || i == source)
+            continue;
+        if (!IA_EQUAL(srcstat, replies[i].poststat, type) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, uid) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, gid) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, prot)) {
+            gf_msg_debug(this->name, 0,
+                         "%s: iatt mismatch "
+                         "for source(%d) vs (%d)",
+                         uuid_utoa(replies[source].poststat.ia_gfid), source,
+                         i);
+            sources[i] = 0;
+            healed_sinks[i] = 1;
+        }
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] || i == source)
+            continue;
+        if (!afr_xattrs_are_equal(replies[source].xdata, replies[i].xdata)) {
+            gf_msg_debug(this->name, 0,
+                         "%s: xattr mismatch "
+                         "for source(%d) vs (%d)",
+                         uuid_utoa(replies[source].poststat.ia_gfid), source,
+                         i);
+            sources[i] = 0;
+            healed_sinks[i] = 1;
+        }
+    }
+    if ((sources_count == priv->child_count) && (source > -1) &&
+        (AFR_COUNT(healed_sinks, priv->child_count) != 0)) {
+        ret = __afr_selfheal_metadata_mark_pending_xattrs(frame, this, inode,
+                                                          replies, sources);
+        if (ret < 0)
+            return ret;
+    }
 out:
-        afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-	return source;
+    afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+    return source;
 }
 
-
 int
-__afr_selfheal_metadata_prepare (call_frame_t *frame, xlator_t *this, inode_t *inode,
-				 unsigned char *locked_on, unsigned char *sources,
-				 unsigned char *sinks, unsigned char *healed_sinks,
-                                 unsigned char *undid_pending,
-				 struct afr_reply *replies, gf_boolean_t *pflag)
+__afr_selfheal_metadata_prepare(call_frame_t *frame, xlator_t *this,
+                                inode_t *inode, unsigned char *locked_on,
+                                unsigned char *sources, unsigned char *sinks,
+                                unsigned char *healed_sinks,
+                                unsigned char *undid_pending,
+                                struct afr_reply *replies, unsigned char *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-	int i = 0;
-        uint64_t *witness = NULL;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    uint64_t *witness = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-        if (ret)
-                return ret;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-        ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_METADATA_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-        /* If any source has witness, pick first
-         * witness source and make everybody else sinks */
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i] && witness[i]) {
-                        source = i;
-                        break;
-                }
-        }
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+    if (ret)
+        return ret;
 
-        if (source != -1) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (i != source && sources[i]) {
-                                sources[i] = 0;
-                                healed_sinks[i] = 1;
-                        }
-                }
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_METADATA_TRANSACTION, locked_on,
+                                      sources, sinks, witness, pflag);
+    if (ret)
+        return ret;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    /* If any source has witness, pick first
+     * witness source and make everybody else sinks */
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i] && witness[i]) {
+            source = i;
+            break;
         }
+    }
 
-	source = __afr_selfheal_metadata_finalize_source (frame, this, inode,
-                                                          sources, sinks,
-                                                          healed_sinks,
-                                                          undid_pending,
-                                                          locked_on, replies);
+    if (source != -1) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (i != source && sources[i]) {
+                sources[i] = 0;
+                healed_sinks[i] = 1;
+            }
+        }
+    }
 
-	if (source < 0)
-		return -EIO;
+    source = __afr_selfheal_metadata_finalize_source(
+        frame, this, inode, sources, sinks, healed_sinks, undid_pending,
+        locked_on, replies);
 
-	return source;
-}
+    if (source < 0)
+        return -EIO;
 
-int
-afr_selfheal_metadata (call_frame_t *frame, xlator_t *this, inode_t *inode)
-{
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *data_lock = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *undid_pending = NULL;
-	struct afr_reply *locked_replies = NULL;
-        gf_boolean_t did_sh = _gf_true;
-	int source = -1;
-
-	priv = this->private;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	undid_pending = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-				    LLONG_MAX - 1, 0, data_lock);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_metadata_prepare (frame, this, inode,
-                                                       data_lock, sources,
-                                                       sinks, healed_sinks,
-                                                       undid_pending,
-						       locked_replies, NULL);
-		if (ret < 0)
-			goto unlock;
-
-		source = ret;
-
-                if (AFR_COUNT (healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                ret = __afr_selfheal_metadata_do (frame, this, inode, source,
-                                                  healed_sinks, locked_replies);
-                if (ret)
-                        goto unlock;
-
-                /* Restore atime/mtime for files that don't need data heal as
-                 * restoring timestamps happens only as a part of data-heal.
-                 */
-                if (!IA_ISREG (locked_replies[source].poststat.ia_type))
-                        afr_selfheal_restore_time (frame, this, inode, source,
-                                                  healed_sinks, locked_replies);
-
-                ret = afr_selfheal_undo_pending (frame, this, inode, sources,
-                                                 sinks, healed_sinks,
-                                                 undid_pending,
-                                                 AFR_METADATA_TRANSACTION,
-                                                 locked_replies, data_lock);
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, inode, this->name,
-				LLONG_MAX -1, 0, data_lock);
-
-        if (did_sh)
-                afr_log_selfheal (inode->gfid, this, ret, "metadata", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
-
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-	return ret;
+    return source;
 }
 
 int
-afr_selfheal_metadata_by_stbuf (xlator_t *this, struct iatt *stbuf)
+afr_selfheal_metadata(call_frame_t *frame, xlator_t *this, inode_t *inode)
 {
-        inode_t      *inode      = NULL;
-        inode_t      *link_inode = NULL;
-        call_frame_t *frame      = NULL;
-        int          ret         = 0;
-
-        if (gf_uuid_is_null (stbuf->ia_gfid)) {
-                ret = -EINVAL;
-                goto out;
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    gf_boolean_t did_sh = _gf_true;
+    int source = -1;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                               data_lock);
+    {
+        if (ret < priv->child_count) {
+            ret = -ENOTCONN;
+            goto unlock;
         }
 
-        inode = inode_new (this->itable);
-        if (!inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        ret = __afr_selfheal_metadata_prepare(
+            frame, this, inode, data_lock, sources, sinks, healed_sinks,
+            undid_pending, locked_replies, NULL);
+        if (ret < 0)
+            goto unlock;
 
-        link_inode = inode_link (inode, NULL, NULL, stbuf);
-        if (!link_inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        source = ret;
 
-        frame = afr_frame_create (this);
-        if (!frame) {
-                ret = -ENOMEM;
-                goto out;
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
         }
 
-        ret = afr_selfheal_metadata (frame, this, link_inode);
+        ret = __afr_selfheal_metadata_do(frame, this, inode, source,
+                                         healed_sinks, locked_replies);
+        if (ret)
+            goto unlock;
+
+        afr_selfheal_restore_time(frame, this, inode, source, healed_sinks,
+                                  locked_replies);
+
+        ret = afr_selfheal_undo_pending(
+            frame, this, inode, sources, sinks, healed_sinks, undid_pending,
+            AFR_METADATA_TRANSACTION, locked_replies, data_lock);
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                           data_lock);
+
+    if (did_sh)
+        afr_log_selfheal(inode->gfid, this, ret, "metadata", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
+
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
+}
+
+int
+afr_selfheal_metadata_by_stbuf(xlator_t *this, struct iatt *stbuf)
+{
+    inode_t *inode = NULL;
+    inode_t *link_inode = NULL;
+    call_frame_t *frame = NULL;
+    int ret = 0;
+
+    if (gf_uuid_is_null(stbuf->ia_gfid)) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    inode = inode_new(this->itable);
+    if (!inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    link_inode = inode_link(inode, NULL, NULL, stbuf);
+    if (!link_inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    ret = afr_selfheal_metadata(frame, this, link_inode);
 out:
-        if (inode)
-                inode_unref (inode);
-        if (link_inode)
-                inode_unref (link_inode);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        return ret;
+    if (inode)
+        inode_unref(inode);
+    if (link_inode)
+        inode_unref(link_inode);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-name.c b/xlators/cluster/afr/src/afr-self-heal-name.c
index 352d151207e..834aac86d48 100644
--- a/xlators/cluster/afr/src/afr-self-heal-name.c
+++ b/xlators/cluster/afr/src/afr-self-heal-name.c
@@ -8,690 +8,609 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "events.h"
+#include <glusterfs/events.h>
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "afr-messages.h"
 
 int
-__afr_selfheal_assign_gfid (xlator_t *this, inode_t *parent, uuid_t pargfid,
-                            const char *bname, inode_t *inode,
-                            struct afr_reply *replies, void *gfid,
-                            unsigned char *locked_on, int source,
-                            gf_boolean_t is_gfid_absent)
+__afr_selfheal_assign_gfid(xlator_t *this, inode_t *parent, uuid_t pargfid,
+                           const char *bname, inode_t *inode,
+                           struct afr_reply *replies, void *gfid,
+                           unsigned char *locked_on, int source,
+                           unsigned char *sources, gf_boolean_t is_gfid_absent,
+                           int *gfid_idx)
 {
-	int             ret          = 0;
-        int             up_count     = 0;
-        int             locked_count = 0;
-	afr_private_t  *priv         = NULL;
+    int ret = 0;
+    int up_count = 0;
+    int locked_count = 0;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	gf_uuid_copy (parent->gfid, pargfid);
+    gf_uuid_copy(parent->gfid, pargfid);
 
-        if (is_gfid_absent) {
-                /* Ensure all children of AFR are up before performing gfid heal, to
-                 * guard against the possibility of gfid split brain. */
+    if (is_gfid_absent) {
+        /* Ensure all children of AFR are up before performing gfid heal, to
+         * guard against the possibility of gfid split brain. */
 
-                up_count = AFR_COUNT (priv->child_up, priv->child_count);
-                if (up_count != priv->child_count) {
-                        ret = -EIO;
-                        goto out;
-                }
+        up_count = AFR_COUNT(priv->child_up, priv->child_count);
+        if (up_count != priv->child_count) {
+            ret = -EIO;
+            goto out;
+        }
 
-                locked_count = AFR_COUNT (locked_on, priv->child_count);
-                if (locked_count != priv->child_count) {
-                        ret = -EIO;
-                        goto out;
-                }
+        locked_count = AFR_COUNT(locked_on, priv->child_count);
+        if (locked_count != priv->child_count) {
+            ret = -EIO;
+            goto out;
         }
+    }
 
-        afr_lookup_and_heal_gfid (this, parent, bname, inode, replies, source,
-                                  gfid);
+    ret = afr_lookup_and_heal_gfid(this, parent, bname, inode, replies, source,
+                                   sources, gfid, gfid_idx);
 
 out:
-	return ret;
+    return ret;
 }
 
 int
-__afr_selfheal_name_impunge (call_frame_t *frame, xlator_t *this,
-                             inode_t *parent, uuid_t pargfid,
-                             const char *bname, inode_t *inode,
-                             struct afr_reply *replies, int gfid_idx)
+__afr_selfheal_name_impunge(call_frame_t *frame, xlator_t *this,
+                            inode_t *parent, uuid_t pargfid, const char *bname,
+                            inode_t *inode, struct afr_reply *replies,
+                            int gfid_idx)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-        int ret = 0;
-        unsigned char *sources = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int ret = 0;
+    unsigned char *sources = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-	sources = alloca0 (priv->child_count);
+    sources = alloca0(priv->child_count);
 
-	gf_uuid_copy (parent->gfid, pargfid);
+    gf_uuid_copy(parent->gfid, pargfid);
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[gfid_idx].poststat.ia_gfid) == 0) {
-                        sources[i] = 1;
-			continue;
-                }
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[gfid_idx].poststat.ia_gfid) == 0) {
+            sources[i] = 1;
+            continue;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i])
+            continue;
 
-		ret |= afr_selfheal_recreate_entry (frame, i, gfid_idx, sources,
-                                                    parent, bname, inode,
-                                                    replies);
-	}
+        ret |= afr_selfheal_recreate_entry(frame, i, gfid_idx, sources, parent,
+                                           bname, inode, replies);
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-__afr_selfheal_name_expunge (xlator_t *this, inode_t *parent, uuid_t pargfid,
-                             const char *bname, inode_t *inode,
-			     struct afr_reply *replies)
-{
-	loc_t loc = {0, };
-	int i = 0;
-	afr_private_t *priv = NULL;
-	char g[64];
-	int ret = 0;
-
-	priv = this->private;
-
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, pargfid);
-	loc.name = bname;
-	loc.inode = inode_ref (inode);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-		if (replies[i].op_ret)
-			continue;
-
-		switch (replies[i].poststat.ia_type) {
-		case IA_IFDIR:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-			        "expunging dir %s/%s (%s) on %s",
-			        uuid_utoa (pargfid), bname,
-			        uuid_utoa_r (replies[i].poststat.ia_gfid, g),
-			        priv->children[i]->name);
-
-			ret |= syncop_rmdir (priv->children[i], &loc, 1, NULL,
-                                             NULL);
-			break;
-		default:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-		                "expunging file %s/%s (%s) on %s",
-			        uuid_utoa (pargfid), bname,
-			        uuid_utoa_r (replies[i].poststat.ia_gfid, g),
-			        priv->children[i]->name);
-
-			ret |= syncop_unlink (priv->children[i], &loc, NULL,
-                                              NULL);
-			break;
-		}
-	}
-
-	loc_wipe (&loc);
-
-	return ret;
-
-}
-
-/* This function is to be called after ensuring that there is no gfid mismatch
- * for the inode across multiple sources
- */
-static int
-afr_selfheal_gfid_idx_get (xlator_t *this, struct afr_reply *replies,
-                           unsigned char *sources)
+__afr_selfheal_name_expunge(xlator_t *this, inode_t *parent, uuid_t pargfid,
+                            const char *bname, inode_t *inode,
+                            struct afr_reply *replies)
 {
-        int             i        =  0;
-        int             gfid_idx = -1;
-        afr_private_t  *priv     =  NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int ret = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if (!sources[i])
-                        continue;
+        if (replies[i].op_ret)
+            continue;
 
-                if (gf_uuid_is_null (replies[i].poststat.ia_gfid))
-                        continue;
+        ret |= afr_selfheal_entry_delete(this, parent, bname, inode, i,
+                                         replies);
+    }
 
-                gfid_idx = i;
-                break;
-        }
-        return gfid_idx;
+    return ret;
 }
 
 static gf_boolean_t
-afr_selfheal_name_need_heal_check (xlator_t *this, struct afr_reply *replies)
+afr_selfheal_name_need_heal_check(xlator_t *this, struct afr_reply *replies)
 {
-        int             i           = 0;
-	int             first_idx   = -1;
-        gf_boolean_t    need_heal   = _gf_false;
-        afr_private_t  *priv        = NULL;
-
-        priv = this->private;
+    int i = 0;
+    int first_idx = -1;
+    gf_boolean_t need_heal = _gf_false;
+    afr_private_t *priv = NULL;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
+    priv = this->private;
 
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA))
-                        need_heal = _gf_true;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-		if (first_idx == -1) {
-			first_idx = i;
-			continue;
-		}
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA))
+            need_heal = _gf_true;
 
-		if (replies[i].op_ret != replies[first_idx].op_ret)
-			need_heal = _gf_true;
+        if (first_idx == -1) {
+            first_idx = i;
+            continue;
+        }
 
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[first_idx].poststat.ia_gfid))
-			need_heal = _gf_true;
+        if (replies[i].op_ret != replies[first_idx].op_ret)
+            need_heal = _gf_true;
 
-                if ((replies[i].op_ret == 0) &&
-                    (gf_uuid_is_null(replies[i].poststat.ia_gfid)))
-                        need_heal = _gf_true;
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[first_idx].poststat.ia_gfid))
+            need_heal = _gf_true;
 
-	}
+        if ((replies[i].op_ret == 0) &&
+            (gf_uuid_is_null(replies[i].poststat.ia_gfid)))
+            need_heal = _gf_true;
+    }
 
-        return need_heal;
+    return need_heal;
 }
 
 static int
-afr_selfheal_name_type_mismatch_check (xlator_t *this, struct afr_reply *replies,
-                                       int source, unsigned char *sources,
-                                       uuid_t pargfid, const char *bname)
+afr_selfheal_name_type_mismatch_check(xlator_t *this, struct afr_reply *replies,
+                                      int source, unsigned char *sources,
+                                      uuid_t pargfid, const char *bname)
 {
-        int             i           = 0;
-        int             type_idx    = -1;
-        ia_type_t       inode_type  = IA_INVAL;
-        ia_type_t       inode_type1 = IA_INVAL;
-        afr_private_t  *priv        = NULL;
+    int i = 0;
+    int type_idx = -1;
+    ia_type_t inode_type = IA_INVAL;
+    ia_type_t inode_type1 = IA_INVAL;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-                if (replies[i].poststat.ia_type == IA_INVAL)
-                        continue;
+        if (replies[i].poststat.ia_type == IA_INVAL)
+            continue;
 
-                if (inode_type == IA_INVAL) {
-                        inode_type = replies[i].poststat.ia_type;
-                        type_idx = i;
-                        continue;
-                }
-                inode_type1 = replies[i].poststat.ia_type;
-                if (sources[i] || source == -1) {
-                        if ((sources[type_idx] || source == -1) &&
-                            (inode_type != inode_type1)) {
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        AFR_MSG_SPLIT_BRAIN,
-                                        "Type mismatch for <gfid:%s>/%s: "
-                                        "%s on %s and %s on %s",
-                                        uuid_utoa(pargfid), bname,
-                                        gf_inode_type_to_str (inode_type1),
-                                        priv->children[i]->name,
-                                        gf_inode_type_to_str (inode_type),
-                                        priv->children[type_idx]->name);
-                                gf_event (EVENT_AFR_SPLIT_BRAIN,
-                                         "subvol=%s;type=file;"
-                                         "file=<gfid:%s>/%s;count=2;"
-                                         "child-%d=%s;type-%d=%s;child-%d=%s;"
-                                         "type-%d=%s", this->name,
-                                         uuid_utoa (pargfid), bname, i,
-                                         priv->children[i]->name, i,
-                                         gf_inode_type_to_str (inode_type1),
-                                         type_idx,
-                                         priv->children[type_idx]->name,
-                                         type_idx,
-                                         gf_inode_type_to_str (inode_type));
-                                return -EIO;
-                        }
-                        inode_type = replies[i].poststat.ia_type;
-                        type_idx = i;
-                }
+        if (inode_type == IA_INVAL) {
+            inode_type = replies[i].poststat.ia_type;
+            type_idx = i;
+            continue;
         }
-        return 0;
+        inode_type1 = replies[i].poststat.ia_type;
+        if (sources[i] || source == -1) {
+            if ((sources[type_idx] || source == -1) &&
+                (inode_type != inode_type1)) {
+                gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Type mismatch for <gfid:%s>/%s: "
+                       "%s on %s and %s on %s",
+                       uuid_utoa(pargfid), bname,
+                       gf_inode_type_to_str(inode_type1),
+                       priv->children[i]->name,
+                       gf_inode_type_to_str(inode_type),
+                       priv->children[type_idx]->name);
+                gf_event(EVENT_AFR_SPLIT_BRAIN,
+                         "client-pid=%d;"
+                         "subvol=%s;type=file;"
+                         "file=<gfid:%s>/%s;count=2;"
+                         "child-%d=%s;type-%d=%s;child-%d=%s;"
+                         "type-%d=%s",
+                         this->ctx->cmd_args.client_pid, this->name,
+                         uuid_utoa(pargfid), bname, i, priv->children[i]->name,
+                         i, gf_inode_type_to_str(inode_type1), type_idx,
+                         priv->children[type_idx]->name, type_idx,
+                         gf_inode_type_to_str(inode_type));
+                return -EIO;
+            }
+            inode_type = replies[i].poststat.ia_type;
+            type_idx = i;
+        }
+    }
+    return 0;
 }
 
 static int
-afr_selfheal_name_gfid_mismatch_check (xlator_t *this, struct afr_reply *replies,
-                                       int source, unsigned char *sources,
-                                       int *gfid_idx, uuid_t pargfid,
-                                       const char *bname, inode_t *inode,
-                                       unsigned char *locked_on, dict_t *xdata)
+afr_selfheal_name_gfid_mismatch_check(xlator_t *this, struct afr_reply *replies,
+                                      int source, unsigned char *sources,
+                                      int *gfid_idx, uuid_t pargfid,
+                                      const char *bname, inode_t *inode,
+                                      unsigned char *locked_on, dict_t *xdata)
 {
-        int             i             = 0;
-	int             gfid_idx_iter = -1;
-        int             ret           = -1;
-        void           *gfid          = NULL;
-        void           *gfid1         = NULL;
-        afr_private_t  *priv          = NULL;
-
-        priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-
-		if (gf_uuid_is_null (replies[i].poststat.ia_gfid))
-			continue;
-
-		if (!gfid) {
-			gfid = &replies[i].poststat.ia_gfid;
-			gfid_idx_iter = i;
-			continue;
-		}
-
-                gfid1 = &replies[i].poststat.ia_gfid;
-		if (sources[i] || source == -1) {
-			if ((sources[gfid_idx_iter] || source == -1) &&
-			    gf_uuid_compare (gfid, gfid1)) {
-                                ret = afr_gfid_split_brain_source (this,
-                                                                   replies,
-                                                                   inode,
-                                                                   pargfid,
-                                                                   bname,
-                                                                   gfid_idx_iter,
-                                                                   i, locked_on,
-                                                                   gfid_idx,
-                                                                   xdata);
-                                if (!ret && *gfid_idx >= 0) {
-                                        ret = dict_set_str (xdata,
-                                                             "gfid-heal-msg",
-                                                             "GFID split-brain "
-                                                             "resolved");
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                        GF_LOG_ERROR, 0,
-                                                        AFR_MSG_DICT_SET_FAILED,
-                                                        "Error setting gfid-"
-                                                        "heal-msg dict");
-                                }
-                                return ret;
-			}
-                        gfid = &replies[i].poststat.ia_gfid;
-			gfid_idx_iter = i;
-		}
-	}
-
-        *gfid_idx = gfid_idx_iter;
-        return 0;
+    int i = 0;
+    int gfid_idx_iter = -1;
+    int ret = -1;
+    void *gfid = NULL;
+    void *gfid1 = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
+
+        if (gf_uuid_is_null(replies[i].poststat.ia_gfid))
+            continue;
+
+        if (!gfid) {
+            gfid = &replies[i].poststat.ia_gfid;
+            gfid_idx_iter = i;
+            continue;
+        }
+
+        gfid1 = &replies[i].poststat.ia_gfid;
+        if (sources[i] || source == -1) {
+            if ((sources[gfid_idx_iter] || source == -1) &&
+                gf_uuid_compare(gfid, gfid1)) {
+                ret = afr_gfid_split_brain_source(this, replies, inode, pargfid,
+                                                  bname, gfid_idx_iter, i,
+                                                  locked_on, gfid_idx, xdata);
+                if (!ret && *gfid_idx >= 0) {
+                    ret = dict_set_sizen_str_sizen(xdata, "gfid-heal-msg",
+                                                   "GFID split-brain resolved");
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error setting gfid-"
+                               "heal-msg dict");
+                }
+                return ret;
+            }
+            gfid = &replies[i].poststat.ia_gfid;
+            gfid_idx_iter = i;
+        }
+    }
+
+    *gfid_idx = gfid_idx_iter;
+    return 0;
 }
 
 static gf_boolean_t
-afr_selfheal_name_source_empty_check (xlator_t *this, struct afr_reply *replies,
-                                      unsigned char *sources, int source)
+afr_selfheal_name_source_empty_check(xlator_t *this, struct afr_reply *replies,
+                                     unsigned char *sources, int source)
 {
-	int             i               = 0;
-	afr_private_t  *priv            = NULL;
-	gf_boolean_t    source_is_empty = _gf_true;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    gf_boolean_t source_is_empty = _gf_true;
 
-	priv = this->private;
+    priv = this->private;
 
-        if (source == -1) {
-                source_is_empty = _gf_false;
-                goto out;
-        }
+    if (source == -1) {
+        source_is_empty = _gf_false;
+        goto out;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
 
-                if (replies[i].op_ret == -1 && replies[i].op_errno == ENOENT)
-                        continue;
+        if (replies[i].op_ret == -1 && replies[i].op_errno == ENOENT)
+            continue;
 
-                source_is_empty = _gf_false;
-                break;
-	}
+        source_is_empty = _gf_false;
+        break;
+    }
 out:
-        return source_is_empty;
+    return source_is_empty;
 }
 
 int
-__afr_selfheal_name_do (call_frame_t *frame, xlator_t *this, inode_t *parent,
-                        uuid_t pargfid, const char *bname, inode_t *inode,
-                        unsigned char *sources, unsigned char *sinks,
-			unsigned char *healed_sinks, int source,
-			unsigned char *locked_on, struct afr_reply *replies,
-                        void *gfid_req, dict_t *xdata)
+__afr_selfheal_name_do(call_frame_t *frame, xlator_t *this, inode_t *parent,
+                       uuid_t pargfid, const char *bname, inode_t *inode,
+                       unsigned char *sources, unsigned char *sinks,
+                       unsigned char *healed_sinks, int source,
+                       unsigned char *locked_on, struct afr_reply *replies,
+                       void *gfid_req, dict_t *xdata)
 {
-	int             gfid_idx        = -1;
-        int             ret             = -1;
-	void           *gfid            = NULL;
-	gf_boolean_t    source_is_empty = _gf_true;
-	gf_boolean_t    need_heal       = _gf_false;
-        gf_boolean_t    is_gfid_absent  = _gf_false;
-
-        need_heal = afr_selfheal_name_need_heal_check (this, replies);
-	if (!need_heal)
-		return 0;
-
-        source_is_empty = afr_selfheal_name_source_empty_check (this, replies,
-                                                                sources,
-                                                                source);
-	if (source_is_empty) {
-		ret = __afr_selfheal_name_expunge (this, parent, pargfid,
-						    bname, inode, replies);
-                if (ret == -EIO)
-                        ret = -1;
-                return ret;
-        }
-
-        ret = afr_selfheal_name_type_mismatch_check (this, replies, source,
-                                                     sources, pargfid, bname);
-        if (ret)
-                return ret;
+    int gfid_idx = -1;
+    int ret = -1;
+    void *gfid = NULL;
+    gf_boolean_t source_is_empty = _gf_true;
+    gf_boolean_t need_heal = _gf_false;
+    gf_boolean_t is_gfid_absent = _gf_false;
+
+    need_heal = afr_selfheal_name_need_heal_check(this, replies);
+    if (!need_heal)
+        return 0;
 
-        ret = afr_selfheal_name_gfid_mismatch_check (this, replies, source,
-                                                     sources, &gfid_idx,
-                                                     pargfid, bname, inode,
-                                                     locked_on, xdata);
-        if (ret)
-                return ret;
+    source_is_empty = afr_selfheal_name_source_empty_check(this, replies,
+                                                           sources, source);
+    if (source_is_empty) {
+        ret = __afr_selfheal_name_expunge(this, parent, pargfid, bname, inode,
+                                          replies);
+        if (ret == -EIO)
+            ret = -1;
+        return ret;
+    }
 
-	if (gfid_idx == -1) {
-                if (!gfid_req || gf_uuid_is_null (gfid_req))
-                        return -1;
-                gfid = gfid_req;
-        } else {
-                gfid = &replies[gfid_idx].poststat.ia_gfid;
-        }
+    ret = afr_selfheal_name_type_mismatch_check(this, replies, source, sources,
+                                                pargfid, bname);
+    if (ret)
+        return ret;
 
-        is_gfid_absent = (gfid_idx == -1) ? _gf_true : _gf_false;
-	ret = __afr_selfheal_assign_gfid (this, parent, pargfid, bname, inode,
-                                          replies, gfid, locked_on, source,
-                                          is_gfid_absent);
-        if (ret)
-                return ret;
+    ret = afr_selfheal_name_gfid_mismatch_check(this, replies, source, sources,
+                                                &gfid_idx, pargfid, bname,
+                                                inode, locked_on, xdata);
+    if (ret)
+        return ret;
 
-        if (gfid_idx == -1) {
-                gfid_idx = afr_selfheal_gfid_idx_get (this, replies, sources);
-                if (gfid_idx == -1)
-                        return -1;
-        }
+    if (gfid_idx == -1) {
+        if (!gfid_req || gf_uuid_is_null(gfid_req))
+            return -1;
+        gfid = gfid_req;
+    } else {
+        gfid = &replies[gfid_idx].poststat.ia_gfid;
+        if (source == -1)
+            /* Either entry split-brain or dirty xattrs are present on parent.*/
+            source = gfid_idx;
+    }
+
+    is_gfid_absent = (gfid_idx == -1) ? _gf_true : _gf_false;
+    ret = __afr_selfheal_assign_gfid(this, parent, pargfid, bname, inode,
+                                     replies, gfid, locked_on, source, sources,
+                                     is_gfid_absent, &gfid_idx);
+    if (ret || (gfid_idx < 0))
+        return ret;
 
-	ret = __afr_selfheal_name_impunge (frame, this, parent, pargfid,
-                                           bname, inode, replies, gfid_idx);
-        if (ret == -EIO)
-                ret = -1;
+    ret = __afr_selfheal_name_impunge(frame, this, parent, pargfid, bname,
+                                      inode, replies, gfid_idx);
+    if (ret == -EIO)
+        ret = -1;
 
-        return ret;
+    return ret;
 }
 
-
 int
-__afr_selfheal_name_finalize_source (xlator_t *this, unsigned char *sources,
-				     unsigned char *healed_sinks,
-				     unsigned char *locked_on,
-                                     uint64_t *witness)
+__afr_selfheal_name_finalize_source(xlator_t *this, unsigned char *sources,
+                                    unsigned char *healed_sinks,
+                                    unsigned char *locked_on, uint64_t *witness)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
-
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count || afr_does_witness_exist (this, witness)) {
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-		return -1;
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (sources[i]) {
-			source = i;
-			break;
-		}
-	}
-
-	return source;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
+
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count || afr_does_witness_exist(this, witness)) {
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+        afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+        return -1;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            break;
+        }
+    }
+
+    return source;
 }
 
 int
-__afr_selfheal_name_prepare (call_frame_t *frame, xlator_t *this, inode_t *parent,
-			     uuid_t pargfid, unsigned char *locked_on,
-			     unsigned char *sources, unsigned char *sinks,
-			     unsigned char *healed_sinks, int *source_p)
+__afr_selfheal_name_prepare(call_frame_t *frame, xlator_t *this,
+                            inode_t *parent, uuid_t pargfid,
+                            unsigned char *locked_on, unsigned char *sources,
+                            unsigned char *sinks, unsigned char *healed_sinks,
+                            int *source_p)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        struct afr_reply *replies = NULL;
-        uint64_t *witness = NULL;
-
-	priv = this->private;
-
-        replies = alloca0 (priv->child_count * sizeof(*replies));
-
-	ret = afr_selfheal_unlocked_discover (frame, parent, pargfid, replies);
-	if (ret)
-		goto out;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_ENTRY_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           NULL);
-	if (ret)
-		goto out;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_name_finalize_source (this, sources,
-                                                      healed_sinks,
-						      locked_on, witness);
-	if (source < 0) {
-		/* If source is < 0 (typically split-brain), we perform a
-		   conservative merge of entries rather than erroring out */
-	}
-	*source_p = source;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    uint64_t *witness = NULL;
+
+    priv = this->private;
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+
+    ret = afr_selfheal_unlocked_discover(frame, parent, pargfid, replies);
+    if (ret)
+        goto out;
+
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_ENTRY_TRANSACTION, locked_on, sources,
+                                      sinks, witness, NULL);
+    if (ret)
+        goto out;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    source = __afr_selfheal_name_finalize_source(this, sources, healed_sinks,
+                                                 locked_on, witness);
+    if (source < 0) {
+        /* If source is < 0 (typically split-brain), we perform a
+           conservative merge of entries rather than erroring out */
+    }
+    *source_p = source;
 
 out:
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_selfheal_name_do (call_frame_t *frame, xlator_t *this, inode_t *parent,
-		      uuid_t pargfid, const char *bname, void *gfid_req,
-                      dict_t *xdata)
+afr_selfheal_name_do(call_frame_t *frame, xlator_t *this, inode_t *parent,
+                     uuid_t pargfid, const char *bname, void *gfid_req,
+                     dict_t *xdata)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *locked_on = NULL;
-	int source = -1;
-        struct afr_reply *replies = NULL;
-	int ret = -1;
-	inode_t *inode = NULL;
-        dict_t *xattr = NULL;
-
-        xattr = dict_new ();
-        if (!xattr)
-                return -ENOMEM;
-
-        ret = dict_set_int32 (xattr, GF_GFIDLESS_LOOKUP, 1);
-        if (ret) {
-                dict_unref (xattr);
-                return -1;
+    afr_private_t *priv = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *locked_on = NULL;
+    int source = -1;
+    struct afr_reply *replies = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+    dict_t *xattr = NULL;
+
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
+
+    ret = dict_set_int32_sizen(xattr, GF_GFIDLESS_LOOKUP, 1);
+    if (ret) {
+        dict_unref(xattr);
+        return -1;
+    }
+
+    priv = this->private;
+
+    locked_on = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+
+    ret = afr_selfheal_entrylk(frame, this, parent, this->name, bname,
+                               locked_on);
+    {
+        if (ret < priv->child_count) {
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_name_prepare(frame, this, parent, pargfid,
+                                          locked_on, sources, sinks,
+                                          healed_sinks, &source);
+        if (ret)
+            goto unlock;
+
+        inode = afr_selfheal_unlocked_lookup_on(frame, parent, bname, replies,
+                                                locked_on, xattr);
+        if (!inode) {
+            ret = -ENOMEM;
+            goto unlock;
         }
 
-	priv = this->private;
-
-	locked_on = alloca0 (priv->child_count);
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-
-	replies = alloca0 (priv->child_count * sizeof(*replies));
-
-	ret = afr_selfheal_entrylk (frame, this, parent, this->name, bname,
-				    locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_name_prepare (frame, this, parent, pargfid,
-						   locked_on, sources, sinks,
-						   healed_sinks, &source);
-		if (ret)
-			goto unlock;
-
-                inode = afr_selfheal_unlocked_lookup_on (frame, parent, bname,
-						         replies, locked_on,
-                                                         xattr);
-		if (!inode) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_name_do (frame, this, parent, pargfid,
-                                              bname, inode, sources, sinks,
-                                              healed_sinks, source, locked_on,
-                                              replies, gfid_req, xdata);
-	}
+        ret = __afr_selfheal_name_do(frame, this, parent, pargfid, bname, inode,
+                                     sources, sinks, healed_sinks, source,
+                                     locked_on, replies, gfid_req, xdata);
+    }
 unlock:
-	afr_selfheal_unentrylk (frame, this, parent, this->name, bname,
-				locked_on, NULL);
-	if (inode)
-		inode_unref (inode);
+    afr_selfheal_unentrylk(frame, this, parent, this->name, bname, locked_on,
+                           NULL);
+    if (inode)
+        inode_unref(inode);
 
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_selfheal_name_unlocked_inspect (call_frame_t *frame, xlator_t *this,
-				    inode_t *parent, uuid_t pargfid,
-				    const char *bname, gf_boolean_t *need_heal)
+afr_selfheal_name_unlocked_inspect(call_frame_t *frame, xlator_t *this,
+                                   inode_t *parent, uuid_t pargfid,
+                                   const char *bname, gf_boolean_t *need_heal)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	struct afr_reply *replies = NULL;
-	inode_t *inode = NULL;
-	int first_idx = -1;
-
-	priv = this->private;
-
-	replies = alloca0 (sizeof (*replies) * priv->child_count);
-
-	inode = afr_selfheal_unlocked_lookup_on (frame, parent, bname,
-						 replies, priv->child_up, NULL);
-	if (!inode)
-		return -ENOMEM;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA))
-                        *need_heal = _gf_true;
-
-		if (first_idx == -1) {
-			first_idx = i;
-			continue;
-		}
-
-		if (replies[i].op_ret != replies[first_idx].op_ret)
-			*need_heal = _gf_true;
-
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[first_idx].poststat.ia_gfid))
-			*need_heal = _gf_true;
-	}
-
-	if (inode)
-		inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-	return 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    struct afr_reply *replies = NULL;
+    inode_t *inode = NULL;
+    int first_idx = -1;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    replies = alloca0(sizeof(*replies) * priv->child_count);
+
+    inode = afr_selfheal_unlocked_lookup_on(frame, parent, bname, replies,
+                                            local->child_up, NULL);
+    if (!inode)
+        return -ENOMEM;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA)) {
+            *need_heal = _gf_true;
+            break;
+        }
+
+        if (first_idx == -1) {
+            first_idx = i;
+            continue;
+        }
+
+        if (replies[i].op_ret != replies[first_idx].op_ret) {
+            *need_heal = _gf_true;
+            break;
+        }
+
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[first_idx].poststat.ia_gfid)) {
+            *need_heal = _gf_true;
+            break;
+        }
+    }
+
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    return 0;
 }
 
 int
-afr_selfheal_name (xlator_t *this, uuid_t pargfid, const char *bname,
-                   void *gfid_req, dict_t *xdata)
+afr_selfheal_name(xlator_t *this, uuid_t pargfid, const char *bname,
+                  void *gfid_req, dict_t *xdata)
 {
-	inode_t *parent = NULL;
-	call_frame_t *frame = NULL;
-	int ret = -1;
-	gf_boolean_t need_heal = _gf_false;
-
-	parent = afr_inode_find (this, pargfid);
-	if (!parent)
-		goto out;
-
-	frame = afr_frame_create (this);
-	if (!frame)
-		goto out;
-
-	ret = afr_selfheal_name_unlocked_inspect (frame, this, parent, pargfid,
-						  bname, &need_heal);
-	if (ret)
-		goto out;
-
-	if (need_heal) {
-		ret = afr_selfheal_name_do (frame, this, parent, pargfid, bname,
-                                            gfid_req, xdata);
-                if (ret)
-                        goto out;
-        }
+    inode_t *parent = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    gf_boolean_t need_heal = _gf_false;
+
+    parent = afr_inode_find(this, pargfid);
+    if (!parent)
+        goto out;
+
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        goto out;
+
+    ret = afr_selfheal_name_unlocked_inspect(frame, this, parent, pargfid,
+                                             bname, &need_heal);
+    if (ret)
+        goto out;
+
+    if (need_heal) {
+        ret = afr_selfheal_name_do(frame, this, parent, pargfid, bname,
+                                   gfid_req, xdata);
+        if (ret)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-	if (parent)
-		inode_unref (parent);
-	if (frame)
-		AFR_STACK_DESTROY (frame);
+    if (parent)
+        inode_unref(parent);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal.h b/xlators/cluster/afr/src/afr-self-heal.h
index a1da4331fb7..48e6dbcfb18 100644
--- a/xlators/cluster/afr/src/afr-self-heal.h
+++ b/xlators/cluster/afr/src/afr-self-heal.h
@@ -8,265 +8,285 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef _AFR_SELFHEAL_H
 #define _AFR_SELFHEAL_H
 
-#define AFR_SH_MIN_PARTICIPANTS 2
-
 /* Perform fop on all UP subvolumes and wait for all callbacks to return */
 
-#define AFR_ONALL(frame, rfn, fop, args ...) do {			\
-	afr_local_t *__local = frame->local;				\
-	afr_private_t *__priv = frame->this->private;			\
-        int __i = 0, __count = 0;                                       \
-        unsigned char *__child_up = NULL;                               \
-                                                                        \
-        __child_up = alloca0 (__priv->child_count);                     \
-        memcpy (__child_up, __priv->child_up,                           \
-                sizeof (*__child_up) * __priv->child_count);            \
-        __count = AFR_COUNT (__child_up, __priv->child_count);          \
-									\
-        __local->barrier.waitfor = __count;                             \
-	afr_local_replies_wipe (__local, __priv);			\
-									\
-	for (__i = 0; __i < __priv->child_count; __i++) {		\
-		if (!__child_up[__i])                                   \
-                        continue;			                \
-		STACK_WIND_COOKIE (frame, rfn, (void *)(long) __i,	\
-				   __priv->children[__i],		\
-				   __priv->children[__i]->fops->fop, args); \
-	}								\
-	syncbarrier_wait (&__local->barrier, __count);			\
-	} while (0)
-
+#define AFR_ONALL(frame, rfn, fop, args...)                                    \
+    do {                                                                       \
+        afr_local_t *__local = frame->local;                                   \
+        afr_private_t *__priv = frame->this->private;                          \
+        int __i = 0, __count = 0;                                              \
+        unsigned char *__child_up = alloca(__priv->child_count);               \
+                                                                               \
+        memcpy(__child_up, __priv->child_up,                                   \
+               sizeof(*__child_up) * __priv->child_count);                     \
+        __count = AFR_COUNT(__child_up, __priv->child_count);                  \
+                                                                               \
+        __local->barrier.waitfor = __count;                                    \
+        afr_local_replies_wipe(__local, __priv);                               \
+                                                                               \
+        for (__i = 0; __i < __priv->child_count; __i++) {                      \
+            if (!__child_up[__i])                                              \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, rfn, (void *)(long)__i,                   \
+                              __priv->children[__i],                           \
+                              __priv->children[__i]->fops->fop, args);         \
+        }                                                                      \
+        syncbarrier_wait(&__local->barrier, __count);                          \
+    } while (0)
 
 /* Perform fop on all subvolumes represented by list[] array and wait
    for all callbacks to return */
 
-#define AFR_ONLIST(list, frame, rfn, fop, args ...) do {		\
-	afr_local_t *__local = frame->local;				\
-	afr_private_t *__priv = frame->this->private;			\
-	int __i = 0;                                                    \
-        int __count = AFR_COUNT (list, __priv->child_count);            \
-									\
-        __local->barrier.waitfor = __count;                             \
-	afr_local_replies_wipe (__local, __priv);			\
-									\
-	for (__i = 0; __i < __priv->child_count; __i++) {		\
-		if (!list[__i]) continue;				\
-		STACK_WIND_COOKIE (frame, rfn, (void *)(long) __i,	\
-				   __priv->children[__i],		\
-				   __priv->children[__i]->fops->fop, args); \
-	}								\
-	syncbarrier_wait (&__local->barrier, __count);			\
-	} while (0)
-
-
-#define AFR_SEQ(frame, rfn, fop, args ...) do {				\
-	afr_local_t *__local = frame->local;				\
-	afr_private_t *__priv = frame->this->private;			\
-	int __i = 0;							\
-									\
-	afr_local_replies_wipe (__local, __priv);			\
-									\
-	for (__i = 0; __i < __priv->child_count; __i++) {		\
-		if (!__priv->child_up[__i]) continue;			\
-		STACK_WIND_COOKIE (frame, rfn, (void *)(long) __i,	\
-				   __priv->children[__i],		\
-				   __priv->children[__i]->fops->fop, args); \
-		syncbarrier_wait (&__local->barrier, 1);		\
-	}								\
-	} while (0)
-
-
-#define ALLOC_MATRIX(n, type) ({type **__ptr = NULL; \
-	int __i; \
-	__ptr = alloca0 (n * sizeof(type *)); \
-	for (__i = 0; __i < n; __i++) __ptr[__i] = alloca0 (n * sizeof(type)); \
-	__ptr;})
-
-
-#define IA_EQUAL(f,s,field) (memcmp (&(f.ia_##field), &(s.ia_##field), sizeof (s.ia_##field)) == 0)
-
-#define SBRAIN_HEAL_NO_GO_MSG "Failed to obtain replies from all bricks of "\
-                      "the replica (are they up?). Cannot resolve split-brain."
-int
-afr_selfheal (xlator_t *this, uuid_t gfid);
+#define AFR_ONLIST(list, frame, rfn, fop, args...)                             \
+    do {                                                                       \
+        afr_local_t *__local = frame->local;                                   \
+        afr_private_t *__priv = frame->this->private;                          \
+        int __i = 0;                                                           \
+        int __count = 0;                                                       \
+        unsigned char *__list = alloca(__priv->child_count);                   \
+                                                                               \
+        memcpy(__list, list, sizeof(*__list) * __priv->child_count);           \
+        __count = AFR_COUNT(__list, __priv->child_count);                      \
+        __local->barrier.waitfor = __count;                                    \
+        afr_local_replies_wipe(__local, __priv);                               \
+                                                                               \
+        for (__i = 0; __i < __priv->child_count; __i++) {                      \
+            if (!__list[__i])                                                  \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, rfn, (void *)(long)__i,                   \
+                              __priv->children[__i],                           \
+                              __priv->children[__i]->fops->fop, args);         \
+        }                                                                      \
+        syncbarrier_wait(&__local->barrier, __count);                          \
+    } while (0)
+
+#define AFR_SEQ(frame, rfn, fop, args...)                                      \
+    do {                                                                       \
+        afr_local_t *__local = frame->local;                                   \
+        afr_private_t *__priv = frame->this->private;                          \
+        int __i = 0;                                                           \
+                                                                               \
+        afr_local_replies_wipe(__local, __priv);                               \
+                                                                               \
+        for (__i = 0; __i < __priv->child_count; __i++) {                      \
+            if (!__priv->child_up[__i])                                        \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, rfn, (void *)(long)__i,                   \
+                              __priv->children[__i],                           \
+                              __priv->children[__i]->fops->fop, args);         \
+            syncbarrier_wait(&__local->barrier, 1);                            \
+        }                                                                      \
+    } while (0)
+
+#define ALLOC_MATRIX(n, type)                                                  \
+    ({                                                                         \
+        int __i;                                                               \
+        type **__ptr = alloca(n * sizeof(type *));                             \
+                                                                               \
+        for (__i = 0; __i < n; __i++)                                          \
+            __ptr[__i] = alloca0(n * sizeof(type));                            \
+        __ptr;                                                                 \
+    })
+
+#define IA_EQUAL(f, s, field)                                                  \
+    (memcmp(&(f.ia_##field), &(s.ia_##field), sizeof(s.ia_##field)) == 0)
+
+#define SBRAIN_HEAL_NO_GO_MSG                                                  \
+    "Failed to obtain replies from all bricks of "                             \
+    "the replica (are they up?). Cannot resolve split-brain."
+#define SFILE_NOT_IN_SPLIT_BRAIN "File not in split-brain"
+#define SNO_BIGGER_FILE "No bigger file"
+#define SNO_DIFF_IN_MTIME "No difference in mtime"
+#define SUSE_SOURCE_BRICK_TO_HEAL                                              \
+    "Use source-brick option to heal metadata"                                 \
+    " split-brain"
+#define SINVALID_BRICK_NAME "Invalid brick name"
+#define SBRICK_IS_NOT_UP "Brick is not up"
+#define SBRICK_NOT_CONNECTED "Brick is not connected"
+#define SLESS_THAN2_BRICKS_in_REP "< 2 bricks in replica are up"
+#define SBRICK_IS_REMOTE "Brick is remote"
+#define SSTARTED_SELF_HEAL "Started self-heal"
+#define SOP_NOT_SUPPORTED "Operation Not Supported"
+#define SFILE_NOT_UNDER_DATA                                                   \
+    "The file is not under data or metadata "                                  \
+    "split-brain"
+#define SFILE_NOT_IN_SPLIT_BRAIN "File not in split-brain"
+#define SALL_BRICKS_UP_TO_RESOLVE                                              \
+    "All the bricks should be up to resolve the"                               \
+    " gfid split brain"
+#define SERROR_GETTING_SRC_BRICK "Error getting the source brick"
+int
+afr_selfheal(xlator_t *this, uuid_t gfid);
 
 gf_boolean_t
-afr_throttled_selfheal (call_frame_t *frame, xlator_t *this);
+afr_throttled_selfheal(call_frame_t *frame, xlator_t *this);
 
 int
-afr_selfheal_name (xlator_t *this, uuid_t gfid, const char *name,
-                   void *gfid_req, dict_t *xdata);
+afr_selfheal_name(xlator_t *this, uuid_t gfid, const char *name, void *gfid_req,
+                  dict_t *xdata);
 
 int
-afr_selfheal_data (call_frame_t *frame, xlator_t *this, inode_t *inode);
+afr_selfheal_data(call_frame_t *frame, xlator_t *this, fd_t *fd);
 
 int
-afr_selfheal_metadata (call_frame_t *frame, xlator_t *this, inode_t *inode);
+afr_selfheal_metadata(call_frame_t *frame, xlator_t *this, inode_t *inode);
 
 int
-afr_selfheal_entry (call_frame_t *frame, xlator_t *this, inode_t *inode);
+afr_selfheal_entry(call_frame_t *frame, xlator_t *this, inode_t *inode);
 
 int
-afr_lookup_and_heal_gfid (xlator_t *this, inode_t *parent, const char *name,
-                          inode_t *inode, struct afr_reply *replies, int source,
-                          void *gfid);
+afr_lookup_and_heal_gfid(xlator_t *this, inode_t *parent, const char *name,
+                         inode_t *inode, struct afr_reply *replies, int source,
+                         unsigned char *sources, void *gfid, int *gfid_idx);
 
 int
-afr_selfheal_inodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, off_t off, size_t size,
-		      unsigned char *locked_on);
+afr_selfheal_inodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, off_t off, size_t size,
+                     unsigned char *locked_on);
 
 int
-afr_selfheal_tryinodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, off_t off, size_t size,
-			 unsigned char *locked_on);
+afr_selfheal_tryinodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, off_t off, size_t size,
+                        unsigned char *locked_on);
 
 int
-afr_selfheal_tie_breaker_inodelk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, off_t off,
-                                  size_t size, unsigned char *locked_on);
+afr_selfheal_tie_breaker_inodelk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, off_t off,
+                                 size_t size, unsigned char *locked_on);
 
 int
-afr_selfheal_uninodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, off_t off, size_t size,
-			const unsigned char *locked_on);
+afr_selfheal_uninodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, off_t off, size_t size,
+                       const unsigned char *locked_on);
 
 int
-afr_selfheal_entrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, const char *name, unsigned char *locked_on);
+afr_selfheal_entrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, const char *name, unsigned char *locked_on);
 
 int
-afr_selfheal_tryentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, const char *name, unsigned char *locked_on);
+afr_selfheal_tryentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, const char *name, unsigned char *locked_on);
 
 int
-afr_selfheal_tie_breaker_entrylk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, const char *name,
-                                  unsigned char *locked_on);
+afr_selfheal_tie_breaker_entrylk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, const char *name,
+                                 unsigned char *locked_on);
 
 int
-afr_selfheal_unentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, const char *name, unsigned char *locked_on,
-                        dict_t *xdata);
+afr_selfheal_unentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, const char *name, unsigned char *locked_on,
+                       dict_t *xdata);
 
 int
-afr_selfheal_unlocked_discover (call_frame_t *frame, inode_t *inode,
-				uuid_t gfid, struct afr_reply *replies);
+afr_selfheal_unlocked_discover(call_frame_t *frame, inode_t *inode, uuid_t gfid,
+                               struct afr_reply *replies);
 
 int
-afr_selfheal_unlocked_discover_on (call_frame_t *frame, inode_t *inode,
-                                   uuid_t gfid, struct afr_reply *replies,
-                                   unsigned char *discover_on);
+afr_selfheal_unlocked_discover_on(call_frame_t *frame, inode_t *inode,
+                                  uuid_t gfid, struct afr_reply *replies,
+                                  unsigned char *discover_on, dict_t *dict);
 inode_t *
-afr_selfheal_unlocked_lookup_on (call_frame_t *frame, inode_t *parent,
-				 const char *name, struct afr_reply *replies,
-				 unsigned char *lookup_on, dict_t *xattr);
+afr_selfheal_unlocked_lookup_on(call_frame_t *frame, inode_t *parent,
+                                const char *name, struct afr_reply *replies,
+                                unsigned char *lookup_on, dict_t *xattr);
 
 int
-afr_selfheal_find_direction (call_frame_t *frame, xlator_t *this,
-                             struct afr_reply *replies,
-                             afr_transaction_type type,
-                             unsigned char *locked_on, unsigned char *sources,
-                             unsigned char *sinks, uint64_t *witness,
-                             gf_boolean_t *flag);
+afr_selfheal_find_direction(call_frame_t *frame, xlator_t *this,
+                            struct afr_reply *replies,
+                            afr_transaction_type type, unsigned char *locked_on,
+                            unsigned char *sources, unsigned char *sinks,
+                            uint64_t *witness, unsigned char *flag);
 int
-afr_selfheal_fill_matrix (xlator_t *this, int **matrix, int subvol, int idx,
-                          dict_t *xdata);
+afr_selfheal_fill_matrix(xlator_t *this, int **matrix, int subvol, int idx,
+                         dict_t *xdata);
 
 int
-afr_selfheal_extract_xattr (xlator_t *this, struct afr_reply *replies,
-			    afr_transaction_type type, int *dirty, int **matrix);
+afr_selfheal_extract_xattr(xlator_t *this, struct afr_reply *replies,
+                           afr_transaction_type type, int *dirty, int **matrix);
 
 int
-afr_sh_generic_fop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, struct iatt *pre,
-                        struct iatt *post, dict_t *xdata);
+afr_sh_generic_fop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *pre,
+                       struct iatt *post, dict_t *xdata);
 
 int
-afr_selfheal_restore_time (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                           int source, unsigned char *healed_sinks,
-                           struct afr_reply *replies);
+afr_selfheal_restore_time(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          int source, unsigned char *healed_sinks,
+                          struct afr_reply *replies);
 int
-afr_selfheal_undo_pending (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			   unsigned char *sources, unsigned char *sinks,
-			   unsigned char *healed_sinks,
-                           unsigned char *undid_pending,
-                           afr_transaction_type type, struct afr_reply *replies,
-                           unsigned char *locked_on);
+afr_selfheal_undo_pending(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          unsigned char *sources, unsigned char *sinks,
+                          unsigned char *healed_sinks,
+                          unsigned char *undid_pending,
+                          afr_transaction_type type, struct afr_reply *replies,
+                          unsigned char *locked_on);
 
 int
-afr_selfheal_recreate_entry (call_frame_t *frame, int dst, int source,
-                             unsigned char *sources,
-                             inode_t *dir, const char *name, inode_t *inode,
-                             struct afr_reply *replies);
+afr_selfheal_recreate_entry(call_frame_t *frame, int dst, int source,
+                            unsigned char *sources, inode_t *dir,
+                            const char *name, inode_t *inode,
+                            struct afr_reply *replies);
 
 int
-afr_selfheal_post_op (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      int subvol, dict_t *xattr, dict_t *xdata);
+afr_selfheal_post_op(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     int subvol, dict_t *xattr, dict_t *xdata);
 
 call_frame_t *
-afr_frame_create (xlator_t *this);
+afr_frame_create(xlator_t *this, int32_t *op_errno);
 
 inode_t *
-afr_inode_find (xlator_t *this, uuid_t gfid);
+afr_inode_find(xlator_t *this, uuid_t gfid);
 
 int
-afr_selfheal_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			   int op_ret, int op_errno, inode_t *inode,
-			   struct iatt *buf, dict_t *xdata,
-                           struct iatt *parbuf);
+afr_selfheal_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xdata, struct iatt *parbuf);
 void
-afr_reply_copy (struct afr_reply *dst, struct afr_reply *src);
+afr_reply_copy(struct afr_reply *dst, struct afr_reply *src);
 
 void
-afr_replies_copy (struct afr_reply *dst, struct afr_reply *src, int count);
+afr_replies_copy(struct afr_reply *dst, struct afr_reply *src, int count);
 
 int
-afr_selfheal_newentry_mark (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                            int source, struct afr_reply *replies,
-                            unsigned char *sources, unsigned char *newentry);
+afr_selfheal_newentry_mark(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                           int source, struct afr_reply *replies,
+                           unsigned char *sources, unsigned char *newentry);
 
 unsigned int
-afr_success_count (struct afr_reply *replies, unsigned int count);
+afr_success_count(struct afr_reply *replies, unsigned int count);
 
 void
-afr_log_selfheal (uuid_t gfid, xlator_t *this, int ret, char *type,
-                  int source, unsigned char *sources,
-                  unsigned char *healed_sinks);
+afr_log_selfheal(uuid_t gfid, xlator_t *this, int ret, char *type, int source,
+                 unsigned char *sources, unsigned char *healed_sinks);
 
 void
-afr_mark_largest_file_as_source (xlator_t *this, unsigned char *sources,
-                                 struct afr_reply *replies);
+afr_mark_largest_file_as_source(xlator_t *this, unsigned char *sources,
+                                struct afr_reply *replies);
 void
-afr_mark_active_sinks (xlator_t *this, unsigned char *sources,
-                       unsigned char *locked_on, unsigned char *sinks);
+afr_mark_active_sinks(xlator_t *this, unsigned char *sources,
+                      unsigned char *locked_on, unsigned char *sinks);
 
 gf_boolean_t
-afr_dict_contains_heal_op (call_frame_t *frame);
+afr_dict_contains_heal_op(call_frame_t *frame);
 
 gf_boolean_t
-afr_can_decide_split_brain_source_sinks (struct afr_reply *replies,
-                                         int child_count);
+afr_can_decide_split_brain_source_sinks(struct afr_reply *replies,
+                                        int child_count);
 int
-afr_mark_split_brain_source_sinks (call_frame_t *frame, xlator_t *this,
-                                   inode_t *inode,
-                                   unsigned char *sources,
-                                   unsigned char *sinks,
-                                   unsigned char *healed_sinks,
-                                   unsigned char *locked_on,
-                                   struct afr_reply *replies,
-                                   afr_transaction_type type);
+afr_mark_split_brain_source_sinks(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type);
 
 int
-afr_sh_get_fav_by_policy (xlator_t *this, struct afr_reply *replies,
-                          inode_t *inode, char **policy_str);
+afr_sh_get_fav_by_policy(xlator_t *this, struct afr_reply *replies,
+                         inode_t *inode, char **policy_str);
 
 int
-_afr_fav_child_reset_sink_xattrs (call_frame_t *frame, xlator_t *this,
+_afr_fav_child_reset_sink_xattrs(call_frame_t *frame, xlator_t *this,
                                  inode_t *inode, int source,
                                  unsigned char *healed_sinks,
                                  unsigned char *undid_pending,
@@ -275,83 +295,83 @@ _afr_fav_child_reset_sink_xattrs (call_frame_t *frame, xlator_t *this,
                                  struct afr_reply *replies);
 
 int
-afr_get_child_index_from_name (xlator_t *this, char *name);
+afr_get_child_index_from_name(xlator_t *this, char *name);
 
 gf_boolean_t
-afr_does_witness_exist (xlator_t *this, uint64_t *witness);
+afr_does_witness_exist(xlator_t *this, uint64_t *witness);
 
 int
-__afr_selfheal_data_prepare (call_frame_t *frame, xlator_t *this,
-                             inode_t *inode, unsigned char *locked_on,
-                             unsigned char *sources,
-                             unsigned char *sinks, unsigned char *healed_sinks,
-                             unsigned char *undid_pending,
-                             struct afr_reply *replies, gf_boolean_t *flag);
+__afr_selfheal_data_prepare(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                            unsigned char *locked_on, unsigned char *sources,
+                            unsigned char *sinks, unsigned char *healed_sinks,
+                            unsigned char *undid_pending,
+                            struct afr_reply *replies, unsigned char *flag);
 
 int
-__afr_selfheal_metadata_prepare (call_frame_t *frame, xlator_t *this,
-                                 inode_t *inode, unsigned char *locked_on,
-                                 unsigned char *sources,
-                                 unsigned char *sinks,
-                                 unsigned char *healed_sinks,
-                                 unsigned char *undid_pending,
-                                 struct afr_reply *replies,
-                                 gf_boolean_t *flag);
+__afr_selfheal_metadata_prepare(call_frame_t *frame, xlator_t *this,
+                                inode_t *inode, unsigned char *locked_on,
+                                unsigned char *sources, unsigned char *sinks,
+                                unsigned char *healed_sinks,
+                                unsigned char *undid_pending,
+                                struct afr_reply *replies, unsigned char *flag);
 int
-__afr_selfheal_entry_prepare (call_frame_t *frame, xlator_t *this,
-                              inode_t *inode, unsigned char *locked_on,
-                              unsigned char *sources,
-                              unsigned char *sinks,
-                              unsigned char *healed_sinks,
-                              struct afr_reply *replies, int *source_p,
-                              gf_boolean_t *flag);
+__afr_selfheal_entry_prepare(call_frame_t *frame, xlator_t *this,
+                             inode_t *inode, unsigned char *locked_on,
+                             unsigned char *sources, unsigned char *sinks,
+                             unsigned char *healed_sinks,
+                             struct afr_reply *replies, int *source_p,
+                             unsigned char *flag);
 
 int
-afr_selfheal_unlocked_inspect (call_frame_t *frame, xlator_t *this,
-                               uuid_t gfid, inode_t **link_inode,
-                               gf_boolean_t *data_selfheal,
-                               gf_boolean_t *metadata_selfheal,
-                               gf_boolean_t *entry_selfheal);
+afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,
+                              inode_t **link_inode, gf_boolean_t *data_selfheal,
+                              gf_boolean_t *metadata_selfheal,
+                              gf_boolean_t *entry_selfheal,
+                              struct afr_reply *replies);
 
 int
-afr_selfheal_do (call_frame_t *frame, xlator_t *this, uuid_t gfid);
+afr_selfheal_do(call_frame_t *frame, xlator_t *this, uuid_t gfid);
 
 int
-afr_selfheal_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		       int op_ret, int op_errno, dict_t *xdata);
+afr_selfheal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata);
 
 int
-afr_locked_fill (call_frame_t *frame, xlator_t *this,
-                 unsigned char *locked_on);
+afr_locked_fill(call_frame_t *frame, xlator_t *this, unsigned char *locked_on);
 int
-afr_choose_source_by_policy (afr_private_t *priv, unsigned char *sources,
-                             afr_transaction_type type);
+afr_choose_source_by_policy(afr_private_t *priv, unsigned char *sources,
+                            afr_transaction_type type);
 
 int
-afr_selfheal_metadata_by_stbuf (xlator_t *this, struct iatt *stbuf);
+afr_selfheal_metadata_by_stbuf(xlator_t *this, struct iatt *stbuf);
 
 int
-afr_sh_fav_by_size (xlator_t *this, struct afr_reply *replies,
-                    inode_t *inode);
+afr_sh_fav_by_size(xlator_t *this, struct afr_reply *replies, inode_t *inode);
 int
-afr_sh_fav_by_mtime (xlator_t *this, struct afr_reply *replies,
-                     inode_t *inode);
+afr_sh_fav_by_mtime(xlator_t *this, struct afr_reply *replies, inode_t *inode);
 int
-afr_sh_fav_by_ctime (xlator_t *this, struct afr_reply *replies,
-                     inode_t *inode);
+afr_sh_fav_by_ctime(xlator_t *this, struct afr_reply *replies, inode_t *inode);
 
 int
-afr_gfid_split_brain_source (xlator_t *this, struct afr_reply *replies,
-                             inode_t *inode, uuid_t pargfid, const char *bname,
-                             int src_idx, int child_idx,
-                             unsigned char *locked_on, int *src, dict_t *xdata);
-
+afr_gfid_split_brain_source(xlator_t *this, struct afr_reply *replies,
+                            inode_t *inode, uuid_t pargfid, const char *bname,
+                            int src_idx, int child_idx,
+                            unsigned char *locked_on, int *src, dict_t *xdata);
 int
-afr_mark_source_sinks_if_file_empty (xlator_t *this, unsigned char *sources,
-                                     unsigned char *sinks,
-                                     unsigned char *healed_sinks,
-                                     unsigned char *locked_on,
-                                     struct afr_reply *replies,
-                                     afr_transaction_type type);
+afr_mark_source_sinks_if_file_empty(xlator_t *this, unsigned char *sources,
+                                    unsigned char *sinks,
+                                    unsigned char *healed_sinks,
+                                    unsigned char *locked_on,
+                                    struct afr_reply *replies,
+                                    afr_transaction_type type);
+
+gf_boolean_t
+afr_is_file_empty_on_all_children(afr_private_t *priv,
+                                  struct afr_reply *replies);
 
+int
+afr_selfheal_entry_delete(xlator_t *this, inode_t *dir, const char *name,
+                          inode_t *inode, int child, struct afr_reply *replies);
+int
+afr_anon_inode_create(xlator_t *this, int child, inode_t **linked_inode);
 #endif /* !_AFR_SELFHEAL_H */
diff --git a/xlators/cluster/afr/src/afr-self-heald.c b/xlators/cluster/afr/src/afr-self-heald.c
index 74c9bb67931..109fd4b7421 100644
--- a/xlators/cluster/afr/src/afr-self-heald.c
+++ b/xlators/cluster/afr/src/afr-self-heald.c
@@ -8,1206 +8,1709 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "afr-self-heald.h"
 #include "protocol-common.h"
-#include "syncop-utils.h"
+#include <glusterfs/syncop-utils.h>
 #include "afr-messages.h"
-
-#define SHD_INODE_LRU_LIMIT          2048
-#define AFR_EH_SPLIT_BRAIN_LIMIT     1024
-#define AFR_STATISTICS_HISTORY_SIZE    50
-
-
-#define ASSERT_LOCAL(this, healer)				\
-	if (!afr_shd_is_subvol_local(this, healer->subvol)) {	\
-		healer->local = _gf_false;			\
-		if (safe_break (healer)) {			\
-			break;					\
-		} else {					\
-			continue;				\
-		}						\
-	} else {						\
-		healer->local = _gf_true;			\
-	}
-
-
-#define NTH_INDEX_HEALER(this, n) &((((afr_private_t *)this->private))->shd.index_healers[n])
-#define NTH_FULL_HEALER(this, n) &((((afr_private_t *)this->private))->shd.full_healers[n])
+#include <glusterfs/byte-order.h>
+
+#define AFR_EH_SPLIT_BRAIN_LIMIT 1024
+#define AFR_STATISTICS_HISTORY_SIZE 50
+
+#define ASSERT_LOCAL(this, healer)                                             \
+    if (!afr_shd_is_subvol_local(this, healer->subvol)) {                      \
+        healer->local = _gf_false;                                             \
+        if (safe_break(healer)) {                                              \
+            break;                                                             \
+        } else {                                                               \
+            continue;                                                          \
+        }                                                                      \
+    } else {                                                                   \
+        healer->local = _gf_true;                                              \
+    }
+
+#define NTH_INDEX_HEALER(this, n)                                              \
+    &((((afr_private_t *)this->private))->shd.index_healers[n])
+#define NTH_FULL_HEALER(this, n)                                               \
+    &((((afr_private_t *)this->private))->shd.full_healers[n])
 
 char *
-afr_subvol_name (xlator_t *this, int subvol)
+afr_subvol_name(xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
-	if (subvol < 0 || subvol > priv->child_count)
-		return NULL;
+    priv = this->private;
+    if (subvol < 0 || subvol > priv->child_count)
+        return NULL;
 
-	return priv->children[subvol]->name;
+    return priv->children[subvol]->name;
 }
 
-
 void
-afr_destroy_crawl_event_data (void *data)
+afr_destroy_crawl_event_data(void *data)
 {
-        return;
+    return;
 }
 
-
 void
-afr_destroy_shd_event_data (void *data)
+afr_destroy_shd_event_data(void *data)
 {
-	shd_event_t *shd_event = data;
-
-	if (!shd_event)
-		return;
-	GF_FREE (shd_event->path);
+    shd_event_t *shd_event = data;
 
+    if (!shd_event)
         return;
-}
+    GF_FREE(shd_event->path);
 
+    return;
+}
 
 gf_boolean_t
-afr_shd_is_subvol_local (xlator_t *this, int subvol)
+afr_shd_is_subvol_local(xlator_t *this, int subvol)
 {
-	afr_private_t *priv    = NULL;
-	gf_boolean_t  is_local = _gf_false;
-        loc_t         loc      = {0, };
-
-        loc.inode = this->itable->root;
-        gf_uuid_copy (loc.gfid, loc.inode->gfid);
-	priv = this->private;
-        syncop_is_subvol_local(priv->children[subvol], &loc, &is_local);
-        return is_local;
+    afr_private_t *priv = NULL;
+    gf_boolean_t is_local = _gf_false;
+    loc_t loc = {
+        0,
+    };
+
+    loc.inode = this->itable->root;
+    gf_uuid_copy(loc.gfid, loc.inode->gfid);
+    priv = this->private;
+    syncop_is_subvol_local(priv->children[subvol], &loc, &is_local);
+    return is_local;
 }
 
-
 int
-__afr_shd_healer_wait (struct subvol_healer *healer)
+__afr_shd_healer_wait(struct subvol_healer *healer)
 {
-	afr_private_t *priv = NULL;
-	struct timespec wait_till = {0, };
-	int ret = 0;
+    afr_private_t *priv = NULL;
+    struct timespec wait_till = {
+        0,
+    };
+    int ret = 0;
 
-	priv = healer->this->private;
+    priv = healer->this->private;
 
 disabled_loop:
-	wait_till.tv_sec = time (NULL) + priv->shd.timeout;
+    wait_till.tv_sec = gf_time() + priv->shd.timeout;
 
-	while (!healer->rerun) {
-		ret = pthread_cond_timedwait (&healer->cond,
-					      &healer->mutex,
-					      &wait_till);
-		if (ret == ETIMEDOUT)
-			break;
-	}
+    while (!healer->rerun) {
+        ret = pthread_cond_timedwait(&healer->cond, &healer->mutex, &wait_till);
+        if (ret == ETIMEDOUT)
+            break;
+    }
 
-	ret = healer->rerun;
-	healer->rerun = 0;
+    ret = healer->rerun;
+    healer->rerun = 0;
 
-	if (!priv->shd.enabled)
-		goto disabled_loop;
+    if (!priv->shd.enabled)
+        goto disabled_loop;
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_shd_healer_wait (struct subvol_healer *healer)
+afr_shd_healer_wait(struct subvol_healer *healer)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&healer->mutex);
-	{
-		ret = __afr_shd_healer_wait (healer);
-	}
-	pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_lock(&healer->mutex);
+    {
+        ret = __afr_shd_healer_wait(healer);
+    }
+    pthread_mutex_unlock(&healer->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-safe_break (struct subvol_healer *healer)
+safe_break(struct subvol_healer *healer)
 {
-	gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-	pthread_mutex_lock (&healer->mutex);
-	{
-		if (healer->rerun)
-			goto unlock;
+    pthread_mutex_lock(&healer->mutex);
+    {
+        if (healer->rerun)
+            goto unlock;
 
-		healer->running = _gf_false;
-		ret = _gf_true;
-	}
+        healer->running = _gf_false;
+        ret = _gf_true;
+    }
 unlock:
-	pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_unlock(&healer->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-afr_shd_inode_find (xlator_t *this, xlator_t *subvol, uuid_t gfid)
+afr_shd_inode_find(xlator_t *this, xlator_t *subvol, uuid_t gfid)
 {
-        int          ret       = 0;
-        uint64_t     val       = IA_INVAL;
-        dict_t       *xdata    = NULL;
-        dict_t       *rsp_dict = NULL;
-        inode_t      *inode    = NULL;
-
-        xdata = dict_new ();
-        if (!xdata)
-                goto out;
-
-        ret = dict_set_int8 (xdata, GF_INDEX_IA_TYPE_GET_REQ, 1);
+    int ret = 0;
+    uint64_t val = IA_INVAL;
+    dict_t *xdata = NULL;
+    dict_t *rsp_dict = NULL;
+    inode_t *inode = NULL;
+
+    xdata = dict_new();
+    if (!xdata)
+        goto out;
+
+    ret = dict_set_int8(xdata, GF_INDEX_IA_TYPE_GET_REQ, 1);
+    if (ret)
+        goto out;
+
+    ret = syncop_inode_find(this, subvol, gfid, &inode, xdata, &rsp_dict);
+    if (ret < 0)
+        goto out;
+
+    if (rsp_dict) {
+        ret = dict_get_uint64(rsp_dict, GF_INDEX_IA_TYPE_GET_RSP, &val);
         if (ret)
-                goto out;
-
-	ret = syncop_inode_find (this, subvol, gfid, &inode,
-                                 xdata, &rsp_dict);
-	if (ret < 0)
-		goto out;
-
-        if (rsp_dict) {
-                ret = dict_get_uint64 (rsp_dict, GF_INDEX_IA_TYPE_GET_RSP,
-                                       &val);
-                if (ret)
-                        goto out;
-        }
-        ret = inode_ctx_set2 (inode, subvol, 0, &val);
+            goto out;
+    }
+    ret = inode_ctx_set2(inode, subvol, 0, &val);
 out:
-        if (ret && inode) {
-                inode_unref (inode);
-                inode = NULL;
-        }
-        if (xdata)
-                dict_unref (xdata);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
-	return inode;
+    if (ret && inode) {
+        inode_unref(inode);
+        inode = NULL;
+    }
+    if (xdata)
+        dict_unref(xdata);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
+    return inode;
 }
 
-inode_t*
-afr_shd_index_inode (xlator_t *this, xlator_t *subvol, char *vgfid)
+inode_t *
+afr_shd_index_inode(xlator_t *this, xlator_t *subvol, char *vgfid)
 {
-	loc_t rootloc = {0, };
-	inode_t *inode = NULL;
-	int ret = 0;
-	dict_t *xattr = NULL;
-	void *index_gfid = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    inode_t *inode = NULL;
+    int ret = 0;
+    dict_t *xattr = NULL;
+    void *index_gfid = NULL;
 
-	rootloc.inode = inode_ref (this->itable->root);
-	gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
 
-	ret = syncop_getxattr (subvol, &rootloc, &xattr,
-			       vgfid, NULL, NULL);
-	if (ret || !xattr) {
-		errno = -ret;
-		goto out;
-	}
+    ret = syncop_getxattr(subvol, &rootloc, &xattr, vgfid, NULL, NULL);
+    if (ret || !xattr) {
+        errno = -ret;
+        goto out;
+    }
 
-	ret = dict_get_ptr (xattr, vgfid, &index_gfid);
-	if (ret)
-		goto out;
+    ret = dict_get_ptr(xattr, vgfid, &index_gfid);
+    if (ret)
+        goto out;
 
-        gf_msg_debug (this->name, 0, "%s dir gfid for %s: %s",
-	              vgfid, subvol->name, uuid_utoa (index_gfid));
+    gf_msg_debug(this->name, 0, "%s dir gfid for %s: %s", vgfid, subvol->name,
+                 uuid_utoa(index_gfid));
 
-	inode = afr_shd_inode_find (this, subvol, index_gfid);
+    inode = afr_shd_inode_find(this, subvol, index_gfid);
 
 out:
-	loc_wipe (&rootloc);
+    loc_wipe(&rootloc);
 
-	if (xattr)
-		dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	return inode;
+    return inode;
 }
 
 int
-afr_shd_index_purge (xlator_t *subvol, inode_t *inode, char *name,
-                     ia_type_t type)
+afr_shd_entry_purge(xlator_t *subvol, inode_t *inode, char *name,
+                    ia_type_t type)
 {
-	int    ret = 0;
-	loc_t  loc = {0,};
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
 
-	loc.parent = inode_ref (inode);
-	loc.name = name;
+    loc.parent = inode_ref(inode);
+    loc.name = name;
 
-        if (IA_ISDIR (type))
-                ret = syncop_rmdir (subvol, &loc, 1, NULL, NULL);
-        else
-                ret = syncop_unlink (subvol, &loc, NULL, NULL);
+    if (IA_ISDIR(type))
+        ret = syncop_rmdir(subvol, &loc, 1, NULL, NULL);
+    else
+        ret = syncop_unlink(subvol, &loc, NULL, NULL);
 
-	loc_wipe (&loc);
-	return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 void
-afr_shd_zero_xattrop (xlator_t *this, uuid_t gfid)
+afr_shd_zero_xattrop(xlator_t *this, uuid_t gfid)
 {
-
-        call_frame_t *frame = NULL;
-        inode_t *inode = NULL;
-        afr_private_t *priv = NULL;
-        dict_t  *xattr = NULL;
-        int ret = 0;
-        int i = 0;
-        int raw[AFR_NUM_CHANGE_LOGS] = {0};
-
-        priv = this->private;
-        frame = afr_frame_create (this);
-        if (!frame)
-                goto out;
-        inode = afr_inode_find (this, gfid);
-        if (!inode)
-                goto out;
-        xattr = dict_new();
-        if (!xattr)
-                goto out;
-        ret = dict_set_static_bin (xattr, AFR_DIRTY, raw,
-                                   sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    call_frame_t *frame = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int ret = 0;
+    int i = 0;
+    int raw[AFR_NUM_CHANGE_LOGS] = {0};
+
+    priv = this->private;
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        goto out;
+    inode = afr_inode_find(this, gfid);
+    if (!inode)
+        goto out;
+    xattr = dict_new();
+    if (!xattr)
+        goto out;
+    ret = dict_set_static_bin(xattr, AFR_DIRTY, raw,
+                              sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret)
+        goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], raw,
+                                  sizeof(int) * AFR_NUM_CHANGE_LOGS);
         if (ret)
-                goto out;
-        for (i = 0; i < priv->child_count; i++) {
-                ret = dict_set_static_bin (xattr, priv->pending_key[i], raw,
-                                           sizeof(int) * AFR_NUM_CHANGE_LOGS);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        /*Send xattrop to all bricks. Doing a lookup to see if bricks are up or
-        * has valid repies for this gfid seems a bit of an overkill.*/
-        for (i = 0; i < priv->child_count; i++)
-                afr_selfheal_post_op (frame, this, inode, i, xattr, NULL);
+    /*Send xattrop to all bricks. Doing a lookup to see if bricks are up or
+     * has valid repies for this gfid seems a bit of an overkill.*/
+    for (i = 0; i < priv->child_count; i++)
+        afr_selfheal_post_op(frame, this, inode, i, xattr, NULL);
 
 out:
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        if (inode)
-                inode_unref (inode);
-        if (xattr)
-                dict_unref (xattr);
-        return;
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    if (inode)
+        inode_unref(inode);
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
 int
-afr_shd_selfheal_name (struct subvol_healer *healer, int child, uuid_t parent,
-		       const char *bname)
+afr_shd_selfheal_name(struct subvol_healer *healer, int child, uuid_t parent,
+                      const char *bname)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = afr_selfheal_name (THIS, parent, bname, NULL, NULL);
+    ret = afr_selfheal_name(THIS, parent, bname, NULL, NULL);
 
-	return ret;
+    return ret;
 }
 
 int
-afr_shd_selfheal (struct subvol_healer *healer, int child, uuid_t gfid)
+afr_shd_selfheal(struct subvol_healer *healer, int child, uuid_t gfid)
 {
-	int ret = 0;
-	eh_t *eh = NULL;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	shd_event_t *shd_event = NULL;
-	char *path = NULL;
-	xlator_t *subvol = NULL;
-	xlator_t *this = NULL;
-	crawl_event_t *crawl_event = NULL;
-
-	this = healer->this;
-	priv = this->private;
-	shd = &priv->shd;
-	crawl_event = &healer->crawl_event;
-
-	subvol = priv->children[child];
-
-        //If this fails with ENOENT/ESTALE index is stale
-        ret = syncop_gfid_to_path (this->itable, subvol, gfid, &path);
-        if (ret < 0)
-                return ret;
-
-	ret = afr_selfheal (this, gfid);
-
-        LOCK (&priv->lock);
-        {
-                if (ret == -EIO) {
-                        eh = shd->split_brain;
-                        crawl_event->split_brain_count++;
-                } else if (ret < 0) {
-                        crawl_event->heal_failed_count++;
-                } else if (ret == 0) {
-                        crawl_event->healed_count++;
-                }
+    int ret = 0;
+    eh_t *eh = NULL;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    shd_event_t *shd_event = NULL;
+    char *path = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    crawl_event_t *crawl_event = NULL;
+
+    this = healer->this;
+    priv = this->private;
+    shd = &priv->shd;
+    crawl_event = &healer->crawl_event;
+
+    subvol = priv->children[child];
+
+    // If this fails with ENOENT/ESTALE index is stale
+    ret = syncop_gfid_to_path(this->itable, subvol, gfid, &path);
+    if (ret < 0)
+        return ret;
+
+    ret = afr_selfheal(this, gfid);
+
+    LOCK(&priv->lock);
+    {
+        if (ret == -EIO) {
+            eh = shd->split_brain;
+            crawl_event->split_brain_count++;
+        } else if (ret < 0) {
+            crawl_event->heal_failed_count++;
+        } else if (ret == 0) {
+            crawl_event->healed_count++;
         }
-        UNLOCK (&priv->lock);
+    }
+    UNLOCK(&priv->lock);
 
-	if (eh) {
-		shd_event = GF_CALLOC (1, sizeof(*shd_event),
-				       gf_afr_mt_shd_event_t);
-		if (!shd_event)
-                        goto out;
+    if (eh) {
+        shd_event = GF_CALLOC(1, sizeof(*shd_event), gf_afr_mt_shd_event_t);
+        if (!shd_event)
+            goto out;
 
-		shd_event->child = child;
-		shd_event->path = path;
+        shd_event->child = child;
+        shd_event->path = path;
 
-		if (eh_save_history (eh, shd_event) < 0)
-                        goto out;
+        if (eh_save_history(eh, shd_event) < 0)
+            goto out;
 
-                shd_event = NULL;
-                path = NULL;
-	}
+        shd_event = NULL;
+        path = NULL;
+    }
 out:
-        GF_FREE (shd_event);
-        GF_FREE (path);
-	return ret;
+    GF_FREE(shd_event);
+    GF_FREE(path);
+    return ret;
 }
 
-
 void
-afr_shd_sweep_prepare (struct subvol_healer *healer)
+afr_shd_sweep_prepare(struct subvol_healer *healer)
 {
-	crawl_event_t *event = NULL;
+    crawl_event_t *event = NULL;
 
-	event = &healer->crawl_event;
+    event = &healer->crawl_event;
 
-	event->healed_count = 0;
-	event->split_brain_count = 0;
-	event->heal_failed_count = 0;
+    event->healed_count = 0;
+    event->split_brain_count = 0;
+    event->heal_failed_count = 0;
 
-	time (&event->start_time);
-	event->end_time = 0;
+    event->start_time = gf_time();
+    event->end_time = 0;
+    _mask_cancellation();
 }
 
-
 void
-afr_shd_sweep_done (struct subvol_healer *healer)
+afr_shd_sweep_done(struct subvol_healer *healer)
 {
-	crawl_event_t *event = NULL;
-	crawl_event_t *history = NULL;
-	afr_self_heald_t *shd = NULL;
+    crawl_event_t *event = NULL;
+    crawl_event_t *history = NULL;
+    afr_self_heald_t *shd = NULL;
 
-	event = &healer->crawl_event;
-	shd = &(((afr_private_t *)healer->this->private)->shd);
+    event = &healer->crawl_event;
+    shd = &(((afr_private_t *)healer->this->private)->shd);
 
-	time (&event->end_time);
-	history = memdup (event, sizeof (*event));
-	event->start_time = 0;
+    event->end_time = gf_time();
+    history = gf_memdup(event, sizeof(*event));
+    event->start_time = 0;
 
-	if (!history)
-		return;
+    if (!history)
+        return;
 
-	if (eh_save_history (shd->statistics[healer->subvol], history) < 0)
-		GF_FREE (history);
+    if (eh_save_history(shd->statistics[healer->subvol], history) < 0)
+        GF_FREE(history);
+    _unmask_cancellation();
 }
 
 int
-afr_shd_index_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                    void *data)
+afr_shd_index_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                   void *data)
 {
-        struct subvol_healer *healer = data;
-        afr_private_t        *priv   = NULL;
-        uuid_t               gfid    = {0};
-        int                  ret     = 0;
-        uint64_t             val     = IA_INVAL;
+    struct subvol_healer *healer = data;
+    afr_private_t *priv = NULL;
+    uuid_t gfid = {0};
+    int ret = 0;
+    uint64_t val = IA_INVAL;
 
-        priv = healer->this->private;
-        if (!priv->shd.enabled)
-                return -EBUSY;
+    priv = healer->this->private;
+    if (!priv->shd.enabled)
+        return -EBUSY;
 
-        gf_msg_debug (healer->this->name, 0, "got entry: %s from %s",
-                      entry->d_name, priv->children[healer->subvol]->name);
+    gf_msg_debug(healer->this->name, 0, "got entry: %s from %s", entry->d_name,
+                 priv->children[healer->subvol]->name);
 
-        ret = gf_uuid_parse (entry->d_name, gfid);
-        if (ret)
-                return 0;
+    ret = gf_uuid_parse(entry->d_name, gfid);
+    if (ret)
+        return 0;
 
-        inode_ctx_get2 (parent->inode, subvol, NULL, &val);
+    inode_ctx_get2(parent->inode, subvol, NULL, &val);
 
-        ret = afr_shd_selfheal (healer, healer->subvol, gfid);
+    ret = afr_shd_selfheal(healer, healer->subvol, gfid);
 
-        if (ret == -ENOENT || ret == -ESTALE)
-                afr_shd_index_purge (subvol, parent->inode, entry->d_name, val);
+    if (ret == -ENOENT || ret == -ESTALE)
+        afr_shd_entry_purge(subvol, parent->inode, entry->d_name, val);
 
-        if (ret == 2)
-                /* If bricks crashed in pre-op after creating indices/xattrop
-                 * link but before setting afr changelogs, we end up with stale
-                 * xattrop links but zero changelogs. Remove such entries by
-                 * sending a post-op with zero changelogs.
-                 */
-                afr_shd_zero_xattrop (healer->this, gfid);
+    if (ret == 2)
+        /* If bricks crashed in pre-op after creating indices/xattrop
+         * link but before setting afr changelogs, we end up with stale
+         * xattrop links but zero changelogs. Remove such entries by
+         * sending a post-op with zero changelogs.
+         */
+        afr_shd_zero_xattrop(healer->this, gfid);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_shd_index_sweep (struct subvol_healer *healer, char *vgfid)
+afr_shd_index_sweep(struct subvol_healer *healer, char *vgfid)
 {
-	loc_t         loc     = {0};
-	afr_private_t *priv   = NULL;
-	int           ret     = 0;
-	xlator_t      *subvol = NULL;
-	dict_t        *xdata  = NULL;
-        call_frame_t  *frame  = NULL;
-
-	priv = healer->this->private;
-	subvol = priv->children[healer->subvol];
-
-        frame = afr_frame_create (healer->this);
-        if (!frame) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    loc_t loc = {0};
+    afr_private_t *priv = NULL;
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    dict_t *xdata = NULL;
+    call_frame_t *frame = NULL;
+
+    priv = healer->this->private;
+    subvol = priv->children[healer->subvol];
+
+    frame = afr_frame_create(healer->this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    loc.inode = afr_shd_index_inode(healer->this, subvol, vgfid);
+    if (!loc.inode) {
+        gf_msg(healer->this->name, GF_LOG_WARNING, 0,
+               AFR_MSG_INDEX_DIR_GET_FAILED, "unable to get index-dir on %s",
+               subvol->name);
+        ret = -errno;
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata || dict_set_int32_sizen(xdata, "get-gfid-type", 1)) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_mt_dir_scan(frame, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
+                             healer, afr_shd_index_heal, xdata,
+                             priv->shd.max_threads, priv->shd.wait_qlength);
+
+    if (ret == 0)
+        ret = healer->crawl_event.healed_count;
 
-	loc.inode = afr_shd_index_inode (healer->this, subvol, vgfid);
-	if (!loc.inode) {
-	        gf_msg (healer->this->name, GF_LOG_WARNING,
-                        0, AFR_MSG_INDEX_DIR_GET_FAILED,
-		        "unable to get index-dir on %s", subvol->name);
-		ret = -errno;
-	        goto out;
-	}
-
-        xdata = dict_new ();
-        if (!xdata || dict_set_int32 (xdata, "get-gfid-type", 1)) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = syncop_mt_dir_scan (frame, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
-                                  healer, afr_shd_index_heal, xdata,
-                                 priv->shd.max_threads, priv->shd.wait_qlength);
+out:
+    loc_wipe(&loc);
 
-        if (ret == 0)
-                ret = healer->crawl_event.healed_count;
+    if (xdata)
+        dict_unref(xdata);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
+}
 
+int
+afr_shd_index_sweep_all(struct subvol_healer *healer)
+{
+    int ret = 0;
+    int count = 0;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_INDEX_GFID);
+    if (ret < 0)
+        goto out;
+    count = ret;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_DIRTY_GFID);
+    if (ret < 0)
+        goto out;
+    count += ret;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_ENTRY_CHANGES_GFID);
+    if (ret < 0)
+        goto out;
+    count += ret;
 out:
-        loc_wipe (&loc);
-
-        if (xdata)
-                dict_unref (xdata);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-	return ret;
+    if (ret < 0)
+        return ret;
+    else
+        return count;
 }
 
 int
-afr_shd_index_sweep_all (struct subvol_healer *healer)
+afr_shd_full_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                  void *data)
 {
-        int            ret    = 0;
-        int            count  = 0;
+    struct subvol_healer *healer = data;
+    xlator_t *this = healer->this;
+    afr_private_t *priv = NULL;
 
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_INDEX_GFID);
-        if (ret < 0)
-                goto out;
-        count = ret;
+    priv = this->private;
 
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_DIRTY_GFID);
-        if (ret < 0)
-                goto out;
-        count += ret;
+    if (this->cleanup_starting) {
+        return -ENOTCONN;
+    }
 
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_ENTRY_CHANGES_GFID);
-        if (ret < 0)
-                goto out;
-        count += ret;
-out:
-        if (ret < 0)
-                return ret;
-        else
-                return count;
+    if (!priv->shd.enabled)
+        return -EBUSY;
+
+    afr_shd_selfheal_name(healer, healer->subvol, parent->inode->gfid,
+                          entry->d_name);
+
+    afr_shd_selfheal(healer, healer->subvol, entry->d_stat.ia_gfid);
+
+    return 0;
 }
 
 int
-afr_shd_full_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                   void *data)
+afr_shd_full_sweep(struct subvol_healer *healer, inode_t *inode)
 {
-        struct subvol_healer *healer = data;
-        xlator_t             *this   = healer->this;
-        afr_private_t        *priv   = NULL;
+    afr_private_t *priv = NULL;
+    loc_t loc = {0};
 
-        priv = this->private;
-        if (!priv->shd.enabled)
-                return -EBUSY;
+    priv = healer->this->private;
+    loc.inode = inode;
+    return syncop_ftw(priv->children[healer->subvol], &loc,
+                      GF_CLIENT_PID_SELF_HEALD, healer, afr_shd_full_heal);
+}
 
-        afr_shd_selfheal_name (healer, healer->subvol,
-                               parent->inode->gfid, entry->d_name);
+int
+afr_shd_fill_ta_loc(xlator_t *this, loc_t *loc)
+{
+    afr_private_t *priv = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    int ret = -1;
+
+    priv = this->private;
+    loc->parent = inode_ref(this->itable->root);
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
+    loc->inode = inode_new(loc->parent->table);
+    GF_CHECK_ALLOC(loc->inode, ret, out);
+
+    if (!gf_uuid_is_null(priv->ta_gfid))
+        goto assign_gfid;
+
+    ret = syncop_lookup(priv->children[THIN_ARBITER_BRICK_INDEX], loc, &stbuf,
+                        0, 0, 0);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed lookup on file %s.", loc->name);
+        goto out;
+    }
+
+    gf_uuid_copy(priv->ta_gfid, stbuf.ia_gfid);
+
+assign_gfid:
+    gf_uuid_copy(loc->gfid, priv->ta_gfid);
+    ret = 0;
 
-        afr_shd_selfheal (healer, healer->subvol, entry->d_stat.ia_gfid);
+out:
+    if (ret)
+        loc_wipe(loc);
 
-        return 0;
+    return ret;
 }
 
 int
-afr_shd_full_sweep (struct subvol_healer *healer, inode_t *inode)
+_afr_shd_ta_get_xattrs(xlator_t *this, loc_t *loc, dict_t **xdata)
 {
-        afr_private_t *priv = NULL;
-        loc_t          loc  = {0};
-
-        priv = healer->this->private;
-        loc.inode = inode;
-        return syncop_ftw (priv->children[healer->subvol], &loc,
-                           GF_CLIENT_PID_SELF_HEALD, healer,
-                           afr_shd_full_heal);
-}
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int raw[AFR_NUM_CHANGE_LOGS] = {
+        0,
+    };
+    int ret = -1;
+    int i = 0;
+
+    priv = this->private;
+
+    xattr = dict_new();
+    if (!xattr) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_DICT_GET_FAILED,
+               "Failed to create dict.");
+        goto out;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], &raw,
+                                  AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret)
+            goto out;
+    }
 
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, xdata, NULL);
+    if (ret || !(*xdata)) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Xattrop failed on %s.", loc->name);
+    }
 
-void *
-afr_shd_index_healer (void *data)
-{
-	struct subvol_healer *healer = NULL;
-	xlator_t *this = NULL;
-	int ret = 0;
-	afr_private_t *priv = NULL;
-
-	healer = data;
-	THIS = this = healer->this;
-	priv = this->private;
-
-	for (;;) {
-		afr_shd_healer_wait (healer);
-
-		ASSERT_LOCAL(this, healer);
-		priv->local[healer->subvol] = healer->local;
-
-		do {
-		        gf_msg_debug (this->name, 0,
-		                      "starting index sweep on subvol %s",
-			              afr_subvol_name (this, healer->subvol));
-
-			afr_shd_sweep_prepare (healer);
-
-                        ret = afr_shd_index_sweep_all (healer);
-
-			afr_shd_sweep_done (healer);
-			/*
-			  As long as at least one gfid was
-			  healed, keep retrying. We may have
-			  just healed a directory and thereby
-			  created entries for other gfids which
-			  could not be healed thus far.
-			*/
-
-		        gf_msg_debug (this->name, 0,
-			              "finished index sweep on subvol %s",
-			              afr_subvol_name (this, healer->subvol));
-			/*
-			  Give a pause before retrying to avoid a busy loop
-			  in case the only entry in index is because of
-			  an ongoing I/O.
-			*/
-			sleep (1);
-		} while (ret > 0);
-	}
-
-	return NULL;
-}
+out:
+    if (xattr)
+        dict_unref(xattr);
 
+    return ret;
+}
 
-void *
-afr_shd_full_healer (void *data)
+void
+afr_shd_ta_get_xattrs(xlator_t *this, loc_t *loc, struct subvol_healer *healer,
+                      dict_t **xdata)
 {
-	struct subvol_healer *healer = NULL;
-	xlator_t *this = NULL;
-	int run = 0;
+    int ret = 0;
+
+    loc_wipe(loc);
+    if (afr_shd_fill_ta_loc(this, loc)) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc->name);
+        ret = -1;
+        goto out;
+    }
+
+    ret = afr_ta_post_op_lock(this, loc);
+    if (ret)
+        goto out;
+
+    ret = _afr_shd_ta_get_xattrs(this, loc, xdata);
+    if (ret) {
+        if (*xdata) {
+            dict_unref(*xdata);
+            *xdata = NULL;
+        }
+    }
 
-	healer = data;
-	THIS = this = healer->this;
+    afr_ta_post_op_unlock(this, loc);
 
-	for (;;) {
-		pthread_mutex_lock (&healer->mutex);
-		{
-			run = __afr_shd_healer_wait (healer);
-			if (!run)
-				healer->running = _gf_false;
-		}
-		pthread_mutex_unlock (&healer->mutex);
+out:
+    if (ret)
+        healer->rerun = 1;
+}
 
-		if (!run)
-			break;
+int
+afr_shd_ta_unset_xattrs(xlator_t *this, loc_t *loc, dict_t **xdata, int healer)
+{
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    gf_boolean_t need_xattrop = _gf_false;
+    void *pending_raw = NULL;
+    int *raw = NULL;
+    int pending[AFR_NUM_CHANGE_LOGS] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+    int val = 0;
+    int ret = -1;
+
+    priv = this->private;
+
+    xattr = dict_new();
+    if (!xattr) {
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        raw = GF_CALLOC(AFR_NUM_CHANGE_LOGS, sizeof(int), gf_afr_mt_int32_t);
+        if (!raw) {
+            goto out;
+        }
 
-		ASSERT_LOCAL(this, healer);
+        ret = dict_get_ptr(*xdata, priv->pending_key[i], &pending_raw);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                   "Error getting value "
+                   "of pending key %s",
+                   priv->pending_key[i]);
+            GF_FREE(raw);
+            goto out;
+        }
 
-	        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
-		        "starting full sweep on subvol %s",
-		        afr_subvol_name (this, healer->subvol));
+        memcpy(pending, pending_raw, sizeof(pending));
+        for (j = 0; j < AFR_NUM_CHANGE_LOGS; j++) {
+            val = ntoh32(pending[j]);
+            if (val) {
+                if (i == healer) {
+                    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_THIN_ARB,
+                           "I am "
+                           "not the good shd. Skipping. "
+                           "SHD = %d.",
+                           healer);
+                    ret = 0;
+                    GF_FREE(raw);
+                    goto out;
+                }
+                need_xattrop = _gf_true;
+                raw[j] = hton32(-val);
+            }
+        }
 
-		afr_shd_sweep_prepare (healer);
+        ret = dict_set_bin(xattr, priv->pending_key[i], raw,
+                           AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret) {
+            GF_FREE(raw);
+            goto out;
+        }
 
-		afr_shd_full_sweep (healer, this->itable->root);
+        if (need_xattrop)
+            break;
+    }
 
-		afr_shd_sweep_done (healer);
+    if (!need_xattrop) {
+        ret = 0;
+        goto out;
+    }
 
-	        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
-		        "finished full sweep on subvol %s",
-		        afr_subvol_name (this, healer->subvol));
-	}
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Xattrop failed.");
 
-	return NULL;
-}
+out:
+    if (xattr)
+        dict_unref(xattr);
 
+    return ret;
+}
 
-int
-afr_shd_healer_init (xlator_t *this, struct subvol_healer *healer)
+void
+afr_shd_ta_check_and_unset_xattrs(xlator_t *this, loc_t *loc,
+                                  struct subvol_healer *healer,
+                                  dict_t *pre_crawl_xdata)
 {
-	int ret = 0;
+    int ret_lock = 0;
+    int ret = 0;
+    dict_t *post_crawl_xdata = NULL;
 
-	ret = pthread_mutex_init (&healer->mutex, NULL);
-	if (ret)
-		goto out;
+    ret_lock = afr_ta_post_op_lock(this, loc);
+    if (ret_lock)
+        goto unref;
 
-	ret = pthread_cond_init (&healer->cond, NULL);
-	if (ret)
-		goto out;
+    ret = _afr_shd_ta_get_xattrs(this, loc, &post_crawl_xdata);
+    if (ret)
+        goto unref;
 
-	healer->this = this;
-	healer->running = _gf_false;
-	healer->rerun = _gf_false;
-	healer->local = _gf_false;
-out:
-	return ret;
-}
+    if (!are_dicts_equal(pre_crawl_xdata, post_crawl_xdata, NULL, NULL)) {
+        ret = -1;
+        goto unref;
+    }
 
+    ret = afr_shd_ta_unset_xattrs(this, loc, &post_crawl_xdata, healer->subvol);
 
-int
-afr_shd_healer_spawn (xlator_t *this, struct subvol_healer *healer,
-		      void *(threadfn)(void *))
-{
-	int ret = 0;
-
-	pthread_mutex_lock (&healer->mutex);
-	{
-		if (healer->running) {
-			pthread_cond_signal (&healer->cond);
-		} else {
-			ret = gf_thread_create (&healer->thread, NULL,
-						threadfn, healer, "shdheal");
-			if (ret)
-				goto unlock;
-			healer->running = 1;
-		}
-
-		healer->rerun = 1;
-	}
-unlock:
-	pthread_mutex_unlock (&healer->mutex);
-
-	return ret;
-}
+unref:
+    if (post_crawl_xdata) {
+        dict_unref(post_crawl_xdata);
+        post_crawl_xdata = NULL;
+    }
 
+    if (ret || ret_lock)
+        healer->rerun = 1;
 
-int
-afr_shd_full_healer_spawn (xlator_t *this, int subvol)
-{
-	return afr_shd_healer_spawn (this, NTH_FULL_HEALER (this, subvol),
-				     afr_shd_full_healer);
+    if (!ret_lock)
+        afr_ta_post_op_unlock(this, loc);
 }
 
-
-int
-afr_shd_index_healer_spawn (xlator_t *this, int subvol)
+gf_boolean_t
+afr_bricks_available_for_heal(afr_private_t *priv)
 {
-	return afr_shd_healer_spawn (this, NTH_INDEX_HEALER (this, subvol),
-				     afr_shd_index_healer);
-}
+    int up_children = 0;
 
+    up_children = __afr_get_up_children_count(priv);
+    if (up_children < 2) {
+        return _gf_false;
+    }
+    return _gf_true;
+}
 
-int
-afr_shd_dict_add_crawl_event (xlator_t *this, dict_t *output,
-			      crawl_event_t *crawl_event)
+static gf_boolean_t
+afr_shd_ta_needs_heal(xlator_t *this, struct subvol_healer *healer)
 {
-        int             ret = 0;
-        uint64_t        count = 0;
-        char            key[256] = {0};
-        int             xl_id = 0;
-        uint64_t        healed_count = 0;
-        uint64_t        split_brain_count = 0;
-        uint64_t        heal_failed_count = 0;
-        char            *start_time_str = 0;
-        char            *end_time_str = NULL;
-        char            *crawl_type = NULL;
-        int             progress = -1;
-	int             child = -1;
-
-	child = crawl_event->child;
-        healed_count = crawl_event->healed_count;
-        split_brain_count = crawl_event->split_brain_count;
-        heal_failed_count = crawl_event->heal_failed_count;
-        crawl_type = crawl_event->crawl_type;
-
-	if (!crawl_event->start_time)
-		goto out;
-
-        start_time_str = gf_strdup (ctime (&crawl_event->start_time));
-
-	if (crawl_event->end_time)
-		end_time_str = gf_strdup (ctime (&crawl_event->end_time));
-
-        ret = dict_get_int32 (output, this->name, &xl_id);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_GET_FAILED, "xl does not have id");
-                goto out;
+    dict_t *xdata = NULL;
+    afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    int i = 0;
+    gf_boolean_t need_heal = _gf_false;
+
+    priv = this->private;
+
+    ret = afr_shd_fill_ta_loc(this, &loc);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        healer->rerun = 1;
+        goto out;
+    }
+
+    if (_afr_shd_ta_get_xattrs(this, &loc, &xdata)) {
+        healer->rerun = 1;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (afr_ta_dict_contains_pending_xattr(xdata, priv, i)) {
+            need_heal = _gf_true;
+            break;
         }
+    }
 
-        snprintf (key, sizeof (key), "statistics-%d-%d-count", xl_id, child);
-        ret = dict_get_uint64 (output, key, &count);
+out:
+    if (xdata)
+        dict_unref(xdata);
+    loc_wipe(&loc);
 
+    return need_heal;
+}
 
-        snprintf (key, sizeof (key), "statistics_healed_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64(output, key, healed_count);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_healed_count to output");
+static int
+afr_shd_anon_inode_cleaner(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                           void *data)
+{
+    struct subvol_healer *healer = data;
+    afr_private_t *priv = healer->this->private;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
+    loc_t loc = {0};
+    int count = 0;
+    int i = 0;
+    int op_errno = 0;
+    struct iatt *iatt = NULL;
+    gf_boolean_t multiple_links = _gf_false;
+    unsigned char *gfid_present = alloca0(priv->child_count);
+    unsigned char *entry_present = alloca0(priv->child_count);
+    char *type = "file";
+
+    frame = afr_frame_create(healer->this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+    local = frame->local;
+    if (AFR_COUNT(local->child_up, priv->child_count) != priv->child_count) {
+        gf_msg_debug(healer->this->name, 0,
+                     "Not all bricks are up. Skipping "
+                     "cleanup of %s on %s",
+                     entry->d_name, subvol->name);
+        ret = 0;
+        goto out;
+    }
+
+    loc.inode = inode_new(parent->inode->table);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    ret = gf_uuid_parse(entry->d_name, loc.gfid);
+    if (ret) {
+        ret = 0;
+        goto out;
+    }
+    AFR_ONLIST(local->child_up, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == 0) {
+            count++;
+            gfid_present[i] = 1;
+            iatt = &local->replies[i].poststat;
+            if (iatt->ia_type == IA_IFDIR) {
+                type = "dir";
+            }
+
+            if (i == healer->subvol) {
+                if (local->replies[i].poststat.ia_nlink > 1) {
+                    multiple_links = _gf_true;
+                }
+            }
+        } else if (local->replies[i].op_errno != ENOENT &&
+                   local->replies[i].op_errno != ESTALE) {
+            /*We don't have complete view. Skip the entry*/
+            gf_msg_debug(healer->this->name, local->replies[i].op_errno,
+                         "Skipping cleanup of %s on %s", entry->d_name,
+                         subvol->name);
+            ret = 0;
+            goto out;
+        }
+    }
+
+    /*Inode is deleted from subvol*/
+    if (count == 1 || (iatt->ia_type != IA_IFDIR && multiple_links)) {
+        gf_msg(healer->this->name, GF_LOG_WARNING, 0,
+               AFR_MSG_EXPUNGING_FILE_OR_DIR, "expunging %s %s/%s on %s", type,
+               priv->anon_inode_name, entry->d_name, subvol->name);
+        ret = afr_shd_entry_purge(subvol, parent->inode, entry->d_name,
+                                  iatt->ia_type);
+        if (ret == -ENOENT || ret == -ESTALE)
+            ret = 0;
+    } else if (count > 1) {
+        loc_wipe(&loc);
+        loc.parent = inode_ref(parent->inode);
+        loc.name = entry->d_name;
+        loc.inode = inode_new(parent->inode->table);
+        if (!loc.inode) {
+            ret = -ENOMEM;
+            goto out;
+        }
+        AFR_ONLIST(local->child_up, frame, afr_selfheal_discover_cbk, lookup,
+                   &loc, NULL);
+        count = 0;
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->replies[i].op_ret == 0) {
+                count++;
+                entry_present[i] = 1;
+                iatt = &local->replies[i].poststat;
+            } else if (local->replies[i].op_errno != ENOENT &&
+                       local->replies[i].op_errno != ESTALE) {
+                /*We don't have complete view. Skip the entry*/
+                gf_msg_debug(healer->this->name, local->replies[i].op_errno,
+                             "Skipping cleanup of %s on %s", entry->d_name,
+                             subvol->name);
+                ret = 0;
                 goto out;
-	}
-
-        snprintf (key, sizeof (key), "statistics_sb_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64 (output, key, split_brain_count);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_split_brain_count to output");
+            }
+        }
+        for (i = 0; i < priv->child_count; i++) {
+            if (gfid_present[i] && !entry_present[i]) {
+                /*Entry is not anonymous on at least one subvol*/
+                gf_msg_debug(healer->this->name, 0,
+                             "Valid entry present on %s "
+                             "Skipping cleanup of %s on %s",
+                             priv->children[i]->name, entry->d_name,
+                             subvol->name);
+                ret = 0;
                 goto out;
+            }
         }
 
-        snprintf (key, sizeof (key), "statistics_crawl_type-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_str (output, key, crawl_type);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-	                "Could not add statistics_crawl_type to output");
-                goto out;
+        gf_msg(healer->this->name, GF_LOG_WARNING, 0,
+               AFR_MSG_EXPUNGING_FILE_OR_DIR,
+               "expunging %s %s/%s on all subvols", type, priv->anon_inode_name,
+               entry->d_name);
+        ret = 0;
+        for (i = 0; i < priv->child_count; i++) {
+            op_errno = -afr_shd_entry_purge(priv->children[i], loc.parent,
+                                            entry->d_name, iatt->ia_type);
+            if (op_errno != ENOENT && op_errno != ESTALE) {
+                ret |= -op_errno;
+            }
         }
+    }
 
-        snprintf (key, sizeof (key), "statistics_heal_failed_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64 (output, key, heal_failed_count);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-	                "Could not add statistics_healed_failed_count to output");
-                goto out;
+out:
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    loc_wipe(&loc);
+    return ret;
+}
+
+static void
+afr_cleanup_anon_inode_dir(struct subvol_healer *healer)
+{
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    afr_private_t *priv = healer->this->private;
+    loc_t loc = {0};
+
+    ret = afr_anon_inode_create(healer->this, healer->subvol, &loc.inode);
+    if (ret)
+        goto out;
+
+    frame = afr_frame_create(healer->this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    ret = syncop_mt_dir_scan(frame, priv->children[healer->subvol], &loc,
+                             GF_CLIENT_PID_SELF_HEALD, healer,
+                             afr_shd_anon_inode_cleaner, NULL,
+                             priv->shd.max_threads, priv->shd.wait_qlength);
+out:
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    loc_wipe(&loc);
+    return;
+}
+
+void *
+afr_shd_index_healer(void *data)
+{
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    dict_t *pre_crawl_xdata = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    healer = data;
+    THIS = this = healer->this;
+    priv = this->private;
+
+    for (;;) {
+        afr_shd_healer_wait(healer);
+
+        if (!afr_bricks_available_for_heal(priv))
+            continue;
+
+        ASSERT_LOCAL(this, healer);
+        priv->local[healer->subvol] = healer->local;
+
+        if (priv->thin_arbiter_count) {
+            if (afr_shd_ta_needs_heal(this, healer))
+                afr_shd_ta_get_xattrs(this, &loc, healer, &pre_crawl_xdata);
         }
 
-        snprintf (key, sizeof (key), "statistics_strt_time-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_dynstr (output, key, start_time_str);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_crawl_start_time to output");
-                goto out;
-        } else {
-		start_time_str = NULL;
-	}
-
-	if (!end_time_str)
-                progress = 1;
-        else
-                progress = 0;
-
-        snprintf (key, sizeof (key), "statistics_end_time-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        if (!end_time_str)
-                end_time_str = gf_strdup ("Could not determine the end time");
-        ret = dict_set_dynstr (output, key, end_time_str);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_crawl_end_time to output");
-                goto out;
-        } else {
-		end_time_str = NULL;
-	}
+        do {
+            gf_msg_debug(this->name, 0, "starting index sweep on subvol %s",
+                         afr_subvol_name(this, healer->subvol));
+
+            afr_shd_sweep_prepare(healer);
+
+            ret = afr_shd_index_sweep_all(healer);
+
+            afr_shd_sweep_done(healer);
+            /*
+              As long as at least one gfid was
+              healed, keep retrying. We may have
+              just healed a directory and thereby
+              created entries for other gfids which
+              could not be healed thus far.
+            */
+
+            gf_msg_debug(this->name, 0, "finished index sweep on subvol %s",
+                         afr_subvol_name(this, healer->subvol));
+            /*
+              Give a pause before retrying to avoid a busy loop
+              in case the only entry in index is because of
+              an ongoing I/O.
+            */
+            sleep(1);
+        } while (ret > 0);
+
+        if (ret == 0) {
+            afr_cleanup_anon_inode_dir(healer);
+        }
 
-        snprintf (key, sizeof (key), "statistics_inprogress-%d-%d-%"PRIu64,
-                  xl_id, child, count);
+        if (ret == 0 && pre_crawl_xdata &&
+            !healer->crawl_event.heal_failed_count) {
+            afr_shd_ta_check_and_unset_xattrs(this, &loc, healer,
+                                              pre_crawl_xdata);
+        }
 
-        ret = dict_set_int32 (output, key, progress);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_inprogress to output");
-                goto out;
+        if (pre_crawl_xdata) {
+            dict_unref(pre_crawl_xdata);
+            pre_crawl_xdata = NULL;
         }
+    }
 
-	snprintf (key, sizeof (key), "statistics-%d-%d-count", xl_id, child);
-	ret = dict_set_uint64 (output, key, count + 1);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not increment the counter.");
-                goto out;
-	}
-out:
-	GF_FREE (start_time_str);
-	GF_FREE (end_time_str);
-        return ret;
+    return NULL;
 }
 
-
-int
-afr_shd_dict_add_path (xlator_t *this, dict_t *output, int child, char *path,
-		       struct timeval *tv)
+void *
+afr_shd_full_healer(void *data)
 {
-        int             ret = -1;
-        uint64_t        count = 0;
-        char            key[256] = {0};
-        int             xl_id = 0;
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+    int run = 0;
 
-        ret = dict_get_int32 (output, this->name, &xl_id);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_GET_FAILED, "xl does not have id");
-                goto out;
+    healer = data;
+    THIS = this = healer->this;
+
+    for (;;) {
+        pthread_mutex_lock(&healer->mutex);
+        {
+            run = __afr_shd_healer_wait(healer);
+            if (!run)
+                healer->running = _gf_false;
         }
+        pthread_mutex_unlock(&healer->mutex);
 
-        snprintf (key, sizeof (key), "%d-%d-count", xl_id, child);
-        ret = dict_get_uint64 (output, key, &count);
+        if (!run)
+            break;
 
-        snprintf (key, sizeof (key), "%d-%d-%"PRIu64, xl_id, child, count);
-	ret = dict_set_dynstr (output, key, path);
+        ASSERT_LOCAL(this, healer);
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_SET_FAILED, "%s: Could not add to output",
-                        path);
-                goto out;
-        }
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+               "starting full sweep on subvol %s",
+               afr_subvol_name(this, healer->subvol));
 
-	if (tv) {
-		snprintf (key, sizeof (key), "%d-%d-%"PRIu64"-time", xl_id,
-			  child, count);
-		ret = dict_set_uint32 (output, key, tv->tv_sec);
-		if (ret) {
-		        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "%s: Could not set time",
-			        path);
-			goto out;
-		}
-	}
-
-        snprintf (key, sizeof (key), "%d-%d-count", xl_id, child);
-
-        ret = dict_set_uint64 (output, key, count + 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "Could not increment count");
-                goto out;
-        }
+        afr_shd_sweep_prepare(healer);
 
-        ret = 0;
-out:
-        return ret;
+        afr_shd_full_sweep(healer, this->itable->root);
+
+        afr_shd_sweep_done(healer);
+
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+               "finished full sweep on subvol %s",
+               afr_subvol_name(this, healer->subvol));
+    }
+
+    return NULL;
 }
 
 int
-afr_add_shd_event (circular_buffer_t *cb, void *data)
+afr_shd_healer_init(xlator_t *this, struct subvol_healer *healer)
 {
-	dict_t *output = NULL;
-	xlator_t *this = THIS;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	shd_event_t *shd_event = NULL;
-	char *path = NULL;
-
-	output = data;
-	priv = this->private;
-	shd = &priv->shd;
-	shd_event = cb->data;
-
-	if (!shd->index_healers[shd_event->child].local)
-		return 0;
-
-	path = gf_strdup (shd_event->path);
-	if (!path)
-		return -ENOMEM;
-
-	afr_shd_dict_add_path (this, output, shd_event->child, path,
-			       &cb->tv);
-	return 0;
+    int ret = 0;
+
+    ret = pthread_mutex_init(&healer->mutex, NULL);
+    if (ret)
+        goto out;
+
+    ret = pthread_cond_init(&healer->cond, NULL);
+    if (ret)
+        goto out;
+
+    healer->this = this;
+    healer->running = _gf_false;
+    healer->rerun = _gf_false;
+    healer->local = _gf_false;
+out:
+    return ret;
 }
 
 int
-afr_add_crawl_event (circular_buffer_t *cb, void *data)
+afr_shd_healer_spawn(xlator_t *this, struct subvol_healer *healer,
+                     void *(threadfn)(void *))
 {
-	dict_t *output = NULL;
-	xlator_t *this = THIS;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	crawl_event_t *crawl_event = NULL;
+    int ret = 0;
 
-	output = data;
-	priv = this->private;
-	shd = &priv->shd;
-	crawl_event = cb->data;
+    pthread_mutex_lock(&healer->mutex);
+    {
+        if (healer->running) {
+            pthread_cond_signal(&healer->cond);
+        } else {
+            ret = gf_thread_create(&healer->thread, NULL, threadfn, healer,
+                                   "shdheal");
+            if (ret)
+                goto unlock;
+            healer->running = 1;
+        }
 
-	if (!shd->index_healers[crawl_event->child].local)
-		return 0;
+        healer->rerun = 1;
+    }
+unlock:
+    pthread_mutex_unlock(&healer->mutex);
 
-	afr_shd_dict_add_crawl_event (this, output, crawl_event);
+    return ret;
+}
 
-	return 0;
+int
+afr_shd_full_healer_spawn(xlator_t *this, int subvol)
+{
+    return afr_shd_healer_spawn(this, NTH_FULL_HEALER(this, subvol),
+                                afr_shd_full_healer);
 }
 
+int
+afr_shd_index_healer_spawn(xlator_t *this, int subvol)
+{
+    return afr_shd_healer_spawn(this, NTH_INDEX_HEALER(this, subvol),
+                                afr_shd_index_healer);
+}
 
 int
-afr_selfheal_daemon_init (xlator_t *this)
+afr_shd_dict_add_crawl_event(xlator_t *this, dict_t *output,
+                             crawl_event_t *crawl_event)
 {
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	int ret = -1;
-	int i = 0;
-
-	priv = this->private;
-	shd = &priv->shd;
-
-	this->itable = inode_table_new (SHD_INODE_LRU_LIMIT, this);
-	if (!this->itable)
-		goto out;
-
-	shd->index_healers = GF_CALLOC (sizeof(*shd->index_healers),
-					priv->child_count,
-					gf_afr_mt_subvol_healer_t);
-	if (!shd->index_healers)
-		goto out;
-
-	for (i = 0; i < priv->child_count; i++) {
-		shd->index_healers[i].subvol = i;
-		ret = afr_shd_healer_init (this, &shd->index_healers[i]);
-		if (ret)
-			goto out;
-	}
-
-	shd->full_healers = GF_CALLOC (sizeof(*shd->full_healers),
-				       priv->child_count,
-				       gf_afr_mt_subvol_healer_t);
-	if (!shd->full_healers)
-		goto out;
-	for (i = 0; i < priv->child_count; i++) {
-		shd->full_healers[i].subvol = i;
-		ret = afr_shd_healer_init (this, &shd->full_healers[i]);
-		if (ret)
-			goto out;
-	}
-
-	shd->split_brain = eh_new (AFR_EH_SPLIT_BRAIN_LIMIT, _gf_false,
-				   afr_destroy_shd_event_data);
-	if (!shd->split_brain)
-		goto out;
-
-        shd->statistics = GF_CALLOC (sizeof(eh_t *), priv->child_count,
-				     gf_common_mt_eh_t);
-        if (!shd->statistics)
-                goto out;
+    int ret = 0;
+    uint64_t count = 0;
+    char key[128] = {0};
+    int keylen = 0;
+    char suffix[64] = {0};
+    int xl_id = 0;
+    uint64_t healed_count = 0;
+    uint64_t split_brain_count = 0;
+    uint64_t heal_failed_count = 0;
+    char *start_time_str = 0;
+    char *end_time_str = NULL;
+    char *crawl_type = NULL;
+    int progress = -1;
+    int child = -1;
+
+    child = crawl_event->child;
+    healed_count = crawl_event->healed_count;
+    split_brain_count = crawl_event->split_brain_count;
+    heal_failed_count = crawl_event->heal_failed_count;
+    crawl_type = crawl_event->crawl_type;
+
+    if (!crawl_event->start_time)
+        goto out;
+
+    start_time_str = gf_strdup(ctime(&crawl_event->start_time));
+
+    if (crawl_event->end_time)
+        end_time_str = gf_strdup(ctime(&crawl_event->end_time));
+
+    ret = dict_get_int32(output, this->name, &xl_id);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+               "xl does not have id");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics-%d-%d-count", xl_id, child);
+    ret = dict_get_uint64(output, key, &count);
+
+    snprintf(suffix, sizeof(suffix), "%d-%d-%" PRIu64, xl_id, child, count);
+    snprintf(key, sizeof(key), "statistics_healed_cnt-%s", suffix);
+    ret = dict_set_uint64(output, key, healed_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_healed_count to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_sb_cnt-%s", suffix);
+    ret = dict_set_uint64(output, key, split_brain_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_split_brain_count to output");
+        goto out;
+    }
+
+    keylen = snprintf(key, sizeof(key), "statistics_crawl_type-%s", suffix);
+    ret = dict_set_strn(output, key, keylen, crawl_type);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_type to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_heal_failed_cnt-%s", suffix);
+    ret = dict_set_uint64(output, key, heal_failed_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_healed_failed_count to output");
+        goto out;
+    }
+
+    keylen = snprintf(key, sizeof(key), "statistics_strt_time-%s", suffix);
+    ret = dict_set_dynstrn(output, key, keylen, start_time_str);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_start_time to output");
+        goto out;
+    } else {
+        start_time_str = NULL;
+    }
+
+    if (!end_time_str)
+        progress = 1;
+    else
+        progress = 0;
+
+    keylen = snprintf(key, sizeof(key), "statistics_end_time-%s", suffix);
+    if (!end_time_str)
+        end_time_str = gf_strdup("Could not determine the end time");
+    ret = dict_set_dynstrn(output, key, keylen, end_time_str);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_end_time to output");
+        goto out;
+    } else {
+        end_time_str = NULL;
+    }
+
+    keylen = snprintf(key, sizeof(key), "statistics_inprogress-%s", suffix);
+
+    ret = dict_set_int32n(output, key, keylen, progress);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_inprogress to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics-%d-%d-count", xl_id, child);
+    ret = dict_set_uint64(output, key, count + 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not increment the counter.");
+        goto out;
+    }
+out:
+    GF_FREE(start_time_str);
+    GF_FREE(end_time_str);
+    return ret;
+}
 
-        for (i = 0; i < priv->child_count ; i++) {
-                shd->statistics[i] = eh_new (AFR_STATISTICS_HISTORY_SIZE,
-					     _gf_false,
-					     afr_destroy_crawl_event_data);
-                if (!shd->statistics[i])
-                        goto out;
-		shd->full_healers[i].crawl_event.child = i;
-		shd->full_healers[i].crawl_event.crawl_type = "FULL";
-		shd->index_healers[i].crawl_event.child = i;
-		shd->index_healers[i].crawl_event.crawl_type = "INDEX";
+int
+afr_shd_dict_add_path(xlator_t *this, dict_t *output, int child, char *path,
+                      struct timeval *tv)
+{
+    int ret = -1;
+    uint64_t count = 0;
+    char key[64] = {0};
+    int keylen = 0;
+    char xl_id_child_str[32] = {0};
+    int xl_id = 0;
+
+    ret = dict_get_int32(output, this->name, &xl_id);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+               "xl does not have id");
+        goto out;
+    }
+
+    snprintf(xl_id_child_str, sizeof(xl_id_child_str), "%d-%d", xl_id, child);
+    snprintf(key, sizeof(key), "%s-count", xl_id_child_str);
+    ret = dict_get_uint64(output, key, &count);
+
+    keylen = snprintf(key, sizeof(key), "%s-%" PRIu64, xl_id_child_str, count);
+    ret = dict_set_dynstrn(output, key, keylen, path);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Could not add to output", path);
+        goto out;
+    }
+
+    if (tv) {
+        snprintf(key, sizeof(key), "%s-%" PRIu64 "-time", xl_id_child_str,
+                 count);
+        ret = dict_set_uint32(output, key, tv->tv_sec);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "%s: Could not set time", path);
+            goto out;
         }
+    }
+
+    snprintf(key, sizeof(key), "%s-count", xl_id_child_str);
 
-	ret = 0;
+    ret = dict_set_uint64(output, key, count + 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not increment count");
+        goto out;
+    }
+
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
+int
+afr_add_shd_event(circular_buffer_t *cb, void *data)
+{
+    dict_t *output = NULL;
+    xlator_t *this = THIS;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    shd_event_t *shd_event = NULL;
+    char *path = NULL;
+
+    output = data;
+    priv = this->private;
+    shd = &priv->shd;
+    shd_event = cb->data;
+
+    if (!shd->index_healers[shd_event->child].local)
+        return 0;
+
+    path = gf_strdup(shd_event->path);
+    if (!path)
+        return -ENOMEM;
+
+    afr_shd_dict_add_path(this, output, shd_event->child, path, &cb->tv);
+    return 0;
+}
 
 int
-afr_selfheal_childup (xlator_t *this, int subvol)
+afr_add_crawl_event(circular_buffer_t *cb, void *data)
 {
-	afr_shd_index_healer_spawn (this, subvol);
+    dict_t *output = NULL;
+    xlator_t *this = THIS;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    crawl_event_t *crawl_event = NULL;
+
+    output = data;
+    priv = this->private;
+    shd = &priv->shd;
+    crawl_event = cb->data;
+
+    if (!shd->index_healers[crawl_event->child].local)
+        return 0;
+
+    afr_shd_dict_add_crawl_event(this, output, crawl_event);
 
-	return 0;
+    return 0;
 }
 
+int
+afr_selfheal_daemon_init(xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    int ret = -1;
+    int i = 0;
+
+    priv = this->private;
+    shd = &priv->shd;
+
+    shd->index_healers = GF_CALLOC(sizeof(*shd->index_healers),
+                                   priv->child_count,
+                                   gf_afr_mt_subvol_healer_t);
+    if (!shd->index_healers)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        shd->index_healers[i].subvol = i;
+        ret = afr_shd_healer_init(this, &shd->index_healers[i]);
+        if (ret)
+            goto out;
+    }
+
+    shd->full_healers = GF_CALLOC(sizeof(*shd->full_healers), priv->child_count,
+                                  gf_afr_mt_subvol_healer_t);
+    if (!shd->full_healers)
+        goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        shd->full_healers[i].subvol = i;
+        ret = afr_shd_healer_init(this, &shd->full_healers[i]);
+        if (ret)
+            goto out;
+    }
+
+    shd->split_brain = eh_new(AFR_EH_SPLIT_BRAIN_LIMIT, _gf_false,
+                              afr_destroy_shd_event_data);
+    if (!shd->split_brain)
+        goto out;
+
+    shd->statistics = GF_CALLOC(sizeof(eh_t *), priv->child_count,
+                                gf_common_mt_eh_t);
+    if (!shd->statistics)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        shd->statistics[i] = eh_new(AFR_STATISTICS_HISTORY_SIZE, _gf_false,
+                                    afr_destroy_crawl_event_data);
+        if (!shd->statistics[i])
+            goto out;
+        shd->full_healers[i].crawl_event.child = i;
+        shd->full_healers[i].crawl_event.crawl_type = "FULL";
+        shd->index_healers[i].crawl_event.child = i;
+        shd->index_healers[i].crawl_event.crawl_type = "INDEX";
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
+
+void
+afr_selfheal_childup(xlator_t *this, afr_private_t *priv)
+{
+    int subvol = 0;
+
+    if (!priv->shd.iamshd)
+        return;
+    for (subvol = 0; subvol < priv->child_count; subvol++)
+        if (priv->child_up[subvol])
+            afr_shd_index_healer_spawn(this, subvol);
+
+    return;
+}
 
 int
-afr_shd_get_index_count (xlator_t *this, int i, uint64_t *count)
+afr_shd_get_index_count(xlator_t *this, int i, uint64_t *count)
 {
-	afr_private_t *priv = NULL;
-	xlator_t *subvol = NULL;
-	loc_t rootloc = {0, };
-	dict_t *xattr = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    xlator_t *subvol = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int ret = -1;
 
-	priv = this->private;
-	subvol = priv->children[i];
+    priv = this->private;
+    subvol = priv->children[i];
 
-	rootloc.inode = inode_ref (this->itable->root);
-	gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
 
-	ret = syncop_getxattr (subvol, &rootloc, &xattr,
-			       GF_XATTROP_INDEX_COUNT, NULL, NULL);
-	if (ret < 0)
-		goto out;
+    ret = syncop_getxattr(subvol, &rootloc, &xattr, GF_XATTROP_INDEX_COUNT,
+                          NULL, NULL);
+    if (ret < 0)
+        goto out;
 
-	ret = dict_get_uint64 (xattr, GF_XATTROP_INDEX_COUNT, count);
-	if (ret)
-		goto out;
+    ret = dict_get_uint64(xattr, GF_XATTROP_INDEX_COUNT, count);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-	loc_wipe (&rootloc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&rootloc);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_xl_op (xlator_t *this, dict_t *input, dict_t *output)
+afr_xl_op(xlator_t *this, dict_t *input, dict_t *output)
 {
-        gf_xl_afr_op_t   op = GF_SHD_OP_INVALID;
-        int              ret = 0;
-        int              xl_id = 0;
-	afr_private_t   *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	struct subvol_healer *healer = NULL;
-	int i = 0;
-	char key[64];
-	int op_ret = 0;
-	uint64_t cnt = 0;
-
-	priv = this->private;
-	shd = &priv->shd;
-
-        ret = dict_get_int32 (input, "xl-op", (int32_t*)&op);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (input, this->name, &xl_id);
-        if (ret)
-                goto out;
-        ret = dict_set_int32 (output, this->name, xl_id);
-        if (ret)
-                goto out;
-        switch (op) {
+    gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
+    int ret = 0;
+    int xl_id = 0;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    struct subvol_healer *healer = NULL;
+    int i = 0;
+    char key[64];
+    int keylen = 0;
+    int this_name_len = 0;
+    int op_ret = 0;
+    uint64_t cnt = 0;
+
+#define AFR_SET_DICT_AND_LOG(name, output, key, keylen, dict_str,              \
+                             dict_str_len)                                     \
+    {                                                                          \
+        int ret;                                                               \
+                                                                               \
+        ret = dict_set_nstrn(output, key, keylen, dict_str, dict_str_len);     \
+        if (ret) {                                                             \
+            gf_smsg(name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,         \
+                    "key=%s", key, "value=%s", dict_str, NULL);                \
+        }                                                                      \
+    }
+
+    priv = this->private;
+    shd = &priv->shd;
+
+    ret = dict_get_int32_sizen(input, "xl-op", (int32_t *)&op);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                "key=xl-op", NULL);
+        goto out;
+    }
+    this_name_len = strlen(this->name);
+    ret = dict_get_int32n(input, this->name, this_name_len, &xl_id);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                "key=%s", this->name, NULL);
+        goto out;
+    }
+    ret = dict_set_int32n(output, this->name, this_name_len, xl_id);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                "key=%s", this->name, NULL);
+        goto out;
+    }
+    switch (op) {
         case GF_SHD_OP_HEAL_INDEX:
-		op_ret = 0;
-
-		for (i = 0; i < priv->child_count; i++) {
-			healer = &shd->index_healers[i];
-			snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-
-			if (!priv->child_up[i]) {
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-                                op_ret = -1;
-			} else if (AFR_COUNT (priv->child_up,
-					      priv->child_count) < 2) {
-				ret = dict_set_str (output, key,
-						    "< 2 bricks in replica are up");
-                                op_ret = -1;
-			} else if (!afr_shd_is_subvol_local (this, healer->subvol)) {
-				ret = dict_set_str (output, key,
-						    "Brick is remote");
-			} else {
-				ret = dict_set_str (output, key,
-						    "Started self-heal");
-				afr_shd_index_healer_spawn (this, i);
-			}
-		}
-                break;
+            op_ret = 0;
+
+            for (i = 0; i < priv->child_count; i++) {
+                healer = &shd->index_healers[i];
+                keylen = snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+
+                if (!priv->child_up[i]) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SBRICK_NOT_CONNECTED,
+                                         SLEN(SBRICK_NOT_CONNECTED));
+                    op_ret = -1;
+                } else if (AFR_COUNT(priv->child_up, priv->child_count) < 2) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SLESS_THAN2_BRICKS_in_REP,
+                                         SLEN(SLESS_THAN2_BRICKS_in_REP));
+                    op_ret = -1;
+                } else if (!afr_shd_is_subvol_local(this, healer->subvol)) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SBRICK_IS_REMOTE,
+                                         SLEN(SBRICK_IS_REMOTE));
+                } else {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SSTARTED_SELF_HEAL,
+                                         SLEN(SSTARTED_SELF_HEAL));
+
+                    ret = afr_shd_index_healer_spawn(this, i);
+
+                    if (ret) {
+                        gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                                AFR_MSG_HEALER_SPAWN_FAILED, NULL);
+                    }
+                }
+            }
+            break;
         case GF_SHD_OP_HEAL_FULL:
-		op_ret = -1;
-
-		for (i = 0; i < priv->child_count; i++) {
-			healer = &shd->full_healers[i];
-			snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-
-			if (!priv->child_up[i]) {
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-			} else if (AFR_COUNT (priv->child_up,
-					      priv->child_count) < 2) {
-				ret = dict_set_str (output, key,
-						    "< 2 bricks in replica are up");
-			} else if (!afr_shd_is_subvol_local (this, healer->subvol)) {
-				ret = dict_set_str (output, key,
-						    "Brick is remote");
-			} else {
-				ret = dict_set_str (output, key,
-						    "Started self-heal");
-				afr_shd_full_healer_spawn (this, i);
-				op_ret = 0;
-			}
-		}
-                break;
-        case GF_SHD_OP_INDEX_SUMMARY:
-                /* this case has been handled in glfs-heal.c */
-                break;
-        case GF_SHD_OP_HEALED_FILES:
-        case GF_SHD_OP_HEAL_FAILED_FILES:
-                for (i = 0; i < priv->child_count; i++) {
-                        snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-                        ret = dict_set_str (output, key, "Operation Not "
-                                            "Supported");
+            op_ret = -1;
+
+            for (i = 0; i < priv->child_count; i++) {
+                healer = &shd->full_healers[i];
+                keylen = snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+
+                if (!priv->child_up[i]) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SBRICK_NOT_CONNECTED,
+                                         SLEN(SBRICK_NOT_CONNECTED));
+                } else if (AFR_COUNT(priv->child_up, priv->child_count) < 2) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SLESS_THAN2_BRICKS_in_REP,
+                                         SLEN(SLESS_THAN2_BRICKS_in_REP));
+                } else if (!afr_shd_is_subvol_local(this, healer->subvol)) {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SBRICK_IS_REMOTE,
+                                         SLEN(SBRICK_IS_REMOTE));
+                } else {
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SSTARTED_SELF_HEAL,
+                                         SLEN(SSTARTED_SELF_HEAL));
+
+                    ret = afr_shd_full_healer_spawn(this, i);
+
+                    if (ret) {
+                        gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                                AFR_MSG_HEALER_SPAWN_FAILED, NULL);
+                    }
+                    op_ret = 0;
                 }
-                break;
+            }
+            break;
+        case GF_SHD_OP_INDEX_SUMMARY:
+            /* this case has been handled in glfs-heal.c */
+            break;
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-		eh_dump (shd->split_brain, output, afr_add_shd_event);
-                break;
+            eh_dump(shd->split_brain, output, afr_add_shd_event);
+            break;
         case GF_SHD_OP_STATISTICS:
-		for (i = 0; i < priv->child_count; i++) {
-			eh_dump (shd->statistics[i], output,
-				 afr_add_crawl_event);
-			afr_shd_dict_add_crawl_event (this, output,
-						      &shd->index_healers[i].crawl_event);
-			afr_shd_dict_add_crawl_event (this, output,
-						      &shd->full_healers[i].crawl_event);
-		}
-                break;
+            for (i = 0; i < priv->child_count; i++) {
+                eh_dump(shd->statistics[i], output, afr_add_crawl_event);
+                ret = afr_shd_dict_add_crawl_event(
+                    this, output, &shd->index_healers[i].crawl_event);
+                if (ret) {
+                    gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                            AFR_MSG_ADD_CRAWL_EVENT_FAILED, NULL);
+                }
+
+                ret = afr_shd_dict_add_crawl_event(
+                    this, output, &shd->full_healers[i].crawl_event);
+                if (ret) {
+                    gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                            AFR_MSG_ADD_CRAWL_EVENT_FAILED, NULL);
+                }
+            }
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT:
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-		op_ret = -1;
-
-		for (i = 0; i < priv->child_count; i++) {
-			if (!priv->child_up[i]) {
-				snprintf (key, sizeof (key), "%d-%d-status",
-                                          xl_id, i);
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-			} else {
-				snprintf (key, sizeof (key), "%d-%d-hardlinks",
-                                          xl_id, i);
-				ret = afr_shd_get_index_count (this, i, &cnt);
-				if (ret == 0) {
-					ret = dict_set_uint64 (output, key, cnt);
-				}
-				op_ret = 0;
-			}
-		}
-
-//                ret = _do_crawl_op_on_local_subvols (this, INDEX_TO_BE_HEALED,
-//                                                     STATISTICS_TO_BE_HEALED,
-//                                                     output);
-                break;
+            op_ret = -1;
+
+            for (i = 0; i < priv->child_count; i++) {
+                if (!priv->child_up[i]) {
+                    keylen = snprintf(key, sizeof(key), "%d-%d-status", xl_id,
+                                      i);
+                    AFR_SET_DICT_AND_LOG(this->name, output, key, keylen,
+                                         SBRICK_NOT_CONNECTED,
+                                         SLEN(SBRICK_NOT_CONNECTED));
+                } else {
+                    snprintf(key, sizeof(key), "%d-%d-hardlinks", xl_id, i);
+                    ret = afr_shd_get_index_count(this, i, &cnt);
+                    if (ret == 0) {
+                        ret = dict_set_uint64(output, key, cnt);
+                    }
+                    if (ret) {
+                        gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                                AFR_MSG_DICT_SET_FAILED, NULL);
+                    }
+                    op_ret = 0;
+                }
+            }
+
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "Unknown set op %d", op);
-                break;
-        }
+            gf_smsg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "op=%d",
+                    op, NULL);
+            break;
+    }
 out:
-        dict_del (output, this->name);
-        return op_ret;
+    dict_deln(output, this->name, this_name_len);
+    return op_ret;
+
+#undef AFR_SET_DICT_AND_LOG
 }
diff --git a/xlators/cluster/afr/src/afr-self-heald.h b/xlators/cluster/afr/src/afr-self-heald.h
index 4ac1d32f58a..18db728ea7b 100644
--- a/xlators/cluster/afr/src/afr-self-heald.h
+++ b/xlators/cluster/afr/src/afr-self-heald.h
@@ -8,74 +8,68 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef _AFR_SELF_HEALD_H
 #define _AFR_SELF_HEALD_H
 
 #include <pthread.h>
 
-
 typedef struct {
-	int child;
-	char *path;
+    char *path;
+    int child;
 } shd_event_t;
 
 typedef struct {
-	int      child;
-	uint64_t healed_count;
-        uint64_t split_brain_count;
-        uint64_t heal_failed_count;
-
-	/* If start_time is 0, it means crawler is not in progress
-	   and stats are not valid */
-	time_t   start_time;
-	/* If start_time is NOT 0 and end_time is 0, it means
-	   cralwer is in progress */
-        time_t   end_time;
-        char     *crawl_type;
+    uint64_t healed_count;
+    uint64_t split_brain_count;
+    uint64_t heal_failed_count;
+
+    /* If start_time is 0, it means crawler is not in progress
+       and stats are not valid */
+    time_t start_time;
+    /* If start_time is NOT 0 and end_time is 0, it means
+       cralwer is in progress */
+    time_t end_time;
+    char *crawl_type;
+    int child;
 } crawl_event_t;
 
 struct subvol_healer {
-	xlator_t        *this;
-	int              subvol;
-	gf_boolean_t     local;
-	gf_boolean_t     running;
-	gf_boolean_t     rerun;
-	crawl_event_t    crawl_event;
-	pthread_mutex_t  mutex;
-	pthread_cond_t   cond;
-	pthread_t        thread;
+    xlator_t *this;
+    crawl_event_t crawl_event;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    pthread_t thread;
+    int subvol;
+    gf_boolean_t local;
+    gf_boolean_t running;
+    gf_boolean_t rerun;
 };
 
 typedef struct {
-	gf_boolean_t            iamshd;
-	gf_boolean_t            enabled;
-	int                     timeout;
-	struct subvol_healer   *index_healers;
-	struct subvol_healer   *full_healers;
-
-        eh_t                    *split_brain;
-        eh_t                    **statistics;
-        uint32_t                max_threads;
-        uint32_t                wait_qlength;
-        uint32_t                halo_max_latency_msec;
+    struct subvol_healer *index_healers;
+    struct subvol_healer *full_healers;
+
+    eh_t *split_brain;
+    eh_t **statistics;
+    int timeout;
+    uint32_t max_threads;
+    uint32_t wait_qlength;
+    uint32_t halo_max_latency_msec;
+    gf_boolean_t iamshd;
+    gf_boolean_t enabled;
 } afr_self_heald_t;
 
-
-int
-afr_selfheal_childup (xlator_t *this, int subvol);
-
 int
-afr_selfheal_daemon_init (xlator_t *this);
+afr_selfheal_daemon_init(xlator_t *this);
 
 int
-afr_xl_op (xlator_t *this, dict_t *input, dict_t *output);
+afr_xl_op(xlator_t *this, dict_t *input, dict_t *output);
 
 int
-afr_shd_gfid_to_path (xlator_t *this, xlator_t *subvol, uuid_t gfid,
-                      char **path_p);
+afr_shd_gfid_to_path(xlator_t *this, xlator_t *subvol, uuid_t gfid,
+                     char **path_p);
 
 int
-afr_shd_index_purge (xlator_t *subvol, inode_t *inode, char *name,
-                     ia_type_t type);
+afr_shd_entry_purge(xlator_t *subvol, inode_t *inode, char *name,
+                    ia_type_t type);
 #endif /* !_AFR_SELF_HEALD_H */
diff --git a/xlators/cluster/afr/src/afr-transaction.c b/xlators/cluster/afr/src/afr-transaction.c
index 35621d98493..a51f79b1f43 100644
--- a/xlators/cluster/afr/src/afr-transaction.c
+++ b/xlators/cluster/afr/src/afr-transaction.c
@@ -8,63 +8,167 @@
   cases as published by the Free Software Foundation.
 */
 
-#include "dict.h"
-#include "byte-order.h"
-#include "common-utils.h"
-#include "timer.h"
+#include <glusterfs/dict.h>
+#include <glusterfs/byte-order.h>
+#include <glusterfs/common-utils.h>
+#include <glusterfs/timer.h>
 
 #include "afr.h"
 #include "afr-transaction.h"
 #include "afr-self-heal.h"
 #include "afr-messages.h"
-#include "compound-fop-utils.h"
 
 #include <signal.h>
 
 typedef enum {
-        AFR_TRANSACTION_PRE_OP,
-        AFR_TRANSACTION_POST_OP,
+    AFR_TRANSACTION_PRE_OP,
+    AFR_TRANSACTION_POST_OP,
 } afr_xattrop_type_t;
 
+static void
+afr_lock_resume_shared(struct list_head *list);
+
+static void
+afr_post_op_handle_success(call_frame_t *frame, xlator_t *this);
+
+static void
+afr_post_op_handle_failure(call_frame_t *frame, xlator_t *this, int op_errno);
+
+void
+__afr_transaction_wake_shared(afr_local_t *local, struct list_head *shared);
+
+void
+afr_changelog_post_op_do(call_frame_t *frame, xlator_t *this);
+
+int
+afr_changelog_post_op_safe(call_frame_t *frame, xlator_t *this);
+
 gf_boolean_t
-afr_changelog_pre_op_uninherit (call_frame_t *frame, xlator_t *this);
+afr_changelog_pre_op_uninherit(call_frame_t *frame, xlator_t *this);
 
 gf_boolean_t
-afr_changelog_pre_op_update (call_frame_t *frame, xlator_t *this);
+afr_changelog_pre_op_update(call_frame_t *frame, xlator_t *this);
 
 int
-afr_changelog_call_count (afr_transaction_type type,
-                          unsigned char *pre_op_subvols,
-                          unsigned char *failed_subvols,
-                          unsigned int child_count);
+afr_changelog_call_count(afr_transaction_type type,
+                         unsigned char *pre_op_subvols,
+                         unsigned char *failed_subvols,
+                         unsigned int child_count);
+int
+afr_changelog_do(call_frame_t *frame, xlator_t *this, dict_t *xattr,
+                 afr_changelog_resume_t changelog_resume,
+                 afr_xattrop_type_t op);
+
+static void
+afr_ta_decide_post_op_state(call_frame_t *frame, xlator_t *this);
+
+static int
+afr_ta_post_op_do(void *opaque);
+
+static int
+afr_ta_post_op_synctask(xlator_t *this, afr_local_t *local);
+
+static int
+afr_changelog_post_op_done(call_frame_t *frame, xlator_t *this);
+
+static void
+afr_changelog_post_op_fail(call_frame_t *frame, xlator_t *this, int op_errno);
+
+void
+afr_ta_locked_priv_invalidate(afr_private_t *priv)
+{
+    priv->ta_bad_child_index = AFR_CHILD_UNKNOWN;
+    priv->release_ta_notify_dom_lock = _gf_false;
+    priv->ta_notify_dom_lock_offset = 0;
+}
+
+static void
+afr_ta_process_waitq(xlator_t *this)
+{
+    afr_local_t *entry = NULL;
+    afr_private_t *priv = this->private;
+    struct list_head waitq = {
+        0,
+    };
+
+    INIT_LIST_HEAD(&waitq);
+    LOCK(&priv->lock);
+    list_splice_init(&priv->ta_waitq, &waitq);
+    UNLOCK(&priv->lock);
+    list_for_each_entry(entry, &waitq, ta_waitq)
+    {
+        afr_ta_decide_post_op_state(entry->transaction.frame, this);
+    }
+}
+
 int
-afr_post_op_unlock_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-                       afr_changelog_resume_t changelog_resume,
-                       afr_xattrop_type_t op);
+afr_ta_lock_release_done(int ret, call_frame_t *ta_frame, void *opaque)
+{
+    afr_ta_process_waitq(ta_frame->this);
+    STACK_DESTROY(ta_frame->root);
+    return 0;
+}
+
 int
-afr_changelog_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-		  afr_changelog_resume_t changelog_resume,
-                  afr_xattrop_type_t op);
+afr_release_notify_lock_for_ta(void *opaque)
+{
+    xlator_t *this = NULL;
+    afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
+    int ret = -1;
+
+    this = (xlator_t *)opaque;
+    priv = this->private;
+    ret = afr_fill_ta_loc(this, &loc, _gf_true);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate loc for thin-arbiter.");
+        goto out;
+    }
+    flock.l_type = F_UNLCK;
+    flock.l_start = priv->ta_notify_dom_lock_offset;
+    flock.l_len = 1;
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_NOTIFY, &loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to unlock AFR_TA_DOM_NOTIFY lock.");
+    }
+
+    LOCK(&priv->lock);
+    {
+        afr_ta_locked_priv_invalidate(priv);
+    }
+    UNLOCK(&priv->lock);
+out:
+    loc_wipe(&loc);
+    return ret;
+}
 
 void
-afr_zero_fill_stat (afr_local_t *local)
-{
-        if (!local)
-                return;
-        if (local->transaction.type == AFR_DATA_TRANSACTION ||
-            local->transaction.type == AFR_METADATA_TRANSACTION) {
-                gf_zero_fill_stat (&local->cont.inode_wfop.prebuf);
-                gf_zero_fill_stat (&local->cont.inode_wfop.postbuf);
-        } else if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
-                   local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                gf_zero_fill_stat (&local->cont.dir_fop.buf);
-                gf_zero_fill_stat (&local->cont.dir_fop.preparent);
-                gf_zero_fill_stat (&local->cont.dir_fop.postparent);
-                if (local->transaction.type == AFR_ENTRY_TRANSACTION)
-                        return;
-                gf_zero_fill_stat (&local->cont.dir_fop.prenewparent);
-                gf_zero_fill_stat (&local->cont.dir_fop.postnewparent);
-        }
+afr_zero_fill_stat(afr_local_t *local)
+{
+    if (!local)
+        return;
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION) {
+        gf_zero_fill_stat(&local->cont.inode_wfop.prebuf);
+        gf_zero_fill_stat(&local->cont.inode_wfop.postbuf);
+    } else if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
+               local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
+        gf_zero_fill_stat(&local->cont.dir_fop.buf);
+        gf_zero_fill_stat(&local->cont.dir_fop.preparent);
+        gf_zero_fill_stat(&local->cont.dir_fop.postparent);
+        if (local->transaction.type == AFR_ENTRY_TRANSACTION)
+            return;
+        gf_zero_fill_stat(&local->cont.dir_fop.prenewparent);
+        gf_zero_fill_stat(&local->cont.dir_fop.postnewparent);
+    }
 }
 
 /* In case of errors afr needs to choose which xdata from lower xlators it needs
@@ -72,2613 +176,2752 @@ afr_zero_fill_stat (afr_local_t *local)
  * any good subvols which failed. Give preference to errnos other than
  * ENOTCONN even if the child is source */
 void
-afr_pick_error_xdata (afr_local_t *local, afr_private_t *priv,
-                      inode_t *inode1, unsigned char *readable1,
-                      inode_t *inode2, unsigned char *readable2)
-{
-        int     s = -1;/*selection*/
-        int     i = 0;
-        unsigned char *readable = NULL;
-
-        if (local->xdata_rsp) {
-                dict_unref (local->xdata_rsp);
-                local->xdata_rsp = NULL;
-        }
-
-        readable = alloca0 (priv->child_count * sizeof (*readable));
-        if (inode2 && readable2) {/*rename fop*/
-                AFR_INTERSECT (readable, readable1, readable2,
-                               priv->child_count);
-        } else {
-                memcpy (readable, readable1,
-                        sizeof (*readable) * priv->child_count);
-        }
-
+afr_pick_error_xdata(afr_local_t *local, afr_private_t *priv, inode_t *inode1,
+                     unsigned char *readable1, inode_t *inode2,
+                     unsigned char *readable2)
+{
+    int s = -1; /*selection*/
+    int i = 0;
+    unsigned char *readable = NULL;
+
+    if (local->xdata_rsp) {
+        dict_unref(local->xdata_rsp);
+        local->xdata_rsp = NULL;
+    }
+
+    readable = alloca0(priv->child_count * sizeof(*readable));
+    if (inode2 && readable2) { /*rename fop*/
+        AFR_INTERSECT(readable, readable1, readable2, priv->child_count);
+    } else {
+        memcpy(readable, readable1, sizeof(*readable) * priv->child_count);
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+
+        if (local->replies[i].op_ret >= 0)
+            continue;
+
+        if (local->replies[i].op_errno == ENOTCONN)
+            continue;
+
+        /*Order is important in the following condition*/
+        if ((s < 0) || (!readable[s] && readable[i]))
+            s = i;
+    }
+
+    if (s != -1 && local->replies[s].xdata) {
+        local->xdata_rsp = dict_ref(local->replies[s].xdata);
+    } else if (s == -1) {
         for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
+            if (!local->replies[i].valid)
+                continue;
 
-                if (local->replies[i].op_ret >= 0)
-                        continue;
+            if (local->replies[i].op_ret >= 0)
+                continue;
 
-                if (local->replies[i].op_errno == ENOTCONN)
-                        continue;
-
-                /*Order is important in the following condition*/
-                if ((s < 0) || (!readable[s] && readable[i]))
-                        s = i;
-        }
-
-        if (s != -1 && local->replies[s].xdata) {
-                local->xdata_rsp = dict_ref (local->replies[s].xdata);
-        } else if (s == -1) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->replies[i].valid)
-                                continue;
-
-                        if (local->replies[i].op_ret >= 0)
-                                continue;
-
-                        if (!local->replies[i].xdata)
-                                continue;
-                        local->xdata_rsp = dict_ref (local->replies[i].xdata);
-                        break;
-                }
+            if (!local->replies[i].xdata)
+                continue;
+            local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            break;
         }
+    }
 }
 
 gf_boolean_t
-afr_needs_changelog_update (afr_local_t *local)
+afr_needs_changelog_update(afr_local_t *local)
 {
-        if (local->transaction.type == AFR_DATA_TRANSACTION)
-                return _gf_true;
-        if (!local->optimistic_change_log)
-                return _gf_true;
-        return _gf_false;
+    if (local->transaction.type == AFR_DATA_TRANSACTION)
+        return _gf_true;
+    if (!local->optimistic_change_log)
+        return _gf_true;
+    return _gf_false;
 }
 
-int
-__afr_txn_write_fop (call_frame_t *frame, xlator_t *this)
+gf_boolean_t
+afr_changelog_has_quorum(afr_local_t *local, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int call_count = -1;
-        unsigned char *failed_subvols = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    unsigned char *success_children = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    priv = this->private;
+    success_children = alloca0(priv->child_count);
 
-        failed_subvols = local->transaction.failed_subvols;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.failed_subvols[i]) {
+            success_children[i] = 1;
+        }
+    }
 
-        call_count = priv->child_count - AFR_COUNT (failed_subvols,
-                                                    priv->child_count);
+    if (afr_has_quorum(success_children, this, NULL)) {
+        return _gf_true;
+    }
 
-        if (call_count == 0) {
-                local->transaction.resume (frame, this);
-                return 0;
-        }
+    return _gf_false;
+}
 
-        local->call_count = call_count;
+gf_boolean_t
+afr_is_write_subvol_valid(call_frame_t *frame, xlator_t *this)
+{
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    uint64_t write_subvol = 0;
+    unsigned char *writable = NULL;
+    uint16_t datamap = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i] && !failed_subvols[i]) {
-			local->transaction.wind (frame, this, i);
+    local = frame->local;
+    priv = this->private;
+    writable = alloca0(priv->child_count);
 
-                        if (!--call_count)
-                                break;
-                }
-        }
+    write_subvol = afr_write_subvol_get(frame, this);
+    datamap = (write_subvol & 0x00000000ffff0000) >> 16;
+    for (i = 0; i < priv->child_count; i++) {
+        if (datamap & (1 << i))
+            writable[i] = 1;
 
-        return 0;
-}
+        if (writable[i] && !local->transaction.failed_subvols[i])
+            return _gf_true;
+    }
 
+    return _gf_false;
+}
 
 int
-__afr_txn_write_done (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        gf_boolean_t unwind = _gf_false;
+afr_transaction_fop(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+    unsigned char *failed_subvols = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    failed_subvols = local->transaction.failed_subvols;
+    call_count = priv->child_count -
+                 AFR_COUNT(failed_subvols, priv->child_count);
+    /* Fail if pre-op did not succeed on quorum no. of bricks. */
+    if (!afr_changelog_has_quorum(local, this) || !call_count) {
+        local->op_ret = -1;
+        /* local->op_errno is already captured in changelog cbk. */
+        afr_transaction_resume(frame, this);
+        return 0;
+    }
 
-        priv  = this->private;
-        local = frame->local;
+    /* Fail if at least one writeable brick isn't up.*/
+    if (local->transaction.type == AFR_DATA_TRANSACTION &&
+        !afr_is_write_subvol_valid(frame, this)) {
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        afr_transaction_resume(frame, this);
+        return 0;
+    }
 
-        if (priv->consistent_metadata) {
-                LOCK (&frame->lock);
-                {
-                        unwind = (local->transaction.main_frame != NULL);
-                }
-                UNLOCK (&frame->lock);
-                if (unwind)/*It definitely did post-op*/
-                        afr_zero_fill_stat (local);
-        }
-        local->transaction.unwind (frame, this);
+    local->call_count = call_count;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] && !failed_subvols[i]) {
+            local->transaction.wind(frame, this, i);
 
-        AFR_STACK_DESTROY (frame);
+            if (!--call_count)
+                break;
+        }
+    }
 
-        return 0;
+    return 0;
 }
 
-
-call_frame_t*
-afr_transaction_detach_fop_frame (call_frame_t *frame)
+int
+afr_transaction_done(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *fop_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t unwind = _gf_false;
+    afr_lock_t *lock = NULL;
+    afr_local_t *lock_local = NULL;
 
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        afr_handle_inconsistent_fop (frame, &local->op_ret, &local->op_errno);
-        LOCK (&frame->lock);
+    if (priv->consistent_metadata) {
+        LOCK(&frame->lock);
         {
-                fop_frame = local->transaction.main_frame;
-                local->transaction.main_frame = NULL;
+            unwind = (local->transaction.main_frame != NULL);
         }
-        UNLOCK (&frame->lock);
+        UNLOCK(&frame->lock);
+        if (unwind) /*It definitely did post-op*/
+            afr_zero_fill_stat(local);
+    }
 
-        return fop_frame;
+    if (local->transaction.do_eager_unlock) {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        LOCK(&local->inode->lock);
+        {
+            lock->acquired = _gf_false;
+            lock->release = _gf_false;
+            list_splice_init(&lock->frozen, &lock->waiting);
+            if (list_empty(&lock->waiting))
+                goto unlock;
+            lock_local = list_entry(lock->waiting.next, afr_local_t,
+                                    transaction.wait_list);
+            list_del_init(&lock_local->transaction.wait_list);
+            list_add(&lock_local->transaction.owner_list, &lock->owners);
+        }
+    unlock:
+        UNLOCK(&local->inode->lock);
+    }
+    if (lock_local) {
+        afr_lock(lock_local->transaction.frame,
+                 lock_local->transaction.frame->this);
+    }
+    local->transaction.unwind(frame, this);
+
+    GF_ASSERT(list_empty(&local->transaction.owner_list));
+    GF_ASSERT(list_empty(&local->transaction.wait_list));
+    AFR_STACK_DESTROY(frame);
+
+    return 0;
 }
 
-
 static void
-afr_save_lk_owner (call_frame_t *frame)
+afr_lock_fail_shared(afr_local_t *local, struct list_head *list)
 {
-        afr_local_t * local = NULL;
+    afr_local_t *each = NULL;
 
-        local = frame->local;
-
-        local->saved_lk_owner = frame->root->lk_owner;
+    while (!list_empty(list)) {
+        each = list_entry(list->next, afr_local_t, transaction.wait_list);
+        list_del_init(&each->transaction.wait_list);
+        each->op_ret = -1;
+        each->op_errno = local->op_errno;
+        afr_transaction_done(each->transaction.frame,
+                             each->transaction.frame->this);
+    }
 }
 
-
 static void
-afr_restore_lk_owner (call_frame_t *frame)
+afr_handle_lock_acquire_failure(afr_local_t *local)
 {
-        afr_local_t * local = NULL;
+    struct list_head shared;
+    afr_lock_t *lock = NULL;
 
-        local = frame->local;
+    if (!local->transaction.eager_lock_on)
+        goto out;
 
-        frame->root->lk_owner = local->saved_lk_owner;
-}
+    lock = &local->inode_ctx->lock[local->transaction.type];
 
-void
-__mark_all_success (call_frame_t *frame, xlator_t *this)
-{
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int i;
+    INIT_LIST_HEAD(&shared);
+    LOCK(&local->inode->lock);
+    {
+        lock->release = _gf_true;
+        list_splice_init(&lock->waiting, &shared);
+    }
+    UNLOCK(&local->inode->lock);
 
-	local = frame->local;
-	priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-		local->transaction.failed_subvols[i] = 0;
-	}
+    afr_lock_fail_shared(local, &shared);
+    local->transaction.do_eager_unlock = _gf_true;
+out:
+    local->internal_lock.lock_cbk = afr_transaction_done;
+    afr_unlock(local->transaction.frame, local->transaction.frame->this);
 }
 
-void
-afr_compute_pre_op_sources (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        afr_transaction_type type = -1;
-        dict_t *xdata = NULL;
-        int **matrix = NULL;
-        int idx = -1;
-        int i = 0;
-        int j = 0;
-
-        priv = this->private;
-        local = frame->local;
-        type = local->transaction.type;
-        idx = afr_index_for_transaction_type (type);
-        matrix = ALLOC_MATRIX (priv->child_count, int);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op_xdata[i])
-                        continue;
-                xdata = local->transaction.pre_op_xdata[i];
-                afr_selfheal_fill_matrix (this, matrix, i, idx, xdata);
-        }
+call_frame_t *
+afr_transaction_detach_fop_frame(call_frame_t *frame)
+{
+    afr_local_t *local = NULL;
+    call_frame_t *fop_frame = NULL;
 
-        memset (local->transaction.pre_op_sources, 1, priv->child_count);
+    local = frame->local;
 
-        /*If lock or pre-op failed on a brick, it is not a source. */
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.failed_subvols[i])
-                        local->transaction.pre_op_sources[i] = 0;
-        }
+    afr_handle_inconsistent_fop(frame, &local->op_ret, &local->op_errno);
+    LOCK(&frame->lock);
+    {
+        fop_frame = local->transaction.main_frame;
+        local->transaction.main_frame = NULL;
+    }
+    UNLOCK(&frame->lock);
 
-        /* If brick is blamed by others, it is not a source. */
-        for (i = 0; i < priv->child_count; i++)
-                for (j = 0; j < priv->child_count; j++)
-                        if (matrix[i][j] != 0)
-                                local->transaction.pre_op_sources[j] = 0;
-
-        /*We don't need the xattrs any more. */
-        for (i = 0; i < priv->child_count; i++)
-                if (local->transaction.pre_op_xdata[i]) {
-                        dict_unref (local->transaction.pre_op_xdata[i]);
-                        local->transaction.pre_op_xdata[i] = NULL;
-                }
+    return fop_frame;
 }
 
-gf_boolean_t
-afr_has_arbiter_fop_cbk_quorum (call_frame_t *frame)
+static void
+afr_save_lk_owner(call_frame_t *frame)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        xlator_t *this = NULL;
-        gf_boolean_t fop_failed = _gf_false;
-        unsigned char *pre_op_sources = NULL;
-        int i = 0;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        this = frame->this;
-        priv  = this->private;
-        pre_op_sources = local->transaction.pre_op_sources;
+    local = frame->local;
 
-        /* If the fop failed on the brick, it is not a source. */
-        for (i = 0; i < priv->child_count; i++)
-                if (local->transaction.failed_subvols[i])
-                        pre_op_sources[i] = 0;
+    local->saved_lk_owner = frame->root->lk_owner;
+}
 
-        switch (AFR_COUNT (pre_op_sources, priv->child_count)) {
-        case 1:
-                if (pre_op_sources[ARBITER_BRICK_INDEX])
-                        fop_failed = _gf_true;
-                break;
-        case 0:
-                fop_failed = _gf_true;
-                break;
-        }
+static void
+afr_restore_lk_owner(call_frame_t *frame)
+{
+    afr_local_t *local = NULL;
 
-        if (fop_failed)
-                return _gf_false;
+    local = frame->local;
 
-        return _gf_true;
+    frame->root->lk_owner = local->saved_lk_owner;
 }
 
 void
-afr_txn_arbitrate_fop (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int pre_op_sources_count = 0;
-
-        priv = this->private;
-        local = frame->local;
-
-        afr_compute_pre_op_sources (frame, this);
-        pre_op_sources_count = AFR_COUNT (local->transaction.pre_op_sources,
-                                          priv->child_count);
-
-        /* If arbiter is the only source, do not proceed. */
-        if (pre_op_sources_count < 2 &&
-            local->transaction.pre_op_sources[ARBITER_BRICK_INDEX]) {
-                local->internal_lock.lock_cbk = local->transaction.done;
-                local->op_ret = -1;
-                local->op_errno =  ENOTCONN;
-                afr_restore_lk_owner (frame);
-                afr_unlock (frame, this);
-        } else {
-                local->transaction.fop (frame, this);
-        }
-
-        return;
-}
-
-int
-afr_transaction_perform_fop (call_frame_t *frame, xlator_t *this)
+__mark_all_success(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t     *local = NULL;
-        afr_private_t   *priv = NULL;
-        fd_t            *fd   = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i;
 
-        local = frame->local;
-        priv = this->private;
-        fd    = local->fd;
+    local = frame->local;
+    priv = this->private;
 
-        /*  Perform fops with the lk-owner from top xlator.
-         *  Eg: lk-owner of posix-lk and flush should be same,
-         *  flush cant clear the  posix-lks without that lk-owner.
-         */
-        afr_save_lk_owner (frame);
-        frame->root->lk_owner =
-                local->transaction.main_frame->root->lk_owner;
-
-	if (local->pre_op_compat)
-		/* old mode, pre-op was done as afr_changelog_do()
-		   just now, before OP */
-		afr_changelog_pre_op_update (frame, this);
-
-        /* The wake up needs to happen independent of
-           what type of fop arrives here. If it was
-           a write, then it has already inherited the
-           lock and changelog. If it was not a write,
-           then the presumption of the optimization (of
-           optimizing for successive write operations)
-           fails.
-        */
-        if (fd)
-                afr_delayed_changelog_wake_up (this, fd);
-        if (priv->arbiter_count == 1) {
-                afr_txn_arbitrate_fop (frame, this);
-        } else {
-                local->transaction.fop (frame, this);
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        local->transaction.failed_subvols[i] = 0;
+    }
+}
 
-	return 0;
+void
+afr_compute_pre_op_sources(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_transaction_type type = -1;
+    dict_t *xdata = NULL;
+    int **matrix = NULL;
+    int idx = -1;
+    int i = 0;
+    int j = 0;
+
+    priv = this->private;
+    local = frame->local;
+    type = local->transaction.type;
+    idx = afr_index_for_transaction_type(type);
+    matrix = ALLOC_MATRIX(priv->child_count, int);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.changelog_xdata[i])
+            continue;
+        xdata = local->transaction.changelog_xdata[i];
+        afr_selfheal_fill_matrix(this, matrix, i, idx, xdata);
+    }
+
+    memset(local->transaction.pre_op_sources, 1, priv->child_count);
+
+    /*If lock or pre-op failed on a brick, it is not a source. */
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i])
+            local->transaction.pre_op_sources[i] = 0;
+    }
+
+    /* If brick is blamed by others, it is not a source. */
+    for (i = 0; i < priv->child_count; i++)
+        for (j = 0; j < priv->child_count; j++)
+            if (matrix[i][j] != 0)
+                local->transaction.pre_op_sources[j] = 0;
 }
 
-static int
-__changelog_enabled (afr_private_t *priv, afr_transaction_type type)
+void
+afr_txn_arbitrate_fop(call_frame_t *frame, xlator_t *this)
 {
-        int ret = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int pre_op_sources_count = 0;
+    int i = 0;
 
-        switch (type) {
-        case AFR_DATA_TRANSACTION:
-                if (priv->data_change_log)
-                        ret = 1;
+    priv = this->private;
+    local = frame->local;
 
-                break;
+    afr_compute_pre_op_sources(frame, this);
+    pre_op_sources_count = AFR_COUNT(local->transaction.pre_op_sources,
+                                     priv->child_count);
 
-        case AFR_METADATA_TRANSACTION:
-                if (priv->metadata_change_log)
-                        ret = 1;
-
-                break;
-
-        case AFR_ENTRY_TRANSACTION:
-        case AFR_ENTRY_RENAME_TRANSACTION:
-                if (priv->entry_change_log)
-                        ret = 1;
+    /* If arbiter is the only source, do not proceed. */
+    if (pre_op_sources_count < 2 &&
+        local->transaction.pre_op_sources[ARBITER_BRICK_INDEX]) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        for (i = 0; i < priv->child_count; i++)
+            local->transaction.failed_subvols[i] = 1;
+    }
 
-                break;
-        }
+    afr_transaction_fop(frame, this);
 
-        return ret;
+    return;
 }
 
+int
+afr_transaction_perform_fop(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int ret = 0;
+    int failure_count = 0;
+    struct list_head shared;
+    afr_lock_t *lock = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    INIT_LIST_HEAD(&shared);
+    if (local->transaction.type == AFR_DATA_TRANSACTION &&
+        !local->transaction.inherited) {
+        ret = afr_write_subvol_set(frame, this);
+        if (ret) {
+            /*act as if operation failed on all subvols*/
+            local->op_ret = -1;
+            local->op_errno = -ret;
+            for (i = 0; i < priv->child_count; i++)
+                local->transaction.failed_subvols[i] = 1;
+        }
+    }
+
+    if (local->pre_op_compat)
+        /* old mode, pre-op was done as afr_changelog_do()
+           just now, before OP */
+        afr_changelog_pre_op_update(frame, this);
+
+    if (!local->transaction.eager_lock_on || local->transaction.inherited)
+        goto fop;
+    failure_count = AFR_COUNT(local->transaction.failed_subvols,
+                              priv->child_count);
+    if (failure_count == priv->child_count) {
+        afr_handle_lock_acquire_failure(local);
+        return 0;
+    } else {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        LOCK(&local->inode->lock);
+        {
+            lock->acquired = _gf_true;
+            __afr_transaction_wake_shared(local, &shared);
+        }
+        UNLOCK(&local->inode->lock);
+    }
 
-static int
-__fop_changelog_needed (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t * priv  = NULL;
-        afr_local_t   * local = NULL;
-        int op_ret = 0;
-        afr_transaction_type type = -1;
-
-        priv  = this->private;
-        local = frame->local;
-        type  = local->transaction.type;
-
-        if (__changelog_enabled (priv, type)) {
-                switch (local->op) {
-
-                case GF_FOP_WRITE:
-                case GF_FOP_FTRUNCATE:
-                        op_ret = 1;
-                        break;
-
-                case GF_FOP_FLUSH:
-                        op_ret = 0;
-                        break;
+fop:
+    /*  Perform fops with the lk-owner from top xlator.
+     *  Eg: lk-owner of posix-lk and flush should be same,
+     *  flush cant clear the  posix-lks without that lk-owner.
+     */
+    afr_save_lk_owner(frame);
+    frame->root->lk_owner = local->transaction.main_frame->root->lk_owner;
 
-                default:
-                        op_ret = 1;
-                }
-        }
+    if (priv->arbiter_count == 1) {
+        afr_txn_arbitrate_fop(frame, this);
+    } else {
+        afr_transaction_fop(frame, this);
+    }
 
-        return op_ret;
+    afr_lock_resume_shared(&shared);
+    return 0;
 }
 
-
 int
-afr_set_pending_dict (afr_private_t *priv, dict_t *xattr, int **pending)
+afr_set_pending_dict(afr_private_t *priv, dict_t *xattr, int **pending)
 {
-        int i = 0;
-        int ret = 0;
-
-        for (i = 0; i < priv->child_count; i++) {
+    int i = 0;
+    int ret = 0;
 
-                ret = dict_set_static_bin (xattr, priv->pending_key[i],
-					   pending[i],
-					   AFR_NUM_CHANGE_LOGS * sizeof (int));
-                /* 3 = data+metadata+entry */
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], pending[i],
+                                  AFR_NUM_CHANGE_LOGS * sizeof(int));
+        /* 3 = data+metadata+entry */
 
-                if (ret)
-                        break;
-        }
+        if (ret)
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
-int
-afr_lock_server_count (afr_private_t *priv, afr_transaction_type type)
-{
-        int ret = 0;
-
-        switch (type) {
-        case AFR_DATA_TRANSACTION:
-                ret = priv->child_count;
+static void
+afr_ta_dom_lock_check_and_release(afr_ta_fop_state_t fop_state, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    unsigned int inmem_count = 0;
+    unsigned int onwire_count = 0;
+    gf_boolean_t release = _gf_false;
+
+    LOCK(&priv->lock);
+    {
+        /*Once we get notify lock release upcall notification,
+         if any of the fop state counters are non-zero, we will
+         not release the lock.
+         */
+        onwire_count = priv->ta_on_wire_txn_count;
+        inmem_count = priv->ta_in_mem_txn_count;
+        switch (fop_state) {
+            case TA_GET_INFO_FROM_TA_FILE:
+                onwire_count = --priv->ta_on_wire_txn_count;
                 break;
-
-        case AFR_METADATA_TRANSACTION:
-                ret = priv->child_count;
+            case TA_INFO_IN_MEMORY_SUCCESS:
+            case TA_INFO_IN_MEMORY_FAILED:
+                inmem_count = --priv->ta_in_mem_txn_count;
                 break;
-
-        case AFR_ENTRY_TRANSACTION:
-        case AFR_ENTRY_RENAME_TRANSACTION:
-                ret = priv->child_count;
+            case TA_WAIT_FOR_NOTIFY_LOCK_REL:
+                GF_ASSERT(0);
+                break;
+            case TA_SUCCESS:
                 break;
         }
+        release = priv->release_ta_notify_dom_lock;
+    }
+    UNLOCK(&priv->lock);
+
+    if (inmem_count != 0 || release == _gf_false || onwire_count != 0)
+        return;
 
-        return ret;
+    afr_ta_lock_release_synctask(this);
 }
 
-/* {{{ pending */
+static void
+afr_ta_process_onwireq(afr_ta_fop_state_t fop_state, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    afr_local_t *entry = NULL;
+    int bad_child = AFR_CHILD_UNKNOWN;
+
+    struct list_head onwireq = {
+        0,
+    };
+    INIT_LIST_HEAD(&onwireq);
+
+    LOCK(&priv->lock);
+    {
+        bad_child = priv->ta_bad_child_index;
+        if (bad_child == AFR_CHILD_UNKNOWN) {
+            /*The previous on-wire ta_post_op was a failure. Just dequeue
+             *one element to wind on-wire again. */
+            entry = list_entry(priv->ta_onwireq.next, afr_local_t, ta_onwireq);
+            list_del_init(&entry->ta_onwireq);
+        } else {
+            /* Prepare to process all fops based on bad_child_index. */
+            list_splice_init(&priv->ta_onwireq, &onwireq);
+        }
+    }
+    UNLOCK(&priv->lock);
 
+    if (entry) {
+        afr_ta_post_op_synctask(this, entry);
+        return;
+    } else {
+        while (!list_empty(&onwireq)) {
+            entry = list_entry(onwireq.next, afr_local_t, ta_onwireq);
+            list_del_init(&entry->ta_onwireq);
+            if (entry->ta_failed_subvol == bad_child) {
+                afr_post_op_handle_success(entry->transaction.frame, this);
+            } else {
+                afr_post_op_handle_failure(entry->transaction.frame, this, EIO);
+            }
+        }
+    }
+}
 
 int
-afr_changelog_post_op_done (call_frame_t *frame, xlator_t *this)
+afr_changelog_post_op_done(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-
-	local = frame->local;
-	priv = this->private;
-        int_lock = &local->internal_lock;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_private_t *priv = NULL;
 
-	if (local->transaction.resume_stub) {
-		call_resume (local->transaction.resume_stub);
-		local->transaction.resume_stub = NULL;
-	}
+    local = frame->local;
+    priv = this->private;
+    int_lock = &local->internal_lock;
 
-	if (afr_lock_server_count (priv, local->transaction.type) == 0) {
-		local->transaction.done (frame, this);
-	} else {
-		int_lock->lock_cbk = local->transaction.done;
-		afr_unlock (frame, this);
-	}
+    if (priv->thin_arbiter_count) {
+        /*fop should not come here with TA_WAIT_FOR_NOTIFY_LOCK_REL state */
+        afr_ta_dom_lock_check_and_release(local->fop_state, this);
+    }
 
-	return 0;
-}
+    /* Fail the FOP if post-op did not succeed on quorum no. of bricks. */
+    if (!afr_changelog_has_quorum(local, this)) {
+        local->op_ret = -1;
+        /*local->op_errno is already captured in changelog cbk*/
+    }
 
+    if (local->transaction.resume_stub) {
+        call_resume(local->transaction.resume_stub);
+        local->transaction.resume_stub = NULL;
+    }
 
-afr_inodelk_t*
-afr_get_inodelk (afr_internal_lock_t *int_lock, char *dom)
-{
-        afr_inodelk_t *inodelk = NULL;
-        int           i = 0;
+    int_lock->lock_cbk = afr_transaction_done;
+    afr_unlock(frame, this);
 
-        for (i = 0; int_lock->inodelk[i].domain; i++) {
-                inodelk = &int_lock->inodelk[i];
-                if (strcmp (dom, inodelk->domain) == 0)
-                        return inodelk;
-        }
-        return NULL;
+    return 0;
 }
 
-unsigned char*
-afr_locked_nodes_get (afr_transaction_type type, afr_internal_lock_t *int_lock)
+static void
+afr_changelog_post_op_fail(call_frame_t *frame, xlator_t *this, int op_errno)
 {
-        unsigned char *locked_nodes = NULL;
-        afr_inodelk_t *inodelk = NULL;
-        switch (type) {
-        case AFR_DATA_TRANSACTION:
-        case AFR_METADATA_TRANSACTION:
-                inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-                locked_nodes = inodelk->locked_nodes;
-        break;
+    afr_local_t *local = frame->local;
+    local->op_ret = -1;
+    local->op_errno = op_errno;
 
-        case AFR_ENTRY_TRANSACTION:
-        case AFR_ENTRY_RENAME_TRANSACTION:
-                /*Because same set of subvols participate in all lockee
-                 * entities*/
-                locked_nodes = int_lock->lockee[0].locked_nodes;
-        break;
-        }
-        return locked_nodes;
+    gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_THIN_ARB,
+           "Failing %s for gfid %s. Fop state is:%d", gf_fop_list[local->op],
+           uuid_utoa(local->inode->gfid), local->fop_state);
+
+    afr_changelog_post_op_done(frame, this);
 }
 
+unsigned char *
+afr_locked_nodes_get(afr_transaction_type type, afr_internal_lock_t *int_lock)
+{
+    /*Because same set of subvols participate in all lockee
+     * entities*/
+    return int_lock->lockee[0].locked_nodes;
+}
 
 int
-afr_changelog_call_count (afr_transaction_type type,
-			  unsigned char *pre_op_subvols,
-                          unsigned char *failed_subvols,
-			  unsigned int child_count)
+afr_changelog_call_count(afr_transaction_type type,
+                         unsigned char *pre_op_subvols,
+                         unsigned char *failed_subvols,
+                         unsigned int child_count)
 {
-        int i = 0;
-        int call_count = 0;
+    int i = 0;
+    int call_count = 0;
 
-        for (i = 0; i < child_count; i++) {
-                if (pre_op_subvols[i] && !failed_subvols[i]) {
-                        call_count++;
-                }
+    for (i = 0; i < child_count; i++) {
+        if (pre_op_subvols[i] && !failed_subvols[i]) {
+            call_count++;
         }
+    }
 
-        if (type == AFR_ENTRY_RENAME_TRANSACTION)
-                call_count *= 2;
+    if (type == AFR_ENTRY_RENAME_TRANSACTION)
+        call_count *= 2;
 
-        return call_count;
+    return call_count;
 }
 
-
 gf_boolean_t
-afr_txn_nothing_failed (call_frame_t *frame, xlator_t *this)
+afr_txn_nothing_failed(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i] &&
-                    local->transaction.failed_subvols[i])
-                        return _gf_false;
-        }
+    if (priv->thin_arbiter_count) {
+        /* We need to perform post-op even if 1 data brick was down
+         * before the txn started.*/
+        if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count))
+            return _gf_false;
+    }
 
-        return _gf_true;
-}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] &&
+            local->transaction.failed_subvols[i])
+            return _gf_false;
+    }
 
+    return _gf_true;
+}
 
 void
-afr_handle_symmetric_errors (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int op_errno = 0;
-	int i_errno = 0;
-	gf_boolean_t matching_errors = _gf_true;
-	int i = 0;
-
-	priv = this->private;
-	local = frame->local;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret != -1) {
-			/* Operation succeeded on at least on subvol,
-			   so it is not a failed-everywhere situation.
-			*/
-			matching_errors = _gf_false;
-			break;
-		}
-		i_errno = local->replies[i].op_errno;
-
-		if (i_errno == ENOTCONN) {
-			/* ENOTCONN is not a symmetric error. We do not
-			   know if the operation was performed on the
-			   backend or not.
-			*/
-			matching_errors = _gf_false;
-			break;
-		}
-
-		if (!op_errno) {
-			op_errno = i_errno;
-		} else if (op_errno != i_errno) {
-			/* Mismatching op_errno's */
-			matching_errors = _gf_false;
-			break;
-		}
-	}
-
-	if (matching_errors)
-		__mark_all_success (frame, this);
+afr_handle_symmetric_errors(call_frame_t *frame, xlator_t *this)
+{
+    if (afr_is_symmetric_error(frame, this))
+        __mark_all_success(frame, this);
 }
 
 gf_boolean_t
-afr_has_quorum (unsigned char *subvols, xlator_t *this)
-{
-        unsigned int  quorum_count = 0;
-        afr_private_t *priv  = NULL;
-        unsigned int  up_children_count = 0;
-
-        priv = this->private;
-        up_children_count = AFR_COUNT (subvols, priv->child_count);
-
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                /*
-                 * Special case for auto-quorum with an even number of nodes.
-                 *
-                 * A replica set with even count N can only handle the same
-                 * number of failures as odd N-1 before losing "vanilla"
-                 * quorum, and the probability of more simultaneous failures is
-                 * actually higher.  For example, with a 1% chance of failure
-                 * we'd have a 0.03% chance of two simultaneous failures with
-                 * N=3 but a 0.06% chance with N=4.  However, the special case
-                 * is necessary for N=2 because there's no real quorum in that
-                 * case (i.e. can't normally survive *any* failures).  In that
-                 * case, we treat the first node as a tie-breaker, allowing
-                 * quorum to be retained in some cases while still honoring the
-                 * all-important constraint that there can not simultaneously
-                 * be two partitioned sets of nodes each believing they have
-                 * quorum.  Of two equally sized sets, the one without that
-                 * first node will lose.
-                 *
-                 * It turns out that the special case is beneficial for higher
-                 * values of N as well.  Continuing the example above, the
-                 * probability of losing quorum with N=4 and this type of
-                 * quorum is (very) slightly lower than with N=3 and vanilla
-                 * quorum.  The difference becomes even more pronounced with
-                 * higher N.  Therefore, even though such replica counts are
-                 * unlikely to be seen in practice, we might as well use the
-                 * "special" quorum then as well.
-                 */
-                if ((up_children_count * 2) == priv->child_count) {
-                        return subvols[0];
-                }
-        }
+afr_has_quorum(unsigned char *subvols, xlator_t *this, call_frame_t *frame)
+{
+    unsigned int quorum_count = 0;
+    afr_private_t *priv = NULL;
+    unsigned int up_children_count = 0;
 
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                quorum_count = priv->child_count/2 + 1;
-        } else {
-                quorum_count = priv->quorum_count;
+    priv = this->private;
+    up_children_count = AFR_COUNT(subvols, priv->child_count);
+
+    if (afr_lookup_has_quorum(frame, up_children_count))
+        return _gf_true;
+
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        /*
+         * Special case for auto-quorum with an even number of nodes.
+         *
+         * A replica set with even count N can only handle the same
+         * number of failures as odd N-1 before losing "vanilla"
+         * quorum, and the probability of more simultaneous failures is
+         * actually higher.  For example, with a 1% chance of failure
+         * we'd have a 0.03% chance of two simultaneous failures with
+         * N=3 but a 0.06% chance with N=4.  However, the special case
+         * is necessary for N=2 because there's no real quorum in that
+         * case (i.e. can't normally survive *any* failures).  In that
+         * case, we treat the first node as a tie-breaker, allowing
+         * quorum to be retained in some cases while still honoring the
+         * all-important constraint that there can not simultaneously
+         * be two partitioned sets of nodes each believing they have
+         * quorum.  Of two equally sized sets, the one without that
+         * first node will lose.
+         *
+         * It turns out that the special case is beneficial for higher
+         * values of N as well.  Continuing the example above, the
+         * probability of losing quorum with N=4 and this type of
+         * quorum is (very) slightly lower than with N=3 and vanilla
+         * quorum.  The difference becomes even more pronounced with
+         * higher N.  Therefore, even though such replica counts are
+         * unlikely to be seen in practice, we might as well use the
+         * "special" quorum then as well.
+         */
+        if ((up_children_count * 2) == priv->child_count) {
+            return subvols[0];
         }
+    }
 
-        if (up_children_count >= quorum_count)
-                return _gf_true;
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        quorum_count = priv->child_count / 2 + 1;
+    } else {
+        quorum_count = priv->quorum_count;
+    }
 
-        return _gf_false;
+    if (up_children_count >= quorum_count)
+        return _gf_true;
+
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_has_fop_quorum (call_frame_t *frame)
+afr_has_fop_quorum(call_frame_t *frame)
 {
-        xlator_t        *this = frame->this;
-        afr_local_t     *local = frame->local;
-        unsigned char *locked_nodes = NULL;
+    xlator_t *this = frame->this;
+    afr_local_t *local = frame->local;
+    unsigned char *locked_nodes = NULL;
 
-        locked_nodes = afr_locked_nodes_get (local->transaction.type,
-                                             &local->internal_lock);
-        return afr_has_quorum (locked_nodes, this);
+    locked_nodes = afr_locked_nodes_get(local->transaction.type,
+                                        &local->internal_lock);
+    return afr_has_quorum(locked_nodes, this, NULL);
 }
 
 static gf_boolean_t
-afr_has_fop_cbk_quorum (call_frame_t *frame)
+afr_has_fop_cbk_quorum(call_frame_t *frame)
 {
-        afr_local_t   *local   = frame->local;
-        xlator_t      *this    = frame->this;
-        afr_private_t *priv    = this->private;
-        unsigned char *success = alloca0(priv->child_count);
-        int           i        = 0;
+    afr_local_t *local = frame->local;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
+    unsigned char *success = alloca0(priv->child_count);
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i])
-                        if (!local->transaction.failed_subvols[i])
-                                success[i] = 1;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i])
+            if (!local->transaction.failed_subvols[i])
+                success[i] = 1;
+    }
 
-        return afr_has_quorum (success, this);
+    return afr_has_quorum(success, this, NULL);
 }
 
-void
-afr_handle_quorum (call_frame_t *frame)
+gf_boolean_t
+afr_need_dirty_marking(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int           i      = 0;
-        const char    *file  = NULL;
-        uuid_t        gfid   = {0};
+    afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    gf_boolean_t need_dirty = _gf_false;
 
-        local = frame->local;
-        priv  = frame->this->private;
+    local = frame->local;
 
-        if (priv->quorum_count == 0)
-                return;
+    if (!priv->quorum_count || !local->optimistic_change_log)
+        return _gf_false;
 
-        /* If the fop already failed return right away to preserve errno */
-        if (local->op_ret == -1)
-                return;
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION)
+        return _gf_false;
 
-        /*
-         * Network split may happen just after the fops are unwound, so check
-         * if the fop succeeded in a way it still follows quorum. If it doesn't,
-         * mark the fop as failure, mark the changelogs so it reflects that
-         * failure.
-         *
-         * Scenario:
-         * There are 3 mounts on 3 machines(node1, node2, node3) all writing to
-         * single file. Network split happened in a way that node1 can't see
-         * node2, node3. Node2, node3 both of them can't see node1. Now at the
-         * time of sending write all the bricks are up. Just after write fop is
-         * wound on node1, network split happens. Node1 thinks write fop failed
-         * on node2, node3 so marks pending changelog for those 2 extended
-         * attributes on node1. Node2, node3 thinks writes failed on node1 so
-         * they mark pending changelog for node1. When the network is stable
-         * again the file already is in split-brain. These checks prevent
-         * marking pending changelog on other subvolumes if the fop doesn't
-         * succeed in a way it is still following quorum. So with this fix what
-         * is happening is, node1 will have all pending changelog(FOOL) because
-         * the write succeeded only on node1 but failed on node2, node3 so
-         * instead of marking pending changelogs on node2, node3 it just treats
-         * the fop as failure and goes into DIRTY state. Where as node2, node3
-         * say they are sources and have pending changelog to node1 so there is
-         * no split-brain with the fix. The problem is eliminated completely.
-         */
+    if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count) ==
+        priv->child_count)
+        return _gf_false;
 
-        if (priv->arbiter_count) {
-                if (afr_has_arbiter_fop_cbk_quorum (frame))
-                        return;
-        } else if (afr_has_fop_cbk_quorum (frame)) {
-                return;
-        }
+    if (!afr_has_fop_cbk_quorum(frame))
+        need_dirty = _gf_true;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i])
-                        afr_transaction_fop_failed (frame, frame->this, i);
-        }
+    return need_dirty;
+}
 
-        local->op_ret = -1;
-        local->op_errno = afr_final_errno (local, priv);
-        if (local->op_errno == 0)
-                local->op_errno = afr_quorum_errno (priv);
+void
+afr_handle_quorum(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    const char *file = NULL;
+    uuid_t gfid = {0};
 
-        if (local->fd) {
-                gf_uuid_copy (gfid, local->fd->inode->gfid);
-                file = uuid_utoa (gfid);
-        } else {
-                loc_path (&local->loc, local->loc.name);
-                file = local->loc.path;
-        }
+    local = frame->local;
+    priv = frame->this->private;
 
-        gf_msg (frame->this->name, GF_LOG_WARNING, local->op_errno,
-                AFR_MSG_QUORUM_FAIL, "%s: Failing %s as quorum is not met",
-                file, gf_fop_list[local->op]);
+    if (priv->quorum_count == 0)
+        return;
 
-        switch (local->transaction.type) {
+    /* If the fop already failed return right away to preserve errno */
+    if (local->op_ret == -1)
+        return;
+
+    /*
+     * Network split may happen just after the fops are unwound, so check
+     * if the fop succeeded in a way it still follows quorum. If it doesn't,
+     * mark the fop as failure, mark the changelogs so it reflects that
+     * failure.
+     *
+     * Scenario:
+     * There are 3 mounts on 3 machines(node1, node2, node3) all writing to
+     * single file. Network split happened in a way that node1 can't see
+     * node2, node3. Node2, node3 both of them can't see node1. Now at the
+     * time of sending write all the bricks are up. Just after write fop is
+     * wound on node1, network split happens. Node1 thinks write fop failed
+     * on node2, node3 so marks pending changelog for those 2 extended
+     * attributes on node1. Node2, node3 thinks writes failed on node1 so
+     * they mark pending changelog for node1. When the network is stable
+     * again the file already is in split-brain. These checks prevent
+     * marking pending changelog on other subvolumes if the fop doesn't
+     * succeed in a way it is still following quorum. So with this fix what
+     * is happening is, node1 will have all pending changelog(FOOL) because
+     * the write succeeded only on node1 but failed on node2, node3 so
+     * instead of marking pending changelogs on node2, node3 it just treats
+     * the fop as failure and goes into DIRTY state. Where as node2, node3
+     * say they are sources and have pending changelog to node1 so there is
+     * no split-brain with the fix. The problem is eliminated completely.
+     */
+
+    if (afr_has_fop_cbk_quorum(frame))
+        return;
+
+    if (afr_need_dirty_marking(frame, this))
+        goto set_response;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i])
+            afr_transaction_fop_failed(frame, frame->this, i);
+    }
+
+set_response:
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    if (local->op_errno == 0)
+        local->op_errno = afr_quorum_errno(priv);
+
+    if (local->fd) {
+        gf_uuid_copy(gfid, local->fd->inode->gfid);
+        file = uuid_utoa(gfid);
+    } else {
+        loc_path(&local->loc, local->loc.name);
+        file = local->loc.path;
+    }
+
+    gf_msg(frame->this->name, GF_LOG_WARNING, local->op_errno,
+           AFR_MSG_QUORUM_FAIL, "%s: Failing %s as quorum is not met", file,
+           gf_fop_list[local->op]);
+
+    switch (local->transaction.type) {
         case AFR_ENTRY_TRANSACTION:
         case AFR_ENTRY_RENAME_TRANSACTION:
-                afr_pick_error_xdata (local, priv, local->parent,
-                                      local->readable, local->parent2,
-                                      local->readable2);
-                break;
+            afr_pick_error_xdata(local, priv, local->parent, local->readable,
+                                 local->parent2, local->readable2);
+            break;
         default:
-                afr_pick_error_xdata (local, priv, local->inode,
-                                      local->readable, NULL, NULL);
-                break;
-        }
+            afr_pick_error_xdata(local, priv, local->inode, local->readable,
+                                 NULL, NULL);
+            break;
+    }
 }
 
 int
-afr_changelog_post_op_now (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t           *priv           = this->private;
-        afr_local_t             *local          = NULL;
-        dict_t                  *xattr          = NULL;
-        afr_fd_ctx_t            *fd_ctx         = NULL;
-        int                     i               = 0;
-        int                     ret             = 0;
-        int                     idx             = 0;
-        int                     nothing_failed  = 1;
-        gf_boolean_t            compounded_unlock = _gf_true;
-        gf_boolean_t            need_undirty    = _gf_false;
-
-        afr_handle_quorum (frame);
-        local = frame->local;
-	idx = afr_index_for_transaction_type (local->transaction.type);
-
-        nothing_failed = afr_txn_nothing_failed (frame, this);
-
-	if (afr_changelog_pre_op_uninherit (frame, this))
-		need_undirty = _gf_false;
-	else
-		need_undirty = _gf_true;
-
-        if (local->op_ret < 0 && !nothing_failed) {
-                afr_changelog_post_op_done (frame, this);
-                goto out;
-        }
+afr_fill_ta_loc(xlator_t *this, loc_t *loc, gf_boolean_t is_gfid_based_fop)
+{
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    loc->parent = inode_ref(priv->root_inode);
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
+    if (is_gfid_based_fop && gf_uuid_is_null(priv->ta_gfid)) {
+        /* Except afr_ta_id_file_check() which is path based, all other gluster
+         * FOPS need gfid.*/
+        return -EINVAL;
+    }
+    gf_uuid_copy(loc->gfid, priv->ta_gfid);
+    loc->inode = inode_new(loc->parent->table);
+    if (!loc->inode) {
+        loc_wipe(loc);
+        return -ENOMEM;
+    }
+    return 0;
+}
 
-	if (nothing_failed && !need_undirty) {
-		afr_changelog_post_op_done (frame, this);
-                goto out;
-	}
+static int
+afr_ta_post_op_done(int ret, call_frame_t *frame, void *opaque)
+{
+    xlator_t *this = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *txn_frame = NULL;
+    afr_ta_fop_state_t fop_state;
 
-        if (local->transaction.in_flight_sb) {
-                local->op_ret = -1;
-                local->op_errno = local->transaction.in_flight_sb_errno;
-                afr_changelog_post_op_done (frame, this);
-                goto out;
-        }
+    local = (afr_local_t *)opaque;
+    fop_state = local->fop_state;
+    txn_frame = local->transaction.frame;
+    this = frame->this;
 
-	xattr = dict_new ();
-	if (!xattr) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->transaction.failed_subvols[i])
-			local->pending[i][idx] = hton32(1);
-	}
-
-	ret = afr_set_pending_dict (priv, xattr, local->pending);
-	if (ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-        if (need_undirty)
-		local->dirty[idx] = hton32(-1);
-	else
-		local->dirty[idx] = hton32(0);
-
-	ret = dict_set_static_bin (xattr, AFR_DIRTY, local->dirty,
-				   sizeof(int) * AFR_NUM_CHANGE_LOGS);
-	if (ret) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-        if (local->compound && local->fd) {
-                LOCK (&local->fd->lock);
-                {
-                        fd_ctx = __afr_fd_ctx_get (local->fd, this);
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (local->transaction.pre_op[i] &&
-                                    local->transaction.eager_lock[i]) {
-                                        if (fd_ctx->lock_piggyback[i])
-                                                compounded_unlock = _gf_false;
-                                        else if (fd_ctx->lock_acquired[i])
-                                                compounded_unlock = _gf_false;
-                                }
-                                if (compounded_unlock == _gf_false)
-                                        break;
-                        }
-                }
-                UNLOCK (&local->fd->lock);
-        }
+    if (ret == 0) {
+        /*Mark pending xattrs on the up data brick.*/
+        afr_post_op_handle_success(txn_frame, this);
+    } else {
+        afr_post_op_handle_failure(txn_frame, this, -ret);
+    }
 
-        /* Do not compound if any brick got piggybacked lock as
-         * unlock should not be done for that. */
-        if (local->compound && compounded_unlock) {
-                afr_post_op_unlock_do (frame, this, xattr,
-                                       afr_changelog_post_op_done,
-                                       AFR_TRANSACTION_POST_OP);
-        } else {
-                afr_changelog_do (frame, this, xattr,
-                                  afr_changelog_post_op_done,
-                                  AFR_TRANSACTION_POST_OP);
-        }
-out:
-	if (xattr)
-                dict_unref (xattr);
+    STACK_DESTROY(frame->root);
+    afr_ta_process_onwireq(fop_state, this);
 
-        return 0;
+    return 0;
 }
 
+int **
+afr_set_changelog_xattr(afr_private_t *priv, unsigned char *pending,
+                        dict_t *xattr, afr_local_t *local)
+{
+    int **changelog = NULL;
+    int idx = 0;
+    int ret = 0;
+    int i;
 
-gf_boolean_t
-afr_changelog_pre_op_uninherit (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	fd_t *fd = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	afr_fd_ctx_t *fd_ctx = NULL;
-	int type = 0;
-
-	local = frame->local;
-	priv = this->private;
-	fd = local->fd;
-
-	type = afr_index_for_transaction_type (local->transaction.type);
-	if (type != AFR_DATA_TRANSACTION)
-		return !local->transaction.dirtied;
-
-	if (!fd)
-		return !local->transaction.dirtied;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		return _gf_false;
-
-	if (local->transaction.no_uninherit)
-		return _gf_false;
-
-	/* This function must be idempotent. So check if we
-	   were called before and return the same answer again.
-
-	   It is important to keep this function idempotent for
-	   the call in afr_changelog_post_op_safe() to not have
-	   side effects on the call from afr_changelog_post_op_now()
-	*/
-	if (local->transaction.uninherit_done)
-		return local->transaction.uninherit_value;
-
-	LOCK(&fd->lock);
-	{
-		for (i = 0; i < priv->child_count; i++) {
-			if (local->transaction.pre_op[i] !=
-			    fd_ctx->pre_op_done[type][i]) {
-				ret = !local->transaction.dirtied;
-				goto unlock;
-			}
-		}
-
-		if (fd_ctx->inherited[type]) {
-			ret = _gf_true;
-			fd_ctx->inherited[type]--;
-		} else if (fd_ctx->on_disk[type]) {
-			ret = _gf_false;
-			fd_ctx->on_disk[type]--;
-		} else {
-			/* ASSERT */
-			ret = _gf_false;
-		}
-
-		if (!fd_ctx->inherited[type] && !fd_ctx->on_disk[type]) {
-			for (i = 0; i < priv->child_count; i++)
-				fd_ctx->pre_op_done[type][i] = 0;
-		}
-	}
-unlock:
-	UNLOCK(&fd->lock);
-
-	local->transaction.uninherit_done = _gf_true;
-	local->transaction.uninherit_value = ret;
+    if (local->is_new_entry == _gf_true) {
+        changelog = afr_mark_pending_changelog(priv, pending, xattr,
+                                               local->cont.dir_fop.buf.ia_type);
+    } else {
+        idx = afr_index_for_transaction_type(local->transaction.type);
+        changelog = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+        if (!changelog) {
+            goto out;
+        }
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->transaction.failed_subvols[i])
+                changelog[i][idx] = hton32(1);
+        }
+        ret = afr_set_pending_dict(priv, xattr, changelog);
+        if (ret < 0) {
+            afr_matrix_cleanup(changelog, priv->child_count);
+            return NULL;
+        }
+    }
 
-	return ret;
+out:
+    return changelog;
 }
 
+static void
+afr_ta_locked_xattrop_validate(afr_private_t *priv, afr_local_t *local,
+                               gf_boolean_t *valid)
+{
+    if (priv->ta_event_gen > local->ta_event_gen) {
+        /* We can't trust the ta's response anymore.*/
+        afr_ta_locked_priv_invalidate(priv);
+        *valid = _gf_false;
+        return;
+    }
+    return;
+}
 
-gf_boolean_t
-afr_changelog_pre_op_inherit (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	fd_t *fd = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	afr_fd_ctx_t *fd_ctx = NULL;
-	int type = 0;
-
-	local = frame->local;
-	priv = this->private;
-	fd = local->fd;
-
-	if (local->transaction.type != AFR_DATA_TRANSACTION)
-		return _gf_false;
-
-	type = afr_index_for_transaction_type (local->transaction.type);
-
-	if (!fd)
-		return _gf_false;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		return _gf_false;
-
-	LOCK(&fd->lock);
-	{
-		if (!fd_ctx->on_disk[type]) {
-			/* nothing to inherit yet */
-			ret = _gf_false;
-			goto unlock;
-		}
-
-		for (i = 0; i < priv->child_count; i++) {
-			if (local->transaction.pre_op[i] !=
-			    fd_ctx->pre_op_done[type][i]) {
-				/* either inherit exactly, or don't */
-				ret = _gf_false;
-				goto unlock;
-			}
-		}
-
-		fd_ctx->inherited[type]++;
-
-		ret = _gf_true;
-
-		local->transaction.inherited = _gf_true;
-	}
-unlock:
-	UNLOCK(&fd->lock);
+static int
+afr_ta_post_op_do(void *opaque)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t *this = NULL;
+    dict_t *xattr = NULL;
+    unsigned char *pending = NULL;
+    int **changelog = NULL;
+    int failed_subvol = -1;
+    int success_subvol = -1;
+    loc_t loc = {
+        0,
+    };
+    int i = 0;
+    int ret = 0;
+    gf_boolean_t valid = _gf_true;
+
+    local = (afr_local_t *)opaque;
+    this = local->transaction.frame->this;
+    priv = this->private;
+
+    ret = afr_fill_ta_loc(this, &loc, _gf_true);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate loc for thin-arbiter.");
+        goto out;
+    }
+
+    xattr = dict_new();
+    if (!xattr) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    pending = alloca0(priv->child_count);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i]) {
+            pending[i] = 1;
+            failed_subvol = i;
+        } else {
+            success_subvol = i;
+        }
+    }
+
+    changelog = afr_set_changelog_xattr(priv, pending, xattr, local);
+
+    if (!changelog) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = afr_ta_post_op_lock(this, &loc);
+    if (ret)
+        goto out;
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Post-op on thin-arbiter id file %s failed for gfid %s.",
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX],
+               uuid_utoa(local->inode->gfid));
+    }
+    LOCK(&priv->lock);
+    {
+        if (ret == 0) {
+            priv->ta_bad_child_index = failed_subvol;
+        } else if (ret == -EINVAL) {
+            priv->ta_bad_child_index = success_subvol;
+            ret = -EIO; /* TA failed the fop. Return EIO to application. */
+        }
+
+        afr_ta_locked_xattrop_validate(priv, local, &valid);
+    }
+    UNLOCK(&priv->lock);
+    if (valid == _gf_false) {
+        gf_msg(this->name, GF_LOG_ERROR, EIO, AFR_MSG_THIN_ARB,
+               "Post-op on thin-arbiter id file %s for gfid %s invalidated due "
+               "to event-gen mismatch.",
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX],
+               uuid_utoa(local->inode->gfid));
+        ret = -EIO;
+    }
+
+    afr_ta_post_op_unlock(this, &loc);
+out:
+    if (xattr)
+        dict_unref(xattr);
 
-	return ret;
-}
+    if (changelog)
+        afr_matrix_cleanup(changelog, priv->child_count);
 
+    loc_wipe(&loc);
 
-gf_boolean_t
-afr_changelog_pre_op_update (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	fd_t *fd = NULL;
-	afr_fd_ctx_t *fd_ctx = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	int type = 0;
-
-	local = frame->local;
-	priv = this->private;
-	fd = local->fd;
-
-	if (!fd)
-		return _gf_false;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		return _gf_false;
-
-	if (local->transaction.inherited)
-		/* was already inherited in afr_changelog_pre_op */
-		return _gf_false;
-
-	if (!local->transaction.dirtied)
-		return _gf_false;
-
-        if (!afr_txn_nothing_failed (frame, this))
-		return _gf_false;
-
-	type = afr_index_for_transaction_type (local->transaction.type);
-
-	ret = _gf_false;
-
-	LOCK(&fd->lock);
-	{
-		if (!fd_ctx->on_disk[type]) {
-			for (i = 0; i < priv->child_count; i++)
-				fd_ctx->pre_op_done[type][i] =
-                                        (!local->transaction.failed_subvols[i]);
-		} else {
-			for (i = 0; i < priv->child_count; i++)
-				if (fd_ctx->pre_op_done[type][i] !=
-				    (!local->transaction.failed_subvols[i])) {
-					local->transaction.no_uninherit = 1;
-					goto unlock;
-				}
-		}
-		fd_ctx->on_disk[type]++;
-
-		ret = _gf_true;
-	}
-unlock:
-	UNLOCK(&fd->lock);
+    return ret;
+}
 
-	return ret;
+static int
+afr_ta_post_op_synctask(xlator_t *this, afr_local_t *local)
+{
+    call_frame_t *ta_frame = NULL;
+    int ret = 0;
+
+    ta_frame = afr_ta_frame_create(this);
+    if (!ta_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to create ta_frame");
+        goto err;
+    }
+    ret = synctask_new(this->ctx->env, afr_ta_post_op_do, afr_ta_post_op_done,
+                       ta_frame, local);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to launch post-op on thin arbiter for gfid %s",
+               uuid_utoa(local->inode->gfid));
+        STACK_DESTROY(ta_frame->root);
+        goto err;
+    }
+
+    return ret;
+err:
+    afr_changelog_post_op_fail(local->transaction.frame, this, ENOMEM);
+    return ret;
 }
 
+static void
+afr_ta_set_fop_state(afr_private_t *priv, afr_local_t *local,
+                     int *on_wire_count)
+{
+    LOCK(&priv->lock);
+    {
+        if (priv->release_ta_notify_dom_lock == _gf_true) {
+            /* Put the fop in waitq until notify dom lock is released.*/
+            local->fop_state = TA_WAIT_FOR_NOTIFY_LOCK_REL;
+            list_add_tail(&local->ta_waitq, &priv->ta_waitq);
+        } else if (priv->ta_bad_child_index == AFR_CHILD_UNKNOWN) {
+            /* Post-op on thin-arbiter to decide success/failure. */
+            local->fop_state = TA_GET_INFO_FROM_TA_FILE;
+            *on_wire_count = ++priv->ta_on_wire_txn_count;
+            if (*on_wire_count > 1) {
+                /*Avoid sending multiple on-wire post-ops on TA*/
+                list_add_tail(&local->ta_onwireq, &priv->ta_onwireq);
+            }
+        } else if (local->ta_failed_subvol == priv->ta_bad_child_index) {
+            /* Post-op on TA not needed as the fop failed on the in-memory bad
+             * brick. Just mark pending xattrs on the good data brick.*/
+            local->fop_state = TA_INFO_IN_MEMORY_SUCCESS;
+            priv->ta_in_mem_txn_count++;
+        } else {
+            /* Post-op on TA not needed as the fop succeeded only on the
+             * in-memory bad data brick and not the good one. Fail the fop.*/
+            local->fop_state = TA_INFO_IN_MEMORY_FAILED;
+            priv->ta_in_mem_txn_count++;
+        }
+    }
+    UNLOCK(&priv->lock);
+}
 
-int
-afr_changelog_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		   int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+static void
+afr_ta_fill_failed_subvol(afr_private_t *priv, afr_local_t *local)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int call_count = -1;
-        int child_index = -1;
-
-        local = frame->local;
-        priv = this->private;
-        child_index = (long) cookie;
+    int i = 0;
 
-	if (op_ret == -1) {
-                local->op_errno = op_errno;
-		afr_transaction_fop_failed (frame, this, child_index);
-        }
-
-        if (priv->arbiter_count == 1 && !op_ret) {
-                if (xattr)
-                        local->transaction.pre_op_xdata[child_index] =
-                                                               dict_ref (xattr);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i]) {
+            local->ta_failed_subvol = i;
+            break;
         }
+    }
+}
 
-	call_count = afr_frame_return (frame);
+static void
+afr_post_op_handle_success(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
 
-        if (call_count == 0)
-		local->transaction.changelog_resume (frame, this);
+    local = frame->local;
+    if (local->is_new_entry == _gf_true) {
+        afr_mark_new_entry_changelog(frame, this);
+    }
+    afr_changelog_post_op_do(frame, this);
 
-        return 0;
+    return;
 }
 
-void
-afr_changelog_populate_xdata (call_frame_t *frame, afr_xattrop_type_t op,
-                              dict_t **xdata, dict_t **newloc_xdata)
-{
-        int              i                    = 0;
-        int              ret                  = 0;
-        char            *key                  = NULL;
-        const char      *name                 = NULL;
-        dict_t          *xdata1               = NULL;
-        dict_t          *xdata2               = NULL;
-        xlator_t        *this                 = NULL;
-        afr_local_t     *local                = NULL;
-        afr_private_t   *priv                 = NULL;
-        gf_boolean_t     need_entry_key_set   = _gf_true;
-
-        local = frame->local;
-        this = THIS;
-        priv = this->private;
-
-        if (local->transaction.type == AFR_DATA_TRANSACTION ||
-            local->transaction.type == AFR_METADATA_TRANSACTION)
-                goto out;
-
-        if (!priv->esh_granular)
-                goto out;
+static void
+afr_post_op_handle_failure(call_frame_t *frame, xlator_t *this, int op_errno)
+{
+    afr_changelog_post_op_fail(frame, this, op_errno);
 
-        xdata1 = dict_new();
-        if (!xdata1)
-                goto out;
+    return;
+}
 
-        name = local->loc.name;
-        if (local->op == GF_FOP_LINK)
-                name = local->newloc.name;
+static void
+afr_ta_decide_post_op_state(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int on_wire_count = 0;
+
+    priv = this->private;
+    local = frame->local;
+
+    afr_ta_set_fop_state(priv, local, &on_wire_count);
+
+    switch (local->fop_state) {
+        case TA_GET_INFO_FROM_TA_FILE:
+            if (on_wire_count == 1)
+                afr_ta_post_op_synctask(this, local);
+            /*else, fop is queued in ta_onwireq.*/
+            break;
+        case TA_WAIT_FOR_NOTIFY_LOCK_REL:
+            /*Post releasing the notify lock, we will act on this queue*/
+            break;
+        case TA_INFO_IN_MEMORY_SUCCESS:
+            afr_post_op_handle_success(frame, this);
+            break;
+        case TA_INFO_IN_MEMORY_FAILED:
+            afr_post_op_handle_failure(frame, this, EIO);
+            break;
+        default:
+            break;
+    }
+    return;
+}
 
-        switch (op) {
-        case AFR_TRANSACTION_PRE_OP:
-                key = GF_XATTROP_ENTRY_IN_KEY;
-                break;
-        case AFR_TRANSACTION_POST_OP:
-                if (afr_txn_nothing_failed (frame, this)) {
-                        key = GF_XATTROP_ENTRY_OUT_KEY;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (!local->transaction.failed_subvols[i])
-                                        continue;
-                                need_entry_key_set = _gf_false;
-                                break;
-                        }
-                        /* If the transaction itself did not fail and there
-                         * are no failed subvolumes, check whether the fop
-                         * failed due to a symmetric error. If it did, do
-                         * not set the ENTRY_OUT xattr which would end up
-                         * deleting a name index which was created possibly by
-                         * an earlier entry txn that may have failed on some
-                         * of the sub-volumes.
-                         */
-                        if (local->op_ret)
-                                need_entry_key_set = _gf_false;
-                } else {
-                        key = GF_XATTROP_ENTRY_IN_KEY;
-                }
-                break;
-        }
+static void
+afr_handle_failure_using_thin_arbiter(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
 
-        if (need_entry_key_set) {
-                ret = dict_set_str (xdata1, key, (char *)name);
-                if (ret)
-                        gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_DICT_SET_FAILED,
-                                "%s/%s: Could not set %s key during xattrop",
-                                uuid_utoa (local->loc.pargfid), local->loc.name,
-                                key);
-                if (local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                        xdata2 = dict_new ();
-                        if (!xdata2)
-                                goto out;
-
-                        ret = dict_set_str (xdata2, key,
-                                            (char *)local->newloc.name);
-                        if (ret)
-                                gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_DICT_SET_FAILED,
-                                        "%s/%s: Could not set %s key during "
-                                        "xattrop",
-                                        uuid_utoa (local->newloc.pargfid),
-                                        local->newloc.name, key);
-                }
-        }
+    afr_ta_fill_failed_subvol(priv, local);
+    gf_msg_debug(this->name, 0,
+                 "Fop failed on data brick (%s) for gfid=%s. "
+                 "ta info needed to decide fop result.",
+                 priv->children[local->ta_failed_subvol]->name,
+                 uuid_utoa(local->inode->gfid));
+    afr_ta_decide_post_op_state(frame, this);
+}
 
-        *xdata = xdata1;
-        *newloc_xdata = xdata2;
-        xdata1 = xdata2 = NULL;
+void
+afr_changelog_post_op_do(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    dict_t *xattr = NULL;
+    int i = 0;
+    int ret = 0;
+    int idx = 0;
+    int nothing_failed = 1;
+    gf_boolean_t need_undirty = _gf_false;
+
+    afr_handle_quorum(frame, this);
+    local = frame->local;
+    idx = afr_index_for_transaction_type(local->transaction.type);
+
+    xattr = dict_new();
+    if (!xattr) {
+        afr_changelog_post_op_fail(frame, this, ENOMEM);
+        goto out;
+    }
+
+    nothing_failed = afr_txn_nothing_failed(frame, this);
+
+    if (afr_changelog_pre_op_uninherit(frame, this))
+        need_undirty = _gf_false;
+    else
+        need_undirty = _gf_true;
+
+    if (local->op_ret < 0 && !nothing_failed) {
+        if (afr_need_dirty_marking(frame, this)) {
+            local->dirty[idx] = hton32(1);
+            goto set_dirty;
+        }
+
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
+
+    if (nothing_failed && !need_undirty) {
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
+
+    if (local->transaction.in_flight_sb) {
+        afr_changelog_post_op_fail(frame, this,
+                                   local->transaction.in_flight_sb_errno);
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i])
+            local->pending[i][idx] = hton32(1);
+    }
+
+    ret = afr_set_pending_dict(priv, xattr, local->pending);
+    if (ret < 0) {
+        afr_changelog_post_op_fail(frame, this, ENOMEM);
+        goto out;
+    }
+
+    if (need_undirty)
+        local->dirty[idx] = hton32(-1);
+    else
+        local->dirty[idx] = hton32(0);
+
+set_dirty:
+    ret = dict_set_static_bin(xattr, AFR_DIRTY, local->dirty,
+                              sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret) {
+        afr_changelog_post_op_fail(frame, this, ENOMEM);
+        goto out;
+    }
+
+    afr_changelog_do(frame, this, xattr, afr_changelog_post_op_done,
+                     AFR_TRANSACTION_POST_OP);
 out:
-        if (xdata1)
-                dict_unref (xdata1);
-        if (xdata2)
-                dict_unref (xdata2);
-        return;
+    if (xattr)
+        dict_unref(xattr);
+
+    return;
 }
 
-int
-afr_pre_op_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       void *data, dict_t *xdata)
-{
-        afr_local_t *local = NULL;
-        call_frame_t    *fop_frame = NULL;
-        default_args_cbk_t *write_args_cbk = NULL;
-        compound_args_cbk_t *args_cbk = data;
-        int call_count = -1;
-        int child_index = -1;
-
-        local = frame->local;
-        child_index = (long) cookie;
-
-	if (local->pre_op_compat)
-		afr_changelog_pre_op_update (frame, this);
-
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-		afr_transaction_fop_failed (frame, this, child_index);
-        }
+static int
+afr_changelog_post_op_now(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int failed_count = 0;
 
-        /* If the compound fop failed due to saved_frame_unwind(), then
-         * protocol/client fails it even before args_cbk is allocated.
-         * Handle that case by passing the op_ret, op_errno values explicitly.
-         */
-        if ((op_ret == -1) && (args_cbk == NULL)) {
-                afr_inode_write_fill  (frame, this, child_index, op_ret,
-                                       op_errno, NULL, NULL, NULL);
+    priv = this->private;
+    local = frame->local;
+
+    if (priv->thin_arbiter_count) {
+        failed_count = AFR_COUNT(local->transaction.failed_subvols,
+                                 priv->child_count);
+        if (failed_count == 1) {
+            afr_handle_failure_using_thin_arbiter(frame, this);
+            return 0;
         } else {
-                write_args_cbk = &args_cbk->rsp_list[1];
-                afr_inode_write_fill  (frame, this, child_index,
-                                       write_args_cbk->op_ret,
-                                       write_args_cbk->op_errno,
-                                       &write_args_cbk->prestat,
-                                       &write_args_cbk->poststat,
-                                       write_args_cbk->xdata);
+            /* Txn either succeeded or failed on both data bricks. Let
+             * post_op_do handle it as the case might be. */
         }
+    }
 
-	call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                compound_args_cleanup (local->c_args);
-                local->c_args = NULL;
-                afr_process_post_writev (frame, this);
-                if (!afr_txn_nothing_failed (frame, this)) {
-                        /* Don't unwind until post-op is complete */
-                        local->transaction.resume (frame, this);
-                } else {
-                /* frame change, place frame in post-op delay and unwind */
-                        fop_frame = afr_transaction_detach_fop_frame (frame);
-                        afr_writev_copy_outvars (frame, fop_frame);
-                        local->transaction.resume (frame, this);
-                        afr_writev_unwind (fop_frame, this);
-                }
-        }
-        return 0;
+    afr_changelog_post_op_do(frame, this);
+    return 0;
 }
 
-int
-afr_changelog_prepare (xlator_t *this, call_frame_t *frame, int *call_count,
-                       afr_changelog_resume_t changelog_resume,
-                       afr_xattrop_type_t op, dict_t **xdata,
-                       dict_t **newloc_xdata)
+gf_boolean_t
+afr_changelog_pre_op_uninherit(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv  = NULL;
-        afr_local_t   *local = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_inode_ctx_t *ctx = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
+    ctx = local->inode_ctx;
 
-        *call_count = afr_changelog_call_count (local->transaction.type,
-                                               local->transaction.pre_op,
-                                              local->transaction.failed_subvols,
-                                               priv->child_count);
+    type = afr_index_for_transaction_type(local->transaction.type);
+    if (type != AFR_DATA_TRANSACTION)
+        return !local->transaction.dirtied;
 
-        if (*call_count == 0) {
-                changelog_resume (frame, this);
-                return -1;
-        }
+    if (local->transaction.no_uninherit)
+        return _gf_false;
 
-        afr_changelog_populate_xdata (frame, op, xdata, newloc_xdata);
-        local->call_count = *call_count;
+    /* This function must be idempotent. So check if we
+       were called before and return the same answer again.
 
-        local->transaction.changelog_resume = changelog_resume;
-        return 0;
-}
+       It is important to keep this function idempotent for
+       the call in afr_changelog_post_op_safe() to not have
+       side effects on the call from afr_changelog_post_op_now()
+    */
+    if (local->transaction.uninherit_done)
+        return local->transaction.uninherit_value;
 
-int
-afr_pre_op_fop_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-                   afr_changelog_resume_t changelog_resume,
-                   afr_xattrop_type_t op)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        dict_t *newloc_xdata = NULL;
-        compound_args_t *args = NULL;
-        int i = 0, call_count = 0;
-        afr_compound_cbk_t compound_cbk;
-        int ret = 0;
-        int op_errno = ENOMEM;
-
-        local = frame->local;
-        priv = this->private;
-
-        /* If lock failed on all, just unlock and unwind */
-        ret = afr_changelog_prepare (this, frame, &call_count, changelog_resume,
-                                     op, &xdata, &newloc_xdata);
+    LOCK(&local->inode->lock);
+    {
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->transaction.pre_op[i] != ctx->pre_op_done[type][i]) {
+                ret = !local->transaction.dirtied;
+                goto unlock;
+            }
+        }
+
+        if (ctx->inherited[type]) {
+            ret = _gf_true;
+            ctx->inherited[type]--;
+        } else if (ctx->on_disk[type]) {
+            ret = _gf_false;
+            ctx->on_disk[type]--;
+        } else {
+            /* ASSERT */
+            ret = _gf_false;
+        }
 
-        if (ret)
-                return 0;
+        if (!ctx->inherited[type] && !ctx->on_disk[type]) {
+            for (i = 0; i < priv->child_count; i++)
+                ctx->pre_op_done[type][i] = 0;
+        }
+    }
+unlock:
+    UNLOCK(&local->inode->lock);
+
+    local->transaction.uninherit_done = _gf_true;
+    local->transaction.uninherit_value = ret;
 
-        local->call_count = call_count;
+    return ret;
+}
 
-        afr_save_lk_owner (frame);
-        frame->root->lk_owner =
-                local->transaction.main_frame->root->lk_owner;
+gf_boolean_t
+afr_changelog_pre_op_inherit(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-        args = compound_fop_alloc (2, GF_CFOP_XATTROP_WRITEV, NULL);
+    local = frame->local;
+    priv = this->private;
 
-        if (!args)
-                goto err;
+    if (local->transaction.type != AFR_DATA_TRANSACTION)
+        return _gf_false;
 
-        /* pack pre-op part */
-        i = 0;
-        COMPOUND_PACK_ARGS (fxattrop, GF_FOP_FXATTROP,
-                            args, i,
-                            local->fd, GF_XATTROP_ADD_ARRAY,
-                            xattr, xdata);
-        i++;
-        /* pack whatever fop needs to be packed
-         * @compound_cbk holds the cbk that would need to be called
-         */
-        compound_cbk = afr_pack_fop_args (frame, args, local->op, i);
+    type = afr_index_for_transaction_type(local->transaction.type);
 
-        local->c_args = args;
+    LOCK(&local->inode->lock);
+    {
+        if (!local->inode_ctx->on_disk[type]) {
+            /* nothing to inherit yet */
+            ret = _gf_false;
+            goto unlock;
+        }
 
         for (i = 0; i < priv->child_count; i++) {
-                /* Means lock did not succeed on this brick */
-                if (!local->transaction.pre_op[i] ||
-                    local->transaction.failed_subvols[i])
-                        continue;
-
-                STACK_WIND_COOKIE (frame, compound_cbk,
-                                   (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->compound,
-                                   args,
-                                   NULL);
-                if (!--call_count)
-                        break;
+            if (local->transaction.pre_op[i] !=
+                local->inode_ctx->pre_op_done[type][i]) {
+                /* either inherit exactly, or don't */
+                ret = _gf_false;
+                goto unlock;
+            }
         }
 
-        if (xdata)
-                dict_unref (xdata);
-        if (newloc_xdata)
-                dict_unref (newloc_xdata);
-        return 0;
-err:
-	local->internal_lock.lock_cbk = local->transaction.done;
-	local->op_ret = -1;
-	local->op_errno = op_errno;
+        local->inode_ctx->inherited[type]++;
 
-        afr_restore_lk_owner (frame);
-	afr_unlock (frame, this);
+        ret = _gf_true;
 
-        if (xdata)
-                dict_unref (xdata);
-        if (newloc_xdata)
-                dict_unref (newloc_xdata);
-	return 0;
+        local->transaction.inherited = _gf_true;
+    }
+unlock:
+    UNLOCK(&local->inode->lock);
+
+    return ret;
 }
 
-int
-afr_post_op_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       void *data, dict_t *xdata)
+gf_boolean_t
+afr_changelog_pre_op_update(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        int call_count = -1;
-        afr_internal_lock_t *int_lock = NULL;
-        int32_t             child_index = (long)cookie;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-        local = frame->local;
-        child_index = (long) cookie;
+    local = frame->local;
+    priv = this->private;
 
-        local = frame->local;
-        int_lock = &local->internal_lock;
+    if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
+        local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION)
+        return _gf_false;
 
-        afr_update_uninodelk (local, int_lock, child_index);
+    if (local->transaction.inherited)
+        /* was already inherited in afr_changelog_pre_op */
+        return _gf_false;
 
-        LOCK (&frame->lock);
-        {
-                call_count = --int_lock->lk_call_count;
-        }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                compound_args_cleanup (local->c_args);
-                local->c_args = NULL;
-                if (local->transaction.resume_stub) {
-                        call_resume (local->transaction.resume_stub);
-                        local->transaction.resume_stub = NULL;
-                }
-                gf_msg_trace (this->name, 0,
-                              "All internal locks unlocked");
-                int_lock->lock_cbk (frame, this);
-        }
+    if (!local->transaction.dirtied)
+        return _gf_false;
 
-        return 0;
-}
+    if (!afr_txn_nothing_failed(frame, this))
+        return _gf_false;
 
-int
-afr_post_op_unlock_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-		       afr_changelog_resume_t changelog_resume,
-                       afr_xattrop_type_t op)
-{
-	afr_local_t             *local          = NULL;
-	afr_private_t           *priv           = NULL;
-        dict_t                  *xdata          = NULL;
-        dict_t                  *newloc_xdata   = NULL;
-        compound_args_t         *args           = NULL;
-        afr_internal_lock_t     *int_lock       = NULL;
-        afr_inodelk_t           *inodelk        = NULL;
-	int                     i               = 0;
-	int                     call_count      = 0;
-        struct gf_flock         flock           = {0,};
-        int                     ret             = 0;
-
-	local = frame->local;
-	priv = this->private;
-        int_lock = &local->internal_lock;
-
-        if (afr_is_inodelk_transaction(local)) {
-                inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-
-                flock.l_start = inodelk->flock.l_start;
-                flock.l_len   = inodelk->flock.l_len;
-                flock.l_type  = F_UNLCK;
-        }
+    type = afr_index_for_transaction_type(local->transaction.type);
 
-        ret = afr_changelog_prepare (this, frame, &call_count, changelog_resume,
-                                     op, &xdata, &newloc_xdata);
+    ret = _gf_false;
 
-        if (ret)
-                return 0;
-
-        int_lock->lk_call_count = call_count;
-
-        int_lock->lock_cbk = local->transaction.done;
-
-        args = compound_fop_alloc (2, GF_CFOP_XATTROP_UNLOCK, NULL);
-
-        if (!args) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-        i = 0;
-        COMPOUND_PACK_ARGS (fxattrop, GF_FOP_FXATTROP,
-                            args, i,
-                            local->fd, GF_XATTROP_ADD_ARRAY,
-                            xattr, xdata);
-        i++;
-
-        if (afr_is_inodelk_transaction(local)) {
-                if (local->fd) {
-                        COMPOUND_PACK_ARGS (finodelk, GF_FOP_FINODELK,
-                                            args, i,
-                                            int_lock->domain, local->fd,
-                                            F_SETLK, &flock, NULL);
-                } else {
-                        COMPOUND_PACK_ARGS (inodelk, GF_FOP_INODELK,
-                                            args, i,
-                                            int_lock->domain, &local->loc,
-                                            F_SETLK, &flock, NULL);
+    LOCK(&local->inode->lock);
+    {
+        if (!local->inode_ctx->on_disk[type]) {
+            for (i = 0; i < priv->child_count; i++)
+                local->inode_ctx->pre_op_done[type][i] =
+                    (!local->transaction.failed_subvols[i]);
+        } else {
+            for (i = 0; i < priv->child_count; i++)
+                if (local->inode_ctx->pre_op_done[type][i] !=
+                    (!local->transaction.failed_subvols[i])) {
+                    local->transaction.no_uninherit = 1;
+                    goto unlock;
                 }
         }
+        local->inode_ctx->on_disk[type]++;
 
-        local->c_args = args;
+        ret = _gf_true;
+    }
+unlock:
+    UNLOCK(&local->inode->lock);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op[i] ||
-                    local->transaction.failed_subvols[i])
-                        continue;
-                STACK_WIND_COOKIE (frame, afr_post_op_unlock_cbk,
-                                   (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->compound,
-                                   args,
-                                   NULL);
-                if (!--call_count)
-                        break;
-        }
-out:
-        if (xdata)
-                dict_unref (xdata);
-        if (newloc_xdata)
-                dict_unref (newloc_xdata);
-        return 0;
+    return ret;
 }
 
 int
-afr_changelog_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-		  afr_changelog_resume_t changelog_resume,
-                  afr_xattrop_type_t op)
+afr_changelog_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, dict_t *xattr, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        dict_t *newloc_xdata = NULL;
-	int i = 0;
-	int call_count = 0;
-        int ret = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-        ret = afr_changelog_prepare (this, frame, &call_count, changelog_resume,
-                                     op, &xdata, &newloc_xdata);
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
 
-        if (ret)
-                return 0;
+    local = frame->local;
+    child_index = (long)cookie;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op[i] ||
-                    local->transaction.failed_subvols[i])
-                        continue;
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
 
-                switch (local->transaction.type) {
-                case AFR_DATA_TRANSACTION:
-                case AFR_METADATA_TRANSACTION:
-                        if (!local->fd) {
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->xattrop,
-						   &local->loc,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        } else {
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->fxattrop,
-						   local->fd,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        }
-			break;
-                case AFR_ENTRY_RENAME_TRANSACTION:
-
-			STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-					   (void *) (long) i,
-					   priv->children[i],
-					   priv->children[i]->fops->xattrop,
-					   &local->transaction.new_parent_loc,
-					   GF_XATTROP_ADD_ARRAY, xattr,
-					   newloc_xdata);
-                        call_count--;
+    if (xattr)
+        local->transaction.changelog_xdata[child_index] = dict_ref(xattr);
 
-                /* fall through */
+    call_count = afr_frame_return(frame);
 
-                case AFR_ENTRY_TRANSACTION:
-                        if (local->fd)
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->fxattrop,
-						   local->fd,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        else
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->xattrop,
-						   &local->transaction.parent_loc,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-			break;
-		}
-
-                if (!--call_count)
-                        break;
-        }
+    if (call_count == 0) {
+        local->transaction.changelog_resume(frame, this);
+    }
 
-        if (xdata)
-                dict_unref (xdata);
-        if (newloc_xdata)
-                dict_unref (newloc_xdata);
-	return 0;
+    return 0;
 }
 
-static void
-afr_init_optimistic_changelog_for_txn (xlator_t *this, afr_local_t *local)
-{
-        int                locked_count   = 0;
-        afr_private_t     *priv           = NULL;
+void
+afr_changelog_populate_xdata(call_frame_t *frame, afr_xattrop_type_t op,
+                             dict_t **xdata, dict_t **newloc_xdata)
+{
+    int i = 0;
+    int ret = 0;
+    char *key = NULL;
+    int keylen = 0;
+    const char *name = NULL;
+    dict_t *xdata1 = NULL;
+    dict_t *xdata2 = NULL;
+    xlator_t *this = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t need_entry_key_set = _gf_true;
+
+    local = frame->local;
+    this = THIS;
+    priv = this->private;
+
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION)
+        goto out;
+
+    if (!priv->esh_granular)
+        goto out;
+
+    xdata1 = dict_new();
+    if (!xdata1)
+        goto out;
+
+    name = local->loc.name;
+    if (local->op == GF_FOP_LINK)
+        name = local->newloc.name;
+
+    switch (op) {
+        case AFR_TRANSACTION_PRE_OP:
+            key = GF_XATTROP_ENTRY_IN_KEY;
+            break;
+        case AFR_TRANSACTION_POST_OP:
+            if (afr_txn_nothing_failed(frame, this)) {
+                key = GF_XATTROP_ENTRY_OUT_KEY;
+                for (i = 0; i < priv->child_count; i++) {
+                    if (!local->transaction.failed_subvols[i])
+                        continue;
+                    need_entry_key_set = _gf_false;
+                    break;
+                }
+                /* If the transaction itself did not fail and there
+                 * are no failed subvolumes, check whether the fop
+                 * failed due to a symmetric error. If it did, do
+                 * not set the ENTRY_OUT xattr which would end up
+                 * deleting a name index which was created possibly by
+                 * an earlier entry txn that may have failed on some
+                 * of the sub-volumes.
+                 */
+                if (local->op_ret)
+                    need_entry_key_set = _gf_false;
+            } else {
+                key = GF_XATTROP_ENTRY_IN_KEY;
+            }
+            break;
+    }
 
-        priv = this->private;
+    if (need_entry_key_set) {
+        keylen = strlen(key);
+        ret = dict_set_strn(xdata1, key, keylen, (char *)name);
+        if (ret)
+            gf_msg(THIS->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                   "%s/%s: Could not set %s key during xattrop",
+                   uuid_utoa(local->loc.pargfid), local->loc.name, key);
+        if (local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
+            xdata2 = dict_new();
+            if (!xdata2)
+                goto out;
 
-        locked_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
-        if (priv->optimistic_change_log && locked_count == priv->child_count)
-                local->optimistic_change_log = 1;
+            ret = dict_set_strn(xdata2, key, keylen,
+                                (char *)local->newloc.name);
+            if (ret)
+                gf_msg(THIS->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                       "%s/%s: Could not set %s key during "
+                       "xattrop",
+                       uuid_utoa(local->newloc.pargfid), local->newloc.name,
+                       key);
+        }
+    }
 
-        return;
+    *xdata = xdata1;
+    *newloc_xdata = xdata2;
+    xdata1 = xdata2 = NULL;
+out:
+    if (xdata1)
+        dict_unref(xdata1);
+    return;
 }
 
 int
-afr_changelog_pre_op (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t * priv = this->private;
-        int i = 0;
-        int ret = 0;
-        int call_count = 0;
-	int op_errno = 0;
-        afr_local_t *local = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        unsigned char       *locked_nodes = NULL;
-	int idx = -1;
-	gf_boolean_t pre_nop = _gf_true;
-	dict_t *xdata_req = NULL;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
-	idx = afr_index_for_transaction_type (local->transaction.type);
-
-        locked_nodes = afr_locked_nodes_get (local->transaction.type, int_lock);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (locked_nodes[i]) {
-			local->transaction.pre_op[i] = 1;
-			call_count++;
-		} else {
-                        local->transaction.failed_subvols[i] = 1;
-                }
-	}
+afr_changelog_prepare(xlator_t *this, call_frame_t *frame, int *call_count,
+                      afr_changelog_resume_t changelog_resume,
+                      afr_xattrop_type_t op, dict_t **xdata,
+                      dict_t **newloc_xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        afr_init_optimistic_changelog_for_txn (this, local);
+    local = frame->local;
+    priv = this->private;
 
-        /* This condition should not be met with present code, as
-         * transaction.done will be called if locks are not acquired on even a
-         * single node.
-         */
-        if (call_count == 0) {
-		op_errno = ENOTCONN;
-		goto err;
-	}
+    *call_count = afr_changelog_call_count(
+        local->transaction.type, local->transaction.pre_op,
+        local->transaction.failed_subvols, priv->child_count);
 
-        /* Check if the fop can be performed on at least
-         * quorum number of nodes.
-         */
-        if (priv->quorum_count && !afr_has_fop_quorum (frame)) {
-                op_errno = int_lock->lock_op_errno;
-                if (op_errno == 0)
-                        op_errno = afr_quorum_errno (priv);
-                goto err;
-        }
+    if (*call_count == 0) {
+        changelog_resume(frame, this);
+        return -1;
+    }
 
-	xdata_req = dict_new();
-	if (!xdata_req) {
-		op_errno = ENOMEM;
-		goto err;
-	}
+    afr_changelog_populate_xdata(frame, op, xdata, newloc_xdata);
+    local->call_count = *call_count;
 
-	if (afr_changelog_pre_op_inherit (frame, this))
-		goto next;
+    local->transaction.changelog_resume = changelog_resume;
+    return 0;
+}
 
-        if (call_count < priv->child_count)
-                pre_nop = _gf_false;
+int
+afr_changelog_do(call_frame_t *frame, xlator_t *this, dict_t *xattr,
+                 afr_changelog_resume_t changelog_resume, afr_xattrop_type_t op)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    dict_t *newloc_xdata = NULL;
+    int i = 0;
+    int call_count = 0;
+    int ret = 0;
 
-        /* Set an all-zero pending changelog so that in the cbk, we can get the
-         * current on-disk values. In a replica 3 volume with arbiter enabled,
-         * these values are needed to arrive at a go/ no-go of the fop phase to
-         * avoid ending up in split-brain.*/
+    local = frame->local;
+    priv = this->private;
 
-        ret = afr_set_pending_dict (priv, xdata_req, local->pending);
-	if (ret < 0) {
-		op_errno = ENOMEM;
-		goto err;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.changelog_xdata[i]) {
+            dict_unref(local->transaction.changelog_xdata[i]);
+            local->transaction.changelog_xdata[i] = NULL;
+        }
+    }
 
-	if (afr_needs_changelog_update (local)) {
+    ret = afr_changelog_prepare(this, frame, &call_count, changelog_resume, op,
+                                &xdata, &newloc_xdata);
 
-		local->dirty[idx] = hton32(1);
+    if (ret)
+        return 0;
 
-		ret = dict_set_static_bin (xdata_req, AFR_DIRTY, local->dirty,
-					   sizeof(int) * AFR_NUM_CHANGE_LOGS);
-		if (ret) {
-			op_errno = ENOMEM;
-			goto err;
-		}
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.pre_op[i] ||
+            local->transaction.failed_subvols[i])
+            continue;
 
-		pre_nop = _gf_false;
-		local->transaction.dirtied = 1;
-	}
+        switch (local->transaction.type) {
+            case AFR_DATA_TRANSACTION:
+            case AFR_METADATA_TRANSACTION:
+                if (!local->fd) {
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->xattrop,
+                        &local->loc, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                } else {
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->fxattrop,
+                        local->fd, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                }
+                break;
+            case AFR_ENTRY_RENAME_TRANSACTION:
 
-	if (pre_nop)
-		goto next;
+                STACK_WIND_COOKIE(frame, afr_changelog_cbk, (void *)(long)i,
+                                  priv->children[i],
+                                  priv->children[i]->fops->xattrop,
+                                  &local->transaction.new_parent_loc,
+                                  GF_XATTROP_ADD_ARRAY, xattr, newloc_xdata);
+                call_count--;
 
-	if (!local->pre_op_compat) {
-		dict_copy (xdata_req, local->xdata_req);
-		goto next;
-	}
+                /* fall through */
 
-	/* Till here we have already decided if pre-op needs to be done,
-         * based on various criteria. The only thing that needs to be checked
-         * now on is whether compound-fops is enabled or not.
-         * If it is, then perform pre-op and fop together for writev op.
-         */
-        if (afr_can_compound_pre_op_and_op (priv, local->op)) {
-                local->compound = _gf_true;
-                afr_pre_op_fop_do (frame, this, xdata_req,
-                                   afr_transaction_perform_fop,
-                                   AFR_TRANSACTION_PRE_OP);
-        } else {
-                afr_changelog_do (frame, this, xdata_req,
-                                  afr_transaction_perform_fop,
-                                  AFR_TRANSACTION_PRE_OP);
+            case AFR_ENTRY_TRANSACTION:
+                if (local->fd)
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->fxattrop,
+                        local->fd, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                else
+                    STACK_WIND_COOKIE(frame, afr_changelog_cbk, (void *)(long)i,
+                                      priv->children[i],
+                                      priv->children[i]->fops->xattrop,
+                                      &local->transaction.parent_loc,
+                                      GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                break;
         }
 
-	if (xdata_req)
-		dict_unref (xdata_req);
-
-	return 0;
-next:
-	afr_transaction_perform_fop (frame, this);
-
-	if (xdata_req)
-		dict_unref (xdata_req);
-
-        return 0;
-err:
-	local->internal_lock.lock_cbk = local->transaction.done;
-	local->op_ret = -1;
-	local->op_errno = op_errno;
-
-	afr_unlock (frame, this);
+        if (!--call_count)
+            break;
+    }
 
-	if (xdata_req)
-		dict_unref (xdata_req);
-
-	return 0;
+    if (xdata)
+        dict_unref(xdata);
+    if (newloc_xdata)
+        dict_unref(newloc_xdata);
+    return 0;
 }
 
-
-int
-afr_post_blocking_inodelk_cbk (call_frame_t *frame, xlator_t *this)
+static void
+afr_init_optimistic_changelog_for_txn(xlator_t *this, afr_local_t *local)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    int locked_count = 0;
+    afr_private_t *priv = NULL;
 
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO,
-                        0, AFR_MSG_BLOCKING_LKS_FAILED,
-                        "Blocking inodelks failed.");
-                local->transaction.done (frame, this);
-        } else {
+    priv = this->private;
 
-                gf_msg_debug (this->name, 0,
-                              "Blocking inodelks done. Proceeding to FOP");
-                afr_internal_lock_finish (frame, this);
-        }
+    locked_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
+    if (priv->optimistic_change_log && locked_count == priv->child_count)
+        local->optimistic_change_log = 1;
 
-        return 0;
+    return;
 }
 
-
 int
-afr_post_nonblocking_inodelk_cbk (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        /* Initiate blocking locks if non-blocking has failed */
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg_debug (this->name, 0,
-                              "Non blocking inodelks failed. Proceeding to blocking");
-                int_lock->lock_cbk = afr_post_blocking_inodelk_cbk;
-                afr_blocking_lock (frame, this);
+afr_changelog_pre_op(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    int i = 0;
+    int ret = 0;
+    int call_count = 0;
+    int op_errno = 0;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    unsigned char *locked_nodes = NULL;
+    int idx = -1;
+    gf_boolean_t pre_nop = _gf_true;
+    dict_t *xdata_req = NULL;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    idx = afr_index_for_transaction_type(local->transaction.type);
+
+    locked_nodes = afr_locked_nodes_get(local->transaction.type, int_lock);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (locked_nodes[i]) {
+            local->transaction.pre_op[i] = 1;
+            call_count++;
         } else {
+            local->transaction.failed_subvols[i] = 1;
+        }
+    }
+
+    afr_init_optimistic_changelog_for_txn(this, local);
+
+    if (afr_changelog_pre_op_inherit(frame, this))
+        goto next;
+
+    /* This condition should not be met with present code, as
+     * transaction.done will be called if locks are not acquired on even a
+     * single node.
+     */
+    if (call_count == 0) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Check if the fop can be performed on at least
+     * quorum number of nodes.
+     */
+    if (priv->quorum_count && !afr_has_fop_quorum(frame)) {
+        op_errno = int_lock->lock_op_errno;
+        if (op_errno == 0)
+            op_errno = afr_quorum_errno(priv);
+        goto err;
+    }
+
+    xdata_req = dict_new();
+    if (!xdata_req) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (call_count < priv->child_count)
+        pre_nop = _gf_false;
+
+    /* Set an all-zero pending changelog so that in the cbk, we can get the
+     * current on-disk values. In a replica 3 volume with arbiter enabled,
+     * these values are needed to arrive at a go/ no-go of the fop phase to
+     * avoid ending up in split-brain.*/
+
+    ret = afr_set_pending_dict(priv, xdata_req, local->pending);
+    if (ret < 0) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (afr_needs_changelog_update(local)) {
+        local->dirty[idx] = hton32(1);
+
+        ret = dict_set_static_bin(xdata_req, AFR_DIRTY, local->dirty,
+                                  sizeof(int) * AFR_NUM_CHANGE_LOGS);
+        if (ret) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+
+        pre_nop = _gf_false;
+        local->transaction.dirtied = 1;
+    }
+
+    if (pre_nop)
+        goto next;
+
+    if (!local->pre_op_compat) {
+        dict_copy(xdata_req, local->xdata_req);
+        goto next;
+    }
+
+    afr_changelog_do(frame, this, xdata_req, afr_transaction_perform_fop,
+                     AFR_TRANSACTION_PRE_OP);
+
+    if (xdata_req)
+        dict_unref(xdata_req);
+
+    return 0;
+next:
+    afr_transaction_perform_fop(frame, this);
 
-                gf_msg_debug (this->name, 0,
-                              "Non blocking inodelks done. Proceeding to FOP");
-                afr_internal_lock_finish (frame, this);
-        }
-
-        return 0;
-}
-
-
-int
-afr_post_blocking_entrylk_cbk (call_frame_t *frame, xlator_t *this)
-{
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    if (xdata_req)
+        dict_unref(xdata_req);
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    return 0;
+err:
+    local->internal_lock.lock_cbk = afr_transaction_done;
+    local->op_ret = -1;
+    local->op_errno = op_errno;
 
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_BLOCKING_LKS_FAILED,
-                        "Blocking entrylks failed.");
-                local->transaction.done (frame, this);
-        } else {
+    afr_handle_lock_acquire_failure(local);
 
-                gf_msg_debug (this->name, 0,
-                             "Blocking entrylks done. Proceeding to FOP");
-                afr_internal_lock_finish (frame, this);
-        }
+    if (xdata_req)
+        dict_unref(xdata_req);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_post_nonblocking_entrylk_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_nonblocking_lock_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        /* Initiate blocking locks if non-blocking has failed */
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg_debug (this->name, 0,
-                              "Non blocking entrylks failed. Proceeding to blocking");
-                int_lock->lock_cbk = afr_post_blocking_entrylk_cbk;
-                afr_blocking_lock (frame, this);
-        } else {
-
-                gf_msg_debug (this->name, 0,
-                              "Non blocking entrylks done. Proceeding to FOP");
+    /* Initiate blocking locks if non-blocking has failed */
+    if (int_lock->lock_op_ret < 0) {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking locks failed. Proceeding to blocking");
+        int_lock->lock_cbk = afr_internal_lock_finish;
+        afr_blocking_lock(frame, this);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking locks done. Proceeding to FOP");
 
-                afr_internal_lock_finish (frame, this);
-        }
+        afr_internal_lock_finish(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_post_blocking_rename_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_blocking_rename_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_BLOCKING_LKS_FAILED,
-                        "Blocking entrylks failed.");
+    if (int_lock->lock_op_ret < 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_INTERNAL_LKS_FAILED,
+               "Blocking entrylks failed.");
 
-                local->transaction.done (frame, this);
-        } else {
-
-                gf_msg_debug (this->name, 0,
-                              "Blocking entrylks done. Proceeding to FOP");
+        afr_transaction_done(frame, this);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Blocking entrylks done. Proceeding to FOP");
 
-                afr_internal_lock_finish (frame, this);
-        }
-        return 0;
+        afr_internal_lock_finish(frame, this);
+    }
+    return 0;
 }
 
 int
-afr_post_lower_unlock_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_lower_unlock_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        GF_ASSERT (!int_lock->higher_locked);
+    GF_ASSERT(!int_lock->higher_locked);
 
-        int_lock->lock_cbk = afr_post_blocking_rename_cbk;
-        afr_blocking_lock (frame, this);
+    int_lock->lock_cbk = afr_post_blocking_rename_cbk;
+    afr_blocking_lock(frame, this);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_set_transaction_flock (xlator_t *this, afr_local_t *local)
+afr_set_transaction_flock(xlator_t *this, afr_local_t *local,
+                          afr_lockee_t *lockee)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_inodelk_t       *inodelk  = NULL;
-        afr_private_t       *priv     = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock *flock = NULL;
 
-        int_lock = &local->internal_lock;
-        inodelk = afr_get_inodelk (int_lock, int_lock->domain);
-        priv = this->private;
+    priv = this->private;
+    flock = &lockee->flock;
 
-        if (priv->arbiter_count &&
-            local->transaction.type == AFR_DATA_TRANSACTION) {
-                /*Lock entire file to avoid network split brains.*/
-                inodelk->flock.l_len   = 0;
-                inodelk->flock.l_start = 0;
-        } else {
-                inodelk->flock.l_len   = local->transaction.len;
-                inodelk->flock.l_start = local->transaction.start;
-        }
-        inodelk->flock.l_type  = F_WRLCK;
+    if ((priv->arbiter_count || local->transaction.eager_lock_on ||
+         priv->full_lock) &&
+        local->transaction.type == AFR_DATA_TRANSACTION) {
+        /*Lock entire file to avoid network split brains.*/
+        flock->l_len = 0;
+        flock->l_start = 0;
+    } else {
+        flock->l_len = local->transaction.len;
+        flock->l_start = local->transaction.start;
+    }
+    flock->l_type = F_WRLCK;
 
-        return 0;
+    return 0;
 }
 
 int
-afr_lock_rec (call_frame_t *frame, xlator_t *this)
+afr_lock(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        int_lock->transaction_lk_type = AFR_TRANSACTION_LK;
-        int_lock->domain = this->name;
+    int_lock->lock_cbk = afr_post_nonblocking_lock_cbk;
+    int_lock->domain = this->name;
 
-        switch (local->transaction.type) {
+    switch (local->transaction.type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
-                afr_set_transaction_flock (this, local);
+            for (i = 0; i < int_lock->lockee_count; i++) {
+                afr_set_transaction_flock(this, local, &int_lock->lockee[i]);
+            }
 
-                int_lock->lock_cbk = afr_post_nonblocking_inodelk_cbk;
-
-                afr_nonblocking_inodelk (frame, this);
-                break;
-
-        case AFR_ENTRY_RENAME_TRANSACTION:
-
-                int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
-                afr_nonblocking_entrylk (frame, this);
-                break;
+            break;
 
         case AFR_ENTRY_TRANSACTION:
-                int_lock->lk_basename = local->transaction.basename;
-                if (local->transaction.parent_loc.path)
-                        int_lock->lk_loc = &local->transaction.parent_loc;
-                else
-                        GF_ASSERT (local->fd);
-
-                int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
-                afr_nonblocking_entrylk (frame, this);
-                break;
-        }
+            int_lock->lk_basename = local->transaction.basename;
+            if (local->transaction.parent_loc.path)
+                int_lock->lk_loc = &local->transaction.parent_loc;
+            else
+                GF_ASSERT(local->fd);
+            break;
+        case AFR_ENTRY_RENAME_TRANSACTION:
+            break;
+    }
+    afr_lock_nonblocking(frame, this);
 
-        return 0;
+    return 0;
 }
 
-
-int
-afr_lock (call_frame_t *frame, xlator_t *this)
+static gf_boolean_t
+afr_locals_overlap(afr_local_t *local1, afr_local_t *local2)
 {
-        afr_set_lock_number (frame, this);
+    uint64_t start1 = local1->transaction.start;
+    uint64_t start2 = local2->transaction.start;
+    uint64_t end1 = 0;
+    uint64_t end2 = 0;
 
-        return afr_lock_rec (frame, this);
+    if (local1->transaction.len)
+        end1 = start1 + local1->transaction.len - 1;
+    else
+        end1 = ULLONG_MAX;
+
+    if (local2->transaction.len)
+        end2 = start2 + local2->transaction.len - 1;
+    else
+        end2 = ULLONG_MAX;
+
+    return ((end1 >= start2) && (end2 >= start1));
 }
 
+gf_boolean_t
+afr_has_lock_conflict(afr_local_t *local, gf_boolean_t waitlist_check)
+{
+    afr_local_t *each = NULL;
+    afr_lock_t *lock = NULL;
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    /*
+     * Once full file lock is acquired in eager-lock phase, overlapping
+     * writes do not compete for inode-locks, instead are transferred to the
+     * next writes. Because of this overlapping writes are not ordered.
+     * This can cause inconsistencies in replication.
+     * Example:
+     * Two overlapping writes w1, w2 are sent in parallel on same fd
+     * in two threads t1, t2.
+     * Both threads can execute afr_writev_wind in the following manner.
+     * t1 winds w1 on brick-0
+     * t2 winds w2 on brick-0
+     * t2 winds w2 on brick-1
+     * t1 winds w1 on brick-1
+     *
+     * This check makes sure the locks are not transferred for
+     * overlapping writes.
+     */
+    list_for_each_entry(each, &lock->owners, transaction.owner_list)
+    {
+        if (afr_locals_overlap(each, local)) {
+            return _gf_true;
+        }
+    }
+
+    if (!waitlist_check)
+        return _gf_false;
+    list_for_each_entry(each, &lock->waiting, transaction.wait_list)
+    {
+        if (afr_locals_overlap(each, local)) {
+            return _gf_true;
+        }
+    }
+    return _gf_false;
+}
 
 /* }}} */
-
-int
-afr_internal_lock_finish (call_frame_t *frame, xlator_t *this)
+static void
+afr_copy_inodelk_vars(afr_internal_lock_t *dst, afr_internal_lock_t *src,
+                      xlator_t *this, int lockee_num)
 {
-        if (__fop_changelog_needed (frame, this)) {
-                afr_changelog_pre_op (frame, this);
-        } else {
-                afr_transaction_perform_fop (frame, this);
-        }
+    afr_private_t *priv = this->private;
+    afr_lockee_t *sl = &src->lockee[lockee_num];
+    afr_lockee_t *dl = &dst->lockee[lockee_num];
 
-        return 0;
+    dst->domain = src->domain;
+    dl->flock.l_len = sl->flock.l_len;
+    dl->flock.l_start = sl->flock.l_start;
+    dl->flock.l_type = sl->flock.l_type;
+    dl->locked_count = sl->locked_count;
+    memcpy(dl->locked_nodes, sl->locked_nodes,
+           priv->child_count * sizeof(*dl->locked_nodes));
 }
 
-
 void
-afr_set_delayed_post_op (call_frame_t *frame, xlator_t *this)
+__afr_transaction_wake_shared(afr_local_t *local, struct list_head *shared)
 {
-        afr_local_t    *local = NULL;
-        afr_private_t  *priv = NULL;
-
-        /* call this function from any of the related optimizations
-           which benefit from delaying post op are enabled, namely:
-
-           - changelog piggybacking
-           - eager locking
-        */
+    gf_boolean_t conflict = _gf_false;
+    afr_local_t *each = NULL;
+    afr_lock_t *lock = &local->inode_ctx->lock[local->transaction.type];
 
-        priv = this->private;
-        if (!priv)
-                return;
-
-        if (!priv->post_op_delay_secs)
-                return;
-
-        local = frame->local;
-        if (!local)
-                return;
-
-        if (!local->transaction.eager_lock_on)
-                return;
-
-        if (!local->fd)
-                return;
-
-        if (local->op == GF_FOP_WRITE)
-                local->delayed_post_op = _gf_true;
+    while (!conflict) {
+        if (list_empty(&lock->waiting))
+            return;
+        each = list_entry(lock->waiting.next, afr_local_t,
+                          transaction.wait_list);
+        if (afr_has_lock_conflict(each, _gf_false)) {
+            conflict = _gf_true;
+        }
+        if (conflict && !list_empty(&lock->owners))
+            return;
+        afr_copy_inodelk_vars(&each->internal_lock, &local->internal_lock,
+                              each->transaction.frame->this, 0);
+        list_move_tail(&each->transaction.wait_list, shared);
+        list_add_tail(&each->transaction.owner_list, &lock->owners);
+    }
 }
 
-gf_boolean_t
-afr_are_multiple_fds_opened (fd_t *fd, xlator_t *this)
+static void
+afr_lock_resume_shared(struct list_head *list)
 {
-        afr_fd_ctx_t *fd_ctx = NULL;
+    afr_local_t *each = NULL;
 
-        if (!fd) {
-                /* If false is returned, it may keep on taking eager-lock
-                 * which may lead to starvation, so return true to avoid that.
-                 */
-                gf_msg_callingfn (this->name, GF_LOG_ERROR, EBADF,
-                                  AFR_MSG_INVALID_ARG, "Invalid fd");
-                return _gf_true;
-        }
-        /* Lets say mount1 has eager-lock(full-lock) and after the eager-lock
-         * is taken mount2 opened the same file, it won't be able to
-         * perform any data operations until mount1 releases eager-lock.
-         * To avoid such scenario do not enable eager-lock for this transaction
-         * if open-fd-count is > 1
-         */
-
-        fd_ctx = afr_fd_ctx_get (fd, this);
-        if (!fd_ctx)
-                return _gf_true;
+    while (!list_empty(list)) {
+        each = list_entry(list->next, afr_local_t, transaction.wait_list);
+        list_del_init(&each->transaction.wait_list);
+        afr_changelog_pre_op(each->transaction.frame,
+                             each->transaction.frame->this);
+    }
+}
 
-        if (fd_ctx->open_fd_count > 1)
-                return _gf_true;
+int
+afr_internal_lock_finish(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = frame->local;
+    afr_lock_t *lock = NULL;
+
+    local->internal_lock.lock_cbk = NULL;
+    if (!local->transaction.eager_lock_on) {
+        if (local->internal_lock.lock_op_ret < 0) {
+            afr_transaction_done(frame, this);
+            return 0;
+        }
+        afr_changelog_pre_op(frame, this);
+    } else {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        if (local->internal_lock.lock_op_ret < 0) {
+            afr_handle_lock_acquire_failure(local);
+        } else {
+            lock->event_generation = local->event_generation;
+            afr_changelog_pre_op(frame, this);
+        }
+    }
 
-        return _gf_false;
+    return 0;
 }
 
-
 gf_boolean_t
-is_afr_delayed_changelog_post_op_needed (call_frame_t *frame, xlator_t *this)
+afr_are_conflicting_ops_waiting(afr_local_t *local, xlator_t *this)
 {
-        afr_local_t      *local = NULL;
-        gf_boolean_t      res = _gf_false;
-
-        local = frame->local;
-        if (!local)
-                goto out;
+    afr_lock_t *lock = NULL;
+    lock = &local->inode_ctx->lock[local->transaction.type];
 
-        if (!local->delayed_post_op)
-                goto out;
+    /* Lets say mount1 has eager-lock(full-lock) and after the eager-lock
+     * is taken mount2 opened the same file, it won't be able to
+     * perform any {meta,}data operations until mount1 releases eager-lock.
+     * To avoid such scenario do not enable eager-lock for this transaction
+     * if open-fd-count is > 1 for metadata transactions and if num-inodelks > 1
+     * for data transactions
+     */
 
-        //Mark pending changelog ASAP
-        if (!afr_txn_nothing_failed (frame, this))
-                goto out;
+    if (local->transaction.type == AFR_METADATA_TRANSACTION) {
+        if (local->inode_ctx->open_fd_count > 1) {
+            return _gf_true;
+        }
+    } else if (local->transaction.type == AFR_DATA_TRANSACTION) {
+        if (lock->num_inodelks > 1) {
+            return _gf_true;
+        }
+    }
 
-        if (local->fd && afr_are_multiple_fds_opened (local->fd, this))
-                goto out;
+    return _gf_false;
+}
 
-        res = _gf_true;
+gf_boolean_t
+afr_is_delayed_changelog_post_op_needed(call_frame_t *frame, xlator_t *this,
+                                        int delay)
+{
+    afr_local_t *local = NULL;
+    afr_lock_t *lock = NULL;
+    gf_boolean_t res = _gf_false;
+
+    local = frame->local;
+    lock = &local->inode_ctx->lock[local->transaction.type];
+
+    if (!afr_txn_nothing_failed(frame, this)) {
+        lock->release = _gf_true;
+        goto out;
+    }
+
+    if (afr_are_conflicting_ops_waiting(local, this)) {
+        lock->release = _gf_true;
+        goto out;
+    }
+
+    if (!list_empty(&lock->owners))
+        goto out;
+    else
+        GF_ASSERT(list_empty(&lock->waiting));
+
+    if (lock->release) {
+        goto out;
+    }
+
+    if (!delay) {
+        goto out;
+    }
+
+    if (local->transaction.disable_delayed_post_op) {
+        goto out;
+    }
+
+    if ((local->op != GF_FOP_WRITE) && (local->op != GF_FOP_FXATTROP) &&
+        (local->op != GF_FOP_FSYNC)) {
+        /*Only allow writes/fsyncs but shard does [f]xattrops on writes, so
+         * they are fine too*/
+        goto out;
+    }
+
+    res = _gf_true;
 out:
-        return res;
+    return res;
 }
 
-
 void
-afr_delayed_changelog_wake_up_cbk (void *data)
-{
-        fd_t           *fd = NULL;
-
-        fd = data;
-
-        afr_delayed_changelog_wake_up (THIS, fd);
+afr_delayed_changelog_wake_up_cbk(void *data)
+{
+    afr_lock_t *lock = NULL;
+    afr_local_t *local = data;
+    afr_local_t *timer_local = NULL;
+    struct list_head shared;
+
+    INIT_LIST_HEAD(&shared);
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        timer_local = list_entry(lock->post_op.next, afr_local_t,
+                                 transaction.owner_list);
+        if (list_empty(&lock->owners) && (local == timer_local)) {
+            GF_ASSERT(list_empty(&lock->waiting));
+            /*Last owner*/
+            lock->release = _gf_true;
+            lock->delay_timer = NULL;
+        }
+    }
+    UNLOCK(&local->inode->lock);
+    afr_changelog_post_op_now(local->transaction.frame,
+                              local->transaction.frame->this);
 }
 
-
 /* SET operation */
 int
-afr_fd_report_unstable_write (xlator_t *this, fd_t *fd)
+afr_fd_report_unstable_write(xlator_t *this, afr_local_t *local)
 {
-        afr_fd_ctx_t *fdctx = NULL;
-
-        fdctx = afr_fd_ctx_get (fd, this);
-
-        LOCK(&fd->lock);
-        {
-                fdctx->witnessed_unstable_write = _gf_true;
-        }
-        UNLOCK(&fd->lock);
+    LOCK(&local->inode->lock);
+    {
+        local->inode_ctx->witnessed_unstable_write = _gf_true;
+    }
+    UNLOCK(&local->inode->lock);
 
-        return 0;
+    return 0;
 }
 
 /* TEST and CLEAR operation */
 gf_boolean_t
-afr_fd_has_witnessed_unstable_write (xlator_t *this, fd_t *fd)
+afr_fd_has_witnessed_unstable_write(xlator_t *this, inode_t *inode)
 {
-        afr_fd_ctx_t *fdctx = NULL;
-        gf_boolean_t witness = _gf_false;
+    afr_inode_ctx_t *ctx = NULL;
+    gf_boolean_t witness = _gf_false;
 
-        fdctx = afr_fd_ctx_get (fd, this);
-        if (!fdctx)
-                return _gf_true;
+    LOCK(&inode->lock);
+    {
+        (void)__afr_inode_ctx_get(this, inode, &ctx);
 
-        LOCK(&fd->lock);
-        {
-                if (fdctx->witnessed_unstable_write) {
-                        witness = _gf_true;
-                        fdctx->witnessed_unstable_write = _gf_false;
-                }
+        if (ctx->witnessed_unstable_write) {
+            witness = _gf_true;
+            ctx->witnessed_unstable_write = _gf_false;
         }
-        UNLOCK (&fd->lock);
+    }
+    UNLOCK(&inode->lock);
 
-        return witness;
+    return witness;
 }
 
-
 int
-afr_changelog_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *pre,
-                         struct iatt *post, dict_t *xdata)
+afr_changelog_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *pre,
+                        struct iatt *post, dict_t *xdata)
 {
-        afr_private_t *priv = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_local_t *local = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        if (op_ret != 0) {
-                /* Failure of fsync() is as good as failure of previous
-                   write(). So treat it like one.
-		*/
-                gf_msg (this->name, GF_LOG_WARNING,
-                        op_errno, AFR_MSG_FSYNC_FAILED,
-                        "fsync(%s) failed on subvolume %s. Transaction was %s",
-                        uuid_utoa (local->fd->inode->gfid),
-                        priv->children[child_index]->name,
-                        gf_fop_list[local->op]);
+    if (op_ret != 0) {
+        /* Failure of fsync() is as good as failure of previous
+           write(). So treat it like one.
+        */
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, AFR_MSG_FSYNC_FAILED,
+               "fsync(%s) failed on subvolume %s. Transaction was %s",
+               uuid_utoa(local->fd->inode->gfid),
+               priv->children[child_index]->name, gf_fop_list[local->op]);
 
-                afr_transaction_fop_failed (frame, this, child_index);
-	}
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
 
-	call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-	if (call_count == 0)
-		afr_changelog_post_op_now (frame, this);
+    if (call_count == 0)
+        afr_changelog_post_op_now(frame, this);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_changelog_fsync (call_frame_t *frame, xlator_t *this)
+afr_changelog_fsync(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        int i = 0;
-        int call_count = 0;
-        afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        GF_UNUSED int ret = -1;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    GF_UNUSED int ret = -1;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        call_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
+    call_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
 
-        if (!call_count) {
-                /* will go straight to unlock */
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    if (!call_count) {
+        /* will go straight to unlock */
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        xdata = dict_new();
-        if (xdata)
-                ret = dict_set_int32 (xdata, "batch-fsync", 1);
+    xdata = dict_new();
+    if (xdata) {
+        ret = dict_set_int32_sizen(xdata, "batch-fsync", 1);
+        ret = dict_set_str(xdata, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.pre_op[i])
+            continue;
 
-                STACK_WIND_COOKIE (frame, afr_changelog_fsync_cbk,
-				   (void *) (long) i, priv->children[i],
-				   priv->children[i]->fops->fsync, local->fd,
-				   1, xdata);
-                if (!--call_count)
-                        break;
-        }
+        STACK_WIND_COOKIE(frame, afr_changelog_fsync_cbk, (void *)(long)i,
+                          priv->children[i], priv->children[i]->fops->fsync,
+                          local->fd, 1, xdata);
+        if (!--call_count)
+            break;
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    if (xdata)
+        dict_unref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_changelog_post_op_safe (call_frame_t *frame, xlator_t *this)
+afr_changelog_post_op_safe(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t    *local = NULL;
-        afr_private_t  *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-        priv = this->private;
-
-        if (!local->fd || local->transaction.type != AFR_DATA_TRANSACTION) {
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-        if (afr_changelog_pre_op_uninherit (frame, this) &&
-	    afr_txn_nothing_failed (frame, this)) {
-                /* just detected that this post-op is about to
-                   be optimized away as a new write() has
-                   already piggybacked on this frame's changelog.
-                   */
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    if (!local->fd || local->transaction.type != AFR_DATA_TRANSACTION) {
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        /* Calling afr_changelog_post_op_now() now will result in
-           issuing ->[f]xattrop().
-
-           Performing a hard POST-OP (->[f]xattrop() FOP) is a more
-           responsible operation that what it might appear on the surface.
-
-           The changelog of a file (in the xattr of the file on the server)
-           stores information (pending count) about the state of the file
-           on the OTHER server. This changelog is blindly trusted, and must
-           therefore be updated in such a way it remains trustworthy. This
-           implies that decrementing the pending count (essentially "clearing
-           the dirty flag") must be done STRICTLY after we are sure that the
-           operation on the other server has reached stable storage.
-
-           While the backend filesystem on that server will eventually flush
-           it to stable storage, we (being in userspace) have no mechanism
-           to get notified when the write became "stable".
-
-           This means we need take matter into our own hands and issue an
-           fsync() EVEN IF THE APPLICATION WAS PERFORMING UNSTABLE WRITES,
-           and get an acknowledgement for it. And we need to wait for the
-           fsync() acknowledgement before initiating the hard POST-OP.
-
-           However if the FD itself was opened in O_SYNC or O_DSYNC then
-           we are already guaranteed that the writes were made stable as
-           part of the FOP itself. The same holds true for NFS stable
-           writes which happen on an anonymous FD with O_DSYNC or O_SYNC
-           flag set in the writev() @flags param. For all other write types,
-           mark a flag in the fdctx whenever an unstable write is witnessed.
+    if (afr_changelog_pre_op_uninherit(frame, this) &&
+        afr_txn_nothing_failed(frame, this)) {
+        /* just detected that this post-op is about to
+           be optimized away as a new write() has
+           already piggybacked on this frame's changelog.
            */
-
-        if (!afr_fd_has_witnessed_unstable_write (this, local->fd)) {
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
-
-        /* Check whether users want durability and perform fsync/post-op
-         * accordingly.
-         */
-        if (priv->ensure_durability) {
-                /* Time to fsync() */
-                afr_changelog_fsync (frame, this);
-        } else {
-                afr_changelog_post_op_now (frame, this);
-        }
-
+        afr_changelog_post_op_now(frame, this);
         return 0;
-}
-
-
-void
-afr_delayed_changelog_post_op (xlator_t *this, call_frame_t *frame, fd_t *fd,
-                               call_stub_t *stub)
-{
-	afr_fd_ctx_t      *fd_ctx = NULL;
-	call_frame_t      *prev_frame = NULL;
-	struct timespec    delta = {0, };
-	afr_private_t     *priv = NULL;
-	afr_local_t       *local = NULL;
-
-	priv = this->private;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-                goto out;
-
-	delta.tv_sec = priv->post_op_delay_secs;
-	delta.tv_nsec = 0;
-
-	pthread_mutex_lock (&fd_ctx->delay_lock);
-	{
-		prev_frame = fd_ctx->delay_frame;
-		fd_ctx->delay_frame = NULL;
-		if (fd_ctx->delay_timer)
-			gf_timer_call_cancel (this->ctx, fd_ctx->delay_timer);
-		fd_ctx->delay_timer = NULL;
-		if (!frame)
-			goto unlock;
-		fd_ctx->delay_timer = gf_timer_call_after (this->ctx, delta,
-							   afr_delayed_changelog_wake_up_cbk,
-							   fd);
-		fd_ctx->delay_frame = frame;
-	}
-unlock:
-	pthread_mutex_unlock (&fd_ctx->delay_lock);
-
-out:
-	if (prev_frame) {
-		local = prev_frame->local;
-		local->transaction.resume_stub = stub;
-		afr_changelog_post_op_now (prev_frame, this);
-	} else if (stub) {
-		call_resume (stub);
-	}
-}
-
-
-void
-afr_changelog_post_op (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t  *local = NULL;
+    }
+
+    /* Calling afr_changelog_post_op_now() now will result in
+       issuing ->[f]xattrop().
+
+       Performing a hard POST-OP (->[f]xattrop() FOP) is a more
+       responsible operation that what it might appear on the surface.
+
+       The changelog of a file (in the xattr of the file on the server)
+       stores information (pending count) about the state of the file
+       on the OTHER server. This changelog is blindly trusted, and must
+       therefore be updated in such a way it remains trustworthy. This
+       implies that decrementing the pending count (essentially "clearing
+       the dirty flag") must be done STRICTLY after we are sure that the
+       operation on the other server has reached stable storage.
+
+       While the backend filesystem on that server will eventually flush
+       it to stable storage, we (being in userspace) have no mechanism
+       to get notified when the write became "stable".
+
+       This means we need take matter into our own hands and issue an
+       fsync() EVEN IF THE APPLICATION WAS PERFORMING UNSTABLE WRITES,
+       and get an acknowledgement for it. And we need to wait for the
+       fsync() acknowledgement before initiating the hard POST-OP.
+
+       However if the FD itself was opened in O_SYNC or O_DSYNC then
+       we are already guaranteed that the writes were made stable as
+       part of the FOP itself. The same holds true for NFS stable
+       writes which happen on an anonymous FD with O_DSYNC or O_SYNC
+       flag set in the writev() @flags param. For all other write types,
+       mark a flag in the fdctx whenever an unstable write is witnessed.
+       */
+
+    if (!afr_fd_has_witnessed_unstable_write(this, local->inode)) {
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        local = frame->local;
+    /* Check whether users want durability and perform fsync/post-op
+     * accordingly.
+     */
+    if (priv->ensure_durability) {
+        /* Time to fsync() */
+        afr_changelog_fsync(frame, this);
+    } else {
+        afr_changelog_post_op_now(frame, this);
+    }
 
-        if (is_afr_delayed_changelog_post_op_needed (frame, this))
-                afr_delayed_changelog_post_op (this, frame, local->fd, NULL);
-        else
-                afr_changelog_post_op_safe (frame, this);
+    return 0;
 }
 
-
-
-/* Wake up the sleeping/delayed post-op, and also register
-   a stub to have it resumed after this transaction
-   completely finishes.
-
-   The @stub gets saved in @local and gets resumed in
-   afr_local_cleanup()
-   */
 void
-afr_delayed_changelog_wake_resume (xlator_t *this, fd_t *fd, call_stub_t *stub)
-{
-        afr_delayed_changelog_post_op (this, NULL, fd, stub);
-}
+afr_changelog_post_op(call_frame_t *frame, xlator_t *this)
+{
+    struct timespec delta = {
+        0,
+    };
+    afr_private_t *priv = NULL;
+    afr_local_t *local = frame->local;
+    afr_lock_t *lock = NULL;
+    gf_boolean_t post_op = _gf_true;
+    struct list_head shared;
+
+    priv = this->private;
+    delta.tv_sec = priv->post_op_delay_secs;
+    delta.tv_nsec = 0;
+
+    INIT_LIST_HEAD(&shared);
+    if (!local->transaction.eager_lock_on)
+        goto out;
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        list_del_init(&local->transaction.owner_list);
+        list_add(&local->transaction.owner_list, &lock->post_op);
+        __afr_transaction_wake_shared(local, &shared);
+
+        if (!afr_is_delayed_changelog_post_op_needed(frame, this,
+                                                     delta.tv_sec)) {
+            if (list_empty(&lock->owners))
+                lock->release = _gf_true;
+            goto unlock;
+        }
+
+        GF_ASSERT(lock->delay_timer == NULL);
+        lock->delay_timer = gf_timer_call_after(
+            this->ctx, delta, afr_delayed_changelog_wake_up_cbk, local);
+        if (!lock->delay_timer) {
+            lock->release = _gf_true;
+        } else {
+            post_op = _gf_false;
+        }
+    }
+unlock:
+    UNLOCK(&local->inode->lock);
 
+    if (!list_empty(&shared)) {
+        afr_lock_resume_shared(&shared);
+    }
 
-void
-afr_delayed_changelog_wake_up (xlator_t *this, fd_t *fd)
-{
-        afr_delayed_changelog_post_op (this, NULL, fd, NULL);
+out:
+    if (post_op) {
+        if (!local->transaction.eager_lock_on || lock->release) {
+            afr_changelog_post_op_safe(frame, this);
+        } else {
+            afr_changelog_post_op_now(frame, this);
+        }
+    }
 }
 
 int
-afr_transaction_resume (call_frame_t *frame, xlator_t *this)
+afr_transaction_resume(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t         *local    = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
+    local = frame->local;
 
-        if (local->transaction.eager_lock_on) {
-                /* We don't need to retain "local" in the
-                   fd list anymore, writes to all subvols
-                   are finished by now */
-                afr_remove_eager_lock_stub (local);
-        }
+    afr_restore_lk_owner(frame);
 
-        afr_restore_lk_owner (frame);
+    afr_handle_symmetric_errors(frame, this);
 
-        afr_handle_symmetric_errors (frame, this);
+    if (!local->pre_op_compat)
+        /* new mode, pre-op was done along
+           with OP */
+        afr_changelog_pre_op_update(frame, this);
 
-	if (!local->pre_op_compat)
-		/* new mode, pre-op was done along
-		   with OP */
-		afr_changelog_pre_op_update (frame, this);
+    afr_changelog_post_op(frame, this);
 
-        if (__fop_changelog_needed (frame, this)) {
-                afr_changelog_post_op (frame, this);
-        } else {
-		afr_changelog_post_op_done (frame, this);
-        }
-
-        return 0;
+    return 0;
 }
 
-
 /**
  * afr_transaction_fop_failed - inform that an fop failed
  */
 
 void
-afr_transaction_fop_failed (call_frame_t *frame, xlator_t *this,
-                            int child_index)
+afr_transaction_fop_failed(call_frame_t *frame, xlator_t *this, int child_index)
 {
-        afr_local_t *   local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	local->transaction.failed_subvols[child_index] = 1;
+    local->transaction.failed_subvols[child_index] = 1;
 }
 
-
-
 static gf_boolean_t
-afr_locals_overlap (afr_local_t *local1, afr_local_t *local2)
+__need_previous_lock_unlocked(afr_local_t *local)
 {
-        uint64_t start1 = local1->transaction.start;
-        uint64_t start2 = local2->transaction.start;
-        uint64_t end1 = 0;
-        uint64_t end2 = 0;
-
-        if (local1->transaction.len)
-                end1 = start1 + local1->transaction.len - 1;
-        else
-                end1 = ULLONG_MAX;
+    afr_lock_t *lock = NULL;
 
-        if (local2->transaction.len)
-                end2 = start2 + local2->transaction.len - 1;
-        else
-                end2 = ULLONG_MAX;
-
-        return ((end1 >= start2) && (end2 >= start1));
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    if (!lock->acquired)
+        return _gf_false;
+    if (lock->acquired && lock->event_generation != local->event_generation)
+        return _gf_true;
+    return _gf_false;
 }
 
 void
-afr_transaction_eager_lock_init (afr_local_t *local, xlator_t *this)
-{
-        afr_private_t *priv = NULL;
-        afr_fd_ctx_t  *fdctx = NULL;
-        afr_local_t   *each = NULL;
-
-        priv = this->private;
-
-        if (!local->fd)
-                return;
-
-        if (local->transaction.type != AFR_DATA_TRANSACTION)
-                return;
-
-        if (!priv->eager_lock)
-                return;
-
-        fdctx = afr_fd_ctx_get (local->fd, this);
-        if (!fdctx)
-                return;
-
-        if (afr_are_multiple_fds_opened (local->fd, this))
-                return;
-        /*
-         * Once full file lock is acquired in eager-lock phase, overlapping
-         * writes do not compete for inode-locks, instead are transferred to the
-         * next writes. Because of this overlapping writes are not ordered.
-         * This can cause inconsistencies in replication.
-         * Example:
-         * Two overlapping writes w1, w2 are sent in parallel on same fd
-         * in two threads t1, t2.
-         * Both threads can execute afr_writev_wind in the following manner.
-         * t1 winds w1 on brick-0
-         * t2 winds w2 on brick-0
-         * t2 winds w2 on brick-1
-         * t1 winds w1 on brick-1
-         *
-         * This check makes sure the locks are not transferred for
-         * overlapping writes.
-         */
-        LOCK (&local->fd->lock);
-        {
-                list_for_each_entry (each, &fdctx->eager_locked,
-                                     transaction.eager_locked) {
-                        if (afr_locals_overlap (each, local)) {
-                                local->transaction.eager_lock_on = _gf_false;
-                                goto unlock;
-                        }
-                }
-
-                local->transaction.eager_lock_on = _gf_true;
-                list_add_tail (&local->transaction.eager_locked,
-                               &fdctx->eager_locked);
-        }
-unlock:
-        UNLOCK (&local->fd->lock);
+__afr_eager_lock_handle(afr_local_t *local, gf_boolean_t *take_lock,
+                        gf_boolean_t *do_pre_op, afr_local_t **timer_local)
+{
+    afr_lock_t *lock = NULL;
+    afr_local_t *owner_local = NULL;
+    xlator_t *this = local->transaction.frame->this;
+
+    local->transaction.eager_lock_on = _gf_true;
+    afr_set_lk_owner(local->transaction.frame, this, local->inode);
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    if (__need_previous_lock_unlocked(local)) {
+        if (!list_empty(&lock->owners)) {
+            lock->release = _gf_true;
+        } else if (lock->delay_timer) {
+            lock->release = _gf_true;
+            if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+                /* It will be put in frozen list
+                 * in the code flow below*/
+            } else {
+                *timer_local = list_entry(lock->post_op.next, afr_local_t,
+                                          transaction.owner_list);
+                lock->delay_timer = NULL;
+            }
+        }
+    }
+
+    if (lock->release) {
+        list_add_tail(&local->transaction.wait_list, &lock->frozen);
+        *take_lock = _gf_false;
+        goto out;
+    }
+
+    if (lock->delay_timer) {
+        *take_lock = _gf_false;
+        if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+            list_add_tail(&local->transaction.wait_list, &lock->frozen);
+        } else {
+            *timer_local = list_entry(lock->post_op.next, afr_local_t,
+                                      transaction.owner_list);
+            afr_copy_inodelk_vars(&local->internal_lock,
+                                  &(*timer_local)->internal_lock, this, 0);
+            lock->delay_timer = NULL;
+            *do_pre_op = _gf_true;
+            list_add_tail(&local->transaction.owner_list, &lock->owners);
+        }
+        goto out;
+    }
+
+    if (!list_empty(&lock->owners)) {
+        if (!lock->acquired || afr_has_lock_conflict(local, _gf_true)) {
+            list_add_tail(&local->transaction.wait_list, &lock->waiting);
+            *take_lock = _gf_false;
+            goto out;
+        }
+        owner_local = list_entry(lock->owners.next, afr_local_t,
+                                 transaction.owner_list);
+        afr_copy_inodelk_vars(&local->internal_lock,
+                              &owner_local->internal_lock, this, 0);
+        *take_lock = _gf_false;
+        *do_pre_op = _gf_true;
+    }
+
+    if (lock->acquired)
+        GF_ASSERT(!(*take_lock));
+    list_add_tail(&local->transaction.owner_list, &lock->owners);
+out:
+    return;
 }
 
 void
-afr_transaction_start (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   *local = frame->local;
-        afr_private_t *priv  = this->private;
-        fd_t          *fd    = NULL;
-
-        afr_transaction_eager_lock_init (local, this);
-
-        if (local->fd && local->transaction.eager_lock_on)
-                afr_set_lk_owner (frame, this, local->fd);
-        else
-                afr_set_lk_owner (frame, this, frame->root);
-
-        if (!local->transaction.eager_lock_on && local->loc.inode) {
-                fd = fd_lookup (local->loc.inode, frame->root->pid);
-                if (fd == NULL)
-                        fd = fd_lookup_anonymous (local->loc.inode,
-                                                  GF_ANON_FD_FLAGS);
-
-                if (fd) {
-                        afr_delayed_changelog_wake_up (this, fd);
-                        fd_unref (fd);
-                }
-        }
-
-        if (afr_lock_server_count (priv, local->transaction.type) == 0) {
-                afr_internal_lock_finish (frame, this);
-        } else {
-                afr_lock (frame, this);
-        }
+afr_transaction_start(afr_local_t *local, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    gf_boolean_t take_lock = _gf_true;
+    gf_boolean_t do_pre_op = _gf_false;
+    afr_local_t *timer_local = NULL;
+
+    priv = this->private;
+
+    if (local->transaction.type != AFR_DATA_TRANSACTION &&
+        local->transaction.type != AFR_METADATA_TRANSACTION)
+        goto lock_phase;
+
+    if (!priv->eager_lock)
+        goto lock_phase;
+
+    LOCK(&local->inode->lock);
+    {
+        __afr_eager_lock_handle(local, &take_lock, &do_pre_op, &timer_local);
+    }
+    UNLOCK(&local->inode->lock);
+lock_phase:
+    if (!local->transaction.eager_lock_on) {
+        afr_set_lk_owner(local->transaction.frame, this,
+                         local->transaction.frame->root);
+    }
+
+    if (take_lock) {
+        afr_lock(local->transaction.frame, this);
+    } else if (do_pre_op) {
+        afr_changelog_pre_op(local->transaction.frame, this);
+    }
+    /*Always call delayed_changelog_wake_up_cbk after calling pre-op above
+     * so that any inheriting can happen*/
+    if (timer_local)
+        afr_delayed_changelog_wake_up_cbk(timer_local);
 }
 
 int
-afr_write_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
+afr_write_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
 {
-        afr_local_t   *local           = frame->local;
+    afr_local_t *local = frame->local;
 
-        if (err) {
-                AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, -err);
-                goto fail;
-        }
+    if (err) {
+        AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, err);
+        goto fail;
+    }
 
-        afr_transaction_start (frame, this);
-        return 0;
+    afr_transaction_start(local, this);
+    return 0;
 fail:
-        local->transaction.unwind (frame, this);
-        AFR_STACK_DESTROY (frame);
-        return 0;
+    local->transaction.unwind(frame, this);
+    AFR_STACK_DESTROY(frame);
+    return 0;
 }
 
 int
-afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
+afr_transaction_lockee_init(call_frame_t *frame)
 {
-        afr_local_t   *local           = NULL;
-        afr_private_t *priv            = NULL;
-        int           ret              = -1;
-        int           event_generation = 0;
+    afr_local_t *local = frame->local;
+    afr_internal_lock_t *int_lock = &local->internal_lock;
+    afr_private_t *priv = frame->this->private;
+    int ret = 0;
 
-        local = frame->local;
-        priv  = this->private;
-
-        local->transaction.resume = afr_transaction_resume;
-        local->transaction.type   = type;
-
-        if (!afr_is_consistent_io_possible (local, priv, &ret)) {
-                ret = -ret; /*op_errno to ret conversion*/
-                goto out;
-        }
+    switch (local->transaction.type) {
+        case AFR_DATA_TRANSACTION:
+        case AFR_METADATA_TRANSACTION:
+            ret = afr_add_inode_lockee(local, priv->child_count);
+            break;
 
-        ret = afr_transaction_local_init (local, this);
-        if (ret < 0)
+        case AFR_ENTRY_TRANSACTION:
+        case AFR_ENTRY_RENAME_TRANSACTION:
+            ret = afr_add_entry_lockee(local, &local->transaction.parent_loc,
+                                       local->transaction.basename,
+                                       priv->child_count);
+            if (ret) {
                 goto out;
+            }
+            if (local->op == GF_FOP_RENAME) {
+                ret = afr_add_entry_lockee(
+                    local, &local->transaction.new_parent_loc,
+                    local->transaction.new_basename, priv->child_count);
+                if (ret) {
+                    goto out;
+                }
 
-        if (type == AFR_ENTRY_TRANSACTION ||
-            type == AFR_ENTRY_RENAME_TRANSACTION) {
-                afr_transaction_start (frame, this);
-                ret = 0;
-                goto out;
-        }
+                if (local->newloc.inode &&
+                    IA_ISDIR(local->newloc.inode->ia_type)) {
+                    ret = afr_add_entry_lockee(local, &local->newloc, NULL,
+                                               priv->child_count);
+                    if (ret) {
+                        goto out;
+                    }
+                }
+            } else if (local->op == GF_FOP_RMDIR) {
+                ret = afr_add_entry_lockee(local, &local->loc, NULL,
+                                           priv->child_count);
+                if (ret) {
+                    goto out;
+                }
+            }
+
+            if (int_lock->lockee_count > 1) {
+                qsort(int_lock->lockee, int_lock->lockee_count,
+                      sizeof(*int_lock->lockee), afr_entry_lockee_cmp);
+            }
+            break;
+    }
+out:
+    return ret;
+}
 
-        ret = afr_inode_get_readable (frame, local->inode, this,
-                                      local->readable, &event_generation, type);
-        if (ret < 0 || afr_is_inode_refresh_reqd (local->inode, this,
-                                                  priv->event_generation,
-                                                  event_generation)) {
-                afr_inode_refresh (frame, this, local->inode, local->loc.gfid,
-                                   afr_write_txn_refresh_done);
-        } else {
-                afr_transaction_start (frame, this);
-        }
+int
+afr_transaction(call_frame_t *frame, xlator_t *this, afr_transaction_type type)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    int event_generation = 0;
+
+    local = frame->local;
+    priv = this->private;
+    local->transaction.frame = frame;
+
+    local->transaction.type = type;
+
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this, NULL)) {
+        ret = -afr_quorum_errno(priv);
+        goto out;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &ret)) {
+        ret = -ret; /*op_errno to ret conversion*/
+        goto out;
+    }
+
+    if (priv->thin_arbiter_count && !afr_ta_has_quorum(priv, local)) {
+        ret = -afr_quorum_errno(priv);
+        goto out;
+    }
+
+    ret = afr_transaction_local_init(local, this);
+    if (ret < 0)
+        goto out;
+
+    ret = afr_transaction_lockee_init(frame);
+    if (ret)
+        goto out;
+
+    if (type != AFR_METADATA_TRANSACTION) {
+        goto txn_start;
+    }
+
+    ret = afr_inode_get_readable(frame, local->inode, this, local->readable,
+                                 &event_generation, type);
+    if (ret < 0 ||
+        afr_is_inode_refresh_reqd(local->inode, this, priv->event_generation,
+                                  event_generation)) {
+        afr_inode_refresh(frame, this, local->inode, local->loc.gfid,
+                          afr_write_txn_refresh_done);
         ret = 0;
+        goto out;
+    }
+
+txn_start:
+    ret = 0;
+    afr_transaction_start(local, this);
 out:
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-transaction.h b/xlators/cluster/afr/src/afr-transaction.h
index dd19e5b2b18..beefa26f4a6 100644
--- a/xlators/cluster/afr/src/afr-transaction.h
+++ b/xlators/cluster/afr/src/afr-transaction.h
@@ -14,51 +14,62 @@
 #include "afr.h"
 
 void
-afr_transaction_fop_failed (call_frame_t *frame, xlator_t *this,
-			    int child_index);
+afr_transaction_fop_failed(call_frame_t *frame, xlator_t *this,
+                           int child_index);
+
+int32_t
+afr_transaction(call_frame_t *frame, xlator_t *this, afr_transaction_type type);
 
 int
-afr_lock_server_count (afr_private_t *priv, afr_transaction_type type);
+afr_set_pending_dict(afr_private_t *priv, dict_t *xattr, int32_t **pending);
 
-afr_inodelk_t*
-afr_get_inodelk (afr_internal_lock_t *int_lock, char *dom);
+void
+afr_delayed_changelog_wake_up(xlator_t *this, fd_t *fd);
 
-int32_t
-afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type);
+void
+__mark_all_success(call_frame_t *frame, xlator_t *this);
+
+gf_boolean_t
+afr_txn_nothing_failed(call_frame_t *frame, xlator_t *this);
 
 int
-afr_set_pending_dict (afr_private_t *priv, dict_t *xattr, int32_t **pending);
+afr_read_txn(call_frame_t *frame, xlator_t *this, inode_t *inode,
+             afr_read_txn_wind_t readfn, afr_transaction_type type);
 
-void
-afr_set_delayed_post_op (call_frame_t *frame, xlator_t *this);
+int
+afr_read_txn_continue(call_frame_t *frame, xlator_t *this, int subvol);
 
 void
-afr_delayed_changelog_wake_up (xlator_t *this, fd_t *fd);
+afr_pending_read_increment(afr_private_t *priv, int child_index);
 
 void
-__mark_all_success (call_frame_t *frame, xlator_t *this);
+afr_pending_read_decrement(afr_private_t *priv, int child_index);
 
+call_frame_t *
+afr_transaction_detach_fop_frame(call_frame_t *frame);
 gf_boolean_t
-afr_txn_nothing_failed (call_frame_t *frame, xlator_t *this);
-
-int afr_read_txn (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		  afr_read_txn_wind_t readfn, afr_transaction_type type);
+afr_has_quorum(unsigned char *subvols, xlator_t *this, call_frame_t *frame);
+gf_boolean_t
+afr_needs_changelog_update(afr_local_t *local);
+void
+afr_zero_fill_stat(afr_local_t *local);
 
-int afr_read_txn_continue (call_frame_t *frame, xlator_t *this, int subvol);
+void
+afr_pick_error_xdata(afr_local_t *local, afr_private_t *priv, inode_t *inode1,
+                     unsigned char *readable1, inode_t *inode2,
+                     unsigned char *readable2);
+int
+afr_transaction_resume(call_frame_t *frame, xlator_t *this);
 
-int __afr_txn_write_fop (call_frame_t *frame, xlator_t *this);
-int __afr_txn_write_done (call_frame_t *frame, xlator_t *this);
-call_frame_t *afr_transaction_detach_fop_frame (call_frame_t *frame);
-gf_boolean_t afr_has_quorum (unsigned char *subvols, xlator_t *this);
-gf_boolean_t afr_needs_changelog_update (afr_local_t *local);
-void afr_zero_fill_stat (afr_local_t *local);
+int
+afr_lock(call_frame_t *frame, xlator_t *this);
 
 void
-afr_pick_error_xdata (afr_local_t *local, afr_private_t *priv,
-                      inode_t *inode1, unsigned char *readable1,
-                      inode_t *inode2, unsigned char *readable2);
+afr_delayed_changelog_wake_up_cbk(void *data);
+
+int
+afr_release_notify_lock_for_ta(void *opaque);
+
 int
-afr_pre_op_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       void *data, dict_t *xdata);
+afr_ta_lock_release_done(int ret, call_frame_t *ta_frame, void *opaque);
 #endif /* __TRANSACTION_H__ */
diff --git a/xlators/cluster/afr/src/afr.c b/xlators/cluster/afr/src/afr.c
index 84dbcc04680..df7366f0a65 100644
--- a/xlators/cluster/afr/src/afr.c
+++ b/xlators/cluster/afr/src/afr.c
@@ -21,1108 +21,1324 @@
 struct volume_options options[];
 
 static char *afr_favorite_child_policies[AFR_FAV_CHILD_POLICY_MAX + 1] = {
-        [AFR_FAV_CHILD_NONE] = "none",
-        [AFR_FAV_CHILD_BY_SIZE] = "size",
-        [AFR_FAV_CHILD_BY_CTIME] = "ctime",
-        [AFR_FAV_CHILD_BY_MTIME] = "mtime",
-        [AFR_FAV_CHILD_BY_MAJORITY] = "majority",
-        [AFR_FAV_CHILD_POLICY_MAX] = NULL,
+    [AFR_FAV_CHILD_NONE] = "none",
+    [AFR_FAV_CHILD_BY_SIZE] = "size",
+    [AFR_FAV_CHILD_BY_CTIME] = "ctime",
+    [AFR_FAV_CHILD_BY_MTIME] = "mtime",
+    [AFR_FAV_CHILD_BY_MAJORITY] = "majority",
+    [AFR_FAV_CHILD_POLICY_MAX] = NULL,
 };
 
 int32_t
-notify (xlator_t *this, int32_t event,
-        void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        int ret = -1;
-        va_list         ap;
-        void *data2 = NULL;
+    int ret = -1;
+    va_list ap;
+    void *data2 = NULL;
 
-        va_start (ap, data);
-        data2 = va_arg (ap, dict_t*);
-        va_end (ap);
-        ret = afr_notify (this, event, data, data2);
+    va_start(ap, data);
+    data2 = va_arg(ap, dict_t *);
+    va_end(ap);
+    ret = afr_notify(this, event, data, data2);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
-
-        if (!this)
-                return ret;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_afr_mt_end + 1);
+    if (!this)
+        return ret;
 
-        if (ret != 0) {
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_afr_mt_end + 1);
 
+    if (ret != 0) {
         return ret;
-}
+    }
 
+    return ret;
+}
 
 int
-xlator_subvolume_index (xlator_t *this, xlator_t *subvol)
+xlator_subvolume_index(xlator_t *this, xlator_t *subvol)
 {
-        int index = -1;
-        int i = 0;
-        xlator_list_t *list = NULL;
-
-        list = this->children;
-
-        while (list) {
-                if (subvol == list->xlator ||
-                    strcmp (subvol->name, list->xlator->name) == 0) {
-                        index = i;
-                        break;
-                }
-                list = list->next;
-                i++;
+    int index = -1;
+    int i = 0;
+    xlator_list_t *list = NULL;
+
+    list = this->children;
+
+    while (list) {
+        if (subvol == list->xlator ||
+            strcmp(subvol->name, list->xlator->name) == 0) {
+            index = i;
+            break;
         }
+        list = list->next;
+        i++;
+    }
 
-        return index;
+    return index;
 }
 
 static void
-fix_quorum_options (xlator_t *this, afr_private_t *priv, char *qtype,
-                    dict_t *options)
+fix_quorum_options(xlator_t *this, afr_private_t *priv, char *qtype,
+                   dict_t *options)
 {
-
-        if (dict_get (options, "quorum-type") == NULL) {
-                /* If user doesn't configure anything enable auto-quorum if the
-                 * replica has more than two subvolumes */
-                if (priv->child_count > 2)
-                        qtype = "auto";
-        }
-
-        if (priv->quorum_count && strcmp (qtype, "fixed")) {
-                gf_msg (this->name,GF_LOG_WARNING, 0, AFR_MSG_QUORUM_OVERRIDE,
-                       "quorum-type %s overriding quorum-count %u",
-                       qtype, priv->quorum_count);
-        }
-
-        if (!strcmp (qtype, "none")) {
-                priv->quorum_count = 0;
-        } else if (!strcmp (qtype, "auto")) {
-                priv->quorum_count = AFR_QUORUM_AUTO;
-        }
-
+    if (dict_get_sizen(options, "quorum-type") == NULL) {
+        /* If user doesn't configure anything enable auto-quorum if the
+         * replica has more than two subvolumes */
+        if (priv->child_count > 2)
+            qtype = "auto";
+    }
+
+    if (priv->quorum_count && strcmp(qtype, "fixed")) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_OVERRIDE,
+               "quorum-type %s overriding quorum-count %u", qtype,
+               priv->quorum_count);
+    }
+
+    if (!strcmp(qtype, "none")) {
+        priv->quorum_count = 0;
+    } else if (!strcmp(qtype, "auto")) {
+        priv->quorum_count = AFR_QUORUM_AUTO;
+    }
 }
 
 int
-afr_set_favorite_child_policy (afr_private_t *priv, char *policy)
+afr_set_favorite_child_policy(afr_private_t *priv, char *policy)
 {
-        int index = -1;
+    int index = -1;
 
-        index = gf_get_index_by_elem (afr_favorite_child_policies, policy);
-        if (index  < 0 || index >= AFR_FAV_CHILD_POLICY_MAX)
-                return -1;
+    index = gf_get_index_by_elem(afr_favorite_child_policies, policy);
+    if (index < 0 || index >= AFR_FAV_CHILD_POLICY_MAX)
+        return -1;
 
-        priv->fav_child_policy = index;
+    priv->fav_child_policy = index;
 
-        return 0;
+    return 0;
 }
-int
-reconfigure (xlator_t *this, dict_t *options)
-{
-        afr_private_t *priv        = NULL;
-        xlator_t      *read_subvol = NULL;
-        int            read_subvol_index = -1;
-        int            ret         = -1;
-        int            index       = -1;
-        char          *qtype       = NULL;
-        char          *fav_child_policy = NULL;
-        gf_boolean_t   consistent_io = _gf_false;
-        gf_boolean_t   choose_local_old = _gf_false;
-
-        priv = this->private;
-
-	GF_OPTION_RECONF ("afr-dirty-xattr",
-			  priv->afr_dirty, options, str,
-			  out);
 
-	GF_OPTION_RECONF ("metadata-splitbrain-forced-heal",
-			  priv->metadata_splitbrain_forced_heal, options, bool,
-			  out);
-
-        GF_OPTION_RECONF ("background-self-heal-count",
-                          priv->background_self_heal_count, options, uint32,
-                          out);
+static void
+set_data_self_heal_algorithm(afr_private_t *priv, char *algo)
+{
+    if (!algo) {
+        priv->data_self_heal_algorithm = AFR_SELFHEAL_DATA_DYNAMIC;
+    } else if (strcmp(algo, "full") == 0) {
+        priv->data_self_heal_algorithm = AFR_SELFHEAL_DATA_FULL;
+    } else if (strcmp(algo, "diff") == 0) {
+        priv->data_self_heal_algorithm = AFR_SELFHEAL_DATA_DIFF;
+    } else {
+        priv->data_self_heal_algorithm = AFR_SELFHEAL_DATA_DYNAMIC;
+    }
+}
 
-        GF_OPTION_RECONF ("heal-wait-queue-length",
-                          priv->heal_wait_qlen, options, uint32, out);
+void
+afr_handle_anon_inode_options(afr_private_t *priv, dict_t *options)
+{
+    char *volfile_id_str = NULL;
+    uuid_t anon_inode_gfid = {0};
+
+    /*If volume id is not present don't enable anything*/
+    if (dict_get_str(options, "volume-id", &volfile_id_str))
+        return;
+    GF_ASSERT(strlen(AFR_ANON_DIR_PREFIX) + strlen(volfile_id_str) <= NAME_MAX);
+    /*anon_inode_name is not supposed to change once assigned*/
+    if (!priv->anon_inode_name[0]) {
+        snprintf(priv->anon_inode_name, sizeof(priv->anon_inode_name), "%s-%s",
+                 AFR_ANON_DIR_PREFIX, volfile_id_str);
+        gf_uuid_parse(volfile_id_str, anon_inode_gfid);
+        /*Flip a bit to make sure volfile-id and anon-gfid are not same*/
+        anon_inode_gfid[0] ^= 1;
+        uuid_utoa_r(anon_inode_gfid, priv->anon_gfid_str);
+    }
+}
 
+int
+reconfigure(xlator_t *this, dict_t *options)
+{
+    afr_private_t *priv = NULL;
+    xlator_t *read_subvol = NULL;
+    int read_subvol_index = -1;
+    int timeout_old = 0;
+    int ret = -1;
+    int index = -1;
+    char *qtype = NULL;
+    char *fav_child_policy = NULL;
+    char *data_self_heal = NULL;
+    char *data_self_heal_algorithm = NULL;
+    char *locking_scheme = NULL;
+    gf_boolean_t consistent_io = _gf_false;
+    gf_boolean_t choose_local_old = _gf_false;
+    gf_boolean_t enabled_old = _gf_false;
 
-        GF_OPTION_RECONF ("metadata-self-heal",
-                          priv->metadata_self_heal, options, bool, out);
+    priv = this->private;
 
-        GF_OPTION_RECONF ("data-self-heal", priv->data_self_heal, options, str,
-                          out);
+    GF_OPTION_RECONF("metadata-splitbrain-forced-heal",
+                     priv->metadata_splitbrain_forced_heal, options, bool, out);
 
-        GF_OPTION_RECONF ("entry-self-heal", priv->entry_self_heal, options,
-                          bool, out);
+    GF_OPTION_RECONF("background-self-heal-count",
+                     priv->background_self_heal_count, options, uint32, out);
 
-        GF_OPTION_RECONF ("data-self-heal-window-size",
-                          priv->data_self_heal_window_size, options,
-                          uint32, out);
+    GF_OPTION_RECONF("heal-wait-queue-length", priv->heal_wait_qlen, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("data-change-log", priv->data_change_log, options,
-                          bool, out);
+    GF_OPTION_RECONF("metadata-self-heal", priv->metadata_self_heal, options,
+                     bool, out);
 
-        GF_OPTION_RECONF ("metadata-change-log",
-                          priv->metadata_change_log, options, bool, out);
+    GF_OPTION_RECONF("data-self-heal", data_self_heal, options, str, out);
+    if (gf_string2boolean(data_self_heal, &priv->data_self_heal) == -1)
+        goto out;
 
-        GF_OPTION_RECONF ("entry-change-log", priv->entry_change_log, options,
-                          bool, out);
+    GF_OPTION_RECONF("entry-self-heal", priv->entry_self_heal, options, bool,
+                     out);
 
-        GF_OPTION_RECONF ("data-self-heal-algorithm",
-                          priv->data_self_heal_algorithm, options, str, out);
+    GF_OPTION_RECONF("data-self-heal-window-size",
+                     priv->data_self_heal_window_size, options, uint32, out);
 
-        GF_OPTION_RECONF ("halo-enabled",
-                          priv->halo_enabled, options, bool,
-                          out);
+    GF_OPTION_RECONF("data-self-heal-algorithm", data_self_heal_algorithm,
+                     options, str, out);
+    set_data_self_heal_algorithm(priv, data_self_heal_algorithm);
 
-        GF_OPTION_RECONF ("halo-shd-max-latency",
-                          priv->shd.halo_max_latency_msec, options, uint32,
-                          out);
+    GF_OPTION_RECONF("halo-enabled", priv->halo_enabled, options, bool, out);
 
-        GF_OPTION_RECONF ("halo-nfsd-max-latency",
-                          priv->nfsd.halo_max_latency_msec, options, uint32,
-                          out);
+    GF_OPTION_RECONF("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
+                     options, uint32, out);
 
-        GF_OPTION_RECONF ("halo-max-latency", priv->halo_max_latency_msec,
-                          options, uint32, out);
+    GF_OPTION_RECONF("halo-nfsd-max-latency", priv->nfsd.halo_max_latency_msec,
+                     options, uint32, out);
 
-        GF_OPTION_RECONF ("halo-max-replicas", priv->halo_max_replicas, options,
-                              uint32, out);
+    GF_OPTION_RECONF("halo-max-latency", priv->halo_max_latency_msec, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("halo-min-replicas", priv->halo_min_replicas, options,
-                              uint32, out);
+    GF_OPTION_RECONF("halo-max-replicas", priv->halo_max_replicas, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("read-subvolume", read_subvol, options, xlator, out);
+    GF_OPTION_RECONF("halo-min-replicas", priv->halo_min_replicas, options,
+                     uint32, out);
 
-        choose_local_old = priv->choose_local;
-        GF_OPTION_RECONF ("choose-local", priv->choose_local, options, bool,
-                          out);
+    GF_OPTION_RECONF("read-subvolume", read_subvol, options, xlator, out);
 
-        if (choose_local_old != priv->choose_local) {
-                priv->read_child = -1;
-                if (choose_local_old == _gf_false)
-                        priv->did_discovery = _gf_false;
-        }
+    choose_local_old = priv->choose_local;
+    GF_OPTION_RECONF("choose-local", priv->choose_local, options, bool, out);
 
-        GF_OPTION_RECONF ("read-hash-mode", priv->hash_mode,
-                          options, uint32, out);
-
-        if (read_subvol) {
-                index = xlator_subvolume_index (this, read_subvol);
-                if (index == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL, "%s not a subvolume",
-                                read_subvol->name);
-                        goto out;
-                }
-                priv->read_child = index;
+    if (choose_local_old != priv->choose_local) {
+        priv->read_child = -1;
+        if (choose_local_old == _gf_false)
+            priv->did_discovery = _gf_false;
+    }
+
+    GF_OPTION_RECONF("read-hash-mode", priv->hash_mode, options, uint32, out);
+
+    if (read_subvol) {
+        index = xlator_subvolume_index(this, read_subvol);
+        if (index == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%s not a subvolume", read_subvol->name);
+            goto out;
         }
-
-        GF_OPTION_RECONF ("read-subvolume-index",read_subvol_index, options,int32,out);
-
-        if (read_subvol_index >-1) {
-                index=read_subvol_index;
-                if (index >= priv->child_count) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL,
-                                "%d not a subvolume-index", index);
-                        goto out;
-                }
-                priv->read_child = index;
+        priv->read_child = index;
+    }
+
+    GF_OPTION_RECONF("read-subvolume-index", read_subvol_index, options, int32,
+                     out);
+
+    if (read_subvol_index > -1) {
+        index = read_subvol_index;
+        if (index >= priv->child_count) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%d not a subvolume-index", index);
+            goto out;
         }
-
-        GF_OPTION_RECONF ("pre-op-compat", priv->pre_op_compat, options, bool,
-                          out);
-        GF_OPTION_RECONF ("locking-scheme", priv->locking_scheme, options, str,
-                          out);
-        GF_OPTION_RECONF ("use-compound-fops", priv->use_compound_fops,
-                          options, bool,
-                          out);
-        GF_OPTION_RECONF ("granular-entry-heal", priv->esh_granular, options,
-                          bool, out);
-
-        GF_OPTION_RECONF ("eager-lock", priv->eager_lock, options, bool, out);
-        GF_OPTION_RECONF ("quorum-type", qtype, options, str, out);
-        GF_OPTION_RECONF ("quorum-count", priv->quorum_count, options,
-                          uint32, out);
-        fix_quorum_options (this, priv, qtype, options);
-        if (priv->quorum_count && !afr_has_quorum (priv->child_up, this))
-                gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
-                        "Client-quorum is not met");
-
-
-	GF_OPTION_RECONF ("post-op-delay-secs", priv->post_op_delay_secs, options,
-			  uint32, out);
-
-        GF_OPTION_RECONF (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size,
-                          options, size_uint64, out);
-        /* Reset this so we re-discover in case the topology changed.  */
-        GF_OPTION_RECONF ("ensure-durability", priv->ensure_durability, options,
-                          bool, out);
-
-	GF_OPTION_RECONF ("self-heal-daemon", priv->shd.enabled, options,
-			  bool, out);
-
-	GF_OPTION_RECONF ("iam-self-heal-daemon", priv->shd.iamshd, options,
-			  bool, out);
-
-        GF_OPTION_RECONF ("heal-timeout", priv->shd.timeout, options,
-                          int32, out);
-
-        GF_OPTION_RECONF ("quorum-reads", priv->quorum_reads, options,
-                          bool, out);
-        GF_OPTION_RECONF ("consistent-metadata", priv->consistent_metadata,
-                          options, bool, out);
-
-        GF_OPTION_RECONF ("shd-max-threads", priv->shd.max_threads,
-                          options, uint32, out);
-
-        GF_OPTION_RECONF ("shd-wait-qlength", priv->shd.wait_qlength,
-                          options, uint32, out);
-
-        GF_OPTION_RECONF ("favorite-child-policy", fav_child_policy, options,
-                          str, out);
-        if (afr_set_favorite_child_policy (priv, fav_child_policy) == -1)
-                goto out;
-
-        priv->did_discovery = _gf_false;
-
-        GF_OPTION_RECONF ("consistent-io", consistent_io, options, bool, out);
-        if (priv->quorum_count != 0)
-                consistent_io = _gf_false;
-        priv->consistent_io = consistent_io;
-
-        ret = 0;
+        priv->read_child = index;
+    }
+
+    GF_OPTION_RECONF("pre-op-compat", priv->pre_op_compat, options, bool, out);
+    GF_OPTION_RECONF("locking-scheme", locking_scheme, options, str, out);
+    priv->granular_locks = (strcmp(locking_scheme, "granular") == 0);
+    GF_OPTION_RECONF("full-lock", priv->full_lock, options, bool, out);
+    GF_OPTION_RECONF("granular-entry-heal", priv->esh_granular, options, bool,
+                     out);
+
+    GF_OPTION_RECONF("eager-lock", priv->eager_lock, options, bool, out);
+    GF_OPTION_RECONF("optimistic-change-log", priv->optimistic_change_log,
+                     options, bool, out);
+    GF_OPTION_RECONF("quorum-type", qtype, options, str, out);
+    GF_OPTION_RECONF("quorum-count", priv->quorum_count, options, uint32, out);
+    fix_quorum_options(this, priv, qtype, options);
+    if (priv->quorum_count && !afr_has_quorum(priv->child_up, this, NULL))
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
+               "Client-quorum is not met");
+
+    GF_OPTION_RECONF("post-op-delay-secs", priv->post_op_delay_secs, options,
+                     uint32, out);
+
+    GF_OPTION_RECONF(AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, options,
+                     size_uint64, out);
+    /* Reset this so we re-discover in case the topology changed.  */
+    GF_OPTION_RECONF("ensure-durability", priv->ensure_durability, options,
+                     bool, out);
+
+    enabled_old = priv->shd.enabled;
+    GF_OPTION_RECONF("self-heal-daemon", priv->shd.enabled, options, bool, out);
+
+    GF_OPTION_RECONF("iam-self-heal-daemon", priv->shd.iamshd, options, bool,
+                     out);
+
+    timeout_old = priv->shd.timeout;
+    GF_OPTION_RECONF("heal-timeout", priv->shd.timeout, options, int32, out);
+
+    GF_OPTION_RECONF("consistent-metadata", priv->consistent_metadata, options,
+                     bool, out);
+
+    GF_OPTION_RECONF("shd-max-threads", priv->shd.max_threads, options, uint32,
+                     out);
+
+    GF_OPTION_RECONF("shd-wait-qlength", priv->shd.wait_qlength, options,
+                     uint32, out);
+
+    GF_OPTION_RECONF("favorite-child-policy", fav_child_policy, options, str,
+                     out);
+    if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
+        goto out;
+
+    priv->did_discovery = _gf_false;
+
+    GF_OPTION_RECONF("consistent-io", consistent_io, options, bool, out);
+    if (priv->quorum_count != 0)
+        consistent_io = _gf_false;
+    priv->consistent_io = consistent_io;
+
+    afr_handle_anon_inode_options(priv, options);
+
+    GF_OPTION_RECONF("use-anonymous-inode", priv->use_anon_inode, options, bool,
+                     out);
+    if (priv->shd.enabled) {
+        if ((priv->shd.enabled != enabled_old) ||
+            (timeout_old != priv->shd.timeout))
+            afr_selfheal_childup(this, priv);
+    }
+
+    ret = 0;
 out:
-        return ret;
-
+    return ret;
 }
 
-
-static const char *favorite_child_warning_str = "You have specified subvolume '%s' "
-        "as the 'favorite child'. This means that if a discrepancy in the content "
-        "or attributes (ownership, permission, etc.) of a file is detected among "
-        "the subvolumes, the file on '%s' will be considered the definitive "
-        "version and its contents will OVERWRITE the contents of the file on other "
-        "subvolumes. All versions of the file except that on '%s' "
-        "WILL BE LOST.";
-
-
 static int
-afr_pending_xattrs_init (afr_private_t *priv, xlator_t *this)
+afr_pending_xattrs_init(afr_private_t *priv, xlator_t *this)
 {
-        int ret = -1;
-        int i = 0;
-        char *ptr = NULL;
-        char *ptr1 = NULL;
-        char *xattrs_list = NULL;
-        xlator_list_t *trav = NULL;
-
-        trav = this->children;
-
-        GF_OPTION_INIT ("afr-pending-xattr", xattrs_list, str, out);
-        priv->pending_key = GF_CALLOC (sizeof (*priv->pending_key),
-                                       priv->child_count, gf_afr_mt_char);
-        if (!priv->pending_key) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        if (!xattrs_list) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_NO_CHANGELOG,
-                        "Unable to fetch afr-pending-xattr option from volfile."
-                        " Falling back to using client translator names. ");
-
-                while (i < priv->child_count) {
-                        ret = gf_asprintf (&priv->pending_key[i], "%s.%s",
-                                           AFR_XATTR_PREFIX,
-                                           trav->xlator->name);
-                        if (ret == -1) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                        trav = trav->next;
-                        i++;
-                }
-                ret = 0;
-                goto out;
-        }
+    int ret = -1;
+    int i = 0;
+    char *ptr = NULL;
+    char *ptr1 = NULL;
+    char *xattrs_list = NULL;
+    xlator_list_t *trav = NULL;
+    int child_count = -1;
+
+    trav = this->children;
+    child_count = priv->child_count;
+    if (priv->thin_arbiter_count) {
+        /* priv->pending_key[THIN_ARBITER_BRICK_INDEX] is used as the
+         * name of the thin arbiter file for persistence across add/
+         * removal of DHT subvols.*/
+        child_count++;
+    }
+
+    GF_OPTION_INIT("afr-pending-xattr", xattrs_list, str, out);
+    priv->pending_key = GF_CALLOC(sizeof(*priv->pending_key), child_count,
+                                  gf_afr_mt_char);
+    if (!priv->pending_key) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    if (!xattrs_list) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_NO_CHANGELOG,
+               "Unable to fetch afr-pending-xattr option from volfile."
+               " Falling back to using client translator names. ");
 
-        ptr = ptr1 = gf_strdup (xattrs_list);
-        if (!ptr) {
+        while (i < child_count) {
+            ret = gf_asprintf(&priv->pending_key[i], "%s.%s", AFR_XATTR_PREFIX,
+                              trav->xlator->name);
+            if (ret == -1) {
                 ret = -ENOMEM;
                 goto out;
-        }
-        for (i = 0, ptr = strtok (ptr, ","); ptr; ptr = strtok (NULL, ",")) {
-                ret = gf_asprintf (&priv->pending_key[i], "%s.%s",
-                                   AFR_XATTR_PREFIX, ptr);
-                if (ret == -1) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
-                i++;
+            }
+            trav = trav->next;
+            i++;
         }
         ret = 0;
+        goto out;
+    }
+
+    ptr = ptr1 = gf_strdup(xattrs_list);
+    if (!ptr) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    for (i = 0, ptr = strtok(ptr, ","); ptr; ptr = strtok(NULL, ",")) {
+        ret = gf_asprintf(&priv->pending_key[i], "%s.%s", AFR_XATTR_PREFIX,
+                          ptr);
+        if (ret == -1) {
+            ret = -ENOMEM;
+            goto out;
+        }
+        i++;
+    }
+    ret = 0;
 
 out:
-        GF_FREE (ptr1);
-        return ret;
+    GF_FREE(ptr1);
+    return ret;
+}
 
+void
+afr_ta_init(afr_private_t *priv)
+{
+    priv->thin_arbiter_count = 1;
+    priv->child_count--;
+    priv->ta_child_up = 0;
+    priv->ta_bad_child_index = AFR_CHILD_UNKNOWN;
+    priv->ta_notify_dom_lock_offset = 0;
+    priv->ta_in_mem_txn_count = 0;
+    priv->ta_on_wire_txn_count = 0;
+    priv->release_ta_notify_dom_lock = _gf_false;
+    INIT_LIST_HEAD(&priv->ta_waitq);
+    INIT_LIST_HEAD(&priv->ta_onwireq);
+    gf_uuid_clear(priv->ta_gfid);
 }
 
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        afr_private_t *priv        = NULL;
-        int            child_count = 0;
-        xlator_list_t *trav        = NULL;
-        int            i           = 0;
-        int            ret         = -1;
-        GF_UNUSED int  op_errno    = 0;
-        xlator_t      *read_subvol = NULL;
-        int            read_subvol_index = -1;
-        xlator_t      *fav_child   = NULL;
-        char          *qtype       = NULL;
-        char          *fav_child_policy = NULL;
-
-        if (!this->children) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_CHILD_MISCONFIGURED,
-                        "replicate translator needs more than one "
-                        "subvolume defined.");
-                return -1;
+    afr_private_t *priv = NULL;
+    int child_count = 0;
+    xlator_list_t *trav = NULL;
+    int i = 0;
+    int ret = -1;
+    GF_UNUSED int op_errno = 0;
+    xlator_t *read_subvol = NULL;
+    int read_subvol_index = -1;
+    char *qtype = NULL;
+    char *fav_child_policy = NULL;
+    char *thin_arbiter = NULL;
+    char *data_self_heal = NULL;
+    char *locking_scheme = NULL;
+    char *data_self_heal_algorithm = NULL;
+
+    if (!this->children) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_CHILD_MISCONFIGURED,
+               "replicate translator needs more than one "
+               "subvolume defined.");
+        return -1;
+    }
+
+    if (!this->parents) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_VOL_MISCONFIGURED,
+               "Volume is dangling.");
+    }
+
+    this->private = GF_CALLOC(1, sizeof(afr_private_t),
+                              gf_afr_mt_afr_private_t);
+    if (!this->private)
+        goto out;
+
+    priv = this->private;
+    INIT_LIST_HEAD(&priv->saved_locks);
+    INIT_LIST_HEAD(&priv->lk_healq);
+    LOCK_INIT(&priv->lock);
+
+    child_count = xlator_subvolume_count(this);
+
+    priv->child_count = child_count;
+
+    priv->read_child = -1;
+
+    GF_OPTION_INIT("arbiter-count", priv->arbiter_count, uint32, out);
+    GF_OPTION_INIT("thin-arbiter", thin_arbiter, str, out);
+    if (thin_arbiter && strlen(thin_arbiter) > 0) {
+        afr_ta_init(priv);
+    }
+    INIT_LIST_HEAD(&priv->healing);
+    INIT_LIST_HEAD(&priv->heal_waiting);
+
+    priv->spb_choice_timeout = AFR_DEFAULT_SPB_CHOICE_TIMEOUT;
+
+    GF_OPTION_INIT("afr-dirty-xattr", priv->afr_dirty, str, out);
+
+    GF_OPTION_INIT("metadata-splitbrain-forced-heal",
+                   priv->metadata_splitbrain_forced_heal, bool, out);
+
+    GF_OPTION_INIT("read-subvolume", read_subvol, xlator, out);
+    if (read_subvol) {
+        priv->read_child = xlator_subvolume_index(this, read_subvol);
+        if (priv->read_child == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%s not a subvolume", read_subvol->name);
+            goto out;
         }
-
-        if (!this->parents) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_VOL_MISCONFIGURED, "Volume is dangling.");
+    }
+    GF_OPTION_INIT("read-subvolume-index", read_subvol_index, int32, out);
+    if (read_subvol_index > -1) {
+        if (read_subvol_index >= priv->child_count) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%d not a subvolume-index", read_subvol_index);
+            goto out;
         }
+        priv->read_child = read_subvol_index;
+    }
+    GF_OPTION_INIT("choose-local", priv->choose_local, bool, out);
 
-	this->private = GF_CALLOC (1, sizeof (afr_private_t),
-                                   gf_afr_mt_afr_private_t);
-        if (!this->private)
-                goto out;
+    priv->pending_reads = GF_CALLOC(sizeof(*priv->pending_reads),
+                                    priv->child_count, gf_afr_mt_atomic_t);
 
-        priv = this->private;
-        LOCK_INIT (&priv->lock);
+    GF_OPTION_INIT("read-hash-mode", priv->hash_mode, uint32, out);
 
-        child_count = xlator_subvolume_count (this);
+    priv->favorite_child = -1;
 
-        priv->child_count = child_count;
+    GF_OPTION_INIT("favorite-child-policy", fav_child_policy, str, out);
+    if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
+        goto out;
 
-        priv->read_child = -1;
+    GF_OPTION_INIT("shd-max-threads", priv->shd.max_threads, uint32, out);
 
-        GF_OPTION_INIT ("arbiter-count", priv->arbiter_count, uint32, out);
-        INIT_LIST_HEAD (&priv->healing);
-        INIT_LIST_HEAD (&priv->heal_waiting);
+    GF_OPTION_INIT("shd-wait-qlength", priv->shd.wait_qlength, uint32, out);
 
-        priv->spb_choice_timeout = AFR_DEFAULT_SPB_CHOICE_TIMEOUT;
+    GF_OPTION_INIT("background-self-heal-count",
+                   priv->background_self_heal_count, uint32, out);
 
-	GF_OPTION_INIT ("afr-dirty-xattr", priv->afr_dirty, str, out);
+    GF_OPTION_INIT("heal-wait-queue-length", priv->heal_wait_qlen, uint32, out);
 
-	GF_OPTION_INIT ("metadata-splitbrain-forced-heal",
-			priv->metadata_splitbrain_forced_heal, bool, out);
+    GF_OPTION_INIT("data-self-heal", data_self_heal, str, out);
+    if (gf_string2boolean(data_self_heal, &priv->data_self_heal) == -1)
+        goto out;
 
-        GF_OPTION_INIT ("read-subvolume", read_subvol, xlator, out);
-        if (read_subvol) {
-                priv->read_child = xlator_subvolume_index (this, read_subvol);
-                if (priv->read_child == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL, "%s not a subvolume",
-                                read_subvol->name);
-                        goto out;
-                }
-        }
-        GF_OPTION_INIT ("read-subvolume-index",read_subvol_index,int32,out);
-        if (read_subvol_index > -1) {
-                if (read_subvol_index >= priv->child_count) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL,
-                                "%d not a subvolume-index", read_subvol_index);
-                        goto out;
-                }
-                priv->read_child = read_subvol_index;
-        }
-        GF_OPTION_INIT ("choose-local", priv->choose_local, bool, out);
-
-        GF_OPTION_INIT ("read-hash-mode", priv->hash_mode, uint32, out);
-
-        priv->favorite_child = -1;
-        GF_OPTION_INIT ("favorite-child", fav_child, xlator, out);
-        if (fav_child) {
-                priv->favorite_child = xlator_subvolume_index (this, fav_child);
-                if (priv->favorite_child == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL, "%s not a subvolume, "
-                                "cannot set it as favorite child",
-                                fav_child->name);
-                        goto out;
-                }
-                gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_FAVORITE_CHILD,
-                        favorite_child_warning_str, fav_child->name,
-                        fav_child->name, fav_child->name);
-        }
+    GF_OPTION_INIT("data-self-heal-algorithm", data_self_heal_algorithm, str,
+                   out);
+    set_data_self_heal_algorithm(priv, data_self_heal_algorithm);
 
-        GF_OPTION_INIT ("favorite-child-policy", fav_child_policy, str, out);
-        if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
-                goto out;
-
-        GF_OPTION_INIT ("shd-max-threads", priv->shd.max_threads,
-                         uint32, out);
-
-        GF_OPTION_INIT ("shd-wait-qlength", priv->shd.wait_qlength,
-                         uint32, out);
-
-        GF_OPTION_INIT ("background-self-heal-count",
-                        priv->background_self_heal_count, uint32, out);
-
-        GF_OPTION_INIT ("heal-wait-queue-length",
-                        priv->heal_wait_qlen, uint32, out);
-
-        GF_OPTION_INIT ("data-self-heal", priv->data_self_heal, str, out);
-
-        GF_OPTION_INIT ("data-self-heal-algorithm",
-                        priv->data_self_heal_algorithm, str, out);
-
-        GF_OPTION_INIT ("data-self-heal-window-size",
-                        priv->data_self_heal_window_size, uint32, out);
+    GF_OPTION_INIT("data-self-heal-window-size",
+                   priv->data_self_heal_window_size, uint32, out);
 
-        GF_OPTION_INIT ("metadata-self-heal", priv->metadata_self_heal, bool,
-                        out);
+    GF_OPTION_INIT("metadata-self-heal", priv->metadata_self_heal, bool, out);
 
-        GF_OPTION_INIT ("entry-self-heal", priv->entry_self_heal, bool, out);
+    GF_OPTION_INIT("entry-self-heal", priv->entry_self_heal, bool, out);
 
-        GF_OPTION_INIT ("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
-                        uint32, out);
+    GF_OPTION_INIT("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
+                   uint32, out);
 
-        GF_OPTION_INIT ("halo-max-latency", priv->halo_max_latency_msec,
-                        uint32, out);
-        GF_OPTION_INIT ("halo-max-replicas", priv->halo_max_replicas, uint32,
-                        out);
-        GF_OPTION_INIT ("halo-min-replicas", priv->halo_min_replicas, uint32,
-                        out);
+    GF_OPTION_INIT("halo-max-latency", priv->halo_max_latency_msec, uint32,
+                   out);
+    GF_OPTION_INIT("halo-max-replicas", priv->halo_max_replicas, uint32, out);
+    GF_OPTION_INIT("halo-min-replicas", priv->halo_min_replicas, uint32, out);
 
-        GF_OPTION_INIT ("halo-enabled",
-                        priv->halo_enabled, bool, out);
+    GF_OPTION_INIT("halo-enabled", priv->halo_enabled, bool, out);
 
-        GF_OPTION_INIT ("halo-nfsd-max-latency",
-                        priv->nfsd.halo_max_latency_msec, uint32, out);
+    GF_OPTION_INIT("halo-nfsd-max-latency", priv->nfsd.halo_max_latency_msec,
+                   uint32, out);
 
-        GF_OPTION_INIT ("iam-nfs-daemon", priv->nfsd.iamnfsd, bool, out);
+    GF_OPTION_INIT("iam-nfs-daemon", priv->nfsd.iamnfsd, bool, out);
 
-        GF_OPTION_INIT ("data-change-log", priv->data_change_log, bool, out);
+    GF_OPTION_INIT("optimistic-change-log", priv->optimistic_change_log, bool,
+                   out);
 
-        GF_OPTION_INIT ("metadata-change-log", priv->metadata_change_log, bool,
-                        out);
+    GF_OPTION_INIT("pre-op-compat", priv->pre_op_compat, bool, out);
+    GF_OPTION_INIT("locking-scheme", locking_scheme, str, out);
+    priv->granular_locks = (strcmp(locking_scheme, "granular") == 0);
+    GF_OPTION_INIT("full-lock", priv->full_lock, bool, out);
+    GF_OPTION_INIT("granular-entry-heal", priv->esh_granular, bool, out);
 
-        GF_OPTION_INIT ("entry-change-log", priv->entry_change_log, bool, out);
+    GF_OPTION_INIT("eager-lock", priv->eager_lock, bool, out);
+    GF_OPTION_INIT("quorum-type", qtype, str, out);
+    GF_OPTION_INIT("quorum-count", priv->quorum_count, uint32, out);
+    GF_OPTION_INIT(AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size_uint64,
+                   out);
+    fix_quorum_options(this, priv, qtype, this->options);
 
-        GF_OPTION_INIT ("optimistic-change-log", priv->optimistic_change_log,
-                        bool, out);
+    GF_OPTION_INIT("post-op-delay-secs", priv->post_op_delay_secs, uint32, out);
+    GF_OPTION_INIT("ensure-durability", priv->ensure_durability, bool, out);
 
-        GF_OPTION_INIT ("inodelk-trace", priv->inodelk_trace, bool, out);
+    GF_OPTION_INIT("self-heal-daemon", priv->shd.enabled, bool, out);
 
-        GF_OPTION_INIT ("entrylk-trace", priv->entrylk_trace, bool, out);
+    GF_OPTION_INIT("iam-self-heal-daemon", priv->shd.iamshd, bool, out);
+    GF_OPTION_INIT("heal-timeout", priv->shd.timeout, int32, out);
 
-        GF_OPTION_INIT ("pre-op-compat", priv->pre_op_compat, bool, out);
-        GF_OPTION_INIT ("locking-scheme", priv->locking_scheme, str, out);
-        GF_OPTION_INIT ("use-compound-fops", priv->use_compound_fops,
-                        bool, out);
-        GF_OPTION_INIT ("granular-entry-heal", priv->esh_granular, bool, out);
+    GF_OPTION_INIT("consistent-metadata", priv->consistent_metadata, bool, out);
+    GF_OPTION_INIT("consistent-io", priv->consistent_io, bool, out);
+    afr_handle_anon_inode_options(priv, this->options);
 
-        GF_OPTION_INIT ("eager-lock", priv->eager_lock, bool, out);
-        GF_OPTION_INIT ("quorum-type", qtype, str, out);
-        GF_OPTION_INIT ("quorum-count", priv->quorum_count, uint32, out);
-        GF_OPTION_INIT (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size_uint64,
-                        out);
-        fix_quorum_options (this, priv, qtype, this->options);
+    GF_OPTION_INIT("use-anonymous-inode", priv->use_anon_inode, bool, out);
+    if (priv->quorum_count != 0)
+        priv->consistent_io = _gf_false;
 
-	GF_OPTION_INIT ("post-op-delay-secs", priv->post_op_delay_secs, uint32, out);
-        GF_OPTION_INIT ("ensure-durability", priv->ensure_durability, bool,
-                        out);
+    priv->wait_count = 1;
 
-	GF_OPTION_INIT ("self-heal-daemon", priv->shd.enabled, bool, out);
+    priv->local = GF_CALLOC(sizeof(unsigned char), child_count, gf_afr_mt_char);
+    if (!priv->local) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-	GF_OPTION_INIT ("iam-self-heal-daemon", priv->shd.iamshd, bool, out);
-        GF_OPTION_INIT ("heal-timeout", priv->shd.timeout, int32, out);
-
-        GF_OPTION_INIT ("quorum-reads", priv->quorum_reads, bool, out);
-        GF_OPTION_INIT ("consistent-metadata", priv->consistent_metadata, bool,
-                        out);
-        GF_OPTION_INIT ("consistent-io", priv->consistent_io, bool, out);
-
-        if (priv->quorum_count != 0)
-                priv->consistent_io = _gf_false;
-
-        priv->wait_count = 1;
-
-        priv->local = GF_CALLOC (sizeof (unsigned char), child_count,
+    priv->anon_inode = GF_CALLOC(sizeof(unsigned char), child_count,
                                  gf_afr_mt_char);
-        if (!priv->local) {
-                ret = -ENOMEM;
-                goto out;
-        }
 
-        priv->child_up = GF_CALLOC (sizeof (unsigned char), child_count,
-                                    gf_afr_mt_char);
-
-        priv->child_latency = GF_CALLOC (sizeof (*priv->child_latency),
-                                         child_count,
-                                         gf_afr_mt_child_latency_t);
+    priv->child_up = GF_CALLOC(sizeof(unsigned char), child_count,
+                               gf_afr_mt_char);
 
-        if (!priv->child_up || !priv->child_latency) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        for (i = 0; i < child_count; i++)
-                priv->child_up[i] = -1; /* start with unknown state.
-                                           this initialization needed
-                                           for afr_notify() to work
-                                           reliably
-                                        */
+    priv->child_latency = GF_MALLOC(sizeof(*priv->child_latency) * child_count,
+                                    gf_afr_mt_child_latency_t);
+    priv->halo_child_up = GF_CALLOC(sizeof(unsigned char), child_count,
+                                    gf_afr_mt_char);
 
-        priv->children = GF_CALLOC (sizeof (xlator_t *), child_count,
-                                    gf_afr_mt_xlator_t);
-        if (!priv->children) {
-                ret = -ENOMEM;
-                goto out;
+    if (!priv->child_up || !priv->child_latency || !priv->halo_child_up ||
+        !priv->anon_inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    /*Initialize to -ve ping timeout so that they are not considered
+     * in child-up events until ping-event comes*/
+    for (i = 0; i < child_count; i++)
+        priv->child_latency[i] = -1;
+
+    priv->children = GF_CALLOC(sizeof(xlator_t *), child_count,
+                               gf_afr_mt_xlator_t);
+    if (!priv->children) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = afr_pending_xattrs_init(priv, this);
+    if (ret)
+        goto out;
+
+    trav = this->children;
+    i = 0;
+    while (i < child_count) {
+        priv->children[i] = trav->xlator;
+        trav = trav->next;
+        i++;
+    }
+
+    ret = gf_asprintf(&priv->sh_domain, AFR_SH_DATA_DOMAIN_FMT, this->name);
+    if (-1 == ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    priv->last_event = GF_CALLOC(child_count, sizeof(*priv->last_event),
+                                 gf_afr_mt_int32_t);
+    if (!priv->last_event) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    this->itable = inode_table_new(SHD_INODE_LRU_LIMIT, this);
+    if (!this->itable) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    if (priv->shd.iamshd) {
+        ret = afr_selfheal_daemon_init(this);
+        if (ret) {
+            ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        ret = afr_pending_xattrs_init (priv, this);
-        if (ret)
-                goto out;
+    /* keep more local here as we may need them for self-heal etc */
+    this->local_pool = mem_pool_new(afr_local_t, 512);
+    if (!this->local_pool) {
+        ret = -1;
+        goto out;
+    }
 
-        trav = this->children;
-        i = 0;
-        while (i < child_count) {
-                priv->children[i] = trav->xlator;
-                trav = trav->next;
-                i++;
-        }
+    priv->root_inode = NULL;
 
-        ret = gf_asprintf (&priv->sh_domain, AFR_SH_DATA_DOMAIN_FMT,
-                           this->name);
-        if (-1 == ret) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    ret = 0;
+out:
+    return ret;
+}
+void
+afr_destroy_healer_object(xlator_t *this, struct subvol_healer *healer)
+{
+    int ret = -1;
 
-        priv->last_event = GF_CALLOC (child_count, sizeof (*priv->last_event),
-                                      gf_afr_mt_int32_t);
-        if (!priv->last_event) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    if (!healer)
+        return;
 
-	ret = afr_selfheal_daemon_init (this);
-	if (ret) {
-		ret = -ENOMEM;
-		goto out;
-	}
+    if (healer->running) {
+        /*
+         * If there are any resources to cleanup, We need
+         * to do that gracefully using pthread_cleanup_push
+         */
+        ret = gf_thread_cleanup_xint(healer->thread);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SELF_HEAL_FAILED,
+                   "Failed to clean up healer threads.");
+        healer->thread = 0;
+    }
+    pthread_cond_destroy(&healer->cond);
+    pthread_mutex_destroy(&healer->mutex);
+}
 
-        /* keep more local here as we may need them for self-heal etc */
-        this->local_pool = mem_pool_new (afr_local_t, 512);
-        if (!this->local_pool) {
-                ret = -1;
-                goto out;
-        }
+void
+afr_selfheal_daemon_fini(xlator_t *this)
+{
+    struct subvol_healer *healer = NULL;
+    afr_self_heald_t *shd = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    priv = this->private;
+    if (!priv)
+        return;
+
+    shd = &priv->shd;
+    if (!shd->iamshd)
+        return;
+
+    for (i = 0; i < priv->child_count; i++) {
+        healer = &shd->index_healers[i];
+        afr_destroy_healer_object(this, healer);
+
+        healer = &shd->full_healers[i];
+        afr_destroy_healer_object(this, healer);
+
+        if (shd->statistics[i])
+            eh_destroy(shd->statistics[i]);
+    }
+    GF_FREE(shd->index_healers);
+    GF_FREE(shd->full_healers);
+    GF_FREE(shd->statistics);
+    if (shd->split_brain)
+        eh_destroy(shd->split_brain);
+}
+void
+fini(xlator_t *this)
+{
+    afr_private_t *priv = NULL;
 
-        priv->root_inode = NULL;
+    priv = this->private;
 
-        ret = 0;
-out:
-        return ret;
-}
+    afr_selfheal_daemon_fini(this);
+    GF_ASSERT(list_empty(&priv->saved_locks));
 
+    LOCK(&priv->lock);
+    if (priv->timer != NULL) {
+        gf_timer_call_cancel(this->ctx, priv->timer);
+        priv->timer = NULL;
+    }
+    UNLOCK(&priv->lock);
 
-int
-fini (xlator_t *this)
-{
-        afr_private_t *priv = NULL;
+    if (this->local_pool != NULL) {
+        mem_pool_destroy(this->local_pool);
+        this->local_pool = NULL;
+    }
 
-        priv = this->private;
-        LOCK (&priv->lock);
-        if (priv->timer != NULL) {
-                gf_timer_call_cancel(this->ctx, priv->timer);
-                priv->timer = NULL;
-        }
-        UNLOCK (&priv->lock);
-        this->private = NULL;
-        afr_priv_destroy (priv);
-        //if (this->itable);//I dont see any destroy func
+    this->private = NULL;
+    afr_priv_destroy(priv);
+    if (this->itable) {
+        inode_table_destroy(this->itable);
+        this->itable = NULL;
+    }
 
-        return 0;
+    return;
 }
 
-
 struct xlator_fops fops = {
-        .lookup      = afr_lookup,
-        .lk          = afr_lk,
-        .flush       = afr_flush,
-        .statfs      = afr_statfs,
-        .fsync       = afr_fsync,
-        .fsyncdir    = afr_fsyncdir,
-        .inodelk     = afr_inodelk,
-        .finodelk    = afr_finodelk,
-        .entrylk     = afr_entrylk,
-        .fentrylk    = afr_fentrylk,
-        .ipc         = afr_ipc,
-
-        /* inode read */
-        .access      = afr_access,
-        .stat        = afr_stat,
-        .fstat       = afr_fstat,
-        .readlink    = afr_readlink,
-        .getxattr    = afr_getxattr,
-        .fgetxattr   = afr_fgetxattr,
-        .readv       = afr_readv,
-
-        /* inode write */
-        .writev      = afr_writev,
-        .truncate    = afr_truncate,
-        .ftruncate   = afr_ftruncate,
-        .setxattr    = afr_setxattr,
-        .fsetxattr   = afr_fsetxattr,
-        .setattr     = afr_setattr,
-        .fsetattr    = afr_fsetattr,
-        .removexattr = afr_removexattr,
-        .fremovexattr = afr_fremovexattr,
-        .fallocate   = afr_fallocate,
-        .discard     = afr_discard,
-        .zerofill    = afr_zerofill,
-        .xattrop     = afr_xattrop,
-        .fxattrop    = afr_fxattrop,
-
-        /*inode open*/
-        .opendir     = afr_opendir,
-        .open        = afr_open,
-
-        /* dir read */
-        .readdir     = afr_readdir,
-        .readdirp    = afr_readdirp,
-
-        /* dir write */
-        .create      = afr_create,
-        .mknod       = afr_mknod,
-        .mkdir       = afr_mkdir,
-        .unlink      = afr_unlink,
-        .rmdir       = afr_rmdir,
-        .link        = afr_link,
-        .symlink     = afr_symlink,
-        .rename      = afr_rename,
+    .lookup = afr_lookup,
+    .lk = afr_lk,
+    .flush = afr_flush,
+    .statfs = afr_statfs,
+    .fsyncdir = afr_fsyncdir,
+    .inodelk = afr_inodelk,
+    .finodelk = afr_finodelk,
+    .entrylk = afr_entrylk,
+    .fentrylk = afr_fentrylk,
+    .ipc = afr_ipc,
+    .lease = afr_lease,
+
+    /* inode read */
+    .access = afr_access,
+    .stat = afr_stat,
+    .fstat = afr_fstat,
+    .readlink = afr_readlink,
+    .getxattr = afr_getxattr,
+    .fgetxattr = afr_fgetxattr,
+    .readv = afr_readv,
+    .seek = afr_seek,
+
+    /* inode write */
+    .writev = afr_writev,
+    .truncate = afr_truncate,
+    .ftruncate = afr_ftruncate,
+    .setxattr = afr_setxattr,
+    .fsetxattr = afr_fsetxattr,
+    .setattr = afr_setattr,
+    .fsetattr = afr_fsetattr,
+    .removexattr = afr_removexattr,
+    .fremovexattr = afr_fremovexattr,
+    .fallocate = afr_fallocate,
+    .discard = afr_discard,
+    .zerofill = afr_zerofill,
+    .xattrop = afr_xattrop,
+    .fxattrop = afr_fxattrop,
+    .fsync = afr_fsync,
+
+    /*inode open*/
+    .opendir = afr_opendir,
+    .open = afr_open,
+
+    /* dir read */
+    .readdir = afr_readdir,
+    .readdirp = afr_readdirp,
+
+    /* dir write */
+    .create = afr_create,
+    .mknod = afr_mknod,
+    .mkdir = afr_mkdir,
+    .unlink = afr_unlink,
+    .rmdir = afr_rmdir,
+    .link = afr_link,
+    .symlink = afr_symlink,
+    .rename = afr_rename,
 };
 
-
 struct xlator_dumpops dumpops = {
-        .priv       = afr_priv_dump,
+    .priv = afr_priv_dump,
 };
 
-
 struct xlator_cbks cbks = {
-        .release     = afr_release,
-        .releasedir  = afr_releasedir,
-        .forget      = afr_forget,
+    .release = afr_release,
+    .releasedir = afr_releasedir,
+    .forget = afr_forget,
 };
 
-
 struct volume_options options[] = {
-        { .key  = {"read-subvolume" },
-          .type = GF_OPTION_TYPE_XLATOR,
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. Afr will prefer the one specified using "
-                         "this option if it is not stale. Option value must be "
-                         "one of the xlator names of the children. "
-                         "Ex: <volname>-client-0 till "
-                         "<volname>-client-<number-of-bricks - 1>"
-        },
-        { .key  = {"read-subvolume-index" },
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "-1",
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. AFR will prefer the one specified using "
-                         "this option if it is not stale. allowed options"
-                         " include -1 till replica-count - 1"
-        },
-        { .key = {"read-hash-mode" },
-          .type = GF_OPTION_TYPE_INT,
-          .min = 0,
-          .max = 2,
-          .default_value = "1",
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. AFR will prefer the one computed using "
-                         "the method specified using this option"
-                         "0 = first up server, "
-                         "1 = hash by GFID of file (all clients use "
-                                                    "same subvolume), "
-                         "2 = hash by GFID of file and client PID",
-        },
-        { .key  = {"choose-local" },
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "true",
-          .description = "Choose a local subvolume (i.e. Brick) to read from"
-	                 " if read-subvolume is not explicitly set.",
-        },
-        { .key  = {"favorite-child"},
-          .type = GF_OPTION_TYPE_XLATOR,
-          .description = "If a split-brain happens choose subvol/brick set by "
-                         "this option as source."
-        },
-        { .key  = {"background-self-heal-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = 256,
-          .default_value = "8",
-          .validate = GF_OPT_VALIDATE_MIN,
-          .description = "This specifies the number of per client self-heal "
-                         "jobs that can perform parallel heals in the "
-                         "background."
-        },
-        { .key   = {"halo-shd-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "99999",
-           .description = "Maximum latency for shd halo replication in msec."
-        },
-        { .key   = {"halo-enabled"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "False",
-           .description = "Enable Halo (geo) replication mode."
-        },
-        { .key   = {"halo-nfsd-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "5",
-           .description = "Maximum latency for nfsd halo replication in msec."
-        },
-        { .key   = {"halo-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "5",
-           .description = "Maximum latency for halo replication in msec."
-        },
-        { .key   = {"halo-max-replicas"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "99999",
-           .description = "The maximum number of halo replicas; replicas"
-                          " beyond this value will be written asynchronously"
-                          "via the SHD."
-        },
-        { .key   = {"halo-min-replicas"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "2",
-           .description = "The minimmum number of halo replicas, before adding "
-                          "out of region replicas."
-         },
-         { .key  = {"heal-wait-queue-length"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = 10000, /*Around 100MB with sizeof(afr_local_t)= 10496 bytes*/
-          .default_value = "128",
-          .validate = GF_OPT_VALIDATE_MIN,
-          .description = "This specifies the number of heals that can be queued"
-                         " for the parallel background self heal jobs."
-        },
-        { .key  = {"data-self-heal"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = {"1", "on", "yes", "true", "enable",
-                    "0", "off", "no", "false", "disable",
-                    "open"},
-          .default_value = "on",
-          .description   = "Using this option we can enable/disable data "
-                           "self-heal on the file. \"open\" means data "
-                           "self-heal action will only be triggered by file "
-                           "open operations."
-        },
-        { .key  = {"data-self-heal-algorithm"},
-          .type = GF_OPTION_TYPE_STR,
-          .description   = "Select between \"full\", \"diff\". The "
-                           "\"full\" algorithm copies the entire file from "
-                           "source to sink. The \"diff\" algorithm copies to "
-                           "sink only those blocks whose checksums don't match "
-                           "with those of source. If no option is configured "
-                           "the option is chosen dynamically as follows: "
-                           "If the file does not exist on one of the sinks "
-                           "or empty file exists or if the source file size is "
-                           "about the same as page size the entire file will "
-                           "be read and written i.e \"full\" algo, "
-                           "otherwise \"diff\" algo is chosen.",
-          .value = { "diff", "full"}
-        },
-        { .key  = {"data-self-heal-window-size"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 1,
-          .max  = 1024,
-          .default_value = "1",
-          .description = "Maximum number blocks per file for which self-heal "
-                         "process would be applied simultaneously."
-        },
-        { .key  = {"metadata-self-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Using this option we can enable/disable metadata "
-                         "i.e. Permissions, ownerships, xattrs self-heal on "
-                         "the file/directory."
-        },
-        { .key  = {"entry-self-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Using this option we can enable/disable entry "
-                         "self-heal on the directory."
-        },
-        { .key  = {"data-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Data fops like write/truncate will not perform "
-                         "pre/post fop changelog operations in afr transaction "
-                         "if this option is disabled"
-        },
-        { .key  = {"metadata-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Metadata fops like setattr/setxattr will not perform "
-                         "pre/post fop changelog operations in afr transaction "
-                         "if this option is disabled"
-        },
-        { .key  = {"entry-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Entry fops like create/unlink will not perform "
-                         "pre/post fop changelog operations in afr transaction "
-                         "if this option is disabled"
-        },
-        { .key  = {"optimistic-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Entry/Metadata fops will not perform "
-                         "pre fop changelog operations in afr transaction "
-                         "if this option is enabled."
-        },
-        { .key = {"inodelk-trace"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Enabling this option logs inode lock/unlocks"
-        },
-        { .key = {"entrylk-trace"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Enabling this option logs entry lock/unlocks"
-        },
-	{ .key = {"pre-op-compat"},
-	  .type = GF_OPTION_TYPE_BOOL,
-	  .default_value = "on",
-	  .description = "Use separate pre-op xattrop() FOP rather than "
-	                 "overloading xdata of the OP"
-	},
-        { .key = {"eager-lock"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Enable/Disable eager lock for replica volume. "
-                         "Lock phase of a transaction has two sub-phases. "
-                         "First is an attempt to acquire locks in parallel by "
-                         "broadcasting non-blocking lock requests. If lock "
-                         "acquisition fails on any server, then the held locks "
-                         "are unlocked and we revert to a blocking locks mode "
-                         "sequentially on one server after another.  If this "
-                         "option is enabled the initial broadcasting lock "
-                         "request attempts to acquire a full lock on the entire file. "
-                         "If this fails, we revert back to the sequential "
-                         "\"regional\" blocking locks as before. In the case "
-                         "where such an \"eager\" lock is granted in the "
-                         "non-blocking phase, it gives rise to an opportunity "
-                         "for optimization. i.e, if the next write transaction "
-                         "on the same FD arrives before the unlock phase of "
-                         "the first transaction, it \"takes over\" the full "
-                         "file lock. Similarly if yet another data transaction "
-                         "arrives before the unlock phase of the \"optimized\" "
-                         "transaction, that in turn \"takes over\" the lock as "
-                         "well. The actual unlock now happens at the end of "
-                         "the last \"optimized\" transaction."
-
-        },
-        { .key = {"self-heal-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "This option applies to only self-heal-daemon. "
-                         "Index directory crawl and automatic healing of files "
-                         "will not be performed if this option is turned off."
-        },
-        { .key = {"iam-self-heal-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option differentiates if the replicate "
-                         "translator is running as part of self-heal-daemon "
-                         "or not."
-        },
-        { .key = {"iam-nfs-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option differentiates if the replicate "
-                         "translator is running as part of an NFS daemon "
-                         "or not."
-        },
-        { .key = {"quorum-type"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = { "none", "auto", "fixed"},
-          .default_value = "none",
-          .description = "If value is \"fixed\" only allow writes if "
-                         "quorum-count bricks are present.  If value is "
-                         "\"auto\" only allow writes if more than half of "
-                         "bricks, or exactly half including the first, are "
-                         "present.",
-        },
-        { .key = {"quorum-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .min = 1,
-          .max = INT_MAX,
-          .default_value = 0,
-          .description = "If quorum-type is \"fixed\" only allow writes if "
-                         "this many bricks or present.  Other quorum types "
-                         "will OVERWRITE this value.",
-        },
-        { .key = {"quorum-reads"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "If quorum-reads is \"true\" only allow reads if "
-                         "quorum is met when quorum is enabled.",
-        },
-        { .key  = {"node-uuid"},
-          .type = GF_OPTION_TYPE_STR,
-          .description = "Local glusterd uuid string, used in starting "
-                         "self-heal-daemon so that it can crawl only on "
-                         "local index directories.",
-        },
-        { .key  = {"post-op-delay-secs"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = INT_MAX,
-          .default_value = "1",
-          .description = "Time interval induced artificially before "
-	                 "post-operation phase of the transaction to "
-                         "enhance overlap of adjacent write operations.",
-        },
-        { .key = {AFR_SH_READDIR_SIZE_KEY},
-          .type = GF_OPTION_TYPE_SIZET,
-          .description = "readdirp size for performing entry self-heal",
-          .min = 1024,
-          .max = 131072,
-          .default_value = "1KB",
-        },
-        { .key = {"ensure-durability"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .description = "Afr performs fsyncs for transactions if this "
-                         "option is on to make sure the changelogs/data is "
-                         "written to the disk",
-          .default_value = "on",
-        },
-	{ .key = {"afr-dirty-xattr"},
-	  .type = GF_OPTION_TYPE_STR,
-	  .default_value = AFR_DIRTY_DEFAULT,
-	},
-	{ .key = {"afr-pending-xattr"},
-	  .type = GF_OPTION_TYPE_STR,
-          .description = "Comma separated list of xattrs that are used to  "
-                         "capture information on pending heals."
-	},
-	{ .key = {"metadata-splitbrain-forced-heal"},
-	  .type = GF_OPTION_TYPE_BOOL,
-	  .default_value = "off",
-	},
-        { .key  = {"heal-timeout"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 60,
-          .max  = INT_MAX,
-          .default_value = "600",
-          .description = "time interval for checking the need to self-heal "
-                         "in self-heal-daemon"
-        },
-        { .key = {"consistent-metadata"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "If this option is enabled, readdirp will force "
-                         "lookups on those entries read whose read child is "
-                         "not the same as that of the parent. This will "
-                         "guarantee that all read operations on a file serve "
-                         "attributes from the same subvol as long as it holds "
-                         " a good copy of the file/dir.",
-        },
-        { .key = {"arbiter-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .description = "subset of child_count. Has to be 0 or 1."
-        },
-        { .key   = {"shd-max-threads"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 64,
-          .default_value = "1",
-           .description = "Maximum number of parallel heals SHD can do per "
-                          "local brick. This can substantially lower heal times"
-                          ", but can also crush your bricks if you don't have "
-                          "the storage hardware to support this."
-        },
-        { .key   = {"shd-wait-qlength"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 655536,
-          .default_value = "1024",
-           .description = "This option can be used to control number of heals"
-                          " that can wait in SHD per subvolume",
-        },
-        { .key = {"locking-scheme"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = { "full", "granular"},
-          .default_value = "full",
-          .description = "If this option is set to granular, self-heal will "
-                         "stop being compatible with afr-v1, which helps afr "
-                         "be more granular while self-healing",
-        },
-        { .key = {"granular-entry-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "If this option is enabled, self-heal will resort to "
-                         "granular way of recording changelogs and doing entry "
-                         "self-heal.",
-        },
-        { .key   = {"favorite-child-policy"},
-          .type  = GF_OPTION_TYPE_STR,
-          .value = {"none", "size", "ctime", "mtime", "majority"},
-          .default_value = "none",
-          .description = "This option can be used to automatically resolve "
-                         "split-brains using various policies without user "
-                         "intervention. \"size\" picks the file with the "
-                         "biggest size as the source. \"ctime\" and \"mtime\" "
-                         "pick the file with the latest ctime and mtime "
-                         "respectively as the source. \"majority\" picks a file"
-                         " with identical mtime and size in more than half the "
-                         "number of bricks in the replica.",
-        },
-        { .key = {"consistent-io"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "If this option is enabled, i/o will fail even if "
-                         "one of the bricks is down in the replicas",
-        },
-        { .key   = {"use-compound-fops"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "Use compound fops framework to modify afr "
-                         "transaction such that network roundtrips are "
-                         "reduced, thus improving the performance.",
-        },
-        { .key  = {NULL} },
+    {.key = {"read-subvolume"},
+     .type = GF_OPTION_TYPE_XLATOR,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "inode-read fops happen only on one of the bricks in "
+                    "replicate. Afr will prefer the one specified using "
+                    "this option if it is not stale. Option value must be "
+                    "one of the xlator names of the children. "
+                    "Ex: <volname>-client-0 till "
+                    "<volname>-client-<number-of-bricks - 1>"},
+    {.key = {"read-subvolume-index"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "-1",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "inode-read fops happen only on one of the bricks in "
+                    "replicate. AFR will prefer the one specified using "
+                    "this option if it is not stale. allowed options"
+                    " include -1 till replica-count - 1"},
+    {.key = {"read-hash-mode"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 5,
+     .default_value = "1",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description =
+         "inode-read fops happen only on one of the bricks in "
+         "replicate. AFR will prefer the one computed using "
+         "the method specified using this option.\n"
+         "0 = first readable child of AFR, starting from 1st child.\n"
+         "1 = hash by GFID of file (all clients use "
+         "same subvolume).\n"
+         "2 = hash by GFID of file and client PID.\n"
+         "3 = brick having the least outstanding read requests.\n"
+         "4 = brick having the least network ping latency.\n"
+         "5 = Hybrid mode between 3 and 4, ie least value among "
+         "network-latency multiplied by outstanding-read-requests."},
+    {
+        .key = {"choose-local"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "true",
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Choose a local subvolume (i.e. Brick) to read from"
+                       " if read-subvolume is not explicitly set.",
+    },
+    {.key = {"background-self-heal-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 256,
+     .default_value = "8",
+     .validate = GF_OPT_VALIDATE_MIN,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This specifies the number of per client self-heal "
+                    "jobs that can perform parallel heals in the "
+                    "background."},
+    {.key = {"halo-shd-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "99999",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for shd halo replication in msec."},
+    {.key = {"halo-enabled"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "False",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Enable Halo (geo) replication mode."},
+    {.key = {"halo-nfsd-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "5",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for nfsd halo replication in msec."},
+    {.key = {"halo-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = AFR_HALO_MAX_LATENCY,
+     .default_value = "5",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for halo replication in msec."},
+    {.key = {"halo-max-replicas"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "99999",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "The maximum number of halo replicas; replicas"
+                    " beyond this value will be written asynchronously"
+                    "via the SHD."},
+    {.key = {"halo-min-replicas"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "2",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "The minimmum number of halo replicas, before adding "
+                    "out of region replicas."},
+    {.key = {"heal-wait-queue-length"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 10000, /*Around 100MB with sizeof(afr_local_t)= 10496 bytes*/
+     .default_value = "128",
+     .validate = GF_OPT_VALIDATE_MIN,
+     .op_version = {GD_OP_VERSION_3_7_10},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This specifies the number of heals that can be queued"
+                    " for the parallel background self heal jobs."},
+    {.key = {"data-self-heal"},
+     .type = GF_OPTION_TYPE_STR,
+     .value = {"1", "on", "yes", "true", "enable", "0", "off", "no", "false",
+               "disable", "open"},
+     .default_value = "off",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Using this option we can enable/disable data "
+                    "self-heal on the file. \"open\" means data "
+                    "self-heal action will only be triggered by file "
+                    "open operations."},
+    {.key = {"data-self-heal-algorithm"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Select between \"full\", \"diff\". The "
+                    "\"full\" algorithm copies the entire file from "
+                    "source to sink. The \"diff\" algorithm copies to "
+                    "sink only those blocks whose checksums don't match "
+                    "with those of source. If no option is configured "
+                    "the option is chosen dynamically as follows: "
+                    "If the file does not exist on one of the sinks "
+                    "or empty file exists or if the source file size is "
+                    "about the same as page size the entire file will "
+                    "be read and written i.e \"full\" algo, "
+                    "otherwise \"diff\" algo is chosen.",
+     .value = {"diff", "full"}},
+    {.key = {"data-self-heal-window-size"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 1024,
+     .default_value = "1",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Maximum number blocks per file for which self-heal "
+                    "process would be applied simultaneously."},
+    {.key = {"metadata-self-heal"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     /*.validate_fn = validate_replica*/
+     .description = "Using this option we can enable/disable metadata "
+                    "i.e. Permissions, ownerships, xattrs self-heal on "
+                    "the file/directory."},
+    {.key = {"entry-self-heal"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     /*.validate_fn = validate_replica*/
+     .description = "Using this option we can enable/disable entry "
+                    "self-heal on the directory."},
+    {.key = {"data-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"metadata-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"entry-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"optimistic-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Entry/Metadata fops will not perform "
+                    "pre fop changelog operations in afr transaction "
+                    "if this option is enabled."},
+    {.key = {"inodelk-trace"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Enabling this option logs inode lock/unlocks"},
+    {.key = {"entrylk-trace"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Enabling this option logs entry lock/unlocks"},
+    {.key = {"pre-op-compat"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Use separate pre-op xattrop() FOP rather than "
+                    "overloading xdata of the OP"},
+    {.key = {"eager-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description =
+         "Enable/Disable eager lock for replica volume. "
+         "Lock phase of a transaction has two sub-phases. "
+         "First is an attempt to acquire locks in parallel by "
+         "broadcasting non-blocking lock requests. If lock "
+         "acquisition fails on any server, then the held locks "
+         "are unlocked and we revert to a blocking locks mode "
+         "sequentially on one server after another.  If this "
+         "option is enabled the initial broadcasting lock "
+         "request attempts to acquire a full lock on the entire file. "
+         "If this fails, we revert back to the sequential "
+         "\"regional\" blocking locks as before. In the case "
+         "where such an \"eager\" lock is granted in the "
+         "non-blocking phase, it gives rise to an opportunity "
+         "for optimization. i.e, if the next write transaction "
+         "on the same FD arrives before the unlock phase of "
+         "the first transaction, it \"takes over\" the full "
+         "file lock. Similarly if yet another data transaction "
+         "arrives before the unlock phase of the \"optimized\" "
+         "transaction, that in turn \"takes over\" the lock as "
+         "well. The actual unlock now happens at the end of "
+         "the last \"optimized\" transaction."
+
+    },
+    {.key = {"self-heal-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+     .tags = {"replicate"},
+     /*.validate_fn   = validate_replica_heal_enable_disable*/
+     .description = "This option applies to only self-heal-daemon. "
+                    "Index directory crawl and automatic healing of files "
+                    "will not be performed if this option is turned off."},
+    {.key = {"iam-self-heal-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option differentiates if the replicate "
+                    "translator is running as part of self-heal-daemon "
+                    "or not."},
+    {.key = {"iam-nfs-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option differentiates if the replicate "
+                    "translator is running as part of an NFS daemon "
+                    "or not."},
+    {
+        .key = {"quorum-type"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"none", "auto", "fixed"},
+        .default_value = "none",
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        /*.option = quorum-type*/
+        .description = "If value is \"fixed\" only allow writes if "
+                       "quorum-count bricks are present.  If value is "
+                       "\"auto\" only allow writes if more than half of "
+                       "bricks, or exactly half including the first, are "
+                       "present.",
+    },
+    {
+        .key = {"quorum-count"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 1,
+        .max = INT_MAX,
+        .default_value = 0,
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        /*.option = quorum-count*/
+        /*.validate_fn = validate_quorum_count*/
+        .description = "If quorum-type is \"fixed\" only allow writes if "
+                       "this many bricks are present.  Other quorum types "
+                       "will OVERWRITE this value.",
+    },
+    {
+        .key = {"quorum-reads"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_7_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option has been removed. Reads are not allowed "
+                       "if quorum is not met.",
+    },
+    {
+        .key = {"node-uuid"},
+        .type = GF_OPTION_TYPE_STR,
+        .description = "Local glusterd uuid string, used in starting "
+                       "self-heal-daemon so that it can crawl only on "
+                       "local index directories.",
+    },
+    {
+        .key = {"post-op-delay-secs"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 0,
+        .max = INT_MAX,
+        .default_value = "1",
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Time interval induced artificially before "
+                       "post-operation phase of the transaction to "
+                       "enhance overlap of adjacent write operations.",
+    },
+    {
+        .key = {AFR_SH_READDIR_SIZE_KEY},
+        .type = GF_OPTION_TYPE_SIZET,
+        .description = "readdirp size for performing entry self-heal",
+        .min = 1024,
+        .max = 131072,
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+        .tags = {"replicate"},
+        .default_value = "1KB",
+    },
+    {
+        .key = {"ensure-durability"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .op_version = {3},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Afr performs fsyncs for transactions if this "
+                       "option is on to make sure the changelogs/data is "
+                       "written to the disk",
+        .default_value = "on",
+    },
+    {
+        .key = {"afr-dirty-xattr"},
+        .type = GF_OPTION_TYPE_STR,
+        .default_value = AFR_DIRTY_DEFAULT,
+    },
+    {.key = {"afr-pending-xattr"},
+     .type = GF_OPTION_TYPE_STR,
+     .description = "Comma separated list of xattrs that are used to  "
+                    "capture information on pending heals."},
+    {
+        .key = {"metadata-splitbrain-forced-heal"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+    },
+    {.key = {"heal-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 5,
+     .max = INT_MAX,
+     .default_value = "600",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "time interval for checking the need to self-heal "
+                    "in self-heal-daemon"},
+    {
+        .key = {"consistent-metadata"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_7_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is enabled, readdirp will force "
+                       "lookups on those entries read whose read child is "
+                       "not the same as that of the parent. This will "
+                       "guarantee that all read operations on a file serve "
+                       "attributes from the same subvol as long as it holds "
+                       " a good copy of the file/dir.",
+    },
+    {.key = {"arbiter-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .description = "subset of child_count. Has to be 0 or 1."},
+    {
+        .key = {"thin-arbiter"},
+        .type = GF_OPTION_TYPE_STR,
+        .op_version = {GD_OP_VERSION_4_1_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"replicate"},
+        .description = "contains host:path of thin abriter brick",
+    },
+    {.key = {"shd-max-threads"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 64,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_3_7_12},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Maximum number of parallel heals SHD can do per "
+                    "local brick. This can substantially lower heal times"
+                    ", but can also crush your bricks if you don't have "
+                    "the storage hardware to support this."},
+    {
+        .key = {"shd-wait-qlength"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 1,
+        .max = 655536,
+        .default_value = "1024",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option can be used to control number of heals"
+                       " that can wait in SHD per subvolume",
+    },
+    {
+        .key = {"locking-scheme"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"full", "granular"},
+        .default_value = "full",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is set to granular, self-heal will "
+                       "stop being compatible with afr-v1, which helps afr "
+                       "be more granular while self-healing",
+    },
+    {.key = {"full-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "yes",
+     .op_version = {GD_OP_VERSION_3_13_2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+     .tags = {"replicate"},
+     .description = "If this option is disabled, then the IOs will take "
+                    "range locks same as versions till 3.13.1."},
+    {
+        .key = {"granular-entry-heal"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_8_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is enabled, self-heal will resort to "
+                       "granular way of recording changelogs and doing entry "
+                       "self-heal.",
+    },
+    {
+        .key = {"favorite-child-policy"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"none", "size", "ctime", "mtime", "majority"},
+        .default_value = "none",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option can be used to automatically resolve "
+                       "split-brains using various policies without user "
+                       "intervention. \"size\" picks the file with the "
+                       "biggest size as the source. \"ctime\" and \"mtime\" "
+                       "pick the file with the latest ctime and mtime "
+                       "respectively as the source. \"majority\" picks a file"
+                       " with identical mtime and size in more than half the "
+                       "number of bricks in the replica.",
+    },
+    {
+        .key = {"consistent-io"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .description = "If this option is enabled, i/o will fail even if "
+                       "one of the bricks is down in the replicas",
+    },
+    {.key = {"use-compound-fops"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .op_version = {GD_OP_VERSION_3_8_4},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"use-anonymous-inode"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .op_version = {GD_OP_VERSION_8_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+     .tags = {"replicate"},
+     .description = "Setting this option heals directory renames efficiently"},
+
+    {.key = {NULL}},
+};
+
+xlator_api_t xlator_api = {
+    .init = init,
+    .fini = fini,
+    .notify = notify,
+    .reconfigure = reconfigure,
+    .mem_acct_init = mem_acct_init,
+    .op_version = {1}, /* Present from the initial version */
+    .dumpops = &dumpops,
+    .fops = &fops,
+    .cbks = &cbks,
+    .options = options,
+    .identifier = "replicate",
+    .category = GF_MAINTAINED,
 };
diff --git a/xlators/cluster/afr/src/afr.h b/xlators/cluster/afr/src/afr.h
index c4ceb66914f..d62f9a9caf2 100644
--- a/xlators/cluster/afr/src/afr.h
+++ b/xlators/cluster/afr/src/afr.h
@@ -8,216 +8,293 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef __AFR_H__
 #define __AFR_H__
 
-#include "call-stub.h"
-#include "compat-errno.h"
+#include <glusterfs/call-stub.h>
+#include <glusterfs/compat-errno.h>
 #include "afr-mem-types.h"
 
 #include "libxlator.h"
-#include "timer.h"
-#include "syncop.h"
+#include <glusterfs/timer.h>
+#include <glusterfs/syncop.h>
 
 #include "afr-self-heald.h"
 #include "afr-messages.h"
 
+#define SHD_INODE_LRU_LIMIT 1
 #define AFR_PATHINFO_HEADER "REPLICATE:"
 #define AFR_SH_READDIR_SIZE_KEY "self-heal-readdir-size"
 #define AFR_SH_DATA_DOMAIN_FMT "%s:self-heal"
 #define AFR_DIRTY_DEFAULT AFR_XATTR_PREFIX ".dirty"
-#define AFR_DIRTY (((afr_private_t *) (THIS->private))->afr_dirty)
+#define AFR_DIRTY (((afr_private_t *)(THIS->private))->afr_dirty)
 
-#define AFR_LOCKEE_COUNT_MAX    3
-#define AFR_DOM_COUNT_MAX    3
-#define AFR_NUM_CHANGE_LOGS            3 /*data + metadata + entry*/
+#define AFR_LOCKEE_COUNT_MAX 3
+#define AFR_DOM_COUNT_MAX 3
+#define AFR_NUM_CHANGE_LOGS 3              /*data + metadata + entry*/
 #define AFR_DEFAULT_SPB_CHOICE_TIMEOUT 300 /*in seconds*/
 
 #define ARBITER_BRICK_INDEX 2
+#define THIN_ARBITER_BRICK_INDEX 2
+#define AFR_TA_DOM_NOTIFY "afr.ta.dom-notify"
+#define AFR_TA_DOM_MODIFY "afr.ta.dom-modify"
+
+#define AFR_LK_HEAL_DOM "afr.lock-heal.domain"
+
+#define AFR_HALO_MAX_LATENCY 99999
+#define AFR_ANON_DIR_PREFIX ".glusterfs-anonymous-inode"
+
+#define PFLAG_PENDING (1 << 0)
+#define PFLAG_SBRAIN (1 << 1)
+
+typedef int (*afr_lock_cbk_t)(call_frame_t *frame, xlator_t *this);
+
+typedef int (*afr_read_txn_wind_t)(call_frame_t *frame, xlator_t *this,
+                                   int subvol);
+
+typedef int (*afr_inode_refresh_cbk_t)(call_frame_t *frame, xlator_t *this,
+                                       int err);
+
+typedef int (*afr_changelog_resume_t)(call_frame_t *frame, xlator_t *this);
+
+#define AFR_COUNT(array, max)                                                  \
+    ({                                                                         \
+        int __i;                                                               \
+        int __res = 0;                                                         \
+        for (__i = 0; __i < max; __i++)                                        \
+            if (array[__i])                                                    \
+                __res++;                                                       \
+        __res;                                                                 \
+    })
+#define AFR_INTERSECT(dst, src1, src2, max)                                    \
+    ({                                                                         \
+        int __i;                                                               \
+        for (__i = 0; __i < max; __i++)                                        \
+            dst[__i] = src1[__i] && src2[__i];                                 \
+    })
+#define AFR_CMP(a1, a2, len)                                                   \
+    ({                                                                         \
+        int __cmp = 0;                                                         \
+        int __i;                                                               \
+        for (__i = 0; __i < len; __i++)                                        \
+            if (a1[__i] != a2[__i]) {                                          \
+                __cmp = 1;                                                     \
+                break;                                                         \
+            }                                                                  \
+        __cmp;                                                                 \
+    })
+#define AFR_IS_ARBITER_BRICK(priv, index)                                      \
+    ((priv->arbiter_count == 1) && (index == ARBITER_BRICK_INDEX))
 
-typedef int (*afr_lock_cbk_t) (call_frame_t *frame, xlator_t *this);
-
-typedef int (*afr_read_txn_wind_t) (call_frame_t *frame, xlator_t *this, int subvol);
-
-typedef int (*afr_inode_refresh_cbk_t) (call_frame_t *frame, xlator_t *this, int err);
+#define AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(ret, errnum)                       \
+    do {                                                                       \
+        local->op_ret = ret;                                                   \
+        local->op_errno = errnum;                                              \
+        if (local->op_errno == EIO)                                            \
+            gf_msg(this->name, GF_LOG_ERROR, local->op_errno,                  \
+                   AFR_MSG_SPLIT_BRAIN,                                        \
+                   "Failing %s on gfid %s: "                                   \
+                   "split-brain observed.",                                    \
+                   gf_fop_list[local->op], uuid_utoa(local->inode->gfid));     \
+    } while (0)
+
+#define AFR_ERROR_OUT_IF_FDCTX_INVALID(__fd, __this, __error, __label)         \
+    do {                                                                       \
+        afr_fd_ctx_t *__fd_ctx = NULL;                                         \
+        __fd_ctx = afr_fd_ctx_get(__fd, __this);                               \
+        if (__fd_ctx && __fd_ctx->is_fd_bad) {                                 \
+            __error = EBADF;                                                   \
+            goto __label;                                                      \
+        }                                                                      \
+    } while (0)
 
-typedef int (*afr_changelog_resume_t) (call_frame_t *frame, xlator_t *this);
+typedef enum {
+    AFR_READ_POLICY_FIRST_UP,
+    AFR_READ_POLICY_GFID_HASH,
+    AFR_READ_POLICY_GFID_PID_HASH,
+    AFR_READ_POLICY_LESS_LOAD,
+    AFR_READ_POLICY_LEAST_LATENCY,
+    AFR_READ_POLICY_LOAD_LATENCY_HYBRID,
+} afr_read_hash_mode_t;
 
-typedef int (*afr_compound_cbk_t) (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int op_ret, int op_errno,
-                                   void *data, dict_t *xdata);
+typedef enum {
+    AFR_FAV_CHILD_NONE,
+    AFR_FAV_CHILD_BY_SIZE,
+    AFR_FAV_CHILD_BY_CTIME,
+    AFR_FAV_CHILD_BY_MTIME,
+    AFR_FAV_CHILD_BY_MAJORITY,
+    AFR_FAV_CHILD_POLICY_MAX,
+} afr_favorite_child_policy;
 
-#define AFR_COUNT(array,max) ({int __i; int __res = 0; for (__i = 0; __i < max; __i++) if (array[__i]) __res++; __res;})
-#define AFR_INTERSECT(dst,src1,src2,max) ({int __i; for (__i = 0; __i < max; __i++) dst[__i] = src1[__i] && src2[__i];})
-#define AFR_CMP(a1,a2,len) ({int __cmp = 0; int __i; for (__i = 0; __i < len; __i++) if (a1[__i] != a2[__i]) { __cmp = 1; break;} __cmp;})
-#define AFR_IS_ARBITER_BRICK(priv, index) ((priv->arbiter_count == 1) && (index == ARBITER_BRICK_INDEX))
+typedef enum {
+    AFR_SELFHEAL_DATA_FULL = 0,
+    AFR_SELFHEAL_DATA_DIFF,
+    AFR_SELFHEAL_DATA_DYNAMIC,
+} afr_data_self_heal_type_t;
 
-#define AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(ret, errnum)                       \
-        do {                                                                   \
-                local->op_ret = ret;                                           \
-                local->op_errno = errnum;                                      \
-                if (local->op_errno == EIO)                                    \
-                        gf_msg (this->name, GF_LOG_ERROR, local->op_errno,     \
-                                AFR_MSG_SPLIT_BRAIN, "Failing %s on gfid %s: " \
-                                "split-brain observed.",                       \
-                                gf_fop_list[local->op],                        \
-                                uuid_utoa (local->inode->gfid));               \
-        } while (0)
+typedef enum {
+    AFR_CHILD_UNKNOWN = -1,
+    AFR_CHILD_ZERO,
+    AFR_CHILD_ONE,
+    AFR_CHILD_THIN_ARBITER,
+} afr_child_index;
 
 typedef enum {
-        AFR_FAV_CHILD_NONE,
-        AFR_FAV_CHILD_BY_SIZE,
-        AFR_FAV_CHILD_BY_CTIME,
-        AFR_FAV_CHILD_BY_MTIME,
-        AFR_FAV_CHILD_BY_MAJORITY,
-        AFR_FAV_CHILD_POLICY_MAX,
-} afr_favorite_child_policy;
+    TA_WAIT_FOR_NOTIFY_LOCK_REL, /*FOP came after notify domain lock upcall
+                                   notification and waiting for its release.*/
+    TA_GET_INFO_FROM_TA_FILE,    /*FOP needs post-op on ta file to get
+                                  *info about which brick is bad.*/
+    TA_INFO_IN_MEMORY_SUCCESS,   /*Bad brick info is in memory and fop failed
+                                  *on BAD brick - Success*/
+    TA_INFO_IN_MEMORY_FAILED,    /*Bad brick info is in memory and fop failed
+                                  *on GOOD brick - Failed*/
+    TA_SUCCESS,                  /*FOP succeeded on both data bricks.*/
+} afr_ta_fop_state_t;
 
 struct afr_nfsd {
-        gf_boolean_t     iamnfsd;
-        uint32_t         halo_max_latency_msec;
+    uint32_t halo_max_latency_msec;
+    gf_boolean_t iamnfsd;
 };
 
+typedef struct _afr_lk_heal_info {
+    fd_t *fd;
+    int32_t cmd;
+    struct gf_flock flock;
+    dict_t *xdata_req;
+    unsigned char *locked_nodes;
+    struct list_head pos;
+    gf_lkowner_t lk_owner;
+    pid_t pid;
+    int32_t *child_up_event_gen;
+    int32_t *child_down_event_gen;
+} afr_lk_heal_info_t;
+
 typedef struct _afr_private {
-        gf_lock_t lock;               /* to guard access to child_count, etc */
-        unsigned int child_count;     /* total number of children   */
-        unsigned int arbiter_count;   /*subset of child_count.
-                                        Has to be 0 or 1.*/
-
-        xlator_t **children;
-
-        inode_t *root_inode;
-
-        unsigned char *child_up;
-        int64_t *child_latency;
-        unsigned char *local;
-
-        char **pending_key;
-
-        char         *data_self_heal;              /* on/off/open */
-        char *       data_self_heal_algorithm;    /* name of algorithm */
-        unsigned int data_self_heal_window_size;  /* max number of pipelined
-                                                     read/writes */
-
-        struct list_head heal_waiting; /*queue for files that need heal*/
-        uint32_t  heal_wait_qlen; /*configurable queue length for heal_waiting*/
-        int32_t  heal_waiters; /* No. of elements currently in wait queue.*/
-
-        struct list_head healing;/* queue for files that are undergoing
-                                    background heal*/
-        uint32_t  background_self_heal_count;/*configurable queue length for
-                                               healing queue*/
-        int32_t  healers;/* No. of elements currently undergoing background
-                          heal*/
-
-        gf_boolean_t metadata_self_heal;   /* on/off */
-        gf_boolean_t entry_self_heal;      /* on/off */
-
-        gf_boolean_t data_change_log;       /* on/off */
-        gf_boolean_t metadata_change_log;   /* on/off */
-        gf_boolean_t entry_change_log;      /* on/off */
-
-	gf_boolean_t metadata_splitbrain_forced_heal; /* on/off */
-        int read_child;               /* read-subvolume */
-        unsigned int hash_mode;       /* for when read_child is not set */
-        int favorite_child;  /* subvolume to be preferred in resolving
-                                         split-brain cases */
-
-        afr_favorite_child_policy fav_child_policy;/*Policy to use for automatic
-                                                 resolution of split-brains.*/
-
-        gf_boolean_t inodelk_trace;
-        gf_boolean_t entrylk_trace;
-
-        unsigned int wait_count;      /* # of servers to wait for success */
-
-        gf_timer_t *timer;      /* launched when parent up is received */
-
-        gf_boolean_t      optimistic_change_log;
-        gf_boolean_t      eager_lock;
-        gf_boolean_t      pre_op_compat;      /* on/off */
-	uint32_t          post_op_delay_secs;
-        unsigned int      quorum_count;
-        gf_boolean_t      quorum_reads;
-
-        char                   vol_uuid[UUID_SIZE + 1];
-        int32_t                *last_event;
-
-	/* @event_generation: Keeps count of number of events received which can
-	   potentially impact consistency decisions. The events are CHILD_UP
-	   and CHILD_DOWN, when we have to recalculate the freshness/staleness
-	   of copies to detect if changes had happened while the other server
-	   was down. CHILD_DOWN and CHILD_UP can also be received on network
-	   disconnect/reconnects and not necessarily server going down/up.
-	   Recalculating freshness/staleness on network events is equally
-	   important as we might have had a network split brain.
-	*/
-	uint32_t               event_generation;
-
-        gf_boolean_t           choose_local;
-        gf_boolean_t           did_discovery;
-        uint64_t               sh_readdir_size;
-        gf_boolean_t           ensure_durability;
-        char                   *sh_domain;
-	char                   *afr_dirty;
-        gf_boolean_t           halo_enabled;
-
-        uint32_t               halo_max_latency_msec;
-        uint32_t               halo_max_replicas;
-        uint32_t               halo_min_replicas;
-
-        afr_self_heald_t       shd;
-        struct afr_nfsd        nfsd;
-
-        gf_boolean_t           consistent_metadata;
-        uint64_t               spb_choice_timeout;
-        gf_boolean_t           need_heal;
-
-	/* pump dependencies */
-	void                   *pump_private;
-	gf_boolean_t           use_afr_in_pump;
-	char                   *locking_scheme;
-        gf_boolean_t            esh_granular;
-        gf_boolean_t           consistent_io;
-        gf_boolean_t            use_compound_fops;
+    gf_lock_t lock;             /* to guard access to child_count, etc */
+    unsigned int child_count;   /* total number of children   */
+    unsigned int arbiter_count; /*subset of child_count.
+                                  Has to be 0 or 1.*/
+
+    xlator_t **children;
+
+    inode_t *root_inode;
+
+    int favorite_child; /* subvolume to be preferred in resolving
+                                    split-brain cases */
+    /* For thin-arbiter. */
+    uuid_t ta_gfid;
+    unsigned int thin_arbiter_count; /* 0 or 1 at the moment.*/
+    int ta_bad_child_index;
+    int ta_event_gen;
+    unsigned int ta_in_mem_txn_count;
+    unsigned int ta_on_wire_txn_count;
+    struct list_head ta_waitq;
+    struct list_head ta_onwireq;
+
+    unsigned char *anon_inode;
+    unsigned char *child_up;
+    unsigned char *halo_child_up;
+    int64_t *child_latency;
+    unsigned char *local;
+
+    char **pending_key;
+
+    afr_data_self_heal_type_t data_self_heal_algorithm;
+    unsigned int data_self_heal_window_size; /* max number of pipelined
+                                                read/writes */
+
+    struct list_head heal_waiting; /*queue for files that need heal*/
+    uint32_t heal_wait_qlen; /*configurable queue length for heal_waiting*/
+    int32_t heal_waiters;    /* No. of elements currently in wait queue.*/
+
+    struct list_head healing;            /* queue for files that are undergoing
+                                            background heal*/
+    uint32_t background_self_heal_count; /*configurable queue length for
+                                           healing queue*/
+    int32_t healers; /* No. of elements currently undergoing background
+                      heal*/
+
+    gf_boolean_t release_ta_notify_dom_lock;
+
+    gf_boolean_t metadata_self_heal; /* on/off */
+    gf_boolean_t entry_self_heal;    /* on/off */
+
+    gf_boolean_t metadata_splitbrain_forced_heal; /* on/off */
+    int read_child;                               /* read-subvolume */
+    gf_atomic_t *pending_reads; /*No. of pending read cbks per child.*/
+
+    gf_timer_t *timer; /* launched when parent up is received */
+
+    unsigned int wait_count; /* # of servers to wait for success */
+
+    unsigned char ta_child_up;
+    gf_boolean_t optimistic_change_log;
+    gf_boolean_t eager_lock;
+    gf_boolean_t pre_op_compat; /* on/off */
+    uint32_t post_op_delay_secs;
+    unsigned int quorum_count;
+
+    off_t ta_notify_dom_lock_offset;
+    afr_favorite_child_policy fav_child_policy; /*Policy to use for automatic
+                                              resolution of split-brains.*/
+    afr_read_hash_mode_t hash_mode; /* for when read_child is not set */
+
+    int32_t *last_event;
+
+    /* @event_generation: Keeps count of number of events received which can
+       potentially impact consistency decisions. The events are CHILD_UP
+       and CHILD_DOWN, when we have to recalculate the freshness/staleness
+       of copies to detect if changes had happened while the other server
+       was down. CHILD_DOWN and CHILD_UP can also be received on network
+       disconnect/reconnects and not necessarily server going down/up.
+       Recalculating freshness/staleness on network events is equally
+       important as we might have had a network split brain.
+    */
+    uint32_t event_generation;
+    char vol_uuid[UUID_SIZE + 1];
+
+    gf_boolean_t choose_local;
+    gf_boolean_t did_discovery;
+    gf_boolean_t ensure_durability;
+    gf_boolean_t halo_enabled;
+    gf_boolean_t consistent_metadata;
+    gf_boolean_t need_heal;
+    gf_boolean_t granular_locks;
+    uint64_t sh_readdir_size;
+    char *sh_domain;
+    char *afr_dirty;
+
+    uint64_t spb_choice_timeout;
+
+    afr_self_heald_t shd;
+    struct afr_nfsd nfsd;
+
+    uint32_t halo_max_latency_msec;
+    uint32_t halo_max_replicas;
+    uint32_t halo_min_replicas;
+
+    gf_boolean_t full_lock;
+    gf_boolean_t esh_granular;
+    gf_boolean_t consistent_io;
+    gf_boolean_t data_self_heal; /* on/off */
+    gf_boolean_t use_anon_inode;
+
+    /*For lock healing.*/
+    struct list_head saved_locks;
+    struct list_head lk_healq;
+
+    /*For anon-inode handling */
+    char anon_inode_name[NAME_MAX + 1];
+    char anon_gfid_str[UUID_SIZE + 1];
 } afr_private_t;
 
-
 typedef enum {
-        AFR_DATA_TRANSACTION,          /* truncate, write, ... */
-        AFR_METADATA_TRANSACTION,      /* chmod, chown, ... */
-        AFR_ENTRY_TRANSACTION,         /* create, rmdir, ... */
-        AFR_ENTRY_RENAME_TRANSACTION,  /* rename */
+    AFR_DATA_TRANSACTION,         /* truncate, write, ... */
+    AFR_METADATA_TRANSACTION,     /* chmod, chown, ... */
+    AFR_ENTRY_TRANSACTION,        /* create, rmdir, ... */
+    AFR_ENTRY_RENAME_TRANSACTION, /* rename */
 } afr_transaction_type;
 
-typedef enum {
-        AFR_TRANSACTION_LK,
-        AFR_SELFHEAL_LK,
-} transaction_lk_type_t;
-
-typedef enum {
-        AFR_LOCK_OP,
-        AFR_UNLOCK_OP,
-} afr_lock_op_type_t;
-
-typedef enum {
-        AFR_DATA_SELF_HEAL_LK,
-        AFR_METADATA_SELF_HEAL_LK,
-        AFR_ENTRY_SELF_HEAL_LK,
-}selfheal_lk_type_t;
-
-typedef enum {
-        AFR_INODELK_TRANSACTION,
-        AFR_INODELK_NB_TRANSACTION,
-        AFR_ENTRYLK_TRANSACTION,
-        AFR_ENTRYLK_NB_TRANSACTION,
-        AFR_INODELK_SELFHEAL,
-        AFR_INODELK_NB_SELFHEAL,
-        AFR_ENTRYLK_SELFHEAL,
-        AFR_ENTRYLK_NB_SELFHEAL,
-} afr_lock_call_type_t;
-
 /*
   xattr format: trusted.afr.volume = [x y z]
   x - data pending
@@ -226,913 +303,940 @@ typedef enum {
 */
 
 static inline int
-afr_index_for_transaction_type (afr_transaction_type type)
+afr_index_for_transaction_type(afr_transaction_type type)
 {
-        switch (type) {
-
+    switch (type) {
         case AFR_DATA_TRANSACTION:
-                return 0;
+            return 0;
 
         case AFR_METADATA_TRANSACTION:
-                return 1;
+            return 1;
 
         case AFR_ENTRY_TRANSACTION:
         case AFR_ENTRY_RENAME_TRANSACTION:
-                return 2;
-        }
+            return 2;
+    }
 
-        return -1;  /* make gcc happy */
+    return -1; /* make gcc happy */
 }
 
 static inline int
-afr_index_from_ia_type (ia_type_t type)
+afr_index_from_ia_type(ia_type_t type)
 {
-        switch (type) {
+    switch (type) {
         case IA_IFDIR:
-                return afr_index_for_transaction_type (AFR_ENTRY_TRANSACTION);
+            return afr_index_for_transaction_type(AFR_ENTRY_TRANSACTION);
         case IA_IFREG:
-                return afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
-        default: return -1;
-        }
+            return afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
+        default:
+            return -1;
+    }
 }
 
 typedef struct {
-        loc_t                   loc;
-        char                    *basename;
-        unsigned char           *locked_nodes;
-        int                     locked_count;
+    struct gf_flock flock;
+    loc_t loc;
+    fd_t *fd;
+    char *basename;
+    unsigned char *locked_nodes;
+    int locked_count;
 
-} afr_entry_lockee_t;
+} afr_lockee_t;
 
 int
-afr_entry_lockee_cmp (const void *l1, const void *l2);
-
-typedef struct {
-        char    *domain; /* Domain on which inodelk is taken */
-        struct gf_flock flock;
-        unsigned char *locked_nodes;
-        int32_t lock_count;
-} afr_inodelk_t;
+afr_entry_lockee_cmp(const void *l1, const void *l2);
 
 typedef struct {
-        loc_t *lk_loc;
+    loc_t *lk_loc;
 
-        int                     lockee_count;
-        afr_entry_lockee_t      lockee[AFR_LOCKEE_COUNT_MAX];
+    afr_lockee_t lockee[AFR_LOCKEE_COUNT_MAX];
 
-        afr_inodelk_t       inodelk[AFR_DOM_COUNT_MAX];
-        const char *lk_basename;
-        const char *lower_basename;
-        const char *higher_basename;
-        char lower_locked;
-        char higher_locked;
+    const char *lk_basename;
+    const char *lower_basename;
+    const char *higher_basename;
 
-        unsigned char *locked_nodes;
-        unsigned char *lower_locked_nodes;
+    unsigned char *lower_locked_nodes;
 
-        selfheal_lk_type_t selfheal_lk_type;
-        transaction_lk_type_t transaction_lk_type;
+    afr_lock_cbk_t lock_cbk;
 
-        int32_t lock_count;
-        int32_t entrylk_lock_count;
+    int lockee_count;
 
-        uint64_t lock_number;
-        int32_t lk_call_count;
-        int32_t lk_expected_count;
-        int32_t lk_attempted_count;
+    int32_t lk_call_count;
+    int32_t lk_expected_count;
+    int32_t lk_attempted_count;
 
-        int32_t lock_op_ret;
-        int32_t lock_op_errno;
-        afr_lock_cbk_t lock_cbk;
-        char *domain; /* Domain on which inode/entry lock/unlock in progress.*/
+    int32_t lock_op_ret;
+    int32_t lock_op_errno;
+    char *domain; /* Domain on which inode/entry lock/unlock in progress.*/
+    int32_t lock_count;
+    char lower_locked;
+    char higher_locked;
 } afr_internal_lock_t;
 
 struct afr_reply {
-	int	valid;
-	int32_t	op_ret;
-	int32_t	op_errno;
-	dict_t *xattr;/*For xattrop*/
-	dict_t *xdata;
-	struct iatt poststat;
-	struct iatt postparent;
-	struct iatt prestat;
-	struct iatt preparent;
-	struct iatt preparent2;
-	struct iatt postparent2;
-        /* For rchecksum */
-	uint8_t checksum[MD5_DIGEST_LENGTH];
-        gf_boolean_t buf_has_zeroes;
-        /* For lookup */
-        int8_t need_heal;
+    int valid;
+    int32_t op_ret;
+    dict_t *xattr; /*For xattrop*/
+    dict_t *xdata;
+    struct iatt poststat;
+    struct iatt postparent;
+    struct iatt prestat;
+    struct iatt preparent;
+    struct iatt preparent2;
+    struct iatt postparent2;
+    int32_t op_errno;
+    /* For rchecksum */
+    uint8_t checksum[SHA256_DIGEST_LENGTH];
+    gf_boolean_t buf_has_zeroes;
+    gf_boolean_t fips_mode_rchecksum;
+    /* For lookup */
+    int8_t need_heal;
 };
 
 typedef enum {
-        AFR_FD_NOT_OPENED,
-        AFR_FD_OPENED,
-        AFR_FD_OPENING
+    AFR_FD_NOT_OPENED,
+    AFR_FD_OPENED,
+    AFR_FD_OPENING
 } afr_fd_open_status_t;
 
 typedef struct {
-        unsigned int *pre_op_done[AFR_NUM_CHANGE_LOGS];
-	int inherited[AFR_NUM_CHANGE_LOGS];
-	int on_disk[AFR_NUM_CHANGE_LOGS];
-        afr_fd_open_status_t *opened_on; /* which subvolumes the fd is open on */
-
-        unsigned int *lock_piggyback;
-        unsigned int *lock_acquired;
-
-        int flags;
-
-	/* used for delayed-post-op optimization */
-	pthread_mutex_t    delay_lock;
-	gf_timer_t        *delay_timer;
-	call_frame_t      *delay_frame;
-
-	/* set if any write on this fd was a non stable write
-	   (i.e, without O_SYNC or O_DSYNC)
-	*/
-	gf_boolean_t      witnessed_unstable_write;
-
-	/* @open_fd_count:
-	   Number of open FDs queried from the server, as queried through
-	   xdata in FOPs. Currently, used to decide if eager-locking must be
-	   temporarily disabled.
-	*/
-        uint32_t        open_fd_count;
-
-
-	/* list of frames currently in progress */
-	struct list_head  eager_locked;
-
-	/* the subvolume on which the latest sequence of readdirs (starting
-	   at offset 0) has begun. Till the next readdir request with 0 offset
-	   arrives, we continue to read off this subvol.
-	*/
-	int readdir_subvol;
+    afr_fd_open_status_t *opened_on; /* which subvolumes the fd is open on */
+    int flags;
+
+    /* the subvolume on which the latest sequence of readdirs (starting
+       at offset 0) has begun. Till the next readdir request with 0 offset
+       arrives, we continue to read off this subvol.
+    */
+    int readdir_subvol;
+    /* lock-healing related members. */
+    gf_boolean_t is_fd_bad;
+    afr_lk_heal_info_t *lk_heal_info;
+
 } afr_fd_ctx_t;
 
 typedef enum {
-        AFR_FOP_LOCK_PARALLEL,
-        AFR_FOP_LOCK_SERIAL,
-        AFR_FOP_LOCK_QUORUM_FAILED,
+    AFR_FOP_LOCK_PARALLEL,
+    AFR_FOP_LOCK_SERIAL,
+    AFR_FOP_LOCK_QUORUM_FAILED,
 } afr_fop_lock_state_t;
 
+typedef struct _afr_inode_lock_t {
+    /* @num_inodelks:
+       Number of inodelks queried from the server, as queried through
+       xdata in FOPs. Currently, used to decide if eager-locking must be
+       temporarily disabled.
+    */
+    int32_t num_inodelks;
+    unsigned int event_generation;
+    gf_timer_t *delay_timer;
+    struct list_head owners;  /*Transactions that are performing fop*/
+    struct list_head post_op; /*Transactions that are done with the fop
+                               *So can not conflict with the fops*/
+    struct list_head waiting; /*Transaction that are waiting for
+                               *conflicting transactions to complete*/
+    struct list_head frozen;  /*Transactions that need to go as part of
+                               * next batch of eager-lock*/
+    gf_boolean_t release;
+    gf_boolean_t acquired;
+} afr_lock_t;
+
+typedef struct _afr_inode_ctx {
+    uint64_t read_subvol;
+    uint64_t write_subvol;
+    int lock_count;
+    int spb_choice;
+    gf_timer_t *timer;
+    unsigned int *pre_op_done[AFR_NUM_CHANGE_LOGS];
+    int inherited[AFR_NUM_CHANGE_LOGS];
+    int on_disk[AFR_NUM_CHANGE_LOGS];
+    /*Only 2 types of transactions support eager-locks now. DATA/METADATA*/
+    afr_lock_t lock[2];
+
+    /* @open_fd_count:
+       Number of open FDs queried from the server, as queried through
+       xdata in FOPs. Currently, used to decide if eager-locking must be
+       temporarily disabled.
+    */
+    uint32_t open_fd_count;
+    gf_boolean_t need_refresh;
+
+    /* set if any write on this fd was a non stable write
+       (i.e, without O_SYNC or O_DSYNC)
+    */
+    gf_boolean_t witnessed_unstable_write;
+} afr_inode_ctx_t;
+
 typedef struct _afr_local {
-	glusterfs_fop_t  op;
-        unsigned int call_count;
+    glusterfs_fop_t op;
+    unsigned int call_count;
 
-	/* @event_generation: copy of priv->event_generation taken at the
-	   time of starting the transaction. The copy is made so that we
-	   have a stable value through the various phases of the transaction.
-	*/
-	unsigned int event_generation;
+    /* @event_generation: copy of priv->event_generation taken at the
+       time of starting the transaction. The copy is made so that we
+       have a stable value through the various phases of the transaction.
+    */
+    unsigned int event_generation;
 
-        uint32_t     open_fd_count;
-        gf_boolean_t update_open_fd_count;
+    uint32_t open_fd_count;
+    int32_t num_inodelks;
 
-	gf_lkowner_t  saved_lk_owner;
+    int32_t op_ret;
+    int32_t op_errno;
 
-        int32_t op_ret;
-        int32_t op_errno;
+    int dirty[AFR_NUM_CHANGE_LOGS];
 
-        int32_t **pending;
+    int32_t **pending;
 
-	int dirty[AFR_NUM_CHANGE_LOGS];
+    loc_t loc;
+    loc_t newloc;
 
-        loc_t loc;
-        loc_t newloc;
+    fd_t *fd;
+    afr_fd_ctx_t *fd_ctx;
 
-        fd_t *fd;
-	afr_fd_ctx_t *fd_ctx;
+    /* @child_up: copy of priv->child_up taken at the time of transaction
+       start. The copy is taken so that we have a stable child_up array
+       through the phases of the transaction as priv->child_up[i] can keep
+       changing through time.
+    */
+    unsigned char *child_up;
 
-	/* @child_up: copy of priv->child_up taken at the time of transaction
-	   start. The copy is taken so that we have a stable child_up array
-	   through the phases of the transaction as priv->child_up[i] can keep
-	   changing through time.
-	*/
-        unsigned char *child_up;
+    /* @read_attempted:
+       array of flags representing subvolumes where read operations of
+       the read transaction have already been attempted. The array is
+       first pre-filled with down subvolumes, and as reads are performed
+       on other subvolumes, those are set as well. This way if the read
+       operation fails we do not retry on that subvolume again.
+    */
+    unsigned char *read_attempted;
 
-	/* @read_attempted:
-	   array of flags representing subvolumes where read operations of
-	   the read transaction have already been attempted. The array is
-	   first pre-filled with down subvolumes, and as reads are performed
-	   on other subvolumes, those are set as well. This way if the read
-	   operation fails we do not retry on that subvolume again.
-	*/
-	unsigned char *read_attempted;
+    /* @readfn:
 
-	/* @readfn:
+       pointer to function which will perform the read operation on a given
+       subvolume. Used in read transactions.
+    */
 
-	   pointer to function which will perform the read operation on a given
-	   subvolume. Used in read transactions.
-	*/
+    afr_read_txn_wind_t readfn;
 
-	afr_read_txn_wind_t readfn;
+    /* @inode:
 
-	/* @refreshed:
+       the inode on which the read txn is performed on. ref'ed and copied
+       from either fd->inode or loc.inode
+    */
 
-	   the inode was "refreshed" (i.e, pending xattrs from all subvols
-	   freshly inspected and inode ctx updated accordingly) as part of
-	   this transaction already.
-	*/
-	gf_boolean_t refreshed;
+    inode_t *inode;
 
-	/* @inode:
+    /* @parent[2]:
 
-	   the inode on which the read txn is performed on. ref'ed and copied
-	   from either fd->inode or loc.inode
-	*/
+       parent inode[s] on which directory transactions are performed.
+    */
 
-	inode_t *inode;
+    inode_t *parent;
+    inode_t *parent2;
 
-	/* @parent[2]:
+    /* @readable:
 
-	   parent inode[s] on which directory transactions are performed.
-	*/
+       array of flags representing servers from which a read can be
+       performed. This is the output of afr_inode_refresh()
+    */
+    unsigned char *readable;
+    unsigned char *readable2; /*For rename transaction*/
 
-	inode_t *parent;
-	inode_t *parent2;
+    afr_inode_refresh_cbk_t refreshfn;
 
-	/* @readable:
+    /* @refreshinode:
 
-	   array of flags representing servers from which a read can be
-	   performed. This is the output of afr_inode_refresh()
-	*/
-	unsigned char *readable;
-	unsigned char *readable2; /*For rename transaction*/
+       Inode currently getting refreshed.
+    */
+    inode_t *refreshinode;
 
-	afr_inode_refresh_cbk_t refreshfn;
+    dict_t *xattr_req;
 
-	/* @refreshinode:
+    dict_t *dict;
 
-	   Inode currently getting refreshed.
-	*/
-	inode_t *refreshinode;
+    int read_subvol; /* Current read subvolume */
 
-        /*To handle setattr/setxattr on yet to be linked inode from dht*/
-        uuid_t  refreshgfid;
+    int optimistic_change_log;
 
-	/*
-	  @pre_op_compat:
+    afr_internal_lock_t internal_lock;
 
-	  compatibility mode of pre-op. send a separate pre-op and
-	  op operations as part of transaction, rather than combining
-	*/
+    /*To handle setattr/setxattr on yet to be linked inode from dht*/
+    uuid_t refreshgfid;
 
-	gf_boolean_t pre_op_compat;
+    /* @refreshed:
 
-        dict_t  *xattr_req;
+       the inode was "refreshed" (i.e, pending xattrs from all subvols
+       freshly inspected and inode ctx updated accordingly) as part of
+       this transaction already.
+    */
+    gf_boolean_t refreshed;
 
-        afr_internal_lock_t internal_lock;
+    gf_boolean_t update_num_inodelks;
+    gf_boolean_t update_open_fd_count;
 
-        dict_t  *dict;
+    /*
+      @pre_op_compat:
 
-        int      optimistic_change_log;
-	gf_boolean_t      delayed_post_op;
+      compatibility mode of pre-op. send a separate pre-op and
+      op operations as part of transaction, rather than combining
+    */
 
-	/* Is the current writev() going to perform a stable write?
-	   i.e, is fd->flags or @flags writev param have O_SYNC or
-	   O_DSYNC?
-	*/
-	gf_boolean_t      stable_write;
+    gf_boolean_t pre_op_compat;
 
-	/* This write appended to the file. Nnot necessarily O_APPEND,
-	   just means the offset of write was at the end of file.
-	*/
-	gf_boolean_t      append_write;
+    /* Is the current writev() going to perform a stable write?
+       i.e, is fd->flags or @flags writev param have O_SYNC or
+       O_DSYNC?
+    */
+    gf_boolean_t stable_write;
 
-        /*
-          This struct contains the arguments for the "continuation"
-          (scheme-like) of fops
-        */
+    /* This write appended to the file. Nnot necessarily O_APPEND,
+       just means the offset of write was at the end of file.
+    */
+    gf_boolean_t append_write;
 
+    /*
+      This struct contains the arguments for the "continuation"
+      (scheme-like) of fops
+    */
+
+    struct {
         struct {
-                struct {
-                        gf_boolean_t needs_fresh_lookup;
-                        uuid_t gfid_req;
-                } lookup;
-
-                struct {
-                        unsigned char buf_set;
-                        struct statvfs buf;
-                } statfs;
-
-                struct {
-                        int32_t flags;
-                } open;
-
-                struct {
-                        int32_t cmd;
-                        struct gf_flock user_flock;
-                        struct gf_flock ret_flock;
-                        unsigned char *locked_nodes;
-                } lk;
-
-                /* inode read */
-
-                struct {
-                        int32_t mask;
-                        int last_index;  /* index of the child we tried previously */
-                } access;
-
-                struct {
-                        int last_index;
-                } stat;
-
-                struct {
-                        int last_index;
-                } fstat;
-
-                struct {
-                        size_t size;
-                        int last_index;
-                } readlink;
-
-                struct {
-                        char *name;
-                        int last_index;
-                        long xattr_len;
-                } getxattr;
-
-                struct {
-                        size_t size;
-                        off_t offset;
-                        int last_index;
-                        uint32_t flags;
-                } readv;
-
-                /* dir read */
-
-                struct {
-                        int success_count;
-                        int32_t op_ret;
-                        int32_t op_errno;
-
-                        uint32_t *checksum;
-                } opendir;
-
-                struct {
-                        int32_t op_ret;
-                        int32_t op_errno;
-                        size_t size;
-                        off_t offset;
-                        dict_t *dict;
-                        gf_boolean_t failed;
-                        int last_index;
-                } readdir;
-                /* inode write */
-
-                struct {
-                        struct iatt prebuf;
-                        struct iatt postbuf;
-                } inode_wfop; //common structure for all inode-write-fops
-
-                struct {
-                        int32_t op_ret;
-
-                        struct iovec *vector;
-                        struct iobref *iobref;
-                        int32_t count;
-                        off_t offset;
-                        uint32_t flags;
-                } writev;
-
-                struct {
-                        off_t offset;
-                } truncate;
-
-                struct {
-                        off_t offset;
-                } ftruncate;
-
-                struct {
-                        struct iatt in_buf;
-                        int32_t valid;
-                } setattr;
-
-                struct {
-                        struct iatt in_buf;
-                        int32_t valid;
-                } fsetattr;
-
-                struct {
-                        dict_t *dict;
-                        int32_t flags;
-                } setxattr;
-
-                struct {
-                        dict_t *dict;
-                        int32_t flags;
-                } fsetxattr;
-
-                struct {
-                        char *name;
-                } removexattr;
-
-                struct {
-                        dict_t *xattr;
-                        gf_xattrop_flags_t optype;
-                } xattrop;
-
-                /* dir write */
-
-                struct {
-                        inode_t *inode;
-                        struct iatt buf;
-                        struct iatt preparent;
-                        struct iatt postparent;
-                        struct iatt prenewparent;
-                        struct iatt postnewparent;
-                } dir_fop; //common structure for all dir fops
-
-                struct {
-                        fd_t *fd;
-                        dict_t *params;
-                        int32_t flags;
-                        mode_t mode;
-                } create;
-
-                struct {
-                        dev_t dev;
-                        mode_t mode;
-                        dict_t *params;
-                } mknod;
-
-                struct {
-                        int32_t mode;
-                        dict_t *params;
-                } mkdir;
-
-                struct {
-                        int flags;
-                } rmdir;
-
-                struct {
-                        dict_t *params;
-                        char *linkpath;
-                } symlink;
-
-		struct {
-			int32_t mode;
-			off_t offset;
-			size_t len;
-		} fallocate;
-
-		struct {
-			off_t offset;
-			size_t len;
-		} discard;
-
-                struct {
-                        off_t offset;
-                        off_t len;
-                        struct iatt prebuf;
-                        struct iatt postbuf;
-                } zerofill;
-
-                struct {
-                        char *volume;
-                        int32_t cmd;
-                        int32_t in_cmd;
-                        struct gf_flock in_flock;
-                        struct gf_flock flock;
-                        void *xdata;
-                } inodelk;
-
-                struct {
-                        char *volume;
-                        char *basename;
-                        entrylk_cmd in_cmd;
-                        entrylk_cmd cmd;
-                        entrylk_type type;
-                        void *xdata;
-                } entrylk;
-
-                struct {
-                        off_t offset;
-                        gf_seek_what_t what;
-                } seek;
-
-        } cont;
+            struct statvfs buf;
+            unsigned char buf_set;
+        } statfs;
 
         struct {
-                off_t start, len;
+            fd_t *fd;
+            int32_t flags;
+        } open;
 
-                gf_boolean_t    eager_lock_on;
-                int *eager_lock;
+        struct {
+            struct gf_flock user_flock;
+            struct gf_flock ret_flock;
+            unsigned char *locked_nodes;
+            int32_t cmd;
+            /*For lock healing only.*/
+            unsigned char *dom_locked_nodes;
+            int32_t *dom_lock_op_ret;
+            int32_t *dom_lock_op_errno;
+            struct gf_flock *getlk_rsp;
+        } lk;
+
+        /* inode read */
 
-                char *basename;
-                char *new_basename;
+        struct {
+            int32_t mask;
+            int last_index; /* index of the child we tried previously */
+        } access;
 
-                loc_t parent_loc;
-                loc_t new_parent_loc;
+        struct {
+            int last_index;
+        } stat;
 
-                afr_transaction_type type;
+        struct {
+            int last_index;
+        } fstat;
 
-		/* stub to resume on destruction
-		   of the transaction frame */
-		call_stub_t      *resume_stub;
+        struct {
+            size_t size;
+            int last_index;
+        } readlink;
 
-		struct list_head  eager_locked;
+        struct {
+            char *name;
+            long xattr_len;
+            int last_index;
+        } getxattr;
 
-                unsigned char   *pre_op;
+        struct {
+            size_t size;
+            off_t offset;
+            int last_index;
+            uint32_t flags;
+        } readv;
 
-                /* For arbiter configuration only. */
-                dict_t **pre_op_xdata;
-                unsigned char *pre_op_sources;
+        /* dir read */
 
-		/* @failed_subvols: subvolumes on which a pre-op or a
-                    FOP failed. */
-                unsigned char   *failed_subvols;
+        struct {
+            uint32_t *checksum;
+            int success_count;
+            int32_t op_ret;
+            int32_t op_errno;
+        } opendir;
 
-		/* @dirtied: flag which indicates whether we set dirty flag
-		   in the OP. Typically true when we are performing operation
-		   on more than one subvol and optimistic changelog is disabled
+        struct {
+            int32_t op_ret;
+            int32_t op_errno;
+            size_t size;
+            off_t offset;
+            dict_t *dict;
+            int last_index;
+            gf_boolean_t failed;
+        } readdir;
+        /* inode write */
 
-		   A 'true' value set in @dirtied flag means an 'undirtying'
-		   has to be done in POST-OP phase.
-		*/
-		gf_boolean_t  dirtied;
+        struct {
+            struct iatt prebuf;
+            struct iatt postbuf;
+        } inode_wfop;  // common structure for all inode-write-fops
 
-		/* @inherited: flag which indicates that the dirty flags
-		   of the previous transaction were inherited
-		*/
-		gf_boolean_t  inherited;
+        struct {
+            struct iovec *vector;
+            struct iobref *iobref;
+            off_t offset;
+            int32_t op_ret;
+            int32_t count;
+            uint32_t flags;
+        } writev;
 
-		/*
-		  @no_uninherit: flag which indicates that a pre_op_uninherit()
-		  must _not_ be attempted (and returned as failure) always. This
-		  flag is set when a hard pre-op is performed, but not accounted
-		  for it in fd_ctx->on_disk[]. Such transactions are "isolated"
-		  from the pre-op piggybacking entirely and therefore uninherit
-		  must not be attempted.
-		*/
-		gf_boolean_t no_uninherit;
+        struct {
+            off_t offset;
+        } truncate;
 
-		/* @uninherit_done:
-		   @uninherit_value:
+        struct {
+            off_t offset;
+        } ftruncate;
 
-		   The above pair variables make pre_op_uninherit() idempotent.
-		   Both are FALSE initially. The first call to pre_op_uninherit
-		   sets @uninherit_done to TRUE and the return value to
-		   @uninherit_value. Further calls will check for @uninherit_done
-		   to be TRUE and if so will simply return @uninherit_value.
-		*/
-		gf_boolean_t uninherit_done;
-		gf_boolean_t uninherit_value;
+        struct {
+            struct iatt in_buf;
+            int32_t valid;
+        } setattr;
 
-                gf_boolean_t in_flight_sb; /* Indicator for occurrence of
-                                              split-brain while in the middle of
-                                              a txn. */
-                int32_t in_flight_sb_errno; /* This is where the cause of the
-                                               failure on the last good copy of
-                                               the file is stored.
-                                               */
+        struct {
+            struct iatt in_buf;
+            int32_t valid;
+        } fsetattr;
 
-		/* @changelog_resume: function to be called after changlogging
-		   (either pre-op or post-op) is done
-		*/
-		afr_changelog_resume_t changelog_resume;
+        struct {
+            dict_t *dict;
+            int32_t flags;
+        } setxattr;
 
-                call_frame_t *main_frame;
+        struct {
+            dict_t *dict;
+            int32_t flags;
+        } fsetxattr;
 
-                int (*wind) (call_frame_t *frame, xlator_t *this, int subvol);
+        struct {
+            char *name;
+        } removexattr;
 
-                int (*fop) (call_frame_t *frame, xlator_t *this);
+        struct {
+            dict_t *xattr;
+            gf_xattrop_flags_t optype;
+        } xattrop;
 
-                int (*done) (call_frame_t *frame, xlator_t *this);
+        /* dir write */
 
-                int (*resume) (call_frame_t *frame, xlator_t *this);
+        struct {
+            inode_t *inode;
+            struct iatt buf;
+            struct iatt preparent;
+            struct iatt postparent;
+            struct iatt prenewparent;
+            struct iatt postnewparent;
+        } dir_fop;  // common structure for all dir fops
 
-                int (*unwind) (call_frame_t *frame, xlator_t *this);
+        struct {
+            fd_t *fd;
+            dict_t *params;
+            int32_t flags;
+            mode_t mode;
+        } create;
 
-                /* post-op hook */
-        } transaction;
+        struct {
+            dict_t *params;
+            dev_t dev;
+            mode_t mode;
+        } mknod;
 
-	syncbarrier_t barrier;
+        struct {
+            dict_t *params;
+            int32_t mode;
+        } mkdir;
 
-        /* extra data for fops */
-        dict_t         *xdata_req;
-        dict_t         *xdata_rsp;
+        struct {
+            dict_t *params;
+            char *linkpath;
+        } symlink;
 
-        dict_t         *xattr_rsp; /*for [f]xattrop*/
+        struct {
+            off_t offset;
+            size_t len;
+            int32_t mode;
+        } fallocate;
 
-        mode_t          umask;
-        int             xflag;
-        gf_boolean_t    do_discovery;
-	struct afr_reply *replies;
+        struct {
+            off_t offset;
+            size_t len;
+        } discard;
 
-        /* For  client side background heals. */
-        struct list_head healer;
-        call_frame_t *heal_frame;
+        struct {
+            off_t offset;
+            off_t len;
+            struct iatt prebuf;
+            struct iatt postbuf;
+        } zerofill;
 
-        gf_boolean_t need_full_crawl;
-        gf_boolean_t compound;
-        afr_fop_lock_state_t fop_lock_state;
-        compound_args_t *c_args;
+        struct {
+            char *volume;
+            int32_t cmd;
+            int32_t in_cmd;
+            struct gf_flock in_flock;
+            struct gf_flock flock;
+            void *xdata;
+        } inodelk;
 
-        gf_boolean_t is_read_txn;
-} afr_local_t;
+        struct {
+            char *volume;
+            char *basename;
+            void *xdata;
+            entrylk_cmd in_cmd;
+            entrylk_cmd cmd;
+            entrylk_type type;
+        } entrylk;
 
+        struct {
+            off_t offset;
+            gf_seek_what_t what;
+        } seek;
 
-typedef struct _afr_inode_ctx {
-        uint64_t        read_subvol;
-        int             spb_choice;
-        gf_timer_t      *timer;
-        gf_boolean_t    need_refresh;
-} afr_inode_ctx_t;
+        struct {
+            struct gf_lease user_lease;
+            struct gf_lease ret_lease;
+            unsigned char *locked_nodes;
+        } lease;
+
+        struct {
+            int flags;
+        } rmdir;
+
+        struct {
+            int32_t datasync;
+        } fsync;
+
+        struct {
+            uuid_t gfid_req;
+            gf_boolean_t needs_fresh_lookup;
+        } lookup;
+
+    } cont;
+
+    struct {
+        char *basename;
+        char *new_basename;
+
+        loc_t parent_loc;
+        loc_t new_parent_loc;
+
+        /* stub to resume on destruction
+           of the transaction frame */
+        call_stub_t *resume_stub;
+
+        struct list_head owner_list;
+        struct list_head wait_list;
+
+        unsigned char *pre_op;
+
+        /* Changelog xattr dict for [f]xattrop*/
+        dict_t **changelog_xdata;
+        unsigned char *pre_op_sources;
+
+        /* @failed_subvols: subvolumes on which a pre-op or a
+            FOP failed. */
+        unsigned char *failed_subvols;
+
+        call_frame_t *main_frame; /*Fop frame*/
+        call_frame_t *frame;      /*Transaction frame*/
+
+        int (*wind)(call_frame_t *frame, xlator_t *this, int subvol);
+
+        int (*unwind)(call_frame_t *frame, xlator_t *this);
+
+        off_t start, len;
+
+        afr_transaction_type type;
+
+        int32_t in_flight_sb_errno; /* This is where the cause of the
+                                       failure on the last good copy of
+                                       the file is stored.
+                                       */
+
+        /* @changelog_resume: function to be called after changlogging
+           (either pre-op or post-op) is done
+        */
+        afr_changelog_resume_t changelog_resume;
+
+        gf_boolean_t eager_lock_on;
+        gf_boolean_t do_eager_unlock;
+
+        /* @dirtied: flag which indicates whether we set dirty flag
+           in the OP. Typically true when we are performing operation
+           on more than one subvol and optimistic changelog is disabled
+
+           A 'true' value set in @dirtied flag means an 'undirtying'
+           has to be done in POST-OP phase.
+        */
+        gf_boolean_t dirtied;
+
+        /* @inherited: flag which indicates that the dirty flags
+           of the previous transaction were inherited
+        */
+        gf_boolean_t inherited;
+
+        /*
+          @no_uninherit: flag which indicates that a pre_op_uninherit()
+          must _not_ be attempted (and returned as failure) always. This
+          flag is set when a hard pre-op is performed, but not accounted
+          for it in fd_ctx->on_disk[]. Such transactions are "isolated"
+          from the pre-op piggybacking entirely and therefore uninherit
+          must not be attempted.
+        */
+        gf_boolean_t no_uninherit;
+
+        gf_boolean_t in_flight_sb; /* Indicator for occurrence of
+                                      split-brain while in the middle of
+                                      a txn. */
+
+        /* @uninherit_done:
+           @uninherit_value:
+
+           The above pair variables make pre_op_uninherit() idempotent.
+           Both are FALSE initially. The first call to pre_op_uninherit
+           sets @uninherit_done to TRUE and the return value to
+           @uninherit_value. Further calls will check for @uninherit_done
+           to be TRUE and if so will simply return @uninherit_value.
+        */
+        gf_boolean_t uninherit_done;
+        gf_boolean_t uninherit_value;
+
+        gf_boolean_t disable_delayed_post_op;
+    } transaction;
+
+    syncbarrier_t barrier;
+
+    /* extra data for fops */
+    dict_t *xdata_req;
+    dict_t *xdata_rsp;
+
+    dict_t *xattr_rsp; /*for [f]xattrop*/
+
+    mode_t umask;
+    int xflag;
+    struct afr_reply *replies;
+
+    /* For  client side background heals. */
+    struct list_head healer;
+    call_frame_t *heal_frame;
+
+    afr_inode_ctx_t *inode_ctx;
+
+    /*For thin-arbiter transactions.*/
+    int ta_failed_subvol;
+    int ta_event_gen;
+    struct list_head ta_waitq;
+    struct list_head ta_onwireq;
+    afr_ta_fop_state_t fop_state;
+    afr_fop_lock_state_t fop_lock_state;
+    gf_lkowner_t saved_lk_owner;
+    unsigned char read_txn_query_child;
+    unsigned char ta_child_up;
+    gf_boolean_t do_discovery;
+    gf_boolean_t need_full_crawl;
+    gf_boolean_t is_read_txn;
+    gf_boolean_t is_new_entry;
+} afr_local_t;
 
 typedef struct afr_spbc_timeout {
-        call_frame_t *frame;
-        gf_boolean_t d_spb;
-        gf_boolean_t m_spb;
-        loc_t        *loc;
-        int          spb_child_index;
+    call_frame_t *frame;
+    loc_t *loc;
+    int spb_child_index;
+    gf_boolean_t d_spb;
+    gf_boolean_t m_spb;
 } afr_spbc_timeout_t;
 
 typedef struct afr_spb_status {
-        call_frame_t *frame;
-        loc_t        *loc;
+    call_frame_t *frame;
+    loc_t *loc;
 } afr_spb_status_t;
 
 typedef struct afr_empty_brick_args {
-        call_frame_t *frame;
-        loc_t loc;
-        int empty_index;
-        char *op_type;
+    call_frame_t *frame;
+    char *op_type;
+    loc_t loc;
+    int empty_index;
 } afr_empty_brick_args_t;
 
 typedef struct afr_read_subvol_args {
-        ia_type_t ia_type;
-        uuid_t gfid;
+    ia_type_t ia_type;
+    uuid_t gfid;
 } afr_read_subvol_args_t;
 
 typedef struct afr_granular_esh_args {
-        fd_t *heal_fd;
-        xlator_t *xl;
-        call_frame_t *frame;
-        gf_boolean_t mismatch; /* flag to represent occurrence of type/gfid
-                                  mismatch */
+    fd_t *heal_fd;
+    xlator_t *xl;
+    call_frame_t *frame;
+    gf_boolean_t mismatch; /* flag to represent occurrence of type/gfid
+                              mismatch */
 } afr_granular_esh_args_t;
 
 int
-afr_inode_get_readable (call_frame_t *frame, inode_t *inode, xlator_t *this,
-                        unsigned char *readable, int *event_p, int type);
+afr_inode_get_readable(call_frame_t *frame, inode_t *inode, xlator_t *this,
+                       unsigned char *readable, int *event_p, int type);
 int
-afr_inode_read_subvol_get (inode_t *inode, xlator_t *this,
-			   unsigned char *data_subvols,
-			   unsigned char *metadata_subvols,
-			   int *event_generation);
+afr_inode_read_subvol_get(inode_t *inode, xlator_t *this,
+                          unsigned char *data_subvols,
+                          unsigned char *metadata_subvols,
+                          int *event_generation);
 int
-__afr_inode_read_subvol_get (inode_t *inode, xlator_t *this,
-			     unsigned char *data_subvols,
-			     unsigned char *metadata_subvols,
-			     int *event_generation);
+__afr_inode_read_subvol_get(inode_t *inode, xlator_t *this,
+                            unsigned char *data_subvols,
+                            unsigned char *metadata_subvols,
+                            int *event_generation);
 
 int
-__afr_inode_read_subvol_set (inode_t *inode, xlator_t *this,
-			     unsigned char *data_subvols,
-			     unsigned char *metadata_subvol,
-			     int event_generation);
+__afr_inode_read_subvol_set(inode_t *inode, xlator_t *this,
+                            unsigned char *data_subvols,
+                            unsigned char *metadata_subvol,
+                            int event_generation);
 int
-afr_inode_read_subvol_set (inode_t *inode, xlator_t *this,
-			   unsigned char *data_subvols,
-			   unsigned char *metadata_subvols,
-			   int event_generation);
+afr_inode_read_subvol_set(inode_t *inode, xlator_t *this,
+                          unsigned char *data_subvols,
+                          unsigned char *metadata_subvols,
+                          int event_generation);
 
 int
-afr_inode_event_gen_reset (inode_t *inode, xlator_t *this);
+__afr_inode_need_refresh_set(inode_t *inode, xlator_t *this);
 
 int
-afr_read_subvol_select_by_policy (inode_t *inode, xlator_t *this,
-				  unsigned char *readable,
-                                  afr_read_subvol_args_t *args);
+afr_inode_need_refresh_set(inode_t *inode, xlator_t *this);
 
 int
-afr_inode_read_subvol_type_get (inode_t *inode, xlator_t *this,
-				unsigned char *readable, int *event_p,
-				int type);
+afr_read_subvol_select_by_policy(inode_t *inode, xlator_t *this,
+                                 unsigned char *readable,
+                                 afr_read_subvol_args_t *args);
+
+int
+afr_inode_read_subvol_type_get(inode_t *inode, xlator_t *this,
+                               unsigned char *readable, int *event_p, int type);
 int
-afr_read_subvol_get (inode_t *inode, xlator_t *this, int *subvol_p,
-                     unsigned char *readables,
-		     int *event_p, afr_transaction_type type,
-                     afr_read_subvol_args_t *args);
+afr_read_subvol_get(inode_t *inode, xlator_t *this, int *subvol_p,
+                    unsigned char *readables, int *event_p,
+                    afr_transaction_type type, afr_read_subvol_args_t *args);
 
-#define afr_data_subvol_get(i, t, s, r, e, a) \
-	afr_read_subvol_get(i, t, s, r, e, AFR_DATA_TRANSACTION, a)
+#define afr_data_subvol_get(i, t, s, r, e, a)                                  \
+    afr_read_subvol_get(i, t, s, r, e, AFR_DATA_TRANSACTION, a)
 
-#define afr_metadata_subvol_get(i, t, s, r, e, a) \
-	afr_read_subvol_get(i, t, s, r, e, AFR_METADATA_TRANSACTION, a)
+#define afr_metadata_subvol_get(i, t, s, r, e, a)                              \
+    afr_read_subvol_get(i, t, s, r, e, AFR_METADATA_TRANSACTION, a)
 
 int
-afr_inode_refresh (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                   uuid_t gfid, afr_inode_refresh_cbk_t cbk);
+afr_inode_refresh(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                  uuid_t gfid, afr_inode_refresh_cbk_t cbk);
 
 int32_t
-afr_notify (xlator_t *this, int32_t event, void *data, void *data2);
+afr_notify(xlator_t *this, int32_t event, void *data, void *data2);
 
 int
-xattr_is_equal (dict_t *this, char *key1, data_t *value1, void *data);
+xattr_is_equal(dict_t *this, char *key1, data_t *value1, void *data);
 
 int
-afr_init_entry_lockee (afr_entry_lockee_t *lockee, afr_local_t *local,
-                       loc_t *loc, char *basename, int child_count);
+afr_add_entry_lockee(afr_local_t *local, loc_t *loc, char *basename,
+                     int child_count);
+
+int
+afr_add_inode_lockee(afr_local_t *local, int child_count);
 
 void
-afr_entry_lockee_cleanup (afr_internal_lock_t *int_lock);
+afr_lockees_cleanup(afr_internal_lock_t *int_lock);
 
 int
-afr_attempt_lock_recovery (xlator_t *this, int32_t child_index);
+afr_attempt_lock_recovery(xlator_t *this, int32_t child_index);
 
 int
-afr_mark_locked_nodes (xlator_t *this, fd_t *fd,
-                       unsigned char *locked_nodes);
+afr_mark_locked_nodes(xlator_t *this, fd_t *fd, unsigned char *locked_nodes);
 
 void
-afr_set_lk_owner (call_frame_t *frame, xlator_t *this, void *lk_owner);
+afr_set_lk_owner(call_frame_t *frame, xlator_t *this, void *lk_owner);
 
 int
-afr_set_lock_number (call_frame_t *frame, xlator_t *this);
+afr_set_lock_number(call_frame_t *frame, xlator_t *this);
 
 int32_t
-afr_unlock (call_frame_t *frame, xlator_t *this);
-
-int
-afr_nonblocking_entrylk (call_frame_t *frame, xlator_t *this);
-
-int
-afr_nonblocking_inodelk (call_frame_t *frame, xlator_t *this);
+afr_unlock(call_frame_t *frame, xlator_t *this);
 
 int
-afr_blocking_lock (call_frame_t *frame, xlator_t *this);
+afr_lock_nonblocking(call_frame_t *frame, xlator_t *this);
 
 int
-afr_internal_lock_finish (call_frame_t *frame, xlator_t *this);
+afr_blocking_lock(call_frame_t *frame, xlator_t *this);
 
 int
-afr_lk_transfer_datalock (call_frame_t *dst, call_frame_t *src, char *dom,
-                          unsigned int child_count);
+afr_internal_lock_finish(call_frame_t *frame, xlator_t *this);
 
 int
-__afr_fd_ctx_set (xlator_t *this, fd_t *fd);
+__afr_fd_ctx_set(xlator_t *this, fd_t *fd);
 
 afr_fd_ctx_t *
-afr_fd_ctx_get (fd_t *fd, xlator_t *this);
+afr_fd_ctx_get(fd_t *fd, xlator_t *this);
 
 int
-afr_build_parent_loc (loc_t *parent, loc_t *child, int32_t *op_errno);
+afr_build_parent_loc(loc_t *parent, loc_t *child, int32_t *op_errno);
 
 int
-afr_locked_nodes_count (unsigned char *locked_nodes, int child_count);
+afr_locked_nodes_count(unsigned char *locked_nodes, int child_count);
 
 int
-afr_replies_interpret (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                       gf_boolean_t *start_heal);
+afr_replies_interpret(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                      gf_boolean_t *start_heal);
 
 void
-afr_local_replies_wipe (afr_local_t *local, afr_private_t *priv);
+afr_local_replies_wipe(afr_local_t *local, afr_private_t *priv);
 
 void
-afr_local_cleanup (afr_local_t *local, xlator_t *this);
+afr_local_cleanup(afr_local_t *local, xlator_t *this);
 
 int
-afr_frame_return (call_frame_t *frame);
+afr_frame_return(call_frame_t *frame);
 
 int
-afr_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-          fd_t *fd, dict_t *xdata);
+afr_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+         fd_t *fd, dict_t *xdata);
 
 void
-afr_local_transaction_cleanup (afr_local_t *local, xlator_t *this);
+afr_local_transaction_cleanup(afr_local_t *local, xlator_t *this);
 
 int
-afr_cleanup_fd_ctx (xlator_t *this, fd_t *fd);
-
-#define AFR_STACK_UNWIND(fop, frame, op_ret, op_errno, params ...)\
-        do {                                                    \
-                afr_local_t *__local = NULL;                    \
-                xlator_t    *__this = NULL;                     \
-                int32_t     __op_ret   = 0;                     \
-                int32_t     __op_errno = 0;                     \
-                                                                \
-                __op_ret = op_ret;                              \
-                __op_errno = op_errno;                          \
-                if (frame) {                                    \
-                        __local = frame->local;                 \
-                        __this = frame->this;                   \
-                        afr_handle_inconsistent_fop (frame, &__op_ret,\
-                                                     &__op_errno);\
-                        frame->local = NULL;                    \
-                }                                               \
-                                                                \
-                STACK_UNWIND_STRICT (fop, frame, __op_ret,      \
-                                     __op_errno, params);       \
-                if (__local) {                                  \
-                        afr_local_cleanup (__local, __this);    \
-                        mem_put (__local);                      \
-                }                                               \
-        } while (0)
-
-#define AFR_STACK_DESTROY(frame)                                \
-        do {                                                    \
-                afr_local_t *__local = NULL;                    \
-                xlator_t    *__this = NULL;                     \
-                __local = frame->local;                         \
-                __this = frame->this;                           \
-                frame->local = NULL;                            \
-                STACK_DESTROY (frame->root);                    \
-                if (__local) {                                  \
-                        afr_local_cleanup (__local, __this);    \
-                        mem_put (__local);                      \
-                }                                               \
-        } while (0);
-
-#define AFR_FRAME_INIT(frame, op_errno)				       \
-	({frame->local = mem_get0 (THIS->local_pool);		       \
-	if (afr_local_init (frame->local, THIS->private, &op_errno)) { \
-		afr_local_cleanup (frame->local, THIS);		       \
-		mem_put (frame->local);				       \
-		frame->local = NULL; };				       \
-	frame->local;})
-
-#define AFR_STACK_RESET(frame)                                         \
-        do {                                                           \
-                afr_local_t *__local = NULL;                           \
-                xlator_t    *__this = NULL;                            \
-                __local = frame->local;                                \
-                __this = frame->this;                                  \
-                frame->local = NULL;                                   \
-                int __opr;                                             \
-                STACK_RESET (frame->root);                             \
-                if (__local) {                                         \
-                        afr_local_cleanup (__local, __this);           \
-                        mem_put (__local);                             \
-                }                                                      \
-                AFR_FRAME_INIT (frame, __opr);                         \
-        } while (0)
+afr_cleanup_fd_ctx(xlator_t *this, fd_t *fd);
+
+#define AFR_STACK_UNWIND(fop, frame, op_ret, op_errno, params...)              \
+    do {                                                                       \
+        afr_local_t *__local = NULL;                                           \
+        xlator_t *__this = NULL;                                               \
+        int32_t __op_ret = 0;                                                  \
+        int32_t __op_errno = 0;                                                \
+                                                                               \
+        __op_ret = op_ret;                                                     \
+        __op_errno = op_errno;                                                 \
+        if (frame) {                                                           \
+            __local = frame->local;                                            \
+            __this = frame->this;                                              \
+            afr_handle_inconsistent_fop(frame, &__op_ret, &__op_errno);        \
+            if (__local && __local->is_read_txn)                               \
+                afr_pending_read_decrement(__this->private,                    \
+                                           __local->read_subvol);              \
+            if (__local && __local->xdata_req &&                               \
+                afr_is_lock_mode_mandatory(__local->xdata_req))                \
+                afr_dom_lock_release(frame);                                   \
+            frame->local = NULL;                                               \
+        }                                                                      \
+                                                                               \
+        STACK_UNWIND_STRICT(fop, frame, __op_ret, __op_errno, params);         \
+        if (__local) {                                                         \
+            afr_local_cleanup(__local, __this);                                \
+            mem_put(__local);                                                  \
+        }                                                                      \
+    } while (0)
+
+#define AFR_STACK_DESTROY(frame)                                               \
+    do {                                                                       \
+        afr_local_t *__local = NULL;                                           \
+        xlator_t *__this = NULL;                                               \
+        __local = frame->local;                                                \
+        __this = frame->this;                                                  \
+        frame->local = NULL;                                                   \
+        STACK_DESTROY(frame->root);                                            \
+        if (__local) {                                                         \
+            afr_local_cleanup(__local, __this);                                \
+            mem_put(__local);                                                  \
+        }                                                                      \
+    } while (0);
+
+#define AFR_FRAME_INIT(frame, op_errno)                                        \
+    ({                                                                         \
+        frame->local = mem_get0(THIS->local_pool);                             \
+        if (afr_local_init(frame->local, frame->this->private, &op_errno)) {   \
+            afr_local_cleanup(frame->local, frame->this);                      \
+            mem_put(frame->local);                                             \
+            frame->local = NULL;                                               \
+        };                                                                     \
+        frame->local;                                                          \
+    })
+
+#define AFR_STACK_RESET(frame)                                                 \
+    do {                                                                       \
+        afr_local_t *__local = NULL;                                           \
+        xlator_t *__this = NULL;                                               \
+        __local = frame->local;                                                \
+        __this = frame->this;                                                  \
+        frame->local = NULL;                                                   \
+        int __opr;                                                             \
+        STACK_RESET(frame->root);                                              \
+        if (__local) {                                                         \
+            afr_local_cleanup(__local, __this);                                \
+            mem_put(__local);                                                  \
+        }                                                                      \
+        AFR_FRAME_INIT(frame, __opr);                                          \
+    } while (0)
 
 /* allocate and return a string that is the basename of argument */
 static inline char *
-AFR_BASENAME (const char *str)
+AFR_BASENAME(const char *str)
 {
-        char *__tmp_str = NULL;
-        char *__basename_str = NULL;
-        __tmp_str = gf_strdup (str);
-        __basename_str = gf_strdup (basename (__tmp_str));
-        GF_FREE (__tmp_str);
-        return __basename_str;
+    char *__tmp_str = NULL;
+    char *__basename_str = NULL;
+    __tmp_str = gf_strdup(str);
+    __basename_str = gf_strdup(basename(__tmp_str));
+    GF_FREE(__tmp_str);
+    return __basename_str;
 }
 
 call_frame_t *
-afr_copy_frame (call_frame_t *base);
+afr_copy_frame(call_frame_t *base);
 
 int
-afr_transaction_local_init (afr_local_t *local, xlator_t *this);
+afr_transaction_local_init(afr_local_t *local, xlator_t *this);
 
 int32_t
-afr_marker_getxattr (call_frame_t *frame, xlator_t *this,
-                     loc_t *loc, const char *name,afr_local_t *local, afr_private_t *priv );
+afr_marker_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    const char *name, afr_local_t *local, afr_private_t *priv);
 
 int
-afr_local_init (afr_local_t *local, afr_private_t *priv, int32_t *op_errno);
+afr_local_init(afr_local_t *local, afr_private_t *priv, int32_t *op_errno);
 
 int
-afr_internal_lock_init (afr_internal_lock_t *lk, size_t child_count,
-                        transaction_lk_type_t lk_type);
+afr_internal_lock_init(afr_internal_lock_t *lk, size_t child_count);
 
 int
-afr_higher_errno (int32_t old_errno, int32_t new_errno);
+afr_higher_errno(int32_t old_errno, int32_t new_errno);
 
 int
-afr_final_errno (afr_local_t *local, afr_private_t *priv);
+afr_final_errno(afr_local_t *local, afr_private_t *priv);
 
 int
-afr_xattr_req_prepare (xlator_t *this, dict_t *xattr_req);
+afr_xattr_req_prepare(xlator_t *this, dict_t *xattr_req);
 
 void
-afr_fix_open (fd_t *fd, xlator_t *this);
+afr_fix_open(fd_t *fd, xlator_t *this);
 
 afr_fd_ctx_t *
-afr_fd_ctx_get (fd_t *fd, xlator_t *this);
+afr_fd_ctx_get(fd_t *fd, xlator_t *this);
 
 void
-afr_set_low_priority (call_frame_t *frame);
+afr_set_low_priority(call_frame_t *frame);
 int
-afr_child_fd_ctx_set (xlator_t *this, fd_t *fd, int32_t child,
-                      int flags);
+afr_child_fd_ctx_set(xlator_t *this, fd_t *fd, int32_t child, int flags);
 
 void
-afr_matrix_cleanup (int32_t **pending, unsigned int m);
+afr_matrix_cleanup(int32_t **pending, unsigned int m);
 
-int32_t**
-afr_matrix_create (unsigned int m, unsigned int n);
+int32_t **
+afr_matrix_create(unsigned int m, unsigned int n);
 
-int**
-afr_mark_pending_changelog (afr_private_t *priv, unsigned char *pending,
-                            dict_t *xattr, ia_type_t iat);
+int **
+afr_mark_pending_changelog(afr_private_t *priv, unsigned char *pending,
+                           dict_t *xattr, ia_type_t iat);
 
 void
-afr_filter_xattrs (dict_t *xattr);
+afr_filter_xattrs(dict_t *xattr);
 
 /*
  * Special value indicating we should use the "auto" quorum method instead of
@@ -1141,125 +1245,179 @@ afr_filter_xattrs (dict_t *xattr);
 #define AFR_QUORUM_AUTO INT_MAX
 
 int
-afr_fd_report_unstable_write (xlator_t *this, fd_t *fd);
+afr_fd_report_unstable_write(xlator_t *this, afr_local_t *local);
 
 gf_boolean_t
-afr_fd_has_witnessed_unstable_write (xlator_t *this, fd_t *fd);
-
-void
-afr_delayed_changelog_wake_resume (xlator_t *this, fd_t *fd, call_stub_t *stub);
-
-int
-afr_inodelk_init (afr_inodelk_t *lk, char *dom, size_t child_count);
-
-void
-afr_handle_open_fd_count (call_frame_t *frame, xlator_t *this);
-
-void
-afr_remove_eager_lock_stub (afr_local_t *local);
+afr_fd_has_witnessed_unstable_write(xlator_t *this, inode_t *inode);
 
 void
-afr_reply_wipe (struct afr_reply *reply);
+afr_reply_wipe(struct afr_reply *reply);
 
 void
-afr_replies_wipe (struct afr_reply *replies, int count);
+afr_replies_wipe(struct afr_reply *replies, int count);
 
 gf_boolean_t
-afr_xattrs_are_equal (dict_t *dict1, dict_t *dict2);
+afr_xattrs_are_equal(dict_t *dict1, dict_t *dict2);
 
 gf_boolean_t
-afr_is_xattr_ignorable (char *key);
+afr_is_xattr_ignorable(char *key);
 
 int
-afr_get_heal_info (call_frame_t *frame, xlator_t *this, loc_t *loc);
+afr_get_heal_info(call_frame_t *frame, xlator_t *this, loc_t *loc);
 
 int
 afr_heal_splitbrain_file(call_frame_t *frame, xlator_t *this, loc_t *loc);
 
 int
-afr_get_split_brain_status (void *opaque);
+afr_get_split_brain_status(void *opaque);
 
 int
-afr_get_split_brain_status_cbk (int ret, call_frame_t *frame, void *opaque);
+afr_get_split_brain_status_cbk(int ret, call_frame_t *frame, void *opaque);
 
 int
-afr_inode_split_brain_choice_set (inode_t *inode, xlator_t *this,
-                                  int spb_choice);
+afr_inode_split_brain_choice_set(inode_t *inode, xlator_t *this,
+                                 int spb_choice);
 int
-afr_inode_split_brain_choice_get (inode_t *inode, xlator_t *this,
-                                  int *spb_choice);
+afr_split_brain_read_subvol_get(inode_t *inode, xlator_t *this,
+                                call_frame_t *frame, int *spb_subvol);
 int
-afr_get_child_index_from_name (xlator_t *this, char *name);
+afr_get_child_index_from_name(xlator_t *this, char *name);
 
 int
-afr_is_split_brain (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                    uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb);
+afr_is_split_brain(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                   uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb);
 int
-afr_spb_choice_timeout_cancel (xlator_t *this, inode_t *inode);
+afr_spb_choice_timeout_cancel(xlator_t *this, inode_t *inode);
 
 int
-afr_set_split_brain_choice (int ret, call_frame_t *frame, void *opaque);
+afr_set_split_brain_choice(int ret, call_frame_t *frame, void *opaque);
 
 gf_boolean_t
-afr_get_need_heal (xlator_t *this);
+afr_get_need_heal(xlator_t *this);
 
 void
-afr_set_need_heal (xlator_t *this, afr_local_t *local);
+afr_set_need_heal(xlator_t *this, afr_local_t *local);
 
 int
-afr_selfheal_data_open (xlator_t *this, inode_t *inode, fd_t **fd);
+afr_selfheal_data_open(xlator_t *this, inode_t *inode, fd_t **fd);
 
 int
-afr_get_msg_id (char *op_type);
+afr_get_msg_id(char *op_type);
 
 int
-afr_set_in_flight_sb_status (xlator_t *this, afr_local_t *local,
-                             inode_t *inode);
+afr_set_in_flight_sb_status(xlator_t *this, call_frame_t *frame,
+                            inode_t *inode);
 
 int32_t
-afr_quorum_errno (afr_private_t *priv);
+afr_quorum_errno(afr_private_t *priv);
 
 gf_boolean_t
-afr_is_consistent_io_possible (afr_local_t *local, afr_private_t *priv,
-                               int32_t *op_errno);
+afr_is_consistent_io_possible(afr_local_t *local, afr_private_t *priv,
+                              int32_t *op_errno);
 void
-afr_handle_inconsistent_fop (call_frame_t *frame, int32_t *op_ret,
-                             int32_t *op_errno);
+afr_handle_inconsistent_fop(call_frame_t *frame, int32_t *op_ret,
+                            int32_t *op_errno);
 
 void
-afr_inode_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
+afr_inode_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                      struct iatt *postbuf, dict_t *xdata);
 void
-afr_process_post_writev (call_frame_t *frame, xlator_t *this);
+afr_process_post_writev(call_frame_t *frame, xlator_t *this);
 
 void
-afr_writev_unwind (call_frame_t *frame, xlator_t *this);
+afr_writev_unwind(call_frame_t *frame, xlator_t *this);
 
 void
-afr_writev_copy_outvars (call_frame_t *src_frame, call_frame_t *dst_frame);
+afr_writev_copy_outvars(call_frame_t *src_frame, call_frame_t *dst_frame);
 
 void
-afr_update_uninodelk (afr_local_t *local, afr_internal_lock_t *int_lock,
-                    int32_t child_index);
+afr_update_uninodelk(afr_local_t *local, afr_internal_lock_t *int_lock,
+                     int32_t child_index);
+afr_fd_ctx_t *
+__afr_fd_ctx_get(fd_t *fd, xlator_t *this);
+
 gf_boolean_t
-afr_can_compound_pre_op_and_op (afr_private_t *priv, glusterfs_fop_t fop);
+afr_is_inode_refresh_reqd(inode_t *inode, xlator_t *this, int event_gen1,
+                          int event_gen2);
 
-afr_compound_cbk_t
-afr_pack_fop_args (call_frame_t *frame, compound_args_t *args,
-                   glusterfs_fop_t fop, int index);
 int
-afr_is_inodelk_transaction(afr_local_t *local);
+afr_serialize_xattrs_with_delimiter(call_frame_t *frame, xlator_t *this,
+                                    char *buf, const char *default_str,
+                                    int32_t *serz_len, char delimiter);
+gf_boolean_t
+afr_is_symmetric_error(call_frame_t *frame, xlator_t *this);
 
-afr_fd_ctx_t *
-__afr_fd_ctx_get (fd_t *fd, xlator_t *this);
+int
+__afr_inode_ctx_get(xlator_t *this, inode_t *inode, afr_inode_ctx_t **ctx);
+
+uint64_t
+afr_write_subvol_get(call_frame_t *frame, xlator_t *this);
+
+int
+afr_write_subvol_set(call_frame_t *frame, xlator_t *this);
+
+int
+afr_write_subvol_reset(call_frame_t *frame, xlator_t *this);
+
+int
+afr_set_inode_local(xlator_t *this, afr_local_t *local, inode_t *inode);
+
+int
+afr_fill_ta_loc(xlator_t *this, loc_t *loc, gf_boolean_t is_gfid_based_fop);
+
+int
+afr_ta_post_op_lock(xlator_t *this, loc_t *loc);
+
+int
+afr_ta_post_op_unlock(xlator_t *this, loc_t *loc);
 
 gf_boolean_t
-afr_is_inode_refresh_reqd (inode_t *inode, xlator_t *this,
-                           int event_gen1, int event_gen2);
+afr_is_pending_set(xlator_t *this, dict_t *xdata, int type);
 
 int
-afr_serialize_xattrs_with_delimiter (call_frame_t *frame, xlator_t *this,
-                                     char *buf, const char *default_str,
-                                     int32_t *serz_len, char delimiter);
+__afr_get_up_children_count(afr_private_t *priv);
+
+call_frame_t *
+afr_ta_frame_create(xlator_t *this);
+
+gf_boolean_t
+afr_ta_has_quorum(afr_private_t *priv, afr_local_t *local);
+
+void
+afr_ta_lock_release_synctask(xlator_t *this);
+
+void
+afr_ta_locked_priv_invalidate(afr_private_t *priv);
+
+gf_boolean_t
+afr_lookup_has_quorum(call_frame_t *frame,
+                      const unsigned int up_children_count);
+
+void
+afr_mark_new_entry_changelog(call_frame_t *frame, xlator_t *this);
+
+void
+afr_handle_replies_quorum(call_frame_t *frame, xlator_t *this);
+
+gf_boolean_t
+afr_ta_dict_contains_pending_xattr(dict_t *dict, afr_private_t *priv,
+                                   int child);
+
+void
+afr_selfheal_childup(xlator_t *this, afr_private_t *priv);
+
+gf_boolean_t
+afr_is_lock_mode_mandatory(dict_t *xdata);
+
+void
+afr_dom_lock_release(call_frame_t *frame);
+
+void
+afr_fill_success_replies(afr_local_t *local, afr_private_t *priv,
+                         unsigned char *replies);
+
+gf_boolean_t
+afr_is_private_directory(afr_private_t *priv, uuid_t pargfid, const char *name,
+                         pid_t pid);
 #endif /* __AFR_H__ */
diff --git a/xlators/cluster/dht/src/Makefile.am b/xlators/cluster/dht/src/Makefile.am
index 525a214c24a..56f1f2ad7c8 100644
--- a/xlators/cluster/dht/src/Makefile.am
+++ b/xlators/cluster/dht/src/Makefile.am
@@ -1,7 +1,4 @@
 xlator_LTLIBRARIES = dht.la nufa.la switch.la
-if BUILD_GFDB
-   xlator_LTLIBRARIES += tier.la
-endif
 
 AM_CFLAGS = -Wall $(GF_CFLAGS)
 
@@ -16,41 +13,28 @@ dht_la_SOURCES = $(dht_common_source) dht.c
 
 nufa_la_SOURCES = $(dht_common_source) nufa.c
 switch_la_SOURCES = $(dht_common_source) switch.c
-tier_la_SOURCES = $(dht_common_source) tier.c tier-common.c
 
-dht_la_LDFLAGS = -module -avoid-version -export-symbols \
-	$(top_srcdir)/xlators/cluster/dht/src/dht.sym
+dht_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
 dht_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
 
-nufa_la_LDFLAGS = -module -avoid-version -export-symbols \
-	$(top_srcdir)/xlators/cluster/dht/src/nufa.sym
+nufa_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
 nufa_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
 
-switch_la_LDFLAGS = -module -avoid-version -export-symbols \
-	$(top_srcdir)/xlators/cluster/dht/src/switch.sym
+switch_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
 switch_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
 
-tier_la_LDFLAGS = -module -avoid-version -export-symbols \
-	$(top_srcdir)/xlators/cluster/dht/src/tier.sym
-tier_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
 noinst_HEADERS = dht-common.h dht-mem-types.h dht-messages.h \
-	dht-lock.h tier-common.h tier.h \
-	$(top_builddir)/xlators/lib/src/libxlator.h
+	dht-lock.h $(top_builddir)/xlators/lib/src/libxlator.h
 
 AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/libglusterfs/src/gfdb \
 	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
 	-I$(top_srcdir)/rpc/rpc-lib/src \
 	-I$(top_srcdir)/xlators/lib/src \
 	-DDATADIR=\"$(localstatedir)\" \
-	-DLIBDIR=\"$(libdir)\" \
-	-DLIBGFDB_VERSION=\"$(LIBGFDB_VERSION)\"
+	-DLIBDIR=\"$(libdir)\"
 
 CLEANFILES =
 
-EXTRA_DIST = dht.sym nufa.sym switch.sym tier.sym
-
 uninstall-local:
 	rm -f $(DESTDIR)$(xlatordir)/distribute.so
 
diff --git a/xlators/cluster/dht/src/dht-common.c b/xlators/cluster/dht/src/dht-common.c
index f6112783d50..8ba0cc4c732 100644
--- a/xlators/cluster/dht/src/dht-common.c
+++ b/xlators/cluster/dht/src/dht-common.c
@@ -8,198 +8,209 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
 
-#include "glusterfs.h"
-#include "xlator.h"
 #include "libxlator.h"
 #include "dht-common.h"
 #include "dht-lock.h"
-#include "defaults.h"
-#include "byte-order.h"
-#include "glusterfs-acl.h"
-#include "quota-common-utils.h"
-#include "upcall-utils.h"
+#include <glusterfs/byte-order.h>
+#include <glusterfs/quota-common-utils.h>
+#include <glusterfs/upcall-utils.h>
+#include "glusterfs/compat-errno.h"  // for ENODATA on BSD
+#include <glusterfs/common-utils.h>
 
 #include <sys/time.h>
 #include <libgen.h>
 #include <signal.h>
 
-int run_defrag = 0;
-
-
+static int
+dht_rmdir_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, gf_dirent_t *entries,
+                       dict_t *xdata);
 
-int dht_link2 (xlator_t *this, xlator_t *dst_node, call_frame_t *frame,
-               int ret);
+static int
+dht_link2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
 
-int
-dht_removexattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                  int ret);
+static int
+dht_set_dir_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req);
 
-int
-dht_setxattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-               int ret);
+static int
+dht_lookup_everywhere_done(call_frame_t *frame, xlator_t *this);
 
+static int
+dht_common_mark_mdsxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, dict_t *xdata);
 
-int
-dht_rmdir_readdirp_do (call_frame_t *readdirp_frame, xlator_t *this);
+static int
+dht_rmdir_unlock(call_frame_t *frame, xlator_t *this);
 
+static const char *dht_dbg_vxattrs[] = {DHT_DBG_HASHED_SUBVOL_PATTERN, NULL};
 
+/* Check the xdata to make sure EBADF has been set by client xlator */
+int32_t
+dht_check_remote_fd_failed_error(dht_local_t *local, int op_ret, int op_errno)
+{
+    if (op_ret == -1 && (op_errno == EBADF || op_errno == EBADFD) &&
+        !(local->fd_checked)) {
+        return 1;
+    }
+    return 0;
+}
 
 /* Sets the blocks and size values to fixed values. This is to be called
  * only for dirs. The caller is responsible for checking the type
  */
-int32_t dht_set_fixed_dir_stat (struct iatt *stat)
+int32_t
+dht_set_fixed_dir_stat(struct iatt *stat)
 {
-        if (stat) {
-                stat->ia_blocks = DHT_DIR_STAT_BLOCKS;
-                stat->ia_size = DHT_DIR_STAT_SIZE;
-                return 0;
-        }
-        return -1;
+    if (stat) {
+        stat->ia_blocks = DHT_DIR_STAT_BLOCKS;
+        stat->ia_size = DHT_DIR_STAT_SIZE;
+        return 0;
+    }
+    return -1;
 }
 
+/* Return true if key exists in array
+ */
+static gf_boolean_t
+dht_match_xattr(const char *key)
+{
+    char **xattrs_to_heal = get_xattrs_to_heal();
 
-int
-dht_rmdir_unlock (call_frame_t *frame, xlator_t *this);
-
-int
-dht_aggregate_quota_xattr (dict_t *dst, char *key, data_t *value)
-{
-        int              ret            = -1;
-        quota_meta_t    *meta_dst       = NULL;
-        quota_meta_t    *meta_src       = NULL;
-        int64_t         *size           = NULL;
-        int64_t          dst_dir_count  = 0;
-        int64_t          src_dir_count  = 0;
-
-        if (value == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DATA_NULL, "data value is NULL");
-                ret = -1;
-                goto out;
-        }
+    return gf_get_index_by_elem(xattrs_to_heal, (char *)key) >= 0;
+}
 
-        ret = dict_get_bin (dst, key, (void **)&meta_dst);
+static int
+dht_aggregate_quota_xattr(dict_t *dst, char *key, data_t *value)
+{
+    int ret = -1;
+    quota_meta_t *meta_dst = NULL;
+    quota_meta_t *meta_src = NULL;
+    int64_t *size = NULL;
+    int64_t dst_dir_count = 0;
+    int64_t src_dir_count = 0;
+
+    if (value == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DATA_NULL,
+               "data value is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_bin(dst, key, (void **)&meta_dst);
+    if (ret < 0) {
+        meta_dst = GF_CALLOC(1, sizeof(quota_meta_t), gf_common_quota_meta_t);
+        if (meta_dst == NULL) {
+            gf_msg("dht", GF_LOG_WARNING, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_bin(dst, key, meta_dst, sizeof(quota_meta_t));
         if (ret < 0) {
-                meta_dst = GF_CALLOC (1, sizeof (quota_meta_t),
-                                      gf_common_quota_meta_t);
-                if (meta_dst == NULL) {
-                        gf_msg ("dht", GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_NO_MEMORY,
-                                "Memory allocation failed");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_bin (dst, key, meta_dst,
-                                    sizeof (quota_meta_t));
-                if (ret < 0) {
-                        gf_msg ("dht", GF_LOG_WARNING, EINVAL,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "dht aggregate dict set failed");
-                        GF_FREE (meta_dst);
-                        ret = -1;
-                        goto out;
-                }
+            gf_msg("dht", GF_LOG_WARNING, EINVAL, DHT_MSG_DICT_SET_FAILED,
+                   "dht aggregate dict set failed");
+            GF_FREE(meta_dst);
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (value->len > sizeof (int64_t)) {
-                meta_src = data_to_bin (value);
+    if (value->len > sizeof(int64_t)) {
+        meta_src = data_to_bin(value);
 
-                meta_dst->size = hton64 (ntoh64 (meta_dst->size) +
-                                         ntoh64 (meta_src->size));
-                meta_dst->file_count = hton64 (ntoh64 (meta_dst->file_count) +
-                                               ntoh64 (meta_src->file_count));
+        meta_dst->size = hton64(ntoh64(meta_dst->size) +
+                                ntoh64(meta_src->size));
+        meta_dst->file_count = hton64(ntoh64(meta_dst->file_count) +
+                                      ntoh64(meta_src->file_count));
 
-                if (value->len > (2 * sizeof (int64_t))) {
-                        dst_dir_count = ntoh64 (meta_dst->dir_count);
-                        src_dir_count = ntoh64 (meta_src->dir_count);
+        if (value->len > (2 * sizeof(int64_t))) {
+            dst_dir_count = ntoh64(meta_dst->dir_count);
+            src_dir_count = ntoh64(meta_src->dir_count);
 
-                        if (src_dir_count > dst_dir_count)
-                                meta_dst->dir_count = meta_src->dir_count;
-                } else {
-                        meta_dst->dir_count = 0;
-                }
+            if (src_dir_count > dst_dir_count)
+                meta_dst->dir_count = meta_src->dir_count;
         } else {
-                size = data_to_bin (value);
-                meta_dst->size = hton64 (ntoh64 (meta_dst->size) +
-                                         ntoh64 (*size));
+            meta_dst->dir_count = 0;
         }
+    } else {
+        size = data_to_bin(value);
+        meta_dst->size = hton64(ntoh64(meta_dst->size) + ntoh64(*size));
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-int add_opt(char **optsp, const char *opt)
-{
-        char *newopts = NULL;
-        unsigned oldsize = 0;
-        unsigned newsize = 0;
-
-        if (*optsp == NULL)
-                newopts = gf_strdup (opt);
-        else {
-                oldsize = strlen (*optsp);
-                newsize = oldsize + 1 + strlen (opt) + 1;
-                newopts = GF_REALLOC (*optsp, newsize);
-                if (newopts)
-                        sprintf (newopts + oldsize, ",%s", opt);
-        }
-        if (newopts == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Error to add choices in buffer in add_opt");
-                return -1;
-        }
-        *optsp = newopts;
-        return 0;
+static int
+add_opt(char **optsp, const char *opt)
+{
+    char *newopts = NULL;
+    unsigned oldsize = 0;
+    unsigned newsize = 0;
+
+    if (*optsp == NULL)
+        newopts = gf_strdup(opt);
+    else {
+        oldsize = strlen(*optsp);
+        newsize = oldsize + 1 + strlen(opt) + 1;
+        newopts = GF_REALLOC(*optsp, newsize);
+        if (newopts)
+            sprintf(newopts + oldsize, ",%s", opt);
+    }
+    if (newopts == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+               "Error to add choices in buffer in add_opt");
+        return -1;
+    }
+    *optsp = newopts;
+    return 0;
 }
 
 /* Return Choice list from Split brain status */
-char *
-getChoices (const char *value)
-{
-        int i = 0;
-        char *ptr = NULL;
-        char *tok = NULL;
-        char *result = NULL;
-        char *newval = NULL;
-
-        ptr = strstr (value, "Choices:");
-        if (!ptr) {
-                result = ptr;
-                goto out;
-        }
+static char *
+getChoices(const char *value)
+{
+    int i = 0;
+    char *ptr = NULL;
+    char *tok = NULL;
+    char *result = NULL;
+    char *newval = NULL;
+
+    ptr = strstr(value, "Choices:");
+    if (!ptr) {
+        result = ptr;
+        goto out;
+    }
 
-        newval = gf_strdup (ptr);
-        if (!newval) {
-                result = newval;
-                goto out;
-        }
+    newval = gf_strdup(ptr);
+    if (!newval) {
+        result = newval;
+        goto out;
+    }
 
-        tok = strtok (newval, ":");
-        if (!tok) {
-                result = tok;
-                goto out;
-        }
+    tok = strtok(newval, ":");
+    if (!tok) {
+        result = tok;
+        goto out;
+    }
 
-        while (tok) {
-                i++;
-                if (i == 2)
-                        break;
-                tok = strtok (NULL, ":");
-        }
+    while (tok) {
+        i++;
+        if (i == 2)
+            break;
+        tok = strtok(NULL, ":");
+    }
 
-        result = gf_strdup (tok);
+    result = gf_strdup(tok);
 
 out:
-        if (newval)
-                GF_FREE (newval);
+    if (newval)
+        GF_FREE(newval);
 
-        return result;
+    return result;
 }
 
 /* This function prepare a list of choices for key
@@ -211,175 +222,225 @@ out:
 
 */
 
-int
-dht_aggregate_split_brain_xattr (dict_t *dst, char *key, data_t *value)
-{
+static int
+dht_aggregate_split_brain_xattr(dict_t *dst, char *key, data_t *value)
+{
+    int ret = 0;
+    char *oldvalue = NULL;
+    char *old_choice = NULL;
+    char *new_choice = NULL;
+    char *full_choice = NULL;
+    char *status = NULL;
+
+    if (value == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DATA_NULL,
+               "GF_AFR_SBRAIN_STATUS value is NULL");
+        ret = -1;
+        goto out;
+    }
 
-        int              ret            = 0;
-        char            *oldvalue       = NULL;
-        char            *old_choice     = NULL;
-        char            *new_choice     = NULL;
-        char            *full_choice    = NULL;
-        char            *status         = NULL;
+    ret = dict_get_str(dst, key, &oldvalue);
+    if (ret)
+        goto out;
+
+    /* skip code that is irrelevant if !oldvalue */
+    if (!oldvalue)
+        goto out;
 
-        if (value == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DATA_NULL,
-                        "GF_AFR_SBRAIN_STATUS value is NULL");
+    if (strstr(oldvalue, "not")) {
+        gf_msg_debug("dht", 0, "Need to update split-brain status in dict");
+        ret = -1;
+        goto out;
+    }
+    if (strstr(oldvalue, "metadata-split-brain:yes") &&
+        (strstr(oldvalue, "data-split-brain:no"))) {
+        if (strstr(value->data, "not")) {
+            gf_msg_debug("dht", 0, "No need to update split-brain status");
+            ret = 0;
+            goto out;
+        }
+        if (strstr(value->data, "yes") &&
+            (strncmp(oldvalue, value->data, strlen(oldvalue)))) {
+            old_choice = getChoices(oldvalue);
+            if (!old_choice) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to get choices");
                 ret = -1;
                 goto out;
-        }
+            }
 
-        ret = dict_get_str (dst, key, &oldvalue);
-        if (ret)
+            ret = add_opt(&full_choice, old_choice);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to add choices");
+                ret = -1;
                 goto out;
+            }
 
-        if (oldvalue && (strstr (oldvalue, "not"))) {
-                gf_msg_debug ("dht", 0,
-                              "Need to update split-brain status in dict");
+            new_choice = getChoices(value->data);
+            if (!new_choice) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to get choices");
                 ret = -1;
                 goto out;
-        }
-        if (oldvalue && (strstr (oldvalue, "metadata-split-brain:yes"))
-                     && (strstr (oldvalue, "data-split-brain:no"))) {
-                if (strstr (value->data, "not")) {
-                        gf_msg_debug ("dht", 0,
-                                      "No need to update split-brain status");
-                        ret = 0;
-                        goto out;
-                }
-                if (strstr (value->data, "yes") &&
-                        (strncmp (oldvalue, value->data, strlen(oldvalue)))) {
-                        old_choice = getChoices (oldvalue);
-                        if (!old_choice) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Error to get choices");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = add_opt (&full_choice, old_choice);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                         DHT_MSG_NO_MEMORY,
-                                         "Error to add choices");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        new_choice = getChoices (value->data);
-                        if (!new_choice) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Error to get choices");
-                                ret = -1;
-                                goto out;
-                        }
+            }
 
-                        ret = add_opt (&full_choice, new_choice);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                       DHT_MSG_NO_MEMORY,
-                                       "Error to add choices ");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = gf_asprintf (&status,
-                                           "data-split-brain:%s    "
-                                           "metadata-split-brain:%s   Choices:%s",
-                                           "no", "yes", full_choice);
-
-                        if (-1 == ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                                 DHT_MSG_NO_MEMORY,
-                                                "Error to prepare status ");
-                                        goto out;
-                                }
-                        ret = dict_set_dynstr (dst, key, status);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set full choice");
-                        }
-                }
+            ret = add_opt(&full_choice, new_choice);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to add choices ");
+                ret = -1;
+                goto out;
+            }
+            ret = gf_asprintf(&status,
+                              "data-split-brain:%s    "
+                              "metadata-split-brain:%s   Choices:%s",
+                              "no", "yes", full_choice);
+
+            if (-1 == ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to prepare status ");
+                goto out;
+            }
+            ret = dict_set_dynstr(dst, key, status);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set full choice");
+            }
         }
+    }
 
 out:
-        if (old_choice)
-                GF_FREE (old_choice);
-        if (new_choice)
-                GF_FREE (new_choice);
-        if (full_choice)
-                GF_FREE (full_choice);
+    if (old_choice)
+        GF_FREE(old_choice);
+    if (new_choice)
+        GF_FREE(new_choice);
+    if (full_choice)
+        GF_FREE(full_choice);
 
-        return ret;
+    return ret;
 }
 
-
-
-int
-dht_aggregate (dict_t *this, char *key, data_t *value, void *data)
+static int
+dht_aggregate(dict_t *this, char *key, data_t *value, void *data)
 {
-        dict_t          *dst            = NULL;
-        int32_t          ret            = -1;
-        data_t          *dict_data      = NULL;
+    dict_t *dst = NULL;
+    int32_t ret = -1;
+    data_t *dict_data = NULL;
 
-        dst = data;
+    dst = data;
 
-        /* compare split brain xattr only */
-        if (strcmp (key, GF_AFR_SBRAIN_STATUS) == 0) {
-                ret = dht_aggregate_split_brain_xattr(dst, key, value);
+    /* compare split brain xattr only */
+    if (strcmp(key, GF_AFR_SBRAIN_STATUS) == 0) {
+        ret = dht_aggregate_split_brain_xattr(dst, key, value);
+        if (!ret)
+            goto out;
+    } else if (strcmp(key, QUOTA_SIZE_KEY) == 0) {
+        ret = dht_aggregate_quota_xattr(dst, key, value);
+        if (ret) {
+            gf_msg("dht", GF_LOG_WARNING, 0,
+                   DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED,
+                   "Failed to aggregate quota xattr");
+        }
+        goto out;
+    } else if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0) {
+        ret = gf_get_min_stime(THIS, dst, key, value);
+        goto out;
+    } else {
+        /* compare user xattrs only */
+        if (!strncmp(key, "user.", SLEN("user."))) {
+            ret = dict_lookup(dst, key, &dict_data);
+            if (!ret && dict_data && value) {
+                ret = is_data_equal(dict_data, value);
                 if (!ret)
-                        goto out;
-        } else if (strcmp (key, QUOTA_SIZE_KEY) == 0) {
-                ret = dht_aggregate_quota_xattr (dst, key, value);
-                if (ret) {
-                        gf_msg ("dht", GF_LOG_WARNING, 0,
-                                DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED,
-                                "Failed to aggregate quota xattr");
-                }
-                goto out;
-        } else if (fnmatch (GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0) {
-                ret = gf_get_min_stime (THIS, dst, key, value);
-                goto out;
-        } else {
-                /* compare user xattrs only */
-                if (!strncmp (key, "user.", strlen ("user."))) {
-                        ret = dict_lookup (dst, key, &dict_data);
-                        if (!ret && dict_data && value) {
-                                ret = is_data_equal (dict_data, value);
-                                if (!ret)
-                                        gf_msg_debug ("dht", 0,
-                                                      "xattr mismatch for %s",
-                                                      key);
-                        }
-                }
+                    gf_msg_debug("dht", 0, "xattr mismatch for %s", key);
+            }
         }
+    }
 
-        ret = dict_set (dst, key, value);
-        if (ret) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        key);
-        }
+    ret = dict_set(dst, key, value);
+    if (ret) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s", key);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
+static void
+dht_aggregate_xattr(dict_t *dst, dict_t *src)
+{
+    if ((dst == NULL) || (src == NULL)) {
+        goto out;
+    }
 
-void
-dht_aggregate_xattr (dict_t *dst, dict_t *src)
+    dict_foreach(src, dht_aggregate, dst);
+out:
+    return;
+}
+
+/* Code to save hashed subvol on inode ctx as a mds subvol
+ */
+int
+dht_inode_ctx_mdsvol_set(inode_t *inode, xlator_t *this, xlator_t *mds_subvol)
+{
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+    uint64_t ctx_int = 0;
+    gf_boolean_t ctx_free = _gf_false;
+
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get(inode, this, &ctx_int);
+        if (ctx_int) {
+            ctx = (dht_inode_ctx_t *)(uintptr_t)ctx_int;
+            ctx->mds_subvol = mds_subvol;
+        } else {
+            ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+            if (!ctx)
+                goto unlock;
+            ctx->mds_subvol = mds_subvol;
+            ctx_free = _gf_true;
+            ctx_int = (long)ctx;
+            ret = __inode_ctx_set(inode, this, &ctx_int);
+        }
+    }
+unlock:
+    UNLOCK(&inode->lock);
+    if (ret && ctx_free)
+        GF_FREE(ctx);
+    return ret;
+}
+
+/*Code to get mds subvol from inode ctx */
+
+int
+dht_inode_ctx_mdsvol_get(inode_t *inode, xlator_t *this, xlator_t **mdsvol)
 {
-        if ((dst == NULL) || (src == NULL)) {
-                goto out;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+
+    if (!mdsvol)
+        return ret;
+
+    if (__is_root_gfid(inode->gfid)) {
+        (*mdsvol) = FIRST_CHILD(this);
+        return 0;
+    }
+
+    ret = dht_inode_ctx_get(inode, this, &ctx);
+
+    if (!ret && ctx) {
+        if (ctx->mds_subvol) {
+            *mdsvol = ctx->mds_subvol;
+            ret = 0;
+        } else {
+            ret = -1;
         }
+    }
 
-        dict_foreach (src, dht_aggregate, dst);
-out:
-        return;
+    return ret;
 }
 
 /* TODO:
@@ -389,1082 +450,1851 @@ out:
    - complete linkfile selfheal
 */
 
-
-int
-dht_lookup_selfheal_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+static int
+dht_lookup_selfheal_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           ret = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
 
-        local = frame->local;
-        ret = op_ret;
+    local = frame->local;
+    conf = this->private;
+    ret = op_ret;
 
-        FRAME_SU_UNDO (frame, dht_local_t);
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-        if (ret == 0) {
-                layout = local->selfheal.layout;
-                ret = dht_layout_set (this, local->inode, layout);
-        }
+    if (ret == 0) {
+        layout = local->selfheal.layout;
+        ret = dht_layout_set(this, local->inode, layout);
+    }
 
-        dht_inode_ctx_time_update (local->inode, this, &local->stbuf, 1);
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           &local->postparent, 1);
-        }
+    dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, &local->postparent,
+                                  1);
+    }
 
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        dht_set_fixed_dir_stat (&local->postparent);
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    dht_set_fixed_dir_stat(&local->postparent);
+    /* Delete mds xattr at the time of STACK UNWIND */
+    GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
 
-        DHT_STACK_UNWIND (lookup, frame, ret, local->op_errno, local->inode,
-                          &local->stbuf, local->xattr, &local->postparent);
+    DHT_STACK_UNWIND(lookup, frame, ret, local->op_errno, local->inode,
+                     &local->stbuf, local->xattr, &local->postparent);
 
 out:
-        return ret;
+    return ret;
 }
 
-int
-dht_discover_complete (xlator_t *this, call_frame_t *discover_frame)
-{
-        dht_local_t     *local           = NULL;
-        dht_local_t     *heal_local      = NULL;
-        call_frame_t    *main_frame      = NULL;
-        call_frame_t    *heal_frame      = NULL;
-        int              op_errno        = 0;
-        int              ret             = -1;
-        dht_layout_t    *layout          = NULL;
-        dht_conf_t      *conf            = NULL;
-        uint32_t         vol_commit_hash = 0;
-        xlator_t        *source          = NULL;
-        int              heal_path       = 0;
-        int              i               = 0;
-        loc_t            loc             = {0 };
-        int8_t           is_read_only    = 0, layout_anomalies = 0;
-
-        local = discover_frame->local;
-        layout = local->layout;
-        conf = this->private;
+static int
+dht_discover_complete(xlator_t *this, call_frame_t *discover_frame)
+{
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *main_frame = NULL;
+    call_frame_t *heal_frame = NULL;
+    int op_errno = 0;
+    int ret = -1;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    uint32_t vol_commit_hash = 0;
+    xlator_t *source = NULL;
+    int heal_path = 0;
+    int error_while_marking_mds = 0;
+    int i = 0;
+    loc_t loc = {0};
+    int8_t is_read_only = 0, layout_anomalies = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+
+    local = discover_frame->local;
+    layout = local->layout;
+    conf = this->private;
+    gf_uuid_unparse(local->gfid, gfid_local);
+
+    LOCK(&discover_frame->lock);
+    {
+        main_frame = local->main_frame;
+        local->main_frame = NULL;
+    }
+    UNLOCK(&discover_frame->lock);
+
+    if (!main_frame)
+        return 0;
+
+    /* Code to update all extended attributed from
+       subvol to local->xattr on that internal xattr has found
+    */
+    if (conf->subvolume_cnt == 1)
+        local->need_xattr_heal = 0;
+    if (local->need_xattr_heal && (local->mds_xattr)) {
+        dht_dir_set_heal_xattr(this, local, local->xattr, local->mds_xattr,
+                               NULL, NULL);
+        dict_unref(local->mds_xattr);
+        local->mds_xattr = NULL;
+    }
+
+    ret = dict_get_int8(local->xattr_req, QUOTA_READ_ONLY_KEY, &is_read_only);
+    if (ret < 0)
+        gf_msg_debug(this->name, 0, "key = %s not present in dict",
+                     QUOTA_READ_ONLY_KEY);
+
+    if (local->file_count && local->dir_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+               "path %s exists as a file on one subvolume "
+               "and directory on another. "
+               "Please fix it manually",
+               local->loc.path);
+        op_errno = EIO;
+        goto out;
+    }
 
-        LOCK(&discover_frame->lock);
-        {
-                main_frame = local->main_frame;
-                local->main_frame = NULL;
+    if (local->cached_subvol) {
+        ret = dht_layout_preset(this, local->cached_subvol, local->inode);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_SET_FAILED,
+                   "failed to set layout for subvolume %s",
+                   local->cached_subvol ? local->cached_subvol->name : "<nil>");
+            op_errno = EINVAL;
+            goto out;
+        }
+    } else {
+        ret = dht_layout_normalize(this, &local->loc, layout);
+        if ((ret < 0) || ((ret > 0) && (local->op_ret != 0))) {
+            /* either the layout is incorrect or the directory is
+             * not found even in one subvolume.
+             */
+            gf_msg_debug(this->name, 0,
+                         "normalizing failed on %s "
+                         "(overlaps/holes present: %s, "
+                         "ENOENT errors: %d)",
+                         local->loc.path, (ret < 0) ? "yes" : "no",
+                         (ret > 0) ? ret : 0);
+            layout_anomalies = 1;
+        } else if (local->inode) {
+            dht_layout_set(this, local->inode, layout);
+        }
+    }
+
+    if (!conf->vch_forced) {
+        ret = dict_get_uint32(local->xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
         }
-        UNLOCK(&discover_frame->lock);
+    }
 
-        if (!main_frame)
-                return 0;
-
-        ret = dict_get_int8 (local->xattr_req, QUOTA_READ_ONLY_KEY,
-                             &is_read_only);
-        if (ret < 0)
-                gf_msg_debug (this->name, 0, "key = %s not present in dict",
-                              QUOTA_READ_ONLY_KEY);
-
-        if (local->file_count && local->dir_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_FILE_TYPE_MISMATCH,
-                        "path %s exists as a file on one subvolume "
-                        "and directory on another. "
-                        "Please fix it manually",
-                        local->loc.path);
-                op_errno = EIO;
-                goto out;
-        }
+    if (IA_ISDIR(local->stbuf.ia_type) && !is_read_only) {
+        for (i = 0; i < layout->cnt; i++) {
+            if (!source && !layout->list[i].err)
+                source = layout->list[i].xlator;
+            if (layout->list[i].err == ENOENT ||
+                layout->list[i].err == ESTALE) {
+                heal_path = 1;
+            }
 
-        if (local->cached_subvol) {
-                ret = dht_layout_preset (this, local->cached_subvol,
-                                         local->inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_SET_FAILED,
-                                "failed to set layout for subvolume %s",
-                                local->cached_subvol ? local->cached_subvol->name : "<nil>");
-                        op_errno = EINVAL;
-                        goto out;
-                }
-        } else {
-                ret = dht_layout_normalize (this, &local->loc, layout);
-                if ((ret < 0) || ((ret > 0) && (local->op_ret != 0))) {
-                        /* either the layout is incorrect or the directory is
-                         * not found even in one subvolume.
-                         */
-                        gf_msg_debug (this->name, 0,
-                                      "normalizing failed on %s "
-                                      "(overlaps/holes present: %s, "
-                                      "ENOENT errors: %d)", local->loc.path,
-                                      (ret < 0) ? "yes" : "no", (ret > 0) ? ret : 0);
-                        layout_anomalies = 1;
-                } else if (local->inode) {
-                        dht_layout_set (this, local->inode, layout);
-                }
+            if (source && heal_path)
+                break;
         }
+    }
 
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (local->xattr,
-                                       conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
+    if (IA_ISDIR(local->stbuf.ia_type)) {
+        /* Call function to save hashed subvol on inode ctx if
+           internal mds xattr is not present and all subvols are up
+        */
+        if (!local->op_ret && !__is_root_gfid(local->stbuf.ia_gfid))
+            (void)dht_common_mark_mdsxattr(discover_frame,
+                                           &error_while_marking_mds, 1);
+
+        if (local->need_xattr_heal && !heal_path) {
+            local->need_xattr_heal = 0;
+            ret = dht_dir_xattr_heal(this, local, &op_errno);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "xattr heal failed for "
+                       "directory  gfid is %s ",
+                       gfid_local);
+            }
         }
+    }
 
-        if (IA_ISDIR (local->stbuf.ia_type) && !is_read_only) {
-                for (i = 0; i < layout->cnt; i++) {
-                       if (!source && !layout->list[i].err)
-                                source = layout->list[i].xlator;
-                        if (layout->list[i].err == ENOENT ||
-                            layout->list[i].err == ESTALE) {
-                                heal_path = 1;
-                        }
-
-                        if (source && heal_path)
-                                break;
-                }
+    if (source && (heal_path || layout_anomalies || error_while_marking_mds)) {
+        gf_uuid_copy(loc.gfid, local->gfid);
+        if (gf_uuid_is_null(loc.gfid)) {
+            goto done;
         }
 
-        if (source && (heal_path || layout_anomalies)) {
-                gf_uuid_copy (loc.gfid, local->gfid);
-                if (gf_uuid_is_null (loc.gfid)) {
-                        goto done;
-                }
+        if (local->inode)
+            loc.inode = inode_ref(local->inode);
+        else
+            goto done;
+
+        heal_frame = create_frame(this, this->ctx->pool);
+        if (heal_frame) {
+            heal_local = dht_local_init(heal_frame, &loc, NULL, 0);
+            if (!heal_local)
+                goto cleanup;
+
+            gf_uuid_copy(heal_local->gfid, local->gfid);
+            heal_frame->cookie = source;
+            heal_local->xattr = dict_ref(local->xattr);
+            heal_local->stbuf = local->stbuf;
+            heal_local->postparent = local->postparent;
+            heal_local->inode = inode_ref(loc.inode);
+            heal_local->main_frame = main_frame;
+            FRAME_SU_DO(heal_frame, dht_local_t);
+            ret = synctask_new(this->ctx->env, dht_heal_full_path,
+                               dht_heal_full_path_done, heal_frame, heal_frame);
+            if (!ret) {
+                loc_wipe(&loc);
+                return 0;
+            }
+            /*
+             * Failed to spawn the synctask. Returning
+             * with out doing heal.
+             */
+        cleanup:
+            loc_wipe(&loc);
+            DHT_STACK_DESTROY(heal_frame);
+        }
+    }
+done:
+    dht_set_fixed_dir_stat(&local->postparent);
+    /* Delete mds xattr at the time of STACK UNWIND */
+    if (local->xattr)
+        GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
 
-                if (local->inode)
-                        loc.inode = inode_ref (local->inode);
-                else
-                        goto done;
-
-               heal_frame = create_frame (this, this->ctx->pool);
-               if (heal_frame) {
-                        heal_local = dht_local_init (heal_frame, &loc,
-                                                     NULL, 0);
-                        if (!heal_local)
-                                goto cleanup;
-
-                        gf_uuid_copy (heal_local->gfid, local->gfid);
-                        heal_frame->cookie = source;
-                        heal_local->xattr = dict_ref (local->xattr);
-                        heal_local->stbuf = local->stbuf;
-                        heal_local->postparent = local->postparent;
-                        heal_local->inode = inode_ref (loc.inode);
-                        heal_local->main_frame = main_frame;
-                        FRAME_SU_DO (heal_frame, dht_local_t);
-                        ret = synctask_new (this->ctx->env,
-                                            dht_heal_full_path,
-                                            dht_heal_full_path_done,
-                                            heal_frame, heal_frame);
-                        if (!ret) {
-                                loc_wipe (&loc);
-                                return 0;
-                        }
-                        /*
-                         * Failed to spawn the synctask. Returning
-                         * with out doing heal.
-                         */
-cleanup:
-                        loc_wipe (&loc);
-                        DHT_STACK_DESTROY (heal_frame);
-                }
+    DHT_STACK_UNWIND(lookup, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
+    return 0;
 
-        }
-done:
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (lookup, main_frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
-        return 0;
 out:
-        DHT_STACK_UNWIND (lookup, main_frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
+    DHT_STACK_UNWIND(lookup, main_frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return ret;
+    return ret;
 }
 
-int
-dht_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno,
-                  inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                  struct iatt *postparent)
-{
-        dht_local_t  *local                   = NULL;
-        int           this_call_cnt           = 0;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        int           ret                     = -1;
-        int           is_dir                  = 0;
-        int           is_linkfile             = 0;
-        int           attempt_unwind          = 0;
-        dht_conf_t   *conf                    = 0;
-        char         gfid_local[GF_UUID_BUF_SIZE]  = {0};
-        char         gfid_node[GF_UUID_BUF_SIZE]  = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
+static int
+dht_common_mark_mdsxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    xlator_t *prev = cookie;
+    int ret = -1;
+    dht_conf_t *conf = 0;
+    dht_layout_t *layout = NULL;
+    int32_t mds_heal_fresh_lookup = 0;
+
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+
+    local = frame->local;
+    conf = this->private;
+    layout = local->selfheal.layout;
+    mds_heal_fresh_lookup = local->mds_heal_fresh_lookup;
+
+    if (op_ret) {
+        gf_msg_debug(this->name, op_ret,
+                     "Failed to set %s on the MDS %s for path %s. ",
+                     conf->mds_xattr_key, prev->name, local->loc.path);
+    } else {
+        /* Save mds subvol on inode ctx */
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set mds subvol on inode ctx"
+                   " %s for %s ",
+                   prev->name, local->loc.path);
+        }
+    }
+    if (!local->mds_heal_fresh_lookup && layout) {
+        dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf, 0xffffffff,
+                                 layout);
+    }
+out:
+    if (mds_heal_fresh_lookup)
+        DHT_STACK_DESTROY(frame);
+    return 0;
+}
+
+static xlator_t *
+dht_inode_get_hashed_subvol(inode_t *inode, xlator_t *this, loc_t *loc)
+{
+    char *path = NULL;
+    loc_t populate_loc = {
+        0,
+    };
+    char *name = NULL;
+    xlator_t *hash_subvol = NULL;
+
+    if (!inode)
+        return hash_subvol;
+
+    if (loc && loc->parent && loc->path) {
+        if (!loc->name) {
+            name = strrchr(loc->path, '/');
+            if (name) {
+                loc->name = name + 1;
+            } else {
+                goto out;
+            }
+        }
+        hash_subvol = dht_subvol_get_hashed(this, loc);
+        goto out;
+    }
 
-        layout = local->layout;
+    if (!gf_uuid_is_null(inode->gfid)) {
+        populate_loc.inode = inode_ref(inode);
+        populate_loc.parent = inode_parent(populate_loc.inode, NULL, NULL);
+        inode_path(populate_loc.inode, NULL, &path);
 
+        if (!path)
+            goto out;
 
-        /* Check if the gfid is different for file from other node */
-        if (!op_ret && gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
+        populate_loc.path = path;
+        if (!populate_loc.name && populate_loc.path) {
+            name = strrchr(populate_loc.path, '/');
+            if (name) {
+                populate_loc.name = name + 1;
 
-                gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
-                gf_uuid_unparse(local->gfid, gfid_local);
+            } else {
+                goto out;
+            }
+        }
+        hash_subvol = dht_subvol_get_hashed(this, &populate_loc);
+    }
+out:
+    if (populate_loc.inode)
+        loc_wipe(&populate_loc);
+    return hash_subvol;
+}
+
+/* Common function call by revalidate/selfheal code path to populate
+   internal xattr if it is not present, mark_during_fresh_lookup value
+   determines either function is call by revalidate_cbk(discover_complete)
+   or call by selfheal code path while fresh lookup.
+   Here we do wind a call serially in case of fresh lookup and
+   for other lookup code path we do wind a call parallel.The reason
+   to wind a call serially is at the time of fresh lookup directory is not
+   discovered and at the time of revalidate_lookup directory is
+   already discovered. So, revalidate codepath can race with setxattr
+   codepath and can get into spurious heals because of an ongoing setxattr.
+   This can slow down revalidates, if healing happens in foreground.
+   However, if healing happens in background, there is no direct performance
+   penalty.
+*/
+int
+dht_common_mark_mdsxattr(call_frame_t *frame, int *errst,
+                         int mark_during_fresh_lookup)
+{
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *hashed_subvol = NULL;
+    int ret = 0;
+    int i = 0;
+    dict_t *xattrs = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+    int32_t zero[1] = {0};
+    dht_conf_t *conf = 0;
+    dht_layout_t *layout = NULL;
+    dht_local_t *copy_local = NULL;
+    call_frame_t *xattr_frame = NULL;
+    gf_boolean_t vol_down = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+
+    local = frame->local;
+    conf = this->private;
+    layout = local->selfheal.layout;
+    local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
+
+    gf_uuid_unparse(local->gfid, gfid_local);
+
+    /* Code to update hashed subvol consider as a mds subvol
+       and wind a setxattr call on hashed subvol to update
+       internal xattr
+    */
+    if (!local->xattr || !dict_get(local->xattr, conf->mds_xattr_key)) {
+        /* It means no internal MDS xattr has been set yet
+         */
+        /* Check the status of all subvol are up while call
+           this function call by lookup code path
+        */
+        if (mark_during_fresh_lookup) {
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (!conf->subvolume_status[i]) {
+                    vol_down = _gf_true;
+                    break;
+                }
+            }
+            if (vol_down) {
+                gf_msg_debug(this->name, 0,
+                             "subvol %s is down. Unable to "
+                             " save mds subvol on inode for "
+                             " path %s gfid is %s ",
+                             conf->subvolumes[i]->name, local->loc.path,
+                             gfid_local);
+                goto out;
+            }
+        }
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on %s, gfid local = %s"
-                        "gfid other = %s",
-                        local->loc.path, prev->name,
-                        gfid_local, gfid_node);
+        /* Calculate hashed subvol based on inode and parent node
+         */
+        hashed_subvol = dht_inode_get_hashed_subvol(local->inode, this,
+                                                    &local->loc);
+        if (!hashed_subvol) {
+            gf_msg(this->name, GF_LOG_DEBUG, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for path %s"
+                   "gfid is %s ",
+                   local->loc.path, gfid_local);
+            if (errst)
+                (*errst) = 1;
+            ret = -1;
+            goto out;
+        }
+        xattrs = dict_new();
+        if (!xattrs) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "dict_new failed");
+            ret = -1;
+            goto out;
         }
+        /* Add internal MDS xattr on disk for hashed subvol
+         */
+        ret = dht_dict_set_array(xattrs, conf->mds_xattr_key, zero, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary"
+                   "  value:key = %s for "
+                   "path %s",
+                   conf->mds_xattr_key, local->loc.path);
+            ret = -1;
+            goto out;
+        }
+        /* Create a new frame to wind a call only while
+           this function call by revalidate_cbk code path
+           To wind a call parallel need to create a new frame
+        */
+        if (mark_during_fresh_lookup) {
+            xattr_frame = create_frame(this, this->ctx->pool);
+            if (!xattr_frame) {
+                ret = -1;
+                goto out;
+            }
+            copy_local = dht_local_init(xattr_frame, &(local->loc), NULL, 0);
+            if (!copy_local) {
+                ret = -1;
+                DHT_STACK_DESTROY(xattr_frame);
+                goto out;
+            }
+            copy_local->stbuf = local->stbuf;
+            copy_local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
+            if (!copy_local->inode)
+                copy_local->inode = inode_ref(local->inode);
+            gf_uuid_copy(copy_local->loc.gfid, local->gfid);
+            FRAME_SU_DO(xattr_frame, dht_local_t);
+            STACK_WIND_COOKIE(xattr_frame, dht_common_mark_mdsxattr_cbk,
+                              hashed_subvol, hashed_subvol,
+                              hashed_subvol->fops->setxattr, &local->loc,
+                              xattrs, 0, NULL);
+        } else {
+            STACK_WIND_COOKIE(frame, dht_common_mark_mdsxattr_cbk,
+                              (void *)hashed_subvol, hashed_subvol,
+                              hashed_subvol->fops->setxattr, &local->loc,
+                              xattrs, 0, NULL);
+        }
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "internal xattr %s is present on subvol"
+                     "on path %s gfid is %s ",
+                     conf->mds_xattr_key, local->loc.path, gfid_local);
+        if (!mark_during_fresh_lookup)
+            dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf,
+                                     0xffffffff, layout);
+    }
 
+out:
+    if (xattrs)
+        dict_unref(xattrs);
+    return ret;
+}
 
-        LOCK (&frame->lock);
-        {
-                /* TODO: assert equal mode on stbuf->st_mode and
-                   local->stbuf->st_mode
+/* Get the value of key from dict in the bytewise and save in array after
+   convert from network byte order to host byte order
+*/
+static int32_t
+dht_dict_get_array(dict_t *dict, char *key, int32_t value[], int32_t size,
+                   int *errst)
+{
+    void *ptr = NULL;
+    int32_t len = -1;
+    int32_t vindex = -1;
+    int32_t err = -1;
+    int ret = 0;
+
+    if (dict == NULL) {
+        (*errst) = -1;
+        return -EINVAL;
+    }
+    err = dict_get_ptr_and_len(dict, key, &ptr, &len);
+    if (err != 0) {
+        (*errst) = -1;
+        return err;
+    }
+
+    if (len != (size * sizeof(int32_t))) {
+        (*errst) = -1;
+        return -EINVAL;
+    }
+
+    for (vindex = 0; vindex < size; vindex++) {
+        value[vindex] = ntoh32(*((int32_t *)ptr + vindex));
+        if (value[vindex] < 0)
+            ret = -1;
+    }
+
+    return ret;
+}
 
-                   else mkdir/chmod/chown and fix
-                */
+static int
+dht_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, inode_t *inode, struct iatt *stbuf,
+                 dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int32_t check_mds = 0;
+    int is_linkfile = 0;
+    int attempt_unwind = 0;
+    dht_conf_t *conf = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_node[GF_UUID_BUF_SIZE] = {0};
+    int32_t mds_xattr_val[1] = {0};
+    int errst = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    layout = local->layout;
+
+    /* Check if the gfid is different for file from other node */
+    if (!op_ret && gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
+        gf_uuid_unparse(local->gfid, gfid_local);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on %s, gfid local = %s"
+               "gfid other = %s",
+               local->loc.path, prev->name, gfid_local, gfid_node);
+    }
+
+    LOCK(&frame->lock);
+    {
+        /* TODO: assert equal mode on stbuf->st_mode and
+           local->stbuf->st_mode
+
+           else mkdir/chmod/chown and fix
+        */
 
-                ret = dht_layout_merge (this, layout, prev,
-                                        op_ret, op_errno, xattr);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_MERGE_FAILED,
-                                "%s: failed to merge layouts for subvol %s",
-                                local->loc.path, prev->name);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "lookup of %s on %s returned error",
-                                      local->loc.path, prev->name);
-
-                        goto unlock;
-                }
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                   "%s: failed to merge layouts for subvol %s", local->loc.path,
+                   prev->name);
 
-                is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                                 conf->link_xattr_name);
-                is_dir = check_is_dir (inode, stbuf, xattr);
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno,
+                         "lookup of %s on %s returned error", local->loc.path,
+                         prev->name);
 
-                if (is_dir) {
-                        local->dir_count ++;
-                } else {
-                        local->file_count ++;
-
-                        if (!is_linkfile && !local->cached_subvol) {
-                                /* real file */
-                                /* Ok, we somehow managed to find a file on
-                                 * more than one subvol. ignore this or we
-                                 * will end up overwriting information while a
-                                 * a thread is potentially unwinding from
-                                 * dht_discover_complete
-                                 */
-                                local->cached_subvol = prev;
-                                attempt_unwind = 1;
-                        } else {
-                                goto unlock;
-                        }
-                }
+            goto unlock;
+        }
 
-                local->op_ret = 0;
+        is_linkfile = check_is_linkfile(inode, stbuf, xattr,
+                                        conf->link_xattr_name);
+        is_dir = check_is_dir(inode, stbuf, xattr);
 
-                if (local->xattr == NULL) {
-                        local->xattr = dict_ref (xattr);
-                } else {
-                        /* Don't aggregate for files. See BZ#1484113 */
-                        if (is_dir)
-                                dht_aggregate_xattr (local->xattr, xattr);
-                }
+        if (is_dir) {
+            local->dir_count++;
+        } else {
+            local->file_count++;
+
+            if (!is_linkfile && !local->cached_subvol) {
+                /* real file */
+                /* Ok, we somehow managed to find a file on
+                 * more than one subvol. ignore this or we
+                 * will end up overwriting information while a
+                 * a thread is potentially unwinding from
+                 * dht_discover_complete
+                 */
+                local->cached_subvol = prev;
+                attempt_unwind = 1;
+            } else {
+                goto unlock;
+            }
+        }
 
-                if (local->inode == NULL)
-                        local->inode = inode_ref (inode);
+        local->op_ret = 0;
 
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                dht_iatt_merge (this, &local->postparent, postparent,
-                                prev);
+        if (local->xattr == NULL) {
+            local->xattr = dict_ref(xattr);
+        } else {
+            /* Don't aggregate for files. See BZ#1484709 */
+            if (is_dir)
+                dht_aggregate_xattr(local->xattr, xattr);
         }
+
+        if (local->inode == NULL)
+            local->inode = inode_ref(inode);
+
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->postparent, postparent);
+
+        if (!dict_get(xattr, conf->mds_xattr_key)) {
+            goto unlock;
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "internal xattr %s is present on subvol"
+                         "on path %s gfid is %s ",
+                         conf->mds_xattr_key, local->loc.path, gfid_local);
+        }
+        check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                       mds_xattr_val, 1, &errst);
+        /* save mds subvol on inode ctx */
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set hashed subvol for %s vol is %s",
+                   local->loc.path, prev->name);
+        }
+
+        if ((check_mds < 0) && !errst) {
+            local->mds_xattr = dict_ref(xattr);
+            gf_msg_debug(this->name, 0,
+                         "Value of %s is not zero on mds subvol"
+                         "so xattr needs to be healed on non mds"
+                         " path is %s and vol name is %s "
+                         " gfid is %s",
+                         conf->mds_xattr_key, local->loc.path, prev->name,
+                         gfid_local);
+            local->need_xattr_heal = 1;
+            local->mds_subvol = prev;
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 out:
-        /* Make sure, the thread executing dht_discover_complete is the one
-         * which calls STACK_DESTROY (frame). In the case of "attempt_unwind",
-         * this makes sure that the thread don't call dht_frame_return, till
-         * call to dht_discover_complete is done.
-         */
-        if (attempt_unwind) {
-                dht_discover_complete (this, frame);
-        }
+    /* Make sure, the thread executing dht_discover_complete is the one
+     * which calls STACK_DESTROY (frame). In the case of "attempt_unwind",
+     * this makes sure that the thread don't call dht_frame_return, till
+     * call to dht_discover_complete is done.
+     */
+    if (attempt_unwind) {
+        dht_discover_complete(this, frame);
+    }
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt) && !attempt_unwind) {
-                dht_discover_complete (this, frame);
-        }
+    if (is_last_call(this_call_cnt) && !attempt_unwind) {
+        dht_discover_complete(this, frame);
+    }
 
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_DESTROY (frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
+static int
+dht_set_file_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    int ret = -EINVAL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    if (!conf) {
+        goto err;
+    }
+
+    if (!xattr_req) {
+        goto err;
+    }
+
+    /* Used to check whether this is a linkto file.
+     */
+    ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->link_xattr_name, loc->path);
+        goto err;
+    }
+
+    /* This is used to make sure we don't unlink linkto files
+     * which are the target of an ongoing file migration.
+     */
+    ret = dict_set_uint32(xattr_req, GLUSTERFS_OPEN_FD_COUNT, 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               GLUSTERFS_OPEN_FD_COUNT, loc->path);
+        goto err;
+    }
+
+    ret = 0;
+err:
+    return ret;
+}
 
-int
-dht_discover (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        int          ret;
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf = NULL;
-        int          call_cnt = 0;
-        int          op_errno = EINVAL;
-        int          i = 0;
-        call_frame_t *discover_frame = NULL;
+/* This is a gfid based nameless lookup. Without a name, the hashed subvol
+ * cannot be calculated so a lookup is sent to all subvols.
+ */
+static int
+dht_do_discover(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    int ret;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int op_errno = EINVAL;
+    int i = 0;
+    call_frame_t *discover_frame = NULL;
+
+    conf = this->private;
+    local = frame->local;
+
+    /* As we do not know if this is a file or directory, request
+     * both file and directory xattrs
+     */
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        goto err;
+    }
+
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        goto err;
+    }
+
+    if (loc_is_root(loc)) {
+        /* Request the DHT commit hash xattr (trusted.glusterfs.dht.commithash)
+         * set on the brick root.
+         */
+        ret = dict_set_uint32(local->xattr_req, conf->commithash_xattr_name,
+                              sizeof(uint32_t));
+    }
 
-        conf = this->private;
-        local = frame->local;
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        ret = dict_set_uint32 (local->xattr_req, conf->xattr_name, 4 * 4);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value:key = %s",
-                        loc->path, conf->xattr_name);
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
 
-        ret = dict_set_uint32 (local->xattr_req, conf->link_xattr_name, 256);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value:key = %s",
-                        loc->path, conf->link_xattr_name);
+    if (!local->layout) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (__is_root_gfid(local->loc.gfid)) {
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->commithash_xattr_name,
-                                       sizeof(uint32_t));
-        }
+    gf_uuid_copy(local->gfid, loc->gfid);
 
-        call_cnt        = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+    discover_frame = copy_frame(frame);
+    if (!discover_frame) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
+    discover_frame->local = local;
+    frame->local = NULL;
+    local->main_frame = frame;
 
-        if (!local->layout) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(discover_frame, dht_discover_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, &local->loc,
+                          local->xattr_req);
+    }
 
-        gf_uuid_copy (local->gfid, loc->gfid);
+    return 0;
 
-        discover_frame = copy_frame (frame);
-        if (!discover_frame) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+err:
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        discover_frame->local = local;
-        frame->local = NULL;
-        local->main_frame = frame;
+    return 0;
+}
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (discover_frame, dht_discover_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
+/* Code to call syntask to heal custom xattr from hashed subvol
+   to non hashed subvol
+*/
+int
+dht_dir_xattr_heal(xlator_t *this, dht_local_t *local, int *op_errno)
+{
+    dht_local_t *copy_local = NULL;
+    call_frame_t *copy = NULL;
+    int ret = -1;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+
+    if (gf_uuid_is_null(local->gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+               "No gfid exists for path %s "
+               "so healing xattr is not possible",
+               local->loc.path);
+        *op_errno = EIO;
+        goto out;
+    }
+
+    gf_uuid_unparse(local->gfid, gfid_local);
+    copy = create_frame(this, this->ctx->pool);
+    if (copy) {
+        copy_local = dht_local_init(copy, &(local->loc), NULL, 0);
+        if (!copy_local) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                   DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                   "Memory allocation failed "
+                   "for path %s gfid %s ",
+                   local->loc.path, gfid_local);
+            *op_errno = ENOMEM;
+            DHT_STACK_DESTROY(copy);
+        } else {
+            copy_local->stbuf = local->stbuf;
+            gf_uuid_copy(copy_local->loc.gfid, local->gfid);
+            copy_local->mds_subvol = local->mds_subvol;
+            FRAME_SU_DO(copy, dht_local_t);
+            ret = synctask_new(this->ctx->env, dht_dir_heal_xattrs,
+                               dht_dir_heal_xattrs_done, copy, copy);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "Synctask creation failed to heal xattr "
+                       "for path %s gfid %s ",
+                       local->loc.path, gfid_local);
+                *op_errno = ENOMEM;
+                DHT_STACK_DESTROY(copy);
+            }
         }
+    }
+out:
+    return ret;
+}
 
-        return 0;
+static int
+dht_needs_selfheal(call_frame_t *frame, xlator_t *this)
+{
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int needs_selfheal = 0;
+    int ret = 0;
 
-err:
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
+    local = frame->local;
+    layout = local->layout;
 
-        return 0;
+    if (local->need_attrheal || local->need_xattr_heal ||
+        local->need_selfheal) {
+        needs_selfheal = 1;
+    }
+
+    ret = dht_layout_normalize(this, &local->loc, layout);
+
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0, "fixing assignment on %s", local->loc.path);
+        needs_selfheal = 1;
+    }
+    return needs_selfheal;
 }
 
+static int
+is_permission_different(ia_prot_t *prot1, ia_prot_t *prot2)
+{
+    if ((prot1->owner.read != prot2->owner.read) ||
+        (prot1->owner.write != prot2->owner.write) ||
+        (prot1->owner.exec != prot2->owner.exec) ||
+        (prot1->group.read != prot2->group.read) ||
+        (prot1->group.write != prot2->group.write) ||
+        (prot1->group.exec != prot2->group.exec) ||
+        (prot1->other.read != prot2->other.read) ||
+        (prot1->other.write != prot2->other.write) ||
+        (prot1->other.exec != prot2->other.exec) ||
+        (prot1->suid != prot2->suid) || (prot1->sgid != prot2->sgid) ||
+        (prot1->sticky != prot2->sticky)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
 
 int
-dht_lookup_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                    struct iatt *postparent)
-{
-        dht_local_t  *local                   = NULL;
-        int           this_call_cnt           = 0;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        int           ret                     = -1;
-        int           is_dir                  = 0;
-        char         gfid_local[GF_UUID_BUF_SIZE]  = {0};
-        char         gfid_node[GF_UUID_BUF_SIZE]  = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev  = cookie;
+dht_lookup_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int32_t check_mds = 0;
+    int errst = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_node[GF_UUID_BUF_SIZE] = {0};
+    int32_t mds_xattr_val[1] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    layout = local->layout;
+    gf_msg_debug(this->name, op_errno,
+                 "%s: lookup on %s returned with op_ret = %d, op_errno = %d",
+                 local->loc.path, prev->name, op_ret, op_errno);
+
+    /* The first successful lookup*/
+    if (!op_ret && gf_uuid_is_null(local->gfid)) {
+        memcpy(local->gfid, stbuf->ia_gfid, 16);
+    }
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid_local);
+    }
+
+    /* Check if the gfid is different for file from other node */
+    if (!op_ret && gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on %s."
+               " gfid local = %s, gfid subvol = %s",
+               local->loc.path, prev->name, gfid_local, gfid_node);
+    }
+
+    LOCK(&frame->lock);
+    {
+        /* TODO: assert equal mode on stbuf->st_mode and
+           local->stbuf->st_mode
+           else mkdir/chmod/chown and fix
+        */
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
 
-        layout = local->layout;
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
 
-        if (!op_ret && gf_uuid_is_null (local->gfid))
-                memcpy (local->gfid, stbuf->ia_gfid, 16);
+            /* The GFID is missing on this subvol. Force a heal. */
+            if (op_errno == ENODATA) {
+                local->need_lookup_everywhere = 1;
+            }
+            goto unlock;
+        }
 
-        /* Check if the gfid is different for file from other node */
-        if (!op_ret && gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
+        is_dir = check_is_dir(inode, stbuf, xattr);
+        if (!is_dir) {
+            gf_msg_debug(this->name, 0,
+                         "%s: lookup on %s returned non dir 0%o"
+                         "calling lookup_everywhere",
+                         local->loc.path, prev->name, stbuf->ia_type);
 
-                gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
-                gf_uuid_unparse(local->gfid, gfid_local);
+            local->need_lookup_everywhere = 1;
+            goto unlock;
+        }
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on %s."
-                        " gfid local = %s, gfid subvol = %s",
-                        local->loc.path, prev->name,
-                        gfid_local, gfid_node);
+        local->op_ret = 0;
+        if (local->xattr == NULL) {
+            local->xattr = dict_ref(xattr);
+        } else {
+            dht_aggregate_xattr(local->xattr, xattr);
         }
 
-        LOCK (&frame->lock);
-        {
-                /* TODO: assert equal mode on stbuf->st_mode and
-                   local->stbuf->st_mode
+        if (__is_root_gfid(stbuf->ia_gfid)) {
+            ret = dht_dir_has_layout(xattr, conf->xattr_name);
+            if (ret >= 0) {
+                if (is_greater_time(local->prebuf.ia_ctime,
+                                    local->prebuf.ia_ctime_nsec,
+                                    stbuf->ia_ctime, stbuf->ia_ctime_nsec)) {
+                    /* Choose source */
+                    local->prebuf.ia_gid = stbuf->ia_gid;
+                    local->prebuf.ia_uid = stbuf->ia_uid;
 
-                   else mkdir/chmod/chown and fix
-                */
-                ret = dht_layout_merge (this, layout, prev, op_ret, op_errno,
-                                        xattr);
+                    local->prebuf.ia_ctime = stbuf->ia_ctime;
+                    local->prebuf.ia_ctime_nsec = stbuf->ia_ctime_nsec;
+                    local->prebuf.ia_prot = stbuf->ia_prot;
+                }
+            }
+        }
 
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "lookup of %s on %s returned error",
-                                      local->loc.path, prev->name);
+        if (local->stbuf.ia_type != IA_INVAL) {
+            /* This is not the first subvol to respond
+             * Compare values to see if attrs need to be healed
+             */
+            if ((local->stbuf.ia_gid != stbuf->ia_gid) ||
+                (local->stbuf.ia_uid != stbuf->ia_uid) ||
+                (is_permission_different(&local->stbuf.ia_prot,
+                                         &stbuf->ia_prot))) {
+                local->need_attrheal = 1;
+            }
+        }
 
-                        goto unlock;
-                }
+        if (local->inode == NULL)
+            local->inode = inode_ref(inode);
 
-                is_dir = check_is_dir (inode, stbuf, xattr);
-                if (!is_dir) {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->postparent, postparent);
 
-                        gf_msg_debug (this->name, 0,
-                                      "lookup of %s on %s returned non"
-                                      "dir 0%o"
-                                      "calling lookup_everywhere",
-                                      local->loc.path, prev->name,
-                                      stbuf->ia_type);
+        if (!dict_get(xattr, conf->mds_xattr_key)) {
+            gf_msg_debug(this->name, 0,
+                         "%s: mds xattr %s is not present "
+                         "on %s(gfid = %s)",
+                         local->loc.path, conf->mds_xattr_key, prev->name,
+                         gfid_local);
+            goto unlock;
+        }
 
-                        local->need_selfheal = 1;
-                        goto unlock;
-                }
+        /* Save the mds subvol info and stbuf. This is the value that will
+         * be used for healing
+         */
+        local->mds_subvol = prev;
+        local->mds_stbuf = *stbuf;
 
-                local->op_ret = 0;
-                if (local->xattr == NULL) {
-                        local->xattr = dict_ref (xattr);
-                } else {
-                        dht_aggregate_xattr (local->xattr, xattr);
-                }
+        /* Save mds subvol on inode ctx */
 
-                if (local->inode == NULL)
-                        local->inode = inode_ref (inode);
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "%s: Failed to set mds (%s)", local->loc.path, prev->name);
+        }
+        check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                       mds_xattr_val, 1, &errst);
+        if ((check_mds < 0) && !errst) {
+            /* Check if xattrs need to be healed on the directories */
+            local->mds_xattr = dict_ref(xattr);
+            gf_msg_debug(this->name, 0,
+                         "%s: %s is not zero on %s. Xattrs need to be healed."
+                         "(gfid = %s)",
+                         local->loc.path, conf->mds_xattr_key, prev->name,
+                         gfid_local);
+            local->need_xattr_heal = 1;
+        }
+    }
 
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                dht_iatt_merge (this, &local->postparent, postparent, prev);
-        }
 unlock:
-        UNLOCK (&frame->lock);
-
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                gf_uuid_copy (local->loc.gfid, local->gfid);
+    if (is_last_call(this_call_cnt)) {
+        /* If the mds subvol is not set correctly*/
+        if (!__is_root_gfid(local->gfid) &&
+            (!dict_get(local->xattr, conf->mds_xattr_key))) {
+            local->need_selfheal = 1;
+        }
 
-                if (local->need_selfheal) {
-                        local->need_selfheal = 0;
-                        dht_lookup_everywhere (frame, this, &local->loc);
-                        return 0;
-                }
+        /* No need to call xattr heal code if volume count is 1
+         */
+        if (conf->subvolume_cnt == 1) {
+            local->need_xattr_heal = 0;
+        }
+
+        if (local->need_selfheal || local->need_lookup_everywhere) {
+            /* Set the gfid-req so posix will set the GFID*/
+            if (!gf_uuid_is_null(local->gfid)) {
+                /* Ok, this should _never_ happen */
+                ret = dict_set_static_bin(local->xattr_req, "gfid-req",
+                                          local->gfid, 16);
+            } else {
+                if (!gf_uuid_is_null(local->gfid_req))
+                    ret = dict_set_static_bin(local->xattr_req, "gfid-req",
+                                              local->gfid_req, 16);
+            }
+        }
 
-                if (local->op_ret == 0) {
-                        ret = dht_layout_normalize (this, &local->loc, layout);
+        if (local->need_lookup_everywhere) {
+            local->need_lookup_everywhere = 0;
+            dht_lookup_everywhere(frame, this, &local->loc);
+            return 0;
+        }
 
-                        if (ret != 0) {
-                                gf_msg_debug (this->name, 0,
-                                              "fixing assignment on %s",
-                                              local->loc.path);
-                                goto selfheal;
-                        }
+        if (local->op_ret == 0) {
+            if (dht_needs_selfheal(frame, this)) {
+                goto selfheal;
+            }
 
-                        dht_layout_set (this, local->inode, layout);
-                }
+            dht_layout_set(this, local->inode, layout);
+            if (local->inode) {
+                dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+            }
 
-                if (local->inode) {
-                        dht_inode_ctx_time_update (local->inode, this,
-                                                   &local->stbuf, 1);
-                }
+            if (local->loc.parent) {
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->postparent, 1);
+            }
+        }
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        /* Delete mds xattr at the time of STACK UNWIND */
+        if (local->xattr)
+            GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                                  local->inode, &local->stbuf, local->xattr,
-                                  &local->postparent);
-        }
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+    }
 
-        return 0;
+    return 0;
 
 selfheal:
-        FRAME_SU_DO (frame, dht_local_t);
-        ret = dht_selfheal_directory (frame, dht_lookup_selfheal_cbk,
-                                      &local->loc, layout);
+    FRAME_SU_DO(frame, dht_local_t);
+    ret = dht_selfheal_directory(frame, dht_lookup_selfheal_cbk, &local->loc,
+                                 layout);
 out:
-        return ret;
+    return ret;
 }
 
-int static
-is_permission_different (ia_prot_t *prot1, ia_prot_t *prot2)
-{
-        if ((prot1->owner.read != prot2->owner.read) ||
-            (prot1->owner.write != prot2->owner.write) ||
-            (prot1->owner.exec != prot2->owner.exec) ||
-            (prot1->group.read != prot2->group.read) ||
-            (prot1->group.write != prot2->group.write) ||
-            (prot1->group.exec != prot2->group.exec) ||
-            (prot1->other.read != prot2->other.read) ||
-            (prot1->other.write != prot2->other.write) ||
-            (prot1->other.exec != prot2->other.exec) ||
-            (prot1->suid != prot2->suid) ||
-            (prot1->sgid != prot2->sgid) ||
-            (prot1->sticky != prot2->sticky)) {
-                return 1;
-        } else {
-                return 0;
-        }
+static int
+dht_lookup_directory(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    int call_cnt = 0;
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int ret = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, unwind);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, unwind);
+    GF_VALIDATE_OR_GOTO("dht", this->private, unwind);
+    GF_VALIDATE_OR_GOTO("dht", loc, unwind);
+
+    conf = this->private;
+    local = frame->local;
+
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
+
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
+    if (!local->layout) {
+        goto unwind;
+    }
+
+    if (local->xattr != NULL) {
+        dict_unref(local->xattr);
+        local->xattr = NULL;
+    }
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        /* use this gfid in order to heal any missing ones */
+        ret = dict_set_gfuuid(local->xattr_req, "gfid-req", local->gfid, true);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: Failed to set dictionary value:"
+                   " key = gfid-req",
+                   local->loc.path);
+    }
+
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(
+            frame, dht_lookup_dir_cbk, conf->subvolumes[i], conf->subvolumes[i],
+            conf->subvolumes[i]->fops->lookup, &local->loc, local->xattr_req);
+    }
+    return 0;
+unwind:
+    DHT_STACK_UNWIND(lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
+out:
+    return 0;
 }
 
 int
-dht_revalidate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                    struct iatt *postparent)
-{
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev          = NULL;
-        dht_layout_t *layout        = NULL;
-        dht_conf_t   *conf          = NULL;
-        int           ret  = -1;
-        int           is_dir = 0;
-        int           is_linkfile = 0;
-        int           follow_link = 0;
-        call_frame_t *copy          = NULL;
-        dht_local_t  *copy_local    = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0};
-        uint32_t      vol_commit_hash = 0;
-        xlator_t      *subvol = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, err);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, err);
-
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (xattr, conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
+dht_revalidate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int is_linkfile = 0;
+    int follow_link = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    uint32_t vol_commit_hash = 0;
+    xlator_t *subvol = NULL;
+    int32_t check_mds = 0;
+    int errst = 0, i = 0;
+    int32_t mds_xattr_val[1] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", cookie, err);
+    GF_VALIDATE_OR_GOTO("dht", this->private, err);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    if (!conf->vch_forced) {
+        /* Update the commithash value if available
+         */
+        ret = dict_get_uint32(xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
         }
+    }
 
-        gf_uuid_unparse (local->loc.gfid, gfid);
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        LOCK (&frame->lock);
-        {
+    gf_msg_debug(this->name, op_errno,
+                 "%s: revalidate lookup on %s returned op_ret %d",
+                 local->loc.path, prev->name, op_ret);
 
-                gf_msg_debug (this->name, op_errno,
-                              "revalidate lookup of %s "
-                              "returned with op_ret %d",
-                              local->loc.path, op_ret);
+    LOCK(&frame->lock);
+    {
+        if (gf_uuid_is_null(local->gfid)) {
+            memcpy(local->gfid, local->loc.gfid, 16);
+        }
 
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+
+            if ((op_errno != ENOTCONN) && (op_errno != ENOENT) &&
+                (op_errno != ESTALE)) {
+                gf_msg(this->name, GF_LOG_INFO, op_errno,
+                       DHT_MSG_REVALIDATE_CBK_INFO,
+                       "Revalidate: subvolume %s for %s "
+                       "(gfid = %s) returned -1",
+                       prev->name, local->loc.path, gfid);
+            }
+            if (op_errno == ESTALE) {
+                /* propagate the ESTALE to parent.
+                 * setting local->return_estale would send
+                 * ESTALE to parent. */
+                local->return_estale = 1;
+            }
 
-                        if ((op_errno != ENOTCONN)
-                            && (op_errno != ENOENT)
-                            && (op_errno != ESTALE)) {
-                                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                                        DHT_MSG_REVALIDATE_CBK_INFO,
-                                        "Revalidate: subvolume %s for %s "
-                                        "(gfid = %s) returned -1",
-                                        prev->name, local->loc.path,
-                                        gfid);
-                        }
-                        if (op_errno == ESTALE) {
-                                /* propagate the ESTALE to parent.
-                                 * setting local->return_estale would send
-                                 * ESTALE to parent. */
-                                local->return_estale = 1;
+            /* if it is ENOENT, we may have to do a
+             * 'lookup_everywhere()' to make sure
+             * the file is not migrated */
+            if (op_errno == ENOENT) {
+                if (IA_ISREG(local->loc.inode->ia_type)) {
+                    gf_msg_debug(this->name, 0,
+                                 "found ENOENT for %s. "
+                                 "Setting "
+                                 "need_lookup_everywhere"
+                                 " flag to 1",
+                                 local->loc.path);
+
+                    local->need_lookup_everywhere = 1;
+                } else if (IA_ISDIR(local->loc.inode->ia_type)) {
+                    layout = local->layout;
+                    for (i = 0; i < layout->cnt; i++) {
+                        if (layout->list[i].xlator == prev) {
+                            layout->list[i].err = op_errno;
+                            break;
                         }
+                    }
 
-                        /* if it is ENOENT, we may have to do a
-                         * 'lookup_everywhere()' to make sure
-                         * the file is not migrated */
-                        if (op_errno == ENOENT) {
-                                if (IA_ISREG (local->loc.inode->ia_type)) {
-
-                                        gf_msg_debug (this->name, 0,
-                                                      "found ENOENT for %s. "
-                                                      "Setting "
-                                                      "need_lookup_everywhere"
-                                                      " flag to 1",
-                                                      local->loc.path);
-
-                                        local->need_lookup_everywhere = 1;
-                                }
-                        }
-                        goto unlock;
+                    local->need_selfheal = 1;
                 }
+            }
 
-                if ((!IA_ISINVAL(local->inode->ia_type)) &&
-                    stbuf->ia_type != local->inode->ia_type) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_FILE_TYPE_MISMATCH,
-                                "mismatching filetypes 0%o v/s 0%o for %s,"
-                                " gfid = %s",
-                                (stbuf->ia_type), (local->inode->ia_type),
-                                local->loc.path, gfid);
+            /* The GFID is missing on this subvol. Lookup everywhere to force a
+             * gfid heal
+             */
+            if ((op_errno == ENODATA) &&
+                (IA_ISDIR(local->loc.inode->ia_type))) {
+                local->need_lookup_everywhere = 1;
+            }
 
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
+            goto unlock;
+        }
 
-                        goto unlock;
+        if ((!IA_ISINVAL(local->inode->ia_type)) &&
+            stbuf->ia_type != local->inode->ia_type) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+                   "mismatching filetypes 0%o v/s 0%o for %s,"
+                   " gfid = %s",
+                   (stbuf->ia_type), (local->inode->ia_type), local->loc.path,
+                   gfid);
 
-                }
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
 
-                layout = local->layout;
+            goto unlock;
+        }
 
-                is_dir = check_is_dir (inode, stbuf, xattr);
-                is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                                 conf->link_xattr_name);
-                if (is_linkfile) {
-                        follow_link = 1;
-                        goto unlock;
-                }
-                if (is_dir) {
-                        ret = dht_dir_has_layout (xattr, conf->xattr_name);
-                        if (ret >= 0) {
-                                if (is_greater_time(local->stbuf.ia_ctime,
-                                                    local->stbuf.ia_ctime_nsec,
-                                                    stbuf->ia_ctime,
-                                                    stbuf->ia_ctime_nsec)) {
-                                        /* Choose source */
-                                        local->prebuf.ia_gid = stbuf->ia_gid;
-                                        local->prebuf.ia_uid = stbuf->ia_uid;
-
-                                        if (__is_root_gfid (stbuf->ia_gfid))
-                                                local->prebuf.ia_prot = stbuf->ia_prot;
-                                }
-                        }
-                        if (local->stbuf.ia_type != IA_INVAL)
-                        {
-                                if ((local->stbuf.ia_gid != stbuf->ia_gid) ||
-                                    (local->stbuf.ia_uid != stbuf->ia_uid) ||
-                                    (__is_root_gfid (stbuf->ia_gfid) &&
-                                     is_permission_different (&local->stbuf.ia_prot,
-                                                              &stbuf->ia_prot))) {
-                                        local->need_selfheal = 1;
-                                }
-                        }
-                        ret = dht_layout_dir_mismatch (this, layout,
-                                                       prev, &local->loc,
-                                                       xattr);
-                        if (ret != 0) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_LAYOUT_MISMATCH,
-                                        "Mismatching layouts for %s, gfid = %s",
-                                        local->loc.path, gfid);
-
-                                local->layout_mismatch = 1;
-
-                                goto unlock;
-                        }
-                }
+        layout = local->layout;
 
+        is_dir = check_is_dir(inode, stbuf, xattr);
+        is_linkfile = check_is_linkfile(inode, stbuf, xattr,
+                                        conf->link_xattr_name);
+        if (is_linkfile) {
+            follow_link = 1;
+            goto unlock;
+        }
+        if (is_dir) {
+            ret = dht_dir_has_layout(xattr, conf->xattr_name);
+            if (ret >= 0) {
+                if (is_greater_time(local->prebuf.ia_ctime,
+                                    local->prebuf.ia_ctime_nsec,
+                                    stbuf->ia_ctime, stbuf->ia_ctime_nsec)) {
+                    /* Choose source */
+                    local->prebuf.ia_gid = stbuf->ia_gid;
+                    local->prebuf.ia_uid = stbuf->ia_uid;
 
-                /* Update stbuf from the servers where layout is present. This
-                 * is an indication that the server is not a newly added brick.
-                 * Merging stbuf from newly added brick may result in the added
-                 * brick being the source of heal for uid/gid */
-                if (!is_dir || (is_dir &&
-                    dht_dir_has_layout (xattr, conf->xattr_name) >= 0)
-                    || conf->subvolume_cnt == 1) {
+                    local->prebuf.ia_ctime = stbuf->ia_ctime;
+                    local->prebuf.ia_ctime_nsec = stbuf->ia_ctime_nsec;
 
-                        dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                        dht_iatt_merge (this, &local->postparent, postparent,
-                                        prev);
-                } else {
-                        /* copy the gfid anyway */
-                        gf_uuid_copy (local->stbuf.ia_gfid, stbuf->ia_gfid);
+                    if (__is_root_gfid(stbuf->ia_gfid))
+                        local->prebuf.ia_prot = stbuf->ia_prot;
                 }
+            }
 
-                local->op_ret = 0;
+            if (local->stbuf.ia_type != IA_INVAL) {
+                if ((local->stbuf.ia_gid != stbuf->ia_gid) ||
+                    (local->stbuf.ia_uid != stbuf->ia_uid) ||
+                    is_permission_different(&local->stbuf.ia_prot,
+                                            &stbuf->ia_prot)) {
+                    local->need_attrheal = 1;
+                }
+            }
 
-                if (!local->xattr) {
-                        local->xattr = dict_ref (xattr);
-                } else if (is_dir) {
-                        dht_aggregate_xattr (local->xattr, xattr);
+            if (!dict_get(xattr, conf->mds_xattr_key)) {
+                gf_msg_debug(this->name, 0,
+                             "%s: internal xattr %s is not present"
+                             " on subvol %s(gfid is %s)",
+                             local->loc.path, conf->mds_xattr_key, prev->name,
+                             gfid);
+            } else {
+                check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                               mds_xattr_val, 1, &errst);
+                local->mds_subvol = prev;
+                local->mds_stbuf.ia_gid = stbuf->ia_gid;
+                local->mds_stbuf.ia_uid = stbuf->ia_uid;
+                local->mds_stbuf.ia_prot = stbuf->ia_prot;
+
+                /* save mds subvol on inode ctx */
+                ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           DHT_MSG_SET_INODE_CTX_FAILED,
+                           "Failed to set MDS subvol for %s vol is %s",
+                           local->loc.path, prev->name);
+                }
+                if ((check_mds < 0) && !errst) {
+                    /* Check if xattrs need to be healed on the directory
+                     */
+                    local->mds_xattr = dict_ref(xattr);
+                    gf_msg_debug(this->name, 0,
+                                 "Value of %s is not zero on "
+                                 "hashed subvol so xattr needs to"
+                                 " be healed on non hashed"
+                                 " path is %s and vol name is %s "
+                                 " gfid is %s",
+                                 conf->mds_xattr_key, local->loc.path,
+                                 prev->name, gfid);
+                    local->need_xattr_heal = 1;
                 }
+            }
+            ret = dht_layout_dir_mismatch(this, layout, prev, &local->loc,
+                                          xattr);
+            if (ret != 0) {
+                /* In memory layout does not match on-disk layout.
+                 */
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_MISMATCH,
+                       "Mismatching layouts for %s, gfid = %s", local->loc.path,
+                       gfid);
+
+                local->layout_mismatch = 1;
+
+                goto unlock;
+            }
         }
+
+        gf_uuid_copy(local->stbuf.ia_gfid, stbuf->ia_gfid);
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->postparent, postparent);
+
+        local->op_ret = 0;
+
+        if (!local->xattr) {
+            local->xattr = dict_ref(xattr);
+        } else if (is_dir) {
+            dht_aggregate_xattr(local->xattr, xattr);
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
+
+    if (follow_link) {
+        /* Found a linkto file. Follow it to see if the target file exists
+         */
+        gf_uuid_copy(local->gfid, stbuf->ia_gfid);
 
-        if (follow_link) {
-                gf_uuid_copy (local->gfid, stbuf->ia_gfid);
+        subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
+        if (!subvol) {
+            op_errno = ESTALE;
+            local->op_ret = -1;
+        } else {
+            STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                              subvol->fops->lookup, &local->loc,
+                              local->xattr_req);
+            return 0;
+        }
+    }
 
-                subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
-                if (!subvol) {
-                        op_errno = ESTALE;
-                        local->op_ret = -1;
-                } else {
+    this_call_cnt = dht_frame_return(frame);
 
-                        STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk,
-                                           subvol, subvol, subvol->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        return 0;
+    if (is_last_call(this_call_cnt)) {
+        if (!IA_ISDIR(local->stbuf.ia_type) &&
+            (local->hashed_subvol != local->cached_subvol) &&
+            (local->stbuf.ia_nlink == 1) &&
+            (conf && conf->unhashed_sticky_bit)) {
+            local->stbuf.ia_prot.sticky = 1;
+        }
+        /* No need to call heal code if volume count is 1
+         */
+        if (conf->subvolume_cnt == 1)
+            local->need_xattr_heal = 0;
+
+        if (IA_ISDIR(local->stbuf.ia_type)) {
+            /* No mds xattr found. Trigger a heal to set it */
+            if (!__is_root_gfid(local->loc.inode->gfid) &&
+                (!dict_get(local->xattr, conf->mds_xattr_key)))
+                local->need_selfheal = 1;
+
+            if (dht_needs_selfheal(frame, this)) {
+                if (!__is_root_gfid(local->loc.inode->gfid)) {
+                    if (local->mds_subvol) {
+                        local->stbuf.ia_gid = local->mds_stbuf.ia_gid;
+                        local->stbuf.ia_uid = local->mds_stbuf.ia_uid;
+                        local->stbuf.ia_prot = local->mds_stbuf.ia_prot;
+                    }
+                } else {
+                    local->stbuf.ia_gid = local->prebuf.ia_gid;
+                    local->stbuf.ia_uid = local->prebuf.ia_uid;
+                    local->stbuf.ia_prot = local->prebuf.ia_prot;
                 }
+
+                layout = local->layout;
+                dht_selfheal_directory(frame, dht_lookup_selfheal_cbk,
+                                       &local->loc, layout);
+                return 0;
+            }
         }
 
-out:
-        this_call_cnt = dht_frame_return (frame);
-
-        if (is_last_call (this_call_cnt)) {
-                if (!IA_ISDIR (local->stbuf.ia_type)
-                    && (local->hashed_subvol != local->cached_subvol)
-                    && (local->stbuf.ia_nlink == 1)
-                    && (conf && conf->unhashed_sticky_bit)) {
-                        local->stbuf.ia_prot.sticky = 1;
-                }
-                if (local->need_selfheal) {
-                        local->need_selfheal = 0;
-                        gf_uuid_copy (local->gfid, local->stbuf.ia_gfid);
-                        local->stbuf.ia_gid = local->prebuf.ia_gid;
-                        local->stbuf.ia_uid = local->prebuf.ia_uid;
-                        if (__is_root_gfid(local->stbuf.ia_gfid))
-                                local->stbuf.ia_prot = local->prebuf.ia_prot;
-                        copy = create_frame (this, this->ctx->pool);
-                        if (copy) {
-                                copy_local = dht_local_init (copy, &local->loc,
-                                                             NULL, 0);
-                                if (!copy_local)
-                                        goto cont;
-                                copy_local->stbuf = local->stbuf;
-                                copy->local = copy_local;
-                                FRAME_SU_DO (copy, dht_local_t);
-                                ret = synctask_new (this->ctx->env,
-                                                    dht_dir_attr_heal,
-                                                    dht_dir_attr_heal_done,
-                                                    copy, copy);
-                        }
-                }
-cont:
-                if (local->layout_mismatch) {
-                        /* Found layout mismatch in the directory, need to
-                           fix this in the inode context */
-                        dht_layout_unref (this, local->layout);
-                        local->layout = NULL;
-                        dht_lookup_directory (frame, this, &local->loc);
-                        return 0;
-                }
+        if (local->layout_mismatch) {
+            /* Found layout mismatch in the directory, need to
+               fix this in the inode context */
+            dht_layout_unref(this, local->layout);
+            local->layout = NULL;
+            dht_lookup_directory(frame, this, &local->loc);
+            return 0;
+        }
 
-                if (local->need_lookup_everywhere) {
-                        /* As the current layout gave ENOENT error, we would
-                           need a new layout */
-                        dht_layout_unref (this, local->layout);
-                        local->layout = NULL;
-
-                        /* We know that current cached subvol is no more
-                           valid, get the new one */
-                        local->cached_subvol = NULL;
-                        dht_lookup_everywhere (frame, this, &local->loc);
-                        return 0;
-                }
-                if (local->return_estale) {
-                        local->op_ret = -1;
-                        local->op_errno = ESTALE;
-                }
+        if (local->need_lookup_everywhere) {
+            /* As the current layout gave ENOENT error, we would
+               need a new layout */
+            dht_layout_unref(this, local->layout);
+            local->layout = NULL;
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
+            /* We know that current cached subvol is no longer
+               valid, get the new one */
+            local->cached_subvol = NULL;
+            if (local->xattr_req) {
+                if (!gf_uuid_is_null(local->gfid)) {
+                    ret = dict_set_static_bin(local->xattr_req, "gfid-req",
+                                              local->gfid, 16);
                 }
+            }
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-
-                /* local->stbuf is udpated only from subvols which have a layout
-                 * The reason is to avoid choosing attr heal source from newly
-                 * added bricks. In case e.g we have only one subvol and for
-                 * some reason layout is not present on it, then local->stbuf
-                 * will be EINVAL. This is an indication that the subvols
-                 * active in the cluster do not have layouts on disk.
-                 * Unwind with ESTALE to trigger a fresh lookup */
-                if (is_dir && local->stbuf.ia_type == IA_INVAL) {
-                        local->op_ret = -1;
-                        local->op_errno = ESTALE;
-                }
+            dht_lookup_everywhere(frame, this, &local->loc);
+            return 0;
+        }
+        if (local->return_estale) {
+            local->op_ret = -1;
+            local->op_errno = ESTALE;
+        }
 
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                                  local->inode, &local->stbuf, local->xattr,
-                                  &local->postparent);
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
 
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+
+        /* local->stbuf is updated only from subvols which have a layout
+         * The reason is to avoid choosing attr heal source from newly
+         * added bricks. In case e.g we have only one subvol and for
+         * some reason layout is not present on it, then local->stbuf
+         * will be EINVAL. This is an indication that the subvols
+         * active in the cluster do not have layouts on disk.
+         * Unwind with ESTALE to trigger a fresh lookup */
+        if (is_dir && local->stbuf.ia_type == IA_INVAL) {
+            local->op_ret = -1;
+            local->op_errno = ESTALE;
+        }
+        /* Delete mds xattr at the time of STACK UNWIND */
+        if (local->xattr)
+            GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
+
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+    }
+
 err:
-        return ret;
+    return ret;
 }
 
+static int
+dht_lookup_linkfile_create_cbk(call_frame_t *frame, void *cooie, xlator_t *this,
+                               int32_t op_ret, int32_t op_errno, inode_t *inode,
+                               struct iatt *stbuf, struct iatt *preparent,
+                               struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-int
-dht_lookup_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this,
-                                int32_t op_ret, int32_t op_errno,
-                                inode_t *inode, struct iatt *stbuf,
-                                struct iatt *preparent, struct iatt *postparent,
-                                dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        xlator_t     *cached_subvol = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
 
-        local = frame->local;
-        cached_subvol = local->cached_subvol;
-        conf = this->private;
+    local = frame->local;
+    cached_subvol = local->cached_subvol;
+    conf = this->private;
 
-        gf_uuid_unparse(local->loc.gfid, gfid);
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        ret = dht_layout_preset (this, local->cached_subvol, local->loc.inode);
-        if (ret < 0) {
-                gf_msg_debug (this->name, EINVAL,
-                              "Failed to set layout for subvolume %s, "
-                              "(gfid = %s)",
-                              cached_subvol ? cached_subvol->name : "<nil>",
-                              gfid);
-                local->op_ret = -1;
-                local->op_errno = EINVAL;
-                goto unwind;
-        }
+    if (local->locked)
+        dht_unlock_namespace(frame, &local->lock[0]);
 
-        local->op_ret = 0;
-        if ((local->stbuf.ia_nlink == 1)
-            && (conf && conf->unhashed_sticky_bit)) {
-                local->stbuf.ia_prot.sticky = 1;
-        }
+    ret = dht_layout_preset(this, local->cached_subvol, local->loc.inode);
+    if (ret < 0) {
+        gf_msg_debug(this->name, EINVAL,
+                     "Failed to set layout for subvolume %s, "
+                     "(gfid = %s)",
+                     cached_subvol ? cached_subvol->name : "<nil>", gfid);
+        local->op_ret = -1;
+        local->op_errno = EINVAL;
+        goto unwind;
+    }
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+    local->op_ret = 0;
+    if ((local->stbuf.ia_nlink == 1) && (conf && conf->unhashed_sticky_bit)) {
+        local->stbuf.ia_prot.sticky = 1;
+    }
 
-unwind:
-        gf_msg_debug (this->name, 0,
-                      "creation of linkto on hashed subvol:%s, "
-                      "returned with op_ret %d and op_errno %d: %s",
-                      local->hashed_subvol->name,
-                      op_ret, op_errno, uuid_utoa (local->loc.gfid));
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
-        if (local->linked == _gf_true)
-                dht_linkfile_attr_heal (frame, this);
+unwind:
+    gf_msg_debug(this->name, 0,
+                 "creation of linkto on hashed subvol:%s, "
+                 "returned with op_ret %d and op_errno %d: %s",
+                 local->hashed_subvol->name, op_ret, op_errno,
+                 uuid_utoa(local->loc.gfid));
 
+    if (local->linked == _gf_true)
+        dht_linkfile_attr_heal(frame, this);
 
-        dht_set_fixed_dir_stat (&local->postparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
 out:
-        return ret;
+    return ret;
 }
 
-int
-dht_lookup_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       struct iatt *preparent, struct iatt *postparent,
-                       dict_t *xdata)
+static int
+dht_lookup_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        const char      *path =  NULL;
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        local =  (dht_local_t*)frame->local;
-        path = local->loc.path;
-        FRAME_SU_UNDO (frame, dht_local_t);
+    local = (dht_local_t *)frame->local;
+    path = local->loc.path;
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO, "lookup_unlink returned with "
-                "op_ret -> %d and op-errno -> %d for %s", op_ret, op_errno,
-                ((path == NULL)? "null" : path ));
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "lookup_unlink returned with "
+           "op_ret -> %d and op-errno -> %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_lookup_everywhere_done (frame, this);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_lookup_everywhere_done(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
-int
-dht_lookup_unlink_of_false_linkto_cbk (call_frame_t *frame, void *cookie,
-                                       xlator_t *this, int op_ret, int op_errno,
-                                       struct iatt *preparent,
-                                       struct iatt *postparent, dict_t *xdata)
+static int
+dht_lookup_unlink_of_false_linkto_cbk(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int op_ret, int op_errno,
+                                      struct iatt *preparent,
+                                      struct iatt *postparent, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        const char      *path =  NULL;
-
-        local =  (dht_local_t*)frame->local;
-        path = local->loc.path;
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO, "lookup_unlink returned with "
-                "op_ret -> %d and op-errno -> %d for %s", op_ret, op_errno,
-                ((path == NULL)? "null" : path ));
+    local = (dht_local_t *)frame->local;
+    path = local->loc.path;
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-                if (op_ret == 0) {
-                        dht_lookup_everywhere_done (frame, this);
-                } else {
-                       /*When dht_lookup_everywhere is performed, one cached
-                         *and one hashed file was found and hashed file does
-                         *not point to the above mentioned cached node. So it
-                         *was considered as stale and an unlink was performed.
-                         *But unlink fails. So may be rebalance is in progress.
-                        *now ideally we have two data-files. One obtained during
-                         *lookup_everywhere and one where unlink-failed. So
-                         *at this point in time we cannot decide which one to
-                         *choose because there are chances of first cached
-                         *file is truncated after rebalance and if it is chosen
-                        *as cached node, application will fail. So return EIO.*/
-
-                        if (op_errno == EBUSY) {
-
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_UNLINK_FAILED,
-                                        "Could not unlink the linkto file as "
-                                        "either fd is open and/or linkto xattr "
-                                        "is set for %s",
-                                        ((path == NULL)? "null":path));
-
-                        }
-                        DHT_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL,
-                                          NULL, NULL);
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "lookup_unlink returned with "
+           "op_ret -> %d and op-errno -> %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-                }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if ((op_ret == 0) || ((op_errno != EBUSY) && (op_errno != ENOTCONN))) {
+            dht_lookup_everywhere_done(frame, this);
+        } else {
+            /*When dht_lookup_everywhere is performed, one cached
+             *and one hashed file was found and hashed file does
+             *not point to the above mentioned cached node. So it
+             *was considered as stale and an unlink was performed.
+             *But unlink fails. So may be rebalance is in progress.
+             *now ideally we have two data-files. One obtained during
+             *lookup_everywhere and one where unlink-failed. So
+             *at this point in time we cannot decide which one to
+             *choose because there are chances of first cached
+             *file is truncated after rebalance and if it is chosen
+             *as cached node, application will fail. So return EIO.*/
+
+            if (op_errno == EBUSY) {
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_UNLINK_FAILED,
+                       "Could not unlink the linkto file as "
+                       "either fd is open and/or linkto xattr "
+                       "is set for %s",
+                       ((path == NULL) ? "null" : path));
+            }
+            DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-int
-dht_lookup_unlink_stale_linkto_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata)
+static int
+dht_lookup_unlink_stale_linkto_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int op_ret, int op_errno,
+                                   struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata)
 {
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        dht_local_t     *local = NULL;
-        const char      *path  = NULL;
+    /* NOTE:
+     * If stale file unlink fails either there is an open-fd or is not an
+     * dht-linkto-file then posix_unlink returns EBUSY, which is overwritten
+     *  to ENOENT
+     */
 
-        /* NOTE:
-         * If stale file unlink fails either there is an open-fd or is not an
-         * dht-linkto-file then posix_unlink returns EBUSY, which is overwritten
-         *  to ENOENT
-         */
-
-        local = frame->local;
+    local = frame->local;
 
-        if (local && local->loc.path)
-                path = local->loc.path;
+    if (local) {
+        FRAME_SU_UNDO(frame, dht_local_t);
+        if (local->loc.path)
+            path = local->loc.path;
+    }
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO,
-                "Returned with op_ret %d and "
-                "op_errno %d for %s", op_ret, op_errno,
-                ((path==NULL)?"null":path));
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "Returned with op_ret %d and "
+           "op_errno %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-        DHT_STACK_UNWIND (lookup, frame, -1, ENOENT, NULL, NULL, NULL,
-                          NULL);
+    DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_fill_dict_to_avoid_unlink_of_migrating_file (dict_t *dict) {
+static int
+dht_fill_dict_to_avoid_unlink_of_migrating_file(dict_t *dict)
+{
+    int ret = 0;
 
-        int                      ret = 0;
-        xlator_t                *this           = NULL;
-        char                    *linktoskip_key = NULL;
+    ret = dict_set_int32_sizen(dict, DHT_SKIP_NON_LINKTO_UNLINK, 1);
 
-        this    = THIS;
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
+    if (ret)
+        return -1;
 
-        if (dht_is_tier_xlator (this))
-                linktoskip_key = TIER_SKIP_NON_LINKTO_UNLINK;
+    ret = dict_set_int32_sizen(dict, DHT_SKIP_OPEN_FD_UNLINK, 1);
+
+    if (ret)
+        return -1;
+
+    return 0;
+}
+
+static int32_t
+dht_linkfile_create_lookup_cbk(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               inode_t *inode, struct iatt *buf, dict_t *xdata,
+                               struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int call_cnt = 0, ret = 0;
+    xlator_t *subvol = NULL;
+    uuid_t gfid = {
+        0,
+    };
+    char gfid_str[GF_UUID_BUF_SIZE] = {0};
+
+    subvol = cookie;
+    local = frame->local;
+
+    if (subvol == local->hashed_subvol) {
+        if ((op_ret == 0) || (op_errno != ENOENT))
+            local->dont_create_linkto = _gf_true;
+    } else {
+        if (gf_uuid_is_null(local->gfid))
+            gf_uuid_copy(gfid, local->loc.gfid);
         else
-                linktoskip_key = DHT_SKIP_NON_LINKTO_UNLINK;
+            gf_uuid_copy(gfid, local->gfid);
+
+        if ((op_ret == 0) && gf_uuid_compare(gfid, buf->ia_gfid)) {
+            gf_uuid_unparse(gfid, gfid_str);
+            gf_msg_debug(this->name, 0,
+                         "gfid (%s) different on cached subvol "
+                         "(%s) and looked up inode (%s), not "
+                         "creating linkto",
+                         uuid_utoa(buf->ia_gfid), subvol->name, gfid_str);
+            local->dont_create_linkto = _gf_true;
+        } else if (op_ret == -1) {
+            local->dont_create_linkto = _gf_true;
+        }
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->dont_create_linkto)
+            goto no_linkto;
+        else {
+            gf_msg_debug(this->name, 0,
+                         "Creating linkto file on %s(hash) to "
+                         "%s on %s (gfid = %s)",
+                         local->hashed_subvol->name, local->loc.path,
+                         local->cached_subvol->name, gfid_str);
 
-        ret = dict_set_int32 (dict, linktoskip_key, 1);
+            ret = dht_linkfile_create(frame, dht_lookup_linkfile_create_cbk,
+                                      this, local->cached_subvol,
+                                      local->hashed_subvol, &local->loc);
 
-        if (ret)
-                goto err;
+            if (ret < 0)
+                goto no_linkto;
+        }
+    }
 
-        ret =  dict_set_int32 (dict, DHT_SKIP_OPEN_FD_UNLINK, 1);
+    return 0;
 
-        if (ret)
-                goto err;
+no_linkto:
+    gf_msg_debug(this->name, 0,
+                 "skipped linkto creation (path:%s) (gfid:%s) "
+                 "(hashed-subvol:%s) (cached-subvol:%s)",
+                 local->loc.path, gfid_str, local->hashed_subvol->name,
+                 local->cached_subvol->name);
 
+    dht_lookup_linkfile_create_cbk(frame, NULL, this, 0, 0, local->loc.inode,
+                                   &local->stbuf, &local->preparent,
+                                   &local->postparent, local->xattr);
+    return 0;
+}
 
-        return 0;
+static int32_t
+dht_call_lookup_linkfile_create(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int i = 0;
+    xlator_t *subvol = NULL;
 
-err:
-        return -1;
+    local = frame->local;
+    if (gf_uuid_is_null(local->gfid))
+        gf_uuid_unparse(local->loc.gfid, gfid);
+    else
+        gf_uuid_unparse(local->gfid, gfid);
+
+    if (op_ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "protecting namespace failed, skipping linkto "
+               "creation (path:%s)(gfid:%s)(hashed-subvol:%s)"
+               "(cached-subvol:%s)",
+               local->loc.path, gfid, local->hashed_subvol->name,
+               local->cached_subvol->name);
+        goto err;
+    }
+
+    local->locked = _gf_true;
+
+    local->call_cnt = 2;
 
+    for (i = 0; i < 2; i++) {
+        subvol = (subvol == NULL) ? local->hashed_subvol : local->cached_subvol;
+
+        STACK_WIND_COOKIE(frame, dht_linkfile_create_lookup_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, NULL);
+    }
+
+    return 0;
+
+err:
+    dht_lookup_linkfile_create_cbk(frame, NULL, this, 0, 0, local->loc.inode,
+                                   &local->stbuf, &local->preparent,
+                                   &local->postparent, local->xattr);
+    return 0;
 }
+
 /* Rebalance is performed from cached_node to hashed_node. Initial cached_node
  * contains a non-linkto file. After migration it is converted to linkto and
  * then unlinked. And at hashed_subvolume, first a linkto file is present,
@@ -1505,7362 +2335,8267 @@ err:
  * dht_lookup_everywhere_done takes decision based on any of the above case
  */
 
-int
-dht_lookup_everywhere_done (call_frame_t *frame, xlator_t *this)
-{
-        int           ret = 0;
-        dht_local_t  *local = NULL;
-        xlator_t     *hashed_subvol = NULL;
-        xlator_t     *cached_subvol = NULL;
-        dht_layout_t *layout = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0};
-        gf_boolean_t  found_non_linkto_on_hashed = _gf_false;
+static int
+dht_lookup_everywhere_done(call_frame_t *frame, xlator_t *this)
+{
+    int ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_layout_t *layout = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    gf_boolean_t found_non_linkto_on_hashed = _gf_false;
+
+    local = frame->local;
+    hashed_subvol = local->hashed_subvol;
+    cached_subvol = local->cached_subvol;
+
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    if (local->file_count && local->dir_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+               "path %s (gfid = %s)exists as a file on one "
+               "subvolume and directory on another. "
+               "Please fix it manually",
+               local->loc.path, gfid);
+        DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
+        return 0;
+    }
+    if (local->op_ret && local->gfid_missing) {
+        if (gf_uuid_is_null(local->gfid_req)) {
+            DHT_STACK_UNWIND(lookup, frame, -1, ENODATA, NULL, NULL, NULL,
+                             NULL);
+            return 0;
+        }
+        /* A hack */
+        dht_lookup_directory(frame, this, &local->loc);
+        return 0;
+    }
+
+    if (local->dir_count) {
+        dht_lookup_directory(frame, this, &local->loc);
+        return 0;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "STATUS: hashed_subvol %s "
+                 "cached_subvol %s",
+                 (hashed_subvol == NULL) ? "null" : hashed_subvol->name,
+                 (cached_subvol == NULL) ? "null" : cached_subvol->name);
+
+    if (!cached_subvol) {
+        if (local->skip_unlink.handle_valid_link && hashed_subvol) {
+            /*Purpose of "DHT_SKIP_NON_LINKTO_UNLINK":
+             * If this lookup is performed by rebalance and this
+             * rebalance process detected hashed file and by
+             * the time it sends the lookup request to cached node,
+             * file got migrated and now at initial hashed_node,
+             * final migrated file is present. With current logic,
+             * because this process fails to find the cached_node,
+             * it will unlink the file at initial hashed_node.
+             *
+             * So we avoid this by setting key, and checking at the
+             * posix_unlink that unlink the file only if file is a
+             * linkto file and not a migrated_file.
+             */
+
+            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
+                local->xattr_req);
+
+            if (ret) {
+                /* If for some reason, setting key in the dict
+                 * fails, return with ENOENT, as with respect to
+                 * this process, it detected only a stale link
+                 * file.
+                 *
+                 * Next lookup will delete it.
+                 *
+                 * Performing deletion of stale link file when
+                 * setting key in dict fails, may cause the data
+                 * loss because of the above mentioned race.
+                 */
 
-        local = frame->local;
-        hashed_subvol = local->hashed_subvol;
-        cached_subvol = local->cached_subvol;
+                DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL,
+                                 NULL);
+            } else {
+                local->skip_unlink.handle_valid_link = _gf_false;
+
+                gf_msg_debug(this->name, 0,
+                             "No Cached was found and "
+                             "unlink on hashed was skipped"
+                             " so performing now: %s",
+                             local->loc.path);
+                FRAME_SU_DO(frame, dht_local_t);
+                STACK_WIND(frame, dht_lookup_unlink_stale_linkto_cbk,
+                           hashed_subvol, hashed_subvol->fops->unlink,
+                           &local->loc, 0, local->xattr_req);
+            }
 
-        gf_uuid_unparse (local->loc.gfid, gfid);
-
-        if (local->file_count && local->dir_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_FILE_TYPE_MISMATCH,
-                        "path %s (gfid = %s)exists as a file on one "
-                        "subvolume and directory on another. "
-                        "Please fix it manually",
-                        local->loc.path, gfid);
-                DHT_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL, NULL,
-                                  NULL);
-                return 0;
-        }
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "There was no cached file and  "
+                         "unlink on hashed is not skipped %s",
+                         local->loc.path);
 
-        if (local->dir_count) {
-                dht_lookup_directory (frame, this, &local->loc);
-                return 0;
+            DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL, NULL);
         }
+        return 0;
+    }
 
-        gf_msg_debug (this->name, 0, "STATUS: hashed_subvol %s "
-                      "cached_subvol %s",
-                      (hashed_subvol == NULL)?"null":hashed_subvol->name,
-                      (cached_subvol == NULL)?"null":cached_subvol->name);
-
-        if (!cached_subvol) {
-
-                if (local->skip_unlink.handle_valid_link && hashed_subvol) {
-
-                        /*Purpose of "DHT_SKIP_NON_LINKTO_UNLINK":
-                         * If this lookup is performed by rebalance and this
-                         * rebalance process detected hashed file and by
-                         * the time it sends the lookup request to cached node,
-                         * file got migrated and now at initial hashed_node,
-                         * final migrated file is present. With current logic,
-                         * because this process fails to find the cached_node,
-                         * it will unlink the file at initial hashed_node.
-                         *
-                         * So we avoid this by setting key, and checking at the
-                         * posix_unlink that unlink the file only if file is a
-                         * linkto file and not a migrated_file.
-                         */
-
-
-                        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                              (local->xattr_req);
-
-                        if (ret) {
-                                /* If for some reason, setting key in the dict
-                                 * fails, return with ENOENT, as with respect to
-                                 * this process, it detected only a stale link
-                                 * file.
-                                 *
-                                 * Next lookup will delete it.
-                                 *
-                                 * Performing deletion of stale link file when
-                                 * setting key in dict fails, may cause the data
-                                 * loss becase of the above mentioned race.
-                                 */
-
-
-                                DHT_STACK_UNWIND (lookup, frame, -1, ENOENT,
-                                                  NULL, NULL, NULL, NULL);
-                        } else {
-                               local->skip_unlink.handle_valid_link = _gf_false;
-
-                                gf_msg_debug (this->name, 0,
-                                              "No Cached was found and "
-                                              "unlink on hashed was skipped"
-                                              " so performing now: %s",
-                                              local->loc.path);
-
-                               STACK_WIND (frame,
-                                            dht_lookup_unlink_stale_linkto_cbk,
-                                            hashed_subvol,
-                                            hashed_subvol->fops->unlink,
-                                            &local->loc, 0, local->xattr_req);
-                        }
+    /* At the time of dht_lookup, no file was found on hashed and that is
+     * why dht_lookup_everywhere is called, but by the time
+     * dht_lookup_everywhere
+     * reached to server, file might have already migrated. In that case we
+     * will find a migrated file at the hashed_node. In this case store the
+     * layout in context and return successfully.
+     */
 
-                } else  {
+    if (hashed_subvol || local->need_lookup_everywhere) {
+        if (local->need_lookup_everywhere) {
+            found_non_linkto_on_hashed = _gf_true;
 
-                        gf_msg_debug (this->name, 0,
-                                      "There was no cached file and  "
-                                      "unlink on hashed is not skipped %s",
-                                      local->loc.path);
+        } else if ((local->file_count == 1) &&
+                   (hashed_subvol == cached_subvol)) {
+            gf_msg_debug(this->name, 0,
+                         "found cached file on hashed subvolume "
+                         "so store in context and return for %s",
+                         local->loc.path);
 
-                        DHT_STACK_UNWIND (lookup, frame, -1, ENOENT, NULL, NULL,
-                                          NULL, NULL);
-                }
-                return 0;
+            found_non_linkto_on_hashed = _gf_true;
         }
 
-        /* At the time of dht_lookup, no file was found on hashed and that is
-         * why dht_lookup_everywhere is called, but by the time
-         * dht_lookup_everywhere
-         * reached to server, file might have already migrated. In that case we
-         * will find a migrated file at the hashed_node. In this case store the
-         * layout in context and return successfully.
-         */
+        if (found_non_linkto_on_hashed)
+            goto preset_layout;
+    }
 
-        if (hashed_subvol || local->need_lookup_everywhere) {
+    if (hashed_subvol) {
+        if (local->skip_unlink.handle_valid_link == _gf_true) {
+            if (cached_subvol == local->skip_unlink.hash_links_to) {
+                if (gf_uuid_compare(local->skip_unlink.cached_gfid,
+                                    local->skip_unlink.hashed_gfid)) {
+                    /*GFID different, return error*/
+                    DHT_STACK_UNWIND(lookup, frame, -1, ESTALE, NULL, NULL,
+                                     NULL, NULL);
 
-                if (local->need_lookup_everywhere) {
+                    return 0;
+                }
 
-                        found_non_linkto_on_hashed = _gf_true;
+                ret = dht_layout_preset(this, cached_subvol, local->loc.inode);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_INFO, 0,
+                           DHT_MSG_LAYOUT_PRESET_FAILED,
+                           "Could not set pre-set layout "
+                           "for subvolume %s",
+                           cached_subvol->name);
+                }
 
-                } else if ((local->file_count == 1) &&
-                            (hashed_subvol == cached_subvol)) {
+                local->op_ret = (ret == 0) ? ret : -1;
+                local->op_errno = (ret == 0) ? ret : EINVAL;
 
-                        gf_msg_debug (this->name, 0,
-                                      "found cached file on hashed subvolume "
-                                      "so store in context and return for %s",
-                                      local->loc.path);
+                /* Presence of local->cached_subvol validates
+                 * that lookup from cached node is successful
+                 */
 
-                        found_non_linkto_on_hashed = _gf_true;
+                if (!local->op_ret && local->loc.parent) {
+                    dht_inode_ctx_time_update(local->loc.parent, this,
+                                              &local->postparent, 1);
+                }
+
+                gf_msg_debug(this->name, 0,
+                             "Skipped unlinking linkto file "
+                             "on the hashed subvolume. "
+                             "Returning success as it is a "
+                             "valid linkto file. Path:%s",
+                             local->loc.path);
+
+                goto unwind_hashed_and_cached;
+            } else {
+                local->skip_unlink.handle_valid_link = _gf_false;
+
+                gf_msg_debug(this->name, 0,
+                             "Linkto file found on hashed "
+                             "subvol "
+                             "and data file found on cached "
+                             "subvolume. But linkto points to "
+                             "different cached subvolume (%s) "
+                             "path %s",
+                             (local->skip_unlink.hash_links_to
+                                  ? local->skip_unlink.hash_links_to->name
+                                  : " <nil>"),
+                             local->loc.path);
+
+                if (local->skip_unlink.opend_fd_count == 0) {
+                    ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
+                        local->xattr_req);
+
+                    if (ret) {
+                        DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL,
+                                         NULL, NULL);
+                    } else {
+                        local->call_cnt = 1;
+                        FRAME_SU_DO(frame, dht_local_t);
+                        STACK_WIND(frame, dht_lookup_unlink_of_false_linkto_cbk,
+                                   hashed_subvol, hashed_subvol->fops->unlink,
+                                   &local->loc, 0, local->xattr_req);
+                    }
+
+                    return 0;
                 }
-
-                if (found_non_linkto_on_hashed)
-                        goto preset_layout;
-
+            }
         }
+    }
 
+preset_layout:
 
-        if (hashed_subvol) {
-                if (local->skip_unlink.handle_valid_link == _gf_true) {
-                        if (cached_subvol == local->skip_unlink.hash_links_to) {
-
-                             if (gf_uuid_compare (local->skip_unlink.cached_gfid,
-                                               local->skip_unlink.hashed_gfid)){
-
-                                        /*GFID different, return error*/
-                                        DHT_STACK_UNWIND (lookup, frame, -1,
-                                                          ESTALE, NULL, NULL,
-                                                          NULL, NULL);
-
-                                        return 0;
-                                }
-
-                                ret = dht_layout_preset (this, cached_subvol,
-                                                         local->loc.inode);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                                "Could not set pre-set layout "
-                                                "for subvolume %s",
-                                                cached_subvol->name);
-                                }
+    if (found_non_linkto_on_hashed) {
+        if (local->need_lookup_everywhere) {
+            if (gf_uuid_compare(local->gfid, local->inode->gfid)) {
+                /* GFID different, return error */
+                DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL,
+                                 NULL);
+                return 0;
+            }
+        }
 
-                                local->op_ret = (ret == 0) ? ret : -1;
-                                local->op_errno = (ret == 0) ? ret : EINVAL;
+        local->op_ret = 0;
+        local->op_errno = 0;
+        layout = dht_layout_for_subvol(this, cached_subvol);
+        if (!layout) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                   "%s: no pre-set layout for subvolume %s,"
+                   " gfid = %s",
+                   local->loc.path,
+                   (cached_subvol ? cached_subvol->name : "<nil>"), gfid);
+        }
 
-                                /* Presence of local->cached_subvol validates
-                                 * that lookup from cached node is successful
-                                 */
+        ret = dht_layout_set(this, local->inode, layout);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                   "%s: failed to set layout for subvol %s, "
+                   "gfid = %s",
+                   local->loc.path,
+                   (cached_subvol ? cached_subvol->name : "<nil>"), gfid);
+        }
 
-                                if (!local->op_ret && local->loc.parent) {
-                                        dht_inode_ctx_time_update
-                                                (local->loc.parent, this,
-                                                 &local->postparent, 1);
-                                }
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
 
-                                gf_msg_debug (this->name, 0,
-                                              "Skipped unlinking linkto file "
-                                              "on the hashed subvolume. "
-                                              "Returning success as it is a "
-                                              "valid linkto file. Path:%s"
-                                              ,local->loc.path);
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+        return 0;
+    }
 
-                                goto unwind_hashed_and_cached;
-                        } else {
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "Cannot create linkfile for %s on %s: "
+                     "hashed subvolume cannot be found, gfid = %s.",
+                     local->loc.path, cached_subvol->name, gfid);
 
-                               local->skip_unlink.handle_valid_link = _gf_false;
+        local->op_ret = 0;
+        local->op_errno = 0;
 
-                               gf_msg_debug (this->name, 0,
-                                             "Linkto file found on hashed "
-                                             "subvol "
-                                             "and data file found on cached "
-                                             "subvolume. But linkto points to "
-                                             "different cached subvolume (%s) "
-                                             "path %s",
-                                            (local->skip_unlink.hash_links_to ?
-                                        local->skip_unlink.hash_links_to->name :
-                                             " <nil>"), local->loc.path);
+        ret = dht_layout_preset(frame->this, cached_subvol, local->inode);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+                   "Failed to set layout for subvol %s"
+                   ", gfid = %s",
+                   cached_subvol ? cached_subvol->name : "<nil>", gfid);
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
+        }
 
-                               if (local->skip_unlink.opend_fd_count == 0) {
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
 
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+        return 0;
+    }
 
-                          ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                                  (local->xattr_req);
+    if (frame->root->op != GF_FOP_RENAME) {
+        local->current = &local->lock[0];
+        ret = dht_protect_namespace(frame, &local->loc, hashed_subvol,
+                                    &local->current->ns,
+                                    dht_call_lookup_linkfile_create);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Creating linkto file on %s(hash) to %s on %s "
+                     "(gfid = %s)",
+                     hashed_subvol->name, local->loc.path, cached_subvol->name,
+                     gfid);
+
+        ret = dht_linkfile_create(frame, dht_lookup_linkfile_create_cbk, this,
+                                  cached_subvol, hashed_subvol, &local->loc);
+    }
+
+    return ret;
 
+unwind_hashed_and_cached:
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
+    return 0;
+}
 
-                                        if (ret) {
-                                          DHT_STACK_UNWIND (lookup, frame, -1,
-                                                            EIO, NULL, NULL,
-                                                            NULL, NULL);
-                                        } else {
-                                                local->call_cnt = 1;
-                                                STACK_WIND (frame,
-                                          dht_lookup_unlink_of_false_linkto_cbk,
-                                                    hashed_subvol,
-                                                    hashed_subvol->fops->unlink,
-                                                    &local->loc, 0,
-                                                    local->xattr_req);
-                                        }
+static int
+dht_lookup_everywhere_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xattr,
+                          struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int is_linkfile = 0;
+    int is_dir = 0;
+    loc_t *loc = NULL;
+    xlator_t *link_subvol = NULL;
+    int ret = -1;
+    int32_t fd_count = 0;
+    dht_conf_t *conf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dict_t *dict_req = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+
+    local = frame->local;
+    loc = &local->loc;
+    conf = this->private;
+
+    prev = cookie;
+
+    gf_msg_debug(this->name, 0,
+                 "returned with op_ret %d and op_errno %d (%s) "
+                 "from subvol %s",
+                 op_ret, op_errno, loc->path, prev->name);
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno != ENOENT)
+                local->op_errno = op_errno;
+            if (op_errno == ENODATA)
+                local->gfid_missing = _gf_true;
+            goto unlock;
+        }
 
-                                        return 0;
+        if (gf_uuid_is_null(local->gfid))
+            gf_uuid_copy(local->gfid, buf->ia_gfid);
 
-                                }
-                        }
+        gf_uuid_unparse(local->gfid, gfid);
 
-                }
+        if (gf_uuid_compare(local->gfid, buf->ia_gfid)) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+                   "%s: gfid differs on subvolume %s,"
+                   " gfid local = %s, gfid node = %s",
+                   loc->path, prev->name, gfid, uuid_utoa(buf->ia_gfid));
         }
 
+        is_linkfile = check_is_linkfile(inode, buf, xattr,
+                                        conf->link_xattr_name);
 
-preset_layout:
-
-        if (found_non_linkto_on_hashed) {
-
-                if (local->need_lookup_everywhere) {
-                        if (gf_uuid_compare (local->gfid, local->inode->gfid)) {
-                                /* GFID different, return error */
-                                DHT_STACK_UNWIND (lookup, frame, -1, ENOENT,
-                                                  NULL, NULL, NULL, NULL);
-                                return 0;
-                        }
-                }
+        if (is_linkfile) {
+            link_subvol = dht_linkfile_subvol(this, inode, buf, xattr);
+            gf_msg_debug(this->name, 0, "found on %s linkfile %s (-> %s)",
+                         prev->name, loc->path,
+                         link_subvol ? link_subvol->name : "''");
+            goto unlock;
+        }
 
-                local->op_ret = 0;
-                local->op_errno = 0;
-                layout = dht_layout_for_subvol (this, cached_subvol);
-                if (!layout) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "%s: no pre-set layout for subvolume %s,"
-                                " gfid = %s",
-                                local->loc.path, (cached_subvol ?
-                                                  cached_subvol->name :
-                                                  "<nil>"), gfid);
-                }
+        is_dir = check_is_dir(inode, buf, xattr);
 
-                ret = dht_layout_set (this, local->inode, layout);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "%s: failed to set layout for subvol %s, "
-                                "gfid = %s",
-                                local->loc.path, (cached_subvol ?
-                                                  cached_subvol->name :
-                                                  "<nil>"), gfid);
-                }
+        /* non linkfile GFID takes precedence but don't overwrite
+         gfid if we have already found a cached file*/
+        if (!local->cached_subvol)
+            gf_uuid_copy(local->gfid, buf->ia_gfid);
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        if (is_dir) {
+            local->dir_count++;
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret,
-                                  local->op_errno, local->inode,
-                                  &local->stbuf, local->xattr,
-                                  &local->postparent);
-                return 0;
+            gf_msg_debug(this->name, 0, "found on %s directory %s", prev->name,
+                         loc->path);
+        } else {
+            local->file_count++;
+
+            gf_msg_debug(this->name, 0, "found cached file on %s for %s",
+                         prev->name, loc->path);
+
+            if (!local->cached_subvol) {
+                /* found one file */
+                dht_iatt_merge(this, &local->stbuf, buf);
+
+                local->xattr = dict_ref(xattr);
+                local->cached_subvol = prev;
+
+                gf_msg_debug(this->name, 0,
+                             "storing cached on %s file"
+                             " %s",
+                             prev->name, loc->path);
+
+                dht_iatt_merge(this, &local->postparent, postparent);
+
+                gf_uuid_copy(local->skip_unlink.cached_gfid, buf->ia_gfid);
+            } else {
+                /* This is where we need 'rename' both entries logic */
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_FILE_ON_MULT_SUBVOL,
+                       "multiple subvolumes (%s and %s) have "
+                       "file %s (preferably rename the file "
+                       "in the backend,and do a fresh lookup)",
+                       local->cached_subvol->name, prev->name, local->loc.path);
+            }
         }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!hashed_subvol) {
+    if (is_linkfile) {
+        ret = dict_get_int32(xattr, GLUSTERFS_OPEN_FD_COUNT, &fd_count);
 
-                gf_msg_debug (this->name, 0,
-                              "Cannot create linkfile for %s on %s: "
-                              "hashed subvolume cannot be found, gfid = %s.",
-                              local->loc.path, cached_subvol->name, gfid);
+        /*  Any linkto file found on the non-hashed subvolume should
+         *  be unlinked (performed in the "else if" block below)
+         *
+         *  But if a linkto file is found on hashed subvolume, it may be
+         *  pointing to valid cached node. So unlinking of linkto
+         *  file on hashed subvolume is skipped and inside
+         *  dht_lookup_everywhere_done, checks are performed. If this
+         *  linkto file is found as stale linkto file, it is deleted
+         *  otherwise unlink is skipped.
+         */
 
-                local->op_ret = 0;
-                local->op_errno = 0;
+        if (local->hashed_subvol && local->hashed_subvol == prev) {
+            local->skip_unlink.handle_valid_link = _gf_true;
+            local->skip_unlink.opend_fd_count = fd_count;
+            local->skip_unlink.hash_links_to = link_subvol;
+            gf_uuid_copy(local->skip_unlink.hashed_gfid, buf->ia_gfid);
+
+            gf_msg_debug(this->name, 0,
+                         "Found"
+                         " one linkto file on hashed subvol %s "
+                         "for %s: Skipping unlinking till "
+                         "everywhere_done",
+                         prev->name, loc->path);
+
+        } else if (!ret && (fd_count == 0)) {
+            dict_req = dict_new();
+
+            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(dict_req);
+
+            if (ret) {
+                /* Skip unlinking for dict_failure
+                 *File is found as a linkto file on non-hashed,
+                 *subvolume. In the current implementation,
+                 *finding a linkto-file on non-hashed does not
+                 *always implies that it is stale. So deletion
+                 *of file should be done only when both fd is
+                 *closed and linkto-xattr is set. In case of
+                 *dict_set failure, avoid skipping of file.
+                 *NOTE: dht_frame_return should get called for
+                 *      this block.
+                 */
 
-                ret = dht_layout_preset (frame->this, cached_subvol,
-                                         local->inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                "Failed to set layout for subvol %s"
-                                ", gfid = %s",
-                                cached_subvol ? cached_subvol->name :
-                                "<nil>", gfid);
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
-                }
+                dict_unref(dict_req);
+
+            } else {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                       "attempting deletion of stale linkfile "
+                       "%s on %s (hashed subvol is %s)",
+                       loc->path, prev->name,
+                       (local->hashed_subvol ? local->hashed_subvol->name
+                                             : "<null>"));
+                /* *
+                 * These stale files may be created using root
+                 * user. Hence deletion will work only with
+                 * root.
+                 */
+                FRAME_SU_DO(frame, dht_local_t);
+                STACK_WIND(frame, dht_lookup_unlink_cbk, prev,
+                           prev->fops->unlink, loc, 0, dict_req);
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+                dict_unref(dict_req);
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret,
-                                  local->op_errno, local->inode,
-                                  &local->stbuf, local->xattr,
-                                  &local->postparent);
                 return 0;
+            }
         }
+    }
 
-        gf_msg_debug (this->name, 0,
-                      "Creating linkto file on %s(hash) to %s on %s (gfid = %s)",
-                      hashed_subvol->name, local->loc.path,
-                      cached_subvol->name, gfid);
-
-        ret = dht_linkfile_create (frame,
-                                   dht_lookup_linkfile_create_cbk, this,
-                                   cached_subvol, hashed_subvol, &local->loc);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_lookup_everywhere_done(frame, this);
+    }
 
-        return ret;
-
-unwind_hashed_and_cached:
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
-        return 0;
+out:
+    return ret;
 }
 
 int
-dht_lookup_everywhere_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno,
-                           inode_t *inode, struct iatt *buf, dict_t *xattr,
-                           struct iatt *postparent)
-{
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev          = NULL;
-        int           is_linkfile   = 0;
-        int           is_dir        = 0;
-        xlator_t     *subvol        = NULL;
-        loc_t        *loc           = NULL;
-        xlator_t     *link_subvol   = NULL;
-        int           ret           = -1;
-        int32_t       fd_count      = 0;
-        dht_conf_t   *conf          = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-        dict_t       *dict_req      = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-
-        local  = frame->local;
-        loc    = &local->loc;
-        conf   = this->private;
-
-        prev   = cookie;
-        subvol = prev;
-
-        gf_msg_debug (this->name, 0,
-                      "returned with op_ret %d and op_errno %d (%s) "
-                      "from subvol %s", op_ret, op_errno, loc->path,
-                      subvol->name);
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno != ENOENT)
-                                local->op_errno = op_errno;
-                        goto unlock;
-                }
-
-                if (gf_uuid_is_null (local->gfid))
-                        gf_uuid_copy (local->gfid, buf->ia_gfid);
+dht_lookup_everywhere(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    int call_cnt = 0;
 
-                gf_uuid_unparse(local->gfid, gfid);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", loc, out);
 
-                if (gf_uuid_compare (local->gfid, buf->ia_gfid)) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "%s: gfid differs on subvolume %s,"
-                                " gfid local = %s, gfid node = %s",
-                                loc->path, prev->name, gfid,
-                                uuid_utoa(buf->ia_gfid));
-                }
+    conf = this->private;
+    local = frame->local;
 
-                is_linkfile = check_is_linkfile (inode, buf, xattr,
-                                                 conf->link_xattr_name);
-
-                if (is_linkfile) {
-                        link_subvol = dht_linkfile_subvol (this, inode, buf,
-                                                           xattr);
-                        gf_msg_debug (this->name, 0,
-                                      "found on %s linkfile %s (-> %s)",
-                                      subvol->name, loc->path,
-                                      link_subvol ? link_subvol->name : "''");
-                        goto unlock;
-                }
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-                is_dir = check_is_dir (inode, buf, xattr);
+    if (!local->inode)
+        local->inode = inode_ref(loc->inode);
 
-                /* non linkfile GFID takes precedence but don't overwrite
-                 gfid if we have already found a cached file*/
-                if (!local->cached_subvol)
-                        gf_uuid_copy (local->gfid, buf->ia_gfid);
+    gf_msg_debug(this->name, 0, "winding lookup call to %d subvols", call_cnt);
 
-                if (is_dir) {
-                        local->dir_count++;
-
-                        gf_msg_debug (this->name, 0,
-                                      "found on %s directory %s",
-                                      subvol->name, loc->path);
-                } else {
-                        local->file_count++;
-
-                        gf_msg_debug (this->name, 0,
-                                      "found cached file on %s for %s",
-                                      subvol->name, loc->path);
-
-                        if (!local->cached_subvol) {
-                                /* found one file */
-                                dht_iatt_merge (this, &local->stbuf, buf,
-                                                subvol);
-                                local->xattr = dict_ref (xattr);
-                                local->cached_subvol = subvol;
-
-                                gf_msg_debug (this->name, 0,
-                                              "storing cached on %s file"
-                                              " %s", subvol->name, loc->path);
-
-                                dht_iatt_merge (this, &local->postparent,
-                                                postparent, subvol);
-
-                                gf_uuid_copy (local->skip_unlink.cached_gfid,
-                                           buf->ia_gfid);
-                        } else {
-                                /* This is where we need 'rename' both entries logic */
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_FILE_ON_MULT_SUBVOL,
-                                        "multiple subvolumes (%s and %s) have "
-                                        "file %s (preferably rename the file "
-                                        "in the backend,and do a fresh lookup)",
-                                        local->cached_subvol->name,
-                                        subvol->name, local->loc.path);
-                        }
-                }
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (is_linkfile) {
-                ret = dict_get_int32 (xattr, GLUSTERFS_OPEN_FD_COUNT, &fd_count);
-
-                /*  Any linkto file found on the non-hashed subvolume should
-                 *  be unlinked (performed in the "else if" block below)
-                 *
-                 *  But if a linkto file is found on hashed subvolume, it may be
-                 *  pointing to valid cached node. So unlinking of linkto
-                 *  file on hashed subvolume is skipped and inside
-                 *  dht_lookup_everywhere_done, checks are performed. If this
-                 *  linkto file is found as stale linkto file, it is deleted
-                 *  otherwise unlink is skipped.
-                 */
-
-                if (local->hashed_subvol && local->hashed_subvol == subvol) {
-
-                        local->skip_unlink.handle_valid_link = _gf_true;
-                        local->skip_unlink.opend_fd_count = fd_count;
-                        local->skip_unlink.hash_links_to = link_subvol;
-                        gf_uuid_copy (local->skip_unlink.hashed_gfid,
-                                   buf->ia_gfid);
-
-                        gf_msg_debug (this->name, 0, "Found"
-                                      " one linkto file on hashed subvol %s "
-                                      "for %s: Skipping unlinking till "
-                                      "everywhere_done", subvol->name,
-                                      loc->path);
-
-                } else if (!ret && (fd_count == 0)) {
-
-                        dict_req = dict_new ();
-
-                        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                              (dict_req);
-
-                        if (ret) {
-
-                                /* Skip unlinking for dict_failure
-                                 *File is found as a linkto file on non-hashed,
-                                 *subvolume. In the current implementation,
-                                 *finding a linkto-file on non-hashed does not
-                                 *always implies that it is stale. So deletion
-                                 *of file should be done only when both fd is
-                                 *closed and linkto-xattr is set. In case of
-                                 *dict_set failure, avoid skipping of file.
-                                 *NOTE: dht_frame_return should get called for
-                                 *      this block.
-                                 */
-
-                                dict_unref (dict_req);
-
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_SUBVOL_INFO,
-                                        "attempting deletion of stale linkfile "
-                                        "%s on %s (hashed subvol is %s)",
-                                        loc->path, subvol->name,
-                                        (local->hashed_subvol?
-                                        local->hashed_subvol->name : "<null>"));
-                                /* *
-                                 * These stale files may be created using root
-                                 * user. Hence deletion will work only with
-                                 * root.
-                                 */
-                                FRAME_SU_DO (frame, dht_local_t);
-                                STACK_WIND (frame, dht_lookup_unlink_cbk,
-                                            subvol, subvol->fops->unlink, loc,
-                                            0, dict_req);
-
-                                dict_unref (dict_req);
-
-                                return 0;
-                        }
-                }
-        }
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_lookup_everywhere_done (frame, this);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_lookup_everywhere_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, loc,
+                          local->xattr_req);
+    }
 
+    return 0;
 out:
-        return ret;
+    DHT_STACK_UNWIND(lookup, frame, -1, EINVAL, NULL, NULL, NULL, NULL);
+err:
+    return -1;
 }
 
-
 int
-dht_lookup_everywhere (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        dht_conf_t     *conf = NULL;
-        dht_local_t    *local = NULL;
-        int             i = 0;
-        int             call_cnt = 0;
+dht_lookup_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, dict_t *xattr,
+                        struct iatt *postparent)
+{
+    xlator_t *prev = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    loc_t *loc = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, unwind);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, unwind);
+    GF_VALIDATE_OR_GOTO("dht", this->private, unwind);
+    GF_VALIDATE_OR_GOTO("dht", cookie, unwind);
+
+    prev = cookie;
+    subvol = prev;
+    conf = this->private;
+    local = frame->local;
+    loc = &local->loc;
+
+    gf_uuid_unparse(loc->gfid, gfid);
+
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "Lookup of %s on %s (following linkfile) failed "
+               ",gfid = %s",
+               local->loc.path, subvol->name, gfid);
+
+        /* If cached subvol returned ENOTCONN, do not do
+        lookup_everywhere. We need to make sure linkfile does not get
+        removed, which can take away the namespace, and subvol is
+        anyways down. */
+
+        local->cached_subvol = NULL;
+        if (op_errno != ENOTCONN)
+            goto err;
+        else
+            goto unwind;
+    }
+
+    if (check_is_dir(inode, stbuf, xattr)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "Lookup of %s on %s (following linkfile) reached dir,"
+               " gfid = %s",
+               local->loc.path, subvol->name, gfid);
+        goto err;
+    }
+
+    if (check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "lookup of %s on %s (following linkfile) reached link,"
+               "gfid = %s",
+               local->loc.path, subvol->name, gfid);
+        goto err;
+    }
+
+    if (gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on data file on %s,"
+               " gfid local = %s, gfid node = %s ",
+               local->loc.path, subvol->name, gfid, uuid_utoa(stbuf->ia_gfid));
+        goto err;
+    }
+
+    if ((stbuf->ia_nlink == 1) && (conf && conf->unhashed_sticky_bit)) {
+        stbuf->ia_prot.sticky = 1;
+    }
+
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+               "Failed to set layout for subvolume %s,"
+               "gfid = %s",
+               prev->name, gfid);
+        op_ret = -1;
+        op_errno = EINVAL;
+    }
+
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", loc, out);
+unwind:
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     postparent);
 
-        conf = this->private;
-        local = frame->local;
+    return 0;
 
-        call_cnt = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
-
-        if (!local->inode)
-                local->inode = inode_ref (loc->inode);
+err:
+    dht_lookup_everywhere(frame, this, loc);
+out:
+    return 0;
+}
 
-        gf_msg_debug (this->name, 0,
-                      "winding lookup call to %d subvols", call_cnt);
+/* Code to get hashed subvol based on inode and loc
+   First it check if loc->parent and loc->path exist then it get
+   hashed subvol based on loc.
+*/
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_lookup_everywhere_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   loc, local->xattr_req);
+static gf_boolean_t
+dht_should_lookup_everywhere(xlator_t *this, dht_conf_t *conf, loc_t *loc)
+{
+    dht_layout_t *parent_layout = NULL;
+    int ret = 0;
+    gf_boolean_t lookup_everywhere = _gf_true;
+
+    /* lookup-optimize supersedes lookup-unhashed settings.
+     * If it is set, do not process search_unhashed
+     * If lookup-optimize if enabled, lookup everywhere if:
+     *  - this is the rebalance daemon.
+     *  - loc->parent is unavailable.
+     *  - parent_layout is unavailable
+     *  - parent_layout->commit_hash != conf->vol_commit_hash
+     */
+
+    if (conf->lookup_optimize) {
+        if (!conf->defrag && loc->parent) {
+            ret = dht_inode_ctx_layout_get(loc->parent, this, &parent_layout);
+            if (!ret && parent_layout &&
+                (parent_layout->commit_hash == conf->vol_commit_hash)) {
+                lookup_everywhere = _gf_false;
+            }
         }
+        goto out;
+    } else {
+        if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) {
+            if (loc->parent) {
+                ret = dht_inode_ctx_layout_get(loc->parent, this,
+                                               &parent_layout);
+                if (ret || !parent_layout ||
+                    (!parent_layout->search_unhashed)) {
+                    lookup_everywhere = _gf_false;
+                }
+            } else {
+                lookup_everywhere = _gf_false;
+            }
 
-        return 0;
+            goto out;
+        }
+    }
 out:
-        DHT_STACK_UNWIND (lookup, frame, -1, EINVAL, NULL, NULL, NULL, NULL);
-err:
-        return -1;
+    return lookup_everywhere;
 }
 
-
 int
-dht_lookup_linkfile_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int op_ret, int op_errno,
-                         inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                         struct iatt *postparent)
-{
-        xlator_t     *prev          = NULL;
-        dht_local_t  *local         = NULL;
-        xlator_t     *subvol        = NULL;
-        loc_t        *loc           = NULL;
-        dht_conf_t   *conf          = NULL;
-        int           ret           = 0;
-        char          gfid[GF_UUID_BUF_SIZE]     = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, unwind);
-
-        prev   = cookie;
-        subvol = prev;
-        conf   = this->private;
-        local  = frame->local;
-        loc    = &local->loc;
+dht_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, inode_t *inode, struct iatt *stbuf, dict_t *xattr,
+               struct iatt *postparent)
+{
+    char is_linkfile = 0;
+    char is_dir = 0;
+    xlator_t *subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    xlator_t *prev = NULL;
+    int ret = 0;
+    uint32_t vol_commit_hash = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+
+    conf = this->private;
+
+    prev = cookie;
+    local = frame->local;
+    loc = &local->loc;
+
+    gf_msg_debug(this->name, op_errno,
+                 "%s: fresh_lookup on %s returned with op_ret %d", loc->path,
+                 prev->name, op_ret);
+
+    if (op_ret == -1) {
+        if (ENTRY_MISSING(op_ret, op_errno)) {
+            if (1 == conf->subvolume_cnt) {
+                /* No need to lookup again */
+                goto out;
+            }
 
-        gf_uuid_unparse(loc->gfid, gfid);
+            gf_msg_debug(this->name, 0, "Entry %s missing on subvol %s",
+                         loc->path, prev->name);
 
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "Lookup of %s on %s (following linkfile) failed "
-                        ",gfid = %s", local->loc.path, subvol->name, gfid);
-
-                /* If cached subvol returned ENOTCONN, do not do
-                lookup_everywhere. We need to make sure linkfile does not get
-                removed, which can take away the namespace, and subvol is
-                anyways down. */
-
-                if (op_errno != ENOTCONN)
-                        goto err;
-                else
-                        goto unwind;
-        }
+            if (dht_should_lookup_everywhere(this, conf, loc)) {
+                local->op_errno = ENOENT;
+                dht_lookup_everywhere(frame, this, loc);
+                return 0;
+            }
 
-        if (check_is_dir (inode, stbuf, xattr)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "Lookup of %s on %s (following linkfile) reached dir,"
-                        " gfid = %s", local->loc.path, subvol->name, gfid);
-                goto err;
+        } else {
+            /* posix returns ENODATA if the gfid is not set but the client and
+             * server protocol layers do not send the stbuf. We need to
+             * heal this so check if this is a directory on the other subvols.
+             */
+            if ((op_errno == ENOTCONN) || (op_errno == ENODATA)) {
+                dht_lookup_directory(frame, this, &local->loc);
+                return 0;
+            }
         }
-
-        if (check_is_linkfile (inode, stbuf, xattr, conf->link_xattr_name)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "lookup of %s on %s (following linkfile) reached link,"
-                        "gfid = %s", local->loc.path, subvol->name, gfid);
-                goto err;
+        gf_msg_debug(this->name, op_errno, "%s: Lookup on subvolume %s failed",
+                     loc->path, prev->name);
+        goto out;
+    }
+
+    /* Lookup succeeded - op_ret = 0 */
+
+    /* This is required for handling stale linkfile deletion,
+     * or any more call which happens from this 'loc'.
+     */
+    if (gf_uuid_is_null(local->gfid)) {
+        /*This is set from the first successful response*/
+        memcpy(local->gfid, stbuf->ia_gfid, 16);
+    }
+
+    if (!conf->vch_forced) {
+        /* Update the commit hash in conf if it is found */
+        ret = dict_get_uint32(xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
         }
+    }
 
-        if (gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on data file on %s,"
-                        " gfid local = %s, gfid node = %s ",
-                        local->loc.path, subvol->name, gfid,
-                        uuid_utoa(stbuf->ia_gfid));
-                goto err;
-        }
+    is_dir = check_is_dir(inode, stbuf, xattr);
+    if (is_dir) {
+        /* A directory is present on all subvols, send the lookup to
+         * all subvols now */
+        local->inode = inode_ref(inode);
+        local->xattr = dict_ref(xattr);
+        dht_lookup_directory(frame, this, &local->loc);
+        return 0;
+    }
 
-        if ((stbuf->ia_nlink == 1)
-            && (conf && conf->unhashed_sticky_bit)) {
-                stbuf->ia_prot.sticky = 1;
-        }
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
+
+    if (!is_linkfile) {
+        /* non-directory and not a linkto file. This is a data file
+         * Update the layout to point to the cached subvol
+         */
 
-        ret = dht_layout_preset (this, prev, inode);
+        ret = dht_layout_preset(this, prev, inode);
         if (ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LAYOUT_PRESET_FAILED,
-                        "Failed to set layout for subvolume %s,"
-                        "gfid = %s", prev->name, gfid);
-                op_ret   = -1;
-                op_errno = EINVAL;
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+                   "%s: could not set pre-set layout for subvolume %s",
+                   loc->path, prev->name);
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto out;
         }
+        goto out;
+    }
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+    /* This is a linkto file. Get the value of the target subvol from the
+     * linkto xattr and lookup there to see if the file exists
+     */
+    subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "%s: No link subvol for linkto", loc->path);
+        dht_lookup_everywhere(frame, this, loc);
+        return 0;
+    }
 
-unwind:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
-                          postparent);
+    gf_msg_debug(this->name, 0, "%s: Calling lookup on linkto target %s",
+                 loc->path, subvol->name);
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                      subvol->fops->lookup, &local->loc, local->xattr_req);
+
+    return 0;
 
-err:
-        dht_lookup_everywhere (frame, this, loc);
 out:
-        return 0;
+    /*
+     * FIXME: postparent->ia_size and postparent->st_blocks do not have
+     * correct values. since, postparent corresponds to a directory these
+     * two members should have values equal to sum of corresponding values
+     * from each of the subvolume. See dht_iatt_merge for reference.
+     */
+
+    if (!op_ret && local && local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     postparent);
+err:
+    return 0;
 }
 
-
-int
-dht_lookup_directory (call_frame_t *frame, xlator_t *this, loc_t *loc)
+/* For directories, check if acl xattrs have been requested (by the acl
+ * xlator), if not, request for them. These xattrs are needed for dht dir
+ * self-heal to perform proper self-healing of dirs
+ */
+static void
+dht_check_and_set_acl_xattr_req(xlator_t *this, dict_t *xattr_req)
 {
-        int           call_cnt = 0;
-        int           i = 0;
-        dht_conf_t   *conf = NULL;
-        dht_local_t  *local = NULL;
-        int           ret = 0;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", loc, unwind);
+    GF_ASSERT(xattr_req);
 
-        conf = this->private;
-        local = frame->local;
+    if (!dict_get(xattr_req, POSIX_ACL_ACCESS_XATTR)) {
+        ret = dict_set_int8(xattr_req, POSIX_ACL_ACCESS_XATTR, 0);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value:key = %s",
+                   POSIX_ACL_ACCESS_XATTR);
+    }
+
+    if (!dict_get(xattr_req, POSIX_ACL_DEFAULT_XATTR)) {
+        ret = dict_set_int8(xattr_req, POSIX_ACL_DEFAULT_XATTR, 0);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value:key = %s",
+                   POSIX_ACL_DEFAULT_XATTR);
+    }
+
+    return;
+}
 
-        call_cnt        = conf->subvolume_cnt;
+/* for directories, we need the following info:
+ * the layout : trusted.glusterfs.dht
+ * the mds information : trusted.glusterfs.dht.mds
+ * the acl info: See above
+ */
+static int
+dht_set_dir_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    int ret = -EINVAL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    if (!conf) {
+        goto err;
+    }
+
+    if (!xattr_req) {
+        goto err;
+    }
+
+    /* Xattr to get the layout for a directory
+     */
+    ret = dict_set_uint32(xattr_req, conf->xattr_name, 4 * 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->xattr_name, loc->path);
+        goto err;
+    }
+
+    /*Non-fatal failure */
+    ret = dict_set_uint32(xattr_req, conf->mds_xattr_key, 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->mds_xattr_key, loc->path);
+    }
+
+    dht_check_and_set_acl_xattr_req(this, xattr_req);
+    ret = 0;
+err:
+    return ret;
+}
+
+/* If the hashed subvol is present, send the lookup to only that subvol first.
+ * If no hashed subvol, send a lookup to all subvols and proceed based on the
+ * responses.
+ */
+static int
+dht_do_fresh_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int call_cnt = 0;
+    int i = 0;
+
+    conf = this->private;
+    if (!conf) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Since we don't know whether this is a file or a directory,
+     * request all xattrs*/
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    /* Fuse sets a random value in gfid-req. If the gfid is missing
+     * on one or more subvols, posix will set the gfid to this value,
+     * causing GFID mismatches for directories. Remove the value fuse
+     * has sent before sending the lookup.
+     */
+    ret = dict_get_gfuuid(local->xattr_req, "gfid-req", &local->gfid_req);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "%s: No gfid-req available", loc->path);
+    } else {
+        dict_del(local->xattr_req, "gfid-req");
+    }
+    /* This should have been set in dht_lookup */
+    hashed_subvol = local->hashed_subvol;
+
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "%s: no subvolume in layout for path, "
+                     "checking on all the subvols to see if "
+                     "it is a directory",
+                     loc->path);
+
+        call_cnt = conf->subvolume_cnt;
         local->call_cnt = call_cnt;
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
+        /* Allocate a layout. This will be populated and saved in
+         * the dht inode_ctx on successful lookup
+         */
+        local->layout = dht_layout_new(this, conf->subvolume_cnt);
         if (!local->layout) {
-                goto unwind;
+            op_errno = ENOMEM;
+            goto err;
         }
 
-        if (local->xattr != NULL) {
-                dict_unref (local->xattr);
-                local->xattr = NULL;
-        }
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                ret = dict_set_static_bin (local->xattr_req, "gfid-req",
-                                           local->gfid, 16);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:"
-                                " key = gfid-req", local->loc.path);
-        }
+        gf_msg_debug(this->name, 0,
+                     "%s: Found null hashed subvol. Calling lookup"
+                     " on all nodes.",
+                     loc->path);
 
         for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
+            STACK_WIND_COOKIE(frame, dht_lookup_dir_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
         }
         return 0;
-unwind:
-        DHT_STACK_UNWIND (lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
-out:
-        return 0;
+    }
 
-}
+    /* if the hashed_subvol is non-null, send the lookup there first so
+     * as to see whether we have a file or a directory */
+    gf_msg_debug(this->name, 0, "%s: Calling fresh lookup on %s", loc->path,
+                 hashed_subvol->name);
 
+    STACK_WIND_COOKIE(frame, dht_lookup_cbk, hashed_subvol, hashed_subvol,
+                      hashed_subvol->fops->lookup, loc, local->xattr_req);
+    return 0;
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
+}
 
-int
-dht_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno,
-                inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                struct iatt *postparent)
-{
-        char          is_linkfile   = 0;
-        char          is_dir        = 0;
-        xlator_t     *subvol        = NULL;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        loc_t        *loc           = NULL;
-        xlator_t     *prev          = NULL;
-        int           ret           = 0;
-        dht_layout_t *parent_layout = NULL;
-        uint32_t      vol_commit_hash = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-
-        conf  = this->private;
-
-        prev  = cookie;
-        local = frame->local;
-        loc   = &local->loc;
+static int
+dht_do_revalidate(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+    int gen = 0;
+
+    conf = this->private;
+    if (!conf) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0,
+                     "path = %s. No layout found in the inode ctx.", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Generation number has changed. This layout may be stale. */
+    if (layout->gen && (layout->gen < conf->gen)) {
+        gen = layout->gen;
+        dht_layout_unref(this, local->layout);
+        local->layout = NULL;
+        local->cached_subvol = NULL;
+
+        gf_msg_debug(this->name, 0,
+                     "path = %s. In memory layout may be stale."
+                     "(layout->gen (%d) is less than "
+                     "conf->gen (%d)). Calling fresh lookup.",
+                     loc->path, gen, conf->gen);
+
+        dht_do_fresh_lookup(frame, this, loc);
+        return 0;
+    }
+
+    local->inode = inode_ref(loc->inode);
+
+    /* Since we don't know whether this has changed,
+     * request all xattrs*/
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    if (IA_ISDIR(local->inode->ia_type)) {
+        ret = dht_inode_ctx_mdsvol_get(local->inode, this, &mds_subvol);
+        if (ret || !mds_subvol) {
+            gf_msg_debug(this->name, 0, "path = %s. No mds subvol in inode ctx",
+                         local->loc.path);
+        }
+        local->mds_subvol = mds_subvol;
+        local->call_cnt = conf->subvolume_cnt;
 
-        /* This is required for handling stale linkfile deletion,
-         * or any more call which happens from this 'loc'.
+        /* local->call_cnt will change as responses are processed. Always use a
+         * local copy to loop through the STACK_WIND calls
          */
-        if (!op_ret && gf_uuid_is_null (local->gfid))
-                memcpy (local->gfid, stbuf->ia_gfid, 16);
-
-        gf_msg_debug (this->name, op_errno,
-                      "fresh_lookup returned for %s with op_ret %d",
-                      loc->path, op_ret);
-
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (xattr, conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
-        }
-
-        if (ENTRY_MISSING (op_ret, op_errno)) {
-                gf_msg_debug (this->name, 0,
-                              "Entry %s missing on subvol %s",
-                              loc->path, prev->name);
-
-                /* lookup-optimize supercedes lookup-unhashed settings,
-                 *   - so if it is set, do not process search_unhashed
-                 *   - except, in the case of rebalance deamon, we want to
-                 *     force the lookup_everywhere behavior */
-                if (!conf->defrag && conf->lookup_optimize && loc->parent) {
-                        ret = dht_inode_ctx_layout_get (loc->parent, this,
-                                                        &parent_layout);
-                        if (ret || !parent_layout ||
-                            (parent_layout->commit_hash !=
-                             conf->vol_commit_hash)) {
-                                gf_msg_debug (this->name, 0,
-                                              "hashes don't match (ret - %d,"
-                                              " parent_layout - %p, parent_hash - %x,"
-                                              " vol_hash - %x), do global lookup",
-                                              ret, parent_layout,
-                                              (parent_layout ?
-                                              parent_layout->commit_hash : -1),
-                                              conf->vol_commit_hash);
-                                local->op_errno = ENOENT;
-                                dht_lookup_everywhere (frame, this, loc);
-                                return 0;
-                        }
-                } else {
-                        if (conf->search_unhashed ==
-                            GF_DHT_LOOKUP_UNHASHED_ON) {
-                                local->op_errno = ENOENT;
-                                dht_lookup_everywhere (frame, this, loc);
-                                return 0;
-                        }
 
-                        if ((conf->search_unhashed ==
-                            GF_DHT_LOOKUP_UNHASHED_AUTO) &&
-                            (loc->parent)) {
-                                ret = dht_inode_ctx_layout_get (loc->parent,
-                                                                this,
-                                                                &parent_layout);
-                                if (ret || !parent_layout)
-                                        goto out;
-                                if (parent_layout->search_unhashed) {
-                                        local->op_errno = ENOENT;
-                                        dht_lookup_everywhere (frame, this,
-                                                               loc);
-                                        return 0;
-                                }
-                        }
-                }
-        }
+        call_cnt = local->call_cnt;
 
-        if (op_ret == 0) {
-                is_dir      = check_is_dir (inode, stbuf, xattr);
-                if (is_dir) {
-                        local->inode = inode_ref (inode);
-                        local->xattr = dict_ref (xattr);
-                }
-        }
-
-        if (is_dir || (op_ret == -1 && op_errno == ENOTCONN)) {
-                dht_lookup_directory (frame, this, &local->loc);
-                return 0;
-        }
-
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, op_errno,
-                              "Lookup of %s for subvolume"
-                              " %s failed", loc->path,
-                              prev->name);
-                goto out;
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_revalidate_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, loc,
+                              local->xattr_req);
         }
+        return 0;
+    }
 
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
-
-        if (!is_linkfile) {
-                /* non-directory and not a linkfile */
+    /* If not a dir, this should be 1 */
+    local->call_cnt = layout->cnt;
+    call_cnt = local->call_cnt;
 
-                ret = dht_layout_preset (this, prev, inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                "could not set pre-set layout for subvolume %s",
-                                prev->name);
-                        op_ret   = -1;
-                        op_errno = EINVAL;
-                        goto out;
-                }
-                goto out;
-        }
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
 
-        subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
-        if (!subvol) {
+        gf_msg_debug(this->name, 0,
+                     "path = %s. Calling "
+                     "revalidate lookup on %s",
+                     loc->path, subvol->name);
 
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO, "linkfile not having link "
-                        "subvol for %s", loc->path);
+        STACK_WIND_COOKIE(frame, dht_revalidate_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, local->xattr_req);
+    }
+    return 0;
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
+}
 
-                gf_msg_debug (this->name, 0,
-                              "linkfile not having link subvolume. path=%s",
-                              loc->path);
-                dht_lookup_everywhere (frame, this, loc);
-                return 0;
-        }
+/* Depending on the input, decide if this is a:
+ * fresh-lookup: loc->name is provided but no dht inode ctx
+ * revalidation: loc->name is provided, dht inode ctx is present
+ * discover: gfid based nameless lookup.
+ */
 
-        gf_msg_debug (this->name, 0,
-                      "Calling lookup on linkto target %s for path %s",
-                      subvol->name, loc->path);
+int
+dht_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    loc_t new_loc = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    conf = this->private;
+    if (!conf)
+        goto err;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_LOOKUP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    ret = dht_filter_loc_subvol_key(this, loc, &new_loc, &hashed_subvol);
+    if (ret) {
+        loc_wipe(&local->loc);
+        ret = loc_dup(&new_loc, &local->loc);
+
+        /* we no longer need 'new_loc' entries */
+        loc_wipe(&new_loc);
+
+        /* check if loc_dup() is successful */
+        if (ret == -1) {
+            op_errno = errno;
+            gf_msg_debug(this->name, errno,
+                         "copying location failed for path=%s", loc->path);
+            goto err;
+        }
+    }
+
+    if (xattr_req) {
+        local->xattr_req = dict_ref(xattr_req);
+    } else {
+        local->xattr_req = dict_new();
+    }
+
+    /* Nameless lookup */
+
+    /* This is usually sent by NFS. Lookups are done based on the gfid and
+     * no name information is available. Without the name, dht cannot calculate
+     * the hash and has to send a lookup to all subvols.
+     */
+    if (gf_uuid_is_null(loc->pargfid) && !gf_uuid_is_null(loc->gfid) &&
+        !__is_root_gfid(loc->inode->gfid)) {
+        local->cached_subvol = NULL;
+        dht_do_discover(frame, this, loc);
+        return 0;
+    }
+
+    if (loc_is_root(loc)) {
+        /* Request the DHT commit hash xattr (trusted.glusterfs.dht.commithash)
+         * set on the brick root.
+         */
+        ret = dict_set_uint32(local->xattr_req, conf->commithash_xattr_name,
+                              sizeof(uint32_t));
+    }
 
-        STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk, subvol,
-                           subvol, subvol->fops->lookup,
-                           &local->loc, local->xattr_req);
+    if (!hashed_subvol)
+        hashed_subvol = dht_subvol_get_hashed(this, loc);
+    local->hashed_subvol = hashed_subvol;
 
+    if (is_revalidate(loc)) {
+        /* The entry has been looked up before and has a dht inode_ctx
+         */
+        dht_do_revalidate(frame, this, loc);
         return 0;
-
-out:
-        /*
-         * FIXME: postparent->ia_size and postparent->st_blocks do not have
-         * correct values. since, postparent corresponds to a directory these
-         * two members should have values equal to sum of corresponding values
-         * from each of the subvolume. See dht_iatt_merge for reference.
+    } else {
+        /* Entry has not been looked up before
          */
+        dht_do_fresh_lookup(frame, this, loc);
+        return 0;
+    }
 
-        if (!op_ret && local && local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
-
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
-                          postparent);
+    return 0;
 err:
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-/* For directories, check if acl xattrs have been requested (by the acl xlator),
- * if not, request for them. These xattrs are needed for dht dir self-heal to
- * perform proper self-healing of dirs
- */
-void
-dht_check_and_set_acl_xattr_req (inode_t *inode, dict_t *xattr_req)
+static int
+dht_unlink_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        int     ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
-        GF_ASSERT (inode);
-        GF_ASSERT (xattr_req);
+    local = frame->local;
+    prev = cookie;
 
-        if (inode->ia_type != IA_IFDIR)
-                return;
-
-        if (!dict_get (xattr_req, POSIX_ACL_ACCESS_XATTR)) {
-                ret = dict_set_int8 (xattr_req, POSIX_ACL_ACCESS_XATTR, 0);
-                if (ret)
-                        gf_msg (THIS->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s",
-                                POSIX_ACL_ACCESS_XATTR);
+    LOCK(&frame->lock);
+    {
+        if ((op_ret == -1) &&
+            !((op_errno == ENOENT) || (op_errno == ENOTCONN))) {
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink link: subvolume %s returned -1", prev->name);
+            goto post_unlock;
         }
 
-        if (!dict_get (xattr_req, POSIX_ACL_DEFAULT_XATTR)) {
-                ret = dict_set_int8 (xattr_req, POSIX_ACL_DEFAULT_XATTR, 0);
-                if (ret)
-                        gf_msg (THIS->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s",
-                                POSIX_ACL_DEFAULT_XATTR);
-        }
+        local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return;
+    return 0;
 }
 
-int
-dht_lookup (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, dict_t *xattr_req)
-{
-        xlator_t     *subvol = NULL;
-        xlator_t     *hashed_subvol = NULL;
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret    = -1;
-        int           op_errno = -1;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-        int           gen = 0;
-        loc_t         new_loc = {0,};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        conf = this->private;
-        if (!conf)
-                goto err;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_LOOKUP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        ret = dht_filter_loc_subvol_key (this, loc, &new_loc,
-                                         &hashed_subvol);
-        if (ret) {
-                loc_wipe (&local->loc);
-                ret = loc_dup (&new_loc, &local->loc);
-
-                /* we no more need 'new_loc' entries */
-                loc_wipe (&new_loc);
-
-                /* check if loc_dup() is successful */
-                if (ret == -1) {
-                        op_errno = errno;
-                        gf_msg_debug (this->name, errno,
-                                      "copying location failed for path=%s",
-                                      loc->path);
-                        goto err;
-                }
-        }
-
-        if (xattr_req) {
-                local->xattr_req = dict_ref (xattr_req);
-        } else {
-                local->xattr_req = dict_new ();
-        }
+static int
+dht_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *preparent, struct iatt *postparent,
+               dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *hashed_subvol = NULL;
 
-        if (gf_uuid_is_null (loc->pargfid) && !gf_uuid_is_null (loc->gfid) &&
-            !__is_root_gfid (loc->inode->gfid)) {
-                local->cached_subvol = NULL;
-                dht_discover (frame, this, loc);
-                return 0;
-        }
+    local = frame->local;
+    prev = cookie;
 
-        if (__is_root_gfid(loc->gfid)) {
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->commithash_xattr_name,
-                                       sizeof(uint32_t));
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno != ENOENT) {
+                local->op_ret = -1;
+                local->op_errno = op_errno;
+            } else {
+                local->op_ret = 0;
+            }
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink: subvolume %s returned -1", prev->name);
+            goto post_unlock;
         }
 
-        if (!hashed_subvol)
-                hashed_subvol = dht_subvol_get_hashed (this, loc);
-        local->hashed_subvol = hashed_subvol;
+        local->op_ret = 0;
 
-        if (is_revalidate (loc)) {
-                layout = local->layout;
-                if (!layout) {
-                        gf_msg_debug (this->name, 0,
-                                      "Revalidate lookup without cache."
-                                      " path=%s", loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
+        local->postparent = *postparent;
+        local->preparent = *preparent;
 
-                if (layout->gen && (layout->gen < conf->gen)) {
-                        gf_msg_trace (this->name, 0,
-                                      "incomplete layout failure for path=%s",
-                                      loc->path);
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->preparent, 0);
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    if (!local->op_ret) {
+        hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
+        if (hashed_subvol && hashed_subvol != local->cached_subvol) {
+            /*
+             * If hashed and cached are different, then we need
+             * to unlink linkfile from hashed subvol if data
+             * file is deleted successfully
+             */
+            STACK_WIND_COOKIE(frame, dht_unlink_linkfile_cbk, hashed_subvol,
+                              hashed_subvol, hashed_subvol->fops->unlink,
+                              &local->loc, local->flags, xdata);
+            return 0;
+        }
+    }
+
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
+
+    return 0;
+}
 
-                        gen = layout->gen;
-                        dht_layout_unref (this, local->layout);
-                        local->layout = NULL;
-                        local->cached_subvol = NULL;
+static int
+dht_common_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+    DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
+}
 
-                        gf_msg_debug(this->name, 0,
-                                     "Called revalidate lookup for %s, "
-                                     "but layout->gen (%d) is less than "
-                                     "conf->gen (%d), calling fresh_lookup",
-                                     loc->path, gen, conf->gen);
+static int
+dht_fix_layout_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
 
-                        goto do_fresh_lookup;
-                }
+    if (op_ret == 0) {
+        /* update the layout in the inode ctx */
+        local = frame->local;
+        layout = local->selfheal.layout;
 
-                local->inode = inode_ref (loc->inode);
+        dht_layout_set(this, local->loc.inode, layout);
+    }
 
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", conf->xattr_name, loc->path);
-                        goto err;
-                }
-                /* need it in case file is not found on cached file
-                 * on revalidate path and we may encounter linkto files on
-                 * with dht_lookup_everywhere*/
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->link_xattr_name, 256);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", conf->link_xattr_name, loc->path);
-                        goto err;
-                }
-                if (IA_ISDIR (local->inode->ia_type)) {
-                        local->call_cnt = call_cnt = conf->subvolume_cnt;
-                        for (i = 0; i < call_cnt; i++) {
-                                STACK_WIND_COOKIE (frame, dht_revalidate_cbk,
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i]->fops->lookup,
-                                                   loc, local->xattr_req);
-                        }
-                        return 0;
-                }
-
-                call_cnt = local->call_cnt = layout->cnt;
+    DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
+}
 
-                /* need it for self-healing linkfiles which is
-                   'in-migration' state */
-                ret = dict_set_uint32 (local->xattr_req,
-                                       GLUSTERFS_OPEN_FD_COUNT, 4);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", GLUSTERFS_OPEN_FD_COUNT, loc->path);
-                        goto err;
-                }
-                /* need it for dir self-heal */
-                dht_check_and_set_acl_xattr_req (loc->inode, local->xattr_req);
+static int
+dht_err_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+            int op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-                for (i = 0; i < call_cnt; i++) {
-                        subvol = layout->list[i].xlator;
+    local = frame->local;
+    prev = cookie;
 
-                        gf_msg_debug (this->name, 0, "calling "
-                                      "revalidate lookup for %s at %s",
-                                      loc->path, subvol->name);
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto post_unlock;
+        }
 
-                        STACK_WIND_COOKIE (frame, dht_revalidate_cbk, subvol,
-                                           subvol, subvol->fops->lookup,
-                                           &local->loc, local->xattr_req);
+        local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if ((local->fop == GF_FOP_SETXATTR) ||
+            (local->fop == GF_FOP_FSETXATTR)) {
+            DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                             NULL);
+            /* 'local' itself may not be valid after this */
+            goto out;
+        }
+        if ((local->fop == GF_FOP_REMOVEXATTR) ||
+            (local->fop == GF_FOP_FREMOVEXATTR)) {
+            DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                             NULL);
+        }
+    }
 
-                }
-        } else {
-        do_fresh_lookup:
-                /* TODO: remove the hard-coding */
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", conf->xattr_name, loc->path);
-                        goto err;
-                }
+out:
+    return 0;
+}
 
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->link_xattr_name, 256);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", conf->link_xattr_name, loc->path);
-                        goto err;
-                }
-                /* need it for self-healing linkfiles which is
-                   'in-migration' state */
-                ret = dict_set_uint32 (local->xattr_req,
-                                       GLUSTERFS_OPEN_FD_COUNT, 4);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", GLUSTERFS_OPEN_FD_COUNT, loc->path);
-                        goto err;
-                }
-                /* need it for dir self-heal */
-                dht_check_and_set_acl_xattr_req (loc->inode, local->xattr_req);
+/* Set the value[] of key into dict after convert from
+   host byte order to network byte order
+*/
+int32_t
+dht_dict_set_array(dict_t *dict, char *key, int32_t value[], int32_t size)
+{
+    int ret = -1;
+    int32_t *ptr = NULL;
+    int32_t vindex;
 
-                if (!hashed_subvol) {
+    if (value == NULL) {
+        return -EINVAL;
+    }
 
-                        gf_msg_debug (this->name, 0,
-                                      "no subvolume in layout for path=%s, "
-                                      "checking on all the subvols to see if "
-                                      "it is a directory", loc->path);
+    ptr = GF_MALLOC(sizeof(int32_t) * size, gf_common_mt_char);
+    if (ptr == NULL) {
+        return -ENOMEM;
+    }
+    for (vindex = 0; vindex < size; vindex++) {
+        ptr[vindex] = hton32(value[vindex]);
+    }
+    ret = dict_set_bin(dict, key, ptr, sizeof(int32_t) * size);
+    if (ret)
+        GF_FREE(ptr);
+    return ret;
+}
 
-                        call_cnt        = conf->subvolume_cnt;
-                        local->call_cnt = call_cnt;
+static int
+dht_common_mds_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    call_frame_t *prev = cookie;
 
-                        local->layout = dht_layout_new (this,
-                                                        conf->subvolume_cnt);
-                        if (!local->layout) {
-                                op_errno = ENOMEM;
-                                goto err;
-                        }
+    local = frame->local;
 
-                        gf_msg_debug (this->name, 0,
-                                      "Found null hashed subvol. Calling lookup"
-                                      " on all nodes.");
+    if (op_ret)
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
 
-                        for (i = 0; i < call_cnt; i++) {
-                                STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i]->fops->lookup,
-                                                   &local->loc, local->xattr_req);
-                        }
-                        return 0;
-                }
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, 0, op_errno, local->xdata);
+        /* 'local' itself may not be valid after this */
+        goto out;
+    }
 
-                gf_msg_debug (this->name, 0, "Calling fresh lookup for %s on"
-                              " %s", loc->path, hashed_subvol->name);
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, 0, op_errno, local->xdata);
+        /* 'local' itself may not be valid after this */
+        goto out;
+    }
 
-                STACK_WIND_COOKIE (frame, dht_lookup_cbk, hashed_subvol,
-                                   hashed_subvol, hashed_subvol->fops->lookup,
-                                   loc, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, 0, op_errno, NULL);
+        /* 'local' itself may not be valid after this */
+        goto out;
+    }
 
-        return 0;
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, 0, op_errno, NULL);
+    }
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
-        return 0;
+out:
+    return 0;
 }
 
-int
-dht_unlink_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+/* Code to wind a xattrop call to add 1 on current mds internal xattr
+   value
+*/
+static int
+dht_setxattr_non_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *prev           = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int ret = 0;
+    dict_t *xattrop = NULL;
+    int32_t addone[1] = {1};
+    call_frame_t *prev = NULL;
+    dht_conf_t *conf = NULL;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret && !local->op_ret) {
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->this->name);
+            goto post_unlock;
+        }
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+
+    if (is_last_call(this_call_cnt)) {
+        if (!local->op_ret) {
+            xattrop = dict_new();
+            if (!xattrop) {
+                gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+                       "dictionary creation failed");
+                ret = -1;
+                goto out;
+            }
+            ret = dht_dict_set_array(xattrop, conf->mds_xattr_key, addone, 1);
+            if (ret != 0) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                       "dictionary set array failed ");
+                ret = -1;
+                goto out;
+            }
+            if ((local->fop == GF_FOP_SETXATTR) ||
+                (local->fop == GF_FOP_REMOVEXATTR)) {
+                STACK_WIND(frame, dht_common_mds_xattrop_cbk, local->mds_subvol,
+                           local->mds_subvol->fops->xattrop, &local->loc,
+                           GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+            } else {
+                STACK_WIND(frame, dht_common_mds_xattrop_cbk, local->mds_subvol,
+                           local->mds_subvol->fops->fxattrop, local->fd,
+                           GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+            }
+        } else {
+            if (local->fop == GF_FOP_SETXATTR) {
+                DHT_STACK_UNWIND(setxattr, frame, 0, 0, local->xdata);
+                /* 'local' itself may not be valid after this */
+                goto just_return;
+            }
 
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if ((op_ret == -1) && !((op_errno == ENOENT) ||
-                                        (op_errno == ENOTCONN))) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink link: subvolume %s"
-                                      " returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+            if (local->fop == GF_FOP_FSETXATTR) {
+                DHT_STACK_UNWIND(fsetxattr, frame, 0, 0, local->xdata);
+                /* 'local' itself may not be valid after this */
+                goto just_return;
+            }
 
-                local->op_ret = 0;
+            if (local->fop == GF_FOP_REMOVEXATTR) {
+                DHT_STACK_UNWIND(removexattr, frame, 0, 0, NULL);
+                /* 'local' itself may not be valid after this */
+                goto just_return;
+            }
+
+            if (local->fop == GF_FOP_FREMOVEXATTR) {
+                DHT_STACK_UNWIND(fremovexattr, frame, 0, 0, NULL);
+                /* 'local' itself may not be valid after this */
+                goto just_return;
+            }
+        }
+    }
+out:
+    if (ret) {
+        if (local->fop == GF_FOP_SETXATTR) {
+            DHT_STACK_UNWIND(setxattr, frame, 0, 0, local->xdata);
+            /* 'local' itself may not be valid after this */
+            goto just_return;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+        if (local->fop == GF_FOP_FSETXATTR) {
+            DHT_STACK_UNWIND(fsetxattr, frame, 0, 0, local->xdata);
+            /* 'local' itself may not be valid after this */
+            goto just_return;
+        }
 
-        return 0;
+        if (local->fop == GF_FOP_REMOVEXATTR) {
+            DHT_STACK_UNWIND(removexattr, frame, 0, 0, NULL);
+            /* 'local' itself may not be valid after this */
+            goto just_return;
+        }
+
+        if (local->fop == GF_FOP_FREMOVEXATTR) {
+            DHT_STACK_UNWIND(fremovexattr, frame, 0, 0, NULL);
+        }
+    }
+just_return:
+    if (xattrop)
+        dict_unref(xattrop);
+    return 0;
 }
 
-int
-dht_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
+static int
+dht_setxattr_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *prev           = NULL;
-        xlator_t        *hashed_subvol  = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    call_frame_t *prev = NULL;
+    xlator_t *mds_subvol = NULL;
+    int i = 0;
 
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno != ENOENT) {
-                                local->op_ret   = -1;
-                                local->op_errno = op_errno;
-                        } else {
-                                local->op_ret = 0;
-                        }
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink: subvolume %s returned -1",
-                                       prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    mds_subvol = local->mds_subvol;
 
-                local->op_ret = 0;
+    if (op_ret == -1) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
+        goto out;
+    }
 
-                local->postparent = *postparent;
-                local->preparent = *preparent;
+    local->op_ret = 0;
+    local->call_cnt = conf->subvolume_cnt - 1;
+    local->xdata = dict_ref(xdata);
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->preparent, 0);
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol && (mds_subvol == conf->subvolumes[i]))
+            continue;
+        if (local->fop == GF_FOP_SETXATTR) {
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->setxattr, &local->loc,
+                       local->xattr, local->flags, local->xattr_req);
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        if (!local->op_ret) {
-                hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
-                if (hashed_subvol &&
-                hashed_subvol != local->cached_subvol) {
-                        /*
-                         * If hashed and cached are different, then we need
-                         * to unlink linkfile from hashed subvol if data
-                         * file is deleted successfully
-                         */
-                        STACK_WIND_COOKIE (frame, dht_unlink_linkfile_cbk,
-                                           hashed_subvol, hashed_subvol,
-                                           hashed_subvol->fops->unlink, &local->loc,
-                                           local->flags, xdata);
-                        return 0;
-                }
+        if (local->fop == GF_FOP_FSETXATTR) {
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->fsetxattr, local->fd,
+                       local->xattr, local->flags, local->xattr_req);
         }
 
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+        if (local->fop == GF_FOP_REMOVEXATTR) {
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->removexattr, &local->loc,
+                       local->key, local->xattr_req);
+        }
 
-        return 0;
+        if (local->fop == GF_FOP_FREMOVEXATTR) {
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->fremovexattr, local->fd,
+                       local->key, local->xattr_req);
+        }
+    }
+
+    return 0;
+out:
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
+
+just_return:
+    return 0;
 }
 
-int
-dht_err_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int op_ret, int op_errno, dict_t *xdata)
+static int
+dht_xattrop_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
-
-                local->op_ret = 0;
-        }
-unlock:
-        UNLOCK (&frame->lock);
+    dht_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
-        }
+    local = frame->local;
+    prev = cookie;
 
-        return 0;
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        local->op_ret = op_ret;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
+        goto out;
+    }
+
+    if (local->fop == GF_FOP_SETXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->setxattr, &local->loc, local->xattr,
+                   local->flags, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_FSETXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->fsetxattr, local->fd, local->xattr,
+                   local->flags, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->removexattr, &local->loc,
+                   local->key, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->fremovexattr, local->fd, local->key,
+                   local->xattr_req);
+    }
+
+    return 0;
+out:
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+        /* 'local' itself may not be valid after this */
+        goto just_return;
+    }
+
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
+
+just_return:
+    return 0;
 }
 
 static void
-fill_layout_info (dht_layout_t *layout, char *buf)
+fill_layout_info(dht_layout_t *layout, char *buf)
 {
-        int i = 0;
-        char tmp_buf[128] = {0,};
+    int i = 0;
+    char tmp_buf[128] = {
+        0,
+    };
 
-        for (i = 0; i < layout->cnt; i++) {
-                snprintf (tmp_buf, 128, "(%s %u %u)",
-                          layout->list[i].xlator->name,
-                          layout->list[i].start,
-                          layout->list[i].stop);
-                if (i)
-                        strcat (buf, " ");
-                strcat (buf, tmp_buf);
-        }
+    for (i = 0; i < layout->cnt; i++) {
+        snprintf(tmp_buf, sizeof(tmp_buf), "(%s %u %u)",
+                 layout->list[i].xlator->name, layout->list[i].start,
+                 layout->list[i].stop);
+        if (i)
+            strcat(buf, " ");
+        strcat(buf, tmp_buf);
+    }
 }
 
-void
-dht_fill_pathinfo_xattr (xlator_t *this, dht_local_t *local,
-                         char *xattr_buf, int32_t alloc_len,
-                         int flag, char *layout_buf)
-{
-        if (flag && local->xattr_val)
-                snprintf (xattr_buf, alloc_len,
-                          "((<"DHT_PATHINFO_HEADER"%s> %s) (%s-layout %s))",
-                          this->name, local->xattr_val, this->name,
-                          layout_buf);
-        else if (local->xattr_val)
-                snprintf (xattr_buf, alloc_len,
-                          "(<"DHT_PATHINFO_HEADER"%s> %s)",
-                          this->name, local->xattr_val);
-        else if (flag)
-                snprintf (xattr_buf, alloc_len, "(%s-layout %s)",
-                          this->name, layout_buf);
+static void
+dht_fill_pathinfo_xattr(xlator_t *this, dht_local_t *local, char *xattr_buf,
+                        int32_t alloc_len, int flag, char *layout_buf)
+{
+    if (flag) {
+        if (local->xattr_val) {
+            snprintf(xattr_buf, alloc_len,
+                     "((<" DHT_PATHINFO_HEADER "%s> %s) (%s-layout %s))",
+                     this->name, local->xattr_val, this->name, layout_buf);
+        } else {
+            snprintf(xattr_buf, alloc_len, "(%s-layout %s)", this->name,
+                     layout_buf);
+        }
+    } else if (local->xattr_val) {
+        snprintf(xattr_buf, alloc_len, "(<" DHT_PATHINFO_HEADER "%s> %s)",
+                 this->name, local->xattr_val);
+    } else {
+        xattr_buf[0] = '\0';
+    }
 }
 
-int
-dht_vgetxattr_alloc_and_fill (dht_local_t *local, dict_t *xattr, xlator_t *this,
-                              int op_errno)
+static int
+dht_vgetxattr_alloc_and_fill(dht_local_t *local, dict_t *xattr, xlator_t *this,
+                             int op_errno)
 {
-        int      ret       = -1;
-        char    *value     = NULL;
-        int32_t  plen      = 0;
+    int ret = -1;
+    char *value = NULL;
 
-        ret = dict_get_str (xattr, local->xsel, &value);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "Subvolume %s returned -1", this->name);
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto out;
-        }
+    ret = dict_get_str(xattr, local->xsel, &value);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_GET_XATTR_FAILED,
+               "Subvolume %s returned -1", this->name);
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto out;
+    }
 
-        local->alloc_len += strlen(value);
+    local->alloc_len += strlen(value);
 
+    if (!local->xattr_val) {
+        local->alloc_len += (SLEN(DHT_PATHINFO_HEADER) + 10);
+        local->xattr_val = GF_MALLOC(local->alloc_len, gf_common_mt_char);
         if (!local->xattr_val) {
-                local->alloc_len += (strlen (DHT_PATHINFO_HEADER) + 10);
-                local->xattr_val = GF_CALLOC (local->alloc_len, sizeof (char),
-                                              gf_common_mt_char);
-                if (!local->xattr_val) {
-                        ret = -1;
-                        goto out;
-                }
+            ret = -1;
+            goto out;
         }
+        local->xattr_val[0] = '\0';
+    }
 
-        if (local->xattr_val) {
-                plen = strlen (local->xattr_val);
-                if (plen) {
-                        /* extra byte(s) for \0 to be safe */
-                        local->alloc_len += (plen + 2);
-                        local->xattr_val = GF_REALLOC (local->xattr_val,
-                                                       local->alloc_len);
-                        if (!local->xattr_val) {
-                                ret = -1;
-                                goto out;
-                        }
-                }
-
-                (void) strcat (local->xattr_val, value);
-                (void) strcat (local->xattr_val, " ");
-                local->op_ret = 0;
+    int plen = strlen(local->xattr_val);
+    if (plen) {
+        /* extra byte(s) for \0 to be safe */
+        local->alloc_len += (plen + 2);
+        local->xattr_val = GF_REALLOC(local->xattr_val, local->alloc_len);
+        if (!local->xattr_val) {
+            ret = -1;
+            goto out;
         }
+    }
 
-        ret = 0;
+    (void)strcat(local->xattr_val, value);
+    (void)strcat(local->xattr_val, " ");
+    local->op_ret = 0;
 
- out:
-        return ret;
+    ret = 0;
+
+out:
+    return ret;
 }
 
-int
-dht_vgetxattr_fill_and_set (dht_local_t *local, dict_t **dict, xlator_t *this,
-                            gf_boolean_t flag)
+static int
+dht_vgetxattr_fill_and_set(dht_local_t *local, dict_t **dict, xlator_t *this,
+                           gf_boolean_t flag)
 {
-        int   ret             = -1;
-        char *xattr_buf       = NULL;
-        char layout_buf[8192] = {0,};
-
-        if (flag)
-                fill_layout_info (local->layout, layout_buf);
+    int ret = -1;
+    char *xattr_buf = NULL;
+    char layout_buf[8192] = {
+        0,
+    };
 
-        *dict = dict_new ();
-        if (!*dict)
-                goto out;
+    if (flag)
+        fill_layout_info(local->layout, layout_buf);
 
-        local->xattr_val[strlen (local->xattr_val) - 1] = '\0';
+    *dict = dict_new();
+    if (!*dict)
+        goto out;
 
-        /* we would need max this many bytes to create xattr string
-         * extra 40 bytes is just an estimated amount of additional
-         * space required as we include translator name and some
-         * spaces, brackets etc. when forming the pathinfo string.
-         *
-         * For node-uuid we just don't have all the pretty formatting,
-         * but since this is a generic routine for pathinfo & node-uuid
-         * we dont have conditional space allocation and try to be
-         * generic
-         */
-        local->alloc_len += (2 * strlen (this->name))
-                + strlen (layout_buf)
-                + 40;
-        xattr_buf = GF_CALLOC (local->alloc_len, sizeof (char),
-                               gf_common_mt_char);
-        if (!xattr_buf)
-                goto out;
+    local->xattr_val[strlen(local->xattr_val) - 1] = '\0';
+
+    /* we would need max this many bytes to create xattr string
+     * extra 40 bytes is just an estimated amount of additional
+     * space required as we include translator name and some
+     * spaces, brackets etc. when forming the pathinfo string.
+     *
+     * For node-uuid we just don't have all the pretty formatting,
+     * but since this is a generic routine for pathinfo & node-uuid
+     * we don't have conditional space allocation and try to be
+     * generic
+     */
+    local->alloc_len += (2 * strlen(this->name)) + strlen(layout_buf) + 40;
+    xattr_buf = GF_MALLOC(local->alloc_len, gf_common_mt_char);
+    if (!xattr_buf)
+        goto out;
 
-        if (XATTR_IS_PATHINFO (local->xsel)) {
-                (void) dht_fill_pathinfo_xattr (this, local, xattr_buf,
-                                                local->alloc_len, flag,
-                                                layout_buf);
-        } else if ((XATTR_IS_NODE_UUID (local->xsel))
-                   || (XATTR_IS_NODE_UUID_LIST (local->xsel))) {
-                (void) snprintf (xattr_buf, local->alloc_len, "%s",
-                                 local->xattr_val);
-        } else {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "Unknown local->xsel (%s)", local->xsel);
-                GF_FREE (xattr_buf);
-                goto out;
-        }
+    if (XATTR_IS_PATHINFO(local->xsel)) {
+        (void)dht_fill_pathinfo_xattr(this, local, xattr_buf, local->alloc_len,
+                                      flag, layout_buf);
+    } else if ((XATTR_IS_NODE_UUID(local->xsel)) ||
+               (XATTR_IS_NODE_UUID_LIST(local->xsel))) {
+        (void)snprintf(xattr_buf, local->alloc_len, "%s", local->xattr_val);
+    } else {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GET_XATTR_FAILED,
+               "Unknown local->xsel (%s)", local->xsel);
+        GF_FREE(xattr_buf);
+        goto out;
+    }
 
-        ret = dict_set_dynstr (*dict, local->xsel, xattr_buf);
-        if (ret)
-                GF_FREE (xattr_buf);
-        GF_FREE (local->xattr_val);
+    ret = dict_set_dynstr(*dict, local->xsel, xattr_buf);
+    if (ret)
+        GF_FREE(xattr_buf);
+    GF_FREE(local->xattr_val);
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
+static int
+dht_find_local_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
+    int ret = 0;
+    char *uuid_str = NULL;
+    char *uuid_list = NULL;
+    char *next_uuid_str = NULL;
+    char *saveptr = NULL;
+    uuid_t node_uuid = {
+        0,
+    };
+    char *uuid_list_copy = NULL;
+    int count = 0;
+    int i = 0;
+    int index = 0;
+    int found = 0;
+    nodeuuid_info_t *tmp_ptr = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    VALIDATE_OR_GOTO(conf->defrag, out);
+
+    gf_msg_debug(this->name, 0, "subvol %s returned", prev->name);
+
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            if (op_errno == ENODATA)
+                gf_msg_debug(this->name, 0, "failed to get node-uuid");
+            else
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_GET_XATTR_FAILED, "failed to get node-uuid");
+            goto post_unlock;
+        }
 
-int
-dht_find_local_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
-{
-        dht_local_t  *local         = NULL;
-        dht_conf_t   *conf          = NULL;
-        xlator_t     *prev          = NULL;
-        int           this_call_cnt = 0;
-        int           ret           = 0;
-        char         *uuid_str      = NULL;
-        char         *uuid_list     = NULL;
-        char         *next_uuid_str = NULL;
-        char         *saveptr       = NULL;
-        uuid_t        node_uuid     = {0,};
-        char         *uuid_list_copy = NULL;
-        int           count          = 0;
-        int           i              = 0;
-        int           index          = 0;
-        int           found          = 0;
-        nodeuuid_info_t *tmp_ptr     = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        VALIDATE_OR_GOTO (conf->defrag, out);
-
-        gf_msg_debug (this->name, 0, "subvol %s returned", prev->name);
-
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-                if (op_ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_GET_XATTR_FAILED,
-                                "getxattr err for dir");
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
+        ret = dict_get_str(xattr, local->xsel, &uuid_list);
 
-                ret = dict_get_str (xattr, local->xsel, &uuid_list);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_GET_FAILED,
+                   "Failed to get %s", local->xsel);
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
+            goto unlock;
+        }
 
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_GET_FAILED,
-                                "Failed to get %s", local->xsel);
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
-                        goto unlock;
-                }
+        /* As DHT will not know details of its child xlators
+         * we need to parse this twice to get the count first
+         * and allocate memory later.
+         */
+        count = 0;
+        index = conf->local_subvols_cnt;
 
-                /* As DHT will not know details of its child xlators
-                 * we need to parse this twice to get the count first
-                 * and allocate memory later.
-                 */
-                count = 0;
-                index = conf->local_subvols_cnt;
-
-                uuid_list_copy = gf_strdup (uuid_list);
-
-                for (uuid_str = strtok_r (uuid_list, " ", &saveptr);
-                     uuid_str;
-                     uuid_str = next_uuid_str) {
-
-                        next_uuid_str = strtok_r (NULL, " ", &saveptr);
-                        if (gf_uuid_parse (uuid_str, node_uuid)) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_UUID_PARSE_ERROR,
-                                        "Failed to parse uuid"
-                                        " for %s", prev->name);
-                                local->op_ret = -1;
-                                local->op_errno = EINVAL;
-                                goto unlock;
-                        }
+        uuid_list_copy = gf_strdup(uuid_list);
+        if (!uuid_list_copy)
+            goto unlock;
 
-                        count++;
-                        if (gf_uuid_compare (node_uuid, conf->defrag->node_uuid)) {
-                                gf_msg_debug (this->name, 0, "subvol %s does not"
-                                              "belong to this node",
-                                              prev->name);
-                        } else {
-
-                                /* handle multiple bricks of the same replica
-                                 * on the same node */
-                                if (found)
-                                        continue;
-                                conf->local_subvols[(conf->local_subvols_cnt)++]
-                                                = prev;
-                                found = 1;
-                                gf_msg_debug (this->name, 0, "subvol %s belongs to"
-                                              " this node", prev->name);
-                        }
-                }
+        for (uuid_str = strtok_r(uuid_list, " ", &saveptr); uuid_str;
+             uuid_str = next_uuid_str) {
+            next_uuid_str = strtok_r(NULL, " ", &saveptr);
+            if (gf_uuid_parse(uuid_str, node_uuid)) {
+                local->op_ret = -1;
+                local->op_errno = EINVAL;
+                UNLOCK(&frame->lock);
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UUID_PARSE_ERROR,
+                       "Failed to parse uuid for %s", prev->name);
+                goto post_unlock;
+            }
 
-                if (!found) {
-                        local->op_ret = 0;
-                        goto unlock;
-                }
+            count++;
+            if (gf_uuid_compare(node_uuid, conf->defrag->node_uuid)) {
+                gf_msg_debug(this->name, 0,
+                             "subvol %s does not"
+                             "belong to this node",
+                             prev->name);
+            } else {
+                /* handle multiple bricks of the same replica
+                 * on the same node */
+                if (found)
+                    continue;
+                conf->local_subvols[(conf->local_subvols_cnt)++] = prev;
+                found = 1;
+                gf_msg_debug(this->name, 0,
+                             "subvol %s belongs to"
+                             " this node",
+                             prev->name);
+            }
+        }
 
-                conf->local_nodeuuids[index].count = count;
-                conf->local_nodeuuids[index].elements
-                               = GF_CALLOC (count, sizeof (nodeuuid_info_t), 1);
+        if (!found) {
+            local->op_ret = 0;
+            goto unlock;
+        }
 
-                /* The node-uuids are guaranteed to be returned in the same
-                 * order as the bricks
-                 * A null node-uuid is returned for a brick that is down.
-                 */
+        conf->local_nodeuuids[index].count = count;
+        conf->local_nodeuuids[index].elements = GF_CALLOC(
+            count, sizeof(nodeuuid_info_t), 1);
 
-                saveptr = NULL;
-                i = 0;
+        /* The node-uuids are guaranteed to be returned in the same
+         * order as the bricks
+         * A null node-uuid is returned for a brick that is down.
+         */
 
-                for (uuid_str = strtok_r (uuid_list_copy, " ", &saveptr);
-                     uuid_str;
-                     uuid_str = next_uuid_str) {
+        saveptr = NULL;
+        i = 0;
 
-                        next_uuid_str = strtok_r (NULL, " ", &saveptr);
-                        tmp_ptr = &(conf->local_nodeuuids[index].elements[i]);
-                        gf_uuid_parse (uuid_str, tmp_ptr->uuid);
+        for (uuid_str = strtok_r(uuid_list_copy, " ", &saveptr); uuid_str;
+             uuid_str = next_uuid_str) {
+            next_uuid_str = strtok_r(NULL, " ", &saveptr);
+            tmp_ptr = &(conf->local_nodeuuids[index].elements[i]);
+            gf_uuid_parse(uuid_str, tmp_ptr->uuid);
 
-                        if (!gf_uuid_compare (tmp_ptr->uuid,
-                                              conf->defrag->node_uuid)) {
-                                tmp_ptr->info = REBAL_NODEUUID_MINE;
-                        }
-                        i++;
-                        tmp_ptr = NULL;
-                }
+            if (!gf_uuid_compare(tmp_ptr->uuid, conf->defrag->node_uuid)) {
+                tmp_ptr->info = REBAL_NODEUUID_MINE;
+            }
+            i++;
+            tmp_ptr = NULL;
         }
+    }
 
-        local->op_ret = 0;
- unlock:
-        UNLOCK (&frame->lock);
-
-        if (!is_last_call (this_call_cnt))
-                goto out;
+    local->op_ret = 0;
+unlock:
+    UNLOCK(&frame->lock);
+post_unlock:
+    if (!is_last_call(this_call_cnt))
+        goto out;
 
-        if (local->op_ret == -1) {
-                goto unwind;
-        }
+    if (local->op_ret == -1) {
+        goto unwind;
+    }
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, xattr, xdata);
-        goto out;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, xattr, xdata);
+    goto out;
 
- unwind:
+unwind:
 
-        GF_FREE (conf->local_nodeuuids[index].elements);
-        conf->local_nodeuuids[index].elements = NULL;
+    GF_FREE(conf->local_nodeuuids[index].elements);
+    conf->local_nodeuuids[index].elements = NULL;
 
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno, NULL, xdata);
- out:
-        GF_FREE (uuid_list_copy);
-        return 0;
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, xdata);
+out:
+    GF_FREE(uuid_list_copy);
+    return 0;
 }
 
-int
-dht_vgetxattr_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+static int
+dht_vgetxattr_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        int          ret           = 0;
-        dht_local_t *local         = NULL;
-        int          this_call_cnt = 0;
-        dict_t      *dict          = NULL;
+    int ret = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    dict_t *dict = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
 
-        local = frame->local;
-
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-                if (op_ret < 0) {
-                        if (op_errno != ENOTCONN) {
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_GET_XATTR_FAILED,
-                                        "getxattr err for dir");
-                                local->op_ret = -1;
-                                local->op_errno = op_errno;
-                        }
+    local = frame->local;
 
-                        goto unlock;
-                }
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+        if (op_ret < 0) {
+            if (op_errno != ENOTCONN) {
+                local->op_ret = -1;
+                local->op_errno = op_errno;
+                UNLOCK(&frame->lock);
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_GET_XATTR_FAILED, "getxattr err for dir");
+                goto post_unlock;
+            }
 
-                ret = dht_vgetxattr_alloc_and_fill (local, xattr, this,
-                                                    op_errno);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "alloc or fill failure");
+            goto unlock;
         }
- unlock:
-        UNLOCK (&frame->lock);
 
-        if (!is_last_call (this_call_cnt))
-                goto out;
+        ret = dht_vgetxattr_alloc_and_fill(local, xattr, this, op_errno);
+        if (ret) {
+            UNLOCK(&frame->lock);
+            gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_DICT_SET_FAILED,
+                   "alloc or fill failure");
+            goto post_unlock;
+        }
+    }
+unlock:
+    UNLOCK(&frame->lock);
+post_unlock:
+    if (!is_last_call(this_call_cnt))
+        goto out;
 
-        /* -- last call: do patch ups -- */
+    /* -- last call: do patch ups -- */
 
-        if (local->op_ret == -1) {
-                goto unwind;
-        }
+    if (local->op_ret == -1) {
+        goto unwind;
+    }
 
-        ret = dht_vgetxattr_fill_and_set (local, &dict, this, _gf_true);
-        if (ret)
-                goto unwind;
+    ret = dht_vgetxattr_fill_and_set(local, &dict, this, _gf_true);
+    if (ret)
+        goto unwind;
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, dict, xdata);
-        goto cleanup;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, dict, xdata);
+    goto cleanup;
 
- unwind:
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno, NULL, NULL);
- cleanup:
-        if (dict)
-                dict_unref (dict);
- out:
-        return 0;
+unwind:
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, NULL);
+cleanup:
+    if (dict)
+        dict_unref(dict);
+out:
+    return 0;
 }
 
-int
-dht_vgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+static int
+dht_vgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        dht_local_t  *local         = NULL;
-        int           ret           = 0;
-        dict_t       *dict          = NULL;
-        xlator_t     *prev          = NULL;
-        gf_boolean_t  flag          = _gf_true;
+    dht_local_t *local = NULL;
+    int ret = 0;
+    dict_t *dict = NULL;
+    xlator_t *prev = NULL;
+    gf_boolean_t flag = _gf_true;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "vgetxattr: Subvolume %s returned -1",
-                         prev->name);
-                goto unwind;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_GET_XATTR_FAILED,
+               "vgetxattr: Subvolume %s returned -1", prev->name);
+        goto unwind;
+    }
 
-        ret = dht_vgetxattr_alloc_and_fill (local, xattr, this,
-                                            op_errno);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Allocation or fill failure");
-                goto unwind;
-        }
+    ret = dht_vgetxattr_alloc_and_fill(local, xattr, this, op_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+               "Allocation or fill failure");
+        goto unwind;
+    }
 
-        flag = (local->layout->cnt > 1) ? _gf_true : _gf_false;
+    flag = (local->layout->cnt > 1) ? _gf_true : _gf_false;
 
-        ret = dht_vgetxattr_fill_and_set (local, &dict, this, flag);
-        if (ret)
-                goto unwind;
+    ret = dht_vgetxattr_fill_and_set(local, &dict, this, flag);
+    if (ret)
+        goto unwind;
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, dict, xdata);
-        goto cleanup;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, dict, xdata);
+    goto cleanup;
 
- unwind:
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno,
-                          NULL, NULL);
- cleanup:
-        if (dict)
-                dict_unref (dict);
+unwind:
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, NULL);
+cleanup:
+    if (dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_linkinfo_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
+static int
+dht_linkinfo_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
 {
-        int   ret   = 0;
-        char *value = NULL;
+    int ret = 0;
+    char *value = NULL;
 
-        if (op_ret != -1) {
-                ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &value);
-                if (!ret) {
-                        ret = dict_set_str (xattr, GF_XATTR_LINKINFO_KEY, value);
-                        if (!ret)
-                                gf_msg_trace (this->name, 0,
-                                              "failed to set linkinfo");
-                }
+    if (op_ret != -1) {
+        ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &value);
+        if (!ret) {
+            ret = dict_set_str(xattr, GF_XATTR_LINKINFO_KEY, value);
+            if (!ret)
+                gf_msg_trace(this->name, 0, "failed to set linkinfo");
         }
+    }
 
-        DHT_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata);
+    DHT_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+static int
+dht_mds_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        dht_conf_t      *conf = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
-        VALIDATE_OR_GOTO (this->private, out);
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
-        local = frame->local;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(frame->local, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        LOCK (&frame->lock);
-        {
-                if (!xattr || (op_ret == -1)) {
-                        local->op_ret = op_ret;
-                        goto unlock;
-                }
+    conf = this->private;
+    local = frame->local;
 
-                if (dict_get (xattr, conf->xattr_name)) {
-                        dict_del (xattr, conf->xattr_name);
-                }
+    if (!xattr || (op_ret == -1)) {
+        local->op_ret = op_ret;
+        goto out;
+    }
+    dict_del(xattr, conf->xattr_name);
+    local->op_ret = 0;
 
-                if (frame->root->pid >= 0) {
-                        GF_REMOVE_INTERNAL_XATTR
-                                ("trusted.glusterfs.quota*", xattr);
-                        GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
-                }
+    if (!local->xattr) {
+        local->xattr = dict_copy_with_ref(xattr, NULL);
+    }
 
-                local->op_ret = 0;
+out:
+    DHT_STACK_UNWIND(getxattr, frame, local->op_ret, op_errno, local->xattr,
+                     xdata);
+    return 0;
+err:
+    DHT_STACK_UNWIND(getxattr, frame, -1, EINVAL, NULL, NULL);
+    return 0;
+}
 
-                if (!local->xattr) {
-                        local->xattr = dict_copy_with_ref (xattr, NULL);
-                } else {
-                        dht_aggregate_xattr (local->xattr, xattr);
-                }
+int
+dht_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xattr, dict_t *xdata)
+{
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
 
-        }
-unlock:
-        UNLOCK (&frame->lock);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(frame->local, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        this_call_cnt = dht_frame_return (frame);
-out:
-        if (is_last_call (this_call_cnt)) {
+    conf = this->private;
+    local = frame->local;
 
-                /* If we have a valid xattr received from any one of the
-                 * subvolume, let's return it */
-                if (local->xattr) {
-                        local->op_ret = 0;
-                }
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto err;
+        return 0;
+    }
 
-                DHT_STACK_UNWIND (getxattr, frame, local->op_ret, op_errno,
-                                  local->xattr, NULL);
+    LOCK(&frame->lock);
+    {
+        if (!xattr || (op_ret == -1)) {
+            local->op_ret = op_ret;
+            goto unlock;
         }
-        return 0;
-}
 
-int32_t
-dht_getxattr_unwind (call_frame_t *frame,
-                     int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
-{
-        DHT_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
-        return 0;
-}
+        dict_del(xattr, conf->xattr_name);
+        dict_del(xattr, conf->mds_xattr_key);
 
+        dict_del(xattr, conf->commithash_xattr_name);
 
-int
-dht_getxattr_get_real_filename_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    dict_t *xattr, dict_t *xdata)
-{
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
+        if (frame->root->pid >= 0) {
+            GF_REMOVE_INTERNAL_XATTR("trusted.glusterfs.quota*", xattr);
+            GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
+        }
 
+        local->op_ret = 0;
 
-        local = frame->local;
+        if (!local->xattr) {
+            local->xattr = dict_copy_with_ref(xattr, NULL);
+        } else {
+            dht_aggregate_xattr(local->xattr, xattr);
+        }
 
-        LOCK (&frame->lock);
-        {
-                if (local->op_errno == ENODATA ||
-                    local->op_errno == EOPNOTSUPP) {
-                        /* Nothing to do here, we have already found
-                         * a subvol which does not have the get_real_filename
-                         * optimization. If condition is for simple logic.
-                         */
-                        goto unlock;
-                }
+        if (!local->xdata) {
+            local->xdata = dict_ref(xdata);
+        } else if ((local->inode && IA_ISDIR(local->inode->ia_type)) ||
+                   (local->fd && IA_ISDIR(local->fd->inode->ia_type))) {
+            dht_aggregate_xattr(local->xdata, xdata);
+        }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-                if (op_ret == -1) {
-
-                        if (op_errno == ENODATA || op_errno == EOPNOTSUPP) {
-                                /* This subvol does not have the optimization.
-                                 * Better let the user know we don't support it.
-                                 * Remove previous results if any.
-                                 */
-
-                                if (local->xattr) {
-                                        dict_unref (local->xattr);
-                                        local->xattr = NULL;
-                                }
-
-                                if (local->xattr_req) {
-                                        dict_unref (local->xattr_req);
-                                        local->xattr_req = NULL;
-                                }
-
-                                local->op_ret = op_ret;
-                                local->op_errno = op_errno;
-                                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                        DHT_MSG_UPGRADE_BRICKS, "At least "
-                                        "one of the bricks does not support "
-                                        "this operation. Please upgrade all "
-                                        "bricks.");
-                                goto unlock;
-                        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        /* If we have a valid xattr received from any one of the
+         * subvolume, let's return it */
+        if (local->xattr) {
+            local->op_ret = 0;
+        }
 
-                        if (op_errno == ENOENT) {
-                                /* Do nothing, our defaults are set to this.
-                                 */
-                                goto unlock;
-                        }
+        DHT_STACK_UNWIND(getxattr, frame, local->op_ret, op_errno, local->xattr,
+                         local->xdata);
+    }
+    return 0;
+err:
+    DHT_STACK_UNWIND(getxattr, frame, -1, EINVAL, NULL, NULL);
+    return 0;
+}
 
-                        /* This is a place holder for every other error
-                         * case. I am not sure of how to interpret
-                         * ENOTCONN etc. As of now, choosing to ignore
-                         * down subvol and return a good result(if any)
-                         * from other subvol.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                DHT_MSG_GET_XATTR_FAILED,
-                                "Failed to get real filename.");
-                        goto unlock;
+static int32_t
+dht_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno, dict_t *dict,
+                    dict_t *xdata)
+{
+    DHT_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    return 0;
+}
 
-                }
+static int
+dht_getxattr_get_real_filename_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int op_ret, int op_errno,
+                                   dict_t *xattr, dict_t *xdata)
+{
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
 
+    local = frame->local;
 
-                /* This subvol has the required file.
-                 * There could be other subvols which have returned
-                 * success already, choosing to return the latest good
-                 * result.
+    LOCK(&frame->lock);
+    {
+        if (local->op_errno == EOPNOTSUPP) {
+            /* Nothing to do here, we have already found
+             * a subvol which does not have the get_real_filename
+             * optimization. If condition is for simple logic.
+             */
+            goto unlock;
+        }
+
+        if (op_ret == -1) {
+            if (op_errno == EOPNOTSUPP) {
+                /* This subvol does not have the optimization.
+                 * Better let the user know we don't support it.
+                 * Remove previous results if any.
                  */
-                if (local->xattr)
-                        dict_unref (local->xattr);
-                local->xattr = dict_ref (xattr);
+
+                if (local->xattr) {
+                    dict_unref(local->xattr);
+                    local->xattr = NULL;
+                }
 
                 if (local->xattr_req) {
-                        dict_unref (local->xattr_req);
-                        local->xattr_req = NULL;
+                    dict_unref(local->xattr_req);
+                    local->xattr_req = NULL;
                 }
-                if (xdata)
-                        local->xattr_req = dict_ref (xdata);
 
                 local->op_ret = op_ret;
-                local->op_errno = 0;
-                gf_msg_debug (this->name, 0, "Found a matching "
-                              "file.");
-        }
-unlock:
-        UNLOCK (&frame->lock);
+                local->op_errno = op_errno;
+                UNLOCK(&frame->lock);
+                gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                       DHT_MSG_UPGRADE_BRICKS,
+                       "At least "
+                       "one of the bricks does not support "
+                       "this operation. Please upgrade all "
+                       "bricks.");
+                goto post_unlock;
+            }
+
+            if (op_errno == ENOATTR) {
+                /* Do nothing, our defaults are set to this.
+                 */
+                goto unlock;
+            }
 
+            /* This is a place holder for every other error
+             * case. I am not sure of how to interpret
+             * ENOTCONN etc. As of now, choosing to ignore
+             * down subvol and return a good result(if any)
+             * from other subvol.
+             */
+            UNLOCK(&frame->lock);
+            gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                   DHT_MSG_GET_XATTR_FAILED, "Failed to get real filename.");
+            goto post_unlock;
+        }
+
+        /* This subvol has the required file.
+         * There could be other subvols which have returned
+         * success already, choosing to return the latest good
+         * result.
+         */
+        if (local->xattr)
+            dict_unref(local->xattr);
+        local->xattr = dict_ref(xattr);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->xattr,
-                                  local->xattr_req);
+        if (local->xattr_req) {
+            dict_unref(local->xattr_req);
+            local->xattr_req = NULL;
         }
+        if (xdata)
+            local->xattr_req = dict_ref(xdata);
 
-        return 0;
-}
+        local->op_ret = op_ret;
+        local->op_errno = 0;
+        UNLOCK(&frame->lock);
+        gf_msg_debug(this->name, 0, "Found a matching file.");
+        goto post_unlock;
+    }
+unlock:
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->xattr, local->xattr_req);
+    }
 
+    return 0;
+}
 
-int
-dht_getxattr_get_real_filename (call_frame_t *frame, xlator_t *this,
-                                loc_t *loc, const char *key, dict_t *xdata)
+static int
+dht_getxattr_get_real_filename(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               const char *key, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
-        int              i = 0;
-        dht_layout_t    *layout = NULL;
-        int              cnt = 0;
-        xlator_t        *subvol = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_layout_t *layout = NULL;
+    int cnt = 0;
+    xlator_t *subvol = NULL;
 
+    local = frame->local;
+    layout = local->layout;
 
-        local = frame->local;
-        layout = local->layout;
+    cnt = local->call_cnt = layout->cnt;
 
-        cnt = local->call_cnt = layout->cnt;
+    local->op_ret = -1;
+    local->op_errno = ENOATTR;
 
-        local->op_ret = -1;
-        local->op_errno = ENOENT;
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_get_real_filename_cbk, subvol,
+                   subvol->fops->getxattr, loc, key, xdata);
+    }
 
-        for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_get_real_filename_cbk,
-                            subvol, subvol->fops->getxattr,
-                            loc, key, xdata);
-        }
-
-        return 0;
+    return 0;
 }
 
-int
-dht_marker_populate_args (call_frame_t *frame, int type, int *gauge,
-                          xlator_t **subvols)
+static int
+dht_marker_populate_args(call_frame_t *frame, int type, int *gauge,
+                         xlator_t **subvols)
 {
-        dht_local_t *local = NULL;
-        int         i = 0;
-        dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_layout_t *layout = NULL;
 
-        local  = frame->local;
-        layout = local->layout;
+    local = frame->local;
+    layout = local->layout;
 
-        for (i = 0; i < layout->cnt; i++)
-                subvols[i] = layout->list[i].xlator;
+    for (i = 0; i < layout->cnt; i++)
+        subvols[i] = layout->list[i].xlator;
 
-        return layout->cnt;
+    return layout->cnt;
 }
 
-int
-dht_getxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, const char *key, dict_t *xdata)
-#define DHT_IS_DIR(layout)  (layout->cnt > 1)
-{
-
-        xlator_t     *subvol        = NULL;
-        xlator_t     *hashed_subvol = NULL;
-        xlator_t     *cached_subvol = NULL;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        dht_layout_t *layout        = NULL;
-        int           op_errno      = -1;
-        int           i             = 0;
-        int           cnt           = 0;
-        char         *node_uuid_key = NULL;
-        int           ret           = -1;
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf   = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_GETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
+static int
+dht_is_debug_xattr_key(const char **array, char *key)
+{
+    int i = 0;
 
-                goto err;
-        }
+    for (i = 0; array[i]; i++) {
+        if (fnmatch(array[i], key, FNM_NOESCAPE) == 0)
+            return i;
+    }
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LAYOUT_NULL,
-                        "Layout is NULL");
-                op_errno = ENOENT;
-                goto err;
-        }
+    return -1;
+}
 
-        if (key) {
-                local->key = gf_strdup (key);
-                if (!local->key) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-        }
+/* Note we already have frame->local initialised here*/
 
-        if (key &&
-            (strncmp (key, GF_XATTR_GET_REAL_FILENAME_KEY,
-                      strlen (GF_XATTR_GET_REAL_FILENAME_KEY)) == 0)
-            && DHT_IS_DIR(layout)) {
-                dht_getxattr_get_real_filename (frame, this, loc, key, xdata);
-                return 0;
-        }
+static int
+dht_handle_debug_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                          const char *key)
+{
+    dht_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENODATA;
+    char *value = NULL;
+    loc_t file_loc = {0};
+    const char *name = NULL;
 
-        if (key && DHT_IS_DIR(layout) &&
-           (!strcmp (key, GF_REBAL_FIND_LOCAL_SUBVOL))) {
-                ret = gf_asprintf
-                           (&node_uuid_key, "%s", GF_XATTR_LIST_NODE_UUIDS_KEY);
-                if (ret == -1 || !node_uuid_key) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_NO_MEMORY,
-                                "Failed to copy key");
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                (void) strncpy (local->xsel, node_uuid_key, 256);
-                cnt = local->call_cnt = conf->subvolume_cnt;
-                for (i = 0; i < cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_find_local_subvol_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, node_uuid_key, xdata);
-                }
-                if (node_uuid_key)
-                        GF_FREE (node_uuid_key);
-                return 0;
-        }
+    local = frame->local;
 
-        if (key && DHT_IS_DIR(layout) &&
-           (!strcmp (key, GF_REBAL_OLD_FIND_LOCAL_SUBVOL))) {
-                ret = gf_asprintf
-                           (&node_uuid_key, "%s", GF_XATTR_NODE_UUID_KEY);
-                if (ret == -1 || !node_uuid_key) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_NO_MEMORY,
-                                "Failed to copy key");
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                (void) strncpy (local->xsel, node_uuid_key, 256);
-                cnt = local->call_cnt = conf->subvolume_cnt;
-                for (i = 0; i < cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_find_local_subvol_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, node_uuid_key, xdata);
-                }
-                if (node_uuid_key)
-                        GF_FREE (node_uuid_key);
-                return 0;
-        }
+    if (dht_is_debug_xattr_key(dht_dbg_vxattrs, (char *)key) == -1) {
+        goto out;
+    }
 
-        /* for file use cached subvolume (obviously!): see if {}
-         * below
-         * for directory:
-         *  wind to all subvolumes and exclude subvolumes which
-         *  return ENOTCONN (in callback)
-         *
-         * NOTE: Don't trust inode here, as that may not be valid
-         *       (until inode_link() happens)
-         */
+    local->xattr = dict_new();
+    if (!local->xattr) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-        if (key && DHT_IS_DIR(layout) &&
-            (XATTR_IS_PATHINFO (key)
-             || (strcmp (key, GF_XATTR_NODE_UUID_KEY) == 0)
-             || (strcmp (key, GF_XATTR_LIST_NODE_UUIDS_KEY) == 0))) {
-                (void) strncpy (local->xsel, key, 256);
-                cnt = local->call_cnt = layout->cnt;
-                for (i = 0; i < cnt; i++) {
-                        subvol = layout->list[i].xlator;
-                        STACK_WIND (frame, dht_vgetxattr_dir_cbk,
-                                    subvol, subvol->fops->getxattr,
-                                    loc, key, xdata);
-                }
-                return 0;
+    if (strncmp(key, DHT_DBG_HASHED_SUBVOL_KEY,
+                SLEN(DHT_DBG_HASHED_SUBVOL_KEY)) == 0) {
+        name = key + strlen(DHT_DBG_HASHED_SUBVOL_KEY);
+        if (strlen(name) == 0) {
+            op_errno = EINVAL;
+            goto out;
         }
 
-        /* node-uuid or pathinfo for files */
-        if (key && ((strcmp (key, GF_XATTR_NODE_UUID_KEY) == 0)
-                    || XATTR_IS_PATHINFO (key))) {
-                cached_subvol = local->cached_subvol;
-                (void) strncpy (local->xsel, key, 256);
-
-                local->call_cnt = 1;
-                STACK_WIND_COOKIE (frame, dht_vgetxattr_cbk, cached_subvol,
-                                   cached_subvol, cached_subvol->fops->getxattr,
-                                   loc, key, xdata);
-
-                return 0;
+        ret = dht_build_child_loc(this, &file_loc, loc, (char *)name);
+        if (ret) {
+            op_errno = ENOMEM;
+            goto out;
         }
 
-        if (key && (strcmp (key, GF_XATTR_LINKINFO_KEY) == 0)) {
-
-                hashed_subvol = dht_subvol_get_hashed (this, loc);
-                if (!hashed_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get hashed subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                cached_subvol = dht_subvol_get_cached (this, loc->inode);
-                if (!cached_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_CACHED_SUBVOL_GET_FAILED,
-                                "Failed to get cached subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (hashed_subvol == cached_subvol) {
-                        op_errno = ENODATA;
-                        goto err;
-                }
-
-                STACK_WIND (frame, dht_linkinfo_getxattr_cbk, hashed_subvol,
-                            hashed_subvol->fops->getxattr, loc,
-                            GF_XATTR_PATHINFO_KEY, xdata);
-                return 0;
+        local->hashed_subvol = dht_subvol_get_hashed(this, &file_loc);
+        if (local->hashed_subvol == NULL) {
+            op_errno = ENODATA;
+            goto out;
         }
 
-        if (key && (!strcmp (QUOTA_LIMIT_KEY, key) ||
-                    !strcmp (QUOTA_LIMIT_OBJECTS_KEY, key))) {
-                /* quota hardlimit and aggregated size of a directory is stored
-                 * in inode contexts of each brick. Hence its good enough that
-                 * we send getxattr for this key to any brick.
-                 */
-                local->call_cnt = 1;
-                subvol = dht_first_up_subvol (this);
-                STACK_WIND (frame, dht_getxattr_cbk, subvol,
-                            subvol->fops->getxattr, loc, key, xdata);
-                return 0;
+        value = gf_strdup(local->hashed_subvol->name);
+        if (!value) {
+            op_errno = ENOMEM;
+            goto out;
         }
 
-        if (cluster_handle_marker_getxattr (frame, loc, key, conf->vol_uuid,
-                                            dht_getxattr_unwind,
-                                            dht_marker_populate_args) == 0)
-                return 0;
-
-        if (DHT_IS_DIR(layout)) {
-                cnt = local->call_cnt = layout->cnt;
-        } else {
-                cnt = local->call_cnt  = 1;
+        ret = dict_set_dynstr(local->xattr, (char *)key, value);
+        if (ret < 0) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
         }
+        ret = 0;
+        goto out;
+    }
 
-        for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_cbk,
-                            subvol, subvol->fops->getxattr,
-                            loc, key, xdata);
-        }
-        return 0;
+out:
+    loc_wipe(&file_loc);
+    DHT_STACK_UNWIND(getxattr, frame, ret, op_errno, local->xattr, NULL);
+    return 0;
+}
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (getxattr, frame, -1, op_errno, NULL, NULL);
+/* Virtual Xattr which returns 1 if all subvols are up,
+   else returns 0. Geo-rep then uses this virtual xattr
+   after a fresh mount and starts the I/O.
+*/
 
-        return 0;
-}
-#undef DHT_IS_DIR
+enum dht_vxattr_subvol {
+    DHT_VXATTR_SUBVOLS_UP = 1,
+    DHT_VXATTR_SUBVOLS_DOWN = 0,
+};
 
 int
-dht_fgetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, const char *key, dict_t *xdata)
-{
-        xlator_t     *subvol        = NULL;
-        dht_local_t  *local         = NULL;
-        dht_layout_t *layout        = NULL;
-        int           op_errno      = -1;
-        int           i             = 0;
-        int           cnt           = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FGETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
+dht_vgetxattr_subvol_status(call_frame_t *frame, xlator_t *this,
+                            const char *key)
+{
+    dht_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENODATA;
+    int value = DHT_VXATTR_SUBVOLS_UP;
+    int i = 0;
+    dht_conf_t *conf = NULL;
 
-                goto err;
-        }
+    conf = this->private;
+    local = frame->local;
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LAYOUT_NULL,
-                        "Layout is NULL");
-                op_errno = ENOENT;
-                goto err;
-        }
+    if (!key) {
+        op_errno = EINVAL;
+        goto out;
+    }
+    local->xattr = dict_new();
+    if (!local->xattr) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            value = DHT_VXATTR_SUBVOLS_DOWN;
+            gf_msg_debug(this->name, 0, "subvol %s is down ",
+                         conf->subvolumes[i]->name);
+            break;
+        }
+    }
+    ret = dict_set_int8(local->xattr, (char *)key, value);
+    if (ret < 0) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 
-        if (key) {
-                local->key = gf_strdup (key);
-                if (!local->key) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-        }
+out:
+    DHT_STACK_UNWIND(getxattr, frame, ret, op_errno, local->xattr, NULL);
+    return 0;
+}
 
-        if ((fd->inode->ia_type == IA_IFDIR)
-            && key
-            && (strncmp (key, GF_XATTR_LOCKINFO_KEY,
-                         strlen (GF_XATTR_LOCKINFO_KEY)) != 0)) {
-                cnt = local->call_cnt = layout->cnt;
-        } else {
-                cnt = local->call_cnt  = 1;
+int
+dht_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *key,
+             dict_t *xdata)
+#define DHT_IS_DIR(layout) (layout->cnt > 1)
+{
+    xlator_t *subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int cnt = 0;
+    char *node_uuid_key = NULL;
+    int ret = -1;
+
+    GF_CHECK_XATTR_KEY_AND_GOTO(key, IO_THREADS_QUEUE_SIZE_KEY, op_errno, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_GETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_NULL,
+               "Layout is NULL");
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    /* skip over code which is irrelevant without a valid key */
+    if (!key)
+        goto no_key;
+
+    local->key = gf_strdup(key);
+    if (!local->key) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (strncmp(key, conf->mds_xattr_key, strlen(key)) == 0) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    if (strncmp(key, DHT_SUBVOL_STATUS_KEY, SLEN(DHT_SUBVOL_STATUS_KEY)) == 0) {
+        dht_vgetxattr_subvol_status(frame, this, key);
+        return 0;
+    }
+
+    /* skip over code which is irrelevant if !DHT_IS_DIR(layout) */
+    if (!DHT_IS_DIR(layout))
+        goto no_dht_is_dir;
+
+    if ((strncmp(key, GF_XATTR_GET_REAL_FILENAME_KEY,
+                 SLEN(GF_XATTR_GET_REAL_FILENAME_KEY)) == 0) &&
+        DHT_IS_DIR(layout)) {
+        dht_getxattr_get_real_filename(frame, this, loc, key, xdata);
+        return 0;
+    }
+
+    if (!strcmp(key, GF_REBAL_FIND_LOCAL_SUBVOL)) {
+        ret = gf_asprintf(&node_uuid_key, "%s", GF_XATTR_LIST_NODE_UUIDS_KEY);
+        if (ret == -1 || !node_uuid_key) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+                   "Failed to copy node uuid key");
+            op_errno = ENOMEM;
+            goto err;
+        }
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", node_uuid_key);
+        cnt = local->call_cnt = conf->subvolume_cnt;
+        for (i = 0; i < cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_find_local_subvol_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              node_uuid_key, xdata);
         }
+        if (node_uuid_key)
+            GF_FREE(node_uuid_key);
+        return 0;
+    }
 
+    if (!strcmp(key, GF_REBAL_OLD_FIND_LOCAL_SUBVOL)) {
+        ret = gf_asprintf(&node_uuid_key, "%s", GF_XATTR_NODE_UUID_KEY);
+        if (ret == -1 || !node_uuid_key) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+                   "Failed to copy node uuid key");
+            op_errno = ENOMEM;
+            goto err;
+        }
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", node_uuid_key);
+        cnt = local->call_cnt = conf->subvolume_cnt;
         for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_cbk,
-                            subvol, subvol->fops->fgetxattr,
-                            fd, key, NULL);
+            STACK_WIND_COOKIE(frame, dht_find_local_subvol_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              node_uuid_key, xdata);
+        }
+        if (node_uuid_key)
+            GF_FREE(node_uuid_key);
+        return 0;
+    }
+
+    /* for file use cached subvolume (obviously!): see if {}
+     * below
+     * for directory:
+     *  wind to all subvolumes and exclude subvolumes which
+     *  return ENOTCONN (in callback)
+     *
+     * NOTE: Don't trust inode here, as that may not be valid
+     *       (until inode_link() happens)
+     */
+
+    if (XATTR_IS_PATHINFO(key) || (strcmp(key, GF_XATTR_NODE_UUID_KEY) == 0) ||
+        (strcmp(key, GF_XATTR_LIST_NODE_UUIDS_KEY) == 0)) {
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", key);
+        cnt = local->call_cnt = layout->cnt;
+        for (i = 0; i < cnt; i++) {
+            subvol = layout->list[i].xlator;
+            STACK_WIND(frame, dht_vgetxattr_dir_cbk, subvol,
+                       subvol->fops->getxattr, loc, key, xdata);
         }
         return 0;
+    }
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fgetxattr, frame, -1, op_errno, NULL, NULL);
+no_dht_is_dir:
+    /* node-uuid or pathinfo for files */
+    if (XATTR_IS_PATHINFO(key) || (strcmp(key, GF_XATTR_NODE_UUID_KEY) == 0)) {
+        cached_subvol = local->cached_subvol;
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", key);
+        local->call_cnt = 1;
+        STACK_WIND_COOKIE(frame, dht_vgetxattr_cbk, cached_subvol,
+                          cached_subvol, cached_subvol->fops->getxattr, loc,
+                          key, xdata);
 
         return 0;
-}
+    }
 
-int
-dht_file_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xdata)
-{
-        int           ret     = -1;
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        struct iatt  *stbuf   = NULL;
-        inode_t      *inode   = NULL;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        local->op_errno = op_errno;
-
-        if ((local->fop == GF_FOP_FSETXATTR) &&
-            op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
+    if (strcmp(key, GF_XATTR_LINKINFO_KEY) == 0) {
+        hashed_subvol = dht_subvol_get_hashed(this, loc);
+        if (!hashed_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if ((op_ret == -1) && !dht_inode_missing (op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1.",
-                              prev->name);
-                goto out;
+        cached_subvol = dht_subvol_get_cached(this, loc->inode);
+        if (!cached_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_CACHED_SUBVOL_GET_FAILED,
+                   "Failed to get cached subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (local->call_cnt != 1)
-                goto out;
-
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
-
-        if ((!op_ret) && !stbuf) {
-                goto out;
+        if (hashed_subvol == cached_subvol) {
+            op_errno = ENODATA;
+            goto err;
         }
 
-        local->op_ret = op_ret;
-        local->rebalance.target_op_fn = dht_setxattr2;
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+        STACK_WIND(frame, dht_linkinfo_getxattr_cbk, hashed_subvol,
+                   hashed_subvol->fops->getxattr, loc, GF_XATTR_PATHINFO_KEY,
+                   xdata);
+        return 0;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+    if (dht_is_debug_xattr_key(dht_dbg_vxattrs, (char *)key) >= 0) {
+        dht_handle_debug_getxattr(frame, this, loc, key);
+        return 0;
+    }
 
-        /* Phase 1 of migration */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
+no_key:
+    if (cluster_handle_marker_getxattr(frame, loc, key, conf->vol_uuid,
+                                       dht_getxattr_unwind,
+                                       dht_marker_populate_args) == 0)
+        return 0;
 
-                ret = dht_inode_ctx_get_mig_info (this, inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        dht_setxattr2 (this, subvol2, frame, 0);
-                        return 0;
+    if (DHT_IS_DIR(layout)) {
+        local->call_cnt = conf->subvolume_cnt;
+        cnt = conf->subvolume_cnt;
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+        if (!mds_subvol) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Cannot determine MDS, fetching xattr %s randomly"
+                   " from a subvol for path %s ",
+                   key, loc->path);
+        } else {
+            /* TODO need to handle it, As of now we are
+               choosing availability instead of chossing
+               consistencty, in case of mds_subvol is
+               down winding a getxattr call on other subvol
+               and return xattr
+            */
+            local->mds_subvol = mds_subvol;
+            for (i = 0; i < cnt; i++) {
+                if (conf->subvolumes[i] == mds_subvol) {
+                    if (!conf->subvolume_status[i]) {
+                        gf_msg(this->name, GF_LOG_INFO, 0,
+                               DHT_MSG_HASHED_SUBVOL_DOWN,
+                               "MDS %s is down for path"
+                               " path %s so fetching xattr "
+                               "%s randomly from a subvol ",
+                               local->mds_subvol->name, loc->path, key);
+                        ret = 1;
+                    }
                 }
-
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+            }
         }
 
-out:
+        if (!ret && key && local->mds_subvol && dht_match_xattr(key)) {
+            STACK_WIND(frame, dht_mds_getxattr_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->getxattr, loc, key, xdata);
 
-        if (local->fop == GF_FOP_SETXATTR) {
-                DHT_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL);
-        } else {
-                DHT_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL);
+            return 0;
         }
+    } else {
+        cnt = local->call_cnt = 1;
+    }
 
-        return 0;
-}
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_cbk, subvol, subvol->fops->getxattr, loc,
+                   key, xdata);
+    }
+    return 0;
 
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
 
+    return 0;
+}
+#undef DHT_IS_DIR
 
 int
-dht_fsetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, dict_t *xattr, int flags, dict_t *xdata)
-{
-        xlator_t     *subvol   = NULL;
-        dht_local_t  *local    = NULL;
-        int           op_errno = EINVAL;
-        dht_conf_t   *conf     = NULL;
-        dht_layout_t *layout   = NULL;
-        int           ret      = -1;
-        int           call_cnt = 0;
-        int           i        = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        if (!conf->defrag)
-                GF_IF_INTERNAL_XATTR_GOTO (conf->wild_xattr_name, xattr,
-                                           op_errno, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+dht_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+              dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int cnt = 0;
+    xlator_t *mds_subvol = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FGETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_NULL,
+               "Layout is NULL");
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    if (key) {
+        local->key = gf_strdup(key);
+        if (!local->key) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+    }
+
+    gf_uuid_unparse(fd->inode->gfid, gfid);
+
+    if ((fd->inode->ia_type == IA_IFDIR) && key &&
+        (strncmp(key, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) !=
+         0)) {
+        local->call_cnt = conf->subvolume_cnt;
+        cnt = conf->subvolume_cnt;
+        ret = dht_inode_ctx_mdsvol_get(fd->inode, this, &mds_subvol);
+
+        if (!mds_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "cannot determine MDS, fetching xattr %s "
+                   " randomly from a subvol for gfid %s ",
+                   key, gfid);
+        } else {
+            /* TODO need to handle it, As of now we are
+               choosing availability instead of chossing
+               consistencty, in case of hashed_subvol is
+               down winding a getxattr call on other subvol
+               and return xattr
+            */
+            local->mds_subvol = mds_subvol;
+            for (i = 0; i < cnt; i++) {
+                if (conf->subvolumes[i] == mds_subvol) {
+                    if (!conf->subvolume_status[i]) {
+                        gf_msg(this->name, GF_LOG_WARNING, 0,
+                               DHT_MSG_HASHED_SUBVOL_DOWN,
+                               "MDS subvolume %s is down"
+                               " for gfid %s so fetching xattr "
+                               " %s randomly from a subvol ",
+                               local->mds_subvol->name, gfid, key);
+                        ret = 1;
+                    }
+                }
+            }
         }
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+        if (!ret && key && local->mds_subvol && dht_match_xattr(key)) {
+            STACK_WIND(frame, dht_mds_getxattr_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->fgetxattr, fd, key, NULL);
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
+            return 0;
         }
 
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
-        local->call_cnt = call_cnt = layout->cnt;
+    } else {
+        cnt = local->call_cnt = 1;
+    }
 
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->fsetxattr,
-                                           fd, xattr, flags, xdata);
-                }
-
-        } else {
-
-                local->call_cnt = 1;
-                local->rebalance.xattr = dict_ref (xattr);
-                local->rebalance.flags = flags;
-
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg_debug (this->name, 0,
-                                      "Failed to set dictionary key %s for fd=%p",
-                                      DHT_IATT_IN_XDATA_KEY, fd);
-                }
-
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, fd, xattr,
-                                   flags, local->xattr_req);
-        }
-        return 0;
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_cbk, subvol, subvol->fops->fgetxattr, fd,
+                   key, NULL);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fgetxattr, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 static int
-dht_common_setxattr_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_setxattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        DHT_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-
-        return 0;
-}
-
-
-int
-dht_checking_pathinfo_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
-{
-        int           i     = -1;
-        int           ret   = -1;
-        char         *value = NULL;
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        xlator_t     *prev  = NULL;
-        int           this_call_cnt = 0;
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        if (op_ret == -1)
-                goto out;
-
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &value);
-        if (ret)
-                goto out;
+    if (!frame || !frame->local)
+        goto err;
 
-        if (!strcmp (value, local->key)) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvolumes[i] == prev)
-                                conf->decommissioned_bricks[i] = prev;
-                }
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-out:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret, ENOTSUP, NULL);
-        }
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         local->rebalance.xdata);
         return 0;
+    }
 
-}
-
-
-int
-dht_setxattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
-{
-        dht_local_t  *local  = NULL;
-        int          op_errno = EINVAL;
-
-        if (!frame || !frame->local)
-                goto err;
-
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                  local->op_errno, local->rebalance.xdata);
-                return 0;
-        }
-
-        if (subvol == NULL)
-                goto err;
-
+    if (subvol == NULL)
+        goto err;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        if (local->fop == GF_FOP_SETXATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->setxattr, &local->loc,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, local->fd,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_SETXATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->setxattr, &local->loc,
+                          local->rebalance.xattr, local->rebalance.flags,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->fsetxattr, local->fd,
+                          local->rebalance.xattr, local->rebalance.flags,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (setxattr, frame, (local ? local->op_ret : -1),
-                          op_errno, NULL);
-        return 0;
-}
-
-int
-dht_nuke_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
-{
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(setxattr, frame, (local ? local->op_ret : -1), op_errno,
+                     NULL);
+    return 0;
 }
 
 int
-dht_nuke_dir (call_frame_t *frame, xlator_t *this, loc_t *loc, data_t *tmp)
+dht_file_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata)
 {
-        if (!IA_ISDIR(loc->inode->ia_type)) {
-                DHT_STACK_UNWIND (setxattr, frame, -1, ENOTSUP, NULL);
-                return 0;
-        }
-
-        /* Setxattr didn't need the parent, but rmdir does. */
-        loc->parent = inode_parent (loc->inode, NULL, NULL);
-        if (!loc->parent) {
-                DHT_STACK_UNWIND (setxattr, frame, -1, ENOENT, NULL);
-                return 0;
-        }
-        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    struct iatt *stbuf = NULL;
+    inode_t *inode = NULL;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
 
-        if (!loc->name && loc->path) {
-                loc->name = strrchr (loc->path, '/');
-                if (loc->name) {
-                        ++(loc->name);
-                }
-        }
+    local = frame->local;
+    prev = cookie;
 
-        /*
-         * We do this instead of calling dht_rmdir_do directly for two reasons.
-         * The first is that we want to reuse all of the initialization that
-         * dht_rmdir does, so if it ever changes we'll just follow along.  The
-         * second (i.e. why we don't use STACK_WIND_TAIL) is so that we don't
-         * obscure the fact that we came in via this path instead of a genuine
-         * rmdir.  That makes debugging just a tiny bit easier.
-         */
-        STACK_WIND (frame, dht_nuke_dir_cbk, this, this->fops->rmdir,
-                    loc, 1, NULL);
+    local->op_errno = op_errno;
 
+    if ((local->fop == GF_FOP_FSETXATTR) &&
+        dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
         return 0;
-}
+    }
 
-int
-dht_setxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, dict_t *xattr, int flags, dict_t *xdata)
-{
-        xlator_t     *subvol   = NULL;
-        dht_local_t  *local    = NULL;
-        dht_conf_t   *conf     = NULL;
-        dht_methods_t *methods = NULL;
-        dht_layout_t *layout   = NULL;
-        int           i        = 0;
-        int           op_errno = EINVAL;
-        int           ret      = -1;
-        data_t       *tmp      = NULL;
-        uint32_t      dir_spread = 0;
-        char          value[4096] = {0,};
-        gf_dht_migrate_data_type_t forced_rebalance = GF_DHT_MIGRATE_DATA;
-        int           call_cnt = 0;
-        uint32_t      new_hash = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        conf   = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
-
-        methods = &(conf->methods);
-
-        /* Rebalance daemon is allowed to set internal keys */
-        if (!conf->defrag)
-                GF_IF_INTERNAL_XATTR_GOTO (conf->wild_xattr_name, xattr,
-                                           op_errno, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1.",
+                     prev->name);
+        goto out;
+    }
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s",
-                              loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (local->call_cnt != 1)
+        goto out;
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
 
-        local->call_cnt = call_cnt = layout->cnt;
+    if ((!op_ret) && !stbuf) {
+        goto out;
+    }
 
-        tmp = dict_get (xattr, GF_XATTR_FILE_MIGRATE_KEY);
-        if (tmp) {
+    local->op_ret = op_ret;
+    local->rebalance.target_op_fn = dht_setxattr2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-                if (IA_ISDIR (loc->inode->ia_type)) {
-                        op_errno = ENOTSUP;
-                        goto err;
-                }
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                /* TODO: need to interpret the 'value' for more meaning
-                   (ie, 'target' subvolume given there, etc) */
-                memcpy (value, tmp->data, tmp->len);
-                if (strcmp (value, "force") == 0)
-                       forced_rebalance =
-                                GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+    /* Phase 1 of migration */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-                if (conf->decommission_in_progress)
-                        forced_rebalance = GF_DHT_MIGRATE_HARDLINK;
+        ret = dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            dht_setxattr2(this, subvol2, frame, 0);
+            return 0;
+        }
 
-                if (!loc->path) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                if (!local->loc.name)
-                        local->loc.name = strrchr (local->loc.path, '/')+1;
+out:
 
-                if (!local->loc.parent)
-                        local->loc.parent =
-                                inode_parent(local->loc.inode, NULL, NULL);
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    } else {
+        DHT_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata);
+    }
 
-                if ((!local->loc.name) || (!local->loc.parent)) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+    return 0;
+}
 
-                if (gf_uuid_is_null (local->loc.pargfid))
-                        gf_uuid_copy (local->loc.pargfid, local->loc.parent->gfid);
+/* Function is call by dict_foreach_fnmatch if key is match with
+   user.* and set boolean flag to true
+*/
+static int
+dht_is_user_xattr(dict_t *this, char *key, data_t *value, void *data)
+{
+    gf_boolean_t *user_xattr_found = data;
+    *user_xattr_found = _gf_true;
+    return 0;
+}
 
-                methods->migration_get_dst_subvol(this, local);
+/* Common code to wind a (f)(set|remove)xattr call to set xattr on directory
+ */
+static int
+dht_dir_common_set_remove_xattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                fd_t *fd, dict_t *xattr, int flags,
+                                dict_t *xdata, int *op_errno)
+
+{
+    dict_t *xattrop = NULL;
+    int32_t subone[1] = {-1};
+    gf_boolean_t uxattr_key_found = _gf_false;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *travvol = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int i = 0;
+    int call_cnt = 0;
+    dht_local_t *local = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char **xattrs_to_heal;
+
+    conf = this->private;
+    local = frame->local;
+    call_cnt = conf->subvolume_cnt;
+    local->flags = flags;
+    xattrs_to_heal = get_xattrs_to_heal();
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid_local);
+    }
+
+    if ((local->fop == GF_FOP_SETXATTR) || (local->fop == GF_FOP_FSETXATTR)) {
+        /* Check if any user xattr present in xattr
+         */
+        dict_foreach_fnmatch(xattr, "user*", dht_is_user_xattr,
+                             &uxattr_key_found);
 
-                if (!local->rebalance.target_node) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get hashed subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
+        /* Check if any custom key xattr present in dict xattr
+           and start index from 1 because user xattr already
+           checked in previous line
+        */
+        for (i = 1; xattrs_to_heal[i]; i++)
+            if (dict_get(xattr, xattrs_to_heal[i]))
+                uxattr_key_found = _gf_true;
+    }
+
+    if ((local->fop == GF_FOP_REMOVEXATTR) ||
+        (local->fop == GF_FOP_FREMOVEXATTR)) {
+        /* Check if any custom key xattr present in local->key
+         */
+        for (i = 0; xattrs_to_heal[i]; i++)
+            if (strstr(local->key, xattrs_to_heal[i]))
+                uxattr_key_found = _gf_true;
+    }
+
+    /* If there is no custom key xattr present or gfid is root
+       or call_cnt is 1 then wind a (f)setxattr call on all subvols
+    */
+    if (!uxattr_key_found || __is_root_gfid(local->gfid) || call_cnt == 1) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            travvol = conf->subvolumes[i];
+            if ((local->fop == GF_FOP_SETXATTR) ||
+                (local->fop == GF_FOP_FSETXATTR)) {
+                if (fd) {
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->fsetxattr, fd, xattr,
+                                      flags, xdata);
+                } else {
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->setxattr, loc, xattr,
+                                      flags, xdata);
                 }
+            }
 
-                local->rebalance.from_subvol = local->cached_subvol;
-
-                if (local->rebalance.target_node == local->rebalance.from_subvol) {
-                        op_errno = EEXIST;
-                        goto err;
-                }
-                if (local->rebalance.target_node) {
-                        local->flags = forced_rebalance;
-
-                        /* Flag to suggest its a tiering migration
-                         * The reason for this dic key-value is that
-                         * promotions and demotions are multithreaded
-                         * so the original frame from gf_defrag_start()
-                         * is not carried. A new frame will be created when
-                         * we do syncop_setxattr(). This doesnot have the
-                         * frame->root->pid of the original frame. So we pass
-                         * this dic key-value when we do syncop_setxattr() to do
-                         * data migration and set the frame->root->pid to
-                         * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
-                         * calling dht_start_rebalance_task() */
-                        tmp = dict_get (xattr, TIERING_MIGRATION_KEY);
-                        if (tmp)
-                                frame->root->pid = GF_CLIENT_PID_TIER_DEFRAG;
-                        else
-                                frame->root->pid = GF_CLIENT_PID_DEFRAG;
-
-                        ret = dht_start_rebalance_task (this, frame);
-                        if (!ret)
-                                return 0;
-
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_REBALANCE_START_FAILED,
-                                "%s: failed to create a new rebalance synctask",
-                                loc->path);
+            if ((local->fop == GF_FOP_REMOVEXATTR) ||
+                (local->fop == GF_FOP_FREMOVEXATTR)) {
+                if (fd) {
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->fremovexattr, fd,
+                                      local->key, local->xattr_req);
+                } else {
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->removexattr, loc,
+                                      local->key, local->xattr_req);
                 }
-                op_errno = EINVAL;
-                goto err;
-
+            }
         }
 
-        tmp = dict_get (xattr, "decommission-brick");
-        if (tmp) {
-                /* This operation should happen only on '/' */
-                if (!__is_root_gfid (loc->inode->gfid)) {
-                        op_errno = ENOTSUP;
-                        goto err;
-                }
-
-                memcpy (value, tmp->data, ((tmp->len < 4095) ? tmp->len : 4095));
-                local->key = gf_strdup (value);
-                local->call_cnt = conf->subvolume_cnt;
+        return 0;
+    }
 
-                for (i = 0 ; i < conf->subvolume_cnt; i++) {
-                        /* Get the pathinfo, and then compare */
-                        STACK_WIND_COOKIE (frame, dht_checking_pathinfo_cbk,
-                                           conf->subvolumes[i], conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, GF_XATTR_PATHINFO_KEY, NULL);
-                }
-                return 0;
+    /* Calculate hash subvol based on inode and parent inode
+     */
+    if (fd) {
+        ret = dht_inode_ctx_mdsvol_get(fd->inode, this, &mds_subvol);
+    } else {
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+    }
+    if (ret || !mds_subvol) {
+        if (fd) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get mds subvol for fd %p"
+                   "gfid is %s ",
+                   fd, gfid_local);
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "%s: Failed to get mds subvol. (gfid is %s)", loc->path,
+                   gfid_local);
+        }
+        (*op_errno) = ENOENT;
+        goto err;
+    }
+
+    local->mds_subvol = mds_subvol;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == mds_subvol) {
+            if (!conf->subvolume_status[i]) {
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_HASHED_SUBVOL_DOWN,
+                       "MDS subvol is down for path "
+                       " %s gfid is %s Unable to set xattr ",
+                       local->loc.path, gfid_local);
+                (*op_errno) = ENOTCONN;
+                goto err;
+            }
+        }
+    }
+
+    if (uxattr_key_found) {
+        xattrop = dict_new();
+        if (!xattrop) {
+            gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+                   "dictionary creation failed for path %s "
+                   "for gfid is %s ",
+                   local->loc.path, gfid_local);
+            (*op_errno) = ENOMEM;
+            goto err;
+        }
+        local->xattr = dict_ref(xattr);
+        /* Subtract current MDS xattr value to -1 , value of MDS
+           xattr represents no. of times xattr modification failed
+           on non MDS subvols.
+        */
+        ret = dht_dict_set_array(xattrop, conf->mds_xattr_key, subone, 1);
+        if (ret != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "dictionary set array failed for path %s "
+                   "for gfid is %s ",
+                   local->loc.path, gfid_local);
+            if (xattrop)
+                dict_unref(xattrop);
+            (*op_errno) = ret;
+            goto err;
+        }
+        /* Wind a xattrop call to use ref counting approach
+           update mds xattr to -1 before update xattr on
+           hashed subvol and update mds xattr to +1 after update
+           xattr on all non hashed subvol
+        */
+        if (fd) {
+            STACK_WIND(frame, dht_xattrop_mds_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->fxattrop, fd,
+                       GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+        } else {
+            STACK_WIND(frame, dht_xattrop_mds_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->xattrop, loc,
+                       GF_XATTROP_ADD_ARRAY, xattrop, NULL);
         }
+        if (xattrop)
+            dict_unref(xattrop);
+    }
 
-        tmp = dict_get (xattr, GF_XATTR_FIX_LAYOUT_KEY);
-        if (tmp) {
-                ret = dict_get_uint32(xattr, "new-commit-hash", &new_hash);
-                if (ret == 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "updating commit hash for %s from %u to %u",
-                                      uuid_utoa(loc->gfid),
-                                      layout->commit_hash, new_hash);
-                        layout->commit_hash = new_hash;
-
-                        ret = dht_update_commit_hash_for_layout (frame);
-                        if (ret) {
-                                op_errno = ENOTCONN;
-                                goto err;
-                        }
-                        return ret;
-                }
+    return 0;
+err:
+    return -1;
+}
 
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_FIX_LAYOUT_INFO,
-                        "fixing the layout of %s", loc->path);
+int
+dht_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xattr,
+              int flags, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    if (!conf->defrag)
+        GF_IF_INTERNAL_XATTR_GOTO(conf->wild_xattr_name, xattr, op_errno, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+    local->call_cnt = call_cnt = layout->cnt;
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, NULL, fd, xattr,
+                                              flags, xdata, &op_errno);
+        if (ret)
+            goto err;
+    } else {
+        local->call_cnt = 1;
+        local->rebalance.xattr = dict_ref(xattr);
+        local->rebalance.flags = flags;
 
-                ret = dht_fix_directory_layout (frame, dht_common_setxattr_cbk,
-                                                layout);
-                if (ret) {
-                        op_errno = ENOTCONN;
-                        goto err;
-                }
-                return ret;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to set dictionary key %s for fd=%p",
+                         DHT_IATT_IN_XDATA_KEY, fd);
         }
 
-        tmp = dict_get (xattr, "distribute.directory-spread-count");
-        if (tmp) {
-                /* Setxattr value is packed as 'binary', not string */
-                memcpy (value, tmp->data, ((tmp->len < 4095)?tmp->len:4095));
-                ret = gf_string2uint32 (value, &dir_spread);
-                if (!ret && ((dir_spread <= conf->subvolume_cnt) &&
-                             (dir_spread > 0))) {
-                        layout->spread_cnt = dir_spread;
-
-                        ret = dht_fix_directory_layout (frame,
-                                                        dht_common_setxattr_cbk,
-                                                        layout);
-                        if (ret) {
-                                op_errno = ENOTCONN;
-                                goto err;
-                        }
-                        return ret;
-                }
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_OPERATION_NOT_SUP,
-                        "wrong 'directory-spread-count' value (%s)", value);
-                op_errno = ENOTSUP;
-                goto err;
-        }
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->fsetxattr, fd, xattr, flags,
+                          local->xattr_req);
+    }
+    return 0;
 
-        tmp = dict_get (xattr, "glusterfs.dht.nuke");
-        if (tmp) {
-                return dht_nuke_dir (frame, this, loc, tmp);
-        }
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
 
-        if (IA_ISDIR (loc->inode->ia_type)) {
+    return 0;
+}
 
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->setxattr,
-                                           loc, xattr, flags, xdata);
-                }
+static int
+dht_checking_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
+{
+    int i = -1;
+    int ret = -1;
+    char *value = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    if (op_ret == -1)
+        goto out;
 
-        } else {
+    ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &value);
+    if (ret)
+        goto out;
 
-                local->rebalance.xattr = dict_ref (xattr);
-                local->rebalance.flags = flags;
-                local->call_cnt = 1;
+    if (!strcmp(value, local->key)) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == prev)
+                conf->decommissioned_bricks[i] = prev;
+        }
+    }
 
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+out:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, ENOTSUP, NULL);
+    }
+    return 0;
+}
 
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->setxattr, loc, xattr,
-                                   flags, local->xattr_req);
-        }
+static int
+dht_nuke_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
+{
+    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, NULL);
+    return 0;
+}
 
+static int
+dht_nuke_dir(call_frame_t *frame, xlator_t *this, loc_t *loc, data_t *tmp)
+{
+    if (!IA_ISDIR(loc->inode->ia_type)) {
+        DHT_STACK_UNWIND(setxattr, frame, -1, ENOTSUP, NULL);
         return 0;
+    }
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-
+    /* Setxattr didn't need the parent, but rmdir does. */
+    loc->parent = inode_parent(loc->inode, NULL, NULL);
+    if (!loc->parent) {
+        DHT_STACK_UNWIND(setxattr, frame, -1, ENOENT, NULL);
         return 0;
-}
+    }
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
 
+    if (!loc->name && loc->path) {
+        loc->name = strrchr(loc->path, '/');
+        if (loc->name) {
+            ++(loc->name);
+        }
+    }
 
+    /*
+     * We do this instead of calling dht_rmdir_do directly for two reasons.
+     * The first is that we want to reuse all of the initialization that
+     * dht_rmdir does, so if it ever changes we'll just follow along.  The
+     * second (i.e. why we don't use STACK_WIND_TAIL) is so that we don't
+     * obscure the fact that we came in via this path instead of a genuine
+     * rmdir.  That makes debugging just a tiny bit easier.
+     */
+    STACK_WIND(frame, dht_nuke_dir_cbk, this, this->fops->rmdir, loc, 1, NULL);
 
+    return 0;
+}
 
 int
-dht_file_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, dict_t *xdata)
-{
-        int           ret     = -1;
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        struct iatt  *stbuf   = NULL;
-        inode_t      *inode   = NULL;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
-
-        local = frame->local;
-        prev = cookie;
+dht_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr,
+             int flags, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int op_errno = EINVAL;
+    int ret = -1;
+    data_t *tmp = NULL;
+    uint32_t dir_spread = 0;
+    char value[4096] = {
+        0,
+    };
+    gf_dht_migrate_data_type_t forced_rebalance = GF_DHT_MIGRATE_DATA;
+    int call_cnt = 0;
+    uint32_t new_hash = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
+
+    methods = &(conf->methods);
+
+    /* Rebalance daemon is allowed to set internal keys */
+    if (!conf->defrag)
+        GF_IF_INTERNAL_XATTR_GOTO(conf->wild_xattr_name, xattr, op_errno, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->call_cnt = call_cnt = layout->cnt;
+    tmp = dict_get(xattr, conf->mds_xattr_key);
+    if (tmp) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    tmp = dict_get(xattr, GF_XATTR_FILE_MIGRATE_KEY);
+    if (tmp) {
+        if (IA_ISDIR(loc->inode->ia_type)) {
+            op_errno = ENOTSUP;
+            goto err;
+        }
+
+        /* TODO: need to interpret the 'value' for more meaning
+           (ie, 'target' subvolume given there, etc) */
+        memcpy(value, tmp->data, tmp->len);
+        if (strcmp(value, "force") == 0)
+            forced_rebalance = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+
+        if (conf->decommission_in_progress)
+            forced_rebalance = GF_DHT_MIGRATE_HARDLINK;
+
+        if (!loc->path) {
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (!local->loc.name)
+            local->loc.name = strrchr(local->loc.path, '/') + 1;
+
+        if (!local->loc.parent)
+            local->loc.parent = inode_parent(local->loc.inode, NULL, NULL);
+
+        if ((!local->loc.name) || (!local->loc.parent)) {
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (gf_uuid_is_null(local->loc.pargfid))
+            gf_uuid_copy(local->loc.pargfid, local->loc.parent->gfid);
+
+        methods->migration_get_dst_subvol(this, local);
+
+        if (!local->rebalance.target_node) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        local->rebalance.from_subvol = local->cached_subvol;
+
+        if (local->rebalance.target_node == local->rebalance.from_subvol) {
+            op_errno = EEXIST;
+            goto err;
+        }
+        if (local->rebalance.target_node) {
+            local->flags = forced_rebalance;
 
-        local->op_errno = op_errno;
+            frame->root->pid = GF_CLIENT_PID_DEFRAG;
 
-        if ((local->fop == GF_FOP_FREMOVEXATTR) &&
-            (op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
+            ret = dht_start_rebalance_task(this, frame);
+            if (!ret)
                 return 0;
-        }
 
-        if ((op_ret == -1) && !dht_inode_missing (op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+                   "%s: failed to create a new rebalance synctask", loc->path);
         }
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (local->call_cnt != 1)
-                goto out;
+    tmp = dict_get(xattr, "decommission-brick");
+    if (tmp) {
+        /* This operation should happen only on '/' */
+        if (!__is_root_gfid(loc->inode->gfid)) {
+            op_errno = ENOTSUP;
+            goto err;
+        }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
+        memcpy(value, tmp->data, min(tmp->len, 4095));
+        local->key = gf_strdup(value);
+        local->call_cnt = conf->subvolume_cnt;
 
-        if ((!op_ret) && !stbuf) {
-                goto out;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            /* Get the pathinfo, and then compare */
+            STACK_WIND_COOKIE(frame, dht_checking_pathinfo_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              GF_XATTR_PATHINFO_KEY, NULL);
         }
+        return 0;
+    }
 
-        local->op_ret = 0;
+    tmp = dict_get(xattr, GF_XATTR_FIX_LAYOUT_KEY);
+    if (tmp) {
+        ret = dict_get_uint32(xattr, "new-commit-hash", &new_hash);
+        if (ret == 0) {
+            gf_msg_debug(this->name, 0,
+                         "updating commit hash for %s from %u to %u",
+                         uuid_utoa(loc->gfid), layout->commit_hash, new_hash);
+            layout->commit_hash = new_hash;
+
+            ret = dht_update_commit_hash_for_layout(frame);
+            if (ret) {
+                op_errno = ENOTCONN;
+                goto err;
+            }
+            return ret;
+        }
 
-        local->rebalance.target_op_fn = dht_removexattr2;
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_FIX_LAYOUT_INFO,
+               "fixing the layout of %s", loc->path);
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+        ret = dht_fix_directory_layout(frame, dht_fix_layout_setxattr_cbk,
+                                       layout);
+        if (ret) {
+            op_errno = ENOTCONN;
+            goto err;
         }
+        return ret;
+    }
+
+    tmp = dict_get(xattr, "distribute.directory-spread-count");
+    if (tmp) {
+        /* Setxattr value is packed as 'binary', not string */
+        memcpy(value, tmp->data, min(tmp->len, 4095));
+        ret = gf_string2uint32(value, &dir_spread);
+        if (!ret && ((dir_spread <= conf->subvolume_cnt) && (dir_spread > 0))) {
+            layout->spread_cnt = dir_spread;
+
+            ret = dht_fix_directory_layout(frame, dht_common_setxattr_cbk,
+                                           layout);
+            if (ret) {
+                op_errno = ENOTCONN;
+                goto err;
+            }
+            return ret;
+        }
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_OPERATION_NOT_SUP,
+               "wrong 'directory-spread-count' value (%s)", value);
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    tmp = dict_get(xattr, "glusterfs.dht.nuke");
+    if (tmp) {
+        return dht_nuke_dir(frame, this, loc, tmp);
+    }
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, loc, NULL, xattr,
+                                              flags, xdata, &op_errno);
+        if (ret)
+            goto err;
+    } else {
+        local->rebalance.xattr = dict_ref(xattr);
+        local->rebalance.flags = flags;
+        local->call_cnt = 1;
 
-        /* Phase 1 of migration */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
 
-                ret = dht_inode_ctx_get_mig_info (this, inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        dht_removexattr2 (this, subvol2, frame, 0);
-                        return 0;
-                }
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->setxattr, loc, xattr, flags,
+                          local->xattr_req);
+    }
 
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+    return 0;
 
-out:
-        if (local->fop == GF_FOP_REMOVEXATTR) {
-                DHT_STACK_UNWIND (removexattr, frame, op_ret, op_errno, NULL);
-        } else {
-                DHT_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, NULL);
-        }
-        return 0;
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
+    return 0;
 }
 
-int
-dht_removexattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                  int ret)
+static int
+dht_removexattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto err;
+    if (!frame || !frame->local)
+        goto err;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        local->call_cnt = 2; /* This is the second attempt */
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
+    local->call_cnt = 2; /* This is the second attempt */
 
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, local->rebalance.xdata);
-                return 0;
-        }
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto err;
+    if (subvol == NULL)
+        goto err;
 
-        if (local->fop == GF_FOP_REMOVEXATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->removexattr,
-                                   &local->loc, local->key, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr,
-                                   local->fd, local->key, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->removexattr, &local->loc, local->key,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->fremovexattr, local->fd, local->key,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+dht_file_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    struct iatt *stbuf = NULL;
+    inode_t *inode = NULL;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
 
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
 
-                local->op_ret = 0;
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
-        }
+    local->op_errno = op_errno;
 
+    if ((local->fop == GF_FOP_FREMOVEXATTR) &&
+        dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
         return 0;
-}
+    }
 
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
 
-int
-dht_removexattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, const char *key, dict_t *xdata)
-{
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           call_cnt = 0;
-        dht_conf_t   *conf = NULL;
-        int i;
-        int           ret = 0;
+    if (local->call_cnt != 1)
+        goto out;
 
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
 
-        conf = this->private;
+    if ((!op_ret) && !stbuf) {
+        goto out;
+    }
 
-        GF_IF_NATIVE_XATTR_GOTO (conf->wild_xattr_name, key, op_errno, err);
+    local->op_ret = 0;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
+    local->rebalance.target_op_fn = dht_removexattr2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_REMOVEXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    /* Phase 1 of migration */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-        layout = local->layout;
-        if (!local->layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
+        ret = dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            dht_removexattr2(this, subvol2, frame, 0);
+            return 0;
         }
-        local->xattr_req = (xdata) ? dict_ref (xdata) : dict_new ();
-
-        local->call_cnt = call_cnt = layout->cnt;
-        local->key = gf_strdup (key);
 
-        if (IA_ISDIR (loc->inode->ia_type)) {
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_removexattr_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->removexattr,
-                                           loc, key, local->xattr_req);
-                }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        } else {
+out:
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata);
+    } else {
+        DHT_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
+    }
+    return 0;
+}
 
-                local->call_cnt = 1;
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED, "Failed to "
-                                "set dictionary key %s for %s",
-                                DHT_IATT_IN_XDATA_KEY, loc->path);
-                }
+int
+dht_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *key, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    GF_IF_NATIVE_XATTR_GOTO(conf->wild_xattr_name, key, op_errno, err);
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_REMOVEXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!local->layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
+
+    local->call_cnt = call_cnt = layout->cnt;
+    local->key = gf_strdup(key);
+
+    if (key && (strncmp(key, conf->mds_xattr_key, strlen(key)) == 0)) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, loc, NULL, NULL, 0,
+                                              local->xattr_req, &op_errno);
+        if (ret)
+            goto err;
 
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->removexattr, loc, key,
-                                   local->xattr_req);
+    } else {
+        local->call_cnt = 1;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to "
+                   "set dictionary key %s for %s",
+                   DHT_IATT_IN_XDATA_KEY, loc->path);
         }
 
-        return 0;
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->removexattr, loc, key,
+                          local->xattr_req);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fremovexattr (call_frame_t *frame, xlator_t *this,
-                  fd_t *fd, const char *key, dict_t *xdata)
+dht_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+                 dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           call_cnt = 0;
-        dht_conf_t   *conf = 0;
-        int           ret = 0;
-
-        int i;
-
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        GF_IF_NATIVE_XATTR_GOTO (conf->wild_xattr_name, key, op_errno, err);
-
-        VALIDATE_OR_GOTO (frame, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FREMOVEXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for inode=%s",
-                              uuid_utoa (fd->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = 0;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    GF_IF_NATIVE_XATTR_GOTO(conf->wild_xattr_name, key, op_errno, err);
+
+    VALIDATE_OR_GOTO(frame, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FREMOVEXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for inode=%s",
+                     uuid_utoa(fd->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!local->layout) {
+        gf_msg_debug(this->name, 0, "no layout for inode=%s",
+                     uuid_utoa(fd->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+
+    local->call_cnt = call_cnt = layout->cnt;
+    local->key = gf_strdup(key);
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, NULL, fd, NULL, 0,
+                                              local->xattr_req, &op_errno);
+        if (ret)
+            goto err;
 
-        layout = local->layout;
-        if (!local->layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for inode=%s",
-                              uuid_utoa (fd->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
+    } else {
+        local->call_cnt = 1;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to "
+                   "set dictionary key %s for fd=%p",
+                   DHT_IATT_IN_XDATA_KEY, fd);
         }
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
-
-        local->call_cnt = call_cnt = layout->cnt;
-        local->key = gf_strdup (key);
 
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_removexattr_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->fremovexattr,
-                                           fd, key, local->xattr_req);
-                }
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->fremovexattr, fd, key,
+                          local->xattr_req);
+    }
 
-        } else {
-
-                local->call_cnt = 1;
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED, "Failed to "
-                                "set dictionary key %s for fd=%p",
-                                DHT_IATT_IN_XDATA_KEY, fd);
-                }
-
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr, fd, key,
-                                   local->xattr_req);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fd_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_fd_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+           int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
 
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto post_unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (open, frame, local->op_ret, local->op_errno,
-                                  local->fd, NULL);
+        local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(open, frame, local->op_ret, local->op_errno, local->fd,
+                         NULL);
 
-        return 0;
+    return 0;
 }
 
 /*
  * dht_normalize_stats -
  */
-void
-dht_normalize_stats (struct statvfs *buf, unsigned long bsize,
-                     unsigned long frsize)
+static void
+dht_normalize_stats(struct statvfs *buf, unsigned long bsize,
+                    unsigned long frsize)
 {
-        double factor = 0;
+    double factor = 0;
 
-        if (buf->f_bsize != bsize) {
-                buf->f_bsize = bsize;
-        }
+    if (buf->f_bsize != bsize) {
+        buf->f_bsize = bsize;
+    }
 
-        if (buf->f_frsize != frsize) {
-                factor = ((double) buf->f_frsize) / frsize;
-                buf->f_frsize = frsize;
-                buf->f_blocks = (fsblkcnt_t) (factor * buf->f_blocks);
-                buf->f_bfree  = (fsblkcnt_t) (factor * buf->f_bfree);
-                buf->f_bavail = (fsblkcnt_t) (factor * buf->f_bavail);
+    if (buf->f_frsize != frsize) {
+        factor = ((double)buf->f_frsize) / frsize;
+        buf->f_frsize = frsize;
+        buf->f_blocks = (fsblkcnt_t)(factor * buf->f_blocks);
+        buf->f_bfree = (fsblkcnt_t)(factor * buf->f_bfree);
+        buf->f_bavail = (fsblkcnt_t)(factor * buf->f_bavail);
+    }
+}
 
+static int
+dht_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct statvfs *statvfs, dict_t *xdata)
+{
+    gf_boolean_t event = _gf_false;
+    qdstatfs_action_t action = qdstatfs_action_OFF;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int bsize = 0;
+    int frsize = 0;
+    GF_UNUSED int ret = 0;
+    unsigned long new_usage = 0;
+    unsigned long cur_usage = 0;
+
+    local = frame->local;
+    GF_ASSERT(local);
+
+    if (xdata)
+        ret = dict_get_int8(xdata, "quota-deem-statfs", (int8_t *)&event);
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
-}
+        if (!statvfs) {
+            op_errno = EINVAL;
+            local->op_ret = -1;
+            goto unlock;
+        }
+        local->op_ret = 0;
 
-int
-dht_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct statvfs *statvfs,
-                dict_t *xdata)
-{
+        if (local->quota_deem_statfs) {
+            if (event == _gf_true) {
+                action = qdstatfs_action_COMPARE;
+            } else {
+                action = qdstatfs_action_NEGLECT;
+            }
+        } else {
+            if (event == _gf_true) {
+                action = qdstatfs_action_REPLACE;
+                local->quota_deem_statfs = _gf_true;
+            }
+        }
 
-        gf_boolean_t            event              = _gf_false;
-        qdstatfs_action_t       action             = qdstatfs_action_OFF;
-        dht_local_t *           local              = NULL;
-        int                     this_call_cnt      = 0;
-        int                     bsize              = 0;
-        int                     frsize             = 0;
-        GF_UNUSED int           ret                = 0;
-        unsigned long           new_usage          = 0;
-        unsigned long           cur_usage          = 0;
+        if (local->quota_deem_statfs) {
+            switch (action) {
+                case qdstatfs_action_NEGLECT:
+                    goto unlock;
 
-        local = frame->local;
-        GF_ASSERT (local);
+                case qdstatfs_action_REPLACE:
+                    local->statvfs = *statvfs;
+                    goto unlock;
 
-        if (xdata)
-                ret = dict_get_int8 (xdata, "quota-deem-statfs",
-                                     (int8_t *)&event);
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-                if (!statvfs) {
-                        op_errno = EINVAL;
-                        local->op_ret = -1;
-                        goto unlock;
-                }
-                local->op_ret = 0;
+                case qdstatfs_action_COMPARE:
+                    new_usage = statvfs->f_blocks - statvfs->f_bfree;
+                    cur_usage = local->statvfs.f_blocks -
+                                local->statvfs.f_bfree;
 
-                switch (local->quota_deem_statfs) {
-                case _gf_true:
-                        if (event == _gf_true)
-                                action = qdstatfs_action_COMPARE;
-                        else
-                                action = qdstatfs_action_NEGLECT;
-                        break;
-
-                case _gf_false:
-                        if (event == _gf_true) {
-                                action = qdstatfs_action_REPLACE;
-                                local->quota_deem_statfs = _gf_true;
-                        }
-                        break;
+                    /* Take the max of the usage from subvols */
+                    if (new_usage >= cur_usage)
+                        local->statvfs = *statvfs;
+                    goto unlock;
 
                 default:
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_VALUE,
-                                "Encountered third "
-                                "value for boolean variable %d",
-                                local->quota_deem_statfs);
-                        break;
-                }
-
-                if (local->quota_deem_statfs) {
-                        switch (action) {
-                        case qdstatfs_action_NEGLECT:
-                                goto unlock;
+                    break;
+            }
+        }
 
-                        case qdstatfs_action_REPLACE:
-                                local->statvfs = *statvfs;
-                                goto unlock;
+        if (local->statvfs.f_bsize != 0) {
+            bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
+            frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
+            dht_normalize_stats(&local->statvfs, bsize, frsize);
+            dht_normalize_stats(statvfs, bsize, frsize);
+        } else {
+            local->statvfs.f_bsize = statvfs->f_bsize;
+            local->statvfs.f_frsize = statvfs->f_frsize;
+        }
+
+        local->statvfs.f_blocks += statvfs->f_blocks;
+        local->statvfs.f_bfree += statvfs->f_bfree;
+        local->statvfs.f_bavail += statvfs->f_bavail;
+        local->statvfs.f_files += statvfs->f_files;
+        local->statvfs.f_ffree += statvfs->f_ffree;
+        local->statvfs.f_favail += statvfs->f_favail;
+        local->statvfs.f_fsid = statvfs->f_fsid;
+        local->statvfs.f_flag = statvfs->f_flag;
+        local->statvfs.f_namemax = statvfs->f_namemax;
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-                        case qdstatfs_action_COMPARE:
-                                new_usage = statvfs->f_blocks -
-                                             statvfs->f_bfree;
-                                cur_usage = local->statvfs.f_blocks -
-                                             local->statvfs.f_bfree;
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                         &local->statvfs, xdata);
 
-                                /* Take the max of the usage from subvols */
-                                if (new_usage >= cur_usage)
-                                        local->statvfs = *statvfs;
-                                goto unlock;
+    return 0;
+}
 
-                        default:
-                                break;
-                        }
-                }
+int
+dht_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    inode_t *inode = NULL;
+    inode_table_t *itable = NULL;
+    static uuid_t root_gfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+    loc_t newloc = {
+        0,
+    };
 
-                if (local->statvfs.f_bsize != 0) {
-                        bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
-                        frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
-                        dht_normalize_stats(&local->statvfs, bsize, frsize);
-                        dht_normalize_stats(statvfs, bsize, frsize);
-                } else {
-                        local->statvfs.f_bsize    = statvfs->f_bsize;
-                        local->statvfs.f_frsize   = statvfs->f_frsize;
-                }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-                local->statvfs.f_blocks  += statvfs->f_blocks;
-                local->statvfs.f_bfree   += statvfs->f_bfree;
-                local->statvfs.f_bavail  += statvfs->f_bavail;
-                local->statvfs.f_files   += statvfs->f_files;
-                local->statvfs.f_ffree   += statvfs->f_ffree;
-                local->statvfs.f_favail  += statvfs->f_favail;
-                local->statvfs.f_fsid     = statvfs->f_fsid;
-                local->statvfs.f_flag     = statvfs->f_flag;
-                local->statvfs.f_namemax  = statvfs->f_namemax;
+    conf = this->private;
 
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_STATFS);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
+    if (loc->inode && !IA_ISDIR(loc->inode->ia_type)) {
+        itable = loc->inode->table;
+        if (!itable) {
+            op_errno = EINVAL;
+            goto err;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
+        loc = &local->loc2;
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (statfs, frame, local->op_ret, local->op_errno,
-                                  &local->statvfs, xdata);
-
-        return 0;
-}
+        inode = inode_find(itable, root_gfid);
+        if (!inode) {
+            op_errno = EINVAL;
+            goto err;
+        }
 
+        dht_build_root_loc(inode, &newloc);
+        loc = &newloc;
+    }
 
-int
-dht_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        inode_t          *inode         = NULL;
-        inode_table_t    *itable        = NULL;
-        uuid_t            root_gfid     = {0, };
-        loc_t         newloc = {0, };
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_STATFS);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local->call_cnt = conf->subvolume_cnt;
 
-        if (loc->inode && !IA_ISDIR (loc->inode->ia_type)) {
-                itable = loc->inode->table;
-                if (!itable) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND(frame, dht_statfs_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->statfs, loc, xdata);
+    }
+    return 0;
 
-                loc = &local->loc2;
-                root_gfid[15] = 1;
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
 
-                inode = inode_find (itable, root_gfid);
-                if (!inode) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+    return 0;
+}
 
-                dht_build_root_loc (inode, &newloc);
-                loc = &newloc;
+int
+dht_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+            dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int ret = 0;
+    gf_boolean_t new_xdata = _gf_false;
+    xlator_t **subvolumes = NULL;
+    int call_count = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_OPENDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->first_up_subvol = dht_first_up_subvol(this);
+
+    if (!xdata) {
+        xdata = dict_new();
+        if (!xdata) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        new_xdata = _gf_true;
+    }
+
+    ret = dict_set_uint32(xdata, conf->link_xattr_name, 256);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value : key = %s",
+               conf->link_xattr_name);
+
+    /* dht_readdirp will wind to all subvols so open has to be sent to
+     * all subvols whether or not conf->local_subvols is set */
+
+    call_count = local->call_cnt = conf->subvolume_cnt;
+    subvolumes = conf->subvolumes;
+
+    /* In case of parallel-readdir, the readdir-ahead will be loaded
+     * below dht, in this case, if we want to enable or disable SKIP_DIRs
+     * it has to be done in opendir, so that prefetching logic in
+     * readdir-ahead, honors it */
+    for (i = 0; i < call_count; i++) {
+        if (conf->readdir_optimize == _gf_true) {
+            if (subvolumes[i] != local->first_up_subvol) {
+                ret = dict_set_int32(xdata, GF_READDIR_SKIP_DIRS, 1);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary"
+                           " value :key = %s, ret:%d",
+                           GF_READDIR_SKIP_DIRS, ret);
+            }
         }
 
-        local->call_cnt = conf->subvolume_cnt;
+        STACK_WIND_COOKIE(frame, dht_fd_cbk, subvolumes[i], subvolumes[i],
+                          subvolumes[i]->fops->opendir, loc, fd, xdata);
+        dict_del(xdata, GF_READDIR_SKIP_DIRS);
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND (frame, dht_statfs_cbk,
-                            conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->statfs, loc,
-                            xdata);
-        }
-        return 0;
+    if (new_xdata)
+        dict_unref(xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(opendir, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
+/* dht_readdirp_cbk creates a new dentry and dentry->inode is not assigned.
+   This functions assigns an inode if all of the following conditions are
+   true:
 
-int
-dht_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-             dict_t *xdata)
+   * DHT has only one child. In this case the entire layout is present on
+   this single child and hence we can set complete layout in inode.
+   * backend has complete layout and there are no anomalies in it and from
+   this information layout can be constructed and set in inode.
+*/
+
+static void
+dht_populate_inode_for_dentry(xlator_t *this, xlator_t *subvol,
+                              gf_dirent_t *entry, gf_dirent_t *orig_entry)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        int           ret = 0;
-        gf_boolean_t  new_xdata = _gf_false;
-        xlator_t    **subvolumes = NULL;
-        int           call_count = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_OPENDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    dht_layout_t *layout = NULL;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
 
-        if (!xdata) {
-                xdata = dict_new ();
-                if (!xdata) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                new_xdata = _gf_true;
-        }
+    if (gf_uuid_is_null(orig_entry->d_stat.ia_gfid)) {
+        /* this skips the '..' entry for the root of the volume */
+        return;
+    }
 
-        ret = dict_set_uint32 (xdata, conf->link_xattr_name, 256);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value : key = %s",
-                        conf->link_xattr_name);
-
-        if ((conf->defrag && conf->defrag->cmd == GF_DEFRAG_CMD_START_TIER) ||
-            (conf->defrag && conf->defrag->cmd ==
-             GF_DEFRAG_CMD_START_DETACH_TIER) ||
-            (!(conf->local_subvols_cnt) || !conf->defrag)) {
-                call_count = local->call_cnt = conf->subvolume_cnt;
-                subvolumes = conf->subvolumes;
-        } else {
-                call_count = local->call_cnt = conf->local_subvols_cnt;
-                subvolumes = conf->local_subvols;
-        }
-
-        for (i = 0; i < call_count; i++) {
-                if (conf->readdir_optimize == _gf_true) {
-                        if (subvolumes[i] != local->first_up_subvol) {
-                                ret = dict_set_int32 (xdata,
-                                                      GF_READDIR_SKIP_DIRS, 1);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_DICT_SET_FAILED,
-                                                "Failed to set dictionary"
-                                                " value :key = %s, ret:%d",
-                                                GF_READDIR_SKIP_DIRS, ret);
-                                }
-                }
+    gf_uuid_copy(loc.gfid, orig_entry->d_stat.ia_gfid);
+    loc.inode = inode_ref(orig_entry->inode);
 
-                STACK_WIND_COOKIE (frame, dht_fd_cbk,
-                                   subvolumes[i],
-                                   subvolumes[i],
-                                   subvolumes[i]->fops->opendir,
-                                   loc, fd, xdata);
-                dict_del (xdata, GF_READDIR_SKIP_DIRS);
-        }
+    if (is_revalidate(&loc)) {
+        goto out;
+    }
 
-        if (new_xdata)
-                dict_unref (xdata);
+    layout = dht_layout_new(this, 1);
+    if (!layout)
+        goto out;
 
-        return 0;
+    ret = dht_layout_merge(this, layout, subvol, 0, 0, orig_entry->dict);
+    if (!ret) {
+        ret = dht_layout_normalize(this, &loc, layout);
+        if (ret == 0) {
+            dht_layout_set(this, orig_entry->inode, layout);
+            entry->inode = inode_ref(orig_entry->inode);
+            layout = NULL;
+        }
+    }
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (opendir, frame, -1, op_errno, NULL, NULL);
+    if (layout)
+        dht_layout_unref(this, layout);
 
-        return 0;
+out:
+    loc_wipe(&loc);
+    return;
 }
 
+/* Posix returns op_errno = ENOENT to indicate that there are no more
+ * entries
+ */
+static int
+dht_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *next_subvol = NULL;
+    off_t next_offset = 0;
+    int count = 0;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    xlator_t *subvol = 0;
+    xlator_t *hashed_subvol = 0;
+    int ret = 0;
+    int readdir_optimize = 0;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+    gf_boolean_t skip_hashed_check = _gf_false;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    prev = cookie;
+    local = frame->local;
+    GF_VALIDATE_OR_GOTO(this->name, local->fd, unwind);
+
+    itable = local->fd->inode->table;
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
+
+    methods = &(conf->methods);
+
+    if (op_ret <= 0) {
+        goto done;
+    }
+
+    /* Why aren't we skipping DHT entirely in case of a single subvol?
+     * Because if this was a larger volume earlier and all but one subvol
+     * was removed, there might be stale linkto files on the subvol.
+     */
+    if (conf->subvolume_cnt == 1) {
+        /* return all directory and file entries except
+         * linkto files for a single child DHT
+         */
+        skip_hashed_check = _gf_true;
+    }
 
-int
-dht_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
-{
-        dht_local_t             *local = NULL;
-        gf_dirent_t             *orig_entry = NULL;
-        gf_dirent_t             *entry = NULL;
-        xlator_t                *prev = NULL;
-        xlator_t                *next_subvol = NULL;
-        off_t                    next_offset = 0;
-        int                      count = 0;
-        dht_layout_t            *layout = 0;
-        dht_conf_t              *conf   = NULL;
-        dht_methods_t           *methods = NULL;
-        xlator_t                *subvol = 0;
-        xlator_t                *hashed_subvol = 0;
-        int                      ret    = 0;
-        int                      readdir_optimize = 0;
-        inode_table_t           *itable = NULL;
-        inode_t                 *inode = NULL;
-
-        prev = cookie;
-        local = frame->local;
-        itable = local->fd ? local->fd->inode->table : NULL;
+    if (!local->layout)
+        local->layout = dht_layout_get(this, local->fd->inode);
 
-        conf  = this->private;
-        GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
+    layout = local->layout;
 
-        methods = &(conf->methods);
+    /* This will skip the entries on the subvol without a layout,
+     * hence preventing the crash but rmdir might fail with
+     * "directory not empty" errors*/
 
-        local->op_errno = op_errno;
+    if (layout == NULL)
+        goto done;
 
-        if (op_ret < 0)
-                goto done;
+    if (conf->readdir_optimize == _gf_true)
+        readdir_optimize = 1;
 
-        if (local->op_ret < 0)
-                local->op_ret = 0;
+    gf_msg_debug(this->name, 0, "Processing entries from %s", prev->name);
 
-        if (!local->layout)
-                local->layout = dht_layout_get (this, local->fd->inode);
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        next_offset = orig_entry->d_off;
 
-        layout = local->layout;
+        gf_msg_debug(this->name, 0, "%s: entry = %s, type = %d", prev->name,
+                     orig_entry->d_name, orig_entry->d_type);
 
-        /* We have seen crashes in while running "rm -rf" on tier volumes
-           when the layout was NULL on the hot tier. This will skip the
-           entries on the subvol without a layout, hence preventing the crash
-           but rmdir might fail with "directory not empty" errors*/
+        if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
+            /*stat failed somewhere- display this entry but the data may
+             * be inaccurate.
+             */
+            gf_msg_debug(this->name, EINVAL, "Invalid stat for %s (gfid %s)",
+                         orig_entry->d_name,
+                         uuid_utoa(orig_entry->d_stat.ia_gfid));
+        }
 
-        if (layout == NULL)
-                goto done;
+        if (check_is_linkfile(NULL, (&orig_entry->d_stat), orig_entry->dict,
+                              conf->link_xattr_name)) {
+            gf_msg_debug(this->name, 0, "%s: %s is a linkto file", prev->name,
+                         orig_entry->d_name);
+            continue;
+        }
 
-        if (conf->readdir_optimize == _gf_true)
-                readdir_optimize = 1;
-
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                next_offset = orig_entry->d_off;
-                if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
-                        /*stat failed somewhere- ignore this entry*/
-                        gf_msg_debug (this->name, EINVAL,
-                                      "Invalid stat, ignoring entry "
-                                      "%s gfid %s", orig_entry->d_name,
-                                      uuid_utoa (orig_entry->d_stat.ia_gfid));
-                        continue;
-                }
+        if (skip_hashed_check) {
+            goto list;
+        }
 
-                if (check_is_dir (NULL, (&orig_entry->d_stat), NULL)) {
+        if (check_is_dir(NULL, (&orig_entry->d_stat), NULL)) {
+            /*Directory entries filtering :
+             * a) If rebalance is running, pick from first_up_subvol
+             * b) (rebalance not running)hashed subvolume is NULL or
+             * down then filter in first_up_subvolume. Other wise the
+             * corresponding hashed subvolume will take care of the
+             * directory entry.
+             */
+            if (readdir_optimize) {
+                if (prev == local->first_up_subvol)
+                    goto list;
+                else
+                    continue;
+            }
 
-                /*Directory entries filtering :
-                 * a) If rebalance is running, pick from first_up_subvol
-                 * b) (rebalance not running)hashed subvolume is NULL or
-                 * down then filter in first_up_subvolume. Other wise the
-                 * corresponding hashed subvolume will take care of the
-                 * directory entry.
-                 */
-                        if (readdir_optimize) {
-                                if (prev == local->first_up_subvol)
-                                        goto list;
-                                else
-                                        continue;
+            hashed_subvol = methods->layout_search(this, layout,
+                                                   orig_entry->d_name);
 
-                        }
+            if (prev == hashed_subvol)
+                goto list;
+            if ((hashed_subvol && dht_subvol_status(conf, hashed_subvol)) ||
+                (prev != local->first_up_subvol))
+                continue;
 
-                        hashed_subvol = methods->layout_search (this, layout,
-                                                         orig_entry->d_name);
+            goto list;
+        }
 
-                        if (prev == hashed_subvol)
-                                goto list;
-                        if ((hashed_subvol
-                             && dht_subvol_status (conf, hashed_subvol))
-                            || (prev != local->first_up_subvol))
-                                continue;
+    list:
+        entry = gf_dirent_for_name(orig_entry->d_name);
+        if (!entry) {
+            goto unwind;
+        }
 
-                        goto list;
-                }
+        /* Do this if conf->search_unhashed is set to "auto" */
+        if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) {
+            subvol = methods->layout_search(this, layout, orig_entry->d_name);
+            if (!subvol || (subvol != prev)) {
+                /* TODO: Count the number of entries which need
+                   linkfile to prove its existence in fs */
+                layout->search_unhashed++;
+            }
+        }
 
-                if (check_is_linkfile (NULL, (&orig_entry->d_stat),
-                                       orig_entry->dict,
-                                       conf->link_xattr_name)) {
-                        continue;
-                }
+        entry->d_off = orig_entry->d_off;
+        entry->d_stat = orig_entry->d_stat;
+        entry->d_ino = orig_entry->d_ino;
+        entry->d_type = orig_entry->d_type;
+        entry->d_len = orig_entry->d_len;
 
-list:
-                entry = gf_dirent_for_name (orig_entry->d_name);
-                if (!entry) {
-                        goto unwind;
-                }
+        if (orig_entry->dict)
+            entry->dict = dict_ref(orig_entry->dict);
 
-                /* Do this if conf->search_unhashed is set to "auto" */
-                if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) {
-                        subvol = methods->layout_search (this, layout,
-                                                         orig_entry->d_name);
-                        if (!subvol || (subvol != prev)) {
-                                /* TODO: Count the number of entries which need
-                                   linkfile to prove its existence in fs */
-                                layout->search_unhashed++;
-                        }
-                }
+        /* making sure we set the inode ctx right with layout,
+           currently possible only for non-directories, so for
+           directories don't set entry inodes */
+        if (IA_ISDIR(entry->d_stat.ia_type)) {
+            entry->d_stat.ia_blocks = DHT_DIR_STAT_BLOCKS;
+            entry->d_stat.ia_size = DHT_DIR_STAT_SIZE;
+            if (orig_entry->inode) {
+                dht_inode_ctx_time_update(orig_entry->inode, this,
+                                          &entry->d_stat, 1);
 
-                entry->d_off  = orig_entry->d_off;
-                entry->d_stat = orig_entry->d_stat;
-                entry->d_ino  = orig_entry->d_ino;
-                entry->d_type = orig_entry->d_type;
-                entry->d_len  = orig_entry->d_len;
-
-                if (orig_entry->dict)
-                        entry->dict = dict_ref (orig_entry->dict);
-
-                /* making sure we set the inode ctx right with layout,
-                   currently possible only for non-directories, so for
-                   directories don't set entry inodes */
-                if (IA_ISDIR(entry->d_stat.ia_type)) {
-                        entry->d_stat.ia_blocks = DHT_DIR_STAT_BLOCKS;
-                        entry->d_stat.ia_size = DHT_DIR_STAT_SIZE;
-                        if (orig_entry->inode) {
-                                dht_inode_ctx_time_update (orig_entry->inode,
-                                                           this, &entry->d_stat,
-                                                           1);
-                        }
-                } else {
-                        if (orig_entry->inode) {
-                                ret = dht_layout_preset (this, prev,
-                                                         orig_entry->inode);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                                DHT_MSG_LAYOUT_SET_FAILED,
-                                                "failed to link the layout "
-                                                "in inode");
-
-                                entry->inode = inode_ref (orig_entry->inode);
-                        } else if (itable) {
-                                /*
-                                 * orig_entry->inode might be null if any upper
-                                 * layer xlators below client set to null, to
-                                 * force a lookup on the inode even if the inode
-                                 * is present in the inode table. In that case
-                                 * we just update the ctx to make sure we didn't
-                                 * missed anything.
-                                 */
-                                inode = inode_find (itable,
-                                                    orig_entry->d_stat.ia_gfid);
-                                if (inode) {
-                                        ret = dht_layout_preset
-                                                            (this, prev,
-                                                             inode);
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                     GF_LOG_WARNING, 0,
-                                                     DHT_MSG_LAYOUT_SET_FAILED,
-                                                     "failed to link the layout"
-                                                     " in inode");
-                                        inode_unref (inode);
-                                        inode = NULL;
-                                }
-                        }
+                if (conf->subvolume_cnt == 1) {
+                    dht_populate_inode_for_dentry(this, prev, entry,
+                                                  orig_entry);
                 }
+            }
+        } else {
+            if (orig_entry->dict &&
+                dict_get(orig_entry->dict, conf->link_xattr_name)) {
+                /* Strip out the S and T flags set by rebalance*/
+                DHT_STRIP_PHASE1_FLAGS(&entry->d_stat);
+            }
 
-                list_add_tail (&entry->list, &local->entries.list);
-                local->filled += gf_dirent_size (entry->d_name);
-                count++;
-                local->op_ret++;
+            if (orig_entry->inode) {
+                ret = dht_layout_preset(this, prev, orig_entry->inode);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_WARNING, 0,
+                           DHT_MSG_LAYOUT_SET_FAILED,
+                           "failed to link the layout "
+                           "in inode for %s",
+                           orig_entry->d_name);
+
+                entry->inode = inode_ref(orig_entry->inode);
+            } else if (itable) {
+                /*
+                 * orig_entry->inode might be null if any upper
+                 * layer xlators below client set to null, to
+                 * force a lookup on the inode even if the inode
+                 * is present in the inode table. In that case
+                 * we just update the ctx to make sure we didn't
+                 * missed anything.
+                 */
+                inode = inode_find(itable, orig_entry->d_stat.ia_gfid);
+                if (inode) {
+                    ret = dht_layout_preset(this, prev, inode);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_WARNING, 0,
+                               DHT_MSG_LAYOUT_SET_FAILED,
+                               "failed to link the layout"
+                               " in inode for %s",
+                               orig_entry->d_name);
+                    inode_unref(inode);
+                    inode = NULL;
+                }
+            }
         }
 
+        gf_msg_debug(this->name, 0, "%s: Adding entry = %s", prev->name,
+                     entry->d_name);
+
+        list_add_tail(&entry->list, &entries.list);
+        count++;
+    }
+
 done:
-        if ((count == 0) || (local && (local->filled < local->size))) {
-                if ((next_offset == 0) || (op_errno == ENOENT)) {
-                        next_offset = 0;
-                        next_subvol = dht_subvol_next (this, prev);
-                } else {
-                        next_subvol = prev;
-                }
 
-                if (!next_subvol) {
-                        goto unwind;
-                }
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     * Possible values:
+     * op_ret == 0 and op_errno != 0
+     *   if op_errno != ENOENT : Error.Unwind.
+     *   if op_errno == ENOENT : There are no more entries on this subvol.
+     *                           Move to the next one.
+     * op_ret > 0 and count == 0 :
+     *    The subvol returned entries to dht but all were stripped out.
+     *    For example, if they were linkto files or dirs where
+     *    hashed_subvol != prev. Try to get some entries by winding
+     *    to the next subvol. This can be dangerous if parallel readdir
+     *    is enabled as it grows the stack.
+     *
+     * op_ret > 0 and count > 0:
+     *   We found some entries. Unwind even if the buffer is not full.
+     *
+     */
+
+    op_ret = count;
+    if (count == 0) {
+        /* non-zero next_offset means that
+         * EOF is not yet hit on the current subvol
+         */
+        if ((next_offset == 0) || (op_errno == ENOENT)) {
+            next_offset = 0;
+            next_subvol = dht_subvol_next(this, prev);
+        } else {
+            next_subvol = prev;
+        }
 
-                if (conf->readdir_optimize == _gf_true) {
-                        if (next_subvol != local->first_up_subvol) {
-                                ret = dict_set_int32 (local->xattr,
-                                                      GF_READDIR_SKIP_DIRS, 1);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_DICT_SET_FAILED,
-                                                "Failed to set dictionary value"
-                                                ":key = %s",
-                                                GF_READDIR_SKIP_DIRS );
-                        } else {
-                                 dict_del (local->xattr,
-                                           GF_READDIR_SKIP_DIRS);
-                        }
-                }
+        if (!next_subvol) {
+            goto unwind;
+        }
 
-                STACK_WIND_COOKIE (frame, dht_readdirp_cbk, next_subvol,
-                                   next_subvol, next_subvol->fops->readdirp,
-                                   local->fd, local->size, next_offset,
-                                   local->xattr);
-                return 0;
+        if (conf->readdir_optimize == _gf_true) {
+            if (next_subvol != local->first_up_subvol) {
+                ret = dict_set_int32(local->xattr, GF_READDIR_SKIP_DIRS, 1);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary value"
+                           ":key = %s",
+                           GF_READDIR_SKIP_DIRS);
+            } else {
+                dict_del(local->xattr, GF_READDIR_SKIP_DIRS);
+            }
         }
 
+        STACK_WIND_COOKIE(frame, dht_readdirp_cbk, next_subvol, next_subvol,
+                          next_subvol->fops->readdirp, local->fd, local->size,
+                          next_offset, local->xattr);
+        return 0;
+    }
+
 unwind:
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         */
-        if ((local->op_ret >= 0) && (prev != dht_last_up_subvol (this)))
-                local->op_errno = 0;
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
+    if (op_ret < 0)
+        op_ret = 0;
 
+    if (prev != dht_last_up_subvol(this))
+        op_errno = 0;
 
-        DHT_STACK_UNWIND (readdirp, frame, local->op_ret, local->op_errno,
-                          &local->entries, NULL);
+    DHT_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &entries, NULL);
 
-        return 0;
+    gf_dirent_free(&entries);
+    return 0;
 }
 
-
-int
-dht_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, gf_dirent_t *orig_entries,
-                 dict_t *xdata)
+static int
+dht_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        gf_dirent_t  *orig_entry = NULL;
-        gf_dirent_t  *entry = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *next_subvol = NULL;
-        off_t         next_offset = 0;
-        int           count = 0;
-        dht_layout_t *layout = 0;
-        xlator_t     *subvol = 0;
-        dht_conf_t   *conf = NULL;
-        dht_methods_t *methods = NULL;
-
-        prev = cookie;
-        local = frame->local;
+    dht_local_t *local = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *next_subvol = NULL;
+    off_t next_offset = 0;
+    int count = 0;
+    dht_layout_t *layout = 0;
+    xlator_t *subvol = 0;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    gf_boolean_t skip_hashed_check = _gf_false;
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, done);
+    INIT_LIST_HEAD(&entries.list);
 
-        methods = &(conf->methods);
+    prev = cookie;
+    local = frame->local;
 
-        local->op_errno = op_errno;
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, done);
 
-        if (op_ret < 0) {
-                goto done;
-        }
+    methods = &(conf->methods);
 
-        if (local->op_ret < 0)
-                local->op_ret = 0;
+    if (op_ret <= 0)
+        goto done;
 
-        if (!local->layout)
-                local->layout = dht_layout_get (this, local->fd->inode);
+    if (!local->layout)
+        local->layout = dht_layout_get(this, local->fd->inode);
 
-        layout = local->layout;
+    layout = local->layout;
 
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                next_offset = orig_entry->d_off;
+    gf_msg_debug(this->name, 0, "Processing entries from %s", prev->name);
 
-                subvol = methods->layout_search (this, layout,
-                                                 orig_entry->d_name);
+    if (conf->subvolume_cnt == 1) {
+        /*return everything*/
+        skip_hashed_check = _gf_true;
+        count = op_ret;
+        goto done;
+    }
 
-                if (!subvol || (subvol == prev)) {
-                        entry = gf_dirent_for_name (orig_entry->d_name);
-                        if (!entry) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Memory allocation failed ");
-                                goto unwind;
-                        }
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        next_offset = orig_entry->d_off;
 
-                        entry->d_off  = orig_entry->d_off;
-                        entry->d_ino  = orig_entry->d_ino;
-                        entry->d_type = orig_entry->d_type;
-                        entry->d_len  = orig_entry->d_len;
+        gf_msg_debug(this->name, 0, "%s: entry = %s, type = %d", prev->name,
+                     orig_entry->d_name, orig_entry->d_type);
 
-                        list_add_tail (&entry->list, &local->entries.list);
-                        count++;
-                        local->filled += gf_dirent_size (entry->d_name);
-                        local->op_ret++;
-                }
-        }
+        subvol = methods->layout_search(this, layout, orig_entry->d_name);
 
-done:
-        if ((count == 0) || (local && (local->filled < local->size))) {
-                if ((op_ret <= 0) || (op_errno == ENOENT)) {
-                        next_subvol = dht_subvol_next (this, prev);
-                } else {
-                        next_subvol = prev;
-                }
-
-                if (!next_subvol) {
-                        goto unwind;
-                }
+        if (!subvol || (subvol == prev)) {
+            entry = gf_dirent_for_name(orig_entry->d_name);
+            if (!entry) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                       "Memory allocation failed ");
+                goto unwind;
+            }
 
-                STACK_WIND_COOKIE (frame, dht_readdir_cbk, next_subvol,
-                                   next_subvol, next_subvol->fops->readdir,
-                                   local->fd, local->size, next_offset, NULL);
-                return 0;
-        }
+            entry->d_off = orig_entry->d_off;
+            entry->d_ino = orig_entry->d_ino;
+            entry->d_type = orig_entry->d_type;
+            entry->d_len = orig_entry->d_len;
 
-unwind:
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         */
-        if ((local->op_ret >= 0) && (prev != dht_last_up_subvol (this)))
-                local->op_errno = 0;
+            gf_msg_debug(this->name, 0, "%s: Adding = entry %s", prev->name,
+                         entry->d_name);
 
+            list_add_tail(&entry->list, &entries.list);
+            count++;
+        }
+    }
+done:
+    op_ret = count;
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
+    if (count == 0) {
+        if ((next_offset == 0) || (op_errno == ENOENT)) {
+            next_offset = 0;
+            next_subvol = dht_subvol_next(this, prev);
+        } else {
+            next_subvol = prev;
+        }
 
-        DHT_STACK_UNWIND (readdir, frame, local->op_ret, local->op_errno,
-                          &local->entries, NULL);
+        if (!next_subvol) {
+            goto unwind;
+        }
 
+        STACK_WIND_COOKIE(frame, dht_readdir_cbk, next_subvol, next_subvol,
+                          next_subvol->fops->readdir, local->fd, local->size,
+                          next_offset, NULL);
         return 0;
-}
-
+    }
 
-int
-dht_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                off_t yoff, int whichop, dict_t *dict)
-{
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        xlator_t     *xvol = NULL;
-        int           ret = 0;
-        dht_conf_t   *conf = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, NULL, whichop);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->fd = fd_ref (fd);
-        local->size = size;
-        local->xattr_req = (dict)? dict_ref (dict) : NULL;
-        local->first_up_subvol = dht_first_up_subvol (this);
-        local->op_ret = -1;
+unwind:
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
 
-        dht_deitransform (this, yoff, &xvol);
+    if (prev != dht_last_up_subvol(this))
+        op_errno = 0;
 
-        /* TODO: do proper readdir */
-        if (whichop == GF_FOP_READDIRP) {
-                if (dict)
-                        local->xattr = dict_ref (dict);
-                else
-                        local->xattr = dict_new ();
+    if (!skip_hashed_check) {
+        DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, NULL);
+        gf_dirent_free(&entries);
 
-                if (local->xattr) {
-                        ret = dict_set_uint32 (local->xattr,
-                                               conf->link_xattr_name, 256);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set dictionary value"
-                                        " : key = %s",
-                                        conf->link_xattr_name);
+    } else {
+        DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, orig_entries, NULL);
+    }
+    return 0;
+}
 
-                        if (conf->readdir_optimize == _gf_true) {
-                                if (xvol != local->first_up_subvol) {
-                                        ret = dict_set_int32 (local->xattr,
-                                                       GF_READDIR_SKIP_DIRS, 1);
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                        GF_LOG_ERROR, 0,
-                                                        DHT_MSG_DICT_SET_FAILED,
-                                                        "Failed to set "
-                                                        "dictionary value: "
-                                                        "key = %s",
-                                                        GF_READDIR_SKIP_DIRS);
-                                } else {
-                                        dict_del (local->xattr,
-                                                  GF_READDIR_SKIP_DIRS);
-                                }
-                        }
+static int
+dht_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t yoff, int whichop, dict_t *dict)
+{
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    xlator_t *xvol = NULL;
+    int ret = 0;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, NULL, NULL, whichop);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->fd = fd_ref(fd);
+    local->size = size;
+    local->xattr_req = (dict) ? dict_ref(dict) : NULL;
+    local->first_up_subvol = dht_first_up_subvol(this);
+    local->op_ret = -1;
+
+    dht_deitransform(this, yoff, &xvol);
+
+    /* TODO: do proper readdir */
+    if (whichop == GF_FOP_READDIRP) {
+        if (dict)
+            local->xattr = dict_ref(dict);
+        else
+            local->xattr = dict_new();
+
+        if (local->xattr) {
+            ret = dict_set_uint32(local->xattr, conf->link_xattr_name, 256);
+            if (ret)
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set dictionary value"
+                       " : key = %s",
+                       conf->link_xattr_name);
+
+            if (conf->readdir_optimize == _gf_true) {
+                if (xvol != local->first_up_subvol) {
+                    ret = dict_set_int32(local->xattr, GF_READDIR_SKIP_DIRS, 1);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               DHT_MSG_DICT_SET_FAILED,
+                               "Failed to set "
+                               "dictionary value: "
+                               "key = %s",
+                               GF_READDIR_SKIP_DIRS);
+                } else {
+                    dict_del(local->xattr, GF_READDIR_SKIP_DIRS);
                 }
+            }
 
-                STACK_WIND_COOKIE (frame, dht_readdirp_cbk, xvol, xvol,
-                                   xvol->fops->readdirp, fd, size, yoff,
-                                   local->xattr);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_readdir_cbk, xvol, xvol,
-                                   xvol->fops->readdir, fd, size, yoff,
-                                   local->xattr);
+            if (conf->subvolume_cnt == 1) {
+                ret = dict_set_uint32(local->xattr, conf->xattr_name, 4 * 4);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
+                           DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary "
+                           "value:key = %s ",
+                           conf->xattr_name);
+                }
+            }
         }
 
-        return 0;
+        STACK_WIND_COOKIE(frame, dht_readdirp_cbk, xvol, xvol,
+                          xvol->fops->readdirp, fd, size, yoff, local->xattr);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_readdir_cbk, xvol, xvol,
+                          xvol->fops->readdir, fd, size, yoff, local->xattr);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t yoff, dict_t *xdata)
+dht_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t yoff, dict_t *xdata)
 {
-        int          op = GF_FOP_READDIR;
-        dht_conf_t  *conf = NULL;
-        int          i = 0;
+    int op = GF_FOP_READDIR;
+    dht_conf_t *conf = NULL;
+    int i = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->subvolume_status[i]) {
-                        op = GF_FOP_READDIRP;
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            op = GF_FOP_READDIRP;
+            break;
         }
+    }
 
-        if (conf->use_readdirp)
-                op = GF_FOP_READDIRP;
+    if (conf->use_readdirp)
+        op = GF_FOP_READDIRP;
 
 out:
-        dht_do_readdir (frame, this, fd, size, yoff, op, 0);
-        return 0;
+    dht_do_readdir(frame, this, fd, size, yoff, op, 0);
+    return 0;
 }
 
 int
-dht_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t yoff, dict_t *dict)
+dht_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t yoff, dict_t *dict)
 {
-        dht_do_readdir (frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
-        return 0;
+    dht_do_readdir(frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
+    return 0;
 }
 
-
-
-int
-dht_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, dict_t *xdata)
+static int
+dht_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1)
-                        local->op_errno = op_errno;
-
-                if (op_ret == 0)
-                        local->op_ret = 0;
-        }
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (fsyncdir, frame, local->op_ret,
-                                  local->op_errno, xdata);
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1)
+            local->op_errno = op_errno;
+        else if (op_ret == 0)
+            local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
+                         xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              int datasync, dict_t *xdata)
+dht_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
+             dict_t *xdata)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        conf = this->private;
+    conf = this->private;
 
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_FSYNCDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_FSYNCDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->fd = fd_ref (fd);
-        local->call_cnt = conf->subvolume_cnt;
+    local->fd = fd_ref(fd);
+    local->call_cnt = conf->subvolume_cnt;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND (frame, dht_fsyncdir_cbk,
-                            conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->fsyncdir,
-                            fd, datasync, xdata);
-        }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND(frame, dht_fsyncdir_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->fsyncdir, fd, datasync, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsyncdir, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_newfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno,
-                 inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+dht_newfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, inode_t *inode, struct iatt *stbuf,
+                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        dht_local_t  *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
+    if (op_ret == -1)
+        goto out;
 
-        if (op_ret == -1)
-                goto out;
-
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        prev = cookie;
-
-        if (local->loc.parent) {
-
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
-
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret < 0) {
-                gf_msg_debug (this->name, EINVAL,
-                              "could not set pre-set layout for subvolume %s",
-                              prev? prev->name: NULL);
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-        if (local->linked == _gf_true)
-                dht_linkfile_attr_heal (frame, this);
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    prev = cookie;
+
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret < 0) {
+        gf_msg_debug(this->name, EINVAL,
+                     "could not set pre-set layout for subvolume %s",
+                     prev ? prev->name : NULL);
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+    if (local->linked == _gf_true)
+        dht_linkfile_attr_heal(frame, this);
 out:
-        /*
-         * FIXME: ia_size and st_blocks of preparent and postparent do not have
-         * correct values. since, preparent and postparent buffers correspond
-         * to a directory these two members should have values equal to sum of
-         * corresponding values from each of the subvolume.
-         * See dht_iatt_merge for reference.
-         */
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        dht_set_fixed_dir_stat (preparent);
-
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                /* store op_errno for failure case*/
-                local->op_errno = op_errno;
-                local->refresh_layout_unlock (frame, this, op_ret, 1);
+    /*
+     * FIXME: ia_size and st_blocks of preparent and postparent do not have
+     * correct values. since, preparent and postparent buffers correspond
+     * to a directory these two members should have values equal to sum of
+     * corresponding values from each of the subvolume.
+     * See dht_iatt_merge for reference.
+     */
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    dht_set_fixed_dir_stat(preparent);
+
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        /* store op_errno for failure case*/
+        local->op_errno = op_errno;
+        local->refresh_layout_unlock(frame, this, op_ret, 1);
 
-                if (op_ret == 0) {
-                        DHT_STACK_UNWIND (mknod, frame, op_ret, op_errno,
-                                          inode, stbuf, preparent, postparent,
-                                          xdata);
-                }
-        } else {
-                DHT_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode,
-                                  stbuf, preparent, postparent, xdata);
+        if (op_ret == 0) {
+            DHT_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, stbuf,
+                             preparent, postparent, xdata);
         }
+    } else {
+        DHT_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, stbuf,
+                         preparent, postparent, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
-int
-dht_mknod_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this,
-                               int32_t op_ret, int32_t op_errno,
-                               inode_t *inode, struct iatt *stbuf,
-                               struct iatt *preparent, struct iatt *postparent,
-                               dict_t *xdata)
+static int
+dht_mknod_linkfile_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno, inode_t *inode,
+                              struct iatt *stbuf, struct iatt *preparent,
+                              struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *cached_subvol  = NULL;
-        dht_conf_t      *conf           = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local || !local->cached_subvol) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (!local || !local->cached_subvol) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        conf = this->private;
-        if (!conf) {
-                local->op_errno =  EINVAL;
-                op_errno = EINVAL;
-                goto err;
-        }
+    conf = this->private;
+    if (!conf) {
+        local->op_errno = EINVAL;
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
+    cached_subvol = local->cached_subvol;
 
-        if (local->params) {
-                 dict_del (local->params, conf->link_xattr_name);
-                 dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
+    if (local->params) {
+        dict_del(local->params, conf->link_xattr_name);
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)cached_subvol,
-                           cached_subvol, cached_subvol->fops->mknod,
-                           &local->loc, local->mode, local->rdev, local->umask,
-                           local->params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)cached_subvol,
+                      cached_subvol, cached_subvol->fops->mknod, &local->loc,
+                      local->mode, local->rdev, local->umask, local->params);
 
-        return 0;
+    return 0;
 err:
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        } else {
-                DHT_STACK_UNWIND (mknod, frame, -1,
-                                  op_errno, NULL, NULL, NULL,
-                                  NULL, NULL);
-        }
-        return 0;
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    } else {
+        DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                         NULL);
+    }
+    return 0;
 }
 
-int
-dht_mknod_wind_to_avail_subvol (call_frame_t *frame, xlator_t *this,
-                                 xlator_t *subvol, loc_t *loc, dev_t rdev,
-                                 mode_t mode, mode_t umask, dict_t *params)
+static int
+dht_mknod_wind_to_avail_subvol(call_frame_t *frame, xlator_t *this,
+                               xlator_t *subvol, loc_t *loc, dev_t rdev,
+                               mode_t mode, mode_t umask, dict_t *params)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *avail_subvol   = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *avail_subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!dht_is_subvol_filled (this, subvol)) {
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path,
-                              subvol->name);
+    if (!dht_is_subvol_filled(this, subvol)) {
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol,
-                                   subvol, subvol->fops->mknod, loc, mode,
-                                   rdev, umask, params);
-        } else {
-                avail_subvol = dht_free_disk_available_subvol (this, subvol, local);
+        STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                          subvol->fops->mknod, loc, mode, rdev, umask, params);
+    } else {
+        avail_subvol = dht_free_disk_available_subvol(this, subvol, local);
 
-                if (avail_subvol != subvol) {
-                        local->params = dict_ref (params);
-                        local->rdev = rdev;
-                        local->mode = mode;
-                        local->umask = umask;
-                        local->cached_subvol = avail_subvol;
-                        local->hashed_subvol = subvol;
+        if (avail_subvol != subvol) {
+            local->params = dict_ref(params);
+            local->rdev = rdev;
+            local->mode = mode;
+            local->umask = umask;
+            local->cached_subvol = avail_subvol;
+            local->hashed_subvol = subvol;
 
-                        gf_msg_debug (this->name, 0,
-                                      "creating %s on %s (link at %s)", loc->path,
-                                      avail_subvol->name, subvol->name);
+            gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)",
+                         loc->path, avail_subvol->name, subvol->name);
 
-                        dht_linkfile_create (frame,
-                                             dht_mknod_linkfile_create_cbk,
-                                             this, avail_subvol, subvol, loc);
+            dht_linkfile_create(frame, dht_mknod_linkfile_create_cbk, this,
+                                avail_subvol, subvol, loc);
 
-                        goto out;
-                }
-
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path, subvol->name);
+            goto out;
+        }
 
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk,
-                                   (void *)subvol, subvol,
-                                   subvol->fops->mknod, loc, mode,
-                                   rdev, umask, params);
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-        }
+        STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                          subvol->fops->mknod, loc, mode, rdev, umask, params);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-int32_t
-dht_mknod_do (call_frame_t *frame)
+static int32_t
+dht_mknod_do(call_frame_t *frame)
 {
-        dht_local_t     *local          = NULL;
-        dht_layout_t    *refreshed      = NULL;
-        xlator_t        *subvol         = NULL;
-        xlator_t        *this           = NULL;
-        dht_conf_t      *conf           = NULL;
-        dht_methods_t   *methods        = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *refreshed = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        this = THIS;
+    this = THIS;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        /* We don't need parent_loc anymore */
-        loc_wipe (&local->loc);
+    /* We don't need parent_loc anymore */
+    loc_wipe(&local->loc);
 
-        loc_copy (&local->loc, &local->loc2);
+    loc_copy(&local->loc, &local->loc2);
 
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc2);
 
-        refreshed = local->selfheal.refreshed_layout;
+    refreshed = local->selfheal.refreshed_layout;
 
-        subvol = methods->layout_search (this, refreshed, local->loc.name);
+    subvol = methods->layout_search(this, refreshed, local->loc.name);
 
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED, "no subvolume in "
-                        "layout for path=%s", local->loc.path);
-                local->op_errno = ENOENT;
-                goto err;
-        }
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in "
+               "layout for path=%s",
+               local->loc.path);
+        local->op_errno = ENOENT;
+        goto err;
+    }
 
-        dht_mknod_wind_to_avail_subvol (frame, this, subvol, &local->loc,
-                                         local->rdev, local->mode,
-                                         local->umask, local->params);
-        return 0;
+    dht_mknod_wind_to_avail_subvol(frame, this, subvol, &local->loc,
+                                   local->rdev, local->mode, local->umask,
+                                   local->params);
+    return 0;
 err:
-        local->refresh_layout_unlock (frame, this, -1, 1);
+    local->refresh_layout_unlock(frame, this, -1, 1);
 
-        return 0;
+    return 0;
 }
 
-
-int32_t
-dht_mknod_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_mknod_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-int32_t
-dht_mknod_finish (call_frame_t *frame, xlator_t *this, int op_ret,
-                  int invoke_cbk)
+static int32_t
+dht_mknod_finish(call_frame_t *frame, xlator_t *this, int op_ret,
+                 int invoke_cbk)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
 
-        local = frame->local;
-        lock_count = dht_lock_count (local->lock[0].layout.parent_layout.locks,
-                                     local->lock[0].layout.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
+    local = frame->local;
+    lock_count = dht_lock_count(local->lock[0].layout.parent_layout.locks,
+                                local->lock[0].layout.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
 
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
 
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
 
-        lock_local->lock[0].layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
-        lock_local->lock[0].layout.parent_layout.lk_count = local->lock[0].layout.parent_layout.lk_count;
+    lock_local->lock[0]
+        .layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
+    lock_local->lock[0].layout.parent_layout.lk_count =
+        local->lock[0].layout.parent_layout.lk_count;
 
-        local->lock[0].layout.parent_layout.locks = NULL;
-        local->lock[0].layout.parent_layout.lk_count = 0;
+    local->lock[0].layout.parent_layout.locks = NULL;
+    local->lock[0].layout.parent_layout.lk_count = 0;
 
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].layout.parent_layout.locks,
-                            lock_local->lock[0].layout.parent_layout.lk_count,
-                            dht_mknod_unlock_cbk);
-        lock_frame = NULL;
+    dht_unlock_inodelk(lock_frame,
+                       lock_local->lock[0].layout.parent_layout.locks,
+                       lock_local->lock[0].layout.parent_layout.lk_count,
+                       dht_mknod_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        if (op_ret == 0)
-                return 0;
-
-        DHT_STACK_UNWIND (mknod, frame, op_ret, local->op_errno, NULL, NULL,
-                          NULL, NULL, NULL);
+    if (op_ret == 0)
         return 0;
+
+    DHT_STACK_UNWIND(mknod, frame, op_ret, local->op_errno, NULL, NULL, NULL,
+                     NULL, NULL);
+    return 0;
 }
 
-int32_t
-dht_mknod_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_mknod_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                gf_msg ("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
-                        "mknod lock failed for file: %s", local->loc2.name);
+    if (op_ret < 0) {
+        gf_msg("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+               "mknod lock failed for file: %s", local->loc2.name);
 
-                local->op_errno = op_errno;
+        local->op_errno = op_errno;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_mknod_finish;
+    local->refresh_layout_unlock = dht_mknod_finish;
 
-        local->refresh_layout_done = dht_mknod_do;
+    local->refresh_layout_done = dht_mknod_do;
 
-        dht_refresh_layout (frame);
+    dht_refresh_layout(frame);
 
-        return 0;
+    return 0;
 err:
-        dht_mknod_finish (frame, this, -1, 0);
-        return 0;
+    if (local)
+        dht_mknod_finish(frame, this, -1, 0);
+    else
+        DHT_STACK_UNWIND(mknod, frame, -1, EINVAL, NULL, NULL, NULL, NULL,
+                         NULL);
+    return 0;
 }
 
-int32_t
-dht_mknod_lock (call_frame_t *frame, xlator_t *subvol)
+static int32_t
+dht_mknod_lock(call_frame_t *frame, xlator_t *subvol)
 {
-        dht_local_t     *local          = NULL;
-        int              count  = 1,    ret = -1;
-        dht_lock_t     **lk_array       = NULL;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-        local = frame->local;
+    local = frame->local;
 
-        lk_array = GF_CALLOC (count, sizeof (*lk_array), gf_common_mt_pointer);
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
 
-        if (lk_array == NULL)
-                goto err;
+    if (lk_array == NULL)
+        goto err;
 
-        lk_array[0] = dht_lock_new (frame->this, subvol, &local->loc, F_RDLCK,
-                                    DHT_LAYOUT_HEAL_DOMAIN, NULL);
+    lk_array[0] = dht_lock_new(frame->this, subvol, &local->loc, F_RDLCK,
+                               DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                               IGNORE_ENOENT_ESTALE);
 
-        if (lk_array[0] == NULL)
-                goto err;
+    if (lk_array[0] == NULL)
+        goto err;
 
-        local->lock[0].layout.parent_layout.locks = lk_array;
-        local->lock[0].layout.parent_layout.lk_count = count;
+    local->lock[0].layout.parent_layout.locks = lk_array;
+    local->lock[0].layout.parent_layout.lk_count = count;
 
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    IGNORE_ENOENT_ESTALE, dht_mknod_lock_cbk);
+    ret = dht_blocking_inodelk(frame, lk_array, count, dht_mknod_lock_cbk);
 
-        if (ret < 0) {
-                local->lock[0].layout.parent_layout.locks = NULL;
-                local->lock[0].layout.parent_layout.lk_count = 0;
-                goto err;
-        }
+    if (ret < 0) {
+        local->lock[0].layout.parent_layout.locks = NULL;
+        local->lock[0].layout.parent_layout.lk_count = 0;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
-int
-dht_refresh_parent_layout_resume (call_frame_t *frame, xlator_t *this, int ret,
-                                  int invoke_cbk)
+static int
+dht_refresh_parent_layout_resume(call_frame_t *frame, xlator_t *this, int ret,
+                                 int invoke_cbk)
 {
-        dht_local_t  *local        = NULL, *parent_local = NULL;
-        call_stub_t  *stub         = NULL;
-        call_frame_t *parent_frame = NULL;
+    dht_local_t *local = NULL, *parent_local = NULL;
+    call_stub_t *stub = NULL;
+    call_frame_t *parent_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        stub = local->stub;
-        local->stub = NULL;
+    stub = local->stub;
+    local->stub = NULL;
 
-        parent_frame = stub->frame;
-        parent_local = parent_frame->local;
+    parent_frame = stub->frame;
+    parent_local = parent_frame->local;
 
-        if (ret < 0) {
-                parent_local->op_ret = -1;
-                parent_local->op_errno = local->op_errno
-                        ? local->op_errno : EIO;
-        } else {
-                parent_local->op_ret = 0;
-        }
+    if (ret < 0) {
+        parent_local->op_ret = -1;
+        parent_local->op_errno = local->op_errno ? local->op_errno : EIO;
+    } else {
+        parent_local->op_ret = 0;
+    }
 
-        call_resume (stub);
+    call_resume(stub);
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_refresh_parent_layout_done (call_frame_t *frame)
+static int
+dht_refresh_parent_layout_done(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        int          ret   = 0;
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->op_ret < 0) {
-                ret = -1;
-                goto resume;
-        }
+    if (local->op_ret < 0) {
+        ret = -1;
+        goto resume;
+    }
 
-        dht_layout_set (frame->this, local->loc.inode,
-                        local->selfheal.refreshed_layout);
+    dht_layout_set(frame->this, local->loc.inode,
+                   local->selfheal.refreshed_layout);
 
 resume:
-        dht_refresh_parent_layout_resume (frame, frame->this, ret, 1);
-        return 0;
+    dht_refresh_parent_layout_resume(frame, frame->this, ret, 1);
+    return 0;
 }
 
-
-int
-dht_handle_parent_layout_change (xlator_t *this, call_stub_t *stub)
+static int
+dht_handle_parent_layout_change(xlator_t *this, call_stub_t *stub)
 {
-        call_frame_t *refresh_frame = NULL, *frame = NULL;
-        dht_local_t  *refresh_local = NULL, *local = NULL;
+    call_frame_t *refresh_frame = NULL, *frame = NULL;
+    dht_local_t *refresh_local = NULL, *local = NULL;
 
-        frame = stub->frame;
-        local = frame->local;
+    frame = stub->frame;
+    local = frame->local;
 
-        refresh_frame = copy_frame (frame);
-        refresh_local = dht_local_init (refresh_frame, NULL, NULL,
-                                        stub->fop);
+    refresh_frame = copy_frame(frame);
+    if (!refresh_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "mem allocation failed for refresh_frame");
+        return -1;
+    }
 
-        refresh_local->loc.inode = inode_ref (local->loc.parent);
-        gf_uuid_copy (refresh_local->loc.gfid, local->loc.parent->gfid);
+    refresh_local = dht_local_init(refresh_frame, NULL, NULL, stub->fop);
+    if (!refresh_local) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "mem allocation failed for refresh_local");
+        return -1;
+    }
 
-        refresh_local->stub = stub;
+    refresh_local->loc.inode = inode_ref(local->loc.parent);
+    gf_uuid_copy(refresh_local->loc.gfid, local->loc.parent->gfid);
 
-        refresh_local->refresh_layout_unlock = dht_refresh_parent_layout_resume;
-        refresh_local->refresh_layout_done = dht_refresh_parent_layout_done;
+    refresh_local->stub = stub;
 
-        dht_refresh_layout (refresh_frame);
-        return 0;
+    refresh_local->refresh_layout_unlock = dht_refresh_parent_layout_resume;
+    refresh_local->refresh_layout_done = dht_refresh_parent_layout_done;
+
+    dht_refresh_layout(refresh_frame);
+    return 0;
 }
 
-int32_t
-dht_call_mkdir_stub (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_call_mkdir_stub(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        call_stub_t *stub  = NULL;
+    dht_local_t *local = NULL;
+    call_stub_t *stub = NULL;
 
-        local = frame->local;
-        stub = local->stub;
-        local->stub = NULL;
+    local = frame->local;
+    stub = local->stub;
+    local->stub = NULL;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-        } else {
-                local->op_ret = 0;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    } else {
+        local->op_ret = 0;
+    }
 
-        call_resume (stub);
+    call_resume(stub);
 
-        return 0;
+    return 0;
 }
 
-int32_t
-dht_guard_parent_layout_and_namespace (xlator_t *subvol, call_stub_t *stub)
+static int32_t
+dht_guard_parent_layout_and_namespace(xlator_t *subvol, call_stub_t *stub)
 {
-        dht_local_t   *local                  = NULL;
-        int            ret                    = -1;
-        loc_t         *loc                    = NULL;
-        xlator_t      *hashed_subvol          = NULL, *this = NULL;;
-        call_frame_t  *frame                  = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int32_t       *parent_disk_layout     = NULL;
-        dht_layout_t  *parent_layout          = NULL;
-        dht_conf_t    *conf                   = NULL;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    loc_t *loc = NULL;
+    xlator_t *hashed_subvol = NULL, *this = NULL;
+    ;
+    call_frame_t *frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t *parent_disk_layout = NULL;
+    dht_layout_t *parent_layout = NULL;
+    dht_conf_t *conf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", stub, err);
+    GF_VALIDATE_OR_GOTO("dht", stub, err);
 
-        frame = stub->frame;
-        this = frame->this;
+    frame = stub->frame;
+    this = frame->this;
 
-        conf = this->private;
+    conf = this->private;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->stub = stub;
+    local->stub = stub;
 
-        /* TODO: recheck whether we should lock on src or dst if we do similar
-         * stale layout checks for rename.
-         */
-        loc = &stub->args.loc;
+    /* TODO: recheck whether we should lock on src or dst if we do similar
+     * stale layout checks for rename.
+     */
+    loc = &stub->args.loc;
 
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
 
+    if (local->params == NULL) {
+        local->params = dict_new();
         if (local->params == NULL) {
-                local->params = dict_new ();
-                if (local->params == NULL) {
-                        local->op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                                DHT_MSG_PARENT_LAYOUT_CHANGED,
-                                "%s (%s/%s) (path: %s): "
-                                "dict allocation failed",
-                                gf_fop_list[stub->fop],
-                                pgfid, loc->name, loc->path);
-                        goto err;
-                }
-        }
-
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                local->op_errno = EINVAL;
-
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "hashed subvolume not found", gf_fop_list[stub->fop],
-                        pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        parent_layout = dht_layout_get (this, loc->parent);
-
-        ret = dht_disk_layout_extract_for_subvol (this, parent_layout,
-                                                  hashed_subvol,
-                                                  &parent_disk_layout);
-        if (ret == -1) {
-                local->op_errno = EINVAL;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "extracting in-memory layout of parent failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        memcpy ((void *)local->parent_disk_layout, (void *)parent_disk_layout,
-                sizeof (local->parent_disk_layout));
-
-        dht_layout_unref (this, parent_layout);
-        parent_layout = NULL;
-
-        ret = dict_set_str (local->params, GF_PREOP_PARENT_KEY,
-                            conf->xattr_name);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "setting %s key in params dictionary failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path,
-                        GF_PREOP_PARENT_KEY);
-                goto err;
-        }
-
-        ret = dict_set_bin (local->params, conf->xattr_name, parent_disk_layout,
-                            4 * 4);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "setting parent-layout in params dictionary failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        parent_disk_layout = NULL;
-        local->hashed_subvol = hashed_subvol;
-
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, loc, hashed_subvol,
-                                     &local->current->ns, dht_call_mkdir_stub);
-        if (ret < 0)
-                goto err;
-
-        return 0;
+            local->op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+                   DHT_MSG_PARENT_LAYOUT_CHANGED,
+                   "%s (%s/%s) (path: %s): "
+                   "dict allocation failed",
+                   gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+            goto err;
+        }
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        local->op_errno = EINVAL;
+
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "hashed subvolume not found",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_layout = dht_layout_get(this, loc->parent);
+
+    ret = dht_disk_layout_extract_for_subvol(this, parent_layout, hashed_subvol,
+                                             &parent_disk_layout);
+    if (ret == -1) {
+        local->op_errno = EINVAL;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "extracting in-memory layout of parent failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    memcpy((void *)local->parent_disk_layout, (void *)parent_disk_layout,
+           sizeof(local->parent_disk_layout));
+
+    dht_layout_unref(this, parent_layout);
+    parent_layout = NULL;
+
+    ret = dict_set_str(local->params, GF_PREOP_PARENT_KEY, conf->xattr_name);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting %s key in params dictionary failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path,
+               GF_PREOP_PARENT_KEY);
+        goto err;
+    }
+
+    ret = dict_set_bin(local->params, conf->xattr_name, parent_disk_layout,
+                       4 * 4);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting parent-layout in params dictionary failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_disk_layout = NULL;
+    local->hashed_subvol = hashed_subvol;
+
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, loc, hashed_subvol, &local->current->ns,
+                                dht_call_mkdir_stub);
+    if (ret < 0)
+        goto err;
+
+    return 0;
 err:
 
-        if (parent_disk_layout != NULL)
-                GF_FREE (parent_disk_layout);
+    if (parent_disk_layout != NULL)
+        GF_FREE(parent_disk_layout);
 
-        if (parent_layout != NULL)
-                dht_layout_unref (this, parent_layout);
+    if (parent_layout != NULL)
+        dht_layout_unref(this, parent_layout);
 
-        return -1;
+    return -1;
 }
 
 int
-dht_mknod (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, mode_t mode, dev_t rdev, mode_t umask, dict_t *params)
-{
-        xlator_t       *subvol     = NULL;
-        int             op_errno   = -1;
-        int             i          = 0;
-        int             ret        = 0;
-        dht_local_t    *local      = NULL;
-        dht_conf_t     *conf       = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKNOD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = EIO;
-                goto err;
-        }
-
-        /* Post remove-brick, the client layout may not be in sync with
-        * disk layout because of lack of lookup. Hence,a mknod call
-        * may fall on the decommissioned brick.  Hence, if the
-        * hashed_subvol is part of decommissioned bricks  list, do a
-        * lookup on parent dir. If a fix-layout is already done by the
-        * remove-brick process, the parent directory layout will be in
-        * sync with that of the disk. If fix-layout is still ending
-        * on the parent directory, we can let the file get created on
-        * the decommissioned brick which will be eventually migrated to
-        * non-decommissioned brick based on the new layout.
-        */
+dht_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t rdev, mode_t umask, dict_t *params)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int ret = 0;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKNOD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = EIO;
+        goto err;
+    }
+
+    /* Post remove-brick, the client layout may not be in sync with
+     * disk layout because of lack of lookup. Hence,a mknod call
+     * may fall on the decommissioned brick.  Hence, if the
+     * hashed_subvol is part of decommissioned bricks  list, do a
+     * lookup on parent dir. If a fix-layout is already done by the
+     * remove-brick process, the parent directory layout will be in
+     * sync with that of the disk. If fix-layout is still ending
+     * on the parent directory, we can let the file get created on
+     * the decommissioned brick which will be eventually migrated to
+     * non-decommissioned brick based on the new layout.
+     */
+
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == subvol) {
+                gf_msg_debug(this->name, 0,
+                             "hashed subvol:%s is "
+                             "part of decommission brick list for "
+                             "file: %s",
+                             subvol->name, loc->path);
+
+                /* dht_refresh_layout needs directory info in
+                 * local->loc. Hence, storing the parent_loc in
+                 * local->loc and storing the create context in
+                 * local->loc2. We will restore this information
+                 * in dht_creation do */
+
+                ret = loc_copy(&local->loc2, &local->loc);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                           "loc_copy failed %s", loc->path);
 
-        if (conf->decommission_subvols_cnt) {
-            for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i] &&
-                        conf->decommissioned_bricks[i] == subvol) {
-
-                        gf_msg_debug (this->name, 0, "hashed subvol:%s is "
-                                      "part of decommission brick list for "
-                                      "file: %s", subvol->name, loc->path);
-
-                        /* dht_refresh_layout needs directory info in
-                         * local->loc. Hence, storing the parent_loc in
-                         * local->loc and storing the create context in
-                         * local->loc2. We will restore this information
-                         * in dht_creation do */
-
-                        ret = loc_copy (&local->loc2, &local->loc);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "loc_copy failed %s", loc->path);
-
-                                goto err;
-                        }
+                    goto err;
+                }
 
-                        local->params = dict_ref (params);
-                        local->rdev = rdev;
-                        local->mode = mode;
-                        local->umask = umask;
+                local->params = dict_ref(params);
+                local->rdev = rdev;
+                local->mode = mode;
+                local->umask = umask;
 
-                        loc_wipe (&local->loc);
+                loc_wipe(&local->loc);
 
-                        ret = dht_build_parent_loc (this, &local->loc, loc,
-                                                                 &op_errno);
+                ret = dht_build_parent_loc(this, &local->loc, loc, &op_errno);
 
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_LOC_FAILED,
-                                        "parent loc build failed");
-                                goto err;
-                        }
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_LOC_FAILED,
+                           "parent loc build failed");
+                    goto err;
+                }
 
-                        ret = dht_mknod_lock (frame, subvol);
+                ret = dht_mknod_lock(frame, subvol);
 
-                        if (ret < 0) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INODE_LK_ERROR,
-                                        "locking parent failed");
-                                goto err;
-                        }
+                if (ret < 0) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+                           "locking parent failed");
+                    goto err;
+                }
 
-                        goto done;
-               }
+                goto done;
             }
         }
+    }
 
-        dht_mknod_wind_to_avail_subvol (frame, this, subvol, loc, rdev, mode,
-                                        umask, params);
+    dht_mknod_wind_to_avail_subvol(frame, this, subvol, loc, rdev, mode, umask,
+                                   params);
 
 done:
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (mknod, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_symlink (call_frame_t *frame, xlator_t *this,
-             const char *linkname, loc_t *loc, mode_t umask, dict_t *params)
+dht_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
+            loc_t *loc, mode_t umask, dict_t *params)
 {
-        xlator_t    *subvol = NULL;
-        int          op_errno = -1;
-        dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SYMLINK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SYMLINK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = EIO;
-                goto err;
-        }
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = EIO;
+        goto err;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol, subvol,
-                           subvol->fops->symlink, linkname, loc, umask,
-                           params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                      subvol->fops->symlink, linkname, loc, umask, params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (link, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-            dict_t *xdata)
+dht_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata)
 {
-        xlator_t    *cached_subvol = NULL;
-        int          op_errno = -1;
-        dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_UNLINK);
-        if (!local) {
-                op_errno = ENOMEM;
+    local = dht_local_init(frame, loc, NULL, GF_FOP_UNLINK);
+    if (!local) {
+        op_errno = ENOMEM;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    cached_subvol = local->cached_subvol;
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        local->flags = xflag;
-        STACK_WIND_COOKIE (frame, dht_unlink_cbk, cached_subvol, cached_subvol,
-                           cached_subvol->fops->unlink, loc, xflag, xdata);
+    local->flags = xflag;
+    STACK_WIND_COOKIE(frame, dht_unlink_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->unlink, loc, xflag, xdata);
 
-        return 0;
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno,
-              inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-              struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           ret = -1;
-        gf_boolean_t  stbuf_merged = _gf_false;
-        xlator_t     *subvol = NULL;
-        call_frame_t *cleanup_frame = NULL;
-        dht_local_t  *cleanup_local = NULL;
+static int
+dht_remove_stale_linkto_cbk(int ret, call_frame_t *sync_frame, void *data)
+{
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
+}
 
-        local = frame->local;
+static int
+dht_remove_stale_linkto(void *data)
+{
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    dict_t *xdata_in = NULL;
+    int ret = 0;
 
-        if (op_ret == -1) {
-                /* Remove the linkto if exists */
-                if (local->linked) {
-                        cleanup_frame = create_frame (this, this->ctx->pool);
-                        if (cleanup_frame) {
-                                cleanup_local = dht_local_init (cleanup_frame,
-                                                                &local->loc2,
-                                                                NULL, 0);
-                                if (!cleanup_local || !local->link_subvol) {
-                                        DHT_STACK_DESTROY (cleanup_frame);
-                                        goto out;
-                                }
-                                cleanup_local->link_subvol = local->link_subvol;
-                                FRAME_SU_DO (cleanup_frame, dht_local_t);
-                                ret = synctask_new (this->ctx->env,
-                                                    dht_remove_stale_linkto,
-                                                    dht_remove_stale_linkto_cbk,
-                                                    cleanup_frame,
-                                                    cleanup_frame);
-                        }
-                }
-                /* No continuation on DHT inode missing errors, as we should
-                 * then have a good stbuf that states P2 happened. We would
-                 * get inode missing if, the file completed migrated between
-                 * the lookup and the link call */
-                goto out;
-        }
+    GF_VALIDATE_OR_GOTO("dht", data, out);
 
-        /* Update parent on success, even if P1/2 checks are positve.
-         * The second call on success will further update the parent */
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
-
-        /* Update linkto attrs, if this is the first call and non-P2,
-         * if we detect P2 then we need to trust the attrs from the
-         * second call, not the first */
-        if (local->linked == _gf_true &&
-            ((local->call_cnt == 1 && !IS_DHT_MIGRATION_PHASE2 (stbuf))
-             || (local->call_cnt != 1 &&
-                 IS_DHT_MIGRATION_PHASE2 (&local->stbuf)))) {
-                dht_iatt_merge (this, &local->stbuf, stbuf, NULL);
-                stbuf_merged = _gf_true;
-                dht_linkfile_attr_heal (frame, this);
-        }
-
-        /* No further P1/2 checks if we are in the second iteration of
-         * the call */
-        if (local->call_cnt != 1) {
-                goto out;
-        } else {
-                /* Preserve the return values, in case the migration decides
-                 * to recreate the link on the same subvol that the current
-                 * hased for the link was created on. */
-                dht_iatt_merge (this, &local->preparent,
-                                preparent, NULL);
-                dht_iatt_merge (this, &local->postparent,
-                                postparent, NULL);
-                if (!stbuf_merged) {
-                        dht_iatt_merge (this, &local->stbuf,
-                                        stbuf, NULL);
-                        stbuf_merged = _gf_true;
-                }
+    frame = data;
+    local = frame->local;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    GF_VALIDATE_OR_GOTO("dht", local->link_subvol, out);
 
-                local->inode = inode_ref (inode);
-        }
+    xdata_in = dict_new();
+    if (!xdata_in)
+        goto out;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
-        local->rebalance.target_op_fn = dht_link2;
-        dht_set_local_rebalance (this, local, stbuf, preparent,
-                                 postparent, xdata);
-
-        /* Check if the rebalance phase2 is true */
-        if (IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_inode_ctx_get_mig_info (this, local->loc.inode, NULL,
-                                                  &subvol);
-                if (!subvol) {
-                        /* Phase 2 of migration */
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        dht_link2 (this, subvol, frame, 0);
-                        return 0;
-                }
-        }
+    ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(xdata_in);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, 0,
+               "Failed to set keys for stale linkto"
+               "deletion on path %s",
+               local->loc.path);
+        goto out;
+    }
+
+    ret = syncop_unlink(local->link_subvol, &local->loc, xdata_in, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, 0,
+               "Removal of linkto failed"
+               " on path %s at subvol %s",
+               local->loc.path, local->link_subvol->name);
+    }
+out:
+    if (xdata_in)
+        dict_unref(xdata_in);
+    return ret;
+}
 
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                ret = dht_inode_ctx_get_mig_info (this, local->loc.inode, NULL,
-                                                  &subvol);
-                if (subvol) {
-                        dht_link2 (this, subvol, frame, 0);
-                        return 0;
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+static int
+dht_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, inode_t *inode, struct iatt *stbuf,
+             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int ret = -1;
+    gf_boolean_t stbuf_merged = _gf_false;
+    xlator_t *subvol = NULL;
+    call_frame_t *cleanup_frame = NULL;
+    dht_local_t *cleanup_local = NULL;
+
+    local = frame->local;
+
+    if (op_ret == -1) {
+        /* Remove the linkto if exists */
+        if (local->linked) {
+            cleanup_frame = create_frame(this, this->ctx->pool);
+            if (cleanup_frame) {
+                cleanup_local = dht_local_init(cleanup_frame, &local->loc2,
+                                               NULL, 0);
+                if (!cleanup_local || !local->link_subvol) {
+                    DHT_STACK_DESTROY(cleanup_frame);
+                    goto out;
+                }
+                cleanup_local->link_subvol = local->link_subvol;
+                FRAME_SU_DO(cleanup_frame, dht_local_t);
+                ret = synctask_new(this->ctx->env, dht_remove_stale_linkto,
+                                   dht_remove_stale_linkto_cbk, cleanup_frame,
+                                   cleanup_frame);
+            }
         }
+        /* No continuation on DHT inode missing errors, as we should
+         * then have a good stbuf that states P2 happened. We would
+         * get inode missing if, the file completed migrated between
+         * the lookup and the link call */
+        goto out;
+    }
+
+    /* Update parent on success, even if P1/2 checks are positive.
+     * The second call on success will further update the parent */
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    /* Update linkto attrs, if this is the first call and non-P2,
+     * if we detect P2 then we need to trust the attrs from the
+     * second call, not the first */
+    if (local->linked == _gf_true &&
+        ((local->call_cnt == 1 && !IS_DHT_MIGRATION_PHASE2(stbuf)) ||
+         (local->call_cnt != 1 && IS_DHT_MIGRATION_PHASE2(&local->stbuf)))) {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        stbuf_merged = _gf_true;
+        dht_linkfile_attr_heal(frame, this);
+    }
+
+    /* No further P1/2 checks if we are in the second iteration of
+     * the call */
+    if (local->call_cnt != 1) {
+        goto out;
+    } else {
+        /* Preserve the return values, in case the migration decides
+         * to recreate the link on the same subvol that the current
+         * hased for the link was created on. */
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+        if (!stbuf_merged) {
+            dht_iatt_merge(this, &local->stbuf, stbuf);
+            stbuf_merged = _gf_true;
+        }
+
+        local->inode = inode_ref(inode);
+    }
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    local->rebalance.target_op_fn = dht_link2;
+    dht_set_local_rebalance(this, local, stbuf, preparent, postparent, xdata);
+
+    /* Check if the rebalance phase2 is true */
+    if (IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_inode_ctx_get_mig_info(this, local->loc.inode, NULL, &subvol);
+        if (!subvol) {
+            /* Phase 2 of migration */
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            dht_link2(this, subvol, frame, 0);
+            return 0;
+        }
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        ret = dht_inode_ctx_get_mig_info(this, local->loc.inode, NULL, &subvol);
+        if (subvol) {
+            dht_link2(this, subvol, frame, 0);
+            return 0;
+        }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno, inode, stbuf,
-                          preparent, postparent, NULL);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_link2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_link2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local  = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        local = frame->local;
-        if (!local)
-                goto err;
+    local = frame->local;
+    if (!local)
+        goto err;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                dht_set_fixed_dir_stat (&local->preparent);
-                dht_set_fixed_dir_stat (&local->postparent);
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        dht_set_fixed_dir_stat(&local->preparent);
+        dht_set_fixed_dir_stat(&local->postparent);
 
-                DHT_STACK_UNWIND (link, frame, local->op_ret, op_errno,
-                                  local->inode,
-                                  &local->stbuf, &local->preparent,
-                                  &local->postparent, NULL);
-                return 0;
-        }
+        DHT_STACK_UNWIND(link, frame, local->op_ret, op_errno, local->inode,
+                         &local->stbuf, &local->preparent, &local->postparent,
+                         NULL);
+        return 0;
+    }
 
-        if (subvol == NULL) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (subvol == NULL) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        /* Second call to create link file could result in EEXIST as the
-         * first call created the linkto in the currently
-         * migrating subvol, which could be the new hashed subvol */
-        if (local->link_subvol == subvol) {
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->preparent);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (link, frame, 0, 0, local->inode,
-                                  &local->stbuf, &local->preparent,
-                                  &local->postparent, NULL);
+    /* Second call to create link file could result in EEXIST as the
+     * first call created the linkto in the currently
+     * migrating subvol, which could be the new hashed subvol */
+    if (local->link_subvol == subvol) {
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->preparent);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(link, frame, 0, 0, local->inode, &local->stbuf,
+                         &local->preparent, &local->postparent, NULL);
 
-                return 0;
-        }
+        return 0;
+    }
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND (frame, dht_link_cbk, subvol, subvol->fops->link,
-                    &local->loc, &local->loc2, local->xattr_req);
+    STACK_WIND(frame, dht_link_cbk, subvol, subvol->fops->link, &local->loc,
+               &local->loc2, local->xattr_req);
 
-        return 0;
+    return 0;
 err:
-        DHT_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_link_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       inode_t *inode, struct iatt *stbuf,
-                       struct iatt *preparent, struct iatt *postparent,
-                       dict_t *xdata)
+static int
+dht_link_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *stbuf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *srcvol = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *srcvol = NULL;
 
-        if (op_ret == -1)
-                goto err;
+    if (op_ret == -1)
+        goto err;
 
-        local = frame->local;
-        srcvol = local->linkfile.srcvol;
+    local = frame->local;
+    srcvol = local->linkfile.srcvol;
 
-        STACK_WIND (frame, dht_link_cbk, srcvol, srcvol->fops->link,
-                    &local->loc, &local->loc2, local->xattr_req);
+    STACK_WIND(frame, dht_link_cbk, srcvol, srcvol->fops->link, &local->loc,
+               &local->loc2, local->xattr_req);
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno, inode, stbuf, preparent,
-                          postparent, xdata);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_link (call_frame_t *frame, xlator_t *this,
-          loc_t *oldloc, loc_t *newloc, dict_t *xdata)
-{
-        xlator_t    *cached_subvol = NULL;
-        xlator_t    *hashed_subvol = NULL;
-        int          op_errno = -1;
-        int          ret = -1;
-        dht_local_t *local = NULL;
+dht_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata)
+{
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    int op_errno = -1;
+    int ret = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    local = dht_local_init(frame, oldloc, NULL, GF_FOP_LINK);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+    local->call_cnt = 1;
+
+    cached_subvol = local->cached_subvol;
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     oldloc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, newloc);
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     newloc->path);
+        op_errno = EIO;
+        goto err;
+    }
+
+    ret = loc_copy(&local->loc2, newloc);
+    if (ret == -1) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (hashed_subvol != cached_subvol) {
+        gf_uuid_copy(local->gfid, oldloc->inode->gfid);
+        dht_linkfile_create(frame, dht_link_linkfile_cbk, this, cached_subvol,
+                            hashed_subvol, newloc);
+    } else {
+        STACK_WIND(frame, dht_link_cbk, cached_subvol,
+                   cached_subvol->fops->link, oldloc, newloc, xdata);
+    }
+
+    return 0;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (newloc, err);
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        local = dht_local_init (frame, oldloc, NULL, GF_FOP_LINK);
-        if (!local) {
-                op_errno = ENOMEM;
+    return 0;
+}
 
-                goto err;
-        }
-        local->call_cnt = 1;
+int
+dht_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
+               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    xlator_t *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    gf_boolean_t parent_layout_changed = _gf_false;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    xlator_t *subvol = NULL;
 
-        cached_subvol = local->cached_subvol;
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", oldloc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
+    local = frame->local;
 
-        hashed_subvol = dht_subvol_get_hashed (this, newloc);
-        if (!hashed_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              newloc->path);
-                op_errno = EIO;
-                goto err;
-        }
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        ret = loc_copy (&local->loc2, newloc);
-        if (ret == -1) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        parent_layout_changed = (xdata &&
+                                 dict_get(xdata, GF_PREOP_CHECK_FAILED))
+                                    ? _gf_true
+                                    : _gf_false;
+
+        if (parent_layout_changed) {
+            if (local && local->lock[0].layout.parent_layout.locks) {
+                /* Returning failure as the layout could not be fixed even under
+                 * the lock */
+                goto out;
+            }
 
-        if (hashed_subvol != cached_subvol) {
-                gf_uuid_copy (local->gfid, oldloc->inode->gfid);
-                dht_linkfile_create (frame, dht_link_linkfile_cbk, this,
-                                     cached_subvol, hashed_subvol, newloc);
-        } else {
-                STACK_WIND (frame, dht_link_cbk,
-                            cached_subvol, cached_subvol->fops->link,
-                            oldloc, newloc, xdata);
-        }
+            gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_PARENT_LAYOUT_CHANGED,
+                   "create (%s/%s) (path: %s): parent layout "
+                   "changed. Attempting a layout refresh and then a "
+                   "retry",
+                   pgfid, local->loc.name, local->loc.path);
 
-        return 0;
+            /*
+              dht_refresh_layout needs directory info in local->loc.Hence,
+              storing the parent_loc in local->loc and storing the create
+              context in local->loc2. We will restore this information in
+              dht_creation_do.
+             */
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+            loc_wipe(&local->loc2);
 
-        return 0;
-}
+            ret = loc_copy(&local->loc2, &local->loc);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                       "loc_copy failed %s", local->loc.path);
 
+                goto out;
+            }
 
-int
-dht_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno,
-                fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        dht_local_t  *local = NULL;
+            loc_wipe(&local->loc);
 
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+            ret = dht_build_parent_loc(this, &local->loc, &local->loc2,
+                                       &op_errno);
 
-        if (op_ret == -1)
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_LOC_FAILED,
+                       "parent loc build failed");
                 goto out;
+            }
 
-        prev = cookie;
+            subvol = dht_subvol_get_hashed(this, &local->loc2);
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
-
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+            ret = dht_create_lock(frame, subvol);
+            if (ret < 0) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+                       "locking parent failed");
+                goto out;
+            }
 
-        ret = dht_fd_ctx_set (this, fd, prev);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0, "Possible fd leak. "
-                              "Could not set fd ctx for subvol %s",
-                              prev->name);
+            return 0;
         }
 
+        goto out;
+    }
+
+    prev = cookie;
+
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
+
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    ret = dht_fd_ctx_set(this, fd, prev);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0,
+                     "Possible fd leak. "
+                     "Could not set fd ctx for subvol %s",
+                     prev->name);
+    }
+
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0, "could not set preset layout for subvol %s",
+                     prev->name);
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0,
-                              "could not set preset layout for subvol %s",
-                              prev->name);
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (local->linked == _gf_true) {
-                local->stbuf = *stbuf;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    if (local->linked == _gf_true) {
+        local->stbuf = *stbuf;
+        dht_linkfile_attr_heal(frame, this);
+    }
 out:
 
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
 
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                /* store op_errno for failure case*/
-                local->op_errno = op_errno;
-                local->refresh_layout_unlock (frame, this, op_ret, 1);
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        /* store op_errno for failure case*/
+        local->op_errno = op_errno;
+        local->refresh_layout_unlock(frame, this, op_ret, 1);
 
-                if (op_ret == 0) {
-                        DHT_STACK_UNWIND (create, frame, op_ret, op_errno, fd,
-                                          inode, stbuf, preparent, postparent,
-                                          xdata);
-                }
-        } else {
-                DHT_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode,
-                                  stbuf, preparent, postparent, xdata);
+        if (op_ret == 0) {
+            DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
+                             preparent, postparent, xdata);
         }
-        return 0;
+    } else {
+        DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
+                         preparent, postparent, xdata);
+    }
+    return 0;
 }
 
-int
-dht_create_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this,
-                                int32_t op_ret, int32_t op_errno,
-                                inode_t *inode, struct iatt *stbuf,
-                                struct iatt *preparent, struct iatt *postparent,
-                                dict_t *xdata)
+static int
+dht_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               inode_t *inode, struct iatt *stbuf,
+                               struct iatt *preparent, struct iatt *postparent,
+                               dict_t *xdata)
 {
-        dht_local_t     *local             = NULL;
-        xlator_t        *cached_subvol     = NULL;
-        dht_conf_t      *conf              = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
 
-        local = frame->local;
-        if (!local) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        conf = this->private;
-        if (!conf) {
-                local->op_errno = EINVAL;
-                op_errno = EINVAL;
-                goto err;
-        }
+    conf = this->private;
+    if (!conf) {
+        local->op_errno = EINVAL;
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
+    cached_subvol = local->cached_subvol;
 
-        if (local->params) {
-                dict_del (local->params, conf->link_xattr_name);
-                dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
+    if (local->params) {
+        dict_del(local->params, conf->link_xattr_name);
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, cached_subvol,
-                           cached_subvol, cached_subvol->fops->create,
-                           &local->loc, local->flags, local->mode,
-                           local->umask, local->fd, local->params);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->create, &local->loc, local->flags,
+                      local->mode, local->umask, local->fd, local->params);
 
-        return 0;
+    return 0;
 err:
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        } else {
-                DHT_STACK_UNWIND (create, frame, -1,
-                                  op_errno, NULL, NULL, NULL,
-                                  NULL, NULL, NULL);
-        }
-        return 0;
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    } else {
+        DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                         NULL, NULL);
+    }
+    return 0;
 }
 
-int
-dht_create_wind_to_avail_subvol (call_frame_t *frame, xlator_t *this,
-                                 xlator_t *subvol, loc_t *loc, int32_t flags,
-                                 mode_t mode, mode_t umask, fd_t *fd,
-                                 dict_t *params)
+static int
+dht_create_wind_to_avail_subvol(call_frame_t *frame, xlator_t *this,
+                                xlator_t *subvol, loc_t *loc, int32_t flags,
+                                mode_t mode, mode_t umask, fd_t *fd,
+                                dict_t *params)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *avail_subvol   = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *avail_subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!dht_is_subvol_filled (this, subvol)) {
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path,
-                              subvol->name);
+    if (!dht_is_subvol_filled(this, subvol)) {
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create,
-                                   loc, flags, mode, umask, fd, params);
+        dht_set_parent_layout_in_dict(loc, this, local);
 
-        } else {
-                avail_subvol = dht_free_disk_available_subvol (this, subvol, local);
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, loc, flags, mode, umask, fd,
+                          params);
 
-                if (avail_subvol != subvol) {
-                        local->params = dict_ref (params);
-                        local->flags = flags;
-                        local->mode = mode;
-                        local->umask = umask;
-                        local->cached_subvol = avail_subvol;
-                        local->hashed_subvol = subvol;
+    } else {
+        avail_subvol = dht_free_disk_available_subvol(this, subvol, local);
 
-                        gf_msg_debug (this->name, 0,
-                                      "creating %s on %s (link at %s)", loc->path,
-                                      avail_subvol->name, subvol->name);
+        if (avail_subvol != subvol) {
+            local->cached_subvol = avail_subvol;
+            local->hashed_subvol = subvol;
 
-                        dht_linkfile_create (frame, dht_create_linkfile_create_cbk,
-                                             this, avail_subvol, subvol, loc);
+            gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)",
+                         loc->path, avail_subvol->name, subvol->name);
 
-                        goto out;
-                }
+            dht_linkfile_create(frame, dht_create_linkfile_create_cbk, this,
+                                avail_subvol, subvol, loc);
 
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path, subvol->name);
-
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create,
-                                   loc, flags, mode, umask, fd, params);
+            goto out;
         }
+
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
+
+        dht_set_parent_layout_in_dict(loc, this, local);
+
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, loc, flags, mode, umask, fd,
+                          params);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_build_parent_loc (xlator_t *this, loc_t *parent, loc_t *child,
-                                                 int32_t *op_errno)
+dht_build_parent_loc(xlator_t *this, loc_t *parent, loc_t *child,
+                     int32_t *op_errno)
 {
-        inode_table_t   *table = NULL;
-        int     ret = -1;
+    inode_table_t *table = NULL;
+    int ret = -1;
 
-        if (!parent || !child) {
-                if (op_errno)
-                        *op_errno = EINVAL;
-                goto out;
-        }
+    if (!parent || !child) {
+        if (op_errno)
+            *op_errno = EINVAL;
+        goto out;
+    }
 
-        if (child->parent) {
-                parent->inode = inode_ref (child->parent);
-                if (!parent->inode) {
-                        if (op_errno)
-                                *op_errno = EINVAL;
-                        goto out;
-                }
+    if (child->parent) {
+        parent->inode = inode_ref(child->parent);
+        if (!parent->inode) {
+            if (op_errno)
+                *op_errno = EINVAL;
+            goto out;
+        }
 
-                gf_uuid_copy (parent->gfid, child->pargfid);
+        gf_uuid_copy(parent->gfid, child->pargfid);
 
-                ret = 0;
+        ret = 0;
 
-                goto out;
-        } else {
-                if (gf_uuid_is_null (child->pargfid)) {
-                        if (op_errno)
-                                *op_errno = EINVAL;
-                        goto out;
-                }
+        goto out;
+    } else {
+        if (gf_uuid_is_null(child->pargfid)) {
+            if (op_errno)
+                *op_errno = EINVAL;
+            goto out;
+        }
 
-                table = this->itable;
+        table = this->itable;
 
-                if (!table) {
-                        if (op_errno) {
-                                *op_errno = EINVAL;
-                                goto out;
-                        }
-                }
+        if (!table) {
+            if (op_errno) {
+                *op_errno = EINVAL;
+                goto out;
+            }
+        }
 
-                parent->inode = inode_find (table, child->pargfid);
+        parent->inode = inode_find(table, child->pargfid);
 
-                if (!parent->inode) {
-                         if (op_errno) {
-                                *op_errno = EINVAL;
-                                goto out;
-                        }
-                }
+        if (!parent->inode) {
+            if (op_errno) {
+                *op_errno = EINVAL;
+                goto out;
+            }
+        }
 
-                gf_uuid_copy (parent->gfid, child->pargfid);
+        gf_uuid_copy(parent->gfid, child->pargfid);
 
-                ret = 0;
-        }
+        ret = 0;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
-int32_t
-dht_create_do (call_frame_t *frame)
+static int32_t
+dht_create_do(call_frame_t *frame)
 {
-        dht_local_t     *local          = NULL;
-        dht_layout_t    *refreshed      = NULL;
-        xlator_t        *subvol         = NULL;
-        xlator_t        *this           = NULL;
-        dht_conf_t      *conf           = NULL;
-        dht_methods_t   *methods        = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *refreshed = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        this = THIS;
+    this = THIS;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        /* We don't need parent_loc anymore */
-        loc_wipe (&local->loc);
+    /* We don't need parent_loc anymore */
+    loc_wipe(&local->loc);
 
-        loc_copy (&local->loc, &local->loc2);
+    loc_copy(&local->loc, &local->loc2);
 
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc2);
 
-        refreshed = local->selfheal.refreshed_layout;
+    refreshed = local->selfheal.refreshed_layout;
 
-        subvol = methods->layout_search (this, refreshed, local->loc.name);
+    subvol = methods->layout_search(this, refreshed, local->loc.name);
 
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED, "no subvolume in "
-                        "layout for path=%s", local->loc.path);
-                local->op_errno = ENOENT;
-                goto err;
-        }
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in "
+               "layout for path=%s",
+               local->loc.path);
+        local->op_errno = ENOENT;
+        goto err;
+    }
 
-        dht_create_wind_to_avail_subvol (frame, this, subvol, &local->loc,
-                                         local->flags, local->mode,
-                                         local->umask, local->fd, local->params);
-        return 0;
+    dht_create_wind_to_avail_subvol(frame, this, subvol, &local->loc,
+                                    local->flags, local->mode, local->umask,
+                                    local->fd, local->params);
+    return 0;
 err:
-        local->refresh_layout_unlock (frame, this, -1, 1);
+    local->refresh_layout_unlock(frame, this, -1, 1);
 
-        return 0;
+    return 0;
 }
 
-int32_t
-dht_create_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_create_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-int32_t
-dht_create_finish (call_frame_t *frame, xlator_t *this, int op_ret,
-                   int invoke_cbk)
+static int32_t
+dht_create_finish(call_frame_t *frame, xlator_t *this, int op_ret,
+                  int invoke_cbk)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
-
-        local = frame->local;
-        lock_count = dht_lock_count (local->lock[0].layout.parent_layout.locks,
-                                     local->lock[0].layout.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
-
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
-
-        lock_local->lock[0].layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
-        lock_local->lock[0].layout.parent_layout.lk_count = local->lock[0].layout.parent_layout.lk_count;
-
-        local->lock[0].layout.parent_layout.locks = NULL;
-	local->lock[0].layout.parent_layout.lk_count = 0;
-
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].layout.parent_layout.locks,
-                            lock_local->lock[0].layout.parent_layout.lk_count,
-                            dht_create_unlock_cbk);
-        lock_frame = NULL;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
+
+    local = frame->local;
+    lock_count = dht_lock_count(local->lock[0].layout.parent_layout.locks,
+                                local->lock[0].layout.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
+
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
+
+    lock_local->lock[0]
+        .layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
+    lock_local->lock[0].layout.parent_layout.lk_count =
+        local->lock[0].layout.parent_layout.lk_count;
+
+    local->lock[0].layout.parent_layout.locks = NULL;
+    local->lock[0].layout.parent_layout.lk_count = 0;
+
+    dht_unlock_inodelk(lock_frame,
+                       lock_local->lock[0].layout.parent_layout.locks,
+                       lock_local->lock[0].layout.parent_layout.lk_count,
+                       dht_create_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
-
-        if (op_ret == 0)
-                return 0;
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        DHT_STACK_UNWIND (create, frame, op_ret, local->op_errno, NULL, NULL,
-                          NULL, NULL, NULL, NULL);
+    if (op_ret == 0)
         return 0;
+
+    DHT_STACK_UNWIND(create, frame, op_ret, local->op_errno, NULL, NULL, NULL,
+                     NULL, NULL, NULL);
+    return 0;
 }
 
-int32_t
-dht_create_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_create_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                gf_msg ("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
-                        "Create lock failed for file: %s", local->loc2.name);
+    if (op_ret < 0) {
+        gf_msg("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+               "Create lock failed for file: %s", local->loc2.name);
 
-                local->op_errno = op_errno;
+        local->op_errno = op_errno;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_create_finish;
+    local->refresh_layout_unlock = dht_create_finish;
 
-        local->refresh_layout_done = dht_create_do;
+    local->refresh_layout_done = dht_create_do;
 
-        dht_refresh_layout (frame);
+    dht_refresh_layout(frame);
 
-        return 0;
+    return 0;
 err:
-        dht_create_finish (frame, this, -1, 0);
-        return 0;
+    if (local)
+        dht_create_finish(frame, this, -1, 0);
+    else
+        DHT_STACK_UNWIND(create, frame, -1, EINVAL, NULL, NULL, NULL, NULL,
+                         NULL, NULL);
+    return 0;
 }
 
 int32_t
-dht_create_lock (call_frame_t *frame, xlator_t *subvol)
+dht_create_lock(call_frame_t *frame, xlator_t *subvol)
 {
-        dht_local_t     *local          = NULL;
-        int              count  = 1,    ret = -1;
-        dht_lock_t     **lk_array       = NULL;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-        local = frame->local;
+    local = frame->local;
 
-        lk_array = GF_CALLOC (count, sizeof (*lk_array), gf_common_mt_pointer);
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
 
-        if (lk_array == NULL)
-                goto err;
+    if (lk_array == NULL)
+        goto err;
 
-        lk_array[0] = dht_lock_new (frame->this, subvol, &local->loc, F_RDLCK,
-                                    DHT_LAYOUT_HEAL_DOMAIN, NULL);
+    lk_array[0] = dht_lock_new(frame->this, subvol, &local->loc, F_RDLCK,
+                               DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                               IGNORE_ENOENT_ESTALE);
 
-        if (lk_array[0] == NULL)
-                goto err;
+    if (lk_array[0] == NULL)
+        goto err;
 
-        local->lock[0].layout.parent_layout.locks = lk_array;
-        local->lock[0].layout.parent_layout.lk_count = count;
+    local->lock[0].layout.parent_layout.locks = lk_array;
+    local->lock[0].layout.parent_layout.lk_count = count;
 
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    IGNORE_ENOENT_ESTALE, dht_create_lock_cbk);
+    ret = dht_blocking_inodelk(frame, lk_array, count, dht_create_lock_cbk);
 
-        if (ret < 0) {
-                local->lock[0].layout.parent_layout.locks = NULL;
-                local->lock[0].layout.parent_layout.lk_count = 0;
-                goto err;
-        }
+    if (ret < 0) {
+        local->lock[0].layout.parent_layout.locks = NULL;
+        local->lock[0].layout.parent_layout.lk_count = 0;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_create (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, int32_t flags, mode_t mode,
-            mode_t umask, fd_t *fd, dict_t *params)
-{
-        int             op_errno           = -1;
-        xlator_t       *subvol             = NULL;
-        dht_local_t    *local              = NULL;
-        int             i                  = 0;
-        dht_conf_t     *conf               = NULL;
-        int             ret                = 0;
+dht_set_parent_layout_in_dict(loc_t *loc, xlator_t *this, dht_local_t *local)
+{
+    dht_conf_t *conf = this->private;
+    dht_layout_t *parent_layout = NULL;
+    int *parent_disk_layout = NULL;
+    xlator_t *hashed_subvol = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    parent_layout = dht_layout_get(this, loc->parent);
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+
+    ret = dht_disk_layout_extract_for_subvol(this, parent_layout, hashed_subvol,
+                                             &parent_disk_layout);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "extracting in-memory layout of parent failed. ",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    ret = dict_set_str_sizen(local->params, GF_PREOP_PARENT_KEY,
+                             conf->xattr_name);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting %s key in params dictionary failed. ",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path,
+               GF_PREOP_PARENT_KEY);
+        goto err;
+    }
+
+    ret = dict_set_bin(local->params, conf->xattr_name, parent_disk_layout,
+                       4 * 4);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting parent-layout in params dictionary failed. ",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_CREATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+err:
+    dht_layout_unref(this, parent_layout);
+    return ret;
+}
 
-        if (dht_filter_loc_subvol_key (this, loc, &local->loc,
-                                       &subvol)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO,
-                        "creating %s on %s (got create on %s)",
-                        local->loc.path, subvol->name, loc->path);
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create, &local->loc,
-                                   flags, mode, umask, fd, params);
-                goto done;
-        }
+int
+dht_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
+{
+    int op_errno = -1;
+    xlator_t *subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->params = dict_ref(params);
+    local->flags = flags;
+    local->mode = mode;
+    local->umask = umask;
+
+    if (dht_filter_loc_subvol_key(this, loc, &local->loc, &subvol)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "creating %s on %s (got create on %s)", local->loc.path,
+               subvol->name, loc->path);
+
+        /* Since lookup-optimize is enabled by default, we need
+         * to create the linkto file if required.
+         * Note this does not check for decommisioned bricks
+         * and min-free-disk limits as this is a debugging tool
+         * and not expected to be used in production.
+         */
+        hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "no subvolume in layout for path=%s",
-                        loc->path);
+        if (hashed_subvol && (hashed_subvol != subvol)) {
+            /* Create the linkto file and then the data file */
+            local->cached_subvol = subvol;
+            local->hashed_subvol = hashed_subvol;
 
-                op_errno = EIO;
-                goto err;
+            dht_linkfile_create(frame, dht_create_linkfile_create_cbk, this,
+                                subvol, hashed_subvol, &local->loc);
+            goto done;
         }
+        /* We either don't have a hashed subvol or the hashed subvol is
+         * the same as the one specified. No need to create the linkto
+         * file as we expect a lookup everywhere if there are problems
+         * with the parent layout
+         */
 
-       /* Post remove-brick, the client layout may not be in sync with
-        * disk layout because of lack of lookup. Hence,a create call
-        * may fall on the decommissioned brick.  Hence, if the
-        * hashed_subvol is part of decommissioned bricks  list, do a
-        * lookup on parent dir. If a fix-layout is already done by the
-        * remove-brick process, the parent directory layout will be in
-        * sync with that of the disk. If fix-layout is still ending
-        * on the parent directory, we can let the file get created on
-        * the decommissioned brick which will be eventually migrated to
-        * non-decommissioned brick based on the new layout.
-        */
-
-        if (conf->decommission_subvols_cnt) {
-            for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i] &&
-                        conf->decommissioned_bricks[i] == subvol) {
-
-                        gf_msg_debug (this->name, 0, "hashed subvol:%s is "
-                                      "part of decommission brick list for "
-                                      "file: %s", subvol->name, loc->path);
-
-                        /* dht_refresh_layout needs directory info in
-                         * local->loc. Hence, storing the parent_loc in
-                         * local->loc and storing the create context in
-                         * local->loc2. We will restore this information
-                         * in dht_creation do */
-
-                        ret = loc_copy (&local->loc2, &local->loc);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "loc_copy failed %s", loc->path);
-
-                                goto err;
-                        }
+        dht_set_parent_layout_in_dict(loc, this, local);
+
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, &local->loc, flags, mode, umask,
+                          fd, params);
+        goto done;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in layout for path=%s", loc->path);
+
+        op_errno = EIO;
+        goto err;
+    }
+
+    /* Post remove-brick, the client layout may not be in sync with
+     * disk layout because of lack of lookup. Hence,a create call
+     * may fall on the decommissioned brick.  Hence, if the
+     * hashed_subvol is part of decommissioned bricks  list, do a
+     * lookup on parent dir. If a fix-layout is already done by the
+     * remove-brick process, the parent directory layout will be in
+     * sync with that of the disk. If fix-layout is still ending
+     * on the parent directory, we can let the file get created on
+     * the decommissioned brick which will be eventually migrated to
+     * non-decommissioned brick based on the new layout.
+     */
+
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == subvol) {
+                gf_msg_debug(this->name, 0,
+                             "hashed subvol:%s is "
+                             "part of decommission brick list for "
+                             "file: %s",
+                             subvol->name, loc->path);
+
+                /* dht_refresh_layout needs directory info in
+                 * local->loc. Hence, storing the parent_loc in
+                 * local->loc and storing the create context in
+                 * local->loc2. We will restore this information
+                 * in dht_creation do */
+
+                ret = loc_copy(&local->loc2, &local->loc);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                           "loc_copy failed %s", loc->path);
 
-                        local->params = dict_ref (params);
-                        local->flags = flags;
-                        local->mode = mode;
-                        local->umask = umask;
+                    goto err;
+                }
 
-                        loc_wipe (&local->loc);
+                loc_wipe(&local->loc);
 
-                        ret = dht_build_parent_loc (this, &local->loc, loc,
-                                                                 &op_errno);
+                ret = dht_build_parent_loc(this, &local->loc, loc, &op_errno);
 
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_LOC_FAILED,
-                                        "parent loc build failed");
-                                goto err;
-                        }
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_LOC_FAILED,
+                           "parent loc build failed");
+                    goto err;
+                }
 
-                        ret = dht_create_lock (frame, subvol);
+                ret = dht_create_lock(frame, subvol);
 
-                        if (ret < 0) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INODE_LK_ERROR,
-                                        "locking parent failed");
-                                goto err;
-                        }
+                if (ret < 0) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+                           "locking parent failed");
+                    goto err;
+                }
 
-                        goto done;
-               }
+                goto done;
             }
         }
+    }
 
-
-        dht_create_wind_to_avail_subvol (frame, this, subvol, loc, flags, mode,
-                                         umask, fd, params);
+    dht_create_wind_to_avail_subvol(frame, this, subvol, loc, flags, mode,
+                                    umask, fd, params);
 done:
-        return 0;
+    return 0;
 
 err:
 
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_mkdir_selfheal_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int
+dht_mkdir_selfheal_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
 
-        local = frame->local;
-        layout = local->selfheal.layout;
+    local = frame->local;
+    layout = local->selfheal.layout;
 
-        FRAME_SU_UNDO (frame, dht_local_t);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    FRAME_SU_UNDO(frame, dht_local_t);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        if (op_ret == 0) {
-                dht_layout_set (this, local->inode, layout);
+    if (op_ret == 0) {
+        dht_layout_set(this, local->inode, layout);
 
-                dht_inode_ctx_time_update (local->inode, this,
-                                           &local->stbuf, 1);
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->preparent, 0);
+        dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->preparent, 0);
 
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
+    }
 
-        DHT_STACK_UNWIND (mkdir, frame, op_ret, op_errno,
-                          local->inode, &local->stbuf, &local->preparent,
-                          &local->postparent, NULL);
+    DHT_STACK_UNWIND(mkdir, frame, op_ret, op_errno, local->inode,
+                     &local->stbuf, &local->preparent, &local->postparent,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
-               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        int           ret = -1;
-        gf_boolean_t subvol_filled = _gf_false;
-        gf_boolean_t dir_exists = _gf_false;
-        xlator_t     *prev = NULL;
-        dht_layout_t *layout = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-        layout = local->layout;
-
-        subvol_filled = dht_is_subvol_filled (this, prev);
-
-        LOCK (&frame->lock);
-        {
-                if (subvol_filled && (op_ret != -1)) {
-                        ret = dht_layout_merge (this, layout, prev,
-                                                -1, ENOSPC, NULL);
-                } else {
-                        if (op_ret == -1 && op_errno == EEXIST) {
-                                /* Very likely just a race between mkdir and
-                                   self-heal (from lookup of a concurrent mkdir
-                                   attempt).
-                                   Ignore error for now. layout setting will
-                                   anyways fail if this was a different (old)
-                                   pre-existing different directory.
-                                */
-                                op_ret = 0;
-                                dir_exists = _gf_true;
-                        }
-                        ret = dht_layout_merge (this, layout, prev,
-                                                op_ret, op_errno, NULL);
-                }
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_MERGE_FAILED,
-                                "%s: failed to merge layouts for subvol %s",
-                                local->loc.path, prev->name);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-
-                if (dir_exists)
-                        goto unlock;
-
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                dht_iatt_merge (this, &local->preparent, preparent, prev);
-                dht_iatt_merge (this, &local->postparent, postparent, prev);
+static int
+dht_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, inode_t *inode, struct iatt *stbuf,
+              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int ret = -1;
+    gf_boolean_t subvol_filled = _gf_false;
+    gf_boolean_t dir_exists = _gf_false;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+
+    local = frame->local;
+    prev = cookie;
+    layout = local->layout;
+
+    subvol_filled = dht_is_subvol_filled(this, prev);
+
+    LOCK(&frame->lock);
+    {
+        if (subvol_filled && (op_ret != -1)) {
+            ret = dht_layout_merge(this, layout, prev, -1, ENOSPC, NULL);
+        } else {
+            if (op_ret == -1 && op_errno == EEXIST) {
+                /* Very likely just a race between mkdir and
+                   self-heal (from lookup of a concurrent mkdir
+                   attempt).
+                   Ignore error for now. layout setting will
+                   anyways fail if this was a different (old)
+                   pre-existing different directory.
+                */
+                op_ret = 0;
+                dir_exists = _gf_true;
+            }
+            ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, NULL);
         }
-unlock:
-        UNLOCK (&frame->lock);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                   "%s: failed to merge layouts for subvol %s", local->loc.path,
+                   prev->name);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                /*Unlock entrylk and inodelk once mkdir is done on all subvols*/
-                dht_unlock_namespace (frame, &local->lock[0]);
-                FRAME_SU_DO (frame, dht_local_t);
-                dht_selfheal_new_directory (frame, dht_mkdir_selfheal_cbk,
-                                            layout);
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
 
-        return 0;
-}
+        if (dir_exists)
+            goto unlock;
 
-int
-dht_mkdir_hashed_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int op_ret, int op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata);
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-int
-dht_mkdir_helper (call_frame_t *frame, xlator_t *this,
-                  loc_t *loc, mode_t mode, mode_t umask, dict_t *params)
-{
-        dht_local_t  *local                   = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           op_errno                = -1, ret = -1;
-        xlator_t     *hashed_subvol           = NULL;
-        int32_t      *parent_disk_layout      = NULL;
-        dht_layout_t *parent_layout           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
-
-        conf = this->private;
-        local = frame->local;
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        /*Unlock entrylk and inodelk once mkdir is done on all subvols*/
+        dht_unlock_namespace(frame, &local->lock[0]);
+        FRAME_SU_DO(frame, dht_local_t);
+        dht_selfheal_new_directory(frame, dht_mkdir_selfheal_cbk, layout);
+    }
 
-        if (local->op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): refreshing parent layout "
-                        "failed.", pgfid, loc->name,
-                        loc->path);
+    return 0;
+}
 
-                op_errno = local->op_errno;
-                goto err;
-        }
+static int
+dht_mkdir_hashed_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata);
 
-        local->op_ret = -1;
+static int
+dht_mkdir_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                 mode_t umask, dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1, ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    int32_t *parent_disk_layout = NULL;
+    dht_layout_t *parent_layout = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    conf = this->private;
+    local = frame->local;
+
+    if (local->op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): refreshing parent layout "
+               "failed.",
+               pgfid, loc->name, loc->path);
 
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                gf_msg_debug (this->name, 0,
-                              "mkdir (%s/%s) (path: %s): hashed subvol not "
-                              "found", pgfid, loc->name, loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
+        op_errno = local->op_errno;
+        goto err;
+    }
+
+    local->op_ret = -1;
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        gf_msg_debug(this->name, 0,
+                     "mkdir (%s/%s) (path: %s): hashed subvol not "
+                     "found",
+                     pgfid, loc->name, loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    local->hashed_subvol = hashed_subvol;
+
+    parent_layout = dht_layout_get(this, loc->parent);
+
+    ret = dht_disk_layout_extract_for_subvol(this, parent_layout, hashed_subvol,
+                                             &parent_disk_layout);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, EIO, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "extracting in-memory layout of parent failed. ",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    if (memcmp(local->parent_disk_layout, parent_disk_layout,
+               sizeof(local->parent_disk_layout)) == 0) {
+        gf_msg(this->name, GF_LOG_WARNING, EIO, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): loop detected. "
+               "parent layout didn't change even though "
+               "previous attempt of mkdir failed because of "
+               "in-memory layout not matching with that on disk.",
+               pgfid, loc->name, loc->path);
+        op_errno = EIO;
+        goto err;
+    }
+
+    memcpy((void *)local->parent_disk_layout, (void *)parent_disk_layout,
+           sizeof(local->parent_disk_layout));
+
+    dht_layout_unref(this, parent_layout);
+    parent_layout = NULL;
+
+    ret = dict_set_str(params, GF_PREOP_PARENT_KEY, conf->xattr_name);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "setting %s key in params dictionary failed. ",
+               pgfid, loc->name, loc->path, GF_PREOP_PARENT_KEY);
+        goto err;
+    }
+
+    ret = dict_set_bin(params, conf->xattr_name, parent_disk_layout, 4 * 4);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "setting parent-layout in params dictionary failed. "
+               "mkdir (%s/%s) (path: %s)",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_disk_layout = NULL;
+
+    STACK_WIND_COOKIE(frame, dht_mkdir_hashed_cbk, hashed_subvol, hashed_subvol,
+                      hashed_subvol->fops->mkdir, loc, mode, umask, params);
+
+    return 0;
 
-        local->hashed_subvol = hashed_subvol;
+err:
+    dht_unlock_namespace(frame, &local->lock[0]);
 
-        parent_layout = dht_layout_get (this, loc->parent);
+    op_errno = local ? local->op_errno : op_errno;
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        ret = dht_disk_layout_extract_for_subvol (this, parent_layout,
-                                                  hashed_subvol,
-                                                  &parent_disk_layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, EIO,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "extracting in-memory layout of parent failed. ",
-                        pgfid, loc->name, loc->path);
-                goto err;
-        }
+    if (parent_disk_layout != NULL)
+        GF_FREE(parent_disk_layout);
 
-        if (memcmp (local->parent_disk_layout, parent_disk_layout,
-                    sizeof (local->parent_disk_layout)) == 0) {
-                gf_msg (this->name, GF_LOG_WARNING, EIO,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): loop detected. "
-                        "parent layout didn't change even though "
-                        "previous attempt of mkdir failed because of "
-                        "in-memory layout not matching with that on disk.",
-                        pgfid, loc->name, loc->path);
-                op_errno = EIO;
-                goto err;
-        }
+    if (parent_layout != NULL)
+        dht_layout_unref(this, parent_layout);
 
-        memcpy ((void *)local->parent_disk_layout, (void *)parent_disk_layout,
-                sizeof (local->parent_disk_layout));
+    return 0;
+}
 
-        dht_layout_unref (this, parent_layout);
-        parent_layout = NULL;
+static int
+dht_mkdir_hashed_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int ret = -1;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *hashed_subvol = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    gf_boolean_t parent_layout_changed = _gf_false;
+    call_stub_t *stub = NULL;
+
+    local = frame->local;
+    prev = cookie;
+    layout = local->layout;
+    conf = this->private;
+    hashed_subvol = local->hashed_subvol;
+
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+
+    if (gf_uuid_is_null(local->loc.gfid) && !op_ret)
+        gf_uuid_copy(local->loc.gfid, stbuf->ia_gfid);
+
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
 
-        ret = dict_set_str (params, GF_PREOP_PARENT_KEY, conf->xattr_name);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "setting %s key in params dictionary failed. ",
-                        pgfid, loc->name, loc->path, GF_PREOP_PARENT_KEY);
+        parent_layout_changed = (xdata &&
+                                 dict_get(xdata, GF_PREOP_CHECK_FAILED))
+                                    ? 1
+                                    : 0;
+        if (parent_layout_changed) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_PARENT_LAYOUT_CHANGED,
+                   "mkdir (%s/%s) (path: %s): parent layout "
+                   "changed. Attempting a refresh and then a "
+                   "retry",
+                   pgfid, local->loc.name, local->loc.path);
+
+            stub = fop_mkdir_stub(frame, dht_mkdir_helper, &local->loc,
+                                  local->mode, local->umask, local->params);
+            if (stub == NULL) {
                 goto err;
-        }
+            }
 
-        ret = dict_set_bin (params, conf->xattr_name, parent_disk_layout,
-                            4 * 4);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "setting parent-layout in params dictionary failed. "
-                        "mkdir (%s/%s) (path: %s)", pgfid, loc->name,
-                        loc->path);
+            ret = dht_handle_parent_layout_change(this, stub);
+            if (ret) {
                 goto err;
-        }
-
-        parent_disk_layout = NULL;
-
-        STACK_WIND_COOKIE (frame, dht_mkdir_hashed_cbk, hashed_subvol,
-                           hashed_subvol, hashed_subvol->fops->mkdir,
-                           loc, mode, umask, params);
-
-        return 0;
+            }
 
+            stub = NULL;
+
+            return 0;
+        }
+
+        goto err;
+    }
+
+    dict_del(local->params, GF_PREOP_PARENT_KEY);
+    dict_del(local->params, conf->xattr_name);
+
+    if (dht_is_subvol_filled(this, hashed_subvol))
+        ret = dht_layout_merge(this, layout, prev, -1, ENOSPC, NULL);
+    else
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, NULL);
+
+    /* TODO: we may have to return from the function
+       if layout merge fails. For now, lets just log an error */
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+               "%s: failed to merge layouts for subvol %s", local->loc.path,
+               prev->name);
+
+    local->op_ret = 0;
+
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preparent, preparent);
+    dht_iatt_merge(this, &local->postparent, postparent);
+
+    local->call_cnt = conf->subvolume_cnt - 1;
+    /* Delete internal mds xattr from params dict to avoid store
+      internal mds xattr on other subvols
+    */
+    dict_del(local->params, conf->mds_xattr_key);
+
+    if (gf_uuid_is_null(local->loc.gfid))
+        gf_uuid_copy(local->loc.gfid, stbuf->ia_gfid);
+
+    /* Set hashed subvol as a mds subvol on inode ctx */
+    /*if (!local->inode)
+            local->inode  = inode_ref (inode);
+    */
+    ret = dht_inode_ctx_mdsvol_set(local->inode, this, hashed_subvol);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+               "Failed to set hashed subvol for %s on inode vol is %s",
+               local->loc.path, hashed_subvol->name);
+    }
+
+    if (local->call_cnt == 0) {
+        /*Unlock namespace lock once mkdir is done on all subvols*/
+        dht_unlock_namespace(frame, &local->lock[0]);
+        FRAME_SU_DO(frame, dht_local_t);
+        dht_selfheal_directory(frame, dht_mkdir_selfheal_cbk, &local->loc,
+                               layout);
+        return 0;
+    }
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == hashed_subvol)
+            continue;
+        STACK_WIND_COOKIE(frame, dht_mkdir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i], conf->subvolumes[i]->fops->mkdir,
+                          &local->loc, local->mode, local->umask,
+                          local->params);
+    }
+
+    return 0;
 err:
-        dht_unlock_namespace (frame, &local->lock[0]);
+    if (local->op_ret != 0) {
+        dht_unlock_namespace(frame, &local->lock[0]);
+    }
 
-        op_errno = local ? local->op_errno : op_errno;
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        if (parent_disk_layout != NULL)
-                GF_FREE (parent_disk_layout);
+    return 0;
+}
 
-        if (parent_layout != NULL)
-                dht_layout_unref (this, parent_layout);
+static int
+dht_mkdir_guard_parent_layout_cbk(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, mode_t mode, mode_t umask,
+                                  dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = 0;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = -1;
+    int32_t zero[1] = {0};
+
+    local = frame->local;
+    conf = this->private;
+
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    if (local->op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "Acquiring lock on parent to guard against "
+               "layout-change failed.",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    local->op_ret = -1;
+    /* Add internal MDS xattr on disk for hashed subvol
+     */
+    ret = dht_dict_set_array(params, conf->mds_xattr_key, zero, 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->mds_xattr_key, loc->path);
+    }
+
+    STACK_WIND_COOKIE(frame, dht_mkdir_hashed_cbk, local->hashed_subvol,
+                      local->hashed_subvol, local->hashed_subvol->fops->mkdir,
+                      loc, mode, umask, params);
+
+    return 0;
+err:
+    DHT_STACK_UNWIND(mkdir, frame, -1, local->op_errno, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir_hashed_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int op_ret, int op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
-{
-        dht_local_t  *local                   = NULL;
-        int           ret                     = -1;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           i                       = 0;
-        xlator_t     *hashed_subvol           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        gf_boolean_t  parent_layout_changed   = _gf_false;
-        call_stub_t  *stub                    = NULL;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = frame->local;
-        prev  = cookie;
-        layout = local->layout;
-        conf = this->private;
-        hashed_subvol = local->hashed_subvol;
-
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
-
-        if (gf_uuid_is_null (local->loc.gfid) && !op_ret)
-                gf_uuid_copy (local->loc.gfid, stbuf->ia_gfid);
-
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
+dht_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = EINVAL, ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    call_stub_t *stub = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    conf = this->private;
+
+    if (!params || !dict_get(params, "gfid-req")) {
+        op_errno = EPERM;
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, op_errno,
+                         DHT_MSG_GFID_NULL,
+                         "mkdir: %s is received "
+                         "without gfid-req %p",
+                         loc->path, params);
+        goto err;
+    }
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        gf_msg_debug(this->name, 0, "hashed subvol not found for %s",
+                     loc->path);
+        local->op_errno = EIO;
+        goto err;
+    }
+
+    local->hashed_subvol = hashed_subvol;
+    local->mode = mode;
+    local->umask = umask;
+    if (params)
+        local->params = dict_ref(params);
+
+    local->inode = inode_ref(loc->inode);
+
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
+    if (!local->layout) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* set the newly created directory hash to the commit hash
+     * if the configuration option is set. If configuration option
+     * is not set, the older clients may still be connecting to the
+     * volume and hence we need to preserve the 1 in disk[0] part of the
+     * layout xattr */
+    if (conf->lookup_optimize)
+        local->layout->commit_hash = conf->vol_commit_hash;
+    else
+        local->layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+
+    stub = fop_mkdir_stub(frame, dht_mkdir_guard_parent_layout_cbk, loc, mode,
+                          umask, params);
+    if (stub == NULL) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "creating stub failed.",
+               pgfid, loc->name, loc->path);
+        local->op_errno = ENOMEM;
+        goto err;
+    }
+
+    ret = dht_guard_parent_layout_and_namespace(this, stub);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s) cannot wind lock request to "
+               "guard parent layout",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    return 0;
 
-                parent_layout_changed = (xdata && dict_get (xdata, GF_PREOP_CHECK_FAILED))
-                        ? 1 : 0;
-                if (parent_layout_changed) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_PARENT_LAYOUT_CHANGED,
-                                "mkdir (%s/%s) (path: %s): parent layout "
-                                "changed. Attempting a refresh and then a "
-                                "retry", pgfid, local->loc.name,
-                                local->loc.path);
-
-                        stub = fop_mkdir_stub (frame, dht_mkdir_helper,
-                                               &local->loc, local->mode,
-                                               local->umask, local->params);
-                        if (stub == NULL) {
-                                goto err;
-                        }
-
-                        dht_handle_parent_layout_change (this, stub);
-                        stub = NULL;
-
-                        return 0;
-                }
-
-                goto err;
-        }
-
-        dict_del (local->params, GF_PREOP_PARENT_KEY);
-        dict_del (local->params, conf->xattr_name);
-
-        if (dht_is_subvol_filled (this, hashed_subvol))
-                ret = dht_layout_merge (this, layout, prev,
-                                        -1, ENOSPC, NULL);
-        else
-                ret = dht_layout_merge (this, layout, prev,
-                                        op_ret, op_errno, NULL);
-
-        /* TODO: we may have to return from the function
-           if layout merge fails. For now, lets just log an error */
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "%s: failed to merge layouts for subvol %s",
-                        local->loc.path, prev->name);
-
-        local->op_ret = 0;
+err:
+    op_errno = local ? local->op_errno : op_errno;
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-        dht_iatt_merge (this, &local->preparent, preparent, prev);
-        dht_iatt_merge (this, &local->postparent, postparent, prev);
+    return 0;
+}
 
-        local->call_cnt = conf->subvolume_cnt - 1;
+static int
+dht_rmdir_selfheal_cbk(call_frame_t *heal_frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        if (gf_uuid_is_null (local->loc.gfid))
-                gf_uuid_copy (local->loc.gfid, stbuf->ia_gfid);
-        if (local->call_cnt == 0) {
-                /*Unlock namespace lock once mkdir is done on all subvols*/
-                dht_unlock_namespace (frame, &local->lock[0]);
-                FRAME_SU_DO (frame, dht_local_t);
-                dht_selfheal_directory (frame, dht_mkdir_selfheal_cbk,
-                                        &local->loc, layout);
-        }
+    heal_local = heal_frame->local;
+    main_frame = heal_local->main_frame;
+    local = main_frame->local;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == hashed_subvol)
-                        continue;
-                STACK_WIND_COOKIE (frame, dht_mkdir_cbk, conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->mkdir,
-                                   &local->loc, local->mode, local->umask,
-                                   local->params);
-        }
-        return 0;
-err:
-        if (local->op_ret != 0) {
-                dht_unlock_namespace (frame, &local->lock[0]);
-        }
+    DHT_STACK_DESTROY(heal_frame);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
-        if (stub) {
-                call_stub_destroy (stub);
-        }
+    DHT_STACK_UNWIND(rmdir, main_frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_mkdir_guard_parent_layout_cbk (call_frame_t *frame, xlator_t *this,
-                                   loc_t *loc, mode_t mode, mode_t umask,
-                                   dict_t *params)
-{
-        dht_local_t *local                    = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
+static int
+dht_rmdir_hashed_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int op_ret, int op_errno, struct iatt *preparent,
+                            struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *heal_frame = NULL;
+    dht_conf_t *conf = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            local->op_ret = -1;
+            if (conf->subvolume_cnt != 1) {
+                if (op_errno != ENOENT && op_errno != EACCES &&
+                    op_errno != ESTALE) {
+                    local->need_selfheal = 1;
+                }
+            }
 
-        if (local->op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "Acquiring lock on parent to guard against "
-                        "layout-change failed.", pgfid, loc->name, loc->path);
-                goto err;
+            gf_msg_debug(this->name, op_errno,
+                         "rmdir on %s for %s failed "
+                         "(gfid = %s)",
+                         prev->name, local->loc.path, gfid);
+            goto unlock;
         }
 
-        local->op_ret = -1;
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        STACK_WIND_COOKIE (frame, dht_mkdir_hashed_cbk, local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->mkdir,
-                           loc, mode, umask, params);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (local->need_selfheal) {
+            dht_rmdir_unlock(frame, this);
+            local->layout = dht_layout_get(this, local->loc.inode);
 
-        return 0;
-err:
-        DHT_STACK_UNWIND (mkdir, frame, -1, local->op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+            /* TODO: neater interface needed below */
+            local->stbuf.ia_type = local->loc.inode->ia_type;
 
-        return 0;
-}
+            gf_uuid_copy(local->gfid, local->loc.inode->gfid);
 
-int
-dht_mkdir (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, mode_t mode, mode_t umask, dict_t *params)
-{
-        dht_local_t  *local                   = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           op_errno                = -1, ret = -1;
-        xlator_t     *hashed_subvol           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        call_stub_t  *stub                    = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
-
-        conf = this->private;
-
-        if (!params || !dict_get (params, "gfid-req")) {
-                op_errno = EPERM;
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, op_errno,
-                                  DHT_MSG_GFID_NULL, "mkdir: %s is received "
-                                  "without gfid-req %p", loc->path, params);
-                goto err;
-        }
+            /* Use a different frame or else the rmdir op_ret is
+             * overwritten by that of the selfheal */
 
-        dht_get_du_info (frame, this, loc);
+            heal_frame = copy_frame(frame);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKDIR);
-        if (!local) {
-                op_errno = ENOMEM;
+            if (heal_frame == NULL) {
                 goto err;
-        }
+            }
 
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                gf_msg_debug (this->name, 0,
-                              "hashed subvol not found for %s",
-                              loc->path);
-                local->op_errno = EIO;
+            heal_local = dht_local_init(heal_frame, &local->loc, NULL, 0);
+            if (!heal_local) {
+                DHT_STACK_DESTROY(heal_frame);
                 goto err;
-        }
-
-
-        local->hashed_subvol = hashed_subvol;
-        local->mode = mode;
-        local->umask = umask;
-        if (params)
-                local->params = dict_ref (params);
-
-        local->inode  = inode_ref (loc->inode);
+            }
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
-        if (!local->layout) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+            heal_local->inode = inode_ref(local->loc.inode);
+            heal_local->main_frame = frame;
+            gf_uuid_copy(heal_local->gfid, local->loc.inode->gfid);
 
-        /* set the newly created directory hash to the commit hash
-         * if the configuration option is set. If configuration option
-         * is not set, the older clients may still be connecting to the
-         * volume and hence we need to preserve the 1 in disk[0] part of the
-         * layout xattr */
-        if (conf->lookup_optimize)
-                local->layout->commit_hash = conf->vol_commit_hash;
-        else
-                local->layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+            dht_selfheal_restore(heal_frame, dht_rmdir_selfheal_cbk,
+                                 &heal_local->loc, heal_local->layout);
+            return 0;
+        } else {
+            if (local->loc.parent) {
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->preparent, 0);
 
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->postparent, 1);
+            }
 
-        stub = fop_mkdir_stub (frame, dht_mkdir_guard_parent_layout_cbk, loc,
-                               mode, umask, params);
-        if (stub == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "creating stub failed.", pgfid, loc->name, loc->path);
-                local->op_errno = ENOMEM;
-                goto err;
-        }
+            dht_set_fixed_dir_stat(&local->preparent);
+            dht_set_fixed_dir_stat(&local->postparent);
 
-        ret = dht_guard_parent_layout_and_namespace (this, stub);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s) cannot wind lock request to "
-                        "guard parent layout", pgfid, loc->name, loc->path);
-                goto err;
+            dht_rmdir_unlock(frame, this);
+            DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                             &local->preparent, &local->postparent, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = local ? local->op_errno : op_errno;
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
-
-        return 0;
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
-
-int
-dht_rmdir_selfheal_cbk (call_frame_t *heal_frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+static int
+dht_rmdir_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *main_frame = NULL;
-
-        heal_local = heal_frame->local;
-        main_frame = heal_local->main_frame;
-        local = main_frame->local;
-
-        DHT_STACK_DESTROY (heal_frame);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
-
-        DHT_STACK_UNWIND (rmdir, main_frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
-
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
+static int
+dht_rmdir_unlock(call_frame_t *frame, xlator_t *this)
+{
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
 
-int
-dht_rmdir_hashed_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int op_ret, int op_errno, struct iatt *preparent,
-                             struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *heal_frame = NULL;
-        dht_conf_t   *conf = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
-
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
-
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        local->op_ret   = -1;
-                        if (conf->subvolume_cnt != 1) {
-                                if (op_errno != ENOENT && op_errno != EACCES
-                                    && op_errno != ESTALE) {
-                                        local->need_selfheal = 1;
-                                }
-                        }
-
-                        gf_msg_debug (this->name, op_errno,
-                                      "rmdir on %s for %s failed "
-                                      "(gfid = %s)",
-                                      prev->name, local->loc.path,
-                                      gfid);
-                        goto unlock;
-                }
-
-                dht_iatt_merge (this, &local->preparent, preparent, prev);
-                dht_iatt_merge (this, &local->postparent, postparent, prev);
-
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-               if (local->need_selfheal) {
-                        dht_rmdir_unlock (frame, this);
-                        local->layout =
-                                dht_layout_get (this, local->loc.inode);
-
-                        /* TODO: neater interface needed below */
-                        local->stbuf.ia_type = local->loc.inode->ia_type;
-
-                        gf_uuid_copy (local->gfid, local->loc.inode->gfid);
-
-                        /* Use a different frame or else the rmdir op_ret is
-                         * overwritten by that of the selfheal */
+    local = frame->local;
 
-                        heal_frame = copy_frame (frame);
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[0].ns.directory_ns);
 
-                        if (heal_frame == NULL) {
-                                goto err;
-                        }
+    /* Unlock inodelk */
+    lock_count = dht_lock_count(local->lock[0].ns.parent_layout.locks,
+                                local->lock[0].ns.parent_layout.lk_count);
 
-                        heal_local = dht_local_init (heal_frame,
-                                                     &local->loc,
-                                                     NULL, 0);
-                        if (!heal_local) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
+    if (lock_count == 0)
+        goto done;
 
-                        heal_local->inode = inode_ref (local->loc.inode);
-                        heal_local->main_frame = frame;
-                        gf_uuid_copy (heal_local->gfid, local->loc.inode->gfid);
-
-                        dht_selfheal_restore (heal_frame,
-                                              dht_rmdir_selfheal_cbk,
-                                              &heal_local->loc,
-                                              heal_local->layout);
-                        return 0;
-               } else {
-
-                        if (local->loc.parent) {
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->preparent,
-                                                           0);
-
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->postparent,
-                                                           1);
-                        }
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL)
+        goto done;
 
-                        dht_set_fixed_dir_stat (&local->preparent);
-                        dht_set_fixed_dir_stat (&local->postparent);
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL)
+        goto done;
 
-                        dht_rmdir_unlock (frame, this);
-                        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-               }
-        }
+    lock_local->lock[0].ns.parent_layout.locks = local->lock[0]
+                                                     .ns.parent_layout.locks;
+    lock_local->lock[0]
+        .ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
 
-        return 0;
+    local->lock[0].ns.parent_layout.locks = NULL;
+    local->lock[0].ns.parent_layout.lk_count = 0;
+    dht_unlock_inodelk(lock_frame, lock_local->lock[0].ns.parent_layout.locks,
+                       lock_local->lock[0].ns.parent_layout.lk_count,
+                       dht_rmdir_unlock_cbk);
+    lock_frame = NULL;
 
-err:
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                          local->op_errno, NULL, NULL, NULL);
-        return 0;
+done:
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
+    return 0;
 }
 
+static int
+dht_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iatt *preparent, struct iatt *postparent,
+              dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int done = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *heal_local = NULL;
+    call_frame_t *heal_frame = NULL;
+    int ret = -1;
+
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
+                local->op_errno = op_errno;
+                local->op_ret = -1;
 
-int
-dht_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, struct iatt *preparent,
-               struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-        int           done = 0;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *heal_frame = NULL;
-        int           ret        = -1;
-
-        local = frame->local;
-        prev  = cookie;
-
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
-                                local->op_errno = op_errno;
-                                local->op_ret = -1;
-
-                                if (op_errno != EACCES)
-                                        local->need_selfheal = 1;
-                        }
-
-                        gf_uuid_unparse(local->loc.gfid, gfid);
-
-                        gf_msg_debug (this->name, op_errno,
-                                      "rmdir on %s for %s failed."
-                                      "(gfid = %s)",
-                                      prev->name, local->loc.path,
-                                      gfid);
-                        goto unlock;
-                }
-
-                /* Track if rmdir succeeded on atleast one subvol*/
-                local->fop_succeeded = 1;
-                dht_iatt_merge (this, &local->preparent, preparent, prev);
-                dht_iatt_merge (this, &local->postparent, postparent, prev);
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
+                if (op_errno != EACCES)
+                    local->need_selfheal = 1;
+            }
 
-        this_call_cnt = dht_frame_return (frame);
+            gf_uuid_unparse(local->loc.gfid, gfid);
 
-        /* if local->hashed_subvol, we are yet to wind to hashed_subvol. */
-        if (local->hashed_subvol && (this_call_cnt == 1)) {
-                done = 1;
-        } else if (!local->hashed_subvol && !this_call_cnt) {
-                done = 1;
+            gf_msg_debug(this->name, op_errno,
+                         "rmdir on %s for %s failed."
+                         "(gfid = %s)",
+                         prev->name, local->loc.path, gfid);
+            goto unlock;
         }
 
+        /* Track if rmdir succeeded on at least one subvol*/
+        local->fop_succeeded = 1;
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (done) {
-                if (local->need_selfheal && local->fop_succeeded) {
-                        dht_rmdir_unlock (frame, this);
-                        local->layout =
-                                dht_layout_get (this, local->loc.inode);
+    this_call_cnt = dht_frame_return(frame);
 
-                        /* TODO: neater interface needed below */
-                        local->stbuf.ia_type = local->loc.inode->ia_type;
+    /* if local->hashed_subvol, we are yet to wind to hashed_subvol. */
+    if (local->hashed_subvol && (this_call_cnt == 1)) {
+        done = 1;
+    } else if (!local->hashed_subvol && !this_call_cnt) {
+        done = 1;
+    }
 
-                        gf_uuid_copy (local->gfid, local->loc.inode->gfid);
-                        heal_frame = copy_frame (frame);
-                        if (heal_frame == NULL) {
-                                goto err;
-                        }
+    if (done) {
+        if (local->need_selfheal && local->fop_succeeded) {
+            dht_rmdir_unlock(frame, this);
+            local->layout = dht_layout_get(this, local->loc.inode);
 
-                        heal_local = dht_local_init (heal_frame, &local->loc,
-                                                     NULL, 0);
-                        if (!heal_local) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
+            /* TODO: neater interface needed below */
+            local->stbuf.ia_type = local->loc.inode->ia_type;
 
-                        heal_local->inode = inode_ref (local->loc.inode);
-                        heal_local->main_frame = frame;
-                        gf_uuid_copy (heal_local->gfid, local->loc.inode->gfid);
-                        ret = dht_selfheal_restore (heal_frame,
-                                                    dht_rmdir_selfheal_cbk,
-                                                    &heal_local->loc,
-                                                    heal_local->layout);
-                        if (ret) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
+            gf_uuid_copy(local->gfid, local->loc.inode->gfid);
+            heal_frame = copy_frame(frame);
+            if (heal_frame == NULL) {
+                goto err;
+            }
 
-                } else if (this_call_cnt) {
-                        /* If non-hashed subvol's have responded, proceed */
-                        if (local->op_ret == 0) {
-                                /* Delete the dir from the hashed subvol if:
-                                 * The fop succeeded on at least one subvol
-                                 *  and did not fail on any
-                                 *  or
-                                 *  The fop failed with ENOENT/ESTALE on
-                                 *  all subvols */
-
-                                STACK_WIND_COOKIE (frame, dht_rmdir_hashed_subvol_cbk,
-                                                   local->hashed_subvol,
-                                                   local->hashed_subvol,
-                                                   local->hashed_subvol->fops->rmdir,
-                                                   &local->loc, local->flags, NULL);
-                        } else {
-                         /* hashed-subvol was non-NULL and rmdir failed on
-                          * all non hashed-subvols. Unwind rmdir with
-                          * local->op_ret and local->op_errno. */
-                                dht_rmdir_unlock (frame, this);
-                                DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-
-                                return 0;
+            heal_local = dht_local_init(heal_frame, &local->loc, NULL, 0);
+            if (!heal_local) {
+                DHT_STACK_DESTROY(heal_frame);
+                goto err;
+            }
 
-                        }
-                } else if (!this_call_cnt) {
-                        /* All subvol's have responded, proceed */
+            heal_local->inode = inode_ref(local->loc.inode);
+            heal_local->main_frame = frame;
+            gf_uuid_copy(heal_local->gfid, local->loc.inode->gfid);
+            ret = dht_selfheal_restore(heal_frame, dht_rmdir_selfheal_cbk,
+                                       &heal_local->loc, heal_local->layout);
+            if (ret) {
+                DHT_STACK_DESTROY(heal_frame);
+                goto err;
+            }
 
-                        if (local->loc.parent) {
+        } else if (this_call_cnt) {
+            /* If non-hashed subvol's have responded, proceed */
+            if (local->op_ret == 0) {
+                /* Delete the dir from the hashed subvol if:
+                 * The fop succeeded on at least one subvol
+                 *  and did not fail on any
+                 *  or
+                 *  The fop failed with ENOENT/ESTALE on
+                 *  all subvols */
+
+                STACK_WIND_COOKIE(frame, dht_rmdir_hashed_subvol_cbk,
+                                  local->hashed_subvol, local->hashed_subvol,
+                                  local->hashed_subvol->fops->rmdir,
+                                  &local->loc, local->flags, NULL);
+            } else {
+                /* hashed-subvol was non-NULL and rmdir failed on
+                 * all non hashed-subvols. Unwind rmdir with
+                 * local->op_ret and local->op_errno. */
+                dht_rmdir_unlock(frame, this);
+                DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                                 &local->preparent, &local->postparent, NULL);
 
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->preparent,
-                                                           0);
+                return 0;
+            }
+        } else if (!this_call_cnt) {
+            /* All subvol's have responded, proceed */
 
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->postparent,
-                                                           1);
+            if (local->loc.parent) {
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->preparent, 0);
 
-                        }
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->postparent, 1);
+            }
 
-                        dht_set_fixed_dir_stat (&local->preparent);
-                        dht_set_fixed_dir_stat (&local->postparent);
+            dht_set_fixed_dir_stat(&local->preparent);
+            dht_set_fixed_dir_stat(&local->postparent);
 
-                        dht_rmdir_unlock (frame, this);
-                        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-                }
+            dht_rmdir_unlock(frame, this);
+            DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                             &local->preparent, &local->postparent, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (rmdir, frame, -1, local->op_errno, NULL, NULL, NULL);
-        return 0;
-
-}
-
-
-int
-dht_rmdir_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_UNWIND(rmdir, frame, -1, local->op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
-int
-dht_rmdir_unlock (call_frame_t *frame, xlator_t *this)
+static int
+dht_rmdir_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
-
-        local = frame->local;
-
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[0].ns.directory_ns);
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *hashed_subvol;
 
-        /* Unlock inodelk */
-        lock_count = dht_lock_count (local->lock[0].ns.parent_layout.locks,
-                                     local->lock[0].ns.parent_layout.lk_count);
+    conf = this->private;
+    local = frame->local;
 
-        if (lock_count == 0)
-                goto done;
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed rmdir for %s)",
+               local->loc.path);
 
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL)
-                goto done;
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL)
-                goto done;
+    hashed_subvol = local->hashed_subvol;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (hashed_subvol && (hashed_subvol == conf->subvolumes[i]))
+            continue;
 
-        lock_local->lock[0].ns.parent_layout.locks = local->lock[0].ns.parent_layout.locks;
-        lock_local->lock[0].ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
+        STACK_WIND_COOKIE(frame, dht_rmdir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i], conf->subvolumes[i]->fops->rmdir,
+                          &local->loc, local->flags, NULL);
+    }
 
-        local->lock[0].ns.parent_layout.locks = NULL;
-        local->lock[0].ns.parent_layout.lk_count = 0;
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].ns.parent_layout.locks,
-                            lock_local->lock[0].ns.parent_layout.lk_count,
-                            dht_rmdir_unlock_cbk);
-        lock_frame = NULL;
+    return 0;
 
-done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+err:
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_rmdir_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int
+dht_rmdir_do(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        int           i     = 0;
-        xlator_t     *hashed_subvol;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(frame->local, err);
+    local = frame->local;
+    VALIDATE_OR_GOTO(this->private, out);
+    conf = this->private;
 
-        conf = this->private;
-        local = frame->local;
+    if (local->op_ret == -1)
+        goto out;
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed rmdir for %s)",
-                        local->loc.path);
+    local->call_cnt = conf->subvolume_cnt;
 
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
+    /* first remove from non-hashed_subvol */
+    hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
 
-        hashed_subvol = local->hashed_subvol;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (hashed_subvol &&
-                    (hashed_subvol == conf->subvolumes[i]))
-                        continue;
+    if (!hashed_subvol) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-                STACK_WIND_COOKIE (frame, dht_rmdir_cbk, conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->rmdir,
-                                   &local->loc, local->flags, NULL);
-        }
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "Failed to get hashed subvol for %s (gfid = %s)",
+               local->loc.path, gfid);
+    } else {
+        local->hashed_subvol = hashed_subvol;
+    }
 
+    /* When DHT has only 1 child */
+    if (conf->subvolume_cnt == 1) {
+        STACK_WIND_COOKIE(frame, dht_rmdir_hashed_subvol_cbk,
+                          conf->subvolumes[0], conf->subvolumes[0],
+                          conf->subvolumes[0]->fops->rmdir, &local->loc,
+                          local->flags, NULL);
         return 0;
+    }
 
-err:
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, &local->loc, local->hashed_subvol,
+                                &local->current->ns, dht_rmdir_lock_cbk);
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = errno ? errno : EINVAL;
+        goto out;
+    }
 
-        return 0;
-}
+    return 0;
 
+out:
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-int
-dht_rmdir_do (call_frame_t *frame, xlator_t *this)
-{
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-        xlator_t     *hashed_subvol = NULL;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
+    return 0;
+err:
+    DHT_STACK_UNWIND(rmdir, frame, -1, EINVAL, NULL, NULL, NULL);
+    return 0;
+}
 
-        VALIDATE_OR_GOTO (this->private, err);
+static void
+dht_rmdir_readdirp_done(call_frame_t *readdirp_frame, xlator_t *this)
+{
+    call_frame_t *main_frame = NULL;
+    dht_local_t *main_local = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        conf = this->private;
-        local = frame->local;
+    local = readdirp_frame->local;
+    main_frame = local->main_frame;
+    main_local = main_frame->local;
 
-        if (local->op_ret == -1)
-                goto err;
+    /* At least one readdirp failed.
+     * This is a bit hit or miss - if readdirp failed on more than
+     * one subvol, we don't know which error is returned.
+     */
+    if (local->op_ret == -1) {
+        main_local->op_ret = local->op_ret;
+        main_local->op_errno = local->op_errno;
+    }
 
-        local->call_cnt = conf->subvolume_cnt;
+    this_call_cnt = dht_frame_return(main_frame);
 
-        /* first remove from non-hashed_subvol */
-        hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_do(main_frame, this);
 
-        if (!hashed_subvol) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
+    DHT_STACK_DESTROY(readdirp_frame);
+}
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "Failed to get hashed subvol for %s (gfid = %s)",
-                        local->loc.path, gfid);
-        } else {
-                local->hashed_subvol = hashed_subvol;
-        }
+/* Keep sending readdirp on the subvol until it returns no more entries
+ * It is possible that not all entries will fit in a single readdirp in
+ * which case the rmdir will keep failing with ENOTEMPTY
+ */
 
-        /* When DHT has only 1 child */
-        if (conf->subvolume_cnt == 1) {
-                STACK_WIND_COOKIE (frame, dht_rmdir_hashed_subvol_cbk,
-                                   conf->subvolumes[0], conf->subvolumes[0],
-                                   conf->subvolumes[0]->fops->rmdir,
-                                   &local->loc, local->flags, NULL);
-                return 0;
-        }
+static int
+dht_rmdir_readdirp_do(call_frame_t *readdirp_frame, xlator_t *this)
+{
+    dht_local_t *local = NULL;
 
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, &local->loc, local->hashed_subvol,
-                                     &local->current->ns, dht_rmdir_lock_cbk);
-        if (ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = errno ? errno : EINVAL;
-                goto err;
-        }
+    local = readdirp_frame->local;
 
+    if (local->op_ret == -1) {
+        /* there is no point doing another readdirp on this
+         * subvol . */
+        dht_rmdir_readdirp_done(readdirp_frame, this);
         return 0;
+    }
 
-err:
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    STACK_WIND_COOKIE(readdirp_frame, dht_rmdir_readdirp_cbk,
+                      local->hashed_subvol, local->hashed_subvol,
+                      local->hashed_subvol->fops->readdirp, local->fd, 4096, 0,
+                      local->xattr);
 
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
-        return 0;
+    return 0;
 }
 
-
-int
-dht_rmdir_linkfile_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                               int op_ret, int op_errno, struct iatt *preparent,
-                               struct iatt *postparent, dict_t *xdata)
+static int
+dht_rmdir_linkfile_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int op_ret, int op_errno, struct iatt *preparent,
+                              struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t    *local = NULL;
-        xlator_t       *prev = NULL;
-        xlator_t       *src = NULL;
-        call_frame_t   *readdirp_frame = NULL;
-        dht_local_t    *readdirp_local = NULL;
-        int             this_call_cnt = 0;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
+    local = frame->local;
+    prev = cookie;
+    src = prev;
 
-        local  = frame->local;
-        prev   = cookie;
-        src    = prev;
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
 
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
-
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        if (op_ret == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Unlinked linkfile %s on %s, gfid = %s",
-                              local->loc.path, src->name, gfid);
-        } else {
-                if (op_errno != ENOENT) {
-                        readdirp_local->op_ret   = -1;
-                        readdirp_local->op_errno = op_errno;
-                }
-                gf_msg_debug (this->name, op_errno,
-                              "Unlink of %s on %s failed. (gfid = %s)",
-                              local->loc.path, src->name, gfid);
+    if (op_ret == 0) {
+        gf_msg_trace(this->name, 0, "Unlinked linkfile %s on %s, gfid = %s",
+                     local->loc.path, src->name, gfid);
+    } else {
+        if (op_errno != ENOENT) {
+            readdirp_local->op_ret = -1;
+            readdirp_local->op_errno = op_errno;
         }
+        gf_msg_debug(this->name, op_errno,
+                     "Unlink of %s on %s failed. (gfid = %s)", local->loc.path,
+                     src->name, gfid);
+    }
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
+    this_call_cnt = dht_frame_return(readdirp_frame);
 
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_readdirp_do (readdirp_frame, this);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_readdirp_do(readdirp_frame, this);
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
+static int
+dht_rmdir_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, dict_t *xattr, struct iatt *parent)
+{
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    prev = cookie;
+    src = prev;
+
+    gf_msg_debug(this->name, 0, "dht_rmdir_lookup_cbk %s", local->loc.path);
+
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
+
+    if (op_ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_FILE_LOOKUP_FAILED,
+               "lookup failed for %s on %s", local->loc.path, src->name);
+        goto err;
+    }
+
+    if (!check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = ENOTEMPTY;
 
-int
-dht_rmdir_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, inode_t *inode,
-                      struct iatt *stbuf, dict_t *xattr, struct iatt *parent)
-{
-        dht_local_t    *local = NULL;
-        xlator_t       *prev = NULL;
-        xlator_t       *src = NULL;
-        call_frame_t   *readdirp_frame = NULL;
-        dht_local_t    *readdirp_local = NULL;
-        int             this_call_cnt = 0;
-        dht_conf_t     *conf = this->private;
-        char               gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        prev  = cookie;
-        src   = prev;
-
-        gf_msg_debug (this->name, 0, "dht_rmdir_lookup_cbk %s",
-                      local->loc.path);
-
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
-
-        if (op_ret != 0) {
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_FILE_LOOKUP_FAILED,
-                        "lookup failed for %s on %s  (type=0%o)",
-                        local->loc.path, src->name, stbuf->ia_type);
-                goto err;
-        }
-
-        if (!check_is_linkfile (inode, stbuf, xattr, conf->link_xattr_name)) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = ENOTEMPTY;
-
-                gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NOT_LINK_FILE_ERROR,
-                        "%s on %s is not a linkfile (type=0%o, gfid = %s)",
-                        local->loc.path, src->name, stbuf->ia_type, gfid);
-                goto err;
-        }
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NOT_LINK_FILE_ERROR,
+               "%s on %s is not a linkfile (type=0%o, gfid = %s)",
+               local->loc.path, src->name, stbuf->ia_type, gfid);
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_rmdir_linkfile_unlink_cbk, src,
-                           src, src->fops->unlink, &local->loc, 0, NULL);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rmdir_linkfile_unlink_cbk, src, src,
+                      src->fops->unlink, &local->loc, 0, NULL);
+    return 0;
 err:
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_rmdir_readdirp_do (readdirp_frame, this);
-        }
+    this_call_cnt = dht_frame_return(readdirp_frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_rmdir_readdirp_do(readdirp_frame, this);
+    }
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
-int
-dht_rmdir_cached_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int op_ret, int op_errno, inode_t *inode,
-                             struct iatt *stbuf, dict_t *xattr,
-                             struct iatt *parent)
-{
-        dht_local_t    *local             = NULL;
-        xlator_t       *src               = NULL;
-        call_frame_t   *readdirp_frame    = NULL;
-        dht_local_t    *readdirp_local    = NULL;
-        int             this_call_cnt     = 0;
-        dht_conf_t     *conf              = this->private;
-        dict_t         *xattrs            = NULL;
-        int             ret               = 0;
-
-        local = frame->local;
-        src   = local->hashed_subvol;
-
-
-        /* main_frame here is the readdirp_frame */
-
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
-
-        gf_msg_debug (this->name, 0, "returning for %s ",
-                      local->loc.path);
-
-        if (op_ret == 0) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = ENOTEMPTY;
-
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_ERROR,
-                        "%s found on cached subvol %s",
-                        local->loc.path, src->name);
-                goto err;
-        } else if (op_errno != ENOENT) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = op_errno;
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_SUBVOL_ERROR,
-                        "%s not found on cached subvol %s",
-                        local->loc.path, src->name);
-                goto err;
-        }
-
-        xattrs = dict_new ();
-        if (!xattrs) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dict_new failed");
-                goto err;
-        }
-
-        ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        conf->link_xattr_name);
-                if (xattrs)
-                        dict_unref (xattrs);
-                goto err;
-        }
-        STACK_WIND_COOKIE (frame, dht_rmdir_lookup_cbk, src, src,
-                           src->fops->lookup, &local->loc, xattrs);
+static int
+dht_rmdir_cached_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int op_ret, int op_errno, inode_t *inode,
+                            struct iatt *stbuf, dict_t *xattr,
+                            struct iatt *parent)
+{
+    dht_local_t *local = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    dht_conf_t *conf = this->private;
+    dict_t *xattrs = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    src = local->hashed_subvol;
+
+    /* main_frame here is the readdirp_frame */
+
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
+
+    gf_msg_debug(this->name, 0, "returning for %s ", local->loc.path);
+
+    if (op_ret == 0) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = ENOTEMPTY;
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_ERROR,
+               "%s found on cached subvol %s", local->loc.path, src->name);
+        goto err;
+    } else if (op_errno != ENOENT) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = op_errno;
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_SUBVOL_ERROR,
+               "%s not found on cached subvol %s", local->loc.path, src->name);
+        goto err;
+    }
+
+    xattrs = dict_new();
+    if (!xattrs) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dict_new failed");
+        goto err;
+    }
+
+    ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s",
+               conf->link_xattr_name);
         if (xattrs)
-                dict_unref (xattrs);
-
-        return 0;
+            dict_unref(xattrs);
+        goto err;
+    }
+    STACK_WIND_COOKIE(frame, dht_rmdir_lookup_cbk, src, src, src->fops->lookup,
+                      &local->loc, xattrs);
+    if (xattrs)
+        dict_unref(xattrs);
+
+    return 0;
 err:
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
+    this_call_cnt = dht_frame_return(readdirp_frame);
 
-        /* Once all the lookups/unlinks etc have returned, proceed to wind
-         * readdirp on the subvol again until no entries are returned.
-         * This is required if there are more entries than can be returned
-         * in a single readdirp call.
-         */
+    /* Once all the lookups/unlinks etc have returned, proceed to wind
+     * readdirp on the subvol again until no entries are returned.
+     * This is required if there are more entries than can be returned
+     * in a single readdirp call.
+     */
 
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_readdirp_do (readdirp_frame, this);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_readdirp_do(readdirp_frame, this);
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
+static int
+dht_rmdir_is_subvol_empty(call_frame_t *frame, xlator_t *this,
+                          gf_dirent_t *entries, xlator_t *src)
+{
+    int ret = 0;
+    int build_ret = 0;
+    gf_dirent_t *trav = NULL;
+    call_frame_t *lookup_frame = NULL;
+    dht_local_t *lookup_local = NULL;
+    dht_local_t *local = NULL;
+    dict_t *xattrs = NULL;
+    dht_conf_t *conf = this->private;
+    xlator_t *subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int count = 0;
+    gf_boolean_t unwind = _gf_false;
+
+    local = frame->local;
+
+    list_for_each_entry(trav, &entries->list, list)
+    {
+        if (strcmp(trav->d_name, ".") == 0)
+            continue;
+        if (strcmp(trav->d_name, "..") == 0)
+            continue;
+        if (check_is_linkfile(NULL, (&trav->d_stat), trav->dict,
+                              conf->link_xattr_name)) {
+            count++;
+            continue;
+        }
+
+        /* this entry is either a directory which is neither "." nor "..",
+           or a non directory which is not a linkfile. the directory is to
+           be treated as non-empty
+        */
+        return 0;
+    }
 
-int
-dht_rmdir_is_subvol_empty (call_frame_t *frame, xlator_t *this,
-                           gf_dirent_t *entries, xlator_t *src)
-{
-        int                 ret          = 0;
-        int                 build_ret    = 0;
-        gf_dirent_t        *trav         = NULL;
-        call_frame_t       *lookup_frame = NULL;
-        dht_local_t        *lookup_local = NULL;
-        dht_local_t        *local        = NULL;
-        dict_t             *xattrs       = NULL;
-        dht_conf_t         *conf         = this->private;
-        xlator_t           *subvol       = NULL;
-        char                gfid[GF_UUID_BUF_SIZE] = {0};
-        int                 count        = 0;
-        gf_boolean_t        unwind        = _gf_false;
-
+    xattrs = dict_new();
+    if (!xattrs) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dict_new failed");
+        return -1;
+    }
 
-        local = frame->local;
+    ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s",
+               conf->link_xattr_name);
 
-        list_for_each_entry (trav, &entries->list, list) {
-                if (strcmp (trav->d_name, ".") == 0)
-                        continue;
-                if (strcmp (trav->d_name, "..") == 0)
-                        continue;
-                if (check_is_linkfile (NULL, (&trav->d_stat), trav->dict,
-                                              conf->link_xattr_name)) {
-                        count++;
-                        continue;
-                }
+        if (xattrs)
+            dict_unref(xattrs);
+        return -1;
+    }
 
-                /* this entry is either a directory which is neither "." nor "..",
-                   or a non directory which is not a linkfile. the directory is to
-                   be treated as non-empty
-                */
-                return 0;
-        }
+    local->call_cnt = count;
+    ret = 0;
 
-        xattrs = dict_new ();
-        if (!xattrs) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dict_new failed");
-                return -1;
-        }
+    list_for_each_entry(trav, &entries->list, list)
+    {
+        if (strcmp(trav->d_name, ".") == 0)
+            continue;
+        if (strcmp(trav->d_name, "..") == 0)
+            continue;
 
-        ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        conf->link_xattr_name);
+        lookup_frame = copy_frame(frame);
 
-                if (xattrs)
-                        dict_unref (xattrs);
-                return -1;
+        if (!lookup_frame) {
+            /* out of memory, let the rmdir fail
+               (as non-empty, unfortunately) */
+            goto err;
         }
 
-        local->call_cnt = count;
-        ret = 0;
-
-        list_for_each_entry (trav, &entries->list, list) {
-                if (strcmp (trav->d_name, ".") == 0)
-                        continue;
-                if (strcmp (trav->d_name, "..") == 0)
-                        continue;
-
-                lookup_frame = copy_frame (frame);
-
-                if (!lookup_frame) {
-                        /* out of memory, let the rmdir fail
-                           (as non-empty, unfortunately) */
-                        goto err;
-                }
-
-                lookup_local = dht_local_init (lookup_frame, NULL, NULL,
-                                               GF_FOP_LOOKUP);
-                if (!lookup_local) {
-                        goto err;
-                }
-
-                lookup_frame->local = lookup_local;
-                lookup_local->main_frame = frame;
-                lookup_local->hashed_subvol = src;
+        lookup_local = dht_local_init(lookup_frame, NULL, NULL, GF_FOP_LOOKUP);
+        if (!lookup_local) {
+            goto err;
+        }
 
-                build_ret = dht_build_child_loc (this, &lookup_local->loc,
-                                                 &local->loc, trav->d_name);
-                if (build_ret != 0)
-                        goto err;
+        lookup_frame->local = lookup_local;
+        lookup_local->main_frame = frame;
+        lookup_local->hashed_subvol = src;
 
-                gf_uuid_copy (lookup_local->loc.gfid, trav->d_stat.ia_gfid);
+        build_ret = dht_build_child_loc(this, &lookup_local->loc, &local->loc,
+                                        trav->d_name);
+        if (build_ret != 0)
+            goto err;
 
-                gf_uuid_unparse(lookup_local->loc.gfid, gfid);
+        gf_uuid_copy(lookup_local->loc.gfid, trav->d_stat.ia_gfid);
 
-                gf_msg_trace (this->name, 0,
-                              "looking up %s on subvolume %s, gfid = %s",
-                              lookup_local->loc.path, src->name, gfid);
+        gf_uuid_unparse(lookup_local->loc.gfid, gfid);
 
-                subvol = dht_linkfile_subvol (this, NULL, &trav->d_stat,
-                                              trav->dict);
-                if (!subvol) {
+        gf_msg_trace(this->name, 0, "looking up %s on subvolume %s, gfid = %s",
+                     lookup_local->loc.path, src->name, gfid);
 
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_INVALID_LINKFILE,
-                                "Linkfile does not have link subvolume. "
-                                "path = %s, gfid = %s",
-                                lookup_local->loc.path, gfid);
+        subvol = dht_linkfile_subvol(this, NULL, &trav->d_stat, trav->dict);
+        if (!subvol || (subvol == src)) {
+            /* we need to delete the linkto file if it does not have a
+             * valid subvol or it points to itself.
+             */
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_INVALID_LINKFILE,
+                   "Linkfile does not have link subvolume. "
+                   "path = %s, gfid = %s",
+                   lookup_local->loc.path, gfid);
 
-                        gf_msg_debug (this->name, 0,
-                                      "looking up %s on subvol %s, gfid = %s",
-                                      lookup_local->loc.path, src->name, gfid);
+            gf_msg_debug(this->name, 0, "looking up %s on subvol %s, gfid = %s",
+                         lookup_local->loc.path, src->name, gfid);
 
-                        STACK_WIND_COOKIE (lookup_frame, dht_rmdir_lookup_cbk,
-                                           src, src, src->fops->lookup,
-                                           &lookup_local->loc, xattrs);
-                } else {
-                        gf_msg_debug (this->name, 0,
-                                      "Looking up linkfile target %s on "
-                                      " subvol %s, gfid = %s",
-                                      lookup_local->loc.path, subvol->name,
-                                      gfid);
-
-                        STACK_WIND (lookup_frame, dht_rmdir_cached_lookup_cbk,
-                                    subvol, subvol->fops->lookup,
-                                    &lookup_local->loc, xattrs);
-                }
-                ret++;
+            STACK_WIND_COOKIE(lookup_frame, dht_rmdir_lookup_cbk, src, src,
+                              src->fops->lookup, &lookup_local->loc, xattrs);
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "Looking up linkfile target %s on "
+                         " subvol %s, gfid = %s",
+                         lookup_local->loc.path, subvol->name, gfid);
 
-                lookup_frame = NULL;
-                lookup_local = NULL;
+            STACK_WIND(lookup_frame, dht_rmdir_cached_lookup_cbk, subvol,
+                       subvol->fops->lookup, &lookup_local->loc, xattrs);
         }
+        ret++;
 
-        if (xattrs)
-                dict_unref (xattrs);
+        lookup_frame = NULL;
+        lookup_local = NULL;
+    }
 
-        return ret;
+    if (xattrs)
+        dict_unref(xattrs);
+
+    return ret;
 err:
-        if (xattrs)
-                dict_unref (xattrs);
+    if (xattrs)
+        dict_unref(xattrs);
 
-        if (lookup_frame)
-                DHT_STACK_DESTROY (lookup_frame);
+    if (lookup_frame)
+        DHT_STACK_DESTROY(lookup_frame);
 
-        /* Handle the case where the wound calls have unwound before the
-         * loop processing is done
-         */
+    /* Handle the case where the wound calls have unwound before the
+     * loop processing is done
+     */
 
-        LOCK (&frame->lock);
-        {
-                local->op_ret = -1;
-                local->op_errno = ENOTEMPTY;
+    LOCK(&frame->lock);
+    {
+        local->op_ret = -1;
+        local->op_errno = ENOTEMPTY;
 
-                local->call_cnt -= (count - ret);
-                if (!local->call_cnt)
-                        unwind = _gf_true;
-        }
-        UNLOCK (&frame->lock);
+        local->call_cnt -= (count - ret);
+        if (!local->call_cnt)
+            unwind = _gf_true;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!unwind) {
-                return ret;
-        }
-        return 0;
+    if (!unwind) {
+        return ret;
+    }
+    return 0;
 }
 
-
-
 /*
  * No more entries on this subvol. Proceed to the actual rmdir operation.
  */
 
-void
-dht_rmdir_readdirp_done (call_frame_t *readdirp_frame, xlator_t *this)
+static int
+dht_rmdir_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, gf_dirent_t *entries,
+                       dict_t *xdata)
 {
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    int ret = 0;
+    char *path = NULL;
 
-        call_frame_t      *main_frame    = NULL;
-        dht_local_t       *main_local         = NULL;
-        dht_local_t       *local         = NULL;
-        int                this_call_cnt = 0;
-
+    local = frame->local;
+    prev = cookie;
+    src = prev;
 
-        local = readdirp_frame->local;
-        main_frame = local->main_frame;
-        main_local = main_frame->local;
-
-        /* At least one readdirp failed.
-         * This is a bit hit or miss - if readdirp failed on more than
-         * one subvol, we don't know which error is returned.
+    if (op_ret > 2) {
+        /* dht_rmdir_is_subvol_empty() may free the frame,
+         * copy path for logging.
          */
-        if (local->op_ret == -1) {
-                main_local->op_ret = local->op_ret;
-                main_local->op_errno = local->op_errno;
-        }
-
-        this_call_cnt = dht_frame_return (main_frame);
-
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_do (main_frame, this);
-
+        path = gf_strdup(local->loc.path);
 
-        DHT_STACK_DESTROY (readdirp_frame);
-}
-
-
-
-int
-dht_rmdir_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, gf_dirent_t *entries,
-                        dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *src = NULL;
-        int           ret = 0;
-
-
-        local = frame->local;
-        prev  = cookie;
-        src   = prev;
-
-        if (op_ret > 2) {
-                ret = dht_rmdir_is_subvol_empty (frame, this, entries, src);
-
-                switch (ret) {
-                case 0: /* non linkfiles exist */
-                        gf_msg_trace (this->name, 0,
-                                      "readdir on %s for %s returned %d "
-                                      "entries", prev->name,
-                                      local->loc.path, op_ret);
-                        local->op_ret = -1;
-                        local->op_errno = ENOTEMPTY;
-                        goto done;
-                default:
-                        /* @ret number of linkfiles are getting unlinked */
-                        gf_msg_trace (this->name, 0,
-                                      "readdir on %s for %s found %d "
-                                      "linkfiles", prev->name,
-                                      local->loc.path, ret);
-                        break;
-                }
+        ret = dht_rmdir_is_subvol_empty(frame, this, entries, src);
 
+        switch (ret) {
+            case 0: /* non linkfiles exist */
+                gf_msg_trace(this->name, 0,
+                             "readdir on %s for %s returned %d "
+                             "entries",
+                             prev->name, local->loc.path, op_ret);
+                local->op_ret = -1;
+                local->op_errno = ENOTEMPTY;
+                break;
+            default:
+                /* @ret number of linkfiles are getting unlinked */
+                gf_msg_trace(this->name, 0,
+                             "readdir on %s for %s found %d "
+                             "linkfiles",
+                             prev->name, path, ret);
+                break;
         }
+    }
 
+    /* readdirp failed or no linkto files were found on this subvol */
+    if (!ret)
+        dht_rmdir_readdirp_done(frame, this);
 
-        if (ret) {
-                return 0;
-        }
-
-done:
-        /* readdirp failed or no linkto files were found on this subvol */
-
-        dht_rmdir_readdirp_done (frame, this);
-        return 0;
+    GF_FREE(path);
+    return 0;
 }
 
-/* Keep sending readdirp on the subvol until it returns no more entries
- * It is possible that not all entries will fit in a single readdirp in which
- * case the rmdir will keep failing with ENOTEMPTY
- */
-
-int
-dht_rmdir_readdirp_do (call_frame_t *readdirp_frame, xlator_t *this)
-{
-        dht_local_t *local  = NULL;
-
-        local = readdirp_frame->local;
+static int
+dht_rmdir_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
+    int ret = 0;
+    dht_conf_t *conf = this->private;
+    dict_t *dict = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *readdirp_local = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    int cnt = 0;
+
+    local = frame->local;
+    prev = cookie;
+
+    this_call_cnt = dht_frame_return(frame);
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-        if (local->op_ret == -1) {
-                /* there is no point doing another readdirp on this
-                 * subvol . */
-                dht_rmdir_readdirp_done (readdirp_frame, this);
-                return 0;
+        gf_msg_debug(this->name, op_errno,
+                     "opendir on %s for %s failed, "
+                     "gfid = %s,",
+                     prev->name, local->loc.path, gfid);
+        if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
+            local->op_ret = -1;
+            local->op_errno = op_errno;
         }
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (readdirp_frame, dht_rmdir_readdirp_cbk,
-                           local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->readdirp,
-                           local->fd, 4096, 0, local->xattr);
-
-
+    if (!is_last_call(this_call_cnt))
         return 0;
 
-}
+    if (local->op_ret == -1)
+        goto err;
 
+    fd_bind(fd);
 
-int
-dht_rmdir_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
-{
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev          = NULL;
-        int           ret           = 0;
-        dht_conf_t   *conf          = this->private;
-        dict_t       *dict          = NULL;
-        int           i             = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-        dht_local_t  *readdirp_local = NULL;
-        call_frame_t *readdirp_frame = NULL;
-        int           cnt           = 0;
+    dict = dict_new();
+    if (!dict) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        goto err;
+    }
 
-        local = frame->local;
-        prev  = cookie;
+    ret = dict_set_uint32(dict, conf->link_xattr_name, 256);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: Failed to set dictionary value:key = %s", local->loc.path,
+               conf->link_xattr_name);
 
+    cnt = local->call_cnt = conf->subvolume_cnt;
 
-        this_call_cnt = dht_frame_return (frame);
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
-
-                gf_msg_debug (this->name, op_errno,
-                              "opendir on %s for %s failed, "
-                              "gfid = %s,",
-                              prev->name, local->loc.path, gfid);
-                if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                }
-                goto err;
-        }
-
-        if (!is_last_call (this_call_cnt))
-                return 0;
-
-        if (local->op_ret == -1)
-                goto err;
+    /* Create a separate frame per subvol as we might need
+     * to resend readdirp multiple times to get all the
+     * entries.
+     */
 
-        fd_bind (fd);
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        readdirp_frame = copy_frame(frame);
 
-        dict = dict_new ();
-        if (!dict) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                goto err;
+        if (!readdirp_frame) {
+            cnt--;
+            /* Reduce the local->call_cnt as well */
+            (void)dht_frame_return(frame);
+            continue;
         }
 
-        ret = dict_set_uint32 (dict, conf->link_xattr_name, 256);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value:key = %s",
-                        local->loc.path, conf->link_xattr_name);
-
-        cnt = local->call_cnt = conf->subvolume_cnt;
-
+        readdirp_local = dht_local_init(readdirp_frame, &local->loc, local->fd,
+                                        0);
 
-        /* Create a separate frame per subvol as we might need
-         * to resend readdirp multiple times to get all the
-         * entries.
-         */
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-
-                readdirp_frame = copy_frame (frame);
-
-                if (!readdirp_frame) {
-                        cnt--;
-                        /* Reduce the local->call_cnt as well */
-                        dht_frame_return (frame);
-                        continue;
-                }
-
-                readdirp_local = dht_local_init (readdirp_frame, &local->loc,
-                                                 local->fd, 0);
-
-                if (!readdirp_local) {
-                        DHT_STACK_DESTROY (readdirp_frame);
-                        cnt--;
-                        /* Reduce the local->call_cnt as well */
-                        dht_frame_return (frame);
-                        continue;
-                }
-                readdirp_local->main_frame = frame;
-                readdirp_local->op_ret = 0;
-                readdirp_local->xattr = dict_ref (dict);
-                /* overload this field to save the subvol info */
-                readdirp_local->hashed_subvol = conf->subvolumes[i];
-
-                STACK_WIND_COOKIE (readdirp_frame, dht_rmdir_readdirp_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->readdirp,
-                                   readdirp_local->fd, 4096, 0,
-                                   readdirp_local->xattr);
+        if (!readdirp_local) {
+            DHT_STACK_DESTROY(readdirp_frame);
+            cnt--;
+            /* Reduce the local->call_cnt as well */
+            dht_frame_return(frame);
+            continue;
         }
+        readdirp_local->main_frame = frame;
+        readdirp_local->op_ret = 0;
+        readdirp_local->xattr = dict_ref(dict);
+        /* overload this field to save the subvol info */
+        readdirp_local->hashed_subvol = conf->subvolumes[i];
 
-        if (dict)
-                dict_unref (dict);
+        STACK_WIND_COOKIE(readdirp_frame, dht_rmdir_readdirp_cbk,
+                          conf->subvolumes[i], conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->readdirp,
+                          readdirp_local->fd, 4096, 0, readdirp_local->xattr);
+    }
 
-        /* Could not wind readdirp to any subvol */
+    if (dict)
+        dict_unref(dict);
 
-        if (!cnt)
-                goto err;
+    /* Could not wind readdirp to any subvol */
 
-        return 0;
+    if (!cnt)
+        goto err;
+
+    return 0;
 
 err:
-        if (is_last_call (this_call_cnt)) {
-                dht_rmdir_do (frame, this);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_rmdir_do(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-           dict_t *xdata)
-{
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_RMDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->call_cnt = conf->subvolume_cnt;
-        local->op_ret   = 0;
-        local->fop_succeeded = 0;
-
-        local->flags = flags;
-
-        local->fd = fd_create (local->loc.inode, frame->root->pid);
-        if (!local->fd) {
-
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        if (flags) {
-                return dht_rmdir_do (frame, this);
-        }
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_rmdir_opendir_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->opendir,
-                                   loc, local->fd, NULL);
-        }
-
-        return 0;
+dht_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_RMDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->call_cnt = conf->subvolume_cnt;
+    local->op_ret = 0;
+    local->fop_succeeded = 0;
+
+    local->flags = flags;
+
+    local->fd = fd_create(local->loc.inode, frame->root->pid);
+    if (!local->fd) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (flags) {
+        return dht_rmdir_do(frame, this);
+    }
+    if (xdata) {
+        xattr_req = dict_ref(xdata);
+    } else {
+        xattr_req = dict_new();
+    }
+    if (xattr_req) {
+        ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+        /* If parallel-readdir is enabled, this is required
+         * to handle stale linkto files in the directory
+         * being deleted. If this fails, log an error but
+         * do not prevent the operation.
+         */
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, 0, "%s: failed to set key %s",
+                   loc->path, conf->link_xattr_name);
+        }
+    } else {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0, "%s: failed to set key %s",
+               loc->path, conf->link_xattr_name);
+    }
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_rmdir_opendir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->opendir, loc, local->fd,
+                          xattr_req);
+    }
+
+    if (xattr_req) {
+        dict_unref(xattr_req);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rmdir, frame, -1, op_errno,
-                          NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_entrylk_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int
+dht_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        DHT_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata);
-        return 0;
+    DHT_STACK_UNWIND(entrylk, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 /* TODO
@@ -8868,769 +10603,789 @@ dht_entrylk_cbk (call_frame_t *frame, void *cookie,
  * as described in the bug 1311002.
  */
 int
-dht_entrylk (call_frame_t *frame, xlator_t *this,
-             const char *volume, loc_t *loc, const char *basename,
-             entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
-{
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_ENTRYLK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+dht_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_uuid_unparse(loc->gfid, gfid);
+    local = dht_local_init(frame, loc, NULL, GF_FOP_ENTRYLK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s, "
-                              "gfid = %s", loc->path, gfid);
-                op_errno = EINVAL;
-                goto err;
-        }
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_uuid_unparse(loc->gfid, gfid);
 
-        local->call_cnt = 1;
+        gf_msg_debug(this->name, 0,
+                     "no cached subvolume for path=%s, "
+                     "gfid = %s",
+                     loc->path, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_entrylk_cbk,
-                    subvol, subvol->fops->entrylk,
-                    volume, loc, basename, cmd, type, xdata);
+    local->call_cnt = 1;
 
-        return 0;
+    STACK_WIND(frame, dht_entrylk_cbk, subvol, subvol->fops->entrylk, volume,
+               loc, basename, cmd, type, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (entrylk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(entrylk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_fentrylk_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int
+dht_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        DHT_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fentrylk, frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_fentrylk (call_frame_t *frame, xlator_t *this,
-              const char *volume, fd_t *fd, const char *basename,
-              entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+dht_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             const char *basename, entrylk_cmd cmd, entrylk_type type,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        char               gfid[GF_UUID_BUF_SIZE] = {0};
-
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO(fd->inode, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
 
-        gf_uuid_unparse(fd->inode->gfid, gfid);
+    gf_uuid_unparse(fd->inode->gfid, gfid);
 
-        subvol = dht_subvol_get_cached (this, fd->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "No cached subvolume for fd=%p,"
-                              " gfid = %s", fd, gfid);
-                op_errno = EINVAL;
-                goto err;
-        }
+    subvol = dht_subvol_get_cached(this, fd->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0,
+                     "No cached subvolume for fd=%p,"
+                     " gfid = %s",
+                     fd, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_fentrylk_cbk,
-                    subvol, subvol->fops->fentrylk,
-                    volume, fd, basename, cmd, type, xdata);
+    STACK_WIND(frame, dht_fentrylk_cbk, subvol, subvol->fops->fentrylk, volume,
+               fd, basename, cmd, type, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fentrylk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fentrylk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int32_t
-dht_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int32_t
+dht_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local                   = NULL;
-        int           this_call_cnt           = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret < 0 && op_errno != ENOTCONN) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret < 0 && op_errno != ENOTCONN) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (ipc, frame, local->op_ret, local->op_errno,
-                                  NULL);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(ipc, frame, local->op_ret, local->op_errno, NULL);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-dht_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+dht_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        dht_local_t  *local    = NULL;
-        int           op_errno = EINVAL;
-        dht_conf_t   *conf     = NULL;
-        int           call_cnt = 0;
-        int           i        = 0;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int i = 0;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
 
-        if (op != GF_IPC_TARGET_UPCALL)
-                goto wind_default;
+    if (op != GF_IPC_TARGET_UPCALL)
+        goto wind_default;
 
-        VALIDATE_OR_GOTO (this->private, err);
-        conf = this->private;
+    VALIDATE_OR_GOTO(this->private, err);
+    conf = this->private;
 
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_IPC);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_IPC);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        call_cnt        = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        if (xdata) {
-                if (dict_set_int8 (xdata, conf->xattr_name, 0) < 0)
-                        goto err;
-        }
+    if (xdata) {
+        if (dict_set_int8(xdata, conf->xattr_name, 0) < 0)
+            goto err;
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND (frame, dht_ipc_cbk, conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->ipc, op, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND(frame, dht_ipc_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->ipc, op, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (ipc, frame, -1, op_errno, NULL);
+    DHT_STACK_UNWIND(ipc, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 
 wind_default:
-        STACK_WIND (frame, default_ipc_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->ipc, op, xdata);
-        return 0;
+    STACK_WIND(frame, default_ipc_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ipc, op, xdata);
+    return 0;
 }
 
-
 int
-dht_forget (xlator_t *this, inode_t *inode)
+dht_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t        ctx_int = 0;
-        dht_inode_ctx_t *ctx    = NULL;
-        dht_layout_t *layout = NULL;
+    uint64_t ctx_int = 0;
+    dht_inode_ctx_t *ctx = NULL;
+    dht_layout_t *layout = NULL;
 
-        inode_ctx_del (inode, this, &ctx_int);
+    inode_ctx_del(inode, this, &ctx_int);
 
-        if (!ctx_int)
-                return 0;
+    if (!ctx_int)
+        return 0;
 
-        ctx = (dht_inode_ctx_t *) (long) ctx_int;
+    ctx = (dht_inode_ctx_t *)(long)ctx_int;
 
-        layout = ctx->layout;
-        ctx->layout = NULL;
-        dht_layout_unref (this, layout);
-        GF_FREE (ctx);
+    layout = ctx->layout;
+    ctx->layout = NULL;
+    dht_layout_unref(this, layout);
+    GF_FREE(ctx);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_notify (xlator_t *this, int event, void *data, ...)
-{
-        xlator_t                *subvol = NULL;
-        int                      cnt    = -1;
-        int                      i      = -1;
-        dht_conf_t              *conf   = NULL;
-        int                      ret    = -1;
-        int                      propagate = 0;
-
-        int                      had_heard_from_all = 0;
-        int                      have_heard_from_all = 0;
-        struct timeval           time = {0,};
-        gf_defrag_info_t        *defrag = NULL;
-        dict_t                  *dict   = NULL;
-        gf_defrag_type           cmd    = 0;
-        dict_t                  *output = NULL;
-        va_list                  ap;
-        dht_methods_t           *methods = NULL;
-        struct gf_upcall        *up_data = NULL;
-        struct gf_upcall_cache_invalidation *up_ci = NULL;
-
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-
-        methods = &(conf->methods);
-
-        /* had all subvolumes reported status once till now? */
-        had_heard_from_all = 1;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->last_event[i]) {
-                        had_heard_from_all = 0;
-                }
-        }
-
-        switch (event) {
+dht_notify(xlator_t *this, int event, void *data, ...)
+{
+    xlator_t *subvol = NULL;
+    int cnt = -1;
+    int i = -1;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int propagate = 0;
+
+    int had_heard_from_all = 0;
+    int have_heard_from_all = 0;
+    gf_defrag_info_t *defrag = NULL;
+    dict_t *dict = NULL;
+    gf_defrag_type cmd = 0;
+    dict_t *output = NULL;
+    va_list ap;
+    struct gf_upcall *up_data = NULL;
+    struct gf_upcall_cache_invalidation *up_ci = NULL;
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+    /* had all subvolumes reported status once till now? */
+    had_heard_from_all = 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->last_event[i]) {
+            had_heard_from_all = 0;
+        }
+    }
+
+    switch (event) {
         case GF_EVENT_CHILD_UP:
-                subvol = data;
+            subvol = data;
 
-                conf->gen++;
+            conf->gen++;
 
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
+            }
 
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_UP bad "
-                                      "subvolume %s",
-                                      subvol->name);
-                        break;
-                }
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_UP bad "
+                             "subvolume %s",
+                             subvol->name);
+                break;
+            }
 
-                gettimeofday (&time, NULL);
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->subvolume_status[cnt] = 1;
-                        conf->last_event[cnt] = event;
-                        conf->subvol_up_time[cnt] = time.tv_sec;
-                }
-                UNLOCK (&conf->subvolume_lock);
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->subvolume_status[cnt] = 1;
+                conf->last_event[cnt] = event;
+                conf->subvol_up_time[cnt] = gf_time();
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                /* one of the node came back up, do a stat update */
-                dht_get_du_info_for_subvol (this, cnt);
+            /* one of the node came back up, do a stat update */
+            dht_get_du_info_for_subvol(this, cnt);
 
-                break;
+            break;
 
         case GF_EVENT_SOME_DESCENDENT_UP:
-                subvol = data;
-                conf->gen++;
-                propagate = 1;
+            subvol = data;
+            conf->gen++;
+            propagate = 1;
 
-                break;
+            break;
 
         case GF_EVENT_SOME_DESCENDENT_DOWN:
-                subvol = data;
-                propagate = 1;
+            subvol = data;
+            propagate = 1;
 
-                break;
+            break;
 
         case GF_EVENT_CHILD_DOWN:
-                subvol = data;
-
-                if (conf->assert_no_child_down) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_CHILD_DOWN,
-                                "Received CHILD_DOWN. Exiting");
-                        if (conf->defrag) {
-                                gf_defrag_stop (conf,
-                                                GF_DEFRAG_STATUS_FAILED, NULL);
-                        } else {
-                                kill (getpid(), SIGTERM);
-                        }
-                }
+            subvol = data;
 
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
-                }
-
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_DOWN bad "
-                                      "subvolume %s", subvol->name);
-                        break;
+            if (conf->assert_no_child_down) {
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_CHILD_DOWN,
+                       "Received CHILD_DOWN. Exiting");
+                if (conf->defrag) {
+                    gf_defrag_stop(conf, GF_DEFRAG_STATUS_FAILED, NULL);
+                } else {
+                    kill(getpid(), SIGTERM);
                 }
+            }
 
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->subvolume_status[cnt] = 0;
-                        conf->last_event[cnt] = event;
-                        conf->subvol_up_time[cnt] = 0;
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
-                UNLOCK (&conf->subvolume_lock);
+            }
 
-                for (i = 0; i < conf->subvolume_cnt; i++)
-                        if (conf->last_event[i] != event)
-                                event = GF_EVENT_SOME_DESCENDENT_DOWN;
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_DOWN bad "
+                             "subvolume %s",
+                             subvol->name);
                 break;
+            }
 
-        case GF_EVENT_CHILD_CONNECTING:
-                subvol = data;
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->subvolume_status[cnt] = 0;
+                conf->last_event[cnt] = event;
+                conf->subvol_up_time[cnt] = 0;
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
-                }
+            for (i = 0; i < conf->subvolume_cnt; i++)
+                if (conf->last_event[i] != event)
+                    event = GF_EVENT_SOME_DESCENDENT_DOWN;
+            break;
 
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_CONNECTING"
-                                      " bad subvolume %s",
-                                      subvol->name);
-                        break;
-                }
+        case GF_EVENT_CHILD_CONNECTING:
+            subvol = data;
 
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->last_event[cnt] = event;
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
-                UNLOCK (&conf->subvolume_lock);
+            }
 
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_CONNECTING"
+                             " bad subvolume %s",
+                             subvol->name);
                 break;
-        case GF_EVENT_VOLUME_DEFRAG:
-        {
-                if (!conf->defrag) {
-                        return ret;
-                }
-                defrag = conf->defrag;
+            }
 
-                dict = data;
-                va_start (ap, data);
-                output = va_arg (ap, dict_t*);
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->last_event[cnt] = event;
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                ret = dict_get_int32 (dict, "rebalance-command",
-                                      (int32_t*)&cmd);
-                if (ret) {
-                        va_end (ap);
-                        return ret;
-                }
-                LOCK (&defrag->lock);
-                {
-                        if (defrag->is_exiting)
-                                goto unlock;
-                        if ((cmd == GF_DEFRAG_CMD_STATUS) ||
-                            (cmd == GF_DEFRAG_CMD_STATUS_TIER) ||
-                            (cmd == GF_DEFRAG_CMD_DETACH_STATUS))
-                                gf_defrag_status_get (conf, output);
-                        else if (cmd == GF_DEFRAG_CMD_START_DETACH_TIER)
-                                gf_defrag_start_detach_tier(defrag);
-                        else if (cmd == GF_DEFRAG_CMD_DETACH_START)
-                                defrag->cmd = GF_DEFRAG_CMD_DETACH_START;
-                        else if (cmd == GF_DEFRAG_CMD_STOP ||
-                                 cmd == GF_DEFRAG_CMD_STOP_DETACH_TIER ||
-                                 cmd == GF_DEFRAG_CMD_DETACH_STOP)
-                                gf_defrag_stop (conf,
-                                                GF_DEFRAG_STATUS_STOPPED, output);
-                        else if (cmd == GF_DEFRAG_CMD_PAUSE_TIER)
-                                ret = gf_defrag_pause_tier (this, defrag);
-                        else if (cmd == GF_DEFRAG_CMD_RESUME_TIER)
-                                ret = gf_defrag_resume_tier (this, defrag);
-                }
-unlock:
-                UNLOCK (&defrag->lock);
-                va_end (ap);
+            break;
+        case GF_EVENT_VOLUME_DEFRAG: {
+            if (!conf->defrag) {
                 return ret;
-                break;
+            }
+            defrag = conf->defrag;
+
+            dict = data;
+            va_start(ap, data);
+            output = va_arg(ap, dict_t *);
+
+            ret = dict_get_int32(dict, "rebalance-command", (int32_t *)&cmd);
+            if (ret) {
+                va_end(ap);
+                return ret;
+            }
+            LOCK(&defrag->lock);
+            {
+                if (defrag->is_exiting)
+                    goto unlock;
+                if ((cmd == GF_DEFRAG_CMD_STATUS) ||
+                    (cmd == GF_DEFRAG_CMD_DETACH_STATUS))
+                    gf_defrag_status_get(conf, output);
+                else if (cmd == GF_DEFRAG_CMD_DETACH_START)
+                    defrag->cmd = GF_DEFRAG_CMD_DETACH_START;
+                else if (cmd == GF_DEFRAG_CMD_STOP ||
+                         cmd == GF_DEFRAG_CMD_DETACH_STOP)
+                    gf_defrag_stop(conf, GF_DEFRAG_STATUS_STOPPED, output);
+            }
+        unlock:
+            UNLOCK(&defrag->lock);
+            va_end(ap);
+            return ret;
+            break;
         }
         case GF_EVENT_UPCALL:
-                up_data = (struct gf_upcall *)data;
-                if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
-                        break;
-                up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
-
-                /* Since md-cache will be aggressively filtering lookups,
-                 * the stale layout issue will be more pronounced. Hence
-                 * when a layout xattr is changed by the rebalance process
-                 * notify all the md-cache clients to invalidate the existing
-                 * stat cache and send the lookup next time*/
-                if (up_ci->dict && dict_get (up_ci->dict, conf->xattr_name))
-                        up_ci->flags |= UP_EXPLICIT_LOOKUP;
-
-                /* TODO: Instead of invalidating iatt, update the new
-                 * hashed/cached subvolume in dht inode_ctx */
-                if (IS_DHT_LINKFILE_MODE (&up_ci->stat))
-                        up_ci->flags |= UP_EXPLICIT_LOOKUP;
-
-                propagate = 1;
+            up_data = (struct gf_upcall *)data;
+            if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
                 break;
+            up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
+
+            /* Since md-cache will be aggressively filtering lookups,
+             * the stale layout issue will be more pronounced. Hence
+             * when a layout xattr is changed by the rebalance process
+             * notify all the md-cache clients to invalidate the existing
+             * stat cache and send the lookup next time*/
+            if (up_ci->dict && dict_get(up_ci->dict, conf->xattr_name))
+                up_ci->flags |= UP_EXPLICIT_LOOKUP;
+
+            /* TODO: Instead of invalidating iatt, update the new
+             * hashed/cached subvolume in dht inode_ctx */
+            if (IS_DHT_LINKFILE_MODE(&up_ci->stat))
+                up_ci->flags |= UP_EXPLICIT_LOOKUP;
+
+            propagate = 1;
+            break;
         default:
-                propagate = 1;
-                break;
-        }
-
+            propagate = 1;
+            break;
+    }
+
+    /* have all subvolumes reported status once by now? */
+    have_heard_from_all = 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->last_event[i])
+            have_heard_from_all = 0;
+    }
+
+    /* if all subvols have reported status, no need to hide anything
+       or wait for anything else. Just propagate blindly */
+    if (have_heard_from_all) {
+        propagate = 1;
+    }
+
+    if (!had_heard_from_all && have_heard_from_all) {
+        static int run_defrag = 0;
+        /* This is the first event which completes aggregation
+           of events from all subvolumes. If at least one subvol
+           had come up, propagate CHILD_UP, but only this time
+        */
+        event = GF_EVENT_CHILD_DOWN;
 
-        /* have all subvolumes reported status once by now? */
-        have_heard_from_all = 1;
         for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->last_event[i])
-                        have_heard_from_all = 0;
-        }
-
-        /* if all subvols have reported status, no need to hide anything
-           or wait for anything else. Just propagate blindly */
-        if (have_heard_from_all) {
-                propagate = 1;
+            if (conf->last_event[i] == GF_EVENT_CHILD_UP) {
+                event = GF_EVENT_CHILD_UP;
+                break;
+            }
 
+            if (conf->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
+                event = GF_EVENT_CHILD_CONNECTING;
+                /* continue to check other events for CHILD_UP */
+            }
         }
 
-
-        if (!had_heard_from_all && have_heard_from_all) {
-                /* This is the first event which completes aggregation
-                   of events from all subvolumes. If at least one subvol
-                   had come up, propagate CHILD_UP, but only this time
-                */
-                event = GF_EVENT_CHILD_DOWN;
-
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->last_event[i] == GF_EVENT_CHILD_UP) {
-                                event = GF_EVENT_CHILD_UP;
-                                break;
-                        }
-
-                        if (conf->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
-                                event = GF_EVENT_CHILD_CONNECTING;
-                                /* continue to check other events for CHILD_UP */
-                        }
-                }
-
-                /* Rebalance is started with assert_no_child_down. So we do
-                 * not need to handle CHILD_DOWN event here.
-                 *
-                 * If there is a graph switch, we should not restart the
-                 * rebalance daemon. Use 'run_defrag' to indicate if the
-                 * thread has already started.
-                 */
-                 if (conf->defrag && !run_defrag) {
-                        if (methods->migration_needed(this)) {
-                                run_defrag = 1;
-                                ret = gf_thread_create(&conf->defrag->th,
-                                                       NULL,
-                                                       gf_defrag_start, this,
-                                                       "dhtdg");
-                                if (ret) {
-                                        GF_FREE (conf->defrag);
-                                        conf->defrag = NULL;
-                                        kill (getpid(), SIGTERM);
-                                }
-                        }
-                }
+        /* Rebalance is started with assert_no_child_down. So we do
+         * not need to handle CHILD_DOWN event here.
+         *
+         * If there is a graph switch, we should not restart the
+         * rebalance daemon. Use 'run_defrag' to indicate if the
+         * thread has already started.
+         */
+        if (conf->defrag && !run_defrag) {
+            run_defrag = 1;
+            ret = gf_thread_create(&conf->defrag->th, NULL, gf_defrag_start,
+                                   this, "dhtdg");
+            if (ret) {
+                GF_FREE(conf->defrag);
+                conf->defrag = NULL;
+                kill(getpid(), SIGTERM);
+            }
         }
+    }
 
-        ret = 0;
-        if (propagate)
-                ret = default_notify (this, event, data);
+    ret = 0;
+    if (propagate)
+        ret = default_notify(this, event, data);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_inode_ctx_layout_get (inode_t *inode, xlator_t *this, dht_layout_t **layout)
+dht_inode_ctx_layout_get(inode_t *inode, xlator_t *this, dht_layout_t **layout)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (!ret && ctx) {
-                if (ctx->layout) {
-                        if (layout)
-                                *layout = ctx->layout;
-                        ret = 0;
-                } else {
-                        ret = -1;
-                }
+    if (!ret && ctx) {
+        if (ctx->layout) {
+            if (layout)
+                *layout = ctx->layout;
+            ret = 0;
+        } else {
+            ret = -1;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-dht_log_new_layout_for_dir_selfheal (xlator_t *this, loc_t *loc,
-                                 dht_layout_t *layout)
-{
-
-        char                    string[2048] = {0};
-        char                  *output_string = NULL;
-        int                              len = 0;
-        int                              off = 0;
-        int                                i = 0;
-        gf_loglevel_t             log_level = gf_log_get_loglevel();
-        int                              ret = 0;
-        int                   max_string_len = 0;
+dht_log_new_layout_for_dir_selfheal(xlator_t *this, loc_t *loc,
+                                    dht_layout_t *layout)
+{
+    char string[2048] = {0};
+    char *output_string = NULL;
+    int len = 0;
+    int off = 0;
+    int i = 0;
+    gf_loglevel_t log_level = gf_log_get_loglevel();
+    int ret = 0;
+
+    if (log_level < GF_LOG_INFO)
+        return;
 
-        if (log_level < GF_LOG_INFO)
-                return;
+    if (!layout)
+        return;
 
-        if (!layout)
-                return;
+    if (!layout->cnt)
+        return;
 
-        if (!layout->cnt)
-                return;
+    if (!loc)
+        return;
 
-        if (!loc)
-                return;
+    if (!loc->path)
+        return;
 
-        if (!loc->path)
-                return;
+    ret = snprintf(string, sizeof(string), "Setting layout of %s with ",
+                   loc->path);
 
-        max_string_len = sizeof (string);
+    if (ret < 0)
+        return;
 
-        ret = snprintf (string, max_string_len, "Setting layout of %s with ",
-                        loc->path);
+    len += ret;
+
+    /* Calculation  of total length of the string required to calloc
+     * output_string. Log includes subvolume-name, start-range, end-range
+     * and err value.
+     *
+     * This log will help to debug cases where:
+     * a) Different processes set different layout of a directory.
+     * b) Error captured in lookup, which will be filled in layout->err
+     * (like ENOENT, ESTALE etc)
+     */
+
+    for (i = 0; i < layout->cnt; i++) {
+        ret = snprintf(string, sizeof(string),
+                       "[Subvol_name: %s, Err: %d , Start: "
+                       "0x%x, Stop: 0x%x, Hash: 0x%x], ",
+                       layout->list[i].xlator->name, layout->list[i].err,
+                       layout->list[i].start, layout->list[i].stop,
+                       layout->list[i].commit_hash);
 
         if (ret < 0)
-                return;
+            return;
 
         len += ret;
+    }
 
-       /* Calculation  of total length of the string required to calloc
-        * output_string. Log includes subvolume-name, start-range, end-range and
-        * err value.
-        *
-        * This log will help to debug cases where:
-        * a) Different processes set different layout of a directory.
-        * b) Error captured in lookup, which will be filled in layout->err
-        * (like ENOENT, ESTALE etc)
-        */
-
-        for (i = 0; i < layout->cnt; i++) {
-
-                ret  = snprintf (string, max_string_len,
-                                 "[Subvol_name: %s, Err: %d , Start: "
-                                 "%"PRIu32 " , Stop: %"PRIu32 " , Hash: %"
-                                 PRIu32 " ], ",
-                                 layout->list[i].xlator->name,
-                                 layout->list[i].err, layout->list[i].start,
-                                 layout->list[i].stop,
-                                 layout->list[i].commit_hash);
-
-                if (ret < 0)
-                        return;
+    len++;
 
-                len += ret;
+    output_string = GF_MALLOC(len + 1, gf_common_mt_char);
 
-        }
+    if (!output_string)
+        return;
 
-        len++;
+    ret = snprintf(output_string, len + 1, "Setting layout of %s with ",
+                   loc->path);
 
-        output_string = GF_CALLOC (len, sizeof (char), gf_common_mt_char);
+    if (ret < 0)
+        goto err;
 
-        if (!output_string)
-                return;
+    off += ret;
 
-        ret = snprintf (output_string, len, "Setting layout of %s with ",
-                        loc->path);
+    for (i = 0; i < layout->cnt; i++) {
+        ret = snprintf(output_string + off, len - off,
+                       "[Subvol_name: %s, Err: %d , Start: "
+                       "0x%x, Stop: 0x%x, Hash: 0x%x], ",
+                       layout->list[i].xlator->name, layout->list[i].err,
+                       layout->list[i].start, layout->list[i].stop,
+                       layout->list[i].commit_hash);
 
         if (ret < 0)
-                goto err;
+            goto err;
 
         off += ret;
+    }
 
-
-        for (i = 0; i < layout->cnt; i++) {
-
-                ret  =  snprintf (output_string + off, len - off,
-                                  "[Subvol_name: %s, Err: %d , Start: "
-                                  "%"PRIu32 " , Stop: %"PRIu32 " , Hash: %"
-                                  PRIu32  " ], ",
-                                  layout->list[i].xlator->name,
-                                  layout->list[i].err, layout->list[i].start,
-                                  layout->list[i].stop,
-                                  layout->list[i].commit_hash);
-
-                if (ret < 0)
-                        goto err;
-
-                off += ret;
-
-        }
-
-        gf_msg (this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_FIXED_LAYOUT,
-                "%s", output_string);
+    gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_FIXED_LAYOUT, "%s",
+           output_string);
 
 err:
-        GF_FREE (output_string);
+    GF_FREE(output_string);
 }
 
-int32_t dht_migration_get_dst_subvol(xlator_t *this, dht_local_t  *local)
+int32_t
+dht_migration_get_dst_subvol(xlator_t *this, dht_local_t *local)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!local)
-                goto out;
+    if (!local)
+        goto out;
 
-        local->rebalance.target_node =
-                dht_subvol_get_hashed (this, &local->loc);
+    local->rebalance.target_node = dht_subvol_get_hashed(this, &local->loc);
 
-        if (local->rebalance.target_node)
-                ret = 0;
+    if (local->rebalance.target_node)
+        ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-int32_t dht_migration_needed(xlator_t *this)
+/*
+This function should not be called more then once during a FOP
+handling path. It is valid only for for ops on files
+*/
+int32_t
+dht_set_local_rebalance(xlator_t *this, dht_local_t *local, struct iatt *stbuf,
+                        struct iatt *prebuf, struct iatt *postbuf,
+                        dict_t *xdata)
 {
-        gf_defrag_info_t        *defrag = NULL;
-        dht_conf_t              *conf   = NULL;
-        int                      ret = 0;
+    if (!local)
+        return -1;
 
-        conf = this->private;
+    if (local->rebalance.set) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_REBAL_STRUCT_SET,
+               "local->rebalance already set");
+    }
 
-        GF_VALIDATE_OR_GOTO ("dht", conf, out);
-        GF_VALIDATE_OR_GOTO ("dht", conf->defrag, out);
+    if (stbuf)
+        memcpy(&local->rebalance.stbuf, stbuf, sizeof(struct iatt));
 
-        defrag = conf->defrag;
+    if (prebuf)
+        memcpy(&local->rebalance.prebuf, prebuf, sizeof(struct iatt));
 
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
-            (defrag->cmd != GF_DEFRAG_CMD_START_DETACH_TIER))
-                ret = 1;
+    if (postbuf)
+        memcpy(&local->rebalance.postbuf, postbuf, sizeof(struct iatt));
 
-out:
-        return ret;
-}
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
+    local->rebalance.set = 1;
 
+    return 0;
+}
 
-/*
-This function should not be called more then once during a FOP
-handling path. It is valid only for for ops on files
-*/
-int32_t dht_set_local_rebalance (xlator_t *this, dht_local_t *local,
-                                 struct iatt *stbuf,
-                                 struct iatt *prebuf, struct iatt *postbuf,
-                                 dict_t *xdata)
+int32_t
+dht_release(xlator_t *this, fd_t *fd)
 {
+    return dht_fd_ctx_destroy(this, fd);
+}
 
-        if (!local)
-                return -1;
-
-        if (local->rebalance.set) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_REBAL_STRUCT_SET,
-                        "local->rebalance already set");
-        }
+static int
+dht_pt_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, inode_t *inode, struct iatt *stbuf,
+                 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
 
+    local = frame->local;
 
-        if (stbuf)
-                memcpy (&local->rebalance.stbuf, stbuf, sizeof (struct iatt));
+    if (!op_ret) {
+        dht_layout_set(this, inode, local->layout);
+    }
 
-        if (prebuf)
-                memcpy (&local->rebalance.prebuf, prebuf, sizeof (struct iatt));
+    DHT_STACK_UNWIND(mkdir, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, NULL);
 
-        if (postbuf)
-                memcpy (&local->rebalance.postbuf, postbuf,
-                        sizeof (struct iatt));
+    return 0;
+}
 
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+int32_t
+dht_pt_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+             mode_t umask, dict_t *xdata)
+{
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    bool free_xdata = false;
+    int ret = 0;
+    int op_errno = 0;
+    int32_t *disk_layout_p = NULL;
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = dht_layout_new(this, conf->subvolume_cnt);
+    if (!layout)
+        goto wind;
+
+    local->layout = layout;
+
+    if (!xdata) {
+        xdata = dict_new();
+        if (!xdata)
+            goto wind;
+        free_xdata = true;
+    }
+
+    /*Set the xlator or the following will crash*/
+    layout->list[0].xlator = conf->subvolumes[0];
+
+    dht_selfheal_layout_new_directory(frame, loc, layout);
+
+    dht_disk_layout_extract(this, layout, 0, &disk_layout_p);
+
+    ret = dict_set_bin(xdata, conf->xattr_name, disk_layout_p, 4 * 4);
+    if (ret) {
+        gf_msg("dht", GF_LOG_DEBUG, EINVAL, DHT_MSG_DICT_SET_FAILED,
+               "dht layout dict set failed");
+    }
+wind:
+    STACK_WIND(frame, dht_pt_mkdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata);
+    if (free_xdata)
+        dict_unref(xdata);
+    return 0;
 
-        local->rebalance.set = 1;
+err:
+    op_errno = local ? local->op_errno : op_errno;
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-gf_boolean_t
-dht_is_tier_xlator (xlator_t *this)
+static int
+dht_pt_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
+    dht_conf_t *conf = NULL;
 
-        if (strcmp (this->type, "cluster/tier") == 0)
-                return _gf_true;
-        return _gf_false;
-}
+    conf = this->private;
+    dict_del(xattr, conf->xattr_name);
+    dict_del(xattr, conf->mds_xattr_key);
+    dict_del(xattr, conf->commithash_xattr_name);
 
-int32_t
-dht_release (xlator_t *this, fd_t *fd)
-{
-        return dht_fd_ctx_destroy (this, fd);
+    if (frame->root->pid >= 0) {
+        GF_REMOVE_INTERNAL_XATTR("trusted.glusterfs.quota*", xattr);
+        GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
+    }
+
+    DHT_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
+    return 0;
 }
 
 int
-dht_remove_stale_linkto (void *data)
+dht_pt_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *key, dict_t *xdata)
 {
-        call_frame_t    *frame = NULL;
-        dht_local_t     *local = NULL;
-        xlator_t        *this  = NULL;
-        dict_t          *xdata_in = NULL;
-        int             ret = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", data, out);
+    STACK_WIND(frame, dht_pt_getxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getxattr, loc, key, xdata);
+    return 0;
+}
 
-        frame = data;
-        local = frame->local;
-        this = frame->this;
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        GF_VALIDATE_OR_GOTO ("dht", local->link_subvol, out);
+static int
+dht_pt_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+{
+    dht_conf_t *conf = NULL;
 
-        xdata_in = dict_new ();
-        if (!xdata_in)
-                goto out;
+    conf = this->private;
+    dict_del(xattr, conf->xattr_name);
 
-        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file (xdata_in);
-        if (ret) {
-                  gf_msg (this->name, GF_LOG_WARNING, -ret, 0,
-                                "Failed to set keys for stale linkto"
-                                "deletion on path %s", local->loc.path);
-                  goto out;
-        }
+    if (frame->root->pid >= 0) {
+        GF_REMOVE_INTERNAL_XATTR("trusted.glusterfs.quota*", xattr);
+        GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
+    }
 
-        ret = syncop_unlink (local->link_subvol, &local->loc, xdata_in, NULL);
-        if (ret) {
-                  gf_msg (this->name, GF_LOG_WARNING, -ret, 0,
-                                "Removal of linkto failed"
-                                " on path %s at subvol %s",
-                                local->loc.path, local->link_subvol->name);
+    DHT_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
+    return 0;
+}
 
-        }
-out:
-        if (xdata_in)
-                dict_unref (xdata_in);
-        return ret;
+int
+dht_pt_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+                 dict_t *xdata)
+{
+    STACK_WIND(frame, dht_pt_fgetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fgetxattr, fd, key, xdata);
+    return 0;
 }
 
+/* The job of this function is to check if all the xlators have updated
+ * error in the layout. */
 int
-dht_remove_stale_linkto_cbk (int ret, call_frame_t *sync_frame, void *data)
+dht_dir_layout_error_check(xlator_t *this, inode_t *inode)
 {
-        DHT_STACK_DESTROY (sync_frame);
-        return 0;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+
+    layout = dht_layout_get(this, inode);
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err == 0) {
+            return 0;
+        }
+    }
+
+    /* Returning the first xlator error as all xlators have errors */
+    return layout->list[0].err;
 }
diff --git a/xlators/cluster/dht/src/dht-common.h b/xlators/cluster/dht/src/dht-common.h
index 60560600a02..fe0dc3db34a 100644
--- a/xlators/cluster/dht/src/dht-common.h
+++ b/xlators/cluster/dht/src/dht-common.h
@@ -9,146 +9,148 @@
 */
 
 #include <regex.h>
-#include <signal.h>
-#include <fnmatch.h>
 
 #include "dht-mem-types.h"
 #include "dht-messages.h"
-#include "call-stub.h"
+#include <glusterfs/call-stub.h>
 #include "libxlator.h"
-#include "syncop.h"
-#include "refcount.h"
-#include "timer.h"
+#include <glusterfs/syncop.h>
+#include <glusterfs/refcount.h>
+#include <glusterfs/timer.h>
 #include "protocol-common.h"
+#include <glusterfs/glusterfs-acl.h>
 
 #ifndef _DHT_H
 #define _DHT_H
 
-#define GF_XATTR_FIX_LAYOUT_KEY         "distribute.fix.layout"
-#define GF_XATTR_TIER_LAYOUT_FIXED_KEY  "trusted.tier.fix.layout.complete"
-#define GF_XATTR_FILE_MIGRATE_KEY       "trusted.distribute.migrate-data"
-#define GF_DHT_LOOKUP_UNHASHED_ON       1
-#define GF_DHT_LOOKUP_UNHASHED_AUTO     2
-#define DHT_PATHINFO_HEADER             "DISTRIBUTE:"
-#define DHT_FILE_MIGRATE_DOMAIN         "dht.file.migrate"
+#define GF_XATTR_FIX_LAYOUT_KEY "distribute.fix.layout"
+#define GF_XATTR_FILE_MIGRATE_KEY "trusted.distribute.migrate-data"
+#define DHT_MDS_STR "mds"
+#define GF_DHT_LOOKUP_UNHASHED_OFF 0
+#define GF_DHT_LOOKUP_UNHASHED_ON 1
+#define GF_DHT_LOOKUP_UNHASHED_AUTO 2
+#define DHT_PATHINFO_HEADER "DISTRIBUTE:"
+#define DHT_FILE_MIGRATE_DOMAIN "dht.file.migrate"
 /* Layout synchronization */
-#define DHT_LAYOUT_HEAL_DOMAIN          "dht.layout.heal"
+#define DHT_LAYOUT_HEAL_DOMAIN "dht.layout.heal"
 /* Namespace synchronization */
-#define DHT_ENTRY_SYNC_DOMAIN           "dht.entry.sync"
-#define TIERING_MIGRATION_KEY           "tiering.migration"
-#define DHT_LAYOUT_HASH_INVALID         1
-#define MAX_REBAL_THREADS               sysconf(_SC_NPROCESSORS_ONLN)
+#define DHT_ENTRY_SYNC_DOMAIN "dht.entry.sync"
+#define DHT_LAYOUT_HASH_INVALID 1
+#define MAX_REBAL_THREADS sysconf(_SC_NPROCESSORS_ONLN)
 
-#define DHT_DIR_STAT_BLOCKS          8
-#define DHT_DIR_STAT_SIZE            4096
+#define DHT_DIR_STAT_BLOCKS 8
+#define DHT_DIR_STAT_SIZE 4096
 
-#include <fnmatch.h>
+/* Virtual xattr for subvols status */
 
-/* Array to hold custom xattr keys
-*/
-extern char *xattrs_to_heal[];
+#define DHT_SUBVOL_STATUS_KEY "dht.subvol.status"
+
+/* Virtual xattrs for debugging */
+
+#define DHT_DBG_HASHED_SUBVOL_PATTERN "dht.file.hashed-subvol.*"
+#define DHT_DBG_HASHED_SUBVOL_KEY "dht.file.hashed-subvol."
 
 /* Rebalance nodeuuid flags */
-#define REBAL_NODEUUID_MINE   0x01
+#define REBAL_NODEUUID_MINE 0x01
 
-typedef int (*dht_selfheal_dir_cbk_t) (call_frame_t *frame, void *cookie,
-                                       xlator_t     *this,
-                                       int32_t       op_ret, int32_t op_errno,
-                                       dict_t       *xdata);
-typedef int (*dht_defrag_cbk_fn_t) (xlator_t        *this, xlator_t *dst_node,
-                                    call_frame_t    *frame, int ret);
+typedef int (*dht_selfheal_dir_cbk_t)(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int32_t op_ret,
+                                      int32_t op_errno, dict_t *xdata);
+typedef int (*dht_defrag_cbk_fn_t)(xlator_t *this, xlator_t *dst_node,
+                                   call_frame_t *frame, int ret);
 
-typedef int (*dht_refresh_layout_unlock) (call_frame_t *frame, xlator_t *this,
+typedef int (*dht_refresh_layout_unlock)(call_frame_t *frame, xlator_t *this,
                                          int op_ret, int invoke_cbk);
 
-typedef int (*dht_refresh_layout_done_handle) (call_frame_t *frame);
+typedef int (*dht_refresh_layout_done_handle)(call_frame_t *frame);
 
 struct dht_layout {
-        int                spread_cnt;  /* layout spread count per directory,
-                                           is controlled by 'setxattr()' with
-                                           special key */
-        int                cnt;
-        int                preset;
-        /*
-         * The last *configuration* state for which this directory was known
-         * to be in balance.  The corresponding vol_commit_hash changes
-         * whenever bricks are added or removed.  This value changes when a
-         * (full) rebalance is complete.  If they match, it's safe to assume
-         * that every file is where it should be and there's no need to do
-         * lookups for files elsewhere.  If they don't, then we have to do a
-         * global lookup to be sure.
-         */
-        uint32_t           commit_hash;
-        /*
-         * The *runtime* state of the volume, changes when connections to
-         * bricks are made or lost.
-         */
-        int                gen;
-        int                type;
-        int                ref; /* use with dht_conf_t->layout_lock */
-        gf_boolean_t       search_unhashed;
-        struct {
-                int        err;   /* 0 = normal
-                                     -1 = dir exists and no xattr
-                                     >0 = dir lookup failed with errno
-                                  */
-                uint32_t   start;
-                uint32_t   stop;
-                uint32_t   commit_hash;
-                xlator_t  *xlator;
-        } list[];
+    int spread_cnt; /* layout spread count per directory,
+                       is controlled by 'setxattr()' with
+                       special key */
+    int cnt;
+    int preset;
+    /*
+     * The last *configuration* state for which this directory was known
+     * to be in balance.  The corresponding vol_commit_hash changes
+     * whenever bricks are added or removed.  This value changes when a
+     * (full) rebalance is complete.  If they match, it's safe to assume
+     * that every file is where it should be and there's no need to do
+     * lookups for files elsewhere.  If they don't, then we have to do a
+     * global lookup to be sure.
+     */
+    uint32_t commit_hash;
+    /*
+     * The *runtime* state of the volume, changes when connections to
+     * bricks are made or lost.
+     */
+    int gen;
+    int type;
+    gf_atomic_t ref; /* use with dht_conf_t->layout_lock */
+    uint32_t search_unhashed;
+    struct {
+        int err; /* 0 = normal
+                    -1 = dir exists and no xattr
+                    >0 = dir lookup failed with errno
+                 */
+        uint32_t start;
+        uint32_t stop;
+        uint32_t commit_hash;
+        xlator_t *xlator;
+    } list[];
 };
-typedef struct dht_layout  dht_layout_t;
+typedef struct dht_layout dht_layout_t;
 
 struct dht_stat_time {
-        uint32_t        atime;
-        uint32_t        atime_nsec;
-        uint32_t        ctime;
-        uint32_t        ctime_nsec;
-        uint32_t        mtime;
-        uint32_t        mtime_nsec;
+    uint32_t atime;
+    uint32_t atime_nsec;
+    uint32_t ctime;
+    uint32_t ctime_nsec;
+    uint32_t mtime;
+    uint32_t mtime_nsec;
 };
 
 typedef struct dht_stat_time dht_stat_time_t;
 
 struct dht_inode_ctx {
-        dht_layout_t    *layout;
-        dht_stat_time_t  time;
-        xlator_t        *lock_subvol;
+    dht_layout_t *layout;
+    dht_stat_time_t time;
+    xlator_t *lock_subvol;
+    xlator_t *mds_subvol; /* This is only used for directories */
 };
 
 typedef struct dht_inode_ctx dht_inode_ctx_t;
 
-
 typedef enum {
-        DHT_HASH_TYPE_DM,
-        DHT_HASH_TYPE_DM_USER,
+    DHT_HASH_TYPE_DM,
+    DHT_HASH_TYPE_DM_USER,
 } dht_hashfn_type_t;
 
 typedef enum {
-        DHT_INODELK,
-        DHT_ENTRYLK,
+    DHT_INODELK,
+    DHT_ENTRYLK,
 } dht_lock_type_t;
 
 /* rebalance related */
 struct dht_rebalance_ {
-        xlator_t            *from_subvol;
-        xlator_t            *target_node;
-        off_t                offset;
-        size_t               size;
-        int32_t              flags;
-        int                  count;
-        struct iobref       *iobref;
-        struct iovec        *vector;
-        struct iatt          stbuf;
-        struct iatt          prebuf;
-        struct iatt          postbuf;
-        dht_defrag_cbk_fn_t  target_op_fn;
-        dict_t              *xdata;
-        dict_t              *xattr;
-        int32_t              set;
-        struct gf_flock      flock;
-        int                  lock_cmd;
+    xlator_t *from_subvol;
+    xlator_t *target_node;
+    off_t offset;
+    size_t size;
+    int32_t flags;
+    int count;
+    struct iobref *iobref;
+    struct iovec *vector;
+    struct iatt stbuf;
+    struct iatt prebuf;
+    struct iatt postbuf;
+    dht_defrag_cbk_fn_t target_op_fn;
+    dict_t *xdata;
+    dict_t *xattr;
+    dict_t *dict;
+    struct gf_flock flock;
+    int32_t set;
+    int lock_cmd;
 };
 
 /**
@@ -156,60 +158,62 @@ struct dht_rebalance_ {
  * events
  **/
 typedef enum {
-        qdstatfs_action_OFF = 0,
-        qdstatfs_action_REPLACE,
-        qdstatfs_action_NEGLECT,
-        qdstatfs_action_COMPARE,
+    qdstatfs_action_OFF = 0,
+    qdstatfs_action_REPLACE,
+    qdstatfs_action_NEGLECT,
+    qdstatfs_action_COMPARE,
 } qdstatfs_action_t;
 
 typedef enum {
-        FAIL_ON_ANY_ERROR,
-        IGNORE_ENOENT_ESTALE
+    REACTION_INVALID,
+    FAIL_ON_ANY_ERROR,
+    IGNORE_ENOENT_ESTALE,
+    IGNORE_ENOENT_ESTALE_EIO,
 } dht_reaction_type_t;
 
 struct dht_skip_linkto_unlink {
-
-        gf_boolean_t    handle_valid_link;
-        int             opend_fd_count;
-        xlator_t        *hash_links_to;
-        uuid_t          cached_gfid;
-        uuid_t          hashed_gfid;
+    xlator_t *hash_links_to;
+    uuid_t cached_gfid;
+    uuid_t hashed_gfid;
+    int opend_fd_count;
+    gf_boolean_t handle_valid_link;
 };
 
 typedef struct {
-        xlator_t     *xl;
-        loc_t         loc;     /* contains/points to inode to lock on. */
-        short         type;    /* read/write lock.                     */
-        char         *domain;  /* Only locks within a single domain
-                                * contend with each other
-                                */
-        char         *basename; /* Required for entrylk */
-        gf_lkowner_t  lk_owner;
-        gf_boolean_t  locked;
+    xlator_t *xl;
+    loc_t loc;      /* contains/points to inode to lock on. */
+    char *domain;   /* Only locks within a single domain
+                     * contend with each other
+                     */
+    char *basename; /* Required for entrylk */
+    gf_boolean_t locked;
+    dht_reaction_type_t do_on_failure;
+    short type; /* read/write lock.                     */
+    gf_lkowner_t lk_owner;
 } dht_lock_t;
 
 /* The lock structure represents inodelk. */
 typedef struct {
-        fop_inodelk_cbk_t   inodelk_cbk;
-        dht_lock_t        **locks;
-        int                 lk_count;
-        dht_reaction_type_t reaction;
-
-        /* whether locking failed on _any_ of the "locks" above */
-        int                 op_ret;
-        int                 op_errno;
+    fop_inodelk_cbk_t inodelk_cbk;
+    dht_lock_t **locks;
+    int lk_count;
+    dht_reaction_type_t reaction;
+
+    /* whether locking failed on _any_ of the "locks" above */
+    int op_ret;
+    int op_errno;
 } dht_ilock_wrap_t;
 
 /* The lock structure represents entrylk. */
 typedef struct {
-        fop_entrylk_cbk_t   entrylk_cbk;
-        dht_lock_t        **locks;
-        int                 lk_count;
-        dht_reaction_type_t reaction;
-
-        /* whether locking failed on _any_ of the "locks" above */
-        int                 op_ret;
-        int                 op_errno;
+    fop_entrylk_cbk_t entrylk_cbk;
+    dht_lock_t **locks;
+    int lk_count;
+    dht_reaction_type_t reaction;
+
+    /* whether locking failed on _any_ of the "locks" above */
+    int op_ret;
+    int op_errno;
 } dht_elock_wrap_t;
 
 /* The first member of dht_dir_transaction_t should be of type dht_ilock_wrap_t.
@@ -218,1195 +222,1163 @@ typedef struct {
  * lock[0].ns.parent_layout (like in dht_local_wipe).
  */
 typedef union {
-        union {
-                 dht_ilock_wrap_t my_layout;
-                 dht_ilock_wrap_t parent_layout;
-        } layout;
-        struct dht_namespace {
-                dht_ilock_wrap_t parent_layout;
-                dht_elock_wrap_t directory_ns;
-                fop_entrylk_cbk_t ns_cbk;
-        } ns;
+    union {
+        dht_ilock_wrap_t my_layout;
+        dht_ilock_wrap_t parent_layout;
+    } layout;
+    struct dht_namespace {
+        dht_ilock_wrap_t parent_layout;
+        dht_elock_wrap_t directory_ns;
+        fop_entrylk_cbk_t ns_cbk;
+    } ns;
 } dht_dir_transaction_t;
 
-typedef
-int (*dht_selfheal_layout_t)(call_frame_t *frame, loc_t *loc,
-                             dht_layout_t *layout);
-
-typedef
-gf_boolean_t (*dht_need_heal_t)(call_frame_t *frame, dht_layout_t **inmem,
-                                dht_layout_t **ondisk);
+typedef int (*dht_selfheal_layout_t)(call_frame_t *frame, loc_t *loc,
+                                     dht_layout_t *layout);
 
-typedef struct {
-        uint64_t                 blocks_used;
-        uint64_t                 pblocks_used;
-        uint64_t                 files_used;
-        uint64_t                 pfiles_used;
-        uint64_t                 unhashed_blocks_used;
-        uint64_t                 unhashed_pblocks_used;
-        uint64_t                 unhashed_files_used;
-        uint64_t                 unhashed_pfiles_used;
-        uint64_t                 unhashed_fsid;
-        uint64_t                 hashed_fsid;
-} tier_statvfs_t;
+typedef gf_boolean_t (*dht_need_heal_t)(call_frame_t *frame,
+                                        dht_layout_t **inmem,
+                                        dht_layout_t **ondisk);
 
 struct dht_local {
-        int                      call_cnt;
-        loc_t                    loc;
-        loc_t                    loc2;
-        int                      op_ret;
-        int                      op_errno;
-        int                      layout_mismatch;
-        /* Use stbuf as the postbuf, when we require both
-         * pre and post attrs */
-        struct iatt              stbuf;
-        struct iatt              prebuf;
-        struct iatt              preoldparent;
-        struct iatt              postoldparent;
-        struct iatt              preparent;
-        struct iatt              postparent;
-        struct statvfs           statvfs;
-        tier_statvfs_t           tier_statvfs;
-        fd_t                    *fd;
-        inode_t                 *inode;
-        dict_t                  *params;
-        dict_t                  *xattr;
-        dict_t                  *xattr_req;
-        dht_layout_t            *layout;
-        size_t                   size;
-        ino_t                    ia_ino;
-        xlator_t                *src_hashed, *src_cached;
-        xlator_t                *dst_hashed, *dst_cached;
-        xlator_t                *cached_subvol;
-        xlator_t                *hashed_subvol;
-        char                     need_selfheal;
-        int                      file_count;
-        int                      dir_count;
-        call_frame_t            *main_frame;
-        int                      fop_succeeded;
-        struct {
-                fop_mknod_cbk_t  linkfile_cbk;
-                struct iatt      stbuf;
-                loc_t            loc;
-                inode_t         *inode;
-                dict_t          *xattr;
-                xlator_t        *srcvol;
-        } linkfile;
-        struct {
-                uint32_t                hole_cnt;
-                uint32_t                overlaps_cnt;
-                uint32_t                down;
-                uint32_t                misc;
-                dht_selfheal_dir_cbk_t  dir_cbk;
-                dht_selfheal_layout_t   healer;
-                dht_need_heal_t         should_heal;
-                gf_boolean_t            force_mkdir;
-                dht_layout_t           *layout, *refreshed_layout;
-        } selfheal;
-
-        dht_refresh_layout_unlock              refresh_layout_unlock;
-        dht_refresh_layout_done_handle         refresh_layout_done;
-
-        uint32_t                 uid;
-        uint32_t                 gid;
-
-        /* needed by nufa */
-        int32_t flags;
-        mode_t  mode;
-        dev_t   rdev;
-        mode_t  umask;
-
-        /* need for file-info */
-        char   *xattr_val;
-        char   *key;
-
-        /* which xattr request? */
-        char xsel[256];
-        int32_t alloc_len;
-
-        /* gfid related */
-        uuid_t  gfid;
-
-        /* flag used to make sure we need to return estale in
-           {lookup,revalidate}_cbk */
-        char return_estale;
-        char need_lookup_everywhere;
-
-        glusterfs_fop_t      fop;
-
-        gf_boolean_t     linked;
-        xlator_t        *link_subvol;
-
-        struct dht_rebalance_ rebalance;
-        xlator_t        *first_up_subvol;
-
-        gf_boolean_t     quota_deem_statfs;
-
-        gf_boolean_t     added_link;
-        gf_boolean_t     is_linkfile;
-
-        struct dht_skip_linkto_unlink  skip_unlink;
-
-        dht_dir_transaction_t lock[2], *current;
-
-        short           lock_type;
-
-        call_stub_t *stub;
-        int32_t      parent_disk_layout[4];
-
-        /* To hold dentries of readdir spawning across subvols */
-        gf_dirent_t   entries;
-        size_t        filled;
-
-        /* rename rollback */
-        int    *ret_cache ;
-
-        /* fd open check */
-        gf_boolean_t fd_checked;
+    loc_t loc;
+    loc_t loc2;
+    int call_cnt;
+    int op_ret;
+    int op_errno;
+    int layout_mismatch;
+    /* Use stbuf as the postbuf, when we require both
+     * pre and post attrs */
+    struct iatt stbuf;
+    struct iatt mds_stbuf;
+    struct iatt prebuf;
+    struct iatt preoldparent;
+    struct iatt postoldparent;
+    struct iatt preparent;
+    struct iatt postparent;
+    struct statvfs statvfs;
+    fd_t *fd;
+    inode_t *inode;
+    dict_t *params;
+    dict_t *xattr;
+    dict_t *mds_xattr;
+    dict_t *xdata; /* dict used to save xdata response by xattr fop */
+    dict_t *xattr_req;
+    dht_layout_t *layout;
+    size_t size;
+    ino_t ia_ino;
+    xlator_t *src_hashed, *src_cached;
+    xlator_t *dst_hashed, *dst_cached;
+    xlator_t *cached_subvol;
+    xlator_t *hashed_subvol;
+    xlator_t *mds_subvol; /* This is use for dir only */
+    int file_count;
+    int dir_count;
+    call_frame_t *main_frame;
+    int fop_succeeded;
+    struct {
+        fop_mknod_cbk_t linkfile_cbk;
+        struct iatt stbuf;
+        loc_t loc;
+        inode_t *inode;
+        dict_t *xattr;
+        xlator_t *srcvol;
+    } linkfile;
+    struct {
+        uint32_t hole_cnt;
+        uint32_t overlaps_cnt;
+        uint32_t down;
+        uint32_t misc;
+        dht_selfheal_dir_cbk_t dir_cbk;
+        dht_selfheal_layout_t healer;
+        dht_need_heal_t should_heal;
+        dht_layout_t *layout, *refreshed_layout;
+        uint32_t missing_cnt;
+        gf_boolean_t force_mkdir;
+    } selfheal;
+
+    dht_refresh_layout_unlock refresh_layout_unlock;
+    dht_refresh_layout_done_handle refresh_layout_done;
+
+    uint32_t uid;
+    uint32_t gid;
+    pid_t pid;
+
+    glusterfs_fop_t fop;
+
+    /* need for file-info */
+    char *xattr_val;
+    char *key;
+
+    /* needed by nufa */
+    int32_t flags;
+    mode_t mode;
+    dev_t rdev;
+    mode_t umask;
+
+    /* which xattr request? */
+    char xsel[256];
+    int32_t alloc_len;
+
+    /* gfid related */
+    uuid_t gfid;
+    uuid_t gfid_req;
+
+    xlator_t *link_subvol;
+
+    struct dht_rebalance_ rebalance;
+    xlator_t *first_up_subvol;
+
+    struct dht_skip_linkto_unlink skip_unlink;
+
+    dht_dir_transaction_t lock[2], *current;
+
+    /* inodelks during filerename for backward compatibility */
+    dht_lock_t **rename_inodelk_backward_compatible;
+
+    call_stub_t *stub;
+    int32_t parent_disk_layout[4];
+
+    /* rename rollback */
+    int *ret_cache;
+
+    loc_t loc2_copy;
+
+    int rename_inodelk_bc_count;
+    /* This is use only for directory operation */
+    int32_t valid;
+    int32_t mds_heal_fresh_lookup;
+    short lock_type;
+    char need_selfheal;
+    char need_xattr_heal;
+    char need_attrheal;
+    /* flag used to make sure we need to return estale in
+       {lookup,revalidate}_cbk */
+    char return_estale;
+    char need_lookup_everywhere;
+    /* fd open check */
+    gf_boolean_t fd_checked;
+    gf_boolean_t linked;
+    gf_boolean_t added_link;
+    gf_boolean_t is_linkfile;
+    gf_boolean_t quota_deem_statfs;
+    gf_boolean_t heal_layout;
+    gf_boolean_t locked;
+    gf_boolean_t dont_create_linkto;
+    gf_boolean_t gfid_missing;
 };
 typedef struct dht_local dht_local_t;
 
 /* du - disk-usage */
 struct dht_du {
-        double   avail_percent;
-        double   avail_inodes;
-        uint64_t avail_space;
-        uint32_t log;
-        uint32_t chunks;
-        uint32_t total_blocks;
-        uint32_t avail_blocks;
-        uint32_t frsize; /*fragment size*/
+    double avail_percent;
+    double avail_inodes;
+    uint64_t avail_space;
+    uint32_t log;
+    uint32_t chunks;
+    uint32_t total_blocks;
+    uint32_t avail_blocks;
+    uint32_t frsize; /*fragment size*/
 };
 typedef struct dht_du dht_du_t;
 
 enum gf_defrag_type {
-        GF_DEFRAG_CMD_NONE = 0,
-        GF_DEFRAG_CMD_START = 1,
-        GF_DEFRAG_CMD_STOP = 1 + 1,
-        GF_DEFRAG_CMD_STATUS = 1 + 2,
-        GF_DEFRAG_CMD_START_LAYOUT_FIX = 1 + 3,
-        GF_DEFRAG_CMD_START_FORCE = 1 + 4,
-        GF_DEFRAG_CMD_START_TIER = 1 + 5,
-        GF_DEFRAG_CMD_STATUS_TIER = 1 + 6,
-        GF_DEFRAG_CMD_START_DETACH_TIER = 1 + 7,
-        GF_DEFRAG_CMD_STOP_DETACH_TIER = 1 + 8,
-        GF_DEFRAG_CMD_PAUSE_TIER = 1 + 9,
-        GF_DEFRAG_CMD_RESUME_TIER = 1 + 10,
-        GF_DEFRAG_CMD_DETACH_STATUS = 1 + 11,
-        GF_DEFRAG_CMD_DETACH_START = 1 + 12,
-        GF_DEFRAG_CMD_DETACH_STOP = 1 + 13,
-        /* new labels are used so it will help
-         * while removing old labels by easily differentiating
-         */
+    GF_DEFRAG_CMD_NONE = 0,
+    GF_DEFRAG_CMD_START = 1,
+    GF_DEFRAG_CMD_STOP = 1 + 1,
+    GF_DEFRAG_CMD_STATUS = 1 + 2,
+    GF_DEFRAG_CMD_START_LAYOUT_FIX = 1 + 3,
+    GF_DEFRAG_CMD_START_FORCE = 1 + 4,
+    GF_DEFRAG_CMD_DETACH_STATUS = 1 + 11,
+    GF_DEFRAG_CMD_DETACH_START = 1 + 13,
+    GF_DEFRAG_CMD_DETACH_COMMIT = 1 + 14,
+    GF_DEFRAG_CMD_DETACH_COMMIT_FORCE = 1 + 15,
+    GF_DEFRAG_CMD_DETACH_STOP = 1 + 16,
+    /* new labels are used so it will help
+     * while removing old labels by easily differentiating.
+     * A few labels are added so that the count remains same
+     * between this enum and the ones on the xdr file.
+     * different values for the same enum cause errors and
+     * confusion.
+     */
 };
 typedef enum gf_defrag_type gf_defrag_type;
 
 enum gf_defrag_status_t {
-        GF_DEFRAG_STATUS_NOT_STARTED,
-        GF_DEFRAG_STATUS_STARTED,
-        GF_DEFRAG_STATUS_STOPPED,
-        GF_DEFRAG_STATUS_COMPLETE,
-        GF_DEFRAG_STATUS_FAILED,
-        GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED,
-        GF_DEFRAG_STATUS_LAYOUT_FIX_STOPPED,
-        GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE,
-        GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED,
+    GF_DEFRAG_STATUS_NOT_STARTED,
+    GF_DEFRAG_STATUS_STARTED,
+    GF_DEFRAG_STATUS_STOPPED,
+    GF_DEFRAG_STATUS_COMPLETE,
+    GF_DEFRAG_STATUS_FAILED,
+    GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED,
+    GF_DEFRAG_STATUS_LAYOUT_FIX_STOPPED,
+    GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE,
+    GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED,
 };
 typedef enum gf_defrag_status_t gf_defrag_status_t;
 
 typedef struct gf_defrag_pattern_list gf_defrag_pattern_list_t;
 
 struct gf_defrag_pattern_list {
-        char                       path_pattern[256];
-        uint64_t                   size;
-        gf_defrag_pattern_list_t  *next;
+    char path_pattern[256];
+    uint64_t size;
+    gf_defrag_pattern_list_t *next;
 };
 
 struct dht_container {
-        union {
-                struct list_head             list;
-                struct {
-                        struct _gf_dirent_t *next;
-                        struct _gf_dirent_t *prev;
-                };
+    union {
+        struct list_head list;
+        struct {
+            struct _gf_dirent_t *next;
+            struct _gf_dirent_t *prev;
         };
-        gf_dirent_t     *df_entry;
-        xlator_t        *this;
-        loc_t           *parent_loc;
-        dict_t          *migrate_data;
-        int             local_subvol_index;
+    };
+    gf_dirent_t *df_entry;
+    xlator_t *this;
+    loc_t *parent_loc;
+    dict_t *migrate_data;
+    int local_subvol_index;
 };
 
-typedef enum tier_mode_ {
-        TIER_MODE_NONE = 0,
-        TIER_MODE_TEST,
-        TIER_MODE_WM
-} tier_mode_t;
-
-typedef enum tier_pause_state_ {
-        TIER_RUNNING = 0,
-        TIER_REQUEST_PAUSE,
-        TIER_PAUSED
-} tier_pause_state_t;
-
-/* This Structure is only used in tiering fixlayout */
-typedef struct gf_tier_fix_layout_arg {
-        xlator_t                *this;
-        dict_t                  *fix_layout;
-        pthread_t               thread_id;
-} gf_tier_fix_layout_arg_t;
-
-typedef struct gf_tier_conf {
-        int                          is_tier;
-        int                          watermark_hi;
-        int                          watermark_low;
-        int                          watermark_last;
-        unsigned long                block_size;
-        fsblkcnt_t                   blocks_total;
-        fsblkcnt_t                   blocks_used;
-        int                          percent_full;
-        uint64_t                     max_migrate_bytes;
-        int                          max_migrate_files;
-        int                          query_limit;
-        tier_mode_t                  mode;
-        /* These flags are only used for tier-compact */
-        gf_boolean_t                 compact_active;
-        /* These 3 flags are set to true when the client changes the */
-        /* compaction mode on the command line. */
-        /* When they are set, the daemon will trigger compaction as */
-        /* soon as possible to activate or deactivate compaction. */
-        /* If in the middle of a compaction, then the switches take */
-        /* effect on the next compaction, not the current one. */
-        /* If the user switches it off, we want to avoid needless */
-        /* compactions. */
-        /* If the user switches it on, they want to compact as soon */
-        /* as possible. */
-        gf_boolean_t                 compact_mode_switched;
-        gf_boolean_t                 compact_mode_switched_hot;
-        gf_boolean_t                 compact_mode_switched_cold;
-        int                          tier_max_promote_size;
-        int                          tier_promote_frequency;
-        int                          tier_demote_frequency;
-        int                          tier_compact_hot_frequency;
-        int                          tier_compact_cold_frequency;
-        uint64_t                     st_last_promoted_size;
-        uint64_t                     st_last_demoted_size;
-        tier_pause_state_t           pause_state;
-        struct synctask             *pause_synctask;
-        gf_timer_t                  *pause_timer;
-        pthread_mutex_t              pause_mutex;
-        int                          promote_in_progress;
-        int                          demote_in_progress;
-        /* This Structure is only used in tiering fixlayout */
-        gf_tier_fix_layout_arg_t     tier_fix_layout_arg;
-        /* Indicates the index of the first queryfile picked
-         * in the last cycle of promote or demote */
-        int32_t last_promote_qfile_index;
-        int32_t last_demote_qfile_index;
-        char                         volname[GD_VOLUME_NAME_MAX + 1];
-} gf_tier_conf_t;
-
 typedef struct nodeuuid_info {
-        char info; /* Set to 1 is this is my node's uuid*/
-        uuid_t uuid; /* Store the nodeuuid as well for debugging*/
+    char info;   /* Set to 1 is this is my node's uuid*/
+    uuid_t uuid; /* Store the nodeuuid as well for debugging*/
 } nodeuuid_info_t;
 
 typedef struct subvol_nodeuuids_info {
-        nodeuuid_info_t *elements;
-        int count;
+    nodeuuid_info_t *elements;
+    int count;
 } subvol_nodeuuids_info_t;
 
-
 struct gf_defrag_info_ {
-        uint64_t                     total_files;
-        uint64_t                     total_data;
-        uint64_t                     num_files_lookedup;
-        uint64_t                     total_failures;
-        uint64_t                     skipped;
-        uint64_t                     num_dirs_processed;
-        uint64_t                     size_processed;
-        gf_lock_t                    lock;
-        int                          cmd;
-        pthread_t                    th;
-        gf_defrag_status_t           defrag_status;
-        struct rpc_clnt             *rpc;
-        uint32_t                     connected;
-        uint32_t                     is_exiting;
-        pid_t                        pid;
-        inode_t                     *root_inode;
-        uuid_t                       node_uuid;
-        struct timeval               start_time;
-        gf_boolean_t                 stats;
-        uint32_t                     new_commit_hash;
-        gf_defrag_pattern_list_t    *defrag_pattern;
-        gf_tier_conf_t               tier_conf;
-
-        /*Data Tiering params for scanner*/
-        uint64_t                     total_files_promoted;
-        uint64_t                     total_files_demoted;
-        int                          write_freq_threshold;
-        int                          read_freq_threshold;
-
-        pthread_cond_t               parallel_migration_cond;
-        pthread_mutex_t              dfq_mutex;
-        pthread_cond_t               rebalance_crawler_alarm;
-        int32_t                      q_entry_count;
-        int32_t                      global_error;
-        struct  dht_container       *queue;
-        int32_t                      crawl_done;
-        int32_t                      abort;
-        int32_t                      wakeup_crawler;
-
-        /*Throttle params*/
-        /*stands for reconfigured thread count*/
-        int32_t                      recon_thread_count;
-        /*stands for current running thread count*/
-        int32_t                      current_thread_count;
-        pthread_cond_t               df_wakeup_thread;
-
-        /* lock migration flag */
-        gf_boolean_t                 lock_migration_enabled;
-
-        /* backpointer to make it easier to write functions for rebalance */
-        xlator_t                     *this;
-
-        pthread_cond_t               fc_wakeup_cond;
-        pthread_mutex_t              fc_mutex;
-
-
+    uint64_t total_files;
+    uint64_t total_data;
+    uint64_t num_files_lookedup;
+    uint64_t total_failures;
+    uint64_t skipped;
+    uint64_t num_dirs_processed;
+    uint64_t size_processed;
+    gf_lock_t lock;
+    pthread_t th;
+    struct rpc_clnt *rpc;
+    uint32_t connected;
+    uint32_t is_exiting;
+    pid_t pid;
+    int cmd;
+    inode_t *root_inode;
+    uuid_t node_uuid;
+    time_t start_time;
+    uint32_t new_commit_hash;
+    gf_defrag_status_t defrag_status;
+    gf_defrag_pattern_list_t *defrag_pattern;
+
+    pthread_cond_t parallel_migration_cond;
+    pthread_mutex_t dfq_mutex;
+    pthread_cond_t rebalance_crawler_alarm;
+    int32_t q_entry_count;
+    int32_t global_error;
+    struct dht_container *queue;
+    int32_t crawl_done;
+    int32_t abort;
+    int32_t wakeup_crawler;
+
+    /*Throttle params*/
+    /*stands for reconfigured thread count*/
+    int32_t recon_thread_count;
+    pthread_cond_t df_wakeup_thread;
+
+    /* backpointer to make it easier to write functions for rebalance */
+    xlator_t *this;
+
+    pthread_cond_t fc_wakeup_cond;
+    pthread_mutex_t fc_mutex;
+
+    /*stands for current running thread count*/
+    int32_t current_thread_count;
+
+    gf_boolean_t stats;
+    /* lock migration flag */
+    gf_boolean_t lock_migration_enabled;
 };
 
 typedef struct gf_defrag_info_ gf_defrag_info_t;
 
 struct dht_methods_s {
-        int32_t      (*migration_get_dst_subvol)(xlator_t *this,
-                                                 dht_local_t *local);
-        int32_t      (*migration_other)(xlator_t *this,
-                                        gf_defrag_info_t *defrag);
-        int32_t      (*migration_needed)(xlator_t *this);
-        xlator_t*    (*layout_search)(xlator_t *this,
-                                      dht_layout_t *layout,
-                                         const char *name);
+    int32_t (*migration_get_dst_subvol)(xlator_t *this, dht_local_t *local);
+    int32_t (*migration_other)(xlator_t *this, gf_defrag_info_t *defrag);
+    xlator_t *(*layout_search)(xlator_t *this, dht_layout_t *layout,
+                               const char *name);
 };
 
 typedef struct dht_methods_s dht_methods_t;
 
 struct dht_conf {
-        gf_lock_t      subvolume_lock;
-        int            subvolume_cnt;
-        xlator_t     **subvolumes;
-        char          *subvolume_status;
-        int           *last_event;
-        dht_layout_t **file_layouts;
-        dht_layout_t **dir_layouts;
-        unsigned int   search_unhashed;
-        gf_boolean_t   lookup_optimize;
-        int            gen;
-        dht_du_t      *du_stats;
-        double         min_free_disk;
-        double         min_free_inodes;
-        char           disk_unit;
-        int32_t        refresh_interval;
-        gf_boolean_t   unhashed_sticky_bit;
-        struct timeval last_stat_fetch;
-        gf_lock_t      layout_lock;
-        dict_t        *leaf_to_subvol;
-        void          *private;     /* Can be used by wrapper xlators over
-                                       dht */
-        gf_boolean_t   use_readdirp;
-        char           vol_uuid[UUID_SIZE + 1];
-        gf_boolean_t   assert_no_child_down;
-        time_t        *subvol_up_time;
-
-        /* This is the count used as the distribute layout for a directory */
-        /* Will be a global flag to control the layout spread count */
-        uint32_t       dir_spread_cnt;
-
-        /* to keep track of nodes which are decommissioned */
-        xlator_t     **decommissioned_bricks;
-        int            decommission_in_progress;
-        int            decommission_subvols_cnt;
-
-        /* defrag related */
-        gf_defrag_info_t *defrag;
-
-        /* Request to filter directory entries in readdir request */
-
-        gf_boolean_t    readdir_optimize;
-
-        /* Support regex-based name reinterpretation. */
-        regex_t         rsync_regex;
-        gf_boolean_t    rsync_regex_valid;
-        regex_t         extra_regex;
-        gf_boolean_t    extra_regex_valid;
-
-        /* Support variable xattr names. */
-        char            *xattr_name;
-        char            *link_xattr_name;
-        char            *commithash_xattr_name;
-        char            *wild_xattr_name;
-
-        /* Support size-weighted rebalancing (heterogeneous bricks). */
-        gf_boolean_t    do_weighting;
-        gf_boolean_t    randomize_by_gfid;
-        int             dthrottle;
-
-        dht_methods_t   methods;
-
-        struct mem_pool *lock_pool;
-
-        /*local subvol storage for rebalance*/
-        xlator_t       **local_subvols;
-        subvol_nodeuuids_info_t       *local_nodeuuids;
-        int32_t          local_subvols_cnt;
-
-        /*
-         * "Commit hash" for this volume topology.  Changed whenever bricks
-         * are added or removed.
-         */
-        uint32_t        vol_commit_hash;
-        gf_boolean_t    vch_forced;
-
-        /* lock migration */
-
-        gf_boolean_t    lock_migration_enabled;
-        gf_lock_t       lock;
-
-        /* Hard link handle requirement for migration triggered from client*/
-        synclock_t      link_lock;
+    xlator_t **subvolumes;
+    char *subvolume_status;
+    int *last_event;
+    dht_layout_t **file_layouts;
+    dht_layout_t **dir_layouts;
+    unsigned int search_unhashed;
+    int gen;
+    dht_du_t *du_stats;
+    double min_free_disk;
+    double min_free_inodes;
+    int subvolume_cnt;
+    int32_t refresh_interval;
+    gf_lock_t subvolume_lock;
+    time_t last_stat_fetch;
+    gf_lock_t layout_lock;
+    dict_t *leaf_to_subvol;
+    void *private; /* Can be used by wrapper xlators over
+                      dht */
+    time_t *subvol_up_time;
+
+    /* to keep track of nodes which are decommissioned */
+    xlator_t **decommissioned_bricks;
+    int decommission_in_progress;
+    int decommission_subvols_cnt;
+
+    /* defrag related */
+    gf_defrag_info_t *defrag;
+
+    /* Support regex-based name reinterpretation. */
+    regex_t rsync_regex;
+    regex_t extra_regex;
+
+    /* Support variable xattr names. */
+    char *xattr_name;
+    char *mds_xattr_key;
+    char *link_xattr_name;
+    char *commithash_xattr_name;
+    char *wild_xattr_name;
+
+    dht_methods_t methods;
+
+    struct mem_pool *lock_pool;
+
+    /*local subvol storage for rebalance*/
+    xlator_t **local_subvols;
+    subvol_nodeuuids_info_t *local_nodeuuids;
+    int32_t local_subvols_cnt;
+
+    int dthrottle;
+
+    /* Hard link handle requirement for migration triggered from client*/
+    synclock_t link_lock;
+
+    /* lock migration */
+    gf_lock_t lock;
+
+    /* This is the count used as the distribute layout for a directory */
+    /* Will be a global flag to control the layout spread count */
+    uint32_t dir_spread_cnt;
+
+    /*
+     * "Commit hash" for this volume topology.  Changed whenever bricks
+     * are added or removed.
+     */
+    uint32_t vol_commit_hash;
+
+    char vol_uuid[UUID_SIZE + 1];
+
+    char disk_unit;
 
+    gf_boolean_t lock_migration_enabled;
+
+    gf_boolean_t vch_forced;
+
+    gf_boolean_t use_fallocate;
+
+    gf_boolean_t force_migration;
+
+    gf_boolean_t lookup_optimize;
+
+    gf_boolean_t unhashed_sticky_bit;
+
+    gf_boolean_t assert_no_child_down;
+
+    gf_boolean_t use_readdirp;
+
+    /* Request to filter directory entries in readdir request */
+    gf_boolean_t readdir_optimize;
+
+    gf_boolean_t rsync_regex_valid;
+
+    gf_boolean_t extra_regex_valid;
+
+    /* Support size-weighted rebalancing (heterogeneous bricks). */
+    gf_boolean_t do_weighting;
+
+    gf_boolean_t randomize_by_gfid;
 };
 typedef struct dht_conf dht_conf_t;
 
 struct dht_dfoffset_ctx {
-        xlator_t       *this;
-        off_t           offset;
-        int32_t         readdir_done;
+    xlator_t *this;
+    off_t offset;
+    int32_t readdir_done;
 };
 typedef struct dht_dfoffset_ctx dht_dfoffset_ctx_t;
 
 struct dht_disk_layout {
-        uint32_t           cnt;
-        uint32_t           type;
-        struct {
-                uint32_t   start;
-                uint32_t   stop;
-        } list[1];
+    uint32_t cnt;
+    uint32_t type;
+    struct {
+        uint32_t start;
+        uint32_t stop;
+    } list[1];
 };
 typedef struct dht_disk_layout dht_disk_layout_t;
 
 typedef enum {
-        GF_DHT_MIGRATE_DATA,
-        GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS,
-        GF_DHT_MIGRATE_HARDLINK,
-        GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS
+    GF_DHT_MIGRATE_DATA,
+    GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS,
+    GF_DHT_MIGRATE_HARDLINK,
+    GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS
 } gf_dht_migrate_data_type_t;
 
 typedef enum {
-        GF_DHT_EQUAL_DISTRIBUTION,
-        GF_DHT_WEIGHTED_DISTRIBUTION
+    GF_DHT_EQUAL_DISTRIBUTION,
+    GF_DHT_WEIGHTED_DISTRIBUTION
 } dht_distribution_type_t;
 
 struct dir_dfmeta {
-        gf_dirent_t             *equeue;
-        dht_dfoffset_ctx_t      *offset_var;
-        struct list_head        **head;
-        struct list_head        **iterator;
-        int                     *fetch_entries;
+    gf_dirent_t *equeue;
+    dht_dfoffset_ctx_t *offset_var;
+    struct list_head **head;
+    struct list_head **iterator;
+    int *fetch_entries;
+    /* fds corresponding to local subvols only */
+    fd_t **lfd;
 };
 
 typedef struct dht_migrate_info {
-        xlator_t *src_subvol;
-        xlator_t *dst_subvol;
-        GF_REF_DECL;
+    xlator_t *src_subvol;
+    xlator_t *dst_subvol;
+    GF_REF_DECL;
 } dht_migrate_info_t;
 
-
-
 typedef struct dht_fd_ctx {
-        uint64_t opened_on_dst;
-        GF_REF_DECL;
+    uint64_t opened_on_dst;
+    GF_REF_DECL;
 } dht_fd_ctx_t;
 
-
 #define ENTRY_MISSING(op_ret, op_errno) (op_ret == -1 && op_errno == ENOENT)
 
-#define is_revalidate(loc) (dht_inode_ctx_layout_get (loc->inode, this, NULL) == 0)
+#define is_revalidate(loc)                                                     \
+    (dht_inode_ctx_layout_get((loc)->inode, this, NULL) == 0)
 
 #define is_last_call(cnt) (cnt == 0)
 
 #define DHT_MIGRATION_IN_PROGRESS 1
-#define DHT_MIGRATION_COMPLETED   2
+#define DHT_MIGRATION_COMPLETED 2
 
-#define check_is_linkfile(i,s,x,n) (IS_DHT_LINKFILE_MODE (s) && dict_get (x, n))
+#define check_is_linkfile(i, s, x, n)                                          \
+    (IS_DHT_LINKFILE_MODE(s) && dict_get(x, n))
 
-#define IS_DHT_MIGRATION_PHASE2(buf)  (                                 \
-                IA_ISREG ((buf)->ia_type) &&                            \
-                ((st_mode_from_ia ((buf)->ia_prot, (buf)->ia_type) &    \
-                  ~S_IFMT) == DHT_LINKFILE_MODE))
+#define IS_DHT_MIGRATION_PHASE2(buf)                                           \
+    (IA_ISREG((buf)->ia_type) &&                                               \
+     ((st_mode_from_ia((buf)->ia_prot, (buf)->ia_type) & ~S_IFMT) ==           \
+      DHT_LINKFILE_MODE))
 
-#define IS_DHT_MIGRATION_PHASE1(buf)  (                                 \
-                IA_ISREG ((buf)->ia_type) &&                            \
-                ((buf)->ia_prot.sticky == 1) &&                         \
-                ((buf)->ia_prot.sgid == 1))
+#define IS_DHT_MIGRATION_PHASE1(buf)                                           \
+    (IA_ISREG((buf)->ia_type) && ((buf)->ia_prot.sticky == 1) &&               \
+     ((buf)->ia_prot.sgid == 1))
 
-#define DHT_STRIP_PHASE1_FLAGS(buf)  do {                       \
-                if ((buf) && IS_DHT_MIGRATION_PHASE1(buf)) {    \
-                        (buf)->ia_prot.sticky = 0;              \
-                        (buf)->ia_prot.sgid = 0;                \
-                }                                               \
-        } while (0)
+#define DHT_STRIP_PHASE1_FLAGS(buf)                                            \
+    do {                                                                       \
+        if ((buf) && IS_DHT_MIGRATION_PHASE1(buf)) {                           \
+            (buf)->ia_prot.sticky = 0;                                         \
+            (buf)->ia_prot.sgid = 0;                                           \
+        }                                                                      \
+    } while (0)
 
-#define dht_inode_missing(op_errno) (op_errno == ENOENT || op_errno == ESTALE \
-                                     || op_errno == EIO) \
-/*Bad fix. Please revert the commit after fixing the bug 1329505*/
+#define dht_inode_missing(op_errno) (op_errno == ENOENT || op_errno == ESTALE)
 
-#define check_is_dir(i,s,x) (IA_ISDIR(s->ia_type))
+#define check_is_dir(i, s, x) (IA_ISDIR(s->ia_type))
 
 #define layout_is_sane(layout) ((layout) && (layout->cnt > 0))
 
-#define we_are_not_migrating(x)   ((x) == 1)
-
-#define DHT_STACK_UNWIND(fop, frame, params ...) do {           \
-                dht_local_t *__local = NULL;                    \
-                xlator_t    *__xl    = NULL;                    \
-                if (frame) {                                    \
-                        __xl         = frame->this;             \
-                        __local      = frame->local;            \
-                        frame->local = NULL;                    \
-                }                                               \
-                STACK_UNWIND_STRICT (fop, frame, params);       \
-                dht_local_wipe (__xl, __local);                 \
-        } while (0)
-
-#define DHT_STACK_DESTROY(frame) do {                   \
-                dht_local_t *__local = NULL;            \
-                xlator_t    *__xl    = NULL;            \
-                __xl                 = frame->this;     \
-                __local              = frame->local;    \
-                frame->local         = NULL;            \
-                STACK_DESTROY (frame->root);            \
-                dht_local_wipe (__xl, __local);         \
-        } while (0)
-
-#define DHT_UPDATE_TIME(ctx_sec, ctx_nsec, new_sec, new_nsec, inode, post) do {\
-                LOCK (&inode->lock);                                    \
-                {                                                       \
-                        if (ctx_sec == new_sec)                         \
-                                new_nsec = max (new_nsec, ctx_nsec);    \
-                        else if (ctx_sec > new_sec) {                   \
-                                new_sec = ctx_sec;                      \
-                                new_nsec = ctx_nsec;                    \
-                        }                                               \
-                        if (post) {                                     \
-                                ctx_sec = new_sec;                      \
-                                ctx_nsec = new_nsec;                    \
-                        }                                               \
-                }                                                       \
-                UNLOCK (&inode->lock);                                  \
-        } while (0)
-
-#define is_greater_time(a, an, b, bn) (((a) < (b)) || (((a) == (b)) && ((an) < (bn))))
-
-#define DHT_MARK_FOP_INTERNAL(xattr) do {                                      \
-                int tmp = -1;                                                  \
-                if (!xattr) {                                                  \
-                        xattr = dict_new ();                                   \
-                        if (!xattr)                                            \
-                                break;                                         \
-                }                                                              \
-                tmp = dict_set_str (xattr, GLUSTERFS_INTERNAL_FOP_KEY, "yes"); \
-                if (tmp) {                                                     \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,                   \
-                                DHT_MSG_DICT_SET_FAILED,                       \
-                                "Failed to set dictionary value: key = %s,"    \
-                                " path = %s", GLUSTERFS_INTERNAL_FOP_KEY,      \
-                                 local->loc.path);                             \
-                }                                                              \
-        } while (0)
-
-dht_layout_t                            *dht_layout_new (xlator_t *this, int cnt);
-dht_layout_t                            *dht_layout_get (xlator_t *this, inode_t *inode);
-dht_layout_t                            *dht_layout_for_subvol (xlator_t *this, xlator_t *subvol);
-xlator_t *dht_layout_search (xlator_t   *this, dht_layout_t *layout,
-                             const char *name);
+#define we_are_not_migrating(x) ((x) == 1)
+
+#define DHT_STACK_UNWIND(fop, frame, params...)                                \
+    do {                                                                       \
+        dht_local_t *__local = NULL;                                           \
+        xlator_t *__xl = NULL;                                                 \
+        if (frame) {                                                           \
+            __xl = frame->this;                                                \
+            __local = frame->local;                                            \
+            frame->local = NULL;                                               \
+        }                                                                      \
+        STACK_UNWIND_STRICT(fop, frame, params);                               \
+        dht_local_wipe(__xl, __local);                                         \
+    } while (0)
+
+#define DHT_STACK_DESTROY(frame)                                               \
+    do {                                                                       \
+        dht_local_t *__local = NULL;                                           \
+        xlator_t *__xl = NULL;                                                 \
+        __xl = frame->this;                                                    \
+        __local = frame->local;                                                \
+        frame->local = NULL;                                                   \
+        STACK_DESTROY(frame->root);                                            \
+        dht_local_wipe(__xl, __local);                                         \
+    } while (0)
+
+#define DHT_UPDATE_TIME(ctx_sec, ctx_nsec, new_sec, new_nsec, post)            \
+    do {                                                                       \
+        if (ctx_sec == new_sec)                                                \
+            new_nsec = max(new_nsec, ctx_nsec);                                \
+        else if (ctx_sec > new_sec) {                                          \
+            new_sec = ctx_sec;                                                 \
+            new_nsec = ctx_nsec;                                               \
+        }                                                                      \
+        if (post) {                                                            \
+            ctx_sec = new_sec;                                                 \
+            ctx_nsec = new_nsec;                                               \
+        }                                                                      \
+    } while (0)
+
+#define is_greater_time(a, an, b, bn)                                          \
+    (((a) < (b)) || (((a) == (b)) && ((an) < (bn))))
+
+#define DHT_MARK_FOP_INTERNAL(xattr)                                           \
+    do {                                                                       \
+        int tmp = -1;                                                          \
+        if (!xattr) {                                                          \
+            xattr = dict_new();                                                \
+            if (!xattr)                                                        \
+                break;                                                         \
+        }                                                                      \
+        tmp = dict_set_str(xattr, GLUSTERFS_INTERNAL_FOP_KEY, "yes");          \
+        if (tmp) {                                                             \
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,       \
+                   "Failed to set dictionary value: key = %s,"                 \
+                   " path = %s",                                               \
+                   GLUSTERFS_INTERNAL_FOP_KEY, local->loc.path);               \
+        }                                                                      \
+    } while (0)
+
+dht_layout_t *
+dht_layout_new(xlator_t *this, int cnt);
+dht_layout_t *
+dht_layout_get(xlator_t *this, inode_t *inode);
+dht_layout_t *
+dht_layout_for_subvol(xlator_t *this, xlator_t *subvol);
+xlator_t *
+dht_layout_search(xlator_t *this, dht_layout_t *layout, const char *name);
 int32_t
-dht_migration_get_dst_subvol(xlator_t *this, dht_local_t  *local);
+dht_migration_get_dst_subvol(xlator_t *this, dht_local_t *local);
 int32_t
 dht_migration_needed(xlator_t *this);
-int                                      dht_layout_normalize (xlator_t *this, loc_t *loc, dht_layout_t *layout);
-int dht_layout_anomalies (xlator_t      *this, loc_t *loc, dht_layout_t *layout,
-                          uint32_t      *holes_p, uint32_t *overlaps_p,
-                          uint32_t      *missing_p, uint32_t *down_p,
-                          uint32_t      *misc_p, uint32_t *no_space_p);
-int dht_layout_dir_mismatch (xlator_t   *this, dht_layout_t *layout,
-                             xlator_t   *subvol, loc_t *loc, dict_t *xattr);
-
-xlator_t *dht_linkfile_subvol (xlator_t *this, inode_t *inode,
-                               struct iatt *buf, dict_t *xattr);
-int dht_linkfile_unlink (call_frame_t      *frame, xlator_t *this,
-                         xlator_t          *subvol, loc_t *loc);
-
-int dht_layouts_init (xlator_t *this, dht_conf_t *conf);
-int dht_layout_merge (xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
-                      int       op_ret, int op_errno, dict_t *xattr);
-
-int     dht_disk_layout_extract (xlator_t *this, dht_layout_t *layout,
-                             int       pos, int32_t **disk_layout_p);
-int dht_disk_layout_merge (xlator_t   *this, dht_layout_t *layout,
-                           int         pos, void *disk_layout_raw, int disk_layout_len);
 int
-dht_disk_layout_extract_for_subvol (xlator_t *this, dht_layout_t *layout,
-                                    xlator_t *subvol, int32_t **disk_layout_p);
+dht_layout_normalize(xlator_t *this, loc_t *loc, dht_layout_t *layout);
+void
+dht_layout_anomalies(xlator_t *this, loc_t *loc, dht_layout_t *layout,
+                     uint32_t *holes_p, uint32_t *overlaps_p,
+                     uint32_t *missing_p, uint32_t *down_p, uint32_t *misc_p,
+                     uint32_t *no_space_p);
+int
+dht_layout_dir_mismatch(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                        loc_t *loc, dict_t *xattr);
+xlator_t *
+dht_linkfile_subvol(xlator_t *this, inode_t *inode, struct iatt *buf,
+                    dict_t *xattr);
+int
+dht_linkfile_unlink(call_frame_t *frame, xlator_t *this, xlator_t *subvol,
+                    loc_t *loc);
 
-int dht_frame_return (call_frame_t *frame);
+int
+dht_layouts_init(xlator_t *this, dht_conf_t *conf);
+int
+dht_layout_merge(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                 int op_ret, int op_errno, dict_t *xattr);
 
-int dht_deitransform (xlator_t *this, uint64_t y, xlator_t **subvol);
+int
+dht_disk_layout_extract(xlator_t *this, dht_layout_t *layout, int pos,
+                        int32_t **disk_layout_p);
+int
+dht_disk_layout_extract_for_subvol(xlator_t *this, dht_layout_t *layout,
+                                   xlator_t *subvol, int32_t **disk_layout_p);
 
-void dht_local_wipe (xlator_t *this, dht_local_t *local);
-dht_local_t *dht_local_init (call_frame_t    *frame, loc_t *loc, fd_t *fd,
-                             glusterfs_fop_t  fop);
-int dht_iatt_merge (xlator_t                 *this, struct iatt *to, struct iatt *from,
-                    xlator_t                 *subvol);
+int
+dht_frame_return(call_frame_t *frame);
 
-xlator_t *dht_subvol_get_hashed (xlator_t *this, loc_t *loc);
-xlator_t *dht_subvol_get_cached (xlator_t *this, inode_t *inode);
-xlator_t *dht_subvol_next (xlator_t *this, xlator_t *prev);
-xlator_t *dht_subvol_next_available (xlator_t *this, xlator_t *prev);
-int       dht_subvol_cnt (xlator_t *this, xlator_t *subvol);
+int
+dht_deitransform(xlator_t *this, uint64_t y, xlator_t **subvol);
 
-int dht_hash_compute (xlator_t *this, int type, const char *name, uint32_t *hash_p);
+void
+dht_local_wipe(xlator_t *this, dht_local_t *local);
+dht_local_t *
+dht_local_init(call_frame_t *frame, loc_t *loc, fd_t *fd, glusterfs_fop_t fop);
+int
+dht_iatt_merge(xlator_t *this, struct iatt *to, struct iatt *from);
 
-int dht_linkfile_create (call_frame_t    *frame, fop_mknod_cbk_t linkfile_cbk,
-                         xlator_t        *this, xlator_t *tovol,
-                         xlator_t        *fromvol, loc_t *loc);
-int                                       dht_lookup_directory (call_frame_t *frame, xlator_t *this, loc_t *loc);
-int                                       dht_lookup_everywhere (call_frame_t *frame, xlator_t *this, loc_t *loc);
+xlator_t *
+dht_subvol_get_hashed(xlator_t *this, loc_t *loc);
+xlator_t *
+dht_subvol_get_cached(xlator_t *this, inode_t *inode);
+xlator_t *
+dht_subvol_next(xlator_t *this, xlator_t *prev);
+xlator_t *
+dht_subvol_next_available(xlator_t *this, xlator_t *prev);
 int
-dht_selfheal_directory (call_frame_t     *frame, dht_selfheal_dir_cbk_t cbk,
-                        loc_t            *loc, dht_layout_t *layout);
+dht_subvol_cnt(xlator_t *this, xlator_t *subvol);
 
 int
-dht_selfheal_directory_for_nameless_lookup (call_frame_t  *frame,
-                                            dht_selfheal_dir_cbk_t cbk,
-                                            loc_t  *loc, dht_layout_t *layout);
+dht_hash_compute(xlator_t *this, int type, const char *name, uint32_t *hash_p);
 
 int
-dht_selfheal_new_directory (call_frame_t *frame, dht_selfheal_dir_cbk_t cbk,
-                            dht_layout_t *layout);
+dht_linkfile_create(call_frame_t *frame, fop_mknod_cbk_t linkfile_cbk,
+                    xlator_t *this, xlator_t *tovol, xlator_t *fromvol,
+                    loc_t *loc);
 int
-dht_selfheal_restore (call_frame_t       *frame, dht_selfheal_dir_cbk_t cbk,
-                      loc_t              *loc, dht_layout_t *layout);
+dht_lookup_everywhere(call_frame_t *frame, xlator_t *this, loc_t *loc);
 int
-dht_layout_sort_volname (dht_layout_t *layout);
+dht_selfheal_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t cbk,
+                       loc_t *loc, dht_layout_t *layout);
+int
+dht_selfheal_new_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t cbk,
+                           dht_layout_t *layout);
+int
+dht_selfheal_restore(call_frame_t *frame, dht_selfheal_dir_cbk_t cbk,
+                     loc_t *loc, dht_layout_t *layout);
+void
+dht_layout_sort_volname(dht_layout_t *layout);
 
-int dht_get_du_info (call_frame_t *frame, xlator_t *this, loc_t *loc);
+int
+dht_get_du_info(call_frame_t *frame, xlator_t *this, loc_t *loc);
 
-gf_boolean_t dht_is_subvol_filled (xlator_t *this, xlator_t *subvol);
-xlator_t *dht_free_disk_available_subvol (xlator_t *this, xlator_t *subvol,
-                                          dht_local_t *layout);
-int       dht_get_du_info_for_subvol (xlator_t *this, int subvol_idx);
+gf_boolean_t
+dht_is_subvol_filled(xlator_t *this, xlator_t *subvol);
+xlator_t *
+dht_free_disk_available_subvol(xlator_t *this, xlator_t *subvol,
+                               dht_local_t *layout);
+int
+dht_get_du_info_for_subvol(xlator_t *this, int subvol_idx);
 
-int dht_layout_preset (xlator_t *this, xlator_t *subvol, inode_t *inode);
-int dht_layout_index_for_subvol (dht_layout_t *layout, xlator_t *subvol);
-int           dht_layout_set (xlator_t *this, inode_t *inode, dht_layout_t *layout);;
-void          dht_layout_unref (xlator_t *this, dht_layout_t *layout);
-dht_layout_t *dht_layout_ref (xlator_t *this, dht_layout_t *layout);
-xlator_t     *dht_first_up_subvol (xlator_t *this);
-xlator_t     *dht_last_up_subvol (xlator_t *this);
+int
+dht_layout_preset(xlator_t *this, xlator_t *subvol, inode_t *inode);
+int
+dht_layout_set(xlator_t *this, inode_t *inode, dht_layout_t *layout);
+;
+void
+dht_layout_unref(xlator_t *this, dht_layout_t *layout);
+dht_layout_t *
+dht_layout_ref(xlator_t *this, dht_layout_t *layout);
+int
+dht_layout_index_for_subvol(dht_layout_t *layout, xlator_t *subvol);
+xlator_t *
+dht_first_up_subvol(xlator_t *this);
+xlator_t *
+dht_last_up_subvol(xlator_t *this);
 
-int dht_build_child_loc (xlator_t *this, loc_t *child, loc_t *parent, char *name);
+int
+dht_build_child_loc(xlator_t *this, loc_t *child, loc_t *parent, char *name);
 
-int dht_filter_loc_subvol_key (xlator_t  *this, loc_t *loc, loc_t *new_loc,
-                               xlator_t **subvol);
+int
+dht_filter_loc_subvol_key(xlator_t *this, loc_t *loc, loc_t *new_loc,
+                          xlator_t **subvol);
 
-int                                     dht_rename_cleanup (call_frame_t *frame);
-int dht_rename_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t           op_ret, int32_t op_errno,
-                         inode_t          *inode, struct iatt *stbuf,
-                         struct iatt      *preparent, struct iatt *postparent,
-                         dict_t *xdata);
+int
+dht_rename_cleanup(call_frame_t *frame);
+int
+dht_rename_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata);
 
-int dht_update_commit_hash_for_layout (call_frame_t *frame);
-int dht_fix_directory_layout (call_frame_t *frame,
-                              dht_selfheal_dir_cbk_t  dir_cbk,
-                              dht_layout_t           *layout);
+int
+dht_update_commit_hash_for_layout(call_frame_t *frame);
+int
+dht_fix_directory_layout(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                         dht_layout_t *layout);
 
-int dht_init_subvolumes (xlator_t *this, dht_conf_t *conf);
+int
+dht_init_subvolumes(xlator_t *this, dht_conf_t *conf);
 
 /* migration/rebalance */
-int dht_start_rebalance_task (xlator_t *this, call_frame_t *frame);
+int
+dht_start_rebalance_task(xlator_t *this, call_frame_t *frame);
 
-int dht_rebalance_in_progress_check (xlator_t *this, call_frame_t *frame);
-int dht_rebalance_complete_check (xlator_t *this, call_frame_t *frame);
+int
+dht_rebalance_in_progress_check(xlator_t *this, call_frame_t *frame);
+int
+dht_rebalance_complete_check(xlator_t *this, call_frame_t *frame);
 
 int
-dht_init_local_subvolumes (xlator_t *this, dht_conf_t *conf);
+dht_init_local_subvolumes(xlator_t *this, dht_conf_t *conf);
 
 /* FOPS */
-int32_t dht_lookup (call_frame_t *frame,
-                    xlator_t *this,
-                    loc_t    *loc,
-                    dict_t   *xattr_req);
-
-int32_t dht_stat (call_frame_t *frame,
-                  xlator_t *this,
-                  loc_t    *loc, dict_t *xdata);
-
-int32_t dht_fstat (call_frame_t *frame,
-                   xlator_t *this,
-                   fd_t     *fd, dict_t *xdata);
-
-int32_t dht_truncate (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t    *loc,
-                      off_t     offset, dict_t *xdata);
-
-int32_t dht_ftruncate (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t     *fd,
-                       off_t     offset, dict_t *xdata);
-
-int32_t dht_access (call_frame_t *frame,
-                    xlator_t *this,
-                    loc_t    *loc,
-                    int32_t   mask, dict_t *xdata);
-
-int32_t dht_readlink (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t    *loc,
-                      size_t    size, dict_t *xdata);
-
-int32_t dht_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata);
-
-int32_t dht_mkdir (call_frame_t *frame, xlator_t *this,
-                   loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata);
-
-int32_t dht_unlink (call_frame_t *frame,
-                    xlator_t *this,
-                    loc_t    *loc, int xflag, dict_t *xdata);
-
-int32_t dht_rmdir (call_frame_t *frame, xlator_t *this,
-                   loc_t    *loc, int flags, dict_t *xdata);
-
-int32_t dht_symlink (call_frame_t   *frame, xlator_t *this,
-                     const char *linkpath, loc_t *loc, mode_t umask,
-                     dict_t *xdata);
-
-int32_t dht_rename (call_frame_t *frame,
-                    xlator_t *this,
-                    loc_t    *oldloc,
-                    loc_t    *newloc, dict_t *xdata);
-
-int32_t dht_link (call_frame_t *frame,
-                  xlator_t *this,
-                  loc_t    *oldloc,
-                  loc_t    *newloc, dict_t *xdata);
-
-int32_t dht_create (call_frame_t *frame, xlator_t *this,
-                    loc_t    *loc, int32_t flags, mode_t mode,
-                    mode_t umask, fd_t     *fd, dict_t *params);
-
-int32_t dht_open (call_frame_t *frame,
-                  xlator_t *this,
-                  loc_t    *loc,
-                  int32_t   flags, fd_t *fd, dict_t *xdata);
-
-int32_t dht_readv (call_frame_t *frame,
-                   xlator_t *this,
-                   fd_t     *fd,
-                   size_t    size,
-                   off_t     offset, uint32_t flags, dict_t *xdata);
-
-int32_t dht_writev (call_frame_t      *frame,
-                    xlator_t      *this,
-                    fd_t          *fd,
-                    struct iovec  *vector,
-                    int32_t        count,
-                    off_t          offset,
-                    uint32_t       flags,
-                    struct iobref *iobref, dict_t *xdata);
-
-int32_t dht_flush (call_frame_t *frame,
-                   xlator_t *this,
-                   fd_t     *fd, dict_t *xdata);
-
-int32_t dht_fsync (call_frame_t *frame,
-                   xlator_t *this,
-                   fd_t     *fd,
-                   int32_t   datasync, dict_t *xdata);
-
-int32_t dht_opendir (call_frame_t *frame,
-                     xlator_t *this,
-                     loc_t    *loc, fd_t *fd, dict_t *xdata);
-
-int32_t dht_fsyncdir (call_frame_t *frame,
-                      xlator_t *this,
-                      fd_t     *fd,
-                      int32_t   datasync, dict_t *xdata);
-
-int32_t dht_statfs (call_frame_t *frame,
-                    xlator_t *this,
-                    loc_t    *loc, dict_t *xdata);
-
-int32_t dht_setxattr (call_frame_t *frame,
-                      xlator_t *this,
-                      loc_t    *loc,
-                      dict_t   *dict,
-                      int32_t   flags, dict_t *xdata);
-
-int32_t dht_getxattr (call_frame_t   *frame,
-                      xlator_t   *this,
-                      loc_t      *loc,
-                      const char *name, dict_t *xdata);
-
-int32_t dht_fsetxattr (call_frame_t *frame,
-                       xlator_t *this,
-                       fd_t     *fd,
-                       dict_t   *dict,
-                       int32_t   flags, dict_t *xdata);
-
-int32_t dht_fgetxattr (call_frame_t   *frame,
-                       xlator_t   *this,
-                       fd_t       *fd,
-                       const char *name, dict_t *xdata);
-
-int32_t dht_removexattr (call_frame_t   *frame,
-                         xlator_t   *this,
-                         loc_t      *loc,
-                         const char *name, dict_t *xdata);
-int32_t dht_fremovexattr (call_frame_t   *frame,
-                          xlator_t   *this,
-                          fd_t      *fd,
-                          const char *name, dict_t *xdata);
-
-int32_t dht_lk (call_frame_t        *frame,
-                xlator_t        *this,
-                fd_t            *fd,
-                int32_t          cmd,
-                struct gf_flock *flock, dict_t *xdata);
-
-int32_t dht_lease (call_frame_t    *frame,
-                   xlator_t        *this,
-                   loc_t           *loc,
-                   struct gf_lease *lease, dict_t *xdata);
-
-int32_t dht_inodelk (call_frame_t *frame, xlator_t *this,
-                     const char      *volume, loc_t *loc, int32_t cmd,
-                     struct gf_flock *flock, dict_t *xdata);
-
-int32_t dht_finodelk (call_frame_t        *frame, xlator_t *this,
-                      const char      *volume, fd_t *fd, int32_t cmd,
-                      struct gf_flock *flock, dict_t *xdata);
-
-int32_t dht_entrylk (call_frame_t    *frame, xlator_t *this,
-                     const char  *volume, loc_t *loc, const char *basename,
-                     entrylk_cmd  cmd, entrylk_type type, dict_t *xdata);
-
-int32_t dht_fentrylk (call_frame_t    *frame, xlator_t *this,
-                      const char  *volume, fd_t *fd, const char *basename,
-                      entrylk_cmd  cmd, entrylk_type type, dict_t *xdata);
-
-int32_t dht_readdir (call_frame_t  *frame,
-                     xlator_t *this,
-                     fd_t     *fd,
-                     size_t    size, off_t off, dict_t *xdata);
-
-int32_t dht_readdirp (call_frame_t *frame,
-                      xlator_t *this,
-                      fd_t     *fd,
-                      size_t    size, off_t off, dict_t *dict);
-
-int32_t dht_xattrop (call_frame_t           *frame,
-                     xlator_t           *this,
-                     loc_t              *loc,
-                     gf_xattrop_flags_t  flags,
-                     dict_t             *dict, dict_t *xdata);
-
-int32_t dht_fxattrop (call_frame_t *frame,
-                      xlator_t           *this,
-                      fd_t               *fd,
-                      gf_xattrop_flags_t  flags,
-                      dict_t             *dict, dict_t *xdata);
-
-int32_t dht_forget (xlator_t *this, inode_t *inode);
-int32_t dht_setattr (call_frame_t  *frame, xlator_t *this, loc_t *loc,
-                     struct iatt   *stbuf, int32_t valid, dict_t *xdata);
-int32_t dht_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                      struct iatt  *stbuf, int32_t valid, dict_t *xdata);
-int32_t dht_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                      int32_t mode, off_t offset, size_t len, dict_t *xdata);
-int32_t dht_discard(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    off_t offset, size_t len, dict_t *xdata);
-int32_t dht_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    off_t offset, off_t len, dict_t *xdata);
-int32_t dht_ipc (call_frame_t *frame, xlator_t *this, int32_t op,
-                 dict_t *xdata);
+int32_t
+dht_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req);
+
+int32_t
+dht_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+
+int32_t
+dht_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
+
+int32_t
+dht_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata);
+
+int32_t
+dht_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata);
+
+int32_t
+dht_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+           dict_t *xdata);
+
+int32_t
+dht_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata);
+
+int32_t
+dht_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t rdev, mode_t umask, dict_t *xdata);
+
+int32_t
+dht_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *xdata);
+
+int32_t
+dht_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata);
+
+int32_t
+dht_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata);
+
+int32_t
+dht_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+            loc_t *loc, mode_t umask, dict_t *xdata);
+
+int32_t
+dht_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata);
+
+int32_t
+dht_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata);
+
+int32_t
+dht_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *params);
+
+int32_t
+dht_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+         fd_t *fd, dict_t *xdata);
+
+int32_t
+dht_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+          off_t offset, uint32_t flags, dict_t *xdata);
+
+int32_t
+dht_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata);
+
+int32_t
+dht_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata);
+
+int32_t
+dht_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+          dict_t *xdata);
+
+int32_t
+dht_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+            dict_t *xdata);
+
+int32_t
+dht_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+             dict_t *xdata);
+
+int32_t
+dht_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
+
+int32_t
+dht_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+             int32_t flags, dict_t *xdata);
+
+int32_t
+dht_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+             dict_t *xdata);
+
+int32_t
+dht_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+              int32_t flags, dict_t *xdata);
+
+int32_t
+dht_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+              dict_t *xdata);
+
+int32_t
+dht_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *name, dict_t *xdata);
+int32_t
+dht_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 const char *name, dict_t *xdata);
+
+int32_t
+dht_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+       struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+dht_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+          struct gf_lease *lease, dict_t *xdata);
+
+int32_t
+dht_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            int32_t cmd, struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+dht_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             int32_t cmd, struct gf_flock *flock, dict_t *xdata);
+
+int32_t
+dht_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata);
+
+int32_t
+dht_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             const char *basename, entrylk_cmd cmd, entrylk_type type,
+             dict_t *xdata);
+
+int32_t
+dht_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t off, dict_t *xdata);
+
+int32_t
+dht_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t off, dict_t *dict);
+
+int32_t
+dht_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+dht_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
+
+int32_t
+dht_forget(xlator_t *this, inode_t *inode);
+int32_t
+dht_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+            int32_t valid, dict_t *xdata);
+int32_t
+dht_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
+             int32_t valid, dict_t *xdata);
+int32_t
+dht_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata);
+int32_t
+dht_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata);
+int32_t
+dht_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             off_t len, dict_t *xdata);
+int32_t
+dht_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata);
 
 int
 dht_set_subvol_range(xlator_t *this);
-int32_t dht_init (xlator_t *this);
-void    dht_fini (xlator_t *this);
-int     dht_reconfigure (xlator_t *this, dict_t *options);
-int32_t dht_notify (xlator_t *this, int32_t event, void *data, ...);
+int32_t
+dht_init(xlator_t *this);
+void
+dht_fini(xlator_t *this);
+int
+dht_reconfigure(xlator_t *this, dict_t *options);
+int32_t
+dht_notify(xlator_t *this, int32_t event, void *data, ...);
 
 /* definitions for nufa/switch */
-int dht_revalidate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, inode_t *inode,
-                        struct iatt *stbuf, dict_t *xattr,
-                        struct iatt *postparent);
-int dht_lookup_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+int
+dht_revalidate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent);
+int
+dht_lookup_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent);
+int
+dht_lookup_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                         int op_ret, int op_errno, inode_t *inode,
                         struct iatt *stbuf, dict_t *xattr,
                         struct iatt *postparent);
-int dht_lookup_linkfile_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int op_ret, int op_errno,
-                             inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                             struct iatt *postparent);
-int dht_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                    struct iatt *postparent);
-int dht_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata);
-int dht_newfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno,
-                     inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata);
-
-int
-gf_defrag_status_get (dht_conf_t *conf, dict_t *dict);
-
-void
-gf_defrag_set_pause_state (gf_tier_conf_t *tier_conf, tier_pause_state_t state);
-
-tier_pause_state_t
-gf_defrag_get_pause_state (gf_tier_conf_t *tier_conf);
-
 int
-gf_defrag_pause_tier (xlator_t *this, gf_defrag_info_t *defrag);
+dht_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, inode_t *inode, struct iatt *stbuf, dict_t *xattr,
+               struct iatt *postparent);
+int
+dht_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
+               struct iatt *preparent, struct iatt *postparent, dict_t *xdata);
+int
+dht_newfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, inode_t *inode, struct iatt *stbuf,
+                struct iatt *preparent, struct iatt *postparent, dict_t *xdata);
 
-tier_pause_state_t
-gf_defrag_check_pause_tier (gf_tier_conf_t *defrag);
+int
+dht_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata);
 
 int
-gf_defrag_resume_tier (xlator_t *this, gf_defrag_info_t *defrag);
+dht_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xattr, dict_t *xdata);
 
 int
-gf_defrag_start_detach_tier (gf_defrag_info_t *defrag);
+dht_common_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata);
+int
+gf_defrag_status_get(dht_conf_t *conf, dict_t *dict);
 
 int
-gf_defrag_stop (dht_conf_t *conf, gf_defrag_status_t status,
-                dict_t *output);
+gf_defrag_stop(dht_conf_t *conf, gf_defrag_status_t status, dict_t *output);
 
-void*
-gf_defrag_start (void *this);
+void *
+gf_defrag_start(void *this);
 
 int32_t
-gf_defrag_handle_hardlink (xlator_t *this, loc_t *loc, int *fop_errno);
+gf_defrag_handle_hardlink(xlator_t *this, loc_t *loc, int *fop_errno);
 int
-dht_migrate_file (xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
+dht_migrate_file(xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
                  int flag, int *fop_errno);
 int
-dht_inode_ctx_layout_get (inode_t *inode, xlator_t *this,
-                          dht_layout_t **layout_int);
+dht_inode_ctx_layout_get(inode_t *inode, xlator_t *this,
+                         dht_layout_t **layout_int);
 int
-dht_inode_ctx_layout_set (inode_t *inode, xlator_t *this,
-                          dht_layout_t* layout_int);
+dht_inode_ctx_layout_set(inode_t *inode, xlator_t *this,
+                         dht_layout_t *layout_int);
 int
-dht_inode_ctx_time_update (inode_t *inode, xlator_t *this, struct iatt *stat,
-                           int32_t update_ctx);
-void dht_inode_ctx_time_set (inode_t *inode, xlator_t *this, struct iatt *stat);
+dht_inode_ctx_time_update(inode_t *inode, xlator_t *this, struct iatt *stat,
+                          int32_t update_ctx);
+void
+dht_inode_ctx_time_set(inode_t *inode, xlator_t *this, struct iatt *stat);
 
-int dht_inode_ctx_get (inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx);
-int dht_inode_ctx_set (inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx);
 int
-dht_dir_attr_heal (void *data);
+dht_inode_ctx_get(inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx);
 int
-dht_dir_attr_heal_done (int ret, call_frame_t *sync_frame, void *data);
+dht_inode_ctx_set(inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx);
 int
-dht_dir_has_layout (dict_t *xattr, char *name);
-gf_boolean_t
-dht_is_subvol_in_layout (dht_layout_t *layout, xlator_t *xlator);
+dht_dir_attr_heal(void *data);
+int
+dht_dir_attr_heal_done(int ret, call_frame_t *sync_frame, void *data);
 xlator_t *
-dht_subvol_with_free_space_inodes (xlator_t *this, xlator_t *subvol, xlator_t *ignore,
-                                   dht_layout_t *layout, uint64_t filesize);
+dht_subvol_with_free_space_inodes(xlator_t *this, xlator_t *subvol,
+                                  xlator_t *ignore, dht_layout_t *layout,
+                                  uint64_t filesize);
 xlator_t *
-dht_subvol_maxspace_nonzeroinode (xlator_t *this, xlator_t *subvol,
-                                  dht_layout_t *layout);
+dht_subvol_maxspace_nonzeroinode(xlator_t *this, xlator_t *subvol,
+                                 dht_layout_t *layout);
 int
-dht_linkfile_attr_heal (call_frame_t *frame, xlator_t *this);
+dht_dir_has_layout(dict_t *xattr, char *name);
+int
+dht_linkfile_attr_heal(call_frame_t *frame, xlator_t *this);
 
-void
-dht_layout_dump (dht_layout_t  *layout, const char *prefix);
 int32_t
-dht_priv_dump (xlator_t *this);
+dht_priv_dump(xlator_t *this);
 int32_t
-dht_inodectx_dump (xlator_t *this, inode_t *inode);
+dht_inodectx_dump(xlator_t *this, inode_t *inode);
 
-int
-dht_inode_ctx_get_mig_info (xlator_t *this, inode_t *inode,
-                            xlator_t **src_subvol, xlator_t **dst_subvol);
 gf_boolean_t
-dht_mig_info_is_invalid (xlator_t *current, xlator_t *src_subvol,
-                         xlator_t *dst_subvol);
+dht_is_subvol_in_layout(dht_layout_t *layout, xlator_t *xlator);
 
 int
-dht_subvol_status (dht_conf_t *conf, xlator_t *subvol);
+dht_inode_ctx_get_mig_info(xlator_t *this, inode_t *inode,
+                           xlator_t **src_subvol, xlator_t **dst_subvol);
+gf_boolean_t
+dht_mig_info_is_invalid(xlator_t *current, xlator_t *src_subvol,
+                        xlator_t *dst_subvol);
 
-void
-dht_log_new_layout_for_dir_selfheal (xlator_t *this, loc_t *loc,
-                                     dht_layout_t *layout);
 int
-dht_lookup_everywhere_done (call_frame_t *frame, xlator_t *this);
+dht_subvol_status(dht_conf_t *conf, xlator_t *subvol);
 
-int
-dht_fill_dict_to_avoid_unlink_of_migrating_file (dict_t *dict);
+void
+dht_log_new_layout_for_dir_selfheal(xlator_t *this, loc_t *loc,
+                                    dht_layout_t *layout);
 
 int
-dht_layout_sort (dht_layout_t *layout);
+dht_layout_sort(dht_layout_t *layout);
 
 int
-dht_heal_full_path (void *data);
+dht_heal_full_path(void *data);
 
 int
-dht_heal_full_path_done (int op_ret, call_frame_t *frame, void *data);
+dht_heal_full_path_done(int op_ret, call_frame_t *frame, void *data);
 
 int
-dht_layout_missing_dirs (dht_layout_t *layout);
+dht_layout_missing_dirs(dht_layout_t *layout);
 
 int
-dht_refresh_layout (call_frame_t *frame);
-
-gf_boolean_t
-dht_is_tier_xlator (xlator_t *this);
+dht_refresh_layout(call_frame_t *frame);
 
 int
-dht_build_parent_loc (xlator_t *this, loc_t *parent, loc_t *child,
-                                                 int32_t *op_errno);
+dht_build_parent_loc(xlator_t *this, loc_t *parent, loc_t *child,
+                     int32_t *op_errno);
 
 int32_t
-dht_set_local_rebalance (xlator_t *this, dht_local_t *local,
-                         struct iatt *stbuf,
-                         struct iatt *prebuf,
-                         struct iatt *postbuf, dict_t *xdata);
+dht_set_local_rebalance(xlator_t *this, dht_local_t *local, struct iatt *stbuf,
+                        struct iatt *prebuf, struct iatt *postbuf,
+                        dict_t *xdata);
 void
-dht_build_root_loc (inode_t *inode, loc_t *loc);
+dht_build_root_loc(inode_t *inode, loc_t *loc);
 
 gf_boolean_t
-dht_fd_open_on_dst (xlator_t *this, fd_t *fd, xlator_t *dst);
+dht_fd_open_on_dst(xlator_t *this, fd_t *fd, xlator_t *dst);
 
 int32_t
-dht_fd_ctx_destroy (xlator_t *this, fd_t *fd);
+dht_fd_ctx_destroy(xlator_t *this, fd_t *fd);
 
 int32_t
-dht_release (xlator_t *this, fd_t *fd);
-
+dht_release(xlator_t *this, fd_t *fd);
 
 int32_t
-dht_set_fixed_dir_stat (struct iatt *stat);
+dht_set_fixed_dir_stat(struct iatt *stat);
 
-xlator_t*
-dht_get_lock_subvolume (xlator_t *this, struct gf_flock *lock,
-                        dht_local_t *local);
+xlator_t *
+dht_get_lock_subvolume(xlator_t *this, struct gf_flock *lock,
+                       dht_local_t *local);
 
 int
-dht_lk_inode_unref (call_frame_t *frame, int32_t op_ret);
+dht_lk_inode_unref(call_frame_t *frame, int32_t op_ret);
 
-void
-dht_normalize_stats (struct statvfs *buf, unsigned long bsize,
-                     unsigned long frsize);
+int
+dht_fd_ctx_set(xlator_t *this, fd_t *fd, xlator_t *subvol);
 
 int
-add_opt(char **optsp, const char *opt);
+dht_check_and_open_fd_on_subvol(xlator_t *this, call_frame_t *frame);
+
+/* FD fop callbacks */
 
-char *
-getChoices (const char *value);
+int
+dht_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+               dict_t *xdata);
 
 int
-dht_aggregate_split_brain_xattr (dict_t *dst, char *key, data_t *value);
+dht_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, dict_t *xdata);
 
 int
-dht_remove_stale_linkto (void *data);
+dht_file_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata);
 
 int
-dht_remove_stale_linkto_cbk (int ret, call_frame_t *sync_frame, void *data);
+dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata);
 
+int
+dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                dict_t *xdata);
 
 int
-dht_fd_ctx_set (xlator_t *this, fd_t *fd, xlator_t *subvol);
+dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                  dict_t *xdata);
 
 int
-dht_check_and_open_fd_on_subvol (xlator_t *this, call_frame_t *frame);
+dht_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata);
 
+int
+dht_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+              dict_t *xdata);
 
+int
+dht_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iovec *vector, int count, struct iatt *stbuf,
+              struct iobref *iobref, dict_t *xdata);
 
+int
+dht_file_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *stbuf, dict_t *xdata);
 
+int
+dht_file_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata);
 
+int
+dht_file_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata);
 
-/* FD fop callbacks */
+/* All custom xattr heal functions */
+int
+dht_dir_heal_xattrs(void *data);
 
 int
-dht_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata);
+dht_dir_heal_xattrs_done(int ret, call_frame_t *sync_frame, void *data);
+
+int32_t
+dht_dict_set_array(dict_t *dict, char *key, int32_t value[], int32_t size);
 
 int
-dht_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, dict_t *xdata);
+dht_set_user_xattr(dict_t *dict, char *k, data_t *v, void *data);
+
+void
+dht_dir_set_heal_xattr(xlator_t *this, dht_local_t *local, dict_t *dst,
+                       dict_t *src, int *uret, int *uflag);
 
 int
-dht_file_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata);
+dht_dir_xattr_heal(xlator_t *this, dht_local_t *local, int *op_errno);
 
 int
-dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata);
+dht_common_mark_mdsxattr(call_frame_t *frame, int *errst, int flag);
 
 int
-dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata);
+dht_inode_ctx_mdsvol_get(inode_t *inode, xlator_t *this, xlator_t **mdsvol);
 
 int
-dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata);
+dht_selfheal_dir_setattr(call_frame_t *frame, loc_t *loc, struct iatt *stbuf,
+                         int32_t valid, dht_layout_t *layout);
+
+/* Abstract out the DHT-IATT-IN-DICT */
+
+void
+dht_selfheal_layout_new_directory(call_frame_t *frame, loc_t *loc,
+                                  dht_layout_t *new_layout);
 
 int
-dht_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata);
+dht_pt_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+                 dict_t *xdata);
 
 int
-dht_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
-               dict_t *xdata);
+dht_pt_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *key, dict_t *xdata);
 
+int32_t
+dht_pt_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+             mode_t umask, dict_t *xdata);
 
 int
-dht_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno,
-               struct iovec *vector, int count, struct iatt *stbuf,
-               struct iobref *iobref, dict_t *xdata);
+dht_pt_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata);
+
+int32_t
+dht_check_remote_fd_failed_error(dht_local_t *local, int op_ret, int op_errno);
 
 int
-dht_file_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *stbuf, dict_t *xdata);
+dht_common_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata);
 
+int32_t
+dht_create_lock(call_frame_t *frame, xlator_t *subvol);
 
 int
-dht_file_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, dict_t *xdata);
+dht_set_parent_layout_in_dict(loc_t *loc, xlator_t *this, dht_local_t *local);
 
+int
+dht_dir_layout_error_check(xlator_t *this, inode_t *inode);
 
 int
-dht_file_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xdata);
-#endif/* _DHT_H */
+dht_inode_ctx_mdsvol_set(inode_t *inode, xlator_t *this, xlator_t *mds_subvol);
+#endif /* _DHT_H */
diff --git a/xlators/cluster/dht/src/dht-diskusage.c b/xlators/cluster/dht/src/dht-diskusage.c
index 05592154e30..c0588828fdb 100644
--- a/xlators/cluster/dht/src/dht-diskusage.c
+++ b/xlators/cluster/dht/src/dht-diskusage.c
@@ -8,487 +8,480 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
 
-#include "glusterfs.h"
-#include "xlator.h"
 #include "dht-common.h"
-#include "dht-messages.h"
-#include "defaults.h"
 
 #include <sys/time.h>
-
+#include <glusterfs/events.h>
 
 int
-dht_du_info_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		 int op_ret, int op_errno, struct statvfs *statvfs,
-                 dict_t *xdata)
+dht_du_info_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
-	dht_conf_t    *conf         = NULL;
-	xlator_t      *prev          = NULL;
-	int            this_call_cnt = 0;
-	int            i = 0;
-	double         percent = 0;
-	double         percent_inodes = 0;
-	uint64_t       bytes = 0;
-        uint32_t       bpc;     /* blocks per chunk */
-        uint32_t       chunks   = 0;
-
-	conf = this->private;
-	prev = cookie;
-
-	if (op_ret == -1) {
-		gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_GET_DISK_INFO_ERROR,
-			"failed to get disk info from %s", prev->name);
-		goto out;
-	}
-
-	if (statvfs && statvfs->f_blocks) {
-		percent = (statvfs->f_bavail * 100) / statvfs->f_blocks;
-		bytes = (statvfs->f_bavail * statvfs->f_frsize);
-                /*
-                 * A 32-bit count of 1MB chunks allows a maximum brick size of
-                 * ~4PB.  It's possible that we could see a single local FS
-                 * bigger than that some day, but this code is likely to be
-                 * irrelevant by then.  Meanwhile, it's more important to keep
-                 * the chunk size small so the layout-calculation code that
-                 * uses this value can be tested on normal machines.
-                 */
-                bpc = (1 << 20) / statvfs->f_bsize;
-                chunks = (statvfs->f_blocks + bpc - 1) / bpc;
-	}
-
-	if (statvfs && statvfs->f_files) {
-		percent_inodes = (statvfs->f_ffree * 100) / statvfs->f_files;
-	} else {
-                /*
-                 * Set percent inodes to 100 for dynamically allocated inode
-                 * filesystems. The rationale is that distribute need not
-                 * worry about total inodes; rather, let the 'create()' be
-                 * scheduled on the hashed subvol regardless of the total
-                 * inodes.
-		 */
-		percent_inodes = 100;
-	}
-
-	LOCK (&conf->subvolume_lock);
-	{
-		for (i = 0; i < conf->subvolume_cnt; i++)
-			if (prev == conf->subvolumes[i]) {
-				conf->du_stats[i].avail_percent = percent;
-				conf->du_stats[i].avail_space   = bytes;
-				conf->du_stats[i].avail_inodes  = percent_inodes;
-                                conf->du_stats[i].chunks        = chunks;
-                                conf->du_stats[i].total_blocks  = statvfs->f_blocks;
-                                conf->du_stats[i].avail_blocks  = statvfs->f_bavail;
-                                conf->du_stats[i].frsize        = statvfs->f_frsize;
-
-                                gf_msg_debug (this->name, 0,
-				              "subvolume '%s': avail_percent "
-					      "is: %.2f and avail_space "
-                                              "is: %" PRIu64" and avail_inodes"
-                                              " is: %.2f",
-					      prev->name,
-					      conf->du_stats[i].avail_percent,
-					      conf->du_stats[i].avail_space,
-					      conf->du_stats[i].avail_inodes);
-                                break;  /* no point in looping further */
-			}
-	}
-	UNLOCK (&conf->subvolume_lock);
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
+    int i = 0;
+    double percent = 0;
+    double percent_inodes = 0;
+    uint64_t bytes = 0;
+    uint32_t bpc; /* blocks per chunk */
+    uint32_t chunks = 0;
+
+    conf = this->private;
+    prev = cookie;
+
+    if (op_ret == -1 || !statvfs) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno,
+               DHT_MSG_GET_DISK_INFO_ERROR, "failed to get disk info from %s",
+               prev->name);
+        goto out;
+    }
+
+    if (statvfs->f_blocks) {
+        percent = (statvfs->f_bavail * 100) / statvfs->f_blocks;
+        bytes = (statvfs->f_bavail * statvfs->f_frsize);
+        /*
+         * A 32-bit count of 1MB chunks allows a maximum brick size of
+         * ~4PB.  It's possible that we could see a single local FS
+         * bigger than that some day, but this code is likely to be
+         * irrelevant by then.  Meanwhile, it's more important to keep
+         * the chunk size small so the layout-calculation code that
+         * uses this value can be tested on normal machines.
+         */
+        bpc = (1 << 20) / statvfs->f_bsize;
+        chunks = (statvfs->f_blocks + bpc - 1) / bpc;
+    }
+
+    if (statvfs->f_files) {
+        percent_inodes = (statvfs->f_ffree * 100) / statvfs->f_files;
+    } else {
+        /*
+         * Set percent inodes to 100 for dynamically allocated inode
+         * filesystems. The rationale is that distribute need not
+         * worry about total inodes; rather, let the 'create()' be
+         * scheduled on the hashed subvol regardless of the total
+         * inodes.
+         */
+        percent_inodes = 100;
+    }
+
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++)
+            if (prev == conf->subvolumes[i]) {
+                conf->du_stats[i].avail_percent = percent;
+                conf->du_stats[i].avail_space = bytes;
+                conf->du_stats[i].avail_inodes = percent_inodes;
+                conf->du_stats[i].chunks = chunks;
+                conf->du_stats[i].total_blocks = statvfs->f_blocks;
+                conf->du_stats[i].avail_blocks = statvfs->f_bavail;
+                conf->du_stats[i].frsize = statvfs->f_frsize;
+
+                gf_msg_debug(this->name, 0,
+                             "subvolume '%s': avail_percent "
+                             "is: %.2f and avail_space "
+                             "is: %" PRIu64
+                             " and avail_inodes"
+                             " is: %.2f",
+                             prev->name, conf->du_stats[i].avail_percent,
+                             conf->du_stats[i].avail_space,
+                             conf->du_stats[i].avail_inodes);
+                break; /* no point in looping further */
+            }
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-	this_call_cnt = dht_frame_return (frame);
-	if (is_last_call (this_call_cnt))
-		DHT_STACK_DESTROY (frame);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_DESTROY(frame);
 
-	return 0;
+    return 0;
 }
 
 int
-dht_get_du_info_for_subvol (xlator_t *this, int subvol_idx)
+dht_get_du_info_for_subvol(xlator_t *this, int subvol_idx)
 {
-	dht_conf_t    *conf         = NULL;
-	call_frame_t  *statfs_frame = NULL;
-	dht_local_t   *statfs_local = NULL;
-	call_pool_t   *pool         = NULL;
-	loc_t          tmp_loc      = {0,};
-
-	conf = this->private;
-	pool = this->ctx->pool;
-
-	statfs_frame = create_frame (this, pool);
-	if (!statfs_frame) {
-		goto err;
-	}
-
-	/* local->fop value is not used in this case */
-	statfs_local = dht_local_init (statfs_frame, NULL, NULL,
-				       GF_FOP_MAXVALUE);
-	if (!statfs_local) {
-		goto err;
-	}
-
-        /* make it root gfid, should be enough to get the proper info back */
-        tmp_loc.gfid[15] = 1;
-
-	statfs_local->call_cnt = 1;
-	STACK_WIND_COOKIE (statfs_frame, dht_du_info_cbk,
-		           conf->subvolumes[subvol_idx],
-                           conf->subvolumes[subvol_idx],
-		           conf->subvolumes[subvol_idx]->fops->statfs,
-		           &tmp_loc, NULL);
-
-	return 0;
+    dht_conf_t *conf = NULL;
+    call_frame_t *statfs_frame = NULL;
+    dht_local_t *statfs_local = NULL;
+    call_pool_t *pool = NULL;
+    loc_t tmp_loc = {
+        0,
+    };
+
+    conf = this->private;
+    pool = this->ctx->pool;
+
+    statfs_frame = create_frame(this, pool);
+    if (!statfs_frame) {
+        goto err;
+    }
+
+    /* local->fop value is not used in this case */
+    statfs_local = dht_local_init(statfs_frame, NULL, NULL, GF_FOP_MAXVALUE);
+    if (!statfs_local) {
+        goto err;
+    }
+
+    /* make it root gfid, should be enough to get the proper info back */
+    tmp_loc.gfid[15] = 1;
+
+    statfs_local->call_cnt = 1;
+    STACK_WIND_COOKIE(
+        statfs_frame, dht_du_info_cbk, conf->subvolumes[subvol_idx],
+        conf->subvolumes[subvol_idx],
+        conf->subvolumes[subvol_idx]->fops->statfs, &tmp_loc, NULL);
+
+    return 0;
 err:
-	if (statfs_frame)
-		DHT_STACK_DESTROY (statfs_frame);
+    if (statfs_frame)
+        DHT_STACK_DESTROY(statfs_frame);
 
-	return -1;
+    return -1;
 }
 
 int
-dht_get_du_info (call_frame_t *frame, xlator_t *this, loc_t *loc)
+dht_get_du_info(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-	int            i            = 0;
-        int            ret          = -1;
-	dht_conf_t    *conf         = NULL;
-	call_frame_t  *statfs_frame = NULL;
-	dht_local_t   *statfs_local = NULL;
-	struct timeval tv           = {0,};
-        loc_t          tmp_loc      = {0,};
-
-	conf  = this->private;
-
-	gettimeofday (&tv, NULL);
-
-        /* make it root gfid, should be enough to get the proper
-           info back */
-        tmp_loc.gfid[15] = 1;
-
-	if (tv.tv_sec > (conf->refresh_interval
-			 + conf->last_stat_fetch.tv_sec)) {
-
-		statfs_frame = copy_frame (frame);
-		if (!statfs_frame) {
-			goto err;
-		}
-
-		/* In this case, 'local->fop' is not used */
-		statfs_local = dht_local_init (statfs_frame, loc, NULL,
-					       GF_FOP_MAXVALUE);
-		if (!statfs_local) {
-			goto err;
-		}
-
-                statfs_local->params = dict_new ();
-                if (!statfs_local->params)
-                        goto err;
-
-                ret = dict_set_int8 (statfs_local->params,
-                                     GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set "
-                                GF_INTERNAL_IGNORE_DEEM_STATFS" in dict");
-                        goto err;
-                }
+    int i = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    call_frame_t *statfs_frame = NULL;
+    dht_local_t *statfs_local = NULL;
+    loc_t tmp_loc = {
+        0,
+    };
+    time_t now;
+
+    conf = this->private;
+    now = gf_time();
+    /* make it root gfid, should be enough to get the proper
+       info back */
+    tmp_loc.gfid[15] = 1;
+
+    if (now > (conf->refresh_interval + conf->last_stat_fetch)) {
+        statfs_frame = copy_frame(frame);
+        if (!statfs_frame) {
+            goto err;
+        }
+
+        /* In this case, 'local->fop' is not used */
+        statfs_local = dht_local_init(statfs_frame, loc, NULL, GF_FOP_MAXVALUE);
+        if (!statfs_local) {
+            goto err;
+        }
+
+        statfs_local->params = dict_new();
+        if (!statfs_local->params)
+            goto err;
+
+        ret = dict_set_int8(statfs_local->params,
+                            GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
+            goto err;
+        }
+
+        statfs_local->call_cnt = conf->subvolume_cnt;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            STACK_WIND_COOKIE(statfs_frame, dht_du_info_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->statfs, &tmp_loc,
+                              statfs_local->params);
+        }
 
-		statfs_local->call_cnt = conf->subvolume_cnt;
-		for (i = 0; i < conf->subvolume_cnt; i++) {
-			STACK_WIND_COOKIE (statfs_frame, dht_du_info_cbk,
-				           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-				           conf->subvolumes[i]->fops->statfs,
-				           &tmp_loc, statfs_local->params);
-		}
-
-		conf->last_stat_fetch.tv_sec = tv.tv_sec;
-	}
-	return 0;
+        conf->last_stat_fetch = now;
+    }
+    return 0;
 err:
-	if (statfs_frame)
-		DHT_STACK_DESTROY (statfs_frame);
+    if (statfs_frame)
+        DHT_STACK_DESTROY(statfs_frame);
 
-	return -1;
+    return -1;
 }
 
-
 gf_boolean_t
-dht_is_subvol_filled (xlator_t *this, xlator_t *subvol)
+dht_is_subvol_filled(xlator_t *this, xlator_t *subvol)
 {
-	int         i = 0;
-	dht_conf_t *conf = NULL;
-	gf_boolean_t subvol_filled_inodes = _gf_false;
-	gf_boolean_t subvol_filled_space = _gf_false;
-	gf_boolean_t is_subvol_filled = _gf_false;
-
-	conf = this->private;
-
-	/* Check for values above specified percent or free disk */
-	LOCK (&conf->subvolume_lock);
-	{
-		for (i = 0; i < conf->subvolume_cnt; i++) {
-			if (subvol == conf->subvolumes[i]) {
-				if (conf->disk_unit == 'p') {
-					if (conf->du_stats[i].avail_percent <
-					    conf->min_free_disk) {
-						subvol_filled_space = _gf_true;
-						break;
-					}
-
-				} else {
-					if (conf->du_stats[i].avail_space <
-					    conf->min_free_disk) {
-						subvol_filled_space = _gf_true;
-						break;
-					}
-				}
-				if (conf->du_stats[i].avail_inodes <
-				    conf->min_free_inodes) {
-					subvol_filled_inodes = _gf_true;
-					break;
-				}
-			}
-		}
-	}
-	UNLOCK (&conf->subvolume_lock);
-
-	if (subvol_filled_space && conf->subvolume_status[i]) {
-		if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
-			gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_SUBVOL_INSUFF_SPACE,
-				"disk space on subvolume '%s' is getting "
-				"full (%.2f %%), consider adding more bricks",
-				subvol->name,
-				(100 - conf->du_stats[i].avail_percent));
-		}
-	}
-
-	if (subvol_filled_inodes && conf->subvolume_status[i]) {
-		if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
-			gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                                DHT_MSG_SUBVOL_INSUFF_INODES,
-				"inodes on subvolume '%s' are at "
-				"(%.2f %%), consider adding more bricks",
-				subvol->name,
-				(100 - conf->du_stats[i].avail_inodes));
-		}
-	}
-
-	is_subvol_filled = (subvol_filled_space || subvol_filled_inodes);
-
-	return is_subvol_filled;
-}
+    int i = 0;
+    char vol_name[256];
+    dht_conf_t *conf = NULL;
+    gf_boolean_t subvol_filled_inodes = _gf_false;
+    gf_boolean_t subvol_filled_space = _gf_false;
+    gf_boolean_t is_subvol_filled = _gf_false;
+    double usage = 0;
+
+    conf = this->private;
+
+    /* Check for values above specified percent or free disk */
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (subvol == conf->subvolumes[i]) {
+                if (conf->disk_unit == 'p') {
+                    if (conf->du_stats[i].avail_percent < conf->min_free_disk) {
+                        subvol_filled_space = _gf_true;
+                        break;
+                    }
+
+                } else {
+                    if (conf->du_stats[i].avail_space < conf->min_free_disk) {
+                        subvol_filled_space = _gf_true;
+                        break;
+                    }
+                }
+                if (conf->du_stats[i].avail_inodes < conf->min_free_inodes) {
+                    subvol_filled_inodes = _gf_true;
+                    break;
+                }
+            }
+        }
+    }
+    UNLOCK(&conf->subvolume_lock);
 
+    if (subvol_filled_space && conf->subvolume_status[i]) {
+        if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
+            usage = 100 - conf->du_stats[i].avail_percent;
 
-/*Get the best subvolume to create the file in*/
-xlator_t *
-dht_free_disk_available_subvol (xlator_t *this, xlator_t *subvol,
-                                dht_local_t *local)
-{
-	xlator_t   *avail_subvol = NULL;
-	dht_conf_t *conf = NULL;
-        dht_layout_t *layout = NULL;
-        loc_t      *loc = NULL;
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+                   "disk space on subvolume '%s' is getting "
+                   "full (%.2f %%), consider adding more bricks",
+                   subvol->name, usage);
 
-	conf = this->private;
-        if (!local)
-                goto out;
-        loc = &local->loc;
-        if (!local->layout) {
-                layout = dht_layout_get (this, loc->parent);
-
-                if (!layout) {
-                        gf_msg_debug (this->name, 0,
-                                      "Missing layout. path=%s,"
-                                      " parent gfid = %s", loc->path,
-                                      uuid_utoa (loc->parent->gfid));
-                        goto out;
-                }
-        } else {
-                layout = dht_layout_ref (this, local->layout);
-        }
+            (void)snprintf(vol_name, sizeof(vol_name), "%s", this->name);
+            vol_name[(strlen(this->name) - 4)] = '\0';
 
-        LOCK (&conf->subvolume_lock);
-	{
-                avail_subvol = dht_subvol_with_free_space_inodes(this, subvol, NULL,
-                                                                 layout, 0);
-                if(!avail_subvol)
-                {
-                        avail_subvol = dht_subvol_maxspace_nonzeroinode(this,
-                                                                        subvol,
-                                                                        layout);
-                }
+            gf_event(EVENT_DHT_DISK_USAGE, "volume=%s;subvol=%s;usage=%.2f %%",
+                     vol_name, subvol->name, usage);
+        }
+    }
+
+    if (subvol_filled_inodes && conf->subvolume_status[i]) {
+        if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
+            usage = 100 - conf->du_stats[i].avail_inodes;
+            gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_SUBVOL_INSUFF_INODES,
+                   "inodes on subvolume '%s' are at "
+                   "(%.2f %%), consider adding more bricks",
+                   subvol->name, usage);
+
+            (void)snprintf(vol_name, sizeof(vol_name), "%s", this->name);
+            vol_name[(strlen(this->name) - 4)] = '\0';
+
+            gf_event(EVENT_DHT_INODES_USAGE,
+                     "volume=%s;subvol=%s;usage=%.2f %%", vol_name,
+                     subvol->name, usage);
+        }
+    }
 
-	}
-	UNLOCK (&conf->subvolume_lock);
-out:
-	if (!avail_subvol) {
-		gf_msg_debug (this->name, 0,
-		              "No subvolume has enough free space \
-                              and/or inodes to create");
-                avail_subvol = subvol;
-	}
+    is_subvol_filled = (subvol_filled_space || subvol_filled_inodes);
 
-        if (layout)
-                dht_layout_unref (this, layout);
-	return avail_subvol;
+    return is_subvol_filled;
 }
 
-static inline
-int32_t dht_subvol_has_err (dht_conf_t *conf, xlator_t *this, xlator_t *ignore,
-                            dht_layout_t *layout)
+/*Get the best subvolume to create the file in*/
+xlator_t *
+dht_free_disk_available_subvol(xlator_t *this, xlator_t *subvol,
+                               dht_local_t *local)
 {
-        int ret = -1;
-        int i   = 0;
-
-        if (!this || !layout)
-                goto out;
-
-        /* this check is meant for rebalance process. The source of the file
-         * should be ignored for space check */
-        if (this == ignore) {
-                goto out;
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    loc_t *loc = NULL;
+
+    conf = this->private;
+    if (!local)
+        goto out;
+    loc = &local->loc;
+    if (!local->layout) {
+        layout = dht_layout_get(this, loc->parent);
+
+        if (!layout) {
+            gf_msg_debug(this->name, 0,
+                         "Missing layout. path=%s,"
+                         " parent gfid = %s",
+                         loc->path, uuid_utoa(loc->parent->gfid));
+            goto out;
+        }
+    } else {
+        layout = dht_layout_ref(this, local->layout);
+    }
+
+    LOCK(&conf->subvolume_lock);
+    {
+        avail_subvol = dht_subvol_with_free_space_inodes(this, subvol, NULL,
+                                                         layout, 0);
+        if (!avail_subvol) {
+            avail_subvol = dht_subvol_maxspace_nonzeroinode(this, subvol,
+                                                            layout);
         }
+    }
+    UNLOCK(&conf->subvolume_lock);
+out:
+    if (!avail_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "No subvolume has enough free space \
+                              and/or inodes to create");
+        avail_subvol = subvol;
+    }
 
+    if (layout)
+        dht_layout_unref(this, layout);
+    return avail_subvol;
+}
 
-        /* check if subvol has layout errors, before selecting it */
-        for (i = 0; i < layout->cnt; i++) {
-                if (!strcmp (layout->list[i].xlator->name, this->name) &&
-                     (layout->list[i].err != 0)) {
-                        ret = -1;
-                        goto out;
-                }
+static inline int32_t
+dht_subvol_has_err(dht_conf_t *conf, xlator_t *this, xlator_t *ignore,
+                   dht_layout_t *layout)
+{
+    int ret = -1;
+    int i = 0;
+
+    if (!this || !layout)
+        goto out;
+
+    /* this check is meant for rebalance process. The source of the file
+     * should be ignored for space check */
+    if (this == ignore) {
+        goto out;
+    }
+
+    /* check if subvol has layout errors, before selecting it */
+    for (i = 0; i < layout->cnt; i++) {
+        if (!strcmp(layout->list[i].xlator->name, this->name) &&
+            (layout->list[i].err != 0)) {
+            ret = -1;
+            goto out;
         }
+    }
 
-        /* discard decommissioned subvol */
-        if (conf->decommission_subvols_cnt) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->decommissioned_bricks[i] &&
-                            conf->decommissioned_bricks[i] == this) {
-                                ret = -1;
-                                goto out;
-                        }
-                }
+    /* discard decommissioned subvol */
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == this) {
+                ret = -1;
+                goto out;
+            }
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /*Get subvolume which has both space and inodes more than the min criteria*/
 xlator_t *
-dht_subvol_with_free_space_inodes(xlator_t *this, xlator_t *subvol, xlator_t *ignore,
-                                  dht_layout_t *layout, uint64_t filesize)
+dht_subvol_with_free_space_inodes(xlator_t *this, xlator_t *subvol,
+                                  xlator_t *ignore, dht_layout_t *layout,
+                                  uint64_t filesize)
 {
-        int i = 0;
-        double max = 0;
-        double max_inodes = 0;
-        int    ignore_subvol = 0;
-        uint64_t total_blocks = 0;
-        uint64_t avail_blocks = 0;
-        uint64_t frsize = 0;
-        double   post_availspace = 0;
-        double   post_percent = 0;
-
-        xlator_t *avail_subvol = NULL;
-        dht_conf_t *conf = NULL;
-
-        conf = this->private;
-
-        for(i=0; i < conf->subvolume_cnt; i++) {
-                /* check if subvol has layout errors and also it is not a
-                 * decommissioned brick, before selecting it */
-                ignore_subvol = dht_subvol_has_err (conf, conf->subvolumes[i],
-                                                    ignore, layout);
-                if (ignore_subvol)
-                        continue;
-
-                if ((conf->disk_unit == 'p') &&
-                    (conf->du_stats[i].avail_percent > conf->min_free_disk) &&
-                    (conf->du_stats[i].avail_inodes  > conf->min_free_inodes)) {
-                        if ((conf->du_stats[i].avail_inodes > max_inodes) ||
-                            (conf->du_stats[i].avail_percent > max)) {
-                                max = conf->du_stats[i].avail_percent;
-                                max_inodes = conf->du_stats[i].avail_inodes;
-                                avail_subvol = conf->subvolumes[i];
-                                total_blocks = conf->du_stats[i].total_blocks;
-                                avail_blocks = conf->du_stats[i].avail_blocks;
-                                frsize       = conf->du_stats[i].frsize;
-                        }
-                }
-
-                if ((conf->disk_unit != 'p') &&
-                    (conf->du_stats[i].avail_space > conf->min_free_disk) &&
-                    (conf->du_stats[i].avail_inodes  > conf->min_free_inodes)) {
-                        if ((conf->du_stats[i].avail_inodes > max_inodes) ||
-                            (conf->du_stats[i].avail_space > max)) {
-                                max = conf->du_stats[i].avail_space;
-                                max_inodes = conf->du_stats[i].avail_inodes;
-                                avail_subvol = conf->subvolumes[i];
-                        }
-                }
+    int i = 0;
+    double max = 0;
+    double max_inodes = 0;
+    int ignore_subvol = 0;
+    uint64_t total_blocks = 0;
+    uint64_t avail_blocks = 0;
+    uint64_t frsize = 0;
+    double post_availspace = 0;
+    double post_percent = 0;
+
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        /* check if subvol has layout errors and also it is not a
+         * decommissioned brick, before selecting it */
+        ignore_subvol = dht_subvol_has_err(conf, conf->subvolumes[i], ignore,
+                                           layout);
+        if (ignore_subvol)
+            continue;
+
+        if ((conf->disk_unit == 'p') &&
+            (conf->du_stats[i].avail_percent > conf->min_free_disk) &&
+            (conf->du_stats[i].avail_inodes > conf->min_free_inodes)) {
+            if ((conf->du_stats[i].avail_inodes > max_inodes) ||
+                (conf->du_stats[i].avail_percent > max)) {
+                max = conf->du_stats[i].avail_percent;
+                max_inodes = conf->du_stats[i].avail_inodes;
+                avail_subvol = conf->subvolumes[i];
+                total_blocks = conf->du_stats[i].total_blocks;
+                avail_blocks = conf->du_stats[i].avail_blocks;
+                frsize = conf->du_stats[i].frsize;
+            }
         }
 
-        if (avail_subvol) {
-                if (conf->disk_unit == 'p') {
-                        post_availspace = (avail_blocks * frsize) - filesize;
-                        post_percent = (post_availspace * 100) / (total_blocks * frsize);
-                        if (post_percent < conf->min_free_disk)
-                                avail_subvol = NULL;
-                }
-                if (conf->disk_unit != 'p') {
-                        if ((max - filesize) < conf->min_free_disk)
-                                avail_subvol = NULL;
-                }
+        if ((conf->disk_unit != 'p') &&
+            (conf->du_stats[i].avail_space > conf->min_free_disk) &&
+            (conf->du_stats[i].avail_inodes > conf->min_free_inodes)) {
+            if ((conf->du_stats[i].avail_inodes > max_inodes) ||
+                (conf->du_stats[i].avail_space > max)) {
+                max = conf->du_stats[i].avail_space;
+                max_inodes = conf->du_stats[i].avail_inodes;
+                avail_subvol = conf->subvolumes[i];
+            }
         }
+    }
+
+    if (avail_subvol) {
+        if (conf->disk_unit == 'p') {
+            post_availspace = (avail_blocks * frsize) - filesize;
+            post_percent = (post_availspace * 100) / (total_blocks * frsize);
+            if (post_percent < conf->min_free_disk)
+                avail_subvol = NULL;
+        }
+        if (conf->disk_unit != 'p') {
+            if ((max - filesize) < conf->min_free_disk)
+                avail_subvol = NULL;
+        }
+    }
 
-        return avail_subvol;
+    return avail_subvol;
 }
 
-
-/* Get subvol which has atleast one inode and maximum space */
+/* Get subvol which has at least one inode and maximum space */
 xlator_t *
-dht_subvol_maxspace_nonzeroinode (xlator_t *this, xlator_t *subvol,
-                                  dht_layout_t *layout)
+dht_subvol_maxspace_nonzeroinode(xlator_t *this, xlator_t *subvol,
+                                 dht_layout_t *layout)
 {
-        int         i = 0;
-        double      max = 0;
-        int         ignore_subvol = 0;
-
-        xlator_t   *avail_subvol = NULL;
-        dht_conf_t *conf = NULL;
-
-        conf = this->private;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                /* check if subvol has layout errors and also it is not a
-                 * decommissioned brick, before selecting it*/
-
-                ignore_subvol = dht_subvol_has_err (conf, conf->subvolumes[i], NULL,
-                                                    layout);
-                if (ignore_subvol)
-                        continue;
-
-                if (conf->disk_unit == 'p') {
-                        if ((conf->du_stats[i].avail_percent > max)
-                            && (conf->du_stats[i].avail_inodes > 0 )) {
-                                max = conf->du_stats[i].avail_percent;
-                                avail_subvol = conf->subvolumes[i];
-                        }
-               } else {
-                         if ((conf->du_stats[i].avail_space > max)
-                            && (conf->du_stats[i].avail_inodes > 0)) {
-                                 max = conf->du_stats[i].avail_space;
-                                 avail_subvol = conf->subvolumes[i];
-                         }
-               }
+    int i = 0;
+    double max = 0;
+    int ignore_subvol = 0;
+
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        /* check if subvol has layout errors and also it is not a
+         * decommissioned brick, before selecting it*/
+
+        ignore_subvol = dht_subvol_has_err(conf, conf->subvolumes[i], NULL,
+                                           layout);
+        if (ignore_subvol)
+            continue;
+
+        if (conf->disk_unit == 'p') {
+            if ((conf->du_stats[i].avail_percent > max) &&
+                (conf->du_stats[i].avail_inodes > 0)) {
+                max = conf->du_stats[i].avail_percent;
+                avail_subvol = conf->subvolumes[i];
+            }
+        } else {
+            if ((conf->du_stats[i].avail_space > max) &&
+                (conf->du_stats[i].avail_inodes > 0)) {
+                max = conf->du_stats[i].avail_space;
+                avail_subvol = conf->subvolumes[i];
+            }
         }
+    }
 
-        return avail_subvol;
+    return avail_subvol;
 }
diff --git a/xlators/cluster/dht/src/dht-hashfn.c b/xlators/cluster/dht/src/dht-hashfn.c
index f8e614a40aa..acda67c312a 100644
--- a/xlators/cluster/dht/src/dht-hashfn.c
+++ b/xlators/cluster/dht/src/dht-hashfn.c
@@ -8,104 +8,103 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "glusterfs.h"
-#include "xlator.h"
 #include "dht-common.h"
-#include "hashfn.h"
-
+#include <glusterfs/hashfn.h>
 
-int
-dht_hash_compute_internal (int type, const char *name, uint32_t *hash_p)
+static int
+dht_hash_compute_internal(int type, const char *name, const int len,
+                          uint32_t *hash_p)
 {
-        int      ret = 0;
-        uint32_t hash = 0;
+    int ret = 0;
+    uint32_t hash = 0;
 
-        switch (type) {
+    switch (type) {
         case DHT_HASH_TYPE_DM:
         case DHT_HASH_TYPE_DM_USER:
-                hash = gf_dm_hashfn (name, strlen (name));
-                break;
+            hash = gf_dm_hashfn(name, len);
+            break;
         default:
-                ret = -1;
-                break;
-        }
+            ret = -1;
+            break;
+    }
 
-        if (ret == 0) {
-                *hash_p = hash;
-        }
+    if (ret == 0) {
+        *hash_p = hash;
+    }
 
-        return ret;
+    return ret;
 }
 
-
-static
-gf_boolean_t
-dht_munge_name (const char *original, char *modified,
-                size_t len, regex_t *re)
+/* The function returns:
+ * 0  : in case no munge took place
+ * >0 : the length (inc. terminating NULL!) of the newly modified string,
+ *      if it was munged.
+ */
+static int
+dht_munge_name(const char *original, char *modified, size_t len, regex_t *re)
 {
-        regmatch_t  matches[2] = {{0}, };
-        size_t      new_len    = 0;
-        int         ret        = 0;
-
-        ret = regexec(re, original, 2, matches, 0);
-
-        if (ret != REG_NOMATCH) {
-                if (matches[1].rm_so != -1) {
-                        new_len = matches[1].rm_eo - matches[1].rm_so;
-                        /* Equal would fail due to the NUL at the end. */
-                        if (new_len < len) {
-                                memcpy (modified,original+matches[1].rm_so,
-                                        new_len);
-                                modified[new_len] = '\0';
-                                return _gf_true;
-                        }
-                }
+    regmatch_t matches[2] = {
+        {0},
+    };
+    size_t new_len = 0;
+    int ret = 0;
+
+    ret = regexec(re, original, 2, matches, 0);
+
+    if (ret != REG_NOMATCH) {
+        if (matches[1].rm_so != -1) {
+            new_len = matches[1].rm_eo - matches[1].rm_so;
+            /* Equal would fail due to the NUL at the end. */
+            if (new_len < len) {
+                memcpy(modified, original + matches[1].rm_so, new_len);
+                modified[new_len] = '\0';
+                return new_len + 1; /* +1 for the terminating NULL */
+            }
         }
+    }
 
-        /* This is guaranteed safe because of how the dest was allocated. */
-        strcpy(modified, original);
-        return _gf_false;
+    /* This is guaranteed safe because of how the dest was allocated. */
+    strcpy(modified, original);
+    return 0;
 }
 
 int
-dht_hash_compute (xlator_t *this, int type, const char *name, uint32_t *hash_p)
+dht_hash_compute(xlator_t *this, int type, const char *name, uint32_t *hash_p)
 {
-        char            *rsync_friendly_name    = NULL;
-        dht_conf_t      *priv                   = NULL;
-        size_t           len                    = 0;
-        gf_boolean_t     munged                 = _gf_false;
-
-        priv = this->private;
-
-        LOCK (&priv->lock);
-        {
-                if (priv->extra_regex_valid) {
-                        len = strlen(name) + 1;
-                        rsync_friendly_name = alloca(len);
-                        munged = dht_munge_name (name, rsync_friendly_name, len,
-                                                 &priv->extra_regex);
-                }
-
-                if (!munged && priv->rsync_regex_valid) {
-                        len = strlen(name) + 1;
-                        rsync_friendly_name = alloca(len);
-                        gf_msg_trace (this->name, 0, "trying regex for %s",
-                                      name);
-                        munged = dht_munge_name (name, rsync_friendly_name, len,
-                                                 &priv->rsync_regex);
-                        if (munged) {
-                                gf_msg_debug (this->name, 0,
-                                              "munged down to %s",
-                                              rsync_friendly_name);
-                        }
-                }
-        }
-        UNLOCK (&priv->lock);
+    char *rsync_friendly_name = NULL;
+    dht_conf_t *priv = NULL;
+    size_t len = 0;
+    int munged = 0;
+
+    priv = this->private;
+
+    if (name == NULL)
+        return -1;
 
-        if (!munged) {
-                rsync_friendly_name = (char *)name;
+    len = strlen(name) + 1;
+    rsync_friendly_name = alloca(len);
+
+    LOCK(&priv->lock);
+    {
+        if (priv->extra_regex_valid) {
+            munged = dht_munge_name(name, rsync_friendly_name, len,
+                                    &priv->extra_regex);
         }
 
-        return dht_hash_compute_internal (type, rsync_friendly_name, hash_p);
+        if (!munged && priv->rsync_regex_valid) {
+            gf_msg_trace(this->name, 0, "trying regex for %s", name);
+            munged = dht_munge_name(name, rsync_friendly_name, len,
+                                    &priv->rsync_regex);
+        }
+    }
+    UNLOCK(&priv->lock);
+    if (munged) {
+        gf_msg_debug(this->name, 0, "munged down to %s", rsync_friendly_name);
+        len = munged;
+    } else {
+        rsync_friendly_name = (char *)name;
+    }
+
+    return dht_hash_compute_internal(type, rsync_friendly_name, len - 1,
+                                     hash_p);
 }
diff --git a/xlators/cluster/dht/src/dht-helper.c b/xlators/cluster/dht/src/dht-helper.c
index cca2bfe3eef..3f2fe43d5f3 100644
--- a/xlators/cluster/dht/src/dht-helper.c
+++ b/xlators/cluster/dht/src/dht-helper.c
@@ -8,266 +8,249 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "glusterfs.h"
-#include "xlator.h"
 #include "dht-common.h"
 #include "dht-lock.h"
+#include "glusterfs/compat-errno.h"  // for ENODATA on BSD
 
 static void
-dht_free_fd_ctx (dht_fd_ctx_t *fd_ctx)
+dht_free_fd_ctx(dht_fd_ctx_t *fd_ctx)
 {
-        GF_FREE (fd_ctx);
+    GF_FREE(fd_ctx);
 }
 
-
 int32_t
-dht_fd_ctx_destroy (xlator_t *this, fd_t *fd)
+dht_fd_ctx_destroy(xlator_t *this, fd_t *fd)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int32_t       ret     = -1;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
 
-        ret = fd_ctx_del (fd, this, &value);
-        if (ret) {
-                goto out;
-        }
+    ret = fd_ctx_del(fd, this, &value);
+    if (ret) {
+        goto out;
+    }
 
-        fd_ctx = (dht_fd_ctx_t *)value;
-        if (fd_ctx) {
-                GF_REF_PUT (fd_ctx);
-        }
+    fd_ctx = (dht_fd_ctx_t *)(uintptr_t)value;
+    if (fd_ctx) {
+        GF_REF_PUT(fd_ctx);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__dht_fd_ctx_set (xlator_t *this, fd_t *fd, xlator_t *dst)
+__dht_fd_ctx_set(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int           ret     = -1;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
 
-        fd_ctx = GF_CALLOC (1, sizeof (*fd_ctx), gf_dht_mt_fd_ctx_t);
+    fd_ctx = GF_CALLOC(1, sizeof(*fd_ctx), gf_dht_mt_fd_ctx_t);
 
-        if (!fd_ctx) {
-                goto out;
-        }
+    if (!fd_ctx) {
+        goto out;
+    }
 
-        fd_ctx->opened_on_dst = (uint64_t) dst;
-        GF_REF_INIT (fd_ctx, dht_free_fd_ctx);
+    fd_ctx->opened_on_dst = (uint64_t)(uintptr_t)dst;
+    GF_REF_INIT(fd_ctx, dht_free_fd_ctx);
 
-        value = (uint64_t) fd_ctx;
+    value = (uint64_t)(uintptr_t)fd_ctx;
 
-        ret = __fd_ctx_set (fd, this, value);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_FD_CTX_SET_FAILED,
-                        "Failed to set fd ctx in fd=0x%p", fd);
-                GF_REF_PUT (fd_ctx);
-        }
+    ret = __fd_ctx_set(fd, this, value);
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_FD_CTX_SET_FAILED,
+                "fd=0x%p", fd, NULL);
+        GF_REF_PUT(fd_ctx);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_fd_ctx_set (xlator_t *this, fd_t *fd, xlator_t *dst)
+dht_fd_ctx_set(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int           ret     = -1;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
-
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, this, &value);
-                if (ret && value) {
-
-                        fd_ctx = (dht_fd_ctx_t *) value;
-                        if (fd_ctx->opened_on_dst == (uint64_t) dst)  {
-                                /* This could happen due to racing
-                                 * check_progress tasks*/
-                                goto unlock;
-                        } else {
-                                /* This would be a big problem*/
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_INVALID_VALUE,
-                                        "Different dst found in the fd ctx");
-
-                                /* Overwrite and hope for the best*/
-                                fd_ctx->opened_on_dst = (uint64_t)dst;
-                                goto unlock;
-                        }
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
+
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, this, &value);
+        if (ret && value) {
+            fd_ctx = (dht_fd_ctx_t *)(uintptr_t)value;
+            if (fd_ctx->opened_on_dst == (uint64_t)(uintptr_t)dst) {
+                /* This could happen due to racing
+                 * check_progress tasks*/
+                goto unlock;
+            } else {
+                /* This would be a big problem*/
+                /* Overwrite and hope for the best*/
+                fd_ctx->opened_on_dst = (uint64_t)(uintptr_t)dst;
+                UNLOCK(&fd->lock);
+                gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_VALUE,
+                        NULL);
 
-                }
-                ret = __dht_fd_ctx_set (this, fd, dst);
+                goto out;
+            }
         }
+        ret = __dht_fd_ctx_set(this, fd, dst);
+    }
 unlock:
-        UNLOCK (&fd->lock);
+    UNLOCK(&fd->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
-
-static
-dht_fd_ctx_t *
-dht_fd_ctx_get (xlator_t *this, fd_t *fd)
+static dht_fd_ctx_t *
+dht_fd_ctx_get(xlator_t *this, fd_t *fd)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        int           ret     = -1;
-        uint64_t      tmp_val = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
-
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, this, &tmp_val);
-                if ((ret < 0) || (tmp_val == 0)) {
-                        UNLOCK (&fd->lock);
-                        goto out;
-                }
+    dht_fd_ctx_t *fd_ctx = NULL;
+    int ret = -1;
+    uint64_t tmp_val = 0;
 
-                fd_ctx = (dht_fd_ctx_t *)tmp_val;
-                GF_REF_GET (fd_ctx);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
+
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, this, &tmp_val);
+        if ((ret < 0) || (tmp_val == 0)) {
+            goto unlock;
         }
-        UNLOCK (&fd->lock);
+
+        fd_ctx = (dht_fd_ctx_t *)(uintptr_t)tmp_val;
+        GF_REF_GET(fd_ctx);
+    }
+unlock:
+    UNLOCK(&fd->lock);
 
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
 gf_boolean_t
-dht_fd_open_on_dst (xlator_t *this, fd_t *fd, xlator_t *dst)
+dht_fd_open_on_dst(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t  *fd_ctx  = NULL;
-        gf_boolean_t   opened  = _gf_false;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    gf_boolean_t opened = _gf_false;
 
-        fd_ctx = dht_fd_ctx_get (this, fd);
+    fd_ctx = dht_fd_ctx_get(this, fd);
 
-        if (fd_ctx) {
-                if (fd_ctx->opened_on_dst == (uint64_t) dst) {
-                        opened = _gf_true;
-                }
-                GF_REF_PUT (fd_ctx);
+    if (fd_ctx) {
+        if (fd_ctx->opened_on_dst == (uint64_t)(uintptr_t)dst) {
+            opened = _gf_true;
         }
+        GF_REF_PUT(fd_ctx);
+    }
 
-        return opened;
+    return opened;
 }
 
-
 void
-dht_free_mig_info (void *data)
+dht_free_mig_info(void *data)
 {
-        dht_migrate_info_t *miginfo = NULL;
+    dht_migrate_info_t *miginfo = NULL;
 
-        miginfo = data;
-        GF_FREE (miginfo);
+    miginfo = data;
+    GF_FREE(miginfo);
 
-        return;
+    return;
 }
 
 static int
-dht_inode_ctx_set_mig_info (xlator_t *this, inode_t *inode,
-                            xlator_t *src_subvol, xlator_t *dst_subvol)
+dht_inode_ctx_set_mig_info(xlator_t *this, inode_t *inode, xlator_t *src_subvol,
+                           xlator_t *dst_subvol)
 {
-        dht_migrate_info_t *miginfo = NULL;
-        uint64_t            value   = 0;
-        int                 ret     = -1;
+    dht_migrate_info_t *miginfo = NULL;
+    uint64_t value = 0;
+    int ret = -1;
 
-        miginfo = GF_CALLOC (1, sizeof (*miginfo), gf_dht_mt_miginfo_t);
-        if (miginfo == NULL)
-                goto out;
+    miginfo = GF_CALLOC(1, sizeof(*miginfo), gf_dht_mt_miginfo_t);
+    if (miginfo == NULL)
+        goto out;
 
-        miginfo->src_subvol = src_subvol;
-        miginfo->dst_subvol = dst_subvol;
-        GF_REF_INIT (miginfo, dht_free_mig_info);
+    miginfo->src_subvol = src_subvol;
+    miginfo->dst_subvol = dst_subvol;
+    GF_REF_INIT(miginfo, dht_free_mig_info);
 
-        value = (uint64_t) miginfo;
+    value = (uint64_t)(uintptr_t)miginfo;
 
-        ret = inode_ctx_set1 (inode, this, &value);
-        if (ret < 0) {
-                GF_REF_PUT (miginfo);
-        }
+    ret = inode_ctx_set1(inode, this, &value);
+    if (ret < 0) {
+        GF_REF_PUT(miginfo);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_inode_ctx_get_mig_info (xlator_t *this, inode_t *inode,
-                            xlator_t **src_subvol, xlator_t **dst_subvol)
+dht_inode_ctx_get_mig_info(xlator_t *this, inode_t *inode,
+                           xlator_t **src_subvol, xlator_t **dst_subvol)
 {
-        int                 ret         = -1;
-        uint64_t            tmp_miginfo = 0;
-        dht_migrate_info_t *miginfo     = NULL;
-
-        LOCK (&inode->lock);
-        {
-                ret =  __inode_ctx_get1 (inode, this, &tmp_miginfo);
-                if ((ret < 0) || (tmp_miginfo == 0)) {
-                        UNLOCK (&inode->lock);
-                        goto out;
-                }
+    int ret = -1;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
 
-                miginfo = (dht_migrate_info_t *)tmp_miginfo;
-                GF_REF_GET (miginfo);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get1(inode, this, &tmp_miginfo);
+        if ((ret < 0) || (tmp_miginfo == 0)) {
+            UNLOCK(&inode->lock);
+            goto out;
         }
-        UNLOCK (&inode->lock);
 
-        if (src_subvol)
-                *src_subvol = miginfo->src_subvol;
+        miginfo = (dht_migrate_info_t *)(uintptr_t)tmp_miginfo;
+        GF_REF_GET(miginfo);
+    }
+    UNLOCK(&inode->lock);
 
-        if (dst_subvol)
-                *dst_subvol = miginfo->dst_subvol;
+    if (src_subvol)
+        *src_subvol = miginfo->src_subvol;
 
-        GF_REF_PUT (miginfo);
+    if (dst_subvol)
+        *dst_subvol = miginfo->dst_subvol;
+
+    GF_REF_PUT(miginfo);
 
 out:
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-dht_mig_info_is_invalid (xlator_t *current, xlator_t *src_subvol,
-                      xlator_t *dst_subvol)
+dht_mig_info_is_invalid(xlator_t *current, xlator_t *src_subvol,
+                        xlator_t *dst_subvol)
 {
-
-/* Not set
- */
-        if (!src_subvol || !dst_subvol)
-                return _gf_true;
-
-/* Invalid scenarios:
- * The src_subvol does not match the subvol on which the current op was sent
- * so the cached subvol has changed between the last mig_info_set and now.
- * src_subvol == dst_subvol. The file was migrated without any FOP detecting
- * a P2 so the old dst is now the current subvol.
- *
- * There is still one scenario where the info could be outdated - if
- * file has undergone multiple migrations and ends up on the same src_subvol
- * on which the mig_info was first set.
- */
-        if ((current == dst_subvol) || (current != src_subvol))
-                return _gf_true;
-
-        return _gf_false;
+    /* Not set
+     */
+    if (!src_subvol || !dst_subvol)
+        return _gf_true;
+
+    /* Invalid scenarios:
+     * The src_subvol does not match the subvol on which the current op was sent
+     * so the cached subvol has changed between the last mig_info_set and now.
+     * src_subvol == dst_subvol. The file was migrated without any FOP detecting
+     * a P2 so the old dst is now the current subvol.
+     *
+     * There is still one scenario where the info could be outdated - if
+     * file has undergone multiple migrations and ends up on the same src_subvol
+     * on which the mig_info was first set.
+     */
+    if ((current == dst_subvol) || (current != src_subvol))
+        return _gf_true;
+
+    return _gf_false;
 }
 
-
-
 /* Used to check if fd fops have the fd opened on the cached subvol
  * This is required when:
  * 1. an fd is opened on FILE1 on subvol1
@@ -279,975 +262,974 @@ dht_mig_info_is_invalid (xlator_t *current, xlator_t *src_subvol,
  *
  */
 
-
 int
-dht_check_and_open_fd_on_subvol_complete (int ret, call_frame_t *frame,
-                                          void *data)
+dht_check_and_open_fd_on_subvol_complete(int ret, call_frame_t *frame,
+                                         void *data)
 {
-        glusterfs_fop_t     fop     = 0;
-        dht_local_t        *local   = NULL;
-        xlator_t           *subvol  = NULL;
-        xlator_t           *this  = NULL;
-        fd_t               *fd      = NULL;
-        int                 op_errno = -1;
-
-        local = frame->local;
-        this = frame->this;
-        fop = local->fop;
-        subvol = local->cached_subvol;
-        fd = local->fd;
-
-        if (ret) {
-                op_errno = local->op_errno;
-                goto handle_err;
-        }
-
-        switch (fop) {
-
+    glusterfs_fop_t fop = 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    fd_t *fd = NULL;
+    int op_errno = -1;
+
+    local = frame->local;
+    this = frame->this;
+    fop = local->fop;
+    subvol = local->cached_subvol;
+    fd = local->fd;
+
+    if (ret) {
+        op_errno = local->op_errno;
+        goto handle_err;
+    }
+
+    switch (fop) {
         case GF_FOP_WRITE:
-                STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol, subvol,
-                                   subvol->fops->writev, fd,
-                                   local->rebalance.vector,
-                                   local->rebalance.count,
-                                   local->rebalance.offset,
-                                   local->rebalance.flags,
-                                   local->rebalance.iobref, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                              subvol->fops->writev, fd, local->rebalance.vector,
+                              local->rebalance.count, local->rebalance.offset,
+                              local->rebalance.flags, local->rebalance.iobref,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FLUSH:
-                STACK_WIND (frame, dht_flush_cbk, subvol,
-                            subvol->fops->flush, fd, local->xattr_req);
-                break;
+            STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, fd,
+                       local->xattr_req);
+            break;
 
         case GF_FOP_FSETATTR:
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, fd,
-                                   &local->rebalance.stbuf,
-                                   local->rebalance.flags,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                              subvol->fops->fsetattr, fd,
+                              &local->rebalance.stbuf, local->rebalance.flags,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_ZEROFILL:
-                STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                                   subvol->fops->zerofill, fd,
-                                   local->rebalance.offset,
-                                   local->rebalance.size, local->xattr_req);
+            STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                              subvol->fops->zerofill, fd,
+                              local->rebalance.offset, local->rebalance.size,
+                              local->xattr_req);
 
-                break;
+            break;
 
         case GF_FOP_DISCARD:
-                STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                                   subvol->fops->discard, local->fd,
-                                   local->rebalance.offset,
-                                   local->rebalance.size,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                              subvol->fops->discard, local->fd,
+                              local->rebalance.offset, local->rebalance.size,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FALLOCATE:
-                STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                                   subvol->fops->fallocate, fd,
-                                   local->rebalance.flags,
-                                   local->rebalance.offset,
-                                   local->rebalance.size,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                              subvol->fops->fallocate, fd,
+                              local->rebalance.flags, local->rebalance.offset,
+                              local->rebalance.size, local->xattr_req);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->ftruncate, fd,
-                                   local->rebalance.offset, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                              subvol->fops->ftruncate, fd,
+                              local->rebalance.offset, local->xattr_req);
+            break;
 
         case GF_FOP_FSYNC:
-                STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                                   subvol->fops->fsync, local->fd,
-                                   local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol,
+                              subvol->fops->fsync, local->fd,
+                              local->rebalance.flags, local->xattr_req);
+            break;
 
         case GF_FOP_READ:
-                STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                            local->fd, local->rebalance.size,
-                            local->rebalance.offset,
-                            local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv,
+                       local->fd, local->rebalance.size,
+                       local->rebalance.offset, local->rebalance.flags,
+                       local->xattr_req);
+            break;
 
         case GF_FOP_FSTAT:
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol,
-                                   subvol, subvol->fops->fstat, fd,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                              subvol->fops->fstat, fd, local->xattr_req);
+            break;
 
         case GF_FOP_FSETXATTR:
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, local->fd,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                              subvol->fops->fsetxattr, local->fd,
+                              local->rebalance.xattr, local->rebalance.flags,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FREMOVEXATTR:
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr,
-                                   local->fd, local->key, local->xattr_req);
-
-                break;
-
+            STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                              subvol->fops->fremovexattr, local->fd, local->key,
+                              local->xattr_req);
+
+            break;
+
+        case GF_FOP_FXATTROP:
+            STACK_WIND(frame, dht_common_xattrop_cbk, subvol,
+                       subvol->fops->fxattrop, local->fd,
+                       local->rebalance.flags, local->rebalance.xattr,
+                       local->xattr_req);
+            break;
+
+        case GF_FOP_FGETXATTR:
+            STACK_WIND(frame, dht_getxattr_cbk, subvol, subvol->fops->fgetxattr,
+                       local->fd, local->key, NULL);
+            break;
+
+        case GF_FOP_FINODELK:
+            STACK_WIND(frame, dht_finodelk_cbk, subvol, subvol->fops->finodelk,
+                       local->key, local->fd, local->rebalance.lock_cmd,
+                       &local->rebalance.flock, local->xattr_req);
+            break;
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_UNKNOWN_FOP,
-                        "Unknown FOP on fd (%p) on file %s @ %s",
-                        fd, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                break;
+            gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UNKNOWN_FOP, "fd=%p",
+                    fd, "gfid=%s", uuid_utoa(fd->inode->gfid), "name=%s",
+                    subvol->name, NULL);
+            break;
+    }
 
-        }
+    goto out;
 
-        goto out;
-
-        /* Could not open the fd on the dst. Unwind */
+    /* Could not open the fd on the dst. Unwind */
 
 handle_err:
 
-        switch (fop) {
-
+    switch (fop) {
         case GF_FOP_WRITE:
-                DHT_STACK_UNWIND (writev, frame, -1,
-                                  op_errno, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FLUSH:
-                DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+            break;
 
         case GF_FOP_FSETATTR:
-                DHT_STACK_UNWIND (fsetattr, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_ZEROFILL:
-                DHT_STACK_UNWIND (zerofill, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_DISCARD:
-                DHT_STACK_UNWIND (discard, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FALLOCATE:
-                DHT_STACK_UNWIND (fallocate, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                DHT_STACK_UNWIND (ftruncate, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FSYNC:
-                DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_READ:
-                DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL,
-                                  0, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL,
+                             NULL);
+            break;
 
         case GF_FOP_FSTAT:
-                DHT_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
+            break;
 
         case GF_FOP_FSETXATTR:
-                DHT_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+            break;
 
         case GF_FOP_FREMOVEXATTR:
-                DHT_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
+            break;
+
+        case GF_FOP_FXATTROP:
+            DHT_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
+            break;
+
+        case GF_FOP_FGETXATTR:
+            DHT_STACK_UNWIND(fgetxattr, frame, -1, op_errno, NULL, NULL);
+            break;
+
+        case GF_FOP_FINODELK:
+            DHT_STACK_UNWIND(finodelk, frame, -1, op_errno, NULL);
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_UNKNOWN_FOP,
-                        "Unknown FOP on fd (%p) on file %s @ %s",
-                        fd, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                break;
-        }
+            gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UNKNOWN_FOP, "fd=%p",
+                    fd, "gfid=%s", uuid_utoa(fd->inode->gfid), "name=%s",
+                    subvol->name, NULL);
+            break;
+    }
 
 out:
 
-        return 0;
-
+    return 0;
 }
 
-
 /* Check once again if the fd has been opened on the cached subvol.
  * If not, open and update the fd_ctx.
  */
 
 int
-dht_check_and_open_fd_on_subvol_task (void *data)
+dht_check_and_open_fd_on_subvol_task(void *data)
 {
-        loc_t          loc        = {0,};
-        int            ret        = -1;
-        call_frame_t  *frame      = NULL;
-        dht_local_t   *local      = NULL;
-        fd_t          *fd         = NULL;
-        xlator_t      *this       = NULL;
-        xlator_t      *subvol     = NULL;
-
-
-        frame = data;
-        local = frame->local;
-        this = THIS;
-        fd = local->fd;
-        subvol = local->cached_subvol;
-
-        local->fd_checked = _gf_true;
-
-        if (fd_is_anonymous (fd) || dht_fd_open_on_dst (this, fd, subvol)) {
-                ret = 0;
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0,
-                      "Opening fd (%p, flags=0%o) on file %s @ %s",
-                      fd, fd->flags, uuid_utoa (fd->inode->gfid),
-                      subvol->name);
-
-
-        loc.inode = inode_ref (fd->inode);
-        gf_uuid_copy (loc.gfid, fd->inode->gfid);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    fd_t *fd = NULL;
+    xlator_t *this = NULL;
+    xlator_t *subvol = NULL;
+
+    frame = data;
+    local = frame->local;
+    this = THIS;
+    fd = local->fd;
+    subvol = local->cached_subvol;
+
+    local->fd_checked = _gf_true;
+
+    if (fd_is_anonymous(fd) || dht_fd_open_on_dst(this, fd, subvol)) {
+        ret = 0;
+        goto out;
+    }
 
-        /* Open this on the dst subvol */
+    gf_msg_debug(this->name, 0, "Opening fd (%p, flags=0%o) on file %s @ %s",
+                 fd, fd->flags, uuid_utoa(fd->inode->gfid), subvol->name);
 
-        SYNCTASK_SETID(0, 0);
+    loc.inode = inode_ref(fd->inode);
+    gf_uuid_copy(loc.gfid, fd->inode->gfid);
 
-        ret = syncop_open (subvol, &loc,
-                           (fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
-                           fd, NULL, NULL);
+    /* Open this on the dst subvol */
 
-        if (ret < 0) {
+    SYNCTASK_SETID(0, 0);
 
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_OPEN_FD_ON_DST_FAILED,
-                        "Failed to open the fd"
-                        " (%p, flags=0%o) on file %s @ %s",
-                        fd, fd->flags, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                /* This can happen if the cached subvol was updated in the
-                 * inode_ctx and the fd was opened on the new cached suvol
-                 * after this fop was wound on the old cached subvol.
-                 * As we do not close the fd on the old subvol (a leak)
-                 * don't treat ENOENT as an error and allow the phase1/phase2
-                 * checks to handle it.
-                 */
-
-                if ((-ret != ENOENT) && (-ret != ESTALE)) {
-                        local->op_errno = -ret;
-                        ret = -1;
-                } else {
-                        ret = 0;
-                }
+    ret = syncop_open(subvol, &loc, (fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                      fd, NULL, NULL);
 
-                local->op_errno = -ret;
-                ret = -1;
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_OPEN_FD_ON_DST_FAILED,
+                "fd=%p", fd, "flags=0%o", fd->flags, "gfid=%s",
+                uuid_utoa(fd->inode->gfid), "name=%s", subvol->name, NULL);
+        /* This can happen if the cached subvol was updated in the
+         * inode_ctx and the fd was opened on the new cached suvol
+         * after this fop was wound on the old cached subvol.
+         * As we do not close the fd on the old subvol (a leak)
+         * don't treat ENOENT as an error and allow the phase1/phase2
+         * checks to handle it.
+         */
 
+        if ((-ret != ENOENT) && (-ret != ESTALE)) {
+            local->op_errno = -ret;
+            ret = -1;
         } else {
-                dht_fd_ctx_set (this, fd, subvol);
+            ret = 0;
         }
 
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
+        local->op_errno = -ret;
+        ret = -1;
+
+    } else {
+        dht_fd_ctx_set(this, fd, subvol);
+    }
+
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
-
 int
-dht_check_and_open_fd_on_subvol (xlator_t *this, call_frame_t *frame)
+dht_check_and_open_fd_on_subvol(xlator_t *this, call_frame_t *frame)
 {
-        int ret            = -1;
-        dht_local_t *local = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-/*
-        if (dht_fd_open_on_dst (this, fd, subvol))
-                goto out;
-*/
-        local = frame->local;
+    /*
+            if (dht_fd_open_on_dst (this, fd, subvol))
+                    goto out;
+    */
+    local = frame->local;
 
-        ret = synctask_new (this->ctx->env,
-                            dht_check_and_open_fd_on_subvol_task,
-                            dht_check_and_open_fd_on_subvol_complete,
-                            frame, frame);
+    ret = synctask_new(this->ctx->env, dht_check_and_open_fd_on_subvol_task,
+                       dht_check_and_open_fd_on_subvol_complete, frame, frame);
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0,
-                        "Failed to create synctask"
-                        " to check and open fd=%p", local->fd);
-        }
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SYNCTASK_CREATE_FAILED,
+                "to-check-and-open fd=%p", local->fd, NULL);
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_frame_return (call_frame_t *frame)
+dht_frame_return(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        int          this_call_cnt = -1;
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
 
-        if (!frame)
-                return -1;
+    if (!frame)
+        return -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+    }
+    UNLOCK(&frame->lock);
 
-        return this_call_cnt;
+    return this_call_cnt;
 }
 
+/*
+ * Use this function to specify which subvol you want the file created
+ * on - this need not be the hashed subvol.
+ * Format: <filename>@<this->name>:<subvol-name>
+ * Eg: file-1@vol1-dht:vol1-client-0
+ *     where vol1 is a pure distribute volume
+ *     will create file-1 on vol1-client-0
+ */
 
 int
-dht_filter_loc_subvol_key (xlator_t *this, loc_t *loc, loc_t *new_loc,
-                           xlator_t **subvol)
+dht_filter_loc_subvol_key(xlator_t *this, loc_t *loc, loc_t *new_loc,
+                          xlator_t **subvol)
 {
-        char          *new_name  = NULL;
-        char          *new_path  = NULL;
-        xlator_list_t *trav      = NULL;
-        char           key[1024] = {0,};
-        int            ret       = 0; /* not found */
-
-        /* Why do other tasks if first required 'char' itself is not there */
-        if (!new_loc || !loc || !loc->name || !strchr (loc->name, '@')) {
-                /* Skip the GF_FREE checks here */
-                return ret;
-        }
-
-        trav = this->children;
-        while (trav) {
-                snprintf (key, 1024, "*@%s:%s", this->name, trav->xlator->name);
-                if (fnmatch (key, loc->name, FNM_NOESCAPE) == 0) {
-                        new_name = GF_CALLOC(strlen (loc->name),
-                                             sizeof (char),
-                                             gf_common_mt_char);
-                        if (!new_name)
-                                goto out;
-                        if (fnmatch (key, loc->path, FNM_NOESCAPE) == 0) {
-                                new_path = GF_CALLOC(strlen (loc->path),
-                                                     sizeof (char),
-                                                     gf_common_mt_char);
-                                if (!new_path)
-                                        goto out;
-                                strncpy (new_path, loc->path, (strlen (loc->path) -
-                                                               strlen (key) + 1));
-                        }
-                        strncpy (new_name, loc->name, (strlen (loc->name) -
-                                                       strlen (key) + 1));
-
-                        if (new_loc) {
-                                new_loc->path   = ((new_path) ? new_path:
-                                                   gf_strdup (loc->path));
-                                new_loc->name   = new_name;
-                                new_loc->inode  = inode_ref (loc->inode);
-                                new_loc->parent = inode_ref (loc->parent);
-                        }
-                        *subvol         = trav->xlator;
-                        ret = 1;  /* success */
-                        goto out;
-                }
-                trav = trav->next;
-        }
-out:
-        if (!ret) {
-                /* !success */
-                GF_FREE (new_path);
-                GF_FREE (new_name);
-        }
+    char *new_name = NULL;
+    char *new_path = NULL;
+    xlator_list_t *trav = NULL;
+    char key[1024] = {
+        0,
+    };
+    int ret = 0; /* not found */
+    int keylen = 0;
+    int name_len = 0;
+    int path_len = 0;
+
+    /* Why do other tasks if first required 'char' itself is not there */
+    if (!new_loc || !loc || !loc->name || !strchr(loc->name, '@')) {
+        /* Skip the GF_FREE checks here */
         return ret;
+    }
+
+    trav = this->children;
+    while (trav) {
+        keylen = snprintf(key, sizeof(key), "*@%s:%s", this->name,
+                          trav->xlator->name);
+        /* Ignore '*' */
+        keylen = keylen - 1;
+        if (fnmatch(key, loc->name, FNM_NOESCAPE) == 0) {
+            name_len = strlen(loc->name) - keylen;
+            new_name = GF_MALLOC(name_len + 1, gf_common_mt_char);
+            if (!new_name)
+                goto out;
+            if (fnmatch(key, loc->path, FNM_NOESCAPE) == 0) {
+                path_len = strlen(loc->path) - keylen;
+                new_path = GF_MALLOC(path_len + 1, gf_common_mt_char);
+                if (!new_path)
+                    goto out;
+                snprintf(new_path, path_len + 1, "%s", loc->path);
+            }
+            snprintf(new_name, name_len + 1, "%s", loc->name);
+
+            if (new_loc) {
+                new_loc->path = ((new_path) ? new_path : gf_strdup(loc->path));
+                new_loc->name = new_name;
+                new_loc->inode = inode_ref(loc->inode);
+                new_loc->parent = inode_ref(loc->parent);
+            }
+            *subvol = trav->xlator;
+            ret = 1; /* success */
+            goto out;
+        }
+        trav = trav->next;
+    }
+out:
+    if (!ret) {
+        /* !success */
+        GF_FREE(new_path);
+        GF_FREE(new_name);
+    }
+    return ret;
 }
 
 static xlator_t *
 dht_get_subvol_from_id(xlator_t *this, int client_id)
 {
-        xlator_t   *xl   = NULL;
-        dht_conf_t *conf = NULL;
-        char       *sid  = NULL;
-        int32_t     ret  = -1;
-
-        conf = this->private;
-
-        ret = gf_asprintf(&sid, "%d", client_id);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_ASPRINTF_FAILED, "asprintf failed while "
-                        "fetching subvol from the id");
-                goto out;
-        }
+    xlator_t *xl = NULL;
+    dht_conf_t *conf = NULL;
+    char *sid = NULL;
+    int32_t ret = -1;
 
-        if (dict_get_ptr(conf->leaf_to_subvol, sid, (void **) &xl))
-                xl = NULL;
+    conf = this->private;
 
-        GF_FREE (sid);
+    ret = gf_asprintf(&sid, "%d", client_id);
+    if (ret == -1) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_ASPRINTF_FAILED, NULL);
+        goto out;
+    }
 
-out:
-        return xl;
+    if (dict_get_ptr(conf->leaf_to_subvol, sid, (void **)&xl))
+        xl = NULL;
 
+    GF_FREE(sid);
+
+out:
+    return xl;
 }
 
 int
-dht_deitransform (xlator_t *this, uint64_t y, xlator_t **subvol_p)
+dht_deitransform(xlator_t *this, uint64_t y, xlator_t **subvol_p)
 {
-        int         client_id = 0;
-        xlator_t   *subvol = 0;
-        dht_conf_t *conf = NULL;
+    int client_id = 0;
+    xlator_t *subvol = 0;
+    dht_conf_t *conf = NULL;
 
-        if (!this->private)
-                return -1;
+    if (!this->private)
+        return -1;
 
-        conf = this->private;
+    conf = this->private;
 
-        client_id = gf_deitransform(this, y);
+    client_id = gf_deitransform(this, y);
 
-        subvol = dht_get_subvol_from_id(this, client_id);
+    subvol = dht_get_subvol_from_id(this, client_id);
 
-        if (!subvol)
-                subvol = conf->subvolumes[0];
+    if (!subvol)
+        subvol = conf->subvolumes[0];
 
-        if (subvol_p)
-                *subvol_p = subvol;
+    if (subvol_p)
+        *subvol_p = subvol;
 
-        return 0;
+    return 0;
 }
 
 void
-dht_local_wipe (xlator_t *this, dht_local_t *local)
+dht_local_wipe(xlator_t *this, dht_local_t *local)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!local)
-                return;
+    if (!local)
+        return;
 
-        loc_wipe (&local->loc);
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc);
+    loc_wipe(&local->loc2);
+    loc_wipe(&local->loc2_copy);
 
-        if (local->xattr)
-                dict_unref (local->xattr);
+    if (local->xattr)
+        dict_unref(local->xattr);
 
-        if (local->inode)
-                inode_unref (local->inode);
+    if (local->inode)
+        inode_unref(local->inode);
 
-        if (local->layout) {
-                dht_layout_unref (this, local->layout);
-                local->layout = NULL;
-        }
+    if (local->layout) {
+        dht_layout_unref(this, local->layout);
+        local->layout = NULL;
+    }
 
-        loc_wipe (&local->linkfile.loc);
+    loc_wipe(&local->linkfile.loc);
 
-        if (local->linkfile.xattr)
-                dict_unref (local->linkfile.xattr);
+    if (local->linkfile.xattr)
+        dict_unref(local->linkfile.xattr);
 
-        if (local->linkfile.inode)
-                inode_unref (local->linkfile.inode);
+    if (local->linkfile.inode)
+        inode_unref(local->linkfile.inode);
 
-        if (local->fd) {
-                fd_unref (local->fd);
-                local->fd = NULL;
-        }
+    if (local->fd) {
+        fd_unref(local->fd);
+        local->fd = NULL;
+    }
 
-        if (local->params) {
-                dict_unref (local->params);
-                local->params = NULL;
-        }
+    if (local->params) {
+        dict_unref(local->params);
+        local->params = NULL;
+    }
 
-        if (local->xattr_req)
-                dict_unref (local->xattr_req);
+    if (local->xattr_req)
+        dict_unref(local->xattr_req);
+    if (local->mds_xattr)
+        dict_unref(local->mds_xattr);
+    if (local->xdata)
+        dict_unref(local->xdata);
 
-        if (local->selfheal.layout) {
-                dht_layout_unref (this, local->selfheal.layout);
-                local->selfheal.layout = NULL;
-        }
+    if (local->selfheal.layout) {
+        dht_layout_unref(this, local->selfheal.layout);
+        local->selfheal.layout = NULL;
+    }
 
-        if (local->selfheal.refreshed_layout) {
-                dht_layout_unref (this, local->selfheal.refreshed_layout);
-                local->selfheal.refreshed_layout = NULL;
-        }
+    if (local->selfheal.refreshed_layout) {
+        dht_layout_unref(this, local->selfheal.refreshed_layout);
+        local->selfheal.refreshed_layout = NULL;
+    }
 
-        for (i = 0; i < 2; i++) {
-                dht_lock_array_free (local->lock[i].ns.parent_layout.locks,
-                                     local->lock[i].ns.parent_layout.lk_count);
+    for (i = 0; i < 2; i++) {
+        dht_lock_array_free(local->lock[i].ns.parent_layout.locks,
+                            local->lock[i].ns.parent_layout.lk_count);
 
-                GF_FREE (local->lock[i].ns.parent_layout.locks);
+        GF_FREE(local->lock[i].ns.parent_layout.locks);
 
-                dht_lock_array_free (local->lock[i].ns.directory_ns.locks,
-                                     local->lock[i].ns.directory_ns.lk_count);
-                GF_FREE (local->lock[i].ns.directory_ns.locks);
-        }
+        dht_lock_array_free(local->lock[i].ns.directory_ns.locks,
+                            local->lock[i].ns.directory_ns.lk_count);
+        GF_FREE(local->lock[i].ns.directory_ns.locks);
+    }
 
-        GF_FREE (local->key);
+    GF_FREE(local->key);
 
-        if (local->rebalance.xdata)
-                dict_unref (local->rebalance.xdata);
+    if (local->rebalance.xdata)
+        dict_unref(local->rebalance.xdata);
 
-        if (local->rebalance.xattr)
-                dict_unref (local->rebalance.xattr);
+    if (local->rebalance.xattr)
+        dict_unref(local->rebalance.xattr);
 
-        GF_FREE (local->rebalance.vector);
+    if (local->rebalance.dict)
+        dict_unref(local->rebalance.dict);
 
-        if (local->rebalance.iobref)
-                iobref_unref (local->rebalance.iobref);
+    GF_FREE(local->rebalance.vector);
 
-        if (local->stub) {
-                call_stub_destroy (local->stub);
-                local->stub = NULL;
-        }
+    if (local->rebalance.iobref)
+        iobref_unref(local->rebalance.iobref);
 
-        if (local->ret_cache)
-                GF_FREE (local->ret_cache);
+    if (local->stub) {
+        call_stub_destroy(local->stub);
+        local->stub = NULL;
+    }
 
-        gf_dirent_free (&local->entries);
+    if (local->ret_cache)
+        GF_FREE(local->ret_cache);
 
-        mem_put (local);
+    mem_put(local);
 }
 
-
 dht_local_t *
-dht_local_init (call_frame_t *frame, loc_t *loc, fd_t *fd, glusterfs_fop_t fop)
+dht_local_init(call_frame_t *frame, loc_t *loc, fd_t *fd, glusterfs_fop_t fop)
 {
-        dht_local_t *local = NULL;
-        inode_t     *inode = NULL;
-        int          ret   = 0;
+    dht_local_t *local = NULL;
+    inode_t *inode = NULL;
+    int ret = 0;
 
-        local = mem_get0 (THIS->local_pool);
-        if (!local)
-                goto out;
+    local = mem_get0(THIS->local_pool);
+    if (!local)
+        goto out;
 
-        if (loc) {
-                ret = loc_copy (&local->loc, loc);
-                if (ret)
-                        goto out;
+    if (loc) {
+        ret = loc_copy(&local->loc, loc);
+        if (ret)
+            goto out;
 
-                inode = loc->inode;
-        }
+        inode = loc->inode;
+    }
 
-        if (fd) {
-                local->fd = fd_ref (fd);
-                if (!inode)
-                        inode = fd->inode;
-        }
+    if (fd) {
+        local->fd = fd_ref(fd);
+        if (!inode)
+            inode = fd->inode;
+    }
 
-        local->op_ret   = -1;
-        local->op_errno = EUCLEAN;
-        local->fop      = fop;
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
+    local->fop = fop;
 
-        if (inode) {
-                local->layout   = dht_layout_get (frame->this, inode);
-                local->cached_subvol = dht_subvol_get_cached (frame->this,
-                                                              inode);
-        }
+    if (inode) {
+        local->layout = dht_layout_get(frame->this, inode);
+        local->cached_subvol = dht_subvol_get_cached(frame->this, inode);
+    }
 
-        INIT_LIST_HEAD (&local->entries.list);
-        frame->local = local;
+    frame->local = local;
 
 out:
-        if (ret) {
-                if (local)
-                        mem_put (local);
-                local = NULL;
-        }
-        return local;
+    if (ret) {
+        if (local)
+            mem_put(local);
+        local = NULL;
+    }
+    return local;
 }
 
 xlator_t *
-dht_first_up_subvol (xlator_t *this)
+dht_first_up_subvol(xlator_t *this)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *child = NULL;
-        int         i = 0;
-        time_t      time = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *child = NULL;
+    int i = 0;
+    time_t time = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        LOCK (&conf->subvolume_lock);
-        {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvol_up_time[i]) {
-                                if (!time) {
-                                        time = conf->subvol_up_time[i];
-                                        child = conf->subvolumes[i];
-                                } else if (time > conf->subvol_up_time[i]) {
-                                        time  = conf->subvol_up_time[i];
-                                        child = conf->subvolumes[i];
-                                }
-                        }
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvol_up_time[i]) {
+                if (!time) {
+                    time = conf->subvol_up_time[i];
+                    child = conf->subvolumes[i];
+                } else if (time > conf->subvol_up_time[i]) {
+                    time = conf->subvol_up_time[i];
+                    child = conf->subvolumes[i];
                 }
+            }
         }
-        UNLOCK (&conf->subvolume_lock);
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return child;
+    return child;
 }
 
 xlator_t *
-dht_last_up_subvol (xlator_t *this)
+dht_last_up_subvol(xlator_t *this)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *child = NULL;
-        int         i = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *child = NULL;
+    int i = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        LOCK (&conf->subvolume_lock);
-        {
-                for (i = conf->subvolume_cnt-1; i >= 0; i--) {
-                        if (conf->subvolume_status[i]) {
-                                child = conf->subvolumes[i];
-                                break;
-                        }
-                }
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = conf->subvolume_cnt - 1; i >= 0; i--) {
+            if (conf->subvolume_status[i]) {
+                child = conf->subvolumes[i];
+                break;
+            }
         }
-        UNLOCK (&conf->subvolume_lock);
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return child;
+    return child;
 }
 
 xlator_t *
-dht_subvol_get_hashed (xlator_t *this, loc_t *loc)
+dht_subvol_get_hashed(xlator_t *this, loc_t *loc)
 {
-        dht_layout_t *layout = NULL;
-        xlator_t     *subvol = NULL;
-        dht_conf_t *conf = NULL;
-        dht_methods_t *methods = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc, out);
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        if (__is_root_gfid (loc->gfid)) {
-                subvol = dht_first_up_subvol (this);
-                goto out;
-        }
+    if (__is_root_gfid(loc->gfid)) {
+        subvol = dht_first_up_subvol(this);
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO (this->name, loc->parent, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc->name, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc->parent, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc->name, out);
 
-        layout = dht_layout_get (this, loc->parent);
+    layout = dht_layout_get(this, loc->parent);
 
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "Missing layout. path=%s, parent gfid =%s",
-                              loc->path, uuid_utoa (loc->parent->gfid));
-                goto out;
-        }
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "Missing layout. path=%s, parent gfid =%s",
+                     loc->path, uuid_utoa(loc->parent->gfid));
+        goto out;
+    }
 
-        subvol = methods->layout_search (this, layout, loc->name);
+    subvol = methods->layout_search(this, layout, loc->name);
 
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "No hashed subvolume for path=%s",
-                              loc->path);
-                goto out;
-        }
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "No hashed subvolume for path=%s",
+                     loc->path);
+        goto out;
+    }
 
 out:
-        if (layout) {
-                dht_layout_unref (this, layout);
-        }
+    if (layout) {
+        dht_layout_unref(this, layout);
+    }
 
-        return subvol;
+    return subvol;
 }
 
-
 xlator_t *
-dht_subvol_get_cached (xlator_t *this, inode_t *inode)
+dht_subvol_get_cached(xlator_t *this, inode_t *inode)
 {
-        dht_layout_t *layout = NULL;
-        xlator_t     *subvol = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *subvol = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        layout = dht_layout_get (this, inode);
+    layout = dht_layout_get(this, inode);
 
-        if (!layout) {
-                goto out;
-        }
+    if (!layout) {
+        goto out;
+    }
 
-        subvol = layout->list[0].xlator;
+    subvol = layout->list[0].xlator;
 
 out:
-        if (layout) {
-                dht_layout_unref (this, layout);
-        }
+    if (layout) {
+        dht_layout_unref(this, layout);
+    }
 
-        return subvol;
+    return subvol;
 }
 
-
 xlator_t *
-dht_subvol_next (xlator_t *this, xlator_t *prev)
+dht_subvol_next(xlator_t *this, xlator_t *prev)
 {
-        dht_conf_t *conf = NULL;
-        int         i = 0;
-        xlator_t   *next = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *next = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == prev) {
-                        if ((i + 1) < conf->subvolume_cnt)
-                                next = conf->subvolumes[i + 1];
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == prev) {
+            if ((i + 1) < conf->subvolume_cnt)
+                next = conf->subvolumes[i + 1];
+            break;
         }
+    }
 
 out:
-        return next;
+    return next;
 }
 
 /* This func wraps around, if prev is actually the last subvol.
  */
 xlator_t *
-dht_subvol_next_available (xlator_t *this, xlator_t *prev)
+dht_subvol_next_available(xlator_t *this, xlator_t *prev)
 {
-        dht_conf_t *conf = NULL;
-        int         i = 0;
-        xlator_t   *next = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *next = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == prev) {
-                        /* if prev is last in conf->subvolumes, then wrap
-                         * around.
-                         */
-                        if ((i + 1) < conf->subvolume_cnt) {
-                                next = conf->subvolumes[i + 1];
-                        } else {
-                                next = conf->subvolumes[0];
-                        }
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == prev) {
+            /* if prev is last in conf->subvolumes, then wrap
+             * around.
+             */
+            if ((i + 1) < conf->subvolume_cnt) {
+                next = conf->subvolumes[i + 1];
+            } else {
+                next = conf->subvolumes[0];
+            }
+            break;
         }
+    }
 
 out:
-        return next;
+    return next;
 }
 int
-dht_subvol_cnt (xlator_t *this, xlator_t *subvol)
+dht_subvol_cnt(xlator_t *this, xlator_t *subvol)
 {
-        int i = 0;
-        int ret = -1;
-        dht_conf_t *conf = NULL;
+    int i = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (subvol == conf->subvolumes[i]) {
-                        ret = i;
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (subvol == conf->subvolumes[i]) {
+            ret = i;
+            break;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
+#define set_if_greater(a, b)                                                   \
+    do {                                                                       \
+        if ((a) < (b))                                                         \
+            (a) = (b);                                                         \
+    } while (0)
 
-#define set_if_greater(a, b) do {               \
-                if ((a) < (b))                  \
-                        (a) = (b);              \
-        } while (0)
-
-
-#define set_if_greater_time(a, an, b, bn) do {                          \
-                if (((a) < (b)) || (((a) == (b)) && ((an) < (bn)))){    \
-                        (a) = (b);                                      \
-                        (an) = (bn);                                    \
-                }                                                       \
-        } while (0)                                                     \
-
+#define set_if_greater_time(a, an, b, bn)                                      \
+    do {                                                                       \
+        if (((a) < (b)) || (((a) == (b)) && ((an) < (bn)))) {                  \
+            (a) = (b);                                                         \
+            (an) = (bn);                                                       \
+        }                                                                      \
+    } while (0)
 
 int
-dht_iatt_merge (xlator_t *this, struct iatt *to,
-                struct iatt *from, xlator_t *subvol)
+dht_iatt_merge(xlator_t *this, struct iatt *to, struct iatt *from)
 {
-        if (!from || !to)
-                return 0;
-
-        to->ia_dev      = from->ia_dev;
-
-        gf_uuid_copy (to->ia_gfid, from->ia_gfid);
-
-        to->ia_ino      = from->ia_ino;
-        to->ia_prot     = from->ia_prot;
-        to->ia_type     = from->ia_type;
-        to->ia_nlink    = from->ia_nlink;
-        to->ia_rdev     = from->ia_rdev;
-        to->ia_size    += from->ia_size;
-        to->ia_blksize  = from->ia_blksize;
-        to->ia_blocks  += from->ia_blocks;
-
-        if (IA_ISDIR (from->ia_type)) {
-                to->ia_blocks = DHT_DIR_STAT_BLOCKS;
-                to->ia_size = DHT_DIR_STAT_SIZE;
-        }
-        set_if_greater (to->ia_uid, from->ia_uid);
-        set_if_greater (to->ia_gid, from->ia_gid);
-
-        set_if_greater_time(to->ia_atime, to->ia_atime_nsec,
-                            from->ia_atime, from->ia_atime_nsec);
-        set_if_greater_time (to->ia_mtime, to->ia_mtime_nsec,
-                             from->ia_mtime, from->ia_mtime_nsec);
-        set_if_greater_time (to->ia_ctime, to->ia_ctime_nsec,
-                             from->ia_ctime, from->ia_ctime_nsec);
-
+    if (!from || !to)
         return 0;
+
+    to->ia_dev = from->ia_dev;
+
+    gf_uuid_copy(to->ia_gfid, from->ia_gfid);
+
+    to->ia_ino = from->ia_ino;
+    to->ia_prot = from->ia_prot;
+    to->ia_type = from->ia_type;
+    to->ia_nlink = from->ia_nlink;
+    to->ia_rdev = from->ia_rdev;
+    to->ia_size += from->ia_size;
+    to->ia_blksize = from->ia_blksize;
+    to->ia_blocks += from->ia_blocks;
+
+    if (IA_ISDIR(from->ia_type)) {
+        to->ia_blocks = DHT_DIR_STAT_BLOCKS;
+        to->ia_size = DHT_DIR_STAT_SIZE;
+    }
+    set_if_greater(to->ia_uid, from->ia_uid);
+    set_if_greater(to->ia_gid, from->ia_gid);
+
+    set_if_greater_time(to->ia_atime, to->ia_atime_nsec, from->ia_atime,
+                        from->ia_atime_nsec);
+    set_if_greater_time(to->ia_mtime, to->ia_mtime_nsec, from->ia_mtime,
+                        from->ia_mtime_nsec);
+    set_if_greater_time(to->ia_ctime, to->ia_ctime_nsec, from->ia_ctime,
+                        from->ia_ctime_nsec);
+
+    return 0;
 }
 
 int
-dht_build_child_loc (xlator_t *this, loc_t *child, loc_t *parent, char *name)
+dht_build_child_loc(xlator_t *this, loc_t *child, loc_t *parent, char *name)
 {
-        if (!child) {
-                goto err;
-        }
+    if (!child) {
+        goto err;
+    }
 
-        if (strcmp (parent->path, "/") == 0)
-                gf_asprintf ((char **)&child->path, "/%s", name);
-        else
-                gf_asprintf ((char **)&child->path, "%s/%s", parent->path, name);
+    if (strcmp(parent->path, "/") == 0)
+        gf_asprintf((char **)&child->path, "/%s", name);
+    else
+        gf_asprintf((char **)&child->path, "%s/%s", parent->path, name);
 
-        if (!child->path) {
-                goto err;
-        }
+    if (!child->path) {
+        goto err;
+    }
 
-        child->name = strrchr (child->path, '/');
-        if (child->name)
-                child->name++;
+    child->name = strrchr(child->path, '/');
+    if (child->name)
+        child->name++;
 
-        child->parent = inode_ref (parent->inode);
-        child->inode = inode_new (parent->inode->table);
+    child->parent = inode_ref(parent->inode);
+    child->inode = inode_new(parent->inode->table);
 
-        if (!child->inode) {
-                goto err;
-        }
+    if (!child->inode) {
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        loc_wipe (child);
-        return -1;
+    if (child) {
+        loc_wipe(child);
+    }
+    return -1;
 }
 
 int
-dht_init_local_subvolumes (xlator_t *this, dht_conf_t *conf)
+dht_init_local_subvolumes(xlator_t *this, dht_conf_t *conf)
 {
-        xlator_list_t *subvols = NULL;
-        int            cnt = 0;
+    xlator_list_t *subvols = NULL;
+    int cnt = 0;
 
-        if (!conf)
-                return -1;
+    if (!conf)
+        return -1;
 
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                cnt++;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        cnt++;
 
-        conf->local_subvols = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                        gf_dht_mt_xlator_t);
+    conf->local_subvols = GF_CALLOC(cnt, sizeof(xlator_t *),
+                                    gf_dht_mt_xlator_t);
 
-        /* FIX FIX : do this dynamically*/
-        conf->local_nodeuuids = GF_CALLOC (cnt,
-                                           sizeof (subvol_nodeuuids_info_t),
-                                           gf_dht_nodeuuids_t);
+    /* FIX FIX : do this dynamically*/
+    conf->local_nodeuuids = GF_CALLOC(cnt, sizeof(subvol_nodeuuids_info_t),
+                                      gf_dht_nodeuuids_t);
 
-        if (!conf->local_subvols || !conf->local_nodeuuids) {
-                return -1;
-        }
+    if (!conf->local_subvols || !conf->local_nodeuuids) {
+        return -1;
+    }
 
-        conf->local_subvols_cnt = 0;
+    conf->local_subvols_cnt = 0;
 
-        return 0;
+    return 0;
 }
 
 int
-dht_init_subvolumes (xlator_t *this, dht_conf_t *conf)
+dht_init_subvolumes(xlator_t *this, dht_conf_t *conf)
 {
-        xlator_list_t *subvols = NULL;
-        int            cnt = 0;
+    xlator_list_t *subvols = NULL;
+    int cnt = 0;
 
-        if (!conf)
-                return -1;
+    if (!conf)
+        return -1;
 
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                cnt++;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        cnt++;
 
-        conf->subvolumes = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                      gf_dht_mt_xlator_t);
-        if (!conf->subvolumes) {
-                return -1;
-        }
-        conf->subvolume_cnt = cnt;
+    conf->subvolumes = GF_CALLOC(cnt, sizeof(xlator_t *), gf_dht_mt_xlator_t);
+    if (!conf->subvolumes) {
+        return -1;
+    }
+    conf->subvolume_cnt = cnt;
+    /* Doesn't make sense to do any dht layer tasks
+       if the subvol count is 1. Set it as pass_through */
+    if (cnt == 1)
+        this->pass_through = _gf_true;
 
-        conf->local_subvols_cnt = 0;
+    conf->local_subvols_cnt = 0;
 
-        dht_set_subvol_range(this);
+    dht_set_subvol_range(this);
 
-        cnt = 0;
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                conf->subvolumes[cnt++] = subvols->xlator;
+    cnt = 0;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        conf->subvolumes[cnt++] = subvols->xlator;
 
-        conf->subvolume_status = GF_CALLOC (cnt, sizeof (char),
-                                            gf_dht_mt_char);
-        if (!conf->subvolume_status) {
-                return -1;
-        }
+    conf->subvolume_status = GF_CALLOC(cnt, sizeof(char), gf_dht_mt_char);
+    if (!conf->subvolume_status) {
+        return -1;
+    }
 
-        conf->last_event = GF_CALLOC (cnt, sizeof (int),
-                                      gf_dht_mt_char);
-        if (!conf->last_event) {
-                return -1;
-        }
+    conf->last_event = GF_CALLOC(cnt, sizeof(int), gf_dht_mt_char);
+    if (!conf->last_event) {
+        return -1;
+    }
 
-        conf->subvol_up_time = GF_CALLOC (cnt, sizeof (time_t),
-                                          gf_dht_mt_subvol_time);
-        if (!conf->subvol_up_time) {
-                return -1;
-        }
+    conf->subvol_up_time = GF_CALLOC(cnt, sizeof(time_t),
+                                     gf_dht_mt_subvol_time);
+    if (!conf->subvol_up_time) {
+        return -1;
+    }
 
-        conf->du_stats = GF_CALLOC (conf->subvolume_cnt, sizeof (dht_du_t),
-                                    gf_dht_mt_dht_du_t);
-        if (!conf->du_stats) {
-                return -1;
-        }
+    conf->du_stats = GF_CALLOC(conf->subvolume_cnt, sizeof(dht_du_t),
+                               gf_dht_mt_dht_du_t);
+    if (!conf->du_stats) {
+        return -1;
+    }
 
-        conf->decommissioned_bricks = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                                 gf_dht_mt_xlator_t);
-        if (!conf->decommissioned_bricks) {
-                return -1;
-        }
+    conf->decommissioned_bricks = GF_CALLOC(cnt, sizeof(xlator_t *),
+                                            gf_dht_mt_xlator_t);
+    if (!conf->decommissioned_bricks) {
+        return -1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 /*
  op_ret values :
   0 : Success.
@@ -1256,270 +1238,274 @@ dht_init_subvolumes (xlator_t *this, dht_conf_t *conf)
 */
 
 static int
-dht_migration_complete_check_done (int op_ret, call_frame_t *frame, void *data)
+dht_migration_complete_check_done(int op_ret, call_frame_t *frame, void *data)
 {
-        dht_local_t *local  = NULL;
-        xlator_t    *subvol = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret != 0)
-                goto out;
+    if (op_ret != 0)
+        goto out;
 
-        if (local->cached_subvol == NULL) {
-                local->op_errno = EINVAL;
-                goto out;
-        }
+    if (local->cached_subvol == NULL) {
+        local->op_errno = EINVAL;
+        goto out;
+    }
 
-        subvol = local->cached_subvol;
+    subvol = local->cached_subvol;
 
 out:
-        local->rebalance.target_op_fn (THIS, subvol, frame, op_ret);
+    local->rebalance.target_op_fn(THIS, subvol, frame, op_ret);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_migration_complete_check_task (void *data)
+dht_migration_complete_check_task(void *data)
 {
-        int                 ret         = -1;
-        xlator_t           *src_node    = NULL;
-        xlator_t           *dst_node    = NULL, *linkto_target = NULL;
-        dht_local_t        *local       = NULL;
-        dict_t             *dict        = NULL;
-        struct iatt         stbuf       = {0,};
-        xlator_t           *this        = NULL;
-        call_frame_t       *frame       = NULL;
-        loc_t               tmp_loc     = {0,};
-        char               *path        = NULL;
-        dht_conf_t         *conf        = NULL;
-        inode_t            *inode       = NULL;
-        fd_t               *iter_fd     = NULL;
-        fd_t               *tmp         = NULL;
-        uint64_t            tmp_miginfo = 0;
-        dht_migrate_info_t *miginfo     = NULL;
-        int                 open_failed = 0;
-
-        this  = THIS;
-        frame = data;
-        local = frame->local;
-        conf = this->private;
-
-        src_node = local->cached_subvol;
-
-        if (!local->loc.inode && !local->fd) {
-                local->op_errno = EINVAL;
-                goto out;
-        }
-
-        inode = (!local->fd) ? local->loc.inode : local->fd->inode;
-
-        /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
-         * as root:root. If a fd is already open, access check wont be done*/
-
-        if (!local->loc.inode) {
-                ret = syncop_fgetxattr (src_node, local->fd, &dict,
-                                        conf->link_xattr_name, NULL, NULL);
-        } else {
-                SYNCTASK_SETID (0, 0);
-                ret = syncop_getxattr (src_node, &local->loc, &dict,
-                                       conf->link_xattr_name, NULL, NULL);
-                SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-        }
-
-
-        /*
-         * Each DHT xlator layer has its own name for the linkto xattr.
-         * If the file mode bits indicate the the file is being migrated but
-         * this layer's linkto xattr is not set, it means that another
-         * DHT layer is migrating the file. In this case, return 1 so
-         * the mode bits can be passed on to the higher layer for appropriate
-         * action.
-         */
-        if (-ret == ENODATA) {
-                /* This DHT translator is not migrating this file */
-
-                ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-                if (tmp_miginfo) {
-
-                        /* This can be a problem if the file was
-                         * migrated by two different layers. Raise
-                         * a warning here.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_HAS_MIGINFO,
-                                "%s: Found miginfo in the inode ctx",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid));
-
-                        miginfo = (void *)tmp_miginfo;
-                        GF_REF_PUT (miginfo);
-                }
-                ret = 1;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *src_node = NULL;
+    xlator_t *dst_node = NULL, *linkto_target = NULL;
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    xlator_t *this = NULL;
+    call_frame_t *frame = NULL;
+    loc_t tmp_loc = {
+        0,
+    };
+    char *path = NULL;
+    dht_conf_t *conf = NULL;
+    inode_t *inode = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *tmp = NULL;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
+    gf_boolean_t skip_open = _gf_false;
+    int open_failed = 0;
+
+    this = THIS;
+    frame = data;
+    local = frame->local;
+    conf = this->private;
+
+    src_node = local->cached_subvol;
+
+    if (!local->loc.inode && !local->fd) {
+        local->op_errno = EINVAL;
+        goto out;
+    }
 
-        if (!ret)
-                linkto_target = dht_linkfile_subvol (this, NULL, NULL, dict);
+    inode = (!local->fd) ? local->loc.inode : local->fd->inode;
 
-        if (local->loc.inode) {
-                loc_copy (&tmp_loc, &local->loc);
-        } else {
-                tmp_loc.inode = inode_ref (inode);
-                gf_uuid_copy (tmp_loc.gfid, inode->gfid);
-        }
+    /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
+     * as root:root. If a fd is already open, access check won't be done*/
 
-        ret = syncop_lookup (this, &tmp_loc, &stbuf, 0, 0, 0);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_FILE_LOOKUP_FAILED,
-                        "%s: failed to lookup the file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        this->name);
-                local->op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+    if (!local->loc.inode) {
+        ret = syncop_fgetxattr(src_node, local->fd, &dict,
+                               conf->link_xattr_name, NULL, NULL);
+    } else {
+        SYNCTASK_SETID(0, 0);
+        ret = syncop_getxattr(src_node, &local->loc, &dict,
+                              conf->link_xattr_name, NULL, NULL);
+        SYNCTASK_SETID(frame->root->uid, frame->root->gid);
+    }
+
+    /*
+     * Each DHT xlator layer has its own name for the linkto xattr.
+     * If the file mode bits indicate the the file is being migrated but
+     * this layer's linkto xattr is not set, it means that another
+     * DHT layer is migrating the file. In this case, return 1 so
+     * the mode bits can be passed on to the higher layer for appropriate
+     * action.
+     */
+    if (-ret == ENODATA) {
+        /* This DHT translator is not migrating this file */
+
+        ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+        if (tmp_miginfo) {
+            /* This can be a problem if the file was
+             * migrated by two different layers. Raise
+             * a warning here.
+             */
+            gf_smsg(
+                this->name, GF_LOG_WARNING, 0, DHT_MSG_HAS_MIGINFO, "tmp=%s",
+                tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid), NULL);
+
+            miginfo = (void *)(uintptr_t)tmp_miginfo;
+            GF_REF_PUT(miginfo);
+        }
+        ret = 1;
+        goto out;
+    }
+
+    if (!ret)
+        linkto_target = dht_linkfile_subvol(this, NULL, NULL, dict);
+
+    if (local->loc.inode) {
+        loc_copy(&tmp_loc, &local->loc);
+    } else {
+        tmp_loc.inode = inode_ref(inode);
+        gf_uuid_copy(tmp_loc.gfid, inode->gfid);
+    }
+
+    ret = syncop_lookup(this, &tmp_loc, &stbuf, 0, 0, 0);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_FILE_LOOKUP_FAILED,
+                "tmp=%s", tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+                "name=%s", this->name, NULL);
+        local->op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    dst_node = dht_subvol_get_cached(this, tmp_loc.inode);
+    if (linkto_target && dst_node != linkto_target) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_LINKFILE,
+                "linkto_target_name=%s", linkto_target->name, "dst_name=%s",
+                dst_node->name, NULL);
+    }
+
+    if (gf_uuid_compare(stbuf.ia_gfid, tmp_loc.inode->gfid)) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH, "tmp=%s",
+                tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+                "dst_name=%s", dst_node->name, NULL);
+        ret = -1;
+        local->op_errno = EIO;
+        goto out;
+    }
 
-        dst_node = dht_subvol_get_cached (this, tmp_loc.inode);
-        if (linkto_target && dst_node != linkto_target) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_INVALID_LINKFILE,
-                        "linkto target (%s) is "
-                        "different from cached-subvol (%s). Treating %s as "
-                        "destination subvol", linkto_target->name,
-                        dst_node->name, dst_node->name);
-        }
+    /* update local. A layout is set in inode-ctx in lookup already */
 
-        if (gf_uuid_compare (stbuf.ia_gfid, tmp_loc.inode->gfid)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "%s: gfid different on the target file on %s",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid), dst_node->name);
-                ret = -1;
-                local->op_errno = EIO;
-                goto out;
-        }
+    dht_layout_unref(this, local->layout);
 
-        /* update local. A layout is set in inode-ctx in lookup already */
+    local->layout = dht_layout_get(frame->this, inode);
+    local->cached_subvol = dst_node;
 
-        dht_layout_unref (this, local->layout);
+    ret = 0;
 
-        local->layout   = dht_layout_get (frame->this, inode);
-        local->cached_subvol = dst_node;
+    /* once we detect the migration complete, the inode-ctx2 is no more
+       required.. delete the ctx and also, it means, open() already
+       done on all the fd of inode */
+    ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+    if (tmp_miginfo) {
+        miginfo = (void *)(uintptr_t)tmp_miginfo;
+        GF_REF_PUT(miginfo);
+        goto out;
+    }
+
+    /* perform 'open()' on all the fd's present on the inode */
+    if (tmp_loc.path == NULL) {
+        inode_path(inode, NULL, &path);
+        if (path)
+            tmp_loc.path = path;
+    }
+
+    LOCK(&inode->lock);
+
+    if (list_empty(&inode->fd_list))
+        goto unlock;
+
+    /* perform open as root:root. There is window between linkfile
+     * creation(root:root) and setattr with the correct uid/gid
+     */
+    SYNCTASK_SETID(0, 0);
+
+    /* It's possible that we are the last user of iter_fd after each
+     * iteration. In this case the fd_unref() of iter_fd at the end of
+     * the loop will cause the destruction of the fd. So we need to
+     * iterate the list safely because iter_fd cannot be trusted.
+     */
+    iter_fd = list_entry((&inode->fd_list)->next, typeof(*iter_fd), inode_list);
+    while (&iter_fd->inode_list != (&inode->fd_list)) {
+        if (fd_is_anonymous(iter_fd) ||
+            (dht_fd_open_on_dst(this, iter_fd, dst_node))) {
+            if (!tmp) {
+                iter_fd = list_entry(iter_fd->inode_list.next, typeof(*iter_fd),
+                                     inode_list);
+                continue;
+            }
+            skip_open = _gf_true;
+        }
+        /* We need to release the inode->lock before calling
+         * syncop_open() to avoid possible deadlocks. However this
+         * can cause the iter_fd to be released by other threads.
+         * To avoid this, we take a reference before releasing the
+         * lock.
+         */
+        fd_ref(iter_fd);
 
-        ret = 0;
+        UNLOCK(&inode->lock);
 
-        /* once we detect the migration complete, the inode-ctx2 is no more
-           required.. delete the ctx and also, it means, open() already
-           done on all the fd of inode */
-        ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-        if (tmp_miginfo) {
-                miginfo = (void *)tmp_miginfo;
-                GF_REF_PUT (miginfo);
-                goto out;
+        if (tmp) {
+            fd_unref(tmp);
+            tmp = NULL;
         }
+        if (skip_open)
+            goto next;
 
-        /* perform 'open()' on all the fd's present on the inode */
-        if (tmp_loc.path == NULL) {
-                inode_path (inode, NULL, &path);
-                if (path)
-                        tmp_loc.path = path;
+        /* flags for open are stripped down to allow following the
+         * new location of the file, otherwise we can get EEXIST or
+         * truncate the file again as rebalance is moving the data */
+        ret = syncop_open(dst_node, &tmp_loc,
+                          (iter_fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                          iter_fd, NULL, NULL);
+        if (ret < 0) {
+            gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                    DHT_MSG_OPEN_FD_ON_DST_FAILED, "id=%p", iter_fd,
+                    "flags=0%o", iter_fd->flags, "path=%s", path, "name=%s",
+                    dst_node->name, NULL);
+
+            open_failed = 1;
+            local->op_errno = -ret;
+            ret = -1;
+        } else {
+            dht_fd_ctx_set(this, iter_fd, dst_node);
         }
 
+    next:
         LOCK(&inode->lock);
+        skip_open = _gf_false;
+        tmp = iter_fd;
+        iter_fd = list_entry(tmp->inode_list.next, typeof(*tmp), inode_list);
+    }
 
-        if (list_empty (&inode->fd_list))
-                goto unlock;
-
-        /* perform open as root:root. There is window between linkfile
-         * creation(root:root) and setattr with the correct uid/gid
-         */
-        SYNCTASK_SETID(0, 0);
-
-        /* It's possible that we are the last user of iter_fd after each
-         * iteration. In this case the fd_unref() of iter_fd at the end of
-         * the loop will cause the destruction of the fd. So we need to
-         * iterate the list safely because iter_fd cannot be trusted.
-         */
-        list_for_each_entry_safe (iter_fd, tmp, &inode->fd_list, inode_list) {
-
-                if (fd_is_anonymous (iter_fd))
-                        continue;
-
-                if (dht_fd_open_on_dst (this, iter_fd, dst_node))
-                        continue;
-
-                /* We need to release the inode->lock before calling
-                 * syncop_open() to avoid possible deadlocks. However this
-                 * can cause the iter_fd to be released by other threads.
-                 * To avoid this, we take a reference before releasing the
-                 * lock.
-                 */
-                __fd_ref(iter_fd);
-
-                UNLOCK(&inode->lock);
-
-                /* flags for open are stripped down to allow following the
-                 * new location of the file, otherwise we can get EEXIST or
-                 * truncate the file again as rebalance is moving the data */
-                ret = syncop_open (dst_node, &tmp_loc,
-                                   (iter_fd->flags &
-                                   ~(O_CREAT | O_EXCL | O_TRUNC)),
-                                   iter_fd, NULL, NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_OPEN_FD_ON_DST_FAILED, "failed"
-                                " to open the fd"
-                                " (%p, flags=0%o) on file %s @ %s",
-                                iter_fd, iter_fd->flags, path,
-                                dst_node->name);
-
-                        open_failed = 1;
-                        local->op_errno = -ret;
-                        ret = -1;
-                } else {
-                        dht_fd_ctx_set (this, iter_fd, dst_node);
-                }
-
-                fd_unref(iter_fd);
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 
-                LOCK(&inode->lock);
-        }
-
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-
-        if (open_failed) {
-                ret = -1;
-                goto unlock;
-        }
-        ret = 0;
+    if (open_failed) {
+        ret = -1;
+        goto unlock;
+    }
+    ret = 0;
 
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
+    if (tmp) {
+        fd_unref(tmp);
+        tmp = NULL;
+    }
 
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        loc_wipe (&tmp_loc);
+    loc_wipe(&tmp_loc);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_rebalance_complete_check (xlator_t *this, call_frame_t *frame)
+dht_rebalance_complete_check(xlator_t *this, call_frame_t *frame)
 {
-        int         ret     = -1;
-
-        ret = synctask_new (this->ctx->env, dht_migration_complete_check_task,
-                            dht_migration_complete_check_done,
-                            frame, frame);
-        return ret;
+    int ret = -1;
 
+    ret = synctask_new(this->ctx->env, dht_migration_complete_check_task,
+                       dht_migration_complete_check_done, frame, frame);
+    return ret;
 }
 
 /* During 'in-progress' state, both nodes should have the file */
@@ -1530,724 +1516,789 @@ dht_rebalance_complete_check (xlator_t *this, call_frame_t *frame)
   1 : File is being migrated but not by this DHT layer.
 */
 static int
-dht_inprogress_check_done (int op_ret, call_frame_t *frame, void *data)
+dht_inprogress_check_done(int op_ret, call_frame_t *frame, void *data)
 {
-        dht_local_t *local      = NULL;
-        xlator_t    *dst_subvol = NULL, *src_subvol = NULL;
-        inode_t     *inode      = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *dst_subvol = NULL, *src_subvol = NULL;
+    inode_t *inode = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret != 0)
-                goto out;
+    if (op_ret != 0)
+        goto out;
 
-        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    inode = local->loc.inode ? local->loc.inode : local->fd->inode;
 
-        dht_inode_ctx_get_mig_info (THIS, inode, &src_subvol, &dst_subvol);
-        if (dht_mig_info_is_invalid (local->cached_subvol,
-                                     src_subvol, dst_subvol)) {
-                dst_subvol = dht_subvol_get_cached (THIS, inode);
-                if (!dst_subvol) {
-                        local->op_errno = EINVAL;
-                        goto out;
-                }
+    dht_inode_ctx_get_mig_info(THIS, inode, &src_subvol, &dst_subvol);
+    if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol, dst_subvol)) {
+        dst_subvol = dht_subvol_get_cached(THIS, inode);
+        if (!dst_subvol) {
+            local->op_errno = EINVAL;
+            goto out;
         }
+    }
 
 out:
-        local->rebalance.target_op_fn (THIS, dst_subvol, frame, op_ret);
+    local->rebalance.target_op_fn(THIS, dst_subvol, frame, op_ret);
 
-        return 0;
+    return 0;
 }
 
 static int
-dht_rebalance_inprogress_task (void *data)
+dht_rebalance_inprogress_task(void *data)
 {
-        int           ret             = -1;
-        xlator_t     *src_node        = NULL;
-        xlator_t     *dst_node        = NULL;
-        dht_local_t  *local           = NULL;
-        dict_t       *dict            = NULL;
-        call_frame_t *frame           = NULL;
-        xlator_t     *this            = NULL;
-        char         *path            = NULL;
-        struct iatt   stbuf           = {0,};
-        loc_t         tmp_loc         = {0,};
-        dht_conf_t   *conf            = NULL;
-        inode_t      *inode           = NULL;
-        fd_t         *iter_fd         = NULL;
-        fd_t         *tmp             = NULL;
-        int           open_failed     = 0;
-        uint64_t      tmp_miginfo     = 0;
-        dht_migrate_info_t *miginfo   = NULL;
-
-
-        this  = THIS;
-        frame = data;
-        local = frame->local;
-        conf = this->private;
-
-        src_node = local->cached_subvol;
-
-        if (!local->loc.inode && !local->fd)
-                goto out;
+    int ret = -1;
+    xlator_t *src_node = NULL;
+    xlator_t *dst_node = NULL;
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    char *path = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    loc_t tmp_loc = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+    inode_t *inode = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *tmp = NULL;
+    int open_failed = 0;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
+    gf_boolean_t skip_open = _gf_false;
+
+    this = THIS;
+    frame = data;
+    local = frame->local;
+    conf = this->private;
+
+    src_node = local->cached_subvol;
+
+    if (!local->loc.inode && !local->fd)
+        goto out;
 
-        inode = (!local->fd) ? local->loc.inode : local->fd->inode;
+    inode = (!local->fd) ? local->loc.inode : local->fd->inode;
 
-        /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
-         * as root:root. If a fd is already open, access check wont be done*/
-        if (local->loc.inode) {
-                SYNCTASK_SETID (0, 0);
-                ret = syncop_getxattr (src_node, &local->loc, &dict,
-                                       conf->link_xattr_name, NULL, NULL);
-                SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-        } else {
-                ret = syncop_fgetxattr (src_node, local->fd, &dict,
-                                        conf->link_xattr_name, NULL, NULL);
-        }
+    /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
+     * as root:root. If a fd is already open, access check won't be done*/
+    if (local->loc.inode) {
+        SYNCTASK_SETID(0, 0);
+        ret = syncop_getxattr(src_node, &local->loc, &dict,
+                              conf->link_xattr_name, NULL, NULL);
+        SYNCTASK_SETID(frame->root->uid, frame->root->gid);
+    } else {
+        ret = syncop_fgetxattr(src_node, local->fd, &dict,
+                               conf->link_xattr_name, NULL, NULL);
+    }
+
+    /*
+     * Each DHT xlator layer has its own name for the linkto xattr.
+     * If the file mode bits indicate the the file is being migrated but
+     * this layer's linkto xattr is not present, it means that another
+     * DHT layer is migrating the file. In this case, return 1 so
+     * the mode bits can be passed on to the higher layer for appropriate
+     * action.
+     */
+
+    if (-ret == ENODATA) {
+        /* This DHT layer is not migrating this file */
+        ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+        if (tmp_miginfo) {
+            /* This can be a problem if the file was
+             * migrated by two different layers. Raise
+             * a warning here.
+             */
+            gf_smsg(
+                this->name, GF_LOG_WARNING, 0, DHT_MSG_HAS_MIGINFO, "tmp=%s",
+                tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid), NULL);
+            miginfo = (void *)(uintptr_t)tmp_miginfo;
+            GF_REF_PUT(miginfo);
+        }
+        ret = 1;
+        goto out;
+    }
 
-        /*
-         * Each DHT xlator layer has its own name for the linkto xattr.
-         * If the file mode bits indicate the the file is being migrated but
-         * this layer's linkto xattr is not present, it means that another
-         * DHT layer is migrating the file. In this case, return 1 so
-         * the mode bits can be passed on to the higher layer for appropriate
-         * action.
-         */
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_GET_XATTR_FAILED,
+                "path=%s", local->loc.path, NULL);
+        ret = -1;
+        goto out;
+    }
 
-        if (-ret == ENODATA) {
-                /* This DHT layer is not migrating this file */
-                ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-                if (tmp_miginfo) {
-                        /* This can be a problem if the file was
-                         * migrated by two different layers. Raise
-                         * a warning here.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_HAS_MIGINFO,
-                                "%s: Found miginfo in the inode ctx",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid));
-                        miginfo = (void *)tmp_miginfo;
-                        GF_REF_PUT (miginfo);
-                }
-                ret = 1;
-                goto out;
-        }
+    dst_node = dht_linkfile_subvol(this, NULL, NULL, dict);
+    if (!dst_node) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GET_XATTR_FAILED,
+                "path=%s", local->loc.path, NULL);
+        ret = -1;
+        goto out;
+    }
+
+    local->rebalance.target_node = dst_node;
+
+    if (local->loc.inode) {
+        loc_copy(&tmp_loc, &local->loc);
+    } else {
+        tmp_loc.inode = inode_ref(inode);
+        gf_uuid_copy(tmp_loc.gfid, inode->gfid);
+    }
+
+    /* lookup on dst */
+    ret = syncop_lookup(dst_node, &tmp_loc, &stbuf, NULL, NULL, NULL);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_FILE_LOOKUP_FAILED,
+                "tmp=%s", tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+                "name=%s", dst_node->name, NULL);
+        ret = -1;
+        goto out;
+    }
 
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "%s: failed to get the 'linkto' xattr",
-                        local->loc.path);
-                ret = -1;
-                goto out;
-        }
+    if (gf_uuid_compare(stbuf.ia_gfid, tmp_loc.inode->gfid)) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH, "tmp=%s",
+                tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+                "name=%s", dst_node->name, NULL);
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
+
+    if (tmp_loc.path == NULL) {
+        inode_path(inode, NULL, &path);
+        if (path)
+            tmp_loc.path = path;
+    }
+
+    LOCK(&inode->lock);
+
+    if (list_empty(&inode->fd_list))
+        goto unlock;
+
+    /* perform open as root:root. There is window between linkfile
+     * creation(root:root) and setattr with the correct uid/gid
+     */
+    SYNCTASK_SETID(0, 0);
+
+    /* It's possible that we are the last user of iter_fd after each
+     * iteration. In this case the fd_unref() of iter_fd at the end of
+     * the loop will cause the destruction of the fd. So we need to
+     * iterate the list safely because iter_fd cannot be trusted.
+     */
+    iter_fd = list_entry((&inode->fd_list)->next, typeof(*iter_fd), inode_list);
+    while (&iter_fd->inode_list != (&inode->fd_list)) {
+        /* We need to release the inode->lock before calling
+         * syncop_open() to avoid possible deadlocks. However this
+         * can cause the iter_fd to be released by other threads.
+         * To avoid this, we take a reference before releasing the
+         * lock.
+         */
 
-        dst_node = dht_linkfile_subvol (this, NULL, NULL, dict);
-        if (!dst_node) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SUBVOL_NOT_FOUND,
-                        "%s: failed to get the 'linkto' xattr from dict",
-                        local->loc.path);
-                ret = -1;
-                goto out;
+        if (fd_is_anonymous(iter_fd) ||
+            (dht_fd_open_on_dst(this, iter_fd, dst_node))) {
+            if (!tmp) {
+                iter_fd = list_entry(iter_fd->inode_list.next, typeof(*iter_fd),
+                                     inode_list);
+                continue;
+            }
+            skip_open = _gf_true;
         }
 
-        local->rebalance.target_node = dst_node;
-
-        if (local->loc.inode) {
-                loc_copy (&tmp_loc, &local->loc);
-        } else {
-                tmp_loc.inode = inode_ref (inode);
-                gf_uuid_copy (tmp_loc.gfid, inode->gfid);
-        }
+        /* Yes, this is ugly but there isn't a cleaner way to do this
+         * the fd_ref is an atomic increment so not too bad. We want to
+         * reduce the number of inode locks and unlocks.
+         */
 
-        /* lookup on dst */
-        ret = syncop_lookup (dst_node, &tmp_loc, &stbuf, NULL,
-                             NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_FILE_LOOKUP_ON_DST_FAILED,
-                        "%s: failed to lookup the file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        dst_node->name);
-                ret = -1;
-                goto out;
-        }
+        fd_ref(iter_fd);
+        UNLOCK(&inode->lock);
 
-        if (gf_uuid_compare (stbuf.ia_gfid, tmp_loc.inode->gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on the target file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        dst_node->name);
-                ret = -1;
-                goto out;
+        if (tmp) {
+            fd_unref(tmp);
+            tmp = NULL;
         }
-        ret = 0;
+        if (skip_open)
+            goto next;
 
-        if (tmp_loc.path == NULL) {
-                inode_path (inode, NULL, &path);
-                if (path)
-                        tmp_loc.path = path;
+        /* flags for open are stripped down to allow following the
+         * new location of the file, otherwise we can get EEXIST or
+         * truncate the file again as rebalance is moving the data */
+        ret = syncop_open(dst_node, &tmp_loc,
+                          (iter_fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                          iter_fd, NULL, NULL);
+        if (ret < 0) {
+            gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                    DHT_MSG_OPEN_FD_ON_DST_FAILED, "fd=%p", iter_fd,
+                    "flags=0%o", iter_fd->flags, "path=%s", path, "name=%s",
+                    dst_node->name, NULL);
+            ret = -1;
+            open_failed = 1;
+        } else {
+            /* Potential fd leak if this fails here as it will be
+               reopened at the next Phase1/2 check */
+            dht_fd_ctx_set(this, iter_fd, dst_node);
         }
 
+    next:
         LOCK(&inode->lock);
+        skip_open = _gf_false;
+        tmp = iter_fd;
+        iter_fd = list_entry(tmp->inode_list.next, typeof(*tmp), inode_list);
+    }
 
-        if (list_empty (&inode->fd_list))
-                goto unlock;
-
-        /* perform open as root:root. There is window between linkfile
-         * creation(root:root) and setattr with the correct uid/gid
-         */
-        SYNCTASK_SETID (0, 0);
-
-        /* It's possible that we are the last user of iter_fd after each
-         * iteration. In this case the fd_unref() of iter_fd at the end of
-         * the loop will cause the destruction of the fd. So we need to
-         * iterate the list safely because iter_fd cannot be trusted.
-         */
-        list_for_each_entry_safe (iter_fd, tmp, &inode->fd_list, inode_list) {
-                if (fd_is_anonymous (iter_fd))
-                        continue;
-
-                if (dht_fd_open_on_dst (this, iter_fd, dst_node))
-                        continue;
-
-                /* We need to release the inode->lock before calling
-                 * syncop_open() to avoid possible deadlocks. However this
-                 * can cause the iter_fd to be released by other threads.
-                 * To avoid this, we take a reference before releasing the
-                 * lock.
-                 */
-                __fd_ref(iter_fd);
-
-                UNLOCK(&inode->lock);
-
-                /* flags for open are stripped down to allow following the
-                 * new location of the file, otherwise we can get EEXIST or
-                 * truncate the file again as rebalance is moving the data */
-                ret = syncop_open (dst_node, &tmp_loc,
-                                  (iter_fd->flags &
-                                   ~(O_CREAT | O_EXCL | O_TRUNC)),
-                                   iter_fd, NULL, NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_OPEN_FD_ON_DST_FAILED,
-                                "failed to send open "
-                                "the fd (%p, flags=0%o) on file %s @ %s",
-                                iter_fd, iter_fd->flags, path,
-                                dst_node->name);
-                        ret = -1;
-                        open_failed = 1;
-                } else {
-                        /* Potential fd leak if this fails here as it will be
-                           reopened at the next Phase1/2 check */
-                        dht_fd_ctx_set (this, iter_fd, dst_node);
-                }
-
-                fd_unref(iter_fd);
-
-                LOCK(&inode->lock);
-        }
-
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 
 unlock:
-        UNLOCK(&inode->lock);
-
-        if (open_failed) {
-                ret = -1;
-                goto out;
-        }
+    UNLOCK(&inode->lock);
+
+    if (tmp) {
+        fd_unref(tmp);
+        tmp = NULL;
+    }
+    if (open_failed) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dht_inode_ctx_set_mig_info (this, inode, src_node, dst_node);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SET_INODE_CTX_FAILED,
-                        "%s: failed to set inode-ctx target file at %s",
-                        local->loc.path, dst_node->name);
-                goto out;
-        }
+    ret = dht_inode_ctx_set_mig_info(this, inode, src_node, dst_node);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                "path=%s", local->loc.path, "name=%s", dst_node->name, NULL);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        loc_wipe (&tmp_loc);
-        return ret;
+    loc_wipe(&tmp_loc);
+    return ret;
 }
 
 int
-dht_rebalance_in_progress_check (xlator_t *this, call_frame_t *frame)
+dht_rebalance_in_progress_check(xlator_t *this, call_frame_t *frame)
 {
+    int ret = -1;
 
-        int         ret     = -1;
-
-        ret = synctask_new (this->ctx->env, dht_rebalance_inprogress_task,
-                            dht_inprogress_check_done,
-                            frame, frame);
-        return ret;
+    ret = synctask_new(this->ctx->env, dht_rebalance_inprogress_task,
+                       dht_inprogress_check_done, frame, frame);
+    return ret;
 }
 
 int
-dht_inode_ctx_layout_set (inode_t *inode, xlator_t *this,
-                          dht_layout_t *layout_int)
+dht_inode_ctx_layout_set(inode_t *inode, xlator_t *this,
+                         dht_layout_t *layout_int)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
-
-        ret = dht_inode_ctx_get (inode, this, &ctx);
-        if (!ret && ctx) {
-                ctx->layout = layout_int;
-        } else {
-                ctx = GF_CALLOC (1, sizeof (*ctx), gf_dht_mt_inode_ctx_t);
-                if (!ctx)
-                        return ret;
-                ctx->layout = layout_int;
-        }
-
-        ret = dht_inode_ctx_set (inode, this, ctx);
-
-        return ret;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+
+    ret = dht_inode_ctx_get(inode, this, &ctx);
+    if (!ret && ctx) {
+        ctx->layout = layout_int;
+    } else {
+        ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+        if (!ctx)
+            return ret;
+        ctx->layout = layout_int;
+    }
+
+    ret = dht_inode_ctx_set(inode, this, ctx);
+
+    return ret;
 }
 
-
 void
-dht_inode_ctx_time_set (inode_t *inode, xlator_t *this, struct iatt *stat)
+dht_inode_ctx_time_set(inode_t *inode, xlator_t *this, struct iatt *stat)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        dht_stat_time_t         *time           = 0;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    dht_stat_time_t *time = 0;
+    int ret = -1;
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (ret)
-		return;
+    if (ret)
+        return;
 
-        time = &ctx->time;
+    time = &ctx->time;
 
-	time->mtime      = stat->ia_mtime;
-	time->mtime_nsec = stat->ia_mtime_nsec;
+    time->mtime = stat->ia_mtime;
+    time->mtime_nsec = stat->ia_mtime_nsec;
 
-	time->ctime      = stat->ia_ctime;
-	time->ctime_nsec = stat->ia_ctime_nsec;
+    time->ctime = stat->ia_ctime;
+    time->ctime_nsec = stat->ia_ctime_nsec;
 
-	time->atime      = stat->ia_atime;
-	time->atime_nsec = stat->ia_atime_nsec;
+    time->atime = stat->ia_atime;
+    time->atime_nsec = stat->ia_atime_nsec;
 
-	return;
+    return;
 }
 
-
 int
-dht_inode_ctx_time_update (inode_t *inode, xlator_t *this, struct iatt *stat,
-                           int32_t post)
+dht_inode_ctx_time_update(inode_t *inode, xlator_t *this, struct iatt *stat,
+                          int32_t post)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        dht_stat_time_t         *time           = 0;
-        int                      ret            = -1;
-
-        GF_VALIDATE_OR_GOTO (this->name, stat, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-
-        ret = dht_inode_ctx_get (inode, this, &ctx);
-
-        if (ret) {
-                ctx = GF_CALLOC (1, sizeof (*ctx), gf_dht_mt_inode_ctx_t);
-                if (!ctx)
-                        return -1;
-        }
-
-        time = &ctx->time;
-
-        DHT_UPDATE_TIME(time->mtime, time->mtime_nsec,
-                        stat->ia_mtime, stat->ia_mtime_nsec, inode, post);
-        DHT_UPDATE_TIME(time->ctime, time->ctime_nsec,
-                        stat->ia_ctime, stat->ia_ctime_nsec, inode, post);
-        DHT_UPDATE_TIME(time->atime, time->atime_nsec,
-                        stat->ia_atime, stat->ia_atime_nsec, inode, post);
-
-        ret = dht_inode_ctx_set (inode, this, ctx);
+    dht_inode_ctx_t *ctx = NULL;
+    dht_stat_time_t *time = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(this->name, stat, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+
+    ret = dht_inode_ctx_get(inode, this, &ctx);
+
+    if (ret) {
+        ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+        if (!ctx)
+            return -1;
+    }
+
+    time = &ctx->time;
+
+    LOCK(&inode->lock);
+    {
+        DHT_UPDATE_TIME(time->mtime, time->mtime_nsec, stat->ia_mtime,
+                        stat->ia_mtime_nsec, post);
+        DHT_UPDATE_TIME(time->ctime, time->ctime_nsec, stat->ia_ctime,
+                        stat->ia_ctime_nsec, post);
+        DHT_UPDATE_TIME(time->atime, time->atime_nsec, stat->ia_atime,
+                        stat->ia_atime_nsec, post);
+    }
+    UNLOCK(&inode->lock);
+
+    ret = dht_inode_ctx_set(inode, this, ctx);
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_inode_ctx_get (inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx)
+dht_inode_ctx_get(inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx)
 {
-        int             ret     = -1;
-        uint64_t        ctx_int = 0;
+    int ret = -1;
+    uint64_t ctx_int = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        ret = inode_ctx_get (inode, this, &ctx_int);
+    ret = inode_ctx_get(inode, this, &ctx_int);
 
-        if (ret)
-                return ret;
+    if (ret)
+        return ret;
 
-        if (ctx)
-                *ctx = (dht_inode_ctx_t *) ctx_int;
+    if (ctx)
+        *ctx = (dht_inode_ctx_t *)(uintptr_t)ctx_int;
 out:
-        return ret;
+    return ret;
 }
 
-int dht_inode_ctx_set (inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx)
+int
+dht_inode_ctx_set(inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx)
 {
-        int             ret = -1;
-        uint64_t        ctx_int = 0;
+    int ret = -1;
+    uint64_t ctx_int = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-        GF_VALIDATE_OR_GOTO (this->name, ctx, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, ctx, out);
 
-        ctx_int = (long)ctx;
-        ret = inode_ctx_set (inode, this, &ctx_int);
+    ctx_int = (long)ctx;
+    ret = inode_ctx_set(inode, this, &ctx_int);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_subvol_status (dht_conf_t *conf, xlator_t *subvol)
+dht_subvol_status(dht_conf_t *conf, xlator_t *subvol)
 {
-        int i;
+    int i;
 
-        for (i=0 ; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == subvol) {
-                        return conf->subvolume_status[i];
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == subvol) {
+            return conf->subvolume_status[i];
         }
-        return 0;
+    }
+    return 0;
 }
 
-inode_t*
-dht_heal_path (xlator_t *this, char *path, inode_table_t *itable)
+inode_t *
+dht_heal_path(xlator_t *this, char *path, inode_table_t *itable)
 {
-        int             ret             = -1;
-        struct iatt     iatt            = {0, };
-        inode_t        *linked_inode    = NULL;
-        loc_t           loc             = {0, };
-        char           *bname           = NULL;
-        char           *save_ptr        = NULL;
-        uuid_t          gfid            = {0, };
-        char           *tmp_path        = NULL;
-
-
-        tmp_path = gf_strdup (path);
-        if (!tmp_path) {
-                goto out;
-        }
-
-        memset (gfid, 0, 16);
-        gfid[15] = 1;
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *linked_inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    char *bname = NULL;
+    char *save_ptr = NULL;
+    static uuid_t gfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+    char *tmp_path = NULL;
+
+    tmp_path = gf_strdup(path);
+    if (!tmp_path) {
+        goto out;
+    }
 
-        gf_uuid_copy (loc.pargfid, gfid);
-        loc.parent = inode_ref (itable->root);
+    gf_uuid_copy(loc.pargfid, gfid);
+    loc.parent = inode_ref(itable->root);
 
-        bname = strtok_r (tmp_path, "/",  &save_ptr);
+    bname = strtok_r(tmp_path, "/", &save_ptr);
 
-        /* sending a lookup on parent directory,
-         * Eg:  if  path is like /a/b/c/d/e/f/g/
-         * then we will send a lookup on a first and then b,c,d,etc
-         */
+    /* sending a lookup on parent directory,
+     * Eg:  if  path is like /a/b/c/d/e/f/g/
+     * then we will send a lookup on a first and then b,c,d,etc
+     */
 
-        while (bname) {
-                linked_inode = NULL;
-                loc.inode = inode_grep (itable, loc.parent, bname);
-                if (loc.inode == NULL) {
-                        loc.inode = inode_new (itable);
-                        if (loc.inode == NULL) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                } else {
-                        /*
-                         * Inode is already populated in the inode table.
-                         * Which means we already looked up the inde and
-                         * linked with a dentry. So that we will skip
-                         * lookup on this entry, and proceed to next.
-                         */
-                        bname = strtok_r (NULL, "/",  &save_ptr);
-                        inode_unref (loc.parent);
-                        loc.parent = loc.inode;
-                        gf_uuid_copy (loc.pargfid, loc.inode->gfid);
-                        loc.inode = NULL;
-                        continue;
-                }
+    while (bname) {
+        linked_inode = NULL;
+        loc.inode = inode_grep(itable, loc.parent, bname);
+        if (loc.inode == NULL) {
+            loc.inode = inode_new(itable);
+            if (loc.inode == NULL) {
+                ret = -ENOMEM;
+                goto out;
+            }
+        } else {
+            /*
+             * Inode is already populated in the inode table.
+             * Which means we already looked up the inode and
+             * linked with a dentry. So that we will skip
+             * lookup on this entry, and proceed to next.
+             */
+            linked_inode = loc.inode;
+            bname = strtok_r(NULL, "/", &save_ptr);
+            if (!bname) {
+                goto out;
+            }
+            inode_unref(loc.parent);
+            loc.parent = loc.inode;
+            gf_uuid_copy(loc.pargfid, loc.inode->gfid);
+            loc.inode = NULL;
+            continue;
+        }
 
-                loc.name = bname;
-                ret = loc_path (&loc, bname);
+        loc.name = bname;
+        ret = loc_path(&loc, bname);
 
-                ret = syncop_lookup (this, &loc, &iatt, NULL, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_DIR_SELFHEAL_FAILED,
-                                "Healing of path %s failed on subvolume %s for "
-                                "directory %s", path, this->name, bname);
-                        goto out;
-                }
+        ret = syncop_lookup(this, &loc, &iatt, NULL, NULL, NULL);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_SELFHEAL_FAILED,
+                    "path=%s", path, "subvolume=%s", this->name, "bname=%s",
+                    bname, NULL);
+            goto out;
+        }
 
-                linked_inode = inode_link (loc.inode, loc.parent, bname, &iatt);
-                if (!linked_inode)
-                        goto out;
+        linked_inode = inode_link(loc.inode, loc.parent, bname, &iatt);
+        if (!linked_inode)
+            goto out;
 
-                loc_wipe (&loc);
-                gf_uuid_copy (loc.pargfid, linked_inode->gfid);
-                loc.inode = NULL;
-                loc.parent = linked_inode;
+        loc_wipe(&loc);
+        gf_uuid_copy(loc.pargfid, linked_inode->gfid);
+        loc.inode = NULL;
 
-                bname = strtok_r (NULL, "/",  &save_ptr);
-        }
+        bname = strtok_r(NULL, "/", &save_ptr);
+        if (bname)
+            loc.parent = linked_inode;
+    }
 out:
-        inode_ref (linked_inode);
-        loc_wipe (&loc);
-        GF_FREE (tmp_path);
+    inode_ref(linked_inode);
+    loc_wipe(&loc);
+    GF_FREE(tmp_path);
 
-        return linked_inode;
+    return linked_inode;
 }
 
-
 int
-dht_heal_full_path (void *data)
+dht_heal_full_path(void *data)
 {
-        call_frame_t            *heal_frame     = data;
-        dht_local_t             *local          = NULL;
-        loc_t                    loc            = {0, };
-        dict_t                  *dict           = NULL;
-        char                    *path           = NULL;
-        int                      ret            = -1;
-        xlator_t                *source         = NULL;
-        xlator_t                *this           = NULL;
-        inode_table_t           *itable         = NULL;
-        inode_t                 *inode          = NULL;
-        inode_t                 *tmp_inode      = NULL;
-
-        GF_VALIDATE_OR_GOTO ("DHT", heal_frame, out);
-
-        local = heal_frame->local;
-        this = heal_frame->this;
-        source = heal_frame->cookie;
-        heal_frame->cookie = NULL;
-        gf_uuid_copy (loc.gfid, local->gfid);
-
-        if (local->loc.inode)
-                loc.inode = inode_ref (local->loc.inode);
-        else
-                goto out;
-
-        itable = loc.inode->table;
-        ret = syncop_getxattr (source, &loc, &dict,
-                       GET_ANCESTRY_PATH_KEY, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_INFO, -ret,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Failed to get path from subvol %s. Aborting "
-                        "directory healing.", source->name);
-                goto out;
-        }
+    call_frame_t *heal_frame = data;
+    dht_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *path = NULL;
+    int ret = -1;
+    xlator_t *source = NULL;
+    xlator_t *this = NULL;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+    inode_t *tmp_inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("DHT", heal_frame, out);
+
+    local = heal_frame->local;
+    this = heal_frame->this;
+    source = heal_frame->cookie;
+    heal_frame->cookie = NULL;
+    gf_uuid_copy(loc.gfid, local->gfid);
+
+    if (local->loc.inode)
+        loc.inode = inode_ref(local->loc.inode);
+    else
+        goto out;
 
-        ret = dict_get_str (dict, GET_ANCESTRY_PATH_KEY, &path);
-        if (path) {
-                inode = dht_heal_path (this, path, itable);
-                if (inode && inode != local->inode) {
-                        /*
-                         * if inode returned by heal function is different
-                         * from what we passed, which means a racing thread
-                         * already linked a different inode for dentry.
-                         * So we will update our local->inode, so that we can
-                         * retrurn proper inode.
-                         */
-                        tmp_inode = local->inode;
-                        local->inode = inode;
-                        inode_unref (tmp_inode);
-                        tmp_inode = NULL;
-                } else {
-                        inode_unref (inode);
-                }
+    itable = loc.inode->table;
+    ret = syncop_getxattr(source, &loc, &dict, GET_ANCESTRY_PATH_KEY, NULL,
+                          NULL);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_HEAL_ABORT,
+                "subvol=%s", source->name, NULL);
+        goto out;
+    }
+
+    ret = dict_get_str(dict, GET_ANCESTRY_PATH_KEY, &path);
+    if (path) {
+        inode = dht_heal_path(this, path, itable);
+        if (inode && inode != local->inode) {
+            /*
+             * if inode returned by heal function is different
+             * from what we passed, which means a racing thread
+             * already linked a different inode for dentry.
+             * So we will update our local->inode, so that we can
+             * retrurn proper inode.
+             */
+            tmp_inode = local->inode;
+            local->inode = inode;
+            inode_unref(tmp_inode);
+            tmp_inode = NULL;
+        } else {
+            inode_unref(inode);
         }
+    }
 
 out:
-        loc_wipe (&loc);
-        if (dict)
-                dict_unref (dict);
-        return 0;
+    loc_wipe(&loc);
+    if (dict)
+        dict_unref(dict);
+    return 0;
 }
 
 int
-dht_heal_full_path_done (int op_ret, call_frame_t *heal_frame, void *data)
+dht_heal_full_path_done(int op_ret, call_frame_t *heal_frame, void *data)
 {
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+    int op_errno = 0;
+
+    local = heal_frame->local;
+    main_frame = local->main_frame;
+    local->main_frame = NULL;
+    this = heal_frame->this;
+
+    dht_set_fixed_dir_stat(&local->postparent);
+    if (local->need_xattr_heal) {
+        local->need_xattr_heal = 0;
+        ret = dht_dir_xattr_heal(this, local, &op_errno);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                    DHT_MSG_DIR_XATTR_HEAL_FAILED, "path=%s", local->loc.path,
+                    NULL);
+        }
+    }
 
-        call_frame_t            *main_frame       = NULL;
-        dht_local_t             *local            = NULL;
-
-        local = heal_frame->local;
-        main_frame = local->main_frame;
-        local->main_frame = NULL;
-
-        dht_set_fixed_dir_stat (&local->postparent);
-
-        DHT_STACK_UNWIND (lookup, main_frame, 0, 0,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
+    DHT_STACK_UNWIND(lookup, main_frame, 0, 0, local->inode, &local->stbuf,
+                     local->xattr, &local->postparent);
 
-        DHT_STACK_DESTROY (heal_frame);
-        return 0;
+    DHT_STACK_DESTROY(heal_frame);
+    return 0;
 }
 
 /* This function must be called inside an inode lock */
 int
-__dht_lock_subvol_set (inode_t *inode, xlator_t *this,
-                       xlator_t *lock_subvol)
+__dht_lock_subvol_set(inode_t *inode, xlator_t *this, xlator_t *lock_subvol)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
-        uint64_t                 value          = 0;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+    uint64_t value = 0;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        ret = __inode_ctx_get0 (inode, this, &value);
-        if (ret || !value) {
-                return -1;
-        }
+    ret = __inode_ctx_get0(inode, this, &value);
+    if (ret || !value) {
+        return -1;
+    }
 
-        ctx = (dht_inode_ctx_t *) value;
-        ctx->lock_subvol = lock_subvol;
+    ctx = (dht_inode_ctx_t *)(uintptr_t)value;
+    ctx->lock_subvol = lock_subvol;
 out:
-        return ret;
+    return ret;
 }
 
-xlator_t*
-dht_get_lock_subvolume (xlator_t *this, struct gf_flock *lock,
-                        dht_local_t *local)
+xlator_t *
+dht_get_lock_subvolume(xlator_t *this, struct gf_flock *lock,
+                       dht_local_t *local)
 {
-        xlator_t                *subvol                  = NULL;
-        inode_t                 *inode                   = NULL;
-        int32_t                  ret                     = -1;
-        uint64_t                 value                   = 0;
-        xlator_t                *cached_subvol           = NULL;
-        dht_inode_ctx_t         *ctx                     = NULL;
-        char                     gfid[GF_UUID_BUF_SIZE]  = {0};
-
-        GF_VALIDATE_OR_GOTO (this->name, lock, out);
-        GF_VALIDATE_OR_GOTO (this->name, local, out);
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    int32_t ret = -1;
+    uint64_t value = 0;
+    xlator_t *cached_subvol = NULL;
+    dht_inode_ctx_t *ctx = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        cached_subvol = local->cached_subvol;
+    GF_VALIDATE_OR_GOTO(this->name, lock, out);
+    GF_VALIDATE_OR_GOTO(this->name, local, out);
 
-        if (local->loc.inode || local->fd) {
-                inode = local->loc.inode ? local->loc.inode : local->fd->inode;
-        }
+    cached_subvol = local->cached_subvol;
 
-        if (!inode)
-                goto out;
+    if (local->loc.inode || local->fd) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    }
 
-        if (!(IA_ISDIR (inode->ia_type) || IA_ISINVAL (inode->ia_type))) {
-                /*
-                 * We may get non-linked inode for directories as part
-                 * of the selfheal code path. So checking  for IA_INVAL
-                 * type also. This will only happen for directory.
-                 */
-                subvol = local->cached_subvol;
-                goto out;
-        }
+    if (!inode)
+        goto out;
 
-        if (lock->l_type != F_UNLCK) {
-                /*
-                 * inode purging might happen on NFS between a lk
-                 * and unlk. Due to this lk and unlk might be sent
-                 * to different subvols.
-                 * So during a lock request, taking a ref on inode
-                 * to prevent inode purging. inode unref will happen
-                 * in unlock cbk code path.
-                 */
-                inode_ref (inode);
-        }
+    if (!(IA_ISDIR(inode->ia_type) || IA_ISINVAL(inode->ia_type))) {
+        /*
+         * We may get non-linked inode for directories as part
+         * of the selfheal code path. So checking  for IA_INVAL
+         * type also. This will only happen for directory.
+         */
+        subvol = local->cached_subvol;
+        goto out;
+    }
 
-        LOCK (&inode->lock);
-                ret = __inode_ctx_get0 (inode, this, &value);
-                if (!ret && value) {
-                        ctx = (dht_inode_ctx_t *) value;
-                        subvol = ctx->lock_subvol;
-                }
-                if (!subvol && lock->l_type != F_UNLCK && cached_subvol) {
-                        ret = __dht_lock_subvol_set (inode, this,
-                                                     cached_subvol);
-                        if (ret) {
-                                gf_uuid_unparse(inode->gfid, gfid);
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_SET_INODE_CTX_FAILED,
-                                        "Failed to set lock_subvol in "
-                                        "inode ctx for gfid %s",
-                                        gfid);
-                                goto unlock;
-                        }
-                        subvol = cached_subvol;
-                }
-unlock:
-        UNLOCK (&inode->lock);
-        if (!subvol && inode && lock->l_type != F_UNLCK) {
-                inode_unref (inode);
-        }
+    if (lock->l_type != F_UNLCK) {
+        /*
+         * inode purging might happen on NFS between a lk
+         * and unlk. Due to this lk and unlk might be sent
+         * to different subvols.
+         * So during a lock request, taking a ref on inode
+         * to prevent inode purging. inode unref will happen
+         * in unlock cbk code path.
+         */
+        inode_ref(inode);
+    }
+
+    LOCK(&inode->lock);
+    ret = __inode_ctx_get0(inode, this, &value);
+    if (!ret && value) {
+        ctx = (dht_inode_ctx_t *)(uintptr_t)value;
+        subvol = ctx->lock_subvol;
+    }
+    if (!subvol && lock->l_type != F_UNLCK && cached_subvol) {
+        ret = __dht_lock_subvol_set(inode, this, cached_subvol);
+        if (ret) {
+            gf_uuid_unparse(inode->gfid, gfid);
+            UNLOCK(&inode->lock);
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                    "lock_subvol gfid=%s", gfid, NULL);
+            goto post_unlock;
+        }
+        subvol = cached_subvol;
+    }
+    UNLOCK(&inode->lock);
+post_unlock:
+    if (!subvol && inode && lock->l_type != F_UNLCK) {
+        inode_unref(inode);
+    }
 out:
-        return subvol;
+    return subvol;
 }
 
 int
-dht_lk_inode_unref (call_frame_t *frame, int32_t op_ret)
+dht_lk_inode_unref(call_frame_t *frame, int32_t op_ret)
 {
-        int                     ret                     = -1;
-        dht_local_t            *local                   = NULL;
-        inode_t                *inode                   = NULL;
-        xlator_t               *this                    = NULL;
-        char                    gfid[GF_UUID_BUF_SIZE]  = {0};
+    int ret = -1;
+    dht_local_t *local = NULL;
+    inode_t *inode = NULL;
+    xlator_t *this = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        this = frame->this;
+    local = frame->local;
+    this = frame->this;
 
-        if (local->loc.inode || local->fd) {
-                inode = local->loc.inode ? local->loc.inode : local->fd->inode;
-        }
-        if (!inode) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LOCK_INODE_UNREF_FAILED,
-                        "Found a NULL inode. Failed to unref the inode");
-                goto out;
-        }
+    if (local->loc.inode || local->fd) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    }
+    if (!inode) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LOCK_INODE_UNREF_FAILED,
+                NULL);
+        goto out;
+    }
 
-        if (!(IA_ISDIR (inode->ia_type) || IA_ISINVAL (inode->ia_type))) {
-                ret = 0;
-                goto out;
-        }
+    if (!(IA_ISDIR(inode->ia_type) || IA_ISINVAL(inode->ia_type))) {
+        ret = 0;
+        goto out;
+    }
 
-        switch (local->lock_type) {
+    switch (local->lock_type) {
         case F_RDLCK:
         case F_WRLCK:
-                if (op_ret) {
-                        gf_uuid_unparse(inode->gfid, gfid);
-                        gf_msg_debug (this->name, 0,
-                                "lock request failed for gfid %s", gfid);
-                        inode_unref (inode);
-                        goto out;
-                }
-                break;
+            if (op_ret) {
+                gf_uuid_unparse(inode->gfid, gfid);
+                gf_msg_debug(this->name, 0, "lock request failed for gfid %s",
+                             gfid);
+                inode_unref(inode);
+                goto out;
+            }
+            break;
 
         case F_UNLCK:
-                if (!op_ret) {
-                        inode_unref (inode);
-                } else {
-                        gf_uuid_unparse(inode->gfid, gfid);
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LOCK_INODE_UNREF_FAILED,
-                                "Unlock request failed for gfid %s."
-                                "Failed to unref the inode", gfid);
-                        goto out;
-                }
+            if (!op_ret) {
+                inode_unref(inode);
+            } else {
+                gf_uuid_unparse(inode->gfid, gfid);
+                gf_smsg(this->name, GF_LOG_WARNING, 0,
+                        DHT_MSG_LOCK_INODE_UNREF_FAILED, "gfid=%s", gfid, NULL);
+                goto out;
+            }
         default:
-                break;
-        }
-        ret = 0;
+            break;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
+}
+
+/* Code to update custom extended attributes from src dict to dst dict
+ */
+void
+dht_dir_set_heal_xattr(xlator_t *this, dht_local_t *local, dict_t *dst,
+                       dict_t *src, int *uret, int *uflag)
+{
+    int ret = -1;
+    data_t *keyval = NULL;
+    int luret = -1;
+    int luflag = -1;
+    int i = 0;
+    char **xattrs_to_heal;
+
+    if (!src || !dst) {
+        gf_smsg(this->name, GF_LOG_WARNING, EINVAL, DHT_MSG_DST_NULL_SET_FAILED,
+                "path=%s", local->loc.path, NULL);
+        return;
+    }
+    /* Check if any user xattr present in src dict and set
+       it to dst dict
+    */
+    luret = dict_foreach_fnmatch(src, "user.*", dht_set_user_xattr, dst);
+    /* Check if any other custom xattr present in src dict
+       and set it to dst dict, here index start from 1 because
+       user xattr already checked in previous statement
+    */
+
+    xattrs_to_heal = get_xattrs_to_heal();
+
+    for (i = 1; xattrs_to_heal[i]; i++) {
+        keyval = dict_get(src, xattrs_to_heal[i]);
+        if (keyval) {
+            luflag = 1;
+            ret = dict_set(dst, xattrs_to_heal[i], keyval);
+            if (ret)
+                gf_smsg(this->name, GF_LOG_WARNING, ENOMEM,
+                        DHT_MSG_DICT_SET_FAILED, "key=%s", xattrs_to_heal[i],
+                        "path=%s", local->loc.path, NULL);
+            keyval = NULL;
+        }
+    }
+    if (uret)
+        (*uret) = luret;
+    if (uflag)
+        (*uflag) = luflag;
 }
diff --git a/xlators/cluster/dht/src/dht-inode-read.c b/xlators/cluster/dht/src/dht-inode-read.c
index a9e47664a81..dbb8070b0da 100644
--- a/xlators/cluster/dht/src/dht-inode-read.c
+++ b/xlators/cluster/dht/src/dht-inode-read.c
@@ -10,1454 +10,1649 @@
 
 #include "dht-common.h"
 
-int dht_access2 (xlator_t *this, xlator_t *dst_node,
-                 call_frame_t *frame, int ret);
-int dht_readv2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
-int dht_attr2 (xlator_t *this, xlator_t *dst_node,
-               call_frame_t *frame, int ret);
-int dht_open2 (xlator_t *this, xlator_t *dst_node,
-               call_frame_t *frame, int ret);
-int dht_flush2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
-int dht_lk2 (xlator_t *this, xlator_t *dst_node,
-             call_frame_t *frame, int ret);
-int dht_fsync2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
-
-
-
-int
-dht_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+static int
+dht_access2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_readv2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_attr2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_open2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_flush2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_lk2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_fsync2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+static int
+dht_common_xattrop2(xlator_t *this, xlator_t *subvol, call_frame_t *frame,
+                    int ret);
+
+static int
+dht_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = 0;
-
-        local = frame->local;
-        prev = cookie;
-
-        local->op_errno = op_errno;
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        /* Update ctx if the fd has been opened on the target*/
-        if (!op_ret && (local->call_cnt == 1)) {
-                dht_fd_ctx_set (this, fd, prev);
-                goto out;
-        }
-
-        if (!op_ret || (local->call_cnt != 1))
-                goto out;
-
-        /* rebalance would have happened */
-        local->rebalance.target_op_fn = dht_open2;
-        ret = dht_rebalance_complete_check (this, frame);
-        if (!ret)
-                return 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    prev = cookie;
+
+    local->op_errno = op_errno;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    /* Update ctx if the fd has been opened on the target*/
+    if (!op_ret && (local->call_cnt == 1)) {
+        dht_fd_ctx_set(this, fd, prev);
+        goto out;
+    }
+
+    if (!op_ret || (local->call_cnt != 1))
+        goto out;
+
+    /* rebalance would have happened */
+    local->rebalance.target_op_fn = dht_open2;
+    ret = dht_rebalance_complete_check(this, frame);
+    if (!ret)
+        return 0;
 
 out:
-        DHT_STACK_UNWIND (open, frame, op_ret, op_errno, local->fd, xdata);
+    DHT_STACK_UNWIND(open, frame, op_ret, op_errno, local->fd, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_open2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_open2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = ENOENT;
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This DHT layer is not migrating the file */
-                DHT_STACK_UNWIND (open, frame, -1, local->op_errno,
-                                  NULL, local->rebalance.xdata);
-                return 0;
-
-        }
+    if (we_are_not_migrating(ret)) {
+        /* This DHT layer is not migrating the file */
+        DHT_STACK_UNWIND(open, frame, -1, local->op_errno, NULL,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND_COOKIE (frame, dht_open_cbk, subvol, subvol,
-                           subvol->fops->open, &local->loc,
-                           local->rebalance.flags, local->fd, local->xattr_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_open_cbk, subvol, subvol, subvol->fops->open,
+                      &local->loc, local->rebalance.flags, local->fd,
+                      local->xattr_req);
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (open, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_open (call_frame_t *frame, xlator_t *this,
-          loc_t *loc, int flags, fd_t *fd, dict_t *xdata)
+dht_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, fd_t *fd,
+         dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_OPEN);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->rebalance.flags = flags;
-        local->call_cnt = 1;
+    local = dht_local_init(frame, loc, fd, GF_FOP_OPEN);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_open_cbk, subvol, subvol,
-                           subvol->fops->open, loc, flags, fd, xdata);
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        return 0;
+    local->rebalance.flags = flags;
+    local->call_cnt = 1;
+
+    STACK_WIND_COOKIE(frame, dht_open_cbk, subvol, subvol, subvol->fops->open,
+                      loc, flags, fd, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (open, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_file_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *stbuf, dict_t *xdata)
+dht_file_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *stbuf, dict_t *xdata)
 {
-        xlator_t     *subvol1 = 0;
-        xlator_t     *subvol2 = 0;
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        inode_t      *inode = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        if ((local->fop == GF_FOP_FSTAT) && (op_ret == -1)
-             && (op_errno == EBADF) && !(local->fd_checked)) {
-
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        if (local->call_cnt != 1)
-                goto out;
+    xlator_t *subvol1 = 0;
+    xlator_t *subvol2 = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    if ((local->fop == GF_FOP_FSTAT) &&
+        dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-        local->op_ret = op_ret;
-
-        /* Check if the rebalance phase2 is true */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-
-                local->rebalance.target_op_fn = dht_attr2;
-                dht_set_local_rebalance (this, local, NULL, NULL,
-                                         stbuf, xdata);
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
-
-                dht_inode_ctx_get_mig_info (this, inode, &subvol1, &subvol2);
-                if (dht_mig_info_is_invalid (local->cached_subvol,
-                                             subvol1, subvol2)){
-                        /* Phase 2 of migration */
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        /* it is a non-fd op or it is an fd based Fop and
-                           opened on the dst.*/
-                       if (local->fd &&
-                           !dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                ret = dht_rebalance_complete_check (this, frame);
-                                if (!ret)
-                                        return 0;
-                        } else {
-                                dht_attr2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1)
+        goto out;
+
+    local->op_errno = op_errno;
+    local->op_ret = op_ret;
+
+    /* Check if the rebalance phase2 is true */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        local->rebalance.target_op_fn = dht_attr2;
+        dht_set_local_rebalance(this, local, NULL, NULL, stbuf, xdata);
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
+
+        dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            /* Phase 2 of migration */
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            /* it is a non-fd op or it is an fd based Fop and
+               opened on the dst.*/
+            if (local->fd && !dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                ret = dht_rebalance_complete_check(this, frame);
+                if (!ret)
+                    return 0;
+            } else {
+                dht_attr2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        DHT_STACK_UNWIND (stat, frame, op_ret, op_errno, stbuf, xdata);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    DHT_STACK_UNWIND(stat, frame, op_ret, op_errno, stbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
-int
-dht_attr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_attr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
-
-        local = frame->local;
-        if (!local)
-                goto out;
-
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (stat, frame, local->op_ret, op_errno,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    if (!local)
+        goto out;
+
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(stat, frame, local->op_ret, op_errno,
+                         &local->rebalance.postbuf, local->rebalance.xdata);
+        return 0;
+    }
 
+    if (subvol == NULL)
+        goto out;
 
-        if (subvol == NULL)
-                goto out;
+    local->call_cnt = 2;
 
-        local->call_cnt = 2;
+    if (local->fop == GF_FOP_FSTAT) {
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, local->fd, local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, &local->loc, local->xattr_req);
+    }
 
-        if (local->fop == GF_FOP_FSTAT) {
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->fstat, local->fd,
-                                   local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, &local->loc,
-                                   local->xattr_req);
-        }
-
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-int
-dht_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno, struct iatt *stbuf, dict_t *xdata)
+static int
+dht_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, struct iatt *stbuf, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+
+            goto post_unlock;
+        }
 
-                        goto unlock;
-                }
+        dht_iatt_merge(this, &local->stbuf, stbuf);
 
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
+        local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
+                         &local->stbuf, xdata);
+    }
 
-                local->op_ret = 0;
-        }
-unlock:
-        UNLOCK (&frame->lock);
-out:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (stat, frame, local->op_ret, local->op_errno,
-                                  &local->stbuf, xdata);
-        }
-err:
-        return 0;
+    return 0;
 }
 
 int
-dht_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dht_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_STAT);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_STAT);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(loc->inode->ia_type)) {
+        local->call_cnt = 1;
 
-        if (IA_ISREG (loc->inode->ia_type)) {
-                local->call_cnt = 1;
+        subvol = local->cached_subvol;
 
-                subvol = local->cached_subvol;
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, loc, xdata);
 
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, loc, xdata);
+        return 0;
+    }
 
-                return 0;
-        }
+    local->call_cnt = call_cnt = layout->cnt;
 
-        local->call_cnt = call_cnt = layout->cnt;
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = layout->list[i].xlator;
+        STACK_WIND_COOKIE(frame, dht_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, loc, xdata);
+    }
 
-                STACK_WIND_COOKIE (frame, dht_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, loc, xdata);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dht_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSTAT);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (fd->inode->ia_type)) {
-                local->call_cnt = 1;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSTAT);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(fd->inode->ia_type)) {
+        local->call_cnt = 1;
 
-                subvol = local->cached_subvol;
+        subvol = local->cached_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol,
-                                   subvol, subvol->fops->fstat, fd,
-                                   xdata);
-                return 0;
-        }
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, fd, xdata);
+        return 0;
+    }
 
-        local->call_cnt = call_cnt = layout->cnt;
+    local->call_cnt = call_cnt = layout->cnt;
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND_COOKIE (frame, dht_attr_cbk, subvol, subvol,
-                                   subvol->fops->fstat, fd, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND_COOKIE(frame, dht_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, fd, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno,
-               struct iovec *vector, int count, struct iatt *stbuf,
-               struct iobref *iobref, dict_t *xdata)
+dht_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iovec *vector, int count, struct iatt *stbuf,
+              struct iobref *iobref, dict_t *xdata)
 {
-        dht_local_t *local      = NULL;
-        int          ret        = 0;
-        xlator_t    *src_subvol = 0;
-        xlator_t    *dst_subvol = 0;
-
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    int ret = 0;
+    xlator_t *src_subvol = 0;
+    xlator_t *dst_subvol = 0;
+
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /* This is already second try, no need for re-check */
+    if (local->call_cnt != 1)
+        goto out;
+
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        /* This is already second try, no need for re-check */
-        if (local->call_cnt != 1)
-                goto out;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno))
+        goto out;
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
+    local->op_errno = op_errno;
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        local->op_ret = op_ret;
+        local->rebalance.target_op_fn = dht_readv2;
+        dht_set_local_rebalance(this, local, NULL, NULL, stbuf, xdata);
+        /* File would be migrated to other node */
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                         &dst_subvol);
+
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
                 return 0;
+        } else {
+            /* value is already set in fd_ctx, that means no need
+               to check for whether its complete or not. */
+            dht_readv2(this, dst_subvol, frame, 0);
+            return 0;
         }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno))
-                goto out;
-
-
-        local->op_errno = op_errno;
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-
-                local->op_ret = op_ret;
-                local->rebalance.target_op_fn = dht_readv2;
-                dht_set_local_rebalance (this, local, NULL, NULL,
-                                         stbuf, xdata);
-                /* File would be migrated to other node */
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &src_subvol,
-                                                  &dst_subvol);
-
-                if (dht_mig_info_is_invalid (local->cached_subvol,
-                                             src_subvol, dst_subvol)
-                        || !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
-
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        /* value is already set in fd_ctx, that means no need
-                           to check for whether its complete or not. */
-                        dht_readv2 (this, dst_subvol, frame, 0);
-                        return 0;
-                }
-        }
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        DHT_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count, stbuf,
-                          iobref, xdata);
+    DHT_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, stbuf,
+                     iobref, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_readv2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_readv2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local  = NULL;
-        int          op_errno = EINVAL;
-
-        local = frame->local;
-        if (!local)
-                goto out;
-
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (readv, frame, local->op_ret, op_errno,
-                                  NULL, 0, &local->rebalance.postbuf,
-                                  NULL, local->rebalance.xdata);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    if (!local)
+        goto out;
+
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(readv, frame, local->op_ret, op_errno, NULL, 0,
+                         &local->rebalance.postbuf, NULL,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                    local->fd, local->rebalance.size, local->rebalance.offset,
-                    local->rebalance.flags, local->xattr_req);
+    STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv, local->fd,
+               local->rebalance.size, local->rebalance.offset,
+               local->rebalance.flags, local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_readv (call_frame_t *frame, xlator_t *this,
-           fd_t *fd, size_t size, off_t off, uint32_t flags, dict_t *xdata)
+dht_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t off,
+          uint32_t flags, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_READ);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local = dht_local_init(frame, NULL, fd, GF_FOP_READ);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->rebalance.offset = off;
-        local->rebalance.size   = size;
-        local->rebalance.flags  = flags;
-        local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                    local->fd, local->rebalance.size,
-                    local->rebalance.offset,
-                    local->rebalance.flags, local->xattr_req);
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        return 0;
+    local->rebalance.offset = off;
+    local->rebalance.size = size;
+    local->rebalance.flags = flags;
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv, local->fd,
+               local->rebalance.size, local->rebalance.offset,
+               local->rebalance.flags, local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, dict_t *xdata)
+static int
+dht_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        int          ret = -1;
-        dht_local_t *local = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *prev = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        if (!prev)
-                goto out;
-        if (local->call_cnt != 1)
-                goto out;
-        if ((op_ret == -1) && ((op_errno == ENOTCONN) ||
-                dht_inode_missing(op_errno)) &&
-                IA_ISDIR(local->loc.inode->ia_type)) {
-                subvol = dht_subvol_next_available (this, prev);
-                if (!subvol)
-                        goto out;
-
-                /* check if we are done with visiting every node */
-                if (subvol == local->cached_subvol) {
-                        goto out;
-                }
-
-                STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                                   subvol->fops->access, &local->loc,
-                                   local->rebalance.flags, NULL);
-                return 0;
-        }
-        if ((op_ret == -1) && dht_inode_missing(op_errno) &&
-                !(IA_ISDIR(local->loc.inode->ia_type))) {
-                /* File would be migrated to other node */
-                local->op_errno = op_errno;
-                local->rebalance.target_op_fn = dht_access2;
-                ret = dht_rebalance_complete_check (frame->this, frame);
-                if (!ret)
-                        return 0;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (!prev)
+        goto out;
+    if (local->call_cnt != 1)
+        goto out;
+    if ((op_ret == -1) &&
+        ((op_errno == ENOTCONN) || dht_inode_missing(op_errno)) &&
+        IA_ISDIR(local->loc.inode->ia_type)) {
+        subvol = dht_subvol_next_available(this, prev);
+        if (!subvol)
+            goto out;
+
+        /* check if we are done with visiting every node */
+        if (subvol == local->cached_subvol) {
+            goto out;
         }
 
-out:
-        DHT_STACK_UNWIND (access, frame, op_ret, op_errno, xdata);
+        STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                          subvol->fops->access, &local->loc,
+                          local->rebalance.flags, NULL);
         return 0;
+    }
+    if ((op_ret == -1) && dht_inode_missing(op_errno) &&
+        !(IA_ISDIR(local->loc.inode->ia_type))) {
+        /* File would be migrated to other node */
+        local->op_errno = op_errno;
+        local->rebalance.target_op_fn = dht_access2;
+        ret = dht_rebalance_complete_check(frame->this, frame);
+        if (!ret)
+            return 0;
+    }
+
+out:
+    DHT_STACK_UNWIND(access, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-int
-dht_access2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_access2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        local = frame->local;
-        if (!local)
-                goto out;
+    local = frame->local;
+    if (!local)
+        goto out;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
 
-                DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
-                return 0;
-        }
+        DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                           subvol->fops->access, &local->loc,
-                           local->rebalance.flags, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                      subvol->fops->access, &local->loc, local->rebalance.flags,
+                      local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-            dict_t *xdata)
+dht_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+           dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_ACCESS);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.flags = mask;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                           subvol->fops->access, loc, mask, xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_ACCESS);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.flags = mask;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                      subvol->fops->access, loc, mask, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, dict_t *xdata)
+dht_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, dict_t *xdata)
 {
-        dht_local_t     *local  = NULL;
-        xlator_t        *subvol = 0;
-        int             ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = 0;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (local->call_cnt != 1)
-                goto out;
+    if (local->call_cnt != 1)
+        goto out;
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_flush2;
+    local->rebalance.target_op_fn = dht_flush2;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        /* If context is set, then send flush() it to the destination */
-        dht_inode_ctx_get_mig_info (this, local->fd->inode, NULL, &subvol);
-        if (subvol && dht_fd_open_on_dst (this, local->fd, subvol)) {
-                dht_flush2 (this, subvol, frame, 0);
-                return 0;
-        }
+    /* If context is set, then send flush() it to the destination */
+    dht_inode_ctx_get_mig_info(this, local->fd->inode, NULL, &subvol);
+    if (subvol && dht_fd_open_on_dst(this, local->fd, subvol)) {
+        dht_flush2(this, subvol, frame, 0);
+        return 0;
+    }
 
-        if (op_errno == EREMOTE) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret) {
-                        return 0;
-                }
+    if (op_errno == EREMOTE) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret) {
+            return 0;
         }
+    }
 
 out:
-        DHT_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata);
+    DHT_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_flush2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_flush2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND (frame, dht_flush_cbk,
-                    subvol, subvol->fops->flush, local->fd,
-                    local->xattr_req);
+    STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, local->fd,
+               local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dht_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FLUSH);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FLUSH);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_flush_cbk,
-                    subvol, subvol->fops->flush, fd, local->xattr_req);
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, fd,
+               local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
-               dict_t *xdata)
+dht_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+              dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        inode_t      *inode = NULL;
-        xlator_t     *src_subvol = 0;
-        xlator_t     *dst_subvol = 0;
-
-        local = frame->local;
-        prev = cookie;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+    xlator_t *src_subvol = 0;
+    xlator_t *dst_subvol = 0;
 
-        local->op_errno = op_errno;
-
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret == -1 && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
+    local->op_errno = op_errno;
 
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
+
+    if (op_ret == -1 && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
+        goto out;
+    }
 
-        local->op_ret = op_ret;
-        inode = local->fd->inode;
-
-        local->rebalance.target_op_fn = dht_fsync2;
-        dht_set_local_rebalance (this, local, NULL, prebuf,
-                                 postbuf, xdata);
-
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+    local->op_ret = op_ret;
+    inode = local->fd->inode;
 
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
+    local->rebalance.target_op_fn = dht_fsync2;
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                dht_inode_ctx_get_mig_info (this, inode, &src_subvol, &dst_subvol);
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-                if (dht_mig_info_is_invalid (local->cached_subvol, src_subvol,
-                                     dst_subvol) ||
-                      !dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
 
-                        ret = dht_rebalance_in_progress_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        dht_fsync2 (this, dst_subvol, frame, 0);
-                        return 0;
-                }
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_in_progress_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            dht_fsync2(this, dst_subvol, frame, 0);
+            return 0;
         }
-
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (fsync, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_fsync2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_fsync2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
-
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
-
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (fsync, frame, local->op_ret,
-                                  op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
+
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
+
+    local = frame->local;
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(fsync, frame, local->op_ret, op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                           subvol->fops->fsync, local->fd,
-                           local->rebalance.flags, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol, subvol->fops->fsync,
+                      local->fd, local->rebalance.flags, local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
-           dict_t *xdata)
+dht_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
+          dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSYNC);
-        if (!local) {
-                op_errno = ENOMEM;
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSYNC);
+    if (!local) {
+        op_errno = ENOMEM;
 
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        local->call_cnt = 1;
-        local->rebalance.flags = datasync;
+    local->call_cnt = 1;
+    local->rebalance.flags = datasync;
 
-        subvol = local->cached_subvol;
+    subvol = local->cached_subvol;
 
-        STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                           subvol->fops->fsync, local->fd,
-                           local->rebalance.flags, local->xattr_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol, subvol->fops->fsync,
+                      local->fd, local->rebalance.flags, local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* TODO: for 'lk()' call, we need some other special error, may be ESTALE to
    indicate that lock migration happened on the fd, so we can consider it as
    phase 2 of migration */
-int
-dht_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int op_ret, int op_errno, struct gf_flock *flock, dict_t *xdata)
+static int
+dht_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+           int op_errno, struct gf_flock *flock, dict_t *xdata)
 {
-        dht_local_t     *local  = NULL;
-        int             ret     = -1;
-        xlator_t        *subvol = NULL;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        if (local->call_cnt != 1)
-                goto out;
+    if (local->call_cnt != 1)
+        goto out;
 
-        local->rebalance.target_op_fn = dht_lk2;
+    local->rebalance.target_op_fn = dht_lk2;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
-
-        if (op_errno == EREMOTE) {
-                dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                            NULL, &subvol);
-                if (subvol && dht_fd_open_on_dst (this, local->fd, subvol)) {
-                        dht_lk2 (this, subvol, frame, 0);
-                        return 0;
-                } else {
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret) {
-                                return 0;
-                        }
-                }
+    if (op_errno == EREMOTE) {
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, NULL, &subvol);
+        if (subvol && dht_fd_open_on_dst(this, local->fd, subvol)) {
+            dht_lk2(this, subvol, frame, 0);
+            return 0;
+        } else {
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret) {
+                return 0;
+            }
         }
+    }
 
 out:
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (lk, frame, op_ret, op_errno, flock, xdata);
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(lk, frame, op_ret, op_errno, flock, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_lk2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_lk2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND (frame, dht_lk_cbk, subvol, subvol->fops->lk, local->fd,
-                    local->rebalance.lock_cmd, &local->rebalance.flock,
-                    local->xattr_req);
+    STACK_WIND(frame, dht_lk_cbk, subvol, subvol->fops->lk, local->fd,
+               local->rebalance.lock_cmd, &local->rebalance.flock,
+               local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (lk, frame, -1, op_errno, NULL,  NULL);
-        return 0;
+    DHT_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int
-dht_lk (call_frame_t *frame, xlator_t *this,
-        fd_t *fd, int cmd, struct gf_flock *flock, dict_t *xdata)
+dht_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int cmd,
+       struct gf_flock *flock, dict_t *xdata)
 {
-        xlator_t        *lock_subvol    = NULL;
-        int             op_errno        = -1;
-        dht_local_t     *local          = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_LK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *lock_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_LK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->lock_type = flock->l_type;
+    lock_subvol = dht_get_lock_subvolume(this, flock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for path=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /*
+            local->cached_subvol = lock_subvol;
+            ret = dht_check_and_open_fd_on_subvol (this, frame);
+            if (ret)
+                    goto err;
+    */
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->rebalance.flock = *flock;
+    local->rebalance.lock_cmd = cmd;
+
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_lk_cbk, lock_subvol, lock_subvol->fops->lk, fd, cmd,
+               flock, xdata);
+
+    return 0;
 
-        local->lock_type = flock->l_type;
-        lock_subvol = dht_get_lock_subvolume (this, flock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for path=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
 
-/*
-        local->cached_subvol = lock_subvol;
-        ret = dht_check_and_open_fd_on_subvol (this, frame);
-        if (ret)
-                goto err;
-*/
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    return 0;
+}
 
-        local->rebalance.flock = *flock;
-        local->rebalance.lock_cmd = cmd;
+static int
+dht_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct gf_lease *lease, dict_t *xdata)
+{
+    DHT_STACK_UNWIND(lease, frame, op_ret, op_errno, lease, xdata);
 
-        local->call_cnt = 1;
+    return 0;
+}
 
-        STACK_WIND (frame, dht_lk_cbk, lock_subvol, lock_subvol->fops->lk, fd,
-                    cmd, flock, xdata);
+int
+dht_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+          struct gf_lease *lease, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
 
-        return 0;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    subvol = dht_subvol_get_cached(this, loc->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* TODO: for rebalance, we need to preserve the fop arguments */
+    STACK_WIND(frame, dht_lease_cbk, subvol, subvol->fops->lease, loc, lease,
+               xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lk, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lease, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, struct gf_lease *lease, dict_t *xdata)
+/* Symlinks are currently not migrated, so no need for any check here */
+static int
+dht_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, const char *path, struct iatt *stbuf,
+                 dict_t *xdata)
 {
-        DHT_STACK_UNWIND (lease, frame, op_ret, op_errno, lease, xdata);
+    dht_local_t *local = NULL;
 
-        return 0;
+    local = frame->local;
+    if (op_ret == -1)
+        goto err;
+
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+    }
+
+err:
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    DHT_STACK_UNWIND(readlink, frame, op_ret, op_errno, path, stbuf, xdata);
+
+    return 0;
 }
 
 int
-dht_lease (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, struct gf_lease *lease, dict_t *xdata)
+dht_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        subvol = dht_subvol_get_cached (this, loc->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_READLINK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    STACK_WIND(frame, dht_readlink_cbk, subvol, subvol->fops->readlink, loc,
+               size, xdata);
+
+    return 0;
 
-        /* TODO: for rebalance, we need to preserve the fop arguments */
-        STACK_WIND (frame, dht_lease_cbk, subvol, subvol->fops->lease,
-                    loc, lease, xdata);
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
+}
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lease, frame, -1, op_errno, NULL, NULL);
+/* Get both DHT_IATT_IN_XDATA_KEY and DHT_MODE_IN_XDATA_KEY
+ * Use DHT_MODE_IN_XDATA_KEY if available, else fall back to
+ * DHT_IATT_IN_XDATA_KEY
+ * This will return a dummy iatt with only the mode and type set
+ */
+static int
+dht_read_iatt_from_xdata(dict_t *xdata, struct iatt *stbuf)
+{
+    int ret = -1;
+    int32_t mode = 0;
 
-        return 0;
+    ret = dict_get_int32(xdata, DHT_MODE_IN_XDATA_KEY, &mode);
+
+    if (ret) {
+        ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+    } else {
+        stbuf->ia_prot = ia_prot_from_st_mode(mode);
+        stbuf->ia_type = ia_type_from_st_mode(mode);
+    }
+
+    return ret;
 }
 
-/* Symlinks are currently not migrated, so no need for any check here */
 int
-dht_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, const char *path,
-                  struct iatt *stbuf, dict_t *xdata)
+dht_common_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
+    call_frame_t *call_frame = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    int ret = -1;
+    inode_t *inode = NULL;
+
+    local = frame->local;
+    call_frame = cookie;
+    prev = call_frame->this;
+
+    local->op_errno = op_errno;
+
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1.",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1)
+        goto out;
+
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
+
+    ret = dht_read_iatt_from_xdata(xdata, &stbuf);
+
+    if ((!op_ret) && (ret)) {
+        /* This is a potential problem and can cause corruption
+         * with sharding.
+         * Oh well. We tried.
+         */
+        goto out;
+    }
 
-        local = frame->local;
-        if (op_ret == -1)
-                goto err;
+    local->op_ret = op_ret;
+    local->rebalance.target_op_fn = dht_common_xattrop2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
+    if (dict)
+        local->rebalance.dict = dict_ref(dict);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(&stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(&stbuf)) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
+
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_in_progress_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            dht_common_xattrop2(this, dst_subvol, frame, 0);
+            return 0;
         }
+    }
 
-err:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        DHT_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, stbuf, xdata);
+out:
+    if (local->fop == GF_FOP_XATTROP) {
+        DHT_STACK_UNWIND(xattrop, frame, op_ret, op_errno, dict, xdata);
+    } else {
+        DHT_STACK_UNWIND(fxattrop, frame, op_ret, op_errno, dict, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-              dict_t *xdata)
+static int
+dht_common_xattrop2(xlator_t *this, xlator_t *subvol, call_frame_t *frame,
+                    int ret)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_READLINK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
+
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
+
+    local = frame->local;
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        if (local->fop == GF_FOP_XATTROP) {
+            DHT_STACK_UNWIND(xattrop, frame, local->op_ret, op_errno,
+                             local->rebalance.dict, local->rebalance.xdata);
+        } else {
+            DHT_STACK_UNWIND(fxattrop, frame, local->op_ret, op_errno,
+                             local->rebalance.dict, local->rebalance.xdata);
         }
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+        return 0;
+    }
 
-        STACK_WIND (frame, dht_readlink_cbk,
-                    subvol, subvol->fops->readlink,
-                    loc, size, xdata);
+    if (subvol == NULL)
+        goto out;
 
-        return 0;
+    local->call_cnt = 2; /* This is the second attempt */
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readlink, frame, -1, op_errno, NULL, NULL, NULL);
+    if (local->fop == GF_FOP_XATTROP) {
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol, subvol->fops->xattrop,
+                   &local->loc, local->rebalance.flags, local->rebalance.xattr,
+                   local->xattr_req);
+    } else {
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol,
+                   subvol->fops->fxattrop, local->fd, local->rebalance.flags,
+                   local->rebalance.xattr, local->xattr_req);
+    }
 
-        return 0;
-}
+    return 0;
 
-/* Currently no translators on top of 'distribute' will be using
- * below fops, hence not implementing 'migration' related checks
- */
+out:
 
-int
-dht_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+    /* If local is unavailable we could be unwinding the wrong
+     * function here */
+
+    if (local && (local->fop == GF_FOP_XATTROP)) {
+        DHT_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
+    } else {
+        DHT_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
+    }
+    return 0;
+}
+
+static int
+dht_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        DHT_STACK_UNWIND (xattrop, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    DHT_STACK_UNWIND(xattrop, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
+/* Set both DHT_IATT_IN_XDATA_KEY and DHT_MODE_IN_XDATA_KEY
+ * Use DHT_MODE_IN_XDATA_KEY if available. Else fall back to
+ * DHT_IATT_IN_XDATA_KEY
+ */
+static int
+dht_request_iatt_in_xdata(dict_t *xattr_req)
+{
+    int ret = -1;
+
+    ret = dict_set_int8(xattr_req, DHT_MODE_IN_XDATA_KEY, 1);
+    ret = dict_set_int8(xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+
+    /* At least one call succeeded */
+    return ret;
+}
 
 int
-dht_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dht_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_XATTROP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_XATTROP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for gfid=%s",
+                     uuid_utoa(loc->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Todo : Handle dirs as well. At the moment the only xlator above dht
+     * that uses xattrop is sharding and that is only for files */
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        STACK_WIND(frame, dht_xattrop_cbk, subvol, subvol->fops->xattrop, loc,
+                   flags, dict, xdata);
+
+    } else {
+        local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+        local->call_cnt = 1;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for gfid=%s",
-                              uuid_utoa (loc->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
+        local->rebalance.xattr = dict_ref(dict);
+        local->rebalance.flags = flags;
 
-        local->call_cnt = 1;
+        ret = dht_request_iatt_in_xdata(local->xattr_req);
 
-        STACK_WIND (frame, dht_xattrop_cbk,
-                    subvol, subvol->fops->xattrop,
-                    loc, flags, dict, xdata);
+        if (ret) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to set dictionary key %s file=%s",
+                         DHT_IATT_IN_XDATA_KEY, loc->path);
+        }
 
-        return 0;
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol, subvol->fops->xattrop,
+                   loc, local->rebalance.flags, local->rebalance.xattr,
+                   local->xattr_req);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (xattrop, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-int
-dht_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+static int
+dht_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        DHT_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    DHT_STACK_UNWIND(fxattrop, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int
-dht_fxattrop (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dht_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        subvol = dht_subvol_get_cached (this, fd->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    subvol = dht_subvol_get_cached(this, fd->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FXATTROP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* Todo : Handle dirs as well. At the moment the only xlator above dht
+     * that uses xattrop is sharding and that is only for files */
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        STACK_WIND(frame, dht_fxattrop_cbk, subvol, subvol->fops->fxattrop, fd,
+                   flags, dict, xdata);
+
+    } else {
+        local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+        local->call_cnt = 1;
+
+        local->rebalance.xattr = dict_ref(dict);
+        local->rebalance.flags = flags;
+
+        ret = dht_request_iatt_in_xdata(local->xattr_req);
+
+        if (ret) {
+            gf_msg_debug(this->name, 0, "Failed to set dictionary key %s fd=%p",
+                         DHT_IATT_IN_XDATA_KEY, fd);
         }
 
-        STACK_WIND (frame,
-                    dht_fxattrop_cbk,
-                    subvol, subvol->fops->fxattrop,
-                    fd, flags, dict, xdata);
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol,
+                   subvol->fops->fxattrop, fd, local->rebalance.flags,
+                   local->rebalance.xattr, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fxattrop, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
+/* Currently no translators on top of 'distribute' will be using
+ * below fops, hence not implementing 'migration' related checks
+ */
 
-int
-dht_inodelk_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+static int
+dht_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (inodelk, frame, op_ret, op_errno, xdata);
-        return 0;
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(inodelk, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-dht_inodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-             loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+dht_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        xlator_t        *lock_subvol            = NULL;
-        int              op_errno               = -1;
-        dht_local_t     *local                  = NULL;
-
+    xlator_t *lock_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_INODELK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, NULL, GF_FOP_INODELK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->lock_type = lock->l_type;
-        lock_subvol = dht_get_lock_subvolume (this, lock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local->lock_type = lock->l_type;
+    lock_subvol = dht_get_lock_subvolume(this, lock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        local->call_cnt = 1;
+    local->call_cnt = 1;
 
-        STACK_WIND (frame, dht_inodelk_cbk,
-                    lock_subvol, lock_subvol->fops->inodelk,
-                    volume, loc, cmd, lock, xdata);
+    STACK_WIND(frame, dht_inodelk_cbk, lock_subvol, lock_subvol->fops->inodelk,
+               volume, loc, cmd, lock, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (inodelk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(inodelk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata);
-        return 0;
-}
-
-
-int
-dht_finodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-              fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
-{
-        xlator_t     *lock_subvol       = NULL;
-        dht_local_t  *local             = NULL;
-        int           op_errno          = -1;
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
 
+    local = frame->local;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_INODELK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->call_cnt = 1;
-        local->lock_type = lock->l_type;
-
-        lock_subvol = dht_get_lock_subvolume (this, lock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+out:
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(finodelk, frame, op_ret, op_errno, xdata);
 
-/*
-        local->cached_subvol = lock_subvol;
-        ret = dht_check_and_open_fd_on_subvol (this, frame);
-        if (ret)
-                goto err;
-*/
-        STACK_WIND (frame, dht_finodelk_cbk, lock_subvol,
-                    lock_subvol->fops->finodelk,
-                    volume, fd, cmd, lock, xdata);
+    return 0;
+}
 
-        return 0;
+int
+dht_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+{
+    xlator_t *lock_subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_INODELK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->call_cnt = 1;
+    local->lock_type = lock->l_type;
+
+    lock_subvol = dht_get_lock_subvolume(this, lock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /*
+            local->cached_subvol = lock_subvol;
+            ret = dht_check_and_open_fd_on_subvol (this, frame);
+            if (ret)
+                    goto err;
+    */
+    local->rebalance.flock = *lock;
+    local->rebalance.lock_cmd = cmd;
+    local->key = gf_strdup(volume);
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND(frame, dht_finodelk_cbk, lock_subvol,
+               lock_subvol->fops->finodelk, volume, fd, cmd, lock, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (finodelk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(finodelk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-inode-write.c b/xlators/cluster/dht/src/dht-inode-write.c
index 9709acfebb7..2f23ce90fbd 100644
--- a/xlators/cluster/dht/src/dht-inode-write.c
+++ b/xlators/cluster/dht/src/dht-inode-write.c
@@ -8,1320 +8,1397 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "dht-common.h"
 
-int dht_writev2 (xlator_t *this, xlator_t *subvol,
-                 call_frame_t *frame, int ret);
-int dht_truncate2 (xlator_t *this, xlator_t *subvol,
-                   call_frame_t *frame, int ret);
-int dht_setattr2 (xlator_t *this, xlator_t *subvol,
-                  call_frame_t *frame, int ret);
-int dht_fallocate2 (xlator_t *this, xlator_t *subvol,
-                    call_frame_t *frame, int ret);
-int dht_discard2 (xlator_t *this, xlator_t *subvol,
-                  call_frame_t *frame, int ret);
-int dht_zerofill2 (xlator_t *this, xlator_t *subvol,
-                   call_frame_t *frame, int ret);
+static int
+dht_writev2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+static int
+dht_truncate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+static int
+dht_setattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+static int
+dht_fallocate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+static int
+dht_discard2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+static int
+dht_zerofill2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
 
 int
-dht_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+               dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        xlator_t    *prev = NULL;
-        int          ret   = -1;
-        xlator_t    *subvol1 = NULL;
-        xlator_t    *subvol2 = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        /* writev fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could be a valid bad fd error.
-         */
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *subvol1 = NULL;
+    xlator_t *subvol2 = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /* writev fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could be a valid bad fd error.
+     */
+
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
+    if (op_ret == -1 && !dht_inode_missing(op_errno)) {
+        local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, 0, "subvolume %s returned -1 (%s)", prev->name,
+                     strerror(op_errno));
+        goto out;
+    }
+
+    if (local->call_cnt != 1) {
+        /* preserve the modes of source */
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        if (op_ret == -1 && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_writev2;
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    /* We might need to pass the stbuf information to the higher DHT
+     * layer for appropriate handling.
+     */
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        if (!local->xattr_req) {
+            local->xattr_req = dict_new();
+            if (!local->xattr_req) {
+                gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+                       "insufficient memory");
+                local->op_errno = ENOMEM;
                 local->op_ret = -1;
-                gf_msg_debug (this->name, 0,
-                              "subvolume %s returned -1 (%s)",
-                              prev->name, strerror (op_errno));
                 goto out;
+            }
         }
 
-        if (local->call_cnt != 1) {
-                /* preserve the modes of source */
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
+        ret = dict_set_uint32(local->xattr_req, GF_PROTECT_FROM_EXTERNAL_WRITES,
+                              1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_DICT_SET_FAILED, 0,
+                   "Failed to set key %s in dictionary",
+                   GF_PROTECT_FROM_EXTERNAL_WRITES);
+            local->op_errno = ENOMEM;
+            local->op_ret = -1;
+            goto out;
         }
 
-        local->rebalance.target_op_fn = dht_writev2;
-
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-        /* We might need to pass the stbuf information to the higher DHT
-         * layer for appropriate handling.
-         */
-
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
-
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
-
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        if (dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                dht_writev2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &subvol1,
+                                         &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            if (dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                dht_writev2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf,
-                          xdata);
+    DHT_STACK_UNWIND(writev, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_writev2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_writev2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (writev, frame, local->op_ret,
-                                  local->op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(writev, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol,
-                           subvol, subvol->fops->writev,
-                           local->fd, local->rebalance.vector,
-                           local->rebalance.count,
-                           local->rebalance.offset, local->rebalance.flags,
-                           local->rebalance.iobref, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                      subvol->fops->writev, local->fd, local->rebalance.vector,
+                      local->rebalance.count, local->rebalance.offset,
+                      local->rebalance.flags, local->rebalance.iobref,
+                      local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-            struct iovec *vector, int count, off_t off, uint32_t flags,
-            struct iobref *iobref, dict_t *xdata)
+dht_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int count, off_t off, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata)
 {
-        xlator_t     *subvol   = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local    = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_WRITE);
-        if (!local) {
-
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        local->rebalance.vector = iov_dup (vector, count);
-        local->rebalance.offset = off;
-        local->rebalance.count = count;
-        local->rebalance.flags = flags;
-        local->rebalance.iobref = iobref_ref (iobref);
-        local->call_cnt = 1;
-
-        STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol, subvol,
-                           subvol->fops->writev, fd,
-                           local->rebalance.vector,
-                           local->rebalance.count,
-                           local->rebalance.offset,
-                           local->rebalance.flags,
-                           local->rebalance.iobref, local->xattr_req);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_WRITE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->rebalance.vector = iov_dup(vector, count);
+    local->rebalance.offset = off;
+    local->rebalance.count = count;
+    local->rebalance.flags = flags;
+    local->rebalance.iobref = iobref_ref(iobref);
+    local->call_cnt = 1;
+
+    STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                      subvol->fops->writev, fd, local->rebalance.vector,
+                      local->rebalance.count, local->rebalance.offset,
+                      local->rebalance.flags, local->rebalance.iobref,
+                      local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-
 int
-dht_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
+dht_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata)
 {
-        dht_local_t  *local      = NULL;
-        xlator_t     *prev       = NULL;
-        int           ret        = -1;
-        xlator_t     *src_subvol = NULL;
-        xlator_t     *dst_subvol = NULL;
-        inode_t      *inode      = NULL;
-
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* Needs to be checked only for ftruncate.
-         * ftruncate fails with EBADF/EINVAL if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+    inode_t *inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* Needs to be checked only for ftruncate.
+     * ftruncate fails with EBADF/EINVAL if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+
+    if ((local->fop == GF_FOP_FTRUNCATE) &&
+        dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if ((local->fop == GF_FOP_FTRUNCATE) && (op_ret == -1)
-             && ((op_errno == EBADF) || (op_errno == EINVAL))
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
+        goto out;
+    }
 
-                goto out;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
+        goto out;
+    }
 
+    local->rebalance.target_op_fn = dht_truncate2;
 
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
-        }
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        local->rebalance.target_op_fn = dht_truncate2;
+    /* We might need to pass the stbuf information to the higher DHT
+     * layer for appropriate handling.
+     */
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-        /* We might need to pass the stbuf information to the higher DHT
-         * layer for appropriate handling.
-         */
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
-
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
-
-                dht_inode_ctx_get_mig_info (this, inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              src_subvol, dst_subvol)) {
-                        if ((!local->fd) || ((local->fd) &&
-                            dht_fd_open_on_dst (this, local->fd, dst_subvol))) {
-                                dht_truncate2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if ((!local->fd) ||
+                ((local->fd) &&
+                 dht_fd_open_on_dst(this, local->fd, dst_subvol))) {
+                dht_truncate2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (truncate, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(truncate, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
-
-int
-dht_truncate2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_truncate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
-
-        if (!frame || !frame->local)
-                goto out;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        local = frame->local;
-        op_errno = local->op_errno;
+    if (!frame || !frame->local)
+        goto out;
 
-        /* This dht xlator is not migrating the file  */
-        if (we_are_not_migrating (ret)) {
+    local = frame->local;
+    op_errno = local->op_errno;
 
-                DHT_STACK_UNWIND (truncate, frame, local->op_ret,
-                                  local->op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    /* This dht xlator is not migrating the file  */
+    if (we_are_not_migrating(ret)) {
+        DHT_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        if (local->fop == GF_FOP_TRUNCATE) {
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->truncate, &local->loc,
-                                   local->rebalance.offset, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->ftruncate, local->fd,
-                                   local->rebalance.offset, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_TRUNCATE) {
+        STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                          subvol->fops->truncate, &local->loc,
+                          local->rebalance.offset, local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                          subvol->fops->ftruncate, local->fd,
+                          local->rebalance.offset, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-              dict_t *xdata)
+dht_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_TRUNCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.offset = offset;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for gfid=%s",
-                              uuid_utoa (loc->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                           subvol->fops->truncate, loc, offset, xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_TRUNCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.offset = offset;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for gfid=%s",
+                     uuid_utoa(loc->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                      subvol->fops->truncate, loc, offset, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               dict_t *xdata)
+dht_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FTRUNCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.offset = offset;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                           subvol->fops->ftruncate, fd,
-                           local->rebalance.offset, local->xattr_req);
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FTRUNCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.offset = offset;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                      subvol->fops->ftruncate, fd, local->rebalance.offset,
+                      local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
+dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                  dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        xlator_t    *src_subvol = NULL;
-        xlator_t    *dst_subvol = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* fallocate fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* fallocate fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-        local->rebalance.target_op_fn = dht_fallocate2;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+        goto out;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
-
-                dht_inode_ctx_get_mig_info (this, local->fd->inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              src_subvol, dst_subvol)) {
-                        if (dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
-                                dht_fallocate2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    local->rebalance.target_op_fn = dht_fallocate2;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                   &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if (dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+                dht_fallocate2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (fallocate, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(fallocate, frame, op_ret, op_errno, prebuf, postbuf,
+                     xdata);
 err:
-        return 0;
+    return 0;
 }
 
-int
-dht_fallocate2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_fallocate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (fallocate, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(fallocate, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (subvol == NULL)
+        goto out;
 
-	STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                           subvol->fops->fallocate, local->fd,
-                           local->rebalance.flags, local->rebalance.offset,
-		           local->rebalance.size, local->xattr_req);
+    local->call_cnt = 2; /* This is the second attempt */
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                      subvol->fops->fallocate, local->fd,
+                      local->rebalance.flags, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-	      off_t offset, size_t len, dict_t *xdata)
+dht_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FALLOCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-	local->rebalance.flags = mode;
-        local->rebalance.offset = offset;
-	local->rebalance.size = len;
-
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                           subvol->fops->fallocate, fd,
-                           local->rebalance.flags,
-                           local->rebalance.offset,
-                           local->rebalance.size,
-                           local->xattr_req);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FALLOCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.flags = mode;
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
+
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                      subvol->fops->fallocate, fd, local->rebalance.flags,
+                      local->rebalance.offset, local->rebalance.size,
+                      local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        xlator_t    *src_subvol = NULL;
-        xlator_t    *dst_subvol = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-
-        /* discard fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* discard fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_discard2;
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+        goto out;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
-
-                dht_inode_ctx_get_mig_info (this, local->fd->inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid(local->cached_subvol,
-                                             src_subvol, dst_subvol)) {
-                        if (dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
-                                dht_discard2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_discard2;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                   &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if (dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+                dht_discard2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (discard, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(discard, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
-int
-dht_discard2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_discard2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (discard, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(discard, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (subvol == NULL)
+        goto out;
 
-	STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                           subvol->fops->discard, local->fd,
-                           local->rebalance.offset, local->rebalance.size,
-		           local->xattr_req);
+    local->call_cnt = 2; /* This is the second attempt */
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                      subvol->fops->discard, local->fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-	    size_t len, dict_t *xdata)
+dht_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_DISCARD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        local->rebalance.offset = offset;
-	local->rebalance.size = len;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, fd, GF_FOP_DISCARD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
 
-        STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                           subvol->fops->discard, fd,
-                           local->rebalance.offset,
-                           local->rebalance.size,
-                           local->xattr_req);
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                      subvol->fops->discard, fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata)
 {
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        int           ret     = -1;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* zerofill fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf, NULL);
-                        dht_iatt_merge (this, prebuf, &local->prebuf, NULL);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* zerofill fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+    if (dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_zerofill2;
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
-
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf, NULL);
-                dht_iatt_merge (this, &local->prebuf, prebuf, NULL);
-
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        if (dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                dht_zerofill2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
-
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_zerofill2;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &subvol1,
+                                         &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            if (dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                dht_zerofill2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
 
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (zerofill, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(zerofill, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
-int
-dht_zerofill2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_zerofill2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (zerofill, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(zerofill, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
 
-                return 0;
-        }
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                           subvol->fops->zerofill,
-                           local->fd, local->rebalance.offset,
-                           local->rebalance.size, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                      subvol->fops->zerofill, local->fd,
+                      local->rebalance.offset, local->rebalance.size,
+                      local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
 
-        DHT_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            off_t len, dict_t *xdata)
+dht_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             off_t len, dict_t *xdata)
 {
-        xlator_t     *subvol       = NULL;
-        int           op_errno     = -1;
-        dht_local_t  *local        = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_ZEROFILL);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        local->rebalance.offset = offset;
-        local->rebalance.size = len;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, fd, GF_FOP_ZEROFILL);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
 
-        STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                           subvol->fops->zerofill, fd,
-                           local->rebalance.offset,
-                           local->rebalance.size, local->xattr_req);
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                      subvol->fops->zerofill, fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
 
-        return 0;
-}
+    return 0;
 
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
 
+    return 0;
+}
 
 /* handle cases of migration here for 'setattr()' calls */
 int
-dht_file_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+dht_file_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-
-        local = frame->local;
-        prev = cookie;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
 
-        local->op_errno = op_errno;
-
-        if ((local->fop == GF_FOP_FSETATTR) &&
-            (op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    local = frame->local;
+    prev = cookie;
 
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
+    local->op_errno = op_errno;
 
-        if (local->call_cnt != 1)
-                goto out;
+    if ((local->fop == GF_FOP_FSETATTR) &&
+        dht_check_remote_fd_failed_error(local, op_ret, op_errno)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
 
-        local->rebalance.target_op_fn = dht_setattr2;
+    if (local->call_cnt != 1)
+        goto out;
 
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
+    local->rebalance.target_op_fn = dht_setattr2;
 
-                dht_set_local_rebalance (this, local, NULL, prebuf,
-                                         postbuf, xdata);
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        /* At the end of the migration process, whatever 'attr' we
-           have on source file will be migrated to destination file
-           in one shot, hence we don't need to check for in progress
-           state here (ie, PHASE1) */
+    /* At the end of the migration process, whatever 'attr' we
+       have on source file will be migrated to destination file
+       in one shot, hence we don't need to check for in progress
+       state here (ie, PHASE1) */
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (setattr, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_setattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+static int
+dht_setattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (setattr, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
-
-        if (local->fop == GF_FOP_SETATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->setattr, &local->loc,
-                                   &local->rebalance.stbuf, local->rebalance.flags,
-                                   local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, local->fd,
-                                   &local->rebalance.stbuf, local->rebalance.flags,
-                                   local->xattr_req);
-        }
+    if (subvol == NULL)
+        goto out;
 
-        return 0;
+    local->call_cnt = 2; /* This is the second attempt */
+
+    if (local->fop == GF_FOP_SETATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->setattr, &local->loc,
+                          &local->rebalance.stbuf, local->rebalance.flags,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->fsetattr, local->fd,
+                          &local->rebalance.stbuf, local->rebalance.flags,
+                          local->xattr_req);
+    }
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* Keep the existing code same for all the cases other than regular file */
 int
-dht_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, struct iatt *statpre,
-                 struct iatt *statpost, dict_t *xdata)
+dht_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *statpre, struct iatt *statpost,
+                dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-
-
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
-
-                dht_iatt_merge (this, &local->prebuf, statpre, prev);
-                dht_iatt_merge (this, &local->stbuf, statpost, prev);
-
-                local->op_ret = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            UNLOCK(&frame->lock);
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto post_unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-		if (local->op_ret == 0)
-			dht_inode_ctx_time_set (local->loc.inode, this,
-						&local->stbuf);
-                DHT_STACK_UNWIND (setattr, frame, local->op_ret, local->op_errno,
-                                  &local->prebuf, &local->stbuf, xdata);
-	}
 
-        return 0;
+        dht_iatt_merge(this, &local->prebuf, statpre);
+        dht_iatt_merge(this, &local->stbuf, statpost);
+
+        local->op_ret = 0;
+        local->op_errno = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (local->op_ret == 0)
+            dht_inode_ctx_time_set(local->loc.inode, this, &local->stbuf);
+        DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                         &local->prebuf, &local->stbuf, xdata);
+    }
+
+    return 0;
 }
 
-
+/* Keep the existing code same for all the cases other than regular file */
 int
-dht_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             struct iatt *stbuf, int32_t valid, dict_t *xdata)
+dht_non_mds_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        dht_layout_t *layout = NULL;
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SETATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (op_ret == -1) {
+        gf_msg(this->name, op_errno, 0, 0, "subvolume %s returned -1",
+               prev->name);
+        goto post_unlock;
+    }
+
+    LOCK(&frame->lock);
+    {
+        dht_iatt_merge(this, &local->prebuf, statpre);
+        dht_iatt_merge(this, &local->stbuf, statpost);
+
+        local->op_ret = 0;
+        local->op_errno = 0;
+    }
+    UNLOCK(&frame->lock);
+post_unlock:
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_inode_ctx_time_set(local->loc.inode, this, &local->stbuf);
+        DHT_STACK_UNWIND(setattr, frame, 0, 0, &local->prebuf, &local->stbuf,
+                         xdata);
+    }
+
+    return 0;
+}
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+int
+dht_mds_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iatt *statpre,
+                    struct iatt *statpost, dict_t *xdata)
 
-        if (!layout_is_sane (layout)) {
-                gf_msg_debug (this->name, 0,
-                              "layout is not sane for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *mds_subvol = NULL;
+    struct iatt loc_stbuf = {
+        0,
+    };
+    int i = 0;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    mds_subvol = local->mds_subvol;
+
+    if (op_ret == -1) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    local->op_ret = 0;
+    loc_stbuf = local->stbuf;
+    dht_iatt_merge(this, &local->prebuf, statpre);
+    dht_iatt_merge(this, &local->stbuf, statpost);
+
+    local->call_cnt = conf->subvolume_cnt - 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol == conf->subvolumes[i])
+            continue;
+        STACK_WIND_COOKIE(frame, dht_non_mds_setattr_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->setattr, &local->loc,
+                          &loc_stbuf, local->valid, local->xattr_req);
+    }
+
+    return 0;
+out:
+    DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                     &local->prebuf, &local->stbuf, xdata);
 
-        if (IA_ISREG (loc->inode->ia_type)) {
-                /* in the regular file _cbk(), we need to check for
-                   migration possibilities */
-                local->rebalance.stbuf = *stbuf;
-                local->rebalance.flags = valid;
-                local->call_cnt = 1;
-                subvol = local->cached_subvol;
+    return 0;
+}
 
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->setattr, loc, stbuf,
-                                   valid, xdata);
+int
+dht_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+            int32_t valid, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int ret = -1;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    conf = this->private;
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SETATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (!layout_is_sane(layout)) {
+        gf_msg_debug(this->name, 0, "layout is not sane for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(loc->inode->ia_type)) {
+        /* in the regular file _cbk(), we need to check for
+           migration possibilities */
+        local->rebalance.stbuf = *stbuf;
+        local->rebalance.flags = valid;
+        local->call_cnt = 1;
+        subvol = local->cached_subvol;
 
-                return 0;
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->setattr, loc, stbuf, valid, xdata);
+
+        return 0;
+    }
+
+    local->call_cnt = call_cnt = layout->cnt;
+
+    if (IA_ISDIR(loc->inode->ia_type) && !__is_root_gfid(loc->inode->gfid) &&
+        call_cnt != 1) {
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+        if (ret || !mds_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get mds subvol for path %s", local->loc.path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        local->call_cnt = call_cnt = layout->cnt;
+        local->mds_subvol = mds_subvol;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == mds_subvol) {
+                if (!conf->subvolume_status[i]) {
+                    gf_msg(this->name, GF_LOG_WARNING, layout->list[i].err,
+                           DHT_MSG_HASHED_SUBVOL_DOWN,
+                           "MDS subvol is down for path "
+                           " %s Unable to set attr ",
+                           local->loc.path);
+                    op_errno = ENOTCONN;
+                    goto err;
+                }
+            }
+        }
+        local->valid = valid;
+        local->stbuf = *stbuf;
 
+        STACK_WIND_COOKIE(frame, dht_mds_setattr_cbk, local->mds_subvol,
+                          local->mds_subvol, local->mds_subvol->fops->setattr,
+                          loc, stbuf, valid, xdata);
+        return 0;
+    } else {
         for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_setattr_cbk,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator->fops->setattr,
-                                   loc, stbuf, valid, xdata);
+            STACK_WIND_COOKIE(frame, dht_setattr_cbk, layout->list[i].xlator,
+                              layout->list[i].xlator,
+                              layout->list[i].xlator->fops->setattr, loc, stbuf,
+                              valid, xdata);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
-              int32_t valid, dict_t *xdata)
+dht_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
+             int32_t valid, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        dht_layout_t *layout = NULL;
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSETATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSETATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (!layout_is_sane(layout)) {
+        gf_msg_debug(this->name, 0, "layout is not sane for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(fd->inode->ia_type)) {
+        /* in the regular file _cbk(), we need to check for
+           migration possibilities */
+        local->rebalance.stbuf = *stbuf;
+        local->rebalance.flags = valid;
+        local->call_cnt = 1;
+        subvol = local->cached_subvol;
 
-        if (!layout_is_sane (layout)) {
-                gf_msg_debug (this->name, 0,
-                              "layout is not sane for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (fd->inode->ia_type)) {
-                /* in the regular file _cbk(), we need to check for
-                   migration possibilities */
-                local->rebalance.stbuf = *stbuf;
-                local->rebalance.flags = valid;
-                local->call_cnt = 1;
-                subvol = local->cached_subvol;
-
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, fd,
-                                   &local->rebalance.stbuf,
-                                   local->rebalance.flags,
-                                   local->xattr_req);
-                return 0;
-        }
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->fsetattr, fd, &local->rebalance.stbuf,
+                          local->rebalance.flags, local->xattr_req);
+        return 0;
+    }
 
-        local->call_cnt = call_cnt = layout->cnt;
+    local->call_cnt = call_cnt = layout->cnt;
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_setattr_cbk,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator->fops->fsetattr,
-                                   fd, stbuf, valid, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_setattr_cbk, layout->list[i].xlator,
+                          layout->list[i].xlator,
+                          layout->list[i].xlator->fops->fsetattr, fd, stbuf,
+                          valid, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-layout.c b/xlators/cluster/dht/src/dht-layout.c
index 3414dc91908..fda904c92c9 100644
--- a/xlators/cluster/dht/src/dht-layout.c
+++ b/xlators/cluster/dht/src/dht-layout.c
@@ -8,890 +8,801 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "glusterfs.h"
-#include "xlator.h"
 #include "dht-common.h"
-#include "byte-order.h"
-#include "dht-messages.h"
+#include <glusterfs/byte-order.h>
 #include "unittest/unittest.h"
 
+#define layout_base_size (sizeof(dht_layout_t))
 
-#define layout_base_size (sizeof (dht_layout_t))
-
-#define layout_entry_size (sizeof ((dht_layout_t *)NULL)->list[0])
+#define layout_entry_size (sizeof((dht_layout_t *)NULL)->list[0])
 
 #define layout_size(cnt) (layout_base_size + (cnt * layout_entry_size))
 
 dht_layout_t *
-dht_layout_new (xlator_t *this, int cnt)
+dht_layout_new(xlator_t *this, int cnt)
 {
-        dht_layout_t *layout = NULL;
-        dht_conf_t   *conf = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
 
-        REQUIRE(NULL != this);
-        REQUIRE(cnt >= 0);
+    REQUIRE(NULL != this);
+    REQUIRE(cnt >= 0);
 
-        conf = this->private;
+    conf = this->private;
 
-        layout = GF_CALLOC (1, layout_size (cnt),
-                            gf_dht_mt_dht_layout_t);
-        if (!layout) {
-                goto out;
-        }
+    layout = GF_CALLOC(1, layout_size(cnt), gf_dht_mt_dht_layout_t);
+    if (!layout) {
+        goto out;
+    }
 
-        layout->type = DHT_HASH_TYPE_DM;
-        layout->cnt = cnt;
+    layout->type = DHT_HASH_TYPE_DM;
+    layout->cnt = cnt;
 
-        if (conf) {
-                layout->spread_cnt = conf->dir_spread_cnt;
-                layout->gen = conf->gen;
-        }
+    if (conf) {
+        layout->spread_cnt = conf->dir_spread_cnt;
+        layout->gen = conf->gen;
+    }
 
-        layout->ref = 1;
+    GF_ATOMIC_INIT(layout->ref, 1);
 
-        ENSURE(NULL != layout);
-        ENSURE(layout->type == DHT_HASH_TYPE_DM);
-        ENSURE(layout->cnt == cnt);
-        ENSURE(layout->ref == 1);
+    ENSURE(NULL != layout);
+    ENSURE(layout->type == DHT_HASH_TYPE_DM);
+    ENSURE(layout->cnt == cnt);
+    ENSURE(GF_ATOMIC_GET(layout->ref) == 1);
 out:
-        return layout;
+    return layout;
 }
 
-
 dht_layout_t *
-dht_layout_get (xlator_t *this, inode_t *inode)
+dht_layout_get(xlator_t *this, inode_t *inode)
 {
-        dht_conf_t   *conf = NULL;
-        dht_layout_t *layout = NULL;
-        int           ret = 0;
-
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-        LOCK (&conf->layout_lock);
-        {
-                ret = dht_inode_ctx_layout_get (inode, this, &layout);
-                if ((!ret) && layout) {
-                        layout->ref++;
-                }
-        }
-        UNLOCK (&conf->layout_lock);
-
-out:
-        return layout;
+    dht_layout_t *layout = NULL;
+    int ret = 0;
+
+    ret = dht_inode_ctx_layout_get(inode, this, &layout);
+    if ((!ret) && layout) {
+        GF_ATOMIC_INC(layout->ref);
+    }
+    return layout;
 }
 
-
 int
-dht_layout_set (xlator_t *this, inode_t *inode, dht_layout_t *layout)
+dht_layout_set(xlator_t *this, inode_t *inode, dht_layout_t *layout)
 {
-        dht_conf_t   *conf = NULL;
-        int           oldret = -1;
-        int           ret = -1;
-        dht_layout_t *old_layout;
-
-        conf = this->private;
-        if (!conf || !layout)
-                goto out;
-
-        LOCK (&conf->layout_lock);
-        {
-                oldret = dht_inode_ctx_layout_get (inode, this, &old_layout);
-                if (layout)
-                        layout->ref++;
-                ret = dht_inode_ctx_layout_set (inode, this, layout);
-        }
-        UNLOCK (&conf->layout_lock);
-
-        if (!oldret) {
-                dht_layout_unref (this, old_layout);
-        }
+    dht_conf_t *conf = NULL;
+    int oldret = -1;
+    int ret = -1;
+    dht_layout_t *old_layout;
+
+    conf = this->private;
+    if (!conf || !layout)
+        goto out;
+
+    LOCK(&conf->layout_lock);
+    {
+        oldret = dht_inode_ctx_layout_get(inode, this, &old_layout);
+        if (layout)
+            GF_ATOMIC_INC(layout->ref);
+        ret = dht_inode_ctx_layout_set(inode, this, layout);
+    }
+    UNLOCK(&conf->layout_lock);
+
+    if (!oldret) {
+        dht_layout_unref(this, old_layout);
+    }
+    if (ret)
+        GF_ATOMIC_DEC(layout->ref);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-dht_layout_unref (xlator_t *this, dht_layout_t *layout)
+dht_layout_unref(xlator_t *this, dht_layout_t *layout)
 {
-        dht_conf_t  *conf = NULL;
-        int          ref = 0;
+    int ref = 0;
 
-        if (!layout || layout->preset || !this->private)
-                return;
+    if (!layout || layout->preset || !this->private)
+        return;
 
-        conf = this->private;
-
-        LOCK (&conf->layout_lock);
-        {
-                ref = --layout->ref;
-        }
-        UNLOCK (&conf->layout_lock);
+    ref = GF_ATOMIC_DEC(layout->ref);
 
-        if (!ref)
-                GF_FREE (layout);
+    if (!ref)
+        GF_FREE(layout);
 }
 
-
 dht_layout_t *
-dht_layout_ref (xlator_t *this, dht_layout_t *layout)
+dht_layout_ref(xlator_t *this, dht_layout_t *layout)
 {
-        dht_conf_t  *conf = NULL;
-
-        if (layout->preset || !this->private)
-                return layout;
+    if (layout->preset || !this->private)
+        return layout;
 
-        conf = this->private;
-        LOCK (&conf->layout_lock);
-        {
-                layout->ref++;
-        }
-        UNLOCK (&conf->layout_lock);
+    GF_ATOMIC_INC(layout->ref);
 
-        return layout;
+    return layout;
 }
 
-
 xlator_t *
-dht_layout_search (xlator_t *this, dht_layout_t *layout, const char *name)
+dht_layout_search(xlator_t *this, dht_layout_t *layout, const char *name)
 {
-        uint32_t   hash = 0;
-        xlator_t  *subvol = NULL;
-        int        i = 0;
-        int        ret = 0;
-
-        ret = dht_hash_compute (this, layout->type, name, &hash);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_COMPUTE_HASH_FAILED,
-                        "hash computation failed for type=%d name=%s",
-                        layout->type, name);
-                goto out;
-        }
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].start <= hash
-                    && layout->list[i].stop >= hash) {
-                        subvol = layout->list[i].xlator;
-                        break;
-                }
-        }
-
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "no subvolume for hash (value) = %u", hash);
-        }
+    uint32_t hash = 0;
+    xlator_t *subvol = NULL;
+    int i = 0;
+    int ret = 0;
+
+    ret = dht_hash_compute(this, layout->type, name, &hash);
+    if (ret != 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_COMPUTE_HASH_FAILED,
+                "type=%d", layout->type, "name=%s", name, NULL);
+        goto out;
+    }
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].start <= hash && layout->list[i].stop >= hash) {
+            subvol = layout->list[i].xlator;
+            break;
+        }
+    }
+
+    if (!subvol) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                "hash-value=0x%x", hash, NULL);
+    }
 
 out:
-        return subvol;
+    return subvol;
 }
 
-
 dht_layout_t *
-dht_layout_for_subvol (xlator_t *this, xlator_t *subvol)
+dht_layout_for_subvol(xlator_t *this, xlator_t *subvol)
 {
-        dht_conf_t   *conf = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == subvol) {
-                        layout = conf->file_layouts[i];
-                        break;
-                }
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+
+    conf = this->private;
+    if (!conf)
+        goto out;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == subvol) {
+            layout = conf->file_layouts[i];
+            break;
         }
+    }
 
 out:
-        return layout;
+    return layout;
 }
 
-
 int
-dht_layouts_init (xlator_t *this, dht_conf_t *conf)
+dht_layouts_init(xlator_t *this, dht_conf_t *conf)
 {
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           ret = -1;
-
-        if (!conf)
-                goto out;
-
-        conf->file_layouts = GF_CALLOC (conf->subvolume_cnt,
-                                        sizeof (dht_layout_t *),
-                                        gf_dht_mt_dht_layout_t);
-        if (!conf->file_layouts) {
-                goto out;
-        }
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int ret = -1;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                layout = dht_layout_new (this, 1);
+    if (!conf)
+        goto out;
 
-                if (!layout) {
-                        goto out;
-                }
-
-                layout->preset = 1;
+    conf->file_layouts = GF_CALLOC(conf->subvolume_cnt, sizeof(dht_layout_t *),
+                                   gf_dht_mt_dht_layout_t);
+    if (!conf->file_layouts) {
+        goto out;
+    }
 
-                layout->list[0].xlator = conf->subvolumes[i];
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        layout = dht_layout_new(this, 1);
 
-                conf->file_layouts[i] = layout;
+        if (!layout) {
+            goto out;
         }
 
-        ret = 0;
+        layout->preset = 1;
+
+        layout->list[0].xlator = conf->subvolumes[i];
+
+        conf->file_layouts[i] = layout;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_disk_layout_extract (xlator_t *this, dht_layout_t *layout,
-                         int pos, int32_t **disk_layout_p)
+dht_disk_layout_extract(xlator_t *this, dht_layout_t *layout, int pos,
+                        int32_t **disk_layout_p)
 {
-        int      ret = -1;
-        int32_t *disk_layout = NULL;
+    int ret = -1;
+    int32_t *disk_layout = NULL;
 
-        disk_layout = GF_CALLOC (5, sizeof (int),
-                                 gf_dht_mt_int32_t);
-        if (!disk_layout) {
-                goto out;
-        }
+    disk_layout = GF_CALLOC(5, sizeof(int), gf_dht_mt_int32_t);
+    if (!disk_layout) {
+        goto out;
+    }
 
-        disk_layout[0] = hton32 (layout->list[pos].commit_hash);
-        disk_layout[1] = hton32 (layout->type);
-        disk_layout[2] = hton32 (layout->list[pos].start);
-        disk_layout[3] = hton32 (layout->list[pos].stop);
+    disk_layout[0] = hton32(layout->list[pos].commit_hash);
+    disk_layout[1] = hton32(layout->type);
+    disk_layout[2] = hton32(layout->list[pos].start);
+    disk_layout[3] = hton32(layout->list[pos].stop);
 
-        if (disk_layout_p)
-                *disk_layout_p = disk_layout;
-        else
-                GF_FREE (disk_layout);
+    if (disk_layout_p)
+        *disk_layout_p = disk_layout;
+    else
+        GF_FREE(disk_layout);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_disk_layout_extract_for_subvol (xlator_t *this, dht_layout_t *layout,
-                                    xlator_t *subvol, int32_t **disk_layout_p)
+dht_disk_layout_extract_for_subvol(xlator_t *this, dht_layout_t *layout,
+                                   xlator_t *subvol, int32_t **disk_layout_p)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol)
-                        break;
-        }
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol)
+            break;
+    }
 
-        if (i == layout->cnt)
-                return -1;
+    if (i == layout->cnt)
+        return -1;
 
-        return dht_disk_layout_extract (this, layout, i, disk_layout_p);
+    return dht_disk_layout_extract(this, layout, i, disk_layout_p);
 }
 
-int
-dht_disk_layout_merge (xlator_t *this, dht_layout_t *layout,
-		       int pos, void *disk_layout_raw, int disk_layout_len)
+static int
+dht_disk_layout_merge(xlator_t *this, dht_layout_t *layout, int pos,
+                      void *disk_layout_raw, int disk_layout_len)
 {
-        int      type = 0;
-        int      start_off = 0;
-        int      stop_off = 0;
-        int      commit_hash = 0;
-        int      disk_layout[4];
+    int type = 0;
+    int start_off = 0;
+    int stop_off = 0;
+    int commit_hash = 0;
+    int disk_layout[4];
 
-	if (!disk_layout_raw) {
-		gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "error no layout on disk for merge");
-		return -1;
-	}
+    if (!disk_layout_raw) {
+        gf_smsg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                NULL);
+        return -1;
+    }
 
-	GF_ASSERT (disk_layout_len == sizeof (disk_layout));
+    GF_ASSERT(disk_layout_len == sizeof(disk_layout));
 
-        memcpy (disk_layout, disk_layout_raw, disk_layout_len);
+    memcpy(disk_layout, disk_layout_raw, disk_layout_len);
 
-        type = ntoh32 (disk_layout[1]);
-	switch (type) {
+    type = ntoh32(disk_layout[1]);
+    switch (type) {
         case DHT_HASH_TYPE_DM_USER:
-                gf_msg_debug (this->name, 0, "found user-set layout");
-                layout->type = type;
-                /* Fall through. */
-	case DHT_HASH_TYPE_DM:
-		break;
+            gf_msg_debug(this->name, 0, "found user-set layout");
+            layout->type = type;
+            /* Fall through. */
+        case DHT_HASH_TYPE_DM:
+            break;
         default:
-		gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_INVALID_DISK_LAYOUT,
-			"Invalid disk layout: "
-                        "Catastrophic error layout with unknown type found %d",
-			disk_layout[1]);
-		return -1;
-	}
-
-        commit_hash = ntoh32 (disk_layout[0]);
-        start_off = ntoh32 (disk_layout[2]);
-        stop_off  = ntoh32 (disk_layout[3]);
-
-        layout->list[pos].commit_hash = commit_hash;
-        layout->list[pos].start = start_off;
-        layout->list[pos].stop  = stop_off;
-
-        gf_msg_trace (this->name, 0,
-                      "merged to layout: %u - %u (type %d, hash %d) from %s",
-                      start_off, stop_off, commit_hash, type,
-                      layout->list[pos].xlator->name);
-
-        return 0;
+            gf_smsg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_INVALID_DISK_LAYOUT,
+                    "layout=%d", disk_layout[1], NULL);
+            return -1;
+    }
+
+    commit_hash = ntoh32(disk_layout[0]);
+    start_off = ntoh32(disk_layout[2]);
+    stop_off = ntoh32(disk_layout[3]);
+
+    layout->list[pos].commit_hash = commit_hash;
+    layout->list[pos].start = start_off;
+    layout->list[pos].stop = stop_off;
+
+    gf_msg_trace(this->name, 0,
+                 "merged to layout: 0x%x - 0x%x (hash 0x%x, type %d) from %s",
+                 start_off, stop_off, commit_hash, type,
+                 layout->list[pos].xlator->name);
+
+    return 0;
 }
 
 int
-dht_layout_merge (xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
-                  int op_ret, int op_errno, dict_t *xattr)
+dht_layout_merge(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                 int op_ret, int op_errno, dict_t *xattr)
 {
-        int         i     = 0;
-        int         ret   = -1;
-        int         err   = -1;
-        void       *disk_layout_raw = NULL;
-        int         disk_layout_len = 0;
-        dht_conf_t *conf = this->private;
-
-        if (op_ret != 0) {
-                err = op_errno;
-        }
+    int i = 0;
+    int ret = -1;
+    int err = -1;
+    void *disk_layout_raw = NULL;
+    int disk_layout_len = 0;
+    dht_conf_t *conf = this->private;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == NULL) {
-                        layout->list[i].err    = err;
-                        layout->list[i].xlator = subvol;
-                        break;
-                }
-        }
+    if (op_ret != 0) {
+        err = op_errno;
+    }
 
-        if (op_ret != 0) {
-                ret = 0;
-                goto out;
-        }
-
-        if (xattr) {
-                /* during lookup and not mkdir */
-                ret = dict_get_ptr_and_len (xattr, conf->xattr_name,
-					    &disk_layout_raw, &disk_layout_len);
-        }
+    if (!layout)
+        goto out;
 
-        if (ret != 0) {
-                layout->list[i].err = 0;
-                gf_msg_trace (this->name, 0,
-                              "Missing disk layout on %s. err = %d",
-                              subvol->name, err);
-                ret = 0;
-                goto out;
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == NULL) {
+            layout->list[i].err = err;
+            layout->list[i].xlator = subvol;
+            break;
         }
+    }
 
-        ret = dht_disk_layout_merge (this, layout, i, disk_layout_raw,
-				     disk_layout_len);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "layout merge from subvolume %s failed",
-                        subvol->name);
-                goto out;
-        }
+    if (op_ret != 0) {
+        ret = 0;
+        goto out;
+    }
 
-        if (layout->commit_hash == 0) {
-                layout->commit_hash = layout->list[i].commit_hash;
-        } else if (layout->commit_hash != layout->list[i].commit_hash) {
-                layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
-        }
+    if (xattr) {
+        /* during lookup and not mkdir */
+        ret = dict_get_ptr_and_len(xattr, conf->xattr_name, &disk_layout_raw,
+                                   &disk_layout_len);
+    }
 
+    if (ret != 0) {
         layout->list[i].err = 0;
+        gf_msg_trace(this->name, 0, "Missing disk layout on %s. err = %d",
+                     subvol->name, err);
+        ret = 0;
+        goto out;
+    }
+
+    ret = dht_disk_layout_merge(this, layout, i, disk_layout_raw,
+                                disk_layout_len);
+    if (ret != 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                "subvolume=%s", subvol->name, NULL);
+        goto out;
+    }
+
+    if (layout->commit_hash == 0) {
+        layout->commit_hash = layout->list[i].commit_hash;
+    } else if (layout->commit_hash != layout->list[i].commit_hash) {
+        layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+    }
+
+    layout->list[i].err = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-dht_layout_entry_swap (dht_layout_t *layout, int i, int j)
+dht_layout_entry_swap(dht_layout_t *layout, int i, int j)
 {
-        uint32_t  start_swap = 0;
-        uint32_t  stop_swap = 0;
-        uint32_t  commit_hash_swap = 0;
-        xlator_t *xlator_swap = 0;
-        int       err_swap = 0;
-
-        start_swap  = layout->list[i].start;
-        stop_swap   = layout->list[i].stop;
-        xlator_swap = layout->list[i].xlator;
-        err_swap    = layout->list[i].err;
-        commit_hash_swap = layout->list[i].commit_hash;
-
-        layout->list[i].start  = layout->list[j].start;
-        layout->list[i].stop   = layout->list[j].stop;
-        layout->list[i].xlator = layout->list[j].xlator;
-        layout->list[i].err    = layout->list[j].err;
-        layout->list[i].commit_hash = layout->list[j].commit_hash;
-
-        layout->list[j].start  = start_swap;
-        layout->list[j].stop   = stop_swap;
-        layout->list[j].xlator = xlator_swap;
-        layout->list[j].err    = err_swap;
-        layout->list[j].commit_hash = commit_hash_swap;
+    uint32_t start_swap = 0;
+    uint32_t stop_swap = 0;
+    uint32_t commit_hash_swap = 0;
+    xlator_t *xlator_swap = 0;
+    int err_swap = 0;
+
+    start_swap = layout->list[i].start;
+    stop_swap = layout->list[i].stop;
+    xlator_swap = layout->list[i].xlator;
+    err_swap = layout->list[i].err;
+    commit_hash_swap = layout->list[i].commit_hash;
+
+    layout->list[i].start = layout->list[j].start;
+    layout->list[i].stop = layout->list[j].stop;
+    layout->list[i].xlator = layout->list[j].xlator;
+    layout->list[i].err = layout->list[j].err;
+    layout->list[i].commit_hash = layout->list[j].commit_hash;
+
+    layout->list[j].start = start_swap;
+    layout->list[j].stop = stop_swap;
+    layout->list[j].xlator = xlator_swap;
+    layout->list[j].err = err_swap;
+    layout->list[j].commit_hash = commit_hash_swap;
 }
 
 void
-dht_layout_range_swap (dht_layout_t *layout, int i, int j)
+dht_layout_range_swap(dht_layout_t *layout, int i, int j)
 {
-        uint32_t  start_swap = 0;
-        uint32_t  stop_swap = 0;
+    uint32_t start_swap = 0;
+    uint32_t stop_swap = 0;
 
-        start_swap  = layout->list[i].start;
-        stop_swap   = layout->list[i].stop;
+    start_swap = layout->list[i].start;
+    stop_swap = layout->list[i].stop;
 
-        layout->list[i].start  = layout->list[j].start;
-        layout->list[i].stop   = layout->list[j].stop;
+    layout->list[i].start = layout->list[j].start;
+    layout->list[i].stop = layout->list[j].stop;
 
-        layout->list[j].start  = start_swap;
-        layout->list[j].stop   = stop_swap;
+    layout->list[j].start = start_swap;
+    layout->list[j].stop = stop_swap;
 }
-
-int64_t
-dht_layout_entry_cmp_volname (dht_layout_t *layout, int i, int j)
+static int64_t
+dht_layout_entry_cmp_volname(dht_layout_t *layout, int i, int j)
 {
-        return (strcmp (layout->list[i].xlator->name,
-                        layout->list[j].xlator->name));
+    return (strcmp(layout->list[i].xlator->name, layout->list[j].xlator->name));
 }
 
 gf_boolean_t
-dht_is_subvol_in_layout (dht_layout_t *layout, xlator_t *xlator)
+dht_is_subvol_in_layout(dht_layout_t *layout, xlator_t *xlator)
 {
-        int i = 0;
-
-        for (i = 0; i < layout->cnt; i++) {
-                /* Check if xlator is already part of layout, and layout is
-                 * non-zero. */
-                if (!strcmp (layout->list[i].xlator->name, xlator->name)) {
-                        if (layout->list[i].start != layout->list[i].stop)
-                                return _gf_true;
-                        break;
-                }
-        }
-        return _gf_false;
+    int i = 0;
+
+    for (i = 0; i < layout->cnt; i++) {
+        /* Check if xlator is already part of layout, and layout is
+         * non-zero. */
+        if (!strcmp(layout->list[i].xlator->name, xlator->name)) {
+            if (layout->list[i].start != layout->list[i].stop)
+                return _gf_true;
+            break;
+        }
+    }
+    return _gf_false;
 }
 
-int64_t
-dht_layout_entry_cmp (dht_layout_t *layout, int i, int j)
+static int64_t
+dht_layout_entry_cmp(dht_layout_t *layout, int i, int j)
 {
-        int64_t diff = 0;
+    int64_t diff = 0;
 
-        /* swap zero'ed out layouts to front, if needed */
-        if (!layout->list[j].start && !layout->list[j].stop) {
-                diff = (int64_t) layout->list[i].stop
-                       - (int64_t) layout->list[j].stop;
-                       goto out;
-        }
-        diff = (int64_t) layout->list[i].start
-                - (int64_t) layout->list[j].start;
+    /* swap zero'ed out layouts to front, if needed */
+    if (!layout->list[j].start && !layout->list[j].stop) {
+        diff = (int64_t)layout->list[i].stop - (int64_t)layout->list[j].stop;
+        goto out;
+    }
+    diff = (int64_t)layout->list[i].start - (int64_t)layout->list[j].start;
 
 out:
-        return diff;
+    return diff;
 }
 
-
 int
-dht_layout_sort (dht_layout_t *layout)
+dht_layout_sort(dht_layout_t *layout)
 {
-        int       i = 0;
-        int       j = 0;
-        int64_t   ret = 0;
+    int i = 0;
+    int j = 0;
+    int64_t ret = 0;
 
-        /* TODO: O(n^2) -- bad bad */
+    /* TODO: O(n^2) -- bad bad */
 
-        for (i = 0; i < layout->cnt - 1; i++) {
-                for (j = i + 1; j < layout->cnt; j++) {
-                        ret = dht_layout_entry_cmp (layout, i, j);
-                        if (ret > 0)
-                                dht_layout_entry_swap (layout, i, j);
-                }
+    for (i = 0; i < layout->cnt - 1; i++) {
+        for (j = i + 1; j < layout->cnt; j++) {
+            ret = dht_layout_entry_cmp(layout, i, j);
+            if (ret > 0)
+                dht_layout_entry_swap(layout, i, j);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-int
-dht_layout_sort_volname (dht_layout_t *layout)
+void
+dht_layout_sort_volname(dht_layout_t *layout)
 {
-        int       i = 0;
-        int       j = 0;
-        int64_t   ret = 0;
+    int i = 0;
+    int j = 0;
+    int64_t ret = 0;
 
-        /* TODO: O(n^2) -- bad bad */
+    /* TODO: O(n^2) -- bad bad */
 
-        for (i = 0; i < layout->cnt - 1; i++) {
-                for (j = i + 1; j < layout->cnt; j++) {
-                        ret = dht_layout_entry_cmp_volname (layout, i, j);
-                        if (ret > 0)
-                                dht_layout_entry_swap (layout, i, j);
-                }
+    for (i = 0; i < layout->cnt - 1; i++) {
+        for (j = i + 1; j < layout->cnt; j++) {
+            ret = dht_layout_entry_cmp_volname(layout, i, j);
+            if (ret > 0)
+                dht_layout_entry_swap(layout, i, j);
         }
-
-        return 0;
+    }
 }
 
-
-int
-dht_layout_anomalies (xlator_t *this, loc_t *loc, dht_layout_t *layout,
-                      uint32_t *holes_p, uint32_t *overlaps_p,
-                      uint32_t *missing_p, uint32_t *down_p, uint32_t *misc_p,
-                      uint32_t *no_space_p)
+void
+dht_layout_anomalies(xlator_t *this, loc_t *loc, dht_layout_t *layout,
+                     uint32_t *holes_p, uint32_t *overlaps_p,
+                     uint32_t *missing_p, uint32_t *down_p, uint32_t *misc_p,
+                     uint32_t *no_space_p)
 {
-        uint32_t    overlaps = 0;
-        uint32_t    missing  = 0;
-        uint32_t    down     = 0;
-        uint32_t    misc     = 0;
-        uint32_t    hole_cnt = 0;
-        uint32_t    overlap_cnt = 0;
-        int         i = 0;
-        int         ret = 0;
-        uint32_t    prev_stop = 0;
-        uint32_t    last_stop = 0;
-        char        is_virgin = 1;
-        uint32_t    no_space  = 0;
-
-        /* This function scans through the layout spread of a directory to
-           check if there are any anomalies. Prior to calling this function
-           the layout entries should be sorted in the ascending order.
-
-           If the layout entry has err != 0
-                then increment the corresponding anomaly.
-           else
-                if (start of the current layout entry > stop + 1 of previous
-                   non erroneous layout entry)
-                        then it indicates a hole in the layout
-                if (start of the current layout entry < stop + 1 of previous
-                    non erroneous layout entry)
-                         then it indicates an overlap in the layout
-        */
-        last_stop = layout->list[0].start - 1;
-        prev_stop = last_stop;
-
-        for (i = 0; i < layout->cnt; i++) {
-                switch (layout->list[i].err) {
-                case -1:
-                case ENOENT:
-                case ESTALE:
-                        missing++;
-                        continue;
-                case ENOTCONN:
-                        down++;
-                        continue;
-                case ENOSPC:
-                        no_space++;
-                        continue;
-                case 0:
-                        /* if err == 0 and start == stop, then it is a non misc++;
-                         * participating subvolume(spread-cnt). Then, do not
-                         * check for anomalies. If start != stop, then treat it
-                         * as misc err */
-                        if (layout->list[i].start == layout->list[i].stop) {
-                                continue;
-                        }
-                        break;
-                default:
-                        misc++;
-                        continue;
-                 }
-
-                is_virgin = 0;
-
-                if ((prev_stop + 1) < layout->list[i].start) {
-                        hole_cnt++;
+    uint32_t overlaps = 0;
+    uint32_t missing = 0;
+    uint32_t down = 0;
+    uint32_t misc = 0;
+    uint32_t hole_cnt = 0;
+    uint32_t overlap_cnt = 0;
+    int i = 0;
+    uint32_t prev_stop = 0;
+    uint32_t last_stop = 0;
+    char is_virgin = 1;
+    uint32_t no_space = 0;
+
+    /* This function scans through the layout spread of a directory to
+       check if there are any anomalies. Prior to calling this function
+       the layout entries should be sorted in the ascending order.
+
+       If the layout entry has err != 0
+            then increment the corresponding anomaly.
+       else
+            if (start of the current layout entry > stop + 1 of previous
+               non erroneous layout entry)
+                    then it indicates a hole in the layout
+            if (start of the current layout entry < stop + 1 of previous
+                non erroneous layout entry)
+                     then it indicates an overlap in the layout
+    */
+    last_stop = layout->list[0].start - 1;
+    prev_stop = last_stop;
+
+    for (i = 0; i < layout->cnt; i++) {
+        switch (layout->list[i].err) {
+            case -1:
+            case ENOENT:
+            case ESTALE:
+                missing++;
+                continue;
+            case ENOTCONN:
+                down++;
+                continue;
+            case ENOSPC:
+                no_space++;
+                continue;
+            case 0:
+                /* if err == 0 and start == stop, then it is a non misc++;
+                 * participating subvolume(spread-cnt). Then, do not
+                 * check for anomalies. If start != stop, then treat it
+                 * as misc err */
+                if (layout->list[i].start == layout->list[i].stop) {
+                    continue;
                 }
+                break;
+            default:
+                misc++;
+                continue;
+        }
 
-                if ((prev_stop + 1) > layout->list[i].start) {
-                        overlap_cnt++;
-                        overlaps += ((prev_stop + 1) - layout->list[i].start);
-                }
-                prev_stop = layout->list[i].stop;
+        is_virgin = 0;
+
+        if ((prev_stop + 1) < layout->list[i].start) {
+            hole_cnt++;
         }
 
-        if ((last_stop - prev_stop) || is_virgin)
-                hole_cnt++;
+        if ((prev_stop + 1) > layout->list[i].start) {
+            overlap_cnt++;
+            overlaps += ((prev_stop + 1) - layout->list[i].start);
+        }
+        prev_stop = layout->list[i].stop;
+    }
 
-        if (holes_p)
-                *holes_p = hole_cnt;
+    if ((last_stop - prev_stop) || is_virgin)
+        hole_cnt++;
 
-        if (overlaps_p)
-                *overlaps_p = overlap_cnt;
+    if (holes_p)
+        *holes_p = hole_cnt;
 
-        if (missing_p)
-                *missing_p = missing;
+    if (overlaps_p)
+        *overlaps_p = overlap_cnt;
 
-        if (down_p)
-                *down_p = down;
+    if (missing_p)
+        *missing_p = missing;
 
-        if (misc_p)
-                *misc_p = misc;
+    if (down_p)
+        *down_p = down;
 
-        if (no_space_p)
-                *no_space_p = no_space;
+    if (misc_p)
+        *misc_p = misc;
 
-        return ret;
+    if (no_space_p)
+        *no_space_p = no_space;
 }
 
-
 int
-dht_layout_missing_dirs (dht_layout_t *layout)
+dht_layout_missing_dirs(dht_layout_t *layout)
 {
-        int i = 0, missing = 0;
+    int i = 0, missing = 0;
 
-        if (layout == NULL)
-                goto out;
+    if (layout == NULL)
+        goto out;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if ((layout->list[i].err == ENOENT)
-                    || ((layout->list[i].err == -1)
-                        && (layout->list[i].start == 0)
-                        && (layout->list[i].stop == 0))) {
-                        missing++;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if ((layout->list[i].err == ENOENT) ||
+            ((layout->list[i].err == -1) && (layout->list[i].start == 0) &&
+             (layout->list[i].stop == 0))) {
+            missing++;
         }
+    }
 
 out:
-        return missing;
+    return missing;
 }
 
-
 int
-dht_layout_normalize (xlator_t *this, loc_t *loc, dht_layout_t *layout)
+dht_layout_normalize(xlator_t *this, loc_t *loc, dht_layout_t *layout)
 {
-        int          ret   = 0;
-        uint32_t     holes = 0;
-        uint32_t     overlaps = 0;
-        uint32_t     missing = 0;
-        uint32_t     down = 0;
-        uint32_t     misc = 0, missing_dirs = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        ret = dht_layout_sort (layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_SORT_FAILED,
-                        "sort failed?! how the ....");
-                goto out;
-        }
-
-        gf_uuid_unparse(loc->gfid, gfid);
-
-        ret = dht_layout_anomalies (this, loc, layout,
-                                    &holes, &overlaps,
-                                    &missing, &down, &misc, NULL);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_FIND_LAYOUT_ANOMALIES_ERROR,
-                        "Error finding anomalies in %s, gfid = %s",
-                        loc->path, gfid);
-                goto out;
-        }
-
-        if (holes || overlaps) {
-                if (missing == layout->cnt) {
-                        gf_msg_debug (this->name, 0,
-                                      "Directory %s looked up first time"
-                                      " gfid = %s", loc->path, gfid);
-                } else {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_ANOMALIES_INFO,
-                                "Found anomalies in %s (gfid = %s). "
-                                "Holes=%d overlaps=%d",
-                                loc->path, gfid, holes, overlaps );
-                }
-                ret = -1;
-        }
-
-        if (ret >= 0) {
-                missing_dirs = dht_layout_missing_dirs (layout);
-                /* TODO During DHT selfheal rewrite (almost) find a better place
-                 * to detect this - probably in dht_layout_anomalies()
-                 */
-                if (missing_dirs > 0)
-                        ret += missing_dirs;
-        }
+    int ret = 0;
+    uint32_t holes = 0;
+    uint32_t overlaps = 0;
+    uint32_t missing = 0;
+    uint32_t down = 0;
+    uint32_t misc = 0, missing_dirs = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    ret = dht_layout_sort(layout);
+    if (ret == -1) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_SORT_FAILED,
+                NULL);
+        goto out;
+    }
+
+    gf_uuid_unparse(loc->gfid, gfid);
+
+    dht_layout_anomalies(this, loc, layout, &holes, &overlaps, &missing, &down,
+                         &misc, NULL);
+
+    if (holes || overlaps) {
+        if (missing == layout->cnt) {
+            gf_msg_debug(this->name, 0,
+                         "Directory %s looked up first time"
+                         " gfid = %s",
+                         loc->path, gfid);
+        } else {
+            gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_ANOMALIES_INFO,
+                    "path=%s", loc->path, "gfid=%s", gfid, "holes=%d", holes,
+                    "overlaps=%d", overlaps, NULL);
+        }
+        ret = -1;
+    }
+
+    if (ret >= 0) {
+        missing_dirs = dht_layout_missing_dirs(layout);
+        /* TODO During DHT selfheal rewrite (almost) find a better place
+         * to detect this - probably in dht_layout_anomalies()
+         */
+        if (missing_dirs > 0)
+            ret += missing_dirs;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_dir_has_layout (dict_t *xattr, char *name)
+dht_dir_has_layout(dict_t *xattr, char *name)
 {
+    void *disk_layout_raw = NULL;
 
-        void     *disk_layout_raw = NULL;
-
-        return dict_get_ptr (xattr, name, &disk_layout_raw);
+    return dict_get_ptr(xattr, name, &disk_layout_raw);
 }
 
 int
-dht_layout_dir_mismatch (xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
-                         loc_t *loc, dict_t *xattr)
+dht_layout_dir_mismatch(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                        loc_t *loc, dict_t *xattr)
 {
-        int         idx = 0;
-        int         pos = -1;
-        int         ret = 0;
-        int         err = 0;
-        int         dict_ret = 0;
-        int32_t     disk_layout[4];
-        void       *disk_layout_raw = NULL;
-        uint32_t    start_off = -1;
-        uint32_t    stop_off = -1;
-        uint32_t    commit_hash = -1;
-        dht_conf_t *conf = this->private;
-        char        gfid[GF_UUID_BUF_SIZE] = {0};
-
-        if(loc && loc->inode)
-                gf_uuid_unparse(loc->inode->gfid, gfid);
-
-        for (idx = 0; idx < layout->cnt; idx++) {
-                if (layout->list[idx].xlator == subvol) {
-                        pos = idx;
-                        break;
-                }
-        }
-
-        if (pos == -1) {
-                if (loc) {
-                        gf_msg_debug (this->name, 0,
-                                      "%s - no layout info for subvolume %s",
-                                      loc ? loc->path : "path not found",
-                                      subvol->name);
-                }
-                ret = 1;
-                goto out;
-        }
-
-        err = layout->list[pos].err;
-
-        if (!xattr) {
-                if (err == 0) {
-                        if (loc) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DICT_GET_FAILED,
-                                        "%s: xattr dictionary is NULL",
-                                        loc->path);
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DICT_GET_FAILED,
-                                        "path not found: "
-                                        "xattr dictionary is NULL");
-                        }
-                        ret = -1;
-                }
-                goto out;
-        }
-
-        dict_ret = dict_get_ptr (xattr, conf->xattr_name,
-                                 &disk_layout_raw);
-
-        if (dict_ret < 0) {
-                if (err == 0 && layout->list[pos].stop) {
-                        if (loc) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DISK_LAYOUT_MISSING,
-                                    "%s: Disk layout missing, gfid = %s",
-                                    loc->path, gfid);
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DISK_LAYOUT_MISSING,
-                                        "path not found: "
-                                        "Disk layout missing, gfid = %s",
-                                        gfid);
-                        }
-                        ret = -1;
-                }
-                goto out;
-        }
-
-        memcpy (disk_layout, disk_layout_raw, sizeof (disk_layout));
-
-        start_off = ntoh32 (disk_layout[2]);
-        stop_off  = ntoh32 (disk_layout[3]);
-        commit_hash = ntoh32 (disk_layout[0]);
-
-        if ((layout->list[pos].start != start_off)
-            || (layout->list[pos].stop != stop_off)
-            || (layout->list[pos].commit_hash != commit_hash)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LAYOUT_INFO,
-                        "subvol: %s; inode layout - %"PRIu32" - %"PRIu32
-                        " - %"PRIu32"; "
-                        "disk layout - %"PRIu32" - %"PRIu32" - %"PRIu32,
-                        layout->list[pos].xlator->name,
-                        layout->list[pos].start, layout->list[pos].stop,
-                        layout->list[pos].commit_hash,
-                        start_off, stop_off, commit_hash);
-                ret = 1;
-        } else {
-                ret = 0;
-        }
+    int idx = 0;
+    int pos = -1;
+    int ret = 0;
+    int err = 0;
+    int dict_ret = 0;
+    int32_t disk_layout[4];
+    void *disk_layout_raw = NULL;
+    uint32_t start_off = -1;
+    uint32_t stop_off = -1;
+    uint32_t commit_hash = -1;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    if (loc && loc->inode)
+        gf_uuid_unparse(loc->inode->gfid, gfid);
+
+    for (idx = 0; idx < layout->cnt; idx++) {
+        if (layout->list[idx].xlator == subvol) {
+            pos = idx;
+            break;
+        }
+    }
+
+    if (pos == -1) {
+        if (loc) {
+            gf_msg_debug(this->name, 0, "%s - no layout info for subvolume %s",
+                         loc ? loc->path : "path not found", subvol->name);
+        }
+        ret = 1;
+        goto out;
+    }
+
+    err = layout->list[pos].err;
+
+    if (!xattr) {
+        if (err == 0) {
+            if (loc) {
+                gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_XATTR_DICT_NULL,
+                        "path=%s", loc->path, NULL);
+            } else {
+                gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_XATTR_DICT_NULL,
+                        "path not found", NULL);
+            }
+            ret = -1;
+        }
+        goto out;
+    }
+
+    dict_ret = dict_get_ptr(xattr, conf->xattr_name, &disk_layout_raw);
+
+    if (dict_ret < 0) {
+        if (err == 0 && layout->list[pos].stop) {
+            if (loc) {
+                gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_DISK_LAYOUT_MISSING,
+                        "path=%s", loc->path, "gfid=%s", gfid, NULL);
+            } else {
+                gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_DISK_LAYOUT_MISSING,
+                        "path not found"
+                        "gfid=%s",
+                        gfid, NULL);
+            }
+            ret = -1;
+        }
+        goto out;
+    }
+
+    memcpy(disk_layout, disk_layout_raw, sizeof(disk_layout));
+
+    start_off = ntoh32(disk_layout[2]);
+    stop_off = ntoh32(disk_layout[3]);
+    commit_hash = ntoh32(disk_layout[0]);
+
+    if ((layout->list[pos].start != start_off) ||
+        (layout->list[pos].stop != stop_off) ||
+        (layout->list[pos].commit_hash != commit_hash)) {
+        gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_INFO, "subvol=%s",
+                layout->list[pos].xlator->name, "inode-layout:start=0x%x",
+                layout->list[pos].start, "inode-layout:stop=0x%x",
+                layout->list[pos].stop, "layout-commit-hash=0x%x; ",
+                layout->list[pos].commit_hash, "disk-layout:start-off=0x%x",
+                start_off, "disk-layout:top-off=0x%x", stop_off,
+                "commit-hash=0x%x", commit_hash, NULL);
+        ret = 1;
+    } else {
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_layout_preset (xlator_t *this, xlator_t *subvol, inode_t *inode)
+dht_layout_preset(xlator_t *this, xlator_t *subvol, inode_t *inode)
 {
-        dht_layout_t *layout = NULL;
-        int           ret = -1;
-        dht_conf_t   *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
+    layout = dht_layout_for_subvol(this, subvol);
+    if (!layout) {
+        gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_NO_LAYOUT_INFO,
+                "subvolume=%s", subvol ? subvol->name : "<nil>", NULL);
+        ret = -1;
+        goto out;
+    }
 
-        layout = dht_layout_for_subvol (this, subvol);
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_NO_LAYOUT_INFO,
-                        "no pre-set layout for subvolume %s",
-                        subvol ? subvol->name : "<nil>");
-                ret = -1;
-                goto out;
-        }
+    gf_msg_debug(this->name, 0, "file = %s, subvol = %s",
+                 uuid_utoa(inode->gfid), subvol ? subvol->name : "<nil>");
 
-        gf_msg_debug (this->name, 0, "file = %s, subvol = %s",
-                      uuid_utoa (inode->gfid), subvol ? subvol->name : "<nil>");
+    LOCK(&conf->layout_lock);
+    {
+        dht_inode_ctx_layout_set(inode, this, layout);
+    }
 
-        LOCK (&conf->layout_lock);
-        {
-                dht_inode_ctx_layout_set (inode, this, layout);
-        }
+    UNLOCK(&conf->layout_lock);
 
-        UNLOCK (&conf->layout_lock);
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_layout_index_for_subvol (dht_layout_t *layout, xlator_t *subvol)
+dht_layout_index_for_subvol(dht_layout_t *layout, xlator_t *subvol)
 {
-        int i = 0, ret = -1;
+    int i = 0, ret = -1;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol) {
-                        ret = i;
-                        break;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol) {
+            ret = i;
+            break;
         }
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-linkfile.c b/xlators/cluster/dht/src/dht-linkfile.c
index 101d93915b9..89ec6cca56e 100644
--- a/xlators/cluster/dht/src/dht-linkfile.c
+++ b/xlators/cluster/dht/src/dht-linkfile.c
@@ -8,351 +8,321 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "glusterfs.h"
-#include "xlator.h"
-#include "compat.h"
+#include <glusterfs/compat.h>
 #include "dht-common.h"
-#include "dht-messages.h"
 
-int
-dht_linkfile_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno,
-                         inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                         struct iatt *postparent)
+static int
+dht_linkfile_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, dict_t *xattr,
+                        struct iatt *postparent)
 {
-        char          is_linkfile   = 0;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        xlator_t     *prev          = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        if (op_ret)
-                goto out;
-
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
-        if (!is_linkfile)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NOT_LINK_FILE_ERROR,
-                        "got non-linkfile %s:%s, gfid = %s",
-                        prev->name, local->loc.path, gfid);
+    char is_linkfile = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    if (op_ret)
+        goto out;
+
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
+    if (!is_linkfile)
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NOT_LINK_FILE_ERROR,
+                "name=%s", prev->name, "path=%s", local->loc.path, "gfid=%s",
+                gfid, NULL);
 out:
-        local->linkfile.linkfile_cbk (frame, cookie, this, op_ret, op_errno,
-                                      inode, stbuf, postparent, postparent,
-                                      xattr);
-        return 0;
+    local->linkfile.linkfile_cbk(frame, cookie, this, op_ret, op_errno, inode,
+                                 stbuf, postparent, postparent, xattr);
+    return 0;
 }
 
-#define is_equal(a, b) ((a) == (b))
-int
-dht_linkfile_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, inode_t *inode,
-                         struct iatt *stbuf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+static int
+dht_linkfile_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *subvol = NULL;
-        dict_t       *xattrs = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-
-        local = frame->local;
-
-        if (!op_ret)
-                local->linked = _gf_true;
-
-        FRAME_SU_UNDO (frame, dht_local_t);
-
-        if (op_ret && (op_errno == EEXIST)) {
-                conf = this->private;
-                subvol = cookie;
-                if (!subvol)
-                        goto out;
-                xattrs = dict_new ();
-                if (!xattrs)
-                        goto out;
-                ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value. key : %s",
-                                conf->link_xattr_name);
-                        goto out;
-                }
-
-                STACK_WIND_COOKIE (frame, dht_linkfile_lookup_cbk, subvol,
-                                   subvol, subvol->fops->lookup, &local->linkfile.loc,
-                                   xattrs);
-                if (xattrs)
-                        dict_unref (xattrs);
-                return 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    dict_t *xattrs = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+
+    local = frame->local;
+
+    if (!op_ret)
+        local->linked = _gf_true;
+
+    FRAME_SU_UNDO(frame, dht_local_t);
+
+    if (op_ret && (op_errno == EEXIST)) {
+        conf = this->private;
+        subvol = cookie;
+        if (!subvol)
+            goto out;
+        xattrs = dict_new();
+        if (!xattrs)
+            goto out;
+        ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                    "mame=%s", conf->link_xattr_name, NULL);
+            goto out;
         }
-out:
-        local->linkfile.linkfile_cbk (frame, cookie, this, op_ret, op_errno,
-                                      inode, stbuf, preparent, postparent,
-                                      xdata);
+
+        STACK_WIND_COOKIE(frame, dht_linkfile_lookup_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->linkfile.loc, xattrs);
         if (xattrs)
-                dict_unref (xattrs);
+            dict_unref(xattrs);
         return 0;
+    }
+out:
+    local->linkfile.linkfile_cbk(frame, cookie, this, op_ret, op_errno, inode,
+                                 stbuf, preparent, postparent, xdata);
+    if (xattrs)
+        dict_unref(xattrs);
+    return 0;
 }
 
-
 int
-dht_linkfile_create (call_frame_t *frame, fop_mknod_cbk_t linkfile_cbk,
-                     xlator_t *this,
-                     xlator_t *tovol, xlator_t *fromvol, loc_t *loc)
+dht_linkfile_create(call_frame_t *frame, fop_mknod_cbk_t linkfile_cbk,
+                    xlator_t *this, xlator_t *tovol, xlator_t *fromvol,
+                    loc_t *loc)
 {
-        dht_local_t *local = NULL;
-        dict_t      *dict = NULL;
-        int          need_unref = 0;
-        int          ret = 0;
-        dht_conf_t  *conf = this->private;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        local->linkfile.linkfile_cbk = linkfile_cbk;
-        local->linkfile.srcvol = tovol;
-        loc_copy (&local->linkfile.loc, loc);
-
-        local->linked = _gf_false;
-
-        dict = local->params;
-        if (!dict) {
-                dict = dict_new ();
-                if (!dict)
-                        goto out;
-                need_unref = 1;
-        }
-
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                gf_uuid_unparse(local->gfid, gfid);
-
-                ret = dict_set_static_bin (dict, "gfid-req", local->gfid, 16);
-                if (ret)
-                        gf_msg ("dht-linkfile", GF_LOG_INFO, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value: "
-                                "key = gfid-req, gfid = %s ", loc->path, gfid);
-        } else {
-                gf_uuid_unparse(loc->gfid, gfid);
-        }
-
-        ret = dict_set_str (dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    int need_unref = 0;
+    int ret = 0;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    local->linkfile.linkfile_cbk = linkfile_cbk;
+    local->linkfile.srcvol = tovol;
+    loc_copy(&local->linkfile.loc, loc);
+
+    local->linked = _gf_false;
+
+    dict = local->params;
+    if (!dict) {
+        dict = dict_new();
+        if (!dict)
+            goto out;
+        need_unref = 1;
+    }
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid);
+
+        ret = dict_set_gfuuid(dict, "gfid-req", local->gfid, true);
         if (ret)
-                gf_msg ("dht-linkfile", GF_LOG_INFO, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        GLUSTERFS_INTERNAL_FOP_KEY, gfid);
-
-        ret = dict_set_str (dict, conf->link_xattr_name, tovol->name);
-
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_CREATE_LINK_FAILED,
-                        "%s: failed to initialize linkfile data, gfid = %s",
-                        loc->path, gfid);
-                goto out;
-        }
-
-        local->link_subvol = fromvol;
-        /* Always create as root:root. dht_linkfile_attr_heal fixes the
-         * ownsership */
-        FRAME_SU_DO (frame, dht_local_t);
-        STACK_WIND_COOKIE (frame, dht_linkfile_create_cbk, fromvol, fromvol,
-                           fromvol->fops->mknod, loc,
-                           S_IFREG | DHT_LINKFILE_MODE, 0, 0, dict);
-
-        if (need_unref && dict)
-                dict_unref (dict);
-
-        return 0;
+            gf_smsg("dht-linkfile", GF_LOG_INFO, 0, DHT_MSG_DICT_SET_FAILED,
+                    "path=%s", loc->path, "gfid=%s", gfid, NULL);
+    } else {
+        gf_uuid_unparse(loc->gfid, gfid);
+    }
+
+    ret = dict_set_str(dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    if (ret)
+        gf_smsg("dht-linkfile", GF_LOG_INFO, 0, DHT_MSG_DICT_SET_FAILED,
+                "path=%s", loc->path, "key=%s", GLUSTERFS_INTERNAL_FOP_KEY,
+                "gfid=%s", gfid, NULL);
+
+    ret = dict_set_str(dict, conf->link_xattr_name, tovol->name);
+
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_INFO, 0, DHT_MSG_CREATE_LINK_FAILED,
+                "path=%s", loc->path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+
+    local->link_subvol = fromvol;
+    /* Always create as root:root. dht_linkfile_attr_heal fixes the
+     * ownsership */
+    FRAME_SU_DO(frame, dht_local_t);
+    STACK_WIND_COOKIE(frame, dht_linkfile_create_cbk, fromvol, fromvol,
+                      fromvol->fops->mknod, loc, S_IFREG | DHT_LINKFILE_MODE, 0,
+                      0, dict);
+
+    if (need_unref && dict)
+        dict_unref(dict);
+
+    return 0;
 out:
-        local->linkfile.linkfile_cbk (frame, frame->this, frame->this, -1, ENOMEM,
-                                      loc->inode, NULL, NULL, NULL, NULL);
+    local->linkfile.linkfile_cbk(frame, frame->this, frame->this, -1, ENOMEM,
+                                 loc->inode, NULL, NULL, NULL, NULL);
 
-        if (need_unref && dict)
-                dict_unref (dict);
+    if (need_unref && dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_linkfile_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno,
-                         struct iatt *preparent, struct iatt *postparent,
-                         dict_t *xdata)
+dht_linkfile_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        struct iatt *preparent, struct iatt *postparent,
+                        dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        xlator_t      *subvol = NULL;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        subvol = cookie;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
+    local = frame->local;
+    subvol = cookie;
 
-        if (op_ret == -1) {
-
-                gf_uuid_unparse(local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_UNLINK_FAILED,
-                        "Unlinking linkfile %s (gfid = %s)on "
-                        "subvolume %s failed ",
-                        local->loc.path, gfid, subvol->name);
-        }
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_smsg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_UNLINK_FAILED,
+                "path=%s", local->loc.path, "gfid=%s", gfid, "subvolume=%s",
+                subvol->name, NULL);
+    }
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_linkfile_unlink (call_frame_t *frame, xlator_t *this,
-                     xlator_t *subvol, loc_t *loc)
+dht_linkfile_unlink(call_frame_t *frame, xlator_t *this, xlator_t *subvol,
+                    loc_t *loc)
 {
-        call_frame_t *unlink_frame = NULL;
-        dht_local_t  *unlink_local = NULL;
+    call_frame_t *unlink_frame = NULL;
+    dht_local_t *unlink_local = NULL;
 
-        unlink_frame = copy_frame (frame);
-        if (!unlink_frame) {
-                goto err;
-        }
+    unlink_frame = copy_frame(frame);
+    if (!unlink_frame) {
+        goto err;
+    }
 
-        /* Using non-fop value here, as anyways, 'local->fop' is not used in
-           this particular case */
-        unlink_local = dht_local_init (unlink_frame, loc, NULL,
-                                       GF_FOP_MAXVALUE);
-        if (!unlink_local) {
-                goto err;
-        }
+    /* Using non-fop value here, as anyways, 'local->fop' is not used in
+       this particular case */
+    unlink_local = dht_local_init(unlink_frame, loc, NULL, GF_FOP_MAXVALUE);
+    if (!unlink_local) {
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (unlink_frame, dht_linkfile_unlink_cbk, subvol,
-                           subvol, subvol->fops->unlink,
-                           &unlink_local->loc, 0, NULL);
+    STACK_WIND_COOKIE(unlink_frame, dht_linkfile_unlink_cbk, subvol, subvol,
+                      subvol->fops->unlink, &unlink_local->loc, 0, NULL);
 
-        return 0;
+    return 0;
 err:
-        if (unlink_frame)
-                DHT_STACK_DESTROY (unlink_frame);
+    if (unlink_frame)
+        DHT_STACK_DESTROY(unlink_frame);
 
-        return -1;
+    return -1;
 }
 
-
 xlator_t *
-dht_linkfile_subvol (xlator_t *this, inode_t *inode, struct iatt *stbuf,
-                     dict_t *xattr)
+dht_linkfile_subvol(xlator_t *this, inode_t *inode, struct iatt *stbuf,
+                    dict_t *xattr)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *subvol = NULL;
-        void       *volname = NULL;
-        int         i = 0, ret = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    void *volname = NULL;
+    int i = 0, ret = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!xattr)
-                goto out;
+    if (!xattr)
+        goto out;
 
-        ret = dict_get_ptr (xattr, conf->link_xattr_name, &volname);
+    ret = dict_get_ptr(xattr, conf->link_xattr_name, &volname);
 
-        if ((-1 == ret) || !volname)
-                goto out;
+    if ((-1 == ret) || !volname)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (strcmp (conf->subvolumes[i]->name, (char *)volname) == 0) {
-                        subvol = conf->subvolumes[i];
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (strcmp(conf->subvolumes[i]->name, (char *)volname) == 0) {
+            subvol = conf->subvolumes[i];
+            break;
         }
+    }
 
 out:
-        return subvol;
+    return subvol;
 }
 
-int
-dht_linkfile_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, struct iatt *statpre,
-                          struct iatt *statpost, dict_t *xdata)
+static int
+dht_linkfile_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, struct iatt *statpre,
+                         struct iatt *statpost, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        loc_t *loc = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
 
-        local = frame->local;
-        loc = &local->loc;
+    local = frame->local;
+    loc = &local->loc;
 
-        if (op_ret)
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_SETATTR_FAILED,
-                        "Failed to set attr uid/gid on %s"
-                        " :<gfid:%s> ",
-                        (loc->path? loc->path: "NULL"),
-                        uuid_utoa(local->gfid));
+    if (op_ret)
+        gf_smsg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_SETATTR_FAILED,
+                "path=%s", (loc->path ? loc->path : "NULL"), "gfid=%s",
+                uuid_utoa(local->gfid), NULL);
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-       return 0;
+    return 0;
 }
 
 int
-dht_linkfile_attr_heal (call_frame_t *frame, xlator_t *this)
+dht_linkfile_attr_heal(call_frame_t *frame, xlator_t *this)
 {
-        int           ret         = -1;
-        call_frame_t  *copy       = NULL;
-        dht_local_t   *local      = NULL;
-        dht_local_t   *copy_local = NULL;
-        xlator_t      *subvol     = NULL;
-        struct iatt   stbuf       = {0,};
-        dict_t        *xattr      = NULL;
-
-        local = frame->local;
-
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        GF_VALIDATE_OR_GOTO ("dht", local->link_subvol, out);
-
-        if (local->stbuf.ia_type == IA_INVAL)
-                return 0;
+    int ret = -1;
+    call_frame_t *copy = NULL;
+    dht_local_t *local = NULL;
+    dht_local_t *copy_local = NULL;
+    xlator_t *subvol = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    local = frame->local;
+
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    GF_VALIDATE_OR_GOTO("dht", local->link_subvol, out);
+
+    if (local->stbuf.ia_type == IA_INVAL)
+        return 0;
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    DHT_MARK_FOP_INTERNAL(xattr);
 
-        gf_uuid_copy (local->loc.gfid, local->stbuf.ia_gfid);
+    gf_uuid_copy(local->loc.gfid, local->stbuf.ia_gfid);
 
-        copy = copy_frame (frame);
+    copy = copy_frame(frame);
 
-        if (!copy)
-                goto out;
+    if (!copy)
+        goto out;
 
-       copy_local = dht_local_init (copy, &local->loc, NULL, 0);
+    copy_local = dht_local_init(copy, &local->loc, NULL, 0);
 
-       if (!copy_local)
-               goto out;
+    if (!copy_local)
+        goto out;
 
-        stbuf = local->stbuf;
-        subvol = local->link_subvol;
+    stbuf = local->stbuf;
+    subvol = local->link_subvol;
 
-        copy->local = copy_local;
+    copy->local = copy_local;
 
-        FRAME_SU_DO (copy, dht_local_t);
+    FRAME_SU_DO(copy, dht_local_t);
 
-        STACK_WIND (copy, dht_linkfile_setattr_cbk, subvol,
-                    subvol->fops->setattr, &copy_local->loc,
-                    &stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID), xattr);
-        ret = 0;
+    STACK_WIND(copy, dht_linkfile_setattr_cbk, subvol, subvol->fops->setattr,
+               &copy_local->loc, &stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
+               xattr);
+    ret = 0;
 out:
-        if ((ret < 0) && (copy))
-                DHT_STACK_DESTROY (copy);
+    if ((ret < 0) && (copy))
+        DHT_STACK_DESTROY(copy);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-lock.c b/xlators/cluster/dht/src/dht-lock.c
index 45ebeec99e8..638821ccee5 100644
--- a/xlators/cluster/dht/src/dht-lock.c
+++ b/xlators/cluster/dht/src/dht-lock.c
@@ -11,1236 +11,1250 @@
 #include "dht-lock.h"
 
 static char *
-dht_lock_asprintf (dht_lock_t *lock)
+dht_lock_asprintf(dht_lock_t *lock)
 {
-        char *lk_buf                = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0, };
+    char *lk_buf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
 
-        if (lock == NULL)
-                goto out;
+    if (lock == NULL)
+        goto out;
 
-        uuid_utoa_r (lock->loc.gfid, gfid);
+    uuid_utoa_r(lock->loc.gfid, gfid);
 
-        gf_asprintf (&lk_buf, "%s:%s", lock->xl->name, gfid);
+    gf_asprintf(&lk_buf, "%s:%s", lock->xl->name, gfid);
 
 out:
-        return lk_buf;
+    return lk_buf;
 }
 
 static void
-dht_log_lk_array (char *name, gf_loglevel_t log_level, dht_lock_t **lk_array,
-                  int count)
+dht_log_lk_array(char *name, gf_loglevel_t log_level, dht_lock_t **lk_array,
+                 int count)
 {
-        int   i      = 0;
-        char *lk_buf = NULL;
+    int i = 0;
+    char *lk_buf = NULL;
 
-        if ((lk_array == NULL) || (count == 0))
-                goto out;
+    if ((lk_array == NULL) || (count == 0))
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lk_buf = dht_lock_asprintf (lk_array[i]);
-                if (!lk_buf)
-                        goto out;
+    for (i = 0; i < count; i++) {
+        lk_buf = dht_lock_asprintf(lk_array[i]);
+        if (!lk_buf)
+            goto out;
 
-                gf_msg (name, log_level, 0, DHT_MSG_LK_ARRAY_INFO,
-                        "%d. %s", i, lk_buf);
-                GF_FREE (lk_buf);
-        }
+        gf_smsg(name, log_level, 0, DHT_MSG_LK_ARRAY_INFO, "index=%d", i,
+                "lk_buf=%s", lk_buf, NULL);
+        GF_FREE(lk_buf);
+    }
 
 out:
-        return;
+    return;
 }
 
 static void
-dht_lock_stack_destroy (call_frame_t *lock_frame, dht_lock_type_t lk)
+dht_lock_stack_destroy(call_frame_t *lock_frame, dht_lock_type_t lk)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        if (lk == DHT_INODELK) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-        } else {
-                local->lock[0].ns.directory_ns.locks = NULL;
-                local->lock[0].ns.directory_ns.lk_count = 0;
-        }
+    if (lk == DHT_INODELK) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+    } else {
+        local->lock[0].ns.directory_ns.locks = NULL;
+        local->lock[0].ns.directory_ns.lk_count = 0;
+    }
 
-        DHT_STACK_DESTROY (lock_frame);
-        return;
+    DHT_STACK_DESTROY(lock_frame);
+    return;
 }
 
 static void
-dht_lock_free (dht_lock_t *lock)
+dht_lock_free(dht_lock_t *lock)
 {
-        if (lock == NULL)
-                goto out;
+    if (lock == NULL)
+        goto out;
 
-        loc_wipe (&lock->loc);
-        GF_FREE (lock->domain);
-        GF_FREE (lock->basename);
-        mem_put (lock);
+    loc_wipe(&lock->loc);
+    GF_FREE(lock->domain);
+    GF_FREE(lock->basename);
+    mem_put(lock);
 
 out:
-        return;
+    return;
 }
 
 static void
-dht_set_lkowner (dht_lock_t **lk_array, int count, gf_lkowner_t *lkowner)
+dht_set_lkowner(dht_lock_t **lk_array, int count, gf_lkowner_t *lkowner)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!lk_array || !lkowner)
-                goto out;
+    if (!lk_array || !lkowner)
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lk_array[i]->lk_owner = *lkowner;
-        }
+    for (i = 0; i < count; i++) {
+        lk_array[i]->lk_owner = *lkowner;
+    }
 
 out:
-        return;
+    return;
 }
 
 static int
-dht_lock_request_cmp (const void *val1, const void *val2)
+dht_lock_request_cmp(const void *val1, const void *val2)
 {
-        dht_lock_t *lock1 = NULL;
-        dht_lock_t *lock2 = NULL;
-        int         ret   = -1;
+    dht_lock_t *lock1 = NULL;
+    dht_lock_t *lock2 = NULL;
+    int ret = -1;
 
-        lock1 = *(dht_lock_t **)val1;
-        lock2 = *(dht_lock_t **)val2;
+    lock1 = *(dht_lock_t **)val1;
+    lock2 = *(dht_lock_t **)val2;
 
-        GF_VALIDATE_OR_GOTO ("dht-locks", lock1, out);
-        GF_VALIDATE_OR_GOTO ("dht-locks", lock2, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", lock1, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", lock2, out);
 
-        ret = strcmp (lock1->xl->name, lock2->xl->name);
+    ret = strcmp(lock1->xl->name, lock2->xl->name);
 
-        if (ret == 0) {
-                ret = gf_uuid_compare (lock1->loc.gfid, lock2->loc.gfid);
-        }
+    if (ret == 0) {
+        ret = gf_uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-dht_lock_order_requests (dht_lock_t **locks, int count)
+dht_lock_order_requests(dht_lock_t **locks, int count)
 {
-        int        ret     = -1;
+    int ret = -1;
 
-        if (!locks || !count)
-                goto out;
+    if (!locks || !count)
+        goto out;
 
-        qsort (locks, count, sizeof (*locks), dht_lock_request_cmp);
-        ret = 0;
+    qsort(locks, count, sizeof(*locks), dht_lock_request_cmp);
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-dht_lock_array_free (dht_lock_t **lk_array, int count)
+dht_lock_array_free(dht_lock_t **lk_array, int count)
 {
-        int            i       = 0;
-        dht_lock_t    *lock    = NULL;
+    int i = 0;
+    dht_lock_t *lock = NULL;
 
-        if (lk_array == NULL)
-                goto out;
+    if (lk_array == NULL)
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lock = lk_array[i];
-                lk_array[i] = NULL;
-                dht_lock_free (lock);
-        }
+    for (i = 0; i < count; i++) {
+        lock = lk_array[i];
+        lk_array[i] = NULL;
+        dht_lock_free(lock);
+    }
 
 out:
-        return;
+    return;
 }
 
 int32_t
-dht_lock_count (dht_lock_t **lk_array, int lk_count)
+dht_lock_count(dht_lock_t **lk_array, int lk_count)
 {
-        int i = 0, locked = 0;
+    int i = 0, locked = 0;
 
-        if ((lk_array == NULL) || (lk_count == 0))
-                goto out;
+    if ((lk_array == NULL) || (lk_count == 0))
+        goto out;
 
-        for (i = 0; i < lk_count; i++) {
-                if (lk_array[i]->locked)
-                        locked++;
-        }
+    for (i = 0; i < lk_count; i++) {
+        if (lk_array[i]->locked)
+            locked++;
+    }
 out:
-        return locked;
+    return locked;
 }
 
 static call_frame_t *
-dht_lock_frame (call_frame_t *parent_frame)
+dht_lock_frame(call_frame_t *parent_frame)
 {
-        call_frame_t *lock_frame = NULL;
+    call_frame_t *lock_frame = NULL;
 
-        lock_frame = copy_frame (parent_frame);
-        if (lock_frame == NULL)
-                goto out;
+    lock_frame = copy_frame(parent_frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        set_lk_owner_from_ptr (&lock_frame->root->lk_owner, parent_frame->root);
+    set_lk_owner_from_ptr(&lock_frame->root->lk_owner, parent_frame->root);
 
 out:
-        return lock_frame;
+    return lock_frame;
 }
 
 dht_lock_t *
-dht_lock_new (xlator_t *this, xlator_t *xl, loc_t *loc, short type,
-              const char *domain, const char *basename)
+dht_lock_new(xlator_t *this, xlator_t *xl, loc_t *loc, short type,
+             const char *domain, const char *basename,
+             dht_reaction_type_t do_on_failure)
 {
-        dht_conf_t *conf = NULL;
-        dht_lock_t *lock = NULL;
-
-        conf = this->private;
-
-        lock = mem_get0 (conf->lock_pool);
-        if (lock == NULL)
-                goto out;
-
-        lock->xl = xl;
-        lock->type = type;
-
-        lock->domain = gf_strdup (domain);
-        if (lock->domain == NULL) {
-                dht_lock_free (lock);
-                lock = NULL;
-                goto out;
-        }
-
-        if (basename) {
-                lock->basename = gf_strdup (basename);
-                if (lock->basename == NULL) {
-                        dht_lock_free (lock);
-                        lock = NULL;
-                        goto out;
-                }
+    dht_conf_t *conf = NULL;
+    dht_lock_t *lock = NULL;
+
+    conf = this->private;
+
+    lock = mem_get0(conf->lock_pool);
+    if (lock == NULL)
+        goto out;
+
+    lock->xl = xl;
+    lock->type = type;
+    lock->do_on_failure = do_on_failure;
+
+    lock->domain = gf_strdup(domain);
+    if (lock->domain == NULL) {
+        dht_lock_free(lock);
+        lock = NULL;
+        goto out;
+    }
+
+    if (basename) {
+        lock->basename = gf_strdup(basename);
+        if (lock->basename == NULL) {
+            dht_lock_free(lock);
+            lock = NULL;
+            goto out;
         }
-
-        /* Fill only inode and gfid.
-           posix and protocol/server give preference to pargfid/basename over
-           gfid/inode for resolution if all the three parameters of loc_t are
-           present. I want to avoid the following hypothetical situation:
-
-           1. rebalance did a lookup on a dentry and got a gfid.
-           2. rebalance acquires lock on loc_t which was filled with gfid and
-              path (pargfid/bname) from step 1.
-           3. somebody deleted and recreated the same file
-           4. rename on the same path acquires lock on loc_t which now points
-              to a different inode (and hence gets the lock).
-           5. rebalance continues to migrate file (note that not all fops done
-              by rebalance during migration are inode/gfid based Eg., unlink)
-           6. rename continues.
-        */
-        lock->loc.inode = inode_ref (loc->inode);
-        loc_gfid (loc, lock->loc.gfid);
+    }
+
+    /* Fill only inode and gfid.
+       posix and protocol/server give preference to pargfid/basename over
+       gfid/inode for resolution if all the three parameters of loc_t are
+       present. I want to avoid the following hypothetical situation:
+
+       1. rebalance did a lookup on a dentry and got a gfid.
+       2. rebalance acquires lock on loc_t which was filled with gfid and
+          path (pargfid/bname) from step 1.
+       3. somebody deleted and recreated the same file
+       4. rename on the same path acquires lock on loc_t which now points
+          to a different inode (and hence gets the lock).
+       5. rebalance continues to migrate file (note that not all fops done
+          by rebalance during migration are inode/gfid based Eg., unlink)
+       6. rename continues.
+    */
+    lock->loc.inode = inode_ref(loc->inode);
+    loc_gfid(loc, lock->loc.gfid);
 
 out:
-        return lock;
+    return lock;
 }
 
 static int
-dht_local_entrylk_init (call_frame_t *frame, dht_lock_t **lk_array,
-                     int lk_count, fop_entrylk_cbk_t entrylk_cbk)
+dht_local_entrylk_init(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                       fop_entrylk_cbk_t entrylk_cbk)
 {
-        int          ret   = -1;
-        dht_local_t *local = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local == NULL) {
-                local = dht_local_init (frame, NULL, NULL, 0);
-        }
+    if (local == NULL) {
+        local = dht_local_init(frame, NULL, NULL, 0);
+    }
 
-        if (local == NULL) {
-                goto out;
-        }
+    if (local == NULL) {
+        goto out;
+    }
 
-        local->lock[0].ns.directory_ns.entrylk_cbk = entrylk_cbk;
-        local->lock[0].ns.directory_ns.locks = lk_array;
-        local->lock[0].ns.directory_ns.lk_count = lk_count;
+    local->lock[0].ns.directory_ns.entrylk_cbk = entrylk_cbk;
+    local->lock[0].ns.directory_ns.locks = lk_array;
+    local->lock[0].ns.directory_ns.lk_count = lk_count;
 
-        ret = dht_lock_order_requests (local->lock[0].ns.directory_ns.locks,
-                                       local->lock[0].ns.directory_ns.lk_count);
-        if (ret < 0)
-                goto out;
+    ret = dht_lock_order_requests(local->lock[0].ns.directory_ns.locks,
+                                  local->lock[0].ns.directory_ns.lk_count);
+    if (ret < 0)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-dht_entrylk_done (call_frame_t *lock_frame)
+dht_entrylk_done(call_frame_t *lock_frame)
 {
-        fop_entrylk_cbk_t  entrylk_cbk = NULL;
-        call_frame_t      *main_frame  = NULL;
-        dht_local_t       *local       = NULL;
+    fop_entrylk_cbk_t entrylk_cbk = NULL;
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
-        main_frame = local->main_frame;
+    local = lock_frame->local;
+    main_frame = local->main_frame;
 
-        local->lock[0].ns.directory_ns.locks = NULL;
-        local->lock[0].ns.directory_ns.lk_count = 0;
+    local->lock[0].ns.directory_ns.locks = NULL;
+    local->lock[0].ns.directory_ns.lk_count = 0;
 
-        entrylk_cbk = local->lock[0].ns.directory_ns.entrylk_cbk;
-        local->lock[0].ns.directory_ns.entrylk_cbk = NULL;
+    entrylk_cbk = local->lock[0].ns.directory_ns.entrylk_cbk;
+    local->lock[0].ns.directory_ns.entrylk_cbk = NULL;
 
-        entrylk_cbk (main_frame, NULL, main_frame->this,
-                     local->lock[0].ns.directory_ns.op_ret,
-                     local->lock[0].ns.directory_ns.op_errno, NULL);
+    entrylk_cbk(main_frame, NULL, main_frame->this,
+                local->lock[0].ns.directory_ns.op_ret,
+                local->lock[0].ns.directory_ns.op_errno, NULL);
 
-        dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
-        return;
+    dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
+    return;
 }
 
 static int32_t
-dht_unlock_entrylk_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_entrylk_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        gf_uuid_unparse (local->lock[0].ns.directory_ns.locks[0]->loc.inode->gfid, gfid);
+    local = frame->local;
+    gf_uuid_unparse(local->lock[0].ns.directory_ns.locks[0]->loc.inode->gfid,
+                    gfid);
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "unlock failed on gfid: %s, stale lock might be left "
-                        "in DHT_LAYOUT_HEAL_DOMAIN", gfid);
-        }
+    if (op_ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, op_errno,
+                DHT_MSG_UNLOCK_GFID_FAILED, "gfid=%s", gfid,
+                "DHT_LAYOUT_HEAL_DOMAIN", NULL);
+    }
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 static int32_t
-dht_unlock_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                  = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        lk_index = (long) cookie;
+    lk_index = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        uuid_utoa_r (local->lock[0].ns.directory_ns.locks[lk_index]->loc.gfid, gfid);
+    uuid_utoa_r(local->lock[0].ns.directory_ns.locks[lk_index]->loc.gfid, gfid);
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "unlocking failed on %s:%s",
-                        local->lock[0].ns.directory_ns.locks[lk_index]->xl->name,
-                        gfid);
-        } else {
-                local->lock[0].ns.directory_ns.locks[lk_index]->locked = 0;
-        }
+    if (op_ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLOCKING_FAILED,
+                "name=%s",
+                local->lock[0].ns.directory_ns.locks[lk_index]->xl->name,
+                "gfid=%s", gfid, NULL);
+    } else {
+        local->lock[0].ns.directory_ns.locks[lk_index]->locked = 0;
+    }
 
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                dht_entrylk_done (frame);
-        }
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        dht_entrylk_done(frame);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-dht_unlock_entrylk (call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
-                     fop_entrylk_cbk_t entrylk_cbk)
+dht_unlock_entrylk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                   fop_entrylk_cbk_t entrylk_cbk)
 {
-        dht_local_t     *local      = NULL;
-        int              ret        = -1 , i = 0;
-        call_frame_t    *lock_frame = NULL;
-        int              call_cnt   = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, entrylk_cbk, done);
-
-        call_cnt = dht_lock_count (lk_array, lk_count);
-        if (call_cnt == 0) {
-                ret = 0;
-                goto done;
-        }
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "cannot allocate a frame, not unlocking following "
-                        "entrylks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-                goto done;
-        }
+    dht_local_t *local = NULL;
+    int ret = -1, i = 0;
+    call_frame_t *lock_frame = NULL;
+    int call_cnt = 0;
 
-        ret = dht_local_entrylk_init (lock_frame, lk_array, lk_count,
-                                      entrylk_cbk);
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "storing locks in local failed, not unlocking "
-                        "following entrylks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-
-                goto done;
-        }
-
-        local = lock_frame->local;
-        local->main_frame = frame;
-        local->call_cnt = call_cnt;
-
-        for (i = 0; i < local->lock[0].ns.directory_ns.lk_count; i++) {
-                if (!local->lock[0].ns.directory_ns.locks[i]->locked)
-                        continue;
-
-                lock_frame->root->lk_owner = local->lock[0].ns.directory_ns.locks[i]->lk_owner;
-                STACK_WIND_COOKIE (lock_frame, dht_unlock_entrylk_cbk,
-                                   (void *)(long)i,
-                                   local->lock[0].ns.directory_ns.locks[i]->xl,
-                                   local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
-                                   local->lock[0].ns.directory_ns.locks[i]->domain,
-                                   &local->lock[0].ns.directory_ns.locks[i]->loc,
-                                   local->lock[0].ns.directory_ns.locks[i]->basename,
-                                   ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
-                if (!--call_cnt)
-                        break;
-        }
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, entrylk_cbk, done);
 
-        return 0;
+    call_cnt = dht_lock_count(lk_array, lk_count);
+    if (call_cnt == 0) {
+        ret = 0;
+        goto done;
+    }
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_ALLOC_FRAME_FAILED_NOT_UNLOCKING_FOLLOWING_ENTRYLKS,
+                NULL);
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+        goto done;
+    }
+
+    ret = dht_local_entrylk_init(lock_frame, lk_array, lk_count, entrylk_cbk);
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_LOCAL_LOCKS_STORE_FAILED_UNLOCKING_FOLLOWING_ENTRYLK,
+                NULL);
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+
+        goto done;
+    }
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+    local->call_cnt = call_cnt;
+
+    for (i = 0; i < local->lock[0].ns.directory_ns.lk_count; i++) {
+        if (!local->lock[0].ns.directory_ns.locks[i]->locked)
+            continue;
+
+        lock_frame->root
+            ->lk_owner = local->lock[0].ns.directory_ns.locks[i]->lk_owner;
+        STACK_WIND_COOKIE(
+            lock_frame, dht_unlock_entrylk_cbk, (void *)(long)i,
+            local->lock[0].ns.directory_ns.locks[i]->xl,
+            local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
+            local->lock[0].ns.directory_ns.locks[i]->domain,
+            &local->lock[0].ns.directory_ns.locks[i]->loc,
+            local->lock[0].ns.directory_ns.locks[i]->basename, ENTRYLK_UNLOCK,
+            ENTRYLK_WRLCK, NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 
 done:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
 
-        /* no locks acquired, invoke entrylk_cbk */
-        if (ret == 0)
-                entrylk_cbk (frame, NULL, frame->this, 0, 0, NULL);
+    /* no locks acquired, invoke entrylk_cbk */
+    if (ret == 0)
+        entrylk_cbk(frame, NULL, frame->this, 0, 0, NULL);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_unlock_entrylk_wrapper (call_frame_t *frame, dht_elock_wrap_t *entrylk)
+dht_unlock_entrylk_wrapper(call_frame_t *frame, dht_elock_wrap_t *entrylk)
 {
-        dht_local_t  *local                   = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame              = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int           ret                     = 0;
-
-        local = frame->local;
-
-        if (!entrylk || !entrylk->locks)
-                goto out;
-
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "copy frame failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
 
-        lock_local = dht_local_init (lock_frame, NULL, NULL, 0);
-        if (lock_local == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "local creation failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
+    local = frame->local;
 
-        lock_frame->local = lock_local;
+    if (!entrylk || !entrylk->locks)
+        goto out;
 
-        lock_local->lock[0].ns.directory_ns.locks = entrylk->locks;
-        lock_local->lock[0].ns.directory_ns.lk_count = entrylk->lk_count;
-        entrylk->locks = NULL;
-        entrylk->lk_count = 0;
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+                DHT_MSG_COPY_FRAME_FAILED, "pgfid=%s", pgfid, "name=%s",
+                local->loc.name, "path=%s", local->loc.path, NULL);
+        goto done;
+    }
 
-        ret = dht_unlock_entrylk (lock_frame,
-                                  lock_local->lock[0].ns.directory_ns.locks,
-                                  lock_local->lock[0].ns.directory_ns.lk_count,
-                                  dht_unlock_entrylk_done);
-        if (ret)
-                goto done;
+    lock_local = dht_local_init(lock_frame, NULL, NULL, 0);
+    if (lock_local == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+                DHT_MSG_CREATE_FAILED, "local", "pgfid=%s", pgfid, "name=%s",
+                local->loc.name, "path=%s", local->loc.path, NULL);
+        goto done;
+    }
 
-        lock_frame = NULL;
+    lock_frame->local = lock_local;
+
+    lock_local->lock[0].ns.directory_ns.locks = entrylk->locks;
+    lock_local->lock[0].ns.directory_ns.lk_count = entrylk->lk_count;
+    entrylk->locks = NULL;
+    entrylk->lk_count = 0;
+
+    ret = dht_unlock_entrylk(
+        lock_frame, lock_local->lock[0].ns.directory_ns.locks,
+        lock_local->lock[0].ns.directory_ns.lk_count, dht_unlock_entrylk_done);
+    if (ret)
+        goto done;
+
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 static int
-dht_entrylk_cleanup_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_entrylk_cleanup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_entrylk_done (frame);
-        return 0;
+    dht_entrylk_done(frame);
+    return 0;
 }
 
 static void
-dht_entrylk_cleanup (call_frame_t *lock_frame)
+dht_entrylk_cleanup(call_frame_t *lock_frame)
 {
-        dht_lock_t  **lk_array = NULL;
-        int           lk_count = 0, lk_acquired = 0;
-        dht_local_t  *local    = NULL;
+    dht_lock_t **lk_array = NULL;
+    int lk_count = 0, lk_acquired = 0;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        lk_array = local->lock[0].ns.directory_ns.locks;
-        lk_count = local->lock[0].ns.directory_ns.lk_count;
+    lk_array = local->lock[0].ns.directory_ns.locks;
+    lk_count = local->lock[0].ns.directory_ns.lk_count;
 
-        lk_acquired = dht_lock_count (lk_array, lk_count);
-        if (lk_acquired != 0) {
-                dht_unlock_entrylk (lock_frame, lk_array, lk_count,
-                                     dht_entrylk_cleanup_cbk);
-        } else {
-                dht_entrylk_done (lock_frame);
-        }
+    lk_acquired = dht_lock_count(lk_array, lk_count);
+    if (lk_acquired != 0) {
+        dht_unlock_entrylk(lock_frame, lk_array, lk_count,
+                           dht_entrylk_cleanup_cbk);
+    } else {
+        dht_entrylk_done(lock_frame);
+    }
 
-        return;
+    return;
 }
 
-
 static int32_t
-dht_blocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_blocking_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int          lk_index = 0;
-        int          i        = 0;
-        dht_local_t *local    = NULL;
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret == 0) {
-                local->lock[0].ns.directory_ns.locks[lk_index]->locked = _gf_true;
-        } else {
-                switch (op_errno) {
-                case ESTALE:
-                case ENOENT:
-                        if (local->lock[0].ns.directory_ns.reaction != IGNORE_ENOENT_ESTALE) {
-                                local->lock[0].ns.directory_ns.op_ret = -1;
-                                local->lock[0].ns.directory_ns.op_errno = op_errno;
-                                goto cleanup;
-                        }
-                        break;
-                default:
-                        local->lock[0].ns.directory_ns.op_ret = -1;
-                        local->lock[0].ns.directory_ns.op_errno = op_errno;
-                        goto cleanup;
+    int lk_index = 0;
+    int i = 0;
+    dht_local_t *local = NULL;
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret == 0) {
+        local->lock[0].ns.directory_ns.locks[lk_index]->locked = _gf_true;
+    } else {
+        switch (op_errno) {
+            case ESTALE:
+            case ENOENT:
+                if (local->lock[0]
+                        .ns.directory_ns.locks[lk_index]
+                        ->do_on_failure != IGNORE_ENOENT_ESTALE) {
+                    local->lock[0].ns.directory_ns.op_ret = -1;
+                    local->lock[0].ns.directory_ns.op_errno = op_errno;
+                    goto cleanup;
                 }
+                break;
+            default:
+                local->lock[0].ns.directory_ns.op_ret = -1;
+                local->lock[0].ns.directory_ns.op_errno = op_errno;
+                goto cleanup;
         }
+    }
 
-        if (lk_index == (local->lock[0].ns.directory_ns.lk_count - 1)) {
-                for (i = 0; (i < local->lock[0].ns.directory_ns.lk_count) &&
-                     (!local->lock[0].ns.directory_ns.locks[i]->locked); i++)
-                        ;
-
-                if (i == local->lock[0].ns.directory_ns.lk_count) {
-                        local->lock[0].ns.directory_ns.op_ret = -1;
-                        local->lock[0].ns.directory_ns.op_errno = op_errno;
-                }
+    if (lk_index == (local->lock[0].ns.directory_ns.lk_count - 1)) {
+        for (i = 0; (i < local->lock[0].ns.directory_ns.lk_count) &&
+                    (!local->lock[0].ns.directory_ns.locks[i]->locked);
+             i++)
+            ;
 
-                dht_entrylk_done (frame);
-        } else {
-                dht_blocking_entrylk_rec (frame, ++lk_index);
+        if (i == local->lock[0].ns.directory_ns.lk_count) {
+            local->lock[0].ns.directory_ns.op_ret = -1;
+            local->lock[0].ns.directory_ns.op_errno = op_errno;
         }
 
-        return 0;
+        dht_entrylk_done(frame);
+    } else {
+        dht_blocking_entrylk_rec(frame, ++lk_index);
+    }
+
+    return 0;
 
 cleanup:
-        dht_entrylk_cleanup (frame);
+    dht_entrylk_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 void
-dht_blocking_entrylk_rec (call_frame_t *frame, int i)
+dht_blocking_entrylk_rec(call_frame_t *frame, int i)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        STACK_WIND_COOKIE (frame, dht_blocking_entrylk_cbk,
-                           (void *) (long) i,
-                           local->lock[0].ns.directory_ns.locks[i]->xl,
-                           local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
-                           local->lock[0].ns.directory_ns.locks[i]->domain,
-                           &local->lock[0].ns.directory_ns.locks[i]->loc,
-                           local->lock[0].ns.directory_ns.locks[i]->basename,
-                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+    STACK_WIND_COOKIE(
+        frame, dht_blocking_entrylk_cbk, (void *)(long)i,
+        local->lock[0].ns.directory_ns.locks[i]->xl,
+        local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
+        local->lock[0].ns.directory_ns.locks[i]->domain,
+        &local->lock[0].ns.directory_ns.locks[i]->loc,
+        local->lock[0].ns.directory_ns.locks[i]->basename, ENTRYLK_LOCK,
+        ENTRYLK_WRLCK, NULL);
 
-        return;
+    return;
 }
 
 int
-dht_blocking_entrylk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, dht_reaction_type_t reaction,
-                      fop_entrylk_cbk_t entrylk_cbk)
+dht_blocking_entrylk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_entrylk_cbk_t entrylk_cbk)
 {
-        int           ret        = -1;
-        call_frame_t *lock_frame = NULL;
-        dht_local_t  *local      = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, entrylk_cbk, out);
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL)
-                goto out;
-
-        ret = dht_local_entrylk_init (lock_frame, lk_array, lk_count,
-                                      entrylk_cbk);
-        if (ret < 0) {
-                goto out;
-        }
+    int ret = -1;
+    call_frame_t *lock_frame = NULL;
+    dht_local_t *local = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, entrylk_cbk, out);
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
+    ret = dht_local_entrylk_init(lock_frame, lk_array, lk_count, entrylk_cbk);
+    if (ret < 0) {
+        goto out;
+    }
 
-        local = lock_frame->local;
-        local->lock[0].ns.directory_ns.reaction = reaction;
-        local->main_frame = frame;
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
 
-        dht_blocking_entrylk_rec (lock_frame, 0);
+    local = lock_frame->local;
+    local->main_frame = frame;
 
-        return 0;
+    dht_blocking_entrylk_rec(lock_frame, 0);
+
+    return 0;
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
 
-        return -1;
+    return -1;
 }
 
 static int
-dht_local_inodelk_init (call_frame_t *frame, dht_lock_t **lk_array,
-                     int lk_count, fop_inodelk_cbk_t inodelk_cbk)
+dht_local_inodelk_init(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                       fop_inodelk_cbk_t inodelk_cbk)
 {
-        int          ret   = -1;
-        dht_local_t *local = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local == NULL) {
-                local = dht_local_init (frame, NULL, NULL, 0);
-        }
+    if (local == NULL) {
+        local = dht_local_init(frame, NULL, NULL, 0);
+    }
 
-        if (local == NULL) {
-                goto out;
-        }
+    if (local == NULL) {
+        goto out;
+    }
 
-        local->lock[0].layout.my_layout.inodelk_cbk = inodelk_cbk;
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = lk_count;
+    local->lock[0].layout.my_layout.inodelk_cbk = inodelk_cbk;
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = lk_count;
 
-        ret = dht_lock_order_requests (local->lock[0].layout.my_layout.locks,
-                                       local->lock[0].layout.my_layout.lk_count);
-        if (ret < 0)
-                goto out;
+    ret = dht_lock_order_requests(local->lock[0].layout.my_layout.locks,
+                                  local->lock[0].layout.my_layout.lk_count);
+    if (ret < 0)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-dht_inodelk_done (call_frame_t *lock_frame)
+dht_inodelk_done(call_frame_t *lock_frame)
 {
-        fop_inodelk_cbk_t  inodelk_cbk = NULL;
-        call_frame_t      *main_frame  = NULL;
-        dht_local_t       *local       = NULL;
+    fop_inodelk_cbk_t inodelk_cbk = NULL;
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
-        main_frame = local->main_frame;
+    local = lock_frame->local;
+    main_frame = local->main_frame;
 
-        local->lock[0].layout.my_layout.locks = NULL;
-        local->lock[0].layout.my_layout.lk_count = 0;
+    local->lock[0].layout.my_layout.locks = NULL;
+    local->lock[0].layout.my_layout.lk_count = 0;
 
-        inodelk_cbk = local->lock[0].layout.my_layout.inodelk_cbk;
-        local->lock[0].layout.my_layout.inodelk_cbk = NULL;
+    inodelk_cbk = local->lock[0].layout.my_layout.inodelk_cbk;
+    local->lock[0].layout.my_layout.inodelk_cbk = NULL;
 
-        inodelk_cbk (main_frame, NULL, main_frame->this,
-                     local->lock[0].layout.my_layout.op_ret,
-                     local->lock[0].layout.my_layout.op_errno, NULL);
+    inodelk_cbk(main_frame, NULL, main_frame->this,
+                local->lock[0].layout.my_layout.op_ret,
+                local->lock[0].layout.my_layout.op_errno, NULL);
 
-        dht_lock_stack_destroy (lock_frame, DHT_INODELK);
-        return;
+    dht_lock_stack_destroy(lock_frame, DHT_INODELK);
+    return;
 }
 
 static int32_t
-dht_unlock_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                  = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret < 0) {
-                uuid_utoa_r (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
-                             gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "unlocking failed on %s:%s",
-                        local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
-                        gfid);
-        } else {
-                local->lock[0].layout.my_layout.locks[lk_index]->locked = 0;
-        }
-
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                dht_inodelk_done (frame);
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret < 0) {
+        uuid_utoa_r(local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
+                    gfid);
+
+        gf_smsg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLOCKING_FAILED,
+                "name=%s",
+                local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
+                "gfid=%s", gfid, NULL);
+    } else {
+        local->lock[0].layout.my_layout.locks[lk_index]->locked = 0;
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        dht_inodelk_done(frame);
+    }
+
+    return 0;
 }
 
 static int32_t
-dht_unlock_inodelk_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_inodelk_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        gf_uuid_unparse (local->lock[0].layout.my_layout.locks[0]->loc.inode->gfid, gfid);
+    local = frame->local;
+    gf_uuid_unparse(local->lock[0].layout.my_layout.locks[0]->loc.inode->gfid,
+                    gfid);
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "unlock failed on gfid: %s, stale lock might be left "
-                        "in DHT_LAYOUT_HEAL_DOMAIN", gfid);
-        }
+    if (op_ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, op_errno,
+                DHT_MSG_UNLOCK_GFID_FAILED, "DHT_LAYOUT_HEAL_DOMAIN gfid=%s",
+                gfid, NULL);
+    }
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
-dht_unlock_inodelk (call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
-                     fop_inodelk_cbk_t inodelk_cbk)
+dht_unlock_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                   fop_inodelk_cbk_t inodelk_cbk)
 {
-        dht_local_t     *local      = NULL;
-        struct gf_flock  flock      = {0,};
-        int              ret        = -1 , i = 0;
-        call_frame_t    *lock_frame = NULL;
-        int              call_cnt   = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, done);
-
-        call_cnt = dht_lock_count (lk_array, lk_count);
-        if (call_cnt == 0) {
-                ret = 0;
-                goto done;
-        }
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "cannot allocate a frame, not unlocking following "
-                        "locks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-                goto done;
-        }
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "storing locks in local failed, not unlocking "
-                        "following locks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-
-                goto done;
-        }
-
-        local = lock_frame->local;
-        local->main_frame = frame;
-        local->call_cnt = call_cnt;
-
-        flock.l_type = F_UNLCK;
-
-        for (i = 0; i < local->lock[0].layout.my_layout.lk_count; i++) {
-                if (!local->lock[0].layout.my_layout.locks[i]->locked)
-                        continue;
-
-                lock_frame->root->lk_owner = local->lock[0].layout.my_layout.locks[i]->lk_owner;
-                STACK_WIND_COOKIE (lock_frame, dht_unlock_inodelk_cbk,
-                                   (void *)(long)i,
-                                   local->lock[0].layout.my_layout.locks[i]->xl,
-                                   local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                                   local->lock[0].layout.my_layout.locks[i]->domain,
-                                   &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK,
-                                   &flock, NULL);
-                if (!--call_cnt)
-                        break;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    int ret = -1, i = 0;
+    call_frame_t *lock_frame = NULL;
+    int call_cnt = 0;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, done);
+
+    call_cnt = dht_lock_count(lk_array, lk_count);
+    if (call_cnt == 0) {
+        ret = 0;
+        goto done;
+    }
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_ALLOC_FRAME_FAILED_NOT_UNLOCKING_FOLLOWING_ENTRYLKS,
+                NULL);
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+        goto done;
+    }
+
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_LOCAL_LOCKS_STORE_FAILED_UNLOCKING_FOLLOWING_ENTRYLK,
+                NULL);
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+
+        goto done;
+    }
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+    local->call_cnt = call_cnt;
+
+    flock.l_type = F_UNLCK;
+
+    for (i = 0; i < local->lock[0].layout.my_layout.lk_count; i++) {
+        if (!local->lock[0].layout.my_layout.locks[i]->locked)
+            continue;
+
+        lock_frame->root
+            ->lk_owner = local->lock[0].layout.my_layout.locks[i]->lk_owner;
+        STACK_WIND_COOKIE(
+            lock_frame, dht_unlock_inodelk_cbk, (void *)(long)i,
+            local->lock[0].layout.my_layout.locks[i]->xl,
+            local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+            local->lock[0].layout.my_layout.locks[i]->domain,
+            &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK, &flock,
+            NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 
 done:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        /* no locks acquired, invoke inodelk_cbk */
-        if (ret == 0)
-                inodelk_cbk (frame, NULL, frame->this, 0, 0, NULL);
+    /* no locks acquired, invoke inodelk_cbk */
+    if (ret == 0)
+        inodelk_cbk(frame, NULL, frame->this, 0, 0, NULL);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_unlock_inodelk_wrapper (call_frame_t *frame, dht_ilock_wrap_t *inodelk)
+dht_unlock_inodelk_wrapper(call_frame_t *frame, dht_ilock_wrap_t *inodelk)
 {
-        dht_local_t  *local                   = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame              = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int           ret                     = 0;
-
-        local = frame->local;
-
-        if (!inodelk || !inodelk->locks)
-                goto out;
-
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "copy frame failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
 
-        lock_local = dht_local_init (lock_frame, NULL, NULL, 0);
-        if (lock_local == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "local creation failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
+    local = frame->local;
 
-        lock_frame->local = lock_local;
+    if (!inodelk || !inodelk->locks)
+        goto out;
 
-        lock_local->lock[0].layout.my_layout.locks = inodelk->locks;
-        lock_local->lock[0].layout.my_layout.lk_count = inodelk->lk_count;
-        inodelk->locks = NULL;
-        inodelk->lk_count = 0;
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+                DHT_MSG_COPY_FRAME_FAILED, "pgfid=%s", pgfid, "name=%s",
+                local->loc.name, "path=%s", local->loc.path, NULL);
+        goto done;
+    }
 
-        ret = dht_unlock_inodelk (lock_frame,
-                                  lock_local->lock[0].layout.my_layout.locks,
-                                  lock_local->lock[0].layout.my_layout.lk_count,
-                                  dht_unlock_inodelk_done);
+    lock_local = dht_local_init(lock_frame, NULL, NULL, 0);
+    if (lock_local == NULL) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+                DHT_MSG_CREATE_FAILED, "local", "gfid=%s", pgfid, "name=%s",
+                local->loc.name, "path=%s", local->loc.path, NULL);
+        goto done;
+    }
 
-        if (ret)
-                goto done;
+    lock_frame->local = lock_local;
 
-        lock_frame = NULL;
+    lock_local->lock[0].layout.my_layout.locks = inodelk->locks;
+    lock_local->lock[0].layout.my_layout.lk_count = inodelk->lk_count;
+    inodelk->locks = NULL;
+    inodelk->lk_count = 0;
+
+    ret = dht_unlock_inodelk(
+        lock_frame, lock_local->lock[0].layout.my_layout.locks,
+        lock_local->lock[0].layout.my_layout.lk_count, dht_unlock_inodelk_done);
+
+    if (ret)
+        goto done;
+
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 static int
-dht_inodelk_cleanup_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_inodelk_cleanup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_inodelk_done (frame);
-        return 0;
+    dht_inodelk_done(frame);
+    return 0;
 }
 
 static void
-dht_inodelk_cleanup (call_frame_t *lock_frame)
+dht_inodelk_cleanup(call_frame_t *lock_frame)
 {
-        dht_lock_t  **lk_array = NULL;
-        int           lk_count = 0, lk_acquired = 0;
-        dht_local_t  *local    = NULL;
+    dht_lock_t **lk_array = NULL;
+    int lk_count = 0, lk_acquired = 0;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        lk_array = local->lock[0].layout.my_layout.locks;
-        lk_count = local->lock[0].layout.my_layout.lk_count;
+    lk_array = local->lock[0].layout.my_layout.locks;
+    lk_count = local->lock[0].layout.my_layout.lk_count;
 
-        lk_acquired = dht_lock_count (lk_array, lk_count);
-        if (lk_acquired != 0) {
-                dht_unlock_inodelk (lock_frame, lk_array, lk_count,
-                                     dht_inodelk_cleanup_cbk);
-        } else {
-                dht_inodelk_done (lock_frame);
-        }
+    lk_acquired = dht_lock_count(lk_array, lk_count);
+    if (lk_acquired != 0) {
+        dht_unlock_inodelk(lock_frame, lk_array, lk_count,
+                           dht_inodelk_cleanup_cbk);
+    } else {
+        dht_inodelk_done(lock_frame);
+    }
 
-        return;
+    return;
 }
 
 static int32_t
-dht_nonblocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_nonblocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        lk_index = (long) cookie;
+    local = frame->local;
+    lk_index = (long)cookie;
 
-        if (op_ret == -1) {
-                local->lock[0].layout.my_layout.op_ret = -1;
-                local->lock[0].layout.my_layout.op_errno = op_errno;
+    if (op_ret == -1) {
+        local->lock[0].layout.my_layout.op_ret = -1;
+        local->lock[0].layout.my_layout.op_errno = op_errno;
 
-                if (local && local->lock[0].layout.my_layout.locks[lk_index]) {
-                        uuid_utoa_r (local->lock[0].layout.my_layout.locks[lk_index]->loc.inode->gfid,
-                                     gfid);
-
-                        gf_msg_debug (this->name, op_errno,
-                                      "inodelk failed on gfid: %s "
-                                      "subvolume: %s", gfid,
-                                      local->lock[0].layout.my_layout.locks[lk_index]->xl->name);
-                }
+        if (local && local->lock[0].layout.my_layout.locks[lk_index]) {
+            uuid_utoa_r(local->lock[0]
+                            .layout.my_layout.locks[lk_index]
+                            ->loc.inode->gfid,
+                        gfid);
 
-                goto out;
+            gf_msg_debug(
+                this->name, op_errno,
+                "inodelk failed on gfid: %s "
+                "subvolume: %s",
+                gfid,
+                local->lock[0].layout.my_layout.locks[lk_index]->xl->name);
         }
 
-        local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
+        goto out;
+    }
 
-out:
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                if (local->lock[0].layout.my_layout.op_ret < 0) {
-                        dht_inodelk_cleanup (frame);
-                        return 0;
-                }
+    local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
 
-                dht_inodelk_done (frame);
+out:
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->lock[0].layout.my_layout.op_ret < 0) {
+            dht_inodelk_cleanup(frame);
+            return 0;
         }
 
-        return 0;
+        dht_inodelk_done(frame);
+    }
+
+    return 0;
 }
 
 int
-dht_nonblocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                         int lk_count, fop_inodelk_cbk_t inodelk_cbk)
+dht_nonblocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array,
+                        int lk_count, fop_inodelk_cbk_t inodelk_cbk)
 {
-        struct gf_flock  flock      = {0,};
-        int              i          = 0, ret = 0;
-        dht_local_t     *local      = NULL;
-        call_frame_t    *lock_frame = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, out);
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL)
-                goto out;
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                goto out;
-        }
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0, ret = 0;
+    dht_local_t *local = NULL;
+    call_frame_t *lock_frame = NULL;
 
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, out);
 
-        local = lock_frame->local;
-        local->main_frame = frame;
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        local->call_cnt = lk_count;
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        goto out;
+    }
 
-        for (i = 0; i < lk_count; i++) {
-                flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
 
-                STACK_WIND_COOKIE (lock_frame, dht_nonblocking_inodelk_cbk,
-                                   (void *) (long) i,
-                                   local->lock[0].layout.my_layout.locks[i]->xl,
-                                   local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                                   local->lock[0].layout.my_layout.locks[i]->domain,
-                                   &local->lock[0].layout.my_layout.locks[i]->loc,
-                                   F_SETLK,
-                                   &flock, NULL);
-        }
+    local = lock_frame->local;
+    local->main_frame = frame;
+
+    local->call_cnt = lk_count;
+
+    for (i = 0; i < lk_count; i++) {
+        flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+
+        STACK_WIND_COOKIE(
+            lock_frame, dht_nonblocking_inodelk_cbk, (void *)(long)i,
+            local->lock[0].layout.my_layout.locks[i]->xl,
+            local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+            local->lock[0].layout.my_layout.locks[i]->domain,
+            &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK, &flock,
+            NULL);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        return -1;
+    return -1;
 }
 
 static int32_t
-dht_blocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_blocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int          lk_index                   = 0;
-        int          i                          = 0;
-        dht_local_t *local                      = NULL;
-        char         gfid[GF_UUID_BUF_SIZE]     = {0,};
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret == 0) {
-                local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
-        } else {
-                switch (op_errno) {
-                case ESTALE:
-                case ENOENT:
-                        if (local->lock[0].layout.my_layout.reaction != IGNORE_ENOENT_ESTALE) {
-                                gf_uuid_unparse (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid, gfid);
-                                local->lock[0].layout.my_layout.op_ret = -1;
-                                local->lock[0].layout.my_layout.op_errno = op_errno;
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_INODELK_FAILED,
-                                        "inodelk failed on subvol %s. gfid:%s",
-                                        local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
-                                        gfid);
-                                goto cleanup;
-                        }
-                        break;
-                default:
-                        gf_uuid_unparse (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid, gfid);
-                        local->lock[0].layout.my_layout.op_ret = -1;
-                        local->lock[0].layout.my_layout.op_errno = op_errno;
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_INODELK_FAILED,
-                                "inodelk failed on subvol %s, gfid:%s",
-                                local->lock[0].layout.my_layout.locks[lk_index]->xl->name, gfid);
-                        goto cleanup;
+    int lk_index = 0;
+    int i = 0;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+    dht_reaction_type_t reaction = 0;
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret == 0) {
+        local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
+    } else {
+        switch (op_errno) {
+            case ESTALE:
+            case ENOENT:
+                reaction = local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->do_on_failure;
+                if ((reaction != IGNORE_ENOENT_ESTALE) &&
+                    (reaction != IGNORE_ENOENT_ESTALE_EIO)) {
+                    gf_uuid_unparse(local->lock[0]
+                                        .layout.my_layout.locks[lk_index]
+                                        ->loc.gfid,
+                                    gfid);
+                    local->lock[0].layout.my_layout.op_ret = -1;
+                    local->lock[0].layout.my_layout.op_errno = op_errno;
+                    gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                            DHT_MSG_INODELK_FAILED, "subvol=%s",
+                            local->lock[0]
+                                .layout.my_layout.locks[lk_index]
+                                ->xl->name,
+                            "gfid=%s", gfid, NULL);
+                    goto cleanup;
                 }
-        }
+                break;
+            case EIO:
+                reaction = local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->do_on_failure;
+                if (reaction != IGNORE_ENOENT_ESTALE_EIO) {
+                    gf_uuid_unparse(local->lock[0]
+                                        .layout.my_layout.locks[lk_index]
+                                        ->loc.gfid,
+                                    gfid);
+                    local->lock[0].layout.my_layout.op_ret = -1;
+                    local->lock[0].layout.my_layout.op_errno = op_errno;
+                    gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                            DHT_MSG_INODELK_FAILED, "subvol=%s",
+                            local->lock[0]
+                                .layout.my_layout.locks[lk_index]
+                                ->xl->name,
+                            "gfid=%s", gfid, NULL);
+                    goto cleanup;
+                }
+                break;
 
-        if (lk_index == (local->lock[0].layout.my_layout.lk_count - 1)) {
-                for (i = 0; (i < local->lock[0].layout.my_layout.lk_count) &&
-                     (!local->lock[0].layout.my_layout.locks[i]->locked); i++)
-                        ;
+            default:
+                gf_uuid_unparse(
+                    local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
+                    gfid);
+                local->lock[0].layout.my_layout.op_ret = -1;
+                local->lock[0].layout.my_layout.op_errno = op_errno;
+                gf_smsg(
+                    this->name, GF_LOG_ERROR, op_errno, DHT_MSG_INODELK_FAILED,
+                    "subvol=%s",
+                    local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
+                    "gfid=%s", gfid, NULL);
+                goto cleanup;
+        }
+    }
 
-                if (i == local->lock[0].layout.my_layout.lk_count) {
-                        local->lock[0].layout.my_layout.op_ret = -1;
-                        local->lock[0].layout.my_layout.op_errno = op_errno;
-                }
+    if (lk_index == (local->lock[0].layout.my_layout.lk_count - 1)) {
+        for (i = 0; (i < local->lock[0].layout.my_layout.lk_count) &&
+                    (!local->lock[0].layout.my_layout.locks[i]->locked);
+             i++)
+            ;
 
-                dht_inodelk_done (frame);
-        } else {
-                dht_blocking_inodelk_rec (frame, ++lk_index);
+        if (i == local->lock[0].layout.my_layout.lk_count) {
+            local->lock[0].layout.my_layout.op_ret = -1;
+            local->lock[0].layout.my_layout.op_errno = op_errno;
         }
 
-        return 0;
+        dht_inodelk_done(frame);
+    } else {
+        dht_blocking_inodelk_rec(frame, ++lk_index);
+    }
+
+    return 0;
 
 cleanup:
-        dht_inodelk_cleanup (frame);
+    dht_inodelk_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 void
-dht_blocking_inodelk_rec (call_frame_t *frame, int i)
+dht_blocking_inodelk_rec(call_frame_t *frame, int i)
 {
-        dht_local_t     *local = NULL;
-        struct gf_flock  flock = {0,};
+    dht_local_t *local = NULL;
+    struct gf_flock flock = {
+        0,
+    };
 
-        local = frame->local;
+    local = frame->local;
 
-        flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+    flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
 
-        STACK_WIND_COOKIE (frame, dht_blocking_inodelk_cbk,
-                           (void *) (long) i,
-                           local->lock[0].layout.my_layout.locks[i]->xl,
-                           local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                           local->lock[0].layout.my_layout.locks[i]->domain,
-                           &local->lock[0].layout.my_layout.locks[i]->loc,
-                           F_SETLKW,
-                           &flock, NULL);
+    STACK_WIND_COOKIE(
+        frame, dht_blocking_inodelk_cbk, (void *)(long)i,
+        local->lock[0].layout.my_layout.locks[i]->xl,
+        local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+        local->lock[0].layout.my_layout.locks[i]->domain,
+        &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLKW, &flock, NULL);
 
-        return;
+    return;
 }
 
 int
-dht_blocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, dht_reaction_type_t reaction,
-                      fop_inodelk_cbk_t inodelk_cbk)
+dht_blocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_inodelk_cbk_t inodelk_cbk)
 {
-        int           ret                       = -1;
-        call_frame_t *lock_frame                = NULL;
-        dht_local_t  *local                     = NULL;
-        dht_local_t  *tmp_local                 = NULL;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, out);
-
-        tmp_local = frame->local;
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_uuid_unparse (tmp_local->loc.gfid, gfid);
-                gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_LOCK_FRAME_FAILED,
-                        "memory allocation failed for lock_frame. gfid:%s"
-                        " path:%s", gfid, tmp_local->loc.path);
-                goto out;
-        }
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                gf_uuid_unparse (tmp_local->loc.gfid, gfid);
-                gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_LOCAL_LOCK_INIT_FAILED,
-                        "dht_local_lock_init failed, gfid: %s path:%s", gfid,
-                        tmp_local->loc.path);
-                goto out;
-        }
-
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
-
-        local = lock_frame->local;
-        local->lock[0].layout.my_layout.reaction = reaction;
-        local->main_frame = frame;
-
-        dht_blocking_inodelk_rec (lock_frame, 0);
-
-        return 0;
+    int ret = -1;
+    call_frame_t *lock_frame = NULL;
+    dht_local_t *local = NULL;
+    dht_local_t *tmp_local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, out);
+
+    tmp_local = frame->local;
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_uuid_unparse(tmp_local->loc.gfid, gfid);
+        gf_smsg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_LOCK_FRAME_FAILED,
+                "gfid=%s", gfid, "path=%s", tmp_local->loc.path, NULL);
+        goto out;
+    }
+
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        gf_uuid_unparse(tmp_local->loc.gfid, gfid);
+        gf_smsg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_LOCAL_LOCK_INIT_FAILED,
+                "gfid=%s", gfid, "path=%s", tmp_local->loc.path, NULL);
+        goto out;
+    }
+
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+
+    dht_blocking_inodelk_rec(lock_frame, 0);
+
+    return 0;
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        return -1;
+    return -1;
 }
 
 void
-dht_unlock_namespace (call_frame_t *frame, dht_dir_transaction_t *lock)
+dht_unlock_namespace(call_frame_t *frame, dht_dir_transaction_t *lock)
 {
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lock, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lock, out);
 
-        dht_unlock_entrylk_wrapper (frame, &lock->ns.directory_ns);
-        dht_unlock_inodelk_wrapper (frame, &lock->ns.parent_layout);
+    dht_unlock_entrylk_wrapper(frame, &lock->ns.directory_ns);
+    dht_unlock_inodelk_wrapper(frame, &lock->ns.parent_layout);
 
 out:
-        return;
+    return;
 }
 
 static int32_t
-dht_protect_namespace_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_protect_namespace_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local    = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (op_ret != 0)
-                dht_unlock_inodelk_wrapper (frame,
-                                            &local->current->ns.parent_layout);
+    local = frame->local;
+    if (op_ret != 0)
+        dht_unlock_inodelk_wrapper(frame, &local->current->ns.parent_layout);
 
-        local->current->ns.ns_cbk (frame, cookie, this, op_ret, op_errno,
-                                   xdata);
-        return 0;
+    local->current->ns.ns_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-dht_blocking_entrylk_after_inodelk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int32_t op_ret,
-                                    int32_t op_errno, dict_t *xdata)
+dht_blocking_entrylk_after_inodelk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t           *local                   = NULL;
-        int                    ret                     = -1;
-        loc_t                 *loc                     = NULL;
-        dht_lock_t           **lk_array                = NULL;
-        char                   pgfid[GF_UUID_BUF_SIZE] = {0};
-        int                    count                   = 0;
-        dht_elock_wrap_t      *entrylk                 = NULL;
-
-        local = frame->local;
-        entrylk = &local->current->ns.directory_ns;
-
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        loc = &entrylk->locks[0]->loc;
-        gf_uuid_unparse (loc->gfid, pgfid);
-
-        local->op_ret = 0;
-        lk_array = entrylk->locks;
-        count = entrylk->lk_count;
-
-        ret = dht_blocking_entrylk (frame, lk_array, count, FAIL_ON_ANY_ERROR,
-                                    dht_protect_namespace_cbk);
-
-        if (ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = EIO;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_ENTRYLK_ERROR,
-                        "%s (%s/%s): "
-                        "dht_blocking_entrylk failed after taking inodelk",
-                        gf_fop_list[local->fop], pgfid,
-                        entrylk->locks[0]->basename);
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    loc_t *loc = NULL;
+    dht_lock_t **lk_array = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int count = 0;
+    dht_elock_wrap_t *entrylk = NULL;
+
+    local = frame->local;
+    entrylk = &local->current->ns.directory_ns;
+
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    loc = &entrylk->locks[0]->loc;
+    gf_uuid_unparse(loc->gfid, pgfid);
+
+    local->op_ret = 0;
+    lk_array = entrylk->locks;
+    count = entrylk->lk_count;
+
+    ret = dht_blocking_entrylk(frame, lk_array, count,
+                               dht_protect_namespace_cbk);
+
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_ENTRYLK_FAILED_AFT_INODELK, "fop=%s",
+                gf_fop_list[local->fop], "pgfid=%s", pgfid, "basename=%s",
+                entrylk->locks[0]->basename, NULL);
+        goto err;
+    }
+
+    return 0;
 
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-                entrylk->locks = NULL;
-                entrylk->lk_count = 0;
-        }
-
-        /* Unlock inodelk. No harm calling unlock twice */
-        dht_unlock_inodelk_wrapper (frame, &local->current->ns.parent_layout);
-        /* Call ns_cbk. It will take care of unwinding */
-        local->current->ns.ns_cbk (frame, NULL, this, local->op_ret,
-                                   local->op_errno, NULL);
-        return 0;
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+        entrylk->locks = NULL;
+        entrylk->lk_count = 0;
+    }
+
+    /* Unlock inodelk. No harm calling unlock twice */
+    dht_unlock_inodelk_wrapper(frame, &local->current->ns.parent_layout);
+    /* Call ns_cbk. It will take care of unwinding */
+    local->current->ns.ns_cbk(frame, NULL, this, local->op_ret, local->op_errno,
+                              NULL);
+    return 0;
 }
 
 /* Given the loc and the subvol, this routine takes the inodelk on
@@ -1249,135 +1263,130 @@ err:
  * and then entrylk serially.
  */
 int
-dht_protect_namespace (call_frame_t *frame, loc_t *loc,
-                       xlator_t *subvol,
-                       struct dht_namespace *ns,
-                       fop_entrylk_cbk_t ns_cbk)
+dht_protect_namespace(call_frame_t *frame, loc_t *loc, xlator_t *subvol,
+                      struct dht_namespace *ns, fop_entrylk_cbk_t ns_cbk)
 {
-        dht_ilock_wrap_t  *inodelk                 = NULL;
-        dht_elock_wrap_t  *entrylk                 = NULL;
-        dht_lock_t       **lk_array                = NULL;
-        dht_local_t       *local                   = NULL;
-        xlator_t          *this                    = NULL;
-        loc_t              parent                  = {0,};
-        int                ret                     = -1;
-        char               pgfid[GF_UUID_BUF_SIZE] = {0};
-        int32_t            op_errno                = 0;
-        int                count                   = 1;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, loc, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, loc->parent, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, subvol, out);
-
-        local = frame->local;
-        this = frame->this;
-
-        inodelk = &ns->parent_layout;
-        entrylk = &ns->directory_ns;
-
-        /* Initialize entrylk_cbk and parent loc */
-        ns->ns_cbk = ns_cbk;
-
-        ret = dht_build_parent_loc (this, &parent, loc, &op_errno);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_LOC_FAILED, "gfid:%s (name:%s) (path: %s): "
-                        "parent loc build failed", loc->gfid, loc->name,
-                         loc->path);
-                goto out;
-        }
-        gf_uuid_unparse (parent.gfid, pgfid);
-
-        /* Alloc inodelk */
-        inodelk->locks = GF_CALLOC (count, sizeof (*lk_array),
-                                    gf_common_mt_pointer);
-        if (inodelk->locks == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "calloc failure",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto out;
-        }
-
-        inodelk->locks[0] = dht_lock_new (this, subvol, &parent, F_RDLCK,
-                                        DHT_LAYOUT_HEAL_DOMAIN, NULL);
-        if (inodelk->locks[0] == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "inodelk: lock allocation failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-        inodelk->lk_count = count;
-
-        /* Allock entrylk */
-        entrylk->locks = GF_CALLOC (count, sizeof (*lk_array),
-                                    gf_common_mt_pointer);
-        if (entrylk->locks == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "entrylk: calloc failure",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-
-                goto err;
-        }
-
-        entrylk->locks[0] = dht_lock_new (this, subvol, &parent, F_WRLCK,
-                                          DHT_ENTRY_SYNC_DOMAIN, loc->name);
-        if (entrylk->locks[0] == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "entrylk: lock allocation failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-
-                goto err;
-        }
-        entrylk->lk_count = count;
-
-        /* Take read inodelk on parent. If it is successful, take write entrylk
-         * on name in cbk.
-         */
-        lk_array = inodelk->locks;
-        ret = dht_blocking_inodelk (frame, lk_array, count, FAIL_ON_ANY_ERROR,
-                                    dht_blocking_entrylk_after_inodelk);
-        if (ret < 0) {
-                local->op_errno = EIO;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_INODELK_ERROR,
-                        "%s (%s/%s) (path: %s): "
-                        "dht_blocking_inodelk failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        loc_wipe (&parent);
-
-        return 0;
+    dht_ilock_wrap_t *inodelk = NULL;
+    dht_elock_wrap_t *entrylk = NULL;
+    dht_lock_t **lk_array = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    loc_t parent = {
+        0,
+    };
+    int ret = -1;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t op_errno = 0;
+    int count = 1;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, loc, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, loc->parent, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, subvol, out);
+
+    local = frame->local;
+    this = frame->this;
+
+    inodelk = &ns->parent_layout;
+    entrylk = &ns->directory_ns;
+
+    /* Initialize entrylk_cbk and parent loc */
+    ns->ns_cbk = ns_cbk;
+
+    ret = dht_build_parent_loc(this, &parent, loc, &op_errno);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_LOC_FAILED,
+                "gfid=%s", loc->gfid, "name=%s", loc->name, "path=%s",
+                loc->path, NULL);
+        goto out;
+    }
+    gf_uuid_unparse(parent.gfid, pgfid);
+
+    /* Alloc inodelk */
+    inodelk->locks = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (inodelk->locks == NULL) {
+        local->op_errno = ENOMEM;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_CALLOC_FAILED, "fop=%s", gf_fop_list[local->fop],
+                "pgfid=%s", pgfid, "name=%s", loc->name, "path=%s", loc->path,
+                NULL);
+        goto out;
+    }
+
+    inodelk->locks[0] = dht_lock_new(this, subvol, &parent, F_RDLCK,
+                                     DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                                     FAIL_ON_ANY_ERROR);
+    if (inodelk->locks[0] == NULL) {
+        local->op_errno = ENOMEM;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_LOCK_ALLOC_FAILED, "inodelk-fop=%s",
+                gf_fop_list[local->fop], "pgfid=%s", pgfid, "name=%s",
+                loc->name, "path=%s", loc->path, NULL);
+        goto err;
+    }
+    inodelk->lk_count = count;
+
+    /* Allock entrylk */
+    entrylk->locks = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (entrylk->locks == NULL) {
+        local->op_errno = ENOMEM;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_CALLOC_FAILED, "entrylk-fop=%s",
+                gf_fop_list[local->fop], "pgfid=%s", pgfid, "name=%s",
+                loc->name, "path=%s", loc->path, NULL);
+
+        goto err;
+    }
+
+    entrylk->locks[0] = dht_lock_new(this, subvol, &parent, F_WRLCK,
+                                     DHT_ENTRY_SYNC_DOMAIN, loc->name,
+                                     FAIL_ON_ANY_ERROR);
+    if (entrylk->locks[0] == NULL) {
+        local->op_errno = ENOMEM;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_LOCK_ALLOC_FAILED, "entrylk-fop=%s",
+                gf_fop_list[local->fop], "pgfid=%s", pgfid, "name=%s",
+                loc->name, "path=%s", loc->path, NULL);
+
+        goto err;
+    }
+    entrylk->lk_count = count;
+
+    /* Take read inodelk on parent. If it is successful, take write entrylk
+     * on name in cbk.
+     */
+    lk_array = inodelk->locks;
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_blocking_entrylk_after_inodelk);
+    if (ret < 0) {
+        local->op_errno = EIO;
+        gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                DHT_MSG_BLOCK_INODELK_FAILED, "fop=%s", gf_fop_list[local->fop],
+                "pgfid=%s", pgfid, "name=%s", loc->name, "path=%s", loc->path,
+                NULL);
+
+        goto err;
+    }
+
+    loc_wipe(&parent);
+
+    return 0;
 err:
-        if (entrylk->locks != NULL) {
-                dht_lock_array_free (entrylk->locks, count);
-                GF_FREE (entrylk->locks);
-                entrylk->locks = NULL;
-                entrylk->lk_count = 0;
-        }
+    if (entrylk->locks != NULL) {
+        dht_lock_array_free(entrylk->locks, count);
+        GF_FREE(entrylk->locks);
+        entrylk->locks = NULL;
+        entrylk->lk_count = 0;
+    }
 
-        if (inodelk->locks != NULL) {
-                dht_lock_array_free (inodelk->locks, count);
-                GF_FREE (inodelk->locks);
-                inodelk->locks = NULL;
-                inodelk->lk_count = 0;
-        }
+    if (inodelk->locks != NULL) {
+        dht_lock_array_free(inodelk->locks, count);
+        GF_FREE(inodelk->locks);
+        inodelk->locks = NULL;
+        inodelk->lk_count = 0;
+    }
 
-        loc_wipe (&parent);
+    loc_wipe(&parent);
 out:
-        return -1;
+    return -1;
 }
diff --git a/xlators/cluster/dht/src/dht-lock.h b/xlators/cluster/dht/src/dht-lock.h
index 0557858041e..6485c03fb6e 100644
--- a/xlators/cluster/dht/src/dht-lock.h
+++ b/xlators/cluster/dht/src/dht-lock.h
@@ -11,36 +11,35 @@
 #ifndef _DHT_LOCK_H
 #define _DHT_LOCK_H
 
-#include "xlator.h"
 #include "dht-common.h"
 
 void
-dht_lock_array_free (dht_lock_t **lk_array, int count);
+dht_lock_array_free(dht_lock_t **lk_array, int count);
 
 int32_t
-dht_lock_count (dht_lock_t **lk_array, int lk_count);
+dht_lock_count(dht_lock_t **lk_array, int lk_count);
 
 dht_lock_t *
-dht_lock_new (xlator_t *this, xlator_t *xl, loc_t *loc, short type,
-              const char *domain, const char *basename);
+dht_lock_new(xlator_t *this, xlator_t *xl, loc_t *loc, short type,
+             const char *domain, const char *basename,
+             dht_reaction_type_t do_on_failure);
 
 int32_t
-dht_unlock_entrylk_wrapper (call_frame_t *, dht_elock_wrap_t *);
+dht_unlock_entrylk_wrapper(call_frame_t *, dht_elock_wrap_t *);
 
 void
-dht_blocking_entrylk_rec (call_frame_t *frame, int i);
+dht_blocking_entrylk_rec(call_frame_t *frame, int i);
 
 int
-dht_blocking_entrylk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, dht_reaction_type_t reaction,
-                      fop_inodelk_cbk_t entrylk_cbk);
+dht_blocking_entrylk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_inodelk_cbk_t entrylk_cbk);
 
 int32_t
-dht_unlock_inodelk (call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
-                     fop_inodelk_cbk_t inodelk_cbk);
+dht_unlock_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                   fop_inodelk_cbk_t inodelk_cbk);
 
 int32_t
-dht_unlock_inodelk_wrapper (call_frame_t *, dht_ilock_wrap_t *);
+dht_unlock_inodelk_wrapper(call_frame_t *, dht_ilock_wrap_t *);
 
 /* Acquire non-blocking inodelk on a list of xlators.
  *
@@ -57,11 +56,11 @@ dht_unlock_inodelk_wrapper (call_frame_t *, dht_ilock_wrap_t *);
  */
 
 int
-dht_nonblocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                         int lk_count, fop_inodelk_cbk_t inodelk_cbk);
+dht_nonblocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array,
+                        int lk_count, fop_inodelk_cbk_t inodelk_cbk);
 
 void
-dht_blocking_inodelk_rec (call_frame_t *frame, int i);
+dht_blocking_inodelk_rec(call_frame_t *frame, int i);
 
 /* same as dht_nonblocking_inodelk, but issues sequential blocking locks on
  * @lk_array directly. locks are issued on some order which remains same
@@ -69,26 +68,24 @@ dht_blocking_inodelk_rec (call_frame_t *frame, int i);
  */
 
 int
-dht_blocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, dht_reaction_type_t reaction,
-                      fop_inodelk_cbk_t inodelk_cbk);
+dht_blocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_inodelk_cbk_t inodelk_cbk);
 
 int32_t
-dht_blocking_entrylk_after_inodelk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int32_t op_ret,
-                                    int32_t op_errno, dict_t *xdata);
+dht_blocking_entrylk_after_inodelk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, dict_t *xdata);
 
 int32_t
-dht_blocking_entrylk_after_inodelk_rename (call_frame_t *frame, void *cookie,
-                                           xlator_t *this, int32_t op_ret,
-                                           int32_t op_errno, dict_t *xdata);
+dht_blocking_entrylk_after_inodelk_rename(call_frame_t *frame, void *cookie,
+                                          xlator_t *this, int32_t op_ret,
+                                          int32_t op_errno, dict_t *xdata);
 
 void
-dht_unlock_namespace (call_frame_t *, dht_dir_transaction_t *);
+dht_unlock_namespace(call_frame_t *, dht_dir_transaction_t *);
 
 int
-dht_protect_namespace (call_frame_t *frame, loc_t *loc, xlator_t *subvol,
-                       struct dht_namespace *ns,
-                       fop_entrylk_cbk_t ns_cbk);
+dht_protect_namespace(call_frame_t *frame, loc_t *loc, xlator_t *subvol,
+                      struct dht_namespace *ns, fop_entrylk_cbk_t ns_cbk);
 
-#endif   /* _DHT_LOCK_H */
+#endif /* _DHT_LOCK_H */
diff --git a/xlators/cluster/dht/src/dht-mem-types.h b/xlators/cluster/dht/src/dht-mem-types.h
index 19cccef537b..e3c4471334a 100644
--- a/xlators/cluster/dht/src/dht-mem-types.h
+++ b/xlators/cluster/dht/src/dht-mem-types.h
@@ -8,38 +8,31 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #ifndef __DHT_MEM_TYPES_H__
 #define __DHT_MEM_TYPES_H__
 
-#include "mem-types.h"
+#include <glusterfs/mem-types.h>
 
 enum gf_dht_mem_types_ {
-        gf_dht_mt_dht_du_t = gf_common_mt_end + 1,
-        gf_dht_mt_dht_conf_t,
-        gf_dht_mt_char,
-        gf_dht_mt_int32_t,
-        gf_dht_mt_xlator_t,
-        gf_dht_mt_dht_layout_t,
-        gf_switch_mt_dht_conf_t,
-        gf_switch_mt_dht_du_t,
-        gf_switch_mt_switch_sched_array,
-        gf_switch_mt_switch_struct,
-        gf_dht_mt_subvol_time,
-        gf_dht_mt_loc_t,
-        gf_defrag_info_mt,
-        gf_dht_mt_inode_ctx_t,
-        gf_dht_mt_ctx_stat_time_t,
-        gf_dht_mt_dirent_t,
-        gf_dht_mt_container_t,
-        gf_dht_mt_octx_t,
-        gf_dht_mt_miginfo_t,
-        gf_tier_mt_bricklist_t,
-        gf_tier_mt_ipc_ctr_params_t,
-        gf_dht_mt_fd_ctx_t,
-        gf_tier_mt_qfile_array_t,
-        gf_dht_ret_cache_t,
-        gf_dht_nodeuuids_t,
-        gf_dht_mt_end
+    gf_dht_mt_dht_du_t = gf_common_mt_end + 1,
+    gf_dht_mt_dht_conf_t,
+    gf_dht_mt_char,
+    gf_dht_mt_int32_t,
+    gf_dht_mt_xlator_t,
+    gf_dht_mt_dht_layout_t,
+    gf_switch_mt_switch_sched_array,
+    gf_switch_mt_switch_struct,
+    gf_dht_mt_subvol_time,
+    gf_dht_mt_loc_t,
+    gf_defrag_info_mt,
+    gf_dht_mt_inode_ctx_t,
+    gf_dht_mt_dirent_t,
+    gf_dht_mt_container_t,
+    gf_dht_mt_octx_t,
+    gf_dht_mt_miginfo_t,
+    gf_dht_mt_fd_ctx_t,
+    gf_dht_ret_cache_t,
+    gf_dht_nodeuuids_t,
+    gf_dht_mt_end
 };
 #endif
diff --git a/xlators/cluster/dht/src/dht-messages.h b/xlators/cluster/dht/src/dht-messages.h
index dcfd7478440..601f8dad78b 100644
--- a/xlators/cluster/dht/src/dht-messages.h
+++ b/xlators/cluster/dht/src/dht-messages.h
@@ -10,1136 +10,377 @@
 #ifndef _DHT_MESSAGES_H_
 #define _DHT_MESSAGES_H_
 
-#include "glfs-message-id.h"
+#include <glusterfs/glfs-message-id.h>
+
+/* To add new message IDs, append new identifiers at the end of the list.
+ *
+ * Never remove a message ID. If it's not used anymore, you can rename it or
+ * leave it as it is, but not delete it. This is to prevent reutilization of
+ * IDs by other messages.
+ *
+ * The component name must match one of the entries defined in
+ * glfs-message-id.h.
+ */
+
+GLFS_MSGID(
+    DHT, DHT_MSG_CACHED_SUBVOL_GET_FAILED, DHT_MSG_CREATE_LINK_FAILED,
+    DHT_MSG_DICT_SET_FAILED, DHT_MSG_DIR_ATTR_HEAL_FAILED,
+    DHT_MSG_DIR_SELFHEAL_FAILED, DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+    DHT_MSG_FILE_ON_MULT_SUBVOL, DHT_MSG_FILE_TYPE_MISMATCH,
+    DHT_MSG_GFID_MISMATCH, DHT_MSG_GFID_NULL, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+    DHT_MSG_INIT_FAILED, DHT_MSG_INVALID_CONFIGURATION,
+    DHT_MSG_INVALID_DISK_LAYOUT, DHT_MSG_INVALID_OPTION,
+    DHT_MSG_LAYOUT_FIX_FAILED, DHT_MSG_LAYOUT_MERGE_FAILED,
+    DHT_MSG_LAYOUT_MISMATCH, DHT_MSG_LAYOUT_NULL, DHT_MSG_MIGRATE_DATA_COMPLETE,
+    DHT_MSG_MIGRATE_DATA_FAILED, DHT_MSG_MIGRATE_FILE_COMPLETE,
+    DHT_MSG_MIGRATE_FILE_FAILED, DHT_MSG_NO_MEMORY, DHT_MSG_OPENDIR_FAILED,
+    DHT_MSG_REBALANCE_FAILED, DHT_MSG_REBALANCE_START_FAILED,
+    DHT_MSG_REBALANCE_STATUS, DHT_MSG_REBALANCE_STOPPED, DHT_MSG_RENAME_FAILED,
+    DHT_MSG_SETATTR_FAILED, DHT_MSG_SUBVOL_INSUFF_INODES,
+    DHT_MSG_SUBVOL_INSUFF_SPACE, DHT_MSG_UNLINK_FAILED,
+    DHT_MSG_LAYOUT_SET_FAILED, DHT_MSG_LOG_FIXED_LAYOUT,
+    DHT_MSG_GET_XATTR_FAILED, DHT_MSG_FILE_LOOKUP_FAILED,
+    DHT_MSG_OPEN_FD_FAILED, DHT_MSG_SET_INODE_CTX_FAILED,
+    DHT_MSG_UNLOCKING_FAILED, DHT_MSG_DISK_LAYOUT_NULL, DHT_MSG_SUBVOL_INFO,
+    DHT_MSG_CHUNK_SIZE_INFO, DHT_MSG_LAYOUT_FORM_FAILED, DHT_MSG_SUBVOL_ERROR,
+    DHT_MSG_LAYOUT_SORT_FAILED, DHT_MSG_REGEX_INFO, DHT_MSG_FOPEN_FAILED,
+    DHT_MSG_SET_HOSTNAME_FAILED, DHT_MSG_BRICK_ERROR, DHT_MSG_SYNCOP_FAILED,
+    DHT_MSG_MIGRATE_INFO, DHT_MSG_SOCKET_ERROR, DHT_MSG_CREATE_FD_FAILED,
+    DHT_MSG_READDIR_ERROR, DHT_MSG_CHILD_LOC_BUILD_FAILED,
+    DHT_MSG_SET_SWITCH_PATTERN_ERROR, DHT_MSG_COMPUTE_HASH_FAILED,
+    DHT_MSG_FIND_LAYOUT_ANOMALIES_ERROR, DHT_MSG_ANOMALIES_INFO,
+    DHT_MSG_LAYOUT_INFO, DHT_MSG_INODE_LK_ERROR, DHT_MSG_RENAME_INFO,
+    DHT_MSG_DATA_NULL, DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED,
+    DHT_MSG_UNLINK_LOOKUP_INFO, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+    DHT_MSG_OPERATION_NOT_SUP, DHT_MSG_NOT_LINK_FILE_ERROR, DHT_MSG_CHILD_DOWN,
+    DHT_MSG_UUID_PARSE_ERROR, DHT_MSG_GET_DISK_INFO_ERROR,
+    DHT_MSG_INVALID_VALUE, DHT_MSG_SWITCH_PATTERN_INFO,
+    DHT_MSG_SUBVOL_OP_FAILED, DHT_MSG_LAYOUT_PRESET_FAILED,
+    DHT_MSG_INVALID_LINKFILE, DHT_MSG_FIX_LAYOUT_INFO,
+    DHT_MSG_GET_HOSTNAME_FAILED, DHT_MSG_WRITE_FAILED,
+    DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED, DHT_MSG_FSYNC_FAILED,
+    DHT_MSG_SUBVOL_DECOMMISSION_INFO, DHT_MSG_BRICK_QUERY_FAILED,
+    DHT_MSG_SUBVOL_NO_LAYOUT_INFO, DHT_MSG_OPEN_FD_ON_DST_FAILED,
+    DHT_MSG_SUBVOL_NOT_FOUND, DHT_MSG_FILE_LOOKUP_ON_DST_FAILED,
+    DHT_MSG_DISK_LAYOUT_MISSING, DHT_MSG_DICT_GET_FAILED,
+    DHT_MSG_REVALIDATE_CBK_INFO, DHT_MSG_UPGRADE_BRICKS, DHT_MSG_LK_ARRAY_INFO,
+    DHT_MSG_RENAME_NOT_LOCAL, DHT_MSG_RECONFIGURE_INFO,
+    DHT_MSG_INIT_LOCAL_SUBVOL_FAILED, DHT_MSG_SYS_CALL_GET_TIME_FAILED,
+    DHT_MSG_NO_DISK_USAGE_STATUS, DHT_MSG_SUBVOL_DOWN_ERROR,
+    DHT_MSG_REBAL_THROTTLE_INFO, DHT_MSG_COMMIT_HASH_INFO,
+    DHT_MSG_REBAL_STRUCT_SET, DHT_MSG_HAS_MIGINFO, DHT_MSG_SETTLE_HASH_FAILED,
+    DHT_MSG_DEFRAG_PROCESS_DIR_FAILED, DHT_MSG_FD_CTX_SET_FAILED,
+    DHT_MSG_STALE_LOOKUP, DHT_MSG_PARENT_LAYOUT_CHANGED,
+    DHT_MSG_LOCK_MIGRATION_FAILED, DHT_MSG_LOCK_INODE_UNREF_FAILED,
+    DHT_MSG_ASPRINTF_FAILED, DHT_MSG_DIR_LOOKUP_FAILED, DHT_MSG_INODELK_FAILED,
+    DHT_MSG_LOCK_FRAME_FAILED, DHT_MSG_LOCAL_LOCK_INIT_FAILED,
+    DHT_MSG_ENTRYLK_ERROR, DHT_MSG_INODELK_ERROR, DHT_MSG_LOC_FAILED,
+    DHT_MSG_UNKNOWN_FOP, DHT_MSG_MIGRATE_FILE_SKIPPED,
+    DHT_MSG_DIR_XATTR_HEAL_FAILED, DHT_MSG_HASHED_SUBVOL_DOWN,
+    DHT_MSG_NON_HASHED_SUBVOL_DOWN, DHT_MSG_SYNCTASK_CREATE_FAILED,
+    DHT_MSG_DIR_HEAL_ABORT, DHT_MSG_MIGRATE_SKIP, DHT_MSG_FD_CREATE_FAILED,
+    DHT_MSG_DICT_NEW_FAILED, DHT_MSG_FAILED_TO_OPEN, DHT_MSG_CREATE_FAILED,
+    DHT_MSG_FILE_NOT_EXIST, DHT_MSG_CHOWN_FAILED, DHT_MSG_FALLOCATE_FAILED,
+    DHT_MSG_FTRUNCATE_FAILED, DHT_MSG_STATFS_FAILED, DHT_MSG_WRITE_CROSS,
+    DHT_MSG_NEW_TARGET_FOUND, DHT_MSG_INSUFF_MEMORY, DHT_MSG_SET_XATTR_FAILED,
+    DHT_MSG_SET_MODE_FAILED, DHT_MSG_FILE_EXISTS_IN_DEST,
+    DHT_MSG_SYMLINK_FAILED, DHT_MSG_LINKFILE_DEL_FAILED, DHT_MSG_MKNOD_FAILED,
+    DHT_MSG_MIGRATE_CLEANUP_FAILED, DHT_MSG_LOCK_MIGRATE,
+    DHT_MSG_PARENT_BUILD_FAILED, DHT_MSG_HASHED_SUBVOL_NOT_FOUND,
+    DHT_MSG_ACQUIRE_ENTRYLK_FAILED, DHT_MSG_CREATE_DST_FAILED,
+    DHT_MSG_MIGRATION_EXIT, DHT_MSG_CHANGED_DST, DHT_MSG_TRACE_FAILED,
+    DHT_MSG_WRITE_LOCK_FAILED, DHT_MSG_GETACTIVELK_FAILED, DHT_MSG_STAT_FAILED,
+    DHT_MSG_UNLINK_PERFORM_FAILED, DHT_MSG_CLANUP_SOURCE_FILE_FAILED,
+    DHT_MSG_UNLOCK_FILE_FAILED, DHT_MSG_REMOVE_XATTR_FAILED,
+    DHT_MSG_DATA_MIGRATE_ABORT, DHT_MSG_DEFRAG_NULL, DHT_MSG_PARENT_NULL,
+    DHT_MSG_GFID_NOT_PRESENT, DHT_MSG_CHILD_LOC_FAILED,
+    DHT_MSG_SET_LOOKUP_FAILED, DHT_MSG_DIR_REMOVED, DHT_MSG_FIX_NOT_COMP,
+    DHT_MSG_SUBVOL_DETER_FAILED, DHT_MSG_LOCAL_SUBVOL, DHT_MSG_NODE_UUID,
+    DHT_MSG_SIZE_FILE, DHT_MSG_GET_DATA_SIZE_FAILED,
+    DHT_MSG_PTHREAD_JOIN_FAILED, DHT_MSG_COUNTER_THREAD_CREATE_FAILED,
+    DHT_MSG_MIGRATION_INIT_QUEUE_FAILED, DHT_MSG_PAUSED_TIMEOUT, DHT_MSG_WOKE,
+    DHT_MSG_ABORT_REBALANCE, DHT_MSG_CREATE_TASK_REBAL_FAILED,
+    DHT_MSG_REBAL_ESTIMATE_NOT_AVAIL, DHT_MSG_ADD_CHOICES_ERROR,
+    DHT_MSG_GET_CHOICES_ERROR, DHT_MSG_PREPARE_STATUS_ERROR,
+    DHT_MSG_SET_CHOICE_FAILED, DHT_MSG_SET_HASHED_SUBVOL_FAILED,
+    DHT_MSG_XATTR_HEAL_NOT_POSS, DHT_MSG_LINKTO_FILE_FAILED,
+    DHT_MSG_STALE_LINKFILE_DELETE, DHT_MSG_NO_SUBVOL_FOR_LINKTO,
+    DHT_MSG_SUBVOL_RETURNED, DHT_MSG_UNKNOWN_LOCAL_XSEL, DHT_MSG_GET_XATTR_ERR,
+    DHT_MSG_ALLOC_OR_FILL_FAILED, DHT_MSG_GET_REAL_NAME_FAILED,
+    DHT_MSG_COPY_UUID_FAILED, DHT_MSG_MDS_DETER_FAILED,
+    DHT_MSG_CREATE_REBAL_FAILED, DHT_MSG_LINK_LAYOUT_FAILED,
+    DHT_MSG_NO_SUBVOL_IN_LAYOUT, DHT_MSG_MEM_ALLOC_FAILED,
+    DHT_MSG_SET_IN_PARAMS_DICT_FAILED, DHT_MSG_LOC_COPY_FAILED,
+    DHT_MSG_PARENT_LOC_FAILED, DHT_MSG_CREATE_LOCK_FAILED,
+    DHT_MSG_PREV_ATTEMPT_FAILED, DHT_MSG_REFRESH_ATTEMPT,
+    DHT_MSG_ACQUIRE_LOCK_FAILED, DHT_MSG_CREATE_STUB_FAILED,
+    DHT_MSG_WIND_LOCK_REQ_FAILED, DHT_MSG_REFRESH_FAILED,
+    DHT_MSG_CACHED_SUBVOL_ERROR, DHT_MSG_NO_LINK_SUBVOL, DHT_MSG_SET_KEY_FAILED,
+    DHT_MSG_REMOVE_LINKTO_FAILED, DHT_MSG_LAYOUT_DICT_SET_FAILED,
+    DHT_MSG_XATTR_DICT_NULL, DHT_MSG_DUMMY_ALLOC_FAILED, DHT_MSG_DICT_IS_NULL,
+    DHT_MSG_LINK_INODE_FAILED, DHT_MSG_SELFHEAL_FAILED, DHT_MSG_NO_MDS_SUBVOL,
+    DHT_MSG_LIST_XATTRS_FAILED, DHT_MSG_RESET_INTER_XATTR_FAILED,
+    DHT_MSG_MDS_DOWN_UNABLE_TO_SET, DHT_MSG_WIND_UNLOCK_FAILED,
+    DHT_MSG_COMMIT_HASH_FAILED, DHT_MSG_UNLOCK_GFID_FAILED,
+    DHT_MSG_UNLOCK_FOLLOW_ENTRYLK, DHT_MSG_COPY_FRAME_FAILED,
+    DHT_MSG_UNLOCK_FOLLOW_LOCKS, DHT_MSG_ENTRYLK_FAILED_AFT_INODELK,
+    DHT_MSG_CALLOC_FAILED, DHT_MSG_LOCK_ALLOC_FAILED,
+    DHT_MSG_BLOCK_INODELK_FAILED,
+    DHT_MSG_LOCAL_LOCKS_STORE_FAILED_UNLOCKING_FOLLOWING_ENTRYLK,
+    DHT_MSG_ALLOC_FRAME_FAILED_NOT_UNLOCKING_FOLLOWING_ENTRYLKS,
+    DHT_MSG_DST_NULL_SET_FAILED);
+
+#define DHT_MSG_FD_CTX_SET_FAILED_STR "Failed to set fd ctx"
+#define DHT_MSG_INVALID_VALUE_STR "Different dst found in the fd ctx"
+#define DHT_MSG_UNKNOWN_FOP_STR "Unknown FOP on file"
+#define DHT_MSG_OPEN_FD_ON_DST_FAILED_STR "Failed to open the fd on file"
+#define DHT_MSG_SYNCTASK_CREATE_FAILED_STR "Failed to create synctask"
+#define DHT_MSG_ASPRINTF_FAILED_STR                                            \
+    "asprintf failed while fetching subvol from the id"
+#define DHT_MSG_HAS_MIGINFO_STR "Found miginfo in the inode ctx"
+#define DHT_MSG_FILE_LOOKUP_FAILED_STR "failed to lookup the file"
+#define DHT_MSG_INVALID_LINKFILE_STR                                           \
+    "linkto target is different from cached-subvol. treating as destination "  \
+    "subvol"
+#define DHT_MSG_GFID_MISMATCH_STR "gfid different on the target file"
+#define DHT_MSG_GET_XATTR_FAILED_STR "failed to get 'linkto' xattr"
+#define DHT_MSG_SET_INODE_CTX_FAILED_STR "failed to set inode-ctx target file"
+#define DHT_MSG_DIR_SELFHEAL_FAILED_STR "Healing of path failed"
+#define DHT_MSG_DIR_HEAL_ABORT_STR                                             \
+    "Failed to get path from subvol. Aborting directory healing"
+#define DHT_MSG_DIR_XATTR_HEAL_FAILED_STR "xattr heal failed for directory"
+#define DHT_MSG_LOCK_INODE_UNREF_FAILED_STR                                    \
+    "Found a NULL inode. Failed to unref the inode"
+#define DHT_MSG_DICT_SET_FAILED_STR "Failed to set dictionary value"
+#define DHT_MSG_NOT_LINK_FILE_ERROR_STR "got non-linkfile"
+#define DHT_MSG_CREATE_LINK_FAILED_STR "failed to initialize linkfile data"
+#define DHT_MSG_UNLINK_FAILED_STR "Unlinking linkfile on subvolume failed"
+#define DHT_MSG_MIGRATE_FILE_FAILED_STR "Migrate file failed"
+#define DHT_MSG_NO_MEMORY_STR "could not allocate memory for dict"
+#define DHT_MSG_SUBVOL_ERROR_STR "Failed to get linkto subvol"
+#define DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED_STR "link failed on subvol"
+#define DHT_MSG_MIGRATE_FILE_SKIPPED_STR "Migration skipped"
+#define DHT_MSG_FD_CREATE_FAILED_STR "fd create failed"
+#define DHT_MSG_DICT_NEW_FAILED_STR "dict_new failed"
+#define DHT_MSG_FAILED_TO_OPEN_STR "failed to open"
+#define DHT_MSG_CREATE_FAILED_STR "failed to create"
+#define DHT_MSG_FILE_NOT_EXIST_STR "file does not exist"
+#define DHT_MSG_CHOWN_FAILED_STR "chown failed"
+#define DHT_MSG_FALLOCATE_FAILED_STR "fallocate failed"
+#define DHT_MSG_FTRUNCATE_FAILED_STR "ftruncate failed"
+#define DHT_MSG_STATFS_FAILED_STR "failed to get statfs"
+#define DHT_MSG_WRITE_CROSS_STR                                                \
+    "write will cross min-fre-disk for file on subvol. looking for new subvol"
+#define DHT_MSG_SUBVOL_INSUFF_SPACE_STR                                        \
+    "Could not find any subvol with space accommodating the file. Cosider "    \
+    "adding bricks"
+#define DHT_MSG_NEW_TARGET_FOUND_STR "New target found for file"
+#define DHT_MSG_INSUFF_MEMORY_STR "insufficient memory"
+#define DHT_MSG_SET_XATTR_FAILED_STR "failed to set xattr"
+#define DHT_MSG_SET_MODE_FAILED_STR "failed to set mode"
+#define DHT_MSG_FILE_EXISTS_IN_DEST_STR "file exists in destination"
+#define DHT_MSG_LINKFILE_DEL_FAILED_STR "failed to delete the linkfile"
+#define DHT_MSG_SYMLINK_FAILED_STR "symlink failed"
+#define DHT_MSG_MKNOD_FAILED_STR "mknod failed"
+#define DHT_MSG_SETATTR_FAILED_STR "failed to perform setattr"
+#define DHT_MSG_MIGRATE_CLEANUP_FAILED_STR                                     \
+    "Migrate file cleanup failed: failed to fstat file"
+#define DHT_MSG_LOCK_MIGRATE_STR "locks will be migrated for file"
+#define DHT_MSG_PARENT_BUILD_FAILED_STR                                        \
+    "failed to build parent loc, which is needed to acquire entrylk to "       \
+    "synchronize with renames on this path. Skipping migration"
+#define DHT_MSG_HASHED_SUBVOL_NOT_FOUND_STR                                    \
+    "cannot find hashed subvol which is needed to synchronize with renames "   \
+    "on this path. Skipping migration"
+#define DHT_MSG_ACQUIRE_ENTRYLK_FAILED_STR "failed to acquire entrylk on subvol"
+#define DHT_MSG_CREATE_DST_FAILED_STR "create dst failed for file"
+#define DHT_MSG_MIGRATION_EXIT_STR "Exiting migration"
+#define DHT_MSG_CHANGED_DST_STR "destination changed fo file"
+#define DHT_MSG_TRACE_FAILED_STR "Trace failed"
+#define DHT_MSG_WRITE_LOCK_FAILED_STR "write lock failed"
+#define DHT_MSG_GETACTIVELK_FAILED_STR "getactivelk failed for file"
+#define DHT_MSG_STAT_FAILED_STR "failed to do a stat"
+#define DHT_MSG_UNLINK_PERFORM_FAILED_STR "failed to perform unlink"
+#define DHT_MSG_MIGRATE_FILE_COMPLETE_STR "completed migration"
+#define DHT_MSG_CLANUP_SOURCE_FILE_FAILED_STR "failed to cleanup source file"
+#define DHT_MSG_UNLOCK_FILE_FAILED_STR "failed to unlock file"
+#define DHT_MSG_REMOVE_XATTR_FAILED_STR "remove xattr failed"
+#define DHT_MSG_SOCKET_ERROR_STR "Failed to unlink listener socket"
+#define DHT_MSG_HASHED_SUBVOL_GET_FAILED_STR "Failed to get hashed subvolume"
+#define DHT_MSG_CACHED_SUBVOL_GET_FAILED_STR "Failed to get cached subvolume"
+#define DHT_MSG_MIGRATE_DATA_FAILED_STR "migrate-data failed"
+#define DHT_MSG_DEFRAG_NULL_STR "defrag is NULL"
+#define DHT_MSG_DATA_MIGRATE_ABORT_STR                                         \
+    "Readdirp failed. Aborting data migration for dict"
+#define DHT_MSG_LAYOUT_FIX_FAILED_STR "fix layout failed"
+#define DHT_MSG_PARENT_NULL_STR "parent is NULL"
+#define DHT_MSG_GFID_NOT_PRESENT_STR "gfid not present"
+#define DHT_MSG_CHILD_LOC_FAILED_STR "Child loc build failed"
+#define DHT_MSG_SET_LOOKUP_FAILED_STR "Failed to set lookup"
+#define DHT_MSG_DIR_LOOKUP_FAILED_STR "lookup failed"
+#define DHT_MSG_DIR_REMOVED_STR "Dir renamed or removed. Skipping"
+#define DHT_MSG_READDIR_ERROR_STR "readdir failed, Aborting fix-layout"
+#define DHT_MSG_SETTLE_HASH_FAILED_STR "Settle hash failed"
+#define DHT_MSG_DEFRAG_PROCESS_DIR_FAILED_STR "gf_defrag_process_dir failed"
+#define DHT_MSG_FIX_NOT_COMP_STR                                               \
+    "Unable to retrieve fixlayout xattr. Assume background fix layout not "    \
+    "complete"
+#define DHT_MSG_SUBVOL_DETER_FAILED_STR                                        \
+    "local subvolume determination failed with error"
+#define DHT_MSG_LOCAL_SUBVOL_STR "local subvol"
+#define DHT_MSG_NODE_UUID_STR "node uuid"
+#define DHT_MSG_SIZE_FILE_STR "Total size files"
+#define DHT_MSG_GET_DATA_SIZE_FAILED_STR                                       \
+    "Failed to get the total data size. Unable to estimate time to complete "  \
+    "rebalance"
+#define DHT_MSG_PTHREAD_JOIN_FAILED_STR                                        \
+    "file_counter_thread: pthread_join failed"
+#define DHT_MSG_COUNTER_THREAD_CREATE_FAILED_STR                               \
+    "Failed to create the file counter thread"
+#define DHT_MSG_MIGRATION_INIT_QUEUE_FAILED_STR                                \
+    "Failed to initialise migration queue"
+#define DHT_MSG_REBALANCE_STOPPED_STR "Received stop command on rebalance"
+#define DHT_MSG_PAUSED_TIMEOUT_STR "Request pause timer timeout"
+#define DHT_MSG_WOKE_STR "woken"
+#define DHT_MSG_ABORT_REBALANCE_STR "Aborting rebalance"
+#define DHT_MSG_REBALANCE_START_FAILED_STR                                     \
+    "Failed to start rebalance: look up on / failed"
+#define DHT_MSG_CREATE_TASK_REBAL_FAILED_STR                                   \
+    "Could not create task for rebalance"
+#define DHT_MSG_REBAL_ESTIMATE_NOT_AVAIL_STR                                   \
+    "Rebalance estimates will not be available"
+#define DHT_MSG_REBALANCE_STATUS_STR "Rebalance status"
+#define DHT_MSG_DATA_NULL_STR "data value is NULL"
+#define DHT_MSG_ADD_CHOICES_ERROR_STR "Error to add choices in buffer"
+#define DHT_MSG_GET_CHOICES_ERROR_STR "Error to get choices"
+#define DHT_MSG_PREPARE_STATUS_ERROR_STR "Error to prepare status"
+#define DHT_MSG_SET_CHOICE_FAILED_STR "Failed to set full choice"
+#define DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED_STR                               \
+    "Failed to aggregate quota xattr"
+#define DHT_MSG_FILE_TYPE_MISMATCH_STR                                         \
+    "path exists as a file on one subvolume and directory on another. Please " \
+    "fix it manually"
+#define DHT_MSG_LAYOUT_SET_FAILED_STR "failed to set layout for subvolume"
+#define DHT_MSG_LAYOUT_MERGE_FAILED_STR "failed to merge layouts for subvolume"
+#define DHT_MSG_SET_HASHED_SUBVOL_FAILED_STR "Failed to set hashed subvolume"
+#define DHT_MSG_XATTR_HEAL_NOT_POSS_STR                                        \
+    "No gfid exists for path. so healing xattr is not possible"
+#define DHT_MSG_REVALIDATE_CBK_INFO_STR "Revalidate: subvolume returned -1"
+#define DHT_MSG_LAYOUT_MISMATCH_STR "Mismatching layouts"
+#define DHT_MSG_UNLINK_LOOKUP_INFO_STR "lookup_unlink retuened"
+#define DHT_MSG_LINKTO_FILE_FAILED_STR                                         \
+    "Could not unlink the linkto file as either fd is open and/or linkto "     \
+    "xattr is set"
+#define DHT_MSG_LAYOUT_PRESET_FAILED_STR                                       \
+    "Could not set pre-set layout for subvolume"
+#define DHT_MSG_FILE_ON_MULT_SUBVOL_STR                                        \
+    "multiple subvolumes have file (preferably rename the file in the "        \
+    "backend, and do a fresh lookup"
+#define DHT_MSG_STALE_LINKFILE_DELETE_STR                                      \
+    "attempting deletion of stale linkfile"
+#define DHT_MSG_LINK_FILE_LOOKUP_INFO_STR "Lookup on following linkfile"
+#define DHT_MSG_NO_SUBVOL_FOR_LINKTO_STR "No link subvolume for linkto"
+#define DHT_MSG_SUBVOL_RETURNED_STR "Subvolume returned -1"
+#define DHT_MSG_UNKNOWN_LOCAL_XSEL_STR "Unknown local->xsel"
+#define DHT_MSG_DICT_GET_FAILED_STR "Failed to get"
+#define DHT_MSG_UUID_PARSE_ERROR_STR "Failed to parse uuid"
+#define DHT_MSG_GET_XATTR_ERR_STR "getxattr err for dir"
+#define DHT_MSG_ALLOC_OR_FILL_FAILED_STR "alloc or fill failed"
+#define DHT_MSG_UPGRADE_BRICKS_STR                                             \
+    "At least one of the bricks does not support this operation. Please "      \
+    "upgrade all bricks"
+#define DHT_MSG_GET_REAL_NAME_FAILED_STR "Failed to get real filename"
+#define DHT_MSG_LAYOUT_NULL_STR "Layout is NULL"
+#define DHT_MSG_COPY_UUID_FAILED_STR "Failed to copy node uuid key"
+#define DHT_MSG_MDS_DETER_FAILED_STR                                           \
+    "Cannot determine MDS, fetching xattr randomly from a subvol"
+#define DHT_MSG_HASHED_SUBVOL_DOWN_STR                                         \
+    "MDS is down for path, so fetching xattr randomly from subvol"
+#define DHT_MSG_CREATE_REBAL_FAILED_STR                                        \
+    "failed to create a new rebalance synctask"
+#define DHT_MSG_FIX_LAYOUT_INFO_STR "fixing the layout"
+#define DHT_MSG_OPERATION_NOT_SUP_STR "wrong directory-spread-count value"
+#define DHT_MSG_LINK_LAYOUT_FAILED_STR "failed to link the layout in inode"
+#define DHT_MSG_NO_SUBVOL_IN_LAYOUT_STR "no subvolume in layout for path"
+#define DHT_MSG_INODE_LK_ERROR_STR "mknod lock failed for file"
+#define DHT_MSG_MEM_ALLOC_FAILED_STR "mem allocation failed"
+#define DHT_MSG_PARENT_LAYOUT_CHANGED_STR                                      \
+    "extracting in-memory layout of parent failed"
+#define DHT_MSG_SET_IN_PARAMS_DICT_FAILED_STR                                  \
+    "setting in params dictionary failed"
+#define DHT_MSG_LOC_COPY_FAILED_STR "loc_copy failed"
+#define DHT_MSG_LOC_FAILED_STR "parent loc build failed"
+#define DHT_MSG_PARENT_LOC_FAILED_STR "locking parent failed"
+#define DHT_MSG_CREATE_LOCK_FAILED_STR "Create lock failed"
+#define DHT_MSG_PREV_ATTEMPT_FAILED_STR                                        \
+    "mkdir loop detected. parent layout didn't change even though previous "   \
+    "attempt of mkdir failed because of in-memory layout not matching with "   \
+    "that on disk."
+#define DHT_MSG_REFRESH_ATTEMPT_STR                                            \
+    "mkdir parent layout changed. Attempting a refresh and then a retry"
+#define DHT_MSG_ACQUIRE_LOCK_FAILED_STR                                        \
+    "Acquiring lock on parent to guard against layout-change failed"
+#define DHT_MSG_CREATE_STUB_FAILED_STR "creating stub failed"
+#define DHT_MSG_WIND_LOCK_REQ_FAILED_STR                                       \
+    "cannot wind lock request to guard parent layout"
+#define DHT_MSG_REFRESH_FAILED_STR "refreshing parent layout failed."
+#define DHT_MSG_CACHED_SUBVOL_ERROR_STR "On cached subvol"
+#define DHT_MSG_NO_LINK_SUBVOL_STR "Linkfile does not have link subvolume"
+#define DHT_MSG_SET_KEY_FAILED_STR "failed to set key"
+#define DHT_MSG_CHILD_DOWN_STR "Received CHILD_DOWN. Exiting"
+#define DHT_MSG_LOG_FIXED_LAYOUT_STR "log layout fixed"
+#define DHT_MSG_REBAL_STRUCT_SET_STR "local->rebalance already set"
+#define DHT_MSG_REMOVE_LINKTO_FAILED_STR "Removal of linkto failed at subvol"
+#define DHT_MSG_LAYOUT_DICT_SET_FAILED_STR "dht layout dict set failed"
+#define DHT_MSG_SUBVOL_INFO_STR "creating subvolume"
+#define DHT_MSG_COMPUTE_HASH_FAILED_STR "hash computation failed"
+#define DHT_MSG_INVALID_DISK_LAYOUT_STR                                        \
+    "Invalid disk layout: Catastrophic error layout with unknown type found"
+#define DHT_MSG_LAYOUT_SORT_FAILED_STR "layout sort failed"
+#define DHT_MSG_ANOMALIES_INFO_STR "Found anomalies"
+#define DHT_MSG_XATTR_DICT_NULL_STR "xattr dictionary is NULL"
+#define DHT_MSG_DISK_LAYOUT_MISSING_STR "Disk layout missing"
+#define DHT_MSG_LAYOUT_INFO_STR "layout info"
+#define DHT_MSG_SUBVOL_NO_LAYOUT_INFO_STR "no pre-set layout for subvol"
+#define DHT_MSG_SELFHEAL_XATTR_FAILED_STR "layout setxattr failed"
+#define DHT_MSG_DIR_SELFHEAL_XATTR_FAILED_STR "Directory self heal xattr failed"
+#define DHT_MSG_DUMMY_ALLOC_FAILED_STR "failed to allocate dummy layout"
+#define DHT_MSG_DICT_IS_NULL_STR                                               \
+    "dict is NULL, need to make sure gfids are same"
+#define DHT_MSG_ENTRYLK_ERROR_STR "acquiring entrylk after inodelk failed"
+#define DHT_MSG_NO_DISK_USAGE_STATUS_STR "no du stats"
+#define DHT_MSG_LINK_INODE_FAILED_STR "linking inode failed"
+#define DHT_MSG_SELFHEAL_FAILED_STR "Directory selfheal failed"
+#define DHT_MSG_NO_MDS_SUBVOL_STR "No mds subvol"
+#define DHT_MSG_LIST_XATTRS_FAILED_STR "failed to list xattrs"
+#define DHT_MSG_RESET_INTER_XATTR_FAILED_STR "Failed to reset internal xattr"
+#define DHT_MSG_MDS_DOWN_UNABLE_TO_SET_STR                                     \
+    "mds subvol is down, unable to set xattr"
+#define DHT_MSG_DIR_ATTR_HEAL_FAILED_STR                                       \
+    "Directory attr heal failed. Failed to set uid/gid"
+#define DHT_MSG_WIND_UNLOCK_FAILED_STR                                         \
+    "Winding unlock failed: stale locks left on brick"
+#define DHT_MSG_COMMIT_HASH_FAILED_STR "Directory commit hash updaten failed"
+#define DHT_MSG_LK_ARRAY_INFO_STR "lk info"
+#define DHT_MSG_UNLOCK_GFID_FAILED_STR                                         \
+    "unlock failed on gfid: stale lock might be left"
+#define DHT_MSG_UNLOCKING_FAILED_STR "unlocking failed"
+#define DHT_MSG_UNLOCK_FOLLOW_ENTRYLK_STR "not unlocking following entrylks"
+#define DHT_MSG_COPY_FRAME_FAILED_STR "copy frame failed"
+#define DHT_MSG_UNLOCK_FOLLOW_LOCKS_STR "not unlocking following locks"
+#define DHT_MSG_INODELK_FAILED_STR "inodelk failed on subvol"
+#define DHT_MSG_LOCK_FRAME_FAILED_STR "memory allocation failed for lock_frame"
+#define DHT_MSG_LOCAL_LOCK_INIT_FAILED_STR "dht_local_lock_init failed"
+#define DHT_MSG_ENTRYLK_FAILED_AFT_INODELK_STR                                 \
+    "dht_blocking_entrylk failed after taking inodelk"
+#define DHT_MSG_BLOCK_INODELK_FAILED_STR "dht_blocking_inodelk failed"
+#define DHT_MSG_CALLOC_FAILED_STR "calloc failed"
+#define DHT_MSG_LOCK_ALLOC_FAILED_STR "lock allocation failed"
+#define DHT_MSG_ALLOC_FRAME_FAILED_NOT_UNLOCKING_FOLLOWING_ENTRYLKS_STR        \
+    "cannot allocate a frame, not unlocking following entrylks"
+#define DHT_MSG_LOCAL_LOCKS_STORE_FAILED_UNLOCKING_FOLLOWING_ENTRYLK_STR       \
+    "storing locks in local failed, not unlocking following entrylks"
+#define DHT_MSG_DST_NULL_SET_FAILED_STR                                        \
+    "src or dst is NULL, Failed to set dictionary value"
 
-/*! \file dht-messages.h
- *  \brief DHT log-message IDs and their descriptions
- *
- */
-
-/* NOTE: Rules for message additions
- * 1) Each instance of a message is _better_ left with a unique message ID, even
- *    if the message format is the same. Reasoning is that, if the message
- *    format needs to change in one instance, the other instances are not
- *    impacted or the new change does not change the ID of the instance being
- *    modified.
- * 2) Addition of a message,
- *       - Should increment the GLFS_NUM_MESSAGES
- *       - Append to the list of messages defined, towards the end
- *       - Retain macro naming as glfs_msg_X (for redability across developers)
- * NOTE: Rules for message format modifications
- * 3) Check acorss the code if the message ID macro in question is reused
- *    anywhere. If reused then then the modifications should ensure correctness
- *    everywhere, or needs a new message ID as (1) above was not adhered to. If
- *    not used anywhere, proceed with the required modification.
- * NOTE: Rules for message deletion
- * 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
- *    anywhere, then can be deleted, but will leave a hole by design, as
- *    addition rules specify modification to the end of the list and not filling
- *    holes.
- */
-
-#define GLFS_DHT_BASE                   GLFS_MSGID_COMP_DHT
-#define GLFS_DHT_NUM_MESSAGES           126
-#define GLFS_MSGID_END          (GLFS_DHT_BASE + GLFS_DHT_NUM_MESSAGES + 1)
-
-/* Messages with message IDs */
-#define glfs_msg_start_x GLFS_DHT_BASE, "Invalid: Start of messages"
-
-
-
-
-/*!
- * @messageid 109001
- * @diagnosis   Cached subvolume could not be found for the specified
- *              path
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_CACHED_SUBVOL_GET_FAILED        (GLFS_DHT_BASE + 1)
-
-/*!
- * @messageid 109002
- * @diagnosis Linkfile creation failed
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_CREATE_LINK_FAILED      (GLFS_DHT_BASE + 2)
-
-/*!
- * @messageid 109003
- * @diagnosis The value could not be set for the specified key in
- *       the dictionary
- *
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_DICT_SET_FAILED         (GLFS_DHT_BASE + 3)
-
-/*!
- * @messageid 109004
- * @diagnosis Directory attributes could not be healed
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_DIR_ATTR_HEAL_FAILED    (GLFS_DHT_BASE + 4)
-
-/*!
- * @messageid 109005
- * @diagnosis Self-heal failed for the specified directory
- * @recommendedaction  Ensure that all subvolumes are online
- *              and reachable and perform a lookup operation
- *              on the directory again.
- *
- */
-
-#define DHT_MSG_DIR_SELFHEAL_FAILED     (GLFS_DHT_BASE + 5)
-
-/*!
- * @messageid 109006
- * @diagnosis The extended attributes could not be healed for
- *            the specified directory on the specified subvolume
- *
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_DIR_SELFHEAL_XATTR_FAILED       (GLFS_DHT_BASE + 6)
-
-/*!
- * @messageid 109007
- * @diagnosis   A lookup operation found the file with the same path
- *      on multiple subvolumes.
- * @recommendedaction
- *      1. Create backups of the file on other subvolumes.
- *      2. Inspect the content of the files to identify
- *                      and retain the most appropriate file.
- *
- */
-
-#define DHT_MSG_FILE_ON_MULT_SUBVOL     (GLFS_DHT_BASE + 7)
-
-/*!
- * @messageid 109008
- * @diagnosis A path resolves to a file on one subvolume and a directory
- *             on another
- * @recommendedaction
- *              1. Create a backup of the file with a different name
- *              and delete the original file.
- *              2. In the newly created back up file, remove the "trusted.gfid"
- *                      extended attribute.
- *                - Command: setfattr -x "trusted.gfid" \<path to the newly created backup file\>
- *              3. Perform a new lookup operation on both the new and old paths.
- *              4. From the mount point, inspect both the paths and retain the
- *              relevant file or directory.
- *
- */
-
-#define DHT_MSG_FILE_TYPE_MISMATCH      (GLFS_DHT_BASE + 8)
-
-/*!
- * @messageid 109009
- * @diagnosis The GFID of the file/directory is different on different subvolumes
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_GFID_MISMATCH           (GLFS_DHT_BASE + 9)
-
-/*!
- * @messageid 109010
- * @diagnosis The GFID of the specified file/directory is NULL.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_GFID_NULL               (GLFS_DHT_BASE + 10)
-
-/*
- * @messageid 109011
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_HASHED_SUBVOL_GET_FAILED   (GLFS_DHT_BASE + 11)
-
-/*!
- * @messageid 109012
- * @diagnosis The Distributed Hash Table Translator could not be initiated as the
- *            system is out of memory.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_INIT_FAILED             (GLFS_DHT_BASE + 12)
-
-/*!
- * @messageid 109013
- * @diagnosis Invalid DHT configuration in the volfile
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_INVALID_CONFIGURATION   (GLFS_DHT_BASE + 13)
-
-/*!
- * @messageid 109014
- * @diagnosis Invalid disk layout
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_INVALID_DISK_LAYOUT     (GLFS_DHT_BASE + 14)
-
-/*!
- * @messageid 109015
- * @diagnosis Invalid DHT configuration option.
- * @recommendedaction
- *              1. Reset the option with a valid value using the volume
- *                set command.
- *              2. Restart the process that logged the message in the
- *                log file.
- *
- */
-
-#define DHT_MSG_INVALID_OPTION          (GLFS_DHT_BASE + 15)
-
-/*!
- * @messageid 109016
- * @diagnosis The fix layout operation failed
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_LAYOUT_FIX_FAILED       (GLFS_DHT_BASE + 16)
-
-/*!
- * @messageid 109017
- * @diagnosis Layout merge failed
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_LAYOUT_MERGE_FAILED     (GLFS_DHT_BASE + 17)
-
-/*!
- * @messageid 109018
- * @diagnosis The layout for the specified directory does not match
-                that on the disk.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_LAYOUT_MISMATCH         (GLFS_DHT_BASE + 18)
-
-/*!
- * @messageid 109019
- * @diagnosis No layout is present for the specified file/directory
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_LAYOUT_NULL             (GLFS_DHT_BASE + 19)
-
-/*!
- * @messageid 109020
- * @diagnosis Informational message: Migration of data from the cached
- *      subvolume to the hashed subvolume is complete
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_MIGRATE_DATA_COMPLETE   (GLFS_DHT_BASE + 20)
-
-/*!
- * @messageid 109021
- * @diagnosis Migration of data failed during the rebalance operation
- *     \n Cause: Directories could not be read to identify the files for the
- *             migration process.
- * @recommendedaction
- *             The log message would indicate the reason for the failure and
- *             the corrective action depends on the specific error that is
- *             encountered. The error is one of the standard UNIX errors.
- *
- */
-
-#define DHT_MSG_MIGRATE_DATA_FAILED     (GLFS_DHT_BASE + 21)
-
-/*!
- * @messageid 109022
- * @diagnosis Informational message: The file was migrated successfully during
- *              the rebalance operation.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_MIGRATE_FILE_COMPLETE   (GLFS_DHT_BASE + 22)
-
-/*!
- * @messageid 109023
- * @diagnosis File migration failed during the rebalance operation
- *            \n Cause: Rebalance moves data from the cached subvolume to
- *            the hashed subvolume. Migrating a single file is a multi-step operation
- *            which involves opening, reading, and writing the data and metadata.
- *            Any failures in this multi-step operation can result in a file
- *            migration failure.
- * @recommendedaction  The log message would indicate the reason for the failure and the
- *              corrective action depends on the specific error that is encountered.
- *              The error is one of the standard UNIX errors.
- *
- */
-
-#define DHT_MSG_MIGRATE_FILE_FAILED     (GLFS_DHT_BASE + 23)
-
-/*!
- * @messageid 109024
- * @diagnosis Out of memory
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_NO_MEMORY               (GLFS_DHT_BASE + 24)
-
-/*!
- * @messageid 109025
- * @diagnosis  The opendir() call failed on the specified directory
- *              \n Cause: When a directory is renamed, the Distribute Hash
- *              table translator checks whether the destination directory
- *              is empty. This message indicates that the opendir() call
- *              on the destination directory has failed.
- * @recommendedaction The log message would indicate the reason for the
- *              failure and the corrective action depends on the specific
- *              error that is encountered. The error is one of the standard
- *              UNIX errors.
- *
- */
-
-#define DHT_MSG_OPENDIR_FAILED          (GLFS_DHT_BASE + 25)
-
-/*!
- * @messageid 109026
- * @diagnosis The rebalance operation failed.
- * @recommendedaction Check the log file for details about the failure.
- *     Possible causes:
- *     - A subvolume is down: Restart the rebalance operation after
- *             bringing up all subvolumes.
- *
- */
-
-#define DHT_MSG_REBALANCE_FAILED        (GLFS_DHT_BASE + 26)
-
-/*!
- * @messageid 109027
- * @diagnosis Failed to start the rebalance process.
- * @recommendedaction Check the log file for details about the failure.
- *
- */
-
-#define DHT_MSG_REBALANCE_START_FAILED  (GLFS_DHT_BASE + 27)
-
-/*!
- * @messageid 109028
- * @diagnosis Informational message that indicates the status of the
- *            rebalance operation and details as to how many files were
- *            migrated, skipped, failed etc
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_REBALANCE_STATUS        (GLFS_DHT_BASE + 28)
-
-/*!
- * @messageid 109029
- * @diagnosis The rebalance operation was aborted by the user.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_REBALANCE_STOPPED       (GLFS_DHT_BASE + 29)
-
-/*!
- * @messageid 109030
- * @diagnosis The file or directory could not be renamed
- * @recommendedaction   Ensure that all the subvolumes are
- *                      online and reachable and try renaming
- *                      the file or directory again.
- *
- */
-
-#define DHT_MSG_RENAME_FAILED           (GLFS_DHT_BASE + 30)
-
-/*!
- * @messageid 109031
- * @diagnosis Attributes could not be set for the specified file or
- *             directory.
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_SETATTR_FAILED          (GLFS_DHT_BASE + 31)
-
-/*!
- * @messageid 109032
- * @diagnosis The specified subvolume is running out of file system inodes.
-        If all subvolumes run out of inodes, then new files cannot be created.
- * @recommendedaction  Consider adding more nodes to the cluster if all subvolumes
- *        run out of inodes
- *
- */
-
-#define DHT_MSG_SUBVOL_INSUFF_INODES    (GLFS_DHT_BASE + 32)
-
-/*!
- * @messageid 109033
- * @diagnosis The specified subvolume is running out of disk space. If all
-              subvolumes run out of space, new files cannot be created.
- * @recommendedaction  Consider adding more bricks to the cluster if all subvolumes
- *              run out of disk space.
- *
- */
-
-#define DHT_MSG_SUBVOL_INSUFF_SPACE    (GLFS_DHT_BASE + 33)
-
-/*!
- * @messageid 109034
- * @diagnosis Failed to unlink the specified file/directory
- * @recommendedaction  The log message would indicate the reason
-              for the failure and the corrective action depends on
-              the specific error that is encountered.
- */
-
-#define DHT_MSG_UNLINK_FAILED           (GLFS_DHT_BASE + 34)
-
-
-
-/*!
- * @messageid 109035
- * @diagnosis The layout information could not be set in the inode
- * @recommendedaction  None
- *
- */
-
-#define DHT_MSG_LAYOUT_SET_FAILED       (GLFS_DHT_BASE + 35)
-
-/*!
- * @messageid 109036
- * @diagnosis Informational message regarding layout range distribution
- *            for a directory across subvolumes
- * @recommendedaction None
- */
-
-#define DHT_MSG_LOG_FIXED_LAYOUT        (GLFS_DHT_BASE + 36)
-
-/*
- * @messageid 109037
- * @diagnosis Informational message regarding error in tier operation
- * @recommendedaction None
- */
-
-#define DHT_MSG_LOG_TIER_ERROR          (GLFS_DHT_BASE + 37)
-
-/*
- * @messageid 109038
- * @diagnosis Informational message regarding tier operation
- * @recommendedaction None
- */
-
-#define DHT_MSG_LOG_TIER_STATUS         (GLFS_DHT_BASE + 38)
-
-/*
- * @messageid 109039
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_GET_XATTR_FAILED        (GLFS_DHT_BASE + 39)
-
-/*
- * @messageid 109040
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FILE_LOOKUP_FAILED      (GLFS_DHT_BASE + 40)
-
-/*
- * @messageid 109041
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_OPEN_FD_FAILED          (GLFS_DHT_BASE + 41)
-
-/*
- * @messageid 109042
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SET_INODE_CTX_FAILED    (GLFS_DHT_BASE + 42)
-
-/*
- * @messageid 109043
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_UNLOCKING_FAILED        (GLFS_DHT_BASE + 43)
-
-/*
- * @messageid 109044
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_DISK_LAYOUT_NULL        (GLFS_DHT_BASE + 44)
-
-/*
- * @messageid 109045
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_INFO             (GLFS_DHT_BASE + 45)
-
-/*
- * @messageid 109046
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_CHUNK_SIZE_INFO         (GLFS_DHT_BASE + 46)
-
-/*
- * @messageid 109047
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LAYOUT_FORM_FAILED      (GLFS_DHT_BASE + 47)
-
-/*
- * @messageid 109048
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_ERROR            (GLFS_DHT_BASE + 48)
-
-/*
- * @messageid 109049
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LAYOUT_SORT_FAILED      (GLFS_DHT_BASE + 49)
-
-/*
- * @messageid 109050
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_REGEX_INFO              (GLFS_DHT_BASE + 50)
-
-/*
- * @messageid 109051
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FOPEN_FAILED            (GLFS_DHT_BASE + 51)
-
-/*
- * @messageid 109052
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SET_HOSTNAME_FAILED     (GLFS_DHT_BASE + 52)
-
-/*
- * @messageid 109053
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_BRICK_ERROR             (GLFS_DHT_BASE + 53)
-
-/*
- * @messageid 109054
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SYNCOP_FAILED           (GLFS_DHT_BASE + 54)
-
-/*
- * @messageid 109055
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_MIGRATE_INFO            (GLFS_DHT_BASE + 55)
-
-/*
- * @messageid 109056
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SOCKET_ERROR            (GLFS_DHT_BASE + 56)
-
-/*
- * @messageid 109057
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_CREATE_FD_FAILED        (GLFS_DHT_BASE + 57)
-
-/*
- * @messageid 109058
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_READDIR_ERROR           (GLFS_DHT_BASE + 58)
-
-/*
- * @messageid 109059
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_CHILD_LOC_BUILD_FAILED  (GLFS_DHT_BASE + 59)
-
-/*
- * @messageid 109060
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SET_SWITCH_PATTERN_ERROR    (GLFS_DHT_BASE + 60)
-
-/*
- * @messageid 109061
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_COMPUTE_HASH_FAILED     (GLFS_DHT_BASE + 61)
-
-/*
- * @messageid 109062
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FIND_LAYOUT_ANOMALIES_ERROR     (GLFS_DHT_BASE + 62)
-
-/*
- * @messageid 109063
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_ANOMALIES_INFO          (GLFS_DHT_BASE + 63)
-
-/*
- * @messageid 109064
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LAYOUT_INFO             (GLFS_DHT_BASE + 64)
-
-/*
- * @messageid 109065
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_INODE_LK_ERROR          (GLFS_DHT_BASE + 65)
-
-/*
- * @messageid 109066
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_RENAME_INFO             (GLFS_DHT_BASE + 66)
-
-/*
- * @messageid 109067
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_DATA_NULL               (GLFS_DHT_BASE + 67)
-
-/*
- * @messageid 109068
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED   (GLFS_DHT_BASE + 68)
-
-/*
- * @messageid 109069
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_UNLINK_LOOKUP_INFO      (GLFS_DHT_BASE + 69)
-
-/*
- * @messageid 109070
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LINK_FILE_LOOKUP_INFO   (GLFS_DHT_BASE + 70)
-
-/*
- * @messageid 109071
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_OPERATION_NOT_SUP       (GLFS_DHT_BASE + 71)
-
-/*
- * @messageid 109072
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_NOT_LINK_FILE_ERROR     (GLFS_DHT_BASE + 72)
-
-/*
- * @messageid 109073
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_CHILD_DOWN              (GLFS_DHT_BASE + 73)
-
-/*
- * @messageid 109074
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_UUID_PARSE_ERROR        (GLFS_DHT_BASE + 74)
-
-/*
- * @messageid 109075
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_GET_DISK_INFO_ERROR     (GLFS_DHT_BASE + 75)
-
-/*
- * @messageid 109076
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_INVALID_VALUE           (GLFS_DHT_BASE + 76)
-
-/*
- * @messageid 109077
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SWITCH_PATTERN_INFO     (GLFS_DHT_BASE + 77)
-
-/*
- * @messageid 109078
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_OP_FAILED        (GLFS_DHT_BASE + 78)
-
-/*
- * @messageid 109079
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LAYOUT_PRESET_FAILED    (GLFS_DHT_BASE + 79)
-
-/*
- * @messageid 109080
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_INVALID_LINKFILE        (GLFS_DHT_BASE + 80)
-
-/*
- * @messageid 109081
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FIX_LAYOUT_INFO         (GLFS_DHT_BASE + 81)
-
-/*
- * @messageid 109082
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_GET_HOSTNAME_FAILED     (GLFS_DHT_BASE + 82)
-
-/*
- * @messageid 109083
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_WRITE_FAILED            (GLFS_DHT_BASE + 83)
-
-/*
- * @messageid 109084
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED (GLFS_DHT_BASE + 84)
-
-/*
- * @messageid 109085
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FSYNC_FAILED            (GLFS_DHT_BASE + 85)
-
-/*
- * @messageid 109086
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_DECOMMISSION_INFO (GLFS_DHT_BASE + 86)
-
-/*
- * @messageid 109087
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_BRICK_QUERY_FAILED      (GLFS_DHT_BASE + 87)
-
-/*
- * @messageid 109088
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_NO_LAYOUT_INFO   (GLFS_DHT_BASE + 88)
-
-/*
- * @messageid 109089
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_OPEN_FD_ON_DST_FAILED   (GLFS_DHT_BASE + 89)
-
-/*
- * @messageid 109090
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_NOT_FOUND        (GLFS_DHT_BASE + 90)
-
-/*
- * @messageid 109190
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FILE_LOOKUP_ON_DST_FAILED   (GLFS_DHT_BASE + 91)
-
-/*
- * @messageid 109092
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_DISK_LAYOUT_MISSING     (GLFS_DHT_BASE + 92)
-
-/*
- * @messageid 109093
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_DICT_GET_FAILED         (GLFS_DHT_BASE + 93)
-
-/*
- * @messageid 109094
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_REVALIDATE_CBK_INFO     (GLFS_DHT_BASE + 94)
-
-/*
- * @messageid 109095
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_UPGRADE_BRICKS         (GLFS_DHT_BASE + 95)
-
-/*
- * @messageid 109096
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LK_ARRAY_INFO           (GLFS_DHT_BASE + 96)
-
-/*
- * @messageid 109097
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_RENAME_NOT_LOCAL        (GLFS_DHT_BASE + 97)
-
-/*
- * @messageid 109098
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_RECONFIGURE_INFO        (GLFS_DHT_BASE + 98)
-
-/*
- * @messageid 109099
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_INIT_LOCAL_SUBVOL_FAILED        (GLFS_DHT_BASE + 99)
-
-/*
- * @messageid 109100
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SYS_CALL_GET_TIME_FAILED        (GLFS_DHT_BASE + 100)
-
-/*
- * @messageid 109101
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_NO_DISK_USAGE_STATUS    (GLFS_DHT_BASE + 101)
-
-/*
- * @messageid 109102
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SUBVOL_DOWN_ERROR       (GLFS_DHT_BASE + 102)
-
-/*
- * @messageid 109103
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_REBAL_THROTTLE_INFO       (GLFS_DHT_BASE + 103)
-
-/*
- * @messageid 109104
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_COMMIT_HASH_INFO       (GLFS_DHT_BASE + 104)
-
-/*
- * @messageid 109105
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_REBAL_STRUCT_SET       (GLFS_DHT_BASE + 105)
-
-/*
- * @messageid 109106
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_HAS_MIGINFO             (GLFS_DHT_BASE + 106)
-
-/*
- * @messageid 109107
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_LOG_IPC_TIER_ERROR      (GLFS_DHT_BASE + 107)
-
-/*
- * @messageid 109108
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_TIER_PAUSED             (GLFS_DHT_BASE + 108)
-
-/*
- * @messageid 109109
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_TIER_RESUME             (GLFS_DHT_BASE + 109)
-
-
-/* @messageid 109110
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_SETTLE_HASH_FAILED       (GLFS_DHT_BASE + 110)
-
-/*
- * @messageid 109111
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_DEFRAG_PROCESS_DIR_FAILED    (GLFS_DHT_BASE + 111)
-
-/*
- * @messageid 109112
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_FD_CTX_SET_FAILED         (GLFS_DHT_BASE + 112)
-
-/*
- * @messageid 109113
- * @diagnosis
- * @recommendedaction None
- */
-
-#define DHT_MSG_STALE_LOOKUP                    (GLFS_DHT_BASE + 113)
-
-/*
- * @messageid 109114
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_PARENT_LAYOUT_CHANGED  (GLFS_DHT_BASE + 114)
-
-/*
- * @messageid 109115
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_LOCK_MIGRATION_FAILED  (GLFS_DHT_BASE + 115)
-
-/*
- * @messageid 109116
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_LOCK_INODE_UNREF_FAILED  (GLFS_DHT_BASE + 116)
-
-/*
- * @messageid 109117
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_ASPRINTF_FAILED         (GLFS_DHT_BASE + 117)
-
-/*
- * @messageid 109118
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_DIR_LOOKUP_FAILED          (GLFS_DHT_BASE + 118)
-
-/*
- * @messageid 109119
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_INODELK_FAILED          (GLFS_DHT_BASE + 119)
-
-/*
- * @messageid 109120
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_LOCK_FRAME_FAILED          (GLFS_DHT_BASE + 120)
-
-/*
- * @messageid 109121
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_LOCAL_LOCK_INIT_FAILED          (GLFS_DHT_BASE + 121)
-
-/*
- * @messageid 109122
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_ENTRYLK_ERROR          (GLFS_DHT_BASE + 122)
-
-/*
- * @messageid 109123
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_INODELK_ERROR          (GLFS_DHT_BASE + 123)
-
-/*
- * @messageid 109124
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_LOC_FAILED             (GLFS_DHT_BASE + 124)
-
-/*
- * @messageid 109125
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_UNKNOWN_FOP            (GLFS_DHT_BASE + 125)
-
-/*
- * @messageid 109126
- * @diagnosis
- * @recommendedaction None
- */
-#define DHT_MSG_MIGRATE_FILE_SKIPPED        (GLFS_DHT_BASE + 126)
-
-#define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
 #endif /* _DHT_MESSAGES_H_ */
diff --git a/xlators/cluster/dht/src/dht-rebalance.c b/xlators/cluster/dht/src/dht-rebalance.c
index 941e982b362..8ba8082bd86 100644
--- a/xlators/cluster/dht/src/dht-rebalance.c
+++ b/xlators/cluster/dht/src/dht-rebalance.c
@@ -8,237 +8,143 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "tier.h"
 #include "dht-common.h"
-#include "xlator.h"
-#include "syscall.h"
-#include <signal.h>
+#include <glusterfs/syscall.h>
 #include <fnmatch.h>
 #include <signal.h>
-#include "events.h"
-
-#define GF_DISK_SECTOR_SIZE              512
-#define DHT_REBALANCE_PID               4242 /* Change it if required */
-#define DHT_REBALANCE_BLKSIZE           (1024 * 1024)  /* 1 MB */
-#define MAX_MIGRATE_QUEUE_COUNT          500
-#define MIN_MIGRATE_QUEUE_COUNT          200
-#define MAX_REBAL_TYPE_SIZE               16
-#define FILE_CNT_INTERVAL                600 /* 10 mins */
-#define ESTIMATE_START_INTERVAL          600 /* 10 mins */
-
+#include <glusterfs/events.h>
+#include "glusterfs/compat-errno.h"  // for ENODATA on BSD
+
+#define GF_DISK_SECTOR_SIZE 512
+#define DHT_REBALANCE_PID 4242        /* Change it if required */
+#define DHT_REBALANCE_BLKSIZE 1048576 /* 1 MB */
+#define MAX_MIGRATE_QUEUE_COUNT 500
+#define MIN_MIGRATE_QUEUE_COUNT 200
+#define MAX_REBAL_TYPE_SIZE 16
+#define FILE_CNT_INTERVAL 600       /* 10 mins */
+#define ESTIMATE_START_INTERVAL 600 /* 10 mins */
+#define HARDLINK_MIG_INPROGRESS -2
+#define SKIP_MIGRATION_FD_POSITIVE -3
 #ifndef MAX
-#define MAX(a, b) (((a) > (b))?(a):(b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
-
-#define GF_CRAWL_INDEX_MOVE(idx, sv_cnt)  {     \
-                idx++;                          \
-                idx %= sv_cnt;                  \
-        }
-
-#define GF_FREE_DIR_DFMETA(dir_dfmeta) {                        \
-                if (dir_dfmeta) {                               \
-                        GF_FREE (dir_dfmeta->head);             \
-                        GF_FREE (dir_dfmeta->equeue);           \
-                        GF_FREE (dir_dfmeta->iterator);         \
-                        GF_FREE (dir_dfmeta->offset_var);       \
-                        GF_FREE (dir_dfmeta->fetch_entries);    \
-                        GF_FREE (dir_dfmeta);                   \
-                }                                               \
-        }                                                       \
+#define GF_CRAWL_INDEX_MOVE(idx, sv_cnt)                                       \
+    {                                                                          \
+        idx++;                                                                 \
+        idx %= sv_cnt;                                                         \
+    }
 
 uint64_t g_totalfiles = 0;
 uint64_t g_totalsize = 0;
 
-
 void
-gf_defrag_free_container (struct dht_container *container)
+gf_defrag_free_dir_dfmeta(struct dir_dfmeta *meta, int local_subvols_cnt)
 {
-        if (container) {
-                gf_dirent_entry_free (container->df_entry);
-
-                if (container->parent_loc) {
-                        loc_wipe (container->parent_loc);
-                }
-
-                GF_FREE (container->parent_loc);
-
-                GF_FREE (container);
-        }
+    int i = 0;
+
+    if (meta) {
+        for (i = 0; i < local_subvols_cnt; i++) {
+            if (meta->equeue)
+                gf_dirent_free(&meta->equeue[i]);
+            if (meta->lfd && meta->lfd[i])
+                fd_unref(meta->lfd[i]);
+        }
+
+        GF_FREE(meta->equeue);
+        GF_FREE(meta->head);
+        GF_FREE(meta->iterator);
+        GF_FREE(meta->offset_var);
+        GF_FREE(meta->fetch_entries);
+        GF_FREE(meta->lfd);
+        GF_FREE(meta);
+    }
 }
 
 void
-dht_set_global_defrag_error (gf_defrag_info_t *defrag, int ret)
+gf_defrag_free_container(struct dht_container *container)
 {
-        LOCK (&defrag->lock);
-        {
-                defrag->global_error = ret;
-        }
-        UNLOCK (&defrag->lock);
-        return;
-}
+    if (container) {
+        gf_dirent_entry_free(container->df_entry);
 
-
-static gf_boolean_t
-dht_is_tier_command (int cmd) {
-
-        gf_boolean_t is_tier = _gf_false;
-
-        switch (cmd) {
-        case GF_DEFRAG_CMD_START_TIER:
-        case GF_DEFRAG_CMD_STATUS_TIER:
-        case GF_DEFRAG_CMD_START_DETACH_TIER:
-        case GF_DEFRAG_CMD_STOP_DETACH_TIER:
-        case GF_DEFRAG_CMD_PAUSE_TIER:
-        case GF_DEFRAG_CMD_RESUME_TIER:
-                is_tier = _gf_true;
-                break;
-        default:
-                break;
+        if (container->parent_loc) {
+            loc_wipe(container->parent_loc);
         }
-        return is_tier;
 
+        GF_FREE(container->parent_loc);
+
+        GF_FREE(container);
+    }
 }
 
+void
+dht_set_global_defrag_error(gf_defrag_info_t *defrag, int ret)
+{
+    LOCK(&defrag->lock);
+    {
+        defrag->global_error = ret;
+    }
+    UNLOCK(&defrag->lock);
+    return;
+}
 
 static int
-dht_send_rebalance_event (xlator_t *this, int cmd, gf_defrag_status_t status)
+dht_send_rebalance_event(xlator_t *this, int cmd, gf_defrag_status_t status)
 {
-        int ret = -1;
-        char *volname = NULL;
-        char *tmpstr  = NULL;
-        char *ptr = NULL;
-        char *suffix = "-dht";
-        dht_conf_t   *conf = NULL;
-        gf_defrag_info_t *defrag = NULL;
-        int len = 0;
-
-        eventtypes_t event = EVENT_LAST;
-
-        switch (status) {
+    int ret = -1;
+    char *volname = NULL;
+    char *tmpstr = NULL;
+    char *ptr = NULL;
+    char *suffix = "-dht";
+    int len = 0;
+
+    eventtypes_t event = EVENT_LAST;
+
+    switch (status) {
         case GF_DEFRAG_STATUS_COMPLETE:
-                event = EVENT_VOLUME_REBALANCE_COMPLETE;
-                break;
+            event = EVENT_VOLUME_REBALANCE_COMPLETE;
+            break;
         case GF_DEFRAG_STATUS_FAILED:
-                event = EVENT_VOLUME_REBALANCE_FAILED;
-                break;
+            event = EVENT_VOLUME_REBALANCE_FAILED;
+            break;
         case GF_DEFRAG_STATUS_STOPPED:
-                event = EVENT_VOLUME_REBALANCE_STOP;
-                break;
+            event = EVENT_VOLUME_REBALANCE_STOP;
+            break;
         default:
-                break;
-
-        }
-
-        if (dht_is_tier_command (cmd)) {
-                /* We should have the tier volume name*/
-                conf = this->private;
-                defrag = conf->defrag;
-                volname = defrag->tier_conf.volname;
-        } else {
-                /* DHT volume */
-                len = strlen (this->name);
-                tmpstr = gf_strdup (this->name);
-                if (tmpstr) {
-                        ptr = tmpstr + (len - strlen (suffix));
-                        if (!strcmp (ptr, suffix)) {
-                                tmpstr[len - strlen (suffix)] = '\0';
-                                volname = tmpstr;
-                        }
-                }
-        }
-
-        if (!volname) {
-                /* Better than nothing */
-                volname = this->name;
-        }
-
-        if (event != EVENT_LAST) {
-                gf_event (event, "volume=%s", volname);
-        }
-
-        GF_FREE (tmpstr);
-        return ret;
+            break;
+    }
+
+    /* DHT volume */
+    len = strlen(this->name) - strlen(suffix);
+    tmpstr = gf_strdup(this->name);
+    if (tmpstr) {
+        ptr = tmpstr + len;
+        if (!strcmp(ptr, suffix)) {
+            tmpstr[len] = '\0';
+            volname = tmpstr;
+        }
+    }
+
+    if (!volname) {
+        /* Better than nothing */
+        volname = this->name;
+    }
+
+    if (event != EVENT_LAST) {
+        gf_event(event, "volume=%s", volname);
+    }
+
+    GF_FREE(tmpstr);
+    return ret;
 }
 
-
-
-
-
-static int
-dht_write_with_holes (xlator_t *to, fd_t *fd, struct iovec *vec, int count,
-                      int32_t size, off_t offset, struct iobref *iobref,
-                      int *fop_errno)
+static void
+dht_strip_out_acls(dict_t *dict)
 {
-        int i            = 0;
-        int ret          = -1;
-        int start_idx    = 0;
-        int tmp_offset   = 0;
-        int write_needed = 0;
-        int buf_len      = 0;
-        int size_pending = 0;
-        char *buf        = NULL;
-
-        /* loop through each vector */
-        for (i = 0; i < count; i++) {
-                buf = vec[i].iov_base;
-                buf_len = vec[i].iov_len;
-
-                for (start_idx = 0; (start_idx + GF_DISK_SECTOR_SIZE) <= buf_len;
-                     start_idx += GF_DISK_SECTOR_SIZE) {
-
-                        if (mem_0filled (buf + start_idx, GF_DISK_SECTOR_SIZE) != 0) {
-                                write_needed = 1;
-                                continue;
-                        }
-
-                        if (write_needed) {
-                                ret = syncop_write (to, fd, (buf + tmp_offset),
-                                                    (start_idx - tmp_offset),
-                                                    (offset + tmp_offset),
-                                                    iobref, 0, NULL, NULL);
-                                /* 'path' will be logged in calling function */
-                                if (ret < 0) {
-                                        gf_log (THIS->name, GF_LOG_WARNING,
-                                                "failed to write (%s)",
-                                                strerror (-ret));
-                                        *fop_errno = -ret;
-                                        ret = -1;
-                                        goto out;
-                                }
-
-                                write_needed = 0;
-                        }
-                        tmp_offset = start_idx + GF_DISK_SECTOR_SIZE;
-                }
-
-                if ((start_idx < buf_len) || write_needed) {
-                        /* This means, last chunk is not yet written.. write it */
-                        ret = syncop_write (to, fd, (buf + tmp_offset),
-                                            (buf_len - tmp_offset),
-                                            (offset + tmp_offset), iobref, 0,
-                                            NULL, NULL);
-                        if (ret < 0) {
-                                /* 'path' will be logged in calling function */
-                                gf_log (THIS->name, GF_LOG_WARNING,
-                                        "failed to write (%s)",
-                                        strerror (-ret));
-                                *fop_errno = -ret;
-                                ret = -1;
-                                goto out;
-                        }
-                }
-
-                size_pending = (size - buf_len);
-                if (!size_pending)
-                        break;
-        }
-
-        ret = size;
-out:
-        return ret;
-
+    if (dict) {
+        dict_del(dict, "trusted.SGI_ACL_FILE");
+        dict_del(dict, POSIX_ACL_ACCESS_XATTR);
+    }
 }
 
 /*
@@ -277,323 +183,318 @@ be converted to "0" in dht_migrate_file.
 */
 
 int32_t
-gf_defrag_handle_hardlink (xlator_t *this, loc_t *loc, int *fop_errno)
+gf_defrag_handle_hardlink(xlator_t *this, loc_t *loc, int *fop_errno)
 {
-        int32_t                 ret             = -1;
-        xlator_t               *cached_subvol   = NULL;
-        xlator_t               *hashed_subvol   = NULL;
-        xlator_t               *linkto_subvol   = NULL;
-        data_t                 *data            = NULL;
-        struct iatt             iatt            = {0,};
-        int32_t                 op_errno        = 0;
-        dht_conf_t             *conf            = NULL;
-        gf_loglevel_t          loglevel         = 0;
-        dict_t                 *link_xattr      = NULL;
-        dict_t                 *dict            = NULL;
-        dict_t                 *xattr_rsp       = NULL;
-        struct iatt             stbuf                   = {0,};
-
+    int32_t ret = -1;
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *linkto_subvol = NULL;
+    data_t *data = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    int32_t op_errno = 0;
+    dht_conf_t *conf = NULL;
+    gf_loglevel_t loglevel = 0;
+    dict_t *link_xattr = NULL;
+    dict_t *dict = NULL;
+    dict_t *xattr_rsp = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+
+    *fop_errno = EINVAL;
+
+    GF_VALIDATE_OR_GOTO("defrag", loc, out);
+    GF_VALIDATE_OR_GOTO("defrag", loc->name, out);
+    GF_VALIDATE_OR_GOTO("defrag", this, out);
+    GF_VALIDATE_OR_GOTO("defrag", this->private, out);
+
+    conf = this->private;
+
+    if (gf_uuid_is_null(loc->pargfid)) {
+        gf_msg("", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "loc->pargfid is NULL for %s",
+               loc->path);
         *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    if (gf_uuid_is_null(loc->gfid)) {
+        gf_msg("", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "loc->gfid is NULL for %s",
+               loc->path);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("defrag", loc, out);
-        GF_VALIDATE_OR_GOTO ("defrag", loc->name, out);
-        GF_VALIDATE_OR_GOTO ("defrag", this, out);
-        GF_VALIDATE_OR_GOTO ("defrag", this->private, out);
-
-        conf = this->private;
-
-        if (gf_uuid_is_null (loc->pargfid)) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "loc->pargfid is NULL for %s", loc->path);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        if (gf_uuid_is_null (loc->gfid)) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "loc->gfid is NULL for %s", loc->path);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        link_xattr = dict_new ();
-        if (!link_xattr) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                goto out;
-        }
-
-        /*
-          Parallel migration can lead to migration of the hard link multiple
-          times which can lead to data loss. Hence, adding a fresh lookup to
-          decide whether migration is required or not.
-
-          Elaborating the scenario for let say 10 hardlinks [link{1..10}]:
-              Let say the first hard link "link1"  does the setxattr of the
-          new hashed subvolume info on the cached file. As there are multiple
-          threads working, we might have already all the links created on the
-          new hashed by the time we reach hardlink let say link5. Now the
-          number of links on hashed is equal to that of cached. Hence, file
-          migration will happen for link6.
-
-                 Cached                                 Hashed
-          --------T link6                        rwxrwxrwx   link6
-
-          Now post above state all the link file on the cached will be zero
-          byte linkto files. Hence, if we still do migration for the following
-          files link{7..10}, we will end up migrating 0 data leading to data
-          loss.
-                Hence, a lookup can make sure whether we need to migrate the
-          file or not.
-        */
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "could not allocate memory for dict");
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
+    link_xattr = dict_new();
+    if (!link_xattr) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        goto out;
+    }
+
+    /*
+      Parallel migration can lead to migration of the hard link multiple
+      times which can lead to data loss. Hence, adding a fresh lookup to
+      decide whether migration is required or not.
+
+      Elaborating the scenario for let say 10 hardlinks [link{1..10}]:
+          Let say the first hard link "link1"  does the setxattr of the
+      new hashed subvolume info on the cached file. As there are multiple
+      threads working, we might have already all the links created on the
+      new hashed by the time we reach hardlink let say link5. Now the
+      number of links on hashed is equal to that of cached. Hence, file
+      migration will happen for link6.
+
+             Cached                                 Hashed
+      --------T link6                        rwxrwxrwx   link6
+
+      Now post above state all the link file on the cached will be zero
+      byte linkto files. Hence, if we still do migration for the following
+      files link{7..10}, we will end up migrating 0 data leading to data
+      loss.
+            Hence, a lookup can make sure whether we need to migrate the
+      file or not.
+    */
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "could not allocate memory for dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to set 'linkto' key in dict",
+               loc->path);
+        goto out;
+    }
+
+    ret = syncop_lookup(this, loc, &stbuf, NULL, dict, &xattr_rsp);
+    if (ret) {
+        /*Ignore ENOENT and ESTALE as file might have been
+          migrated already*/
+        if (-ret == ENOENT || -ret == ESTALE) {
+            ret = -2;
+            goto out;
+        }
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:%s lookup failed with ret = %d", loc->path,
+               ret);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    cached_subvol = dht_subvol_get_cached(this, loc->inode);
+    if (!cached_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "Failed to get cached subvol"
+               " for %s on %s",
+               loc->name, this->name);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (!hashed_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "Failed to get hashed subvol"
+               " for %s on %s",
+               loc->name, this->name);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    /* Hardlink migration happens only with remove-brick. So this condition will
+     * be true only when the migration has happened. In case hardlinks are
+     * migrated for rebalance case, remove this check. Having this check here
+     * avoid redundant calls below*/
+    if (hashed_subvol == cached_subvol) {
+        ret = -2;
+        goto out;
+    }
+
+    gf_log(this->name, GF_LOG_INFO,
+           "Attempting to migrate hardlink %s "
+           "with gfid %s from %s -> %s",
+           loc->name, uuid_utoa(loc->gfid), cached_subvol->name,
+           hashed_subvol->name);
+
+    data = dict_get(xattr_rsp, conf->link_xattr_name);
+    /* set linkto on cached -> hashed if not present, else link it */
+    if (!data) {
+        ret = dict_set_str(link_xattr, conf->link_xattr_name,
+                           hashed_subvol->name);
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed :"
+                   "Failed to set dictionary value:"
+                   " key = %s for %s",
+                   conf->link_xattr_name, loc->name);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_lookup (this, loc, &stbuf, NULL, dict, &xattr_rsp);
+        ret = syncop_setxattr(cached_subvol, loc, link_xattr, 0, NULL, NULL);
         if (ret) {
-                /*Ignore ENOENT and ESTALE as file might have been
-                  migrated already*/
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        ret = -2;
-                        goto out;
-                }
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:%s lookup failed with ret = %d",
-                        loc->path, ret);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed :"
+                   "Linkto setxattr failed %s -> %s",
+                   cached_subvol->name, loc->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        cached_subvol = dht_subvol_get_cached (this, loc->inode);
-        if (!cached_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "Failed to get cached subvol"
-                        " for %s on %s", loc->name, this->name);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (!hashed_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "Failed to get hashed subvol"
-                        " for %s on %s", loc->name, this->name);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        /* Hardlink migration happens only with remove-brick. So this condition will
-         * be true only when the migration has happened. In case hardlinks are migrated
-         * for rebalance case, remove this check. Having this check here avoid redundant
-         * calls below*/
-        if (hashed_subvol == cached_subvol) {
-                ret = -2;
-                goto out;
-        }
-
-        gf_log (this->name, GF_LOG_INFO, "Attempting to migrate hardlink %s "
-                "with gfid %s from %s -> %s", loc->name, uuid_utoa (loc->gfid),
-                cached_subvol->name, hashed_subvol->name);
-
-        data = dict_get (xattr_rsp, conf->link_xattr_name);
-        /* set linkto on cached -> hashed if not present, else link it */
-        if (!data) {
-                ret = dict_set_str (link_xattr, conf->link_xattr_name,
-                                    hashed_subvol->name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed :"
-                                "Failed to set dictionary value:"
-                                " key = %s for %s",
-                                conf->link_xattr_name, loc->name);
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
+        gf_msg_debug(this->name, 0,
+                     "hardlink target subvol created on %s "
+                     ",cached %s, file %s",
+                     hashed_subvol->name, cached_subvol->name, loc->path);
 
-                ret = syncop_setxattr (cached_subvol, loc, link_xattr, 0, NULL,
-                                       NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed :"
-                                "Linkto setxattr failed %s -> %s",
-                                cached_subvol->name,
-                                loc->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                gf_msg_debug (this->name, 0, "hardlink target subvol created on %s "
-                              ",cached %s, file %s",
-                              hashed_subvol->name, cached_subvol->name, loc->path);
-
-                ret = -2;
-                goto out;
+        ret = -2;
+        goto out;
+    } else {
+        linkto_subvol = dht_linkfile_subvol(this, NULL, NULL, xattr_rsp);
+        if (!linkto_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_ERROR,
+                   "Failed to get "
+                   "linkto subvol for %s",
+                   loc->name);
         } else {
-                linkto_subvol = dht_linkfile_subvol (this, NULL, NULL, xattr_rsp);
-                if (!linkto_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SUBVOL_ERROR,
-                                "Failed to get "
-                                "linkto subvol for %s", loc->name);
-                } else {
-                        hashed_subvol = linkto_subvol;
-                }
-
-                ret = syncop_link (hashed_subvol, loc, loc, &iatt, NULL, NULL);
-                if  (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-
-                        loglevel = (op_errno == EEXIST) ? GF_LOG_DEBUG : \
-                                    GF_LOG_ERROR;
-                        gf_msg (this->name, loglevel, op_errno,
-                                DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED,
-                                "link of %s -> %s"
-                                " failed on  subvol %s", loc->name,
-                                uuid_utoa(loc->gfid),
-                                hashed_subvol->name);
-                        if (op_errno != EEXIST) {
-                                *fop_errno = op_errno;
-                                goto out;
-                        }
-                } else {
-                        gf_msg_debug (this->name, 0, "syncop_link successful for"
-                                      " hardlink %s on subvol %s, cached %s", loc->path,
-                                      hashed_subvol->name, cached_subvol->name);
-
-                }
+            hashed_subvol = linkto_subvol;
         }
 
-        ret = syncop_lookup (hashed_subvol, loc, &iatt, NULL, NULL, NULL);
+        ret = syncop_link(hashed_subvol, loc, loc, &iatt, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :Failed lookup %s on %s ",
-                        loc->name, hashed_subvol->name);
-
-                *fop_errno = -ret;
-                ret = -1;
+            op_errno = -ret;
+            ret = -1;
+
+            loglevel = (op_errno == EEXIST) ? GF_LOG_DEBUG : GF_LOG_ERROR;
+            gf_msg(this->name, loglevel, op_errno,
+                   DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED,
+                   "link of %s -> %s"
+                   " failed on  subvol %s",
+                   loc->name, uuid_utoa(loc->gfid), hashed_subvol->name);
+            if (op_errno != EEXIST) {
+                *fop_errno = op_errno;
                 goto out;
+            }
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "syncop_link successful for"
+                         " hardlink %s on subvol %s, cached %s",
+                         loc->path, hashed_subvol->name, cached_subvol->name);
         }
+    }
 
-        /* There is a race where on the target subvol for the hardlink
-         * (note: hash subvol for the hardlink might differ from this), some
-         * other client(non-rebalance) would have created a linkto file for that
-         * hardlink as part of lookup. So let say there are 10 hardlinks, on the
-         * 5th hardlink it self the hardlinks might have migrated. Now for
-         * (6..10th) hardlinks the cached and target would be same as the file
-         * has already migrated. Hence this check is needed  */
-        if (cached_subvol == hashed_subvol) {
-                gf_msg_debug (this->name, 0, "source %s and destination %s "
-                             "for hardlink %s are same", cached_subvol->name,
-                             hashed_subvol->name, loc->path);
-                ret = -2;
-                goto out;
-        }
+    ret = syncop_lookup(hashed_subvol, loc, &iatt, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :Failed lookup %s on %s ", loc->name,
+               hashed_subvol->name);
 
-        if (iatt.ia_nlink == stbuf.ia_nlink) {
-                ret = dht_migrate_file (this, loc, cached_subvol, hashed_subvol,
-                                        GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS,
-                                        fop_errno);
-                if (ret) {
-                        goto out;
-                }
-        }
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* There is a race where on the target subvol for the hardlink
+     * (note: hash subvol for the hardlink might differ from this), some
+     * other client(non-rebalance) would have created a linkto file for that
+     * hardlink as part of lookup. So let say there are 10 hardlinks, on the
+     * 5th hardlink it self the hardlinks might have migrated. Now for
+     * (6..10th) hardlinks the cached and target would be same as the file
+     * has already migrated. Hence this check is needed  */
+    if (cached_subvol == hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "source %s and destination %s "
+                     "for hardlink %s are same",
+                     cached_subvol->name, hashed_subvol->name, loc->path);
         ret = -2;
+        goto out;
+    }
+
+    if (iatt.ia_nlink == stbuf.ia_nlink) {
+        ret = dht_migrate_file(this, loc, cached_subvol, hashed_subvol,
+                               GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS, fop_errno);
+        if (ret) {
+            goto out;
+        }
+    }
+    ret = -2;
 out:
-        if (link_xattr)
-                dict_unref (link_xattr);
+    if (link_xattr)
+        dict_unref(link_xattr);
 
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
-
-
 static int
-__check_file_has_hardlink (xlator_t *this, loc_t *loc,
-                           struct iatt *stbuf, dict_t *xattrs, int flags,
-                           gf_defrag_info_t *defrag, dht_conf_t *conf, int *fop_errno)
+__check_file_has_hardlink(xlator_t *this, loc_t *loc, struct iatt *stbuf,
+                          dict_t *xattrs, int flags, gf_defrag_info_t *defrag,
+                          dht_conf_t *conf, int *fop_errno)
 {
-       int ret = 0;
+    int ret = 0;
 
-       if (flags == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS) {
-                ret = 0;
-                return ret;
-       }
-       if (stbuf->ia_nlink > 1) {
-                /* support for decomission */
-                if (flags == GF_DHT_MIGRATE_HARDLINK) {
-                        synclock_lock (&conf->link_lock);
-                        ret = gf_defrag_handle_hardlink
-                                (this, loc, fop_errno);
-                        synclock_unlock (&conf->link_lock);
-                        /*
-                        Returning zero will force the file to be remigrated.
-                        Checkout gf_defrag_handle_hardlink for more information.
-                        */
-                        if (ret && ret != -2) {
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "Migrate file failed:"
-                                        "%s: failed to migrate file with link",
-                                        loc->path);
-                        }
-                } else {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migration skipped for:"
-                                "%s: file has hardlinks", loc->path);
-                        *fop_errno = ENOTSUP;
-                        ret = -1;
-                }
-       }
+    if (flags == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS) {
+        ret = 0;
+        return ret;
+    }
+    if (stbuf->ia_nlink > 1) {
+        /* support for decomission */
+        if (flags == GF_DHT_MIGRATE_HARDLINK) {
+            synclock_lock(&conf->link_lock);
+            ret = gf_defrag_handle_hardlink(this, loc, fop_errno);
+            synclock_unlock(&conf->link_lock);
+            /*
+            Returning zero will force the file to be remigrated.
+            Checkout gf_defrag_handle_hardlink for more information.
+            */
+            if (ret && ret != -2) {
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "Migrate file failed:"
+                       "%s: failed to migrate file with link",
+                       loc->path);
+            }
+        } else {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migration skipped for:"
+                   "%s: file has hardlinks",
+                   loc->path);
+            *fop_errno = ENOTSUP;
+            ret = 1;
+        }
+    }
 
-       return ret;
+    return ret;
 }
 
-
 /*
      return values
      0 : File will be migrated
@@ -603,846 +504,963 @@ __check_file_has_hardlink (xlator_t *this, loc_t *loc,
     -1 : failure
 */
 static int
-__is_file_migratable (xlator_t *this, loc_t *loc,
-                      struct iatt *stbuf, dict_t *xattrs, int flags,
-                      gf_defrag_info_t *defrag, dht_conf_t *conf,
-                      int *fop_errno)
+__is_file_migratable(xlator_t *this, loc_t *loc, struct iatt *stbuf,
+                     dict_t *xattrs, int flags, gf_defrag_info_t *defrag,
+                     dht_conf_t *conf, int *fop_errno)
 {
-        int ret = -1;
-        int lock_count = 0;
-
-        if (IA_ISDIR (stbuf->ia_type)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: migrate-file called on directory", loc->path);
-                *fop_errno = EISDIR;
-                ret = -1;
-                goto out;
-        }
-
-        if (!conf->lock_migration_enabled) {
-                ret = dict_get_int32 (xattrs, GLUSTERFS_POSIXLK_COUNT,
-                                      &lock_count);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: Unable to get lock count for file",
-                                loc->path);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (lock_count) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: %s: File has locks."
-                                " Skipping file migration", loc->path);
-                        *fop_errno = ENOTSUP;
-                        ret = -1;
-                        goto out;
-                }
-        }
+    int ret = -1;
+    int lock_count = 0;
+
+    if (IA_ISDIR(stbuf->ia_type)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: migrate-file called on directory",
+               loc->path);
+        *fop_errno = EISDIR;
+        ret = -1;
+        goto out;
+    }
 
-        /* Check if file has hardlink*/
-        ret = __check_file_has_hardlink (this, loc, stbuf, xattrs,
-                                         flags, defrag, conf, fop_errno);
+    if (!conf->lock_migration_enabled) {
+        ret = dict_get_int32(xattrs, GLUSTERFS_POSIXLK_COUNT, &lock_count);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: Unable to get lock count for file",
+                   loc->path);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+
+        if (lock_count) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: %s: File has locks."
+                   " Skipping file migration",
+                   loc->path);
+            *fop_errno = ENOTSUP;
+            ret = 1;
+            goto out;
+        }
+    }
+
+    /* Check if file has hardlink*/
+    ret = __check_file_has_hardlink(this, loc, stbuf, xattrs, flags, defrag,
+                                    conf, fop_errno);
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__dht_rebalance_create_dst_file (xlator_t *this, xlator_t *to, xlator_t *from,
-                                 loc_t *loc, struct iatt *stbuf, fd_t **dst_fd,
-                                 dict_t *xattr, int *fop_errno)
+__dht_rebalance_create_dst_file(xlator_t *this, xlator_t *to, xlator_t *from,
+                                loc_t *loc, struct iatt *stbuf, fd_t **dst_fd,
+                                int *fop_errno, int file_has_holes)
 {
-        int          ret  = -1;
-        fd_t        *fd   = NULL;
-        struct iatt  new_stbuf = {0,};
-        struct iatt  check_stbuf= {0,};
-        dht_conf_t  *conf = NULL;
-        dict_t      *dict = NULL;
-
-        conf = this->private;
-
-        dict = dict_new ();
-        if (!dict) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dictionary allocation failed for"
-                        "path:%s", loc->path);
-                goto out;
-        }
-        ret = dict_set_static_bin (dict, "gfid-req", stbuf->ia_gfid, 16);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: failed to set dictionary value: key = gfid-req",
-                        loc->path);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, conf->link_xattr_name, from->name);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: failed to set dictionary value: key = %s ",
-                        loc->path, conf->link_xattr_name);
-                goto out;
-        }
-
-        fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-        if (!fd) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: fd create failed (destination)",
-                        loc->path);
-                goto out;
-        }
-
-        ret = syncop_lookup (to, loc, &new_stbuf, NULL, NULL, NULL);
-        if (!ret) {
-                /* File exits in the destination, check if gfid matches */
-                if (gf_uuid_compare (stbuf->ia_gfid, new_stbuf.ia_gfid) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "file %s exists in %s with different gfid",
-                                loc->path, to->name);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-        }
-        if ((ret < 0) && (-ret != ENOENT)) {
-                /* File exists in destination, but not accessible */
-                gf_msg (THIS->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to lookup file",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        /* Create the destination with LINKFILE mode, and linkto xattr,
-           if the linkfile already exists, just open the file */
-        if (!ret) {
-                /*
-                 * File already present, just open the file.
-                 */
-                ret = syncop_open (to, loc, O_RDWR, fd, NULL, NULL);
-                 if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "failed to open %s on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                 }
-        } else {
-                ret = syncop_create (to, loc, O_RDWR, DHT_LINKFILE_MODE, fd,
-                                     &new_stbuf, dict, NULL);
-                 if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "failed to create %s on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-        }
-
-        fd_bind (fd);
+    int ret = -1;
+    int ret2 = -1;
+    fd_t *fd = NULL;
+    struct iatt new_stbuf = {
+        0,
+    };
+    struct iatt check_stbuf = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+    dict_t *dict = NULL;
+    dict_t *xdata = NULL;
+
+    conf = this->private;
+
+    dict = dict_new();
+    if (!dict) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dictionary allocation failed for"
+               "path:%s",
+               loc->path);
+        goto out;
+    }
+    ret = dict_set_gfuuid(dict, "gfid-req", stbuf->ia_gfid, true);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: failed to set dictionary value: key = gfid-req", loc->path);
+        goto out;
+    }
+
+    ret = dict_set_str(dict, conf->link_xattr_name, from->name);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: failed to set dictionary value: key = %s ", loc->path,
+               conf->link_xattr_name);
+        goto out;
+    }
+
+    fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+    if (!fd) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: fd create failed (destination)", loc->path);
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: dict_new failed)", loc->path);
+        goto out;
+    }
+
+    ret = dict_set_int32_sizen(xdata, GF_CLEAN_WRITE_PROTECTION, 1);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: failed to set dictionary value: key = %s ", loc->path,
+               GF_CLEAN_WRITE_PROTECTION);
+        goto out;
+    }
+
+    ret = syncop_lookup(to, loc, &new_stbuf, NULL, xdata, NULL);
+    if (!ret) {
+        /* File exits in the destination, check if gfid matches */
+        if (gf_uuid_compare(stbuf->ia_gfid, new_stbuf.ia_gfid) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+                   "file %s exists in %s with different gfid", loc->path,
+                   to->name);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+    }
+    if ((ret < 0) && (-ret != ENOENT)) {
+        /* File exists in destination, but not accessible */
+        gf_msg(THIS->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to lookup file", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        /*Reason of doing lookup after create again:
-         *In the create, there is some time-gap between opening fd at the
-         *server (posix_layer) and binding it in server (incrementing fd count),
-         *so if in that time-gap, if other process sends unlink considering it
-         *as a linkto file, because inode->fd count will be 0, so file will be
-         *unlinked at the backend. And because furthur operations are performed
-         *on fd, so though migration will be done but will end with no file
-         *at  the backend.
+    /* Create the destination with LINKFILE mode, and linkto xattr,
+       if the linkfile already exists, just open the file */
+    if (!ret) {
+        /*
+         * File already present, just open the file.
          */
-
-        ret = syncop_lookup (to, loc, &check_stbuf, NULL, NULL, NULL);
-        if (!ret) {
-
-                if (gf_uuid_compare (stbuf->ia_gfid, check_stbuf.ia_gfid) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "file %s exists in %s with different gfid,"
-                                "found in lookup after create",
-                                loc->path, to->name);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-
-        }
-
-        if (-ret == ENOENT) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED, "%s: file does not exists"
-                        "on %s", loc->path, to->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_fsetxattr (to, fd, xattr, 0, NULL, NULL);
+        ret = syncop_open(to, loc, O_RDWR, fd, NULL, NULL);
         if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to set xattr on %s",
-                        loc->path, to->name);
-
-        }
-
-        /* TODO: Need to add a detailed comment about why we moved away from
-        ftruncate.
-
-        ret = syncop_ftruncate (to, fd, stbuf->ia_size, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "ftruncate failed for %s on %s",
-                        loc->path, to->name);
-        */
-
-        ret = syncop_fsetattr (to, fd, stbuf,
-                               (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
-                                NULL, NULL, NULL, NULL);
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to open %s on %s", loc->path, to->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    } else {
+        ret = syncop_create(to, loc, O_RDWR, DHT_LINKFILE_MODE, fd, &new_stbuf,
+                            dict, NULL);
         if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "chown failed for %s on %s",
-                        loc->path, to->name);
-        }
-
-        /* Fallocate does not work for size 0, hence the check. Anyway we don't
-         * need to care about min-free-disk for 0 byte size file */
-        if (stbuf->ia_size > 0) {
-                ret = syncop_fallocate (to, fd, 0, 0, stbuf->ia_size, NULL,
-                                        NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "fallocate failed for %s on %s",
-                                loc->path, to->name);
-                        ret = -1;
-                        goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to create %s on %s", loc->path, to->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    fd_bind(fd);
+
+    /*Reason of doing lookup after create again:
+     *In the create, there is some time-gap between opening fd at the
+     *server (posix_layer) and binding it in server (incrementing fd count),
+     *so if in that time-gap, if other process sends unlink considering it
+     *as a linkto file, because inode->fd count will be 0, so file will be
+     *unlinked at the backend. And because further operations are performed
+     *on fd, so though migration will be done but will end with no file
+     *at  the backend.
+     */
+
+    ret = syncop_lookup(to, loc, &check_stbuf, NULL, NULL, NULL);
+    if (!ret) {
+        if (gf_uuid_compare(stbuf->ia_gfid, check_stbuf.ia_gfid) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+                   "file %s exists in %s with different gfid,"
+                   "found in lookup after create",
+                   loc->path, to->name);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    if (-ret == ENOENT) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: file does not exist"
+               "on %s",
+               loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_fsetattr(to, fd, stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
+                          NULL, NULL, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "chown failed for %s on %s", loc->path, to->name);
+    }
+
+    /* No need to bother about 0 byte size files */
+    if (stbuf->ia_size > 0) {
+        if (conf->use_fallocate && !file_has_holes) {
+            ret = syncop_fallocate(to, fd, 0, 0, stbuf->ia_size, NULL, NULL);
+            if (ret < 0) {
+                if (ret == -EOPNOTSUPP || ret == -EINVAL || ret == -ENOSYS) {
+                    conf->use_fallocate = _gf_false;
+                } else {
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_MIGRATE_FILE_FAILED,
+                           "fallocate failed for %s on %s", loc->path,
+                           to->name);
+
+                    *fop_errno = -ret;
+
+                    /* fallocate does not release the space
+                     * in some cases
+                     */
+                    ret2 = syncop_ftruncate(to, fd, 0, NULL, NULL, NULL, NULL);
+                    if (ret2 < 0) {
+                        gf_msg(this->name, GF_LOG_WARNING, -ret2,
+                               DHT_MSG_MIGRATE_FILE_FAILED,
+                               "ftruncate failed for "
+                               "%s on %s",
+                               loc->path, to->name);
+                    }
+                    goto out;
                 }
+            }
+        } else {
+            ret = syncop_ftruncate(to, fd, stbuf->ia_size, NULL, NULL, NULL,
+                                   NULL);
+            if (ret < 0) {
+                *fop_errno = -ret;
+                gf_msg(this->name, GF_LOG_WARNING, -ret,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "ftruncate failed for %s on %s", loc->path, to->name);
+            }
         }
+    }
 
-        /* success */
-        ret = 0;
+    /* success */
+    ret = 0;
 
-        if (dst_fd)
-                *dst_fd = fd;
+    if (dst_fd)
+        *dst_fd = fd;
 
 out:
-        if (ret) {
-                if (fd) {
-                        fd_unref (fd);
-                }
+    if (ret) {
+        if (fd) {
+            fd_unref(fd);
         }
-        if (dict)
-                dict_unref (dict);
+    }
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    if (xdata)
+        dict_unref(xdata);
+
+    return ret;
 }
 
 static int
-__dht_check_free_space (xlator_t *this, xlator_t *to, xlator_t *from, loc_t *loc,
-                        struct iatt *stbuf, int flag, dht_conf_t *conf,
-                        gf_boolean_t *target_changed, xlator_t **new_subvol,
-                        int *fop_errno)
+__dht_check_free_space(xlator_t *this, xlator_t *to, xlator_t *from, loc_t *loc,
+                       struct iatt *stbuf, int flag, dht_conf_t *conf,
+                       gf_boolean_t *target_changed, xlator_t **new_subvol,
+                       int *fop_errno)
 {
-        struct statvfs  src_statfs = {0,};
-        struct statvfs  dst_statfs = {0,};
-        int             ret        = -1;
-        dict_t         *xdata      = NULL;
-        dht_layout_t   *layout     = NULL;
-        uint64_t        src_statfs_blocks = 1;
-        uint64_t        dst_statfs_blocks = 1;
-        double          post_availspacepercent = 0;
-
-        xdata = dict_new ();
-        if (!xdata) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY,
-                        "failed to allocate dictionary");
-                goto out;
-        }
-
-        ret = dict_set_int8 (xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set "
-                        GF_INTERNAL_IGNORE_DEEM_STATFS" in dict");
-                ret = -1;
-                *fop_errno = ENOMEM;
-                goto out;
-        }
-
-        ret = syncop_statfs (from, loc, &src_statfs, xdata, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to get statfs of %s on %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_statfs (to, loc, &dst_statfs, xdata, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to get statfs of %s on %s",
-                        loc->path, to->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0, "min_free_disk - %f , block available - %lu ,"
-                      " block size - %lu ", conf->min_free_disk, dst_statfs.f_bavail,
-                      dst_statfs.f_bsize);
-
-        /* if force option is given, do not check for space @ dst.
-         * Check only if space is avail for the file */
-        if (flag != GF_DHT_MIGRATE_DATA)
-                goto check_avail_space;
-
-        /* Check:
-           During rebalance `migrate-data` - Destination subvol experiences
-           a `reduction` in 'blocks' of free space, at the same time source
-           subvol gains certain 'blocks' of free space. A valid check is
-           necessary here to avoid errorneous move to destination where
-           the space could be scantily available.
-         */
-        if (stbuf) {
-                dst_statfs_blocks = ((dst_statfs.f_bavail *
-                                      dst_statfs.f_bsize) /
-                                     GF_DISK_SECTOR_SIZE);
-                src_statfs_blocks = ((src_statfs.f_bavail *
-                                      src_statfs.f_bsize) /
-                                     GF_DISK_SECTOR_SIZE);
-                if ((dst_statfs_blocks) <
-                    (src_statfs_blocks + stbuf->ia_blocks)) {
-
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                               DHT_MSG_MIGRATE_FILE_FAILED,
-                               "data movement of file "
-                               "{blocks:%"PRIu64" name:(%s) } would result in "
-                               "dst node (%s:%"PRIu64") having lower disk "
-                               "space then the source node (%s:%"PRIu64")"
-                               ".Skipping file.", stbuf->ia_blocks, loc->path,
-                               to->name, dst_statfs_blocks, from->name,
-                               src_statfs_blocks);
-
-                        /* this is not a 'failure', but we don't want to
-                           consider this as 'success' too :-/ */
-                        *fop_errno = ENOSPC;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
+    struct statvfs src_statfs = {
+        0,
+    };
+    struct statvfs dst_statfs = {
+        0,
+    };
+    int ret = -1;
+    dict_t *xdata = NULL;
+    dht_layout_t *layout = NULL;
+    uint64_t src_statfs_blocks = 1;
+    uint64_t dst_statfs_blocks = 1;
+    double dst_post_availspacepercent = 0;
+    double src_post_availspacepercent = 0;
+    uint64_t file_blocks = 0;
+    uint64_t src_total_blocks = 0;
+    uint64_t dst_total_blocks = 0;
+
+    xdata = dict_new();
+    if (!xdata) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "failed to allocate dictionary");
+        goto out;
+    }
+
+    ret = dict_set_int8(xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
+        ret = -1;
+        *fop_errno = ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_statfs(from, loc, &src_statfs, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to get statfs of %s on %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_statfs(to, loc, &dst_statfs, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to get statfs of %s on %s", loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "min_free_disk - %f , block available - %" PRId64
+                 ", block size - %lu",
+                 conf->min_free_disk, dst_statfs.f_bavail, dst_statfs.f_bsize);
+
+    dst_statfs_blocks = dst_statfs.f_bavail *
+                        (dst_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    src_statfs_blocks = src_statfs.f_bavail *
+                        (src_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    dst_total_blocks = dst_statfs.f_blocks *
+                       (dst_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    src_total_blocks = src_statfs.f_blocks *
+                       (src_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    /* if force option is given, do not check for space @ dst.
+     * Check only if space is avail for the file */
+    if (flag != GF_DHT_MIGRATE_DATA)
+        goto check_avail_space;
+
+    /* Check:
+       During rebalance `migrate-data` - Destination subvol experiences
+       a `reduction` in 'blocks' of free space, at the same time source
+       subvol gains certain 'blocks' of free space. A valid check is
+       necessary here to avoid erroneous move to destination where
+       the space could be scantily available.
+       With heterogeneous brick support, an actual space comparison could
+       prevent any files being migrated to newly added bricks if they are
+       smaller then the free space available on the existing bricks.
+     */
+    if (!conf->use_fallocate) {
+        file_blocks = stbuf->ia_size + GF_DISK_SECTOR_SIZE - 1;
+        file_blocks /= GF_DISK_SECTOR_SIZE;
+
+        if (file_blocks >= dst_statfs_blocks) {
+            dst_statfs_blocks = 0;
+        } else {
+            dst_statfs_blocks -= file_blocks;
+        }
+    }
+
+    src_post_availspacepercent = ((src_statfs_blocks + file_blocks) * 100) /
+                                 src_total_blocks;
+
+    dst_post_availspacepercent = (dst_statfs_blocks * 100) / dst_total_blocks;
+
+    if (dst_post_availspacepercent < src_post_availspacepercent) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "data movement of file "
+               "{blocks:%" PRIu64
+               " name:(%s)} would result in "
+               "dst node (%s:%" PRIu64
+               ") having lower disk "
+               "space than the source node (%s:%" PRIu64
+               ")"
+               ".Skipping file.",
+               stbuf->ia_blocks, loc->path, to->name, dst_statfs_blocks,
+               from->name, src_statfs_blocks);
+
+        /* this is not a 'failure', but we don't want to
+           consider this as 'success' too :-/ */
+        *fop_errno = ENOSPC;
+        ret = 1;
+        goto out;
+    }
 
 check_avail_space:
-
-        if (conf->disk_unit == 'p' && dst_statfs.f_blocks) {
-                post_availspacepercent = (dst_statfs.f_bavail * 100) / dst_statfs.f_blocks;
-                gf_msg_debug (this->name, 0, "file : %s, post_availspacepercent : %lf "
-                              "f_bavail : %lu min-free-disk: %lf", loc->path,
-                              post_availspacepercent, dst_statfs.f_bavail, conf->min_free_disk);
-
-                if (post_availspacepercent < conf->min_free_disk) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0, 0,
-                                "Write will cross min-free-disk for "
-                                "file - %s on subvol - %s. Looking "
-                                "for new subvol", loc->path, to->name);
-
-                        goto find_new_subvol;
-                } else {
-                        ret = 0;
-                        goto out;
-                }
-        }
-
-        if (conf->disk_unit != 'p' &&
-            ((dst_statfs.f_bavail * dst_statfs.f_frsize) < conf->min_free_disk)) {
-                gf_msg_debug (this->name, 0, "file : %s,  destination frsize: %lu "
-                              "f_bavail : %lu min-free-disk: %lf", loc->path,
-                              dst_statfs.f_frsize, dst_statfs.f_bavail, conf->min_free_disk);
-
-                gf_msg (this->name, GF_LOG_WARNING, 0, 0, "Write will cross "
-                        "min-free-disk for file - %s on subvol - %s. Looking "
-                        "for new subvol", loc->path, to->name);
-
-                goto find_new_subvol;
+    if (conf->disk_unit == 'p' && dst_statfs.f_blocks) {
+        dst_post_availspacepercent = (dst_statfs_blocks * 100) /
+                                     dst_total_blocks;
+
+        gf_msg_debug(this->name, 0,
+                     "file : %s, post_availspacepercent"
+                     " : %lf f_bavail : %" PRIu64 " min-free-disk: %lf",
+                     loc->path, dst_post_availspacepercent, dst_statfs.f_bavail,
+                     conf->min_free_disk);
+
+        if (dst_post_availspacepercent < conf->min_free_disk) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, 0,
+                   "Write will cross min-free-disk for "
+                   "file - %s on subvol - %s. Looking "
+                   "for new subvol",
+                   loc->path, to->name);
+
+            goto find_new_subvol;
         } else {
-                ret = 0;
-                goto out;
+            ret = 0;
+            goto out;
         }
+    }
 
+    if (conf->disk_unit != 'p') {
+        if ((dst_statfs_blocks * GF_DISK_SECTOR_SIZE) < conf->min_free_disk) {
+            gf_msg_debug(this->name, 0,
+                         "file : %s,  destination frsize: %lu "
+                         "f_bavail : %" PRIu64 " min-free-disk: %lf",
+                         loc->path, dst_statfs.f_frsize, dst_statfs.f_bavail,
+                         conf->min_free_disk);
 
-find_new_subvol:
-        layout = dht_layout_get (this, loc->parent);
-        if (!layout) {
-                gf_log (this->name, GF_LOG_ERROR, "Layout is NULL");
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
+            gf_msg(this->name, GF_LOG_WARNING, 0, 0,
+                   "write will"
+                   " cross min-free-disk for file - %s on subvol -"
+                   " %s. looking for new subvol",
+                   loc->path, to->name);
 
-        *new_subvol = dht_subvol_with_free_space_inodes (this, to, from, layout,
-                                                         stbuf->ia_size);
-        if ((!(*new_subvol)) || (*new_subvol == from)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_INSUFF_SPACE, "Could not find any subvol"
-                        " with space accomodating the file - %s. Consider adding "
-                        "bricks", loc->path);
+            goto find_new_subvol;
 
-               *target_changed = _gf_false;
-                *fop_errno = ENOSPC;
-                ret = -1;
-                goto out;
         } else {
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "new target found - %s"
-                        " for file - %s", (*new_subvol)->name, loc->path);
-                *target_changed = _gf_true;
-                ret = 0;
-                goto out;
+            ret = 0;
+            goto out;
         }
+    }
 
+find_new_subvol:
+    layout = dht_layout_get(this, loc->parent);
+    if (!layout) {
+        gf_log(this->name, GF_LOG_ERROR, "Layout is NULL");
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    *new_subvol = dht_subvol_with_free_space_inodes(this, to, from, layout,
+                                                    stbuf->ia_size);
+    if ((!(*new_subvol)) || (*new_subvol == from)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+               "Could not find any subvol"
+               " with space accommodating the file - %s. Consider "
+               "adding bricks",
+               loc->path);
+
+        *target_changed = _gf_false;
+        *fop_errno = ENOSPC;
+        ret = -1;
+    } else {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "new target found - %s"
+               " for file - %s",
+               (*new_subvol)->name, loc->path);
+        *target_changed = _gf_true;
         ret = 0;
+    }
+
 out:
-        if (xdata)
-                dict_unref (xdata);
-        return ret;
+    if (xdata)
+        dict_unref(xdata);
+    return ret;
 }
 
 static int
-__dht_rebalance_migrate_data (gf_defrag_info_t *defrag, xlator_t *from,
-                              xlator_t *to, fd_t *src, fd_t *dst,
-                              uint64_t ia_size, int hole_exists,
-                              int *fop_errno)
+__dht_rebalance_migrate_data(xlator_t *this, gf_defrag_info_t *defrag,
+                             xlator_t *from, xlator_t *to, fd_t *src, fd_t *dst,
+                             uint64_t ia_size, int hole_exists, int *fop_errno)
 {
-        int            ret    = 0;
-        int            count  = 0;
-        off_t          offset = 0;
-        struct iovec  *vector = NULL;
-        struct iobref *iobref = NULL;
-        uint64_t       total  = 0;
-        size_t         read_size = 0;
-
-        /* if file size is '0', no need to enter this loop */
-        while (total < ia_size) {
-                read_size = (((ia_size - total) > DHT_REBALANCE_BLKSIZE) ?
-                             DHT_REBALANCE_BLKSIZE : (ia_size - total));
-
-                ret = syncop_readv (from, src, read_size,
-                                    offset, 0, &vector, &count, &iobref, NULL,
-                                    NULL);
-                if (!ret || (ret < 0)) {
+    int ret = 0;
+    int count = 0;
+    off_t offset = 0;
+    off_t data_offset = 0;
+    off_t hole_offset = 0;
+    struct iovec *vector = NULL;
+    struct iobref *iobref = NULL;
+    uint64_t total = 0;
+    size_t read_size = 0;
+    size_t data_block_size = 0;
+    dict_t *xdata = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    /* if file size is '0', no need to enter this loop */
+    while (total < ia_size) {
+        /* This is a regular file - read it sequentially */
+        if (!hole_exists) {
+            read_size = (((ia_size - total) > DHT_REBALANCE_BLKSIZE)
+                             ? DHT_REBALANCE_BLKSIZE
+                             : (ia_size - total));
+        } else {
+            /* This is a sparse file - read only the data segments in the file
+             */
+
+            /* If the previous data block is fully copied, find the next data
+             * segment
+             * starting at the offset of the last read and written byte,  */
+            if (data_block_size <= 0) {
+                ret = syncop_seek(from, src, offset, GF_SEEK_DATA, NULL,
+                                  &data_offset);
+                if (ret) {
+                    if (ret == -ENXIO)
+                        ret = 0; /* No more data segments */
+                    else
+                        *fop_errno = -ret; /* Error occurred */
+
+                    break;
+                }
+
+                /* If the position of the current data segment is greater than
+                 * the position of the next hole, find the next hole in order to
+                 * calculate the length of the new data segment */
+                if (data_offset > hole_offset) {
+                    /* Starting at the offset of the last data segment, find the
+                     * next hole */
+                    ret = syncop_seek(from, src, data_offset, GF_SEEK_HOLE,
+                                      NULL, &hole_offset);
+                    if (ret) {
+                        /* If an error occurred here it's a real error because
+                         * if the seek for a data segment was successful then
+                         * necessarily another hole must exist (EOF is a hole)
+                         */
                         *fop_errno = -ret;
                         break;
-                }
+                    }
 
-                if (hole_exists) {
-                        ret = dht_write_with_holes (to, dst, vector, count,
-                                                    ret, offset, iobref,
-                                                    fop_errno);
-                } else {
-                        ret = syncop_writev (to, dst, vector, count,
-                                             offset, iobref, 0, NULL, NULL);
-                        if (ret < 0) {
-                                *fop_errno = -ret;
-                        }
+                    /* Calculate the total size of the current data block */
+                    data_block_size = hole_offset - data_offset;
                 }
-
-                if ((defrag && defrag->cmd == GF_DEFRAG_CMD_START_TIER) &&
-                    (gf_defrag_get_pause_state (&defrag->tier_conf) != TIER_RUNNING)) {
-                        gf_msg ("tier", GF_LOG_INFO, 0,
-                                DHT_MSG_TIER_PAUSED,
-                                "Migrate file paused");
-                        ret = -1;
+            } else {
+                /* There is still data in the current segment, move the
+                 * data_offset to the position of the last written byte */
+                data_offset = offset;
+            }
+
+            /* Calculate how much data needs to be read and written. If the data
+             * segment's length is bigger than DHT_REBALANCE_BLKSIZE, read and
+             * write DHT_REBALANCE_BLKSIZE data length and the rest in the
+             * next iteration(s) */
+            read_size = ((data_block_size > DHT_REBALANCE_BLKSIZE)
+                             ? DHT_REBALANCE_BLKSIZE
+                             : data_block_size);
+
+            /* Calculate the remaining size of the data block - maybe there's no
+             * need to seek for data in the next iteration */
+            data_block_size -= read_size;
+
+            /* Set offset to the offset of the data segment so read and write
+             * will have the correct position */
+            offset = data_offset;
+        }
+
+        ret = syncop_readv(from, src, read_size, offset, 0, &vector, &count,
+                           &iobref, NULL, NULL, NULL);
+
+        if (!ret || (ret < 0)) {
+            if (!ret) {
+                /* File was probably truncated*/
+                ret = -1;
+                *fop_errno = ENOSPC;
+            } else {
+                *fop_errno = -ret;
+            }
+            break;
+        }
+
+        if (!conf->force_migration) {
+            if (!xdata) {
+                xdata = dict_new();
+                if (!xdata) {
+                    gf_msg("dht", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                           "insufficient memory");
+                    ret = -1;
+                    *fop_errno = ENOMEM;
+                    break;
                 }
 
-                if (ret < 0) {
-                        break;
+                /* Fail this write and abort rebalance if we
+                 * detect a write from client since migration of
+                 * this file started. This is done to avoid
+                 * potential data corruption due to out of order
+                 * writes from rebalance and client to the same
+                 * region (as compared between src and dst
+                 * files). See
+                 * https://github.com/gluster/glusterfs/issues/308
+                 * for more details.
+                 */
+                ret = dict_set_int32_sizen(xdata, GF_AVOID_OVERWRITE, 1);
+                if (ret) {
+                    gf_msg("dht", GF_LOG_ERROR, 0, ENOMEM,
+                           "failed to set dict");
+                    ret = -1;
+                    *fop_errno = ENOMEM;
+                    break;
                 }
+            }
+        }
 
-                offset += ret;
-                total += ret;
-
-                GF_FREE (vector);
-                if (iobref)
-                        iobref_unref (iobref);
-                iobref = NULL;
-                vector = NULL;
+        ret = syncop_writev(to, dst, vector, count, offset, iobref, 0, NULL,
+                            NULL, xdata, NULL);
+        if (ret < 0) {
+            *fop_errno = -ret;
+            break;
         }
+
+        offset += ret;
+        total += ret;
+
+        GF_FREE(vector);
         if (iobref)
-                iobref_unref (iobref);
-        GF_FREE (vector);
+            iobref_unref(iobref);
+        iobref = NULL;
+        vector = NULL;
+    }
+    if (iobref)
+        iobref_unref(iobref);
+    GF_FREE(vector);
+
+    if (ret >= 0)
+        ret = 0;
+    else
+        ret = -1;
 
-        if (ret >= 0)
-                ret = 0;
-        else
-                ret = -1;
+    if (xdata) {
+        dict_unref(xdata);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__dht_rebalance_open_src_file (xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
-                               struct iatt *stbuf, fd_t **src_fd,
-                               gf_boolean_t *clean_src, int *fop_errno)
+__dht_rebalance_open_src_file(xlator_t *this, xlator_t *from, xlator_t *to,
+                              loc_t *loc, struct iatt *stbuf, fd_t **src_fd,
+                              gf_boolean_t *clean_src, int *fop_errno)
 {
-
-        int          ret  = 0;
-        fd_t        *fd   = NULL;
-        dict_t      *dict = NULL;
-        struct iatt  iatt = {0,};
-        dht_conf_t  *conf = NULL;
-
-        conf = this->private;
-
-        *clean_src = _gf_false;
-
-        fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-        if (!fd) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: fd create failed (source)", loc->path);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_open (from, loc, O_RDWR, fd, NULL, NULL);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to open file %s on %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        fd_bind (fd);
-
-        if (src_fd)
-                *src_fd = fd;
-
+    int ret = 0;
+    fd_t *fd = NULL;
+    dict_t *dict = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    *clean_src = _gf_false;
+
+    fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+    if (!fd) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: fd create failed (source)", loc->path);
+        *fop_errno = ENOMEM;
         ret = -1;
-        dict = dict_new ();
-        if (!dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: Could not allocate memory for dict", loc->path);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_str (dict, conf->link_xattr_name, to->name);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to set xattr in dict for %s (linkto:%s)",
-                        loc->path, to->name);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        /* Once the migration starts, the source should have 'linkto' key set
-           to show which is the target, so other clients can work around it */
-        ret = syncop_setxattr (from, loc, dict, 0, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to set xattr on %s in %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+        goto out;
+    }
+
+    ret = syncop_open(from, loc, O_RDWR, fd, NULL, NULL);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to open file %s on %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        /* Reset source mode/xattr if migration fails*/
-        *clean_src = _gf_true;
+    fd_bind(fd);
 
-        /* mode should be (+S+T) to indicate migration is in progress */
-        iatt.ia_prot = stbuf->ia_prot;
-        iatt.ia_type = stbuf->ia_type;
-        iatt.ia_prot.sticky = 1;
-        iatt.ia_prot.sgid = 1;
+    if (src_fd)
+        *src_fd = fd;
 
-        ret = syncop_setattr (from, loc, &iatt, GF_SET_ATTR_MODE, NULL, NULL,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to set mode on %s in %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+    ret = -1;
+    dict = dict_new();
+    if (!dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: Could not allocate memory for dict", loc->path);
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_str(dict, conf->link_xattr_name, to->name);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set xattr in dict for %s (linkto:%s)", loc->path,
+               to->name);
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    /* Once the migration starts, the source should have 'linkto' key set
+       to show which is the target, so other clients can work around it */
+    ret = syncop_setxattr(from, loc, dict, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to set xattr on %s in %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* Reset source mode/xattr if migration fails*/
+    *clean_src = _gf_true;
+
+    /* mode should be (+S+T) to indicate migration is in progress */
+    iatt.ia_prot = stbuf->ia_prot;
+    iatt.ia_type = stbuf->ia_type;
+    iatt.ia_prot.sticky = 1;
+    iatt.ia_prot.sgid = 1;
+
+    ret = syncop_setattr(from, loc, &iatt, GF_SET_ATTR_MODE, NULL, NULL, NULL,
+                         NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to set mode on %s in %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        /* success */
-        ret = 0;
+    /* success */
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int
-migrate_special_files (xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
-                       struct iatt *buf, int *fop_errno)
+migrate_special_files(xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
+                      struct iatt *buf, int *fop_errno)
 {
-        int          ret      = -1;
-        dict_t      *rsp_dict = NULL;
-        dict_t      *dict     = NULL;
-        char        *link     = NULL;
-        struct iatt  stbuf    = {0,};
-        dht_conf_t  *conf     = this->private;
-
-        dict = dict_new ();
-        if (!dict) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
-        }
-
-        /* check in the destination if the file is link file */
-        ret = syncop_lookup (to, loc, &stbuf, NULL, dict, &rsp_dict);
-        if ((ret < 0) && (-ret != ENOENT)) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: lookup failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        /* we no more require this key */
-        dict_del (dict, conf->link_xattr_name);
-
-        /* file exists in target node, only if it is 'linkfile' its valid,
-           otherwise, error out */
-        if (!ret) {
-                if (!check_is_linkfile (loc->inode, &stbuf, rsp_dict,
-                                        conf->link_xattr_name)) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: file exists in destination", loc->path);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-
-                /* as file is linkfile, delete it */
-                ret = syncop_unlink (to, loc, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to delete the linkfile",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        /* Set the gfid of the source file in dict */
-        ret = dict_set_static_bin (dict, "gfid-req", buf->ia_gfid, 16);
+    int ret = -1;
+    dict_t *rsp_dict = NULL;
+    dict_t *dict = NULL;
+    char *link = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    dht_conf_t *conf = this->private;
+
+    dict = dict_new();
+    if (!dict) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_log(this->name, GF_LOG_ERROR,
+               "%s: failed to set 'linkto' key in dict", loc->path);
+        goto out;
+    }
+
+    /* check in the destination if the file is link file */
+    ret = syncop_lookup(to, loc, &stbuf, NULL, dict, &rsp_dict);
+    if ((ret < 0) && (-ret != ENOENT)) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: lookup failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* we no more require this key */
+    dict_del(dict, conf->link_xattr_name);
+
+    /* file exists in target node, only if it is 'linkfile' its valid,
+       otherwise, error out */
+    if (!ret) {
+        if (!check_is_linkfile(loc->inode, &stbuf, rsp_dict,
+                               conf->link_xattr_name)) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: file exists in destination", loc->path);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+
+        /* as file is linkfile, delete it */
+        ret = syncop_unlink(to, loc, NULL, NULL);
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s: failed to set gfid in dict for create", loc->path);
-                goto out;
-        }
-
-        /* Create the file in target */
-        if (IA_ISLNK (buf->ia_type)) {
-                /* Handle symlinks separately */
-                ret = syncop_readlink (from, loc, &link, buf->ia_size, NULL,
-                                       NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: readlink on symlink failed",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_symlink (to, loc, link, 0, dict, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: creating symlink failed",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                goto done;
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to delete the linkfile", loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    /* Set the gfid of the source file in dict */
+    ret = dict_set_gfuuid(dict, "gfid-req", buf->ia_gfid, true);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_log(this->name, GF_LOG_ERROR,
+               "%s: failed to set gfid in dict for create", loc->path);
+        goto out;
+    }
+
+    /* Create the file in target */
+    if (IA_ISLNK(buf->ia_type)) {
+        /* Handle symlinks separately */
+        ret = syncop_readlink(from, loc, &link, buf->ia_size, NULL, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: readlink on symlink failed", loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_mknod (to, loc, st_mode_from_ia (buf->ia_prot,
-                                                      buf->ia_type),
-                            makedev (ia_major (buf->ia_rdev),
-                                     ia_minor (buf->ia_rdev)), 0, dict, NULL);
+        ret = syncop_symlink(to, loc, link, 0, dict, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: mknod failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED, "%s: creating symlink failed",
+                   loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+
+        goto done;
+    }
+
+    ret = syncop_mknod(to, loc, st_mode_from_ia(buf->ia_prot, buf->ia_type),
+                       makedev(ia_major(buf->ia_rdev), ia_minor(buf->ia_rdev)),
+                       0, dict, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: mknod failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
 done:
-        ret = syncop_setattr (to, loc, buf,
-                              (GF_SET_ATTR_MTIME |
-                               GF_SET_ATTR_UID | GF_SET_ATTR_GID |
-                               GF_SET_ATTR_MODE), NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to perform setattr on %s",
-                        loc->path, to->name);
-                *fop_errno = -ret;
-                ret = -1;
-        }
-
-        ret = syncop_unlink (from, loc, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: unlink failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-        }
+    ret = syncop_setattr(to, loc, buf,
+                         (GF_SET_ATTR_MTIME | GF_SET_ATTR_UID |
+                          GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
+                         NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to perform setattr on %s", loc->path, to->name);
+        *fop_errno = -ret;
+    }
+
+    ret = syncop_unlink(from, loc, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: unlink failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+    }
 
 out:
-        GF_FREE (link);
-        if (dict)
-                dict_unref (dict);
+    GF_FREE(link);
+    if (dict)
+        dict_unref(dict);
 
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
 
 static int
-__dht_migration_cleanup_src_file (xlator_t *this, loc_t *loc, fd_t *fd,
-                                  xlator_t *from, ia_prot_t *src_ia_prot)
+__dht_migration_cleanup_src_file(xlator_t *this, loc_t *loc, fd_t *fd,
+                                 xlator_t *from, ia_prot_t *src_ia_prot)
 {
-        int ret                       = -1;
-        dht_conf_t     *conf          = NULL;
-        struct iatt     new_stbuf     = {0,};
-
-        if (!this || !fd || !from || !src_ia_prot) {
-                goto out;
-        }
-
-        conf = this->private;
-
-        /*Revert source mode and xattr changes*/
-        ret = syncop_fstat (from, fd, &new_stbuf, NULL, NULL);
-        if (ret < 0) {
-                /* Failed to get the stat info */
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file cleanup failed: failed to fstat "
-                        "file %s on %s ", loc->path, from->name);
-                ret = -1;
-                goto out;
-        }
-
-
-        /* Remove the sticky bit and sgid bit set, reset it to 0*/
-        if (!src_ia_prot->sticky)
-                new_stbuf.ia_prot.sticky = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    struct iatt new_stbuf = {
+        0,
+    };
+
+    if (!this || !fd || !from || !src_ia_prot) {
+        goto out;
+    }
+
+    conf = this->private;
+
+    /*Revert source mode and xattr changes*/
+    ret = syncop_fstat(from, fd, &new_stbuf, NULL, NULL);
+    if (ret < 0) {
+        /* Failed to get the stat info */
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file cleanup failed: failed to fstat "
+               "file %s on %s ",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
 
-        if (!src_ia_prot->sgid)
-                new_stbuf.ia_prot.sgid = 0;
+    /* Remove the sticky bit and sgid bit set, reset it to 0*/
+    if (!src_ia_prot->sticky)
+        new_stbuf.ia_prot.sticky = 0;
 
-        ret = syncop_fsetattr (from, fd, &new_stbuf,
-                               (GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
-                               NULL, NULL, NULL, NULL);
+    if (!src_ia_prot->sgid)
+        new_stbuf.ia_prot.sgid = 0;
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file cleanup failed:"
-                        "%s: failed to perform fsetattr on %s ",
-                        loc->path, from->name);
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_fsetattr(from, fd, &new_stbuf,
+                          (GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL, NULL,
+                          NULL, NULL);
 
-        ret = syncop_fremovexattr (from, fd, conf->link_xattr_name, 0, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to remove linkto xattr on %s (%s)",
-                        loc->path, from->name, strerror (-ret));
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file cleanup failed:"
+               "%s: failed to perform fsetattr on %s ",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_fremovexattr(from, fd, conf->link_xattr_name, 0, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to remove linkto xattr on %s (%s)", loc->path,
+               from->name, strerror(-ret));
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
-
 /*
   return values:
 
@@ -1451,1002 +1469,1066 @@ out:
     1 : not a failure, but we can't migrate data as of now
 */
 int
-dht_migrate_file (xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
-                  int flag, int *fop_errno)
+dht_migrate_file(xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
+                 int flag, int *fop_errno)
 {
-        int                     ret                     = -1;
-        struct iatt             new_stbuf               = {0,};
-        struct iatt             stbuf                   = {0,};
-        struct iatt             empty_iatt              = {0,};
-        ia_prot_t               src_ia_prot             = {0,};
-        fd_t                    *src_fd                 = NULL;
-        fd_t                    *dst_fd                 = NULL;
-        dict_t                  *dict                   = NULL;
-        dict_t                  *xattr                  = NULL;
-        dict_t                  *xattr_rsp              = NULL;
-        int                     file_has_holes          = 0;
-        dht_conf_t              *conf                   = this->private;
-        int                     rcvd_enoent_from_src    = 0;
-        struct gf_flock         flock                   = {0, };
-        struct gf_flock         plock                   = {0, };
-        loc_t                   tmp_loc                 = {0, };
-        gf_boolean_t            locked                  = _gf_false;
-        gf_boolean_t            p_locked                = _gf_false;
-        int                     lk_ret                  = -1;
-        gf_defrag_info_t        *defrag                 =  NULL;
-        gf_boolean_t            clean_src               = _gf_false;
-        gf_boolean_t            clean_dst               = _gf_false;
-        int                     log_level               = GF_LOG_INFO;
-        gf_boolean_t            delete_src_linkto       = _gf_true;
-        lock_migration_info_t   locklist;
-        dict_t                  *meta_dict              = NULL;
-        gf_boolean_t            meta_locked             = _gf_false;
-        gf_boolean_t            target_changed          = _gf_false;
-        xlator_t                *new_target             = NULL;
-        xlator_t                *old_target             = NULL;
-        fd_t                    *linkto_fd              = NULL;
-
-
-        if (from == to) {
-                gf_msg_debug (this->name, 0, "destination and source are same. file %s"
-                              " might have migrated already", loc->path);
-                ret = 0;
-                goto out;
-        }
-
-        /* If defrag is NULL, it should be assumed that migration is triggered
-         * from client */
-        defrag = conf->defrag;
-
-        /* migration of files from clients is restricted to non-tiered clients
-         * for now */
-        if (!defrag && dht_is_tier_xlator (this)) {
-                ret = ENOTSUP;
-                goto out;
-        }
-
-        if (defrag && defrag->tier_conf.is_tier)
-                log_level = GF_LOG_TRACE;
-
-        gf_log (this->name,
-                log_level, "%s: attempting to move from %s to %s",
-                loc->path, from->name, to->name);
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "Could not allocate memory for dict");
-                goto out;
-        }
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
-        }
-
-
-        /* Do not migrate file in case lock migration is not enabled on the
-         * volume*/
-        if (!conf->lock_migration_enabled) {
-                ret = dict_set_int32 (dict,
-                                 GLUSTERFS_POSIXLK_COUNT, sizeof(int32_t));
-                if (ret) {
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: %s: failed to "
-                                "set "GLUSTERFS_POSIXLK_COUNT" key in dict",
-                                loc->path);
-                        goto out;
-                }
-        } else {
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "locks will be migrated"
-                        " for file: %s", loc->path);
-        }
-
-        flock.l_type = F_WRLCK;
-
-        tmp_loc.inode = inode_ref (loc->inode);
-        gf_uuid_copy (tmp_loc.gfid, loc->gfid);
-        tmp_loc.path = gf_strdup(loc->path);
-
-        /* this inodelk happens with flock.owner being zero. But to synchronize
-         * hardlink migration we need to have different lkowner for each migration
-         * Filed a bug here: https://bugzilla.redhat.com/show_bug.cgi?id=1468202 to
-         * track the fix for this. Currently synclock takes care of synchronizing
-         * hardlink migration. Once this bug is fixed we can avoid taking synclock */
-        ret = syncop_inodelk (from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc, F_SETLKW,
-                              &flock, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "migrate file failed: "
-                        "%s: failed to lock file on %s",
-                        loc->path, from->name);
-                goto out;
-        }
+    int ret = -1;
+    struct iatt new_stbuf = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    struct iatt empty_iatt = {
+        0,
+    };
+    ia_prot_t src_ia_prot = {
+        0,
+    };
+    fd_t *src_fd = NULL;
+    fd_t *dst_fd = NULL;
+    dict_t *dict = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xattr_rsp = NULL;
+    int file_has_holes = 0;
+    dht_conf_t *conf = this->private;
+    int rcvd_enoent_from_src = 0;
+    struct gf_flock flock = {
+        0,
+    };
+    struct gf_flock plock = {
+        0,
+    };
+    loc_t tmp_loc = {
+        0,
+    };
+    loc_t parent_loc = {
+        0,
+    };
+    gf_boolean_t inodelk_locked = _gf_false;
+    gf_boolean_t entrylk_locked = _gf_false;
+    gf_boolean_t p_locked = _gf_false;
+    int lk_ret = -1;
+    gf_defrag_info_t *defrag = NULL;
+    gf_boolean_t clean_src = _gf_false;
+    gf_boolean_t clean_dst = _gf_false;
+    int log_level = GF_LOG_INFO;
+    gf_boolean_t delete_src_linkto = _gf_true;
+    lock_migration_info_t locklist;
+    dict_t *meta_dict = NULL;
+    gf_boolean_t meta_locked = _gf_false;
+    gf_boolean_t target_changed = _gf_false;
+    xlator_t *new_target = NULL;
+    xlator_t *old_target = NULL;
+    xlator_t *hashed_subvol = NULL;
+    fd_t *linkto_fd = NULL;
+    dict_t *xdata = NULL;
+
+    if (from == to) {
+        gf_msg_debug(this->name, 0,
+                     "destination and source are same. file %s"
+                     " might have migrated already",
+                     loc->path);
+        ret = 0;
+        goto out;
+    }
 
-        locked = _gf_true;
+    gf_log(this->name, log_level, "%s: attempting to move from %s to %s",
+           loc->path, from->name, to->name);
 
-        /* Phase 1 - Data migration is in progress from now on */
-        ret = syncop_lookup (from, loc, &stbuf, NULL, dict, &xattr_rsp);
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "Could not allocate memory for dict");
+        goto out;
+    }
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to set 'linkto' key in dict",
+               loc->path);
+        goto out;
+    }
+
+    /* Do not migrate file in case lock migration is not enabled on the
+     * volume*/
+    if (!conf->lock_migration_enabled) {
+        ret = dict_set_int32(dict, GLUSTERFS_POSIXLK_COUNT, sizeof(int32_t));
         if (ret) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: lookup failed on %s",
-                        loc->path, from->name);
-               goto out;
-        }
-
-        /* preserve source mode, so set the same to the destination */
-        src_ia_prot = stbuf.ia_prot;
-
-        /* Check if file can be migrated */
-        ret = __is_file_migratable (this, loc, &stbuf, xattr_rsp, flag, defrag, conf,
-                                    fop_errno);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: %s: failed to "
+                   "set " GLUSTERFS_POSIXLK_COUNT " key in dict",
+                   loc->path);
+            goto out;
+        }
+    } else {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "locks will be migrated"
+               " for file: %s",
+               loc->path);
+    }
+
+    /* The file is locked to prevent a rename during a migration. Renames
+     * and migrations on the file at the same time can lead to data loss.
+     */
+
+    ret = dht_build_parent_loc(this, &parent_loc, loc, fop_errno);
+    if (ret < 0) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to build parent loc, which is needed to "
+               "acquire entrylk to synchronize with renames on this "
+               "path. Skipping migration",
+               loc->path);
+        goto out;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, EINVAL, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: cannot find hashed subvol which is needed to "
+               "synchronize with renames on this path. "
+               "Skipping migration",
+               loc->path);
+        goto out;
+    }
+
+    flock.l_type = F_WRLCK;
+
+    tmp_loc.inode = inode_ref(loc->inode);
+    gf_uuid_copy(tmp_loc.gfid, loc->gfid);
+    tmp_loc.path = gf_strdup(loc->path);
+
+    /* this inodelk happens with flock.owner being zero. But to synchronize
+     * hardlink migration we need to have different lkowner for each migration
+     * Filed a bug here: https://bugzilla.redhat.com/show_bug.cgi?id=1468202 to
+     * track the fix for this. Currently synclock takes care of synchronizing
+     * hardlink migration. Once this bug is fixed we can avoid taking synclock
+     */
+    ret = syncop_inodelk(from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc, F_SETLKW,
+                         &flock, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "migrate file failed: "
+               "%s: failed to lock file on %s",
+               loc->path, from->name);
+        goto out;
+    }
+
+    inodelk_locked = _gf_true;
+
+    /* dht_rename has changed to use entrylk on hashed subvol for
+     * synchronization. So, rebalance too has to acquire an entrylk on
+     * hashed subvol.
+     */
+    ret = syncop_entrylk(hashed_subvol, DHT_ENTRY_SYNC_DOMAIN, &parent_loc,
+                         loc->name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to acquire entrylk on subvol %s", loc->path,
+               hashed_subvol->name);
+        goto out;
+    }
+
+    entrylk_locked = _gf_true;
+
+    /* Phase 1 - Data migration is in progress from now on */
+    ret = syncop_lookup(from, loc, &stbuf, NULL, dict, &xattr_rsp);
+    if (ret) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: lookup failed on %s",
+               loc->path, from->name);
+        goto out;
+    }
+
+    /* preserve source mode, so set the same to the destination */
+    src_ia_prot = stbuf.ia_prot;
+
+    /* Check if file can be migrated */
+    ret = __is_file_migratable(this, loc, &stbuf, xattr_rsp, flag, defrag, conf,
+                               fop_errno);
+    if (ret) {
+        if (ret == HARDLINK_MIG_INPROGRESS)
+            ret = 0;
+        goto out;
+    }
+
+    /* Take care of the special files */
+    if (!IA_ISREG(stbuf.ia_type)) {
+        /* Special files */
+        ret = migrate_special_files(this, from, to, loc, &stbuf, fop_errno);
+        goto out;
+    }
+
+    /* Try to preserve 'holes' while migrating data */
+    if (stbuf.ia_size > (stbuf.ia_blocks * GF_DISK_SECTOR_SIZE))
+        file_has_holes = 1;
+
+    /* create the destination, with required modes/xattr */
+    ret = __dht_rebalance_create_dst_file(this, to, from, loc, &stbuf, &dst_fd,
+                                          fop_errno, file_has_holes);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+               "Create dst failed"
+               " on - %s for file - %s",
+               to->name, loc->path);
+        goto out;
+    }
+
+    clean_dst = _gf_true;
+
+    ret = __dht_check_free_space(this, to, from, loc, &stbuf, flag, conf,
+                                 &target_changed, &new_target, fop_errno);
+    if (target_changed) {
+        /* Can't handle for hardlinks. Marking this as failure */
+        if (flag == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS || stbuf.ia_nlink > 1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+                   "Exiting migration for"
+                   " file - %s. flag - %d, stbuf.ia_nlink - %d",
+                   loc->path, flag, stbuf.ia_nlink);
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncop_ftruncate(to, dst_fd, 0, NULL, NULL, NULL, NULL);
         if (ret) {
-                if (ret == -2)
-                        ret = 0;
-                goto out;
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s: failed to perform truncate on %s (%s)", loc->path,
+                   to->name, strerror(-ret));
         }
 
-        /* Take care of the special files */
-        if (!IA_ISREG (stbuf.ia_type)) {
-                /* Special files */
-                ret = migrate_special_files (this, from, to, loc, &stbuf,
-                                             fop_errno);
-                goto out;
-        }
+        syncop_close(dst_fd);
+        dst_fd = NULL;
 
+        old_target = to;
+        to = new_target;
 
-        /* TODO: move all xattr related operations to fd based operations */
-        ret = syncop_listxattr (from, loc, &xattr, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to get xattr from %s",
-                        loc->path, from->name);
-        }
+        clean_dst = _gf_false;
 
-        /* create the destination, with required modes/xattr */
-        ret = __dht_rebalance_create_dst_file (this, to, from, loc, &stbuf,
-                                               &dst_fd, xattr, fop_errno);
+        /* if the file migration is successful to this new target, then
+         * update the xattr on the old destination to point the new
+         * destination. We need to do update this only post migration
+         * as in case of failure the linkto needs to point to the source
+         * subvol */
+        ret = __dht_rebalance_create_dst_file(
+            this, to, from, loc, &stbuf, &dst_fd, fop_errno, file_has_holes);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0, "Create dst failed"
-                        " on - %s for file - %s", to->name, loc->path);
-                goto out;
-        }
-
-        clean_dst = _gf_true;
-
-        ret = __dht_check_free_space (this, to, from, loc, &stbuf, flag, conf,
-                                      &target_changed, &new_target, fop_errno);
-        if (target_changed) {
-                /* Can't handle for hardlinks. Marking this as failure */
-                if (flag == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS || stbuf.ia_nlink > 1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SUBVOL_INSUFF_SPACE, "Exiting migration for"
-                                " file - %s. flag - %d, stbuf.ia_nlink - %d",
-                               loc->path,  flag, stbuf.ia_nlink);
-                        ret = -1;
-                        goto out;
-                }
-
-
-                ret = syncop_ftruncate (to, dst_fd, 0, NULL, NULL);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "%s: failed to perform truncate on %s (%s)",
-                                loc->path, to->name, strerror (-ret));
-                        ret = -1;
-                }
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Create dst failed"
+                   " on - %s for file - %s",
+                   to->name, loc->path);
+            goto out;
+        } else {
+            gf_msg(this->name, GF_LOG_INFO, 0, 0,
+                   "destination for file "
+                   "- %s is changed to - %s",
+                   loc->path, to->name);
+            clean_dst = _gf_true;
+        }
+    }
+
+    if (ret) {
+        goto out;
+    }
+
+    /* Open the source, and also update mode/xattr */
+    ret = __dht_rebalance_open_src_file(this, from, to, loc, &stbuf, &src_fd,
+                                        &clean_src, fop_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: failed to open %s on %s", loc->path,
+               from->name);
+        goto out;
+    }
+
+    /* TODO: move all xattr related operations to fd based operations */
+    ret = syncop_listxattr(from, loc, &xattr, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to get xattr from %s",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
+
+    /* Copying posix acls to the linkto file messes up the permissions*/
+    dht_strip_out_acls(xattr);
+
+    /* Remove the linkto xattr as we don't want to overwrite the value
+     * set on the dst.
+     */
+    dict_del(xattr, conf->link_xattr_name);
+
+    /* We need to error out if this fails as having the wrong shard xattrs
+     * set on the dst could cause data corruption
+     */
+    ret = syncop_fsetxattr(to, dst_fd, xattr, 0, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to set xattr on %s", loc->path, to->name);
+        ret = -1;
+        goto out;
+    }
 
-                syncop_close (dst_fd);
-                dst_fd = NULL;
+    if (xattr_rsp) {
+        /* we no more require this key */
+        dict_del(dict, conf->link_xattr_name);
+        dict_unref(xattr_rsp);
+    }
+
+    ret = syncop_fstat(from, src_fd, &stbuf, dict, &xattr_rsp);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:failed to lookup %s on %s ", loc->path,
+               from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* Check again if file has hardlink */
+    ret = __check_file_has_hardlink(this, loc, &stbuf, xattr_rsp, flag, defrag,
+                                    conf, fop_errno);
+    if (ret) {
+        if (ret == HARDLINK_MIG_INPROGRESS)
+            ret = 0;
+        goto out;
+    }
+
+    ret = __dht_rebalance_migrate_data(this, defrag, from, to, src_fd, dst_fd,
+                                       stbuf.ia_size, file_has_holes,
+                                       fop_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: %s: failed to migrate data", loc->path);
 
-                old_target = to;
-                to = new_target;
+        ret = -1;
+        goto out;
+    }
+
+    /* TODO: Sync the locks */
+
+    xdata = dict_new();
+    if (!xdata || dict_set_int8(xdata, "last-fsync", 1)) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "%s: failed to set last-fsync flag on "
+               "%s (%s)",
+               loc->path, to->name, strerror(ENOMEM));
+    }
+
+    ret = syncop_fsync(to, dst_fd, 0, NULL, NULL, xdata, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "%s: failed to fsync on %s (%s)",
+               loc->path, to->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* Phase 2 - Data-Migration Complete, Housekeeping updates pending */
+
+    ret = syncop_fstat(from, src_fd, &new_stbuf, NULL, NULL);
+    if (ret < 0) {
+        /* Failed to get the stat info */
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: failed to fstat file %s on %s ", loc->path,
+               from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-                clean_dst = _gf_false;
+    /* Lock the entire source file to prevent clients from taking a
+       lock on it as dht_lk does not handle file migration.
 
+       This still leaves a small window where conflicting locks can
+       be granted to different clients. If client1 requests a blocking
+       lock on the src file, it will be granted after the migrating
+       process releases its lock. If client2 requests a lock on the dst
+       data file, it will also be granted, but all FOPs will be redirected
+       to the dst data file.
+    */
 
-                /* if the file migration is successful to this new target, then
-                 * update the xattr on the old destination to point the new
-                 * destination. We need to do update this only post migration
-                 * as in case of failure the linkto needs to point to the source
-                 * subvol */
-                ret = __dht_rebalance_create_dst_file (this, to, from, loc, &stbuf,
-                                                       &dst_fd, xattr, fop_errno);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "Create dst failed"
-                                " on - %s for file - %s", to->name, loc->path);
-                        goto out;
-                } else {
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0, "destination for file "
-                                "- %s is changed to - %s", loc->path, to->name);
-                        clean_dst = _gf_true;
-                }
-        }
+    /* Take meta lock  */
 
-        if (ret) {
-                goto out;
-        }
+    if (conf->lock_migration_enabled) {
+        meta_dict = dict_new();
+        if (!meta_dict) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "dict_new failed");
 
-        /* Open the source, and also update mode/xattr */
-        ret = __dht_rebalance_open_src_file (this, from, to, loc, &stbuf, &src_fd,
-                                             &clean_src, fop_errno);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: failed to open %s on %s",
-                        loc->path, from->name);
-                goto out;
-        }
-        if (xattr_rsp) {
-                /* we no more require this key */
-                dict_del (dict, conf->link_xattr_name);
-                dict_unref (xattr_rsp);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_fstat (from, src_fd, &stbuf, dict, &xattr_rsp);
+        ret = dict_set_str(meta_dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:failed to lookup %s on %s ",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value: key = %s,"
+                   " path = %s",
+                   GLUSTERFS_INTERNAL_FOP_KEY, loc->path);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        /* Check again if file has hardlink */
-        ret = __check_file_has_hardlink (this, loc, &stbuf, xattr_rsp,
-                                         flag, defrag, conf, fop_errno);
+        ret = dict_set_int32(meta_dict, GF_META_LOCK_KEY, 1);
         if (ret) {
-                if (ret == -2)
-                        ret = 0;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
-        /* Try to preserve 'holes' while migrating data */
-        if (stbuf.ia_size > (stbuf.ia_blocks * GF_DISK_SECTOR_SIZE))
-                file_has_holes = 1;
-
 
-        ret = __dht_rebalance_migrate_data (defrag, from, to, src_fd, dst_fd,
-                                            stbuf.ia_size,
-                                            file_has_holes, fop_errno);
+        ret = syncop_setxattr(from, loc, meta_dict, 0, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: %s: failed to migrate data",
-                        loc->path);
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace syncop_setxattr metalock failed");
 
-                ret = -1;
-                goto out;
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        } else {
+            meta_locked = _gf_true;
         }
+    }
 
-        /* TODO: Sync the locks */
+    if (!conf->lock_migration_enabled) {
+        plock.l_type = F_WRLCK;
+        plock.l_start = 0;
+        plock.l_len = 0;
+        plock.l_whence = SEEK_SET;
 
-        ret = syncop_fsync (to, dst_fd, 0, NULL, NULL);
+        ret = syncop_lk(from, src_fd, F_SETLK, &plock, NULL, NULL);
         if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to fsync on %s (%s)",
-                        loc->path, to->name, strerror (-ret));
-                *fop_errno = -ret;
-                ret = -1;
-        }
-
-
-        /* Phase 2 - Data-Migration Complete, Housekeeping updates pending */
-
-        ret = syncop_fstat (from, src_fd, &new_stbuf, NULL, NULL);
-        if (ret < 0) {
-                /* Failed to get the stat info */
-                gf_msg ( this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: failed to fstat file %s on %s ",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: Failed to lock on %s",
+                   loc->path, from->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        /* Lock the entire source file to prevent clients from taking a
-           lock on it as dht_lk does not handle file migration.
+        p_locked = _gf_true;
 
-           This still leaves a small window where conflicting locks can
-           be granted to different clients. If client1 requests a blocking
-           lock on the src file, it will be granted after the migrating
-           process releases its lock. If client2 requests a lock on the dst
-           data file, it will also be granted, but all FOPs will be redirected
-           to the dst data file.
-        */
-
-        /* Take meta lock  */
-
-        if (conf->lock_migration_enabled) {
-                meta_dict = dict_new ();
-                if (!meta_dict) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "dict_new failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_set_str (meta_dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value: key = %s,"
-                                " path = %s", GLUSTERFS_INTERNAL_FOP_KEY,
-                                 loc->path);
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
+    } else {
+        INIT_LIST_HEAD(&locklist.list);
 
-                ret = dict_set_int32 (meta_dict, GF_META_LOCK_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_setxattr (from, loc, meta_dict, 0, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace syncop_setxattr metalock failed");
-
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                } else {
-                        meta_locked = _gf_true;
-                }
-        }
-
-        if (!conf->lock_migration_enabled) {
-                plock.l_type = F_WRLCK;
-                plock.l_start = 0;
-                plock.l_len = 0;
-                plock.l_whence = SEEK_SET;
-
-                ret = syncop_lk (from, src_fd, F_SETLK, &plock, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: Failed to lock on %s",
-                                loc->path, from->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                p_locked = _gf_true;
-
-        } else {
-
-                INIT_LIST_HEAD (&locklist.list);
-
-                ret = syncop_getactivelk (from, loc, &locklist, NULL, NULL);
-                if (ret == 0) {
-                        gf_log (this->name, GF_LOG_INFO, "No active locks on:%s"
-                                , loc->path);
-
-                } else if (ret > 0) {
-
-                        ret = syncop_setactivelk (to, loc, &locklist, NULL,
-                                                  NULL);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                        DHT_MSG_LOCK_MIGRATION_FAILED,
-                                        "write lock failed on:%s", loc->path);
-
-                                *fop_errno = -ret;
-                                ret = -1;
-                                goto metaunlock;
-                        }
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_LOCK_MIGRATION_FAILED,
-                                "getactivelk failed for file: %s", loc->path);
-                        *fop_errno = -ret;
-                }
-        }
-
-
-        /* source would have both sticky bit and sgid bit set, reset it to 0,
-           and set the source permission on destination, if it was not set
-           prior to setting rebalance-modes in source  */
-        if (!src_ia_prot.sticky)
-                new_stbuf.ia_prot.sticky = 0;
-
-        if (!src_ia_prot.sgid)
-                new_stbuf.ia_prot.sgid = 0;
+        ret = syncop_getactivelk(from, loc, &locklist, NULL, NULL);
+        if (ret == 0) {
+            gf_log(this->name, GF_LOG_INFO, "No active locks on:%s", loc->path);
 
-        /* TODO: if the source actually had sticky bit, or sgid bit set,
-           we are not handling it */
+        } else if (ret > 0) {
+            ret = syncop_setactivelk(to, loc, &locklist, NULL, NULL);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, -ret,
+                       DHT_MSG_LOCK_MIGRATION_FAILED, "write lock failed on:%s",
+                       loc->path);
 
-        ret = syncop_fsetattr (to, dst_fd, &new_stbuf,
-                               (GF_SET_ATTR_UID | GF_SET_ATTR_GID |
-                                GF_SET_ATTR_MODE), NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, to->name);
                 *fop_errno = -ret;
                 ret = -1;
                 goto metaunlock;
-        }
-
-        /* Because 'futimes' is not portable */
-        ret = syncop_setattr (to, loc, &new_stbuf,
-                              (GF_SET_ATTR_MTIME | GF_SET_ATTR_ATIME),
-                              NULL, NULL, NULL, NULL);
+            }
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret,
+                   DHT_MSG_LOCK_MIGRATION_FAILED,
+                   "getactivelk failed for file: %s", loc->path);
+            *fop_errno = -ret;
+        }
+    }
+
+    /* source would have both sticky bit and sgid bit set, reset it to 0,
+       and set the source permission on destination, if it was not set
+       prior to setting rebalance-modes in source  */
+    if (!src_ia_prot.sticky)
+        new_stbuf.ia_prot.sticky = 0;
+
+    if (!src_ia_prot.sgid)
+        new_stbuf.ia_prot.sgid = 0;
+
+    /* TODO: if the source actually had sticky bit, or sgid bit set,
+       we are not handling it */
+
+    ret = syncop_fsetattr(
+        to, dst_fd, &new_stbuf,
+        (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL, NULL,
+        NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to perform setattr on %s ",
+               loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto metaunlock;
+    }
+
+    /* Because 'futimes' is not portable */
+    ret = syncop_setattr(to, loc, &new_stbuf,
+                         (GF_SET_ATTR_MTIME | GF_SET_ATTR_ATIME), NULL, NULL,
+                         NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform setattr on %s ", loc->path, to->name);
+        *fop_errno = -ret;
+    }
+
+    if (target_changed) {
+        dict_del(dict, GLUSTERFS_POSIXLK_COUNT);
+        ret = dict_set_str(dict, conf->link_xattr_name, to->name);
         if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, to->name);
-                *fop_errno = -ret;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set xattr in dict for %s (linkto:%s)", loc->path,
+                   to->name);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncop_setxattr(old_target, loc, dict, 0, NULL, NULL);
+        if (ret && -ret != ESTALE && -ret != ENOENT) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to set xattr on %s in %s", loc->path,
+                   old_target->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        } else if (-ret == ESTALE || -ret == ENOENT) {
+            /* The failure ESTALE indicates that the linkto
+             * file on the hashed subvol might have been deleted.
+             * In this case will create a linkto file with new target
+             * as linkto xattr value*/
+            linkto_fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+            if (!linkto_fd) {
+                gf_msg(this->name, GF_LOG_ERROR, errno,
+                       DHT_MSG_MIGRATE_FILE_FAILED, "%s: fd create failed",
+                       loc->path);
+                *fop_errno = ENOMEM;
                 ret = -1;
-        }
-
-        if (target_changed) {
-               if (!dict) {
-                        dict = dict_new ();
-                        if (!dict) {
-                                *fop_errno = ENOMEM;
-                                ret = -1;
-                                goto out;
-                        }
-               } else {
-                        dict_del (dict, conf->link_xattr_name);
-                        dict_del (dict, GLUSTERFS_POSIXLK_COUNT);
-                        ret = dict_set_str (dict, conf->link_xattr_name, to->name);
-                         if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to set xattr in dict for %s (linkto:%s)",
-                                        loc->path, to->name);
-                                *fop_errno = ENOMEM;
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = syncop_setxattr (old_target, loc, dict, 0, NULL, NULL);
-                        if (ret && -ret != ESTALE && -ret != ENOENT) {
-                                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "failed to set xattr on %s in %s",
-                                        loc->path, old_target->name);
-                                *fop_errno = -ret;
-                                ret = -1;
-                                goto out;
-                        } else if (-ret == ESTALE || -ret == ENOENT) {
-                               /* The failure ESTALE indicates that the linkto
-                                * file on the hashed subvol might have been deleted.
-                                * In this case will create a linkto file with new target
-                                * as linkto xattr value*/
-                                linkto_fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-                                if (!linkto_fd) {
-                                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "%s: fd create failed",
-                                                loc->path);
-                                        *fop_errno = ENOMEM;
-                                        ret = -1;
-                                        goto out;
-                                }
-                                ret = syncop_create (old_target, loc, O_RDWR,
-                                                     DHT_LINKFILE_MODE, linkto_fd,
-                                                     NULL, dict, NULL);
-                                if (ret != 0 && -ret != EEXIST && -ret != ESTALE) {
-                                        *fop_errno = -ret;
-                                        ret = -1;
-                                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "failed to create linkto file on %s in %s",
-                                                loc->path, old_target->name);
-                                        goto out;
-                                } else if (ret == 0) {
-                                        ret = syncop_fsetattr (old_target, linkto_fd, &stbuf,
-                                                               (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
-                                                               NULL, NULL, NULL, NULL);
-                                        if (ret < 0)
-                                                *fop_errno = -ret;
-                                                gf_msg (this->name, GF_LOG_ERROR,
-                                                -ret, DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "chown failed for %s on %s",
-                                                loc->path, old_target->name);
-                                }
-                        }
-               }
-        }
-
-        clean_dst = _gf_false;
-
-        /* Posix acls are not set on DHT linkto files as part of the initial
-         * initial xattrs set on the dst file, so these need
-         * to be set on the dst file after the linkto attrs are removed.
-         * TODO: Optimize this.
-         */
-        if (xattr) {
-                dict_unref (xattr);
-                xattr = NULL;
-        }
-
-        ret = syncop_listxattr (from, loc, &xattr, NULL, NULL);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to get xattr from %s",
-                        loc->path, from->name);
+                goto out;
+            }
+            ret = syncop_create(old_target, loc, O_RDWR, DHT_LINKFILE_MODE,
+                                linkto_fd, NULL, dict, NULL);
+            if (ret != 0 && -ret != EEXIST && -ret != ESTALE) {
                 *fop_errno = -ret;
                 ret = -1;
-        } else {
-                ret = syncop_setxattr (to, loc, xattr, 0, NULL, NULL);
+                gf_msg(this->name, GF_LOG_ERROR, -ret,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "failed to create linkto file on %s in %s", loc->path,
+                       old_target->name);
+                goto out;
+            } else if (ret == 0) {
+                ret = syncop_fsetattr(old_target, linkto_fd, &stbuf,
+                                      (GF_SET_ATTR_UID | GF_SET_ATTR_GID), NULL,
+                                      NULL, NULL, NULL);
                 if (ret < 0) {
-                        /* Potential problem here where Posix ACLs will
-                         * not be set on the target file */
-
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: failed to set xattr on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                }
-        }
-
-        /* store size of previous migrated file  */
-        if (defrag && defrag->tier_conf.is_tier) {
-                if (from != TIER_HASHED_SUBVOL) {
-                        defrag->tier_conf.st_last_promoted_size = stbuf.ia_size;
-                } else {
-                        /* Don't delete the linkto file on the hashed subvol */
-                        delete_src_linkto = _gf_false;
-                        defrag->tier_conf.st_last_demoted_size = stbuf.ia_size;
+                    *fop_errno = -ret;
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_MIGRATE_FILE_FAILED,
+                           "chown failed for %s on %s", loc->path,
+                           old_target->name);
                 }
-        }
-
-        /* The src file is being unlinked after this so we don't need
-           to clean it up */
-        clean_src = _gf_false;
-
-        /* Make the source as a linkfile first before deleting it */
-        empty_iatt.ia_prot.sticky = 1;
-        ret = syncop_fsetattr (from, src_fd, &empty_iatt,
-                               GF_SET_ATTR_MODE, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto metaunlock;
-        }
-
-       /* Free up the data blocks on the source node, as the whole
-           file is migrated */
-        ret = syncop_ftruncate (from, src_fd, 0, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform truncate on %s (%s)",
-                        loc->path, from->name, strerror (-ret));
-                *fop_errno = -ret;
-                ret = -1;
-        }
-
-        /* remove the 'linkto' xattr from the destination */
-        ret = syncop_fremovexattr (to, dst_fd, conf->link_xattr_name, 0, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform removexattr on %s (%s)",
-                        loc->path, to->name, strerror (-ret));
-                *fop_errno = -ret;
-                ret = -1;
-        }
-
-        /* Do a stat and check the gfid before unlink */
-
-        /*
-         * Cached file changes its state from non-linkto to linkto file after
-         * migrating data. If lookup from any other mount-point is performed,
-         * converted-linkto-cached file will be treated as a stale and will be
-         * unlinked. But by this time, file is already migrated. So further
-         * failure because of ENOENT should  not be treated as error
-         */
-
-        ret = syncop_stat (from, loc, &empty_iatt, NULL, NULL);
+            }
+        }
+    }
+
+    clean_dst = _gf_false;
+
+    /* Posix acls are not set on DHT linkto files as part of the initial
+     * initial xattrs set on the dst file, so these need
+     * to be set on the dst file after the linkto attrs are removed.
+     * TODO: Optimize this.
+     */
+    if (xattr) {
+        dict_unref(xattr);
+        xattr = NULL;
+    }
+
+    /* Set only the Posix ACLs this time */
+    ret = syncop_getxattr(from, loc, &xattr, POSIX_ACL_ACCESS_XATTR, NULL,
+                          NULL);
+    if (ret < 0) {
+        if ((-ret != ENODATA) && (-ret != ENOATTR)) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: failed to get xattr from %s",
+                   loc->path, from->name);
+            *fop_errno = -ret;
+        }
+    } else {
+        ret = syncop_setxattr(to, loc, xattr, 0, NULL, NULL);
+        if (ret < 0) {
+            /* Potential problem here where Posix ACLs will
+             * not be set on the target file */
+
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: failed to set xattr on %s",
+                   loc->path, to->name);
+            *fop_errno = -ret;
+        }
+    }
+
+    /* The src file is being unlinked after this so we don't need
+       to clean it up */
+    clean_src = _gf_false;
+
+    /* Make the source as a linkfile first before deleting it */
+    empty_iatt.ia_prot.sticky = 1;
+    ret = syncop_fsetattr(from, src_fd, &empty_iatt, GF_SET_ATTR_MODE, NULL,
+                          NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to perform setattr on %s ",
+               loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto metaunlock;
+    }
+
+    /* Free up the data blocks on the source node, as the whole
+        file is migrated */
+    ret = syncop_ftruncate(from, src_fd, 0, NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform truncate on %s (%s)", loc->path,
+               from->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* remove the 'linkto' xattr from the destination */
+    ret = syncop_fremovexattr(to, dst_fd, conf->link_xattr_name, 0, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform removexattr on %s (%s)", loc->path,
+               to->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* Do a stat and check the gfid before unlink */
+
+    /*
+     * Cached file changes its state from non-linkto to linkto file after
+     * migrating data. If lookup from any other mount-point is performed,
+     * converted-linkto-cached file will be treated as a stale and will be
+     * unlinked. But by this time, file is already migrated. So further
+     * failure because of ENOENT should  not be treated as error
+     */
+
+    ret = syncop_stat(from, loc, &empty_iatt, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to do a stat on %s", loc->path, from->name);
+
+        if (-ret != ENOENT) {
+            *fop_errno = -ret;
+            ret = -1;
+            goto metaunlock;
+        }
+
+        rcvd_enoent_from_src = 1;
+    }
+
+    if ((gf_uuid_compare(empty_iatt.ia_gfid, loc->gfid) == 0) &&
+        (!rcvd_enoent_from_src) && delete_src_linkto) {
+        /* take out the source from namespace */
+        ret = syncop_unlink(from, loc, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to do a stat on %s",
-                        loc->path, from->name);
-
-                if (-ret != ENOENT) {
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto metaunlock;
-                }
-
-                rcvd_enoent_from_src = 1;
-        }
-
-
-        if ((gf_uuid_compare (empty_iatt.ia_gfid, loc->gfid) == 0 ) &&
-            (!rcvd_enoent_from_src) && delete_src_linkto) {
-                /* take out the source from namespace */
-                ret = syncop_unlink (from, loc, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to perform unlink on %s",
-                                loc->path, from->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto metaunlock;
-                }
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to perform unlink on %s", loc->path, from->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto metaunlock;
         }
+    }
 
-        ret = syncop_lookup (this, loc, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "%s: failed to lookup the file on subvolumes",
-                              loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-        }
+    ret = syncop_lookup(this, loc, NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "%s: failed to lookup the file on subvolumes", loc->path);
+        *fop_errno = -ret;
+    }
 
-        gf_msg (this->name, log_level, 0,
-                DHT_MSG_MIGRATE_FILE_COMPLETE,
-                "completed migration of %s from subvolume %s to %s",
-                loc->path, from->name, to->name);
+    gf_msg(this->name, log_level, 0, DHT_MSG_MIGRATE_FILE_COMPLETE,
+           "completed migration of %s from subvolume %s to %s", loc->path,
+           from->name, to->name);
 
-        ret = 0;
+    ret = 0;
 
 metaunlock:
 
-        if (conf->lock_migration_enabled && meta_locked) {
-
-                dict_del (meta_dict, GF_META_LOCK_KEY);
-
-                ret = dict_set_int32 (meta_dict, GF_META_UNLOCK_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (clean_dst == _gf_false)
-                        ret = dict_set_int32 (meta_dict, "status", 1);
-                else
-                        ret = dict_set_int32 (meta_dict, "status", 0);
-
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
+    if (conf->lock_migration_enabled && meta_locked) {
+        dict_del(meta_dict, GF_META_LOCK_KEY);
 
-                ret = syncop_setxattr (from, loc, meta_dict, 0, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace syncop_setxattr meta unlock failed");
-
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        }
+        ret = dict_set_int32(meta_dict, GF_META_UNLOCK_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
 
-out:
-        if (clean_src) {
-                /* Revert source mode and xattr changes*/
-                lk_ret = __dht_migration_cleanup_src_file (this, loc, src_fd,
-                                                        from, &src_ia_prot);
-                if (lk_ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to cleanup source file on %s",
-                                loc->path, from->name);
-                }
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        /* reset the destination back to 0 */
-        if (clean_dst) {
-                lk_ret = syncop_ftruncate (to, dst_fd, 0, NULL, NULL);
-                if (lk_ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: "
-                                "%s: failed to reset target size back to 0",
-                                loc->path);
-                }
-        }
+        if (clean_dst == _gf_false)
+            ret = dict_set_int32(meta_dict, "status", 1);
+        else
+            ret = dict_set_int32(meta_dict, "status", 0);
 
-        if (locked) {
-                flock.l_type = F_UNLCK;
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
 
-                lk_ret = syncop_inodelk (from, DHT_FILE_MIGRATE_DOMAIN,
-                                         &tmp_loc, F_SETLK, &flock, NULL, NULL);
-                if (lk_ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to unlock file on %s",
-                                loc->path, from->name);
-                }
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        if (p_locked) {
-                plock.l_type = F_UNLCK;
-                lk_ret = syncop_lk (from, src_fd, F_SETLK, &plock, NULL, NULL);
+        ret = syncop_setxattr(from, loc, meta_dict, 0, NULL, NULL);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace syncop_setxattr meta unlock failed");
 
-                if (lk_ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to unlock file on %s",
-                                loc->path, from->name);
-                }
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (dict)
-                dict_unref (dict);
-
-        if (xattr)
-                dict_unref (xattr);
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
-
-        if (dst_fd)
-                syncop_close (dst_fd);
-        if (src_fd)
-                syncop_close (src_fd);
-        if (linkto_fd)
-                syncop_close (linkto_fd);
-
-        loc_wipe (&tmp_loc);
-
-        return ret;
+out:
+    if (clean_src) {
+        /* Revert source mode and xattr changes*/
+        lk_ret = __dht_migration_cleanup_src_file(this, loc, src_fd, from,
+                                                  &src_ia_prot);
+        if (lk_ret) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to cleanup source file on %s", loc->path,
+                   from->name);
+        }
+    }
+
+    /* reset the destination back to 0 */
+    if (clean_dst) {
+        lk_ret = syncop_ftruncate(to, dst_fd, 0, NULL, NULL, NULL, NULL);
+        if (lk_ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: "
+                   "%s: failed to reset target size back to 0",
+                   loc->path);
+        }
+    }
+
+    if (inodelk_locked) {
+        flock.l_type = F_UNLCK;
+
+        lk_ret = syncop_inodelk(from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc,
+                                F_SETLK, &flock, NULL, NULL);
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock file on %s", loc->path, from->name);
+        }
+    }
+
+    if (entrylk_locked) {
+        lk_ret = syncop_entrylk(hashed_subvol, DHT_ENTRY_SYNC_DOMAIN,
+                                &parent_loc, loc->name, ENTRYLK_UNLOCK,
+                                ENTRYLK_UNLOCK, NULL, NULL);
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock entrylk on %s", loc->path,
+                   hashed_subvol->name);
+        }
+    }
+
+    if (p_locked) {
+        plock.l_type = F_UNLCK;
+        lk_ret = syncop_lk(from, src_fd, F_SETLK, &plock, NULL, NULL);
+
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock file on %s", loc->path, from->name);
+        }
+    }
+
+    lk_ret = syncop_removexattr(to, loc, GF_PROTECT_FROM_EXTERNAL_WRITES, NULL,
+                                NULL);
+    if (lk_ret && (lk_ret != -ENODATA) && (lk_ret != -ENOATTR)) {
+        gf_msg(this->name, GF_LOG_WARNING, -lk_ret, 0,
+               "%s: removexattr failed key %s", loc->path,
+               GF_PROTECT_FROM_EXTERNAL_WRITES);
+    }
+
+    if (dict)
+        dict_unref(dict);
+
+    if (xattr)
+        dict_unref(xattr);
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
+
+    if (dst_fd)
+        syncop_close(dst_fd);
+
+    if (src_fd)
+        syncop_close(src_fd);
+    if (linkto_fd)
+        syncop_close(linkto_fd);
+
+    if (xdata)
+        dict_unref(xdata);
+
+    loc_wipe(&tmp_loc);
+    loc_wipe(&parent_loc);
+
+    return ret;
 }
 
 static int
-rebalance_task (void *data)
+rebalance_task(void *data)
 {
-        int           ret   = -1;
-        dht_local_t  *local = NULL;
-        call_frame_t *frame = NULL;
-        int           fop_errno = 0;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    int fop_errno = 0;
 
-        frame = data;
+    frame = data;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* This function is 'synchrounous', hence if it returns,
-           we are done with the task */
-        ret = dht_migrate_file (THIS, &local->loc, local->rebalance.from_subvol,
-                                local->rebalance.target_node, local->flags,
-                                &fop_errno);
+    /* This function is 'synchrounous', hence if it returns,
+       we are done with the task */
+    ret = dht_migrate_file(THIS, &local->loc, local->rebalance.from_subvol,
+                           local->rebalance.target_node, local->flags,
+                           &fop_errno);
 
-        return ret;
+    return ret;
 }
 
 static int
-rebalance_task_completion (int op_ret, call_frame_t *sync_frame, void *data)
+rebalance_task_completion(int op_ret, call_frame_t *sync_frame, void *data)
 {
-        int32_t       op_errno   = EINVAL;
-
-        if (op_ret == -1) {
-                /* Failure of migration process, mostly due to write process.
-                   as we can't preserve the exact errno, lets say there was
-                   no space to migrate-data
-                */
-                op_errno = ENOSPC;
-        } else if (op_ret == 1) {
-                /* migration didn't happen, but is not a failure, let the user
-                   understand that he doesn't have permission to migrate the
-                   file.
-                */
-                op_ret = -1;
-                op_errno = EPERM;
-        } else if (op_ret != 0) {
-                op_errno = -op_ret;
-                op_ret = -1;
-        }
+    int32_t op_errno = EINVAL;
 
-        DHT_STACK_UNWIND (setxattr, sync_frame, op_ret, op_errno, NULL);
-        return 0;
+    if (op_ret == -1) {
+        /* Failure of migration process, mostly due to write process.
+           as we can't preserve the exact errno, lets say there was
+           no space to migrate-data
+        */
+        op_errno = ENOSPC;
+    } else if (op_ret == 1) {
+        /* migration didn't happen, but is not a failure, let the user
+           understand that he doesn't have permission to migrate the
+           file.
+        */
+        op_ret = -1;
+        op_errno = EPERM;
+    } else if (op_ret != 0) {
+        op_errno = -op_ret;
+        op_ret = -1;
+    }
+
+    DHT_STACK_UNWIND(setxattr, sync_frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
 int
-dht_start_rebalance_task (xlator_t *this, call_frame_t *frame)
+dht_start_rebalance_task(xlator_t *this, call_frame_t *frame)
 {
-        int           ret   = -1;
+    int ret = -1;
 
-        ret = synctask_new (this->ctx->env, rebalance_task,
-                            rebalance_task_completion,
-                            frame, frame);
-        return ret;
+    ret = synctask_new(this->ctx->env, rebalance_task,
+                       rebalance_task_completion, frame, frame);
+    return ret;
 }
 
-
 int
-gf_listener_stop (xlator_t *this)
+gf_listener_stop(xlator_t *this)
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        cmd_args_t       *cmd_args = NULL;
-        int              ret = 0;
-
-        ctx = this->ctx;
-        GF_ASSERT (ctx);
-        cmd_args = &ctx->cmd_args;
-        if (cmd_args->sock_file) {
-                ret = sys_unlink (cmd_args->sock_file);
-                if (ret && (ENOENT == errno)) {
-                        ret = 0;
-                }
-        }
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        DHT_MSG_SOCKET_ERROR,
-                        "Failed to unlink listener "
-                        "socket %s", cmd_args->sock_file);
-        }
-        return ret;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
+
+    ctx = this->ctx;
+    GF_ASSERT(ctx);
+    cmd_args = &ctx->cmd_args;
+    if (cmd_args->sock_file) {
+        ret = sys_unlink(cmd_args->sock_file);
+        if (ret && (ENOENT == errno)) {
+            ret = 0;
+        }
+    }
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, DHT_MSG_SOCKET_ERROR,
+               "Failed to unlink listener "
+               "socket %s",
+               cmd_args->sock_file);
+    }
+    return ret;
 }
 
 void
-dht_build_root_inode (xlator_t *this, inode_t **inode)
+dht_build_root_inode(xlator_t *this, inode_t **inode)
 {
-        inode_table_t    *itable        = NULL;
-        uuid_t            root_gfid     = {0, };
+    inode_table_t *itable = NULL;
+    static uuid_t root_gfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
-        itable = inode_table_new (0, this);
-        if (!itable)
-                return;
+    itable = inode_table_new(0, this);
+    if (!itable)
+        return;
 
-        root_gfid[15] = 1;
-        *inode = inode_find (itable, root_gfid);
+    *inode = inode_find(itable, root_gfid);
 }
 
 void
-dht_build_root_loc (inode_t *inode, loc_t *loc)
+dht_build_root_loc(inode_t *inode, loc_t *loc)
 {
-        loc->path = "/";
-        loc->inode = inode;
-        loc->inode->ia_type = IA_IFDIR;
-        memset (loc->gfid, 0, 16);
-        loc->gfid[15] = 1;
+    loc->path = "/";
+    loc->inode = inode;
+    loc->inode->ia_type = IA_IFDIR;
+    memset(loc->gfid, 0, 16);
+    loc->gfid[15] = 1;
 }
 
 /* return values: 1 -> error, bug ignore and continue
                   0 -> proceed
                  -1 -> error, handle it */
 int32_t
-gf_defrag_handle_migrate_error (int32_t op_errno, gf_defrag_info_t *defrag)
+gf_defrag_handle_migrate_error(int32_t op_errno, gf_defrag_info_t *defrag)
 {
-        /* if errno is not ENOSPC or ENOTCONN, we can still continue
-           with rebalance process */
-        if ((op_errno != ENOSPC) && (op_errno != ENOTCONN))
-                return 1;
-
-        if (op_errno == ENOTCONN) {
-                /* Most probably mount point went missing (mostly due
-                   to a brick down), say rebalance failure to user,
-                   let him restart it if everything is fine */
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                return -1;
-        }
-
-        if (op_errno == ENOSPC) {
-                /* rebalance process itself failed, may be
-                   remote brick went down, or write failed due to
-                   disk full etc etc.. */
-                return 0;
-        }
+    int ret = 0;
+    /* if errno is not ENOTCONN, we can still continue
+       with rebalance process */
+    if (op_errno != ENOTCONN) {
+        ret = 1;
+        goto out;
+    }
+
+    if (op_errno == ENOTCONN) {
+        /* Most probably mount point went missing (mostly due
+           to a brick down), say rebalance failure to user,
+           let him restart it if everything is fine */
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        ret = -1;
+        goto out;
+    }
 
-        return 0;
+out:
+    return ret;
 }
 
 static gf_boolean_t
-gf_defrag_pattern_match (gf_defrag_info_t *defrag, char *name, uint64_t size)
+gf_defrag_pattern_match(gf_defrag_info_t *defrag, char *name, uint64_t size)
 {
-        gf_defrag_pattern_list_t *trav = NULL;
-        gf_boolean_t               match = _gf_false;
-        gf_boolean_t               ret = _gf_false;
+    gf_defrag_pattern_list_t *trav = NULL;
+    gf_boolean_t match = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("dht", defrag, out);
+    GF_VALIDATE_OR_GOTO("dht", defrag, out);
 
-        trav = defrag->defrag_pattern;
-        while (trav) {
-                if (!fnmatch (trav->path_pattern, name, FNM_NOESCAPE)) {
-                        match = _gf_true;
-                        break;
-                }
-                trav = trav->next;
+    trav = defrag->defrag_pattern;
+    while (trav) {
+        if (!fnmatch(trav->path_pattern, name, FNM_NOESCAPE)) {
+            match = _gf_true;
+            break;
         }
+        trav = trav->next;
+    }
 
-        if ((match == _gf_true) && (size >= trav->size))
-                ret = _gf_true;
+    if ((match == _gf_true) && (size >= trav->size))
+        ret = _gf_true;
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
-int dht_dfreaddirp_done (dht_dfoffset_ctx_t *offset_var, int cnt) {
-
-        int i;
-        int result = 1;
+int
+dht_dfreaddirp_done(dht_dfoffset_ctx_t *offset_var, int cnt)
+{
+    int i;
+    int result = 1;
 
-        for (i = 0; i < cnt; i++) {
-                if (offset_var[i].readdir_done == 0) {
-                        result = 0;
-                        break;
-                }
+    for (i = 0; i < cnt; i++) {
+        if (offset_var[i].readdir_done == 0) {
+            result = 0;
+            break;
         }
-        return result;
+    }
+    return result;
 }
 
-int static
-gf_defrag_ctx_subvols_init (dht_dfoffset_ctx_t *offset_var, xlator_t *this) {
+int static gf_defrag_ctx_subvols_init(dht_dfoffset_ctx_t *offset_var,
+                                      xlator_t *this)
+{
+    int i;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
 
-        int i;
-        dht_conf_t *conf = NULL;
+    if (!conf)
+        return -1;
 
-        conf = this->private;
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        offset_var[i].this = conf->local_subvols[i];
+        offset_var[i].offset = (off_t)0;
+        offset_var[i].readdir_done = 0;
+    }
 
-        if (!conf)
-               return -1;
+    return 0;
+}
 
-        for (i = 0; i < conf->local_subvols_cnt; i++) {
-               offset_var[i].this = conf->local_subvols[i];
-               offset_var[i].offset = (off_t) 0;
-               offset_var[i].readdir_done = 0;
+static int
+dht_get_first_non_null_index(subvol_nodeuuids_info_t *entry)
+{
+    int i = 0;
+    int index = 0;
+
+    for (i = 0; i < entry->count; i++) {
+        if (!gf_uuid_is_null(entry->elements[i].uuid)) {
+            index = i;
+            goto out;
         }
+    }
 
-        return 0;
+    if (i == entry->count) {
+        index = -1;
+    }
+out:
+    return index;
 }
 
-
 /* Return value
  * 0 : this node does not migrate the file
  * 1 : this node migrates the file
@@ -2456,2754 +2538,2165 @@ gf_defrag_ctx_subvols_init (dht_dfoffset_ctx_t *offset_var, xlator_t *this) {
  * all hardlinks.
  */
 
-int
-gf_defrag_should_i_migrate (xlator_t *this, int local_subvol_index, uuid_t gfid)
+gf_boolean_t
+gf_defrag_should_i_migrate(xlator_t *this, int local_subvol_index, uuid_t gfid)
 {
-        int         ret               = 0;
-        int         i                 = local_subvol_index;
-        char       *str               = NULL;
-        uint32_t    hashval           = 0;
-        int32_t     index        = 0;
-        dht_conf_t *conf              = NULL;
-        char        buf[UUID_CANONICAL_FORM_LEN + 1] = {0, };
-
-        conf = this->private;
-
-        /* Pure distribute */
-
-        if (conf->local_nodeuuids[i].count == 1) {
-                return 1;
-        }
-
-        str = uuid_utoa_r (gfid, buf);
-        ret = dht_hash_compute (this, 0, str, &hashval);
-        if (ret == 0) {
-                index = (hashval % conf->local_nodeuuids[i].count);
-                if (conf->local_nodeuuids[i].elements[index].info
-                                 == REBAL_NODEUUID_MINE) {
-                        /* Index matches this node's nodeuuid.*/
-                        ret = 1;
-                }
+    gf_boolean_t ret = _gf_false;
+    int i = local_subvol_index;
+    char *str = NULL;
+    uint32_t hashval = 0;
+    int32_t index = 0;
+    dht_conf_t *conf = NULL;
+    char buf[UUID_CANONICAL_FORM_LEN + 1] = {
+        0,
+    };
+    subvol_nodeuuids_info_t *entry = NULL;
+
+    conf = this->private;
+
+    /* Pure distribute. A subvol in this case
+        will be handled by only one node */
+
+    entry = &(conf->local_nodeuuids[i]);
+    if (entry->count == 1) {
+        return 1;
+    }
+
+    str = uuid_utoa_r(gfid, buf);
+    if (dht_hash_compute(this, 0, str, &hashval) == 0) {
+        index = (hashval % entry->count);
+        if (entry->elements[index].info == REBAL_NODEUUID_MINE) {
+            /* Index matches this node's nodeuuid.*/
+            ret = _gf_true;
+            goto out;
+        }
+
+        /* Brick down - some other node has to migrate these files*/
+        if (gf_uuid_is_null(entry->elements[index].uuid)) {
+            /* Fall back to the first non-null index */
+            index = dht_get_first_non_null_index(entry);
+
+            if (index == -1) {
+                /* None of the bricks in the subvol are up.
+                 * CHILD_DOWN will kill the process soon */
+
+                return _gf_false;
+            }
+
+            if (entry->elements[index].info == REBAL_NODEUUID_MINE) {
+                /* Index matches this node's nodeuuid.*/
+                ret = _gf_true;
+                goto out;
+            }
         }
-        return ret;
+    }
+out:
+    return ret;
 }
 
-
 int
-gf_defrag_migrate_single_file (void *opaque)
+gf_defrag_migrate_single_file(void *opaque)
 {
-        xlator_t                *this           = NULL;
-        dht_conf_t              *conf           = NULL;
-        gf_defrag_info_t        *defrag         = NULL;
-        int                      ret            = 0;
-        gf_dirent_t             *entry          = NULL;
-        struct timeval           start          = {0,};
-        loc_t                    entry_loc      = {0,};
-        loc_t                   *loc            = NULL;
-        struct iatt              iatt           = {0,};
-        dict_t                  *migrate_data   = NULL;
-        struct timeval           end            = {0,};
-        double                   elapsed        = {0,};
-        struct dht_container    *rebal_entry    = NULL;
-        inode_t                 *inode          = NULL;
-        xlator_t                *hashed_subvol  = NULL;
-        xlator_t                *cached_subvol  = NULL;
-        call_frame_t            *statfs_frame   = NULL;
-        xlator_t                *old_THIS       = NULL;
-        data_t                  *tmp            = NULL;
-        int                      fop_errno      = 0;
-        gf_dht_migrate_data_type_t rebal_type   = GF_DHT_MIGRATE_DATA;
-        char                     value[MAX_REBAL_TYPE_SIZE]    = {0,};
-        struct iatt             *iatt_ptr       = NULL;
-        gf_boolean_t            update_skippedcount = _gf_true;
-        int                     i = 0;
-
-        rebal_entry = (struct dht_container *)opaque;
-        if (!rebal_entry) {
-                gf_log ("DHT", GF_LOG_ERROR, "rebal_entry is NULL");
-                ret = -1;
-                goto out;
-        }
-
-        this = rebal_entry->this;
-
-        conf = this->private;
-
-        defrag = conf->defrag;
-
-        loc = rebal_entry->parent_loc;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    int ret = 0;
+    gf_dirent_t *entry = NULL;
+    struct timeval start = {
+        0,
+    };
+    loc_t entry_loc = {
+        0,
+    };
+    loc_t *loc = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *migrate_data = NULL;
+    struct timeval end = {
+        0,
+    };
+    double elapsed = {
+        0,
+    };
+    struct dht_container *rebal_entry = NULL;
+    inode_t *inode = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    call_frame_t *statfs_frame = NULL;
+    xlator_t *old_THIS = NULL;
+    data_t *tmp = NULL;
+    int fop_errno = 0;
+    gf_dht_migrate_data_type_t rebal_type = GF_DHT_MIGRATE_DATA;
+    char value[MAX_REBAL_TYPE_SIZE] = {
+        0,
+    };
+    struct iatt *iatt_ptr = NULL;
+    gf_boolean_t update_skippedcount = _gf_true;
+    int i = 0;
+    gf_boolean_t should_i_migrate = 0;
+
+    rebal_entry = (struct dht_container *)opaque;
+    if (!rebal_entry) {
+        gf_log("DHT", GF_LOG_ERROR, "rebal_entry is NULL");
+        ret = -1;
+        goto out;
+    }
 
-        migrate_data = rebal_entry->migrate_data;
+    this = rebal_entry->this;
 
-        entry = rebal_entry->df_entry;
-        iatt_ptr = &entry->d_stat;
+    conf = this->private;
 
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                ret = -1;
-                goto out;
-        }
+    defrag = conf->defrag;
 
-        if (defrag->stats == _gf_true) {
-                gettimeofday (&start, NULL);
-        }
+    loc = rebal_entry->parent_loc;
 
-        if (defrag->defrag_pattern &&
-            (gf_defrag_pattern_match (defrag, entry->d_name,
-                                      entry->d_stat.ia_size) == _gf_false)) {
-                gf_log (this->name, GF_LOG_ERROR, "pattern_match failed");
-                goto out;
-        }
+    migrate_data = rebal_entry->migrate_data;
 
-        memset (&entry_loc, 0, sizeof (entry_loc));
+    entry = rebal_entry->df_entry;
+    iatt_ptr = &entry->d_stat;
 
-        ret = dht_build_child_loc (this, &entry_loc, loc, entry->d_name);
-        if (ret) {
-                LOCK (&defrag->lock);
-                {
-                        defrag->total_failures += 1;
-                }
-                UNLOCK (&defrag->lock);
+    if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+        ret = -1;
+        goto out;
+    }
 
-                ret = 0;
+    if (defrag->stats == _gf_true) {
+        gettimeofday(&start, NULL);
+    }
 
-                gf_log (this->name, GF_LOG_ERROR, "Child loc build failed");
+    if (defrag->defrag_pattern &&
+        (gf_defrag_pattern_match(defrag, entry->d_name,
+                                 entry->d_stat.ia_size) == _gf_false)) {
+        gf_log(this->name, GF_LOG_ERROR, "pattern_match failed");
+        goto out;
+    }
 
-                goto out;
-        }
+    memset(&entry_loc, 0, sizeof(entry_loc));
 
-        if (!gf_defrag_should_i_migrate (this, rebal_entry->local_subvol_index,
-                                         entry->d_stat.ia_gfid)) {
-                gf_msg_debug (this->name, 0, "Don't migrate %s ",
-                              entry_loc.path);
-                goto out;
+    ret = dht_build_child_loc(this, &entry_loc, loc, entry->d_name);
+    if (ret) {
+        LOCK(&defrag->lock);
+        {
+            defrag->total_failures += 1;
         }
+        UNLOCK(&defrag->lock);
 
-        gf_uuid_copy (entry_loc.gfid, entry->d_stat.ia_gfid);
+        ret = 0;
 
-        gf_uuid_copy (entry_loc.pargfid, loc->gfid);
+        gf_log(this->name, GF_LOG_ERROR, "Child loc build failed");
 
-        ret = syncop_lookup (this, &entry_loc, &iatt, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: %s lookup failed",
-                        entry_loc.path);
-                ret = 0;
-                goto out;
-        }
+        goto out;
+    }
 
-        iatt_ptr = &iatt;
-
-        hashed_subvol = dht_subvol_get_hashed (this, &entry_loc);
-        if (!hashed_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "Failed to get hashed subvol for %s",
-                        entry_loc.path);
-                ret = 0;
-                goto out;
-        }
+    should_i_migrate = gf_defrag_should_i_migrate(
+        this, rebal_entry->local_subvol_index, entry->d_stat.ia_gfid);
 
-        cached_subvol = dht_subvol_get_cached (this, entry_loc.inode);
-        if (!cached_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_CACHED_SUBVOL_GET_FAILED,
-                        "Failed to get cached subvol for %s",
-                        entry_loc.path);
+    gf_uuid_copy(entry_loc.gfid, entry->d_stat.ia_gfid);
 
-                ret = 0;
-                goto out;
-        }
+    gf_uuid_copy(entry_loc.pargfid, loc->gfid);
 
-        if (hashed_subvol == cached_subvol) {
-                ret = 0;
-                goto out;
-        }
+    ret = syncop_lookup(this, &entry_loc, &iatt, NULL, NULL, NULL);
 
-        inode = inode_link (entry_loc.inode, entry_loc.parent, entry->d_name, &iatt);
-        inode_unref (entry_loc.inode);
-        /* use the inode returned by inode_link */
-        entry_loc.inode = inode;
-
-        old_THIS = THIS;
-        THIS = this;
-        statfs_frame = create_frame (this, this->ctx->pool);
-        if (!statfs_frame) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
-                        "Insufficient memory. Frame creation failed");
-                ret = -1;
-                goto out;
+    if (!should_i_migrate) {
+        /* this node isn't supposed to migrate the file. suppressing any
+         * potential error from lookup as this file is under migration by
+         * another node */
+        if (ret) {
+            gf_msg_debug(this->name, -ret,
+                         "Ignoring lookup failure: node isn't migrating %s",
+                         entry_loc.path);
+            ret = 0;
+        }
+        gf_msg_debug(this->name, 0, "Don't migrate %s ", entry_loc.path);
+        goto out;
+    }
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: %s lookup failed", entry_loc.path);
+
+        /* Increase failure count only for remove-brick op, so that
+         * user is warned to check the removed-brick for any files left
+         * unmigrated
+         */
+        if (conf->decommission_subvols_cnt) {
+            LOCK(&defrag->lock);
+            {
+                defrag->total_failures += 1;
+            }
+            UNLOCK(&defrag->lock);
         }
 
-        /* async statfs information for honoring min-free-disk */
-        dht_get_du_info (statfs_frame, this, loc);
-        THIS = old_THIS;
+        ret = 0;
+        goto out;
+    }
 
-        tmp = dict_get (migrate_data, GF_XATTR_FILE_MIGRATE_KEY);
-        if (tmp) {
-                memcpy (value, tmp->data, tmp->len);
-                if (strcmp (value, "force") == 0)
-                        rebal_type = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+    iatt_ptr = &iatt;
 
-                if (conf->decommission_in_progress)
-                        rebal_type = GF_DHT_MIGRATE_HARDLINK;
-        }
+    hashed_subvol = dht_subvol_get_hashed(this, &entry_loc);
+    if (!hashed_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "Failed to get hashed subvol for %s", entry_loc.path);
+        ret = 0;
+        goto out;
+    }
 
-        ret = dht_migrate_file (this, &entry_loc, cached_subvol,
-                                hashed_subvol, rebal_type, &fop_errno);
-        if (ret < 0) {
-                if (fop_errno == ENOSPC) {
-                        gf_msg_debug (this->name, 0, "migrate-data skipped for"
-                                      " %s due to space constraints",
-                                      entry_loc.path);
-
-                        /* For remove-brick case if the source is not one of the
-                        * removed-brick, do not mark the error as failure */
-                        if (conf->decommission_subvols_cnt) {
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (conf->decommissioned_bricks[i] == cached_subvol) {
-                                                LOCK (&defrag->lock);
-                                                {
-                                                    defrag->total_failures += 1;
-                                                    update_skippedcount = _gf_false;
-                                                }
-                                                UNLOCK (&defrag->lock);
-
-                                                break;
-                                        }
-                                }
-                        }
+    cached_subvol = dht_subvol_get_cached(this, entry_loc.inode);
+    if (!cached_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_CACHED_SUBVOL_GET_FAILED,
+               "Failed to get cached subvol for %s", entry_loc.path);
 
-                        if (update_skippedcount) {
-                                LOCK (&defrag->lock);
-                                {
-                                        defrag->skipped += 1;
-                                }
-                                UNLOCK (&defrag->lock);
-
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_MIGRATE_FILE_SKIPPED,
-                                        "File migration skipped for %s.",
-                                        entry_loc.path);
-                        }
+        ret = 0;
+        goto out;
+    }
 
-                } else if (fop_errno == ENOTSUP) {
-                        gf_msg_debug (this->name, 0, "migrate-data skipped for"
-                                      " hardlink %s ", entry_loc.path);
-                        LOCK (&defrag->lock);
+    if (hashed_subvol == cached_subvol) {
+        ret = 0;
+        goto out;
+    }
+
+    inode = inode_link(entry_loc.inode, entry_loc.parent, entry->d_name, &iatt);
+    inode_unref(entry_loc.inode);
+    /* use the inode returned by inode_link */
+    entry_loc.inode = inode;
+
+    old_THIS = THIS;
+    THIS = this;
+    statfs_frame = create_frame(this, this->ctx->pool);
+    if (!statfs_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+               "Insufficient memory. Frame creation failed");
+        ret = -1;
+        goto out;
+    }
+
+    /* async statfs information for honoring min-free-disk */
+    dht_get_du_info(statfs_frame, this, loc);
+    THIS = old_THIS;
+
+    tmp = dict_get(migrate_data, GF_XATTR_FILE_MIGRATE_KEY);
+    if (tmp) {
+        memcpy(value, tmp->data, tmp->len);
+        if (strcmp(value, "force") == 0)
+            rebal_type = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+
+        if (conf->decommission_in_progress)
+            rebal_type = GF_DHT_MIGRATE_HARDLINK;
+    }
+
+    ret = dht_migrate_file(this, &entry_loc, cached_subvol, hashed_subvol,
+                           rebal_type, &fop_errno);
+    if (ret == 1) {
+        if (fop_errno == ENOSPC) {
+            gf_msg_debug(this->name, 0,
+                         "migrate-data skipped for"
+                         " %s due to space constraints",
+                         entry_loc.path);
+
+            /* For remove-brick case if the source is not one of the
+             * removed-brick, do not mark the error as failure */
+            if (conf->decommission_subvols_cnt) {
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (conf->decommissioned_bricks[i] == cached_subvol) {
+                        LOCK(&defrag->lock);
                         {
-                                defrag->skipped += 1;
+                            defrag->total_failures += 1;
+                            update_skippedcount = _gf_false;
                         }
-                        UNLOCK (&defrag->lock);
+                        UNLOCK(&defrag->lock);
 
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_MIGRATE_FILE_SKIPPED,
-                                "File migration skipped for %s.",
-                                entry_loc.path);
-
-                } else if (fop_errno != EEXIST) {
-                        gf_msg (this->name, GF_LOG_ERROR, fop_errno,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "migrate-data failed for %s", entry_loc.path);
-
-                        LOCK (&defrag->lock);
-                        {
-                                defrag->total_failures += 1;
-                        }
-                        UNLOCK (&defrag->lock);
+                        break;
+                    }
+                }
+            }
 
+            if (update_skippedcount) {
+                LOCK(&defrag->lock);
+                {
+                    defrag->skipped += 1;
                 }
+                UNLOCK(&defrag->lock);
 
-                ret = gf_defrag_handle_migrate_error (fop_errno, defrag);
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_MIGRATE_FILE_SKIPPED,
+                       "File migration skipped for %s.", entry_loc.path);
+            }
 
-                if (!ret) {
-                        gf_msg(this->name, GF_LOG_ERROR, fop_errno,
-                               DHT_MSG_MIGRATE_FILE_FAILED,
-                               "migrate-data on %s failed:", entry_loc.path);
-                } else if (ret == 1) {
-                        ret = 0;
-                }
+        } else if (fop_errno == ENOTSUP) {
+            gf_msg_debug(this->name, 0,
+                         "migrate-data skipped for"
+                         " hardlink %s ",
+                         entry_loc.path);
+            LOCK(&defrag->lock);
+            {
+                defrag->skipped += 1;
+            }
+            UNLOCK(&defrag->lock);
 
-                goto out;
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_MIGRATE_FILE_SKIPPED,
+                   "File migration skipped for %s.", entry_loc.path);
         }
 
-        LOCK (&defrag->lock);
-        {
-                defrag->total_files += 1;
-                defrag->total_data += iatt.ia_size;
-        }
-        UNLOCK (&defrag->lock);
-
-        if (defrag->stats == _gf_true) {
-                gettimeofday (&end, NULL);
-                elapsed = (end.tv_sec - start.tv_sec) * 1e6 +
-                          (end.tv_usec - start.tv_usec);
-                gf_log (this->name, GF_LOG_INFO, "Migration of "
-                        "file:%s size:%"PRIu64" bytes took %.2f"
-                        "secs and ret: %d", entry_loc.name,
-                        iatt.ia_size, elapsed/1e6, ret);
+        ret = 0;
+        goto out;
+    } else if (ret < 0) {
+        if (fop_errno != EEXIST) {
+            gf_msg(this->name, GF_LOG_ERROR, fop_errno,
+                   DHT_MSG_MIGRATE_FILE_FAILED, "migrate-data failed for %s",
+                   entry_loc.path);
+
+            LOCK(&defrag->lock);
+            {
+                defrag->total_failures += 1;
+            }
+            UNLOCK(&defrag->lock);
         }
 
+        ret = gf_defrag_handle_migrate_error(fop_errno, defrag);
+
+        if (!ret) {
+            gf_msg(this->name, GF_LOG_ERROR, fop_errno,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "migrate-data on %s failed:", entry_loc.path);
+        } else if (ret == 1) {
+            ret = 0;
+        }
+
+        goto out;
+    }
+
+    LOCK(&defrag->lock);
+    {
+        defrag->total_files += 1;
+        defrag->total_data += iatt.ia_size;
+    }
+    UNLOCK(&defrag->lock);
+
+    if (defrag->stats == _gf_true) {
+        gettimeofday(&end, NULL);
+        elapsed = gf_tvdiff(&start, &end);
+        gf_log(this->name, GF_LOG_INFO,
+               "Migration of "
+               "file:%s size:%" PRIu64
+               " bytes took %.2f"
+               "secs and ret: %d",
+               entry_loc.name, iatt.ia_size, elapsed / 1e6, ret);
+    }
+
 out:
-        if (statfs_frame) {
-                STACK_DESTROY (statfs_frame->root);
-        }
+    if (statfs_frame) {
+        STACK_DESTROY(statfs_frame->root);
+    }
 
-        if (iatt_ptr) {
-                LOCK (&defrag->lock);
-                {
-                        defrag->size_processed += iatt_ptr->ia_size;
-                }
-                UNLOCK (&defrag->lock);
+    if (iatt_ptr) {
+        LOCK(&defrag->lock);
+        {
+            defrag->size_processed += iatt_ptr->ia_size;
         }
-        loc_wipe (&entry_loc);
-
-        return ret;
+        UNLOCK(&defrag->lock);
+    }
+    loc_wipe(&entry_loc);
 
+    return ret;
 }
 
 void *
-gf_defrag_task (void *opaque)
+gf_defrag_task(void *opaque)
 {
-        struct list_head        *q_head         = NULL;
-        struct dht_container    *iterator       = NULL;
-        gf_defrag_info_t        *defrag         = NULL;
-        int                      ret            = 0;
-        pid_t                    pid            = GF_CLIENT_PID_DEFRAG;
-
-        defrag = (gf_defrag_info_t *)opaque;
-        if (!defrag) {
-                gf_msg ("dht", GF_LOG_ERROR, 0, 0, "defrag is NULL");
-                goto out;
+    struct list_head *q_head = NULL;
+    struct dht_container *iterator = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    int ret = 0;
+    pid_t pid = GF_CLIENT_PID_DEFRAG;
+
+    defrag = (gf_defrag_info_t *)opaque;
+    if (!defrag) {
+        gf_msg("dht", GF_LOG_ERROR, 0, 0, "defrag is NULL");
+        goto out;
+    }
+
+    syncopctx_setfspid(&pid);
+
+    q_head = &(defrag->queue[0].list);
+
+    /* The following while loop will dequeue one entry from the defrag->queue
+       under lock. We will update the defrag->global_error only when there
+       is an error which is critical to stop the rebalance process. The stop
+       message will be intimated to other migrator threads by setting the
+       defrag->defrag_status to GF_DEFRAG_STATUS_FAILED.
+
+       In defrag->queue, a low watermark (MIN_MIGRATE_QUEUE_COUNT) is
+       maintained so that crawler does not starve the file migration
+       workers and a high watermark (MAX_MIGRATE_QUEUE_COUNT) so that
+       crawler does not go far ahead in filling up the queue.
+     */
+
+    while (_gf_true) {
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
+            pthread_cond_broadcast(&defrag->parallel_migration_cond);
+            goto out;
         }
 
-        syncopctx_setfspid (&pid);
+        pthread_mutex_lock(&defrag->dfq_mutex);
+        {
+            /*Throttle down:
+              If the reconfigured count is less than current thread
+              count, then the current thread will sleep */
+
+            /*TODO: Need to refactor the following block to work
+             *under defrag->lock. For now access
+             * defrag->current_thread_count and rthcount under
+             * dfq_mutex lock */
+            while (!defrag->crawl_done && (defrag->recon_thread_count <
+                                           defrag->current_thread_count)) {
+                defrag->current_thread_count--;
+                gf_msg_debug("DHT", 0,
+                             "Thread sleeping. "
+                             "current thread count: %d",
+                             defrag->current_thread_count);
+
+                pthread_cond_wait(&defrag->df_wakeup_thread,
+                                  &defrag->dfq_mutex);
+
+                defrag->current_thread_count++;
+                gf_msg_debug("DHT", 0,
+                             "Thread wokeup. "
+                             "current thread count: %d",
+                             defrag->current_thread_count);
+            }
+
+            if (defrag->q_entry_count) {
+                iterator = list_entry(q_head->next, typeof(*iterator), list);
+
+                gf_msg_debug("DHT", 0,
+                             "picking entry "
+                             "%s",
+                             iterator->df_entry->d_name);
+
+                list_del_init(&(iterator->list));
+
+                defrag->q_entry_count--;
+
+                if ((defrag->q_entry_count < MIN_MIGRATE_QUEUE_COUNT) &&
+                    defrag->wakeup_crawler) {
+                    pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
+                }
+                pthread_mutex_unlock(&defrag->dfq_mutex);
+                ret = gf_defrag_migrate_single_file((void *)iterator);
 
-        q_head = &(defrag->queue[0].list);
+                /*Critical errors: ENOTCONN and ENOSPACE*/
+                if (ret) {
+                    dht_set_global_defrag_error(defrag, ret);
 
-       /* The following while loop will dequeue one entry from the defrag->queue
-          under lock. We will update the defrag->global_error only when there
-          is an error which is critical to stop the rebalance process. The stop
-          message will be intimated to other migrator threads by setting the
-          defrag->defrag_status to GF_DEFRAG_STATUS_FAILED.
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-          In defrag->queue, a low watermark (MIN_MIGRATE_QUEUE_COUNT) is
-          maintained so that crawler does not starve the file migration
-          workers and a high watermark (MAX_MIGRATE_QUEUE_COUNT) so that
-          crawler does not go far ahead in filling up the queue.
-        */
+                    pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
 
-        while (_gf_true) {
+                    pthread_cond_broadcast(&defrag->parallel_migration_cond);
 
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        pthread_cond_broadcast (
-                                &defrag->rebalance_crawler_alarm);
-                        pthread_cond_broadcast (
-                                &defrag->parallel_migration_cond);
-                        goto out;
+                    goto out;
                 }
 
-                pthread_mutex_lock (&defrag->dfq_mutex);
-                {
-
-                        /*Throttle down:
-                          If the reconfigured count is less than current thread
-                          count, then the current thread will sleep */
-
-                        /*TODO: Need to refactor the following block to work
-                         *under defrag->lock. For now access
-                         * defrag->current_thread_count and rthcount under
-                         * dfq_mutex lock */
-                        while (!defrag->crawl_done &&
-                              (defrag->recon_thread_count <
-                                        defrag->current_thread_count)) {
-                                defrag->current_thread_count--;
-                                gf_msg_debug ("DHT", 0, "Thread sleeping. "
-                                              "current thread count: %d",
-                                              defrag->current_thread_count);
-
-                                pthread_cond_wait (
-                                           &defrag->df_wakeup_thread,
-                                           &defrag->dfq_mutex);
-
-                                defrag->current_thread_count++;
-                                gf_msg_debug ("DHT", 0, "Thread wokeup. "
-                                              "current thread count: %d",
-                                              defrag->current_thread_count);
-
-                        }
+                gf_defrag_free_container(iterator);
+
+                continue;
+            } else {
+                /* defrag->crawl_done flag is set means crawling
+                 file system is done and hence a list_empty when
+                 the above flag is set indicates there are no more
+                 entries to be added to the queue and rebalance is
+                 finished */
+
+                if (!defrag->crawl_done) {
+                    defrag->current_thread_count--;
+                    gf_msg_debug("DHT", 0,
+                                 "Thread "
+                                 "sleeping while  waiting "
+                                 "for migration entries. "
+                                 "current thread  count:%d",
+                                 defrag->current_thread_count);
+
+                    pthread_cond_wait(&defrag->parallel_migration_cond,
+                                      &defrag->dfq_mutex);
+                }
 
-                        if (defrag->q_entry_count) {
-                                iterator = list_entry (q_head->next,
-                                                typeof(*iterator), list);
-
-                                gf_msg_debug ("DHT", 0, "picking entry "
-                                              "%s", iterator->df_entry->d_name);
-
-                                list_del_init (&(iterator->list));
-
-                                defrag->q_entry_count--;
-
-                                if ((defrag->q_entry_count <
-                                        MIN_MIGRATE_QUEUE_COUNT) &&
-                                        defrag->wakeup_crawler) {
-                                        pthread_cond_broadcast (
-                                              &defrag->rebalance_crawler_alarm);
-                                }
-                                pthread_mutex_unlock (&defrag->dfq_mutex);
-                                ret = gf_defrag_migrate_single_file
-                                                        ((void *)iterator);
-
-                                /*Critical errors: ENOTCONN and ENOSPACE*/
-                                if (ret) {
-                                        dht_set_global_defrag_error
-                                                         (defrag, ret);
-
-                                        defrag->defrag_status =
-                                                       GF_DEFRAG_STATUS_FAILED;
-
-                                        pthread_cond_broadcast (
-                                             &defrag->rebalance_crawler_alarm);
-
-                                        pthread_cond_broadcast (
-                                             &defrag->parallel_migration_cond);
-
-                                        goto out;
-                                }
-
-                                gf_defrag_free_container (iterator);
-
-                                continue;
-                        } else {
-
-                        /* defrag->crawl_done flag is set means crawling
-                         file system is done and hence a list_empty when
-                         the above flag is set indicates there are no more
-                         entries to be added to the queue and rebalance is
-                         finished */
-
-                                if (!defrag->crawl_done) {
-
-                                        defrag->current_thread_count--;
-                                        gf_msg_debug ("DHT", 0, "Thread "
-                                                      "sleeping while  waiting "
-                                                      "for migration entries. "
-                                                      "current thread  count:%d",
-                                                      defrag->current_thread_count);
-
-                                        pthread_cond_wait (
-                                           &defrag->parallel_migration_cond,
-                                           &defrag->dfq_mutex);
-                                }
-
-                                if (defrag->crawl_done &&
-                                                 !defrag->q_entry_count) {
-                                        defrag->current_thread_count++;
-                                        gf_msg_debug ("DHT", 0, "Exiting thread");
-
-                                        pthread_cond_broadcast (
-                                             &defrag->parallel_migration_cond);
-                                        goto unlock;
-                                } else {
-                                        defrag->current_thread_count++;
-                                        gf_msg_debug ("DHT", 0, "Thread woke up"
-                                                      " as found migrating entries. "
-                                                      "current thread count:%d",
-                                                      defrag->current_thread_count);
-
-                                        pthread_mutex_unlock
-                                                 (&defrag->dfq_mutex);
-                                        continue;
-                                }
-                        }
+                if (defrag->crawl_done && !defrag->q_entry_count) {
+                    defrag->current_thread_count++;
+                    gf_msg_debug("DHT", 0, "Exiting thread");
 
+                    pthread_cond_broadcast(&defrag->parallel_migration_cond);
+                    goto unlock;
+                } else {
+                    defrag->current_thread_count++;
+                    gf_msg_debug("DHT", 0,
+                                 "Thread woke up"
+                                 " as found migrating entries. "
+                                 "current thread count:%d",
+                                 defrag->current_thread_count);
+
+                    pthread_mutex_unlock(&defrag->dfq_mutex);
+                    continue;
                 }
-unlock:
-                pthread_mutex_unlock (&defrag->dfq_mutex);
-                break;
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&defrag->dfq_mutex);
+        break;
+    }
 out:
-        return NULL;
+    return NULL;
 }
 
-int static
-gf_defrag_get_entry (xlator_t *this, int i, struct dht_container **container,
-                     loc_t *loc, dht_conf_t *conf, gf_defrag_info_t *defrag,
-                     fd_t *fd, dict_t *migrate_data,
-                     struct dir_dfmeta *dir_dfmeta, dict_t *xattr_req,
-                     int *should_commit_hash, int *perrno)
+int static gf_defrag_get_entry(xlator_t *this, int i,
+                               struct dht_container **container, loc_t *loc,
+                               dht_conf_t *conf, gf_defrag_info_t *defrag,
+                               fd_t *fd, dict_t *migrate_data,
+                               struct dir_dfmeta *dir_dfmeta, dict_t *xattr_req,
+                               int *perrno)
 {
-        int                     ret             = -1;
-        char                    is_linkfile     = 0;
-        gf_dirent_t            *df_entry        = NULL;
-        dict_t                 *xattr_rsp       = NULL;
-        struct dht_container   *tmp_container   = NULL;
-
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                ret = -1;
-                goto out;
-        }
-
-        if (dir_dfmeta->offset_var[i].readdir_done == 1) {
-                ret = 0;
-                goto out;
-        }
+    int ret = 0;
+    char is_linkfile = 0;
+    gf_dirent_t *df_entry = NULL;
+    struct dht_container *tmp_container = NULL;
 
-        if (dir_dfmeta->fetch_entries[i] == 1) {
-                ret = syncop_readdirp (conf->local_subvols[i], fd, 131072,
-                                       dir_dfmeta->offset_var[i].offset,
-                                       &(dir_dfmeta->equeue[i]),
-                                       xattr_req, NULL);
-                if (ret == 0) {
-                        dir_dfmeta->offset_var[i].readdir_done = 1;
-                        ret = 0;
-                        goto out;
-                }
+    if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+        ret = -1;
+        goto out;
+    }
 
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_DATA_FAILED,
-                                "Readdirp failed. Aborting data migration for "
-                                "directory: %s", loc->path);
-                        *perrno = -ret;
-                        ret = -1;
-                        goto out;
-                }
+    if (dir_dfmeta->offset_var[i].readdir_done == 1) {
+        ret = 0;
+        goto out;
+    }
 
-                if (list_empty (&(dir_dfmeta->equeue[i].list))) {
-                        dir_dfmeta->offset_var[i].readdir_done = 1;
-                        ret = 0;
-                        goto out;
-                }
+    if (dir_dfmeta->fetch_entries[i] == 1) {
+        if (!fd) {
+            dir_dfmeta->fetch_entries[i] = 0;
+            dir_dfmeta->offset_var[i].readdir_done = 1;
+            ret = 0;
+            goto out;
+        }
 
-                dir_dfmeta->fetch_entries[i] = 0;
+        ret = syncop_readdirp(conf->local_subvols[i], fd, 131072,
+                              dir_dfmeta->offset_var[i].offset,
+                              &(dir_dfmeta->equeue[i]), xattr_req, NULL);
+        if (ret == 0) {
+            dir_dfmeta->offset_var[i].readdir_done = 1;
+            ret = 0;
+            goto out;
         }
 
-        while (1) {
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_DATA_FAILED,
+                   "Readdirp failed. Aborting data migration for "
+                   "directory: %s",
+                   loc->path);
+            *perrno = -ret;
+            ret = -1;
+            goto out;
+        }
 
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        ret = -1;
-                        goto out;
-                }
+        if (list_empty(&(dir_dfmeta->equeue[i].list))) {
+            dir_dfmeta->offset_var[i].readdir_done = 1;
+            ret = 0;
+            goto out;
+        }
 
-                df_entry = list_entry (dir_dfmeta->iterator[i]->next,
-                                       typeof (*df_entry), list);
+        dir_dfmeta->fetch_entries[i] = 0;
+    }
 
-                if (&df_entry->list == dir_dfmeta->head[i]) {
-                        gf_dirent_free (&(dir_dfmeta->equeue[i]));
-                        INIT_LIST_HEAD (&(dir_dfmeta->equeue[i].list));
-                        dir_dfmeta->fetch_entries[i] = 1;
-                        dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
-                        ret = 0;
-                        goto out;
-                }
+    while (1) {
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            ret = -1;
+            goto out;
+        }
 
-                dir_dfmeta->iterator[i] = dir_dfmeta->iterator[i]->next;
+        df_entry = list_entry(dir_dfmeta->iterator[i]->next, typeof(*df_entry),
+                              list);
 
-                dir_dfmeta->offset_var[i].offset = df_entry->d_off;
-                if (!strcmp (df_entry->d_name, ".") ||
-                    !strcmp (df_entry->d_name, ".."))
-                        continue;
+        if (&df_entry->list == dir_dfmeta->head[i]) {
+            gf_dirent_free(&(dir_dfmeta->equeue[i]));
+            INIT_LIST_HEAD(&(dir_dfmeta->equeue[i].list));
+            dir_dfmeta->fetch_entries[i] = 1;
+            dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
+            ret = 0;
+            goto out;
+        }
 
-                if (IA_ISDIR (df_entry->d_stat.ia_type)) {
-                        defrag->size_processed += df_entry->d_stat.ia_size;
-                        continue;
-                }
+        dir_dfmeta->iterator[i] = dir_dfmeta->iterator[i]->next;
 
-                defrag->num_files_lookedup++;
+        dir_dfmeta->offset_var[i].offset = df_entry->d_off;
+        if (!strcmp(df_entry->d_name, ".") || !strcmp(df_entry->d_name, ".."))
+            continue;
 
-                if (defrag->defrag_pattern &&
-                    (gf_defrag_pattern_match (defrag, df_entry->d_name,
-                                              df_entry->d_stat.ia_size)
-                     == _gf_false)) {
-                        defrag->size_processed += df_entry->d_stat.ia_size;
-                        continue;
-                }
+        if (IA_ISDIR(df_entry->d_stat.ia_type)) {
+            defrag->size_processed += df_entry->d_stat.ia_size;
+            continue;
+        }
 
-                is_linkfile = check_is_linkfile (NULL, &df_entry->d_stat,
-                                                 df_entry->dict,
-                                                 conf->link_xattr_name);
+        defrag->num_files_lookedup++;
 
-                if (is_linkfile) {
-                        /* No need to add linkto file to the queue for
-                           migration. Only the actual data file need to
-                           be checked for migration criteria.
-                        */
+        if (defrag->defrag_pattern &&
+            (gf_defrag_pattern_match(defrag, df_entry->d_name,
+                                     df_entry->d_stat.ia_size) == _gf_false)) {
+            defrag->size_processed += df_entry->d_stat.ia_size;
+            continue;
+        }
 
-                        gf_msg_debug (this->name, 0, "Skipping linkfile"
-                                      " %s on subvol: %s", df_entry->d_name,
-                                      conf->local_subvols[i]->name);
-                        continue;
-                }
+        is_linkfile = check_is_linkfile(NULL, &df_entry->d_stat, df_entry->dict,
+                                        conf->link_xattr_name);
 
-                /*Build Container Structure */
+        if (is_linkfile) {
+            /* No need to add linkto file to the queue for
+               migration. Only the actual data file need to
+               be checked for migration criteria.
+            */
 
-                tmp_container =  GF_CALLOC (1, sizeof(struct dht_container),
-                                            gf_dht_mt_container_t);
-                if (!tmp_container) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for container");
-                        ret = -1;
-                        goto out;
-                }
-                tmp_container->df_entry = gf_dirent_for_name (df_entry->d_name);
-                if (!tmp_container->df_entry) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for df_entry");
-                        ret = -1;
-                        goto out;
-                }
+            gf_msg_debug(this->name, 0,
+                         "Skipping linkfile"
+                         " %s on subvol: %s",
+                         df_entry->d_name, conf->local_subvols[i]->name);
+            continue;
+        }
 
-                tmp_container->local_subvol_index = i;
+        /*Build Container Structure */
 
-                tmp_container->df_entry->d_stat = df_entry->d_stat;
+        tmp_container = GF_CALLOC(1, sizeof(struct dht_container),
+                                  gf_dht_mt_container_t);
+        if (!tmp_container) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for container");
+            ret = -1;
+            goto out;
+        }
+        tmp_container->df_entry = gf_dirent_for_name(df_entry->d_name);
+        if (!tmp_container->df_entry) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for df_entry");
+            ret = -1;
+            goto out;
+        }
 
-                tmp_container->df_entry->d_ino  = df_entry->d_ino;
+        tmp_container->local_subvol_index = i;
 
-                tmp_container->df_entry->d_type = df_entry->d_type;
+        tmp_container->df_entry->d_stat = df_entry->d_stat;
 
-                tmp_container->df_entry->d_len  = df_entry->d_len;
+        tmp_container->df_entry->d_ino = df_entry->d_ino;
 
-                tmp_container->parent_loc = GF_CALLOC(1, sizeof(*loc),
-                                                      gf_dht_mt_loc_t);
-                if (!tmp_container->parent_loc) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for loc");
-                        ret = -1;
-                        goto out;
-                }
+        tmp_container->df_entry->d_type = df_entry->d_type;
 
+        tmp_container->df_entry->d_len = df_entry->d_len;
 
-                ret = loc_copy (tmp_container->parent_loc, loc);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "loc_copy failed");
-                        ret = -1;
-                        goto out;
-                }
+        tmp_container->parent_loc = GF_CALLOC(1, sizeof(*loc), gf_dht_mt_loc_t);
+        if (!tmp_container->parent_loc) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for loc");
+            ret = -1;
+            goto out;
+        }
 
-                tmp_container->migrate_data = migrate_data;
+        ret = loc_copy(tmp_container->parent_loc, loc);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR, "loc_copy failed");
+            ret = -1;
+            goto out;
+        }
 
-                tmp_container->this = this;
+        tmp_container->migrate_data = migrate_data;
 
-                if (df_entry->dict)
-                        tmp_container->df_entry->dict =
-                                        dict_ref (df_entry->dict);
+        tmp_container->this = this;
 
-               /*Build Container Structue >> END*/
+        if (df_entry->dict)
+            tmp_container->df_entry->dict = dict_ref(df_entry->dict);
 
-                ret = 0;
-                goto out;
+        /*Build Container Structure >> END*/
 
-        }
+        ret = 0;
+        goto out;
+    }
 
 out:
-        if (ret == 0) {
-                *container = tmp_container;
-        } else {
-                if (tmp_container) {
-                        gf_defrag_free_container (tmp_container);
-                }
+    if (ret == 0) {
+        *container = tmp_container;
+    } else {
+        if (tmp_container) {
+            gf_defrag_free_container(tmp_container);
         }
+    }
 
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
-
-
-        return ret;
+    return ret;
 }
 
 int
-gf_defrag_process_dir (xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
-                       dict_t *migrate_data, int *perrno)
+gf_defrag_process_dir(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                      dict_t *migrate_data, int *perrno)
 {
-        int                      ret               = -1;
-        fd_t                    *fd                = NULL;
-        dht_conf_t              *conf              = NULL;
-        gf_dirent_t              entries;
-        dict_t                  *dict              = NULL;
-        dict_t                  *xattr_req         = NULL;
-        struct timeval           dir_start         = {0,};
-        struct timeval           end               = {0,};
-        double                   elapsed           = {0,};
-        int                      local_subvols_cnt = 0;
-        int                      i                 = 0;
-        int                      j                 = 0;
-        struct  dht_container   *container         = NULL;
-        int                      ldfq_count        = 0;
-        int                      dfc_index         = 0;
-        int                      throttle_up       = 0;
-        struct dir_dfmeta       *dir_dfmeta        = NULL;
-        int                      should_commit_hash = 1;
-
-        gf_log (this->name, GF_LOG_INFO, "migrate data called on %s",
-                loc->path);
-        gettimeofday (&dir_start, NULL);
-
-        conf = this->private;
-        local_subvols_cnt = conf->local_subvols_cnt;
-
-        if (!local_subvols_cnt) {
-                ret = 0;
-                goto out;
-        }
-
-        fd = fd_create (loc->inode, defrag->pid);
-        if (!fd) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to create fd");
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_opendir (this, loc, fd, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_DATA_FAILED,
-                        "Migrate data failed: Failed to open dir %s",
-                        loc->path);
-                *perrno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        fd_bind (fd);
-        dir_dfmeta = GF_CALLOC (1, sizeof (*dir_dfmeta),
-                                                gf_common_mt_pointer);
-        if (!dir_dfmeta) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta is NULL");
-                ret = -1;
-                goto out;
-        }
-
-
-        dir_dfmeta->head = GF_CALLOC (local_subvols_cnt,
-                                      sizeof (*(dir_dfmeta->head)),
-                                      gf_common_mt_pointer);
-        if (!dir_dfmeta->head) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta->head is NULL");
-                ret = -1;
-                goto out;
-        }
-
-        dir_dfmeta->iterator = GF_CALLOC (local_subvols_cnt,
-                                          sizeof (*(dir_dfmeta->iterator)),
-                                          gf_common_mt_pointer);
-        if (!dir_dfmeta->iterator) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->iterator is NULL");
-                ret = -1;
-                goto out;
-        }
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    gf_dirent_t entries;
+    dict_t *xattr_req = NULL;
+    struct timeval dir_start = {
+        0,
+    };
+    struct timeval end = {
+        0,
+    };
+    double elapsed = {
+        0,
+    };
+    int local_subvols_cnt = 0;
+    int i = 0;
+    int j = 0;
+    struct dht_container *container = NULL;
+    int ldfq_count = 0;
+    int dfc_index = 0;
+    int throttle_up = 0;
+    struct dir_dfmeta *dir_dfmeta = NULL;
+    xlator_t *old_THIS = NULL;
+
+    gf_log(this->name, GF_LOG_INFO, "migrate data called on %s", loc->path);
+    gettimeofday(&dir_start, NULL);
+
+    conf = this->private;
+    local_subvols_cnt = conf->local_subvols_cnt;
+
+    if (!local_subvols_cnt) {
+        ret = 0;
+        goto out;
+    }
 
-        dir_dfmeta->equeue = GF_CALLOC (local_subvols_cnt, sizeof (entries),
-                                        gf_dht_mt_dirent_t);
-        if (!dir_dfmeta->equeue) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta->equeue is NULL");
-                ret = -1;
-                goto out;
-        }
+    old_THIS = THIS;
+    THIS = this;
 
-        dir_dfmeta->offset_var = GF_CALLOC (local_subvols_cnt,
-                                            sizeof (dht_dfoffset_ctx_t),
-                                            gf_dht_mt_octx_t);
-        if (!dir_dfmeta->offset_var) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->offset_var is NULL");
-                ret = -1;
-                goto out;
-        }
-        ret = gf_defrag_ctx_subvols_init (dir_dfmeta->offset_var, this);
+    dir_dfmeta = GF_CALLOC(1, sizeof(*dir_dfmeta), gf_common_mt_pointer);
+    if (!dir_dfmeta) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    dir_dfmeta->lfd = GF_CALLOC(local_subvols_cnt, sizeof(fd_t *),
+                                gf_common_mt_pointer);
+    if (!dir_dfmeta->lfd) {
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_INSUFF_MEMORY,
+                "for dir_dfmeta", NULL);
+        ret = -1;
+        *perrno = ENOMEM;
+        goto out;
+    }
+
+    for (i = 0; i < local_subvols_cnt; i++) {
+        dir_dfmeta->lfd[i] = fd_create(loc->inode, defrag->pid);
+        if (!dir_dfmeta->lfd[i]) {
+            gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_FD_CREATE_FAILED,
+                    NULL);
+            *perrno = ENOMEM;
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncop_opendir(conf->local_subvols[i], loc, dir_dfmeta->lfd[i],
+                             NULL, NULL);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "dht_dfoffset_ctx_t"
-                        "initialization failed");
-                ret = -1;
-                goto out;
-        }
+            fd_unref(dir_dfmeta->lfd[i]);
+            dir_dfmeta->lfd[i] = NULL;
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_FAILED_TO_OPEN,
+                    "dir: %s", loc->path, "subvol: %s",
+                    conf->local_subvols[i]->name, NULL);
 
-        dir_dfmeta->fetch_entries = GF_CALLOC (local_subvols_cnt,
-                                               sizeof (int), gf_common_mt_int);
-        if (!dir_dfmeta->fetch_entries) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->fetch_entries is NULL");
+            if (conf->decommission_in_progress) {
+                *perrno = -ret;
                 ret = -1;
                 goto out;
+            }
+        } else {
+            fd_bind(dir_dfmeta->lfd[i]);
         }
+    }
 
-        for (i = 0; i < local_subvols_cnt ; i++) {
-                INIT_LIST_HEAD (&(dir_dfmeta->equeue[i].list));
-                dir_dfmeta->head[i]          = &(dir_dfmeta->equeue[i].list);
-                dir_dfmeta->iterator[i]      = dir_dfmeta->head[i];
-                dir_dfmeta->fetch_entries[i] = 1;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-               gf_log (this->name, GF_LOG_ERROR, "dict_new failed");
-               ret = -1;
-               goto out;
-        }
-
-        ret = dict_set_uint32 (xattr_req,
-                               conf->link_xattr_name, 256);
-        if (ret) {
-               gf_log (this->name, GF_LOG_ERROR, "failed to set dict for "
-                       "key: %s", conf->link_xattr_name);
-               ret = -1;
-               goto out;
-        }
-
-        /*
-         Job: Read entries from each local subvol and store the entries
-              in equeue array of linked list. Now pick one entry from the
-              equeue array in a round robin basis and add them to defrag Queue.
-        */
-
-        while (!dht_dfreaddirp_done(dir_dfmeta->offset_var,
-                                         local_subvols_cnt)) {
-
-                pthread_mutex_lock (&defrag->dfq_mutex);
-                {
-
-                      /*Throttle up: If reconfigured count is higher than
-                        current thread count, wake up the sleeping threads
-                        TODO: Need to refactor this. Instead of making the
-                        thread sleep and wake, we should terminate and spawn
-                        threads on-demand*/
-
-                        if (defrag->recon_thread_count >
-                                         defrag->current_thread_count) {
-                                throttle_up =
-                                        (defrag->recon_thread_count -
-                                            defrag->current_thread_count);
-                                for (j = 0; j < throttle_up; j++) {
-                                        pthread_cond_signal (
-                                             &defrag->df_wakeup_thread);
-                                }
-
-                        }
+    dir_dfmeta->head = GF_CALLOC(local_subvols_cnt, sizeof(*(dir_dfmeta->head)),
+                                 gf_common_mt_pointer);
+    if (!dir_dfmeta->head) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->head is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    dir_dfmeta->iterator = GF_CALLOC(local_subvols_cnt,
+                                     sizeof(*(dir_dfmeta->iterator)),
+                                     gf_common_mt_pointer);
+    if (!dir_dfmeta->iterator) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->iterator is NULL");
+        ret = -1;
+        goto out;
+    }
 
-                        while (defrag->q_entry_count >
-                                        MAX_MIGRATE_QUEUE_COUNT) {
-                                defrag->wakeup_crawler = 1;
-                                pthread_cond_wait (
-                                        &defrag->rebalance_crawler_alarm,
-                                        &defrag->dfq_mutex);
-                        }
+    dir_dfmeta->equeue = GF_CALLOC(local_subvols_cnt, sizeof(entries),
+                                   gf_dht_mt_dirent_t);
+    if (!dir_dfmeta->equeue) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->equeue is NULL");
+        ret = -1;
+        goto out;
+    }
 
-                       ldfq_count = defrag->q_entry_count;
+    dir_dfmeta->offset_var = GF_CALLOC(
+        local_subvols_cnt, sizeof(dht_dfoffset_ctx_t), gf_dht_mt_octx_t);
+    if (!dir_dfmeta->offset_var) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->offset_var is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_defrag_ctx_subvols_init(dir_dfmeta->offset_var, this);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "dht_dfoffset_ctx_t"
+               "initialization failed");
+        ret = -1;
+        goto out;
+    }
+
+    dir_dfmeta->fetch_entries = GF_CALLOC(local_subvols_cnt, sizeof(int),
+                                          gf_common_mt_int);
+    if (!dir_dfmeta->fetch_entries) {
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_INSUFF_MEMORY,
+                "for dir_dfmeta->fetch_entries", NULL);
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < local_subvols_cnt; i++) {
+        INIT_LIST_HEAD(&(dir_dfmeta->equeue[i].list));
+        dir_dfmeta->head[i] = &(dir_dfmeta->equeue[i].list);
+        dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
+        dir_dfmeta->fetch_entries[i] = 1;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        gf_log(this->name, GF_LOG_ERROR, "dict_new failed");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set dict for "
+               "key: %s",
+               conf->link_xattr_name);
+        ret = -1;
+        goto out;
+    }
 
-                       if (defrag->wakeup_crawler) {
-                               defrag->wakeup_crawler = 0;
-                       }
+    /*
+     Job: Read entries from each local subvol and store the entries
+          in equeue array of linked list. Now pick one entry from the
+          equeue array in a round robin basis and add them to defrag Queue.
+    */
 
+    while (!dht_dfreaddirp_done(dir_dfmeta->offset_var, local_subvols_cnt)) {
+        pthread_mutex_lock(&defrag->dfq_mutex);
+        {
+            /*Throttle up: If reconfigured count is higher than
+              current thread count, wake up the sleeping threads
+              TODO: Need to refactor this. Instead of making the
+              thread sleep and wake, we should terminate and spawn
+              threads on-demand*/
+
+            if (defrag->recon_thread_count > defrag->current_thread_count) {
+                throttle_up = (defrag->recon_thread_count -
+                               defrag->current_thread_count);
+                for (j = 0; j < throttle_up; j++) {
+                    pthread_cond_signal(&defrag->df_wakeup_thread);
                 }
-                pthread_mutex_unlock (&defrag->dfq_mutex);
-
-                while (ldfq_count <= MAX_MIGRATE_QUEUE_COUNT &&
-                       !dht_dfreaddirp_done(dir_dfmeta->offset_var,
-                                               local_subvols_cnt)) {
-
-                        ret = gf_defrag_get_entry (this, dfc_index, &container,
-                                                   loc, conf, defrag, fd,
-                                                   migrate_data, dir_dfmeta,
-                                                   xattr_req,
-                                                   &should_commit_hash, perrno);
+            }
 
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_WARNING, "Found "
-                                        "error from gf_defrag_get_entry");
+            while (defrag->q_entry_count > MAX_MIGRATE_QUEUE_COUNT) {
+                defrag->wakeup_crawler = 1;
+                pthread_cond_wait(&defrag->rebalance_crawler_alarm,
+                                  &defrag->dfq_mutex);
+            }
 
-                                ret = -1;
-                                goto out;
-                        }
-
-                        /* Check if we got an entry, else we need to move the
-                           index to the next subvol */
-                        if (!container) {
-                                GF_CRAWL_INDEX_MOVE(dfc_index,
-                                                    local_subvols_cnt);
-                                continue;
-                        }
+            ldfq_count = defrag->q_entry_count;
 
-                        /* Q this entry in the dfq */
-                        pthread_mutex_lock (&defrag->dfq_mutex);
-                        {
-                                list_add_tail (&container->list,
-                                        &(defrag->queue[0].list));
-                                defrag->q_entry_count++;
-                                ldfq_count = defrag->q_entry_count;
-
-                                gf_msg_debug (this->name, 0, "added "
-                                              "file:%s parent:%s to the queue ",
-                                              container->df_entry->d_name,
-                                              container->parent_loc->path);
-
-                                pthread_cond_signal (
-                                        &defrag->parallel_migration_cond);
-                        }
-                        pthread_mutex_unlock (&defrag->dfq_mutex);
-
-                        GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
-                }
+            if (defrag->wakeup_crawler) {
+                defrag->wakeup_crawler = 0;
+            }
         }
+        pthread_mutex_unlock(&defrag->dfq_mutex);
 
-        gettimeofday (&end, NULL);
-        elapsed = (end.tv_sec - dir_start.tv_sec) * 1e6 +
-                  (end.tv_usec - dir_start.tv_usec);
-        gf_log (this->name, GF_LOG_INFO, "Migration operation on dir %s took "
-                "%.2f secs", loc->path, elapsed/1e6);
-        ret = 0;
-out:
-
-        GF_FREE_DIR_DFMETA (dir_dfmeta);
-
-        if (dict)
-                dict_unref(dict);
+        while (
+            ldfq_count <= MAX_MIGRATE_QUEUE_COUNT &&
+            !dht_dfreaddirp_done(dir_dfmeta->offset_var, local_subvols_cnt)) {
+            ret = gf_defrag_get_entry(this, dfc_index, &container, loc, conf,
+                                      defrag, dir_dfmeta->lfd[dfc_index],
+                                      migrate_data, dir_dfmeta, xattr_req,
+                                      perrno);
 
-        if (xattr_req)
-                dict_unref(xattr_req);
+            if (defrag->defrag_status == GF_DEFRAG_STATUS_STOPPED) {
+                goto out;
+            }
 
-        if (fd)
-                fd_unref (fd);
+            if (ret) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "Found "
+                       "error from gf_defrag_get_entry");
 
-        if (ret == 0 && should_commit_hash == 0) {
-                ret = 2;
-        }
-
-        /* It does not matter if it errored out - this number is
-         * used to calculate rebalance estimated time to complete.
-         * No locking required as dirs are processed by a single thread.
-         */
-        defrag->num_dirs_processed++;
-        return ret;
+                ret = -1;
+                goto out;
+            }
+
+            /* Check if we got an entry, else we need to move the
+               index to the next subvol */
+            if (!container) {
+                GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
+                continue;
+            }
+
+            /* Q this entry in the dfq */
+            pthread_mutex_lock(&defrag->dfq_mutex);
+            {
+                list_add_tail(&container->list, &(defrag->queue[0].list));
+                defrag->q_entry_count++;
+                ldfq_count = defrag->q_entry_count;
+
+                gf_msg_debug(this->name, 0,
+                             "added "
+                             "file:%s parent:%s to the queue ",
+                             container->df_entry->d_name,
+                             container->parent_loc->path);
+
+                pthread_cond_signal(&defrag->parallel_migration_cond);
+            }
+            pthread_mutex_unlock(&defrag->dfq_mutex);
+
+            GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+    elapsed = gf_tvdiff(&dir_start, &end);
+    gf_log(this->name, GF_LOG_INFO,
+           "Migration operation on dir %s took "
+           "%.2f secs",
+           loc->path, elapsed / 1e6);
+    ret = 0;
+out:
+    THIS = old_THIS;
+    gf_defrag_free_dir_dfmeta(dir_dfmeta, local_subvols_cnt);
+
+    if (xattr_req)
+        dict_unref(xattr_req);
+
+    /* It does not matter if it errored out - this number is
+     * used to calculate rebalance estimated time to complete.
+     * No locking required as dirs are processed by a single thread.
+     */
+    defrag->num_dirs_processed++;
+    return ret;
 }
+
 int
-gf_defrag_settle_hash (xlator_t *this, gf_defrag_info_t *defrag,
-                       loc_t *loc, dict_t *fix_layout)
+gf_defrag_settle_hash(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                      dict_t *fix_layout)
 {
-        int     ret;
-        dht_conf_t *conf = NULL;
-        /*
-         * Now we're ready to update the directory commit hash for the volume
-         * root, so that hash miscompares and broadcast lookups can stop.
-         * However, we want to skip that if fix-layout is all we did.  In
-         * that case, we want the miscompares etc. to continue until a real
-         * rebalance is complete.
+    int ret;
+    dht_conf_t *conf = NULL;
+    /*
+     * Now we're ready to update the directory commit hash for the volume
+     * root, so that hash miscompares and broadcast lookups can stop.
+     * However, we want to skip that if fix-layout is all we did.  In
+     * that case, we want the miscompares etc. to continue until a real
+     * rebalance is complete.
+     */
+    if (defrag->cmd == GF_DEFRAG_CMD_START_LAYOUT_FIX ||
+        defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
+        return 0;
+    }
+
+    conf = this->private;
+    if (!conf) {
+        /*Uh oh
          */
-        if (defrag->cmd == GF_DEFRAG_CMD_START_LAYOUT_FIX
-            || defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-            defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-                return 0;
-        }
+        return -1;
+    }
 
-        conf = this->private;
-        if (!conf) {
-                /*Uh oh
-                 */
-                return -1;
-        }
+    if (conf->local_subvols_cnt == 0 || !conf->lookup_optimize) {
+        /* Commit hash updates are only done on local subvolumes and
+         * only when lookup optimization is needed (for older client
+         * support)
+         */
+        return 0;
+    }
 
-        if (conf->local_subvols_cnt == 0 || !conf->lookup_optimize) {
-                /* Commit hash updates are only done on local subvolumes and
-                 * only when lookup optmization is needed (for older client
-                 * support)
-                 */
-                return 0;
-        }
+    ret = dict_set_uint32(fix_layout, "new-commit-hash",
+                          defrag->new_commit_hash);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to set new-commit-hash");
+        return -1;
+    }
 
-        ret = dict_set_uint32 (fix_layout, "new-commit-hash",
-                               defrag->new_commit_hash);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set new-commit-hash");
-                return -1;
-        }
+    ret = syncop_setxattr(this, loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+               "fix layout on %s failed", loc->path);
 
-        ret = syncop_setxattr (this, loc, fix_layout, 0, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "fix layout on %s failed", loc->path);
-                return -1;
+        if (-ret == ENOENT || -ret == ESTALE) {
+            /* Dir most likely is deleted */
+            return 0;
         }
 
-        /* TBD: find more efficient solution than adding/deleting every time */
-        dict_del(fix_layout, "new-commit-hash");
-
-        return 0;
-}
+        return -1;
+    }
 
+    /* TBD: find more efficient solution than adding/deleting every time */
+    dict_del(fix_layout, "new-commit-hash");
 
+    return 0;
+}
 
-/* Function for doing a named lookup on file inodes during an attach tier
- * So that a hardlink lookup heal i.e gfid to parent gfid lookup heal
- * happens on pre-existing data. This is required so that the ctr database has
- * hardlinks of all the exisitng file in the volume. CTR xlator on the
- * brick/server side does db update/insert of the hardlink on a namelookup.
- * Currently the namedlookup is done synchronous to the fixlayout that is
- * triggered by attach tier. This is not performant, adding more time to
- * fixlayout. The performant approach is record the hardlinks on a compressed
- * datastore and then do the namelookup asynchronously later, giving the ctr db
- * eventual consistency
- * */
 int
-gf_fix_layout_tier_attach_lookup (xlator_t *this,
-                                 loc_t *parent_loc,
-                                 gf_dirent_t *file_dentry)
+gf_defrag_fix_layout(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                     dict_t *fix_layout, dict_t *migrate_data)
 {
-        int                      ret            = -1;
-        dict_t                  *lookup_xdata   = NULL;
-        dht_conf_t              *conf           = NULL;
-        loc_t                    file_loc       = {0,};
-        struct iatt              iatt           = {0,};
-
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, parent_loc, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, file_dentry, out);
+    int ret = -1;
+    loc_t entry_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_boolean_t free_entries = _gf_false;
+    off_t offset = 0;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *linked_inode = NULL, *inode = NULL;
+    dht_conf_t *conf = NULL;
+    int perrno = 0;
+
+    conf = this->private;
+    if (!conf) {
+        ret = -1;
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    ret = syncop_lookup(this, loc, &iatt, NULL, NULL, NULL);
+    if (ret) {
+        if (strcmp(loc->path, "/") == 0) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "lookup failed for:%s", loc->path);
 
-        if (!parent_loc->inode) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s parent is NULL", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
 
+        if (-ret == ENOENT || -ret == ESTALE) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "Dir:%s renamed or removed. Skipping", loc->path);
+            if (conf->decommission_subvols_cnt) {
+                defrag->total_failures++;
+            }
+            ret = 0;
+            goto out;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "lookup failed for:%s", loc->path);
 
-        conf   = this->private;
-
-        loc_wipe (&file_loc);
-
-        if (gf_uuid_is_null (file_dentry->d_stat.ia_gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s gfid not present", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
+            defrag->total_failures++;
+            goto out;
         }
+    }
 
-        gf_uuid_copy (file_loc.gfid, file_dentry->d_stat.ia_gfid);
+    fd = fd_create(loc->inode, defrag->pid);
+    if (!fd) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to create fd");
+        ret = -1;
+        goto out;
+    }
 
-        if (gf_uuid_is_null (parent_loc->gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s"
-                        " gfid not present", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
+    ret = syncop_opendir(this, loc, fd, NULL, NULL);
+    if (ret) {
+        if (-ret == ENOENT || -ret == ESTALE) {
+            if (conf->decommission_subvols_cnt) {
+                defrag->total_failures++;
+            }
+            ret = 0;
+            goto out;
         }
 
-        gf_uuid_copy (file_loc.pargfid, parent_loc->gfid);
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to open dir %s, "
+               "err:%d",
+               loc->path, -ret);
 
+        ret = -1;
+        goto out;
+    }
 
-        ret = dht_build_child_loc (this, &file_loc, parent_loc,
-                                                file_dentry->d_name);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Child loc build failed");
-                ret = -1;
-                goto out;
-        }
-
-        lookup_xdata = dict_new ();
-        if (!lookup_xdata) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed creating lookup dict for %s",
-                        file_dentry->d_name);
-                goto out;
-        }
+    fd_bind(fd);
+    INIT_LIST_HEAD(&entries.list);
 
-        ret = dict_set_int32 (lookup_xdata, CTR_ATTACH_TIER_LOOKUP, 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to set lookup flag");
+    while ((ret = syncop_readdirp(this, fd, 131072, offset, &entries, NULL,
+                                  NULL)) != 0) {
+        if (ret < 0) {
+            if (-ret == ENOENT || -ret == ESTALE) {
+                if (conf->decommission_subvols_cnt) {
+                    defrag->total_failures++;
+                }
+                ret = 0;
                 goto out;
-        }
+            }
 
-        gf_uuid_copy (file_loc.parent->gfid, parent_loc->gfid);
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_READDIR_ERROR,
+                   "readdirp failed for "
+                   "path %s. Aborting fix-layout",
+                   loc->path);
 
-        /* Sending lookup to cold tier only */
-        ret = syncop_lookup (conf->subvolumes[0], &file_loc, &iatt,
-                        NULL, lookup_xdata, NULL);
-        if (ret) {
-                /* If the file does not exist on the cold tier than it must */
-                /* have been discovered on the hot tier. This is not an error. */
-                gf_msg (this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                        "%s lookup to cold tier on attach heal failed", file_loc.path);
-                goto out;
+            ret = -1;
+            goto out;
         }
 
-        ret = 0;
-
-out:
+        if (list_empty(&entries.list))
+            break;
 
-        loc_wipe (&file_loc);
+        free_entries = _gf_true;
 
-        if (lookup_xdata)
-                dict_unref (lookup_xdata);
+        list_for_each_entry_safe(entry, tmp, &entries.list, list)
+        {
+            if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+                ret = 1;
+                goto out;
+            }
 
-        return ret;
-}
+            offset = entry->d_off;
 
-int
-gf_defrag_fix_layout (xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
-                  dict_t *fix_layout, dict_t *migrate_data)
-{
-        int                      ret            = -1;
-        loc_t                    entry_loc      = {0,};
-        fd_t                    *fd             = NULL;
-        gf_dirent_t              entries;
-        gf_dirent_t             *tmp            = NULL;
-        gf_dirent_t             *entry          = NULL;
-        gf_boolean_t             free_entries   = _gf_false;
-        off_t                    offset         = 0;
-        struct iatt              iatt           = {0,};
-        inode_t                 *linked_inode   = NULL, *inode = NULL;
-        dht_conf_t              *conf           = NULL;
-        int                      should_commit_hash = 1;
-        int                      perrno         = 0;
-
-        conf = this->private;
-        if (!conf) {
-                ret = -1;
-                goto out;
-        }
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
+            if (!IA_ISDIR(entry->d_stat.ia_type)) {
+                continue;
+            }
+            loc_wipe(&entry_loc);
 
-        ret = syncop_lookup (this, loc, &iatt, NULL, NULL, NULL);
-        if (ret) {
-                if (strcmp (loc->path, "/") == 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "lookup failed for:%s", loc->path);
+            ret = dht_build_child_loc(this, &entry_loc, loc, entry->d_name);
+            if (ret) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "Child loc"
+                       " build failed for entry: %s",
+                       entry->d_name);
 
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
+                if (conf->decommission_in_progress) {
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "Dir:%s renamed or removed. Skipping",
-                                loc->path);
-                                ret = 0;
-                                goto out;
+                    goto out;
                 } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "lookup failed for:%s", loc->path);
-
-                        defrag->total_failures++;
-                        goto out;
+                    continue;
                 }
-        }
-
-        fd = fd_create (loc->inode, defrag->pid);
-        if (!fd) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to create fd");
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_opendir (this, loc, fd, NULL, NULL);
-        if (ret) {
+            }
+
+            if (gf_uuid_is_null(entry->d_stat.ia_gfid)) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "%s/%s"
+                       " gfid not present",
+                       loc->path, entry->d_name);
+                continue;
+            }
+
+            gf_uuid_copy(entry_loc.gfid, entry->d_stat.ia_gfid);
+
+            /*In case the gfid stored in the inode by inode_link
+             * and the gfid obtained in the lookup differs, then
+             * client3_3_lookup_cbk will return ESTALE and proper
+             * error will be captured
+             */
+
+            linked_inode = inode_link(entry_loc.inode, loc->inode,
+                                      entry->d_name, &entry->d_stat);
+
+            inode = entry_loc.inode;
+            entry_loc.inode = linked_inode;
+            inode_unref(inode);
+
+            if (gf_uuid_is_null(loc->gfid)) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "%s/%s"
+                       " gfid not present",
+                       loc->path, entry->d_name);
+                continue;
+            }
+
+            gf_uuid_copy(entry_loc.pargfid, loc->gfid);
+
+            ret = syncop_lookup(this, &entry_loc, &iatt, NULL, NULL, NULL);
+            if (ret) {
                 if (-ret == ENOENT || -ret == ESTALE) {
-                        ret = 0;
-                        goto out;
-                }
-
-                gf_log (this->name, GF_LOG_ERROR, "Failed to open dir %s, "
-                        "err:%d", loc->path, -ret);
-
-                ret = -1;
-                goto out;
-        }
-
-        fd_bind (fd);
-        INIT_LIST_HEAD (&entries.list);
-
-        while ((ret = syncop_readdirp (this, fd, 131072, offset, &entries,
-                                       NULL, NULL)) != 0)
-        {
-                if (ret < 0) {
-                        if (-ret == ENOENT || -ret == ESTALE) {
-                                ret = 0;
-                                goto out;
-                        }
+                    gf_msg(this->name, GF_LOG_INFO, -ret,
+                           DHT_MSG_DIR_LOOKUP_FAILED,
+                           "Dir:%s renamed or removed. "
+                           "Skipping",
+                           loc->path);
+                    ret = 0;
+                    if (conf->decommission_subvols_cnt) {
+                        defrag->total_failures++;
+                    }
+                    continue;
+                } else {
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_DIR_LOOKUP_FAILED, "lookup failed for:%s",
+                           entry_loc.path);
 
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_READDIR_ERROR, "readdirp failed for "
-                                "path %s. Aborting fix-layout", loc->path);
+                    defrag->total_failures++;
 
+                    if (conf->decommission_in_progress) {
+                        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
                         ret = -1;
                         goto out;
+                    } else {
+                        continue;
+                    }
                 }
+            }
 
-                if (list_empty (&entries.list))
-                        break;
-
-                free_entries = _gf_true;
+            /* A return value of 2 means, either process_dir or
+             * lookup of a dir failed. Hence, don't commit hash
+             * for the current directory*/
 
-                list_for_each_entry_safe (entry, tmp, &entries.list, list) {
-                        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                                ret = 1;
-                                goto out;
-                        }
-
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-                        if (!IA_ISDIR (entry->d_stat.ia_type)) {
-
-                                /* If its a fix layout during the attach
-                                 * tier operation do lookups on files
-                                 * on cold subvolume so that there is a
-                                 * CTR DB Lookup Heal triggered on existing
-                                 * data.
-                                 * */
-                                if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                                        gf_fix_layout_tier_attach_lookup
-                                                (this, loc, entry);
-                                }
-
-                                continue;
-                        }
-                        loc_wipe (&entry_loc);
-
-                        ret = dht_build_child_loc (this, &entry_loc, loc,
-                                                  entry->d_name);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR, "Child loc"
-                                        " build failed for entry: %s",
-                                        entry->d_name);
-
-                                if (conf->decommission_in_progress) {
-                                        defrag->defrag_status =
-                                        GF_DEFRAG_STATUS_FAILED;
-
-                                        goto out;
-                                } else {
-                                        should_commit_hash = 0;
-
-                                        continue;
-                                }
-                        }
-
-                        if (gf_uuid_is_null (entry->d_stat.ia_gfid)) {
-                                gf_log (this->name, GF_LOG_ERROR, "%s/%s"
-                                        " gfid not present", loc->path,
-                                         entry->d_name);
-                                continue;
-                        }
-
-
-                        gf_uuid_copy (entry_loc.gfid, entry->d_stat.ia_gfid);
-
-                        /*In case the gfid stored in the inode by inode_link
-                         * and the gfid obtained in the lookup differs, then
-                         * client3_3_lookup_cbk will return ESTALE and proper
-                         * error will be captured
-                         */
-
-                        linked_inode = inode_link (entry_loc.inode, loc->inode,
-                                                   entry->d_name,
-                                                   &entry->d_stat);
-
-                        inode = entry_loc.inode;
-                        entry_loc.inode = linked_inode;
-                        inode_unref (inode);
-
-                        if (gf_uuid_is_null (loc->gfid)) {
-                                gf_log (this->name, GF_LOG_ERROR, "%s/%s"
-                                        " gfid not present", loc->path,
-                                         entry->d_name);
-                                continue;
-                        }
-
-                        gf_uuid_copy (entry_loc.pargfid, loc->gfid);
-
-                        ret = syncop_lookup (this, &entry_loc, &iatt, NULL,
-                                             NULL, NULL);
-                        if (ret) {
-                                if (-ret == ENOENT || -ret == ESTALE) {
-                                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                                "Dir:%s renamed or removed. "
-                                                "Skipping", loc->path);
-                                                ret = 0;
-                                        continue;
-                                } else {
-                                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                                "lookup failed for:%s",
-                                                entry_loc.path);
-
-                                        defrag->total_failures++;
-
-                                        if (conf->decommission_in_progress) {
-                                                defrag->defrag_status =
-                                                GF_DEFRAG_STATUS_FAILED;
-                                                ret = -1;
-                                                goto out;
-                                        } else {
-                                                should_commit_hash = 0;
-                                                continue;
-                                        }
-                                }
-                        }
+            ret = gf_defrag_fix_layout(this, defrag, &entry_loc, fix_layout,
+                                       migrate_data);
 
-                        /* A return value of 2 means, either process_dir or
-                         * lookup of a dir failed. Hence, don't commit hash
-                         * for the current directory*/
-
-                        ret = gf_defrag_fix_layout (this, defrag, &entry_loc,
-                                                    fix_layout, migrate_data);
-
-                        if (ret && ret != 2) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_LAYOUT_FIX_FAILED,
-                                        "Fix layout failed for %s",
-                                        entry_loc.path);
-
-                                defrag->total_failures++;
+            if (defrag->defrag_status == GF_DEFRAG_STATUS_STOPPED ||
+                defrag->defrag_status == GF_DEFRAG_STATUS_FAILED) {
+                goto out;
+            }
 
-                                if (conf->decommission_in_progress) {
-                                        defrag->defrag_status =
-                                        GF_DEFRAG_STATUS_FAILED;
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_FIX_FAILED,
+                       "Fix layout failed for %s", entry_loc.path);
 
-                                        goto out;
-                                } else {
-                                        /* Let's not commit-hash if
-                                         * gf_defrag_fix_layout failed*/
-                                        continue;
-                                }
-                        }
-                }
+                defrag->total_failures++;
 
-                gf_dirent_free (&entries);
-                free_entries = _gf_false;
-                INIT_LIST_HEAD (&entries.list);
-        }
+                if (conf->decommission_in_progress) {
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-        ret = syncop_setxattr (this, loc, fix_layout, 0, NULL, NULL);
-        if (ret) {
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_LAYOUT_FIX_FAILED,
-                                "Setxattr failed. Dir %s "
-                                "renamed or removed",
-                                loc->path);
-                        ret = 0;
+                    goto out;
                 } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_LAYOUT_FIX_FAILED,
-                                "Setxattr failed for %s",
-                                loc->path);
-
-                        defrag->total_failures++;
-
-                        if (conf->decommission_in_progress) {
-                                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                                ret = -1;
-                                goto out;
-                        }
-                 }
-        }
-
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
-            (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX)) {
-                ret = gf_defrag_process_dir (this, defrag, loc, migrate_data,
-                                             &perrno);
-
-                if (ret && (ret != 2)) {
-                        if (perrno == ENOENT || perrno == ESTALE) {
-                                ret = 0;
-                                goto out;
-                        } else {
-
-                                defrag->total_failures++;
-
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DEFRAG_PROCESS_DIR_FAILED,
-                                        "gf_defrag_process_dir failed for "
-                                        "directory: %s", loc->path);
-
-                                if (conf->decommission_in_progress) {
-                                        goto out;
-                                }
-
-                                should_commit_hash = 0;
-                        }
-                } else if (ret == 2) {
-                        should_commit_hash = 0;
+                    /* Let's not commit-hash if
+                     * gf_defrag_fix_layout failed*/
+                    continue;
                 }
-        }
-
-        gf_msg_trace (this->name, 0, "fix layout called on %s", loc->path);
-
-        if (should_commit_hash &&
-            gf_defrag_settle_hash (this, defrag, loc, fix_layout) != 0) {
-
+            }
+        }
+
+        gf_dirent_free(&entries);
+        free_entries = _gf_false;
+        INIT_LIST_HEAD(&entries.list);
+    }
+
+    /* A directory layout is fixed only after its subdirs are healed to
+     * any newly added bricks. If the layout is fixed before subdirs are
+     * healed, the newly added brick will get a non-null layout.
+     * Any subdirs which hash to that layout will no longer show up
+     * in a directory listing until they are healed.
+     */
+
+    ret = syncop_setxattr(this, loc, fix_layout, 0, NULL, NULL);
+
+    /* In case of a race where the directory is deleted just before
+     * layout setxattr, the errors are updated in the layout structure.
+     * We can use this information to make a decision whether the directory
+     * is deleted entirely.
+     */
+    if (ret == 0) {
+        ret = dht_dir_layout_error_check(this, loc->inode);
+        ret = -ret;
+    }
+
+    if (ret) {
+        if (-ret == ENOENT || -ret == ESTALE) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+                   "Setxattr failed. Dir %s "
+                   "renamed or removed",
+                   loc->path);
+            if (conf->decommission_subvols_cnt) {
                 defrag->total_failures++;
+            }
+            ret = 0;
+            goto out;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+                   "Setxattr failed for %s", loc->path);
 
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SETTLE_HASH_FAILED,
-                        "Settle hash failed for %s",
-                         loc->path);
+            defrag->total_failures++;
 
+            if (conf->decommission_in_progress) {
+                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
                 ret = -1;
-
-                if (conf->decommission_in_progress) {
-                        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                        goto out;
-                }
-        }
-
-        ret = 0;
-out:
-        if (free_entries)
-                gf_dirent_free (&entries);
-
-        loc_wipe (&entry_loc);
-
-        if (fd)
-                fd_unref (fd);
-
-        if (ret == 0 && should_commit_hash == 0) {
-                ret = 2;
+                goto out;
+            }
         }
+    }
 
-        return ret;
-
-}
+    if (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX) {
+        ret = gf_defrag_process_dir(this, defrag, loc, migrate_data, &perrno);
 
-
-
-/******************************************************************************
- *                      Tier background Fix layout functions
- ******************************************************************************/
-/* This is the background tier fixlayout thread */
-void *
-gf_tier_do_fix_layout (void *args)
-{
-        gf_tier_fix_layout_arg_t *tier_fix_layout_arg   =  args;
-        int                 ret                         = -1;
-        xlator_t            *this                       = NULL;
-        dht_conf_t          *conf                       = NULL;
-        gf_defrag_info_t    *defrag                     = NULL;
-        dict_t              *dict                       = NULL;
-        loc_t               loc                         = {0,};
-        struct iatt         iatt                        = {0,};
-        struct iatt         parent                      = {0,};
-
-        GF_VALIDATE_OR_GOTO ("tier", tier_fix_layout_arg, out);
-        GF_VALIDATE_OR_GOTO ("tier", tier_fix_layout_arg->this, out);
-        this = tier_fix_layout_arg->this;
-
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-        GF_VALIDATE_OR_GOTO (this->name, defrag->root_inode, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, tier_fix_layout_arg->fix_layout, out);
-
-
-        /* Get Root loc_t */
-        dht_build_root_loc (defrag->root_inode, &loc);
-        ret = syncop_lookup (this, &loc, &iatt, &parent, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Lookup on root failed.");
-                ret = -1;
+            if (perrno == ENOENT || perrno == ESTALE) {
+                ret = 0;
                 goto out;
-        }
-
+            } else {
+                defrag->total_failures++;
 
-        /* Start the crawl */
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS, "Tiering Fixlayout started");
+                gf_msg(this->name, GF_LOG_ERROR, 0,
+                       DHT_MSG_DEFRAG_PROCESS_DIR_FAILED,
+                       "gf_defrag_process_dir failed for "
+                       "directory: %s",
+                       loc->path);
 
-        ret = gf_defrag_fix_layout (this, defrag, &loc,
-                                    tier_fix_layout_arg->fix_layout, NULL);
-        if (ret && ret != 2) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_FAILED,
-                        "Tiering fixlayout failed.");
-                ret = -1;
-                goto out;
+                if (conf->decommission_in_progress) {
+                    goto out;
+                }
+            }
         }
+    }
 
-        if (ret != 2 && gf_defrag_settle_hash
-                        (this, defrag, &loc,
-                                tier_fix_layout_arg->fix_layout) != 0) {
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
-        }
+    gf_msg_trace(this->name, 0, "fix layout called on %s", loc->path);
 
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    if (gf_defrag_settle_hash(this, defrag, loc, fix_layout) != 0) {
+        defrag->total_failures++;
 
-        ret = dict_set_str (dict, GF_XATTR_TIER_LAYOUT_FIXED_KEY, "yes");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        GF_XATTR_TIER_LAYOUT_FIXED_KEY);
-                ret = -1;
-                goto out;
-        }
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SETTLE_HASH_FAILED,
+               "Settle hash failed for %s", loc->path);
 
-        /* Marking the completion of tiering fix layout via a xattr on root */
-        ret = syncop_setxattr (this, &loc, dict, 0, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to set tiering fix "
-                        "layout completed xattr on %s", loc.path);
-                ret = -1;
-                goto out;
+        ret = -1;
+
+        if (conf->decommission_in_progress) {
+            defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret)
-                defrag->total_failures++;
+    if (free_entries)
+        gf_dirent_free(&entries);
 
-        if (dict)
-                dict_unref (dict);
+    loc_wipe(&entry_loc);
 
-        return NULL;
+    if (fd)
+        fd_unref(fd);
+
+    return ret;
 }
 
 int
-gf_tier_start_fix_layout (xlator_t *this,
-                         loc_t *loc,
-                         gf_defrag_info_t *defrag,
-                         dict_t *fix_layout)
+dht_init_local_subvols_and_nodeuuids(xlator_t *this, dht_conf_t *conf,
+                                     loc_t *loc)
 {
-        int ret                                       = -1;
-        dict_t  *tier_dict                            = NULL;
-        gf_tier_fix_layout_arg_t *tier_fix_layout_arg = NULL;
-
-        tier_dict = dict_new ();
-        if (!tier_dict) {
-                gf_log ("tier", GF_LOG_ERROR, "Tier fix layout failed :"
-                        "Creation of tier_dict failed");
-                ret = -1;
-                goto out;
-        }
-
-        /* Check if layout is fixed already */
-        ret = syncop_getxattr (this, loc, &tier_dict,
-                                GF_XATTR_TIER_LAYOUT_FIXED_KEY,
-                                NULL, NULL);
-        if (ret != 0) {
-
-                tier_fix_layout_arg = &defrag->tier_conf.tier_fix_layout_arg;
-
-                /*Fill crawl arguments */
-                tier_fix_layout_arg->this = this;
-                tier_fix_layout_arg->fix_layout = fix_layout;
+    dict_t *dict = NULL;
+    uuid_t *uuid_ptr = NULL;
+    int ret = -1;
+    int i = 0;
+    int j = 0;
+
+    /* Find local subvolumes */
+    ret = syncop_getxattr(this, loc, &dict, GF_REBAL_FIND_LOCAL_SUBVOL, NULL,
+                          NULL);
+    if (ret && (ret != -ENODATA)) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, 0,
+               "local "
+               "subvolume determination failed with error: %d",
+               -ret);
+        ret = -1;
+        goto out;
+    }
+
+    if (!ret)
+        goto out;
+
+    ret = syncop_getxattr(this, loc, &dict, GF_REBAL_OLD_FIND_LOCAL_SUBVOL,
+                          NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, 0,
+               "local "
+               "subvolume determination failed with error: %d",
+               -ret);
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 
-                /* Spawn the fix layout thread so that its done in the
-                 * background */
-                ret = gf_thread_create (&tier_fix_layout_arg->thread_id, NULL,
-                                        gf_tier_do_fix_layout,
-                                        tier_fix_layout_arg, "tierfixl");
-                if (ret) {
-                        gf_log ("tier", GF_LOG_ERROR, "Thread creation failed. "
-                                "Background fix layout for tiering will not "
-                                "work.");
-                        defrag->total_failures++;
-                        goto out;
-                }
-        }
-        ret = 0;
 out:
-        if (tier_dict)
-                dict_unref (tier_dict);
-
+    if (ret) {
         return ret;
-}
+    }
 
-void
-gf_tier_clear_fix_layout (xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
-{
-        int ret         = -1;
-        dict_t *dict    = NULL;
-
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc, out);
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-
-        /* Check if background fixlayout is completed. This is not
-         * multi-process safe i.e there is a possibility that by the time
-         * we move to remove the xattr there it might have been cleared by some
-         * other detach process from other node. We ignore the error if such
-         * a thing happens */
-        ret = syncop_getxattr (this, loc, &dict,
-                        GF_XATTR_TIER_LAYOUT_FIXED_KEY, NULL, NULL);
-        if (ret) {
-                /* Background fixlayout not complete - nothing to clear*/
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Unable to retrieve fixlayout xattr."
-                        "Assume background fix layout not complete");
-                goto out;
-        }
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "local subvol: "
+               "%s",
+               conf->local_subvols[i]->name);
 
-        ret = syncop_removexattr (this, loc, GF_XATTR_TIER_LAYOUT_FIXED_KEY,
-                                  NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Failed removing tier fix layout "
-                        "xattr from %s", loc->path);
-                goto out;
+        for (j = 0; j < conf->local_nodeuuids[i].count; j++) {
+            uuid_ptr = &(conf->local_nodeuuids[i].elements[j].uuid);
+            gf_msg(this->name, GF_LOG_INFO, 0, 0, "node uuid : %s",
+                   uuid_utoa(*uuid_ptr));
         }
-        ret = 0;
-out:
-        if (dict)
-                dict_unref (dict);
-}
+    }
 
-void
-gf_tier_wait_fix_lookup (gf_defrag_info_t *defrag) {
-        if (defrag->tier_conf.tier_fix_layout_arg.thread_id) {
-                pthread_join (defrag->tier_conf.tier_fix_layout_arg.thread_id,
-                        NULL);
-        }
+    return ret;
 }
-/******************Tier background Fix layout functions END********************/
 
+/* Functions for the rebalance estimates feature */
 
 uint64_t
-gf_defrag_subvol_file_size (xlator_t *this, loc_t *root_loc)
+gf_defrag_subvol_file_size(xlator_t *this, loc_t *root_loc)
 {
-        int ret = -1;
-        struct statvfs buf = {0,};
-
-        if (!this)
-                return 0;
-
-        ret = syncop_statfs (this, root_loc, &buf, NULL, NULL);
-        if (ret) {
-                /* Aargh! */
-                return 0;
-        }
-        return ((buf.f_blocks - buf.f_bfree) * buf.f_frsize);
+    int ret = -1;
+    struct statvfs buf = {
+        0,
+    };
+
+    ret = syncop_statfs(this, root_loc, &buf, NULL, NULL);
+    if (ret) {
+        /* Aargh! */
+        return 0;
+    }
+    return ((buf.f_blocks - buf.f_bfree) * buf.f_frsize);
 }
 
 uint64_t
-gf_defrag_subvol_file_cnt (xlator_t *this, loc_t *root_loc)
+gf_defrag_total_file_size(xlator_t *this, loc_t *root_loc)
 {
-        int ret = -1;
-        struct statvfs buf = {0,};
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    uint64_t size_files = 0;
+    uint64_t total_size = 0;
 
-        if (!this)
-                return 0;
-
-        ret = syncop_statfs (this, root_loc, &buf, NULL, NULL);
-        if (ret) {
-                /* Aargh! */
-                return 0;
-        }
-        return (buf.f_files - buf.f_ffree);
+    conf = this->private;
+    if (!conf) {
+        return 0;
+    }
+
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        size_files = gf_defrag_subvol_file_size(conf->local_subvols[i],
+                                                root_loc);
+        total_size += size_files;
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "local subvol: %s,"
+               "cnt = %" PRIu64,
+               conf->local_subvols[i]->name, size_files);
+    }
+
+    gf_msg(this->name, GF_LOG_INFO, 0, 0, "Total size files = %" PRIu64,
+           total_size);
+
+    return total_size;
 }
 
-
-uint64_t
-gf_defrag_total_file_size (xlator_t *this, loc_t *root_loc)
+static void *
+dht_file_counter_thread(void *args)
 {
-        dht_conf_t    *conf  = NULL;
-        int            i     = 0;
-        uint64_t       size_files = 0;
-        uint64_t       total_size = 0;
-
-        conf = this->private;
-        if (!conf) {
-                return 0;
-        }
+    gf_defrag_info_t *defrag = NULL;
+    loc_t root_loc = {
+        0,
+    };
+    struct timespec time_to_wait = {
+        0,
+    };
+    uint64_t tmp_size = 0;
+
+    if (!args)
+        return NULL;
 
-        for (i = 0 ; i < conf->local_subvols_cnt; i++) {
-                size_files = gf_defrag_subvol_file_size (conf->local_subvols[i],
-                                                       root_loc);
-                total_size += size_files;
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "local subvol: %s,"
-                        "cnt = %"PRIu64, conf->local_subvols[i]->name,
-                        size_files);
-        }
+    defrag = (gf_defrag_info_t *)args;
+    dht_build_root_loc(defrag->root_inode, &root_loc);
 
-        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                "Total size files = %"PRIu64, total_size);
+    while (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED) {
+        timespec_now(&time_to_wait);
+        time_to_wait.tv_sec += 600;
 
-        return total_size;
-}
+        pthread_mutex_lock(&defrag->fc_mutex);
+        pthread_cond_timedwait(&defrag->fc_wakeup_cond, &defrag->fc_mutex,
+                               &time_to_wait);
 
+        pthread_mutex_unlock(&defrag->fc_mutex);
 
-uint64_t
-gf_defrag_total_file_cnt (xlator_t *this, loc_t *root_loc)
-{
-        dht_conf_t    *conf  = NULL;
-        int            i     = 0;
-        uint64_t       num_files = 0;
-        uint64_t       total_entries = 0;
-
-        conf = this->private;
-        if (!conf) {
-                return 0;
-        }
-
-        for (i = 0 ; i < conf->local_subvols_cnt; i++) {
-                num_files = gf_defrag_subvol_file_cnt (conf->local_subvols[i],
-                                                       root_loc);
-                total_entries += num_files;
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "local subvol: %s,"
-                        "cnt = %"PRIu64, conf->local_subvols[i]->name,
-                        num_files);
-        }
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
+            break;
 
-        /* FIXFIXFIX: halve the number of files to negate .glusterfs contents
-           We need a better way to figure this out */
+        tmp_size = gf_defrag_total_file_size(defrag->this, &root_loc);
 
-        total_entries = total_entries/2;
-        if (total_entries > 20000)
-                total_entries += 10000;
+        gf_log("dht", GF_LOG_INFO, "tmp data size =%" PRIu64, tmp_size);
 
-        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                "Total number of files = %"PRIu64, total_entries);
+        if (!tmp_size) {
+            gf_msg("dht", GF_LOG_ERROR, 0, 0,
+                   "Failed to get "
+                   "the total data size. Unable to estimate "
+                   "time to complete rebalance.");
+        } else {
+            g_totalsize = tmp_size;
+            gf_msg_debug("dht", 0, "total data size =%" PRIu64, g_totalsize);
+        }
+    }
 
-        return total_entries;
+    return NULL;
 }
 
+int
+gf_defrag_estimates_cleanup(xlator_t *this, gf_defrag_info_t *defrag,
+                            pthread_t filecnt_thread)
+{
+    int ret = -1;
+
+    /* Wake up the filecounter thread.
+     * By now the defrag status will no longer be
+     * GF_DEFRAG_STATUS_STARTED so the thread will exit the loop.
+     */
+    pthread_mutex_lock(&defrag->fc_mutex);
+    {
+        pthread_cond_broadcast(&defrag->fc_wakeup_cond);
+    }
+    pthread_mutex_unlock(&defrag->fc_mutex);
+
+    ret = pthread_join(filecnt_thread, NULL);
+    if (ret) {
+        gf_msg("dht", GF_LOG_ERROR, ret, 0,
+               "file_counter_thread: pthread_join failed.");
+        ret = -1;
+    }
+    return ret;
+}
 
+int
+gf_defrag_estimates_init(xlator_t *this, loc_t *loc, pthread_t *filecnt_thread)
+{
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+
+    conf = this->private;
+    defrag = conf->defrag;
+
+    g_totalsize = gf_defrag_total_file_size(this, loc);
+    if (!g_totalsize) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+               "Failed to get "
+               "the total data size. Unable to estimate "
+               "time to complete rebalance.");
+        goto out;
+    }
+
+    ret = gf_thread_create(filecnt_thread, NULL, dht_file_counter_thread,
+                           (void *)defrag, "dhtfcnt");
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ret, 0,
+               "Failed to "
+               "create the file counter thread ");
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
+out:
+    return ret;
+}
 
+/* Init and cleanup functions for parallel file migration*/
 int
-dht_get_local_subvols_and_nodeuuids (xlator_t *this, dht_conf_t *conf,
-                                     loc_t *loc)
+gf_defrag_parallel_migration_init(xlator_t *this, gf_defrag_info_t *defrag,
+                                  pthread_t **tid_array, int *thread_index)
 {
+    int ret = -1;
+    int thread_spawn_count = 0;
+    int index = 0;
+    pthread_t *tid = NULL;
 
-        dict_t                  *dict         = NULL;
-        gf_defrag_info_t        *defrag       = NULL;
-        int                      ret          = -1;
+    if (!defrag)
+        goto out;
 
-        defrag = conf->defrag;
+    /* Initialize global entry queue */
+    defrag->queue = GF_CALLOC(1, sizeof(struct dht_container),
+                              gf_dht_mt_container_t);
 
-        if (defrag->cmd != GF_DEFRAG_CMD_START_TIER) {
-                /* Find local subvolumes */
-                ret = syncop_getxattr (this, loc, &dict,
-                                       GF_REBAL_FIND_LOCAL_SUBVOL,
-                                       NULL, NULL);
-                if (ret && (ret != -ENODATA)) {
+    if (!defrag->queue) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, 0,
+               "Failed to initialise migration queue");
+        ret = -1;
+        goto out;
+    }
 
-                        gf_msg (this->name, GF_LOG_ERROR, -ret, 0, "local "
-                                "subvolume determination failed with error: %d",
-                                -ret);
-                        ret = -1;
-                        goto out;
-                 }
+    INIT_LIST_HEAD(&(defrag->queue[0].list));
 
-        if (!ret)
-                goto out;
-        }
+    thread_spawn_count = MAX(MAX_REBAL_THREADS, 4);
 
-        ret = syncop_getxattr (this, loc, &dict,
-                               GF_REBAL_OLD_FIND_LOCAL_SUBVOL,
-                               NULL, NULL);
-        if (ret) {
+    gf_msg_debug(this->name, 0, "thread_spawn_count: %d", thread_spawn_count);
 
-                gf_msg (this->name, GF_LOG_ERROR, -ret, 0, "local "
-                        "subvolume determination failed with error: %d",
-                        -ret);
-                ret = -1;
-                goto out;
+    tid = GF_CALLOC(thread_spawn_count, sizeof(pthread_t),
+                    gf_common_mt_pthread_t);
+    if (!tid) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, 0,
+               "Failed to create migration threads");
+        ret = -1;
+        goto out;
+    }
+    defrag->current_thread_count = thread_spawn_count;
+
+    /*Spawn Threads Here*/
+    while (index < thread_spawn_count) {
+        ret = gf_thread_create(&(tid[index]), NULL, gf_defrag_task,
+                               (void *)defrag, "dhtmig%d", (index + 1) & 0x3ff);
+        if (ret != 0) {
+            gf_msg("DHT", GF_LOG_ERROR, ret, 0, "Thread[%d] creation failed. ",
+                   index);
+            ret = -1;
+            goto out;
+        } else {
+            gf_log("DHT", GF_LOG_INFO,
+                   "Thread[%d] "
+                   "creation successful",
+                   index);
         }
-        ret = 0;
+        index++;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    *thread_index = index;
+    *tid_array = tid;
+
+    return ret;
 }
 
-static void*
-dht_file_counter_thread (void *args)
+int
+gf_defrag_parallel_migration_cleanup(gf_defrag_info_t *defrag,
+                                     pthread_t *tid_array, int thread_index)
 {
-        gf_defrag_info_t *defrag      = NULL;
-        loc_t root_loc                = {0,};
-        struct timespec time_to_wait  = {0,};
-        struct timeval now            = {0,};
-        uint64_t tmp_size             = 0;
-
-
-        if (!args)
-                return NULL;
+    int ret = -1;
+    int i = 0;
 
-        defrag = (gf_defrag_info_t *) args;
-        dht_build_root_loc (defrag->root_inode, &root_loc);
+    if (!defrag)
+        goto out;
 
-        while (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED) {
+    /* Wake up all migration threads */
+    pthread_mutex_lock(&defrag->dfq_mutex);
+    {
+        defrag->crawl_done = 1;
 
-                gettimeofday (&now, NULL);
-                time_to_wait.tv_sec = now.tv_sec + 600;
-                time_to_wait.tv_nsec = 0;
+        pthread_cond_broadcast(&defrag->parallel_migration_cond);
+        pthread_cond_broadcast(&defrag->df_wakeup_thread);
+    }
+    pthread_mutex_unlock(&defrag->dfq_mutex);
 
+    /*Wait for all the threads to complete their task*/
+    for (i = 0; i < thread_index; i++) {
+        pthread_join(tid_array[i], NULL);
+    }
 
-                pthread_mutex_lock (&defrag->fc_mutex);
-                pthread_cond_timedwait (&defrag->fc_wakeup_cond,
-                                        &defrag->fc_mutex,
-                                        &time_to_wait);
+    GF_FREE(tid_array);
 
-                pthread_mutex_unlock (&defrag->fc_mutex);
-
-
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
-                        break;
+    /* Cleanup the migration queue */
+    if (defrag->queue) {
+        gf_dirent_free(defrag->queue[0].df_entry);
+        INIT_LIST_HEAD(&(defrag->queue[0].list));
+    }
 
-                tmp_size = gf_defrag_total_file_size (defrag->this,
-                                                         &root_loc);
+    GF_FREE(defrag->queue);
 
-                gf_log ("dht", GF_LOG_INFO,
-                        "tmp data size =%"PRIu64,
-                        tmp_size);
-
-                if (!tmp_size) {
-                        gf_msg ("dht", GF_LOG_ERROR, 0, 0, "Failed to get "
-                                "the total data size. Unable to estimate "
-                                "time to complete rebalance.");
-                } else {
-                        g_totalsize = tmp_size;
-                        gf_msg_debug ("dht", 0,
-                                      "total data size =%"PRIu64,
-                                      g_totalsize);
-                }
-        }
-
-        return NULL;
+    ret = 0;
+out:
+    return ret;
 }
 
-
-
 int
-gf_defrag_start_crawl (void *data)
+gf_defrag_start_crawl(void *data)
 {
-        xlator_t                *this                   = NULL;
-        dht_conf_t              *conf                   = NULL;
-        gf_defrag_info_t        *defrag                 = NULL;
-        int                      ret                    = -1;
-        loc_t                    loc                    = {0,};
-        struct iatt              iatt                   = {0,};
-        struct iatt              parent                 = {0,};
-        dict_t                  *fix_layout             = NULL;
-        dict_t                  *migrate_data           = NULL;
-        dict_t                  *status                 = NULL;
-        dict_t                  *dict                   = NULL;
-        glusterfs_ctx_t         *ctx                    = NULL;
-        dht_methods_t           *methods                = NULL;
-        int                      i                      = 0;
-        int                      thread_index           = 0;
-        int                      err                    = 0;
-        int                      thread_spawn_count     = 0;
-        pthread_t               *tid                    = NULL;
-        char                    thread_name[GF_THREAD_NAMEMAX] = {0,};
-        pthread_t                filecnt_thread;
-        gf_boolean_t             is_tier_detach         = _gf_false;
-        call_frame_t            *statfs_frame           = NULL;
-        xlator_t                *old_THIS               = NULL;
-        int                      j                      = 0;
-        gf_boolean_t             fc_thread_started      = _gf_false;
-        uuid_t                  *uuid_ptr               = NULL;
-
-        this = data;
-        if (!this)
-                goto exit;
-
-        ctx = this->ctx;
-        if (!ctx)
-                goto exit;
-
-        conf = this->private;
-        if (!conf)
-                goto exit;
-
-        defrag = conf->defrag;
-        if (!defrag)
-                goto exit;
-
-        gettimeofday (&defrag->start_time, NULL);
-        dht_build_root_inode (this, &defrag->root_inode);
-        if (!defrag->root_inode)
-                goto out;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    dict_t *fix_layout = NULL;
+    dict_t *migrate_data = NULL;
+    dict_t *status = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    call_frame_t *statfs_frame = NULL;
+    xlator_t *old_THIS = NULL;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    struct iatt parent = {
+        0,
+    };
+    int thread_index = 0;
+    pthread_t *tid = NULL;
+    pthread_t filecnt_thread;
+    gf_boolean_t fc_thread_started = _gf_false;
+
+    this = data;
+    if (!this)
+        goto exit;
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto exit;
+
+    conf = this->private;
+    if (!conf)
+        goto exit;
+
+    defrag = conf->defrag;
+    if (!defrag)
+        goto exit;
+
+    defrag->start_time = gf_time();
+
+    dht_build_root_inode(this, &defrag->root_inode);
+    if (!defrag->root_inode)
+        goto out;
+
+    dht_build_root_loc(defrag->root_inode, &loc);
+
+    /* fix-layout on '/' first */
+
+    ret = syncop_lookup(this, &loc, &iatt, &parent, NULL, NULL);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_REBALANCE_START_FAILED,
+               "Failed to start rebalance: look up on / failed");
+        ret = -1;
+        goto out;
+    }
 
-        dht_build_root_loc (defrag->root_inode, &loc);
+    old_THIS = THIS;
+    THIS = this;
 
-        /* fix-layout on '/' first */
+    statfs_frame = create_frame(this, this->ctx->pool);
+    if (!statfs_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+               "Insufficient memory. Frame creation failed");
+        ret = -1;
+        goto out;
+    }
 
-        ret = syncop_lookup (this, &loc, &iatt, &parent, NULL, NULL);
+    /* async statfs update for honoring min-free-disk */
+    dht_get_du_info(statfs_frame, this, &loc);
+    THIS = old_THIS;
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Failed to start rebalance: look up on / failed");
-                ret = -1;
-                goto out;
-        }
+    fix_layout = dict_new();
+    if (!fix_layout) {
+        ret = -1;
+        goto out;
+    }
+
+    /*
+     * Unfortunately, we can't do special xattrs (like fix.layout) and
+     * real ones in the same call currently, and changing it seems
+     * riskier than just doing two calls.
+     */
+
+    gf_log(this->name, GF_LOG_INFO, "%s using commit hash %u", __func__,
+           conf->vol_commit_hash);
+
+    ret = dict_set_uint32(fix_layout, conf->commithash_xattr_name,
+                          conf->vol_commit_hash);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to set %s",
+               conf->commithash_xattr_name);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_setxattr(this, &loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to set commit hash on %s. "
+               "Rebalance cannot proceed.",
+               loc.path);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
+
+    /* We now return to our regularly scheduled program. */
+
+    ret = dict_set_str(fix_layout, GF_XATTR_FIX_LAYOUT_KEY, "yes");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+               "Failed to start rebalance:"
+               "Failed to set dictionary value: key = %s",
+               GF_XATTR_FIX_LAYOUT_KEY);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        old_THIS = THIS;
-        THIS = this;
+    defrag->new_commit_hash = conf->vol_commit_hash;
 
-        statfs_frame = create_frame (this, this->ctx->pool);
-        if (!statfs_frame) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
-                        "Insufficient memory. Frame creation failed");
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_setxattr(this, &loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_REBALANCE_FAILED,
+               "fix layout on %s failed", loc.path);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        /* async statfs update for honoring min-free-disk */
-        dht_get_du_info (statfs_frame, this, &loc);
-        THIS = old_THIS;
+    if (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX) {
+        /* We need to migrate files */
 
-        fix_layout = dict_new ();
-        if (!fix_layout) {
-                ret = -1;
-                goto out;
+        migrate_data = dict_new();
+        if (!migrate_data) {
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
-
-        /*
-         * Unfortunately, we can't do special xattrs (like fix.layout) and
-         * real ones in the same call currently, and changing it seems
-         * riskier than just doing two calls.
-         */
-
-        gf_log (this->name, GF_LOG_INFO, "%s using commit hash %u",
-                __func__, conf->vol_commit_hash);
-
-        ret = dict_set_uint32 (fix_layout, conf->commithash_xattr_name,
-                               conf->vol_commit_hash);
+        ret = dict_set_str(
+            migrate_data, GF_XATTR_FILE_MIGRATE_KEY,
+            (defrag->cmd == GF_DEFRAG_CMD_START_FORCE) ? "force" : "non-force");
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set %s", conf->commithash_xattr_name);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_setxattr (this, &loc, fix_layout, 0, NULL, NULL);
+        ret = dht_init_local_subvols_and_nodeuuids(this, conf, &loc);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "fix layout on %s failed",
-                        loc.path);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            ret = -1;
+            goto out;
         }
 
-        /* We now return to our regularly scheduled program. */
-
-        ret = dict_set_str (fix_layout, GF_XATTR_FIX_LAYOUT_KEY, "yes");
+        /* Initialise the structures required for parallel migration */
+        ret = gf_defrag_parallel_migration_init(this, defrag, &tid,
+                                                &thread_index);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Failed to start rebalance:"
-                        "Failed to set dictionary value: key = %s",
-                        GF_XATTR_FIX_LAYOUT_KEY);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, 0, "Aborting rebalance.");
+            goto out;
         }
 
-        defrag->new_commit_hash = conf->vol_commit_hash;
-
-        ret = syncop_setxattr (this, &loc, fix_layout, 0, NULL, NULL);
+        ret = gf_defrag_estimates_init(this, &loc, &filecnt_thread);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_FAILED,
-                        "fix layout on %s failed",
-                        loc.path);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
-        }
-
-        if (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX) {
-                migrate_data = dict_new ();
-                if (!migrate_data) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_str (migrate_data, GF_XATTR_FILE_MIGRATE_KEY,
-                        (defrag->cmd == GF_DEFRAG_CMD_START_FORCE)
-                        ?  "force" : "non-force");
-                if (ret) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dht_get_local_subvols_and_nodeuuids (this, conf, &loc);
-                if (ret) {
-                        ret = -1;
-                        goto out;
-                }
-
-                for (i = 0 ; i < conf->local_subvols_cnt; i++) {
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0, "local subvols "
-                                "are %s", conf->local_subvols[i]->name);
-
-                        for (j = 0; j < conf->local_nodeuuids[i].count; j++) {
-                                uuid_ptr = &(conf->local_nodeuuids[i].elements[j].uuid);
-                                gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                                        "node uuids are %s",
-                                        uuid_utoa(*uuid_ptr));
-                        }
-                }
-
-                g_totalsize = gf_defrag_total_file_size (this, &loc);
-                if (!g_totalsize) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0, 0, "Failed to get "
-                                "the total data size. Unable to estimate "
-                                "time to complete rebalance.");
-                }
-
-                g_totalfiles = gf_defrag_total_file_cnt (this, &loc);
-                if (!g_totalfiles) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0, 0, "Failed to get "
-                                "the total number of files. Unable to estimate "
-                                "time to complete rebalance.");
-                }
-
-                ret = gf_thread_create (&filecnt_thread, NULL,
-                                        &dht_file_counter_thread,
-                                        (void *)defrag, "dhtfcnt");
-
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, ret, 0, "Failed to "
-                                "create the file counter thread ");
-                        ret = 0;
-                } else {
-                        fc_thread_started = _gf_true;
-                }
-
-
-                /* Initialize global entry queue */
-                defrag->queue = GF_CALLOC (1, sizeof (struct dht_container),
-                                           gf_dht_mt_container_t);
-
-                if (!defrag->queue) {
-                        gf_log (this->name, GF_LOG_ERROR, "No memory for "
-                                "queue");
-                        ret = -1;
-                        goto out;
-                }
-
-                INIT_LIST_HEAD (&(defrag->queue[0].list));
-
-                thread_spawn_count = MAX (MAX_REBAL_THREADS, 4);
-
-                gf_msg_debug (this->name, 0, "thread_spawn_count: %d",
-                              thread_spawn_count);
-
-                tid = GF_CALLOC (thread_spawn_count, sizeof (pthread_t),
-                                 gf_common_mt_pthread_t);
-                if (!tid) {
-                        gf_log (this->name, GF_LOG_ERROR, "Insufficient memory "
-                                "for tid");
-                        ret = -1;
-                        goto out;
-                }
-
-                defrag->current_thread_count = thread_spawn_count;
-
-                /*Spawn Threads Here*/
-                while (thread_index < thread_spawn_count) {
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "%s%d", "dhtdf", thread_index + 1);
-                        err = gf_thread_create (&(tid[thread_index]), NULL,
-                                                &gf_defrag_task, (void *)defrag,
-                                                thread_name);
-                        if (err != 0) {
-                                gf_log ("DHT", GF_LOG_ERROR,
-                                        "Thread[%d] creation failed. "
-                                        "Aborting Rebalance",
-                                         thread_index);
-                                ret = -1;
-                                goto out;
-                        } else {
-                                gf_log ("DHT", GF_LOG_INFO, "Thread[%d] "
-                                        "creation successful", thread_index);
-                        }
-                        thread_index++;
-                }
-        }
-
-        if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                /* Fix layout for attach tier */
-                ret = gf_tier_start_fix_layout (this, &loc, defrag, fix_layout);
-                if (ret) {
-                        goto out;
-                }
-
-                methods = &(conf->methods);
-
-                /* Calling tier_start of tier.c */
-                methods->migration_other(this, defrag);
-                if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-                    defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-
-                        ret = dict_set_str (migrate_data,
-                                            GF_XATTR_FILE_MIGRATE_KEY,
-                                            "force");
-                        if (ret)
-                                goto out;
-
-                }
+            /* Not a fatal error. Allow the rebalance to proceed*/
+            ret = 0;
         } else {
-                ret = gf_defrag_fix_layout (this, defrag, &loc, fix_layout,
-                                    migrate_data);
-                if (ret && ret != 2) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (ret != 2 && gf_defrag_settle_hash
-                        (this, defrag, &loc, fix_layout) != 0) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-                    defrag->cmd == GF_DEFRAG_CMD_DETACH_START)
-                        is_tier_detach = _gf_true;
-
-        }
-
-        gf_log ("DHT", GF_LOG_INFO, "crawling file-system completed");
-out:
-
-        /* We are here means crawling the entire file system is done
-           or something failed. Set defrag->crawl_done flag to intimate
-           the migrator threads to exhaust the defrag->queue and terminate*/
-
-        if (ret) {
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-        }
-
-        pthread_mutex_lock (&defrag->dfq_mutex);
-        {
-                defrag->crawl_done = 1;
-
-                pthread_cond_broadcast (
-                        &defrag->parallel_migration_cond);
-                pthread_cond_broadcast (
-                        &defrag->df_wakeup_thread);
+            fc_thread_started = _gf_true;
         }
-        pthread_mutex_unlock (&defrag->dfq_mutex);
+    }
 
-        /*Wait for all the threads to complete their task*/
-        for (i = 0; i < thread_index; i++) {
-                pthread_join (tid[i], NULL);
-        }
-
-        GF_FREE (tid);
-
-        if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                /* Wait for the tier fixlayout to
-                 * complete if its was started.*/
-                 gf_tier_wait_fix_lookup (defrag);
-        }
+    ret = gf_defrag_fix_layout(this, defrag, &loc, fix_layout, migrate_data);
+    if (ret) {
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        if (is_tier_detach && ret == 0) {
-                /* If it was a detach remove the tier fix-layout
-                * xattr on root. Ignoring the failure, as nothing has to be
-                * done, logging is done in gf_tier_clear_fix_layout */
-                gf_tier_clear_fix_layout (this, &loc, defrag);
-        }
+    if (gf_defrag_settle_hash(this, defrag, &loc, fix_layout) != 0) {
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        if (defrag->queue) {
-                gf_dirent_free (defrag->queue[0].df_entry);
-                INIT_LIST_HEAD (&(defrag->queue[0].list));
-        }
+    gf_log("DHT", GF_LOG_INFO, "crawling file-system completed");
+out:
 
-        if ((defrag->defrag_status != GF_DEFRAG_STATUS_STOPPED) &&
-            (defrag->defrag_status != GF_DEFRAG_STATUS_FAILED)) {
-                defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
-        }
+    /* We are here means crawling the entire file system is done
+       or something failed. Set defrag->crawl_done flag to intimate
+       the migrator threads to exhaust the defrag->queue and terminate*/
 
-        if (fc_thread_started) {
-                pthread_mutex_lock (&defrag->fc_mutex);
-                {
-                        pthread_cond_broadcast (&defrag->fc_wakeup_cond);
-                }
-                pthread_mutex_unlock (&defrag->fc_mutex);
+    if (ret) {
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+    }
 
-                pthread_join (filecnt_thread, NULL);
-        }
+    gf_defrag_parallel_migration_cleanup(defrag, tid, thread_index);
 
-        dht_send_rebalance_event (this, defrag->cmd, defrag->defrag_status);
+    if ((defrag->defrag_status != GF_DEFRAG_STATUS_STOPPED) &&
+        (defrag->defrag_status != GF_DEFRAG_STATUS_FAILED)) {
+        defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
+    }
 
-        LOCK (&defrag->lock);
-        {
-                status = dict_new ();
-                gf_defrag_status_get (conf, status);
-                if (ctx && ctx->notify)
-                        ctx->notify (GF_EN_DEFRAG_STATUS, status);
-                if (status)
-                        dict_unref (status);
-                defrag->is_exiting = 1;
-        }
-        UNLOCK (&defrag->lock);
+    if (fc_thread_started) {
+        gf_defrag_estimates_cleanup(this, defrag, filecnt_thread);
+    }
 
-        GF_FREE (defrag->queue);
+    dht_send_rebalance_event(this, defrag->cmd, defrag->defrag_status);
 
-        GF_FREE (defrag);
-        conf->defrag = NULL;
+    status = dict_new();
+    LOCK(&defrag->lock);
+    {
+        gf_defrag_status_get(conf, status);
+        if (ctx && ctx->notify)
+            ctx->notify(GF_EN_DEFRAG_STATUS, status);
+        if (status)
+            dict_unref(status);
+        defrag->is_exiting = 1;
+    }
+    UNLOCK(&defrag->lock);
 
-        if (dict)
-                dict_unref (dict);
+    GF_FREE(defrag);
+    conf->defrag = NULL;
 
-        if (migrate_data)
-                dict_unref (migrate_data);
+    if (migrate_data)
+        dict_unref(migrate_data);
 
-        if (statfs_frame) {
-                STACK_DESTROY (statfs_frame->root);
-        }
+    if (statfs_frame) {
+        STACK_DESTROY(statfs_frame->root);
+    }
 exit:
-        return ret;
+    return ret;
 }
 
-
-
 static int
-gf_defrag_done  (int ret, call_frame_t *sync_frame, void *data)
+gf_defrag_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        gf_listener_stop (sync_frame->this);
+    gf_listener_stop(sync_frame->this);
 
-        STACK_DESTROY (sync_frame->root);
-        kill (getpid(), SIGTERM);
-        return 0;
+    STACK_DESTROY(sync_frame->root);
+    kill(getpid(), SIGTERM);
+    return 0;
 }
 
 void *
-gf_defrag_start (void *data)
+gf_defrag_start(void *data)
 {
-        int                      ret    = -1;
-        call_frame_t            *frame  = NULL;
-        dht_conf_t              *conf   = NULL;
-        gf_defrag_info_t        *defrag = NULL;
-        xlator_t                *this  = NULL;
-        xlator_t                *old_THIS = NULL;
-
-        this = data;
-        conf = this->private;
-        if (!conf)
-                goto out;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    xlator_t *this = NULL;
+    xlator_t *old_THIS = NULL;
 
-        defrag = conf->defrag;
-        if (!defrag)
-                goto out;
+    this = data;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+    defrag = conf->defrag;
+    if (!defrag)
+        goto out;
 
-        frame->root->pid = GF_CLIENT_PID_DEFRAG;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-        defrag->pid = frame->root->pid;
+    frame->root->pid = GF_CLIENT_PID_DEFRAG;
 
-        defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
+    defrag->pid = frame->root->pid;
 
-        old_THIS = THIS;
-        THIS = this;
-        ret = synctask_new (this->ctx->env, gf_defrag_start_crawl,
-                            gf_defrag_done, frame, this);
+    defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
 
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Could not create task for rebalance");
-        THIS = old_THIS;
-out:
-        return NULL;
-}
-
-
-uint64_t
-gf_defrag_get_estimates_based_on_size (dht_conf_t *conf)
-{
-        gf_defrag_info_t *defrag = NULL;
-        double            rate_processed = 0;
-        uint64_t          total_processed = 0;
-        uint64_t          tmp_count = 0;
-        uint64_t          time_to_complete = 0;
-        struct            timeval now = {0,};
-        double            elapsed = 0;
-
-        defrag = conf->defrag;
-
-        if (!g_totalsize)
-                goto out;
-
-        gettimeofday (&now, NULL);
-        elapsed = now.tv_sec - defrag->start_time.tv_sec;
-
-        /* Don't calculate the estimates for the first 10 minutes.
-         * It is unlikely to be accurate and estimates are not required
-         * if the process finishes in less than 10 mins.
-         */
-
-        if (elapsed < ESTIMATE_START_INTERVAL) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0, 0,
-                        "Rebalance estimates will not be available for the "
-                        "first %d seconds.", ESTIMATE_START_INTERVAL);
-
-                goto out;
-        }
-
-        total_processed = defrag->size_processed;
-
-        /* rate at which files processed */
-        rate_processed = (total_processed)/elapsed;
-
-        tmp_count = g_totalsize;
-
-        if (rate_processed) {
-                time_to_complete = (tmp_count)/rate_processed;
-
-        } else {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, 0,
-                        "Unable to calculate estimated time for rebalance");
-        }
-
-        gf_log (THIS->name, GF_LOG_INFO,
-                "TIME: (size) total_processed=%"PRIu64" tmp_cnt = %"PRIu64","
-                "rate_processed=%f, elapsed = %f", total_processed, tmp_count,
-                rate_processed, elapsed);
+    old_THIS = THIS;
+    THIS = this;
+    ret = synctask_new(this->ctx->env, gf_defrag_start_crawl, gf_defrag_done,
+                       frame, this);
 
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+               "Could not create task for rebalance");
+    THIS = old_THIS;
 out:
-        return time_to_complete;
+    return NULL;
 }
 
-
-
 uint64_t
-gf_defrag_get_estimates (dht_conf_t *conf)
+gf_defrag_get_estimates_based_on_size(dht_conf_t *conf)
 {
-        gf_defrag_info_t *defrag = NULL;
-        loc_t             loc = {0,};
-        double            rate_lookedup = 0;
-        uint64_t          dirs_processed = 0;
-        uint64_t          files_processed = 0;
-        uint64_t          total_processed = 0;
-        uint64_t          tmp_count = 0;
-        uint64_t          time_to_complete = 0;
-        struct            timeval now = {0,};
-        double            elapsed = 0;
+    gf_defrag_info_t *defrag = NULL;
+    double rate_processed = 0;
+    uint64_t total_processed = 0;
+    uint64_t tmp_count = 0;
+    uint64_t time_to_complete = 0;
+    double elapsed = 0;
 
+    defrag = conf->defrag;
 
-        defrag = conf->defrag;
+    if (!g_totalsize)
+        goto out;
 
-        if (!g_totalfiles)
-                goto out;
+    elapsed = gf_time() - defrag->start_time;
 
-        gettimeofday (&now, NULL);
-        elapsed = now.tv_sec - defrag->start_time.tv_sec;
+    /* Don't calculate the estimates for the first 10 minutes.
+     * It is unlikely to be accurate and estimates are not required
+     * if the process finishes in less than 10 mins.
+     */
 
-        /* I tried locking before accessing num_files_lookedup and
-         * num_dirs_processed but the status function
-         * never seemed to get the lock, causing the status cli to
-         * hang.
-         */
+    if (elapsed < ESTIMATE_START_INTERVAL) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, 0,
+               "Rebalance estimates will not be available for the "
+               "first %d seconds.",
+               ESTIMATE_START_INTERVAL);
 
-        dirs_processed = defrag->num_dirs_processed;
-        files_processed = defrag->num_files_lookedup;
+        goto out;
+    }
 
-        total_processed = files_processed + dirs_processed;
+    total_processed = defrag->size_processed;
 
-        if (total_processed > g_totalfiles) {
-                /* lookup the number of files again
-                 * The problem here is that not all the newly added files
-                 * might need to be processed. So this need not work
-                 * in some cases
-                 */
-                dht_build_root_loc (defrag->root_inode, &loc);
-                g_totalfiles = gf_defrag_total_file_cnt (defrag->this, &loc);
-                if (!g_totalfiles)
-                        goto out;
-        }
+    /* rate at which files processed */
+    rate_processed = (total_processed) / elapsed;
 
-        /* rate at which files looked up */
-        rate_lookedup = (total_processed)/elapsed;
+    tmp_count = g_totalsize;
 
-        /* We initially sum up dirs across all local subvols because we get the
-         * file count from the inodes on each subvol.
-         * The same directories will be counted for each subvol but
-         * we want them to be counted once.
-         */
+    if (rate_processed) {
+        time_to_complete = (tmp_count) / rate_processed;
 
-        tmp_count = g_totalfiles
-                     - (dirs_processed * (conf->local_subvols_cnt - 1));
+    } else {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, 0,
+               "Unable to calculate estimated time for rebalance");
+    }
 
-        if (rate_lookedup) {
-                time_to_complete = (tmp_count)/rate_lookedup;
-
-        } else {
-
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, 0,
-                        "Unable to calculate estimated time for rebalance");
-        }
-
-        gf_log (THIS->name, GF_LOG_INFO,
-                "TIME: (count) total_processed=%"PRIu64" tmp_cnt = %"PRIu64","
-                "rate_lookedup=%f", total_processed, tmp_count,
-                rate_lookedup);
+    gf_log(THIS->name, GF_LOG_INFO,
+           "TIME: (size) total_processed=%" PRIu64 " tmp_cnt = %" PRIu64
+           ","
+           "rate_processed=%f, elapsed = %f",
+           total_processed, tmp_count, rate_processed, elapsed);
 
 out:
-        return time_to_complete;
+    return time_to_complete;
 }
 
-
 int
-gf_defrag_status_get (dht_conf_t *conf, dict_t *dict)
+gf_defrag_status_get(dht_conf_t *conf, dict_t *dict)
 {
-        int      ret    = 0;
-        uint64_t files  = 0;
-        uint64_t size   = 0;
-        uint64_t lookup = 0;
-        uint64_t failures = 0;
-        uint64_t skipped = 0;
-        uint64_t promoted = 0;
-        uint64_t demoted = 0;
-        char    *status = "";
-        double   elapsed = 0;
-        struct timeval end = {0,};
-        uint64_t time_to_complete = 0;
-        uint64_t time_left = 0;
-        gf_defrag_info_t *defrag = conf->defrag;
-
-        if (!defrag)
-                goto out;
-
-        ret = 0;
-        if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED)
-                goto out;
-
-        files  = defrag->total_files;
-        size   = defrag->total_data;
-        lookup = defrag->num_files_lookedup;
-        failures = defrag->total_failures;
-        skipped = defrag->skipped;
-        promoted = defrag->total_files_promoted;
-        demoted = defrag->total_files_demoted;
-
-        gettimeofday (&end, NULL);
-
-        elapsed = end.tv_sec - defrag->start_time.tv_sec;
-
-
-        /* The rebalance is still in progress */
-
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER)
-            && (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED)) {
-
-/*
-                time_to_complete = gf_defrag_get_estimates (conf);
-
-                if (time_to_complete && (time_to_complete > elapsed))
-                        time_left = time_to_complete - elapsed;
-
-                gf_log (THIS->name, GF_LOG_INFO,
-                        "TIME: Estimated total time to complete based on"
-                        " count = %"PRIu64 " seconds, seconds left = %"PRIu64"",
-                        time_to_complete, time_left);
-*/
-
-                time_to_complete = gf_defrag_get_estimates_based_on_size (conf);
-
-                if (time_to_complete && (time_to_complete > elapsed))
-                        time_left = time_to_complete - elapsed;
-
-                gf_log (THIS->name, GF_LOG_INFO,
-                        "TIME: Estimated total time to complete (size)= %"PRIu64
-                        " seconds, seconds left = %"PRIu64"",
-                        time_to_complete, time_left);
-        }
-
-        if (!dict)
-                goto log;
-
-        ret = dict_set_uint64 (dict, "promoted", promoted);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set promoted count");
-
-        ret = dict_set_uint64 (dict, "demoted", demoted);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set demoted count");
-
-        ret = dict_set_uint64 (dict, "files", files);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set file count");
-
-        ret = dict_set_uint64 (dict, "size", size);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set size of xfer");
-
-        ret = dict_set_uint64 (dict, "lookups", lookup);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set lookedup file count");
-
-
-        ret = dict_set_int32 (dict, "status", defrag->defrag_status);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set status");
-
-        ret = dict_set_double (dict, "run-time", elapsed);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set run-time");
-
-        ret = dict_set_uint64 (dict, "failures", failures);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set failure count");
-
-        ret = dict_set_uint64 (dict, "skipped", skipped);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set skipped file count");
-
-        ret = dict_set_uint64 (dict, "time-left", time_left);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set time-left");
+    int ret = 0;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookup = 0;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    char *status = "";
+    double elapsed = 0;
+    uint64_t time_to_complete = 0;
+    uint64_t time_left = 0;
+    gf_defrag_info_t *defrag = conf->defrag;
+
+    if (!defrag)
+        goto out;
+
+    ret = 0;
+    if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED)
+        goto out;
+
+    files = defrag->total_files;
+    size = defrag->total_data;
+    lookup = defrag->num_files_lookedup;
+    failures = defrag->total_failures;
+    skipped = defrag->skipped;
+
+    elapsed = gf_time() - defrag->start_time;
+
+    /* The rebalance is still in progress */
+
+    if (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED) {
+        time_to_complete = gf_defrag_get_estimates_based_on_size(conf);
+
+        if (time_to_complete && (time_to_complete > elapsed))
+            time_left = time_to_complete - elapsed;
+
+        gf_log(THIS->name, GF_LOG_INFO,
+               "TIME: Estimated total time to complete (size)= %" PRIu64
+               " seconds, seconds left = %" PRIu64 "",
+               time_to_complete, time_left);
+    }
+
+    if (!dict)
+        goto log;
+
+    ret = dict_set_uint64(dict, "files", files);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set file count");
+
+    ret = dict_set_uint64(dict, "size", size);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set size of xfer");
+
+    ret = dict_set_uint64(dict, "lookups", lookup);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set lookedup file count");
+
+    ret = dict_set_int32(dict, "status", defrag->defrag_status);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set status");
+
+    ret = dict_set_double(dict, "run-time", elapsed);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set run-time");
+
+    ret = dict_set_uint64(dict, "failures", failures);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set failure count");
+
+    ret = dict_set_uint64(dict, "skipped", skipped);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set skipped file count");
+
+    ret = dict_set_uint64(dict, "time-left", time_left);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set time-left");
 
 log:
-        switch (defrag->defrag_status) {
+    switch (defrag->defrag_status) {
         case GF_DEFRAG_STATUS_NOT_STARTED:
-                status = "not started";
-                break;
+            status = "not started";
+            break;
         case GF_DEFRAG_STATUS_STARTED:
-                status = "in progress";
-                break;
+            status = "in progress";
+            break;
         case GF_DEFRAG_STATUS_STOPPED:
-                status = "stopped";
-                break;
+            status = "stopped";
+            break;
         case GF_DEFRAG_STATUS_COMPLETE:
-                status = "completed";
-                break;
+            status = "completed";
+            break;
         case GF_DEFRAG_STATUS_FAILED:
-                status = "failed";
-                break;
+            status = "failed";
+            break;
         default:
-                break;
-        }
-
-        gf_msg (THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
-                "Rebalance is %s. Time taken is %.2f secs",
-                status, elapsed);
-        gf_msg (THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
-                "Files migrated: %"PRIu64", size: %"
-                PRIu64", lookups: %"PRIu64", failures: %"PRIu64", skipped: "
-                "%"PRIu64, files, size, lookup, failures, skipped);
-out:
-        return 0;
-}
-
-void
-gf_defrag_set_pause_state (gf_tier_conf_t *tier_conf, tier_pause_state_t state)
-{
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-        tier_conf->pause_state = state;
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-}
-
-
-tier_pause_state_t
-gf_defrag_get_pause_state (gf_tier_conf_t *tier_conf)
-{
-        int state;
-
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-        state = tier_conf->pause_state;
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-
-        return state;
-}
-
-tier_pause_state_t
-gf_defrag_check_pause_tier (gf_tier_conf_t *tier_conf)
-{
-        int woke = 0;
-        int state  = -1;
-
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-
-        if (tier_conf->pause_state == TIER_RUNNING)
-                goto out;
-
-        if (tier_conf->pause_state == TIER_PAUSED)
-                goto out;
-
-        if (tier_conf->promote_in_progress ||
-            tier_conf->demote_in_progress)
-                goto out;
-
-        tier_conf->pause_state = TIER_PAUSED;
-
-        if (tier_conf->pause_synctask) {
-                synctask_wake (tier_conf->pause_synctask);
-                tier_conf->pause_synctask = 0;
-                woke = 1;
-        }
-
-        gf_msg ("tier", GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "woken %d", woke);
-
-        gf_event (EVENT_TIER_PAUSE, "vol=%s", tier_conf->volname);
+            break;
+    }
+
+    gf_msg(THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
+           "Rebalance is %s. Time taken is %.2f secs", status, elapsed);
+    gf_msg(THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
+           "Files migrated: %" PRIu64 ", size: %" PRIu64 ", lookups: %" PRIu64
+           ", failures: %" PRIu64
+           ", skipped: "
+           "%" PRIu64,
+           files, size, lookup, failures, skipped);
 out:
-        state = tier_conf->pause_state;
-
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-
-        return state;
-}
-
-void
-gf_defrag_pause_tier_timeout (void *data)
-{
-        xlator_t         *this                  = NULL;
-        dht_conf_t       *conf                  = NULL;
-        gf_defrag_info_t *defrag                = NULL;
-
-        this   = (xlator_t *) data;
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-
-        conf   = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Request pause timer timeout");
-
-        gf_defrag_check_pause_tier (&defrag->tier_conf);
-
-out:
-        return;
+    return 0;
 }
 
 int
-gf_defrag_pause_tier (xlator_t *this, gf_defrag_info_t *defrag)
+gf_defrag_stop(dht_conf_t *conf, gf_defrag_status_t status, dict_t *output)
 {
-        int             ret         = 0;
-        struct timespec delta       = {0,};
-        int             delay       = 2;
-
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
-                goto out;
-
-        /*
-         * Set flag requesting to pause tiering. Wait 'delay' seconds for
-         * tiering to actually stop as indicated by the pause state
-         * before returning success or failure.
-         */
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_REQUEST_PAUSE);
+    /* TODO: set a variable 'stop_defrag' here, it should be checked
+       in defrag loop */
+    int ret = -1;
+    gf_defrag_info_t *defrag = conf->defrag;
 
-        /*
-         * If migration is not underway, can pause immediately.
-         */
-        gf_defrag_check_pause_tier (&defrag->tier_conf);
-        if (gf_defrag_get_pause_state (&defrag->tier_conf) == TIER_PAUSED)
-                goto out;
-
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Request pause tier");
+    GF_ASSERT(defrag);
 
-        defrag->tier_conf.pause_synctask = synctask_get ();
-        delta.tv_sec  = delay;
-        delta.tv_nsec = 0;
-        defrag->tier_conf.pause_timer =
-                gf_timer_call_after (this->ctx, delta,
-                                     gf_defrag_pause_tier_timeout,
-                                     this);
-
-        synctask_yield (defrag->tier_conf.pause_synctask);
-
-        if (gf_defrag_get_pause_state (&defrag->tier_conf) == TIER_PAUSED)
-                goto out;
+    if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED) {
+        goto out;
+    }
 
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
+    gf_msg("", GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STOPPED,
+           "Received stop command on rebalance");
+    defrag->defrag_status = status;
 
-        ret = -1;
+    if (output)
+        gf_defrag_status_get(conf, output);
+    ret = 0;
 out:
-
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Pause tiering ret=%d", ret);
-
-        return ret;
-}
-
-int
-gf_defrag_resume_tier (xlator_t *this, gf_defrag_info_t *defrag)
-{
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_RESUME,
-                "Pause end. Resume tiering");
-
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
-
-        gf_event (EVENT_TIER_RESUME, "vol=%s", defrag->tier_conf.volname);
-
-        return 0;
-}
-
-int
-gf_defrag_start_detach_tier (gf_defrag_info_t *defrag)
-{
-        defrag->cmd = GF_DEFRAG_CMD_START_DETACH_TIER;
-
-        return 0;
-}
-
-int
-gf_defrag_stop (dht_conf_t *conf, gf_defrag_status_t status,
-                dict_t *output)
-{
-        /* TODO: set a variable 'stop_defrag' here, it should be checked
-           in defrag loop */
-        int     ret = -1;
-        gf_defrag_info_t *defrag = conf->defrag;
-
-        GF_ASSERT (defrag);
-
-        if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED) {
-                goto out;
-        }
-
-        gf_msg ("", GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STOPPED,
-                "Received stop command on rebalance");
-        defrag->defrag_status = status;
-
-        if (output)
-                gf_defrag_status_get (conf, output);
-        ret = 0;
-out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-rename.c b/xlators/cluster/dht/src/dht-rename.c
index 3068499618c..d9dbf50492f 100644
--- a/xlators/cluster/dht/src/dht-rename.c
+++ b/xlators/cluster/dht/src/dht-rename.c
@@ -11,1750 +11,1987 @@
 /* TODO: link(oldpath, newpath) fails if newpath already exists. DHT should
  *       delete the newpath if it gets EEXISTS from link() call.
  */
-#include "glusterfs.h"
-#include "xlator.h"
 #include "dht-common.h"
 #include "dht-lock.h"
-#include "defaults.h"
+#include <glusterfs/defaults.h>
 
-int dht_rename_unlock (call_frame_t *frame, xlator_t *this);
+int
+dht_rename_unlock(call_frame_t *frame, xlator_t *this);
+int32_t
+dht_rename_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
 
 int
-dht_rename_unlock_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+dht_rename_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        dht_set_fixed_dir_stat (&local->preoldparent);
-        dht_set_fixed_dir_stat (&local->postoldparent);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    dht_set_fixed_dir_stat(&local->preoldparent);
+    dht_set_fixed_dir_stat(&local->postoldparent);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        if (IA_ISREG (local->stbuf.ia_type))
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
+    if (IA_ISREG(local->stbuf.ia_type))
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
 
-        DHT_STACK_UNWIND (rename, frame, local->op_ret, local->op_errno,
-                          &local->stbuf, &local->preoldparent,
-                          &local->postoldparent, &local->preparent,
-                          &local->postparent, local->xattr);
-        return 0;
+    DHT_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
+                     &local->stbuf, &local->preoldparent, &local->postoldparent,
+                     &local->preparent, &local->postparent, local->xattr);
+    return 0;
 }
 
 static void
-dht_rename_unlock_src (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock_src(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        dht_unlock_namespace (frame, &local->lock[0]);
-        return;
+    local = frame->local;
+    dht_unlock_namespace(frame, &local->lock[0]);
+    return;
 }
 
 static void
-dht_rename_unlock_dst (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock_dst(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
-        int          op_ret                     = -1;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[1].ns.directory_ns);
-
-        /* Unlock inodelk */
-        op_ret = dht_unlock_inodelk (frame,
-                                     local->lock[1].ns.parent_layout.locks,
-                                     local->lock[1].ns.parent_layout.lk_count,
-                                     dht_rename_unlock_cbk);
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                if (IA_ISREG (local->stbuf.ia_type))
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s:%s %s:%s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->src_cached->name,
-                                local->loc2.path, dst_gfid,
-                                local->dst_cached ?
-                                local->dst_cached->name : NULL);
-                else
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s %s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->loc2.path, dst_gfid);
-
-                dht_rename_unlock_cbk (frame, NULL, this, 0, 0, NULL);
-        }
+    dht_local_t *local = NULL;
+    int op_ret = -1;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[1].ns.directory_ns);
+
+    /* Unlock inodelk */
+    op_ret = dht_unlock_inodelk(frame, local->lock[1].ns.parent_layout.locks,
+                                local->lock[1].ns.parent_layout.lk_count,
+                                dht_rename_unlock_cbk);
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        if (IA_ISREG(local->stbuf.ia_type))
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s:%s %s:%s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->src_cached->name,
+                   local->loc2.path, dst_gfid,
+                   local->dst_cached ? local->dst_cached->name : NULL);
+        else
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s %s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->loc2.path, dst_gfid);
+
+        dht_rename_unlock_cbk(frame, NULL, this, 0, 0, NULL);
+    }
 
-        return;
+    return;
 }
 
 static int
-dht_rename_dir_unlock (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock(call_frame_t *frame, xlator_t *this)
 {
-
-        dht_rename_unlock_src (frame, this);
-        dht_rename_unlock_dst (frame, this);
-        return 0;
+    dht_rename_dir_unlock_src(frame, this);
+    dht_rename_dir_unlock_dst(frame, this);
+    return 0;
 }
 int
-dht_rename_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
+dht_rename_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
 {
-        dht_conf_t  *conf                    = NULL;
-        dht_local_t *local                   = NULL;
-        int          this_call_cnt           = 0;
-        xlator_t    *prev                    = NULL;
-        int          i                       = 0;
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        int          subvol_cnt              = -1;
-
-        conf = this->private;
-        local = frame->local;
-        prev = cookie;
-        subvol_cnt = dht_subvol_cnt (this, prev);
-        local->ret_cache[subvol_cnt] = op_ret;
-
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_RENAME_FAILED,
-                        "Rename %s -> %s on %s failed, (gfid = %s)",
-                        local->loc.path, local->loc2.path,
-                        prev->name, gfid);
-
-                local->op_ret   = op_ret;
-                local->op_errno = op_errno;
-                goto unwind;
-        }
-        /* TODO: construct proper stbuf for dir */
-        /*
-         * FIXME: is this the correct way to build stbuf and
-         * parent bufs?
-         */
-        dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-        dht_iatt_merge (this, &local->preoldparent, preoldparent, prev);
-        dht_iatt_merge (this, &local->postoldparent, postoldparent, prev);
-        dht_iatt_merge (this, &local->preparent, prenewparent, prev);
-        dht_iatt_merge (this, &local->postparent, postnewparent, prev);
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int subvol_cnt = -1;
+
+    conf = this->private;
+    local = frame->local;
+    prev = cookie;
+    subvol_cnt = dht_subvol_cnt(this, prev);
+    local->ret_cache[subvol_cnt] = op_ret;
+
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+               "Rename %s -> %s on %s failed, (gfid = %s)", local->loc.path,
+               local->loc2.path, prev->name, gfid);
+
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        goto unwind;
+    }
+    /* TODO: construct proper stbuf for dir */
+    /*
+     * FIXME: is this the correct way to build stbuf and
+     * parent bufs?
+     */
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preoldparent, preoldparent);
+    dht_iatt_merge(this, &local->postoldparent, postoldparent);
+    dht_iatt_merge(this, &local->preparent, prenewparent);
+    dht_iatt_merge(this, &local->postparent, postnewparent);
 
 unwind:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                /* We get here with local->call_cnt == 0. Which means
-                 * we are the only one executing this code, there is
-                 * no contention. Therefore it's safe to manipulate or
-                 * deref local->call_cnt directly (without locking).
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        /* We get here with local->call_cnt == 0. Which means
+         * we are the only one executing this code, there is
+         * no contention. Therefore it's safe to manipulate or
+         * deref local->call_cnt directly (without locking).
+         */
+        if (local->ret_cache[conf->subvolume_cnt] == 0) {
+            /* count errant subvols in last field of ret_cache */
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (local->ret_cache[i] != 0)
+                    ++local->ret_cache[conf->subvolume_cnt];
+            }
+            if (local->ret_cache[conf->subvolume_cnt]) {
+                /* undoing the damage:
+                 * for all subvolumes, where rename
+                 * succeeded, we perform the reverse operation
                  */
-                if (local->ret_cache[conf->subvolume_cnt] == 0) {
-                        /* count errant subvols in last field of ret_cache */
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                if (local->ret_cache[i] != 0)
-                                        ++local->ret_cache[conf->subvolume_cnt];
-                        }
-                        if (local->ret_cache[conf->subvolume_cnt]) {
-                                /* undoing the damage:
-                                 * for all subvolumes, where rename
-                                 * succeeded, we perform the reverse operation
-                                 */
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (local->ret_cache[i] == 0)
-                                                ++local->call_cnt;
-                                }
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (local->ret_cache[i])
-                                                continue;
-
-                                        STACK_WIND (frame,
-                                                    dht_rename_dir_cbk,
-                                                    conf->subvolumes[i],
-                                                    conf->subvolumes[i]->fops->rename,
-                                                    &local->loc2, &local->loc,
-                                                    NULL);
-                                }
-
-                                return 0;
-                        }
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (local->ret_cache[i] == 0)
+                        ++local->call_cnt;
                 }
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (local->ret_cache[i])
+                        continue;
 
-                WIPE (&local->preoldparent);
-                WIPE (&local->postoldparent);
-                WIPE (&local->preparent);
-                WIPE (&local->postparent);
+                    STACK_WIND(frame, dht_rename_dir_cbk, conf->subvolumes[i],
+                               conf->subvolumes[i]->fops->rename, &local->loc2,
+                               &local->loc, NULL);
+                }
 
-                dht_rename_dir_unlock (frame, this);
+                return 0;
+            }
         }
 
-        return 0;
-}
+        WIPE(&local->preoldparent);
+        WIPE(&local->postoldparent);
+        WIPE(&local->preparent);
+        WIPE(&local->postparent);
+
+        dht_rename_dir_unlock(frame, this);
+    }
 
+    return 0;
+}
 
 int
-dht_rename_hashed_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                           struct iatt *preoldparent,
-                           struct iatt *postoldparent,
-                           struct iatt *prenewparent,
-                           struct iatt *postnewparent, dict_t *xdata)
+dht_rename_hashed_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                          struct iatt *preoldparent, struct iatt *postoldparent,
+                          struct iatt *prenewparent, struct iatt *postnewparent,
+                          dict_t *xdata)
 {
-        dht_conf_t   *conf = NULL;
-        dht_local_t  *local = NULL;
-        int           call_cnt = 0;
-        xlator_t     *prev = NULL;
-        int           i = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        conf = this->private;
-        local = frame->local;
-        prev = cookie;
-
-
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_RENAME_FAILED,
-                        "rename %s -> %s on %s failed, (gfid = %s) ",
-                        local->loc.path, local->loc2.path,
-                        prev->name, gfid);
-
-                local->op_ret   = op_ret;
-                local->op_errno = op_errno;
-                goto unwind;
-        }
-        /* TODO: construct proper stbuf for dir */
-        /*
-         * FIXME: is this the correct way to build stbuf and
-         * parent bufs?
-         */
-        dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-        dht_iatt_merge (this, &local->preoldparent, preoldparent, prev);
-        dht_iatt_merge (this, &local->postoldparent, postoldparent, prev);
-        dht_iatt_merge (this, &local->preparent, prenewparent, prev);
-        dht_iatt_merge (this, &local->postparent, postnewparent, prev);
-
-        call_cnt = local->call_cnt = conf->subvolume_cnt - 1;
-
-        if (!local->call_cnt)
-                goto unwind;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == local->dst_hashed)
-                        continue;
-                STACK_WIND_COOKIE (frame, dht_rename_dir_cbk,
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->rename,
-                                   &local->loc, &local->loc2, NULL);
-                if (!--call_cnt)
-                        break;
-        }
-
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int call_cnt = 0;
+    xlator_t *prev = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    conf = this->private;
+    local = frame->local;
+    prev = cookie;
+
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
 
-        return 0;
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+               "rename %s -> %s on %s failed, (gfid = %s) ", local->loc.path,
+               local->loc2.path, prev->name, gfid);
+
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        goto unwind;
+    }
+    /* TODO: construct proper stbuf for dir */
+    /*
+     * FIXME: is this the correct way to build stbuf and
+     * parent bufs?
+     */
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preoldparent, preoldparent);
+    dht_iatt_merge(this, &local->postoldparent, postoldparent);
+    dht_iatt_merge(this, &local->preparent, prenewparent);
+    dht_iatt_merge(this, &local->postparent, postnewparent);
+
+    call_cnt = local->call_cnt = conf->subvolume_cnt - 1;
+
+    if (!local->call_cnt)
+        goto unwind;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == local->dst_hashed)
+            continue;
+        STACK_WIND_COOKIE(
+            frame, dht_rename_dir_cbk, conf->subvolumes[i], conf->subvolumes[i],
+            conf->subvolumes[i]->fops->rename, &local->loc, &local->loc2, NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 unwind:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_dir_do (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_do(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->op_ret == -1)
-                goto err;
+    if (local->op_ret == -1)
+        goto err;
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-        STACK_WIND_COOKIE (frame, dht_rename_hashed_dir_cbk, local->dst_hashed,
-                           local->dst_hashed,
-                           local->dst_hashed->fops->rename,
-                           &local->loc, &local->loc2, NULL);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rename_hashed_dir_cbk, local->dst_hashed,
+                      local->dst_hashed, local->dst_hashed->fops->rename,
+                      &local->loc, &local->loc2, NULL);
+    return 0;
 
 err:
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, gf_dirent_t *entries,
-                        dict_t *xdata)
+dht_rename_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, gf_dirent_t *entries,
+                       dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-
-        if (op_ret > 2) {
-                gf_msg_trace (this->name, 0,
-                              "readdir on %s for %s returned %d entries",
-                              prev->name, local->loc.path, op_ret);
-                local->op_ret = -1;
-                local->op_errno = ENOTEMPTY;
-        }
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
 
-        this_call_cnt = dht_frame_return (frame);
+    local = frame->local;
+    prev = cookie;
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_dir_do (frame, this);
-        }
+    if (op_ret > 2) {
+        gf_msg_trace(this->name, 0, "readdir on %s for %s returned %d entries",
+                     prev->name, local->loc.path, op_ret);
+        local->op_ret = -1;
+        local->op_errno = ENOTEMPTY;
+    }
 
-        return 0;
-}
+    this_call_cnt = dht_frame_return(frame);
 
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_dir_do(frame, this);
+    }
+
+    return 0;
+}
 
 int
-dht_rename_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_rename_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        prev  = cookie;
+    local = frame->local;
+    prev = cookie;
 
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_OPENDIR_FAILED,
+               "opendir on %s for %s failed,(gfid = %s) ", prev->name,
+               local->loc.path, gfid);
+        goto err;
+    }
 
-        if (op_ret == -1) {
-
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_OPENDIR_FAILED,
-                        "opendir on %s for %s failed,(gfid = %s) ",
-                        prev->name, local->loc.path, gfid);
-                goto err;
-        }
-
-        fd_bind (fd);
-        STACK_WIND_COOKIE (frame, dht_rename_readdir_cbk, prev, prev,
-                           prev->fops->readdir, local->fd, 4096, 0, NULL);
+    fd_bind(fd);
+    STACK_WIND_COOKIE(frame, dht_rename_readdir_cbk, prev, prev,
+                      prev->fops->readdir, local->fd, 4096, 0, NULL);
 
-        return 0;
+    return 0;
 
 err:
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_dir_do (frame, this);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_dir_do(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_dir_lock2_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+dht_rename_dir_lock2_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        dht_conf_t  *conf                       = NULL;
-        int          i                          = 0;
-
-        local = frame->local;
-        conf = this->private;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed"
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_conf_t *conf = NULL;
+    int i = 0;
+
+    local = frame->local;
+    conf = this->private;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    local->fd = fd_create(local->loc.inode, frame->root->pid);
+    if (!local->fd) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->op_ret = 0;
+
+    if (!local->dst_cached) {
+        dht_rename_dir_do(frame, this);
+        return 0;
+    }
 
-        local->fd = fd_create (local->loc.inode, frame->root->pid);
-        if (!local->fd) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_rename_opendir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->opendir, &local->loc2,
+                          local->fd, NULL);
+    }
 
-        local->op_ret = 0;
-
-        if (!local->dst_cached) {
-                dht_rename_dir_do (frame, this);
-                return 0;
-        }
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_rename_opendir_cbk,
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->opendir,
-                                   &local->loc2, local->fd, NULL);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        /* No harm in calling an extra unlock */
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    /* No harm in calling an extra unlock */
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
 int
-dht_rename_dir_lock1_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rename_dir_lock1_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        int          ret                        = 0;
-        loc_t       *loc                        = NULL;
-        xlator_t    *subvol                     = NULL;
-
-        local = frame->local;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed"
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        if (local->current == &local->lock[0]) {
-                loc = &local->loc2;
-                subvol = local->dst_hashed;
-                local->current = &local->lock[1];
-        } else {
-                loc = &local->loc;
-                subvol = local->src_hashed;
-                local->current = &local->lock[0];
-        }
-        ret = dht_protect_namespace (frame, loc, subvol, &local->current->ns,
-                                     dht_rename_dir_lock2_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+
+    local = frame->local;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    if (local->current == &local->lock[0]) {
+        loc = &local->loc2;
+        subvol = local->dst_hashed;
+        local->current = &local->lock[1];
+    } else {
+        loc = &local->loc;
+        subvol = local->src_hashed;
+        local->current = &local->lock[0];
+    }
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_dir_lock2_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 err:
-        /* No harm in calling an extra unlock */
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    /* No harm in calling an extra unlock */
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-static void
-dht_order_rename_lock (call_frame_t *frame, loc_t **loc, xlator_t **subvol)
+/*
+ * If the hashed subvolumes of both source and dst are the different,
+ * lock in dictionary order of hashed subvol->name. This is important
+ * in case the parent directory is the same for both src and dst to
+ * prevent inodelk deadlocks when racing with a fix-layout op on the parent.
+ *
+ * If the hashed subvols are the same, use the gfid/name to determine
+ * the order of taking locks to prevent entrylk deadlocks when the parent
+ * dirs are the same.
+ *
+ */
+static int
+dht_order_rename_lock(call_frame_t *frame, loc_t **loc, xlator_t **subvol)
 {
-        dht_local_t        *local                       = NULL;
-        char                src[GF_UUID_BNAME_BUF_SIZE] = {0};
-        char                dst[GF_UUID_BNAME_BUF_SIZE] = {0};
-
-        local = frame->local;
-
-        if (local->loc.pargfid)
-                uuid_utoa_r (local->loc.pargfid, src);
+    int ret = 0;
+    int op_ret = 0;
+    dht_local_t *local = NULL;
+    char *src = NULL;
+    char *dst = NULL;
+
+    local = frame->local;
+
+    if (local->src_hashed->name == local->dst_hashed->name) {
+        ret = 0;
+    } else {
+        ret = strcmp(local->src_hashed->name, local->dst_hashed->name);
+    }
+
+    if (ret == 0) {
+        /* hashed subvols are the same for src and dst */
+        /* Entrylks need to be ordered*/
+
+        src = alloca(GF_UUID_BNAME_BUF_SIZE + strlen(local->loc.name) + 1);
+        if (!src) {
+            gf_msg(frame->this->name, GF_LOG_ERROR, ENOMEM, 0,
+                   "Insufficient memory for src");
+            op_ret = -1;
+            goto out;
+        }
+
+        if (!gf_uuid_is_null(local->loc.pargfid))
+            uuid_utoa_r(local->loc.pargfid, src);
         else if (local->loc.parent)
-                uuid_utoa_r (local->loc.parent->gfid, src);
-
-        strcat (src, local->loc.name);
-
-        if (local->loc2.pargfid)
-                uuid_utoa_r (local->loc2.pargfid, dst);
-        else if (local->loc2.parent)
-                uuid_utoa_r (local->loc2.parent->gfid, dst);
+            uuid_utoa_r(local->loc.parent->gfid, src);
+        else
+            src[0] = '\0';
 
-        strcat (dst, local->loc2.name);
+        strcat(src, local->loc.name);
 
-        if (strcmp(src, dst) > 0) {
-                local->current = &local->lock[1];
-                *loc = &local->loc2;
-                *subvol = local->dst_hashed;
-        } else {
-                local->current = &local->lock[0];
-                *loc = &local->loc;
-                *subvol = local->src_hashed;
+        dst = alloca(GF_UUID_BNAME_BUF_SIZE + strlen(local->loc2.name) + 1);
+        if (!dst) {
+            gf_msg(frame->this->name, GF_LOG_ERROR, ENOMEM, 0,
+                   "Insufficient memory for dst");
+            op_ret = -1;
+            goto out;
         }
 
-        return;
-}
-
-int
-dht_rename_dir (call_frame_t *frame, xlator_t *this)
-{
-        dht_conf_t    *conf         = NULL;
-        dht_local_t   *local        = NULL;
-        loc_t         *loc          = NULL;
-        xlator_t      *subvol       = NULL;
-        int            i            = 0;
-        int            ret          = 0;
-        int            op_errno     = -1;
-
-        conf = frame->this->private;
-        local = frame->local;
-
-        local->ret_cache = GF_CALLOC (conf->subvolume_cnt + 1, sizeof (int),
-                                      gf_dht_ret_cache_t);
-
-        if (local->ret_cache == NULL) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+        if (!gf_uuid_is_null(local->loc2.pargfid))
+            uuid_utoa_r(local->loc2.pargfid, dst);
+        else if (local->loc2.parent)
+            uuid_utoa_r(local->loc2.parent->gfid, dst);
+        else
+            dst[0] = '\0';
 
-        local->call_cnt = conf->subvolume_cnt;
+        strcat(dst, local->loc2.name);
+        ret = strcmp(src, dst);
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->subvolume_status[i]) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_RENAME_FAILED,
-                                "Rename dir failed: subvolume down (%s)",
-                                conf->subvolumes[i]->name);
-                        op_errno = ENOTCONN;
-                        goto err;
-                }
-        }
+    if (ret <= 0) {
+        /*inodelk in dictionary order of hashed subvol names*/
+        /*entrylk in dictionary order of gfid/basename */
+        local->current = &local->lock[0];
+        *loc = &local->loc;
+        *subvol = local->src_hashed;
 
+    } else {
+        local->current = &local->lock[1];
+        *loc = &local->loc2;
+        *subvol = local->dst_hashed;
+    }
 
-        /* Locks on src and dst needs to ordered which otherwise might cause
-         * deadlocks when rename (src, dst) and rename (dst, src) is done from
-         * two different clients
-         */
-        dht_order_rename_lock (frame, &loc, &subvol);
+    op_ret = 0;
 
-        /* Rename must take locks on src to avoid lookup selfheal from
-         * recreating src on those subvols where the rename was successful.
-         * The locks can't be issued parallel as two different clients might
-         * attempt same rename command and be in dead lock.
-         */
-        ret = dht_protect_namespace (frame, loc, subvol,
-                                     &local->current->ns,
-                                     dht_rename_dir_lock1_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
+out:
+    return op_ret;
+}
 
-        return 0;
+int
+dht_rename_dir(call_frame_t *frame, xlator_t *this)
+{
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+    int i = 0;
+    int ret = 0;
+    int op_errno = -1;
+
+    conf = frame->this->private;
+    local = frame->local;
+
+    local->ret_cache = GF_CALLOC(conf->subvolume_cnt + 1, sizeof(int),
+                                 gf_dht_ret_cache_t);
+
+    if (local->ret_cache == NULL) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->call_cnt = conf->subvolume_cnt;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+                   "Rename dir failed: subvolume down (%s)",
+                   conf->subvolumes[i]->name);
+            op_errno = ENOTCONN;
+            goto err;
+        }
+    }
+
+    /* Locks on src and dst needs to ordered which otherwise might cause
+     * deadlocks when rename (src, dst) and rename (dst, src) is done from
+     * two different clients
+     */
+    ret = dht_order_rename_lock(frame, &loc, &subvol);
+    if (ret) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* Rename must take locks on src to avoid lookup selfheal from
+     * recreating src on those subvols where the rename was successful.
+     * The locks can't be issued parallel as two different clients might
+     * attempt same rename command and be in dead lock.
+     */
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_dir_lock1_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                          NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 static int
-dht_rename_track_for_changelog (xlator_t *this, dict_t *xattr,
-                                loc_t *oldloc, loc_t *newloc)
+dht_rename_track_for_changelog(xlator_t *this, dict_t *xattr, loc_t *oldloc,
+                               loc_t *newloc)
 {
-        int ret        = -1;
-        dht_changelog_rename_info_t *info = NULL;
-        char *name     = NULL;
-        int len1       = 0;
-        int len2       = 0;
-        int size       = 0;
-
-        if (!xattr || !oldloc || !newloc || !this)
-                return ret;
-
-        len1 = strlen (oldloc->name) + 1;
-        len2 = strlen (newloc->name) + 1;
-        size = sizeof (dht_changelog_rename_info_t) + len1 + len2;
-
-        info = GF_CALLOC (size, sizeof(char), gf_common_mt_char);
-        if (!info) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to calloc memory");
-                return ret;
-        }
+    int ret = -1;
+    dht_changelog_rename_info_t *info = NULL;
+    char *name = NULL;
+    int len1 = 0;
+    int len2 = 0;
+    int size = 0;
+
+    if (!xattr || !oldloc || !newloc || !this)
+        return ret;
 
-        gf_uuid_copy (info->old_pargfid, oldloc->pargfid);
-        gf_uuid_copy (info->new_pargfid, newloc->pargfid);
-
-        info->oldname_len = len1;
-        info->newname_len = len2;
-        strncpy (info->buffer, oldloc->name, len1);
-        name = info->buffer + len1;
-        strncpy (name, newloc->name, len2);
-
-        ret = dict_set_bin (xattr, DHT_CHANGELOG_RENAME_OP_KEY,
-                            info, size);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s,"
-                        " path = %s", DHT_CHANGELOG_RENAME_OP_KEY,
-                        oldloc->name);
-                GF_FREE (info);
-        }
+    len1 = strlen(oldloc->name) + 1;
+    len2 = strlen(newloc->name) + 1;
+    size = sizeof(dht_changelog_rename_info_t) + len1 + len2;
 
+    info = GF_CALLOC(size, sizeof(char), gf_common_mt_char);
+    if (!info) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to calloc memory");
         return ret;
+    }
+
+    gf_uuid_copy(info->old_pargfid, oldloc->pargfid);
+    gf_uuid_copy(info->new_pargfid, newloc->pargfid);
+
+    info->oldname_len = len1;
+    info->newname_len = len2;
+    strncpy(info->buffer, oldloc->name, len1);
+    name = info->buffer + len1;
+    strncpy(name, newloc->name, len2);
+
+    ret = dict_set_bin(xattr, DHT_CHANGELOG_RENAME_OP_KEY, info, size);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s,"
+               " path = %s",
+               DHT_CHANGELOG_RENAME_OP_KEY, oldloc->name);
+        GF_FREE(info);
+    }
+
+    return ret;
 }
 
-
-
-#define DHT_MARKER_DONT_ACCOUNT(xattr) do {                             \
-                int tmp = -1;                                                  \
-                if (!xattr) {                                                  \
-                        xattr = dict_new ();                                   \
-                        if (!xattr)                                            \
-                                break;                                         \
-                }                                                              \
-                tmp = dict_set_str (xattr, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY,  \
-                                    "yes");                                    \
-                if (tmp) {                                                     \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,                    \
-                                DHT_MSG_DICT_SET_FAILED,                       \
-                                "Failed to set dictionary value: key = %s,"    \
-                                " path = %s",GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, \
-                                local->loc.path);                             \
-                }                                                              \
-        }while (0)
-
-
-#define DHT_CHANGELOG_TRACK_AS_RENAME(xattr, oldloc, newloc) do {            \
-                int tmp = -1;                                                \
-                if (!xattr) {                                                \
-                        xattr = dict_new ();                                 \
-                        if (!xattr) {                                        \
-                                gf_msg (this->name, GF_LOG_ERROR, 0,         \
-                                        DHT_MSG_DICT_SET_FAILED,             \
-                                        "Failed to create dictionary to "    \
-                                        "track rename");                     \
-                                break;                                       \
-                        }                                                    \
-                }                                                            \
-                                                                             \
-                tmp = dht_rename_track_for_changelog (this, xattr,           \
-                                oldloc, newloc);                             \
-                                                                             \
-                if (tmp) {                                                   \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,                 \
-                                DHT_MSG_DICT_SET_FAILED,                     \
-                                "Failed to set dictionary value: key = %s,"  \
-                                " path = %s", DHT_CHANGELOG_RENAME_OP_KEY,   \
-                                (oldloc)->path);                             \
-                }                                                            \
-        } while (0)
-
+#define DHT_MARKER_DONT_ACCOUNT(xattr)                                         \
+    do {                                                                       \
+        int tmp = -1;                                                          \
+        if (!xattr) {                                                          \
+            xattr = dict_new();                                                \
+            if (!xattr)                                                        \
+                break;                                                         \
+        }                                                                      \
+        tmp = dict_set_str(xattr, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, "yes");   \
+        if (tmp) {                                                             \
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,       \
+                   "Failed to set dictionary value: key = %s,"                 \
+                   " path = %s",                                               \
+                   GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, local->loc.path);        \
+        }                                                                      \
+    } while (0)
+
+#define DHT_CHANGELOG_TRACK_AS_RENAME(xattr, oldloc, newloc)                   \
+    do {                                                                       \
+        int tmp = -1;                                                          \
+        if (!xattr) {                                                          \
+            xattr = dict_new();                                                \
+            if (!xattr) {                                                      \
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,   \
+                       "Failed to create dictionary to "                       \
+                       "track rename");                                        \
+                break;                                                         \
+            }                                                                  \
+        }                                                                      \
+                                                                               \
+        tmp = dht_rename_track_for_changelog(this, xattr, oldloc, newloc);     \
+                                                                               \
+        if (tmp) {                                                             \
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,       \
+                   "Failed to set dictionary value: key = %s,"                 \
+                   " path = %s",                                               \
+                   DHT_CHANGELOG_RENAME_OP_KEY, (oldloc)->path);               \
+        }                                                                      \
+    } while (0)
 
 int
-dht_rename_unlock (call_frame_t *frame, xlator_t *this)
+dht_rename_unlock(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
-        int          op_ret                     = -1;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        op_ret = dht_unlock_inodelk (frame,
-                                     local->lock[0].layout.parent_layout.locks,
-                                     local->lock[0].layout.parent_layout.lk_count,
-                                     dht_rename_unlock_cbk);
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                if (IA_ISREG (local->stbuf.ia_type))
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s:%s %s:%s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->src_cached->name,
-                                local->loc2.path, dst_gfid,
-                                local->dst_cached ?
-                                local->dst_cached->name : NULL);
-                else
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s %s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->loc2.path, dst_gfid);
-
-                dht_rename_unlock_cbk (frame, NULL, this, 0, 0, NULL);
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int op_ret = -1;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_ilock_wrap_t inodelk_wrapper = {
+        0,
+    };
+
+    local = frame->local;
+    inodelk_wrapper.locks = local->rename_inodelk_backward_compatible;
+    inodelk_wrapper.lk_count = local->rename_inodelk_bc_count;
+
+    op_ret = dht_unlock_inodelk_wrapper(frame, &inodelk_wrapper);
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        if (IA_ISREG(local->stbuf.ia_type))
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s:%s %s:%s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->src_cached->name,
+                   local->loc2.path, dst_gfid,
+                   local->dst_cached ? local->dst_cached->name : NULL);
+        else
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s %s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->loc2.path, dst_gfid);
+    }
+
+    dht_unlock_namespace(frame, &local->lock[0]);
+    dht_unlock_namespace(frame, &local->lock[1]);
+
+    dht_rename_unlock_cbk(frame, NULL, this, local->op_ret, local->op_errno,
+                          NULL);
+    return 0;
 }
 
 int
-dht_rename_done (call_frame_t *frame, xlator_t *this)
+dht_rename_done(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->linked == _gf_true) {
-                local->linked = _gf_false;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    if (local->linked == _gf_true) {
+        local->linked = _gf_false;
+        dht_linkfile_attr_heal(frame, this);
+    }
 
-        dht_rename_unlock (frame, this);
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
 int
-dht_rename_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
+dht_rename_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           this_call_cnt = 0;
-
-        local = frame->local;
-        prev  = cookie;
-
-        FRAME_SU_UNDO (frame, dht_local_t);
-        if (!local) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_INVALID_VALUE,
-                        "!local, should not happen");
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
 
-        this_call_cnt = dht_frame_return (frame);
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLINK_FAILED,
-                        "%s: Rename: unlink on %s failed ",
-                        local->loc.path, prev->name);
-        }
+    FRAME_SU_UNDO(frame, dht_local_t);
+    if (!local) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_VALUE,
+               "!local, should not happen");
+        goto out;
+    }
 
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_done (frame, this);
-        }
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLINK_FAILED,
+               "%s: Rename: unlink on %s failed ", local->loc.path, prev->name);
+    }
+
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
+
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_done(frame, this);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rename_cleanup (call_frame_t *frame)
+dht_rename_cleanup(call_frame_t *frame)
 {
-        dht_local_t *local                  = NULL;
-        xlator_t    *this                   = NULL;
-        xlator_t    *src_hashed             = NULL;
-        xlator_t    *src_cached             = NULL;
-        xlator_t    *dst_hashed             = NULL;
-        xlator_t    *dst_cached             = NULL;
-        int          call_cnt               = 0;
-        dict_t      *xattr                  = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        this  = frame->this;
-
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-
-        if (src_cached == dst_cached)
-                goto nolinks;
-
-        if (local->linked && (dst_hashed != src_hashed )&&
-                (dst_hashed != src_cached)) {
-                call_cnt++;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    int call_cnt = 0;
+    dict_t *xattr = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        if (local->added_link && (src_cached != dst_hashed)) {
-                call_cnt++;
-        }
+    local = frame->local;
+    this = frame->this;
 
-        local->call_cnt = call_cnt;
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-        if (!call_cnt)
-                goto nolinks;
+    if (src_cached == dst_cached)
+        goto nolinks;
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    if (local->linked && (dst_hashed != src_hashed) &&
+        (dst_hashed != src_cached)) {
+        call_cnt++;
+    }
 
-        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+    if (local->added_link && (src_cached != dst_hashed)) {
+        call_cnt++;
+    }
 
-        if (local->linked && (dst_hashed != src_hashed) &&
-                        (dst_hashed != src_cached)) {
-                dict_t *xattr_new = NULL;
+    local->call_cnt = call_cnt;
 
-                gf_msg_trace (this->name, 0,
-                              "unlinking linkfile %s @ %s => %s, (gfid = %s)",
-                              local->loc.path, dst_hashed->name,
-                              src_cached->name, gfid);
+    if (!call_cnt)
+        goto nolinks;
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+    DHT_MARK_FOP_INTERNAL(xattr);
 
+    gf_uuid_unparse(local->loc.inode->gfid, gfid);
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+    if (local->linked && (dst_hashed != src_hashed) &&
+        (dst_hashed != src_cached)) {
+        dict_t *xattr_new = NULL;
 
-                FRAME_SU_DO (frame, dht_local_t);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, dst_hashed,
-                                   dst_hashed, dst_hashed->fops->unlink,
-                                   &local->loc, 0, xattr_new);
+        gf_msg_trace(this->name, 0,
+                     "unlinking linkfile %s @ %s => %s, (gfid = %s)",
+                     local->loc.path, dst_hashed->name, src_cached->name, gfid);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
-        }
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-        if (local->added_link && (src_cached != dst_hashed)) {
-                dict_t *xattr_new = NULL;
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-                gf_msg_trace (this->name, 0,
-                              "unlinking link %s => %s (%s), (gfid = %s)",
-                              local->loc.path, local->loc2.path,
-                              src_cached->name, gfid);
+        FRAME_SU_DO(frame, dht_local_t);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, dst_hashed, dst_hashed,
+                          dst_hashed->fops->unlink, &local->loc, 0, xattr_new);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-                if (gf_uuid_compare (local->loc.pargfid,
-                                  local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
-                /* *
-                 * The link to file is created using root permission.
-                 * Hence deletion should happen using root. Otherwise
-                 * it will fail.
-                 */
-                FRAME_SU_DO (frame, dht_local_t);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_cached,
-                                   src_cached, src_cached->fops->unlink,
-                                   &local->loc2, 0, xattr_new);
+    if (local->added_link && (src_cached != dst_hashed)) {
+        dict_t *xattr_new = NULL;
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
-        }
+        gf_msg_trace(this->name, 0, "unlinking link %s => %s (%s), (gfid = %s)",
+                     local->loc.path, local->loc2.path, src_cached->name, gfid);
 
-        if (xattr)
-                dict_unref (xattr);
-
-        return 0;
-
-nolinks:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
-
-        dht_rename_unlock (frame, this);
-        return 0;
-}
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
+        }
+        /* *
+         * The link to file is created using root permission.
+         * Hence deletion should happen using root. Otherwise
+         * it will fail.
+         */
+        FRAME_SU_DO(frame, dht_local_t);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_cached, src_cached,
+                          src_cached->fops->unlink, &local->loc2, 0, xattr_new);
 
-int
-dht_rename_links_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             inode_t *inode, struct iatt *stbuf,
-                             struct iatt *preparent, struct iatt *postparent,
-                             dict_t *xdata)
-{
-        xlator_t *prev = NULL;
-        dht_local_t  *local = NULL;
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-        prev = cookie;
-        local = frame->local;
+    if (xattr)
+        dict_unref(xattr);
 
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_CREATE_LINK_FAILED,
-                        "link/file %s on %s failed",
-                        local->loc.path, prev->name);
-        }
+    return 0;
 
-        if (local->linked == _gf_true) {
-                local->linked = _gf_false;
-                dht_linkfile_attr_heal (frame, this);
-        }
-        DHT_STACK_DESTROY (frame);
+nolinks:
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                struct iatt *preoldparent, struct iatt *postoldparent,
-                struct iatt *prenewparent, struct iatt *postnewparent,
-                dict_t *xdata)
+dht_rename_unlink(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *src_hashed = NULL;
-        xlator_t     *src_cached = NULL;
-        xlator_t     *dst_hashed = NULL;
-        xlator_t     *dst_cached = NULL;
-        xlator_t     *rename_subvol = NULL;
-        call_frame_t *link_frame = NULL;
-        dht_local_t *link_local = NULL;
-        dict_t       *xattr     = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-
-        if (local->linked == _gf_true)
-                FRAME_SU_UNDO (frame, dht_local_t);
-
-        /* It is a critical failure iff we fail to rename the cached file
-         * if the rename of the linkto failed, it is not a critical failure,
-         * and we do not want to lose the created hard link for the new
-         * name as that could have been read by other clients.
-         *
-         * NOTE: If another client is attempting the same oldname -> newname
-         * rename, and finds both file names as existing, and are hard links
-         * to each other, then FUSE would send in an unlink for oldname. In
-         * this time duration if we treat the linkto as a critical error and
-         * unlink the newname we created, we would have effectively lost the
-         * file to rename operations.
-         *
-         * Repercussions of treating this as a non-critical error is that
-         * we could leave behind a stale linkto file and/or not create the new
-         * linkto file, the second case would be rectified by a subsequent
-         * lookup, the first case by a rebalance, like for all stale linkto
-         * files */
-
-        if (op_ret == -1) {
-                /* Critical failure: unable to rename the cached file */
-                if (prev == src_cached) {
-                        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                DHT_MSG_RENAME_FAILED,
-                                "%s: Rename on %s failed, (gfid = %s) ",
-                                local->loc.path, prev->name,
-                                local->loc.inode ?
-                                uuid_utoa(local->loc.inode->gfid):"");
-                        local->op_ret   = op_ret;
-                        local->op_errno = op_errno;
-                        goto cleanup;
-                } else {
-                        /* Non-critical failure, unable to rename the linkto
-                         * file
-                         */
-                        gf_msg (this->name, GF_LOG_INFO, op_errno,
-                                DHT_MSG_RENAME_FAILED,
-                                "%s: Rename (linkto file) on %s failed, "
-                                "(gfid = %s) ",
-                                local->loc.path, prev->name,
-                                local->loc.inode ?
-                                uuid_utoa(local->loc.inode->gfid):"");
-                }
-        }
-        if (xdata) {
-                if (!local->xattr)
-                        local->xattr = dict_ref (xdata);
-                else
-                        local->xattr = dict_copy_with_ref (xdata, local->xattr);
-        }
+    dht_local_t *local = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *rename_subvol = NULL;
+    dict_t *xattr = NULL;
 
-        if ((src_cached == dst_cached) && (dst_hashed != dst_cached)) {
-                link_frame = copy_frame (frame);
-                if (!link_frame) {
-                        goto err;
-                }
+    local = frame->local;
 
-                /* fop value sent as maxvalue because it is not used
-                   anywhere in this case */
-                link_local = dht_local_init (link_frame, &local->loc2, NULL,
-                                             GF_FOP_MAXVALUE);
-                if (!link_local) {
-                        goto err;
-                }
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-                if (link_local->loc.inode)
-                        inode_unref (link_local->loc.inode);
-                link_local->loc.inode = inode_ref (local->loc.inode);
-                gf_uuid_copy (link_local->gfid, local->loc.inode->gfid);
+    local->call_cnt = 0;
 
-                dht_linkfile_create (link_frame, dht_rename_links_create_cbk,
-                                     this, src_cached, dst_hashed,
-                                     &link_local->loc);
-        }
+    /* NOTE: rename_subvol is the same subvolume from which dht_rename_cbk
+     * is called. since rename has already happened on rename_subvol,
+     * unlink shouldn't be sent for oldpath (either linkfile or cached-file)
+     * on rename_subvol. */
+    if (src_cached == dst_cached)
+        rename_subvol = src_cached;
+    else
+        rename_subvol = dst_hashed;
 
-err:
-        /* Merge attrs only from src_cached. In case there of src_cached !=
-         * dst_hashed, this ignores linkfile attrs. */
-        if (prev == src_cached) {
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                dht_iatt_merge (this, &local->preoldparent, preoldparent,
-                                prev);
-                dht_iatt_merge (this, &local->postoldparent, postoldparent,
-                                prev);
-                dht_iatt_merge (this, &local->preparent, prenewparent, prev);
-                dht_iatt_merge (this, &local->postparent, postnewparent, prev);
-        }
+    /* TODO: delete files in background */
 
+    if (src_cached != dst_hashed && src_cached != dst_cached)
+        local->call_cnt++;
 
-        /* NOTE: rename_subvol is the same subvolume from which dht_rename_cbk
-         *       is called. since rename has already happened on rename_subvol,
-         *       unlink should not be sent for oldpath (either linkfile or cached-file)
-         *       on rename_subvol. */
-        if (src_cached == dst_cached)
-                rename_subvol = src_cached;
-        else
-                rename_subvol = dst_hashed;
-
-        /* TODO: delete files in background */
-
-        if (src_cached != dst_hashed && src_cached != dst_cached)
-                local->call_cnt++;
+    if (src_hashed != rename_subvol && src_hashed != src_cached)
+        local->call_cnt++;
 
-        if (src_hashed != rename_subvol && src_hashed != src_cached)
-                local->call_cnt++;
+    if (dst_cached && dst_cached != dst_hashed && dst_cached != src_cached)
+        local->call_cnt++;
 
-        if (dst_cached && dst_cached != dst_hashed && dst_cached != src_cached)
-                local->call_cnt++;
+    if (local->call_cnt == 0)
+        goto unwind;
 
-        if (local->call_cnt == 0)
-                goto unwind;
+    DHT_MARK_FOP_INTERNAL(xattr);
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    if (src_cached != dst_hashed && src_cached != dst_cached) {
+        dict_t *xattr_new = NULL;
 
-        if (src_cached != dst_hashed && src_cached != dst_cached) {
-                dict_t *xattr_new = NULL;
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        gf_msg_trace(this->name, 0, "deleting old src datafile %s @ %s",
+                     local->loc.path, src_cached->name);
 
-                gf_msg_trace (this->name, 0,
-                              "deleting old src datafile %s @ %s",
-                              local->loc.path, src_cached->name);
-
-                if (gf_uuid_compare (local->loc.pargfid,
-                                  local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
-
-                DHT_CHANGELOG_TRACK_AS_RENAME(xattr_new, &local->loc,
-                                              &local->loc2);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_cached,
-                                   src_cached, src_cached->fops->unlink,
-                                   &local->loc, 0, xattr_new);
-
-                dict_unref (xattr_new);
-                xattr_new = NULL;
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
         }
 
-        if (src_hashed != rename_subvol && src_hashed != src_cached) {
-                dict_t *xattr_new = NULL;
+        DHT_CHANGELOG_TRACK_AS_RENAME(xattr_new, &local->loc, &local->loc2);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_cached, src_cached,
+                          src_cached->fops->unlink, &local->loc, 0, xattr_new);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-                gf_msg_trace (this->name, 0,
-                              "deleting old src linkfile %s @ %s",
-                              local->loc.path, src_hashed->name);
+    if (src_hashed != rename_subvol && src_hashed != src_cached) {
+        dict_t *xattr_new = NULL;
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_hashed,
-                                   src_hashed, src_hashed->fops->unlink,
-                                   &local->loc, 0, xattr_new);
+        gf_msg_trace(this->name, 0, "deleting old src linkfile %s @ %s",
+                     local->loc.path, src_hashed->name);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
-        }
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-        if (dst_cached
-            && (dst_cached != dst_hashed)
-            && (dst_cached != src_cached)) {
-                gf_msg_trace (this->name, 0,
-                              "deleting old dst datafile %s @ %s",
-                              local->loc2.path, dst_cached->name);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_hashed, src_hashed,
+                          src_hashed->fops->unlink, &local->loc, 0, xattr_new);
 
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, dst_cached,
-                                   dst_cached, dst_cached->fops->unlink,
-                                   &local->loc2, 0, xattr);
-        }
-        if (xattr)
-                dict_unref (xattr);
-        return 0;
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-unwind:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    if (dst_cached && (dst_cached != dst_hashed) &&
+        (dst_cached != src_cached)) {
+        gf_msg_trace(this->name, 0, "deleting old dst datafile %s @ %s",
+                     local->loc2.path, dst_cached->name);
 
-        dht_rename_done (frame, this);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, dst_cached, dst_cached,
+                          dst_cached->fops->unlink, &local->loc2, 0, xattr);
+    }
+    if (xattr)
+        dict_unref(xattr);
+    return 0;
 
-        return 0;
+unwind:
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_done(frame, this);
 
-        return 0;
+    return 0;
 }
 
+int
+dht_rename_links_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, inode_t *inode,
+                            struct iatt *stbuf, struct iatt *preparent,
+                            struct iatt *postparent, dict_t *xdata)
+{
+    xlator_t *prev = NULL;
+    dht_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
+
+    prev = cookie;
+    local = frame->local;
+    main_frame = local->main_frame;
+
+    /* TODO: Handle this case in lookup-optimize */
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_CREATE_LINK_FAILED,
+               "link/file %s on %s failed", local->loc.path, prev->name);
+    }
+
+    if (local->linked == _gf_true) {
+        local->linked = _gf_false;
+        dht_linkfile_attr_heal(frame, this);
+    }
+
+    dht_rename_unlink(main_frame, this);
+    DHT_STACK_DESTROY(frame);
+    return 0;
+}
 
 int
-dht_do_rename (call_frame_t *frame)
+dht_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+               struct iatt *preoldparent, struct iatt *postoldparent,
+               struct iatt *prenewparent, struct iatt *postnewparent,
+               dict_t *xdata)
 {
-        dht_local_t *local         = NULL;
-        xlator_t    *dst_hashed    = NULL;
-        xlator_t    *src_cached    = NULL;
-        xlator_t    *dst_cached    = NULL;
-        xlator_t    *this          = NULL;
-        xlator_t    *rename_subvol = NULL;
-
-        local = frame->local;
-        this  = frame->this;
-
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-        src_cached = local->src_cached;
-
-        if (src_cached == dst_cached)
-                rename_subvol = src_cached;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    call_frame_t *link_frame = NULL;
+    dht_local_t *link_local = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
+
+    if (local->linked == _gf_true)
+        FRAME_SU_UNDO(frame, dht_local_t);
+
+    /* It is a critical failure iff we fail to rename the cached file
+     * if the rename of the linkto failed, it is not a critical failure,
+     * and we do not want to lose the created hard link for the new
+     * name as that could have been read by other clients.
+     *
+     * NOTE: If another client is attempting the same oldname -> newname
+     * rename, and finds both file names as existing, and are hard links
+     * to each other, then FUSE would send in an unlink for oldname. In
+     * this time duration if we treat the linkto as a critical error and
+     * unlink the newname we created, we would have effectively lost the
+     * file to rename operations.
+     *
+     * Repercussions of treating this as a non-critical error is that
+     * we could leave behind a stale linkto file and/or not create the new
+     * linkto file, the second case would be rectified by a subsequent
+     * lookup, the first case by a rebalance, like for all stale linkto
+     * files */
+
+    if (op_ret == -1) {
+        /* Critical failure: unable to rename the cached file */
+        if (prev == src_cached) {
+            gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_RENAME_FAILED,
+                   "%s: Rename on %s failed, (gfid = %s) ", local->loc.path,
+                   prev->name,
+                   local->loc.inode ? uuid_utoa(local->loc.inode->gfid) : "");
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
+            goto cleanup;
+        } else {
+            /* Non-critical failure, unable to rename the linkto
+             * file
+             */
+            gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+                   "%s: Rename (linkto file) on %s failed, "
+                   "(gfid = %s) ",
+                   local->loc.path, prev->name,
+                   local->loc.inode ? uuid_utoa(local->loc.inode->gfid) : "");
+        }
+    }
+    if (xdata) {
+        if (!local->xattr)
+            local->xattr = dict_ref(xdata);
         else
-                rename_subvol = dst_hashed;
+            local->xattr = dict_copy_with_ref(xdata, local->xattr);
+    }
+
+    /* Merge attrs only from src_cached. In case there of src_cached !=
+     * dst_hashed, this ignores linkfile attrs. */
+    if (prev == src_cached) {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->preoldparent, preoldparent);
+        dht_iatt_merge(this, &local->postoldparent, postoldparent);
+        dht_iatt_merge(this, &local->preparent, prenewparent);
+        dht_iatt_merge(this, &local->postparent, postnewparent);
+    }
+
+    /* Create the linkto file for the dst file */
+    if ((src_cached == dst_cached) && (dst_hashed != dst_cached)) {
+        link_frame = copy_frame(frame);
+        if (!link_frame) {
+            goto unlink;
+        }
+
+        /* fop value sent as maxvalue because it is not used
+         * anywhere in this case */
+        link_local = dht_local_init(link_frame, &local->loc2, NULL,
+                                    GF_FOP_MAXVALUE);
+        if (!link_local) {
+            goto unlink;
+        }
+
+        if (link_local->loc.inode)
+            inode_unref(link_local->loc.inode);
+        link_local->loc.inode = inode_ref(local->loc.inode);
+        link_local->main_frame = frame;
+        link_local->stbuf = local->stbuf;
+        gf_uuid_copy(link_local->gfid, local->loc.inode->gfid);
+
+        dht_linkfile_create(link_frame, dht_rename_links_create_cbk, this,
+                            src_cached, dst_hashed, &link_local->loc);
+        return 0;
+    }
 
-        if ((src_cached != dst_hashed) && (rename_subvol == dst_hashed)) {
-                DHT_MARKER_DONT_ACCOUNT(local->xattr_req);
-        }
+unlink:
 
-        if (rename_subvol == src_cached) {
-                DHT_CHANGELOG_TRACK_AS_RENAME(local->xattr_req, &local->loc,
-                                              &local->loc2);
-        }
+    if (link_frame) {
+        DHT_STACK_DESTROY(link_frame);
+    }
+    dht_rename_unlink(frame, this);
+    return 0;
 
-        gf_msg_trace (this->name, 0,
-                      "renaming %s => %s (%s)",
-                      local->loc.path, local->loc2.path, rename_subvol->name);
+cleanup:
+    dht_rename_cleanup(frame);
 
-        if (local->linked == _gf_true)
-                FRAME_SU_DO (frame, dht_local_t);
-        STACK_WIND_COOKIE (frame, dht_rename_cbk, rename_subvol, rename_subvol,
-                           rename_subvol->fops->rename, &local->loc,
-                           &local->loc2, local->xattr_req);
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+dht_do_rename(call_frame_t *frame)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *this = NULL;
+    xlator_t *rename_subvol = NULL;
+
+    local = frame->local;
+    this = frame->this;
+
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
+    src_cached = local->src_cached;
+
+    if (src_cached == dst_cached)
+        rename_subvol = src_cached;
+    else
+        rename_subvol = dst_hashed;
+
+    if ((src_cached != dst_hashed) && (rename_subvol == dst_hashed)) {
+        DHT_MARKER_DONT_ACCOUNT(local->xattr_req);
+    }
+
+    if (rename_subvol == src_cached) {
+        DHT_CHANGELOG_TRACK_AS_RENAME(local->xattr_req, &local->loc,
+                                      &local->loc2);
+    }
+
+    gf_msg_trace(this->name, 0, "renaming %s => %s (%s)", local->loc.path,
+                 local->loc2.path, rename_subvol->name);
+
+    if (local->linked == _gf_true)
+        FRAME_SU_DO(frame, dht_local_t);
+    STACK_WIND_COOKIE(frame, dht_rename_cbk, rename_subvol, rename_subvol,
+                      rename_subvol->fops->rename, &local->loc, &local->loc2,
+                      local->xattr_req);
+    return 0;
+}
 
-        local = frame->local;
-        prev = cookie;
+int
+dht_rename_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, 0,
-                              "link/file on %s failed (%s)",
-                              prev->name, strerror (op_errno));
-                local->op_ret   = -1;
-                local->op_errno = op_errno;
-                local->added_link = _gf_false;
-        } else
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
+    local = frame->local;
+    prev = cookie;
 
-        if (local->op_ret == -1)
-                goto cleanup;
+    if (op_ret == -1) {
+        gf_msg_debug(this->name, 0, "link/file on %s failed (%s)", prev->name,
+                     strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        local->added_link = _gf_false;
+    } else
+        dht_iatt_merge(this, &local->stbuf, stbuf);
 
-        dht_do_rename (frame);
+    if (local->op_ret == -1)
+        goto cleanup;
 
-        return 0;
+    dht_do_rename(frame);
+
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_linkto_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+dht_rename_linkto_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, inode_t *inode,
+                      struct iatt *stbuf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
-        xlator_t        *prev = NULL;
-        xlator_t        *src_cached = NULL;
-        dict_t          *xattr = NULL;
-
-        local = frame->local;
-        DHT_MARK_FOP_INTERNAL (xattr);
-        prev = cookie;
-        src_cached = local->src_cached;
-
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, 0,
-                              "link/file on %s failed (%s)",
-                              prev->name, strerror (op_errno));
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_cached = NULL;
+    dict_t *xattr = NULL;
 
-        /* If linkto creation failed move to failure cleanup code,
-        * instead of continuing with creating the link file */
-        if (local->op_ret != 0) {
-                goto cleanup;
-        }
+    local = frame->local;
+    DHT_MARK_FOP_INTERNAL(xattr);
+    prev = cookie;
+    src_cached = local->src_cached;
 
-        gf_msg_trace (this->name, 0,
-                      "link %s => %s (%s)", local->loc.path,
-                      local->loc2.path, src_cached->name);
-        if (gf_uuid_compare (local->loc.pargfid,
-                                local->loc2.pargfid) == 0) {
-                DHT_MARKER_DONT_ACCOUNT(xattr);
-        }
+    if (op_ret == -1) {
+        gf_msg_debug(this->name, 0, "link/file on %s failed (%s)", prev->name,
+                     strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
 
-        local->added_link = _gf_true;
+    /* If linkto creation failed move to failure cleanup code,
+     * instead of continuing with creating the link file */
+    if (local->op_ret != 0) {
+        goto cleanup;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_rename_link_cbk, src_cached, src_cached,
-                           src_cached->fops->link, &local->loc, &local->loc2,
-                           xattr);
+    gf_msg_trace(this->name, 0, "link %s => %s (%s)", local->loc.path,
+                 local->loc2.path, src_cached->name);
+    if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+        DHT_MARKER_DONT_ACCOUNT(xattr);
+    }
 
-        if (xattr)
-                dict_unref (xattr);
+    local->added_link = _gf_true;
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rename_link_cbk, src_cached, src_cached,
+                      src_cached->fops->link, &local->loc, &local->loc2, xattr);
+
+    if (xattr)
+        dict_unref(xattr);
+
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_unlink_links_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             struct iatt *preparent, struct iatt *postparent,
-                             dict_t *xdata)
+dht_rename_unlink_links_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            struct iatt *preparent, struct iatt *postparent,
+                            dict_t *xdata)
 {
-	dht_local_t  *local = NULL;
-	xlator_t     *prev = NULL;
-
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
-	local = frame->local;
-	prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-	if ((op_ret == -1) && (op_errno != ENOENT)) {
-		gf_msg_debug (this->name, 0,
-		              "unlink of %s on %s failed (%s)",
-			      local->loc2.path, prev->name,
-                              strerror (op_errno));
-		local->op_ret   = -1;
-		local->op_errno = op_errno;
-	}
+    if ((op_ret == -1) && (op_errno != ENOENT)) {
+        gf_msg_debug(this->name, 0, "unlink of %s on %s failed (%s)",
+                     local->loc2.path, prev->name, strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
 
-        if (local->op_ret == -1)
-                goto cleanup;
+    if (local->op_ret == -1)
+        goto cleanup;
 
-        dht_do_rename (frame);
+    dht_do_rename(frame);
 
-	return 0;
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-	return 0;
+    return 0;
 }
 
-
 int
-dht_rename_create_links (call_frame_t *frame)
+dht_rename_create_links(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        xlator_t    *this = NULL;
-        xlator_t    *src_hashed = NULL;
-        xlator_t    *src_cached = NULL;
-        xlator_t    *dst_hashed = NULL;
-        xlator_t    *dst_cached = NULL;
-        int          call_cnt = 0;
-        dict_t      *xattr = NULL;
-
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    int call_cnt = 0;
+    dict_t *xattr = NULL;
 
-        local = frame->local;
-        this  = frame->this;
+    local = frame->local;
+    this = frame->this;
 
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    DHT_MARK_FOP_INTERNAL(xattr);
 
-        if (src_cached == dst_cached) {
-                dict_t *xattr_new = NULL;
+    if (src_cached == dst_cached) {
+        dict_t *xattr_new = NULL;
 
-                if (dst_hashed == dst_cached)
-                        goto nolinks;
+        if (dst_hashed == dst_cached)
+            goto nolinks;
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-		gf_msg_trace (this->name, 0,
-		              "unlinking dst linkfile %s @ %s",
-			      local->loc2.path, dst_hashed->name);
+        gf_msg_trace(this->name, 0, "unlinking dst linkfile %s @ %s",
+                     local->loc2.path, dst_hashed->name);
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-		STACK_WIND_COOKIE (frame, dht_rename_unlink_links_cbk,
-                                   dst_hashed, dst_hashed,
-			           dst_hashed->fops->unlink, &local->loc2, 0,
-			           xattr_new);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_links_cbk, dst_hashed,
+                          dst_hashed, dst_hashed->fops->unlink, &local->loc2, 0,
+                          xattr_new);
 
-                dict_unref (xattr_new);
-                if (xattr)
-                        dict_unref (xattr);
-
-                return 0;
-        }
+        dict_unref(xattr_new);
+        if (xattr)
+            dict_unref(xattr);
 
-        if (src_cached != dst_hashed) {
-                /* needed to create the link file */
-                call_cnt++;
-                if (dst_hashed != src_hashed)
-                        /* needed to create the linkto file */
-                        call_cnt ++;
+        return 0;
+    }
+
+    if (src_cached != dst_hashed) {
+        /* needed to create the link file */
+        call_cnt++;
+        if (dst_hashed != src_hashed)
+            /* needed to create the linkto file */
+            call_cnt++;
+    }
+
+    /* We should not have any failures post the link creation, as this
+     * introduces the newname into the namespace. Clients could have cached
+     * the existence of the newname and may start taking actions based on
+     * the same. Hence create the linkto first, and then attempt the link.
+     *
+     * NOTE: If another client is attempting the same oldname -> newname
+     * rename, and finds both file names as existing, and are hard links
+     * to each other, then FUSE would send in an unlink for oldname. In
+     * this time duration if we treat the linkto as a critical error and
+     * unlink the newname we created, we would have effectively lost the
+     * file to rename operations. */
+    if (dst_hashed != src_hashed && src_cached != dst_hashed) {
+        gf_msg_trace(this->name, 0, "linkfile %s @ %s => %s", local->loc.path,
+                     dst_hashed->name, src_cached->name);
+
+        memcpy(local->gfid, local->loc.inode->gfid, 16);
+        dht_linkfile_create(frame, dht_rename_linkto_cbk, this, src_cached,
+                            dst_hashed, &local->loc);
+    } else if (src_cached != dst_hashed) {
+        dict_t *xattr_new = NULL;
+
+        xattr_new = dict_copy_with_ref(xattr, NULL);
+
+        gf_msg_trace(this->name, 0, "link %s => %s (%s)", local->loc.path,
+                     local->loc2.path, src_cached->name);
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
         }
 
-        /* We should not have any failures post the link creation, as this
-         * introduces the newname into the namespace. Clients could have cached
-         * the existence of the newname and may start taking actions based on
-         * the same. Hence create the linkto first, and then attempt the link.
-         *
-         * NOTE: If another client is attempting the same oldname -> newname
-         * rename, and finds both file names as existing, and are hard links
-         * to each other, then FUSE would send in an unlink for oldname. In
-         * this time duration if we treat the linkto as a critical error and
-         * unlink the newname we created, we would have effectively lost the
-         * file to rename operations. */
-        if (dst_hashed != src_hashed && src_cached != dst_hashed) {
-                gf_msg_trace (this->name, 0,
-                              "linkfile %s @ %s => %s",
-                              local->loc.path, dst_hashed->name,
-                              src_cached->name);
-
-                memcpy (local->gfid, local->loc.inode->gfid, 16);
-                dht_linkfile_create (frame, dht_rename_linkto_cbk, this,
-                                     src_cached, dst_hashed, &local->loc);
-        } else if (src_cached != dst_hashed) {
-                dict_t *xattr_new = NULL;
-
-                xattr_new = dict_copy_with_ref (xattr, NULL);
-
-                gf_msg_trace (this->name, 0,
-                              "link %s => %s (%s)", local->loc.path,
-                              local->loc2.path, src_cached->name);
-                if (gf_uuid_compare (local->loc.pargfid,
-                                  local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
-
-                local->added_link = _gf_true;
+        local->added_link = _gf_true;
 
-                STACK_WIND_COOKIE (frame, dht_rename_link_cbk, src_cached,
-                                   src_cached, src_cached->fops->link,
-                                   &local->loc, &local->loc2, xattr_new);
+        STACK_WIND_COOKIE(frame, dht_rename_link_cbk, src_cached, src_cached,
+                          src_cached->fops->link, &local->loc, &local->loc2,
+                          xattr_new);
 
-                dict_unref (xattr_new);
-        }
+        dict_unref(xattr_new);
+    }
 
 nolinks:
-        if (!call_cnt) {
-                /* skip to next step */
-                dht_do_rename (frame);
-        }
-        if (xattr)
-                dict_unref (xattr);
-
-        return 0;
+    if (!call_cnt) {
+        /* skip to next step */
+        dht_do_rename(frame);
+    }
+    if (xattr)
+        dict_unref(xattr);
+
+    return 0;
 }
 
 int
-dht_rename_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                       struct iatt *postparent)
+dht_rename_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *stbuf, dict_t *xattr,
+                      struct iatt *postparent)
 {
-        dht_local_t *local                              = NULL;
-        int          call_cnt                           = 0;
-        dht_conf_t  *conf                               = NULL;
-        char         gfid_local[GF_UUID_BUF_SIZE]       = {0};
-        char         gfid_server[GF_UUID_BUF_SIZE]      = {0};
-        int          child_index                        = -1;
-
-
-        child_index = (long)cookie;
-
-        local = frame->local;
-        conf = this->private;
-
-        if (op_ret < 0) {
-                /* The meaning of is_linkfile is overloaded here. For locking
-                 * to work properly both rebalance and rename should acquire
-                 * lock on datafile. The reason for sending this lookup is to
-                 * find out whether we've acquired a lock on data file.
-                 * Between the lookup before rename and this rename, the
-                 * file could be migrated by a rebalance process and now this
-                 * file this might be a linkto file. We verify that by sending
-                 * this lookup. However, if this lookup fails we cannot really
-                 * say whether we've acquired lock on a datafile or linkto file.
-                 * So, we act conservatively and _assume_
-                 * that this is a linkfile and fail the rename operation.
-                 */
-                local->is_linkfile = _gf_true;
-                local->op_errno = op_errno;
-        } else if (xattr && check_is_linkfile (inode, stbuf, xattr,
-                                               conf->link_xattr_name)) {
-                local->is_linkfile = _gf_true;
-                /* Found linkto file instead of data file, passdown ENOENT
-                 * based on the above comment */
-                local->op_errno = ENOENT;
-        }
-
-        if (!local->is_linkfile &&
-             gf_uuid_compare (local->lock[0].layout.parent_layout.locks[child_index]->loc.gfid,
-             stbuf->ia_gfid)) {
-                gf_uuid_unparse (local->lock[0].layout.parent_layout.locks[child_index]->loc.gfid,
-                                 gfid_local);
-                gf_uuid_unparse (stbuf->ia_gfid, gfid_server);
-
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "path:%s, received a different gfid, local_gfid= %s"
-                        " server_gfid: %s",
-                        local->loc.path, gfid_local, gfid_server);
-
-                /* Will passdown ENOENT anyway since the file we sent on
-                 * rename is replaced with a different file */
-                local->op_errno = ENOENT;
-                /* Since local->is_linkfile is used here to detect failure,
-                 * marking this to true */
-                local->is_linkfile = _gf_true;
-        }
-
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                if (local->is_linkfile) {
-                        local->op_ret = -1;
-                        goto fail;
+    dht_local_t *local = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_server[GF_UUID_BUF_SIZE] = {0};
+    int child_index = -1;
+    gf_boolean_t is_src = _gf_false;
+    loc_t *loc = NULL;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+    conf = this->private;
+
+    is_src = (child_index == 0);
+    if (is_src)
+        loc = &local->loc;
+    else
+        loc = &local->loc2;
+
+    if (op_ret >= 0) {
+        if (is_src)
+            local->src_cached = dht_subvol_get_cached(this, local->loc.inode);
+        else {
+            if (loc->inode)
+                gf_uuid_unparse(loc->inode->gfid, gfid_local);
+
+            gf_msg_debug(this->name, 0,
+                         "dst_cached before lookup: %s, "
+                         "(path:%s)(gfid:%s),",
+                         local->loc2.path,
+                         local->dst_cached ? local->dst_cached->name : NULL,
+                         local->dst_cached ? gfid_local : NULL);
+
+            local->dst_cached = dht_subvol_get_cached(this,
+                                                      local->loc2_copy.inode);
+
+            gf_uuid_unparse(stbuf->ia_gfid, gfid_local);
+
+            gf_msg_debug(this->name, GF_LOG_WARNING,
+                         "dst_cached after lookup: %s, "
+                         "(path:%s)(gfid:%s)",
+                         local->loc2.path,
+                         local->dst_cached ? local->dst_cached->name : NULL,
+                         local->dst_cached ? gfid_local : NULL);
+
+            if ((local->loc2.inode == NULL) ||
+                gf_uuid_compare(stbuf->ia_gfid, local->loc2.inode->gfid)) {
+                if (local->loc2.inode != NULL) {
+                    inode_unlink(local->loc2.inode, local->loc2.parent,
+                                 local->loc2.name);
+                    inode_unref(local->loc2.inode);
                 }
 
-                dht_rename_create_links (frame);
-        }
-
-        return 0;
+                local->loc2.inode = inode_link(local->loc2_copy.inode,
+                                               local->loc2_copy.parent,
+                                               local->loc2_copy.name, stbuf);
+                gf_uuid_copy(local->loc2.gfid, stbuf->ia_gfid);
+            }
+        }
+    }
+
+    if (op_ret < 0) {
+        if (is_src) {
+            /* The meaning of is_linkfile is overloaded here. For locking
+             * to work properly both rebalance and rename should acquire
+             * lock on datafile. The reason for sending this lookup is to
+             * find out whether we've acquired a lock on data file.
+             * Between the lookup before rename and this rename, the
+             * file could be migrated by a rebalance process and now this
+             * file this might be a linkto file. We verify that by sending
+             * this lookup. However, if this lookup fails we cannot really
+             * say whether we've acquired lock on a datafile or linkto file.
+             * So, we act conservatively and _assume_
+             * that this is a linkfile and fail the rename operation.
+             */
+            local->is_linkfile = _gf_true;
+            local->op_errno = op_errno;
+        } else {
+            if (local->dst_cached)
+                gf_msg_debug(this->name, op_errno,
+                             "file %s (gfid:%s) was present "
+                             "(hashed-subvol=%s, "
+                             "cached-subvol=%s) before rename,"
+                             " but lookup failed",
+                             local->loc2.path,
+                             uuid_utoa(local->loc2.inode->gfid),
+                             local->dst_hashed->name, local->dst_cached->name);
+            if (dht_inode_missing(op_errno))
+                local->dst_cached = NULL;
+        }
+    } else if (is_src && xattr &&
+               check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        local->is_linkfile = _gf_true;
+        /* Found linkto file instead of data file, passdown ENOENT
+         * based on the above comment */
+        local->op_errno = ENOENT;
+    }
+
+    if (!local->is_linkfile && (op_ret >= 0) &&
+        gf_uuid_compare(loc->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(loc->gfid, gfid_local);
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_server);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "path:%s, received a different gfid, local_gfid= %s"
+               " server_gfid: %s",
+               local->loc.path, gfid_local, gfid_server);
+
+        /* Will passdown ENOENT anyway since the file we sent on
+         * rename is replaced with a different file */
+        local->op_errno = ENOENT;
+        /* Since local->is_linkfile is used here to detect failure,
+         * marking this to true */
+        local->is_linkfile = _gf_true;
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->is_linkfile) {
+            local->op_ret = -1;
+            goto fail;
+        }
+
+        dht_rename_create_links(frame);
+    }
+
+    return 0;
 fail:
-        dht_rename_unlock (frame, this);
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
-int32_t
-dht_rename_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+int
+dht_rename_file_lock1_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        dict_t      *xattr_req                  = NULL;
-        dht_conf_t  *conf                       = NULL;
-        int          i                          = 0;
-        int          count                      = 0;
-
-
-        local = frame->local;
-        conf = this->private;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring inodelk failed "
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+
+    local = frame->local;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "protecting namespace of %s failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->current == &local->lock[0] ? local->loc.path
+                                                 : local->loc2.path,
+               local->loc.path, src_gfid, local->src_hashed->name,
+               local->loc2.path, dst_gfid,
+               local->dst_hashed ? local->dst_hashed->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    if (local->current == &local->lock[0]) {
+        loc = &local->loc2;
+        subvol = local->dst_hashed;
+        local->current = &local->lock[1];
+    } else {
+        loc = &local->loc;
+        subvol = local->src_hashed;
+        local->current = &local->lock[0];
+    }
+
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_lock_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
+err:
+    /* No harm in calling an extra unlock */
+    dht_rename_unlock(frame, this);
+    return 0;
+}
 
-                local->op_ret = -1;
-                local->op_errno = op_errno;
+int32_t
+dht_rename_file_protect_namespace(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+
+    local = frame->local;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring inodelk failed "
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+
+        goto err;
+    }
+
+    /* Locks on src and dst needs to ordered which otherwise might cause
+     * deadlocks when rename (src, dst) and rename (dst, src) is done from
+     * two different clients
+     */
+    ret = dht_order_rename_lock(frame, &loc, &subvol);
+    if (ret) {
+        local->op_errno = ENOMEM;
+        goto err;
+    }
+
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_file_lock1_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 
-                goto done;
-        }
+err:
+    /* Its fine to call unlock even when no locks are acquired, as we check
+     * for lock->locked before winding a unlock call.
+     */
+    dht_rename_unlock(frame, this);
 
-        xattr_req = dict_new ();
-        if (xattr_req == NULL) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                goto done;
-        }
+    return 0;
+}
 
-        op_ret = dict_set_uint32 (xattr_req,
-                                  conf->link_xattr_name, 256);
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = -op_ret;
-                goto done;
+int32_t
+dht_rename_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dict_t *xattr_req = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *subvol = NULL;
+    dht_lock_t *lock = NULL;
+
+    local = frame->local;
+    conf = this->private;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "protecting namespace of %s failed. "
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->current == &local->lock[0] ? local->loc.path
+                                                 : local->loc2.path,
+               local->loc.path, src_gfid, local->src_hashed->name,
+               local->loc2.path, dst_gfid,
+               local->dst_hashed ? local->dst_hashed->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+
+        goto done;
+    }
+
+    xattr_req = dict_new();
+    if (xattr_req == NULL) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        goto done;
+    }
+
+    op_ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = -op_ret;
+        goto done;
+    }
+
+    /* dst_cached might've changed. This normally happens for two reasons:
+     * 1. rebalance migrated dst
+     * 2. Another parallel rename was done overwriting dst
+     *
+     * Doing a lookup on local->loc2 when dst exists, but is associated
+     * with a different gfid will result in an ESTALE error. So, do a fresh
+     * lookup with a new inode on dst-path and handle change of dst-cached
+     * in the cbk. Also, to identify dst-cached changes we do a lookup on
+     * "this" rather than the subvol.
+     */
+    loc_copy(&local->loc2_copy, &local->loc2);
+    inode_unref(local->loc2_copy.inode);
+    local->loc2_copy.inode = inode_new(local->loc.inode->table);
+
+    /* Why not use local->lock.locks[?].loc for lookup post lock phase
+     * ---------------------------------------------------------------
+     * "layout.parent_layout.locks[?].loc" does not have the name and pargfid
+     * populated.
+     * Reason: If we had populated the name and pargfid, server might
+     * resolve to a successful lookup even if there is a file with same name
+     * with a different gfid(unlink & create) as server does name based
+     * resolution on first priority. And this can result in operating on a
+     * different inode entirely.
+     *
+     * Now consider a scenario where source file was renamed by some other
+     * client to a new name just before this lock was granted. So if a
+     * lookup would be done on local->lock[0].layout.parent_layout.locks[?].loc,
+     * server will send success even if the entry was renamed (since server will
+     * do a gfid based resolution). So once a lock is granted, make sure the
+     * file exists with the name that the client requested with.
+     * */
+
+    local->call_cnt = 2;
+    for (i = 0; i < 2; i++) {
+        if (i == 0) {
+            lock = local->rename_inodelk_backward_compatible[0];
+            if (gf_uuid_compare(local->loc.gfid, lock->loc.gfid) == 0)
+                subvol = lock->xl;
+            else {
+                lock = local->rename_inodelk_backward_compatible[1];
+                subvol = lock->xl;
+            }
+        } else {
+            subvol = this;
         }
 
-        count = local->call_cnt = local->lock[0].layout.parent_layout.lk_count;
-
-        /* Why not use local->lock.locks[?].loc for lookup post lock phase
-         * ---------------------------------------------------------------
-         * "layout.parent_layout.locks[?].loc" does not have the name and pargfid
-         * populated.
-         * Reason: If we had populated the name and pargfid, server might
-         * resolve to a successful lookup even if there is a file with same name
-         * with a different gfid(unlink & create) as server does name based
-         * resolution on first priority. And this can result in operating on a
-         * different inode entirely.
-         *
-         * Now consider a scenario where source file was renamed by some other
-         * client to a new name just before this lock was granted. So if a
-         * lookup would be done on local->lock[0].layout.parent_layout.locks[?].loc,
-         * server will send success even if the entry was renamed (since server will
-         * do a gfid based resolution). So once a lock is granted, make sure the file
-         * exists with the name that the client requested with.
-         * */
-
-        for (i = 0; i < count; i++) {
-                STACK_WIND_COOKIE (frame, dht_rename_lookup_cbk, (void *)(long)i,
-                                   local->lock[0].layout.parent_layout.locks[i]->xl,
-                                   local->lock[0].layout.parent_layout.locks[i]->xl->fops->lookup,
-                                   ((gf_uuid_compare (local->loc.gfid, \
-                                     local->lock[0].layout.parent_layout.locks[i]->loc.gfid) == 0) ?
-                                    &local->loc : &local->loc2), xattr_req);
-        }
+        STACK_WIND_COOKIE(frame, dht_rename_lookup_cbk, (void *)(long)i, subvol,
+                          subvol->fops->lookup,
+                          (i == 0) ? &local->loc : &local->loc2_copy,
+                          xattr_req);
+    }
 
-        dict_unref (xattr_req);
-        return 0;
+    dict_unref(xattr_req);
+    return 0;
 
 done:
-        /* Its fine to call unlock even when no locks are acquired, as we check
-         * for lock->locked before winding a unlock call.
-         */
-        dht_rename_unlock (frame, this);
+    /* Its fine to call unlock even when no locks are acquired, as we check
+     * for lock->locked before winding a unlock call.
+     */
+    dht_rename_unlock(frame, this);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_lock (call_frame_t *frame)
+dht_rename_lock(call_frame_t *frame)
 {
-        dht_local_t  *local    = NULL;
-        int           count    = 1, ret = -1;
-        dht_lock_t  **lk_array = NULL;
-
-        local = frame->local;
-
-        if (local->dst_cached)
-                count++;
-
-        lk_array = GF_CALLOC (count, sizeof (*lk_array), gf_common_mt_pointer);
-        if (lk_array == NULL)
-                goto err;
-
-        lk_array[0] = dht_lock_new (frame->this, local->src_cached, &local->loc,
-                                    F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL);
-        if (lk_array[0] == NULL)
-                goto err;
-
-        if (local->dst_cached) {
-                lk_array[1] = dht_lock_new (frame->this, local->dst_cached,
-                                            &local->loc2, F_WRLCK,
-                                            DHT_FILE_MIGRATE_DOMAIN, NULL);
-                if (lk_array[1] == NULL)
-                        goto err;
-        }
-
-        local->lock[0].layout.parent_layout.locks = lk_array;
-        local->lock[0].layout.parent_layout.lk_count = count;
-
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    FAIL_ON_ANY_ERROR, dht_rename_lock_cbk);
-        if (ret < 0) {
-                local->lock[0].layout.parent_layout.locks = NULL;
-                local->lock[0].layout.parent_layout.lk_count = 0;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
+
+    local = frame->local;
+
+    if (local->dst_cached)
+        count++;
+
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (lk_array == NULL)
+        goto err;
+
+    lk_array[0] = dht_lock_new(frame->this, local->src_cached, &local->loc,
+                               F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL,
+                               FAIL_ON_ANY_ERROR);
+    if (lk_array[0] == NULL)
+        goto err;
+
+    if (local->dst_cached) {
+        /* dst might be removed by the time inodelk reaches bricks,
+         * which can result in ESTALE errors. POSIX imposes no
+         * restriction for dst to be present for renames to be
+         * successful. So, we'll ignore ESTALE errors. As far as
+         * synchronization on dst goes, we'll achieve the same by
+         * holding entrylk on parent directory of dst in the namespace
+         * of basename(dst). Also, there might not be quorum in cluster
+         * xlators like EC/disperse on errno, in which case they return
+         * EIO. For eg., in a disperse (4 + 2), 3 might return success
+         * and three might return ESTALE. Disperse, having no Quorum
+         * unwinds inodelk with EIO. So, ignore EIO too.
+         */
+        lk_array[1] = dht_lock_new(frame->this, local->dst_cached, &local->loc2,
+                                   F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL,
+                                   IGNORE_ENOENT_ESTALE_EIO);
+        if (lk_array[1] == NULL)
+            goto err;
+    }
+
+    local->rename_inodelk_backward_compatible = lk_array;
+    local->rename_inodelk_bc_count = count;
+
+    /* retaining inodelks for the sake of backward compatibility. Please
+     * make sure to remove this inodelk once all of 3.10, 3.12 and 3.13
+     * reach EOL. Better way of getting synchronization would be to acquire
+     * entrylks on src and dst parent directories in the namespace of
+     * basenames of src and dst
+     */
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_rename_file_protect_namespace);
+    if (ret < 0) {
+        local->rename_inodelk_backward_compatible = NULL;
+        local->rename_inodelk_bc_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (lk_array != NULL) {
-                int tmp_count = 0, i = 0;
+    if (lk_array != NULL) {
+        int tmp_count = 0, i = 0;
 
-                for (i = 0; (i < count) && (lk_array[i]); i++, tmp_count++);
+        for (i = 0; (i < count) && (lk_array[i]); i++, tmp_count++)
+            ;
 
-                dht_lock_array_free (lk_array, tmp_count);
-                GF_FREE (lk_array);
-        }
+        dht_lock_array_free(lk_array, tmp_count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_rename (call_frame_t *frame, xlator_t *this,
-            loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+dht_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata)
 {
-        xlator_t    *src_cached = NULL;
-        xlator_t    *src_hashed = NULL;
-        xlator_t    *dst_cached = NULL;
-        xlator_t    *dst_hashed = NULL;
-        int          op_errno = -1;
-        int          ret = -1;
-        dht_local_t *local = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (newloc, err);
-
-        gf_uuid_unparse(oldloc->inode->gfid, gfid);
-
-        src_hashed = dht_subvol_get_hashed (this, oldloc);
-        if (!src_hashed) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No hashed subvolume in layout for path=%s,"
-                        "(gfid = %s)", oldloc->path, gfid);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        src_cached = dht_subvol_get_cached (this, oldloc->inode);
-        if (!src_cached) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No cached subvolume for path = %s,"
-                        "(gfid = %s)", oldloc->path, gfid);
-
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        dst_hashed = dht_subvol_get_hashed (this, newloc);
-        if (!dst_hashed) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No hashed subvolume in layout for path=%s",
-                        newloc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (newloc->inode)
-                dst_cached = dht_subvol_get_cached (this, newloc->inode);
-
-        local = dht_local_init (frame, oldloc, NULL, GF_FOP_RENAME);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        /* cached_subvol will be set from dht_local_init, reset it to NULL,
-           as the logic of handling rename is different  */
-        local->cached_subvol = NULL;
-
-        ret = loc_copy (&local->loc2, newloc);
-        if (ret == -1) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->src_hashed = src_hashed;
-        local->src_cached = src_cached;
-        local->dst_hashed = dst_hashed;
-        local->dst_cached = dst_cached;
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_RENAME_INFO,
-                "renaming %s (hash=%s/cache=%s) => %s (hash=%s/cache=%s)",
-                oldloc->path, src_hashed->name, src_cached->name,
-                newloc->path, dst_hashed->name,
-                dst_cached ? dst_cached->name : "<nul>");
-
-        if (IA_ISDIR (oldloc->inode->ia_type)) {
-                dht_rename_dir (frame, this);
-        } else {
-                local->op_ret = 0;
-                ret = dht_rename_lock (frame);
-                if (ret < 0)
-                        goto err;
+    xlator_t *src_cached = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    int op_errno = -1;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    char newgfid[GF_UUID_BUF_SIZE] = {0};
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    gf_uuid_unparse(oldloc->inode->gfid, gfid);
+
+    src_hashed = dht_subvol_get_hashed(this, oldloc);
+    if (!src_hashed) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No hashed subvolume in layout for path=%s,"
+               "(gfid = %s)",
+               oldloc->path, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    src_cached = dht_subvol_get_cached(this, oldloc->inode);
+    if (!src_cached) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No cached subvolume for path = %s,"
+               "(gfid = %s)",
+               oldloc->path, gfid);
+
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    dst_hashed = dht_subvol_get_hashed(this, newloc);
+    if (!dst_hashed) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No hashed subvolume in layout for path=%s", newloc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (newloc->inode)
+        dst_cached = dht_subvol_get_cached(this, newloc->inode);
+
+    local = dht_local_init(frame, oldloc, NULL, GF_FOP_RENAME);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    /* cached_subvol will be set from dht_local_init, reset it to NULL,
+       as the logic of handling rename is different  */
+    local->cached_subvol = NULL;
+
+    ret = loc_copy(&local->loc2, newloc);
+    if (ret == -1) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->src_hashed = src_hashed;
+    local->src_cached = src_cached;
+    local->dst_hashed = dst_hashed;
+    local->dst_cached = dst_cached;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (newloc->inode)
+        gf_uuid_unparse(newloc->inode->gfid, newgfid);
+
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_INFO,
+           "renaming %s (%s) (hash=%s/cache=%s) => %s (%s) "
+           "(hash=%s/cache=%s) ",
+           oldloc->path, gfid, src_hashed->name, src_cached->name, newloc->path,
+           newloc->inode ? newgfid : NULL, dst_hashed->name,
+           dst_cached ? dst_cached->name : "<nul>");
+
+    if (IA_ISDIR(oldloc->inode->ia_type)) {
+        dht_rename_dir(frame, this);
+    } else {
+        local->op_ret = 0;
+        ret = dht_rename_lock(frame);
+        if (ret < 0) {
+            op_errno = ENOMEM;
+            goto err;
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                          NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
+}
+
+int
+dht_pt_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata)
+{
+    gf_boolean_t free_xdata = _gf_false;
+
+    /* Just a pass through */
+    if (!IA_ISDIR(oldloc->inode->ia_type)) {
+        if (!xdata) {
+            free_xdata = _gf_true;
+        }
+        DHT_CHANGELOG_TRACK_AS_RENAME(xdata, oldloc, newloc);
+    }
+    default_rename(frame, this, oldloc, newloc, xdata);
+    if (free_xdata && xdata) {
+        dict_unref(xdata);
+        xdata = NULL;
+    }
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-selfheal.c b/xlators/cluster/dht/src/dht-selfheal.c
index 1577d03e728..3e24065227c 100644
--- a/xlators/cluster/dht/src/dht-selfheal.c
+++ b/xlators/cluster/dht/src/dht-selfheal.c
@@ -8,2564 +8,2531 @@
   cases as published by the Free Software Foundation.
 */
 
-
-#include "glusterfs.h"
-#include "xlator.h"
-#include "dht-common.h"
-#include "dht-messages.h"
 #include "dht-lock.h"
-#include "glusterfs-acl.h"
-
-#define DHT_SET_LAYOUT_RANGE(layout,i,srt,chunk,path)    do {           \
-                layout->list[i].start = srt;                            \
-                layout->list[i].stop  = srt + chunk - 1;                \
-                layout->list[i].commit_hash = layout->commit_hash;      \
-                                                                        \
-                gf_msg_trace (this->name, 0,                            \
-                              "gave fix: %u - %u, with commit-hash %u"  \
-                              " on %s for %s",                          \
-                              layout->list[i].start,                    \
-                              layout->list[i].stop,                     \
-                              layout->list[i].commit_hash,              \
-                              layout->list[i].xlator->name, path);      \
-        } while (0)
-
-#define DHT_RESET_LAYOUT_RANGE(layout)    do {                          \
-                int cnt = 0;                                            \
-                for (cnt = 0; cnt < layout->cnt; cnt++ ) {              \
-                        layout->list[cnt].start = 0;                    \
-                        layout->list[cnt].stop  = 0;                    \
-                }                                                       \
-        } while (0)
 
-int
-dht_selfheal_layout_lock (call_frame_t *frame, dht_layout_t *layout,
-                          gf_boolean_t newdir,
-                          dht_selfheal_layout_t healer,
-                          dht_need_heal_t should_heal);
+#define DHT_SET_LAYOUT_RANGE(layout, i, srt, chunk, path)                      \
+    do {                                                                       \
+        layout->list[i].start = srt;                                           \
+        layout->list[i].stop = srt + chunk - 1;                                \
+        layout->list[i].commit_hash = layout->commit_hash;                     \
+                                                                               \
+        gf_msg_trace(this->name, 0,                                            \
+                     "gave fix: 0x%x - 0x%x, with commit-hash 0x%x"            \
+                     " on %s for %s",                                          \
+                     layout->list[i].start, layout->list[i].stop,              \
+                     layout->list[i].commit_hash,                              \
+                     layout->list[i].xlator->name, path);                      \
+    } while (0)
+
+#define DHT_RESET_LAYOUT_RANGE(layout)                                         \
+    do {                                                                       \
+        int cnt = 0;                                                           \
+        for (cnt = 0; cnt < layout->cnt; cnt++) {                              \
+            layout->list[cnt].start = 0;                                       \
+            layout->list[cnt].stop = 0;                                        \
+        }                                                                      \
+    } while (0)
+
+static int
+dht_selfheal_layout_lock(call_frame_t *frame, dht_layout_t *layout,
+                         gf_boolean_t newdir, dht_selfheal_layout_t healer,
+                         dht_need_heal_t should_heal);
 
 static uint32_t
-dht_overlap_calc (dht_layout_t *old, int o, dht_layout_t *new, int n)
+dht_overlap_calc(dht_layout_t *old, int o, dht_layout_t *new, int n)
 {
-	if (o >= old->cnt || n >= new->cnt)
-		return 0;
+    if (o >= old->cnt || n >= new->cnt)
+        return 0;
 
-	if (old->list[o].err > 0 || new->list[n].err > 0)
-		return 0;
+    if (old->list[o].err > 0 || new->list[n].err > 0)
+        return 0;
 
-        if (old->list[o].start == old->list[o].stop) {
-                return 0;
-        }
+    if (old->list[o].start == old->list[o].stop) {
+        return 0;
+    }
 
-        if (new->list[n].start == new->list[n].stop) {
-                return 0;
-        }
+    if (new->list[n].start == new->list[n].stop) {
+        return 0;
+    }
 
-	if ((old->list[o].start > new->list[n].stop) ||
-	    (old->list[o].stop < new->list[n].start))
-		return 0;
+    if ((old->list[o].start > new->list[n].stop) ||
+        (old->list[o].stop < new->list[n].start))
+        return 0;
 
-	return min (old->list[o].stop, new->list[n].stop) -
-	        max (old->list[o].start, new->list[n].start) + 1;
+    return min(old->list[o].stop, new->list[n].stop) -
+           max(old->list[o].start, new->list[n].start) + 1;
 }
 
 int
-dht_selfheal_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_selfheal_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int
-dht_selfheal_dir_finish (call_frame_t *frame, xlator_t *this, int ret,
-                         int invoke_cbk)
+dht_selfheal_dir_finish(call_frame_t *frame, xlator_t *this, int ret,
+                        int invoke_cbk)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[0].ns.directory_ns);
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[0].ns.directory_ns);
 
-        /* Unlock inodelk */
-        lock_count = dht_lock_count (local->lock[0].ns.parent_layout.locks,
-                                     local->lock[0].ns.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
+    /* Unlock inodelk */
+    lock_count = dht_lock_count(local->lock[0].ns.parent_layout.locks,
+                                local->lock[0].ns.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
 
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
 
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
 
-        lock_local->lock[0].ns.parent_layout.locks = local->lock[0].ns.parent_layout.locks;
-        lock_local->lock[0].ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
+    lock_local->lock[0].ns.parent_layout.locks = local->lock[0]
+                                                     .ns.parent_layout.locks;
+    lock_local->lock[0]
+        .ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
 
-        local->lock[0].ns.parent_layout.locks = NULL;
-        local->lock[0].ns.parent_layout.lk_count = 0;
+    local->lock[0].ns.parent_layout.locks = NULL;
+    local->lock[0].ns.parent_layout.lk_count = 0;
 
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].ns.parent_layout.locks,
-                            lock_local->lock[0].ns.parent_layout.lk_count,
-                            dht_selfheal_unlock_cbk);
-        lock_frame = NULL;
+    dht_unlock_inodelk(lock_frame, lock_local->lock[0].ns.parent_layout.locks,
+                       lock_local->lock[0].ns.parent_layout.lk_count,
+                       dht_selfheal_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (invoke_cbk)
-                local->selfheal.dir_cbk (frame, NULL, frame->this, ret,
-                                         local->op_errno, NULL);
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
-
-        return 0;
+    if (invoke_cbk)
+        local->selfheal.dir_cbk(frame, NULL, frame->this, ret, local->op_errno,
+                                NULL);
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
+
+    return 0;
 }
 
 int
-dht_refresh_layout_done (call_frame_t *frame)
+dht_refresh_layout_done(call_frame_t *frame)
 {
-        int                    ret         = -1;
-        dht_layout_t          *refreshed   = NULL, *heal = NULL;
-        dht_local_t           *local       = NULL;
-        dht_need_heal_t        should_heal = NULL;
-        dht_selfheal_layout_t  healer      = NULL;
+    int ret = -1;
+    dht_layout_t *refreshed = NULL, *heal = NULL;
+    dht_local_t *local = NULL;
+    dht_need_heal_t should_heal = NULL;
+    dht_selfheal_layout_t healer = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        refreshed = local->selfheal.refreshed_layout;
-        heal = local->selfheal.layout;
+    refreshed = local->selfheal.refreshed_layout;
+    heal = local->selfheal.layout;
 
-        healer = local->selfheal.healer;
-        should_heal = local->selfheal.should_heal;
+    healer = local->selfheal.healer;
+    should_heal = local->selfheal.should_heal;
 
-        ret = dht_layout_sort (refreshed);
-        if (ret == -1) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_SORT_FAILED,
-                        "sorting the layout failed");
-                goto err;
-        }
+    ret = dht_layout_sort(refreshed);
+    if (ret == -1) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_LAYOUT_SORT_FAILED, NULL);
+        goto err;
+    }
 
-        if (should_heal (frame, &heal, &refreshed)) {
-                healer (frame, &local->loc, heal);
-        } else {
-                local->selfheal.layout = NULL;
-                local->selfheal.refreshed_layout = NULL;
-                local->selfheal.layout = refreshed;
+    if (should_heal(frame, &heal, &refreshed)) {
+        healer(frame, &local->loc, heal);
+    } else {
+        local->selfheal.layout = NULL;
+        local->selfheal.refreshed_layout = NULL;
+        local->selfheal.layout = refreshed;
 
-                dht_layout_unref (frame->this, heal);
+        dht_layout_unref(frame->this, heal);
 
-                dht_selfheal_dir_finish (frame, frame->this, 0, 1);
-        }
+        dht_selfheal_dir_finish(frame, frame->this, 0, 1);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, frame->this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, frame->this, -1, 1);
+    return 0;
 }
 
 int
-dht_refresh_layout_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, inode_t *inode,
-                        struct iatt *stbuf, dict_t *xattr,
-                        struct iatt *postparent)
+dht_refresh_layout_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, inode_t *inode,
+                       struct iatt *stbuf, dict_t *xattr,
+                       struct iatt *postparent)
 {
-        dht_local_t  *local                     = NULL;
-        int           this_call_cnt             = 0;
-        xlator_t     *prev                      = NULL;
-        dht_layout_t *layout                    = NULL;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, err);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, err);
-
-        local = frame->local;
-        prev  = cookie;
-
-        layout = local->selfheal.refreshed_layout;
-
-        LOCK (&frame->lock);
-        {
-                op_ret = dht_layout_merge (this, layout, prev,
-                                           op_ret, op_errno, xattr);
-
-                dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-
-                if (op_ret == -1) {
-                        gf_uuid_unparse (local->loc.gfid, gfid);
-                        local->op_errno = op_errno;
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_FILE_LOOKUP_FAILED,
-                                "lookup of %s on %s returned error, gfid: %s",
-                                local->loc.path, prev->name, gfid);
-
-                        goto unlock;
-                }
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
 
-                local->op_ret = 0;
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", this->private, err);
+
+    local = frame->local;
+    prev = cookie;
+
+    layout = local->selfheal.refreshed_layout;
+
+    LOCK(&frame->lock);
+    {
+        op_ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
+
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+
+        if (op_ret == -1) {
+            gf_uuid_unparse(local->loc.gfid, gfid);
+            local->op_errno = op_errno;
+            gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                    DHT_MSG_FILE_LOOKUP_FAILED, "path=%s", local->loc.path,
+                    "name=%s", prev->name, "gfid=%s", gfid, NULL);
+
+            goto unlock;
         }
+
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-
-        if (is_last_call (this_call_cnt)) {
-                if (local->op_ret == 0) {
-                        local->refresh_layout_done (frame);
-                } else {
-                        goto err;
-                }
+    this_call_cnt = dht_frame_return(frame);
 
+    if (is_last_call(this_call_cnt)) {
+        if (local->op_ret == 0) {
+            local->refresh_layout_done(frame);
+        } else {
+            goto err;
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        local->refresh_layout_unlock (frame, this, -1, 1);
-        return 0;
+    if (local) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    }
+    return 0;
 }
 
 int
-dht_refresh_layout (call_frame_t *frame)
+dht_refresh_layout(call_frame_t *frame)
 {
-        int          call_cnt                   = 0;
-        int          i                          = 0, ret = -1;
-        dht_conf_t  *conf                       = NULL;
-        dht_local_t *local                      = NULL;
-        xlator_t    *this                       = NULL;
-        char         gfid[GF_UUID_BUF_SIZE]     = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-
-        this = frame->this;
-        conf = this->private;
-        local = frame->local;
-
-        call_cnt = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
-        local->op_ret = -1;
-
-        if (local->selfheal.refreshed_layout) {
-                dht_layout_unref (this, local->selfheal.refreshed_layout);
-                local->selfheal.refreshed_layout = NULL;
-        }
-
-        local->selfheal.refreshed_layout = dht_layout_new (this,
-                                                           conf->subvolume_cnt);
-        if (!local->selfheal.refreshed_layout) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "mem allocation for layout failed, path:%s gfid:%s",
-                        local->loc.path, gfid);
-                goto out;
-        }
-
-        if (local->xattr != NULL) {
-                dict_del (local->xattr, conf->xattr_name);
-        }
-
+    int call_cnt = 0;
+    int i = 0, ret = -1;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+
+    this = frame->this;
+    conf = this->private;
+    local = frame->local;
+
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
+    local->op_ret = -1;
+
+    if (local->selfheal.refreshed_layout) {
+        dht_layout_unref(this, local->selfheal.refreshed_layout);
+        local->selfheal.refreshed_layout = NULL;
+    }
+
+    local->selfheal.refreshed_layout = dht_layout_new(this,
+                                                      conf->subvolume_cnt);
+    if (!local->selfheal.refreshed_layout) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MEM_ALLOC_FAILED,
+                "path=%s", local->loc.path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+
+    if (local->xattr != NULL) {
+        dict_del(local->xattr, conf->xattr_name);
+    }
+
+    if (local->xattr_req == NULL) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        local->xattr_req = dict_new();
         if (local->xattr_req == NULL) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                local->xattr_req = dict_new ();
-                if (local->xattr_req == NULL) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY,
-                                "dict mem allocation failed, path:%s gfid:%s",
-                                local->loc.path, gfid);
-                        goto out;
-                }
+            gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                    "path=%s", local->loc.path, "gfid=%s", gfid, NULL);
+            goto out;
         }
+    }
 
-        if (dict_get (local->xattr_req, conf->xattr_name) == 0) {
-                ret = dict_set_uint32 (local->xattr_req, conf->xattr_name,
-                                       4 * 4);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:key = %s",
-                                local->loc.path, conf->xattr_name);
-        }
+    if (dict_get(local->xattr_req, conf->xattr_name) == 0) {
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret)
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                    "path=%s", local->loc.path, "key=%s", conf->xattr_name,
+                    NULL);
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_refresh_layout_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_refresh_layout_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, &local->loc,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        local->refresh_layout_unlock (frame, this, -1, 1);
-        return 0;
+    if (local) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    }
+    return 0;
 }
 
-
 int32_t
-dht_selfheal_layout_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_selfheal_layout_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret < 0) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_selfheal_dir_finish;
-        local->refresh_layout_done = dht_refresh_layout_done;
+    local->refresh_layout_unlock = dht_selfheal_dir_finish;
+    local->refresh_layout_done = dht_refresh_layout_done;
 
-        dht_refresh_layout (frame);
-        return 0;
+    dht_refresh_layout(frame);
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-
 gf_boolean_t
-dht_should_heal_layout (call_frame_t *frame, dht_layout_t **heal,
-                        dht_layout_t **ondisk)
+dht_should_heal_layout(call_frame_t *frame, dht_layout_t **heal,
+                       dht_layout_t **ondisk)
 {
-        gf_boolean_t  fixit = _gf_true;
-        dht_local_t  *local = NULL;
-        int           ret   = -1, heal_missing_dirs = 0;
-
-        local = frame->local;
-
-        if ((heal == NULL) || (*heal == NULL) || (ondisk == NULL)
-            || (*ondisk == NULL))
-                goto out;
-
-        ret = dht_layout_anomalies (frame->this, &local->loc, *ondisk,
-                                    &local->selfheal.hole_cnt,
-                                    &local->selfheal.overlaps_cnt,
-                                    NULL, &local->selfheal.down,
-                                    &local->selfheal.misc, NULL);
-
-        if (ret < 0)
-                goto out;
-
-        /* Directories might've been created as part of this self-heal. We've to
-         * sync non-layout xattrs and set range 0-0 on new directories
+    gf_boolean_t fixit = _gf_true;
+    dht_local_t *local = NULL;
+    int heal_missing_dirs = 0;
+
+    local = frame->local;
+
+    if ((heal == NULL) || (*heal == NULL) || (ondisk == NULL) ||
+        (*ondisk == NULL))
+        goto out;
+
+    dht_layout_anomalies(
+        frame->this, &local->loc, *ondisk, &local->selfheal.hole_cnt,
+        &local->selfheal.overlaps_cnt, &local->selfheal.missing_cnt,
+        &local->selfheal.down, &local->selfheal.misc, NULL);
+
+    /* Directories might've been created as part of this self-heal. We've to
+     * sync non-layout xattrs and set range 0-0 on new directories
+     */
+    heal_missing_dirs = local->selfheal.force_mkdir
+                            ? local->selfheal.force_mkdir
+                            : dht_layout_missing_dirs(*heal);
+
+    if ((local->selfheal.hole_cnt == 0) &&
+        (local->selfheal.overlaps_cnt == 0) && heal_missing_dirs) {
+        dht_layout_t *tmp = NULL;
+
+        /* Just added a brick and need to set 0-0 range on this brick.
+         * But ondisk layout is well-formed. So, swap layouts "heal" and
+         * "ondisk". Now "ondisk" layout will be used for healing
+         * xattrs. If there are any non-participating subvols in
+         * "ondisk" layout, dht_selfheal_dir_xattr_persubvol will set
+         * 0-0 and non-layout xattrs. This way we won't end up in
+         * "corrupting" already set and well-formed "ondisk" layout.
          */
-        heal_missing_dirs = local->selfheal.force_mkdir
-                ? local->selfheal.force_mkdir : dht_layout_missing_dirs (*heal);
-
-        if ((local->selfheal.hole_cnt == 0)
-            && (local->selfheal.overlaps_cnt == 0) && heal_missing_dirs) {
-                dht_layout_t *tmp = NULL;
-
-                /* Just added a brick and need to set 0-0 range on this brick.
-                 * But ondisk layout is well-formed. So, swap layouts "heal" and
-                 * "ondisk". Now "ondisk" layout will be used for healing
-                 * xattrs. If there are any non-participating subvols in
-                 * "ondisk" layout, dht_selfheal_dir_xattr_persubvol will set
-                 * 0-0 and non-layout xattrs. This way we won't end up in
-                 * "corrupting" already set and well-formed "ondisk" layout.
-                 */
-                tmp = *heal;
-                *heal = *ondisk;
-                *ondisk = tmp;
-
-                /* Current selfheal code, heals non-layout xattrs only after
-                 * an add-brick. In fact non-layout xattrs are considered as
-                 * secondary citizens which are healed only if layout xattrs
-                 * need to be healed. This is wrong, since for eg., quota can be
-                 * set when layout is well-formed, but a node is down. Also,
-                 * just for healing non-layout xattrs, we don't need locking.
-                 * This issue is _NOT FIXED_ by this patch.
-                 */
-        }
+        tmp = *heal;
+        *heal = *ondisk;
+        *ondisk = tmp;
+
+        /* Current selfheal code, heals non-layout xattrs only after
+         * an add-brick. In fact non-layout xattrs are considered as
+         * secondary citizens which are healed only if layout xattrs
+         * need to be healed. This is wrong, since for eg., quota can be
+         * set when layout is well-formed, but a node is down. Also,
+         * just for healing non-layout xattrs, we don't need locking.
+         * This issue is _NOT FIXED_ by this patch.
+         */
+    }
 
-        fixit = (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt
-                 || heal_missing_dirs);
+    fixit = (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt ||
+             heal_missing_dirs);
 
 out:
-        return fixit;
+    return fixit;
 }
 
 int
-dht_layout_span (dht_layout_t *layout)
+dht_layout_span(dht_layout_t *layout)
 {
-        int i = 0, count = 0;
+    int i = 0, count = 0;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err)
-                        continue;
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err)
+            continue;
 
-                if (layout->list[i].start != layout->list[i].stop)
-                        count++;
-        }
+        if (layout->list[i].start != layout->list[i].stop)
+            count++;
+    }
 
-        return count;
+    return count;
 }
 
 int
-dht_decommissioned_bricks_in_layout (xlator_t *this, dht_layout_t *layout)
+dht_decommissioned_bricks_in_layout(xlator_t *this, dht_layout_t *layout)
 {
-        dht_conf_t *conf  = NULL;
-        int         count = 0, i = 0, j = 0;
+    dht_conf_t *conf = NULL;
+    int count = 0, i = 0, j = 0;
 
-        if ((this == NULL) || (layout == NULL))
-                goto out;
+    if ((this == NULL) || (layout == NULL))
+        goto out;
 
-        conf = this->private;
+    conf = this->private;
 
-        for (i = 0; i < layout->cnt; i++) {
-                for (j = 0; j < conf->subvolume_cnt; j++) {
-                        if (conf->decommissioned_bricks[j] &&
-                            conf->decommissioned_bricks[j]
-                            == layout->list[i].xlator) {
-                                count++;
-                        }
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        for (j = 0; j < conf->subvolume_cnt; j++) {
+            if (conf->decommissioned_bricks[j] &&
+                conf->decommissioned_bricks[j] == layout->list[i].xlator) {
+                count++;
+            }
         }
+    }
 
 out:
-        return count;
+    return count;
 }
 
 dht_distribution_type_t
-dht_distribution_type (xlator_t *this, dht_layout_t *layout)
+dht_distribution_type(xlator_t *this, dht_layout_t *layout)
 {
-        dht_distribution_type_t type        = GF_DHT_EQUAL_DISTRIBUTION;
-        int                     i           = 0;
-        uint32_t                start_range = 0, range = 0, diff = 0;
+    dht_distribution_type_t type = GF_DHT_EQUAL_DISTRIBUTION;
+    int i = 0;
+    uint32_t start_range = 0, range = 0, diff = 0;
 
-        if ((this == NULL) || (layout == NULL) || (layout->cnt < 1)) {
-                goto out;
-        }
+    if ((this == NULL) || (layout == NULL) || (layout->cnt < 1)) {
+        goto out;
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (start_range == 0) {
-                        start_range = layout->list[i].stop
-                                - layout->list[i].start;
-                        continue;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (start_range == 0) {
+            start_range = layout->list[i].stop - layout->list[i].start;
+            continue;
+        }
 
-                range = layout->list[i].stop - layout->list[i].start;
-                diff = (range >= start_range)
-                        ? range - start_range
-                        : start_range - range;
+        range = layout->list[i].stop - layout->list[i].start;
+        diff = (range >= start_range) ? range - start_range
+                                      : start_range - range;
 
-                if ((range != 0) && (diff > layout->cnt)) {
-                        type = GF_DHT_WEIGHTED_DISTRIBUTION;
-                        break;
-                }
+        if ((range != 0) && (diff > layout->cnt)) {
+            type = GF_DHT_WEIGHTED_DISTRIBUTION;
+            break;
         }
+    }
 
 out:
-        return type;
+    return type;
 }
 
 gf_boolean_t
-dht_should_fix_layout (call_frame_t *frame, dht_layout_t **inmem,
-                       dht_layout_t **ondisk)
+dht_should_fix_layout(call_frame_t *frame, dht_layout_t **inmem,
+                      dht_layout_t **ondisk)
 {
-        gf_boolean_t             fixit                 = _gf_true;
+    gf_boolean_t fixit = _gf_true;
 
-        dht_local_t             *local                 = NULL;
-        int                      layout_span           = 0;
-        int                      decommissioned_bricks = 0;
-        int                      ret                   = 0;
-        dht_conf_t              *conf                  = NULL;
-        dht_distribution_type_t  inmem_dist_type       = 0;
-        dht_distribution_type_t  ondisk_dist_type      = 0;
+    dht_local_t *local = NULL;
+    int layout_span = 0;
+    int decommissioned_bricks = 0;
+    dht_conf_t *conf = NULL;
+    dht_distribution_type_t inmem_dist_type = 0;
+    dht_distribution_type_t ondisk_dist_type = 0;
 
-        conf = frame->this->private;
+    conf = frame->this->private;
 
-        local = frame->local;
+    local = frame->local;
 
-        if ((inmem == NULL) || (*inmem == NULL) || (ondisk == NULL)
-            || (*ondisk == NULL))
-                goto out;
+    if ((inmem == NULL) || (*inmem == NULL) || (ondisk == NULL) ||
+        (*ondisk == NULL))
+        goto out;
 
-        ret = dht_layout_anomalies (frame->this, &local->loc, *ondisk,
-                                    &local->selfheal.hole_cnt,
-                                    &local->selfheal.overlaps_cnt, NULL,
-                                    &local->selfheal.down,
-                                    &local->selfheal.misc, NULL);
-        if (ret < 0) {
-                fixit = _gf_false;
-                goto out;
-        }
+    dht_layout_anomalies(frame->this, &local->loc, *ondisk,
+                         &local->selfheal.hole_cnt,
+                         &local->selfheal.overlaps_cnt, NULL,
+                         &local->selfheal.down, &local->selfheal.misc, NULL);
 
-        if (local->selfheal.down || local->selfheal.misc) {
-                fixit = _gf_false;
-                goto out;
-        }
+    if (local->selfheal.down || local->selfheal.misc) {
+        fixit = _gf_false;
+        goto out;
+    }
 
-        if (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt)
-                goto out;
+    if (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt)
+        goto out;
 
-        /* If commit hashes are being updated, let it through */
-        if ((*inmem)->commit_hash != (*ondisk)->commit_hash)
-                goto out;
+    /* If commit hashes are being updated, let it through */
+    if ((*inmem)->commit_hash != (*ondisk)->commit_hash)
+        goto out;
 
-        layout_span = dht_layout_span (*ondisk);
+    layout_span = dht_layout_span(*ondisk);
 
-        decommissioned_bricks
-                = dht_decommissioned_bricks_in_layout (frame->this,
-                                                       *ondisk);
-        inmem_dist_type = dht_distribution_type (frame->this, *inmem);
-        ondisk_dist_type = dht_distribution_type (frame->this, *ondisk);
+    decommissioned_bricks = dht_decommissioned_bricks_in_layout(frame->this,
+                                                                *ondisk);
+    inmem_dist_type = dht_distribution_type(frame->this, *inmem);
+    ondisk_dist_type = dht_distribution_type(frame->this, *ondisk);
 
-        if ((decommissioned_bricks == 0)
-            && (layout_span == (conf->subvolume_cnt
-                                - conf->decommission_subvols_cnt))
-            && (inmem_dist_type == ondisk_dist_type))
-                fixit = _gf_false;
+    if ((decommissioned_bricks == 0) &&
+        (layout_span ==
+         (conf->subvolume_cnt - conf->decommission_subvols_cnt)) &&
+        (inmem_dist_type == ondisk_dist_type))
+        fixit = _gf_false;
 
 out:
 
-        return fixit;
+    return fixit;
 }
 
-int
-dht_selfheal_layout_lock (call_frame_t *frame, dht_layout_t *layout,
-                          gf_boolean_t newdir,
-                          dht_selfheal_layout_t healer,
-                          dht_need_heal_t should_heal)
-{
-        dht_local_t   *local    = NULL;
-        int            count    = 1, ret = -1, i = 0;
-        dht_lock_t   **lk_array = NULL;
-        dht_conf_t    *conf     = NULL;
-        dht_layout_t  *tmp      = NULL;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
-
-        local = frame->local;
-
-        conf = frame->this->private;
-
-        local->selfheal.healer = healer;
-        local->selfheal.should_heal = should_heal;
-
-        tmp = local->selfheal.layout;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
-        dht_layout_unref (frame->this, tmp);
-
-        if (!newdir) {
-                count = conf->subvolume_cnt;
-
-                lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                                      gf_common_mt_char);
-                if (lk_array == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path: %s", gfid,
-                                local->loc.path);
-                        goto err;
-                }
-
-                for (i = 0; i < count; i++) {
-                        lk_array[i] = dht_lock_new (frame->this,
-                                                    conf->subvolumes[i],
-                                                    &local->loc, F_WRLCK,
-                                                    DHT_LAYOUT_HEAL_DOMAIN,
-                                                    NULL);
-                        if (lk_array[i] == NULL) {
-                                gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY, "mem allocation "
-                                        "failed for lk_array, gfid:%s path:%s",
-                                        gfid, local->loc.path);
-                                goto err;
-                        }
-                }
-        } else {
-                count = 1;
-                lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                                      gf_common_mt_char);
-                if (lk_array == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path:%s",
-                                gfid, local->loc.path);
-                        goto err;
-                }
-
-                lk_array[0] = dht_lock_new (frame->this, local->hashed_subvol,
-                                            &local->loc, F_WRLCK,
-                                            DHT_LAYOUT_HEAL_DOMAIN, NULL);
-                if (lk_array[0] == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path:%s", gfid,
-                                local->loc.path);
-                        goto err;
-                }
-        }
-
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = count;
-
-        ret = dht_blocking_inodelk (frame, lk_array, count, FAIL_ON_ANY_ERROR,
-                                    dht_selfheal_layout_lock_cbk);
-        if (ret < 0) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-                goto err;
-        }
-
-        return 0;
-err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
-
-        return -1;
-}
-
-int
-dht_selfheal_dir_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int op_ret, int op_errno, dict_t *xdata)
-{
-        dht_local_t  *local                     = NULL;
-        xlator_t     *subvol                    = NULL;
-        struct iatt  *stbuf                     = NULL;
-        int           i                         = 0;
-        int           ret                       = 0;
-        dht_layout_t *layout                    = NULL;
-        int           err                       = 0;
-        int           this_call_cnt             = 0;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0};
-
-        local = frame->local;
-        layout = local->selfheal.layout;
-        subvol = cookie;
-
-        if (op_ret == 0) {
-                err = 0;
-        } else {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "layout setxattr failed on %s, path:%s gfid:%s",
-                        subvol->name, local->loc.path, gfid);
-                err = op_errno;
-        }
-
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
-        if (ret < 0) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg_debug (this->name, 0, "key = %s not present in dict"
-                              ", path:%s gfid:%s", DHT_IATT_IN_XDATA_KEY,
-                              local->loc.path, gfid);
-        }
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol) {
-                        layout->list[i].err = err;
-                        break;
-                }
-        }
-
-        LOCK (&frame->lock);
-        {
-                dht_iatt_merge (this, &local->stbuf, stbuf, subvol);
-        }
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-
-        if (is_last_call (this_call_cnt)) {
-                dht_selfheal_dir_finish (frame, this, 0, 1);
-        }
-
-        return 0;
-}
-
-
-int
-dht_selfheal_dir_xattr_persubvol (call_frame_t *frame, loc_t *loc,
-                                  dht_layout_t *layout, int i,
-                                  xlator_t *req_subvol)
+static int
+dht_selfheal_layout_lock(call_frame_t *frame, dht_layout_t *layout,
+                         gf_boolean_t newdir, dht_selfheal_layout_t healer,
+                         dht_need_heal_t should_heal)
 {
-        xlator_t          *subvol = NULL;
-        dict_t            *xattr = NULL;
-        dict_t            *xdata = NULL;
-        int                ret = 0;
-        xlator_t          *this = NULL;
-        int32_t           *disk_layout = NULL;
-        dht_local_t       *local = NULL;
-        dht_conf_t        *conf = NULL;
-        data_t            *data = NULL;
-        char              gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        if (req_subvol)
-                subvol = req_subvol;
-        else
-                subvol = layout->list[i].xlator;
-        this = frame->this;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0;
+    dht_lock_t **lk_array = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *tmp = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        GF_VALIDATE_OR_GOTO ("", this, err);
-        GF_VALIDATE_OR_GOTO (this->name, layout, err);
-        GF_VALIDATE_OR_GOTO (this->name, local, err);
-        GF_VALIDATE_OR_GOTO (this->name, subvol, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-        conf = this->private;
+    local = frame->local;
 
-        xattr = dict_new ();
-        if (!xattr) {
-                goto err;
-        }
-
-        xdata = dict_new ();
-        if (!xdata)
-                goto err;
+    conf = frame->this->private;
 
-        ret = dict_set_str (xdata, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        GLUSTERFS_INTERNAL_FOP_KEY, gfid);
-                goto err;
-        }
+    local->selfheal.healer = healer;
+    local->selfheal.should_heal = should_heal;
 
-        ret = dict_set_int8 (xdata, DHT_IATT_IN_XDATA_KEY, 1);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        DHT_IATT_IN_XDATA_KEY, gfid);
-                goto err;
-        }
+    tmp = local->selfheal.layout;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
+    dht_layout_unref(frame->this, tmp);
 
-        gf_uuid_unparse(loc->inode->gfid, gfid);
+    if (!newdir) {
+        count = conf->subvolume_cnt;
 
-        ret = dht_disk_layout_extract (this, layout, i, &disk_layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory self heal xattr failed:"
-                        " %s: (subvol %s) Failed to extract disk layout,"
-                        " gfid = %s", loc->path, subvol->name, gfid);
-                goto err;
+        lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+        if (lk_array == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_smsg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_MEM_ALLOC_FAILED,
+                    "lk_array-gfid=%s", gfid, "path=%s", local->loc.path, NULL);
+            goto err;
         }
 
-        ret = dict_set_bin (xattr, conf->xattr_name, disk_layout, 4 * 4);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory self heal xattr failed:"
-                        "%s: (subvol %s) Failed to set xattr dictionary,"
-                        " gfid = %s", loc->path, subvol->name, gfid);
+        for (i = 0; i < count; i++) {
+            lk_array[i] = dht_lock_new(
+                frame->this, conf->subvolumes[i], &local->loc, F_WRLCK,
+                DHT_LAYOUT_HEAL_DOMAIN, NULL, FAIL_ON_ANY_ERROR);
+            if (lk_array[i] == NULL) {
+                gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+                gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM,
+                        DHT_MSG_MEM_ALLOC_FAILED, "lk_array-gfid=%s", gfid,
+                        "path=%s", local->loc.path, NULL);
                 goto err;
-        }
-        disk_layout = NULL;
-
-        gf_msg_trace (this->name, 0,
-                      "setting hash range %u - %u (type %d) on subvolume %s"
-                      " for %s", layout->list[i].start, layout->list[i].stop,
-                      layout->type, subvol->name, loc->path);
-
-        if (local->xattr) {
-                data = dict_get (local->xattr, QUOTA_LIMIT_KEY);
-                if (data) {
-                        ret = dict_add (xattr, QUOTA_LIMIT_KEY, data);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "%s: Failed to set dictionary value:"
-                                        " key = %s",
-                                        loc->path, QUOTA_LIMIT_KEY);
-                        }
-                }
-                data = dict_get (local->xattr, QUOTA_LIMIT_OBJECTS_KEY);
-                if (data) {
-                        ret = dict_add (xattr, QUOTA_LIMIT_OBJECTS_KEY, data);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "%s: Failed to set dictionary value:"
-                                        " key = %s",
-                                        loc->path, QUOTA_LIMIT_OBJECTS_KEY);
-                        }
-                }
-        }
-
-        if (!gf_uuid_is_null (local->gfid))
-                gf_uuid_copy (loc->gfid, local->gfid);
-
-        STACK_WIND_COOKIE (frame, dht_selfheal_dir_xattr_cbk,
-                    (void *) subvol, subvol, subvol->fops->setxattr,
-                    loc, xattr, 0, xdata);
-
-        dict_unref (xattr);
-        dict_unref (xdata);
-
-        return 0;
-
+            }
+        }
+    } else {
+        count = 1;
+        lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+        if (lk_array == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MEM_ALLOC_FAILED,
+                    "lk_array-gfid=%s", gfid, "path=%s", local->loc.path, NULL);
+            goto err;
+        }
+
+        lk_array[0] = dht_lock_new(frame->this, local->hashed_subvol,
+                                   &local->loc, F_WRLCK, DHT_LAYOUT_HEAL_DOMAIN,
+                                   NULL, FAIL_ON_ANY_ERROR);
+        if (lk_array[0] == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MEM_ALLOC_FAILED,
+                    "lk_array-gfid=%s", gfid, "path=%s", local->loc.path, NULL);
+            goto err;
+        }
+    }
+
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = count;
+
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_selfheal_layout_lock_cbk);
+    if (ret < 0) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (xattr)
-                dict_unref (xattr);
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        if (xdata)
-                dict_unref (xdata);
-
-        GF_FREE (disk_layout);
-
-        dht_selfheal_dir_xattr_cbk (frame, (void *) subvol, frame->this,
-                                    -1, ENOMEM, NULL);
-        return 0;
+    return -1;
 }
 
-int
-dht_fix_dir_xattr (call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
+static int
+dht_selfheal_dir_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        int          i = 0;
-        int          count = 0;
-        xlator_t    *this = NULL;
-        dht_conf_t  *conf = NULL;
-        dht_layout_t *dummy = NULL;
-
-        local = frame->local;
-        this = frame->this;
-        conf = this->private;
-
-        gf_msg_debug (this->name, 0,
-                      "%s: Writing the new range for all subvolumes",
-                      loc->path);
-
-        local->call_cnt = count = conf->subvolume_cnt;
-
-        if (gf_log_get_loglevel () >= GF_LOG_DEBUG)
-                dht_log_new_layout_for_dir_selfheal (this, loc, layout);
-
-        for (i = 0; i < layout->cnt; i++) {
-                dht_selfheal_dir_xattr_persubvol (frame, loc, layout, i, NULL);
-
-                if (--count == 0)
-                        goto out;
-        }
-        /* if we are here, subvolcount > layout_count. subvols-per-directory
-         * option might be set here. We need to clear out layout from the
-         * non-participating subvolumes, else it will result in overlaps */
-        dummy = dht_layout_new (this, 1);
-        if (!dummy)
-                goto out;
-        dummy->commit_hash = layout->commit_hash;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        if (--count == 0)
-                                break;
-                }
-        }
-
-        dht_layout_unref (this, dummy);
-out:
-        return 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    struct iatt *stbuf = NULL;
+    int i = 0;
+    int ret = 0;
+    dht_layout_t *layout = NULL;
+    int err = 0;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    layout = local->selfheal.layout;
+    subvol = cookie;
+
+    if (op_ret == 0) {
+        err = 0;
+    } else {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED, "name=%s", subvol->name,
+                "path=%s", local->loc.path, "gfid=%s", gfid, NULL);
+        err = op_errno;
+    }
+
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+    if (ret < 0) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg_debug(this->name, 0,
+                     "key = %s not present in dict"
+                     ", path:%s gfid:%s",
+                     DHT_IATT_IN_XDATA_KEY, local->loc.path, gfid);
+    }
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol) {
+            layout->list[i].err = err;
+            break;
+        }
+    }
+
+    LOCK(&frame->lock);
+    {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+    }
+    UNLOCK(&frame->lock);
+
+    this_call_cnt = dht_frame_return(frame);
+
+    if (is_last_call(this_call_cnt)) {
+        dht_selfheal_dir_finish(frame, this, 0, 1);
+    }
+
+    return 0;
 }
 
+/* Code is required to set user xattr to local->xattr
+ */
 int
-dht_selfheal_dir_xattr (call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
+dht_set_user_xattr(dict_t *dict, char *k, data_t *v, void *data)
 {
-        dht_local_t *local = NULL;
-        int          missing_xattr = 0;
-        int          i = 0;
-        xlator_t    *this = NULL;
-        dht_conf_t   *conf = NULL;
-        dht_layout_t *dummy = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0,};
-
-        local = frame->local;
-        this = frame->this;
-        conf = this->private;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop) {
-                        /* err != -1 would mean xattr present on the directory
-                         * or the directory is non existent.
-                         * !layout->list[i].stop would mean layout absent
-                         */
+    dict_t *set_xattr = data;
+    int ret = -1;
 
-                        continue;
-                }
-                missing_xattr++;
-        }
-        /* Also account for subvolumes with no-layout. Used for zero'ing out
-         * the layouts and for setting quota key's if present */
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        missing_xattr++;
-                }
-        }
-        gf_msg_trace (this->name, 0,
-                      "%d subvolumes missing xattr for %s",
-                      missing_xattr, loc->path);
-
-        if (missing_xattr == 0) {
-                dht_selfheal_dir_finish (frame, this, 0, 1);
-                return 0;
-        }
-
-        local->call_cnt = missing_xattr;
-
-        if (gf_log_get_loglevel () >= GF_LOG_DEBUG)
-                dht_log_new_layout_for_dir_selfheal (this, loc, layout);
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop)
-                        continue;
-
-                dht_selfheal_dir_xattr_persubvol (frame, loc, layout, i, NULL);
-
-                if (--missing_xattr == 0)
-                        break;
-        }
-        dummy = dht_layout_new (this, 1);
-        if (!dummy) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "failed to allocate dummy layout, path:%s gfid:%s",
-                        loc->path, gfid);
-                goto out;
-        }
-        for (i = 0; i < conf->subvolume_cnt && missing_xattr; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        missing_xattr--;
-                }
-        }
-
-        dht_layout_unref (this, dummy);
-out:
-        return 0;
+    ret = dict_set(set_xattr, k, v);
+    return ret;
 }
 
-gf_boolean_t
-dht_is_subvol_part_of_layout (dht_layout_t *layout, xlator_t *xlator)
+static int
+dht_selfheal_dir_xattr_persubvol(call_frame_t *frame, loc_t *loc,
+                                 dht_layout_t *layout, int i,
+                                 xlator_t *req_subvol)
 {
-        int               i = 0;
-        gf_boolean_t    ret = _gf_false;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+    int ret = 0;
+    xlator_t *this = NULL;
+    int32_t *disk_layout = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    data_t *data = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    if (req_subvol)
+        subvol = req_subvol;
+    else
+        subvol = layout->list[i].xlator;
+    this = frame->this;
+
+    GF_VALIDATE_OR_GOTO("", this, err);
+    GF_VALIDATE_OR_GOTO(this->name, layout, err);
+    GF_VALIDATE_OR_GOTO(this->name, local, err);
+    GF_VALIDATE_OR_GOTO(this->name, subvol, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    xattr = dict_new();
+    if (!xattr) {
+        goto err;
+    }
+
+    xdata = dict_new();
+    if (!xdata)
+        goto err;
+
+    ret = dict_set_str(xdata, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                "path=%s", loc->path, "key=%s", GLUSTERFS_INTERNAL_FOP_KEY,
+                "gfid=%s", gfid, NULL);
+        goto err;
+    }
+
+    ret = dict_set_int8(xdata, DHT_IATT_IN_XDATA_KEY, 1);
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                "path=%s", loc->path, "key=%s", DHT_IATT_IN_XDATA_KEY,
+                "gfid=%s", gfid, NULL);
+        goto err;
+    }
+
+    gf_uuid_unparse(loc->inode->gfid, gfid);
+
+    ret = dht_disk_layout_extract(this, layout, i, &disk_layout);
+    if (ret == -1) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+                "extract-disk-layout-failed, path=%s", loc->path, "subvol=%s",
+                subvol->name, "gfid=%s", gfid, NULL);
+        goto err;
+    }
+
+    ret = dict_set_bin(xattr, conf->xattr_name, disk_layout, 4 * 4);
+    if (ret == -1) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0,
+                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED, "path=%s", loc->path,
+                "subvol=%s", subvol->name,
+                "set-xattr-dictionary-failed"
+                "gfid=%s",
+                gfid, NULL);
+        goto err;
+    }
+    disk_layout = NULL;
+
+    gf_msg_trace(this->name, 0,
+                 "setting hash range 0x%x - 0x%x (type %d) on subvolume %s"
+                 " for %s",
+                 layout->list[i].start, layout->list[i].stop, layout->type,
+                 subvol->name, loc->path);
+
+    if (local->xattr) {
+        data = dict_get(local->xattr, QUOTA_LIMIT_KEY);
+        if (data) {
+            ret = dict_add(xattr, QUOTA_LIMIT_KEY, data);
+            if (ret) {
+                gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                        "path=%s", loc->path, "key=%s", QUOTA_LIMIT_KEY, NULL);
+            }
+        }
+        data = dict_get(local->xattr, QUOTA_LIMIT_OBJECTS_KEY);
+        if (data) {
+            ret = dict_add(xattr, QUOTA_LIMIT_OBJECTS_KEY, data);
+            if (ret) {
+                gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                        "path=%s", loc->path, "key=%s", QUOTA_LIMIT_OBJECTS_KEY,
+                        NULL);
+            }
+        }
+    }
+
+    if (!gf_uuid_is_null(local->gfid))
+        gf_uuid_copy(loc->gfid, local->gfid);
+
+    STACK_WIND_COOKIE(frame, dht_selfheal_dir_xattr_cbk, (void *)subvol, subvol,
+                      subvol->fops->setxattr, loc, xattr, 0, xdata);
+
+    dict_unref(xattr);
+    dict_unref(xdata);
+
+    return 0;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (!strcmp (layout->list[i].xlator->name, xlator->name)) {
-                        ret = _gf_true;
-                        break;
+err:
+    if (xattr)
+        dict_unref(xattr);
+    if (xdata)
+        dict_unref(xdata);
 
-                }
-        }
+    GF_FREE(disk_layout);
 
-        return ret;
+    dht_selfheal_dir_xattr_cbk(frame, (void *)subvol, frame->this, -1, ENOMEM,
+                               NULL);
+    return 0;
 }
 
-int
-dht_layout_index_from_conf (dht_layout_t *layout, xlator_t *xlator)
+static int
+dht_fix_dir_xattr(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        int i = -1;
-        int j = 0;
-
-        for (j = 0; j < layout->cnt; j++) {
-                if (!strcmp (layout->list[j].xlator->name, xlator->name)) {
-                        i = j;
-                        break;
-                }
-        }
-
-        return i;
+    dht_local_t *local = NULL;
+    int i = 0;
+    int count = 0;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *dummy = NULL;
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    gf_msg_debug(this->name, 0, "%s: Writing the new range for all subvolumes",
+                 loc->path);
+
+    local->call_cnt = count = conf->subvolume_cnt;
+
+    if (gf_log_get_loglevel() >= GF_LOG_DEBUG)
+        dht_log_new_layout_for_dir_selfheal(this, loc, layout);
+
+    for (i = 0; i < layout->cnt; i++) {
+        dht_selfheal_dir_xattr_persubvol(frame, loc, layout, i, NULL);
+
+        if (--count == 0)
+            goto out;
+    }
+    /* if we are here, subvolcount > layout_count. subvols-per-directory
+     * option might be set here. We need to clear out layout from the
+     * non-participating subvolumes, else it will result in overlaps */
+    dummy = dht_layout_new(this, 1);
+    if (!dummy)
+        goto out;
+    dummy->commit_hash = layout->commit_hash;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            dht_selfheal_dir_xattr_persubvol(frame, loc, dummy, 0,
+                                             conf->subvolumes[i]);
+            if (--count == 0)
+                break;
+        }
+    }
+
+    dht_layout_unref(this, dummy);
+out:
+    return 0;
 }
 
-
 static int
-dht_selfheal_dir_xattr_for_nameless_lookup (call_frame_t *frame, loc_t *loc,
-                                            dht_layout_t  *layout)
+dht_selfheal_dir_xattr(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t     *local = NULL;
-        int             missing_xattr = 0;
-        int             i = 0;
-        xlator_t        *this = NULL;
-        dht_conf_t      *conf = NULL;
-        dht_layout_t    *dummy = NULL;
-        int             j = 0;
-
-        local = frame->local;
-        this = frame->this;
-        conf = this->private;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop) {
-                        /* err != -1 would mean xattr present on the directory
-                           or the directory is non existent.
-                           !layout->list[i].stop would mean layout absent
-                        */
-
-                        continue;
-                }
-                missing_xattr++;
-        }
-
-        /* Also account for subvolumes with no-layout. Used for zero'ing out
-           the layouts and for setting quota key's if present */
-
-        /* Send  where either the subvol is not part of layout,
-         * or it is part of the layout but error is non-zero but error
-         * is not equal to -1 or ENOENT.
-         */
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (dht_is_subvol_part_of_layout (layout, conf->subvolumes[i])
-                    == _gf_false) {
-                        missing_xattr++;
-                        continue;
-                }
-
-                j = dht_layout_index_from_conf (layout, conf->subvolumes[i]);
-
-                if ((j != -1) && (layout->list[j].err != -1) &&
-                   (layout->list[j].err != 0) &&
-                   (layout->list[j].err != ENOENT)) {
-                        missing_xattr++;
-                }
-
-        }
-
-
-        gf_msg_trace (this->name, 0,
-                      "%d subvolumes missing xattr for %s",
-                      missing_xattr, loc->path);
-
-        if (missing_xattr == 0) {
-                dht_selfheal_dir_finish (frame, this, 0, 1);
-                return 0;
-        }
-
-        local->call_cnt = missing_xattr;
-
-        if (gf_log_get_loglevel () >= GF_LOG_DEBUG)
-                dht_log_new_layout_for_dir_selfheal (this, loc, layout);
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop)
-                        continue;
-
-                dht_selfheal_dir_xattr_persubvol (frame, loc, layout, i, NULL);
-
-                if (--missing_xattr == 0)
-                        break;
-        }
-
-        dummy = dht_layout_new (this, 1);
-        if (!dummy)
-                goto out;
-
-        for (i = 0; i < conf->subvolume_cnt && missing_xattr; i++) {
-              if (dht_is_subvol_part_of_layout (layout, conf->subvolumes[i])
-                  == _gf_false) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        missing_xattr--;
-                        continue;
-              }
-
-                j = dht_layout_index_from_conf (layout, conf->subvolumes[i]);
-
-                if ((j != -1) && (layout->list[j].err != -1) &&
-                    (layout->list[j].err != ENOENT) &&
-                    (layout->list[j].err != 0)) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        missing_xattr--;
-                }
-        }
-
-        dht_layout_unref (this, dummy);
-out:
+    dht_local_t *local = NULL;
+    int missing_xattr = 0;
+    int i = 0;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *dummy = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err != -1 || !layout->list[i].stop) {
+            /* err != -1 would mean xattr present on the directory
+             * or the directory is non existent.
+             * !layout->list[i].stop would mean layout absent
+             */
+
+            continue;
+        }
+        missing_xattr++;
+    }
+    /* Also account for subvolumes with no-layout. Used for zero'ing out
+     * the layouts and for setting quota key's if present */
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            missing_xattr++;
+        }
+    }
+    gf_msg_trace(this->name, 0, "%d subvolumes missing xattr for %s",
+                 missing_xattr, loc->path);
+
+    if (missing_xattr == 0) {
+        dht_selfheal_dir_finish(frame, this, 0, 1);
         return 0;
-
+    }
+
+    local->call_cnt = missing_xattr;
+
+    if (gf_log_get_loglevel() >= GF_LOG_DEBUG)
+        dht_log_new_layout_for_dir_selfheal(this, loc, layout);
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err != -1 || !layout->list[i].stop)
+            continue;
+
+        dht_selfheal_dir_xattr_persubvol(frame, loc, layout, i, NULL);
+
+        if (--missing_xattr == 0)
+            break;
+    }
+    dummy = dht_layout_new(this, 1);
+    if (!dummy) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_DUMMY_ALLOC_FAILED,
+                "path=%s", loc->path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+    for (i = 0; i < conf->subvolume_cnt && missing_xattr; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            dht_selfheal_dir_xattr_persubvol(frame, loc, dummy, 0,
+                                             conf->subvolumes[i]);
+            missing_xattr--;
+        }
+    }
+
+    dht_layout_unref(this, dummy);
+out:
+    return 0;
 }
 
 int
-dht_selfheal_dir_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int op_ret, int op_errno, struct iatt *statpre,
-                              struct iatt *statpost, dict_t *xdata)
+dht_selfheal_dir_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, struct iatt *statpre,
+                             struct iatt *statpost, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
-        int            this_call_cnt = 0, ret = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int this_call_cnt = 0, ret = -1;
 
-        local  = frame->local;
-        layout = local->selfheal.layout;
+    local = frame->local;
+    layout = local->selfheal.layout;
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                ret = dht_selfheal_layout_lock (frame, layout, _gf_false,
-                                                dht_selfheal_dir_xattr,
-                                                dht_should_heal_layout);
+    if (is_last_call(this_call_cnt)) {
+        if (!local->heal_layout) {
+            gf_msg_trace(this->name, 0, "Skip heal layout for %s gfid = %s ",
+                         local->loc.path, uuid_utoa(local->gfid));
 
-                if (ret < 0) {
-                        dht_selfheal_dir_finish (frame, this, -1, 1);
-                }
+            dht_selfheal_dir_finish(frame, this, 0, 1);
+            return 0;
         }
+        ret = dht_selfheal_layout_lock(frame, layout, _gf_false,
+                                       dht_selfheal_dir_xattr,
+                                       dht_should_heal_layout);
 
-        return 0;
-}
+        if (ret < 0) {
+            dht_selfheal_dir_finish(frame, this, -1, 1);
+        }
+    }
 
+    return 0;
+}
 
 int
-dht_selfheal_dir_setattr (call_frame_t *frame, loc_t *loc, struct iatt *stbuf,
-                          int32_t valid, dht_layout_t *layout)
+dht_selfheal_dir_setattr(call_frame_t *frame, loc_t *loc, struct iatt *stbuf,
+                         int32_t valid, dht_layout_t *layout)
 {
-        int           missing_attr = 0;
-        int           i     = 0, ret = -1;
-        dht_local_t  *local = NULL;
-        xlator_t     *this = NULL;
-        int           cnt  = 0;
+    int missing_attr = 0;
+    int i = 0, ret = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *this = NULL;
+    int cnt = 0;
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    /* We need to heal the attrs if:
+     * 1. Any directories were missing - the newly created dirs will need
+     *    to have the correct attrs set
+     * 2. An existing dir does not have the correct permissions -they may
+     *    have been changed when a brick was down.
+     */
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err == -1)
+            missing_attr++;
+    }
+
+    if ((missing_attr == 0) && (local->need_attrheal == 0)) {
+        if (!local->heal_layout) {
+            gf_msg_trace(this->name, 0, "Skip heal layout for %s gfid = %s ",
+                         loc->path, uuid_utoa(loc->gfid));
+            dht_selfheal_dir_finish(frame, this, 0, 1);
+            return 0;
+        }
+        ret = dht_selfheal_layout_lock(frame, layout, _gf_false,
+                                       dht_selfheal_dir_xattr,
+                                       dht_should_heal_layout);
 
-        local = frame->local;
-        this = frame->this;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err == -1)
-                        missing_attr++;
+        if (ret < 0) {
+            dht_selfheal_dir_finish(frame, this, -1, 1);
         }
 
-        if (missing_attr == 0) {
-                ret = dht_selfheal_layout_lock (frame, layout, _gf_false,
-                                                dht_selfheal_dir_xattr,
-                                                dht_should_heal_layout);
+        return 0;
+    }
 
-                if (ret < 0) {
-                        dht_selfheal_dir_finish (frame, this, -1, 1);
-                }
+    cnt = local->call_cnt = conf->subvolume_cnt;
 
-                return 0;
-        }
+    for (i = 0; i < cnt; i++) {
+        STACK_WIND(frame, dht_selfheal_dir_setattr_cbk, layout->list[i].xlator,
+                   layout->list[i].xlator->fops->setattr, loc, stbuf, valid,
+                   NULL);
+    }
 
-        if (!gf_uuid_is_null (local->gfid))
-                gf_uuid_copy (loc->gfid, local->gfid);
-
-        local->call_cnt = missing_attr;
-        cnt = layout->cnt;
-        for (i = 0; i < cnt; i++) {
-                if (layout->list[i].err == -1) {
-                        gf_msg_trace (this->name, 0,
-                                      "%s: setattr on subvol %s, gfid = %s",
-                                      loc->path, layout->list[i].xlator->name,
-                                      uuid_utoa(loc->gfid));
-
-                        STACK_WIND (frame, dht_selfheal_dir_setattr_cbk,
-                                    layout->list[i].xlator,
-                                    layout->list[i].xlator->fops->setattr,
-                                    loc, stbuf, valid, NULL);
-                }
-        }
-
-        return 0;
+    return 0;
 }
 
-int
-dht_selfheal_dir_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int op_ret, int op_errno,
-                            inode_t *inode, struct iatt *stbuf,
-                            struct iatt *preparent, struct iatt *postparent,
-                            dict_t *xdata)
+static int
+dht_selfheal_dir_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, inode_t *inode,
+                           struct iatt *stbuf, struct iatt *preparent,
+                           struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
-        xlator_t      *prev = NULL;
-        xlator_t      *subvol = NULL;
-        int            i = 0, ret = -1;
-        int            this_call_cnt = 0;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local  = frame->local;
-        layout = local->selfheal.layout;
-        prev   = cookie;
-        subvol = prev;
-
-        if ((op_ret == 0) || ((op_ret == -1) && (op_errno == EEXIST))) {
-                for (i = 0; i < layout->cnt; i++) {
-                        if (layout->list[i].xlator == subvol) {
-                                layout->list[i].err = -1;
-                                break;
-                        }
-                }
-        }
-
-        if (op_ret) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
-                gf_msg (this->name, ((op_errno == EEXIST) ? GF_LOG_DEBUG :
-                                     GF_LOG_WARNING),
-                        op_errno, DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed: path = %s, gfid = %s",
-                        local->loc.path, gfid );
-                goto out;
-        }
-        dht_iatt_merge (this, &local->preparent, preparent, prev);
-        dht_iatt_merge (this, &local->postparent, postparent, prev);
-        ret = 0;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *subvol = NULL;
+    int i = 0, ret = -1;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    layout = local->selfheal.layout;
+    prev = cookie;
+    subvol = prev;
+
+    if ((op_ret == 0) || ((op_ret == -1) && (op_errno == EEXIST))) {
+        for (i = 0; i < layout->cnt; i++) {
+            if (layout->list[i].xlator == subvol) {
+                layout->list[i].err = -1;
+                break;
+            }
+        }
+    }
+
+    if (op_ret) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_smsg(this->name,
+                ((op_errno == EEXIST) ? GF_LOG_DEBUG : GF_LOG_WARNING),
+                op_errno, DHT_MSG_DIR_SELFHEAL_FAILED, "path=%s",
+                local->loc.path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+    dht_iatt_merge(this, &local->preparent, preparent);
+    dht_iatt_merge(this, &local->postparent, postparent);
+    ret = 0;
 
 out:
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_selfheal_dir_finish (frame, this, ret, 0);
-                dht_selfheal_dir_setattr (frame, &local->loc, &local->stbuf, 0xffffff, layout);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_selfheal_dir_finish(frame, this, ret, 0);
+        dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf, 0xffffff,
+                                 layout);
+    }
 
-        return 0;
+    return 0;
 }
 
-void
-dht_selfheal_dir_mkdir_setacl (dict_t *xattr, dict_t *dict)
+static int
+dht_selfheal_dir_mkdir_lookup_done(call_frame_t *frame, xlator_t *this)
 {
-        data_t          *acl_default = NULL;
-        data_t          *acl_access = NULL;
-        xlator_t        *this = NULL;
-        int     ret = -1;
-
-        GF_ASSERT (xattr);
-        GF_ASSERT (dict);
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        acl_default = dict_get (xattr, POSIX_ACL_DEFAULT_XATTR);
+    dht_local_t *local = NULL;
+    int i = 0;
+    dict_t *dict = NULL;
+    dht_layout_t *layout = NULL;
+    loc_t *loc = NULL;
+    int cnt = 0;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(this->private, err);
+
+    local = frame->local;
+    layout = local->layout;
+    loc = &local->loc;
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        dict = dict_new();
+        if (!dict)
+            return -1;
 
-        if (!acl_default) {
-                gf_msg_debug (this->name, 0,
-                              "ACL_DEFAULT xattr not present");
-                goto cont;
-        }
-        ret = dict_set (dict, POSIX_ACL_DEFAULT_XATTR, acl_default);
+        ret = dict_set_gfuuid(dict, "gfid-req", local->gfid, true);
         if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        POSIX_ACL_DEFAULT_XATTR);
-cont:
-        acl_access = dict_get (xattr, POSIX_ACL_ACCESS_XATTR);
-        if (!acl_access) {
-                gf_msg_debug (this->name, 0,
-                              "ACL_ACCESS xattr not present");
-                goto out;
-        }
-        ret = dict_set (dict, POSIX_ACL_ACCESS_XATTR, acl_access);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        POSIX_ACL_ACCESS_XATTR);
-
-out:
-        return;
-}
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                    "path=%s", loc->path, "key=gfid-req", NULL);
+    } else if (local->params) {
+        /* Send the dictionary from higher layers directly */
+
+        dict = dict_ref(local->params);
+    }
+    /* Code to update all extended attributed from local->xattr
+       to dict
+    */
+    dht_dir_set_heal_xattr(this, local, dict, local->xattr, NULL, NULL);
+
+    if (!dict) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_IS_NULL, NULL);
+        dict = dict_new();
+        if (!dict)
+            return -1;
+    }
+    ret = dict_set_flag(dict, GF_INTERNAL_CTX_KEY, GF_DHT_HEAL_DIR);
+    if (ret) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED, "key=%s",
+                GF_INTERNAL_CTX_KEY, "path=%s", loc->path, NULL);
+        /* We can still continue. As heal can still happen
+         * unless quota limits have reached for the dir.
+         */
+    }
 
-int
-dht_selfheal_dir_mkdir_lookup_done (call_frame_t *frame, xlator_t *this)
-{
-        dht_local_t  *local = NULL;
-        int           i     = 0;
-        int           ret   = -1;
-        dict_t       *dict = NULL;
-        dht_layout_t  *layout = NULL;
-        loc_t        *loc   = NULL;
-        int           cnt   = 0;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = frame->local;
-        layout = local->layout;
-        loc    = &local->loc;
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                dict = dict_new ();
-                if (!dict)
-                        return -1;
-
-                ret = dict_set_static_bin (dict, "gfid-req", local->gfid, 16);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:"
-                                " key = gfid-req", loc->path);
-        } else if (local->params) {
-                /* Send the dictionary from higher layers directly */
-
-                dict = dict_ref (local->params);
-        }
-        /* Set acls */
-        if (local->xattr && dict)
-                dht_selfheal_dir_mkdir_setacl (local->xattr, dict);
+    cnt = layout->cnt;
+    for (i = 0; i < cnt; i++) {
+        if (layout->list[i].err == ESTALE || layout->list[i].err == ENOENT ||
+            local->selfheal.force_mkdir) {
+            gf_msg_debug(this->name, 0, "Creating directory %s on subvol %s",
+                         loc->path, layout->list[i].xlator->name);
 
-        if (!dict)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "dict is NULL, need to make sure gfids are same");
-
-        cnt = layout->cnt;
-        for (i = 0; i < cnt; i++) {
-                if (layout->list[i].err == ESTALE ||
-                    layout->list[i].err == ENOENT ||
-                    local->selfheal.force_mkdir) {
-                        gf_msg_debug (this->name, 0,
-                                      "Creating directory %s on subvol %s",
-                                      loc->path, layout->list[i].xlator->name);
-
-                        STACK_WIND_COOKIE (frame, dht_selfheal_dir_mkdir_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->mkdir,
-                                           loc,
-                                           st_mode_from_ia (local->stbuf.ia_prot,
-                                                            local->stbuf.ia_type),
-                                           0, dict);
-                }
+            STACK_WIND_COOKIE(
+                frame, dht_selfheal_dir_mkdir_cbk, layout->list[i].xlator,
+                layout->list[i].xlator, layout->list[i].xlator->fops->mkdir,
+                loc,
+                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
+                dict);
         }
+    }
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-int
-dht_selfheal_dir_mkdir_lookup_cbk (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int op_ret, int op_errno,
-                                   inode_t *inode, struct iatt *stbuf,
-                                   dict_t *xattr, struct iatt *postparent)
+static int
+dht_selfheal_dir_mkdir_lookup_cbk(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int op_ret, int op_errno,
+                                  inode_t *inode, struct iatt *stbuf,
+                                  dict_t *xattr, struct iatt *postparent)
 {
-        dht_local_t  *local = NULL;
-        int           i     = 0;
-        int           this_call_cnt = 0;
-        int           missing_dirs = 0;
-        dht_layout_t  *layout = NULL;
-        loc_t         *loc    = NULL;
-        xlator_t      *prev    = NULL;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = frame->local;
-        layout = local->layout;
-        loc = &local->loc;
-        prev  = cookie;
-
-        this_call_cnt = dht_frame_return (frame);
-
-        LOCK (&frame->lock);
-        {
-                if ((op_ret < 0) &&
-                    (op_errno == ENOENT || op_errno == ESTALE)) {
-                        local->selfheal.hole_cnt = !local->selfheal.hole_cnt ? 1
-                                                : local->selfheal.hole_cnt + 1;
-                }
-
-                if (!op_ret) {
-                        dht_iatt_merge (this, &local->stbuf, stbuf, prev);
-                }
+    dht_local_t *local = NULL;
+    int i = 0;
+    int this_call_cnt = 0;
+    int missing_dirs = 0;
+    dht_layout_t *layout = NULL;
+    xlator_t *prev = 0;
+    loc_t *loc = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    int index = -1;
+
+    VALIDATE_OR_GOTO(this->private, err);
+
+    local = frame->local;
+    layout = local->layout;
+    loc = &local->loc;
+    prev = cookie;
+
+    if (!gf_uuid_is_null(local->gfid))
+        gf_uuid_unparse(local->gfid, gfid_local);
+
+    LOCK(&frame->lock);
+    {
+        index = dht_layout_index_for_subvol(layout, prev);
+        if ((op_ret < 0) && (op_errno == ENOENT || op_errno == ESTALE)) {
+            local->selfheal.hole_cnt = !local->selfheal.hole_cnt
+                                           ? 1
+                                           : local->selfheal.hole_cnt + 1;
+            /* the status might have changed. Update the layout with the
+             * new status
+             */
+            if (index >= 0) {
+                layout->list[index].err = op_errno;
+            }
+        }
+
+        if (!op_ret) {
+            dht_iatt_merge(this, &local->stbuf, stbuf);
+            if (prev == local->mds_subvol) {
+                dict_unref(local->xattr);
+                local->xattr = dict_ref(xattr);
+            }
+            /* the status might have changed. Update the layout with the
+             * new status
+             */
+            if (index >= 0) {
+                layout->list[index].err = -1;
+            }
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    this_call_cnt = dht_frame_return(frame);
+
+    if (is_last_call(this_call_cnt)) {
+        if (local->selfheal.hole_cnt == layout->cnt) {
+            gf_msg_debug(this->name, op_errno,
+                         "Lookup failed, an rmdir could have "
+                         "deleted this entry %s",
+                         loc->name);
+            local->op_errno = op_errno;
+            goto err;
+        } else {
+            for (i = 0; i < layout->cnt; i++) {
+                if (layout->list[i].err == ENOENT ||
+                    layout->list[i].err == ESTALE ||
+                    local->selfheal.force_mkdir)
+                    missing_dirs++;
+            }
+
+            if (missing_dirs == 0) {
+                dht_selfheal_dir_finish(frame, this, 0, 0);
+                dht_selfheal_dir_setattr(frame, loc, &local->stbuf, 0xffffffff,
+                                         layout);
+                return 0;
+            }
 
+            local->call_cnt = missing_dirs;
+            dht_selfheal_dir_mkdir_lookup_done(frame, this);
         }
-        UNLOCK (&frame->lock);
-
-        if (is_last_call (this_call_cnt)) {
-                if (local->selfheal.hole_cnt == layout->cnt) {
-                        gf_msg_debug (this->name, op_errno,
-                                      "Lookup failed, an rmdir could have "
-                                      "deleted this entry %s", loc->name);
-                        local->op_errno = op_errno;
-                        goto err;
-                } else {
-                        for (i = 0; i < layout->cnt; i++) {
-                                if (layout->list[i].err == ENOENT ||
-                                    layout->list[i].err == ESTALE ||
-                                    local->selfheal.force_mkdir)
-                                        missing_dirs++;
-                        }
-
-                        if (missing_dirs == 0) {
-                                dht_selfheal_dir_finish (frame, this, 0, 0);
-                                dht_selfheal_dir_setattr (frame, loc,
-                                                          &local->stbuf,
-                                                          0xffffffff, layout);
-                                return 0;
-                        }
-
-                        local->call_cnt = missing_dirs;
-                        dht_selfheal_dir_mkdir_lookup_done (frame, this);
-                }
-        }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-
-int
-dht_selfheal_dir_mkdir_lock_cbk (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *xdata)
+static int
+dht_selfheal_dir_mkdir_lock_cbk(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        int           i     = 0;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-        local = frame->local;
-
-	    local->call_cnt = conf->subvolume_cnt;
-
-        if (op_ret < 0) {
-
-                /* We get this error when the directory entry was not created
-                 * on a newky attatched tier subvol. Hence proceed and do mkdir
-                 * on the tier subvol.
-                 */
-                if (op_errno == EINVAL) {
-                        local->call_cnt = 1;
-                        dht_selfheal_dir_mkdir_lookup_done (frame, this);
-                        return 0;
-                }
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_ENTRYLK_ERROR,
-                        "acquiring entrylk after inodelk failed for %s",
-                        local->loc.path);
-
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        /* After getting locks, perform lookup again to ensure that the
-           directory was not deleted by a racing rmdir
-        */
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_selfheal_dir_mkdir_lookup_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, NULL);
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    int ret = -1;
+    xlator_t *mds_subvol = NULL;
+
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+    local = frame->local;
+    mds_subvol = local->mds_subvol;
+
+    local->call_cnt = conf->subvolume_cnt;
+
+    if (op_ret < 0) {
+        if (op_errno == EINVAL) {
+            local->call_cnt = 1;
+            dht_selfheal_dir_mkdir_lookup_done(frame, this);
+            return 0;
+        }
+
+        gf_smsg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_ENTRYLK_ERROR,
+                "path=%s", local->loc.path, NULL);
+
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    /* After getting locks, perform lookup again to ensure that the
+       directory was not deleted by a racing rmdir
+    */
+    if (!local->xattr_req)
+        local->xattr_req = dict_new();
+
+    ret = dict_set_int32(local->xattr_req, "list-xattr", 1);
+    if (ret)
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED, "path=%s",
+                local->loc.path, NULL);
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol && conf->subvolumes[i] == mds_subvol) {
+            STACK_WIND_COOKIE(frame, dht_selfheal_dir_mkdir_lookup_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
+        } else {
+            STACK_WIND_COOKIE(frame, dht_selfheal_dir_mkdir_lookup_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              NULL);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-int
-dht_selfheal_dir_mkdir (call_frame_t *frame, loc_t *loc,
-                        dht_layout_t *layout, int force)
+static int
+dht_selfheal_dir_mkdir(call_frame_t *frame, loc_t *loc, dht_layout_t *layout,
+                       int force)
 {
-        int           missing_dirs = 0;
-        int           i     = 0;
-        int           ret   = -1;
-        dht_local_t  *local = NULL;
-        xlator_t     *this  = NULL;
-
-        local = frame->local;
-        this = frame->this;
-
-        local->selfheal.force_mkdir = force;
-        local->selfheal.hole_cnt = 0;
+    int missing_dirs = 0;
+    int i = 0;
+    int op_errno = 0;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    local->selfheal.force_mkdir = force;
+    local->selfheal.hole_cnt = 0;
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err == ENOENT || force)
+            missing_dirs++;
+    }
+
+    if (missing_dirs == 0) {
+        /* We don't need to create any directories. Proceed to heal the
+         * attrs and xattrs
+         */
+        if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+            if (local->need_xattr_heal) {
+                local->need_xattr_heal = 0;
+                ret = dht_dir_xattr_heal(this, local, &op_errno);
+                if (ret) {
+                    gf_smsg(this->name, GF_LOG_ERROR, op_errno,
+                            DHT_MSG_DIR_XATTR_HEAL_FAILED, "path=%s",
+                            local->loc.path, "gfid=%s", local->gfid, NULL);
+                }
+            } else {
+                if (!gf_uuid_is_null(local->gfid))
+                    gf_uuid_copy(loc->gfid, local->gfid);
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err == ENOENT || force)
-                        missing_dirs++;
-        }
+                ret = dht_common_mark_mdsxattr(frame, NULL, 0);
+                if (!ret)
+                    return 0;
 
-        if (missing_dirs == 0) {
-                dht_selfheal_dir_setattr (frame, loc, &local->stbuf,
-                                          0xffffffff, layout);
-                return 0;
+                gf_smsg(this->name, GF_LOG_INFO, 0, DHT_MSG_SET_XATTR_FAILED,
+                        "path=%s", local->loc.path, "gfid=%s", local->gfid,
+                        NULL);
+            }
         }
-
-        if (local->hashed_subvol == NULL)
-                local->hashed_subvol = dht_subvol_get_hashed (this, loc);
-
+        dht_selfheal_dir_setattr(frame, loc, &local->stbuf, 0xffffffff, layout);
+        return 0;
+    }
+
+    /* MDS xattr is populated only while DHT is having more than one
+     subvol.In case of graph switch while adding more dht subvols need to
+     consider hash subvol as a MDS to avoid MDS check failure at the time
+     of running fop on directory
+    */
+    if (!dict_get(local->xattr, conf->mds_xattr_key) &&
+        (conf->subvolume_cnt > 1)) {
         if (local->hashed_subvol == NULL) {
+            local->hashed_subvol = dht_subvol_get_hashed(this, loc);
+            if (local->hashed_subvol == NULL) {
                 local->op_errno = EINVAL;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "(%s/%s) (path: %s): "
-                        "hashed subvolume not found", loc->pargfid, loc->name,
-                        loc->path);
+                gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                        DHT_MSG_HASHED_SUBVOL_GET_FAILED, "gfid=%s",
+                        loc->pargfid, "name=%s", loc->name, "path=%s",
+                        loc->path, NULL);
                 goto err;
+            }
         }
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this,
+                                       local->hashed_subvol);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set hashed subvol for %s on inode vol is %s",
+                   local->loc.path,
+                   local->hashed_subvol ? local->hashed_subvol->name : "NULL");
+            goto err;
+        }
+    }
 
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, loc, local->hashed_subvol,
-                                     &local->current->ns,
-                                     dht_selfheal_dir_mkdir_lock_cbk);
+    if (local->hashed_subvol == NULL) {
+        local->hashed_subvol = dht_subvol_get_hashed(this, loc);
+        if (local->hashed_subvol == NULL) {
+            local->op_errno = EINVAL;
+            gf_smsg(this->name, GF_LOG_WARNING, local->op_errno,
+                    DHT_MSG_HASHED_SUBVOL_GET_FAILED, "gfid=%s", loc->pargfid,
+                    "name=%s", loc->name, "path=%s", loc->path, NULL);
+            goto err;
+        }
+    }
 
-        if (ret < 0)
-                goto err;
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, loc, local->hashed_subvol,
+                                &local->current->ns,
+                                dht_selfheal_dir_mkdir_lock_cbk);
 
-        return 0;
+    if (ret < 0)
+        goto err;
+
+    return 0;
 err:
-        return -1;
+    return -1;
 }
 
-int
-dht_selfheal_layout_alloc_start (xlator_t *this, loc_t *loc,
-                                 dht_layout_t *layout)
+static int
+dht_selfheal_layout_alloc_start(xlator_t *this, loc_t *loc,
+                                dht_layout_t *layout)
 {
-        int         start                               = 0;
-        uint32_t    hashval                             = 0;
-        int         ret                                 = 0;
-        const char *str                                 = NULL;
-        dht_conf_t *conf                                = NULL;
-        char           buf[UUID_CANONICAL_FORM_LEN + 1] = {0, };
-
-        conf = this->private;
-
-        if (conf->randomize_by_gfid) {
-                str = uuid_utoa_r (loc->gfid, buf);
-        } else {
-                str = loc->path;
-        }
-
-        ret = dht_hash_compute (this, layout->type, str, &hashval);
-        if (ret == 0) {
-                start = (hashval % layout->cnt);
-        }
-
-        return start;
+    int start = 0;
+    uint32_t hashval = 0;
+    int ret = 0;
+    const char *str = NULL;
+    dht_conf_t *conf = NULL;
+    char buf[UUID_CANONICAL_FORM_LEN + 1] = {
+        0,
+    };
+
+    conf = this->private;
+
+    if (conf->randomize_by_gfid) {
+        str = uuid_utoa_r(loc->gfid, buf);
+    } else {
+        str = loc->path;
+    }
+
+    ret = dht_hash_compute(this, layout->type, str, &hashval);
+    if (ret == 0) {
+        start = (hashval % layout->cnt);
+    }
+
+    return start;
 }
 
 static int
-dht_get_layout_count (xlator_t *this, dht_layout_t *layout, int new_layout)
+dht_get_layout_count(xlator_t *this, dht_layout_t *layout, int new_layout)
 {
-        int i = 0;
-        int j = 0;
-        int err = 0;
-        int count = 0;
-        dht_conf_t *conf = NULL;
-
-        /* Gets in use only for replace-brick, remove-brick */
-        conf = this->private;
-        for (i = 0; i < layout->cnt; i++) {
-                for (j = 0; j < conf->subvolume_cnt; j++) {
-                        if (conf->decommissioned_bricks[j] &&
-                            conf->decommissioned_bricks[j] == layout->list[i].xlator) {
-                                layout->list[i].err = EINVAL;
-                                break;
-                        }
-                }
-        }
-
+    int i = 0;
+    int j = 0;
+    int err = 0;
+    int count = 0;
+    dht_conf_t *conf = NULL;
+
+    /* Gets in use only for replace-brick, remove-brick */
+    conf = this->private;
+    for (i = 0; i < layout->cnt; i++) {
+        for (j = 0; j < conf->subvolume_cnt; j++) {
+            if (conf->decommissioned_bricks[j] &&
+                conf->decommissioned_bricks[j] == layout->list[i].xlator) {
+                layout->list[i].err = EINVAL;
+                break;
+            }
+        }
+    }
+
+    for (i = 0; i < layout->cnt; i++) {
+        err = layout->list[i].err;
+        if (err == -1 || err == 0 || err == ENOENT) {
+            /* Take this with a pinch of salt. The behaviour seems
+             * to be slightly different when this function is
+             * invoked from mkdir codepath. For eg., err == 0 in
+             * mkdir codepath means directory created but xattr
+             * is not set yet.
+             */
+
+            /* Setting list[i].err = -1 is an indication for
+               dht_selfheal_layout_new_directory() to assign
+               a range. We set it to -1 based on any one of
+               the three criteria:
+
+               - err == -1 already, which means directory
+                 existed but layout was not set on it.
+
+               - err == 0, which means directory exists and
+                 has an old layout piece which will be
+                 overwritten now.
+
+               - err == ENOENT, which means directory does
+                 not exist (possibly racing with mkdir or
+                 finishing half done mkdir). The missing
+                 directory will be attempted to be recreated.
+            */
+            count++;
+            if (!err)
+                layout->list[i].err = -1;
+        }
+    }
+
+    /* no subvolume has enough space, but can't stop directory creation */
+    if (!count || !new_layout) {
         for (i = 0; i < layout->cnt; i++) {
-                err = layout->list[i].err;
-                if (err == -1 || err == 0 || err == ENOENT) {
-                        /* Take this with a pinch of salt. The behaviour seems
-                         * to be slightly different when this function is
-                         * invoked from mkdir codepath. For eg., err == 0 in
-                         * mkdir codepath means directory created but xattr
-                         * is not set yet.
-                         */
-
-			/* Setting list[i].err = -1 is an indication for
-			   dht_selfheal_layout_new_directory() to assign
-			   a range. We set it to -1 based on any one of
-			   the three criteria:
-
-			   - err == -1 already, which means directory
-			     existed but layout was not set on it.
-
-			   - err == 0, which means directory exists and
-			     has an old layout piece which will be
-			     overwritten now.
-
-			   - err == ENOENT, which means directory does
-			     not exist (possibly racing with mkdir or
-			     finishing half done mkdir). The missing
-			     directory will be attempted to be recreated.
-			*/
-                        count++;
-			if (!err)
-				layout->list[i].err = -1;
-                }
-        }
-
-        /* no subvolume has enough space, but can't stop directory creation */
-        if (!count || !new_layout) {
-                for (i = 0; i < layout->cnt; i++) {
-                        err = layout->list[i].err;
-                        if (err == ENOSPC) {
-                                layout->list[i].err = -1;
-                                count++;
-                        }
-                }
-        }
-
-        /* if layout->spread_cnt is set, check if it is <= available
-         * subvolumes (down brick and decommissioned bricks are considered
-         * un-availbale). Else return count (available up bricks) */
-        count = ((layout->spread_cnt &&
-                 (layout->spread_cnt <= count)) ?
-                 layout->spread_cnt : ((count) ? count : 1));
-
-        return count;
+            err = layout->list[i].err;
+            if (err == ENOSPC) {
+                layout->list[i].err = -1;
+                count++;
+            }
+        }
+    }
+
+    /* if layout->spread_cnt is set, check if it is <= available
+     * subvolumes (down brick and decommissioned bricks are considered
+     * un-available). Else return count (available up bricks) */
+    count = ((layout->spread_cnt && (layout->spread_cnt <= count))
+                 ? layout->spread_cnt
+                 : ((count) ? count : 1));
+
+    return count;
 }
 
+void
+dht_selfheal_layout_new_directory(call_frame_t *frame, loc_t *loc,
+                                  dht_layout_t *new_layout);
 
-void dht_selfheal_layout_new_directory (call_frame_t *frame, loc_t *loc,
-					dht_layout_t *new_layout);
-
-void dht_layout_entry_swap (dht_layout_t *layout, int i, int j);
-void dht_layout_range_swap (dht_layout_t *layout, int i, int j);
+void
+dht_layout_range_swap(dht_layout_t *layout, int i, int j);
 
 /*
  * It's a bit icky using local variables in a macro, but it makes the rest
  * of the code a lot clearer.
  */
-#define OV_ENTRY(x,y)      table[x*new->cnt+y]
+#define OV_ENTRY(x, y) table[x * new->cnt + y]
 
-void
-dht_selfheal_layout_maximize_overlap (call_frame_t *frame, loc_t *loc,
-				      dht_layout_t *new, dht_layout_t *old)
+static void
+dht_selfheal_layout_maximize_overlap(call_frame_t *frame, loc_t *loc,
+                                     dht_layout_t *new, dht_layout_t *old)
 {
-	int           i            = 0;
-	int           j            = 0;
-	uint32_t      curr_overlap = 0;
-	uint32_t      max_overlap  = 0;
-	int           max_overlap_idx = -1;
-	uint32_t      overlap      = 0;
-        uint32_t     *table = NULL;
-
-	dht_layout_sort_volname (old);
-	/* Now both old_layout->list[] and new_layout->list[]
-	   are match the same xlators/subvolumes. i.e,
-	   old_layout->[i] and new_layout->[i] are referring
-	   to the same subvolumes
-	*/
-
-        /* Build a table of overlaps between new[i] and old[j]. */
-        table = alloca(sizeof(overlap)*old->cnt*new->cnt);
-        if (!table) {
-                return;
-        }
-        memset(table,0,sizeof(overlap)*old->cnt*new->cnt);
-        for (i = 0; i < new->cnt; ++i) {
-                for (j = 0; j < old->cnt; ++j) {
-                        OV_ENTRY(i,j) = dht_overlap_calc(old,j,new,i);
+    int i = 0;
+    int j = 0;
+    uint32_t curr_overlap = 0;
+    uint32_t max_overlap = 0;
+    int max_overlap_idx = -1;
+    uint32_t overlap = 0;
+    uint32_t *table = NULL;
+
+    dht_layout_sort_volname(old);
+    /* Now both old_layout->list[] and new_layout->list[]
+       are match the same xlators/subvolumes. i.e,
+       old_layout->[i] and new_layout->[i] are referring
+       to the same subvolumes
+    */
+
+    /* Build a table of overlaps between new[i] and old[j]. */
+    table = alloca(sizeof(overlap) * old->cnt * new->cnt);
+    if (!table) {
+        return;
+    }
+    memset(table, 0, sizeof(overlap) * old->cnt * new->cnt);
+    for (i = 0; i < new->cnt; ++i) {
+        for (j = 0; j < old->cnt; ++j) {
+            OV_ENTRY(i, j) = dht_overlap_calc(old, j, new, i);
+        }
+    }
+
+    for (i = 0; i < new->cnt; i++) {
+        if (new->list[i].err > 0) {
+            /* Subvol might be marked for decommission
+               with EINVAL, or some other serious error
+               marked with positive errno.
+            */
+            continue;
+        }
+
+        max_overlap = 0;
+        max_overlap_idx = i;
+        for (j = (i + 1); j < new->cnt; ++j) {
+            if (new->list[j].err > 0) {
+                /* Subvol might be marked for decommission
+                with EINVAL, or some other serious error
+                marked with positive errno.
+                */
+                continue;
+            }
+            /* Calculate the overlap now. */
+            curr_overlap = OV_ENTRY(i, i) + OV_ENTRY(j, j);
+            /* Calculate the overlap after the proposed swap. */
+            overlap = OV_ENTRY(i, j) + OV_ENTRY(j, i);
+            /* Are we better than status quo? */
+            if (overlap > curr_overlap) {
+                overlap -= curr_overlap;
+                /* Are we better than the previous choice? */
+                if (overlap > max_overlap) {
+                    max_overlap = overlap;
+                    max_overlap_idx = j;
                 }
+            }
         }
 
-	for (i = 0; i < new->cnt; i++) {
-		if (new->list[i].err > 0) {
-			/* Subvol might be marked for decommission
-			   with EINVAL, or some other serious error
-			   marked with positive errno.
-			*/
-			continue;
-                }
-
-                max_overlap = 0;
-                max_overlap_idx = i;
-                for (j = (i + 1); j < new->cnt; ++j) {
-                        if (new->list[j].err > 0) {
-			        /* Subvol might be marked for decommission
-			        with EINVAL, or some other serious error
-			        marked with positive errno.
-			        */
-			        continue;
-                        }
-                        /* Calculate the overlap now. */
-                        curr_overlap = OV_ENTRY(i,i) + OV_ENTRY(j,j);
-                        /* Calculate the overlap after the proposed swap. */
-                        overlap = OV_ENTRY(i,j) + OV_ENTRY(j,i);
-                        /* Are we better than status quo? */
-                        if (overlap > curr_overlap) {
-                                overlap -= curr_overlap;
-                                /* Are we better than the previous choice? */
-                                if (overlap > max_overlap) {
-                                        max_overlap = overlap;
-                                        max_overlap_idx = j;
-                                }
-                        }
-                }
-
-		if (max_overlap_idx != i) {
- 			dht_layout_range_swap (new, i, max_overlap_idx);
-                        /* Need to swap the table values too. */
-                        for (j = 0; j < old->cnt; ++j) {
-                                overlap = OV_ENTRY(i,j);
-                                OV_ENTRY(i,j) = OV_ENTRY(max_overlap_idx,j);
-                                OV_ENTRY(max_overlap_idx,j) = overlap;
-                        }
-                }
-	}
+        if (max_overlap_idx != i) {
+            dht_layout_range_swap(new, i, max_overlap_idx);
+            /* Need to swap the table values too. */
+            for (j = 0; j < old->cnt; ++j) {
+                overlap = OV_ENTRY(i, j);
+                OV_ENTRY(i, j) = OV_ENTRY(max_overlap_idx, j);
+                OV_ENTRY(max_overlap_idx, j) = overlap;
+            }
+        }
+    }
 }
 
-
-dht_layout_t *
-dht_fix_layout_of_directory (call_frame_t *frame, loc_t *loc,
-                             dht_layout_t *layout)
+static dht_layout_t *
+dht_fix_layout_of_directory(call_frame_t *frame, loc_t *loc,
+                            dht_layout_t *layout)
 {
-        int           i                         = 0;
-        xlator_t     *this                      = NULL;
-        dht_layout_t *new_layout                = NULL;
-        dht_conf_t   *priv                      = NULL;
-        dht_local_t  *local                     = NULL;
-        uint32_t      subvol_down               = 0;
-        int           ret                       = 0;
-        gf_boolean_t  maximize_overlap          = _gf_true;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0};
-
-        this  = frame->this;
-        priv  = this->private;
-        local = frame->local;
-
-        if (layout->type == DHT_HASH_TYPE_DM_USER) {
-                gf_msg_debug (THIS->name, 0, "leaving %s alone",
-                              loc->path);
-                goto done;
-        }
-
-        new_layout = dht_layout_new (this, priv->subvolume_cnt);
-        if (!new_layout) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "mem allocation failed for new_layout, path:%s gfid:%s",
-                        loc->path, gfid);
-                goto done;
-        }
-
-        /* If a subvolume is down, do not re-write the layout. */
-        ret = dht_layout_anomalies (this, loc, layout, NULL, NULL, NULL,
-                                    &subvol_down, NULL, NULL);
-
-        if (subvol_down || (ret == -1)) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_FIX_FAILED,
-                        "Layout fix failed: %u subvolume(s) are down"
-                        ". Skipping fix layout. path:%s gfid:%s", subvol_down,
-                        loc->path, gfid);
-                GF_FREE (new_layout);
-                return NULL;
-        }
-
-        for (i = 0; i < new_layout->cnt; i++) {
-		if (layout->list[i].err != ENOSPC)
-			new_layout->list[i].err = layout->list[i].err;
-		else
-			new_layout->list[i].err = -1;
-
-		new_layout->list[i].xlator = layout->list[i].xlator;
-        }
-
-        new_layout->commit_hash = layout->commit_hash;
-
-        if (priv->du_stats) {
-                for (i = 0; i < priv->subvolume_cnt; ++i) {
-                        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "subvolume %d (%s): %u chunks, path:%s", i,
-                                priv->subvolumes[i]->name,
-                                priv->du_stats[i].chunks, loc->path);
-
-                        /* Maximize overlap if the bricks are all the same
-                         *  size.
-                         * This is probably not going to be very common on
-                         * live setups but will benefit our regression tests
-                         */
-                        if (i && (priv->du_stats[i].chunks
-                                  != priv->du_stats[0].chunks)) {
-                                maximize_overlap = _gf_false;
-                        }
-                }
-        } else {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NO_DISK_USAGE_STATUS, "no du stats ?!?");
-        }
-
-	/* First give it a layout as though it is a new directory. This
-	   ensures rotation to kick in */
-        dht_layout_sort_volname (new_layout);
-	dht_selfheal_layout_new_directory (frame, loc, new_layout);
-
-
-        /* Maximize overlap if weighted-rebalance is disabled */
-        if (!priv->do_weighting)
-                maximize_overlap = _gf_true;
-
-	/* Now selectively re-assign ranges only when it helps */
-        if (maximize_overlap) {
-                dht_selfheal_layout_maximize_overlap (frame, loc, new_layout,
-                                                      layout);
-        }
+    int i = 0;
+    xlator_t *this = NULL;
+    dht_layout_t *new_layout = NULL;
+    dht_conf_t *priv = NULL;
+    dht_local_t *local = NULL;
+    uint32_t subvol_down = 0;
+    gf_boolean_t maximize_overlap = _gf_true;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    this = frame->this;
+    priv = this->private;
+    local = frame->local;
+
+    if (layout->type == DHT_HASH_TYPE_DM_USER) {
+        gf_msg_debug(THIS->name, 0, "leaving %s alone", loc->path);
+        goto done;
+    }
+
+    new_layout = dht_layout_new(this, priv->subvolume_cnt);
+    if (!new_layout) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MEM_ALLOC_FAILED,
+                "new_layout, path=%s", loc->path, "gfid=%s", gfid, NULL);
+        goto done;
+    }
+
+    /* If a subvolume is down, do not re-write the layout. */
+    dht_layout_anomalies(this, loc, layout, NULL, NULL, NULL, &subvol_down,
+                         NULL, NULL);
+
+    if (subvol_down) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_FIX_FAILED,
+                "subvol-down=%u", subvol_down, "Skipping-fix-layout", "path=%s",
+                loc->path, "gfid=%s", gfid, NULL);
+        GF_FREE(new_layout);
+        return NULL;
+    }
+
+    for (i = 0; i < new_layout->cnt; i++) {
+        if (layout->list[i].err != ENOSPC)
+            new_layout->list[i].err = layout->list[i].err;
+        else
+            new_layout->list[i].err = -1;
+
+        new_layout->list[i].xlator = layout->list[i].xlator;
+    }
+
+    new_layout->commit_hash = layout->commit_hash;
+
+    if (priv->du_stats) {
+        for (i = 0; i < priv->subvolume_cnt; ++i) {
+            gf_smsg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_SUBVOL_INFO,
+                    "index=%d", i, "name=%s", priv->subvolumes[i]->name,
+                    "chunks=%u", priv->du_stats[i].chunks, "path=%s", loc->path,
+                    NULL);
+
+            /* Maximize overlap if the bricks are all the same
+             *  size.
+             * This is probably not going to be very common on
+             * live setups but will benefit our regression tests
+             */
+            if (i && (priv->du_stats[i].chunks != priv->du_stats[0].chunks)) {
+                maximize_overlap = _gf_false;
+            }
+        }
+    } else {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NO_DISK_USAGE_STATUS,
+                NULL);
+    }
+
+    /* First give it a layout as though it is a new directory. This
+       ensures rotation to kick in */
+    dht_layout_sort_volname(new_layout);
+    dht_selfheal_layout_new_directory(frame, loc, new_layout);
+
+    /* Maximize overlap if weighted-rebalance is disabled */
+    if (!priv->do_weighting)
+        maximize_overlap = _gf_true;
+
+    /* Now selectively re-assign ranges only when it helps */
+    if (maximize_overlap) {
+        dht_selfheal_layout_maximize_overlap(frame, loc, new_layout, layout);
+    }
 done:
-        if (new_layout) {
-                /* Now that the new layout has all the proper layout, change the
-                   inode context */
-                dht_layout_set (this, loc->inode, new_layout);
+    if (new_layout) {
+        /* Make sure the extra 'ref' for existing layout is removed */
+        dht_layout_unref(this, local->layout);
 
-                /* Make sure the extra 'ref' for existing layout is removed */
-                dht_layout_unref (this, local->layout);
+        local->layout = new_layout;
+    }
 
-                local->layout = new_layout;
-        }
-
-        return local->layout;
+    return local->layout;
 }
 
-
 /*
  * Having to call this 2x for each entry in the layout is pretty horrible, but
  * that's what all of this layout-sorting nonsense gets us.
  */
-uint32_t
-dht_get_chunks_from_xl (xlator_t *parent, xlator_t *child)
+static uint32_t
+dht_get_chunks_from_xl(xlator_t *parent, xlator_t *child)
 {
-        dht_conf_t      *priv   = parent->private;
-        xlator_list_t   *trav;
-        uint32_t        index   = 0;
+    dht_conf_t *priv = parent->private;
+    xlator_list_t *trav;
+    uint32_t index = 0;
 
-        if (!priv->du_stats) {
-                return 0;
-        }
+    if (!priv->du_stats) {
+        return 0;
+    }
 
-        for (trav = parent->children; trav; trav = trav->next) {
-                if (trav->xlator == child) {
-                        return priv->du_stats[index].chunks;
-                }
-                ++index;
+    for (trav = parent->children; trav; trav = trav->next) {
+        if (trav->xlator == child) {
+            return priv->du_stats[index].chunks;
         }
+        ++index;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 void
-dht_selfheal_layout_new_directory (call_frame_t *frame, loc_t *loc,
-                                   dht_layout_t *layout)
+dht_selfheal_layout_new_directory(call_frame_t *frame, loc_t *loc,
+                                  dht_layout_t *layout)
 {
-        xlator_t    *this = NULL;
-        double       chunk = 0;
-        int          i = 0;
-        uint32_t     start = 0;
-        int          bricks_to_use = 0;
-        int          err = 0;
-        int          start_subvol = 0;
-        uint32_t     curr_size;
-        uint32_t     range_size;
-        uint64_t     total_size = 0;
-        int          real_i;
-        dht_conf_t   *priv;
-        gf_boolean_t weight_by_size;
-        int          bricks_used = 0;
-
-        this = frame->this;
-        priv = this->private;
-        weight_by_size = priv->do_weighting;
-
-        bricks_to_use = dht_get_layout_count (this, layout, 1);
-        GF_ASSERT (bricks_to_use > 0);
-
-        bricks_used = 0;
-        for (i = 0; i < layout->cnt; ++i) {
-                err = layout->list[i].err;
-                if ((err != -1) && (err != ENOENT)) {
-                        continue;
-                }
-                curr_size = dht_get_chunks_from_xl (this,
-                                                    layout->list[i].xlator);
-                if (!curr_size) {
-                        weight_by_size = _gf_false;
-                        break;
-                }
-                total_size += curr_size;
-                if (++bricks_used >= bricks_to_use) {
-                        break;
-                }
-        }
-
-        if (weight_by_size && total_size) {
-                /* We know total_size is not zero. */
-                chunk = ((double) 0xffffffff) / ((double) total_size);
-                gf_msg_debug (this->name, 0,
-                              "chunk size = 0xffffffff / %lu = %f",
-                              total_size, chunk);
-        }
-        else {
-                weight_by_size = _gf_false;
-                chunk = ((unsigned long) 0xffffffff) / bricks_to_use;
+    xlator_t *this = NULL;
+    double chunk = 0;
+    int i = 0;
+    uint32_t start = 0;
+    int bricks_to_use = 0;
+    int err = 0;
+    int start_subvol = 0;
+    uint32_t curr_size;
+    uint32_t range_size;
+    uint64_t total_size = 0;
+    int real_i;
+    dht_conf_t *priv;
+    gf_boolean_t weight_by_size;
+    int bricks_used = 0;
+
+    this = frame->this;
+    priv = this->private;
+    weight_by_size = priv->do_weighting;
+
+    bricks_to_use = dht_get_layout_count(this, layout, 1);
+    GF_ASSERT(bricks_to_use > 0);
+
+    bricks_used = 0;
+    for (i = 0; i < layout->cnt; ++i) {
+        err = layout->list[i].err;
+        if ((err != -1) && (err != ENOENT)) {
+            continue;
+        }
+        curr_size = dht_get_chunks_from_xl(this, layout->list[i].xlator);
+        if (!curr_size) {
+            weight_by_size = _gf_false;
+            break;
+        }
+        total_size += curr_size;
+        if (++bricks_used >= bricks_to_use) {
+            break;
+        }
+    }
+
+    if (weight_by_size && total_size) {
+        /* We know total_size is not zero. */
+        chunk = ((double)0xffffffff) / ((double)total_size);
+        gf_msg_debug(this->name, 0,
+                     "chunk size = 0xffffffff / %" PRIu64 " = %f", total_size,
+                     chunk);
+    } else {
+        weight_by_size = _gf_false;
+        chunk = ((unsigned long)0xffffffff) / bricks_to_use;
+    }
+
+    start_subvol = dht_selfheal_layout_alloc_start(this, loc, layout);
+
+    /* clear out the range, as we are re-computing here */
+    DHT_RESET_LAYOUT_RANGE(layout);
+
+    /*
+     * OK, what's this "real_i" stuff about?  This used to be two loops -
+     * from start_subvol to layout->cnt-1, then from 0 to start_subvol-1.
+     * That way is practically an open invitation to bugs when only one
+     * of the loops is updated.  Using real_i and modulo operators to make
+     * it one loop avoids this problem.  Remember, folks: it's everyone's
+     * responsibility to help stamp out copy/paste abuse.
+     */
+    bricks_used = 0;
+    for (real_i = 0; real_i < layout->cnt; real_i++) {
+        i = (real_i + start_subvol) % layout->cnt;
+        err = layout->list[i].err;
+        if ((err != -1) && (err != ENOENT)) {
+            continue;
+        }
+        if (weight_by_size) {
+            curr_size = dht_get_chunks_from_xl(this, layout->list[i].xlator);
+            if (!curr_size) {
+                continue;
+            }
+        } else {
+            curr_size = 1;
         }
-
-        start_subvol = dht_selfheal_layout_alloc_start (this, loc, layout);
-
-        /* clear out the range, as we are re-computing here */
-        DHT_RESET_LAYOUT_RANGE (layout);
-
-        /*
-         * OK, what's this "real_i" stuff about?  This used to be two loops -
-         * from start_subvol to layout->cnt-1, then from 0 to start_subvol-1.
-         * That way is practically an open invitation to bugs when only one
-         * of the loops is updated.  Using real_i and modulo operators to make
-         * it one loop avoids this problem.  Remember, folks: it's everyone's
-         * responsibility to help stamp out copy/paste abuse.
-         */
-        bricks_used = 0;
-        for (real_i = 0; real_i < layout->cnt; real_i++) {
-                i = (real_i + start_subvol) % layout->cnt;
-                err = layout->list[i].err;
-                if ((err != -1) && (err != ENOENT)) {
-                        continue;
-                }
-                if (weight_by_size) {
-                        curr_size = dht_get_chunks_from_xl (this,
-                                layout->list[i].xlator);
-                        if (!curr_size) {
-                                continue;
-                        }
-                }
-                else {
-                        curr_size = 1;
-                }
-                range_size = chunk * curr_size;
-                gf_msg_debug (this->name, 0,
-                              "assigning range size 0x%x to %s",
-                              range_size,
-                              layout->list[i].xlator->name);
-                DHT_SET_LAYOUT_RANGE(layout, i, start, range_size,
-                                     loc->path);
-                if (++bricks_used >= bricks_to_use) {
-                        layout->list[i].stop = 0xffffffff;
-                        goto done;
-                }
-                start += range_size;
+        range_size = chunk * curr_size;
+        gf_msg_debug(this->name, 0, "assigning range size 0x%x to %s",
+                     range_size, layout->list[i].xlator->name);
+        DHT_SET_LAYOUT_RANGE(layout, i, start, range_size, loc->path);
+        if (++bricks_used >= bricks_to_use) {
+            layout->list[i].stop = 0xffffffff;
+            goto done;
         }
+        start += range_size;
+    }
 
 done:
-        return;
+    return;
 }
 
-int
-dht_selfheal_dir_getafix (call_frame_t *frame, loc_t *loc,
-                          dht_layout_t *layout)
+static int
+dht_selfheal_dir_getafix(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local = NULL;
-        uint32_t     holes = 0;
-        int          ret = -1;
-        int          i = -1;
-        uint32_t     overlaps = 0;
-
-        local = frame->local;
-
-        holes = local->selfheal.hole_cnt;
-        overlaps = local->selfheal.overlaps_cnt;
-
-        if (holes || overlaps) {
-                /* If the layout has anomolies which would change the hash
-                 * ranges, then we need to reset the commit_hash for this
-                 * directory, as the layout would change and things may not
-                 * be in place as expected */
-                layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
-                dht_selfheal_layout_new_directory (frame, loc, layout);
-                ret = 0;
-        }
+    dht_local_t *local = NULL;
+    uint32_t holes = 0;
+    int ret = -1;
+    int i = -1;
+    uint32_t overlaps = 0;
+
+    local = frame->local;
+
+    holes = local->selfheal.hole_cnt;
+    overlaps = local->selfheal.overlaps_cnt;
+
+    if (holes || overlaps) {
+        /* If the layout has anomalies which would change the hash
+         * ranges, then we need to reset the commit_hash for this
+         * directory, as the layout would change and things may not
+         * be in place as expected */
+        layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+        dht_selfheal_layout_new_directory(frame, loc, layout);
+        ret = 0;
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                /* directory not present */
-                if (layout->list[i].err == ENOENT) {
-                        ret = 0;
-                        break;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        /* directory not present */
+        if (layout->list[i].err == ENOENT) {
+            ret = 0;
+            break;
         }
+    }
 
-        /* TODO: give a fix to these non-virgins */
+    /* TODO: give a fix to these non-virgins */
 
-        return ret;
+    return ret;
 }
 
 int
-dht_selfheal_new_directory (call_frame_t *frame,
-                            dht_selfheal_dir_cbk_t dir_cbk,
-                            dht_layout_t *layout)
+dht_selfheal_new_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                           dht_layout_t *layout)
 {
-        dht_local_t *local                   = NULL;
-        int          ret                     = 0;
-        inode_t     *linked_inode            = NULL, *inode = NULL;
-        loc_t       *loc                     = NULL;
-        char         pgfid[GF_UUID_BUF_SIZE] = {0};
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        int32_t      op_errno                = EIO;
+    dht_local_t *local = NULL;
+    int ret = 0;
+    inode_t *linked_inode = NULL, *inode = NULL;
+    loc_t *loc = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t op_errno = EIO;
 
-        local = frame->local;
+    local = frame->local;
 
-        loc = &local->loc;
+    loc = &local->loc;
 
-        gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
-        gf_uuid_unparse(loc->parent->gfid, pgfid);
+    gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
 
-        linked_inode = inode_link (loc->inode, loc->parent, loc->name,
-                                   &local->stbuf);
-        if (!linked_inode) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "linking inode failed (%s/%s) => %s",
-                        pgfid, loc->name, gfid);
-                ret = -1;
-                goto out;
-        }
+    linked_inode = inode_link(loc->inode, loc->parent, loc->name,
+                              &local->stbuf);
+    if (!linked_inode) {
+        gf_smsg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_LINK_INODE_FAILED,
+                "pgfid=%s", pgfid, "name=%s", loc->name, "gfid=%s", gfid, NULL);
+        ret = -1;
+        goto out;
+    }
 
-        inode = loc->inode;
-        loc->inode = linked_inode;
-        inode_unref (inode);
+    inode = loc->inode;
+    loc->inode = linked_inode;
+    inode_unref(inode);
 
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
 
-        dht_layout_sort_volname (layout);
-        dht_selfheal_layout_new_directory (frame, &local->loc, layout);
+    dht_layout_sort_volname(layout);
+    dht_selfheal_layout_new_directory(frame, &local->loc, layout);
 
-        op_errno = ENOMEM;
-        ret = dht_selfheal_layout_lock (frame, layout, _gf_true,
-                                        dht_selfheal_dir_xattr,
-                                        dht_should_heal_layout);
+    op_errno = ENOMEM;
+    ret = dht_selfheal_layout_lock(frame, layout, _gf_true,
+                                   dht_selfheal_dir_xattr,
+                                   dht_should_heal_layout);
 
 out:
-        if (ret < 0) {
-                dir_cbk (frame, NULL, frame->this, -1, op_errno, NULL);
-        }
+    if (ret < 0) {
+        dir_cbk(frame, NULL, frame->this, -1, op_errno, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fix_directory_layout (call_frame_t *frame,
-                          dht_selfheal_dir_cbk_t dir_cbk,
-                          dht_layout_t *layout)
+dht_fix_directory_layout(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                         dht_layout_t *layout)
 {
-        dht_local_t  *local      = NULL;
-        dht_layout_t *tmp_layout = NULL;
-        int           ret        = 0;
+    dht_local_t *local = NULL;
+    dht_layout_t *tmp_layout = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
 
-        /* No layout sorting required here */
-        tmp_layout = dht_fix_layout_of_directory (frame, &local->loc, layout);
-        if (!tmp_layout) {
-                return -1;
-        }
+    /* No layout sorting required here */
+    tmp_layout = dht_fix_layout_of_directory(frame, &local->loc, layout);
+    if (!tmp_layout) {
+        return -1;
+    }
 
-        ret = dht_selfheal_layout_lock (frame, tmp_layout, _gf_false,
-                                        dht_fix_dir_xattr,
-                                        dht_should_fix_layout);
+    ret = dht_selfheal_layout_lock(frame, tmp_layout, _gf_false,
+                                   dht_fix_dir_xattr, dht_should_fix_layout);
 
-        return ret;
+    return ret;
 }
 
-
 int
-dht_selfheal_directory (call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
-                        loc_t *loc, dht_layout_t *layout)
+dht_selfheal_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                       loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local                   = NULL;
-        uint32_t     down                    = 0;
-        uint32_t     misc                    = 0;
-        int          ret                     = 0;
-        xlator_t    *this                    = NULL;
-        char         pgfid[GF_UUID_BUF_SIZE] = {0};
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        inode_t     *linked_inode            = NULL, *inode = NULL;
-
-        local = frame->local;
-        this = frame->this;
-
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (this, layout);
-
-        if (!__is_root_gfid (local->stbuf.ia_gfid)) {
-                gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
-                gf_uuid_unparse(loc->parent->gfid, pgfid);
-
-                linked_inode = inode_link (loc->inode, loc->parent, loc->name,
-                                           &local->stbuf);
-                if (!linked_inode) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_FAILED,
-                                "linking inode failed (%s/%s) => %s",
-                                pgfid, loc->name, gfid);
-                        ret = 0;
-                        goto sorry_no_fix;
-                }
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    uint32_t down = 0;
+    uint32_t misc = 0;
+    int ret = 0;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    inode_t *linked_inode = NULL, *inode = NULL;
 
-                inode = loc->inode;
-                loc->inode = linked_inode;
-                inode_unref (inode);
-        }
+    local = frame->local;
+    this = frame->this;
 
-        dht_layout_anomalies (this, loc, layout,
-                              &local->selfheal.hole_cnt,
-                              &local->selfheal.overlaps_cnt,
-                              NULL, &local->selfheal.down,
-                              &local->selfheal.misc, NULL);
-
-        down     = local->selfheal.down;
-        misc     = local->selfheal.misc;
-
-        if (down) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed: %d subvolumes down."
-                        "Not fixing. path = %s, gfid = %s",
-                        down, loc->path, gfid);
-                ret = 0;
-                goto sorry_no_fix;
-        }
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(this, layout);
 
-        if (misc) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed : %d subvolumes "
-                        "have unrecoverable errors. path = %s, gfid = %s",
-                        misc, loc->path, gfid);
+    if (local->need_attrheal) {
+        if (__is_root_gfid(local->stbuf.ia_gfid)) {
+            local->stbuf.ia_gid = local->prebuf.ia_gid;
+            local->stbuf.ia_uid = local->prebuf.ia_uid;
 
-                ret = 0;
-                goto sorry_no_fix;
-        }
+            local->stbuf.ia_ctime = local->prebuf.ia_ctime;
+            local->stbuf.ia_ctime_nsec = local->prebuf.ia_ctime_nsec;
+            local->stbuf.ia_prot = local->prebuf.ia_prot;
 
-        dht_layout_sort_volname (layout);
-        ret = dht_selfheal_dir_getafix (frame, loc, layout);
-
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed: "
-                        "Unable to form layout for directory %s",
-                        loc->path);
-                goto sorry_no_fix;
+        } else if (!IA_ISINVAL(local->mds_stbuf.ia_type)) {
+            local->stbuf = local->mds_stbuf;
         }
+    }
 
-        dht_selfheal_dir_mkdir (frame, loc, layout, 0);
-
-        return 0;
-
-sorry_no_fix:
-        /* TODO: need to put appropriate local->op_errno */
-        dht_selfheal_dir_finish (frame, this, ret, 1);
-
-        return 0;
-}
+    if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+        gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+        gf_uuid_unparse(loc->parent->gfid, pgfid);
 
-int
-dht_selfheal_directory_for_nameless_lookup (call_frame_t *frame,
-                                            dht_selfheal_dir_cbk_t dir_cbk,
-                                            loc_t *loc, dht_layout_t *layout)
-{
-        dht_local_t     *local  = NULL;
-        uint32_t        down    = 0;
-        uint32_t        misc    = 0;
-        int             ret     = 0;
-        xlator_t        *this   = NULL;
-
-        local = frame->local;
-        this = frame->this;
-        dht_layout_anomalies (this, loc, layout,
-                              &local->selfheal.hole_cnt,
-                              &local->selfheal.overlaps_cnt,
-                              NULL, &local->selfheal.down,
-                              &local->selfheal.misc, NULL);
-
-        down     = local->selfheal.down;
-        misc     = local->selfheal.misc;
-
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (this, layout);
-
-        if (down) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_DOWN_ERROR,
-                        "%d subvolumes down -- not fixing", down);
-                ret = 0;
-                goto sorry_no_fix;
+        linked_inode = inode_link(loc->inode, loc->parent, loc->name,
+                                  &local->stbuf);
+        if (!linked_inode) {
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LINK_INODE_FAILED,
+                    "pgfid=%s", pgfid, "name=%s", loc->name, "gfid=%s", gfid,
+                    NULL);
+            ret = 0;
+            goto sorry_no_fix;
         }
 
-        if (misc) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_ERROR,
-                        "%d subvolumes have unrecoverable errors", misc);
-                ret = 0;
-                goto sorry_no_fix;
-        }
+        inode = loc->inode;
+        loc->inode = linked_inode;
+        inode_unref(inode);
+    }
+
+    if (local->need_xattr_heal && (local->mds_xattr)) {
+        dht_dir_set_heal_xattr(this, local, local->xattr, local->mds_xattr,
+                               NULL, NULL);
+        dict_unref(local->mds_xattr);
+        local->mds_xattr = NULL;
+    }
+
+    dht_layout_anomalies(this, loc, layout, &local->selfheal.hole_cnt,
+                         &local->selfheal.overlaps_cnt,
+                         &local->selfheal.missing_cnt, &local->selfheal.down,
+                         &local->selfheal.misc, NULL);
+
+    down = local->selfheal.down;
+    misc = local->selfheal.misc;
+
+    if (down) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SELFHEAL_FAILED,
+                "path=%s", loc->path, "subvol-down=%d", down, "Not-fixing",
+                "gfid=%s", gfid, NULL);
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        dht_layout_sort_volname (layout);
-        ret = dht_selfheal_dir_getafix (frame, loc, layout);
+    if (misc) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SELFHEAL_FAILED,
+                "path=%s", loc->path, "misc=%d", misc, "unrecoverable-errors",
+                "gfid=%s", gfid, NULL);
 
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_FORM_FAILED,
-                        "not able to form layout for the directory");
-                goto sorry_no_fix;
-        }
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        ret = dht_selfheal_layout_lock (frame, layout, _gf_false,
-                                     dht_selfheal_dir_xattr_for_nameless_lookup,
-                                        dht_should_heal_layout);
+    dht_layout_sort_volname(layout);
+    local->heal_layout = _gf_true;
 
-        if (ret < 0) {
-                goto sorry_no_fix;
-        }
+    /* Ignore return value as it can be inferred from result of
+     * dht_layout_anomalies
+     */
+    dht_selfheal_dir_getafix(frame, loc, layout);
 
-        return 0;
+    if (!(local->selfheal.hole_cnt || local->selfheal.overlaps_cnt ||
+          local->selfheal.missing_cnt)) {
+        local->heal_layout = _gf_false;
+    }
 
-sorry_no_fix:
-        /* TODO: need to put appropriate local->op_errno */
-        dht_selfheal_dir_finish (frame, this, ret, 1);
+    ret = dht_selfheal_dir_mkdir(frame, loc, layout, 0);
+    if (ret < 0) {
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        return 0;
+    return 0;
 
+sorry_no_fix:
+    /* TODO: need to put appropriate local->op_errno */
+    dht_selfheal_dir_finish(frame, this, ret, 1);
 
+    return 0;
 }
 
 int
-dht_selfheal_restore (call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
-                      loc_t *loc, dht_layout_t *layout)
+dht_selfheal_restore(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                     loc_t *loc, dht_layout_t *layout)
 {
-        int          ret = 0;
-        dht_local_t *local    = NULL;
+    int ret = 0;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
 
-        ret = dht_selfheal_dir_mkdir (frame, loc, layout, 1);
+    ret = dht_selfheal_dir_mkdir(frame, loc, layout, 1);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_dir_attr_heal (void *data)
+dht_dir_heal_xattrs(void *data)
 {
-        call_frame_t    *frame = NULL;
-        dht_local_t     *local = NULL;
-        xlator_t        *subvol = NULL;
-        xlator_t        *this  = NULL;
-        dht_conf_t      *conf  = NULL;
-        int              call_cnt = 0;
-        int              ret   = -1;
-        int              i     = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-
-        GF_VALIDATE_OR_GOTO ("dht", data, out);
-
-        frame = data;
-        local = frame->local;
-        this = frame->this;
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO ("dht", conf, out);
-
-        call_cnt = conf->subvolume_cnt;
-
-        for (i = 0; i < call_cnt; i++) {
-                subvol = conf->subvolumes[i];
-                if (!subvol)
-                        continue;
-
-                if (__is_root_gfid (local->stbuf.ia_gfid)) {
-                        ret = syncop_setattr (subvol, &local->loc, &local->stbuf,
-                                              (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
-                                              NULL, NULL, NULL, NULL);
-                } else {
-                        ret = syncop_setattr (subvol, &local->loc, &local->stbuf,
-                                              (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
-                                              NULL, NULL, NULL, NULL);
-                }
-
-                if (ret) {
-                        gf_uuid_unparse(local->loc.gfid, gfid);
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dict_t *user_xattr = NULL;
+    dict_t *internal_xattr = NULL;
+    dict_t *mds_xattr = NULL;
+    dict_t *xdata = NULL;
+    int call_cnt = 0;
+    int ret = -1;
+    int uret = 0;
+    int uflag = 0;
+    int i = 0;
+    int xattr_hashed = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t allzero[1] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", data, out);
+
+    frame = data;
+    local = frame->local;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, local, out);
+    mds_subvol = local->mds_subvol;
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    if (!mds_subvol) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NO_MDS_SUBVOL, "path=%s",
+                local->loc.path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+
+    if ((local->loc.inode && gf_uuid_is_null(local->loc.inode->gfid)) ||
+        gf_uuid_is_null(local->loc.gfid)) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_NOT_PRESENT,
+                "skip-heal path=%s", local->loc.path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+
+    internal_xattr = dict_new();
+    if (!internal_xattr) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_CREATE_FAILED,
+                "dictionary", NULL);
+        goto out;
+    }
+    xdata = dict_new();
+    if (!xdata) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_CREATE_FAILED,
+                "dictionary", NULL);
+        goto out;
+    }
+
+    call_cnt = conf->subvolume_cnt;
+
+    user_xattr = dict_new();
+    if (!user_xattr) {
+        gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_CREATE_FAILED,
+                "dictionary", NULL);
+        goto out;
+    }
+
+    ret = syncop_listxattr(local->mds_subvol, &local->loc, &mds_xattr, NULL,
+                           NULL);
+    if (ret < 0) {
+        gf_smsg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LIST_XATTRS_FAILED,
+                "path=%s", local->loc.path, "name=%s", local->mds_subvol->name,
+                NULL);
+    }
+
+    if (!mds_xattr)
+        goto out;
+
+    dht_dir_set_heal_xattr(this, local, user_xattr, mds_xattr, &uret, &uflag);
+
+    /* To set quota related xattr need to set GLUSTERFS_INTERNAL_FOP_KEY
+     * key value to 1
+     */
+    if (dict_get(user_xattr, QUOTA_LIMIT_KEY) ||
+        dict_get(user_xattr, QUOTA_LIMIT_OBJECTS_KEY)) {
+        ret = dict_set_int32(xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                    "key=%s", GLUSTERFS_INTERNAL_FOP_KEY, "path=%s",
+                    local->loc.path, NULL);
+            goto out;
+        }
+    }
+    if (uret <= 0 && !uflag)
+        goto out;
+
+    for (i = 0; i < call_cnt; i++) {
+        subvol = conf->subvolumes[i];
+        if (subvol == mds_subvol)
+            continue;
+        if (uret || uflag) {
+            /* Custom xattr heal is required - let posix handle it */
+            ret = dict_set_int8(xdata, "sync_backend_xattrs", _gf_true);
+            if (ret) {
+                gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                        "path=%s", local->loc.path, "key=%s",
+                        "sync_backend_xattrs", NULL);
+                goto out;
+            }
+
+            ret = syncop_setxattr(subvol, &local->loc, user_xattr, 0, xdata,
+                                  NULL);
+            if (ret) {
+                xattr_hashed = 1;
+                gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                        "set-user-xattr-failed path=%s", local->loc.path,
+                        "subvol=%s", subvol->name, "gfid=%s", gfid, NULL);
+            } else {
+                dict_del(xdata, "sync_backend_xattrs");
+            }
+        }
+    }
+    /* After heal all custom xattr reset internal MDS xattr to 0 */
+    if (!xattr_hashed) {
+        ret = dht_dict_set_array(internal_xattr, conf->mds_xattr_key, allzero,
+                                 1);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                    "key=%s", conf->mds_xattr_key, "path=%s", local->loc.path,
+                    NULL);
+            goto out;
+        }
+        ret = syncop_setxattr(mds_subvol, &local->loc, internal_xattr, 0, NULL,
+                              NULL);
+        if (ret) {
+            gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                    DHT_MSG_DIR_XATTR_HEAL_FAILED, "path=%s", local->loc.path,
+                    "subvol=%s", mds_subvol->name, "gfid=%s", gfid, NULL);
+        }
+    }
 
-                        gf_msg ("dht", GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_ATTR_HEAL_FAILED,
-                                "Directory attr heal failed. Failed to set"
-                                " uid/gid on path %s on subvol %s, gfid = %s ",
-                                local->loc.path, subvol->name, gfid);
-                }
-        }
 out:
-        return 0;
+    if (user_xattr)
+        dict_unref(user_xattr);
+    if (mds_xattr)
+        dict_unref(mds_xattr);
+    if (internal_xattr)
+        dict_unref(internal_xattr);
+    if (xdata)
+        dict_unref(xdata);
+    return 0;
 }
 
 int
-dht_dir_attr_heal_done (int ret, call_frame_t *sync_frame, void *data)
+dht_dir_heal_xattrs_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        DHT_STACK_DESTROY (sync_frame);
-        return 0;
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
 }
 
-/* EXIT: dht_update_commit_hash_for_layout */
 int
-dht_update_commit_hash_for_layout_done (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+dht_dir_attr_heal(void *data)
 {
-        dht_local_t  *local = NULL;
-
-        local = frame->local;
-
-        /* preserve oldest error */
-        if (op_ret && !local->op_ret) {
-                local->op_ret = op_ret;
-                local->op_errno = op_errno;
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int ret = -1;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", data, out);
+
+    frame = data;
+    local = frame->local;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO("dht", conf, out);
+
+    mds_subvol = local->mds_subvol;
+    call_cnt = conf->subvolume_cnt;
+
+    if (!__is_root_gfid(local->stbuf.ia_gfid) && (!mds_subvol)) {
+        gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NO_MDS_SUBVOL, "path=%s",
+                local->loc.path, "gfid=%s", gfid, NULL);
+        goto out;
+    }
+
+    if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == mds_subvol) {
+                if (!conf->subvolume_status[i]) {
+                    gf_smsg(this->name, GF_LOG_ERROR, 0,
+                            DHT_MSG_MDS_DOWN_UNABLE_TO_SET, "path=%s",
+                            local->loc.path, "gfid=%s", gfid, NULL);
+                    goto out;
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < call_cnt; i++) {
+        subvol = conf->subvolumes[i];
+        if (!subvol || subvol == mds_subvol)
+            continue;
+        if (__is_root_gfid(local->stbuf.ia_gfid)) {
+            ret = syncop_setattr(
+                subvol, &local->loc, &local->stbuf,
+                (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL,
+                NULL, NULL, NULL);
+        } else {
+            ret = syncop_setattr(
+                subvol, &local->loc, &local->mds_stbuf,
+                (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL,
+                NULL, NULL, NULL);
         }
 
-        DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                          local->op_errno, NULL);
+        if (ret) {
+            gf_uuid_unparse(local->loc.gfid, gfid);
 
-        return 0;
+            gf_smsg(this->name, GF_LOG_ERROR, -ret,
+                    DHT_MSG_DIR_ATTR_HEAL_FAILED, "path=%s", local->loc.path,
+                    "subvol=%s", subvol->name, "gfid=%s", gfid, NULL);
+        }
+    }
+out:
+    return 0;
 }
 
 int
-dht_update_commit_hash_for_layout_unlock (call_frame_t *frame, xlator_t *this)
+dht_dir_attr_heal_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        dht_local_t  *local = NULL;
-        int ret = 0;
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
+}
 
-        local = frame->local;
+/* EXIT: dht_update_commit_hash_for_layout */
+static int
+dht_update_commit_hash_for_layout_done(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
 
-        ret = dht_unlock_inodelk (frame, local->lock[0].layout.my_layout.locks,
-                                   local->lock[0].layout.my_layout.lk_count,
-                                   dht_update_commit_hash_for_layout_done);
-        if (ret < 0) {
-                /* preserve oldest error, just ... */
-                if (!local->op_ret) {
-                        local->op_errno = errno;
-                        local->op_ret = -1;
-                }
+    local = frame->local;
 
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Winding unlock failed: stale locks left on brick"
-                        " %s", local->loc.path);
+    /* preserve oldest error */
+    if (op_ret && !local->op_ret) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+    }
 
-                dht_update_commit_hash_for_layout_done (frame, NULL, this,
-                                                        0, 0, NULL);
-        }
+    DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-int
-dht_update_commit_hash_for_layout_cbk (call_frame_t *frame, void *cookie,
-                                       xlator_t *this, int op_ret,
-                                       int op_errno, dict_t *xdata)
+static int
+dht_update_commit_hash_for_layout_unlock(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        /* store first failure, just because */
-        if (op_ret && !local->op_ret) {
-                local->op_ret = op_ret;
-                local->op_errno = op_errno;
+    ret = dht_unlock_inodelk(frame, local->lock[0].layout.my_layout.locks,
+                             local->lock[0].layout.my_layout.lk_count,
+                             dht_update_commit_hash_for_layout_done);
+    if (ret < 0) {
+        /* preserve oldest error, just ... */
+        if (!local->op_ret) {
+            local->op_errno = errno;
+            local->op_ret = -1;
         }
-        UNLOCK (&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+        gf_smsg(this->name, GF_LOG_WARNING, errno, DHT_MSG_WIND_UNLOCK_FAILED,
+                "path=%s", local->loc.path, NULL);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_update_commit_hash_for_layout_unlock (frame, this);
-        }
+        dht_update_commit_hash_for_layout_done(frame, NULL, this, 0, 0, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
-int
-dht_update_commit_hash_for_layout_resume (call_frame_t *frame, void *cookie,
-                                          xlator_t *this, int32_t op_ret,
-                                          int32_t op_errno, dict_t *xdata)
+static int
+dht_update_commit_hash_for_layout_cbk(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int op_ret, int op_errno,
+                                      dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        int            count = 1, ret = -1, i = 0, j = 0;
-        dht_conf_t    *conf = NULL;
-        dht_layout_t  *layout = NULL;
-        int32_t       *disk_layout = NULL;
-        dict_t        **xattr = NULL;
-
-        local = frame->local;
-        conf = frame->this->private;
-        count = conf->local_subvols_cnt;
-        layout = local->layout;
-
-        if (op_ret < 0) {
-                goto err_done;
-        }
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        /* We precreate the xattr list as we cannot change call count post the
-         * first wind as we may never continue from there. So we finish prep
-         * work before winding the setxattrs */
-        xattr = GF_CALLOC (count, sizeof (*xattr), gf_common_mt_char);
-        if (!xattr) {
-                local->op_errno = errno;
+    local = frame->local;
 
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory commit hash update failed:"
-                        " %s: Allocation failed", local->loc.path);
+    LOCK(&frame->lock);
+    /* store first failure, just because */
+    if (op_ret && !local->op_ret) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+    }
+    UNLOCK(&frame->lock);
 
-                goto err;
-        }
+    this_call_cnt = dht_frame_return(frame);
 
-        for (i = 0; i < count; i++) {
-                /* find the layout index for the subvolume */
-                ret = dht_layout_index_for_subvol (layout,
-                                                   conf->local_subvols[i]);
-                if (ret < 0) {
-                        local->op_errno = ENOENT;
-
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: (subvol %s) Failed to find disk layout",
-                                local->loc.path, conf->local_subvols[i]->name);
-
-                        goto err;
-                }
-                j = ret;
+    if (is_last_call(this_call_cnt)) {
+        dht_update_commit_hash_for_layout_unlock(frame, this);
+    }
 
-                /* update the commit hash for the layout */
-                layout->list[j].commit_hash = layout->commit_hash;
+    return 0;
+}
 
-                /* extract the current layout */
-                ret = dht_disk_layout_extract (this, layout, j, &disk_layout);
-                if (ret == -1) {
-                        local->op_errno = errno;
+static int
+dht_update_commit_hash_for_layout_resume(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int32_t op_ret,
+                                         int32_t op_errno, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0, j = 0;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int32_t *disk_layout = NULL;
+    dict_t **xattr = NULL;
+
+    local = frame->local;
+    conf = frame->this->private;
+    count = conf->local_subvols_cnt;
+    layout = local->layout;
+
+    if (op_ret < 0) {
+        goto err_done;
+    }
+
+    /* We precreate the xattr list as we cannot change call count post the
+     * first wind as we may never continue from there. So we finish prep
+     * work before winding the setxattrs */
+    xattr = GF_CALLOC(count, sizeof(*xattr), gf_common_mt_char);
+    if (!xattr) {
+        local->op_errno = errno;
+
+        gf_smsg(this->name, GF_LOG_WARNING, errno, DHT_MSG_COMMIT_HASH_FAILED,
+                "allocation-failed path=%s", local->loc.path, NULL);
+
+        goto err;
+    }
+
+    for (i = 0; i < count; i++) {
+        /* find the layout index for the subvolume */
+        ret = dht_layout_index_for_subvol(layout, conf->local_subvols[i]);
+        if (ret < 0) {
+            local->op_errno = ENOENT;
 
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: (subvol %s) Failed to extract disk"
-                                " layout", local->loc.path,
-                                conf->local_subvols[i]->name);
+            gf_smsg(this->name, GF_LOG_WARNING, 0, DHT_MSG_COMMIT_HASH_FAILED,
+                    "path=%s", local->loc.path, "subvol=%s",
+                    conf->local_subvols[i]->name, "find-disk-layout-failed",
+                    NULL);
 
-                        goto err;
-                }
+            goto err;
+        }
+        j = ret;
 
-                xattr[i] = dict_new ();
-                if (!xattr[i]) {
-                        local->op_errno = errno;
+        /* update the commit hash for the layout */
+        layout->list[j].commit_hash = layout->commit_hash;
 
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: Allocation failed", local->loc.path);
+        /* extract the current layout */
+        ret = dht_disk_layout_extract(this, layout, j, &disk_layout);
+        if (ret == -1) {
+            local->op_errno = errno;
 
-                        goto err;
-                }
+            gf_smsg(this->name, GF_LOG_WARNING, errno,
+                    DHT_MSG_COMMIT_HASH_FAILED, "path=%s", local->loc.path,
+                    "subvol=%s", conf->local_subvols[i]->name,
+                    "extract-disk-layout-failed", NULL);
 
-                ret = dict_set_bin (xattr[i], conf->xattr_name,
-                                    disk_layout, 4 * 4);
-                if (ret != 0) {
-                        local->op_errno = ENOMEM;
+            goto err;
+        }
 
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory self heal xattr failed:"
-                                "%s: (subvol %s) Failed to set xattr"
-                                " dictionary,", local->loc.path,
-                                conf->local_subvols[i]->name);
+        xattr[i] = dict_new();
+        if (!xattr[i]) {
+            local->op_errno = errno;
 
-                        goto err;
-                }
-                disk_layout = NULL;
+            gf_smsg(this->name, GF_LOG_WARNING, errno,
+                    DHT_MSG_COMMIT_HASH_FAILED, "path=%s Allocation-failed",
+                    local->loc.path, NULL);
 
-                gf_msg_trace (this->name, 0,
-                              "setting commit hash %u on subvolume %s"
-                              " for %s", layout->list[j].commit_hash,
-                              conf->local_subvols[i]->name, local->loc.path);
+            goto err;
         }
 
-        /* wind the setting of the commit hash across the local subvols */
-        local->call_cnt = count;
-        local->op_ret = 0;
-        local->op_errno = 0;
-        for (i = 0; i < count; i++) {
-                STACK_WIND (frame, dht_update_commit_hash_for_layout_cbk,
-                            conf->local_subvols[i],
-                            conf->local_subvols[i]->fops->setxattr,
-                            &local->loc, xattr[i], 0, NULL);
+        ret = dict_set_bin(xattr[i], conf->xattr_name, disk_layout, 4 * 4);
+        if (ret != 0) {
+            local->op_errno = ENOMEM;
+
+            gf_smsg(this->name, GF_LOG_WARNING, 0,
+                    DHT_MSG_DIR_SELFHEAL_XATTR_FAILED, "path=%s",
+                    local->loc.path, "subvol=%s", conf->local_subvols[i]->name,
+                    "set-xattr-failed", NULL);
 
+            goto err;
         }
-        for (i = 0; i < count; i++)
-                dict_unref (xattr[i]);
-        GF_FREE (xattr);
+        disk_layout = NULL;
 
-        return 0;
+        gf_msg_trace(this->name, 0,
+                     "setting commit hash %u on subvolume %s"
+                     " for %s",
+                     layout->list[j].commit_hash, conf->local_subvols[i]->name,
+                     local->loc.path);
+    }
+
+    /* wind the setting of the commit hash across the local subvols */
+    local->call_cnt = count;
+    local->op_ret = 0;
+    local->op_errno = 0;
+    for (i = 0; i < count; i++) {
+        STACK_WIND(frame, dht_update_commit_hash_for_layout_cbk,
+                   conf->local_subvols[i],
+                   conf->local_subvols[i]->fops->setxattr, &local->loc,
+                   xattr[i], 0, NULL);
+    }
+    for (i = 0; i < count; i++)
+        dict_unref(xattr[i]);
+    GF_FREE(xattr);
+
+    return 0;
 err:
-        if (xattr) {
-                for (i = 0; i < count; i++) {
-                        if (xattr[i])
-                                dict_unref (xattr[i]);
-                }
-
-                GF_FREE (xattr);
+    if (xattr) {
+        for (i = 0; i < count; i++) {
+            if (xattr[i])
+                dict_unref(xattr[i]);
         }
 
-        GF_FREE (disk_layout);
+        GF_FREE(xattr);
+    }
 
-        local->op_ret = -1;
+    GF_FREE(disk_layout);
 
-        dht_update_commit_hash_for_layout_unlock (frame, this);
+    local->op_ret = -1;
 
-        return 0;
+    dht_update_commit_hash_for_layout_unlock(frame, this);
+
+    return 0;
 err_done:
-        local->op_ret = -1;
+    local->op_ret = -1;
 
-        dht_update_commit_hash_for_layout_done (frame, NULL, this, 0, 0, NULL);
+    dht_update_commit_hash_for_layout_done(frame, NULL, this, 0, 0, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* ENTER: dht_update_commit_hash_for_layout (see EXIT above)
@@ -2582,54 +2549,52 @@ err_done:
  *  - Unlock and return.
  */
 int
-dht_update_commit_hash_for_layout (call_frame_t *frame)
+dht_update_commit_hash_for_layout(call_frame_t *frame)
 {
-        dht_local_t   *local = NULL;
-        int            count = 1, ret = -1, i = 0;
-        dht_lock_t   **lk_array = NULL;
-        dht_conf_t    *conf = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
-
-        local = frame->local;
-        conf = frame->this->private;
-
-        if (!conf->defrag)
-                goto err;
-
-        count = conf->local_subvols_cnt;
-        lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                              gf_common_mt_char);
-        if (lk_array == NULL)
-                goto err;
-
-        for (i = 0; i < count; i++) {
-                lk_array[i] = dht_lock_new (frame->this,
-                                            conf->local_subvols[i],
-                                            &local->loc, F_WRLCK,
-                                            DHT_LAYOUT_HEAL_DOMAIN, NULL);
-                if (lk_array[i] == NULL)
-                        goto err;
-        }
-
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = count;
-
-        ret = dht_blocking_inodelk (frame, lk_array, count, FAIL_ON_ANY_ERROR,
-                                    dht_update_commit_hash_for_layout_resume);
-        if (ret < 0) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0;
+    dht_lock_t **lk_array = NULL;
+    dht_conf_t *conf = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
+
+    local = frame->local;
+    conf = frame->this->private;
+
+    if (!conf->defrag)
+        goto err;
+
+    count = conf->local_subvols_cnt;
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+    if (lk_array == NULL)
+        goto err;
+
+    for (i = 0; i < count; i++) {
+        lk_array[i] = dht_lock_new(frame->this, conf->local_subvols[i],
+                                   &local->loc, F_WRLCK, DHT_LAYOUT_HEAL_DOMAIN,
+                                   NULL, FAIL_ON_ANY_ERROR);
+        if (lk_array[i] == NULL)
+            goto err;
+    }
+
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = count;
+
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_update_commit_hash_for_layout_resume);
+    if (ret < 0) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
diff --git a/xlators/cluster/dht/src/dht-shared.c b/xlators/cluster/dht/src/dht-shared.c
index 0373ebffe5a..bb72b0ffbb5 100644
--- a/xlators/cluster/dht/src/dht-shared.c
+++ b/xlators/cluster/dht/src/dht-shared.c
@@ -8,1151 +8,1097 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
-#include "statedump.h"
+#include <glusterfs/statedump.h>
 #include "dht-common.h"
 #include "dht-messages.h"
 
 #ifndef MAX
-#define MAX(a, b) (((a) > (b))?(a):(b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
-#define GF_DECIDE_DEFRAG_THROTTLE_COUNT(throttle_count, conf) {         \
-                                                                        \
-                pthread_mutex_lock (&conf->defrag->dfq_mutex);          \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "lazy"))              \
-                        conf->defrag->recon_thread_count = 1;           \
-                                                                        \
-                throttle_count =                                        \
-                    MAX ((sysconf(_SC_NPROCESSORS_ONLN) - 4), 4);       \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "normal"))            \
-                        conf->defrag->recon_thread_count =              \
-                                                 (throttle_count / 2);  \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "aggressive"))        \
-                        conf->defrag->recon_thread_count =              \
-                                                 throttle_count;        \
-                                                                        \
-                pthread_mutex_unlock (&conf->defrag->dfq_mutex);        \
-        }                                                               \
-
 /* TODO:
    - use volumename in xattr instead of "dht"
    - use NS locks
    - handle all cases in self heal layout reconstruction
    - complete linkfile selfheal
 */
-struct volume_options options[];
-
-extern dht_methods_t dht_methods;
 
-void
-dht_layout_dump (dht_layout_t  *layout, const char *prefix)
+static void
+dht_layout_dump(dht_layout_t *layout, const char *prefix)
 {
-
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     i = 0;
-
-        if (!layout)
-                goto out;
-        if (!prefix)
-                goto out;
-
-        gf_proc_dump_build_key(key, prefix, "cnt");
-        gf_proc_dump_write(key, "%d", layout->cnt);
-        gf_proc_dump_build_key(key, prefix, "preset");
-        gf_proc_dump_write(key, "%d", layout->preset);
-        gf_proc_dump_build_key(key, prefix, "gen");
-        gf_proc_dump_write(key, "%d", layout->gen);
-        if (layout->type != IA_INVAL) {
-                gf_proc_dump_build_key(key, prefix, "inode type");
-                gf_proc_dump_write(key, "%d", layout->type);
-        }
-
-        if  (!IA_ISDIR (layout->type))
-                goto out;
-
-        for (i = 0; i < layout->cnt; i++) {
-                gf_proc_dump_build_key(key, prefix,"list[%d].err", i);
-                gf_proc_dump_write(key, "%d", layout->list[i].err);
-                gf_proc_dump_build_key(key, prefix,"list[%d].start", i);
-                gf_proc_dump_write(key, "%u", layout->list[i].start);
-                gf_proc_dump_build_key(key, prefix,"list[%d].stop", i);
-                gf_proc_dump_write(key, "%u", layout->list[i].stop);
-                if (layout->list[i].xlator) {
-                        gf_proc_dump_build_key(key, prefix,
-                                               "list[%d].xlator.type", i);
-                        gf_proc_dump_write(key, "%s",
-                                           layout->list[i].xlator->type);
-                        gf_proc_dump_build_key(key, prefix,
-                                               "list[%d].xlator.name", i);
-                        gf_proc_dump_write(key, "%s",
-                                           layout->list[i].xlator->name);
-                }
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+
+    if (!layout)
+        goto out;
+
+    gf_proc_dump_build_key(key, prefix, "cnt");
+    gf_proc_dump_write(key, "%d", layout->cnt);
+    gf_proc_dump_build_key(key, prefix, "preset");
+    gf_proc_dump_write(key, "%d", layout->preset);
+    gf_proc_dump_build_key(key, prefix, "gen");
+    gf_proc_dump_write(key, "%d", layout->gen);
+    if (layout->type != IA_INVAL) {
+        gf_proc_dump_build_key(key, prefix, "inode type");
+        gf_proc_dump_write(key, "%d", layout->type);
+    }
+
+    if (!IA_ISDIR(layout->type))
+        goto out;
+
+    for (i = 0; i < layout->cnt; i++) {
+        gf_proc_dump_build_key(key, prefix, "list[%d].err", i);
+        gf_proc_dump_write(key, "%d", layout->list[i].err);
+        gf_proc_dump_build_key(key, prefix, "list[%d].start", i);
+        gf_proc_dump_write(key, "0x%x", layout->list[i].start);
+        gf_proc_dump_build_key(key, prefix, "list[%d].stop", i);
+        gf_proc_dump_write(key, "0x%x", layout->list[i].stop);
+        if (layout->list[i].xlator) {
+            gf_proc_dump_build_key(key, prefix, "list[%d].xlator.type", i);
+            gf_proc_dump_write(key, "%s", layout->list[i].xlator->type);
+            gf_proc_dump_build_key(key, prefix, "list[%d].xlator.name", i);
+            gf_proc_dump_write(key, "%s", layout->list[i].xlator->name);
         }
+    }
 
 out:
-        return;
+    return;
 }
 
-
 int32_t
-dht_priv_dump (xlator_t *this)
+dht_priv_dump(xlator_t *this)
 {
-        char            key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char            key[GF_DUMP_MAX_BUF_LEN];
-        int             i = 0;
-        dht_conf_t      *conf = NULL;
-        int             ret = -1;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
 
-        if (!this)
-                goto out;
+    if (!this)
+        goto out;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        ret = TRY_LOCK(&conf->subvolume_lock);
-        if (ret != 0) {
-                return ret;
+    ret = TRY_LOCK(&conf->subvolume_lock);
+    if (ret != 0) {
+        return ret;
+    }
+
+    gf_proc_dump_add_section("xlator.cluster.dht.%s.priv", this->name);
+    gf_proc_dump_build_key(key_prefix, "xlator.cluster.dht", "%s.priv",
+                           this->name);
+    gf_proc_dump_write("subvol_cnt", "%d", conf->subvolume_cnt);
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        snprintf(key, sizeof(key), "subvolumes[%d]", i);
+        gf_proc_dump_write(key, "%s.%s", conf->subvolumes[i]->type,
+                           conf->subvolumes[i]->name);
+        if (conf->file_layouts && conf->file_layouts[i]) {
+            snprintf(key, sizeof(key), "file_layouts[%d]", i);
+            dht_layout_dump(conf->file_layouts[i], key);
         }
-
-        gf_proc_dump_add_section("xlator.cluster.dht.%s.priv", this->name);
-        gf_proc_dump_build_key(key_prefix,"xlator.cluster.dht","%s.priv",
-                               this->name);
-        gf_proc_dump_write("subvol_cnt","%d", conf->subvolume_cnt);
+        if (conf->dir_layouts && conf->dir_layouts[i]) {
+            snprintf(key, sizeof(key), "dir_layouts[%d]", i);
+            dht_layout_dump(conf->dir_layouts[i], key);
+        }
+        if (conf->subvolume_status) {
+            snprintf(key, sizeof(key), "subvolume_status[%d]", i);
+            gf_proc_dump_write(key, "%d", (int)conf->subvolume_status[i]);
+        }
+    }
+
+    gf_proc_dump_write("search_unhashed", "%d", conf->search_unhashed);
+    gf_proc_dump_write("gen", "%d", conf->gen);
+    gf_proc_dump_write("min_free_disk", "%lf", conf->min_free_disk);
+    gf_proc_dump_write("min_free_inodes", "%lf", conf->min_free_inodes);
+    gf_proc_dump_write("disk_unit", "%c", conf->disk_unit);
+    gf_proc_dump_write("refresh_interval", "%d", conf->refresh_interval);
+    gf_proc_dump_write("unhashed_sticky_bit", "%d", conf->unhashed_sticky_bit);
+    gf_proc_dump_write("use-readdirp", "%d", conf->use_readdirp);
+
+    if (conf->du_stats && conf->subvolume_status) {
         for (i = 0; i < conf->subvolume_cnt; i++) {
-                snprintf (key, sizeof (key), "subvolumes[%d]", i);
-                gf_proc_dump_write(key, "%s.%s", conf->subvolumes[i]->type,
-                                   conf->subvolumes[i]->name);
-                if (conf->file_layouts && conf->file_layouts[i]){
-                        snprintf (key, sizeof (key), "file_layouts[%d]", i);
-                        dht_layout_dump(conf->file_layouts[i], key);
-                }
-                if (conf->dir_layouts && conf->dir_layouts[i]) {
-                        snprintf (key, sizeof (key), "dir_layouts[%d]", i);
-                        dht_layout_dump(conf->dir_layouts[i], key);
-                }
-                if (conf->subvolume_status) {
-
-                        snprintf (key, sizeof (key), "subvolume_status[%d]", i);
-                        gf_proc_dump_write(key, "%d",
-                                           (int)conf->subvolume_status[i]);
-                }
+            if (!conf->subvolume_status[i])
+                continue;
 
-        }
+            snprintf(key, sizeof(key), "subvolumes[%d]", i);
+            gf_proc_dump_write(key, "%s", conf->subvolumes[i]->name);
+
+            snprintf(key, sizeof(key), "du_stats[%d].avail_percent", i);
+            gf_proc_dump_write(key, "%lf", conf->du_stats[i].avail_percent);
+
+            snprintf(key, sizeof(key), "du_stats[%d].avail_space", i);
+            gf_proc_dump_write(key, "%" PRIu64, conf->du_stats[i].avail_space);
 
-        gf_proc_dump_write("search_unhashed", "%d", conf->search_unhashed);
-        gf_proc_dump_write("gen", "%d", conf->gen);
-        gf_proc_dump_write("min_free_disk", "%lf", conf->min_free_disk);
-        gf_proc_dump_write("min_free_inodes", "%lf", conf->min_free_inodes);
-        gf_proc_dump_write("disk_unit", "%c", conf->disk_unit);
-        gf_proc_dump_write("refresh_interval", "%d", conf->refresh_interval);
-        gf_proc_dump_write("unhashed_sticky_bit", "%d", conf->unhashed_sticky_bit);
-        gf_proc_dump_write("use-readdirp", "%d", conf->use_readdirp);
-
-        if (conf->du_stats && conf->subvolume_status) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (!conf->subvolume_status[i])
-                                continue;
-
-                        snprintf (key, sizeof (key), "subvolumes[%d]", i);
-                        gf_proc_dump_write (key, "%s",
-                                            conf->subvolumes[i]->name);
-
-                        snprintf (key, sizeof (key),
-                                  "du_stats[%d].avail_percent", i);
-                        gf_proc_dump_write (key, "%lf",
-                                            conf->du_stats[i].avail_percent);
-
-                        snprintf (key, sizeof (key), "du_stats[%d].avail_space",
-                                  i);
-                        gf_proc_dump_write (key, "%lu",
-                                            conf->du_stats[i].avail_space);
-
-                        snprintf (key, sizeof (key),
-                                  "du_stats[%d].avail_inodes", i);
-                        gf_proc_dump_write (key, "%lf",
-                                            conf->du_stats[i].avail_inodes);
-
-                        snprintf (key, sizeof (key), "du_stats[%d].log", i);
-                        gf_proc_dump_write (key, "%lu",
-                                            conf->du_stats[i].log);
-                }
+            snprintf(key, sizeof(key), "du_stats[%d].avail_inodes", i);
+            gf_proc_dump_write(key, "%lf", conf->du_stats[i].avail_inodes);
+
+            snprintf(key, sizeof(key), "du_stats[%d].log", i);
+            gf_proc_dump_write(key, "%" PRIu32, conf->du_stats[i].log);
         }
+    }
 
-        if (conf->last_stat_fetch.tv_sec)
-                gf_proc_dump_write("last_stat_fetch", "%s",
-                                    ctime(&conf->last_stat_fetch.tv_sec));
+    if (conf->last_stat_fetch)
+        gf_proc_dump_write("last_stat_fetch", "%s",
+                           ctime(&conf->last_stat_fetch));
 
-        UNLOCK(&conf->subvolume_lock);
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_inodectx_dump (xlator_t *this, inode_t *inode)
+dht_inodectx_dump(xlator_t *this, inode_t *inode)
 {
-        int             ret = -1;
-        dht_layout_t    *layout = NULL;
+    int ret = -1;
+    dht_layout_t *layout = NULL;
 
-        if (!this)
-                goto out;
-        if (!inode)
-                goto out;
+    if (!this)
+        goto out;
+    if (!inode)
+        goto out;
 
-        ret = dht_inode_ctx_layout_get (inode, this, &layout);
+    ret = dht_inode_ctx_layout_get(inode, this, &layout);
 
-        if ((ret != 0) || !layout)
-                return ret;
+    if ((ret != 0) || !layout)
+        return ret;
 
-        gf_proc_dump_add_section("xlator.cluster.dht.%s.inode", this->name);
-        dht_layout_dump(layout, "layout");
+    gf_proc_dump_add_section("xlator.cluster.dht.%s.inode", this->name);
+    dht_layout_dump(layout, "layout");
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-dht_fini (xlator_t *this)
+dht_fini(xlator_t *this)
 {
-        int         i = 0;
-        dht_conf_t *conf = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
+    int i = 0;
+    dht_conf_t *conf = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+
+    conf = this->private;
+    this->private = NULL;
+    if (conf) {
+        if (conf->file_layouts) {
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                GF_FREE(conf->file_layouts[i]);
+            }
+            GF_FREE(conf->file_layouts);
+        }
 
-        conf = this->private;
-        this->private = NULL;
-        if (conf) {
-                if (conf->file_layouts) {
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                GF_FREE (conf->file_layouts[i]);
-                        }
-                        GF_FREE (conf->file_layouts);
-                }
+        dict_unref(conf->leaf_to_subvol);
 
-                dict_unref(conf->leaf_to_subvol);
+        /* allocated in dht_init_subvolumes() */
+        GF_FREE(conf->subvolumes);
+        GF_FREE(conf->subvolume_status);
+        GF_FREE(conf->last_event);
+        GF_FREE(conf->subvol_up_time);
+        GF_FREE(conf->du_stats);
+        GF_FREE(conf->decommissioned_bricks);
 
-                GF_FREE (conf->subvolumes);
+        /* allocated in dht_init() */
+        GF_FREE(conf->mds_xattr_key);
+        GF_FREE(conf->link_xattr_name);
+        GF_FREE(conf->commithash_xattr_name);
+        GF_FREE(conf->wild_xattr_name);
 
-                GF_FREE (conf->subvolume_status);
+        /* allocated in dht_init_regex() */
+        if (conf->rsync_regex_valid)
+            regfree(&conf->rsync_regex);
+        if (conf->extra_regex_valid)
+            regfree(&conf->extra_regex);
 
-                synclock_destroy (&conf->link_lock);
+        synclock_destroy(&conf->link_lock);
 
-                if (conf->lock_pool)
-                        mem_pool_destroy (conf->lock_pool);
+        if (conf->lock_pool)
+            mem_pool_destroy(conf->lock_pool);
 
-                GF_FREE (conf);
-        }
+        GF_FREE(conf);
+    }
 out:
-        return;
+    return;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
 
-        ret = xlator_mem_acct_init (this, gf_dht_mt_end + 1);
+    ret = xlator_mem_acct_init(this, gf_dht_mt_end + 1);
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Memory accounting init failed");
-                return ret;
-        }
-out:
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+               "Memory accounting init failed");
         return ret;
+    }
+out:
+    return ret;
 }
 
-
-int
-dht_parse_decommissioned_bricks (xlator_t *this, dht_conf_t *conf,
-                                 const char *bricks)
+static int
+dht_parse_decommissioned_bricks(xlator_t *this, dht_conf_t *conf,
+                                const char *bricks)
 {
-        int         i  = 0;
-        int         ret  = -1;
-        char       *tmpstr = NULL;
-        char       *dup_brick = NULL;
-        char       *node = NULL;
-
-        if (!conf || !bricks)
-                goto out;
-
-        dup_brick = gf_strdup (bricks);
-        node = strtok_r (dup_brick, ",", &tmpstr);
-        while (node) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (!strcmp (conf->subvolumes[i]->name, node)) {
-                                conf->decommissioned_bricks[i] =
-                                        conf->subvolumes[i];
-                                        conf->decommission_subvols_cnt++;
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_SUBVOL_DECOMMISSION_INFO,
-                                        "decommissioning subvolume %s",
-                                        conf->subvolumes[i]->name);
-                                break;
-                        }
-                }
-                if (i == conf->subvolume_cnt) {
-                        /* Wrong node given. */
-                        goto out;
-                }
-                node = strtok_r (NULL, ",", &tmpstr);
+    int i = 0;
+    int ret = -1;
+    char *tmpstr = NULL;
+    char *dup_brick = NULL;
+    char *node = NULL;
+
+    if (!conf || !bricks)
+        goto out;
+
+    dup_brick = gf_strdup(bricks);
+    if (dup_brick == NULL) {
+        goto out;
+    }
+
+    node = strtok_r(dup_brick, ",", &tmpstr);
+    while (node) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (!strcmp(conf->subvolumes[i]->name, node)) {
+                conf->decommissioned_bricks[i] = conf->subvolumes[i];
+                conf->decommission_subvols_cnt++;
+                gf_msg(this->name, GF_LOG_INFO, 0,
+                       DHT_MSG_SUBVOL_DECOMMISSION_INFO,
+                       "decommissioning subvolume %s",
+                       conf->subvolumes[i]->name);
+                break;
+            }
         }
+        if (i == conf->subvolume_cnt) {
+            /* Wrong node given. */
+            goto out;
+        }
+        node = strtok_r(NULL, ",", &tmpstr);
+    }
 
-        ret = 0;
-        conf->decommission_in_progress = 1;
+    ret = 0;
+    conf->decommission_in_progress = 1;
 out:
-        GF_FREE (dup_brick);
+    GF_FREE(dup_brick);
 
-        return ret;
+    return ret;
 }
 
-int
-dht_decommissioned_remove (xlator_t *this, dht_conf_t *conf)
+static void
+dht_decommissioned_remove(xlator_t *this, dht_conf_t *conf)
 {
-        int         i  = 0;
-        int         ret  = -1;
-
-        if (!conf)
-                goto out;
+    int i = 0;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i]) {
-                        conf->decommissioned_bricks[i] = NULL;
-                        conf->decommission_subvols_cnt--;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->decommissioned_bricks[i]) {
+            conf->decommissioned_bricks[i] = NULL;
+            conf->decommission_subvols_cnt--;
         }
-
-        ret = 0;
-out:
-
-        return ret;
+    }
 }
-void
-dht_init_regex (xlator_t *this, dict_t *odict, char *name,
-                regex_t *re, gf_boolean_t *re_valid, dht_conf_t *conf)
+
+static void
+dht_init_regex(xlator_t *this, dict_t *odict, char *name, regex_t *re,
+               gf_boolean_t *re_valid, dht_conf_t *conf)
 {
-        char       *temp_str = NULL;
+    char *temp_str = NULL;
 
-        if (dict_get_str (odict, name, &temp_str) != 0) {
-                if (strcmp(name,"rsync-hash-regex")) {
-                        return;
-                }
-                temp_str = "^\\.(.+)\\.[^.]+$";
+    if (dict_get_str(odict, name, &temp_str) != 0) {
+        if (strcmp(name, "rsync-hash-regex")) {
+            return;
+        }
+        temp_str = "^\\.(.+)\\.[^.]+$";
+    }
+
+    LOCK(&conf->lock);
+    {
+        if (*re_valid) {
+            regfree(re);
+            *re_valid = _gf_false;
         }
 
-        LOCK (&conf->lock);
-        {
-                if (*re_valid) {
-                        regfree(re);
-                        *re_valid = _gf_false;
-                }
-
-                if (!strcmp(temp_str, "none")) {
-                        goto unlock;
-                }
-
-                if (regcomp(re, temp_str, REG_EXTENDED) == 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "using regex %s = %s", name, temp_str);
-                        *re_valid = _gf_true;
-                } else {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_REGEX_INFO,
-                                "compiling regex %s failed", temp_str);
-                }
+        if (!strcmp(temp_str, "none")) {
+            goto unlock;
         }
+
+        if (regcomp(re, temp_str, REG_EXTENDED) == 0) {
+            gf_msg_debug(this->name, 0, "using regex %s = %s", name, temp_str);
+            *re_valid = _gf_true;
+        } else {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_REGEX_INFO,
+                   "compiling regex %s failed", temp_str);
+        }
+    }
 unlock:
-        UNLOCK (&conf->lock);
+    UNLOCK(&conf->lock);
 }
 
 int
 dht_set_subvol_range(xlator_t *this)
 {
-        int ret = -1;
-        dht_conf_t *conf = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!conf)
-                goto out;
+    if (!conf)
+        goto out;
 
-        conf->leaf_to_subvol = dict_new();
-        if (!conf->leaf_to_subvol)
-                goto out;
+    conf->leaf_to_subvol = dict_new();
+    if (!conf->leaf_to_subvol)
+        goto out;
 
-        ret = glusterfs_reachable_leaves(this, conf->leaf_to_subvol);
+    ret = glusterfs_reachable_leaves(this, conf->leaf_to_subvol);
 
 out:
-        return ret;
+    return ret;
 }
 
-int
-dht_configure_throttle (xlator_t *this, dht_conf_t *conf, char *temp_str)
+static int
+dht_configure_throttle(xlator_t *this, dht_conf_t *conf, char *temp_str)
 {
-        int     rebal_thread_count      = 0;
-        int     ret                     = 0;
-
-        pthread_mutex_lock (&conf->defrag->dfq_mutex);
-        {
-        if (!strcasecmp (temp_str, "lazy")) {
-                conf->defrag->recon_thread_count = 1;
-        } else if (!strcasecmp (temp_str, "normal")) {
-                conf->defrag->recon_thread_count = 2;
-        } else if (!strcasecmp (temp_str, "aggressive")) {
-                conf->defrag->recon_thread_count = MAX (MAX_REBAL_THREADS - 4, 4);
-        } else if ((gf_string2int (temp_str, &rebal_thread_count) == 0)) {
-                if ((rebal_thread_count > 0) && (rebal_thread_count <= MAX_REBAL_THREADS)) {
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                                "rebal thread count configured to %d",
-                                rebal_thread_count);
-                                conf->defrag->recon_thread_count = rebal_thread_count;
-                } else {
-                        gf_msg(this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION,
-                                "Invalid option: Reconfigure: "
-                                "rebal-throttle should be "
-                                "within range of 0 and maximum number of"
-                                " cores available");
-                                ret = -1;
-                                pthread_mutex_unlock (&conf->defrag->dfq_mutex);
-                                goto out;
-                }
+    int rebal_thread_count = 0;
+    int ret = 0;
+
+    pthread_mutex_lock(&conf->defrag->dfq_mutex);
+    {
+        if (!strcasecmp(temp_str, "lazy")) {
+            conf->defrag->recon_thread_count = 1;
+        } else if (!strcasecmp(temp_str, "normal")) {
+            conf->defrag->recon_thread_count = 2;
+        } else if (!strcasecmp(temp_str, "aggressive")) {
+            conf->defrag->recon_thread_count = MAX(MAX_REBAL_THREADS - 4, 4);
+        } else if ((gf_string2int(temp_str, &rebal_thread_count) == 0)) {
+            if ((rebal_thread_count > 0) &&
+                (rebal_thread_count <= MAX_REBAL_THREADS)) {
+                conf->defrag->recon_thread_count = rebal_thread_count;
+                pthread_mutex_unlock(&conf->defrag->dfq_mutex);
+                gf_msg(this->name, GF_LOG_INFO, 0, 0,
+                       "rebal thread count configured to %d",
+                       rebal_thread_count);
+                goto out;
+            } else {
+                pthread_mutex_unlock(&conf->defrag->dfq_mutex);
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option: Reconfigure: "
+                       "rebal-throttle should be "
+                       "within range of 0 and maximum number of"
+                       " cores available");
+                ret = -1;
+                goto out;
+            }
         } else {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_INVALID_OPTION,
-                        "Invalid option: Reconfigure: "
-                        "rebal-throttle should be {lazy|normal|aggressive}"
-                        " or a number up to the number of cores available,"
-                        " not (%s), defaulting to (%d)",
-                        temp_str, conf->dthrottle);
-                        ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option: Reconfigure: "
+                   "rebal-throttle should be {lazy|normal|aggressive}"
+                   " or a number up to the number of cores available,"
+                   " not (%s), defaulting to (%d)",
+                   temp_str, conf->dthrottle);
+            ret = -1;
         }
-        }
-        pthread_mutex_unlock (&conf->defrag->dfq_mutex);
+    }
+    pthread_mutex_unlock(&conf->defrag->dfq_mutex);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_reconfigure (xlator_t *this, dict_t *options)
+dht_reconfigure(xlator_t *this, dict_t *options)
 {
-        dht_conf_t      *conf = NULL;
-        char            *temp_str = NULL;
-        gf_boolean_t     search_unhashed;
-        int              ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", options, out);
-
-        conf = this->private;
-        if (!conf)
-                return 0;
-
-        if (dict_get_str (options, "lookup-unhashed", &temp_str) == 0) {
-                /* If option is not "auto", other options _should_ be boolean*/
-                if (strcasecmp (temp_str, "auto")) {
-                        if (!gf_string2boolean (temp_str, &search_unhashed)) {
-                                gf_msg_debug(this->name, 0, "Reconfigure: "
-                                             "lookup-unhashed reconfigured(%s)",
-                                             temp_str);
-                                conf->search_unhashed = search_unhashed;
-                        } else {
-                                gf_msg(this->name, GF_LOG_ERROR, 0,
-                                       DHT_MSG_INVALID_OPTION,
-                                       "Invalid option: Reconfigure: "
-                                       "lookup-unhashed should be boolean,"
-                                       " not (%s), defaulting to (%d)",
-                                       temp_str, conf->search_unhashed);
-                                ret = -1;
-                                goto out;
-                        }
-                } else {
-                        gf_msg_debug(this->name, 0, "Reconfigure:"
-                                     " lookup-unhashed reconfigured auto ");
-                        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
-                }
-        }
+    dht_conf_t *conf = NULL;
+    char *temp_str = NULL;
+    gf_boolean_t search_unhashed;
+    int ret = -1;
 
-        GF_OPTION_RECONF ("lookup-optimize", conf->lookup_optimize, options,
-                          bool, out);
-
-        GF_OPTION_RECONF ("min-free-disk", conf->min_free_disk, options,
-                          percent_or_size, out);
-        /* option can be any one of percent or bytes */
-        conf->disk_unit = 0;
-        if (conf->min_free_disk < 100.0)
-                conf->disk_unit = 'p';
-
-        GF_OPTION_RECONF ("min-free-inodes", conf->min_free_inodes, options,
-                          percent, out);
-
-        GF_OPTION_RECONF ("directory-layout-spread", conf->dir_spread_cnt,
-                          options, uint32, out);
-
-        GF_OPTION_RECONF ("readdir-optimize", conf->readdir_optimize, options,
-                          bool, out);
-        GF_OPTION_RECONF ("randomize-hash-range-by-gfid",
-                          conf->randomize_by_gfid,
-                          options, bool, out);
-
-        GF_OPTION_RECONF ("lock-migration", conf->lock_migration_enabled,
-                          options, bool, out);
-
-        if (conf->defrag) {
-                if (dict_get_str (options, "rebal-throttle", &temp_str) == 0) {
-                        ret = dht_configure_throttle (this, conf, temp_str);
-                        if (ret == -1)
-                                goto out;
-                }
-        }
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", options, out);
 
-        if (conf->defrag) {
-                conf->defrag->lock_migration_enabled =
-                                        conf->lock_migration_enabled;
-        }
-
-        if (conf->defrag) {
-                GF_OPTION_RECONF ("rebalance-stats", conf->defrag->stats,
-                                  options, bool, out);
-        }
+    conf = this->private;
+    if (!conf)
+        return 0;
 
-        if (dict_get_str (options, "decommissioned-bricks", &temp_str) == 0) {
-                ret = dht_parse_decommissioned_bricks (this, conf, temp_str);
-                if (ret == -1)
-                        goto out;
+    if (dict_get_str(options, "lookup-unhashed", &temp_str) == 0) {
+        /* If option is not "auto", other options _should_ be boolean*/
+        if (strcasecmp(temp_str, "auto")) {
+            if (!gf_string2boolean(temp_str, &search_unhashed)) {
+                gf_msg_debug(this->name, 0,
+                             "Reconfigure: "
+                             "lookup-unhashed reconfigured(%s)",
+                             temp_str);
+                conf->search_unhashed = search_unhashed;
+            } else {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option: Reconfigure: "
+                       "lookup-unhashed should be boolean,"
+                       " not (%s), defaulting to (%d)",
+                       temp_str, conf->search_unhashed);
+                ret = -1;
+                goto out;
+            }
         } else {
-                ret = dht_decommissioned_remove (this, conf);
-                if (ret == -1)
-                        goto out;
+            gf_msg_debug(this->name, 0,
+                         "Reconfigure:"
+                         " lookup-unhashed reconfigured auto ");
+            conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
         }
+    }
+
+    GF_OPTION_RECONF("lookup-optimize", conf->lookup_optimize, options, bool,
+                     out);
+
+    GF_OPTION_RECONF("min-free-disk", conf->min_free_disk, options,
+                     percent_or_size, out);
+    /* option can be any one of percent or bytes */
+    conf->disk_unit = 0;
+    if (conf->min_free_disk < 100.0)
+        conf->disk_unit = 'p';
+
+    GF_OPTION_RECONF("min-free-inodes", conf->min_free_inodes, options, percent,
+                     out);
+
+    GF_OPTION_RECONF("directory-layout-spread", conf->dir_spread_cnt, options,
+                     uint32, out);
 
-        dht_init_regex (this, options, "rsync-hash-regex",
-                        &conf->rsync_regex, &conf->rsync_regex_valid, conf);
-        dht_init_regex (this, options, "extra-hash-regex",
-                        &conf->extra_regex, &conf->extra_regex_valid, conf);
+    GF_OPTION_RECONF("readdir-optimize", conf->readdir_optimize, options, bool,
+                     out);
+    GF_OPTION_RECONF("randomize-hash-range-by-gfid", conf->randomize_by_gfid,
+                     options, bool, out);
 
-        GF_OPTION_RECONF ("weighted-rebalance", conf->do_weighting, options,
-                          bool, out);
+    GF_OPTION_RECONF("lock-migration", conf->lock_migration_enabled, options,
+                     bool, out);
 
-        GF_OPTION_RECONF ("use-readdirp", conf->use_readdirp, options,
-                          bool, out);
-        ret = 0;
+    GF_OPTION_RECONF("force-migration", conf->force_migration, options, bool,
+                     out);
+
+    if (conf->defrag) {
+        if (dict_get_str(options, "rebal-throttle", &temp_str) == 0) {
+            ret = dht_configure_throttle(this, conf, temp_str);
+            if (ret == -1)
+                goto out;
+        }
+    }
+
+    if (conf->defrag) {
+        conf->defrag->lock_migration_enabled = conf->lock_migration_enabled;
+    }
+
+    if (conf->defrag) {
+        GF_OPTION_RECONF("rebalance-stats", conf->defrag->stats, options, bool,
+                         out);
+    }
+
+    if (dict_get_str(options, "decommissioned-bricks", &temp_str) == 0) {
+        ret = dht_parse_decommissioned_bricks(this, conf, temp_str);
+        if (ret == -1)
+            goto out;
+    } else {
+        dht_decommissioned_remove(this, conf);
+    }
+
+    dht_init_regex(this, options, "rsync-hash-regex", &conf->rsync_regex,
+                   &conf->rsync_regex_valid, conf);
+    dht_init_regex(this, options, "extra-hash-regex", &conf->extra_regex,
+                   &conf->extra_regex_valid, conf);
+
+    GF_OPTION_RECONF("weighted-rebalance", conf->do_weighting, options, bool,
+                     out);
+
+    GF_OPTION_RECONF("use-readdirp", conf->use_readdirp, options, bool, out);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_defrag_pattern_list_fill (xlator_t *this, gf_defrag_info_t *defrag, char *data)
+gf_defrag_pattern_list_fill(xlator_t *this, gf_defrag_info_t *defrag,
+                            char *data)
 {
-        int                    ret = -1;
-        char                  *tmp_str = NULL;
-        char                  *tmp_str1 = NULL;
-        char                  *dup_str = NULL;
-        char                  *num = NULL;
-        char                  *pattern_str = NULL;
-        char                  *pattern = NULL;
-        gf_defrag_pattern_list_t *temp_list = NULL;
-        gf_defrag_pattern_list_t *pattern_list = NULL;
-
-        if (!this || !defrag || !data)
-                goto out;
-
-        /* Get the pattern for pattern list. "pattern:<optional-size>"
-         * eg: *avi, *pdf:10MB, *:1TB
-         */
-        pattern_str = strtok_r (data, ",", &tmp_str);
-        while (pattern_str) {
-                dup_str = gf_strdup (pattern_str);
-                pattern_list = GF_CALLOC (1, sizeof (gf_defrag_pattern_list_t),
-                                        1);
-                if (!pattern_list) {
-                        goto out;
-                }
-                pattern = strtok_r (dup_str, ":", &tmp_str1);
-                num = strtok_r (NULL, ":", &tmp_str1);
-                if (!pattern)
-                        goto out;
-                if (!num) {
-                        if (gf_string2bytesize_uint64(pattern, &pattern_list->size)
-                             == 0) {
-                                pattern = "*";
-                        }
-                } else if (gf_string2bytesize_uint64 (num, &pattern_list->size) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION,
-                                "Invalid option. Defrag pattern:"
-                                " Invalid number format \"%s\"", num);
-                        goto out;
-                }
-                memcpy (pattern_list->path_pattern, pattern, strlen (dup_str));
-
-                if (!defrag->defrag_pattern)
-                        temp_list = NULL;
-                else
-                        temp_list = defrag->defrag_pattern;
-
-                pattern_list->next = temp_list;
-
-                defrag->defrag_pattern = pattern_list;
-                pattern_list = NULL;
-
-                GF_FREE (dup_str);
-                dup_str = NULL;
-
-                pattern_str = strtok_r (NULL, ",", &tmp_str);
+    int ret = -1;
+    char *tmp_str = NULL;
+    char *tmp_str1 = NULL;
+    char *dup_str = NULL;
+    char *num = NULL;
+    char *pattern_str = NULL;
+    char *pattern = NULL;
+    gf_defrag_pattern_list_t *temp_list = NULL;
+    gf_defrag_pattern_list_t *pattern_list = NULL;
+
+    if (!this || !defrag || !data)
+        goto out;
+
+    /* Get the pattern for pattern list. "pattern:<optional-size>"
+     * eg: *avi, *pdf:10MB, *:1TB
+     */
+    pattern_str = strtok_r(data, ",", &tmp_str);
+    while (pattern_str) {
+        dup_str = gf_strdup(pattern_str);
+        if (!dup_str)
+            goto out;
+        pattern_list = GF_CALLOC(1, sizeof(gf_defrag_pattern_list_t), 1);
+        if (!pattern_list) {
+            goto out;
         }
+        pattern = strtok_r(dup_str, ":", &tmp_str1);
+        num = strtok_r(NULL, ":", &tmp_str1);
+        if (!pattern)
+            goto out;
+        if (!num) {
+            if (gf_string2bytesize_uint64(pattern, &pattern_list->size) == 0) {
+                pattern = "*";
+            }
+        } else if (gf_string2bytesize_uint64(num, &pattern_list->size) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option. Defrag pattern:"
+                   " Invalid number format \"%s\"",
+                   num);
+            goto out;
+        }
+        memcpy(pattern_list->path_pattern, pattern, strlen(dup_str));
 
-        ret = 0;
-out:
-        if (ret)
-                GF_FREE (pattern_list);
-        GF_FREE (dup_str);
+        if (!defrag->defrag_pattern)
+            temp_list = NULL;
+        else
+            temp_list = defrag->defrag_pattern;
 
-        return ret;
-}
+        pattern_list->next = temp_list;
 
+        defrag->defrag_pattern = pattern_list;
+        pattern_list = NULL;
 
+        GF_FREE(dup_str);
+        dup_str = NULL;
 
-int
-dht_init_methods (xlator_t *this)
+        pattern_str = strtok_r(NULL, ",", &tmp_str);
+    }
+
+    ret = 0;
+out:
+    if (ret)
+        GF_FREE(pattern_list);
+    GF_FREE(dup_str);
+
+    return ret;
+}
+
+static int
+dht_init_methods(xlator_t *this)
 {
-        int ret                  = -1;
-        dht_conf_t      *conf    = NULL;
-        dht_methods_t   *methods = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
 
-        conf = this->private;
-        methods = &(conf->methods);
+    conf = this->private;
+    methods = &(conf->methods);
 
-        methods->migration_get_dst_subvol = dht_migration_get_dst_subvol;
-        methods->migration_needed = dht_migration_needed;
-        methods->migration_other  = NULL;
-        methods->layout_search    = dht_layout_search;
+    methods->migration_get_dst_subvol = dht_migration_get_dst_subvol;
+    methods->migration_other = NULL;
+    methods->layout_search = dht_layout_search;
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-dht_init (xlator_t *this)
+dht_init(xlator_t *this)
 {
-        dht_conf_t                      *conf           = NULL;
-        char                            *temp_str       = NULL;
-        int                              ret            = -1;
-        int                              i              = 0;
-        gf_defrag_info_t                *defrag         = NULL;
-        int                              cmd            = 0;
-        char                            *node_uuid      = NULL;
-        uint32_t                         commit_hash    = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-
-        if (!this->children) {
-                gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_INVALID_CONFIGURATION,
-                        "Distribute needs more than one subvolume");
-                return -1;
-        }
-
-        if (!this->parents) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_INVALID_CONFIGURATION,
-                        "dangling volume. check volfile");
-        }
+    dht_conf_t *conf = NULL;
+    char *temp_str = NULL;
+    int ret = -1;
+    int i = 0;
+    gf_defrag_info_t *defrag = NULL;
+    int cmd = 0;
+    char *node_uuid = NULL;
+    uint32_t commit_hash = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+
+    if (!this->children) {
+        gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_INVALID_CONFIGURATION,
+               "Distribute needs more than one subvolume");
+        return -1;
+    }
 
-        conf = GF_CALLOC (1, sizeof (*conf), gf_dht_mt_dht_conf_t);
-        if (!conf) {
-                goto err;
-        }
+    if (!this->parents) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_CONFIGURATION,
+               "dangling volume. check volfile");
+    }
 
-        LOCK_INIT (&conf->subvolume_lock);
-        LOCK_INIT (&conf->layout_lock);
-        LOCK_INIT (&conf->lock);
-        synclock_init (&conf->link_lock, SYNC_LOCK_DEFAULT);
-
-        /* We get the commit-hash to set only for rebalance process */
-        if (dict_get_uint32 (this->options,
-                             "commit-hash", &commit_hash) == 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_COMMIT_HASH_INFO, "%s using commit hash %u",
-                        __func__, commit_hash);
-                conf->vol_commit_hash = commit_hash;
-                conf->vch_forced = _gf_true;
-        }
+    conf = GF_CALLOC(1, sizeof(*conf), gf_dht_mt_dht_conf_t);
+    if (!conf) {
+        goto err;
+    }
 
-        ret = dict_get_int32 (this->options, "rebalance-cmd", &cmd);
+    LOCK_INIT(&conf->subvolume_lock);
+    LOCK_INIT(&conf->layout_lock);
+    LOCK_INIT(&conf->lock);
+    synclock_init(&conf->link_lock, SYNC_LOCK_DEFAULT);
 
-        if (cmd) {
-                defrag = GF_CALLOC (1, sizeof (gf_defrag_info_t),
-                                    gf_defrag_info_mt);
+    /* We get the commit-hash to set only for rebalance process */
+    if (dict_get_uint32(this->options, "commit-hash", &commit_hash) == 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_COMMIT_HASH_INFO,
+               "%s using commit hash %u", __func__, commit_hash);
+        conf->vol_commit_hash = commit_hash;
+        conf->vch_forced = _gf_true;
+    }
 
-                GF_VALIDATE_OR_GOTO (this->name, defrag, err);
+    ret = dict_get_int32(this->options, "rebalance-cmd", &cmd);
 
-                LOCK_INIT (&defrag->lock);
+    if (cmd) {
+        defrag = GF_CALLOC(1, sizeof(gf_defrag_info_t), gf_defrag_info_mt);
 
-                defrag->is_exiting = 0;
+        GF_VALIDATE_OR_GOTO(this->name, defrag, err);
 
-                conf->defrag = defrag;
-                defrag->this = this;
+        LOCK_INIT(&defrag->lock);
 
-                ret = dict_get_str (this->options, "node-uuid", &node_uuid);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_CONFIGURATION,
-                                "Invalid volume configuration: "
-                                "node-uuid not specified");
-                        goto err;
-                }
+        defrag->is_exiting = 0;
 
-                if (gf_uuid_parse (node_uuid, defrag->node_uuid)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION, "Invalid option:"
-                                " Cannot parse glusterd node uuid");
-                        goto err;
-                }
+        conf->defrag = defrag;
+        defrag->this = this;
 
-                defrag->cmd = cmd;
+        ret = dict_get_str(this->options, "node-uuid", &node_uuid);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_CONFIGURATION,
+                   "Invalid volume configuration: "
+                   "node-uuid not specified");
+            goto err;
+        }
 
-                defrag->stats = _gf_false;
+        if (gf_uuid_parse(node_uuid, defrag->node_uuid)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option:"
+                   " Cannot parse glusterd node uuid");
+            goto err;
+        }
 
-                defrag->queue = NULL;
+        defrag->cmd = cmd;
 
-                defrag->crawl_done = 0;
+        defrag->stats = _gf_false;
 
-                defrag->global_error = 0;
+        defrag->queue = NULL;
 
-                defrag->q_entry_count = 0;
+        defrag->crawl_done = 0;
 
-                defrag->wakeup_crawler = 0;
+        defrag->global_error = 0;
 
-                pthread_mutex_init (&defrag->dfq_mutex, 0);
-                pthread_cond_init  (&defrag->parallel_migration_cond, 0);
-                pthread_cond_init  (&defrag->rebalance_crawler_alarm, 0);
-                pthread_cond_init  (&defrag->df_wakeup_thread, 0);
+        defrag->q_entry_count = 0;
 
-                pthread_mutex_init (&defrag->fc_mutex, 0);
-                pthread_cond_init  (&defrag->fc_wakeup_cond, 0);
+        defrag->wakeup_crawler = 0;
 
-                defrag->global_error = 0;
+        pthread_mutex_init(&defrag->dfq_mutex, 0);
+        pthread_cond_init(&defrag->parallel_migration_cond, 0);
+        pthread_cond_init(&defrag->rebalance_crawler_alarm, 0);
+        pthread_cond_init(&defrag->df_wakeup_thread, 0);
 
-        }
+        pthread_mutex_init(&defrag->fc_mutex, 0);
+        pthread_cond_init(&defrag->fc_wakeup_cond, 0);
 
-        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_ON;
-        if (dict_get_str (this->options, "lookup-unhashed", &temp_str) == 0) {
-                /* If option is not "auto", other options _should_ be boolean */
-                if (strcasecmp (temp_str, "auto")) {
-                        ret = gf_string2boolean (temp_str,
-                                                 &conf->search_unhashed);
-                        if (ret == -1)
-                                goto err;
-                }
-                else
-                        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
-        }
+        defrag->global_error = 0;
+    }
 
-        GF_OPTION_INIT ("lookup-optimize", conf->lookup_optimize, bool, err);
+    conf->use_fallocate = 1;
 
-        GF_OPTION_INIT ("unhashed-sticky-bit", conf->unhashed_sticky_bit, bool,
-                        err);
+    conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_ON;
+    if (dict_get_str(this->options, "lookup-unhashed", &temp_str) == 0) {
+        /* If option is not "auto", other options _should_ be boolean */
+        if (strcasecmp(temp_str, "auto")) {
+            gf_boolean_t search_unhashed_bool;
+            ret = gf_string2boolean(temp_str, &search_unhashed_bool);
+            if (ret == -1) {
+                goto err;
+            }
+            conf->search_unhashed = search_unhashed_bool
+                                        ? GF_DHT_LOOKUP_UNHASHED_ON
+                                        : GF_DHT_LOOKUP_UNHASHED_OFF;
+        } else {
+            conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
+        }
+    }
 
-        GF_OPTION_INIT ("use-readdirp", conf->use_readdirp, bool, err);
+    GF_OPTION_INIT("lookup-optimize", conf->lookup_optimize, bool, err);
 
-        GF_OPTION_INIT ("min-free-disk", conf->min_free_disk, percent_or_size,
-                        err);
+    GF_OPTION_INIT("unhashed-sticky-bit", conf->unhashed_sticky_bit, bool, err);
 
-        GF_OPTION_INIT ("min-free-inodes", conf->min_free_inodes, percent,
-                        err);
+    GF_OPTION_INIT("use-readdirp", conf->use_readdirp, bool, err);
 
-        conf->dir_spread_cnt = conf->subvolume_cnt;
-        GF_OPTION_INIT ("directory-layout-spread", conf->dir_spread_cnt,
-                        uint32, err);
+    GF_OPTION_INIT("min-free-disk", conf->min_free_disk, percent_or_size, err);
 
-        GF_OPTION_INIT ("assert-no-child-down", conf->assert_no_child_down,
-                        bool, err);
+    GF_OPTION_INIT("min-free-inodes", conf->min_free_inodes, percent, err);
 
-        GF_OPTION_INIT ("readdir-optimize", conf->readdir_optimize, bool, err);
+    conf->dir_spread_cnt = conf->subvolume_cnt;
+    GF_OPTION_INIT("directory-layout-spread", conf->dir_spread_cnt, uint32,
+                   err);
 
+    GF_OPTION_INIT("assert-no-child-down", conf->assert_no_child_down, bool,
+                   err);
 
-        GF_OPTION_INIT ("lock-migration", conf->lock_migration_enabled,
-                         bool, err);
+    GF_OPTION_INIT("readdir-optimize", conf->readdir_optimize, bool, err);
 
-        if (defrag) {
-              defrag->lock_migration_enabled = conf->lock_migration_enabled;
+    GF_OPTION_INIT("lock-migration", conf->lock_migration_enabled, bool, err);
 
-              GF_OPTION_INIT ("rebalance-stats", defrag->stats, bool, err);
-                if (dict_get_str (this->options, "rebalance-filter", &temp_str)
-                    == 0) {
-                        if (gf_defrag_pattern_list_fill (this, defrag, temp_str)
-                            == -1) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INVALID_OPTION,
-                                        "Invalid option:"
-                                        " Cannot parse rebalance-filter (%s)",
-                                        temp_str);
+    GF_OPTION_INIT("force-migration", conf->force_migration, bool, err);
 
-                                goto err;
-                        }
-                }
-        }
+    if (defrag) {
+        defrag->lock_migration_enabled = conf->lock_migration_enabled;
 
-        /* option can be any one of percent or bytes */
-        conf->disk_unit = 0;
-        if (conf->min_free_disk < 100)
-                conf->disk_unit = 'p';
+        GF_OPTION_INIT("rebalance-stats", defrag->stats, bool, err);
+        if (dict_get_str(this->options, "rebalance-filter", &temp_str) == 0) {
+            if (gf_defrag_pattern_list_fill(this, defrag, temp_str) == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option:"
+                       " Cannot parse rebalance-filter (%s)",
+                       temp_str);
 
-        ret = dht_init_subvolumes (this, conf);
-        if (ret == -1) {
                 goto err;
+            }
         }
-
-        if (cmd) {
-                ret = dht_init_local_subvolumes (this, conf);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INIT_LOCAL_SUBVOL_FAILED,
-                                "dht_init_local_subvolumes failed");
-                        goto err;
-                }
+    }
+
+    /* option can be any one of percent or bytes */
+    conf->disk_unit = 0;
+    if (conf->min_free_disk < 100)
+        conf->disk_unit = 'p';
+
+    ret = dht_init_subvolumes(this, conf);
+    if (ret == -1) {
+        goto err;
+    }
+
+    if (cmd) {
+        ret = dht_init_local_subvolumes(this, conf);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_INIT_LOCAL_SUBVOL_FAILED,
+                   "dht_init_local_subvolumes failed");
+            goto err;
         }
-
-        if (dict_get_str (this->options, "decommissioned-bricks", &temp_str) == 0) {
-                ret = dht_parse_decommissioned_bricks (this, conf, temp_str);
-                if (ret == -1)
-                        goto err;
-        }
-
-        dht_init_regex (this, this->options, "rsync-hash-regex",
-                        &conf->rsync_regex, &conf->rsync_regex_valid, conf);
-        dht_init_regex (this, this->options, "extra-hash-regex",
-                        &conf->extra_regex, &conf->extra_regex_valid, conf);
-
-        ret = dht_layouts_init (this, conf);
-        if (ret == -1) {
-                goto err;
-        }
-
-
-        conf->gen = 1;
-
-        this->local_pool = mem_pool_new (dht_local_t, 512);
-        if (!this->local_pool) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY,
-                        " DHT initialisation failed. "
-                        "failed to create local_t's memory pool");
+    }
+
+    if (dict_get_str(this->options, "decommissioned-bricks", &temp_str) == 0) {
+        ret = dht_parse_decommissioned_bricks(this, conf, temp_str);
+        if (ret == -1)
+            goto err;
+    }
+
+    dht_init_regex(this, this->options, "rsync-hash-regex", &conf->rsync_regex,
+                   &conf->rsync_regex_valid, conf);
+    dht_init_regex(this, this->options, "extra-hash-regex", &conf->extra_regex,
author	Krishnan Parthasarathi <kp@gluster.com>	2012-05-02 18:38:52 +0530
committer	Vijay Bellur <vijay@gluster.com>	2012-05-03 21:26:07 -0700
commit	5f48ad266195ec85171db48cf3dba83f98cbe728 (patch)
tree	f8a021a1e047272f2f3f546ea6c825771bbce2d5 /cli
parent	d88237faa6982c9f0beca65262a220becaacb096 (diff)